diff --git a/.python-version b/.python-version new file mode 100644 index 0000000..6324d40 --- /dev/null +++ b/.python-version @@ -0,0 +1 @@ +3.14 diff --git a/Makefile b/Makefile index c86a0a1..795318c 100644 --- a/Makefile +++ b/Makefile @@ -1,7 +1,8 @@ # Layer 1 + Layer 1.5 automation. The uv venv (built from the committed uv.lock) is the # reproducibility source of truth; every target runs inside it via `uv run`. -.PHONY: env env-neural env-mnist env-llm test layer1 layer2 neural mnist llm figures clean +.PHONY: env env-neural env-mnist env-llm env-notebooks test layer1 layer2 neural mnist llm \ + llm-epistasis llm-society figures paper-figures notebooks clean env: ## build .venv from the committed lockfile uv sync --extra dev @@ -27,6 +28,7 @@ mnist: ## run the torchvision tiers: MNIST collapse + E13 real-weigh uv run python -m neural.experiment configs/neural/speciation_real.yaml uv run python -m neural.experiment configs/neural/speciation_real_cliff.yaml uv run python -m neural.experiment configs/neural/speciation_real_emergent.yaml + MPLBACKEND=Agg uv run python figures/mnist_montage.py # the asset paper Fig. 2B embeds env-llm: ## add the LLM stack for the Layer-2 prototype (GPU; transformers/peft) uv sync --extra dev --extra neural --extra llm @@ -40,6 +42,14 @@ llm-speciation: ## LLM-tier speciation: conflict cliff (replace + de-confound uv run python -m llm.experiment configs/llm/speciation.yaml uv run python -m llm.experiment configs/llm/speciation_add.yaml +llm-epistasis: ## the controlled predictive test (feeds paper Fig. 3C-D) + its robust statistics + uv run python -m llm.experiment configs/llm/epistasis.yaml + uv run python -m llm.experiment configs/llm/epistasis_compat.yaml + uv run python figures/stats_llm_epistasis.py + +llm-society: ## the composed society at LLM scale (C3): pilot; the campaign runs on HPC + uv run python -m llm.experiment configs/llm/society.yaml + llm-seeds: ## multi-seed firm-up (heavy): merge x5, moe-hard x3, directed-hard x3 uv run python -m llm.experiment configs/llm/merge_seeds.yaml uv run python -m llm.experiment configs/llm/moe_hard_seeds.yaml @@ -47,11 +57,22 @@ llm-seeds: ## multi-seed firm-up (heavy): merge x5, moe-hard x3, directe layer2: neural ## alias: Layer 1.5 is the current Layer-2 deliverable (LLM rung deferred) -figures: ## regenerate figures from committed results +figures: ## regenerate per-experiment figures from committed results (pure; no re-simulation) for e in E1 E2 E3 E4 E5 E6; do MPLBACKEND=Agg uv run python figures/plot_$$e.py; done for p in figures/plot_*.py; do case "$$p" in */plot_E[1-6].py|*/_*) ;; \ *) [ -e "$$p" ] && MPLBACKEND=Agg uv run python "$$p" ;; esac; done +paper-figures: ## regenerate the manuscript figures (Fig. 1-7) and rebuild the PDF body + MPLBACKEND=Agg uv run python paper/pnas/make_figs.py + uv run python paper/pnas/build.py + +env-notebooks: ## add Jupyter for the walkthrough notebooks + uv sync --extra dev --extra notebooks + +notebooks: ## execute every notebook end-to-end (a reproduction check in itself) + for nb in notebooks/*.ipynb; do uv run jupyter nbconvert --to notebook --execute \ + --inplace --ExecutePreprocessor.timeout=1800 "$$nb"; done + clean: ## remove caches and generated results (keeps committed manifests) rm -rf .pytest_cache **/__pycache__ find results -type f ! -name '.gitkeep' -delete 2>/dev/null || true diff --git a/README.md b/README.md index 9fcc155..cce3d79 100644 --- a/README.md +++ b/README.md @@ -1,39 +1,88 @@ -# The Lamarckian Society — Layer 1 (analytical core) +# The evolution of sex for artificial intelligence -A parametric population-genetics model of knowledge transmission across generations of -learning agents. Knowledge transmission is modelled *literally* as a Wright–Fisher -process (not by analogy): a model's knowledge is a distribution `p_t` over `K` discrete -items; a fixed true distribution `p*` has a rare tail; each generational step is -"sample from the parent (drift) + mix in fresh real samples (grounding/immigration) + -refit." Model collapse is the loss of rare alleles under drift. +A population-genetic framework for multigenerational model populations. Knowledge transmission +between generations of learning agents is modelled *literally* as a Wright–Fisher process, not by +analogy: a model's knowledge is a distribution `p_t` over `K` discrete items, a fixed true +distribution `p*` has a rare tail, and each generational step is "sample from the parent (drift) + +mix in fresh real samples (grounding/immigration) + refit". Model collapse is the loss of rare +alleles under drift — and the remedies population genetics knows for drift (immigration, +recombination, selection, population structure) become engineering levers for model populations. -See `paper/blueprint.md` (the normative build spec), -`paper/the-lamarckian-society-v5.md` (the perspective paper), and -`paper/results-summary.md` (a summary of all results). +The framework is developed at three tiers of increasing realism: + +| Tier | What it is | Hardware | +|---|---|---| +| **Biological model** | Wright–Fisher simulator over knowledge distributions; closed forms, bitwise reproducible | laptop | +| **Trained networks** | RNN / MLP / VAE on a synthetic mode universe with an exact oracle; convolutional VAE on MNIST | one GPU | +| **Language models** | LoRA specialists on Qwen2.5-Instruct (0.5B / 7B) with an exact-match verifier | one GPU / L40S | ## Reproduce -Environment is a `uv` venv built from the committed, hash-pinned `uv.lock` — that -lockfile is the single source of truth for "it runs" (Layer 1 is pure NumPy/SciPy and -bitwise-reproducible from a seed; no container needed). +**Start here: [`REPRODUCING.md`](REPRODUCING.md)** — the authoritative map from every manuscript +figure panel back to the artifact, config, and seed that produced it, plus the determinism policy +and artifact-hash verification. ```bash -# one-time: install uv (https://astral.sh/uv) -curl -LsSf https://astral.sh/uv/install.sh | sh +curl -LsSf https://astral.sh/uv/install.sh | sh # one-time, if needed -uv sync # build .venv from uv.lock -make test # correctness + scientific-validation tests (the spine of trust) -make layer1 # run experiments E1–E6 -make figures # regenerate figures from committed results +./reproduce.sh # env -> tests -> biological-model tier at committed seeds -> figures +./reproduce.sh --with-gpu # ... and the trained-network + language-model tiers ``` +Or tier by tier: + +```bash +make env # build .venv from the committed, hash-pinned uv.lock +make test # correctness + closed-form scientific validation (the spine of trust) +make layer1 # the biological model: E1-E12, E14, learning kernel +make figures # per-experiment figures, from committed parquets (no re-simulation) +make paper-figures # the manuscript's Fig. 1-7 + rebuild the PDF body +``` + +`make help` is not defined, but every target carries a `##` description — `grep '##' Makefile`. + +## Notebooks + +```bash +make env-notebooks && jupyter lab notebooks/ +``` + +- `01_biological_model.ipynb` — builds the Wright–Fisher model from scratch, checks it against the + closed forms (geometric diversity decay, the immigration–drift equilibrium), and derives the + grounding threshold and its per-item observation floor. Runs on a laptop in under a minute. +- `02_paper_figures.ipynb` — verifies artifact hashes, then regenerates and displays every + manuscript figure from the committed artifacts. + ## Layout ``` -src/knowledge/ Layer 1 package (imported as `knowledge`) -configs/layer1/ one YAML per experiment (E1..E6) -figures/ plot_EX.py — read results.parquet only -tests/ test_correctness.py + test_scientific_validation.py (analytic checks) -paper/ blueprint.md, perspective paper, figure_manifest.md -results/ written artifacts (gitignored; hashes tracked in manifest.json) +src/knowledge/ biological-model tier (imported as `knowledge`) +src/neural/ trained-network tier +src/llm/ language-model tier +configs/ one YAML per experiment: layer1/ neural/ llm/ (each declares its master seed) +figures/ plot_*.py — per-experiment diagnostics, read results.parquet only +paper/pnas/ the manuscript: main.md, make_figs.py (Fig. 1-7), build.py, si.md +notebooks/ executable walkthroughs +hpc/ PBS job scripts for the 7B tier (Imperial CX3) +tests/ correctness + test_scientific_validation.py (the closed forms as assertions) +results/ run artifacts: results.parquet (gitignored) + resolved_config.yaml + manifest.json ``` + +Design documents: `paper/blueprint.md` (the normative build spec) and `paper/results-summary.md` +(plain-language + technical summary of every result). + +## The engineering contract + +- **Reproducibility is a requirement, not a preference.** The environment is a `uv` venv built from + a committed, hash-pinned `uv.lock`; the biological-model tier is bitwise reproducible from a + single master seed, and the GPU tiers are statistically reproducible with per-seed points + reported. +- **One master seed per config**, with all sub-randomness derived via `SeedSequence.spawn`. No code + touches global RNG state; a run is a pure function of its resolved config. +- **No magic numbers in code.** Every parameter lives in a YAML resolved at run time, and the + resolved config is written next to the results. +- **Every run writes the same triple:** `results.parquet` + `resolved_config.yaml` + + `manifest.json` (seed, git commit, library versions, row count, SHA-256 of the results). +- **Every figure is a pure function of a committed artifact** — figure scripts never re-simulate. +- **The scientific-validation tests are the spine of trust.** They assert that the simulator + reproduces the closed forms to within 0.5%. If they fail, the science is wrong, not just the code. diff --git a/REPRODUCING.md b/REPRODUCING.md new file mode 100644 index 0000000..c442415 --- /dev/null +++ b/REPRODUCING.md @@ -0,0 +1,201 @@ +# Reproducing every number and figure in the paper + +This document is the authoritative map from the manuscript back to the code, configs, and seeds +that produced it. Every figure panel, every headline number, and the environment they were computed +in are listed below. If something in the paper is not traceable through this document, that is a +bug — please open an issue. + +Manuscript: `paper/pnas/main.md` (built to `paper/pnas/main.pdf`). + +--- + +## 1. The three tiers, and what each costs to reproduce + +| Tier | What it is | Hardware | Determinism | +|---|---|---|---| +| Biological model | Wright–Fisher simulator over knowledge distributions (pure NumPy/SciPy) | Any laptop, no GPU | **Bitwise** from the master seed | +| Trained networks | RNN / MLP / VAE on a synthetic mode universe; convolutional VAE on MNIST | One consumer GPU (16 GB) | Statistical (GPU non-determinism documented in §5) | +| Language models | LoRA specialists on Qwen2.5-Instruct 0.5B / 7B | 0.5B: one 16 GB GPU · 7B: one L40S (46 GB) | Statistical; per-seed points reported | + +The biological-model tier carries every quantitative claim in the paper and reproduces exactly on a +laptop in minutes. The two AI tiers are confirmatory (signs, not magnitudes) and need a GPU. + +## 2. Environment + +The environment is a `uv` venv built from the committed, hash-pinned `uv.lock`. That lockfile — not +a container, not a requirements file — is the single source of truth for "it runs". + +```bash +curl -LsSf https://astral.sh/uv/install.sh | sh # one-time, if you don't have uv + +make env # biological-model tier (pure NumPy/SciPy) +make env-neural # + torch, for the trained-network tier +make env-mnist # + torchvision, for the real-MNIST tier +make env-llm # + transformers/peft, for the language-model tier +make env-notebooks # + Jupyter, for the walkthrough notebooks +``` + +## 3. One command + +```bash +./reproduce.sh +``` + +runs the environment build, the test suite (including the closed-form scientific-validation tests), +the entire biological-model tier at its committed seeds, every figure, and writes `REPRODUCED.md` +with the resulting artifact hashes for comparison against the committed manifests. It deliberately +stops at the GPU tiers; pass `--with-gpu` to include them if you have the hardware. + +Tier by tier, by hand: + +```bash +make test # correctness + closed-form scientific validation +make layer1 # the biological model: E1-E12, E14, learning kernel +make neural # trained networks (needs a GPU) +make mnist # real-MNIST tier + the Fig. 2B montage asset (needs torchvision) +make llm # language-model prototypes (needs a GPU) +make llm-seeds # the multi-seed firm-ups behind Fig. 3A +make llm-epistasis # the controlled predictive test behind Fig. 3C-D +make llm-speciation # the LLM speciation tier behind Fig. 7E-F +make figures # per-experiment figures, from committed parquets (no re-simulation) +make paper-figures # the manuscript figures Fig. 1-7 + rebuild the PDF body +``` + +## 4. The figure map + +Every manuscript panel, the artifact it is plotted from, the config that produced that artifact, and +that config's declared seed. All panels are drawn by `paper/pnas/make_figs.py` (function per figure); +`make paper-figures` regenerates all of them. Figures are a **pure function of committed artifacts** — +no panel re-simulates anything, with the single documented exception of the Fig. 2B montage asset. + +| Panel | Drawn by | From artifact | Produced by config | Seed(s) | +|---|---|---|---|---| +| Fig. 1A, 1B | `fig1a()`, `fig1b()` | — (schematics; icons in `paper/pnas/figs/icons/`) | — | — | +| Fig. 2A | `fig2()` | `results/E2/` | `configs/layer1/E2.yaml` | 20260704 | +| Fig. 2B | `fig2()` | `results/mnist_collapse/mnist_montage.png` | `configs/neural/mnist_collapse.yaml` → asset from `figures/mnist_montage.py` | 20260705 | +| Fig. 3A | `fig3()` | `results/llm_merge_seeds/` | `configs/llm/merge_seeds.yaml` | 1, 2, 3, 4, 5 | +| Fig. 3B | `fig3()` | `results/llm_moe_hard_hpc/` | `configs/llm/moe_hard_hpc.yaml` (7B, HPC) | 1 (single run) | +| Fig. 3C, 3D | `fig3()` | `results/llm_epistasis/` + `results/llm_epistasis_compat/` | `configs/llm/epistasis.yaml`, `configs/llm/epistasis_compat.yaml` | 1, 2, 3 | +| Fig. 4A | `fig4()` | `results/E4/` | `configs/layer1/E4.yaml` | 20260704 | +| Fig. 4B | `fig4()` | `results/E8/` | `configs/layer1/E8.yaml` | 20260705 | +| Fig. 5A | `fig5()` | `results/E9/` | `configs/layer1/E9.yaml` | 20260705 | +| Fig. 5B | `fig5()` | `results/E10/` | `configs/layer1/E10.yaml` | 20260705 | +| Fig. 5C, 5D | `fig5()` | `results/E14/` | `configs/layer1/E14.yaml` | 20260709 | +| Fig. 6A, 6B, 6C | `fig6()` | `results/E11/` | `configs/layer1/E11.yaml` | 20260705 | +| Fig. 7A, 7B | `fig7()` | `results/E12/` | `configs/layer1/E12.yaml` | 12 | +| Fig. 7C | `fig7()` | `results/speciation_real/` | `configs/neural/speciation_real.yaml` | 13 | +| Fig. 7D | `fig7()` | `results/speciation_real_cliff/` | `configs/neural/speciation_real_cliff.yaml` | 13 | +| Fig. 7E, 7F | `fig7()` | `results/llm_speciation/` | `configs/llm/speciation.yaml` | 1 (single seed) | + +**Single-run panels.** Fig. 3B and Fig. 7E–F come from single-seed runs and are reported as +sign-level confirmations, not estimates; the manuscript labels them as such. Every other panel is +replicated (biological-model panels over 12–100 internal replicates; Fig. 3A over five training +seeds; Fig. 3C–D over three). + +### Results reported in the text but not plotted in the manuscript + +| Result | Artifact | Config | Seed | +|---|---|---|---| +| Collapse null (E1) | `results/E1/` | `configs/layer1/E1.yaml` | 20260704 | +| Region-matched grounding (E3) | `results/E3/` | `configs/layer1/E3.yaml` | 20260704 | +| Quality-diversity vs greedy (E5) | `results/E5/` | `configs/layer1/E5.yaml` | 20260704 | +| Re-minting / irreversibility (E6) | `results/E6/` | `configs/layer1/E6.yaml` | 20260704 | +| Advantage of sex, lineage (E7) | `results/E7/` | `configs/layer1/E7.yaml` | 20260705 | +| Incompatibilities on NK (E12_nk) | `results/E12_nk/` | `configs/layer1/E12_nk.yaml` | 12 | +| Learning kernel (estimator bias) | `results/kernel_sharpen/`, `results/kernel_smooth/` | `configs/layer1/kernel_{sharpen,smooth}.yaml` | 20260705 | +| Histogram bridge gate | `results/bridge/` | `configs/neural/bridge.yaml` | 20260704 | +| Neural collapse / grounding / architectures / recombination | `results/{collapse,grounding,architectures,recombination}/` | `configs/neural/*.yaml` | 20260704 | +| Emergent-isolation null | `results/speciation_real_emergent/` | `configs/neural/speciation_real_emergent.yaml` | 813 | +| Budget-controlled speciation (add design) | `results/llm_speciation_add/` | `configs/llm/speciation_add.yaml` | 1, 2, 3 | +| LLM prototypes (0.5B) | `results/llm_{merge,moe,directed}/` | `configs/llm/{merge,moe,directed}.yaml` | 1 | +| 7B firm-ups | `results/llm_*_hpc/` | `configs/llm/*_hpc.yaml` (run via `hpc/*.pbs`) | 1 | + +### Per-experiment (exploratory) figures + +`figures/plot_*.py` regenerate a diagnostic figure **inside each results bundle** +(`results//.pdf`), named after the experiment, not after a manuscript figure. They are +the working views, not the manuscript's; the table above is the authority on what appears in the +paper. `figures/stats_llm_epistasis.py` prints the robust statistics quoted in the predictive-test +section (clustered bootstrap, paired contrasts, leave-one-condition-out, outcome-reference +sensitivity). + +## 5. Seeds and determinism + +**Policy.** One master seed per config. All sub-randomness is derived from it via +`numpy.random.SeedSequence.spawn` (`src/knowledge/seeding.py`); no code touches global RNG state, and +every `rng` is passed explicitly. A run is a pure function of its resolved config. + +**Biological-model tier: bitwise reproducible.** Re-running a config on the same lockfile +reproduces its `results.parquet` byte-for-byte; the `results_sha256` in each `manifest.json` is the +check. + +**GPU tiers: statistically reproducible.** cuDNN kernel selection and reduction order make bitwise +equality unattainable across machines. Per-seed points are reported rather than seed-averaged +summaries alone, and the multi-seed protocols fix the evaluation sets and vary only the training +seed. Expect sign agreement and magnitudes within noise, not identical digits. + +**Seed provenance.** `20260704`/`20260705`/`20260709` are date-stamped master seeds chosen at the +time each experiment was written and never re-drawn. Small integer seeds (`1`, `12`, `13`, `813`) +are likewise fixed at authoring time. No seed in this repository was selected after seeing results. + +## 6. Verifying artifact integrity + +Every run writes three files next to its results: + +- `results.parquet` — the long-form data (the only thing figures read) +- `resolved_config.yaml` — the config **after** sweep expansion, i.e. exactly what ran +- `manifest.json` — master seed, git commit, Python and library versions, row count, and + `results_sha256` (the content hash of the parquet) + +To verify a bundle you have regenerated matches the one behind the paper: + +```bash +python - <<'EOF' +import hashlib, json, pathlib +for m in sorted(pathlib.Path("results").glob("*/manifest.json")): + man = json.loads(m.read_text()) + pq = m.parent / "results.parquet" + if not pq.exists(): + print(f"{m.parent.name:28s} (no parquet — run its config first)"); continue + got = hashlib.sha256(pq.read_bytes()).hexdigest() + ok = "OK " if got == man.get("results_sha256") else "DIFF" + print(f"{ok} {m.parent.name:28s} seed={man.get('master_seed')}") +EOF +``` + +`DIFF` on a biological-model bundle means a genuine discrepancy worth investigating. `DIFF` on a GPU +tier is expected (see §5) — compare the figures and the reported statistics instead. + +## 7. HPC (the 7B tier) + +The 7B runs were executed on Imperial College's CX3 cluster (PBS Pro, one L40S 46 GB per job). Job +scripts are in `hpc/`; each is self-contained and documents its own submission line. They stage the +same `uv.lock` environment, so the only difference from a local run is the GPU. + +```bash +qsub hpc/llm_merge.pbs # 7B merge firm-up +qsub hpc/llm_hard.pbs # hard-benchmark moe + directed at 7B +qsub hpc/llm_society.pbs # the society campaign (array over seeds) +``` + +## 8. Notebooks + +`notebooks/` contains executable walkthroughs (`make env-notebooks`, then `jupyter lab`): + +| Notebook | What it does | Needs | +|---|---|---| +| `01_biological_model.ipynb` | Builds the Wright–Fisher model from scratch, checks it against the three closed forms, and derives the grounding threshold interactively | Laptop | +| `02_paper_figures.ipynb` | Regenerates every manuscript figure from the committed artifacts and displays them inline, panel by panel | Laptop (artifacts must be present) | + +`make notebooks` executes both end-to-end, which is itself a reproduction check. + +## 9. Known gaps + +- `results/**/results.parquet` is currently **gitignored** (only manifests, hashes, and resolved + configs are tracked). A fresh clone therefore has to re-run the experiments before figures can be + regenerated. The archived deposit (Zenodo DOI, on publication) includes the parquets so that the + paper's "regenerates from committed artifacts without re-simulation" holds from the archive. +- `figures/mnist_montage.py` re-runs a short dry lineage to draw its montage rather than reading a + parquet; it is an eyeball diagnostic whose quantitative counterpart is `results/mnist_collapse/`. +- The composed society at language-model scale is an open experiment at the time of writing; see + `tasks/workorder-llm-society.md`. diff --git a/notebooks/01_biological_model.ipynb b/notebooks/01_biological_model.ipynb new file mode 100644 index 0000000..16375d1 --- /dev/null +++ b/notebooks/01_biological_model.ipynb @@ -0,0 +1,489 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "26f42fa9", + "metadata": {}, + "source": [ + "# 1 — The biological model, from scratch\n", + "\n", + "This notebook builds the paper's biological model in the open and checks it against the three\n", + "closed forms it is required to reproduce. Everything here is pure NumPy/SciPy: it runs on a\n", + "laptop in under a minute and needs no GPU.\n", + "\n", + "The claim being demonstrated is the one the whole paper rests on: **knowledge transmission\n", + "between model generations is a Wright–Fisher process**, not merely something that resembles one.\n", + "\n", + "Companion: `REPRODUCING.md` (the figure-by-figure map) and `tests/test_scientific_validation.py`\n", + "(the same checks as assertions with publication tolerances)." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "4e02e4f2", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-07T14:39:33.085488Z", + "iopub.status.busy": "2026-09-07T14:39:33.085304Z", + "iopub.status.idle": "2026-09-07T14:39:33.637432Z", + "shell.execute_reply": "2026-09-07T14:39:33.636220Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ready\n" + ] + } + ], + "source": [ + "import sys, pathlib\n", + "sys.path.insert(0, str(pathlib.Path.cwd().parent / 'src'))\n", + "\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from knowledge.lineage import run_lineage\n", + "from knowledge.metrics import heterozygosity\n", + "from knowledge.truth import make_true_distribution\n", + "\n", + "K, N_SAMPLES = 200, 100 # K items of knowledge; n samples drawn per generation\n", + "print('ready')" + ] + }, + { + "cell_type": "markdown", + "id": "eca5c488", + "metadata": {}, + "source": [ + "## Knowledge as an allele-frequency distribution\n", + "\n", + "A model's knowledge is a distribution `p` over `K` discrete items (capabilities, facts, modes of\n", + "behaviour). Reality is a fixed distribution `p*` with a Zipf tail: a few things are common, most\n", + "are rare. In population-genetics terms `p` is a vector of allele frequencies at one locus with\n", + "`K` alleles, and the rare tail is what drift destroys first.\n", + "\n", + "Diversity is **heterozygosity**, `H = 1 − Σ pᵢ²` — the probability that two random draws differ." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "6afb0adf", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-07T14:39:33.640226Z", + "iopub.status.busy": "2026-09-07T14:39:33.639948Z", + "iopub.status.idle": "2026-09-07T14:39:34.167745Z", + "shell.execute_reply": "2026-09-07T14:39:34.166324Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "H* (diversity of reality) = 0.9326\n", + "tail items (rare knowledge) = 70 of 200\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "td = make_true_distribution(K, 1, 'zipf', 0.5, 1.1, 0, tail_threshold=1e-3)\n", + "p_star = td.p_star\n", + "H_star = heterozygosity(p_star)\n", + "\n", + "print(f'H* (diversity of reality) = {H_star:.4f}')\n", + "print(f'tail items (rare knowledge) = {int(td.tail_mask.sum())} of {K}')\n", + "\n", + "fig, ax = plt.subplots(figsize=(6, 3))\n", + "ax.loglog(np.arange(1, K + 1), np.sort(p_star)[::-1], '.')\n", + "ax.set(xlabel='item rank', ylabel='probability $p^*_i$', title='reality has a heavy tail')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "045375e5", + "metadata": {}, + "source": [ + "## One generation is a Wright–Fisher step\n", + "\n", + "A generation is: *draw `n` samples from the parent's distribution, optionally mix in `m` verified\n", + "real samples, refit the child*. With `m = 0` that resampling step **is** the Wright–Fisher\n", + "process — the textbook model of neutral evolution in a finite population of size `n`.\n", + "\n", + "The config below is the same schema the experiments use, so anything you learn here transfers\n", + "directly to `configs/layer1/*.yaml`." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "79caa8e6", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-07T14:39:34.170068Z", + "iopub.status.busy": "2026-09-07T14:39:34.169950Z", + "iopub.status.idle": "2026-09-07T14:39:34.203294Z", + "shell.execute_reply": "2026-09-07T14:39:34.202249Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
generationheterozygositytail_masssupport_size
000.9325570.054961200
50500.6148000.0000004
1001000.4982000.0000002
1501500.4950000.0000002
2002000.1302000.0000002
\n", + "
" + ], + "text/plain": [ + " generation heterozygosity tail_mass support_size\n", + "0 0 0.932557 0.054961 200\n", + "50 50 0.614800 0.000000 4\n", + "100 100 0.498200 0.000000 2\n", + "150 150 0.495000 0.000000 2\n", + "200 200 0.130200 0.000000 2" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def cfg(m=0, generations=200, n=N_SAMPLES):\n", + " \"\"\"A lineage config: m = real samples mixed in per generation (m=0 is the dry null).\"\"\"\n", + " return {\n", + " 'truth': {'K': K, 'R': 1, 'tail': 'zipf', 'zipf_s': 1.1, 'tail_frac': 0.5,\n", + " 'tail_threshold': 1e-3, 'init': 'truth'},\n", + " 'dynamics': {'n': n,\n", + " 'teachers': {'K_T': 1, 'rho': 0.0, 'q': 1.0},\n", + " 'grounding': {'m': m, 'policy': 'proportional'},\n", + " 'selection': {'mode': 'none', 'novelty_alpha': 0.0},\n", + " 'remint': {'enabled': False, 'period': None, 'H_gate': None}},\n", + " 'metrics': {'kl_floor': 1e-9, 'support_eps': 1e-9},\n", + " 'generations': generations,\n", + " }\n", + "\n", + "one = run_lineage(cfg(), seed=1) # a run is a pure function of (config, seed)\n", + "one[['generation', 'heterozygosity', 'tail_mass', 'support_size']].iloc[::50]" + ] + }, + { + "cell_type": "markdown", + "id": "1135a629", + "metadata": {}, + "source": [ + "## Closed form 1 — neutral diversity decays geometrically\n", + "\n", + "Wright–Fisher predicts that diversity decays at a rate set only by the sample size:\n", + "\n", + "$$\\mathbb{E}[H_t] = H_0\\left(1 - \\frac{1}{n}\\right)^t$$\n", + "\n", + "This is an *expectation*, so we average lineages. Drift has high variance, and the agreement\n", + "tightens as $\\sqrt{R}$ in the number of replicates." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "0074c5ea", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-07T14:39:34.205125Z", + "iopub.status.busy": "2026-09-07T14:39:34.205000Z", + "iopub.status.idle": "2026-09-07T14:39:38.029646Z", + "shell.execute_reply": "2026-09-07T14:39:38.028989Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "max relative deviation: 2.10%\n", + "(the publication-tolerance version of this check is a standing assertion in tests/test_scientific_validation.py)\n" + ] + } + ], + "source": [ + "R = 200\n", + "H = np.mean([run_lineage(cfg(), seed=s).heterozygosity.to_numpy() for s in range(R)], axis=0)\n", + "t = np.arange(len(H))\n", + "law = H[0] * (1 - 1 / N_SAMPLES) ** t\n", + "\n", + "fig, ax = plt.subplots(figsize=(6, 3.4))\n", + "ax.plot(t, H, label=f'simulation (mean of {R} lineages)')\n", + "ax.plot(t, law, 'k--', label=r'$H_0(1-1/n)^t$')\n", + "ax.set(xlabel='generation', ylabel='heterozygosity $H$')\n", + "ax.legend(); plt.show()\n", + "\n", + "print(f'max relative deviation: {np.abs(H - law).max() / law.max():.2%}')\n", + "print('(the publication-tolerance version of this check is a standing assertion in',\n", + " 'tests/test_scientific_validation.py)')" + ] + }, + { + "cell_type": "markdown", + "id": "874cfaaf", + "metadata": {}, + "source": [ + "**This is model collapse.** Diversity falls geometrically, the rare tail goes first, and the\n", + "lineage converges on its own most common behaviour. Nothing about language models is needed to\n", + "produce it — only the fact that each generation is a finite sample of the last." + ] + }, + { + "cell_type": "markdown", + "id": "34f43d83", + "metadata": {}, + "source": [ + "## Closed form 2 — grounding is immigration, and it has an equilibrium\n", + "\n", + "Now mix `m` verified real samples into each generation. In population genetics that is\n", + "**immigration** from a non-drifting source, and drift no longer wins: the population settles at a\n", + "non-zero equilibrium diversity\n", + "\n", + "$$H_{eq} = H^* \\cdot \\frac{m(2n + m - 1)}{n + 2nm + m^2}$$\n", + "\n", + "(The textbook $\\theta/(1+\\theta)$ is the rare-immigrant limit of this; the paper uses the exact\n", + "form for the implemented model.)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "44195b4d", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-07T14:39:38.033172Z", + "iopub.status.busy": "2026-09-07T14:39:38.032931Z", + "iopub.status.idle": "2026-09-07T14:39:44.881068Z", + "shell.execute_reply": "2026-09-07T14:39:44.880729Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "m= 0 g=0.000 simulated 0.0000 closed form 0.0000\n", + "m= 1 g=0.010 simulated 0.5855 closed form 0.6196\n", + "m= 2 g=0.020 simulated 0.7443 closed form 0.7438\n", + "m= 5 g=0.048 simulated 0.8485 closed form 0.8455\n", + "m= 10 g=0.091 simulated 0.8905 closed form 0.8859\n", + "m= 20 g=0.167 simulated 0.9057 closed form 0.9077\n", + "m= 50 g=0.333 simulated 0.9225 closed form 0.9215\n" + ] + } + ], + "source": [ + "def H_eq(m, n=N_SAMPLES):\n", + " return H_star * m * (2 * n + m - 1) / (n + 2 * n * m + m * m) if m > 0 else 0.0\n", + "\n", + "ms = [0, 1, 2, 5, 10, 20, 50]\n", + "sim = []\n", + "for m in ms:\n", + " tail = [run_lineage(cfg(m=m, generations=800), seed=100 + s)\n", + " .heterozygosity.to_numpy()[-200:].mean() for s in range(12)]\n", + " sim.append(np.mean(tail))\n", + "\n", + "g = np.array(ms) / (N_SAMPLES + np.array(ms))\n", + "grid = np.linspace(0, 50, 300)\n", + "\n", + "fig, ax = plt.subplots(figsize=(6, 3.4))\n", + "ax.plot(grid / (N_SAMPLES + grid), [H_eq(m) for m in grid], 'k--', label='closed form')\n", + "ax.plot(g, sim, 'o', label='simulation')\n", + "ax.axhline(H_star, ls=':', color='gray', label='$H^*$ (reality)')\n", + "ax.set(xlabel='grounding fraction $g = m/(n+m)$', ylabel='stationary $H$')\n", + "ax.legend(); plt.show()\n", + "\n", + "for m, s in zip(ms, sim):\n", + " print(f'm={m:3d} g={m/(N_SAMPLES+m):.3f} simulated {s:.4f} closed form {H_eq(m):.4f}')" + ] + }, + { + "cell_type": "markdown", + "id": "3a30c1b0", + "metadata": {}, + "source": [ + "## The operational threshold, and the floor underneath it\n", + "\n", + "The equilibrium is **smooth** in `g` — there is no phase transition in aggregate diversity, and\n", + "the paper is careful to say so. What there *is* is an operational threshold: the grounding\n", + "fraction that retains a chosen share of reality's diversity. A few percent buys most of it.\n", + "\n", + "But averages hide the thing that matters. A capability of rarity `p` appears in a real-data batch\n", + "of size `m` with probability $1 - e^{-mp}$, so protecting the rarest knowledge is priced\n", + "*per item* at $m \\sim 1/p$ — the floor no amount of average-case grounding removes." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "180153fd", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-07T14:39:44.884947Z", + "iopub.status.busy": "2026-09-07T14:39:44.884827Z", + "iopub.status.idle": "2026-09-07T14:39:44.887903Z", + "shell.execute_reply": "2026-09-07T14:39:44.887436Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "first swept point retaining 95% of H*: g = 0.091 (m = 10)\n", + "the paper reports g ~ 0.05 for its tested setting; see results/E2 and Fig. 2A\n", + "\n", + "common item (p=1e-02): seen once per batch at m ~ 100 -> P(seen | m=1000) = 100.0%\n", + "rare item (p=1e-03): seen once per batch at m ~ 1,000 -> P(seen | m=1000) = 63.2%\n", + "very rare item (p=1e-04): seen once per batch at m ~ 10,000 -> P(seen | m=1000) = 9.5%\n" + ] + } + ], + "source": [ + "target = 0.95\n", + "i = int(np.argmax(np.array(sim) >= target * H_star))\n", + "print(f'first swept point retaining {target:.0%} of H*: g = {g[i]:.3f} (m = {ms[i]})')\n", + "print('the paper reports g ~ 0.05 for its tested setting; see results/E2 and Fig. 2A\\n')\n", + "\n", + "for p, label in [(1e-2, 'common'), (1e-3, 'rare'), (1e-4, 'very rare')]:\n", + " need = 1 / p\n", + " print(f'{label:10s} item (p={p:.0e}): seen once per batch at m ~ {need:,.0f}'\n", + " f' -> P(seen | m=1000) = {1 - np.exp(-1000 * p):.1%}')" + ] + }, + { + "cell_type": "markdown", + "id": "2fbabda7", + "metadata": {}, + "source": [ + "## Where to go next\n", + "\n", + "- `02_paper_figures.ipynb` — regenerate every manuscript figure from the committed artifacts.\n", + "- `configs/layer1/E2.yaml` — the full grounding sweep this notebook miniaturises (Fig. 2A).\n", + "- `REPRODUCING.md` — the map from each paper panel to its config and seed.\n", + "- `tests/test_scientific_validation.py` — these same identities as assertions; if they fail, the\n", + " science is wrong, not just the code." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.15" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/02_paper_figures.ipynb b/notebooks/02_paper_figures.ipynb new file mode 100644 index 0000000..56a2d86 --- /dev/null +++ b/notebooks/02_paper_figures.ipynb @@ -0,0 +1,565 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "c00", + "metadata": {}, + "source": [ + "# 2 — Every manuscript figure, from the committed artifacts\n", + "\n", + "This notebook regenerates each figure in the paper and shows it inline, together with the\n", + "artifact, config, and seed behind it. Nothing here re-simulates: every panel is a pure function\n", + "of a committed `results//results.parquet`.\n", + "\n", + "Prerequisite: the results bundles must be present (they ship with the archived deposit; from a\n", + "bare git clone, run `make layer1` first — see `REPRODUCING.md`)." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "c01", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-07T14:40:29.761107Z", + "iopub.status.busy": "2026-09-07T14:40:29.760984Z", + "iopub.status.idle": "2026-09-07T14:40:30.319301Z", + "shell.execute_reply": "2026-09-07T14:40:30.318182Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "figure functions: ['fig1a', 'fig1b', 'fig2', 'fig3', 'fig4', 'fig5', 'fig6', 'fig7']\n" + ] + } + ], + "source": [ + "import sys, pathlib, json, hashlib\n", + "\n", + "ROOT = pathlib.Path.cwd().parent\n", + "sys.path.insert(0, str(ROOT / 'paper' / 'pnas'))\n", + "\n", + "import make_figs # note: importing this chdir's to the repo root, by design\n", + "from IPython.display import IFrame, display, Markdown\n", + "\n", + "print('figure functions:', [f for f in dir(make_figs) if f.startswith('fig')])" + ] + }, + { + "cell_type": "markdown", + "id": "c02", + "metadata": {}, + "source": [ + "## The provenance table\n", + "\n", + "Each manuscript panel, the artifact it reads, the config that produced that artifact, and that\n", + "config's declared seed. This is the same table as `REPRODUCING.md` section 4, kept here so the\n", + "notebook is self-contained." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "c03", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-07T14:40:30.321586Z", + "iopub.status.busy": "2026-09-07T14:40:30.321362Z", + "iopub.status.idle": "2026-09-07T14:40:30.327799Z", + "shell.execute_reply": "2026-09-07T14:40:30.327111Z" + } + }, + "outputs": [ + { + "data": { + "text/markdown": [ + "| Panel | Artifact | Config | Seed(s) |\n", + "|---|---|---|---|\n", + "| Fig. 1A/1B | `schematics (no data)` | `-` | - |\n", + "| Fig. 2A | `results/E2` | `configs/layer1/E2.yaml` | 20260704 |\n", + "| Fig. 2B | `results/mnist_collapse` | `configs/neural/mnist_collapse.yaml` | 20260705 |\n", + "| Fig. 3A | `results/llm_merge_seeds` | `configs/llm/merge_seeds.yaml` | 1-5 |\n", + "| Fig. 3B | `results/llm_moe_hard_hpc` | `configs/llm/moe_hard_hpc.yaml` | 1 |\n", + "| Fig. 3C/3D | `results/llm_epistasis(_compat)` | `configs/llm/epistasis*.yaml` | 1-3 |\n", + "| Fig. 4A | `results/E4` | `configs/layer1/E4.yaml` | 20260704 |\n", + "| Fig. 4B | `results/E8` | `configs/layer1/E8.yaml` | 20260705 |\n", + "| Fig. 5A | `results/E9` | `configs/layer1/E9.yaml` | 20260705 |\n", + "| Fig. 5B | `results/E10` | `configs/layer1/E10.yaml` | 20260705 |\n", + "| Fig. 5C/5D | `results/E14` | `configs/layer1/E14.yaml` | 20260709 |\n", + "| Fig. 6A-C | `results/E11` | `configs/layer1/E11.yaml` | 20260705 |\n", + "| Fig. 7A/7B | `results/E12` | `configs/layer1/E12.yaml` | 12 |\n", + "| Fig. 7C | `results/speciation_real` | `configs/neural/speciation_real.yaml` | 13 |\n", + "| Fig. 7D | `results/speciation_real_cliff` | `configs/neural/speciation_real_cliff.yaml` | 13 |\n", + "| Fig. 7E/7F | `results/llm_speciation` | `configs/llm/speciation.yaml` | 1 |" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "PROVENANCE = [\n", + " ('Fig. 1A/1B', 'schematics (no data)', '-', '-'),\n", + " ('Fig. 2A', 'results/E2', 'configs/layer1/E2.yaml', '20260704'),\n", + " ('Fig. 2B', 'results/mnist_collapse', 'configs/neural/mnist_collapse.yaml', '20260705'),\n", + " ('Fig. 3A', 'results/llm_merge_seeds', 'configs/llm/merge_seeds.yaml', '1-5'),\n", + " ('Fig. 3B', 'results/llm_moe_hard_hpc', 'configs/llm/moe_hard_hpc.yaml', '1'),\n", + " ('Fig. 3C/3D', 'results/llm_epistasis(_compat)', 'configs/llm/epistasis*.yaml', '1-3'),\n", + " ('Fig. 4A', 'results/E4', 'configs/layer1/E4.yaml', '20260704'),\n", + " ('Fig. 4B', 'results/E8', 'configs/layer1/E8.yaml', '20260705'),\n", + " ('Fig. 5A', 'results/E9', 'configs/layer1/E9.yaml', '20260705'),\n", + " ('Fig. 5B', 'results/E10', 'configs/layer1/E10.yaml', '20260705'),\n", + " ('Fig. 5C/5D', 'results/E14', 'configs/layer1/E14.yaml', '20260709'),\n", + " ('Fig. 6A-C', 'results/E11', 'configs/layer1/E11.yaml', '20260705'),\n", + " ('Fig. 7A/7B', 'results/E12', 'configs/layer1/E12.yaml', '12'),\n", + " ('Fig. 7C', 'results/speciation_real', 'configs/neural/speciation_real.yaml','13'),\n", + " ('Fig. 7D', 'results/speciation_real_cliff','configs/neural/speciation_real_cliff.yaml','13'),\n", + " ('Fig. 7E/7F', 'results/llm_speciation', 'configs/llm/speciation.yaml', '1'),\n", + "]\n", + "\n", + "rows = ['| Panel | Artifact | Config | Seed(s) |', '|---|---|---|---|']\n", + "rows += [f'| {p} | `{a}` | `{c}` | {s} |' for p, a, c, s in PROVENANCE]\n", + "display(Markdown('\\n'.join(rows)))" + ] + }, + { + "cell_type": "markdown", + "id": "c04", + "metadata": {}, + "source": [ + "## Artifact integrity\n", + "\n", + "Each bundle carries a `manifest.json` with the master seed, the git commit, library versions, and\n", + "a SHA-256 of its parquet. Before plotting anything, confirm the artifacts on disk are the ones\n", + "the paper was written from." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "c05", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-07T14:40:30.329337Z", + "iopub.status.busy": "2026-09-07T14:40:30.329129Z", + "iopub.status.idle": "2026-09-07T14:40:30.345342Z", + "shell.execute_reply": "2026-09-07T14:40:30.344242Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "E10 hash OK seed=20260705\n", + "E11 hash OK seed=20260705\n", + "E12 hash OK seed=12\n", + "E14 hash OK seed=20260709\n", + "E2 hash OK seed=20260704\n", + "E4 hash OK seed=20260704\n", + "E8 hash OK seed=20260705\n", + "E9 hash OK seed=20260705\n", + "llm_epistasis hash OK seed=1\n", + "llm_merge_seeds hash OK seed=1\n", + "llm_moe_hard_hpc hash OK seed=1\n", + "llm_speciation hash OK seed=1\n", + "mnist_collapse hash OK seed=20260705\n", + "speciation_real hash OK seed=13\n", + "speciation_real_cliff hash OK seed=13\n", + "\n", + "15 bundles verified\n" + ] + } + ], + "source": [ + "checked = 0\n", + "for name in sorted({a for _, a, _, _ in PROVENANCE if a.startswith('results/')}):\n", + " d = ROOT / name.split('(')[0]\n", + " man_p, pq = d / 'manifest.json', d / 'results.parquet'\n", + " if not man_p.exists():\n", + " print(f'{d.name:24s} MISSING bundle'); continue\n", + " man = json.loads(man_p.read_text())\n", + " if not pq.exists():\n", + " print(f'{d.name:24s} manifest only (run its config to regenerate the parquet)'); continue\n", + " ok = hashlib.sha256(pq.read_bytes()).hexdigest() == man.get('results_sha256')\n", + " print(f\"{d.name:24s} {'hash OK ' if ok else 'HASH DIFFERS'} seed={man.get('master_seed')}\")\n", + " checked += 1\n", + "print(f'\\n{checked} bundles verified')" + ] + }, + { + "cell_type": "markdown", + "id": "c06", + "metadata": {}, + "source": [ + "## Regenerate the figures\n", + "\n", + "One call per manuscript figure. Each writes `paper/pnas/figs/.pdf` — exactly the files the\n", + "manuscript includes, so a rebuilt PDF picks them up unchanged." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "c07", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-07T14:40:30.347139Z", + "iopub.status.busy": "2026-09-07T14:40:30.346995Z", + "iopub.status.idle": "2026-09-07T14:40:35.575082Z", + "shell.execute_reply": "2026-09-07T14:40:35.573430Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "wrote /home/gg/ownCloud/Work/Projects/LamarckianAI/paper/pnas/figs/fig1a.pdf\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "wrote /home/gg/ownCloud/Work/Projects/LamarckianAI/paper/pnas/figs/fig1b.pdf\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "wrote /home/gg/ownCloud/Work/Projects/LamarckianAI/paper/pnas/figs/fig2.pdf\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "wrote /home/gg/ownCloud/Work/Projects/LamarckianAI/paper/pnas/figs/fig3.pdf\n", + "wrote /home/gg/ownCloud/Work/Projects/LamarckianAI/paper/pnas/figs/fig4.pdf\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "wrote /home/gg/ownCloud/Work/Projects/LamarckianAI/paper/pnas/figs/fig5.pdf\n", + "wrote /home/gg/ownCloud/Work/Projects/LamarckianAI/paper/pnas/figs/fig6.pdf\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "wrote /home/gg/ownCloud/Work/Projects/LamarckianAI/paper/pnas/figs/fig7.pdf\n", + "\n", + "all manuscript figures regenerated into paper/pnas/figs/\n" + ] + } + ], + "source": [ + "FIGURES = [\n", + " ('fig1a', 'Fig. 1A — the experimental programme (schematic)'),\n", + " ('fig1b', 'Fig. 1B — society in space vs society in time (schematic)'),\n", + " ('fig2', 'Fig. 2 — grounding is immigration (A: equilibrium, B: MNIST collapse)'),\n", + " ('fig3', 'Fig. 3 — the language-model tier (A-D)'),\n", + " ('fig4', 'Fig. 4 — blending inheritance and the Fisher-Muller effect (A, B)'),\n", + " ('fig5', 'Fig. 5 — rugged landscapes: risk, remedy, population structure (A-D)'),\n", + " ('fig6', 'Fig. 6 — the composed society (A-C)'),\n", + " ('fig7', 'Fig. 7 — model speciation at three tiers (A-F)'),\n", + "]\n", + "\n", + "for name, caption in FIGURES:\n", + " getattr(make_figs, name)()\n", + "print('\\nall manuscript figures regenerated into paper/pnas/figs/')" + ] + }, + { + "cell_type": "markdown", + "id": "c08", + "metadata": {}, + "source": [ + "## Look at them\n", + "\n", + "Rendered inline from the regenerated PDFs, in manuscript order. These are the exact files\n", + "the manuscript includes — what you see here is what is in the paper." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "c09", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-07T14:40:35.578125Z", + "iopub.status.busy": "2026-09-07T14:40:35.577772Z", + "iopub.status.idle": "2026-09-07T14:40:36.989794Z", + "shell.execute_reply": "2026-09-07T14:40:36.989028Z" + } + }, + "outputs": [ + { + "data": { + "text/markdown": [ + "### Fig. 1A — the experimental programme (schematic)" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/markdown": [ + "### Fig. 1B — society in space vs society in time (schematic)" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/markdown": [ + "### Fig. 2 — grounding is immigration (A: equilibrium, B: MNIST collapse)" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/markdown": [ + "### Fig. 3 — the language-model tier (A-D)" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/markdown": [ + "### Fig. 4 — blending inheritance and the Fisher-Muller effect (A, B)" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA9gAAAGBCAIAAAASVo4wAAAACXBIWXMAABDqAAAQ6gGC0wqYAAAgAElEQVR42uzdfVxT5/k/8Ds1iiXBViQYFTWhSPEhgba2TKAVZ2RTnLrNHzPEuXaW19daxDm+HfVhKq7Ssv6YVah2L7R2rcTWX12lBV0VtWyCpbUtJhYppZIq1JSj0GpOKniQ3x+3np0mIYSnkIfP+w9fJ4c8nHPAO1fuXPd1iTo7OwkAAAAAALjXXbgEAAAAAAAIxAEAAAAAEIgDAAAAAAACcQAAAAAABOIAAAAAAIBAHAAAAAAAgTgAAAAAACAQBwAAAABAIA4AAAAAAISIe3RvlmWLi4v5m3PmzJHJZLiIAACezGQyVVZW2uxUqVRyuRxjOACA1wTi5eXlOp2Ov5mdnb1x40ZcRAAAT1ZZWSkcuoXUanVlZaVEIsFVAgBwv56lpmzbtk14c9euXRzH4SICAHgpg8Eg/J4TAAA8NBBnGKasrEy4x2w2V1VV4SICAHiLhoaGzs5Og8GgVqvpnszMTEypAAB4eiD+1ltv8dsajYZuvPzyy7iIAADeRaVSpaWl0W2z2dza2oprAgDg0YH41q1b6UZ2dvaaNWvo9v79+1mWxXUEAPAKNTU1JpNJr9fzQzqWbAIADBZXF2sajUaz2Uy3f/nLX4aHh/M/Ki4uTk1NxaUEAPB8ycnJwptyudxgMOCyAAAMCldnxHfv3s2P2iqVSiKR8Nkpubm5uI4AAN7IbDa/9dZbyBEHAPDcQJzjuB07dtDtp556im7w2SkGg4FhGFxKAADPV1pa2tDQcOrUKa1WS/esWrUKy+4BADw3EBeO0Zs2bRKJRCKRSPj95q5du3ApAQA835QpUxQKRXx8fGFhIb/z+PHjuDIAAB4aiG/evNn5HRCIAwB4F6vVym9fvXoVFwQAwP26X6zJsixfPlytVk+dOpX/EV9Z3Gw2V1RUxMfH44ICAHiy119/PSIior6+/uDBg/xOPtUQAAA8KxDfu3cvv11WViascsVx3NChQ+n2gQMHEIgDAHi4TZs22ezRaDQKhQJXBgDA/bpPTeHzCNVqtU2tWbFYnJGRQbd37NiBguIAAN4lOzv70KFDuA4AAINC1NnZ6fweJpOJbkgkEvumDyzL8iVTwsLCxGIxrikAgEcRDtSUTCaTSCS4MgAAnh6IAwAAAABAv7sLlwAAAAAAAIE4AAAAAAACcQAAAAAAQCAOAAAAAIBAHAAAAAAAEIgDAAAAACAQBwAAAAAABOIAAAAAAAjEAQAAAADAxwJxkUiE3ygAAIZxAAAE4gAAAAAAgEAcAAAAAACBOAAAAAAAAnEAAAAAAEAgDgAAAACAQBwAAAAAABCIAwAAAAD4ArGfnz/XcSti/RGbnaYXkvGXAQAAAAADyt9nxMVD3HoFTCaTj11AhmFYlsV/pB99uuM4hmFwHQDwfwEAAIF4d8HxC8n8FLhweyAolUrPDKZTU1N79y6rVqsdvtH2+jkH8XT6UWhoKD6fgP8oKCiIjo4WiUT8fz2WZefMmTN06NDQ0NAxY8YUFBTgKgEAIBB34FB10/TnjtFt3e6qq5a2gXuthoYGD7wCLMvu37+/Fw88cODArFmzFApFPz7nIJ5OfxGLxdnZ2Xl5efjPBf4jKytLrVbzN61W66OPPmowGJqbm9evX79q1Srf+z4QAHyepbz8woKF56MmX1iw0FJejkC8/121tP3hzeorlnZ6s6L+SmphVU+fxGQyiUQiQgjHcXSb/rtlyxaRSBQdHW00Guk9+Rnxw4cP0wmkLVu20Bnlrh7Cs3kIvX9qaqrN/Y1G45w5c+iP6Duf8J56vZ4+CX0ejuMIIevWrSOE0J3OX0iv1wsPKTc39+mnn6YnTl9UJBKtXr3a5jltnsH1c9fr9WPGjBGJRPTJHZ6d85fmD9X+bl2dqfD3aH/1+AMQiUT04O0PiRCybNmyTZs2YQgDP5Genp6amjp16lR+j0wm27hxo0qlkslk6enphJCSkhJcKADwrij80v+saKurI4S01dVd+p8V1k8/7fdX8ZfFmopnS1285xffXndyZ+eJK2Kx7fW0WCx5eXnPP/+8MITlOC45Obm0tHTmzJlpaWm7du3auHFjTx+ybNky+m5nsVj27t27dOnSs2fP0lyR0tLSI0eOvPLKK9u2bdu+fTv/vmixWAICAlQqlUqlYlk2Li5u9uzZ8fHxOTk5+/fv7+zs7PaFAgIChGdnMBjGjRtHCDl69Ghzc/PNmzfFYjENT4XPScNT+gxDhgy5++67XTl3lmV1Ot2pU6diYmIWLVpE7mTC2Jyd85fm2d+tqzN1+HsUHnx+fv6RI0fa2tq6OiRCSFhYGD1xh18XgD+wtnNTNr7fowHEV9H/ceHh4firAHDoltX6xYMP2eycXHseV4YQwrW03LL+0KOH/PDZZz26f/vFr9svOEhYsPz73zZ7zJuzw98t7t8TFNnEK15NJOrydFwPxJ1z+D5qMpmUSiUfdCqVyoaGBqVS2dzcLJPJhD+lR1hRUbF48eLLly8TQvhtejf7h1D2Dzl9+jR9IYVCwbKsVCptbm6uq6tLSEgoKioihNTX12/atOnmzZuNjY38M9OHHz9+vLa29vPPP09MTNy+fbvw5bp6If7hNmdNQ1uj0ahWqzMyMlJSUuLj4x1eE/oMrp/74cOH165de/bsWULI4cOHk5OTT506ZX9258+fd/LSPPsj7OpMhcfc2dnZ1cHzvxf7Q6JxvEgkMhgMKpUKw6jfsh92fDsQpwniNt+bcRz30EMPhYaGHjt2rKtx23bXZtK5qZMQIsoWEXJ7m21npc9L+77N3eKG/mVoT7f5wxAekju33X/KdHsQT3lwT9/Np3lz1dUv4+J/FBqKbsUsqevLKd9cdfWW9YeOTi5ix6SG1Q2EkG63afyq+6eOEFL0q6Jut1+f/fIPn1XvP7efEKKdpiWEdLvd9uWXdILZe02uPd/T3zICcWfOmFoWv3LaZmf91rk9qqYijPxowEcDcZuQjj9CYYhpNBqTkpL4YNT+IZT9Q4TxMcdxQ4cObWhoqKmpSU5OpnEhtXDhQoZh+GdjGCY0NLS0tHTKlCk0hUOv1wtfrqsXsr+w/IvSSV+GYd56662tW7eGhoaePXu2q9Nx/dztA/HS0lL7s5NIJE5e2mZaTng352dKf498IG5/8PzvxeEh0d81f3EAsbg/zIXbB+Icx82dO/fcuXP19fX0/8VADOMA3q75pZeuvvJ3m51Bc+eK7rqLnxW2nj6NCzXQhoSESGJjhTPit65fF94h8Cc/mfja3v59UX+vIx4z/t4Q6TA+R5wQkr1gak9rGtI8BKPROHny5N27d3d7/5kzZxoMBpPJFBYWtnv37pSUlF4/5K233kpPT6+qqpLL5QqFgk5a0+QTGnrSOJV/no8//litVs+bN49l2ZMnT86aNYs/foZhZDKZ68cmFovlcvn169cJISzLjhw5Mj09ff78+UqlkuM44XP27tzpPSsqKmJiYrZt20b32J+diy9tfzf7I+n290gfYjQaVSoVTa93eEjkznfx9AkB/BMfhRsMBhejcAA/0clxbV9daKurs3zwAVtV1XHliv19rh854qXxqyuGhSuHTZjYo4cEREbe1cORZFjYuL6cF80RF+6RZazq96vn74G4eMhdH66dXWK8/Ic3qwkhb6+YMV0R3OMnEYuzs7NpxQCNRtPt/SUSSX5+/owZM8xms0ajKSws7PVDiouLt27dSgjZs2cPvVtpaenSpUsJIc3NzYQQYR4FISQpKWn58uVjxoyhz8Mff35+fmhoKCGks7PT9WN76qmn3nnnHZVKVVxcrNPptFrt/v378/PzaW4G/5zCWjGun7tEIikqKlq8eLHZbFar1XK53OHZOX9pfmrN/m70rIVH0u3vkR5AUlJSaGiowWCgE94OL/ixY8e0Wq19rjmAT2JZlmEYfu21RCIZOXLk3Llzy8rKSktLWZZlWVYikdh8LAfwK+2NTT989tkPhrPWqo9cSc8Qzoj/N+QNHnm3OrpHrzt03Fhx6Gh3xq8+Qzpz5kR9kXlzdltdXeBPfiLLWBX44IP9/ir+nprCo98g9+XrY5ZlrVbryJEjGxsbw8LCGhsbaVoCx3H8tnD1Hsdxra2t/DuT8G7CbZsZJv4hwiTmsLAwm5iPro/s6tlMJhN9EqvV2tUB8C/U1cHQU5ZKpRaLhc67syxrcyT0scKr0aNzp7POYrF49erVo0aN4pd1Cs+O3Gkq5PClhS/a1d2ER2Lze1QoFA5Pn4YawkfZHFJ0dPTOnTtpMjr4Mz9JTdHr9Tqdjr+p1WpzcnJs2iZotVqb9PF+H8YBPArX0nLDaPzh3DnrmU+6Siyhc8nD1erm558X7g9ZlS57+mlcQ3/g74G497a47yoT2s0qKioiIyMHaKKLppyePHkyNDS0uLjYW/KtWZYtLi4e9KZCMLis7dwvX6784tvb+YUh0mHv/+GxUdIAnzxZOiPO36Qz4o2NjcL7uDgjjkAcvDrybjeZbtTU/PBZ9bXSLktEjEhOvvuBmMCHHxk2PuyuwECCqikIxP05EPfi//BdT1T72Ls7vtEGb/SPStOmdz8X7nk8TrF5wVRcGQzj4DNuWa3tlxqdp3oTQgJnzAic/pBkxoxhCoU4OBjXzVs4LLjX73O1CMQBAPqTtZ2r+eba7179iG3vsPlRzZafBQ7DygEM4+CtOjnupvnbblO9AyIjg36WdPe0acPui0C+tc+E4wOULuGOtwQ+0xe/TgDwSVctbWcbv/93HfPhhau15uu4IAA+o72xqf2r+h/Onbv+/tGuIu8hISEj5v78bnX03Q88MFQ+WoSABzwkEOc47sCBA5mZmYSQt99+2+HatYKCgsLCQoPB4HApD617TQTlLwAAPMGlFusnF1tPnG9+9+w3rtx/QfRYTIcDeD4+1fv68RNOqnePSE6WJiYGREbyqd4AHheI5+Tk7Nq16+jRo0ajMSEhobS0dN68efZ3y8rKys3NdfgMqampcrncbDYP0BF2clztNNveh1ghAQD2rO3cxRZr1YWWozXfVtRf6Sra/unk0Ch50Nh7hi9+5XTdtxa6P0Q6bNMvpuAaAnggmupt/fgjVxZZDp8yBane4DWB+MGDB/Py8mi7k5KSkjNnztgH4unp6YSQkpIS+4fr9fpz586tX79+1apVA3SE+P6oWwzDBAYGSiSSrgr59XrBaFeFHV15oE3NQYABQnNOjI3fHTlndphzIpMGJKvHxEy496EJI8cH/2hW7OiamXxy4YdrZ/e0UxgADBA+1duVRZZI9YZBDsRpgeSu2Few5rEsazAYaMdBQkhcXFxhYSFfCtqV+E+n09FGhgN6Cej89/moyWSA58IZhlm9erUrlXT7/qj+wnGcWq0+ffq0RCJpbGy0L5jYlxKKwifs6fOEhobS+uX4Pwz9js85Of3VVcbSZn+HKHnQ3Gny+IgQZYjExYqEiMIBBhdN9bacOuV8kWVg7CNI9QbPCsRtmjLYoM0Fu4ogCSFBQUH0ZnBwsMFgcP3IUlNTMzIyVCqVk0BcJBL18fxp/G1zc4DCcZZl9+/f39OQuneP6i8HDhyYNWuWG4okCrtvdv9XKxZnZ2fn5eW5/rkOwNkHzo5b9Yyl6kLLJ1+3dpXwvSB67EMTR8aGB0fIpIiqAbzg/7XL/XRoqnfAfeGIvMH9un87abhDo9Go1eqioqKGhob8/Hy1Wq3RaMLCwrp6IM0cuH79v1/m0ubhrqioqCgrK3vyySdNJlN9fT0hxGQy0eorQp0/NojX8fDhw9HR0SKRaMuWLQzDmEwm+iGB4zh+e926dfTDg0gkojtTU1NFIlF0dDT9sNHto4SvKHyGMWPGGI3GOXPm0D0syxJChHv4rzXoQdLj5F9ly5YtwsMQys3NffrHzb1sjpln/3JdPblerx8zZoxIJEpLSxN+3uv2/vT56c5ly5Zt2rQJ/4Gh165a2s6YWraX1f38pX9HrD/y85f+s+ndz4VRuEwasCB67EtLYv7zp1mmF5J3aB/4XZwiSj4CUTiAZ7pltVo//bRl376mzP89HzX5y7j4S/+z4kp+gU0UPiI5efSG9RP1Rfd/+knkqf+My/u/9/xi/vD7IxGFg8N3Cn7b2s4NxEt0/2fHp/CWlZXx89/p6enz589XKpVtbW1dpaZIJBK1Wm00Gml2SklJSWJioouH9fXXX9sE7kql0snsuytsJr97ek8n0+QcxyUnJ5eWls6cOTMtLW3Xrl3Lli27fX0FFycnJ2f//v30AwMNVWUymcVi2bt379KlS8+ePfvf30oXj7IXFRVlsVjWrVtHPyMdOnQoLi6uuro6NjZWrVaXlpYeOXLklVde2bZt2/bt2wkh+/btU6lULMvGxcXNnj173LjbSW8WiyUvL+/555+3mXo3GAz8ffjPV/bHTDNY7F/O/slZltXpdKdOnYqJiVm0aJHDk3Ll/vQTYF8y1MEP0ZyT6ovflRouO8k5UYXdGx12j692wQQYaG6rgoB+OjCgas3Xfv7Sf/ibUza+/58/zbJZC9R3rrZOMBqNarVamJXLsqxUKm1ubnayZm716tUffPBBcXFxTU3N8uXL9+zZQxdrFhQUkDvLNGn3RDo5WlhYaN9GUa/X63Q6V47TeScI1wNxh5wMIhUVFYsXL758+TK/ffr0aT7pme9FL2xKT7fpRwv+SrIs2+2jKisrCSFxcXH0wwn9jQgPYMuWLVevXk1JSUlISCgqKiKE1NfXb9q06ebNm2KxuKKi4vjx47W1tZ9//nliYuKaNWuUSiX9JQpfiKJ76AO7OubQ0NDOzs6Kigr7l6Mp4DZPXlFRsXLlShrBHz58ODk5mb6iSCRqaGiwv//hw4fXrl1rf3/6EOEiBAAHH5I7btUzllrzdSdFBuMjQpKmjI4ND54QHNiP5QWt7dyUje/b7BygfhC+BA19fIP9G26/BOKu99MJjH1EmpCARZbQFxn7P7N54xiIBsmuvuuoVCq1Wp2WlrZ27drw8PDq6uqXX35ZrVY7r1yRk5OTl5enVCrlcnleXl5SUhLdT6NJGogXFxfrdDq6X6lUOqwm3i8cjgI9nfx26Pvvv6fFzgkhI0aMsPmpMDnHBv1UExAQQD+QuPgo+2cYN27crFmz6J6IiIja2trvv/+ev09ERERRUVFbW1traystIrls2bJ169bRJH5yJ4nIHp11tqmU4vCYHb6cwycX3tOhHtVC4VcgAAgj4JpvrlXUX/nI1Oq8yKB9nZN+FDhMjLAb/FY/VkHg++m4kuqNRZbQj28i9tM3r1WaBi0QJ4Ts27dv6dKlfLqIWq3et29ft2Hixo0bMzMzAwIChOkWwryFhQsXChfq2dfBsLmDB5o5c6bBYDCZTGFhYbt3705JSaEhrNFonDx58u7du4VxLcMwfKz51ltvpaenV1VVyeVyhUJBk+CdPEqhUPAxsfNqNjNnzqQfn+iEMcMwEomkvLxcrVbPmzePZdmTJ0/ysXuXfxxisVwut/lIYHPMTl6OD/S7ulbd/v3w96+oqIiJidm2bRu/nz65kyUK4FcutVi/bLb8u45xknPyk/BRj0XKkHMC4OHQTwcGMfjuqlItFSId1u8v3YNAXKVSnT17lmGYurq6mJgY1yvH2d9TOOspkUicP1W3dxh0EokkPz9/xowZZrNZo9EUFhbSsh70Q4tGo+Hj2vz8fDp3Tj9aFBcXb926lRCyZ88ecqcYiJNHuf6NrUQiKS0tXbp0KSGkubmZEHL58uWkpKTly5ePGTOGHqcrz/PUU0+98847wvQPm2N28nJdHVh2djYtxePKMUgkkqKiosWLF5vNZrVaLZfL6f5jx45ptVoxpj389q2649bl7284b2xJc06mjh0xZewItLQE8FjCVG8n/XQCZ8wImv1T9NMBtwXf4SGSC1d+lK2wYX7/92XzqWy8viQX9v0bNPsuMyzLWq3WkSNHCrM7aBcbcqdyNp0bFgaUTh4lTBER7hG+NH04fxh04lz4QJPJRH9q8yoO+/XQXHCaic7fQXjMNsslhS9nc4TCJ7c/R/qcDu9PvygQi8WrV68eNWoULVkYHR29c+fO+Ph4DCX+Nmh+/s21bhtbPjRh5Jh7hqO8ib8N4+BZ/2E//fTrVB0h5L6yMptEbWGq97Uj/0I/HfCc4JtfNRQhkxJCnis9/1qlif5ojWbS07Mi+v2dpfshz3nG9sKFCz1nuroXI/hgtbi3XxnpsSoqKiIjIwexjWVqaioh5OTJk6GhocXFxXSpaHFxMd0Pvo02tvx3HfPhhatOGls+FimbFCoduIRvQCAOPfL1409YP/yQvzl6w3pp4iz004HBeh9puMK6GHzbx9l8g+QBWvbT/ZDnvGlOH0sK+u0I7nD6GRyidXXsy+mAr+IbWzrJOXlEMTI+IgQ5JwjEwQPxc+HdEvbTQao39G/wTSdxulo45Dz4dmcg3v17GMbEAbnuYjGicBd5/iIB6Ovbdjt3scVadaGl25yTKHkQGlsCeLhrR444+emI5OS7H4gZPmXK8KgoRN7gzuDbM3MXuw/E9Xr9xIkTY2JiiouL7X/qUakpAOBdI6ax8buuviukOScxE+4d0CKDANDvuG+b7XeGPvO/9/zyl1hkCYMVfHvs+0j3gbhOp9NqtTk5OXy1b6GGhgYE4gDgCj7n5PRXV500toyPCFGGSFBkEMD7QvCWlqbM/7WvOThk1KhRy5fj+gCC794E4nxqCnJUAKBn78odt+oZS9WFlk++bu0q4XtB9NiHJo50JVEPADzZ9++VfPPMM3RbJJF03un4FjApQp6djesDfdFtswjvCr57FogDALiu2/XpMmnAjPtGeemICQD2blmtl/+8kS8BPvK3S0dnZRFCaFGy8PfewyWC3gXfzhfue2/w3adAnGEYYTN2mxrYAOC3w2X1xe+cNLacO02uCrsXjS0BfIylvPyb9RtoLfAhISFhO7YHPvggLgsMRPDt5nq1fL0U4c1+r53Sgxhar9dnZmaazWbhTo8qXwgA7kFzTmrN17ttbBkbHjwhOBBFBgF8j81E+Ijk5DF/2YJCKDBAwbevzuO4WrGVdljMzs5etmyZcL9HzYijAC3AwOEbkn1kau22sSVyTgDDuG+zmQgfu/U56cyZNvfpe8tqQPDt81+iujrkGY1GtVp98+ZNT05EwQgO0O9jpfP1MVHyoJ+Ej/KT4RIwjANxYSJ8sFpWgyfr9ntUvwq+hVyNqsPDwwkhaAYJ4PNj5eXvb3Tb2DJpyuipY0egsSWAv3FlIhyt6UEYfDtp1ua3wXfPAnG9Xk83NBqNUqnMyMiIjY3lf4qGPgDejuacfP7NtW4bW3paQzIAcJseZYRj/rung/CUje/b7ByghuqDHnzz/SIwlXP7g2u3XwKKRCInP/WoxZr4ThPARXxDhA8vXHXS2NJti9MBMIx7MlcmwqEvbAp0eFcgjuB7YANxjOAAvqHbmqzxESGPKEZirAQM48Dr5Lhvsp5FaRR3huNeEYIj+O4vPStfOGfOHJlMdvuzmslUWVmZmpqKiwjgmazt3MUWq5OBktzJOYmSB6GxJfRaQUFBYWGhwWDQarV8NqPDneBdbnxRd3H5ckyEA/+e4jyPEcH3AAbiJpNJp9NZLBZ+j0Qi0el0wtAcAAYdzTkxNn7npLFlsnpMzIR7UWQQ+lFWVlZubq4rO8ErdHLct7m5rW/sozcDZ8wYl/d/xcHBuDL+GXw7aZaM4NtNgXhTUxMNvv/7di6TEUJYlkUgDjC4XGxsGR8RogyRoMgg9Lv09HRCSElJSbc7wSsIJ8IJIWNffPGeX8zHZUHwzeP7teGrVPcF4jExMYQQk8nEL800Go18OA4A7sQn533ydWu3jS0xUAKAizARjuAbwbeHBuISiUSr1aalpW3evHncuHE1NTVr167NyMhA7UIA97hqaWu4wjoZJWXSgBn3jUJjSwDoHUyEI/hG8O25gTghJCcnJy0tLSEhgd7MyMjYsGEDriDAwHGlseXcaXJV2L1obAleynmFXHAPTIT7j27XESH49txAXKFQHDt2jGXZ6urqmJgYzIWDv3FDnddumwALR8kJwYFYGQNeHwL+uFgh4nL3w0S4nwTfTuZ0EHx7RyBOSSSS+Ph4XDjwN1zHrQF6Zv7LwY9MrWhsCd6IZVmGYRiGIYSYTCaJRCKTyRzuxLXyrE9BmAj34+Cbf1tBKqOXBeIAfvpfZchddP67XxoudDtERsmDfhI+6rFIGXJOwPMVFxfrdDq6rVQqaeFwhztxrTxHe2NT48qVbXV19CYmwhF8AwJxAJ/Fddy6/P2NbhtbJk0ZPXXsCFRjBe+ycOHChoYG/iZNXHS4EzxBJ8e1vvnmt89tpTcxEY7gGxCIA/igbpuQETS2BJ8gkUjs42yHO2HQ2UyEj96wfuSSJSIxggFvQntHnDjffPqrqwi+/S4QZximrq4uPj6eZVmr1YqcPwCHkxMfXrjqpLHlY5GySaFSDJEA4DY2E+EBkZFhO3cOCxuHK+MhnK9E4oNvh9+ponytXwTihw8fXrt2rcFg0Gq18fHx5eXly5cvv3z5Mi4i+Ila87Ut79XQ7c3vfr7qpxE0e7vbyYn4iJBHFCPRARgABgsmwj3coeqm50puv79k7P9s0y+mjJIGdBt802kdLCXyaiKb0lFOREdHp6WlPfDAAy+//LJer+c4bujQoQ0NDXyvzS4/5HEcIUTc8//wHMc1NjZ2+/z/PRlRD04HoEes7dyUje8L94QGBUwaHeQk5+ShiSNRDQqgZ+9JGMb7GybCPV+t+drPX/qPcI8yRNJwhUXw7Q9cDY6NRqPBYFixYkVjY+PtR7oQWHMcd+DAgczMTELI22+/7bDuYUFBQWFhIZ1oF66pHzNmjNlsJoTI5fKUlJS8vDwxPrvD4Dla863Nnubrbc3X22zGx5gJ9+KbQQDwEJgI9wo7T35ls0cYhSP4RiBOCCHh4eGEkLa2NpGCyBEAACAASURBVGFoTggJCwtz8qicnJxdu3YdPXrUaDQmJCSUlpbOmzfP/m5ZWVm5ubk2O/fs2TNlyhSZTFZeXp6cnJySkoL65TCIyuwCcULImHuGL3l4fHxEiDJEgvERADwHJsK9Bddx60Rts/3+Xz84Llk9FsE3AvHbJBKJVqtNS0ubP38+wzAVFRUrV67Mzs52Pkt98ODBvLw8lUqlUqlKSkrOnDljH4inp6cTQkpKSmz28/ecN2+eXC4/fvw4AnEYLJdarIbG7+z3H8+ciZxvAPC42K6l5eLjT2Ai3POdMbU8te9TSxtnsz9EOiwvJQbXxx/0IHU1JyeHYRidTldWVpaQkJCYmPjUU085uT/LsgaDQaVS0ZtxcXEHDx7s0cFVVFTo9frU1FRCyLJly/DbgkGZq/hHpenRv5682PKDzY8WRI9FFA4Anub790q+jIunUXhAZOR9ZWXBS5ciCvfAEPznL/178Sun6RJ/kehHP90wfwoukZ/owf9MhUJx7NgxlmWrq6tjYmK6LRBLOxsHBQXRm8HBwQaDoUcH99lnn/Hp4w7rJIps/nIB+tWlFmva62f4KoTr500ecpdoS0kNIeTVxx9+bFIILhEAeNDEQUtLU+b/Wk+fpjdH/nbp6KwshOAe+M7y4vtf8IVQZNKA9fMn//R+2YkvmD+8WU0I+c+fZmGhEQLxLlmt1nHjxjEMQ+PssLCwrrJTaOh8/fp/Symr1eoevVZ6enp6ejrDMGq1Oi8vb+PGjTZ3sFlcj7gc+tE/Kk2b3v2cbkfJgwqXTacjIw3EfxoViksEAP2lk+Nqp6lsdkadM7oeRn//Xsk3zzxDt4eEhEzYs2f4/ZG4sB7lqqUt+70aYS3C7AVTdbETaGWtRTHjaCCOKByBuGN6vT4zM5NWMuE5KV8okUjUarXRaKTZKSUlJYmJib04RJlMlpKScvDgQftAHGCAxsqMN6v5uoTCgRIAYCD0Zd4aE+Gez9rOFf77wrayL/k9azST0h4LR34juPoXwLKsTqfLzs62ydV2XjUlMTExNzc3Li6upqbm5MmTe/bsofsLCgrInWWaLMvy8+smk0kikchkMpoAExsbSwg5f/78jh07ioqK8NsCNzhU3UTnJAghMmnAP1fGYXICANxgcu15Qsj5qMn8tiswEe7huI5bRVUX+e9XCSELosfSfj24ONCDQPzChQuEkHXr1vWomHdOTk5eXp5SqZTL5Xl5eUlJSXR/ZWUlH4gXFxfrdDq6X6lU0mriDMMkJCTwz5ORkZGSkoLfFgwom4nwx+MUG5InYyIcADw0wsNEuMeH4CXGy1tLzvMdlxdEj33mZ/djcgeEXO1hxrKsVCp1pY+mw8cGBAQII3g6/02TyOmMOP8jOiNO7rTVJISgsya4gc1E+BtPPhIlH2EzpEasP2LzKNMLybh0AP35nuT3w7iLM+KYCPdwtC4hH4JHyYOeWzRtuiLY+aMUz5bincXfdP/Rme92qdFolEplRkYGzRihFi5c2G35FPs7CEugSCQSh88gFot7EfQD9JS1nUt7/ZNuJ8LFQ+7C4AgAgw4T4Z4fgm84dI4vtyWTBuxa+mC3ITggEO8SnzdC7dixQ3izoaGh20AcwGOdqG3OettAJy0cToQDAHgOS3n5N+s3dFy5QjAR7nkc1iWcrxqDFEfoUyCOZA/wSdZ27tmDRn7EXBA99m8p0RguAcAz3bJaL/9547XSUnoTE+EexXldQoA+BeKUyWRSKpX2dbt7lzUOMLhsJsJzF6tRFxwAPJbNRPjYrc9JZ87EZfEEqEsIbgrE7bEsS36c7Q3gFYOmzUT4C79WYcQEAM9kMxE+Ijl5zF+23BWIshuDD3UJwU2BOMuyxcXF9fX1RLBwkxBSUlKiVquRIA5eRLiMHRPhAODhMBHusSE46hKC+wJxhmH49ZrChZsZGRk7d+7EFQRvGTefKz3/WqWJHzQxEQ4AHuWW1Xp17166ffXVvT+cPXv9/ffpTUyEe47e1SUE6H0grlAoOjs7GYZZvXq1cEYcwFvUmq/9dvdH/Lj56uMPYyIcADxN/ZykjqtX6XbzX/9KNzAR7lEhOOoSQr/zqdYJ6AQBNmwmwuMjQnYsiUECHwCGcU9j/fTTr1N1Njsljz4atv0lTIQPuoGuS2ht56ZsfN9mJzpX+Al8NQ8+y2Yi/KUlMYtixuGyAIAHutn0jf3OexYsQBQ+uNxTlzBwmBhhNwJxAN+BiXAA8C5Dx411cSe4B+oSAgJxgN641GJNe/0Mn8aHiXAAF7EsyzAMWkMMirvVatGwYZ3t7fyegEkRgQ8+iCvjfqhLCAjEAfph9MREOECPMAyjVCrVavXzzz+flJQkRtdGd34KqqgQRuEhq9JHarW4LO5/E0FdQnCzHi+LYRiGtvKhwsLCPGewxmJNf2YzEY72wgC9UFFR8fLLL+/fv58Qkp2dvWzZMjdPkPvnMN7JcV8mzuq4cmVISAitGj659jz+Gt0MdQnB0wNxvV6fmZlpNpuFOz2qxT0Ccf9kMxEeJQ8qXDYdExgAvcay7N69e7du3Wo2mzUazebNm+Pj4zGMDxzm5Zev5BcQQsa++OI3zzyDQNz9ITjqEoKnB+Isy0qlUjpBItyPGXEYXFctbbrdVZgIB+hfJpPp9ddf37RpE72pVquLi4vdMO3ih8N4e2PTVxoNISRwxoyJe189HzUZgbjbDHRdQoB+C8SNRqNarb5586YnZw0iEPc3h6qb/vBmNd3GRDhA33Ecd/To0bVr1xoMBrVanZWVtXDhQqvVmpqaOmXKlO3bt/fiCQkhrr9x+OEwfmHBwra6OkLIfWVlw8LGIRB3D/fUJQTolqt/cOHh4YSQxsZGXDLwkDFUt7uKj8LXaCaVrEpAFA7QFwzDDB06NDk5OTEx0WAwnD17NjU1VSKRyGSyJ554gmGYrh5YUFAQHR0tEolSU1OFIbherx8/fvz48eMrKipweR36/r0SGoWP3rB+WBjqO7mDtZ3bXlb30HNlfBS+RjOpZsvPfhenQBQO7teD6W2NRqNUKjMyMmJjY/mdCxculEgkuI7gTsKJcJk04I0nH4mSj8BlAei7/Pz8J554wn5UT01NFQbZ9rKysnJzc4V7cnJydu3adfToUaPRmJCQUFpaOm/ePFxhoVtWK80IHxISMnLJElyQgYa6hOCBXP0S0GQyKZVK+/1YrAnudNXSlvFmdUX9FXrz8TjFhuTJmMMA6Bd0nLcZRUUikYvjPI3U9Xo9vRkdHZ2VlUV3pqamRkVFbdy4EcO4UFPm/14rLSWETNQX8SXDkZoyQCE46hKCZ3J1RlyhUCDGhcGFiXAAN6PFamUyWS8eaDAYVCoVvRkXF1dYWOhKIO4/bnxRR6PwEcnJaNwzoFCXELw7ENfr9RMnToyJiSkuLrb/KVJTwA2s7dyzB418Ph8mwgH6PeAuLi6ur68ngiltQkhJSYlare7FIE8TyoOCgujN4OBgg8Hg8J4ikcgPL3gnx11cvpxuj/nLFvwFDlwIjrqE4PWBuE6n02q1OTk5Op3O/qcNDQ0IxGFAnahtznrbQCczMBEOMBAYhuFHeOFQn5GRsXPnzl48IZ1Ev379Or9HrVY7DkntMmH84YK3vvkmbdwz9sUX7wpEdkT/Q11C8J1AnB8lkZoCbmYzEb4geuwLv1YFDkPbbYB+RpMPGYZZvXq1cEa81yQSiVqtNhqNNDulpKQkMTER15lqb2z69rmthJCAyMh7fjH/9jssx9VOU/H3oZni91d/dtfw4bhiPYK6hOBrgTjAoLCZCM9drP5pVCguC8DAkclkvYvCWZZlGIamo5hMJlrxMDExMTc3Ny4urqam5uTJk3v27MEVpi7/+c90I0zwbYNILMYCzT6ytnOF/76wrexLfs8azaS0x8IxfQMIxAF6NphiIhzAnfq4Fqi4uJhPaFEqlVqtVq/X5+Tk5OXlKZVKuVyel5eXlJSE60wIsZSXW0+fJoSM/O1SFA7vL6hLCN7LpwpFoXyhD6g1X/vt7o8wEQ7g5sGTrgXqXZlaOiPO36Qz4vyPAgIC0FmTumW11if9rOPKlSEhIZM+OCkSY36hH0Jw1CUEr4ZRADxoPH2u9PxrlSZ+MMVEOIB79HEtkEQi6WrKHKv5hZq3bbu9RnPrc4jC+w51CcGPAnGO4+z728tkMgyy0C+EE+GEkJeWxCyKwZe2AOA7bnxR1/rGPkLIiORk6cyZuCB9DMFRlxB8Q187a2o0moULF6anp3vEySA1xQvZTITHR4TsWBKDxD4Ad3K+RtOd/SJ8dRjv5LiGX/26ra6OEDKpskIcjJCxl1CXEHyMqzPiYWFhGo2mubk5KytLpVKVl5dv3bo1JSVl1KhRq1atmjlzJt9BzUGkxXGEEHHPv4bjOK61tbUXTd3AW2AiHMATOGwTwUO/iL67duRfNAofvWG9z0fhXMetiPVHbHaaXkju49OiLiH4dSDe2NhYVlZmsVjocKxSqcLDw5cvX3758uXa2tp33nnHYSDOcdyBAwcyMzMJIW+//XZ8fLz9fQoKCgoLCw0GA11oT3eyLLto0aKysjJCiFwuX79+vYdMukM/jtTCRe6YCAcYRPgucWCHu5aWb555hhASEBk5cskS3w8s+jsyRl1CQCD+owZp1D333GM2mzmOmz9/fklJicNH5eTk7Nq16+jRo0ajMSEhobS0dN68efZ3y8rKys3N/dH/Oqv10Ucf/dvf/iaXy996661Vq1bNnz/f+bJ98CKXWqxpr5/h0/swEQ4wuPpYvhCc+3ZrDt0Y++KLfrJGk85/K54tJX2bC0ddQvB5PcjGi46Onjp16tq1a+VyeV1d3cqVK3/9619v3Lhxy5YttbW1DlMMo6Ojs7KyUlNTCSGpqalRUVEbN250+OT0Pl3lKYpEovz8/G4nxZEj7vlsRtUoeVDhsumoMwUwyO8EfStf2L9H4mPDuKW8/NL/rCCEjPztUvn69X71d9WXQBx1CcFP9OCj+c6dO1euXKlWq+lNjUZDc06mT5++bNky+/uzLGswGPiUlbi4uMLCwq4CcSdoedrw8HD8trydzUQ40vsAPEQfyxdClxeW475Zv4EQMiQkJHTNGlwQF6EuISAQdyA+Pv7s2bMMw9TV1cXExPDfVDrMNuED6KCgIHozODjYYDD0+DMxx2k0Go1G4/BVRCIRfoVeARPhAOCHrvz977Rw+OisrLsCMeK5FIKjLiEgEHdGJpO5WMaE3k2YXM7Pprsehc+dO7e5ubmyshK/Ku911dKW8WZ1Rf0VehMT4QCejGXZ6urq48ePz549OzY2Voy+M73V3th0Jb+AEBI4Y8Y9v5iPC+Ic6hICAnGXMAzDsix/MywsrKthWiKRqNVqo9FIs1NKSkoSExN7GoWfO3fOYDB0tU7I5ltUTJB7oEPVTX94s5puYyIcwMPp9XpaylAul2/atIkQUlRURNfwQE81rlxJN8b85S+4Gk6gLiEgEHd1gM7MzDSbzcKdzhfxJCYm5ubmxsXF1dTUnDx5cs+ePXR/QUEBIYQuvmRZlmEYmsdiMpkkEolMJqNReFlZWWlpKcuyLMvS/fiFedfYKpwIfzxOsSF5MgZWAI/FcVxmZmZ+fv6KFSvEYjHLsnv37s3MzEQg3gvfv1fCFw4fFoaqUI6hLiGAq+vTWZaVSqXZ2dk26zKdzIjTR+Xl5W3atEkul+fl5aWkpNA7C2uk8BMwFK0mbt/IU1hlvMuTQdUUjyGcCJdJA9548pEo+QhcFgBPZjQa1Wr1zZs3+VGd47ihQ4eiakpP3bJav3jwIULIkJCQSR+cFPlreo+TqimoSwjQs0DcfoB2HcuyAQEBwgfS+W86w01nxPkf8TPijY2NwidxZUYcgbgnwEQ4gJdiGCY0NPTUqVN887WKioqEhITejfz+HIg3Zf7vtdJSQshEfVHggw/67V+Uw0AcdQkBhFwdW2n1wMbGxl7Mi9hneAtDaolEYn8HsViM9j3e6ERt8+9f+/j2bxkT4QBegv++UaPRJCQkaLXa+fPn7927t6ysTKPRtLW1Ycmm6258UUej8BHJyf4chTuEuoQAtrMPrqem0J7zGRkZsbGx/H6P6riGGfFBZG3nnj1o5FfbYCIcwJveCZyudEdqius6Oe7LxFm0ZOH9n37izyULuY5bEeuPkDsz4vZ1CXMXq38aFYr/fYBA3KUhzz5p2/0DNAJxj3WitjnrbQOd5EDZVwDw22G8Zd++b5/bSggZ++KL/lyy8B+VJj7/e2Tg0CljR1TUX+VDcNQlBOhxII4RHByymQhfED32hV+rsOAdwEuxLFteXr5t27aysjJ+J2bEXdTe2PSVRkMICYiMDH+32G//ii61WB/960mHP1qjmfT0rAiE4AC87gMmvV4/ceLEmJiY4mIHw4pHpaaAm9lMhON7RgBvt2jRonPnzk2bNk2r1TIMQ3PEUTrWRZf//Ge6EbZzpz9fh39+2mi/M2V62OYFUzFNA9DjQFyn02m12pycHGGRQV5DQwMCcR9D17nbsF/2/lzp+dcqTfQmJsIBfACNvC0WS3FxcUtLS3p6ekVFxeLFiwMCUFGue5bycuvp04SQkb9d6ueFwy9/f8N+58+njcF7BEBvAnH+W0JkffgJGnPz4bh9Cdha87Xf7v4IE+EAPqauro7cqXNVWVmZnp4eGxtrNpt7Vy/LZ3RyXO00lc3OqHNGYXXwW1brN+s3EEKGhISMzsry57+iQ9VNb358yX7/Y5NC8F8MoDeBOEWrfaOkoJ+zmQiPjwjZsSQG/RcAfMO4ceMIIRzHxcXFZWZmGo1Go9FIflxw1g+50o6neds2Will7Nbn/LZ9j7WdS3v9E76JhFD2gqnICwfoUyDOMIxSqVSr1VlZWcgL90/CiXBCyEtLYhbFoG8zgO9QKBRarZbOf8+aNUutVhNCMjIyMOBPrj1PCDkfNZnfFrrxRV3rG/sIISOSk6UzZ/rnJbJZMvTGk48QQn7+0n8IIZ9s0GC+BqCvgbhCoTh16tSBAwdoprhWq3366adjY2PR5cEfYCIcwE/wnX30ev327duJ30+Hd6uT47555hm6PXr9Ov98g/jjgbPC2ll/S4kWzn/jzQKgHwJxQkh8fHx8fHxeXt7Ro0e3bduWkJAgl8sNBgOGad9zqcXKb3/wRfMz/8+AiXAAf4Ox3RXXjvyrra6OEDJ6w3pxsN/1T8CSIQD3BeK3HyAWz5w587vvvjt37pzZbGZZFoO17w2s9PtE6vG9t1vWYyIcwB+wLFtdXX38+PHZs2fja0/nuJYWOh0eEBk5cskS/zp31M4C6A89WDzBcVxFRcWcOXOkUqlOp0tJSTEYDFi+6Xt2nvzKfmf2gqlFT8YiCgfwbXq9XiqVJiQk7Nq1KyEhYejQoXyyCtj7dmsO3Rj74ot+tUbzUot1xvMn+Cj8pSUxO7QPIAoHGMBAnGGYoUOHJiQkEEJKS0tv3ry5fft2lUqFK+h7+FQ/od/F4RMXgI/jOC4zMzM/P//mzZuXL1+2WCz5+fmZmZm4Mg5ZysuvlZYSQkb+dunw+yP95Y+k49Y/Kk2P/vUkTUeJjwj5ZIMG+YoAvdaDz6/5+fm/+c1vkIji8+4fHfTFt9eFe0Kkw3BZAHze+fPnzWbzihUraDqKRCJZsWLFqlWrTCYTvvy00clxfOHw0DVr/OSsL7VY014/U2u+/QaRvWAq5mgA+sjVGXGZTJaeno4o3B8sT1Da7NkwfwouC4DPk8vlhJCqqip+D90OCwvDxbFx5e9/p4XDR2dl3RUY6A+nfKi66dG/nqRReJQ86D9/moUoHKDvup8R1+v1EydOjImJKS4utv8paor7GK7j1p5TF4R71mgmzVeNwZUB8HmBgYEajSYhIUGr1c6fP3/v3r1lZWUajebAgQOEkIkTJ8bHx/f0OVmW9b33iPbGpiv5BYSQwBkz7vnFfJ//w7hqact4s5rv1JO9YKoudgIa9AD0C1G3jetFIpFWq83JyVEqlfY/bWho8JyvLEWi7k8HnPtHpWnTu58L99i3uAcAn2QymRyO85RWq+3Rwk2j0fj888/v379frVbv3LnTxSDek4dxvqHPhQULacnC+8rKhoX5eHr0oeqmP7xZTbdpp54o+QgXH6t4thRvIgDOdT8jTsdElmU9KuaGgXCpxUqj8Ch5EJ8FCAB+QqFQ9GMQvHTp0qlTp1oslurq6oSEBIPB4Bvr+79/r4QvHO7bUbi1nXv2oJFfvv94nGJD8mRMhAP0rx5UTVEqldHR0Xq9nmVZXDjfw3XcSnv9DN0uXDYdFwQAeo1hGIPBsHbtWolEEh8fr9FoysvLfePUaOHwISEhvl04/ERt88y/fkCjcJk04F9/eHTzgqmIwgEGLRCnLe4TExN1Op1UKk1NTa2oqOA4DlfQZxRVXaSz4NkLpo4PDsQFAfBDLMsePnx4zpw5IgGTydT3Z3a4yshbcC0t5q1bhXvCdmz31cLhXMetjP2f/f61j2mBwgXRY8v/lOh6Ogp9BsWzpTQvhRAi3AYAGz3OxuM4jra4Lysr87QW98gR77VLLdZH/3qSdJ2UgiQ/AH8wZ86cc+fOTZs2TSaTMQxDF2seOnSoFwsuo6OjQ0ND//a3vxmNRp1OR+4kOtqP2zZ7PHAYr4tP6Lh69b/HPGzY/Z9+4pOBOFrWA7gZWtyDbVIKpsMB/BONvC0WS3FxcUtLS3p6ekVFxeLFiwMCetNSd9++fbt371ar1XK5XC6XT5s2zeHdbMJu+7h80Fk//VQYhRNCOtvbfzAYAh980MfeCIQt6+MjQgqXPYRmmQADDS3uAUkpAEAIIXV1dYQQOvldWVlJCImNjTWbzY2Njb14NpVKtX379s7OzsuXL4eGhj7xxBNeelluNn3j4k7vZd+yvujJWEThAG7g6n8zhmFCQ0MJIRqNprS0NCkpSSzGf1FfcNXSxldK0cVOwAUB8Fvjxo0jhHAcFxcXl5mZaTQajUYjIaR3X3uaTKawsLC2tra8vDyDwTBnzhwvvSx3P/CA/c6ASB/pac913CqqushXrY2PCNmxJGaUNAD/HQA2b97s4k53BOIELe59VMadArEvLYnBingAf6ZQKLRabWNjo0KhmDVrllqtJoRkZGT0riPPunXr9u/fTwjRarUetZqop4aFjQuIjKQlC29H4ZMiht/vC4H4VUubbncVWtYDOAnE+ci730PwHgfiwcHBiMJ9zKHqJtos7fE4RY8WxQOAT+Jb9uj1+u3bt5PeTofTZ8jJyZFIJD7wxhG2a+dXszV0e/SG9ff+6le+Mf7znXqi5EFYIAQwKFydAa2rq6PL3sFnXLW00VFYJg3YkDwZFwQA9Ho9wzB0WyaTsSzbo26aNhQKhW9M37TX1/PbwUuX3hXo3QErnQjno/A1mkklqxIQhQN4dCAeGRlJCKmoqMAl8xl8UsobTz6CpBQAMJlMOp0uUBBlSiQSnU7Hh+Z+y3LqlM+cy4na5oeeK6PfhdJOPas1kXgLABgsrqamBAYGajSahISEjIyM2NhYfv/ChQt7lz4IgwtJKQBgo6mpidypmkLR+WyUqW19Y58PnAVa1gN4cSBO68sSQnbs2CHc39DQ0G0gThtwosqK50BSCgDYi4mJIYSYTCa+Lm1fqqb4jPbGJh84ixO1zVlvG/hOPbuWPjhdEYy/eYBB14MW952OOK8jznGcXq8fP378+PHju0prKSgoiI6OFolEqampruyHvkNSCgDYk0gkWq02LS2toqLCZDIdPnx46dKlva6a4jMsH5z06uPnOm5tfvdzm5b1iMIBXHHx4kWH24MQiHMcZ3KEznZ3JScnJzMz8+jRo3l5eQkJCYcPH3Z4t6ysLFony8X90BdISgEAJ4M2ISQhIUGpVCYnJycmJm7YsMHPr8n14yeI1xYOrzVf4zv1yKQBrz7+8A7tA+jUA+BiFP7qq6/yN1999dWBiMVd/d/Y2NioVCrt9zc0NDiZFD948GBeXp5KpVKpVCUlJWfOnJk3b57NfdLT0wkhJSUlLu6HvkBSCgA4oVAojh07xrJsdXV1TEwMlgDdslqtp08TQoJ+liQsJe757FvWo1MPgIs6OjquXbv2/vvv2+z/4IMPli1bNjiBeFhYWENDA3+zpqZm7dq1oaGhYWFhXT2EZVmDwaBSqejNuLi4wsLCjRs34hc8iJCUAgDdkkgk8fHxuA6EkBu1tXQjSDPnSn7BgMbNEeuP2Oys3fKz4b2avb7UYk17/QzfqeelJTGLYsbhtwlgr7W1lRBy6dIlQkhdXZ3Var1w4UJXd3byowEPxAkhwplvhUIxZcoUpVLZ1tbW1SpMWvEqKCiI3gwODjYYDPiVD6ITtc1ISgEAcB17+jTdCLgvfEBfSDzkLtMLyYQQxbOlhBC63buAHi3rAboNuAkh586d6+mThIaGDlogbh9t03X0DMN09d0lvcP169f5Pf2e8C0SifC35SJrO5f1toEQIpMG/Onn9+OCAAB0/+a9/01CSOCMGSJvKPxl37JeFzsBX36Cf314Ztn29naGYW7cuNHU1MSyrOsB9+jRo2UyWUhISHBw8L333tvU1GSTnaLRaAYtEGdZtri4WLgnNzdXrVY7SRCXSCRqtdpoNNLslJKSksTExP49+s7OTsTlLnr2oJEumc9drMZKHQCAbnEtLR1XrhBCvKKnPVrWg58H3CaTyWKxuPJYqVSqUCgkEsm4ceOGDx8uk8mGDRtmP608YcIEiUTyz3/+k9781a9+FTkAi7Z7UEdc2OJeLpenpKQ8+eSTzh+VmJiYm5sbFxdXU1Nz8uTJPXv20P0FBQXkznJMlmUZhqF5LCaTSSKR8C0kHO6HXjhR20ybOCyIHvvTqFBcEABwEHdyXGNjo81OmUzmt0s2bxiNdOPuBx7w5OO8amnLeLOaZh4SQtZoJj09KwIT4eAb2tvbWZa9fv36d99919LSWYgeuQAAIABJREFUcuXKFYZhvv32WxcfPm3atG4DbifUajUfiA9QHT9XA3FaR7ynz56Tk5OXl6dUKuVyeV5eXlJSEt1fWVnJB+LFxcV8iK9UKrVarV6vd7IfekqYlPLCr1W4IADgUFfVsTQazcKFC+mI7Ve+f/c9QsiQkJCvBN9Hn4+aTAiZXHveQw7yRG3z71/7+PanJmnAG08+giVA4I1ooZK+BNyEEDpjPX78eELIyJEjveLEe5miwLIs+XEnZIckEsnGjRszMzMDAgKEWebbt2/ntxcuXCisx8I/Z1f7oaeQlAIArggLC9NoNM3NzVlZWSqVqry8fOvWrSkpKaNGjVq1atXMmTP5Klh+4lppKSFkxM9+1lpUZPOjWzdu3DV8+OAeHlrW+4z29nZawl9o8+bNPhxwt7e3f/vttz/88MOlS5ecFyqxER4eHhgY6I0Bd18DcZZlpVIprRp++PDh5ORkQkhRUZErbS/tY2hhkolEInEYZHe1H3o6WYKkFABwRWNjY1lZmcVioWOvSqUKDw9fvnz55cuXa2tr33nnHb8KxG98cbtquPSxR+V/9riuRmdMLU/t+xQt633DsGHDfPK8Wltb+xhwjx8//u677x49evSwYcNGjBgxZMgQ37tKPcgRJ3cqGC5fvjwjI2PSpEk6nQ795z0ZklIAwHXCIlfUPffcYzabOY6bP3++v7VXs378Ed0IfPhhjzowm049C6LHvvBrFb7t9HZ0/lv4r3cF3KS3lQGFhUp8O+DuayBeU1NDs9SNRqPZbN6wYYNMJlu1apXJZHJSOAUGF5JSAMB1KpVKrVanpaWtXbtWLpfX1dWtXLkyOztbLBbX19f73ceSO53t7wr0oNojteZrv939ER3YCSGvPv4wvuoEtxEWKulLwH3vvfcGBQVJJBJf/SpgQALxhx9+2GAwmEym3bt3q9VqFDDxfEhKAYCe2rlz58qVK/niABqNJjMzkxAyffr0fm/s7Mn4zvb3pvwfDzkkruPWyyfrt5V9SW+iUw+4J+Due2VA7w24bb6aGKDvK1wNxGUymUajoQvqT506RQgxGo3kx9ne4DmQlAIAvRAfH3/27FmGYerq6mJiYviFOvPmzfOr68B3tg98+BFPOB60rIeBYF8ZsN9LcXs19+QI9SBd4dixYwzDBAYG0gsdFBRUVFSE9ZSe6a//+gJJKQDQa+PGjeM7OYSFhYnF/jWMuK2zfbdsWtZHyYOKnozFRDj0MeDuS2VA3wu4B1fPxlbh/LdCoUB2uGeqNV+j63jiI0KQlAIArtPr9ZmZmWazWbiT1svyq+tAO9uPSE4e3M72Np160LIenLOvDOgnpbj9KBAHz8d13Prt7tuL/XcsicEFAQAXsSyr0+mys7Nt0sHDwsL8axS909lempjo5peuNV+jG5darJ9cbEXLer+KoZuamuh2e3u786TqfinF7Q+VAb2CqBf9Mj33ZEQ+dTq9s/ndz+l0OJIIAaBHjEajWq2+efPmICaieMIwbikvv/Q/KwghkyorxMHuK86drv+0xHDZfj869fi89vb27du301aJ1O9///sJEyaQ/qgMiIDbw2FG3KcIk1IQhQNAj4SHhxNCGhsb/TztkO9s784o/FKL1T4KD5EM25cWi5b1vv/eXVsrjMIJIUVFRW1tbT0KuFEZ0L8CcRdb3IM7ISkFAPqIVsfKyMiIjY3ldy5cuNCvRvvbne3n/tydL/rJxVb7neuSJyMK9z00sYQunWxqamIYxj6rxGEUTguVIOD200C8Ly3uwT2eKz1PK6W8hOKyANBzDMOUlZURQnbs2CHc39DQ4D+BON/ZfsTcue583RHDh9rvvDfQW2Ms+7pvXtctsr/wbd5puRLXE0sefPBBhULhq5UBoceBOFrcezgkpQBAHykUCiyz4TvbD4+KcufrTp94r/3OxyaFeOM17Ojo8M8/Hlol8NKlS65XLKGT3EOHDv3ss8+E+6dNm7ZgwQIMSgjE/wst7j0ZklIAAPrFdwf+HxmMzvZ/O/al8GaIdNgrSx/y0gWaQ4YMEfYg9Mm5cGF6SV1dnYtFS8LDw2Uy2bhx42hiiXDp5LBhw6qqquh2aGjoXPd+IQNeEIijxb0nQ1IKAPSFXq+fOHFiTExMcXGx/U/9J0f8ltXaVldH3N7Z/kRtM/1KM+6+UZVfXSWEnNkwB3+WnqMX6SV8xZKRI0e60uZ97ty5s2fPzsnJIYSsXLkS1xyBuC20uPdYSEoBgD7S6XRarTYnJ0en09n/tC854izLBgQEeEtjzkHpbH+pxfr71z4mhMikAfnaBx56rgx/kIOIZdn29vZepJfQNZR9aTyJZZcIxLuBFvceiOu4xXd8QFIKAPQOTQ1nGKYfl+AbjcY//vGPdPWnVqstLCz0/PeLa0eO0A23dbbnOm79amcl3X7jyUfwlaY70fQShmFu3LjhenrJtGnTJBIJn16C3pPgvkCcECKTyRiGqa6ujo+Pl8lkc+bgu7NBVlR1sdZ8nRCSvWAqRnAA6Iu6urp+XIL/xz/+USaTNTc3syw7Y8aMvLy8jRs3enwg/i/i3s72fzxwliYWZi+YikqFA4pPL2lqamJZ1vX0ksjISFq6BLUCYZAD8cOHD69du9ZgMGi12vj4+PLy8uXLl1++fBkXcbBcarFuevdzQkiUPEgXOwEXBAD6IjIykhBSUVERHx/f92crKysrKiqSyWQymWzWrFm1d7I+PJb7O9sfqm569+w3hJD4iJDfxSnwF9hfbNJLTCaTxWJx/pD+Si8BGMBAfO3atWlpaQ888MDLL79MCElKSjKbzaiaMmjvGR230l4/Q7cLl01H92MA6KPAwECNRpOQkNAvDX2ys7MzMzPvvffeCxcu7N+/ny4u8ujoreJ2iogkPs4NL3epxUoTC2XSgMJlD+HPr3eQXgL+EogbjUaDwbBixYrGxsbbj/SSxTe+SpiUMj44EBcEAPqofxv6LFu2bNeuXbT7m1qtjolxvIhFJBJ5yOlbPviAuKuzvU1qeOAwvJ+6pLW1lW9I6WJ6SXh4eGBgIJ9eIqwYCOBNgXh4eDj5cc9VWjUlLCwMF9H9kJQCAP2uHxv6cBw3Y8aMlJSUvLy8tra2RYsWLVq06NixYx577p0cRzvbj9QuccPL/W7vx0gNd45PL6EVA11PLxk/fvzdd9/tXekl7e3ttHAh5cP116H3gbhEItFqtWlpafPnz2cYpqKiYuXKldnZ2ZgXdz8kpQCAh2tsbDSbzWvWrBGLxWKx+IknnnBYGJHcKdjCG6wJ8ravbuczSGbMGOjX+kelqaL+CiFkQfRYH04Nb29vpxsdHR3OJ6FpQ0o+vcSVioFEkF4yevToYcOGeXV6CdaA+jOR6/MfJpMpLS2NfnFJCMnIyKD9NT3oZEQif+jP/I9KE50Oz14wFet7AKB/sSxbXV19/Pjx2bNnx8bG9nq2ZcyYMSkpKXSeLy4uLjExcfv27R47jLfs2/ftc1sJIfd/+smA9tSsNV/7+Uv/IYTIpAGn1/7UfiZF8WwpIcT0QrJX/xVVVVUduVMLUiKR/OY3v5kw4faXt0gvAehlIC4co2NiYjzwGx9/CMQvtVgf/etJQkiUPKhkVQKmwwGgH+n1ejp1LZfLzWYzIaTXlcUPHz68fPly+iRqtbq4uNiVlf2DNYxfWLCwra4ucMaMiXtfHbhXsbZzM//6AU1K+c+fZjlc3uMDgXhra6vNh66hQ4fef//9rqSX8A0pvS69BKB3up/qcNj6+Ouvv6Yb/tP62BMgKQUABnCE4bjMzMz8/PwVK1aIxWKWZffu3ZuZmdm7QHzevHmXL18WtoHzWHxn+6DZPx3QF0p7/RMahb+0JMaHF9mfPXvWZs/NmzcdznxPmzaNVgz0gfQSgIEKxAeu9TH0FCqlAMDAOX/+vNlsplE4IUQikaxYsWLVqlV9KVPrUemLXXFPZ3thaviimHG++ld08eLFqqoq+/1yuTwkJCQyMpJWDER6CYCrgTj/LaE/pF97squWNpoaLpMGoFIKAPQ7uVxOCKmqquIb+tCIyuerY/Gd7YffHzlAL3HG1MIP4H9LiXZ4H5qUItz2ogSVjo6Ozz///OjRow6TTyQSSVpaGiJvgN4E4pTJZFIqlfbL2xsaGtDQxz0y3qymG288+QiSUgCg3/ENfbRa7fz58/fu3VtWVqbRaA4cOEAImThxYr903PTIQPx2Z/sBev6rlran9n1Kt//1h0cdDuBcxy37nTfaueEeX2K8vb29srLygw8+4PdIpVKxWPzdd9/xex577DFE4QAOubosxj4QZ1lWKpVaLBbPSU3x4cWah6qbaA+2x+MUmxdMxR8uAPQ7Os539VOtVqvX631vGOdaWr6MiyeEjP/7K9KZM/v/+Ttu/W7vxzQp5dXHH/5pVKjP/MG0trZ++OGHwkSU0aNHx8fHT506dciQIfySzXXr1qE8H0BXuv+ozbJscXFxfX09IUQ4CpeUlKjVaiSIu8FVSxvfCXlD8mRcEAAYCDYNfViWJYT4/CDPd7YfrlINxPO/fLKeRuGPxyl8Jgq/ePHiBx98IGwmP3r06OTkZL5GISGEX3mJKBygT4E4wzD8Mk3hes2MjIydO3e6NB/AcYSQ3hWj7ctjfQaSUgDAHSEpy0qlUppwePjwYdqdvtflC73Fd//8JxmwzvZnTC3byr4khETJg3xgGoUmgldUVAgb7kybNm327NkoeALQO91HdXSOpLm5WavVdgps376923xBjuP0ev348ePHjx9fUVHh8D4FBQXR0dEikchmrHflsf7gUHUTP5uCTsgAMHAYhqFjPiFk+fLlGRkZ+fn5XXXE9A2dHGc9fZoMTGd7YWp40ZOxXj2N0t7eXlVVtW3btn/+8598FJ6YmLhu3brFixcjCgfoNVdnmmUyWS+yA3Nycnbt2nX06FGj0ZiQkFBaWjpv3jz7u2VlZeXm5vbusb4NSSkA4DY1NTVqtZoQYjQazWYz7Z3cx/KFHm7gOttzHbcy3qymVcNfffzhUdIAL71Era2tZ8+etVmLmZSURBPB8b8GYMADcYcNfXjOG/ocPHgwLy9PpVKpVKqSkpIzZ87YB9Pp6emEkJKSkl481uchKQUA3Obhhx82GAwmk2n37t1qtdorSoD30fWyY3RjeFRU/z4znxq+RjPJS1PDL168+NFHHwkb8dBE8HHjxiEEB3BfIN7rhj4syxoMBtWd5S9xcXGFhYUbN2505bD68lifgaQUAHAnmUym0Who4ZRTp04RQoxGI/GSpjy9DMTfP0oICZwx467A/myRdqK2maaGx0eEPD0rwruuSUdHR1NTU2lpqU0i+KOPPjp69Gj8NwFwdyDe64Y+NN0wKCiI3gwODjYYDP37WJFI5Ku/GCSlAIDbmEymsLAwsVh87NgxYVP6oKCgoqIiXy2cMkCd7a9a2n7/2sd09N6xJMaLvsxsb2+vra21acqTmJgYHR2NLHCAQQvEnaeGO0lNoZMo169f5/fQ7ENXuPhY+wZDPvOLyX6vhm4gKQUABppSqWxoaKAbwnFVoVD4cMs268cf041+7GzPddzS7b5dV3vX0ge9JTXcYVOeRx999IEHHkDxQYBBDsSdL5l3kpoikUjUarXRaKQZJiUlJYmJiS4eVl8e6wNO1Da/e/YbQsiC6LFISgGAgaZWq0tKSmYOQDsbT2Y5dYpuOO9sz3Xcilh/xGZn/da5DqdInis9X2u+TghZo5k0XRHs+RehtbX1+PHjNongs2fPvu+++5AIDuARgXhfmpwlJibm5ubGxcXV1NScPHlyz549dH9BQQG5s0yTZVmGYWguislkkkgkdDq8q8f6PGs7l/W2gRAikwa88GsV/kYBYKBlZWXxcy72Xy3SyuK+d9YudrZ3/TvJE7XNr1WaiJekhl+8eNEmETw8PDwxMVHYlKfXNm/ebLMt3AMAPQjE+yInJycvL0+pVMrl8ry8vKSkJLq/srKSD8SLi4v5NwClUsl3Ue7qsT7v2YNGWvEqd7E6cJgYf6MAMNBSU1MXLlxYXl6enJxMc1SEwsLCfO+U2xubOq5cIYTcs+AX3d7Z9EIyIUTxbCm/ba+PqeEdHR1/+ctfbHauX79+6NCh/XvitCmPTSJ4bGzsT37yk/5KBO/o6MD/KQAXibqd8O5L+UKKZdmAgABhd0w6/01nvumMOP8jfka8q8c6OxmRqC/z957gRG0zHcoXRI/doX0Af6AA4I53ApHIYY74oByJew7g+/dKvnnmGULIpMoKF3tqOgnEuY5bM54/QedQ3l4xoy9JKQM3f0wTwc+cOcOH4FKpdPr06XFxcUgEBxgsA1i+UBhb2+wRhtoSicTJM/jqan2HkJQCAINCLpdfv36dL1TlD2hn+4DIyH7pbP/HA2dpFJ69YKoHpoa3trZ++OGHVVVV/B405QHwmkC81+ULoaeQlAIAg+Kpp55KSkqaNm0aISQ1NdXmp9u3b/exUuJ8Z/ugn/VD0uOh6ia6vD4+IuR3cQqPOtOumvL0SyI4ALgjEBdiWba6uvr48eOzZ8+OjY11MWMEXCGslOKlbdgAwEtlZmZOnz5927ZtfnK+/djZ/lKLle/5ULjsof/f3v3HN1HlewM/gZSuncDSSkpq65ogsIh0Ul3dbn94aZeAlxYVods1aeVexL4ewJJurbsuhSuUq2VZnz7dUpT7WkTu7pJ25QFfW6VlXxgsaFO3Vx+FBLCLSCIUKYmURWaqpVPy/HFkdkjSNA39kaSf9x+8JpOTmTOnyeGbk++cEyIX2NfX9/nnnx86dMhjUZ558+ZhRnCAcA3E6+rqaHaKSqXasGEDIcRkMnmPnUAQkJQCAKOIYZicnJwHH3ywpKTE/9oRkUFc2f62gFe38Enou77k1Va6/aenfxwKv2Reu3btk08+ef/99z0W5XnwwQfHVKonQKQF4oIglJWV1dbWrly5Ui6X8zy/a9eusrIyBOJDAkkpADDqlEoljcLpPfR0rc3IDMRvrGwvu7ULlKaGj/qaDzzPf/jhhx6L8ixYsGDWrFm4FxMg7APxTz/9tLOzk0bhhBCGYVauXLlmzRqHwxHB666NDCSlAECIcDgcRUVFZrOZPtTr9ZGXID5UK9v/odURIqnhFy9efP/9970TwRMTE3EvJkCEBOIqlYoQ0tbWlpGRQffQ+68jcn7ZkST0XUdSCgCEiKKiIkJIY2Pj7NmzT548WV1dHXnJKuLK9oqs7KAP0t759Ya3TtCu+w/LHxyVC+nr6zt//rzHojxz5sz58Y9/jHsxASInEBe7YJ1Ol5mZqdfrFy1atGvXLrPZrNPpenp6cMvmrXix8VP6y+a6RfcgKQUARpHD4TCbzRzH0WRitVo9e/ZsjUazY8eOSEovFle2n5CUGGQof0148rX/odtvrk4f7No9QxKCey/Kk5WVpdVqcS8mQKQF4h7Th9fX19fX19Nts9nscrlw/0fQ2ju/FtdDXpySiAYBABhul/+0mxAS+2Rh0Eco+uP/owMov3si5c64mJGsPF2UxyMRHIvyAERyII7pw4eJ0HddHFPZ+kQKGgQARpdarWZZtqio6JlnnklMTDx//vzGjRv1en0kjbZc6zj/XfyamRngSySLzz9ICPn5+lfbhLsIIY9q7xjJAZTLly8fOnTIIxE8IyMDi/IARHggDsNETEr53RMptyui0SAAMOp279797LPPZt4IUnU6XWVlZSRdIHe4mW58LznQe3LGjx//q/L1O947Q8yfEUJoFK5URP+ffO3I1Pns2bOHDx8+c+aMuGfatGlZWVlIBAcYW4E4z/NHjhyprq4Wb6gnhNjtdsyaEgQkpQBACEpOTn7nnXfo2m0pKSmRl3l49dC7ZPAr2z/+SuvfL16V7hmO1HCadkK329raWJb97LPPLBYLFuUBQCBOCCGLFy8+fvz4nDlz9Hq9y+WiN2tG2LRWIwNJKQAQyhiGESfIiiTBrWzf3vm1RxROCLn49bdDnh1eU1PD8zzdPnDgwF//+ldpamhWVhYSwQHGbiBOI2+O4xoaGrq6uoqLiy0WS15eXnQ0cioGDUkpAAAj7xur9btvGoNZ2b6986r3zo5/fPPAkNbt7NmzYhT+3dcGt5vcWJQHieAAkSrQX9ZOnTpFCKE/U9LfzlJTUzs7Ozs6OtCIg4KkFACAUcF/8AHdGNTK9kmTbwtwZ3D6+vrOnj175MgR76fmzp373HPPsSyLKBwgUgU6Ip6YmEgIEQQhPT29rKzMZrPZbDZCCFJTBgVJKQAwRshkMulDvV4/6gsDBbeyfcqdkyeMH3et77q4Z4piwgPquFusDF2O58SJE3R1PJ/uvvtuvJEAEIgTQohardbr9R0dHWq1Ojs7m2VZQojRaMQk4oOCpBQAGCPsdvt34e/VqyzLpqenj259hK6u4Fa2N7WdlUbh/56uXvPT6cMRf8vlckEQxIfx8fGYFwUg8scsgpsm3OVykdAbDpfJZKE86/m5ru6HfttMCMmYPsX0dCrefAAwFjQ1NeXm5jqdzkD+yxi+bpw7cuTc/1pJCLnbbA58TU2x31YqoukwiuM3uUMbf6empt57772JiYnffvvte++9RwtkZWU9+OCDGOoCiHiDm0eczml16NChefPmpaYilBwEoe960R8/otu/WZKMBgGAMaK6ujoUptiiK9uPnzIl8Chc2m+/uTqdRuRDHn+L+d8MwyxcuFAMxPHOAUAgfpO6ujq63L1KpdqwYQMhxGQyGQwGNGIgTG1n6a33FY/eO8JLIgMAjBY641ZLS0t/BTxSyYcPXdl+0sJ/HYF+e1DxNwAgEA9gYEAQysrKamtrV65cKZfLeZ7ftWtXWVkZAvFAnOvq3vDWCULILNXEglTk/AHAWLF9+3aVSuXnF1SPRJRhisuDWNk+iH772rVrDofjb3/7m3QVTMTfADAEgfinn37a2dlJo3BCCMMwK1euXLNmjcPhwMqaA3yHkfy4uWPZA0O+GBsAQCgH4qtWrZLL5aNbDXFl+5gHHxzyfhvxNwAMeyCuUqkIIW1tbeJya/QXt6SkJDSif0hKAYCxyWKxdHZ2Llu2bNRrIq5sPy4moE7Yo9+mqSb/EvU5IeTs2bM0sO4v/lYoFA888MA999wzZcoUxN8AMDSBeExMjE6ny8zM1Ov1ixYt2rVrF13ifs+ePYSQu+66KyLXQ751SEoBgDHrlVdeYVl21H81HezK9t799ptvvnnixIlp4wkh5PXXX586dSrDMP3F31OnTsWfHgCGOBCnN9wQQurr6+vr6+lOs9lMd+r1egTi3pCUAgBjWWVlZSjMciuubD9RNz+Ifvvy5csnTpyQlrl48SLibwAY0UBcrVaH8hTdoQlJKQAwloXIHUTiyvbRd08Lot8+d+6cd7Ho6Oi0tDTE3wAwQoE4DBaSUgAAQsHl+j+TwFa299lvT5482bvk0qVLZ86cibYFgFs0iGQJnuebmprmz58vk3A4HGhEb0hKAQAIid64q6vvq68IIZOXLAmu375+/bp34bvvvhttCwC3bhAj4osXLz5+/PicOXP0ej1NGQ+FxdJC037bBSSlAACMum9tNrpx2333+S/pM5mQ5/m9e/dKi8XHxy9duhTToQDAiAbiNPLmOK6hoaGrq6u4uNhiseTl5UVHR6MRPVzien7x56OEEKUiGkkpAACj6Mpbb5MAVrb3mZTC8/z27ds5jiOEGAyGR14/GSW7fnz1ErQqjClYMWZYBZoycerUKUIIwzCEkNbWVkJIampqZ2dnR0fHgK8VBEEQhODK8Dwfdm1q/PNRuvGnp3+MpBQAgFH0dWMjGWhle59JKX19ffv27aNR+Ce9dyx4/bMeEsW5o9W/blT/uvHba8LQ1rOvr2/jxo0bN26kD+l2b28v/oIwwlwul8ei6RqNBs0yfAIdEU9MTKThcnp6ellZmc1ms9lshBD/qSmCIOzZs6esrIwQsnfvXp9THPZXxmazbd68ub6+nmXZV199NVymR/zL0fOW018RQv49XT1LNQnvMACA0fLt30/RDf8r23snpfT19ZlMJjpTeFZW1sasLBoci/8OufHjxw/TkQEGhef5+vr6uro6cY/dbkezDJ9Ax2vVarVer+/o6FCr1dnZ2SzLFhQUGI1GOkben8rKyrKysoMHD1ZVVWVmZjY1NQVeprCwkBDCcdyrr76amZlpu5HnF8qkSSnrc+/B2wsAYBR1f/g/dMPPyvY+k1Lef/99GoVPmzbtoYceQktCZGhqatJqtTKZbNOmTS6XixDicDhkMpnBYJDJZFqt1mazlZeXE0LohBz0VXREXFoyISHBZrPR2TsMBgPP8/RZQoggCOK2/5fgzzG4QJwQUldXR5OE6urqnE6n0+msqanx/5J9+/ZVVVUlJycbDAa9Xv/RRx8FWMblclmt1rVr1zIMk5GRodPpjhw5EvqtiaQUAIDQMeDK9j6TUg4fPnz48GEahRcUFOC+TIgMgiDk5uZu3ryZ47j29vbt27eLTymVSo7jioqKCgsLKysrCSFut9vn6jGzZs3iOC4/P59l2eXLl3Mcd+LEiaNHj4oF5F6ThA74EgTiwVAqlQPOl8LzvNVqTU5Opg/T09P37dsXRBmqoaEhxJsSSSkAAKHjenf3gCvbeyelnDp1ikbhCoUCs6PAyOOv8bIKWeDbwnXB57a3trY2lUqVk5PDMMwzzzwjDcRLS0sZhlm+fLnVar106ZKf6pWVlTEMk5+fr1KpDAYDwzBLly7ds2fP0L4EgbhvdXV19IcMyuFwSFOIvNHCEydOpA/j4uKsN9YZHrCMUqlkWfbZZ5+12Wx1dXVms9lsNnufQnazUWxHJKUAAISUb9vb6UZ/K9t7J6WcPXuW/r+mUChWrVrlP/cSYDgwExj3Bnfg2/Jxcp/b3q5cuRIfH0+3J026abiQvtXpPHjffPONv+oxDCEkMTExOzub7pk+fbo0OCSEXL05amvhAAAgAElEQVR6dbAvQSA+MIfDUVBQECP5dY9hmIKCAj9NSYfMpX8PlmUDL7N79+7Zs2ezLFtWVqZSqXQ6nfcp3DcbxXZEUgoAQEjxv7K9d1IKz/Ovv/463ZOfn48oHCLM3LlzrVarw+EQBOG1117Lz88Xn3rjjTfIjSHzn/zkJ+TGOGngkpKSCCE2m40eHK099IH4+fPnxa810hjaT7o9wzAsy4o3We7fvz8rKyvwMsnJyTU1NW63+8KFC/Hx8cuXLw/ZRkRSCgBAqKEr20/KzfW5sr1HUgqdMpw+9dRTT/3gB1gCAiINwzC1tbVpaWlRUVEnT54sLS0Vn2poaEhISMjLy9u5c6dcLq+trY2Pjx9UooFcLq+oqGBZlh4crR04WYADyTzPKxQKu90uTupus9lYluU4zs+wQUlJyeHDhxsaGk6ePLlixYqdO3fm5OQQQrZt20YIKS4u9lPG4XAkJSX19PRUVVVt2LDB6XQOmJUuk8lGflz8EtfzoxfNhBClIvqDtT/FcDgAQPD/Jw1RNy50dX2WnkEIuePll7//yCKPZ891dT/022ZCyCzVxP1rMmXE/fvf//7ixYuEkKysLO8xI2pYpy8EGBmCIFy+fFkMqBwOh0ajcbvdNOgSb7UUBIFOlEduLOgj3SM9CM/z3d3d0u3Y2FhaMpCXQKBRI8Mwer2+qKjIYrE4HI6mpqbCwsJApi9cunSpRqNZsWJFVVXVggXf3THT2tpKVwXyU6a8vDwqKkqhULS3t1ut1pD9g1W8/d03PySlAACECHFleyYj3TMQuTkpRUbcJpNpwCgcIDLI5XKfAZVarZZOeCKXy8WBV7oh3SM9CMMwHttiyUBeAoMYe3A4HEVFReJNk0ajcf369YE0Jc/z0dHR0j8wzT2Svta7DD3joP5aIz8i/m6786n//pAQ8qj2jq36+/B+AgC4pf+ThqgbP1/23NeNjeOnTJnZ8r7HU39oddB7NCsevfff0tUHDhxoa2sjhEybNm3ZsmV+jokRcYg80kFrCPVAXIyYjx49mpKSEoI3soxwIN59TZj728MurkepiD7yq6yYCXK8nwAAQqEb/3TWPYSQ2CcLVevWSfd7JKW0vP/egFOG9/X1/ed//qfHzv/4j//AzIYAcOsGHTvSFXbQcISQX++zubgeQsiWPBZROABAiBBXtp+0cKF0v0dSyskTx8Upw5944on+AmsE3AAQQoE4UO+2O9869iUh5FHtHT+dFY8GAQAYeXTkW+oOS2vfjZXtvzdrlvQp6Uwpbu6rN998k9yYMnzChAl+zoJ0FABAIB5Cuq8Jz++1EkKUiujfLE1GgwAAjIp72j8Vw3G6TQg5s+f/Eq+V7aXL9+T8cNIrtVvp/ieffBJThgMAAvFwgqQUAIDQdL27u+fUKULI5PyfiTulSSlbfzb7D7u+W7jnqaeemjp1KhoNQp/3zzLPPfecQqEI/AgjcF8mnehwuF8SYQY93Z7L5bJYLIQQnufH5gqlSEoBAAhZ4sr2MQ/+WNwpJqVsWHTPW/X/zXEcIWTJkiVYuAfCKBAXY3G6PagonBDS0dGh0WiCOLXL5TIYDIGUDOL4wVVpqAR+aSERiDc1NWm12vj4+FdeeYUQcuTIEe8l6yMeklIAAELZ1wcO0A1xZXsxKeWHUxXk8xYahWdlZY3B/8IgrJ09e5ZutLW1Xbt2bcTOy/N8fX19ICXtdnt4NWnglxYSgfjatWuLiopaWlrowwULFnR2djocjjH1MUBSCgBAaAfifyWSle2lSSk5E899YT9DCJkzZw4W7oHw0tbW9vrr36VUHThwoKamJrhY3GAwyGQyrVZru7Holc1mmz9/vkwmMxgMDodDEAT6UCaTlZSUEELKy8sJIXSP9FDeJenwtsPhkMlkmzZt8jhRXV1dQkKCTCajr/KomEc1pE/RA3rUXKvV0lNv2rRJEASPYnV1dd4H9K5Yf5cWioG4zWazWq0rV65MTEykezwW3xkLPnJ0ISkFACBkCV1dfV99RQhR3IizxaSUwnsmXO44TQiZNm3a448/jraCMNLX1/fee+9J9/A8334jC2tQlEolx3FFRUWFhYU0mGZZtrS0tLe3Nz09vbq6+uDBg06ns7e31+12r1+/nhBSWVlJCHG73R5z/HuX9MBx3NKlSzdv3kwrXFBQsHfvXvqTlOcn16saA9Z89+7dbreb47h9+/bRNbmkxZYsWeLngGLF+ru0kRTo0gk8zysUCo7jXC5XeXk5/arBsmxvb2/oROTDuqCP0Hc9bfO7dDj85KaHMRwOABAi3bg4a8qVt/d/+ctfEkJmtFrkcXHi8j0/mDQ+q+dv42REoVCUlpZianAITUM1UabP4zgcDo1GY7fb1Wo1DeqcTuepU6cyMzNNJhMh5PTp0xs2bPj444/vv/9+o9GYn59P142hL/T+YNI4UFqSfn5peafTqVQqxdc2NTWtXbv22LFjhJCmpqbc3Fx6QPoSi8XiUQ1peNlfzQ8dOtTe3n7ixImsrKyamhrpeX0ekGbJSytmt9t9XtpICnREnGEYvV5fVFTU2tpK79csLCysqKgYO+PiLzZ+SqPw3z2RgigcACAEcYcPE0LGT5kij4uTJqU8+O3HNApftWoVonAYy+hkndHR0YQQnuevXLkiPjV9+nSTyTRz5kyn0zljxoy8vDytVuvnUMnJyX5KKpXKwGvlXY2enh4/NT979mxmZuYDDzxQWVl57733SucOoef1c8BBVWwEDCKgrKysLCoqKigoIISYzWaj0bhq1aox8sZt7/z6v1sdhJCM6VMWpyTikwwAEGrcgvB1YyMhZNLCfyWSpJRU+RcTx10jhKxYsQJThkMo8zMivnfv3uPHj0v3lJSUxMbGDvYUb7zxRnFxcVtbm0qlUqvVNCpNTk5OTk4mhNCINjY2tri4eNGiRRqNRhCEpKQk+pRHCMvzvEdJP+edO3eu1Wq1WCwpKSnemSdz5871qIb3R1Va84sXL7Ism5OTw/N8c3NzdnZ2IAf0nuuvv0sbSYGOiLtcrtbW1nfeeYfjuJaWFo7jampqQu1bxTAR+q4/+dp367RtfSIFPQUAQAjq+fwM3Zi0cKE4U8rt47/94XgnIeSpp54KImoBCBELFy5MTU2l2wzDLFmyJLj3c0NDQ0JCQl5e3s6dO+mhGhsbCwsLtVptQkICy7INDQ1RUVEGg0Gj0dTW1srlcrlcXltbGx8f73FHo3dJP+dlGMZkMuXl5dHEEpVK5fGsRzX813zBggVOpzMhIUGhUMyZM8fn6QY8ICGkv0sbSYFm49Fsm9FNoxn4YoYnR3zjWyfocPjvnkjBcDgAwKC4XK6YmJgAh6JvJUd86vp1F198iRBy94cfPrrzYzocvnTCsYnjrhkMhpkzZ+JvAeGODpkHl0ouLujjcDiSkpI84mY6rwhdW8flcvE871HG53pAHiXp6jzSkh7bNPYtKSm5/fbbX3jhBeK1oI+0GtKdNJPbo+YOh4OOCHd3dyuVSp81lB7QT8WGe6mjIQjEXS5XfHx8S0sLzccfO4F4e+fX//q79wkhGdOnmJ5ORS8AABAgh8NRXl5Op+k1mUyBLJxxK4F49MyZPadOxaSlHS56gQ6Hp8q/uEfuzMrKwmSFEBkhuP89IY72AM3NzfHx8Q0NDYEHvv3dLRoZAs0Rj4mJ0el0mZmZRqNR/HGEEPLYY49FcModklIAIDjXu7v/fv+PPHbe0/7p2GkB+jtqRUUFnW5rBM5IV7YX0h6iUXisrPuH452pqamIwiEicRw32MU1R9eOHTtorvZgE5uTkpLCbqmgwAU69kC/jnjvp7PJhMrFDPWIOJJSACBodJh2zAbidIGPmpqaEejGpU3925+90Nw7iRCydMIx7fSkgoICTJMCACEr0Js11Wq125fQicKHHGZKAYBbIQ2772n/dExF4YSQrVu3njx5UqvVarXabdu2+Z9RYQjRKDxV/sX0hFhE4QAQ4jAftm9ISgEPbkFon5PsJ9ICABG9Qer48eNVVVWTJ09esWJFV1cXvTdrWB1OTCGExMq6f/T97mXLMGU4AIS6cYEX5Xm+qalp/vz5Mgna20aeV5pPi8v33K6IxhsFZHK5dFBzDA5wwqB8Ouseab6Ex8OIR2fnXbVqlcFgyMnJWbdu3fbt231/sm4W3OlcMRPpxrt3/ogQ8sjkL59ZvQpThgNA6BvEiPjixYuPHz8+Z84cvV7vcrnMZrNOp4vIqcTPdXVXmz8jhMxSTURSCgDAoP9rkct1Ol1cXBx9GBcX19nZKQiC90zDHhnhg43Fz546Y/lFeUr3VfrwG/mEVPkXT+sfRxQOEUb960aPPR+tnzdF8b3Aj9DfJH0eEwje+gGDKzZmDW76Qo7jGhoaurq6iouLLRZLXl7euXPnQmeV+yG5WVPou76otoVOQPv+r7LvjIsZa+8Jn+N2GP1Fs4wwoavrevc34sNxMbfJb0R1Hk9JTUj67pvztY7z33zyic8yE+f9dFxMjJ8y185+EavX09MJXV0XX6r0eZzYAkPM/fd7l6GLO/o0pt4wmzZt2rdvn9lsjomJSU9Pz8rKCuTGzcF24wd/nHXn1xdv+vPVvaG9n8UnCCI4HHf8JjeI1/Y3CWDQsVOAswpG9uSDQzBsEWC5U6dOEULoGENra2txcXFqampnZ2fkfcsRV0WuePTeMRiFQwi61nE+iEj0ene30HVZcF7sPf/lYCNRaZkgIlGxkt0ffHDHyy9//5FFfr7MEEIm5eYmVv1vun3m0cfoJHR+ylx8qbK/YFeMdL/55JMvf/lLn2XuNpsnxMT4L/P9xxaTONqM3/R3LkVWFrn/fv9lxrKysjJCSHx8PCFEp9OtX79+yE9h/tObHlE4IeTU24cQiENEau/8mm785ej5BbOnxkzAbX5jKRBPTEwkhAiCkJ6eXlZWZrPZbDYbISSsU1O8f+h5/1fZdALaWaqJBak/GJvvCRrKiDHTGBnD8w5to1RTZXI5jWivHnrX56u6P/7YTyTqEa0GGIkGUiaQSPTqoXdvJRIVy4xwJBo9Y4bPQHy0jIu5bVKu78GnqMQ7/JRBaM4wzAsvvEDD8WFKFLl85gvv3MGeEyfxXztEnr8cPf+LPx+l27/489HbmQnvP58dRCxuMBjq6+tZlt29e3dy8k0zENhstmeffdZsNuv1+srKSkKIRqOpqKjYsGGDtHxdXV1ZWVlnZ6dOp+vvtWq12mcxKa1Wa7VaCSEVFRXl5eVlZWXicps2m41l2d7eXrlc7rNWer2+vr6eLhPmcRy5XC49tdlspoPx3jUMs0BcrVbr9Xo6/p2dnc2yLCHEaDRGWB7eij98SDd2LHtAPn4cPvmhjI4T3xRMOy/2nv9SHH/99u+nek6d4g4f9o6579r1Ot2+8vZ+f5FoUiIhROi63F+Z3vNfDhiJitFqgMZPmdL31Veh1trjp0xhUlMHFYl6lCGE3PHyywOWiS0wKLyWX7ntvvukD6euK1eWlvqv8MR5P73bbCaEyONi6dC+t+8/skh8t/TbRcbFid9/BlUGgbgYjg/fwVP1j/H1v/fYqXpkIZodIm2oqO/6i/tv+oZ5ib928OTFIG5jUyqVHMft2rWrsLDw2LFj/zyFILAs29jYeODAgf/6r/+qrq4uvdHNchxXVVW1efPmuro6nucLCgpaWlpSUlIWL17c32srKyu9i3mgkT3P8+np6fPmzcvPz8/Ly6OR9GuvvWY0GuVyeX+1olcRHR3tfZyUlJRAajjYJQ6GzyByxN955x1xgWK6TFqoDYcHl+ckZlz9odVBh8MrHr3339LVY/YDP6zJ0B7R87XPT/d9fZWGYuKw8fmy5zxexbe19X31lXRI+HzZcwMOCQcSZAdS5lrH+c/7+UJ/V51pUCPi58ueU/ha5E96+d0ff+ydTOJRJvDUlJuOcGOMH8L9cxTBBtuN1+c8kXLmn8HEP6IVacc+RDNCmPL+oT44PpPIaa42XYeR53mFQuF0OpVKJf3Q0aVwTSYTIeT06dMbNmz47LPPZsyYQcuIed4Wi2X16tU0gm9qasrNzfX52sOHDxuNRo9iHvWxWCyHDh1qb28/ceIEvYckISFh7969qampUVFRVqs1OTnZf618Hufhhx9eu3btgDWkw+2h8EcfRI54QUGBGIhH3mQp57q6kZQyYAB9nec90gZuu+++G8PG/d6vJs0S7i+inZSbK40yuz/4wLtMz2efBVf56Jkzo2fMkO4ZF3ObWH9xmHb8pIkT7p4uDVvF0Pae9k99xlVinQMZNyWEBFIm5v77BxxBl8fFkbgBjjMuJmZCDG5yGDVjM8Vr5D2+d1fLvgN9W2tkxH1l0eOP/HIl2gTAD/ojFR1L5nleDOeuXLkilpk+fbrJZLp27Zp3vCct5nMnfe2lS5f8V8PlcmVmZjY2Ni5btqy8vJwO765ateqVV165cuWKSqWiaTAD1srncQKpYU9PT5gF4jNnzqRfOzIyMiLyrVn0x4/oxlhLSqHjpvSOvW+sx/puHkMV9RdA3/HyyzQQH8IsYXlcnHeew/i42NtYrfiQJjBEz5w5rv8fvgNJPJiQlCgOIQNA2PlezG26J5d8+tI6QsiCDaVoEAhrfqZDMdZ/8taxm34s/esvHpqlmjTYU7zxxhvFxcVtbW0qlUqaJz137lxCSHJyMo2AXS4Xz/PeL587d67VanU4HElJSbt37+7vtTExMUuXLvUoJvXhhx+yLJuTk8PzfHNzc3Z2Ng3E4+PjT5w4sW7dugBr5X0cWkOLxZKSklJdXd3fcUInszrQQDwmJkan02VmZhqNxlRJquhjjz0Wvmnil7ieire/S7qK1JlS3ILQ23mR3EgCuXb2i2tn7ISQqevK6RQcfm7pG5QJSYke0fNt96WM//5kcnMGME3bvTns9kzhHaph46EljmjSMU4McMKAX3H/fv+PxId42wDArdjwyGxCCI3FpygmrF80O4gonBDS0NDw0ksvEUJ27twp3c8wTGNjY2FhISHE6XQSQj7w9dM0wzAVFRUajYYQIt6F6f3aCxcueBeTWrBgwYoVKxISEqR3cyqVSpZlrVbrz3/+8wBr5X0chmFMJlNeXl5nZyfLsiqVqr8ahshfNtBsPJoe5L2fJhuFysUMMrnw4er3/n7xqnRPW/lPp066Lew+nzRvRMy3FoeBg0iAjklL85kWIg2gx3iqMSIqGNRbxefXORiqbhyfShhTaBL56ZcWBvHTvbiwDh2oFhMzPBb0oSumq9Vq6UI8Hovy8Dzf3d0dGxvrMYe1+Fr/xaTlaZJJd3c33eB53uVy+Vx1yLtW/R1HEARCiFwuLykpEWdi8VnDcArEb4XYIkGU4Xk+Ojo6wDyeQfXg57q6H/pts8fOUt2MEt3MkA21BedFMSn5ytv7L+3Y4XOitxmtFjra7TMQj0lLk8fFiSPidMhcOkc1bjLzyS0I7XOS0SwACMQBRisEvyn6DGpZn7GA3tDY3NwcHx/f0NAQ4svdDO+4piAIe/bsofPI7t2712d+eX9lxBkfCSF6vX7Hjh1DmwPzmZPz3nn6xmz5I+96d7eYodH98cdfHzjQ13XZ+7ZF6f80/U23fL37G3onH5ORfsfLL0cl3iGPn0ok82nc9N+eXI4k6YDiA8w3AgAAIeMr7ttBLXE/duzYsYNmgYfFzCLDG1tUVlZu37794MGDNpuN3taak5MTYJlnn31WqVQ6nU6e59PS0qqqqqQ/Lty6n0zzMevE4w8M+3wpQlcXb2klhIjp2uI9jmKQ/fWBA5f/tLu/l9Oh66jEOybl5tI8bHG6D4+kEXlc3IB3K3rDbA/+WwYAAGCEYfw7cAzDhNHti8MbiO/bt6+qqoreprp///6PPvrIOxDvr4zZbDaZTEqlUqlUZmdnt7e3D23dYibIS3Uzqs3/nBFvimLCv8yYcivH9Lgzsu/KP7755Lt1sAJZE1F0G6u9THbTex8nTNNM+MFd5MaaJuMnfXdzRsz998eM7N2KAAAAABAegTjP83Q+dvowPT19x44dHqPafspUVFSUlZVNnjz5zJkz9fX1LS0tQ17DBcWPLbh5z2e7Bx71FNO1e89/2XflH4SQuMJC+pR9ydL+0kXEQHx8XOw/vwykpcnj4jwm5iOBzbs3fDxyxJF8CQAAABBmgTidVn3ixIn0YVxcnNVqDbzMsmXLtm/fnpubSwhhWTYlJWXEGoUuW3id56/znDjqfObRx3wG2ZNyc8mNQDx6xgyPMnQpGWnwHV9aOmXVKvHOyBCEmBsAAAAgvANxmiN/9eo/5wdkWTbAMoIgpKWl5efnV1VV9fT0LF68ePHixe+8847Hy2Uy2ZBXWzoeLF3usT98W5u4HVtgiC0w+LkzkhAyLiZmHNY7BAAAgKCCE2qGpUV+++2hVs/+phcMeuoSnwf0HY9Jpj6k47zB3ax5K7UNrUCcYRiWZW02G8082b9/f1ZWVoBlOjo6Ojs7S0tL5XK5XC5fvnx5QUGB9yk8ZrkajrhcNDn/Z4QQP3dGEsmC5wAAAABDRTqPQij/cN3R0aHRaDzCM+89t3hAb9u2bVuzZo1er6+rq0tISIiPjy8qKiouLg7ijLdS29AKxAkhWVlZW7ZsSU9PP3nyZHNzs7iM07Zt2wghtIF8llGr1SqVqrq6urKykhCyZcsWo9E4Mi1yx8svkxt3RsolKSViIjgAAADACKO3qBFCuCNHmIyMMJpU1263D/cpXnrpJXrPIV2y59ixY6FcW6lxw3r0ysrKpUuXajSaFStWVFVVLVjw3b2Rra2tra2t/svs3Llzz549CoVCoVAQQkpLS0emReiNkhOSEickJSKHBAAAAEbdlbf3i8tgn/tfKz/7l7nXu7sHdQSHwyGTyQwGg0wmq6urs9ls8+fPp3to8EoIEXfKZDKa3dHU1KTVamUy2aZNm1wul/QgCQkJ0oPwPC+eixbQarU2m40QQpdmp6/dtGmT9CnpSaU1oQPbMpmsqKjI+1o8aiWTyeiC9jKZTKPRdHZ20msUBEG8nJKSEmnlxQp4NAutbX9VFWtFDxsGgTjDMC+88ALHcefOnTMYDOICmTU1NTU1Nf7L5OTkXLhwwel0chx37NixEF8YCQAAAGCYXPzNb6QP+7q6rh56N4jjKJVKjuOWLFnCsmxpaWlvb296enp1dTUhRBAElmUfe+yx3t5ejuNiYmIEQcjNzd28eTPHce3t7du3b6cHmTVrFsdx+fn5LMsuX76c47gTJ04cPXrU4yxFRUWFvrIJOI5bunTp5s2bxZN61ITn+YKCgr1793Kcj7UXvWtFM0nsdrvb7bbb7Xq93u12GwyGgwcPOp3O3t5et9u9fv16P3WjO/Pz8/1U1X+tgiYbyTyY4Ya1kQEA0I0DhCnvOzKD4/Oz4HA4NBqN0+lUKpUWiyUzM9NkMhFCTp8+vWHDht7e3ra2try8vAsXLogvsVgs4h66/cEHH2g0Go7jGIaRPrtp06ZLly7V1NTQs9jtdrVazfO8QqFwOp3x8fFut1taAbrtdrv7q8nq1atpeklTU1Nubq60W/Cu1YULF2QyGT2pw+EoLy+nY9s2m41lWaPRmJ+fn5GR4bNuPM+LtRJ7Ibvd7l3VpqamtWvX9leroI3D+x4AAABgLKDh5pUrV8Q906dPN5lMPT09V65ciY+PlxaW7pl0Yz1BQghdtzIxMTE7O1s8CE1lkRaIjo4mhEhTVojXTCb91cTPJfRXK2/JyclOp3PGjBl5eXlardZP3XzOrxLcpCuDJR/Lb0fpV08MqAAAoBsHGEV+3r3ny57zWJZb09DwvR/ODO5Ec+fOpXEqnbPO5XIxDDN37lyr1UonshMEgRazWq0OhyMpKem1117zztzozxtvvFFcXNzW1qZSqfynFvupCT3v7t27vV8SYK14no+NjS0uLl60aJFGo6EX5VE3MSs9kEazWq0WiyUlJYWm0AwJjIjf5Pq336IRAADC15VLl9EIEHmmriuPSUuj2+Pj4qauXxd0FE4IYRimsbGxsLBQq9UmJCTQJVzozgULFmi12qioqI6ODoZhamtr09LSoqKiTp48Gfi0GQ0NDQkJCXl5eeJ0eYOtSUVFhUajiYqKkg60iy8JsFYNDQ1RUVEGg0Gj0dTW1tK7EAOvm/d5TSZTXl4ezWlRqVRD8pdFjjgAAKAbBwgD9GefWcdtQcxd2N9SO4QQ750Mw4iJGYIgXL58mT6UHkS6n+f57u5upVIpFqAj1jT2pUvkeLzWozLeNaHHjI2N9bmgj/Ts9OX0dB77XS4Xz/P0KTHbW1o3nzVJSkryWVU6pi6Xy0tKSm6//fYXXngBgTh6cAAABOIAYyIEl0IW1mCJgXjQRzAYDISQ5ubm+Pj4hoaGIZnQD4E4AACgGwcIs0A8NJe4D2U+fxMYFJ7naRb7EN7HiUAcAADQjQMAjALcrAkAAAAAgEAcAAAAAACBOAAAAAAAIBAHAAAAAEAgDgAAAAAACMQBAAAAABCIAwAAAAAAAnEAAAAAgNAjj7Drkclk+KMCQGQYm0vboBsHgLHTjWMNs+/6fbQDmgXNAnjDwIDfECLjrxlh1xIxHzFcyxi8FqSmAAAAAACMAgTiAAAAAAAIxAEAAAAAEIgDAAAAAAAC8WHU29uLRkCzoFkAbxjww+12R8xfs7e3N2JupIukjxiuZQxeC27nBwAAAAAYBRgRBwAAAABAIA4AAAAAgEAcxixBEFwuF9rBu1kcDgfaAQC9IoQOl8vF83wEXAjP84IgRORnJzKua5g6gTEdiG/btk2r1cpkMoPBgL5M7Ajmz58fFRUVHx+fkJCwbds2tAmVkJAQFRWl0WgSEhJKSkoisruEIWQwGGQS+AqHXjHUglf6zgzrq3A4HAaDIT4+XqFQ1NXVhe+F2Gy2+fPnKxSKqKgog8EQdt8r+oumBEGoq6u7884777zzTovFEr7XMqydwIKESsQAAAlLSURBVFgfEX/++edZlsX/NKLu7u6HHnrIarU6nc5169atWbMGAQS1c+dOu93OcdzOnTu3bt3a1taGNgH/Kioq7DckJSWhQdArhtQXRZVKFdaXYLFYNBrNrFmzOI6z2+3p6enhey3PPvusUql0Op12u725ubmqqioyoqnKysqysrKDBw9WVVVlZmY2NTWF6bUMbyfgHvP0er1er0c7+EQIqa2tRTt4UKlUFRUVaAfw37GYTCa0A3rFEGQymVQqVW1tbVjHAEaj0Wg0RsybSuwuwjcm8a45y7LS6wqj/zf9/xWGthNAjjj4++2SEDJt2jQ0hTgAU1dXR3+uWrZsGRoE/CsoKJDJZCUlJeHymyyMhV7R5XIVFBQcPHgwLi4urP8WW7duPXnypFar1Wq127ZtC+t0wYqKirKysqampm3bttXX1z/zzDMR8GHhed5qtSYnJ9OH6enp+/btQyfgDYE4+CYIgk6n0+l0OTk5aA3qk08+2bJlS319fXZ2tlKpRIOAH4sWLbJarS0tLS6XKzMzEyle6BVDhMFgMBqNYngUpugH6vjx488///zmzZtfeumlysrK8L0cOrKTm5u7Zs0almVTUlIiJmCdOHEifRgXF2e1WtEJIBCHQN9qCxcudDqdf/nLX9AaouLi4mPHjjmdzjDN4YMRDneSk5MzMjLq6upUKtUf//hHtAl6xVFnsVjMZvPTTz/tcDhOnz5NI9pwHEumN12sWrXKYDDk5OSsW7du+/bt4fvWSktLy8/P7+3t5TguPj5+8eLFEfCRocNVV69eFfeE+y15w9QJIBAH32+148ePW61WhmHQIN6dS35+fmT8xAYjY86cOZcuXUI7oFccdV988QWNhzQazYYNGwghGo2mo6Mj7C5ELpfrdDoxuyYuLq6zszNMs1M6Ojo6OztLS0vlcjnDMMuXLzebzRHwqWEYhmVZm81GH+7fvz8rKwudAALxm/A873A4XC6Xy+WiG/j/hr7VzGbzzp07xfZBs/A8b7FY6GSoNptt69atzz//PJoFBnzD8Dzf1NRkNpvz8/PRLOgVR53BYJDeskkIcbvdarU6HK/loYce2rFjB51EfMuWLUajUS6Xh+OFqNVqlUpVXV3N87x4LZERTWVlZW3ZssXhcDQ1NTU3Nz/88MNhei3D2wmM5ZvfaTckwtwpbrfbbrd7vEPQLN7NYjQae3t70SwQyBsGc+ygVwzl/wHDt/4cx1VUVNC/iE6nczqd4XstjY2N4mySLMva7fbIiKbEv5FKpTKZTGHx/6bPaxnWTkBG52EZs6NW0u80DMPgDjxBEDx+pkSzeLRMmI4eAd4wgF7R+3/AcH9/0rVvIiOL0uVyxcTEhOO1+I+meJ6Pjo4Ol98rfF7LsHYCYzoQBwAAAAAYLbhZEwAAAAAAgTgAAAAAAAJxAAAAAABAIA4AAAAAgEAcAAAAAAAQiAMAAAAAIBAHAAAAAAAE4jAmyWSyurq64T4Lz/ObNm1KSEiQyWSje70Oh4MubAEAgG4c3TggEAeIfEeOHNm+ffvBgwe9178dYRqNpqGhAX8RAAB044BAHGBwYwA8z9tsNulggDg2IAiCIAgOh0MQBHG/y+Wy2WziOrQOh8NisXgfnBajL5Sip/Ouhsvlslgs0uVtPco4HA7pwaurq+fMmTNx4kSPRYmllfQ+O62tx1l8VqC/eno0Fy1/+vRpaQ1dLldTUxOGWAAA3Ti6cQhdboBRRQjR6XTiG9JkMon7xW06UGG3232WFx+yLMtxnPdhVSqV9FB6vV4s39jY6F1eLCyyWq0sy9JndTodrYl4HEKIXq/v76KkZ/d4lU6n81lhk8kUSD3FqkqPST/UtIxYZ7zNAADdOLpxCMWPD5oARr0Hp71zb29vRUWFSqUasAcXy9Oey2g0chzndDoJIS0tLdLDtrS09Pb21tbWEkJoX6nT6fR6PcdxdD/Lsh7lfVZSfBXHcTqdTqfTid2xR9/t/+z0Wnp7e91uN8dxKpVK2jVLK+C/nv6bizYFbS56RrzNAADdOLpxQCAO4KOzMxqN0p7a6XT678HF8o2NjYQQq9Uq9noVFRXiYcW+tbe3l3aOHMeJAxV2u72lpUV6OvGwHuirxL6VnpT2yH56cO+zi8/a7XaTyUQHgcT/DKQVCLCe/TUXfbnRaBRbBgAA3Ti6cQhBciTnwKhLTU31yPxTKpWBlJ89ezYhJDk5mT5UKpXt7e1isUWLFtENuVyuUqkOHTpEH+7atWv//v3ib5GnTp2ip/Oohujo0aOEkMTEROlJXS6XR0KhB++zZ2RkEEIMBkNzc3N2dnZ6erpSqayvr/e+LnrGAOvp3VwMw7S0tKxevXrr1q0qlWrnzp05OTl4mwEAunF04xBqEIhDiFKpVOL2yZMngzjCrl27DAYD7eM6OzvnzZuXkpJCCNm4cSPtTANEX3X+/Hm1Wi1WJikpabBnp/1+fX291Wql/+v0d4N8cPWUysjIOHbsmMvlevHFF3NzczmO8///DQAAunF04zDyMGsKhKj8/PwtW7bwPO9wONauXRvEEcxms8ViEQRh165ddASCYRij0bh69Wp6D7sgCE1NTQPejc4wjE6n27hxI72Zvbq6Wq/Xy+XywZ5dfIreg2+xWMxmc39nHGw9jUbj/v37aRmHw0FfqFQqZ8yYgfcSAKAbRzcOoQkj4hCinn766cOHDysUCnLzDeaB0+l0mZmZ5MYN77TPXb9+/e233y7eh65SqaxW64DDDDt27CgvL9doNIQQvV5fU1MT3NmVSqXRaCwoKCgoKFCpVDqdrr9OfLD1zM/PX716NW0uk8lUUFAgPmUymTCOAgDoxtGNQwiSiTfwAowKh8OhVCppFyMIQkdHR1JSkjhQQZ+Njo4W93uXpz81khvzsNJMO+kLxQIi+kJCiPiU9LD9oQMV0jLSM970uZLJTCZTfn6+z7PTiWaTkpJ6enpcLhct4LMC/uvp3Vz0yGq1mm5IXwgAgG4c3TggEAcYA58rmcxkMtHkQgAAQDcO4BNyxAGGnl6vv+uuu9AOAADoxgH8feXDiDgAAAAAwMjDiDgAAAAAAAJxAAAAAAAE4gAAAAAAgEAcAAAAAACBOAAAAAAAIBAHAAAAAEAgDgAAAAAACMQBAAAAABCIAwAAAAAAAnEAAAAAAATiAAAAAABjxv8HX3Bay+6K+QgAAAAASUVORK5CYII=", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/markdown": [ + "### Fig. 5 — rugged landscapes: risk, remedy, population structure (A-D)" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/markdown": [ + "### Fig. 6 — the composed society (A-C)" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/markdown": [ + "### Fig. 7 — model speciation at three tiers (A-F)" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABBQAAAKHCAIAAAC+X4wcAAAACXBIWXMAABDqAAAQ6gGC0wqYAAAgAElEQVR42uy9f1xTV57wfwIJAW5Q0IaGAjWx1FFrLnY7rSMwo7ZBR3RHOzLMJGGYx8fyrFiEtTz78EgdNeyUft1dxhXo0F31YacLYXV1WnYAO5CWOkvoMNqpJlZbxzGx0hJzlZ+5gZAL+f5x2jt3khADIoHk83758nVz78m55x5uzvl8Pufz+Ryey+VCAAAAAAAAAAAA9yMMugAAAAAAAAAAAFAeAAAAAAAAAAAA5QEAAAAAAAAAAFAeAAAAAAAAAAAA5QEAAAAAAAAAAFAeAAAAAAAAAAAA5QEAAAAAAAAAAACUBwAAAAAAAAAAQHkAAAAAAAAAAGDm4M9URTRNNzU1sR8zMzPFYjH0LwAEPWazuaury+2kXC6XSCQwCABASMEwzLVr14xGY3d3N0VRaWlpS5cuXbduHUEQ0DkAEDTwXC7XjFTU2tq6ZcsW9qNGozl48CD0LwAEPVqtVq1We71EkmRXVxfIDQAQChiNxtzcXIPB4Hmps7MzPT0duggAgoMZc1s6evQo92NtbS3DMNC/ABDKGAwG7oIkAADBilarJUnSq+aAELp16xZ0EQCA8vAXUBSl0+m4ZywWS3d3N/QvAIQUJpPJ5XIZDAaSJPGZkpISsCMAQHBDURR3+ZEkyZaWFqfTaTKZGhoaJBIJdBEAgPLgzqlTp9hjhUKBD9544w3oXwAIQeRyeX5+PmtH6O/vhz4BgCDmZz/7GXtcXV19+fLlrKwsPp8vlUpVKtXt27e3bdsGvQQAQcPMxDwkJCRYLBaEkEaj+eY3v8kGP9hsNnB3BoDghhvz0NLSsnLlyq6urpKSEjwmSCSS3t5e6CUACGJYGQAhZLVaIVMCAAQ3M5BtyWg0sqPGiy++uHTpUvZSU1OTSqWCXgaAEIGbNQFrDpP5QAMAEBwwDMPKACRJguYAAEHPDLgtnThxghUU5HI5QRCs59KRI0egiwEgZLFYLKdOnYKYBwAIYnp6etjjp556CjoEAEB5uA8Mw1RVVeHjgoICfLBv3z58YDAYKIqCXgaAEKGlpcVkMnV2diqVSnxm7969kDsBAIIYqVTKHjc2NoKxAABAebgPXLHg0KFDPB6Px+NxXRdqa2uhlwEgRFi5cqVUKk1PTz9+/Dh78r333oOeAYAghs2u5iYVAAAAyoMXDh8+7LsAKA8AEILY7Xb2+N69e9AhABDEsNnVsFTg5nFgNpuNRiP0EgAEDQ+UbYmmaZFIhI9JkuQ6O3J3foCtJQEgiOFmW9JoNCkpKTdu3Dh79iwbKm0ymbiODQAABBkMwzzzzDPc7AgKhWLnzp0Iobq6Op1O19DQANlTACBoeKBsS3V1deyxTqfj5lhgGEYgEODj06dPg/IAAKHAoUOH3M4oFArQHAAgyCUJPl+n05EkyaZd0ul0blvHAgAQNDyQ2xLr1uyZnY3P5xcVFeHjqqoqmqahrwEg1NBoNO+88w70AwAEPWKx+Pbt29XV1Z6XioqK0tLSoIsAIGh4ILcls9mMDwiC8EztTNM06/iYlJTE5/OhuwEg+OD+0lkxAnaHBIAQHxOGh4djYmJgNAAAUB4AAAAAAAAAAAhRwqALAAAAAAAAAAAA5QEAAAAAAAAAAFAeAAAAAAAAAAAA5QEAAAAAAAAAAFAeAAAAAAAAAAAA5QEAAAAAAAAAAFAeAAAAAAAAAAAAQHkAACDwMAzDMAz0AwAAAACA8jDz8Hg8+MsBwLygpqYmNTWVx+OpVKrJ1AatVpucnJycnKzX62EQAAAABgEAAOUBAIDQpbS0lCTJya5WVFSUlJS0tbVVVlZmZGS0trZCjwEAAADAnIUPXQAAwMOjsLAQIdTc3DxZgbNnz1ZWVsrlcrlc3tzcfPHixaysLOg3AAAAAJibwMoDAAABg6Zpg8Egl8vxx7S0tLNnz0K3AAAAAAAoDwAAAO5QFIUQiomJwR8XLVpkMBigWwAAAAAAlAcAAAB3xGIxQmh4eJg94zU6gmEY3l8CXQcAAAAAoas8QJZGAAhNCIIgSdJoNOKPzc3N69ev9yzG5/Ndfwl0HQAAAAAEs/IwWbrG6WVpBABgvkDTtNlspiiKoih8gAeEmpoaXGD9+vVHjhwxm82tra0dHR2bNm2CTgOA4AOshAAAysOU8ZquEbI0AkBw09TUJJPJdDqdTqeTyWTFxcUIoa6urq6uLnYQ2LFjh0wm27VrV2Vl5caNG6HTACDI1AbfVkKVSsV1SjSbzdBpAADKAyosLFSpVE899ZTbeTZLo0qlUiqVFy9ehD8JAAQT27ZtM3E4duwYQujYsWP4ACFEEMTBgwdtNtvt27dVKhWfD/mj5z1arZam6fnV1Mna7LXAjDyg2WyewfX2udzn/lgJNRoNO0okJSXNZUVoSroNXnp9GC1hqwVdCwha5WGyHxVkacRQFDXZ/rsAMK8hCELKAUdIi8VifMAtBmpD0KBWq7F/2hxEpVJx28Y2dbI2ey3AHrvVNiW6urreeOONGe/zB2nSQ8IfK2FKSgo7SszloaCnp0cmk/lZuKamRiQSlZWVPYyWsM3wvz0gtAAzRSB/on5maWQYRiAQBPefgabpxsZGrVYLbyQws5jN5vz8/HPnzoFoDswac9l43NjYWFFRwequ922q1wLsSbfa5kKfz50msbObm5Xw+PHjBw8e9FR+1Gp1UVFRTk5Oenr6g9+37sLnD/L1nc8+/uBteO2117jP/vD+9CC0ALNMIFce/MzSOEeEHrPZjAO+eTxeamoqmx8GB4LzeLzy8nIcDcYtqdVqjUZjZmYmPmM2m/HV8vJybj3YMoHrYRgGl+fxeNhBHACmh1arxfEGJSUl0BvArFFWVtbf348QUqlUer0+MzMzISGhpqaGjZdlGKa1tRUPdHiUo2laq9WmpqYWFxezo6tbDcXFxQzDFBcXJyQklJeXs1463DJarZa9S3l5OR6fy8vLsWsHDtPPz8/HX+E2FSF09epVz0q4Bdwe0K02rVZbXl7OlmltbfUcwGmaxoN/cXFxX18fex53SGpqamZmpl6vx3efrPfYrktNTWUdn6bdpIeNP1bCrVu3GgyGzs5OiqIyMjLmvh+OpyTgNtHjCd1isZAkqVKp8B8Xv4q4Q3zLCW638xQzuLArD1qtNiEhgcfj4aq8Chvc+yYkJHDvy/6gpiq0wIgXirhmEaVSqVQquWdIkmxoaGCvFhUV+VOPj2Y7nU7fj+m7H/DXvdaMlfuioiKbzVZdXU2SJD5vMBhcLpfNZiNJsrOz063kyMgIQqilpcXpdFZXVxcVFeGrGo3GZrNpNBrcIfgkrrClpYUkSafT6XK5rFarCwCmjtPpLCoqYnXy4HuRZnnsAqb61zGZTPhAIpFUV1e3tLRIJJKWlhZcoKioCA/+JpNJo9G4XC6FQoGHUI1GgxDC4ypbQ0NDQ0NDAz4uKirCgyT+Ijuq4zISiYQ9X1RUZDAYDAYDrtPpdFqtVjwgm0wmm83m1lSvlXAL4AP22K02LBOzvzX84G49Q5Ik9zHZCRF3SGdnJ747nkq89h6+Ke66zs5ObkdNr0kPG5vNxv2DNjQ0sLOnV7idf9/J3Uc9/+/3tx7k32TVepUEcNu4Ez33j8JetdlsSqUSP51vOcHtpp5iBncMxAe4nzs7O202m0KhYFckvAob+CSeIxoaGrg1ez7LfYWWoOQB358Hf9PmOLO08uA1XSN6CFkaH3CZ4r5f37dvH0EQO3fuNBgM+CmGhobKy8vz8/MRQqdPn2ZLHjhwgCCIjz76CCE0MDBw+vTpvr6+qqoqbDYoKCggCCIvL6+xsdHtFsnJyQaDoaSkRK/Xz52lZ2B+0d3dXVVVhSenjz76CF4kIFAUFBQUFhZmZWXl5OTU19fj6aCqquoXv/iFSqWSSqUHDx6kaVqn09XX16enpx88eFChULz99tvcGlQqlUqlwiLRsWPHsrKySktLuTFyRUVFuExlZSV7/tixYytWrIiJiXnxxRcRQteuXcM/hJUrV0qlUoIg3JrqtZL7Lp6ztcnlcpIka2trEUJ6vd5isezcudNtHjQYDE1NTfgxJRIJu+xQVVWFz6tUqoKCAnYq8ew9i8WCEFqyZIlUKk1PT3dziZlqk2YBP/dyYVm1atW9e/e8zs5zZ7MXN0mgu7vb60TPjsYSiSQrK4sgiJdffhn/OfyRE1gmEzO4nD9/niTJ9PR0giD27dvH/fl4ChslJSUEQeTk5EgkEpVKRRDEjh07cM2TPYsPoQUIQWbJI6ipqUmtVrNLbEqlErvKVVRUVFZWymQyiUQyU1kafY8p9x1xfBfA841QKMQzAUIoIyOjpaUlLy+vrKyMG6aGB/HBwUH2TEpKSkNDw9jYGHvVK3K53Gq1njp1Kjs7Oz4+/vLly/CaAlMlPT1do9GkpKRATBsQWLDgjhBas2ZNc3MzlnLwR67cgxBasWIF/rht27bXXnuNdYtnaxCLxRs2bMDHaWlpXO8XtjZ8nqIosVhcXFxcVVUlkUjwt4xGo2/vc6+VTOlhS0tLS0pKysrK3njjDaVS6aaf4MeUSqX4Y05ODp4y2trakEfYK05H5tl7crlco9FkZGRgYzCWAqfdpNkBWwnT0tKuXr3a0dFx8uRJ9LULWWFhIU3Tly5dWrNmjcPhOH/+vE6nO3z48Bx/q90kAc+J3uFwsLbIwcHB+Ph4fLxgwQJPZc/317Erl1cxwx+8vsO4/YmJiewPKiUl5dNPP52e0AI8CNeWr5i1e6349No8Ux5wuka3Fxd9naWxpKREKBTOi4DOU6dOFRYWYkOCVCptbW0lSTIrK4um6Y6ODvZ3yLJu3To83ONJi6Ior9n0cKAbnqtomo6LiyssLNy6datMJmMYBkJdAT/RarV9fX2FhYUIIc+QRACYfVhnd5Znn30WIdTT08OK0fhMf38/FlC6urpycnJ81OAJGz9w9epVLOhQFFVVVWUymaRSKcMwXHMpN9DOdyX+PCC3tm3btqnV6tOnTzc2NnZ2drqVXLlyJTvO47vgA/z4VqvV845enx1PmufPn9+1a9e9e/fYrMfTaNLs4NVKiHd6KSwsxMIxLol9lmYkYHo2JQH8h+NO9Fwlbd26dQaDwWw2JyUlnThxgvtuTyYncL9+4cIF32IG9y56vX716tVHjx6d9qNNQ2iBUS4EmSW3Ja/pGrlX54t83NTUlJCQkJ2djW0nGzdutFqtCQkJIpFo1apVXh+8paUlNzc3NTU1ISHBa0Q4QojP51dXV8fHx/N4vKamJoFAoFKpZDJZdXU1aA6APzAMo1Kp1Gr13r17ufGmADDXEIvFJEmWlZVhocRsNuMzP/vZzxiG0ev1jY2NngKWb44fP242m2maPnr0KPbkZiUehmHefPNNtiT2ifK61bFnJffFrTaCIIqKitRqtUQi8ZSApVKpRCKpra3Fj6nT6bgdUlxcjI3KNE37+Aljv1+CILKysjZs2OBph55Sk2ZNAPDcy4Xd7EUqlTqdTrzDQ29v77ywerhJAr4neoIgqqur165dKxAIrl69yvUp8kdOuK+YwVbS0NCQnZ0tEomsVivrFDeNP9ZUhRYY00IQEEynRnt7O7Yf4OGPz+f39vbiyQ8hZLfbsUbOXWbJysrKysrC+ROwDYy9yi1ZWFi4e/dubI3LzMykafqtt94CzQHwB4qiFAoF9uLQaDSs+wcAzE3q6+tff/11kUiEP7pcrvr6+tzcXJyVW6PRcJ2a/CE+Ph67/SiVygMHDuDBVqlU4pM4GhuX3Ldv365duw4dOtTQ0ODm1OdZyX3xrG3fvn1VVVWvvvqq1/JtbW25ubmHDh3CreIKo2VlZaxzS1FRked6Aqarq4v1AZZIJB9++OEDNmk2VQg3HZIribLLUDPFjORa9QTP2lKplCsJeE70+CSbPxfP7+za2n3lBDcx3VPMQJwMrexBTk5OTk4On88vLi5evHgx9xbssdtJ9jXbtm1bZmbm9IQWGNBCEF5go46m2WheAJptNptlMtl87C4guNHr9dnZ2TiMsqWlJSsrKyRGLh4PfoxzFlau4gpYNE3b7XauyEjTNEVRXAmMoqi4uDiu0YRbA7ay4xoYhmEdn3g8nslkEovFbvWjr50upFIpRVHR0dGs/Mp+dGuqw+Fwq8Trs7gJjtzK9Xp9RkaGzWbzEV0w2b1whxAEgU9O1ntuxTw7ahpNgkEgCMC6YkdHR3x8fFNT04zrYyHFA+4T4j/f+vGmWXuoGYx5AOXBX7hzFQDMEbRaLTZDYhtk6LyfIDcA3JcBG4MD2wyappuamkpKSgoKCuaI780cbBIMAg/1z+2pVQKgPDwM5QG8YvzuqYewrgoADwiOaVMoFO+8806QmRUBwE8ClUTIDbvd3tzcXFlZOdWAjZBqEvDwIAgCZgFgllR3WHkAgHkHTdNsgjI3d4VQGblgEACAEBdfYBAAHhqw8uCbMHhFAGB+odfrRSJRRUUF/iiVSiGwHgAAAACA2QGUBwCYT5SXl+Oc6LW1tV7TbwMAAAAAAIDyEHgYhsGZy2akmGeZma1/qncH5j40TWdmZrJJHm/fvg3urQAAAHNniJ7xuZWtcK7N2pNtHjc9CWQagg0uzzDMVLfcBkB5mFV6enpwCvAZKeZZZmbr9+fuFEW5pTn3PSyWl5fzeDytVuu5v1J5eXlmZiaPxwO15CFhNptTUlLwrlLV1dXt7e3gqgQAADBHqKmpEYlEr7zyiv+zqv+TtVeZYXY0BK+PwzAMSZLTltqnLf94rSQ+Ph4W4WefEJI/fq//48lqnflP1iVLxT/a+e3nvysPYGO4u8ME6u40TTc2Nmq1Wn++kpaWtn79epPJlJ+ff+PGDc+sf/v27WM3TAVmnLVr11osFolEcubMmUBtEwsAIQ5N05WVlXj/Nbwbl1uB8vLy//7v/9bpdHMhdWyIc235A+2VOdXQ0tdee81gMMTExMhkMj9n1bkvM0wmJJw+fXrDhg3TfsNn8Fn4fL5Go6msrAy+TMRznFBZefjk8uc//Vut+U9WhNCtm9SRn/7q/XeN06gHW99TU1ONRiNCqLi4uLy8HF8yGo08Hg9b5VUqFbeY2Wzm8Xj4JP4dskqzVqtNSEjg8Xj5+fk+7uu1mNFoxPZ+lUplNpvxXdxayDAMLsPj8YqLi7kqe1lZGUKIveT1QVgzg8FgOHDggFQqPXz48NmzZ92ad/DgwRDZmyxQGAwGkiQNBgNoDgAwfQnsxp333zV+cvnzcWZiGl9PS0u7d++eyWSqq6tjMxZ4mlGgn4Ob1NRUPG+Wl5fjiZLH41ksFpIk169fz86qPqZprjDgo1ounjIDu9rvOe9z75KQkMBtA2uk90d+4AoJ3MYcOXLk5ZdfxsduT+RWrQ8JxKtgg2tDXzsy4WPfPZOXl4e9eQFQHqbPpmc1Xv+98lKdW8kjP/3VZIV938Jms+3YseP1119HCL300kuHDh3Cb/OJEyc0Gg22RYnFYpvNlp+fn5uby34Rn+Tm26ZpWq1Wnzlzxmaz+db+PYvhdcN9+/Y5nc60tLSjR496bWFbW5vVanU6nS6X68CBA9xq8eTncrlcLtdkD/KVCefaNfT1xq6JiYkGgwFWCWcBiqKKi4vxH0UsFl++fBm2/gGA6TE6MvY3P6rdrXzzyE9/9cpLdaotPx/on9ogdl8bCphRQoT6+nqXy2Wz2c6ePdvd3Y2nUYSQyWT64IMP2FnVxzTtKQx4rdZPYcBz3scsX74c34UkyZ07d9pstk8++eTSpUv+yw9cIcHNmJWYmMg9g5/o+9//vlu1PiQQ3/IPVwLx3TNJSUkIIjlBeZjjFBQUEASRl5fX2NiIEJLL5SRJtrW10TRdVVWVl5fHGp8Igti5c6fBYGD9Ag8cOEAQBPcncenSJZIk09PTCYLwYa/yWgz/hAYGBk6fPt3X11dVVYWlTLcWJicnGwyGkpISvV7vQ/Sc7EEwQ0ND7DEO0rXb7fAyPFSMRiNJklVVVZs3b4beAIAH5De/voRXnjEDfXTtP707pRrAhgKwE2J5eTk2lp8+fdpHycmmaU9hwM9qz58/71VmcJv3MSUlJQRB5OTkSCQSlUpFEMSOHTtwzX7KD17BYjoW2VnwE3300Udu1SYkJEwmgfgp/9y3Z3A3Dg8Pw5s5m0DM5dTwlL9LS0v3799fWlpKkqRUKsW/KyxhC4VCrF5P9t3BwUF/buq1GPdkSkpKQ0PD2NiY513kcrnVaj116lR2dnZ8fPzly5cnu4vbg3AvrV69Gj8IQRDY8x5M4A8VrVarVqsRQhKJ5Oc//zl0CAD4yX2Xjlk+aLvyQdsV75rGhUNeJRhPGwpkPAs1KIrKyMhoaWnJy8srKyvzHTTs5zQ91Wr9kUzYtzQxMXHDhg1sGz799NMpNcwTrDb09PRw5QT8Rc9qly1bNpkEcl/5B+sDfvZMTEwMvJygPDyAeemCd9e3Ty5/7ua5VPr335+RmOmcnBy1Wl1SUnLy5En25KlTpwoLC7u7uyUSCatReLJu3TqDwYB3CK6vr8cn9Xp9YmIi92fptdi6deuwbiCXy9HkedNomo6LiyssLNy6datMJmMYhrV24CGAoij8s/f6IOwYRJJkXV3d7t27T5w4wS62arXabdu2wfQ5gzAMU1JSUlVVhRBSKBRarRb0NACYC4ANBUAIXbhwgSTJrKwsmqY7OjpYudzrrOrnNH3fat2EAb1ev3r1aq6v0VTxs2Fuj/OV1MjnSyQSr5Z+z2oRQpNJIF4FG3xHo9G4YsWKEydO+NMz+C5uKyHAwyZU3JaeSn385yd2rt+4CiEkfSL+5yd2zlS2JRzsb7FYNm7cyJ5sampKSEjIzs72FMTdhHKNRiOTyQQCAatP79mzp6ur677FCIJoaWnJzc1NTU1NSEggSdLrLZqamgQCgUqlkslk1dXV3HVSPp9fXV0dHx+PY5K8PghLfX398ePHcQNYz0W1Wo3bg4OlEEIymcwtsgrwH5qmN2/ejDWHoqKic+fOgXQCAFO1H3n9t+fv3N3/1m9cNVnhyYZrbENhGMbNhgL+S6HDxo0brVZrQkKCSCRatWqVpzzAnVX9nKbvWy33JWxoaMjOzhaJRFarVSKRTO8p/GyY2+OwFBQUvP322/5U60MC8SrYYDmEJEmBQHD16lV/eqa9vV2pVELu8lmG5xYHMz8azQtAsxmGYdfpuMdYdF6+fDnOFMZewvo0fqHdyiOEzGYz+5GmabvdHhcX19PTIxaLU1JSbty44WnO5xZzqwohJJVKJ2shNiqwjXG7O7ck90G84maBYJ/RzW4BOQqn/Y5t3rxZp9M1NDTMbLLwIBy5ePNy7AICxejIWPHOk2zYQ+wi4l/+oyA2bmqrpkajMTc312AwKJXKY8eO4cGQx+OxiVlVKhXXWRxe0WAdBMxmM/7r2+12fHDfGd9zmvazWlyYPcDBCXw+v7i4ePHixWVlZZ7zvpsw0N/fj2vDUoTbJO5bfvD6ODRNi0Qim81GEITXJ2Krva8E4lWw8Tzpo2dSU1N/8YtfzHgewroLn8/Ou/StH2+atfd2qgmIQXl4WOAtVK5cueJV3J+e+Mj+zuf1gwBTAvtCsOMsaF+gPAAPA9ONO6Yb1kcTFj6V+viDjJZebSjIw/0DfsgwCMw42K7U0dERHx/f1NQUqHdMr9cvW7Ys4GvjNE03NTU9DFsbKA+gPDxEsM4tFovnu8AdNA8yH3s+Ly+vo6PDYDCAkxLIDQAAwCDgW1ymKIogCJgvHiqgPPgGvMQerPv4/OCwLQXNg8wvKIpSKBQGgwEh1N7eDq5KAAAAgA8IggAbHxB4oRG6AAACgl6vz8jIwMctLS2wtxQAAAAAAHMf2CQOAAJAeXk51hwkEonJZALNAQAAAAAAUB4AAPBCa2vroUOHEEIKheL27dvgMAYAAAAAACgPwQbDMJPt9TaNYp5lZrb+qd4dmE2ysrKUSqVGo2lvb4fs1AAAAAAAgPIQhPT09Mhkspkq5llmZuv35+44PaufX6Fpury8nMfjabVanGeaeykzM5PH4yUkJJSXl7OZCnkctFotvEKtra16vR4fa7VaH/tpAAAAAAAAgPIQYC5++UXur/5zaVXl5oZfdphvBrYxJpMp4HenaZq7n5Fv0tLS7t27ZzKZ6urqKioquJfsdvvOnTtNJlNbW9vZs2ebmprYSy0tLSaTyWQybdu2LZR/ZgzDlJeXb9myJSMjg91KEwCA+YUPGwqaxIwCNhQAAEB5mMeaQ86Z/+jq+Rwh9Nm9u7v+6+2mz6aT7xbPHKmpqUajESFUXFxcXl6OLxmNRh6Ph2cUlUrFLWY2m3k8Hj6J5w929UCr1SYkJPB4vPz8fB/39VrMaDTiuUqlUpnNZnwXtxYyDIPL8Hi84uJi/EV897KyMnZum+xBWNnXYDAcOHBAKpUePnz47Nmz3LaJxWKVSiWVSuVy+Y4dO5qbm92uSqXSUE4tR9P05s2bcZCDUqmMi4uDcQcAAkLP0GDTZ9cufvnF9L7uw4biw4wCNhQAAIKMYPO3XlpV6WfJfb9p3febVq+XbhaV+PiizWarrKx8/fXXtVrtSy+9RJJkWVkZn88/ceKERqPBLuxisdhms9XV1eXm5l6+fJkVo202m1Ao5IqVarW6s7Nz9erV27dv9yF9ehZjGIYkyZaWlnPnzr355ptHjx7dt2+fZwvb2tqsVqvT6eTz+W4274qKisbGRrzJjtFo9PogmGvXruH2I4QSExMNBgO7I7JbO2traysr//wn2LJlC0JIoVBotdrQ3NHGbDavXbvWYrEghKqrqwsLC2HQAYDZx+507jit/ezeXfxxcVT0u+qfLI6O9r8GbEPR6XRisfjw4cN79uxx8zzEZhR8jM0o7EfYfxMAgGACYh6mRkFBAUEQeXl52OFHLpeTJNnW1kbTdFVVVV5e3leayb59BEHs3LnTYDCwIvuBAwcIguAK5ZcuXSJJMj09nSn7864AACAASURBVCAIVvT3xGux7u5uhNDAwMDp06f7+vqqqqrwWoFbC5OTkw0GQ0lJiV6v9yG+T/YgmKGhIfYYT4F2u91zZt2+ffuqVavY+dJqtbpcLpvNJhaLa2trQ/BtaW1tlclkFotFIpF0dnaC5gAAgaL95g1Wc0AI3Rux11z43ZRq8GpDmczcU1tbu3XrVtaGIhKJMjMzwWURAIDgYE6sPNA0LRQK50XaGU/5u7S0dP/+/aWlpSRJSqVSnMgIS9h4kYGdYDy/Ozg46M9NvRbjnkxJSWloaBgbG/O8i1wut1qtp06dys7Ojo+PZ5dBPHF7EO6l1atX4wchCAKLwm53YRhm8+bNCKFz58659RVBEFu3blWr1SEbHxzKCy8AMMv4v/j8y8sf//Lyx14veV189mpD8VxPcDOjWK1WsVhM03R+fn5tbS2kSQAAAJSHB8VoNL7yyis6nQ4hpFQqjx8//oBru5N5HOGYB+6Zo5uytn1jxYM/Qk5OjlqtLikpOXnyJHvy1KlThYWF3d3dEomE1Sg8WbduncFgMJvNSUlJ9fX1+KRer09MTOSK716LrVu3DusGcrkcIURRlFczGE3TcXFxhYWFW7dulclkDMOwSlpSUhL+IpZrvT4IO1OSJFlXV7d79+4TJ07k5OTg81qtdtu2bUKhkNUc2MoZhnE4HARB0DTd3Nys0WhC50fF+nRlZWW1tLRs3LgR8rHiZTEf/TCPLAhAaHJfG4pXMwrYUAAACD4C7Lb0yiuviMViq9VqMpk6Ojq47vIzyzcfSzyd/aO0pMcRQt9Y/MjJ7704I5oDloc0Go3FYtm4cSN7sqmpKSEhITs721MQdxPKNRqNTCYTCATsivaePXu6urruW4wgiJaWltzc3NTU1ISEBJIkvd6iqalJIBCoVCqZTFZdXc0Vzvh8fnV1dXx8PI/Hm+xBWOrr648fP44bcODAAXxSrVZTFNXT06PT6XQ6nUAgwNHbCKGenh6RSMTj8UQiEUVRBQUFIfKLMhqNKSkpNTU1+GNWVlaIC8QMw2i12uTk5OTkZDZTrVuPZWZmikQi/KJO5goCAH7aj7z+O7TuebeSf71s+WSFJxuusQ2FYRg3Gwp+abmaA/7VMwyDL4WgDQUAgCCGh+NlA3Z7Hq+hoQGLm/h/f5LZ8XgBaDbDMD09PXhBgHuMW758+XJsUmIv4YUCdgrhlkcImc1m9iNN03a7PS4urqenRywWp6Sk3Lhxw2s4MlvMrSqEkFQqnayFeFGCbYzb3bkluQ/iFXaZgq0HL1/09PRwp1hchqZpXD50IgW1Wq1arUYISSSS27dvgx0dIVReXl5bW9vW1mY0GtVqdUtLS1ZWFrdAZmamWCw+duwYTdNr164tKCjwxzobkEEAmL/Ync7vn2q43ncPf1wcFf3vL2Yvf2RqzoRGozE3N9dgMCiVymPHjuGBjsfjmUwmPOZzN+FRKpUVFRXsGXBffBjyAwwCwEOi7sLns3Ojb/1406w91IpPr83Yry+wvz0sWJw8efLmzZt79+7t7OxMT0+fR0MG3mftypUrXsX96ako/f39sz/BzPiDhBoMw7BB6iAlcElNTS0tLWUNBJ7a6TyyIADznYtffvHF8FBizILVkgR+2DQX3r3aUPh8PjbEuJlRQtCGAsoDAMoDKA8PF24iS5Iku7q6vI6w2K+GyxwZMvBsEQQTQ9A8SKB0SIVCYTAYEEIajQZnvIVuQQjRNC0SiQwGA47MqampOX78uFvU/ny3IAAAAMoDAMpDSCkPgYx5YBhm7dq1OTk5TqfTZrPFx8d73evAcyPPuQOfzw+OHdCC5kECAqs5tLS0HDx4cE5pDhMTrqEB+9CAPVBqFUIoJiYGf1y0aBHuKC44L/CWLVv27t1LkiQOSwUAAAAAYG4SSOWhp6fHYrHs27ePz+fjXRFw2iVPudb1l8CfDZhT1NfXSyQSk8nk5s0fcLXB2jvwi386t/P71T/I/Mdf/NO5gf7ZjkXG3h3Dw8PsGbfIfv8tCLy/BN46AAAAAAg55UEqlUokkqNHj9I0TdP0kSNHioqK4E8CzAsYhikvL8fLYnK5vLe3121zjADicrnstOO2mfq7grd+/Z8XbMOjCKGmU7//mx/VjjMTs9kSnKDGaDTij83NzevXrwcLAgAAAACA8jBNTp48efr0aZFIJBKJEEI+dlkGgLkDRVHJycmHDh2qqKiYUw3DasOXPf03/3jnxmcWyxf93KsDffRH3X+a5SatX7/+yJEjZrO5tbW1o6Nj06ZNCKGamhqczRYsCAAQIjAMM5edkAEAmDfKQ1ZWVm9vr9Vqtdlsly9fnju2W68D32R7vU2jmGeZma1/qncH/Eev18fHx+Mo/xdeeGGuqQ2fmyhr74AwUmDt9bIx+XuthlluWEVFxY4dO2Qy2a5duyorK/EuIl1dXexmJmBBAICgVxt8b/aCoSgKnBIBAJQHf5kXSX56enq4ObwfsJhnmZmt35+74/Ssfn6Fpuny8nIej6fVaj2tR1xndH/ybM5fysvLMzIyEEISicRqtfqTF2gWYNWG3p4+hJAoJqq9+dK/1b7vWfJ7Oc/OctsIgjh48KDNZrt9+7ZKpcLR5MeOHTt27Ni8syAAADA9C0JJSUlbW1tlZWVGRkZra6vXYiqVSiKRQHcBACgPcwjLiOH9Xs2J699uvV1sGTEEtjEmkyngd6dpGu9L4A9paWn37t0zmUx1dXVefXVaWlpMJpPJZNq2bVtQvj8Mw2RmZh46dAghpFAobt++PRd2cnCMOnu/+LPasDCWeP9dY2Hevzad+r1n4dhFxPKnkgLSToIguEmoxGKxW+9BmmBg7uPbhoJCyYwyJc6ePVtZWSmXy1UqlVKpvHjxomcZrVZ75cqVV199FboLAEB5mEOaQ/Ptl28O6xBCX478ofn2yzeG2qdRD545UlNTcQxocXFxeXk5vmQ0Gnk8Hp5RVCoVt5jZbObxePgknlHY1QOtVpuQkMDj8fLz833c12sxo9GYmZmJazabzfgubi3EIi+ezIqLi/EX8d3LysrY2W6yB2HlZoPBcODAAalUevjw4bNnz3ptpFgsDu58r1euXEEIVVdXt7e3Bzwfq2PUafmy/3PzXUtPv1e14bmMJ//+qHLrjm+KYiIRQj/+X+v/5T8KwvlhMOoBIcuws/fGUHufY5qRP/e1oYSCGWUaGhe70wvuQ88ZhKIotVrd1ta2aNEi6DEAmPsE21ZWJ65/28+SH1jKP7CUe7300rL/9vFFm81WWVn5+uuva7Xal156iSRJvCnYiRMnNBoNlinFYrHNZqurq8vNzWW3xMInhUIhd1RVq9WdnZ2rV6/2mqHSRzGGYUiSbGlpOXfu3Jtvvnn06FHWWZzbwra2NqvV6nQ6+Xw+TrrPUlFR0djYiBPXGI1Grw+CuXbtGvo67WZiYqLBYKBp2k1J2LJlCwrSzZXxw/L5fIPBcP369YC7KjlGnf19tuGhUdvgiEDIFy2Iam+5xF1qeC7jyR2qtQsWRg8N2b+tWLnl+888Er9gQWw0jHdAyDLhYj7o/fubtq98+eIilmYl/XMUP87/GrANRafTicXiw4cP79mzx22vdK4ZBZbRuIoBut9mLyqVqqioSC6Xs5nZvPa/QCCA/gSAuQCYIadGQUEBQRB5eXnY4Ucul5Mk2dbWRtN0VVUV3u4KIbRv3z6cd9JgMLAi+4EDB9ycNy5dukSSZHp6OkEQPuJEvRbr7u5GCA0MDJw+fbqvr6+qqgqvFbi1MDk52WAwlJSU6PV6HzL9ZA+CGRoaYo/xpGi3/8WmY1ar1eVy2Ww2sVhcW1sbNH9unI81JSUF961YLA6s5sAw41bL4Ofmu723+x2jzmiR8Le6T7irDUlLFv/fn+3YWfAC4qGhIfuCBVHJ0kceXyoGzQEIcW4Od7CaA0Kof+zmpb63plSDVxuKZ7EtW7aIRKLMzEw3Y03Ict/NXvR6vU6ne+mll8xm840bNxBCZrPZ0ysM8jUDwNyBD10wjXGQS2lp6f79+0tLS0mSlEqlOJERlrDxIgM7wXh+d3Bw0J+bei3GPZmSktLQ0DA2NuZ5F7lcbrVaT506lZ2dHR8fzy6DeOL2INxLeNNfbIC3WCwSicTTYR0/9datW9Vq9WQGufkFDijH2w68+eabhYWFgVUbBgfsA322of4RgZC/IC7649/fPH7sz653SUsW5+avXyITDw3ZsdqwcBGxMDaazw+Hny0QOvi/+PzJwJlPBs54veR18dmrDcVthcFqtYrFYpqm8/Pza2trg2MkfEDYzV6w55LnZi+3bt1y0yhkMpnJZILcCQAAysMsMZnHEY554J5ZLzmYsiDzwe+Yk5OjVqtLSkpOnjzJnjx16lRhYWF3d7dEImE1Ck/WrVtnMBjMZnNSUlJ9fT1rhklMTOSOm16LrVu3DusGeESmKMqrGYym6bi4uMLCwq1bt8pkMoZh2KWPpKQk/EUs+nt9EO7oX1dXt3v37hMnTuTk5ODzWq1227ZtQqHQ4XAQBEHTdHNzs0ajCYIXyWg0bty4EedjbWho8D8t1UNSGwb76KGhET4/HKsNp36pHxqwg9oAALPGfW0owWpG4dpT2tvbpzEY4s1e0tLSrl692tHRgacYvNNLYWGhSqVi69RqtWq1GlYVAACUhzmBJIrc+Ng/XLj7Zv/YzbgIWeqiHy+N2TAzPcjnazSaQ4cO4QT2mKamptdeew0h5CmIuwnlGo0Ghy8rFAp8cs+ePaWlpVzlwWsxgiBaWlpyc3MRQlarFSH04Ycfet6iqalJrVYrlcrGxsbq6mqu0xSfz6+uro6Pj0cIuVwurw/CUl9fn5ubu3fvXqVSySbZVKvVOHETG/+tUCjYq/MXPIEhhCQSSVtbGxvqN8uMj08M9NNYbUAIEUTk5Y9MoDYAwDTsR5/0n/2Q+mfumaUxiucTDvlfs28bCkEQDMMEnxmFy/Xr19Vq9TSUh4qKisrKSplMJpFIuJu9YOUBXloAmHfw5qOKz+NNv9kjTP+UguRYGIbp6enBMj33GCGkUqmWL1+OjUzsJbxQgIV1t/IIIbPZzH6kadput8fFxfX09IjF4pSUlBs3bnjG23GLuVWFEJJKpZO1EC9KsI1xuzu3JPdBJrM8cY1t7DPSNI0vBUGYoF6vxzs5BDD4e2LCZRsauWsd8kdtQAiFoNrwIIMAEII4J0ZOmX44Ov7nPde/v+TfFgmfmFIlRqMxNzfXYDBgGwoeHHg8HvaxMZvNXDNK8KWOoCgqPj6+s7NzeqFfNE0LhUJ2GsIxIW5dhKcSPx2WYBAAHh51Fz6fnRt968ebZu2hVnx6DZSHOdFs7BZ/5coVr+L+9FSU/v7+2Z9yZvxB5i8Mw2zevHnlypWVlZWznI/V5XKNOZiLH95offsjhpl4+jnZ6m8uvXLpFqgNIDcAM4JlxHB14O2UmI1JxLNhvGn+uiezobCyb7BmW6Jpevv27TqdrqioaM2aNex5vPACgwAAygMoDyA3+Cto4uWC+T5VBM2DTBu9Xr9gwQLsoeSZiPZhMzbGjNrH+vvpNyvf/UP3Tc6rjtg3HdQGkBsAIIBwl1a4BCq4GQYBAJSHQCkPkG3pwbqPzw+OjBBB8yDTo6amZu/evRKJxGAwzKYGNTHhstOO4aEROz06PDTqGBnjag4IfaU5LIiN/uFP0lOfkdH0KMQ2AAAQEKRSKQjrAACA8gCEOgzDsHtirFq1Kjp6NvZDwO5JQ4Mjw4P20VGnnXZEE8KFsUTL+16sAk+lJheUbKbpUZoeBbUBAICAQ1EU3i4TR+IFWWgHAAD3BTaJA0J6CnzmmWew5qDRaM6dO/ew1xwYZnxowP65+a7pxp0e812bzSEUCsLDwz5ou/J/Cn756/+84PmVJ5YnYLUBb/e2+JGYgGgOer1epVKlpqbyeDwej5eZmVlcXKzX6+EtAoDQobW1NTU1NT4+/o033kAInT9/3m3HNwAAQgFYeQBCFDarEkKopaUlKyvr4d1rYsI1OjI2NGinbaO0bWycGY+KjhDFRHb99rPf6j7puXXPx3ef37gq/rHYAK426PX6PXv24AwzO3bsKC0tRQh1d3dfvXo1IyODJMn6+vpAZbMFAGA22b9/f35+/tNPP42VB7wZDjd9HwAAoDwAQNDy8ccfI4TYOIeHcQvsnmSzjQ4N2EfsY9g9KSoqoufze798s+OasYdbeIU8aeNfr056fPHxqvbrV79ECD2WvKjglU3fWJUUFsYLYEdlZ2e/+uqrO3fu5C7L4FzvNE1XVla+/vrrWq0W3igACG6MRqPBYNi9e3dPz1dj1yznowMAAJQHAAgA7B7beHOi3bt3P4z5j2HG7TbH0NCI3eagh0d54byYmKiBfvv77158r9XALZm0ZPF3FE+lrVuOeIi2jY4zEy//3WZmfCJSKFi6TBJYtQHT29s72SWCIIJsD10AACZj6dKlCCGHw8FVJxBCSUlJ0DkAAMoDAAQnFEWRJHny5EnspDTjm5t6dU+KEPIv/u5PzWcvsns1IIQWxEZv2LTq6WeXxksW0rRjcIAWxUQujI1eEBstEkVGCPk8Hm/O9iHESgJACEIQhFKpzM/P37p1K0VR2KFRo9HA+gMAgPIAAMFJa2vrli1bEEJbtmxxOp0zO+FRdwbv3R0WCgWse5KAH95z6+7Zhg/dQhqey3jy+e+SSY8vdjoZO+1wOJwikVD0WOyChVERQsFcWGrw0YH79+/HwQ/p6ennz5/ftWuXj3UJAACCjIqKivz8fLVajRDCu8UVFBRAtwAAKA8AEGwwDFNRUXHo0CGEEEmSOp1uBjWHm3+0/OIf3zV+fAsh9GhC7I92ZkRGRrz/rtHTPWmHeu3SJyUIuUbsYyMjY4QoIm6xKGZBVFR0RHj4PMh7BrGSABDiSKXS9vZ2mqYvXbq0evXqkN1UFABAeQCAYIam6e3bt+t0OoSQUql86623ZlBzGB+f+Nn/PfPF51+tLdzpHThW0cwtsCA2euuOb37zW08IIvh2u2N0dCw6WhifEBsTExktEs6j7RogVhIAQhatVrtkyZLVq1c3NTWxJ2/duoUPtm3bBloEAIDyAADBQ0pKisViQQhVV1fPbJDD6MjYpYsmVnNw44UsMuP5lY9KFg4Pj4w5mHB+WNxi0cKF0dEiYUTE/PvdQawkAIQsarVaqVRWVFRghyU3TCYTKA8AAMoDAAQPJ0+e3LVr15kzZ9LT02eqTpfLNdhvp6xDn1z63PPqM996YueeF0ZGxsYcTqeTmRdh0PcFYiUBIGRxuVxuBwAAhDKwwzQQhDAM09raio+zsrJu3Lgxg5oDw4z3ftHf8/m9/nvDf/rM4k15WOp0MiKRMGnJYukT8UuWxi9+JEYYKZi/mgOmoqKCoii1Wq3T6TIyMtavXw+xkgAQOlAUBTu6AACAYOUBCMoZTqVS6XQ61k9pBpfU7bTjTu/AwD26v89W+/PfcLOvYmIWRqWtXzGPwqD9B2IlASCUuX79ulqtxhtEAgAAygMABAlGoxFnAUIILVq0aAZrnphw3bUODfTRQ4P2D397vfnMBXz+ubSU1c/JPjH0OB3MC5vJNd9eFhUdEUxd6tXWCLGSABBqLFu2DCGk1+tncCEXAABQHgAgwGIujueTSCRtbW1yuXymah4bY6yWwb67Ntvw6Olfdl4zfpVxaOee51OWJyyMI9Zvki9aLJrvjkle8RoiyQKxkgAQIkRHRysUioyMjKKiojVr1rDnwYIAAKA8AMD8g2GYvLy8xsZGhJBCodBqtTO187HL5RoeHKGsg0P9I7dMVG3lu/h80uOL8/92Y2SUIG6x6FHJwsioiGDtWwiRBAAAIURRFM55XVVVBRYEAADlAQDmNw6Ho6OjAyGk0WjKyspmKgXQ+PgEdWew765tZGTsbe3vLnTdwOe3Zj+79jvLRDGRix6JWSyOCbLYBgAAAE8IgmhoaICYBwAAQHkAgmRWa2tru337dlZW1kzVOToydqd3oL+Pvmsd+pejbTg2ekFs9P98+QVJQmzsYkL86EJCJAxKV6XJwNHS77333gsvvLBmzRrI0woAoQMETAMAgJkrFlOKomiahr8HMCVqamoyMzMZhkEIyeXymdIcXC7XvbvDt2/do+4MffThn/7x0DtYc1ghTyotfzFZ+kj8Y7GJjy8WxUSGlOag1WpFIlFGRkZtbW1GRoZAIIC8jQAQOrAB09AVABDiBN5waDaby8rKsLc6LIkCfsIwzObNm7ED7unTp2fwtRkbY6g7Q/eo4clio8XxCxbGRYeU2oA7vKSkpLq6evfu3Xw+n6bpurq6kpIS+MECQIgAAdMAAGB4gY2G1Ov1GRkZGo2mpKSEoiiEkFQqvX+jeTwI4gxlKIoiSRLnY9VoNAcPHpypmm3Do9SdwYF7tPmm9c2f/wafTHp88U8KNiyIjX4kfsEj4pggjo32gdFoJEnS6XSyrkoMwwgEApPJ5M9vduZHLhgEAGB2MZvNMpnM8zwMAkDwUXfh89m50bd+vGnWHmrFp9dmqqoArzycPn26qKgIC39gugD8VzjxcWdn50xlHB8fn7hHDffdHbYNj+paDR3vGvH5Dd+VK7JIiI2WSCQIoe7ubrbDu7u7EUJJSUnwTgJAKCCVSkFYBwAg8MpDVVWVQqFITU1FCOXn52OPCPirAJPR2tq6ZcsWLMsaDIaZysfqGHVS1qG71qGhAXv1kVavsdGimMjQ7HM2sAF7LCiVyq1bt9bV1el0OoVC4XA44DcLAAAAAKFDIFf98BqoRCKprKyMjY3dtWtXQUGBPy4osFgZsjAMk5ycvGrVqnPnzs2IzOpyuQb77ffuDvXfoy9dMP3nv3fh8yvkSbn56yKjIuIWix5NWMjnh4fuGOEzugM8FgAgdKBp+vz580ePHsXxZjAIAMEKuC35JpAmQ+zwUFBQgGMuX3311ddee81TecCu1fAqhzJms5kgCLFYzOfzb9y4MVMebgwzftc6dNc6PNBPn/n3LjY2+gc/Tlv9rCxkY6M99St4AwEAQAht3779ypUrq1atUiqVeM84hUIxUyvAAADMFwKpPPD5fIVCsWjRIvxx0aJFFouFYRg3izKfz3cTX0JcmAs1sKuSRCK5ffs2n8+fEc3BTjtafvXRzeuWb65NGein/+PfOllXpb2lWSEeGw0AAOAJ1hZsNltTU1NfX19hYaFer8/OzhYKhdA5ABBSBDj689vf/vbx48fxJg9HjhwpKioC/2mAhWGY8vJyHOQQHx/f39//4HWOj0+c+rfOF9f/fyeq2t9/1/gPh97+13/+agO4Dd+Vl5a/GC9Z+FjSooTEONAc3KBpurW1NTMzk8fBbDZDzwBAKHD9+nX0dWqTrq4uhNCaNWssFktPTw90DgCEFAGW1EtKSrBciBBSKBQHDhyAPwmAoShKpVJhz1qlUvnWW289oGLJMOODA/Y+avjUW+6bHBExkepd31ma8miIx0b75kE8FvBGfr7/ghRFRUdHQ9Y1AJibJCYm4t9yWlpaSUmJ0Wg0Go0IIXBbAoBQI8ArDwRBHDx40Gaz2Wy29vZ2GIMADN5VAGsODQ0NWq32QTQHx6jT8mX/rZvW2+a7Fz68QQ+PuhVYSSZ/46nE+Mdik6WPgOYwmWSv0+lu3Lixc+fOtLS09vb2zs7OK1eu3NdjgWEYrVabnJycnJw82d60ZrNZpVLFx8eLRCLYtRoA5iZSqVSpVPb09Eil0g0bNpAkqVari4qKQOEHAFAeAqNCwOgDcHn77bctFgvOxzrtPYxdLpeddnxxu+/WTar3dj91Z/i/37vG5lPiEi9ZkPT44seS4kI5q5Jvpu2xUFFRUVJS0tbWVllZmZGR0dra6lZAr9fLZLLly5fbbDaTyZSWlga9DQBzE61WixMrabVaq9VqtVqPHTsG3QIAoQYEGABzkbKyMoRQQUHB9BajJiZctqGRoaER29DI4ID9HjXc9utLbDIlT7blPBe7CNRXX0zbY+Hs2bOVlZVyuVwulzc3N1+8eDErK4tbAHaKBIB5BE3Tly5deu+991544YU1a9ZAhwBACBIGXQDMESiKSk1NxSIpn88/ePDgNDQHhhkf6KNv3bR+br5r+uOd3/zXpX/SNB2raGY1hxXyJOX/yOD6Ju0u+e6SpfHQ/76ZnscCTdMGg0Eul+OPaWlpZ8+edStTVVV19erV1NTU1NTUmpoaHB0BAMAcRKvVikSijIyM2trajIwMgUAAfoYAEILMyz1WYGuY4AOn/MOuSr29vdOowTHqHBocGR609/fTt813O84ZP/3kC/bqgtjo7yieWpOREhYWFhkVIRTye7/s5yHes2kpkFVpepoe8mPZAW8Eye4hpdVq1Wo198fr/06RngmaYRAAgNkE79H56quv7t69m8/n0zRdV1f32muvTW/EBkkAmMvAJnG+AbclIPDU1NTs3bsXISSRSD788MMpfdflcjlGnQP99PDQqKWn//ddf/zdbz8bGhxhCyxflbTpe6vjJQsjhAJCFBEZJVwYGx0VHfHkiseg5/1Bq9UuWbJk9erVTU1Nnle3bdvmY/EBaxfDw8PsGZIkuQX83ykS/hAAEFiuXbtmsViw5oAQIghi9+7de/fuNZvNAdlhGgCAQAHKAxBIGIbJy8trbGxECCkUinfeecd/r/eJCZeddgwO2Af6bJ9e6fngN59cv/Yle3XBwqiM51c+s/YJUUxkdLQwWiRcsCAqMjoiIgLe+amhVquVSmVFRYVarfa8ajKZfPzJCIIgSdJoNGLPpebm5vXr1//FAAQ7RQLAPEEikSCEuru709PT8Znu7m7WBODPaI8mz9fMMAz2ioR+BoDgVx5omkYQ5ghMV3N45plnDAYDQkij0ZSVlfnOxzo6MjY66oyNI8bHJ+jh0f4+211q+HfnP+v4zZXhoT8vNSQmL9q07a+eePJR0YLIqOiIhbFEiZJrpgAAIABJREFUVHREhJAP4ub0YKX26XkIrF+//siRI2lpaVevXu3o6Dh58iRCqKamBiFUWFiIvt4p8oc//GF0dDTsFAkAcxA2sEGhUGRkZCiVyq1bt9bV1eHNXhwOh+/fLMMwp0+fxts6nTlzhtU9WBISEiwWC9ZPcnJyKisrYRAAgLnMlF0GaZoWiUTYibm1tRXv/tvQ0DDtfJrTaTR4OgYL2GGppaXFLQOPGwP9dPOZi//+rx8ghJ5anfziD9f09dH6jmuXL5q5xTZ972n5048nPr44KjpCFBMVsyBSGCkAnWFGoGmaoqhp2AVpmq6srDx06BAObMjJyeHz+Xi4wBIJWwCLJlqt1p9AeRgEAGA251wfV9mgpskoLy+vra1ta2szGo1qtdpzwG9tbV25cqVYLD5//vyWLVs6Ozs9FQwYBIDZBGIeZlh5wAGO+FsJCQk5OTlPPvnk3r17Z/M3DEPGfEev17NzA03T9125Kt3z1qULpsmuJiTFZW5JXfX0kpiYyGiRMDaOiBAKwsJAZ5hJ8A+fJMnS0lLfcQ6TqRBCoZC1JnrGW091DRMGAQCYL6SmppaWlmKTgUqlWr58udekCF+N5wkJk2VNgEEAAOVhjigPU07VevXqVRzyaDQaLRbLgQMHsO+B2WyGtw24LwzDZGZmcjcLu6+82PtF/2Sag2JL6v7Xdvz0yA+e30w+sUyy5Il4yWNxkVERoDnMOFKptLOzc/369Wq1WiQSqVQqvV7vfxwzQRBcPwSxWOy2vAA7RQJAUOJPvmaEkF6v12q1WMHIy8uDfgOAucyU3QqfffZZg8FgNptPnDhBkuT09vACQhOz2bx27Vrs23rz5k1/vjI6Mtb5vhddWfbko8X7t8YsjIIw6FkjPT09PT29srKyra3t6NGjGRkZeAtwGAQAAJgMvMwYExODPy5atAjHubnx8ccfHz9+3GAwKJVKr0MKwzACgQD6EwDmpfIgFosVCoVMJkMIdXZ2IoT83GgWCHHYCBn85tzXpZVhxvvu2v7w+5uN/++3nldz8tKXPvmoMBLmklkfMvj8devWDQwMXLlyxWKx0DQNv30AAHzIDMhnvmZMYWFhYWEhRVEkSVZWVnq6LUHKNQCYO0xnh+n29nar1Wqz2bD8FxMT09DQAC4HwORqAFNeXo41B5IkrVarb83B5XINDdg/vnDznzTvHP37/6JtDrcCsYuIdYqnQHOY/b+jXq/PzMwUiURqtTonJ8dgMEBqRQAIESiKmsZ+0my+ZvzRM1+zm6aRk5Pj1a8JAIC5wzSdPVhbI7Y7zmaqJWDe0dPTg3PpKJXKt9566775WO9YBs/Wf/ib//oYnxEtiPzeD56Llyx8u/F3A/30937wXHbu2nB+GHTsLMsN8fHxCCGFQtHS0rJx40bIpQgAIcX169fVavU0pnvf+Zppmr506dKaNWsQQteuXauqqmpoaIDeBoCgUh7mQqpWYH6BY20//vhjHFs/GdhPSd9xrf74edvwKD6Z/vyKH/0kPWnJI1HREZu3/xV0ZgCprq7+4Q9/CE5KABCaLFu2DP1lrjw/qaioqKyslMlkOF/zxo0bEUJdXV1YeaAoKiMjgy1cVFSUk5MDvQ0AcxlI1Qo8LLRabXNzsz/L3BMTrqEB+x+vfflvte/f+MyCT0oei335/2x+4hsJcYtEkD1p7kBRFE6riklKSgrIEgQMAgAwy9A0vX37dp1OV1RUhBcKMH7mbvaRrxlvL40QmpIbJAwCwMMDUrXOsPLQ2tq6f//+y5cvG41G7L8uFot5PN59t4kBuSF0YBimpKSkqqoKIXTfDeDstKP3i37tyd+yWZVEMZG5+evWrvvGI/EL+Pxw6M+5ow2WlJTgZFkss/nDh0EAAAIINh16nodBAADlIdSUB0jVCswwFEWpVCqdTocQKioqwivUk+gY43etQ++fM55t+JD1U9r0vad35K4Vxy+IJoTQmXMHmqbVarVGo3FLwZ6UlASdAwChgFQqBWEdAAAEqVqBmcVoNG7cuBEbp31EwrB+SjX/0Gr5cgCfTFme8D/2bPjGisSYhVGQg2+ugfflKCsrgzhpAABTAkVRgXJZBABg/ikPCKH29naKoqKjo7GbI6RqBTBsAL1EImlra2O3FHUD+ykdP9b28e+/2jdaFBOZ/7cb/+q5pYseEYGfEkJofGLCOTEezgvjh4XNET1q6dKlCKGenh7IzQoAIYvZbM7Pz8cLywghpVJ57NgxMB0CACgPfiEWiymKunTpUnp6ulgszszMhK4Enn32WYlEsmrVKq1WO8kWoeN3egfOt33yyzc72JPfV31r84vPPCpZCPs2IIRGGWffyMiQY9Q5PsHj8SLCw8MQb0GkMIwXFsnn88N4AdQo8JLj9GIlAQAIAvLz8xFCLS0tK1euvHr16tGjR4uLi6ex+QMAAPOa6cQb4ZhpvI28VqttbW3dtWtXb2/v7DUawqTmEtxlKIqi4uLiPNeysZ+S8Q/mE9U61k9p9bOyH/+vddInHiVEwhD3U3K5XI5x5i5tH3CMDo6O3uzvG3e5Uh99lJlwMRMTYxPjEWHhgvAwYTg/UBoFxEoCQIiDBwGbzcbaCzzPwCAABAcQMO2b6aw87N+/Pz8//+mnn37jjTcQQtjH3Ww2gz9DCKLX67Ozs1etWnXu3Dk+n89dcDDduHPunT8M9tsznl8Rt1hUf/wD1k9J8lis+qXvPLM2BdKwulwu2um8a6cHRkZp55h5oL/yd/qB0VGEUGxkZK48dfvylQih8YkJF0Jj4+MTronBUSczMfGFbWg2NQqIlQQAAAAAYDrKg9FoNBgMu3fvxlmZEUIQMhWy1NTU7N27Fx87HA7um9B0+ve/+Mdz+PiDtivcb/1k94Z1G58SP7owIiKk35wJl2twdJSy0/Yx5+DY6AKh8FGRaO+7zVhzQAgNjI7WXOje9MSTUQJBeFgYQogfFoYQEkV8VcP4xMS4y8VMTDgnxkecTsf4+GQaxQKhMJIPXmEAADyQBYEkyfz8/JdffjkxMfGLL744fPiwUqkEx0UAAOXhPuC4SYfDwVUnEGRsDDEYhtm8eTMOm1MoFO+88w53/hhnJljNgcvTz8nyizcmJMaFeBpW5/i4bWzsDm2zjTlGmfHYyMjEmAVhPN4V6x1Wc2D5aYdu85PLZLFxi6KiYyMjuZfCw8LCEYoID0foz4oBMzEx4aFRJIhili1+ZHqt1Wq1S5YsWb16dVNTk+dViHkAgLnPCNPPuEZjBAkPWE99ff0rr7zCbgitUCgqKiqgewEAlIf7QBCEUqnMz8/funUrRVF6vX7Pnj0ajQbWH0IHiqJIksT5WDUazcGDB90KXOj6o+e3nkpNLnstW7Qgai74KWFnoVGGiRYIhOHh2K4/CzgYZtAx2jdi7x8ZRQgtEArjIr/KS2uxDZ/6xOj5lUt3LJfu/HlfNllsnDQ29ltJyaKIiCULY8XRhFvj8eoEq1GMT0z8ruf27cHBpXGL+NN6TLVarVQqKyoq1Gq151WTyQTKAwDMWfocf/qdterLkT8ghOIiZOmP/m9JFDntkd9oNLa3t9M0fenSpdWrV8NvHwBCk+nEG7klaysqKjpw4MBsJmuDMKnAkpmZif/6nZ2d6enpblfttKPjN8aq11vcZdCXvpP3NxvmQvttY2N37bRl2DboGH2UEEXww6P4fCIiIloQIQwPF4Q/lFyxo4wTx0MPOxwIodjISOHX+vYV6523Ln/8B8v0Uw5skMpiIyOXPyKWxcZFCwQSUQxb8+Hz77OrGYfWPf+T1KeDZOSCQQAA/OCsOa9/zMQ985OUNkFY1DSq0uv1GRkZc+d3B4MA8PCAgGnfTGe5QCqVgu0hlDl37twzzzyj0+ncNMaJCZfVMvjr/7xwpr7L81vfy3ku4C3HEvyf+vuaPrv2zmfXEELfeVz6vW8sjydEPIQiBYIoPp8fFhYbGRktiBCEhUWEhz9gwDEbDz3scAw5HBHh4Yujo/EKwPjExAe3TG9evNA/OsKWf3LR4j/23WM/Pi1J+MfM7444nYOO0U8o67DD8QllNQ8MmAb6uXfpMGPh4M/jgiw27vGFC3//Rc8Iw7AnNeff/8HKVdECCH4AgJDAMmJw0xwQQtcHW5+K2zGN2pYtW4ZVCE+bEQAAIcX0fY3sdntiYiJFURRFIYRgs8nghqbp7du34w0c+Hz+5cuX3eXykTHTDeuRn/6q94uv5FpJYpzli36EUOwi4m/2bYqNC6SS6Rwfp+x038jI4OjoofPvfT44iM//9nPzbz83//pHuRHh4czExOg4MzjK9NqGCYEgki+ICA+PiRASEQJhOF8QHh42FUViwuWyjTn6RkYGRkZxPHQ88ZWL0cDo6K+vf/rLyx9zy/8k9ensFU9FCQQW23D7zT8NOUbXLZGtin8UIRQlEER9vZ6Aky8hhCy2YbvTaRro//QuNTA6+rX+8BWmgX43BQNz4g8Xi9ashfcZAEIBm/OO58khZ8/0aouOjlYoFBkZGbDZCwCA8jBltFptSUkJdnn/s7ASoHTvwCxgNpvXrl1rsVhIkvTc0MPlcg3221vf+cMva9/HZxIS4/72wF8vfypxdNQ5OuKUPBYbWLWhf3Skb8R+zz4SER4+7nKxmgPLB2bT5ieXhYeFCfn8hUI04XI5x8edE+P9I2O9tuHIcH60QCAIDxcJIoiIiCgBPyKc70ORGJ+YGHI4KDs95BgdZcaJCAGOh0YI3ezva7xi4Ar6sti4H62Sr18iw3rFhMu1QBi5cWkK3tvhnt0eJRCE83jhYWFuEQtYl1gat+gF2RMIoVe/vR4vUNwaHOgdHv6Esl6lqDu0za1t3FUOAACCm0cjV3melMVM032UoijssFpVVeU2+4PyAACgPPiCpmm1Wq3RaPLy8rjnIdtSsNLa2rplyxaEkEQiOXPmjNvVsTGm59a9n/990x+vfaVUZL34TM5P0h9NiA0L40VGRaC4gLUc50K9Q9v6R0YQQmKC4IeF/eraJ54lK3+n/9WnV7+zRLps8eJvLBbjgAQh4osihC6XyzkxMTbODDscd2jb14pEGCEQRgkEbvHWrKIyOOpwTkzERkbieOjxiYkrlPVY94fc1YC/kiTkpT6N1xYQQszEBO0cG3I4RBHCxdHRsZGRA6OjE64JZsJlZxhmfHx0nIkIC+eHhQn54eG8MEF4eDiPx/WqclugGHE6//o/6t2edNfTz8ArDQChgGXE0Hz7ZbeTUeFx0w6Yhs1eAACYpvJw8+ZNhFBZWdkMOilRFBUfH48QgoFpTsEwTEVFxaFDhxBCJEm6BTm4XC7a5nj/nOGXb3bYhkcRQqKYyFcOfu/pZ5cGPBOry+UaHnNYbLYhx6hzfAIrAyNOZ+MVg5uzEAvXzycu8v9n78zjo6jv//+Za2fvTTbZzSYk5OA+stwCCbcBBVGsUNskWr8e8asW8KD9KtJC8dum2hYtCOX7+/q1VquxWqlQAypEETUgihybcMoRyJ3NubuzO7PzmZnfHxOXNRchEHK9n3/kMfOZz052Pzvz2c9r3pduTlLSyGjbGJvdYTRpKEpDUUYNikIIy3JQkrxCsJrjNCSloxktQ7EUbWK1QQk38nzT9/Xd1HjogCh+fO67t4pc4Y/8fzRy1NJRY9RVvqIoQUnyCAKWZYtWm2iJiNYb9AxDEoTdYJQVRZJlQZJUS4iHF7AiY1nmJckXDPISpgiSpSiWpkiC1FAUSRAhk4iOYZZPmbr5m4Oh/5sWPzjebLnawSwpKengKPgrAkAvVw5jIu5GSA7g+qHmW+MNU67ll3rPnj1ZWVkwvAAwwLnqZAUcxxmNxuvrpDR//vzi4uKqqqpOvhnIsXADUIMcVCN1ZmbmG2+8Eb5GxFiqrmx8bcunX3xyQm2ZcFPKimcWxcRG0DTVg287FKBc6+fUEgo6muYxfu/k8fZkg0nD3uscd7LW3SJsIMTcpORp8QljbPYWeVGxLIuSxGMcwFhdsGsoysSyGopCCKmhC+H/NFKry051qkXfEEKyovjFoEcIamnKqNFYdfrOlHJTmms4yFiWeIz9ohiUpKAkYUnGisSJIkJITzM0RTIkpaGoJp5/78TxoIz/c9JNI6O7khKt45DxnvJXhEkAANrjku/A7or/UrcXJ2zpsqmhBZBtCRg4QLaljunKI8OMjIzk5OTrFTKVl5dXXFy8Zs2aUK1ioDdgMBhGjx5dUFDw1ltvtXjU5OeEwwfPvfTbD0IGh/semTtnwViTRXeNuYmuER6Lbs5f5/c3BfkonT5Sq+MxfrPoWPgKfm5S8n+Mm3CqrjavyNXI83eOHKWGKSOE1sycU+XzHnfXfFVWerSqKmQr2FtyIaQrJjpi0xIGO2McsUaTjmFoktRQ1OGqiq2Hvm7keTXoubiutkXq1eSIyIcmTpocO0jVHkFJ8gqCH4sWjXaQyRSh1ZlZtpO1JgiCYJrzyTJm9gdyQlUjApYCWMSyLMmyR+CDkrRo+PBrKRJ34ULzZ8/JyampqXn66afT0tLy8/NfeeUVu90O/ooA0Ks4XPfa4bq/XnflgCDbEgAAoaXI1Qr3kpKS5OTkNlcYXXgAqTosuVyuoqKi7OxssDz0BkpKStSvEmN88uTJ1NTU0CFJkmuqmvLfOxRKxjpsZOzPn75tyPAYjaYnfVcEjN0c1yjwTTyv1zAmDSu0sjbMTUp+cMIkh9EkK4o3KHgEQUNSQVnS04yOYTQU1SIiuZHnT9e5D1WUf1ZS0maccXJE5KzEpKLqqnCdQBKEHHZxzk1KzhzrTIm0qqt8HmOPICCELFqtWcNa9XodTXeH4hIlSVLjJcQglmWKIGK+L/7Q5asiOTk5/DZXW3w+X4/ESsIkAAAdKAcdZV0Y/6KVHXIdTx4yR/eSbEswCQDdB1gerrN4uL7Mnz9/9OjRGzduzMvLA/HQ42CMV61atWnTJpfLFa4ZVNRkrM//eltVeaPact+j8265Y7w1ytiDBgc1RrnW728IBDQUFaHVIoQ+u3jh919+Hr7K/++5N4fLBotGG6HT6hnGL4o8FnlREiTMS1hL0WoyJYYkwz9UQBTPNdQfqar8/GJJmylQW3PfuAm3Dx+pvh9Jln1i0CMIBoYxathovcGk0bB9KlSgqKjI6XSGSwXVg7GmpuZGFoiESQAA2kRW8EH3luON76nK4a7Ev+no65yt4vo+OoRJAADxgAaO25I6fbS4YwmC6ML0UVhYWFBQ8OKLL5aUlJw9e1Y9eev4S4wxA2Wtuh+3252RkeFyuRBC+/btCxcPsqw01Ps+/vfRUDJWx6CIJ391x8gxg7Q6Tc/9WCr1gUCt39cQ4EmCsBkMBEItyq4lR0Q+PnX6WHuMrChNAq/KBjUo2cAwqjyQFSUo4YCIuWDQJwaxLPuCAieKGpLSMrSWommS1DHMWHvMWHvMvc7xkixfbGp0VVftL73UZlno0dG2l25ZpLohCRirwdBmlk20RFh1OqOGJXvUuatrpKamOp3OnJyc1atXp6SkHD16dMuWLU6ns0eUAwAALZTDR+W/rPAf6j7lgCDbEgAAXRYPreE4DiHUhTXExYsXEUJO52WPzBZ+Ec1vkaZbaxX45q4vhYWFy5YtU2t3tAhyCAbxuTPVW17Y+d2p5oXysnvSFi+bbHdYKIrskXerKEojz7v9XEMgICtKhFZLk2QXZIMKSRBamtHSTKROp+Y+EiTMY9zI80FJ8mPMi6KCkI6mtTTNUBRNkimR1pRI650jR1f5vPe83zJ97ZKRowiC8ItiI88zJGnRsmZWa9XpWIru05fum2++ec8994RuWKfT+eabb8K9AwC9RznE6SfPj8tlSF23/ke3233mzJn09HSO4/x+PzxBAAAQDx2JhB07dqgmgry8vFB7fn6+0+nsgstjVlZWaJF6VW5LwPVl8+bNarS6w+E4cOBASLyp1d/2FRS/8T+fhWKjn/zV7ROnDumpZKxqMiU356sL+HksRWq1GopqTzZgWW4IBHiMLVptSoTVZtBfcflOEARL0yxNm1lkNxhFSRIkyS8GuWAwgHEQSx5BCA+TiDEYkyMiWzgyjbM7yr0ei0ZrNxhseoNRo2Eoqh9cJ6mpqceOHVPXDePHj4eyUADQ4wRww4dlT9YHz6nK4dZBfySJbvSH3LVr1+rVq10uV2ZmZnp6+r59+x588MHWlUMBAOjfXIXLYHv+jitXrrz77ruvMf0CxDz0FKGvNSMjY/v27aEVoZqM9eXndx75ujnZzsybR9//83lXlYz1lLumURDGxTjoDlMJqZmCrng2WZHrA4HGAO8Tg2oO1k9LzofLhkitbt3suapsaOL5oCRZtNoIVhtt0F8xBeoVUest+EUxIIqcGBQlyS+KvISDGH928cLbxUUIoenxCXcMHzXGbrew2kidroWJA7ieMxdMAgAoB9zwr4v/EZDqb4xyQAiNGzcuJydnwoQJW7ZsycvLU52KIeYB6H9AzEPHXMVEo/o7ut3uxx9/PNzycF1YsmRJKCMkcCNJSkp6+eWX6+vrn332WSzKO979uvxS3ez5YxvqvOHJWH/2yJy5C1I7n4z1pLvm8Y93nq2vRwhZWPYnY5yLh4/ooD+PxY5PWMNxO787XR8I3D5i5CRH3Om62vCCzZFa3SOTp8xJTFYQqvP7VdkQazRdF9mgQpGkniT135doCEo4KEm+YNAXDGaazHcMH4kVFKXTdrJcQx8iLy8vMTFx/PjxO3bsaPPOBRMEAPSscpgY9cDEqPu7+z8WFRW5XK5HHnmkrKyseQEBBSIBYEDSJ4U7PG+4dgoLC48cObJ8+fJQy453v/7LHz9s3XPYyNin1i6JT4zqZDJWSZY9grD0n3kljY3h7X+/c5lFq+1IyJJke5HE/z598i+Hvg7tammax7i1bLju1obOoIZJiLKMEFIrQ/e3OYIgMjMzc3NzIdEKAPQSwgtI3xjlgL5PsObz+dxu97PPPpuXl6cmYRNFsUdUBEwCQPcBloeOoa/qRu2FawigCzz33HPr1q1DCM2ePVvNqiRhOe/Vz1v3vKpkrALGTQJfH/AXVVe3UA4IoXu3twwsnpuUfIWbKj4BISQrSrhyQAipyiEkGyRFaeR5LMsmlh1kNlt1uhv54L85TKL/Xi3qz7Pb7W5dLhAAgJ5VDtNtT4yJXHpj/q/BYMjMzMzJyVm8eLHb7S4sLHzsscfWr18P9gcAGGhcxT1/4cIFg8Gg5lZq7WIEhWb7BBjjhQsXFhQUIIQyMjJGjRqltp8oKm2s51p0nnHzqLsyp3YmGSuPxVrO3yjwXkFwc9y/Tp7ozJsJlW3uQgc1HSqW5Vq/HyEUqdNadfpIra5/hCb3Qs6cOZOdnQ3iAQB6lku+A7sr/kvdvr4FpDtDbm5uTk5OdnY2QkitFvfoo4/ClwIAIB7aRc2jqm6DkaEvUlJSMn36dDUf6/r169euXdu89A8EL12obd3fGmXsWDmouY9q/ZxXEBoCgZO17ndPFLdXQ+1e57h4s0Xd/qqstIPTNvF8m/UTwpkQGwey4UYyfPhwhFBhYeE1pkYAAKDLhApI94hyUH/69+zZw3Hc0aNHIeUaAIB4uDIOh8Pr9ZpMJhi1vkhhYeGMGTPU7/G9995Tl4Ctq7+FszQ7rb2zyYrSxPNuP+cPiqXepv2ll3af+66B50MdhkZazzbUh3ZHRdvmJQ9BCFEEyVLU+JhYhBBJEKEqywRCodU/gRD1w+xMOR9sb6FJZiQkgmy4kej1+oyMjBkzZqxcuXLq1KmhdgiYBoAbrBx0lHVh/ItWdkhPvRODwQAPEQAAxEOnePTRRxcsWDB27FiEUGvvhY0bN0KlmN7MoEGDEEJOp7OgoED9poJBfO501ZY/7ApVf2M0lBiU1O3HfrnQERfR+jyiJDUJQq2f8wUFV3X15xdLPr9UEjoaqdUtGz162qDBWpr2i+L+skuVXu+PRo0eY7Or2Vo9vCCj5hA3HJahlZekwPcJlwQsYUVWt1Wx8djkmzZ9/VWppwkhZGbZ/5w0ZUJsLMiGG4nb7Va93TZt2hTernozwvgAQPchK/ige8vxxvdQdxaQBgAAuP7iYdWqVZMnT37ppZdg1PoQHMexLEvTdFJSksvlGjVqlFqxu6nB/9GOw6/9pdngoFZ/Gz8lpeRcdU2VJ232iNYOSzwW6wMBj8BXen3fVlbkFR9rDDM1jI9x/Gjk6EFms1Wr12sYq05v0mhuTmn5bMxuMIbrkNC2ELbtF4OhbVVspGodr9x+Z53fH5TwaFuMVaejSBK+3BuJmqm5yy/HGCNI7AgAXVIOoQLSoBwAAOgNXHWms26q83B1bxoStHUONchh7ty54d9XMIjPnane8oed351sNjh0XP1NUZQAxvV+f6PAn62r233+7Efnvgvv8JMxqTfFxceZTBYta2RYq16vo+nuKI4mShLVfjpX4MZo0aNHj37yySc333zz1KlTOyMGMMbvvvvuqlWrEEIhf7k2Jxa73Y6+T+4EkwAwwAVDDX8iKHExurGfVK5VlUOcfvL8uFyG1MH4wCQAdDeQqvU6iweYMvoKatFuhJDD4XC5XDabTVEUzifkv/fNZYODWfvkmtvHT0kxGNnWy31ZUXxBoT4QqOP8heWX/nXy+KWmptDRJEvEomEjboobFKnTGTWaCK3OzLJgEBggV5Qadt+Z5K3PPffc1q1bd+/eXVRUlJ2dvXPnzkWLFrXuNn/+/OLi4qqqKhAPwACnKuAqqPgVL/0gyuvGFJDuJG63+8yZM+np6RzH+f3+nvJYhkkAAPHQU+IBlnr9EIzx448/rq7zMjIyVOWAsfTdqYrVP/97SDnMnj9m8xsPT5s1wmjSqsoBy/LekvM7Tp9Usyedra87VFH28tdf5ezc/uev9oeUQ3rC4Ofm3vzHBQsXDx8+0mYbFhWVFBEZCa5E/f2iWrVq1csvvyyKYmVlpc/ne/nll1V7QsduBYAaAAAgAElEQVRs27Ztw4YNqampWVlZmZmZhw4dalOWFBcXr1mzBsYZGODICm6tHGJ043qJcti1a9e4cePsdvuWLVsQQvv27XM6nfCtAcBAAywP/Q23252VlaXGtq5cuXLDhg00Tfu8/KcfuV7futfn5RFCRrP2qV/fMWFKit5wubjZoYryR3fuqAsE1N2xthijRvNV+eWcqhFa7ZLho2YlJtkMBgurtWhZo4YFJ6IBQutSshhjhmE6rg6plqR1uVxqLcLNmze/8sorx44da3HF2u12l8ulmibA8gAMZMILwIW4YTWkr8i4ceNycnImTJiwZcuWvLy8zkwCsBIA+iJgeegYiF/sbzz++OOqclBdSiRJvlRSu/VPHx4+eF7tMGnakBXP3GZ3WCjqsqFAUZRw5YAQKnZXh7ZT7TG3Dx85ISbWpGXVSGgWIl8HGA6HAyF08ODBUNDCwYMH0ZWqQ7rdboRQKL+z1Wp1uVwt+mRlZa1cuTI1NbWoqKi986hrFPgWgP6NrOCLvi9btwuSp5c8QXC5XI888khZWVnzAgJ+CABgQAJ3fn9j48aNx48ff/PNN1NTU/2c8OmHrte2furzNBsc7n903ryFznCDg1qx4ctLJeHKIcSPRo6em5g8NMrarZHQQG8mFG2v1nnIzMxcvHjxa6+9VlBQkJGRIQhCBwsI1Rna6/WGWlo4ORQWFhYUFLz44oslJSVnz55FCJWUlMTHx7c4J6xRgH7PWc+eg+7NAam+9aGxkXf3hneYkpKCEBIEIVxOXPEJQvgjgA7uZYxxQ0MDJHwHABAPwA1C9UfPzc01GAw2m+3YsWOyrFwqqf2fDR99+9U5tc+kaUMeWXXroARryOAgYNwk8G7Od6Sq8rWjh1uf9tYhw5ZPmQqR0AMcNXgmxNtvv/3222+r2wUFBW63u4M6DwaDwel0FhUVqW5L+fn5c+bMCe9w8eLFFopCrWTf2guihX8CiFig31AVcO2vfrE+2DxXM4ReVPyho3G6iSYmtje8T4PBkJmZmZOTs3jxYrfbXVhY+Nhjj61fv/6K2r7jlGscx915552qwdzhcKxZs2b58uVwVQAAiAegG3G73WpU9IkTJ/bs2YMQ4gPBTz8q+uvmT7yeAGplcAilXq3x+z44fXr76ZNNAt/mme9xjkuKiIRV2gDnGr2K58yZ88ILL6SlpZ04cWLv3r2vvvoqQmjz5s0IoeXLl2dlZYXyNanZnMCJGRiwskFHWafalqeY5kqKWNTwD0HyjI28u5coB5Xc3NycnBz1gUJBQcHKlSsfffTRzrwqlHJtxowZLVKu+f3+mTNnvvjiiw6H45133lmxYsXixYt7JIgCAIBOAgHTfZvCwsJly5apeTN37tx5660LKysatrywq02Dg+qh1CTwZ2pr/3XqxO7zZ0PnsbDa8TGOfWG1otPiB795149hhAEVjuPcbncXftE5jtuwYcO6descDseGDRvuvvtumqZVwdCiXMxViQeYBIA+jVes/KL6D2oBh3DZ0EuSsV7xpj569Oj48eM7WV1+3LhxTz/9tHrXZ2VljRw5cu3atR3c2i+//HJnjA8wCQDdBwRMg3jot2zevHnFihUEIuPiBn9ZuDcuLr5w76ktf9jV2uDwvYcSd6Sq4pXD35Z6LpdrSDBbMsc6Zw4eHKnTa2n6WHWVRxAmxcbFmy0wwkCIkpKS5ORkp9P5+9//fsGCBVcbhBCqdK7uqoHULfybr0qfwCQA9F3Z8E3t/573FoRaJkY9MN56b++XDRjjUKh0CJvN1rGE6EzKtRBq7rX2qsHAJACAeOgl4gHclvokGOOFCxd+UvBpSuzsIfHphKL52+avRFE6tL/ZmKAaHOLiIzGSy5qa2vRQmjoo/qdjnKNsNpveYNRoGIpCCM1NSoHhBVqTlJT05Zdfbtmy5bbbbkMIrV+//mc/+1nnDREtlhdthkUaDIZOPsgEgL5IADcccG9qIRtSI3/aV4pGl5WVJScnt27PyMhYsmRJe7aCzqRcC/2uZWRkZGRktKccwIcWAHoJIB765tdG0wihsck/io1KRQpCCB3Ydzp0dMXTi+bcmiozqMznOVZV9eHZMy08lDKSh/xkbGqMwRip0xkYBmZkoDOkp6enp6e/8sorr7322u9+97t169ZlZGT85je/aRH+CABAC0Q5UNTwj8N1fw21jIlYNjn64b4iG1Ti4+MzMjJqamqefvrp1NTUffv2/e53v7v77rujoqJWrFgxe/Zs1bbQgiumXAsph4ULF9bU1Ozfv789aQEXEgCAeAC6Asdx6tPZ9/+1Y+m8P7Y4aneY1/zhbmu85aK/qbD04ltFrhYeStmpzvSEwTaD0cyyWhoS5wNXjcFgWLx4cX19/bp16woKCgoKCpxO544dOyDAEQA6IxtSTBlToh/uVWHQnaSsrKygoMDn86m/QampqSkpKQ8++GBlZeWpU6fef//9NsXDFVOuhZRDcXGxy+Vqz/xI0zSkXAMAEA/A1YExzs3NXbduXU1Njc1m++qL79T2gI0UDaSxDJMYJQy3+yPQqwe+LLhwLtxDaUHK0LtGjh4WFRWh1Vm0WigLDXTtCty9e/fq1atdLpfT6XzrrbeWLFni9/uzsrJeeumljRs3whABQAhZwee9ez+req4fyAaVcOuBisViqaqqwhgvXrw4Pz+/vRd2nHJNVQ4FBQU7d+7kOE59QAYFHwAAxANwrYRnwt66deuqJ//rwnfVARtZOVsr6UiEUDVCkUXBY8OEf/zzH5dndlZ754hRt48YYdcbocQbcC2ogYwIoZUrV6olCNV2g8Fw//33d7BuAICBQL1w7nRTfkBqHB3xo2h2RInv8/CKb1bNkDmxv7ayQ/r0Z0xNTXU6nTk5OatXr3Y4HGfOnAnVeVArPLZHbm7uhg0bkpOT1ZRrCxYsQAip7knLly9XDRoIITWeCiGUmZnZIhUbAAC9Csi21AcoKSmZPn26mo9106ZNixfe/dJvPzh9vPziYl0wkmrzJfFm839Ouml8jCPGaLKwrBoMDQDXIh7eeeed+++/v5fENEOiFaD3cLxh2wH3n0O7JKJlhEOyIS3mKYfO2T8+qVoYLhTxnJGRsX37doPBsGvXrtGjR3fsu9heyrXWSZw6aXmASQDoPiDbUseA5aG3s2vXLvV5jMPhePvtf9SVax7J/B+EkBBBtqkcFqQMXTZ6zFBrlFWnM2rYHvRQkhVcxh0UJF+84SYdHQlfZZ/GZrOp2VTcbjfHcZdlanz81aZtBYD+hCgHwpUDQkhVDjrKenPcf/cb2aDe+xcvXjx27Jjb7T5z5kx4nYfOZFZtL+UaTdMQMQUAfQv41e/VFBUVqcohNTX13Xe2/33r/kMHmqu/JU6Pu4QaW/S/bdiw1TPmWHW6Hg+GruAO7yp/PLSbaJg5y7GaIjQUwRAECd9sXyQvL2/VqlWqBSzEhQsX4IcfGMhU+o+2bhykv+mWQS/0iYpvnefMmTPZ2dlZWVk2mw1iEgAAxAPQS0lNTV25cmV1dc2TK37zq+XvqdXf9BbtyJwx71Sfbt0/O3VCnMncg29YUeSgzPFS0yeVvw5vv8h9cdE3I1KTTBIMTWoZUkuTeprQEIiCMIw+Acdx2dnZanmH8Pb4+HgYHGAgY2TsrRtjdGP7mXJACA0fPhwhVFhYCNmZAQDEA9DrKCoqKi0tVQ3Bv33u+b/86cO1TzSHQSemDTrhlI+1pRzS4gdPi0/oIc2gSEpQkJp4yYNlvoYvFmRPiz7feT4cb72PIhheakQIUQRDkToKUTSpZ0gtTWopgul/P7f9hvPnzyOEnn32WXBSAoBwrOwQM5PgEUvDG1Mjf9r/Pqler8/IyJgxY8bKlSunTp0aal+yZAmUdwQAEA9AT5KXl5ednY0QOnr0GEtbX/j1+xWl9QghhUDmB5MLBDfiEELIwrK/mzd/jM2+t+TCxabGn4xJHRndA3ZkWcFBmQvgBlH2i7JfVnBl4MjJxh2te1YGjlaWH9VSlnj9tBjd2AhmMFKkoBLwS7UkwVBIQ5EsRdAa0kCTOorQkARNEhDn3VtISUlBCJWVlYGTEgC0wMwMCokHLRU5zbaib1V/6yRut1tNi7Rp06bw9gsXLoB4AAAQD0DPgDFetWqVOi/Pmzdv/yeXtr/9vnrIMjnqdKpyVnCruw9NmJQ1dlysycTS9H+M74FYZEWRRYXncVNQ9okyh2XBh6u+83xYwx/v+IW81HTW+/FZ78cIIVVIJBimmpl4kqAkJRiUPRyuoQiWJliSYCiS1ZA6mtRTiCYJGoIlekrNqhsZGRnJycnw0BEAwhHlQJn/K4RQomHWNPvyvlvG4YokJSVBdiMAABCkau09uN3ujIwMNQXeQw88psPjT5+oQAjJNEI/cZwjfWq3sTb7L9JmToyNMzBMj0QLYFkQZX8A12NFCMpeWZFKuQMXfHt56XIpawuTEK+/6XjTtlBLrG7C2IgfN4oXqwKuUu5A69NamIR4w0127RgLM5giGUkRJSWIZUFBEk1ov3dw0tGkJvQSimCJK5kmSER1YL6AiItO3m4dHO2pgGnI0gj0Eg7XvaYWkP5J8rv9WDm0+LU6c+ZMeno6x3F+v7+ngqdhEgC6D0jV2jE9b3nAGDc0NAzw1A2FhYXLli1T89g8/9z/ffrvMoQqEELCKN2lyRRCPoSQhWUfmjD5x2PGRusNNz4Bq6xIQdknSN6g5BWVgKzgxuDFk43vN/3Q03eU5c5Y3QSWMjOkfqj5Vo9YJiq8VZPCkDos8wxliGZHTrDeJ0jehuCFysCRkJBoEkubGkuPo23hQsLKDiUQISNJkoNVfHG5/xte8sToxjp042hSS6IrKAcCUWSY2GgNQ+rMTBw4R3UM/DwDQHuIckBVDimmjIGgHHbt2qXWmM/MzExPT9+3b9+DDz5YWVkJVwIADCh6UjyEV012OBxr1qxRE8kPTKqqqmJjBv30jnWf/rsMISQaiIbFliZNc6Wh9ITEZ2fMSom0sjc2XFVRFKzwAvYIsleUOazwWObL/d+ebHo/vJtdO2a4+TYDbadJVkMaGdKgoyNoQmvTjQydR1KCWOEFySvKAZrUWtkUu3b05KiHfGJ1rXC63P9tDV/cWkjYtWMH6SfVCd9d4varR6t51+mm/EXxf+540a8gRVYwQkr7cgj7sY9EtIlxgP2hY3nfcZD0FTsAQH+lqKE5lcWU6IcHwuddvXp1Tk7OhAkTtmzZghBasGBBVVVVSUkJhEIBAIiHG4Tf7585c+aLL77ocDjeeeedFStWLF68eEDNQRhjhBBN09Onp73+6vs73jp9/EiFQiDvJF31KAohjBCysNrnb14wPSHBpGHbXOMGcANW+Ov+0EuSg6ISCI+Erhe+O+P5MNzUoKUsyca58fqpNKllSD1D6nV0pIY0tE6aRBAETbA0YrWURZKDWBEESQ2W4GlSF6ufMNiQThI0h6vd/KlwIVHDF4e2Qwiyp9J/1MqmIIQMTLs2K4pg2pENUr1w9njjtsbgpTERdw0332bSxMJc0B4Mw6xfv37VqlWtYxtKSkreeOONU6dOheIiAGDgMNDMDkVFRS6X65FHHgkVhIanBgAwMOlFLoMEQbz88sudMT70D09HNchh6dKlv/zFM6/95ZMd73yNEArYyJoMQ5Bu/nQPT5zys3HjYwxGiiTblA17K9dXBL5V1/ETox5IMs5SD5EEQxKdrRMXHhhQL5z3BMus7DCs8EHZqygyjxtK/V+d9e4Of0mCflqicZaJiSUJOtzUcFWP8GVFkpRgUPIKkldSgqISUBSZIXU0wSJE+nBFuf9QGfd1C8+o9rAwCWZNPEKIJc1R7BC1MYodrm7oaGvoMx6pe0ON2FZhSfPdye+wlBGmgzYpLCx87LHHXC5XRkaGzWZbvHhxfX39/v37jx8/rnov5Obm3njND+7OQI8z0KIdOI4zGo0+n8/tdj/77LN5eXlFRUVOp1MUxR5RETAJAN0HxDx0TG95bOB2u9H36SAHyIJsxowZCKEzpy6dP2ypLG+UaVQ9jfUlM6qnTao9ZvWMWeMdse3VilYUeWfZisbgRXWXl5r217ykJS0aykggiuq0cggFBtQJ3x2r/7tXLFfbR1vuYkj9ac8H4ZHQLGkZaVkcq5tIEGTHpoZOiRaCIgkdQ+r0tE1SgqLsF2QflnlB9kmKwFKW4eZFoyx3esSK3RVPX/FsTWJpSGac9bbbjSXNLWpQCLLnkq9wiPlmqDLRJunp6ceOHSssLPzkk09OnTqVnZ3tcDjmzp27dOnSHTt2gLsCMDAZaGYHhJDBYMjMzMzJyVm8eLHb7VYfK6xfvx7sDwAw0OgVwh1jPGnSJLvdvmfPnn7/vOH4sUu5a18rv+g7XfqxxRSRaLsZIeRJoqtnatUOFlb7yKQpmanO9vyU1NIKtfzpj8pXtT5q147RkKYWjSYm1sjEtGhkSL2JiZUVSd09UPOSD1e397aHmhbE66fqaKtqamBJE0ubr9bU0BlaODWJCkcRms+rXwipGpUFsS/QJOsRy0WZQwj5cLVHrEAICZK3tZvTFYnVTZgR87SZiYPghz4zc8FDR6BHGYBJlhBCJSUlOTk5aqQiQmjlypW/+tWvINsS0P8Ay0PH9IpsSwsXLqypqdm/f397HRiG6R+X4/tvH/ifF3fLNKKMRmfKUoSQaCAq5mqDkc0eNbMGJ/1m9twES0SbfkqygnmpMYAbOew+2bS9zX9xxUoLV4WFSRhuXmhlh5EEzZB6DWXSUmYNaey+DEUUqaGQhqVMsiJhRRAlnyB502xPuhryKgOHEUImJm6i9T9MGgeByA4CHhBCguTBsoAQCkj1flyLEArKXFXAVRk40qJnFDvcj90MyerpaJg028Ttdn/zzTezZ8+Gqg4AMADNDipJSUl79uzhOO7o0aPjx4+H2QAABiY9LB5U5VBcXOxyudqbhmiabvF0oY8+HpawvHnL7qZUpn48ixDSNEjaaskzsjmXaASrfW7uzfOSh+jbUkpYFnjcKMjehuCFC77PLvo+b/NfRLEjdFRki4Fqs65CZ4jROidG3R8yNWjpCIrQ3LDBJwlKQ+g1pF5PR5s18dHa4U3BUkHm9HSUJAcEyYsVHiFEERoCkRShIQiSJGgCESHvI5YysxRCzUHVI9TGoeYFH5c/4/lhHEWCfhpCCie6aVKvIfUwL7Rg3LhxagUShND69evXrl0LYwIMZAZakqUWGAyG9PR0uAwAAMRDjymHgoKCnTt3chzHcZzBYOjHBR/cNR73FDWqASGEgpFUyOBwT+q4FTdNj9brWy/NsSz4cb0ge6v9R483bfOKFaFDWtLCy+EBCaap0Y+FbAIykmRFRAiNiViKEGoRCCHKARlJ4f9oX9Vvg7IvvGWo+RYDE9PdpoYrQhAkTbA0yeroSFnBCCGsBBVFkhRBUeSgzCmKLCFJUaSg7FOQIikCQogmtAghmtSqcoJAZKhA9RzHs0fq3wjXVN/WvzrD/ouA1OALVlo0CVSH1SEGGm632+VyvfXWW2lpaS+99NLWrVtBPAADmQFrdkAIqTYHNfwp1Lhx48YBXqkJAEA83DjKyspU18nbbrtNbcnMzOx/OR8xxu++++6Pf/zjY6cuhZRDCJ1CvfHjHztjHAz1g9W5oiiiEgjger9YW+Y/eKpphyBfjgKO001KMc2zskP9uK7UfyAoeQcb0hONs1CY9JBkQQmTB4LkCy96QJG6sH8mSUpwmHnh8cZ/htrs2tRh5ltupKmhM6hWBU2zbcGEEDIgpCiKgiRZkVS9JCsiloOSIsiKJCNZVrAoByRFVJCkKiiSoCdFPTgh8j4FSSeb/n3W+3ENX3za88EIy+0B3EBijYUZFFIawJ49e5xOZ1ZWFkIoNzd306ZNkNYdGMgMZLNDWlpaKPEaXAkAAOKhB4iPj79w4UJ4S/9zoFQL4X1S8Onbr+3jxEHorpYfMD0xcVLcoB/KBllU+ACubxDOl/j2hedIZUlzgiFtiClDT0ep2VFt2lFJppntLLR/4H4T7s2vrrZDu+qy26odNiZy2emm/KZg6ZiIpbH68X1lkAmCIBDdOleSrEgIKZIiKkhRpZSqoCQFK0iREcYK74zMdPMnmsTS443b7NoxZiY+gOtopDFqYmB2CDFmzJj+eocCwFUxkM0OhYWFLperpqYGlAMAgHjouf9N0/37+WVRUdGCBQvqaj3TRj/M+xzu6W04w9w2amS4bBBkbwDXV/ldpzz/rhPOhA6ZmLhk45zBhhksZbqW7Kjhq+3LKuP7U2lIfX96lqa6WjV/OlIfUlCq75MoB7xiFS83zopZ/UHZYwihA+6NC+KeJxDhl+poSaulLDBBqOzdu1e1PKjk5OSEVg/gsQAMKAay2WHQoEEIIb0eosIAAMQD0D3k5eVlZ2c7rKlzxz/CxVElaayka+kJE6XTzU8Zir7PvsqJ7hLfZ2c9u724MtQnVjch0TjLoRunIY1dKMQGtCUqaIQQS5lkBeOgHxFohv2XX9b8kZeavnJvmWH/ZUCq50Q3TWhpkoXhSkxMnDt3bmg3MzMTxgQYmITMDnH6yQPN7IAQSkpKysjIePbZZx966KHU1FS4HgAAxANw3cAYr1q1asvmrZOG3xtpHVI57XKQ9KzBiVmp4176an+tn7vXOeGhiZO1NOHHtY3Cpe+8H33n+TD8PENNC4aYFhgZu462XqOpAWgTLRUh0rxXLLdrRw813fJ98MO/R1ru4LCbwqyZievBSPFeQnp6OmRWAQAUZnaYGHX/wByB+++/Pzs7e9OmTeGNFy5cgCAoAADxAFwrxUcuzUhdiWyWkgytanCI0GpXp8+6Y8TwUv/nD6V/0hC8MMrCe4LGqkDtyabtagUDFQ1pGhVxZ6JhlpaygKmhWyEIwsjYJIX347oWwQ8RmkQ/dtNIY2DsMP4AAITMDlbNEIfOOQBHwO12Z2dnZ2Zm3nPPPaNHjw61x8fHw+UBACAegC6CMVZkYtPzOyl+fP10TdOo5iCHCY7YrbctsRsMB2o2Hm98T2082fT+yab3w18exQ4babnToUsFU8MNgyRoAxODZV6QPbMdz/679FH0ffADRTAcdlOkRkdHwkABwAAnZHZIi3lqYI5AVVUVQuiNN96gafhtAgAQD8D1YPPmzS/8fuPUUTm1hFC+VB+KcFg7a+69zvEUSQYlf0g5tGCYeWGScW6kJglMDTceDak3MLamYBmBqPDgh1kxz/ilWh9206SWCc9sCwDAAAPMDgghh8OBECorKwMnJQAA8QBcKxjje+65d//e86MS7zk3TGoa1ZyMYoIj9qVbbhtssSiKEpT9l3z7W782UpMyK2a1SRMLpoYeREdZg3SAE6tjdGNDwQ/nvHuGmDJ8uNonMhbNYAh+AIABC5gdEEJ6vT4jIyM5OXnlypVTp04NtS9ZsgSSOAMAiAfgKnC73fNvXkgLo1Ociy98H+GAvjc4kAQRlP21gdPHGv5e7v+m9cuHmRdGa0eAqaFnIQjSRMdIsuDH9c7ILDX44Uj96zbtSCPt8OM6ktCYmTj4mgBgAAJmh9CPnVrXtXXANIgHAADxAHSWwsLCB+99ZnD07e50zaXvIxwmOmJfvOW2BLNZVAIl3gPf1r3iEcvbO8OoiCWwJO0NUKTGwNiwzIsKl25ftav8CYTQ59XPLxz0IkPqAriWIdnwQnsAAAwQwOygkpSUpCgKXA8AAIB46DqffrLviZyXHUMWhBsc1s+ZlzXWGZS9RQ3/ONW0I1w2jDDfnmycV8kfPt2Uz0sNKaaM8dZ7wJm+98CSZgNt8+ByljJNjX7sYO1feKmpsOalWTHPNFd+IPUaEgokAcAAAswOAAAAIB6uD2dPVf7lha+pWyaFGxxeumVRpF4obvyHq/4tQfaGOo+0LBltWWrWxFGEJt44eQCWJu0TEAShZ6JFxe/HdQmG6RWBI6XcgVDwA4drfcHKCDYRQlMAYOAAZgcAAAAQD9dKVVX1xtx/HzhZVZ6hlXTNyuE3s+feOSquqOGvH1dfzr7KkiZnZNZQ8606OgJWnH0CkqCMjAMrYkBqmBL1iJs/wUtNzcEPTGwAN1Aia2biCIKEsQKAfg+YHQAAAEA8dAUJy98ePOfz8qOdCd98803umn/xMwc33d7svjLREbt+3qhSPu/dkq9CLzEzgyZF5cTpJ2kpMyw0+xYMqTPQVk8wICnCPMf68OAHDWnw41oKMUZNDAwUAPR7wOwAAAAA4uGqOX7s0orH/+ZJoYMWMmKTSGBUe29KKMJhzRxHnPXwgfqtof427ejUiJ8ONqZRhAYiofsoOipKpHmfWKWjI8ODH2Y7VmPM+6U6RtKzlAkGCgD6MbKCTzZuR2B2AAAAAPFwVfzir9tL7jIQhKyjxbLkZmsDQchzkuWbRx32SxXl/uae8fqpE6MeiGKHUqQGxq1PQxCEiXFIshDADQmGtFDww1nP7iGm+Rx2+8RqitDQJAtj1Ukwxgih9grTYowbGhpsNhsMFNB7OO/dG5DqEZgdAAAAfgh41HREWVn9uUGBGUNOrZzz0RM3f7jE+Y3d1DgmtvSZ+Z9MH57vlyrUbqMjlv40+b1bBv3BrhsNyqGf3BgEbWDsDKnnpcaboh/VUhaE0JH61/24Vk9beanRh2tkRYKB6oxsyMvLS0hISEhIKCwsbHGU47j58+czDGO322NjYzdv3gwjBvQGZAUfdG9GYHYAAAAA8XBVuAPcbTcdmTXslIENIoTGxJU/lP7ZknHfEiSHEGJJ8wTrA1kpO6bbHjcyMRDb0M9gKZOeipKRJCnBeY71auOnVesQIljK5Mduv1gLWc+vSG5u7qpVq3bv3r1hw4YZM2bs2rUr/Kjf7585c6bL5aqpqVmzZs2KFStKSkpg0IAeB8wOAAAAIB6uGgnLr27eOSaujfpuZiY+zf7kT5PfmxR9v562QmxDf0XPROtpG/uOpgIAACAASURBVC816umoqdGPIYR4qenr2q0MqaMIhsNuQfbAKHXMtm3bNmzYkJqampWVlZmZeejQofCjNptt7dq1qampNptt+fLlCKH8/HwYNKBnAbMDAAAAiIer5ux3F+ctXHdgaHXrQ5HM2GVJb46OuIuhoL5bf789CMpAR2spq1+qSzCkJRimI4RKuQOXfIUsaZaQ4BNrRDkAA9UeHMe5XK7U1FR1Ny0tbdu2be11drvdCKGUlBQYN6BnAbMDAAAAiIer4x9//zh7/Vtld5iHDa5qfXRkRAZJUDBKAwSG1BnoaBLRQdk3OeohNfjhYO1f/LhWT0XxUr1PrIbgh471gMnUnJnKarW6XK42e2KMMzIyMjIyFi1a1OZR4ofA2ALdBJgdugmMsZo4AQAAEA/9CgnLT/38z7mHj3Dp6IG0zzJGFbfuM9yyCAZqQKGlIvS0XZQDBCJnxTyjNn5atU5Bio6K9ONan1gDwQ9toiZQ8novV1t3Op1trioWLlxYU1Ozffv2Ns9D07TyQ2BsgW4CzA7dIRs6yJqAENq8efO4ceMIgsjKyoLhAgAQD30Jn9e/+M61HwwWE9Oqnrj5wxiTByFkphNuin4sUpOMEJoY9cBPkt9lSPBWGlgQBGFkbDoqMiA1mpn4Cdb70PfBDzSpZUidH9fwUiMMVGsMBoPT6SwqKlJ38/Pz58yZ06ZyKC4udrlcBoMBBg3oQcDs0B10nDVB5emnn27zyQIAAL0QqPPQTGV5w11PbPTepr973IHkaLfa6IzMmhT1EEUyTmsmDNGAFtkEbdTESkIwIDUMNS8o939bwxeXcgfidBMSDGkBqd6H3SRBQ+W41syZM+eFF15IS0s7ceLE3r17X331VYSQmpJ1+fLlqnIoKCjYuXMnx3EcxxkMBij4APQUYHboDkJZE1JTU/Pz8w8dOtTCOxGSJQBAH1sUwRAghD7OP3LLn/6f8UfcQzM+VZWDlrIsSXjlJtujFMnA+AAIIQ2p19NRCBGiHEi3Pxke/KCjIoOSxxMsaxBK/Lg2KPshCiJEbm7u0qVLk5OTH3zwwQ0bNixYsAAhtH///v379yOEysrKCgoKEEK33XZbcnJycnLy448/DoMG9AhgdugOriprAgAAfYKBbnmQsPzzp7Z8Pth3y5JjoaysI8yL0+xPgWwAWqCno0VF4MRqPW2dFfPM7orVCKFPq9bdFv+ynraKciAg1flxLU1oKZJlSJ2GNNCklibYgVwDxGAwrF27dtWqVSzLhipMb9y4Ud2Ij4+/cOFCi/5wpQE9ApgduoPOZ00AAADEQx+gzt10xxN/wjcTD0/Zb2QFhBBLWmbGPJ1kmglXBtAagiBNdAyWeT+uNzMJE6z3Hal/XQ1+mGZbzlImFpkURZaUIFZ4QWwiCJImtBShYUiDhtKr2wMzU1ALSRByTKJpOikpCS4toMcBs0M30cmsCVcEY8ww8EQPAEA89Cj79h5Z8e/86fddmpJ0Xm1JNMya7VijofRwWQDtQZEaI2OXZEGQPeHBD3X8d5ISHGqeP9y8iCa1NNIiCimKjBVBlLmAVEdhliZYitCwlIkmdTTBUqQGxhMAeglgdui+Bwdq1gTVc6nNrAmdWqzQdIs0a5CyGQBAPNxQ1uW+kW+68MADX6gGB4TQrJhnh1sWwgUBXBGWNOvoKB+uxDKfbn9yR+kjsiL6pVqE0PHGbWc9exYnbFYrgRAEyRA6NT2XpIiSHBRkj19S/Zp0NKFhKSNN6mmChcohANCDhMwOOsoKZofrTsdZExBCHMe53W7VwamkpASyJgAAiIfehYTlhY/9t2VRzaOjm90ubWzq/Ljf6ZlIuBqAzkAQhJGxSwrvx3UsaZQVMfyoIHvqhbPR2hEtXkURDEUxGmRQFEVWRKwIAdkLARIA0BsImR2m2pbDaFx3cnNzN2zYkJyc7HA4wrMmhMTDjh07srOz1c7JycmZmZl5eXkwbgDQexdCfbHcEkF08W3X1nmX/XHj/B8fUGs4IISmRi9Ptf4ErgPgahHlQGOw9KJv39H6N1ocIgkmxTjPoXOamUEGpqPnZ98HSAhYFloESDCEDvyaumMSAIAWyAp++/zSgFSvo6yZKdtIAjKYdwscx4VnTVDtDKqFQbU8hHp20vIAkwDQfbz2zaUb84+m3XvLDftQo06dvF6nGkCz5JcHz/zp5OZ7Hjii7mqJ+DsSN5g1cXCTAF2AIXUG2hqpSWlrLSKe9X581vuxuptgmB6nmxDFDtfR1hbuSapgaDNAQkMaDYxNTQgLAED3EW52AOXQfbSXNUE9BGnWAKAP0SsmSowxQij0QOK6I2H50d//2Xbzl4vTmp9tjLXce5P9AfidAK4FHRUVrR1hpGN9uDK8fZD+pnL/16HdUu5AKXdA3bZrxw7ST7JpR5qYQa2FRHiARAA3SEoQU7yBsUNcIAB0E+HRDimmuTAgAAAAvV08YIzffffdVatWIYTee++99PT063XmgCBcqi0bMWhIY5Pvob/+asadxWpstIQNy1I2R2mHwncPXCMEQRhp++yY1cWN/7zIfaFqg/HWbItmMEJIkDz1wvmqgKvM/xUvNakvqeGLa/hiddvCJMQbbrJrx0RoEmlSGzptLX+6lDsoSJ54w9QITZKERBPjAKELANedAG446ykAswMAAMDVrX961mXwueee27p16+7du4uKirKzs3fu3Nmian17i7YO3nZAEJ7/dLU1/piBDZbXRPOYGBLXbHAwSnPvHrkWfiGA64ggeZuCpUHJp6H0LGVuWyTLfGPwYg1/vIz7ukksbd1BS1ni9dMcOme5/9AF395QezQ7Ykr0I3o6ysg4VKME0JlJAACuKBt2lT3REGzO080QhnuH5sNPA0wCAKACMQ8d08Nz5bZt2zZs2JCampqampqfn3/o0KHOiIeOyf3ywcQhF9XtQfZadYMLsAsG/XZU9DS4JYDrC0uZ9FQUVniSaLeAEU1qo7UjorUjRkfchWWewzVu/pRaI0LtwEtN4WESIWqF037sRghJCjYydpY0gwsTAFw74coBISQqnKSIIB4AAAA6Q08mheQ4zuVyqYVjEEJpaWnbtm27xnPWNNYlJlxs0VjXaH54zA5QDkA3oWei9bQtKHNesdKP6wTJK8lBRZHbExIWzeCh5gWzHauXJr6xaNCfp0Y/lmCY3t7Jy/3fGujooOxpEko5saa90wIA0EnqhXPhykGlqOEfMDIAAAC9XTyoqdlMJpO6a7VaXS5X624YY+KHhA797//+L0JIlmV1QxTF7e9uQwgpEi1/di9CSP3r80b+/a9vtfmS8NeqG+rf1hu94SVtvhZe0uMv+b9XXjUzsflvHopgkrRUxPa/F4oy7xPr3vnbRwHcwIu+d/72kaLIWMTv/O0jhNA7f/tI3fjn63sMjG2wMf3izqE/TnprqnWFesUqMtG8IdFnPrATBJn/5rc73tzvxZWvvPJ/khzsps8CAAOBUu5g68bG4CUYGQAAgM7Qky6DHMcZjcaQ8SEvL++FF144duzYld90+56OAUF462JGi8aqc/N+tXA9fNnADUBRFAVJWAlKsiDKASwHJCRJckBSRIQQRTA0qSUJmkRUm8XgPi5/2iOWtWicYf9lrH48QigocUGZ01GRRk2shtQP6JkL3J2Bq0RWcA1/Yn/1i/XBc62PLk7YArWlYRIAABWIeeiYnnTxNBgMTqezqKhIFQ/5+flz5sy5xnPqWLb03JSEId+ENz48fSXcCcAN+z0jEK0haETqdSgypCWw7BdlXpIFSQkGZR9WeAJRqpagCIZAlGpSm2b7+Vfuv3jEUoQQTWixwiOEvqz545iIpSMtSzSUgSI1AdwgBSUjbdNSERACAQCdkQ3nvXsPujeriZUQQgyhFxX/5R8OKhKUAwAAQB8QDwihOXPmvPDCC2lpaSdOnNi7d++rr7567ed8Zt7v3zjw9wbD+9EWT+m5KQuH3GOPiIJvGuhZLaEaChRFlhUsIYxlf1AOSLIgK6Ige7HCkwRNERo9bZsf99ugxElK0MDYavnTB9wbeanpeOM2N3863f4kTWoNdHRAavAEgxId1DPRLepFAADQgWzQUdaptuUpprmNwYunm/IDUuNQ04J4wxQYKwAAgM6ubXrW6sdx3IYNG9atW+dwODZs2HD33Xd3plQcGCuB/rKykWQFS0pQUgRB8koKlhVR3aUJrZayEAQpSJ59VblqglctZZnnWG9gbIqiCLJHUkQ9bTPRMRSpGYCqDCYBoGuyAbIqwSQAAB0Dbku9WjyEJATLsp2vMA1TBtCPtQRWeEkW/LguKHN62koStKxIX9duDZWpDoVAiHJAkLxaKsLIxLCUCdYNAACyASYBAADx0N3ioVfMpAaDAa5UACAJiiQoGrGIQjSp84nVflyvpcw0qZ1mWx7NDj9S/zoKC4FgSB1J0AHcICuigbHpqCgIgQBANoBsAAAA6FZgPgWA3ghLmShCQ2HWj92SImpI41DzgghNYvshEOWYFo2MHUIgAJANIBsAAAC6jz5p9QNjJTBglkSST6zhcDVCio6K7CAEIij7RDlgYGKMtJ0m2f4/c8EkALQjG6yaIWkxT0H2JJgEAKDLgNtSx8AjGQDovZAEZWIcNMn4xBoO1+ppK0uZM+J+p4ZA8FLTrvIn1BAIljJRBOMTKyRZMDA2LWWB0QP6n04o474Jyr5E4wyG1IFsAAAA6BFAPABAr4YgCD0dTRGsT6zmsFtHRbYXAkGTWgNh8+N6SQlKtKCnbRACAfQbqgKugoo1vNSo7sbqJlQGjoSOgmwAAAAA8QAAwGVCIRCcWM0oIkuZ2g+BsAWkeo9YgZWgiYmFEAigf1BQ8auQckAIhZQDyAYAAIAbDAlDAAB9Q+iTrJmJMzKxkiL6cZ2iKNHaEQvinrcwCQihGr74w/KnONFNEISejqIIxidWNQUviXIAhg7o61QFXLzU0FJRk5bFCVvuSvobKAcAAAAQDwAAtHW7EpSZiTMzcRTBctitKLIaApFgmI4QUkMgKv1HEUIsZdJRERyuaQqW8VIThBUCfRpvsLx141DzfJANAAAAIB4AAOgIgiAMjN2sGaSlIny4WpKDJEFNsy2fYL1P7fBlzR9PNP5LViSK1BjpmKDs8QTL/bgWhg7oiwRww6eV6/dV57Y+NMKyGMYHAADgxgMxDwDQ99BSFprQkiLlx3WMousgBEJPRful2qDsMyAbjBvQh5AVfLJxxwH3n9s8GqebaGWHwCgBAACAeAAAoHO3LslaNINJgvHjWj+u01FWNQRCrQKhhkCoVSBIuM2BvkZVwPVJxa9DOVhTTBkzY/4LIXSmaZcge4aZbzUxsTBKAHAt3LBSBgih+6cMhgEH8QAAQM9DEpSZGUQhxi/VcdhtoKPVEIhj9W+d9X6shkAMNqRXBY4FZd/EqAdGWe7U0ZEwbkBvxitWflH9hwr/IXXXqhkyJ/bXISPDmMilMEQAAAAgHgAA6CJqCARNadUqcjoqgiI1E6J+FsUOOVj7F4TQJa5Q7Xm47q8nGt/PSvkXScBdD/RGZAUfrf/74bq/qrs6yjrVtnyoeT6MDAAAAIgHAACup37QUhaK0PhE2o/rNIpBQxkGG9M1pPGLmj+E9+SlhjLum8HG6TBoQG/jrGdPeK3oMRHLJkc/zJA6GBkAAAAQDwAAXH8YUmfRJKghEBIOaqmIoOxrY4nm3Q3iAehVeMXKPeWr64Pn1N04/eSZMf8FIQ3XFyzLQUnSMwwMBQAAIB4AAGiGJGgzE0chhsNuv1RrZYe27jPUtAAGCugliHLgi+o/nPcWqLs6yjoz5hkQt9eXOr//raJjfz64HyF0+/CRv0ybEW+2wLAAAADiAQAAhBAiCFINgfCK1UHJY2biPWJZ6KiWiow3TIFRAnocWcHnvXs/q3ou1DLd9sSoiCV9OiDHL4oBUYzS63vVu7rn/X+ermsu8/LBmVMfnDl1ZvmTNAklngAAAPEAAECzfmgOgfAGK6ZGL7/EFV7w7Q1lW4JoaaDHqQq49le/GPJTSjFlTLet7NN5wFo83X908k0jo3tFWZWi6qqQcgjxxaWSuUkpcB0CAADiAQCAyzSHQJCaoZQh2TTbQNsj2WQYFqBj1LpsR+pf56WGMRHLxkbefe2xBwHcgBVePU8ANxxwbwr5KVk1Q9JinnLonH193Fo/3S9+dGWPBBiUeZq+q6+71NR0uLLigzOn2uyz/dRJEA8AAIB4AACgJRSpMTNxNNJw2A2jAXSGz6p+F1rZH29873jje/cN3d3llEfhUiFCkxShSSzx7QsdneNYm2Ka29dNYX5RPF5T3frp/vNf7rtjxCiH0aijma45MnUmxBnLcpXP+21lxcXGxm8qygpLO1Xz617neLjUAQAA8QAAQBuQBKWGQMBQAFfEG6wMKYcQH5Y9ZdOOtGlHt/mSGN3YNtsNtI0k6F1lTzQEz6stjcGSxmCJut1307DW+f1uP3e6rvZoVWV9INDeo32E0JtFx94sOhbajdbrp8cPRgjNS05BCE2KjUMIOYymNmMPOnCC8otifcD/bWXF0arKg2Wlp1qJlhDpCYOHWqPGO2I/OH3q05LzofYonX68AzJZAQBwTRCKovS9N030ybcNAAMWjDFCiKbpLneASeD6IsoBr1hRL5x38ycagiWhis7dio6KvGPw/+sNaVixLB+tqvzzV/tP19X+atac+SlDWz/jD5cKZ+vrOvlc/2oZGRU9LCp6SKQ1MSLCzLLDrFH37/jXuYb68D5/mn/rvoslB8ou1fr97Z3n9uEjh0RaU2NihlmjwvMpYVl+q+jY5q+/qgv4n5ia9tDEyf0mYStMAtfIa99cumH/6/4pg2Fw2mTavbfcsA816tTJ63UqsDwAANC9suHdd99dtWoVQui9995LT0+/2g7AFWXARd+Xbv5EByEKohzgpcbqQLFHLGsMXmptYbgxxOonXYtyUB/JN/CBn4xJvcaI5N998dnrx46o209+vCtKp8/PvLeBD3ReKqiL9cSIiEmxcb//8vMPz54JHYrS6b+4P6fWzyGEvq2sQAh9euE8QqjN1f+putoODAgqv9jzUZtvYGJs3BibPTkisgPPKJok7xs34b5xE+BOAQAAxAMAAH2A3NzcrVu37t69u6ioaMaMGTt37ly0aNFVdegCAUHYfviDM9LbEZbG+rJxWc6fjxg05Hqd7efT19gjoq7xbBfp13Ra/trPVuo58nHVSnX7eON7Ns34JUkvywrmsLtBKKkVTnVGKqSYMiI0g81M/NmmgrLA/vBD7cU8qGHQbakUf71wHiEkycEvap5vcfRayoz87cjh577Yq26/fuzItLj4vGU/ubJ2leUqnze85bv6OjfHhZRDsywJ+Kf/9f91UipYdfoWD+9fzFg4RDK+VnxEoOWMqMTfLlukpWn18b/6d8mIUeESKIDFKp+v3Otp5PnDlRX1Af8VtYrq+DQvOWVEVPRgS0TnrQcSlr89eO7VlwsaG7isB2fdcvt4rU4D8xIAANcCuC0BANCNjBs37umnn87KykIIZWVljRw5cu3atVfVoQuTwLoPn0oY8k14yx327V1eo7c4GydoMhPe7amzqTaE0O6bp3/GaH6wiNeQpqDs7eAMcfrJDp3TzMTH6MZqqYhwbfDjP7+Kkg6nDzltZIXjFYO+KB5d+PCzrKaLz5iezl85bPjlNTrHsw+P2Klj2S6s+LEsL3r9dZ6QwhuXT542JMqqPtS/rA068SD/inQsFVrz+zXbPttdHNqNsBrydj5F0VddS6HM09TIB+74x1sthdPtS2clJ3Xts1yv9wYrgf4HuC31hsHpo25LIB4AAOguOI4zGo0ulys1NRUhtHnz5ldeeeXYsWOd79CFSSAgCG9dzGjRWFVrbmowdulDKCOGVbZoKq+J8DXpu+9sI4ZVXK+v4FJZdH29saomoq7O5PezAb7dtbtCIC6p5SqZrcEM15XJVj1bfETdpMHnbSbPgfPDz9TEUuWIDlw+my+5Fznfm08HrcdF2q8QPf3bUjmDDR8ZKiAnb/Nfx3f14v/dP2bc4H4wvcBKAMQDiIeeEg/gtgQAQHfhdrsRQiaTSd21Wq0ul+uqOqhgjJlO+2kcu3i8daMj2uOI9lyvzzXI3ojsjb3zbHU+w5fnRtZ4zZyg9YthUsGCkOWqzybYaeEa3kxZY1RZ42WjiujolstMV4kp/vIikuIVba38gw7uH5gsKEEpvVUXjKTCG22HgyTuFXeNo1Dwlkm1kzUIIctpMfKkeH31zL/f/aZHxMN1z5oAAEBPAXcpAADdhc1mQwh5vZddUJxO51V1aJ6naLrFI0aCINr7pyn2xOKavjRKNR6T22du0egPshVN7RZdrvGagxKNEPrppP1RRi780L+O3uT2WXrnJ9XUShrvD5b1rRf6IRhOpv2Xv/Tym3Wi5QfONkn/4rpmFUEIDdoTcE9pfsCvaZAcXwq9RDkghAgFmUuwuaS73tDUmcNvvGyArAkAAOIBAADgyhgMBqfTWVRUpHol5efnz5kz56o6dAF7RNTFbxMTEy6GN45FG6cNn9i1E/76k3tanG2m4W9djsBufbalsS93+WyZrzw3ddrnRrbZPHC8YtA/Fq5Mjo3u2tmm/X5TjUEMbzn0H49YzYbrdbb9v/h5l8/24KpXP9fUS7pm/WD7Wtj14TNdjv39z59upb+skb8SZOr/s/fucW1V6f7/k5AAuUAhEAjXAm3pldDq9ELBDipUezlWq9+OCU7PcTz1tGOFn9PxdKznp6W/Y0e/DuO3QoeZ6VRnHEnVr3Wsp6BWnNYK1dZaa+gVW0gpFEhKuOSe7CS/Pxbd7iYhhEsgCc/71VdfO5uVtddl7yfrs9ezngVkbuXQ8efGkpvq6m2CNZBzW/7T2RNsByYlagKCIP6DjU2AIIj/KCwsfOWVV1QqVV1d3dGjR++77z4AqKqqqqqq8pJgjDw2p/z61cXk+GZ/tP3Gv45aObjnlmJ8cSyxm8Y3t91rf9n4ueytr+869P2df/jwX9ZG7xy1cgCAA/8mv8MuIsdCA2tfwZpRj/XHPbeK/3r0mbAFqZ8Ykz833fM1752dT4wlatAr1RvX/WwJmwKOBRYuzvzjgc1jz40cB2BuhSsXjFduo+PgwYMVFRU5OTlyuVwmk50+fXqkCRAECShwwTSCIH7EYDBUVFS8+OKLEomkoqJiw4YNHA6HxFZSKBRDJRgXI6Du6+k19I1laB4suWkHDP0G01hkQ7DkZjZZzWZbTKwAc5vE3EZqASY+agLiC7hgOhAaJ0gXTIMzCMFnHkH8hJ+eWb1eb7PZ6I9qtVqtVntJgEYAQULDCLS2tgJAa2sr+VhTU+NyiWETEGw2G3YNggSIEeAEaa18SRYCryWwCliFcSm/70+NnxAIbnvlSdZJe0mARgCrgFUIDSPgv6gJ2Mj4BGHLTBa45gFBEARBEH+9OCBBEchHL1EThkqAIAiKBwRBEARBpgqTEjUBQRD/gaFaEQRBEATxF7t3766oqMjMzCRBEVauXAkAJ06cAICtW7cOlQBBkIAllL3Q0NEWq4BVgKntiYu3H1YBqxAgRsBgMERERNCx1Mju8szlTy4JsJHRFGPLoHhAEARBEARBECS4wTUPCIIgCIIgCIKgeEAQBEEQBEEQBMUDgiAIgiAIgiAoHsYHiqIoisIOxh6Zmk1NFiNO8V7AWw57BI0A9gKCICgefDKaCoUiLS0tLS2tsbExGKsgl8tZDFQqVVAUu6qqKjc3l8ViyeXyIO2RoaoQLD1iMBiKi4u5XG5CQkJSUhIdRj00ngs0AmgE0AigEQh5FAqFwWDAdgixljEYDHV1dQqFQqFQ0E/fiGoUUNUPQfGwe/fubdu2HTlypKKioqCgoK6uLhhrUV5e3nqL1NTUYCn29u3bpVJpUPeIxyoES48Yjca77rpLqVSq1ernn3/+6aefpoc4ofFcoBFAI4BGAI1AsOj/oSZ/vFNSUjK6L2LLBCyNjY1CofC11147fPjwtm3b9u7d60uNXBoqsKrvDDmkUmlNTQ05lslk5eXlQVcFmUxGVyEYCy+TyYK6R9yrEKQ9AgCVlZUh81ygEUAjgEYAjUAQtXxra+tEfhFbJmApLS2lHzembWltbbXZbD7W13viCSbUZh4MBoNSqczJySEfly9ffvDgwWCsSElJCYvFKisrC/bJZeyRyYK8osjKygqlXsBbDnsEewSNwOioq6srLi5msVi5ubmkB3ft2kVc1Hbt2sX0Q5PL5Y2NjcXFxUlJSWVlZRRFlZWVJSUl7dq1i/YboSiqrq4uNze3uLi4sbHRZRkJ8RbbtGkTycrLtdxLxey+srIypuPZhLXMUAWeai3DrBEpTFlZGW3WFApFbm5uWVlZU1OTe/tUVVWRuldVVb333nsHDx50n3LZsWNHb2+vx0u4NxSd2ONVSJF27dpFcqirq/Nv+4SYom1tbWVqtZqammCsY01NjVKpbGhokMlkQSe1Xd7YBWOPuL90DLoesdlsUqm0qKgolJ4LNAJoBNAIoBEYHWq1GgBqampaW1sbGhqUSiV5H6xUKpVKZXl5OQDQr3UBQCKR1NTUkFaSSCSlpaW1tbVSqZR+f1xaWiqVShsaGmpqaiQSSUNDg/vlamtrW1tb9Xr9UNfyWCrSTWq1WiKRFBUV+ftls8cyDFXgKdUyzHkDMmvX2tpKV7OoqIhUkxSbLqFEIqmsrKytrZVIJLW1taQuRUVFxOnRZrMxbQv9SLpfwr2h6MQer0KmFplFcrFg4zx9FGIGQq/X071I7KNUKg3qGkkkkuCaXHb50Q3GHnEfNwRXj9hstqKiIolEQixOSD4XaATQCKARQCPgO0qlEgBcBrKkoVpbW8lf6cYh61voMaJEInFpNJvNxlRi5eXlpaWlrqMrN4Xpfi2PpSKeZhN2jw3VMh4LPKVahvnguJTE5Wki0UXTlwAAIABJREFU2sClfUpLS2kbwnR6dBcPHi/h3lBM8eB+FZIJnV4qlfpVPISa25JAIJBKpfQU0uHDhwsLC4O6RgsWLOjp6cEewR7xfYJ11apV586dUyqVAoEgVHsBbznsEewRNAK+k5OTU15eXlBQQNxjiI9NWVkZl8vNy8v77W9/CwB04wDAQw89RA7EYvHdd99N+3qRQe2RI0cAIDMzk4TeevHFF19//XXvBfB4LY+lAoCnn346ISHhhRdemKyW8dI4U6dlCF988QUALF261P3k3Llzycd169ZVV1e7tI/LV0Z6Ce+4X4VkkpGRQT76++kOwWhLhYWFr7zyikqlqqurO3r06H333Rd0/sHETZAE9qqvr9+wYUOwlFylUmk0Go1GQw6Crkc8ViGIeoQMGurr6/fv30/XJTSeCzQCaATQCKARGAsvvPCCXq+vra2trq7esWOHRqN5/fXXW1tbOzs733rrLZfEUVFRXrJavHgxAKjVapf3xC7odDpy4OVaLqUiJysrK9Vq9a5duyalZbwXeEq1DF2j9vZ295NkBQIAnDhxgjYI3tvH90u4NNSw9yfJhH7Yjx075t92CUmnBeLvRTzzAmdxuo8Qz1RCcLkrECdIGnrKLIh6xGMVgqhHmEUN3l5AI4BGAI0AGoFxbxZ6REv8RuhFIDabrbKyEgBoxxJguH+4xMahR03ELYTkqdfraQ8WGuLKQhp5qGu5l8p5u2c/nUNlZSUdNcvfLeOlwFOqZWhIjYgHINMvqLS01GazNTQ0wC2nI7h9WZGPbktDXYLZUC5uSx6vQjJpbW0lRgzXPIxy9BC8lpH4/wVdSDK9Xt/KwOXdQ1D0yFBVCJYeocsZ1L2ARgCNABoBNAL+04QSiYT0I1n7DgBk8euIxENrayv9dQBw9+wni1np0bDHa3ksFX115spg74twxr1lhirwlGoZGqVSyawRfZLeDYYe4o9aPHi8hEtDDSse6JYnkRLcW34cYTk9zSghCIIgCIKEDAaDQaPRCAQCsVhMn9RoNAaDISMjQ6PR8Pl8skREpVKlpqZyOBzaD4R8haKo9vZ22q18qDyZMLP1eC33HJhXJ39NTU3lcrkNDQ35+fkT1jIeCzzVWsa9legC0LWIjY2lz7iU0Gg0ksK7VJZuN2Z6L5dwafyhrkI7LnI4nKSkpP37969evdpPrYHiAUEQBEEQJHBlz6FDh+RyOTYFtowX5HL5nDlzRCLRSy+91NXVpdfr6XgJKB4QBEEQBEEQBPmRpqampqamkydPbtiwYenSpczpCxQPCIIgCIIgCIJMDmxsAgRBEARBEARBUDwgCIIgCIL8iEKhoDcdG3dUKlVjY2PgNwJdTpfWIDuZkD8xj5Ggvi3HHc7Y778TJ064nMzJycnKyvLfQg0EQQLqR8jdCNDgUjYEQSMQUKUtKSlpbW310xDlxIkThw8f9iX4j1wu37Nnz1DBiMb3W17KyWyNxsbGgoKCoqKidevWRUdHk4if69at80csoxFVZBS1Hq+G8nfVJua2HHfGuuZBoVCUlJR4/JNMJpusnkMQZMLwYgQAAFdVIQgagcAa97BYra2tzLii49sUhw8fVigUfirGeBWeLicz7mdZWVlcXNwLL7wAALt27bp06ZIvFZmAXhhFrf3ay4HcsxODH92WDhw4kJCQ4L87LwRQqVS+zFKxWKxhm1GlUrFYLJVK5WP6IKKxsZHFYlEUNYoH2Pd2cOkL5nd97CYvOYwLSUlJOH2MRgCNABoBfGp8p66urri4mMVi5ebmMpvuwoULxcXFSUlJVVVV9H21a9eu3NxcFou1a9cu8hwBgFwub2xslMvl5OGiKKquri43N7e4uLixsZF812Aw7Nq1i8VilZWVabVaX0pSVVUFAJs2bSL5D3V1lwKQDcKZ3xoRHsu5Y8eO3t5eAKiqqnrvvfcOHjwol8vlcnl1dfXRo0fJhTzW2qVsV65c8ZLGpbXdq++ly3xsq3FsqLHgY2mHujMBQKPRlJWVkXy8p5xMxnFvwtra2tra2qKiIpdLBN0mqRMG3No4cOzJ6D3eyf6FZKf00EAqlZaXl/uveT0mZrbh6Lpp3HuhsrJSKpUG+NattbW1Lrvb4mOORgCNABqBSUGtVpMeaW1tbWhoUCqVdDdJJJLKykqyg29tbS05X1paqlQqlUolGXrSewZLJJLy8nKlUqnX60tLS6VSaUNDQ01NjUQiIf0rlUrJSfJF9w2P3UtCzpC20uv1Q13dpQDkGWd+a6TPkXs5gbFtc1FRUXl5Oem1oqKioqIiciGPtXYp25YtW7ykcWlt9+p76TIf22ocG2rsd5330nqsJukI5ubZXu7hyf/lGkeTQdsIvV5P2ogQmMbO40+vXq9Xq9VKpZJ+bpl/bWhoUKvVHr/C/JNer3fpYJKMnKfvY3JP0A+ql6t4/90izwlz3EDfsmq12mOBvZfTpTokf5vNRv5npvexpsz0DQ0NLr8l7pkwaWhoAAAX4+JiEehjm83GLCdpN48d6pKJe1/48ifm5bwkYzaOS929NJd7NfV6PQAE4IjQoxEIUtAIoBFAIxAyRkCpVHpsLtJNtGBgjvVJb5Iv0kM6OrHNZmNWsLy8vLS0lHQKfVIikbiLB48lcW8r96u7FMDjt3xkqHIyT8pkMtrOyGQyksBjrV3K5ksal9b2WBEvXTZsW41XQ43LKyHvpR3qfqisrCT6Z9gGCU3xQN+mNO4/w4H5CpCeNpFIJC4vkOi6FBUV0aac+RUiDemUUqmUfp/BTEYPAph5kikgL1fxOG5QKpVSqZROT3cBnb6yspLZ+OQ3mPx6DVvOmpqahoYGj/mTHzzfa+qSnj4/VCZMysvLi4qK6I8kc7pU7u3DHD8N1aHumbj3hZdu8ng578lceopuxqGay2M1mdY8YMcN5eXlNQyC7uU3GgE0AmgEQskI0O8xy8vLmU8TPTSvqamh27O0tJTcJ6QrSV8wh261tbXu7hvkJH1FFzXipSQuoyaPV3cpwFjGxEOVc1jx4LHWLmXznsZjaw9VkaG6bNi2Gq+GGnfx4LG0Hu8Hj2/bPTZIyIoHF4MbFO8jSVEbGhpsNhv5xWW+1iK/vnq9njnLSX+FNvcymUyv15Mc6JuAbgSbzVZeXi6RSDwOCLxcxeO4QSqVksu1traS3xiXcQN5E0YXj8w8DltOOj2dv16vZ+Y/iprSE6CkduSN5lCZuNxFtK0h1WGOXYYdN7h3qC+ZuHz08ieXyw2VjK6pXq8nTeGluYYqITEiATiPxzQCLgTgKAeNABoBNAJTygjo9XriMMN8F043KT2cZbY5eY9OD0npxCSN+1Qe8yTpaF9KwhxVD3V195Eo81sjnVb1WM5hxYPHWruUzZc07uJhqIp47LJh22q8Gmpcfkd86Vn3+8F95mGoBpl0/Lhgevny5fRxR0dHUCyukslk+fn5HA5n8+bNAHD27FlyPiMjo729XaFQHDp0aMGCBa+99hr9ldLSUhLFzGAw1NfXr127VqPRtLe3L1q0SKlUajQaOllGRgaHw9m4cWNXVxd9nomXq7ij0WiUSuVzzz0nEAgyMjK2b9/unkYsFhcVFe3cuRMAKIp6/fXXt2/fPmw5SXWY+QsEAmb+I60pSb9z504SRkAgEIjFYu+ZMJfdr127lhzz+XwAeO2115qamkhzjaJDR5HJGCE1feqpp0hLPvPMM/X19fSqSvfm8lLCmTNnkklMBI0AGgE0Asiw69c1Go1AIFi9evXdd9/t8Ylj9hE5oCjqj3/8o8c0YrFYKpWWlZWRrAwGQ1NTU0ZGhkQiqa6upiiqsbGxvr7ex5IUFRX94x//oJdcD3t1etqK/taI8KWcvtd6FGl8qchQXTaKthp1Q42dYUs7VDXXrl2rVCqrq6t37dpFvj6ie3gi8aN42LdvH32ckpISFLaG/onicDgSieTzzz+nV/Hn5eUdPnxYq9WKxWLmU7d06VJyQAYZb7755o4dO3bs2LF3716ZTNbc3OySzMVOMfFyFXdIzllZWe5SjQn9K3XkyBEAWLdunY/lJGckEgn5mJOTQ+c50pqS9C73gPdMaCQSCR0UQiAQNDQ0HDt2TCqVJiUl1dXVjaJDR5HJGHGp/rx588iwbKjmmvgSjiMuHgtPPfVU0A040AigEUAjEBpG4MSJEwkJCSwWi8ViHT16dPfu3d7H1jKZLDMzk8vlHjp0iHYYc+HQoUMAQLIVCoV/+ctfAODIkSMHDx7kcrlkkwQfS/LMM89UV1dzuVyFQuHj1V2+NdIGGbacQ+Gx1qNIM2xFhuqyUbTVWBpqjAxbWi93plgsJvph1apVFEWN6B6eUPzktuTyaiSI3J2ZazbI3D2ZdaInocgj5z4r7WUpmy9z3D5exWVVCX05MiPvni09TUbPUfpYTi/5j7SmJL2LN7OPK/88Oviq1WriREhcSpiuzMTzkunuPNTlXDLx3WPBy+U85uByafIV5mpO9xvDYwmJzwnT+TsAPRaCfcE0GgE0AmgEQskIEI8+d0cjehUQ7UFHNzjth0Pa3D1IgPdsXTL0/hXmhTxefagCMBOMwn+JWU5m/i6FcSmtexU8RlDwksa9cdwrMlRDDdtW495QY8R7aYdtKKYL61ANElJrHohvFlMLBo6T1kjdnV1CZdlsNrLccKhfdOJPTH77bTZbbW2t+28S8+eBrFhiBvTw5Sq+uzvTpSLvDl38nr2Xk4xdSOQ14mzH/FUYRU3p9PRTNFQmLkuFaAdfEqyAOY6h46BJpVKP7eDeoV4yofvCpSIufxrqcl5yoL29Sfw7ptOne3MNVUKSTwA+TSEmHtAIoBFAIzCVjQCCIBMqHohxdJ9xDopQS06vgVbIux9y3svrQLVazYxRK5FIiFgc6teUGcnE96swp3e8B1phzgIxO8KXcjoZIXfJMh3mD9hIa0q/PyPQSzk9ZuLyjoTOxGVN3lBhTMBroJWhMnHpCy9/GupyXnJgRmKRyWR0NT0211AlDIoojWRUxCTQ3pegEUAjgEYAxQOCIIEiHjyuGgmioQP9zs+j7aNnkcgBbevd35ORHJiZMJO5x0pnZuj7VZiDFRKrhM7WY3Bx947wXk5mMqdbtMSx1NSlJO6ZuCCTyejgAyQHj4nJpd3bwb1DvWRCN7t7UzB7xOPlfMnBvV88NpfHEgZmlJVhjUBwjSTQCKARQCOA4gFBkMkRD8G4vymMZC/SqUBtbS1Z+kZemFVWVk5KMcgbu2CZv/IfMpkscHaXDG3xgM8+GgE0AigeEAQZCpbzllfoqCPQ0SEjxGKxQCAI3rBucrn8qaeeIjEKERIjbMeOHQAwZ86chx56iBlrBUE8GgF3UlNTORwOGgE0AsgUMQLB9cgjCDIKxioeEARBEARBEASZIrCxCRAEQRAEQRAEQfGAIAiCIAiCIAiKBwRBEARBEARBUDwgCIIgCIIgCILiAUEQBEEQBEEQFA8IgiAIgiAIgqB4QBAEGRGU3UHZHdgOCIIgCBJi4E4uCIL4iuLktYNn2pu79asWSP73I7lDyYZPz3e9euQyALy2YeGi9FhsNwRBhoWiKADADeYQJPAJypkHFouFPYcg4/5Y+fJk/SI/MztR6CXBvi9bXj1y+c8//8mzK2dvfOPU8WYNGgEEmcpUVVXl5uayWCy5XD6UbFAoFGlpaWlpaY2NjWgEEATFA4IgIYJ86fQ10uQZYm/iof5i97MrZ2cnRq2RJq9aIDl/ox/bDUGmONu3b5dKpUP9dffu3du2bTty5EhFRUVBQUFdXR22GIKgeEAQZEpgtFLN3fpZiVHk48K0mPqL3dgsCDKV2bp1q1wunz9//lAJDh48WFFRkZOTI5fLZTLZ6dOnsdEQBMUDgiDBAYvBKL7ea7ABgCB80Gt5Go/b3K3HVkUQZCgMBoNSqczJySEfly9ffvDgQWwWBEHxgCBIUP6oj/QrsQIuABisFH3G+wIJBEGmOBqNBgCioganK0UikVKpxGZBEBQPCIIEB04GAoFgpF/nh3OyE4U/dOvIxy+aNYszRNiqCIIMhVgsBgCdTkef8bg6gqIo1u1g0yEIigcEQQIdo5Xq6DX1Gq29RmtHr0lrsJLzipPXFCevkR/4O9Nj3mhs7eg1HW/WnFJpl8+IZ/78k7eMCIIgBIFAIJVKm5qayMfDhw8XFha6J+NwOM7bwaZDEBQPCIIEOkcvqe/fc/zrFu3XLdr79xx/+eOL5PzZ633ftfWSYIuVm1dnC6z37zn+wkfnnl05e/mMOAAwGAzFxcVcLjchISEpKamqqorOUy6XM98mqlQqbGcECSUMBoNKpdJoNBqNhhwAQFVVFW0HCgsLX3nlFZVKVVdXd/To0fvuuw8bDUECGVYwyncWy1uxc3Z+6n6yaScaI2QqQmm1vQcO2Pv6Yh75X5Gzs70/VgDg3SAYrRRZEk3ghYeJBOEAoDVYK373uzf+WHnkyJGmpqaSkpJ/fFS7dvX9nLDB1xMajaa6uvqhhx6SSCTvvvvu008/3drampGRQcTDnDlzNm7cSFKmpqb6skuUdyOAIAiN2Wa/pNabKXu2WCjih098ARQKRUlJCf1RJpMpFAqy54NCoSDqoqKi4sUXX5RIJBUVFRs2bEAjgCBTXTyM+7aRKB4QxBe0b7/d/d8v0R/5y5ZN/+ubYxEPXsjNzd2+fTsZEBA98MILL3i5VmVl5datW0nitWvXDrV7FI4bEGQsXOjWnWzrpT8mRUXcPydxgstgMBiY/ooCgUAsFpMzZMEDnSwiIsL3oQIaAQTxkV6L9of+y2a7aU7MvPjIBDZrrG5H/nVbGnbbSPRYQBA/4TAamcoBAIxff21t7/DT4MD3YItk0JCVlUWfKSkpYbFYZWVlvm8uiyDIsNjsDqZyAIBOnUVnoSa4GAKBIIMBEQxisZipHEiycXzJiCAI4VLv+f+59sGlvvMqXcsn1w/Xt38y9jz9Kx582TayvLy89RapqanYzQgyLhi/+cb9pPZvf/XHtXwPtkhRVFFRUVFR0erVq8mZtWvXKpXKhoYGjUZTUFDg8Q0CBlpBkFHQOWB2P3m+awBbBkGmCH2W3lOar5hnukw3ei3aMWbrX5VPbxuZk5Nz+PDh06dP0yMGmpkzZxLXZwRBxhH2raE8k7CYGH9cy/dgi6tWrVKr1SdOnKBP0g5L+fn5R48efeutt9z9nUigFeYZ1A8I4gWb3XG+S3e+24NOiOSEYfsgSCg85g6bxW4mCsHqsAq5wgSehPzpeOc/VbqWob74Q//lJQl5ASoe3D0Z9u3b5z4sKCkpKSkpKS0t3bBhQ35+vp8KQ9kd9NpNBAl5nBSl9+QCFCuT+eNydLBF8rx7DLZIlMO5c+eUSuVQO0gsWLCgp6cHuw9BRo3WaFV2DrRqjUMlmJOA+zYiSBBgpkyUkwIAtambKQw+a6/rNN5wT58RlUWn8U40N3qMZfOjePDFk2Ht2rXPPffcwMDA3r17CwoK6AAsLmMOLpc7xsJsqfm2uuRO1A/IFFEObZueNH71FQAAiwW33tkn/tfzHJG/tmwjwRaXL19+4cKFo0eP7t+/n5wn0Rg3b968atWq+vr62tpag8FgMBjIokmDwXD27NmlS5daLJYvvviivr5+586d2IMIMlIcTmdHv/nb9r5e04/x0GJ53Nli4dkb/WbKQc4sTY+N5OLMwyRgc9iu9jerzd0JkYkzpmVz2dwQqBQJ5NVntqXF8NJjeFwcYo3ggXUYKQMAGCkDnyMQcgeHysc7/9ll7DTbTV6EgYkye8xTpWtZkXQPOU4VpKcK0gEgnB3e2PWFxWFhppwxLTtwxYMvngz+8FhgBlai7I4tNd+SsPSoH5CpAKXVdmz7NVEO/Ly85FdetrW3O3Q6QX4+y5+LEXfv3l1RUZGZmUmCLa5cuZKcJx5Ka9eura+vB4A1a9aQ8yRcI1nnQM5IJJLy8nL/TT8iSGjT2NpjuiUS5iYI50uioyI4ADA7QajRW612R8q0SDb6+00Gepvug9Z36RHeKc1X6zN/Ro8XgxSt0XrofBc5btUaIznsR6TJqB9orUgciiLCIolQNFMmsvbA3ZsoN+6O3Lg76Ntj2Myzp822OCxR3GgAiI0Qkfz5HAEzhlJW9Ez6WBJWoLKdZIXpAcDpCJ8G88euXf0b6cwleqNYLN6zZ89QiYuLi+fNm+clAVM8+F5sWj8AwLIsEeoHJLSVQ8sD6+w3bxLlkL7vz6yRxD2EMYRqJbgHWyQzkLGxse3t7cyUZOYBACiKIn8a0donjNKIIFqjtUtnmZc4OAY929F/Sa2TJk+bFS+YCmO4IDIC7g7oqYL0wuSisUfMnCx0FupIs3rAfFvkrumxvPmJ0YlREeRjt86it3oO7TUjTuB7Gp2FUustHtPQ0x2+pLHZHW19Jo9pEoQRRGkDwNUeg8c0wnAOXbXz6m4AiGDzWSw2ANgc5hbDGQAwO/r1VN9tA31hnjhi8KetseeAx5zjw6fPjlpOji/rTgCAKDw5QRgBAAm8RL2V6jM6uOzI0VUtOSrine9vAACwTAAATh4ArJ6TSNclEMVDWVnZsWPHDh06dOHChSeeeGL//v2rV68mbgxbt2518VhYs2ZNQ0ODL+8dR2oyUD8gUwHz5ea2J54gyiH2548lbt8+oqmGcREPOG5AEH/j4qH0iDSZjHscTicATJ25hQA3AsQvRW3qbje0eXmdHBMuiomIAYA74heTuQiH02G1WyI5vEm8u6x2BwBYKAc9Iu8aMC9Oj6UH9G9+0+bx65kifuGMeHJ87OrNodbePL443fc0V3sMx1s8r4Wjb35f0ugs1PvKGx7TrMiKY1StBVg2cEbcikdKsSKvAMsqjAhzsLVMhyK7YRFQYjIuD4v+0nN7muY4rYMVYfGUAADO8BXTswBAyBUqOyzX+8zg5Lr7AY2o+l6qtiQt5tT1PpeTcxOEy6aPyYfZv9GWPHoyEDeGrVu3TpjHAieMXV1yJ/ovISGM8cyZa/LBPVzjn94qfuopbBMECTFIDKVLah3tngQARqudDCDQJWnS0dt0fZbeHsvNazpVn/XHaJjh7HCrw+rxK31WLUk5J2YeEQ9GykD7OGVEZQHAtPCYKG50ODs8kZ80IocTm91hphyC8DByb5D30zoz1We20ZKA3EvM0XP9DxqPuV3vM9Fpgll0WsHJGRQGLBOL0wcczWVdRIvJRlYhh00DALAP3EVe0gPLxo5oAwCjE8DuIl+pQfHqjHDahU67UBgRtiA+PTwsAgCuqFkdfRTAj0uMnKZB1/2s6EFhwGHdBKd/H1t+uIc1TlHssaruiRDuLp4MzH0lJ9JjAecfkFCl/38O33j2WXKc9qc/Cn/609HYApx5QJAAlg2NKi3zHS2Pw546HkoBawTMlCk8LIJ4H6lNXZ9cP+yeJjKMlxmVdbHvPPPk3Jj5cZFiq92iNncDQJexc3X6A0Q8MBdIuFAgKcyKnmm22S12+9HO/xFypnHD2GnCdABgO6OuaMws4ISxIlze5dM+Kj6/em9j3maS6EGHmRlxgrSYwfkQnYW60K270K3zeKEAEXJqU7fONtBv7QOAPksfLefoBSft+rZ/3jji8ev3JK9MFabT3ZHET44IiwQAehVyTEQsvZ7BBSdF2bq6fSyn6bvvfE2p/N6u7fUlpeWHHyzNzfTH01XvUNNimQnWNDcklMgDXTwEjslg6oc4YfgHW/JFgnD8WUKCGs3evTcrq8jxdEUN/447Rv1YoXhAkIAVD2+fGVw1lBQduSh5mlgYPsWnGibFCNgcNr1N12vR0s5I96etJWFwzJTpvZYakiwjKishMlEUGRcbEcdlc/vN1n/8cIy8wAYAhyX9oVmF0yJvG37QO3/rLbZr+hYAYIX1Wxxmi91Mx+W06xeDPRbAZz+ZiKvg4M9PFM2NlwAA2xn57vedABDL48bwBke9RA8wnf51FoqerPBCzxdfNn7f0pN392A+df+38NebOQI/Tk1Y2zsGf/XsvQanCQB6HH0WpxUA2uyd5E8bePexWWzr1SvXnOpvk/s95lN8NZ5PcQDAyKE+m3Ez3EjF3jACAL/Xwh+wAUCkzhbVYw6jnF5G5EGEMTXjhy3bTelZAMDp782o+dOsmSmS559H8TAy/fC7I5drTrahfkCCHSdF3dj+m4HaWgAIi4/PeOed8NSUsTxWKB4QJECgg2DSHuRnO/oBYEa8gB7kTXEm0gjYHLbvbp5W6VrcY2guEefNiZ1Pjtv1bTERse5hlG559lPAshEHd3ptwAgc+lmmHx3xWVZW5CUA4EX2Wxy3FSmOdWdc+HSxMMLpdJzQepjBiAkXZU+bTZdZb9MBAIfFGXaVhcsL9bbHH7ddv26NFpiTEoVXr7Epe9TKlVHFxQBgbbtmbWn1aUim1Q5GFaebOpo3sHA6AFBRkfo5yQBATeOTM4sfqCBputcsbPuPez1mKP33fRHqAQDoWTGn5ddrACD67DVOvxEAhJducHRmABA1XGY5gvjnI/pW0MJh4S1ayOLxu55/HgBsUdPsEZGRN7thbO8ZCVPOBnHC2L9ZNXcaj/uHY1d79Nb11Y2oH5AgVQ70Zg5h8fFZHx3y3x4OCIJMGN06y0W1jvY8yc9wEMekhSnTsHEmBnrpQrowIzZCBAB2B3Xpdr+jmHCRhJ8UHylO5v/4yoY4urhzqzc54OTQZwpn+FqeBGFEpogfEzktKnLw67E8LjcsAwDIFAEdGFRt6k7gJdLuT6D1kFufVUv19VsNg2/xPzB+zPyrpM3ktNqmdRmjblpiuk3k5ZRnQRXNa9u2WvvTueRjck1j8v/9THfkiDcNFs0zp8RaxdEAYE6KMaeKAGIHNm/m9hkXlL01qEk23U3nOeRATvfjRgeiLy4CAGfAJLzcCQBEJwBA3PFLcccv+WlEHjYtxpeU3JRkTkKiLynZfJ7/fsGNJ04M1NZydf1cXT8AhMXFjVFh9wJpAAAgAElEQVQ5wBSceaCpPnblD8euAs4/IEEIpdW2/dvjZAqVn5eXtreKzeeP/bECnHlAkEnC4XS2ao1NnQPMXd6SoiPzM0Q41eBvI2CmTAO2fq2557rhGnPvXuaswntXayT8pFRBemyESMiN8n3hsse5hUgOW7YoFW6PMUqic5K/+rKUhXbjAQCHwcB0qmH6x5uEXP3Rf1rjhFZxNHmdn1B3NuriDQBwslmnP/yVx8xFX1ycUVFHjs/t2WjKFPNaNby2m/QwXTc3WbNmEfMrM17+iG2h7IIIAOhbnAUAYfHx7IiIBZ8PNum5e5O7Z3re23jtqUgyIr8Up78crx8c0Js5UVYOAAitHKE1TKKP4DjZ3JRkEMexgT1soFu/jsiDC+OZMwMff0zd7Il5cN24bPo0dcUD6gckeJXDqDdzQPGAIAFIt85Sd+m2FZaLkqehh9IYjUCvRftD/2UTZUwTTk8TTmcO920OGwDQu3fRaxVcYIqH0WgSm/2Ty2qmGqRZxtLN/cn8YTWAi/+P4eRJYvnHCyebZY2PsvPCTdPjAUA/O4mK5plnpRiTo7MbutLO9wEAb9HCw0vMo75ETLjogYz15NhlvwvmKmR6UzObw2Z3UJMVqRbxkSltmLYUzgQA9F9Cguv9QXtpGfn9wJCsCBLU2OyDLkki/uC4lsdhL06Ppfd+QkbNpd7zZENfALimb40Ii7wvdY3W0nPTrCFLF2hhwBynJvGTE3iSuIh4j0sXRkoYm2W22QGAox8QXj7fd2ceOS/59EOn4k8XHQ6/tkBEdnbErFn0RxdnG96iHycNPL+hz/7xsGDgCh0YypctkAEgMown4SeRA6YYuyN+8VBBighcNnfs+x8jfpfuU3nmgYDzD0gQKQf/beaAMw8I4nmIP96vQmkPpYxYPr2S4WxHf1J0pJ8iXYbk21wvRsDhdLzfojDbvb0vT+InF6euJsdqUxefI+BzBGPf8tnhdPaZbCL+4EDiao+hT63lPXw/y+GwR0TYomK4ur4wi2XiNIDfHoraax8O2G4LZzQ3ZsHc2PljF10IiofgGDegfkACn/EKyYriAUF8xEyZlNqzZKWshJe8OGEZWT47anQW6upNw3c3fhxyPXZHql8nGcyU6ZTmK/K2eFyqEBRGwMtWCeSNOFm6MO5N0a2zHL2iMVGOR6TJwjAwKZWayiqXaEKEsARx4rP/OekaYCy4b5KwIasE3Y1QPEytcQOtHwDgrV8sWZQeizcHMnWUA4oHBHHnI9XBPuttuzLJZv7r6HwqunWW7270dw78+C48lsfNSYrOFPH9ul3DOFYhiIyAx2UM04UZSxPy/TS61VmoRpWW7t/ZN1XxLz3vZX2Cn8z4BKO36a4O/NBv7UuITJwxLRvdjVA8TMVxQ63yxm8+aEL9gAQUExaSFcUDghBI4MtOw42v1F8Om5jerdbL2+45vNXnuygAb3t7kc2DB3+Amv/iMU1GVNaKpHt8T1Pf/skNY7uXC4WqeAC3tbnMnhrnu8XuON+lo2eTwi2m9P174k5+wXI4iNGOlT0aK5NZVaquneWW5uaI7GzJzhdDQDkgUxmM5PAja6TJyTG8jW+cAoCNb5xC/YAElHKIyM5O/+ubGHgOQcYXM2W6adZYHdZ2QxtzN99xJF3EO9+lA4D5iVGXTBNXNavD6n6y3dAWGuLBO0vEeXBrdW9kWORPxMv8oRyu9hi+aes1UYNLn1MPvpX08ftkSUNEdnbCtl/RYTE5IlHWR4fwcUNQPIQgi9Jj3/rFEtQPSCDgp5CsCDI1IfMJfZZeohPo1/OX+y9+33PGx0wkvORITuRtP6IsDn2QEZUFAGabo9dkM9nsIh43hs8FgJiIyNVz+GJhuNVuNmuyPOYs5ArpY5KPOwmRiSNKkyZIv2lWuySYEzNvKnR3JIe3IumeJeI8ykmNy0poj/T36ohyiD53Jmv//yHb98b+/LGYR/5X5OxsfOiQUAXdljzwXVsv0Q+A/kvIJGFt71A9+ihRDtFr1iS/8rK/lQO6LSGhR7u+rUV3pc/S12d13Wv3sVm/IAPKloErDV3H4NZS2mnhMVHc6NgIEZfNPXPzG6brS2RY5CNZ8qGGoTa7o63PxHwPzeOwH12UOrkt4OK9ExkWuWHGYyEyfJkkI2C22cPYLNv3Z3trFL319edf+D+Zf62M+uFCWHx8/Ob/iFm/fuxbdiIIioegNBmoH5BJxK8hWVE8IKGEmTJRTkpt6iZx6IlO2Jj97+Sv3/ec8TirEBMuWpm6iqyd9RLG1OF03DC0n7n5jdlukooWDbUk1D2GEgAsSp42J0EYyQ2b3PbxsQooHnxrTOelrv6T7QMpp46lVf6WPs/PyxM/vZUnleLkMILiYaqbDNQPyKSg/+KL6/+xmRwn/tfzoscem7DHCsUDEvg6gfZcP6X+igRRdYc5q3BOq4yJiEmITAwPi0jgJXJYnHGPt/P1Ne1FtZ4cT0wMJWTijUDrlfavuo2W8EGntTt/uYGr649/euu0dQ+Gp6ZgdyAoHtBkoH5AJocJCMmK4gEJFp3gMp9A/kTPKjC3ECbEhIuITvD3+3XioUTvA601Wg+d78oU8ecmRPlplzdkEo2A5tuzR9VWQ7yEfOS3teR8+LeUDQ9H3XsPeighKB7QZAyjH35ZOGNL4Uy8aRB/4KSom3/6E1EOYfHx6fv3T/B6OxQPAYXD6ezoN3/b3mey2ecmRM2XRPl1KzH/VOFHh5nZMfPmxeZ4HNDTOiGcHZ4qTCcn3eNs0tDbFKhNXVpzj//mE4CxFTTdC2bKcb5rgMwzrMiKmxEnGKyFzT7pHkooHsa5943Gm//48EyXvnPF/eQMt0875+KpeQU/wUCrCIoHFA/D64dn3jvbo7eifkD8pxwmZjMHFA/BwtmOfqYPfSSH/Yg0Obj0g4tbEb3amAz6XeYTCB5nFej5BKIT/Bc5x51jV2+2ao0/3nUAzHsuKTry/tkJaL5CzwhY2zu0f/tr79/fNscnnn3tLXIyu/3y4hV3hMfFYcsjCC7uGZ5F6bEfbMlfX93Yo7eSXahRPyDjCKXVdmz7NVEO/Ly8lIrf4WYOUxyb3eGy+tZMOdr6TPR77iCogsPmsiDBbDffMLSnCtMv9V0YalbB5rCRWYVUYXqqMN1P8wm+9wJTOQBDOWSK+NKkaBE/HO/VUMJJUYbGRnXF7/Wd3VxdPwBE3uyefqzWUfDT/IUzeIvTsYkQBMXDCBAJwlE/IH5SDriZA+KC+VasTyan2notlCMthhcVEQR3yHX9NfeTLborqcL0VEG6StfiMp/gohP8sZ/XiGSD1mjTWyn3P8XyuGvmJgadCxniHYfR2PPmm70H3jFA2PUNj/fk3b343x+ILSqKe/LJubhdA4KgeED9gATQGPFyc9sTTxDlEPvzxxK3b0flgABAJIftUVGcbOs92dbL47AzRPxMkUDE5wbuKNaTOwnZvywremZg7nCsNVq7dJZmjb7XZAOAh3OS3NPkJEWjcggljGfO9NYoBmprnWx2xwOy9oc3DgrIQ/UpGfHYPgiC4gH1AxJYP1oTv5kDEhRww9hiQbjGYGWenBbJ6TdTAGCiHBfV+otqPXPBbuDgcDpOa056DKI6Y1rAvcS12R1dOktHv4mOtUpjsjlieVwiJGjSY3h4f4YATooa+PiTnn37LM3NAHAz7+5r8idtMYP+onMThAtSY7CVEGQocMH0iNEarEQ/AK6fRkZL//8cvvHss+Q47U9/FP70p4HwWIGnBdMGgwEABAIBGoEJQ2eh3lfeoD/G8rgrsuJE/HCzza4xWK/2GIgvvmxhConwozVaj1xWB8J0hMPpeL/lgNluAoAIdmSyIKVVdxUAJLzkxQnLYiMCbjHP1R7D8ZYe5plYHjdbLJRERZAGP3ujn+iKpOjIJWkxuM4huIyAk6LsAwPMVWSUVtt74AAdEduYmnFly3Zjehb5mBQdmZ8hCgrPQARB8RBk4wbUD8hYmMTNHHwRDwaDQSgUtra2ZmRk1NXVrVmzBgBqamrkcjkagYnhk8vqzgEzAKzPSYoIY7vHAHU4nX0mGz2QvdCtO9nWS/81KToyPYY3WasjSKCkJH7yXZK7Izk8L/s3TzBEepFJhnXzJaT1zDb7gbMdADA3QZgyjSeJinCXXja7w+5wYiTW4BoJkODXvTUKu1bLX7Ys8bnnHAa9prKKhKYghMXHX9td1c6LBQAeh52fGZeGM0sIguJhYvTDqgWS3Q/lcNARFhkOJ0Xd2P6bgdpa8ruV8c47gbM1KS0eVCpVZmYmecSSkpI2bNgwa9asp59+OqBsRQiLB/pd+NwE4bLpPr2q79ZZLqp1LqGByHjowQVJEzDqNVOmMDaHBEoi2zvQOzZMLkRltfWaVL1GpgPS0vTYeYmDa7J1FgrfNIeeeOh66aXev7/t2Q6z2bxleYlbf8m/4w6iHpemx85JEOKm4AiC4mEi9MOmt75p7tYDwLIsUXXJnagfEO/KYdI3c/BFPNTV1T333HPff/99U1OTVCpVq9VisZjFYpG5CDQCfsVmd7x9pp2M+zcsTBnRaMbjQPnxW/Elu3WWHqPVH9MR7fq2E91fSvhJK5LuCajGpGcVXARVhoifLRaiA1IIiweH0Xj5jjs9/on93P97JueuJdNF9Hohh9OJsgFBRgS+bhk9IkH4u0/mban59usW7dct2i0136J+QIaC0mrb/u1xsjiPn5eXtreKzecHZlEXL16sVCpVKtVf/vIXqVQqFoux+yaMRtXgpml3zxSPdEDDZrFE/HARP3xhyjSyDthq/zHk63c3+jsHzMS7yYuLzohgro1W6VrmxMxL4Ekmq+lo7ZQUHZkYFQEAzCmXyXXlQibc3g568RlTMyxx4uhLyjCLxXlXYdu2Fzt1VrA7j7f0pMfwyP2PygFBUDxMbPOFsatL7kT9gAyrHIJoMwexWFxUVJSZmQkADQ0NANDU1ETOY1f6let9JuJ6lCnik+HvqOGGsV28t802O31MgjXBrcXBtAPPiOi1aD9r/5isjY4M4y1PvGtSlIPLInIA6NJb6I2fV2TFCcM5AR3TFvEDXEmiLWrahd+8bLq1Ejrq4ve6ubmgswIAj8NenB6LtwSCjBp0WxqPoaHdQfQDoP8S4obxzJn20jKiHAI5JKtLtCWNRsPn80mQJZVKdeLECXrBNGV3EOXsrdZWKjyM7b8HISTdlsg6aR6H/bA02R8jG49hSZOiI+mhttZojYrgDHtph9PR3HfxlGZw4WkSP7kwuZgseJhIznb0u6xkcK8REsrDF69G4KP6b3umeXjfsSh52nxJFCoHBEHxgPoBCVzlECybOXhcMM38a2tra2pa+qfnu149chkAXtuwcFF6rHs+zd26Vz+9RJ6FVQskOx+Yzw/nTAUjMHYcTucltT4qgjMBIV/oDdFykqKJ87fD6fzb6etwe6xSj9/9rL2u0zgYSbZAUjhhO76ZbXajzU6X6tjVm/RsQ3BsnDe1oSgKADhDT7oaDIaIiAiOz7OyXoyAx+Uu0RGclbMT0G8NQcYOGtnxgfgvLcsSAQDxX6IY3sbI1ESzdy+tHKYraoJ3Gziy1YNYLN73ZcurRy7/+ec/eXbl7I1vnDrerHFP/Oqnl2L54V88e/cnZStOqbR/O6HCO8FXc8xizUuMmphgkSJ++LzEqAcXJNHLRvtuvcLvNdlOtvUeOt/15jdtX1/TXu8z2W63ZjOiswEgJly0PvNn/lYODqdTa7Se7ej/8FzngbMdh853OW6NF2fECZKiI5emxz4iTX50Ueqy6aLEMa/iQPwkGxQKRVpaWlpaWmNjo3uCpqam4uJioVDI5XLlcjkxOGPB5vAgKuIE4agcEGR8Br3YBOOrH3D9A0IrhwDczGFYFArFlStXyAF98vDhw1KpVCAQ1F/sfnbl7OzEqOzEqC+aNedv9K/IdnUM+LpF+/L6HJEgHASwJEPUetOAN8Ow42ON3jrGRQ7jIifWzZeQ6QjaF4isjliaHjsnQWB32olvUlb0TKvdkh0zl83yl31zX8lAQ29wkRbDw6j8QcHu3burq6uPHDnS1NRUUFBQW1u7evVqZoJf/epXYrFYrVYbDIa8vLyKiooXXnhhLFeMiuBEcthm6nbRG3jbsSMIigfEVT/87M9f7du4WCTAgIBTiwAPyeqdkpISlwMAKC0t/cMf/mC0Us3d+lm3FtcuTIs5eKbdZYdEiqI2r8h89cjlqEhue6/x43Ndb/1iCfOvvb29HhdeD+vSEMJcUutPtvVmivgrsuImN/ALCdY0LzHKZXVENN/8fstHsRGxy8Qr31femJsgTJmWZXcAe1w3kGBGzGzRGpnb3gFAUnTkrHhBgjACXx4HHQcPHqyoqMjJycnJyTl8+PDp06ddxEN9fX1NTY1YLBaLxXffffelS5fGftEl6bHMvcMjOeyUaZHYFwiC4iHQ9UNzt359deMHW/JRP0xN5RCRnZ3+1zeDSDm4oNfryYJpQkevCQAEtxYwTONxySYn9Oj/vffe27ZtG1sYn/F4xVOKMwCQnSicLYkCAIPB8OCDD9bX1wOARCJ5/vnnt27d6vJFAHj//ffz8/On1A2js1BklNzntvB3EiHBmtJieEvSY5Q3z/+z8wgAdBpNTZqrADyXYE1eVkf4gtlm7xgw/3DT0DlgfkSaTLRBWgzvZFsvj8OekxCVFB0pFoZjPM0gxWAwKJXKnJwc8nH58uX79u1zmVgoLy/ftm1bTExMS0vLgQMHSJC3MTIjTpASHXlJre8z2+YmROEthCAoHgJdP+zbuLj62JU/HLvao7eifgh5rO0d/Yc+tPf1Ra1c2fHMr4IlJKtn8XPLodxgMJw9e/bzzz+/9957ly5dyuFwYgVcADBYKTpxdqKQPiaeCR9/8unmjzpav/zHn7b+y73FK8ve+a7sne/2bVxsNBrvuuuu3//+9xKJ5N1333366afXrl1Ltpwb1qUhtPn8h8F1I/fOEgfa4MZMmb7sOspcGx3DSWfb9Sqt0UQ54NbqCPJX2cIU962siUeW3krRMfWZ5zsHzJfUOhPDt+R6n4nEjY2K4HjMEAk6NBoNAERFDc5YikQipVLpkmbjxo3V1dVr1qwBAKlUunDhwnG5dCQ3bGHKNOwCBBl3JsIjn6Io4pMwpdhSOPOXhTMAgOgHrcGKd1tIon377atFRTcrq3r//nbbzzcS5RC9Zk0wKgcahUIhFAoLCgqqq6sLCgq4XK5CoeCHc7IThT9060iaL5o1izN+nFQhngni9FkGO3u5mPru29P8cM6DC1NI2CWxWPzCCy/k5OSIxWIy53D48GHmF3NycuRyuUwmO3369NS5ea72GMjqgqXpsYHmjdMycOW9lhqiHOi10SJ++LLpokcXpT4iTV6aHpsU/aMfSDhn8NekW2c529GvNVq7Bszvnu2ou9R9vKXn7TPtF27dOToL9bfT1+sudX93o59WDjwOe1HyNAlj4Qcqh9CAuCnqdDr6jFQqdRkh5OXlbdiwwWaz6fX6hISEBx980ONAgnU72LYIEpriYdgYC/SbiZC0BagfQh4nRXX/90suJ2Nkj6ZU/C54lQNFUdu2bausrLTZbJ2dnXq9vrKykrgVLc4QvdHY2tFrOt6sOaXSLp8RT77y1y9/aI+YnpOTkxLLixOGc+cVvf/hR0Yr9UZja8nSdPfnHQCysrLAk0vDwYMHp8jNY7bZiU82j8OekyAMqLId7/xnQ9cxcpwbd8fa6Q8KubdtJBcVwZmXGHX/7ITH7khdPSeRuVrjolr33Y3+Q+e7Pr6sZq5YPdnWq7NQACAIv23j5xVZcbKFKY8uSl2YMm0s7k9IYCIQCKRSKdlokrw1KCwsZCZob2/v6up65plnOByOQCB4/PHHiX+jCxwOx3k72LYIEpriYffu3du2bTty5EhFRUVBQUFdXZ3HZHK5XCKRhGT7on4IbQyeJDEryFf9Xrx4saura/PmzWT5skAg2Lx5c1dXl0qlKr13VtHcxPv3HH/ho3PPrpy9fEYc+co3LRp+2jzimbDrgQWttmjnAy8t3f05APx8WYaLMikqKioqKiK+Sb64NAy2asi9dPz6lsPPytkJgeawlBU1EwAiw3j/Mn19btwdXqIqccPYiVERzDg2LiFumJzvGgAANotVNEu8ek7iv/4k7f7ZCTPiBDjJENoUFha+8sorKpWqrq7u6NGj9913HwBUVVVVVVUBQEZGhkQiee211wwGg8FgeOWVV0pLS7HREGTqigdfHBIUCsW5c+eef/75UG1i1A+h/PxERbmfDIuJCepKESV/8uRJ+gw5Tk1N5YdzthTOPLnj3vpnfrpGmkxHIn5u9bzOT/5IPBNWZItLZ/SyastP7rj34Jb8lFgeUzmsWrVKrVZ/+OGH5MywLg30F0PszunWWUgQ0rkJwgB53e5wOmyOwUXbqcL0JeK8hzI3xEaMeLk/mY5Y5mkDQZq0GF5iVAQuYJ0i7N69++GHH87MzHziiScqKipWrlwJACdOnDhx4gRJsH///vfee08oFAqFQgB45plnsNEQJJDx4y6tBoNBKBTSPglVVVX79u37/vvvmWk0Gk1CQoJSqWxqaiopKfGxMMG4uSxZP+3xT00778MbMUihtNof8gvg9rtx1onGYIywRO8wTUdGkslka9euffPNN+vr64uKih5//HEAmD59useASLm5udu3b5fL5QAgl8vFYvGePXtcBMCqVavOnTunVCqZ0VqH/WLIGIHbR+rOVq3xm7beh6XJgbCvmZkyHWn/GADWTn9wXHZvcDid757tcJmFWD0ncdK3s0AmC5cNpMmsI9MUaDQaPp/PjPAW2kYAQYIXP/pX+OKQIJfLS0tLc3JyaIdID+MziuJyucHe0CQc/lD6AQlGnBTV8sA6F+WQ+F/PB29sVvrJJT7HBw4cOHDgADlZX19PTspkMo/igXgmLF++/MKFC0ePHt2/fz85TzwTNm/evGrVqvr6+traWuKcIBAIyLhhqC+GNmwWa0acIEB2rWoZuEKvcFDpWsZl02g2i5WbPI25V0NSVAQqh6mMiypw3+/F4w4wCIJMLfEwrENCY2NjfX3973//e5VKRTa1ValUqampLhtFkWVSLu8bglQ/oHgIJeXQtulJElsp/umtgrw8h04nyM9nBf82ZxkZGaN4n7d79+6KiorMzEyJREJ7JgAA8UxYu3Yt0R4kGiMRIWQT66G+GKrY7A5uwGw8b3PYvur+UqVrIR9z4+7IiMoar8znJUbNihf8cNMwYLZli4W4GBpBECQ08O+sn3eHBIVCwdzFltDa2kqiv3srdNBOVubs/NT9JLotBalyIDvBRa9Zk1Lxu1CwBbfclsaSiYtnAtyagYyNjW1vb2empGcehvpiSBoBh9P53tmOGH54YVbcpK8S7rVoP2v/2Gw3AUBkGK84ddUoVjggyCSaLHRbQpBJwb9vST06JBA3hq1bt8rlcqIraCGBhgAJCm7+6U9EOfDz8pJfeTn0KkjvEHfp0iX65J49e4b1K3D3V6a/4v2lgO+OzkGN8saAiXKYBswdA+bJ9Vm61Hv+lOarwa6JyspLvIvL5uKjjSAIggyL30O1eo+xgADApre+oewObIdgQbN3783KKgjaPaR9Yfny5QUFBV9++SV29ziis1Df3egHgKToyElf7SCKHAyze0/yyhVJ96ByQBAEQXxkImb9ho2xQNJoNJphHZYGCx1abksAkJ0o3LdxsUiAPsGBjv6LL67/x2YACIuPz/roULCvjXZ5rADA6XQ2NjYWFBSo1epAXr8YdEbA4XR+dL6L7Cf9iDR5svaTtjlstE5oGbiSzE+J5PDwuUaC1GShtwKChKx4QJMxFJTdsaXm269btAAQJwyveWIZMyg+EmgYz5y5Ji8JSeXAFA8qlSozM1Ov1weyK1HQGYEL3ToSemhpeuy8xKhJkQ3HbnzWa+l9JEs2LsFYEQSNAIJMTfAnZDLhhLGrS+6kt5C7f8/x7xiRDZGAwny5mSgHAEjfvz/ElAOTjIyMoqKiHTt2eAmgjIzs5rHZiXKI5XHnJAgnvgBqU9c/Wt/rNN4w201N2rPYIwiCIMjopTvOPAQCtcobv/lgcKD2y8IZZFMIJHCgtNqWB9aRwKzTFTX8O+4IQVvAiLY06khoaAQ88slldeeAGQDWzZdMcMRSh9NxWnPyUt/5QWUYlVUgKcSZByQ0TBbOPCAIiocpbTK+a+vd+MYpclyyNP3XK2dzwvAHPuCUQ/Krr077l7Wh+ktMxAPZ910mkz322GPz5s2jE7jvwYJGwEeu9hi+aevNEPGXTZ/QCSu9TffPjs/6rFry8Z7klanCdHyiERQPCIKgeAgRtAbr+urGHr0VAJZlifY8uogfzsF7dHJhbukQ//RW8VNPhfAvMREPTU1NUqnUZrNNgFQwWqleg20US32CzgjY7I4wNos9gRtctuvb/nnjCDlO4iffJbkb10YjKB4QBBk7+G47gBAJwutK71qWJQKAr1u0q1//UmuwYrOgcphgJBIJALjs6eYneg22+/ccf7i68XizJrQDFnPD2BOpHABAwB1cXLFEnHdvyv2oHBAEQZDxke448xBoUHbHjn80fXyuCwDihOGvbVi4KD0W79RJoWPbrwdqayGkt3RgPlYA4HQ6DQbDgw8+WF9fX1paunTpUjrBunXr/BF/6bu23gOn2sgN/8vCGQ/kpvgyEREURqBbZ/nqmvbeWeKJDMzqEow1gZco5Ebhs4yEpMnCmQcEQfGAJuNHqo9d+cOxq+T45fU5a6TJeLNOMFNhMziP4oGEanVP4NcF00Yr9eF3HX/+sqVHb12WJfpl4UzvmjnwjYDD6XzvbIeJcvA47A0LUyZg2oGsjVbpWh7K3ICbviEoHhAEQfEw5UwGcwk1hmCaYLRvv9393y8BQFh8/Mwjn7L5/KnwSwy3oi1NCh29ppdQ1IQAACAASURBVI++76A1c3ai8PVH7xhqFiLwjcDX17QX1XoAWJEVNwH7Setturq2j8x2EwDMiZm/JCEPn2IExQOCICgeppzJaO7WPfn30/QS6uqSOzEE0wQQ2pvB+S4eyL7v/g6yRNkdJ6727Pm8ublbn50o/EV+5t1zEsw2x/aD388QC3+zam4wGgGt0XrofBcAJEVH3j87wd+Xu9R7/pTmK3KMa6MRFA8IgvgVHIkGNNmJUR9syc9OFALA1y3an/35K1xCPWHKAQCmjnJwQaVSFRcXC4XCzMxMLpcrl8s1Go1fBtkG66L/77OnFGcWZ4gObll+cEv+GmkyP5wjEoQ/uDAlSO92h9N5vKWHHBdmxfn1WmbK9Fl7Ha0clojzilNXo3JAEARB/CjdfRHuGo3ms88+k8vl+L5hUqDsji01337dogWAOGF4zRPLRhHaEvGpqbXaH5bnk+NQ3QzOy2MFt2YeiouLAeCZZ56ZN2/ehQsXXnvtNbFYrFAo/CEePjnX+eCilJFGJQ5kI3ChW0f2k16aHjsv0Y+LldWmrmM3PieuSpFhvNXpD+DaaGRKmSyceUCQwBUPjY2NBQUFgfOUTkGTQdkd+75sod3B3/rFEgzB5A/lEPLbSPsiHsiCab1eT8dWcj8zjtQqb+TNiBcJBvdd7ug1nb3eO2yEgIA1AjoL9b7yBgDE8rgPzJf4dZ203qb7oPVdAJgTM/8n4qW4bzSC4gFBkAnApx+b7OxsIiGwvSYLThh7S+HMl9fnkI8b3zhVfewKNss44qQoWjnEP711qimHyaKj1/SbD5oiuT8aIl542G8+aApe9zyb3cHjsAHg3lliPykHm8NGDoTcqHuSV96TvHJJQh4qBwRBEGSCBqW+JOLz+UVFRQUFBRMT9x0ZijXS5OQYHgnB9IdjV/tNtl+vnI1LqMdFObRtepJWDlNkM7ihyMjIkEqlmzZteuqpp1JSUjo6Onbu3CmTyfzxsKt1ZgBg+iyRKQiT1Q7BaVpE/PCHpcldOos/9nZwOB3NfReV2rMPTF9PFjakCtPx+UUQBEEmEp9m/SYl7ru3Qk/tyUqtwbq+upEOwbTn0UUj9RdHXLj2+C/INtLRa9akVPxuitoCxpqHpqamX/3qV/X19eRPRUVF+/bt88fDbrRSS3d//knZCnoZT3O37uHqEyd33Ov9rp6CRsBMmb7sOtppvAEASfzk4tTV+OQiU3r4gm5LCBLI4gFNRqBhtFJl73xHL6H+YEs+7TKOjJSpthncsOKBDpBgMBjOnj27cOFCv04w/uf73/carb8snJkQFXlVo9/zefPiDNFQEVoD2Qic7eifES8YxwkHvU13deCHfmvfnJh5Zsp8rHNQy8WEi+5JKca10QiKBxQPCBIE4kGj0TQ3N+fn5xsMBqPRKBaL0WRMFpTdseMfTR+f6yL64bUNC3EJ9ViUQ0R2duYHB6escmCKhwkOkNDRa9r5P+eIEgaAkqXpT66YMawYDjQjcL3PVP+DBgCKZonTYsYhGBpz6wYmuDYaQXAkgCDBIR7q6uqee+45pVIpk8kUCkVdXd0TTzzR2dmJJmNyqT52hQ7B9PL6nGFj1CBM9F98cf0/NsMU2wxuWPGg0WgSEhIaGhry8/Mn7OpGK3W5SzdbEuWjD15AGQGb3XFQecNEOXgc9sPSZO6YlyE5nI73WxRmu5l5Mpwdfk/KygSeBJ9cBMGRAIIEgXjIzc3dtGnTokWL9u7dq1AoKIricrm45iEQON6seUpxhhz/snDGlsKZ2CY+jVan5DbSvogHg8Hw4IMP1tfXB3KAhIAyAl9f015U62H8ph3oGKxMpgszf5p8Lz65CIIjAQSZXHx6ydfU1KRUKjdv3tze3j74NQ6u0A0UVmSLD25Z/uTfT/forX84dvVMW291yZ0Ygsk71vYOehvp1Nf3oHJgotFoyFLp119/nXm+tbXVH+LBaKVOq3r//rWK9lwCAOYS6gBHa7QS5ZAUHTkuygEAOCwPBjYmAv0SEQRBkMnHpyFmVlYWAFgsFqacAIDU1FRswUAgOzHqgy35ccJwAPi6RfuzP38VvGHyJwBKq1U9+ig5noKbwQ1LRkaG0xN+mmYse+e7Fz46BwCrFkiWZYkAYFmWKFbADYq2cjidRy6ryXFhVtx4ZRvJ4cWEu0qFGdGz8OZEEARBgkM8CAQCmUy2adOmEydOaDSaxsbGxx57rLy8HOcfAgeRILz+mZ+SsVdzt359dWNHrwmbxaNyoDeDS371VVQOQ2EwGBobG3ft2tXY2EhRlJ+uojVYv27R1pXe9eDClIVpMfs2Ln7rF0t+UOvDg2Tq7JJab6IcALAiKy6SGzaOOa9IumdaeMyglgiLXCLOw/BKCIIgSNCIBwDYvXu3RqMpKSmpr68vKCgoLCzcsmULNl9AwQljV5fc+cvCGQDQo7fev+f4d2292CxMnBTVse3X9GZw0/5lLbaJRxQKhVAoLCgoqK6uLigo4HK5CoXCHxe61mOAW5vEnb3eBwA5KdN69NbuAUvgt5LD6VTe6AeAWB53Rtw4O3Qptd/1W/tSBGn3JK98JEs+J3Y+3pYIgiBIMImHjIyMzz77TK/XNzQ06PX6PXv2TFacVsS7fthSOPO5VXPIx41vnFKcvIbNQiuHtk1Pks3gYn/+2BTfRtoLFEVt27atsrLSZrN1dnbq9frKyspt27b541oJUZEAQNkdC9NiT6m0zd26T893AUBQuC2xWawNC1MWJU+7d9Y4G0Obw6bStQBAFDc6VZiOgVkRBEGQwGGYYAUKhWL69OkLFy48dOiQ+18nK/oKxlgYlu/aeje+cYoclyxN//XK2biEuuull3r//jZM+c3gvDxWAOB0OpuamqRSqc1mo/0S/Rpd7T/f/77s3uyUWN5/vv892bekZGl6MG4SN47Qmzysz/wZeishCI4EECSYxAOLxZLJZLt3787MzHT/K4ZqDWS0Buv66sYevRUAlmWJpngIJtxG2nfx4L7PA9k2jikn/HfTAoAv26VPrhEw2+xGm13E98u27g6n4/2WA2a7KSZc9EDGerwzEQRHAggSTOIBTUaw64ftB78nETDjhOEfbMn3ZVgWgu3w9tvd//0SAITFx8888imbz8d7w4t4oPd5kMlka9euffPNN+vr64uKih5//HEAmD59+jhuHqc1WL+6enMUmxtOrhH45LK6c8CcKeIXzogf98zVpq5Prh8GgHuSV6YK0/HORBAcCSBI8IkHjUbz2WefyeVyNBlBB2V37PhHE/EGiROGv7Zh4aL0qRUtHjeDG6l4UKlUHmcaCWSP+fG6KPGva9p5XxAZget9pvofNAAwN0G4bPr4306ftdd1Gm9EhvEeyZLhagcEwZEAggQaPv0yNTc3l5SUYGMFI5ww9v9+JJcOwbTxjVPHmzVTUDkAQMY776By8IWh9nkgjG/YpelxAiIhgqVxbHZHY2sPAPA47DtTY8Y9fzNl6jTeAIDZMXNROSAIgiDBKh6ys7MBoLGxEdsrSNlSOHOvfHBDg6cUZ6qPXZkKtaa02vbSssFBqqImPDUF74RAI5LLXpYl2vjGqZc/vlirvEH/M1qpwCxwo0pLNnbIz4zj+mER0YCtnxzMnjYXbw8EQRAkAPFp1o/2gS4tLV26dCl9HqMtBRfN3bon/356iiyhZm4Gh9tI+/hYAYAvTxZldwDAsDeP1mCN5LLJHg5D0dFrun/Pcffzn5StSInlBZoR0Bqth853AYCfVjsQbA5br6UngSfBexIJKAwGg0ajmZQoKTgSQJDgEw9D+UBjtKWgwyUE0ysP54bkEmonRbWuf9jS3AwA8U9vxS0dxks8UHbHp+e7Xj1yGQA8rp8he1F362x7Pm8mK21eXp8zivXQAWgEHE7ne2c7yLTDY3ekcsPQpwiZWpCRgFQq/e1vf7ty5UrOZMesw5EAgkwWPv3+CQSCmpoad+/nwHkDgfiISBBe/8xPl2WJAODrFu366saOXlPoKYe2TU+icvAH+75sefXI5T///CfPrpztsn6GoiiFQpGWlpb5k3vu33M8M15wcse9n5StWJg2KDCqqqpyc3NZLBYz9AJldzyycVN4jIT+d7Lph45eE5ncCCguqfVEOazIivOTcrA5bHiPIQFLRkZGQ0PD/Pnz16xZw+Vyd+3apVKpfP86RVHk5YIXNBqNwWDApkaQUBAPY1ww7d1kUBQ1IgOEjBFOGLu65E56CfX9e44H0XJVX6C3kebn5aFyGF/qL3Y/u3J2dmLUGmnyqgWS8zf66T/t3r1727ZtR44cKfq3X/Wc/HC6sZkfzkmJ5TG9j7Zv3y6VSpkZdg9YLmc9Mvv/+Rv9798Ptty/53j3gCXQ6j4nQbg0PTYpOnJGnF98NXst2gNX/nZK/RVKCCRgyc/PVygUZNf56urqzMzM4uLiYddD0m8W0tLShkqsUqnkcnlCQoJQKBzfqAwIgkyOeBj1gulhTUZSUhKXy83MzExKSiorKxv2tQQyXvphS+HM51bNIR83vnFKcfJaaFRNs3cvrRzS9/0Z+3qkqIZGZ7Q0d+tnJQ5ueLwwLab+Yjf9xYMHD1ZUVOTk5Jzu401fsGT3KcvD1Y2Kk9foOYStW7fK5fL58+czL5cYHTG75f0tmb2flK34pGzFXvkd2YnCZVmixOiIgLOVLNb/z965xzVx5f3/CwQUAirBxCCIBClqa4LaCxWo4hppFbe6youWxLprKV1RDD9/1ketropPxXVbHl+Ill3RurUSq4/6kxbQKl0vJd5qqQavqBARFBIJCjNBkgF+fxydTpMQwiWQwHm/+GMynDlzZjJzcj7nfC8vD/N6ZzTPRvXfeXobAG49uY4fQoydw2azZ82alZSUBACFhYWRkZGhoaEWJgHpmYX09PTIyMiCggKjAgqFQiAQjBkzhiCI8vLy8PBwfJMxGIcXDx4eHmKxODIyMiUlRc6g3eXFdruM3bt3l5eXEwSxe/fubdu2Xbx4EX8lPYYkbOTeD99A25uP3fr7sZt2aCvSUeWA0kgPCAnBaaQ7h6BtbtyrAAD2Cwfowe6upTUE2iZJUqlUCoVCZAXX7Mmr//loyrSQnT+VZf9UZvmMbhS55C/x/hyPf2xY5aIp3fb+xAtlWr09PYrPDM22PoWhxYBkQ6BXkKuzK34OMfYJRVEFBQWhoaECgeDw4cM5OTkEQajVah6Pt3Xr1raOomcWJBJJfHz85cuXjQocPHhQJpOtW7eOzWYHBgZii2gMxs6xanSl0WgKCwsBYNu2bcz95eXllqMt0V2GUCjMy8u7fPnyzJkzmQXojzNnzuTz+T/++GM3Jq/FtMuEAO8zK6YiF+qcixU5FyuMCnQie1dvoSsuRsrBZejQgH/vwcqh6+Tk5ISHh+fl5WVnZ/N4vJdHBQCUkYwgqiHDPOkuAgC8vLzQisFrHH1Wwd7J+V9//FbQzp/KkqKC2+yAXJxnzZq1evXq+vr6HTt2REZG3iy9BwB1pMFymKaeVA77r1QJOB4RgRzbOUk/IJ4v/Qk54/GDh7HT2RmNhsfjAYBMJtu3b59QKET72Wz2woUL8/LyzB5Fzyygj+Hh4dnZ2evWrWOW2bZtm1gsDg0NBYDExMRFixaxcAeOwTi6eEBJozpatTVdBgAoFIr79++jfmfBggX4K+lhOGy3I0kRKw9fvVCmddyrwGmkuws6wzQdSy05OXnWrFkCgcC5lQoZ5nmnpiFkmBcAnCnVvB74/D5zuVwAaGhoYLk4vxnEGdhAIt+Gwe6utYSeam5pK66rTk8NHhdV0Qrg5SNd9cW5B40f5VwNGcYzitNKUZSra+/Mx58uqwWAcq1O5DuI42Gr0GSXNRcBYIgbx3sAfnQx9ktmZubChQtNJw0lEgkzEIKR5EAzC89/cTgcpVLJLIDsna5du5aenj5kyJCEhAStVms6VOjFTgCDwRhhw2iD7XYZiF9//XXLli379++fOnUqGoKY4vR78NfW7fohS/qq47ZfX1lFp5H235aBlUMXaWhooPUAUxvodLrXAzlfKcqr6hrPlmouqbThL3Id5F57LJyzqKSkBAAmBnj/VNkUPjVap6e+UpRLwwIsZISoIw2rjpTQf4Pf+sDrmXrzXJHxJAeLZRTqrWduxb1a8lH9MwAYy/O0nXJQN1Y/a24EgHEcEX78MJ2gZ4KOcLlcDoej0+mY523XuZmeWaD3GEVN8Pf3B4CkpCSJRDJz5sw1a9ZkZWWZ1oPXIjAYxxMPJEkWFBRMnz6dOYi33GG122UgkpOTr169qlarT506lZ6ebloAe1H3AI6bLY7SalXvv4+2cTK4bkEoFIpEosTExJKSEpIkFQpFYmKiSCTicrmyaS+Jxw57J+Psuu+urYgeHT7KBx1y5cET3tg3tmzZolKpfBtKa5VnioaIw9J+5LDdXO6c3r59O+pDVCqVRqPRaDRoAwCGuLX8c7rnr2unXVgRueWNZuXmeWv/OC7khU9272Jobvm5og4A3FnOb5hktOhGbj25gTYCvYLs6kl4Zmg22J8flEajaWuSG/3XyckJPXJ9FdM7YDYRky0kilQq9fDwoPew2WypVIre5bZgs9kikQjNLABAXl5eVFSUkSoQi8WcF5M+HA6nurra7O9+r8wgYDCYzouHOXPmJCQkAEB8fLxYLAYAsVjc1kKBlV2GkdKIi4s7fPiw2fkG3GVgzNKi09FppIetXYOVQ3exb9++69evi0QiT0/PyMjI69ev79u3DwA83FhJUcEXP51WuGxKjGg4rTlXzRj772V/mjdvnkAgSPo44TPp5HP/FXXx02nZC17/9cJP586dA4Dc3FyBQFBYWFhYWCgQCFJSUtAwKGbR2oGDh3p6eiYkJKSmpga+PDFf+dAeboJCpUWJHaYGc51ttuD5jGpUNZQBQKjPRGcne9HwWp3++K2a/Veq9hVXXriv7QGXceshSXL//v1t/TcrK4vP52/atKkPv56md6C8vLwHzltVVYV+2Zk/3Kg9lg+MiopCMwsFBQWnTp16++23AWD79u20xnvrrbeys7NRkoctW7bIZDK8zoDB2DWtVqBWqwGAIIicnJzMzMzW1taioiI+n28wGCwfKJPJRCJReXl5fn4+n8/Pz89vbW3NzMxElRAEUVRUZDAYDAYDsmgym4rOFCubjekQ49YfN/378tQdu21wi8Gg+svCG6PH3Bg9Rr19O/4Gu4hph6BWq4uKigiCsL4SgiCMugW1Wq1Wq9G/yhmgnZVa3bj1x2+W3isvL0fla4mmceuP1xJNvdsJVNTpvrp0/6tL90/d1dj6zjcadFce/9Kgr7eTJ0FPNaNrp/+O3azuaCVoOBsfHw8AIpFIqVS2trbSi8+pqanoOWEWy8nJUSqVaHIqPj4ePRKoQGpqKl0PKmz298tgMKAfGgBAZ2yL/Px81JjU1FT0KKampspkMvQvAEA7+Xz+//7v/xo1wLQ2utnoQNPKTa8C/T6mpqbSNQAA+insxB2gN4xObfa8nYYgCCRUmBeOxgbtHojawOfzc3Jy0FcfHx8fHx9vVADNS6KbhkcCGIzdYm2SOHq+AU0ihoWFVVdXV1ZWWj4wLS0NTUYmJCSkp6dHR0ejGlAlGo0mMjLS1dXV1dVVJBLJZLK4uDgs5+yKL0/fyzp91x5FL0XRyeC8P5iPk8HZDjabTZKkZcsEZmGjKUMul4umJ+kgjAi0U93wDADGvBREB2fksN0AoFHfm1PdLa2tivJaAHBnOUcE2tyFZiDLPdRnoqdrLxhr7fm5wvRvX7Fxx/6ooclsyXbr53K5BEEkJibOnz8frWihkeLhw4eZgblRsblz54pEomXLlhkMhvDwcKPQnwRBzJs3b/PmzWlpacxBMxNUZ3R0tEwm27VrV1utoigqJiZm8+bNBEHcunULWdhPmzbt4MGDAPDDDz/w+fyff/5Zo9FUV1e//PLLRg0wrU0kEs2ePdtgMBAE4ebmZlq56VUAQFxcXFZWFrLP2bVrl0wmQ0P8Tt8Bs9dlufEd7Qri4+MTExMVCgVaRpg/f75MJrMcdBEduG7dOoIgHjx4IJFIUBeRkZGRkZFhVIAgiJMnT1o2asBgML2OkzVWQCj6isFgqKysnDRp0okTJ0pKSqRSKUEQ7fYaaE1zwIAB9JACjUJQ70BRFFIgHYrr7ORkVbMxXUFL6lEIVwB4M4iTJX3VrvwiqjdtqvtmH7xIBocDs3ZDX+DkhEYkAFBQULB69Wo0xymXywsKChISEh49etTtJ9XpqbC0H4+nTKbDK5XWNMzLOnfx02mWQ7Va7gRujhlrunPsrZvWN+xeLXm2rHZykI+N8knbCdYIAAssfD3A8q8GitlFkqSnp6darS4tLf3xxx9v3bp1/fr1qKiojIwMVEytVnO5XIVCERkZmZOTAwB3795dv349+tGhC9B1CgQCs9++RCIZM2bMunXrSkpKRCKRwWAwa/2iUChiY2PR80xv040UiURJSUm1tbVvv/321q1bs7OzjRpgdGpmbW1VzrxMZiW+vr6HDh0KCwtzdXVVKpX19fWduwPodTA99fnz5y03vqOoVKrExEQUuh0AZDLZ2rVre2usj0cCGExvYW2o1vj4+MrKysDAwKlTp6JVUWvmG+hJBaO5qN9Oz2LhdDD2CQrhmrj359Ia4kKZNinnF/vRD5odO7BysCmrV69OTEycMGHCjh07ACA6Orq6ulqlUnX72+rhxpoxjr/h+2uLo4J5XgPvaYiMH0ulYQG9nuRhlA87YIi7q40f+JOVBTx3/ujBYwey3Pvkg4Q6/wEDBgBARUVFZGRkfn7+ggULPv30U+ZaFvpRePr0Kb0nODg4JyenqanJ9FfDwiwV8gRYv3492nPixAmjzEKIp0+fonwFADBo0CC6qWKx+LPPPgOApKQkVGD27NntNoBZW1uVt1VJUlLSjh07nj59yufzhUIhM49qJ+5AW6fuxsF9YGDgyZMnSZK8cuXK+PHjrRwDYDCY/igeAIAOxyaXy9FSI15Y7A/64cDHk5JyfrlQpr1Qpn1v5/nsBa8jq5Kep0Wn0/38c3N9QzNB0Mng/NK/wMqh2ykpKVEqlYsWLaLtEm3qvJgyLWTD99cWfHUJfZSGBXw8eZQ93AdbKwfC0PBI9/CR7iEAhPr0jq+/2aWDltbWA1eqnlG/xVkay/N8c2RnzLcOHDiQnJx88eJFPp9fU1MjEolmzpxJkuSpU6emTp1qVHjKlCkAgJKKAoBGo2Gz2ab2ciiyp0ajMfoNys3NFYlEubm56OPevXtXr149c+ZMhULh5+fH1L1TpkxRKpUqlcrf33/Xrl20uezs2bOXLl0qk8m4XC6fz9+2bZvZ8OKmzVYqlSUlJUKhkKKoiIgIs5WbBamU69evr1mzput3oK3rsoUmxOlcMZj+TAd+HVHQxo0bN5aWlnp7e+N7Zw2m0WwpiupoTG6j8p2owZqGmReXLs5Z0lffDOIAQGkNMTdLoSX1PX8bdcXFtye++uCvix6uWFGTmgo4GZwtCQoKAgB6yhPJCXrI0u34ebtnL3j94qfT9n74xsVPp62aMba3BCoA3KhpOH5b3TPBhe7V30EbL3sL7etXwckpVjR8wvDBA1nO3u6u4pe4nY5Um5ub6+vrGxsbu3v37ujoaLVa7evr6+npOW7cOLND0vz8/Pnz54eGhvr6+poN7Y2kbGZmJo/HM8r5s2XLlsTERNqpJikpSalUajSaxYsXIy875okyMzMnTZrk6up648aNZcuWMdULGnMnJSUBwNixY60ZSefn50dHR4eGhrq6utbV1Zmt3CxcLhf5Mb/33ntdvwNtXVc30omg7RgMpu9hrcmgXC6XSqUAwOfzq6urASAnJ8dCsG3bNroLlo76yio3f79ebGonDE+NKukW09UO3UOquSX7p7IvT98DAB9Pt5yEN40SANuUVoq6MyWqubaWudN/506vyW/hF7h7n1V44fOAXu1Zs2bt2bNnw4YNixcvnjdvnmnO124hX/lw0qihtGCoqmu88qAuRjS8Kw9w53weGpqoQ8qHAODt7jpnnK9N77ahxbD/7tcAEOgVNNn3D31y3gR1U2ginF68UqlUdM5BLpeL3N6MzOHQYBTtZBZoa5s+inkitMfb23vMmDF37941NbChKKquro45eY/qRJWgIAGBgYGWT2rUbDabTbvzMSu3UAl9oq7cAaZJIfPU1jfeSqZPn37t2rVx48ZxuVyNRlNYWCgWi48ePdor9kvY5wGDsWvxQFHUiBEj1qxZs2jRItSr7tmzZ9OmTbZwoLRdl/H0+7zanf9qunPXxcdnaNIi7/ff7wGLF1MzcTsRD52wX886fRfpBwDY++EbEwJ6aPVJV1xMJ5Cm8f5gPn/NGvwC20g89JhbZFVd4zsZZ5nu0VpSP+XzU2dWTLW8/tAJ8fDSOYXlparjt9Uon3SsaLjXANt2DmX1d4uqTwPAOyNm8dz5fVg89G4zTBUCptNoNBoej0cQRG5urlarTU5ORm7ZDx486JW0DFg8YDC9hVVmSzdv3qyurkbKAQDYbPaiRYuQA6WjXKeuuPjhihVNd+4CQHNtbc1nm+q+/bajv4VOTk4SicTJyUkul5eUlKClW4lEgu4DRVH0Yi5KgAWMxJ9yudzX19fJySkxMZGuDV7YINGrz6GhoaiGjRs3Wk6tjVoSGhpKp+EzOtaowUYf6YaZXohRSfqMSVHBf5/73L5iwVeXfq2ow+9PXx0inDt37uTJkygTC0EQGRkZNhp+oVCtTPdo24VqLXt3NqXVtvXfe7UkUg4Thg+2tXIAgGtaJQAMdHHvk8oBAPz9/Xsmc5llWCwWVg7dRaeDtmMwmP4oHvh8PrwIoY1A2zayge4KN8eMNftnOnVd89mmtgpbqN9CPPITJ06o1WqU/mbt2rXMo0iSlEqlhw4dQkl2jH7bmB/bioPeVkvoAOptHYuK0Z5zRh9Ru9w3qAAAIABJREFUhHKzYcWNSiJiRMP3fvgGrR96IAVEK0Vpv9lnup/z57/gt9d2QwRko4jcIm1qkDCa7wUAVXWNv529pgEAvNmuXal27K2bzL+hS5MBoPnx47b0wzND89my54kdRMMH2foO1zVpn+i1APAaN6yvPkU4kl7fw8/PD/1qhIeHnzp1qqSkBGXGwPIMg8Hi4XfI5XK5XH7y5EmxWBwZGSmRSORy+fTp0yMjI8ViMdOlsp+wdu1aNpv9yy+/AMCTJ08OHjyo1Wq3bduGLLuUSuXy5csVCoVRZ3rlyhWRSITGYZad2Orr6zdu3IhWJ1C/3BbLli1js9kLFy5EToFtHYsaTEsUo49IYxhdiNmSNBMCvPd++IaPpxvYPoUcpdWWz53XcOyY0f5BMTE96bjS3wgJCQEAhULRA+eiQ7X+WlFXVdd4tlSz+oiy20O1cpcssawfLrxYRosezXP+vROqLSjRXkEbIzxH4ucN4yiYBm2XSqXWB23HYDB9hnZ+odEEJM3+/ftRIG0AKCwsRIHk+tX9shCPXCgUqtXqAwcOxMbG8ni8q1ev0mWY5U1paGhAGyjlttk46KYwA6iTJAkAZo81kjFGHzsXWH1CgPeRpAiUQu7L0/fKH5NpfxJ2ewoIXXFxpSyl+fFjAPCYNGlE1pe6ixeb6xvYEeE4yJJtB/QeHmiyQCaThYX9NjU+e/ZsW7zvPROqFeUgf5y5HekHZqiuB08ay7U6ABBwPDgePRHoaeLQ1we6uAOAq7Mrft4wDgQO2o7BYABepLh3LDrR7KYHlTdGj2H+NZw+3aEakP0u2kbWR0qlEn1Uq9VoJ7JZQiXRNjoElS8vLzcYDPHx8ei/qAaDwSCTyVCx/Px8kUiEyvP5/Pj4eLPXi+rPzMxsbW0tKiri8/lmj2U22Kj9Rg0zuhCjkm1RSzRN+fw/49YfH7f++EdfXzJQzd34Fdd+8w39Tam3b2/F9Mhrhb73tkzVy8vLbXd2sslQfF9LNhls1wm0traqt29HD9XtiEhDbS3aWV3/bH/xg/3FD/Td+gxjMH0MtVqdk5Pj0CMBDAbTLTj3E43k5u83qrDQ+4P5ADAoJmakPMdzypRO12Y2Gndubq6rq6tEIhEIBJmZmUyDHzabnZqaKhAIXF1d0ZoAi8VKTU0ViUQoIDcq1m4cdCbMAOodPdbyhVgJh+1WIHsLpYBAKah1eqob1CxFVS3/pOazTejjSHkOmjPG9BiBgYFmOwubmrB7uLEmBHjbOrG0WfulYV4D5omGR4/mubo4428f44j0TPAS2hsKg8H0cxwy0lmvBGhrNx45AGg0GpIkjYKaM+N563Q6b29vuh7TPWASBx1MwqrSLTEb15w+1qhao/Yb1dlWWPH2b0tzC0pBDQA+nm5HkiK6kuGL0mor/rKwqbQUcBq43nit4EWo1p5Ep6cuq+q+uaBCTxHieMpky7lEutIJaHbsoJOU9/AzVtekrdE9GjU4xCEMlp5RjW4uA5yd7EtTaTSalJQUZiA4o2cYAOLj45csWdKHsyAb3YSe+U1EoVqLiors5MbiUK0YDBYPuMtwVKjmli9O3M65WNFF/WDs5LBju7OHB769vSIeSJI8c+bM1q1b6VQPAFBeXm6LxYfEvT/fURMv8Ty9PdzqdPoLZdo3gzgZ70+wvArRxU6A1g/OPj6jvv+ux/TDycqCR7qHALAg5CN7fhjqmrQl2iuqhjIACPWZOHrw2IEsdztpm4UMEk5OTvn5+S+//HJeXt7SpUsJguirXnlGN6ETeXs6AUmSc+bMKSws7BlvKDwSwGDsFrxMj+kqLBfnVTPGLo4aBQC1hH7K56c6kQJCu2/ffYkUKYehS5MDsndi5dCLzJkzJyEhAQDi4+PFYjEAiMViW3hGakn9hTJtgeytOeP9xo8Ykr3g9b0fvnFHTbjZ2IKIu2QJ9edEAGiprb33x3ct5H/oRp5RjUg5hPpMtOdv39Bi+P7+EaQcAOBqbfFP1ac6Mbql08XQ6WhM89i0mz8HFdi4cSNdz6effooGjk7m4mK9/PLLgYGBCxcuBICysrK2mldQUIAas3HjRmRKunHjRpSfp6CgwMnJCe309fU9dOiQUQNMa6ObjQ40rdz0KgAgJSVl48aNdA1OTk4URVlzBwDA6CbQeXuMTm322M5Lbo0GzSZs27ZNysBybA8MBoPFAwZjnqSo4NUzxqDtDqWQM3JyGPGvf3KXLHHqjXylGOYQ4e7duwsXLgwPDz958mRRUdG1a9dQaK/u5X4tCS+SxF158AQAhH6Dawl9Tb1tw0A3NFGXxbEP5n6A9IPl/HHdxe2nN9HG6MFj7eS73lu6y/Rv/92vjYo90j00W7J9kfb7dDRt5bGxkD+HhiCIefPmbd68OS0tDV54ypqeMTExUSKRBAcHx8fHjx1r/j5TFBUTE7N582aCIG7dupWVlQUA06ZNQxGuf/jhBz6f//PPP2s0murq6pdfftmoAaa1iUSi2bNnGwwGgiDc3NxMKze9CgCIi4vLyspCImrXrl0ocoY1dwAAzN4Es9dlufEdole8oTAYjB3SzqqfWbtSGrxYiTHi14o6Oubm6hljJGHthLE3cnII/PZbnMCh1/qCF2ZLCoUiMjKytbVVLpfn5eXJ5XKKolxdXW1htlRV1/hOxtlf/za9pr5JuvvCzg9eu1PTsOpIycVPp9nObKmltfW769V1jQYAiD6XW5/1Jdje/6GltWXfna8AwNdj+HT/mfYjHrpyuAXjK2RXg54ZkiQ9PT3VanVpaemPP/5469at69evR0VFZWRkoGJqtZrL5aIHLycnBwDu3r27fv16g8FQWVlJF6DrtGC2lJqaGhwcfPfu3aysrPPnz5t9YhUKRWxs7KNHj5jbdCNFIlFSUlJtbe3bb7+9devW7OxsowYYnZpZW1uVMy+TWQla2QgLC3N1dVUqlfX19dbcgdbWVqOWoNfB9NTnz5+33PgOgdzhTPcbud7hkQAG0+fpWJ4HI8rLy3F2GAwTlEIO6YfNx249bTQkRQW3VRg7OdgnzDyyy5cvLykpQdYOtjBb8vN2nzGOX1Pf5Oft/kYgZ17WOQDo9iRxxh2XVoeUQ1iAt9/rS91YzmbzP3QvD8nnoy47t1nqXpjpaCoqKtrKY2Mhfw6zgFV6ZsECJBh++umnvXv3rlu3zrTM06dPeTwe2h40aBDdVLFY/NlnnwFAUlISKjB79ux2G8Csra3K26okKSlpx44dT58+5fP5QqGwoKCgK3egrVN315uLZIzZkQBefMBgsHj4DSzrMZ3QD8dTJkt3X0Ap5AAg8a0g0xRy2n37aFOloUuTh/71r9hUyU4wzSMLALbLI/uP2FB6Y9WMsQDQlYBd7fLM0Hy2rBYA3FnOY3ieYDF/XDdS/PgyAAx0cee58+3nuza7dNDS2nKoTP6s+dlvj4RX0GTfP3Si/gMHDiQnJ1+8eJHP59fU1IhEopkzZ5IkeerUqalTpxoVnjJlCgAIhUKhUAgAKAmpqT29v78/+q+FMbFGo7l27dqyZcsAQKFQ+Pn5MUe3U6ZMUSqVKFrdrl274uLi0P7Zs2cvXbpUJpNxuVw+n79t2zalUtnuNaLaSkpKhEIhRVERERFmKzcLUinXr19fs2aN9XegrZvQ1nV1F/7+/swkMDdu3Fi9ejWPx0ONwWAw/Yh+kiTOQTEYDN2bmavdCrvrdBZSyLUYDJX/d3mns/VhbJ0kzjQzFMoe2Dc6gWO3ar66dP+rS/dryaZ288d1Fw36+q9vZ399O/um9ppDPAz6Zv2Vx798fTs7t/zQvad3mls6nD4PjTLFYjGfz+fz+fn5+QaDAW2j/SgJplFKSpTsUiQSoZJGBejtzMxMs48r/bvG5/NlMhnK1CkSiUxTm2VmZtItoTs9JBWKiopaW1tTU1MBAHWYpg0wIj8/n8/nI5ldXl5uWrmFStBR9Ctm5R0wugnMncxTW9P4Dv18mP2WCYLAIwEMpl9hrclgT4ZubJf+Y+nYdSvVjlbYjfdWS+pXHr6Kgve/GcTJkr7KcnGmtNqq5Z/ozp8H7ORgZ5jmeUB5S5jzjiy7WR3q3IP6zNB89NqjRqplLM/zzZHGywu2y/9AGBqKH/+saiiLD/6zQ2R46MauxigdjVEem3bz5zALtLVtdCAwcu+QJIlcIEzXzSiKqqurY87cozpRa0mS1Gg0gYGB7Z6UeXY2m40qNKrcQiX0iTp6B+D3OX+YO+lTW9/4zoEcRfBIAIPpdwMGK9+96dOnX7t2bdy4cVwuFwVjEYvFR48edRSHaeGGH0x3lmx4G4sHm3bHRink9k/nNyz5GDs52L94kMvly5cvr66uZhawK8vmTj+oLa2tyof1ouGDnM0F+rRp/jhDi6GfKAdb9F2d7IJMFAKmK1IhNzeXuWfLli0AcPXqVcfqBDAYTBexKlRrT4ZutOffQjoeua+vLzMaNz07axSi2yiEORqT+fr6Ojk5oWKmh6B66GKJiYmdaIlplHGzFZo9tSmmodnBJK656R7USJaLc+b7oZMFXgBQS+infnNFdqf85du3zrwZFpC9c8KkSUY1G1ViNg46fml7YIgglUqTkpLKf0/fsGx2dnIa7zfYrHIAAO6SJUOXJgMA8n/o3vit/Uc5gIl9fG/BYrGwcuguNBoNM73D8uXLo6Ki9u3bh+8MBoPFgxlKS0vhRdyMc+fOAUBYWFh1dbXZqG29i3DDD2b/ul4YMWbMGIIg4uLiRCLRwoULCYK4fv36lStX4EW0b9MQ3SiEeVxcHBqTHTp0iCAI9C+zh5gW61BLTEN9m62wrdaaYhqa3SiuuYeHh+ke+vCBbm6fRPBqTu0FAFdPTs2C9HOHj320a5cTi2VUs2klH3300fr16+k46KmpqSzsVG17UGqtTz/9NPD3dO/Nr6prtPBHNbd070VpdXqtTm9NyW7XD5VERUtrS397ilgsFo7A08cwyvPw6NGjjIwM5NuNwWD6Vw9vTaGeDN1o5yxfvpzNZsfFxR08eFAikQDAvHnzDh48GBERgQbWT548OXjwoFar3bZt29KlSwFg7dq1SHedOHFCJBJFREQAwLJlywoLC00PSU9Pv3LlilExAFCpVEi2hYeHW24JAPD5/JkzZwLAkiVLYmNjp02bZlqh2VObHR3W19dv3Ljx1q1bAEBfKZ/PT05ORkMEAFAoFEZ76AghlFZbtWq15uyhP3tzjo+fRbGHfKyEva81TAjwNqoZtZxZiVAoFIlEJ06cmDJlyrZt2+xhIrM/EBQUBADdbh5txDsZZy3893jKZD9v9+46V0tr64nb6rZcHczqB+im+Evqxur/PDwBAH8cOdd7AAc/XRiHRi6XT58+nf7pRz9M6AcIg8Fg8WA839CToRvtGXTJfn5+dJzB4OBgNPw1DVKu1+uhvQDhRoc0NTUxd3aiJaahvs1WaPbUpuJBo9GYhmY3imtudg/i2e3SioSE2qpKAJjNqv5nzt8Cpf8NAAu+upQWM+rd39dstpKVK1euXr165cqVIpEIT2T2zOAAAMRisUAgkMlkYWFh9L+6Nynk8ZTJaGPD99e0pP7DCMH4Ed5nStWHiys5bLdhg7rTJPJSRV0j1QIAXE9rq+0u/XDryQ20MdhtCH66MA6NSqWSSqXMFWw2my2VSplyAoPB9As6EaGp10M3dqLZKGao0V8nIg/S2yjOYGtra05ODtpGXapSqaTvklFoPFSgqKiIIAixWAwApofQxcrLyw0GQ3x8vOnFWm4J83CZTCaTycxWaPbUpvcWxQ1E5fl8vumVGgwGZGVktMdgMADA0cBAZcjo+UO8AaDszh0AKL6vpe+/MO7/Mms2rQRtAAAK9YiDo/VAqFYLdG/UYESlVjdu/fFKrc5oD9lk6K5OoP6ZAcVmPXarpsN9Xdfit+qb9ShC65XHv+AHDOPoFBUVgbnwuLboGXCoVgzGnrHK54GiKBUDkiRJklSpVNh71WgpID8/f/78+aGhob6+vmh9xqhATk5ObGysp6enWq3m8/lmD2Gz2ampqQKBwNXV1Wx6oHabkZmZOWnSJFdX1xs3bixbtsxshe22FhEdHa1Wq319fT09PceNG8c8Njo6OjQ01NXVtbKy0mjPA5Xq8ZYtyT5D56hUotLblSMDAADlgJsQ4H04KdzH0w0AWsdGB8Usoms2rRYAWCxWampqdXV1dHQ0fsZ6dzbBFis/pJ4CAG/2b57EaPuZoRucBJ4ZmuufGQpL1ehjVJBPR2voov/DjboStDFq0Ev40eox0A9W35v17/U2jB8/3qgl/daAGYPp51gV6QwF3TM7E9l/ojsbBcymw/+RJIkClhv18kYBwulK0IA4JSXFx8dn3bp1Rof8NqgiSZ1O5+3tbWp6bk1LTAMUtlWh0amZ8cKZZZih2Zn76bjm9J4Ber1+899RJocmb2+f//kf39dfQ9HT6VNrSf3cLEUtoQeA10cO2Rr7iv5ZI9OOllmtRCIZM2YMfa8wtnutwFxSeRTCy3Y2ivOyFKO4nh+9FeTv7X67umH/pYp7GuJwUkRXOoFnhubTZbWP6n/LkRwW4P3yMK/OtbBz8VtbWlsOle1/1tw4xI3zbuBc/ID15Di7c1FiUYQ3ZLnXu5i2xE7CkkokEo1Gs2HDBj8/P5RhOioqKiMjo7e6LByqFYOxX/GARqv0Rzop/bFjx3ol+o3jdhnIsezUqVM8Hi83N7fvGfEjJwc6k4Nf+hdtjbSY+oFOIWf6CyqRSK5du2Y2xxPGRuKBmfipoKAgJiYGAHJycmzkFlla07D6iLK05rkhdcgwz81zRSHtDfQtdwLHb6uZygEA5gl9Bw3sfKTUTugHdWP18Qd5APDOiFk8d74DPQk3x4w13Tn21s0+Lx7sJDeF2ZaYndbplYYlJibSuWJlMtnatWt7a+UBiwcMprdwtrIcM2LjzJkzc3NzCwsLm5qa8B3sENnZ2WlpaUql8urVq31POTz9Pq989mykHLw/mB+QvdPCGIvDditcNuXNIA4AXCjTJuX8oiWNI2l6e3tnZ2dj5dDDINs29HwmJCTIZLLMzEypVGqj04UM8zqcFHFmxdS9H75x8dNph5MiQjq7RPBcwRqajZQDANyoaehKnZ2wX7pQcw4ABrq4Dx3I64dPUbvpaEzzzBglxjHNigNWZ6dBMzVOTk6hoaHItMb0WIqi6KwyKSkpAPDpp5+iIanT79OAmKa1Mc2lgxq/ceNG5knNZqpp68KZx5q2hF78Nzq12fPajsDAwJMnTxIEgZz3MjIysM0SBoPFg3lMlxdQf9EJi/x+DpvNDgwM7Hu9bStFVW/a9HDFCvRx+Oef89escWpvVYrl4pwlfZXWD3OzFEb6AYWKx8qhh7lx4wbygSkpKamurl67di2Kn9sDVtcebiydnjKVkR3C0GJmMvIZ1VUnig7pBzqxw+ghY52dnO3zi745ZqzZvw4Vbqs8wkI6mrbyzKDEODExMV3JTkPXk5iYOH/+fLPHnjhxQq1Wo8AMa9euBYC0tDR44fZjdFKjtDZGuXSY5yUIYt68eZs3bwaAuLi4rKwsOlONTCYDAAuXQB9rtiWoMW2dmnle2yGXyzUaDZvNjoiIYLPZKpXKHqy8MBhMD2PVqh9OSo+xAKXVVi3/BDk5uAwdGrB798DRIR04vLkl+6eyL0/fAwAfT7echDe7McA/pkOvFRqvaDQaHo9XXl6+devW06dPo9fcycnJRj5OZ0s1GT+WltYQM8bx/xEberZUs+67a6c/mdrpTqCltfXAlSojtTA5yGeUTzeo0A7ZLxGGhgEuA+02sbTlcb/1mLVoQoY3BEGw2WyFQhEbG/vo0SMA2LhxY21tbVxcXGRkZE5ODgDcvXt3/fr1BoOhsrJSIBCo1Woul1tQULB69Wr07CHbudbWVoVCYXqU6dwWOjV6XJENnlqtLi0tNTq2uLh44sSJMpksLi4OpcExa7bEbLzpHnobHYsaz6zH19f30KFDYWFhrq6uSqWyvr7e8oXTjTdqCXrgTU99/vx5s+e1Bczv9PnroNHweDx0djwSwGD6D1Z5LKCk9PRHPp8fFxf30Ucf4duH0VdWqd5/3xonhzYfQRfnpKhgAPjy9L1aQv9Oxtm9H74xIcAb39vegsvlojwPAICCM9o0pkrGj6XzJvqP9R20/1IFAISP8qkl9FV1jZ3WkM5OTqHDB1+sqKP3DGQ5Czge3XNzOpL/wdPVq58/SxbS0dBl6Dwz9OPXVm1WZqdhnnrAgAFo/sv02JCQELVafeDAgdjYWB6P19ZcmOW0NiiXDvPdMTo8KSlpx44dT58+5fP5QqGwoKCgExfe7ql7ZuxeVVUFv4+dQMfqwMZLGAwWD8agpPT4ZmGMIM6cefDXRWjb+4P5w1audOqsA31SVHAAx2PVkRIAWPDVJawfepeTJ09qNBoPDw80UPDy8srJybGF/VhpTUNpDRH32oia+iZaTHa92peHeY0Y4n69uv4Z1TJiiLuA4+H8eyt2m+qHZ1TjQJYDrJ615QPdAw7TU6ZMAQChUCgUCgEAWcIw7WCnTJmiVCoVCsX48eNp2x6zRykUCj8/P9M1sQMHDiQnJ1+8eJHP59PGosxjAcDb2zs5OXnWrFkCgYCiKH9/f/Qv5lAYtaSkpEQoFCIDJLRHpVL5+/vv2rUrLi7OUs+WlMTj8a5fv75mzRprLhxhtiUdPXW3Q4dqpe82DtWKwWDxYAbLVs7+/v69Em0J0+u0UtTjf/0L2W8AwPDPPx/8x1ldrDNGNHz4EPcFX11C+mFx1Ci0IoHpFZgDAhQpwZqj6GDEVp7F39sdAPTNLc3NFJqhKK1pAICuZ5j2GsB6cyTHVjfHon44UXnsWXNj+LC3/D0D8INkFjrPDACo1WoAYNoFASMrTnV1tUgk4vP5bR21ePHilStXmj6fubm5mzZtAoDdu3ebPTY9PV0qlcbHx+/fvz8zMxM9tJmZmWhqn54vo/PP8Hg8pVKJrKFQLp3q6mqxWJydnW35PRKJREql8r333rPmwp//MLNYpi0BRhofa05ti28tPj4+MTGRGapVJpNhtzQMpr/Rjsmgk8XpOittoC2PJ0wzErTfaGzp2Ku06HQPliR32snBMr9W1CH9AABYP/RoX9BGngcz72xzC5gsEVAUdfDgweXLlwPAoUOHkBE5k+3bt2dnZyuVyvj4eKaT5Yr/vVJRUXHx6J4Bo9/69E+vfVfhIh47rN3v3R46AbP+D3VN2u/vHwGASH5U0KD++/RamRiHmWfGKDFOW1lxmEeRJBkcHGwUkI2uB83QG/30MM+o0WhIkjQqY5qfhz6QmX/G6JfL6HqZNZAkqdFojCps68Lb2mbO9zNPbeG8tgCHasVgMO2LB3rlITExUa1Wr1y5Mjw8PC8vLzs725o8D5bHEyRJzpkzB3VDfD5/zZo1KKgL7jLsma47ObQLMwWENCzgk+jR3WLKgum6eKCaW364Xv35idsAsDVuPNO0bOPGjVlZWSdOnCgpKZFKpQeO5v/3ry4AULLhbVo8cDicLVu2vPLKK0zxsDL170cfuLn5v4I+RgxrSVswjcN2c4hOwFQ/nH30H1VDGQDEB//Zbl2lHQJrsuJ0Yu4J03VIkrxy5cr48eN7d80BjwQwGDsVD7SEoINXMPcwoy6YxWg8kZ+fP3PmzN9+dzWarKysP/3pT3w+/8CBA0uXLrVyKQN3Gb1FNzo5WK8f2kohh+l58ZB1+u6Byw92fvDanZqGVUdKdkgmTg55Pm4LDQ1duXIlGvBJJJKakDnNntxaQk+LB+aIkCke0IFzYuNuVzdsWZ3y8uhga7KJ208noN23r+azTUg/BBw9dFD7PQCMGfLKG7xJ+KHq4ggVuQRgbYDBIwEMxq6wakDW0NAAv7eBRts6nc7ygYcPH05PTxcKhRKJJD4+/vLly8z/crncdevWCYVCLpeL1hzy8vLwV2KftFKUZscOWjkMW7vGmkwOnYbDdiuQvcVMIafTU/hb6HUKb9asiB4dMswrRjR8xjj+9YdP6XGeUqlEPqAAwJ34tvqZ88dvBVkzQEQHerixJgR4R0564/Dhw451Tzjz54+U5wBA8+PH5ZFRnjeqAOClwaPx09JF+mpWHEdXdAUFBXTKPISVGWAoikKmaBgMpl+IB6FQKBKJEhMTS0pKSJJUKBSJiYkikchyt240nggPD7cwLEDhJoKCgvBXYoe06HQViR/T5hkj5Tmc+fNtfVIPNxYzhVxY2o/CDT8w//D30mNIJBJfX99/75OX1hAvvUj/PH7EkMKbNcz318vLCwC0pP4/BP/OnhWD3ds32qmuUbsOHqaDgVV1jVV1jc5eQ2/erzEVihRFOf0eu7o/HhMnIv0AAGNXfcu/0+A9gIMfG0zfY86cOQkJCQAQHx8vFosBQCwWtyvwKIqSy+UjRowYMWKEQqGwMAyww7cbg8GYYu3M8b59++bPn4/yzgKASCTat2+f5UOY4wkA4HA4SqWyrZ5FLBaLxWKmURPzv66u2HS412A6OQwICQn4955ud3Jo8+l0cc6SvvrFids5FyvwF9GLLFmyZMyYMf+zYye8vZrt9rzTGOzuWlrzPPsvGj2gJcqVh6++NqTRmT/IKl06cNDo//P1R4fLAMoAAMB79P/5OiztxzeDOFNH8yRhI58/CSyWkX2CHeqHQXu21S+UAcCI5Tt1vlM8Jk7ETw6mL6HRaAoLCwmCyM3N1Wq1ycnJKFEdSqZhgbS0NNqAOTIy0siAmTlJwefzq6ur8a3GYOwca+3IhULh1atX1Wp1UVERQRBXr16llxTagjmeoCWHWW0wY8YMtVp99OhR8yNIFqv19+Cvrccgzpy5JxYj5TAoJkZw5HCPKQdaP6yaMRZ/ET0Gc3afJEm0MyIiYt26dRfOFAIAyVgWCBnmiTbYbLZIJCopKfm1ou5CmfbplRNhf5hRodUBQFVdI4qmhIvnAAAgAElEQVTOZBbBMG9Q3+G6UX+fKzycFO6rvujW0iQNC5gY4L352C0UttVRqBrlefPv76Pt+xKprrgYP06YvkRpaSm8SBJ37tw5AAgLC6uurq6srLR8oGUDZoRcLr927RrKhoHBYPqIeKD1QEREhJUBFujxBPqYl5cXFRVlVjlcu3ZNqVTiWNF2hamTg1/6F044rUef/95bWwmCKC8vb21tNXolPdxYIcM877wY0J8p1bwe+JuSjIqK2rJly9W7DwDgTuDs84Onfnn6HgC8k3H28+07AYAkSZVKpdFoNBoN2gCAmvom4L30+ND6Vwbp7/7yU8n/y5KOYR2/Xp0UFTxjHP/HF2ZRDsEbvElTZyx13/U/WD9g+iR+fn7oVzs8PPzUqVMlJSUHDx6E9pLEWWPArNFopFLpiRMnOBxs74fBOADtjAXlcvnIkSPHjx+fm5tr+t/Zs2dbHvGj8UR4ePiNGzdOnTqFkvVs374dAJKTk5FyKCwszM/PJ0mSJEkcWKN30RUX1x87Rj2u9YyMePJ9XuOFCwDgMnSo/7YMbIPRf9BoNAKBQCQSbd68OTo6mhmO+fVAzleK8vEjvO9piEsq7cZ3xz3vKC7enxCb7OPjs3BaKJ/PT09Pj4uL++GGetWREmHp1yUAAItyc3OlUikqLxAIULYHtI4xZ/YcgUCADgyZ9Maer3+hmlumhHDPlGoc69Z5D+B4R87QyYfdl0iRfhgpz8HvDqZvEBgYGB8fj1JJTJ06FZkStJskzhoDZolEIpPJhEIhPdtoCjZgxmDsh/aTxMXHx6elpQkEAtP/thtZlSTJ9PT09evX0+MJFotFx2pE8V6Z5Y2yR1loFTZe6nboiJNMetjJoS3Mukcz44RiuqEvYIRqVSgUO3bs2L9/PwCkpqYuWLAAvek6PfX1OdWXp+/5eLqtiB799it8FEL3vw5dBYB/xIaSJDlgwACkN/KVD1cdKfnPkokAwOVyUeRN+nT0TMG8LMUorqf0NV9fb8+qp02f5d9ASeKyTt8tf0z+IzbUETsBXXEx0g8AgPUDpq/OMkB7yw5oGODp6UkvPsjl8i1btly9epUuoFAoIiMjlUqll5fX3r17169fX15ebprdD48EMBiHEQ9t9QXwwvDRyvL0eILZ46B0mMySVq484C6j22mlqFvjjJ1Y3F9/feSer+zBVKmt2Eo4BbWNxAP95u7Zs2fTpk3V1dVisXjDhg0oz6NOT7m5ODMzb2hJPQAYZXbT6ak60uDn7W75vL9W1H2Wf4P2vX4ziJPx/gQPN9bZUs0ormdbh9tVJ1BJVBQ/vjyOIwr0CnJ2csb6AYNhYpQEhsvlZmRk0P+Vy+X0miSNNUmf8EgAg7Fr8YBmDtDLXFBQEBMTAwA5OTmoL+iVUQ7uMroXZvY3mkExMX7pX9hha0trGj7+5jJKIYf1g+3EAwCoVCo0F4g+ikSitnL9dg4tqT9/73GMaLiW1N+vJUfzvTzcWA7XCXynOvJErx3o4h4bFE+LB6wfMBhESkrK6dOnc3Nzb9y4kZCQsHv37pkzZ9IGzMySSEhY+WrjkQAG01tY5TCN1grQiCEhIUEmk2VmZppOFWAclBad7unx46b73YIE9tngkGFeR5IifDzdAODL0/eyTt/FX2L3QlFUQUFBaGioQCA4fPhwTk4OQRBqtZrH423durUbT3S/llx1pAQAOGy3CQHeVioH+xLehoYnei0AiDjjmcoBfp//AftPY/otaWlp8+bNEwgECQkJ6enp0dHRAHDu3DkUsgmDwTgcVgn3goKC1atXX716taSkRCQSqdVqLpfr5ORkzcKiTRqN5xu6iVaKqj92/OGKFWb/+9I5BcuOY19oSf3cLAVaf5CGBXwSPZppSIPpxGsFAK2trRqNhsfjAYBMJvvoo4+YQZnlcnleXp41jknWf4lTPj+198M3JgR4O2gncEl9/taT6wAQH/xnV2czDp14/QGDgbYNmI3KaDQaK8cVeCSAwdi1eECDifLy8q1bt54+fRq5OmHx4OjoiosrZSkohwMAeIrFzVptY3ExALj4+AxbtWrwH2fZ+SUw9cObQZws6atYP3SLeDhw4MDChQt7IHqyTk+lfPvrhTKtNCxA6DeY3j91DM/yKoSddAKGFsP+u18DQKBX0GTfP1h417B+wGDwSACD6RtYZSTA5XLFYjGKjFRUVAQAKJ4aDqvqoOgrqx797W+68+fRxwEhIfwN69GAhtJqW3SNbv5+DnEhHLZbgewtNPq8UKZNyvkF64euw+VyORyOTqejxYNKpTp37pwtfJzqSMOFMi0AGCURP54y2SFMmB4Q99GGkDPeQjFkv4Tjt2IwGAymL0h364W7RqPx8PBA4wnbDSbwfINNadHpHv1tXX1+PvroMnTosJUrB814x6Gzv1HNLUk5v6AxKF5/6MprBQCtra0ohjJBELR4QGuPyF7RflprD50AcpUe4sZ5N3Buu4Xx+gMGg0cCGEwfoANjLC6Xq9PpFAoF2p4+fTq+fQ5EK0Vp9+27PfFVWjkMXZr80ulTg/84y9HzRrNcnLOkr74ZxAGAC2Xa93aeR5FDMZ2jqqoKfh+LGWkGFKPZRmhJ/a8VdQCg01OO8vWpG6uRq/Q4jsia8th/GoPBYDD9SDyg0Cs8Hm/Hjh0AcObMGZRdEuMQEGfO3ImaSueAGxQT89I5BXfJEkeXDWb1Q2kNMTdLgfVDpxk/fjwAqFQqeo9NzRTPlmrmZSmmfH5q/6UKALisqpubpXCIGzV0IO+dEbN8PYaP8Bxp5SFYP2AwGAzG0bF21S80NDQxMXHChAk7duyQy+UoUTx2mLZ/9JVVlYsXN5WWoo8DQkKGf/75wNEhffV6s07f/fL0PQDw8XQ7khRhlLYMY/m1ghd5HiQSiUaj2bBhg5+f340bN1avXh0VFcXM69SNzMtSzJvoP9Z30P5LFf+IDaWaWyb898njKZMtZ5dz6E6gn9gv3Rwz1nTn2Fs38SVg8EgAg3ForFp5KCkpUSqVixYt8vN77kfL6isz1n2YFp2uavkn98RipBxchg4d/vnnQd/l9mHlAABJUcGLo0YBQC2hx+sPnSYtLQ0AIiMjBQJBTExMVFTU2rVrbXGi0pqG0hoi7rURPK+Bz/uWfuCvgtcfMBgMBuO4WKUBgoKCAKCpqYkpJwDA398f30E7pJWi6r79ljZSAoChS5OH/vWvTv1D8qGE01+evldLdDKHACYwMPDkyZMkSV65cmX8+PG2i9nq7+0OAPrmFqacAIBhgwbYtTJvbSmqPj1myMtDB/KMEsN1SD/0w/hL+soq/H5hMBiMQ2Ptqh8KrDRr1qw9e/Zs2LBh8eLF8+bNW7duXe80Gi9Wtg1x5szDNWvp7A2DYmKGrfnUnnO92Qj5xfubj91C21g/WPlawQuzpZ7kvw5dBYApIdyjV6oWRwV/ln9DPHYYUoB22wmoG6uPP8gDgHdGzOK58ztdT1+yX2qlKEN1DaWuMVQ9bFRebdbW0bEZ+hjYbMl+uiw8EsBg7Fo8qFSqxMTEwsJC9FEmk61du7a34jbiLsMs/c29oV1+rahb8NUlrB86IR5Ikjxz5szWrVvpVx4AbOTjVFXXuOH7ayjSLgBIwwI+njyqXWeV3u0ETlYWPNI9HOjiHhsU37mVB4fWD/1HJ2DxgMUDBoPppHjQaDQnT56USCQ9YMaAu4xOYDZ7g/3nh+5h/bBDMnFyCE5raJV4mD59+rVr18aNG8flcjUaTWFhoVgsPnr0qO1efJ2eul3dMJrvZWVuuF7sBAhDw5HyAwAQ6jMx1Kcbxvr2rB9adDpKW6e/d7e5voE4fRoArNQJg2JizJYcxZCj9s89sdh05+jiX5w9PHCPgcUDBoPFgyUUCkVkZKT9vKW4y6Dp5+4NHdUPi6NGtWsPg8UDSglHEERubq5Wq01OTlYoFLGxsQ8ePLBFpAQkGy6U1ZY//i2PxKoZYy0vPvRiJ3C1tvhqbTEAxAVJB7Lcu+cm2IF+MNIJlFZLJ6G3gMvQoeywMLcggVvAyAEhIc5stit/GOp/+mq0JZehQ4O+y+2HtqBYPGAwmA6IBzSYKCoqioiIwF2G/YDdG6yktKbh428u1xJ6rB+sEQ/0ZIFcLs/Ly7N1aOZ5WYrSGuLNII63h5v9i4eW1pZ9d74CgECvoMm+f+hOEdWD+qG7dIKbv1+/mqmp2bKl7pt96Fb4b8vAOcLxSACDweKhTUiSnDNnTmFhoUwmCwsLo/fPnj27V+yXcJeB3Rs6ipbUz81SYP1gjXhQqVQCgcBgMFRWVk6aNOnEiRMlJSVSqZQgiG5/39G60JkVUzuakaO3OoGy+rtF1aehy67SPaYfsE7oXjQ7djzO3I62h3/+ObYOxeIBg+mHWGWEgIyeAWDbtm3M/eXl5b3r/NAPwe4NnYPDdjuSFIH0w5en7z1tNHwSPbo/pBToBIGBgfHx8ZWVlYGBgVOnTkW55GUymS1edpTeYaCrw3wR17RKABjo4t7tygG6HL8V64QegLtkCXvSJPQdPVyxQl9xn7tkCb4tGAymf0l3RxTu/XO+Abs3dB3m+sObQZws6atYPzBfK3jh84ACJNBzBwBgu9BqiXt/HsX1nDvRP2SYl/13AmX1d69plSGDR4/xfsVGp2CuPxhBOwxgndC7PLtdWpGQgExGPSZNCsjeifthPBLAYLB4wF2GfYHdG7ptZKanUr79FQUGxfrBrHjo4QAJ+cqHq46UGO08njLZz9u933YCbemHQTExWCfYCZRWW/bubFo/+KV/gTtkPBLAYLB4wF2GXYDdG7r/V7+5JSnnF6wf2hIPPRkgQUvqp3x+asY4/izR8FFcT3r/sEEDLH8pfb4TMBvnB+sEu6KVoioSP0ZaDodgwiMBDAaLB9xl9D7YvaFn9EPIMM/sBa931GG3D4uHngyQUFrTMC/r3K9/m95R/dbznYC6sRoAbOHqYL14wDrBDvUDHYIJHD9NOB4JYDAYLB4c+AcJuzf0pH7w8XQ7khTRz/WDUbQl0wK2CNWKVh7aNVKyh07g4L2cZ82N3R6htUPiAec2tk+0+/bR3TUOwYRHAhgMFg+4y+hpsHtDT5J1+u6Xp+9h/QC/zzDdY9AuKNKwAKHfYHr/1DE8y6mme7gTUDdWH3+QBwB/GB7t7xmAxQPG+ElmuKnguR48EsBgsHjAXUYPgd0bsH6wB/FAUVRlZaVpAX9//27PMF1V1/hOxlnT/fbmMH2ysuCR7iEAzH/pQ2ennvCQweLBETtw1fvv4xBMeCSAwWDxgLuMngC7N9iJfgCAvR++MSHAuz+Lh540W3KITuAZ1XiwLAcAQn0mhvpgi3ZMm1BabcVfFqIJoAEhIQH/3oMXjfFIAIPB4gF3Gd0jFVqePUM/Kti9wU6QX7y/+dit/qwf2lp5uHHjxurVq3k83rFjx1h281j2ZCdwtbb4am0xAMwVvOfp6oVfFowFjEIwBX77LXZqxyMBDAaLB9xldB5Kq63bv/9x5nYAGBASMuT99x5/mYXdG+yEXyvqFnx1qd/qB6Z4MBIJaC2CIAj7ySjfY51AS2vLobL9z5obfT2GT/efiV8TjDX64fG//oX6ecAhmPBIAIPB4gF3GV2havkntG0SE+zeYIf6YYdk4uQQbj/qC9p2mCZJ0tPTs3+aLVUSFf95eAIA3hkxq8fitGL6AMwQTMPWruHMn4/vCR4JYDBYPOAuo2NQWu2dcOOsW04eHr6pqdi9wT71w+KoUUlRwf1NPJAkmZuby/zXli1bAODq1av9sBOoJCrO1fwEALFB8T3jKo3pM+AQTHgkgMFg8YC7jC6hr6y6JxYb7fSaMcN/6//gB9GuKK1p+Piby7WEvl/ph7Ycpvl8flxc3EcffSQUCvttJ/CMahzIcsevBqajUFpt2buzcQgmPBLAYLB4wF1GZ2jR6W5PfNVoJ84oZJ9oSf3cLEW/0g+9kucBjxsw/UE/VC3/BLlQ4xBMuBPAYPoAeBW+56jds8dojwuH4zXtD/jO2CEcttuRpAgfTzcA+PL0vb8fu0k1t/Sfy5fL5RqNhv6oUqnkcnl/ewYMLQbC0IDfBUwXYXE4Adk7PSZNAoCm0tKyd2c/u12KbwsGg3Fg6Y5XHnoG2nnOefBglo9P85Mn3lKJz8KFzh4e+Cm032+Nsf7wZhAnS/oqy6XP6m0jsyVmbCWNRsPj8dRqNZfL7T+dQFn93aLq00PcODMC/ujq7IpfB0wX0ezYgUMw9fORAAbTN+iJkRBFURRF9ee7rCsuRsrBZejQUccKRhXkh5xTcJcswcrBzuGw3Qpkb70ZxAGAC2XapJxf+sP6Q1VVFQAwo7IizUCSZNdfdgfqDa5plWgDKwdMt8BdsmT455+j7fsSqWbHDnxPMBgMFg9mBgpyuXzEiBEjRoxQKBSmBbZv3x4aGurk5CSRSPqwcqADbgR9l4utXR0LDzdWlvTVfqUfxo8fDwAqlYreU1JSQkuITr/sbRWQSCRODJjn7UXUjdVP9FoAGMcR4bcA010M/uOskfIctP04c3v1pk2t/XtmDYPBYPFgTFpa2vLly0+cOJGenh4ZGVlQUGBaZuXKlSJRn/15ZiqHkfIcrBwcEZaLM1M/vLfzvJbU9+HrZbPZ8fHxiYmJCoVCpVIVFBTMnz9fJpNZzhDX7stuoUBqamr5C/z9/e3hJtx6cgNtjPAciV8BTHfOR0yc+NI5hcvQoQBQ982+isSPsX7AYDBYPPzG4cOH09PThUKhRCKJj4+/fPmyUYHk5GSJRPLKK6/0yZv77HYpUzlgC9e+oR9Ka4i5WYq+rR/S0tIAIDIyUiAQxMTEREVFrV27tosvu4UCwcHBgS9g2UEgS0OLQdVQBgChPhOxzRKm+/sTDifou1zkQq07f/5O1FRKq8W3BYPBYPEAJEkqlUo6Nnx4ePjhw4f7z52ltNqKhASsHPqYflgcNQoAagl939YPgYGBJ0+eJAiiqKiIIIiMjAzLNkvtvuyWC0ilUicnp5SUFLP2Tj3PjboStDFq0Ev4ycfYSD8EZO8cFBMDAM2PH+MQTBgMBosHAAAU6tHLywt95HA4SqWy/ygHOjHQiH/9EyuHPqMfkqKC+4l+AAA2mx0REWFqrUQ1txg5fhi97EO8Odfv3reyN5g1a5ZSqSwqKtJoNJGRkWZ9HiiKcvo9trvqltaW209uAsAQN46nqxd+7DE2wonF8kv/YujSZKQfymfPJs6cwbcFg8H0a/GApiobGn4LlN4534aeHDd0u3IYujTZc8oU/Jz1JYz0w68VdX3vGtvK80A1t+QrH4q3nhFvPcO8cPpl1+mpxL0/b7njM3bFgagvTskv3m+3N5BIJEKhMCIiQi6X8/n8vXv3mpFtLFbr77Hdteubm541NwLAxKGv4acdY2u4S5aM+Nc/0faDvy7CIZgwGIz9Y0PzYjabLRKJSkpKkK1CXl5eVFRUZ5rIYhmNFexZP7TodEzlwF2yBD9kfVI/AMCXp+/VEvoFX10yLVCy4W3HvTqVSiWVSgmCYL7LUql0+vTph64/PXD5wc4PXrtT07Dgq0s7JBMnh3CZL7tf0OiJAd61/9kzbAj7rRnJm4/dmhLC8/N2t7I3GDduXG1tbe9e/kCW+/yXPnxIVg5n++NHHdMDeE6ZMlKeUylLaX78+HHmdn1Z+fAtf3eyA+cfDAaDMYttHaajoqK2bNmCAracOnXq7bffBoDt27dv3/48UQ5JkiqVSqPRaDQatOHQd7OVoh4sScbKoZ/oh70fvtEnL81CnofCmzUrokeHDPOKEQ2fMY5//eFTo5e9XvNwpK70/A//74/RUyVhIwHgv3cdQu+72d6AJEmFQkFRFEmSBQUFhYWFcXFxvd8tOjn7ewY4Oznj5xzTM3hMnBj0XS4KwVSfn1+R+HGLTtfHrtFyjheKohx9AIDBYPHQPaSlpc2bN08gECQkJKSnp0dHRwPAuXPnzp07hwrk5uYKBILCwsLCwkKBQJCSkuLQyqEi8WPd+fMA4P3BfKwc+jwTArz7pH5oK8+D52BOaQ3x0rDnbgDjRwwpvFlj4WVHDiGVpUr0vpvtDZCfg6urq6enZ0JCQmpqakRERC9ee0trC36wMb0Ci8MJPvEDHYLpbvTbfSYEk+UkMCRJTp8+3dXVlcfj+fr60nOLGAzGbumJ7O4kSQ4YMICOwIhmF+i5TOZkA5vNthzU5Xmj7S8pPVM5eEyaFJC9Ey869xOEG34w3emIZkum1oAnT54MDg6+cePG6tWro6Ki/mvD39/JOHs8ZbKftzsA5CsfrjpSYnSl9MtONbe8t/M8h+2WNiMQGAnmjHoDNLCorKwEgMDAwA61tts7gZbWln13vgr0Cpo49HXsKo3prZ+ShytX1efnA4DL0KH+2zL6QLyNjRs3ZmVlnThxoqSkRCqV5ufnz5w5k/6vRqPJysr605/+xOfzDxw4sHTp0vLycmt6AzscCdhOfVVWVnaoh+xKhSqVqhvPhemT9MS6PJvNZo4VuFwuPZJgs9mBDKxRDvYJVg6YPjJ2aW1tbW0tLy8Xi8XTp09n5nnwZrsCAKn/zfAgZJin2Zedam5JyvmlltRnvD+B+b6b9gYAwGKx0Ovf69f+kKwEAFVDmY4i8ZOA6R0N//sQTPcl0j4QgslyEhgul7tu3TqhUMjlcpOTkwEgLy/P1k3SV1Y50A2srKwUCAQ9VmH3nguDxQPGPJodO7BywDCpqmt06PabzfPg4cYKGeZ5p+Z5xKQzpZrXA81kTEfK4Y6aOJIU4eHmSO9C8ePLADDQxZ3nzsfPMKYX4S5ZMlKeg7YdPQRThzI+IUuEoKAg27Xn6fd5Ze/OvicWl0ZEavftw+m9MRgsHnpHOTzO3A4AA0JCsHLAIN7JOHu21IGd/5D78pw5cyIjIz09PVGIZJVK9Xog5ytFeVVd49lSzSWVNnzUUFRefvE+isqKlMOFMu3Gd8c16pur6hodJRVGXZP2iV4LACLOePwAY3odj4kTBbnPXagfZ26vWv6Jgw5zrc/4RFGUWCwWi8VMoybmf7setF1XXPxwxYqm0lIAaK6trflsU92333aoBpVK5eTkJJFInJycfH19S0pKpk+fjvaQ5PMVS+ZOlUrFPATFvJbL5b6+vk5OTqiY6SHP+9UXxRITEzvajIKCgtDQUCcnp40bN9LG4WYrNHtqDAaLh55QDi5Dhwb8ew9WDv2Qkg1vM/9WzxiD9i+RF//92E2jZGqOwpw5cxISEgAgPj5eLBYDgFgs5nK5smkviccOeyfj7Lrvrq2IHh0+ygeVv/LgyZUHTwCgpr7pQpkWXf47GWffyTj792M3HeKS7zy9jTZGDQ7BTzXGHhg4OsQoBJMjulBbmfGJoqgZM2ao1eqjR4+aradDyV5ujhlr9u++RGpUsuazTW0VtlD/mDFjCIKIi4sTiUQLFy4kCOL69etXrlxBFyISiZYtW2YwGMLDw7du3UrfB3QISZJSqfTQoUN0OGyzh5gWs74ZFEXFxMRs3ryZIIhbt25lZWW1VWFbrcVgLOOQ/kZ24ib19Pu8hytWIOUQ9F0ui8PBzxMGAEprGj7+5nItoQeAN4M4W+aFcthuDvFaAUBra6tGo+HxeARB5ObmarXa5ORkhUIRGxv74MED5K6g01NuLs4sl9+mHtDyAoftRjW31NQ3Mat1d3OxxeV3bydgaDHsv/s1AIwZ8sobvEn4GcbYD8xoHA76WxMaGrpy5UqJRAIAEomEy+VmZGSYKodr164plUrrXR8tdAKWh/5WMvaWmYkPlUolEAgIgmCz2ahjfPToEQBs3LixtrY2IyNDoVBERkbm5OQAwN27d9evX3/nzp2XXnpJrVajSysoKFi9evXVq1fRdkxMTFFRkdEhBoPh4sWLixcvZhZjXqzlZsTFxdF76P8qFArTCk1bazAYXF1d+4knOqbT4JWHToJWP7FywJgSMszrSFLEm0EcALhQpp2bpSitaXAk8VNaCi/yPKAoq2FhYdXV1SgmEgB4uLGYygHJBqQQWC7Oft7uzD+HEE73npaijZcGj8YPMMa+VD2LFZC90/uD+QDQ/PjxnfAIXXGxY12C5YxPSDkUFhbu3r2bTv1k51eEukc/P7+pU6eiPcHBwajZT5/+lv0mODg4JydHr9cDI+KcKaaHNDU1MXd2tBlPnz7l8Xhoz6BBg0zPYvnU+KXDtAs2s+mkcqBXPwO//RYrB4wRHLZblvTVL07czrlYUUvo52WdWz1jDEqaZv/4+fmhX/Tw8PDly5eXlJSgPA+OGwytXZTaKwAwxI3jPQC/yxh71A/8NWtchgxBVrL3JdLhn38++I+zHKX9aWlp6enpAoGAz+czMz4BQHJycmVlZWFhIQDExMSg8vHx8cg3oNOYXTQAAH1l1T2xmLlnxL/+6TllSjde7JQpUwBAKBQiH3GNRkP7QtAFlEqlQqEYP348MhMyPYTNZqNiKpXK399/3759HW0DfeyuXbtQ5k2zFZo9NX7jMFg82FY5jJTnuPn74XuCMfNquTivmjE2fNTQJfJiANh87NaVB0/S/iQ0mrO3QwIDA+Pj41EU8KlTpyIDZZlM1od/VP4kiHtA3Pd09cTPLcZu4S5Zwp40Cf36PFyxQl9x31FSkbLZ7HXr1i1fvpyZ44W2XPL39y8vLzcqb6OWuPn7jSos1GzdWp+f7zFpEndpcren0WCz2fn5+fPnzwcAtVoNAOfPnzcqkJOTExsbW11dLRKJ+Hy+6SGPHj1is9mpqakoaqr494LHmjZkZmZOmjSpurpaLBZnZ2ejnaYVmj01ftcw7c9oYJ+HDsGctxgpz+kD6XswtqaqrlG6+wJygQgZ5pm94HX7tOShfR6M9jOzOuJOAIPpXZ7dLq1ISGh+/Bj6fXDwXukEmOnVKIqqq6ujM97qdDpmP4kiFwUGBppmZKMoCgBYLFZKSoqPj8+6dV/r+ewAACAASURBVOuMDqFLomq9vb1Na2i3Gcz97VbIPDVOEofB4qFbew2ttuzd2ajXxsoBYz06PZXy7a8oDJGPp9vWuPETArwdRTzgTgCDsSsorbbiLwtRvFGPSZP80r/on6azjtsJIN/xU6dO8Xi83NxcPFLHYPHQd+cbGMrBsexNMXbxe9/ckv1T2Zen76GPi6NGJUUFY/HQ653A1dripuaml73Hebp64acU4yj0gRBM/Vk8kP+/vfMPbuLK9vwVSHawTAYLZCSwwSKEAYJlh5m8hF/BDLIzNuxjNri8K8HzFpM4OzZGKReb3YRQSexKTHh5LgpsRjOTEPbxkCjYRzae9Y+B8TwgQU6ICQMSIYxDkMiYxEhgIKghYzV4/7ik09Nq/bAs6+f3UxQl3z7dfe7pe07f033vbYahswuSeCIZQPKAkPF3mcOkDbWJMtIUxBt//up65buf0N9PzFCY1vwkfqZApGDycG/o3r9f3Pfd3TvqjCnFOWVonyCx8oerv/0tnUJNUvJlOF4/AhArsFRrSDEamQOICI9Oyzr2wrKJmWmEkI8vDui2Hbt8/Q7MEiu+Zvq+u3uHEFIwEUMQQaJ1naVS5fr1kze/TP+8ZFgzMMw1eQAAAMnDaGUOX1U9h8wBRAqFPK2rbmnpPBUh5Jpn8OfbP/ig1w2zxIRTV08SQh4YO27SA9mwBkjIeLJ27XSLmf6+8vob7p07h1gWZgEAIHmIceZAx5U+uGIFMgcQEaRjx/xzecFLpbPpn+stp0xHL7B378Ey0cTjvXVjcIAQ8uMJc8ZIEAlBopIxf/5DXV1jJ00ihFxtbvmq6jnkDwAAJA+xzxwyFiyYsvVN2AREEMPj0/f88h/oEKZfH/2y2vzpADMIs0SNL7/9gv6Ym5UPa4CEJi1n6ozft6bPmkUIuf3RR46nV7MDAzALiDIsy9IlXwGSh9TlytatXOaQymtpg9Hj0WlZ71UvemKGghDy8cWBp03W3iu3YJYo4L3nPXPtFCEkb/wM2RgZDAISHalCoXnvYMaCBYSQv/X2XvzHVYN9l2GWxMLtdtNVXP1tlUgkLS0t8aCMKH19ffQjdADJQ6r68M6d1/9tLzIHMNoo5GmmNT9Z8/g0Qsg1z+BqU3e77WuYZbT5q+cS/TF7wlxYAyQHEql02tu/m7ShlhBy9+rVL3W626dOwSxC379x5/2z3+zu+er/nv3my2vMvXhar4lhmH379vnbajKZVCrVG2+8EQ/KACQPQCRzoOvfjZ00KXdnCzIHMKpIx455sXTOm0/fHzzz4nv2//nvZzAFYlSZkjG1YOJ8dcaU7HEqWAMkU/6gXL9+yltv0T+xBJOAK7f+1vWF+/odLyHkxh3vBxevOQZuD+sITqdTIpEYDAaJRFJQUGC322l5QUGBRCKRSCQNDQ30A9J8SYvFYrfbi4uLaYnT6aRbGxoa+MfZtGkTIYQeR3BelmVNJtOuXbv6+/u5k4rS0dFBlWloaHC73Q0NDc8//zwtl0gkbrebEKJWq61Wq6gOHL7KCOrIsiytkUQioafga1tcXFxcXMxi+g2ShxTMHGb8vnVMRgZsAqLACu2UPzz/JJ0C0Xm2/7/87iNMgRg9HpCOK5g4H992AEnJj/7TSv4STJ/PniP4l/QWuDc0tLvnK99/HeevCCQ/uHhNVDLw8ZVKpcfjqaqqWrt2LS3Zu3fv0NCQx+M5ePDgiRMnBJJPP/20Vqutq6vzer0LFy7ctm0bJ+DxeFavXr1lyxZCSGNjIyFkaGjI9/sV9JglJSVGo/Gdd97xpxjLsitWrNiyZYvH4zl//rzJZFq+fPmBAwcIIYcOHVKpVD09PW63u7+/v7CwUFQHDl9lBHU8fPiwy+Xyer1DQ0ObN2/+oRPldpeWliqVys7OTimevSJ5SAU8x47xM4cU/GYniCFTs8Z1GJfQKRC9VzxPm6x//uo6zAIAGC4Z8+c/3G2lSzClYs/G58l9ZKmrq5PL5evWrbPZbPRZ/rffftvQ0FBVVUUIoZ11yubNm+Vy+aeffkoIuXHjxoEDBwYGBnbs2EEfyVdXV8vl8srKyqADhHbu3FldXS2VSp999llud19OnDihUqnKysrkcvn69etNJlNhYWF/f7/b7T5w4EB1dfWhQ4d6enp0Op1cLqe7hK6DoI65ubk2m23jxo1Wq5X/qWytVrtkyRKLxYLMAclDSnD71Km//vdfIXMAsbzlp0lNa35SU/QQIeSaZ7Dy3U8sJy7BLBGETpX+jsW3+UCSI1UoZvy+FXYYDWjPOz09nRDCMIzb7V68ePFPf/rTxsbGRx55hKYTFNqrvnnzJlcyc+ZMs9k8ODjIbQ0KnX7w6quvSiQSrVZLCDl8+LCo5M2bN7Oz73+15sEHH6Sq6nS6119/neYJO3bsOHTo0KpVqwQaBsW3jvn5+S6X6+GHHy4vLy8oKOAk582b9+GHH2LAUpKHF5iAyxwuGdbQ39N27ULmAGLmk2PHVBfNfGTKj9ZbThFCtnSeP/IXl2nNT6RjkepHgC9v9p65durMtVMVM9Y8IB0Hg4Dkzh9Stu7rHpvmW3jl1t8EI5eenDHxoYny4R58//79tbW19DF/Xl5eR0eHVqstKytjGObIkSPLli0TyC9dupQQkp+fn5+fTzviDMP4HjYnJ4duFXToW1tbtVpta+v9VHDPnj0vvfRSWVmZ1WqdOnVqXl4e/0Q2m83pdObk5LzzzjsVFRWEkFWrVm3YsMFoNCqVSpVKtWPHDpvNFrSOAmV6enoEdWQYJisrq7a2duXKlRqNhssWOjs7S0tLS0tLMWwpiUF3RJg5TLeYH/jxLNgExJYnZymPvbCMToH4+OKAbtsxTIEYOfeG7tkGThNCJqQpkDkAkGpMHp9eNnuyRpFBCMkaJyubPTmMzIH25tVqdXl5+a5duwghJSUlLpdLrVZnZmbOmzfPV14ul7e3t69du7agoECtVtO3ByLJnlTa3NycnZ0tmDC9devWqqqqvO+prq6mw6Vqamq6u7sFJ2publ6wYIFMJjt37lxdXR2XutBEorq6mhAyZ07weS8CZXzr2NraKpPJDAaDRqNpbm7m8gSpVNrZ2UkIKS0txfuHZEUyFE/rlIWqtCSSarMDA18sXMRlDhnz56NZgDiBvXuv2vzpxxfvf+9pp2H+k7OUo+dWhJBECQjhBQHXnf4//LWNEPKzKSU5mdPQwEDSIzo9es75z5Oh+yKJQQfG6XRqNJqhoSH6dJ//ZN3pdNKH9Ldv31YqlSzL9vX18V8LUBlCSF5eHn+rQNJ3R9FzZWVlzZ49+8KFC9zshR9uHCx7/fp17vUFPSA9Ah1k5XteUW19ywV1pK9QON18DyhQGyB5SJKQwQ4MXPzHVXevXkXmAOIWy4lLWzrP0981RQ9VLZkxGkOYUiF5+GNfxze3v35g7LjyGfoxErx3BUgekDyEmTzEvPqCDAEAJA9RChn8zGHy5pcV36+5BkC88eevrtcdOH3NM0gIeWKGYvt/fTQjTRpxt0ru5MHjvfWeYz8hpGDi/IKJeEwAAJKHcLrsok/oAUgpUvfZGz9zmLShFpkDiGcenZb1XvWiWZMzCSEfXxwo2/Fh75VbMMuw+PLbL+iPH/9oDqwBAAgDqVSKzAGAFE0ehlj28sb/wWUOyvXr0RRAnKOQp+1/bsGax6cRQq55BlebutttX8MsIXJv6N6Za6cIIeqMKZgqDQAAACB5GF7m8FXVc7c/+giZA0gspGPHvFg6582n8+mfL75nf7Pzc/buPVgmKHeH7s6e8AghBAOWAAAAgJGQcnMe+JlDxoIF097+nQRLAYBEo/fKref+7SQ3BWLr6gKFPG3kbkWSfcK0955XNkaG9gNAMnRfJAnZgQEAyUOChQxkDiBpGGAG/9fBM3QV14mZadsqCh+dloXkAQCA5AHEBMwmTx1Sa9jS1d/+FpkDSA4U8jTTmp/UFD1ECLnmGax89xPLiUswiyiuO/3ee17YAQAQz7jdboPB4C9TohgMBqvVGltl/NHX16fRaHAdUyJ1T503D+6dO682tyBzAEnGB73u9ZZT9HfpPFXjf84P7ysQyfrmwXvPu+/CvxJCFquKZjw4Ew0GgCTpvoT7pcjTV0/13/l6QlrW/EmPxdXHIgN8REIikbS3t8+dO7etrW3Dhg0ej8f323BRUyaCu4AEJVXePHCZw9hJk6Y2/QsyB5A0PDlL+Yfnn5yYmUYI6Tzbr9t2bIAZhFk4vrzZS39kpStgDQBSGfqN+f47XxNCbgxe/4+vD1/89sJwu9T08b9EIikoKLDb7bS8oKCAvhloaGhgWVYgabFY7HZ7cXExLXE6nXRrQ0MD/zibNm0i379k8D313Llz8/Ly1q1bRwi5ePGiPw07OjqoMg0NDW63u6Gh4fnnn6flEonE7XYTQtRqtdVqFdWBw1cZQR1ZlqU1kkgk9BQcdFNxcTE1BUg+otGHpq0nwCfKgwpEMHOY8ftWqQJ9CJBUTM0a11W3tNr86ccXB655Bpe+dWTPL/9hhFMgouzsoxcEbAOnCSET0hRIHgBIEe4N3dv7xbuhSB7vP3q8/6hveeWsZwPspVQqPR7P7t27165de+bMGULI3r178/PzGYZZuHDh8uXLFy1axJccO3bsuHHj2tvbOzs7f/Ob32zbtq2uro4KeDyepqamLVu2WCyWxsbGffv2+XtyX1VVpVQqjxw5otfr58yZ4y/Arlixor29fenSpVVVVSaTafny5eXl5du3bz906JBKperp6Xnsscf6+/sLCwtpIiHQgTuUrzKCOt68edPlcnm9XqlUyh2KfD/eSalU7tmzR4oHtUnK6L55YFnWYrHk5ubm5uaKjtILKjBybp86hcwBJP9jgLFj3q58jE6BIIRUvvuJ6eiFaK7iGrazj2oQcN3p/+7uHULIPIUWjQSAVOnZSEa3b1NXVyeXy9etW2ez2Wi/+dtvv21oaKiqqiKEHDhwgJPcvHmzXC7/9NNPCSE3btw4cODAwMDAjh076OOS6upquVxeWVm5b9++oCddsmTJypUrq6urjxw50tfXJypz4sQJlUpVVlYml8vXr19vMpkKCwv7+/vdbveBAweqq6sPHTrU09Oj0+m4UU+h6yCoY25urs1m27hxo9VqVSqVnJhWq12yZInFYkHmkMxdjlE9emNjo8lkOnz4sN1uX7x4cXt7e1lZ2bAEwnzqcPv2jffeG7x0KW3GjCv1DcgcQIpQXTTziRkT6w6cvuYZ/PXRL3999EtfGftrT8WVs49SEPDe8355s/fzG5/RP/PGz0DzAABEBNrzTk9PJ4QwDEMIobGrsrJy06ZN/MfwtFd98+ZNrmTmzJlms3lwcJDbGiKVlZV0IaMPP/xwz549r7zyiq/MzZs3s7Oz6e8HH3yQqqrT6V5//XWaJ9Ctq1atEmgYFLfbLahjfn6+y+Xav39/eXl5dnY2fQNDCJk3b96HH37IsiySByQPYXLw4MGmpqb8/Pz8/Py2traTJ08KugVBBcLg5v9r+/qFFwSFOTu2I3MAqcCj07Leq15Utaen94onmucN29lHIwhc/PYCfyhCpnQ8GgYAKYXouCM654FfEt46Cvv376+traWP+fPy8jo6OrRabVlZGcMwR44cWbZsmUB+6dKlhBAa5WhHnKYcwo5KTg7dGqBD73a7z549S0c9Wa3WqVOn8pdGXbp0qc1mczqdOTk577zzTkVFBU0VNmzYYDQalUqlSqXasWOHzWYLWkeBMj09PYI6MgyTlZVVW1u7cuVKjUbDTW/o7OwsLS0tLS3t7OxE/pCsjOKrPYZhbDYbdRVCyMKFCw8ePDgsgfC48uabgpLJr76SMR+flQWpgkKetv+5BaXzVFE7Y9jOPkpB4KT7Y/6fHvbW1e9caBgApDjZ41Q/z12pGjeFEDIhLetnU0rCW4GttbVVrVaXl5fv2rWLEFJSUuJyudRqdWZm5rx583zl5XJ5e3v72rVrCwoK1Gq1Vis+ilIqlTY3N2dnZ4tOmNZoNBKJRKvVVlRUlJSUEEJqamq6u7sFJ2publ6wYIFMJjt37hzNMWjqQhOJ6upqQoi/KRMBlPGtY2trq0wmMxgMGo2mubmZyxOkUmlnZychpLS0FBOmk5VRTArpm7vx4+8/81MoFIJkN6gAhWVZmSzUj8IO9l2+e+2aoPDOyU+JXo+LDVLIsceO+efygs6z/dE5XdjOPhpBwOO99d3d7wSF52+cyx6nQsMAAPlDSe5I323+8Y9/pE/3aY9ZKpV+8803TqeTPqS/ffs2ISQnJ8fhcHC7lJWVlZWVOZ1OQkheXh7LstxWvmRtbe2vfvUr3ykNnAD3noFhGJfLxR+AxD/C9evXudcXc+bMcTgc9E3Cxo0bKysrqdr88wq09VXGt45KpbK4uJhhGG5iNHcQmj/4m5gBkDwEgrawW7ducSWCbDuoAJfFhn7SMRnjfAvHKrJwpQGIQ2cPPQgIViARfTJ3X1giEjEeGDsOlwkAECl8v6PMldAZEVKpNIAMf6tAMvCOHOnp6TabTfRrD1KplD/wiX9AuVzO7RJAB3/KCOqoVCr9ncjfAUFyMIrDluRyuVar5VYObmtrKyoqGpYAx9DfEygZUijSZ80SFD5YWoorDUAcOnvoQSB0HpCOm5AmfF6QNx7fPQUAjBTRJ/QxQZAhAJAkyQMhpKioaOvWrU6ns6Oj48iRI0899RQhpKWlpaWlJYDACJny1lvpD/8wijHrn9ZiwgMAEYS9e893EViBL+tKnqIynL/7c/bRCAJL1Mv4+cPsCY9gzBIAICJddjxQB0Ayqh8SZximqanp1VdfValUTU1NFRUVUqnUYDAQQui3SEQFgisdwkfpb5865b389fjlPxuTkYHLDEAobkUICexZ7N17hz7rf+vwXwgh2yoK+d+h+8GX1VN++cp2662JREK2VRS+9eJ66u/+nH30goDrTr/H68nNnC4bI8P1BSD5QtaodmAAALFJHrheRXp6OtchoFMk+a/bBAIIGQDEZ/JgOnph/8m//u6ffvrFlVsvvmffaZj/5CylwNn/94nL/+fUZU6mccVDT+T9iPN3f86OIAAAQPIAQEIQjSV4BRN6fEfpic74AQDEG12fX3mh5MezJo+fNXn8sV73Z1/fFCQPcrn8P/7i5sv0MX/n8v6cHUEAAAAASAjGwAQAgFC4Pcj2XvE8PPn+sqqFuRO6Pr8ShgwAIAVhWTbwqv9BBQAASB4AAInEdcZLCJGn3X9d+aNxMt+PWIciAwBItbTBYrHk5ubm5uZardYwBAAAcQW+HA4A+AH+9xM8Hg9/NFGWXEYIYQZ/eDQ4a3KmYPdQZAAAKUVjY6PJZDp8+LDdbl+8eHF7e3tZWdmwBAAAcQXePAAAfoD/QRXBPISMNOmsyZlfXLn/Qbdjve7H8hSC3UORAQCkFAcPHmxqasrPzzcYDHq9/uTJk8MVAAAgeQAAJCSP5SnetTouX7/zQa/7E+fAwocm0XLLiUuWE5cCywAAUhCGYWw2W35+Pv1z4cKFBw8eHJYAACDeSNRhS/zBFQCA6GBc/vC/djt/vv2DiZlpL5T8eOFDE2n56b/eIIQYHp8eQAZBAICEILLrn9LF2cePv7+IgkKhsNlswxKgsCwrk8kQBACIhyAgTcpacWElbheBhm7QLcqZdkR0y0iTVhfN/G8L89LGjpGO/eG95Yulc4LKIAhAN+iWBEFguNCVmm/dusWVaLXaYQnc76xIpTG0bbxd2bjSB8okijIRDAIYtgQAGHYKIcgKFPI0hTwtsAwAIAWRy+VardZut9M/29raioqKhiUAAIg3cHcHAAAAwGhRVFS0detWp9PZ0dFx5MiRp556ihDS0tLS0tISQAAAELdgqVYAAAAAjBaNjY1NTU0ajUalUjU1NZWUlBBCuru7CSG1tbX+BAAAcUv8Dh6NQN0wNBa6QbeYDnfGRYFu0A1BgMIwTHp6ulR6/5ElnSdNJzyICuDKJoo+UCZRlIlgEJCkZpcCAAAAAAAAMFww5wEAAAAAAACA5AEAAAAAAACA5AEAAAAAAACA5CEcWJZlWXbkMjHRjWVZOnUsPu0Wz9eUEOJ2uxmGiUPdGIZJdNsiCCAIIAggCKQ4MfTNRCEmDphYHhdX7haRJj0mCRzbYrHk5ubm5uZardawZWKiG8MwxcXFMpksOztbrVZzi17Hid24uCCRSOg8/bjSzel0GgyG7OzszMxMi8USP7rZ7fbi4uLMzEyZTGYwGKIWVVtaWgoKCiQSicFgGPl1RxBAEEAQQBBIZWLom0E761H2x7hywLjyuKDeFyt3E1Umkk16KMGpr69XqVQ2m81sNhNC2tvbw5OJiW4ul6u+vt5ms7lcrubmZkKIw+GIH7tRdDqdSqWKZlMJRbfjx48TQurr6z0ej8PhiCu76XQ6vV7vcrkcDodKpaqvr4+Obs3NzWazWavV6vX6kV93BAEEAQQBBIFUJoa+GZjo+6MosXJAfzaJiccF9b5YuZuoMhFs0gmfPGi1WrPZTH/r9XrRFhOKTKx0+7uLQUhzc3Nc6WY2m1UqFW1kcXVNjUaj0WiMz/ZGCOHLBLiLjwaBzxgrX0AQQBBAEEAQSGii6ZsBiIk/ihIrB/R3dWLocQG8L7buFtgUI2nSYxL9raLNZsvPz6d/Lly48ODBg2HIxEo3wYtIQsiMGTPiRze3271mzZrDhw8rFIq4uqaEkB07dpw7d66goKCgoKClpSU6owlD1K2+vn7jxo0dHR0tLS379u1bv359AvkLggCCAIIAggCIoW8GViP6/uiPmDigP+LT4+LZ3UbYpKVJ4M/jx4+nfyoUCpvNFoZMrHTjj4rT6XQ6na6srCx+dDMYDEajMT8/3263x9U1dTqdhJCzZ882NTVNmDDhmWeeGRgYeOWVV+LEbpWVlSaTacWKFYQQrVZbWFiYQP6CIIAggCCAIABi6JsBiIk/ihIrB/RHfHpc3LrbyJt0Yr95oF+2v3XrFlei1WrDkImVbtxVLC0tdblc77//fvzYzWq1dnV1Pfvss06n88KFCzRYROHRQii65eTkEEKqq6sNBkNZWdnLL79sMpnixG4syy5YsKCiosLr9Xo8nuzs7F/84hcJ5C8IAggCCAIIAiCGvumPWPmjKLFyQH/XKD49Lj7dLSJNOrGTB7lcrtVquRS8ra2tqKgoDJlY6cZdxbNnz9psNrlcHj92u3TpEm3oGo3m1VdfJYRoNJq+vr540E0qlep0Ou69rUKh6O/vj0IMDUW3vr6+/v7+uro6qVQql8vXrVvX1dWVQP6CIIAggCCAIABi6Jv+iJU/ihIrBxQlbj0uDt0tYk060ecwGY1GrVbrcDja29tVKhU3k725uZmbCOJPJua6eb1enU5HCGlvb6eLFbhcrvixG3+GVjSbSii61dfXa7Val8vl8Xi0Wm3Upm2FoptKpTIajR6PJ8q60SUv6LtIfluKB19AEEAQQBBAEEgsYuiboUybjnn/LVYOKEqsPC6o98XK3USViWCTTvjkwePx1NfXE0JUKpXZbPZ6vb5zzP3JxFw3h8MhyOWitkRAKHaLVZwa1jUlhOh0uqjF9FB0ozGCe0cZtQXs6GXybUvx4AsIAggCCAIIAolFDH0zIZKHWDmgKLHyuKDeFyt3E1Umgk1aMjQ0lATvFhmGSU9Pl0p/mP9N56nQAWf+ZGKuG8uygneOcrmcr3M82I2Kud3uvLy8OLym1Ghx2N7cbndGRkY0daOXybctxY8vIAggCCAIIAgk0Jil2Ppm0AsdZX/0p0lMHFCU6HtcKN4XE3cTVSaCTTpJkgcAAAAAAADAaDMGJgAAAAAAAAAgeQAAAAAAAAAgeQAAAAAAAAAgeQAAAAAAAAAgeQAAAAAAAAAgeQAAAAAAAAAgeQAAAAAAAAAAJA+RhGGYhoYGtVotkUhGeCin00m/vUKRSCQWiyV+NB9tfeJWB76hKCEqI7igAO4/rNYyqq09gOZht9ugCkewRggFIDUJpeVzMoGFAzfL8BrtsNQbOVarVSKRsCwbb90PtVpttVqRPAC/HDt2zGQyHT582Pcb4MNFo9G0trZyf+r1+unTpyeE5lFjtG0S1FDt7e2hKyO4oADuP6zWMqqtPYDmYbfboApHsEYIBSA1GVbLDywcuFmG12hDUS+CzltTU1NfXx+HH01/+eWXa2pqkDwAcdxu97Zt2+bNmzd+/Hj6dXSarLvdbqvVSr8T7nQ6ud8CGIaxWq1Op5MeihBy4cIFp9NJSxobGwsLCwVPAugmwbMBhmHsdnvghwSCfX01D6ye6AFF6+V2uzs6OvgPLXxLuOPb7fagu/Ph2yT0uotWJERjCgw1d+5cUWVCuaAA7j+s1iJoYNFxf19NfCvlr16cwv4UC91/7Xa70+lkWZb+HyAUhG4EhAIQ5fgguJdxrmS3231btegN0bfR+oYFfxHGV5ivUuBmGUocCBwEohAHrFarzWbbuHFjYDMGNrs/r/TX/xFV1fdar1u3zmazJdvLhyEQIfR6PT+ZHhoaIoTodDpaYjab+QI6nc7j8dAdHQ4Hf5NAkl4jWk7lbTabVqvljuNwOGg5/3R8eT6i+/pqzsdXPYE+/upFleFOJ1oiOL5Wq21vb/e3uwC+DqHUXbQiwzKmwFD0Ma2vMqFcUAD3H1ZrCa/FjtD9RQMRv1IB3J8fK0QVC8V/jx8/zleYEMLVVzQUhGIEhAIQZUTvZfx2pVKpRNsM/4YY9o1YVFigUuBmGTQOBD11FOJAfX29TqcT9XG+Gf2Z3Z/7i5o9gKr++i16vd63c5XQIHhFuAPBbx+09Rw/fpxrhV6vd2hoyOPxqFQqfi+Za6wej8flcgk8ytft9Xq9x+PxeDx0X/7p6Fnq6+tVKpVoFBPdN0DLDqqeaL1cLhffwx0Oh2+JQCWv19vc3KzVakV3D5o8hFJ334oM15h8Q/nrY/RTiAAABj9JREFUMYRyQQHcf1ithSuJsvv7BiJ+pQLUi99lEVUsFP/VarWcwvR+HDR5CGoEhAIQTfzdyzhXojc+Qgjtc4veEMO+EYsmD6IqBW6WgeNA0FNHIQ4Igpg/MwY1u8D9Rc3uT9UA/Zb6+npOByQPIHjvwWg0Cp54mc1ms9nMtU6PxyO4GfvzVfqnQJ6OtaWtn386ejPjGjolwL7+eg8hquevXkaj0Waz8Q/FL+EKzWazw+FwOBzHjx+naosKB04ehlX3oAbxd8CgPYYQLQbg/sNqLbQkyu4vGogElRKtl6DLIqpYUP+ld2IuApjN5lCSh8BGQCgAUcbfvYz/os/r9dKmEviGGMaNWDR5EFVpuMlD0OAW4j06UnGAfxx/Zgxsdl/392d2f6oG6LdQtZOpYWPOw+jy+OOPc78NBsOCBQva2toGBgaUSmVXVxch5PTp04SQqVOnhnhAgTwda8sNNOSfjg7IC33fUE4nimi95HL58ePHjx49qtVq1Wp1R0eHbwl3/N27d2/atGnTpk07d+7U6/W9vb2iwqGbOmjdR27MkVgMwP0Twv1DcTTReg3LN/3J9Pb20qEFtCQ/Pz8M9XzPhVAAokmAe9nKlSvpD6lUqlKp/vSnP/m7IYZ9Ix6uShEMblGOAyqVamBggO96vmYMbHZf9w9sdl9VI2LYREEK347afKl9+/bZbDba9LmFC+hUoXPnzuXl5YVyHCp/+fJlKn/u3DlCSE5OzijtG1Q9f/UihCxatOjMmTNut/v1119fsWKFx+PxLaHHf+211xYtWiQ4sq+wv8ncodddUJGRGDNsiwG4f6K4f9j1ighU4d7eXqVSSQg5duxYBA+LUACihr972e7duw0GA+139vf3L1++3N8Nkfazw7sRh6hSfAaB0OPAsmXLuru7a2truV1E+xUBzO7r/vSMw3Jhf9f6xIkT/DkSSQDePEQVOsHfarVyqblcLjcajS+99BJdE8DtdtMZ/Uajsa2tzTc1l8vlOp3utddeo8sCbNu2Ta/Xh7g2WRj7+lMvaL2cTifdRalUPvzww4SQS5cuCUq449fU1NBNLMt2dHQwDOO7+8gf//hWZCTGHK7F/F1QAPePW/cPsd361isiUIVramqsVmtHR8cbb7wRqcMiFICoEeBe1tXVZbVaWZbdvXs3IeTxxx/3d0MM+0YcukqBm2XQRjtKQSD0ODB79uzPPvsscL8igNlF3T9Es4dyrc+dO8dfkw3JAwgVpVJpNBrXrFkjk8nKy8v5OejmzZuLioq0Wq1EIsnOzu7u7iaEVFRUfPbZZ5mZmb6fbXr77beVSqVGo9FoNEqlcvv27aGrEca+ouoFrVd3dzfdRSKRbNiwwWw2nz59WlBCM/LNmzevXr2abpLJZM8888zt27d9dx/Ja4cAFRmJMYd1ogAXFMD949b9A7fbAPWKCO+///7q1asXL178zDPPVFRU0DOOkociFIDRIMC9TKfTLV68WCaTvfHGG2azmSarojfEsG/EoasUuFkG2DraQSDEOFBZWWmz2bjOvT8z+jO7P/cPbPYQrzXDMF1dXVTz5AHzmSK7rgJ/fp7D4eDWLOPm8dDp+fSH7ybfOY5UTPRQghK+jNfr5RZAEJ3CJdhXoLnoLnz1BPqI1ov+5lfTt4SDKhyisK8Ow6q7qJ1DNCbfULQ88LX2d0EB3H9YrcXX46Lv/qKV8lcvTtKfYqH7L/0tWIpRtO6hGwGhAERzzrTvvYwQYjab+S0n8A0x7BuxqHf4u70GbpaBOyQBTh2dOKDX6+vr6wObMbDZfd3fnwv7U1XUsMm31NLQ0JBk6Ps1pwAAAID4oaOj4+TJkzNnzmxra9u3b19zczMd0wxAoiORSMxmMx18DyISB5xO56ZNm/bs2RNgwGFMzG4wGF566aUQl3xIFDBhGgAAQDwyd+7cvXv3nj9/fvbs2dyMTACSAL1eP336dNghgnEgLy/PYrHEodmDapWQ2S/ePAAAAAAAAABCAROmAQAAAAAAAEgeAAAAAAAAAEgeAAAAAAAAAEgeAAAAAAAAAEgeAAAAAAAAAEgeAAAAAAAAAEgeAAAAAAAAAADJAwAAAAAAAADJAwAAAAAAAADJAwAAAAAAAADJAwAAAAAAACAu+f9I6/dvW9t5WAAAAABJRU5ErkJggg==", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Render each regenerated PDF to a PNG preview (needs poppler's pdftoppm; falls back to\n", + "# printing the path if it is unavailable).\n", + "import shutil, subprocess, tempfile\n", + "from IPython.display import Image\n", + "\n", + "has_poppler = shutil.which('pdftoppm') is not None\n", + "for name, caption in FIGURES:\n", + " pdf = ROOT / 'paper' / 'pnas' / 'figs' / f'{name}.pdf'\n", + " display(Markdown(f'### {caption}'))\n", + " if not has_poppler:\n", + " print(f'(install poppler-utils to preview inline) {pdf}'); continue\n", + " with tempfile.TemporaryDirectory() as tmp:\n", + " subprocess.run(['pdftoppm', '-png', '-r', '110', '-singlefile',\n", + " str(pdf), f'{tmp}/p'], check=True)\n", + " display(Image(filename=f'{tmp}/p.png'))" + ] + }, + { + "cell_type": "markdown", + "id": "c10", + "metadata": {}, + "source": [ + "## Rebuild the manuscript PDF (optional)\n", + "\n", + "`build.py` converts `paper/pnas/main.md` to LaTeX, placing these figures; compiling needs a TeX\n", + "toolchain (`tectonic main.tex`), so it is left as a shell step rather than run here." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "c11", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-07T14:40:36.993214Z", + "iopub.status.busy": "2026-09-07T14:40:36.992919Z", + "iopub.status.idle": "2026-09-07T14:40:37.039217Z", + "shell.execute_reply": "2026-09-07T14:40:37.038560Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "wrote /home/gg/ownCloud/Work/Projects/LamarckianAI/paper/pnas/body.tex\n", + "now: cd paper/pnas && tectonic main.tex\n" + ] + } + ], + "source": [ + "import subprocess\n", + "print(subprocess.run([sys.executable, str(ROOT / 'paper' / 'pnas' / 'build.py')],\n", + " capture_output=True, text=True).stdout.strip())\n", + "print('now: cd paper/pnas && tectonic main.tex')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.15" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/paper/pnas/figs/fig1a.pdf b/paper/pnas/figs/fig1a.pdf index 18ff3ed..9c8e41b 100644 Binary files a/paper/pnas/figs/fig1a.pdf and b/paper/pnas/figs/fig1a.pdf differ diff --git a/paper/pnas/figs/fig1b.pdf b/paper/pnas/figs/fig1b.pdf index 85b4fa4..895cb63 100644 Binary files a/paper/pnas/figs/fig1b.pdf and b/paper/pnas/figs/fig1b.pdf differ diff --git a/paper/pnas/figs/fig2.pdf b/paper/pnas/figs/fig2.pdf index 6c133d9..71e0c8b 100644 Binary files a/paper/pnas/figs/fig2.pdf and b/paper/pnas/figs/fig2.pdf differ diff --git a/paper/pnas/figs/fig3.pdf b/paper/pnas/figs/fig3.pdf index 068a2c3..38e3928 100644 Binary files a/paper/pnas/figs/fig3.pdf and b/paper/pnas/figs/fig3.pdf differ diff --git a/paper/pnas/figs/fig4.pdf b/paper/pnas/figs/fig4.pdf index 79161a2..a9d2f14 100644 Binary files a/paper/pnas/figs/fig4.pdf and b/paper/pnas/figs/fig4.pdf differ diff --git a/paper/pnas/figs/fig5.pdf b/paper/pnas/figs/fig5.pdf index 0763c49..1c4cb17 100644 Binary files a/paper/pnas/figs/fig5.pdf and b/paper/pnas/figs/fig5.pdf differ diff --git a/paper/pnas/figs/fig6.pdf b/paper/pnas/figs/fig6.pdf index 8f91033..bb84dbf 100644 Binary files a/paper/pnas/figs/fig6.pdf and b/paper/pnas/figs/fig6.pdf differ diff --git a/paper/pnas/figs/fig7.pdf b/paper/pnas/figs/fig7.pdf index 4492ced..827825f 100644 Binary files a/paper/pnas/figs/fig7.pdf and b/paper/pnas/figs/fig7.pdf differ diff --git a/pyproject.toml b/pyproject.toml index 58e07b5..e771e07 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -26,6 +26,9 @@ mnist = ["torchvision>=0.17"] # Layer 2 / LLM prototype (blueprint C2/C4): LoRA specialists + weight-space merging on a small # open-weight base. GPU; models download to the HF cache (outside the repo). `uv sync --extra llm`. llm = ["transformers>=4.44", "peft>=0.11", "datasets", "accelerate"] +# Jupyter notebooks that walk through the biological model and regenerate every paper figure +# from the committed artifacts. `uv sync --extra notebooks`. +notebooks = ["jupyter>=1.0"] [build-system] requires = ["hatchling"] diff --git a/reproduce.sh b/reproduce.sh new file mode 100755 index 0000000..019749e --- /dev/null +++ b/reproduce.sh @@ -0,0 +1,82 @@ +#!/usr/bin/env bash +# One-command reproduction of the paper's biological-model tier (see REPRODUCING.md). +# +# ./reproduce.sh env -> tests -> biological model at committed seeds -> figures +# ./reproduce.sh --with-gpu also runs the trained-network, MNIST, and language-model tiers +# +# Writes REPRODUCED.md: every artifact's recomputed content hash next to the committed one, so a +# reader can see at a glance which bundles reproduced bitwise. The biological-model tier must match +# exactly; GPU tiers are statistically reproducible only (REPRODUCING.md section 5). +set -euo pipefail + +WITH_GPU=0 +[[ "${1:-}" == "--with-gpu" ]] && WITH_GPU=1 + +cd "$(dirname "$0")" +START=$(date -u +"%Y-%m-%dT%H:%M:%SZ") +say() { printf '\n\033[1m== %s\033[0m\n' "$1"; } + +say "Environment (uv sync from the committed uv.lock)" +if ! command -v uv >/dev/null; then + echo "uv not found. Install it: curl -LsSf https://astral.sh/uv/install.sh | sh" >&2 + exit 1 +fi +if [[ $WITH_GPU -eq 1 ]]; then + uv sync --extra dev --extra neural --extra mnist --extra llm +else + uv sync --extra dev +fi + +say "Tests (correctness + closed-form scientific validation)" +uv run pytest -q + +say "Biological-model tier at the committed seeds" +make layer1 + +if [[ $WITH_GPU -eq 1 ]]; then + say "Trained-network tier"; make neural + say "Real-MNIST tier"; make mnist + say "Language-model tier"; make llm + say "LLM predictive test"; make llm-epistasis +fi + +say "Figures (pure functions of the artifacts)" +make figures +make paper-figures + +say "Hash report -> REPRODUCED.md" +uv run python - "$START" "$WITH_GPU" <<'EOF' +import hashlib, json, pathlib, subprocess, sys, datetime + +start, with_gpu = sys.argv[1], sys.argv[2] == "1" +commit = subprocess.run(["git", "rev-parse", "HEAD"], capture_output=True, text=True).stdout.strip() +rows, exact, differ, missing = [], 0, 0, 0 +for man_path in sorted(pathlib.Path("results").glob("*/manifest.json")): + man = json.loads(man_path.read_text()) + pq = man_path.parent / "results.parquet" + want = man.get("results_sha256", "") + if not pq.exists(): + status, got, missing = "not run", "-", missing + 1 + else: + got = hashlib.sha256(pq.read_bytes()).hexdigest() + if got == want: + status, exact = "bitwise match", exact + 1 + else: + status, differ = "differs", differ + 1 + rows.append((man_path.parent.name, man.get("master_seed", "-"), status, want[:12], got[:12])) + +out = [ + "# Reproduction report", "", + f"- Started: {start}", f"- Finished: {datetime.datetime.now(datetime.UTC):%Y-%m-%dT%H:%M:%SZ}", + f"- Commit: `{commit}`", f"- GPU tiers included: {'yes' if with_gpu else 'no'}", + f"- Bundles: {exact} bitwise match, {differ} differ, {missing} not run", "", + "The biological-model tier is bitwise reproducible and must show `bitwise match`. GPU tiers are", + "statistically reproducible only, so `differs` is expected there (see REPRODUCING.md section 5).", + "", "| Bundle | Seed | Status | Committed sha256 | Recomputed |", "|---|---|---|---|---|", +] +out += [f"| `{n}` | {s} | {st} | `{w}…` | `{g}…` |" for n, s, st, w, g in rows] +pathlib.Path("REPRODUCED.md").write_text("\n".join(out) + "\n") +print(f"{exact} bitwise match, {differ} differ, {missing} not run -> REPRODUCED.md") +EOF + +say "Done. See REPRODUCED.md, and REPRODUCING.md for the figure-by-figure map." diff --git a/tasks/lessons.md b/tasks/lessons.md index b3a6694..b66e0f2 100644 --- a/tasks/lessons.md +++ b/tasks/lessons.md @@ -39,3 +39,14 @@ pop-gen construct is **"the biological model"** (GG decision, 2026-09-07) — us line "closed forms · bitwise-reproducible" carries that content). Support level formerly "Exact" is now "Closed form". Keep "exact" only in technical noun phrases (exact-match verifier, exact oracle, exact equilibrium, exact recovery). + +## Never `uv sync` while a job is using the venv (2026-09-07) +Adding the `notebooks` extra mid-session ran `uv sync` **without** `--extra llm`, which rebuilt the +shared `.venv` — dropping the LLM stack *and* silently switching the interpreter 3.14 → 3.11 (uv +recreates with the system default when no `.python-version` is pinned). That killed the running +local society seed with a `FileNotFoundError` deep in `huggingface_hub` templates — a failure that +looked scientific but was pure environment churn. +Rules: (1) never mutate `.venv` while a background job is running against it — wait, or build a +throwaway venv elsewhere; (2) `uv sync` is *declarative* — always pass **every** extra the project +needs, or it removes the ones you omit; (3) the repo now pins `.python-version` (3.14) so the +interpreter can never drift silently. diff --git a/uv.lock b/uv.lock index 96280af..a97d76c 100644 --- a/uv.lock +++ b/uv.lock @@ -13,6 +13,174 @@ resolution-markers = [ "python_full_version < '3.12' and sys_platform != 'emscripten' and sys_platform != 'win32'", ] +[[package]] +name = "accelerate" +version = "1.14.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "huggingface-hub" }, + { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12'" }, + { name = "numpy", version = "2.5.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" }, + { name = "packaging" }, + { name = "psutil" }, + { name = "pyyaml" }, + { name = "safetensors" }, + { name = "torch" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/8d/75/94cd5d389649578aca399e5aa822637eec18319a1dadc400ffe2f9a7493f/accelerate-1.14.0.tar.gz", hash = "sha256:41b9c4377a54e0b460a959b0defa1b736e4ca0a2373252d9a539964c2afe3c8d", size = 412167, upload-time = "2026-06-11T13:45:52.326Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a8/db/253133d7e7cb40d3af384bb2f5c0b4a2b7fdcffbc95c688cc67a20a3c103/accelerate-1.14.0-py3-none-any.whl", hash = "sha256:e94390c2863b873be18f623f9df48a0d8fe5eff13ea7f1a00092b0a7904888c6", size = 389246, upload-time = "2026-06-11T13:45:50.477Z" }, +] + +[[package]] +name = "aiohappyeyeballs" +version = "2.7.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ce/f4/eec0465c2f67b2664688d0240b3212d5196fd89e741df67ddb81f8d35658/aiohappyeyeballs-2.7.1.tar.gz", hash = "sha256:065665c041c42a5938ed220bdcd7230f22527fbec085e1853d2402c8a3615d9d", size = 24757, upload-time = "2026-07-01T17:11:55.501Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/71/43/1947f06babed6b3f1d7f38b0c767f52df66bfb2bc10b468c4a7de9eceff2/aiohappyeyeballs-2.7.1-py3-none-any.whl", hash = "sha256:9243213661e29250eb41368e5daa826fc017156c3b8a11440826b2e3ed376472", size = 15038, upload-time = "2026-07-01T17:11:54.055Z" }, +] + +[[package]] +name = "aiohttp" +version = "3.14.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "aiohappyeyeballs" }, + { name = "aiosignal" }, + { name = "attrs" }, + { name = "frozenlist" }, + { name = "multidict" }, + { name = "propcache" }, + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, + { name = "yarl" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/58/d9/22ce5786ac0c1653ae8b6c23bded02c1686d11f0dbb45b31ce128e0df985/aiohttp-3.14.3.tar.gz", hash = "sha256:9491196535a88924a60afd5b5f434b5b203b6cc616250878dbdb223a8f7844bc", size = 7971213, upload-time = "2026-07-23T01:57:27.037Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f8/5c/b3e4ff8ad43a8afef9602c5e90285936da1beaea8b029016b793891f03c3/aiohttp-3.14.3-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:e568e14940c09955aa51f4e645b6daa18a581c5dcfcd73744dcc86a856e3ced3", size = 764250, upload-time = "2026-07-23T01:52:48.525Z" }, + { url = "https://files.pythonhosted.org/packages/0e/da/f1b384465e51449d844056b75070461da03a9a23e6c1747003695bf4172a/aiohttp-3.14.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:54cfcdee2770dac994417cbb0ee1f3eb0e7cb6b30c79bf44f2c02ff79ec5124a", size = 516281, upload-time = "2026-07-23T01:52:51.047Z" }, + { url = "https://files.pythonhosted.org/packages/b9/3f/01264f820ee2e3712a827892b1cd6ff80f3300c1fcbffbb45714a915d47a/aiohttp-3.14.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:21c016079415ed3fd676963e9793700a566d85dbbd6bfc564b9b2d209147dcc8", size = 514742, upload-time = "2026-07-23T01:52:53.779Z" }, + { url = "https://files.pythonhosted.org/packages/9e/8d/a71c6f2db52ac1ed142b133f7feddaa6b70539c3f4de24d7e226c95b794c/aiohttp-3.14.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d6088ec9894113802bddb3c09e974929aed2c7b3a8c456219b8aab4481f1a239", size = 1780613, upload-time = "2026-07-23T01:52:56.948Z" }, + { url = "https://files.pythonhosted.org/packages/a5/11/3dd9b3fb3a170f6ec9011b5291d876a6fab4086714c9e158600edf01b4fd/aiohttp-3.14.3-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:16ea7e24c309fb7c0bbd505d149abe4fe4dccfb8db911db7dbec0921bc889a6f", size = 1737688, upload-time = "2026-07-23T01:52:59.294Z" }, + { url = "https://files.pythonhosted.org/packages/6d/3e/834c26918be7d88068822b40e0db30fca50b5f4fe79104aa16a93f1d74e6/aiohttp-3.14.3-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:56f355e79f71aef2a85c80305cc915f894b170dba76de5fe84f6351939b83c06", size = 1845742, upload-time = "2026-07-23T01:53:01.641Z" }, + { url = "https://files.pythonhosted.org/packages/cc/c9/49ab8572df7d66bc13d11e31f781292badb04180dd87ba98733066c6aed7/aiohttp-3.14.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:18c441d0a8fca6de8d1f546849b9f0ab20d435993e2c5b59562b2fae6be2f929", size = 1928412, upload-time = "2026-07-23T01:53:04.018Z" }, + { url = "https://files.pythonhosted.org/packages/a5/b9/2b8f0c0ce09c87a1daf80fd483431b56b1435d3f62789bc86f572e1245de/aiohttp-3.14.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:53e7b4ce82b54a8bcc71b3b67a5cbd177ca1d7f592cbc92cd38b7349f73482db", size = 1786220, upload-time = "2026-07-23T01:53:06.481Z" }, + { url = "https://files.pythonhosted.org/packages/85/00/9c45f81de11710460edfa1dc81317b6e882703b160926c879a9d20da9fcc/aiohttp-3.14.3-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f55119f7bf25f49ed210f6096090715da24f2943c62102448915fde3c62877ce", size = 1637231, upload-time = "2026-07-23T01:53:10.258Z" }, + { url = "https://files.pythonhosted.org/packages/19/ce/967d628e910756f3539c6107cb7844a1b69440dcb3029a5ee7871b09ab63/aiohttp-3.14.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:9aa6e61fdf20105c4144e755bd586008ff450791d67b1c8146fdc15959c4d51c", size = 1753161, upload-time = "2026-07-23T01:53:13.817Z" }, + { url = "https://files.pythonhosted.org/packages/11/b2/0c3d4114f0aee4f580f5b3b4eb71b24d7a23b834ea506a4dfebe76513f35/aiohttp-3.14.3-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:ccd4893707b3e2a13e39c90d43cf80edf2e4d0457935bcc103bf2346214c3f15", size = 1756356, upload-time = "2026-07-23T01:53:16.211Z" }, + { url = "https://files.pythonhosted.org/packages/63/5d/99e7d91c82f1399d1ae2a854e080bd1493fbc31e5e959dbc4ec33dac3bec/aiohttp-3.14.3-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:b2466434105a4e03113c36ec775cc2ebe6676b62eae326fa670bb607ef788c1c", size = 1819846, upload-time = "2026-07-23T01:53:18.289Z" }, + { url = "https://files.pythonhosted.org/packages/ad/05/d5e1cb6480eeffd3f901d40a2c5e2d1e7effdc797837da3b490272699f13/aiohttp-3.14.3-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:ba59d59aba08ac02fc03b0c8983ccd5ee39a199d0552ce9e6d2b4845b34d59ae", size = 1628531, upload-time = "2026-07-23T01:53:23.86Z" }, + { url = "https://files.pythonhosted.org/packages/c9/90/b934682bcaefae18a9e04f3dff5b68522ba810906358ae5029b68110ea3b/aiohttp-3.14.3-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:ed099d105449c4f9e84f24af203cd131349d4761d8813fa7e02c32e7128cd910", size = 1832712, upload-time = "2026-07-23T01:53:27.551Z" }, + { url = "https://files.pythonhosted.org/packages/21/df/6061679faaf81fac746e7307c7adb71e858071a5d34c27583afefc64f543/aiohttp-3.14.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:152516815ef926786a0b6ae2b8f1fd2e0c71582dee0b435636865316fd4891b7", size = 1775014, upload-time = "2026-07-23T01:53:30.223Z" }, + { url = "https://files.pythonhosted.org/packages/8a/1d/f854878bbc69b88faefe924b619a34a6f59ec05fd387c77690667eaa75eb/aiohttp-3.14.3-cp311-cp311-win32.whl", hash = "sha256:a4af35c443e0b1a1bd6a8af3f3485d7fda15c142751a00f3ff8090f0b93346fa", size = 456006, upload-time = "2026-07-23T01:53:34.97Z" }, + { url = "https://files.pythonhosted.org/packages/73/0c/2af9d1674baccd1dbd47282a93d660a22e57ef6167c856deb24b4214fbab/aiohttp-3.14.3-cp311-cp311-win_amd64.whl", hash = "sha256:e1e74298bab6ee0d6e749ed4fd1901c7e604bdda32c03d787a2cc71c46d0433d", size = 481069, upload-time = "2026-07-23T01:53:39.673Z" }, + { url = "https://files.pythonhosted.org/packages/8e/76/88401ff3fc95e85c5fc38d588f36f55e61ecb64343b2bc8d69326f453cc0/aiohttp-3.14.3-cp311-cp311-win_arm64.whl", hash = "sha256:03cd2bde3d7f085b64e549c985f4bb928cad7e8ecf5323bfca320db548d81b39", size = 453021, upload-time = "2026-07-23T01:53:43.749Z" }, + { url = "https://files.pythonhosted.org/packages/18/d4/eb96299230e20acf2efae207cb8d69051f1f68e357e5ea5e479bf6fb097a/aiohttp-3.14.3-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:39aded8c7f3b935b54aab1d8d73c70ec0ee2d3ec3b943e0e86611bc150ba47f5", size = 754690, upload-time = "2026-07-23T01:53:47.332Z" }, + { url = "https://files.pythonhosted.org/packages/88/11/e7a70a209eb9a067c0d3212b518a0134e3484f5178c7533878b6b514d469/aiohttp-3.14.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:5bcb6ff3fdab1258a192679ff1a05d44f59626430aa05cd1a9d2447423599228", size = 509484, upload-time = "2026-07-23T01:53:51.159Z" }, + { url = "https://files.pythonhosted.org/packages/30/07/4bbc222cc8dbe31d4c3e8a5baad2286e4d42026ac0c570027b89afce6344/aiohttp-3.14.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:617105e2c3018ee38d0c8ce5ee3c84f621a6d8b9f723202aacaff28449ca91ee", size = 511949, upload-time = "2026-07-23T01:53:55.083Z" }, + { url = "https://files.pythonhosted.org/packages/54/b9/42e74c46b7b7c794b995bbc1f573fb48950c38b19d8600c62a6804ee2d67/aiohttp-3.14.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f631fe87a6f30df5fbe6d79640b25e4cffb38c31c7fb6f10871517b84b0f8c1a", size = 1765282, upload-time = "2026-07-23T01:53:59.662Z" }, + { url = "https://files.pythonhosted.org/packages/6b/ed/62bc4d74363ad346d518e0720363a949f63e2e23439a79eb5813d4d29bb3/aiohttp-3.14.3-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:a94dbaae5ae27bd849c93570669bff91e0510f33a80805738e3de72a7be0447b", size = 1741511, upload-time = "2026-07-23T01:54:04.063Z" }, + { url = "https://files.pythonhosted.org/packages/d0/9f/181e8a8bc79e47d13c7fc4540bd7a3b729d9505609c61f392a8dd2fbfe55/aiohttp-3.14.3-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8f2f1c4c032c7cedd7d8da6f54c97b70266c6570c3108d3fdffee7188bb70529", size = 1810680, upload-time = "2026-07-23T01:54:09.882Z" }, + { url = "https://files.pythonhosted.org/packages/5c/9a/dec94d6ad694552fe3424e3f1928d7a606a5d9d9433a04e7ecdd9d38ae7f/aiohttp-3.14.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ea05e1f97ceea523942d9b2a7d7c0359d781d683d6b043f5943a602b14da4787", size = 1905646, upload-time = "2026-07-23T01:54:13.475Z" }, + { url = "https://files.pythonhosted.org/packages/52/b7/7cd31f29d6055bd711ae6e669367fba6f5ae9de463910a793e30556a8db7/aiohttp-3.14.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:543906c127fb1d929b95076db19b83fa2d46751006ff1e23b093aa5ac4d8db42", size = 1792122, upload-time = "2026-07-23T01:54:15.752Z" }, + { url = "https://files.pythonhosted.org/packages/66/73/10b1ef93afa61f4963c746257b70ced619cf31a4798671de5fdb2608501d/aiohttp-3.14.3-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0a5ff2dfbb9ce645fa5b8ef3e02c6c0b9cc3f6030ff863d0c51fffc50cb5541b", size = 1591127, upload-time = "2026-07-23T01:54:19.489Z" }, + { url = "https://files.pythonhosted.org/packages/49/ed/3b203fa6de1b338c14acdc06bf6ca9b043b7944f005966958c2ced932cde/aiohttp-3.14.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:041badb8f84396357c4d3ad26de6afd7a32b112f43d3c63045c0c8278cfd2043", size = 1725210, upload-time = "2026-07-23T01:54:24.129Z" }, + { url = "https://files.pythonhosted.org/packages/28/b7/1c2aab8c706436dcc28598452488ac9cd7c409da815237c28c27d58993e6/aiohttp-3.14.3-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:530125ee1163c4219af35dc3aa1206e541e7b31b6efc1a3f93b70a136f65d427", size = 1764848, upload-time = "2026-07-23T01:54:27.973Z" }, + { url = "https://files.pythonhosted.org/packages/54/50/94c28f08b131c4bf10984ea2c7a536c9920608bb2d6e7f95642c30cc87b7/aiohttp-3.14.3-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:c8653fd547c93a61aadc612007790f5555cdd18946fa48cf45e26d8ea4ea473d", size = 1777102, upload-time = "2026-07-23T01:54:31.775Z" }, + { url = "https://files.pythonhosted.org/packages/13/d4/e7d09ba7d345fb2d74440fd2fa033c5e079fac05552927705986f41a364f/aiohttp-3.14.3-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:89176250f686cb9853c0fb7ead90e639e915b84a6f43eedc2a4e7ec21f1037f0", size = 1580205, upload-time = "2026-07-23T01:54:34.518Z" }, + { url = "https://files.pythonhosted.org/packages/a3/84/072a91d68e1e1eb587985b54baab94221277f877e8ef274fc213a0ceae28/aiohttp-3.14.3-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:3a26434dafe408229ff3403458ca58de24fb51936504decac49ce6755f77e59d", size = 1797219, upload-time = "2026-07-23T01:54:36.995Z" }, + { url = "https://files.pythonhosted.org/packages/e0/eb/aad34e897e668424d6e995da5dff8a4a09af93363d3392488772957a63aa/aiohttp-3.14.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:d1558173930a5a8d3069cee5c92fc91c87c4dbcb099debbb3622053717145a19", size = 1768629, upload-time = "2026-07-23T01:54:40.103Z" }, + { url = "https://files.pythonhosted.org/packages/b6/2b/6bb88ddba0fecd9122aa3ebcad25996cf6c083a4a7040dbb3a4f97972af6/aiohttp-3.14.3-cp312-cp312-win32.whl", hash = "sha256:16100ad3ab8d649fdfbee87602d9d2dcdca9df0b9eda8a1b5fdc0d41f96da559", size = 451481, upload-time = "2026-07-23T01:54:42.547Z" }, + { url = "https://files.pythonhosted.org/packages/76/9b/f2f8f108da17ecef2cc3efc424e8b7ad3782b1a8360f7b8eae8ced84f6ea/aiohttp-3.14.3-cp312-cp312-win_amd64.whl", hash = "sha256:33a2d7c28d33797a2e99923dffa63f83d908a19b6bf26cfe80fa790aa5e1a75a", size = 476845, upload-time = "2026-07-23T01:54:44.853Z" }, + { url = "https://files.pythonhosted.org/packages/3e/44/28dac80a8941b604f4da10ce21097614ca1bf905ce93dca28d8d7de9c1e7/aiohttp-3.14.3-cp312-cp312-win_arm64.whl", hash = "sha256:362a3fd481769cac1a824514bcd86fda51c65e8fe6e051099e008fddde6db17c", size = 448050, upload-time = "2026-07-23T01:54:47.087Z" }, + { url = "https://files.pythonhosted.org/packages/57/be/5afd201cc0ab139029aadb75392efe85a293403d9dd3a3226161c21ce00c/aiohttp-3.14.3-cp313-cp313-android_21_arm64_v8a.whl", hash = "sha256:2e9878ae68e4a5f1c0abe4dd497dbc3d51946f5837b56759e2a02e78fa90ef86", size = 506269, upload-time = "2026-07-23T01:54:49.075Z" }, + { url = "https://files.pythonhosted.org/packages/22/09/dec8189d62b45ade009f6792a2264b942a90cb88aeaf181239933cd72c3c/aiohttp-3.14.3-cp313-cp313-android_21_x86_64.whl", hash = "sha256:f3d2669fe7dec7fc359ecdb5984b29b50d85d5d00f8c1cb61de4f4a24ee42627", size = 515166, upload-time = "2026-07-23T01:54:51.894Z" }, + { url = "https://files.pythonhosted.org/packages/28/24/2854869d29ed8a8b19d74f9ec6629515f7e04d02dd329d9d179201e58e47/aiohttp-3.14.3-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:cc7cb243a68167172f48c1fd43cee91ec4b1d40cefd190edd43369d1a6bc9c82", size = 486263, upload-time = "2026-07-23T01:54:54.223Z" }, + { url = "https://files.pythonhosted.org/packages/d4/dd/57187c8be2a35aea65eaee3bd2c3dcbbcf0204f5106c89637e3610380cd1/aiohttp-3.14.3-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:78253b573e6ffab5028924fc98bc281aae05445969982a10864bc360dea2016c", size = 492299, upload-time = "2026-07-23T01:54:56.236Z" }, + { url = "https://files.pythonhosted.org/packages/b9/11/06ae6ed8f0d414edf4068861e233d8fe23ee699bfd4b3ceb8663db948a62/aiohttp-3.14.3-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:7041d52c3a7fa20c9e8c182b534704abb19502c8bdcbde7ab23bfda6f642394f", size = 502235, upload-time = "2026-07-23T01:54:58.377Z" }, + { url = "https://files.pythonhosted.org/packages/7e/a3/559639c34a345d2cf7c52dff6838119f2eaf29eb508227b5b83f573af813/aiohttp-3.14.3-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ac74facc01463f138b0da5580329cfcc82818dea5656e83ddcd11268fc12ff80", size = 750883, upload-time = "2026-07-23T01:55:00.65Z" }, + { url = "https://files.pythonhosted.org/packages/91/cd/41e131f13afd1e7b0172a9d9eda085ef90eb8439f41f0d279db81ed3ae60/aiohttp-3.14.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:d6218d92e450824e9b4881f44e8c09f1853b490f9a64130801024a4793b1b3b0", size = 508473, upload-time = "2026-07-23T01:55:02.945Z" }, + { url = "https://files.pythonhosted.org/packages/bc/6b/e7f13410d391c6e55b4c007a8de024355389d7d459e3d64c42b2d33617e5/aiohttp-3.14.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:11fb37ef075669eee52ab1928fbf6e1741fada40409fa309ebde9607a962aebf", size = 509190, upload-time = "2026-07-23T01:55:05.173Z" }, + { url = "https://files.pythonhosted.org/packages/97/21/6464573e53d69672cc1eada3e5c5cb2d2efa82701e8305a0f2047a576967/aiohttp-3.14.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:55bdcc472aafe2de4a253045cc128007a64f1e0264fb675791e132ea5edaa3bd", size = 1761478, upload-time = "2026-07-23T01:55:07.383Z" }, + { url = "https://files.pythonhosted.org/packages/1a/81/d217043a4c17fbce360905e3b2bdd20139ebc9a2de836d035d179c4da006/aiohttp-3.14.3-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:c39846c3aad97a8530c89d7a3869a8f8e9e3762c6ac0504481e5c80948f7e807", size = 1735092, upload-time = "2026-07-23T01:55:09.803Z" }, + { url = "https://files.pythonhosted.org/packages/a1/66/e13a02d0eeb1a9a502402a977abb4e4abff9fe4051c26f80558c57a7c975/aiohttp-3.14.3-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5895ef58c4620afe02fa16044f023dc4dafec08158f9d08874a46a7dbc0341b8", size = 1800546, upload-time = "2026-07-23T01:55:12.012Z" }, + { url = "https://files.pythonhosted.org/packages/26/5e/57d42fca1d18cb5acc1cad945d017fabc5d6ae71d8a08ad66be8dc3ee544/aiohttp-3.14.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:fa9467a8113aa69d3d7c55a70ef0b7c636010a40993f3df9d9d0d73b3eb7ef24", size = 1895250, upload-time = "2026-07-23T01:55:14.357Z" }, + { url = "https://files.pythonhosted.org/packages/ca/1c/7da8d08e74d56f00070822f9638ff3f1c563f8ad87d1efa996c87bfc8644/aiohttp-3.14.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d7d2deec16eeedf55f2c7cf75b521ea3856a5177e123844f8fd0f114ce252cb5", size = 1789289, upload-time = "2026-07-23T01:55:16.668Z" }, + { url = "https://files.pythonhosted.org/packages/cd/0f/cf16bcf56896981c1a0319f5d5db9337994b5165730c48a8fa07e9b34be6/aiohttp-3.14.3-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:dd54d0e8717de95939766febac482ac0474d8ac3b048115f9f2b1d23a16e7db4", size = 1586706, upload-time = "2026-07-23T01:55:18.913Z" }, + { url = "https://files.pythonhosted.org/packages/fe/6f/76eac12a7f2480e1e304f842efdb07db33256b0d9165b866b6ef0806c202/aiohttp-3.14.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:df82f3787c940c94986b34222d59c9e38843fba85139f36e85255a82ad5355a9", size = 1724652, upload-time = "2026-07-23T01:55:21.296Z" }, + { url = "https://files.pythonhosted.org/packages/39/b6/19c8c592baeeb94b75f966547d40c02ac7590902306ec5863d5c027cf506/aiohttp-3.14.3-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:42a67efc36300d052fb4508a53e8b6901b9284b599ae63945c377569c5fcc1e1", size = 1756239, upload-time = "2026-07-23T01:55:23.705Z" }, + { url = "https://files.pythonhosted.org/packages/dc/c9/4e9383150296f97f873b680c4de8fb2cd88608fb9f48c79edcb111611abc/aiohttp-3.14.3-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:7a75aa63cbf9b21cfaf60dc2657e19df2c2867d91707d653fee171ffeedd1371", size = 1769161, upload-time = "2026-07-23T01:55:26.082Z" }, + { url = "https://files.pythonhosted.org/packages/aa/1e/147bdc6cc5de5f3ab011be8bf5d6e786633249f22c20bae06f85e45f5387/aiohttp-3.14.3-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:e92eb8acc45eb6a9f4935071a77edf5b85cc6f8dfad5cd99e97653c26593cdde", size = 1578759, upload-time = "2026-07-23T01:55:28.846Z" }, + { url = "https://files.pythonhosted.org/packages/fd/31/78388a9d6040ece2e11df62ea229a822cf5e52d238374b220ae9975b2623/aiohttp-3.14.3-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:b014a6ed7cf912e787149fdc529166d3ceabac23f26efeea3158c9aba2354e7e", size = 1792025, upload-time = "2026-07-23T01:55:31.457Z" }, + { url = "https://files.pythonhosted.org/packages/03/51/a3d29fdf2c25d796746af8ad6fe56a45d6256c38b0a8a2ed752e1160b3a2/aiohttp-3.14.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:3d4f72af88ac2474bb5bca640030320e3d38a0163a1d7533500e87be458eef71", size = 1768477, upload-time = "2026-07-23T01:55:33.87Z" }, + { url = "https://files.pythonhosted.org/packages/29/a6/442e18b5afeade534d877a2dc3c3e392aff8d49787890b0cf84790410267/aiohttp-3.14.3-cp313-cp313-win32.whl", hash = "sha256:5f08ec777f35ee70720233b8b9811d3bb5d728137f30ac91b7457709c3261ac0", size = 451069, upload-time = "2026-07-23T01:55:36.121Z" }, + { url = "https://files.pythonhosted.org/packages/9d/69/3d876ac02659f271cf7f6769f14a8e3de5b6e888ed8b5a7e998086a4cec8/aiohttp-3.14.3-cp313-cp313-win_amd64.whl", hash = "sha256:dff9461ec275f22135650d5ba4b4931a11f3958df7dfbb8db630000d4dee0883", size = 476518, upload-time = "2026-07-23T01:55:38.303Z" }, + { url = "https://files.pythonhosted.org/packages/b2/0e/50d6e6471cd31edce8b282bdec59375a3a69124d8a989a0b1313355cae52/aiohttp-3.14.3-cp313-cp313-win_arm64.whl", hash = "sha256:ddcac3c6b382e81f1dd0499199d4136b877beb4cb5ef770bbbfba56c4b8f55d2", size = 447676, upload-time = "2026-07-23T01:55:40.451Z" }, + { url = "https://files.pythonhosted.org/packages/c8/20/887fdcf832326571b370ffc347b3e70abe101096f3720126aac161b1d872/aiohttp-3.14.3-cp314-cp314-android_24_arm64_v8a.whl", hash = "sha256:49f7325beb0f85ef4aef5f48f490269575f83e6e2acad00a1d80b807eb027062", size = 509067, upload-time = "2026-07-23T01:55:42.618Z" }, + { url = "https://files.pythonhosted.org/packages/ad/a3/92cec936f78cc4bf0fa5554ebe593b73459d94e3c62303e1902a4cccb6f7/aiohttp-3.14.3-cp314-cp314-android_24_x86_64.whl", hash = "sha256:e3be98a7c30b8c25d573dafba7171d66dfb05ee6a9070fc46535464ff97700a6", size = 514774, upload-time = "2026-07-23T01:55:44.937Z" }, + { url = "https://files.pythonhosted.org/packages/29/ba/2a0c38df3fc557620b6a5acd98364af050053b6285b4dc7ee74100c63c18/aiohttp-3.14.3-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:614c61d478b83953e261d02bb2df750f17227cd33ef8002945bf5aebbde21919", size = 488134, upload-time = "2026-07-23T01:55:47.135Z" }, + { url = "https://files.pythonhosted.org/packages/48/d6/d51b7d4bf309af3693940d8ffd2b9ed0b682434ef85959b7c9c137f60cf8/aiohttp-3.14.3-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:1caa7b0d05f3e3a36f87788c59e970a7ee1cefcfcbb924a9f138c4a6551c9cb7", size = 494201, upload-time = "2026-07-23T01:55:49.451Z" }, + { url = "https://files.pythonhosted.org/packages/3f/5a/8f624384e5f1efabb5229b94157eb966b021e97bdb188c62860c2ae243c2/aiohttp-3.14.3-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:dfa68deb2a443bdaa3ea5297b0699c1464f08aef3812b486d1348eee61b07dc0", size = 502766, upload-time = "2026-07-23T01:55:51.656Z" }, + { url = "https://files.pythonhosted.org/packages/a6/26/4ff0164370deec18fb19254ee4ab10b7a73304ac0c860b13f5f84663759b/aiohttp-3.14.3-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:e72ee89e28d907a18f46959b4eb0bb06701cc7f8cf4366e00029e2ccfaaf5924", size = 756557, upload-time = "2026-07-23T01:55:53.964Z" }, + { url = "https://files.pythonhosted.org/packages/97/a3/7056b86dc0d9ec709ea9777eae3b0161428f943372f8b98c01c11593b682/aiohttp-3.14.3-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:ad4c8b7488d745d2ca4838ebd8ae5ba9b56341d30b1da43640e4ce87f9f49646", size = 510168, upload-time = "2026-07-23T01:55:56.22Z" }, + { url = "https://files.pythonhosted.org/packages/85/ed/0357a015892fd68058bf2d39d3fd1958e459b997a7db30aaa6aaa434ae96/aiohttp-3.14.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:db332af25642007330fca8be5c4d194caf2bea7a7fc84415aff3497af5dfee6b", size = 512957, upload-time = "2026-07-23T01:55:58.437Z" }, + { url = "https://files.pythonhosted.org/packages/47/d1/8aba53f15ccb2238405f5e9d30e2a8ca44f93878c26e7165ade00d374b1c/aiohttp-3.14.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:25bd2708db6bdf6a6630dd37bdcdfcb47c4434d22ac69c64665b802910140b30", size = 1750149, upload-time = "2026-07-23T01:56:00.856Z" }, + { url = "https://files.pythonhosted.org/packages/49/bd/40c3fee327529284375c6701cbb0fa4600cc2e8432af1378f897e2ef7d3a/aiohttp-3.14.3-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:cef89a58e628c4efcac3275c2d68083f82426dcdc89c1492a6f654f9f7ea6ab9", size = 1707685, upload-time = "2026-07-23T01:56:03.371Z" }, + { url = "https://files.pythonhosted.org/packages/2a/a3/ca0cc6724cca8114b05694abd916060758c79894c3aa5b012cdadc1bc28e/aiohttp-3.14.3-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c23ec8ee9d5ab2f5421f9c7fffce208435607af27fd46d4a44e031954352838f", size = 1803911, upload-time = "2026-07-23T01:56:05.817Z" }, + { url = "https://files.pythonhosted.org/packages/95/b5/85b099c299c3ffd38ad9b3e43694c8a346934e4a30c88c4fd5a841234f77/aiohttp-3.14.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:e2667f0bbe7eb6c74eae5e9691441ad186e5845ca3cff63230fc09c4e7514f5d", size = 1876929, upload-time = "2026-07-23T01:56:08.413Z" }, + { url = "https://files.pythonhosted.org/packages/d5/b7/1da684a04175473fa4cddbf9a2f572e79514c3fd27a74597f43057d4f3da/aiohttp-3.14.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:18cb43369747b2ae007bd2655fb8e63a099c2ff1d207962943636dac989b3147", size = 1761112, upload-time = "2026-07-23T01:56:10.918Z" }, + { url = "https://files.pythonhosted.org/packages/d1/16/bc4b55e3e5cb175fd69c53c90d60d2f47797cb343da5106e23863dc4dba4/aiohttp-3.14.3-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d77640cc618c1d99fc4f8589c0f24a730adfa54eb1e57ef7bf0c8dfb78da898c", size = 1583500, upload-time = "2026-07-23T01:56:13.613Z" }, + { url = "https://files.pythonhosted.org/packages/2a/e8/13a9d957a1ee40837f46aa30f0f4c657e673ad86a2e6362a9f9be20d26d9/aiohttp-3.14.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:53e5179d8abb5710f8e83ba207c41c8d1261fcffd4616500e15ca2b7a33be10a", size = 1713940, upload-time = "2026-07-23T01:56:15.969Z" }, + { url = "https://files.pythonhosted.org/packages/38/05/d33c680c1bcf1c7e130f9cbfc1fc02fe8bb0c4af2a94a53dd5fb56131e5c/aiohttp-3.14.3-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:cd817772b2fcf2b8c0905795318485f9ec16eae60b29feb7f4c77085311637f0", size = 1724413, upload-time = "2026-07-23T01:56:18.591Z" }, + { url = "https://files.pythonhosted.org/packages/85/1d/af798d306f7a74b6a632dbcabcf62a4c91391b7582d2a8c6d7712e2cc54e/aiohttp-3.14.3-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:4e3ac92d90e92773b2362d506068e9a948192bd553e743c5b2429e28527c8661", size = 1770748, upload-time = "2026-07-23T01:56:21.074Z" }, + { url = "https://files.pythonhosted.org/packages/a8/92/ad720d472556a995049206867765e9410969684f86ee09423ff9969044c1/aiohttp-3.14.3-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:3f42e9b78301f11c8f861746175d8b9c1ccef713fcad9eab396e2f6db8ed4a22", size = 1577564, upload-time = "2026-07-23T01:56:23.475Z" }, + { url = "https://files.pythonhosted.org/packages/60/ad/0ed7586cbef7a884e23a752fa2bb987a122e6a5dd50dab109258d0a95193/aiohttp-3.14.3-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:9d9edccfe496b476db5f398d97b865e9a6752bcf8aec4eef8390ce20fb64bb41", size = 1782080, upload-time = "2026-07-23T01:56:25.994Z" }, + { url = "https://files.pythonhosted.org/packages/97/ea/dbaed0d73e8a69aad653b045dab451c67c2454bb731a37b45a86593e9422/aiohttp-3.14.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:1c5ec8fb1bcc31a8466f74aaf26c345d5c386fa4bd08a3f0eb9c7a4a3fe8b5bf", size = 1745813, upload-time = "2026-07-23T01:56:28.604Z" }, + { url = "https://files.pythonhosted.org/packages/81/1b/6893d4bc57e434fc93a6c9217c637d967a0b651d989f6e3265179375754a/aiohttp-3.14.3-cp314-cp314-win32.whl", hash = "sha256:38901a84da3ce22249f6e860bf8f90d141bcab7da090cc398f8bb58c0e44b7da", size = 455872, upload-time = "2026-07-23T01:56:31.031Z" }, + { url = "https://files.pythonhosted.org/packages/f5/8b/c7baa1ba1eda4db6989baefe5de6d99834921b84ebd7918624febcb9f290/aiohttp-3.14.3-cp314-cp314-win_amd64.whl", hash = "sha256:8b3b60de05f3dcb6f6a00f818bb2ec781cee4de0645f59ccaf99b1d1823b6100", size = 481030, upload-time = "2026-07-23T01:56:33.365Z" }, + { url = "https://files.pythonhosted.org/packages/22/8c/c29d067df825a2df88ca432db848aa2fe8199598359cc06c12b09320cac9/aiohttp-3.14.3-cp314-cp314-win_arm64.whl", hash = "sha256:1576145bdceeb92382d899751e12743a3a5b8e460a841e3e50543859e54864dc", size = 453669, upload-time = "2026-07-23T01:56:35.731Z" }, + { url = "https://files.pythonhosted.org/packages/6a/a4/9c033beb355d39b6147980597ec9645e4729243f686ee4dc73945de72030/aiohttp-3.14.3-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:8800c996b01c2772a783e3e46f3e1abd5823029adca0df54231960de9bfefa5b", size = 791403, upload-time = "2026-07-23T01:56:37.972Z" }, + { url = "https://files.pythonhosted.org/packages/80/ca/87c32a0a7704583cfc49660bd817889bae5b830bf53b5dcb4e92145ac2da/aiohttp-3.14.3-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:ebe8e504f058fe91223351cecd2d9d6946c9d241bb0250d898ffbdf584cc72b0", size = 526413, upload-time = "2026-07-23T01:56:40.523Z" }, + { url = "https://files.pythonhosted.org/packages/9e/d8/8ec0e471248c500acdce2be3f46db8fb62b5eb60efef072529cc85ee1d26/aiohttp-3.14.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:30402d03a7c0ff52bce290b57e564e9079fd9d0cb545c8aba73f86a103162d2e", size = 532135, upload-time = "2026-07-23T01:56:42.876Z" }, + { url = "https://files.pythonhosted.org/packages/fe/45/f8919fd936e8b79fcd9bda7b6d8e62613462a713f4f17987fd7c34399142/aiohttp-3.14.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9fc7b5bfec6573f3ae844f457fdde5adeb713f8b8e4a81ad64fc207b49383716", size = 1922742, upload-time = "2026-07-23T01:56:45.528Z" }, + { url = "https://files.pythonhosted.org/packages/f6/ec/9ca76b28a27525b0cc53e20842e0228b022f301ce1f436b7d814b4aaf2df/aiohttp-3.14.3-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:8a5fd34f7f7410d1730d5c2ba873cacb2eed3fede366feb268a70ba22581ed8f", size = 1787371, upload-time = "2026-07-23T01:56:48.045Z" }, + { url = "https://files.pythonhosted.org/packages/b1/04/6acdbf17315f7b55f1937e3387acb89a3cddeb4995689553d064af8e92ab/aiohttp-3.14.3-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:270d3dace9ca2f10f0da5d8ebe519b7a310fc6112ed916e32df5866df0888553", size = 1912623, upload-time = "2026-07-23T01:56:50.605Z" }, + { url = "https://files.pythonhosted.org/packages/86/e6/438b0c79ca6f45eb9fd9817dd4c01a91919a38c0de5ee9e05e2b4dc0ece7/aiohttp-3.14.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3ae5b3a59436d089b5395d910121a390feed4d00578eb95a0fd1a329fe963100", size = 2005515, upload-time = "2026-07-23T01:56:53.153Z" }, + { url = "https://files.pythonhosted.org/packages/bb/6b/62cbd6577758699525f5c712d1ddef57d9875fbab0ae8d5f5a202fd598f8/aiohttp-3.14.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2498f0fe69ead802f9675beca44a7c21c62fdaa4ec5145ea1c3ad6edbee29f85", size = 1879906, upload-time = "2026-07-23T01:56:55.818Z" }, + { url = "https://files.pythonhosted.org/packages/00/95/18bcbf830a21dc3aae24d8f6b6feaf3db1d2090242d00a7868db2ffb0b67/aiohttp-3.14.3-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a0dc483c00da8b673abbb367eb6f8d8f4bcec30eb58529ea13cb42e7fd2dfa33", size = 1675849, upload-time = "2026-07-23T01:56:58.861Z" }, + { url = "https://files.pythonhosted.org/packages/a9/19/47f4968659c5e23606c3790c80fc624e691c153d036148449ee84d31b287/aiohttp-3.14.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c7d3a97c678d34fc5b59da671ee9cd630096ddc643e7b5a30d54a2a6f3574d3f", size = 1843496, upload-time = "2026-07-23T01:57:01.591Z" }, + { url = "https://files.pythonhosted.org/packages/64/af/38c33c4dd82fddcb4e56c4653b6f1072a8edbc6b7fa15809f14932c41e2d/aiohttp-3.14.3-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:f8fb78a83c9e5f741ca3a68cfb455c1f5bb83b4e7249a3848b3cd78d0a8563b0", size = 1827746, upload-time = "2026-07-23T01:57:05.131Z" }, + { url = "https://files.pythonhosted.org/packages/a1/9d/0537cda4885ac8f5b7053d164dd06312f4c483a4edcb8ee5b8aaf2a989bf/aiohttp-3.14.3-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:74ab5b6a9fb13e873e5a90946588baecaf488745e1db1a4a5c433f971f035098", size = 1853810, upload-time = "2026-07-23T01:57:08.043Z" }, + { url = "https://files.pythonhosted.org/packages/19/fe/26f9c5e6458385aa86497836b0dea6fb2f027827d63f37c7856cce9286ee/aiohttp-3.14.3-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:bd52f811e65f6fb634b1047159657c98f52b407f8efec907bcfc09da9a4c0a25", size = 1668895, upload-time = "2026-07-23T01:57:10.837Z" }, + { url = "https://files.pythonhosted.org/packages/ec/4c/618b1db9b9ba079b8875d2cdf78e7c4a3bf72903bd5850fee7dd9544600a/aiohttp-3.14.3-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:f0f177d1b195b9e06376cfd7d308d8a1b920909a609d03ac82a8c73bbb16d3b9", size = 1883833, upload-time = "2026-07-23T01:57:13.672Z" }, + { url = "https://files.pythonhosted.org/packages/94/c6/bd959bd1e4771f9fd944e9e436224c48c77b018b73b519b5aad346335bcc/aiohttp-3.14.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:498c6c623134f8e09a3c4e60bcd607a0b4590dd7dbf08dd40851b27cbb520ccb", size = 1844251, upload-time = "2026-07-23T01:57:16.593Z" }, + { url = "https://files.pythonhosted.org/packages/5e/19/08d41839658bdd44a0ed2480f3891705ecb487ce28c0dde62c9040c997e0/aiohttp-3.14.3-cp314-cp314t-win32.whl", hash = "sha256:b304db572b4368edd8dda8a2274f73156fe15558fca4a917cb8a09fc47af5963", size = 474180, upload-time = "2026-07-23T01:57:19.306Z" }, + { url = "https://files.pythonhosted.org/packages/99/5d/3cd6ef0a2b2851f7ab913b5b079334781bd50ff56a323e4454063377a080/aiohttp-3.14.3-cp314-cp314t-win_amd64.whl", hash = "sha256:b20032766aedf6261c7a566585a40867d092ac03a0d81592d5370ef9b054f99b", size = 500528, upload-time = "2026-07-23T01:57:21.762Z" }, + { url = "https://files.pythonhosted.org/packages/a4/37/cfd1ed540a4d318da025590d96b728e63713c09e9377950fc655dadeb856/aiohttp-3.14.3-cp314-cp314t-win_arm64.whl", hash = "sha256:2e1161602f45a54de2ce0905243a95f58cb42dcd378402f3697f5e0b21e9d2e7", size = 469280, upload-time = "2026-07-23T01:57:24.241Z" }, +] + +[[package]] +name = "aiosignal" +version = "1.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "frozenlist" }, + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +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 = "annotated-doc" +version = "0.0.5" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/5a/8e/38aa427ed5402449e226975b649c5dc73ccadfefeb95e6aecb8f8ea4b6b6/annotated_doc-0.0.5.tar.gz", hash = "sha256:c7e58ce09192557605d8bbd92836d7e1d520ac9580096042c0bfd197efacf1bb", size = 10758, upload-time = "2026-07-28T13:50:58.129Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3e/30/e900b21425a860e195f32e37657aa1f7c7f2b1bfb26f03ca209b90933c06/annotated_doc-0.0.5-py3-none-any.whl", hash = "sha256:117bac03a25ede5df5440e855b32d556049ca169ead221505badf432fed4b101", size = 5302, upload-time = "2026-07-28T13:50:57.239Z" }, +] + [[package]] name = "annotated-types" version = "0.7.0" @@ -22,6 +190,429 @@ 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 = "anyio" +version = "4.15.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "idna" }, + { name = "typing-extensions", marker = "python_full_version < '3.15'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a9/d2/f4d173e22df740bc37b1db102b386ba719b66e95b0f0d751f556b387e6d2/anyio-4.15.1.tar.gz", hash = "sha256:9f28306018cbd6d329e64a36d58256edff76dd996fe423bc957326e578b82a94", size = 276966, upload-time = "2026-09-05T10:42:39.44Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/12/b8/4bd346e22b28902df4d651910f5242c28d84e4a5c2435ca5c3f797ed7e2e/anyio-4.15.1-py3-none-any.whl", hash = "sha256:6152fdbbf9a77fdec97731721bebf7c4c44f7c29b424b0065826173efc7ed101", size = 132079, upload-time = "2026-09-05T10:42:37.923Z" }, +] + +[[package]] +name = "appnope" +version = "1.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/11/f7/a82489c2b6ebe32d3e2831895ae19c77861f0eadf3bb16034484d965dbb2/appnope-1.0.0.tar.gz", hash = "sha256:685db59cb6043c3c2e528adc0b3bce3a5f8d09bcf7492c6ea650d1b7421f3c49", size = 5454, upload-time = "2026-08-20T21:36:13.748Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/46/c7/6b687cb0f83d2a51017d47953f2ee430ffad6fec2a8ebc964e0718a33eb1/appnope-1.0.0-py3-none-any.whl", hash = "sha256:6fe0c04218aab65c54c4ff81638cdbf848d89f5653b74d68638a137f200dd16e", size = 4158, upload-time = "2026-08-20T21:36:12.444Z" }, +] + +[[package]] +name = "argon2-cffi" +version = "25.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "argon2-cffi-bindings" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/0e/89/ce5af8a7d472a67cc819d5d998aa8c82c5d860608c4db9f46f1162d7dab9/argon2_cffi-25.1.0.tar.gz", hash = "sha256:694ae5cc8a42f4c4e2bf2ca0e64e51e23a040c6a517a85074683d3959e1346c1", size = 45706, upload-time = "2025-06-03T06:55:32.073Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4f/d3/a8b22fa575b297cd6e3e3b0155c7e25db170edf1c74783d6a31a2490b8d9/argon2_cffi-25.1.0-py3-none-any.whl", hash = "sha256:fdc8b074db390fccb6eb4a3604ae7231f219aa669a2652e0f20e16ba513d5741", size = 14657, upload-time = "2025-06-03T06:55:30.804Z" }, +] + +[[package]] +name = "argon2-cffi-bindings" +version = "26.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cffi" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/0b/43/bb8b6e8708d49a5ab36781333af092d9f483b198a2710d01281204640055/argon2_cffi_bindings-26.1.0.tar.gz", hash = "sha256:63505c71542a44b68b1e38060450fb006404170da375feb31af153e7f9c6205d", size = 1790807, upload-time = "2026-08-20T07:44:22.492Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e7/d2/0ae991f1b2181e5be49007c574710a800ad36c2978683addb3e67c474e55/argon2_cffi_bindings-26.1.0-cp310-abi3-macosx_11_0_arm64.whl", hash = "sha256:21ca0396fe5ec995dd54431c32698189666f9224810acfa752e50d2bd94d9df2", size = 25521, upload-time = "2026-08-20T07:32:43.019Z" }, + { url = "https://files.pythonhosted.org/packages/7e/e4/ad91d8297638aa2258aad4501c306aca99480dfe76ccd638173fa3702db9/argon2_cffi_bindings-26.1.0-cp310-abi3-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:78de2d65e0b9ea7ce9d1b1c3e87297b2d7305a02c266ee2a2d6910daddd7ee69", size = 27177, upload-time = "2026-08-20T07:32:44.158Z" }, + { url = "https://files.pythonhosted.org/packages/6f/86/5363df11b86d02cf3662208e7406496327649cc90eb365bf6f4e8a54a41f/argon2_cffi_bindings-26.1.0-cp310-abi3-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:27f1821903e2ceadcb88ec2b45ef190897b7682449c772f4d9b53e42c520cf29", size = 26597, upload-time = "2026-08-20T07:32:45.172Z" }, + { url = "https://files.pythonhosted.org/packages/f4/b5/a14dcc592652347dad23ee93b278a4da5d2a25c9ed3ebd10d68eea823a4f/argon2_cffi_bindings-26.1.0-cp310-abi3-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d88e5f7e60f28ae0b0cc6b2f16c43e87cd642a196a86f85e0d8bb6fe016fc16d", size = 27403, upload-time = "2026-08-20T07:32:46.13Z" }, + { url = "https://files.pythonhosted.org/packages/b3/81/b4a20d4902af7f796390bf9245ff83c5217dfa7367efa1d14986956c482b/argon2_cffi_bindings-26.1.0-cp310-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:34b7d9c24a4165a2c61cc8ae11d44d48c9ce2830fb536cb7914e11fdd9962728", size = 27132, upload-time = "2026-08-20T07:32:47.13Z" }, + { url = "https://files.pythonhosted.org/packages/7e/1b/c8de358af07b1c490e0fcb863ef98e46ddb486e45567aca5a60bd68d9daa/argon2_cffi_bindings-26.1.0-cp310-abi3-musllinux_1_2_riscv64.whl", hash = "sha256:224865cbbcb7a2bd1356741dff12b0134df726b6d44bb7b500df8e303cbd9e81", size = 27588, upload-time = "2026-08-20T07:32:48.087Z" }, + { url = "https://files.pythonhosted.org/packages/48/2f/7ee62a6e79f9309f9d9982d301b22a00010adb580c05c8109b94d7b33de0/argon2_cffi_bindings-26.1.0-cp310-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:ffff613aaa9ce6236766e2fc6dc560bb5abde7a2e2416e3db1f9ae395a2b4dd4", size = 26785, upload-time = "2026-08-20T07:32:48.977Z" }, + { url = "https://files.pythonhosted.org/packages/e9/10/960d0ee93d4897741bcaf4799c697dae2d81499f66fd1ed042a7dd54c1f4/argon2_cffi_bindings-26.1.0-cp310-abi3-win32.whl", hash = "sha256:a86c069c91a747a2c4e5c51473590aeb48172fff9b2130d23729a42d98665ecb", size = 23898, upload-time = "2026-08-20T07:32:50.114Z" }, + { url = "https://files.pythonhosted.org/packages/6d/3a/0cc14a05810e6add9bce5e87693334baa2222de5f647fa31781885b6573f/argon2_cffi_bindings-26.1.0-cp310-abi3-win_amd64.whl", hash = "sha256:2c36ff87b5dfaa477d0bd51e9d7f6abdae7c8955d2983c97419085d842154b3e", size = 25730, upload-time = "2026-08-20T07:32:51.091Z" }, + { url = "https://files.pythonhosted.org/packages/4e/db/d83cf2af140547f0b9cdaece05b2dc2dcbf991be4667331d073eff771435/argon2_cffi_bindings-26.1.0-cp310-abi3-win_arm64.whl", hash = "sha256:f9c4420a7a864fe1b86ce35befc95b8e39fb852493b81cf798671ddc265de638", size = 24478, upload-time = "2026-08-20T07:32:52.111Z" }, + { url = "https://files.pythonhosted.org/packages/bb/5f/f652055e18d2627e2eed94c7f31a792127cfe38df786635395d742321674/argon2_cffi_bindings-26.1.0-cp313-cp313-pyemscripten_2025_0_wasm32.whl", hash = "sha256:af11ac37a7c53dc16cb7950a6190851b0870fe218b6c60c0bb7ac355234e3083", size = 15434, upload-time = "2026-08-20T07:32:53.143Z" }, + { url = "https://files.pythonhosted.org/packages/76/38/de696045960f5b846d428c0fb6c130ed3da87aac2af209b05c193815404c/argon2_cffi_bindings-26.1.0-cp314-cp314-pyemscripten_2026_0_wasm32.whl", hash = "sha256:db0fcd827ca61622a01b220aadfbece01939acf53888f2cb98cd93e9b1e2c97e", size = 15449, upload-time = "2026-08-20T07:32:54.075Z" }, + { url = "https://files.pythonhosted.org/packages/91/0a/c25af768f6b75a5a71e31207f87c540656b2808c015260444a22763221ad/argon2_cffi_bindings-26.1.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:28524438cd3e723f25412f63d4fd516ff5bae9ae5aa56acbe2a1404398a0cf31", size = 25683, upload-time = "2026-08-20T07:32:55.05Z" }, + { url = "https://files.pythonhosted.org/packages/a8/7e/be212c751ab0bcea7f646615f933bf262e8e50b3f7bef32f861d0a2d066b/argon2_cffi_bindings-26.1.0-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ac82fc756a446b6ccd7139ce70efa9d8bbe541e7ad579a12dcb52764b7175c5f", size = 27311, upload-time = "2026-08-20T07:32:56.166Z" }, + { url = "https://files.pythonhosted.org/packages/a6/ee/f84b28e4afd13d3cac36c1d8fa8c239d2dc2c51cd978d02ee5d5ad98d9bb/argon2_cffi_bindings-26.1.0-cp314-cp314t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6a4e68eed961a8de6928d1c17ff3dc2a547e0e923c17f8f1cd79fb7bc9502f98", size = 26771, upload-time = "2026-08-20T07:32:57.206Z" }, + { url = "https://files.pythonhosted.org/packages/21/c3/95c07a023691ecd529da9cb6a8f0779e13ebc1bdfaa86d145fdc1c6e7e79/argon2_cffi_bindings-26.1.0-cp314-cp314t-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:151dfaad9de753f4af2a7854e707e4784f2acc434340ade64239c5b104b2d605", size = 27568, upload-time = "2026-08-20T07:32:58.361Z" }, + { url = "https://files.pythonhosted.org/packages/e6/31/3a18e31406d8694b4d6a31573c3e572fff6bed318bb744453eb653766d22/argon2_cffi_bindings-26.1.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:061a6919145bbf282ebf1f9c59d3135d4833c25313c8595c0d68cf7712ddfce2", size = 27280, upload-time = "2026-08-20T07:32:59.343Z" }, + { url = "https://files.pythonhosted.org/packages/0b/39/d4be4577e178b2397aa5b5575c8a309bf0da2afe05fe0c72c8f398662d63/argon2_cffi_bindings-26.1.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:62ff20cd130c956c7c9144d5fe35228f98b51c579b2439e988b27ef93e16c02a", size = 27776, upload-time = "2026-08-20T07:33:00.325Z" }, + { url = "https://files.pythonhosted.org/packages/71/47/78f4dd96f7411339f723b96fe24039c1bd5835102b8a5ba71ac4ec712ac7/argon2_cffi_bindings-26.1.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:19423e5d7ac1cc354baab59eaabf18db2ec04ef6593b5abe5a34f323c4a8f87a", size = 26932, upload-time = "2026-08-20T07:33:01.272Z" }, + { url = "https://files.pythonhosted.org/packages/3b/cd/96bfd37434cc0a848a9066c291d84b28846c4c9ea289ed9866b1164d622b/argon2_cffi_bindings-26.1.0-cp314-cp314t-win32.whl", hash = "sha256:4f84cdd868978d7b7350a566c254042d44216d9e37f241f3a6d3b1dfebeede35", size = 24878, upload-time = "2026-08-20T07:33:02.189Z" }, + { url = "https://files.pythonhosted.org/packages/f1/42/d8b6810abd9b1bd2f47ebbccf460da59c9f32e94888bea4f7b137d998797/argon2_cffi_bindings-26.1.0-cp314-cp314t-win_amd64.whl", hash = "sha256:2b741888c93147444fdfc851abd81cc207f37f7f7da42062a00deb3888e57da8", size = 26656, upload-time = "2026-08-20T07:33:03.222Z" }, + { url = "https://files.pythonhosted.org/packages/a9/d1/095d95eaf2ed1d9f77268cf3291bde148c6cd56121f8db2c74c1ba618a0e/argon2_cffi_bindings-26.1.0-cp314-cp314t-win_arm64.whl", hash = "sha256:6ab674f668d5962a3a4136ae0812519b0f1586874263723a32181d60d64137e1", size = 25378, upload-time = "2026-08-20T07:33:04.332Z" }, + { url = "https://files.pythonhosted.org/packages/66/cb/214092c39c4dbcb72cf98b12234ddac2221f8fe2c0acf29c6a70fa83be53/argon2_cffi_bindings-26.1.0-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:1d98e33bd8bd67d7206c124e200bf2229c4cfa8c9c19f7b44a897f0fc71837eb", size = 25683, upload-time = "2026-08-20T07:33:05.337Z" }, + { url = "https://files.pythonhosted.org/packages/83/e5/02015b83e9b05ccb85ff2ced424cf6e83a12d3810bc7f66d679a92b69ffb/argon2_cffi_bindings-26.1.0-cp315-cp315t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ccaf0a46cbb380f1fd102a874e32aa629fd3cb0c0e94f4943fa1f6d5edc5dac6", size = 27310, upload-time = "2026-08-20T07:33:06.344Z" }, + { url = "https://files.pythonhosted.org/packages/c3/4a/85e612787d0796878b3b4f6bd53dcd5484b6fe7b64cc6fc7b6e6a04cf835/argon2_cffi_bindings-26.1.0-cp315-cp315t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f0c3103fcff20183e593459cfea6e012281c0e76ae3ed8b5565ad1b92eac3990", size = 26771, upload-time = "2026-08-20T07:33:07.429Z" }, + { url = "https://files.pythonhosted.org/packages/f6/84/ccb003b6f9969820e87656398f4d49c857def71a85ca1588a0e809afd7ce/argon2_cffi_bindings-26.1.0-cp315-cp315t-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c49e853a3bef9dd10329f31f702e7fa9b5c58229ff9c2ff6d069efaf09177c08", size = 27569, upload-time = "2026-08-20T07:33:08.598Z" }, + { url = "https://files.pythonhosted.org/packages/88/07/c26b76debf0998ee08fbe947ab2058ac5de37d4b9d46b06c17abaa6c4ce9/argon2_cffi_bindings-26.1.0-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:6376d4b3aca039375ca8bf92f770da0ec424a1ce3a37077a8d3c557411aa56ca", size = 27279, upload-time = "2026-08-20T07:33:09.518Z" }, + { url = "https://files.pythonhosted.org/packages/ee/0d/ead6ddc029f91bc9b9390686dad3c808ab08100d348f6266b5f93f8970ee/argon2_cffi_bindings-26.1.0-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:9bacedc04b0402837586a17f0919e3dfdd95291f441f1f56bd80ec274c2840a1", size = 27774, upload-time = "2026-08-20T07:33:10.728Z" }, + { url = "https://files.pythonhosted.org/packages/7d/47/c108530d9eb86036b78d3af4de28b83b4a2d9a70512bd10ff8e59966aab4/argon2_cffi_bindings-26.1.0-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:76ae29acace5d33355344612844d588e19deaaba4639d8bb01601e4b1418ef36", size = 26933, upload-time = "2026-08-20T07:33:11.661Z" }, + { url = "https://files.pythonhosted.org/packages/a9/02/0bfc59e781c89acf64c31c388aade9d9d1c1ea38aa1ba1292fe07f607fe9/argon2_cffi_bindings-26.1.0-cp315-cp315t-win32.whl", hash = "sha256:df612391feca41c44d20118f3b88d1b86419465cd1f5496859f715ca60ec2210", size = 24875, upload-time = "2026-08-20T07:33:12.616Z" }, + { url = "https://files.pythonhosted.org/packages/61/c7/c3e46068cddffccecb8ad94d71135e9bf62bbc789589e7dfadc7c6f59214/argon2_cffi_bindings-26.1.0-cp315-cp315t-win_amd64.whl", hash = "sha256:1a0a29ed86960e44eaace7e081bdfab4f08b012fd96ec8edba71e2ad020939e4", size = 26655, upload-time = "2026-08-20T07:33:13.521Z" }, + { url = "https://files.pythonhosted.org/packages/f4/ca/18b9c8c45fecf34b9100ec6d7946057f14a158f2eaa20ea123a3e82351cb/argon2_cffi_bindings-26.1.0-cp315-cp315t-win_arm64.whl", hash = "sha256:d157ddfab1e8b21f2f1dedda9c09645d98b5ed0b667b0626be600a345d426440", size = 25376, upload-time = "2026-08-20T07:33:14.491Z" }, + { url = "https://files.pythonhosted.org/packages/a0/b9/97f0370f99611b14efd384918613dd5cbda75f28d9bb1b677aacfeaa17df/argon2_cffi_bindings-26.1.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:19b562b1de4b9052ef1214a2821c44b6e6f22945daa102c32ae4eff929d8b6d8", size = 23055, upload-time = "2026-08-20T07:33:19.716Z" }, + { url = "https://files.pythonhosted.org/packages/ae/70/7eb3fe7bf00103cbbb569c51aef150661f22b734a782673a600ff0f52309/argon2_cffi_bindings-26.1.0-pp311-pypy311_pp73-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:49d525938467d52c923a890153c99087c9d5a937d1f6b585dbdba34ec82e397a", size = 24869, upload-time = "2026-08-20T07:33:20.671Z" }, + { url = "https://files.pythonhosted.org/packages/5b/4b/9d5919c6cb1f15df7406af0f99b048bd93936f112e3e8f4c8077bc2a9110/argon2_cffi_bindings-26.1.0-pp311-pypy311_pp73-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1b0bcac4d490a237e18cf91f57352920c29f77f2fa39efd0813fb81298bf17ba", size = 24216, upload-time = "2026-08-20T07:33:21.653Z" }, + { url = "https://files.pythonhosted.org/packages/a3/34/32109943bace7729233cc4ee78530baa306d8cc3c6501a64ba8cb3b58129/argon2_cffi_bindings-26.1.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:0cc40f7b4050bb93eb67de95d2d759322fc7ce4930b9d645581ecf4913ec651e", size = 23584, upload-time = "2026-08-20T07:33:22.613Z" }, +] + +[[package]] +name = "arrow" +version = "1.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "python-dateutil" }, + { name = "tzdata" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b9/33/032cdc44182491aa708d06a68b62434140d8c50820a087fac7af37703357/arrow-1.4.0.tar.gz", hash = "sha256:ed0cc050e98001b8779e84d461b0098c4ac597e88704a655582b21d116e526d7", size = 152931, upload-time = "2025-10-18T17:46:46.761Z" } +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 = "asttokens" +version = "3.0.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/25/1e/faf0f247f6f881b98fc4d6d07e14085cb89d13665084e6d6ac1dc2c03d0b/asttokens-3.0.2.tar.gz", hash = "sha256:3ecdbd8f2cc195f53ccada3a613538bb5f9ef6f6869129f13e03c30a677b8fe2", size = 63136, upload-time = "2026-07-12T03:31:49.084Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d4/2b/04b8a15f3a1c77bc79ddf5c73875327f34b4fa75982df2b76e45e402d364/asttokens-3.0.2-py3-none-any.whl", hash = "sha256:9da13157f5b28becde0bd374fc677dcd3c290614264eff096f167c469cd9f933", size = 28702, upload-time = "2026-07-12T03:31:47.542Z" }, +] + +[[package]] +name = "async-lru" +version = "2.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e8/1f/989ecfef8e64109a489fff357450cb73fa73a865a92bd8c272170a6922c2/async_lru-2.3.0.tar.gz", hash = "sha256:89bdb258a0140d7313cf8f4031d816a042202faa61d0ab310a0a538baa1c24b6", size = 16332, upload-time = "2026-03-19T01:04:32.413Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e5/e2/c2e3abf398f80732e58b03be77bde9022550d221dd8781bf586bd4d97cc1/async_lru-2.3.0-py3-none-any.whl", hash = "sha256:eea27b01841909316f2cc739807acea1c623df2be8c5cfad7583286397bb8315", size = 8403, upload-time = "2026-03-19T01:04:30.883Z" }, +] + +[[package]] +name = "attrs" +version = "26.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/9a/8e/82a0fe20a541c03148528be8cac2408564a6c9a0cc7e9171802bc1d26985/attrs-26.1.0.tar.gz", hash = "sha256:d03ceb89cb322a8fd706d4fb91940737b6642aa36998fe130a9bc96c985eff32", size = 952055, upload-time = "2026-03-19T14:22:25.026Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/64/b4/17d4b0b2a2dc85a6df63d1157e028ed19f90d4cd97c36717afef2bc2f395/attrs-26.1.0-py3-none-any.whl", hash = "sha256:c647aa4a12dfbad9333ca4e71fe62ddc36f4e63b2d260a37a8b83d2f043ac309", size = 67548, upload-time = "2026-03-19T14:22:23.645Z" }, +] + +[[package]] +name = "babel" +version = "2.18.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7d/b2/51899539b6ceeeb420d40ed3cd4b7a40519404f9baf3d4ac99dc413a834b/babel-2.18.0.tar.gz", hash = "sha256:b80b99a14bd085fcacfa15c9165f651fbb3406e66cc603abf11c5750937c992d", size = 9959554, upload-time = "2026-02-01T12:30:56.078Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/77/f5/21d2de20e8b8b0408f0681956ca2c69f1320a3848ac50e6e7f39c6159675/babel-2.18.0-py3-none-any.whl", hash = "sha256:e2b422b277c2b9a9630c1d7903c2a00d0830c409c59ac8cae9081c92f1aeba35", size = 10196845, upload-time = "2026-02-01T12:30:53.445Z" }, +] + +[[package]] +name = "beautifulsoup4" +version = "4.15.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "soupsieve" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/43/65/318323f98dbee45d42dff61d8f047181bc6f2268a9068cfad035a46be5af/beautifulsoup4-4.15.0.tar.gz", hash = "sha256:288e3ca7d54b06f2ac191970bc275c1939cb46d450b255bf6718b04aa37ab4f7", size = 632571, upload-time = "2026-06-07T16:44:20.453Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/88/c6/92fcd42f1ba33e1184263f25bfabf3d27c383410470f169e4b8163bf9c17/beautifulsoup4-4.15.0-py3-none-any.whl", hash = "sha256:d6f88de62e1d4e38ecb1077eb9724cd0eff29d2a08ca16a401e9b9e93f117cf9", size = 109924, upload-time = "2026-06-07T16:44:21.566Z" }, +] + +[[package]] +name = "bleach" +version = "6.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "webencodings" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/48/3c/e12ac860709702bd5ebeb9b56a4fe334f1001246ee1b8f2b7ee28912df7d/bleach-6.4.0.tar.gz", hash = "sha256:4202482733d85cedd04e59fcb2f89f4e4c7c385a78d3c3c23c30446843a37452", size = 204857, upload-time = "2026-06-05T13:01:13.734Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/58/9d/40b6267367182187139a4000b82a3b287d84d745bccd808e75d916920e9d/bleach-6.4.0-py3-none-any.whl", hash = "sha256:4b6b6a54fff2e69a3dde9d21cc6301220bee3c3cb792187d11403fd795031081", size = 165109, upload-time = "2026-06-05T13:01:12.504Z" }, +] + +[package.optional-dependencies] +css = [ + { name = "tinycss2" }, +] + +[[package]] +name = "certifi" +version = "2026.7.22" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a3/c2/24167ea9858356b47a87a50d39908bfdb72ceeefe0041586e704e5376b3a/certifi-2026.7.22.tar.gz", hash = "sha256:741e2c3b351ddf169a738da9f2c048608ff7f2c5cc02f1ebc6b118bb090d5d55", size = 138112, upload-time = "2026-07-22T03:35:12.644Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0b/a7/71ac2cff56fec219ed242bb11b8efb69fcc4bec75db06fb7bfe35de520e6/certifi-2026.7.22-py3-none-any.whl", hash = "sha256:62f22742b58a1a33014a2b6b706588a8d7e2a88ae7bd1a6ebe8c992928483775", size = 136983, upload-time = "2026-07-22T03:35:11.276Z" }, +] + +[[package]] +name = "cffi" +version = "2.1.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pycparser", marker = "implementation_name != 'PyPy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/9e/ef/008a1939e372c06329a3fce4279c02f328488f3526744906eeec3da7ad5f/cffi-2.1.1.tar.gz", hash = "sha256:dd31f52ea1086513bb9df30f8fcee9b8918323ae067a3d5b78bc826a000712be", size = 530807, upload-time = "2026-08-03T21:21:18.939Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/70/d2/16d99a0c4948febc0ebd133a13b2f688ff7f8cb04da971e1128872ce0c03/cffi-2.1.1-cp311-cp311-macosx_10_15_x86_64.whl", hash = "sha256:c8d2c9fd1f2d16f780d15127abb050d13d1a76c03a4bd87d7e4980e45e511e12", size = 183838, upload-time = "2026-08-03T21:19:29.637Z" }, + { url = "https://files.pythonhosted.org/packages/cd/95/31b535a9f0220ae9f357de4a08d57ce89cb417653c2fd9f075f50822a388/cffi-2.1.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:398aff33cee2767e3e781d2554c54bd0dff386bb437581e0d8011fde1a942ec1", size = 184168, upload-time = "2026-08-03T21:19:30.764Z" }, + { url = "https://files.pythonhosted.org/packages/ad/5a/4707a0dc1f203f5dde5a907b0d4e3c25d71120241048bd5bc6f1bb9d4e71/cffi-2.1.1-cp311-cp311-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:154852545011f779917b11c78db2358d095da62a9a172b78ad0a583ee5adc0d0", size = 211805, upload-time = "2026-08-03T21:19:31.867Z" }, + { url = "https://files.pythonhosted.org/packages/ad/66/c19feabb28485b6e0bbaaafa90837a1ef5d302e90f2178bd33f17a49879b/cffi-2.1.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:3311ed60d36f83378794e1009ac6258bafbf81f7888b4caa7b35a521e3f95813", size = 218716, upload-time = "2026-08-03T21:19:32.896Z" }, + { url = "https://files.pythonhosted.org/packages/a7/92/500760486c8baab49a7a8a58ba7fc3355ec3974b454b8a09e528efde9e1d/cffi-2.1.1-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:6e192623c49c94421616a5778fba35cf0d5a8d000650c1967ef4448ee5cdd990", size = 205569, upload-time = "2026-08-03T21:19:34.142Z" }, + { url = "https://files.pythonhosted.org/packages/a5/a7/a67c733254d6e7373f7822f8082d8d6beade791e0cf12a7611f376fa61c7/cffi-2.1.1-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:a6e721d4b0e45d5b65e87534470e67b18dcd092c83f68fba09f152b9cbc061af", size = 204907, upload-time = "2026-08-03T21:19:35.174Z" }, + { url = "https://files.pythonhosted.org/packages/f7/a4/4399daaf8f7dfee9d7c3327fdb0426ee041cc63edc358b93911ceb2bfc7a/cffi-2.1.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:34e261f78cb6ceaaa36f42f2613f4380d94d9c759a9c73c769ee6e0247364632", size = 217807, upload-time = "2026-08-03T21:19:36.286Z" }, + { url = "https://files.pythonhosted.org/packages/28/f7/dabe6da2466ecbd82dc62e7342dc6b1065dad990c06f00f0ede9ebf2a0ed/cffi-2.1.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:7225e4514edb64eb6740324353e0da0711954fd8d7da4576755b1c6e09b697cd", size = 221252, upload-time = "2026-08-03T21:19:37.416Z" }, + { url = "https://files.pythonhosted.org/packages/ce/87/616202d8e51342c07d2534c510111c4cc37201775ce8f60802c9335d1edd/cffi-2.1.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:df913725b79db7bcf03448f36b7bf8815363417d5b58deecf9305e3e30f0f21a", size = 214214, upload-time = "2026-08-03T21:19:38.507Z" }, + { url = "https://files.pythonhosted.org/packages/b4/c6/ab025d75d2c26c19b087c0124e75ee31cb65032f4fe345d356d8c507ab97/cffi-2.1.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f5cfbc5fe74540d335175b656c725d74d90e3730c626d92575eea35029d9afaa", size = 219408, upload-time = "2026-08-03T21:19:39.809Z" }, + { url = "https://files.pythonhosted.org/packages/db/e2/7e8109f65445bdc673a7b54f02c677de462db75674220fd1335efc8eb598/cffi-2.1.1-cp311-cp311-win32.whl", hash = "sha256:f8ec5e643a9a937f64e1999eb9f75d072263751912dc5cd06d3c85f8f44be7c3", size = 174470, upload-time = "2026-08-03T21:19:41.246Z" }, + { url = "https://files.pythonhosted.org/packages/73/c0/77ba02423c2f7d7091143c45cd49e0e6575c4c1967394bb542bd923a9b74/cffi-2.1.1-cp311-cp311-win_amd64.whl", hash = "sha256:42f6930c31dc7f50732c9ae793c2786c7b6b044195967bbdde40bb9be81c4cc0", size = 185096, upload-time = "2026-08-03T21:19:42.615Z" }, + { url = "https://files.pythonhosted.org/packages/7c/47/9f1f85f9672ceda4984dc6c4f8824e8558992a2972c3d3c81fb8eb28d4ba/cffi-2.1.1-cp311-cp311-win_arm64.whl", hash = "sha256:c7659f22557c5a0bc4855cd635f55edec690cc008a40768527762cb9fb263455", size = 179941, upload-time = "2026-08-03T21:19:43.747Z" }, + { url = "https://files.pythonhosted.org/packages/10/69/43965eccfdead3b9220015fd1320e117be8c6ed01a62ffab76eeb752f5d5/cffi-2.1.1-cp312-cp312-macosx_10_15_x86_64.whl", hash = "sha256:c8c69575568085ba0b1b10c0249d779a214aea6f6522e949a0fc9fb0fcb449d0", size = 184821, upload-time = "2026-08-03T21:19:44.887Z" }, + { url = "https://files.pythonhosted.org/packages/54/7d/16e5a096677b5e313ca80cd5e5170efa3ea44624a82bb111925522da64b1/cffi-2.1.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f81b3b8f3d4e343550fa4baa0e479bba9f2d29ce9c2e9b51d1ce1718d7442fcf", size = 184719, upload-time = "2026-08-03T21:19:46.129Z" }, + { url = "https://files.pythonhosted.org/packages/56/e6/8941622732edec876dd17d0453dce07317ae96db34f2ec1436c9d3785986/cffi-2.1.1-cp312-cp312-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:811bd1e21d32de12efca32393a0ab3f5133b54fce9bd44b8bd77ab07da14bf6a", size = 214799, upload-time = "2026-08-03T21:19:47.218Z" }, + { url = "https://files.pythonhosted.org/packages/44/de/f98430906df1545ffde0d543dd124a7a439bc2cd32b36b9c53f805df7333/cffi-2.1.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:68e62fe11f30d5ca8289242866f0a5291402d8529ca2178ab8afc5c9694ae890", size = 222389, upload-time = "2026-08-03T21:19:48.331Z" }, + { url = "https://files.pythonhosted.org/packages/6a/5b/717f1526b9957b34456313c31645c5b82b8fb5c3fe9e4752999be7128bfc/cffi-2.1.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:4a7c934f7360e8cd64fe9efadcbd10c7c6364f531e432b9a4bf5ccbc9e0e8b50", size = 210249, upload-time = "2026-08-03T21:19:49.543Z" }, + { url = "https://files.pythonhosted.org/packages/64/b3/f8aa4f3e34986c7e4ec45072d1b1b9dd295b6b18007b45518d79726dd725/cffi-2.1.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:3143d81e29e1e20a9ce10901ec369012947876596f75a222235965f2b7ae832e", size = 208775, upload-time = "2026-08-03T21:19:50.918Z" }, + { url = "https://files.pythonhosted.org/packages/b1/db/dceb9dd5b231e1da801793f8acc9f3c52a7e1afe40bb1aae37e02b0faad5/cffi-2.1.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c1453022f490d2459a11819d83ad1d586e9ff65a12ac3e705ffebd46d3685dcf", size = 221822, upload-time = "2026-08-03T21:19:52.054Z" }, + { url = "https://files.pythonhosted.org/packages/a0/d2/6cd24ae3be000a634109c247d1475d62e5616d0dc78c82770942ec384248/cffi-2.1.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:208f941bb9d18e768138677f0a6d2ce01f590df56043dda1df1535ac57c88517", size = 225232, upload-time = "2026-08-03T21:19:53.109Z" }, + { url = "https://files.pythonhosted.org/packages/cb/52/3fa190537004dd7f0ab860a6dc7c0175b8667f68d1e618a46f5498d30250/cffi-2.1.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:210019b6c7cf07f081b4c54635c8cf744377001350e29cc0f81c4377b4797735", size = 223597, upload-time = "2026-08-03T21:19:54.515Z" }, + { url = "https://files.pythonhosted.org/packages/80/fb/0bb75b7039588c074b37ae99f40d9bfddf990ecb2fbc346ebccd2e56b9be/cffi-2.1.1-cp312-cp312-win32.whl", hash = "sha256:046bfc24911b37851ee1b51aab8bffe713d89c68c6a057b09484ce9fd5f69b4e", size = 175292, upload-time = "2026-08-03T21:19:55.566Z" }, + { url = "https://files.pythonhosted.org/packages/d9/79/615cc094e2fb508cade7de88d3b4f6c4ec2bab695c97bce9153dc65aadf5/cffi-2.1.1-cp312-cp312-win_amd64.whl", hash = "sha256:f53e442b08449d42821fa4a4fba000095af9f62742a500f978a9f557ec44339a", size = 185919, upload-time = "2026-08-03T21:19:56.89Z" }, + { url = "https://files.pythonhosted.org/packages/70/c6/d0ea84713fe46b243a436a18fcd47d639732747e21635c8a27191b06dc30/cffi-2.1.1-cp312-cp312-win_arm64.whl", hash = "sha256:7bde5e4cc5c10140859842b9d383af292b22639a4dffb725314baf45968cef80", size = 180093, upload-time = "2026-08-03T21:19:58.155Z" }, + { url = "https://files.pythonhosted.org/packages/9d/f4/035513d4117049066b4779dc3b7c0c0fdad175fa13731c9f4003f1cd1478/cffi-2.1.1-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:b5bdfd1c873d4e093aabc0ca84c4ca6dbc4f752afb5c86f146d9742580c9da2e", size = 194248, upload-time = "2026-08-03T21:19:59.399Z" }, + { url = "https://files.pythonhosted.org/packages/76/af/2aeb4dbb5fc41a04161ae9ff1518de7cec08e164f44a8ce6a4cf7fd2cd1d/cffi-2.1.1-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:31348097ff5bbe827ccc41795d4dd099d9f0625e7def00ee653c137a490c2a6c", size = 196908, upload-time = "2026-08-03T21:20:00.746Z" }, + { url = "https://files.pythonhosted.org/packages/a7/46/2e5fdde8555706dd98139a910ca11be02809f3f605ce956f655d0214e100/cffi-2.1.1-cp313-cp313-macosx_10_15_x86_64.whl", hash = "sha256:9d2055050ea716bd38b7f7f1579c275386646b4894c155a3e2f3cd62ed41b7c6", size = 184805, upload-time = "2026-08-03T21:20:02.02Z" }, + { url = "https://files.pythonhosted.org/packages/55/41/4c7042f317b9217502988f0873af87e16ad606dc20f84e546e3e6ce9764c/cffi-2.1.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:19ee6127ee34de7d83ce3d371ebc5ed91addbdcc39f9ab15ce4eb35a4e534971", size = 184764, upload-time = "2026-08-03T21:20:03.141Z" }, + { url = "https://files.pythonhosted.org/packages/43/1f/1c3d90d91811c8f86ced9ed637956c54bfe5b79ca98fe976d7f8c8979f6b/cffi-2.1.1-cp313-cp313-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:6a8dddef476fab96d066d578fc88526767b836ab5ab21754e1d5bf3879c31c7c", size = 214722, upload-time = "2026-08-03T21:20:04.377Z" }, + { url = "https://files.pythonhosted.org/packages/37/6f/3b5ce4c3b2192d250f04908f2bfd91ef34552ec8f7716a5d4abdb8d67bb2/cffi-2.1.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f16c709686a78c727bbbf059f92b0bf41c6fc60deec706d2dc19f529175a6125", size = 222369, upload-time = "2026-08-03T21:20:05.544Z" }, + { url = "https://files.pythonhosted.org/packages/02/10/4b3c75dde3d9663c9e02ba05c2668b954f671d4bbe346413ca8c696b295a/cffi-2.1.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:fcd22650c908d7b7da162bbfaab594a1227a15d1643a98c68b122ac642fa2264", size = 210175, upload-time = "2026-08-03T21:20:06.75Z" }, + { url = "https://files.pythonhosted.org/packages/df/62/14f74b9543e605d17701dc797b815958b8bb70b7624ce1b832ddad48ed6c/cffi-2.1.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:aa9511c62d14da7aacc9b4bf51f3f697a621e83b2d6919008243c3aad168eea3", size = 208670, upload-time = "2026-08-03T21:20:08.04Z" }, + { url = "https://files.pythonhosted.org/packages/95/95/86342356ff5953b3fb06f7ef7c5bee212d45e770abc7218d451b9148313c/cffi-2.1.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:a931079504ecc49efed7744c476a5c343a92fabf66dec2db95edb1b2fdc770e2", size = 221824, upload-time = "2026-08-03T21:20:09.274Z" }, + { url = "https://files.pythonhosted.org/packages/eb/ff/7b3429ff53aafe931ed8a5fc69f481bbef7ba6de87ddcbb63d08f483f613/cffi-2.1.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a2d7755bef5a12ed488f4ef1f1b69ee9191d7396083b755a5d2295f6edb4768b", size = 225148, upload-time = "2026-08-03T21:20:10.7Z" }, + { url = "https://files.pythonhosted.org/packages/34/34/a95870b9221e09cf4f2ce3178b1a210abdfe63a1bd357da940418d7b8d15/cffi-2.1.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e0bcb7e0f677f543555d2adff3bf19c05f66cdb4796e5ff602442ab2fe3c4ef7", size = 223564, upload-time = "2026-08-03T21:20:12.165Z" }, + { url = "https://files.pythonhosted.org/packages/70/ea/839b50531021a647fb5e929f72cf97bc1ff702b5472166164b5b6e76b851/cffi-2.1.1-cp313-cp313-win32.whl", hash = "sha256:334644fbac4eff73d985a17a91226df55d0f394160c4cfb880e084c8f7161cac", size = 175263, upload-time = "2026-08-03T21:20:13.559Z" }, + { url = "https://files.pythonhosted.org/packages/60/a6/8b149b2c3f2e11aaa1618ef64500b45f50f22c57a977a4dff1aff1f91042/cffi-2.1.1-cp313-cp313-win_amd64.whl", hash = "sha256:1aa5645c30469b09530c4ebca77ebf8f17618293c58f8549cb1a543a50236e7d", size = 185688, upload-time = "2026-08-03T21:20:14.69Z" }, + { url = "https://files.pythonhosted.org/packages/01/9a/11f687cb39d6a3504060d5242f04f48c735afb4d3d533958a20594890cb2/cffi-2.1.1-cp313-cp313-win_arm64.whl", hash = "sha256:63bbfd5ded17c4840ac07cd8f1c21ba9d9708141f840b324f422f41b207e3973", size = 180078, upload-time = "2026-08-03T21:20:15.917Z" }, + { url = "https://files.pythonhosted.org/packages/d3/7b/d6bbf82b8b96e7391438898c42f5bd96dd02030fd5b64937d248220003e2/cffi-2.1.1-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:7dbb61fe3a7699468030f71bbe5f8a0e326a151daa91beb11a6fc1f980c55e1c", size = 194064, upload-time = "2026-08-03T21:20:17.148Z" }, + { url = "https://files.pythonhosted.org/packages/94/e6/bcc91b283be94735e268487a054004f0aa19947b6348fa367db53230abc8/cffi-2.1.1-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:f24fb43132a4c6b4cb4eb029492919b2db645be6808d738f244fd146c03c32cb", size = 196720, upload-time = "2026-08-03T21:20:18.268Z" }, + { url = "https://files.pythonhosted.org/packages/d9/99/c4b0c17cacdc9c3b8f280026286a9826d6a208c0f047591a3c3ce99b91fd/cffi-2.1.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:d28630f5854ab07ab1fd4aba756de52326c82e6be15d414b12793f1975048b54", size = 184964, upload-time = "2026-08-03T21:20:19.708Z" }, + { url = "https://files.pythonhosted.org/packages/b3/a9/9db617d05d7367c1ad0ab00b3aa6e6f9281edd689b4ee9ea0e5a84e89c97/cffi-2.1.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:661c298b4821edebead0c91edd2b00374d67ad7c5a1f7a91d4442633b79d6a72", size = 184962, upload-time = "2026-08-03T21:20:20.833Z" }, + { url = "https://files.pythonhosted.org/packages/67/b8/b42132ca113dc567d37684437b46ca1dafc885902b02a110a02d5b511857/cffi-2.1.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:58acb8ab8e295e6c5ea12f888cbb13cf21511ef2a3303a23f4325c29d17fe5c1", size = 222328, upload-time = "2026-08-03T21:20:22.118Z" }, + { url = "https://files.pythonhosted.org/packages/80/10/c5c0cbf0a657aecf59ef511409734230bf556f05a0d6c9eed7aa5c0a0166/cffi-2.1.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:456a61fa52d579ebf9df2e9552ead5129855dbaff6c1e5a9b1bc408809bdc062", size = 209985, upload-time = "2026-08-03T21:20:23.401Z" }, + { url = "https://files.pythonhosted.org/packages/d5/6c/bfa0b87b03b9238148beca990292843c9396ba069b54496596594173de7b/cffi-2.1.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:a4f00aa42f75d6e4595e8866e748cc1705adc0cddfeb2ca86d0d03993d63ba03", size = 208530, upload-time = "2026-08-03T21:20:24.628Z" }, + { url = "https://files.pythonhosted.org/packages/e9/02/4e7d553a7ac4b4238b38b3c1b80d486e9d4436f8d2acbf87a0997fe3f402/cffi-2.1.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b0431303acaea1089ad4b3e9ce4e6518193def1118d4073ca848635ee4ea2e96", size = 221525, upload-time = "2026-08-03T21:20:25.758Z" }, + { url = "https://files.pythonhosted.org/packages/82/1d/a4aaf9babd75acb4d5f223bff71533bee748dd770a382619a798960ee9ba/cffi-2.1.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:64faea20f4e2613363a1a9b9c7dd73058f3ecd00133a511e72ad7c511658f527", size = 225053, upload-time = "2026-08-03T21:20:26.985Z" }, + { url = "https://files.pythonhosted.org/packages/81/10/5dc0e7bdd18e22107054288283380fc97a06ae3f1656a106908d666a3c88/cffi-2.1.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5c58fe613dc5e5336357eff555824a314d8e43282600435c8d1cb6a7a2fedd13", size = 223213, upload-time = "2026-08-03T21:20:28.277Z" }, + { url = "https://files.pythonhosted.org/packages/0b/e9/d0061c364cde06ee43168a0d076ac1da512cbc380d44767b844ba34fe2b6/cffi-2.1.1-cp314-cp314-win32.whl", hash = "sha256:1a18a57b58cfb21fc28d72e876acf10eaed67a1ed96226f92af4df681d571c4c", size = 177682, upload-time = "2026-08-03T21:20:44.288Z" }, + { url = "https://files.pythonhosted.org/packages/a7/06/1c3e01e3ba14c39f6d10bfbac52753b7e22259e38088e5cfe1d704918690/cffi-2.1.1-cp314-cp314-win_amd64.whl", hash = "sha256:3222ba5d678f80a030e6afbcc33dc1ae5cb45facabb61cee2c7016b8432fde48", size = 187949, upload-time = "2026-08-03T21:20:45.623Z" }, + { url = "https://files.pythonhosted.org/packages/87/5b/da4e39efe18eeb89cf580ea9cfc66b6a7c3eadb808fc0cc1d3a295cb5a5d/cffi-2.1.1-cp314-cp314-win_arm64.whl", hash = "sha256:ab36d55f9ed2d067327667c2fea18dda018eb628dd6347aa01dda6cf1f5d3836", size = 182947, upload-time = "2026-08-03T21:20:46.955Z" }, + { url = "https://files.pythonhosted.org/packages/23/59/40338bf421c5accea1d45158170c87006ef1cd371b05c077e76476949728/cffi-2.1.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:7750c6449dff7864bb9bb27ddfb0267756189201a3afc911d82b3caacd70dfc3", size = 188504, upload-time = "2026-08-03T21:20:29.495Z" }, + { url = "https://files.pythonhosted.org/packages/7d/47/5ecf1023850036e674c77ec4de86182d309ae344e39e7cba984b7df5d647/cffi-2.1.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:0beceaabe56af686895136a2de78db54ecd8e4046b236b8fd6d6cb61389e9bf2", size = 188259, upload-time = "2026-08-03T21:20:31.291Z" }, + { url = "https://files.pythonhosted.org/packages/2a/9c/92934c3bea9f785b23eba304538c0b4d37a2a96d2431eb3a1bc87a11aa19/cffi-2.1.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:49cbc70e6542d4ccccb936558d1064a8012541e78f821f955cff24e357776c94", size = 223864, upload-time = "2026-08-03T21:20:32.571Z" }, + { url = "https://files.pythonhosted.org/packages/4d/45/ba4c93527bc38616a8bd36488acb69a2212d60486794f0c1f318949bbb76/cffi-2.1.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:e2d65b31f36619cda3999b78b2aa9632e76b78448e7a56fc4240824200e7c4fc", size = 211538, upload-time = "2026-08-03T21:20:33.808Z" }, + { url = "https://files.pythonhosted.org/packages/80/e9/b6ef565e452acb932fb0cb5443f44a78efbd1233e566f02b5a83855e9115/cffi-2.1.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:28907ab9bfb6aa13184cfc17c6b8e1023c5ab6fd7076d8c20a35e59fe04f8f29", size = 210688, upload-time = "2026-08-03T21:20:34.974Z" }, + { url = "https://files.pythonhosted.org/packages/9a/95/eff5f0cee78d2eabc7eebffec40d3fc1876b5f3c95582e018bb4b99601f2/cffi-2.1.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:51b31d1c98274844cfd7838ce00bfc27c7423a4dc00fc0772fc3331c2cc90676", size = 223803, upload-time = "2026-08-03T21:20:36.564Z" }, + { url = "https://files.pythonhosted.org/packages/fa/01/579d39fb8bef00a335a23d83757b44feb24cd6345a2c451b64cb67b9c362/cffi-2.1.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:5e7cecbaadb83884793e05828cee59b210b24583b9c7425d0ba6a754fe22eb4e", size = 226763, upload-time = "2026-08-03T21:20:37.816Z" }, + { url = "https://files.pythonhosted.org/packages/8d/b0/0b44f47c60b01b57b6e2bbd92343f13a85a1d93bc46ccf6e47e244acd99c/cffi-2.1.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:25792eac27877609e7bb06d42ff88278a6624fff2ba9bbb523c09616b117e80f", size = 225688, upload-time = "2026-08-03T21:20:38.959Z" }, + { url = "https://files.pythonhosted.org/packages/eb/d2/3b7176cb570a1d3e27faf67b72f591af508036e0d8b2be2ef9af9e8c84bb/cffi-2.1.1-cp314-cp314t-win32.whl", hash = "sha256:8ef53b2de9bcb9197d31854256575d59dbac0cba72ac627bb291ef5eceb74be4", size = 182868, upload-time = "2026-08-03T21:20:40.388Z" }, + { url = "https://files.pythonhosted.org/packages/56/78/31f00c1bcd97c9bbf55f1bfdf5bc809a5de8887473e90bb9960dca825e80/cffi-2.1.1-cp314-cp314t-win_amd64.whl", hash = "sha256:616f097f2fe415bc92a247f02e11f634e1f9e9a83d327e3c915c15089c87869e", size = 194104, upload-time = "2026-08-03T21:20:41.725Z" }, + { url = "https://files.pythonhosted.org/packages/7b/1b/58496f2ed0a35de575250c02a43ab3cc2c04d494a88fed31c1cabc0fd176/cffi-2.1.1-cp314-cp314t-win_arm64.whl", hash = "sha256:ad2c86c495b899d862ea0f4b42891b8713a3bd45dd4105c7fd51c2a72f39f3a5", size = 186402, upload-time = "2026-08-03T21:20:43.042Z" }, + { url = "https://files.pythonhosted.org/packages/c1/8f/9ebe220eab48a093d1a5a5e339ab0dc7316eef3bb04d63c42f0251b61f50/cffi-2.1.1-cp315-cp315-ios_13_0_arm64_iphoneos.whl", hash = "sha256:dddad92b554513a31f272570678ba307fb9f618f05e3d4a5eacafff9eae03e1d", size = 194043, upload-time = "2026-08-03T21:20:48.179Z" }, + { url = "https://files.pythonhosted.org/packages/ff/69/844bad3ece306c4782c2ecb93597035b6690d48704b803914c199da1e8b3/cffi-2.1.1-cp315-cp315-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:da0e573f9f97159390c89d9f1a9e41908b66d408cc5b58d08cf3847d844c531b", size = 196737, upload-time = "2026-08-03T21:20:49.457Z" }, + { url = "https://files.pythonhosted.org/packages/1b/8a/af668013284634733f02d683458a0728739c7d6ddb5e14cb0c20832266fe/cffi-2.1.1-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:fb92203a88b3d3053034db775110081c49d28be6551923805e039924093761e4", size = 184933, upload-time = "2026-08-03T21:20:50.639Z" }, + { url = "https://files.pythonhosted.org/packages/0c/75/2f5207ff6d1a613133b23a5203cc0c2a628313b5eb3974d7956ae3c57950/cffi-2.1.1-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:2ae64be792b8966f2c69538199728b290e34726562896df1e5dc8ffd8d8188e8", size = 185002, upload-time = "2026-08-03T21:20:52.173Z" }, + { url = "https://files.pythonhosted.org/packages/e2/31/9e1313b0a6e30e91b3b3d3fff51ae99c857c07738e3afcce1f7334e1b7ab/cffi-2.1.1-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:507a24c282e0f42f8ed737cf048572cbf580468da5555764a8331735e9c736b6", size = 222271, upload-time = "2026-08-03T21:20:53.462Z" }, + { url = "https://files.pythonhosted.org/packages/50/e3/f6234a833e6e08c7007003074723c406559eecf9b48dfc97471e5a8eb7a0/cffi-2.1.1-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:246fa40ce8645a614ff682e0b70f37134e460eaf93a775e0cbe3cca585a67a80", size = 209919, upload-time = "2026-08-03T21:20:54.783Z" }, + { url = "https://files.pythonhosted.org/packages/0d/fc/5f74e293fced6edb51af3a46c4ccf6c23c9943774ecb375ddbd522c76add/cffi-2.1.1-cp315-cp315-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:471cee653ae88de62096552e6d24ccb4a5adb8c8c9f10b5054d0122c15bf2779", size = 208529, upload-time = "2026-08-03T21:20:56.066Z" }, + { url = "https://files.pythonhosted.org/packages/44/16/29e6d01b388bef055ecd6ca8244b3f4d336bd09e92d5d892187b9601084e/cffi-2.1.1-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:aeae0e330c9f6acd681f647d46cefd30c29f93e3392882e792e82080c9691399", size = 221630, upload-time = "2026-08-03T21:20:57.336Z" }, + { url = "https://files.pythonhosted.org/packages/a4/18/fa7f1f6857d5eb88a4ca99ffcbfb7c387a287ccc154c64a73e86314745d7/cffi-2.1.1-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:42a494cee34437f05546455144f2b5d9ac09b1face62bcfce597d2e521066688", size = 225134, upload-time = "2026-08-03T21:20:58.675Z" }, + { url = "https://files.pythonhosted.org/packages/e0/9f/e8e3dfa04a1b4c241f8c91faacad872b4d4efd051d49764ad4e2fd4b9fea/cffi-2.1.1-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:cc572dace3f60ef98d7b12ff411d20f5362feb31a0439eab0085bbfd349982d7", size = 223197, upload-time = "2026-08-03T21:20:59.968Z" }, + { url = "https://files.pythonhosted.org/packages/f8/7e/8debeb04f1ab9fe2a6963964cd6f1aaf7192627b83926586a6a4e089c9fa/cffi-2.1.1-cp315-cp315-win32.whl", hash = "sha256:4f42141fc14250de6dde5ee7ea4432be017252d91f19c5ad043c084cea629cac", size = 177683, upload-time = "2026-08-03T21:21:14.901Z" }, + { url = "https://files.pythonhosted.org/packages/e0/31/5158704cc474ab65c1647932e88be78dc0873f47130e253be38bcaf13d01/cffi-2.1.1-cp315-cp315-win_amd64.whl", hash = "sha256:e6e8cff14d6fb0be70a09c0bdc58096f501952d04624ebf867e0e56da2df8960", size = 187897, upload-time = "2026-08-03T21:21:16.108Z" }, + { url = "https://files.pythonhosted.org/packages/cc/4b/b3a2da8570c704ffc0f9762cdc3ec0f02c8573798e0b5cf7f11c82bbb70f/cffi-2.1.1-cp315-cp315-win_arm64.whl", hash = "sha256:27350daa11d4f10c540e6e89dada4c54feb7256ad03e9a4dc075ebad7ba360d1", size = 182935, upload-time = "2026-08-03T21:21:17.271Z" }, + { url = "https://files.pythonhosted.org/packages/d0/ef/5443574510a1207e6f6bc38ba6e1f1de36cb48fef07b2728bb896a21f430/cffi-2.1.1-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:c26608d2222fb1e94487e4a387d85f13eb55d5ed725cb25a0c589ac4ee60e7bc", size = 188464, upload-time = "2026-08-03T21:21:01.163Z" }, + { url = "https://files.pythonhosted.org/packages/7e/ae/a56fa8c4686ad50e148fcbc8d3ae0d03915ff5c30d795058988c24118cef/cffi-2.1.1-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:4be96343e422f2dfcd12ab5c9f5aebe03f82f737c6bffeca6830b3875cb44aab", size = 188262, upload-time = "2026-08-03T21:21:02.382Z" }, + { url = "https://files.pythonhosted.org/packages/53/b2/6187f46f2912276a3ae284076109cc5c8680482f11f766ccf26db4a86427/cffi-2.1.1-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:937c0052c05a31ca1daf18de3158eed4dbfcb9cc107adbea227728d647be701e", size = 223779, upload-time = "2026-08-03T21:21:03.553Z" }, + { url = "https://files.pythonhosted.org/packages/8a/f6/c3ad28bd19f77047a03084424fbd4cbe997303267c14423737324be0385d/cffi-2.1.1-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:df423d40ee8654634421812bc3b196da3f9bd7d32929da813f8394c4348a5358", size = 211520, upload-time = "2026-08-03T21:21:04.863Z" }, + { url = "https://files.pythonhosted.org/packages/a0/cd/ccac9013a5bd9fd764de118674ab9c805b5ca10c19270d90ee273f8b2240/cffi-2.1.1-cp315-cp315t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:a730a083190634c65cca36ba5f489531576ebd79bcd5c8e172130f6453127231", size = 210673, upload-time = "2026-08-03T21:21:06.223Z" }, + { url = "https://files.pythonhosted.org/packages/52/86/2976131c639aead931c5bee5aba67e4b09fbeb8018b6f282f70803f923a7/cffi-2.1.1-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:363e05fa78e15116c3c32c210ee36884fd6b9afa6d440e47112c3bd511d64cb6", size = 223835, upload-time = "2026-08-03T21:21:07.539Z" }, + { url = "https://files.pythonhosted.org/packages/ac/0c/33a7aeab2f9c76918c52e084beb39c570db3588133412929e8ec06fab90b/cffi-2.1.1-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:770de9db11e84213beec501cfcaa013b019820ca881e03344dea5844f7876d94", size = 226705, upload-time = "2026-08-03T21:21:08.774Z" }, + { url = "https://files.pythonhosted.org/packages/e3/26/2cde30fdde421130bfc18f70395731a6e6b2053c6a1978a5258ff04e72fa/cffi-2.1.1-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:7da0c5eff80f0197f3b3d1232ec5a682a9325f4ae9016a78f5f5ca35f9ced1f5", size = 225539, upload-time = "2026-08-03T21:21:09.911Z" }, + { url = "https://files.pythonhosted.org/packages/6d/cd/a361394c94b2129d604bb846f624a8e88255a3ee33129c434a00d715e64f/cffi-2.1.1-cp315-cp315t-win32.whl", hash = "sha256:06c72bb76605a4b0cd0aad6930b69d4baf7dd5d806cfc409b824191099700e66", size = 182707, upload-time = "2026-08-03T21:21:11.226Z" }, + { url = "https://files.pythonhosted.org/packages/9b/b5/ba2b299993c26577d529b6ae29841f9e15b9fcf004d65f423f4fcf94ade9/cffi-2.1.1-cp315-cp315t-win_amd64.whl", hash = "sha256:d9c275eaacd24aa73f94ffd6de08fc3f932424d8b6c376f4bed7cde376fe7bc3", size = 193772, upload-time = "2026-08-03T21:21:12.39Z" }, + { url = "https://files.pythonhosted.org/packages/aa/29/35e016098c814cd93de9cd320c66b5bfba14dc6ecedd3cb518fa7c408c69/cffi-2.1.1-cp315-cp315t-win_arm64.whl", hash = "sha256:d18e5ac0f2f03f4f518d3e23db0f0cad7faa1da8620e9c09461d443bbf6e6692", size = 186360, upload-time = "2026-08-03T21:21:13.636Z" }, +] + +[[package]] +name = "charset-normalizer" +version = "3.5.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e5/3f/143b048436775b0f76ac3eec145c019e8173ccc2885c8f20319b996d5e83/charset_normalizer-3.5.1.tar.gz", hash = "sha256:6117b84ea48435e5356dc737f5121485c30920ba43375fa7b434fd753df0eac3", size = 171764, upload-time = "2026-08-15T08:20:44.807Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6a/b6/034f6802e9c3f6418966cfabb7db8c9252cc2429c5098f41cc43af804149/charset_normalizer-3.5.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:eda059b6bc8bc0812d626fd91a7ce01bf583df0a61296eff390fd94141a34e30", size = 363585, upload-time = "2026-08-15T08:16:46.646Z" }, + { url = "https://files.pythonhosted.org/packages/d5/fa/6a7e2a7c4b5451912b8c417732df79574354443592a88d616de03da66ae5/charset_normalizer-3.5.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:aa2bb0b37202dca27175591f761108b5d34096ade1191ffe4808bdf6b1571488", size = 251189, upload-time = "2026-08-15T08:16:48.287Z" }, + { url = "https://files.pythonhosted.org/packages/a4/c8/ab42b07cfd82e919f427fcfaa7c41abae8242833ad1aad66d42bae40b669/charset_normalizer-3.5.1-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:0b2b1b3fa5670c127b246df1d0c059defd41f689a868a3b9d79df9b1cac42d22", size = 239724, upload-time = "2026-08-15T08:16:49.67Z" }, + { url = "https://files.pythonhosted.org/packages/e7/80/b9348b5d3041209f98b4cdad7655766369233f1d533f4f4f7558e9717bec/charset_normalizer-3.5.1-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6e5e4d73d588ca5ed09df1b7dcd1b203d1df3c542e3f50d126c947d432b10731", size = 280078, upload-time = "2026-08-15T08:16:51.228Z" }, + { url = "https://files.pythonhosted.org/packages/82/38/083a24028304bc85bb9e376fed801178423dcbb67495f73b6ea0624e1894/charset_normalizer-3.5.1-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b54e7e13267d49ffbfe68e25b3cbd774dab38fa37238f71265e91b36146eb21c", size = 276650, upload-time = "2026-08-15T08:16:52.625Z" }, + { url = "https://files.pythonhosted.org/packages/0d/35/731ac04aa0a097fc1c97f0994c375bdb230c6c96619db794208fe664e9ce/charset_normalizer-3.5.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c7b742bf31c88566b4bb6335a7f393bb322e580b6bb98df7bd0c25e6e3519ce8", size = 262325, upload-time = "2026-08-15T08:16:54.085Z" }, + { url = "https://files.pythonhosted.org/packages/f5/28/c2028e7021fb89c6e56868ed0e387b8e9aa811abdd2ab3208d6578d2c930/charset_normalizer-3.5.1-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:6ba32c4d2abf1d2fe7cf27d280f4cca5664233b0f885549c7761719eb977f486", size = 261140, upload-time = "2026-08-15T08:16:55.604Z" }, + { url = "https://files.pythonhosted.org/packages/28/f0/0c0ceec6d98b7daa62e361e418135d59685811d79ba11529aad5cdf15e84/charset_normalizer-3.5.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:0722590aabf9dc6a6c0343d523c05458fa2b5047dbe6302fd526bb570600753f", size = 252791, upload-time = "2026-08-15T08:16:57.103Z" }, + { url = "https://files.pythonhosted.org/packages/f0/3e/48f4cd187b1c33189d86039e9cbe4f92c05454175504b44ff81806d4d1bf/charset_normalizer-3.5.1-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:aa1099b956fb795e686d073568f6dc002a0bb89765ea6d5b055dd7d9bf1b116c", size = 240730, upload-time = "2026-08-15T08:16:58.418Z" }, + { url = "https://files.pythonhosted.org/packages/42/85/f9e22af69af67c54cce42be9455d9c81294f918b4ccc454db01f66efcac2/charset_normalizer-3.5.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:bd6c173f04743d483881bffa1478d5a4624475b8cd1d2194956a75548e191c18", size = 280791, upload-time = "2026-08-15T08:16:59.918Z" }, + { url = "https://files.pythonhosted.org/packages/fd/4c/9044135f42127630b6fa742feb51256353f6ab87a78f2fdd1de3de955a7f/charset_normalizer-3.5.1-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:f298e218441525d3794428b4c8b8fb8662c6d3ea79925d4807ee6b9a96a3bca5", size = 259598, upload-time = "2026-08-15T08:17:01.421Z" }, + { url = "https://files.pythonhosted.org/packages/ba/ed/1dd7cfebb4e75812934c49ca3b79757d11948053f7937ab7070c151f3c55/charset_normalizer-3.5.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:6e2912d4babbc65196ac13c2f53468dc57fb8b9c25ef913e8c59ddf7c6dc0e1b", size = 278217, upload-time = "2026-08-15T08:17:02.782Z" }, + { url = "https://files.pythonhosted.org/packages/bf/eb/239c84503cc9e3ba6eb34686a24bc66e84f3924efdd7e38e751a19f6bc10/charset_normalizer-3.5.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:3d27167433c0d5f18dc850f07d0b3816221984fecdc405d6c157a6f0b8f8e9e6", size = 263417, upload-time = "2026-08-15T08:17:04.216Z" }, + { url = "https://files.pythonhosted.org/packages/37/ab/4e4510e1e288478e2c8333131d1c1382382ba8cd2165053c79e39d1da961/charset_normalizer-3.5.1-cp311-cp311-win32.whl", hash = "sha256:ac00177c4831ffa650f8609e4bdddd5fe09c03b1c0c47acece7e6ea20421598b", size = 181774, upload-time = "2026-08-15T08:17:05.58Z" }, + { url = "https://files.pythonhosted.org/packages/e3/57/32f0ccea59e8612057c61d6fd22ef2cb63cca93c9fe594094919696ac170/charset_normalizer-3.5.1-cp311-cp311-win_amd64.whl", hash = "sha256:f9b1e28d0e8dbfa858abdba91d6b547beaf2df1a59bec6da6faae7b96a4991a9", size = 206653, upload-time = "2026-08-15T08:17:07.075Z" }, + { url = "https://files.pythonhosted.org/packages/17/d4/b65c433fc521e58b5f54293982a5e51c05cb5f2dd3f1c7a6acb65b75324e/charset_normalizer-3.5.1-cp311-cp311-win_arm64.whl", hash = "sha256:ae31a1a1db2ee6cc2942fccaf695c934bc7f3db9f2133a3fef1f367cf1a4ab10", size = 185630, upload-time = "2026-08-15T08:17:08.502Z" }, + { url = "https://files.pythonhosted.org/packages/30/27/78873dc8b6a56357517b74b6bb9568b80450e7bb4f6ef7e3fa9d22aa0bd7/charset_normalizer-3.5.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:5b6d1386bf0096d26d3a863dc0a487a5b4eb9aa93cf5ba69683d29dde6b9d60f", size = 344456, upload-time = "2026-08-15T08:17:10.072Z" }, + { url = "https://files.pythonhosted.org/packages/9a/4c/be49ada26b1f0232d57aa89bbebf997a5cc2332a5616b6eca26ff680044d/charset_normalizer-3.5.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4582c27e8c889d64811987b5967fbd3ae0c823fe1fd933b543d55ac20bb475fa", size = 238530, upload-time = "2026-08-15T08:17:11.563Z" }, + { url = "https://files.pythonhosted.org/packages/76/84/6f1290fa07ae6978d3960caa3eb1b8019bf9284ab7c2297b00c099ef4250/charset_normalizer-3.5.1-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:1d1c7a53a6c2103925cdd6d7229f8c567379f211c869793df679f2e9f738c369", size = 230200, upload-time = "2026-08-15T08:17:12.919Z" }, + { url = "https://files.pythonhosted.org/packages/e7/a0/47b18adeed31c8f16ba9700f32c1b18594cfa09f47eb672a488c273c22bf/charset_normalizer-3.5.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e6621fb2a4988d6e53eedc455e5903e2679f3967b8acb3d639f1b63c14a2e893", size = 262222, upload-time = "2026-08-15T08:17:14.571Z" }, + { url = "https://files.pythonhosted.org/packages/38/fe/341861ac118dae06f3ec0eb487488af52128f2ef2faf0b11003944d22259/charset_normalizer-3.5.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:7c0c10730342b0c9b35dd1d619beb8214e520bd96a1f870f452680b238aab3e0", size = 258951, upload-time = "2026-08-15T08:17:16.158Z" }, + { url = "https://files.pythonhosted.org/packages/6f/89/bb5108dc6c3651dca963f2b0a3ba19bbcb370c94e1b6d3e0e844a58e6dca/charset_normalizer-3.5.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b9af956078716df40d985fb0dfeb2c2120c5ca92ba4ff4b388acfd01cdc14d08", size = 248801, upload-time = "2026-08-15T08:17:17.683Z" }, + { url = "https://files.pythonhosted.org/packages/b1/ba/ef83ae3aca816393decfa3530976f38a79812d707b80b580ac33b83f9877/charset_normalizer-3.5.1-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f9f8405c2c758532c74fed975dbee57be1f31a6e865c031870c79a6ed3212ada", size = 244070, upload-time = "2026-08-15T08:17:19.191Z" }, + { url = "https://files.pythonhosted.org/packages/f6/0b/c5292a2462d69b7378ea89793bbb5b2b6fcf6f7dd6d1667f9619094ad553/charset_normalizer-3.5.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:96fef3e886d6a9874b14f27fc193fbdc69d5d8035783d86aa4e1cea594e695f9", size = 240110, upload-time = "2026-08-15T08:17:20.547Z" }, + { url = "https://files.pythonhosted.org/packages/46/22/111e5be3b740d5c2a5bfcedb3d237b6591e5c2e82ae9d6ffcb121fe0909c/charset_normalizer-3.5.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:5d8531a6569d025f68e2321e7638fb7978f23db58e5f69f56913837aae03816e", size = 232836, upload-time = "2026-08-15T08:17:21.895Z" }, + { url = "https://files.pythonhosted.org/packages/f9/d2/d2aad6fe0dbb44b194bf3becb60f5a0ac48446ade999a47fe7bb41eb09a7/charset_normalizer-3.5.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:aae2ee51122d3ae968a3837d97dc24a0aeebb0dea23694422cd172bd30017cd6", size = 262712, upload-time = "2026-08-15T08:17:23.727Z" }, + { url = "https://files.pythonhosted.org/packages/35/5a/337e4663a5eae6de99db940ee8066d4145caafb61327db62deda15313cce/charset_normalizer-3.5.1-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:7235dc28fc6dd9d832ac7c7bce95367dedb85929f17368a0c2bee1e080b9acbf", size = 242977, upload-time = "2026-08-15T08:17:25.157Z" }, + { url = "https://files.pythonhosted.org/packages/ca/85/f82f8a92e31c7519410e2e1afdc630f28ec47490ce2c09a11c1a43cbb459/charset_normalizer-3.5.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:4abdc5f9ad448c1ecbfae2974b820535d6bc6e7eef63babbab3d81cf46968c71", size = 260207, upload-time = "2026-08-15T08:17:26.602Z" }, + { url = "https://files.pythonhosted.org/packages/b7/52/643d11ffd60e9ac2fd1fb87e167a19285b9eefeff4a40e63c87cbfbeab36/charset_normalizer-3.5.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ba501e667c17d8411f98e67a022d9604ef179aff0e459b7e292c796837c13573", size = 250562, upload-time = "2026-08-15T08:17:27.971Z" }, + { url = "https://files.pythonhosted.org/packages/62/16/46556278c2168d12df9da7fede5dc6fc70e60301b26a82bbeec238c9cfe3/charset_normalizer-3.5.1-cp312-cp312-win32.whl", hash = "sha256:cfa1c0cc3a8f9f53f1243a5a99ac36fd003880199383b37672e86ddda9cb07e2", size = 178507, upload-time = "2026-08-15T08:17:29.277Z" }, + { url = "https://files.pythonhosted.org/packages/9d/7a/4c6c298171e6b3e745633180ff59350fc0ca0db1ffd28df1e369e0579f71/charset_normalizer-3.5.1-cp312-cp312-win_amd64.whl", hash = "sha256:3617ac3cfd8b9888f145ad89dd6e692285834b0201c6074a5eeaad3fd4d668c2", size = 200551, upload-time = "2026-08-15T08:17:30.668Z" }, + { url = "https://files.pythonhosted.org/packages/cd/d7/eb95a042f0dd22e304b0b6472b154f3546a1a039a9ee89ccb2a7f61591fc/charset_normalizer-3.5.1-cp312-cp312-win_arm64.whl", hash = "sha256:88e85ab89cb822c1e635f51d6d32e488f94e002e70e2f492bdb8b945543f345a", size = 180700, upload-time = "2026-08-15T08:17:32.028Z" }, + { url = "https://files.pythonhosted.org/packages/bc/61/2cb6ad133dbbb449fa2d37ccae973232f4827e799af258d15e589a3d1e9e/charset_normalizer-3.5.1-cp313-cp313-android_24_arm64_v8a.whl", hash = "sha256:4f298bdadb8f0b9e5672877f647d1be9373ef5320c9e2f049795e26cad28b6a9", size = 211584, upload-time = "2026-08-15T08:17:33.597Z" }, + { url = "https://files.pythonhosted.org/packages/18/57/a305c968be1ca13f3dd1b32f445877e97addf55d80b65c7cb35fac82b777/charset_normalizer-3.5.1-cp313-cp313-android_24_x86_64.whl", hash = "sha256:88ca277405c2d3b71c4e1c2ee0e7966e807bcba86a69d11e19ba199d18ae4491", size = 223359, upload-time = "2026-08-15T08:17:35.022Z" }, + { url = "https://files.pythonhosted.org/packages/09/0a/d3646670292ce8d8f8cc11ac067d44885e697a5591f57a9221128da5e7b3/charset_normalizer-3.5.1-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:9362dd90aa7dab48c0054a21187791ccf05473f7dba5d92b8033ae62164675e7", size = 194464, upload-time = "2026-08-15T08:17:36.452Z" }, + { url = "https://files.pythonhosted.org/packages/de/93/d51ec556e01042fed6f993ea859311bc7917b466684182fbbceb6ca24762/charset_normalizer-3.5.1-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:977cdbd483a9cff38179bea4fd754289a6f2195c7abd414aba85410b3e66cc5e", size = 197676, upload-time = "2026-08-15T08:17:37.819Z" }, + { url = "https://files.pythonhosted.org/packages/a4/a0/562247944386f7d4ef94467e84876600cc1e0f1b93239aaa9213d2bc3cbd/charset_normalizer-3.5.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:e90251c0c7bdd54a100a0dce3c07b7e637278c93af29dbf78ebb89a58c4bac7d", size = 340473, upload-time = "2026-08-15T08:17:39.303Z" }, + { url = "https://files.pythonhosted.org/packages/31/e7/1d994be1b93d41e9502b8b0460eaa88a1dd8df335df415db87d6c3e91ab2/charset_normalizer-3.5.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:94d78ecec2605a8d0398b0f365d5f12a63248438516f5dac536a5eff7337df4a", size = 240156, upload-time = "2026-08-15T08:17:40.66Z" }, + { url = "https://files.pythonhosted.org/packages/09/53/27923ce5cc6cbccb832037b27dca98882d9c53e9b69e866bbbef4aae7fc8/charset_normalizer-3.5.1-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:d59b75732e9b6f27388e10c14b0259cc5f2e48c78627d185e6a177b58ad3cffe", size = 228246, upload-time = "2026-08-15T08:17:42.003Z" }, + { url = "https://files.pythonhosted.org/packages/ce/48/5a97e84d63af1d55c07439cb80e56d99a8efb4295700eb4e18c0d1615d2c/charset_normalizer-3.5.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:0d929fc574b4d6fd9e7c0f5c2ede8716a41911923aa7fa5fce38e0818aa4a1ac", size = 263660, upload-time = "2026-08-15T08:17:43.627Z" }, + { url = "https://files.pythonhosted.org/packages/7a/c2/071575791dcc88316c0a9a65ce38897a82e4cfe4a325f0f7fe1b1ac47bcf/charset_normalizer-3.5.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:394fea06235c8543390050ed5f529187074b029fb027213f6c46ac11ab5d950e", size = 260354, upload-time = "2026-08-15T08:17:45.094Z" }, + { url = "https://files.pythonhosted.org/packages/fb/af/63240b0c0248c075c2535a1f1bd992821d8251b9f173abc13329661d09e4/charset_normalizer-3.5.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:62b55f6722735a6c472f88361cde6640608773d9443cebdbb51abf436a1fcdd3", size = 250638, upload-time = "2026-08-15T08:17:46.496Z" }, + { url = "https://files.pythonhosted.org/packages/4d/66/70dfad64f15be09c15ccfee81330a7e515895dbe296dd23114e9a231268a/charset_normalizer-3.5.1-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:fa48b1b63d639f9483e0633e092f5851e2348c352f1f9bb6c8182f87884ef876", size = 244583, upload-time = "2026-08-15T08:17:47.963Z" }, + { url = "https://files.pythonhosted.org/packages/c0/24/ef36367d38b9ddd4bccbf72888c342e8de1f5ae506fa0b2dcf970e2732a1/charset_normalizer-3.5.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:c71fb0d56c920c269cd3e2e3fe7c610e3f1fdb21a6ce60efa6430ff63676cea6", size = 242038, upload-time = "2026-08-15T08:17:49.481Z" }, + { url = "https://files.pythonhosted.org/packages/db/ab/55e683ba0fff2e43adafc10daa3001eac90fdaa419a97227d5a7067eedde/charset_normalizer-3.5.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:485a0d363cafefcd2538a73c7c838daa2035f09b2c9f9b5e3133f80c6aeb84c2", size = 233677, upload-time = "2026-08-15T08:17:50.845Z" }, + { url = "https://files.pythonhosted.org/packages/bd/67/0f40eaf8d1b6e7cf15e82382a2965efaca787fc1c2794b7021d37aaf5036/charset_normalizer-3.5.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:5c0ea61a470e070686aa30892fed79e297d2c8d0ab46b8bcdf027d38c51da591", size = 264491, upload-time = "2026-08-15T08:17:52.61Z" }, + { url = "https://files.pythonhosted.org/packages/5c/64/12b4c2a11ee8df4fcc518c78b0d93e3a92bd3d5253d1617ce74ff0e8c7ef/charset_normalizer-3.5.1-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:90b7481fb62fbe172c558bc6fd1c4c98d82004a54a7551f20e11ac9bf0b8708c", size = 245196, upload-time = "2026-08-15T08:17:54.023Z" }, + { url = "https://files.pythonhosted.org/packages/37/2e/651d910af6d0fba325eee1cda37ec5443462ed25360e666c144166eb6091/charset_normalizer-3.5.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:35fe081843b35aad20ffeccec3eeffbe637b15d14f3fb22cc1b59cd8ec17e93c", size = 261660, upload-time = "2026-08-15T08:17:55.491Z" }, + { url = "https://files.pythonhosted.org/packages/90/c6/b09e05e6db7f64338e0dc067c79577b1138da86c1e38369096851d96be88/charset_normalizer-3.5.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:fd0350afdc3aabd5576f60ea109228bd5538139713c7b094c5cd27c73a98bc6f", size = 252618, upload-time = "2026-08-15T08:17:57.025Z" }, + { url = "https://files.pythonhosted.org/packages/76/4e/362d4f9fdcdf5556fb2aa3ce7d4a58ebce03ed1ff03aa1d9aca8d02f13f3/charset_normalizer-3.5.1-cp313-cp313-pyemscripten_2025_0_wasm32.whl", hash = "sha256:9d9a0dc7cbe9bec24c3f767c9122c41fe5a1bc43f47cd099d00d393e09769de4", size = 140362, upload-time = "2026-08-15T08:17:58.425Z" }, + { url = "https://files.pythonhosted.org/packages/b4/d4/703be739b26acce318bd29eb3b25b7209e1b1f527f9eae3d1f1f01fdde2b/charset_normalizer-3.5.1-cp313-cp313-win32.whl", hash = "sha256:d63600d620ad0064c3a748b950ac5ea38a80190e5498532efefa4b7b3f1da1f3", size = 177755, upload-time = "2026-08-15T08:18:00.037Z" }, + { url = "https://files.pythonhosted.org/packages/8a/33/56d97ade41c8db611e727168c52ae46c9224c362ec28d4b65d7e9869e8da/charset_normalizer-3.5.1-cp313-cp313-win_amd64.whl", hash = "sha256:aea996a6aba25260827c9ea511d1addfde2da9eb686ac961838509086188b7e6", size = 199295, upload-time = "2026-08-15T08:18:01.506Z" }, + { url = "https://files.pythonhosted.org/packages/5b/75/5b20dd1e6573a01a08158fe104104fa2c8abf941745596954185726cd46c/charset_normalizer-3.5.1-cp313-cp313-win_arm64.whl", hash = "sha256:fd0a274c0e5f9a21565cd9d3dd749b61f96b7aa1e20a93aa1ba4029518f2e5c0", size = 179856, upload-time = "2026-08-15T08:18:02.929Z" }, + { url = "https://files.pythonhosted.org/packages/29/cd/2b812ce5e888f1ce69a5350281e58aab07ae64a958ecae8912f30865718e/charset_normalizer-3.5.1-cp314-cp314-android_24_arm64_v8a.whl", hash = "sha256:774d157f112367ff4abd29019f38f023c24e00e56edc7829c20e358a5a913ad8", size = 212318, upload-time = "2026-08-15T08:18:04.403Z" }, + { url = "https://files.pythonhosted.org/packages/9e/4a/a6ee107430768a5334e6d63f31f148a04a1a491ef161a1ac9415a73f2fa8/charset_normalizer-3.5.1-cp314-cp314-android_24_x86_64.whl", hash = "sha256:26422d45fd13551cf564c58932f7d72b4f58b93b0fcf18c35ba6be12b46bb102", size = 224897, upload-time = "2026-08-15T08:18:05.997Z" }, + { url = "https://files.pythonhosted.org/packages/c3/d9/35ae3f64f29d0179c35c3baefe575904df2913dde519129c7f75995a2b1d/charset_normalizer-3.5.1-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:09a7bba9f739468c8e78c36a75c33768e53cb1959fc638f510454c14683f00d5", size = 194848, upload-time = "2026-08-15T08:18:07.397Z" }, + { url = "https://files.pythonhosted.org/packages/74/76/f2fc7380f056cc273a53af37f50d08ad54b2c59f61078f31432edcf1c2bd/charset_normalizer-3.5.1-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:4c9548dc78002099910abaebc0a72ac58b7d30931869e0351c09b507dff4ece3", size = 198163, upload-time = "2026-08-15T08:18:08.989Z" }, + { url = "https://files.pythonhosted.org/packages/e9/40/095ce62fa078483cccc1fa2b36e6bc9580b85422a20ee9f925341c50e44f/charset_normalizer-3.5.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:c428c6c31eb5f4277d7f8eccaf767fbd548ddd5ce3c8b4f4cbbfab3d96b5904c", size = 341823, upload-time = "2026-08-15T08:18:10.458Z" }, + { url = "https://files.pythonhosted.org/packages/f1/5a/0e58b1c04a1596e0256f407274a92d5fb2ee21324409d1fab1da48a65b5b/charset_normalizer-3.5.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2f06b7eae9dbe77fe1d644ca244dad508de8d302870a43f3c559b521270938a0", size = 242458, upload-time = "2026-08-15T08:18:11.989Z" }, + { url = "https://files.pythonhosted.org/packages/22/95/b4618ce912e6db0b1aae89ba788e38e8a7eba0f3025cc66e8c0699f977b2/charset_normalizer-3.5.1-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:6b7430cf5728e68f6c462254009a6ef4086e1bea43cf2f57aa9c55fb4f50ff96", size = 226717, upload-time = "2026-08-15T08:18:13.401Z" }, + { url = "https://files.pythonhosted.org/packages/8a/76/c681192bbda3d55356db5dadd64381d5202b37c6b598fcda5282e88b5d3d/charset_normalizer-3.5.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ab743e9bc90c1f73552ec33e10e3331315acd2c397b36065b591b0181de533cc", size = 266111, upload-time = "2026-08-15T08:18:14.961Z" }, + { url = "https://files.pythonhosted.org/packages/88/be/55127bfca72c0cff6c022488d140d7c5b04c771e3b72e9bdb4836d54979d/charset_normalizer-3.5.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f6f7deae3feb4edfa2efaf7c574fe88cbf055038a6abdb40188e4fff66d5699f", size = 263128, upload-time = "2026-08-15T08:18:16.515Z" }, + { url = "https://files.pythonhosted.org/packages/e0/91/39c3af510b0aa32bbda03374259200f28430febfd1bf5e511fe765282ce5/charset_normalizer-3.5.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:15f024313246a4ed976c60f440bb8d257815513a681d212ff74fd46f7d715a90", size = 251240, upload-time = "2026-08-15T08:18:18.127Z" }, + { url = "https://files.pythonhosted.org/packages/1c/a5/cbe418bbc6ecdfc3e05a0116002897c4b403a5e838d697e64c78e9f0190d/charset_normalizer-3.5.1-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:823f82903d189af463d7df250ef1f7f696f3cee08cc8d91deb565e8d425f6506", size = 245282, upload-time = "2026-08-15T08:18:19.625Z" }, + { url = "https://files.pythonhosted.org/packages/cc/a4/689bb42e8e7cd492f3cb64907c6bc00ad247ec9a3628cd3f8eed126e8ae1/charset_normalizer-3.5.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:01e93745f7f219b703b60ba7afead36cfc4242782be5af484673fc500df12da5", size = 244597, upload-time = "2026-08-15T08:18:21.121Z" }, + { url = "https://files.pythonhosted.org/packages/c1/ce/9962938e179cf9f699d3f1e7b3114b5d7642dee6a893745229f9dd04f274/charset_normalizer-3.5.1-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:329fc3ccb63ad22d867d84c2adea759a64079a37ba4a343433b02c7a2816871e", size = 231376, upload-time = "2026-08-15T08:18:22.57Z" }, + { url = "https://files.pythonhosted.org/packages/85/54/46000450ada53bd9eac5429a2c8c54cd2d9b39c0c255f229aea9af0948a5/charset_normalizer-3.5.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:bb57753e36e4855b8ca375069482250a6246372331a3e4f3407eaebb007443f5", size = 266715, upload-time = "2026-08-15T08:18:24.235Z" }, + { url = "https://files.pythonhosted.org/packages/3d/bb/618749d70f792b44252a777bf89bfb86823b9bbc1ea13fe8ce759b07f38a/charset_normalizer-3.5.1-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:fce8cbd4997efeb450bd298b54f755dcdff18d496f7a5ddbb4867c6d7c88fdc3", size = 245848, upload-time = "2026-08-15T08:18:25.726Z" }, + { url = "https://files.pythonhosted.org/packages/7e/3f/ffb64458527c7668031d5eb095d978de561958dc9f5b53f8e488a533e603/charset_normalizer-3.5.1-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:6c9cdde8becb25a7fde49924511aa2644d6f8081cc8df8e9452724303348d8e3", size = 264521, upload-time = "2026-08-15T08:18:27.193Z" }, + { url = "https://files.pythonhosted.org/packages/4f/ab/74a55fd803916a35ac461daf002708191aac19b546b80dc8cabfedc63d98/charset_normalizer-3.5.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:9ac4444d8d4fd4c4bd08bf451ed3167aa9e7ec6cdb41b648794f1d1103652e36", size = 253054, upload-time = "2026-08-15T08:18:28.568Z" }, + { url = "https://files.pythonhosted.org/packages/a0/2a/6a9034b7d3c60b17499afb482df5878bf9fa20b50cc3887d5ef017a833db/charset_normalizer-3.5.1-cp314-cp314-pyemscripten_2026_0_wasm32.whl", hash = "sha256:f03ac127268b43ef4fe9e6ab6794a6794b49485a0cc0c1db79876d2f33f75bc7", size = 140580, upload-time = "2026-08-15T08:18:30.214Z" }, + { url = "https://files.pythonhosted.org/packages/f3/46/1d362e1a00d035d66b9869e1281eee115907f7e390a16a07824ab5737360/charset_normalizer-3.5.1-cp314-cp314-win32.whl", hash = "sha256:1f5883d77fd409a261abb5dc8ccbe335720d798b1de4abb3b1d47ccbbc76b53b", size = 180325, upload-time = "2026-08-15T08:18:31.877Z" }, + { url = "https://files.pythonhosted.org/packages/7a/7c/4938c329b6a9d446f6a59aa2092ff7118f274209b5ed0e26893d1d30a63c/charset_normalizer-3.5.1-cp314-cp314-win_amd64.whl", hash = "sha256:c658c50ac0c98cd755a2dd50b7977d3bca7df401dcc47fbdfa87db53ef7d4e8b", size = 204175, upload-time = "2026-08-15T08:18:33.466Z" }, + { url = "https://files.pythonhosted.org/packages/ac/33/eeb384dbd8dec570661354592f4f2e1b2fcc92585624d146a000caf53841/charset_normalizer-3.5.1-cp314-cp314-win_arm64.whl", hash = "sha256:4bea7f8ebe90bbd7f0e4a2de42ca6924ba23e3e76418c408ff82f1d46fabd687", size = 184123, upload-time = "2026-08-15T08:18:34.913Z" }, + { url = "https://files.pythonhosted.org/packages/1c/6c/c73fa9d5a85f6ab05395de61c5f6984e0a9ff40bb5ff888d46dff02526c6/charset_normalizer-3.5.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:fbc597639158fd7c14d55e808718848319540f51b0e6746e3eefa59723a4a348", size = 381682, upload-time = "2026-08-15T08:18:36.349Z" }, + { url = "https://files.pythonhosted.org/packages/30/c7/63565f860921457feba93bae6c86fb7746deb4cffeed2f375cb845318146/charset_normalizer-3.5.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e71c909f353863b2b89c83de2ebed71ea6d0df8a6ef65a128193c5e650766bef", size = 240826, upload-time = "2026-08-15T08:18:37.887Z" }, + { url = "https://files.pythonhosted.org/packages/06/ae/7ae8807410dfa33f8e6f1715740adeaafa8a816cc4cb33508f54b1f7c896/charset_normalizer-3.5.1-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:7ac76cf9afd34929d76eb7fcb63be476a4853d8a96f0dcf2d0db68a0cbdf9885", size = 227861, upload-time = "2026-08-15T08:18:39.315Z" }, + { url = "https://files.pythonhosted.org/packages/e9/a3/887c1642f0da26000b0e0652d91071113c0e72cea33952e225cf589f49a9/charset_normalizer-3.5.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a3a370082ce34d0612f421e15fe011c53bb1feff21a26d06ad4fb244dab5a375", size = 260758, upload-time = "2026-08-15T08:18:40.88Z" }, + { url = "https://files.pythonhosted.org/packages/3e/11/e6f5b9a3d0e55b0ef7505cd3765cdd48f22db89994c947b316f52f801fd8/charset_normalizer-3.5.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:256dd4d85d9e4dc595e2bc983c980e73f62ddeb3165c58b4c3dfe78c5c8548c1", size = 259950, upload-time = "2026-08-15T08:18:42.351Z" }, + { url = "https://files.pythonhosted.org/packages/1b/ee/e4e10a94d51cd1ee638aa7e00b65399e6b2a4e8376ab6d2eac9f95586671/charset_normalizer-3.5.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:58d4aa13a59c969dbfdf9e6a9560e242cbfd9e8a8f50c2747714df1a423adf65", size = 249329, upload-time = "2026-08-15T08:18:43.914Z" }, + { url = "https://files.pythonhosted.org/packages/c4/25/d5f4198819e6059735a84e8d0bfb72dc33976da67b97adcd3fb5a5e07ec6/charset_normalizer-3.5.1-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0c6dfb5ca6723eeed15aa8e564a014d69fcb8812f94eef11fe3631e0508199f5", size = 243137, upload-time = "2026-08-15T08:18:45.368Z" }, + { url = "https://files.pythonhosted.org/packages/a5/e9/e925ca7569cf9fb9701fd82503fee73eea5268fdb856bdd64947092d3daa/charset_normalizer-3.5.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c010f5581d9c612804cc59fcf7b524b707fbcb72828551237ab545bb5c7034af", size = 242820, upload-time = "2026-08-15T08:18:46.842Z" }, + { url = "https://files.pythonhosted.org/packages/34/17/672c251a888ed2aebcdd2fe830ad0104e25ff83c43f5c4f9c15e9fc6853c/charset_normalizer-3.5.1-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:52ec005752a56ae79547a05c0139ca2501a0c866390b6115008456b9f0e7cde1", size = 230504, upload-time = "2026-08-15T08:18:48.353Z" }, + { url = "https://files.pythonhosted.org/packages/3f/fc/f6a85abebd42ce4da2f1db0aa56cc6a0df1995e318b3875d14401b8381d1/charset_normalizer-3.5.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:2bced4061f000f7187254a02ad3433ae17eaf991747ceea2f478422590a5bba9", size = 263087, upload-time = "2026-08-15T08:18:49.859Z" }, + { url = "https://files.pythonhosted.org/packages/98/66/7c42677e739ba66746b297e2046918d793078094dc239e1e72768cffccc6/charset_normalizer-3.5.1-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:9eea3ab2597a5e65fe65296e2d6a84570845a6b55532d90333d740d48bbc850a", size = 243269, upload-time = "2026-08-15T08:18:51.601Z" }, + { url = "https://files.pythonhosted.org/packages/de/d8/a50b79237f417af10f8c2a501ce8d1ca87829a22e69117891ca4ba20a69e/charset_normalizer-3.5.1-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:496846868fea80e479324862fa877f02411f2fd0f83b79ccee2607aa68b2a032", size = 258766, upload-time = "2026-08-15T08:18:53.23Z" }, + { url = "https://files.pythonhosted.org/packages/2e/1d/0fc91aeaeb3c83b748f532399ce67cf84604b48297405d740000f7a9e786/charset_normalizer-3.5.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:85d5855daafc240cc045c026d7a15fd198a09b0fc8ff6f5ecbb5297b509cb11e", size = 250814, upload-time = "2026-08-15T08:18:54.768Z" }, + { url = "https://files.pythonhosted.org/packages/ae/10/3d8c777cf9024615295aa1b808324ad5b4a77855869c00824bad74ffaf8a/charset_normalizer-3.5.1-cp314-cp314t-win32.whl", hash = "sha256:58d3e12c88e0950bca850ae1f7c256055c097639c2edb9eb123af9807d8b15e4", size = 191074, upload-time = "2026-08-15T08:18:56.305Z" }, + { url = "https://files.pythonhosted.org/packages/4d/81/ae557d3c44d1a1d688696d60563413a0866a91b7ebc50f20df838be3d8c8/charset_normalizer-3.5.1-cp314-cp314t-win_amd64.whl", hash = "sha256:acaf604462bf330b0d07e7a07c1d6e4adac79e5fb13e9c5140590542cafacc00", size = 216476, upload-time = "2026-08-15T08:18:57.889Z" }, + { url = "https://files.pythonhosted.org/packages/27/e9/61c01fb8b804692569c036b3fc50495814502dcf13a60649c6055390b02c/charset_normalizer-3.5.1-cp314-cp314t-win_arm64.whl", hash = "sha256:fdb8a068947befafba9952162645dc2fecaeb400e64584829ed5e9b2fbe21a7f", size = 194115, upload-time = "2026-08-15T08:18:59.418Z" }, + { url = "https://files.pythonhosted.org/packages/4a/4e/8544831ef59d8f27ce92c80871380fdacc8076a8a56ed62f82e54f991333/charset_normalizer-3.5.1-cp315-cp315-macosx_10_15_universal2.whl", hash = "sha256:9085f87b0e38a2b92b8923059b4e8789fe40d9279712d15dcc670048d77079af", size = 342048, upload-time = "2026-08-15T08:19:01.054Z" }, + { url = "https://files.pythonhosted.org/packages/7f/a6/e3b46852424246065355644f4fb6dbccc0239a42a2eee27ecfc8957f0bcd/charset_normalizer-3.5.1-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2679de311c7946dde5d3b6f44941844133ff5c7cb86099c0061ab1e8901c20a8", size = 242997, upload-time = "2026-08-15T08:19:02.492Z" }, + { url = "https://files.pythonhosted.org/packages/03/3b/0cc9a26777334ab2f2e3089b948bbf4e4fe72ea70b897715ef6415043ec8/charset_normalizer-3.5.1-cp315-cp315-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:baf3775a2635e5a11fbd5e4e64ee69c7e86875d224a5c72aca4c141064589a90", size = 237014, upload-time = "2026-08-15T08:19:03.943Z" }, + { url = "https://files.pythonhosted.org/packages/8c/c2/027335f0aa337a2a2e121bac1ad88c4f02ba6053ea0926802784f3db11af/charset_normalizer-3.5.1-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8ac8c94b6539074e0f40899301273ac8402b9b3e01c7b7ba269ff30340aaaf20", size = 266174, upload-time = "2026-08-15T08:19:05.598Z" }, + { url = "https://files.pythonhosted.org/packages/86/d3/e367787febe4e74769dec0f406f2c3c8d1b955fce5aee1fd0f94e8367a45/charset_normalizer-3.5.1-cp315-cp315-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:8fe532b3c966d1fb794e0698e4589d0444017ae77fc0b31edea13c0e35bcc449", size = 263361, upload-time = "2026-08-15T08:19:07.251Z" }, + { url = "https://files.pythonhosted.org/packages/af/3d/391b193eb9f3e84b02f9314088c386debdc0debee843535aaea2e2c6715d/charset_normalizer-3.5.1-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5c84bec0ab5ae0c64bfe73a7d2adcb5ce73b467523fc27fd6a28ab2aa6cbe35a", size = 252143, upload-time = "2026-08-15T08:19:08.816Z" }, + { url = "https://files.pythonhosted.org/packages/2e/57/de221f1745a90d418199761967e2776bfe2c275a1194220985e8c1d37833/charset_normalizer-3.5.1-cp315-cp315-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:854066be00447fa8de2ccbbe893e2ffc4b123ef16d897af794c1e18bd4a714b0", size = 252086, upload-time = "2026-08-15T08:19:10.255Z" }, + { url = "https://files.pythonhosted.org/packages/c8/e3/d119f86a01f9331e8186175f24873b1d74a7ee9e2e4b4d68f9947dae5afd/charset_normalizer-3.5.1-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:21b82d8082f6f5e7f456ef0bd16323d08de1266efbfeb476e64b2a91d1471a4e", size = 245231, upload-time = "2026-08-15T08:19:11.807Z" }, + { url = "https://files.pythonhosted.org/packages/26/de/d8e48c135ae480879539cdb179c8d3b50c7879497d75dd899b5763b69cee/charset_normalizer-3.5.1-cp315-cp315-musllinux_1_2_armv7l.whl", hash = "sha256:838648accb3a7fd9803fd45c87bce8509648eb0c11bc34e216141300977244f2", size = 241546, upload-time = "2026-08-15T08:19:13.416Z" }, + { url = "https://files.pythonhosted.org/packages/67/c4/217755fd1abc50d326c252922cd642002758095a81ff45010337b8b3ef65/charset_normalizer-3.5.1-cp315-cp315-musllinux_1_2_ppc64le.whl", hash = "sha256:195ce897c6153c0700078142cf8efe3e6454ca4cf4357499e4078dfd83396626", size = 267033, upload-time = "2026-08-15T08:19:14.981Z" }, + { url = "https://files.pythonhosted.org/packages/b8/d7/34d8e404e358d2adcc5a228c2134643af00104c8fb0bf525f3688d756f05/charset_normalizer-3.5.1-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:978eab16f55b4ab2c2a745be9a0a840bf8f09a7f227d9c76eb30214d078865a5", size = 252045, upload-time = "2026-08-15T08:19:16.618Z" }, + { url = "https://files.pythonhosted.org/packages/5e/fa/40414471acf0aa0692ca77305aa00e434fcd8288f0941c93c30e9a5f8f2f/charset_normalizer-3.5.1-cp315-cp315-musllinux_1_2_s390x.whl", hash = "sha256:cc0329df4caaceb950d2f580b5ac716a377f7059624a0bafaeaf8a218c6ed774", size = 264866, upload-time = "2026-08-15T08:19:18.101Z" }, + { url = "https://files.pythonhosted.org/packages/32/90/fcc850bae791abd2e0c041847f13e270aa08692a79f3e00de6d2dce1cb50/charset_normalizer-3.5.1-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:687c9ca3035544b113bea2055e180af96fb63c0c476e22a9180f51925186e7b7", size = 253932, upload-time = "2026-08-15T08:19:19.734Z" }, + { url = "https://files.pythonhosted.org/packages/af/af/53afe99068b3c10b4cbae592a52ef72a7c92c0188440e83ee3a078fd8f75/charset_normalizer-3.5.1-cp315-cp315-win32.whl", hash = "sha256:706bfd38730a5ac7a365793269a00f4e988178cec121391f4248d84ad8c972e9", size = 180320, upload-time = "2026-08-15T08:19:21.37Z" }, + { url = "https://files.pythonhosted.org/packages/c9/bc/f46a132041b29e4a8779ed712d3df1bf112e94ca8de58b66d7ec2c0cf8b9/charset_normalizer-3.5.1-cp315-cp315-win_amd64.whl", hash = "sha256:92caef967d287a407085d61176fce4012b1dd62daed4eb6d5ceb26d3d2538712", size = 204174, upload-time = "2026-08-15T08:19:23.088Z" }, + { url = "https://files.pythonhosted.org/packages/a1/5d/9ed554480eda8e447b673648628fdc29574d23dbad01fe11837adedd1cae/charset_normalizer-3.5.1-cp315-cp315-win_arm64.whl", hash = "sha256:5fc45d653ea8c9a20479167e11d4a0f8cb2fa3470737ab6f9c827532313187b7", size = 184126, upload-time = "2026-08-15T08:19:24.471Z" }, + { url = "https://files.pythonhosted.org/packages/3b/32/9b8929bf384061ee1fe5d9c27c6f9776d3d824039ad4e14c88ec00c7808e/charset_normalizer-3.5.1-cp315-cp315t-macosx_10_15_universal2.whl", hash = "sha256:59171c6e45bf07d0d5cab3b0bf81d945035530f6873398b3b531c31184d46663", size = 381441, upload-time = "2026-08-15T08:19:26.038Z" }, + { url = "https://files.pythonhosted.org/packages/96/10/e9aa7923d3ddac652c99a1c5f7be494e737e151566a44abe018daf757f2c/charset_normalizer-3.5.1-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9dbdd9205662134957cf0c324f639bdc5031c0ca056e2369e238db75187c0f11", size = 241742, upload-time = "2026-08-15T08:19:27.532Z" }, + { url = "https://files.pythonhosted.org/packages/28/53/a2d249ebddf47b889a100c0bdcb61a2f9dbb8bc24ef325cc062e4f476877/charset_normalizer-3.5.1-cp315-cp315t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e4b018dc5a0eee4676e38fe84a47a427816c590b93b55d9025274ec4d6ffc2dc", size = 235298, upload-time = "2026-08-15T08:19:29.274Z" }, + { url = "https://files.pythonhosted.org/packages/7d/07/469f78af590f7d5cd48e20d8dbfa3d66deeff9ba37768c04d886b5afd45c/charset_normalizer-3.5.1-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ced3fdd71aaa83ce593746c2edb42b7a59cb4c19c8b5c407781c72e493aae55a", size = 262500, upload-time = "2026-08-15T08:19:30.955Z" }, + { url = "https://files.pythonhosted.org/packages/55/66/3bb56a47f7dcba014055b1a1d33c6f08bbe9c1e74dba154cfa25f90ae885/charset_normalizer-3.5.1-cp315-cp315t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:19a3dd5aa73cef1c99687c4fc57db016a9c17104ae1185da88ba566a5d3bebe4", size = 258888, upload-time = "2026-08-15T08:19:32.458Z" }, + { url = "https://files.pythonhosted.org/packages/ff/c1/2adc2800903fb013210349313b710a5376856578d9e33e6b9a1d8b36714a/charset_normalizer-3.5.1-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:cc5d36d96478aa9c60654bd932525bf32964c62a7281eafdf16d85003a8d6004", size = 250243, upload-time = "2026-08-15T08:19:33.94Z" }, + { url = "https://files.pythonhosted.org/packages/95/b5/a18d0dd1157ab655cc2cb14a545f4a4784bbad70ab3502412e36097502d9/charset_normalizer-3.5.1-cp315-cp315t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:04368edf83514385ffc3e1cfd4546e595f4f1272dd23ba437a93a9cc3741d47b", size = 249871, upload-time = "2026-08-15T08:19:35.413Z" }, + { url = "https://files.pythonhosted.org/packages/ad/c3/525f508cd1e58d0450ac55ed40ac75bc3a97482c59def5278456a5fbf03c/charset_normalizer-3.5.1-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:9b5db6052055d34d41230fb78d7c439c23dc536a9896f6cb039e8dd92cfc1263", size = 243580, upload-time = "2026-08-15T08:19:36.886Z" }, + { url = "https://files.pythonhosted.org/packages/7c/c1/49a91fe7e97c8140094ca5c64161ab623a70d9f636bf834eace14048acb5/charset_normalizer-3.5.1-cp315-cp315t-musllinux_1_2_armv7l.whl", hash = "sha256:252d099029bcbea642f2a06c4ed5046bdf8b5a8150b64afa5e027e88b106e5ee", size = 239807, upload-time = "2026-08-15T08:19:38.392Z" }, + { url = "https://files.pythonhosted.org/packages/d3/58/56a48c296601274c4689b864a8e2dfb209b81dfcb39472753ce95eea662b/charset_normalizer-3.5.1-cp315-cp315t-musllinux_1_2_ppc64le.whl", hash = "sha256:6199d5606e2bbf2b096cf64d03f8b6790c91081d5ac866b8e7bb6422738cc60c", size = 264083, upload-time = "2026-08-15T08:19:39.856Z" }, + { url = "https://files.pythonhosted.org/packages/10/4c/dc48409274a1817ff349711d26c62aa0c597df865d4d69ef79160c859193/charset_normalizer-3.5.1-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:77efcff2b23071c349402ac1066667a3d011f62398d81408c9b88ad991747c9e", size = 250317, upload-time = "2026-08-15T08:19:41.53Z" }, + { url = "https://files.pythonhosted.org/packages/81/58/d325912115caec62d6bdd77bbab5e0b7da5d234a9f20affdffcbcb530d0b/charset_normalizer-3.5.1-cp315-cp315t-musllinux_1_2_s390x.whl", hash = "sha256:a5cbd90ecf0fc62e64726917ad083b73001f0563657a87ec3c0b504e277dc90d", size = 258173, upload-time = "2026-08-15T08:19:43.07Z" }, + { url = "https://files.pythonhosted.org/packages/34/f7/b13b1ccae2c8ec63980d13be1890eb73f8aeabbfce02a24aabc0908788f5/charset_normalizer-3.5.1-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:4d26f14f041e83dd8edfd61f4cd4fa7285d31798b5bf1f28e70c367ba6c41d61", size = 251960, upload-time = "2026-08-15T08:19:44.587Z" }, + { url = "https://files.pythonhosted.org/packages/1e/25/ed3f9919c5aef8cc818be1f972f565f7610d7b2076b8ebb98839516ffc3c/charset_normalizer-3.5.1-cp315-cp315t-win32.whl", hash = "sha256:ac13b004224fb341e1e25a1ed5e19d32f57cdb2a403e01f003b46f051a550f6f", size = 191186, upload-time = "2026-08-15T08:19:46.293Z" }, + { url = "https://files.pythonhosted.org/packages/69/d5/43c2b3e9d8267092b913eb8b0603f0f71993c395632886bd37a7223f96cf/charset_normalizer-3.5.1-cp315-cp315t-win_amd64.whl", hash = "sha256:35aea775dc2bd5f54cd84a1cd2696cc3207c479cb9cf0bd346f0d343e4300ddb", size = 215947, upload-time = "2026-08-15T08:19:47.853Z" }, + { url = "https://files.pythonhosted.org/packages/a8/76/9aad3e9c8865e5e0efa9a7f6f81c37a67635a985145ecd44528a81e088ee/charset_normalizer-3.5.1-cp315-cp315t-win_arm64.whl", hash = "sha256:fb78f6e7fcd8ad785d28cd577168bc1aaee827b25bb8755638f694794ea98f0a", size = 193909, upload-time = "2026-08-15T08:19:49.383Z" }, + { url = "https://files.pythonhosted.org/packages/5b/97/fb4e82231aba271ffd775a1b4993b0defc4e3059f286ae41d9433409fe85/charset_normalizer-3.5.1-cp37-abi3-macosx_10_9_universal2.whl", hash = "sha256:41876ee62a3dddf48ff1121ad8f0798032aa03f2fd35f21f34a4cab14f18d8d2", size = 331467, upload-time = "2026-08-15T08:19:50.959Z" }, + { url = "https://files.pythonhosted.org/packages/9f/2f/fe3f187327aac18e2d54e9d2b08e15d27bf9b642d9e51c219f130fc34d1a/charset_normalizer-3.5.1-cp37-abi3-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:a6dac12ff6b846103483683f60c5f8fee205121adc58ffd87e90a90a3af69e99", size = 253057, upload-time = "2026-08-15T08:19:52.654Z" }, + { url = "https://files.pythonhosted.org/packages/d7/c7/9e48cee5c161fe24da823b61bf381921d77cb994a0a4de148e95018c1984/charset_normalizer-3.5.1-cp37-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:cee5dd7c6fb5dd52a0fe2a740f9bc6e3593f5f8b1788bde49de02086f30182b2", size = 240930, upload-time = "2026-08-15T08:19:54.163Z" }, + { url = "https://files.pythonhosted.org/packages/49/e0/716601f3cc69be7b198951150c75ead1ece33c3c8036ff6ffa46029659a0/charset_normalizer-3.5.1-cp37-abi3-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:343fb4f2821043bd87095f7b08a1a181febc8e36ac64212143bbfd0a0e1bc235", size = 230822, upload-time = "2026-08-15T08:19:55.807Z" }, + { url = "https://files.pythonhosted.org/packages/d3/05/71bfc5caa0abcc45aea1f6a4d50ac68e59605ddc7666fe8494f4cd229665/charset_normalizer-3.5.1-cp37-abi3-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ae4a097991662cd4fff0ddc74e0fe7874f82e00042fa0ea00855645ed0c79598", size = 260037, upload-time = "2026-08-15T08:19:57.312Z" }, + { url = "https://files.pythonhosted.org/packages/c3/92/de7e32ed05341e7a9c4c877c318418197b7f2d66a3b68d561bf2ac57ca3e/charset_normalizer-3.5.1-cp37-abi3-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4b599739b93b2cbeded49645ae3c8d1405c29ddfbceac1545c87a3f9580a9e96", size = 255097, upload-time = "2026-08-15T08:19:59.056Z" }, + { url = "https://files.pythonhosted.org/packages/f5/7b/ade0a122600319dfa0b1000ab0f9731c94a817904cf3c5de408c73a4ede7/charset_normalizer-3.5.1-cp37-abi3-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b39b69b347e5e47a3b5b8cfc005c68c1ba347474e3960236c4944a8ecd174962", size = 250166, upload-time = "2026-08-15T08:20:00.612Z" }, + { url = "https://files.pythonhosted.org/packages/75/9c/019fbb9f4834491a160951349b1a3714439376f66e5f7cf18b4f18f0c7aa/charset_normalizer-3.5.1-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:a2028475ba855475b8b4d3cfeb4994269c967aea8b9892dfba907f4263a863a3", size = 241821, upload-time = "2026-08-15T08:20:02.321Z" }, + { url = "https://files.pythonhosted.org/packages/2b/b8/11d4840bfc99330cc7fbcc2681ee5a044553a6e77655508d8f9b2bff7b34/charset_normalizer-3.5.1-cp37-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:36047af20e17097c3bb9476c2b7655f2f7aa51322c0ba58c07695bedf755a950", size = 232529, upload-time = "2026-08-15T08:20:04.008Z" }, + { url = "https://files.pythonhosted.org/packages/18/96/2b3a21492d9f65171ac75d872f5018260013d00bfa0ff70ec9f179148cbd/charset_normalizer-3.5.1-cp37-abi3-musllinux_1_2_ppc64le.whl", hash = "sha256:4c4fb141a727957c93edfe5c32a26ceb6b5f6461d67146e2d39f51e16170bea8", size = 260348, upload-time = "2026-08-15T08:20:05.877Z" }, + { url = "https://files.pythonhosted.org/packages/d6/aa/a69a2028e8bd052476c245460ab19d7de595de084dd968f2d75cd50c3e25/charset_normalizer-3.5.1-cp37-abi3-musllinux_1_2_riscv64.whl", hash = "sha256:2f293479cce755c75f1697e87c409b7ae4c555c7dfecb6e988ad13abba943031", size = 247234, upload-time = "2026-08-15T08:20:07.487Z" }, + { url = "https://files.pythonhosted.org/packages/35/8a/3d130aeabcaf3d2466af76b7b141c08d9e89c9016ab4b7cdd0f7dc2d1c62/charset_normalizer-3.5.1-cp37-abi3-musllinux_1_2_s390x.whl", hash = "sha256:3588e376b3ea2eea84976f67273d679f229e24c66dce7b82ae45aef04ff6e072", size = 256917, upload-time = "2026-08-15T08:20:09.142Z" }, + { url = "https://files.pythonhosted.org/packages/80/c2/a7379b840292d0c1ab9fbd17d1f3967aa81794dc95bc74be8999d7fedcf7/charset_normalizer-3.5.1-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:e199fb99720074809a7720f1c0b4d919eea8b87e88713e0f8f602f7bef543d9d", size = 254846, upload-time = "2026-08-15T08:20:10.727Z" }, + { url = "https://files.pythonhosted.org/packages/01/65/d43b714731bb2f40d4053dfa00ecfc1c5a301f8e3316c5db3a09af59fe94/charset_normalizer-3.5.1-cp37-abi3-win32.whl", hash = "sha256:dd732602a7009217f658d5863d12d79d373a4de0eebc111094bcdd3bb8e0a6cc", size = 174216, upload-time = "2026-08-15T08:20:12.334Z" }, + { url = "https://files.pythonhosted.org/packages/35/4f/b911ed898b26a09789eba9c9200c999aff6c61b4bafaf4838e56d1a1e1a3/charset_normalizer-3.5.1-cp37-abi3-win_amd64.whl", hash = "sha256:70055ff39b97c99e7ae40ea3e393fb62aa2e44dbd9b29f8d14f42fb0025c3959", size = 199764, upload-time = "2026-08-15T08:20:13.908Z" }, + { url = "https://files.pythonhosted.org/packages/f0/a7/920baf467bfd9bf689f3b318340f37aee4572a71f162bd8db51da55ba4fa/charset_normalizer-3.5.1-cp37-abi3-win_arm64.whl", hash = "sha256:87e4f41d375c0b9be2fb5251aee4b8a689169e134535aed81bf085c3b647451e", size = 287318, upload-time = "2026-08-15T08:20:15.551Z" }, + { url = "https://files.pythonhosted.org/packages/cc/61/d01fc49b8dea277640b55a9e15960dbca9fdc8c9fde18e572d39c59f4019/charset_normalizer-3.5.1-py3-none-any.whl", hash = "sha256:6df0ec430f9a831772c23ca5a224cba36517a58a84bb32c32bb59a9fa67c47f6", size = 68658, upload-time = "2026-08-15T08:20:43.306Z" }, +] + +[[package]] +name = "click" +version = "8.5.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/c7/0e/7fa0ef50764b67090eca4114772a2abf8b6148198475e54c660b97caeee6/click-8.5.0.tar.gz", hash = "sha256:ba0d2089de75ea0310e2dde03160e6ca10009947fb95a182f9b54021bb272e34", size = 382235, upload-time = "2026-08-26T13:33:14.56Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/58/50/6c0d534c5f134586a8e1ba4e330569e32f057e33372ae556463212fb4cd3/click-8.5.0-py3-none-any.whl", hash = "sha256:255bc9599cf7748b4b1a446ccc735421bd08a2ae529a8b88597d3de5664ee360", size = 125251, upload-time = "2026-08-26T13:33:12.928Z" }, +] + [[package]] name = "colorama" version = "0.4.6" @@ -31,6 +622,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" }, ] +[[package]] +name = "comm" +version = "0.2.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/4c/13/7d740c5849255756bc17888787313b61fd38a0a8304fc4f073dfc46122aa/comm-0.2.3.tar.gz", hash = "sha256:2dc8048c10962d55d7ad693be1e7045d891b7ce8d999c97963a5e3e99c055971", size = 6319, upload-time = "2025-07-25T14:02:04.452Z" } +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 = "contourpy" version = "1.3.3" @@ -191,6 +791,93 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/e7/05/c19819d5e3d95294a6f5947fb9b9629efb316b96de511b418c53d245aae6/cycler-0.12.1-py3-none-any.whl", hash = "sha256:85cef7cff222d8644161529808465972e51340599459b8ac3ccbac5a854e0d30", size = 8321, upload-time = "2023-10-07T05:32:16.783Z" }, ] +[[package]] +name = "datasets" +version = "5.0.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "dill" }, + { name = "filelock" }, + { name = "fsspec", extra = ["http"] }, + { name = "httpx" }, + { name = "huggingface-hub" }, + { name = "multiprocess" }, + { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12'" }, + { name = "numpy", version = "2.5.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" }, + { name = "packaging" }, + { name = "pandas" }, + { name = "pyarrow" }, + { name = "pyyaml" }, + { name = "requests" }, + { name = "tqdm" }, + { name = "xxhash" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/0a/5b/836516269d4f618efe621661cfb6f9acc57e6f95265db3efaee48a5ffe04/datasets-5.0.1.tar.gz", hash = "sha256:ce22bb851efd7494f08aad33b940803784434f6e77763d00679a0dc45fcf686a", size = 641498, upload-time = "2026-07-28T11:09:12.016Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/44/0b/98fc6eb83333508ca5f44c52b3e287ea8137a0ad582714e2cbc67a02154b/datasets-5.0.1-py3-none-any.whl", hash = "sha256:9fbf73688f8c18f7529b4fe592abd04015f81d1e58001e4bac73ffb2b39d7cc4", size = 559079, upload-time = "2026-07-28T11:09:10.266Z" }, +] + +[[package]] +name = "debugpy" +version = "1.8.21" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f2/aa/12037145b7a56eaa5b29b41872f7a21b538e807e13f32c4d3c46e59be084/debugpy-1.8.21.tar.gz", hash = "sha256:a3c53278e84c94e11bd87c53970ec391d1a67396c8b22609fcac576520e611a6", size = 1697577, upload-time = "2026-06-01T19:30:35.156Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/89/fb/cbf306d6e07a313a91e7171a98669054502840931432c227cfd505ee367f/debugpy-1.8.21-cp311-cp311-macosx_15_0_universal2.whl", hash = "sha256:da456226c7b4c69e35dbe35dcee6623d912000a77816db7856a41af1c72a0264", size = 2203120, upload-time = "2026-06-01T19:30:43.964Z" }, + { url = "https://files.pythonhosted.org/packages/aa/57/aa739bd4ad2cbf96aeb1b20b56918ddd5ae4c28b68709bfcd327f02123ee/debugpy-1.8.21-cp311-cp311-manylinux_2_34_x86_64.whl", hash = "sha256:f68b891688e61bdc08b8d364d919ff0051e0b94657b39dcd027bc3173edb7cdc", size = 3059958, upload-time = "2026-06-01T19:30:45.622Z" }, + { url = "https://files.pythonhosted.org/packages/a8/31/453d2c9a23d133fe2c8ec7ca1d816ded52a913487fe3ffef7c01b4b706af/debugpy-1.8.21-cp311-cp311-win32.whl", hash = "sha256:f843a8b08c2edeaf9b1582eed4f25441af21a297c22ff16bf76a662557aa9c9e", size = 5236515, upload-time = "2026-06-01T19:30:47.461Z" }, + { url = "https://files.pythonhosted.org/packages/60/94/6660de2f2d7bf388f229335ba4637646eebabdbf38564cb439a95a9193c9/debugpy-1.8.21-cp311-cp311-win_amd64.whl", hash = "sha256:84c564d8cc701d41843b29a92814c1f1bef6798724ca9d675c284ad9f6a547d7", size = 5256138, upload-time = "2026-06-01T19:30:49.113Z" }, + { url = "https://files.pythonhosted.org/packages/a2/df/bf625547431a9cadc9f4cbfeda38866e2b17f6aed147b625377e87834449/debugpy-1.8.21-cp312-cp312-macosx_15_0_universal2.whl", hash = "sha256:9f96713896f39c3dff0ee841f47320c3f2983d33c341e009361bb0ebc79adc4e", size = 2483609, upload-time = "2026-06-01T19:30:50.794Z" }, + { url = "https://files.pythonhosted.org/packages/bf/09/59324b903599031ff9faaec1758292409f6561a0ec2492fe4b703327705a/debugpy-1.8.21-cp312-cp312-manylinux_2_34_x86_64.whl", hash = "sha256:c193d474f0a211191f2b4449d2d06157c689013035bd952f3b617e0ef422b176", size = 3968900, upload-time = "2026-06-01T19:30:52.341Z" }, + { url = "https://files.pythonhosted.org/packages/14/cd/27f65b805d7fe005c44e1a36b9183ecdfbcdbf9d3e721a5115d461ecc7ee/debugpy-1.8.21-cp312-cp312-win32.whl", hash = "sha256:4743373c1cac7f9e74a1b9915bf1dbe0e900eca657ffb170ae07ac8363205ae9", size = 5336340, upload-time = "2026-06-01T19:30:54.047Z" }, + { url = "https://files.pythonhosted.org/packages/77/1d/c84e30c0c674184948b66f076ab271c01d940618a2824c23cd035a27bc20/debugpy-1.8.21-cp312-cp312-win_amd64.whl", hash = "sha256:bd7ba9dd3daa7c2f942c6ca8d4695a16bf9ac16b63615261c7982bc74f7ed20c", size = 5374751, upload-time = "2026-06-01T19:30:55.891Z" }, + { url = "https://files.pythonhosted.org/packages/77/6b/d817e1f8cc77aa055d37fba092e0febfdff40fe652d8d53d4cd7a86ad98d/debugpy-1.8.21-cp313-cp313-macosx_15_0_universal2.whl", hash = "sha256:13678151fc401e2d68c9880b91e28714f797d40422994572b24560ef80910a88", size = 2477398, upload-time = "2026-06-01T19:30:57.644Z" }, + { url = "https://files.pythonhosted.org/packages/48/57/412421516afc3055fa577516f00beec3d663f9b0ab330639547ae6c57720/debugpy-1.8.21-cp313-cp313-manylinux_2_34_x86_64.whl", hash = "sha256:ecbd158386c31ffe71d46f72d44d56e66331ab9b16cad649156d514368f23ab2", size = 3962096, upload-time = "2026-06-01T19:30:59.235Z" }, + { url = "https://files.pythonhosted.org/packages/c1/62/2c616337cf6ba7b07ebbc97f02c6c945a8e2f76b365e33ee809c32ee36d1/debugpy-1.8.21-cp313-cp313-win32.whl", hash = "sha256:2c2ae706dec41d99a9ca1f7ebc987a83e65578363be6f6b3ac9067504917fae1", size = 5336288, upload-time = "2026-06-01T19:31:00.79Z" }, + { url = "https://files.pythonhosted.org/packages/f8/99/9175103392f84c4b1bf7622888cdc68da07f0ff7d9e581266428f6776033/debugpy-1.8.21-cp313-cp313-win_amd64.whl", hash = "sha256:aa648733047443eb1d07682c4ef287d36a54507b643ffdf38b09a3ef002c72a0", size = 5376567, upload-time = "2026-06-01T19:31:02.56Z" }, + { url = "https://files.pythonhosted.org/packages/ce/3d/f4bbb323a548bfab2af3d6b4ffd9bf22636e55956a1285d317a1de643aad/debugpy-1.8.21-cp314-cp314-macosx_15_0_universal2.whl", hash = "sha256:9bb2a685287a2ac9b181cde89edcec64845cb51de7faaa75badb9a698bc24782", size = 2477209, upload-time = "2026-06-01T19:31:04.157Z" }, + { url = "https://files.pythonhosted.org/packages/8c/2d/6e7ec524984a1702777868de49a4c53202bddac2a432a76a093469587750/debugpy-1.8.21-cp314-cp314-manylinux_2_34_x86_64.whl", hash = "sha256:3d6922439bf33fd38a3e2c447869ebc7b97da5cd3d329ff1ef9bc06c4903437e", size = 3927115, upload-time = "2026-06-01T19:31:05.863Z" }, + { url = "https://files.pythonhosted.org/packages/97/47/d1aa6d64005a98a9144647d99306b419396f9ad7bf1d73c119e17a81fb4d/debugpy-1.8.21-cp314-cp314-win32.whl", hash = "sha256:15d4963bd5ffa48f0da0947fd06757fa7621945048a14ad7705431566d3c0e7c", size = 5336724, upload-time = "2026-06-01T19:31:07.711Z" }, + { url = "https://files.pythonhosted.org/packages/5f/67/b905b90d163af11878c1af8abafa4a25206335e112e284e413454543a6da/debugpy-1.8.21-cp314-cp314-win_amd64.whl", hash = "sha256:fe0744a12353406de0ae8ccff0d0a4a666f00801a3db8fd04e7a5f761cd520e8", size = 5373803, upload-time = "2026-06-01T19:31:09.469Z" }, + { url = "https://files.pythonhosted.org/packages/95/51/67e7cf11a53e40694f720457d5b3a1cdaaa3d5a9a633e482f225456b93ff/debugpy-1.8.21-py2.py3-none-any.whl", hash = "sha256:b1e37d333663c8851516a47364ef473da127f9caebe4417e6df6f5825a7e9a92", size = 5352888, upload-time = "2026-06-01T19:31:25.186Z" }, +] + +[[package]] +name = "defusedxml" +version = "0.7.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0f/d5/c66da9b79e5bdb124974bfe172b4daf3c984ebd9c2a06e2b8a4dc7331c72/defusedxml-0.7.1.tar.gz", hash = "sha256:1bb3032db185915b62d7c6209c5a8792be6a32ab2fedacc84e01b52c51aa3e69", size = 75520, upload-time = "2021-03-08T10:59:26.269Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/07/6c/aa3f2f849e01cb6a001cd8554a88d4c77c5c1a31c95bdf1cf9301e6d9ef4/defusedxml-0.7.1-py2.py3-none-any.whl", hash = "sha256:a352e7e428770286cc899e2542b6cdaedb2b4953ff269a210103ec58f6198a61", size = 25604, upload-time = "2021-03-08T10:59:24.45Z" }, +] + +[[package]] +name = "dill" +version = "0.4.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/81/e1/56027a71e31b02ddc53c7d65b01e68edf64dea2932122fe7746a516f75d5/dill-0.4.1.tar.gz", hash = "sha256:423092df4182177d4d8ba8290c8a5b640c66ab35ec7da59ccfa00f6fa3eea5fa", size = 187315, upload-time = "2026-01-19T02:36:56.85Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1e/77/dc8c558f7593132cf8fefec57c4f60c83b16941c574ac5f619abb3ae7933/dill-0.4.1-py3-none-any.whl", hash = "sha256:1e1ce33e978ae97fcfcff5638477032b801c46c7c65cf717f95fbc2248f79a9d", size = 120019, upload-time = "2026-01-19T02:36:55.663Z" }, +] + +[[package]] +name = "executing" +version = "2.2.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/cc/28/c14e053b6762b1044f34a13aab6859bbf40456d37d23aa286ac24cfd9a5d/executing-2.2.1.tar.gz", hash = "sha256:3632cc370565f6648cc328b32435bd120a1e4ebb20c77e3fdde9a13cd1e533c4", size = 1129488, upload-time = "2025-09-01T09:48:10.866Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c1/ea/53f2148663b321f21b5a606bd5f191517cf40b7072c0497d3c92c4a13b1e/executing-2.2.1-py2.py3-none-any.whl", hash = "sha256:760643d3452b4d777d295bb167ccc74c64a81df23fb5e08eff250c425a4b2017", size = 28317, upload-time = "2025-09-01T09:48:08.5Z" }, +] + +[[package]] +name = "fastjsonschema" +version = "2.22.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/33/a4/9473c7c3b87009d9c1d74034e4a0f6a35ff0d42dd0f9866d0c3ec4e9217b/fastjsonschema-2.22.2.tar.gz", hash = "sha256:72064e12356a7d6ef02165be2946b9abadbdf238536e07eb587e3dbaa33099cf", size = 385171, upload-time = "2026-08-15T19:47:08.853Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/49/82/2755c7c982086f00d4dab85bc120ec35045a9fc2191893a6ce79afe94443/fastjsonschema-2.22.2-py3-none-any.whl", hash = "sha256:0fb3915616adac85ccfdd737d26be1089845d2019819505b42d39888458f74d4", size = 27413, upload-time = "2026-08-15T19:47:04.406Z" }, +] + [[package]] name = "filelock" version = "3.29.5" @@ -249,6 +936,120 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/2c/47/c99d5268f354002ce80f8d029cd9d7d872969da1de8b93d32de4dc56d6f4/fonttools-4.63.0-py3-none-any.whl", hash = "sha256:445af2eab030a16b9171ea8bdda7ebf7d96bda2df88ee182a464252f6e05e20d", size = 1164562, upload-time = "2026-05-14T12:04:29.092Z" }, ] +[[package]] +name = "fqdn" +version = "1.5.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/30/3e/a80a8c077fd798951169626cde3e239adeba7dab75deb3555716415bd9b0/fqdn-1.5.1.tar.gz", hash = "sha256:105ed3677e767fb5ca086a0c1f4bb66ebc3c100be518f0e0d755d9eae164d89f", size = 6015, upload-time = "2021-03-11T07:16:29.08Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cf/58/8acf1b3e91c58313ce5cb67df61001fc9dcd21be4fadb76c1a2d540e09ed/fqdn-1.5.1-py3-none-any.whl", hash = "sha256:3a179af3761e4df6eb2e026ff9e1a3033d3587bf980a0b1b2e1e5d08d7358014", size = 9121, upload-time = "2021-03-11T07:16:28.351Z" }, +] + +[[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/bc/03/077f869d540370db12165c0aa51640a873fb661d8b315d1d4d67b284d7ac/frozenlist-1.8.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:09474e9831bc2b2199fad6da3c14c7b0fbdd377cce9d3d77131be28906cb7d84", size = 86912, upload-time = "2025-10-06T05:35:45.98Z" }, + { url = "https://files.pythonhosted.org/packages/df/b5/7610b6bd13e4ae77b96ba85abea1c8cb249683217ef09ac9e0ae93f25a91/frozenlist-1.8.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:17c883ab0ab67200b5f964d2b9ed6b00971917d5d8a92df149dc2c9779208ee9", size = 50046, upload-time = "2025-10-06T05:35:47.009Z" }, + { url = "https://files.pythonhosted.org/packages/6e/ef/0e8f1fe32f8a53dd26bdd1f9347efe0778b0fddf62789ea683f4cc7d787d/frozenlist-1.8.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:fa47e444b8ba08fffd1c18e8cdb9a75db1b6a27f17507522834ad13ed5922b93", size = 50119, upload-time = "2025-10-06T05:35:48.38Z" }, + { url = "https://files.pythonhosted.org/packages/11/b1/71a477adc7c36e5fb628245dfbdea2166feae310757dea848d02bd0689fd/frozenlist-1.8.0-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:2552f44204b744fba866e573be4c1f9048d6a324dfe14475103fd51613eb1d1f", size = 231067, upload-time = "2025-10-06T05:35:49.97Z" }, + { url = "https://files.pythonhosted.org/packages/45/7e/afe40eca3a2dc19b9904c0f5d7edfe82b5304cb831391edec0ac04af94c2/frozenlist-1.8.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:957e7c38f250991e48a9a73e6423db1bb9dd14e722a10f6b8bb8e16a0f55f695", size = 233160, upload-time = "2025-10-06T05:35:51.729Z" }, + { url = "https://files.pythonhosted.org/packages/a6/aa/7416eac95603ce428679d273255ffc7c998d4132cfae200103f164b108aa/frozenlist-1.8.0-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:8585e3bb2cdea02fc88ffa245069c36555557ad3609e83be0ec71f54fd4abb52", size = 228544, upload-time = "2025-10-06T05:35:53.246Z" }, + { url = "https://files.pythonhosted.org/packages/8b/3d/2a2d1f683d55ac7e3875e4263d28410063e738384d3adc294f5ff3d7105e/frozenlist-1.8.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:edee74874ce20a373d62dc28b0b18b93f645633c2943fd90ee9d898550770581", size = 243797, upload-time = "2025-10-06T05:35:54.497Z" }, + { url = "https://files.pythonhosted.org/packages/78/1e/2d5565b589e580c296d3bb54da08d206e797d941a83a6fdea42af23be79c/frozenlist-1.8.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:c9a63152fe95756b85f31186bddf42e4c02c6321207fd6601a1c89ebac4fe567", size = 247923, upload-time = "2025-10-06T05:35:55.861Z" }, + { url = "https://files.pythonhosted.org/packages/aa/c3/65872fcf1d326a7f101ad4d86285c403c87be7d832b7470b77f6d2ed5ddc/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:b6db2185db9be0a04fecf2f241c70b63b1a242e2805be291855078f2b404dd6b", size = 230886, upload-time = "2025-10-06T05:35:57.399Z" }, + { url = "https://files.pythonhosted.org/packages/a0/76/ac9ced601d62f6956f03cc794f9e04c81719509f85255abf96e2510f4265/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:f4be2e3d8bc8aabd566f8d5b8ba7ecc09249d74ba3c9ed52e54dc23a293f0b92", size = 245731, upload-time = "2025-10-06T05:35:58.563Z" }, + { url = "https://files.pythonhosted.org/packages/b9/49/ecccb5f2598daf0b4a1415497eba4c33c1e8ce07495eb07d2860c731b8d5/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:c8d1634419f39ea6f5c427ea2f90ca85126b54b50837f31497f3bf38266e853d", size = 241544, upload-time = "2025-10-06T05:35:59.719Z" }, + { url = "https://files.pythonhosted.org/packages/53/4b/ddf24113323c0bbcc54cb38c8b8916f1da7165e07b8e24a717b4a12cbf10/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:1a7fa382a4a223773ed64242dbe1c9c326ec09457e6b8428efb4118c685c3dfd", size = 241806, upload-time = "2025-10-06T05:36:00.959Z" }, + { url = "https://files.pythonhosted.org/packages/a7/fb/9b9a084d73c67175484ba2789a59f8eebebd0827d186a8102005ce41e1ba/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:11847b53d722050808926e785df837353bd4d75f1d494377e59b23594d834967", size = 229382, upload-time = "2025-10-06T05:36:02.22Z" }, + { url = "https://files.pythonhosted.org/packages/95/a3/c8fb25aac55bf5e12dae5c5aa6a98f85d436c1dc658f21c3ac73f9fa95e5/frozenlist-1.8.0-cp311-cp311-win32.whl", hash = "sha256:27c6e8077956cf73eadd514be8fb04d77fc946a7fe9f7fe167648b0b9085cc25", size = 39647, upload-time = "2025-10-06T05:36:03.409Z" }, + { url = "https://files.pythonhosted.org/packages/0a/f5/603d0d6a02cfd4c8f2a095a54672b3cf967ad688a60fb9faf04fc4887f65/frozenlist-1.8.0-cp311-cp311-win_amd64.whl", hash = "sha256:ac913f8403b36a2c8610bbfd25b8013488533e71e62b4b4adce9c86c8cea905b", size = 44064, upload-time = "2025-10-06T05:36:04.368Z" }, + { url = "https://files.pythonhosted.org/packages/5d/16/c2c9ab44e181f043a86f9a8f84d5124b62dbcb3a02c0977ec72b9ac1d3e0/frozenlist-1.8.0-cp311-cp311-win_arm64.whl", hash = "sha256:d4d3214a0f8394edfa3e303136d0575eece0745ff2b47bd2cb2e66dd92d4351a", size = 39937, upload-time = "2025-10-06T05:36:05.669Z" }, + { 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/2d/40/0832c31a37d60f60ed79e9dfb5a92e1e2af4f40a16a29abcc7992af9edff/frozenlist-1.8.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:8d92f1a84bb12d9e56f818b3a746f3efba93c1b63c8387a73dde655e1e42282a", size = 85717, upload-time = "2025-10-06T05:36:27.341Z" }, + { url = "https://files.pythonhosted.org/packages/30/ba/b0b3de23f40bc55a7057bd38434e25c34fa48e17f20ee273bbde5e0650f3/frozenlist-1.8.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:96153e77a591c8adc2ee805756c61f59fef4cf4073a9275ee86fe8cba41241f7", size = 49651, upload-time = "2025-10-06T05:36:28.855Z" }, + { url = "https://files.pythonhosted.org/packages/0c/ab/6e5080ee374f875296c4243c381bbdef97a9ac39c6e3ce1d5f7d42cb78d6/frozenlist-1.8.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f21f00a91358803399890ab167098c131ec2ddd5f8f5fd5fe9c9f2c6fcd91e40", size = 49417, upload-time = "2025-10-06T05:36:29.877Z" }, + { url = "https://files.pythonhosted.org/packages/d5/4e/e4691508f9477ce67da2015d8c00acd751e6287739123113a9fca6f1604e/frozenlist-1.8.0-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:fb30f9626572a76dfe4293c7194a09fb1fe93ba94c7d4f720dfae3b646b45027", size = 234391, upload-time = "2025-10-06T05:36:31.301Z" }, + { url = "https://files.pythonhosted.org/packages/40/76/c202df58e3acdf12969a7895fd6f3bc016c642e6726aa63bd3025e0fc71c/frozenlist-1.8.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:eaa352d7047a31d87dafcacbabe89df0aa506abb5b1b85a2fb91bc3faa02d822", size = 233048, upload-time = "2025-10-06T05:36:32.531Z" }, + { url = "https://files.pythonhosted.org/packages/f9/c0/8746afb90f17b73ca5979c7a3958116e105ff796e718575175319b5bb4ce/frozenlist-1.8.0-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:03ae967b4e297f58f8c774c7eabcce57fe3c2434817d4385c50661845a058121", size = 226549, upload-time = "2025-10-06T05:36:33.706Z" }, + { url = "https://files.pythonhosted.org/packages/7e/eb/4c7eefc718ff72f9b6c4893291abaae5fbc0c82226a32dcd8ef4f7a5dbef/frozenlist-1.8.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f6292f1de555ffcc675941d65fffffb0a5bcd992905015f85d0592201793e0e5", size = 239833, upload-time = "2025-10-06T05:36:34.947Z" }, + { url = "https://files.pythonhosted.org/packages/c2/4e/e5c02187cf704224f8b21bee886f3d713ca379535f16893233b9d672ea71/frozenlist-1.8.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:29548f9b5b5e3460ce7378144c3010363d8035cea44bc0bf02d57f5a685e084e", size = 245363, upload-time = "2025-10-06T05:36:36.534Z" }, + { url = "https://files.pythonhosted.org/packages/1f/96/cb85ec608464472e82ad37a17f844889c36100eed57bea094518bf270692/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ec3cc8c5d4084591b4237c0a272cc4f50a5b03396a47d9caaf76f5d7b38a4f11", size = 229314, upload-time = "2025-10-06T05:36:38.582Z" }, + { url = "https://files.pythonhosted.org/packages/5d/6f/4ae69c550e4cee66b57887daeebe006fe985917c01d0fff9caab9883f6d0/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:517279f58009d0b1f2e7c1b130b377a349405da3f7621ed6bfae50b10adf20c1", size = 243365, upload-time = "2025-10-06T05:36:40.152Z" }, + { url = "https://files.pythonhosted.org/packages/7a/58/afd56de246cf11780a40a2c28dc7cbabbf06337cc8ddb1c780a2d97e88d8/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:db1e72ede2d0d7ccb213f218df6a078a9c09a7de257c2fe8fcef16d5925230b1", size = 237763, upload-time = "2025-10-06T05:36:41.355Z" }, + { url = "https://files.pythonhosted.org/packages/cb/36/cdfaf6ed42e2644740d4a10452d8e97fa1c062e2a8006e4b09f1b5fd7d63/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:b4dec9482a65c54a5044486847b8a66bf10c9cb4926d42927ec4e8fd5db7fed8", size = 240110, upload-time = "2025-10-06T05:36:42.716Z" }, + { url = "https://files.pythonhosted.org/packages/03/a8/9ea226fbefad669f11b52e864c55f0bd57d3c8d7eb07e9f2e9a0b39502e1/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:21900c48ae04d13d416f0e1e0c4d81f7931f73a9dfa0b7a8746fb2fe7dd970ed", size = 233717, upload-time = "2025-10-06T05:36:44.251Z" }, + { url = "https://files.pythonhosted.org/packages/1e/0b/1b5531611e83ba7d13ccc9988967ea1b51186af64c42b7a7af465dcc9568/frozenlist-1.8.0-cp313-cp313-win32.whl", hash = "sha256:8b7b94a067d1c504ee0b16def57ad5738701e4ba10cec90529f13fa03c833496", size = 39628, upload-time = "2025-10-06T05:36:45.423Z" }, + { url = "https://files.pythonhosted.org/packages/d8/cf/174c91dbc9cc49bc7b7aab74d8b734e974d1faa8f191c74af9b7e80848e6/frozenlist-1.8.0-cp313-cp313-win_amd64.whl", hash = "sha256:878be833caa6a3821caf85eb39c5ba92d28e85df26d57afb06b35b2efd937231", size = 43882, upload-time = "2025-10-06T05:36:46.796Z" }, + { url = "https://files.pythonhosted.org/packages/c1/17/502cd212cbfa96eb1388614fe39a3fc9ab87dbbe042b66f97acb57474834/frozenlist-1.8.0-cp313-cp313-win_arm64.whl", hash = "sha256:44389d135b3ff43ba8cc89ff7f51f5a0bb6b63d829c8300f79a2fe4fe61bcc62", size = 39676, upload-time = "2025-10-06T05:36:47.8Z" }, + { url = "https://files.pythonhosted.org/packages/d2/5c/3bbfaa920dfab09e76946a5d2833a7cbdf7b9b4a91c714666ac4855b88b4/frozenlist-1.8.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:e25ac20a2ef37e91c1b39938b591457666a0fa835c7783c3a8f33ea42870db94", size = 89235, upload-time = "2025-10-06T05:36:48.78Z" }, + { url = "https://files.pythonhosted.org/packages/d2/d6/f03961ef72166cec1687e84e8925838442b615bd0b8854b54923ce5b7b8a/frozenlist-1.8.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:07cdca25a91a4386d2e76ad992916a85038a9b97561bf7a3fd12d5d9ce31870c", size = 50742, upload-time = "2025-10-06T05:36:49.837Z" }, + { url = "https://files.pythonhosted.org/packages/1e/bb/a6d12b7ba4c3337667d0e421f7181c82dda448ce4e7ad7ecd249a16fa806/frozenlist-1.8.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:4e0c11f2cc6717e0a741f84a527c52616140741cd812a50422f83dc31749fb52", size = 51725, upload-time = "2025-10-06T05:36:50.851Z" }, + { url = "https://files.pythonhosted.org/packages/bc/71/d1fed0ffe2c2ccd70b43714c6cab0f4188f09f8a67a7914a6b46ee30f274/frozenlist-1.8.0-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:b3210649ee28062ea6099cfda39e147fa1bc039583c8ee4481cb7811e2448c51", size = 284533, upload-time = "2025-10-06T05:36:51.898Z" }, + { url = "https://files.pythonhosted.org/packages/c9/1f/fb1685a7b009d89f9bf78a42d94461bc06581f6e718c39344754a5d9bada/frozenlist-1.8.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:581ef5194c48035a7de2aefc72ac6539823bb71508189e5de01d60c9dcd5fa65", size = 292506, upload-time = "2025-10-06T05:36:53.101Z" }, + { url = "https://files.pythonhosted.org/packages/e6/3b/b991fe1612703f7e0d05c0cf734c1b77aaf7c7d321df4572e8d36e7048c8/frozenlist-1.8.0-cp313-cp313t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3ef2d026f16a2b1866e1d86fc4e1291e1ed8a387b2c333809419a2f8b3a77b82", size = 274161, upload-time = "2025-10-06T05:36:54.309Z" }, + { url = "https://files.pythonhosted.org/packages/ca/ec/c5c618767bcdf66e88945ec0157d7f6c4a1322f1473392319b7a2501ded7/frozenlist-1.8.0-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5500ef82073f599ac84d888e3a8c1f77ac831183244bfd7f11eaa0289fb30714", size = 294676, upload-time = "2025-10-06T05:36:55.566Z" }, + { url = "https://files.pythonhosted.org/packages/7c/ce/3934758637d8f8a88d11f0585d6495ef54b2044ed6ec84492a91fa3b27aa/frozenlist-1.8.0-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:50066c3997d0091c411a66e710f4e11752251e6d2d73d70d8d5d4c76442a199d", size = 300638, upload-time = "2025-10-06T05:36:56.758Z" }, + { url = "https://files.pythonhosted.org/packages/fc/4f/a7e4d0d467298f42de4b41cbc7ddaf19d3cfeabaf9ff97c20c6c7ee409f9/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:5c1c8e78426e59b3f8005e9b19f6ff46e5845895adbde20ece9218319eca6506", size = 283067, upload-time = "2025-10-06T05:36:57.965Z" }, + { url = "https://files.pythonhosted.org/packages/dc/48/c7b163063d55a83772b268e6d1affb960771b0e203b632cfe09522d67ea5/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:eefdba20de0d938cec6a89bd4d70f346a03108a19b9df4248d3cf0d88f1b0f51", size = 292101, upload-time = "2025-10-06T05:36:59.237Z" }, + { url = "https://files.pythonhosted.org/packages/9f/d0/2366d3c4ecdc2fd391e0afa6e11500bfba0ea772764d631bbf82f0136c9d/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:cf253e0e1c3ceb4aaff6df637ce033ff6535fb8c70a764a8f46aafd3d6ab798e", size = 289901, upload-time = "2025-10-06T05:37:00.811Z" }, + { url = "https://files.pythonhosted.org/packages/b8/94/daff920e82c1b70e3618a2ac39fbc01ae3e2ff6124e80739ce5d71c9b920/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:032efa2674356903cd0261c4317a561a6850f3ac864a63fc1583147fb05a79b0", size = 289395, upload-time = "2025-10-06T05:37:02.115Z" }, + { url = "https://files.pythonhosted.org/packages/e3/20/bba307ab4235a09fdcd3cc5508dbabd17c4634a1af4b96e0f69bfe551ebd/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:6da155091429aeba16851ecb10a9104a108bcd32f6c1642867eadaee401c1c41", size = 283659, upload-time = "2025-10-06T05:37:03.711Z" }, + { url = "https://files.pythonhosted.org/packages/fd/00/04ca1c3a7a124b6de4f8a9a17cc2fcad138b4608e7a3fc5877804b8715d7/frozenlist-1.8.0-cp313-cp313t-win32.whl", hash = "sha256:0f96534f8bfebc1a394209427d0f8a63d343c9779cda6fc25e8e121b5fd8555b", size = 43492, upload-time = "2025-10-06T05:37:04.915Z" }, + { url = "https://files.pythonhosted.org/packages/59/5e/c69f733a86a94ab10f68e496dc6b7e8bc078ebb415281d5698313e3af3a1/frozenlist-1.8.0-cp313-cp313t-win_amd64.whl", hash = "sha256:5d63a068f978fc69421fb0e6eb91a9603187527c86b7cd3f534a5b77a592b888", size = 48034, upload-time = "2025-10-06T05:37:06.343Z" }, + { url = "https://files.pythonhosted.org/packages/16/6c/be9d79775d8abe79b05fa6d23da99ad6e7763a1d080fbae7290b286093fd/frozenlist-1.8.0-cp313-cp313t-win_arm64.whl", hash = "sha256:bf0a7e10b077bf5fb9380ad3ae8ce20ef919a6ad93b4552896419ac7e1d8e042", size = 41749, upload-time = "2025-10-06T05:37:07.431Z" }, + { url = "https://files.pythonhosted.org/packages/f1/c8/85da824b7e7b9b6e7f7705b2ecaf9591ba6f79c1177f324c2735e41d36a2/frozenlist-1.8.0-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:cee686f1f4cadeb2136007ddedd0aaf928ab95216e7691c63e50a8ec066336d0", size = 86127, upload-time = "2025-10-06T05:37:08.438Z" }, + { url = "https://files.pythonhosted.org/packages/8e/e8/a1185e236ec66c20afd72399522f142c3724c785789255202d27ae992818/frozenlist-1.8.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:119fb2a1bd47307e899c2fac7f28e85b9a543864df47aa7ec9d3c1b4545f096f", size = 49698, upload-time = "2025-10-06T05:37:09.48Z" }, + { url = "https://files.pythonhosted.org/packages/a1/93/72b1736d68f03fda5fdf0f2180fb6caaae3894f1b854d006ac61ecc727ee/frozenlist-1.8.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:4970ece02dbc8c3a92fcc5228e36a3e933a01a999f7094ff7c23fbd2beeaa67c", size = 49749, upload-time = "2025-10-06T05:37:10.569Z" }, + { url = "https://files.pythonhosted.org/packages/a7/b2/fabede9fafd976b991e9f1b9c8c873ed86f202889b864756f240ce6dd855/frozenlist-1.8.0-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:cba69cb73723c3f329622e34bdbf5ce1f80c21c290ff04256cff1cd3c2036ed2", size = 231298, upload-time = "2025-10-06T05:37:11.993Z" }, + { url = "https://files.pythonhosted.org/packages/3a/3b/d9b1e0b0eed36e70477ffb8360c49c85c8ca8ef9700a4e6711f39a6e8b45/frozenlist-1.8.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:778a11b15673f6f1df23d9586f83c4846c471a8af693a22e066508b77d201ec8", size = 232015, upload-time = "2025-10-06T05:37:13.194Z" }, + { url = "https://files.pythonhosted.org/packages/dc/94/be719d2766c1138148564a3960fc2c06eb688da592bdc25adcf856101be7/frozenlist-1.8.0-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:0325024fe97f94c41c08872db482cf8ac4800d80e79222c6b0b7b162d5b13686", size = 225038, upload-time = "2025-10-06T05:37:14.577Z" }, + { url = "https://files.pythonhosted.org/packages/e4/09/6712b6c5465f083f52f50cf74167b92d4ea2f50e46a9eea0523d658454ae/frozenlist-1.8.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:97260ff46b207a82a7567b581ab4190bd4dfa09f4db8a8b49d1a958f6aa4940e", size = 240130, upload-time = "2025-10-06T05:37:15.781Z" }, + { url = "https://files.pythonhosted.org/packages/f8/d4/cd065cdcf21550b54f3ce6a22e143ac9e4836ca42a0de1022da8498eac89/frozenlist-1.8.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:54b2077180eb7f83dd52c40b2750d0a9f175e06a42e3213ce047219de902717a", size = 242845, upload-time = "2025-10-06T05:37:17.037Z" }, + { url = "https://files.pythonhosted.org/packages/62/c3/f57a5c8c70cd1ead3d5d5f776f89d33110b1addae0ab010ad774d9a44fb9/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:2f05983daecab868a31e1da44462873306d3cbfd76d1f0b5b69c473d21dbb128", size = 229131, upload-time = "2025-10-06T05:37:18.221Z" }, + { url = "https://files.pythonhosted.org/packages/6c/52/232476fe9cb64f0742f3fde2b7d26c1dac18b6d62071c74d4ded55e0ef94/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:33f48f51a446114bc5d251fb2954ab0164d5be02ad3382abcbfe07e2531d650f", size = 240542, upload-time = "2025-10-06T05:37:19.771Z" }, + { url = "https://files.pythonhosted.org/packages/5f/85/07bf3f5d0fb5414aee5f47d33c6f5c77bfe49aac680bfece33d4fdf6a246/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:154e55ec0655291b5dd1b8731c637ecdb50975a2ae70c606d100750a540082f7", size = 237308, upload-time = "2025-10-06T05:37:20.969Z" }, + { url = "https://files.pythonhosted.org/packages/11/99/ae3a33d5befd41ac0ca2cc7fd3aa707c9c324de2e89db0e0f45db9a64c26/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:4314debad13beb564b708b4a496020e5306c7333fa9a3ab90374169a20ffab30", size = 238210, upload-time = "2025-10-06T05:37:22.252Z" }, + { url = "https://files.pythonhosted.org/packages/b2/60/b1d2da22f4970e7a155f0adde9b1435712ece01b3cd45ba63702aea33938/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:073f8bf8becba60aa931eb3bc420b217bb7d5b8f4750e6f8b3be7f3da85d38b7", size = 231972, upload-time = "2025-10-06T05:37:23.5Z" }, + { url = "https://files.pythonhosted.org/packages/3f/ab/945b2f32de889993b9c9133216c068b7fcf257d8595a0ac420ac8677cab0/frozenlist-1.8.0-cp314-cp314-win32.whl", hash = "sha256:bac9c42ba2ac65ddc115d930c78d24ab8d4f465fd3fc473cdedfccadb9429806", size = 40536, upload-time = "2025-10-06T05:37:25.581Z" }, + { url = "https://files.pythonhosted.org/packages/59/ad/9caa9b9c836d9ad6f067157a531ac48b7d36499f5036d4141ce78c230b1b/frozenlist-1.8.0-cp314-cp314-win_amd64.whl", hash = "sha256:3e0761f4d1a44f1d1a47996511752cf3dcec5bbdd9cc2b4fe595caf97754b7a0", size = 44330, upload-time = "2025-10-06T05:37:26.928Z" }, + { url = "https://files.pythonhosted.org/packages/82/13/e6950121764f2676f43534c555249f57030150260aee9dcf7d64efda11dd/frozenlist-1.8.0-cp314-cp314-win_arm64.whl", hash = "sha256:d1eaff1d00c7751b7c6662e9c5ba6eb2c17a2306ba5e2a37f24ddf3cc953402b", size = 40627, upload-time = "2025-10-06T05:37:28.075Z" }, + { url = "https://files.pythonhosted.org/packages/c0/c7/43200656ecc4e02d3f8bc248df68256cd9572b3f0017f0a0c4e93440ae23/frozenlist-1.8.0-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:d3bb933317c52d7ea5004a1c442eef86f426886fba134ef8cf4226ea6ee1821d", size = 89238, upload-time = "2025-10-06T05:37:29.373Z" }, + { url = "https://files.pythonhosted.org/packages/d1/29/55c5f0689b9c0fb765055629f472c0de484dcaf0acee2f7707266ae3583c/frozenlist-1.8.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:8009897cdef112072f93a0efdce29cd819e717fd2f649ee3016efd3cd885a7ed", size = 50738, upload-time = "2025-10-06T05:37:30.792Z" }, + { url = "https://files.pythonhosted.org/packages/ba/7d/b7282a445956506fa11da8c2db7d276adcbf2b17d8bb8407a47685263f90/frozenlist-1.8.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:2c5dcbbc55383e5883246d11fd179782a9d07a986c40f49abe89ddf865913930", size = 51739, upload-time = "2025-10-06T05:37:32.127Z" }, + { url = "https://files.pythonhosted.org/packages/62/1c/3d8622e60d0b767a5510d1d3cf21065b9db874696a51ea6d7a43180a259c/frozenlist-1.8.0-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:39ecbc32f1390387d2aa4f5a995e465e9e2f79ba3adcac92d68e3e0afae6657c", size = 284186, upload-time = "2025-10-06T05:37:33.21Z" }, + { url = "https://files.pythonhosted.org/packages/2d/14/aa36d5f85a89679a85a1d44cd7a6657e0b1c75f61e7cad987b203d2daca8/frozenlist-1.8.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:92db2bf818d5cc8d9c1f1fc56b897662e24ea5adb36ad1f1d82875bd64e03c24", size = 292196, upload-time = "2025-10-06T05:37:36.107Z" }, + { url = "https://files.pythonhosted.org/packages/05/23/6bde59eb55abd407d34f77d39a5126fb7b4f109a3f611d3929f14b700c66/frozenlist-1.8.0-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:2dc43a022e555de94c3b68a4ef0b11c4f747d12c024a520c7101709a2144fb37", size = 273830, upload-time = "2025-10-06T05:37:37.663Z" }, + { url = "https://files.pythonhosted.org/packages/d2/3f/22cff331bfad7a8afa616289000ba793347fcd7bc275f3b28ecea2a27909/frozenlist-1.8.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:cb89a7f2de3602cfed448095bab3f178399646ab7c61454315089787df07733a", size = 294289, upload-time = "2025-10-06T05:37:39.261Z" }, + { url = "https://files.pythonhosted.org/packages/a4/89/5b057c799de4838b6c69aa82b79705f2027615e01be996d2486a69ca99c4/frozenlist-1.8.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:33139dc858c580ea50e7e60a1b0ea003efa1fd42e6ec7fdbad78fff65fad2fd2", size = 300318, upload-time = "2025-10-06T05:37:43.213Z" }, + { url = "https://files.pythonhosted.org/packages/30/de/2c22ab3eb2a8af6d69dc799e48455813bab3690c760de58e1bf43b36da3e/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:168c0969a329b416119507ba30b9ea13688fafffac1b7822802537569a1cb0ef", size = 282814, upload-time = "2025-10-06T05:37:45.337Z" }, + { url = "https://files.pythonhosted.org/packages/59/f7/970141a6a8dbd7f556d94977858cfb36fa9b66e0892c6dd780d2219d8cd8/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:28bd570e8e189d7f7b001966435f9dac6718324b5be2990ac496cf1ea9ddb7fe", size = 291762, upload-time = "2025-10-06T05:37:46.657Z" }, + { url = "https://files.pythonhosted.org/packages/c1/15/ca1adae83a719f82df9116d66f5bb28bb95557b3951903d39135620ef157/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:b2a095d45c5d46e5e79ba1e5b9cb787f541a8dee0433836cea4b96a2c439dcd8", size = 289470, upload-time = "2025-10-06T05:37:47.946Z" }, + { url = "https://files.pythonhosted.org/packages/ac/83/dca6dc53bf657d371fbc88ddeb21b79891e747189c5de990b9dfff2ccba1/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:eab8145831a0d56ec9c4139b6c3e594c7a83c2c8be25d5bcf2d86136a532287a", size = 289042, upload-time = "2025-10-06T05:37:49.499Z" }, + { url = "https://files.pythonhosted.org/packages/96/52/abddd34ca99be142f354398700536c5bd315880ed0a213812bc491cff5e4/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:974b28cf63cc99dfb2188d8d222bc6843656188164848c4f679e63dae4b0708e", size = 283148, upload-time = "2025-10-06T05:37:50.745Z" }, + { url = "https://files.pythonhosted.org/packages/af/d3/76bd4ed4317e7119c2b7f57c3f6934aba26d277acc6309f873341640e21f/frozenlist-1.8.0-cp314-cp314t-win32.whl", hash = "sha256:342c97bf697ac5480c0a7ec73cd700ecfa5a8a40ac923bd035484616efecc2df", size = 44676, upload-time = "2025-10-06T05:37:52.222Z" }, + { url = "https://files.pythonhosted.org/packages/89/76/c615883b7b521ead2944bb3480398cbb07e12b7b4e4d073d3752eb721558/frozenlist-1.8.0-cp314-cp314t-win_amd64.whl", hash = "sha256:06be8f67f39c8b1dc671f5d83aaefd3358ae5cdcf8314552c57e7ed3e6475bdd", size = 49451, upload-time = "2025-10-06T05:37:53.425Z" }, + { url = "https://files.pythonhosted.org/packages/e0/a3/5982da14e113d07b325230f95060e2169f5311b1017ea8af2a29b374c289/frozenlist-1.8.0-cp314-cp314t-win_arm64.whl", hash = "sha256:102e6314ca4da683dca92e3b1355490fed5f313b768500084fbe6371fddfdb79", size = 42507, upload-time = "2025-10-06T05:37:54.513Z" }, + { 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 = "2026.6.0" @@ -258,6 +1059,101 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/e5/22/4222d7ddf3da30f363edaa98e329c2bce6c65497c9cb2810931c8b2c0fbc/fsspec-2026.6.0-py3-none-any.whl", hash = "sha256:02e0b71817df9b2169dc30a16832045764def1191b43dcff5bb85bdee212d2a1", size = 203949, upload-time = "2026-06-16T01:57:26.358Z" }, ] +[package.optional-dependencies] +http = [ + { name = "aiohttp" }, +] + +[[package]] +name = "h11" +version = "0.16.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250, upload-time = "2025-04-24T03:35:25.427Z" } +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 = "hf-xet" +version = "1.6.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1b/ab/522a2ab67f27971a9d48ca666d4fca85ef7d5282d142e31fd087e27b1bbe/hf_xet-1.6.0.tar.gz", hash = "sha256:2e58454a340b3556dfa4972d5451aff4fba8dd42a236600ba1a1d2b1514f0fef", size = 920527, upload-time = "2026-08-03T22:33:13.243Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/41/62/3c062f593bd92ef4e77a0ef39541e3d82a0a1d3947c8a777a02a13a27828/hf_xet-1.6.0-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:70cbb9c896901600128cb9b6f06e132954fbede1db30f31f7c6c63f84cb7c31d", size = 4074584, upload-time = "2026-08-03T22:32:47.364Z" }, + { url = "https://files.pythonhosted.org/packages/bb/1e/c0ad437dd267a8e435bef594acf781bbc3874ff0b6435b4962d03ecf7cc4/hf_xet-1.6.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:23379c2f9ec8696d952b16414a2bae72cad86a52df869b050698ba60f538c675", size = 3867381, upload-time = "2026-08-03T22:32:49.049Z" }, + { url = "https://files.pythonhosted.org/packages/d5/ee/7c0d7b6ab336167531b1c30af2af003f054af4c749becbd7209ae33a77c3/hf_xet-1.6.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f2f7278c05c22fd60cb436cda1269649b3e81db65ecdc8496e5e164aa4143e7b", size = 4453982, upload-time = "2026-08-03T22:32:50.568Z" }, + { url = "https://files.pythonhosted.org/packages/63/06/ad8eab1c9525246650cbaa821caa3cdbaca734ab1a5b8c91bea09cbd8d69/hf_xet-1.6.0-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:948f15d3a9545cfe5932f6bd8b440f6ae630aee108f14b7bd6c561f7c2dcc522", size = 4249445, upload-time = "2026-08-03T22:32:52.391Z" }, + { url = "https://files.pythonhosted.org/packages/d8/26/1eee8aedb0dafc1ab9717dc9ac602cde33361b232dc06803f1f6ed18b58c/hf_xet-1.6.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:5153e6bb103ad49d6ea9f1b2e230db5a2ea32551ad09a706d2f61d7c7c80d80e", size = 4451099, upload-time = "2026-08-03T22:32:54.114Z" }, + { url = "https://files.pythonhosted.org/packages/67/57/0b88af1f194ab6c9c650547d9cc06bfeaab836ae4dcdb331676bfb8be95a/hf_xet-1.6.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:35cec30d75c6f9eb9c16a77cef68e85a103b72e24d4b473714ec9ff06428bab9", size = 4664712, upload-time = "2026-08-03T22:32:55.547Z" }, + { url = "https://files.pythonhosted.org/packages/53/a0/26b717a9d1840e8abf48dcec64b5ed8fbe472671d38ad28d30e147132b33/hf_xet-1.6.0-cp314-cp314t-win_amd64.whl", hash = "sha256:5789835d7c6bc9436962853192082374297fb72d7eff7e7762ec25ceb7e25338", size = 4025906, upload-time = "2026-08-03T22:32:57.391Z" }, + { url = "https://files.pythonhosted.org/packages/49/f6/4a9966633c6fef83af997e2cff68ec1963676d412bdfd096df2a93b8e185/hf_xet-1.6.0-cp314-cp314t-win_arm64.whl", hash = "sha256:75765820ce4700db3750c94acc8fe27c5fae4c9ec000a0dbac3ca082acf97765", size = 3849221, upload-time = "2026-08-03T22:32:59.123Z" }, + { url = "https://files.pythonhosted.org/packages/a2/50/7afa2c9c787405864fc47a0d1bbc02c62e9101947ed43c1f43899fc7d91d/hf_xet-1.6.0-cp38-abi3-macosx_10_12_x86_64.whl", hash = "sha256:633dc0cd71d32da58ab8c03ad38e2fac452c15c2b0a2866ebf6ededfe0a5061d", size = 4071729, upload-time = "2026-08-03T22:33:00.721Z" }, + { url = "https://files.pythonhosted.org/packages/4b/69/55b8dcf636142ae660fec1869fcac14c4da2e8412e14d6eee1523be77e9f/hf_xet-1.6.0-cp38-abi3-macosx_11_0_arm64.whl", hash = "sha256:f0906082d9932ae0c0057fa194041c22b4e2cdb46b2592ef3b91f020d62a081a", size = 3876287, upload-time = "2026-08-03T22:33:02.251Z" }, + { url = "https://files.pythonhosted.org/packages/67/4e/a28359bf1c1ecf11eba22123168c138698f7cb576ac678f5a2e16cd5da08/hf_xet-1.6.0-cp38-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d62671bb130879cef0ee4c9ebe47a14af6c66ec53e6d84dc15936e5ffdfac82f", size = 4464663, upload-time = "2026-08-03T22:33:03.802Z" }, + { url = "https://files.pythonhosted.org/packages/9a/69/1f0cbc2fb22ae6082d094f743d1b8945a3f36f6089cb95f42b7ee348cda7/hf_xet-1.6.0-cp38-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:0e6e21fa3cdfcdcd76748564bf593870a5e013f47d97cf10aed63aa222cff5b7", size = 4262538, upload-time = "2026-08-03T22:33:05.287Z" }, + { url = "https://files.pythonhosted.org/packages/d1/3a/4f4f2301ade26e404462d3336fa11f7958d914cabbabdd6e03c3c5d5658c/hf_xet-1.6.0-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:4fc74352a17015bd0ee90038bc9efe38db894cde45f268b6712b04fce8cd0acb", size = 4460520, upload-time = "2026-08-03T22:33:06.81Z" }, + { url = "https://files.pythonhosted.org/packages/ab/5f/311725e2a905534dfee2dcb5b08414f249147f1f12252bfc2bd24caa075c/hf_xet-1.6.0-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:8fb4f71cba6129110c3374a33f919001ff130488fc23553698e34cc1c2a1198c", size = 4675937, upload-time = "2026-08-03T22:33:08.616Z" }, + { url = "https://files.pythonhosted.org/packages/98/b7/8c59a66d15205024662f1d66968136f13893f96df1ddc5087e2e281fc95f/hf_xet-1.6.0-cp38-abi3-win_amd64.whl", hash = "sha256:fb4fadde1b2b70bf4c0c14a6dccbe7194b1c28947fefd5bbe3fed9d940676c3b", size = 4033128, upload-time = "2026-08-03T22:33:10.171Z" }, + { url = "https://files.pythonhosted.org/packages/73/63/ca511b6f802f28cf3489b280fe77475bcca8de85e81a6299d7916b5b5555/hf_xet-1.6.0-cp38-abi3-win_arm64.whl", hash = "sha256:3dc3e35441ba395006af5aaacc40ef2e603c51ef46c3530b9156185f00935ea3", size = 3859359, upload-time = "2026-08-03T22:33:11.725Z" }, +] + +[[package]] +name = "httpcore" +version = "1.0.9" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "certifi" }, + { name = "h11" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484, upload-time = "2025-04-24T22:06:22.219Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784, upload-time = "2025-04-24T22:06:20.566Z" }, +] + +[[package]] +name = "httpx" +version = "0.28.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "certifi" }, + { name = "httpcore" }, + { name = "idna" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406, upload-time = "2024-12-06T15:37:23.222Z" } +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]] +name = "huggingface-hub" +version = "1.30.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "click" }, + { name = "filelock" }, + { name = "fsspec" }, + { name = "hf-xet", marker = "platform_machine == 'AMD64' or platform_machine == 'aarch64' or platform_machine == 'amd64' or platform_machine == 'arm64' or platform_machine == 'x86_64'" }, + { name = "httpx" }, + { name = "packaging" }, + { name = "pyyaml" }, + { name = "tqdm" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/35/97/2eb4abaa5b969ed385066a0496a3823b3ff467fc1082e2202955f1867d60/huggingface_hub-1.30.0.tar.gz", hash = "sha256:e6a6120bc8c8e2723d03648434ee247088cceb55ba7067e7d34d692cad5fdb57", size = 964291, upload-time = "2026-09-03T10:05:14.053Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c3/0e/3e45bbe0dd48f4e56b1d46649d342de853cd1c7e815323472ab62687f153/huggingface_hub-1.30.0-py3-none-any.whl", hash = "sha256:96ae0a8e99a234374a6fe43e989ebd21c04640b91ab2927e7e5773ba1131ca59", size = 796795, upload-time = "2026-09-03T10:05:12.21Z" }, +] + +[[package]] +name = "idna" +version = "3.19" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/5f/f7/abb373e5757eaec4b922b92f97ec8d6d7e057cf06778247604fbc4e7c3f3/idna-3.19.tar.gz", hash = "sha256:5e0811a4383b21dc5838069f801c4fb62113b7447663d2530d2bd6e77b49bf15", size = 215237, upload-time = "2026-08-18T05:14:24.27Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/57/b0/0e52c878c53f245edd3a11020f20979b3f490f245af532c7cae3027754b5/idna-3.19-py3-none-any.whl", hash = "sha256:815e7be7a7806d54abb586dc943addc79e8b2ee16915059658cbeff4b1b43bf4", size = 68550, upload-time = "2026-08-18T05:14:22.343Z" }, +] + [[package]] name = "iniconfig" version = "2.3.0" @@ -267,6 +1163,104 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" }, ] +[[package]] +name = "ipykernel" +version = "7.3.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "appnope", marker = "sys_platform == 'darwin'" }, + { name = "comm" }, + { name = "debugpy" }, + { name = "ipython" }, + { name = "jupyter-client" }, + { name = "jupyter-core" }, + { name = "matplotlib-inline" }, + { name = "nest-asyncio2" }, + { name = "packaging" }, + { name = "psutil" }, + { name = "pyzmq" }, + { name = "tornado" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/3d/c4/e4a38f579de4225a561305666f7541cdabb30075def2aa1ac17bd73c1fb5/ipykernel-7.3.0.tar.gz", hash = "sha256:9acaaaf97d16355166e4085afe9d225bfbdf2b7ef520f9df3be8f2b248275e09", size = 184899, upload-time = "2026-06-10T08:41:25.481Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3d/02/77b271f5dc58bfbc0b577c877b2365d1ffea2afe66a80c13f2312820348c/ipykernel-7.3.0-py3-none-any.whl", hash = "sha256:897eb64da762549ef610698fca5e9675195ec6ac8ec7f19d81ce1ca20c876057", size = 120583, upload-time = "2026-06-10T08:41:23.648Z" }, +] + +[[package]] +name = "ipython" +version = "9.17.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "ipython-pygments-lexers" }, + { name = "jedi" }, + { name = "matplotlib-inline" }, + { name = "pexpect", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" }, + { name = "prompt-toolkit" }, + { name = "psutil", marker = "sys_platform != 'cygwin' and sys_platform != 'emscripten'" }, + { name = "pygments" }, + { name = "stack-data" }, + { name = "traitlets" }, + { name = "typing-extensions", marker = "python_full_version < '3.12'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b9/32/99451b1283ec5d92ad77073f12e1c667dc10775384d8f15c2914207149dd/ipython-9.17.1.tar.gz", hash = "sha256:8919be8c27f20a6f4423145028063f6637b42a03ce57665bb12015ee1f073529", size = 4539289, upload-time = "2026-09-01T08:29:32.6Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2d/1e/65b59cf518c106aa755e7f7da3099027738687a862ec785060702a481320/ipython-9.17.1-py3-none-any.whl", hash = "sha256:6d1645743cfd1a07eb695d85aa2b5fa66721f8cbae9431d4049f7084bbf06509", size = 639038, upload-time = "2026-09-01T08:29:30.673Z" }, +] + +[[package]] +name = "ipython-pygments-lexers" +version = "1.1.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pygments" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ef/4c/5dd1d8af08107f88c7f741ead7a40854b8ac24ddf9ae850afbcf698aa552/ipython_pygments_lexers-1.1.1.tar.gz", hash = "sha256:09c0138009e56b6854f9535736f4171d855c8c08a563a0dcd8022f78355c7e81", size = 8393, upload-time = "2025-01-17T11:24:34.505Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d9/33/1f075bf72b0b747cb3288d011319aaf64083cf2efef8354174e3ed4540e2/ipython_pygments_lexers-1.1.1-py3-none-any.whl", hash = "sha256:a9462224a505ade19a605f71f8fa63c2048833ce50abc86768a0d81d876dc81c", size = 8074, upload-time = "2025-01-17T11:24:33.271Z" }, +] + +[[package]] +name = "ipywidgets" +version = "8.1.9" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "comm" }, + { name = "ipython" }, + { name = "jupyterlab-widgets" }, + { name = "traitlets" }, + { name = "widgetsnbextension" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c9/7c/6db60eddf38547353b06d57941f5eee22a990640ce30479fd71a810507f2/ipywidgets-8.1.9.tar.gz", hash = "sha256:bcccba38a6ec3253f7a39c943cea5b9ad01999ce071396171adbc51c6a6a8613", size = 117252, upload-time = "2026-08-18T08:54:24.123Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c3/55/298e9b3b864a198234997e87a1471c1b17d7f3546ace6d18fb5cf1ce24b2/ipywidgets-8.1.9-py3-none-any.whl", hash = "sha256:f2b8cbcaae10252b809fbe4d7470db75c09b769a32cbf816d20e5ca6d3c5a79d", size = 140101, upload-time = "2026-08-18T08:54:22.339Z" }, +] + +[[package]] +name = "isoduration" +version = "20.11.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "arrow" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/7c/1a/3c8edc664e06e6bd06cce40c6b22da5f1429aa4224d0c590f3be21c91ead/isoduration-20.11.0.tar.gz", hash = "sha256:ac2f9015137935279eac671f94f89eb00584f940f5dc49462a0c4ee692ba1bd9", size = 11649, upload-time = "2020-11-01T11:00:00.312Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7b/55/e5326141505c5d5e34c5e0935d2908a74e4561eca44108fbfb9c13d2911a/isoduration-20.11.0-py3-none-any.whl", hash = "sha256:b2904c2a4228c3d44f409c8ae8e2370eb21a26f7ac2ec5446df141dde3452042", size = 11321, upload-time = "2020-11-01T10:59:58.02Z" }, +] + +[[package]] +name = "jedi" +version = "0.20.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "parso" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/46/b7/a3635f6a2d7cf5b5dd98064fc1d5fbbafcb25477bcea204a3a92145d158b/jedi-0.20.0.tar.gz", hash = "sha256:c3f4ccbd276696f4b19c54618d4fb18f9fc24b0aef02acf704b23f487daa1011", size = 3119416, upload-time = "2026-05-01T23:38:47.814Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9a/93/242e2eab5fe682ffcb8b0084bde703a41d51e17ee0f3a31ff0d9d813620a/jedi-0.20.0-py2.py3-none-any.whl", hash = "sha256:7bdd9c2634f56713299976f4cbd59cb3fa92165cc5e05ea811fb253480728b67", size = 4884812, upload-time = "2026-05-01T23:38:43.919Z" }, +] + [[package]] name = "jinja2" version = "3.1.6" @@ -279,6 +1273,278 @@ 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 = "json5" +version = "0.15.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e4/7d/05c46a96a78147ae3bf99c2f4169ce144a70220b8d6fcd56f6ec368b8ce9/json5-0.15.0.tar.gz", hash = "sha256:7424d1f1eb1d56da6e3d70643f53619862b4ce81440bdb8ecfd6f875e5ba4a71", size = 53278, upload-time = "2026-06-19T20:08:27.716Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/eb/be/59527c99478aade6bb33a68d72e6e18dd4e6ff6eacfc7d01bdb15bc76912/json5-0.15.0-py3-none-any.whl", hash = "sha256:56636a30c0e8a4665fe2179c0212f32eae3796dea89ea6f649b9436ecdb39618", size = 36570, upload-time = "2026-06-19T20:08:26.748Z" }, +] + +[[package]] +name = "jsonpointer" +version = "3.1.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/18/c7/af399a2e7a67fd18d63c40c5e62d3af4e67b836a2107468b6a5ea24c4304/jsonpointer-3.1.1.tar.gz", hash = "sha256:0b801c7db33a904024f6004d526dcc53bbb8a4a0f4e32bfd10beadf60adf1900", size = 9068, upload-time = "2026-03-23T22:32:32.458Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9e/6a/a83720e953b1682d2d109d3c2dbb0bc9bf28cc1cbc205be4ef4be5da709d/jsonpointer-3.1.1-py3-none-any.whl", hash = "sha256:8ff8b95779d071ba472cf5bc913028df06031797532f08a7d5b602d8b2a488ca", size = 7659, upload-time = "2026-03-23T22:32:31.568Z" }, +] + +[[package]] +name = "jsonschema" +version = "4.26.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "attrs" }, + { name = "jsonschema-specifications" }, + { name = "referencing" }, + { name = "rpds-py" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b3/fc/e067678238fa451312d4c62bf6e6cf5ec56375422aee02f9cb5f909b3047/jsonschema-4.26.0.tar.gz", hash = "sha256:0c26707e2efad8aa1bfc5b7ce170f3fccc2e4918ff85989ba9ffa9facb2be326", size = 366583, upload-time = "2026-01-07T13:41:07.246Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/69/90/f63fb5873511e014207a475e2bb4e8b2e570d655b00ac19a9a0ca0a385ee/jsonschema-4.26.0-py3-none-any.whl", hash = "sha256:d489f15263b8d200f8387e64b4c3a75f06629559fb73deb8fdfb525f2dab50ce", size = 90630, upload-time = "2026-01-07T13:41:05.306Z" }, +] + +[package.optional-dependencies] +format-nongpl = [ + { name = "fqdn" }, + { name = "idna" }, + { name = "isoduration" }, + { name = "jsonpointer" }, + { name = "rfc3339-validator" }, + { name = "rfc3986-validator" }, + { name = "rfc3987-syntax" }, + { name = "uri-template" }, + { name = "webcolors" }, +] + +[[package]] +name = "jsonschema-specifications" +version = "2025.9.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "referencing" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/19/74/a633ee74eb36c44aa6d1095e7cc5569bebf04342ee146178e2d36600708b/jsonschema_specifications-2025.9.1.tar.gz", hash = "sha256:b540987f239e745613c7a9176f3edb72b832a4ac465cf02712288397832b5e8d", size = 32855, upload-time = "2025-09-08T01:34:59.186Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/41/45/1a4ed80516f02155c51f51e8cedb3c1902296743db0bbc66608a0db2814f/jsonschema_specifications-2025.9.1-py3-none-any.whl", hash = "sha256:98802fee3a11ee76ecaca44429fda8a41bff98b00a0f2838151b113f210cc6fe", size = 18437, upload-time = "2025-09-08T01:34:57.871Z" }, +] + +[[package]] +name = "jupyter" +version = "1.1.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "ipykernel" }, + { name = "ipywidgets" }, + { name = "jupyter-console" }, + { name = "jupyterlab" }, + { name = "nbconvert" }, + { name = "notebook" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/58/f3/af28ea964ab8bc1e472dba2e82627d36d470c51f5cd38c37502eeffaa25e/jupyter-1.1.1.tar.gz", hash = "sha256:d55467bceabdea49d7e3624af7e33d59c37fff53ed3a350e1ac957bed731de7a", size = 5714959, upload-time = "2024-08-30T07:15:48.299Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/38/64/285f20a31679bf547b75602702f7800e74dbabae36ef324f716c02804753/jupyter-1.1.1-py2.py3-none-any.whl", hash = "sha256:7a59533c22af65439b24bbe60373a4e95af8f16ac65a6c00820ad378e3f7cc83", size = 2657, upload-time = "2024-08-30T07:15:47.045Z" }, +] + +[[package]] +name = "jupyter-builder" +version = "1.2.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-core" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/75/3e/56f593e6a664cd14d441724654ce8243f3cac7d3e45867cf084749c8bc75/jupyter_builder-1.2.3.tar.gz", hash = "sha256:01aba6794eb9b19e0e29ae21137ca60ba4135c70347d4b9f664a586822b8c809", size = 1024218, upload-time = "2026-09-04T18:54:09.411Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/84/aa/be79e87c50698673f196d0633fc1664607da2289f9688d1de7a1c9db9e71/jupyter_builder-1.2.3-py3-none-any.whl", hash = "sha256:c5ea5a7190c2a7b082494abade98eece1b2b5bd5dbd7d610606cbcd10a1d08b3", size = 947541, upload-time = "2026-09-04T18:54:07.644Z" }, +] + +[[package]] +name = "jupyter-client" +version = "8.10.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-core" }, + { name = "python-dateutil" }, + { name = "pyzmq" }, + { name = "tornado" }, + { name = "traitlets" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c5/2a/906772148a06e48885039e0250c340b770a55bbf37b08d6ee0449df369c3/jupyter_client-8.10.0.tar.gz", hash = "sha256:9f7116294dca55f1785be880057d44544db9b1567718d92cb33c58886afb9497", size = 360653, upload-time = "2026-08-28T12:17:10.854Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0f/88/7c548de1f6c2ade7c931a3282da73f9274fa6a1531091be682f89c85efb9/jupyter_client-8.10.0-py3-none-any.whl", hash = "sha256:5f73f24f22fa25192cfff6b23c051932a2473a797b05734aff495b392103e14e", size = 110184, upload-time = "2026-08-28T12:17:09.028Z" }, +] + +[[package]] +name = "jupyter-console" +version = "6.6.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "ipykernel" }, + { name = "ipython" }, + { name = "jupyter-client" }, + { name = "jupyter-core" }, + { name = "prompt-toolkit" }, + { name = "pygments" }, + { name = "pyzmq" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/bd/2d/e2fd31e2fc41c14e2bcb6c976ab732597e907523f6b2420305f9fc7fdbdb/jupyter_console-6.6.3.tar.gz", hash = "sha256:566a4bf31c87adbfadf22cdf846e3069b59a71ed5da71d6ba4d8aaad14a53539", size = 34363, upload-time = "2023-03-06T14:13:31.02Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ca/77/71d78d58f15c22db16328a476426f7ac4a60d3a5a7ba3b9627ee2f7903d4/jupyter_console-6.6.3-py3-none-any.whl", hash = "sha256:309d33409fcc92ffdad25f0bcdf9a4a9daa61b6f341177570fdac03de5352485", size = 24510, upload-time = "2023-03-06T14:13:28.229Z" }, +] + +[[package]] +name = "jupyter-core" +version = "5.9.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "platformdirs" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/02/49/9d1284d0dc65e2c757b74c6687b6d319b02f822ad039e5c512df9194d9dd/jupyter_core-5.9.1.tar.gz", hash = "sha256:4d09aaff303b9566c3ce657f580bd089ff5c91f5f89cf7d8846c3cdf465b5508", size = 89814, upload-time = "2025-10-16T19:19:18.444Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e7/e7/80988e32bf6f73919a113473a604f5a8f09094de312b9d52b79c2df7612b/jupyter_core-5.9.1-py3-none-any.whl", hash = "sha256:ebf87fdc6073d142e114c72c9e29a9d7ca03fad818c5d300ce2adc1fb0743407", size = 29032, upload-time = "2025-10-16T19:19:16.783Z" }, +] + +[[package]] +name = "jupyter-events" +version = "0.12.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jsonschema", extra = ["format-nongpl"] }, + { name = "packaging" }, + { name = "python-json-logger" }, + { name = "pyyaml" }, + { name = "referencing" }, + { name = "rfc3339-validator" }, + { name = "rfc3986-validator" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/18/f8/475c4241b2b75af0deaae453ed003c6c851766dbc44d332d8baf245dc931/jupyter_events-0.12.1.tar.gz", hash = "sha256:faff25f77218335752f35f23c5fe6e4a392a7bd99a5939ccb9b8fbf594636cf3", size = 62854, upload-time = "2026-04-20T23:17:50.66Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/eb/6c/6fcde0c8f616ed360ffd3587f7db9e225a7e62b583a04494d2f069cf64ea/jupyter_events-0.12.1-py3-none-any.whl", hash = "sha256:c366585253f537a627da52fa7ca7410c5b5301fe893f511e7b077c2d93ec8bcf", size = 19512, upload-time = "2026-04-20T23:17:48.927Z" }, +] + +[[package]] +name = "jupyter-lsp" +version = "2.3.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-server" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/36/ff/1e4a61f5170a9a1d978f3ac3872449de6c01fc71eaf89657824c878b1549/jupyter_lsp-2.3.1.tar.gz", hash = "sha256:fdf8a4aa7d85813976d6e29e95e6a2c8f752701f926f2715305249a3829805a6", size = 55677, upload-time = "2026-04-02T08:10:06.749Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/23/e8/9d61dcbd1dce8ef418f06befd4ac084b4720429c26b0b1222bc218685eff/jupyter_lsp-2.3.1-py3-none-any.whl", hash = "sha256:71b954d834e85ff3096400554f2eefaf7fe37053036f9a782b0f7c5e42dadb81", size = 77513, upload-time = "2026-04-02T08:10:01.753Z" }, +] + +[[package]] +name = "jupyter-server" +version = "2.21.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "argon2-cffi" }, + { name = "jinja2" }, + { name = "jupyter-client" }, + { name = "jupyter-core" }, + { name = "jupyter-events" }, + { name = "jupyter-server-terminals" }, + { name = "nbconvert" }, + { name = "nbformat" }, + { name = "overrides", marker = "python_full_version < '3.12'" }, + { name = "packaging" }, + { name = "prometheus-client" }, + { name = "pywinpty", marker = "os_name == 'nt'" }, + { name = "pyzmq" }, + { name = "send2trash" }, + { name = "terminado" }, + { name = "tornado" }, + { name = "traitlets" }, + { name = "websocket-client" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/cf/e0/63b481d5b21f81fe23173dfc9eb25629fa1bc174fdc4a2c19d09c1ff8124/jupyter_server-2.21.0.tar.gz", hash = "sha256:70d9a1883f57d3576ea17f4ce061ec1a7aad7ef388d00428cfb7f5e4f0022271", size = 760357, upload-time = "2026-08-27T16:06:34.049Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cb/8a/cb97c2b353cb46cced413be8f742fa8fcd3cb1659524f27314494aa94968/jupyter_server-2.21.0-py3-none-any.whl", hash = "sha256:2ae2e5ce5e97268553e25aebe040197455673d925b5fc7995477153318160cf7", size = 393961, upload-time = "2026-08-27T16:06:31.814Z" }, +] + +[[package]] +name = "jupyter-server-terminals" +version = "0.5.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pywinpty", marker = "os_name == 'nt'" }, + { name = "terminado" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f4/a7/bcd0a9b0cbba88986fe944aaaf91bfda603e5a50bda8ed15123f381a3b2f/jupyter_server_terminals-0.5.4.tar.gz", hash = "sha256:bbda128ed41d0be9020349f9f1f2a4ab9952a73ed5f5ac9f1419794761fb87f5", size = 31770, upload-time = "2026-01-14T16:53:20.213Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d1/2d/6674563f71c6320841fc300911a55143925112a72a883e2ca71fba4c618d/jupyter_server_terminals-0.5.4-py3-none-any.whl", hash = "sha256:55be353fc74a80bc7f3b20e6be50a55a61cd525626f578dcb66a5708e2007d14", size = 13704, upload-time = "2026-01-14T16:53:18.738Z" }, +] + +[[package]] +name = "jupyterlab" +version = "4.6.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "async-lru" }, + { name = "httpx" }, + { name = "ipykernel" }, + { name = "jinja2" }, + { name = "jupyter-builder" }, + { name = "jupyter-core" }, + { name = "jupyter-lsp" }, + { name = "jupyter-server" }, + { name = "jupyterlab-server" }, + { name = "notebook-shim" }, + { name = "packaging" }, + { name = "tornado" }, + { name = "traitlets" }, + { name = "typing-extensions", marker = "python_full_version < '3.12'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/00/c0/45934229995d4c6e38192ca118d93185f60808f64157e3df3c5c28f8c5fd/jupyterlab-4.6.3.tar.gz", hash = "sha256:2e3db6e3a12495ebd188276e985bf5ac502fbde3d1e8628819920210008de498", size = 28319771, upload-time = "2026-08-10T18:50:57.947Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e9/47/242f46de028074651c9bd6d8000fc340ed0d3cdd1a0eae4387826123413a/jupyterlab-4.6.3-py3-none-any.whl", hash = "sha256:0a1ebc6567186f1eabd99536e94df7ed9e96d1e7c5ddf3e4406ae16e88abacb7", size = 17168312, upload-time = "2026-08-10T18:50:53.044Z" }, +] + +[[package]] +name = "jupyterlab-pygments" +version = "0.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/90/51/9187be60d989df97f5f0aba133fa54e7300f17616e065d1ada7d7646b6d6/jupyterlab_pygments-0.3.0.tar.gz", hash = "sha256:721aca4d9029252b11cfa9d185e5b5af4d54772bb8072f9b7036f4170054d35d", size = 512900, upload-time = "2023-11-23T09:26:37.44Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b1/dd/ead9d8ea85bf202d90cc513b533f9c363121c7792674f78e0d8a854b63b4/jupyterlab_pygments-0.3.0-py3-none-any.whl", hash = "sha256:841a89020971da1d8693f1a99997aefc5dc424bb1b251fd6322462a1b8842780", size = 15884, upload-time = "2023-11-23T09:26:34.325Z" }, +] + +[[package]] +name = "jupyterlab-server" +version = "2.28.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "babel" }, + { name = "jinja2" }, + { name = "json5" }, + { name = "jsonschema" }, + { name = "jupyter-server" }, + { name = "packaging" }, + { name = "requests" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/d6/2c/90153f189e421e93c4bb4f9e3f59802a1f01abd2ac5cf40b152d7f735232/jupyterlab_server-2.28.0.tar.gz", hash = "sha256:35baa81898b15f93573e2deca50d11ac0ae407ebb688299d3a5213265033712c", size = 76996, upload-time = "2025-10-22T13:59:18.37Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e0/07/a000fe835f76b7e1143242ab1122e6362ef1c03f23f83a045c38859c2ae0/jupyterlab_server-2.28.0-py3-none-any.whl", hash = "sha256:e4355b148fdcf34d312bbbc80f22467d6d20460e8b8736bf235577dd18506968", size = 59830, upload-time = "2025-10-22T13:59:16.767Z" }, +] + +[[package]] +name = "jupyterlab-widgets" +version = "3.0.17" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/21/8b/e739cf9066ad5037a2d4b0a403f06da374fdccb9748221661c8b492d3dbc/jupyterlab_widgets-3.0.17.tar.gz", hash = "sha256:6e61fe21ca8a66039180a5cc52a433e07279d2fee79c8be963e00d55193f17a8", size = 213919, upload-time = "2026-08-18T08:52:17.511Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/33/ef/6d27fc118f58cb24886da413545a7efb0853d405fddbfd8b2d9ac09fbed4/jupyterlab_widgets-3.0.17-py3-none-any.whl", hash = "sha256:40ac1e9955acf116c4d995d9bfa082d86ad9ec6d91c4f134827cf5e0a5eb75e0", size = 217292, upload-time = "2026-08-18T08:52:15.47Z" }, +] + [[package]] name = "kiwisolver" version = "1.5.0" @@ -405,18 +1671,31 @@ dependencies = [ dev = [ { name = "pytest" }, ] +llm = [ + { name = "accelerate" }, + { name = "datasets" }, + { name = "peft" }, + { name = "transformers" }, +] mnist = [ { name = "torchvision" }, ] neural = [ { name = "torch" }, ] +notebooks = [ + { name = "jupyter" }, +] [package.metadata] requires-dist = [ + { name = "accelerate", marker = "extra == 'llm'" }, + { name = "datasets", marker = "extra == 'llm'" }, + { name = "jupyter", marker = "extra == 'notebooks'", specifier = ">=1.0" }, { name = "matplotlib", specifier = ">=3.8" }, { name = "numpy", specifier = ">=1.26" }, { name = "pandas", specifier = ">=2.1" }, + { name = "peft", marker = "extra == 'llm'", specifier = ">=0.11" }, { name = "pyarrow", specifier = ">=15" }, { name = "pydantic", specifier = ">=2.5" }, { name = "pytest", marker = "extra == 'dev'", specifier = ">=8.0" }, @@ -424,8 +1703,30 @@ requires-dist = [ { name = "scipy", specifier = ">=1.11" }, { name = "torch", marker = "extra == 'neural'", specifier = ">=2.2" }, { name = "torchvision", marker = "extra == 'mnist'", specifier = ">=0.17" }, + { name = "transformers", marker = "extra == 'llm'", specifier = ">=4.44" }, +] +provides-extras = ["dev", "neural", "mnist", "llm", "notebooks"] + +[[package]] +name = "lark" +version = "1.3.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/da/34/28fff3ab31ccff1fd4f6c7c7b0ceb2b6968d8ea4950663eadcb5720591a0/lark-1.3.1.tar.gz", hash = "sha256:b426a7a6d6d53189d318f2b6236ab5d6429eaf09259f1ca33eb716eed10d2905", size = 382732, upload-time = "2025-10-27T18:25:56.653Z" } +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 = "markdown-it-py" +version = "4.2.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "mdurl" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/06/ff/7841249c247aa650a76b9ee4bbaeae59370dc8bfd2f6c01f3630c35eb134/markdown_it_py-4.2.0.tar.gz", hash = "sha256:04a21681d6fbb623de53f6f364d352309d4094dd4194040a10fd51833e418d49", size = 82454, upload-time = "2026-05-07T12:08:28.36Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b3/81/4da04ced5a082363ecfa159c010d200ecbd959ae410c10c0264a38cac0f5/markdown_it_py-4.2.0-py3-none-any.whl", hash = "sha256:9f7ebbcd14fe59494226453aed97c1070d83f8d24b6fc3a3bcf9a38092641c4a", size = 91687, upload-time = "2026-05-07T12:08:27.182Z" }, ] -provides-extras = ["dev", "neural", "mnist"] [[package]] name = "markupsafe" @@ -566,6 +1867,36 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/0c/d8/c4ecab06b7ea36a570c4f3bd2d48d1799fd5d9174470e45c2194199431e7/matplotlib-3.11.0-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:cf662e5ac5707658cb931e19972c4bd99f7b4f8b7bf79d3c821d239fa6b71e64", size = 10015653, upload-time = "2026-06-12T02:29:13.251Z" }, ] +[[package]] +name = "matplotlib-inline" +version = "0.2.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/bd/c0/9f7c9a46090390368a4d7bcb76bb87a4a36c421e4c0792cdb53486ffac7a/matplotlib_inline-0.2.2.tar.gz", hash = "sha256:72f3fe8fce36b70d4a5b612f899090cd0401deddc4ea90e1572b9f4bfb058c79", size = 8150, upload-time = "2026-05-08T17:33:33.49Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/41/09/5b161152e2d90f7b87f781c2e1267494aef9c32498df793f73ad0a0a494a/matplotlib_inline-0.2.2-py3-none-any.whl", hash = "sha256:3c821cf1c209f59fb2d2d64abbf5b23b67bcb2210d663f9918dd851c6da1fcf6", size = 9534, upload-time = "2026-05-08T17:33:32.055Z" }, +] + +[[package]] +name = "mdurl" +version = "0.1.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729, upload-time = "2022-08-14T12:40:10.846Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979, upload-time = "2022-08-14T12:40:09.779Z" }, +] + +[[package]] +name = "mistune" +version = "3.3.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7b/92/328a294a6de83bacb95bed01f04e0eaff4e3616ee359fc821a5dfc539b02/mistune-3.3.4.tar.gz", hash = "sha256:58b5c96d6fcb61190dfe5fae498d2b2065f99cf61e9649418fd54cf1ada86dfe", size = 121426, upload-time = "2026-07-22T05:22:30.89Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/77/e4/288365afae98953bc01de09f686f40d8ee84578135aa7767d5d4e60b5278/mistune-3.3.4-py3-none-any.whl", hash = "sha256:ee015381e955e370962968befe1d729ab60fafb6a715ac6751763fbce38c8d4a", size = 66862, upload-time = "2026-07-22T05:22:29.419Z" }, +] + [[package]] name = "mpmath" version = "1.3.0" @@ -575,6 +1906,207 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/43/e3/7d92a15f894aa0c9c4b49b8ee9ac9850d6e63b03c9c32c0367a13ae62209/mpmath-1.3.0-py3-none-any.whl", hash = "sha256:a0b2b9fe80bbcd81a6647ff13108738cfb482d481d826cc0e02f5b35e5c88d2c", size = 536198, upload-time = "2023-03-07T16:47:09.197Z" }, ] +[[package]] +name = "multidict" +version = "6.7.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1a/c2/c2d94cbe6ac1753f3fc980da97b3d930efe1da3af3c9f5125354436c073d/multidict-6.7.1.tar.gz", hash = "sha256:ec6652a1bee61c53a3e5776b6049172c53b6aaba34f18c9ad04f82712bac623d", size = 102010, upload-time = "2026-01-26T02:46:45.979Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ce/f1/a90635c4f88fb913fbf4ce660b83b7445b7a02615bda034b2f8eb38fd597/multidict-6.7.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:7ff981b266af91d7b4b3793ca3382e53229088d193a85dfad6f5f4c27fc73e5d", size = 76626, upload-time = "2026-01-26T02:43:26.485Z" }, + { url = "https://files.pythonhosted.org/packages/a6/9b/267e64eaf6fc637a15b35f5de31a566634a2740f97d8d094a69d34f524a4/multidict-6.7.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:844c5bca0b5444adb44a623fb0a1310c2f4cd41f402126bb269cd44c9b3f3e1e", size = 44706, upload-time = "2026-01-26T02:43:27.607Z" }, + { url = "https://files.pythonhosted.org/packages/dd/a4/d45caf2b97b035c57267791ecfaafbd59c68212004b3842830954bb4b02e/multidict-6.7.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:f2a0a924d4c2e9afcd7ec64f9de35fcd96915149b2216e1cb2c10a56df483855", size = 44356, upload-time = "2026-01-26T02:43:28.661Z" }, + { url = "https://files.pythonhosted.org/packages/fd/d2/0a36c8473f0cbaeadd5db6c8b72d15bbceeec275807772bfcd059bef487d/multidict-6.7.1-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:8be1802715a8e892c784c0197c2ace276ea52702a0ede98b6310c8f255a5afb3", size = 244355, upload-time = "2026-01-26T02:43:31.165Z" }, + { url = "https://files.pythonhosted.org/packages/5d/16/8c65be997fd7dd311b7d39c7b6e71a0cb449bad093761481eccbbe4b42a2/multidict-6.7.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2e2d2ed645ea29f31c4c7ea1552fcfd7cb7ba656e1eafd4134a6620c9f5fdd9e", size = 246433, upload-time = "2026-01-26T02:43:32.581Z" }, + { url = "https://files.pythonhosted.org/packages/01/fb/4dbd7e848d2799c6a026ec88ad39cf2b8416aa167fcc903baa55ecaa045c/multidict-6.7.1-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:95922cee9a778659e91db6497596435777bd25ed116701a4c034f8e46544955a", size = 225376, upload-time = "2026-01-26T02:43:34.417Z" }, + { url = "https://files.pythonhosted.org/packages/b6/8a/4a3a6341eac3830f6053062f8fbc9a9e54407c80755b3f05bc427295c2d0/multidict-6.7.1-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6b83cabdc375ffaaa15edd97eb7c0c672ad788e2687004990074d7d6c9b140c8", size = 257365, upload-time = "2026-01-26T02:43:35.741Z" }, + { url = "https://files.pythonhosted.org/packages/f7/a2/dd575a69c1aa206e12d27d0770cdf9b92434b48a9ef0cd0d1afdecaa93c4/multidict-6.7.1-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:38fb49540705369bab8484db0689d86c0a33a0a9f2c1b197f506b71b4b6c19b0", size = 254747, upload-time = "2026-01-26T02:43:36.976Z" }, + { url = "https://files.pythonhosted.org/packages/5a/56/21b27c560c13822ed93133f08aa6372c53a8e067f11fbed37b4adcdac922/multidict-6.7.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:439cbebd499f92e9aa6793016a8acaa161dfa749ae86d20960189f5398a19144", size = 246293, upload-time = "2026-01-26T02:43:38.258Z" }, + { url = "https://files.pythonhosted.org/packages/5a/a4/23466059dc3854763423d0ad6c0f3683a379d97673b1b89ec33826e46728/multidict-6.7.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6d3bc717b6fe763b8be3f2bee2701d3c8eb1b2a8ae9f60910f1b2860c82b6c49", size = 242962, upload-time = "2026-01-26T02:43:40.034Z" }, + { url = "https://files.pythonhosted.org/packages/1f/67/51dd754a3524d685958001e8fa20a0f5f90a6a856e0a9dcabff69be3dbb7/multidict-6.7.1-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:619e5a1ac57986dbfec9f0b301d865dddf763696435e2962f6d9cf2fdff2bb71", size = 237360, upload-time = "2026-01-26T02:43:41.752Z" }, + { url = "https://files.pythonhosted.org/packages/64/3f/036dfc8c174934d4b55d86ff4f978e558b0e585cef70cfc1ad01adc6bf18/multidict-6.7.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:0b38ebffd9be37c1170d33bc0f36f4f262e0a09bc1aac1c34c7aa51a7293f0b3", size = 245940, upload-time = "2026-01-26T02:43:43.042Z" }, + { url = "https://files.pythonhosted.org/packages/3d/20/6214d3c105928ebc353a1c644a6ef1408bc5794fcb4f170bb524a3c16311/multidict-6.7.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:10ae39c9cfe6adedcdb764f5e8411d4a92b055e35573a2eaa88d3323289ef93c", size = 253502, upload-time = "2026-01-26T02:43:44.371Z" }, + { url = "https://files.pythonhosted.org/packages/b1/e2/c653bc4ae1be70a0f836b82172d643fcf1dade042ba2676ab08ec08bff0f/multidict-6.7.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:25167cc263257660290fba06b9318d2026e3c910be240a146e1f66dd114af2b0", size = 247065, upload-time = "2026-01-26T02:43:45.745Z" }, + { url = "https://files.pythonhosted.org/packages/c8/11/a854b4154cd3bd8b1fd375e8a8ca9d73be37610c361543d56f764109509b/multidict-6.7.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:128441d052254f42989ef98b7b6a6ecb1e6f708aa962c7984235316db59f50fa", size = 241870, upload-time = "2026-01-26T02:43:47.054Z" }, + { url = "https://files.pythonhosted.org/packages/13/bf/9676c0392309b5fdae322333d22a829715b570edb9baa8016a517b55b558/multidict-6.7.1-cp311-cp311-win32.whl", hash = "sha256:d62b7f64ffde3b99d06b707a280db04fb3855b55f5a06df387236051d0668f4a", size = 41302, upload-time = "2026-01-26T02:43:48.753Z" }, + { url = "https://files.pythonhosted.org/packages/c9/68/f16a3a8ba6f7b6dc92a1f19669c0810bd2c43fc5a02da13b1cbf8e253845/multidict-6.7.1-cp311-cp311-win_amd64.whl", hash = "sha256:bdbf9f3b332abd0cdb306e7c2113818ab1e922dc84b8f8fd06ec89ed2a19ab8b", size = 45981, upload-time = "2026-01-26T02:43:49.921Z" }, + { url = "https://files.pythonhosted.org/packages/ac/ad/9dd5305253fa00cd3c7555dbef69d5bf4133debc53b87ab8d6a44d411665/multidict-6.7.1-cp311-cp311-win_arm64.whl", hash = "sha256:b8c990b037d2fff2f4e33d3f21b9b531c5745b33a49a7d6dbe7a177266af44f6", size = 43159, upload-time = "2026-01-26T02:43:51.635Z" }, + { url = "https://files.pythonhosted.org/packages/8d/9c/f20e0e2cf80e4b2e4b1c365bf5fe104ee633c751a724246262db8f1a0b13/multidict-6.7.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:a90f75c956e32891a4eda3639ce6dd86e87105271f43d43442a3aedf3cddf172", size = 76893, upload-time = "2026-01-26T02:43:52.754Z" }, + { url = "https://files.pythonhosted.org/packages/fe/cf/18ef143a81610136d3da8193da9d80bfe1cb548a1e2d1c775f26b23d024a/multidict-6.7.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:3fccb473e87eaa1382689053e4a4618e7ba7b9b9b8d6adf2027ee474597128cd", size = 45456, upload-time = "2026-01-26T02:43:53.893Z" }, + { url = "https://files.pythonhosted.org/packages/a9/65/1caac9d4cd32e8433908683446eebc953e82d22b03d10d41a5f0fefe991b/multidict-6.7.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b0fa96985700739c4c7853a43c0b3e169360d6855780021bfc6d0f1ce7c123e7", size = 43872, upload-time = "2026-01-26T02:43:55.041Z" }, + { url = "https://files.pythonhosted.org/packages/cf/3b/d6bd75dc4f3ff7c73766e04e705b00ed6dbbaccf670d9e05a12b006f5a21/multidict-6.7.1-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:cb2a55f408c3043e42b40cc8eecd575afa27b7e0b956dfb190de0f8499a57a53", size = 251018, upload-time = "2026-01-26T02:43:56.198Z" }, + { url = "https://files.pythonhosted.org/packages/fd/80/c959c5933adedb9ac15152e4067c702a808ea183a8b64cf8f31af8ad3155/multidict-6.7.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:eb0ce7b2a32d09892b3dd6cc44877a0d02a33241fafca5f25c8b6b62374f8b75", size = 258883, upload-time = "2026-01-26T02:43:57.499Z" }, + { url = "https://files.pythonhosted.org/packages/86/85/7ed40adafea3d4f1c8b916e3b5cc3a8e07dfcdcb9cd72800f4ed3ca1b387/multidict-6.7.1-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:c3a32d23520ee37bf327d1e1a656fec76a2edd5c038bf43eddfa0572ec49c60b", size = 242413, upload-time = "2026-01-26T02:43:58.755Z" }, + { url = "https://files.pythonhosted.org/packages/d2/57/b8565ff533e48595503c785f8361ff9a4fde4d67de25c207cd0ba3befd03/multidict-6.7.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9c90fed18bffc0189ba814749fdcc102b536e83a9f738a9003e569acd540a733", size = 268404, upload-time = "2026-01-26T02:44:00.216Z" }, + { url = "https://files.pythonhosted.org/packages/e0/50/9810c5c29350f7258180dfdcb2e52783a0632862eb334c4896ac717cebcb/multidict-6.7.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:da62917e6076f512daccfbbde27f46fed1c98fee202f0559adec8ee0de67f71a", size = 269456, upload-time = "2026-01-26T02:44:02.202Z" }, + { url = "https://files.pythonhosted.org/packages/f3/8d/5e5be3ced1d12966fefb5c4ea3b2a5b480afcea36406559442c6e31d4a48/multidict-6.7.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bfde23ef6ed9db7eaee6c37dcec08524cb43903c60b285b172b6c094711b3961", size = 256322, upload-time = "2026-01-26T02:44:03.56Z" }, + { url = "https://files.pythonhosted.org/packages/31/6e/d8a26d81ac166a5592782d208dd90dfdc0a7a218adaa52b45a672b46c122/multidict-6.7.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3758692429e4e32f1ba0df23219cd0b4fc0a52f476726fff9337d1a57676a582", size = 253955, upload-time = "2026-01-26T02:44:04.845Z" }, + { url = "https://files.pythonhosted.org/packages/59/4c/7c672c8aad41534ba619bcd4ade7a0dc87ed6b8b5c06149b85d3dd03f0cd/multidict-6.7.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:398c1478926eca669f2fd6a5856b6de9c0acf23a2cb59a14c0ba5844fa38077e", size = 251254, upload-time = "2026-01-26T02:44:06.133Z" }, + { url = "https://files.pythonhosted.org/packages/7b/bd/84c24de512cbafbdbc39439f74e967f19570ce7924e3007174a29c348916/multidict-6.7.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:c102791b1c4f3ab36ce4101154549105a53dc828f016356b3e3bcae2e3a039d3", size = 252059, upload-time = "2026-01-26T02:44:07.518Z" }, + { url = "https://files.pythonhosted.org/packages/fa/ba/f5449385510825b73d01c2d4087bf6d2fccc20a2d42ac34df93191d3dd03/multidict-6.7.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:a088b62bd733e2ad12c50dad01b7d0166c30287c166e137433d3b410add807a6", size = 263588, upload-time = "2026-01-26T02:44:09.382Z" }, + { url = "https://files.pythonhosted.org/packages/d7/11/afc7c677f68f75c84a69fe37184f0f82fce13ce4b92f49f3db280b7e92b3/multidict-6.7.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:3d51ff4785d58d3f6c91bdbffcb5e1f7ddfda557727043aa20d20ec4f65e324a", size = 259642, upload-time = "2026-01-26T02:44:10.73Z" }, + { url = "https://files.pythonhosted.org/packages/2b/17/ebb9644da78c4ab36403739e0e6e0e30ebb135b9caf3440825001a0bddcb/multidict-6.7.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fc5907494fccf3e7d3f94f95c91d6336b092b5fc83811720fae5e2765890dfba", size = 251377, upload-time = "2026-01-26T02:44:12.042Z" }, + { url = "https://files.pythonhosted.org/packages/ca/a4/840f5b97339e27846c46307f2530a2805d9d537d8b8bd416af031cad7fa0/multidict-6.7.1-cp312-cp312-win32.whl", hash = "sha256:28ca5ce2fd9716631133d0e9a9b9a745ad7f60bac2bccafb56aa380fc0b6c511", size = 41887, upload-time = "2026-01-26T02:44:14.245Z" }, + { url = "https://files.pythonhosted.org/packages/80/31/0b2517913687895f5904325c2069d6a3b78f66cc641a86a2baf75a05dcbb/multidict-6.7.1-cp312-cp312-win_amd64.whl", hash = "sha256:fcee94dfbd638784645b066074b338bc9cc155d4b4bffa4adce1615c5a426c19", size = 46053, upload-time = "2026-01-26T02:44:15.371Z" }, + { url = "https://files.pythonhosted.org/packages/0c/5b/aba28e4ee4006ae4c7df8d327d31025d760ffa992ea23812a601d226e682/multidict-6.7.1-cp312-cp312-win_arm64.whl", hash = "sha256:ba0a9fb644d0c1a2194cf7ffb043bd852cea63a57f66fbd33959f7dae18517bf", size = 43307, upload-time = "2026-01-26T02:44:16.852Z" }, + { url = "https://files.pythonhosted.org/packages/f2/22/929c141d6c0dba87d3e1d38fbdf1ba8baba86b7776469f2bc2d3227a1e67/multidict-6.7.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:2b41f5fed0ed563624f1c17630cb9941cf2309d4df00e494b551b5f3e3d67a23", size = 76174, upload-time = "2026-01-26T02:44:18.509Z" }, + { url = "https://files.pythonhosted.org/packages/c7/75/bc704ae15fee974f8fccd871305e254754167dce5f9e42d88a2def741a1d/multidict-6.7.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:84e61e3af5463c19b67ced91f6c634effb89ef8bfc5ca0267f954451ed4bb6a2", size = 45116, upload-time = "2026-01-26T02:44:19.745Z" }, + { url = "https://files.pythonhosted.org/packages/79/76/55cd7186f498ed080a18440c9013011eb548f77ae1b297206d030eb1180a/multidict-6.7.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:935434b9853c7c112eee7ac891bc4cb86455aa631269ae35442cb316790c1445", size = 43524, upload-time = "2026-01-26T02:44:21.571Z" }, + { url = "https://files.pythonhosted.org/packages/e9/3c/414842ef8d5a1628d68edee29ba0e5bcf235dbfb3ccd3ea303a7fe8c72ff/multidict-6.7.1-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:432feb25a1cb67fe82a9680b4d65fb542e4635cb3166cd9c01560651ad60f177", size = 249368, upload-time = "2026-01-26T02:44:22.803Z" }, + { url = "https://files.pythonhosted.org/packages/f6/32/befed7f74c458b4a525e60519fe8d87eef72bb1e99924fa2b0f9d97a221e/multidict-6.7.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e82d14e3c948952a1a85503817e038cba5905a3352de76b9a465075d072fba23", size = 256952, upload-time = "2026-01-26T02:44:24.306Z" }, + { url = "https://files.pythonhosted.org/packages/03/d6/c878a44ba877f366630c860fdf74bfb203c33778f12b6ac274936853c451/multidict-6.7.1-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:4cfb48c6ea66c83bcaaf7e4dfa7ec1b6bbcf751b7db85a328902796dfde4c060", size = 240317, upload-time = "2026-01-26T02:44:25.772Z" }, + { url = "https://files.pythonhosted.org/packages/68/49/57421b4d7ad2e9e60e25922b08ceb37e077b90444bde6ead629095327a6f/multidict-6.7.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:1d540e51b7e8e170174555edecddbd5538105443754539193e3e1061864d444d", size = 267132, upload-time = "2026-01-26T02:44:27.648Z" }, + { url = "https://files.pythonhosted.org/packages/b7/fe/ec0edd52ddbcea2a2e89e174f0206444a61440b40f39704e64dc807a70bd/multidict-6.7.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:273d23f4b40f3dce4d6c8a821c741a86dec62cded82e1175ba3d99be128147ed", size = 268140, upload-time = "2026-01-26T02:44:29.588Z" }, + { url = "https://files.pythonhosted.org/packages/b0/73/6e1b01cbeb458807aa0831742232dbdd1fa92bfa33f52a3f176b4ff3dc11/multidict-6.7.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9d624335fd4fa1c08a53f8b4be7676ebde19cd092b3895c421045ca87895b429", size = 254277, upload-time = "2026-01-26T02:44:30.902Z" }, + { url = "https://files.pythonhosted.org/packages/6a/b2/5fb8c124d7561a4974c342bc8c778b471ebbeb3cc17df696f034a7e9afe7/multidict-6.7.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:12fad252f8b267cc75b66e8fc51b3079604e8d43a75428ffe193cd9e2195dfd6", size = 252291, upload-time = "2026-01-26T02:44:32.31Z" }, + { url = "https://files.pythonhosted.org/packages/5a/96/51d4e4e06bcce92577fcd488e22600bd38e4fd59c20cb49434d054903bd2/multidict-6.7.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:03ede2a6ffbe8ef936b92cb4529f27f42be7f56afcdab5ab739cd5f27fb1cbf9", size = 250156, upload-time = "2026-01-26T02:44:33.734Z" }, + { url = "https://files.pythonhosted.org/packages/db/6b/420e173eec5fba721a50e2a9f89eda89d9c98fded1124f8d5c675f7a0c0f/multidict-6.7.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:90efbcf47dbe33dcf643a1e400d67d59abeac5db07dc3f27d6bdeae497a2198c", size = 249742, upload-time = "2026-01-26T02:44:35.222Z" }, + { url = "https://files.pythonhosted.org/packages/44/a3/ec5b5bd98f306bc2aa297b8c6f11a46714a56b1e6ef5ebda50a4f5d7c5fb/multidict-6.7.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:5c4b9bfc148f5a91be9244d6264c53035c8a0dcd2f51f1c3c6e30e30ebaa1c84", size = 262221, upload-time = "2026-01-26T02:44:36.604Z" }, + { url = "https://files.pythonhosted.org/packages/cd/f7/e8c0d0da0cd1e28d10e624604e1a36bcc3353aaebdfdc3a43c72bc683a12/multidict-6.7.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:401c5a650f3add2472d1d288c26deebc540f99e2fb83e9525007a74cd2116f1d", size = 258664, upload-time = "2026-01-26T02:44:38.008Z" }, + { url = "https://files.pythonhosted.org/packages/52/da/151a44e8016dd33feed44f730bd856a66257c1ee7aed4f44b649fb7edeb3/multidict-6.7.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:97891f3b1b3ffbded884e2916cacf3c6fc87b66bb0dde46f7357404750559f33", size = 249490, upload-time = "2026-01-26T02:44:39.386Z" }, + { url = "https://files.pythonhosted.org/packages/87/af/a3b86bf9630b732897f6fc3f4c4714b90aa4361983ccbdcd6c0339b21b0c/multidict-6.7.1-cp313-cp313-win32.whl", hash = "sha256:e1c5988359516095535c4301af38d8a8838534158f649c05dd1050222321bcb3", size = 41695, upload-time = "2026-01-26T02:44:41.318Z" }, + { url = "https://files.pythonhosted.org/packages/b2/35/e994121b0e90e46134673422dd564623f93304614f5d11886b1b3e06f503/multidict-6.7.1-cp313-cp313-win_amd64.whl", hash = "sha256:960c83bf01a95b12b08fd54324a4eb1d5b52c88932b5cba5d6e712bb3ed12eb5", size = 45884, upload-time = "2026-01-26T02:44:42.488Z" }, + { url = "https://files.pythonhosted.org/packages/ca/61/42d3e5dbf661242a69c97ea363f2d7b46c567da8eadef8890022be6e2ab0/multidict-6.7.1-cp313-cp313-win_arm64.whl", hash = "sha256:563fe25c678aaba333d5399408f5ec3c383ca5b663e7f774dd179a520b8144df", size = 43122, upload-time = "2026-01-26T02:44:43.664Z" }, + { url = "https://files.pythonhosted.org/packages/6d/b3/e6b21c6c4f314bb956016b0b3ef2162590a529b84cb831c257519e7fde44/multidict-6.7.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:c76c4bec1538375dad9d452d246ca5368ad6e1c9039dadcf007ae59c70619ea1", size = 83175, upload-time = "2026-01-26T02:44:44.894Z" }, + { url = "https://files.pythonhosted.org/packages/fb/76/23ecd2abfe0957b234f6c960f4ade497f55f2c16aeb684d4ecdbf1c95791/multidict-6.7.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:57b46b24b5d5ebcc978da4ec23a819a9402b4228b8a90d9c656422b4bdd8a963", size = 48460, upload-time = "2026-01-26T02:44:46.106Z" }, + { url = "https://files.pythonhosted.org/packages/c4/57/a0ed92b23f3a042c36bc4227b72b97eca803f5f1801c1ab77c8a212d455e/multidict-6.7.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:e954b24433c768ce78ab7929e84ccf3422e46deb45a4dc9f93438f8217fa2d34", size = 46930, upload-time = "2026-01-26T02:44:47.278Z" }, + { url = "https://files.pythonhosted.org/packages/b5/66/02ec7ace29162e447f6382c495dc95826bf931d3818799bbef11e8f7df1a/multidict-6.7.1-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:3bd231490fa7217cc832528e1cd8752a96f0125ddd2b5749390f7c3ec8721b65", size = 242582, upload-time = "2026-01-26T02:44:48.604Z" }, + { url = "https://files.pythonhosted.org/packages/58/18/64f5a795e7677670e872673aca234162514696274597b3708b2c0d276cce/multidict-6.7.1-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:253282d70d67885a15c8a7716f3a73edf2d635793ceda8173b9ecc21f2fb8292", size = 250031, upload-time = "2026-01-26T02:44:50.544Z" }, + { url = "https://files.pythonhosted.org/packages/c8/ed/e192291dbbe51a8290c5686f482084d31bcd9d09af24f63358c3d42fd284/multidict-6.7.1-cp313-cp313t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:0b4c48648d7649c9335cf1927a8b87fa692de3dcb15faa676c6a6f1f1aabda43", size = 228596, upload-time = "2026-01-26T02:44:51.951Z" }, + { url = "https://files.pythonhosted.org/packages/1e/7e/3562a15a60cf747397e7f2180b0a11dc0c38d9175a650e75fa1b4d325e15/multidict-6.7.1-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:98bc624954ec4d2c7cb074b8eefc2b5d0ce7d482e410df446414355d158fe4ca", size = 257492, upload-time = "2026-01-26T02:44:53.902Z" }, + { url = "https://files.pythonhosted.org/packages/24/02/7d0f9eae92b5249bb50ac1595b295f10e263dd0078ebb55115c31e0eaccd/multidict-6.7.1-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:1b99af4d9eec0b49927b4402bcbb58dea89d3e0db8806a4086117019939ad3dd", size = 255899, upload-time = "2026-01-26T02:44:55.316Z" }, + { url = "https://files.pythonhosted.org/packages/00/e3/9b60ed9e23e64c73a5cde95269ef1330678e9c6e34dd4eb6b431b85b5a10/multidict-6.7.1-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6aac4f16b472d5b7dc6f66a0d49dd57b0e0902090be16594dc9ebfd3d17c47e7", size = 247970, upload-time = "2026-01-26T02:44:56.783Z" }, + { url = "https://files.pythonhosted.org/packages/3e/06/538e58a63ed5cfb0bd4517e346b91da32fde409d839720f664e9a4ae4f9d/multidict-6.7.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:21f830fe223215dffd51f538e78c172ed7c7f60c9b96a2bf05c4848ad49921c3", size = 245060, upload-time = "2026-01-26T02:44:58.195Z" }, + { url = "https://files.pythonhosted.org/packages/b2/2f/d743a3045a97c895d401e9bd29aaa09b94f5cbdf1bd561609e5a6c431c70/multidict-6.7.1-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:f5dd81c45b05518b9aa4da4aa74e1c93d715efa234fd3e8a179df611cc85e5f4", size = 235888, upload-time = "2026-01-26T02:44:59.57Z" }, + { url = "https://files.pythonhosted.org/packages/38/83/5a325cac191ab28b63c52f14f1131f3b0a55ba3b9aa65a6d0bf2a9b921a0/multidict-6.7.1-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:eb304767bca2bb92fb9c5bd33cedc95baee5bb5f6c88e63706533a1c06ad08c8", size = 243554, upload-time = "2026-01-26T02:45:01.054Z" }, + { url = "https://files.pythonhosted.org/packages/20/1f/9d2327086bd15da2725ef6aae624208e2ef828ed99892b17f60c344e57ed/multidict-6.7.1-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:c9035dde0f916702850ef66460bc4239d89d08df4d02023a5926e7446724212c", size = 252341, upload-time = "2026-01-26T02:45:02.484Z" }, + { url = "https://files.pythonhosted.org/packages/e8/2c/2a1aa0280cf579d0f6eed8ee5211c4f1730bd7e06c636ba2ee6aafda302e/multidict-6.7.1-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:af959b9beeb66c822380f222f0e0a1889331597e81f1ded7f374f3ecb0fd6c52", size = 246391, upload-time = "2026-01-26T02:45:03.862Z" }, + { url = "https://files.pythonhosted.org/packages/e5/03/7ca022ffc36c5a3f6e03b179a5ceb829be9da5783e6fe395f347c0794680/multidict-6.7.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:41f2952231456154ee479651491e94118229844dd7226541788be783be2b5108", size = 243422, upload-time = "2026-01-26T02:45:05.296Z" }, + { url = "https://files.pythonhosted.org/packages/dc/1d/b31650eab6c5778aceed46ba735bd97f7c7d2f54b319fa916c0f96e7805b/multidict-6.7.1-cp313-cp313t-win32.whl", hash = "sha256:df9f19c28adcb40b6aae30bbaa1478c389efd50c28d541d76760199fc1037c32", size = 47770, upload-time = "2026-01-26T02:45:06.754Z" }, + { url = "https://files.pythonhosted.org/packages/ac/5b/2d2d1d522e51285bd61b1e20df8f47ae1a9d80839db0b24ea783b3832832/multidict-6.7.1-cp313-cp313t-win_amd64.whl", hash = "sha256:d54ecf9f301853f2c5e802da559604b3e95bb7a3b01a9c295c6ee591b9882de8", size = 53109, upload-time = "2026-01-26T02:45:08.044Z" }, + { url = "https://files.pythonhosted.org/packages/3d/a3/cc409ba012c83ca024a308516703cf339bdc4b696195644a7215a5164a24/multidict-6.7.1-cp313-cp313t-win_arm64.whl", hash = "sha256:5a37ca18e360377cfda1d62f5f382ff41f2b8c4ccb329ed974cc2e1643440118", size = 45573, upload-time = "2026-01-26T02:45:09.349Z" }, + { url = "https://files.pythonhosted.org/packages/91/cc/db74228a8be41884a567e88a62fd589a913708fcf180d029898c17a9a371/multidict-6.7.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:8f333ec9c5eb1b7105e3b84b53141e66ca05a19a605368c55450b6ba208cb9ee", size = 75190, upload-time = "2026-01-26T02:45:10.651Z" }, + { url = "https://files.pythonhosted.org/packages/d5/22/492f2246bb5b534abd44804292e81eeaf835388901f0c574bac4eeec73c5/multidict-6.7.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:a407f13c188f804c759fc6a9f88286a565c242a76b27626594c133b82883b5c2", size = 44486, upload-time = "2026-01-26T02:45:11.938Z" }, + { url = "https://files.pythonhosted.org/packages/f1/4f/733c48f270565d78b4544f2baddc2fb2a245e5a8640254b12c36ac7ac68e/multidict-6.7.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:0e161ddf326db5577c3a4cc2d8648f81456e8a20d40415541587a71620d7a7d1", size = 43219, upload-time = "2026-01-26T02:45:14.346Z" }, + { url = "https://files.pythonhosted.org/packages/24/bb/2c0c2287963f4259c85e8bcbba9182ced8d7fca65c780c38e99e61629d11/multidict-6.7.1-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:1e3a8bb24342a8201d178c3b4984c26ba81a577c80d4d525727427460a50c22d", size = 245132, upload-time = "2026-01-26T02:45:15.712Z" }, + { url = "https://files.pythonhosted.org/packages/a7/f9/44d4b3064c65079d2467888794dea218d1601898ac50222ab8a9a8094460/multidict-6.7.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:97231140a50f5d447d3164f994b86a0bed7cd016e2682f8650d6a9158e14fd31", size = 252420, upload-time = "2026-01-26T02:45:17.293Z" }, + { url = "https://files.pythonhosted.org/packages/8b/13/78f7275e73fa17b24c9a51b0bd9d73ba64bb32d0ed51b02a746eb876abe7/multidict-6.7.1-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:6b10359683bd8806a200fd2909e7c8ca3a7b24ec1d8132e483d58e791d881048", size = 233510, upload-time = "2026-01-26T02:45:19.356Z" }, + { url = "https://files.pythonhosted.org/packages/4b/25/8167187f62ae3cbd52da7893f58cb036b47ea3fb67138787c76800158982/multidict-6.7.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:283ddac99f7ac25a4acadbf004cb5ae34480bbeb063520f70ce397b281859362", size = 264094, upload-time = "2026-01-26T02:45:20.834Z" }, + { url = "https://files.pythonhosted.org/packages/a1/e7/69a3a83b7b030cf283fb06ce074a05a02322359783424d7edf0f15fe5022/multidict-6.7.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:538cec1e18c067d0e6103aa9a74f9e832904c957adc260e61cd9d8cf0c3b3d37", size = 260786, upload-time = "2026-01-26T02:45:22.818Z" }, + { url = "https://files.pythonhosted.org/packages/fe/3b/8ec5074bcfc450fe84273713b4b0a0dd47c0249358f5d82eb8104ffe2520/multidict-6.7.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7eee46ccb30ff48a1e35bb818cc90846c6be2b68240e42a78599166722cea709", size = 248483, upload-time = "2026-01-26T02:45:24.368Z" }, + { url = "https://files.pythonhosted.org/packages/48/5a/d5a99e3acbca0e29c5d9cba8f92ceb15dce78bab963b308ae692981e3a5d/multidict-6.7.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:fa263a02f4f2dd2d11a7b1bb4362aa7cb1049f84a9235d31adf63f30143469a0", size = 248403, upload-time = "2026-01-26T02:45:25.982Z" }, + { url = "https://files.pythonhosted.org/packages/35/48/e58cd31f6c7d5102f2a4bf89f96b9cf7e00b6c6f3d04ecc44417c00a5a3c/multidict-6.7.1-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:2e1425e2f99ec5bd36c15a01b690a1a2456209c5deed58f95469ffb46039ccbb", size = 240315, upload-time = "2026-01-26T02:45:27.487Z" }, + { url = "https://files.pythonhosted.org/packages/94/33/1cd210229559cb90b6786c30676bb0c58249ff42f942765f88793b41fdce/multidict-6.7.1-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:497394b3239fc6f0e13a78a3e1b61296e72bf1c5f94b4c4eb80b265c37a131cd", size = 245528, upload-time = "2026-01-26T02:45:28.991Z" }, + { url = "https://files.pythonhosted.org/packages/64/f2/6e1107d226278c876c783056b7db43d800bb64c6131cec9c8dfb6903698e/multidict-6.7.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:233b398c29d3f1b9676b4b6f75c518a06fcb2ea0b925119fb2c1bc35c05e1601", size = 258784, upload-time = "2026-01-26T02:45:30.503Z" }, + { url = "https://files.pythonhosted.org/packages/4d/c1/11f664f14d525e4a1b5327a82d4de61a1db604ab34c6603bb3c2cc63ad34/multidict-6.7.1-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:93b1818e4a6e0930454f0f2af7dfce69307ca03cdcfb3739bf4d91241967b6c1", size = 251980, upload-time = "2026-01-26T02:45:32.603Z" }, + { url = "https://files.pythonhosted.org/packages/e1/9f/75a9ac888121d0c5bbd4ecf4eead45668b1766f6baabfb3b7f66a410e231/multidict-6.7.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:f33dc2a3abe9249ea5d8360f969ec7f4142e7ac45ee7014d8f8d5acddf178b7b", size = 243602, upload-time = "2026-01-26T02:45:34.043Z" }, + { url = "https://files.pythonhosted.org/packages/9a/e7/50bf7b004cc8525d80dbbbedfdc7aed3e4c323810890be4413e589074032/multidict-6.7.1-cp314-cp314-win32.whl", hash = "sha256:3ab8b9d8b75aef9df299595d5388b14530839f6422333357af1339443cff777d", size = 40930, upload-time = "2026-01-26T02:45:36.278Z" }, + { url = "https://files.pythonhosted.org/packages/e0/bf/52f25716bbe93745595800f36fb17b73711f14da59ed0bb2eba141bc9f0f/multidict-6.7.1-cp314-cp314-win_amd64.whl", hash = "sha256:5e01429a929600e7dab7b166062d9bb54a5eed752384c7384c968c2afab8f50f", size = 45074, upload-time = "2026-01-26T02:45:37.546Z" }, + { url = "https://files.pythonhosted.org/packages/97/ab/22803b03285fa3a525f48217963da3a65ae40f6a1b6f6cf2768879e208f9/multidict-6.7.1-cp314-cp314-win_arm64.whl", hash = "sha256:4885cb0e817aef5d00a2e8451d4665c1808378dc27c2705f1bf4ef8505c0d2e5", size = 42471, upload-time = "2026-01-26T02:45:38.889Z" }, + { url = "https://files.pythonhosted.org/packages/e0/6d/f9293baa6146ba9507e360ea0292b6422b016907c393e2f63fc40ab7b7b5/multidict-6.7.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:0458c978acd8e6ea53c81eefaddbbee9c6c5e591f41b3f5e8e194780fe026581", size = 82401, upload-time = "2026-01-26T02:45:40.254Z" }, + { url = "https://files.pythonhosted.org/packages/7a/68/53b5494738d83558d87c3c71a486504d8373421c3e0dbb6d0db48ad42ee0/multidict-6.7.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:c0abd12629b0af3cf590982c0b413b1e7395cd4ec026f30986818ab95bfaa94a", size = 48143, upload-time = "2026-01-26T02:45:41.635Z" }, + { url = "https://files.pythonhosted.org/packages/37/e8/5284c53310dcdc99ce5d66563f6e5773531a9b9fe9ec7a615e9bc306b05f/multidict-6.7.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:14525a5f61d7d0c94b368a42cff4c9a4e7ba2d52e2672a7b23d84dc86fb02b0c", size = 46507, upload-time = "2026-01-26T02:45:42.99Z" }, + { url = "https://files.pythonhosted.org/packages/e4/fc/6800d0e5b3875568b4083ecf5f310dcf91d86d52573160834fb4bfcf5e4f/multidict-6.7.1-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:17307b22c217b4cf05033dabefe68255a534d637c6c9b0cc8382718f87be4262", size = 239358, upload-time = "2026-01-26T02:45:44.376Z" }, + { url = "https://files.pythonhosted.org/packages/41/75/4ad0973179361cdf3a113905e6e088173198349131be2b390f9fa4da5fc6/multidict-6.7.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7a7e590ff876a3eaf1c02a4dfe0724b6e69a9e9de6d8f556816f29c496046e59", size = 246884, upload-time = "2026-01-26T02:45:47.167Z" }, + { url = "https://files.pythonhosted.org/packages/c3/9c/095bb28b5da139bd41fb9a5d5caff412584f377914bd8787c2aa98717130/multidict-6.7.1-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:5fa6a95dfee63893d80a34758cd0e0c118a30b8dcb46372bf75106c591b77889", size = 225878, upload-time = "2026-01-26T02:45:48.698Z" }, + { url = "https://files.pythonhosted.org/packages/07/d0/c0a72000243756e8f5a277b6b514fa005f2c73d481b7d9e47cd4568aa2e4/multidict-6.7.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a0543217a6a017692aa6ae5cc39adb75e587af0f3a82288b1492eb73dd6cc2a4", size = 253542, upload-time = "2026-01-26T02:45:50.164Z" }, + { url = "https://files.pythonhosted.org/packages/c0/6b/f69da15289e384ecf2a68837ec8b5ad8c33e973aa18b266f50fe55f24b8c/multidict-6.7.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f99fe611c312b3c1c0ace793f92464d8cd263cc3b26b5721950d977b006b6c4d", size = 252403, upload-time = "2026-01-26T02:45:51.779Z" }, + { url = "https://files.pythonhosted.org/packages/a2/76/b9669547afa5a1a25cd93eaca91c0da1c095b06b6d2d8ec25b713588d3a1/multidict-6.7.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9004d8386d133b7e6135679424c91b0b854d2d164af6ea3f289f8f2761064609", size = 244889, upload-time = "2026-01-26T02:45:53.27Z" }, + { url = "https://files.pythonhosted.org/packages/7e/a9/a50d2669e506dad33cfc45b5d574a205587b7b8a5f426f2fbb2e90882588/multidict-6.7.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e628ef0e6859ffd8273c69412a2465c4be4a9517d07261b33334b5ec6f3c7489", size = 241982, upload-time = "2026-01-26T02:45:54.919Z" }, + { url = "https://files.pythonhosted.org/packages/c5/bb/1609558ad8b456b4827d3c5a5b775c93b87878fd3117ed3db3423dfbce1b/multidict-6.7.1-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:841189848ba629c3552035a6a7f5bf3b02eb304e9fea7492ca220a8eda6b0e5c", size = 232415, upload-time = "2026-01-26T02:45:56.981Z" }, + { url = "https://files.pythonhosted.org/packages/d8/59/6f61039d2aa9261871e03ab9dc058a550d240f25859b05b67fd70f80d4b3/multidict-6.7.1-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:ce1bbd7d780bb5a0da032e095c951f7014d6b0a205f8318308140f1a6aba159e", size = 240337, upload-time = "2026-01-26T02:45:58.698Z" }, + { url = "https://files.pythonhosted.org/packages/a1/29/fdc6a43c203890dc2ae9249971ecd0c41deaedfe00d25cb6564b2edd99eb/multidict-6.7.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:b26684587228afed0d50cf804cc71062cc9c1cdf55051c4c6345d372947b268c", size = 248788, upload-time = "2026-01-26T02:46:00.862Z" }, + { url = "https://files.pythonhosted.org/packages/a9/14/a153a06101323e4cf086ecee3faadba52ff71633d471f9685c42e3736163/multidict-6.7.1-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:9f9af11306994335398293f9958071019e3ab95e9a707dc1383a35613f6abcb9", size = 242842, upload-time = "2026-01-26T02:46:02.824Z" }, + { url = "https://files.pythonhosted.org/packages/41/5f/604ae839e64a4a6efc80db94465348d3b328ee955e37acb24badbcd24d83/multidict-6.7.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:b4938326284c4f1224178a560987b6cf8b4d38458b113d9b8c1db1a836e640a2", size = 240237, upload-time = "2026-01-26T02:46:05.898Z" }, + { url = "https://files.pythonhosted.org/packages/5f/60/c3a5187bf66f6fb546ff4ab8fb5a077cbdd832d7b1908d4365c7f74a1917/multidict-6.7.1-cp314-cp314t-win32.whl", hash = "sha256:98655c737850c064a65e006a3df7c997cd3b220be4ec8fe26215760b9697d4d7", size = 48008, upload-time = "2026-01-26T02:46:07.468Z" }, + { url = "https://files.pythonhosted.org/packages/0c/f7/addf1087b860ac60e6f382240f64fb99f8bfb532bb06f7c542b83c29ca61/multidict-6.7.1-cp314-cp314t-win_amd64.whl", hash = "sha256:497bde6223c212ba11d462853cfa4f0ae6ef97465033e7dc9940cdb3ab5b48e5", size = 53542, upload-time = "2026-01-26T02:46:08.809Z" }, + { url = "https://files.pythonhosted.org/packages/4c/81/4629d0aa32302ef7b2ec65c75a728cc5ff4fa410c50096174c1632e70b3e/multidict-6.7.1-cp314-cp314t-win_arm64.whl", hash = "sha256:2bbd113e0d4af5db41d5ebfe9ccaff89de2120578164f86a5d17d5a576d1e5b2", size = 44719, upload-time = "2026-01-26T02:46:11.146Z" }, + { url = "https://files.pythonhosted.org/packages/81/08/7036c080d7117f28a4af526d794aab6a84463126db031b007717c1a6676e/multidict-6.7.1-py3-none-any.whl", hash = "sha256:55d97cc6dae627efa6a6e548885712d4864b81110ac76fa4e534c03819fa4a56", size = 12319, upload-time = "2026-01-26T02:46:44.004Z" }, +] + +[[package]] +name = "multiprocess" +version = "0.70.19" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "dill" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a2/f2/e783ac7f2aeeed14e9e12801f22529cc7e6b7ab80928d6dcce4e9f00922d/multiprocess-0.70.19.tar.gz", hash = "sha256:952021e0e6c55a4a9fe4cd787895b86e239a40e76802a789d6305398d3975897", size = 2079989, upload-time = "2026-01-19T06:47:39.744Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7e/aa/714635c727dbfc251139226fa4eaf1b07f00dc12d9cd2eb25f931adaf873/multiprocess-0.70.19-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:1bbf1b69af1cf64cd05f65337d9215b88079ec819cd0ea7bac4dab84e162efe7", size = 144743, upload-time = "2026-01-19T06:47:24.562Z" }, + { url = "https://files.pythonhosted.org/packages/0f/e1/155f6abf5e6b5d9cef29b6d0167c180846157a4aca9b9bee1a217f67c959/multiprocess-0.70.19-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:5be9ec7f0c1c49a4f4a6fd20d5dda4aeabc2d39a50f4ad53720f1cd02b3a7c2e", size = 144738, upload-time = "2026-01-19T06:47:26.636Z" }, + { url = "https://files.pythonhosted.org/packages/af/cb/f421c2869d75750a4f32301cc20c4b63fab6376e9a75c8e5e655bdeb3d9b/multiprocess-0.70.19-pp311-pypy311_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:1c3dce098845a0db43b32a0b76a228ca059a668071cfeaa0f40c36c0b1585d45", size = 144741, upload-time = "2026-01-19T06:47:27.985Z" }, + { url = "https://files.pythonhosted.org/packages/e3/45/8004d1e6b9185c1a444d6b55ac5682acf9d98035e54386d967366035a03a/multiprocess-0.70.19-py310-none-any.whl", hash = "sha256:97404393419dcb2a8385910864eedf47a3cadf82c66345b44f036420eb0b5d87", size = 134948, upload-time = "2026-01-19T06:47:32.325Z" }, + { url = "https://files.pythonhosted.org/packages/86/c2/dec9722dc3474c164a0b6bcd9a7ed7da542c98af8cabce05374abab35edd/multiprocess-0.70.19-py311-none-any.whl", hash = "sha256:928851ae7973aea4ce0eaf330bbdafb2e01398a91518d5c8818802845564f45c", size = 144457, upload-time = "2026-01-19T06:47:33.711Z" }, + { url = "https://files.pythonhosted.org/packages/71/70/38998b950a97ea279e6bd657575d22d1a2047256caf707d9a10fbce4f065/multiprocess-0.70.19-py312-none-any.whl", hash = "sha256:3a56c0e85dd5025161bac5ce138dcac1e49174c7d8e74596537e729fd5c53c28", size = 150281, upload-time = "2026-01-19T06:47:35.037Z" }, + { url = "https://files.pythonhosted.org/packages/7f/74/d2c27e03cb84251dfe7249b8e82923643c6d48fa4883b9476b025e7dc7eb/multiprocess-0.70.19-py313-none-any.whl", hash = "sha256:8d5eb4ec5017ba2fab4e34a747c6d2c2b6fecfe9e7236e77988db91580ada952", size = 156414, upload-time = "2026-01-19T06:47:35.915Z" }, + { url = "https://files.pythonhosted.org/packages/a0/61/af9115673a5870fd885247e2f1b68c4f1197737da315b520a91c757a861a/multiprocess-0.70.19-py314-none-any.whl", hash = "sha256:e8cc7fbdff15c0613f0a1f1f8744bef961b0a164c0ca29bdff53e9d2d93c5e5f", size = 160318, upload-time = "2026-01-19T06:47:37.497Z" }, + { url = "https://files.pythonhosted.org/packages/7e/82/69e539c4c2027f1e1697e09aaa2449243085a0edf81ae2c6341e84d769b6/multiprocess-0.70.19-py39-none-any.whl", hash = "sha256:0d4b4397ed669d371c81dcd1ef33fd384a44d6c3de1bd0ca7ac06d837720d3c5", size = 133477, upload-time = "2026-01-19T06:47:38.619Z" }, +] + +[[package]] +name = "nbclient" +version = "0.11.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-client" }, + { name = "jupyter-core" }, + { name = "nbformat" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/28/a5/b3bae4b590c0cbcada2c63a34f7580024e834a8ba213e949a2f906705787/nbclient-0.11.0.tar.gz", hash = "sha256:04a134a5b087f2c5887f228aca155db50169b8cd9334dee6942c8e927e56081a", size = 62535, upload-time = "2026-06-05T07:52:41.746Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/36/c9/94d73e5a01c5b926c3fa2496e97d7a8dc28ed5a77c0b2ed712f1a62e6694/nbclient-0.11.0-py3-none-any.whl", hash = "sha256:ef7fa0d59d6e1d41103933d8a445a18d5de860ca6b613b87b8574accdb3c2895", size = 25288, upload-time = "2026-06-05T07:52:40.115Z" }, +] + +[[package]] +name = "nbconvert" +version = "7.17.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "beautifulsoup4" }, + { name = "bleach", extra = ["css"] }, + { name = "defusedxml" }, + { name = "jinja2" }, + { name = "jupyter-core" }, + { name = "jupyterlab-pygments" }, + { name = "markupsafe" }, + { name = "mistune" }, + { name = "nbclient" }, + { name = "nbformat" }, + { name = "packaging" }, + { name = "pandocfilters" }, + { name = "pygments" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/01/b1/708e53fe2e429c103c6e6e159106bcf0357ac41aa4c28772bd8402339051/nbconvert-7.17.1.tar.gz", hash = "sha256:34d0d0a7e73ce3cbab6c5aae8f4f468797280b01fd8bd2ca746da8569eddd7d2", size = 865311, upload-time = "2026-04-08T00:44:14.914Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/67/f8/bb0a9d5f46819c821dc1f004aa2cc29b1d91453297dbf5ff20470f00f193/nbconvert-7.17.1-py3-none-any.whl", hash = "sha256:aa85c087b435e7bf1ffd03319f658e285f2b89eccab33bc1ba7025495ab3e7c8", size = 261927, upload-time = "2026-04-08T00:44:12.845Z" }, +] + +[[package]] +name = "nbformat" +version = "5.11.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "fastjsonschema" }, + { name = "jsonschema" }, + { name = "jupyter-core" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/31/72/b3446efab8756e7df4b8ec587f8e611cb5a7249e4323db480802f1d3be04/nbformat-5.11.1.tar.gz", hash = "sha256:32d4521c68c6e7d5b29c76defaeed9f42ea733142b9b19f88277ce10390b9c4d", size = 147775, upload-time = "2026-08-17T08:10:51.942Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1a/69/ee613f74085ca7103f79cd08d579c4f3177d1d26e5d3d9528d2d6536a707/nbformat-5.11.1-py3-none-any.whl", hash = "sha256:cc6698fa75f4fab8755ead786317815f13a6fee3b53311c0abb1a8b51d52f7ec", size = 79849, upload-time = "2026-08-17T08:10:50.18Z" }, +] + +[[package]] +name = "nest-asyncio2" +version = "1.7.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b4/73/731debf26e27e0a0323d7bda270dc2f634b398e38f040a09da1f4351d0aa/nest_asyncio2-1.7.2.tar.gz", hash = "sha256:1921d70b92cc4612c374928d081552efb59b83d91b2b789d935c665fa01729a8", size = 14743, upload-time = "2026-02-13T00:34:04.386Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c5/3c/3179b85b0e1c3659f0369940200cd6d0fa900e6cefcc7ea0bc6dd0e29ffb/nest_asyncio2-1.7.2-py3-none-any.whl", hash = "sha256:f5dfa702f3f81f6a03857e9a19e2ba578c0946a4ad417b4c50a24d7ba641fe01", size = 7843, upload-time = "2026-02-13T00:34:02.691Z" }, +] + [[package]] name = "networkx" version = "3.6.1" @@ -584,6 +2116,35 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/9e/c9/b2622292ea83fbb4ec318f5b9ab867d0a28ab43c5717bb85b0a5f6b3b0a4/networkx-3.6.1-py3-none-any.whl", hash = "sha256:d47fbf302e7d9cbbb9e2555a0d267983d2aa476bac30e90dfbe5669bd57f3762", size = 2068504, upload-time = "2025-12-08T17:02:38.159Z" }, ] +[[package]] +name = "notebook" +version = "7.6.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-builder" }, + { name = "jupyter-server" }, + { name = "jupyterlab" }, + { name = "jupyterlab-server" }, + { name = "notebook-shim" }, + { name = "tornado" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/31/d9/5c76de84e96e1cf8aae3fce930875e0615e14f3557bbcdb634aab52da9d3/notebook-7.6.2.tar.gz", hash = "sha256:cc02b5f0bb972160cccfe44ad8a1a202036206ba3439469c514f03aefa9ae807", size = 5500147, upload-time = "2026-08-11T13:21:16.632Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5c/fd/3e552ff5b24dd305c6e9a10e8645e29c03091c317429f326ae10dbae1ac6/notebook-7.6.2-py3-none-any.whl", hash = "sha256:5fe9e09c335cb4b7de21627b860f77210e70e54b1fb1276ad942a4a7e1d858d3", size = 5547102, upload-time = "2026-08-11T13:21:13.302Z" }, +] + +[[package]] +name = "notebook-shim" +version = "0.2.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-server" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/54/d2/92fa3243712b9a3e8bafaf60aac366da1cada3639ca767ff4b5b3654ec28/notebook_shim-0.2.4.tar.gz", hash = "sha256:b4b2cfa1b65d98307ca24361f5b30fe785b53c3fd07b7a47e89acb5e6ac638cb", size = 13167, upload-time = "2024-02-14T23:35:18.353Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f9/33/bd5b9137445ea4b680023eb0469b2bb969d61303dedb2aac6560ff3d14a1/notebook_shim-0.2.4-py3-none-any.whl", hash = "sha256:411a5be4e9dc882a074ccbcae671eda64cceb068767e9a3419096986560e1cef", size = 13307, upload-time = "2024-02-14T23:35:16.286Z" }, +] + [[package]] name = "numpy" version = "2.4.6" @@ -879,6 +2440,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/a8/64/3708a90d1ebe202ffdeb7185f878a3c84d15c2b2c31858da2ce0583e2def/nvidia_nvtx-13.0.85-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:cb7780edb6b14107373c835bf8b72e7a178bac7367e23da7acb108f973f157a6", size = 148878, upload-time = "2025-09-04T08:28:53.627Z" }, ] +[[package]] +name = "overrides" +version = "7.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/36/86/b585f53236dec60aba864e050778b25045f857e17f6e5ea0ae95fe80edd2/overrides-7.7.0.tar.gz", hash = "sha256:55158fa3d93b98cc75299b1e67078ad9003ca27945c76162c1c0766d6f91820a", size = 22812, upload-time = "2024-01-27T21:01:33.423Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2c/ab/fc8290c6a4c722e5514d80f62b2dc4c4df1a68a41d1364e625c35990fcf3/overrides-7.7.0-py3-none-any.whl", hash = "sha256:c7ed9d062f78b8e4c1a7b70bd8796b35ead4d9f510227ef9c5dc7626c60d7e49", size = 17832, upload-time = "2024-01-27T21:01:31.393Z" }, +] + [[package]] name = "packaging" version = "26.2" @@ -949,6 +2519,58 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/0f/54/68a0978d1ef8502b8492099beaa6e7a0c1b32e3b5d4f677f5810cb08711c/pandas-3.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:b2c95f8bfc1ee412bf482605d7bfd30c12d1d26bd59fdd91efeef1d4718decb1", size = 9466464, upload-time = "2026-05-11T18:54:22.754Z" }, ] +[[package]] +name = "pandocfilters" +version = "1.5.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/70/6f/3dd4940bbe001c06a65f88e36bad298bc7a0de5036115639926b0c5c0458/pandocfilters-1.5.1.tar.gz", hash = "sha256:002b4a555ee4ebc03f8b66307e287fa492e4a77b4ea14d3f934328297bb4939e", size = 8454, upload-time = "2024-01-18T20:08:13.726Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ef/af/4fbc8cab944db5d21b7e2a5b8e9211a03a79852b1157e2c102fcc61ac440/pandocfilters-1.5.1-py2.py3-none-any.whl", hash = "sha256:93be382804a9cdb0a7267585f157e5d1731bbe5545a85b268d6f5fe6232de2bc", size = 8663, upload-time = "2024-01-18T20:08:11.28Z" }, +] + +[[package]] +name = "parso" +version = "0.8.7" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/30/4b/90c937815137d43ce71ba043cd3566221e9df6b9c805f24b5d138c9d40a7/parso-0.8.7.tar.gz", hash = "sha256:eaaac4c9fdd5e9e8852dc778d2d7405897ec510f2a298071453e5e3a07914bb1", size = 401824, upload-time = "2026-05-01T23:13:02.138Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/99/5d/8268b644392ee874ee82a635cd0df1773de230bde356c38de28e298392cc/parso-0.8.7-py2.py3-none-any.whl", hash = "sha256:a8926eb2a1b915486941fdbd31e86a4baf88fe8c210f25f2f35ecec5b574ca1c", size = 107025, upload-time = "2026-05-01T23:12:58.867Z" }, +] + +[[package]] +name = "peft" +version = "0.20.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "accelerate" }, + { name = "huggingface-hub" }, + { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12'" }, + { name = "numpy", version = "2.5.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" }, + { name = "packaging" }, + { name = "psutil" }, + { name = "pyyaml" }, + { name = "safetensors" }, + { name = "torch" }, + { name = "tqdm" }, + { name = "transformers" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b4/08/02541a2c29be7c78698f73d438bc0e733b214f3f35ec5db79fca8da8fc61/peft-0.20.0.tar.gz", hash = "sha256:4769c8093a4ca145fd6fb3fd4dd50449675f5fe46434ad1e98b285a132d4b1d0", size = 880503, upload-time = "2026-07-28T13:46:01.85Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/28/79/13bcabb8048126422d5c4b880575d40886c726f354db88cfeed4325525bb/peft-0.20.0-py3-none-any.whl", hash = "sha256:0fbba16ffebfad3de96e06f2da6860fd860292324b85b6141909fa1e26ea9233", size = 775777, upload-time = "2026-07-28T13:45:59.809Z" }, +] + +[[package]] +name = "pexpect" +version = "4.9.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "ptyprocess" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/42/92/cc564bf6381ff43ce1f4d06852fc19a2f11d180f23dc32d9588bee2f149d/pexpect-4.9.0.tar.gz", hash = "sha256:ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f", size = 166450, upload-time = "2023-11-25T09:07:26.339Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9e/c3/059298687310d527a58bb01f3b1965787ee3b40dce76752eda8b44e9a2c5/pexpect-4.9.0-py2.py3-none-any.whl", hash = "sha256:7236d1e080e4936be2dc3e326cec0af72acf9212a7e1d060210e70a47e253523", size = 63772, upload-time = "2023-11-25T06:56:14.81Z" }, +] + [[package]] name = "pillow" version = "12.3.0" @@ -1034,6 +2656,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/36/54/0169bc772ec491108b62f644f8ecf1fe5d8ae5ebafde2ee2142210166903/pillow-12.3.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:04f01d28a6aaff387bf842a13be313df23ba0597a44f1a976c9feb3c6ff4711a", size = 7231786, upload-time = "2026-07-01T11:56:35.046Z" }, ] +[[package]] +name = "platformdirs" +version = "4.11.7" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/69/b7/802a56eca9f2fac455b8bab5375a2647b0f0e14a2cd63ef077de3c4a7658/platformdirs-4.11.7.tar.gz", hash = "sha256:4f41487eeeeeb07f3a6625e61d9bc0ae6809f92d3386dbd74392fbb76108104d", size = 35127, upload-time = "2026-09-01T13:35:10.502Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/27/6e/80993e10a0482f630cef528635789233224f36b1ffd11592aa15d13ff9ce/platformdirs-4.11.7-py3-none-any.whl", hash = "sha256:8a02cb259042c79d1cd0450facc2fe6dc9d303ae7901afbe33bf8ea0b188cef6", size = 23938, upload-time = "2026-09-01T13:35:09.02Z" }, +] + [[package]] name = "pluggy" version = "1.6.0" @@ -1043,6 +2674,184 @@ 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 = "prometheus-client" +version = "0.26.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/52/73/f1334c29c2af4cd9dba6c7817e61b611bd0215e2eb5565c6064a4de18802/prometheus_client-0.26.0.tar.gz", hash = "sha256:04a91bcf94e2cf74a44a1a874d651a2e853ed354b6e822f3b7487751465d5c2b", size = 92910, upload-time = "2026-07-24T19:36:41.893Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/eb/a3/b69efbf4143b5b9859b977770bbbabcc2796b702fa69dc40271e45cd5a56/prometheus_client-0.26.0-py3-none-any.whl", hash = "sha256:fa93d06737aa02bacd05794768508bb97d2fbee28cb3bca04eaae92f0ca953d6", size = 64494, upload-time = "2026-07-24T19:36:40.854Z" }, +] + +[[package]] +name = "prompt-toolkit" +version = "3.0.53" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "wcwidth" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/7d/ea/39b988c938f75cb75d7045b5c69f8bfed47ee2152c8837fb403de29d6fb8/prompt_toolkit-3.0.53.tar.gz", hash = "sha256:9ec8a0ad96d5c56148b3f914aa79c1564c3fde5d2e6b876e7bc327e353cf8fa6", size = 435492, upload-time = "2026-07-26T20:56:14.758Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/54/6f/84908cad2d6aa5144abcf7b42709fe4fdb459bc640ec7ac5786e7693dabc/prompt_toolkit-3.0.53-py3-none-any.whl", hash = "sha256:01c0891d7f9237d5e339f7d3e42cdae80b7534abb1c7c0e3352efba6231492f2", size = 392288, upload-time = "2026-07-26T20:56:12.512Z" }, +] + +[[package]] +name = "propcache" +version = "0.5.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ec/44/c87281c333769159c50594f22610f77398a47ccbfbbf23074e744e86f87c/propcache-0.5.2.tar.gz", hash = "sha256:01c4fc7480cd0598bb4b57022df55b9ca296da7fc5a8760bd8451a7e63a7d427", size = 50208, upload-time = "2026-05-08T21:02:12.199Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e7/f1/8a8cc1c2c7e7934ab77e0163414f736fadbc0f5e8dd9673b952355ac175b/propcache-0.5.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:74b70780220e2dd89175ca24b81b68b67c83db499ae611e7f2313cb329801c78", size = 90744, upload-time = "2026-05-08T20:59:45.799Z" }, + { url = "https://files.pythonhosted.org/packages/c2/f4/651b1225e976bd1a2ba5cfba0c29d096581c2636b437e3a9a7ab6276270a/propcache-0.5.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:a4840ab0ae0216d952f4b53dc6d0b992bfc2bedbfe360bdd9b548bc184c08959", size = 52033, upload-time = "2026-05-08T20:59:47.408Z" }, + { url = "https://files.pythonhosted.org/packages/15/a8/8ede85d6aa1f79fc7dc2f8fd2c8d65920b8272c3892903c8a1affde48cfb/propcache-0.5.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c6844ba6364fb12f403928a82cfd295ab103a2b315c77c747b2dbe4a41894ea7", size = 52754, upload-time = "2026-05-08T20:59:49.202Z" }, + { url = "https://files.pythonhosted.org/packages/7d/fe/b3551b41bbc2f5b5bb088fc6920567cd43101253e68fbaa261339eb96fe1/propcache-0.5.2-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2293949b855ce597f2826452d17c2d545fb5622379c4ea6fdf525e9b8e8a2511", size = 57573, upload-time = "2026-05-08T20:59:50.778Z" }, + { url = "https://files.pythonhosted.org/packages/83/27/ab851ebd1b7172e3e161f5f8d39e315d54a91bea246f01f4d872d3376aef/propcache-0.5.2-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:0fd59b5af35f74da48d905dcbad55449ba13be91823cb05a9bd590bbf5b61660", size = 60645, upload-time = "2026-05-08T20:59:52.227Z" }, + { url = "https://files.pythonhosted.org/packages/95/7d/466b3d18022e9897cbda9c735c493c5bd747d7a4c6f5ea1480b4cec434b6/propcache-0.5.2-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:29f9309a2e42b0d273be006fdb4be2d6c39a47f6f57d8fb1cf9f81481df81b66", size = 61563, upload-time = "2026-05-08T20:59:53.866Z" }, + { url = "https://files.pythonhosted.org/packages/27/1b/16ab7f2cf2041da2f60d156ba64c2484eadf9168075b4ff43c3ef60045af/propcache-0.5.2-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5aaa2b923c1944ac8febd6609cb373540a5563e7cbcb0fd770f75dace2eb817b", size = 58888, upload-time = "2026-05-08T20:59:55.457Z" }, + { url = "https://files.pythonhosted.org/packages/0a/67/bb777ffd907633563bf35fd859c4ce97b0512c32f4633cf5d1eb7c33512b/propcache-0.5.2-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:66ea454f095ddf5b6b14f56c064c0941c4788be11e18d2464cf643bf7203ff67", size = 59253, upload-time = "2026-05-08T20:59:57.075Z" }, + { url = "https://files.pythonhosted.org/packages/b9/42/64f8d90b73fd9cdc1499b48057ff6d9cd2a98a25734c9bb62ecf07e87061/propcache-0.5.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:95f1e3f4760d404b13c9976c0229b2b49a3c8e2c62a9ce92efdd2b11ada75e3f", size = 57558, upload-time = "2026-05-08T20:59:58.602Z" }, + { url = "https://files.pythonhosted.org/packages/eb/02/dba5bc03c9041f2092ea55a449caf5dfe68352c6654511b29ba0654ddb69/propcache-0.5.2-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:85341b12b9d55bad0bded24cac341bb34289469e03a11f3f583ea1cc1db0326c", size = 55007, upload-time = "2026-05-08T20:59:59.837Z" }, + { url = "https://files.pythonhosted.org/packages/14/c0/43f649c7aa2a77a3b100d84e9dea3a483120ecb608bfe36ce49eaff517fe/propcache-0.5.2-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:26a4dca084132874e639895c3135dfad5eb20bae209f62d1aeb31b03e601c3c0", size = 60355, upload-time = "2026-05-08T21:00:01.144Z" }, + { url = "https://files.pythonhosted.org/packages/83/c0/435dafd27f1cb4a495381dae60e25883ccfe4020bb72818e8184c1678092/propcache-0.5.2-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:3b199b9b2b3d6a7edf3183ba8a9a137a22b97f7df525feb5ae1eccf026d2a9c6", size = 59057, upload-time = "2026-05-08T21:00:02.401Z" }, + { url = "https://files.pythonhosted.org/packages/53/ae/6e292df9135d659944e96cb3389258e4a663e5b2b5f6c217ef0ddc8d2f73/propcache-0.5.2-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:e59bc9e66329185b93dab73f210f1a37f81cb40f321501db8017c9aea15dba27", size = 61938, upload-time = "2026-05-08T21:00:03.638Z" }, + { url = "https://files.pythonhosted.org/packages/0b/42/314ebc50d8159055411fd6b0bda322ff510e4b1f7d2e4927940ad0f6af20/propcache-0.5.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:552ffadf6ad409844bc5919c42a0a83d88314cedddaea0e41e80a8b8fffe881f", size = 59731, upload-time = "2026-05-08T21:00:04.881Z" }, + { url = "https://files.pythonhosted.org/packages/b8/9b/2da6dee38871c3c8772fabc2758325a5c9077d6d18c597737dc04dd884cd/propcache-0.5.2-cp311-cp311-win32.whl", hash = "sha256:cd416c1de191973c52ff1a12a57446bfc7642797b282d7caf2162d7d1b8aa9a0", size = 38966, upload-time = "2026-05-08T21:00:06.511Z" }, + { url = "https://files.pythonhosted.org/packages/42/4e/f17363fb58c0afe05b067361cb6d86ed2d29de6506779a27547c4d183075/propcache-0.5.2-cp311-cp311-win_amd64.whl", hash = "sha256:44e488ef40dbb452700b2b1f8188934121f6648f52c295055662d2191959ff82", size = 42135, upload-time = "2026-05-08T21:00:08.088Z" }, + { url = "https://files.pythonhosted.org/packages/c6/eb/6af6685077d22e8b33358d3c548e3282706a0b3cd85044ffba4e5dd08e3b/propcache-0.5.2-cp311-cp311-win_arm64.whl", hash = "sha256:54adaa85a22078d1e306304a40984dc5be99d599bf3dc0a24dc98f7daeab89ab", size = 38381, upload-time = "2026-05-08T21:00:09.692Z" }, + { url = "https://files.pythonhosted.org/packages/4a/cb/e27bc2b2737a0bb49962b275efa051e8f1c35a936df7d5139b6b658b7dc9/propcache-0.5.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:806719138ecd720339a12410fb9614ac9b2b2d3a5fdf8235d56981c36f4039ba", size = 95887, upload-time = "2026-05-08T21:00:11.277Z" }, + { url = "https://files.pythonhosted.org/packages/e6/13/b8ae04c59392f8d11c6cd9fb4011d1dc7c86b81225c770280300e259ffe1/propcache-0.5.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:db2b80ea58eab4f86b2beec3cc8b39e8ff9276ac20e96b7cce43c8ae84cd6b5a", size = 54654, upload-time = "2026-05-08T21:00:12.604Z" }, + { url = "https://files.pythonhosted.org/packages/2c/7d/49777a3e20b55863d4794384a38acd460c04157b0a00f8602b0d508b8431/propcache-0.5.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:e5cbfac9f61484f7e9f3597775500cd3ebe8274e9b050c38f9525c77c97520bf", size = 55190, upload-time = "2026-05-08T21:00:13.935Z" }, + { url = "https://files.pythonhosted.org/packages/44/c7/085d0cd63062e84044e3f05797749c3f8e3938ff3aeb0eb2f69d43fafc91/propcache-0.5.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5dbc581d2814337da56222fab8dc5f161cd798a434e49bac27930aaef798e144", size = 59995, upload-time = "2026-05-08T21:00:15.526Z" }, + { url = "https://files.pythonhosted.org/packages/9c/42/32cf8e3009e92b2645cf1e944f701e8ea4e924dffde1ee26db860bcbf7e4/propcache-0.5.2-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:857187f381f88c8e2fa2fe56ab94879d011b883d5a2ee5a1b60a8cd2a06846d9", size = 63422, upload-time = "2026-05-08T21:00:16.824Z" }, + { url = "https://files.pythonhosted.org/packages/9e/1b/f112433f99fc979431b87a39ef169e3f8df070d99a72792c56d6937ac48b/propcache-0.5.2-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:178b4a2cdaac1818e2bf1c5a99b94383fa73ea5382e032a48dec07dc5668dc42", size = 64342, upload-time = "2026-05-08T21:00:18.362Z" }, + { url = "https://files.pythonhosted.org/packages/14/15/5574111ae50dd6e879456888c0eadd4c5a869959775854e18e18a6b345f3/propcache-0.5.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6f328175a2cde1f0ff2c4ed8ce968b9dcfb55f3a7153f39e2957ed994da13476", size = 61639, upload-time = "2026-05-08T21:00:19.692Z" }, + { url = "https://files.pythonhosted.org/packages/cc/da/4d775080b1490c0ae604acda868bd71aabe3a89ed16f2aa4339eb8a283e7/propcache-0.5.2-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:5671d09a36b06d0fd4a3da0fccbcae360e9b1570924171a15e9e0997f0249fba", size = 61588, upload-time = "2026-05-08T21:00:21.155Z" }, + { url = "https://files.pythonhosted.org/packages/04/ac/f076982cbe2195ee9cf32de5a1e46951d9fb399fc207f390562dd0fd8fb2/propcache-0.5.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:80168e2ebe4d3ec6599d10ad8f520304ae1cad9b6c5a95372aef1b66b7bfb53a", size = 60029, upload-time = "2026-05-08T21:00:22.713Z" }, + { url = "https://files.pythonhosted.org/packages/70/60/189be62e0dd898dce3b331e1b8c7a543cd3a405ac0c81fe8ee8a9d5d77e1/propcache-0.5.2-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:45f11346f884bc47444f6e6647131055844134c3175b629f84952e2b5cd62b64", size = 56774, upload-time = "2026-05-08T21:00:24.001Z" }, + { url = "https://files.pythonhosted.org/packages/ea/9e/93377b9c7939c1ffae98f878dee955efadfd638078bc86dbc21f9d52f651/propcache-0.5.2-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:8e778ebd44ef4f66ed60a0416b06b489687db264a9c0b3620362f26489492913", size = 63532, upload-time = "2026-05-08T21:00:25.545Z" }, + { url = "https://files.pythonhosted.org/packages/14/f9/590ef6cfb9b8028d516d287812ece32bb0bc5f11fbb9c8bf6b2e6313fec8/propcache-0.5.2-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:c0cb9ed24c8964e172768d455a38254c2dd8a552905729ce006cad3d3dda59b1", size = 61592, upload-time = "2026-05-08T21:00:27.186Z" }, + { url = "https://files.pythonhosted.org/packages/b4/5e/70958b3034c297a630bba2f17ca7abc2d5f39a803ad7e370ab79d1ecd022/propcache-0.5.2-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:1d1ad32d9d4355e2be65574fd0bfd3677e7066b009cd5b9b2dee8aa6a6393b33", size = 64788, upload-time = "2026-05-08T21:00:28.8Z" }, + { url = "https://files.pythonhosted.org/packages/12/fd/77fe5936d8c3086ca9048f7f415f122ed82e53884a9ec193646b42deef06/propcache-0.5.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:c80f4ba3e8f00189165999a742ee526ebeccedf6c3f7beb0c7df821e9772435a", size = 62514, upload-time = "2026-05-08T21:00:30.098Z" }, + { url = "https://files.pythonhosted.org/packages/cf/74/66bd798b5b3be70aa1b391f5cc9d6a0a5532d7fd3b19ec0b213e72e6ad9d/propcache-0.5.2-cp312-cp312-win32.whl", hash = "sha256:8c7972d8f193740d9175f0998ab38717e6cd322d5935c5b0fef8c0d323fd9031", size = 39018, upload-time = "2026-05-08T21:00:31.622Z" }, + { url = "https://files.pythonhosted.org/packages/61/7c/5c0d34aa3024694d6dcb9271cdbdd08c4e47c1c0ad95ec7e7bc74cdea145/propcache-0.5.2-cp312-cp312-win_amd64.whl", hash = "sha256:d9ee8826a7d47863a08ac44e1a5f611a462eefc3a194b492da242128bec75b42", size = 42322, upload-time = "2026-05-08T21:00:32.918Z" }, + { url = "https://files.pythonhosted.org/packages/4d/91/875812f1a3feb20ceba818ef39fbe4d92f1081e04ac815c822496d0d038b/propcache-0.5.2-cp312-cp312-win_arm64.whl", hash = "sha256:2800a4a8ead6b28cccd1ec54b59346f0def7922ee1c7598e8499c733cfbb7c84", size = 38172, upload-time = "2026-05-08T21:00:35.124Z" }, + { url = "https://files.pythonhosted.org/packages/c5/09/f049e45385503fe67db75a6b6186a7b9f0c3930366dc960522c312a825b1/propcache-0.5.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:099aaf4b4d1a02265b92a977edf00b5c4f63b3b17ac6de39b0d637c9cac0188a", size = 94457, upload-time = "2026-05-08T21:00:36.355Z" }, + { url = "https://files.pythonhosted.org/packages/6b/65/83d1d05655baf63113731bd5a1008435e14f8d1e5a06cbe4ec5b23ad7a31/propcache-0.5.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:68ce1c44c7a813a7f71ea04315a8c7b330b63db99d059a797a4651bb6f69f117", size = 53835, upload-time = "2026-05-08T21:00:38.072Z" }, + { url = "https://files.pythonhosted.org/packages/a9/12/a6ba6482bb5ea3260c000c9b20881c95fa11c6b30173715668259f844ed7/propcache-0.5.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:fc299c129490f55f254cd90be0deca4764e36e9a7c08b4aa588479a3bbed3098", size = 54545, upload-time = "2026-05-08T21:00:39.319Z" }, + { url = "https://files.pythonhosted.org/packages/a9/19/7fa086f5764c59ec8a8e157cd93aa8497acc00aba9dcdec56bfffb32602d/propcache-0.5.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a6ae2198be502c10f09b2516e7b5d019816924bc3183a43ce792a7bd6625e6f4", size = 59886, upload-time = "2026-05-08T21:00:40.621Z" }, + { url = "https://files.pythonhosted.org/packages/a1/e4/5d7663dc8235956c8f5281698a3af1d351d8820341ddd890f59d9a9127f2/propcache-0.5.2-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6041d31504dc1779d700e1edcfb08eea334b357620b06681a4eabb57a74e574e", size = 63261, upload-time = "2026-05-08T21:00:41.775Z" }, + { url = "https://files.pythonhosted.org/packages/4a/4a/15a03adee24d6350da4292caeac44c34c033d2afe5e87eb370f38854560f/propcache-0.5.2-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f7eabc04151c78a9f4d5bbb5f1faf571e4defeb4b585e0fe95b60ff2dbe4d3d7", size = 64184, upload-time = "2026-05-08T21:00:43.018Z" }, + { url = "https://files.pythonhosted.org/packages/8b/c6/979176efdaa3d239e36d503d5af63a0a773b36662ed8f52e5b6a6d9fd40e/propcache-0.5.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4db0ba63d693afd40d249bd93f842b5f144f8fcbb83de05660373bcf30517b1d", size = 61534, upload-time = "2026-05-08T21:00:44.507Z" }, + { url = "https://files.pythonhosted.org/packages/c8/22/63e8cd1bae4c2d2be6493b6b7d10566ddafad88137cfbc99964a1119853c/propcache-0.5.2-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:1dbcf7675229b35d31abb6547d8ebc8c27a830ac3f9a794edff6254873ec7c0a", size = 61500, upload-time = "2026-05-08T21:00:45.796Z" }, + { url = "https://files.pythonhosted.org/packages/60/5a/28e5d9acbac1cc9ccb67045e8c1b943aa8d79fdf39c93bd73cacd68008ea/propcache-0.5.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d310c013aad2c72f1c3f2f8dd3279d460a858c551f97aeb8c63e4693cca7b4d2", size = 59994, upload-time = "2026-05-08T21:00:47.093Z" }, + { url = "https://files.pythonhosted.org/packages/f3/40/db650677f554a95b9c01a7c9d93d629e93a15562f5deb4573c9ee136fed2/propcache-0.5.2-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:06187263ddad280d05b4d8a8b3bb7d164cbebd469236544a42e6d9b28ac6a4fa", size = 56884, upload-time = "2026-05-08T21:00:48.376Z" }, + { url = "https://files.pythonhosted.org/packages/80/45/70b39b89516ff8b96bf732fa6fded8cef20f293cb1508690101c3c07ec51/propcache-0.5.2-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:3115559b8effafd63b142ea5ed53d63a16ea6469cbc63dce4ee194b42db5d853", size = 63464, upload-time = "2026-05-08T21:00:49.954Z" }, + { url = "https://files.pythonhosted.org/packages/f9/e2/fa59d3a89eac5534293124af4f1d0d0ada091ce4a0ab4610ce03fd2bdd8d/propcache-0.5.2-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:c60462af8e6dc30c35407c7237ea908d777b22862bbee27bc4699c0d8bcdc45a", size = 61588, upload-time = "2026-05-08T21:00:51.281Z" }, + { url = "https://files.pythonhosted.org/packages/0b/97/efb547a55c4bc7381cfb202d6a2239ac621045277bc1ea5dfd3a7f0516c0/propcache-0.5.2-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:40314bca9ac559716fe374094fc81c11dcc34b64fd6c585360f5775690505704", size = 64667, upload-time = "2026-05-08T21:00:52.602Z" }, + { url = "https://files.pythonhosted.org/packages/92/56/f5c7d9b4b7595d5127da38974d791b2153f3d1eae6c674af3583ace92ad3/propcache-0.5.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:cfa21e036ce1e1db2be04ba3b85d2df1bb1702fa01932d984c5464c665228ff4", size = 62463, upload-time = "2026-05-08T21:00:54.303Z" }, + { url = "https://files.pythonhosted.org/packages/bd/3b/484a3a65fc9f9f60c41dcd17b428bace5389544e2c680994534a20755066/propcache-0.5.2-cp313-cp313-win32.whl", hash = "sha256:f156a3529f38063b6dbaf356e15602a7f95f8055b1295a438433a6386f10463d", size = 38621, upload-time = "2026-05-08T21:00:55.808Z" }, + { url = "https://files.pythonhosted.org/packages/1c/fd/3f0f10dba4dabad3bf53102be007abf55481067952bde0fdddff439e7c61/propcache-0.5.2-cp313-cp313-win_amd64.whl", hash = "sha256:dfed59d0a5aeb01e242e66ff0300bc4a265a7c05f612d30016f0b60b1017d757", size = 41649, upload-time = "2026-05-08T21:00:57.061Z" }, + { url = "https://files.pythonhosted.org/packages/90/ec/6ce619cc32bb500a482f811f9cd509368b4e58e638d13f2c68f370d6b475/propcache-0.5.2-cp313-cp313-win_arm64.whl", hash = "sha256:ba338430e87ceb9c8f0cf754de38a9860560261e56c00376debd628698a7364f", size = 37636, upload-time = "2026-05-08T21:00:58.646Z" }, + { url = "https://files.pythonhosted.org/packages/1b/82/c1d268bbbf2ef981c5bf0fbbe746db617c66e3bcefe431a1aa8943fbe23a/propcache-0.5.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:a592f5f3da71c8691c788c13cb6734b6d17663d2e1cb8caddf0673d01ef8847d", size = 98872, upload-time = "2026-05-08T21:00:59.889Z" }, + { url = "https://files.pythonhosted.org/packages/f4/d4/52c871e73e864e6b34c0e2d58ac1ec5ccd149497ddc7ad2137ae98323a35/propcache-0.5.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:6a997d0489e9668a384fcfd5061b857aa5361de73191cac204d04b889cfbbafa", size = 56257, upload-time = "2026-05-08T21:01:01.195Z" }, + { url = "https://files.pythonhosted.org/packages/67/f0/9b90ca2a210b3d09bcfcd96ecd0f55545c091535abce2a45de2775cfd357/propcache-0.5.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:10734b5484ea113152ee25a91dccedf81631791805d2c9ccb054958e51842c94", size = 56696, upload-time = "2026-05-08T21:01:02.941Z" }, + { url = "https://files.pythonhosted.org/packages/9d/0e/6e9d4ba07c8e56e21ddec1e75f12148142b21ca83a51871babce095334f4/propcache-0.5.2-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:cafca7e56c12bb02ae16d283742bef25a61122e9dab2b5b3f2ccbe589ce32164", size = 62378, upload-time = "2026-05-08T21:01:04.475Z" }, + { url = "https://files.pythonhosted.org/packages/65/19/c10badaa463dde8a27ce884f8ee2ec37e6035b7c9f5ff0c8f74f06f08dac/propcache-0.5.2-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f064f8d2b59177878b7615df1735cd8fe3462ed6be8c7b217d17a276489c2b7f", size = 65283, upload-time = "2026-05-08T21:01:05.959Z" }, + { url = "https://files.pythonhosted.org/packages/b0/b6/93bea99ca80e19cef6512a8580e5b7857bbe09422d9daa7fd4ef5723306c/propcache-0.5.2-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f78abfa8dfc32376fd1aacf597b2f2fbbe0ea751419aee718af5d4f82537ef8c", size = 66616, upload-time = "2026-05-08T21:01:07.228Z" }, + { url = "https://files.pythonhosted.org/packages/83/e4/5c7462e50625f051f37fb38b8224f7639f667184bbd34424ec83819bb1b7/propcache-0.5.2-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f7467da8a9822bf1a55336f877340c5bcbd3c482afc43a99771169f74a26dedc", size = 63773, upload-time = "2026-05-08T21:01:08.514Z" }, + { url = "https://files.pythonhosted.org/packages/ca/b6/99238894047b13c823be25027e736626cd414a52a5e30d2c3347c2733529/propcache-0.5.2-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a6ddc6ac9e25de626c1f129c1b467d7ecd33ce2237d3fd0c4e429feef0a7ee1f", size = 63664, upload-time = "2026-05-08T21:01:09.874Z" }, + { url = "https://files.pythonhosted.org/packages/85/1e/a3a1a63116a2b8edb415a8bb9a6f0c34bd03830b1e18e8ce2904e1dc1cf4/propcache-0.5.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:2f22cbbac9e26a8e864c0985ff1268d5d939d53d9d9411a9824279097e03a2cb", size = 62643, upload-time = "2026-05-08T21:01:11.132Z" }, + { url = "https://files.pythonhosted.org/packages/e4/03/893cf147de2fc6543c5eaa07ad833170e7e2a2385725bbebe8c0503723bb/propcache-0.5.2-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:fc76378c62a0f04d0cd82fbb1a2cd2d7e28fcb40d5873f28a6c44e388aaa2751", size = 59595, upload-time = "2026-05-08T21:01:12.387Z" }, + { url = "https://files.pythonhosted.org/packages/86/3b/04c1a2e12c57766568ba75ba72b3bf2042818d4c1425fab6fc07155c7cff/propcache-0.5.2-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:acd2c8edba48e31e58a363b8cf4e5c7db3b04b3f9e371f601df30d9b0d244836", size = 65711, upload-time = "2026-05-08T21:01:13.676Z" }, + { url = "https://files.pythonhosted.org/packages/1c/34/80f8d0099f8d6bacc4de1624c85672681c8cd1149ca2da0e38fd120b817f/propcache-0.5.2-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:452b5065457eb9991ec5eb38ff41d6cd4c991c9ac7c531c4d5849ae473a9a13f", size = 64247, upload-time = "2026-05-08T21:01:14.936Z" }, + { url = "https://files.pythonhosted.org/packages/f3/1a/8b08f3a5f1037e9e370c55883ceeeee0f6dd0416fb2d2d67b8bfc91f2a79/propcache-0.5.2-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:3430bb2bfe1331885c427745a751e774ee679fd4344f80b97bf879815fe8fa55", size = 67102, upload-time = "2026-05-08T21:01:16.281Z" }, + { url = "https://files.pythonhosted.org/packages/34/68/8bdb7bb7756d76e005490649d10e4a8369e610c74d619f71e1aedf889e9c/propcache-0.5.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:cef6cea3922890dd6c9654971001fa797b526c16ab5e1e46c05fd6f877be7568", size = 64964, upload-time = "2026-05-08T21:01:17.57Z" }, + { url = "https://files.pythonhosted.org/packages/0a/aa/50fb0b5d3968b61a510926ff8b8465f1d6e976b3ab74496d7a4b9fc42515/propcache-0.5.2-cp313-cp313t-win32.whl", hash = "sha256:72d61e16dd78228b58c5d47be830ff3da7e5f139abdf0aef9d86cde1c5cf2191", size = 42546, upload-time = "2026-05-08T21:01:18.946Z" }, + { url = "https://files.pythonhosted.org/packages/ae/4c/0ddbae64321bd4a95bcbfc19307238016b5b1fee645c84626c8d539e5b74/propcache-0.5.2-cp313-cp313t-win_amd64.whl", hash = "sha256:0958834041a0166d343b8d2cedcd8bcbaeb4fdbe0cf08320c5379f143c3be6e7", size = 46330, upload-time = "2026-05-08T21:01:20.162Z" }, + { url = "https://files.pythonhosted.org/packages/00/d9/9cddc8efb78d8af264c5ec9f6d10b62f57c515feda8d321595f56010fb23/propcache-0.5.2-cp313-cp313t-win_arm64.whl", hash = "sha256:6de8bd93ddde9b992cf2b2e0d796d501a19026b5b9fd87356d7d0779531a8d96", size = 40521, upload-time = "2026-05-08T21:01:21.399Z" }, + { url = "https://files.pythonhosted.org/packages/e2/ea/23ee535d90ce8bcc465a3028eb3cc0ce3bd1005f4bb27710b30587de798d/propcache-0.5.2-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:46088abff4cba581dea21ae0467a480526cb25aa5f3c269e909f800328bc3999", size = 94662, upload-time = "2026-05-08T21:01:22.683Z" }, + { url = "https://files.pythonhosted.org/packages/b5/06/c5a52f419b5d8972f8d46a7577476090d8e3263ff589ce40b5ca4968d5be/propcache-0.5.2-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:fc88b26f08d634f7bc819a7852e5214f5802641ab8d9fd5326892292eee1993e", size = 53928, upload-time = "2026-05-08T21:01:23.986Z" }, + { url = "https://files.pythonhosted.org/packages/63/b1/4260d67d6bd85e58a66b72d54ce15d5de789b6f3870cc6bedf8ff9667401/propcache-0.5.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:97797ebb098e670a2f92dd66f32897e30d7615b14e7f59711de23e30a9072539", size = 54650, upload-time = "2026-05-08T21:01:25.305Z" }, + { url = "https://files.pythonhosted.org/packages/70/06/2f46c318e3307cd7a6a7481def374ce838c0fe20084b39dd54b0879d0e99/propcache-0.5.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ba57fffe4ac99c5d30076161b5866336d97600769bad35cc68f7774b15298a4e", size = 59912, upload-time = "2026-05-08T21:01:26.545Z" }, + { url = "https://files.pythonhosted.org/packages/4c/29/fe1aebec2ce57ab985a9c382bded1124431f85078113aa222c5d278430d4/propcache-0.5.2-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:583c19759d9eec1e5b69e2fbef36a7d9c326041be9746cb822d335c8cedc2979", size = 63300, upload-time = "2026-05-08T21:01:27.937Z" }, + { url = "https://files.pythonhosted.org/packages/b4/18/2334b26768b6c82be8c69e83671b767d5ef426aa09b0cba6c2ea47816774/propcache-0.5.2-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d0326e2e5e1f3163fa306c834e48e8d490e5fae607a097a40c0648109b47ba80", size = 64208, upload-time = "2026-05-08T21:01:29.484Z" }, + { url = "https://files.pythonhosted.org/packages/2b/76/7f1bfd6afff4c5e38e36a3c6d68eb5f4b7311ea80baf693db78d95b603c4/propcache-0.5.2-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e00820e192c8dbebcafb383ebbf99030895f09905e7a0eb2e0340a0bcc2bc825", size = 61633, upload-time = "2026-05-08T21:01:31.068Z" }, + { url = "https://files.pythonhosted.org/packages/c4/46/b3ff8aba2b4953a3e50de2cf72f1b5748b8eca93b15f3dc2c84339084c09/propcache-0.5.2-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c66afea89b1e43725731d2004732a046fe6fe955d51f952c3e95a7314a284a39", size = 61724, upload-time = "2026-05-08T21:01:32.374Z" }, + { url = "https://files.pythonhosted.org/packages/c5/01/814cfcafbcff954f94c01cf30e097ddc88a076b5440fbcf4570753437d40/propcache-0.5.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:d4dc37dec6c6cdad0b57881a5658fd14fbf53e333b1a86cf86559f190e1d9ec4", size = 60069, upload-time = "2026-05-08T21:01:33.67Z" }, + { url = "https://files.pythonhosted.org/packages/da/68/5c6f7622d510cc666a300687e06fd060c1a43361c0c9b20d284f06d8096a/propcache-0.5.2-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:5570dbcc97571c15f68068e529c92715a12f8d54030e272d264b377e22bd17a5", size = 57099, upload-time = "2026-05-08T21:01:34.915Z" }, + { url = "https://files.pythonhosted.org/packages/55/27/9cb0b4c679124085327957d42521c99dba04c88c90c3e55a6f0b633ebccc/propcache-0.5.2-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:f814362777a9f841adddb200ecdf8f5cb1e5a3c4b7a86378edbd6ccb26edd702", size = 63391, upload-time = "2026-05-08T21:01:36.231Z" }, + { url = "https://files.pythonhosted.org/packages/f0/9d/7258aaa5bdf60fc6f27591eef6fe52768cb0beda7140be477c8b12c9794a/propcache-0.5.2-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:196913dea116aeb5a2ba95af4ddcb7ea85559ae07d8eee8751688310d09168c3", size = 61626, upload-time = "2026-05-08T21:01:37.545Z" }, + { url = "https://files.pythonhosted.org/packages/8e/0d/41c602003e8a9b16fe1e7eadf62c7bfba9d5474370b24200bf48b315f45f/propcache-0.5.2-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:6e7b8719005dd1175be4ab1cd25e9b98659a5e0347331506ec6760d2773a7fb5", size = 64781, upload-time = "2026-05-08T21:01:38.83Z" }, + { url = "https://files.pythonhosted.org/packages/8b/f3/38e66b1856e9bd079deea015bc4a55f7767c0e4db2f7dcf69e7e680ba4ce/propcache-0.5.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:51f96d685ab16e88cab128cd37a52c5da540809c8b879fa047731bfcb4ad35a4", size = 62570, upload-time = "2026-05-08T21:01:40.415Z" }, + { url = "https://files.pythonhosted.org/packages/95/ca/bbfe9b910ce57dde8bb4876b4520fc02a4e89497c10de26be936758a3aaa/propcache-0.5.2-cp314-cp314-win32.whl", hash = "sha256:cc6fc3cc62e8501d3ed62894425040d2728ecddb1ed072737a5c70bd537aa9f0", size = 39436, upload-time = "2026-05-08T21:01:41.654Z" }, + { url = "https://files.pythonhosted.org/packages/61/d2/45c9defbaa1ea297035d9d4cce9e8f80daafbf19319c6007f157c6256ea9/propcache-0.5.2-cp314-cp314-win_amd64.whl", hash = "sha256:81e3a30b0bb60caa22033dd0f8a3618d1d67356212514f62c57db75cb0ef410c", size = 42373, upload-time = "2026-05-08T21:01:43.041Z" }, + { url = "https://files.pythonhosted.org/packages/44/68/9ea5103f41d5217d7d6ec24db90018e23aebec070c3f9a6e54d12b841fd8/propcache-0.5.2-cp314-cp314-win_arm64.whl", hash = "sha256:0d2c9bf8528f135dbb805ce027567e09164f7efa51a2be07458a2c0420f292d0", size = 38554, upload-time = "2026-05-08T21:01:44.336Z" }, + { url = "https://files.pythonhosted.org/packages/8a/81/fadf555f42d3b762eea8a53950b0489fdc0aa9da5f8ed9e10ce0a4e01b48/propcache-0.5.2-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:4bc8ff1feffc6a61c7002ffe84634c41b822e104990ae009f44a0834430070bb", size = 99395, upload-time = "2026-05-08T21:01:45.883Z" }, + { url = "https://files.pythonhosted.org/packages/f5/c9/c61e134a686949cf7971af3a390148b1156f7be81c73bc0cd12c873e2d48/propcache-0.5.2-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:79aa3ff0a9b566633b642fa9caf7e21ed1c13d6feca718187873f199e1514078", size = 56653, upload-time = "2026-05-08T21:01:47.307Z" }, + { url = "https://files.pythonhosted.org/packages/cb/73/daf935ea7048ddd7ec8eec5345b4a40b619d2d178b3c0a0900796bc3c794/propcache-0.5.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1b31822f4474c4036bae62de9402710051d431a606d6a0f907fec79935a071aa", size = 56914, upload-time = "2026-05-08T21:01:48.573Z" }, + { url = "https://files.pythonhosted.org/packages/79/9f/aba959b435ea18617edd7cf0a7ad0b9c574b8fc7e3d2cd55fb59cb255d33/propcache-0.5.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:13fef48778b5a2a756523fdb781326b028ca75e32858b04f2cdd19f394564917", size = 62567, upload-time = "2026-05-08T21:01:49.903Z" }, + { url = "https://files.pythonhosted.org/packages/6c/a1/859942de9a791ff42f6141736f5b37749b8f53e65edfa49638c67dd67e6a/propcache-0.5.2-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8b73ab70f1a3351fbc71f663b3e645af6dd0329100c353081cf69c37433fc6fe", size = 65542, upload-time = "2026-05-08T21:01:51.204Z" }, + { url = "https://files.pythonhosted.org/packages/b5/61/315bc0fd6c0fc7f80a528b8afd209e5fc4a875ea79571b91b8f50f442907/propcache-0.5.2-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5538d2c13d93e4698af7e092b57bc7298fd35d1d58e656ae18f23ee0d0378e03", size = 66845, upload-time = "2026-05-08T21:01:52.539Z" }, + { url = "https://files.pythonhosted.org/packages/47/f7/9f8122e3132e8e354ac41975ef8f1099be7d5a16bc7ae562734e993665c0/propcache-0.5.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:cd645f03898405cabe694fb8bc35241e3a9c332ec85627584fe3de201452b335", size = 63985, upload-time = "2026-05-08T21:01:53.847Z" }, + { url = "https://files.pythonhosted.org/packages/c8/54/c317819ec157cbf6f35df9df9657a6f82daf34d5faf15948b2f639c2192e/propcache-0.5.2-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a473b3440261e0c60706e732b2ed2f517857344fc21bf48fdfe211e2d98eb285", size = 63999, upload-time = "2026-05-08T21:01:55.179Z" }, + { url = "https://files.pythonhosted.org/packages/5a/56/387e3f7dfce0a9233df41fb888aa1c30222cb4bbbf09537c02dd9bd85fe2/propcache-0.5.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:7afa37062e6650640e932e4cc9297d81f9f42d9944029cc386b8247dea4da837", size = 62779, upload-time = "2026-05-08T21:01:57.489Z" }, + { url = "https://files.pythonhosted.org/packages/a1/9c/596784cb5824ed61ee960d3f8655a3f0993e107c6e98ab6c818b7fb92ccb/propcache-0.5.2-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:8a90efd5777e996e42d568db9ac740b944d691e565cbfd31b2f7832f9184b2b8", size = 59796, upload-time = "2026-05-08T21:01:58.736Z" }, + { url = "https://files.pythonhosted.org/packages/c2/3d/1a6cfa1726a48542c1e8784a0761421476a5b68e09b7f36bf95eb954aaba/propcache-0.5.2-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:f19bb891234d72535764d703bfed1153cc34f4214d5bd7150aee1eec9e8f4366", size = 66023, upload-time = "2026-05-08T21:02:00.228Z" }, + { url = "https://files.pythonhosted.org/packages/e4/0e/05fd6990369477076e4e280bcb970de760fddf0161a46e988bc95f7940ec/propcache-0.5.2-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:32775082acd2d807ee3db715c7770d38767b817870acfa08c29e057f3c4d5b56", size = 64448, upload-time = "2026-05-08T21:02:01.888Z" }, + { url = "https://files.pythonhosted.org/packages/cd/86/5f8da315a4309c62c10c0b2516b17492d5d3bbe1bb862b96604db67e2a37/propcache-0.5.2-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:9282fb1a3bccd038da9f768b927b24a0c753e466c086b7c4f3c6982851eefb2d", size = 67329, upload-time = "2026-05-08T21:02:03.484Z" }, + { url = "https://files.pythonhosted.org/packages/da/d3/3368efe79ab21f0cdf86ef49895811c9cc933131d4cde1f28a624e22e712/propcache-0.5.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:cc49723e2f60d6b32a0f0b08a3fd6d13203c07f1cd9566cfce0f12a917c967a2", size = 65172, upload-time = "2026-05-08T21:02:04.745Z" }, + { url = "https://files.pythonhosted.org/packages/d5/07/127e8b0bacfb325396196f9d976a22453049b89b9b2b08477cc3145faa44/propcache-0.5.2-cp314-cp314t-win32.whl", hash = "sha256:2d7aa89ebca5acc98cba9d1472d976e394782f587bad6661003602a619fd1821", size = 43813, upload-time = "2026-05-08T21:02:06.025Z" }, + { url = "https://files.pythonhosted.org/packages/88/fb/46dad6c0ae49ed230ab1b16c890c2b6314e2403e6c412976f4a72d64a527/propcache-0.5.2-cp314-cp314t-win_amd64.whl", hash = "sha256:d447bb0b3054be5818458fbb171208b1d9ff11eba14e18ca18b90cbb45767370", size = 47764, upload-time = "2026-05-08T21:02:07.353Z" }, + { url = "https://files.pythonhosted.org/packages/e7/c4/a47d0a63aa309d10d59ede6e9d4cff03a344a79d1f0f4cd0cd74997b53e0/propcache-0.5.2-cp314-cp314t-win_arm64.whl", hash = "sha256:fe67a3d11cd9b4efabfa45c3d00ffba2b26811442a73a581a94b67c2b5faccf6", size = 41140, upload-time = "2026-05-08T21:02:09.065Z" }, + { url = "https://files.pythonhosted.org/packages/3a/ed/1cdcab6ba3d6ab7feca11fc14f0eeea80755bb53ef4e892079f31b10a25f/propcache-0.5.2-py3-none-any.whl", hash = "sha256:be1ddfcbb376e3de5d2e2db1d58d6d67463e6b4f9f040c000de8e300295465fe", size = 14036, upload-time = "2026-05-08T21:02:10.673Z" }, +] + +[[package]] +name = "psutil" +version = "7.2.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/aa/c6/d1ddf4abb55e93cebc4f2ed8b5d6dbad109ecb8d63748dd2b20ab5e57ebe/psutil-7.2.2.tar.gz", hash = "sha256:0746f5f8d406af344fd547f1c8daa5f5c33dbc293bb8d6a16d80b4bb88f59372", size = 493740, upload-time = "2026-01-28T18:14:54.428Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/51/08/510cbdb69c25a96f4ae523f733cdc963ae654904e8db864c07585ef99875/psutil-7.2.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:2edccc433cbfa046b980b0df0171cd25bcaeb3a68fe9022db0979e7aa74a826b", size = 130595, upload-time = "2026-01-28T18:14:57.293Z" }, + { url = "https://files.pythonhosted.org/packages/d6/f5/97baea3fe7a5a9af7436301f85490905379b1c6f2dd51fe3ecf24b4c5fbf/psutil-7.2.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:e78c8603dcd9a04c7364f1a3e670cea95d51ee865e4efb3556a3a63adef958ea", size = 131082, upload-time = "2026-01-28T18:14:59.732Z" }, + { url = "https://files.pythonhosted.org/packages/37/d6/246513fbf9fa174af531f28412297dd05241d97a75911ac8febefa1a53c6/psutil-7.2.2-cp313-cp313t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1a571f2330c966c62aeda00dd24620425d4b0cc86881c89861fbc04549e5dc63", size = 181476, upload-time = "2026-01-28T18:15:01.884Z" }, + { url = "https://files.pythonhosted.org/packages/b8/b5/9182c9af3836cca61696dabe4fd1304e17bc56cb62f17439e1154f225dd3/psutil-7.2.2-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:917e891983ca3c1887b4ef36447b1e0873e70c933afc831c6b6da078ba474312", size = 184062, upload-time = "2026-01-28T18:15:04.436Z" }, + { url = "https://files.pythonhosted.org/packages/16/ba/0756dca669f5a9300d0cbcbfae9a4c30e446dfc7440ffe43ded5724bfd93/psutil-7.2.2-cp313-cp313t-win_amd64.whl", hash = "sha256:ab486563df44c17f5173621c7b198955bd6b613fb87c71c161f827d3fb149a9b", size = 139893, upload-time = "2026-01-28T18:15:06.378Z" }, + { url = "https://files.pythonhosted.org/packages/1c/61/8fa0e26f33623b49949346de05ec1ddaad02ed8ba64af45f40a147dbfa97/psutil-7.2.2-cp313-cp313t-win_arm64.whl", hash = "sha256:ae0aefdd8796a7737eccea863f80f81e468a1e4cf14d926bd9b6f5f2d5f90ca9", size = 135589, upload-time = "2026-01-28T18:15:08.03Z" }, + { url = "https://files.pythonhosted.org/packages/81/69/ef179ab5ca24f32acc1dac0c247fd6a13b501fd5534dbae0e05a1c48b66d/psutil-7.2.2-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:eed63d3b4d62449571547b60578c5b2c4bcccc5387148db46e0c2313dad0ee00", size = 130664, upload-time = "2026-01-28T18:15:09.469Z" }, + { url = "https://files.pythonhosted.org/packages/7b/64/665248b557a236d3fa9efc378d60d95ef56dd0a490c2cd37dafc7660d4a9/psutil-7.2.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7b6d09433a10592ce39b13d7be5a54fbac1d1228ed29abc880fb23df7cb694c9", size = 131087, upload-time = "2026-01-28T18:15:11.724Z" }, + { url = "https://files.pythonhosted.org/packages/d5/2e/e6782744700d6759ebce3043dcfa661fb61e2fb752b91cdeae9af12c2178/psutil-7.2.2-cp314-cp314t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1fa4ecf83bcdf6e6c8f4449aff98eefb5d0604bf88cb883d7da3d8d2d909546a", size = 182383, upload-time = "2026-01-28T18:15:13.445Z" }, + { url = "https://files.pythonhosted.org/packages/57/49/0a41cefd10cb7505cdc04dab3eacf24c0c2cb158a998b8c7b1d27ee2c1f5/psutil-7.2.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e452c464a02e7dc7822a05d25db4cde564444a67e58539a00f929c51eddda0cf", size = 185210, upload-time = "2026-01-28T18:15:16.002Z" }, + { url = "https://files.pythonhosted.org/packages/dd/2c/ff9bfb544f283ba5f83ba725a3c5fec6d6b10b8f27ac1dc641c473dc390d/psutil-7.2.2-cp314-cp314t-win_amd64.whl", hash = "sha256:c7663d4e37f13e884d13994247449e9f8f574bc4655d509c3b95e9ec9e2b9dc1", size = 141228, upload-time = "2026-01-28T18:15:18.385Z" }, + { url = "https://files.pythonhosted.org/packages/f2/fc/f8d9c31db14fcec13748d373e668bc3bed94d9077dbc17fb0eebc073233c/psutil-7.2.2-cp314-cp314t-win_arm64.whl", hash = "sha256:11fe5a4f613759764e79c65cf11ebdf26e33d6dd34336f8a337aa2996d71c841", size = 136284, upload-time = "2026-01-28T18:15:19.912Z" }, + { url = "https://files.pythonhosted.org/packages/e7/36/5ee6e05c9bd427237b11b3937ad82bb8ad2752d72c6969314590dd0c2f6e/psutil-7.2.2-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:ed0cace939114f62738d808fdcecd4c869222507e266e574799e9c0faa17d486", size = 129090, upload-time = "2026-01-28T18:15:22.168Z" }, + { url = "https://files.pythonhosted.org/packages/80/c4/f5af4c1ca8c1eeb2e92ccca14ce8effdeec651d5ab6053c589b074eda6e1/psutil-7.2.2-cp36-abi3-macosx_11_0_arm64.whl", hash = "sha256:1a7b04c10f32cc88ab39cbf606e117fd74721c831c98a27dc04578deb0c16979", size = 129859, upload-time = "2026-01-28T18:15:23.795Z" }, + { url = "https://files.pythonhosted.org/packages/b5/70/5d8df3b09e25bce090399cf48e452d25c935ab72dad19406c77f4e828045/psutil-7.2.2-cp36-abi3-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:076a2d2f923fd4821644f5ba89f059523da90dc9014e85f8e45a5774ca5bc6f9", size = 155560, upload-time = "2026-01-28T18:15:25.976Z" }, + { url = "https://files.pythonhosted.org/packages/63/65/37648c0c158dc222aba51c089eb3bdfa238e621674dc42d48706e639204f/psutil-7.2.2-cp36-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b0726cecd84f9474419d67252add4ac0cd9811b04d61123054b9fb6f57df6e9e", size = 156997, upload-time = "2026-01-28T18:15:27.794Z" }, + { url = "https://files.pythonhosted.org/packages/8e/13/125093eadae863ce03c6ffdbae9929430d116a246ef69866dad94da3bfbc/psutil-7.2.2-cp36-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:fd04ef36b4a6d599bbdb225dd1d3f51e00105f6d48a28f006da7f9822f2606d8", size = 148972, upload-time = "2026-01-28T18:15:29.342Z" }, + { url = "https://files.pythonhosted.org/packages/04/78/0acd37ca84ce3ddffaa92ef0f571e073faa6d8ff1f0559ab1272188ea2be/psutil-7.2.2-cp36-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:b58fabe35e80b264a4e3bb23e6b96f9e45a3df7fb7eed419ac0e5947c61e47cc", size = 148266, upload-time = "2026-01-28T18:15:31.597Z" }, + { url = "https://files.pythonhosted.org/packages/b4/90/e2159492b5426be0c1fef7acba807a03511f97c5f86b3caeda6ad92351a7/psutil-7.2.2-cp37-abi3-win_amd64.whl", hash = "sha256:eb7e81434c8d223ec4a219b5fc1c47d0417b12be7ea866e24fb5ad6e84b3d988", size = 137737, upload-time = "2026-01-28T18:15:33.849Z" }, + { url = "https://files.pythonhosted.org/packages/8c/c7/7bb2e321574b10df20cbde462a94e2b71d05f9bbda251ef27d104668306a/psutil-7.2.2-cp37-abi3-win_arm64.whl", hash = "sha256:8c233660f575a5a89e6d4cb65d9f938126312bca76d8fe087b947b3a1aaac9ee", size = 134617, upload-time = "2026-01-28T18:15:36.514Z" }, +] + +[[package]] +name = "ptyprocess" +version = "0.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/20/e5/16ff212c1e452235a90aeb09066144d0c5a6a8c0834397e03f5224495c4e/ptyprocess-0.7.0.tar.gz", hash = "sha256:5c5d0a3b48ceee0b48485e0c26037c0acd7d29765ca3fbb5cb3831d347423220", size = 70762, upload-time = "2020-12-28T15:15:30.155Z" } +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 = "pure-eval" +version = "0.2.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/cd/05/0a34433a064256a578f1783a10da6df098ceaa4a57bbeaa96a6c0352786b/pure_eval-0.2.3.tar.gz", hash = "sha256:5f4e983f40564c576c7c8635ae88db5956bb2229d7e9237d03b3c0b0190eaf42", size = 19752, upload-time = "2024-07-21T12:58:21.801Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8e/37/efad0257dc6e593a18957422533ff0f87ede7c9c6ea010a2177d738fb82f/pure_eval-0.2.3-py3-none-any.whl", hash = "sha256:1db8e35b67b3d218d818ae653e27f06c3aa420901fa7b081ca98cbedc874e0d0", size = 11842, upload-time = "2024-07-21T12:58:20.04Z" }, +] + [[package]] name = "pyarrow" version = "24.0.0" @@ -1093,6 +2902,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/51/be/6f79d55816d5c22557cf27533543d5d70dfe692adfbee4b99f2760674f38/pyarrow-24.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:c91d00057f23b8d353039520dc3a6c09d8608164c692e9f59a175a42b2ae0c19", size = 28131282, upload-time = "2026-04-21T10:51:16.815Z" }, ] +[[package]] +name = "pycparser" +version = "3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1b/7d/92392ff7815c21062bea51aa7b87d45576f649f16458d78b7cf94b9ab2e6/pycparser-3.0.tar.gz", hash = "sha256:600f49d217304a5902ac3c37e1281c9fe94e4d0489de643a9504c5cdfdfc6b29", size = 103492, upload-time = "2026-01-21T14:26:51.89Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0c/c3/44f3fbbfa403ea2a7c779186dc20772604442dde72947e7d01069cbe98e3/pycparser-3.0-py3-none-any.whl", hash = "sha256:b727414169a36b7d524c1c3e31839a521725078d7b2ff038656844266160a992", size = 48172, upload-time = "2026-01-21T14:26:50.693Z" }, +] + [[package]] name = "pydantic" version = "2.13.4" @@ -1256,6 +3074,35 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892, upload-time = "2024-03-01T18:36:18.57Z" }, ] +[[package]] +name = "python-json-logger" +version = "4.2.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/21/25/5473e46b179f8e8b4ad3aeeb36773d1701b7770eaf5e5bc2025c7303b598/python_json_logger-4.2.0.tar.gz", hash = "sha256:e371ebe22ec01e289850102091a2b1f6fc9e655c7f1f5f29073936756c290afa", size = 18211, upload-time = "2026-08-15T11:36:38.232Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/dc/55/6467fde553886cb293e41538f3a8b4e4fd4688c6df242cf982162d8367fb/python_json_logger-4.2.0-py3-none-any.whl", hash = "sha256:158a52126fcd6869e09574d2b66272666f3dc8f468c62637ef9a1fa883719cb9", size = 14988, upload-time = "2026-08-15T11:36:36.821Z" }, +] + +[[package]] +name = "pywinpty" +version = "3.0.5" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a9/ef/2d27f30c59a67be7025b2d7858c8c2d282b74d66544b2384730b82de74fd/pywinpty-3.0.5.tar.gz", hash = "sha256:61db0db063de9865adbea66db294628f8577f608d9764a4c7d3384eeacc4e81b", size = 16223484, upload-time = "2026-06-11T00:11:58.93Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b0/5c/31feb3dd82d1b33ae0bd09ca601edb993d9da1b7f0226b3336d4b4c39e1e/pywinpty-3.0.5-cp311-cp311-win_amd64.whl", hash = "sha256:af7a8720c78776ddd6259b71dd567944f766a6cd67f8d2887fbc4973967bacda", size = 2092466, upload-time = "2026-06-10T23:44:24.453Z" }, + { url = "https://files.pythonhosted.org/packages/ee/fe/fe23e2229ffec0c10190cef5964f5c9b2dba179d23b69ae537b7ea90bcab/pywinpty-3.0.5-cp311-cp311-win_arm64.whl", hash = "sha256:c2406f54f699eab75953fb75ce805f2ae55a33a957cd070890abd454fb4b7680", size = 818395, upload-time = "2026-06-10T23:41:56.93Z" }, + { url = "https://files.pythonhosted.org/packages/45/34/942cc95ca4e26489875aa8a95192766247a687379ec29543eebe73ec945f/pywinpty-3.0.5-cp312-cp312-win_amd64.whl", hash = "sha256:d62946adf14b15b54c0b8d785f93fe18b04da23f4ad59e2e8c4612646e9abd23", size = 2090915, upload-time = "2026-06-10T23:43:14.98Z" }, + { url = "https://files.pythonhosted.org/packages/6a/70/5b9053004844139ea8bd86209c57ade12b134b2782f383a095784c8531ec/pywinpty-3.0.5-cp312-cp312-win_arm64.whl", hash = "sha256:e9391c05fbfa7a992a97e831fc6849887b4014a614192e3d984a7ca59592b376", size = 815934, upload-time = "2026-06-10T23:41:42.384Z" }, + { url = "https://files.pythonhosted.org/packages/b9/f4/2a464b9893cceb3b3f416356e94fdc3e1bca9476993927e4e6d99fe95382/pywinpty-3.0.5-cp313-cp313-win_amd64.whl", hash = "sha256:48db1b0ad9d0a1b81dcaaa7163a99a7808deaceb0c1b2344716dc1fc090c3c4c", size = 2090471, upload-time = "2026-06-10T23:42:11.071Z" }, + { url = "https://files.pythonhosted.org/packages/3c/2c/a138491a0afbdb50eb79395577bd326d4b0fbde7209417d1a8087ff2493a/pywinpty-3.0.5-cp313-cp313-win_arm64.whl", hash = "sha256:2c6008fb2d3774b48693b2fcb7f2cc317ade9dc581289a964ffeeaf81307c9b5", size = 815518, upload-time = "2026-06-10T23:42:02.363Z" }, + { url = "https://files.pythonhosted.org/packages/6f/15/54400049a380582acd1282665c70fcf11e0bd3713679aca78e24c3aae738/pywinpty-3.0.5-cp313-cp313t-win_amd64.whl", hash = "sha256:22ce1b780d89821cc52daf6eac0708af22d93d000ce9c7c07e37489db8594598", size = 2089920, upload-time = "2026-06-10T23:44:13.395Z" }, + { url = "https://files.pythonhosted.org/packages/94/0c/6f24f3c0799f502259b24bdf841a99ad2b0d59df5c2525b4e2a286d14be2/pywinpty-3.0.5-cp313-cp313t-win_arm64.whl", hash = "sha256:9c2919a81bc5cfb09b86fc5a002112b2de95ca4304a07413cbeeb746a1307a5c", size = 814520, upload-time = "2026-06-10T23:43:28.588Z" }, + { url = "https://files.pythonhosted.org/packages/e9/23/f3cd1b1e5fc56517f54452c49f92049e7dd9ffc8a63de22a495581f50d04/pywinpty-3.0.5-cp314-cp314-win_amd64.whl", hash = "sha256:03bb3c16d691d9242267201830bcd0e64a9b663170e9042bc84b210da9de15ac", size = 2090663, upload-time = "2026-06-10T23:43:59.845Z" }, + { url = "https://files.pythonhosted.org/packages/9d/dd/96d6cbfc6d9ddab5c1c2f92c26545ae8997446a2ba7ee2024cd43c81f49b/pywinpty-3.0.5-cp314-cp314-win_arm64.whl", hash = "sha256:89c5c6ef08997a3b4b277b214a35fe15cab4dd6d119f0140aa71df5b1168fdbc", size = 815700, upload-time = "2026-06-10T23:40:50.001Z" }, + { url = "https://files.pythonhosted.org/packages/30/36/d98087bce0acaa4cce7f196103cfa7be3f63ce65f52473bb3e38784ae5d9/pywinpty-3.0.5-cp314-cp314t-win_amd64.whl", hash = "sha256:7b566165e0c5fdd6abe167a5ac8b954be6a843eb55a85946576d6bc1dea03d6d", size = 2090093, upload-time = "2026-06-10T23:40:58.933Z" }, + { url = "https://files.pythonhosted.org/packages/57/fd/fe2b0db922ba052ce3976a08f3fc05d0c05047c8b4ebb6102e832b8ef563/pywinpty-3.0.5-cp314-cp314t-win_arm64.whl", hash = "sha256:24366280a8aa677323da87bec729cb3ea3b35367386cece0978bdc6e4695c690", size = 814517, upload-time = "2026-06-10T23:42:34.946Z" }, +] + [[package]] name = "pyyaml" version = "6.0.3" @@ -1311,6 +3158,412 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341, upload-time = "2025-09-25T21:32:56.828Z" }, ] +[[package]] +name = "pyzmq" +version = "27.2.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cffi", marker = "implementation_name == 'pypy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e7/8d/5b3d5631c2f4b4b8862f64cd0c9eb777b5710eeb5125b4be8dd0a200a4c0/pyzmq-27.2.0.tar.gz", hash = "sha256:54d4259d1bfae24ecdb5ca79f7acc2eac6c286a02d6a0ae617797cb45f0726d3", size = 292316, upload-time = "2026-08-20T19:08:21.19Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1d/2e/8897afa4538707d86645f51cc50e66b2b84900edb1be9dc9af2c2fc04e5d/pyzmq-27.2.0-cp311-cp311-macosx_10_15_universal2.whl", hash = "sha256:9216132843d139a123f243c07fe70f7487dce5041093dd77040f9adb5dc91872", size = 1457109, upload-time = "2026-08-20T19:06:26.022Z" }, + { url = "https://files.pythonhosted.org/packages/d1/bc/dbce7bc1654fa25b1e68b9bad9e547906f581ce919c186a88ed951cb794c/pyzmq-27.2.0-cp311-cp311-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:d41ebb260b69329b7d4a2936d44c872c86dd785355b51366c8b14e07ed7e9373", size = 985701, upload-time = "2026-08-20T19:06:27.481Z" }, + { url = "https://files.pythonhosted.org/packages/95/cf/6981738b57c83fef33f356141ad83bf51e92f2f70c9d5767affd1a699f07/pyzmq-27.2.0-cp311-cp311-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:468139ddb2e494d06e586bd3a6835077e8b3764560c8db552fe685c5867fc24e", size = 714285, upload-time = "2026-08-20T19:06:28.962Z" }, + { url = "https://files.pythonhosted.org/packages/50/b5/13657961a845e29c28a4e7ac4202999ec90b3bba1890a5469ce2ae90359d/pyzmq-27.2.0-cp311-cp311-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:39755dc4a923021bd0677990ffdbc21cff0e1ee1cf07fe3817acea153ef4cb67", size = 888465, upload-time = "2026-08-20T19:06:30.4Z" }, + { url = "https://files.pythonhosted.org/packages/58/5a/ca7ee7a767413d4ba858e93748b95e30b35b8c139849fba94de4433ea2e5/pyzmq-27.2.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:714f8cbd66c7e405338d668f79d2fe83fe923defe348e843be998603cf92eeff", size = 1705731, upload-time = "2026-08-20T19:06:31.819Z" }, + { url = "https://files.pythonhosted.org/packages/0b/8b/083f6184e4eba566c9a3cc9974b1b0fe327b7093788135ba8133edaa67a6/pyzmq-27.2.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:1132805970045adb9f5f05dd57040978286a8e21a5475f2c2ddf1bc983b9a2c7", size = 2074243, upload-time = "2026-08-20T19:06:33.36Z" }, + { url = "https://files.pythonhosted.org/packages/57/f5/249362b664ae725d534c8843214fa9fd7fccd74532a19e24603954a88a7d/pyzmq-27.2.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:b26f2d0493b79ce3c3112c8a12649418915582ba4707b8ed9f44febf2be71f42", size = 1926859, upload-time = "2026-08-20T19:06:34.796Z" }, + { url = "https://files.pythonhosted.org/packages/bf/cc/23c613c15f06d879f13364d14c17e5e4e8304049411e96c1410e6e56c3ea/pyzmq-27.2.0-cp311-cp311-win32.whl", hash = "sha256:44f261eca7dfb9904ea2b56428f59ab693bbe2715c0413a701f17b067ebf877c", size = 570747, upload-time = "2026-08-20T19:06:36.337Z" }, + { url = "https://files.pythonhosted.org/packages/dc/bc/bbbcf89003c93f18e33665c26e3c48d75e3915c3dd22887f3a7aea2c5e26/pyzmq-27.2.0-cp311-cp311-win_amd64.whl", hash = "sha256:8b86e04f55af0f4d8cd8ecf14c0b8b81ebc8fd66fa20126b753514628ecadc7e", size = 644845, upload-time = "2026-08-20T19:06:37.711Z" }, + { url = "https://files.pythonhosted.org/packages/14/c5/4635d0ba2b8493edf6d5541fff0b07fa1d986fdfc29c596a53a21e20f9af/pyzmq-27.2.0-cp311-cp311-win_arm64.whl", hash = "sha256:917d601e9540098f580d2723d0ce6402cdb6f02bc8dc2de74e0dca6e13bffd1b", size = 567495, upload-time = "2026-08-20T19:06:39.246Z" }, + { url = "https://files.pythonhosted.org/packages/57/8a/153532fa53db30e116118164f3af269a1f3966b3e2ba32c89b12fe864bd8/pyzmq-27.2.0-cp312-abi3-macosx_10_15_universal2.whl", hash = "sha256:591c8de5851c5ea372194469fe97587b97c3b641e9a70f31bb3474acbfde0241", size = 1431074, upload-time = "2026-08-20T19:06:40.601Z" }, + { url = "https://files.pythonhosted.org/packages/c8/ef/c08b91248bb90a9efa81fa00ba81b69c157c74d0c5efbb2c319d91babb62/pyzmq-27.2.0-cp312-abi3-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:00e73942ef12cecbc7951c4a9104bb8ffaed742abb13af2da6833d90dd368cef", size = 973915, upload-time = "2026-08-20T19:06:42.037Z" }, + { url = "https://files.pythonhosted.org/packages/b4/78/a3a3a86c2b00fadb92ece1ca4f8f028d62b2ce9ac3526097239ab2d6fba9/pyzmq-27.2.0-cp312-abi3-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1f8079d0521fe94bbb401fe9407578b28f3701627c8be2c9f7e0c5b77dcb0109", size = 697722, upload-time = "2026-08-20T19:06:43.325Z" }, + { url = "https://files.pythonhosted.org/packages/62/2c/d5828306f795e8d34676d266823b74e2101e0ad3760d12083de3e02abbb2/pyzmq-27.2.0-cp312-abi3-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:dea74fd65f1fc5f7fe167916a473ebe6ed6174e5e5d9de11ea6583661be6cf43", size = 872258, upload-time = "2026-08-20T19:06:44.627Z" }, + { url = "https://files.pythonhosted.org/packages/09/52/51253b78fd8739293e283407eeecb14215c02c71b6519af21f6eed8e69cd/pyzmq-27.2.0-cp312-abi3-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:dcc99ca132b667a4ed750afd42db4ea73288f18425a9b2e3c0af095665c491f5", size = 739591, upload-time = "2026-08-20T19:06:46.214Z" }, + { url = "https://files.pythonhosted.org/packages/e6/3e/142c85b67a4c9678629b0cf6d5125b29663d75be69bfaa57a3cac344d780/pyzmq-27.2.0-cp312-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:b8d5f66e4a8246cf77f7b8f7902af64f00553368fa0373c89d99b78f0ad79394", size = 1689031, upload-time = "2026-08-20T19:06:47.612Z" }, + { url = "https://files.pythonhosted.org/packages/0e/ee/0776fb0f98ed1eb74d77240087fef0ab045b6ad15cb09555c6c5134c98ad/pyzmq-27.2.0-cp312-abi3-musllinux_1_2_i686.whl", hash = "sha256:d1526b42a2e725b84ed226f37becedc250c6347594e5ed304e4e9aff68c9aec3", size = 2059547, upload-time = "2026-08-20T19:06:49.064Z" }, + { url = "https://files.pythonhosted.org/packages/aa/0e/ec77f691a4aebe29ab6329f996fb0e0270c876a3016086e3ca6ef733bcae/pyzmq-27.2.0-cp312-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:f707bcf2c1d007d14d70531d4dd7b41060881c73efa845580bf6faaf9ea24d42", size = 1910457, upload-time = "2026-08-20T19:06:50.783Z" }, + { url = "https://files.pythonhosted.org/packages/30/97/1f5530ff4fc271b4597048371d5af972c2baab51be132ba15874e0327a6a/pyzmq-27.2.0-cp312-abi3-win32.whl", hash = "sha256:fdaaa4ea3242f6ad298eb5177eb042aea5c73c30e76d20caee7b15af20d24ec2", size = 563450, upload-time = "2026-08-20T19:06:52.307Z" }, + { url = "https://files.pythonhosted.org/packages/02/8b/b83f7780dad22e0878e4c7bd9158ebd24ed12bc3d5e3a471cd0576f77ded/pyzmq-27.2.0-cp312-abi3-win_amd64.whl", hash = "sha256:2c218c6ab8bc447ba62054b581fd30209689d199c6ecb253f79615ca74a38e12", size = 628633, upload-time = "2026-08-20T19:06:53.809Z" }, + { url = "https://files.pythonhosted.org/packages/52/aa/3918b5ac7f9987bd9c421b065074fd7409ded88f856f2c704a24341877ec/pyzmq-27.2.0-cp312-abi3-win_arm64.whl", hash = "sha256:348d6fd3e4b81ae4580622ea8c2ea60224e84b2ac1b3be4482e6edc7de06e7a3", size = 556006, upload-time = "2026-08-20T19:06:55.242Z" }, + { url = "https://files.pythonhosted.org/packages/83/5e/d0541596b48c5a19f85dcbea83d6673d8e91681cdf853eb194c31fc9766e/pyzmq-27.2.0-cp313-cp313-android_24_arm64_v8a.whl", hash = "sha256:c551b9e2f86dc625fcb1a032c0d68042678caf96a8dd7c28796766b673bd5b52", size = 1127193, upload-time = "2026-08-20T19:06:56.545Z" }, + { url = "https://files.pythonhosted.org/packages/50/9f/8c7411bb283982d46e6d56dca6a095678c87eb0398daead12776d9881ac2/pyzmq-27.2.0-cp313-cp313-android_24_x86_64.whl", hash = "sha256:288cc790da0e3064a14a38ddc56ba169dada8c8af4cb86518db2bcbd380eedbb", size = 1166833, upload-time = "2026-08-20T19:06:58.011Z" }, + { url = "https://files.pythonhosted.org/packages/f9/84/a849161ff88b2de9b991cc8ab332218824741122fdc4fdf222a5b822ac8c/pyzmq-27.2.0-cp314-cp314-android_24_arm64_v8a.whl", hash = "sha256:3d45189c0c3c99f817b7fefff0d32eeef684cf33e1e3c0fc4281515357c54702", size = 1134452, upload-time = "2026-08-20T19:06:59.898Z" }, + { url = "https://files.pythonhosted.org/packages/3c/34/ff4aaff0cfba2a4d7ad1a16ffedc52c6deb89fcf673d455085446b23f215/pyzmq-27.2.0-cp314-cp314-android_24_x86_64.whl", hash = "sha256:d61910b52be5b2cd8b248dbcbe3a1b0275556a7d99fb613fc43323b546e273b8", size = 1167520, upload-time = "2026-08-20T19:07:01.283Z" }, + { url = "https://files.pythonhosted.org/packages/b6/07/42111e9dc1041d78b4443d6eb1b82b027f1a58178dc8a38385effbc72ad5/pyzmq-27.2.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:3ab6eb88590e510ab16715c32dbba12000da9bee989fdadd9ee19a234c492eb7", size = 1466289, upload-time = "2026-08-20T19:07:02.738Z" }, + { url = "https://files.pythonhosted.org/packages/4b/b4/def7a478458da78665840564161772e7e938600c32a89f28e8b221b54d2d/pyzmq-27.2.0-cp314-cp314t-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:1ecbdd131b9669f62d3a45afee5527c7ae9f141e4301267f21714c90bd21725f", size = 975868, upload-time = "2026-08-20T19:07:04.155Z" }, + { url = "https://files.pythonhosted.org/packages/38/d5/e3e85f7fea37153097aaff49db9e33093909cc2a7b22c1ac4ebe546600fc/pyzmq-27.2.0-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3146385b94a760236c5eceff468a66a296a716ca98a2e0f9217b1518118466b1", size = 706054, upload-time = "2026-08-20T19:07:05.623Z" }, + { url = "https://files.pythonhosted.org/packages/1c/ef/3b7d9449b223183222bf517245e1e53d5f1ab8c10be8b45f6a301b2f994a/pyzmq-27.2.0-cp314-cp314t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9846e881620dd62566ca76a53e384c3f37490faf4b9240aebc7498810dfca853", size = 878984, upload-time = "2026-08-20T19:07:07.153Z" }, + { url = "https://files.pythonhosted.org/packages/be/a5/8b49dbd494f6dcfda69dc4cade322a4b02706ef4e3d30cc366d4e369899f/pyzmq-27.2.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:d9527e3dbaef1edaeeb2446fa7379446814a43ade8adc7c4a5ebe69437815ddd", size = 1697489, upload-time = "2026-08-20T19:07:08.945Z" }, + { url = "https://files.pythonhosted.org/packages/da/5a/4bb8280901130c26ea25f0cbb4a6d39d94250860c6b3dbd912f1cf48fca7/pyzmq-27.2.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:56b48fa9d478a3af7254f397697a62f5ad3e1bb677e200b2701f0c290d97e5af", size = 2064236, upload-time = "2026-08-20T19:07:10.384Z" }, + { url = "https://files.pythonhosted.org/packages/de/38/f433af66922554adb2b5f79e897018c8e19a90b9eaeb49c4814f8355ebe4/pyzmq-27.2.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:bf0b6e4ce1bb089751c504c5493d6b0557eabd02dd21b76e9086cf964234b103", size = 1917424, upload-time = "2026-08-20T19:07:11.909Z" }, + { url = "https://files.pythonhosted.org/packages/36/81/ea1c1ae3f801d96ba2c269e056761ebcfe023476e651d3af2a7817962051/pyzmq-27.2.0-cp314-cp314t-win32.whl", hash = "sha256:fba8afcf265c6e9fbe1594cb045d4765c6c9a7d607653a8196067ef23566b843", size = 591103, upload-time = "2026-08-20T19:07:13.451Z" }, + { url = "https://files.pythonhosted.org/packages/8a/04/149a627707e780fa9f2c1ede3590c14fa6b18b5576d15744342622299a50/pyzmq-27.2.0-cp314-cp314t-win_amd64.whl", hash = "sha256:d1bc1d380a91d954ed5fc9f12915dba014eed0978d2de05ee7ca688bdaac144a", size = 670215, upload-time = "2026-08-20T19:07:15.069Z" }, + { url = "https://files.pythonhosted.org/packages/30/ba/f9c3c1536c41ef3dbf765ea04218990e2056e558f98184ecd883767fc501/pyzmq-27.2.0-cp314-cp314t-win_arm64.whl", hash = "sha256:c7cfb75caa83f5153c687e9d2107f64b5ef0ef0d6edd260d3ff920baaaa69101", size = 582252, upload-time = "2026-08-20T19:07:16.582Z" }, + { url = "https://files.pythonhosted.org/packages/fa/00/78fe097a304a408275747ce43f20428789130b059c5649956277c20f30cf/pyzmq-27.2.0-cp315-cp315-android_24_arm64_v8a.whl", hash = "sha256:c5129a8fe43ecc49b99eb75616603d483a3c2fcaef504988fafe8ea392aea98b", size = 1134295, upload-time = "2026-08-20T19:07:17.94Z" }, + { url = "https://files.pythonhosted.org/packages/f2/83/1c36270658d2ee56e23a3f9ef5fbcb94cbd2f9fe966a6641f2f38e697162/pyzmq-27.2.0-cp315-cp315-android_24_x86_64.whl", hash = "sha256:baa2ce3485145653194d6c8c5beedd1e9f0bf46a0919c9fa2fe2204fc35b74d9", size = 1167492, upload-time = "2026-08-20T19:07:19.476Z" }, + { url = "https://files.pythonhosted.org/packages/58/b2/f0ae223438d7faa991f6feefdc823815f11cc604f898738376b59fd96515/pyzmq-27.2.0-cp315-cp315t-macosx_10_15_universal2.whl", hash = "sha256:e1ed46048d1920cabc96d952a0d5cfe4127ad8db572c335aae4e3c57b9278d7f", size = 1465992, upload-time = "2026-08-20T19:07:20.941Z" }, + { url = "https://files.pythonhosted.org/packages/59/46/fb56f3f37a6a0937b0e1d2885e808b5eedc171320bac85573cfae78fa9bc/pyzmq-27.2.0-cp315-cp315t-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:e0fa0bc6b1a184aee59b32efcd1b7f0e6d5b8f9387799e4c16a4cb66a86747d6", size = 976118, upload-time = "2026-08-20T19:07:22.577Z" }, + { url = "https://files.pythonhosted.org/packages/21/82/a2c9bfd7c4d34eea1278493cd041bc000d41acb4463c89ceaad29dc813b6/pyzmq-27.2.0-cp315-cp315t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0f4bd6743e8bf854c3bfce892dd6578a514aabf128e37a4b2eafcf01856f7e44", size = 705968, upload-time = "2026-08-20T19:07:24.019Z" }, + { url = "https://files.pythonhosted.org/packages/d6/12/b906b269116b6591dc15c0acc5d04c043957c8a531d336999731f4b1d899/pyzmq-27.2.0-cp315-cp315t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:95369ed6626afcfe2ac89832fb1b917c077fbeb905fbbe5d918349ce0222b89b", size = 879011, upload-time = "2026-08-20T19:07:25.428Z" }, + { url = "https://files.pythonhosted.org/packages/12/13/f96359534bfb77651c15f1fbfc4bfdd7ec3489d23f434706d39598dd0dcd/pyzmq-27.2.0-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:40124779c3a56ad5d91902df1ff89159cb414b6c1a0ee697abcc66cf5e6db62d", size = 1697496, upload-time = "2026-08-20T19:07:26.821Z" }, + { url = "https://files.pythonhosted.org/packages/21/b4/2c007ae5f2fe5eca86cbfbc874ed86b5135f2f7812615dfd78606d3c93f6/pyzmq-27.2.0-cp315-cp315t-musllinux_1_2_i686.whl", hash = "sha256:ec8a318dfc27c7d946651b3d9e8025d5734f30c168a822195601827207bac09b", size = 2064347, upload-time = "2026-08-20T19:07:28.315Z" }, + { url = "https://files.pythonhosted.org/packages/9b/88/767af3a6630c15215f3a66700ec79598a375edd1fdc9d75a3ad522178c01/pyzmq-27.2.0-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:88c0fac061bac269076edeb3a209acefc96cd6167c239daf1c2b404ac48d7012", size = 1917360, upload-time = "2026-08-20T19:07:29.693Z" }, + { url = "https://files.pythonhosted.org/packages/35/c1/80dd2d20d6e57bc68e1dce1e84bf3e76c9577c1bf728199985c8b4ea0fd1/pyzmq-27.2.0-cp315-cp315t-win32.whl", hash = "sha256:ac126d48cf18aa955daabef43bf0009ff76ad4deee437d09ecf15388214b5beb", size = 591073, upload-time = "2026-08-20T19:07:31.341Z" }, + { url = "https://files.pythonhosted.org/packages/f8/b5/33b781666f3f52ae834bc9c8e38f4f0483a826c5a91cccc993292007bf10/pyzmq-27.2.0-cp315-cp315t-win_amd64.whl", hash = "sha256:edce90a1e588ec63adbf612cc0ad582de4169cd216c7ae53c15f42a2ee902f35", size = 670701, upload-time = "2026-08-20T19:07:32.895Z" }, + { url = "https://files.pythonhosted.org/packages/6e/97/bc4f0edefb992df4fdebcf9f0cc40f631cd4ed277e1ed59ef2cd99a5c8c5/pyzmq-27.2.0-cp315-cp315t-win_arm64.whl", hash = "sha256:a843094b4d3d633bc3623e47a2ff50742d6af02bc1f7606aa2e67e971e21878d", size = 581985, upload-time = "2026-08-20T19:07:34.19Z" }, + { url = "https://files.pythonhosted.org/packages/93/22/7187a1f0bf2b8bf8dc6b91762438fb9b472f684f2dc4cb74a24bf8957943/pyzmq-27.2.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:a7c1144dc61777938e932a2c9011b980b89fd8ff3733033b34c44c299187a6e1", size = 875015, upload-time = "2026-08-20T19:08:01.692Z" }, + { url = "https://files.pythonhosted.org/packages/92/71/09b71620ad52bad4eb68b1516978ecaf52ef623c3fa16e0732a03cf3274c/pyzmq-27.2.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:c218b816220d05acf6ab1bafca58926d95cbcc5fec5024724666030466308f0c", size = 774395, upload-time = "2026-08-20T19:08:03.108Z" }, + { url = "https://files.pythonhosted.org/packages/9c/cf/5c8eb9994a14ff5ee5b0cada339421748746c95aee0280c8b656741e8749/pyzmq-27.2.0-pp311-pypy311_pp73-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:ae6ebbc0bfe5a21ce21e32ba567bf73df2d93888109c65acbd42506cf9395759", size = 877994, upload-time = "2026-08-20T19:08:04.724Z" }, + { url = "https://files.pythonhosted.org/packages/97/64/e22094c5555e550b6450ecfcceb6a1205d893d9a18ae27764c8c45acfb16/pyzmq-27.2.0-pp311-pypy311_pp73-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:679b5b1dde326a921ea2c9ec1f9ea3115bfe1b4735779bbc6eb0473a0ed93f71", size = 614492, upload-time = "2026-08-20T19:08:06.487Z" }, + { url = "https://files.pythonhosted.org/packages/d2/28/5b1042899caed18278c56d54a502f5254d463afe8aea1acbecc98e053391/pyzmq-27.2.0-pp311-pypy311_pp73-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f5c6d8744d10b5e1eadd90a7c58f8546acf6bf680ee463f7e6ada09ad6c9f802", size = 780574, upload-time = "2026-08-20T19:08:07.987Z" }, + { url = "https://files.pythonhosted.org/packages/77/a3/f134603a671c114c6b56eb912bba890f09e2d43b8a28d243be5a5507cf2f/pyzmq-27.2.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:3ee8dd7031d5e23f632e0e7eee67183ca7d2536e0de35dc1e5d69f3471a791e8", size = 553961, upload-time = "2026-08-20T19:08:09.651Z" }, +] + +[[package]] +name = "referencing" +version = "0.37.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "attrs" }, + { name = "rpds-py" }, + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/22/f5/df4e9027acead3ecc63e50fe1e36aca1523e1719559c499951bb4b53188f/referencing-0.37.0.tar.gz", hash = "sha256:44aefc3142c5b842538163acb373e24cce6632bd54bdb01b21ad5863489f50d8", size = 78036, upload-time = "2025-10-13T15:30:48.871Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2c/58/ca301544e1fa93ed4f80d724bf5b194f6e4b945841c5bfd555878eea9fcb/referencing-0.37.0-py3-none-any.whl", hash = "sha256:381329a9f99628c9069361716891d34ad94af76e461dcb0335825aecc7692231", size = 26766, upload-time = "2025-10-13T15:30:47.625Z" }, +] + +[[package]] +name = "regex" +version = "2026.9.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/19/c1/6b30b775c7bcc6cf6506a4d4741c2123e8d99cd50f3fe8cbd731f5fef526/regex-2026.9.3.tar.gz", hash = "sha256:aabd43208e335f4c3f0b56de3464b066dd425983a58f6eeb5738bcd7465403db", size = 416720, upload-time = "2026-09-01T00:53:43.821Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/db/fc/b4ff5d9550796f9f955b6c2470f37e2b582ec944638f3004499929a69c96/regex-2026.9.3-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:6fe39780de6916ecb1c664eda81802e6310fd9d4a07dccb13a86b63918e00e65", size = 493967, upload-time = "2026-09-01T00:50:00.23Z" }, + { url = "https://files.pythonhosted.org/packages/49/6b/ab60a24883b810a4b29065540f56e6f72590bb97d704d7e0ee7bcd2ba98c/regex-2026.9.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:3d75065d9f6ed1afb2a41588def408cf442cee65b3651cbd7e86650146127bb4", size = 295227, upload-time = "2026-09-01T00:50:01.804Z" }, + { url = "https://files.pythonhosted.org/packages/6c/e6/e3bf61522cd82eda85a90dd8f69c839f0ce1da64dc6e87f803bb79267c59/regex-2026.9.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:5dd356a646fe549d42b766cb9075b54eccd3f20604d87a3eff25f1430bba5b2e", size = 290639, upload-time = "2026-09-01T00:50:03.244Z" }, + { url = "https://files.pythonhosted.org/packages/b1/b2/e8492b054c5c9fe09bc0aefdc308b8f845ec2094b1ae779accec8f14dedb/regex-2026.9.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:90aa2a7f9cc1cd2e8082db61618a2ed0f4197eef52266a6420e88277f184e328", size = 791712, upload-time = "2026-09-01T00:50:05.539Z" }, + { url = "https://files.pythonhosted.org/packages/48/03/429ee3479bb438f7b2b41147fa68d63a7ef9c7486fcd3960e04e61133cf3/regex-2026.9.3-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:1f975a75dae06e88665e4a709873d936a7e8f9445e3d354b75de0e735d28cf71", size = 861711, upload-time = "2026-09-01T00:50:06.988Z" }, + { url = "https://files.pythonhosted.org/packages/cb/9e/6ebf3cec538ed49d0a4cf5729129fe39580ddfa80c1c59c4274651762202/regex-2026.9.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d1d52739de118acf82bfbaf7046955ead4fb613d24ba4187be565cd91ff9a64e", size = 905894, upload-time = "2026-09-01T00:50:08.437Z" }, + { url = "https://files.pythonhosted.org/packages/19/e4/a7bb1e4038a170714c824dc7c739f8b911cb1172f87ab950be39e0691f95/regex-2026.9.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:99034ec353c973e2c89555866083491b9a2dbe81f2fbe15fb0f2b68506232f01", size = 801135, upload-time = "2026-09-01T00:50:10.308Z" }, + { url = "https://files.pythonhosted.org/packages/bd/47/1b318fb249d5fa3dcb0375ad284d34155f0da4a2fe92c8f01edef0cb0258/regex-2026.9.3-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3cc1a82779315f7b2a4642d5028b39057838cd4c0415744d4e53c8b512352141", size = 773578, upload-time = "2026-09-01T00:50:12.125Z" }, + { url = "https://files.pythonhosted.org/packages/a6/16/63f2644a0a3e92623f83ccadd04873916f5b650e2028bc44ee9df104a839/regex-2026.9.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:c0ea77435b1d5a27cccf27f8762f50e73fd2d94e8e412a8e5cdedb650b36d5fc", size = 783915, upload-time = "2026-09-01T00:50:14.081Z" }, + { url = "https://files.pythonhosted.org/packages/ca/f2/f078963d1dbd3632f6e25f7d972cc9a9332649ed239995bfeb403cf88a3b/regex-2026.9.3-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:6c997a1703401089bc02d731e360127428fb4ecdf6524268e8975882ff02528b", size = 854924, upload-time = "2026-09-01T00:50:15.826Z" }, + { url = "https://files.pythonhosted.org/packages/53/46/457ac94a2a2aaa2ab5c076324dfd7e38e76f36d4d78923c4ddb8c3d93d75/regex-2026.9.3-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:70082b2a8f099b8bf660b553b22a4b8ffd34fcc09ef154fc6b9c7108518fc124", size = 763172, upload-time = "2026-09-01T00:50:17.682Z" }, + { url = "https://files.pythonhosted.org/packages/66/1c/db145a6ad935cdc6c694381543d53e6e7d7212287d4f8885f965e91ea4a4/regex-2026.9.3-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:f5e8a0ce681ddabf6a35d7b817d74a94ab237ae7233a5b97118db0b4e524473f", size = 844983, upload-time = "2026-09-01T00:50:19.572Z" }, + { url = "https://files.pythonhosted.org/packages/76/00/100346c5cc2384a7ce0adfb7dbb11f4a865c76e3a920fe68542042da66ea/regex-2026.9.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:3367d5eefae493ac2a1586ec11cc8213c3305528ed3f8e19d5c3871cc01da6ce", size = 789532, upload-time = "2026-09-01T00:50:21.142Z" }, + { url = "https://files.pythonhosted.org/packages/39/62/d878c1d3eed2768f19e8b6fa4aa81b0a0e6bc23fa34e64173ef48816844a/regex-2026.9.3-cp311-cp311-win32.whl", hash = "sha256:33d3a772ff62c882a5d1402045e17c0199f33b9b173139071c4203e7e0292420", size = 266766, upload-time = "2026-09-01T00:50:22.863Z" }, + { url = "https://files.pythonhosted.org/packages/e5/da/6a0ac27bacb39aca3452cdd7d1bfc361608ad000cea3e1b0d7dbaa1e2b15/regex-2026.9.3-cp311-cp311-win_amd64.whl", hash = "sha256:8c8a63d55cdf3c716225a2f8741a1df7a52b5fa98ac7530165c9cc9b32feabcc", size = 278007, upload-time = "2026-09-01T00:50:24.597Z" }, + { url = "https://files.pythonhosted.org/packages/d8/a2/b23997814f48f823bcda615764b4fb00d72a5a06bdbb41cafa895ec62428/regex-2026.9.3-cp311-cp311-win_arm64.whl", hash = "sha256:cb6374a84f11a6b25e63aa69ee2d015286048c1efee93c4a3b5b8df62da79ff8", size = 276960, upload-time = "2026-09-01T00:50:26.101Z" }, + { url = "https://files.pythonhosted.org/packages/da/cb/cba530bc3b068fc337f8f455c63ef5ee91a4eb4c76ecf5998e5cef5aaa6b/regex-2026.9.3-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:5db80d0b1c8238940b5957dd66b5c818ea40a221f6652fb717c027a562d09c77", size = 496699, upload-time = "2026-09-01T00:50:27.98Z" }, + { url = "https://files.pythonhosted.org/packages/81/39/f2e9fb6bbbc80f8bf67ad79d7e2e8866f7837d7c24c692f7faf8f1272e7e/regex-2026.9.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:35d48ce3dee087b63b15cd0a7a3110d0a76c29edbe1f2ad0520b8c4adb7cb596", size = 297018, upload-time = "2026-09-01T00:50:29.487Z" }, + { url = "https://files.pythonhosted.org/packages/a1/b6/c16ee58840baf7659def27ef6f62f3d9a9909670d3c1b4b98bb8b8ee47e2/regex-2026.9.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1f22e0d21ae7016c77175c139a7fca465b988efc1280df4816c79752068d9e2e", size = 292008, upload-time = "2026-09-01T00:50:30.929Z" }, + { url = "https://files.pythonhosted.org/packages/cb/b4/4987bf0f17604669b4ea5aef219886d0a73188c4716ff3a7d275d4d15c15/regex-2026.9.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:233662cf8cfdfe3c0e58aa8f7bbefc579b5be0ac34546f123c159804179e8687", size = 796101, upload-time = "2026-09-01T00:50:32.486Z" }, + { url = "https://files.pythonhosted.org/packages/0b/95/2a9ab02a68c8a61dc0b4882ed643b1a95740d9dc291dc26c77d19af79691/regex-2026.9.3-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7d2eed2e4d231278a2ccab3f4bfa2c1e39855f336475f7756a281d767d2b1753", size = 865435, upload-time = "2026-09-01T00:50:34.171Z" }, + { url = "https://files.pythonhosted.org/packages/04/92/0570d41559b446c97c1148cb9ebc1df09f2949b03c7c9bfee09976b3465f/regex-2026.9.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5e674cecb61cb160be392da07fd8a71509ef927f437fbf3215432692ed385151", size = 911828, upload-time = "2026-09-01T00:50:35.72Z" }, + { url = "https://files.pythonhosted.org/packages/4b/8b/9cc6d4123033f7cb82df6cd8ce19eb0fc18a964afe060a03c9b26757c9f3/regex-2026.9.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:665207e41bacd435db001099eeab44103197c2c1a729d73ade74688a905ed4ce", size = 801965, upload-time = "2026-09-01T00:50:37.701Z" }, + { url = "https://files.pythonhosted.org/packages/c9/98/39262e91aa87a67c82cbe90a0df4c3d382c7a44811fe80067904085211b4/regex-2026.9.3-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:7a7ddc9a8ca1795166a1ca80364b8ce74187fc210e112d3fb048b711b934f36c", size = 776192, upload-time = "2026-09-01T00:50:39.57Z" }, + { url = "https://files.pythonhosted.org/packages/24/e9/3bb93fe4ee4b6f8ce7ba69b527c4a63cfa3393fc425ab26486041fe441c8/regex-2026.9.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e3037d02425863ce9501afbaa04ba967162810004bacde39a53ea9a5b740eb32", size = 785053, upload-time = "2026-09-01T00:50:41.156Z" }, + { url = "https://files.pythonhosted.org/packages/f9/05/31d5bc2553a700c0dfc6b5b6a13c61cdcd1210fde1e304cfa18a33f138b2/regex-2026.9.3-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:3de4eab8c763393b75bbb26f81934ab2cc8794f48f79e90622e3ab7ea57f3d14", size = 860546, upload-time = "2026-09-01T00:50:42.746Z" }, + { url = "https://files.pythonhosted.org/packages/65/a3/2e1e854d80becda0f061093805bbfc037a5849448f46d0a2b71a070d45e2/regex-2026.9.3-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:98620c9c4c22568ad70f57b80527c780b6f8fd26e36507bf8e2273262a228275", size = 765841, upload-time = "2026-09-01T00:50:44.5Z" }, + { url = "https://files.pythonhosted.org/packages/6a/d6/43d02948cedde2e8476ac893ea02755ee5ee1b21c531fda92d80e114f0bc/regex-2026.9.3-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:0b1ba3aaaf5776de473ee16625ac60ac195abb0343afb273575a8201d99be089", size = 852147, upload-time = "2026-09-01T00:50:46.474Z" }, + { url = "https://files.pythonhosted.org/packages/21/ff/adb4e2d08afe8f4c6df004d94604257e1f72af7ba328af7715601585aba4/regex-2026.9.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:56d8659c65166641d8f1b5efccc391c62c8a899eff4d528b981cc62b7b402a4b", size = 789761, upload-time = "2026-09-01T00:50:48.749Z" }, + { url = "https://files.pythonhosted.org/packages/c3/e1/1490d1351758e87f6e702cf2025036bdc7bc59182e2ff5c7bec004b19aed/regex-2026.9.3-cp312-cp312-win32.whl", hash = "sha256:837c1859913798d8bebcd98d4a037e113f8d79e81733009bf590e449769eecb3", size = 267150, upload-time = "2026-09-01T00:50:50.414Z" }, + { url = "https://files.pythonhosted.org/packages/d5/49/4c40cf722d84d60e807a08ef4c3f579216bf97df60c4a1b10be49655d302/regex-2026.9.3-cp312-cp312-win_amd64.whl", hash = "sha256:1ba1dbbb93c5c5629c1861763aec5bfa9f05ad24ef450694130e25029ce7bc36", size = 277773, upload-time = "2026-09-01T00:50:51.963Z" }, + { url = "https://files.pythonhosted.org/packages/aa/af/c48b3b2b4244b4b090554c78d3387e9ae7b859f3dbf7148a27d427e9e5b8/regex-2026.9.3-cp312-cp312-win_arm64.whl", hash = "sha256:d7b3a8a4bbd83ad8b29758f5d24bab10a3f2de87970db36f1e3651c733353136", size = 277122, upload-time = "2026-09-01T00:50:53.778Z" }, + { url = "https://files.pythonhosted.org/packages/9b/d8/1fb6053247efc5b5a1d7b3b7881dcf42861f8ba46bd72a2ff126469d4053/regex-2026.9.3-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:1d9148e47cfa1a067138867996b1d5d825de0132fed8dac3c92eebaaf312d280", size = 496442, upload-time = "2026-09-01T00:50:55.351Z" }, + { url = "https://files.pythonhosted.org/packages/5b/b7/0b9c1c0385365ad12deba0bdf93a70ad9f97d1a919cc5699c33b449ad662/regex-2026.9.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:33c2860b73ea342c0a42bee9ebe3b3a0de3d68c580c4dcb52241cf4b6663731b", size = 296913, upload-time = "2026-09-01T00:50:57.251Z" }, + { url = "https://files.pythonhosted.org/packages/e6/eb/5750ebabdb010ffb0d31fceae68c7a8f3876c06140c3bd6a7feff6240d6d/regex-2026.9.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:e33dfc13c02d9c4e55bcf3f3b2eb448537823a6f6f30bf737b2974b63a530bc9", size = 291783, upload-time = "2026-09-01T00:50:58.892Z" }, + { url = "https://files.pythonhosted.org/packages/96/12/3ee1542b6428a0955ac5a31562d87966a417c0e0a4c1e5c62ec822fe78de/regex-2026.9.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:48e84252a16234ee860206a738f9a5084f830a5d0a1370a418d3af4e917f5e08", size = 796114, upload-time = "2026-09-01T00:51:00.5Z" }, + { url = "https://files.pythonhosted.org/packages/0a/24/5ad415b80958d79f2da66a1997743ea8c38a1e9e2f63660f7cbf9303eda4/regex-2026.9.3-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:3077ace9bf59f8513c8471a817a5af63699987dc024f535c1eac3447a4d70211", size = 865524, upload-time = "2026-09-01T00:51:02.25Z" }, + { url = "https://files.pythonhosted.org/packages/2b/8a/c298d469f5dd12b11d4e7b8c7714c808b9edace73118eaf753fc327c9429/regex-2026.9.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:635482cd183a1856da75a39c473a2e222697b7927f1955f586db83fc8a5da17c", size = 911948, upload-time = "2026-09-01T00:51:04.099Z" }, + { url = "https://files.pythonhosted.org/packages/3f/a6/e9a59b507cdf7a9735df4bab92b4ea9d2ca2e665c6de14c112db7e3c0926/regex-2026.9.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:27f0809798071f56fb1bc536bb93714a95e8ed2ec0dfd869f095deebb30fd11a", size = 801945, upload-time = "2026-09-01T00:51:05.878Z" }, + { url = "https://files.pythonhosted.org/packages/56/1d/443e5541fd23d97c841ccddf90dbc9a964bd00e0ec9219b45a3eb0cde552/regex-2026.9.3-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d514026ca1c473cc14440e4d7bdf6721c642455b647a74c8143c0f22da358c28", size = 776223, upload-time = "2026-09-01T00:51:07.58Z" }, + { url = "https://files.pythonhosted.org/packages/7e/ae/78d48b14582f5733facaa2e001499b98707d8b8b1b31ab7559053c18f168/regex-2026.9.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:b9190d4901d7786af9ab0ec46172e27cf7d72cdba2b82ee38eb40aadd3239a6e", size = 785072, upload-time = "2026-09-01T00:51:09.648Z" }, + { url = "https://files.pythonhosted.org/packages/55/42/2f4ac830de12d264c1486f749988003a7f5a0366d7557a75de2418461466/regex-2026.9.3-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:6c0f60b05cc708e6cdf68dbca86b7a36d99695962db0189bb1b3884ca3b28e90", size = 860644, upload-time = "2026-09-01T00:51:11.558Z" }, + { url = "https://files.pythonhosted.org/packages/47/50/6b44c6cf56f353744e6066a1310177b7b195afb11d33dff4d6cf3ec52720/regex-2026.9.3-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:b7b7e6be82fd6d5256adabb82253c5c307de981cc20c0ce4cff0cbe6de88529b", size = 765862, upload-time = "2026-09-01T00:51:13.371Z" }, + { url = "https://files.pythonhosted.org/packages/64/0f/c5a8023dfc988cddd2c614b1afbe547aedab1ffebd5b5d9cd58f6ab28908/regex-2026.9.3-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:b5f85bffdfe17da7dfff78eb32b261c27f3cd64c060033645079493f4cebc8e9", size = 852081, upload-time = "2026-09-01T00:51:15.324Z" }, + { url = "https://files.pythonhosted.org/packages/8f/f4/ab0ba467ebcaecfddf72ea7b3527a6088863094377c1303a3379284ef621/regex-2026.9.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:d10a442c6450ebd35aa89392b8e4b0459ba474df63fc5e6828573d0a31a627ec", size = 789774, upload-time = "2026-09-01T00:51:17.057Z" }, + { url = "https://files.pythonhosted.org/packages/4e/fa/8e2f3021ff5ee3aafc80eed8f16663be5e16c7b663d72e4bd2c9e71e1433/regex-2026.9.3-cp313-cp313-win32.whl", hash = "sha256:63fa79eab192623acb169de1dfe8e733598c4047d06f7712347d1bb810a5ad20", size = 267125, upload-time = "2026-09-01T00:51:18.837Z" }, + { url = "https://files.pythonhosted.org/packages/6d/25/6d20a309c2e4b554cc33579dd55b0bb50d0c2ace7ce6f084be2327c330fc/regex-2026.9.3-cp313-cp313-win_amd64.whl", hash = "sha256:185c1ae881856208dda05708b6c908aff76878e59c998c8548d365c1bbcaf1bd", size = 277741, upload-time = "2026-09-01T00:51:20.583Z" }, + { url = "https://files.pythonhosted.org/packages/cc/b3/0282ae58fc167953809a968850622f89955e0fd70a65df882e5d488138b0/regex-2026.9.3-cp313-cp313-win_arm64.whl", hash = "sha256:db6538d733047f9ce4b74ee29c77643a1f99e4ca36e273495da93fbeedd2f03f", size = 277123, upload-time = "2026-09-01T00:51:22.332Z" }, + { url = "https://files.pythonhosted.org/packages/c6/a0/322f050f77289a1acf99b5c400fe201780bdcfa8f8876fbe250ae3de37af/regex-2026.9.3-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:99896cc18fb421be93e337d6bf2c1686ba330bc2d5c0ef581c842f0639a5e886", size = 496701, upload-time = "2026-09-01T00:51:24.146Z" }, + { url = "https://files.pythonhosted.org/packages/91/30/85df182aec58aaa34b02a3f0a99068bf34a7c9b3f9bd7ff06d58aa866e1d/regex-2026.9.3-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:0540de6e7917f89acaf9771bdcd6fa7e505c67416d3b283e52ad4ab25399c6d6", size = 297055, upload-time = "2026-09-01T00:51:25.812Z" }, + { url = "https://files.pythonhosted.org/packages/27/8f/64b8bbd0316baaede047dbdbf2bcc96f10a4eeddec2e9cbf289e855e636f/regex-2026.9.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:647983d2609be6155c748249e770ab7e75e15e386cbf15469569f3eaf165bbb7", size = 292008, upload-time = "2026-09-01T00:51:27.415Z" }, + { url = "https://files.pythonhosted.org/packages/b8/87/224614ef16bc8336269a84b578fb0dbab1433b584aaefc5f0680cacf9227/regex-2026.9.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7bb75921a4885d30d9e881d7a595ce50407a8a82933e15451ad7e0d89d1a5944", size = 796341, upload-time = "2026-09-01T00:51:29.344Z" }, + { url = "https://files.pythonhosted.org/packages/4a/e1/10ad988d3b673db86353666c56cb32e1b6246ca1ab0c81018a58ebec889c/regex-2026.9.3-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f93c60d8c522b4ecea35dd6c58cc42f251ecb12882a5d67d4bd8d12137fbd05b", size = 866311, upload-time = "2026-09-01T00:51:31.592Z" }, + { url = "https://files.pythonhosted.org/packages/08/16/8d597f97bb6215876512cd7b3c47179c0eb79d1820ab2ed8412d3ba5599a/regex-2026.9.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:9e61478a8a06e6456ff2e66b9ac18f7f28d76a75fa5fda0c5198a4de07b8dcb8", size = 911869, upload-time = "2026-09-01T00:51:33.926Z" }, + { url = "https://files.pythonhosted.org/packages/89/e3/f6bcb26472873b9308df329f507d9c6cb526e3f9aed847498f153f2b7539/regex-2026.9.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6f64c66b3b13758b4f8f56f17972cd0ce5d0033d19d7332ed32e2dbdbce94dec", size = 801375, upload-time = "2026-09-01T00:51:35.779Z" }, + { url = "https://files.pythonhosted.org/packages/bc/a5/38c7cd736bfd58b190412dbf5a81aae1c38456c538d5c4987f5980cbfa3d/regex-2026.9.3-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:6b5dc780377e35be6b0cf6fec7fb4a45cadb1e834bc0ef2ce596cc015290ef69", size = 776522, upload-time = "2026-09-01T00:51:37.81Z" }, + { url = "https://files.pythonhosted.org/packages/a9/ac/8ecefa1c9b57b29fcbe963797435e69a3ba6a9773d802b3d4fca4c75ecf6/regex-2026.9.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:f02091b425bbcc2d8481913855c744baa4dd73e334814337b201d837e9040ef7", size = 785727, upload-time = "2026-09-01T00:51:39.995Z" }, + { url = "https://files.pythonhosted.org/packages/5a/4c/af402c5aa95615ab66620d775de07ea09b0fea206cd79e3c8a5716d5fc96/regex-2026.9.3-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:ad2027883344e70ddddff02259411f80faf47d5e779eb0e39cb95ee546fa628c", size = 861375, upload-time = "2026-09-01T00:51:41.829Z" }, + { url = "https://files.pythonhosted.org/packages/dd/7b/b83dd26470fa4cc6d7beee9b3c52ff0e988ba636c1367a04d4b2829d8d95/regex-2026.9.3-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:0edd12c8201222f58817689dc61fe44893f3f2f2aee530b211dfa92af84df9cc", size = 766221, upload-time = "2026-09-01T00:51:44.7Z" }, + { url = "https://files.pythonhosted.org/packages/94/5b/3b91b19d8fb11a353738cec56b19440bf181f3f9a0298d91140fb4061778/regex-2026.9.3-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:4a9cd8485a6729387c889c88c24d5eace39dc0c0c9ddb9003f9c81751f654b69", size = 851737, upload-time = "2026-09-01T00:51:46.708Z" }, + { url = "https://files.pythonhosted.org/packages/2e/be/ea0762fd8a12fa711f1a626283f6d79a3d8a81df4eaada4fbe82009e46f6/regex-2026.9.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:994fa00a9b0d14c6e6926ff5ade98d4d83676a5eeab6f87718170e481396d380", size = 789455, upload-time = "2026-09-01T00:51:49.2Z" }, + { url = "https://files.pythonhosted.org/packages/d1/dd/b9af9d65de78831fb76cb8ef420db4094295b09f93f8abd17c867261c4fb/regex-2026.9.3-cp314-cp314-win32.whl", hash = "sha256:4f39485bb02dae23e14cdbad086ab0e468756775bc5c64bb69e7cb756ebc1dcd", size = 272528, upload-time = "2026-09-01T00:51:51.416Z" }, + { url = "https://files.pythonhosted.org/packages/d0/fe/ecb15616ae7aa4892299b9ca7c20ef0dd6e5c833643b7ed46e27ff5fcccd/regex-2026.9.3-cp314-cp314-win_amd64.whl", hash = "sha256:445623b1337e971ccc571d3642aeb3f2fec77e60b6ee193dd7688168471d1846", size = 280812, upload-time = "2026-09-01T00:51:53.211Z" }, + { url = "https://files.pythonhosted.org/packages/18/4f/60efc748152c82b967bd186c356dd1fc21c4f6c225b8026b52547ae60c9f/regex-2026.9.3-cp314-cp314-win_arm64.whl", hash = "sha256:9887e9455398a1517294dec14e23ed9a178c8dd909f2788e971b66623d3f7c16", size = 281095, upload-time = "2026-09-01T00:51:55.052Z" }, + { url = "https://files.pythonhosted.org/packages/d2/cc/aa269583e8986be9604ef5fb9e2164f33108f6220c896efff2dfb0d4e4c4/regex-2026.9.3-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:c1fa3f84cee5211a3e574ba76ac9596df8c8d16a855f31a25681d23eadcc6c16", size = 501014, upload-time = "2026-09-01T00:51:56.902Z" }, + { url = "https://files.pythonhosted.org/packages/22/51/bb8a3f3a47beccbf92c3bcda67c2c0336c13c2e10f9744306275f428ebc9/regex-2026.9.3-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:d539a51be176e874ed66029b2df8cb8e1123a3e6420d52a690de6effded4f20d", size = 299376, upload-time = "2026-09-01T00:51:59.121Z" }, + { url = "https://files.pythonhosted.org/packages/48/ec/c646df2b62c1b1334e28581715ed776814c8ac80c0c9106175f0c61ce12a/regex-2026.9.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:5133884ec10c9d6bcf7fed4ceb98fb3a6acbb6c2ba1bab6c4b6700d6c39c7595", size = 294424, upload-time = "2026-09-01T00:52:01.113Z" }, + { url = "https://files.pythonhosted.org/packages/d2/18/3dd8c49cc4af440a9a1a0ebb2b4a939398398c81fb7fecbc3c7d534924a1/regex-2026.9.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5fecba510f6b8f9cf1dfd103d785a61da47221cf09d4cec10946d1950daf1a17", size = 811421, upload-time = "2026-09-01T00:52:03.289Z" }, + { url = "https://files.pythonhosted.org/packages/71/32/c35f031aec040b9136189e3f403681e3168f1f9862e31d9df92ea599f2c1/regex-2026.9.3-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:72df83ee0eb89b070e28d1260786d13485b98a8b80228c7439d303dd9aac9970", size = 870110, upload-time = "2026-09-01T00:52:05.746Z" }, + { url = "https://files.pythonhosted.org/packages/a7/7b/931d962f9fbca3326f282a01fa5bed4d6734dab5215d1c20bac0ab85df58/regex-2026.9.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:610371fe95c7e8e824ad8762248836cabbb5a4ab8befb982cb7dc8df773075d3", size = 917489, upload-time = "2026-09-01T00:52:07.703Z" }, + { url = "https://files.pythonhosted.org/packages/46/1a/da0c28f2b1e65d46a24abc1dd33e0dc9ddbcfeeee7c5625103b3e09e548c/regex-2026.9.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:af06c9099df15ee44fda3fdfa002bfe37de02901c2b3a5ef350853861ef3b4b5", size = 817470, upload-time = "2026-09-01T00:52:09.686Z" }, + { url = "https://files.pythonhosted.org/packages/d4/a1/6a540ec40c3b8eeefec445362cf08bbb686b22d4088f97d3c1ea38323434/regex-2026.9.3-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e27003c0a93a5aa541c260bd8ba8b917a2af4c378eb684daa9f1565f5e363181", size = 784742, upload-time = "2026-09-01T00:52:11.778Z" }, + { url = "https://files.pythonhosted.org/packages/fc/88/75500ca27ba85256eb46119ebd99ec10ead4c3ffacd47fe7dfe034662960/regex-2026.9.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:9ce34fc5a6f6c9b2ba4a8060009d989e4f55630e3f9c3bf5962f42dcc31355ef", size = 800609, upload-time = "2026-09-01T00:52:13.817Z" }, + { url = "https://files.pythonhosted.org/packages/67/33/18541aaad8b88977e2c3fbbb53c1a75f6f6c999800a82d2f7306581cb6b6/regex-2026.9.3-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:2cbc83154c8b0201ada07bc5d6e37106df6325f2fda60d73228e2e8da7433cae", size = 864798, upload-time = "2026-09-01T00:52:16.137Z" }, + { url = "https://files.pythonhosted.org/packages/16/62/ffbfbeb5a3f2cca701afb9f8aebbfcbf37a4aae2f1584c96680142aab445/regex-2026.9.3-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:f568bdc17b7ebb3a323ee8920468d2ed74af84da911a00d9585ac887bac73b88", size = 772892, upload-time = "2026-09-01T00:52:18.567Z" }, + { url = "https://files.pythonhosted.org/packages/23/14/04e2db28f490b1fcc684428bd2de21e1ec46f7d8d421b7f2cc74d120affd/regex-2026.9.3-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:ae9f7055e7357b2873866a3d77d0136a251ca2ae2dde3d8cdb819425d717c177", size = 858065, upload-time = "2026-09-01T00:52:20.674Z" }, + { url = "https://files.pythonhosted.org/packages/ac/14/c0cac930d1dc0b86c5d8ff10602f15df4fb15fa3f33e04a98be197f33618/regex-2026.9.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:d963442186918577ad83e3a8c5564eeeba90e2da233ce59f6eeccbb7b5cf771e", size = 804739, upload-time = "2026-09-01T00:52:22.866Z" }, + { url = "https://files.pythonhosted.org/packages/01/12/69e6f4d02e11a5cb45033abede6e04b0da3716b1b6c311d4609be14a01a7/regex-2026.9.3-cp314-cp314t-win32.whl", hash = "sha256:bda6af6fb4d5fe9532620e4f72d3c7efcdf7472ead9037b184c0a060f0e7c71f", size = 274514, upload-time = "2026-09-01T00:52:25.224Z" }, + { url = "https://files.pythonhosted.org/packages/28/64/064b78028b52c0c21b9c0b362b1bdcee7179f009891ddf959d9b6390b30c/regex-2026.9.3-cp314-cp314t-win_amd64.whl", hash = "sha256:2d25e41851e41539898116ac760fcc856e2c1047a843a336b19e2c8e4a43ad16", size = 283797, upload-time = "2026-09-01T00:52:27.358Z" }, + { url = "https://files.pythonhosted.org/packages/f2/46/fbb41eb6cc92403ba9f896dfd56a1d5d31549c4033dfb7418da7ecd5802a/regex-2026.9.3-cp314-cp314t-win_arm64.whl", hash = "sha256:356fc21b4c313decb3214a4306bb5bd0623dce4a8d03d0d5ada6fb0b6a5b93b5", size = 283444, upload-time = "2026-09-01T00:52:29.632Z" }, + { url = "https://files.pythonhosted.org/packages/1b/1a/825beb1c803d579d1119723235ede2211949a8d320bcc79e3f6e5dd6090f/regex-2026.9.3-cp315-cp315-macosx_10_15_universal2.whl", hash = "sha256:e337dceb936f333775cf51d49f6badb8cd3d2a6b27e8cb443a6c5861fbf3c1f9", size = 496929, upload-time = "2026-09-01T00:52:31.593Z" }, + { url = "https://files.pythonhosted.org/packages/ff/54/9b8255521680d54e1d157ed6532e3082998f47925d2ab3861550e0e89455/regex-2026.9.3-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:bb2d4ad7f9bac398a7a19f07bd09fd5b2c1e4eeab316065aa84a305f62fc5361", size = 297050, upload-time = "2026-09-01T00:52:33.459Z" }, + { url = "https://files.pythonhosted.org/packages/5c/8b/0e4df28fd94304050efc2373dff1803e5d62056cf744a694eaa376df2fe8/regex-2026.9.3-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:01bdce6a372efd5ae3d8560cedbc691be259a50206564bbaf04008b2937721ab", size = 292296, upload-time = "2026-09-01T00:52:35.309Z" }, + { url = "https://files.pythonhosted.org/packages/97/a0/689a8403f309a7a3f3f3e74b3e81b144602481d122c9e4070a601367f8e0/regex-2026.9.3-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:55493b5b6cb6c4ec9a3c310d4ef947dbd34326ee4eecd4249e18e00d84f14be5", size = 798376, upload-time = "2026-09-01T00:52:37.235Z" }, + { url = "https://files.pythonhosted.org/packages/ad/a9/3d22278a38bb8adb254d345e60935316222091caf00a4233aaef388d636e/regex-2026.9.3-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:690ab9d06cd689b79aab84afa0984a1bc85ea4b93b0a42b015f3ff5e2f5b08be", size = 866607, upload-time = "2026-09-01T00:52:39.461Z" }, + { url = "https://files.pythonhosted.org/packages/69/ef/ecf8c5fdcec73ac0526fbd074be3bd1059b11cbda739ac0ab9001f311aed/regex-2026.9.3-cp315-cp315-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:24b4bbb65ff2c4e8c552c93c342bf5ffa0ad162d963d96bac7c1883c20e1b34e", size = 912160, upload-time = "2026-09-01T00:52:41.603Z" }, + { url = "https://files.pythonhosted.org/packages/68/e8/c07c3d2b44c9154672a33911cfcfba626c78d939d7e31103864d81ad319a/regex-2026.9.3-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fbaf76379bf2a72e534bbb1276d45e63a80d8cade17953ed79a350d6426262fb", size = 804589, upload-time = "2026-09-01T00:52:43.658Z" }, + { url = "https://files.pythonhosted.org/packages/91/16/d42957c78b5934efd03ca5713d99952cbe71e2d0b3b24d9e78256f208587/regex-2026.9.3-cp315-cp315-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:57f405fcb82e2b78df88f04f8aa49ce513ce23bfea073b581597bd52545e9b3f", size = 784446, upload-time = "2026-09-01T00:52:45.866Z" }, + { url = "https://files.pythonhosted.org/packages/00/1e/4252dff33a1a5afb3271fb3859e992d34c47c040ecfc27bbfe6a7eaf99a8/regex-2026.9.3-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:a87ab35e92d40b53c5373af36625794e422f83ec56122f0a63871892856d721c", size = 787996, upload-time = "2026-09-01T00:52:48.345Z" }, + { url = "https://files.pythonhosted.org/packages/ee/19/90d31048bb402fd746a95922d7dfdb9de9f902c39c8d838f2fef05c9c92c/regex-2026.9.3-cp315-cp315-musllinux_1_2_ppc64le.whl", hash = "sha256:14bf4a88833c12a990dbf5cca77eb293401d60878be7d566a2d5096fb0216c27", size = 861752, upload-time = "2026-09-01T00:52:50.597Z" }, + { url = "https://files.pythonhosted.org/packages/88/77/42ad133550cbd64d8fb33ec5ff55e1f524b06c6328e9f3bf9c3e8652b525/regex-2026.9.3-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:862c29f7e7927e71391df6700079b1dd7c2aeb75115dc46e37004a092f8f16b7", size = 773488, upload-time = "2026-09-01T00:52:53.142Z" }, + { url = "https://files.pythonhosted.org/packages/78/8f/0c90e8fa607c36a65c360f6b02980aa7aa5885afa3d737daba4229bef086/regex-2026.9.3-cp315-cp315-musllinux_1_2_s390x.whl", hash = "sha256:61a9da95a836e7d300945891265bbeb6510a860863f6b01ed6397e6239a31253", size = 852603, upload-time = "2026-09-01T00:52:55.471Z" }, + { url = "https://files.pythonhosted.org/packages/4e/bc/e1be309afb6be94916d8f4f000dbc66040fc0da2008b3f714dc4893259fd/regex-2026.9.3-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:e7663a6803a47255c32cc7e17ae3ccfe02dba5b0849f87729651c0263a129d20", size = 794635, upload-time = "2026-09-01T00:52:57.611Z" }, + { url = "https://files.pythonhosted.org/packages/0e/f7/15f6d0ea137316531c992e7468a4c6f6e39159a6780c2c16ec3ab56f2149/regex-2026.9.3-cp315-cp315-win32.whl", hash = "sha256:0ee4721472e00e96b3cceec545c9867f91815f628f6ea304ae6cea93a7e4e7ae", size = 272530, upload-time = "2026-09-01T00:52:59.644Z" }, + { url = "https://files.pythonhosted.org/packages/ba/8e/739168818790278dd4f1ba60c582fed41323508d7a8e850323851de1aa1f/regex-2026.9.3-cp315-cp315-win_amd64.whl", hash = "sha256:cc5d0f82cf05beb6c0d463398173a09357ed4f4a631f7641cef6f6480a05bc57", size = 280822, upload-time = "2026-09-01T00:53:02.57Z" }, + { url = "https://files.pythonhosted.org/packages/12/6a/55f5f6e92a8c7d6511e069d3e8a4b45e3506941c1a97dddf5a329b132be4/regex-2026.9.3-cp315-cp315-win_arm64.whl", hash = "sha256:6f198b622a3ccf02eeab00de71f6b2f45b1b50b1979aa56b25178c963e475950", size = 281102, upload-time = "2026-09-01T00:53:04.62Z" }, + { url = "https://files.pythonhosted.org/packages/ff/6a/adaf9ed10ffdef60684bf8757c257400500342503f1ce5c7cffcdb2e8aaf/regex-2026.9.3-cp315-cp315t-macosx_10_15_universal2.whl", hash = "sha256:294ef8fb58a45f912513692380f366ca191940de5b3b3de5308ce2e8500d8ea4", size = 501333, upload-time = "2026-09-01T00:53:06.681Z" }, + { url = "https://files.pythonhosted.org/packages/64/dd/2cbc3b253a88fdb0c8ca641367dc2f280541fdf1722f201fc0be62797577/regex-2026.9.3-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:edfd2b0cad175780f8668fd6f66486354b8770e4057e44038daaa4a066f8ddff", size = 299273, upload-time = "2026-09-01T00:53:09.002Z" }, + { url = "https://files.pythonhosted.org/packages/2a/29/4818d31ec2555309b3935d3cd006a7f6076e11bb21eec9e72afee3db87b1/regex-2026.9.3-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:cda393bb35828e3993fcaf39c8ede78b16614954eb15fe77336d5d141be40f76", size = 294888, upload-time = "2026-09-01T00:53:11.009Z" }, + { url = "https://files.pythonhosted.org/packages/94/37/8970a4102a067e0a28e40a232bf536752c373da8a4f932755679f77fa9ac/regex-2026.9.3-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:cce8e5243d95068f595155663e3e18b1938b16cf716dce6cf2491ebc08b98d96", size = 813072, upload-time = "2026-09-01T00:53:13.566Z" }, + { url = "https://files.pythonhosted.org/packages/90/1c/2e52f5e9e92b79e324c9807e977fa6f9ab210b41ab5b7356307d5ffb2f4c/regex-2026.9.3-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2a1269856278ae8bc78342bf20191c1f10638d2c22df72364d2fa02d70d49f35", size = 869947, upload-time = "2026-09-01T00:53:15.773Z" }, + { url = "https://files.pythonhosted.org/packages/f6/42/c676e3f2dcb47ec941fa678019044cbac51db9441e09cec47392e4986013/regex-2026.9.3-cp315-cp315t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4ac52b95a938789fcfcfbf6faf647b45d7be940f0c51f06991c1353db54c67aa", size = 915678, upload-time = "2026-09-01T00:53:18.384Z" }, + { url = "https://files.pythonhosted.org/packages/01/6a/73c971bcaf1d24e73aa3c8e0f767caccfdc9fcda021e59f28f6dcd12728b/regex-2026.9.3-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:490a81770599b17b8594227674872dfb215af05f2be0065a32a7c70175fd9e23", size = 817714, upload-time = "2026-09-01T00:53:20.723Z" }, + { url = "https://files.pythonhosted.org/packages/b2/7c/0e9bffb6cfa8a00e765eaea0d1e6d207bb98e620d5658c537c8d87df671c/regex-2026.9.3-cp315-cp315t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f584dd93ef6ddb10ba028e247fe1fc0ba52ed70ca4d596bb8d52bf4304c147ec", size = 792411, upload-time = "2026-09-01T00:53:22.925Z" }, + { url = "https://files.pythonhosted.org/packages/61/d4/b1d226e8a3d0c8aac577a517384ffaea7b9ff98b194ddbd0bef58b9d8738/regex-2026.9.3-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:c07eaf30bc072b179acc8ac50519a2a81f03f88a220750c6d83dadbdc33fb1de", size = 802521, upload-time = "2026-09-01T00:53:25.281Z" }, + { url = "https://files.pythonhosted.org/packages/c6/ad/dc47f94a4ace898561dfafeed6052dd3551915f36aa1971f4387d6daf0d4/regex-2026.9.3-cp315-cp315t-musllinux_1_2_ppc64le.whl", hash = "sha256:9e1c602c55dc8ec05cc7e0a8e31f3ad3d4644dbcb7ac39114105c9bd0384371f", size = 865266, upload-time = "2026-09-01T00:53:27.667Z" }, + { url = "https://files.pythonhosted.org/packages/41/7b/743565fc25cb36981186b4e9b42b3d093a7226cca328380cfd223c1b5a03/regex-2026.9.3-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:2ef9a284ec658d48ec57edfba0944d1582532601472f695b799ba08d37fd6544", size = 780298, upload-time = "2026-09-01T00:53:30.017Z" }, + { url = "https://files.pythonhosted.org/packages/c6/ad/d62e48324632eb0bae2c336da5810b51a14a9e23ba964f2828cc1ac23011/regex-2026.9.3-cp315-cp315t-musllinux_1_2_s390x.whl", hash = "sha256:c90f34f1b1905d7d6c42b25b6ffb4e5066e6c95c7715169e3332b1760614d092", size = 858045, upload-time = "2026-09-01T00:53:32.397Z" }, + { url = "https://files.pythonhosted.org/packages/2e/41/8eff42a2516494bb6b36d33b15bcd861764dcc836ad7c0b746e46c513af9/regex-2026.9.3-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:307dbd844f678de48ea74cdc909b007729c50e6be7f182bdf6a1df6732374c69", size = 805406, upload-time = "2026-09-01T00:53:34.601Z" }, + { url = "https://files.pythonhosted.org/packages/f6/1d/98198fd6dc185a172f5de48b8a4c7ca03c0d4285b1c1c32300672e7cf85a/regex-2026.9.3-cp315-cp315t-win32.whl", hash = "sha256:ce6505846d29f860966e0e9cfadaad1041a7d8ce7dc4af39940fcb1877dec29a", size = 274674, upload-time = "2026-09-01T00:53:36.77Z" }, + { url = "https://files.pythonhosted.org/packages/d2/82/dc0e76842ccddc8756471adff38c140d130c6b601b9ae5724274f1881e7a/regex-2026.9.3-cp315-cp315t-win_amd64.whl", hash = "sha256:2c71da070224baf426850d9eab23ac797d9859b1841dbda43012c01b69697803", size = 283692, upload-time = "2026-09-01T00:53:38.951Z" }, + { url = "https://files.pythonhosted.org/packages/da/3d/e0677f590f3473a3defb63ef6e3469154382a2a15ebafb364482d7ed3b01/regex-2026.9.3-cp315-cp315t-win_arm64.whl", hash = "sha256:ecc27adda0d1e1bc39793b41fdd562d2f4bc4dcee6ee0e3c733d519c332183b2", size = 283421, upload-time = "2026-09-01T00:53:41.393Z" }, +] + +[[package]] +name = "requests" +version = "2.34.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "certifi" }, + { name = "charset-normalizer" }, + { name = "idna" }, + { name = "urllib3" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ac/c3/e2a2b89f2d3e2179abd6d00ebd70bff6273f37fb3e0cc209f48b39d00cbf/requests-2.34.2.tar.gz", hash = "sha256:f288924cae4e29463698d6d60bc6a4da69c89185ad1e0bcc4104f584e960b9ed", size = 142856, upload-time = "2026-05-14T19:25:27.735Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a0/f4/c67b0b3f1b9245e8d266f0f112c500d50e5b4e83cb6f3b71b6528104182a/requests-2.34.2-py3-none-any.whl", hash = "sha256:2a0d60c172f83ac6ab31e4554906c0f3b3588d37b5cb939b1c061f4907e278e0", size = 73075, upload-time = "2026-05-14T19:25:26.443Z" }, +] + +[[package]] +name = "rfc3339-validator" +version = "0.1.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "six" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/28/ea/a9387748e2d111c3c2b275ba970b735e04e15cdb1eb30693b6b5708c4dbd/rfc3339_validator-0.1.4.tar.gz", hash = "sha256:138a2abdf93304ad60530167e51d2dfb9549521a836871b88d7f4695d0022f6b", size = 5513, upload-time = "2021-05-12T16:37:54.178Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7b/44/4e421b96b67b2daff264473f7465db72fbdf36a07e05494f50300cc7b0c6/rfc3339_validator-0.1.4-py2.py3-none-any.whl", hash = "sha256:24f6ec1eda14ef823da9e36ec7113124b39c04d50a4d3d3a3c2859577e7791fa", size = 3490, upload-time = "2021-05-12T16:37:52.536Z" }, +] + +[[package]] +name = "rfc3986-validator" +version = "0.1.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/da/88/f270de456dd7d11dcc808abfa291ecdd3f45ff44e3b549ffa01b126464d0/rfc3986_validator-0.1.1.tar.gz", hash = "sha256:3d44bde7921b3b9ec3ae4e3adca370438eccebc676456449b145d533b240d055", size = 6760, upload-time = "2019-10-28T16:00:19.144Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9e/51/17023c0f8f1869d8806b979a2bffa3f861f26a3f1a66b094288323fba52f/rfc3986_validator-0.1.1-py2.py3-none-any.whl", hash = "sha256:2f235c432ef459970b4306369336b9d5dbdda31b510ca1e327636e01f528bfa9", size = 4242, upload-time = "2019-10-28T16:00:13.976Z" }, +] + +[[package]] +name = "rfc3987-syntax" +version = "1.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "lark" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/2c/06/37c1a5557acf449e8e406a830a05bf885ac47d33270aec454ef78675008d/rfc3987_syntax-1.1.0.tar.gz", hash = "sha256:717a62cbf33cffdd16dfa3a497d81ce48a660ea691b1ddd7be710c22f00b4a0d", size = 14239, upload-time = "2025-07-18T01:05:05.015Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7e/71/44ce230e1b7fadd372515a97e32a83011f906ddded8d03e3c6aafbdedbb7/rfc3987_syntax-1.1.0-py3-none-any.whl", hash = "sha256:6c3d97604e4c5ce9f714898e05401a0445a641cfa276432b0a648c80856f6a3f", size = 8046, upload-time = "2025-07-18T01:05:03.843Z" }, +] + +[[package]] +name = "rich" +version = "15.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markdown-it-py" }, + { name = "pygments" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c0/8f/0722ca900cc807c13a6a0c696dacf35430f72e0ec571c4275d2371fca3e9/rich-15.0.0.tar.gz", hash = "sha256:edd07a4824c6b40189fb7ac9bc4c52536e9780fbbfbddf6f1e2502c31b068c36", size = 230680, upload-time = "2026-04-12T08:24:00.75Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/82/3b/64d4899d73f91ba49a8c18a8ff3f0ea8f1c1d75481760df8c68ef5235bf5/rich-15.0.0-py3-none-any.whl", hash = "sha256:33bd4ef74232fb73fe9279a257718407f169c09b78a87ad3d296f548e27de0bb", size = 310654, upload-time = "2026-04-12T08:24:02.83Z" }, +] + +[[package]] +name = "rpds-py" +version = "2026.6.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/aa/2a/9618a122aeb2a169a28b03889a2995fe297588964333d4a7d67bdf46e147/rpds_py-2026.6.3.tar.gz", hash = "sha256:1cebd1337c242e4ec2293e541f712b2da849b29f48f0c293684b71c0632625d4", size = 64051, upload-time = "2026-06-30T07:17:53.009Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/94/1f/a2dca5ffdbf1d475ffc4e80e4d5d720ff3a00f691795910116960ee12511/rpds_py-2026.6.3-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:7b689145a1485c335569bd056464f3243a29af7ed3871c7be31ad624ba239bc7", size = 342174, upload-time = "2026-06-30T07:14:54.821Z" }, + { url = "https://files.pythonhosted.org/packages/4d/dc/323d08583c0832911768663d1944f0107fcd4088704858d84b5e06d105a0/rpds_py-2026.6.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:db08f45aecde626498fb3df07bcf6d2ec040af42e859a4f5040d79c200342911", size = 345513, upload-time = "2026-06-30T07:14:56.515Z" }, + { url = "https://files.pythonhosted.org/packages/0b/2a/e31989834d18d2f26ec1d2774c5b1eb3331df4ea8ada525175294c94b48a/rpds_py-2026.6.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:acc992ab27b15f852c76755eb2ab7dce86585ddadba6fa5946e58556088845b4", size = 373783, upload-time = "2026-06-30T07:14:57.736Z" }, + { url = "https://files.pythonhosted.org/packages/87/fe/e80107ee3639585c9941c17d6a42cd65325022f656c023191fce78c324c8/rpds_py-2026.6.3-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:7f88d653e7b3b779d71ae7454e20dcc9b6bae903f33c269db9f2be41bda3f261", size = 378316, upload-time = "2026-06-30T07:14:59.077Z" }, + { url = "https://files.pythonhosted.org/packages/22/6f/81e3adf81acfb6fa694de2a6e4e7d8863121e3e0799e0a7725e6cf5679c4/rpds_py-2026.6.3-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e52655eaf81e32593abedaa4bfe33170c8cfedf3365ed9be6e11e07f148f0278", size = 499423, upload-time = "2026-06-30T07:15:00.488Z" }, + { url = "https://files.pythonhosted.org/packages/2d/9a/41263969df0ce3d9af2a96d5005a288200af1989aed3354bfceb5fc0b21f/rpds_py-2026.6.3-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:dfcc8b909769d19db55c7cc9541eb64b9b774b1057ffffb4f1048070475bb9f9", size = 386077, upload-time = "2026-06-30T07:15:01.911Z" }, + { url = "https://files.pythonhosted.org/packages/5e/19/7e98f468bd50346faff5b10e5297374b443bfdddacc8e9fbc65984539597/rpds_py-2026.6.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9c1255b302953c86a486b81d330d5ee1d5bd937691ce271b6be0ef0e299eaab7", size = 371315, upload-time = "2026-06-30T07:15:03.317Z" }, + { url = "https://files.pythonhosted.org/packages/99/3c/2b973b4d371906a134b03decfea7f5d9835a2c6d263454392e15b64b5b18/rpds_py-2026.6.3-cp311-cp311-manylinux_2_31_riscv64.whl", hash = "sha256:8d2294a31386bfa251d8c8a39472beee17db67d4f1a6eabea665d35c9a4461c3", size = 383502, upload-time = "2026-06-30T07:15:04.627Z" }, + { url = "https://files.pythonhosted.org/packages/98/2a/12e2799500af0a307bca76b63361c51f9fe479223561489c29eea1f2ee41/rpds_py-2026.6.3-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:f8f23ead891a3b762f35ab3b04623da7056545b48aa60d59957e6789914545da", size = 402673, upload-time = "2026-06-30T07:15:05.856Z" }, + { url = "https://files.pythonhosted.org/packages/2d/e3/21e5872d165fe08be4f229e3d5ee9d90019c0bf0e5538de60dbd54009450/rpds_py-2026.6.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:421aba32367055614287a4292b6a17f1939c9452299f7a0209c117e990b646d4", size = 549964, upload-time = "2026-06-30T07:15:07.159Z" }, + { url = "https://files.pythonhosted.org/packages/1a/d0/5ee0fe36844297de8123bee27bc12078c1a7416ad9f1b8a8ca18d6b0c0ac/rpds_py-2026.6.3-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:1e5822dfc2f0d4ab7e745eaa6d85945069329beeccef965af3f3bb26058fcab6", size = 615446, upload-time = "2026-06-30T07:15:08.531Z" }, + { url = "https://files.pythonhosted.org/packages/b1/80/1ea5873cb683f2fbe5f21b23ea1f6d179ead19f3c5b249b7eb5dca568ef2/rpds_py-2026.6.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:83e35b57523816c8613fd0776b40cd8bb9f596b37ddd2692eb4a6bb5ab2f8c93", size = 576975, upload-time = "2026-06-30T07:15:09.97Z" }, + { url = "https://files.pythonhosted.org/packages/c9/e1/90ef639217a5ddb15b7f4f61b1c33911fd044ad03c311bafdd2bcab85582/rpds_py-2026.6.3-cp311-cp311-win32.whl", hash = "sha256:de3eceba0b683bcbb1ab93da016d0270df1f9ae7be716b40214c5dafac6ea45a", size = 204453, upload-time = "2026-06-30T07:15:11.324Z" }, + { url = "https://files.pythonhosted.org/packages/f2/b7/b7a1695d7af36f521fb11e80d6d3adbd744f73b921859bd3c2a2c0dc706f/rpds_py-2026.6.3-cp311-cp311-win_amd64.whl", hash = "sha256:2c54a076ca4d370980ab57bc0e31df57bbe8d41340436a90ef8b1219a3cbb127", size = 223219, upload-time = "2026-06-30T07:15:12.476Z" }, + { url = "https://files.pythonhosted.org/packages/d7/a2/145afacf796e4506062825941176ad9445c2dcf2b3b6a1f13d3030a15e19/rpds_py-2026.6.3-cp311-cp311-win_arm64.whl", hash = "sha256:168c733a7112e071bb7a66460e667edfcff06c017a3c523f7a8a8e08d0140804", size = 219137, upload-time = "2026-06-30T07:15:13.631Z" }, + { url = "https://files.pythonhosted.org/packages/5c/be/2e8974163072e7bab7df1a5acd54c4498e75e35d6d18b864d3a9d5dadc92/rpds_py-2026.6.3-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:a0811d33247c3d6128a3001d763f2aa056bb3425204335400ac54f89eec3a0d0", size = 343691, upload-time = "2026-06-30T07:15:14.96Z" }, + { url = "https://files.pythonhosted.org/packages/a4/73/319dfa745dd668efe89309141ded489126461fcecd2b8f3a3cda185129b6/rpds_py-2026.6.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:538949e262e46caa31ac01bdb3c1e8f642622922cacbabbae6a8445d9dc33eaf", size = 338542, upload-time = "2026-06-30T07:15:16.267Z" }, + { url = "https://files.pythonhosted.org/packages/21/63/4239893be1c4d09b709b1a8f6be4188f0870084ff547f46606b8a75f1b03/rpds_py-2026.6.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:55927d532399c2c646100ff7feb48eaa940ad70f42cd68e1328f3ded9f81ca24", size = 368180, upload-time = "2026-06-30T07:15:17.62Z" }, + { url = "https://files.pythonhosted.org/packages/1c/ca/9c5de382225234ceb37b1844ebdb140db12b2a278bb9efe2fcd19f6c82ce/rpds_py-2026.6.3-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f56f1695bc5c0871cbc33dc0130fcf503aab0c57dcc5a6700a4f49eba4f2652e", size = 375067, upload-time = "2026-06-30T07:15:18.952Z" }, + { url = "https://files.pythonhosted.org/packages/87/dc/863f69d1bf04ade34b7fe0d59b9fdf6f0135fe2d7cbca74f1d665589559d/rpds_py-2026.6.3-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:270b293dae9058fc9fcedab50f13cebf46fb8ed1d1d54e0521a9da5d6b211975", size = 490509, upload-time = "2026-06-30T07:15:20.434Z" }, + { url = "https://files.pythonhosted.org/packages/ce/ef/eac16a12048b45ec7c7fa94f2be3438a5f26bf9cc8580b18a1cfd609b7f6/rpds_py-2026.6.3-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:127565fead0a10943b282957bd5447804ff3160ad79f2ad2635e6d249e380680", size = 382754, upload-time = "2026-06-30T07:15:21.831Z" }, + { url = "https://files.pythonhosted.org/packages/04/8f/d2f3f532616be4d06c316ef119683e832bd3d41e112bf3a88f4151c95b17/rpds_py-2026.6.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ecabd69db66de867690f9797f2f8fa27ba501bbc24540cbdbdc649cd15888ba6", size = 366189, upload-time = "2026-06-30T07:15:23.371Z" }, + { url = "https://files.pythonhosted.org/packages/e3/29/41a7b0e98a4b44cd676ab7598419623373eb43b20be68c084935c1a8cf88/rpds_py-2026.6.3-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:58eadac9cd119677b60e1cf8ac4052f35949d71b8a9e5556efccbe82533cf22a", size = 377750, upload-time = "2026-06-30T07:15:24.659Z" }, + { url = "https://files.pythonhosted.org/packages/2e/05/ecda0bec46f9a1565090bcdc941d023f6a25aff85fda28f89f8d19878152/rpds_py-2026.6.3-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:7491ee23305ac3eb59e492b6945881f5cd77a6f731061a3f25b77fd40f9e99a4", size = 395576, upload-time = "2026-06-30T07:15:25.987Z" }, + { url = "https://files.pythonhosted.org/packages/68/a8/6ed52f03ee6cb854ce78785cc9a9a672eb880e83fd7224d471f667d151f1/rpds_py-2026.6.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2c99f7e8ccb3dd6e3e4bfeac657a7b208c9bac8075f4b078c02d7404c34107fa", size = 543807, upload-time = "2026-06-30T07:15:27.356Z" }, + { url = "https://files.pythonhosted.org/packages/8f/d6/156c0d3eea27ba09b92562ba2364ba124c0a061b199e17eac637cd25a5e2/rpds_py-2026.6.3-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:62698275682bf121181861295c9181e789030a2d516071f5b8f3c23c170cd0fc", size = 611187, upload-time = "2026-06-30T07:15:28.931Z" }, + { url = "https://files.pythonhosted.org/packages/f1/31/774212ed989c62f7f310220089f9b0a3fb8f40f5443d1727abd5d9f52bc9/rpds_py-2026.6.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a214c993455f99a89aaeadc9b21241900037adc9d97203e374d75513c5911822", size = 573030, upload-time = "2026-06-30T07:15:30.553Z" }, + { url = "https://files.pythonhosted.org/packages/c9/50/22f73127a41f1ce4f87fe39aadfb9a126345801c274aa93ae88456249327/rpds_py-2026.6.3-cp312-cp312-win32.whl", hash = "sha256:501f9f04a588d6a09179368c57071301445191767c64e4b52a6aa9871f1ef5ed", size = 202185, upload-time = "2026-06-30T07:15:32.027Z" }, + { url = "https://files.pythonhosted.org/packages/04/3a/f0ee4d4dde9d3b69dedf1b5f74e7a40017046d55052d173e418c6a94f960/rpds_py-2026.6.3-cp312-cp312-win_amd64.whl", hash = "sha256:2c958bf94822e9290a40aaf2a822d4bc5c88099093e3948ad6c571eca9272e5f", size = 220394, upload-time = "2026-06-30T07:15:33.359Z" }, + { url = "https://files.pythonhosted.org/packages/f3/83/3382fe37f809b59f02aac04dbc4e765b480b46ee0227ed516e3bdc4d3dfc/rpds_py-2026.6.3-cp312-cp312-win_arm64.whl", hash = "sha256:22bffe6042b9bcb0822bcd1955ec00e245daf17b4344e4ed8e9551b976b63e96", size = 215753, upload-time = "2026-06-30T07:15:34.778Z" }, + { url = "https://files.pythonhosted.org/packages/a4/9e/b818ee580026ec578138e961027a68820c40afeb1ec8f6819b54fb99e196/rpds_py-2026.6.3-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:3cfe765c1da0072636ca06628261e0ea05688e160d5c8a03e0217c3854037223", size = 343012, upload-time = "2026-06-30T07:15:36.005Z" }, + { url = "https://files.pythonhosted.org/packages/f3/6b/686d9dc4359a8f163cfbbf89ee0b4e586431de22fe8248edb63a8cf50d49/rpds_py-2026.6.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f4d78253f6996be4901669ad25319f842f740eccf4d58e3c7f3dd39e6dde1d8f", size = 338203, upload-time = "2026-06-30T07:15:37.462Z" }, + { url = "https://files.pythonhosted.org/packages/9e/9b/069aa329940f8207615e091f5eedbbd40e1e15eac68a0790fd05ccdf796c/rpds_py-2026.6.3-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:54f45a148e28767bf343d33a684693c70e451c6f4c0e9904709a723fafbdfc1f", size = 367984, upload-time = "2026-06-30T07:15:39.008Z" }, + { url = "https://files.pythonhosted.org/packages/14/db/34c203e4becff3703e4d3bc121842c00b8689197f398161203a880052f4e/rpds_py-2026.6.3-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:842e7b070435622248c7a2c44ae53fa1440e073cc3023bc919fed570884097a7", size = 374815, upload-time = "2026-06-30T07:15:40.253Z" }, + { url = "https://files.pythonhosted.org/packages/ee/7d/8071067d2cc453d916ad836e828c943f575e8a44612537759002a1e07381/rpds_py-2026.6.3-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8020133a74bd81b4572dd8e4be028a6b1ebcd70e6726edc3918008c08bee6ee6", size = 490545, upload-time = "2026-06-30T07:15:41.729Z" }, + { url = "https://files.pythonhosted.org/packages/a3/42/da06c5aa8f0484ff07f270787434204d9f4535e2f8c3b51ed402267e63c3/rpds_py-2026.6.3-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cdc7e35386f3847df728fbcb5e887e2d79c19e2fa1eba9e51b6621d23e3243af", size = 382828, upload-time = "2026-06-30T07:15:43.327Z" }, + { url = "https://files.pythonhosted.org/packages/57/d7/fe978efc2ae50abe48eb7464668ea99f53c010c60aeebb7b35ad27f23661/rpds_py-2026.6.3-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:acac386b453c2516111b50985d60ce46e7fadb5ea71ae7b25f4c946935bf27cf", size = 365678, upload-time = "2026-06-30T07:15:44.992Z" }, + { url = "https://files.pythonhosted.org/packages/69/9d/1d8922e1990b2a6eb532b6ff53d3e73d2b3bbffc84116c75826bee73dfc6/rpds_py-2026.6.3-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:425560c6fa0415f27261727bb20bd097568485e5eb0c121f1949417d1c516885", size = 377811, upload-time = "2026-06-30T07:15:46.523Z" }, + { url = "https://files.pythonhosted.org/packages/b1/3d/198dceafb4fb034a6a47347e1b0735d34e0bd4a50be4e898d408ee66cb14/rpds_py-2026.6.3-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:a550fb4950a06dde3beb4721f5ad4b25bf4513784665b0a8522c792e2bd822a4", size = 395382, upload-time = "2026-06-30T07:15:47.955Z" }, + { url = "https://files.pythonhosted.org/packages/1f/f1/13968e49655d40b6b19d8b9140296bbc6f1d86b3f0f6c346cf9f1adddf4b/rpds_py-2026.6.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4f4bca01b63096f606e095734dd56e74e175f94cfbf24ff3d63281cec61f7bb7", size = 543832, upload-time = "2026-06-30T07:15:49.33Z" }, + { url = "https://files.pythonhosted.org/packages/ac/ab/289bcb1b90bd3e40a2900c561fa0e2087345ecbb094f0b870f2345142b7c/rpds_py-2026.6.3-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:ccffae9a092a00deb7efd545fe5e2c33c33b88e7c054337e9a74c179347d0b7d", size = 611011, upload-time = "2026-06-30T07:15:50.847Z" }, + { url = "https://files.pythonhosted.org/packages/1e/16/5043105e679436ccfbc8e5e0dd2d663ed18a8b8113515fd06a5e5d77c83e/rpds_py-2026.6.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:1cf01971c4f2c5553b772a542e4aaf191789cd331bc2cd4ff0e6e65ba49e1e97", size = 572431, upload-time = "2026-06-30T07:15:52.394Z" }, + { url = "https://files.pythonhosted.org/packages/85/ed/adab103321c0a6565d5ae1c2998349bc3ee175b82ccc5ae8fc04cc413075/rpds_py-2026.6.3-cp313-cp313-win32.whl", hash = "sha256:8c3d1e9c15b9d51ca0391e13da1a25a0a4df3c58a37c9dc368e0736cf7f69df0", size = 201710, upload-time = "2026-06-30T07:15:53.894Z" }, + { url = "https://files.pythonhosted.org/packages/7b/ed/a03b09668e74e5dabbf2e211f6468e1820c0552f7b0500082da31841bf7b/rpds_py-2026.6.3-cp313-cp313-win_amd64.whl", hash = "sha256:9250a9a0a6fd4648b3f868da8d91a4c52b5811a62df58e753d50ae4454a36f80", size = 219454, upload-time = "2026-06-30T07:15:55.25Z" }, + { url = "https://files.pythonhosted.org/packages/27/17/b8642c12930b71bc2b25831f6708ccf0f75abcd11883932ec9ce54ba3a78/rpds_py-2026.6.3-cp313-cp313-win_arm64.whl", hash = "sha256:900a67df3fd1660b035a4761c4ce73c382ea6b35f90f9863c36c6fd8bf8b09bb", size = 215063, upload-time = "2026-06-30T07:15:56.573Z" }, + { url = "https://files.pythonhosted.org/packages/b6/36/7fbe9dcdaf857fb3f63c2a2284b62492d95f5e8334e947e5fb6e7f68c9be/rpds_py-2026.6.3-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:931908d9fc855d8f74783377822be318edb6dcb19e47169dc038f9a1bf60b06e", size = 344510, upload-time = "2026-06-30T07:15:57.921Z" }, + { url = "https://files.pythonhosted.org/packages/ba/54/f785cc3d3f60839ca57a5af4927a9f347b07b2799c373fc20f7949f87c7e/rpds_py-2026.6.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:d7469697dce35be237db177d42e2a2ee26e6dcc5fc052078a6fefabd288c6edd", size = 339495, upload-time = "2026-06-30T07:15:59.238Z" }, + { url = "https://files.pythonhosted.org/packages/63/ef/d4cdaf309e6b095b43597103cf8c0b951d6cca2acce68c474f75ec12e0c7/rpds_py-2026.6.3-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bcfbcf66006befb9fd2aeaa9e01feaf881b4dc330a02ba07d2322b1c11be7b5d", size = 369454, upload-time = "2026-06-30T07:16:01.021Z" }, + { url = "https://files.pythonhosted.org/packages/96/4a/9559a68b7ee15db09d7981212e8c2e219d2a1d6d4faa0391d813c3496a36/rpds_py-2026.6.3-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:847927daf4cffbd4e90e42bc890069897101edd015f956cb8721b3473372edda", size = 374583, upload-time = "2026-06-30T07:16:02.287Z" }, + { url = "https://files.pythonhosted.org/packages/ef/75/8964aa7d2c6e8ac43eba8eb6e6b0fdda1f46d39f2fc3e6aa9f2cb17f485d/rpds_py-2026.6.3-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:aca6c1ef08a82bfe327cc156da694660f599923e2e6665b6d81c9c2d0ac9ffc8", size = 492919, upload-time = "2026-06-30T07:16:03.723Z" }, + { url = "https://files.pythonhosted.org/packages/8f/97/6908094ac804115e65aedfd90f1b5fee4eebebd3f6c4cfc5419939267565/rpds_py-2026.6.3-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ae50181a047c871561212bb97f7932a2d45fb53e947bd9b57ebad85b529cbc53", size = 383725, upload-time = "2026-06-30T07:16:05.305Z" }, + { url = "https://files.pythonhosted.org/packages/d1/9c/0d1fdc2e7aba23e290d603bc494e97bd205bae262ce33c6b32a69768ed5e/rpds_py-2026.6.3-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dc319e5a1de4b6913aac94bf6a2f9e847371e0a140a43dd4991db1a09bc2d504", size = 367255, upload-time = "2026-06-30T07:16:07.086Z" }, + { url = "https://files.pythonhosted.org/packages/c4/fe/f0209ca4a9ed074bc8acb44dfd0e81c3122e94c9689f5645b7973a866719/rpds_py-2026.6.3-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:e4316bf32babbed84e691e352faf967ce2f0f024174a8643c37c94a1080374fc", size = 379060, upload-time = "2026-06-30T07:16:08.525Z" }, + { url = "https://files.pythonhosted.org/packages/c6/8d/f1cc54c616b9d8897de8738aac148d20afca93f68187475fe194d09a71b9/rpds_py-2026.6.3-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:8c6e5a2f750cc71c3e3b11d71661f21d6f9bc6cebc6564b1466417a1ec03ec77", size = 395960, upload-time = "2026-06-30T07:16:09.989Z" }, + { url = "https://files.pythonhosted.org/packages/fb/04/aafff00f73aeca2945f734f1d483c64ab8f472d0864ab02377fd8e89c3b2/rpds_py-2026.6.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:4470ce197d4090875cf6affbf1f853338387428df97c4fb7b7106317b8214698", size = 545356, upload-time = "2026-06-30T07:16:11.816Z" }, + { url = "https://files.pythonhosted.org/packages/fd/cc/e229663b9e4ddac5a4acbe9085dd80a71af2a5d356b8b39d6bff233f24b0/rpds_py-2026.6.3-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:ea964164cc9afa72d4d9b23cc28dafae93693c0a53e0b42acbff15b22c3f9ddd", size = 612319, upload-time = "2026-06-30T07:16:13.586Z" }, + { url = "https://files.pythonhosted.org/packages/e3/7a/8a0e6d3e6cd066af108b71b43122c3fe158dd9eb86acac626593a2582eb1/rpds_py-2026.6.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:639c8929aa0afe81be836b04de888460d6bed38b9c54cfc18da8f6bfabf5af5d", size = 573508, upload-time = "2026-06-30T07:16:15.23Z" }, + { url = "https://files.pythonhosted.org/packages/87/03/2a69ab618a789cf6cf85c86bb844c62d090e700ab1a2aa676b3741b6c516/rpds_py-2026.6.3-cp314-cp314-win32.whl", hash = "sha256:882076c00c0a608b131187055ddc5ae29f2e7eaf870d6168980420d58528a5c8", size = 202504, upload-time = "2026-06-30T07:16:16.893Z" }, + { url = "https://files.pythonhosted.org/packages/85/62/a3892ba945f4e24c78f352e5de3c7620d8479f73f211406a97263d13c7d2/rpds_py-2026.6.3-cp314-cp314-win_amd64.whl", hash = "sha256:0be972be84cfcaf46c8c6edf690ca0f154ac17babf1f6a955a51579b34ad2dc5", size = 220380, upload-time = "2026-06-30T07:16:18.108Z" }, + { url = "https://files.pythonhosted.org/packages/3d/e7/c2bd44dc831931815ad11ebb5f430b5a0a4d3caa9de837107876c30c3432/rpds_py-2026.6.3-cp314-cp314-win_arm64.whl", hash = "sha256:2a9c6f195058cb45335e8cc3802745c603d716eb96bc9625950c1aac71c0c703", size = 215976, upload-time = "2026-06-30T07:16:19.654Z" }, + { url = "https://files.pythonhosted.org/packages/79/9c/fff7b74bce9a091ec9a012a03f9ff5f69364eaf9451060dfc4486da2ffdd/rpds_py-2026.6.3-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:f90938e92afda60266da758ee7d363447f7f0138c9559f9e1811629580582d90", size = 346840, upload-time = "2026-06-30T07:16:21.268Z" }, + { url = "https://files.pythonhosted.org/packages/e9/44/77bcb1168b33704908295533d27f10eb811e9e3e193e8993dc99572211d3/rpds_py-2026.6.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ec829541c45bca16e61c7ae50c20501f213605beb75d1aba91a6ee37fbbb56a4", size = 340282, upload-time = "2026-06-30T07:16:22.875Z" }, + { url = "https://files.pythonhosted.org/packages/87/3c/7a9081c7c9e645b39efe19e4ffbeccd80add246327cd9b888aecffd72317/rpds_py-2026.6.3-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:afd70d95892096cdb26f15a00c45907b17817577aa8d1c76b2dcc2788391f9e9", size = 370403, upload-time = "2026-06-30T07:16:24.415Z" }, + { url = "https://files.pythonhosted.org/packages/f7/69/af47021eb7dad6ff3396cb001c08f0f3c4d06c20253f75be6421a59fe6b7/rpds_py-2026.6.3-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:29dfa0533a5d4c94d4dfa1b694fcb56c9c63aad8330ffdd816fd225d0a7a162f", size = 376055, upload-time = "2026-06-30T07:16:26.111Z" }, + { url = "https://files.pythonhosted.org/packages/81/fc/a3bcf517084396a6dd258c592567a3c011ba4557f2fde23dceaf26e74f2e/rpds_py-2026.6.3-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:af05d726809bff6b141be124d4c7ce998f9c9c7f30edb1f46c07aa103d540b41", size = 494419, upload-time = "2026-06-30T07:16:27.596Z" }, + { url = "https://files.pythonhosted.org/packages/c9/eb/13d529d1788135425c7bf207f8463458ca5d92e43f3f701365b83e9dffc1/rpds_py-2026.6.3-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9826217f048f620d9a712672818bf231442c1b35d96b227a07eabd11b4bb6945", size = 384848, upload-time = "2026-06-30T07:16:29.183Z" }, + { url = "https://files.pythonhosted.org/packages/8e/f4/b7ac49f30013aba8f7b9566b1dd07e81de95e708c1374b7bacc5b9bc5c9c/rpds_py-2026.6.3-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:536bceea4fa4acf7e1c61da2b5786304367c816c8895be71b8f537c480b0ea1f", size = 371369, upload-time = "2026-06-30T07:16:30.912Z" }, + { url = "https://files.pythonhosted.org/packages/31/86/6260bafa622f788b07ddec0e52d810305c8b9b0b8c27f58a2ab04bf62b4f/rpds_py-2026.6.3-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:bc0011654b91cc4fb2ae701bec0a0ba1e552c0714247fa7af6c59e0ccfa3a4e1", size = 379673, upload-time = "2026-06-30T07:16:32.486Z" }, + { url = "https://files.pythonhosted.org/packages/19/c3/03f1ee79a047b48daeca157c89a18509cde22b6b951d642b9b0af1be660a/rpds_py-2026.6.3-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:539d75de9e0d536c84ff18dfeb805398e58227001ce09231a26a08b9aed1ee0e", size = 397500, upload-time = "2026-06-30T07:16:34.471Z" }, + { url = "https://files.pythonhosted.org/packages/f0/95/8ed0cd8c377dca12aea498f119fe639fc474d1461545c39d2b5872eb1c0f/rpds_py-2026.6.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:166cf54d9f44fc6ceb53c7860258dde44a81406646de79f8ed3234fca3b6e538", size = 545978, upload-time = "2026-06-30T07:16:36.45Z" }, + { url = "https://files.pythonhosted.org/packages/d3/f2/0eb57f0eaa83f8fc152a7e03de968ab77e1f00732bebc892b190c6eebde7/rpds_py-2026.6.3-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:d34c20167764fbcf927194d532dd7e0c56772f0a5f943fa5ef9e9afbba8fb9db", size = 613350, upload-time = "2026-06-30T07:16:38.213Z" }, + { url = "https://files.pythonhosted.org/packages/5b/de/e0674bdbc3ef7634989b3f854c3f34bc1f587d36e5bfdc5c378d57034619/rpds_py-2026.6.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ea7bb13b7c9a29791f87a0387ba7d3ad3a6d783d827e4d3f27b40a0ff44495e2", size = 576486, upload-time = "2026-06-30T07:16:39.797Z" }, + { url = "https://files.pythonhosted.org/packages/f2/f6/21101359743cd136ada781e8210a85769578422ba460672eea0e29739200/rpds_py-2026.6.3-cp314-cp314t-win32.whl", hash = "sha256:6de4744d05bd1aa1be4ed7ea1189e3979196808008113bbbf899a460966b925e", size = 201068, upload-time = "2026-06-30T07:16:41.316Z" }, + { url = "https://files.pythonhosted.org/packages/a6/b2/9574d4d44f7760c2aa32d92a0a4f41698e33f5b204a0bf5c9758f52c79d5/rpds_py-2026.6.3-cp314-cp314t-win_amd64.whl", hash = "sha256:c7b9a2f8f4d8e90af72571d3d495deebdd7e3c75451f5b41719aee166e940fc2", size = 220600, upload-time = "2026-06-30T07:16:43.091Z" }, + { url = "https://files.pythonhosted.org/packages/08/ae/f23a2697e6ee6340a578b0f136be6483657bef0c6f9497b752bb5c0964bb/rpds_py-2026.6.3-cp315-cp315-macosx_10_12_x86_64.whl", hash = "sha256:e059c5dde6452b44424bd1834557556c226b57781dee1227af23518459722b13", size = 344726, upload-time = "2026-06-30T07:16:44.5Z" }, + { url = "https://files.pythonhosted.org/packages/c3/63/e7b3a1a5358dd32c930a1062d8e15b67fd6e8922e81df9e91706d66ee5c8/rpds_py-2026.6.3-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:2f7c26fbc5acd2522b95d4177fe4710ffd8e9b20529e703ffbf8db4d93903f05", size = 339587, upload-time = "2026-06-30T07:16:46.255Z" }, + { url = "https://files.pythonhosted.org/packages/ec/64/10a85681916ca55fffb91b0a211f84e34297c109243484dd6394660a8a7c/rpds_py-2026.6.3-cp315-cp315-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a3086b538543802f84c843911242db20447de00d8752dd0efc936dbcf02218ba", size = 369585, upload-time = "2026-06-30T07:16:48.101Z" }, + { url = "https://files.pythonhosted.org/packages/76/c2/baf95c7c38823e12ba34407c5f5767a89e5cf2233895e56f608167ae9493/rpds_py-2026.6.3-cp315-cp315-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:8f2e5c5ee828d42cb11760761c0af6507927bec42d0ad5458f97c9203b054617", size = 375479, upload-time = "2026-06-30T07:16:49.93Z" }, + { url = "https://files.pythonhosted.org/packages/6a/94/0aad06c72d65101e11d33528d438cda99a39ce0da99466e156158f2541d3/rpds_py-2026.6.3-cp315-cp315-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ed0c1e5d10cdc7135537988c74a0188da68e2f3c30813ba3744ab1e42e0480f9", size = 492418, upload-time = "2026-06-30T07:16:51.641Z" }, + { url = "https://files.pythonhosted.org/packages/b5/17/de3f5a479a1f056535d7489819639d8cd591ea6281d700390b43b1abd745/rpds_py-2026.6.3-cp315-cp315-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8c2642a7603ec0b16ed77da4555db3b4b472341904873788327c0b0d7b95f1bb", size = 384123, upload-time = "2026-06-30T07:16:53.622Z" }, + { url = "https://files.pythonhosted.org/packages/46/7d/bf09bd1b145bb2671c03e1e6d1ab8651858d90d8c7dfeadd85a37a934fd8/rpds_py-2026.6.3-cp315-cp315-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8e4320744c1ffdd95a603def63344bfab2d33edeab301c5007e7de9f9f5b3885", size = 367351, upload-time = "2026-06-30T07:16:55.241Z" }, + { url = "https://files.pythonhosted.org/packages/a3/ea/1bb734f314b8be319149ddee80b18bd41372bdcfbdf88d28131c0cd37719/rpds_py-2026.6.3-cp315-cp315-manylinux_2_31_riscv64.whl", hash = "sha256:a9f4645593036b81bbdb36b9c8e0ea0d1c3fee968c4d59db0344c14087ef143a", size = 378827, upload-time = "2026-06-30T07:16:56.841Z" }, + { url = "https://files.pythonhosted.org/packages/4b/93/d9611e5b25e26df9a3649813ed66193ace9347a7c7fc4ab7cf70e94851c0/rpds_py-2026.6.3-cp315-cp315-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:e55d236be29255554da47abe5c577637db7c24a02b8b46f0ca9524c855801868", size = 395966, upload-time = "2026-06-30T07:16:58.557Z" }, + { url = "https://files.pythonhosted.org/packages/c3/cb/99d77e16e5534ae1d90629bbe419ba6ee170833a6a85e3aa1cc41726fbbc/rpds_py-2026.6.3-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:24e9c5386e16669b674a69c156c8eeefcb578f3b3397b713b08e6d60f3c7b187", size = 545680, upload-time = "2026-06-30T07:17:00.164Z" }, + { url = "https://files.pythonhosted.org/packages/59/15/11a29755f790cef7a2f755e8e14f4f0c33f39489e1893a632a2eee59672b/rpds_py-2026.6.3-cp315-cp315-musllinux_1_2_i686.whl", hash = "sha256:c60924535c75f1566b6eb75b5c31a48a43fef04fa2d0d201acbad8a9969c6107", size = 611853, upload-time = "2026-06-30T07:17:01.962Z" }, + { url = "https://files.pythonhosted.org/packages/68/86/0c27547e21644da938fb530f7e1a8148dd24d02db07e7a5f2567a17ce710/rpds_py-2026.6.3-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:38a2fea2787428f811719ceb9114cb78964a3138838320c29ac39526c79c16ba", size = 573715, upload-time = "2026-06-30T07:17:03.693Z" }, + { url = "https://files.pythonhosted.org/packages/29/71/4d8fcf700931815594bce892255bbd973b94efaf0fc1932b0590df18d886/rpds_py-2026.6.3-cp315-cp315-win32.whl", hash = "sha256:d483fe17f01ad64b7bf7cc38fcefff1ca9fb83f8c2b2542b68f97ffe0611b369", size = 202864, upload-time = "2026-06-30T07:17:05.746Z" }, + { url = "https://files.pythonhosted.org/packages/eb/62/b577562de0edbb55b2be85ce5fd09c33e386b9b13eee09833af4240fd5c4/rpds_py-2026.6.3-cp315-cp315-win_amd64.whl", hash = "sha256:67e3a721ffc5d8d2210d3671872298c4a84e4b8035cfe42ffd7cde35d772b146", size = 220430, upload-time = "2026-06-30T07:17:07.471Z" }, + { url = "https://files.pythonhosted.org/packages/c8/95/d6d0b2509825141eef60669a5739eec88dbc6a48053d6c92993a5704defe/rpds_py-2026.6.3-cp315-cp315-win_arm64.whl", hash = "sha256:6e84adbcf4bf841aed8116a8264b9f50b4cb3e7bd89b516122e616ac56ca269e", size = 215877, upload-time = "2026-06-30T07:17:09.008Z" }, + { url = "https://files.pythonhosted.org/packages/b7/bf/f3ea278f0afd615c1d0f19cb69043a41526e2bb600c2b536eb192218eb27/rpds_py-2026.6.3-cp315-cp315t-macosx_10_12_x86_64.whl", hash = "sha256:ae6dd8f10bd17aad820876d24caec9efdafd80a318d16c0a48edb5e136902c6b", size = 346933, upload-time = "2026-06-30T07:17:10.762Z" }, + { url = "https://files.pythonhosted.org/packages/9d/29/9907bdf1c5346763cf10b7f6852aad86652168c259def904cbe0082c5864/rpds_py-2026.6.3-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:bdbd97738551fca3917c1bd7188bec1920bb520104f28e7e1007f9ceb17b7690", size = 340274, upload-time = "2026-06-30T07:17:12.266Z" }, + { url = "https://files.pythonhosted.org/packages/6f/2c/8e03767b5778ef25cebf74a7a91a2c3806f8eced4c92cb7406bbe060756d/rpds_py-2026.6.3-cp315-cp315t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8b95977e7211527ab0ba576e286d023389fbeeb32a6b7b771665d333c60e5342", size = 370763, upload-time = "2026-06-30T07:17:14.107Z" }, + { url = "https://files.pythonhosted.org/packages/2e/e1/df2a7e1ba2efd796af26194250b8d42c821b46592311595162af9ef0528d/rpds_py-2026.6.3-cp315-cp315t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:d15fde0e6fb0d88a60d221204873743e5d9f0b7d29165e62cd86d0413ad74ba6", size = 376467, upload-time = "2026-06-30T07:17:15.76Z" }, + { url = "https://files.pythonhosted.org/packages/6b/de/8a0814d1946af29cb068fb259aa8622f856df1d0bab58429448726b537f5/rpds_py-2026.6.3-cp315-cp315t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a136d453475ac0fcbda502ef1e6504bd28d6d904700915d278deeab0d00fe140", size = 496689, upload-time = "2026-06-30T07:17:17.308Z" }, + { url = "https://files.pythonhosted.org/packages/df/f3/f19e0c852ba13694f5a79f3b719331051573cb5693feacf8a88ffffc3a71/rpds_py-2026.6.3-cp315-cp315t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f826877d462181e5eb1c26a0026b8d0cab05d99844ecb6d8bf3627a2ca0c0442", size = 385340, upload-time = "2026-06-30T07:17:18.928Z" }, + { url = "https://files.pythonhosted.org/packages/e2/ae/7ec3a9d2d4351f99e37bcb06b6b6f954512646bfdbf9742e1de727865daf/rpds_py-2026.6.3-cp315-cp315t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:79486287de1730dbaff3dbd124d0ca4d2ef7f9d29bf2544f1f93c09b5bcbbd12", size = 372179, upload-time = "2026-06-30T07:17:20.539Z" }, + { url = "https://files.pythonhosted.org/packages/d3/ac/9cee911dff2aaa9a5a8354f6610bf2e6a616de9197c5fff4f54f82585f1e/rpds_py-2026.6.3-cp315-cp315t-manylinux_2_31_riscv64.whl", hash = "sha256:808345f53cb952433ca2816f1604ff3515608a81784954f38d4452acfe8e61d5", size = 379993, upload-time = "2026-06-30T07:17:22.212Z" }, + { url = "https://files.pythonhosted.org/packages/83/6b/7c2a07ba88d1e9a936612f7a5d067467ed03d971d5a06f7d309dff044a7e/rpds_py-2026.6.3-cp315-cp315t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:1967debc37f64f2c4dc90a7f563aec558b471966e12adcac4e1c4240496b6ebf", size = 398909, upload-time = "2026-06-30T07:17:23.66Z" }, + { url = "https://files.pythonhosted.org/packages/97/0b/776ffcb66783637b0031f6d58d6fb55913c8b5abf00aeecd46bf933fb477/rpds_py-2026.6.3-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:f0840b5b17057f7fd918b76183a4b5a0635f43e14eb2ce60dce1d4ee4707ea00", size = 546584, upload-time = "2026-06-30T07:17:25.264Z" }, + { url = "https://files.pythonhosted.org/packages/55/33/ba3bc04d7092bd553c9b2b195624992d2cc4f3de1f380b7b93cbee67bd79/rpds_py-2026.6.3-cp315-cp315t-musllinux_1_2_i686.whl", hash = "sha256:faa679d19a6696fd54259ad321251ad77a13e70e03dd834daa762a44fb6196ef", size = 614357, upload-time = "2026-06-30T07:17:26.888Z" }, + { url = "https://files.pythonhosted.org/packages/8b/71/14edf065f04630b1a8472f7653cad03f6c478bcf95ea0e6aed55451e33ea/rpds_py-2026.6.3-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:23a439f31ccbeff1574e24889128821d1f7917470e830cf6544dced1c662262a", size = 576533, upload-time = "2026-06-30T07:17:28.546Z" }, + { url = "https://files.pythonhosted.org/packages/ba/76/65002b08596c389105720a8c0d22298b8dc25a4baf89b2ce431343c8b1de/rpds_py-2026.6.3-cp315-cp315t-win32.whl", hash = "sha256:913ca42ccad3f8cc6e292b587ae8ae49c8c823e5dce51a736252fc7c7cdfa577", size = 201204, upload-time = "2026-06-30T07:17:30.193Z" }, + { url = "https://files.pythonhosted.org/packages/8c/97/d855d6b3c322d1f27e26f5241c42016b56cf01377ea8ed348285f54652f0/rpds_py-2026.6.3-cp315-cp315t-win_amd64.whl", hash = "sha256:ae3d4fe8c0b9213624fdce7279d70e3b148b682ca20719ebd193a23ebfa47324", size = 220719, upload-time = "2026-06-30T07:17:31.788Z" }, + { url = "https://files.pythonhosted.org/packages/b4/9c/f0d19ac587fd0e4ab6b72cda355e9c5a6166b01ef7e064e437aef8eb9fef/rpds_py-2026.6.3-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:4cf2d36a2357e4d07bb5a4f98801265327b48256867816cfd2ceb001e9754a8f", size = 349791, upload-time = "2026-06-30T07:17:33.315Z" }, + { url = "https://files.pythonhosted.org/packages/38/c7/1d49d204c9fd2ee6c537601dc4c1ba921e03363ca576bfab94a00254ac9a/rpds_py-2026.6.3-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:30c6dc199b24a5e3e81d50da0f00858c5bbdb2617a750395687f4339c5818171", size = 352842, upload-time = "2026-06-30T07:17:34.897Z" }, + { url = "https://files.pythonhosted.org/packages/ac/e5/c0b5dc93cd0d4c06ce1f438907649514e2ea077bcd911e3154a51e96c38e/rpds_py-2026.6.3-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9891e594296ab9dada6551c8e7b387b2721f27a67eecd528412e8906247a7b90", size = 382094, upload-time = "2026-06-30T07:17:36.514Z" }, + { url = "https://files.pythonhosted.org/packages/0d/54/ec0e907b4ca8d541112db352409bd15f871c9b243e0c92c9b5a46ae96f01/rpds_py-2026.6.3-pp311-pypy311_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b5c2dc92304aa48a4a60443b548bb12f12e119d4b72f314015e67b9e1be97fca", size = 388662, upload-time = "2026-06-30T07:17:38.235Z" }, + { url = "https://files.pythonhosted.org/packages/d3/f4/921c22a4fd0f1c1ac13a3996ffbf0aa67951e2c8ad0d1d9574938a2932e8/rpds_py-2026.6.3-pp311-pypy311_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:127e08c0642d880cf32ca47ec2a4a77b901f7e2dd1ad9762adb13955d72ffcc9", size = 504896, upload-time = "2026-06-30T07:17:39.689Z" }, + { url = "https://files.pythonhosted.org/packages/0b/1b/a114b972cefa1ab1cdb3c7bb177cd3844a12826c507c722d3a73516dbbaf/rpds_py-2026.6.3-pp311-pypy311_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8bb68f03f395eb793220b45c097bd4d8c32944393da0fad8b999efac0868fc8c", size = 391545, upload-time = "2026-06-30T07:17:41.336Z" }, + { url = "https://files.pythonhosted.org/packages/4e/98/af9b3db77d47fcbe6c8c1f36e2c2147ec70292819e99c325f871584a1c11/rpds_py-2026.6.3-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a3450b693fde92133e9f51060568a4c31fcca76d5e53bbd611e689ca446517e9", size = 380059, upload-time = "2026-06-30T07:17:42.857Z" }, + { url = "https://files.pythonhosted.org/packages/c9/ba/0efd8668b97c1d26a61566386c636a7a7a09829e474fdf807caa15a2c844/rpds_py-2026.6.3-pp311-pypy311_pp73-manylinux_2_31_riscv64.whl", hash = "sha256:5e8d07bddee435a2ff6f1920e18feff28d0bc4533e42f4bf6927fbd073312c41", size = 393235, upload-time = "2026-06-30T07:17:44.637Z" }, + { url = "https://files.pythonhosted.org/packages/62/90/8c139ee9690f73b0829f32647de6f40d826f8f443af6fa72644f96351aac/rpds_py-2026.6.3-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:3a83ae6c67b7676b9878378547ca8e93ed77a580037bcbcd1d32f739e1e6089c", size = 413008, upload-time = "2026-06-30T07:17:46.225Z" }, + { url = "https://files.pythonhosted.org/packages/9c/97/0043896fdd7828ce09a1d9a8b06433714d0960fc4ff3fc4aa72b666b764e/rpds_py-2026.6.3-pp311-pypy311_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:2bfd04c19ddbd6640de0b51894d764bd2758854d5b75bd102d2ef10cb9c293a9", size = 558118, upload-time = "2026-06-30T07:17:47.759Z" }, + { url = "https://files.pythonhosted.org/packages/f6/40/02355f0e134f783a8f9814c4680a1bd311d37671577a5964ea838573ff37/rpds_py-2026.6.3-pp311-pypy311_pp73-musllinux_1_2_i686.whl", hash = "sha256:ca6546b66be9dc4738b1b043d5ebd5488c66c578c5ff0fd0e8065313fe3afb76", size = 623138, upload-time = "2026-06-30T07:17:49.355Z" }, + { url = "https://files.pythonhosted.org/packages/10/85/48f0abdcef5cce4e034c7a5b0ceeceba0b01bf0d942824f4bb720afe2dec/rpds_py-2026.6.3-pp311-pypy311_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:8e65860d238379ed982fd9ba690579b5e95af2f4840f99c772816dbe573cb826", size = 586486, upload-time = "2026-06-30T07:17:51.141Z" }, +] + +[[package]] +name = "safetensors" +version = "0.8.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/45/06/f955dbbb1859e3bd23c8ac6141af5106e7ad5fedec4a3a6e3d60f94b7001/safetensors-0.8.0.tar.gz", hash = "sha256:fabaf3e0f18a6618d9b36560682562157f77c2b71fcffc7b432be2baed9d753d", size = 325846, upload-time = "2026-06-09T07:52:25.563Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/39/a0/f718cda65b05407d228f97602cf60dca269c979867aa5beb25410de26cd3/safetensors-0.8.0-cp310-abi3-macosx_10_12_x86_64.whl", hash = "sha256:c554f85858e05226d3c2828e32395e677434685d6d94594a41643361c5e837f0", size = 473568, upload-time = "2026-06-09T07:52:18.829Z" }, + { url = "https://files.pythonhosted.org/packages/f5/b1/fa7c600e7dceae12e9606c7578cbc9ff1e1ed55844883ee5c92205e86226/safetensors-0.8.0-cp310-abi3-macosx_11_0_arm64.whl", hash = "sha256:c80201d22cbf405b80647a60ada77bba06c8fba2da2743ba1e89cdcc39a81f25", size = 484562, upload-time = "2026-06-09T07:52:17.518Z" }, + { url = "https://files.pythonhosted.org/packages/09/7d/65a7de0af421317bb36a067241e4235fff194eed60b961ed6d3f59a3fc60/safetensors-0.8.0-cp310-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7a46e5ff292c356d6991e60942ba7f79817682d3a2cef0702136448cb9c4d235", size = 502844, upload-time = "2026-06-09T07:52:07.624Z" }, + { url = "https://files.pythonhosted.org/packages/91/4f/3175c9d75634e0e0dda0082794193521035edd7c70a6f212bf33ca06ddf4/safetensors-0.8.0-cp310-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:4124502b78f03534117c848f87a39b8f31e577b15eff423bf8bfb95f2a8c30d0", size = 511823, upload-time = "2026-06-09T07:52:09.565Z" }, + { url = "https://files.pythonhosted.org/packages/20/87/846c289e7aa2299eff406335717cf43ce8777194ece8aad75772e0411615/safetensors-0.8.0-cp310-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7bc0a787ba8a35be368ee3574edfa2b1ad389eebd0a72e482ae275490e3f6c98", size = 633461, upload-time = "2026-06-09T07:52:11.128Z" }, + { url = "https://files.pythonhosted.org/packages/76/22/8d64d9df2c45d5ded401df889d0ad90882804ca172d79ec4f0df8f727fe0/safetensors-0.8.0-cp310-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:040070828e36dc8e122178bbbd5830ff9e97920affb84cbe0f46442497bed358", size = 545148, upload-time = "2026-06-09T07:52:13.603Z" }, + { url = "https://files.pythonhosted.org/packages/28/50/f203ff3a3ddfe19308efc83c5a3a29ed02bf786732ec35e68bf9162f3365/safetensors-0.8.0-cp310-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fd6f3f93c9a0a7cc2788ee63fb763353d4bd2e89b0751bc78fcf7dda00bea774", size = 516040, upload-time = "2026-06-09T07:52:16.29Z" }, + { url = "https://files.pythonhosted.org/packages/46/fb/cdaed17ceb2948784fd9c36b6fd3e951b608547cea81a48e8ee6f8cfdfcb/safetensors-0.8.0-cp310-abi3-manylinux_2_31_riscv64.whl", hash = "sha256:fcdd41ec4628fee5799f807c73c353629130fbd942aa23d83c623dd6c9d52d78", size = 513832, upload-time = "2026-06-09T07:52:12.37Z" }, + { url = "https://files.pythonhosted.org/packages/0d/49/1e15de264dcc3b77943d2d0c56a95809956883b1c2d6d585c792523f180b/safetensors-0.8.0-cp310-abi3-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:8e9f537aa183a38ace122d27303dcd986b26bd2a7591f9181d7f0c396f4677ca", size = 559930, upload-time = "2026-06-09T07:52:14.743Z" }, + { url = "https://files.pythonhosted.org/packages/2a/43/bf38443278eab4b1be1fce2931e2b012ad9cb7df52ada751d0aab8f7659a/safetensors-0.8.0-cp310-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:87eec7ffed2b809f05a398a8becb7d013f19f7837cd15d9748580d6cf30dbaf4", size = 678670, upload-time = "2026-06-09T07:52:20.032Z" }, + { url = "https://files.pythonhosted.org/packages/72/e3/68cd3fa5b48488e84add63e04cb12f3bc28ae4638c06d4508c6e88823d0e/safetensors-0.8.0-cp310-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:4a95ae2b05d7726d751da4ebf626a2ca782b706e101bd894c95bc2450b1cffcc", size = 786679, upload-time = "2026-06-09T07:52:21.322Z" }, + { url = "https://files.pythonhosted.org/packages/29/4b/1c19c509d56e01f4fbb3d0a2e597450f6cc04d1d56cf52defb0a62dfd715/safetensors-0.8.0-cp310-abi3-musllinux_1_2_i686.whl", hash = "sha256:3ae091f16662658bdc019a4ff6cb4c085bb7d725eb5978b183ffd265863b6d2d", size = 765683, upload-time = "2026-06-09T07:52:22.594Z" }, + { url = "https://files.pythonhosted.org/packages/27/43/41c1621732edd934d868a00d1b891584c892a7b62a9aab82ea5a0a5623ee/safetensors-0.8.0-cp310-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:8e080062fcde23be189565e1c3305d16751a218ecf9412c8601e64204eb6f846", size = 722361, upload-time = "2026-06-09T07:52:23.924Z" }, + { url = "https://files.pythonhosted.org/packages/8e/3f/73ccf82579412b4a71c4ca673f10b5f1f888d7cf5af7fe24f27d30307be4/safetensors-0.8.0-cp310-abi3-win32.whl", hash = "sha256:2ddf52eac562eda224f99acfa7889d02968c1fd59a5b011ae7d8137c37e9c02d", size = 342401, upload-time = "2026-06-09T07:52:28.895Z" }, + { url = "https://files.pythonhosted.org/packages/1b/6d/3fba214c1e5e0f69991677ec3bc17023f0421776975e1de0c682dca475e2/safetensors-0.8.0-cp310-abi3-win_amd64.whl", hash = "sha256:096ec1a98435df7beb08853bb5aa9081a84f23d0adc67ed1a0a10550f608373f", size = 355540, upload-time = "2026-06-09T07:52:27.832Z" }, + { url = "https://files.pythonhosted.org/packages/8d/fc/7eedc3510d97878876e32774eebbeb61c43f148a96e915c84229a3e967aa/safetensors-0.8.0-cp310-abi3-win_arm64.whl", hash = "sha256:f7838e5135a406ad3e02efdcb8cf2e5397d368b0154537c4fec682dbc544d452", size = 340500, upload-time = "2026-06-09T07:52:26.745Z" }, +] + [[package]] name = "scipy" version = "1.17.1" @@ -1446,6 +3699,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/d5/19/969dc072906c84dd0a3b05dcf57ea750936087d7873549e408b35cfc3f97/scipy-1.18.0-cp314-cp314t-win_arm64.whl", hash = "sha256:368e0a705903c466aa5f08eefb39e6b1b6b2d659e7352a31fd9e2438365be0f8", size = 25279661, upload-time = "2026-06-19T15:01:40.817Z" }, ] +[[package]] +name = "send2trash" +version = "2.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/c5/f0/184b4b5f8d00f2a92cf96eec8967a3d550b52cf94362dad1100df9e48d57/send2trash-2.1.0.tar.gz", hash = "sha256:1c72b39f09457db3c05ce1d19158c2cbef4c32b8bedd02c155e49282b7ea7459", size = 17255, upload-time = "2026-01-14T06:27:36.056Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1c/78/504fdd027da3b84ff1aecd9f6957e65f35134534ccc6da8628eb71e76d3f/send2trash-2.1.0-py3-none-any.whl", hash = "sha256:0da2f112e6d6bb22de6aa6daa7e144831a4febf2a87261451c4ad849fe9a873c", size = 17610, upload-time = "2026-01-14T06:27:35.218Z" }, +] + [[package]] name = "setuptools" version = "81.0.0" @@ -1455,6 +3717,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/e1/e3/c164c88b2e5ce7b24d667b9bd83589cf4f3520d97cad01534cd3c4f55fdb/setuptools-81.0.0-py3-none-any.whl", hash = "sha256:fdd925d5c5d9f62e4b74b30d6dd7828ce236fd6ed998a08d81de62ce5a6310d6", size = 1062021, upload-time = "2026-02-06T21:10:37.175Z" }, ] +[[package]] +name = "shellingham" +version = "1.5.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/58/15/8b3609fd3830ef7b27b655beb4b4e9c62313a4e8da8c676e142cc210d58e/shellingham-1.5.4.tar.gz", hash = "sha256:8dbca0739d487e5bd35ab3ca4b36e11c4078f3a234bfce294b0a0291363404de", size = 10310, upload-time = "2023-10-24T04:13:40.426Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e0/f9/0595336914c5619e5f28a1fb793285925a8cd4b432c9da0a987836c7f822/shellingham-1.5.4-py2.py3-none-any.whl", hash = "sha256:7ecfff8f2fd72616f7481040475a65b2bf8af90a56c89140852d1120324e8686", size = 9755, upload-time = "2023-10-24T04:13:38.866Z" }, +] + [[package]] name = "six" version = "1.17.0" @@ -1464,6 +3735,29 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050, upload-time = "2024-12-04T17:35:26.475Z" }, ] +[[package]] +name = "soupsieve" +version = "2.9.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/69/99/a6ca3beb3ccacb41fb3321d8a60e5566f9e6467601ef8eba6a17e1b89778/soupsieve-2.9.2.tar.gz", hash = "sha256:4a55d8cf158a9c2e587fa4922f1bbb91d68ac829e2d6f25403a85747c71daf74", size = 122445, upload-time = "2026-08-07T00:57:24.801Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/eb/dc/ad025c1ee131eba60c69f4dd5779b18fcf1e6b21a343e2162a84d5d133c7/soupsieve-2.9.2-py3-none-any.whl", hash = "sha256:8089a26fd974ca7a1f30276d3d8492ab266ab15af581642dfe8aa162e0c1c823", size = 37370, upload-time = "2026-08-07T00:57:23.524Z" }, +] + +[[package]] +name = "stack-data" +version = "0.6.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "asttokens" }, + { name = "executing" }, + { name = "pure-eval" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/28/e3/55dcc2cfbc3ca9c29519eb6884dd1415ecb53b0e934862d3559ddcb7e20b/stack_data-0.6.3.tar.gz", hash = "sha256:836a778de4fec4dcd1dcd89ed8abff8a221f58308462e1c4aa2a3cf30148f0b9", size = 44707, upload-time = "2023-09-30T13:58:05.479Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f1/7b/ce1eafaf1a76852e2ec9b22edecf1daa58175c090266e9f6c64afcd81d91/stack_data-0.6.3-py3-none-any.whl", hash = "sha256:d5558e0c25a4cb0853cddad3d77da9891a08cb85dd9f9f91b9f8cd66e511e695", size = 24521, upload-time = "2023-09-30T13:58:03.53Z" }, +] + [[package]] name = "sympy" version = "1.14.0" @@ -1476,6 +3770,59 @@ 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 = "terminado" +version = "0.18.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "ptyprocess", marker = "os_name != 'nt'" }, + { name = "pywinpty", marker = "os_name == 'nt'" }, + { name = "tornado" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/8a/11/965c6fd8e5cc254f1fe142d547387da17a8ebfd75a3455f637c663fb38a0/terminado-0.18.1.tar.gz", hash = "sha256:de09f2c4b85de4765f7714688fff57d3e75bad1f909b589fde880460c753fd2e", size = 32701, upload-time = "2024-03-12T14:34:39.026Z" } +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 = "tinycss2" +version = "1.5.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "webencodings" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a3/ae/2ca4913e5c0f09781d75482874c3a95db9105462a92ddd303c7d285d3df2/tinycss2-1.5.1.tar.gz", hash = "sha256:d339d2b616ba90ccce58da8495a78f46e55d4d25f9fd71dfd526f07e7d53f957", size = 88195, upload-time = "2025-11-23T10:29:10.082Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/60/45/c7b5c3168458db837e8ceab06dc77824e18202679d0463f0e8f002143a97/tinycss2-1.5.1-py3-none-any.whl", hash = "sha256:3415ba0f5839c062696996998176c4a3751d18b7edaaeeb658c9ce21ec150661", size = 28404, upload-time = "2025-11-23T10:29:08.676Z" }, +] + +[[package]] +name = "tokenizers" +version = "0.23.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "huggingface-hub" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/18/1e/bc6587c5ab643b2e17776cace9070a2ae73549c86bffac9934a600bf3c31/tokenizers-0.23.2.tar.gz", hash = "sha256:7f0f085686b9de0d0079e6f874ae053600db64c5d13049e0bbc0119926d25aac", size = 385745, upload-time = "2026-09-03T08:55:42.89Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4d/ed/8a443528baa6fac8dfe8c3b75b038c63ac92bb539bcabe311e227c718173/tokenizers-0.23.2-cp310-abi3-macosx_10_12_x86_64.whl", hash = "sha256:85a9a357a3764aecc904ee76bdaf8cf1ad8e5a67a1b929a487c4a39b49ed0e90", size = 3148852, upload-time = "2026-09-03T08:55:30.874Z" }, + { url = "https://files.pythonhosted.org/packages/67/49/22da045a91732384d3a3771816bf188dc5a1f702c32e635afa7c679c0bef/tokenizers-0.23.2-cp310-abi3-macosx_11_0_arm64.whl", hash = "sha256:986670e43691469dcee610ea0f846f91a8f84e91fc6f7a48d4c064414c0ec2bf", size = 3101593, upload-time = "2026-09-03T08:55:28.587Z" }, + { url = "https://files.pythonhosted.org/packages/2e/4d/8f569ed49372a3ed8e57099bd515055fd48d7c95912c4307cda6973c2168/tokenizers-0.23.2-cp310-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a37039b5dfc4af84eb3ef0a92f4307e28936c8f9adccba2629d36f652e9bf7a2", size = 3516830, upload-time = "2026-09-03T08:55:14.741Z" }, + { url = "https://files.pythonhosted.org/packages/2a/de/e2f14c8919d5bf51874051d00d6c7b7e0e8bde6c6a2dbeddda7f642896ff/tokenizers-0.23.2-cp310-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:7b7e37ba198f24150f523e1242e83c4970de4a525480586be5dcc24d9add32c5", size = 3407975, upload-time = "2026-09-03T08:55:16.842Z" }, + { url = "https://files.pythonhosted.org/packages/c5/bd/93c69152d02ef06ce47aed8b2bf4952dcf733c935a62791873932b2934d9/tokenizers-0.23.2-cp310-abi3-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:43e4f2071e3cc8d5d86421c874aebc82659bb51a68bcdef5a0da75ee89511ccb", size = 3748165, upload-time = "2026-09-03T08:55:24.769Z" }, + { url = "https://files.pythonhosted.org/packages/2d/b7/56b84b80bc96942bba8eb23751a9e8a1fce4faaf4390425e7083f721c98c/tokenizers-0.23.2-cp310-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:325fee2e0418a9dc6c9ecf736a5f5f0db7875183ace9549ae339da76f7a1fbb7", size = 4024165, upload-time = "2026-09-03T08:55:18.806Z" }, + { url = "https://files.pythonhosted.org/packages/9b/8a/0175e216f005c2fe08238292663aa41e4c802b216e71047a69a0e9fc6fa3/tokenizers-0.23.2-cp310-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:950d7c9426fa72406a0ffeacdbc0bb9985f5db20eb8b263f29c79aaf83105703", size = 3591899, upload-time = "2026-09-03T08:55:22.752Z" }, + { url = "https://files.pythonhosted.org/packages/2c/ca/ca6b93c7820df123b2662a9469e8facc826ccc94e98fdd0d615f6431e73a/tokenizers-0.23.2-cp310-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:41c2f84d172449b4dadb9cdc508e3e364076613c35b16e76ecfe47a60d1e3305", size = 3386843, upload-time = "2026-09-03T08:55:26.584Z" }, + { url = "https://files.pythonhosted.org/packages/e9/a4/4f9106d317b14a80aefea9f0e3a8d07ef25f856a7607eb7f5ab894281fcb/tokenizers-0.23.2-cp310-abi3-manylinux_2_31_riscv64.whl", hash = "sha256:12f0835dc2ee694746a76adf7b1567d4346a4a502ebe93fb1f5f80ea49799b78", size = 3577314, upload-time = "2026-09-03T08:55:20.825Z" }, + { url = "https://files.pythonhosted.org/packages/8d/6a/1552b70fb0d9ab074fd3fc961435d01364e79c9058481822c3af6e8d402c/tokenizers-0.23.2-cp310-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:eb2f9c8a24da020ea8c11a01a19c1c2547912d92121ae4a01cfbca46125dee40", size = 9967367, upload-time = "2026-09-03T08:55:33.188Z" }, + { url = "https://files.pythonhosted.org/packages/06/01/3ccb3a956c7528b2507b8a9714155c4baf86af593039db6ea375dd0c96c3/tokenizers-0.23.2-cp310-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:f486f402f6f9abee5bb032553736813af0c710a86b2e0ca592634c55cea1f835", size = 9811886, upload-time = "2026-09-03T08:55:35.642Z" }, + { url = "https://files.pythonhosted.org/packages/fa/73/7038e612d48bda1599457f712f6bd3854eae1a9dc9c13aa47f835349db48/tokenizers-0.23.2-cp310-abi3-musllinux_1_2_i686.whl", hash = "sha256:bef235815a067b2648caf6dcc7a71091b0b0fff9ee8057f6451eb9335fae52ef", size = 10146224, upload-time = "2026-09-03T08:55:38.391Z" }, + { url = "https://files.pythonhosted.org/packages/b5/d8/8e9e4e0b287a338d8f88976729628c9d22e8a54cfaf9777018a7f7cb58a0/tokenizers-0.23.2-cp310-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:5c56bda1511921587789163e524d196ed8284174ac23abd7685d5ea8da6c4718", size = 10256304, upload-time = "2026-09-03T08:55:40.977Z" }, + { url = "https://files.pythonhosted.org/packages/f3/1f/c79a01f671a49728ebb0b61f7ff9ea45663b66cab40bc0858e9859b25c16/tokenizers-0.23.2-cp310-abi3-win32.whl", hash = "sha256:debf978920d93ba9c219bd67cc4bbfaf912c9039e41e7a28b91ec15e3728c95a", size = 2592809, upload-time = "2026-09-03T08:55:48.02Z" }, + { url = "https://files.pythonhosted.org/packages/db/f7/0a69ac6b82dbccf3f71add938a161c497952749294b8dd6dfe03a819dc40/tokenizers-0.23.2-cp310-abi3-win_amd64.whl", hash = "sha256:2e96f5699d5249c9c64aa8412e044f727aae3a4098cf830f9901ec1afc361cde", size = 2863236, upload-time = "2026-09-03T08:55:46.193Z" }, + { url = "https://files.pythonhosted.org/packages/d7/b0/dee84cb44175be1b4c35bd2f770727494e78f0bb38e571a623ade94dbebb/tokenizers-0.23.2-cp310-abi3-win_arm64.whl", hash = "sha256:e49c394456dd9985787fec76132438ba3fb8911f857b1bf3d40119f9292d41aa", size = 2729352, upload-time = "2026-09-03T08:55:44.345Z" }, +] + [[package]] name = "torch" version = "2.12.1" @@ -1553,6 +3900,65 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/90/aa/d6179812ec52b70a7a8f5e99fe7937895d28c535106df1ca0d03f5f51425/torchvision-0.27.1-cp314-cp314t-win_amd64.whl", hash = "sha256:12deaee20d0d9dec6302025d3f93354266befeb692f5c50bca0137b395598b9e", size = 4284412, upload-time = "2026-06-17T21:09:08.989Z" }, ] +[[package]] +name = "tornado" +version = "6.5.8" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/10/d3/343e5bb989d6515b1646cf3d40135d73f3d5e45339bded401b56cdac24dd/tornado-6.5.8.tar.gz", hash = "sha256:9452e1b208a8bd771e2cb1f2ff564985b9b214bdebbe622793e1799e0a6bd23f", size = 520493, upload-time = "2026-08-07T02:12:42.971Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f2/d5/007086fd8df5489338e204f65adce33fd4f21a4999dbb2b9cff2f897b5f4/tornado-6.5.8-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:cc6aa787d7cfab7c3d35189dc7a56fbd2399a569624c730c6b55b3d6531d0403", size = 449487, upload-time = "2026-08-07T02:12:28.682Z" }, + { url = "https://files.pythonhosted.org/packages/70/c8/5a24a99495903f594f6a199dd7beead1cbc0a13e2cb9102727bcaaf2a997/tornado-6.5.8-cp39-abi3-macosx_10_9_x86_64.whl", hash = "sha256:9715b5eb79735b2bcd454ce216a9275b7c0470e64ea1bf5742f78b2f72b26eeb", size = 447649, upload-time = "2026-08-07T02:12:30.306Z" }, + { url = "https://files.pythonhosted.org/packages/6e/de/f2e733f386b85962d1b1dc82cd63d169b5b4580062b35397eac9244a41fe/tornado-6.5.8-cp39-abi3-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:547d63f450d570c14fe0e8db2cfb14c9bbd1c2503b4a6612586267955aa47b58", size = 450707, upload-time = "2026-08-07T02:12:31.95Z" }, + { url = "https://files.pythonhosted.org/packages/0b/94/20efeee9a01c141e9ac47c397f81679dfda24b32768fc4fff24e76d36c2c/tornado-6.5.8-cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7e2360a0ffbe145eca8af0b19cb7203d79b1a98dd4cccdd6b368f6f49c2e3808", size = 451677, upload-time = "2026-08-07T02:12:33.512Z" }, + { url = "https://files.pythonhosted.org/packages/42/ec/a96ccb8ccf0de2b7bc2c5fa1608a4803735018242e90c4882365a9fd418f/tornado-6.5.8-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:5d242290bdf7ab3151bc1065fdd75c0dcc21cbc7b49f22a4c56329c2d6566d22", size = 451510, upload-time = "2026-08-07T02:12:35.346Z" }, + { url = "https://files.pythonhosted.org/packages/29/b5/93185859245ad3f00e62175f29607346788b696369347f0146e0421286bb/tornado-6.5.8-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:7b94ff0e128fe0542f3bd331fb44d06260fc4ac16881545159f34ef08aad4195", size = 450917, upload-time = "2026-08-07T02:12:36.963Z" }, + { url = "https://files.pythonhosted.org/packages/97/cf/fe33cf062834487d34d1559746a4a12521033c22645b6d74d4bca702e018/tornado-6.5.8-cp39-abi3-win32.whl", hash = "sha256:67832909c4779c64942380cb5f044a5c6163d00831472d80e25e115de9917836", size = 451952, upload-time = "2026-08-07T02:12:38.512Z" }, + { url = "https://files.pythonhosted.org/packages/cb/e1/468ad54333e92ccb62627e62cb88e5fc14a2171daa67ed47b1b8542d5b86/tornado-6.5.8-cp39-abi3-win_amd64.whl", hash = "sha256:11881db6b7c168494be2c2d12e65931451bdf7ee718535418ae1d8855dd5a0ee", size = 452391, upload-time = "2026-08-07T02:12:39.971Z" }, + { url = "https://files.pythonhosted.org/packages/ad/3e/cd5e4f06e34cde33b8ef66cf36aa2b5ad46354cc1af7d2136bbe365fee1d/tornado-6.5.8-cp39-abi3-win_arm64.whl", hash = "sha256:68a7468c7e289f8514d7d664101753903217eff1bb6822c6b5994a0b5f5bcb26", size = 451411, upload-time = "2026-08-07T02:12:41.469Z" }, +] + +[[package]] +name = "tqdm" +version = "4.70.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/21/3b/6c24bec5be5e743ffd99576daa5cc077722fc7d5bbc00bd133fa0c698dc6/tqdm-4.70.0.tar.gz", hash = "sha256:55b0b0dbd97462d06ebee91e4dac24ed4d4702be82b24f07e6c1d27e08cea220", size = 795438, upload-time = "2026-07-27T11:33:15.271Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f9/1c/01bfd571a64e7f270e6bab5e33777debe0edc56759233ce84f27dec92d14/tqdm-4.70.0-py3-none-any.whl", hash = "sha256:7f585706bfddbdebf89daac705b2dfcc16890130727d3197ca62c732b4310953", size = 80184, upload-time = "2026-07-27T11:33:13.167Z" }, +] + +[[package]] +name = "traitlets" +version = "5.16.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/2c/2e/a7fbfe268c8a3b32546930c0297c101d65a4a14c304ad5790a9f478f0e4e/traitlets-5.16.1.tar.gz", hash = "sha256:ed900c2b631aa3a112811139fa97b8d2c3bad5e989656bba4b7e52c7852c18c1", size = 166137, upload-time = "2026-08-03T08:32:36.848Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ad/66/0d785f0bc5e4315a96c989bb476d0fc07ea4f85132550c7b156ca2035d52/traitlets-5.16.1-py3-none-any.whl", hash = "sha256:f775618166caa0396c8e337099240f2bd3e5e917d203b2e6fbe21a58d3cb1f6b", size = 86211, upload-time = "2026-08-03T08:32:34.48Z" }, +] + +[[package]] +name = "transformers" +version = "5.16.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "huggingface-hub" }, + { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12'" }, + { name = "numpy", version = "2.5.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" }, + { name = "packaging" }, + { name = "pyyaml" }, + { name = "regex" }, + { name = "safetensors" }, + { name = "tokenizers" }, + { name = "tqdm" }, + { name = "typer" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ad/2e/ba418680ab901dae269360bb8642485eae04f1af91ee2ebb8bd6f3607305/transformers-5.16.1.tar.gz", hash = "sha256:17b0eac726ddc55e84ac58946063e0c6d37fd000c456b581f050ea0f4e822869", size = 9650542, upload-time = "2026-08-26T14:48:58.789Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0d/4d/ee3728674c0bbc637bb4af88ccf0be697f92e4e90b55f5dc110c44d61b61/transformers-5.16.1-py3-none-any.whl", hash = "sha256:2f2d5b98a5ad3718713653734298fa620754ed683702a635ebb587df3ed29c7e", size = 12080592, upload-time = "2026-08-26T14:48:55.083Z" }, +] + [[package]] name = "triton" version = "3.7.1" @@ -1570,6 +3976,21 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/f0/ac/229b7d4589d2e5937310e72c6d46e89599d16a4a12b479ffa1499fee8eb8/triton-3.7.1-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:10ba85fa2cca4a2fbdeb36bf1cb082f2c252bda55bf9fccd74f65ec5bc647e68", size = 197824404, upload-time = "2026-06-17T19:53:42.772Z" }, ] +[[package]] +name = "typer" +version = "0.27.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "annotated-doc" }, + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "rich" }, + { name = "shellingham" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/16/f7/57713ba479fd405eb76de31404b2c744c289e336b2d999511ebf51e496f7/typer-0.27.2.tar.gz", hash = "sha256:269b7eb9d3c202ca84b4bc9618cb04ebb43d3d4d1e567e4c768607232c05f945", size = 204045, upload-time = "2026-08-28T10:26:55.046Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/dc/bf/205d0004930ede8f542fb58f601526fccf4ae7626075ca1e6c4de5d3d652/typer-0.27.2-py3-none-any.whl", hash = "sha256:b3a5fc4342d5fc8fda8fc3010b1cf117e9249aab7fae800c2eff62fd3842d97d", size = 123130, upload-time = "2026-08-28T10:26:53.752Z" }, +] + [[package]] name = "typing-extensions" version = "4.16.0" @@ -1599,3 +4020,336 @@ sdist = { url = "https://files.pythonhosted.org/packages/ba/19/1b9b0e29f30c6d35c wheels = [ { url = "https://files.pythonhosted.org/packages/ce/e4/dccd7f47c4b64213ac01ef921a1337ee6e30e8c6466046018326977efd95/tzdata-2026.2-py2.py3-none-any.whl", hash = "sha256:bbe9af844f658da81a5f95019480da3a89415801f6cc966806612cc7169bffe7", size = 349321, upload-time = "2026-04-24T15:22:05.876Z" }, ] + +[[package]] +name = "uri-template" +version = "1.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/31/c7/0336f2bd0bcbada6ccef7aaa25e443c118a704f828a0620c6fa0207c1b64/uri-template-1.3.0.tar.gz", hash = "sha256:0e00f8eb65e18c7de20d595a14336e9f337ead580c70934141624b6d1ffdacc7", size = 21678, upload-time = "2023-06-21T01:49:05.374Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e7/00/3fca040d7cf8a32776d3d81a00c8ee7457e00f80c649f1e4a863c8321ae9/uri_template-1.3.0-py3-none-any.whl", hash = "sha256:a44a133ea12d44a0c0f06d7d42a52d71282e77e2f937d8abd5655b8d56fc1363", size = 11140, upload-time = "2023-06-21T01:49:03.467Z" }, +] + +[[package]] +name = "urllib3" +version = "2.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/53/0c/06f8b233b8fd13b9e5ee11424ef85419ba0d8ba0b3138bf360be2ff56953/urllib3-2.7.0.tar.gz", hash = "sha256:231e0ec3b63ceb14667c67be60f2f2c40a518cb38b03af60abc813da26505f4c", size = 433602, upload-time = "2026-05-07T16:13:18.596Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7f/3e/5db95bcf282c52709639744ca2a8b149baccf648e39c8cc87553df9eae0c/urllib3-2.7.0-py3-none-any.whl", hash = "sha256:9fb4c81ebbb1ce9531cce37674bbc6f1360472bc18ca9a553ede278ef7276897", size = 131087, upload-time = "2026-05-07T16:13:17.151Z" }, +] + +[[package]] +name = "wcwidth" +version = "0.8.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/36/57/ed58088fafdf4c55a0ad6bde846502567645424d7ebf325230b9237f4085/wcwidth-0.8.3.tar.gz", hash = "sha256:d128512515fbf4612e0ff21fd6380399210318b7b54a9af59dff8454cf9730eb", size = 1458450, upload-time = "2026-08-28T18:10:06.875Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c4/0e/57f6bb3024a597b2e8ec4aee710ffe62ddc95af2e2bb1ee7a7abdc22c68c/wcwidth-0.8.3-py3-none-any.whl", hash = "sha256:d5b73dba6158a595ec9370350e7f2637bcac8d6c5e4fde34f30fcffb6103a5e4", size = 331669, upload-time = "2026-08-28T18:10:04.909Z" }, +] + +[[package]] +name = "webcolors" +version = "25.10.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1d/7a/eb316761ec35664ea5174709a68bbd3389de60d4a1ebab8808bfc264ed67/webcolors-25.10.0.tar.gz", hash = "sha256:62abae86504f66d0f6364c2a8520de4a0c47b80c03fc3a5f1815fedbef7c19bf", size = 53491, upload-time = "2025-10-31T07:51:03.977Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e2/cc/e097523dd85c9cf5d354f78310927f1656c422bd7b2613b2db3e3f9a0f2c/webcolors-25.10.0-py3-none-any.whl", hash = "sha256:032c727334856fc0b968f63daa252a1ac93d33db2f5267756623c210e57a4f1d", size = 14905, upload-time = "2025-10-31T07:51:01.778Z" }, +] + +[[package]] +name = "webencodings" +version = "0.6.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d5/a0/8fd707bcb776a7be556bad06a2ea5fb9bd519df78ef8e26f70ccf0f38bff/webencodings-0.6.1.tar.gz", hash = "sha256:565f9ad031c702dae404e27a099e3e09186a3ab1b9520f06d215502b651fd910", size = 15001, upload-time = "2026-08-15T14:22:57.549Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/77/c6/040cbc72480d789a5f40d63fb484d3106554c4dfa2d2b70ad5022057750f/webencodings-0.6.1-py3-none-any.whl", hash = "sha256:7fab6269c8bf237c657876b52058ccb182e861518d1c695c1a9aaa8c1c105d5b", size = 8745, upload-time = "2026-08-15T14:22:56.31Z" }, +] + +[[package]] +name = "websocket-client" +version = "1.9.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d8/cb/a5abcc2891249f393827c650c6296660ce40374ac22d99ab9aea41f9d2a2/websocket_client-1.9.2.tar.gz", hash = "sha256:0fcb57545848be86992e128218fd96dd87a6769ffdb1a968dff79632b85604d0", size = 84110, upload-time = "2026-08-31T14:08:40.964Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d5/d2/cc4dc1271e464942db7ee278baae2daa99ee77cb2af744025c04da585a3e/websocket_client-1.9.2-py3-none-any.whl", hash = "sha256:e1a673830a9c7bfa47b1cd3d5e4178f4c9651d80a4eab02c9c23a1c3ec6250ce", size = 95786, upload-time = "2026-08-31T14:08:39.899Z" }, +] + +[[package]] +name = "widgetsnbextension" +version = "4.0.16" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/bf/60/bc7a980fc78837d6ef8f5940cca4cadc433364503a4c4d42e2a7a0de3231/widgetsnbextension-4.0.16.tar.gz", hash = "sha256:adeea0ae78f0856ee4945f413299801b82a0a01416303301f39a704282a37b73", size = 1111094, upload-time = "2026-08-18T08:52:55.859Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/34/95/40e17e20046b7bc820d29d09ae84ec157ec8dd6e6f6cd722626292c31b2e/widgetsnbextension-4.0.16-py3-none-any.whl", hash = "sha256:a31a8774885b96fe825462f5d6496166f0c7cae111195b6465c801d230eb5a4e", size = 2225148, upload-time = "2026-08-18T08:52:53.736Z" }, +] + +[[package]] +name = "xxhash" +version = "4.0.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f6/a5/1386f35da1475fcaeef42581deae73417c6d2a6a0b2d2e8914de18844dcd/xxhash-4.0.1.tar.gz", hash = "sha256:d55bf4ef10eb09b8b6866790e083d26d087d84caa3cc0946ba87c3ca7ecaf7b7", size = 101513, upload-time = "2026-08-17T08:24:08.557Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0e/58/bc81e25cceab76ce4b400441e3a43312bf3887fedbb2e5f80cc5a7dd7f75/xxhash-4.0.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:8b4477edc03091f51f5309406d230851c23cf4822029e3bf40b8df53093fff1c", size = 38473, upload-time = "2026-08-17T08:20:34.303Z" }, + { url = "https://files.pythonhosted.org/packages/64/8d/d95e810c9a2930906f1fbd0e38f77554abb8e042a190aa9cbb24da39e9a2/xxhash-4.0.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:04f9a24de11a6647666d5302fd73d6a5224ce50ddc965fb0bb44cee736e6bd7c", size = 36228, upload-time = "2026-08-17T08:20:36.641Z" }, + { url = "https://files.pythonhosted.org/packages/72/be/ebcded2a32ba664a17a1737a91b6baa298bcda6942acdad81af81660b74c/xxhash-4.0.1-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:6a8c5ce76b94ba49f3be8a8f2611abc6564210702c72ac9e237ca2bebfd17794", size = 253292, upload-time = "2026-08-17T08:21:27.206Z" }, + { url = "https://files.pythonhosted.org/packages/52/2a/72d31d787d988d1130253bc34d249c553f02c9387e7dda789b6d5aa7963b/xxhash-4.0.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b4c8842fb19d78b5e8c2a52baf4c8357658cc56c62bc822b86ce0f942f28e286", size = 276545, upload-time = "2026-08-17T08:20:26.726Z" }, + { url = "https://files.pythonhosted.org/packages/39/ae/048f3b1f283a340bef3697fe5a9d4f10de1696a379af9af6b2352c24d82a/xxhash-4.0.1-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:a43418e1a90b4809a9caf64aeb8b0696e3e1f300a323acc1e6ee2f93ae319fcf", size = 296295, upload-time = "2026-08-17T08:20:15.759Z" }, + { url = "https://files.pythonhosted.org/packages/8e/43/e9a593c81445c8e8d669402edb8264144624e7e5e2406df7d33e3c164d90/xxhash-4.0.1-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b3662719007e059abde7eddacf8517142ba076ddc7b30c807260e57d28c3c191", size = 279966, upload-time = "2026-08-17T08:21:22.217Z" }, + { url = "https://files.pythonhosted.org/packages/f9/4c/29da2b166955a300521c0abd498ad4481916c3743949b106192b781f58fc/xxhash-4.0.1-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:06d7fbd609503c3be5e65cdb6bb2f040d6a98574404e2e1d5c60815c97fff4aa", size = 509850, upload-time = "2026-08-17T08:20:32.731Z" }, + { url = "https://files.pythonhosted.org/packages/40/ff/e39e1900179ce7f0f23e7000d9fc672471a8d05b6b2dc657cb496c8975d0/xxhash-4.0.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:101aa300de6ceef3d9c77569706330d8921fc45dd82bceed2084f1e9f2557a24", size = 261005, upload-time = "2026-08-17T08:20:40.735Z" }, + { url = "https://files.pythonhosted.org/packages/89/79/76ee26720d13219458f4b2ec0b22f539fe2bcb1f83dc22a24be4cda4e285/xxhash-4.0.1-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e4296fcc790876a8b0f297edc83d3b088457b774d8f67b4636807f8a2ec69a79", size = 339620, upload-time = "2026-08-17T08:20:50.371Z" }, + { url = "https://files.pythonhosted.org/packages/2f/c7/56b53252d64ecb2f3a0d283b41033561b1bec9c268095150153b694c2e52/xxhash-4.0.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:57d7fa8f23908d173001c21a9e82bfc6ad997d1b6c270fb121812b7ed158891c", size = 272558, upload-time = "2026-08-17T08:21:33.883Z" }, + { url = "https://files.pythonhosted.org/packages/fc/76/83101a2f2ad3eb6b4b5d571e0aa394a576e3e23121707d507d80197ac385/xxhash-4.0.1-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:85e402dab0f9acd3604539747c6fcc57dc188a18af6ab07eb8189351cd32466c", size = 300417, upload-time = "2026-08-17T08:20:36.183Z" }, + { url = "https://files.pythonhosted.org/packages/34/5d/5be1166ec4fc4bc896e508dc51189a2dad200b373269a430e214fb152693/xxhash-4.0.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:fb59a0dd61fb2ad481c03fda399d78ce57dab6bb62c2c8fdb446a7ba4754b89a", size = 259286, upload-time = "2026-08-17T08:20:21.51Z" }, + { url = "https://files.pythonhosted.org/packages/77/6c/42f6201f13278787c58a6b3a1cd597b47e8665a7d4f68a3440d001c05a75/xxhash-4.0.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:0b20a06454b34f1531fc677c54efe2ecdec691ef9224f7fa919bf2c1363f7ff1", size = 278230, upload-time = "2026-08-17T08:21:47.62Z" }, + { url = "https://files.pythonhosted.org/packages/7f/37/3cb7f149a5a469c628604c33bec6d79764698b315700a4bbf1c6fb15622b/xxhash-4.0.1-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:f7db035447a0ac8959aa230c5d36545ecf9f547413eb1711c0ca6f0ba1418925", size = 329846, upload-time = "2026-08-17T08:35:10.922Z" }, + { url = "https://files.pythonhosted.org/packages/8c/ee/934eb1e11f4d0e95f3828825f8da4b6d59e338235d63edc3d929769262d2/xxhash-4.0.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:34ed93e20bfd98d722b902121643791eeb4b1641871e2dc63d0d4c2d93f187df", size = 477285, upload-time = "2026-08-17T08:20:46.297Z" }, + { url = "https://files.pythonhosted.org/packages/e2/0b/77835dcd7aec970db74f5724c94207ada83b3e2f5e1474ab44b9c8fe5ea5/xxhash-4.0.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f6247f5e23ee94f2557ac9dab738a336f607c6ff476fcf66ca70c3aef5eee15a", size = 257552, upload-time = "2026-08-17T08:20:58.211Z" }, + { url = "https://files.pythonhosted.org/packages/da/6c/a3ce7a1a9c4ec9ad8babba591a996a71c474ff9630c5fb04c8c9d8b995ca/xxhash-4.0.1-cp311-cp311-win32.whl", hash = "sha256:348c8f288dc961d6bbd1985c8152a3ed7a85c95df00e82320f0c5215d922a399", size = 34630, upload-time = "2026-08-17T08:21:53.323Z" }, + { url = "https://files.pythonhosted.org/packages/d9/58/60d2170e8cda0891aab25dcaa74797b420c3c6cde8a5bc8372f17b30c0cf/xxhash-4.0.1-cp311-cp311-win_amd64.whl", hash = "sha256:ac0f291ab6485bd71f33941f9b92771318332a05d505460b41e893a549caadc0", size = 36992, upload-time = "2026-08-17T08:20:41.973Z" }, + { url = "https://files.pythonhosted.org/packages/ac/de/b229a39f9bbbe30cbcf9afaaa8993cb65286715c90a3b058c3769196ae02/xxhash-4.0.1-cp311-cp311-win_arm64.whl", hash = "sha256:72f34834518157a75e7090f328ee7a16c70c804cfc7c694fa069cc888e9fc03e", size = 33289, upload-time = "2026-08-17T08:20:32.176Z" }, + { url = "https://files.pythonhosted.org/packages/26/6c/dc7cffeadd06336cd934947187cd38abb263103bbc552ca0f55fe4ff595a/xxhash-4.0.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:1ee523f51718e41753f04f7102bb4dc55a18d2ea5cbaceef8ec7ca08571bd428", size = 38444, upload-time = "2026-08-17T08:21:54.332Z" }, + { url = "https://files.pythonhosted.org/packages/75/c9/cf736f6db8c3273af18925061572db0d4357818a9ce425f4b5fb0021918e/xxhash-4.0.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:515a822c73abbf6a0b7c70976d9662be342835c9d78b8dc7c023411f39c35dbc", size = 36195, upload-time = "2026-08-17T08:35:13.004Z" }, + { url = "https://files.pythonhosted.org/packages/da/a2/ca1929354b6851529d0148f7f335b5e2b0281f83bab3e19f0896dc579796/xxhash-4.0.1-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:f5d031f35962e5483a613214e61f09fe24ab523062c3646d592dc16c4a217451", size = 253113, upload-time = "2026-08-17T08:20:52.152Z" }, + { url = "https://files.pythonhosted.org/packages/de/bb/542005206af59518bc8d78a210f1e0172217bc53beb32f64a5b632e72b6b/xxhash-4.0.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:da0264844a09b538c894e5eff25313d941deb4dedec2131b98418a71a3c9944e", size = 276525, upload-time = "2026-08-17T08:21:01.886Z" }, + { url = "https://files.pythonhosted.org/packages/1b/df/607cff25dcb0f1d35c3b04493f6ad8471edb03fd4eacbdcc5ceddef1f3e9/xxhash-4.0.1-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:1642907941ee4b75aacc3db688af52ea02ca2305ab22af7ee686ed726b332684", size = 297703, upload-time = "2026-08-17T08:21:57.958Z" }, + { url = "https://files.pythonhosted.org/packages/15/ba/9d2275eea0b9d9c6b02921be23f7588356c60df95c763b25f0e045894d43/xxhash-4.0.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4af350bc3f329970c0e3a59af84a8a30998bf8a9167eb50cd48e59baaa1d7bec", size = 280252, upload-time = "2026-08-17T08:20:47.299Z" }, + { url = "https://files.pythonhosted.org/packages/1d/aa/2299d9f6369e550aef2abb64945e39daa34412725aa46a20d99b74d76f67/xxhash-4.0.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:8ba782ca3bf1e81492611152b9a0d5264971339e95e34d69de0ac2c926be496d", size = 511041, upload-time = "2026-08-17T08:20:36.771Z" }, + { url = "https://files.pythonhosted.org/packages/83/97/31bd8b8279e6935a0719f6910ced15e9d5a2cd554b253f6027ce1b5a1c2c/xxhash-4.0.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:237b8f63a2a0fcfb1ffc06e21dad23add44e6d354b2b014364a1d41e419a4dee", size = 261812, upload-time = "2026-08-17T08:22:00.469Z" }, + { url = "https://files.pythonhosted.org/packages/2d/c1/d180a2da23c105d8e0b02d54f9f5841013fc81c233010ec781e31f1aee4c/xxhash-4.0.1-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:81507a68ba84c55241fb61cce1469f473a5da4205fc8ef6f698e5948eea8dd88", size = 339878, upload-time = "2026-08-17T08:35:17.626Z" }, + { url = "https://files.pythonhosted.org/packages/a8/3d/f584cd3172fe934f0f5a0a3917d0d7ce781f74d794fd43bb72be71c3ef6f/xxhash-4.0.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:5f1ea31d61bcd2cd2f3ec4ca80a64187bbd7948f490b63cf0dcbc6e717b4c1e9", size = 272871, upload-time = "2026-08-17T08:20:56.067Z" }, + { url = "https://files.pythonhosted.org/packages/34/50/2c7956b2b551682e00b9aebce9ceb0a991a131d65f9850c09f5f9760be2e/xxhash-4.0.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:06713a5aaf1d0905c5579416c020c02e42b3ceb931e86c7d3b7fb85403dee3f3", size = 301440, upload-time = "2026-08-17T08:21:35.911Z" }, + { url = "https://files.pythonhosted.org/packages/eb/a2/0739f6482184a8026f4b022718f5f815d352059312e80696825433f0a8e7/xxhash-4.0.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:e8cda075b10bb3917b002c74a04f9e02b7d13b5bf732571404d51c52b11c7329", size = 260157, upload-time = "2026-08-17T08:22:01.416Z" }, + { url = "https://files.pythonhosted.org/packages/a1/25/b31a7bcf1d7d116842812e54f9b944843b4236ea4fa85634e8259f342212/xxhash-4.0.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:c10b9206753b64aa791b35b201485477525b26fdec5bf86e8364c388a03e2592", size = 278233, upload-time = "2026-08-17T08:21:15.674Z" }, + { url = "https://files.pythonhosted.org/packages/db/e8/5293bae090fc6119dbc5fcf5c4cc0e1536394b52d73b7904d033836c73db/xxhash-4.0.1-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:f3e1a44af01b6692de0ec6caba5f0bf93ceb36896e02b7fc00952c6ea7ef39e1", size = 330270, upload-time = "2026-08-17T08:20:51.128Z" }, + { url = "https://files.pythonhosted.org/packages/72/9e/e2ab12d40921f3f34c9317637d65e011aeababf8288356ea8d527de2c1d0/xxhash-4.0.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:c6fc415b5568bd9accc7187f1729a99707330c0a67a8b9f93c1149ed573ed75d", size = 478555, upload-time = "2026-08-17T08:22:04.183Z" }, + { url = "https://files.pythonhosted.org/packages/6d/32/c6148d39a49efa95f39b4cf0d41ef35a487f3b30f6fb1fc8fe8d8eab577e/xxhash-4.0.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:96d8de55029d42251945531f6aa7590c32b48163c66a43bf29d8657d7446a377", size = 258174, upload-time = "2026-08-17T08:35:21.18Z" }, + { url = "https://files.pythonhosted.org/packages/8f/fb/0b04b68d6c5bc71c7a2c344f1287327b67e607f28fbcfd937697caca64b6/xxhash-4.0.1-cp312-cp312-pyemscripten_2024_0_wasm32.whl", hash = "sha256:0163b5d259de23ae9e07b7eabf435ce4704f6f205589a2b154e6af4be985ce1b", size = 20767, upload-time = "2026-08-17T08:21:00.806Z" }, + { url = "https://files.pythonhosted.org/packages/a6/be/476092aba34d1fcd313e1613a3bb3bc692f253d167b54bc90049043b5034/xxhash-4.0.1-cp312-cp312-win32.whl", hash = "sha256:1216f7ba5683f17a89eb7dcb4bc50a0b743dfe1902278d7b3d0786f538118433", size = 34669, upload-time = "2026-08-17T08:21:49.486Z" }, + { url = "https://files.pythonhosted.org/packages/aa/02/f9413d94fae43cec6d1a74c4f12156c6f4a7f5fd50e1d34defebdee3dec9/xxhash-4.0.1-cp312-cp312-win_amd64.whl", hash = "sha256:5c2d525a3afabcd8e3549d85fc7e111fde6bc302d06a1893fe73adb79823415e", size = 37073, upload-time = "2026-08-17T08:22:04.886Z" }, + { url = "https://files.pythonhosted.org/packages/c1/83/6fe93c1b95acf962bc61a246df09dc2dcce895ccfc1080c9f48d0b652b92/xxhash-4.0.1-cp312-cp312-win_arm64.whl", hash = "sha256:86b2b12bec60c678ed8f5cca0258ad93a8928ebddb6ca7732f0875afe1451d1a", size = 33299, upload-time = "2026-08-17T08:35:12.708Z" }, + { url = "https://files.pythonhosted.org/packages/f3/dd/c707286b527722f776e1fb81dd202c45623355ba1a2972337a2a26075b2b/xxhash-4.0.1-cp313-cp313-android_24_arm64_v8a.whl", hash = "sha256:8c9fe122444e129881afd1d4d1c7ac0d3ce2d91b68c2b40173b6025ff1c31f9a", size = 43639, upload-time = "2026-08-17T08:20:54.945Z" }, + { url = "https://files.pythonhosted.org/packages/1b/3b/bb71639a0f95635f61936a6f2653599c4261b645ddddd8d00f9dfe3613e2/xxhash-4.0.1-cp313-cp313-android_24_x86_64.whl", hash = "sha256:1f3346c5c287ac3c7f38b20380f55e8768230e7252af59fabcf3b87ab21e4256", size = 40657, upload-time = "2026-08-17T08:22:12.616Z" }, + { url = "https://files.pythonhosted.org/packages/3c/91/76f3f5385faa9886a36f21fcc603f40b4c0c40ce622382f133160c48b4d9/xxhash-4.0.1-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:4e5141543c7f7fe3087500bbb4ac2845cb528a980aa91f8f1e661e2292ff4a5d", size = 34708, upload-time = "2026-08-17T08:35:24.614Z" }, + { url = "https://files.pythonhosted.org/packages/9a/4a/f48f0e3e1b1ab072979fff2a5be899234e28090883e8b519d0b10215d708/xxhash-4.0.1-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:f09ee747e2a5f876cc5ad56947734811828335e13b403dd8ea1e06d77a9dd48d", size = 35650, upload-time = "2026-08-17T08:21:09.337Z" }, + { url = "https://files.pythonhosted.org/packages/c4/53/b73d7472b196101ad1f57ed0674af3af803ac3e9ec2feadd650a7b262562/xxhash-4.0.1-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:acf52474b2494ef66dc7e0fb6d5e2b50c18313039ad4d275fbf9f9907c804bc5", size = 37958, upload-time = "2026-08-17T08:22:10.616Z" }, + { url = "https://files.pythonhosted.org/packages/d0/f2/024946ad8fa532074af4e4380179da54b7ec9facc8bd0b279ec0fac4e63a/xxhash-4.0.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:1b3cccf75eeb5b01639b2feadb042a8e07889293b7ca72fa2985e7dcb64763cf", size = 38032, upload-time = "2026-08-17T08:22:09.535Z" }, + { url = "https://files.pythonhosted.org/packages/da/e0/934af8d99bb5885711006bec30a691f728edd513d2c40f053f887d8e7577/xxhash-4.0.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:cd878d32f5c6cbce9783f8d6897561fb772211edba9dde49d85672b88ed45276", size = 35895, upload-time = "2026-08-17T08:35:16.53Z" }, + { url = "https://files.pythonhosted.org/packages/20/5f/a8011f6a1558f7ca66d9077bb4f192b1871afcea62fbd5733605d2015755/xxhash-4.0.1-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:41e579025a6e13a99e6d71e39c9cfc621a0dcdbbf19106325e145fa858f2d794", size = 259464, upload-time = "2026-08-17T08:21:06.72Z" }, + { url = "https://files.pythonhosted.org/packages/ff/89/9665a44397547e7a3d58c0942425a976d58dcfd4b538f33220a312bf6912/xxhash-4.0.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:74379a577a9f3b6afbdedf1b90e5c7764467051977f18a326d7d607336d743bd", size = 283949, upload-time = "2026-08-17T08:22:17.003Z" }, + { url = "https://files.pythonhosted.org/packages/34/2d/78774141266457468f29f3f5803092df4db87d8148ba74e4debd041649db/xxhash-4.0.1-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:acb31ecdd1a97fab5cd39a84ee9f515e727d319f796fec48703b8339b9998360", size = 303898, upload-time = "2026-08-17T08:35:27.951Z" }, + { url = "https://files.pythonhosted.org/packages/59/48/d78d22de576b42528bff87c14207de50de4f0b888221a50ff7c9d675d670/xxhash-4.0.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5b7875ac1a2edcb691f27642b8b94b904baa6bcecb7d79c72df2228ba8cb5c51", size = 287241, upload-time = "2026-08-17T08:21:13.042Z" }, + { url = "https://files.pythonhosted.org/packages/4c/de/7a1755a59c59fd46176f293bbdd99e399a6537ba9537fc723aa4d1bf6e27/xxhash-4.0.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4751f1d7eecae6b2d2a773630f1a7248f125c9a92a456694d03c15bceffc9d68", size = 519856, upload-time = "2026-08-17T08:22:15.35Z" }, + { url = "https://files.pythonhosted.org/packages/6f/fb/76580c08e916507859b0f335393cb5fdc59452c4402edbc6bcca6e47e7df/xxhash-4.0.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9a51b061d54cda8b83e62c44458bfbf0dabbef9b975dd9649952ba5076b9f349", size = 268572, upload-time = "2026-08-17T08:22:14.533Z" }, + { url = "https://files.pythonhosted.org/packages/d0/2b/1abde3e07b8f2077a38b4fbfaf764115008bfe0ff03bc7756a52c9fd0607/xxhash-4.0.1-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:74a164e8b63f1e9cf35c9a7809d082b033d1a00e7375d5d814415436e7867e57", size = 344967, upload-time = "2026-08-17T08:35:23.569Z" }, + { url = "https://files.pythonhosted.org/packages/5c/15/80b6ddf0732eef48a8b5fe717398274794392bd6dbe82af38d189d214772/xxhash-4.0.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4f5e5c6df4b703afcbe9352d238a51efd97c3b91fdc3a2052e40fdacb1e7505f", size = 279956, upload-time = "2026-08-17T08:21:24.97Z" }, + { url = "https://files.pythonhosted.org/packages/77/e0/11cbc43c205bf81fad50d69c7319cd1b1ccc01a66cd4fb8766357126c43d/xxhash-4.0.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:d54b8ae068af532c8cdf56abb9e09a60fbe7b10792444c9c27987bb6d3b450fa", size = 307583, upload-time = "2026-08-17T08:22:22.541Z" }, + { url = "https://files.pythonhosted.org/packages/1c/11/cf0bc07feb2791045b6ac075d4bf64f1a5beedef2f46ae70d7104d63a19f/xxhash-4.0.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:1749f0688020209fe0d357ce1e1cd9ec9c6161ed0405ea949d24581c4c43fa91", size = 265848, upload-time = "2026-08-17T08:35:31.298Z" }, + { url = "https://files.pythonhosted.org/packages/d4/c4/7ada4bea2a2795073dfc42d96842930efbe7a0c1857ef4b522e4e90e5d83/xxhash-4.0.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:94ac8a6b8c47951173f0b67bf862bcb971bf24e493b9fbbdb0e010cbbc7d9f54", size = 284409, upload-time = "2026-08-17T08:21:23.156Z" }, + { url = "https://files.pythonhosted.org/packages/3c/f4/d8ce83dd6b99ccfbdadaf2db968ae40334d2e5f73a0297e593b9ddb3df39/xxhash-4.0.1-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:a33de7633c948ab2dc144af370a66e7e7af29b425dcd0f7e4f59689fb9391b53", size = 335921, upload-time = "2026-08-17T08:22:21.802Z" }, + { url = "https://files.pythonhosted.org/packages/a6/9f/f47d8724bd8bc45b395b06b7cacea2dae0d00031af1b707184a091161df6/xxhash-4.0.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:247ece770647c0aef080561fa996f9774b4dadce2d0c42eeb98229db7dcf820d", size = 487023, upload-time = "2026-08-17T08:22:19.729Z" }, + { url = "https://files.pythonhosted.org/packages/57/54/2d87098f3371cc1e42dd04d2285ad56bca4c56667bc501bff02d2b9fd6b5/xxhash-4.0.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a4553d36cc0b7fce1f35ba8a94dfd775aa3ed12f5eab2dc3b46ac75a0706b0bb", size = 264333, upload-time = "2026-08-17T08:35:27.001Z" }, + { url = "https://files.pythonhosted.org/packages/27/b8/93795ca5898ec7d7d0455283ad261c0fc76b4f0c0a69e86233bd7badb0bd/xxhash-4.0.1-cp313-cp313-pyemscripten_2025_0_wasm32.whl", hash = "sha256:87aa309a93bd5ec13f14309a305ff4e9bf74c5363fc46c264c0a22edfd5b0670", size = 20581, upload-time = "2026-08-17T08:21:39.207Z" }, + { url = "https://files.pythonhosted.org/packages/b6/96/926f7335a0a1647952c00421e8da877f658094f61336306c7cadc335c94d/xxhash-4.0.1-cp313-cp313-win32.whl", hash = "sha256:cba763d84b06bda2c38d5185dee76f1b9dfdc0789e96e476d9e10005526d0788", size = 34449, upload-time = "2026-08-17T08:22:29.362Z" }, + { url = "https://files.pythonhosted.org/packages/ea/61/8a5aeb811de093bab3434e77eff0e9461624a1a56a6a93d315d080aab2aa/xxhash-4.0.1-cp313-cp313-win_amd64.whl", hash = "sha256:97b94fb29abf21f5f0bde15f7dbdd3a4aa2dc59f37026adc7b4bee8563b84375", size = 36520, upload-time = "2026-08-17T08:35:34.852Z" }, + { url = "https://files.pythonhosted.org/packages/04/14/97f3c74000ca36955e9cb86f6d270dcd5848b5c65afa623453f5cf2d83d6/xxhash-4.0.1-cp313-cp313-win_arm64.whl", hash = "sha256:08ed8da18cd4fd0a6a5d6a444852d8fbd0e565388a74a4937085451b5f1a312a", size = 33428, upload-time = "2026-08-17T08:21:31.713Z" }, + { url = "https://files.pythonhosted.org/packages/81/0e/ea406a02b561d3275232ccfdb3e29df80f7a65414940e3a15721c7bea40f/xxhash-4.0.1-cp314-cp314-android_24_arm64_v8a.whl", hash = "sha256:af05a3f650220a6c59fa0ad2410249f2d2470a05225807c378fb67458693f8df", size = 43747, upload-time = "2026-08-17T08:22:31.37Z" }, + { url = "https://files.pythonhosted.org/packages/f9/f0/b0c94d61ccf6b5d1f8847b58ef8f923125ac4919ed5bd0eb082750ca7cbd/xxhash-4.0.1-cp314-cp314-android_24_x86_64.whl", hash = "sha256:a6e3653df1a70b8ac4191216324242e4be2bca18c9a7c10934e1bd56dc7ca15e", size = 40749, upload-time = "2026-08-17T08:22:29.431Z" }, + { url = "https://files.pythonhosted.org/packages/2f/c5/8085881a538983be0fd1c865d5df236242fea496044e2c8ca32b9f2ba39c/xxhash-4.0.1-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:4528cf80ebbbf57d40edfb31521ae265daa6dd636d615b1cf0ac86209579e59d", size = 34734, upload-time = "2026-08-17T08:35:33.68Z" }, + { url = "https://files.pythonhosted.org/packages/d3/94/8803d13c968fc75ca434eea991d29ac5fd8a36b4afc9a6a9803c53933db4/xxhash-4.0.1-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:90cb2a1c9cc503a054a19612b48ff6e8e47805f618bdb3224a07568aad03a37e", size = 35671, upload-time = "2026-08-17T08:21:48.322Z" }, + { url = "https://files.pythonhosted.org/packages/85/d5/ad91d7f0fd294190d37c08236fe661f5c4e3f83dcd1a121877a2e64681ce/xxhash-4.0.1-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:a949b072ea59c6eca0811ccd9e95133cc50d2afda8d464b5b077c78f78efa269", size = 38094, upload-time = "2026-08-17T08:22:39.763Z" }, + { url = "https://files.pythonhosted.org/packages/89/f4/2b7ebdc1869caca5f02c4cba8379b631050d3c3d4adb9187e4dc1a6b8d3c/xxhash-4.0.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:79a3203aadf39637869dfea1185227d8452844d78b837e54fb1117b4d34ba5c3", size = 38244, upload-time = "2026-08-17T08:35:38.081Z" }, + { url = "https://files.pythonhosted.org/packages/90/9d/f66cf6935f528e575f1ae4d6560d376e7587569747186f4fae8777cadc1b/xxhash-4.0.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:d9f3848ffaf010bdbabdbf4c25641fa258b6227ff27bc74a4d06edef521a4873", size = 35904, upload-time = "2026-08-17T08:21:37.358Z" }, + { url = "https://files.pythonhosted.org/packages/07/29/34569d7b482f0dc060074faafd163c588f915cbc3e3e218f1ffd8a3ad340/xxhash-4.0.1-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:9283d9dd6b44acad35118e2976fc763a065509e4118debdb61916ec322ed17b9", size = 259595, upload-time = "2026-08-17T08:22:38.153Z" }, + { url = "https://files.pythonhosted.org/packages/ce/d2/a2370acfcd48732cf5c2b87f06cfbf7fa51c0ce0dd736bde42939eb9ebf7/xxhash-4.0.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1c7c642a0f79c3e3cf2965475507574d3d1a50ec71060039d60cb87358667cb2", size = 284279, upload-time = "2026-08-17T08:22:36.396Z" }, + { url = "https://files.pythonhosted.org/packages/08/15/17d33c24e6c4a1c0b9ddc5584f0c25d51d48b34bacde1416a2235a19db4b/xxhash-4.0.1-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:96dedccfb09a73a25751053a183159b88f4ee75f388df8166040c152ac0531c6", size = 303973, upload-time = "2026-08-17T08:35:39.22Z" }, + { url = "https://files.pythonhosted.org/packages/ec/e0/4ec0d69ad5738729098a61e631b7ed2df22a922b0e03014b597c72bd863d/xxhash-4.0.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:81664268dba92e037b740ecf37fa02f1cab4a391f93f28e35792b3341c60648f", size = 287535, upload-time = "2026-08-17T08:21:52.158Z" }, + { url = "https://files.pythonhosted.org/packages/0f/8b/4f9b17e7a9eb71c65548ecddd9c18b84e3c18ca41c4d436ad2a3000d3f7b/xxhash-4.0.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:839f58c5bd9989875be0fd28446dbf32cace2c2cd8bf2f6762acdc38a95cd1aa", size = 519257, upload-time = "2026-08-17T08:22:43.272Z" }, + { url = "https://files.pythonhosted.org/packages/68/35/3276b3e743b8ddbed9c3f71c76d9dd6a75d72aa4e678b1447b635cfd92e0/xxhash-4.0.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ffa44b4c7c5d0ffa31356b4428659516c0e47647825c74079a296b3857b6d99d", size = 268190, upload-time = "2026-08-17T08:35:44.985Z" }, + { url = "https://files.pythonhosted.org/packages/08/d4/f1555de3c96721320930dbb7988c8482d82b85970076aba1a8d40e83ad43/xxhash-4.0.1-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e681a6fc7e4f715252b9b5acfb30536ec7dd1f75033a32dc617e6fa95af1a3fd", size = 345553, upload-time = "2026-08-17T08:21:41.025Z" }, + { url = "https://files.pythonhosted.org/packages/ac/98/c28908f27007087b61139d290f908dd827ffd40b88af0c43f9e1a1a7ffd5/xxhash-4.0.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c6301d92545c591ad31c3e050aa40a5f8a4c16413f1f9e6f9322c6f0f9d2b736", size = 280499, upload-time = "2026-08-17T08:22:52.236Z" }, + { url = "https://files.pythonhosted.org/packages/a9/76/3ef57622c65816348f8196273485baab4752aae064959901e85cd867e067/xxhash-4.0.1-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:6efb8f21cc136c79b3e5bb747c8682d37916fb202cdbbc32182de5c4e47f821f", size = 307211, upload-time = "2026-08-17T08:22:40.815Z" }, + { url = "https://files.pythonhosted.org/packages/8a/4c/5804504bbc808968e57d6a50286dd8f8cc06e0ddd6e4ab4b1dc89ae42f35/xxhash-4.0.1-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:760de77279e9cf9c81d012ce0705cba13afccee9b09c480f17d778c8c5cefae8", size = 265865, upload-time = "2026-08-17T08:35:42.727Z" }, + { url = "https://files.pythonhosted.org/packages/aa/ee/8572fdfd70e7aaaf150af899871c2cc0bb88c3295ca82172a31e04ca5168/xxhash-4.0.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:a16a3fa6936e36bb1414d16a6bd012c9033e5161b68b426805b61d895392437d", size = 284545, upload-time = "2026-08-17T08:21:56.965Z" }, + { url = "https://files.pythonhosted.org/packages/c1/f8/6eadcca0904660c848b466524e82a233d16c9d2d5258433aaf3546142d86/xxhash-4.0.1-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:9c3c4b9aa9a27196b921197f7daf9e6c1412739df06a99cfa6e923879362eff6", size = 336022, upload-time = "2026-08-17T08:22:46.346Z" }, + { url = "https://files.pythonhosted.org/packages/27/df/4aa107b81602d6d6d09ab5a607c530d2d3a6b28e2e9a59b01875bd877c54/xxhash-4.0.1-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:863f3d3b44110f7243e86cf994aa5c5d88f2348b6e84ab4402fadadfbf9f7da7", size = 486671, upload-time = "2026-08-17T08:35:49.016Z" }, + { url = "https://files.pythonhosted.org/packages/45/b7/b2bf9b5301e9cd5f2e335fea8da0f5cf209a6594cb1fe77754774ad4a6fd/xxhash-4.0.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:63aa52659bc32bb9bd7cb5caf523b4d14429a477762cfac886132d687c1f80fc", size = 263744, upload-time = "2026-08-17T08:21:56.165Z" }, + { url = "https://files.pythonhosted.org/packages/0b/96/35b1c02177ae26234892c2310fb4822ba62411acccbf425ab8f9fd99354a/xxhash-4.0.1-cp314-cp314-pyemscripten_2026_0_wasm32.whl", hash = "sha256:67e57b834e07ed973cee7b6da1548ff28a56458d77696fd2a5f397f340694848", size = 20563, upload-time = "2026-08-17T08:35:11.924Z" }, + { url = "https://files.pythonhosted.org/packages/51/c2/a06300b165fbd6b0cb4a9742987f2e997a9f447ce3bf7c6ac97b862ce62a/xxhash-4.0.1-cp314-cp314-win32.whl", hash = "sha256:b6c1f9c59bbe593f88a0aad30be4150f15bd57bd64efb95feeabcb8e563f1ecd", size = 35151, upload-time = "2026-08-17T08:22:44.283Z" }, + { url = "https://files.pythonhosted.org/packages/06/96/c5b37296b78f80fc97124c0fee0c7bbd1bdb6f3b18bcd8748bb113b2d8fc/xxhash-4.0.1-cp314-cp314-win_amd64.whl", hash = "sha256:da544672efd9ad76077928a3e6c5d894e52ce82d3bf14002db4a1bf17d1a36a2", size = 37156, upload-time = "2026-08-17T08:35:46.551Z" }, + { url = "https://files.pythonhosted.org/packages/ce/5e/248f9cd169c2fb62236bedfba246d213bce728f74901e99047e3f3c55875/xxhash-4.0.1-cp314-cp314-win_arm64.whl", hash = "sha256:d0d24a4f3fb63852cd09af46ae4b7a4d00cc8b8615a046dca543786e728d1056", size = 34379, upload-time = "2026-08-17T08:21:59.446Z" }, + { url = "https://files.pythonhosted.org/packages/58/c8/db1d37c0da0324d0298f6abd931ca1d4736e049d9f2081230a8421da74d2/xxhash-4.0.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:349775ac30372b344d2338b2a168c0a1312a644194da25b8bec476d55761a128", size = 38656, upload-time = "2026-08-17T08:22:49.119Z" }, + { url = "https://files.pythonhosted.org/packages/c5/8e/e18998ec465fb977bc74272e5bf3c2e886c13b014cbef916cd607802c709/xxhash-4.0.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:43e5f9169e73d0f0db33b5f6b8554bcce69ac278c966daf83d5eb4eb2f13829f", size = 36306, upload-time = "2026-08-17T08:35:52.853Z" }, + { url = "https://files.pythonhosted.org/packages/ef/1a/b83f86f8a987a3cbcb7e005a6824ff64aecae35abc1395a0d44ee16c3319/xxhash-4.0.1-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:4a252fb862b0ae2590587e625f47a0e03da05cf0205e8830b67b6596c06038b1", size = 273729, upload-time = "2026-08-17T08:21:58.833Z" }, + { url = "https://files.pythonhosted.org/packages/02/4e/2db15aa8508e0cd5b632927a53b98234f24039ea65377e6cf996c06d2d4f/xxhash-4.0.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2df3ca8757dc381e75e90a4d7995a6324f58a923c7145220a7b2c0231f66fddc", size = 301083, upload-time = "2026-08-17T08:35:14.113Z" }, + { url = "https://files.pythonhosted.org/packages/26/94/ed759787ffe802bd8e31cfcdad3755cbeca2dcdafd2f790cd6f25d195199/xxhash-4.0.1-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:bfed61996d618eb90d6eaae0178002e3466a28b06bfc557a7a3a7266378d8c5a", size = 312745, upload-time = "2026-08-17T08:22:52.232Z" }, + { url = "https://files.pythonhosted.org/packages/45/7a/f64b4a4cc8b51e950709207f55f7f56ae9c5af6631dd31d7fb443312418c/xxhash-4.0.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9761ff4a0ffa583fe850731ad24fe82c88cccb7a2294727db0955f3279a4cb3f", size = 301419, upload-time = "2026-08-17T08:35:50.143Z" }, + { url = "https://files.pythonhosted.org/packages/a0/71/bac313b8de073569b8db3152044a7cfcce87a3fa9698c18fe9f914dee6b1/xxhash-4.0.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:edccc2ec58435a580f96a48a3ccae8cd0a480824119165dd90108718ad81ae6e", size = 534485, upload-time = "2026-08-17T08:22:11.515Z" }, + { url = "https://files.pythonhosted.org/packages/b9/0c/16b5e419f24e59507ee05626d2bb0deafdb03f9f27783bc0785a9849602e/xxhash-4.0.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4741d42d59e4e5fa1a86c17ab9c27dc8ea459c700d91b6742fdb9138d9a516cb", size = 279605, upload-time = "2026-08-17T08:22:52.934Z" }, + { url = "https://files.pythonhosted.org/packages/5f/55/5787dd6e2d8d5b61256a5039f6b18c2193c7c1de4a2fd2413288d0d9c604/xxhash-4.0.1-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:440c401e146ce64bdb3beb8ff0c84677b6f21307c28a34779071cecee5d4d70c", size = 358924, upload-time = "2026-08-17T08:35:58.164Z" }, + { url = "https://files.pythonhosted.org/packages/f3/68/89be41991f3b0a2e91f940bdf3128852c3ed571cf560d98ad0f67024afe4/xxhash-4.0.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:5b7979f71d06ae45a769de0699900a246d8cb632db1e8bfdc79ec019063a503c", size = 295305, upload-time = "2026-08-17T08:22:13.683Z" }, + { url = "https://files.pythonhosted.org/packages/e6/5a/52ff0a0cc361aad393ff9a46ffe3aabbcf9c03d6c8f2612da7d553048276/xxhash-4.0.1-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:62198213fc3e0c56e567894b318ba45834e007d065f84ba6dc9165d21546fc56", size = 320228, upload-time = "2026-08-17T08:35:18.946Z" }, + { url = "https://files.pythonhosted.org/packages/0f/b5/91c60ff22c7f6cd5f6d7a5bad5a2cdcb4c33987dfa50bf13f0d856279b2e/xxhash-4.0.1-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:b3bece52127ac20044311ee73567f9f0893b5de64f9028aecc90cc740cfd525a", size = 279414, upload-time = "2026-08-17T08:23:03.212Z" }, + { url = "https://files.pythonhosted.org/packages/b9/94/9685954804d47d0390871a64bec606a0d536406382d71a784df3a5883fb4/xxhash-4.0.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:a865d2d470220e659220fdb59d5b6c4422802d8d6098e1324bc4d12444798914", size = 297594, upload-time = "2026-08-17T08:35:57.881Z" }, + { url = "https://files.pythonhosted.org/packages/89/62/b67ac9412907b7a07a2a0c08c3440b9e4480231a7b3de0767e87011e4564/xxhash-4.0.1-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:8580aab306888224074c7edeec734de0c3c5ccde65b2da4e6c9a5e28f7c0a1bd", size = 348526, upload-time = "2026-08-17T08:22:18.571Z" }, + { url = "https://files.pythonhosted.org/packages/37/ed/6723cc49a9f567d52d01fd7c1741b0f2e3a13e71d15f7ac49d753a20c115/xxhash-4.0.1-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:2d52dc7c33c1b83082b707f6b7814dc76d2faaa2ea62bd9c5fab4b36f83c087f", size = 499307, upload-time = "2026-08-17T08:22:56.52Z" }, + { url = "https://files.pythonhosted.org/packages/fd/2e/7b10e101ab988d93b791023be7191d7661271d6ab31ac082276b9091042a/xxhash-4.0.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6a9f98af872355e0c02439e48583958eee00e60b928bb20476460d9d40cb7b4e", size = 274989, upload-time = "2026-08-17T08:36:01.834Z" }, + { url = "https://files.pythonhosted.org/packages/9b/8d/7eabcc8d29cce40621443cff24c07d7306ef574b8956c47ac59f21098005/xxhash-4.0.1-cp314-cp314t-win32.whl", hash = "sha256:a14578102a6081465aec9cf73c76c3cd3f79f0709bdb3b8ae7ab0b54c9d8b089", size = 35482, upload-time = "2026-08-17T08:22:32.336Z" }, + { url = "https://files.pythonhosted.org/packages/ca/89/2a4268e1971f63038b79fb75e3b9c8de942cd77acabbb0c5625352a31940/xxhash-4.0.1-cp314-cp314t-win_amd64.whl", hash = "sha256:c57963970d359a72262f7fe6be88f945e2334d4bc41462b7f08c37b0abf35ca6", size = 37490, upload-time = "2026-08-17T08:35:22.475Z" }, + { url = "https://files.pythonhosted.org/packages/90/7b/950ecab1fe4cf421d0a6211ddd9a0ac82e39e55c45a111ceb90953dc6c9a/xxhash-4.0.1-cp314-cp314t-win_arm64.whl", hash = "sha256:b659fad79c99b0238c7ad7e9d7dbf4eebfea9097c2dba65fa0a4d18a25b29a2f", size = 34596, upload-time = "2026-08-17T08:23:10.001Z" }, + { url = "https://files.pythonhosted.org/packages/c4/03/7dc3b85fac10751613bfedb0e120734e0e8710054abad3f931e9d3843a14/xxhash-4.0.1-cp315-cp315-android_24_arm64_v8a.whl", hash = "sha256:5adf927dca8c47fde7e683fe69efdd81bc865c4db1fb6bb00b391e2b6185207b", size = 43749, upload-time = "2026-08-17T08:36:00.47Z" }, + { url = "https://files.pythonhosted.org/packages/a5/55/bfac071c5b1c6d6a3d48ab1ab96a15e958a1d7061f4afc97804292d87264/xxhash-4.0.1-cp315-cp315-android_24_x86_64.whl", hash = "sha256:c30dd1af66a820820398b26e0d74e7a9aa43cae705924f23ed828cd8e5c26c3d", size = 40758, upload-time = "2026-08-17T08:22:30.209Z" }, + { url = "https://files.pythonhosted.org/packages/79/87/49a260e685d1a74c56a69432a8ee0527ddcbd684a3c51f87edc3b75639c5/xxhash-4.0.1-cp315-cp315-ios_13_0_arm64_iphoneos.whl", hash = "sha256:1bc591533fc975614f7e13594daee76af96b8e1fbcf8de76c8773858fa9e7cea", size = 34788, upload-time = "2026-08-17T08:23:09.014Z" }, + { url = "https://files.pythonhosted.org/packages/6c/ef/50d72ed2170dae872e1c0fe333d0908e0a2afbffe74c5c9037d5406a4b89/xxhash-4.0.1-cp315-cp315-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:567cbc630302a46a8ecfd943b309ccf5372bb3718f1f3762d452df30f033bcf0", size = 35746, upload-time = "2026-08-17T08:36:05.557Z" }, + { url = "https://files.pythonhosted.org/packages/66/f0/969deaa2bab3bfd5ad5b023442124d2255b9961eef6f797ec74eb8683bdf/xxhash-4.0.1-cp315-cp315-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:e998cb3685b92101ec5de0fb4d9485cf01e50bc418211955c55d98064664cf4c", size = 38098, upload-time = "2026-08-17T08:22:36.906Z" }, + { url = "https://files.pythonhosted.org/packages/86/aa/45ed7d7b8d7b66202a47bf8ff3b77cea28d2ea54dfcdd202b4cfe043e3dc/xxhash-4.0.1-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:c3074db513c81f764053e3da079312ecf85a50d8350c71f4cc0105d9662a9e6c", size = 38251, upload-time = "2026-08-17T08:35:25.774Z" }, + { url = "https://files.pythonhosted.org/packages/f1/9d/45e7520a7856e13800a5dc8cd038d34c6372429465b163af0c5722f16918/xxhash-4.0.1-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:3088dadbffa33c29e0518578430a7dff2e901a212e487aefa5faaa0dc06dad34", size = 35986, upload-time = "2026-08-17T08:23:25.854Z" }, + { url = "https://files.pythonhosted.org/packages/9e/0e/5ad466e5fea18c9f9bdc5828c0506f62190061b4a1b0e688aa54969d0a9e/xxhash-4.0.1-cp315-cp315-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:1b50223d92df94d54e1a31469335a2c74b16692e6c1cb726f1e6949514458706", size = 264609, upload-time = "2026-08-17T08:36:04.229Z" }, + { url = "https://files.pythonhosted.org/packages/aa/cf/8f269f85217e3dbd45e31e25e46cc26f3aff0e159ef05d228b4b982c778c/xxhash-4.0.1-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:427b62d62d4f967fbb10b82a3813e4875c2a6e7e7634739f17265b650c7f65a6", size = 285910, upload-time = "2026-08-17T08:22:38.589Z" }, + { url = "https://files.pythonhosted.org/packages/ca/30/2fc1a16ee0f9501d074b798ebfae52e24fa602c7117f5c4b81de71eada72/xxhash-4.0.1-cp315-cp315-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:c6370189e8e66b7e608f533b939a9de092ddca6cce084ca0d3d414d2ed5b5d59", size = 306566, upload-time = "2026-08-17T08:23:16.895Z" }, + { url = "https://files.pythonhosted.org/packages/e0/a7/08375cf2b997e1903663fe7525c5973b1987a4f8ad2b8d47463e9143f2ee/xxhash-4.0.1-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ec1a470c6db94ac4589c203921e89ac1bc13e796a8b1784d8135e1893559cd3b", size = 287978, upload-time = "2026-08-17T08:36:09.296Z" }, + { url = "https://files.pythonhosted.org/packages/b2/e5/90a7b404c11add9e53a497d06236152852490c3b2f21e468d97a58f26afe/xxhash-4.0.1-cp315-cp315-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:37f667dee0f867c42894b34e2a6fe26bf195c0ea4683d9d2b713db023f242c3a", size = 520098, upload-time = "2026-08-17T08:22:41.565Z" }, + { url = "https://files.pythonhosted.org/packages/11/02/7fba10b1b17eb46308f09cc0a4ed513d74dff16b1e22a1c439f011c77129/xxhash-4.0.1-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f18732adcc271741bd651c3e56fa519d8a237d2cccda01fe3afb226bf87f783b", size = 268273, upload-time = "2026-08-17T08:35:29.043Z" }, + { url = "https://files.pythonhosted.org/packages/54/49/c21b228877357a3be43eeeaa22182ad1685796f415390ada475922c084e4/xxhash-4.0.1-cp315-cp315-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0b42a5a26607e4b2409fea174773a66f2dff9dfdbf2c1a851bb7b804e2c97535", size = 350164, upload-time = "2026-08-17T08:23:29.494Z" }, + { url = "https://files.pythonhosted.org/packages/00/3c/c15bb4aa33d94b78a5553b52e7fa1070565f0199925aeadec3871de20ce9/xxhash-4.0.1-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:99166cc98637e8bf550cda2aab07f4f1d5f899c45fbd721801aeabcc9d404824", size = 281975, upload-time = "2026-08-17T08:36:08.139Z" }, + { url = "https://files.pythonhosted.org/packages/18/7a/b1d0388315fe7752b7725b68a912667526a1dd48ed492fcc031ac03f4b52/xxhash-4.0.1-cp315-cp315-musllinux_1_2_armv7l.whl", hash = "sha256:6cf633df84d80a1668fcf61e330791dae46825e395549e7d34f376411e75088a", size = 307872, upload-time = "2026-08-17T08:22:42.206Z" }, + { url = "https://files.pythonhosted.org/packages/b4/a1/037cb2dd8cf725c9565dfe3712b2915c0e0276a9154913dbfcbcecbeb672/xxhash-4.0.1-cp315-cp315-musllinux_1_2_i686.whl", hash = "sha256:e259bb7e1e2d8de6b35f430f5c7220b1c0ebf3962d1ba7ec7545980d5931edb8", size = 268241, upload-time = "2026-08-17T08:23:23.997Z" }, + { url = "https://files.pythonhosted.org/packages/c6/a9/67c44422d0ee082169b238ce24bd2796b82d7c21ed953471365df8c508d8/xxhash-4.0.1-cp315-cp315-musllinux_1_2_ppc64le.whl", hash = "sha256:704381264b36a18b9c62ecbabe2e71d0fc58c77c129c15355c989b10bf05b6b0", size = 284970, upload-time = "2026-08-17T08:36:13.476Z" }, + { url = "https://files.pythonhosted.org/packages/7f/d0/254a5f51c4014cacc77a26f321372338b924f54e89efb730164ee336d850/xxhash-4.0.1-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:e90b4bcf1d9eb1010fdaee7c9209fb667e74c0684f3ba17f9032bd7319da90c9", size = 338074, upload-time = "2026-08-17T08:22:51.166Z" }, + { url = "https://files.pythonhosted.org/packages/64/03/f21c4830118d72ef3a958ce8bf2152f49e0d4cf200907616c9be6caf372a/xxhash-4.0.1-cp315-cp315-musllinux_1_2_s390x.whl", hash = "sha256:a65785e653573fcd1e33062760ab4c3c3440e8e910765018e4b6ed4ad07b54a0", size = 487626, upload-time = "2026-08-17T08:35:32.768Z" }, + { url = "https://files.pythonhosted.org/packages/45/1f/268a689d741d7da649317eb4ce41760140beb4179aaf43a7216fdbe8100c/xxhash-4.0.1-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:e3996ff9b6f99180357024336bf5749a8ad6476a9a2523e535c5212b995b12a2", size = 263852, upload-time = "2026-08-17T08:23:41.871Z" }, + { url = "https://files.pythonhosted.org/packages/a7/f5/adaf8101cd7f143191a0b390600294d83924b32cb13770fde8803dce27a2/xxhash-4.0.1-cp315-cp315-pyemscripten_2026_5_wasm32.whl", hash = "sha256:99054b838b74d8d3995ea0d410976ae967c46207ae22d6ddfc535e809197dab9", size = 20569, upload-time = "2026-08-17T08:36:11.952Z" }, + { url = "https://files.pythonhosted.org/packages/ee/2c/56a5eb8c993420fc07114c08f447a2b66ee996510b4764cb368b9b44c9f0/xxhash-4.0.1-cp315-cp315-win32.whl", hash = "sha256:6c45258a37fc22721395c09927cb982d3e7a83607cab15be7e2416501bd3a330", size = 35145, upload-time = "2026-08-17T08:22:50.038Z" }, + { url = "https://files.pythonhosted.org/packages/67/c7/65f210db43e62157d0fef3b4d4d7b394821e7733c8bb4ece49f91410a725/xxhash-4.0.1-cp315-cp315-win_amd64.whl", hash = "sha256:0ab851b45c70d4992be7cdeeee16f97a0b677408c758c4b1efb1cfe8030bfd37", size = 37161, upload-time = "2026-08-17T08:23:32.438Z" }, + { url = "https://files.pythonhosted.org/packages/33/ae/1a641d1d60ba219756d9ebe907ff0ecf4445adcf4fa96f6e3da57b91d439/xxhash-4.0.1-cp315-cp315-win_arm64.whl", hash = "sha256:a5b21b42a01a343096a1c018d35e9b7aec9c7065dda53ae8da071e37478b2cea", size = 34378, upload-time = "2026-08-17T08:36:15.912Z" }, + { url = "https://files.pythonhosted.org/packages/48/7f/7698b320b251806d1249e513922a626f19027e104c829a611272250350eb/xxhash-4.0.1-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:44ab12e8cd17d4f001769f00ad465208b4bcb897ed29e65f058f74466b57a98f", size = 38610, upload-time = "2026-08-17T08:22:55.203Z" }, + { url = "https://files.pythonhosted.org/packages/c0/3d/436497e775b647b3b3e9a4ffe8c76c59fa4aa7a9fab6447cb59acf1b50ea/xxhash-4.0.1-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:45e88111ebe331de478ef8d4293efbe88f3cf8b863386c9a2357136b838e1af0", size = 36378, upload-time = "2026-08-17T08:35:36.18Z" }, + { url = "https://files.pythonhosted.org/packages/e3/d8/17a4f8182b9257898aa2a77c2a45f70233eb8e50681a280e8e09d2ee76e9/xxhash-4.0.1-cp315-cp315t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:bf430c587f447a554c53768ad76b9846fe7c5632180ef6f69c4fce8b0552fbd0", size = 273559, upload-time = "2026-08-17T08:23:51.075Z" }, + { url = "https://files.pythonhosted.org/packages/83/28/121bd5a5c5adb88e0da772c7bef61964cf9da92956a7a237c7d24c4351b8/xxhash-4.0.1-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:adbd48b30e3f82c89fb2b3e6a87cdd28d113b190a5ed0ee2dee286323ee9a621", size = 299133, upload-time = "2026-08-17T08:36:14.731Z" }, + { url = "https://files.pythonhosted.org/packages/11/8f/57c7b6e04642ed738a0d08a31bed7fc63fdacb661d665f98739cc9751b62/xxhash-4.0.1-cp315-cp315t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e71b34978e77868cbf2d18c5206a4603f9c644dd7181bec5643bd40141d3b8c5", size = 314527, upload-time = "2026-08-17T08:22:54.224Z" }, + { url = "https://files.pythonhosted.org/packages/8e/18/42793917dbab0ea1ff71458aea4875e17a7263f2797b798af048dc81e867/xxhash-4.0.1-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:488ca5c5e28ef56ec4bbb12f835b3f1cbecc5f3510062e70117bc6594851932a", size = 299199, upload-time = "2026-08-17T08:23:36.864Z" }, + { url = "https://files.pythonhosted.org/packages/37/60/51dc92443923d8e908d5614f1145d8d696450f9d6c8f1abe243c6f2a0222/xxhash-4.0.1-cp315-cp315t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:421b94f3ba7067958d02e38960d987756347aa150df06df11aa68ae1af78c619", size = 531967, upload-time = "2026-08-17T08:36:18.66Z" }, + { url = "https://files.pythonhosted.org/packages/88/c5/d0de77de09661fac71742c4155b1cd65e274f7cc277819d702b6c8ff2db5/xxhash-4.0.1-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f33cf0baa91eccd2cb7b62bf00f10c2264ef578b71dd33a12962e71a36eb4d32", size = 278764, upload-time = "2026-08-17T08:22:58.15Z" }, + { url = "https://files.pythonhosted.org/packages/08/9a/589929c655aba1bfb2c41ee03e50eec1547c39c3042a66bda9c173a9614b/xxhash-4.0.1-cp315-cp315t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:23a4376b4a3183cb50d4d2a3179f887a7773cc695eb2c908e551bec3221b8c60", size = 359876, upload-time = "2026-08-17T08:35:40.35Z" }, + { url = "https://files.pythonhosted.org/packages/3e/a8/c1d8c94d54d91db2215565f4b4151c1593af3e6d27ac4c00fd1e8d714a02/xxhash-4.0.1-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:38c3d22129a6958846a3098d68bc8e661704461c0be4793ae28836e4690c8478", size = 293548, upload-time = "2026-08-17T08:23:54.951Z" }, + { url = "https://files.pythonhosted.org/packages/8b/67/85d8abca94508a4dd10561d9dea3e6e68843c6986dd6d9c1b3729c8622e4/xxhash-4.0.1-cp315-cp315t-musllinux_1_2_armv7l.whl", hash = "sha256:87cbdec1a7dd930079671a60b249f3ca4e773e6fbd0676e21e36fdc9dd0f3b00", size = 318780, upload-time = "2026-08-17T08:36:17.623Z" }, + { url = "https://files.pythonhosted.org/packages/1b/16/2b920ed456b9cdcfc99ddc20c3afe42f9f807ee5850773c12fd891f3c08d/xxhash-4.0.1-cp315-cp315t-musllinux_1_2_i686.whl", hash = "sha256:6cbf4e21ef0890804b5bb9ad25c48f9c127758d7f6c66bef374efcacc63c738a", size = 277582, upload-time = "2026-08-17T08:22:57.156Z" }, + { url = "https://files.pythonhosted.org/packages/fa/cc/5811b5997aebb8452047f5800d32fc50eaa29d0ba08d4e426f84450b9c2f/xxhash-4.0.1-cp315-cp315t-musllinux_1_2_ppc64le.whl", hash = "sha256:c101180495cb4ba3617b279a944345c53a5e73b0c150053d1fa8d8af32de9579", size = 295116, upload-time = "2026-08-17T08:23:40.868Z" }, + { url = "https://files.pythonhosted.org/packages/2d/dc/c2f3f9c2f4d6aadb79f17a9f1c9a7ee82638cc873680da044cf29537d2ee/xxhash-4.0.1-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:c0e6ccc2b19ec8a726b2e26062ac71ea63e15500d6bf85910e42481844fdffc1", size = 347065, upload-time = "2026-08-17T08:36:21.618Z" }, + { url = "https://files.pythonhosted.org/packages/a2/4c/750cc642c92252e10772ec09e1a1d995581ba4c3ceb24f6e2d57c7ce47ca/xxhash-4.0.1-cp315-cp315t-musllinux_1_2_s390x.whl", hash = "sha256:8bcba9456242ebf180a04d9443812fd85ffe6bd12bda464dd116fcece8886ff3", size = 497208, upload-time = "2026-08-17T08:23:17.88Z" }, + { url = "https://files.pythonhosted.org/packages/6c/2d/58693cb13d6395f39b6b9bb40c5e0db53a5df7c9fce805aa7e792f64a1a5/xxhash-4.0.1-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:83b8c2013edb5dc1f9e7268b6496130705bc48d79c86bb8817b3d210b81a5513", size = 274338, upload-time = "2026-08-17T08:35:44.062Z" }, + { url = "https://files.pythonhosted.org/packages/4a/08/9aa9787586d9b3e92d63343ce7dc24f0f445fd9e74ff5d6e85dd82233df5/xxhash-4.0.1-cp315-cp315t-win32.whl", hash = "sha256:aa6ccc7f31018484d652cf52db020003433f3c9fa83189c028bd807d2adde503", size = 35471, upload-time = "2026-08-17T08:24:05.795Z" }, + { url = "https://files.pythonhosted.org/packages/f0/ab/4615789c333bee331ac417885c50105715eeb8244bfc68d2bc37dcfd63ca/xxhash-4.0.1-cp315-cp315t-win_amd64.whl", hash = "sha256:daade8936c4deaaf7b01561324ce438ba4f885d717e9adc62b4d67212ad7d7bd", size = 37488, upload-time = "2026-08-17T08:36:19.929Z" }, + { url = "https://files.pythonhosted.org/packages/fb/81/49f718beb0c55d0411bc4bd90b50a3fbe5863a0e97a2f4d11682ba13d298/xxhash-4.0.1-cp315-cp315t-win_arm64.whl", hash = "sha256:f00330ac7e24769e2032203f2b01794d670916b0c1799fd261340f1af9499875", size = 34590, upload-time = "2026-08-17T08:23:19.597Z" }, + { url = "https://files.pythonhosted.org/packages/86/79/9127ff42a887a348dc4ce3211cf1a962836887adee6f57078132bfba78b4/xxhash-4.0.1-graalpy312-graalpy250_312_native-macosx_10_13_x86_64.whl", hash = "sha256:ff48915bf1871a1f19f74c11834c6329443d306cedc0c05fe7fe617810422a80", size = 31836, upload-time = "2026-08-17T08:36:28.261Z" }, + { url = "https://files.pythonhosted.org/packages/0a/e6/f238693bfdd642adb59c99683964d46d9947fe721ff44d3bd850ae675407/xxhash-4.0.1-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:4a76345f5aceb4ec404918edf9c7f2b5507db864dc0d7455982009ac0890b57b", size = 34453, upload-time = "2026-08-17T08:23:49.795Z" }, + { url = "https://files.pythonhosted.org/packages/40/4b/796ace33cdfb75c91ba6d11615c3bd436355b9f3103e05865bbee9abce57/xxhash-4.0.1-graalpy312-graalpy250_312_native-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:31d86f9e81f3e84e00131ac7c54caf5119ae4ddd82c09c31cff597c813ce1ee2", size = 38488, upload-time = "2026-08-17T08:23:59.901Z" }, + { url = "https://files.pythonhosted.org/packages/ad/23/2d549e5d5d7759eaf9ac2d2d2ab81ff60f1bb2b52cdaae8e5ec5c6524354/xxhash-4.0.1-graalpy312-graalpy250_312_native-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:deca2a30d983d240b8375ec2ee0a4288e72042827fc61df2f7671f8467e4cb2f", size = 38206, upload-time = "2026-08-17T08:36:32.193Z" }, + { url = "https://files.pythonhosted.org/packages/79/98/1ee576b27f78e6107ee4ea8ac03e8a52888dff256e57d560f8282c195563/xxhash-4.0.1-graalpy312-graalpy250_312_native-win_amd64.whl", hash = "sha256:7c343ee174d417a44d0c3355602c0cbbfa52a04d1bbbf1723378c7d2c8f60626", size = 37127, upload-time = "2026-08-17T08:23:42.705Z" }, + { url = "https://files.pythonhosted.org/packages/ea/4f/e0648288a17d0d1084ca4f7bef206097831988fc86af74aa1dff8f1fbd68/xxhash-4.0.1-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:554f87034635bcec47c5d72447bf3db7e02da1bf493a0ada010db28a76f891c6", size = 36333, upload-time = "2026-08-17T08:23:52.913Z" }, + { url = "https://files.pythonhosted.org/packages/22/15/34b7f72e9b5a8bfd7e6178de9e1e342bc3de9f07111a5ae26c00506d9edf/xxhash-4.0.1-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:3c2445edafc300cc40feb6a25a8356a971c30cd0bf47b5349c2ad74c508343b1", size = 33519, upload-time = "2026-08-17T08:36:03.04Z" }, + { url = "https://files.pythonhosted.org/packages/06/4b/e0af324ccf701bf84a7a060bef11c915d45d9e3c5b9caf5b94d62ecb040b/xxhash-4.0.1-pp311-pypy311_pp73-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:bdd16718b63aa3ebd68aabb79021a40e47c81374852d41a306b9453141bbcbee", size = 47995, upload-time = "2026-08-17T08:24:14.335Z" }, + { url = "https://files.pythonhosted.org/packages/59/46/cc7130e6ca6b41ab72eb6a03177b933c7c74145545c99a8610ecc208c449/xxhash-4.0.1-pp311-pypy311_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8b99ebaf9e816ac5069423b1367ee7e8078fbcebcf62545506bb0608d2f4f468", size = 42725, upload-time = "2026-08-17T08:36:34.144Z" }, + { url = "https://files.pythonhosted.org/packages/1c/24/4f26ff9a7dd0998f6d1036bdddef7ce3e78972a74f7fffa7967e7bc3b7e4/xxhash-4.0.1-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f484ed57bb3e4142f9d6439568658c38be5f94b702ba00a1ff32c69783b6c66d", size = 39532, upload-time = "2026-08-17T08:23:57.556Z" }, + { url = "https://files.pythonhosted.org/packages/7d/f3/1ac078fc8fceadcf066469acecacb35d2821cbfaf7d6fc5ac2107c7a314d/xxhash-4.0.1-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:fac4832b638000106207bc44e44b9616a6a416aaee56c62b01d61f3705e49f58", size = 37252, upload-time = "2026-08-17T08:24:06.652Z" }, +] + +[[package]] +name = "yarl" +version = "1.24.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "idna" }, + { name = "multidict" }, + { name = "propcache" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/31/33/ebe9e3d1f86c7a0b51094c0a146392045ca1631d2664889539dec8088a33/yarl-1.24.5.tar.gz", hash = "sha256:e81b83143bee16329c23db3c1b2d82b29892fcbcb849186d2f6e98a5abe9a57f", size = 228679, upload-time = "2026-07-20T02:07:45.435Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fe/db/3cb5df059756a45761cc3dee8fd25ec82b83a6585ea3542b969fda850f99/yarl-1.24.5-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:2c1fe720934a16ea8e7146175cba2126f87f54912c8c5435e7f7c7a51ef808d3", size = 135043, upload-time = "2026-07-20T02:04:52.39Z" }, + { url = "https://files.pythonhosted.org/packages/44/f8/767d6bd5a03db63bc467df2fb56d6fafeae9667d74aea92cd6af399f828b/yarl-1.24.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:c687ed078e145f5fd53a14854beff320e1d2ab76df03e2009c98f39a0f68f39a", size = 96942, upload-time = "2026-07-20T02:04:54.26Z" }, + { url = "https://files.pythonhosted.org/packages/ce/97/10b939c44d7b28d1dbc389cfc7012306d1ea8dba01eaef44b39fffaee52a/yarl-1.24.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:709f1efed56c4a145793c046cd4939f9959bcd818979a787b77d8e09c57a0840", size = 97046, upload-time = "2026-07-20T02:04:56.638Z" }, + { url = "https://files.pythonhosted.org/packages/5b/7a/b410dbe39b6255c55fb2a2bcee96eb844d0789235ddc381a889a90dc72d6/yarl-1.24.5-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:874019bd513008b009f58657134e5d0c5e030b3559bd0553976837adf52fe966", size = 110512, upload-time = "2026-07-20T02:04:58.955Z" }, + { url = "https://files.pythonhosted.org/packages/83/c7/da591971f78a5617e1f21f5699858ebccd836fe181a6493788ffc91ba69b/yarl-1.24.5-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:a4582acf7ef76482f6f511ebaf1946dae7f2e85ec4728b81a678c01df63bd723", size = 102454, upload-time = "2026-07-20T02:05:00.623Z" }, + { url = "https://files.pythonhosted.org/packages/c4/8e/73b0ed4de47289a78a96045d76d1cfe5e41848bf0da59ce25b2ec87ee05d/yarl-1.24.5-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2cabe6546e41dabe439999a23fcb5246e0c3b595b4315b96ef755252be90caeb", size = 117617, upload-time = "2026-07-20T02:05:02.325Z" }, + { url = "https://files.pythonhosted.org/packages/cf/14/b744747bc4f57a8d55bd744df463457524583e1e9f7538b5ace0346ab92e/yarl-1.24.5-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:17f57620f5475b3c69109376cc87e42a7af5db13c9398e4292772a706ff10780", size = 116135, upload-time = "2026-07-20T02:05:04.05Z" }, + { url = "https://files.pythonhosted.org/packages/66/ca/95aa4d0e5b7ea4f20e4d577c42d001ed9df207569fdb063cc5ed4ebb496b/yarl-1.24.5-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:570fec8fbd22b032733625f03f10b7ff023bc399213db15e72a7acaef28c2f4e", size = 111935, upload-time = "2026-07-20T02:05:05.738Z" }, + { url = "https://files.pythonhosted.org/packages/72/0d/d2ad8d6b147832d177a4e720ba1962fe686eb0913b74503b3eca094b8bba/yarl-1.24.5-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:5fede79c6f73ff2c3ef822864cb1ada23196e62756df53bc6231d351a49516a2", size = 110010, upload-time = "2026-07-20T02:05:07.471Z" }, + { url = "https://files.pythonhosted.org/packages/50/18/eb335e4120903903f4865041355ae46256a2406eb2865bc24827f4f27b61/yarl-1.24.5-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:8ccf9aca873b767977c73df497a85dbedee4ee086ae9ae49dc461333b9b79f58", size = 110058, upload-time = "2026-07-20T02:05:09.246Z" }, + { url = "https://files.pythonhosted.org/packages/44/70/97353add32c62ad6f206d948ac5a5ee84398225e534dc6ed6433d1b335b6/yarl-1.24.5-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:ad5d8201d310b031e6cd839d9bac2d4e5a01533ce5d3d5b50b7de1ef3af1de61", size = 103308, upload-time = "2026-07-20T02:05:11.31Z" }, + { url = "https://files.pythonhosted.org/packages/68/39/5e7398d4b6f6b3c9062823ebc60802df5b272e3fe9e788f9734c6ee46c85/yarl-1.24.5-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:841f0852f48fefea3b12c9dfec00704dfa3aef5215d0e3ce564bb3d7cd8d57c6", size = 116898, upload-time = "2026-07-20T02:05:13.099Z" }, + { url = "https://files.pythonhosted.org/packages/e4/c9/09e52f2239e8b96357eccca05915382e4ba5405ebfb623b6036040d99654/yarl-1.24.5-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:9baafc71b04f8f4bb0703b21d6fc9f0c30b346c636a532ff16ec8491a5ea4b1f", size = 109400, upload-time = "2026-07-20T02:05:14.821Z" }, + { url = "https://files.pythonhosted.org/packages/4b/6a/e94133d4c2d1a14d2384310bf3e79d9cf32c9d1eae1c6f034fb80d098fa1/yarl-1.24.5-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:d897129df1a22b12aeed2c2c98df0785a2e8e6e0bde87b389491d0025c187077", size = 115934, upload-time = "2026-07-20T02:05:17.78Z" }, + { url = "https://files.pythonhosted.org/packages/4e/3c/34955ed967b976fc38edcbb6d538dee79dbda4cb7fc7f72a0907a7c78e0f/yarl-1.24.5-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:dd625535328fd9882374356269227670189adfcc6a2d90284f323c05862eecbd", size = 112178, upload-time = "2026-07-20T02:05:19.675Z" }, + { url = "https://files.pythonhosted.org/packages/f5/46/d7bd3a8859d47dcfaffd7127af7076032a7da278a9a02e17b5f37bfb6712/yarl-1.24.5-cp311-cp311-win_amd64.whl", hash = "sha256:f4239bbec5a3577ddb49e4b50aeb32d8e5792098262ae2f63723f916a29b1a25", size = 97544, upload-time = "2026-07-20T02:05:21.523Z" }, + { url = "https://files.pythonhosted.org/packages/01/69/c1bfd21e32c638974ea2c542a0b8c53ef1fa9eff336020f5d014f9503ff2/yarl-1.24.5-cp311-cp311-win_arm64.whl", hash = "sha256:3ac6aff147deb9c09461b2d4bbdf6256831198f5d8a23f5d37138213090b6d8a", size = 93359, upload-time = "2026-07-20T02:05:23.493Z" }, + { url = "https://files.pythonhosted.org/packages/1b/84/71d051c850b5af41d168c679d9eb67eb7c55283ac4ee131673edf134bc4e/yarl-1.24.5-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:d693396e5aea78db03decd60aec9ece16c9b40ba00a587f089615ff4e718a81d", size = 136035, upload-time = "2026-07-20T02:05:25.489Z" }, + { url = "https://files.pythonhosted.org/packages/03/4d/8ad27f9a1b7e69313cca5d695b925b48efe51208d3490e0844bae97cabc0/yarl-1.24.5-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:3363fcc96e665878946ad7a106b9a13eac0541766a690ef287c0232ac768b6ec", size = 97642, upload-time = "2026-07-20T02:05:27.429Z" }, + { url = "https://files.pythonhosted.org/packages/ea/b4/05b4131c407006cd1e410e9c6539f16a0945724677e5364447313c15ea3e/yarl-1.24.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:9d399bdcfb4a0f659b9b3788bbc89babe63d9a6a65aacdf4d4e7065ff2e6316c", size = 97323, upload-time = "2026-07-20T02:05:29.441Z" }, + { url = "https://files.pythonhosted.org/packages/20/16/e618c875c73e0e39611f20a581b3d5e8d59b8857bf001bee3263044c6deb/yarl-1.24.5-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:90333fd89b43c0d08ac85f3f1447593fc2c66de18c3d6378d7125ea118dc7a54", size = 107741, upload-time = "2026-07-20T02:05:31.367Z" }, + { url = "https://files.pythonhosted.org/packages/d9/9a/c4defeaf3ed33fcb346aacf9c6e971a8d4e2bde04a0310e79abb208e7965/yarl-1.24.5-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:665b0a2c463cc9423dd647e0bfd9f4ccc9b50f768c55304d5e9f80b177c1de12", size = 103570, upload-time = "2026-07-20T02:05:33.303Z" }, + { url = "https://files.pythonhosted.org/packages/5f/e7/0e0e0de5865ebd5914537ef486f36c727a59865c3ac0cf5ff1b32aececbf/yarl-1.24.5-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e006d3a974c4ee19512e5f058abedb6eef36a5e553c14812bdeba1758d812e6d", size = 115815, upload-time = "2026-07-20T02:05:35.292Z" }, + { url = "https://files.pythonhosted.org/packages/2b/27/ca56b700cb170aba25a3893b75355b213935657dc5714d2383354a270e62/yarl-1.24.5-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:e7d42c531243450ef0d4d9c172e7ed6ef052640f195629065041b5add4e058d1", size = 116025, upload-time = "2026-07-20T02:05:37.503Z" }, + { url = "https://files.pythonhosted.org/packages/d6/d0/d56c859b8222116f5d68459199f48359e0bf121b6f65a69bf329b3602ba0/yarl-1.24.5-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f08c7513ecef5aad65687bfdf6bc601ae9fccd04a42904501f8f7141abad9eb9", size = 109835, upload-time = "2026-07-20T02:05:39.506Z" }, + { url = "https://files.pythonhosted.org/packages/70/a2/3a35557e4d1a79425040eba202ccaf08bdc8717680fc77e2498a1ad2e0a5/yarl-1.24.5-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:6c95b17fe34ed802f17e205112e6e10db92275c34fee290aa9bdc55a9c724027", size = 108884, upload-time = "2026-07-20T02:05:41.584Z" }, + { url = "https://files.pythonhosted.org/packages/e4/35/ef4c26356b7913c68983bac2d72a4212b3347af551cb8d250b99b5ed7b7f/yarl-1.24.5-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:56b149b22de33b23b0c6077ab9518c6dcb538ad462e1830e68d06591ccf6e38b", size = 107308, upload-time = "2026-07-20T02:05:43.697Z" }, + { url = "https://files.pythonhosted.org/packages/d5/91/ff0dc66c2ccf3e0153ab97ff61eabab4400e6a5264af427ab30cd69f1857/yarl-1.24.5-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:a8fe66b8f300da93798025a785a5b90b42f3810dc2b72283ff84a41aaaebc293", size = 103646, upload-time = "2026-07-20T02:05:45.895Z" }, + { url = "https://files.pythonhosted.org/packages/74/f0/33b9271c7f881766359d58266fa0811d2e5210ed860e28da7dc6d7786344/yarl-1.24.5-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:377fe3732edbaf78ee74efdf2c9f49f6e99f20e7f9d2649fda3eb4badd77d76e", size = 115305, upload-time = "2026-07-20T02:05:47.832Z" }, + { url = "https://files.pythonhosted.org/packages/ef/65/fd79fb1868c4a80db8661091de525bf430f63c3bea1b20e8b6a84fc7d359/yarl-1.24.5-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:e8ffa78582120024f476a611d7befc123cee59e47e8309d470cf667d806e613b", size = 108404, upload-time = "2026-07-20T02:05:49.604Z" }, + { url = "https://files.pythonhosted.org/packages/ff/ba/dbabe6b262f17a816c70cfc09558dbf03ece3ec76684d02f911a3d3a189c/yarl-1.24.5-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:daba5e594f06114e37db186efd2dd916609071e59daca901a0a2e71f02b142ce", size = 115940, upload-time = "2026-07-20T02:05:51.741Z" }, + { url = "https://files.pythonhosted.org/packages/a5/43/fab2d1dad9d340a268cdde63756a123d069723efff6a372d123fa74a9517/yarl-1.24.5-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:65be18ec59496c13908f02a2472751d9ef840b4f3fb5726f129306bf6a2a7bba", size = 110006, upload-time = "2026-07-20T02:05:53.554Z" }, + { url = "https://files.pythonhosted.org/packages/c4/27/41eb51bbd1b8d89546b83897cfb0164f1e109304fd408dbb151b639eec0f/yarl-1.24.5-cp312-cp312-win_amd64.whl", hash = "sha256:a929d878fec099030c292803b31e5d5540a7b6a31e6a3cc76cb4685fc2a2f51b", size = 97618, upload-time = "2026-07-20T02:05:55.57Z" }, + { url = "https://files.pythonhosted.org/packages/3c/25/b2553764b3d65db711d8f45416351ec4f420847558eb669edcbcaadf5780/yarl-1.24.5-cp312-cp312-win_arm64.whl", hash = "sha256:7ce27823052e2013b597e0c738b13e7e36b8ccb9400df8959417b052ab0fd92c", size = 93018, upload-time = "2026-07-20T02:05:57.554Z" }, + { url = "https://files.pythonhosted.org/packages/e1/63/64ef361967cc983573149dc1515d531db5da8a4c92d22bb833d59e01b313/yarl-1.24.5-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:79af890482fc94648e8cde4c68620378f7fef60932710fa17a66abc039244da2", size = 135075, upload-time = "2026-07-20T02:05:59.671Z" }, + { url = "https://files.pythonhosted.org/packages/bb/89/55920fd853ce43e608adbc3962456f0d649d6bb15250dc2988321da0fe1c/yarl-1.24.5-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:46c2f213e23a04b93a392942d782eb9e413e6ef6bf7c8c53884e599a5c174dcb", size = 97225, upload-time = "2026-07-20T02:06:01.769Z" }, + { url = "https://files.pythonhosted.org/packages/15/f0/7688d3f2cfff7590df2af38ec46d969f4281a4dddb08a9ad2eafbcdddf98/yarl-1.24.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:92ab3e11448f2ff7bf53c5a26eff0edc086898ec8b21fb154b85839ce1d88075", size = 96751, upload-time = "2026-07-20T02:06:03.676Z" }, + { url = "https://files.pythonhosted.org/packages/05/1a/a851a0f94aaaf379dd4f901bfc80f634280bec51eb260b47363e2a4cd62e/yarl-1.24.5-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ebb0ec7f17803063d5aeb982f3b1bd2b2f4e4fae6751226cbd6ba1fcfe9e63ff", size = 107960, upload-time = "2026-07-20T02:06:05.699Z" }, + { url = "https://files.pythonhosted.org/packages/6c/a8/faea066c12f9c77ca0de90641f1655f9dd7b412477bf28c76d692f3aecff/yarl-1.24.5-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:82632daed195dcc8ea664e8556dc9bdbd671960fb3776bd92806ce05792c2448", size = 103500, upload-time = "2026-07-20T02:06:07.556Z" }, + { url = "https://files.pythonhosted.org/packages/fb/9c/1e67084c2a6e2f2db0e3be798328cb3be42c0119b621d25461479a224d21/yarl-1.24.5-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:53e549287ef628fecba270045c9701b0c564563a9b0577d24a4ec75b8ab8040f", size = 115780, upload-time = "2026-07-20T02:06:09.599Z" }, + { url = "https://files.pythonhosted.org/packages/58/86/1f94664e147474337e3359f52012cf3d02f825f694317b178bfba1078c62/yarl-1.24.5-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:fcd3b77e2f17bbe4ca56ec7bcb07992647d19d0b9c05d84886dcd6f9eb810afd", size = 115308, upload-time = "2026-07-20T02:06:11.352Z" }, + { url = "https://files.pythonhosted.org/packages/0a/43/8e55ae7538ba5f28ccb3c845c6dd4549cf7016d5992e5326512519107cdd/yarl-1.24.5-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d46b86567dd4e248c6c159fcbcdcce01e0a5c8a7cd2334a0fff759d0fa075b16", size = 110574, upload-time = "2026-07-20T02:06:13.129Z" }, + { url = "https://files.pythonhosted.org/packages/ce/ba/a889ec8765cedcf2ac44dcb02d6a21e4861399b243b263c5f2dde27ee740/yarl-1.24.5-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:7f72c74aa99359e27a2ee8d6613fefa28b5f76a983c083074dfc2aaa4ab46213", size = 109914, upload-time = "2026-07-20T02:06:15.243Z" }, + { url = "https://files.pythonhosted.org/packages/9c/c3/e45f821af67b791c2dbbe4a9f4137a1d33f8d386654a05a0c3f47bdfa25d/yarl-1.24.5-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:3f45789ce415a7ec0820dc4f82925f9b5f7732070be1dec1f5f23ec381435a24", size = 107712, upload-time = "2026-07-20T02:06:17.443Z" }, + { url = "https://files.pythonhosted.org/packages/02/00/2ab0f42c9857fcb490bfaa6647b14540b53d241ab209f23220b958cc5832/yarl-1.24.5-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:6e73e7fe93f17a7b191f52ec9da9dd8c06a8fe735a1ecbd13b97d1c723bff385", size = 104251, upload-time = "2026-07-20T02:06:19.259Z" }, + { url = "https://files.pythonhosted.org/packages/7a/70/709d9a286e98af2c7fd8e4e6cada658b5c0e30d87dd7e2a63c2fb5767217/yarl-1.24.5-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:4a36f9becdd4c5c52a20c3e9484128b070b1dcfc8944c006f3a528295a359a9c", size = 115319, upload-time = "2026-07-20T02:06:21.207Z" }, + { url = "https://files.pythonhosted.org/packages/5c/6c/3eaa515142991fe84cfc483ff986492211f1978f90161ccefdbec919d09b/yarl-1.24.5-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:7bcbe0fcf850eae67b6b01749815a4f7161c560a844c769ad7b48fcd99f791c4", size = 109163, upload-time = "2026-07-20T02:06:23.006Z" }, + { url = "https://files.pythonhosted.org/packages/bb/64/711dafce66c323a3144d470547a71c5384c57623308ac8bb5e4b903ac148/yarl-1.24.5-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:24e861e9630e0daddcb9191fb187f60f034e17a4426f8101279f0c475cd74144", size = 115435, upload-time = "2026-07-20T02:06:24.923Z" }, + { url = "https://files.pythonhosted.org/packages/cf/f3/9b9d0e6d84bea851eb1ba99e4bdc755b86fd813e49ec86dfe42f26befdef/yarl-1.24.5-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9335a099ad87287c37fe5d1a982ff392fa5efe5d14b40a730b1ec1d6a41382b4", size = 110691, upload-time = "2026-07-20T02:06:26.973Z" }, + { url = "https://files.pythonhosted.org/packages/86/e4/62a06b7e87c4246ac76b7c2da136f972eb4a3a1fc94abb07e7022d6fdb0a/yarl-1.24.5-cp313-cp313-win_amd64.whl", hash = "sha256:2dbe06fc16bc91502bca713704022182e5729861ae00277c3a23354b40929740", size = 97454, upload-time = "2026-07-20T02:06:29.163Z" }, + { url = "https://files.pythonhosted.org/packages/9e/c9/5fc8025b318ab10db413b61056bd0d95c557a70e8df4210c7511f866329c/yarl-1.24.5-cp313-cp313-win_arm64.whl", hash = "sha256:6b8536851f9f65e7f00c7a1d49ba7f2be0ffe2c11555367fc9f50d9f842410a1", size = 92813, upload-time = "2026-07-20T02:06:31.113Z" }, + { url = "https://files.pythonhosted.org/packages/a9/08/5f3085fef9564217074db9dd8573de1795bc82cde61a7ad10b6a7234a569/yarl-1.24.5-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:2729fcfc4f6a596fb0c50f32090400aa9367774ac296a00387e65098c0befa76", size = 135680, upload-time = "2026-07-20T02:06:33.273Z" }, + { url = "https://files.pythonhosted.org/packages/98/35/ba9436e579bd48a8801f2021d842d9ab4994c26e4c7dd3a4c1f1bcb57a9e/yarl-1.24.5-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:ff330d3c30db4eb6b01d79e29d2d0b407a7ecad39cfd9ec993ece57396a2ec0d", size = 97395, upload-time = "2026-07-20T02:06:35.259Z" }, + { url = "https://files.pythonhosted.org/packages/18/a9/a07f76f3c44e02b25cc743af5ef93eef27f7013eadca770451b6a6ccb5db/yarl-1.24.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:e42d75862735da90e7fc5a7b23db0c976f737113a54b3c9777a9b665e9cbff75", size = 97223, upload-time = "2026-07-20T02:06:37.216Z" }, + { url = "https://files.pythonhosted.org/packages/77/f7/a9a1d6fa7dd9e388f95b30f6ad3ec4e285f6c8f61f44ce16070c3fcfe414/yarl-1.24.5-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a3732e66413163e72508da9eff9ce9d2846fde51fae45d3605393d3e6cd303e9", size = 108777, upload-time = "2026-07-20T02:06:39.292Z" }, + { url = "https://files.pythonhosted.org/packages/2f/44/e0b86c302471fabd6f02808ecf2ac52b8412b624787849d4bf2cdb466f6f/yarl-1.24.5-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:5b8ee53be440a0cffc991a27be3057e0530122548dbe7c0892df08822fce5ede", size = 103119, upload-time = "2026-07-20T02:06:41.456Z" }, + { url = "https://files.pythonhosted.org/packages/d1/16/9c16d180bf8faaf223225eb50e1245870ff1ae0e302a27153988e65c51fd/yarl-1.24.5-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:af3aefa655adb5869491fa907e652290386800ae99cc50095cba71e2c6aefdca", size = 116471, upload-time = "2026-07-20T02:06:43.696Z" }, + { url = "https://files.pythonhosted.org/packages/d2/8d/b219b9df28a02ce95cfbdd41d2f7caa5669d0ff979c1c9975697145e33c5/yarl-1.24.5-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2120b96872df4a117cde97d270bac96aea7cc52205d305cf4611df694a487027", size = 115974, upload-time = "2026-07-20T02:06:45.874Z" }, + { url = "https://files.pythonhosted.org/packages/9b/e8/f20557aca240d88e69850ad1ee91756821d094bb1310565c04d25c6682a2/yarl-1.24.5-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:66410eb6345d467151934b49bfa70fb32f5b35a6140baa40ad97d6436abea2e9", size = 110830, upload-time = "2026-07-20T02:06:47.852Z" }, + { url = "https://files.pythonhosted.org/packages/db/18/199b85109a53eeca64ee19c9cca228287e8e4ab0cc1a09b28f530e65cce0/yarl-1.24.5-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:4af7b7e1be0a69bee8210735fe6dcfc38879adfac6d62e789d53ba432d1ffa41", size = 110054, upload-time = "2026-07-20T02:06:49.84Z" }, + { url = "https://files.pythonhosted.org/packages/aa/2f/ed28147f8cd7f48c49367c90713b30a555284b6105a6a56f3a05568da795/yarl-1.24.5-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:fa139875ff98ab97da323cfadfaff08900d1ad42f1b5087b0b812a55c5a06373", size = 108312, upload-time = "2026-07-20T02:06:51.835Z" }, + { url = "https://files.pythonhosted.org/packages/c5/c5/55e16ae0a5c227cea8df1c6871ba57d614a34243146c05729caf2a1bd9c5/yarl-1.24.5-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:0055afc45e864b92729ac7600e2d102c17bef060647e74bca75fa84d66b9ff36", size = 103662, upload-time = "2026-07-20T02:06:54.061Z" }, + { url = "https://files.pythonhosted.org/packages/8d/ea/dbd7c2caec459c9a426f18b02688ecbfb58620d0f6a3422d24769fbaf8ab/yarl-1.24.5-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:f0e466ed7511fe9d459a819edbc6c2585c0b6eabde9fa8a8947552468a7a6ef0", size = 116090, upload-time = "2026-07-20T02:06:56.015Z" }, + { url = "https://files.pythonhosted.org/packages/06/84/39ce4ce3059e07fece5fbdbee8c4053406af9aca911ce9fa5f8548aab6af/yarl-1.24.5-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:f141474e85b7e54998ec5180530a7cda99ab29e282fa50e0756d89981a9b43c5", size = 109523, upload-time = "2026-07-20T02:06:57.926Z" }, + { url = "https://files.pythonhosted.org/packages/a9/8b/71ff44137b405c64a7788075669c24010019f57a7464b78c3a6cbee539d9/yarl-1.24.5-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:e2935f8c39e3b03e83519292d78f075189978f3f4adc15a78144c7c8e2a1cba5", size = 116084, upload-time = "2026-07-20T02:06:59.868Z" }, + { url = "https://files.pythonhosted.org/packages/62/c0/423078fdd4042e1862c11f0ffd977a0ffa393783c12bee94685923bc189e/yarl-1.24.5-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:9d1216a7f6f77836617dba35687c5b78a4170afc3c3f18fc788f785ba26565c4", size = 111006, upload-time = "2026-07-20T02:07:01.907Z" }, + { url = "https://files.pythonhosted.org/packages/cf/52/6daa2ee9d95e5c98b8128f8df91eb692eb423ab274b8cf08db52152fad26/yarl-1.24.5-cp314-cp314-win_amd64.whl", hash = "sha256:5ba4f78df2bcc19f764a4b26a8a4f5049c110090ad5825993aacb052bf8003ad", size = 99215, upload-time = "2026-07-20T02:07:03.852Z" }, + { url = "https://files.pythonhosted.org/packages/ec/0e/464a847d7359e0da75dd9fc5c1d1aa35d0159ea31e5f8e66a3c1c29ff3d0/yarl-1.24.5-cp314-cp314-win_arm64.whl", hash = "sha256:9e4e16c73d717c5cf27626c524d0a2e261ad20e46932b2670f64ad5dde23e26f", size = 94566, upload-time = "2026-07-20T02:07:06.074Z" }, + { url = "https://files.pythonhosted.org/packages/e2/55/e03acc4446772660bc335e86e41ef31e4d0d838fd641531a11a5ee33b493/yarl-1.24.5-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:e1ae548a9d901adca07899a4147a7c826bbcc06239d3ce9a59f57886a28a4c88", size = 142533, upload-time = "2026-07-20T02:07:08.284Z" }, + { url = "https://files.pythonhosted.org/packages/ae/71/4acd3a1fc7cf14345cdb302665ecd2097f62c365b4f14ca17d4f37775cf9/yarl-1.24.5-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:ff405d91509d88e8d44129cd87b18d70acd1f0c1aeabd7bc3c46792b1fe2acba", size = 100776, upload-time = "2026-07-20T02:07:10.197Z" }, + { url = "https://files.pythonhosted.org/packages/ff/0b/cfb76b7fe99686db264bff829779a539d923e7564ffd7ef18da6c54c3774/yarl-1.24.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:47e98aab9d8d82ff682e7b0b5dded33bf138a32b817fcf7fa3b27b2d7c412928", size = 100913, upload-time = "2026-07-20T02:07:12.357Z" }, + { url = "https://files.pythonhosted.org/packages/8b/3f/7116e782992abbd4fb6948488aec72078895e929a23078290739e8396fce/yarl-1.24.5-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f0a658a6d3fafee5c6f63c58f3e785c8c43c93fbc02bf9f2b6663f8185e0971f", size = 106507, upload-time = "2026-07-20T02:07:14.173Z" }, + { url = "https://files.pythonhosted.org/packages/33/90/d4d2d73ee78229cc889872eb8e085d8f5c6f51abdb178409fd9b23cf74fd/yarl-1.24.5-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:4377407001ca3c057773f44d8ddd6358fa5f691407c1ba92210bd3cf8d9e4c95", size = 99219, upload-time = "2026-07-20T02:07:16.019Z" }, + { url = "https://files.pythonhosted.org/packages/3e/fa/a6df1a9bccd644eec00abee0dff4277416222cec435330fd1f2858523ec1/yarl-1.24.5-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7c0494a31a1ac5461a226e7947a9c9b78c44e1dc7185164fa7e9651557a5d9bc", size = 111804, upload-time = "2026-07-20T02:07:18.141Z" }, + { url = "https://files.pythonhosted.org/packages/8a/9e/7b2a1f4bcc20e9447156dd2b1c4d01f70d9df0759025ee7d09a84ffae134/yarl-1.24.5-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a7cff474ab7cd149765bb784cf6d78b32e18e20473fb7bda860bce98ab58e9da", size = 110943, upload-time = "2026-07-20T02:07:20.06Z" }, + { url = "https://files.pythonhosted.org/packages/08/ff/22c92affb0f9b623ca753d27d968b5625b868f12c6378d049d55ae247643/yarl-1.24.5-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:cbb833ccacdb5519eff9b8b71ee618cc2801c878e77e288775d77c3a2ced858a", size = 108251, upload-time = "2026-07-20T02:07:22.217Z" }, + { url = "https://files.pythonhosted.org/packages/45/44/5769b96298c1e195fb412997b6090af2a84105cf59c17613558a2d011d1f/yarl-1.24.5-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:82f75e05912e84b7a0fe57075d9c59de3cb352b928330f2eb69b2e1f54c3e1f0", size = 106025, upload-time = "2026-07-20T02:07:24.083Z" }, + { url = "https://files.pythonhosted.org/packages/4c/40/009e8e791fd9762c0e1567e69248acb4f49064597e1680874c16dd8bb798/yarl-1.24.5-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:16a2f5010280020e90f5330257e6944bc33e73593b136cc5a241e6c1dc292498", size = 106573, upload-time = "2026-07-20T02:07:26.248Z" }, + { url = "https://files.pythonhosted.org/packages/20/c6/b7480578f8a0a80946f36ad6df547ecec704f9ba69d2de60f8aa6f1c1cbf/yarl-1.24.5-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:ffcd54362564dc1a30fb74d8b8a6e5a6b11ebd5e27266adc3b7427a21a6c9104", size = 100751, upload-time = "2026-07-20T02:07:28.098Z" }, + { url = "https://files.pythonhosted.org/packages/d4/27/4476f3360b91a48c5cf125e91f59a3bd35299d84a431a258d57f5977bb11/yarl-1.24.5-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:0465ec8cedc2349b97a6b595ace64084a50c6e839eca40aa0626f38b8350e331", size = 111643, upload-time = "2026-07-20T02:07:30.88Z" }, + { url = "https://files.pythonhosted.org/packages/4c/4b/5cdd3e5ee944e8af31e52f6cd3d3af5fd7b937e036ccbbba2c9ffebede95/yarl-1.24.5-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:4db9aecb141cb7a5447171b57aa1ed3a8fee06af40b992ffc31206c0b0121550", size = 106312, upload-time = "2026-07-20T02:07:33.06Z" }, + { url = "https://files.pythonhosted.org/packages/18/86/f406b0c2a6f99575de2da671ef47aa06f89a5be83a27a46971c3b86cecdb/yarl-1.24.5-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:f540c013589084679a6c7fac07096b10159737918174f5dfc5e11bf5bca4dfe6", size = 110379, upload-time = "2026-07-20T02:07:35.155Z" }, + { url = "https://files.pythonhosted.org/packages/f0/6c/9f3adfbd3b30b4fa0f7ccb3a83eba2c1152d3fff554d535e640ba0f7ba2b/yarl-1.24.5-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:a61834fb15d81322d872eaafd333838ae7c9cea84067f232656f75965933d047", size = 108497, upload-time = "2026-07-20T02:07:37.35Z" }, + { url = "https://files.pythonhosted.org/packages/dd/37/91eb2e5ca883a529c1b390348a74cd9fc0512171727f547ce70bfe02be5c/yarl-1.24.5-cp314-cp314t-win_amd64.whl", hash = "sha256:5c88e5815a49d289e599f3513aa7fde0bc2092ff188f99c940f007f90f53d104", size = 102450, upload-time = "2026-07-20T02:07:39.578Z" }, + { url = "https://files.pythonhosted.org/packages/bf/f4/ed5c402ac8fde4403ed3366c2716bfddc8a6677ebd59f3d62772cc7fe468/yarl-1.24.5-cp314-cp314t-win_arm64.whl", hash = "sha256:cf139c02f5f23ef6532040a30ff662c00a318c952334f211046b8e60b7f17688", size = 97222, upload-time = "2026-07-20T02:07:41.55Z" }, + { url = "https://files.pythonhosted.org/packages/61/02/962c1cbfc401a30c1d034dc67ff395f64b52302c6d62de556c1fca99acc0/yarl-1.24.5-py3-none-any.whl", hash = "sha256:a33700d13d9b7d84fd10947b09ff69fb9a792e519c8cb9764a3ca70baa6c23a7", size = 58612, upload-time = "2026-07-20T02:07:43.461Z" }, +]