From 99b122999a7793adc7d759b1d654ba9fa7f66054 Mon Sep 17 00:00:00 2001 From: Zachery Aaron Shores-Chmielewski Date: Tue, 21 Jul 2026 12:32:30 +0400 Subject: [PATCH] init --- .gitignore | 15 + PROJECT_PLAN.md | 80 + configs/mlp_tiny.toml | 32 + notebooks/airfrans_simulation_deep_dive.ipynb | 1218 +++++++++++ notebooks/explore_raw_subset.ipynb | 1654 +++++++++++++++ pyproject.toml | 28 + src/airfrans_frontier/__init__.py | 1 + src/airfrans_frontier/cli.py | 68 + src/airfrans_frontier/models/__init__.py | 5 + src/airfrans_frontier/models/mlp.py | 47 + src/airfrans_frontier/paths.py | 8 + src/airfrans_frontier/raw/__init__.py | 0 src/airfrans_frontier/raw/inspect.py | 92 + src/airfrans_frontier/raw/manifest.py | 69 + src/airfrans_frontier/runtime.py | 25 + src/airfrans_frontier/training/__init__.py | 3 + src/airfrans_frontier/training/artifacts.py | 66 + src/airfrans_frontier/training/config.py | 207 ++ src/airfrans_frontier/training/data.py | 254 +++ src/airfrans_frontier/training/loop.py | 316 +++ src/airfrans_frontier/training/metrics.py | 45 + src/airfrans_frontier/training/normalize.py | 126 ++ tests/test_cli.py | 113 ++ tests/test_mlp.py | 25 + tests/test_training_config.py | 30 + tests/test_training_data.py | 96 + tests/test_training_loop.py | 155 ++ uv.lock | 1779 +++++++++++++++++ 28 files changed, 6557 insertions(+) create mode 100644 .gitignore create mode 100644 PROJECT_PLAN.md create mode 100644 configs/mlp_tiny.toml create mode 100644 notebooks/airfrans_simulation_deep_dive.ipynb create mode 100644 notebooks/explore_raw_subset.ipynb create mode 100644 pyproject.toml create mode 100644 src/airfrans_frontier/__init__.py create mode 100644 src/airfrans_frontier/cli.py create mode 100644 src/airfrans_frontier/models/__init__.py create mode 100644 src/airfrans_frontier/models/mlp.py create mode 100644 src/airfrans_frontier/paths.py create mode 100644 src/airfrans_frontier/raw/__init__.py create mode 100644 src/airfrans_frontier/raw/inspect.py create mode 100644 src/airfrans_frontier/raw/manifest.py create mode 100644 src/airfrans_frontier/runtime.py create mode 100644 src/airfrans_frontier/training/__init__.py create mode 100644 src/airfrans_frontier/training/artifacts.py create mode 100644 src/airfrans_frontier/training/config.py create mode 100644 src/airfrans_frontier/training/data.py create mode 100644 src/airfrans_frontier/training/loop.py create mode 100644 src/airfrans_frontier/training/metrics.py create mode 100644 src/airfrans_frontier/training/normalize.py create mode 100644 tests/test_cli.py create mode 100644 tests/test_mlp.py create mode 100644 tests/test_training_config.py create mode 100644 tests/test_training_data.py create mode 100644 tests/test_training_loop.py create mode 100644 uv.lock diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..2dd5719 --- /dev/null +++ b/.gitignore @@ -0,0 +1,15 @@ +# Local data and generated artifacts +data/ +outputs/ +artifacts/ + +# Python +.venv/ +__pycache__/ +*.py[cod] +.pytest_cache/ +.ruff_cache/ + +.ipynb_checkpoints/ +# OS/editor +.DS_Store diff --git a/PROJECT_PLAN.md b/PROJECT_PLAN.md new file mode 100644 index 0000000..24f2252 --- /dev/null +++ b/PROJECT_PLAN.md @@ -0,0 +1,80 @@ +# AirfRANS Scaling Frontier Project + +This document is a scope anchor, not a specification. It should help a human or agent understand what this repository is for without forcing a particular architecture, experiment grid, or implementation shape. + +## What we are doing + +We are exploring the **scaling frontier for AirfRANS-based CFD surrogate simulations**. + +The project is about understanding how far useful surrogate simulation can be pushed with open AirfRANS-style data, and what factors appear to control that frontier. The goal is not to preselect a model family, reproduce every baseline, or build a large simulation platform. The goal is to produce grounded evidence about what improves surrogate quality and where returns begin to flatten. + +Use careful language: this is an empirical scaling/frontier study, not a claim of universal scaling laws unless the evidence later supports that. + +## Core questions + +The work should stay centered on questions like: + +1. What quality frontier is reachable using open AirfRANS-based simulation data? +2. How does performance change as available data, compute, and model capacity change? +3. Which bottleneck is most visible at a given stage: data, compute, representation, model capacity, optimization, or evaluation target? +4. When does additional simulation data appear more valuable than better training, representation, or model choice? +5. What is the simplest experiment that can move our understanding of the frontier forward? + +These questions matter more than any specific architecture list or dataset-shape detail. + +## Working principles + +- Start from open AirfRANS data and existing public context. +- Keep experiments small enough that results can be inspected, repeated, and compared. +- Change one major scaling axis at a time when possible. +- Track compute and wall-clock cost alongside quality metrics. +- Prefer evidence that informs the next decision over exhaustive sweeps. +- Avoid committing early to a specific model family, pipeline abstraction, or benchmark layout. +- Treat additional generated simulations as a later decision, justified only by measured need. + +## Scaling axes to keep in mind + +The project should distinguish between several sources of scale: + +- number of independent simulations available; +- number of sampled/query points used from those simulations; +- model capacity; +- training compute; +- inference cost; +- evaluation target, such as field quality versus engineering quantities. + +Not every experiment needs to cover every axis. The important part is to avoid confusing them when interpreting results. + +## What counts as progress + +A useful step should do at least one of the following: + +- establish a trustworthy baseline; +- reveal a bottleneck; +- compare two choices under a controlled constraint; +- improve measurement or logging so future comparisons are reliable; +- show that a proposed direction is not worth pursuing yet; +- produce a plot, table, or saved artifact that clarifies the frontier. + +A larger run is not automatically better. A small run that changes the next decision is more valuable than a broad sweep with unclear interpretation. + +## Non-goals for now + +- Do not turn this into a general CFD framework. +- Do not make model selection the center of the project before the measurement loop is solid. +- Do not overfit the plan to AirfRANS implementation details that are not needed for the current decision. +- Do not generate additional CFD simulations before the open-data frontier has been measured. +- Do not treat a large experiment grid as inherently more credible than a focused frontier measurement. + +## Expected final shape + +The eventual artifact should explain, with measured evidence: + +- what frontier was explored; +- what axes were varied; +- what improved quality or efficiency; +- what bottleneck seems most important; +- whether additional generated simulation data appears justified; +- what the next most rational experiment would be. + +The final output should be legible to someone evaluating the project as evidence of experimental judgment, simulation awareness, and resource-aware ML engineering. diff --git a/configs/mlp_tiny.toml b/configs/mlp_tiny.toml new file mode 100644 index 0000000..6b9452b --- /dev/null +++ b/configs/mlp_tiny.toml @@ -0,0 +1,32 @@ +[run] +name = "mlp_tiny" +seed = 0 +artifact_dir = "artifacts/runs" + +[data] +root = "data/processed/minimal" +train_cases = 4 +val_cases = 1 +test_cases = 1 +points_per_case = 128 +batch_size = 128 + +[model] +type = "mlp" +hidden_width = 128 +depth = 4 +activation = "gelu" + +[optim] +lr = 0.001 +weight_decay = 0.0 +steps = 500 +log_interval = 100 + +[device] +type = "cuda" +allow_cpu_fallback = false +benchmark_kernels = true + +[loss] +type = "normalized_mse" diff --git a/notebooks/airfrans_simulation_deep_dive.ipynb b/notebooks/airfrans_simulation_deep_dive.ipynb new file mode 100644 index 0000000..aff1d3f --- /dev/null +++ b/notebooks/airfrans_simulation_deep_dive.ipynb @@ -0,0 +1,1218 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "f63c5c8a", + "metadata": {}, + "source": [ + "# AirfRANS simulation deep dive\n", + "\n", + "This notebook is a concrete map from the AirfRANS paper to the files in this repo's local raw OpenFOAM subset.\n", + "\n", + "Sources used while writing it:\n", + "\n", + "- Paper: Bonnet et al., **AirfRANS: High Fidelity Computational Fluid Dynamics Dataset for Approximating Reynolds-Averaged Navier-Stokes Solutions**, arXiv:2212.07564, v3.\n", + "- AirfRANS docs: introduction, simulation, dataset pages.\n", + "- `Extrality/NACA_simulation`: `README.md`, `params.yaml`, `main.py`, `dataset_generator.py`, `simulation_generator.py`.\n", + "\n", + "The paper's simulation is not a toy equation on a grid. It is a generated CFD case:\n", + "\n", + "```text\n", + "sample airfoil shape + Reynolds + angle of attack\n", + " ↓\n", + "convert Reynolds to freestream speed U_inf because chord = 1 m and ν is fixed\n", + " ↓\n", + "generate NACA 4/5-digit airfoil coordinates\n", + " ↓\n", + "generate an OpenFOAM C-grid blockMesh around the airfoil\n", + " ↓\n", + "run steady incompressible RANS with k-ω SST turbulence model using simpleFoam/SIMPLEC\n", + " ↓\n", + "postprocess fields, wall stresses, lift/drag/moment histories, VTK files\n", + " ↓\n", + "crop/slice/select fields for ML surrogate-model training\n", + "```\n", + "\n", + "You can run the code cells top-to-bottom. Change `SIM_INDEX` later to inspect another case.\n" + ] + }, + { + "cell_type": "markdown", + "id": "7caaa053", + "metadata": {}, + "source": [ + "## 1. Domain translation: what problem is being simulated?\n", + "\n", + "AirfRANS = airfoil data built from **Reynolds-Averaged Navier-Stokes** simulations.\n", + "\n", + "The simulated object is a 2D airfoil cross-section with chord length $c = 1\\ \\mathrm{m}$, not a full 3D wing. The surrounding fluid is air at sea-level-like conditions and $T = 298.15\\ \\mathrm{K}$. The flow is **subsonic** and treated as **incompressible** because the paper limits the regime to roughly $\\mathrm{Ma} < 0.3$.\n", + "\n", + "Each simulation solves for a steady **mean** flow around one airfoil. \"Mean\" matters because the real turbulent flow contains rapidly fluctuating eddies; RANS replaces those instant-by-instant fluctuations with time-averaged fields that are useful for engineering design.\n", + "\n", + "- **Mean velocity field** $\\bar u(x,y) = (\\bar u_x, \\bar u_y)$. This gives the average flow speed and direction at every point in the 2D domain. It shows acceleration over the suction side, stagnation near the leading edge, wake deficit behind the airfoil, and any separated/recirculating region. Velocity is the primary state variable: its gradients set viscous shear, and its deflection is directly related to lift.\n", + "- **Reduced pressure** $\\bar p/\\rho$. OpenFOAM's incompressible pressure variable is pressure divided by density, so its units are $\\mathrm{m^2/s^2}$ rather than Pa. This is convenient because the incompressible momentum equation uses pressure as a velocity-squared quantity. Pressure differences over the airfoil are crucial: low pressure on the upper/suction side and higher pressure on the lower/pressure side produce most of the lift, while pressure imbalance in the streamwise direction contributes to pressure drag.\n", + "- **Turbulent viscosity** $\\nu_t(x,y)$ from the turbulence model. This is not a material property like air's molecular viscosity $\\nu$; it is the $k$-$\\omega$ SST model's estimate of extra momentum mixing caused by unresolved turbulent eddies. Large $\\nu_t$ usually marks shear layers, wakes, and boundary-layer regions where turbulence transports momentum much faster than molecular diffusion alone. For surrogate models, $\\nu_t$ is important because it encodes where the closure model thinks turbulence is controlling the mean flow.\n", + "- **Surface pressure and viscous/shear stresses** on the airfoil wall. The volume fields describe the flow around the body, but forces come from stresses acting on the surface. Pressure acts normal to the wall; viscous shear acts tangentially through the near-wall velocity gradient. Integrating these wall quantities gives the aerodynamic loads.\n", + "- **Integrated force coefficients**: drag $C_D$, lift $C_L$, and moment coefficient. These nondimensionalize the total forces and torque by dynamic pressure and chord-based reference scales, so cases with different freestream speeds and airfoil shapes can be compared directly. $C_L$ measures useful vertical force, $C_D$ measures aerodynamic resistance, and the moment coefficient measures pitching tendency/stability.\n", + "\n", + "The original full dataset has 1000 simulations. This repo currently has a 50-case raw OpenFOAM subset under `data/raw/OF_dataset/`.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1346d8f4", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-20T19:11:12.234873Z", + "iopub.status.busy": "2026-07-20T19:11:12.234506Z", + "iopub.status.idle": "2026-07-20T19:11:12.518603Z", + "shell.execute_reply": "2026-07-20T19:11:12.518263Z" + } + }, + "outputs": [], + "source": [ + "from pathlib import Path\n", + "import gzip\n", + "import json\n", + "import math\n", + "import re\n", + "import sys\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "\n", + "def find_repo_root(start: Path) -> Path:\n", + " for candidate in (start, *start.parents):\n", + " if (candidate / \"pyproject.toml\").exists() and (candidate / \"src\" / \"airfrans_frontier\").exists():\n", + " return candidate\n", + " raise RuntimeError(f\"Could not find repository root from {start}\")\n", + "\n", + "\n", + "REPO_ROOT = find_repo_root(Path.cwd())\n", + "SRC = REPO_ROOT / \"src\"\n", + "if str(SRC) not in sys.path:\n", + " sys.path.insert(0, str(SRC))\n", + "\n", + "from airfrans_frontier.paths import DEFAULT_RAW_DATA_DIR, DEFAULT_RAW_MANIFEST_PATH\n", + "from airfrans_frontier.raw.inspect import format_raw_inspection, inspect_raw_subset\n", + "from airfrans_frontier.raw.manifest import load_raw_subset_manifest\n", + "\n", + "DATA_DIR = REPO_ROOT / DEFAULT_RAW_DATA_DIR\n", + "MANIFEST_PATH = REPO_ROOT / DEFAULT_RAW_MANIFEST_PATH\n", + "print(f\"repo: {REPO_ROOT}\")\n", + "print(f\"raw data: {DATA_DIR}\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "5bb5d36c", + "metadata": {}, + "source": [ + "## 2. Constants and the key nondimensional numbers\n", + "\n", + "For incompressible flow, the key dimensionless control parameter is Reynolds number\n", + "\n", + "$$\n", + "\\mathrm{Re}=\\frac{U L}{\\nu}.\n", + "$$\n", + "\n", + "Here:\n", + "\n", + "- $U$ is the freestream/inlet velocity magnitude,\n", + "- $L$ is the characteristic length; AirfRANS uses the chord, $L = 1\\ \\mathrm{m}$, for the airfoil Reynolds number,\n", + "- $\\nu$ is kinematic viscosity. The dataset generation used about $1.56\\times 10^{-5}\\ \\mathrm{m^2/s}$.\n", + "\n", + "So, because $L=1$, AirfRANS effectively maps\n", + "\n", + "$$\n", + "U_\\infty \\approx \\mathrm{Re}\\,\\nu.\n", + "$$\n", + "\n", + "The paper samples $\\mathrm{Re}\\in[2,6]\\times10^6$, giving speeds around 31.2 to 93.6 m/s. The speed of sound at 298.15 K is about 346.1 m/s, so the upper speed gives $\\mathrm{Ma}\\approx0.27$, below the usual $0.3$ incompressible cutoff.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "eb38682d", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-20T19:11:12.520848Z", + "iopub.status.busy": "2026-07-20T19:11:12.520703Z", + "iopub.status.idle": "2026-07-20T19:11:12.523976Z", + "shell.execute_reply": "2026-07-20T19:11:12.523621Z" + } + }, + "outputs": [], + "source": [ + "NU_DATASET = 1.56e-5 # m^2/s, paper Table 6 / docs note\n", + "RHO = 1.184 # kg/m^3, paper Table 6\n", + "SOUND_SPEED = 346.1 # m/s, paper Table 6\n", + "CHORD = 1.0 # m\n", + "\n", + "for Re in [2e6, 3e6, 4e6, 5e6, 6e6]:\n", + " U = Re * NU_DATASET / CHORD\n", + " Ma = U / SOUND_SPEED\n", + " q_reduced = 0.5 * U**2 # reduced dynamic pressure q/rho for OpenFOAM incompressible pressure convention\n", + " q_physical = 0.5 * RHO * U**2\n", + " print(f\"Re={Re/1e6:.0f}e6 U_inf={U:6.2f} m/s Mach={Ma:.3f} q/rho={q_reduced:8.1f} m^2/s^2 q={q_physical:8.1f} Pa\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "2631a6d7", + "metadata": {}, + "source": [ + "## 3. What equations are actually solved?\n", + "\n", + "The paper writes steady incompressible RANS in index notation. In plain terms:\n", + "\n", + "### Mass conservation\n", + "\n", + "$$\n", + "\\nabla\\cdot \\bar u = 0.\n", + "$$\n", + "\n", + "For incompressible flow, the mean velocity field has zero divergence: no local volume expansion/compression.\n", + "\n", + "### Momentum balance\n", + "\n", + "The paper gives, schematically,\n", + "\n", + "$$\n", + "\\partial_j(\\bar u_i\\bar u_j)\n", + "= -\\partial_i \\bar p + (\\nu + \\nu_t)\\partial_{jj}^2 \\bar u_i,\n", + "\\quad i\\in\\{1,2\\},\n", + "$$\n", + "\n", + "where pressure is the **reduced** pressure $p/\\rho$ in the incompressible convention. The indices are just compact notation for the two spatial directions: $i=1,2$ selects the velocity component being solved ($\\bar u_x$ or $\\bar u_y$), and a repeated $j$ means \"sum over both $x$ and $y$ directions.\"\n", + "\n", + "Interpretation:\n", + "\n", + "- $\\partial_j(\\bar u_i\\bar u_j)$: convection of momentum. It means the moving mean flow is carrying component-$i$ momentum through the $x$ and $y$ directions. For example, for $i=x$ it expands to $\\partial_x(\\bar u_x\\bar u_x)+\\partial_y(\\bar u_x\\bar u_y)$.\n", + "- $-\\partial_i \\bar p$: pressure-gradient force in the selected direction; pressure differences push and turn the flow.\n", + "- $(\\nu+\\nu_t)\\partial_{jj}^2\\bar u_i$: viscous/turbulent smoothing of the selected velocity component. Here $\\partial_{jj}^2$ means $\\partial_x^2+\\partial_y^2$, so this term responds to curvature/sharp spatial changes in the velocity field.\n", + "\n", + "The closure is the **$k$-$\\omega$ SST** turbulence model. That means OpenFOAM also solves extra turbulence equations for quantities such as turbulent kinetic energy $k$ and specific dissipation rate $\\omega$; those determine $\\nu_t$. The dataset exposes $\\nu_t$ as a target field because it indicates local turbulence intensity, but force computation only needs pressure and near-wall velocity gradients; on the airfoil wall $\\nu_t=0$ for this setup.\n", + "\n", + "OpenFOAM solves these equations with a finite-volume method: the domain is split into cells, integral conservation laws are enforced over each cell, and fluxes across cell faces couple neighboring cells.\n" + ] + }, + { + "cell_type": "markdown", + "id": "e41bd5ea", + "metadata": {}, + "source": [ + "## 4. What kinds of objects are involved?\n", + "\n", + "A raw AirfRANS case contains several distinct object types. Keeping them separate avoids confusion.\n", + "\n", + "| Object | Meaning in CFD | Where it appears in raw OpenFOAM |\n", + "|---|---|---|\n", + "| airfoil geometry | the solid obstacle boundary, chord 1 m | spline points inside `system/blockMeshDict`; wall patch named `aerofoil` |\n", + "| farfield/freestream boundary | outer domain boundary 200 chords away | patch named `freestream` |\n", + "| mesh vertices/points | coordinates used to define cell corners/faces | `constant/polyMesh/points.gz` |\n", + "| faces | polygon faces connecting vertices | `constant/polyMesh/faces.gz` |\n", + "| cells | finite volumes where equations are solved | OpenFOAM topology under `constant/polyMesh/`; volume fields have one row per cell |\n", + "| boundary patches | named sets of boundary faces | `constant/polyMesh/boundary` |\n", + "| volume fields | solved fields over cells | final time folder, e.g. `40000/U.gz`, `40000/p.gz`, turbulence fields |\n", + "| surface fields | wall quantities on airfoil faces | `40000/wallShearStress.gz`, `40000/forceCoeff.gz`, `40000/yPlus.gz` |\n", + "| force histories | integrated engineering outputs versus solver iteration | `postProcessing/forceCoeffs1/0/coefficient.dat` |\n", + "\n", + "The mesh is a C-grid/multiblock hexahedral mesh. It is deliberately very fine near the airfoil wall because drag depends strongly on wall shear stress, which depends on the velocity gradient immediately next to the wall.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a7370288", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-20T19:11:12.525617Z", + "iopub.status.busy": "2026-07-20T19:11:12.525521Z", + "iopub.status.idle": "2026-07-20T19:11:12.587426Z", + "shell.execute_reply": "2026-07-20T19:11:12.586915Z" + } + }, + "outputs": [], + "source": [ + "report = inspect_raw_subset(DATA_DIR, MANIFEST_PATH)\n", + "print(format_raw_inspection(report, sample_limit=8))\n", + "manifest = load_raw_subset_manifest(MANIFEST_PATH)\n", + "sim_names = list(manifest.simulation_names)\n" + ] + }, + { + "cell_type": "markdown", + "id": "8960a178", + "metadata": {}, + "source": [ + "## 5. Dataset design space: what is varied?\n", + "\n", + "Each simulation is defined by:\n", + "\n", + "1. turbulence model: AirfRANS dataset uses `SST` = $k$-$\\omega$ SST;\n", + "2. freestream speed $U_\\infty$;\n", + "3. angle of attack $\\alpha$ in degrees;\n", + "4. NACA airfoil parameters.\n", + "\n", + "The name stores these parameters. Example:\n", + "\n", + "```text\n", + "airFoil2D_SST_43.597_5.932_3.551_3.1_1.0_18.252\n", + " │ │ │ └──── NACA parameters; 4 numbers => 5-digit family\n", + " │ │ └────────── angle of attack α [deg]\n", + " │ └───────────────── U_inf [m/s]\n", + " └───────────────────── turbulence model\n", + "```\n", + "\n", + "NACA 4-digit family uses 3 parameters `(M, P, XX)`:\n", + "\n", + "- `M`: maximum camber in percent of chord,\n", + "- `P`: location of maximum camber in tenths of chord,\n", + "- `XX`: maximum thickness in percent of chord.\n", + "\n", + "NACA 5-digit family uses 4 parameters `(L, P, Q, XX)`:\n", + "\n", + "- `L`: controls design lift coefficient through $C_L = 0.15L$ in the classical definition,\n", + "- `P`: camber-location parameter in twentieths of chord,\n", + "- `Q`: 0 for standard camber, 1 for reflex camber,\n", + "- `XX`: maximum thickness in percent of chord.\n", + "\n", + "The AirfRANS paper samples 500 airfoils from the 4-digit family and 500 from the 5-digit family, for 1000 total simulations. The docs/code sample Reynolds uniformly in `[2e6, 6e6]` and angle of attack uniformly in `[-5°, 15°]`; high-|AoA| cases may run more iterations.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "473b211e", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-20T19:11:12.589141Z", + "iopub.status.busy": "2026-07-20T19:11:12.589030Z", + "iopub.status.idle": "2026-07-20T19:11:12.596837Z", + "shell.execute_reply": "2026-07-20T19:11:12.596532Z" + } + }, + "outputs": [], + "source": [ + "SIM_RE = re.compile(\n", + " r\"^airFoil2D_(?P[^_]+)_\"\n", + " r\"(?P-?\\d+(?:\\.\\d+)?)_\"\n", + " r\"(?P-?\\d+(?:\\.\\d+)?)_\"\n", + " r\"(?P.+)$\"\n", + ")\n", + "\n", + "\n", + "def parse_sim_name(name: str) -> dict:\n", + " m = SIM_RE.match(name)\n", + " if not m:\n", + " raise ValueError(f\"unexpected simulation name: {name}\")\n", + " params = [float(x) for x in m.group(\"params\").split(\"_\")]\n", + " family = \"NACA-4-like\" if len(params) == 3 else \"NACA-5-like\" if len(params) == 4 else \"unknown\"\n", + " u_inf = float(m.group(\"u_inf\"))\n", + " return {\n", + " \"name\": name,\n", + " \"turbulence\": m.group(\"turbulence\"),\n", + " \"u_inf\": u_inf,\n", + " \"alpha_deg\": float(m.group(\"alpha\")),\n", + " \"naca_params\": params,\n", + " \"family\": family,\n", + " \"reynolds_from_name\": u_inf * CHORD / NU_DATASET,\n", + " \"mach_from_name\": u_inf / SOUND_SPEED,\n", + " }\n", + "\n", + "rows = [parse_sim_name(n) for n in sim_names]\n", + "u = np.array([r[\"u_inf\"] for r in rows])\n", + "a = np.array([r[\"alpha_deg\"] for r in rows])\n", + "re_vals = np.array([r[\"reynolds_from_name\"] for r in rows])\n", + "\n", + "print(f\"local simulations: {len(rows)}\")\n", + "print(f\"U_inf range: {u.min():.3f} .. {u.max():.3f} m/s\")\n", + "print(f\"Re range from U/nu: {re_vals.min():.3e} .. {re_vals.max():.3e}\")\n", + "print(f\"angle range: {a.min():.3f} .. {a.max():.3f} deg\")\n", + "print(f\"families: { {family: sum(r['family'] == family for r in rows) for family in sorted(set(r['family'] for r in rows))} }\")\n", + "rows[:3]\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2f2e29bb", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-20T19:11:12.598192Z", + "iopub.status.busy": "2026-07-20T19:11:12.598103Z", + "iopub.status.idle": "2026-07-20T19:11:12.853202Z", + "shell.execute_reply": "2026-07-20T19:11:12.852448Z" + } + }, + "outputs": [], + "source": [ + "fig, axes = plt.subplots(1, 3, figsize=(13, 3.5))\n", + "axes[0].hist(re_vals / 1e6, bins=12)\n", + "axes[0].set_title(\"Local subset Reynolds numbers\")\n", + "axes[0].set_xlabel(\"Re [millions]\")\n", + "axes[0].set_ylabel(\"cases\")\n", + "\n", + "axes[1].hist(a, bins=12)\n", + "axes[1].set_title(\"Angles of attack\")\n", + "axes[1].set_xlabel(\"α [deg]\")\n", + "\n", + "axes[2].scatter(re_vals / 1e6, a, s=28)\n", + "axes[2].set_title(\"Local subset coverage\")\n", + "axes[2].set_xlabel(\"Re [millions]\")\n", + "axes[2].set_ylabel(\"α [deg]\")\n", + "fig.tight_layout()\n" + ] + }, + { + "cell_type": "markdown", + "id": "1ef32b82", + "metadata": {}, + "source": [ + "## 6. Pick one simulation and read its OpenFOAM dictionaries\n", + "\n", + "OpenFOAM cases are self-describing. Important files:\n", + "\n", + "- `system/controlDict`: solver application, time/iteration controls, force-coefficient postprocessor setup;\n", + "- `system/fvSchemes`: discretization schemes;\n", + "- `system/fvSolution`: linear solver and SIMPLE/SIMPLEC settings;\n", + "- `constant/transportProperties`: viscosity;\n", + "- `constant/turbulenceProperties`: RAS/turbulence model;\n", + "- `constant/polyMesh/boundary`: patch names and face ranges.\n", + "\n", + "Change `SIM_INDEX` to inspect a different case.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b1fa24ec", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-20T19:11:12.854493Z", + "iopub.status.busy": "2026-07-20T19:11:12.854338Z", + "iopub.status.idle": "2026-07-20T19:11:12.857336Z", + "shell.execute_reply": "2026-07-20T19:11:12.856721Z" + } + }, + "outputs": [], + "source": [ + "SIM_INDEX = 0\n", + "SIM_NAME = sim_names[SIM_INDEX]\n", + "SIM_DIR = DATA_DIR / SIM_NAME\n", + "meta = parse_sim_name(SIM_NAME)\n", + "print(SIM_NAME)\n", + "print(json.dumps(meta, indent=2))\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e35d99c0", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-20T19:11:12.858618Z", + "iopub.status.busy": "2026-07-20T19:11:12.858481Z", + "iopub.status.idle": "2026-07-20T19:11:12.869906Z", + "shell.execute_reply": "2026-07-20T19:11:12.869229Z" + } + }, + "outputs": [], + "source": [ + "FLOAT_RE = re.compile(r\"[-+]?(?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:[eE][-+]?\\d+)?\")\n", + "INT_RE = re.compile(r\"\\d+\")\n", + "\n", + "\n", + "def open_text(path: Path):\n", + " if path.suffix == \".gz\":\n", + " return gzip.open(path, \"rt\", errors=\"replace\")\n", + " return path.open(\"rt\", errors=\"replace\")\n", + "\n", + "\n", + "def read_text(path: Path, max_bytes: int = 200_000) -> str:\n", + " if path.suffix == \".gz\":\n", + " with gzip.open(path, \"rb\") as stream:\n", + " data = stream.read(max_bytes)\n", + " else:\n", + " data = path.read_bytes()[:max_bytes]\n", + " return data.decode(\"utf-8\", errors=\"replace\")\n", + "\n", + "\n", + "def assignment(text: str, key: str) -> str | None:\n", + " match = re.search(rf\"^\\s*{re.escape(key)}\\s+([^;]+);\", text, flags=re.MULTILINE)\n", + " return match.group(1).strip() if match else None\n", + "\n", + "\n", + "def vector_assignment(text: str, key: str) -> np.ndarray | None:\n", + " value = assignment(text, key)\n", + " if value is None:\n", + " return None\n", + " return np.array([float(item) for item in FLOAT_RE.findall(value)], dtype=float)\n", + "\n", + "\n", + "def parse_boundary(path: Path) -> dict[str, dict[str, int | str]]:\n", + " text = read_text(path, max_bytes=500_000)\n", + " patches: dict[str, dict[str, int | str]] = {}\n", + " for name, body in re.findall(r\"\\n\\s*([A-Za-z][A-Za-z0-9_]*)\\s*\\n\\s*\\{(.*?)\\n\\s*\\}\", text, flags=re.DOTALL):\n", + " patch_type = assignment(body, \"type\") or \"\"\n", + " n_faces = assignment(body, \"nFaces\")\n", + " start_face = assignment(body, \"startFace\")\n", + " if n_faces is not None and start_face is not None:\n", + " patches[name] = {\"type\": patch_type, \"nFaces\": int(n_faces), \"startFace\": int(start_face)}\n", + " return patches\n", + "\n", + "\n", + "def parse_foam_list(path: Path, columns: int) -> np.ndarray:\n", + " expected_count: int | None = None\n", + " in_values = False\n", + " rows = []\n", + " with open_text(path) as stream:\n", + " for line in stream:\n", + " stripped = line.strip()\n", + " if not in_values:\n", + " if expected_count is None and stripped.isdigit():\n", + " expected_count = int(stripped)\n", + " continue\n", + " if expected_count is not None and stripped == \"(\":\n", + " in_values = True\n", + " continue\n", + " continue\n", + " if stripped == \")\":\n", + " break\n", + " nums = [float(item) for item in FLOAT_RE.findall(stripped)]\n", + " if len(nums) >= columns:\n", + " rows.append(nums[:columns])\n", + " arr = np.array(rows, dtype=float)\n", + " if expected_count is not None and len(arr) != expected_count:\n", + " raise ValueError(f\"{path}: parsed {len(arr)} rows, expected {expected_count}\")\n", + " return arr.reshape(-1) if columns == 1 else arr\n", + "\n", + "\n", + "def parse_faces(path: Path, start_face: int, n_faces: int) -> list[list[int]]:\n", + " expected_count = None\n", + " in_values = False\n", + " face_index = -1\n", + " selected = []\n", + " stop_face = start_face + n_faces\n", + " with open_text(path) as stream:\n", + " for line in stream:\n", + " stripped = line.strip()\n", + " if not in_values:\n", + " if expected_count is None and stripped.isdigit():\n", + " expected_count = int(stripped)\n", + " continue\n", + " if expected_count is not None and stripped == \"(\":\n", + " in_values = True\n", + " continue\n", + " continue\n", + " if stripped == \")\":\n", + " break\n", + " face_index += 1\n", + " if face_index < start_face:\n", + " continue\n", + " if face_index >= stop_face:\n", + " break\n", + " values = [int(item) for item in INT_RE.findall(stripped)]\n", + " if values:\n", + " selected.append(values[1:])\n", + " if len(selected) != n_faces:\n", + " raise ValueError(f\"{path}: parsed {len(selected)} selected faces, expected {n_faces}\")\n", + " return selected\n", + "\n", + "\n", + "def load_force_coefficients(path: Path) -> tuple[list[str], np.ndarray]:\n", + " columns = []\n", + " with path.open(\"rt\", errors=\"replace\") as stream:\n", + " for line in stream:\n", + " if line.startswith(\"# Time\"):\n", + " columns = line[1:].split()\n", + " break\n", + " data = np.loadtxt(path, comments=\"#\")\n", + " return columns, data\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9f350525", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-20T19:11:12.871234Z", + "iopub.status.busy": "2026-07-20T19:11:12.871073Z", + "iopub.status.idle": "2026-07-20T19:11:12.876931Z", + "shell.execute_reply": "2026-07-20T19:11:12.876263Z" + } + }, + "outputs": [], + "source": [ + "control_text = read_text(SIM_DIR / \"system\" / \"controlDict\")\n", + "transport_text = read_text(SIM_DIR / \"constant\" / \"transportProperties\")\n", + "turbulence_text = read_text(SIM_DIR / \"constant\" / \"turbulenceProperties\")\n", + "\n", + "application = assignment(control_text, \"application\")\n", + "end_time = assignment(control_text, \"endTime\")\n", + "write_interval = assignment(control_text, \"writeInterval\")\n", + "u_inf_config = float(assignment(control_text, \"Uinf\"))\n", + "nu_case = float(assignment(transport_text, \"nu\"))\n", + "turbulence_model = assignment(turbulence_text, \"RASModel\")\n", + "drag_dir = vector_assignment(control_text, \"dragDir\")\n", + "lift_dir = vector_assignment(control_text, \"liftDir\")\n", + "alpha_from_drag = math.degrees(math.atan2(drag_dir[1], drag_dir[0])) if drag_dir is not None else float(\"nan\")\n", + "\n", + "print(f\"solver application: {application}\")\n", + "print(f\"final solver iteration/endTime: {end_time}\")\n", + "print(f\"writeInterval: {write_interval}\")\n", + "print(f\"RAS turbulence model: {turbulence_model}\")\n", + "print(f\"Uinf from controlDict: {u_inf_config:.3f} m/s\")\n", + "print(f\"nu from transportProperties: {nu_case:.3e} m^2/s\")\n", + "print(f\"Re = U*chord/nu: {u_inf_config / nu_case:.3e}\")\n", + "print(f\"Mach = U/c: {u_inf_config / SOUND_SPEED:.3f}\")\n", + "print(f\"dragDir: {drag_dir}\")\n", + "print(f\"liftDir: {lift_dir}\")\n", + "print(f\"angle inferred from dragDir: {alpha_from_drag:.3f} deg\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "e1380985", + "metadata": {}, + "source": [ + "## 7. Boundary conditions in concrete terms\n", + "\n", + "For the incompressible SST cases in AirfRANS, the paper's Table 7 gives these patch meanings:\n", + "\n", + "| field | internal/initial | aerofoil wall | freestream boundary |\n", + "|---|---:|---|---|\n", + "| `U` | $U_\\infty$ | `noSlip`: wall velocity is zero | `freestreamVelocity` |\n", + "| `p` | 0 in reduced-pressure convention | `zeroGradient` | `freestreamPressure` |\n", + "| `nut` | $\\nu$ initially | low-Re wall function | `freestream` |\n", + "| `k` | about $0.001 U_\\infty^2 / Re_L$ | fixed value | `freestream` |\n", + "| `omega` | about $5U_\\infty/L$ | wall function | `freestream` |\n", + "\n", + "The important non-domain intuition:\n", + "\n", + "- **No slip wall** means the fluid sticks to the airfoil surface: velocity exactly zero at the wall. The rapid change from 0 at the wall to freestream away from it creates large velocity gradients.\n", + "- **Pressure zeroGradient at wall** means the solver does not impose a pressure value at the wall; pressure is solved consistently with momentum and continuity.\n", + "- **Freestream boundary** lets the outer C-grid behave like a far-away free flow boundary.\n", + "- The outer boundary is placed 200 chords away so the arbitrary boundary condition does not pollute the near-airfoil field too much.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1e0fc222", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-20T19:11:12.878190Z", + "iopub.status.busy": "2026-07-20T19:11:12.878049Z", + "iopub.status.idle": "2026-07-20T19:11:12.884898Z", + "shell.execute_reply": "2026-07-20T19:11:12.884089Z" + } + }, + "outputs": [], + "source": [ + "for field in [\"U\", \"p\", \"nut\", \"k\", \"omega\"]:\n", + " candidate = SIM_DIR / \"0\" / field\n", + " if not candidate.exists():\n", + " candidate = SIM_DIR / \"0\" / f\"turbulenceProperties:{field}\"\n", + " if candidate.exists():\n", + " text = read_text(candidate, max_bytes=2_500)\n", + " print(f\"\\n--- 0/{candidate.name} ---\")\n", + " # Show header plus boundaryField region start; enough to connect concepts to files.\n", + " lines = text.splitlines()\n", + " for line in lines[:80]:\n", + " print(line)\n", + " else:\n", + " print(f\"missing initial field for {field}\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "f9513904", + "metadata": {}, + "source": [ + "## 8. Mesh: why so many cells for a 2D problem?\n", + "\n", + "The paper reports around 250k-300k cells per full simulation. That is large for a 2D teaching example, but small compared with industrial 3D CFD.\n", + "\n", + "The key reason is the **boundary layer** near the airfoil. Drag needs wall shear stress:\n", + "\n", + "$$\n", + "\\tau_w \\propto \\mu \\frac{\\partial u_\\text{tangent}}{\\partial n}\\bigg|_\\text{wall}.\n", + "$$\n", + "\n", + "That derivative is only trustworthy if the first cell center is extremely close to the wall. The AirfRANS mesh uses first-cell height $2\\ \\mu\\mathrm{m}$ near the airfoil to get $y^+\\approx 1$, i.e. low-Re wall resolution rather than a coarse wall-function-only treatment.\n", + "\n", + "`points.gz` are vertices. Volume field arrays such as `U.gz` are cell-centered. Boundary patch arrays are face-centered. Counts will not match one-to-one.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "dc969024", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-20T19:11:12.886185Z", + "iopub.status.busy": "2026-07-20T19:11:12.886085Z", + "iopub.status.idle": "2026-07-20T19:11:14.072342Z", + "shell.execute_reply": "2026-07-20T19:11:14.071808Z" + } + }, + "outputs": [], + "source": [ + "points = parse_foam_list(SIM_DIR / \"constant\" / \"polyMesh\" / \"points.gz\", columns=3)\n", + "patches = parse_boundary(SIM_DIR / \"constant\" / \"polyMesh\" / \"boundary\")\n", + "print(f\"mesh vertices/points: {points.shape}\")\n", + "print(\"patches:\")\n", + "for name, info in patches.items():\n", + " print(f\" {name:12} type={info['type']:10} nFaces={info['nFaces']:8} startFace={info['startFace']}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "04c89f1f", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-20T19:11:14.074124Z", + "iopub.status.busy": "2026-07-20T19:11:14.074009Z", + "iopub.status.idle": "2026-07-20T19:11:14.347016Z", + "shell.execute_reply": "2026-07-20T19:11:14.346335Z" + } + }, + "outputs": [], + "source": [ + "rng = np.random.default_rng(20260720)\n", + "sample_count = min(80_000, len(points))\n", + "point_sample = points[rng.choice(len(points), size=sample_count, replace=False)]\n", + "\n", + "fig, axes = plt.subplots(1, 2, figsize=(12, 4))\n", + "axes[0].scatter(point_sample[:, 0], point_sample[:, 1], s=0.15, alpha=0.25)\n", + "axes[0].set_title(\"Full C-grid vertex sample\")\n", + "axes[0].set_aspect(\"equal\", adjustable=\"box\")\n", + "axes[0].set_xlabel(\"x [m]\")\n", + "axes[0].set_ylabel(\"y [m]\")\n", + "\n", + "near = point_sample[(point_sample[:, 0] > -0.4) & (point_sample[:, 0] < 1.4) & (np.abs(point_sample[:, 1]) < 0.45)]\n", + "axes[1].scatter(near[:, 0], near[:, 1], s=0.4, alpha=0.45)\n", + "axes[1].set_title(\"Near-airfoil mesh concentration\")\n", + "axes[1].set_aspect(\"equal\", adjustable=\"box\")\n", + "axes[1].set_xlabel(\"x [m]\")\n", + "fig.tight_layout()\n" + ] + }, + { + "cell_type": "markdown", + "id": "8adf2d5d", + "metadata": {}, + "source": [ + "## 9. Integrated forces: what $C_D$ and $C_L$ mean\n", + "\n", + "Surface stress force combines pressure and viscous stress. The paper writes a face force as\n", + "\n", + "$$\n", + "df = -p n\\,dS + 2\\mu S\\cdot n\\,dS.\n", + "$$\n", + "\n", + "OpenFOAM integrates over the airfoil wall. Then:\n", + "\n", + "- **drag** $D$ is the component parallel to freestream direction,\n", + "- **lift** $L$ is the component perpendicular to freestream direction,\n", + "- coefficients divide by dynamic pressure times reference area:\n", + "\n", + "$$\n", + "C_D = \\frac{D}{\\frac{1}{2}\\rho U_\\infty^2 A},\\qquad\n", + "C_L = \\frac{L}{\\frac{1}{2}\\rho U_\\infty^2 A}.\n", + "$$\n", + "\n", + "For this 2D dataset, the reference area is effectively chord $\\times$ unit span, so $A=1\\ \\mathrm{m^2}$.\n", + "\n", + "Why this matters for ML: a model can have visually plausible pressure/velocity fields but still rank airfoils incorrectly by $C_D$ or $C_L$. AirfRANS evaluates both fields and force coefficients.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ba58a7d4", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-20T19:11:14.349038Z", + "iopub.status.busy": "2026-07-20T19:11:14.348886Z", + "iopub.status.idle": "2026-07-20T19:11:14.385211Z", + "shell.execute_reply": "2026-07-20T19:11:14.383778Z" + } + }, + "outputs": [], + "source": [ + "coeff_path = SIM_DIR / \"postProcessing\" / \"forceCoeffs1\" / \"0\" / \"coefficient.dat\"\n", + "coeff_columns, coeff_data = load_force_coefficients(coeff_path)\n", + "lookup = {name: idx for idx, name in enumerate(coeff_columns)}\n", + "time = coeff_data[:, lookup[\"Time\"]]\n", + "cd = coeff_data[:, lookup[\"Cd\"]]\n", + "cl = coeff_data[:, lookup[\"Cl\"]]\n", + "cm = coeff_data[:, lookup[\"CmPitch\"]]\n", + "\n", + "print(coeff_columns)\n", + "print(f\"rows: {len(coeff_data)}\")\n", + "print(f\"final iteration: {time[-1]:.0f}\")\n", + "print(f\"final Cd: {cd[-1]:.6f}\")\n", + "print(f\"final Cl: {cl[-1]:.6f}\")\n", + "print(f\"final CmPitch: {cm[-1]:.6f}\")\n", + "print(f\"last 500 Cd std: {np.std(cd[-min(500, len(cd)):]):.3e}\")\n", + "print(f\"last 500 Cl std: {np.std(cl[-min(500, len(cl)):]):.3e}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "51cb325f", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-20T19:11:14.386355Z", + "iopub.status.busy": "2026-07-20T19:11:14.386250Z", + "iopub.status.idle": "2026-07-20T19:11:14.682440Z", + "shell.execute_reply": "2026-07-20T19:11:14.681608Z" + } + }, + "outputs": [], + "source": [ + "fig, axes = plt.subplots(1, 2, figsize=(12, 4))\n", + "axes[0].plot(time, cd, label=\"Cd\")\n", + "axes[0].plot(time, cl, label=\"Cl\")\n", + "axes[0].plot(time, cm, label=\"CmPitch\")\n", + "axes[0].set_title(\"Force/moment coefficient convergence history\")\n", + "axes[0].set_xlabel(\"simpleFoam iteration\")\n", + "axes[0].legend()\n", + "\n", + "window = min(750, len(time))\n", + "axes[1].plot(time[-window:], cd[-window:], label=\"Cd\")\n", + "axes[1].plot(time[-window:], cl[-window:], label=\"Cl\")\n", + "axes[1].set_title(f\"Final {window} iterations\")\n", + "axes[1].set_xlabel(\"simpleFoam iteration\")\n", + "axes[1].legend()\n", + "fig.tight_layout()\n" + ] + }, + { + "cell_type": "markdown", + "id": "bc431803", + "metadata": {}, + "source": [ + "## 10. Airfoil-surface quantities: yPlus, wall shear, force coefficient density\n", + "\n", + "The `aerofoil` patch is a sequence of wall faces. For each face we can approximate a face center from its vertices, then plot surface fields:\n", + "\n", + "- `wallShearStress`: vector shear stress-like wall quantity from the OpenFOAM postprocessing field;\n", + "- `forceCoeff`: local force coefficient contribution on faces;\n", + "- `yPlus`: nondimensional first-cell wall distance. Values near or below 1 are what the paper wanted for resolved boundary layers.\n", + "\n", + "These surface quantities are central to drag. Lift is often dominated by pressure distribution; drag is more sensitive to velocity-gradient errors near the wall.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6d3ea796", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-20T19:11:14.683807Z", + "iopub.status.busy": "2026-07-20T19:11:14.683663Z", + "iopub.status.idle": "2026-07-20T19:11:14.777574Z", + "shell.execute_reply": "2026-07-20T19:11:14.776955Z" + } + }, + "outputs": [], + "source": [ + "aerofoil_patch = patches[\"aerofoil\"]\n", + "aerofoil_faces = parse_faces(\n", + " SIM_DIR / \"constant\" / \"polyMesh\" / \"faces.gz\",\n", + " start_face=int(aerofoil_patch[\"startFace\"]),\n", + " n_faces=int(aerofoil_patch[\"nFaces\"]),\n", + ")\n", + "aerofoil_centers = np.array([points[face, :2].mean(axis=0) for face in aerofoil_faces])\n", + "\n", + "surface_force = parse_foam_list(SIM_DIR / \"40000\" / \"forceCoeff.gz\", columns=3)\n", + "wall_shear = parse_foam_list(SIM_DIR / \"40000\" / \"wallShearStress.gz\", columns=3)\n", + "y_plus = parse_foam_list(SIM_DIR / \"40000\" / \"yPlus.gz\", columns=1)\n", + "\n", + "force_norm = np.linalg.norm(surface_force[:, :2], axis=1)\n", + "shear_norm = np.linalg.norm(wall_shear[:, :2], axis=1)\n", + "\n", + "print(f\"aerofoil faces: {len(aerofoil_faces)}\")\n", + "print(f\"surface_force rows: {surface_force.shape}\")\n", + "print(f\"wall_shear rows: {wall_shear.shape}\")\n", + "print(f\"yPlus rows: {y_plus.shape}\")\n", + "print(f\"yPlus min/median/max: {y_plus.min():.4f} / {np.median(y_plus):.4f} / {y_plus.max():.4f}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "29982f97", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-20T19:11:14.778789Z", + "iopub.status.busy": "2026-07-20T19:11:14.778638Z", + "iopub.status.idle": "2026-07-20T19:11:15.101946Z", + "shell.execute_reply": "2026-07-20T19:11:15.101306Z" + } + }, + "outputs": [], + "source": [ + "fig, axes = plt.subplots(1, 3, figsize=(14, 4))\n", + "for ax, values, title in [\n", + " (axes[0], force_norm, \"|forceCoeff| on wall faces\"),\n", + " (axes[1], shear_norm, \"|wallShearStress|\"),\n", + " (axes[2], y_plus, \"yPlus\"),\n", + "]:\n", + " sc = ax.scatter(aerofoil_centers[:, 0], aerofoil_centers[:, 1], c=values, s=13, cmap=\"viridis\")\n", + " ax.set_title(title)\n", + " ax.set_aspect(\"equal\", adjustable=\"box\")\n", + " ax.set_xlabel(\"x [m]\")\n", + " fig.colorbar(sc, ax=ax, shrink=0.8)\n", + "fig.tight_layout()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a9582f0a", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-20T19:11:15.103453Z", + "iopub.status.busy": "2026-07-20T19:11:15.103294Z", + "iopub.status.idle": "2026-07-20T19:11:15.282512Z", + "shell.execute_reply": "2026-07-20T19:11:15.282063Z" + } + }, + "outputs": [], + "source": [ + "idx = np.arange(len(y_plus))\n", + "fig, axes = plt.subplots(3, 1, figsize=(10, 8), sharex=True)\n", + "axes[0].plot(idx, force_norm)\n", + "axes[0].set_ylabel(\"|forceCoeff|\")\n", + "axes[1].plot(idx, shear_norm)\n", + "axes[1].set_ylabel(\"|wall shear|\")\n", + "axes[2].plot(idx, y_plus)\n", + "axes[2].axhline(1.0, color=\"black\", linestyle=\"--\", linewidth=1, label=\"yPlus=1\")\n", + "axes[2].set_ylabel(\"yPlus\")\n", + "axes[2].set_xlabel(\"aerofoil boundary face index; not physical arc-length\")\n", + "axes[2].legend()\n", + "fig.tight_layout()\n" + ] + }, + { + "cell_type": "markdown", + "id": "39e3601e", + "metadata": {}, + "source": [ + "## 11. Volume fields: what the surrogate model sees as targets\n", + "\n", + "At the final iteration folder (`40000/` here), the raw OpenFOAM case contains cell-centered fields. AirfRANS's preprocessed ML dataset keeps, after cropping/slicing:\n", + "\n", + "- velocity $\\bar u_x, \\bar u_y$,\n", + "- reduced pressure $\\bar p/\\rho$,\n", + "- turbulent kinematic viscosity $\\nu_t$,\n", + "- signed/implicit distance to the airfoil as input geometry signal,\n", + "- surface flag / normals as geometry features.\n", + "\n", + "The paper's supervised learning target per point is roughly\n", + "\n", + "$$\n", + "y_i = (\\bar u_x,\\bar u_y,\\bar p,\\nu_t)_i.\n", + "$$\n", + "\n", + "The input per point is roughly\n", + "\n", + "$$\n", + "x_i = (x,y,U_{\\infty,x},U_{\\infty,y},\\mathrm{distance},n_x,n_y)_i,\n", + "$$\n", + "\n", + "with normals zero away from the airfoil. Exact library attributes include `position`, `input_velocity`, `sdf`, `surface`, and `normals`.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "187f7fea", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-20T19:11:15.284075Z", + "iopub.status.busy": "2026-07-20T19:11:15.283994Z", + "iopub.status.idle": "2026-07-20T19:11:17.039996Z", + "shell.execute_reply": "2026-07-20T19:11:17.039369Z" + } + }, + "outputs": [], + "source": [ + "U = parse_foam_list(SIM_DIR / \"40000\" / \"U.gz\", columns=3)\n", + "p = parse_foam_list(SIM_DIR / \"40000\" / \"p.gz\", columns=1)\n", + "nut_path = SIM_DIR / \"40000\" / \"turbulenceProperties:nut.gz\"\n", + "k_path = SIM_DIR / \"40000\" / \"turbulenceProperties:k.gz\"\n", + "omega_path = SIM_DIR / \"40000\" / \"turbulenceProperties:omega.gz\"\n", + "nut = parse_foam_list(nut_path, columns=1) if nut_path.exists() else np.array([])\n", + "k = parse_foam_list(k_path, columns=1) if k_path.exists() else np.array([])\n", + "omega = parse_foam_list(omega_path, columns=1) if omega_path.exists() else np.array([])\n", + "speed = np.linalg.norm(U[:, :2], axis=1)\n", + "\n", + "def summary(name, values):\n", + " finite = values[np.isfinite(values)]\n", + " return {\n", + " \"name\": name,\n", + " \"count\": int(values.size),\n", + " \"min\": float(np.min(finite)),\n", + " \"p01\": float(np.percentile(finite, 1)),\n", + " \"mean\": float(np.mean(finite)),\n", + " \"p99\": float(np.percentile(finite, 99)),\n", + " \"max\": float(np.max(finite)),\n", + " }\n", + "\n", + "summaries = [summary(\"|U_xy|\", speed), summary(\"Ux\", U[:,0]), summary(\"Uy\", U[:,1]), summary(\"p\", p)]\n", + "if nut.size: summaries.append(summary(\"nut\", nut))\n", + "if k.size: summaries.append(summary(\"k\", k))\n", + "if omega.size: summaries.append(summary(\"omega\", omega))\n", + "summaries\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2eccca27", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-20T19:11:17.041292Z", + "iopub.status.busy": "2026-07-20T19:11:17.041183Z", + "iopub.status.idle": "2026-07-20T19:11:17.671734Z", + "shell.execute_reply": "2026-07-20T19:11:17.671231Z" + } + }, + "outputs": [], + "source": [ + "plots = [(speed, \"speed |U_xy|\"), (p, \"reduced pressure p\"), (nut, \"turbulent viscosity nut\"), (k, \"turbulent kinetic energy k\")]\n", + "fig, axes = plt.subplots(2, 2, figsize=(12, 8))\n", + "for ax, (values, title) in zip(axes.flat, plots):\n", + " if values.size:\n", + " ax.hist(values[np.isfinite(values)], bins=80)\n", + " ax.set_yscale(\"log\")\n", + " ax.set_title(title)\n", + "fig.tight_layout()\n" + ] + }, + { + "cell_type": "markdown", + "id": "99baa471", + "metadata": {}, + "source": [ + "## 12. Airfoil geometry: generate a simple NACA 4-digit profile\n", + "\n", + "AirfRANS includes both NACA 4- and 5-digit families. This code implements only the 4-digit equations because they are compact and useful for intuition.\n", + "\n", + "For NACA `MPXX`:\n", + "\n", + "- $m=0.01M$ is maximum camber fraction,\n", + "- $p=0.1P$ is max-camber position as chord fraction,\n", + "- $t=XX/100$ is thickness fraction.\n", + "\n", + "The thickness envelope is\n", + "\n", + "$$\n", + "y_t(x)=\\frac{t}{0.2}\\left(0.2969\\sqrt{x}-0.1260x-0.3516x^2+0.2843x^3-0.1015x^4\\right).\n", + "$$\n", + "\n", + "The camber line bends the upper/lower surfaces by the local angle $\\theta=\\arctan(y_c')$.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2fdb418b", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-20T19:11:17.673116Z", + "iopub.status.busy": "2026-07-20T19:11:17.672936Z", + "iopub.status.idle": "2026-07-20T19:11:17.777014Z", + "shell.execute_reply": "2026-07-20T19:11:17.776578Z" + } + }, + "outputs": [], + "source": [ + "def naca4(M=2.0, P=4.0, XX=12.0, n=250):\n", + " x = np.linspace(0, 1, n)\n", + " m = 0.01 * M\n", + " p = 0.1 * P\n", + " t = XX / 100\n", + " yt = (t / 0.2) * (0.2969*np.sqrt(x) - 0.1260*x - 0.3516*x**2 + 0.2843*x**3 - 0.1015*x**4)\n", + " if m == 0 or p == 0:\n", + " yc = np.zeros_like(x)\n", + " dyc = np.zeros_like(x)\n", + " else:\n", + " yc = np.where(x <= p, m / p**2 * (2*p*x - x**2), m / (1-p)**2 * ((1 - 2*p) + 2*p*x - x**2))\n", + " dyc = np.where(x <= p, 2*m / p**2 * (p - x), 2*m / (1-p)**2 * (p - x))\n", + " theta = np.arctan(dyc)\n", + " xu = x - yt * np.sin(theta)\n", + " yu = yc + yt * np.cos(theta)\n", + " xl = x + yt * np.sin(theta)\n", + " yl = yc - yt * np.cos(theta)\n", + " return x, yc, xu, yu, xl, yl\n", + "\n", + "fig, ax = plt.subplots(figsize=(9, 3))\n", + "for M, P, XX, label in [(0, 0, 12, \"0012 symmetric\"), (2, 4, 12, \"2412 cambered\"), (4, 4, 15, \"4415 thicker/cambered\")]:\n", + " x, yc, xu, yu, xl, yl = naca4(M, P, XX)\n", + " ax.plot(xu, yu, label=label)\n", + " ax.plot(xl, yl, color=ax.lines[-1].get_color())\n", + "ax.set_aspect(\"equal\", adjustable=\"box\")\n", + "ax.set_xlabel(\"x / chord\")\n", + "ax.set_ylabel(\"y / chord\")\n", + "ax.set_title(\"NACA 4-digit geometry intuition\")\n", + "ax.legend()\n", + "fig.tight_layout()\n" + ] + }, + { + "cell_type": "markdown", + "id": "d7668533", + "metadata": {}, + "source": [ + "## 13. What the data is used for\n", + "\n", + "The dataset is built for **surrogate modeling**: replace a slow CFD solve with a learned function that maps geometry + boundary conditions to flow fields and force coefficients.\n", + "\n", + "Concrete ML tasks in the paper/docs:\n", + "\n", + "1. **Full data interpolation**: train on 800 simulations, test on 200 from same distribution.\n", + "2. **Scarce data interpolation**: train on 200, same 200-case test set as full regime.\n", + "3. **Reynolds extrapolation**: train only on $\\mathrm{Re}\\in[3,5]\\times10^6$, test below 3e6 and above 5e6.\n", + "4. **Angle-of-attack extrapolation**: train on $\\alpha\\in[-2.5^\\circ,12.5^\\circ]$, test on $[-5,-2.5]$ and $[12.5,15]$ degrees.\n", + "\n", + "Targets and evaluation:\n", + "\n", + "- field MSE for $\\bar u_x,\\bar u_y,\\bar p,\\nu_t$ in the volume;\n", + "- surface pressure MSE on airfoil;\n", + "- relative error for $C_D$ and $C_L$;\n", + "- Spearman rank correlation for $C_D$ and $C_L$, important for optimization because ranking airfoils correctly can matter more than exact coefficient calibration.\n", + "\n", + "The paper found drag harder than lift for the baselines. Reason: lift is often dominated by pressure distribution, which models predicted better; drag depends strongly on wall shear stress, i.e. near-wall velocity gradients, which are hard to recover from sampled point-cloud training.\n" + ] + }, + { + "cell_type": "markdown", + "id": "17c606a1", + "metadata": {}, + "source": [ + "## 14. Preprocessing: why raw OpenFOAM differs from the ML dataset\n", + "\n", + "Raw OpenFOAM cases contain the full farfield and many files. The preprocessed AirfRANS dataset:\n", + "\n", + "- clips the internal field to $x\\in[-2,4]$, $y\\in[-1.5,1.5]$, $z\\in[0,1]$;\n", + "- slices at $z=0.5$ to get a 2D representation from the thin 3D OpenFOAM mesh;\n", + "- computes an implicit distance / signed-distance-like field to the airfoil;\n", + "- keeps only pressure, velocity, turbulent viscosity, distance for internal nodes;\n", + "- for the airfoil patch, computes inward-pointing normals, slices to 1D, and keeps pressure, velocity, turbulent viscosity, normals.\n", + "\n", + "The raw case remains useful because it exposes solver dictionaries, gradients/postprocessing fields, and force histories. The preprocessed case is convenient for ML.\n" + ] + }, + { + "cell_type": "markdown", + "id": "2111d2fa", + "metadata": {}, + "source": [ + "## 15. Practical checklist when you inspect or model these simulations\n", + "\n", + "Use this checklist to avoid domain mistakes:\n", + "\n", + "1. **Do not treat the mesh as an image.** It is unstructured and highly nonuniform; near-wall density is intentional.\n", + "2. **Distinguish cells, vertices, and faces.** Raw OpenFOAM volume fields here are cell-centered; patch fields are face-centered; preprocessed VTK data may be node-based.\n", + "3. **Pressure is reduced pressure in incompressible OpenFOAM.** It is effectively $p/\\rho$, not absolute atmospheric pressure.\n", + "4. **Reynolds is encoded through velocity.** With fixed $\\nu$ and chord 1 m, $U_\\infty$ determines $\\mathrm{Re}$.\n", + "5. **Angle of attack rotates the freestream/force directions.** Check `dragDir` and `liftDir`, not only the filename.\n", + "6. **Drag needs near-wall gradients.** Good volume MSE does not guarantee good $C_D$.\n", + "7. **Lift/drag coefficients are integrated outputs.** They are computed from pressure and wall shear over the airfoil surface, normalized by dynamic pressure.\n", + "8. **Extrapolation tasks are materially harder.** A model good inside the sampled Re/AoA distribution may fail outside it.\n", + "\n", + "Next cells print raw dictionary snippets so you can connect the explanations above to actual files.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "336f680c", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-20T19:11:17.778411Z", + "iopub.status.busy": "2026-07-20T19:11:17.778320Z", + "iopub.status.idle": "2026-07-20T19:11:17.780856Z", + "shell.execute_reply": "2026-07-20T19:11:17.780315Z" + } + }, + "outputs": [], + "source": [ + "print(\"--- system/controlDict preview ---\")\n", + "print(read_text(SIM_DIR / \"system\" / \"controlDict\", max_bytes=6_000))\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "940c0923", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-20T19:11:17.782129Z", + "iopub.status.busy": "2026-07-20T19:11:17.782013Z", + "iopub.status.idle": "2026-07-20T19:11:17.784645Z", + "shell.execute_reply": "2026-07-20T19:11:17.784234Z" + } + }, + "outputs": [], + "source": [ + "print(\"--- constant/turbulenceProperties preview ---\")\n", + "print(read_text(SIM_DIR / \"constant\" / \"turbulenceProperties\", max_bytes=3_000))\n", + "print(\"\\n--- constant/transportProperties preview ---\")\n", + "print(read_text(SIM_DIR / \"constant\" / \"transportProperties\", max_bytes=3_000))\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3992406a", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-20T19:11:17.785699Z", + "iopub.status.busy": "2026-07-20T19:11:17.785619Z", + "iopub.status.idle": "2026-07-20T19:11:17.787920Z", + "shell.execute_reply": "2026-07-20T19:11:17.787486Z" + } + }, + "outputs": [], + "source": [ + "print(\"--- final U field header and first values ---\")\n", + "print(read_text(SIM_DIR / \"40000\" / \"U.gz\", max_bytes=4_000))\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} \ No newline at end of file diff --git a/notebooks/explore_raw_subset.ipynb b/notebooks/explore_raw_subset.ipynb new file mode 100644 index 0000000..a1b8b62 --- /dev/null +++ b/notebooks/explore_raw_subset.ipynb @@ -0,0 +1,1654 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "3df2f77e", + "metadata": {}, + "source": [ + "# Explore the local AirfRANS raw subset\n", + "\n", + "This notebook is a guided tour through one raw OpenFOAM-style AirfRANS simulation and the 50-simulation local subset. It imports the package utilities in `src/airfrans_frontier`; it does not train models, download data, or mutate the dataset.\n", + "\n", + "AirfRANS cases are CFD simulations around 2D aerofoils. The raw case is a solver directory, not a tidy ML table. Each file is tied to a physical object:\n", + "\n", + "- `system/`: solver controls, freestream direction, reference values, and output functions.\n", + "- `constant/polyMesh/`: mesh topology; points, faces, and named boundary patches.\n", + "- `0/`: initial field values and boundary conditions.\n", + "- `40000/`: final solved fields after the steady solver reached its last iteration.\n", + "- `postProcessing/`: histories such as drag/lift coefficients over solver iterations.\n", + "\n", + "The charts below answer three questions: which simulations are in the subset, what one selected simulation represents physically, and what the final solver fields look like on the aerofoil surface and throughout the domain.\n" + ] + }, + { + "cell_type": "markdown", + "id": "745e9b81", + "metadata": {}, + "source": [ + "## Setup\n", + "\n", + "Run from the repository root or the `notebooks/` directory. Select the repository `.venv` as the notebook kernel. If imports fail, run `uv sync --dev` from the repository root, restart VS Code's notebook kernel picker, and choose the `.venv` interpreter.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "255840f4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "python: /home/aaron/data/airfrans/.venv/bin/python\n", + "repo: /home/aaron/data/airfrans\n", + "data: /home/aaron/data/airfrans/data/raw/OF_dataset\n" + ] + } + ], + "source": [ + "from pathlib import Path\n", + "import gzip\n", + "import math\n", + "import re\n", + "import sys\n", + "print(f\"python: {sys.executable}\")\n", + "\n", + "\n", + "try:\n", + " import matplotlib.pyplot as plt\n", + " import numpy as np\n", + "except ModuleNotFoundError as exc:\n", + " raise ModuleNotFoundError(\n", + " f\"{exc.name!r} is not installed in this notebook kernel: {sys.executable}. \"\n", + " \"From the repository root, run `uv sync --dev`, then restart the VS Code kernel.\"\n", + " ) from exc\n", + "\n", + "\n", + "\n", + "def find_repo_root(start: Path) -> Path:\n", + " for candidate in (start, *start.parents):\n", + " if (candidate / \"pyproject.toml\").exists() and (candidate / \"src\" / \"airfrans_frontier\").exists():\n", + " return candidate\n", + " raise RuntimeError(f\"Could not find repository root from {start}\")\n", + "\n", + "\n", + "REPO_ROOT = find_repo_root(Path.cwd())\n", + "SRC_DIR = REPO_ROOT / \"src\"\n", + "if str(SRC_DIR) not in sys.path:\n", + " sys.path.insert(0, str(SRC_DIR))\n", + "\n", + "from airfrans_frontier.paths import DEFAULT_RAW_DATA_DIR, DEFAULT_RAW_MANIFEST_PATH\n", + "from airfrans_frontier.raw.inspect import format_raw_inspection, inspect_raw_subset\n", + "from airfrans_frontier.raw.manifest import load_raw_subset_manifest\n", + "\n", + "DATA_DIR = REPO_ROOT / DEFAULT_RAW_DATA_DIR\n", + "MANIFEST_PATH = REPO_ROOT / DEFAULT_RAW_MANIFEST_PATH\n", + "print(f\"repo: {REPO_ROOT}\")\n", + "print(f\"data: {DATA_DIR}\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "a920e5bc", + "metadata": {}, + "source": [ + "## Verify the local subset\n", + "\n", + "This is the same package-backed check as the CLI. If this fails, fix local data before interpreting plots.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "792f49bd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "AirfRANS raw subset\n", + "status: ok\n", + "data_dir: /home/aaron/data/airfrans/data/raw/OF_dataset\n", + "manifest: /home/aaron/data/airfrans/data/raw/OF_dataset_subset_manifest.json\n", + "simulations: 50 / 50\n", + "files: 5820 / 5820\n", + "bytes: 7565631222 / 7565631222 (7.57 GB)\n", + "source_zip_bytes: 71310335730\n", + "sample_seed: 20260719\n", + "sample_method: uniform random sample without replacement from the 1000 top-level OF_dataset simulation directories, using sorted names as the sampling population\n", + "sample_simulations:\n", + "- airFoil2D_SST_32.137_12.122_4.854_5.202_9.247\n", + "- airFoil2D_SST_33.238_-0.071_0.667_2.065_6.479\n", + "- airFoil2D_SST_33.816_-1.984_6.59_0.0_7.983\n", + "- airFoil2D_SST_33.846_6.261_0.922_3.023_1.0_12.36\n", + "- airFoil2D_SST_36.155_8.69_3.296_7.636_1.0_8.571\n", + "- airFoil2D_SST_38.797_3.751_1.748_7.04_0.0_19.453\n", + "- airFoil2D_SST_40.175_10.442_1.962_3.054_0.0_6.878\n", + "- airFoil2D_SST_40.585_14.545_0.315_2.716_9.25\n", + "... 42 more\n" + ] + } + ], + "source": [ + "report = inspect_raw_subset(DATA_DIR, MANIFEST_PATH)\n", + "print(format_raw_inspection(report, sample_limit=8))\n" + ] + }, + { + "cell_type": "markdown", + "id": "1aad48db", + "metadata": {}, + "source": [ + "## Subset-level simulation conditions\n", + "\n", + "Simulation names encode the sampled run conditions and NACA shape parameters. This section turns those names into columns so we can see what local cases are available before opening a single case.\n", + "\n", + "Name pattern used here:\n", + "\n", + "`airFoil2D______`\n", + "\n", + "Meaning of the parsed values:\n", + "\n", + "- `turbulence`: turbulence closure family used to generate the case.\n", + "- `U_inf`: freestream speed in m/s. Higher values increase the Reynolds number when viscosity is fixed.\n", + "- `alpha`: angle of attack in degrees. Positive/negative values rotate the incoming flow relative to the aerofoil and usually change lift sign/magnitude.\n", + "- `naca_a`, `naca_b`, `naca_c`: NACA shape parameters encoded by the dataset. Treat them as geometry descriptors: they identify aerofoil shape variation, not solver outputs.\n", + "\n", + "The histograms show how many local cases occupy each range of `U_inf` and `alpha`; the scatter plot shows whether speed and angle are sampled independently or clustered in this subset.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "30001151", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "simulations: 50\n", + "U_inf range: 32.137 .. 93.213 m/s\n", + "alpha range: -2.718 .. 14.794 deg\n", + "First parsed rows show one case per simulation directory:\n" + ] + }, + { + "data": { + "text/plain": [ + "[{'name': 'airFoil2D_SST_32.137_12.122_4.854_5.202_9.247',\n", + " 'turbulence': 'SST',\n", + " 'u_inf': 32.137,\n", + " 'alpha': 12.122,\n", + " 'naca_a': 4.854,\n", + " 'naca_b': 5.202,\n", + " 'naca_c': 9.247},\n", + " {'name': 'airFoil2D_SST_33.238_-0.071_0.667_2.065_6.479',\n", + " 'turbulence': 'SST',\n", + " 'u_inf': 33.238,\n", + " 'alpha': -0.071,\n", + " 'naca_a': 0.667,\n", + " 'naca_b': 2.065,\n", + " 'naca_c': 6.479},\n", + " {'name': 'airFoil2D_SST_33.816_-1.984_6.59_0.0_7.983',\n", + " 'turbulence': 'SST',\n", + " 'u_inf': 33.816,\n", + " 'alpha': -1.984,\n", + " 'naca_a': 6.59,\n", + " 'naca_b': 0.0,\n", + " 'naca_c': 7.983},\n", + " {'name': 'airFoil2D_SST_33.846_6.261_0.922_3.023_1.0_12.36'},\n", + " {'name': 'airFoil2D_SST_36.155_8.69_3.296_7.636_1.0_8.571'}]" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "manifest = load_raw_subset_manifest(MANIFEST_PATH)\n", + "sim_names = list(manifest.simulation_names)\n", + "\n", + "# Simulation directory names carry both operating conditions and geometry parameters.\n", + "# The named capture groups below become explicit variables instead of leaving the\n", + "# notebook reader to decode a long string by eye.\n", + "SIM_RE = re.compile(\n", + " r\"^airFoil2D_(?P[^_]+)_\" # solver/turbulence family label\n", + " r\"(?P-?\\d+(?:\\.\\d+)?)_\" # freestream speed U_inf [m/s]\n", + " r\"(?P-?\\d+(?:\\.\\d+)?)_\" # angle of attack alpha [degrees]\n", + " r\"(?P-?\\d+(?:\\.\\d+)?)_\" # first encoded NACA geometry parameter\n", + " r\"(?P-?\\d+(?:\\.\\d+)?)_\" # second encoded NACA geometry parameter\n", + " r\"(?P-?\\d+(?:\\.\\d+)?)$\" # third encoded NACA geometry parameter\n", + ")\n", + "\n", + "\n", + "def parse_sim_name(name: str) -> dict[str, float | str]:\n", + " \"\"\"Parse one AirfRANS simulation directory name into readable columns.\"\"\"\n", + " match = SIM_RE.match(name)\n", + " if not match:\n", + " # Keep unparsed names visible rather than dropping them silently.\n", + " return {\"name\": name}\n", + "\n", + " row: dict[str, float | str] = {\"name\": name, \"turbulence\": match.group(\"turbulence\")}\n", + "\n", + " # Convert numeric groups to floats so range checks, histograms, and scatter\n", + " # plots operate on real values rather than lexicographic strings.\n", + " for key in [\"u_inf\", \"alpha\", \"naca_a\", \"naca_b\", \"naca_c\"]:\n", + " row[key] = float(match.group(key))\n", + " return row\n", + "\n", + "\n", + "sim_meta = [parse_sim_name(name) for name in sim_names]\n", + "u_inf = np.array([row[\"u_inf\"] for row in sim_meta if \"u_inf\" in row], dtype=float)\n", + "alpha = np.array([row[\"alpha\"] for row in sim_meta if \"alpha\" in row], dtype=float)\n", + "\n", + "print(f\"simulations: {len(sim_names)}\")\n", + "print(f\"U_inf range: {u_inf.min():.3f} .. {u_inf.max():.3f} m/s\")\n", + "print(f\"alpha range: {alpha.min():.3f} .. {alpha.max():.3f} deg\")\n", + "print(\"First parsed rows show one case per simulation directory:\")\n", + "sim_meta[:5]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "15776396", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(1, 3, figsize=(14, 3.8))\n", + "axes[0].hist(u_inf, bins=12, edgecolor=\"white\")\n", + "axes[0].set_title(\"Freestream speed distribution\")\n", + "axes[0].set_xlabel(\"U_inf [m/s]; imposed incoming speed\")\n", + "axes[0].set_ylabel(\"number of simulation cases\")\n", + "axes[0].grid(alpha=0.25)\n", + "\n", + "axes[1].hist(alpha, bins=12, edgecolor=\"white\")\n", + "axes[1].set_title(\"Angle-of-attack distribution\")\n", + "axes[1].set_xlabel(\"alpha [deg]; inflow angle relative to aerofoil\")\n", + "axes[1].set_ylabel(\"number of simulation cases\")\n", + "axes[1].grid(alpha=0.25)\n", + "\n", + "axes[2].scatter(u_inf, alpha, s=28, alpha=0.8)\n", + "axes[2].set_title(\"Local subset coverage\")\n", + "axes[2].set_xlabel(\"U_inf [m/s]\")\n", + "axes[2].set_ylabel(\"alpha [deg]\")\n", + "axes[2].grid(alpha=0.25)\n", + "fig.suptitle(\"Each mark/bin is one raw simulation directory\", y=1.03)\n", + "fig.tight_layout()\n" + ] + }, + { + "cell_type": "markdown", + "id": "619e4a24", + "metadata": {}, + "source": [ + "### Reading the subset chart\n", + "\n", + "- Left histogram: tall bars mean many simulations share a similar freestream speed. This is input coverage, not a performance metric.\n", + "- Middle histogram: bars count cases by angle of attack. Angles far from zero are more aggressive flow conditions and may show stronger lift, separation, or numerical difficulty.\n", + "- Right scatter: each point is one case. A rectangular cloud would mean broad coverage of speed/angle combinations; diagonal bands or clusters would mean the subset only samples certain combinations.\n", + "\n", + "These plots do not say whether a simulation is accurate or converged. They only describe the local subset's operating-condition coverage.\n" + ] + }, + { + "cell_type": "markdown", + "id": "30b94d50", + "metadata": {}, + "source": [ + "## Pick one simulation to understand\n", + "\n", + "Start with index `0`, then change `SIM_INDEX` and rerun cells below. The selected case is a complete OpenFOAM run directory.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "5ca9a3fd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "airFoil2D_SST_32.137_12.122_4.854_5.202_9.247\n", + "/home/aaron/data/airfrans/data/raw/OF_dataset/airFoil2D_SST_32.137_12.122_4.854_5.202_9.247\n" + ] + }, + { + "data": { + "text/plain": [ + "{'name': 'airFoil2D_SST_32.137_12.122_4.854_5.202_9.247',\n", + " 'turbulence': 'SST',\n", + " 'u_inf': 32.137,\n", + " 'alpha': 12.122,\n", + " 'naca_a': 4.854,\n", + " 'naca_b': 5.202,\n", + " 'naca_c': 9.247}" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "SIM_INDEX = 0\n", + "SIM_NAME = sim_names[SIM_INDEX]\n", + "SIM_DIR = DATA_DIR / SIM_NAME\n", + "print(SIM_NAME)\n", + "print(SIM_DIR)\n", + "parse_sim_name(SIM_NAME)\n" + ] + }, + { + "cell_type": "markdown", + "id": "5af214c1", + "metadata": {}, + "source": [ + "## OpenFOAM parsing helpers\n", + "\n", + "These helpers read ASCII OpenFOAM files, including `.gz` files. They intentionally parse only the pieces used for exploration: dictionary assignments, list fields, force coefficient tables, and selected boundary faces.\n", + "\n", + "OpenFOAM list files often look like:\n", + "\n", + "```text\n", + "\n", + "(\n", + "(value0 value1 value2)\n", + "...\n", + ")\n", + "```\n", + "\n", + "The parsers below first find the declared row count, then collect numeric rows between parentheses. That count check is important: if the file format changes or we start reading the wrong section, the notebook should fail loudly instead of plotting misaligned data.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "44dd2160", + "metadata": {}, + "outputs": [], + "source": [ + "FLOAT_RE = re.compile(r\"[-+]?(?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:[eE][-+]?\\d+)?\")\n", + "INT_RE = re.compile(r\"\\d+\")\n", + "\n", + "\n", + "def open_text(path: Path):\n", + " \"\"\"Open plain text or gzip-compressed OpenFOAM text files.\"\"\"\n", + " if path.suffix == \".gz\":\n", + " return gzip.open(path, \"rt\", errors=\"replace\")\n", + " return path.open(\"rt\", errors=\"replace\")\n", + "\n", + "\n", + "def read_text(path: Path, max_bytes: int = 200_000) -> str:\n", + " \"\"\"Read a bounded preview so huge field files do not overwhelm the notebook.\"\"\"\n", + " if path.suffix == \".gz\":\n", + " with gzip.open(path, \"rb\") as stream:\n", + " data = stream.read(max_bytes)\n", + " else:\n", + " data = path.read_bytes()[:max_bytes]\n", + " return data.decode(\"utf-8\", errors=\"replace\")\n", + "\n", + "\n", + "def assignment(text: str, key: str) -> str | None:\n", + " \"\"\"Return the raw value from an OpenFOAM dictionary line like `key value;`.\"\"\"\n", + " match = re.search(rf\"^\\s*{re.escape(key)}\\s+([^;]+);\", text, flags=re.MULTILINE)\n", + " return match.group(1).strip() if match else None\n", + "\n", + "\n", + "def vector_assignment(text: str, key: str) -> np.ndarray | None:\n", + " \"\"\"Return an OpenFOAM vector dictionary value as a numeric numpy array.\"\"\"\n", + " value = assignment(text, key)\n", + " if value is None:\n", + " return None\n", + " numbers = [float(item) for item in FLOAT_RE.findall(value)]\n", + " return np.array(numbers, dtype=float)\n", + "\n", + "\n", + "def parse_foam_list(path: Path, columns: int) -> np.ndarray:\n", + " \"\"\"Parse a numeric OpenFOAM list into an array with the requested columns.\"\"\"\n", + " expected_count: int | None = None\n", + " in_values = False\n", + " rows: list[list[float]] = []\n", + "\n", + " with open_text(path) as stream:\n", + " for line in stream:\n", + " stripped = line.strip()\n", + " if not in_values:\n", + " # First standalone integer is the OpenFOAM-declared list length.\n", + " if expected_count is None and stripped.isdigit():\n", + " expected_count = int(stripped)\n", + " continue\n", + " # Values begin on the line containing only `(` after the count.\n", + " if expected_count is not None and stripped == \"(\":\n", + " in_values = True\n", + " continue\n", + " continue\n", + "\n", + " # A line containing only `)` ends the list.\n", + " if stripped == \")\":\n", + " break\n", + "\n", + " # Field rows may be scalar (`1.23`) or vector-like (`(1 2 3)`).\n", + " # The regex strips OpenFOAM punctuation and keeps the numeric payload.\n", + " numbers = [float(item) for item in FLOAT_RE.findall(stripped)]\n", + " if len(numbers) >= columns:\n", + " rows.append(numbers[:columns])\n", + "\n", + " array = np.array(rows, dtype=float)\n", + " if expected_count is not None and len(array) != expected_count:\n", + " raise ValueError(f\"{path}: parsed {len(array)} rows, expected {expected_count}\")\n", + " if columns == 1:\n", + " return array.reshape(-1)\n", + " return array\n", + "\n", + "\n", + "def parse_boundary(path: Path) -> dict[str, dict[str, int | str]]:\n", + " \"\"\"Parse named boundary patches and their face ranges from polyMesh/boundary.\"\"\"\n", + " text = read_text(path, max_bytes=500_000)\n", + " patches: dict[str, dict[str, int | str]] = {}\n", + " for name, body in re.findall(r\"\\n\\s*([A-Za-z][A-Za-z0-9_]*)\\s*\\n\\s*\\{(.*?)\\n\\s*\\}\", text, flags=re.DOTALL):\n", + " patch_type = assignment(body, \"type\") or \"\"\n", + " n_faces = assignment(body, \"nFaces\")\n", + " start_face = assignment(body, \"startFace\")\n", + " if n_faces is not None and start_face is not None:\n", + " patches[name] = {\n", + " \"type\": patch_type,\n", + " \"nFaces\": int(n_faces),\n", + " \"startFace\": int(start_face),\n", + " }\n", + " return patches\n", + "\n", + "\n", + "def parse_faces(path: Path, start_face: int, n_faces: int) -> list[list[int]]:\n", + " \"\"\"Read only the face definitions belonging to one named boundary patch.\"\"\"\n", + " expected_count: int | None = None\n", + " in_values = False\n", + " face_index = -1\n", + " selected: list[list[int]] = []\n", + " stop_face = start_face + n_faces\n", + "\n", + " with open_text(path) as stream:\n", + " for line in stream:\n", + " stripped = line.strip()\n", + " if not in_values:\n", + " if expected_count is None and stripped.isdigit():\n", + " expected_count = int(stripped)\n", + " continue\n", + " if expected_count is not None and stripped == \"(\":\n", + " in_values = True\n", + " continue\n", + " continue\n", + "\n", + " if stripped == \")\":\n", + " break\n", + " face_index += 1\n", + " if face_index < start_face:\n", + " continue\n", + " if face_index >= stop_face:\n", + " break\n", + "\n", + " # OpenFOAM face row format is `N(v0 v1 ... vN)`. The first integer is\n", + " # the number of vertices; the remaining integers index into `points`.\n", + " values = [int(item) for item in INT_RE.findall(stripped)]\n", + " if not values:\n", + " continue\n", + " selected.append(values[1:])\n", + "\n", + " if len(selected) != n_faces:\n", + " raise ValueError(f\"{path}: parsed {len(selected)} selected faces, expected {n_faces}\")\n", + " return selected\n", + "\n", + "\n", + "def load_force_coefficients(path: Path) -> tuple[list[str], np.ndarray]:\n", + " \"\"\"Load coefficient.dat and keep the header names aligned with data columns.\"\"\"\n", + " columns: list[str] = []\n", + " with path.open(\"rt\", errors=\"replace\") as stream:\n", + " for line in stream:\n", + " if line.startswith(\"# Time\"):\n", + " columns = line[1:].split()\n", + " break\n", + " data = np.loadtxt(path, comments=\"#\")\n", + " return columns, data\n", + "\n", + "\n", + "def summarize_array(name: str, values: np.ndarray) -> dict[str, float | int | str]:\n", + " \"\"\"Return robust distribution landmarks for large field arrays.\"\"\"\n", + " finite = values[np.isfinite(values)]\n", + " return {\n", + " \"name\": name,\n", + " \"count\": int(values.size),\n", + " \"finite\": int(finite.size),\n", + " \"min\": float(np.min(finite)),\n", + " \"p01\": float(np.percentile(finite, 1)),\n", + " \"mean\": float(np.mean(finite)),\n", + " \"p99\": float(np.percentile(finite, 99)),\n", + " \"max\": float(np.max(finite)),\n", + " }\n" + ] + }, + { + "cell_type": "markdown", + "id": "cc795a71", + "metadata": {}, + "source": [ + "## What this simulation says about the run\n", + "\n", + "Read solver setup and physical/run metadata from OpenFOAM dictionaries instead of guessing from filenames only.\n", + "\n", + "Important values printed below:\n", + "\n", + "- `solver`: OpenFOAM application used. `simpleFoam` is a steady incompressible RANS solver, so the time axis in coefficient plots is an iteration count, not physical seconds.\n", + "- `turbulence model`: closure used for Reynolds-averaged turbulence terms.\n", + "- `Uinf`: freestream speed used by force-coefficient normalization.\n", + "- `nu`: kinematic viscosity in $m^2/s$.\n", + "- `Re for lRef=1`: Reynolds number computed as `Re = U_inf * L / nu` with `L=1`. Larger Reynolds numbers generally mean inertia dominates viscosity more strongly.\n", + "- `dragDir` / `liftDir`: unit directions used to project total surface force into drag and lift coefficients.\n", + "- `angle from dragDir`: check that the solver dictionary agrees with the angle encoded in the simulation name.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "f52501cd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "solver: simpleFoam\n", + "turbulence model: kOmegaSST\n", + "Uinf: 32.137 m/s\n", + "nu: 1.560e-05 m^2/s\n", + "Re for lRef=1: 2.060e+06\n", + "dragDir: [0.97770268 0.20999399 0. ]\n", + "liftDir: [-0.20999399 0.97770268 0. ]\n", + "angle from dragDir: 12.122 deg\n" + ] + } + ], + "source": [ + "control_text = read_text(SIM_DIR / \"system\" / \"controlDict\")\n", + "transport_text = read_text(SIM_DIR / \"constant\" / \"transportProperties\")\n", + "turbulence_text = read_text(SIM_DIR / \"constant\" / \"turbulenceProperties\")\n", + "\n", + "# These variables are read from solver dictionaries, not the filename. That makes\n", + "# this cell the authoritative check for the selected case's physical setup.\n", + "u_inf_config = float(assignment(control_text, \"Uinf\"))\n", + "nu = float(assignment(transport_text, \"nu\"))\n", + "application = assignment(control_text, \"application\")\n", + "turbulence_model = assignment(turbulence_text, \"RASModel\")\n", + "drag_dir = vector_assignment(control_text, \"dragDir\")\n", + "lift_dir = vector_assignment(control_text, \"liftDir\")\n", + "alpha_from_drag = math.degrees(math.atan2(drag_dir[1], drag_dir[0])) if drag_dir is not None else float(\"nan\")\n", + "re_lref1 = u_inf_config / nu\n", + "\n", + "print(f\"solver: {application}\")\n", + "print(f\"turbulence model: {turbulence_model}\")\n", + "print(f\"Uinf: {u_inf_config:.3f} m/s\")\n", + "print(f\"nu: {nu:.3e} m^2/s\")\n", + "print(f\"Re for lRef=1: {re_lref1:.3e}\")\n", + "print(f\"dragDir: {drag_dir}\")\n", + "print(f\"liftDir: {lift_dir}\")\n", + "print(f\"angle from dragDir: {alpha_from_drag:.3f} deg\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "19b2fbea", + "metadata": {}, + "source": [ + "## Directory organization\n", + "\n", + "This shows the case as OpenFOAM organizes it: mesh under `constant/polyMesh`, solver dictionaries under `system`, initial fields under `0`, final fields under `40000`, and time histories under `postProcessing` / `logs`.\n", + "\n", + "The file counts and sizes help separate small configuration files from large arrays. Large files in `40000/` and `constant/polyMesh/` are usually numeric fields or mesh topology; small files in `system/` are mostly human-readable dictionaries.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "f776bc17", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[('0', 'dir', '7.45 MB', 13),\n", + " ('0.orig', 'dir', '9.61 KB', 8),\n", + " ('40000', 'dir', '42.52 MB', 29),\n", + " ('SST_32.137_12.122_(4.854, 5.202, 9.247).foam', 'file', '0 B', 1),\n", + " ('coef_convergence.png', 'file', '169.98 KB', 1),\n", + " ('constant', 'dir', '16.03 MB', 8),\n", + " ('log.blockMesh', 'file', '2.96 KB', 1),\n", + " ('log.checkMesh', 'file', '3.36 KB', 1),\n", + " ('log.decomposePar', 'file', '7.67 KB', 1),\n", + " ('log.foamLog', 'file', '607 B', 1),\n", + " ('log.foamToVTK', 'file', '1.75 KB', 1),\n", + " ('log.reconstructPar', 'file', '2.05 KB', 1),\n", + " ('log.simpleFoam', 'file', '84.13 MB', 1),\n", + " ('logs', 'dir', '19.75 MB', 35),\n", + " ('naca_(4.854, 5.202, 9.247).png', 'file', '26.79 KB', 1),\n", + " ('postProcessing', 'dir', '18.44 MB', 5),\n", + " ('residuals.png', 'file', '227.71 KB', 1),\n", + " ('system', 'dir', '395.57 KB', 7)]" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def format_bytes(size: int) -> str:\n", + " if size >= 1_000_000_000:\n", + " return f\"{size / 1_000_000_000:.2f} GB\"\n", + " if size >= 1_000_000:\n", + " return f\"{size / 1_000_000:.2f} MB\"\n", + " if size >= 1_000:\n", + " return f\"{size / 1_000:.2f} KB\"\n", + " return f\"{size} B\"\n", + "\n", + "\n", + "def child_rows(path: Path) -> list[tuple[str, str, str, int]]:\n", + " rows = []\n", + " for child in sorted(path.iterdir(), key=lambda item: item.name):\n", + " if child.is_dir():\n", + " files = [item for item in child.rglob(\"*\") if item.is_file()]\n", + " size = sum(item.stat().st_size for item in files)\n", + " rows.append((child.name, \"dir\", format_bytes(size), len(files)))\n", + " else:\n", + " rows.append((child.name, \"file\", format_bytes(child.stat().st_size), 1))\n", + " return rows\n", + "\n", + "\n", + "child_rows(SIM_DIR)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "bead87a2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 files= 13 size=7.45 MB\n", + "40000 files= 29 size=42.52 MB\n", + "constant files= 8 size=16.03 MB\n", + "system files= 7 size=395.57 KB\n", + "postProcessing files= 5 size=18.44 MB\n", + "logs files= 35 size=19.75 MB\n" + ] + } + ], + "source": [ + "for folder in [\"0\", \"40000\", \"constant\", \"system\", \"postProcessing\", \"logs\"]:\n", + " path = SIM_DIR / folder\n", + " if path.exists():\n", + " files = [item for item in path.rglob(\"*\") if item.is_file()]\n", + " print(f\"{folder:16} files={len(files):4d} size={format_bytes(sum(item.stat().st_size for item in files))}\")\n", + " else:\n", + " print(f\"{folder:16} missing\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "773a1932", + "metadata": {}, + "source": [ + "## Force coefficient history\n", + "\n", + "`postProcessing/forceCoeffs1/0/coefficient.dat` is the simulation-level history for drag, lift, and pitching-moment coefficients. These are dimensionless quantities formed by normalizing forces/moments by freestream dynamic pressure and reference geometry from `controlDict`.\n", + "\n", + "What the common columns mean:\n", + "\n", + "- `Cd`: drag coefficient. Positive drag acts along `dragDir`; smaller positive values usually mean less resistance.\n", + "- `Cl`: lift coefficient. Sign follows `liftDir`; magnitude indicates force normal to drag direction.\n", + "- `CmPitch`: pitching moment coefficient around the configured reference point. Sign indicates nose-up vs nose-down by the case convention.\n", + "- `Time`: for `simpleFoam`, this is an iteration index. It is not physical elapsed time.\n", + "\n", + "The first plot shows the whole convergence history. The second zooms into the final iterations; nearly flat traces imply the steady solve has stopped changing appreciably, while trends/oscillations would warn that final coefficients are less reliable.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "166e8dad", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['Time', 'Cd', 'Cs', 'Cl', 'CmRoll', 'CmPitch', 'CmYaw', 'Cd(f)', 'Cd(r)', 'Cs(f)', 'Cs(r)', 'Cl(f)', 'Cl(r)']\n", + "rows: 40000 solver iterations recorded\n", + "final Cd: 0.024150 (dimensionless drag coefficient at last iteration)\n", + "final Cl: 1.675002 (dimensionless lift coefficient at last iteration)\n", + "final CmPitch: -0.520471 (dimensionless pitching-moment coefficient)\n", + "final-500 Cd span: 0.024150 .. 0.024151\n", + "final-500 Cl span: 1.675002 .. 1.675008\n" + ] + } + ], + "source": [ + "coeff_columns, coeff_data = load_force_coefficients(SIM_DIR / \"postProcessing\" / \"forceCoeffs1\" / \"0\" / \"coefficient.dat\")\n", + "coeff_lookup = {name: idx for idx, name in enumerate(coeff_columns)}\n", + "time = coeff_data[:, coeff_lookup[\"Time\"]]\n", + "cd = coeff_data[:, coeff_lookup[\"Cd\"]]\n", + "cl = coeff_data[:, coeff_lookup[\"Cl\"]]\n", + "cm_pitch = coeff_data[:, coeff_lookup[\"CmPitch\"]]\n", + "\n", + "final_window = min(500, len(time))\n", + "print(coeff_columns)\n", + "print(f\"rows: {len(coeff_data)} solver iterations recorded\")\n", + "print(f\"final Cd: {cd[-1]:.6f} (dimensionless drag coefficient at last iteration)\")\n", + "print(f\"final Cl: {cl[-1]:.6f} (dimensionless lift coefficient at last iteration)\")\n", + "print(f\"final CmPitch: {cm_pitch[-1]:.6f} (dimensionless pitching-moment coefficient)\")\n", + "print(f\"final-{final_window} Cd span: {cd[-final_window:].min():.6f} .. {cd[-final_window:].max():.6f}\")\n", + "print(f\"final-{final_window} Cl span: {cl[-final_window:].min():.6f} .. {cl[-final_window:].max():.6f}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "dbd12749", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(1, 2, figsize=(13, 4.2))\n", + "axes[0].plot(time, cd, label=\"Cd: drag coefficient\")\n", + "axes[0].plot(time, cl, label=\"Cl: lift coefficient\")\n", + "axes[0].plot(time, cm_pitch, label=\"CmPitch: pitching moment\")\n", + "axes[0].set_title(\"Coefficient history over all solver iterations\")\n", + "axes[0].set_xlabel(\"simpleFoam iteration\")\n", + "axes[0].set_ylabel(\"dimensionless coefficient\")\n", + "axes[0].grid(alpha=0.25)\n", + "axes[0].legend()\n", + "\n", + "window = min(500, len(time))\n", + "axes[1].plot(time[-window:], cd[-window:], label=\"Cd\")\n", + "axes[1].plot(time[-window:], cl[-window:], label=\"Cl\")\n", + "axes[1].set_title(f\"Final {window} iterations: convergence check\")\n", + "axes[1].set_xlabel(\"simpleFoam iteration\")\n", + "axes[1].set_ylabel(\"dimensionless coefficient\")\n", + "axes[1].grid(alpha=0.25)\n", + "axes[1].legend()\n", + "fig.tight_layout()\n" + ] + }, + { + "cell_type": "markdown", + "id": "ce49eb43", + "metadata": {}, + "source": [ + "### Reading the force-coefficient plots\n", + "\n", + "- The full-history panel shows how the solver approached a steady solution from its starting fields.\n", + "- The final-window panel is the practical quality check: if `Cd` and `Cl` are almost horizontal, the final printed numbers are representative of the converged state.\n", + "- The numbers are dimensionless. They let cases with different speeds be compared more directly than raw Newton forces, because the freestream normalization removes much of the speed scaling.\n" + ] + }, + { + "cell_type": "markdown", + "id": "867f9511", + "metadata": {}, + "source": [ + "## Mesh geometry and boundary patches\n", + "\n", + "The mesh points are vertices. The volume fields below are cell-centered arrays, so vertex count and field row count differ. Boundary faces tell us where the aerofoil wall and freestream patches live.\n", + "\n", + "The mesh plots are geometry/mesh-density plots, not solution plots. Dense regions indicate where the CFD mesh has more resolution. For aerofoils, high density near the wall is expected because boundary-layer gradients are steep there.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "3b7a5b0e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "mesh points: (520500, 3)\n" + ] + }, + { + "data": { + "text/plain": [ + "{'aerofoil': {'type': 'wall', 'nFaces': 908, 'startFace': 516702},\n", + " 'freestream': {'type': 'patch', 'nFaces': 1624, 'startFace': 517610},\n", + " 'frontAndBack': {'type': 'empty', 'nFaces': 517968, 'startFace': 519234}}" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "points = parse_foam_list(SIM_DIR / \"constant\" / \"polyMesh\" / \"points.gz\", columns=3)\n", + "patches = parse_boundary(SIM_DIR / \"constant\" / \"polyMesh\" / \"boundary\")\n", + "print(f\"mesh points: {points.shape}\")\n", + "patches\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "e7ce6dff", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "rng = np.random.default_rng(20260719)\n", + "sample_count = min(60_000, len(points))\n", + "sample_idx = rng.choice(len(points), size=sample_count, replace=False)\n", + "point_sample = points[sample_idx]\n", + "\n", + "fig, axes = plt.subplots(1, 2, figsize=(12.5, 4.2))\n", + "axes[0].scatter(point_sample[:, 0], point_sample[:, 1], s=0.2, alpha=0.25)\n", + "axes[0].set_title(\"Mesh vertices: sampled full farfield\")\n", + "axes[0].set_xlabel(\"x coordinate\")\n", + "axes[0].set_ylabel(\"y coordinate\")\n", + "axes[0].set_aspect(\"equal\", adjustable=\"box\")\n", + "axes[0].grid(alpha=0.15)\n", + "\n", + "near = point_sample[(point_sample[:, 0] > -0.5) & (point_sample[:, 0] < 1.5) & (np.abs(point_sample[:, 1]) < 0.6)]\n", + "axes[1].scatter(near[:, 0], near[:, 1], s=0.4, alpha=0.35)\n", + "axes[1].set_title(\"Mesh vertices: near aerofoil\")\n", + "axes[1].set_xlabel(\"x coordinate near chord\")\n", + "axes[1].set_ylabel(\"y coordinate\")\n", + "axes[1].set_aspect(\"equal\", adjustable=\"box\")\n", + "axes[1].grid(alpha=0.15)\n", + "fig.tight_layout()\n" + ] + }, + { + "cell_type": "markdown", + "id": "eca551a0", + "metadata": {}, + "source": [ + "## Aerofoil surface fields\n", + "\n", + "The `aerofoil` patch is the wall boundary. We map each boundary face to its face center and color those centers by final surface quantities.\n", + "\n", + "Fields plotted here:\n", + "\n", + "- `forceCoeff`: per-face contribution to force coefficient. The plotted norm combines x/y components, so color means contribution magnitude, not drag or lift sign.\n", + "- `wallShearStress`: near-wall viscous shear stress vector. Higher magnitude often marks stronger skin-friction loading or steep near-wall velocity gradients.\n", + "- `yPlus`: dimensionless wall distance of the first cell. It is a mesh/turbulence-model diagnostic: small values mean the first cell is close to the wall in viscous units. Good/bad thresholds depend on the wall treatment, so use it here as a distribution check rather than a universal pass/fail score.\n", + "\n", + "These are final-iteration values from `40000/`, so they describe the solved state, not the initialization.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "13b1a5a2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "aerofoil faces: 908\n", + "aerofoil centers: (908, 2)\n" + ] + } + ], + "source": [ + "aerofoil_patch = patches[\"aerofoil\"]\n", + "aerofoil_faces = parse_faces(\n", + " SIM_DIR / \"constant\" / \"polyMesh\" / \"faces.gz\",\n", + " start_face=int(aerofoil_patch[\"startFace\"]),\n", + " n_faces=int(aerofoil_patch[\"nFaces\"]),\n", + ")\n", + "aerofoil_centers = np.array([points[face, :2].mean(axis=0) for face in aerofoil_faces])\n", + "print(f\"aerofoil faces: {len(aerofoil_faces)}\")\n", + "print(f\"aerofoil centers: {aerofoil_centers.shape}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "7766ae33", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "surface_force: (908, 3) values, one vector per aerofoil wall face\n", + "wall_shear: (908, 3) values, one vector per aerofoil wall face\n", + "y_plus: (908,) values, range 0.0025 .. 0.3785\n", + "Surface distribution summaries:\n" + ] + }, + { + "data": { + "text/plain": [ + "[{'name': '|forceCoeff_xy|',\n", + " 'count': 908,\n", + " 'finite': 908,\n", + " 'min': 4.3631415850623045e-06,\n", + " 'p01': 2.743305896474191e-05,\n", + " 'mean': 0.002002579090723482,\n", + " 'p99': 0.0119255645132304,\n", + " 'max': 0.012571306964867877},\n", + " {'name': '|wallShearStress_xy|',\n", + " 'count': 908,\n", + " 'finite': 908,\n", + " 'min': 0.0013604693437104711,\n", + " 'p01': 0.022830534823254253,\n", + " 'mean': 9.20671527439559,\n", + " 'p99': 31.8291138984418,\n", + " 'max': 31.8967788099112},\n", + " {'name': 'yPlus',\n", + " 'count': 908,\n", + " 'finite': 908,\n", + " 'min': 0.00251439,\n", + " 'p01': 0.010309987999999999,\n", + " 'mean': 0.15439976128854627,\n", + " 'p99': 0.37796499,\n", + " 'max': 0.37849}]" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "surface_force = parse_foam_list(SIM_DIR / \"40000\" / \"forceCoeff.gz\", columns=3)\n", + "wall_shear = parse_foam_list(SIM_DIR / \"40000\" / \"wallShearStress.gz\", columns=3)\n", + "y_plus = parse_foam_list(SIM_DIR / \"40000\" / \"yPlus.gz\", columns=1)\n", + "\n", + "# Norms collapse vector components into one positive magnitude for color maps.\n", + "# Use component plots instead if you need drag/lift sign on each face.\n", + "force_norm = np.linalg.norm(surface_force[:, :2], axis=1)\n", + "shear_norm = np.linalg.norm(wall_shear[:, :2], axis=1)\n", + "\n", + "print(f\"surface_force: {surface_force.shape} values, one vector per aerofoil wall face\")\n", + "print(f\"wall_shear: {wall_shear.shape} values, one vector per aerofoil wall face\")\n", + "print(f\"y_plus: {y_plus.shape} values, range {y_plus.min():.4f} .. {y_plus.max():.4f}\")\n", + "print(\"Surface distribution summaries:\")\n", + "[\n", + " summarize_array(\"|forceCoeff_xy|\", force_norm),\n", + " summarize_array(\"|wallShearStress_xy|\", shear_norm),\n", + " summarize_array(\"yPlus\", y_plus),\n", + "]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "070e6676", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(1, 3, figsize=(14.5, 4.2))\n", + "for ax, values, title, label in [\n", + " (axes[0], force_norm, \"Surface force-coefficient magnitude\", \"dimensionless |forceCoeff_xy|\"),\n", + " (axes[1], shear_norm, \"Wall-shear magnitude\", \"|wallShearStress_xy|\"),\n", + " (axes[2], y_plus, \"First-cell wall distance\", \"yPlus\"),\n", + "]:\n", + " sc = ax.scatter(aerofoil_centers[:, 0], aerofoil_centers[:, 1], c=values, s=12, cmap=\"viridis\")\n", + " ax.set_title(title)\n", + " ax.set_xlabel(\"x along aerofoil\")\n", + " ax.set_ylabel(\"y\")\n", + " ax.set_aspect(\"equal\", adjustable=\"box\")\n", + " cbar = fig.colorbar(sc, ax=ax, shrink=0.8)\n", + " cbar.set_label(label)\n", + "fig.suptitle(\"Color shows final value on each aerofoil wall face\", y=1.03)\n", + "fig.tight_layout()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "ef843b8d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABAcAAAMhCAYAAACUltjnAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvctoD+AAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3Xd4U2UbBvA7o3vvQScUOihlQ0G2yBaRIUNAVByICiJucTNUVBRFEVQUPxegIKACZW9krzK6905305Xz/VEaKV1JOk6a3L/rytX25JyTJydvTnqevO/zSgRBEEBERERERERERksqdgBEREREREREJC4mB4iIiIiIiIiMHJMDREREREREREaOyQEiIiIiIiIiI8fkABEREREREZGRY3KAiIiIiIiIyMgxOUBERERERERk5JgcICIiIiIiIjJyTA4QERERERERGTkmB4iozbt06RKGDh0KW1tbSCQSbN26VeyQarh+/TqGDRsGa2trdXyff/45JBIJkpKStN7f+vXrIZFIEBcX1+i6//zzDyQSCQ4cOKB94K2sruelzXMVU1uJU0xNfZ9qc4z1/ZwgJrHbqtiP31AcYsXWFs7TK1euhEQiQVZWltihEFELYnKASA/8+++/mDRpEnx9fWFhYYFOnTph1qxZOHz4sNihtQnTp0+HXC5HYmIiBEHAhAkTxA6phgcffBAymQzJycl6GR+JqymJorakNd+n+n5OaA4NtRtjaVNERNS8mBwgEtnOnTvRr18/VFZWYseOHcjJycHvv/+OiooKDBo0CGlpaWKHqNeys7Nx5coVjB8/HnZ2dmKHU0teXh7OnDlTK76nn34agiDAy8tLxOj039y5cyEIAvz8/MQOhZqgNd+n+n5OEBvfU/XjsSEiYycXOwAiY/f+++/DysoKv/32G0xNTQEAoaGh+Pnnn9G3b19IpczhNaS6i6OFhYXIkdQtPT0dgP7GR9QaWvN9qu/nBCIiIn3Fqw4ikeXk5MDZ2VmdGLjdwoUL4erqqv57x44dkEgk6puVlRV69+6N77//vsZ21WMDU1JSsGDBAjg7O8PJyQnPP/88VCoVSktL8eyzz8LFxQU2NjaYM2cOSkpKaj1+UlISHn30UXh6esLU1BT+/v5YsmQJysrKGnxOWVlZmDdvXo1hEosWLUJ2dnaN52Zubl5r2+rneOTIkTqfz+LFi+Hu7g4TExPMnTsXQUFBAIDHHnsMEokE7u7uWh0rAEhMTMRjjz0GHx8fmJubIyQkBCtXrqzxPHU5FnPnzkVgYGCN+O683dntV9djDgBHjhxB//79YWFhAR8fH3zyySd1rqfJ61MXTY+prvuvS11jgKvbQ1paGl566SW4urrCysoK48aNq7Mbta7HtPpxkpOT8eyzz8LZ2RnW1taYMGECYmNjNYr//PnzGD9+PBwcHGBubo6wsDB8+eWX6vsXL16MZ555BgDg7e2tPrYREREAND+WEokEQ4YMaTQebd53mj52Y8e3ofepNvFooqHHAhp/PYD6zzf10eQ4aduWmtJuGmtTzfGeOnjwIMLDw2uca5o6bl6T1wZo/Hytzbn/Tncem9zc3DrP29W38+fPq7fV9Dyj6Xm6Ltq2I01iasrxio+PR5cuXdCxY0fcuHEDQPOe/4mo9TE5QCSyAQMGICYmBuvWrYMgCA2uO27cOAiCAEEQoFKpEB0djcmTJ+ORRx7BH3/8UWv9V199Ff3790dMTAw2btyINWvW4IMPPsAzzzyDfv36ISoqCps3b8amTZvwzjvv1Ng2Pj4evXr1QmRkJP78808oFAp888032LBhA2bMmNFgnLNmzcKBAwewdetWKBQK/PPPP/Dz88N3332n/QG6zQsvvIDQ0FBERkbiiy++wPr16xEZGQkA6uNXPQxD02MVGxuLnj174syZM/jpp5+QmZmJ33//HRkZGTh48GCTjkVd8VXfVq9eXWv9phzz06dPY/jw4XB3d8eVK1dw+vRpKBQKrF27tta6ur4+mh7Tlnr97/T6668jNDQUN2/exIEDB3DhwgXMmTOnxjpNOabVXnjhBfTq1QvR0dE4dOgQYmNjMWjQIOTk5DS43fnz53HXXXdBqVTixIkTSE5OxiOPPIJnnnkGL774IoCqf/ar20L1+HhBEDB8+HAArXcs66LJY2tyfBt6nza3hh5Lk9fjdneeb+qjzWukSVtqartprE01RJP31KlTpzBixAh4e3vj6tWrOHPmDAoLC+s812hK09dGk/O1tp+TDbG3t69x3q5uT35+fnB0dISHhwcAzc8z2pynG6JJO9I0Jl2P18mTJ9G3b184OjrixIkT6NSpEwBxz1lE1AwEIhJVTk6OcM899wgABBcXF2HChAnCO++8I5w6dUrjfQwfPlwYNWqU+u8PP/xQACCsWLGixnozZswQrKyshPfee6/G8lmzZgkuLi41lk2fPl2wt7cXMjMzayzfunWrAEA4fvx4vfGYm5sLr7zySoMxL1iwQDAzM6u1fPv27QIA4fDhw7Wez5IlS2qtHxkZKQAQ1q1b1+DjVbvzWE2ePFmwtrYW0tPT692mKceivvhWr14tABASExO1fpx169YJAITY2Fj1OqNHjxbc3NyEkpKSGtuOGjVKACDs379fvUyT10cbdx5TXfdf1/Oqa1l1e1i2bFmN7T/99FMBgBAdHa1e1pTXrvpx3nzzzRrLr169KkgkEuGNN95oMM4xY8YI9vb2Ql5eXo3tn3jiCUEmkwlxcXGCINTdFqo192ulzftOk8fW9PjW9z7QJp66jnFd6nssTV+Phs43ddHkOGnTlpqj3TR0X1PfUyNHjhQ8PDwEpVJZY91x48bVOtfUpSnvFU3O1/W58zyl6fnmdkVFRULv3r0FMzMz4dChQ+rlmr4PtDlP10WbdtSUc58g1P9/RWZmpvDrr78K5ubmwuzZs4XS0tIa2zX3OYuIWhd7DhCJzMHBAbt370ZkZCTefvtteHh4YOPGjejTpw/GjBmDwsJC9bqVlZVYuXIlunfvDisrqxrdRaOiomrte/To0TX+DgoKQlFRUa3lwcHByMzMREFBgXrZ9u3bMWTIEDg7O9dY9+677wYA9bc0denatSu+/vprrFmzBgkJCZofjEaMHz9e43U1PVZ///03hg8fXmP4xp2aciy0oevjCIKA/fv3Y8SIEbW6aNdVpV3X10fTY9pSr/+dxo4dW+Pv0NBQAEBMTIx6WXO8dne2u+DgYAQGBmLfvn31biMIAvbt24fhw4fD1ta2xn2TJ09GZWWlRt2vW+tY6vrYrfXeaCpdXg9NzzfavEaNtaXmaje6auw9JQgCDh48iHvuuQdmZmY11tXm/Hw7bZ6zJudrbT8nNaVSqfDggw/i9OnT+O677zBw4ED1fZq8D7Q9TzdEk3OSpu9NbY/X8uXLMX36dLz66qv4/vvvaw2JFPOcRURNx+QAkZ4ICgrCvHnzsGbNGty4cQPvv/8+/v77b7z55pvqdV566SW8+uqreOaZZxATE4OKigr1NF3l5eW19lnd5bGajY1Ng8vz8vIAAEVFRSgsLMS2bdsgl8shk8kgk8kglUrV6zY0fnDTpk0YOXIkXn75Zfj6+qJ9+/Z4/vnnNRpzKDQwtKJdu3aNbl9Nk2NVVFSEoqKiBvfb1GOhqaY8TlFREZRKJdzc3GrdV9cyXV8fTdtfU15/bdzZjqsvLHJzcwE032tX33FtaL7v4uJiKJXKGuPdq1Uv02S+8NY6lnW97xp77JZ8bzR0HtCFLq+HpucbbV6jxtpSc7UbXWnynlIqlXVenDd0wd4QTZ+zJudrQPvPSU0tWrQIW7duxbvvvovp06erl2v6PtD2PN2QxtqRNu9NbY/XDz/8ADc3Nzz00EN1xtZa5ywiahmcrYBIT73wwgt46623cPjwYfWyH374QT0W8Hb1FUeTSCRaLa9maWkJCwsLTJo0CRs3btQy8qoiWP/73/9QUVGBixcvYufOnVi+fDnOnDmj/gbIzs4OpaWlKCsrq/HNQ3Jycr37bago2J00OVaWlpawtLRs8DGbeiw01ZTHsbKygrm5uXpmhNvVtUyT16cumrY/XfevrZZux9XS09NrXZCkp6fDycmpwcdu7DW58xu9ujT3sdTmfdfYYzfH8dXlPKALXV4PTc832rxGjbWl5mo3umrsPVV9rsnIyKh1X13LNKHpc9bkfA1o/zmpidWrV+PTTz/FI488gtdee61W/Jq8DwRB0Oo83RBN2pGm701tj9euXbswffp03HXXXdizZ4+6AGi11jr/E1HLYM8BIpG98sorNYYOVMvOzoZSqYS9vX2N5Xd25bx48SIuXrzYrDFJJBKMGzcOe/bsgUKh0Hk/crkcPXr0wJIlSzBjxgwcOXJE/Y1ghw4dAABXrlypsc2OHTt0D/wOjR0riUSCsWPHYu/evfX+Y9tcx6IxTXmc6kr1e/bsQWlpaY37tm3bVu92Db0+9dGm/emy/+bUXK/d9u3ba/x97do13LhxQ909t77HHjp0KCIiImq9v7ds2QKpVKqeXcDKygoAar12t2uuY6nL+66+x26O49sa5wFAu9dDV5q8Ro21peZqN5q0KV1IJBIMHjwYERERtarw6/qaafqcNTlfV2vOz8nt27dj4cKFGD58OL766qs649fkfaDrebq+mG5XVzvS5r2pzfHy8fHBkSNH4OLigkGDBuHs2bN1rif2+Z+IdMPkAJHItm/fjtDQUGzYsEHddfLEiROYOHEipFIpFi1apF53/Pjx+O2337Br1y4UFRXh8OHDePzxxzF48OBmj+uDDz6AVCrF2LFjcfjwYRQUFCA9PR0RERGYNGkSzp07V+d22dnZGD58OLZt24bk5GSUlpbi5MmTiIiIwODBg9XfTE2cOBFOTk5YvHgxEhMTkZ6ejiVLlqi7PDaVpsfq/fffh7m5OUaPHo0jR46gsLAQ169fx4svvog9e/Y06VhoqymP8/bbbyMnJwczZ85EXFwcMjMz8fbbb9f6p0/T16cumhzTpuy/JTTHa3fjxg38+OOPyMvLw7lz5zB9+nR4eHjg2WefbXC79957DyUlJZgyZQpu3LiBnJwcrF69GuvWrcPChQvh6+sL4L9x3Tt37qxxwaXNsdR0KkNN33eaPnZTj29Lnwdup+nroQ1t27smbamp7aax+5rqnXfeQVZWFmbPnq0+1yxduhQymUznfWr6nDU5Xzfn52R0dDSmT5+OkJAQbN68ud7eJJq+DzQ9TzdGk3akaUy6HC8XFxccOHAAQUFBGDp0KA4dOgRA/87/RKSDVix+SER1iI2NFd555x2hb9++gpOTkyCXywVPT09h4sSJwtGjR2usm5+fLzzxxBOCm5ubYGVlJQwbNky4ePGiMHXqVMHX11e93u1VhW/3ySefCACE1NTUGsvrq2ydmpoqzJ8/X/Dz8xNMTEwET09PYdSoUcIff/whVFZW1vuc9u3bJ0ycOFFo166dYGFhIQQEBAgvvPCCoFAoaqx3+PBhoVevXoKpqang7+8vrFu3rsHZCu58PoJQf2VyTY+VIAhCfHy88PDDDwseHh6CmZmZ0LlzZ2HlypU1qjDreiy0ma1A08epr6L2gQMHhL59+wpmZmaCl5eX8OGHHwp///13rSrYmr4+d9L0mOq6f21nK7izPfz7778CAGHTpk1aH9O6VD9OUlKSMG/ePMHR0VGwsrIS7r33XiEqKqrR2AVBEM6cOSOMHTtWsLOzE0xNTYXOnTsLn3/+uaBSqWqs98Ybbwienp6CVCoVAAh79uzR+FgWFBQIAITp06fX+1xup+n7TtPXUZPj29CsIprG09TZCgRBs9ejofNNXTQ5Ttq0JU3jFIT6201D9zXHe2r//v3qc423t7fw8ccfq6vgHzt2rMHj1dT3SmPna03PU5qcb/bs2SMAqPd27tw59baanmc0PU/XRdt2pElMTfm/ori4WBg7dqxgYWEh7NixQxAE3c//RKQfJILAPj5ERER3WrlyJV544QVkZma26Djvptq5cyfGjx+PCxcuqL8xJv3SVtpSU3zxxRd4+umnERMTA39/f7HDMUjG0I6ISFwcVkBERNSG7d27FzNmzGBigES1ZcsW+Pj4MDFARNSGcbYCIiKiNuzjjz8WOwQyMg8++CDmzZuHrl27IjMzE59++in279+P7777TuzQiIioCZgcICIiIiKNzZo1C0uWLMGFCxegVCoRGhqKX375BVOnThU7NCIiagLWHCAiIiIiIiIycqw5QERERERERGTkmBwgIiIiIiIiMnJMDhAREREREREZOSYHiIiIiIiIiIwckwNERERERERERo7JASIiIiIiIiIjx+QAERERERERkZFjcoCIiIiIiIjIyDE5QERERERERGTkmBwgIiIiIiIiMnJMDhAREREREREZOSYHiIiIiIiIiIwckwNERERERERERo7JASIiIiIiIiIjx+QAERERERERkZFjcoCIiIiIiIjIyDE5QERERERERGTkmBwgIiIiIiIiMnJMDhAREREREREZOSYHiIiIiIiIiIwckwNERERERERERo7JASIiIiIiIiIjx+QAERERERERkZFjcoCIiIiIiIjIyMnFDoD+o1KpkJKSAhsbG0gkErHDISIiIiIiojZMEAQUFBTA09MTUmnDfQOYHNAjKSkp8Pb2FjsMIiIiIiIiMiCJiYnw8vJqcB0mB/SIjY0NgKoXztbWVuRo6qZSqaBQKODg4NBo5omoLWIbJ0PHNk6Gjm2cDBnbN2krPz8f3t7e6mvNhjA5oEeqhxLY2trqdXKgoqICtra2PCGRQWIbJ0PHNk6Gjm2cDBnbN+lKk2HrbFFERERERERERo7JASIiIiIiIiIjx+QAERERERERkZFjcoCIiIiIiIjIyDE5QERERERERGTkmBwgrZSWV+JEXJ7YYRAREREREVEzYnKAtPLuzkg8vfkalv4ViYpKldjhEBERERERUTNgcoA0plIJMDeRAQC+ORKHd3dcFTkiIiIiIiIiag5MDpDGpFIJXh8bjPfGdgAAfH88HhuPx4kbFBERERERETUZkwOktVHBznhhZCcAwFvbr+JMvELkiIiIiIiIiKgpmBwgnTw5qD3Gd/VEpUrAwl/PoUBZLnZIREREREREpCODSw789ddfmDhxIoYOHYoXX3wRCkXj32prss2+ffswbdo0hIeHIz4+vtb9KSkpWLJkCUaNGoWJEydizZo1KC833AtmiUSC9+4PRTt7CyTmlOCtP1l/gIiIiIiIqK0yqOTApk2bcN999yE8PByLFi3CkSNHMGzYsAYv0jXZZu7cuXj33XcRGBiIkydPoqSkpMY+MjIyMHDgQJibm2PhwoWYOHEiPvjgAzzwwAMt9lz1ga25CVZN6wapBNhyNgkHb2SKHRIRERERERHpQCIIgiB2EM0lICAA48aNw6pVqwAA6enpaNeuHb7//ns8+OCDOm+Tl5cHOzs7nD59Gr1790ZkZCSCgoLU+ygvL4dKpYKZmZl62e7duzFy5EhER0ejffv2GsWfn58POzs75OXlwdbWVocj0PJUKhVycnLg6OgIqbQqt/Tujqv45kgsvB0tsHvhYFiYykSOkkh3dbVxIkPCNk6Gjm2cDBnbt/44m6CArbkJfBwtYSrX39dCm2tM/X0WWoqLi0N0dDTuvfde9TI3Nzf07dsXERERTdrGzs6uwcc2MTGpkRgAAGtrawBAWVmZ1s+lrVl0Tyd42JkjMacEn+27KXY4RERERERELWrej2cw/OODiEzNFzuUZiMXO4DmUl0HwNPTs8ZyT0/POmsE6LqNJgRBwLJlyxAcHIxOnTrVu15paSlKS0vVf+fnVzUslUoFlUql8+O3JJVKBUEQasRnYSLFm/eG4Mkfz2L94RhM7eUFH0dLEaMk0l1dbZzIkLCNk6FjGydDxvatH0orKpGeX3Ud52lnptevhzaxGUxyoLpGwJ3f4FtYWNRbc0CXbTTx2muv4eDBgzh06FCD3X2WL1+Ot99+u9ZyhUKBiooKnR+/JalUKhQUFEAQhBrPraebHH19bXEyPh/v/XkJK8Z3FDFKIt3V18aJDAXbOBk6tnEyZGzf+iFBoQRQ9SUpSguRU1YkckT1Kygo0Hhdg0kOODo6AgBycnJqjPHPzs6Gk5NTs23TmHfffRefffYZ/vrrL3Tv3r3BdV955RUsWrRI/Xd+fj68vb3h4OCg1zUHJBIJHBwcap2Q3hjfBeM+P4qIGzmILZCgp6+DSFES6a6hNk5kCNjGydCxjZMhY/vWD1eyswAA3g6WOl83tha5XPNLfoNJDgQHB8PCwgL//vsvevXqBaDqzXPmzBnMmzev2bZpyNKlS7FixQr89ddfGDRoUKPrm5mZ1eq1AABSqVSv3+wSiaTOGDu3s8cDPb3x6+lELPv7Gn6f1x8SiUSkKIl0V18bJzIUbONk6NjGyZCxfYsvJa+q54CXo6Xevw7axKffz0QLFhYWmD59Oj777DMoFAoAwJdffgmFQoFZs2ap11u8eDGeffZZrbbRxIoVK7B8+XL89ddfGDx4cDM9q7bn+RGdYGEiw7mEXOy8lCp2OERERERERM0qSVEMAPBysBA5kuZlMD0HAOCTTz7B5MmT4e3tDTc3N2RlZeGHH36oMWTg2rVrUCqVWm2zceNGfPHFFygqqhpLMm3aNJibm+Oll17C/fffjxs3buCVV16Bq6srXnrppRoxffTRR7jrrrta+JnrD1dbczwxuD1WRdzER7tvYFRnd8hlBpODIiIiIiIiI5eYUwKAyQG9Zmtri927dyM+Ph4KhQKBgYGwsKj5gn300Uc1KjZqss3dd9+Njh1rF9irTiB4e3vj+PHjdcYUFBTU1KfV5swd2B7fH4tDbFYR/jiXjCm9vMUOiYiIiIiIqFn813PAsGZoM6jkQDVfX1/4+vrWeV9gYKDW23h6etaa7vB2FhYWCA8P1z5QA2VtJseTgztg+d/X8Nm+m5jQvR1M2HuAiIiIiIgMQKLCMHsO6MUVm1KpxIULFxAXFyd2KNRMZvXzhbO1KRJzSrDlTJLY4RARERERETVZYWkFMgtKAQC+TlYiR9O8RE8O/PTTT3B3d0e3bt2wYcMGAMCxY8cwevRocQOjJrE0reo9AACr90WhtKJS5IiIiIiIiIiaJj67qg6do5Up7CxMRI6meYmaHIiKisJTTz2FDRs21Cjk179/fxQWFtY7jp/ahpnhvnC1MUNybgk2nWbvASIiIiIiatvis6vqDfg6GVa9AUDk5EBERASmTJmCCRMm1CoC2KtXLxw+fFikyKg5mJvIMG9IVe+Brw5Go6JS1cgWRERERERE+ivuVs8BPwMbUgCInBzIy8uDjY0NAEAikdS6Ty43yHqJRmVabx84WpkiSVGC7RdTxA6HiIiIiIhIZ/FZ7DnQIvr06YMdO3ZAqVTWSA5ERkZi06ZNuOuuu0SMjpqDhakMjw7wBwCs2R8NlUoQOSIiIiIiIiLdsOdACxk6dCg6d+6M7t2746+//sLBgwcxc+ZM9OjRA2PHjkXfvn3FDI+ayax+vrAxk+NmRiH2RKaLHQ4REREREZFOWHOgBW3evBlPP/00LCwskJaWhsTERLz//vv43//+J3Zo1ExszU0wu78vAGDN/igIAnsPEBERERFR21JSVom0fCUAw+w5IPqgfplMhvnz52P+/Plih0It6OG7/PHNkVhcSMrD0ahsDOjoLHZIREREREREGkvIqeo1YGsuh72lYU1jCOhBzwEyDs7WZpjW2wcA8MX+KJGjISIiIiIi0o663oCzVa2C+oag1ZMD77zzDuRyuUa3d955p7XDoxb0+KD2kEslOB6TjTPxCrHDISIiIiIi0lj8reSArwEOKQBEGFYwc+ZM9O/fX/33ggUL4ODggDlz5sDDwwOpqanYsGEDFAoFZs6c2drhUQvytLfAxB7t8NvpJHx5IArrH+otdkhEREREREQaibtVjNDPAIsRAiIkB9q3b4/27dsDAPbs2QM7OzscPHgQMplMvc7DDz+MAQMGICYmRr0uGYZ5QwKw+UwSIiIzcC0tH0HutmKHRERERERE1KjYTMPuOSBqzYGLFy8iPDy8RmIAqCpS2K9fP1y4cEGkyKil+DtbYXSoBwBg7cEYkaMhIiIiIiLSTExWIQCggwuTA83OyckJf/31F/Lz82ssz8/Px19//QVnZ1a0N0RPDu4AAPjzQgoSb1X8JCIiIiIi0lcFynKk55cCANq7WIscTcsQNTkwdepUmJubIygoCM888wyWLl2KZ555BkFBQbC0tMTUqVPFDI9aSBcvOwzs6IxKlYBvjsSKHQ4REREREVGDYm4NKXC2NoOdheFNYwiInBywsLDA8ePHsXjxYly/fh2//PILrl+/jhdeeAHHjh2Dubm5mOFRC5p3q/fAL/8mILuwVORoiIiIiIiI6mfoQwoAEQoS3snCwgKLFi3CokWLxA6FWlG/Dk4I87LDxaQ8fH8sDotGBIodEhERERERUZ2iM6p6DhjqkAJA5J4DZLwkEom698D3x+NRVFohckRERERERER1M4aeA6ImB9555x3I5fJ6b++8845O+01JScGVK1dQWqp5d3VNtklNTcXp06ehVCqb9bGN1YjO7mjvbIW8knL8fCpB7HCIiIiIiIjqVN1zoAN7DrSMGTNmYMeOHTVuP//8M6ZMmYKQkBDMmDFDq/0VFBRgzJgxCAgIwJgxY+Du7o4tW7Y0eZtjx45h4sSJ6Ny5M3r37o24uLhmeWxjJ5NK8MTg9gCA9YdjUVahEjkiIiIiIiKimipVAmKzDT85IGrNgYCAAAQEBNRaPmXKFAwZMgQpKSl13l+f559/HtHR0UhMTISTkxM+/fRTzJgxA9evX4efn5/O25w8eRIPPvggXnzxRfTr16/ZHpuACd3b4eM9N5CWr8TW88l4oJe32CERERERERGpJStKUFahgqlcinYOFmKH02L0tuZA7969cebMGY3XVyqV+PHHH7FgwQI4OTkBAJ5++mnY29vjhx9+aNI2zz33HCZNmgS5vO5cii6PTVXM5DI8OsAfAPDVwWioVILIEREREREREf0nOrOq3oC/kxVkUonI0bQcvUwOKBQK7N69G46OjhpvExkZiZKSEvTu3Vu9TCaToWfPnjh79myzbdOS+zFW0/v4wNZcjpjMIuyJTBc7HCIiIiIiIrXq5EAHV8MtRgiIPKxgzZo1WLNmTY1lFRUViI+PR0BAACZPnqzxvrKzswFA/c19NWdnZ8TGxjbbNs25n9LS0hqFC/Pz8wEAKpUKKpV+jr9XqVQQBKFZ47MylWFmuC/WHIjGmv1RGB7kAonEcDNypN9aoo0T6RO2cTJ0bONkyNi+xRGd8V/PgbZ27LWJV9TkQI8ePTB37tway0xMTODn54cRI0bAxMRE431Vr3vnLAElJSX17keXbZpzP8uXL8fbb79da7lCoUBFhX5O7adSqVBQUABBECCVNl/Hk/uC7fDNEQkuJOVhz4V49PKxbbZ9E2mjpdo4kb5gGydDxzZOhoztWxzXU3MBAG6WQE5OjrjBaKmgoEDjdUVNDhQWFiI0NBTDhw+vdV9ERAQA1HlfXXx8fABUTSUYHBysXp6SkoKOHTs22zbNuZ9XXnkFixYtUv+dn58Pb29vODg4wNZWPy+OVSoVJBIJHBwcmvWE5OgITOnpjR9PJuCnc5kY0c2v2fZNpI2WauNE+oJtnAwd2zgZMrZvcSTkVn0J3MXPFY6O9uIGo6X66ubVuW4LxtGoI0eOAKg7AXDkyBFIJBKNkwP+/v5o3749du7cibvvvhsAkJGRgVOnTuHJJ59UrxcVFQWVSoVOnTppvE1zPfadzMzMYGZmVmu5VCrV6ze7RCJpkRifGNwBP/+biEM3s3A1tQCh7eyadf9EmmqpNk6kL9jGydCxjZMhY/tuXXkl5cgqLAMABLjatLnjrk28oiYH6lNZWYnLly9j2LBhWm23dOlSzJ49G15eXggODsbSpUsREhKCqVOnqtdZuHAhlEqlumeCJtukpaUhKSkJkZGRAIArV66gsLAQvr6+cHFx0Xg/1DBvR0uM7eKBPy+kYO2hGKye3l3skIiIiIiIyIjF3CpG6GpjBhtzzYeet0WiJAdWrFiBFStWQKlUAgBWrVpV4/7i4mJYWlri448/1mq/06ZNg4WFBdavX4/ff/8dvXv3xuuvvw5TU1P1Oh07dkRZWZlW2+zatQurV68GAPTs2RPLly8HALz66quYOHGixvuhxj05uAP+vJCCnRdTsHhEJ/g6GXZFUCIiIiIi0l/RmUUAgA4u1iJH0vIkgiC0+sTyV69exdWrV/Hbb78BAB544IH/ApJIYGdnh549e8LBwaG1QxNVfn4+7OzskJeXp9c1B3JycuDo6NhiXWrmfHcKB65n4sG+Plh6f5cWeQyi+rRGGycSE9s4GTq2cTJkbN+tb8Xf1/DVwWjMDPfBexPa3rWJNteYovQcCAkJQUhICHr16gUA8PPzEyMM0lPzBnfAgeuZ2HQmCQuGd4SrjbnYIRERERERkRG6kV5V7T/QzUbkSFqeqOkmPz8/Jgaolj7+jujuY4+yChU2HI0TOxwiIiIiIjJS1cmBjkwONL9ly5bB2toay5YtU/9e323ZsmWtHR7pAYlEgnmDOwAANh6PR76yXOSIiIiIiIjI2BSVViBJUQIA6GQEyYFWH1YwceJEhISEICgoCEDVEIP6VK9Dxmd4sBsCXK0RlVGIn04m4MlbyQIiIiIiIqLWcDOjaqYCFxszOFoZfqH5Vk8OBAUF1bjoZwKA6iKVSvDk4A5YvOkCvjkSizn9/WBuIhM7LCIiIiIiMhI30qqGFHRyM/yZCgCRaw7crqioCLm5uTVu1VMdknEa39UTHnbmyCwoxR/nksUOh4iIiIiIjMj19OrkgOEPKQD0IDmwdOlSODs7w9raGg4ODjVuK1asEDs8EpGpXIq5A9sDANYejEalqtVn3SQiIiIiIiNlTDMVACJNZVgtIiICK1aswMqVK9G1a1fI5TXD8fT0FCky0hfTentj9b6biMsuxj+X0zA2zEPskIiIiIiIyAgY00wFgMjJgXPnzmHOnDl44oknxAyD9JiVmRwP9fPDp3tv4suDURjTxR0SiUTssIiIiIiIyIDlFZcjPb8UAGsOtApvb2/WFaBGPdTfD+YmUlxOzsfRqGyxwyEiIiIiIgN3I6Oq10A7ewvYmJuIHE3rEDU5MHbsWJw4cQJ79+4VMwzSc45WppjW2wcA8OXBKJGjISIiIiIiQ3ctNR+A8fQaALQcVpCWlobc3FytH8TDwwN2dna1lq9duxaxsbEYPnw4rK2tYWVlVeP+xYsXY/HixVo/HhmeuQP98eOJeByNysaFxFx09bYXOyQiIiIiIjJQV1KqkgOdPWtfxxoqrZIDr7/+Or755hutH2TdunWYO3dureUjRoyAu7t7vduFhYVp/VhkmLwcLDG+myd+P5uMLw9E46tZPcUOiYiIiIiIDNTVWz0HQjxtRY6k9WiVHFi/fj3Wr1/fbA8eFhbGBABp7MnBHfD72WT8cyUNkan5CPYwnjcqERERERG1jopKFa6lVdUcCDGiaw6tag5kZ2ejsLCwpWIhalAnNxuM7VI1leGnETdFjoaIiIiIiAxRTFYRyipUsDaTw8fRUuxwWo1WyYGXXnoJv/zyCwDgvffew7Zt25r04O+88w7kcnmdN1NTU7i5uWHixImIjIxs0uOQ4VgwvCMkEuCfK2m4kpIndjhERERERGRgqq8zgj1sIJUazzTqWiUH7OzskJWVBQCIi4tDZmZmkx585syZCAwMxMCBA7F27Vps27YNa9euxV133YWOHTvio48+glKpxKhRo1BQUNCkxyLDwN4DRERERETUkq7eKkZoTEMKAC1rDowYMQITJkzA7t27cfPmTZw4cQKbN2+uc93nnnsOI0eObHB/0dHRcHBwwN69eyGV/penmDNnDgYNGgR3d3fs3LkTffr0wd9//40HHnhAm3DJQC24uyN2XkrF7qvpuJych9B2xlNBlIiIiIiIWpYxFiMEtEwOjBw5Ev/88w8OHDiArKwseHh4IDQ0tM51HRwcGt3fxYsX0bdv3xqJAQCQyWTo27cvLly4gOHDh2PQoEFISEjQJlQyYB3dbHBvmCf+vJCCVRE3sf6hXmKHREREREREBkAQhNt6DhjXl5BaJQf2798PNzc3vPnmm0hMTER4eHidUxRqysnJCevXr8fbb78Na2tr9fKCggL89ddfePnllwFUDWEYMmSIzo9DhufZuztix8UURESm41JSHrp4Gdcbl4iIiIiIml9avhKK4nLIpRJ0dLNufAMDolVy4KeffkLfvn0REhLSLA/+wAMP4KOPPkJgYCAmTZoENzc3pKenY/PmzXBycsIDDzyA69evQ6FQYPTo0RrtMzIyEhs3boRCoUDv3r0xe/ZsyOUNP01NttFknV27dmHfvn0oKChAhw4dMHv2bLi4uGh3UEgjAa7WGN/VE1vPp2BVxA18M6e32CEREREREVEbdyW5qtdAgKs1zE1kIkfTurQqSOju7o7jx4+juLgYgiBApVKhoqKizpsgCI3uz9LSEidPnsRzzz2HyMhI/Pzzz4iMjMSiRYtw8uRJWFpaIjAwEPv27Wv0Ah8ADh8+jO7duyMtLQ3t27fH0qVLMWHChCZvo8k6L7zwAqZOnQozMzOEhobi77//RkhICOLj4xuNm3Tz7N0dIZUAe69l4EJirtjhEBERERFRG6euN2BkxQgBQCJochV/S1RUFAYMGID09PRG1123bl2ThhzoomfPnggJCcHGjRsBANeuXUNwcDB27NiBsWPH6ryNJuvY2trizTffxPPPPw8AKC8vh6urK5YsWYJFixZpFH9+fj7s7OyQl5cHW1v9bIwqlQo5OTlwdHSsVStCDIt+PY/fzyVjYEdnbHy0r9jhkAHQtzZO1NzYxsnQsY2TIWP7bnlPbjyDf66k4fWxwZg7sL3Y4TSZNteYWrWogIAAxMTE4PTp0xgzZgwWL16M/fv313mr72K8paSmpuLs2bOYOnWqellQUBC6d++O7du367yNpvv18fFBamqq+m+FQgGlUgk/P7/meopUh+fu6QQTmQSHb2bhaFSW2OEQEREREVEbZqwzFQBa1hwAqoYC9OzZEwsWLICHhwe6dOnSpACKiorw9ddf4+LFi1AoFDXumzZtGqZNm6bRfqKjowGg1sW4n5+f+j5dttF0v1u2bMETTzyBIUOGwM3NDWfOnMGyZcswceLEemMuLS1FaWmp+u/8/KqGqFKpoFKp6t1OTCqVSj2kRB+0szfHjD4++P54PFb8fQ1bn+oHiUQidljUhulbGydqbmzjZOjYxsmQsX23rHxlORJyigEAQW7WBnGctXkOWicHqo0YMUL9e2FhIWQyGSwsLLTaR1lZGfr27QszMzNIJBJIpVJ4eXlh165dcHNzw+OPP67xvkpKSgAAVlZWNZbb2NggIyND52003e++fftw7do1PProo/Dw8EB2djZ+/fVXzJw5s96ihMuXL8fbb79da7lCoUBFRUW9z1VMKpUKBQUFEARBb7oyPdjNCZtOJ+JSch42nYjC8EAnsUOiNkwf2zhRc2IbJ0PHNk6GjO27Zf2bkAcA8LQ1g0pZiBylyAE1g4KCAo3X1Tk5AAA7duzAc889h6ioKHWNgW3btuHKlSt49dVXG93+zz//hIWFBU6cOIF3330XAPDWW28hNjYW/fr1g7+/v8axVI+fyM3NrbE8JycHdnZ1T3OnyTaarJOeno4FCxbgu+++w4MPPggAmDdvHjp37oz33nsPn376aZ2P/8orr9SoR5Cfnw9vb284ODjodc0BiUQCBwcHvTkhOToCcwe2x2f7ovDVsRTc36cDTGT6ERu1PfrYxomaE9s4GTq2cTJkbN8tK+5yLgCgm48DHB0dxQ2mmWhS2F+9rq4PcvXqVcycORNLly7Fnj171MtHjx6N5557DnPnzoWrq2uD+4iKisKwYcMgk8lgamqqvgD39/fH5MmTsWfPHgQHB2sUT3BwMGQyGa5cuYLu3burl1+5cgVTpkzReRtN1klMTER5eTlCQ0PV98tkMgQHB9c7pAEAzMzMYGZmVmu5VCrV6zd7dS8PfYrx8cEd8L+TCYjLLsbms8l4sK+v2CFRG6aPbZyoObGNk6FjGydDxvbdci7fmsYwzNveYI6vNs9D52e8ZcsWzJ07F/Pnz6/Rbd7U1BRdunTBoUOHGt2HUqlUD0Vo164drl69qr6vsLBQq671tra2GDt2LL788kuUl5cDqOqZEBcXV6NuwapVq/Dhhx9qvI0m6wQGBsLCwgJbt25VP05mZiaOHj1aI6FALcfaTI6nhwUAAD6NuImSskqRIyIiIiIiorbkQlIuACCsXd09zw2dzsmBtLQ0eHt7A0CtAnCVlZUoKyvTan9jxozB/v378eijj2L+/Pn4+eefMXToUK328fnnnyMjIwNdunTB2LFjMX36dLz77rs1LtAjIiKwa9curbZpbB0bGxt8/fXXWLlyJQYMGIDJkycjJCQEgYGBeOmll7R6DqS7GX194OVggYyCUnx7NFbscIiIiIiIqI3IKSpDkqKq3lxnI00O6DysoHPnztizZw8WLFhQIzkQHR2NgwcPqr+db8jcuXPVv7u4uGDPnj34+OOPkZaWhl9++UXrb929vb1x+fJlHDhwAAqFAp9++ikCAgJqrPPcc8+hsrJSq200WWfmzJkYNWoUzpw5g/z8fLz66qvo0aOHVvFT05jJZXh+RCc89+sFfHUwGtP7+MDRylTssIiIiIiISM9dSq4qRtje2Qp2FiYiRyMOiSAIgi4bFhQUoFu3bujduzdSU1MRGBgIV1dXrFmzBsOHD8dvv/3W3LEavPz8fNjZ2SEvL0+vCxLm5OTA0dFRL8fhqFQCxq0+gqup+Zjdzxfv3Bfa+EZEt9H3Nk7UVGzjZOjYxsmQsX23nNV7b+KjPTdwXzdPfDrNcIaGa3ONqXOLsrGxwZEjR2Bubo6rV69i/fr12LBhAx5//HFs3LhR190SNYlUKsHr46qKWP7vZAJupms+dQcRERERERmni7d6DnQx0iEFQBOnMvTw8MCGDRuaFEBERAQ+//xzxMfHqwv+VXvqqafw1FNPNWn/ZHz6d3DGiBA37L6ajvd2RuL7R/qIHRIREREREemxS0lVyYGu3vbiBiKiJiUHmurcuXMYO3YsZsyYgQEDBtSag5Fj9klXr44Jxv7rGTh4IxP7r2dgaGDD02oSEREREZFxyshXIi1fCakECPHQz+HdraFJyYG4uDi8/vrrOHjwIDIyMuDt7Y1Jkybhtdde02jM/N69ezFjxgx89913TQmDqBY/ZyvM6e+HdYdjsXRnJAYEOMNExnFZRERERERU08VbvQYCXK1hZSbq9+eiatJUhr1790ZsbCxeeuklfP/995g7dy42b96MESNGQKVSNboPOzs7WFhY6BoCUYOeHtYRjlamiMooxE8nE8QOh4iIiIiI9NDFpFwAQJiXvahxiE3n5MCGDRvQo0cPHD58GE8//TSmTZuGl19+GWfOnEFKSgoOHTrU6D4mTpyIPXv24Pjx47qGQVQvOwsTPHdPJwDAx3tuILuwVOSIiIiIiIhI31QXIwzzMt5ihEATkgPx8fEYOXJkrSk07O3tER4ejoSExr+pdXJywujRo9G/f384OzvDz8+vxm3VqlW6hkcEAJje2xshHrbIKynH+/9cEzscIiIiIiLSI4Ig4EJiLgDjnqkAaELNAV9fX0REROC5556DRCJRL8/Ly8OJEyc0mmUgIiICX375JZ5++ml07tyZBQmp2cllUrw7oTMmfXkcv51OwtTePujp6yB2WEREREREpAdis4qgKC6HqVyKzp5MDuhkzpw5+OijjzBkyBA88MADcHZ2Rnx8PNavXw8PDw8MGjSo0X2cOXMGc+bMwerVq3UNg6hRPX0dMaWnFzadScKSrZex/ZkBkEkljW9IREREREQG7WxCLoCqXgOmcuMuYK7zs3d3d8epU6fg7e2N5cuXY9asWVi7di3uv/9+7Nmzp9Zwg7q0a9cOMplM1xCINPby6CDYmstxNTUf/zsZL3Y4RERERESkB84mKACAvYvRhOQAAPj7++PHH39EUlISysrKEB0djffff1+jaQwBYNSoUdizZw/27t3blDCIGuVkbYYXRgUBAD7cdR2ZBSxOSERERERk7M7GVyUHevjYixuIHtApOXDt2jVkZ2fXeV9sbCxSUlI02s+GDRuQlpaG4cOHw8bGBu7u7jVuK1eu1CU8ojrN6OOD0Ha2KFBW4L2dV8UOh4iIiIiIRFSgLMf19AIAQA8f9hzQuuZAUVERxowZg9OnT9d5f1JSEt544w3s37+/0X2NGDEC7u7u9d4fFhambXhE9ZJJJVh2fxdM+OIotp1PwYRu7TA0yFXssIiIiIiISAQXEvMgCICXgwVcbc3FDkd0WicHNm3ahKFDh8LR0bHO+wcOHIiMjAxcv34dgYGBDe4rLCyMCQBqVWFe9nh0gD/WHY7Fa39cwu5Fg2FtpnNdTiIiIiIiaqPOqIcUsNcAoMOwgsjISAQHBze4TnBwMCIjI3UOiqglPXdPJ3g7WiAlT4mVu66LHQ4REREREYmAxQhr0jo5UFxcDLm84W9aZTIZiouLdQ6KqCVZmsqx7P4uAIDvj8epM4ZERERERGQcVCoB5xLYc+B2WicHOnXqhAMHDtR7f3l5OY4ePdrokAIiMQ3s6IJJPbwgCMDLWy6itKJS7JCIiIiIiKiVRGcWIl9ZAXMTKYI8bMQORy9onRyYNGkSdu3aha+//hqCINS4T6lUYsGCBbCxsUH37t2bLUiilvD62GA4W5viZkYhVkXcFDscIiIiIiJqJdVDCrp62cNEptMkfgZH60psnp6e+PTTT/Hkk09izZo16N+/P1xdXZGQkICIiAjk5uYiIiICUql2B7ioqAjl5eU1lpmbm8PcnFUjqWU4WJnivQld8OSPZ7D2YDSGB7uip2/dhTaJiIiIiMhwqIsRst6Amk4pkscffxz79u1Du3bt8Ouvv2Lp0qXYtWsXhg0bhjNnzqBPnz4a72vp0qVwdnaGtbU1HBwcatxWrFihS3gAgIqKihbZRpN1VCpVrV4VpJ9GhbpjYvd2UAnA879dQHGZ9u2GiIiIiIjallOxOQCA3n5MDlTTuf/EkCFDsHPnTmRnZ6O8vBzJycnYsGEDOnbsqPE+IiIisGLFCixduhTHjx/Hv//+W+P2+OOPaxVTZWUlFi1aBDs7O5ibm6NHjx44depUk7fRdL/Hjh3DgAEDYG5uDnd3d7z77ruorORYdn335vjO8LAzR1x2Md7/+5rY4RARERERUQtKy1MiLrsYUgnQy489h6s1y+CKwsJClJSUaL3duXPnMGfOHDzxxBMIDw9Hr169atw8PT212t9bb72F//3vf9i/fz/y8vIwYMAAjBo1CllZWU3aRpN1Tp48iWHDhmHEiBHIzc1FTEwMBEFAXFyc1seFWpedhQk+mBwGAPj+eDyORtXfXoiIiIiIqG07GZsNAAjxtIWtuYnI0eiPJiUHduzYgY4dO8LGxgb/+9//AADbtm3DsmXLNNre29sbSqWyKSGoVVRU4PPPP8eiRYvQo0cPWFlZ4cMPP0RFRQW+//57nbfRdL+LFy/GsGHD8MYbb8DS0hJWVlZ444030KFDh2Z5ftSyBnZ0waxwXwBVwwsURWUiR0RERERERC3hREzVkIK+/k4iR6JfdE4OXL16FTNnzsTChQtx3333qZePHj0a69evR0ZGRqP7GDt2LE6cOIG9e/fqGobatWvXkJubi0GDBqmXmZmZITw8HCdOnNB5G03WUSgUOHr0KKZOnQpAt3oHJL5XxgShvYsV0vKVeHHLRdaNICIiIiIyQNU9B/r6c0jB7bSeraDali1bMHfuXMyfPx/nz59XLzc1NUWXLl1w6NAhTJ48ucF9rF27FrGxsRg+fDisra1hZWVV4/7Fixdj8eLFGsVTnYxwcXGpsdzFxQVJSUk6b6PJOvHx8RAEATk5OejUqRNiY2Ph6uqKp556Cq+++iokEkmdj19aWorS0lL13/n5+QCqChqqVKrGn7QIqost6mt8TWEul+LTqV0x6cvj2HM1Hd8fi8Psfr5ih0WtzJDbOBHANk6Gj22cDBnbd9NlFpQiJrMIEgnQy9fe4I+lNs9P5+RAWloaOnXqBAC1Ln4rKytRVtZ4t+wRI0bA3d293vvDwsK0juvOJ69Sqeq9ONdmm4bWqf6G+ZNPPsGOHTsQGhqKAwcOYNy4cbC2tsaCBQvqfNzly5fj7bffrrVcoVDobe8DlUqFgoICCIKg9XSVbYGHOfDMIB98tD8ey/6KRKCjDB1dLMUOi1qRobdxIrZxMnRs42TI2L6bbt+1ql4DAc6WUCkLkdM8o9z1VkFBgcbr6pwc6Ny5M/bs2YMFCxbUuJCOjo7GwYMH8eGHHza6j7CwMJ0SAHWpLl6YkZGhTlpU/+3h4aHzNtqs88QTT6ifz7BhwzBp0iRs27at3uTAK6+8gkWLFqn/zs/Ph7e3NxwcHGBra6vFs2891UkRBwcHgz0hPTXcAWdTirH/eiaW/BWDrfP7w9JU57cKtTHG0MbJuLGNk6FjGydDxvbddFcyUwEA/QNc4Oho+MMK5HLNr2N0vuKZNWsWPvroI0ybNg2pqanqyvxr1qzB6NGjERwcrNX+SkpKkJKSAk9PT1hYWGgdT6dOneDq6oq9e/diwIABAICioiIcP368RqKiugCiubm5Rttoso6bmxsCAwNr9ZYoLS2FqalpvTGbmZnBzMys1nKpVKrXb3aJRKL3MTbVyildMfrTw4jKLMKbf0Zi5ZSwRnugkOEwhjZOxo1tnAwd2zgZMrbvpjkVV1WMMLy9k1EcQ22eo85Hw8bGBkeOHIG5uTmuXr2K9evXY8OGDXj88cexceNGjfdz8eJFDB06FFZWVggICICVlRWGDh2KixcvahWPVCrFCy+8gI8//hh//fUXYmNj8dhjj8HBwQGzZs1Srzd58mSMGzdO42003e/rr7+ONWvWYPfu3cjIyMBPP/2ErVu34qGHHtLqeZB+cLI2w6pp3SCVAFvOJuGnUwlih0RERERERE2QU1SGG+mFAIA+LEZYS5P6Snt4eGDDhg06b5+VlYWhQ4di4MCB2LFjBzw9PZGamoq1a9di6NChuH79OpydnTXe3+LFi6FSqbBgwQIoFAr07t0be/furdFF38LCosY3wJpso8k6M2fORFlZGZ5//nmkpaXB398f3333HaZPn67z8SFx9e/gjBdGBuH9f67h7T+vorOnHbp524sdFhERERER6eDUrVkKOrpaw8m6dg9uYycRmjBfW2lpKWQyWY1xDHUtq8+6devw008/Yd++fTUu2AVBwLBhw/Dggw9i7ty5uobX5uTn58POzg55eXl6XXMgJycHjo6ORtENRxAEPPnjGey6kg5PO3Nsf2YATyQGztjaOBkftnEydGzjZMjYvpvm9a2X8OOJBMzu54t37gsVO5xWoc01ps4tKjMzE7169UJ2dnaN5adOncI999yj0ZQJmZmZ6NatW62x3BKJBN26dUNmZqau4RE1C4lEgg+ndIW/sxVS8pR49pdzqFTpnE8jIiIiIiKRHLmZBQAYEKB573RjonNy4Ntvv8W4cePg5uZWY/nAgQMhCAKOHz/e6D6Cg4Oxfft2KBSKGstzcnLw559/IigoSNfwiJqNrbkJvprZExYmMhyNysayvyLFDomIiIiIiLSQmFOMuOxiyKQS9OvgJHY4eknn5EBiYiIcHBzqvM/BwQFxcXGN7mP8+PHqSv9PPvkk3n77bTz55JMIDAyEu7s7xo8fr2t4RM0q0N0GK6d0BQB8cyQWv/7LAoVERERERG3F4Vu9Brp728PG3ETkaPSTzsmB0NBQbNq0CRUVFTWWJycn48CBAxpNZSiTybB//368+uqriI2NxebNmxEbG4vXXnsN+/fvh0wm0zU8omY3NswDC+7uCAB4fetlnIzJbmQLIiIiIiLSB0eiqoasD+zoInIk+kvngoSFhYUICwuDg4MDHnroIbi6uiI6Ohpr1qxBjx49sH379uaO1eCxIKH+U6kEPPPzOey8lApHK1Nsm38XvB0txQ6LmpGxt3EyfGzjZOjYxsmQsX3rplIloMe7e5BXUo4t8/qjp2/dPeANUasUJLS2tsbhw4cRHByMt956CzNmzMBXX32FmTNn4rffftN1t0R6TSqVYOWUrujSzg45RWV4ZMO/yCsuFzssIiIiIiKqx6XkPOSVlMPGXI6uXnZih6O3dE4OXLlyBYIg4Mcff0ROTg5UKhUSExPx/vvvw8LCot7tli1bBmtrayxbtkz9e323ZcuW6RoeUYuxMJVh3execLM1w82MQjz2w2koyyvFDouIiIiIiOpw5GbVkIL+HZwgl7HHRX3kum64evVq9OzZE4899phW202cOBEhISHqmQhCQkLqXZezFZC+crczx/eP9MGUL4/jVFwOFvxyDmse7AmZVNL4xkQGRBAEfHs0Dj187NHdx3i66BEREVHbUV2MkPUGGqZzcqB9+/aIjNR+SregoCD1RX9ERASsra0xfPjwWutFREQgKSmJCQLSW0Hutvh6di889O0p7LqSjrf+vIJ37usMiYQJAjIe5xJz8e6Oq7A2k+OfhQPh5cAaHERERKQ/ikorcDZBAQAY2NFZ5Gj0m859KmbPno1t27bhq6++QlxcHHJzc2vcysrKGt3HkSNHcOTIkXrvO3r0qK7hEbWKfh2c8MnUbpBIgI0n4rHmQLTYIRG1qgJl1Yw1haUVeHHzRahUOtW4JSIiarLI1HxcTs4TOwzSM0ejslBeKcDH0RK+TlZih6PXdE4OvP7664iJicG8efPg7+8PBweHGrcffvhB56AqKytx+fJluLiw2wfpv7FhHnhzXNXwmA93XcfPpxJEjoio9dyeDDgWnY0fT8aLGA0RERmrhOxijP70MO5fc5S1oKiGvZEZAIC7g11FjkT/6TysYMmSJXjyySfrvd/Pz6/e+1asWIEVK1ZAqVQCAFatWlXj/uLiYlhaWuLjjz/WNTyiVjXnLn+kF5TiywPRePWPSzCRSTG5p5fYYRG1uMpbyQGpBFAJwPK/rmFQRxf4OTMzT0REreejPdcBAOWVAorLKmFuIhM5ItIHKpWAvdduJQeC3ESORv/pnBzw9fWFr6+vTtuOHz8eAQEB6ikPH3jgAfV9EokEdnZ26NmzJxwcWNyK2o4XRwaiqLQCPxyPx4ubL8BEJsF93dqJHRZRi6oUqpIDXb3tYS6X4XhMNl7YfAG/PN6PBTqJiKhVXE7Ow7bzKeq/KznEjW65mJyHrMJSWJvJ0cffUexw9J7OyYFqxcXFiIyMRHp6Onx8fBAcHAyZrOFMXUhICEJCQtCrVy8ADfcyIGorJBIJ3rq3M8orVfj5VCIW/XYBpjIpRnfxEDs0ohZTPaxALpXgg8lhGLXqEP6NU2Dd4Rg8ObiDyNEREZGhEwQB7+28WmOZSmBygKrsi0wHAAzq5AxTOacwbEyTjtDGjRvh5+eHXr16YezYsejSpQvCwsJw/Phxjbb38/NjYoAMilQqwdIJXTC5pxcqVQKe+fkc9lxNFzssohZT3XNAKpHA29ESS27V31i56zrOJ+aKGBkRERmDiMgMnIjJqXHhx54DVC0ikkMKtKFzcuDUqVN49NFHsWjRIiQmJqKkpASRkZEIDw/HuHHjkJfXeKXQd955B3K5vN7bO++8o2t4RKKRSiV4f1IY7uvmiQqVgKf+dwb/XE4VOyyiFlH9D1j1EIKpvb0xtosHKlQCnvn5LPKV5WKGR0REBqy8UoXlf1VNrf7oAH+Y3UoQMDlAAJCSW4KrqfmQSIAhgSx0rwmdhxX8/vvvmDdvHl5++WX1sqCgIHzzzTe4fPky9u/fjwkTJjS4jxkzZqBPnz41lhUUFOD333/HlStXMGPGDF3DIxKVTCrBR1O6okIlYOfFVMz/6Rw+nFyJiT1YpJAMS3XXzerkgEQiwbKJXXAhKReJOSV45fdL+Hx6d0gkrD9ARETN66eTCYjJKoKTlSmeGtIB3x+LA8BhBVRl361ChD18HOBkbSZyNG2DzsmBwsJCeHt713mfh4cHCgsLG91HQEAAAgICai2fMmUKhgwZgpSUlDrvJ2oL5DIpPp3aDRYmMmw+k4RFv11AUVklZoXrVsiTSB9Vqqp+Sm+7+LezMMHq6d0x5avj2HkxFQMDnDGtj49IERIRkSHKLCjFR7urZihYeE8n2JibQHbrs4g9BwgA9t6qNzAsiFMYakrnYQW9e/fGunXrkJKSUmP50aNHERERoS422JT9nzlzpkn7IBKbXCbFB5PCMKe/HwBgydbLWHswWtygiJqR6o5hBdW6+zjghZGBAIC3tl/B1ZT8Vo+NiIgM1/K/IpGvrEBoO1vMuJWAlt76LGLPASosrcDR6GwAwPBg1hvQlM7JgRkzZsDf3x/t27fHPffcg+nTp6N///4YOHAg5s+fj6CgIJ2DUigU2L17NxwdOd0EtX1SqQRv3huC+UOrKrcv//saPtx1DQI/uMgA3F6Q8E6PDWyPIYEuUJar8MSPp6EoKmvt8IiIyAAdj87G7+eSIZEASyd0USeoq39W92oj47U3Mh1lFSr4O1uhk5u12OG0GToPKzAxMcHu3buxZcsWHDhwABkZGejXrx8++ugj9OvXT6N9rFmzBmvWrKmxrKKiAvHx8QgICMDkyZO1jkuhUGD79u1QKBTo3bs3+vfv3yzbaLPf06dPIyIiAkOGDEF4eLjWz4EMj0QiwQsjg2BlJscH/1zHF/ujkZqrxIpJYZxWhdq0/woS1r5PKpVg1dRuGP/5USTkFOPZX87huzm9Ia9rZSIiIg2UVaiwZNtlAMCDfX3Q1dtefZ+Uwwrolr8uVRUDH9PFnXWPtKBVcuDjjz9GcHAwRo8ejSNHjsDFxQWTJ0/W6SIeAHr06IG5c+fWWGZiYgI/Pz+MGDECJiYmWu3v2rVrGDJkCAICAhAYGIi33noLs2fPxqefftqkbbTZb1ZWFqZMmYLU1FS89dZbTA5QDU8NCYCzlRle+eMSfj+XjNQ8Jb6a1RN2Ftq1dSJ9cWdBwjvZW5ri69k9cf8Xx3D4ZhY+3H0dr4wObs0QiYjIgHx1MBpRGYVwtjbFCyNr9lSuzj1zWIFxKyqtwIHrmQCAMV08RI6mbdEqOXDz5k1YWloCADZs2IDw8HAEBgbq/ODh4eHNevH8zDPPoGvXrvjnn38gkUgwe/ZsDBkyBFOnTq33m35NttF0v4IgYM6cOZg3bx4+/vjjZnteZFge6O0NNztzPPXjGRyPycaUr47hu4f7oJ29hdihEWmt+tuZuoYVVAtyt8WHU8Lw9E/nsPZgDEI97XBvV8/WCpGIiAzElZQ8fLb3JgBgybiQWl+usCAhAVWzFJRWqODrZIkQD1uxw2lTtEoOBAUF4dtvv4WtrS3i4uJgYmICe3v7Otft1asX/Pz8NNpvYmIiDhw4gJSUFHh6emLo0KHw8tJuyrecnBzs3bsXv/zyi7rryODBgxEYGIhNmzbVmRzQZBtt9vvJJ5+gqKgIixcvZnKAGjS4kwt+e7IfHtnwL26kF+L+L45i/UO9EOZlL3ZoRFqprKcg4Z3GhXniUnIe1h6MweJNF+DlYIHuPg6tESIRERmAsgoVFm+6iAqVgFGd3TG+jiRzdUHCSvYcMGr/DSnw4JACLWmVHJg7dy5Onz6NF198EZmZmTh27Bh+/vnnOtddvXq1RsmBd999F++99x6srKzg5uaG9PR0FBcX44033sCrr76qcWzXr1+HIAi1ejIEBgYiMjJS52003e+ZM2fwwQcf4N9//4VUqtl42tLSUpSWlqr/zs+vquatUqmgUulnJRWVSgVBEPQ2vrYk2N0GW57sh0e+P40b6YWY/NVxrLg/FBO6txM7NKPGNq6dylvHSSpBo8ds8T2dcCOtAPuvZ2Lu96ex+clw+DpZtUaYdBu2cTJ0bOOGafW+m4hMzYejpQneuS8EgiDUKu5cnaiuqNTf/6Wbiu27YcVlFdh/PQMAMLqzG48TGv//7HZaJQesrKywceNGAFWJgvDw8Fo1A7Rx8OBBLFu2DD/99BMmTpwIiUQCQRDw+++/Y+bMmRgwYAAGDRqk0b4KCwsBAHZ2djWW29vbIzq67qnjNNlGk3UKCgowbdo0fPbZZ/D29tYoXgBYvnw53n777VrLFQoFKioqNN5Pa1KpVCgoKIAgCBonQah+5gC+fiAQS3ZG43BMLhZtuohzsZl4epB3o9/EUstgG9dOQWExAKCirAw5OTmNrv/2SF+k5hbhWnoxHvr2FL6dEQJ71txoVWzjZOjYxg3P5dRCrNkfBQB48W5fSMuKkJNTVHtFoeoiKDc3Dzk2htl7gO27YRHXs6EsV6GdnRk8zCs0+t/E0BUUFGi8rs6zFSxfvhxmZma6bg4AOH78OGbNmoVJkyapl0kkEkyaNAm7du3C8ePHNU4OWFlVfftU/e17tby8PPV9umyjyTqff/45SkpKEBMTgxUrVgAAioqKcPDgQVhaWuLZZ5+t8/FfeeUVLFq0SP13fn4+vL294eDgAFtb/Rwfo1KpIJFI4ODgwBNSM3EE8N0jLvgk4ia+OBCNjadTEZdXjs+mdWOhQhGwjWvHzEIBALCwMNdo+llHABse7ouJXx1HgkKJl3fEYuMjvWFmImvhSKka2zgZOrZxw5JXUo7Xdl5EpQCM6+KBB/p1rHddU3nVpY2ltY3BTonO9t2wg7HxAICxXT3h5OQkcjT6QS7X/JJf5+SAi4uLrpuqeXt749q1a3XeV1paqtW38J06dQIAREVFISwsTL08KioKQ4cO1XkbTdbp2bMnZs6cidzcXPX9giCgpKQEeXl59cZsZmZWZ4JFKpXq9ZtdIpHofYxtjVQKvDAqCCGedli86QIO38zCfV8cw5oHeyC0nV3jO6BmxTauueoenTItjpe7vSU2PNwHk748htPxCiz87QK+mNGDUxy2IrZxMnRs44ZBEAS8uOUSknNL4OtkiWWTujT4mlb3uhQAg37t2b7rlldcjr3XqoYUjO/ajsfnFm2Og1bJgb///hsXLlzQOqAxY8bUuLCuNnbsWLz55pv46quvMGfOHJibm0OpVGLDhg04evRog1MQ3snZ2RkDBgzADz/8gIkTJwIA/v33X1y5cgWrV69Wr7d582ZUVFRg2rRpGm2jyTojRozAiBEjasSzYcMGjBo1Ci+//LIWR4qM3dgwD/g7W+HxjaeRkFOMiV8ew5v3hmBGHx8WVCG99F9BQu226+Rmg7WzemLOt/9i15V0LN50AR8/0E1dTIqIiOjbo3HYczUdpjIpvpjRA7bmDfeolHK2AqO281IqyipUCHSzQWdP/eyFre+0Sg7ExMTgxIkTWj9Ir1691L+vXLkSK1euVP9dWFiIefPm4amnnoKdnR3y8vIgCAKsrKywfv16LF68WOPHWb16NYYMGYKxY8ciKCgIP/74I2bPnl2j58CGDRugVCoxbdo0jbfRZB2i5hLiaYsdzwzA879dwN5rGXjtj8s4FZuDZfd3gZWZzp19iFpE9VzSMh2SV/07OGPNgz3w5I9nsPV8CizN5Fg6IZSJMCIiwvnEXKz4u6r49+vjgjXqSVndc0DF2QqM0h/nkgAAE3u04/8SOtLqSmP+/PmYP39+kx5wxIgRcHd312jdunobNKRbt264evUqNm3aBIVCgW+//RZjx46tsc6UKVNqFPvTZBtN1rnTM888g379+mkVP1E1e0tTrJvdC+sOx+CDXdex7XwKLiXn4YsZPRDM+VpJj1R/O6PrN/7DQ9zw8dRuWPDLOfx0MgGWJjK8NjaYH+pEREYsr7gcT/90FuWVAsZ0ccescF+NtlNPZcgC9UYnPrsI/8YpIJEA93XjzF+6avWvIcPCwrS+6NeGp6cnFixYUO/9Dz30kNbbaLrO7V577TWN1yWqi1QqwRODO6CnrwOe/ukcYjKLcN/nR/HiqEA8cpc/u1+TXqhsQs+BauO7ekJZVokXt1zE+iOxkEiAV8cwQUBEZIxUKgGLN19AkqIEPo6WWDEpTOPPA9mt1TiswPj8cS4ZADAgwBnuduYiR9N2sUoDkZ7r5eeInc8OwPBgV5RVqvDezkjM/OYkUnJLxA6NCCp1zYGmXcg/0Nsb79zXGQCw7nAs3th2Rb1vIiIyHqv3RWlVZ+B2HFZgnARBwO9nq5IDE3uw10BTtHpyYNmyZbC2tsayZcvUv9d3W7ZsWWuHR6SXnKzNsG52Lyyf2AUWJjIci87GqFWH8OeFFLFDIyNX3XWzOXqyzO7nh+UTu0AiATaeiMfLv1/ktz9EREZkz9V0fBJxAwDw3v2h6OKl3YxNLEhonM7EK5CQUwxLUxlGdtZs+DrVrdWHFUycOBEhISEICgoCAISEhNS7bvU6RFQ1bc30Pj4Ib++Ehb+ex4XEXDz78znsjUzHW/d2hoOVqdghkhFqSkHCukzv4wNzEyme/+0CfjudhJJyFT6a0hWmcnZ0IyIyZFEZBXju1/MAgIf6+eKBXppPaV6NPQeM02+nEwEAo0LdYWnK4t1N0epHLygoSH3Rn5ubC3d3d9jb27d2GERtlr+zFTY/2Q+f74vC5/ujsO18Co5GZeGd+0IxOtSd47SpVTW1IGFd7u/uBTO5DM/+fA7bL6Qgp6gUX87sqVXXUiIiajvySsrx2A9nUFhagT7+jnh9XP1fHjZEJmXPAWOTV1yu7kk7o4+PyNG0faJ+FbN69WqsWrVKzBCI2iQTmRTP3dMJW+b1R0dXa2QVluGp/53Fkz+eQUa+UuzwyIg0R0HCuozp4oFv5vSGlakMR6Oy8cBXx5GWx7ZNRGRoyitVePqns4jNKoKnnTnWPNgDJjLdLlE4rMD4/H4uCcpyFQLdbNDT10HscNo8UZMDnp6eSExMFDMEojatm7c9djw7AM8OC4BcKsGuK+kY/vFB/HY6EQK71FEr+K8gYfPve3AnF/z6RD+42JjhWloB7l9zFNfTCpr/gYiISBSCIGDJ1ss4fDMLFiYyfD27F5ytzXTeH4cVGBdBEPC/kwkAgAfDfdh7thmImhyYPHkyjh07hq1bt0Kl4oSkRLowk8uwaEQgtj8zAF3a2SFfWYEXN1/Eg+tPIjqzUOzwyMC1xLCC24W2s8Pv8/qjvYsVUvOUmLjmKPZGprfIYxERUetacyAav/ybCKkE+HxGd4S2064A4Z3+G1bQHNGRvjsVm4OojEJYmspwf3fOUtAcRE0OrFu3DomJibj//vthYWEBd3f3GreVK1eKGR5RmxLsYYs/nuqPV0YHwUwuxbHobIxedRgf7b4OZXml2OGRgWqpYQW383a0xO/z+iO8vSOKyiox94fT+OpgNHvHEBG1YdvOJ+PDXdcBAG+N74y7g92avM/qz6JKfj4YhepeA/d184QN6xI1C1HLOY4YMQLu7vVPNxEWFtaK0RC1fXKZFE8M7oDRoR5448/LOHA9E6v3RWHr+WS8Mz4UQ4NcxQ6RDMx/wwpatiufvaUpNj7aF2/+eQU/nUzAir+v4UZaAZZN7AJzE1mLPjYRETWvY9FZeGHTRQDA3AH+mN3Pr1n2qx5WwJoDBi+rsBR/X04FAMzo4ytyNIZD1ORARkYG3N3dMXz48Fr3RUREICMjQ4SoiNo+HydLfDenN3ZdScPb268iMacED2/4F6M6u+P1ccHwcrAUO0QyEJW3/v+StsI4PxOZFEsnhCLI3QZvb7+K388lIza7CGtn9YSrjXmLPz4RETXd+cRcPPb9aZRVqjCqszteHRPcbPuWcrYCo/HjiXiUVwro6m2PLl5NG45C/xF1WMGRI0dw5MiReu87evRoK0dEZDgkEglGhXogYtFgPDbQHzKpBP9cScPdHx3Ex3tuoKSMQw2o6Vqr50A1iUSC2f388MMjfWBnYYJzCbkYv/ooTsfltMrjExGR7q6nFWDOd6dQVFaJuwKcsGpat2atWSO7tSsWJDRsJWWV+OF4PICqnifUfERNDtSnsrISly9fhouLi9ihELV5VmZyvDY2BDufHYDw9o4orVDhs703cfdHB7DjYgrHbVOTtHRBwvrcFeCMrfPvQgcXK6TlKzH16xP4fN9NfltERKSnErKLMeubk8gtLkc3b3t8PatXsw8LY88B47DlbBJyisrg5WCB0aH1D1En7YmSHFixYgXs7e2xYsUK9e+33ywsLBAREYFx48aJER6RQQpyt8XPj4VjzYM90M7eAil5Sjz90zlM/foELifniR0etVGqVihIWB9/Zytse3oAJnTzRKVKwMrdNzDrm5PIyFe2eixERFS/xJxizFh/AhkFpQhyt8GGh3vDyqz5RzezIKHhq1QJ+OZILADg0QH+kLfEXMpGTJSaA+PHj0dAQAB+++03AMADDzygvk8ikcDOzg49e/aEg4ODGOERGSyJRIIxXTwwLMgVaw/G4MuDUTgVm4Nxq49gQjdPPD8iEN6OrEdAmqtODrRyxwE1azM5PpnaDQM6umDJ1ss4Fp2NkasO4b0JXTA2zEOcoIiISC0xpxjTvj6B5NwS+DlZ4odH+8De0rRFHks9lWElkwOGKiIyHbFZRbA1l+OBXt5ih2NwREkOhISEICQkBL169QIA+Pn5iREGkdEyN5FhwfCOmNzLC+//fQ1/XkjB1vMp+OtSGmaG++LpYQFwtGqZD24yLGINK7idRCLB5J5e6O5jj2d+OoerqfmY/9NZ/HPFE++M7wwHtmUiIlEkZBdj2tfHkZKnRHtnK/z8eHiLFpBVDytgzwGDJAgCvj4UAwCYGe7bIr1PjJ2o/TD8/PzUiYGioiLk5ubWuCmV7BpK1JLa2Vvgs+ndseOZARgQ4IyyShW+PRqLwR/sx+f7bqK4rELsEEnPVX85I8awgjt1cLHG1vl34dlhAZBJJdh+IQUjVh3CvmvpYodGRGR04rKKMPVWYqCDixV+eTwcbrYtO7NM9WcRpzI0TMejs3EmXgFTmRRz+vuJHY5BEn2QxtKlS+Hs7Axra2s4ODjUuK1YsULs8IiMQmg7O/w4ty82PtoHnT1tUVBagZW7b2DIhwfw08kEVFSqxA6R9FRrz1bQGFO5FItGBOL3ef3RwcUKmQWleGTDaTz363lkFZaKHR4RkVG4nJyHyV8dR2qeEh1drat6DLRwYgC4bVgBew4YHEEQ8PGeGwCAGX19WqU9GSNR+2JERERgxYoVWLlyJbp27Qq5vGY4np6eIkVGZJwGdnTBXR2csf1iCj7cdR1JihK8+sclrD8SgxdHBmFkZzdI9OAbYtIf+jCsoC5dve2x89mBWLnrOr45Gos/ziVj//UMvDI6CFN6eutdvEREhuJ4dDYe/+E0CkorEOJhi+8f6QMXG7NWeWxpdUFCfqdhcA7dzMLpeAXM5FLMG9JB7HAMlqjJgXPnzmHOnDl44oknxAyDiG4jlUpwX7d2GBXqjp9OJmD1vijEZBbhyR/PoLuPPV4ZHYw+/o5ih0l6olLE2QoaY24iw+vjQjCuqyde+f0SIlPz8dKWS9hyJhnLJoYiwNVG7BCJiAzKP5dT8ewv51FWoUJff0ese6gXbM1NWu3xqwvXq9hzwKDc3mtgZrhviw9PMWaiDivw9vZmXQEiPWUml+Hhu/xx8IUheGZYACxMZDiXkIsH1h7H3O//xY30ArFDJD3w37ACkQNpQDdve2x/+i68NiYYFiYynIrLwehPD2Plruusq0FE1Ew2HI3FU/87i7IKFUaEuOH7R/q0amIAuK0gIWsOGJT91zNwITEX5iZSPDmYvQZakqj/zo0dOxYnTpzA3r17m22fX3/9Nfr06YOOHTtixowZSEhIaJZtGlvn/PnzePjhhxEaGoo+ffrg1VdfRV4e546nts/G3ATPjwjEwReG4MG+PpBJJYiIzMCoVYfw4uYLSM4tETtEElGleipD/es5cDu5TIrHBrXHnkWDMCzIFeWVAj7fH4VhKw9i67lkCPyWiYhIJxWVKryx7TLe2n4VKgGY1tsbax7sAXMTWavHIpMwOWBoKlUCPtxV1WvgoX5+rTZExViJmhxYu3YtYmNjMXz4cNjY2MDd3b3GbeXKlVrt76uvvsLChQuxcOFC/PbbbygoKMCQIUNQXFzcpG0aWyc1NRWPPvoohgwZgl9++QUffPABdu7ciXvvvZf/cJLBcLU1x9L7u2D3c4MwOtQdKgH47XQShn54AG9uu4yMfPYCMkb6VpCwMV4OlvjmoV74amYPeDlYIC1fiYW/nsfEL4/hfGKu2OEREbUp+cpyPLzhX/xwPB4SCfDy6CAsn9gFcpG6k8lvfRZxWIHh2HQ6EZGp+bAxl+MJ9hpocaLWHBgxYgTc3d3rvT8sLEzjfQmCgHfffReLFi3CjBkzAAA//vgj3Nzc8OOPP+Lxxx/XaRtN1nFzc8OZM2dq7Pvzzz/HoEGDcP36dQQFBWn8PIj0XQcXa3w5syfOJijwwT/XcCImB98fj8cv/yZiVrgvnhzSAc7WzOoaC3XPgTaSHAAAiUSCUaEeGBLoim+OxOKL/VE4l5CLCV8cxcTu7fDCqEB42FmIHSYRkV6LyijEkz+eQVRGISxMZPhkajeMCq3///rWwGEFhqVAWY6Vu68DABbc3RGOVqYiR2T4RE0OhIWFaZUAaEhUVBRSUlJwzz33qJfZ2dkhPDwchw4dqjM5oMk2mqwjldbOjpaXlwMATExad6wVUWvp4eOAXx7vh2NRWfhozw2ciVdg/ZFY/HQqAQ/198MTg9rD3pIncUNXXRFaHwsSNsbcRIb5QwMwuacXPvjnOracTcLv55Kx41Iq5vT3w7zBHeDAf0SIiGr5+1IqFm+6gKKySrjbmmP9Q70Q2s5O7LDUn0XsOWAYPt8fhazCMrR3tsLsfn5ih2MURE0O3K6kpAQpKSnw9PSEhYX239gkJSUBQK2eCG5ubkhOTtZ5G132W1FRgTfeeAN9+/ZFhw71d38pLS1Fael/827n5+cDAFQqFVQq/ZyDRaVSQRAEvY2PWl94e0f89nhfHLqZhY/33MSl5Dx8eSAaG4/H45G7/PDIAL9WL0jUFGzj2qm8dZwkaLvHzMXaFB9O7oKZfb2x7O9r+DdOga8PxeCnkwl4YpA/Hr7LD5amevNx2WRs42To2MZbTkWlCh/uvoF1h2MBAH39HfHZtG5wsTHTi+NdnaeuqDTc199Y2nd8dhG+O1LVzl4dEwS5FAb/nFuKNsdN9P92Ll68iAULFuDgwYMQBAESiQSDBw/Gp59+qlWvguonLZfXfEomJiaorKzUeRtt9ysIAh5//HHcvHkTx44dazDm5cuX4+233661XKFQoKJCPytoq1QqFBQUQBCEOntMkPHq4izDt9MCcSg6F18dTcLNzGJ8ti8KG47FYmYvD0zr4Q5L09YvTqQttnHtlJdXnauKCguRk9O2j5e3FbBmUkcci83DF4cTcSOzGB/tuYkNR+PwaD9P3B/mChN9npZBQ2zjZOjYxltGSl4plvwVhQvJhQCAWb09MH+gN2TlRcjJKRI5uiqlyqoiySVKJXJyckSOpmUYQ/sWBAGvbbmOskoB4X526OoiM9jXszUUFGg+w5ioyYGsrCwMHToUAwcOxI4dO+Dp6YnU1FSsXbsWQ4cOxfXr1+Hs7KzRvlxcXNT7vP3b+qysLPV9umyjzX4FQcBTTz2F7du3Y//+/Q32GgCAV155BYsWLVL/nZ+fD29vbzg4OMDW1rbR5ywGlUoFiUQCBwcHgz0hUdPc7+SE+3q1xz9X0rAq4iaiMouw5kgSfjmbjscHtceDfX1gZSZ6XrJebONaklYlfOztbOHo6ChyMM3jXicnjO3hjx2XUvHxnhtIyCnBB3vj8dPZDDw1pAMmdm8HU3nbbRts42To2Mab39bzyXhj21UUllbA2kyG9yeFYbTI9QXqYmNVNVOY3MTUYD6T7mQM7fuPc8k4FpcHU7kU790fBicna7FDatPu/JK7wXVbMI5G/fHHHwgLC8Mff/wBya1+QN26dcOoUaMwbNgwbN26FXPnztVoX0FBQbCxscHRo0fRt29fAFXj/k+ePImXX35Z52202e/TTz+NzZs3Y9++fQgNDW00ZjMzM5iZ1S7cJpVK9frNLpFI9D5GEpdUCozr2g6ju3hi+4UUrIq4gbjsYqz45zrWHorB3IHtMbufL2z0dLgB27jmqsd1msgN63hJpcCE7l4Y08UTv55OxGd7byJJUYJX/7iMz/dFYd7QADzQywtmcv3vDVMXtnEydGzjzSNfWY4lWy9j2/kUAEBPXwesmtoN3o6WIkdWN9mt3l0qAQb92hty+84sKMW7OyMBVBUhDHDTzy9M2xJt2omoLSozMxPdunVTJwaqSSQSdOvWDZmZmRrvy9TUFI899hhWrVqFmJgYVFZW4u2330ZFRQVmz56tXm/OnDmYPn26xttout9nnnkGv/32G/bt24cuXbo05bAQGQyZVIIJ3dshYtFgfDg5DH5OllAUl+PDXdcx4P39WL33JvKV5WKHSU1QXRFa2gYLEmrCVC7FrHBfHHphKJaMC4GLjRlS8pRYsvUyBn9wABuOxkJZXvfQNSKituzIzSyMXnUY286nQCaVYNE9nfDr4+F6mxgAANmtj6JKFiRss97afgW5xeUI8bDF44Paix2O0RG150BwcDC+/fZbvPHGG3BwcFAvz8nJwZ9//omVK1dqtb9ly5ZBoVAgODgYcrkcbm5u2LZtGzw8PNTrZGVlQalUarVNY+tcvXoVn3/+OaytrTF69OgaMX3//fe4++67tXoeRIZGLpNiSi9v3N+9HbZfTMHqfVGIySzCR3tu4OvDMXjkLn88cpc/7Cz1sycB1U91Kzkga0NTGerCwlSGRwf448G+Pvj130R8eSAaaflKvLX9Kr44EI0nBrXHjL4+BlW4kIiMU25xGd7bGYnNZ6qKcns7WmDV1O7o6evQyJbiq/4sUnEqwzZpx8UU7LyYCplUgg8mhxlEnZ+2RiII4qXWKisrMWjQINy8eRMTJ06Eh4cHUlNTsWXLFnTq1AmHDh2CTKZ9l02lUonCwsI66xVkZ2dDEIRa9zW0TWPrVFRUIC0trc5tnJ2dYW5urlHc+fn5sLOzQ15enl7XHMjJyYGjo6NBdmWi1lGpErDjVpIgKqOqsJGVqQwz+vrgkQH+os4xzzaunb7LIpCeX4odzwzQi2msWktpRSU2nU7ClweikZxbVQDLzsIEs/v54qH+fnC2rj1kTF+wjZOhYxvXjSAI2HkpFW/9eQVZhWWQSIDZ4b54YVQQrPW4VtDt/ncyHq/9cRkjQtzw9exeYofTIgy1fSdkF2PsZ4dRUFqBp4cGYPHIQLFDMhjaXGOK+k6XyWTYv38/1qxZg7///htHjx6Fp6cnXnvtNTz11FM6JQYAwNzcvN4LcicnJ623aWwduVwOLy8v7QMlMlIyqQT3dWuHe8M88fflNKzedxPX0gqw7nAsvjsah/u6tcMTg9ujk5uN2KFSIypvzY5j6D0H7mQml2FmuC8e6OWN388m4auD0YjLLsbqfVFYeygGk3t64bGB7eHvbCV2qEREjYrNKsK7O65i37UMAECAqzXen9QFPX3bVlE/2a0hbpXsOdCmlFWo8PTPZ1FQWoGevg5YOLyj2CEZLdHTgKampli4cCEWLlwodihE1MqkUgnGhnlgTBd3HLieia8ORuNkbA62nE3ClrNJuDvIFU8M7oDefg61apOQfqguSGhsyYFqpnIppvXxwZRe3th9JQ1fHYrBhcRc/HQyAT+fSsDIEHc8Mbg9uvvof3dcIjI+BcpyfL4vCt8ejUV5pQATmQRPDQnAU0M7tMmCq9Jbn0WsOdC2fPDPNVxMyoOdhQk+m94dcg4nEI3oyYHExESYmZnB1dVVvSwjIwOlpaXw9vYWMTIiai0SiQRDg1wxNMgV5xIUWHswBruupmHvtQzsvZaB7j72eGJQB9wT4ma0F6H6ytALEmpKJpVgdBcPjAp1x6nYHHx9KAZ7r2Xgnytp+OdKGvr4OWLuQH/cHcw2TETiU6kEbD6bhA/+uY6swlIAwOBOLlgyLgQBrm132jj2HGh7tp5LxvojsQCAlVO6op29eENLSeTkQHZ2NkaPHo29e/fWWC4IAsaMGYODBw8a7BylRFS37j4O+GpWT8RkFmLd4VhsOZuEcwm5ePLHM2hnb4FZ/XwxtZc3HKxMxQ6VYDwFCTUlkUjQt70T+rZ3ws30Anx9KAZbzyfjVFwOTsXlwNvRAg/188OUXt6ws2ABTiJqXYIgICIyAx/tvo5raQUAgPbOVlgyLgRDg1wb2Vr/qQsSsudAm3A6Lgcvbr4IAHhicHvcE+ImckQkap+NP/74A/3794ebW82G4ObmhvDwcPz5558iRUZEYmvvYo3lE7vgyEtD8dSQDrC3NEFybglW/H0N4cv34sXNF3A5OU/sMI1edddNmZH3HKhLRzcbfDilKw6/OAxPDq5qw4k5JXhvZyT6Ld+LJVsvqwtyEhG1tKNRWbh/zTE89sNpXEsrgI25HK+NCcY/CwcZRGIAuG1YAXsO6L2E7GI8vvEMyipVGNnZDS+NDBI7JILIPQcUCkW944glEgkyMjJaOSIi0jeuNuZ4cVQQnr27I/48n4INx+JwNTUfv51Owm+nk9DL1wGz+/thdKg7p7wRgXpYAQ99vdztzPHy6CAsuLsjtp5PxoajcbieXoCNJ+Kx8UQ8BnVywcP9/TC4k4v6H1siouYgCAKORmXji/1ROB6TDQCwMJHh4bv88MSgDgY3hbBcPZWhyIFQgzLylXjou1PIKSpDl3Z2+GRqN37+6QlRkwN9+/bF+++/jyVLltSo9p+QkIAtW7Zgy5YtIkZHRPrE3ESGB3p7Y0ovL5xNUGDDsXj8fSkVp+MVOB2vgKuNGWb09cGMvj5wtdFs+lBqOmMvSKgNC1MZpvfxwbTe3jgenY3vjsUhIjIdh25k4tCNTPg7W+Ghfr6Y3Mu7zUwbRkT6qVIlYNeVNHx5IBqXbvWyM5VJMaOvD+YPDYCLjf5Ot9oU1fVvWJBQf2UUKDF93QnEZhWhnb0F1j/UC5am/MzTF6K+EoMGDcKAAQPQuXNnTJkyBV5eXkhKSsJvv/2GYcOGYciQIWKGR0R6SCKRoKevI3r6OiJjbDB+OpWA/51MQEZBKVZF3MQX+6MwOtQDD/X3Qw8fe85y0MKqew5wWIHmJBIJ+gc4o3+AMxKyi/HD8Tj8ejoRsVlFeGv7VazcfQOTe3phZrhvmy4MRkStr6i0AlvPJ+Obw7GIySoCAJibSDGttw8eG9Te4Iu9yTisQK9lFZbiwXUnEZ1ZBE87c/zyeDjcbPmFjj4RPU2zefNmfP755/jjjz9w9OhRuLq64t1338X8+fPFDo2I9JyrrTkWDu+Ep4YE4J8rafj+WBzOxCvw54UU/HkhBZ09bTG1tzfGd/WEvSULGDY3QRBQ/f8XuwPqxsfJEq+PC8Fz93TC72eT8N2xOMRkFmHDsThsOBaH/h2cMLufL4YHu3FqJyKqV2xWETYej8emM4koUFYAAOwsTPBQfz/M6e8HRyMp4lt9mmRBQv0Tm1WEh787hbjsYrjbmuPnx8Ph7Wgpdlh0B9GTA3K5HAsXLsTChQvFDoWI2ihTuRTju3pifFdPXE7Oww/H47DtfAqupOTjjW1X8N6OSNzT2Q1TenphYEcXdoFvJrd/McOeA01jZSbHrH5+eLCvL45EZWHjiXjsjUzHsehsHIvOhrutOab38cH0Pt5w5bcsRASgtKISeyMz8Mu/iTh0I1O93N/ZCrPCfTG1tzesjGyIkpRTGeql03E5eOyH01AUl8PLwQIbH+0LXycrscOiOhjXGYOIDF5oOzt8MLkrXhkdjD/OJWPTmSREpuZj58VU7LyYCndbc9zX3RP3hnmis6cthx00we3/fLHnQPOQSiUY1MkFgzq5IElRjJ9PJeCXU4lIy1fik4gbWL3vJkaGumNWuC/6+juy/RIZGUEQcDEpD5vPJOHPCynIKykHAEgkwLBAV8zu74eBAc5Ge07msAL9IggCfv03EW/8eQVlFSp09bLD+od6G2zNC0PA5AARGSQHK1M8MsAfjwzwx+Xkqn+ktp5PRlq+EmsPxmDtwRj4OVliXJgnxnX1QKCbDS+0tHR7t032xmh+Xg6WeGFk1Uwd/1xOw8bj8Tgdr1Anujq5WWNWuC8mdG8HG3PDqjhORDXFZRXhr8up+ONsMm7eNgWqh5057u/eDtN6+8DHiV20q3uxcViB+AqU5Xjl90vYcTEVAHBPiBs+ndaNxQf1HF8dIjJ4oe3sENrODq+MCcK+yAxsv5iCfdcyEJddjM/3R+Hz/VEIcLXG8GA3DA10hq81/6nQxO3fzHBYQcsxk8twX7d2uK9bO1xNycfGE/HYei4ZN9ILsWTbFaz4+xom9qgqYBjobiN2uETUTKIzC/H3pVT8dSkNV1Pz1cvN5FKMCnXH5J5e6N/BmcnZ20jZc0AvHL6Zidf+uIyEnGLIpRIsHhmIxwe2N9oeLW0JkwNEZDTM5DKM7uKB0V08UFRagYjIdOy4mIqD1zMRlVGIqIxCfHUwGrbmMgwJdMXdwW4Y3MmFxQzrcftUUVLWymsVIZ62WD6xC14ZE4TfzyRh44l4RGcWYeOJeGw8EY8+/o6Y3c8XI0LcYSrni0LUllRUqnA2IRcHrmdgb2QGrqcXqO+TSSXo38EJY7p4YGyYB2zZW6hO1YkS5gbEkVGgxHs7IvHnhRQAQDt7C6ye0R09fBxEjow0xeQAERklKzO5+tvYfGU59l/LwL5rGThwPRN5JeX480Iq/ryQCqkE6OXriAEdndHX3xFdve1hbiITO3y9oGLPAdHYmptgzl3+eKi/H45HZ2PjiXjsvpqOU7E5OBWbAxcbM0zv44MH+/oY3DRRgiCgoLQCGflK5CsrUFJWiaLSCpSUV6K0XAWJpOoCQSaVQCqRwNxEBhtzOWzM5bA1N6m6Wcg5jIj0Qka+EoduZmH/9QwcvpGJ/FszDQCAXCrBXQHOGNvFA/eEuMHBSGYcaAoWJBRHXkk51h+OwTdHYlFcVgmpBHiovx+eHxEIayMritnW8dUiIqNna26iThSUlVfg0JVE/JuixIHrmbieXoBTcTk4FZcDADCVSdHN2x592zuij78jevg4GF016Go1hhWwq6AoJBIJ+gc4o3+AM1LzSvDzqUT8fCoBmQWl+GzvTazZH4WRnd0xu58v+rSxAoZFpRW4mVGIG+kFuJlegJsZhUjIKUZ6nhJFZZVN2repTAoXGzO42JjB1cYMrrZmcLMxh7udObwcLOHtaAEPOwu2a2p2GflKnIjNwYmYbJyIyUZMZlGN++0tTTC4kwuGBLpgWKAb7CzZQ0AbLEjYujIKlPjxRAI2HI1VJ7a6etnhvQld0MXLTuToSBfG+R8tEVE95DIpunnZYFiYL14ZE4wkRTH2X8/EyZhsnIzNQWZBaY1kgVwqQWg7O/TydUAXr6raBv5OVkYxrq56WIFEgjZ10WmoPOwssOieTnhmWIC6gOGpuBzsvJSKnZdSEeRug1n9fDE+zEPsUOuUmFOMU7E5OB2vwJn4HNxIL2xwfRtzOewsTGBlKoelmQyWpjKYyWUQBAEVKgEqQUClSkBJuQoFynIUKCtQoCyHslyFskoVknNLkJxbUu/+5VIJPOzN4e1gWXVztFAnDrwdLeFibcZ2Tw1SqQTEZBXiXEIuzibk4mRs7WSARAKEetphaKALhgS5oquXPZNSTcCChC2vUiXgZGw2Np1Owo6LKSivrDrWHV2t8fyIThjZ2Z3nxjaMyQEiogZ4OVhiVrgvZoX7QhAExGUX42RMNk7F5uBkbA6Sc0twPjEX5xNz1dtYm8kR4mmLLu3s0KWdHULb2cLPyQpymWGNAVepqn5ySIF+MZFJcW9XT9zb1RORqfn44XhVAcNraQV47Y/LWPH3NYwLccajQ8wQ4CpeAUNleSVOxGTjwPVMHLyRidisolrrOFuboZObNTq52aCjmzX8nazgblf1Db+uFa9LKyqRVViG9HwlMvJLkVmgREZBKdLzlUjNUyIxpxjJuSUorxSQmFOCxJwSANm19mNuIq1KFjhYwMfREt6OljWSBxwTblwEQUB6fikuJuXiQlLVZ8LFxDwUlFbUWE8iAUI8bBHe3gnh7Z3Qx8+RvQOaUXX9G/YcaF6VKgEXk3Kx42IqdlxMQXp+qfq+Hj72eGSAP0aHejCxZQCYHCAi0pBEIoG/sxX8na0wrY8PACBJUYyTMTm4kJSLS8l5uJqSj8LSCvXY72qmMinau1iho5sNOrlao6ObNTq62cDX0bLNJg2qew4YQy+JtirYo6qA4cujgrDpTCJ+PBGPuOxi/Hw2DT+fTcOgTi6YHe6LoUGurfJPXXUh0O0XUnEkKhPKcpX6PrlUgjAvO/Tyc0RPXwf09HWAs3Xzz4VtJpehnb0F2tlb1LuOSiUgvUB5KzlQjCRFCRIVxerfU/NKoCxXqQuZ1sXe0kTd48Dbsbr3QVUyoZ2DBczkrF3SVinLK3EzvRCRqfmITMvHtdQCXEvLh6K4vNa6FiYydGlnh24+9ujj54jeTAa0qP8KEjI50BSCUJUcPRGTjUM3M3E0KqtG+7Y1l2N0qAdm9PVBV2978QKlZsfkABFRE3g5WMKrpyUm9fQCUFVtOiqzEJeS8nA5OQ+XkvMQmVqAkvJKXEsrwLW0ghrby6QStLP/75tHH0dL+DpZqv+2s9DffyKrCxKy54D+s7M0wdyB7fHIXf44eCMD3xyKwtHYXBy6kYlDNzLh5WCBmeG+mNrLu9mLninLK7H/WgZ2XEzF3mvpNRIC7rbmGBJYNb76rgBn2OjJt+1SqQQedlV1B/r4O9a6v6xChdS8EiTkFFclEBTFSMgpRlJOMRIVJcgpKkNucTlyi6vOAXeSSKqeu6e9Bdxtq3pCqH/e+t3N1pwzTohIEARkFZYhJrMQsVlFiM0qQkxWkfrvur6YlkqAAFdrdPO2RzdvB3T1tkOgm02bTQC3RdWfRxXsOaCxSpWAxJxi3MwoxLXUfHVvyOyishrr2ZjJMTjQBfd1a4dBnZyZ4DRQBpccUKlUOH36NBQKBbp16wY3N7dm2aa51iEiwyaXSRHkbosgd1tM6eUNoOoiOjm3pKqwmrrAWtU3jiXllUjIqbqwqIudhQm8HKouIFxtzeFmawZXm6qfbrbmcLU1g5OVmShd+aq7bbIbYdshlUowuJMLujjLUAhz/HQqEb/+m4gkRQlW/H0Nn+y5gfFdPTG7n1+TikkJgoCLSXn45d8EbL+QisLbulb7OVni3q6eGB3qgWAPmzY5NtVULoWvkxV8nazqvL+wtAKJOVU9DRIVJbf9XpVMKCmvRGpe1TCGhjhbm8LN1vzW+7/qve5kbQpn69t+WpnC3tKU70MdKMsrq2pPKErUPxMVxVXJgMyiWkMCbudgaYJgj6pzfbCHDYI9bBHgas3ZbETGgoR1q05oJuaUIEnxX2+o6t5PpRWqWtuYyKpqKg3s6IJBHZ3RzdueiS4jYFDJgYyMDIwcORKZmZnw9fXFuXPn8OGHH2L+/PlN2qa51iEi4ySVSqq6Ezta4u7g/5KGKpWAzMJSJOQUIz67+Na3kMXqv7MKS5FXUo68knJcScmvd/8yqQQu1lUV1x0sTeFoZQoHS1M4WJrAweq2v61M4GhpChtzE5ibSJt8UaYeVsBrkjbJx9ESr44JxnPDO2H7hRRsOBaHq6n52HQmCZvOJKG7jz0e6ueH0V3cNf6GKF9Zjm3nkvHzqURcTf2vzbazt8C4MA/c29UTnT1t22RCQBvWZnIEe9gi2MO21n3V30gnKoqRlqesuuUra/1eVqlCVmEZsgrLGnz/A1XvQUcrUzhZmcHZpipZYGdh0vDN0gTWpnKDHBYkCAIKSyuQm1mIzMJyZBaWIuPWca0uRJmsKKn1zeidJBLAy8EC/s7WaO9shfYuVcPKAt1s4GLDgpT6SD2swMCTAxWVKmQXlqKwTIX8W/8n5BSVIauwFJkFt263fs8qLEV2URkaGmlhKpciwMUandysEeZlj24+9gjxsGWyywgZVHLgmWeegUwmw82bN2FhYYGff/4ZM2fOxNChQxESEqLzNs21DhHR7aRSCdxudR/u7Ve763JxWQUSc0qQnFuMjPxSpOeXIr1AiYx8ZdXv+UpkFZaiUiVUXVDkN/wt5O1MZBJYm8lhc2vOdxszk1tzwZvcmg9eDmtzOWRSKfJLylFcVgErMzkcrUzR3tkaQR42/w0rMMCLC2NiYSrDA729MaWXF84mKPDD8Xj8dSkV5xJycS7hPN7dYYrpfXwwo68PPOsYpy8IAs4mKPDTyUTsvJSiHjZgKpdidKg7pvX2QV9/R4O8CNWFRCJRT6NYH0EQoCguR2peibpQYlZBGbKLSpFdWKb+Zz+7sBSK4nKoBKgTCdfTNY9FKgFsLare81amcliZyWFpKlP/bmUmg6WpHNa3fgoAcourLjKszeXwtLdQX1C05DeKgiCguKwSiuKq4RqK4jIoisuRW1wGRVE5sotKq4pLFpYio0CJzILSGsNXGmJlKkM7h6oaFFU/LeHvbIUOLlbwdrTkxVEbI72VsKnUk5oDlSoBZRVVM6SUVaigLK9EcVklissqUFJWiZJbf5fcWlZcXv179fIKFCgrkK8sR35JBfJKypGvLEexDtO5msml8HKwuFU8tWr2FX9nK3Rys4GPoyU/ywkAIBEEPXn3NFFhYSEcHR2xdu1aPPzwwwCqPkx8fX0xa9YsLF26VKdtmmsdTeTn58POzg55eXmwta39bYM+UKlUyMnJgaOjI6RSdi0iw9PW2nhFpQrZRf9VXq/6p7kMOUXlUBSVIae4TP2z+p/q5jrre9qZIyVPCWdrU5x+/Z7m2Sm1OE3aeEaBEr+cSsT/Tsarq1JLJcDwYDfM6ueLuzo4I6+kHL+fS8YvpxJw87aifJ3crDGttw8m9mgHe8vmrV9AtZVXqqAoqkoMZBdVfUuYW1yu7nWUV1KOvDv/LimvsxuxrqxMZejl54jw9k64J8QNAa7WtdapVAkovHWRU3Dbz+ppJvNLylFQWvV39bnq9kRAmQ7xWpvJ4WprdqtnlTncbMzUiQBPewt4OVjAzsKEPQAMSEpuCfqv2AcA+PXxcCgrVJBJJKhQqVBaUXWrqFSholJAuarqZ4VKQEWlCuWVKpRVVl3Ml9+6mK/+WXb735UqlFcIKK1UofzWfbevX3rbdi3dgcHGTK5O8DlamcLFxgzO1mZ3/DSFq405nK1N2daNlDbXmAbTcyAyMhLl5eXo2rWreplEIkFYWBguXryo8zbNtU5dSktLUVr631Qg+flV3QZVKhVUqub70G5OKpUKgiDobXxETdXW2rhUArhYm8LF2hTwbHx9lUpA0a1vIgqUFep/xtV/3/Z7YWkFKlQCbMzlsDaTo6i0ApkFpbiZUYi47GKk3BovbWUqbzPHizRr485Wpnh6aAc8Mcgfe66mY+OJBJyMzcHuq+nYfTUdjpYmKCytQNmt+a3NTaQY28UD0/t4o7u3vfofULaLlieTVNUmcLY2BVD7orw+peWV6kRBYWkFisoqUVRageKyShTe+ll0+/LSSkBSNdZeAgnyleVIzCnGjYxCFCgrcPBG1ZSU7/9zDX5OlpBLJZDJqnoeFSjLUViq/TeddzKRSWBvaQoHi6ohU/aWJuqhVK63emO42JjB2coEJhXF8HB1bjTJKwgCDOR7MgIgxX+v5dSvT4gYSd3MTaSwNJHBwrSql46FqQyWJjKY3/ppYSqrsdzSVH6rV58cdhYmsLUwgbWpDEJpEbzcnGBqovmlHNu68dLms9hgkgN5eVXVgB0cHGosd3JyQkxMjM7bNNc6dVm+fDnefvvtWssVCgUqKuovgiMmlUqFgoICCILQJr5VJdKWsbRxcwDmpoCLKQAbObT9OMgtKce5pAJcTi1Ebx875OTkNL4R6QVt23h4OzOET+qI6KxibLmQgZ1XMpFza0qrQFdL3B/milHBTrA2kwMQoFAoWvgZUHORA3AyqboBUgDa9/RQCQKiMotxJrEAx2NzcSI+D3HZdRdYBQAzuQTWplVDFmzMZLA2k8HarGrogrVp1d825nLYW1Td7MxNYGchh52FHJYa1UoRoFIpUVBShJwcqUGfx6k2mSBgSIADorKKIUFVV3qgavibmVwKU5kUcpmkKnklrfpZ/buJTAJTmQRymRSmMglMpFKYyCUwkUpgKpdCLpXAVCaFiezWunIpTKQSmNxadvt9Jrf2Ib9tuVwqaYZv7iuhUpWjoLwY+Xkytm/SSEFBQeMr3WIwyQFT06oPtOLimh9IhYWFMDOre1yfJts01zp1eeWVV7Bo0SL13/n5+fD29oaDg4NeDyuQSCRwcHDgCYkMEtu4ZhwBtG/nhkliB0Ja07WNOzo6oncnLywZX4ELSXnwsDOHv3Pd1frJuDg7OSE8CJgPIC67CJGpBbCzMEGlSoCdxX91TGzMTVplekaex43bt484iR1Ci2L7Jm3J5Zpf8htMcqB9+/YAgMTERHTu3Fm9PDExsUZ3f223aa516mJmZlZn8kAq1e9Mt0Qi0fsYiZqCbZwMXVPauI2FKQZ0dGmBqMgQtHexQXsXG7HD4HmcDBrbN2lDm3ZiMC3Ky8sLoaGh2LJli3pZbGwsTp8+jdGjR6uXnThxAseOHdN4m+Zah4iIiIiIiEhfGUzPAQBYuXIlxo0bBxsbGwQHB2PVqlUYNGgQJkyYoF7nvffeg1KpREREhMbbNNc6RERERERERPrIYHoOAMDIkSNx9OhRlJSUYO/evXjkkUfwzz//1OhK0a9fP9x1111abdNc6xARERERERHpI4nAOS30hjZzUIqlrc0BT6QttnEydGzjZOjYxsmQsX2TtrS5xmSLIiIiIiIiIjJyTA4QERERERERGTmDKkjY1lWP8MjPzxc5kvqpVCoUFBRALpezKxMZJLZxMnRs42To2MbJkLF9k7aqry01qSbA5IAeKSgoAAB4e3uLHAkREREREREZioKCAtjZ2TW4DgsS6hGVSoWUlBTY2NhAIpGIHU6d8vPz4e3tjcTERL0tmkjUFGzjZOjYxsnQsY2TIWP7Jm0JgoCCggJ4eno22tuEPQf0iFQqhZeXl9hhaMTW1pYnJDJobONk6NjGydCxjZMhY/smbTTWY6AaB6oQERERERERGTkmB4iIiIiIiIiMHJMDpBUzMzO8+eabMDMzEzsUohbBNk6Gjm2cDB3bOBkytm9qSSxISERERERERGTk2HOAiIiIiIiIyMgxOUBERERERERk5JgcICIiIiIiIjJyTA4QERERERERGTkmB4iIiIiIiIiMHJMDREREREREREaOyQEiIiIiIiIiI8fkABEREREREZGRY3KAiIiIiIiIyMgxOUBERERERERk5JgcICIiIiIiIjJyTA4QERERERERGTm52AHQf1QqFVJSUmBjYwOJRCJ2OERERERERNSGCYKAgoICeHp6QiptuG8AkwN6JCUlBd7e3mKHQURERERERAYkMTERXl5eDa7D5IAesbGxAVD1wtna2oocTd1UKhUUCgUcHBwazTwRtUVs42To2MbJ0LGNkyFj+yZt5efnw9vbW32t2RAmB/RI9VACW1tbvU4OVFRUwNbWlickMkhs42To2MbJ0LGNkyFj+yZdaTJsnS2KiIiIiIiIyMgxOUBERERERERk5JgcICIiIiIiIjJyTA4QERERERERGTkmB4iIiIiIiIiMHJMDREREREREREaOUxkSERERASirUOF4TDZOx+XgQlIekhTFyMgvRXmlCgIAuVQCJ2tTuNqYw9PeAoFu1ujkZoMgd1t4OVhAKm18migiIiJ9xeQAERERGbX47CKsOxyDP8+nIF9ZUe96ZQCKc0qQmFOCM/EKbL/tPjsLE/TwsUdPXwf08HFAV297WJnx3ywiImo7+KlFRERERimnqAzL/4rElrNJUAlVy1xszDC4kwu6edujvYsV3G3NYSqXQiKRoLxChazCUmQUlCIhpxjX0wpwLa0A0RmFyCspx/7rmdh/PRMAIJUAwR626OXrgLsCnNGvgxNszE1EfLZEREQNY3KAiIiIjM5fl1Lx2h+XoCguBwAMCXTBYwPbI7y9E2QNDA/wc7aqtaysQoXI1HyciVfgbIICZ+MVSMlT4kpKPq6k5OP74/GQSyXo4eOAIUEuGB3qAf869kNERCQmJgeIiIjIaFSqBHy46zq+OhgNAAhyt8HS+7ugp6+Dzvs0lUvR1dseXb3t8Qj8AQCpeSU4G5+L4zFZOHIzC3HZxTgVl4NTcTn44J/rCHK3wZguHhjTxR0BrjbN8tyIiIiagskBIiIiMgrllSos/OU8dl5KBQA8Pqg9XhgZCBNZ80/e5GFngbFhFhgb5gEASMguxsGbmdh9JQ3HorNx7daQhI/33ECIhy0m9miH+7q1g4uNWbPHQkREpAkmB4iIiMjglVeq8OzP5/D35TSYyCRYOeX/7N13fFRV+sfxz8yk9wohhU5C772LoNgREddell27q26xi6z6A3fX1bX3CnbFhqKiIii99xJCSYOQ3svM3N8fQwYiLYEkU/J9v168krn3zp1n4HBm7nPPeU4fLuqb0Gyv3zY6iKuj23H10HYUlFXzw9YDfLsxm19Tc9mSXcyWecXM/HYbY5NjuWRAImd2a4W/j6XZ4hMREVFyQERERLyaYRg8/MUmvt20Hz+LmZeu7s+4rq1dFk9ksB9TByYxdWASBWXVfL0hi0/WZLI+vZAft+Xw47YcwgN9Ob93Gy4ZkEi/pAhMJi2TKCIiTavxx9F5oZycHO69916GDBlCv379uOGGG9i+fftRx73xxhsMHz6cbt26cc0115CRkeGCaEVERORIr/+6m/dXpGM2wfNXujYx8HuRwX5cPaw9X9w6ggV3j+bmsZ2ICwugqKKGOcv3MfmFJZz53194YWEq+4sqXR2uiIh4MSUH6mHatGnExcXx4osv8vLLL1NWVsbIkSM5ePCg85hXXnmFW2+9lZtuuol33nmH3Nxcxo4dS0VFhQsjFxERadmW7srj/77ZCsD953ZjQnf3SQz8XudWodwzsSu/3TuO2X8cwsX9EgjwNZN2sIx/zd/OsFk/cvXry/liXSYV1TZXhysiIl7GZBiG4eog3J3NZsNiOTzv78CBA8TFxTFv3jzOPfdcDMOgbdu2XH311fzf//0fAIWFhbRu3Zrnn3+eadOm1et1iouLCQ8Pp6ioiLCwsCZ5L6fLbreTn59PVFQUZrNyS+J91MbF27WkNl5UXsPE/y0iu6iSKQMS+feU3h43PL+ksoZvN+7nk9UZrNiT79we6u/D+X3acEn/RAa0i/S499WUWlIbl5ZH7VsaqiHXmKo5UA9HJgYMw+Cjjz4iNDSUfv36AZCamkpGRgZnn32287iIiAiGDh3KwoUL650cEBERkcbzwOcbyS6qpH10EDMu7OGRF9ChAb5MHZTE1EFJ7M0r49M1mXy2JoOMggreX5HO+yvS6RATzOR+CUwekEhCRKCrQxYREQ+l5EA9ffLJJ/ztb3+joKCAoKAgfvjhB9q0cSxPVFtbIC4urs5z4uLiyMzMPO45q6qqqKqqcj4uLi4GHBlBu93e2G+hUdjtdgzDcNv4RE6X2rh4u5bSxhdsPcDXG7KxmE08NbUPgb5mj3/PSZGB3HlmZ+44oxMr9uTz6ZpMvt20n925ZTz5ww7+u2AHwzpGM6lvPGd1b01YoK+rQ3aJltLGpWVS+5aGakhbUXKgniZOnMjAgQPZv38///3vf5kyZQorVqygTZs2zr9wH5+6f52+vr7YbMefEzhz5kxmzJhx1PaCggKsVmvjvoFGYrfbKSkpwTAMDWUSr6Q2Lt6uJbTxyhob07/YBMCVA+JICnYMw/UmyREm7huXyF9GtuGnHfl8tfkgq9NLWLIrjyW78rh/7iaGtQ9nfEoUYzpHEuLfcr7ytYQ2Li2X2rc0VElJSb2PVc2BU2C1WklISOD222/nwQcfZP369fTt25fly5czePBg53ETJ04kODiYTz/99JjnOdbIgaSkJAoKCty65kBBQQGRkZHqkMQrqY2Lt2sJbfw/3+/ghYW7aBMewA93jSLIr2VcGGcUlDN3bRbzNmSzI6fUud3PYmJ0cizn9orjzK6tCA3w7hEFLaGNS8ul9i0NVVxcTGRkpGoONBUfHx8CAgIoLy8HoFu3boSEhLBkyRJncqCmpoYVK1bwj3/847jn8ff3x9/f/6jtZrPZrf+zm0wmt49R5HSojYu38+Y2nllYwWuLdwMw/YIehAT4uTii5tM2OoS/jE/mL+OT2XGghHkbsvl6Qxa7DpaxYGsOC7bm4OdjZljHaM7s1opxXVuRGBnk6rCbhDe3cRG1b2mIhrQTJQdOIj09nbfeeos77riD8PBwqqurefLJJ8nIyGDSpEkA+Pn5MW3aNJ566ikuvvhikpKSePzxx6muruaaa65x7RsQERFpQf63YAfVNjtDO0Zxdg/3XbawqSW3DiV5Qih3ju/CjgOlzNuQxdcbsknLLeOXHQf5ZcdBHv5iM13jQhnXtRVndmtN36QILGbPK9ooIiKNQ8mBk4iLi8PHx4eUlBQMw6CoqIhu3brxxRdf1JlCMHPmTPLy8ujSpQsBAQFERkYyd+5c4uPjXRi9iIhIy5GaU8Inqx1Fgv8xsatHrk7Q2EwmEylxoaTEpXDXhGR2HSxlwdYcftqaw6q9+WzbX8K2/SW8sHAXYQE+DO0YzfBO0QzvHEOXViH6OxQRaUFUc6ABDh48SHh4OH5+xx+iWFZWRklJCa1bt27wB2pD1qB0Fa2tKt5ObVy8nTe38VvnrGHexmzO6t6aV64Z6Opw3F5BWTW/7DjIj9tyWLg9h5LKusWQY0L8GNoxmv5tI+naJpQurUKJDT16OqS78eY2LqL2LQ3VkGtMjRxogNjY2JMeExwcTHBwcDNEIyLievll1QT7W/D3sbg6FGnhdh0s5ZtN2QD89awUF0fjGSKD/ZjUL4FJ/RKw2uxsyipmya5clu7KY+WefHJLq/l6QzZfb3D8vfpZzDxwXjeuHd7+qHPNWb6XZ39M5Y3rBtE93j1vcIiIyIkpOSAiIqckNaeUs59exLCO0cyeNsTV4UgL98ovaRgGjO/WmpS4UFeH43F8LGb6JkXQNymCW8Z2pspqY92+QpbvzmddeiFbsorZX1zJ9C83ExHky0V9E5zPPVBcyQNzHUtHfrk+S8kBEREPpeSAiIgcV05xJVuyixnQLvKo5c8em7cFm93g19RcF0Un4rC/qJLP1jpqDdw8tpOLo/EO/j4WhnSMZkjHaAAMw2DWt9t4eVEaf/94A5U1Ns7vHc+ytDwe/2ar83kxIS1ndQgREW+j5ICIiBzFarPz3M+pPPPjTuwGhAb4cM2wdtwwogPRIf5s21/Mwu0HXR2mCABv/rabGpvB4A5RDGgX6epwvJLJZOIfE7uSUVDBvI3Z3PPpRu75dKOrwxIRkUak5ICIiDjtzi3ji3WZfLomg/T8CgB8LSZKKq08//MuXl20m9bh/s59AOGBvsc7nUiTq6i28cHKdABuHN3RxdF4N4vZxDOX96Nbm1De+G0P+WXVRAb5cunAJFJzSvlpWw521bkWEfFYSg6IiLRwOSWVfLU+my/XZbI+o8i5PSrYjwfO7cbF/RL4fssBnv85lY2ZRaTnV2A2QcfYEFJzSrUuurjUl+szKaqoISkqkLEprVwdjtezmE3cNq4Lt57RmaKKGsICfDGbTfz1o/UAKDcgIuK5lBwQEWmBKmtsLNh6gE9WZ7Box0Hsh77QW8wmRnaO4aK+8UzsGUeQn+NjYmLPOM7u0Zo9eeUcKK6kY2wwxRU1jP/vIrQirriKYRi8vWQvAFcPbadEVTMymUxEBPkd8djx067uQETEYyk5ICLSQhiGwdr0Qj5dncFX67MoPmJN875JEVzcL4Fze7U57jrmJpOJDjHBdIhxLNdaXOF4vi4GxFXW7CtgS3Yx/j5mpg5McnU4LVptXsZAHYKIiKdSckBExMtVVNv4Yl0mby/dy9bsYuf2+PAALu6fwOT+iXSKDWnweWvvFGrkgLjK+ysctQYu6BNf5y62ND8Tjg5B3YGIiOdSckBExEul55fz7rK9fLgynaKKGgD8fcyc26sNUwYkMqxjNObTGIZtPpQd0LWAuEJplZV5G7IBuHywRg24mtns+KlkoYiI51JyQETEy+w8UMLzP6fy5fos55D/xMhArhnWjqkDkxrtDmttWkHXAuIK32zIpqLGRsfYYPq31fKFrufoETTNSETEcyk5ICLiJTZnFfHsj6nM37zfuW1E52iuG96BcV1bNXqxNk0rEFf6eLVjSsGUAYmYTCpE6GrOmgPqDkREPJaSAyIiHi49v5wnv9/O5+uynNsm9ojjljM60Tsxoslet3Zage4USnPbnVvGyj0FmE1wSf9EV4cjHLlagToEERFPpeSAiIiHKiir5pmfdjJ72V5qbI4v5Bf0ieeOcZ3p0jq02eJQdXJpbl+sywRgVJdYWocFuDgaAdUgERHxBkoOiIh4GLvd4OPV6cz6dhsF5Y5Cg6O6xHDPxK70TAhvtjhqixnqRqE0J8Mw+Gq9Y5TMhX3iXRyN1Dpcg0QdgoiIp1JyQETEg2zOKuKhzzexZl8hAMmtQ3jo/O6M6hLb7LGoIKG4wrb9Jew6WIafj5kJPVq7Ohw5pLbug/oDERHPpeSAiIgHqLbaee6nnTy/cBc2u0Gwn4U7xydz3Yj2+FrMLonJWZBQA4mlGdWOGhibHEtYgK+Lo5FaqjkgIuL5lBwQEXFz2/eXcPdH69icVQzAub3iePj8HsSFu3autVl3CqWZGYbB1xuyAUd9DXEfqjkgIuL5lBwQEXFThmHw+q+7+df87VTb7EQE+fLYpJ6c39s9LopqpxXoTqE0lw0ZRezLLyfQ18KZ3Vq5Ohw5gvoDERHPp+SAiIgbKqqo4e8fr+f7LQcAGNe1FbMm96KVO1Vmd04rEGkeX29wTCk4s1srgvz0Fcad1BYoVYcgIuK59MkqIuJmNmcVccucNezNK8fPYubhC7pz5ZC2zoJf7kLTCqQ52e0G8zSlwG1p5ICIiOdzi+SA1WrFarU2+Hm+vr5YLJYmiEhExDU+X5vJPZ9uoMpqJyEikBev6k/vxAhXh3VMR6YqDMNwu+SFeJcNmUVkFVUS4u/DmOTmX51DTkyrFYiIeD7XlLj+nZtuuonAwMAG/3nzzTddHbqISKMwDIP/LdjJnR+uo8pqZ1zXVsy7Y6TbJgbg8MgB0AWBNL0ftuwHYExKLAG+ujHgbg6vVuDaOERE5NS5xciBJ554ggcffLDBz4uJiWmCaEREmle11c59n23k0zUZANw4piP3nN318BxeN3XkQAG7YWDGveMVz/bDofobE7q1dnEkcixmLW0qIuLx3CI5EB0dTXR0tKvDEBFpdiWVNdz47mqW7MrDYjbx6EU9uWJIW1eHVS+mI5IBuhyQprQ3r4wdB0qxmE2ckaJVCtxRbX+gUUQiIp7LLaYV/N7KlSs5ePAgAMXFxfztb3/jhhtuYNOmTS6OTESk8RSV13DV6ytYsiuPYD8Lr1870GMSAwCmIz5BdEEgTal21MCQDlGEB/m6OBo5FufIAXUGIiIey+2SA9u3b+emm24iPDwcgHvuuYcvv/ySnJwcJkyYQGVlpYsjFBE5ffll1Vzx2jLWpxcSGeTLhzcOY6yH3RE9chKBKpRLU3JOKeiuKQVu69A8I9UcEBHxXG6XHPj444+56KKL8PPzw26389FHHzF37ly+/vprOnbsyKJFi1wdoojIaTlYUsUVry5jc1YxMSF+vP/nofRMCHd1WA2m1QmkORSUVbNyTz4A41VvwG2p5oCIiOdzi5oDR8rNzaVdu3YAbNiwgeDgYHr06AFAu3btyMvLO+k5nnnmGZ555plj7jObzURGRjJixAjuueceWrfWFw0RaT75ZdVc8eoyduaU0irUn/f+NITOrUJdHdYpMf+uIKFIU/hpWw52A7rGhZIUFeTqcOQ4amsOaOSAiIjncruRAz179uTdd99l/fr1PPHEE0ycONG5b9OmTfTs2fOk5xg5ciT+/v6YzWYuv/xy7rrrLi6//HJMJhM+Pj5ceOGFLFiwgPHjx1NdXd2Ub0dExKm0ysp1b65gZ04pcWEBfHjjMI9NDMDvChLqgkCaSO2UgrM0pcCtHa454No4RETk1LndyIErr7ySjz/+mL59+9K+fXt+/vlnAH766SdatWpFr169TnqOqqoqfHx8WL16NQEBAc7t999/P0OGDGHcuHH8/e9/p0+fPnzzzTdMmjSpqd6OiAgAlTU2/vT2KjZkFBEV7MfsaUPoEBPs6rBOy5GzCnQ9IE2h2mpn8U5HgeLxSg64NZMKEoqIeDy3Sw4EBgby3XffUVZWRlBQkHNOa+/evfn000/rdY7ly5czfvz4OomB2nOPHz+eFStWMGzYMCZOnEhqamqjvwcRkSPZ7QZ3fbiOpWl5hPj78Pb1g+ncKsTVYZ02k6YVSBNbvbeAsmob0cF+9Iz3vLocLUnt9zV1BSIinsvtphWAYynD8vJyTCaTcynDf/zjH6Snp9fr+QEBASxatIiampo622tqali0aJEzaZCTk0P79u0bO3wRkTqe+G4b327aj5/FzCvXDKBXondc5GhagTS1RYdGDYxOjsVsVgFMd1abLFSiUETEc7ldcqAxljKcOnUq2dnZDB06lP/+97/MmTOH//73vwwZMoQDBw5w6aWXsnv3bjZt2sS5557b1G9JRFqwD1bs4+Vf0gD415TeDO8U4+KIGk+dazVdD0gT+GW7IzkwJjnWxZHIyZhrRw64OA4RETl1bpccaIylDKOioli5ciXDhg3jxRdf5MYbb+TFF19k+PDhrFixgqioKBITE1m5ciVBQap8LCJNY8muXB78fBMAfzmzC5P6Jbg4osZ15FKGulsojS2nuJIt2cWYTDCqi/ck1bxVbW+gvkBExHO5Xc2BxljKEKBNmzY899xzx93v6+t7+sGKiBxHZmEFt723Fqvd4KK+8dw5vourQ2p0GjggTWnRzlwAeiWEEx3i7+Jo5GTMzoqEro1DREROnduNHGiMpQxFRFypssbGLbNXk19WTc+EMJ64pHedu+zeQgUJpSn9skNTCjyJag6IiHg+t0sOXHnllcTGxtK3b1+WLVvG/fffDzRsKUOA2bNnM3DgQGJjY4mIiKjzZ9asWU35FkSkhZvx1WbWZxQREeTLi1cOIMDX4uqQmsSRCQ9dD0hjstkN5xKGSg54BpNqDoiIeDy3m1bQWEsZ/vGPf+Tuu++mT58++PjUfZvdu3dv9LhFRAA+W5PB+yvSMZngf3/oR1KUd9c1MZvAboChSwJpRBsyCiksryE0wIe+SRGuDkfq4XDNAZeGISIip8HtkgO1goOD6zyOial/MaJff/2Va665hpkzZzZ2WCIix7Unt4yHjihA2BLueJpMJjAMjRyQRrVoh6PewMjOMfhY3G6QoxxD7eolhjoDERGP5ZafuKtXr2bChAnExsby1ltvAfDtt9/y5ptv1uv5sbGx+PureJGINJ9qq52/fLCWsmobgztEcfs47ytAeCy1dwt1PSCN6ZcdOYCmFHgS57QC9QUiIh7L7ZID6enpjB8/nr59+9K7d2+sVisAI0eO5NFHH6WoqOik55g4cSI//vgj27Zta+pwRUQA+O8PO1ifUUR4oC9PX9YXi9n7ChAey+G1zXVFII2jsLyademFAIxWcsBjOEcOqC8QEfFYbpccmDNnDpdddhn//ve/6dixo3N7aGgoKSkpLFy48KTn+PLLLykoKKBXr1707NmToUOH1vnz2muvNeE7EJGWZsXufF5etAuAJy7pRXxEoIsjakbOCuWuDUO8x6+pudgNSG4d0rL+L3m6Q4lCu93FcYiIyClzu5oD6enp9OjRA+Copb8CAwMpKSk56TmSk5O57bbbTrhfRKQxlFdb+fsn6zEMmDowkYk927g6pGZ1eFqBsgPSOBYfqjcwuotGDXgSZ1+gkQMiIh7L7ZIDHTp0YNWqVUDd5EBOTg6//PILDzzwwEnPMXr0aEaPHt1kMYqI1PrX/O3szSunTXgAD57f8lZCMWuesTSyJWmO5MCILvUvRCyuV9sXaBSRiIjncrtpBddeey3fffcd9957L5mZmezatYvXXnuNESNG0Lt3bwYMGODqEEVEAFiWlsdbS/YAMOuS3oQF+Lo2IBcwOSuUuzYO8Q7p+eWk51fgYzYxqH2Uq8ORBlBfICLi+dxu5EBsbCw//vgjt956K4sWLWLevHn4+voyefJkXnjhheM+74UXXuCFF17glltucT4+nltuucV5nIjIqaissXHvpxsAuHxwUoutqq6ChNKYluxyjBrokxRBiL/bfUWRE9BShiIins/tPnn3799PYmIiCxcupKSkhPz8fFq1akVg4ImLEvXv359p06bRv39/AKZNm3bCY0VETscLP6eyJ6+c1mH+3H9uN1eH4zK1k780lFgaw5JdeQCM6BTt4kikoUzUJgpFRMRTuV1yYPr06QwaNIhp06YRGhpKaGhovZ5XuxLBkY9FRJpCak4pL/7iWJ3gkQt6ENoCpxM46W6hNBLDMJzJgWGdVG/A05jUF4iIeDy3qzmQmJjI3r17XR2GiMgxGYbBg59vpMZmMK5rKyb2jHN1SC6lImTSWHYdLOVgSRX+Pmb6tY1wdTjSQCb1BSIiHs/tRg5MmzaN0aNHM2LECMaPH4+PT/1CfOaZZ3jmmWfqdewdd9zBHXfccTphikgLNXdtJsvS8gnwNTPjwh5HLbna0hx++7oikNNTO2pgYPtIAnwtLo5GGspZc8C1YYiIyGlwu+TAzJkz2bt3L+eccw4Wi4WQkJA6+5999lmuvvrqo543cuRIgoKCnI+feuopKisrufzyy2nTpg3Z2dm8//77BAQEMHLkyAbFVFZWxuzZs1m5ciVBQUGMHz+eCy+88Kjj1qxZw1tvvUVBQQGDBg3ixhtvxN/fv0GvJSLuq6zKysxvtwFwx5ldSIoKOskzvJ+WMpTGsiTVkRwYrikFHknTCkREPJ/bJQeuvfZaRo8efdz9AwcOPOb2/v37OwsNLl26FLPZzMaNG+skDO6//36GDBlCVVVVvePJy8tj4MCBTJw4kaFDh5Kbm8sNN9zAJZdcwssvv+w8bsGCBZx77rncdNNNDB8+nGeeeYYvvviCBQsWtPg7iyLe4sWFuzhYUkW76CD+OLKDq8NxCypIKI3BZjdYmlabHFAxQk+kRKGIiOdzu+RAamoq7dq1O2ZBwQ8//JD9+/fTvn37E55j+fLlTJgwoU5iACAoKIgJEyawYsUKhg0bVq94goODWbVqFdHRh7+spKSkMHnyZB566CESExMB+Otf/8rVV1/tnNpw9tln07lzZ7744gsmTZpUr9cSEfeVnl/OK4vTALj/3G74+2jYMxxxt1CDieU0bM0upqiihhB/H3olhLs6HDkNdmUHREQ8ltsVJPzhhx/YtGnTMfd9//33bNmy5aTnCAwMZNGiRdTU1NTZXlNTw6JFi066LOKRAgIC6iQGAGdCoKCgAIDMzEw2bNjAlClTnMd07NiRAQMG8M0339T7tUTEfc2av41qq53hnaI5q3trV4fjNky6WyiNYMmuXACGdIjCx+J2X02kHjRyQETE87ndyIHjKS8vZ/PmzfW6Cz916lQef/xxhgwZwpVXXklcXBz79+9nzpw55OfnM3Xq1NOK5dlnnyUpKYlu3Rxrm6elOe4mtm3bts5xbdu2de47lqqqqjpTHIqLiwGw2+3Y7fbTirGp2O12DMNw2/hETtex2vjKPfnM25CN2QQPnNsVwzA0r/aQ2mkFNpv79ltSlzv2478dqjcwtGOUW8UlDXCoT7S7QdtyxzYu0ljUvqWhGtJW3CY5cPPNN/Pmm29itVp5++23ue222+rsr6qqokOHDpxxxhknPVdkZCQrV67k8ccf5+WXXyY7O5s2bdpwzjnn8MADDxAREXHKcT733HN88MEHfPfdd86VFGov8H8/jSEkJIQDBw4c91wzZ85kxowZR20vKCjAarWecoxNyW63U1JSgmEYmM26uyPe5/dt3G4YPPLFZgAu6tWK1v5W8vPzXRyl+zAMxwdOYVER+QHu2W9JXe7Wj1ttdlbsdiQHesT46P+XhyorKwUcozRd/W/obm1cpDGpfUtDlZSU1PtYt0oOnHfeeTz77LOkpKRw1llnOfeZTCaioqLo168fAQEB9Tpf69at6720YX29/vrr/PWvf+X999+vk6QID3fMjywoKKBDh8NFyvLy8k6YiLjvvvu4++67nY+Li4tJSkoiMjKSsLCwRo29sdjtdkwmE5GRkeqQxCv9vo1/vjaTrQfKCPH34b7zexIVohVIjuRjsQA1hIaFERWlueKewN368VV7C6iosRMV5Mvg5ETMZhXx9UShodUAmC0+REVFuTQWd2vjIo1J7VsaqvaGdr2ObcI4GqR379707t2b7t27ExoaSmxsrKtDquPNN9/klltuYfbs2VxyySV19nXr1g1fX182bNjgXDEBYOPGjVx55ZXHPae/v/8xlzo0m81u/Z/dZDK5fYwip6O2jVvt8PSPqQDcPLYTrcLqX6+kpai9jKv9OxPP4E79+LI0x13mYZ1i8FGhT49lOaItuUO7cqc2LtLY1L6lIRrSTtwmOVCrY8eOdR4vXryYJUuWkJyczKRJk+q9LKDdbueLL75gw4YNzsKBtSZOnMjEiRPrHdPbb7/NTTfdxOzZs7n00kuP2h8SEsJFF13ECy+8wB/+8AcCAgL46KOPyMjI4Iorrqj364iIe/lwVTr78suJCfHn+hHtXR2OW1JBQjldtcUIh2kJQ49W+/VMqxWIiHgut0oOjBs3jpdeeonk5GQAXnvtNf70pz/h7+9PVVUVN954Iy+99NJJz2O325kwYQLbtm0jMDAQs9lMSEgI69atIz4+nsGDB9c7pt27d3PDDTeQkJDAhx9+yIcffujcd9999zFgwADAUaRwwoQJpKSk0L59e1auXMmTTz5Jz549G/i3ICLuoKLaxrM/7gTg9nGdCfJzq+7SbeiCQE5HZY2NNXsLARiu5IBHc65W4OI4RETk1LnNt93vv/+eoKAgZ2LAMAweeughbr75Zp577jlWrlzJ2LFjuf/++49aFeD3vvnmGzIzM9mxYwf//ve/AXjkkUdYtmwZ559/PiNHjqx3XNHR0XUSAkdKSEhw/h4XF8e6detYtmwZBQUF9OvXr85+EfEs7yzbS05JFYmRgVw++MR9TktWmxzQBYGcitV7C6i22YkLC6BDTLCrw5HTUDuu067OQETEY7lNcmDx4sWMGjXK+XjTpk3s37+f+++/H7PZzJAhQxgzZgwbN248aXJgy5YtnH/++QQHB+Pj40NpqaOC7tChQ5k8eTLz5s3j5ptvrldcYWFhTJkypV7HWiwWRowYUa9jRcR9lVZZeekXxzKkd45Pxs9Hc/qOR2uby+monVIwvFN0vacNintyTmlVZyAi4rHc5htvWVkZFsvhQkTLly8nKSmJxMRE57bo6GiKi4tPeq7y8nJCQkIAxx39Xbt2OfcdmSwQETmWd1dmU1RRQ+dWIVzcTyOATqT2cs7QBYGcgt9SHUsYDu8c4+JI5HSZDvUGGjkgIuK53CY5kJKSwty5c7FaHetkf/zxx4wbN67OMbt27aJz584NOu9ZZ53FN998w6OPPsq///1v3n77bYYOHdpocYuIdyksr+b91fsB+NtZyVi0rNoJmTTPWE5RcWUNGzIKARUj9AaHpxipNxAR8VRuM63giiuuYMaMGaSkpBASEsLGjRtZunSpc396ejp5eXl1lgo8niOnAbRt25a3336bWbNmUVFRwf/93//Vmb4gInKkd5fto7zGTrc2oZzdI87V4bg9Z0FC3S6UBlq5Ox+7Ae2jg0iI0DKhnq42UWi3uzgQERE5ZW6THAgNDWXFihU899xz5Obm8p///IchQ4Y492/cuJGZM2fWmXpwPL9fIWDKlCn1rhsgIi1XebWVt5bsAeCm0R01B7oenNMKXBqFeKIluxxTCoZ10pQCb2BWcVIREY/nNskBgMTERO68804CAwMJDw+vs+/cc8895fNarVZ8fNzqrYqIG/poZToF5TUkhPtzTk+NGqgPFSSUU1WbHNASht6htuaA6o+IiHgut6k5UGv69Ol8/PHHp32ezMxMrr/+euLi4vD19SUuLo7rr7+ezMzMRohSRLxNjc3Oq4t3A3D1oDb4WNyue3RLznnGuiCQBsgvq2ZrtqPAsOoNeAfnyAF1BSIiHsvtbqcnJiayd+/e0zpHaWkpI0aMICYmhocffpj4+Hiys7N5/fXXGTFiBJs2bXKuZiAiAvDV+iwyCyuIDvbj/B6xrg7HYzjvFro4DvEsSw+NGugaF0pMiL+Lo5FGUVt/RNkBERGP5XbJgWnTpjF69GhGjBjB+PHjT2k6wGeffUZMTAxLly7F19e3zrmHDRvGZ599xjXXXNOYYYuIB7PbDV76xbHk6fUj2hPgq1ED9WXS3UI5BUt25QIaNeBNzFq5RETE47ndN+CZM2eyd+9ezjnnHAICAoiIiKjz59133z3pOTIyMhgzZkydxACAr68vo0ePJiMjo6nCFxEP9PP2HHYcKCXE34erhrR1dTgexVmhXNkBaYClznoDKkboLWqLk6ovEBHxXG43cuDaa69l9OjRx90/cODAk56jffv2fPTRR1RVVeHvf3i4YmVlJQsWLODee+9tlFhFxDu8uNAxauDKoW0JC/Qlv8LFAXkQrVYgDZVdVEFabhlmEwzuEOXqcKSRmLVcgYiIx3O75MCAAQMYMGDAaZ3j4osvZsaMGQwYMICrrrqKNm3akJ2dzbvvvovNZmPy5MmNFK2IeLqVe/JZtbcAP4uZP47o4OpwPI750Pgz3S2U+qodNdArIZzwQN+THC2eQiMHREQ8n9slBxpDYGAgS5Ys4dFHH+XNN98kKyuL+Ph4zjnnHB566CECAgJcHaKIuInaUQOXDEikVVgAdrvdxRF5ltqChLpbKPXlXMKws6YUeBOTag6IiHg8t0wOHDhwgOeff56tW7dSUlJSZ99dd93F2WeffdJzREdH8/TTT/P00083UZQi4um2Zhfz07YczCa4cXRHV4fjkQ6PJNYlgZycYRgsST1UjLCjihF6E5NWKxAR8XhuV5AwLy+P3r17s3TpUrZt24bNZiMkJISFCxeSnZ1NZGSkq0MUES/x8qEVCs7p1Yb2McEujsZD1RYk1IALqYc9eeVkFVXiZzEzqL3qDXgT52oFyg2IiHgstxs58PbbbzNy5Eg+/fRTpk2bxtChQ5k2bRqbNm3ijDPOoF27dsd83gsvvMALL7xQr9e45ZZbuOWWWxozbBGph/JqKyv3FLA3rwyTyUSn2GAGtovCz6f585Tp+eV8tSEbgJvHdGr21/cWKkgoDVG7hGG/thEE+llcHI00JmdfoM5ARMRjuV1yYNeuXZxxxhkA+Pv7U1ZWBkDPnj0ZNWoUixcvZsqUKUc9r3///kybNq1er9G/f//GC1hETqqwvJoXF+7inaV7qaix1dkXEeTLn0Z15E+jOjZrkuDVxWnY7AajusTQMyG82V7X2zinFeiKQOphSaqWMPRWh0cOqC8QEfFUbpccqKqqchYMTEhIYNOmTc59hYWFxy0WNnToUIYOHdosMYpI/X2zMZt7P91AcaUVgISIQHomhGGzw7r0QnJLq/j3d9uZtyGbV68dSEJEYJPHlFtaxYcr0wG4eaxGDZyO2iJkdl0PyEnY7QZL0xzJgRGdVW/A2xyuOeDaOERE5NS5XXLgSFOmTKFXr16YTCaKi4tZsWIFs2fPdnVYIlIPdrvBrPnbeGVRGgBd40K5Z2JXxqbEOi8obXaDL9Zl8ti8rWzJLmbyC7/x8Y3DaRsd1KSxvfXbHqqsdvokhqso2mkyOX/TFYGc2Lb9JeSXVRPkZ6FPUoSrw5FGZlJxUhERj+d2BQmnT5/O5MmTAUhOTmbevHkUFxdjGAbff/898fHxLo5QRE7GZjf4+ycbnImBP4/uyNe3j+SMrq2ciQEAi9nE5P6JfHX7SLq0CuFAcRXXvrmCksqaJoutpLKGd5buARyjBo6MRxrOrJEDUk+19QYGd4jC1+J2Xz/kNNUua6q+QETEc7ndyIGkpKQ6j8ePH8/48eNdFI2INJTNbnD3R+v4Yl0WFrOJJy/tw6R+CSd8TkJEIHOmDWHS87+xO7eMh7/YzFOX9W2S+N5fsY/iSisdY4M5q3tck7xGi+KsOeDaMMT9Ldl1aEqB6g14JfOhfI/6AhERz+W2qfuCggJ+++03MjIyXB2KiNSTYRg8+vUWvliXhY/ZxHOX9ztpYqBWq7AAnr2iP2YTzF2b6bzL2JiqrDZeW7wbgJtGd8Js1qiB02XWUGKphxqbneWH6g0M66SpPN6oduSAChKKiHgut0wOPPHEE8TFxTFy5Ejmz58PwMcff8zVV19d73PMmzePbdu2AY5Ew2WXXcbgwYNVs0CkCb2yKI23luwB4L+X9eWcXm0a9PwB7SK5cohjudL/+2Zro3/JnLsmk5ySKuLCArion6YoNQYNJZb62JBRSFm1jcggX7q3CXN1ONIEDicKRUTEU7ldcmDRokU89dRT/PTTT1x//fXO7VOmTGH58uXs2rXrpOdIS0vj3nvvpUOHDgA89thj7Ny5k7PPPpubbrqpXucQkYb5adsBZs13JOQePK8bF/Y5tYvvuyYkE+hrYVNmMYt2Nt7oAZvd4OVDNRCmjeqAv4/WWG8MJi1lKPVQu4ThsE7RGrHjpQ6vVqC+QETEU7ldcuC7777j1ltvZcSIEVgsh7+8m0wm+vTpw/Lly096ju+//56xY8fi7+8PwNy5c3n++ed59NFHueyyy/jhhx+aLH6RlijtYCl/eX8dhgFXDGnLtFEdT/lcUcF+XD64LQCv/7q7sULku8372Z1bRnigL384dH45fWYVdJR6+O3QNKFhqjfgtWqLuyo3ICLiudwuOVBSUkJQkGMZs99XES8oKMDX1/ek5ygvL3fexdqzZw95eXkMGTIEgIiICMrLyxs5apGWq6Syhj+/u5qSKisD20XyyAU9Tvuc1w1vD8DinQfJKqw47fMZhsGLCx0jhq4d1o4Qf7erxeqxdLdQTqayxsaavYUAjFC9Aa9V+41NfYGIiOdyu+TA0KFD+eSTT6ipqamTHPjxxx9ZvHgxw4cPr9c5PvjgA2bPns1f//pXzj33XMyHyuiuWrWKQYMGNVn8Ii2JYRjc8+kGUnNKiQsL4IWr+uPnc/rdStvoIIZ0iMIw4LM1p1+UdMmuPDZmFhHga+baQ4kHaVy6HpDjWbWngGqbnTbhAXSICXZ1ONJEnKOI1BeIiHgst0sOTJ06FX9/f/r3789vv/3GJ598wvnnn89ZZ53F3/72NxISTl75fPjw4dxxxx08+OCDHDhwgFmzZgGwZMkSTCYTo0aNauq3IdIizFm+j2827sfXYuLFq/rTKjSg0c59Sf9EAL7ZuP+0z1U7auAPg9oSHeJ/2ueTw2ovCFSQUI7n8JSC6KNGBIr30CgiERHP53bJAR8fH77//nv++Mc/0qZNGw4cOADAnDlzePzxx+t9nocffpg9e/bw66+/0q6do/r58OHDWbhwYVOELdLibM0u5p9fbwHgnold6dc2slHPP757a8wm2JJdTHr+qU8F2pBRyK+puVjMJqaN6tCIEQqoIKGc3JJdjmKEI1RvwKs5lzJ0cRwiInLq3HLirZ+fH3feeSd33nmnq0MRkWMor7Zy23trqLbaOSMllhtGNP5Fd1SwH4M7RLEsLZ/vNu8/5SKHL/3iGDVwYZ94EiODGjNE4fDIAV0QyLEUVdSwMaMQgOGdVW/Am2nkgIiI53PL5AA47kLl5uZis9nqbA8PDycwMPCEz33mmWd45plnjrv/jjvu4I477miUOEVaoke+3Myug2W0DvPnP5f2abKlycZ3a82ytHx+2XHwlJIDqTklfLvJMS3hxjGnvoKCHF/tv7xGDsixLE/Lw25Ax5hg2oSf+LNbPNvhUUSujUNERE6d2yUHbDYbt912G2+99RaVlZVH7X/11VeZNm3aCc8xfPhw/Pz86mwrKSnh888/p7i4uF5FDUXk2L5Yl8lHqzIwmeDpy/o16Rz+McmxPDZvK8t351NRbSPQz3LyJx3hhZ93YRhwVvfWdI0La6IoWzZdEMiJ/JbqqDegUQPez6ylDEVEPJ7bJQfeeustvvrqK95++21SUlKwWOpeDNSnIOHAgQMZOHDgUdvvvvtuhg4dqoJIIqdoT24ZD8zdBMDt47owrImXJevcKoQ24QFkF1WybHceZ6S0qvdz9+aV8cX6LABuG9e5qUJs8UwqSCgnsGinIzkwqkusiyORpnZ4sQJ1BiIinsrtkgMbNmzgL3/5C1OnTm30c1ssFsaOHctvv/3GgAEDGv38It6symrj9vfXUlplZXD7KO5ohgtuk8nEmORYPliZzqIdBxuUHHjpl13Y7AZjkmPpnRjRdEG2cM5pBbogkN9Jzy9nd24ZFrOJ4U2cSBTX08olIiKez+1WK2jbti2lpaVNcm6r1crSpUtPWrNARI72r/nb2ZhZRESQL/+7vC8+lubpPkYnO+44LtpxsN7PySqs4JPVGQDcrlEDTUrTCuR4Fu10/J/t3zaC0ABfF0cjTU31R0REPJ/bjRy46qqrOOOMM5gwYQIjRow4pSkA7733Hu+9916dbVarlc2bN2Oz2bj44osbK1yRFuHHrQd4/dfdAPxnSp9mLSw2olMMZhPsOlhGZmEFCREnf+2XftlFjc1gWMdoBraPaoYoW67D84x1QSB11Sb0RmtKQYugKUYiIp7PLZIDd9xxB++8847zcXl5OaNGjSIgIAB//7rFzp599lmuvvrqE54vKiqKzp3r3i309fXlggsu4IorriAysnHXYxfxZtlFFfzt4/UAXD+iPeO7t27W1w8P8qVvUgRr9hWyaMdBLh/c9oTH78sr5/0V+wC4/UyNGmhqh+cZixxWY7OzJDUPODz6R7zbkfdyDMNQfScREQ/kFsmBa6+9ltGjR9fr2GMVGvy9iRMnMnHixNMNS6TFs9rs3PH+WgrKa+iZEMa953R1SRyjk2PrnRx4asEOamwGo7rEMLxTTDNF2HKZVKFcjmFdeiElVVYig3zpmRDu6nCkGZiPSAYYRt1kgYiIeAa3SA4MGDCgSQsEWq1WfHzc4q2KeJSnFuxg5Z4CQvx9eO7y/vj7NGwpwcYyOjmWpxfs5NfUXKw2+3HrHWzNLubzdZkA3DPRNYmMlqb2+79d2QE5Qu2UghGdY7CYdZXYEhz5r6zeQETEM7ldQcLfW7x4MU888QRz585t0JzWzMxMrr/+euLi4vD19SUuLo7rr7+ezMzMJoxWxHss2nGQFxbuAmDWJb1oHxPsslj6JEYQHuhLSaWVtemFxzzGMAymf7kZw4DzerfR3cpmopEDciy1SxhqSkHLUXfkgDoEERFP5FbJgXHjxrFjxw7n49dee43Ro0czffp0Jk+ezM0331yv85SWljJixAg2btzIww8/zNy5c5k+fTobN25kxIgRTbYagoi3yCmu5K4P12EYcMWQtpzfO96l8VjMJs7s6ljG8PO1x07wfbw6gxW78wn0tXCvRg00m9qbwho5ILUKyqrZkFEIqBhhi3LE0AEVJRQR8Uxukxz4/vvvCQoKIjk5GXBknR966CFuvvlmysvLWbZsGW+//Tb79u076bk+++wzYmJiWLp0KbfccguTJk3i5ptvZunSpcTExPDZZ5819dsR8Vg2u8FfPlhHXlk1XeNCefj87q4OCYBLBiQC8NX6LCprbHX25ZVWMfObrQDcOb4LSVFBzR5fS6UB4/J7v6bmYhiQ0jqUuPAAV4cjzeTI2SOGJhaIiHgkt0kOLF68mFGjRjkfb9q0if3793P//fdjNpsZMmQIY8aMYePGjSc9V0ZGBmPGjMHXt+66yr6+vowePZqMjIxGj1/EWzz7006WpuUR5Gfh+Sv7E+DrmjoDvzesYzQJEYEUV1qZs/xwktBuN/jrx+spKK+ha1woN4zs4MIoWx5NK5Dfq603MKqLCoK2JKbfFSQUERHP4zbJgbKyMiyWwxchy5cvJykpicTEROe26OhoiouLT3qu9u3b8+OPP1JVVVVne2VlJQsWLKB9+/aNFreIN1myK5f//bgTgMcv7kmn2BAXR3SY2Wzi9nGOpQn/t2AHaQdLqbHZuX/uRhZuP4i/j5n/Tu2L73GKFUrTMGlagRzBMAwW7XQkB1RvoGWpM3JA3YGIiEdym2/RKSkpzJ07F6vVCsDHH3/MuHHj6hyza9cuOnc++brlF198MRUVFQwYMIBZs2bx9ttvM2vWLAYMGEB1dTWTJ09ukvcg4smyCiu4/b21GAZcOiCRi/slnvxJzezSgUn0SQynuNLKec/8yohZP/HBynTMJvjPpX3oHh/m6hBbHNOhiQW6FhCAHQdKOVBchb+PmcEdolwdjjQj0xGTjJQsFBHxTG6THLjiiivYvXs3KSkp9OnThx9++KFOAcL09HTy8vLo37//Sc8VGBjIkiVLGD9+PG+++Sa33XYbb775JhMmTOC3334jIEBzIEWOVFlj4+bZq8krq6Z7mzD+eVFPV4d0TBaziTeuG0TPhDAqamzklFQRGeTLC1f254I+ri2a2FLV3i3UtYAA/LQtB4DhnaLdZkqSNA9TnZoDIiLiiXxcHUCt0NBQVqxYwXPPPUdubi7/+c9/GDJkiHP/xo0bmTlzZp2pBycSHR3N008/zdNPP91EEYt4j0e+3Mz6jCIignx5+eoBBPq575f66BB/vrx1JCv35FNebWNA+0jCAnxP/kRpEppWIEf6adsBAMZ1a+3iSKS5meqsVqD+QETEE7lNcgAgMTGRWbNmHXPfueee26BzlZeXYzKZCAwMdG6rqKjAMAyCglTJXKTWe8v3OYfmP/OHfh5R6d9sNjGkY7SrwxDqDiWWlq2grJrVewsAGHdo6VFpOcwqSCgi4vHcZlpBYyorK2PEiBFkZtZdDz0jI4MRI0ZQXl7uoshE3MuqPflM/3ITAH87O0UFxKTBzIc+Rexa2LzF+2XHQewGdI0LJSEi8ORPEK9yZJrQUHZARMQjuUVy4MYbb8THx6def954442Tnu+zzz6jd+/eRxUv7NKlCz179uSLL75oqrci4jH25ZXz53dXU2MzOKdnHDeP6eTqkMQjqSChOPx4qN7Amd00aqAl0sgBERHP5xbTCu644w4uvvjieh3bs+fJC6VlZWURFnbsquXh4eHs27fvmPtEWoqiihpueHsl+WXV9EoI579T+9ZZo1qkvkwqSChAjc3OL9sdyYFxXVVvoCVSzQEREc/nFsmBHj160KNHj0Y7X+/evXnhhRd47LHHCA8Pd24vLCzkyy+/5MUXX2zwOauqqpg7dy579uzhz3/+M1FRRy/RVFBQwFdffUVBQQGDBg1i+PDhp/U+RJpCjc3Obe+tITWnlDbhAbx27UC3LkAo7s2sgoQCrN5bQHGllahgP/omRbg6HHGBIxPM6g1ERDyTWyQHGtvZZ59NQkICffv25Y9//COJiYlkZGTw2muvkZCQwDnnnNOg87300ks89thjdOrUiUWLFjFp0qSjkgPbtm1j7NixdO7cmZSUFB555BGuueYa/ve//zXmWxM5LYZhMP3LzSzemUuQn4XXrh1I6zAt7SmnzqRpBcLhJQzHpsRiMWsUUktlMjlGESlZKCLimbyy5oDZbGb+/PlcdNFFvPrqq9x88828+uqrXHzxxXz33XeYzQ172507d2bt2rU8+eSTxz3m9ttvp0+fPixevJjXX3+dzz//nGeeeYYlS5Y06LVEmtLTC3by3vJ9mA6tTNAjPvzkTxI5Aed1oC4GWrQFWx1LGJ6pKQUtmrPugLoDERGP5BYjBxq75gBAWFgYTz/9NE8//fRpROYwfvx4APbu3XvM/fn5+fz444988MEHzmF1Y8aMISUlhY8//ljTC8QtvL1kD//7cScA/7yoJ+O760u8nL7aPk+LFbRcqTklpB0sw9diYlRyjKvDEReqzRWqPxAR8UxukRxo7JoDAPPmzaNTp0507dqVgoICbrrpJnbv3s0dd9zBVVdd1aivtX37dgzDICUlpc72lJQUtm7detznVVVVUVVV5XxcXFwMgN1ux263N2qMjcVut2MYhtvGJ8f25fosHvlqMwB3ntmZKwcn6d/wONTGG+jQiAG7/s48RmO38W837QdgeKcYQvwsagctWO1IIpvd5tJ2oH5cvJnatzRUQ9qKWyQHGltaWhr33nsvq1atAuCxxx5j586dnHfeedx0000MGzaMTp0ab9m20tJSgDrFDwEiIiLYtWvXcZ83c+ZMZsyYcdT2goICrFZro8XXmOx2OyUlJRiG0eDpGeIav6UV8tfPd2AYMLVfa67sG0V+fr6rw3JbauMNU1XtSHCWl5erXXmIxm7j36zPBGBU+xC1AQGgoKAQf1uFy15f/bh4M7VvaaiSkpJ6H+uWyYEDBw7w/PPPs3Xr1qPezF133cXZZ599wud///33jB07Fn9/fwDmzp3LnDlzGDZsGFlZWfzwww+NmhwIDg4GDt/5r1VUVOTcdyz33Xcfd999t/NxcXExSUlJREZGHncpRlez2+2YTCYiIyPVIXmAX3Yc5O9f7sRmNzi/dxv+75I+mFUs7ITUxhsmMMAx19w/IPCYq7iI+2nMNp5ZUMHWA2WYTXDhwA5Ehfg3UpTiicxmE9gMwsMjiIoMdFkc6sfFm6l9S0P5+NT/kt/tkgN5eXn07t2b3r17s3//fuLi4ggPD+frr78mJSWFyMjIk56jvLwc49BQ1z179pCXl8eQIUMAx9388vLyRo05OTkZgNTUVHr37u3cnpqayhlnnHHc5/n7+zsTGEcym81u/Z/dZDK5fYwCC7fncOPsNVRb7ZzVvTX/ndoXHx/9m9WH2nj9OQuQmdDflwdprDb+/VbHKgWD2kfRKsx1F4PiHmpXL+FQ+3JpLOrHxYupfUtDNKSduF2Levvttxk5ciQ//PADQ4YM4bLLLuOTTz5h1apVZGVl0a5du5OeY+jQoXzwwQfMnj2bv/71r5x77rnOv5RVq1YxaNCgRo05JiaGkSNH8s477zi3rVy5ks2bNzN58uRGfS2R+vh5ew5/fmc11VY7Z/dozfNX9sdPiQFpArUjUbRYQcv03aF6AxN7xrk4EnEHtQPT1B+IiHgmtxs5sGvXLufddn9/f8rKygDHKgWjRo1i8eLFTJky5YTnGD58OHfccQcPPvggiYmJzJkzB4AlS5ZgMpkYNWpUg2JatmwZCxcuJDPTMa/y1VdfJTY2lokTJ9K3b18Ann32WcaOHct5551H165dmT17Ntdcc80JRw6INIX5m/Zzx/trqbbZmdgjjmev6IevRYkBaRqHVzLU1UBLc7CkipV7HTUGzu6h5IAcuXqJ+gMREU/kdsmBqqoqAgICAEhISGDTpk3OfYWFhfWutvjwww/z8MMP19k2fPhwFi5ceEoxFRYWEhwczD333OOM5ciVBvr27cuWLVv4+OOPKSgo4I033uC8885r8GuJnI73lu/jwc83YjfgnJ5xPHO5EgPStGovBnQt0PL8sOUAhgF9EsOJj9CUAoHaWUbqDkREPJPbJQeONGXKFHr16oXJZKK4uJgVK1Ywe/bsZo9jzJgxjBkz5qTHxcfH85e//KUZIhKpyzAMnv0plf/+sAOAPwxK4rFJPfFRYkCaWO3FgNY1b3m+3ZQNwNmaUiCH1I4k0sgBERHP5HbJgenTpzsr/CcnJzNv3jxee+01DMPg+++/Jz4+/pjPe+GFF3jhhRe45ZZbnI+P55ZbbnEeJ+LprDY7M77awrvL9gJw+7jO3D0h2XlHV6QpOacV6F5hi3KwpIrfUnMBOK9XGxdHI+5CNUhERDyb2yUHAEJCQpy/jx8/nvHjx5/0Of3792fatGn0798fgGnTpp3wWBFvUFRew23vr2HxzlxMJph+fneuG9HB1WFJC2LWtIIW6ZuN2dgN6JMUQbvo4y/ZKy2LapCIiHg2t0sO/POf/2TOnDkMHz6csWPHMnbsWAYPHoyfn98Jnzd06FCGDh0KQE1NjfN3EW+VmlPKn95Zxe7cMgJ9LTx1WR8m9tQdPGlezjnGuhhoUb5Y5yjQe1GfY4/mk5bJmSx0cRwiInJq3G5C8jPPPMOXX37J0KFDmT9/PmeeeSYRERGMHz+exx57jL179570HDNnzmTUqFG8/PLLFBQUNEPUIs3rp20HuPiF39idW0ZCRCCf3jxciQFxicPTCqSlSM8vZ82+QswmOL+3+h057HANEvUIIiKeyO2SA4GBgc5EwK+//kpBQQFPPPEEW7du5aGHHuKHH3446Tkuu+wy+vbty0MPPURcXBwXX3wxn376aZ3VBUQ8UY3NzsxvtnLDW6soqbQyqH0kX9w2gu7xYa4OTVooLV3W8ny5PguAYZ2iaRUW4OJoxJ1o9RIREc/mdskBgO3bt/PSSy/xhz/8gY4dO/Lwww8zYMAAnnzySc4999yTPj8lJYVnn32WrKwsPv/8c4KDg7n22muJi4vjT3/6E5s3b26GdyHSuDILK7js5aW8vCgNgGuHtWPOtKHEhPi7ODJpyQ5PK3BtHNJ8vlznSA5cqCkF8jtarUBExLO5Xc2B2267jRdeeIGJEycyfvx4/vGPf9C3b1/M5obnMXx8fDjnnHM455xzKCsr48knn+TRRx8lISGBHj16NEH0Ik3j6w1ZPDB3E0UVNYQG+PCvS3pzjiqEixvQHOOWZdv+YrYfKMHPYmZiD/VBUpcKlIqIeDa3Sw5069aNhIQEFi9ejGEY1NTUYLVaGTBgABaLpcHnO3jwIB999BFz5sxh6dKl9OzZk2HDhjVB5CKNL7+smoc+38S8jY71xPskhvPcFf1JigpycWQiDqpO3rLMXesoRDgmJZbwIF8XRyPuRiOJREQ8m9tNK7j11ltJT09n7dq1XHLJJWzcuJFLLrmEqKgozjvvPFauXHnSc5SVlfHee+9x3nnnER8fz8yZMxkxYgTr1q1j48aNnH322c3wTkROz/xN+znrqV+YtzEbi9nEHWd24eObhisxIG5FFwMtR43NzqerHcmBS/onujgacUeHRxKpQxAR8URuN3KgVufOnWndujUJCQkkJCQwe/ZsvvnmGy6++GIGDRp0wuf++9//5umnn+aSSy7hu+++Y+zYsac0LUHEFdLzy5nx1RYWbD0AQHLrEJ68tC+9EsNdHJnI0VSQsOX4eVsOuaVVxIT4cWa3Vq4OR9yYXd2BiIhHcrvkwJo1a/j444/5+eefWb16Nf7+/gwfPpxbb72VsWPHnjQxAHDDDTdw7733EhCgKsriOaqtdl77NY1nftxJZY0dH7OJP4/uyF/Gd8Hfp+FTakSag0YOtBwfrUoHYHL/RHwtSrjL0Wrvw2iakYiIZ3K75MA777zDli1buPDCC/nvf//LoEGD8PVt2LzGtm3bNlF0Io3PMAy+27yfJ+ZvZ3duGQBDOkTx2KSedGkd6uLoRE7MhAoStgQ5xZX8vP0gAFMHJrk4GnFXtf2BRg6IiHgmt0sOPP30064OQaTZrN6bz+PztrJmXyEAMSF+3H9uNy7ul+Acri3izsyHmqmmFXi3T9ZkYLMbDGgXSedWIa4OR9zU4Y8t9QciIp7I7ZIDIi3B9v0lPPXDDuZv3g9AoK+FP43uyJ9HdyTEX/8txXM4LwZ0LeC1DMPg41UZAFymUQNyAmaTRg6IiHgyt7gKWblyJbt27Wrw8wYPHkzHjh2bICKRprEps4hnf9rJd5sdxQbNJscQ3bsmJNM6TDUyxPOYVZDQ6y1Ly2d3bhnBfhbO693G1eGIGzu8tKlLwxARkVPkFsmBb7/9ls8++6zBz5s+fbqSA+IRVu8t4PmfU/lpWw7guNt6Ts847hyfTLLqCogX0LWA93p7yR4ALuybQLBGNskJmDTNSETEo7nFp/zDDz/Mww8/7OowRBpVjc3Ot5v288avu1mXXgg4Rgpc2CeeW8/orGKD4hVqa2PoWsA7peeX8/0Wx/Sn60e0d20w4vbUH4iIeDa3SA6IeJO80io+XJXOO0v2sr+4EgA/i5lJ/eK5eWxnOsQEuzhCkcajgoTebfayvdgNGNk5RqOc5KTMzqVN1R+IiHgiJQdEGoHNbvBrai4frtzHD1sOUGNzfDGKCfHn6qHtuGJIW2JD/V0cpUjjUz1C71VebeX9FfsAuG54e9cGIx5BS5uKiHg2JQdETkNmYQUfr0rn41UZZBZWOLf3Tgzn2mHtOb9PG/x9LC6MUKRpOZfc1NWA15m7NpPiSivtooMY17WVq8MRD6CaAyIink3JAZEGOlhSxbebsvlqfRYr9xQ4t4cH+nJxvwSmDkyie3yYCyMUaT6aVuCdDMPgrd/2AHDNsPaYzaYTP0EE1RwQEfF0Sg6I1ENReQ3fbd7PVxuy+C0117mGs8kEwzpGc9mgJM7uEUeAr0YJSAujiwGvtGBrDjtzSgnx9+HSgYmuDkc8hJKFIiKeTckBkePILqpgwdYcFmw5wJJduc46AgB9kiK4oHcbzu8dT1x4gAujFHEtXQx4H8MweO6nnQBcPawdYQG+Lo5IPIVmGYmIeDYlB0QOMQyDLdnFLNiSww9b97Mps7jO/q5xoVzQJ54LesfTNjrIRVGKuBcVIPM+i3bmsj6jiABfM9NGdnB1OOJBzM6RROoRREQ8kZID0qLlllaxLC2Ppbvy+HlbDllFlc59JhP0bxvJ+G6tmdC9FZ1baRkvkd9z3inUtYBXMAyDZ390jBq4ckg7okO0yorUn3P1EvUHIiIeSckBaVEKy6tZlpbvTAhsP1BSZ3+gr4VRXWIY370147q2IkZfjEVOSOuae5dlafms2luAn4+ZP4/u6OpwxMPUFiS0qzsQEfFISg6IVyuurGHl7nyW7spjya48tu4vPuqORte4UIZ2jGZUlxhGdI5RUUGRBtC0Au9hGAb/+3EHAJcNTKJ1mOqpSMOYlCwUEfFoSg6IVymrsrJqbwFLduWybFceGzOLjrqD0blVCMM6RjOsUzRDOkRp2KzI6dDFgNdYuP0gy9Ly8bOYuWlsJ1eHIx7IWXPAxXGIiMipUXJAPFpljY3VewtYuiuPpWl5rE8vxPq7bED76CCGdYpmaMdohnWMppXuhok0GrOGEXsFq83OzG+3AnDdiPYkRAS6OCLxRIdrDqhDEBHxREoOiEepstpYt6+QpYdqBqzdV0i1zV7nmISIQIZ3inYmBOL1JVekyTgvBlwahZyuT1ZnsONAKeGBvtw6trOrwxEPdXi1AhcHIiIip0TJAXFrNTY7GzKKWJaWx5JduazeW0BlTd1kQFxYAMM6RTunCiRFaZlBkeZiNjt+6k6h5yqvtvLfHxy1Bm4f15nwIF8XRyQe61C2UCOJREQ8k5ID4lZsdoNNmUXOkQGr9uRTVm2rc0xMiB9DO0YzvFMMwzpF0z46yFkhWUSal7MgoS4GPNZLv6SRU1JFUlQgVw9r5+pwxIM5Vy/RWCIREY+k5IC4lN1usG1/iaOAYFoey3fnU1JprXNMRJCvc1TAsI7RdG4VomSAiJsw6WLAo6XmlPLSwl0A3DuxG/4+Wq1FTl1tslAjB0REPJOSA9Ls9uWV89uuXH5NzWXprjzyy6rr7A8N8GFIh8PJgK5xoZjNSgaIuCPnuub2kxwobscwDB6Yu5Fqm52xKbGc2yvO1SGJh9M0IxERz6bkgDS53NIqluzKY0mqIyGQUVBRZ3+Qn4XBHaIYdmiqQPf4MCxKBoh4hMMFCXUx4Gk+Xp3B8t35BPpaePSinhqRJafNcig7UG1VtlBExBMpOSCNzmqzs3pvAT9vP8gvOw6yNbu4zn4fs4n+bSMZ3jmakZ1j6JMUga/F7KJoReR0OKcVKDfgUfLKapj57XYA7prQRYVcpVFEB/sBHDUiUEREPIOSA9Io8kqr+GXHQX7alsOiHQcp/l3dgG5twhjRKZoRXWIY3D6KYH81PRFvoKXLPI9hGPxzfhpFFTV0bxPGDSM6uDok8RIxIY7kQG5plYsjERGRU6ErNDklhmGwfX8JP2zZz4KtOazPKKxzcRAZ5MuY5FjO6NqKEZ1jiAnxd12wItJkNK3A87y9dC+/7S7Ez8fMfy/rg49GbkkjiQ11fNYfLFFyQETEEyk5IA2yem8BX6zey+K0jezNL6+zr3ubMMZ1bcUZXVvRNylCdQNEWgBnQULlBjzClqxiZn27DYD7z+lK17gwF0ck3qT2RsDn67KorLHzn6l9CNFIQRHxUhXVNtZnFDK0Y7SrQ2k06rGlQZ79KZVFO3MB8PMxM6pzDOO7t+aMlFbEhQe4ODoRaW6Haw4oO+DuSqus3PHBWqptBqM6RXD10LauDkm8TO3IAYD5m/czf/p+LhuYxMD2kcSG+tMpNoT4iEDdPBARj5VXWsWPW3P4fssBfk09SJXVzor7x9fp/zyZkgPSIBf1jSfYx+D8fm0Zm9JKtQNEWrjD0wrEndnsBnd+sI7UnFJahfoz/eyOWp1AGt2xphB+uCqdD1elOx/7WkwkRASSFBVEUlQQbaOCSIwMpE14AK3DAmgVGoCfj6a6iIh7sNrsrEsvZNGOgyzamcuGjMI6oyUTIgLZl1+u5IC0TBf3S2BMu0CioqIwm/XhLdLSmTWtwCP867ttLNh6AD8fMy9d1Z+IIC01J43v98mBID8LXVqHEuJv4WBJFXtyy6m22dmTV86evPLjnMVR2LB1WIAzYRAXFkB0iD9RwX5Eh/g5fgb7ERbgi1mjEESkkaXnl/PLjoMs3nmQJal5lFTVLbTeMyGMCd3imNC9Nd3ahHpVsl3JAREROWXOz0NNK3BbH69K5+Vf0gD495Te9E2KID8/38VRiTeKOrSUIcDg9lF88OehdS7ebXaD/cWVpOeXsy+/3Pkzs6CC/cWV5BRXUW2zk1taTW5pNZuzio/1Mk4Ws4nIIEeiICrYj6gQx+/hAT74GDW0iS4nIsiP8EBfwoN8CQvwJTzQlyA/i1d9mReR01NaZWXprjwWHUoI/D55GRHky8jOMYxOjmVUlxjahAe6KNKmp+SAiIicMmfNAdeGIccxf9N+7v1sIwC3j+vMRX0TsNs1akCaxpG1BGJD/Y+6q28xO6YUJEQEHrOAl91ukF9ezf6iSg4UV7K/uJIDRZUcKK4ir6yKvLJq8suqyS+tpqTKis1ukFta1eClE30tJmeiICzQ8dPxuw8h/r6EBvgQ4u9DsL/jZ2hA3d9D/H2UYBDxYHa7waasIudUgTV7C7AeMQTSx2yif9tIRifHMKpLLD0TwltMrRQlB0RE5JQdXq1A6QF38/O2HG5/fw02u8HkfgncNT7Z1SFJCzKsU8Ord5vNJmJC/IkJ8adnQvgJj62y2igoqyGvrMqRMChzjDbIL6uisLyG3KIyKu0miiqsFFfUUHToj9VuUGMzyCurJq+s+lTfHiYThPj5EPK7xEHwoW0hh7YF+VsI9vMh0M/xM8jfQpCvhWD/w9sC/SwE+Vnw1bKiIk1mf1Eli3YeZPHOXH7deZCC8po6+9tHBzGqSyyjk2MZ2jGK0ABfF0XqWkoOiIjIKdOsAve0aMdBbpy9mhqbwfm92/CvKb01N1uaxac3D2dZWh6XD27a1TD8fSzEhVuOuVKS3W4nPz//qPpIhmFQXm2juPJQsqD8cNKgqKKG4korZVVWSiutlFZZKamq+7j2j81uYBhQcuiYxuJnMTuTB0GHRic4/hz9e7C/D4G+FoL9LQT6+RDsZyHQz0Kgr4UAX8fPQD8LAT4WAvzM+FnMGukgLUpplZUVu/P4LTWPxTsPsuNAaZ39If4+DO8UzejkWEZ3iaVtdJCLInUvSg6IiMgpU0FC9/PZmgz+8ckGrHaDs7q35qnL+uKjO5LSTAa0i2RAu0hXh3FMJpOJ4EPTBU51zrBhGFTW2CmpqqGsykZppfXw71U1hx47kgollVbKq22UVx/6WWWjvMbq+Flto+zQdtuhDrTaZqe63E4hNSeJouFMJuokDvx9zXUeB/iaCfjd40BfCwGHEgyBfoe3+deew8eMn4/Z8dNiwdfHhJ/Fsc3PRwkJaV5VVhtr9hayZFcuS3blsT69sM5UAZMJeidGMKZLDKOSY+mbFKHROseg5ICIiJyy2u99mQXl/PWj9VjMjoSB2WzCbAKLyYTJZMJy6LFjuwmL6fBji/P4Q88xH3rOof0RQX4kRASQGBlEq1B/fdk8DsMweGHhLv793XYALugTz38u7a0vPyKNyGQyOe7Q+1kg9PTPZxgG1TY7FdU2yqptVFRbKTuUPHAmFZw/Hb+XVdkOHW/93U8blTW1f+xU1BxOPBgGznM0J1/L4YSB7+8SB/5HbLMc8zPAhNnM4d8PfSacTP+2kVw1tF0zvDtxJZvdYHNWEb+l5rFkVy4r9+RTWVO3pk7bqCBGdI5meKcYRnaOIfKIoqlybEoOiIjIKYsMcnzQFlda+XRNRpO/XmyoP0M6RHF+7zZM6B7XYgoEnUxplZX7P9vIl+uzALhxTEfuOburphKIuDmTyYS/jwV/HwsRTTCqucbmSBJU1tiorLZTaXUkFiprbIe224/4ve62yppDx1odyYuq2uc6z2GnxmZ3jHiwOn6vsRm/e32DGpsjcdFcPluTqWHiXqjGZmdzVjErd+ezYk8+y9PyKK6sO60nJsSf4Z2inQmBpCi1gYZSckBERE5Zj/gwXrqqP/vyy7EbHJqLa2CzO4oU1v6x2Tm03cBucMT2Q4/thx4bjrm8Nvvh/Xll1c6lzg6WVPH1hmy+3pBNx9hg7hqfzHm92jToItgwDKx2g8oaG1VWu/NnVY3ji3NVjePLLjhqKphMYMJx14pDv/v5mAnyOzyvN9DPMU/YFcP3t2YXc+ucNaTllmExm3j4/O5cO7x9s8chIu7H1+K4Ox/WTMXV7HbHSIgjEwbVVsefqiMfH7G/ymp3fCbYOfQZcPgz5PefGza7wYkGj328KoOdOaX8siOHq4e1b5b3LE2jotrG2n0FrNiTz8o9+azdV3jUyJdQfx+GdHQkA0Z0jqFLqxCNLjxNSg40sh07dlBQUED37t0JDW2E8WYiIm7MZDIxsWebZnmtyhob69ML+Wl7Dh+sSCftYBm3v7+Wf323jc6xji8EtRf+R17o1/6ssjrudFVZbU1WIyE0wOfwmuvBfrQKCyApMoikqECSIoNoGxXUaMMaa2x2XlmUxv9+3Em11U5cWADPXdGPge2jGuX8IiINZTabCDA7ahe4Qo3N4N/fbeeXHQeVHPAgdrtBWm4p69OL2JhZxLr0QjZlFtWpGQAQHujLwHaRDOoQxZAOUfRKCFdNnUam5EAjKSgo4KKLLmLDhg0kJCSwd+9eXnzxRa6++mpXhyYi4hUCfC0M6RjNkI7R3HZGZ974dQ+v/ZpGen4F6fkVp3xePx8zAT5m/A8V2ArwPbykmGEcnq9rYBz6CdVWx1DdikNzgGu/v5RUOoqQ7ckrP+7rxYb6061NGN3ahNIzPpzBHaJoHXZ0xfUTWZdeyL2fbmDb/hIAzkiJ5cmpfYnSfEoRacHGpsTy7++281tqHpU1NpclKeT4qqw2duWUsTOnhM1ZxaxPL2RzVjGlx1j5o014AIPaRzGoQxSD20fRpVWIpss1MSUHGsmdd95Jfn4++/btIywsjFdffZUbbriBoUOH0qVLF1eHJyLiVUIDfPnL+C5cP7I9q/bkk1tS7VxX0ddiIsDHUY3b38dRYdsxp9dx4e/vc+ixr6Mo1ul+0TAMx7rppVVW53rr+WXV5JVVsb+okvT8ctILKkjPLyenpIqDJVUcLDnIoh0HnedoHx3EkA7RjOgSwxkpscddX3lvXhn//m47X2/IBiAiyJeHzuvO5P4JGkopIi1e9zZhJEQEkllYwc/bcjinV/OMbJO6DMPgYEkV+/LL2ZtXzt78cnYeKGHHgRL25JU7C2UeKdDXQs+EMHonRtA7MZz+bSNJjAzUZ1szMxmGVqc+XeXl5URFRfHMM8/w5z//GXCssZuYmMif/vQnZsyYUa/zFBcXEx4eTlFREWFhYU0Z8ik73trBIt5CbVyaUnm1le37S9iSXczW7GLWpReyJau4zjQHP4uZUV1iOLtnHGd3jyM8yJfUnFJeW5zGJ6szsB6ac3txvwTuP7cbMSH+DYpBbVy8ndp4yzbzm628vCiNxEjHdK6IIF+sdoOYEH+sNjtRIX5UVtsID/LDBPiYTfhYzPhaTPhaHCsn+Jgdq+z4WExYzObDj50/HcdZfr/dcvQKPGaTCdOhVRhqf3fsc+yvs6LPcfYfyZXtu9pqp7iyhuKKGnJLq8kpcdQCOpz4riKrsIL0gvKjVg44UliADylxoaTEhTqTAZ1jQzRFoIk05BpTIwcawdatW6mqqmLAgAHObWazmb59+7J27drjPq+qqoqqqirn4+LiYsDxn95uP/5/KFey2+0YhuG28YmcLrVxaUoBPmb6JIbTJzHcua24soZVewpYlpbPgq0H2JNXzo/bcvhxWw4PWjbStU0YGzKKnMePSY7hH2en0K2N4wO+oW1VbVy8ndp4y3Z+7zheXpRGRkEFGQWnPuXMndQmD0y1CQOOXhrYdMQyws6EhMlUJzlRm7ioTVRYzBze9rt9dsOgpLKG4gorJVVWiitqqLLW//+U2QTxEbX1dgLp1CqElNYhJLcOPe6yxPo/2zQa8veq5EAjKCgoACAqqm4RqJiYGHbv3n3c582cOfOYowoKCgqwWo+ed+MO7HY7JSUlGIahbLx4JbVxcYW+rXzo26oVNw6JJS2vgp925LNgRz67civYkFGECRjTOZKrBrWhb0IoYCU/P/+UXkttXLyd2njL1iYA7p/Qgf/9speyasdFUXiAD73iQ0iKCKDaZicswIfSKqtjdRzDwGpzFLOtsTlWzbHaD6+eYLM7/lgP/bQdWk3hyG1253FgPbTKgt3AufKCQe2KCzj3NYTNbuCo0+8eA76D/cxEBfkSHexHTLAv0cG+xIT4Eh3kR6tQXxIjAogL9Tv2SABrOQUFx6/LI42vpKSk3scqOdAI/PwcBaAqKupmJ8vLy537juW+++7j7rvvdj4uLi4mKSmJyMhIt55WYDKZiIyM1AeueCW1cXG16GgYlJzIPeCcejCkYzQdY4Ib5fxq4+Lt1MZl2hlRXDs6GR+ziSqr3S0LE9Yu4XtkwuDIJX0dyzsekWQ4dIzNZqegsJDQsDAwmY9xnt8vEXzE7/bDywvbnOc/vFzkkYkOs8lEWKAPof4+hAb4On4P8CXE3weLigJ6FB+f+l/yKznQCNq1awdAZmYm3bt3d27PzMykW7dux32ev78//v5HzxU1m81u/WHmGLbk3jGKnA61cXEXPRIi6JEQ0ejnVRsXb6c2Lv6H/u2DLO6XGAA41aZpt9sJMVURFRWq9i310pB2ohbVCNq1a0dycjJffvmlc1tWVhYrV65kwoQJLoxMRERERERE5OQ0cqCRzJo1i6lTpxIbG0u3bt3417/+Rb9+/bj00ktdHZqIiIiIiIjICWnkQCO5+OKL+fbbb9m6dSuvv/46EydO5Mcff2zQHA8RERERERERV9CVayMaP34848ePd3UYIiIiIiIiIg2ikQMiIiIiIiIiLZySAyIiIiIiIiItnKYVuBHDMAAoLi52cSTHZ7fbKSkpwcfHR8uniFdSGxdvpzYu3k5tXLyZ2rc0VO21Ze215okoOeBGSkpKAEhKSnJxJCIiIiIiIuItSkpKCA8PP+ExJqM+KQRpFna7naysLEJDQzGZTK4O55iKi4tJSkoiPT2dsLAwV4cj0ujUxsXbqY2Lt1MbF2+m9i0NZRgGJSUlxMfHn3S0iUYOuBGz2UxiYqKrw6iXsLAwdUji1dTGxdupjYu3UxsXb6b2LQ1xshEDtTRRRURERERERKSFU3JAREREREREpIVTckAaxN/fn+nTp+Pv7+/qUESahNq4eDu1cfF2auPizdS+pSmpIKGIiIiIiIhIC6eRAyIiIiIiIiItnJIDIiIiIiIiIi2ckgMiIiIiIiIiLZySAyIiIiIiIiItnJIDIiIiIiIiIi2ckgMiIiIiIiIiLZySAyIiIiIiIiItnJIDIiIiIiIiIi2ckgMiIiIiIiIiLZySAyIiIiIiIiItnJIDIiIiIiIiIi2ckgMiIiIiIiIiLZyPqwOQw+x2O1lZWYSGhmIymVwdjoiIiIiIiHgwwzAoKSkhPj4es/nEYwOUHHAjWVlZJCUluToMERERERER8SLp6ekkJiae8BglB9xIaGgo4PiHCwsLc3E0x2a32ykoKCAyMvKkmScRT6Q2Lt5ObVy8ndq4eDO1b2mo4uJikpKSnNeaJ6LkgBupnUoQFhbm1skBq9VKWFiYOiTxSmrj4u3UxsXbqY2LN1P7llNVn2nralEiIiIiIiIiLZySAyIiIiIiIiItnJIDIiIiIiIiIi2ckgMiIiIiIiIiLZySAyIiIiIiIiItnJIDIiIiIiIiIi2cljIUERER8VKlVVa27y9h18FSsgsr2V9cQVZhJQXl1VRU26i02jBhIsDXTKCvhdjQABIjA0mMDKRXQji9EsMJ8tPXRRGRlkC9vYiIiIgXqKyxsTGziNV7C1izt4At2cVkFFQ08CxFdR5ZzCa6tQllROcYzu4RR/+2kY0XsIiIuBUlB0REREQ8UGWNjVV7ClicepDlaflsziqixmYcdVyrUH+SW4eSGBlIXHgA8eGBRIf4EehnIcDXgmE4zlVebWN/cSWZBRWkHSxlXXohOSVVbMosZlNmMS//ksZVQ9vyyAU98LFoZqqIiLdRckBERACw2uxkF1WSUVBBXlkVB0uqSDtYRlSwH5cNSiI+ItDVIYq0aIZhsP1ACYt35LI4NZflaXlUWe11jokN9Wdgu0j6t42kZ0I4XeNCiQz2O+XXyy6qZMXufH7clsNX67OYvWwfOcVVPHtFP/x9LI3xtkRExE0oOSAi0kLlFFfya2ouK/cUsHpvPmkHy7Daj77rCPDKojTuOLMLfxzZAT8f3TEUaS45JZX8lprrTAgcLKmqs791mD+jusQyonM0A9tFkRgZiMlkapTXNplMxEcEMqlfApP6JXBhn3hufW8N3285wJWvLueJKb3pFBvSKK8lIiKup+SAiEgLUlBWzZfrs5i3IZuVe/MxfpcL8LOYSYgMJDbUn8ggX9pHB7NyTz5r9hXyxPxtfL42k8cv7snA9lEA2O0GJhONdjEi0tI5pwrsPMiinblszS6usz/A18zQjtGM6hLL6C4xdG4V0mz//yZ0b81b1w3iT++sYtXeAs56ahFjkmM5u0drWocFsL+okkn9Egjw1YgCERFPpOSAiEgLsCmziLeX7OHL9Vl1hiH3TgxnaMdoBrSLpFdCOHFhAZjNdS80DMPgszWZPP7NVrYfKGHKS0udVcwXbDnAiM4xPHVZ32Z+RyLewTAMduaUsmjHQRbvzGX57jwqa+pOFeiZEMaoLrGM6hLDgHaRLh3OP7xzDN/+ZTQzvtrMj9ty+OnQn1pmk4mpg5JcFp+IiJw6JQdERLzYuvRCnvphB7/sOOjc1iM+jIv7JXBurzb1qiNgMpm4ZEAi47q2Yta32/hsbQYbM4vYmOmoaj53baaSAyINkFNcydK0PH7dmcvinbnsL66ss792qsCoLjGM7BxDdIi/iyI9trbRQbx+3SB2Hihh/qb9/LQ9h7X7CgEoqbK6NjgRETllSg6IiHihXQdL+b95W/nx0B09i9nEeb3acO3w9vRvG3FKw5Ajg/14Ykpv7jmnK1+sy+TtJXvYk1dOaIA+SkRO5EBxJcvS8liWls/ytDzScsvq7Pf3MTOkYzSju8Qwqkssya2bb6rA6ejSOpQurUO5/cwu3PXhOuauzcT4/VwlERHxGPpGJyLiRUoqa3jup1Te+G03NTYDi9nExf0SuH1cZ9pFBzfKa0QF+3H9iA4M7xTD2U8vwk9Lmok42ewGqTmlrM8oZO2+Apan5R+VDDCZoHubMIZ3imZ0ciyD2kd5/Dz92lyGXckBERGPpeSAiIgXMAyDL9dn8di8rc5q5mekxPLg+d2brJp4bWkCXQpIS2QYBjklVew6WMqug2Xsyillc1YRmzKLqaix1TnWZHJM5xnaIZqhHaMZ1D6K8CBfF0XeNEw4OoTjLHgiIiIeQMkBEREPd7Ckigc/38h3mw8A0D46iIcv6M64rq2b9HV1p1C8nWEYFJTXsDu3jL15ZezJLWNPXjm7c8vYnVtG6XHm1wf7WeiZEE6fpAiGdIhiYPsowgO9Kxnwe85koboDERGPpeSAiIgH+3pDFg99vomC8hp8zCZuH9eFm8Z2bJZq5rVzonUxIN6gotrGluxitmQVOX5ml5B2sJSSyuMX2LOYTSRFBtIxNoSOMcF0jw+jd2I4HWNCjlr1w9uZTbUjB9QhiIh4KiUHREQ8UFmVlYc+38RnazMB6NYmjP9c2pse8eHNFkPtpY8uBsQTGYbB5qxiftyaw2+7clm7r4Aa27Hbcnx4AO2ig2kfE0z76CDaxwTTKTaYtlHB+Pmo5gaA+dBfgwoSioh4LiUHREQ8zNbsYm59bw1pB8swm+C2Mzpz27guzX6RUnunUEUHxJNkF1XwwYp0vlqfdVShwNhQf3rEh9EjPozubcLp0jqEtlFBHl8ssHmo5oCIiKdTckBExEMYhsF7K/Yx46stVFvtxIUF8Mzl/RjcIcol8ajmgHiS1JwSXvoljS/WZTpHCPj7mDkjpRWjkmMY0SmGdtFBHrGEoDtSzQEREc/nNcmBr7/+mi5dupCSkuLctn37dlJTUznvvPNcGJmIyOmrstp4+PPNfLgqHXCsRPDk1L5EBfu5LKbakQO6FhB3lldaxX++384HK9OdF66DO0Rx+eAkJnSPI8Tfa74KuZRqDoiIeD6v+ETcvn07DzzwACtXrqyzvUOHDkydOpUuXbqQnJzsouhERE5PTkklN727mjX7CjGb4O9nd+XG0R3dpuCZLgbEXX21PosHP99EUUUNAGd1b83NYzvRr22kiyPzPodHDqg/EBHxVF6RHJg/fz5nnHEGfn5176D5+flxxhln8P333ys5ICIeaX16ITe+u5r9xZWEBvjw7OX9GJvSytVhATiTE7oWEHdTUW3j/rkbmXuoYGf3NmHMuKgHg9q7ZgpOS2AyqeaAiIin84rkgNls5sCBA8fct3//fjp27NjMEYmInL4v1mXy9082UG210yk2mFevGUjH2BBXh+VUO25ByQFxJ1mFFfz53VVsyizGYjZx6xmduX1cZ3wtWlWgKakGiYiI5/OKT8qzzjqLzz77jC+//LLO9rlz5/LZZ58xYcIEF0UmItJwhmHw/M+p/OWDdVRb7ZzZtRWf3zrCrRIDcGTNAV0MiHtIzSll8gtL2JRZTFSwH3OmDeHuCclKDDQD1SAREfF8XjFyICUlhX/+859MmjSJjh07kpiYSEZGBmlpacycOZNu3bq5OkQRkXqx2uxM/3Izc5bvA+BPozpw3znd3Ka+wJEO3yl0bRwiANv2F3PVa8vJLa2mc6sQ3rxuEElRQa4Oq8Uwa+SAiIjH84rkAMA999zDWWedxeeff05OTg5jxoxh0qRJ9OvXz9WhiYjUS3m1lTveX8uCrTmYTPDw+d25fkQHV4d1XCYVIBM3sS+vnKtfX0FuaTXd24Tx7h8HEx3i7+qwWhTnyAF1ByIiHstrkgMA/fr1UzJARDxSXmkVN7y9ivXphfj7mPnfH/oysWcbV4d1QiZUgExcL7e0imveWM7Bkiq6xoXy/p+GEh7k6+qwWp7akQPqEEREPJbHJgeysrLIysoiPj7e+fh44uPjnceJiLib7KIKrnptObsOlhER5Mvr1w5kQDv3r6p+5EwHwzCc1cpFmkuNzc4ts9ewJ6+cxMhA3r5hsBIDLqKaAyIins9jkwOvvPIKM2bMYPr06QDMmDHjuMdOnz6dRx55pJkiExGpv715ZVzx6nIyCytoEx7Au38cQudW7lV48HiOTAYYxuFpBiLN5fF5W1mxJ59Qfx/eun4wrcMCXB1Si6WaAyIins9jkwP33nsvd955JwEBji8Cd95553GPrT1GRMSdbN9fwtWvLyenpIr20UHMnjaExEjPKaBWZ+SA68KQFurrDVm8tWQPAE9O7eMxSTVvpZoDIiKez2OTAwEBAc6L/tdeew2AadOmHXXcifaJiLjK+vRCrn1zBYXlNXSNC+WdPw6mVahnJTJraw6A426hBQ0dkOaRXVTB/Z9tBOCWsZ04q0eciyOS2pFEGjkgIuK5PDY5cKSMjIzj7tu7dy/+/qpYLCLuY82+Aq55fQWlVVb6JkXw1vWDiAjyc3VYDWY6Yul4XQ9Ic7HbDf728XqKK630SQznrgnJrg5JcNYjVHJARMSDeXRyYP/+/c4/AOvWrauzv6SkhO+//55bbrnFBdGJiBztyMTAkA5RvH7dIEL8PbMrPnKcgC4IpLl8sDKd31LzCPS18NRlffG1mE/+JGlymlYgIuL5PPMb6SEvvfRSnUKEL7/8cp39JpOJUaNGMWXKlOYOTUTkKEcmBoZ2jOKN6wYR5Oe53bBZFQilmeWUVDLr260A/P3sFDrGqs6AuzhckNC1cYiIyKnz3G+lwD/+8Q9uu+02/vWvfzkf1zKZTISGhuLn53lDdUXE+6zZV8C1XpQYgLqrE2jkgDSHR7/eSnGllV4J4Vw7vL2rw5EjmM21IwfUF4iIeCqP/mYaFBREUFCQMzlwpNzcXFJTU+natStms4YciojrrD2UGCg5NJXAGxIDUHfkgK4HpKktT8vjq/VZmE0wc3IvLGaNXHFHShSKiHgur7lqvuaaa1i/fj0AS5cupV27dvTo0YPzzz9fWWwRcZmt2cVc+4YjMTC4QxRvXu8diYHf0wWBNCW73eD/vnFMJ7h8cFt6JoS7OCL5PdUcEBHxfF6RHPjxxx/JycmhT58+AMyaNYsbb7yR1NRUdu7cyYIFC1wcoYi0RLtzy7j69RUUV1rp3zaCN71kxECtOiMHXBiHeL+vN2azPqOIYD8Ld47X6gTuSDUHREQ8n1ckB9auXetMDNhsNn7++WfuuusuOnXqxKRJk9i4caOLIxSRliarsIKrXltObmkV3dqE8eb1gwn20FUJjufImgOG3XVxiHerstr41/xtANw0phOxoVqe2B0dHjmg7ICIiKfyiuRAeHg4O3fuBGDhwoXExcWRlJQEQH5+PuHhGn4oIs0nt7SKq15fTmZhBR1jgnn3j4MJD/R1dViNru7IAV0QSNN4Z8leMgoqaB3mz7RRHV0djhyHyTlyQH2BiIin8orkwAUXXMAPP/zA+PHjueqqq7juuusAqK6uZvHixZx11lmndN6SkhIyMzOx2+t/S6yoqIi8vLxTej0R8XzFlTVc8/oK0g6WER8ewLvThhAT4p13Oo8sB6ehxNIUSqusPL8wFYC/Tkgh0M/i4ojkeEyHsgPqC0REPJdXJAfi4uJYvnw5I0eO5NFHH+Wee+4BYMOGDfz1r391jiKor8rKSq644gqio6Pp2bMnbdu25bvvvjvhc7755hsGDhxIp06d6NSpE23btuW999475fckIp6n2mrn5tmr2ZJdTEyIH7OnDSEhItDVYTUZLWUoTW3Osr0UltfQISaYSwYkujocOYHamgPqCUREPJfXTIDt3r07jzzySJ1tAwcOZODAgQ0+1z333MPSpUtJS0sjISGBxx57jMmTJ7Njxw4SEhKO+Zzly5fz1ltv0bNnTwzD4JlnnuHqq69m4MCBJCereJKItzMMg3s+3cBvqXkE+1l46/rBdIwNcXVYTcpkMmEyOaqTKzcgja2yxsari9MAuGVsJy1d6ObMzpED6gxERDyVV4wcqFVYWMj8+fN5/fXXmT9/PoWFhQ0+R1VVFW+88QZ33nkniYmJmEwm7rvvPgICAnj77beP+7wZM2bQs2dPwPGF+fLLL8dut5Oamnqqb0dEPMh/vt/O3LWZWMwmXrhqQItZaq32ck1FyKSxvb9iH7ml1SREBDKp37ET8+I+nCMH1BeIiHgsrxk58M4773DnnXdSWFhIWFgYxcXFRERE8PTTT3PNNdfU+zzbtm2jtLSUYcOGObf5+PgwePBgVq1adcLnlpSUcODAAfLz83nqqafo168fZ5xxxim/JxHxDLOX7eX5n3cBMHNyL8Ykx7o4ouZjNpmwGypHKI2rymrj5V8cowZuHtsJX4tX3cvwTrUjB7RyiYiIx/KK5MC2bduYNm0as2bN4sYbbyQ4OJjy8nJeeuklpk2bxpAhQ0hJSanXuXJzcwGIjo6usz0mJoa9e/ee8Lk//PAD//jHP8jJySE4OJg5c+YQGHj8+cZVVVVUVVU5HxcXFwNgt9sbVASxOdntdgzDcNv4RE5XQ9v4j1sP8PAXmwC488zOTOmf0KL+f9TWHbDabC3qfXsyT+jHP1mVzv7iSlqH+XNJ/3i3jlUcTIdGDNjdoG15QhsXOVVq39JQDWkrXpEcmD9/PlOnTuXuu+92bgsKCuLuu+9m9erVzJ8/v97JAbPZcXeipqamzvbq6moslhNXSZ48eTKTJ0/GMAxefPFFzj77bJYsWcKgQYOOefzMmTOZMWPGUdsLCgqwWq31ire52e12SkpKMAzD+Xcl4k0a0sZ35JRx+/tbsBtwUa9YruwbRX5+fjNF6h5qpxUUFBTib6twaSxSP+7ej9sNg5d/cYzEuXJAa8qKiyhzcUxychUV5QBUVVe7vB909zYucjrUvqWhSkpK6n2sVyQHqqurCQsLO+a+sLCwOnfnT6Z2ZYP9+/fTtWtX5/b9+/fTtm3bep3DZDJxyy238OSTTzJ37tzjJgfuu+++OgmN4uJikpKSiIyMPO77cTW73Y7JZCIyMlIdknil+rbx3NIq/vbleiqtdkZ0juZfU/u3yKHPjuXLDMLDI4iK9N6VGbyJu/fjC7cfZF9BJSH+Plw3OoUQf6/4quL1QkIcKRwfH1+ioqJcGou7t3GR06H2LQ3l41P/z1Gv+MQdOXIkjz/+OFdccQUjR450bl+0aBFz5sw56TKER+rUqRNJSUl89913jB07FnDcyV+2bFmd2gXZ2dkYhkF8fDw2m+2oUQVVVVUUFBQQEnL8auX+/v74+x+9/rnZbHbr/+wmk8ntYxQ5HSdr49VWO7e+t5aswko6xATzwhUD8Pf1iu60wWorlHPo70w8gzv3428u2QPAHwYlERbo59pgpN4sJkdbMsAt2pU7t3GR06X2LQ3RkHbiFd9mhw8fzp/+9CdGjx5NcnIybdq0ITs7mx07dnD33XfXKS54MiaTienTp3PrrbfSpUsXunXrxowZM2jXrh1XXnml87g//elPVFZWsmDBAtLT07n++uu57bbbSE5OJicnhyeffBKLxdKgYogi4v4Mw+Chzzexck8BoQE+vHrNQMKDfF0dlsuYnBXKXRuHeIedB0pYvDMXswmuHd7e1eFIA9T2BVrKUETEc3lFcgDgP//5D1deeSXz588nKyuLs846i4kTJ9KvX78Gn+uPf/wjvr6+vPrqqxQUFDBo0CBef/11AgICnMfEx8c7pyu0b9+ef/3rXzz99NNs2rSJiIgIBg8ezGuvvUZ8fHyjvUcRcb03f9vDh6vSMZvg2cv70bnV8UcHtQS1Iwe0XoE0htpRAxO6tyYpKsi1wUiDOPsCdQUiIh7La5IDAP369TulZMCxXHPNNSe86//KK6/UeTxo0CDmzJnTKK8tIu7p1525PDZvCwD3n9uNsSmtXByR69UWJLTrgkBOU0FZNZ+tyQDghhEdXByNNFTtqFWNHBAR8VxelRzYtGkTe/fuPWqlga5du9YpLigi0lDZRRXc8cFa7AZMGZDIH0fq4gWOnFagCwI5PR+tSqeyxk73NmEM7uDagnbScBo5ICLi+bwiOVBTU8O5557LggUL8Pf3P6oi4/3338/999/vouhExNPV2OzcOmcN+WXV9IgP47FJPQ9V6ZfavweNHJDTYRgG76/YB8C1w9vp/5cH08gBERHP5RXJgU8++YS0tDS2bdtGSkqKq8MRES8z85ttrNlXSGiADy9eOYAAX8vJn9RCmJ3XcLogkFO3dFcee/LKCfH34fzeqtXjiTRyQETE83nF+heZmZlMnjxZiQERaXTfbMzmjd92A/DfqX1pG60iaUfSyAFpDO8dGjVwUd94gv294r5Fi2N29gXqDEREPJVXJAd69OhBamqqq8MQES+TdrCUf3yyAYAbx3RkQvfWLo7I/Zi1lKGcptzSKr7bvB+AK4a0dXE0cqrUF4iIeD6vSM8PHDiQe++9l4ceeoiLLrqIkJC6S4vFxMQQExPjouhExBNV1ti4Zc4aSqusDO4Qxd/P0sikY9PdQjk9n67OoMZm0CcxnB7x4a4OR05RbZkI9QUiIp7LK5IDzz//PBs2bGDDhg089thjR+2fPn06jzzySPMHJiIea9a329m2v4SYED+eu7wfPhavGGjV6HS3UE7HkYUILx+sUQOerHaKkboCERHP5RXJgbvvvptp06Ydd39YWFgzRiMinu7XtELeWbYXgP9c2odWYQEujsh96W6hnI7lu/OdhQgv6KNChJ5MNQdERDyfVyQHwsLClAAQkUZxsKSKf87fBcD1I9ozNqWViyNyb2YtOSen4ZPVGQCc16uNChF6OLMzUejaOERE5NR5xSfxvn372Ldv3zH3mc1mIiMjSU5OxmLR8mMicnyGYXDPZxvJL7eS3DqEeyZ2dXVIbq82NaC7hdJQ5dVWvt2YDcCUgYkujkZO1+GlDNUXiIh4Kq9IDrzxxhvMmDHjhMfExsby/PPPc+mllzZTVCLiad5dtpeF2w/iZzHx9GV9CfBVQvFkTFrbXE7R/E37Kau20S46iIHtIl0djpwuTTESEfF4XlFh6+9//zs9evTgoYceIjU1ldLSUlJTU3nggQfo3r07O3bs4O677+b6669n7969rg5XRNzQjgMlPD5vKwB3jGlL17hQF0fkGVRzQE7Vp2scUwom90t0JpnEc5mVKBQR8XhekRz45ptv6NGjB//85z/p1KkTwcHBdOrUiccee4wePXqwbt067r33XsaNG8fPP//s6nBFxM1YbXbu/mgdVVY7Y5JjuKxfa1eH5DHMqlAupyCzsIIlu/IAmNw/wcXRSGNQzQEREc/nFcmBtLQ0YmNjj7mvVatWpKWlAZCcnExBQUFzhiYiHuDVxbvZlFlMeKAvT0zupbuYDWByLmWoKwKpv7lrMjAMGNIhiqSoIFeHI41ANQdERDyfVyQHevTowfvvv8/q1avrbF+1ahXvvfcePXr0AA8lhxAAAGu2SURBVGDFihUMHTrUFSGKiJtKO1jKUwt2APDged20bGEDaSixNJRhGHy6JhOAKQNUiNBbqDipiIjn84qChOeffz4XXXQRgwYNomfPnrRu3ZoDBw6wadMmrr/+es4//3y2b9/OmDFjGDZsmKvDFRE3Ybcb3PvpRqqtdkZ1iWHKgETd9WqgwxcELg1DPMiafYXszi0j0NfCOb3auDocaSQqTioi4vm8IjkAjhULbr75Zr7//nuys7MZO3Ysr7/+OoMGDQIgJSWFRx991MVRiog7eW/FPlbsySfIz8L/XeyYTqDkQMNoWoE0VG0hwnN6xhHi7zVfQ1o8s4qTioh4PK/6VB40aJAzGSAiciJZhRXM+nYbAH8/O0Xznk9R7d1CjRyQ+qiy2vh6fRYAl2hKgVcxmzVyQETE03lFzQERkYYwDIMHP99EaZWV/m0juGZYe1eH5LFq7xYaWq9A6mHRjlyKK620DvNnaMdoV4cjjUgjB0REPJ/XJAfWrl3LRRddRIcOHYiIiKjzZ9asWa4OT0QOsdrspOaUsj69kI0ZRZRXW5s9hi/XZ/HTthz8LGaeuKQ3FrNWJzhVJnS3UOrvi3WOQoTn947X/zuvo1FEIiKeziumFeTk5DB+/HiuuuoqfH19MZvNjBw5kjfffJOSkhIuvPBCV4co0qLZ7AY/bNnPR6syWJ6WR1m1zbnPZIJucWFcMaQtF/dLILiJ5yDnlVYx46stANw+rjNdWoc26et5O5PuFko9lVVZWbD1AAAX9Y13cTTS2DSKSETE83nFyIFvvvmGkSNH8r///Y+ePXvSrVs37rjjDpYtW0ZAQAA5OTmuDlGkxfp+837GPbmQm2av4adtOZRV2wj2s5AQEUh0sB+GAVuyi3nw802M+fdC5m/KbtJ4/vn1FvLLqukaF8qNYzo16Wu1BKpQLvX1w5YDVNbY6RATTK+EcFeHI42sdllTu93FgYiIyCnzipED6enp9OrVC4Dg4GAyMx3DFv39/Zk4cSIrVqxg7NixLoxQpOXJK63ink83Ou8URgT5cuWQtpzbqw3d4sKcxatySir5en02by/dw968cm6avYa7xifzl/FdGj2mH7ce4It1WZhN8K8pvfHz8Yr8qEtpnrHUV+2Uggv6xDuTSuI9zM5EofoCERFP5RXfjG02Gz4+jjxHp06d+PXXX7HZbBiGwcaNGwkJCXFxhCIty4rd+Zz7zGIWbD2Ar8XELWM7seTecfz97K70iA93JgYAWoUGcMPIDnx/12j+NKoDAE8t2MGri9IaNaaSyhoemLsJgGmjOtI7MaJRz99SOS8IXByHuLf8smoW78wF4MI+mlLgjQ5PMXJtHCIicuq8Ijng4+PjTA6cd955FBQU0L17d3r16sWKFSuYNGmSawMUaUE+W5PBFa8u40BxFZ1ig/nq9pH8Y2JXgvxOPFDJ38fCA+d1575zugIwa/42Vu3Jb7S4Zn27jf3FlbSLDuKu8cmNdt6WrvaCQHcL5US+2ZiN1W7QIz6Mzq2UsPdGJtUcEBHxeF4xreDBBx90/u7v78+KFSt4//33qaioYOrUqcTH6y6FSFMzDIMXFu7i399tB+C83m341yW9G1xg8M+jO7I1u5jP12Vxz6cbmH/naHwtp5fHXJ6Wx5zl+wCYObkXgX6W0zqfHKaaA1IfX67LAlSI0Js5aw6oLxAR8VhekRz4vejoaG677TZXhyHSYtjtBo98tZl3lu4F4MbRHblnYtc60wfqy2QyMeOinizemcuug2XMXraX60d0OOXYKmts3PvZRgAuH9yW4Z1iTvlccrTaf2FdEMjxZBVWsGJPPiaTo96AeCfVHBAR8XwemxzIysoiKyvLOSogKyvruMfGx8dr9IBIEzEMg4e/3MTsZfswmeCRC3pw7fD2p3XO8EBf7pqQzIOfb+KlX3ZxxZC2+Puc2t3+pxfsZHduGa3D/Lnv3K6nFZcczaxpBXISX613fD4Pah9Fm/BAF0cjTUU1B0REPJ/H1hx45ZVXGDRoEK+88orz9+P9eeWVV1wdrohXMgyDh7/Y7EwM/HtKn9NODNS6dGAircP8OVBcxRdrj5/8O5GNGUW8uthR2PDxSb0IC/BtlNjkMJOGEstJfKEpBS2CVi4REfF8Hjty4N577+XOO+8kICAAgDvvvPO4x9YeIyKNxzAMpn+5mXeX7cVkgn9d0pspAxIb7fz+PhZuGNGBmd9uY/byvUwdlNSg51db7fzj0w3Y7AYX9IlnfPfWjRabHHZ45oguCORoqTklbMkuxsds4tyebVwdjjQh1R8REfF8HpscCAgIqHPRrwSASPOa9e023lnqSAw8cUlvLh3YsIv3+pgyIJH/fL+dDRlFbMosomdCeL2f+/zPqWzNLiYyyJfpF3Rv9NjEwYRGDsjxfbk+G4DRybFEBvu5OBppSocLEqozEBHxVB6bHNi3bx/79u2r17Ft27albdu2TRyRSMvx2uI0Xl7kGK4/8+JeTG2CxABAdIg/Z/WIY96GbD5YuY/HEnrV63mbs4p4/udUAP55UU9iQvybJD45cilD18Yh7scwDL4+VG/gQhUi9Hpm9QUiIh7PY5MDb7zxBjNmzKjXsdOnT+eRRx5p2oBEWojP12by2LytANwzsSt/GNy0ibfLB7Vl3oZsvlibxf3ndiPI78TdVrXVzl8/Wo/VbnBOzzjO762hzE3JpHnGchybs4pJyy3D38esaT0twOFRROoLREQ8lVsWJMzOzmbHjh0nPObhhx+mpqaGmpoaiouL6dGjB/feey87d+6ktLSUnTt3cu+999KjRw/+/ve/N1PkIt7tlx0H+dvH6wG4fkR7bhrTsclfc3inaNpGBVFSZWXehuyTHv/MjzvZtr+EqGA/Hp3U0zkPVpqGc/kyF8ch7uerDY5RA2d2a0WIv8fei5B60igiERHP5/LkgNVqZdKkSWRkZADwxRdf0LZtW1JSUpg2bdpxn2c2m/Hx8cHHx4f58+fTrVs3Zs6cSefOnQkODqZz587MnDmTbt268c033zTX2xHxWuvTC7l59mqsdoML+8Tz0Hndm+XC22w2cdmhYoTvrzjxVKLfUnN5fqFjOsGjmk7QLExaylCOwTGlwJHMu6C3phS0BGazRg6IiHg6lycH5syZQ0xMDImJjirn//znP/m///s/Nm7cyBdffMHWrVtPeo60tDRatz72kMVWrVqRlpbWqDGLtDRpB0u5/q2VlFfbGNk5hv9c2sf5RbA5XDogEYvZxJp9hWzNLj7mMQdLqrjzw3UYBlw+OInzNJ2gWZhVoVyOYc2+QjILKwj2s3BG11auDkeagWoOiIh4PpcnB9auXUufPn0AyM/PZ+vWrdx222307NmT8ePHs3HjxpOeo2fPnrz33nusXLmyzvaVK1fy/vvv06tX/YqYicjRcoorueaNFeSXVdMrIZyXrh6An0/zdh2twgKY2CMOgGd/2nnU/rIqK398eyUHS6pIbh3Cw+f3aNb4RHcLpa6vDhUinNC9NQG+FhdHI81BNQdERDyfy5MD4eHh7Nzp+LL/1VdfMXToUAIDAwFHsiA8/ORLl5133nlceumlDBkyhF69ejFhwgR69erFkCFDuOyyyzj33HOb9D2IeKviyhqufXMlGQUVtIsO4s3rB7ls7vAdZ3bBZIJvNu5nya5c5/bKGhs3zV7NhowiooL9eOmqAQT66WKkuWjkgPyezW7wzcZDUwq0SkGLYVZxUhERj+fyCkGXXnopAwcOZOfOnSxbtoz//e9/ABQUFLBz506GDx9er/O8/PLL/PnPf+a7774jOzubM844g4kTJ9K/f/+mDF/Ea1XW2PjzO6vYml1MTIg/79ww2KVz+FPiQrlsYBIfrEzn9vfW8vjFvQgL9OGJ+dtZn15IoK+FN64bRMfYEJfF2BJptQL5vRW788kpqSIswIdRXWJdHY40E5OKk4qIeDyXJwd69uzJokWL+Oqrr7j22mv5wx/+AMCqVauYNWsWoaGh9T7XgAEDGDBgQFOFKtJi2OwGd324jmVp+YT4+/DW9YNoFx3s6rCYfkEPNmUVsSmzmJtmr3ZuDw/05cWr+tM3KcJ1wbVQWq1Afq92lYJzerZp9ilI4jpH1hwwDEMrxYiIeCCXJwcABg8ezODBg+tsmzBhgouiEWnZDMPgkS838+2m/fhZzLxy9QB6Jpx8ek9zCPSz8NGNw/jX/O18szEbu2EwJrkVd5+VTEJEoKvDa5Fqv/5rtQIBqLHZ+VZTClok8xHJAMM4PKpIREQ8h8uTA6mpqezfv/+4+7t06XLclQiaUlVVFb/88gsFBQUMGDCAzp07n/Q56enprF69mqCgIAYNGkRkZGQzRCrSuJ77KZV3l+3FZIL/XtaH4Z1jXB1SHUF+PjxyYQ8euVBFB92BSTUH5Ai/peZSUF5DdLAfQztGuTocaUZHJgPshoEZZQdERDyNy5MDs2bN4vXXXz/u/ldffZVp06Y1Y0SOi/xx48ZhsVjo1KkTN9xwAw888AD333//MY8vKyvjuuuuY9WqVfTp04fc3Fw2bdrEK6+8wtSpU5s1dpHT8f6KfTz5ww4App/fnfO1PrmcxOGaA66NQ9zDV+sdowbO7dUGH4umFLQkR04jUHcgIuKZXJ4ceOmll3juuefqbCsoKOD1119n4cKFXHfddc0e0+23306rVq1YuHAhvr6+fPnll0yaNIlzzjmHfv36HXV8TU0Nl112GR999JHzw/Hxxx/n2muvZeLEiYSFhTX3WxBpsO837+eBuY6lQ289oxPXjejg4ojEEzjnGetyoMWrrLHx/WbHSEBNKWh5zL8bOSAiIp7H5Wl9Hx8fAgIC6vxp06YNDz74IFVVVaxdu7be51q6dCn/+9//WLhwIQAHDhwgIyOjQfEUFxczb948br75Znx9fQG48MILad++PR988MExnxMREcGUKVPqZM0vuOACKisrSU1NbdDri7jCqj353P7+WuwGTB2YyN/OSnF1SOIhDq9t7uJAxOV+2XGQkiorcWEBDGynaXUtze9rDoiIiOdx+ciBE2nTpg27du1i0KBBJz329ttv54033iA0NJSbbrqJsWPHUlpaykUXXcS6devw8anfW922bRtWq5UePerOZ+7RowebNm2qd+zz588nICCA5OTk4x5TVVVFVVWV83FxcTEAdrsdu91e79dqTna7HcMw3DY+abgdB0q44a2VVFntjOsay2MX9cAwjBZbYE5tvGGc0wrcuN+SupqqjX+13rFKwXm94wADuzJGLYphHG5PVpsNu8V1NQfUj4s3U/uWhmpIW3F5cqC0tJTKyso626qrq1myZAnz5s3jvvvuO+k5lixZwmeffcaOHTt47bXXnBc1nTp1olOnTnz99ddMmjSpXvEUFRUBjtEAR4qKimLXrl31OseqVat45JFHeOSRRwgJOf6a6zNnzmTGjBlHbS8oKMBqtdbrtZqb3W6npKQEwzAwm10+8EROU3ZRFX98fzPFlVZ6x4fwz7PbUVxU6OqwXEptvGFqqqsBKC0tIz8/38XRSH00RRuvqLaxYMsBAEa3C1ZbaIEqaw5/+czPL6DSz+KyWNSPizdT+5aGKikpqfexLk8O3HnnnccsSOjr68t99913zDn+v7d8+XIuu+wyEhISjtqXnJzM1q1b650cCAx0LIdWVlZWZ3tJSYlz34ls3ryZc875//buO76pcv8D+Cdp03RvuidltFBGoQyh1RYKsmSpFEQEEdSrMhzXC168gl4v/NR7HYgDUdxsEEQUBdnDAqVAZbUUSgfdI+nMen5/hEZCW2ihkCb9vF+vvNqcPOecb5KnpznfPOf7DMdjjz2Gf/zjHzdsO3/+fLzwwguG+wqFAoGBgXBzc2u1dQp0Oh0kEgnc3Nx4QDJzBYoaPLfhFAoq1OjQzgFfTu8HV3sbU4dlcuzjzWMrlwMA7O3t4e7O6vTm4E708a0nr6BGo0OQux1iugRyjvs2qFajNfzu4uoKJ1uZyWLhcZwsGfs3NVdTR9ADrSA58Nprr+G5554zWiaXyxEcHAx7e/smbUMqlaKqqgqAvlrutcOh09LScP/99zc5nrCwMADApUuXEBkZaVh+6dIl9O3b94brnj59GoMGDcLYsWPx8ccf33Rfcrkc8qsfrK8llUpb9R+7RCJp9THSjZVUqvDYyiPILKlCoLsdvp3RH+6OtqYOq9VgH286ydUqZAISvl5mpKX7+NaT+lkKRnX3g5WV6b4xJtOxvvZtl5j++MnjOFky9m9qjub0E5P3qMDAQPTs2dPoFhER0eTEAAAMHToU69atw/nz542+rfjyyy+xbds2DBs2rMnb8vX1Ra9evbBmzRrDsrNnz+L48eMYNWqUYdnOnTvx66+/Gu6fOXMGgwYNwujRo7F8+XJ+a0KtlqJGjalfJOF8fgW8neX4fkZ/+LgwMUC3RmqYypDXl7dViho1dp8rBMBZCtoy44KEPB4QEZkjk4wcyMzMRGFhYZPahoSEwNPT84ZtIiIiMH/+fPTo0QOurq6wtbXF559/jpycHLz77rsIDW3elGzvvfcehgwZAplMhoiICHzyyScYMWKEUXLg3XffRU1NDYYOHYqioiIMHjwY9vb2GDBgAL766itDu4SEBAQEBDRr/0R3SpVKg+krj+BUTjncHWzw3Yx+CHRveiKO6HpMg9Kvf+ZDpdWhg5cjwn2cTB0Omci1xwLWoiQiMk8mSQ688cYbDdYZaMhnn32GGTNm3LTdSy+9hPvvvx+bNm3ClStX4OXlhXHjxqFnz57Nji82NhbJycn45ptvcOHCBbzyyiuYOnWqUZuEhASo1WoA+lkHhg4dCgDYs2ePUbuoqCgmB6hVqFZp8eTXx3A0sxTOttb45om+6ODFD/J0e+q+LeTIgbarbpaCB7r7cdRcG3btW8+RA0RE5skkyYGlS5finXfeaVLb5lxe0K1bN3Tr1u1WwzLSpUsXLF68uNHH586da/jd398fX375ZYvsl+hOqFJpMOOrozh4oRj2NlZY+XhfdPVzMXVYZAmunhDwXKBtKqlU4UB6EQBgVA9fE0dDpiSRSCCR6I8FHDlARGSeTJIcsLOzg52dHcrKyvDVV18hKysLkZGRmDJlyi0XMtq6dSs6duyIzp07G5adO3cO6enpGDlyZEuFTmR2Kms1eOKrIzicUQIHGyt8Nb0vege7mTosshB/jRwwcSBkEr+k5kGjE+ji64ywdo1P3Uttg1QigVYIjhwgIjJTJputoLKyEr169UJ2djY8PT2Rl5eHTZs2YfPmzc3e1rlz5/DPf/4TR44cMVoeGhqKCRMmoGPHjujUqVNLhU5kNipq9TUGki6VwFFuzcQAtbi6goQCPBloi7acyAHAQoSkV3dlAZOFRETmyWSzFXz77bdwcHBAdnY2cnNzkZycjJ07d+LEiRPN3tYvv/yC+Ph42NgYz9FuY2OD+Ph4o1kFiNoKZY0a075IQtKlEjhdrTHAxAC1NMnV0wF+Udj2XCmvxh8XSwAAo7rzkgL6ayQRk4VERObJZMmBs2fPYtq0afDy8gIA9OzZE8OHD8fZs2ebvS2pVIr8/PwGH8vLy4NOp7utWInMTVFFLSZ9dthQfPC7Gf0QFcTEALW8uqlzOYy47dmSkgshgD4hbpz1hAD8VZSQIweIiMyTyZIDSqUSLi7GBdFcXFygVCqbva2hQ4di48aN2LJli9HyTZs2YePGjRgyZMhtxUpkTrJKqvDQxweRmqOAh4MNvp/ZH90DXE0dFlks1hxoqzYd119SMDbK38SRUGthqEHCAwIRkVkyWc0BADh48CCsrf8KIS0tDTqdzmjZwIED0bFjxxtup3Pnznj99dcxduxYtG/fHgEBAcjOzkZGRgYWL16MiIiIO/YciFqTM1cUeOyLJBQqaxHgZodvnuiHUE8HU4dFFkzK2QrapHN5SpzNU0JmJcHIbrykgPQkPB4QEZk1kyYHVq5ciZUrVxot27t3r9Gyzz777KbJAQD4xz/+gaFDh+KHH35AQUEB7rvvPowdOxZRUVEtHjdRa5R0sQRPfHUEyhoNOns74esn+sLb2dbUYZGF+2sYMc8G2pIfUvSjBuI6e8HV3uYmramt+Gv2Eh4PiIjMkcmSAytWrMCKFStadJtRUVFMBlCbtOVELl5adwIqjQ59Qtyw4rE+cLGXmTosagP+KkBGbYVOJ7C57pKCnrykgP5iGDlg2jCIiOgWmXTkAAAcOHAAHTp0gLe3921vKzU1FZmZmVCr1UbLw8PDER4eftvbJ2ptdDqB93am4YOdaQCAhAhvLJ0UBTsbKxNHRm1F3dRlLEjYdhy5VILc8ho4ya0xOMLL1OFQK8KRA0RE5s3kyYHVq1fjk08+wciRIzF9+nSMGDHCqOZAU6jVaowYMQI7duyAXC6vt/4rr7yCV155pSXDJjK5apUWL607gZ9OXQEAPHVve7w8LBxWdReBE90FEgmnMmxr6i4pGBbpA1sZE5H0l79qkPCAQERkjkyeHHj//fcxevRofPHFF0hMTISrqyumTJmC6dOnN/nb/vXr1yMjIwNnz55F586d73DERKaXV16DmV8fxamccsisJHhzXDdMiA40dVjUBrHmQNtSq9Hip5P6hOQ4zlJA15FIOHsJEZE5M9lUhoYApFIMGTIEq1atQm5uLhYsWICdO3ciIiICAwcOxOeff47KysobbiMnJwfjx49nYoDahIMXijBq6T6cyimHm70M383oz8QAmQxrDrQtu88VQlGjgbezHP3ae5g6HGplOHsJEZF5M3ly4Fpubm6YOXMm5s+fj/DwcBw8eBBz585FYGAg3n///UbX69q1K9LT0+9ipER3n04nsGxXOh5d8QeKKlQI93HC5mdj0DfU3dShURtWdxELRw60DT9cLUQ4pqc/L2GieiSsOUBEZNZMfllBnZMnT+KLL77Ad999ByEEpkyZgg0bNqBDhw5YvXo1Zs+ejejoaAwcOLDeutHR0Zg3bx5effVVjBkzBo6OjkaPe3p6wtPT8249FaIWV1alwotrT2Dn2QIAwEO9A/DGmEgWHiSTk0pZnrytKK9WG45BY3r6mTgaao2kvMyIiMismTw5sHXrVixcuBDJyckYNGgQli5dinHjxkEulxvaPPbYY9i5cyfOnTvXYHJg2bJlOHnyJE6ePIl///vf9R5/7bXXsHDhwjv5NIjumH1phXhp3QnkK2phYy3FG2O6YkJ0oOEbGiJT4siBtuOX1CtQaXTo5O2ILr7Opg6HWiEJWKCUiMicmTw5kJSUhPvvvx9r165F+/btG203b948uLi4NPjYCy+8gBkzZjS6rrMzP8SQ+alRa/HWL+fwxYGLAID27RzwwcQoRPo3/HdAZAqcraDtWH8sGwAwNsqfyUlqEEcOEBGZN5MnB15//fUmtYuIiGj0MWdnZyYAyKKczlVg7prjOJ9fAQCY0j8Yr4yI4GUE1Or8NVuBaeOgO+tSUSWOXCqFVAKMjwowdTjUSjFZSERk3kyeHCCiv9SotVi2Kx2f7LkAtVbA09EGbz/UA/HhXqYOjahBf5Uc4NmAJduQrB81ENuxHXxcbE0cDbVW0qtlrjlygIjIPLWq2Qpux/HjxzFmzBiEhobC1dXV6LZkyRJTh0d0U4czijHi/X1Y+ns61FqBoV288cvce5kYoFaN1xhbPq1OYMPVSwoejuaoAWqc1DBbgYkDISKiW2IRIwcKCgqQkJCARx99FDKZDFKpFDExMVi5ciWUSiVGjx5t6hCJGlVWpcLibWex5mgWAKCdkxyvj+6KYZE+vK6XWr2/5jXn2YClOnShGLnlNXC2tUZChLepw6FWrO4/Fo8HRETmySJGDmzbtg0xMTF4//33ERkZiYiICMyePRuHDx+Gra0tCgoKTB0iUT0arQ5fHbyEuHd2GxIDj/QLwo4X7sPwbr5MDJB54DeFFm/9Mf3xaXRPP9jKWPeEGlc3coCHAyIi82QRIweysrLQrVs3AICDgwNycnIAAHK5HMOGDUNSUhLi4uJMGCGRsT3nC/HvraeRVqAvONjJ2xH/HtsNfUPdTRwZUfOw5oBlU9So8XNqHgDgod6BJo6GWjtDgVJmC4mIzJJFJAe0Wi2srfVPJSwsDGvWrIFWq4VUKsWpU6cwZswYE0dIpHfmigJvbz+H38/qR7O42cvwwtDOmNQnENZWFjGQh9qYupoDPBewTD+dvIJajQ4dvRzRI4DTqNKNseYAEZF5s4jkQF1iAABGjhyJv//97+jSpQtkMhlycnKwcuVKE0ZHBKQXKPHujjT8dPIKAMBaKsG0ASGYNbgjXOxkJo6O6Nb9VXPAtHHQnbH+aiHCh3oH8FInuikJa5AQEZk1i0gOLFiwwPC7XC5HUlISVq1aherqakyYMAF+fn4mjI7asktFlfjg9zT8cDzH8E3KAz388HxCR7Rv52ja4IhaAE8GLFd6QQWOZZZCKgHGRfmbOhwyAxw5QERk3iwiObBixQoAwIwZMwAAHh4eeO655xp8jOhuOJldhk/3ZODn1CuGD0lDu3jj+SGdEOHrbNrgiFpQ3bfJzA1YntVJlwEAg8K94OVsa+JoyBwYjgesQUJEZJYsIjmQnZ3d6GOZmZmQy+V3MRpqq4QQ2JtWhE92X8ChjGLD8vjO7fD8kE7oHuBquuCI7hBDATJmByxKjVqLDcn6/62T+gaZOBoyF1LD8cC0cRAR0a0x6+RAXl6e4QYAKSkpRo8rlUr8+uuveOaZZ0wQHbUV5dVqbEzOxjeHM5FRWAlAX1NgdA8/PHlfe4T7cKQAWS4OI7ZM2//MQ2mVGr4utrivUztTh0Nm4q/jAQ8IRETmyKyTA5988gkWLVpkuP/pp58aPS6RSBAbG4uHHnrobodGFk4IgT9zFfjuj0z8cDwX1WotAMDBxgqJfYLwRGwo/F3tTBwl0Z1XV6KOw4gty6qrlxRMiOZMKtR0rEFCRGTezDo58PLLL+O5557DW2+9ZbhfRyKRwMnJCTY2NqYKjyxQvqIGm1NysDE5B2fzlIblnbwdMaV/MMZG+cPJlrMPUNshZc0Bi5NRWIHDGSWQSoAJfQJNHQ6ZEdYgISIyb2adHLC3t4e9vb0hOXCtoqIipKenIzw8HFIpv/WgW1dZq8Fvp/OxITkbB9KLDMOnbaykGNrVG1P6B6NvqDun+aI2id8UWp41R7IAAHGdvTgCipqFNQeIiMybWScHrvXYY4/hxRdfRI8ePXDo0CEkJCSgqqoKw4cPx08//cQTN2qW0koVdpzJx/Y/87E3rRAqjc7wWHSwG8b3CsDIbr5wsecoAWrbJKw5YFFqNVqsO8ZChHRrWHOAiMi8WURyYOfOnSgoKECPHj0AAEuWLMFTTz2FZ599FsOGDcOOHTswZMgQE0dJrd2lokrsOV+IX0/n4XBGCbTXnO0Ee9hjbE9/jIvyR4ingwmjJGpd/qo5QJbgt9P5KKlUwdtZjvjOLERIzWM4HjA5QERkliwiOXD8+HFDYkCr1WLXrl348MMPERgYiLFjx+LUqVNMDlA9yho1Dl4oxt7zhdiXVoTLJVVGj4f7OGFYpA+GRfqgs7cTR58QNUDKqQwtyvd/6AsRJrIQId0C1iAhIjJvFpEccHFxwcGDBwEAu3fvho+PDwID9UWUSkpKEB4ebsrwqJUorVThaGYpjlwqQdLFEqTmlENzzegAmZUEvYPdEN/ZC8MifRDswRECRDcjrcsO8GTA7KXlK3HwQjGkEiCRlxTQLZCw5gARkVmziOTAAw88gBdeeAEJCQn4888/MWvWLACASqXCvn37sHDhQtMGSHedSqPD+XwlTuWU42R2OY5eKkFaQUW9dqGeDojt6Il7O7ZD/zAPOMot4k+C6K6pG0/DkQPm76tDlwAAQ7p4sxAh3RLWHCAiMm8WcSbk4+ODP/74A2vXrsXEiRPx+OOPAwBOnjyJF1980TCKgCxTcUUt0gsqkFZQgTNXFDiVU46zV5RQaXX12nbwckSfEDf0CXFHnxB3BLrbmyBiIsvBqcssg6JGjY3JOQCAqQNCTBsMmS0JLzMiIjJrFpEcAIAuXbrUGyEQHR2N6Oho0wRELapKpUFWSTWySqqQVVqFC4UVSMvXJwRKKlUNruNsa41uAS6I9HdBryA3RAe7wcNRfpcjJ7JsPBmwDOuOZqNKpUUnb0fc097D1OGQmbK6epmRltcVEBGZJbNNDuTm5iI3Nxd+fn6G+43x8/MztKPWQ6cTKK9Wo7hShdIqFYor9D9LKvW3AmWtPhlQUoXiRhIAdQLd7dDRywkdvR3Rzd8F3f1dEehuxyKCRHeYoQCZieOgW6fTCXxz9ZKCx+4J4XGTbpm9jRUAoEqlNXEkRER0K8w2ObB8+XIsWrQIr732GgBg0aJFjbZ97bXXWHfgLqhRaw0n9vVuVSqUVFz9WalC6dWEQHO+XHC2tUaguz0C3ezRvp0DOno7oqOXE9q3c4C9jdl2ZSKzxqnLzN+etEJcKq6Ck601xkX5mzocMmOOchkAoKJWY+JIiIjoVpjtGdW8efMwd+5c2NraAgDmzp3baNu6NnT7NqfkIik9H9W6LJRWqY2+8b/Vbwqcba3h7mBjdHNzsEE7RzkC3OwQ4GaPQHd7uNjJWvjZENHt4tRl5u+rg5cAABOiA+HAoqx0G5xs9f2noobJASKyfOVVaiRnlSK+s5epQ2kxZvspwNbW1uikv6UTAOnp6fj+++9RWlqKPn36YOLEiZBKbzznc15eHr788ktcunQJixYtgre3d4vG1Br8frYAP57Ma/RxmZVEf3JvbwMPx6s/r57s1/00SgLY20DGubSJzBdrDpi1i0WV2H2uEBIJMKV/sKnDITNXN+MPRw4QkSUTQmBjcg4W/3wGihoNfnv+XouZAt1skwOXL1/G5cuXm9Q2KCgIQUFNn7P58OHDGDRoEMaOHYuIiAjMnz8f69evx8aNGxtd54033sDy5csRExOD1atXY+7cuRaZHBgc4QUPW8DXwxluDnJ4XHey7yi35vWqRG0Iaw6Yt7pRA3Gd2iHE0zI+2JDpOF4dOaDkyAEislDn85VY8EMqki6WAADC2jlAUW05xzyzTQ588cUXN6wzcK3m1hyYM2cORo8eje+//x4AMG7cOHTr1g2//PILhg0b1uA6Y8aMwbx583DixAmsXr26yfsyN6N7+CEm0Bbu7u43HUlBRJavLhXI4uTmp6xKhTVHsgAA02NCTRwNWYK6kQNZpVW4WFSJUCaciMhCVNRqsHRnGj7ffxEanYCtTIrZgztiRkx72FhbzjmR2T6Tf/3rX1Cr1VCr1VAoFOjatSvmzZuHtLQ0VFRUIC0tDfPmzUPXrl3x97//vcnbzc/PR1JSEh555BHDssjISPTo0QNbtmxpdL3u3btDJuM18UTUttTlCFmQ0Px8l5SFarUWEb7OiOngaepwyALU1RxIuliC+Hd243SuwsQRERHdHo1Wh+//uIy4t3fj070Z0OgEhnTxxo4X7sMzcR0sKjEAmPHIAalUavjm+pdffkFERAQWL15seLxDhw5YvHgx0tPTsW3bNjz88MNN2m5aWhoAIDTU+FuU0NBQpKent1D0erW1taitrTXcVyj0/0R1Oh10Ol2L7qul6HQ6CCFabXxEt4t9vHnqkgI6vmZmQ6fToVatNVxSMDMmBEIIJnjottVNZVhn7urjeO2BLrgnzOOuxsHjOFky9u+7QwiB3ecLseTnc0grqAAABHvYY8GIcAyO0F86bi7vQXPiNNvkwLUyMjIavb7fy8sLGRkZTd5WdXU1AMDJycloubOzMwoLC289yAYsXry4wUsjSktLodG0zmtXdDodlEolhBC8rIAsEvt481RVVgIA1Co1SkpKTBwNNYVOp8Om49koqlDBy1GGAQFyvnfUIkRtldH98wUVmPx5Evxd5Ojq64gBIS6I9HNEkJutoV7JncDjOFky9u87L6OoCv/bfRmHL5UDAFxsrTFzgD8e7OEFmZXU7P5nKpXKJre1iORAZGQk/u///g9Tp05Fnz59DMuPHDmCVatW4dtvv23ytpydnQEAZWVlRstLS0sNj7WU+fPn44UXXjDcVygUCAwMhJubW4vvq6XodDpIJBK4ubnxgEQWiX28eZwcawAAVtbWcHd3N3E01BQajRYbUk8BAJ6IbQ+vdrykgFqGX03DHytzymuRU16LX88WAwBc7GToHuCCHldv3QNc0c5J3mJx8DhOloz9+84prVLh/R3p+C7pMrQ6ARsrCaYOCMGzcWFwNuMp1a2tm37KbxHJgZEjR+Lhhx9Gv3790LVrV/j4+CAvLw9//vknnnrqKYwYMaLJ2woPD4eVlRVOnz6Nnj17GpafPn0a48aNa9G45XI55PL6/wyvvWSiNZJIJK0+RqLbwT7edFZXpyIVAF8vM7HvQgEultTAUW6FSf2C+b5Ri3G67sNzj0BXLBgZgSJlLU5kl+NYZglOZpejvFqNfWlF2JdWZGjr72qHbv4uCPd1QriPM8J9nBDkbg+p9NZGGPA4TpaM/btl6XQC645lYfHPZ1FWpQYA3N/VG6+MiLCIKQqb008sIjkAAJ9++imefPJJbN++HVeuXEF8fDyGDRuGXr16NWs7Li4uGDZsGD799FNMmDAB1tbW+Pnnn3HhwgUkJiYa2n300UdQq9WYM2dOSz8VIiKzIbk6XwFnKzAfK/ZdBABM7BMEZ1vz/SaEWp+62QoAoHewGzb8bYDh/vBuvgAAtVaHc3lKpGSV4URWGVKyypBeWIGcsmrklFXjlz/zDOvY21iho7cTInycENbOEaGeDght54BAN3uLKwJGRKZxLk+Jf246haOZpQCAzt5OeO2BLhjQRgv1WkxyAAB69+6N3r173/Z2li5divj4ePTu3RsdOnTA9u3b8eqrryI6OtrQZtu2baipqTEkB7Zv345NmzYZ6hIsXLgQrq6umDx5MmJjY287JiKi1sjwpR6TA2bhZHYZDmWUwEoqwbQBwaYOhyyMo+1fHyuvL05YR2YlRaS/CyL9XfBof30fVNaocSq7HKevKHDmihLn8hU4n1+BKpUWJ64mEa5lJZUg0M1OnyzwdERoOwcEu9sjwM0Ofq52sLG6c/UMiMgyVKk0eH9nGj7fp5+a0N7GCs8ndMK0gSGQWbXd5KNFJQfqLFy40Ohnc4WGhuL06dP47bffUFpaitdffx1du3Y1avPss89Cq9Ua7nt7exsuQxgyZIhhuYfH3a3QS0R0N9XVFNOx0r1Z+PB3/aw794d7wM/VzsTRkKWRW/+VELCTNZwcaIiTrQwDOngafVOn0epwqbgK5/KUOJenQEZRJS5evVWptLhUXIVLxVXYda5+sWgvJzl8nGQI9nRCoLs9Atz0iYO65IFtM2IjIsvz2+l8LNzyJ3LK9IXoh3bxxmuju8Kf/xctMznQEuzt7TFmzJhGHx8+fLjR/Z49exrVKCAiagskV7MDTA20fufylPj1dD4kEuDxfn6mDocsnF0jIweaytpKig5ejujg5YiR3X0Ny4UQKFDWIqOwLllQgYtFlcgqqUZWaRWqVFoUKGtRoKzFydyKBrftai+Dj7MtfFxs4eNsC++636/e93G2hau9zHB8IyLLkFNWjYVb/sRvp/MB6GudLBrdFQldGp71ri1icoCIiG5Z3Udnjhxo/Zbt0o8aGNbVB6Ee/HaE7qzmjBxoDolEAu+rJ/T3hBmPzhRCoKxKjcsllTibVYhytRVyyqqRXaq/1SUPyqrUKKtS42xe49N7ya2l8HGxNezL09EGno5ytHOSo93Vn56Ocng42rTpIchE5kCrE/j60CW8vf0cqlRaWEslmHlve8wa1AH2NjwdvpZFvhrh4eGmDoGIqE2om6ucuYHW7WJRJbaezAUAPBsXBkBj2oDI4nUPcL3r+5RIJHBzsIGLnTX87bRwd3c3qtIthICiWoM8RY3+Vl6NvPLav35X1CJfUYOSShVqNTpkFlchs7jqpvt1s5cZkgUN/7SBh4Mcbg4yo0sviOjOSy9Q4uX1J5F8uQwA0DfEHf8eF4lO3k6mDayVssjkwMSJE00dAhFRm1A36lYwO9Cqfbw7HToBDAr3Qhc/Z5SUlJg6JLJQG/42AIczipHYJ9DUodQjkUjgYi+Di70MnX0aPzGoUWtRoKg1JBEKFDUoqlChUFmLoopaw8/iShW0OoHSKjVKq9Q4n9/wZQzXcpRbw93Bxujm4WADt+t+r/vpJLfm5Q1Et0Ct1eHTPRfwwc50qLQ6OMqtMX9EOCb1CbrlKVLbArNNDuTm5iI3N7dJbf38/ODnx+sriYhampQ1B1q9nLJqbEzOAQA8G9/BxNGQpesd7IbewW6mDuO22MqsEORhjyAP+xu20+kESqtUKKyoRZFShcKKmqs/a1GkrEXhNYmEkkoVdAKoqNWgolaDyyU3H5EAADZWUrg5yOBmbwMPRxu4O8jhbi+Dm4MNXO1kcLW3gYu9zPC7q50MznYyWPHkh9qwU9nl+Pv6E4ZLhwaFe+HNcZHwdeEldTdjtsmB5cuXY9GiRU1q+9prr93yzAVERHQDnK2g1ft0zwVodAIDwjzQO9gNOp3O1CERWQSpVAIPRzk8HOWAz43b6nQCiho1iitVKK1U1ftZUqlCSZX+Z3GFCqVVKlSptFBpdchX1CJfUdus2JxtrfXJAnsZXK5JHDR0X7/MBi52MthYs34CmS+VRof3d57HJ3syoNUJuNnLsHB0V4zu4ccROE1ktsmBefPmYe7cuU1qa2tre2eDISJqo+pGDvB8s3W6Ul6N1UeyAADPcdQAkclIpZKrJ+s2QLumrVOj1uqTBg3cSqtUKKtWo7xKjbJqFcqq9L8ra/X1RBQ1GihqNLjczCuIbKylcLa1hpOtzPDTydb66k1m9NO5gWVOttasq0AmcS5PiblrUnDmigIA8EAPP7z2QBd4OspNHJl5MdvkgK2tLU/6iYhMjLMVtG7LdqVDpdGhb4h7vcruRNS62cqs4OdqB79mzL2u1uqgqFajrFo/I0P51cRBWZX6ajJBZXjs2vvl1WoIof/mtahChaIK1S3HbS2VwM7GCvY2VrC3sYadTP+70TIbK9gbllvDxloKmZUEMivp1Zv+d2upBLKroxm0WgGNTgeNTkCrE1BrBbRX72u04upyHboHuKJ/ex7v2gqtTuDz/Rl4Z/t5qLQ6uNnL8J9x3TC8m+/NV6Z6zDY5wJoDRESmZ22lTw+czVNi1NJ9eKC7H0Z290WA242v1aU7L7u0Cmuujhp4YWgnDqkkagNkVtK/LnVoBp1OQFmrgbJGDWWNBopq/U9l7dWfNRooav76XWn4XQ1Ftf5npUoLANDohKEd0LzLIVqCjbUUya8OgaPcbE9zqImySqrw4roTSLqoHyIzKNwLSx7sBi8nfoF8q8z2r4Y1B4iITK9noCuGdvHGzrMFSM1RIDVHgcU/n0WkvzMGh3tjcIQXIv1cWBnYBJbtSodaq681wG/RiOhGpFIJXOz09QhulVYnUFGjQZVagyqVFtUqLapUWlSpNH/9rtaiWnX941qotTpodDqoNMLwu1ojoNLqoNbqIJEAVlL9SAJrqQTWVhJYSaWQSSWwunrfWirF9j/zUKvRIa+8Gh28OFWdpRJCYN2xbCza8icqVVrY21jh1VFdMLFPIBPht8lskwOsOUBEZHr2NtZY/lg0iitq8XNqHraezMUfF0sMiYL3d6bBy0mOwRFeiO/shf5hHnC2vfUPn9Q0l4ursO5oNgDghSGdTBwNEbUFVtKrU0XCdMf4hP/tQXpBBQoUtUwOWChFjRqvbDyFrSevAACig93wvwk9bzq7CDWN2SYHWHOAiKj18HCU49H+wXi0fzCKKmqx62wBdp4pwN60QhQoa7EqKQurkrIglQDdAlwxMMwDMR080SvYDbYyFq9qaR/8ngaNTuDeTu0QHeJu6nCIiO4Kb2c50gsqkK+sMXUodAecyCrDrFXHcbmkClZSCV4Y0glP3xfGqTtbkNkmB4iIqHXydJTj4ehAPBwdiFqNFoczSrDzTD72pxUho6gSJ7LKcCKrDB/tvgC5tRTRIW4YEOaJgR080c3fhf/kb1NGYQU2JnPUABG1PXXXmhc0c+pHat10OoHP91/E//1yFhqdgL+rHT6YFIXewW6mDs3iWExy4Pjx41i4cCFOnjyJ0tJSo8fmzZuHefPmmSgyIqK2S25thfs6tcN9nfRzd+WWVeNAehEOXijGgfQiFChrcSC9GAfSi/H29nNwsrVG//YeGBjmgYEdPNHBy5HXDzbTBzvToBPA4HAv9Ax0NXU4RER3jZeTvhBjPpMDFqOkUoUX16Zg17lCAMDwSB8sebD7bdXHoMZZRHKgoKAACQkJePTRRyGTySCVShETE4OVK1dCqVRi9OjRpg6RiIgA+LnaGUYVCCFwobDianKgCIcyiqGs0eC30/n47XQ+AMDf1Q4P9PDDhOgAtG/naOLoW7/0AiU2n9DP5PM8Rw0QURvj5Xx15AAvK7AISRdLMGtVMvIVtbCxluJfo7pgcr8gfmlwB1lEcmDbtm2IiYnB+++/j4ULF0IIgdmzZ+Opp55C7969UVBQgC5dupg6TCIiuoZEIkEHLyd08HLC1AEh0OoEUnPKceBCEQ6mF+PIpRLklFXjkz0X8OneCxgR6YsXhnZCGJMEjXr3tzQIAdzf1RuR/i6mDoeI6K6qGzlQoOTIAXMmhP4ygsU/n4VWJxDWzgEfPtILEb7Opg7N4llEciArKwvdunUDADg4OCAnJwcAIJfLMWzYMCQlJSEuLs6EERIR0c1YSSXoEeiKHoGueCauA2rUWvx+tgDrjmZh17lC/HTqCn47nY9/DA/H9IEh/ObgOqk55fjp1BVIJMALQzqbOhwiorvOu27kgIIjB8xVZa0GL284iZ+uzkYwtqcf/jO+G+xtLOK0tdWTmjqAlqDVamFtre8wYWFh2L9/P7RaLYQQOHXqFBwd+S0TEZG5sZVZYUQ3X6x8vC9+nhOLuM7toNLq8MbW03jzpzMQQpg6xFblf7+dBwCM7uGHzj6cwouI2h6OHDBv6QUVGLPsAH46eQXWUgleH9MV7yb2ZGLgLrKI5IC1tbUhOTBy5EiUlpaiS5cu6NatG5KSkjB27FjTBkhERLclwtcZK6f1wYKREQCAFfsv4tvDmSaOqvU4llmK388WwEoqwdwE1hogorbJ3dEGAFCl0qJGrTVxNNQcP5+6gjEf7kd6QQW8neVY81R/PHYPRwnebRaRhlmwYIHhd7lcjqSkJKxatQrV1dWYMGEC/Pz8TBgdERG1BIlEghmx7aHRCSz5+Sze3HYGAzt4slAhgHe2nwMAPNQrAKGeDiaOhojINBxtrCGVADoBKKrVsJVZmTokugmNVoe3t5/Dp3szAAD9Qt3x4SO90O7qKBC6uywiOXDkyBGoVCr07dsXMpkMHh4eeO6550wdFhER3QFPxrbHvrRCHEgvxgtrT2D90/fA2soiBsLdkrqZHmyspJid0NHU4RARmYxUKoGznQxlVWqUV6sNsxdQ61SorMWsVck4nFECAHjy3vZ4+f7Obfp/uqlZxCt/5MgRxMfHw9XVFUOGDMGbb76JAwcOQK1Wmzo0IiJqYVKpBG8/1ANOttZIySrDx7svmDokkxFC4O2rowYe6RcEf1c7E0dERGRaLnYyAEB5Nc8DWrNjmaV4YOl+HM4ogYONFT6a3AuvjIhgYsDELGLkwDPPPINp06bhwIED2L17N7Zt24ZFixZBJpNhwIABePnllzFkyBBTh0lERC3Ez9UOr4/piufXnMB7O9NwRVGDLr7OkFtLoRMC1SotqtU6VKs0qFZr9TeVDjVqLWo1Oqi0Oqg0WqgMv+tvaq2+yKFUCkglEkig/ymzksJBbgUHuTUc5dZwkFvDw9EGPs62+puLLcK8HOFsK7urr8PvZwuQklUGW5kUz8SH3dV9ExG1RkwOtG5CCHx9KBP//uk01Fr9NIWfTumNDl4spNsaWERyAADs7e0xZMgQDBkyBLm5udi2bRuWLFmCHTt2YODAgUwOEBFZmLE9/fFHRglWH8nC939cNnU4AABfF1t08nZCFz9n9At1R3SIOxzld+ZfrU4n8M6v+hkKpg0IhZcTh88SETE50HpV1Gowb8NJbL06TeGIbj5466Eed+z/JDWfRbwTRUVF2LFjB3bv3o1du3bh8uXL6Nu3LyZPnoy4uDjcc889pg6RiIhamEQiwZIHu2N4N1/8djoPBYpaqLQ6WEslsJVZwU5mBTsb/U/bq7/bWkthY20FG2up/mYlhbzud2spZFZSSADohIBO6L/h0AlArdWholaDyqs3Za0GRUoV8hU1yFPUIKe0GnmKGlwp19/2nC/Ex7svwEoqQe9gNzzQww8jIn3g4dhyBZa2pV7BmSsKOMmt8dS97Vtsu0RE5syZyYFW6cwVBZ79LhkZRZWwlkowb3g4nogJ5WwErYxFJAc+/PBDLFq0CPfffz8+/PBDxMbGwtaW36AQEbUF93Vqh/s6tTN1GCivViMtX4lz+UqkXC7D4YvFyCqpRtLFEiRdLMHCLX8iIcILM2LbIzrY7bY+EGl1Av/7TT9q4InYULg52LTU0yAiMmscOdD6rD2ahVd/SEWtRgdfF1t8+Egv9A52M3VY1ACLSA4MHToUaWlp2LNnDx588EHExMQgPj4e8fHxiIqKgpUVpzEhIqI7y8VOhugQ/aUEk/sFAwCySqrwc+oVbD15BSezy7H9z3xs/zMfA8I8MH94BLoFuNzSvraduoKMwkq42svwRExoSz4NIiKzxuRA61Gt0uLVzalYfywbgD6Z/25iT7gzod1qWUQ5yAEDBuC7775DdnY2jh07hnHjxiElJQWjR4+Gu7s7vvjiC1OHSEREbVCguz2evDcMW56Lwa/P34tJfQNhYyXFwQvFeODD/Vi45U9Uq7TN2qYQAh9dnaFh2oAQON3lIohERK0ZkwOtw4XCCoxddgDrj2VDKgFeGtoJK6f1YWKglbOI5EAdjUaDoqIiFBYWorCwEOXl5aiqqkJVVZWpQyMiojauk7cTFo/vjp0v3oexPf0AAF8evISRH+xDekFFk7ez+1whzlxRwN7GCtMGhNyhaImIzFNdckDB5IDJ/HgiF6OX7se5fCU8HeX4dkY/PDeoI6RS1hdo7SwiObBjxw4MGzYMbm5uuPfee7F582ZERUVh/fr1KC0txXPPPWfqEImIiADoRxO8NzEKXz7eBz7OtsgoqsT4jw7g4IWim64rhMCHu9IBAI/2D4arPb+BISK6Vl1yILu0Gs99n4zfTuejvFoNIYSJI7N8tRot/rU5FbNWHUelSot+oe7YNjsGA8I8TR0aNZFF1BzIy8tDjx49MGfOHMTGxsLR0dHUIREREd1QXGcv/DQ7Bk9+cwzHMksx7Ysj+Gp6X9wT5tHoOkkXS3AssxQ2VlLMYK0BIqJ66pIDZ/OUOJunNEyb9/R9YfB3tcVDvQNhK5OySn4LyyqpwrPfJ+NkdjkA4Nn4MDyf0AnWVhbxXXSbYRHJgUcffdTUIRARETWbh6Mc383oh+e+P44dZ/Lx5DdHse7pexDu49xg+4/36GsNPBwdAC9nzspDRHS9uuTA9T65evx8dfOfcHewQa8gN3QPcEG/UHcEezjAx4XH1Fv12+l8vLg2BYoaDVztZXg3sSfiO3uZOiy6BRaRHCAiIjJXtjIrfPhIFKZ8/geOXCrF9JVH8POce+Fib/wBN6ukCrvPFQIAZsa2N0WoREStXoCb3U3blFSqsONMPnacyTdar7O3E3oFuyEqyBVd/VwaTTSQnlqrwzvbz+HTvRkAgJ6Brlg2uRf8XW/+HlDrxOQAERGRidnKrLDisT4Ys2w/LhVXYcHmVCydFGXUZs2RLABAbEdPhHg6mCJMIqJWz9XeBl5OchQoaxtt4+9qB383O6i1OuSX1+CKogbZpdXILq3GzrMFhnZ+Lrbo7OOEcF9nhPs4IdzHGaGeDrCx5lD5vPIazFqVjCOXSgEA0weGYt7wcL42Zo7JASIiolbAxV6G9ydGYfzHB/HjiVxM7BOIgR30RZzUWh3WHtUnByb1DTJlmERErV4nb6cGkwP/GBaOR/oF1RsRUFKpwoXCCpzMLkfy5VKkXC5DTlk1cstrkFteg11XR20BgEQCeDrK4etiC18XW7g7yOFiJ6t3c7K1vnrT/24rs7rjz/tu2ZdWiDmrU1BSqYKT3BpvPdQdw7v5mjosagFMDhAREbUSPQJdMaV/ML48eAn//ukMts2OgUQiwe9nC1CgrIWHgw0SIrxNHSYRUasW5GEPpBsv2/zsQHTzd2lwOj13Bxu4O7ijT4g7noC+2Gt5tRrn85U4e0WBM3lKnMvT/16p0qJQWYtCZa2h+F5T2FhJ4WRrDedrEwdymVECoe4xZ1truNrbwNNRjnaOcjjbWbeKAopancAHO9Pwwe9pEALo4uuMjyb34mg2C8LkABERUSsyN6Ej1h3NwpkrCuw+X4j4zl7YcCwbAPBQ7wAO2SQiugm7Br6l7xHo2qxtuNjJ0CdEnzCoo9MJlFSpkFdegyvlNcgrr0ZJpRrl1X/dFFd/KmvUUNZoUKHSQAhApdWhuFKF4kpVs5+PjZUUHo76ZIG7gw1cbIAOPiUI8nBAoLsdAt3t0c5RfkcTCEUVtZi7OgX70/XT7k7qG4TXHuhiUSMiiMkBIiKiVsXV3gaP9AvCZ/su4ov9F9E/1AN70/RDWkf39DNxdERErd+4KH98vv9ii29XKpXA01EOT0c5Iv1dmrSOTidQodJAWaOBskYNRbXGkDhQ1qihqNE/prh2WbUapVVqFClroazVQKXV4crVhIRBaqHRfmxlUrT3dNTXRvDV10foGeQKZ9vbL6p45FIJnvs+GfmKWtjJrPCf8ZEYFxVw29ul1ofJASIiolZmcr9gfLbvIg5eKMaPJ3JRo9bB39UOXXwbnuKQiIj+Eunvgl+fvxd2Mit8vv8ixvfyN1ksUqkEzrayqyfpza/iX6PWoqiiFkUVKhRX1KJAWYNLeaUoqoGhiOKV8mrUqHU4fUWB01cUwPGr+5YAXfyc0S/UAwPCPBDT0RNy66Z/0y+EMFzmptUJdPByxMeTe6Gjt1OznweZByYHiIiIWpkQTwdE+jsjNUeB+ZtOAQAGR3i1imtOiYjMQaerJ7ALR3c1cSS3x1ZmhQA3ewS42QMAdDodSkoc4O7uDqlUf5mZSqNDblk10goqcPaKAmfzlEjNLUdmcRVScxRIzVHg8/0X4SS3xtCuPhjfyx8Dwjxu+D+lRq3FPzelYkOy/rK20T38sHh8NzjIefpoyfjuEhERtUIjuvkiNUcBrU4AAHoHu5k4IiIiao1srKUI8XRAiKcDhnT5q2htXnkN/rhYjD8uluD3MwXIU9RgQ3I2NiRno4uvM+YkdMTQLt71kgTlVWpM+zIJxy+XQSoBXhkRgSdiQpmgbgOYHCAiImqFegcZJwM6cRgnERE1g4+LLcb09MeYnv7QjRE4mlmKzSk52Jicg9NXFHjqm2NIiPDGv8dGwsfFFoC+8OCUz5Nw5ooCLnYyLHukF2I6epr4mdDdwpLHjVi7di2GDh2KPn364JlnnkFBQcEdWYeIiKghXfyM6wu0b8epooiI6NZIpRL0DXXHm+O64eC8QXgmLgzWUgl2nMnH6A/348wVBapUGjx2NTHg6SjH2qfuYWKgjWFyoAHffPMNpkyZgrFjx+Ktt97C2bNnERcXh9ra2hZdh4iIqDFO11WYbk4RKSIiosa4Odjg5WHh2DYnFp29nVCgrMX0L49g9qoUnL6igKejDdY9fQ86+3DEWlvD5EADXn31VcyePRvPPPMM4uPjsW7dOqSnp2PVqlUtug4REREREZEpdPJ2wtqn70H7dg64Ul6DHWfyAQBLJ/VCqCdHq7VFTA5cJyMjA5mZmRgxYoRhmYeHB/r164ddu3a12DpEREQ3s/LxPpBbS/HR5F6mDoWIiCyQi50MKx6LhrOtvhTdsK4+uCfMw8RRkamwIOF1srKyAAC+vr5Gy319fQ2PtcQ6AFBbW2t02YFCoQCgn6JEp9M1P/i7QKfTQQjRauMjul3s49Sa3NfRE2devx8AWqxPso+TpWMfJ0t2J/p3iIc9Njx9D9Yey8aMmFD+7ViY5ryfTA5cR6PRAABsbGyMlsvlcqjV6hZbBwAWL16MRYsW1VteWlpq2GZro9PpoFQqIYQwzK1KZEnYx8nSsY+TpWMfJ0t2p/q3mzXwVD8vQF2JkpLKFtsumZ5SqWxyWyYHruPhoR9GU1xcjPbt2xuWFxcXw9Oz4Wqdt7IOAMyfPx8vvPCC4b5CoUBgYCDc3Nzg7Ozc6HqmpNPpIJFI4Obmxn+4ZJHYx8nSsY+TpWMfJ0vG/k3NZW3d9FN+JgeuEx4eDnt7e/zxxx/o06cPAECr1eLIkSOYM2dOi60D6EcWyOXyesulUmmr/mOXSCStPkai28E+TpaOfZwsHfs4WTL2b2qO5vQT9qjr2NraYurUqXjvvfeQn6+v2Pnf//4XFRUVeOyxxwztnn32WcycObNZ6xARERERERG1Rhw50IC3334beXl5CAoKgqurK4QQWLNmDYKCggxtMjMzUVNT06x1iIiIiIiIiFojJgca4ODggI0bN6KoqAhlZWUICQmpd63GRx99ZFT5sSnrEBEREREREbVGPHu9AU9Pz0YLCjY2IuBG6xARERERERG1RkwOtCJCCAD6WQtaq7rpU6ytrVkEhSwS+zhZOvZxsnTs42TJ2L+puerOLevONW+EyYFWpG4OysDAQBNHQkRERERERJZCqVTCxcXlhm0koikpBLordDodcnNz4eTkBIlEYupwGqRQKBAYGIisrCw4OzubOhyiFsc+TpaOfZwsHfs4WTL2b2ouIQSUSiX8/PxuOtqEIwdaEalUioCAAFOH0STOzs48IJFFYx8nS8c+TpaOfZwsGfs3NcfNRgzU4YUqRERERERERG0ckwNEREREREREbRyTA9Qscrkcr732GuRyualDIboj2MfJ0rGPk6VjHydLxv5NdxILEhIRERERERG1cRw5QERERERERNTGMTlARERERERE1MYxOUBERERERETUxjE5QM2SlZWFo0ePQqFQmDoUomaprq5GSkoKsrOzG20jhMDp06eRkpICjUZzy22ITCklJQX79+9v8LHq6mocO3YM6enpja7flDZEppKWlobTp0+jsZJZhYWFOHLkCAoKChrdRlPaEN1tGo0GaWlpOH78OEpLSxttd+HCBRw7dgxVVVW31YaoIUwOUJPU1NTgwQcfROfOnTFlyhT4+Phg6dKlpg6L6KYKCwsxY8YM+Pr6Ytq0aejRowf69+9f78QnPT0dkZGRiIuLw5gxYxAUFIQDBw40uw2RKe3cuRN9+vRBbGxsveTVpk2b4Ovri4kTJyI6OhoDBw5EUVFRs9sQmUJSUhIiIiJw3333YcqUKYiKisLZs2eN2vz9739HYGAgpk2bhqCgIMyePbteEqEpbYjutt27dyMsLAyDBw/GE088AX9/fzz55JPQ6XSGNqWlpYiLi0NUVBQmTZoEX19frFmzxmg7TWlDdEOCqAnmzZsnAgICRG5urhBCiE2bNgkA4vDhwyaOjOjGjh07Jj7//HOhUqmEEEJUVlaKIUOGiD59+hi169OnjxgxYoTQaDRCCCGeffZZ4ePjIyorK5vVhshU8vPzRVBQkHj++ecFAKFWqw2PZWVlCTs7O/G///1PCCGEUqkUPXr0EA8//HCz2hCZQmZmpnB2dhYvvvii0Gq1Qgghzpw5I3bu3Glo8+233wo7Oztx7NgxIYQQJ06cEPb29uLzzz9vVhsiUwgKChLTpk0TOp1OCKHvm1ZWVmLVqlWGNo8++qiIjIwU5eXlQgghli5dKmxsbMTFixeb1YboRpgcoCbx9vYWCxcuNFoWGRkpnnrqKRNFRHTrvv32WyGRSERNTY0QQoiTJ08KAGL//v2GNrm5uUIqlYp169Y1uQ2Rqeh0OjFs2DCxZMkS8c0339RLDrz11lvCzc3NaNmXX34prK2tRWlpaZPbEJnCrFmzRFBQkFHfvN6gQYPEQw89ZLRs4sSJYuDAgc1qQ3S36XQ6YW9vLz755BOjZa6uruKDDz4QQuiTtTY2NmLFihWGNhqNRnh6eoo33nijyW2IboaXFdBN5ebmIj8/H7179zZa3rdvXxw/ftxEURHduiNHjiAgIAByuRwADP342j7u6+uLgIAAw2NNaUNkKu+88w6qq6vx97//vcHHjx8/ju7du8Pa2tqwrG/fvtBoNDh16lST2xCZws6dOzF8+HDodDokJyfj0qVL9S4FOH78+E0/pzSlDdHdJpFI8Oabb+Ktt97Cd999h19//RUzZsxAcHAwHn30UQDA6dOnoVKpjPqvlZUVevXqZei/TWlDdDPWN29CbV1JSQkAwMPDw2i5h4eH4TEic7Fv3z589NFHWLZsmWFZSUkJ7O3tYWtra9T22j7elDZEppCUlIR33nkHR48ehVTacM6/pKSkwWN43WNNbUNkCrm5uSgtLUVERAScnJyQk5MDf39/rFq1ChERERBCoKysrMH+W1VVhdraWtjY2Ny0TV3CmOhuGz16NLZs2YKXX34Z7dq1Q3Z2NpYsWQI3NzcAN/4sfuXKlSa3IboZjhygm5LJZAD0RQmvVV1dDRsbG1OERHRLUlJSMGbMGDzzzDOYOXOmYblMJkNtbW29b6Ku7eNNaUNkCo8++igeeeQRZGZmYv/+/Th//jwA4MCBA4bZOWQyWYPHcABGffxmbYhMQSaTYevWrdi8eTNSUlKQlZUFb29vPPbYYwD037xaW1s32n9lMlmT2hCZQk1NDeLi4hAeHo6srCykpKRg9+7dmDt3Lr788ksATfsszs/r1BKYHKCbCgwMhFQqRU5OjtHynJwcBAUFmSgqouY5ceIEEhISMHnyZLz33ntGjwUHB0Or1SI/P9+wTKfTIS8vz9DHm9KGyBQCAwNx5MgRzJs3D/PmzTNUpv7nP/+JPXv2AND334aO4QCM+vjN2hCZQkhICGJiYhAZGQkAsLW1xbRp04ymagsKCmqw/wYEBBhG1DSlDdHdduLECWRlZeFvf/uboR9GRkbivvvuw5YtWwDoj88AbvhZvCltiG6GR0K6KXt7ewwYMMBwgAKAyspK7NixA0OGDDFhZERNc/LkSQwePBgTJ05scArO2NhYyOVyoz6+Z88elJWVGfp4U9oQmcLOnTuxf/9+w+3VV18FoJ8aa/LkyQCAIUOG4OTJk8jMzDSst3nzZvj7+yMiIqLJbYhM4f7770dubq7RsuzsbDg6OsLOzg6Avv9u3brVMLpLCIEtW7YYHZ+b0obobmvXrh0AGEZ61cnOzjY81qFDB4SGhhp9BsnOzsaxY8cM/bcpbYhuynS1EMmc7N69W8hkMjFv3jyxefNmkZCQIMLCwoRSqTR1aEQ3lJaWJtq1aydiYmLEvn37jG51sxUIIcSiRYuEs7OzWL58ufj+++9FUFCQeOSRR4y21ZQ2RKbW0GwFWq1WDBw4UERFRYkNGzaIt99+W1hbW4uvvvqqWW2ITKGoqEgEBgaK6dOni19++UUsW7ZMuLi4GFVgv3jxonBzcxOTJ08WW7ZsEVOnThXOzs4iLS2tWW2ITGHkyJEiODhYfPnll+Lnn38Wjz/+uJDJZIZpN4UQYvXq1cLa2losXrxYbNy4UURHR4s+ffoYplduahuiG5EIcd0FtESNOHDgAJYtW4b8/Hx069YN8+bNg4+Pj6nDIrqhnTt34rXXXmvwsfXr1xv14S+//BIbNmyASqXC0KFDMWvWrHrX6TWlDZEp/frrr3j99dexZ88eWFlZGZYrlUq8/fbbOHToEJydnTF16lSMHj3aaN2mtCEyhdzcXLz11ltITU2Fl5cXHnroIYwfP96ozfnz5/H222/jwoULCA0NxUsvvVRv1EtT2hDdbbW1tVi+fDn27NkDpVKJsLAwPPvss+jatatRu59//hmff/45ysrK0K9fP7z88stwcXFpdhuixjA5QERERERERNTGseYAERERERERURvH5AARERERERFRG8fkABEREREREVEbx+QAERERERERURvH5AARERERERFRG8fkABEREREREVEbx+QAERERERERURvH5AAREdWTmpqKDRs2YN++fU1qX1ZWhtWrV0OlUjV4/3pFRUVYvXo1dDpdi8Xc0ioqKrB69WpUV1ebLIbmvg93ws3ey6a6m6/n0aNHkZqaesf3cyOnT5/Gjh07TBrD4cOHceTIkRbZ1v79+5GcnNwi27JUGzZsQG5u7l3b3+rVq5Gfn9/g/ZqaGqxdu7ZVH2OJqPVhcoCIiIy88cYbGDRoEFatWoVDhw41aZ1Lly5h0qRJUCgUDd6/3tmzZzFp0qTbPuG8k/Ly8jBp0iQUFxebZP+38j7cCTd7L5vqbr2eJSUlGDlyJKytre/ofm5m48aNWLBggUlj+PDDD/Hpp5+2yLbeeecdfPHFFy2yLUs1derUu5pAmTRpEk6dOtXgfVtbW3z88cdYsWLFXYuHiMyfaf9zEhFRq7N8+XL897//xZQpU5q8jpubGxITEyGXy+9gZG3LrbwPd4K5vbdvvfUW4uLiEB4ebupQLEpsbCzc3d1NHQY1w/z58zF16lRMmzYNNjY2pg6HiMwAkwNERK3Ijh07UFRUBIlEAl9fX0RFRcHJyaleO5VKhcOHD6O8vBxdunRBWFiY0eObNm1C7969IZFIkJycjKCgIERFRQHQfxOckpICZ2dnDBgwALa2tgCA8vJy/Pzzz8jPz0dqaipWr16Ne+65B8HBwTdcDwBcXFwwduzYWzqBTE1NRUZGBiIiItCxY8d6j99ovzk5OTh8+DAefPBBwzKlUomffvoJY8aMgZ2dHYqKirBjxw5MmDAB586dw4ULF9CxY0d07ty53r5OnTqFS5cuITw8HBKJxOixmpoa/PDDDwAAmUyG0NBQ9OzZE1LpX4Pw6vb18MMP4/jx47h06RJiYmKwZ88exMTEwN/f39BWq9Vi/fr19ZY39j54e3vfdP91SkpKkJSUBLlcjv79+8POzs7o8eLiYhw+fBhyuRy9evW64Unf9e9tS72eN4tFCIGNGzeiU6dO6Natm6H9wYMHoVQqcf/999fbVm1tLT777DN8++23hmWnT59Gbm4uYmNjceLECeTl5aF///7w8vJCbW0tDhw4AJVKhXvuuQcuLi71tnnhwgWkpqbCy8sLUVFRRv0PAPLz83H8+HHY2dkhOjoaDg4ORo+r1WqkpKSgsLAQvXr1go+PT2MvtUFycjIuXbqEgIAA9OnTx+i1u/b5HDp0CAUFBZgwYQIA/aUbe/fuhZOTk+Hv/XpCCBw7dgzZ2dlo3749unfvbvT47t274e7ujoCAABw+fBh2dnaIj49Hv379YG9vX69dcHAwjh8/Dq1Wi/79+9d7/kqlEnv37oWzszOioqKQmpoKKysr9OnTp8H4jh49ivT0dACAh4cHevToAS8vrybFCOj75+HDhyGVSjFgwAC4uroa1qusrMSPP/6IUaNGwdHR0bB83bp1GDhwIPz8/KDRaLB+/XoMGTIElZWVhvc+Ojq6XqyZmZlISUlBcHBwvdfxegcOHICdnR169eoFQH9cO3z4MO6//364ubkBAHbt2oV27dohMjISmzdvRnV1NaRSKQIDAxvsezeTkJAAiUSCjRs3YuLEic1al4jaKEFERK3GggULRGJiopgwYYKIjo4WXl5eYt++fUZtjh8/LoKDg0VUVJQYNWqU8PT0FE899ZRRGw8PDzF06FARHBwsxo4dK7766ishhBCvvPKKsLe3FwkJCSI8PFwEBASIEydOCCGEyMrKEomJiUIqlYrY2FiRmJho2PeN1quLCYAoLCxs8P719u3bJwCI4cOHi8jISDF48GAhl8vF//3f/xm1u9l+N23aJBwcHIzWOXPmjAAgsrKyjPb1wAMPiF69eonhw4cLuVwulixZYrTe7Nmzhb29vRg6dKgICwsTw4cPN9pOWVmZSExMFImJiWLcuHEiMDBQ9O/fX5SVldV7XiNHjhQ9evQQEyZMEH/++ae47777xKxZs4z2t3XrVmFjYyOKioqMljf2PjRl/0IIsWzZMmFvby/69esnBg0aJLp27SrOnTtnePyjjz4SLi4uIiEhQQwePFi4urqKNWvWNPg+CVH/vWyp17MpsSxatEj4+PiIgoICIYQQJ0+eFHK5vNF4d+3aJaysrERFRYVh2RtvvCGCg4NFx44dxZAhQ0RUVJRwcHAQK1euFJ06dRJDhw4V3bp1EwEBASI7O9uwnkajEdOnTxeenp5i5MiRIioqSoSFhYnU1FRDm6+//lo4OjqKwYMHi4SEBNGpUydx8OBBw35DQkJEVFSUGDx4sBgwYIBwcHAQv//+e6OvdVVVlRg6dKjw9PQUw4cPFz4+PiImJkaUl5cbPZ+QkBDRvXt3ER8fLxITE4UQQvz555/Cx8dHhIeHi4SEBBEaGip69uwpnnjiCcO6eXl5ol+/fiIsLEw88MADIjg4WAwePFgolUpDm7pYQ0JCxMiRI8WiRYuEEEKMGTNGPPvss0btBg4cKMLCwsSIESNEp06dRGhoqMjLyzO0OXHihPDy8hIRERGNxnS9FStWGPp5XFyc4b26VmMxfvPNN8Le3l7ExMSI/v37CycnJ/HDDz8Y1rt48aIAINLS0oy2J5fLxY8//iiEEEKpVAoAYtSoUaJTp05i1KhRws3NTUyaNMloneXLlwu5XC7i4uJEr169xKBBg4y2c70FCxaI+Ph4w/2XXnpJADAcm4UQwsvLS6xdu1YIIcRTTz0lEhMTxUMPPSS6dOki2rdvL86cOWO0TQDit99+a/S+EEJMnDhRTJ48ucGYiIiux+QAEVEr9uabb4rIyEjDfZVKJUJCQsS7775rWFZQUCB8fX3FqlWrDMs8PDxEZGSkUCgUhmX79+8XEonEcMKv1WrFgw8+KPr27St0Op2h3fUfcJuy3q0mBx599FHDNjZt2iSsra3F+fPnm7zf5iQHFixYYGjz7bffCrlcLqqqqoQQQuzdu1dYWVmJo0ePGl7n+Pj4eiez16qtrRUDBw402m7dvubMmWPU9ttvvxXu7u6ipqbGsGz8+PHi4YcfbnDbQtR/H5qy/7rXbP369YZlGRkZ4uTJk0IIIQ4fPiycnJzEqVOnDI9v3bpVODk5GU7Ar9dYcuB2X8+mxKLRaMTAgQPFyJEjRVVVlejatauYOnVqo6/Jf//7X9G+fXujZW+88YaQSCSGk3KdTidiY2OFVCoVBw4cEELo+1avXr3E/PnzDeu99dZbolu3bkYn5i+99JLo16+f4X6HDh3ERx99ZLifl5dn2Gbdfq89WZsxY4a49957G43/3//+twgICDCcYBcXF4uwsDDx97//3ej5ABCbNm0yWjc+Pl6MGzdOaLVaIYQQv/32mwBgdCI+YsQIMX36dEObmpoaMXDgQPGPf/zD0Gbw4MHC2dlZZGZmGm2/oeRAu3btRG5urhBC/x5HRESIf/3rX4Y29957rxg/frxhf7///nu9mG7mp59+Eo6OjkZJsIZizMvLE46OjuLDDz80LFu4cKHw9PQ0rNuc5MDYsWOFWq0WQghx6tQpAUAkJycb9mVvb2+UtHj22WcFgEb/Znfs2CFsbW0Nx4Do6GgRHR0tHn/8cSGEEKmpqQKAyM/Pb3D9J598UowaNcpoWVOSA2+++abo1KlTg9skIroeCxISEbUyly9fxvbt27FmzRrIZDKkpqaiqqoKgH7YaWZmJry8vLB+/XqsW7cOu3btQlhYGHbt2mW0nccff9zokoTVq1cjNjYWMTExAACpVIr58+cjKSkJFy9ebDSeW12vKV566SXDkOmxY8eiffv22Lhx4x3Z79/+9jfD73FxcaitrUVmZiYAYM2aNYiPj0fv3r0B6IftP//88w1uJyUlBZs3b8bGjRvh7++PpKSkem1mz55tdP/BBx+EEAKbN28GoB/6vHXrVkyfPr3Zz+NG+//666/Rr18/o8ssQkNDDcPyv/rqK3To0AFnz57FunXrsHbtWlRUVECtVuPo0aPNiuN2X8+mxGJlZYVvv/0W+/fvR79+/VBdXY2lS5c2GlNRUZFhiPa1OnbsaBh2LpFI0K9fP0RGRmLAgAEA9H2rb9++OH/+vGGdlStXokePHvj1118N8bm7uyMpKQmVlZUAADs7O5w5c8ZQWNPb29uwTQDo0KEDEhISjF6nc+fONRr/6tWrMX36dHh7ewMA3N3d8be//Q2rV682ahcYGIixY8caPe9du3bhxRdfNFxmkpCQYBjCDgAFBQXYtm0bOnbsiI0bN2LdunXYvHkzQkND6x07xowZg6CgoEbjrDN27Fj4+voC0L/HAwcONDy/wsJC7N27Fy+88IIhpvj4+AaH51+vuLgYv//+O9auXYvy8nJUV1fj9OnTN4xx69atkMlkePrppw3LXn75ZSgUCuzcufOm+7zezJkzDUUtIyMj4enpaXhuP/74IxwdHfHYY48Z2v/jH/+44fYGDBgAnU6Hw4cPQ6FQ4MSJE/jXv/5leO13796NLl26GF1CkZaWhm3btmH16tVwcXFp8FhzM25ubigqKmr2ekTUNrHmABFRKzJr1iysXLkSffr0gaenp2Hat8LCQgQHB+PSpUuwsbHBli1bjNbz9/dHp06djJbVfWivk5mZifbt2xstq6tV0NBjt7teU4SEhBjdDw0NNZxgtvR+r72uvu76+ZqaGgD6hExDsVyruLgYQ4cORW5uLqKiouDs7Gx0Mnmt6197W1tbTJ48GV988QUmTJiAb775Bl5eXhg6dGiT42/K/i9fvlyvH1zr0qVLKC8vx/r1642Wjxkzpt614jdzu69nU2MJCQnBE088gf/973/4/vvvG6zBUcfR0dFw4n6t6xMGcrm8wWV18dfF5+LiUi++CRMmoLq6Gg4ODli+fDmefvpptGvXDjExMRg3bhymTZtmOKm8vpbD9fu4XmN9Pjs7GxqNxrDd6/vX5cuXATT893Tt8wGAQ4cOISUlxahdv379jO5fv/3GNPT8CgsLAQBZWVkNxnT9/et9/PHHePnllxEZGQk/Pz/IZDJIJBIUFBTcMMbMzEwEBwfDysrKsMzOzg6+vr6GY0pz3Oi9u3z5MoKCgozqfQQEBNxwhgw7Ozv07dsXu3btQkVFBbp06YJhw4ahoKAAly5dwu7duxEXFwcA0Gg0SExMxI4dO9CvXz+4urqisLCw3mvQFJWVlTf8myEiuhaTA0RErURycjKWLVuGtLQ0w0nw4cOH8dNPP0EIAQBwdnaGSqXCihUrjApqNeT6AnCenp71ppErKSkxPNaYW12vKUpLS42KwJWWlhq22ZT9SqXSevN43+jkqzEeHh4oLS2tF9u13n//fQD6k566k4B58+bhl19+qbe9horvzZw5E1FRUcjOzsbKlSsxderUBosJNqYp+3d1db3hVIHOzs4ICwur9010S2vK69nUWM6fP49PP/0UXbp0wZIlSzB+/PhGC1926tQJWVlZ0Gq1RieJt8LZ2RkPPPAAXnnllUbb9O/fHykpKcjOzsavv/6KhQsXIjk5GR999NEt7dPT09PQx+uUlJTAzc3N6MTz+v7l4eEBQP8aX1vcsrS01FCQz9nZGYD+G+5rRzc0pLHikc1Rd3JdVlZWL6aGCj8C+oKSc+bMwZo1azBu3DgAQHV1NdauXWs4BjYWY0OvXd3+rj1eADA6Zmg0Gmg0mmY9t4b6d0VFxU23ExcXh927d6OyshLx8fGQyWQYMGAAdu3ahb179+LDDz8EAGzZsgW7du1CRkaG4b1dvXo1du/e3aw4AeDixYsNFgslImoILysgImol8vLyYGdnZ5gdAEC9by3j4uJgY2OD5cuXGy3XarXIz8+/4fZjYmKwa9cuow+169atg5eX1w2/bb7V9Zqirvo+oP9mMzk5GQMHDmzyfv39/VFdXY3c3FxDm+uHSDdFTEwMdu7cCaVSaVhWd3lDnby8PISFhRlO0jQajeEygabo3r07evfujVmzZiE1NRWPP/54s2Jsyv6HDh2K33//HdnZ2YZlOp3OkDAYNmwYdu/ejbNnzxqtV1RUZBga3xKa8no2JRa1Wo3Jkydj5MiROHjwIMrKym54sh4XF4eampp634zfimHDhmHlypWora01Wp6Tk1Pv94CAAEyfPh0zZ87E4cOHb3mfMTEx9V6nuhktbiQwMBBBQUFGf095eXk4ePCg4X7nzp0REhKCTz75pN761z6nlhIUFITAwECjPlpUVGQU0/WKi4uhVquNTmY3bNhQLzHQkJiYGGRlZRldHrN9+3ZUVlaif//+AAAfHx9IpVLDbAgAsG/fPmi12mY9t4EDByIjIwOnTp0yLLv+fWtIXFwcDh8+jO3btxtGCcTFxeGjjz5CQUEB7rvvPgD6987T09OQGADq/y9oqgMHDhhd2kJEdCMcOUBE1Ercc889cHR0xIQJEzBq1Cj88ccfWLdunVEbHx8fvPfee5g1axbOnj2Lfv36ITs7Gxs2bMB//vMfjBo1qtHtT506FZ988gni4uLw1FNP4fLly3j33Xfx2Wef3XAKwltdrynefvttFBUVwcfHBx988AHuu+8+wxR1Tdlvz5490a1bN0yYMAGPP/44zp8/j1WrVjU7jsceewzvvfceBg0ahCeeeAJnzpyp9432mDFjMHbsWLz66qsICAjAN998g7y8PKNkzs3MnDkTTz75JOLi4upNP3kzTdn/lClTDFMfzpo1C/b29lizZg3eeOMNxMXFYcqUKdi4cSNiY2Mxe/Zs+Pr64tSpU9i2bRuSk5NbbC70pryeTYnltddeQ15eHn799Ve4uLjg22+/xaBBgzB8+PAGT3g8PT0xduxYrFq1ylDv4FYtXrwYsbGx6Nu3Lx5//HHIZDIcOHAACoUCW7duBaC/rv/ee+9FdHQ0FAoFli1bhjlz5tzyPl9//XX07t0bY8eOxciRI7Fz507s37//pgkHqVSKJUuWYOrUqVAqlQgODsbHH39sdHmGRCLBF198gQceeADl5eUYOXIkSktLsW3bNgwfPhzz5s275bgbi+nNN9/EE088AYVCgaCgIHz66aewt7dvdGSCn58f+vTpg8cffxxPPvkkMjIy8NlnnzVpFEivXr0wbdo0jB49Gi+99BI0Gg2WLFmCOXPmGKZItbGxwcSJEzF79mxcvnwZZWVl+Oqrr5o1ggcAoqOjMWHCBIwcORIvvvgiFAoFPv3005vGOWDAAAgh8Oeff+Lee+8FoE8OLFiwwKjewP3334+XXnoJM2fORP/+/bF9+/Zbqptw7tw5nDlzxqg2AhHRjXDkABFRK+Hm5obDhw+jQ4cO2L17N4KCgrB3714kJiYafch/+umnkZSUBHd3d+zduxeA/hv1axMD48ePr3fSamVlhd27d+OJJ54wFFXbsWNHvQ+OEyZMMBoG3JT13NzckJiYaDhpv/7+9dq1a4fExEQcOnQItra2OHbsGJ588kn8+OOPzdpvXZuEhAQcOnQIPj4+2LlzJxITEw1zstft69oP7nK5HImJiYbrzmUyGfbu3YsHHngASUlJ8Pf3N7z2ddsZOXIktm7diqKiIhw5cgQzZ87El19+iWHDhtV7Xo2dJNQVkWtKIcLr34em7N/a2ho//fQT/vOf/+D8+fO4cOEC3n77bcO3lFZWVvjhhx/wySef4MqVK/jjjz/QqVMnJCcnN3pd8vXvZUu9njeLpbCwEJmZmfjuu+8M242NjcV7772HX375pdFvkxcsWICvv/4aCoUCANC1a1cMGTLEqE337t0xaNAgo2W9evUynLAB+mvaU1JS8NRTT+HkyZM4d+4cxo4da1Tv4/jx44iOjsaRI0dw+fJlfPHFF5g/f36j+w0MDDQqFnm9kJAQnDhxAt27d8e+ffvQvn17pKSkoEuXLoY2DW0XACZNmoSffvoJJSUlSE9Px7vvvotFixahb9++hjbx8fE4ffo0oqOjceDAAZSVleE///mPUWIgPj4ePXr0qLf92NhYo4RLQ+169+6N2NhYw/0pU6Zgy5YtKC4uRnp6Ov773/+iT58+N7wGfvv27Rg1ahT27t0LrVaL/fv349FHH0VAQMBNY1yxYgXefvttnD59Gunp6Vi+fDneeecdozYrV67Ec889hyNHjkCtVmPnzp2YPHmy4W9NJpMhMTGx3iVTY8aMMarh8M033+Dll1/G8ePHodFoDHFe+zd7PTs7O7z44ouYM2eOoU/37dsXkyZNwnPPPWdoFxYWhkOHDsHBwQH79u3DPffcg59//hmJiYlG20tMTISPj0+j95cuXYoZM2YYClwSEd2MRDRlrBYRERHdtq+//hpz585FTk4O7OzsTB2OxXrnnXfQvXv3ZhV8pJZXVlYGFxcXw0iB0tJShIWFYenSpZg8ebKJo7NsNTU1ePrpp/G///2vXnFFIqLGMDlARER0h2VkZGD37t1YuHAhnnzySSxYsMDUIRHdcQcOHMCCBQswfvx4aLVafPbZZ7C1tcWBAwdga2tr6vCIiOg6TA4QERHdYbt27cKKFSvQs2dPvPDCC7ddSZ/IXBw4cACbNm1CZWUlevTogenTp7dYbQsiImpZTA4QERERERERtXEsSEhERERERETUxjE5QERERERERNTGMTlARERERERE1MYxOUBERERERETUxjE5QERERERERNTGMTlARERERERE1MYxOUBERERERETUxjE5QERERERERNTGMTlARERERERE1Mb9P+NoR2jNG5xmAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "surface_index = np.arange(len(y_plus))\n", + "fig, axes = plt.subplots(3, 1, figsize=(10.5, 8), sharex=True)\n", + "axes[0].plot(surface_index, force_norm)\n", + "axes[0].set_ylabel(\"|forceCoeff|\\ncontribution magnitude\")\n", + "axes[0].grid(alpha=0.25)\n", + "axes[1].plot(surface_index, shear_norm)\n", + "axes[1].set_ylabel(\"|wallShearStress|\\nviscous loading\")\n", + "axes[1].grid(alpha=0.25)\n", + "axes[2].plot(surface_index, y_plus)\n", + "axes[2].set_ylabel(\"yPlus\\nwall-distance diagnostic\")\n", + "axes[2].set_xlabel(\"aerofoil boundary face index (mesh ordering around wall)\")\n", + "axes[2].grid(alpha=0.25)\n", + "fig.suptitle(\"Same surface fields as line plots; useful for spotting localized peaks\", y=0.995)\n", + "fig.tight_layout()\n" + ] + }, + { + "cell_type": "markdown", + "id": "3dd1357a", + "metadata": {}, + "source": [ + "### Reading the surface-field plots\n", + "\n", + "- The colored aerofoil plots show where each final wall quantity is located in physical space.\n", + "- The line plots show the same values in boundary-face order. Peaks identify localized regions that may be leading/trailing edges or high-gradient wall zones; the face index is mesh ordering, not a physical distance unit.\n", + "- `forceCoeff` and `wallShearStress` are vector fields. Because these charts use vector norms, they show intensity. They do not distinguish forward/backward or upward/downward direction.\n" + ] + }, + { + "cell_type": "markdown", + "id": "77f42737", + "metadata": {}, + "source": [ + "## Final volume fields\n", + "\n", + "`40000/U.gz`, `40000/p.gz`, and turbulence fields are cell-centered OpenFOAM volume fields. These arrays describe the solved flow field over cells; they are not directly indexed by mesh vertices.\n", + "\n", + "Fields summarized below:\n", + "\n", + "- `U`: velocity vector. `|U_xy|` is speed in the 2D plane.\n", + "- `p`: OpenFOAM incompressible pressure, commonly pressure divided by density (`p/rho`), so values are in velocity-squared units rather than Pascals.\n", + "- `nut`: turbulent kinematic viscosity from the turbulence model. Larger values mean the model is adding more eddy viscosity.\n", + "- `k`: turbulent kinetic energy per unit mass. Larger values indicate stronger modeled velocity fluctuations.\n", + "\n", + "The summary table uses min, 1st percentile, mean, 99th percentile, and max so a few extreme cells do not hide the bulk distribution.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "99b5127c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[{'name': 'speed |U_xy|',\n", + " 'count': 258984,\n", + " 'finite': 258984,\n", + " 'min': 9.274197929486949e-05,\n", + " 'p01': 0.21615380686796398,\n", + " 'mean': 32.09927286785441,\n", + " 'p99': 97.0217835728182,\n", + " 'max': 101.66421787590755},\n", + " {'name': 'Ux',\n", + " 'count': 258984,\n", + " 'finite': 258984,\n", + " 'min': -40.1626,\n", + " 'p01': -26.663384999999998,\n", + " 'mean': 24.143595454931,\n", + " 'p99': 57.23976799999999,\n", + " 'max': 64.0673},\n", + " {'name': 'Uy',\n", + " 'count': 258984,\n", + " 'finite': 258984,\n", + " 'min': -4.48142,\n", + " 'p01': -2.5176868000000003,\n", + " 'mean': 12.237414191923309,\n", + " 'p99': 95.408068,\n", + " 'max': 100.078},\n", + " {'name': 'p',\n", + " 'count': 258984,\n", + " 'finite': 258984,\n", + " 'min': -4783.75,\n", + " 'p01': -4551.2704,\n", + " 'mean': -371.1175586042671,\n", + " 'p99': 486.94471999999973,\n", + " 'max': 516.845},\n", + " {'name': 'nut',\n", + " 'count': 258984,\n", + " 'finite': 258984,\n", + " 'min': 6.05286e-19,\n", + " 'p01': 3.6575001e-14,\n", + " 'mean': 0.0006963185103278898,\n", + " 'p99': 0.015897779999999934,\n", + " 'max': 0.0205544},\n", + " {'name': 'k',\n", + " 'count': 258984,\n", + " 'finite': 258984,\n", + " 'min': 1e-15,\n", + " 'p01': 7.4761248e-10,\n", + " 'mean': 1.8431521013304757,\n", + " 'p99': 29.00798499999999,\n", + " 'max': 70.9575}]" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "U = parse_foam_list(SIM_DIR / \"40000\" / \"U.gz\", columns=3)\n", + "p = parse_foam_list(SIM_DIR / \"40000\" / \"p.gz\", columns=1)\n", + "nut = parse_foam_list(SIM_DIR / \"40000\" / \"turbulenceProperties:nut.gz\", columns=1)\n", + "k = parse_foam_list(SIM_DIR / \"40000\" / \"turbulenceProperties:k.gz\", columns=1)\n", + "\n", + "speed = np.linalg.norm(U[:, :2], axis=1)\n", + "summary_rows = [\n", + " summarize_array(\"speed |U_xy|\", speed),\n", + " summarize_array(\"Ux\", U[:, 0]),\n", + " summarize_array(\"Uy\", U[:, 1]),\n", + " summarize_array(\"p\", p),\n", + " summarize_array(\"nut\", nut),\n", + " summarize_array(\"k\", k),\n", + "]\n", + "summary_rows\n" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "ef2f8457", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(2, 2, figsize=(12.5, 8.3))\n", + "for ax, values, title, xlabel in [\n", + " (axes[0, 0], speed, \"Speed distribution\", \"|U_xy| [m/s-like velocity magnitude]\"),\n", + " (axes[0, 1], p, \"Pressure distribution\", \"p/rho [velocity^2 units]\"),\n", + " (axes[1, 0], nut, \"Turbulent viscosity distribution\", \"nut [m^2/s]\"),\n", + " (axes[1, 1], k, \"Turbulent kinetic energy distribution\", \"k [m^2/s^2]\"),\n", + "]:\n", + " ax.hist(values[np.isfinite(values)], bins=80, edgecolor=\"white\")\n", + " ax.set_title(title)\n", + " ax.set_xlabel(xlabel)\n", + " ax.set_ylabel(\"number of cells\")\n", + " ax.set_yscale(\"log\")\n", + " ax.grid(alpha=0.2)\n", + "fig.suptitle(\"Histograms count final cell-centered field values across the mesh\", y=1.01)\n", + "fig.tight_layout()\n" + ] + }, + { + "cell_type": "markdown", + "id": "3ae9f126", + "metadata": {}, + "source": [ + "### Reading the volume-field histograms\n", + "\n", + "- Each bar counts cells whose final value falls in that range. The y-axis is logarithmic so both common values and rare extremes remain visible.\n", + "- These histograms do not show where cells are located. They show distribution only. To connect values to geometry, you would need cell centers and a spatial plot.\n", + "- Wide tails can indicate boundary layers, wake regions, or localized numerical/physical extremes. Use the percentile summary above before focusing on the absolute min/max.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Raw text previews\n", + "\n", + "Use these to connect the arrays and plots back to the files on disk. Previews are capped so huge logs or fields do not blow up the notebook.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- system/controlDict ---\n", + "/*--------------------------------*- C++ -*----------------------------------*\\\n", + "| ========= | |\n", + "| \\\\ / F ield | OpenFOAM: The Open Source CFD Toolbox |\n", + "| \\\\ / O peration | Version: v2112 |\n", + "| \\\\ / A nd | Website: www.openfoam.com |\n", + "| \\\\/ M anipulation | |\n", + "\\*---------------------------------------------------------------------------*/\n", + "FoamFile\n", + "{\n", + " version 2.0;\n", + " format ascii;\n", + " class dictionary;\n", + " object controlDict;\n", + "}\n", + "// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //\n", + "Uinf\t32.137;\n", + "\n", + "application simpleFoam;\n", + "\n", + "startFrom startTime;\n", + "\n", + "startTime 0;\n", + "\n", + "stopAt endTime;\n", + "\n", + "endTime\t40000;\n", + "\n", + "deltaT 1;\n", + "\n", + "writeControl timeStep;\n", + "\n", + "writeInterval $endTime;\n", + "\n", + "purgeWrite 0;\n", + "\n", + "writeFormat ascii;\n", + "\n", + "writePrecision 6;\n", + "\n", + "writeCompression on;\n", + "\n", + "timeFormat general;\n", + "\n", + "timePrecision 6;\n", + "\n", + "runTimeModifiable true;\n", + "\n", + "functions\n", + "{\n", + "\tforces_object\n", + "\t{\n", + "\t type forces;\n", + "\t libs (\"libforces.so\");\n", + "\n", + "\t enabled true;\n", + "\n", + "\t writeControl timeStep;\n", + "\t writeInterval $endTime;\n", + "\n", + "\t patches (\"aerofoil\");\n", + "\n", + "\t p\t\tp;\n", + "\t U\t\tU;\n", + "\t rho\trhoInf;\n", + "\n", + "\t //// Density only for incompressible flows\n", + "\t rhoInf 1.204;\n", + "\t \n", + "\t //// Centre of rotation\n", + "\t CofR (0 0 0);\n", + "\t}\n", + "\t\n", + "\tforceCoeffs1\n", + "\t{\n", + "\t // Mandatory entries\n", + "\t type forceCoeffs;\n", + "\t libs (\"libforces.so\");\n", + "\t patches (\"aerofoil\");\n", + "\n", + "\n", + "\t // Optional entries\n", + "\n", + "\t // Field names\n", + "\t p\t\tp;\n", + "\t U\t\tU;\n", + "\t rho\trhoInf;\n", + "\t \n", + "\t ////Density only for incompressible flows\n", + "\t rhoInf 1.204;\n", + "\n", + "\t // Reference pressure [Pa]\n", + "\t pRef 0;\n", + "\n", + "\t // Include porosity effects?\n", + "\t porosity no;\n", + "\n", + "\t // Store and write volume field representations of forces and moments\n", + "\t writeFields yes;\n", + "\t writeControl timeStep;\n", + "\t writeInterval $endTime;\n", + "\n", + "\t // Centre of rotation for moment calculations\n", + "\t CofR (0 0 0);\n", + "\n", + "\t // Lift direction\n", + "\t liftDir\t (-0.20999398925280716 0.9777026769308202 0);\n", + "\n", + "\t // Drag direction\n", + "\t dragDir\t (0.9777026769308202 0.20999398925280716 0);\n", + "\n", + "\t // Pitch axis\n", + "\t pitchAxis (0 0 1);\n", + "\n", + "\t // Freestream velocity magnitude [m/s]\n", + "\t magUInf $Uinf;\n", + "\n", + "\t // Reference length [m]\n", + "\t lRef 1;\n", + "\n", + "\t // Reference area [m2]\n", + "\t Aref 1;\n", + "\n", + "\t // Spatial data binning\n", + "\t // - extents given by the bounds of the input geometry\n", + "\t /*binData\n", + "\t {\n", + "\t\tnBin 20;\n", + "\t\tdirection (1 0 0);\n", + "\t\tcumulative yes;\n", + "\t }*/\n", + "\t}\n", + "\n", + " momErr\n", + " {\n", + " type momentumError;\n", + " libs (fieldFunctionObjects);\n", + " executeControl writeTime;\n", + " writeControl writeTime;\n", + " }\n", + "\n", + " contErr\n", + " {\n", + " type div;\n", + " libs (fieldFunctionObjects);\n", + " field phi;\n", + " executeControl writeTime;\n", + " writeControl writeTime;\n", + " }\n", + "\n", + "\n", + " turbulenceFields1\n", + " {\n", + " type turbulenceFields;\n", + " libs (fieldFunctionObjects);\n", + " fields\n", + " (\n", + " R\n", + " I\n", + " L\n", + " k\n", + " epsilon\n", + " omega\n", + " nut\n", + " nuEff\n", + " devReff\n", + " );\n", + "\n", + " executeControl writeTime;\n", + " writeControl writeTime;\n", + " }\n", + "\n", + " yplus\n", + " {\n", + "\ttype\t\tyPlus;\n", + "\tlibs\t\t(fieldFunctionObjects);\n", + "\n", + "\tenabled\ttrue;\n", + "\texecuteControl\twriteTime;\n", + "\twriteControl\twriteTime;\n", + " }\n", + " \n", + " wallshearstress\n", + " {\n", + " \ttype\t\twallShearStress;\n", + " \tlibs\t\t(fieldFunctionObjects);\n", + " \t\n", + " \texecuteControl\twriteTime;\n", + " \twriteControl\twriteTime;\n", + " }\n", + " \n", + " mach\n", + " {\n", + " \ttype\t\tMachNo;\n", + " \tlibs\t\t(fieldFunctionObjects);\n", + " \t\n", + " \texecuteControl\twriteTime;\n", + " \twriteControl\twriteTime;\n", + " }\n", + "}\n", + "\n", + "\n", + "// *************************************************************************\n" + ] + } + ], + "source": [ + "print(\"--- system/controlDict ---\")\n", + "print(read_text(SIM_DIR / \"system\" / \"controlDict\", max_bytes=4_000))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- 40000/U.gz header and first values ---\n", + "/*--------------------------------*- C++ -*----------------------------------*\\\n", + "| ========= | |\n", + "| \\\\ / F ield | OpenFOAM: The Open Source CFD Toolbox |\n", + "| \\\\ / O peration | Version: 2112 |\n", + "| \\\\ / A nd | Website: www.openfoam.com |\n", + "| \\\\/ M anipulation | |\n", + "\\*---------------------------------------------------------------------------*/\n", + "FoamFile\n", + "{\n", + " version 2.0;\n", + " format ascii;\n", + " arch \"LSB;label=32;scalar=64\";\n", + " class volVectorField;\n", + " location \"40000\";\n", + " object U;\n", + "}\n", + "// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //\n", + "\n", + "dimensions [0 1 -1 0 0 0 0];\n", + "\n", + "internalField nonuniform List \n", + "258984\n", + "(\n", + "(30.9771 6.60589 7.13234e-22)\n", + "(30.9449 6.59872 0)\n", + "(30.9331 6.59577 -4.37143e-32)\n", + "(30.924 6.59278 2.99688e-21)\n", + "(30.9226 6.5912 -2.39008e-21)\n", + "(30.9275 6.59069 -2.40176e-32)\n", + "(30.9387 6.59126 2.71343e-22)\n", + "(30.9558 6.59283 -4.89239e-22)\n", + "(30.9785 6.59534 -1.07139e-21)\n", + "(31.0064 6.59871 -2.02935e-21)\n", + "(31.0395 6.60292 2.80758e-21)\n", + "(31.0775 6.60792 -3.88218e-21)\n", + "(31.1205 6.61368 -2.44941e-21)\n", + "(31.1682 6.62018 3.2547e-21)\n", + "(31.2205 6.62735 -1.00218e-31)\n", + "(31.2768 6.63505 6.6084e-21)\n", + "(31.3352 6.64288 1.06892e-20)\n", + "(31.3911 6.64978 2.97873e-31)\n", + "(31.4321 6.65311 -1.39049e-29)\n", + "(31.4453 6.65005 0)\n", + "(31.4446 6.64357 4.23594e-28)\n", + "(31.446 6.63704 6.78282e-28)\n", + "(31.4474 6.63002 8.20923e-19)\n", + "(31.4489 6.62246 9.06432e-19)\n", + "(31.4506 6.61435 1.24796e-22)\n", + "(31.4523 6.60564 -2.22734e-18)\n", + "(31.4542 6.5963 6.06896e-19)\n", + "(31.4563 6.58629 6.63523e-19)\n", + "(31.4585 6.57555 0)\n", + "(31.4608 6.56405 -1.32388e-22)\n", + "(31.4633 6.55171 0)\n", + "(31.4659 6.5385 5.05547e-19)\n", + "(31.4687 6.52436 0)\n", + "(31.4717 6.50922 0)\n", + "(31.4749 6.49301 -7.48502e-19)\n", + "(31.4782 6.47567 -1.71535e-27)\n", + "(31.4818 6.45714 -9.07347e-23)\n", + "(31.4855 6.43732 0)\n", + "(31.4895 6.41614 -1.20768e-22)\n", + "(31.4937 6.39353 8.10999e-19)\n", + "(31.498 6.36938 -9.57919e-19)\n", + "(31.5026 6.34362 -4.55391e-27)\n", + "(31.5074 6.31615 -1.34617e-18)\n", + "(31.5124 6.28687 -7.9968e-19)\n", + "(31.5176 6.25568 9.51028e-19)\n", + "(31.523 6.22247 4.54929e-27)\n", + "(31.5286 6.18715 -6.73109e-19)\n", + "(31.5343 6.14959 -8.00407e-19)\n", + "(31.5402 6.1097 -7.64645e-27)\n", + "(31.5463 6.06735 -1.13053e-18)\n", + "(31.5524 6.02244 -1.07685e-26)\n", + "(31.5587 5.97485 1.11139e-26)\n", + "(31.565 5.92447 9.41686e-19)\n", + "(31.5712 5.87119 -1.55796e-26)\n", + "(31.5775 5.81489 2.10475e-26)\n", + "(31.5836 5.75548 -7.75313e-19)\n", + "(31.5896 5.69284 -9.12881e-19)\n", + "(31.5953 5.62689 -1.07297e-18)\n", + "(31.6007 5.55753 0)\n", + "(31.6057 5.48468 1.47569e-18)\n", + "(31.6103 5.40826 8.63075e-19)\n", + "(31.6142 5.32822 1.00778e-18)\n", + "(31.6174 5.2445 0)\n", + "(31.6198 5.15706 -1.36747e-18)\n", + "(31.6213 5.06586 -7.94401e-19)\n", + "(31.6216 4.9709 -5.20441e-26)\n", + "(31.6208 4.87218 0)\n", + "(31.6185 4.7697 -1.23312e-18)\n", + "(31.6146 4.66349 0)\n", + "(31.6091 4.5536 0)\n", + "(31.6018 4.44011 -1.88511e-18)\n", + "(31.5928 4.3231 -1.08226e-18)\n", + "(31.5821 4.20267 -1.24049e-18)\n", + "(31.5694 4.0789 -8.31105e-27)\n", + "(31.554 3.95181 9.2397e-26)\n", + "(31.5342 3.8213 0)\n", + "(31.5075 3.68715 -1.05318e-18)\n", + "(31.4716 3.54914 -6.7894e-23)\n", + "(31.4283 3.40744 2.7224e-18)\n", + "(31.3918 3.26374 -1.76631e-25)\n", + "(31.3952 3.1223 0)\n", + "(31.4677 2.98758 0)\n", + "(31.5514 2.85369 -2.75739e-25)\n", + "(31.4104 2.69109 2.94594e-26)\n", + "(30.7887 2.4651 -1.11872e-20)\n", + "(29.8417 2.2057 5.89645e-21)\n", + "(28.7783 1.94455 0)\n", + "(27.654 1.68842 -8.75387e-28)\n", + "(26.4758 1.43935 -8.61442e-26)\n", + "(25.2452 1.19962 -7.57069e-28)\n", + "(23.9674 0.971889 1.52416e-21)\n", + "(22.6519 0.758733 7.17327e-28)\n", + "(21.3102 0.562214 1.57519e-21)\n", + "(19.9537 0.383784 0)\n", + "(18.5935 0.224254 0)\n", + "(17.2397 0.0838885 0)\n", + "(15.9016 -0.0376447 -9.34507e-22)\n", + "(14.5875 -0.141296 0)\n", + "(13.3044 -0.228505 -5.15522e-22)\n", + "(12.0583 -0.301162 5.3938e-22)\n", + "(10.8529 -0.361165 5.28847e-28)\n", + "(9.69116 -0.410397 -5.71385e-28)\n", + "(8.57561 -0.450505 6.06921e-22)\n", + "(7.50773 -0.482642 3.10611e-22)\n", + "(6.48864 -0.50726 -3.15733e-22)\n", + "(5.52035 -0.524054 6.37224e-28)\n", + "(4.60703 -0.532391 -5.47e-28)\n", + "(3.75636 -0.531905 2.98549e-22)\n", + "(2.9803 -\n" + ] + } + ], + "source": [ + "print(\"--- 40000/U.gz header and first values ---\")\n", + "print(read_text(SIM_DIR / \"40000\" / \"U.gz\", max_bytes=4_000))\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..409b4f3 --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,28 @@ +[project] +name = "airfrans-frontier" +version = "0.1.0" +description = "Utilities for inspecting local AirfRANS scaling-frontier data." +requires-python = ">=3.11" +dependencies = [ + "numpy>=2.4.0", + "torch>=2.8.0", +] + +[project.scripts] +airfrans-frontier = "airfrans_frontier.cli:main" + +[tool.hatch.build.targets.wheel] +packages = ["src/airfrans_frontier"] + +[build-system] +requires = ["hatchling"] +build-backend = "hatchling.build" + +[dependency-groups] +dev = [ + "ipykernel>=6.30.0", + "matplotlib>=3.11.1", + "numpy>=2.4.0", + "nbclient>=0.10.2", + "nbformat>=5.10.4", +] diff --git a/src/airfrans_frontier/__init__.py b/src/airfrans_frontier/__init__.py new file mode 100644 index 0000000..3dc1f76 --- /dev/null +++ b/src/airfrans_frontier/__init__.py @@ -0,0 +1 @@ +__version__ = "0.1.0" diff --git a/src/airfrans_frontier/cli.py b/src/airfrans_frontier/cli.py new file mode 100644 index 0000000..e3db888 --- /dev/null +++ b/src/airfrans_frontier/cli.py @@ -0,0 +1,68 @@ +from __future__ import annotations + +import argparse +import sys + +from airfrans_frontier.paths import DEFAULT_RAW_DATA_DIR, DEFAULT_RAW_MANIFEST_PATH, resolve_path +from airfrans_frontier.raw.inspect import format_raw_inspection, inspect_raw_subset + + +def build_parser() -> argparse.ArgumentParser: + parser = argparse.ArgumentParser(prog="airfrans-frontier") + subparsers = parser.add_subparsers(required=True) + + inspect_raw = subparsers.add_parser("inspect-raw", help="inspect the local raw AirfRANS subset") + inspect_raw.add_argument("--data-dir", default=str(DEFAULT_RAW_DATA_DIR)) + inspect_raw.add_argument("--manifest", default=str(DEFAULT_RAW_MANIFEST_PATH)) + inspect_raw.add_argument("--sample-limit", type=int, default=5) + inspect_raw.set_defaults(command="inspect-raw") + + train = subparsers.add_parser("train", help="train a configured baseline model") + train.add_argument("config", help="path to a training config TOML file") + train.set_defaults(command="train") + + return parser + + +def main(argv: list[str] | None = None) -> int: + parser = build_parser() + args = parser.parse_args(argv) + + if args.command == "inspect-raw": + if args.sample_limit < 0: + print("error: --sample-limit must be non-negative", file=sys.stderr) + return 1 + + data_dir = resolve_path(args.data_dir) + manifest_path = resolve_path(args.manifest) + try: + report = inspect_raw_subset(data_dir, manifest_path) + except (FileNotFoundError, NotADirectoryError, ValueError) as exc: + print(f"error: {exc}", file=sys.stderr) + return 1 + + print(format_raw_inspection(report, sample_limit=args.sample_limit)) + return 0 if report.matches_manifest else 1 + + if args.command == "train": + from airfrans_frontier.runtime import remove_pythonpath_entries + + remove_pythonpath_entries() + from airfrans_frontier.training.loop import train_from_config_path + + try: + result = train_from_config_path(resolve_path(args.config)) + except (FileNotFoundError, NotADirectoryError, ValueError, RuntimeError) as exc: + print(f"error: {exc}", file=sys.stderr) + return 1 + + print(f"run_dir: {result.run_dir}") + print(f"final_metrics: {result.run_dir / 'final_metrics.json'}") + return 0 + + parser.error(f"unknown command: {args.command}") + return 2 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/src/airfrans_frontier/models/__init__.py b/src/airfrans_frontier/models/__init__.py new file mode 100644 index 0000000..7a24280 --- /dev/null +++ b/src/airfrans_frontier/models/__init__.py @@ -0,0 +1,5 @@ +"""Baseline model definitions.""" + +from airfrans_frontier.models.mlp import PointwiseMLP + +__all__ = ["PointwiseMLP"] diff --git a/src/airfrans_frontier/models/mlp.py b/src/airfrans_frontier/models/mlp.py new file mode 100644 index 0000000..d7b7f49 --- /dev/null +++ b/src/airfrans_frontier/models/mlp.py @@ -0,0 +1,47 @@ +from __future__ import annotations + +import torch +from torch import nn + + +class PointwiseMLP(nn.Module): + def __init__( + self, + *, + input_dim: int, + output_dim: int, + hidden_width: int = 128, + depth: int = 4, + activation: str = "gelu", + ) -> None: + super().__init__() + if input_dim <= 0: + raise ValueError("input_dim must be positive") + if output_dim <= 0: + raise ValueError("output_dim must be positive") + if hidden_width <= 0: + raise ValueError("hidden_width must be positive") + if depth <= 0: + raise ValueError("depth must be positive") + + layers: list[nn.Module] = [nn.Linear(input_dim, hidden_width), _activation(activation)] + for _ in range(depth - 1): + layers.extend((nn.Linear(hidden_width, hidden_width), _activation(activation))) + layers.append(nn.Linear(hidden_width, output_dim)) + self.network = nn.Sequential(*layers) + + def forward(self, features: torch.Tensor) -> torch.Tensor: + return self.network(features) + + +def _activation(name: str) -> nn.Module: + normalized = name.lower() + if normalized == "gelu": + return nn.GELU() + if normalized == "relu": + return nn.ReLU() + if normalized == "silu": + return nn.SiLU() + if normalized == "tanh": + return nn.Tanh() + raise ValueError(f"Unsupported activation: {name}") diff --git a/src/airfrans_frontier/paths.py b/src/airfrans_frontier/paths.py new file mode 100644 index 0000000..bc5420b --- /dev/null +++ b/src/airfrans_frontier/paths.py @@ -0,0 +1,8 @@ +from pathlib import Path + +DEFAULT_RAW_DATA_DIR = Path("data/raw/OF_dataset") +DEFAULT_RAW_MANIFEST_PATH = Path("data/raw/OF_dataset_subset_manifest.json") + + +def resolve_path(value: str | Path) -> Path: + return Path(value).expanduser() diff --git a/src/airfrans_frontier/raw/__init__.py b/src/airfrans_frontier/raw/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/airfrans_frontier/raw/inspect.py b/src/airfrans_frontier/raw/inspect.py new file mode 100644 index 0000000..7484ec0 --- /dev/null +++ b/src/airfrans_frontier/raw/inspect.py @@ -0,0 +1,92 @@ +from __future__ import annotations + +from dataclasses import dataclass +from pathlib import Path + +from airfrans_frontier.raw.manifest import RawSubsetManifest, load_raw_subset_manifest + + +@dataclass(frozen=True) +class RawInspection: + data_dir: Path + manifest_path: Path + simulation_count: int + file_count: int + total_bytes: int + manifest: RawSubsetManifest + missing_simulations: tuple[str, ...] + unexpected_simulations: tuple[str, ...] + + @property + def matches_manifest(self) -> bool: + return ( + not self.missing_simulations + and not self.unexpected_simulations + and self.simulation_count == self.manifest.extracted_simulations + and self.file_count == self.manifest.actual_file_count_under_target + and self.total_bytes == self.manifest.expected_extracted_bytes + ) + + +def inspect_raw_subset(data_dir: Path, manifest_path: Path) -> RawInspection: + if not data_dir.exists(): + raise FileNotFoundError(f"Raw data directory not found: {data_dir}") + if not data_dir.is_dir(): + raise NotADirectoryError(f"Raw data path is not a directory: {data_dir}") + + manifest = load_raw_subset_manifest(manifest_path) + actual_simulation_names = tuple(sorted(path.name for path in data_dir.iterdir() if path.is_dir())) + actual_simulation_set = set(actual_simulation_names) + manifest_simulation_set = set(manifest.simulation_names) + + file_paths = tuple(path for path in data_dir.rglob("*") if path.is_file()) + file_count = len(file_paths) + total_bytes = sum(path.stat().st_size for path in file_paths) + + return RawInspection( + data_dir=data_dir, + manifest_path=manifest_path, + simulation_count=len(actual_simulation_names), + file_count=file_count, + total_bytes=total_bytes, + manifest=manifest, + missing_simulations=tuple(sorted(manifest_simulation_set - actual_simulation_set)), + unexpected_simulations=tuple(sorted(actual_simulation_set - manifest_simulation_set)), + ) + + +def format_raw_inspection(report: RawInspection, sample_limit: int = 5) -> str: + status = "ok" if report.matches_manifest else "mismatch" + gb = report.total_bytes / 1_000_000_000 + actual_names = tuple( + sorted((set(report.manifest.simulation_names) - set(report.missing_simulations)) | set(report.unexpected_simulations)) + ) + visible_names = actual_names[: max(sample_limit, 0)] + remaining = len(actual_names) - len(visible_names) + + lines = [ + "AirfRANS raw subset", + f"status: {status}", + f"data_dir: {report.data_dir}", + f"manifest: {report.manifest_path}", + f"simulations: {report.simulation_count} / {report.manifest.extracted_simulations}", + f"files: {report.file_count} / {report.manifest.actual_file_count_under_target}", + f"bytes: {report.total_bytes} / {report.manifest.expected_extracted_bytes} ({gb:.2f} GB)", + f"source_zip_bytes: {report.manifest.source_zip_bytes}", + f"sample_seed: {report.manifest.sample_seed}", + f"sample_method: {report.manifest.sample_method}", + "sample_simulations:", + ] + lines.extend(f"- {name}" for name in visible_names) + if remaining > 0: + lines.append(f"... {remaining} more") + + if report.missing_simulations: + lines.append("missing_simulations:") + lines.extend(f"- {name}" for name in report.missing_simulations) + + if report.unexpected_simulations: + lines.append("unexpected_simulations:") + lines.extend(f"- {name}" for name in report.unexpected_simulations) + + return "\n".join(lines) diff --git a/src/airfrans_frontier/raw/manifest.py b/src/airfrans_frontier/raw/manifest.py new file mode 100644 index 0000000..89320e5 --- /dev/null +++ b/src/airfrans_frontier/raw/manifest.py @@ -0,0 +1,69 @@ +from __future__ import annotations + +import json +from dataclasses import dataclass +from pathlib import Path +from typing import Any + + +@dataclass(frozen=True) +class RawSubsetManifest: + path: Path + source_url: str + source_zip_bytes: int + sample_seed: int + sample_method: str + requested_simulations: int + extracted_simulations: int + expected_extracted_bytes: int + actual_file_count_under_target: int + target_root: str + simulation_names: tuple[str, ...] + + +_REQUIRED_KEYS = ( + "source_url", + "source_zip_bytes", + "sample_seed", + "sample_method", + "requested_simulations", + "extracted_simulations", + "expected_extracted_bytes", + "actual_file_count_under_target", + "target_root", + "simulations", +) + + +def load_raw_subset_manifest(path: Path) -> RawSubsetManifest: + if not path.exists(): + raise FileNotFoundError(f"Raw subset manifest not found: {path}") + + data: dict[str, Any] = json.loads(path.read_text()) + for key in _REQUIRED_KEYS: + if key not in data: + raise ValueError(f"Raw subset manifest missing key: {key}") + + simulations = data["simulations"] + if not isinstance(simulations, list): + raise ValueError("Raw subset manifest simulations must be a list") + + simulation_names: list[str] = [] + for simulation in simulations: + if not isinstance(simulation, dict) or "name" not in simulation: + raise ValueError("Raw subset manifest simulation entry missing key: name") + simulation_names.append(str(simulation["name"])) + + return RawSubsetManifest( + path=path, + source_url=str(data["source_url"]), + source_zip_bytes=int(data["source_zip_bytes"]), + sample_seed=int(data["sample_seed"]), + sample_method=str(data["sample_method"]), + requested_simulations=int(data["requested_simulations"]), + extracted_simulations=int(data["extracted_simulations"]), + expected_extracted_bytes=int(data["expected_extracted_bytes"]), + actual_file_count_under_target=int(data["actual_file_count_under_target"]), + target_root=str(data["target_root"]), + simulation_names=tuple(sorted(simulation_names)), + ) diff --git a/src/airfrans_frontier/runtime.py b/src/airfrans_frontier/runtime.py new file mode 100644 index 0000000..5a45ebc --- /dev/null +++ b/src/airfrans_frontier/runtime.py @@ -0,0 +1,25 @@ +from __future__ import annotations + +import os +import sys +from pathlib import Path + + +def remove_pythonpath_entries() -> None: + """Prefer uv-managed project dependencies over externally injected PYTHONPATH entries. + + The training stack imports compiled dependencies such as NumPy and PyTorch. If an + unrelated tool injects a Python-version-specific dependency directory through + PYTHONPATH, those imports can resolve outside the project's uv environment. The + CLI should use the environment it was installed into. + """ + raw_pythonpath = os.environ.get("PYTHONPATH") + if not raw_pythonpath: + return + + blocked = {_normalize_path(entry) for entry in raw_pythonpath.split(os.pathsep) if entry} + sys.path[:] = [entry for entry in sys.path if _normalize_path(entry) not in blocked] + + +def _normalize_path(entry: str) -> str: + return str(Path(entry or ".").expanduser().resolve()) diff --git a/src/airfrans_frontier/training/__init__.py b/src/airfrans_frontier/training/__init__.py new file mode 100644 index 0000000..d000033 --- /dev/null +++ b/src/airfrans_frontier/training/__init__.py @@ -0,0 +1,3 @@ +"""Training utilities for AirfRANS frontier baselines.""" + +__all__: list[str] = [] diff --git a/src/airfrans_frontier/training/artifacts.py b/src/airfrans_frontier/training/artifacts.py new file mode 100644 index 0000000..481df23 --- /dev/null +++ b/src/airfrans_frontier/training/artifacts.py @@ -0,0 +1,66 @@ +from __future__ import annotations + +import json +from datetime import datetime, timezone +from pathlib import Path +from typing import Any, Mapping + +import torch + + +class ArtifactWriter: + def __init__(self, run_dir: Path) -> None: + self.run_dir = run_dir + + @classmethod + def create(cls, base_dir: str | Path, run_name: str) -> ArtifactWriter: + base_path = Path(base_dir).expanduser() + base_path.mkdir(parents=True, exist_ok=True) + timestamp = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ") + safe_name = _safe_name(run_name) + candidate = base_path / f"{timestamp}_{safe_name}" + suffix = 1 + while candidate.exists(): + candidate = base_path / f"{timestamp}_{safe_name}_{suffix}" + suffix += 1 + candidate.mkdir(parents=True) + return cls(candidate) + + def write_config(self, config_text: str) -> None: + (self.run_dir / "config.toml").write_text(config_text) + + def write_split_manifest(self, split_manifest: Mapping[str, Any]) -> None: + self.write_json("split_manifest.json", dict(split_manifest)) + + def write_normalization(self, normalization: Mapping[str, Any]) -> None: + self.write_json("normalization.json", dict(normalization)) + + def append_metrics(self, metrics: Mapping[str, Any]) -> None: + with (self.run_dir / "metrics.jsonl").open("a") as file: + file.write(json.dumps(dict(metrics), sort_keys=True) + "\n") + + def write_final_metrics(self, metrics: Mapping[str, Any]) -> None: + self.write_json("final_metrics.json", dict(metrics)) + + def write_json(self, name: str, data: Mapping[str, Any]) -> None: + (self.run_dir / name).write_text(json.dumps(dict(data), indent=2, sort_keys=True) + "\n") + + def save_checkpoint(self, payload: Mapping[str, Any]) -> None: + torch.save(_to_cpu(payload), self.run_dir / "checkpoint.pt") + + +def _safe_name(value: str) -> str: + safe = "".join(character if character.isalnum() or character in "-_" else "_" for character in value) + return safe or "run" + + +def _to_cpu(value: Any) -> Any: + if isinstance(value, torch.Tensor): + return value.detach().cpu() + if isinstance(value, dict): + return {key: _to_cpu(item) for key, item in value.items()} + if isinstance(value, list): + return [_to_cpu(item) for item in value] + if isinstance(value, tuple): + return tuple(_to_cpu(item) for item in value) + return value diff --git a/src/airfrans_frontier/training/config.py b/src/airfrans_frontier/training/config.py new file mode 100644 index 0000000..62cbbac --- /dev/null +++ b/src/airfrans_frontier/training/config.py @@ -0,0 +1,207 @@ +from __future__ import annotations + +import tomllib +from dataclasses import dataclass +from pathlib import Path +from typing import Any + + +@dataclass(frozen=True) +class RunConfig: + name: str + seed: int + artifact_dir: Path + + +@dataclass(frozen=True) +class DataConfig: + root: Path + train_cases: int + val_cases: int + test_cases: int + points_per_case: int + batch_size: int + + +@dataclass(frozen=True) +class ModelConfig: + type: str + hidden_width: int + depth: int + activation: str + + +@dataclass(frozen=True) +class OptimConfig: + lr: float + weight_decay: float + steps: int + log_interval: int | None = None + + +@dataclass(frozen=True) +class DeviceConfig: + type: str + allow_cpu_fallback: bool + benchmark_kernels: bool + + +@dataclass(frozen=True) +class LossConfig: + type: str + + +@dataclass(frozen=True) +class TrainingConfig: + path: Path + config_text: str + run: RunConfig + data: DataConfig + model: ModelConfig + optim: OptimConfig + device: DeviceConfig + loss: LossConfig + + +_REQUIRED_SECTIONS = ("run", "data", "model", "optim", "device", "loss") + + +def load_training_config(path: str | Path) -> TrainingConfig: + config_path = Path(path).expanduser() + if not config_path.exists(): + raise FileNotFoundError(f"Training config not found: {config_path}") + if not config_path.is_file(): + raise ValueError(f"Training config is not a file: {config_path}") + + text = config_path.read_text() + try: + raw = tomllib.loads(text) + except tomllib.TOMLDecodeError as exc: + raise ValueError(f"Invalid TOML config {config_path}: {exc}") from exc + + for section_name in _REQUIRED_SECTIONS: + if section_name not in raw or not isinstance(raw[section_name], dict): + raise ValueError(f"Training config missing [{section_name}] section") + + run_raw = raw["run"] + data_raw = raw["data"] + model_raw = raw["model"] + optim_raw = raw["optim"] + device_raw = raw["device"] + loss_raw = raw["loss"] + + run = RunConfig( + name=_string(run_raw, "name"), + seed=_integer(run_raw, "seed", minimum=0), + artifact_dir=_path(run_raw, "artifact_dir"), + ) + data = DataConfig( + root=_path(data_raw, "root"), + train_cases=_integer(data_raw, "train_cases", minimum=1), + val_cases=_integer(data_raw, "val_cases", minimum=0), + test_cases=_integer(data_raw, "test_cases", minimum=0), + points_per_case=_integer(data_raw, "points_per_case", minimum=1), + batch_size=_integer(data_raw, "batch_size", minimum=1), + ) + model = ModelConfig( + type=_choice(_string(model_raw, "type"), {"mlp"}, "model.type"), + hidden_width=_integer(model_raw, "hidden_width", minimum=1), + depth=_integer(model_raw, "depth", minimum=1), + activation=_choice(_string(model_raw, "activation").lower(), {"gelu", "relu", "silu", "tanh"}, "model.activation"), + ) + optim = OptimConfig( + lr=_number(optim_raw, "lr", minimum=0.0, exclusive_minimum=True), + weight_decay=_number(optim_raw, "weight_decay", minimum=0.0), + steps=_integer(optim_raw, "steps", minimum=1), + log_interval=_optional_integer(optim_raw, "log_interval", minimum=1), + ) + device = DeviceConfig( + type=_choice(_string(device_raw, "type").lower(), {"cuda", "cpu", "auto"}, "device.type"), + allow_cpu_fallback=_boolean(device_raw, "allow_cpu_fallback"), + benchmark_kernels=_boolean(device_raw, "benchmark_kernels"), + ) + loss = LossConfig(type=_choice(_string(loss_raw, "type"), {"normalized_mse"}, "loss.type")) + + requested_cases = data.train_cases + data.val_cases + data.test_cases + if requested_cases <= 0: + raise ValueError("Training config must request at least one case") + + return TrainingConfig( + path=config_path, + config_text=text, + run=run, + data=data, + model=model, + optim=optim, + device=device, + loss=loss, + ) + + +def _path(section: dict[str, Any], key: str) -> Path: + value = _string(section, key) + path = Path(value).expanduser() + if path.is_absolute(): + return path + return Path.cwd() / path + + +def _string(section: dict[str, Any], key: str) -> str: + value = _required(section, key) + if not isinstance(value, str) or not value: + raise ValueError(f"Expected non-empty string for {key}") + return value + + +def _integer(section: dict[str, Any], key: str, *, minimum: int | None = None) -> int: + value = _required(section, key) + if isinstance(value, bool) or not isinstance(value, int): + raise ValueError(f"Expected integer for {key}") + if minimum is not None and value < minimum: + raise ValueError(f"Expected {key} >= {minimum}") + return value + + +def _optional_integer(section: dict[str, Any], key: str, *, minimum: int | None = None) -> int | None: + if key not in section: + return None + return _integer(section, key, minimum=minimum) + + +def _number( + section: dict[str, Any], + key: str, + *, + minimum: float | None = None, + exclusive_minimum: bool = False, +) -> float: + value = _required(section, key) + if isinstance(value, bool) or not isinstance(value, (int, float)): + raise ValueError(f"Expected number for {key}") + result = float(value) + if minimum is not None: + if exclusive_minimum and result <= minimum: + raise ValueError(f"Expected {key} > {minimum}") + if not exclusive_minimum and result < minimum: + raise ValueError(f"Expected {key} >= {minimum}") + return result + + +def _boolean(section: dict[str, Any], key: str) -> bool: + value = _required(section, key) + if not isinstance(value, bool): + raise ValueError(f"Expected boolean for {key}") + return value + + +def _choice(value: str, allowed: set[str], key: str) -> str: + if value not in allowed: + allowed_text = ", ".join(sorted(allowed)) + raise ValueError(f"Expected {key} to be one of: {allowed_text}") + return value + + +def _required(section: dict[str, Any], key: str) -> Any: + if key not in section: + raise ValueError(f"Training config missing key: {key}") + return section[key] diff --git a/src/airfrans_frontier/training/data.py b/src/airfrans_frontier/training/data.py new file mode 100644 index 0000000..5a0d4f4 --- /dev/null +++ b/src/airfrans_frontier/training/data.py @@ -0,0 +1,254 @@ +from __future__ import annotations + +import random +from dataclasses import dataclass +from pathlib import Path + +import numpy as np +from numpy.typing import NDArray + + +FloatArray = NDArray[np.float32] + + +@dataclass(frozen=True) +class SimulationSample: + case_id: str + features: FloatArray + targets: FloatArray + feature_names: tuple[str, ...] + target_names: tuple[str, ...] + source_path: Path + + @property + def num_points(self) -> int: + return int(self.features.shape[0]) + + @property + def num_features(self) -> int: + return int(self.features.shape[1]) + + @property + def num_targets(self) -> int: + return int(self.targets.shape[1]) + + +@dataclass(frozen=True) +class CaseSplit: + train_ids: tuple[str, ...] + val_ids: tuple[str, ...] + test_ids: tuple[str, ...] + + def to_dict(self) -> dict[str, list[str]]: + return { + "train_ids": list(self.train_ids), + "val_ids": list(self.val_ids), + "test_ids": list(self.test_ids), + } + + +@dataclass(frozen=True) +class SplitArrays: + features: FloatArray + targets: FloatArray + case_ids: tuple[str, ...] + + +@dataclass(frozen=True) +class DatasetBundle: + train: SplitArrays + val: SplitArrays | None + test: SplitArrays | None + split: CaseSplit + feature_names: tuple[str, ...] + target_names: tuple[str, ...] + + +def load_processed_dataset(root: str | Path) -> list[SimulationSample]: + root_path = Path(root).expanduser() + if not root_path.exists(): + raise FileNotFoundError(f"Processed data directory not found: {root_path}") + if not root_path.is_dir(): + raise NotADirectoryError(f"Processed data path is not a directory: {root_path}") + + paths = sorted(root_path.glob("*.npz")) + if not paths: + raise ValueError(f"No .npz simulation files found under: {root_path}") + + samples = [load_simulation_npz(path) for path in paths] + validate_common_schema(samples) + return samples + + +def load_simulation_npz(path: str | Path) -> SimulationSample: + source_path = Path(path).expanduser() + if not source_path.exists(): + raise FileNotFoundError(f"Simulation file not found: {source_path}") + if not source_path.is_file(): + raise ValueError(f"Simulation path is not a file: {source_path}") + + try: + with np.load(source_path, allow_pickle=False) as npz: + keys = set(npz.files) + if "features" not in keys or "targets" not in keys: + raise ValueError(f"Simulation file missing features/targets arrays: {source_path}") + features = _float_matrix(npz["features"], "features", source_path) + targets = _float_matrix(npz["targets"], "targets", source_path) + if features.shape[0] != targets.shape[0]: + raise ValueError( + f"Simulation features/targets row mismatch in {source_path}: " + f"{features.shape[0]} != {targets.shape[0]}" + ) + feature_names = _names(npz, "feature_names", features.shape[1], "feature") + target_names = _names(npz, "target_names", targets.shape[1], "target") + except OSError as exc: + raise ValueError(f"Could not read simulation file {source_path}: {exc}") from exc + + return SimulationSample( + case_id=source_path.stem, + features=features, + targets=targets, + feature_names=feature_names, + target_names=target_names, + source_path=source_path, + ) + + +def validate_common_schema(samples: list[SimulationSample]) -> None: + if not samples: + raise ValueError("Dataset contains no simulation samples") + first = samples[0] + seen_ids: set[str] = set() + for sample in samples: + if sample.case_id in seen_ids: + raise ValueError(f"Duplicate simulation case id: {sample.case_id}") + seen_ids.add(sample.case_id) + if sample.feature_names != first.feature_names: + raise ValueError(f"Feature schema mismatch in case {sample.case_id}") + if sample.target_names != first.target_names: + raise ValueError(f"Target schema mismatch in case {sample.case_id}") + + +def create_case_split( + case_ids: list[str] | tuple[str, ...], + *, + train_cases: int, + val_cases: int, + test_cases: int, + seed: int, +) -> CaseSplit: + requested = train_cases + val_cases + test_cases + if requested > len(case_ids): + raise ValueError( + f"Requested {requested} split cases but only {len(case_ids)} cases are available" + ) + + shuffled = list(case_ids) + random.Random(seed).shuffle(shuffled) + selected = shuffled[:requested] + train_end = train_cases + val_end = train_end + val_cases + return CaseSplit( + train_ids=tuple(selected[:train_end]), + val_ids=tuple(selected[train_end:val_end]), + test_ids=tuple(selected[val_end:]), + ) + + +def build_dataset_bundle( + samples: list[SimulationSample], + *, + train_cases: int, + val_cases: int, + test_cases: int, + points_per_case: int, + seed: int, +) -> DatasetBundle: + validate_common_schema(samples) + samples_by_id = {sample.case_id: sample for sample in samples} + split = create_case_split( + tuple(samples_by_id), + train_cases=train_cases, + val_cases=val_cases, + test_cases=test_cases, + seed=seed, + ) + train = build_split_arrays(samples_by_id, split.train_ids, points_per_case, seed=seed + 101) + val = ( + build_split_arrays(samples_by_id, split.val_ids, points_per_case, seed=seed + 202) + if split.val_ids + else None + ) + test = ( + build_split_arrays(samples_by_id, split.test_ids, points_per_case, seed=seed + 303) + if split.test_ids + else None + ) + return DatasetBundle( + train=train, + val=val, + test=test, + split=split, + feature_names=samples[0].feature_names, + target_names=samples[0].target_names, + ) + + +def build_split_arrays( + samples_by_id: dict[str, SimulationSample], + case_ids: tuple[str, ...], + points_per_case: int, + *, + seed: int, +) -> SplitArrays: + if not case_ids: + raise ValueError("Cannot build split arrays for an empty case split") + rng = np.random.default_rng(seed) + feature_parts: list[FloatArray] = [] + target_parts: list[FloatArray] = [] + for case_id in case_ids: + sample = samples_by_id[case_id] + indices = _sample_indices(sample.num_points, points_per_case, rng) + feature_parts.append(np.ascontiguousarray(sample.features[indices], dtype=np.float32)) + target_parts.append(np.ascontiguousarray(sample.targets[indices], dtype=np.float32)) + + return SplitArrays( + features=np.concatenate(feature_parts, axis=0), + targets=np.concatenate(target_parts, axis=0), + case_ids=case_ids, + ) + + +def _sample_indices(num_points: int, points_per_case: int, rng: np.random.Generator) -> NDArray[np.int64]: + if num_points <= 0: + raise ValueError("Cannot sample from an empty simulation") + if points_per_case >= num_points: + return np.arange(num_points, dtype=np.int64) + return np.sort(rng.choice(num_points, size=points_per_case, replace=False)).astype(np.int64) + + +def _float_matrix(array: np.ndarray, name: str, path: Path) -> FloatArray: + if array.ndim != 2: + raise ValueError(f"Expected {name} to be a 2D array in {path}; got shape {array.shape}") + if array.shape[0] == 0 or array.shape[1] == 0: + raise ValueError(f"Expected non-empty {name} matrix in {path}; got shape {array.shape}") + result = np.asarray(array, dtype=np.float32) + if not np.isfinite(result).all(): + raise ValueError(f"Expected finite values in {name} array: {path}") + return np.ascontiguousarray(result, dtype=np.float32) + + +def _names( + npz: np.lib.npyio.NpzFile, + key: str, + expected_count: int, + prefix: str, +) -> tuple[str, ...]: + if key not in npz.files: + return tuple(f"{prefix}_{index}" for index in range(expected_count)) + values = np.asarray(npz[key]) + if values.ndim != 1 or values.shape[0] != expected_count: + raise ValueError( + f"Expected {key} to be a 1D array of length {expected_count}; got shape {values.shape}" + ) + return tuple(str(value) for value in values.tolist()) diff --git a/src/airfrans_frontier/training/loop.py b/src/airfrans_frontier/training/loop.py new file mode 100644 index 0000000..f47e0ec --- /dev/null +++ b/src/airfrans_frontier/training/loop.py @@ -0,0 +1,316 @@ +from __future__ import annotations + +import random +import time +from dataclasses import asdict, dataclass +from pathlib import Path +from typing import Any + +import numpy as np +import torch +from torch.nn import functional as F + +from airfrans_frontier.models import PointwiseMLP +from airfrans_frontier.training.artifacts import ArtifactWriter +from airfrans_frontier.training.config import TrainingConfig, load_training_config +from airfrans_frontier.training.data import DatasetBundle, build_dataset_bundle, load_processed_dataset +from airfrans_frontier.training.metrics import count_parameters, device_metrics, overall_mse, per_channel_mse +from airfrans_frontier.training.normalize import ( + NormalizationStats, + compute_normalization_stats, + normalize_features, + normalize_targets, +) + + +@dataclass(frozen=True) +class TrainingResult: + run_dir: Path + final_metrics: dict[str, Any] + + +def train_from_config_path(path: str | Path) -> TrainingResult: + config = load_training_config(path) + return train(config) + + +def train(config: TrainingConfig) -> TrainingResult: + _seed_all(config.run.seed) + device = select_device(config) + + samples = load_processed_dataset(config.data.root) + bundle = build_dataset_bundle( + samples, + train_cases=config.data.train_cases, + val_cases=config.data.val_cases, + test_cases=config.data.test_cases, + points_per_case=config.data.points_per_case, + seed=config.run.seed, + ) + stats = compute_normalization_stats( + bundle.train.features, + bundle.train.targets, + feature_names=bundle.feature_names, + target_names=bundle.target_names, + ) + train_features = normalize_features(bundle.train.features, stats) + train_targets = normalize_targets(bundle.train.targets, stats) + val_features = normalize_features(bundle.val.features, stats) if bundle.val is not None else None + val_targets = normalize_targets(bundle.val.targets, stats) if bundle.val is not None else None + test_features = normalize_features(bundle.test.features, stats) if bundle.test is not None else None + test_targets = normalize_targets(bundle.test.targets, stats) if bundle.test is not None else None + + model = PointwiseMLP( + input_dim=train_features.shape[1], + output_dim=train_targets.shape[1], + hidden_width=config.model.hidden_width, + depth=config.model.depth, + activation=config.model.activation, + ).to(device) + optimizer = torch.optim.AdamW( + model.parameters(), + lr=config.optim.lr, + weight_decay=config.optim.weight_decay, + ) + writer = ArtifactWriter.create(config.run.artifact_dir, config.run.name) + writer.write_config(config.config_text) + writer.write_split_manifest(bundle.split.to_dict()) + writer.write_normalization(stats.to_dict()) + + started = time.perf_counter() + initial_train = evaluate_arrays( + model, + train_features, + train_targets, + batch_size=config.data.batch_size, + device=device, + target_names=bundle.target_names, + ) + initial_val = ( + evaluate_arrays( + model, + val_features, + val_targets, + batch_size=config.data.batch_size, + device=device, + target_names=bundle.target_names, + ) + if val_features is not None and val_targets is not None + else None + ) + writer.append_metrics( + _log_metrics( + step=0, + train_loss=initial_train["loss"], + val_loss=initial_val["loss"] if initial_val is not None else None, + elapsed_seconds=0.0, + ) + ) + + log_interval = config.optim.log_interval or max(1, config.optim.steps // 10) + rng = np.random.default_rng(config.run.seed + 404) + model.train() + for step in range(1, config.optim.steps + 1): + batch_features, batch_targets = _sample_batch( + train_features, + train_targets, + batch_size=config.data.batch_size, + rng=rng, + ) + features_tensor = _to_device(batch_features, device) + targets_tensor = _to_device(batch_targets, device) + + optimizer.zero_grad(set_to_none=True) + predictions = model(features_tensor) + loss = F.mse_loss(predictions, targets_tensor) + loss.backward() + optimizer.step() + + if step % log_interval == 0 or step == config.optim.steps: + train_eval = evaluate_arrays( + model, + train_features, + train_targets, + batch_size=config.data.batch_size, + device=device, + target_names=bundle.target_names, + ) + val_eval = ( + evaluate_arrays( + model, + val_features, + val_targets, + batch_size=config.data.batch_size, + device=device, + target_names=bundle.target_names, + ) + if val_features is not None and val_targets is not None + else None + ) + writer.append_metrics( + _log_metrics( + step=step, + train_loss=train_eval["loss"], + val_loss=val_eval["loss"] if val_eval is not None else None, + elapsed_seconds=time.perf_counter() - started, + ) + ) + model.train() + + final_train = evaluate_arrays( + model, + train_features, + train_targets, + batch_size=config.data.batch_size, + device=device, + target_names=bundle.target_names, + ) + final_val = ( + evaluate_arrays( + model, + val_features, + val_targets, + batch_size=config.data.batch_size, + device=device, + target_names=bundle.target_names, + ) + if val_features is not None and val_targets is not None + else None + ) + final_test = ( + evaluate_arrays( + model, + test_features, + test_targets, + batch_size=config.data.batch_size, + device=device, + target_names=bundle.target_names, + ) + if test_features is not None and test_targets is not None + else None + ) + + elapsed = time.perf_counter() - started + final_metrics: dict[str, Any] = { + "initial_train_loss": initial_train["loss"], + "train_loss": final_train["loss"], + "train_mse_per_channel": final_train["per_channel_mse"], + "val_loss": final_val["loss"] if final_val is not None else None, + "val_mse_per_channel": final_val["per_channel_mse"] if final_val is not None else None, + "test_loss": final_test["loss"] if final_test is not None else None, + "test_mse_per_channel": final_test["per_channel_mse"] if final_test is not None else None, + "parameter_count": count_parameters(model), + "train_cases": len(bundle.split.train_ids), + "val_cases": len(bundle.split.val_ids), + "test_cases": len(bundle.split.test_ids), + "points_per_case": config.data.points_per_case, + "steps": config.optim.steps, + "elapsed_seconds": elapsed, + **device_metrics(device), + } + writer.write_final_metrics(final_metrics) + writer.save_checkpoint( + { + "step": config.optim.steps, + "model_type": config.model.type, + "input_dim": train_features.shape[1], + "output_dim": train_targets.shape[1], + "model_config": asdict(config.model), + "model_state_dict": model.state_dict(), + "optimizer_state_dict": optimizer.state_dict(), + "normalization": stats.to_dict(), + "target_names": bundle.target_names, + "feature_names": bundle.feature_names, + "final_metrics": final_metrics, + } + ) + return TrainingResult(run_dir=writer.run_dir, final_metrics=final_metrics) + + +def select_device(config: TrainingConfig) -> torch.device: + requested = config.device.type + if requested == "cuda": + if torch.cuda.is_available(): + torch.backends.cudnn.benchmark = config.device.benchmark_kernels + return torch.device("cuda:0") + if config.device.allow_cpu_fallback: + return torch.device("cpu") + raise RuntimeError("CUDA requested by config but torch.cuda.is_available() is false") + if requested == "auto": + if torch.cuda.is_available(): + torch.backends.cudnn.benchmark = config.device.benchmark_kernels + return torch.device("cuda:0") + return torch.device("cpu") + return torch.device("cpu") + + +def evaluate_arrays( + model: torch.nn.Module, + features: np.ndarray, + targets: np.ndarray, + *, + batch_size: int, + device: torch.device, + target_names: tuple[str, ...], +) -> dict[str, Any]: + model.eval() + target_dim = targets.shape[1] + squared_error_sum = torch.zeros(target_dim, dtype=torch.float64) + count = 0 + with torch.no_grad(): + for start in range(0, features.shape[0], batch_size): + stop = min(start + batch_size, features.shape[0]) + batch_features = _to_device(features[start:stop], device) + batch_targets = _to_device(targets[start:stop], device) + predictions = model(batch_features) + errors = predictions - batch_targets + squared_error_sum += (errors.double().pow(2).sum(dim=0)).detach().cpu() + count += stop - start + return { + "loss": overall_mse(squared_error_sum, count, target_dim), + "per_channel_mse": per_channel_mse(squared_error_sum, count, target_names), + } + + +def _sample_batch( + features: np.ndarray, + targets: np.ndarray, + *, + batch_size: int, + rng: np.random.Generator, +) -> tuple[np.ndarray, np.ndarray]: + indices = rng.integers(0, features.shape[0], size=batch_size) + return ( + np.ascontiguousarray(features[indices], dtype=np.float32), + np.ascontiguousarray(targets[indices], dtype=np.float32), + ) + + +def _to_device(values: np.ndarray, device: torch.device) -> torch.Tensor: + tensor = torch.from_numpy(values) + if device.type == "cuda": + tensor = tensor.pin_memory() + return tensor.to(device, non_blocking=device.type == "cuda") + + +def _seed_all(seed: int) -> None: + random.seed(seed) + np.random.seed(seed) + torch.manual_seed(seed) + if torch.cuda.is_available(): + torch.cuda.manual_seed_all(seed) + + +def _log_metrics( + *, + step: int, + train_loss: float, + val_loss: float | None, + elapsed_seconds: float, +) -> dict[str, Any]: + return { + "step": step, + "train_loss": train_loss, + "val_loss": val_loss, + "elapsed_seconds": elapsed_seconds, + } diff --git a/src/airfrans_frontier/training/metrics.py b/src/airfrans_frontier/training/metrics.py new file mode 100644 index 0000000..b0b44ca --- /dev/null +++ b/src/airfrans_frontier/training/metrics.py @@ -0,0 +1,45 @@ +from __future__ import annotations + +from typing import Any + +import torch + + +def count_parameters(model: torch.nn.Module) -> int: + return sum(parameter.numel() for parameter in model.parameters() if parameter.requires_grad) + + +def per_channel_mse( + squared_error_sum: torch.Tensor, + count: int, + target_names: tuple[str, ...], +) -> dict[str, float]: + if count <= 0: + raise ValueError("Metric count must be positive") + values = (squared_error_sum / count).detach().cpu().tolist() + return {name: float(value) for name, value in zip(target_names, values, strict=True)} + + +def overall_mse(squared_error_sum: torch.Tensor, count: int, target_dim: int) -> float: + if count <= 0 or target_dim <= 0: + raise ValueError("Metric count and target dimension must be positive") + return float((squared_error_sum.sum() / (count * target_dim)).detach().cpu().item()) + + +def device_metrics(device: torch.device) -> dict[str, Any]: + if device.type != "cuda": + return { + "device": str(device), + "gpu_name": None, + "gpu_memory_total_mb": None, + "gpu_memory_peak_allocated_mb": None, + } + + index = device.index if device.index is not None else torch.cuda.current_device() + properties = torch.cuda.get_device_properties(index) + return { + "device": f"cuda:{index}", + "gpu_name": torch.cuda.get_device_name(index), + "gpu_memory_total_mb": int(properties.total_memory // (1024 * 1024)), + "gpu_memory_peak_allocated_mb": int(torch.cuda.max_memory_allocated(index) // (1024 * 1024)), + } diff --git a/src/airfrans_frontier/training/normalize.py b/src/airfrans_frontier/training/normalize.py new file mode 100644 index 0000000..3528b68 --- /dev/null +++ b/src/airfrans_frontier/training/normalize.py @@ -0,0 +1,126 @@ +from __future__ import annotations + +import json +from dataclasses import dataclass +from pathlib import Path + +import numpy as np +from numpy.typing import NDArray + +FloatArray = NDArray[np.float32] + + +@dataclass(frozen=True) +class NormalizationStats: + feature_mean: FloatArray + feature_std: FloatArray + target_mean: FloatArray + target_std: FloatArray + feature_names: tuple[str, ...] + target_names: tuple[str, ...] + + def to_dict(self) -> dict[str, object]: + return { + "feature_names": list(self.feature_names), + "target_names": list(self.target_names), + "feature_mean": self.feature_mean.tolist(), + "feature_std": self.feature_std.tolist(), + "target_mean": self.target_mean.tolist(), + "target_std": self.target_std.tolist(), + } + + @classmethod + def from_dict(cls, data: dict[str, object]) -> NormalizationStats: + return cls( + feature_names=tuple(str(value) for value in _list(data, "feature_names")), + target_names=tuple(str(value) for value in _list(data, "target_names")), + feature_mean=np.asarray(_list(data, "feature_mean"), dtype=np.float32), + feature_std=np.asarray(_list(data, "feature_std"), dtype=np.float32), + target_mean=np.asarray(_list(data, "target_mean"), dtype=np.float32), + target_std=np.asarray(_list(data, "target_std"), dtype=np.float32), + ) + + +def compute_normalization_stats( + features: FloatArray, + targets: FloatArray, + *, + feature_names: tuple[str, ...], + target_names: tuple[str, ...], + min_std: float = 1e-6, +) -> NormalizationStats: + _validate_matrix(features, "features") + _validate_matrix(targets, "targets") + if features.shape[1] != len(feature_names): + raise ValueError("Feature name count does not match feature matrix width") + if targets.shape[1] != len(target_names): + raise ValueError("Target name count does not match target matrix width") + + feature_mean = features.mean(axis=0, dtype=np.float64).astype(np.float32) + feature_std = features.std(axis=0, dtype=np.float64).astype(np.float32) + target_mean = targets.mean(axis=0, dtype=np.float64).astype(np.float32) + target_std = targets.std(axis=0, dtype=np.float64).astype(np.float32) + + feature_std = _clamp_std(feature_std, min_std) + target_std = _clamp_std(target_std, min_std) + + return NormalizationStats( + feature_mean=feature_mean, + feature_std=feature_std, + target_mean=target_mean, + target_std=target_std, + feature_names=feature_names, + target_names=target_names, + ) + + +def normalize_features(features: FloatArray, stats: NormalizationStats) -> FloatArray: + _validate_matrix(features, "features") + if features.shape[1] != stats.feature_mean.shape[0]: + raise ValueError("Feature width does not match normalization stats") + return np.ascontiguousarray((features - stats.feature_mean) / stats.feature_std, dtype=np.float32) + + +def normalize_targets(targets: FloatArray, stats: NormalizationStats) -> FloatArray: + _validate_matrix(targets, "targets") + if targets.shape[1] != stats.target_mean.shape[0]: + raise ValueError("Target width does not match normalization stats") + return np.ascontiguousarray((targets - stats.target_mean) / stats.target_std, dtype=np.float32) + + +def denormalize_targets(targets: FloatArray, stats: NormalizationStats) -> FloatArray: + _validate_matrix(targets, "targets") + if targets.shape[1] != stats.target_mean.shape[0]: + raise ValueError("Target width does not match normalization stats") + return np.ascontiguousarray(targets * stats.target_std + stats.target_mean, dtype=np.float32) + + +def save_normalization_stats(stats: NormalizationStats, path: str | Path) -> None: + Path(path).write_text(json.dumps(stats.to_dict(), indent=2, sort_keys=True) + "\n") + + +def load_normalization_stats(path: str | Path) -> NormalizationStats: + data = json.loads(Path(path).read_text()) + if not isinstance(data, dict): + raise ValueError(f"Invalid normalization stats file: {path}") + return NormalizationStats.from_dict(data) + + +def _clamp_std(std: FloatArray, min_std: float) -> FloatArray: + result = std.copy() + result[result < min_std] = 1.0 + return result.astype(np.float32) + + +def _validate_matrix(values: FloatArray, name: str) -> None: + if values.ndim != 2: + raise ValueError(f"Expected {name} to be 2D; got shape {values.shape}") + if not np.isfinite(values).all(): + raise ValueError(f"Expected finite values in {name}") + + +def _list(data: dict[str, object], key: str) -> list[object]: + value = data.get(key) + if not isinstance(value, list): + raise ValueError(f"Expected list for normalization key: {key}") + return value diff --git a/tests/test_cli.py b/tests/test_cli.py new file mode 100644 index 0000000..ed57ebd --- /dev/null +++ b/tests/test_cli.py @@ -0,0 +1,113 @@ +from __future__ import annotations + +import json +import subprocess +import sys +import tempfile +import unittest +from pathlib import Path + + +def make_raw_subset(root: Path) -> tuple[Path, Path, int, int]: + data_dir = root / "OF_dataset" + sim_a_file = data_dir / "sim_a" / "field.txt" + sim_b_file = data_dir / "sim_b" / "nested" / "field.txt" + sim_a_file.parent.mkdir(parents=True) + sim_b_file.parent.mkdir(parents=True) + sim_a_file.write_text("abc") + sim_b_file.write_text("defgh") + + expected_bytes = 8 + expected_files = 2 + manifest_path = root / "OF_dataset_subset_manifest.json" + manifest_path.write_text( + json.dumps( + { + "source_url": "https://example.invalid/OF_dataset.zip", + "source_zip_bytes": 0, + "sample_seed": 123, + "sample_method": "test sample", + "requested_simulations": 2, + "extracted_simulations": 2, + "expected_extracted_bytes": expected_bytes, + "actual_file_count_under_target": expected_files, + "target_root": str(data_dir), + "simulations": [{"name": "sim_a"}, {"name": "sim_b"}], + } + ) + ) + return data_dir, manifest_path, expected_bytes, expected_files + + +class InspectRawCliTests(unittest.TestCase): + def run_cli(self, *args: str) -> subprocess.CompletedProcess[str]: + return subprocess.run( + [sys.executable, "-m", "airfrans_frontier.cli", *args], + text=True, + capture_output=True, + check=False, + ) + + def test_inspect_raw_success_reports_manifest_match(self) -> None: + with tempfile.TemporaryDirectory() as tmp: + data_dir, manifest_path, _, _ = make_raw_subset(Path(tmp)) + + result = self.run_cli( + "inspect-raw", + "--data-dir", + str(data_dir), + "--manifest", + str(manifest_path), + "--sample-limit", + "2", + ) + + self.assertEqual(result.returncode, 0) + self.assertIn("status: ok", result.stdout) + self.assertIn("simulations: 2 / 2", result.stdout) + self.assertIn("files: 2 / 2", result.stdout) + self.assertIn("bytes: 8 / 8", result.stdout) + self.assertIn("- sim_a", result.stdout) + self.assertIn("- sim_b", result.stdout) + self.assertEqual(result.stderr, "") + + def test_inspect_raw_missing_data_dir_is_clear_error(self) -> None: + with tempfile.TemporaryDirectory() as tmp: + _, manifest_path, _, _ = make_raw_subset(Path(tmp)) + missing_dir = Path(tmp) / "missing" + + result = self.run_cli( + "inspect-raw", + "--data-dir", + str(missing_dir), + "--manifest", + str(manifest_path), + ) + + self.assertEqual(result.returncode, 1) + self.assertEqual(result.stdout, "") + self.assertIn("error: Raw data directory not found:", result.stderr) + + def test_inspect_raw_manifest_mismatch_returns_one(self) -> None: + with tempfile.TemporaryDirectory() as tmp: + data_dir, manifest_path, _, _ = make_raw_subset(Path(tmp)) + unexpected_file = data_dir / "sim_c" / "field.txt" + unexpected_file.parent.mkdir(parents=True) + unexpected_file.write_text("unexpected") + + result = self.run_cli( + "inspect-raw", + "--data-dir", + str(data_dir), + "--manifest", + str(manifest_path), + ) + + self.assertEqual(result.returncode, 1) + self.assertIn("status: mismatch", result.stdout) + self.assertIn("unexpected_simulations:", result.stdout) + self.assertEqual(result.stderr, "") + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_mlp.py b/tests/test_mlp.py new file mode 100644 index 0000000..2ed553e --- /dev/null +++ b/tests/test_mlp.py @@ -0,0 +1,25 @@ +from __future__ import annotations + +import unittest + +from airfrans_frontier.runtime import remove_pythonpath_entries + +remove_pythonpath_entries() + +import torch + +from airfrans_frontier.models import PointwiseMLP + + +class PointwiseMLPTests(unittest.TestCase): + def test_forward_pass_returns_batch_by_target_dim(self) -> None: + model = PointwiseMLP(input_dim=5, output_dim=4, hidden_width=16, depth=2, activation="gelu") + batch = torch.randn(7, 5) + + output = model(batch) + + self.assertEqual(tuple(output.shape), (7, 4)) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_training_config.py b/tests/test_training_config.py new file mode 100644 index 0000000..7e7fd0c --- /dev/null +++ b/tests/test_training_config.py @@ -0,0 +1,30 @@ +from __future__ import annotations + +import tempfile +import unittest +from pathlib import Path + +from airfrans_frontier.training.config import load_training_config + + +class TrainingConfigTests(unittest.TestCase): + def test_config_loader_accepts_mlp_tiny(self) -> None: + config = load_training_config("configs/mlp_tiny.toml") + + self.assertEqual(config.run.name, "mlp_tiny") + self.assertEqual(config.model.type, "mlp") + self.assertEqual(config.loss.type, "normalized_mse") + self.assertEqual(config.device.type, "cuda") + self.assertTrue(config.data.root.is_absolute()) + + def test_config_loader_rejects_missing_section(self) -> None: + with tempfile.TemporaryDirectory() as tmp: + config_path = Path(tmp) / "bad.toml" + config_path.write_text("[run]\nname = 'bad'\n") + + with self.assertRaisesRegex(ValueError, r"missing \[data\] section"): + load_training_config(config_path) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_training_data.py b/tests/test_training_data.py new file mode 100644 index 0000000..d42df56 --- /dev/null +++ b/tests/test_training_data.py @@ -0,0 +1,96 @@ +from __future__ import annotations + +import tempfile +import unittest +from pathlib import Path + +from airfrans_frontier.runtime import remove_pythonpath_entries + +remove_pythonpath_entries() + +import numpy as np + +from airfrans_frontier.training.data import create_case_split, load_processed_dataset, load_simulation_npz +from airfrans_frontier.training.normalize import compute_normalization_stats, normalize_targets + + +def write_case(path: Path, offset: float = 0.0) -> None: + features = np.array( + [ + [offset + 0.0, 1.0], + [offset + 1.0, 2.0], + [offset + 2.0, 3.0], + ], + dtype=np.float32, + ) + targets = np.array( + [ + [offset + 10.0, -1.0], + [offset + 11.0, 0.0], + [offset + 12.0, 1.0], + ], + dtype=np.float32, + ) + np.savez( + path, + features=features, + targets=targets, + feature_names=np.array(["x", "y"]), + target_names=np.array(["pressure", "velocity"]), + ) + + +class TrainingDataTests(unittest.TestCase): + def test_dataset_loader_rejects_malformed_npz(self) -> None: + with tempfile.TemporaryDirectory() as tmp: + path = Path(tmp) / "bad.npz" + np.savez(path, features=np.array([1.0, 2.0], dtype=np.float32), targets=np.ones((2, 1))) + + with self.assertRaisesRegex(ValueError, "features to be a 2D array"): + load_simulation_npz(path) + + def test_dataset_loader_loads_common_schema(self) -> None: + with tempfile.TemporaryDirectory() as tmp: + root = Path(tmp) + write_case(root / "case_a.npz", offset=0.0) + write_case(root / "case_b.npz", offset=1.0) + + samples = load_processed_dataset(root) + + self.assertEqual([sample.case_id for sample in samples], ["case_a", "case_b"]) + self.assertEqual(samples[0].feature_names, ("x", "y")) + self.assertEqual(samples[0].target_names, ("pressure", "velocity")) + + def test_case_split_is_deterministic_and_case_level(self) -> None: + case_ids = [f"case_{index}" for index in range(10)] + + first = create_case_split(case_ids, train_cases=6, val_cases=2, test_cases=2, seed=7) + second = create_case_split(case_ids, train_cases=6, val_cases=2, test_cases=2, seed=7) + + self.assertEqual(first, second) + self.assertEqual(len(set(first.train_ids) & set(first.val_ids)), 0) + self.assertEqual(len(set(first.train_ids) & set(first.test_ids)), 0) + self.assertEqual(len(first.train_ids), 6) + self.assertEqual(len(first.val_ids), 2) + self.assertEqual(len(first.test_ids), 2) + + def test_normalization_uses_train_split_only(self) -> None: + train_features = np.array([[0.0], [2.0]], dtype=np.float32) + train_targets = np.array([[10.0], [14.0]], dtype=np.float32) + validation_targets = np.array([[1000.0]], dtype=np.float32) + + stats = compute_normalization_stats( + train_features, + train_targets, + feature_names=("x",), + target_names=("pressure",), + ) + normalized_validation = normalize_targets(validation_targets, stats) + + self.assertAlmostEqual(float(stats.target_mean[0]), 12.0) + self.assertAlmostEqual(float(stats.target_std[0]), 2.0) + self.assertAlmostEqual(float(normalized_validation[0, 0]), 494.0) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_training_loop.py b/tests/test_training_loop.py new file mode 100644 index 0000000..c9c58a7 --- /dev/null +++ b/tests/test_training_loop.py @@ -0,0 +1,155 @@ +from __future__ import annotations + +import json +import subprocess +import sys +import tempfile +import unittest +from pathlib import Path +from unittest.mock import patch + +from airfrans_frontier.runtime import remove_pythonpath_entries + +remove_pythonpath_entries() + +import numpy as np +import torch + +from airfrans_frontier.training.config import load_training_config +from airfrans_frontier.training.loop import select_device + + +FEATURE_NAMES = np.array(["re_norm", "aoa_norm", "x", "y", "sdf"]) +TARGET_NAMES = np.array(["velocity_x", "velocity_y", "pressure", "turbulent_viscosity"]) + + +def write_toy_simulator_dataset(root: Path, *, cases: int = 4, points: int = 64) -> None: + root.mkdir(parents=True) + rng = np.random.default_rng(123) + for case_index in range(cases): + re_norm = np.full(points, -0.5 + 0.25 * case_index, dtype=np.float32) + aoa_norm = np.full(points, -0.2 + 0.15 * case_index, dtype=np.float32) + x = rng.uniform(-1.0, 1.0, size=points).astype(np.float32) + y = rng.uniform(-1.0, 1.0, size=points).astype(np.float32) + sdf = (np.sqrt(x * x + y * y) - 0.5).astype(np.float32) + features = np.stack([re_norm, aoa_norm, x, y, sdf], axis=1).astype(np.float32) + targets = np.stack( + [ + 0.5 * x + 0.2 * y + 0.1 * aoa_norm, + -0.3 * x + 0.7 * sdf, + x * y + 0.05 * re_norm, + sdf**2 + 0.1 * y, + ], + axis=1, + ).astype(np.float32) + np.savez( + root / f"case_{case_index:02d}.npz", + features=features, + targets=targets, + feature_names=FEATURE_NAMES, + target_names=TARGET_NAMES, + ) + + +def write_training_config( + path: Path, + *, + data_root: Path, + artifact_dir: Path, + device_type: str, + allow_cpu_fallback: bool = False, +) -> None: + path.write_text( + f""" +[run] +name = "test_mlp" +seed = 0 +artifact_dir = "{artifact_dir}" + +[data] +root = "{data_root}" +train_cases = 2 +val_cases = 1 +test_cases = 1 +points_per_case = 64 +batch_size = 64 + +[model] +type = "mlp" +hidden_width = 128 +depth = 4 +activation = "gelu" + +[optim] +lr = 0.01 +weight_decay = 0.0 +steps = 1000 +log_interval = 250 + +[device] +type = "{device_type}" +allow_cpu_fallback = {str(allow_cpu_fallback).lower()} +benchmark_kernels = true + +[loss] +type = "normalized_mse" +""".strip() + + "\n" + ) + + +class TrainingLoopTests(unittest.TestCase): + def test_cuda_config_fails_clearly_when_cuda_unavailable(self) -> None: + with tempfile.TemporaryDirectory() as tmp: + tmp_path = Path(tmp) + config_path = tmp_path / "config.toml" + write_training_config( + config_path, + data_root=tmp_path / "data", + artifact_dir=tmp_path / "artifacts", + device_type="cuda", + ) + config = load_training_config(config_path) + + with patch("torch.cuda.is_available", return_value=False): + with self.assertRaisesRegex(RuntimeError, "CUDA requested"): + select_device(config) + + def test_mlp_training_smoke_learns_tiny_deterministic_simulator(self) -> None: + with tempfile.TemporaryDirectory() as tmp: + tmp_path = Path(tmp) + data_root = tmp_path / "data" + artifact_dir = tmp_path / "artifacts" + config_path = tmp_path / "config.toml" + write_toy_simulator_dataset(data_root, cases=4, points=64) + device_type = "cuda" if torch.cuda.is_available() else "cpu" + write_training_config( + config_path, + data_root=data_root, + artifact_dir=artifact_dir, + device_type=device_type, + ) + + result = subprocess.run( + [sys.executable, "-m", "airfrans_frontier.cli", "train", str(config_path)], + text=True, + capture_output=True, + check=False, + ) + self.assertEqual(result.returncode, 0, msg=f"stdout={result.stdout}\nstderr={result.stderr}") + run_dir_line = next(line for line in result.stdout.splitlines() if line.startswith("run_dir: ")) + run_dir = Path(run_dir_line.removeprefix("run_dir: ")) + final_metrics = json.loads((run_dir / "final_metrics.json").read_text()) + + self.assertTrue(np.isfinite(final_metrics["train_loss"])) + self.assertLess(final_metrics["train_loss"], final_metrics["initial_train_loss"] * 0.1) + self.assertLess(final_metrics["train_loss"], 1e-2) + self.assertTrue((run_dir / "checkpoint.pt").exists()) + self.assertTrue((run_dir / "metrics.jsonl").exists()) + self.assertEqual(final_metrics["device"].startswith("cuda"), torch.cuda.is_available()) + if torch.cuda.is_available(): + self.assertIn("T550", final_metrics["gpu_name"]) + + +if __name__ == "__main__": + unittest.main() diff --git a/uv.lock b/uv.lock new file mode 100644 index 0000000..0ba29f0 --- /dev/null +++ b/uv.lock @@ -0,0 +1,1779 @@ +version = 1 +revision = 3 +requires-python = ">=3.11" +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version < '3.12'", +] + +[[package]] +name = "airfrans-frontier" +version = "0.1.0" +source = { editable = "." } +dependencies = [ + { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12'" }, + { name = "numpy", version = "2.5.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" }, + { name = "torch" }, +] + +[package.dev-dependencies] +dev = [ + { name = "ipykernel" }, + { name = "matplotlib" }, + { name = "nbclient" }, + { name = "nbformat" }, + { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12'" }, + { name = "numpy", version = "2.5.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" }, +] + +[package.metadata] +requires-dist = [ + { name = "numpy", specifier = ">=2.4.0" }, + { name = "torch", specifier = ">=2.8.0" }, +] + +[package.metadata.requires-dev] +dev = [ + { name = "ipykernel", specifier = ">=6.30.0" }, + { name = "matplotlib", specifier = ">=3.11.1" }, + { name = "nbclient", specifier = ">=0.10.2" }, + { name = "nbformat", specifier = ">=5.10.4" }, + { name = "numpy", specifier = ">=2.4.0" }, +] + +[[package]] +name = "appnope" +version = "0.1.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/35/5d/752690df9ef5b76e169e68d6a129fa6d08a7100ca7f754c89495db3c6019/appnope-0.1.4.tar.gz", hash = "sha256:1de3860566df9caf38f01f86f65e0e13e379af54f9e4bee1e66b48f2efffd1ee", size = 4170, upload-time = "2024-02-06T09:43:11.258Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/81/29/5ecc3a15d5a33e31b26c11426c45c501e439cb865d0bff96315d86443b78/appnope-0.1.4-py2.py3-none-any.whl", hash = "sha256:502575ee11cd7a28c0205f379b525beefebab9d161b7c964670864014ed7213c", size = 4321, upload-time = "2024-02-06T09:43:09.663Z" }, +] + +[[package]] +name = "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 = "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 = "cffi" +version = "2.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pycparser", marker = "implementation_name != 'PyPy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/57/5f/ff100cae70ebe9d8df1c01a00e510e45d9adb5c1fdda84791b199141de97/cffi-2.1.0.tar.gz", hash = "sha256:efc1cdd798b1aaf39b4610bba7aad28c9bea9b910f25c784ccf9ec1fa719d1f9", size = 531036, upload-time = "2026-07-06T21:34:30.382Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d3/67/85c89a59ba36a671e79638f44d466749f08179266a57e4f2ffdf92174072/cffi-2.1.0-cp311-cp311-macosx_10_15_x86_64.whl", hash = "sha256:02cb7ff33ded4f1532476731f89ede53e2e488a8e6205515a82144246ffa7dcc", size = 183845, upload-time = "2026-07-06T21:32:26.32Z" }, + { url = "https://files.pythonhosted.org/packages/ea/dd/e3b0baa2d3d6a857ac72b7efbf18e32e487c9cdafcc13049ad765495b15e/cffi-2.1.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:f5bce581e6b8c235e566a14768a943b172ada3ed73537bb0c0be1edee312d4e7", size = 184186, upload-time = "2026-07-06T21:32:28.025Z" }, + { url = "https://files.pythonhosted.org/packages/65/68/9f3ef890cf3c6ab97bd531c5677f67613d302165d16f8142b2811782a614/cffi-2.1.0-cp311-cp311-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:30b65779d598c370374fefabf138d456fd6f3216bfa7bedfab1ba82025b0cd93", size = 211892, upload-time = "2026-07-06T21:32:29.565Z" }, + { url = "https://files.pythonhosted.org/packages/22/d7/1a74539db16d8bfd839ff1515948948efbb162e574650fd3d846896eea95/cffi-2.1.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:88023dfe18799507b73f1dbb0d14326a17465de1bc9c9c7655c22845e9ddc3a2", size = 218793, upload-time = "2026-07-06T21:32:30.951Z" }, + { url = "https://files.pythonhosted.org/packages/ec/d1/9a5b7169499e8e8d8e636de70b97ac7c9447104d2ff1a2cd94790cea5162/cffi-2.1.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:0a96b74cda968eebbad56d973efe5098974f0a9fb323865bf99ea1fd24e3e64c", size = 205737, upload-time = "2026-07-06T21:32:32.216Z" }, + { url = "https://files.pythonhosted.org/packages/ba/b0/e131a9c41f10607926278453d9596163594fe1c4ebc46efe3b5e5b34eb84/cffi-2.1.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:a5781494d4d400a3f47f8f1da94b324f6e6b440a53387774002890a2a2f4b50f", size = 204909, upload-time = "2026-07-06T21:32:33.655Z" }, + { url = "https://files.pythonhosted.org/packages/fb/d2/4398416cd699b35167947c6e22aca52c47e69ad5695073c9f1f2c52e04aa/cffi-2.1.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:aa7a1b53a2a4452ada2d1b5dade9960b2522f1e61293a811a077439e39029565", size = 217883, upload-time = "2026-07-06T21:32:35.173Z" }, + { url = "https://files.pythonhosted.org/packages/a2/a5/d4fe77b589e5e82d43ebc809bf2e6474afe8e48e32ea050b9357645b6471/cffi-2.1.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:9d8272c0e483b024e1b9ad029821470ed8ec65631dbd90217469da0e7cd89f1c", size = 221251, upload-time = "2026-07-06T21:32:36.527Z" }, + { url = "https://files.pythonhosted.org/packages/22/f0/a2fc43084c0433caf7f461bccc013e28f848d04ee1c5ed7fce71423cf4d9/cffi-2.1.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:7762faa47e8ff7eb80bd261d9a7d8eea2d8baa69de5e95b70c1f338bbe712f02", size = 214250, upload-time = "2026-07-06T21:32:37.852Z" }, + { url = "https://files.pythonhosted.org/packages/04/8c/b925975448cf20634a9fbd5efceb807219db452653648d2897c0989cab2d/cffi-2.1.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:89095c1968b4ba8285840e131bf2891b09ae137fe2146905acae0354fbce1b5e", size = 219441, upload-time = "2026-07-06T21:32:39.146Z" }, + { url = "https://files.pythonhosted.org/packages/eb/da/5c4918a2d61d86fa927d716cb3d8e4626ef8dc8f605a599d32f33897f59a/cffi-2.1.0-cp311-cp311-win32.whl", hash = "sha256:64c753a0f87a256020004f37a1c8c02c480e725f910f0b2a0f3f07debd1b2479", size = 174496, upload-time = "2026-07-06T21:32:40.467Z" }, + { url = "https://files.pythonhosted.org/packages/f9/c8/6c2de1d55cf35ef8b92885d5ef280790f0fb9634d87ea1cc315176aecd61/cffi-2.1.0-cp311-cp311-win_amd64.whl", hash = "sha256:4f26194e3d95e06501b942642855aed4f953d55e95d7d01b7c4483db3ecff458", size = 185113, upload-time = "2026-07-06T21:32:41.761Z" }, + { url = "https://files.pythonhosted.org/packages/9e/4e/e8d7cb5783f1841a3c8fb3a7735838d7484d08ec08c9f984b14cac1ac0e9/cffi-2.1.0-cp311-cp311-win_arm64.whl", hash = "sha256:35aaea0c7ee0e58a5cd8c2fd1a48fdf7ece0d2699b7ecdda08194e9ce5dd9b3d", size = 179927, upload-time = "2026-07-06T21:32:42.961Z" }, + { url = "https://files.pythonhosted.org/packages/1e/85/990925db5df586ec90beb97529c853497e7f85ba0234830447faf41c3057/cffi-2.1.0-cp312-cp312-macosx_10_15_x86_64.whl", hash = "sha256:df2b82571a1b30f58a87bf4e5a9e78d2b1eff6c6ce8fd3aa3757221f93f0863f", size = 184829, upload-time = "2026-07-06T21:32:44.324Z" }, + { url = "https://files.pythonhosted.org/packages/4b/92/e7bb136ad6b5352603732cf907ef862ca103f20f2031c1735a46300c20c9/cffi-2.1.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:78474632761faa0fb96f30b1c928c84ebcf68713cbb80d15bab09dfe61640fde", size = 184728, upload-time = "2026-07-06T21:32:45.683Z" }, + { url = "https://files.pythonhosted.org/packages/c3/c0/d1ec30ffb370f748f2fb54425972bfef9871e0132e82fb589c46b6676049/cffi-2.1.0-cp312-cp312-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:5972433ad71a9e46516584ef60a0fda12d9dc459938d1539c3ddecf9bdc1368d", size = 214815, upload-time = "2026-07-06T21:32:48.557Z" }, + { url = "https://files.pythonhosted.org/packages/1b/dc/5620cf930688be01f2d673804291de757a934c90b946dbdc3d84130c2ea4/cffi-2.1.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:b6422532152adf4e59b110cb2808cee7a033800952f5c036b4af047ee43199e7", size = 222429, upload-time = "2026-07-06T21:32:49.848Z" }, + { url = "https://files.pythonhosted.org/packages/4b/a4/77b53abbf7a1e0beb9637edbef2a94d15f9c822f591e85d439ffd91519a6/cffi-2.1.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:46b1c8db8f6122420f32d02fffb924c2fe9bc772d228c7c711748fff56aabb2b", size = 210315, upload-time = "2026-07-06T21:32:51.221Z" }, + { url = "https://files.pythonhosted.org/packages/58/0c/f528df19cc94b675087324d4760d9e6d5bfae97d6217aa4fac43de4f5fcc/cffi-2.1.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:d9fafc5aa2e2a39aaf7f8cc0c1f044a9b07fca12e558dca53a3cc5c654ad67a7", size = 208859, upload-time = "2026-07-06T21:32:52.512Z" }, + { url = "https://files.pythonhosted.org/packages/62/f2/c9522a81c32132799a1972c39f5c5f8b4c8b9f00488a23feaa6c06f07741/cffi-2.1.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1e9f50d192a3e525b15a75ab5114e442d83d657b7ec29182a991bc9a88fd3a66", size = 221844, upload-time = "2026-07-06T21:32:53.704Z" }, + { url = "https://files.pythonhosted.org/packages/6e/28/bd53988b9833e8f8ad539d26f4c07a6b3f6bcb1e9e02e7ca038250b3428d/cffi-2.1.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:98fff996e983a36d3aa2eca83af40c5821202e7e6f32d13ae94e3d2286f10cfe", size = 225287, upload-time = "2026-07-06T21:32:54.907Z" }, + { url = "https://files.pythonhosted.org/packages/79/99/0d0fd37f055224085f42bbb2c022d002e17dde4a97972822327b07d84101/cffi-2.1.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:379de10ce1ba048b1448599d1b37b24caee16309d1ac98d3982fc997f768700b", size = 223681, upload-time = "2026-07-06T21:32:56.329Z" }, + { url = "https://files.pythonhosted.org/packages/b0/80/c138990aa2a70b1a269f6e06348729836d733d6f970867943f61d367f8cc/cffi-2.1.0-cp312-cp312-win32.whl", hash = "sha256:9b8f0f26ca4e7513c534d351eca551947d053fac438f2a04ac96d882909b0d3a", size = 175269, upload-time = "2026-07-06T21:32:57.777Z" }, + { url = "https://files.pythonhosted.org/packages/a8/eb/f636456ff21a83fc13c032b58cc5dde061691546ac79efa284b2989b7982/cffi-2.1.0-cp312-cp312-win_amd64.whl", hash = "sha256:c97f080ea627e2863524c5af3836e2270b5f5dfff1f104392b959f8df0c5d384", size = 185881, upload-time = "2026-07-06T21:32:59.253Z" }, + { url = "https://files.pythonhosted.org/packages/dd/2c/400ea43e721727dca8a65c4521390e9196757caba4a45643acb2b63271b8/cffi-2.1.0-cp312-cp312-win_arm64.whl", hash = "sha256:6d194185eabd279f1c05ebe3504265ddfc5ad2b58d0714f7db9f01da592e9eb6", size = 180088, upload-time = "2026-07-06T21:33:02.278Z" }, + { url = "https://files.pythonhosted.org/packages/96/88/a996879e2eeccb815f6e3a5967b12a308257412acec882039d386bd2aa7b/cffi-2.1.0-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:10537b1df4967ca26d21e5072d7d54188354483b91dc75058968d3f0cf13fbda", size = 194331, upload-time = "2026-07-06T21:33:03.697Z" }, + { url = "https://files.pythonhosted.org/packages/58/85/7ae00d5c8dd6266f4e944c3db630f3c5c9a98b61d469c714d848b1d8138a/cffi-2.1.0-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:a95b05f9baf29b91171b3a8bd2020b028835243e7b0ff6bb23e2a3c228518b1b", size = 196966, upload-time = "2026-07-06T21:33:05.353Z" }, + { url = "https://files.pythonhosted.org/packages/8c/e9/45c3a76ad8d43ad9261f4c95436da61128d3ca545d72b9612c0ab5be0b1c/cffi-2.1.0-cp313-cp313-macosx_10_15_x86_64.whl", hash = "sha256:15faec4adfff450819f3aee0e2e02c812de6edb88203aa58807955db2003472a", size = 184795, upload-time = "2026-07-06T21:33:06.699Z" }, + { url = "https://files.pythonhosted.org/packages/84/4c/82f132cb4418ee6d953d982b19191e87e2a6372c8a4ce36e50b69d6ade4a/cffi-2.1.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:716ff8ec22f20b4d988b12884086bcef0fc99737043e503f7a3935a6be99b1ea", size = 184746, upload-time = "2026-07-06T21:33:08.071Z" }, + { url = "https://files.pythonhosted.org/packages/a0/1c/4ed5a0e5bdca6cbc275556de3328dd1b76fd0c11cc13c88fe66d1d8715f2/cffi-2.1.0-cp313-cp313-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:63960549e4f8dc41e31accb97b975abaecfc44c03e396c093a6436763c2ea7db", size = 214747, upload-time = "2026-07-06T21:33:09.671Z" }, + { url = "https://files.pythonhosted.org/packages/3a/a6/e879bb68cc23a2bc9ba8f4b7d8019f0c2694bad2ab6c4a3701d429439f58/cffi-2.1.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ff067a8d8d880e7809e4ac88eb009bb848870115317b306666502ccad30b147f", size = 222392, upload-time = "2026-07-06T21:33:10.896Z" }, + { url = "https://files.pythonhosted.org/packages/88/f6/01890cfd63c08f8eb96a8319b0443690197d240a8bd6346048cf7bde9190/cffi-2.1.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:3b926723c13eba9f81d2ef3820d63aeceec3b2d4639906047bf675cb8a7a500d", size = 210285, upload-time = "2026-07-06T21:33:12.251Z" }, + { url = "https://files.pythonhosted.org/packages/a6/cf/2b684132056f438567b61e19d690dd31cd0921ace051e0a458be6074369e/cffi-2.1.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:47ff3a8bfd8cb9da1af7524b965127095055654c177fcfc7578debcb015eecd0", size = 208801, upload-time = "2026-07-06T21:33:13.617Z" }, + { url = "https://files.pythonhosted.org/packages/6f/08/f2e7d62c460faae0926f2d6e423694aa409ced3bc1fe2927a0a6e5f05416/cffi-2.1.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:799416bae98336e400981ff6e532d67d5c709cfb30afb79865a1315f94b0e224", size = 221808, upload-time = "2026-07-06T21:33:15.466Z" }, + { url = "https://files.pythonhosted.org/packages/38/37/04f54b8e63a02f3d908332c9effbf8c366167c6f733ed8a3d4f79b7e2a1e/cffi-2.1.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:961be50688f7fba2fa65f63712d3b9b341a22311f5253460ce933f52f0de1c8c", size = 225241, upload-time = "2026-07-06T21:33:16.869Z" }, + { url = "https://files.pythonhosted.org/packages/a9/d6/c72eecca433cd3e681c65ed313ab4835d9d4a379704d0f628a6a05f51c2e/cffi-2.1.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:bf5c6cf48238b0eb4c086978c492ad1cbc22373fc5b2d7353b3a598ce6db887a", size = 223588, upload-time = "2026-07-06T21:33:18.239Z" }, + { url = "https://files.pythonhosted.org/packages/c6/4b/e706f67279140f92939da3475ad610df18bfd52d50f14953a8e5fede71d5/cffi-2.1.0-cp313-cp313-win32.whl", hash = "sha256:db3eb7d46527159a878ec3460e9d40615bc25ba337d477db681aea6e4f05c5d2", size = 175248, upload-time = "2026-07-06T21:33:19.799Z" }, + { url = "https://files.pythonhosted.org/packages/5a/47/59eb7975cb0e4ef0afa764ea945b29a5bb4537a9f771cb7d6c8a5dd74c95/cffi-2.1.0-cp313-cp313-win_amd64.whl", hash = "sha256:8e74a6135550c4748af665b1b1118b6aab33b1fc6a16f9aff630af107c3b4512", size = 185717, upload-time = "2026-07-06T21:33:21.47Z" }, + { url = "https://files.pythonhosted.org/packages/5a/af/34fee85c48f8d94efc8597bc09470c9dd274c145f1c12e0fbc6ab6d38d74/cffi-2.1.0-cp313-cp313-win_arm64.whl", hash = "sha256:2282cd5e38aa8accd03e99d1256af8411c84cdbee6a89d841b563fdbd1f3e50f", size = 180114, upload-time = "2026-07-06T21:33:22.515Z" }, + { url = "https://files.pythonhosted.org/packages/d8/f0/81478e482afa03f6d18dc8f2afb5edc45b3080853b634b5ed91961be0998/cffi-2.1.0-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:d2117334c3af3bdcb9a88522b844a2bdb5efdc4f71c6c822df55486ae1c3347a", size = 194142, upload-time = "2026-07-06T21:33:23.657Z" }, + { url = "https://files.pythonhosted.org/packages/7d/95/8de304305cd9204974b0ca051b86d307cafca13aa575a0ef1b44d92c0d8c/cffi-2.1.0-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:702c436735fbe99d59ada02a1f65cfc0d31c0ee8b7290912f8fbc5cd1e4b16c3", size = 196819, upload-time = "2026-07-06T21:33:25.007Z" }, + { url = "https://files.pythonhosted.org/packages/20/71/7c8372d30e42415602ed9f268f7cfd66f1b855fed881ecd168bcb45dbc0b/cffi-2.1.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:1ff3456eab0d889592d1936d6125bbfbc7ae4d3354a700f8bd80450a66445d4d", size = 184965, upload-time = "2026-07-06T21:33:26.605Z" }, + { url = "https://files.pythonhosted.org/packages/d6/5c/584e626835f0375c928176c04137c96927165cb8733cdb3150ec04e5ee5e/cffi-2.1.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c4165821e131d6d4ca444347c2b694e2311bcfa3fe5a861cc72968f28867beac", size = 184952, upload-time = "2026-07-06T21:33:27.823Z" }, + { url = "https://files.pythonhosted.org/packages/2e/d2/065fcae1c73979fac8e054462478d0ff8a29c40cdc2ed7ea5676a061df53/cffi-2.1.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:276f20fffd7b396e12516ba8edf9509210ac248cbbc5acbc39cd512f9f59ebe6", size = 222353, upload-time = "2026-07-06T21:33:29.178Z" }, + { url = "https://files.pythonhosted.org/packages/ed/a5/e8bbb1ce5b3ac2f53ad6a10bde44318a5a8d99d4f4a000d44a6e39aeb3e4/cffi-2.1.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:7d5980a3433d4b71a5e120f9dd551403d7824e31e2e67124fe2769c404c06913", size = 210051, upload-time = "2026-07-06T21:33:30.534Z" }, + { url = "https://files.pythonhosted.org/packages/28/ed/c127d3ac36e899c965e3361357c3befacd6578c03f40125183e41c3b219e/cffi-2.1.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:6ca4919c6e4f89aa99c42510b42cf54596892c00b3f9077f6bdd1505e24b9c8d", size = 208630, upload-time = "2026-07-06T21:33:31.753Z" }, + { url = "https://files.pythonhosted.org/packages/cc/d7/97d3136f81db489ec8d1d67748c110d6c994268fd7528014aa9f2b085e4e/cffi-2.1.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d53d10f7da99ae46f7373b9150393e9c5eab9b224909982b43832668de4779f5", size = 221593, upload-time = "2026-07-06T21:33:33.044Z" }, + { url = "https://files.pythonhosted.org/packages/d3/27/93195977168ee63aed233a1a0993a2178798654d1f4bddcdd321d6fd3b21/cffi-2.1.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c351efb95e832a853a29361675f33a7ce53de1a109cd73fd47af0712213aa4ce", size = 225146, upload-time = "2026-07-06T21:33:34.224Z" }, + { url = "https://files.pythonhosted.org/packages/b3/c1/6dbd291ee2ae5a50a034aa057207081f545923bbf15dad4511e985aafff5/cffi-2.1.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:dbf7c7a88e2bac086f06d14577332760bdeecc42bdec8ac4077f6260557d9326", size = 223240, upload-time = "2026-07-06T21:33:35.57Z" }, + { url = "https://files.pythonhosted.org/packages/0f/6f/ade5ce9863a57992a6ea3d0d10d7e29b8749fc127204b3d493d667b2815f/cffi-2.1.0-cp314-cp314-win32.whl", hash = "sha256:1854b724d00f6654c742097d5387569021be12d3a0f770eae1df8f8acfcc6acd", size = 177723, upload-time = "2026-07-06T21:33:51.626Z" }, + { url = "https://files.pythonhosted.org/packages/41/de/92b9eeed4ae4a21d6fd9b2a2c8505cbed573299902ea73981cc13f7ff62c/cffi-2.1.0-cp314-cp314-win_amd64.whl", hash = "sha256:1b96bfe2c4bd825681b7d311ad6d9b7280a091f43e8f63da5729638083cd3bfb", size = 187937, upload-time = "2026-07-06T21:33:53.403Z" }, + { url = "https://files.pythonhosted.org/packages/2e/1a/cc6ae6c2913a03aab8898eee57963cf1035b8df5872ed8b9115fcc7e2be8/cffi-2.1.0-cp314-cp314-win_arm64.whl", hash = "sha256:7d28dff1db6764108bc30788d85d61c876beff416d9a49cb9dd7c5a9f34f5804", size = 183001, upload-time = "2026-07-06T21:33:54.74Z" }, + { url = "https://files.pythonhosted.org/packages/14/f0/134c00ce0779ec86dea2aa1aac69339c2741a8045072676763512363a2ea/cffi-2.1.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:7ea6b3e2c4250ff1de21c630fe72d0f63eb95c2c32ffbf64a358cf4a8836d714", size = 188538, upload-time = "2026-07-06T21:33:36.792Z" }, + { url = "https://files.pythonhosted.org/packages/50/d8/3b86aba791cb610d24e8a3e1b2cd529e71fa15096b04e4d4e360049d4a4c/cffi-2.1.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:6af371f3767faeffc6ac1ef57cdfd25844403e9d3f476c5537caee499de96376", size = 188230, upload-time = "2026-07-06T21:33:38.011Z" }, + { url = "https://files.pythonhosted.org/packages/14/d0/117dcd9209255ad8571fbc8c92ef32593a1d294dcec91ddc4e4db50606f2/cffi-2.1.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:eb4e8997a49aa2c08a3e43c9045d224448b8941d88e7ac163c7d383e560cbf98", size = 223899, upload-time = "2026-07-06T21:33:39.514Z" }, + { url = "https://files.pythonhosted.org/packages/b6/3d/f20f8b886b254e3ad10e15cd4186d3aed49f3e6a35ab37aab9f8f25f7c03/cffi-2.1.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:bf01d8c84cbea96b944c73b22182e6c7c432b3475632b8111dbfdc95ddad6e13", size = 211652, upload-time = "2026-07-06T21:33:40.851Z" }, + { url = "https://files.pythonhosted.org/packages/28/3b/fad54de07260b93ddeef4b96d0131d57ea900675df1d410ae1deee52d7a6/cffi-2.1.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:33eb1ad83ebe8f313e0df035c406227d55a79456704a863fad9842136af5ad7d", size = 210755, upload-time = "2026-07-06T21:33:42.183Z" }, + { url = "https://files.pythonhosted.org/packages/cc/82/3d5c705acb7abbba9bbd7d79b8e62e0f25b6120eb7ae6ac49f1b721722fe/cffi-2.1.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ac0f1a2d0cfa7eea3f2aaf006ab6e70e8feeb16b75d65b7e5939982ca2f11056", size = 223933, upload-time = "2026-07-06T21:33:43.603Z" }, + { url = "https://files.pythonhosted.org/packages/6c/d0/47e338384ab6b1004241002fa616301020cea4fc95f283506565d252f276/cffi-2.1.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c16914df9fb7f500e440e6875fa23ff5e0b31db01fa9c06af98d59a91f0dc2e4", size = 226749, upload-time = "2026-07-06T21:33:45.046Z" }, + { url = "https://files.pythonhosted.org/packages/70/25/65bd5b58ea4bfdfc15cde02cb5365f89ef8ab8b2adfb8fe5c4bd4233382f/cffi-2.1.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5ecbd0499275d57506d397eebe1981cee87b47fcd9ef5c22cab7ed7644a39a94", size = 225703, upload-time = "2026-07-06T21:33:46.374Z" }, + { url = "https://files.pythonhosted.org/packages/dc/78/aa01ac599a8a4322533d45a1f9bc93b338276d2d59dabbe7c6d92a775c81/cffi-2.1.0-cp314-cp314t-win32.whl", hash = "sha256:7d034dcffa09e9a46c93fa3a3be402096cb5354ac6e41ab8e5cc9cd8b642ad76", size = 182857, upload-time = "2026-07-06T21:33:47.696Z" }, + { url = "https://files.pythonhosted.org/packages/b9/26/d00496b22de4d4228f32dde94ad996f350c8aad676d63bcca0743c8dea4d/cffi-2.1.0-cp314-cp314t-win_amd64.whl", hash = "sha256:0582a58f3051372229ca8e7f5f589f9e5632678208d8636fea3676711fdf7fe5", size = 194065, upload-time = "2026-07-06T21:33:48.953Z" }, + { url = "https://files.pythonhosted.org/packages/d5/dd/0c7dbf815a579ff005008a2d815a55d6bb047c349eef536d9dc53d3f0a8d/cffi-2.1.0-cp314-cp314t-win_arm64.whl", hash = "sha256:510aeeeac94811b138077451da1fb18b308a5feab47dd2b603af55804155e1c8", size = 186404, upload-time = "2026-07-06T21:33:50.309Z" }, + { url = "https://files.pythonhosted.org/packages/55/c7/8c8c50cb11c6750051daf12164098a9a6f027ac4356967fd4d800a07f242/cffi-2.1.0-cp315-cp315-ios_13_0_arm64_iphoneos.whl", hash = "sha256:2e9dabb9abcb7ad15938c7196ad5c1718a4e6d33cc79b4c0209bdb64c4a54a5c", size = 194121, upload-time = "2026-07-06T21:33:56.109Z" }, + { url = "https://files.pythonhosted.org/packages/99/e2/67680bf19a6b60d2bb7ff83baefa2a4c3d2d7dc0f3277034b802e1fc504c/cffi-2.1.0-cp315-cp315-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:37f525a7e7e50c017fdebe58b787be310ad59357ae43a053943a6e1a6c526001", size = 196820, upload-time = "2026-07-06T21:33:57.288Z" }, + { url = "https://files.pythonhosted.org/packages/ed/da/4bbe583a3b3a5c8c60892124fe17f3fa3656523faf0d3484eae90f091853/cffi-2.1.0-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:95f2954c2c9473d892eca6e0409f3568b37ab62a8eedb122461f73cc273476e3", size = 184936, upload-time = "2026-07-06T21:33:58.765Z" }, + { url = "https://files.pythonhosted.org/packages/e5/4b/1f4c36ab273980d7aa75bb126ea4f8971f24a96108acad3a0a084028c57b/cffi-2.1.0-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:cdf2448aab5f661c9315308ec8b93f4e8a1a67a3c733f8631067a2b67d5913dc", size = 185045, upload-time = "2026-07-06T21:34:00.085Z" }, + { url = "https://files.pythonhosted.org/packages/ef/c3/ad299dc38f3583f8d916b299f028af418a9ec98bc695fcbebeae7420691c/cffi-2.1.0-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:90bec57cf82089383bd06a605b3eb8daebf7e5a668520beaf6e327a83a947699", size = 222342, upload-time = "2026-07-06T21:34:01.814Z" }, + { url = "https://files.pythonhosted.org/packages/eb/d8/df4543cc087245044ed02ef3ad8e0a26619d0075ac7a77a12dc81177851b/cffi-2.1.0-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:6274dcb2d15cef48daa73ed1be5a40d501d74dccd0cd6db364776d12cb6ba022", size = 210073, upload-time = "2026-07-06T21:34:03.255Z" }, + { url = "https://files.pythonhosted.org/packages/2c/0e/fac738d73728c6cea2a88a2883dca54892496cbba88a1dc1f2909cb8a6f5/cffi-2.1.0-cp315-cp315-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:2b71d409cccee78310ab5dec549aed052aaea483346e282c7b02362596e01bb0", size = 208551, upload-time = "2026-07-06T21:34:04.433Z" }, + { url = "https://files.pythonhosted.org/packages/e6/3f/0b04a700dd64f465c93020253a793a82c9b4dff9961f48facd0df945d9b8/cffi-2.1.0-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7d3538f9c0e50670f4deb93dbb696576e60590369cae2faf7de681e597a8a1f1", size = 221649, upload-time = "2026-07-06T21:34:06.157Z" }, + { url = "https://files.pythonhosted.org/packages/5d/7c/b7379a5704c79eda57ce075869ba70a0368d1c850f803b3c0d078d39dcaf/cffi-2.1.0-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:8f9ec95b8a043d3dfbc74d9abc6f7baf524dd27a8dc160b0a32ff9cdab650c28", size = 225203, upload-time = "2026-07-06T21:34:07.489Z" }, + { url = "https://files.pythonhosted.org/packages/5a/02/d5e6c43ea85c41bda2a184a3418f195fe7cf602967a8d2b94e085b83deef/cffi-2.1.0-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:af5e2915d41fe6c961694d7bfdc8562942638200f3ce2765dfb8b745cf997629", size = 223263, upload-time = "2026-07-06T21:34:08.712Z" }, + { url = "https://files.pythonhosted.org/packages/2c/d8/772b8259bf75749adffb1c546828978381fb516f60cf701f6c83daf60c85/cffi-2.1.0-cp315-cp315-win32.whl", hash = "sha256:0a42c688d19fca6e095a53c6a6e2295a5b050a8b289f109adab02a9e61a25de6", size = 177696, upload-time = "2026-07-06T21:34:26.355Z" }, + { url = "https://files.pythonhosted.org/packages/2f/dd/afa2191fc6d57fedd26e5844a2fe2fcc0bbfa00961bbaa5a41e4921e7cca/cffi-2.1.0-cp315-cp315-win_amd64.whl", hash = "sha256:bccbbb5ee76a61f9d99b5bf3846a51d7fca4b6a732fe46f89295610edaf41853", size = 187914, upload-time = "2026-07-06T21:34:27.58Z" }, + { url = "https://files.pythonhosted.org/packages/05/ef/6cd4f8c671517162379dc79cfae5aea9106bc38abb89628d5c16adf6a838/cffi-2.1.0-cp315-cp315-win_arm64.whl", hash = "sha256:8d35c139744adb3e727cd51b1a18324bbe44b8bd41bf8322bca4d41289f48eda", size = 183004, upload-time = "2026-07-06T21:34:28.905Z" }, + { url = "https://files.pythonhosted.org/packages/11/b6/12fc55092817a5faa26fb8c40c7f9d662e11a46ee248c137aafc42517d92/cffi-2.1.0-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:f9912624a0c0b834b7520d7769b3644453aabc0a7e1c839da7359f050750e9bc", size = 188378, upload-time = "2026-07-06T21:34:09.926Z" }, + { url = "https://files.pythonhosted.org/packages/8d/2e/cdac88979f295fde5daa69622c7d2111e56e7ceb94f211357fbe452339e4/cffi-2.1.0-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:df92f2aba50eb4d96718b68ef76f2e57a57b54f2fa62333496d16c6d585a85ca", size = 188319, upload-time = "2026-07-06T21:34:11.101Z" }, + { url = "https://files.pythonhosted.org/packages/e0/27/1d0b408497e41a74795af122d7b603c418c5fed0171450f899afd04e594f/cffi-2.1.0-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:0520e1f4c35f44e209cbbb421b67eec42e6a157f59444dfb6058874ff3610e5d", size = 223904, upload-time = "2026-07-06T21:34:12.606Z" }, + { url = "https://files.pythonhosted.org/packages/8b/31/e115c985105dd7ffb32444505f18ceb874bb42d992af05d5dced7ecf1980/cffi-2.1.0-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:3681e031db29958a7502f5c0c9d6bbc4c36cb20f7b104086fa642d1799631ff8", size = 211554, upload-time = "2026-07-06T21:34:13.987Z" }, + { url = "https://files.pythonhosted.org/packages/5a/67/9e6e09409336d9e515c58367e7cfcf4f89df06ad25252675595a58eb59d5/cffi-2.1.0-cp315-cp315t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:762f99479dcb369f60ab9017ad4ab97a36a1dd7c1ee5a3b15db0f4b8659120cd", size = 210795, upload-time = "2026-07-06T21:34:15.972Z" }, + { url = "https://files.pythonhosted.org/packages/19/e5/d3cc82a4a0be7902af279c04181ad038449c096734464a5ae1de3e1401bd/cffi-2.1.0-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:0611e7ebf90573a535ebdc33ae9da222d037853983e13359f580fab781ca017f", size = 223843, upload-time = "2026-07-06T21:34:17.509Z" }, + { url = "https://files.pythonhosted.org/packages/b9/65/b434abc97ce7cecc2c640fde160507c0ecc7e21544b483ba3325d2e2ea17/cffi-2.1.0-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:86cf8755a791f72c85dc287128cc62d4f24d392e3f1e15837245623f4a33cccc", size = 226773, upload-time = "2026-07-06T21:34:19.05Z" }, + { url = "https://files.pythonhosted.org/packages/b5/9f/d4dc66ca651eb1145a133314cda721abf13cfac3d28c4a0402263ae6ad75/cffi-2.1.0-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:ba00f661f8ba35d075c937174e27c2c421cec3942fd2e0ea3e66996757c0fdd9", size = 225719, upload-time = "2026-07-06T21:34:20.576Z" }, + { url = "https://files.pythonhosted.org/packages/68/5a/e536c528bc8057496c360c0978559a2dc45653f89dd6151078aa7d8fca1a/cffi-2.1.0-cp315-cp315t-win32.whl", hash = "sha256:cb96698e3c7413d906ce83f8ffd245ec1bd94707541f299d0ce4d6b0193e982b", size = 182760, upload-time = "2026-07-06T21:34:22.059Z" }, + { url = "https://files.pythonhosted.org/packages/d3/0b/0ffe8b82d3875bced5fa1e7986a7a46b748262a40ab7f60b475eb9fb1bb3/cffi-2.1.0-cp315-cp315t-win_amd64.whl", hash = "sha256:f146d154428a2523f9cc7936c02353c2459b8f6cf07d3cd1ee1c0a611109c5d5", size = 193769, upload-time = "2026-07-06T21:34:23.589Z" }, + { url = "https://files.pythonhosted.org/packages/a0/17/1073b53b68c9b5ca6914adf5f8bf55aacc2d3be102418c90700160ea8605/cffi-2.1.0-cp315-cp315t-win_arm64.whl", hash = "sha256:cbb7640ce37159548d2147b5b8c241f962143d4c71231431820783f4dc78f210", size = 186405, upload-time = "2026-07-06T21:34:24.857Z" }, +] + +[[package]] +name = "colorama" +version = "0.4.6" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" } +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" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12'" }, + { name = "numpy", version = "2.5.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/58/01/1253e6698a07380cd31a736d248a3f2a50a7c88779a1813da27503cadc2a/contourpy-1.3.3.tar.gz", hash = "sha256:083e12155b210502d0bca491432bb04d56dc3432f95a979b429f2848c3dbe880", size = 13466174, upload-time = "2025-07-26T12:03:12.549Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/91/2e/c4390a31919d8a78b90e8ecf87cd4b4c4f05a5b48d05ec17db8e5404c6f4/contourpy-1.3.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:709a48ef9a690e1343202916450bc48b9e51c049b089c7f79a267b46cffcdaa1", size = 288773, upload-time = "2025-07-26T12:01:02.277Z" }, + { url = "https://files.pythonhosted.org/packages/0d/44/c4b0b6095fef4dc9c420e041799591e3b63e9619e3044f7f4f6c21c0ab24/contourpy-1.3.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:23416f38bfd74d5d28ab8429cc4d63fa67d5068bd711a85edb1c3fb0c3e2f381", size = 270149, upload-time = "2025-07-26T12:01:04.072Z" }, + { url = "https://files.pythonhosted.org/packages/30/2e/dd4ced42fefac8470661d7cb7e264808425e6c5d56d175291e93890cce09/contourpy-1.3.3-cp311-cp311-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:929ddf8c4c7f348e4c0a5a3a714b5c8542ffaa8c22954862a46ca1813b667ee7", size = 329222, upload-time = "2025-07-26T12:01:05.688Z" }, + { url = "https://files.pythonhosted.org/packages/f2/74/cc6ec2548e3d276c71389ea4802a774b7aa3558223b7bade3f25787fafc2/contourpy-1.3.3-cp311-cp311-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9e999574eddae35f1312c2b4b717b7885d4edd6cb46700e04f7f02db454e67c1", size = 377234, upload-time = "2025-07-26T12:01:07.054Z" }, + { url = "https://files.pythonhosted.org/packages/03/b3/64ef723029f917410f75c09da54254c5f9ea90ef89b143ccadb09df14c15/contourpy-1.3.3-cp311-cp311-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0bf67e0e3f482cb69779dd3061b534eb35ac9b17f163d851e2a547d56dba0a3a", size = 380555, upload-time = "2025-07-26T12:01:08.801Z" }, + { url = "https://files.pythonhosted.org/packages/5f/4b/6157f24ca425b89fe2eb7e7be642375711ab671135be21e6faa100f7448c/contourpy-1.3.3-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:51e79c1f7470158e838808d4a996fa9bac72c498e93d8ebe5119bc1e6becb0db", size = 355238, upload-time = "2025-07-26T12:01:10.319Z" }, + { url = "https://files.pythonhosted.org/packages/98/56/f914f0dd678480708a04cfd2206e7c382533249bc5001eb9f58aa693e200/contourpy-1.3.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:598c3aaece21c503615fd59c92a3598b428b2f01bfb4b8ca9c4edeecc2438620", size = 1326218, upload-time = "2025-07-26T12:01:12.659Z" }, + { url = "https://files.pythonhosted.org/packages/fb/d7/4a972334a0c971acd5172389671113ae82aa7527073980c38d5868ff1161/contourpy-1.3.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:322ab1c99b008dad206d406bb61d014cf0174df491ae9d9d0fac6a6fda4f977f", size = 1392867, upload-time = "2025-07-26T12:01:15.533Z" }, + { url = "https://files.pythonhosted.org/packages/75/3e/f2cc6cd56dc8cff46b1a56232eabc6feea52720083ea71ab15523daab796/contourpy-1.3.3-cp311-cp311-win32.whl", hash = "sha256:fd907ae12cd483cd83e414b12941c632a969171bf90fc937d0c9f268a31cafff", size = 183677, upload-time = "2025-07-26T12:01:17.088Z" }, + { url = "https://files.pythonhosted.org/packages/98/4b/9bd370b004b5c9d8045c6c33cf65bae018b27aca550a3f657cdc99acdbd8/contourpy-1.3.3-cp311-cp311-win_amd64.whl", hash = "sha256:3519428f6be58431c56581f1694ba8e50626f2dd550af225f82fb5f5814d2a42", size = 225234, upload-time = "2025-07-26T12:01:18.256Z" }, + { url = "https://files.pythonhosted.org/packages/d9/b6/71771e02c2e004450c12b1120a5f488cad2e4d5b590b1af8bad060360fe4/contourpy-1.3.3-cp311-cp311-win_arm64.whl", hash = "sha256:15ff10bfada4bf92ec8b31c62bf7c1834c244019b4a33095a68000d7075df470", size = 193123, upload-time = "2025-07-26T12:01:19.848Z" }, + { url = "https://files.pythonhosted.org/packages/be/45/adfee365d9ea3d853550b2e735f9d66366701c65db7855cd07621732ccfc/contourpy-1.3.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:b08a32ea2f8e42cf1d4be3169a98dd4be32bafe4f22b6c4cb4ba810fa9e5d2cb", size = 293419, upload-time = "2025-07-26T12:01:21.16Z" }, + { url = "https://files.pythonhosted.org/packages/53/3e/405b59cfa13021a56bba395a6b3aca8cec012b45bf177b0eaf7a202cde2c/contourpy-1.3.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:556dba8fb6f5d8742f2923fe9457dbdd51e1049c4a43fd3986a0b14a1d815fc6", size = 273979, upload-time = "2025-07-26T12:01:22.448Z" }, + { url = "https://files.pythonhosted.org/packages/d4/1c/a12359b9b2ca3a845e8f7f9ac08bdf776114eb931392fcad91743e2ea17b/contourpy-1.3.3-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:92d9abc807cf7d0e047b95ca5d957cf4792fcd04e920ca70d48add15c1a90ea7", size = 332653, upload-time = "2025-07-26T12:01:24.155Z" }, + { url = "https://files.pythonhosted.org/packages/63/12/897aeebfb475b7748ea67b61e045accdfcf0d971f8a588b67108ed7f5512/contourpy-1.3.3-cp312-cp312-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b2e8faa0ed68cb29af51edd8e24798bb661eac3bd9f65420c1887b6ca89987c8", size = 379536, upload-time = "2025-07-26T12:01:25.91Z" }, + { url = "https://files.pythonhosted.org/packages/43/8a/a8c584b82deb248930ce069e71576fc09bd7174bbd35183b7943fb1064fd/contourpy-1.3.3-cp312-cp312-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:626d60935cf668e70a5ce6ff184fd713e9683fb458898e4249b63be9e28286ea", size = 384397, upload-time = "2025-07-26T12:01:27.152Z" }, + { url = "https://files.pythonhosted.org/packages/cc/8f/ec6289987824b29529d0dfda0d74a07cec60e54b9c92f3c9da4c0ac732de/contourpy-1.3.3-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4d00e655fcef08aba35ec9610536bfe90267d7ab5ba944f7032549c55a146da1", size = 362601, upload-time = "2025-07-26T12:01:28.808Z" }, + { url = "https://files.pythonhosted.org/packages/05/0a/a3fe3be3ee2dceb3e615ebb4df97ae6f3828aa915d3e10549ce016302bd1/contourpy-1.3.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:451e71b5a7d597379ef572de31eeb909a87246974d960049a9848c3bc6c41bf7", size = 1331288, upload-time = "2025-07-26T12:01:31.198Z" }, + { url = "https://files.pythonhosted.org/packages/33/1d/acad9bd4e97f13f3e2b18a3977fe1b4a37ecf3d38d815333980c6c72e963/contourpy-1.3.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:459c1f020cd59fcfe6650180678a9993932d80d44ccde1fa1868977438f0b411", size = 1403386, upload-time = "2025-07-26T12:01:33.947Z" }, + { url = "https://files.pythonhosted.org/packages/cf/8f/5847f44a7fddf859704217a99a23a4f6417b10e5ab1256a179264561540e/contourpy-1.3.3-cp312-cp312-win32.whl", hash = "sha256:023b44101dfe49d7d53932be418477dba359649246075c996866106da069af69", size = 185018, upload-time = "2025-07-26T12:01:35.64Z" }, + { url = "https://files.pythonhosted.org/packages/19/e8/6026ed58a64563186a9ee3f29f41261fd1828f527dd93d33b60feca63352/contourpy-1.3.3-cp312-cp312-win_amd64.whl", hash = "sha256:8153b8bfc11e1e4d75bcb0bff1db232f9e10b274e0929de9d608027e0d34ff8b", size = 226567, upload-time = "2025-07-26T12:01:36.804Z" }, + { url = "https://files.pythonhosted.org/packages/d1/e2/f05240d2c39a1ed228d8328a78b6f44cd695f7ef47beb3e684cf93604f86/contourpy-1.3.3-cp312-cp312-win_arm64.whl", hash = "sha256:07ce5ed73ecdc4a03ffe3e1b3e3c1166db35ae7584be76f65dbbe28a7791b0cc", size = 193655, upload-time = "2025-07-26T12:01:37.999Z" }, + { url = "https://files.pythonhosted.org/packages/68/35/0167aad910bbdb9599272bd96d01a9ec6852f36b9455cf2ca67bd4cc2d23/contourpy-1.3.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:177fb367556747a686509d6fef71d221a4b198a3905fe824430e5ea0fda54eb5", size = 293257, upload-time = "2025-07-26T12:01:39.367Z" }, + { url = "https://files.pythonhosted.org/packages/96/e4/7adcd9c8362745b2210728f209bfbcf7d91ba868a2c5f40d8b58f54c509b/contourpy-1.3.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:d002b6f00d73d69333dac9d0b8d5e84d9724ff9ef044fd63c5986e62b7c9e1b1", size = 274034, upload-time = "2025-07-26T12:01:40.645Z" }, + { url = "https://files.pythonhosted.org/packages/73/23/90e31ceeed1de63058a02cb04b12f2de4b40e3bef5e082a7c18d9c8ae281/contourpy-1.3.3-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:348ac1f5d4f1d66d3322420f01d42e43122f43616e0f194fc1c9f5d830c5b286", size = 334672, upload-time = "2025-07-26T12:01:41.942Z" }, + { url = "https://files.pythonhosted.org/packages/ed/93/b43d8acbe67392e659e1d984700e79eb67e2acb2bd7f62012b583a7f1b55/contourpy-1.3.3-cp313-cp313-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:655456777ff65c2c548b7c454af9c6f33f16c8884f11083244b5819cc214f1b5", size = 381234, upload-time = "2025-07-26T12:01:43.499Z" }, + { url = "https://files.pythonhosted.org/packages/46/3b/bec82a3ea06f66711520f75a40c8fc0b113b2a75edb36aa633eb11c4f50f/contourpy-1.3.3-cp313-cp313-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:644a6853d15b2512d67881586bd03f462c7ab755db95f16f14d7e238f2852c67", size = 385169, upload-time = "2025-07-26T12:01:45.219Z" }, + { url = "https://files.pythonhosted.org/packages/4b/32/e0f13a1c5b0f8572d0ec6ae2f6c677b7991fafd95da523159c19eff0696a/contourpy-1.3.3-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4debd64f124ca62069f313a9cb86656ff087786016d76927ae2cf37846b006c9", size = 362859, upload-time = "2025-07-26T12:01:46.519Z" }, + { url = "https://files.pythonhosted.org/packages/33/71/e2a7945b7de4e58af42d708a219f3b2f4cff7386e6b6ab0a0fa0033c49a9/contourpy-1.3.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a15459b0f4615b00bbd1e91f1b9e19b7e63aea7483d03d804186f278c0af2659", size = 1332062, upload-time = "2025-07-26T12:01:48.964Z" }, + { url = "https://files.pythonhosted.org/packages/12/fc/4e87ac754220ccc0e807284f88e943d6d43b43843614f0a8afa469801db0/contourpy-1.3.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ca0fdcd73925568ca027e0b17ab07aad764be4706d0a925b89227e447d9737b7", size = 1403932, upload-time = "2025-07-26T12:01:51.979Z" }, + { url = "https://files.pythonhosted.org/packages/a6/2e/adc197a37443f934594112222ac1aa7dc9a98faf9c3842884df9a9d8751d/contourpy-1.3.3-cp313-cp313-win32.whl", hash = "sha256:b20c7c9a3bf701366556e1b1984ed2d0cedf999903c51311417cf5f591d8c78d", size = 185024, upload-time = "2025-07-26T12:01:53.245Z" }, + { url = "https://files.pythonhosted.org/packages/18/0b/0098c214843213759692cc638fce7de5c289200a830e5035d1791d7a2338/contourpy-1.3.3-cp313-cp313-win_amd64.whl", hash = "sha256:1cadd8b8969f060ba45ed7c1b714fe69185812ab43bd6b86a9123fe8f99c3263", size = 226578, upload-time = "2025-07-26T12:01:54.422Z" }, + { url = "https://files.pythonhosted.org/packages/8a/9a/2f6024a0c5995243cd63afdeb3651c984f0d2bc727fd98066d40e141ad73/contourpy-1.3.3-cp313-cp313-win_arm64.whl", hash = "sha256:fd914713266421b7536de2bfa8181aa8c699432b6763a0ea64195ebe28bff6a9", size = 193524, upload-time = "2025-07-26T12:01:55.73Z" }, + { url = "https://files.pythonhosted.org/packages/c0/b3/f8a1a86bd3298513f500e5b1f5fd92b69896449f6cab6a146a5d52715479/contourpy-1.3.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:88df9880d507169449d434c293467418b9f6cbe82edd19284aa0409e7fdb933d", size = 306730, upload-time = "2025-07-26T12:01:57.051Z" }, + { url = "https://files.pythonhosted.org/packages/3f/11/4780db94ae62fc0c2053909b65dc3246bd7cecfc4f8a20d957ad43aa4ad8/contourpy-1.3.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:d06bb1f751ba5d417047db62bca3c8fde202b8c11fb50742ab3ab962c81e8216", size = 287897, upload-time = "2025-07-26T12:01:58.663Z" }, + { url = "https://files.pythonhosted.org/packages/ae/15/e59f5f3ffdd6f3d4daa3e47114c53daabcb18574a26c21f03dc9e4e42ff0/contourpy-1.3.3-cp313-cp313t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e4e6b05a45525357e382909a4c1600444e2a45b4795163d3b22669285591c1ae", size = 326751, upload-time = "2025-07-26T12:02:00.343Z" }, + { url = "https://files.pythonhosted.org/packages/0f/81/03b45cfad088e4770b1dcf72ea78d3802d04200009fb364d18a493857210/contourpy-1.3.3-cp313-cp313t-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ab3074b48c4e2cf1a960e6bbeb7f04566bf36b1861d5c9d4d8ac04b82e38ba20", size = 375486, upload-time = "2025-07-26T12:02:02.128Z" }, + { url = "https://files.pythonhosted.org/packages/0c/ba/49923366492ffbdd4486e970d421b289a670ae8cf539c1ea9a09822b371a/contourpy-1.3.3-cp313-cp313t-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:6c3d53c796f8647d6deb1abe867daeb66dcc8a97e8455efa729516b997b8ed99", size = 388106, upload-time = "2025-07-26T12:02:03.615Z" }, + { url = "https://files.pythonhosted.org/packages/9f/52/5b00ea89525f8f143651f9f03a0df371d3cbd2fccd21ca9b768c7a6500c2/contourpy-1.3.3-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:50ed930df7289ff2a8d7afeb9603f8289e5704755c7e5c3bbd929c90c817164b", size = 352548, upload-time = "2025-07-26T12:02:05.165Z" }, + { url = "https://files.pythonhosted.org/packages/32/1d/a209ec1a3a3452d490f6b14dd92e72280c99ae3d1e73da74f8277d4ee08f/contourpy-1.3.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:4feffb6537d64b84877da813a5c30f1422ea5739566abf0bd18065ac040e120a", size = 1322297, upload-time = "2025-07-26T12:02:07.379Z" }, + { url = "https://files.pythonhosted.org/packages/bc/9e/46f0e8ebdd884ca0e8877e46a3f4e633f6c9c8c4f3f6e72be3fe075994aa/contourpy-1.3.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:2b7e9480ffe2b0cd2e787e4df64270e3a0440d9db8dc823312e2c940c167df7e", size = 1391023, upload-time = "2025-07-26T12:02:10.171Z" }, + { url = "https://files.pythonhosted.org/packages/b9/70/f308384a3ae9cd2209e0849f33c913f658d3326900d0ff5d378d6a1422d2/contourpy-1.3.3-cp313-cp313t-win32.whl", hash = "sha256:283edd842a01e3dcd435b1c5116798d661378d83d36d337b8dde1d16a5fc9ba3", size = 196157, upload-time = "2025-07-26T12:02:11.488Z" }, + { url = "https://files.pythonhosted.org/packages/b2/dd/880f890a6663b84d9e34a6f88cded89d78f0091e0045a284427cb6b18521/contourpy-1.3.3-cp313-cp313t-win_amd64.whl", hash = "sha256:87acf5963fc2b34825e5b6b048f40e3635dd547f590b04d2ab317c2619ef7ae8", size = 240570, upload-time = "2025-07-26T12:02:12.754Z" }, + { url = "https://files.pythonhosted.org/packages/80/99/2adc7d8ffead633234817ef8e9a87115c8a11927a94478f6bb3d3f4d4f7d/contourpy-1.3.3-cp313-cp313t-win_arm64.whl", hash = "sha256:3c30273eb2a55024ff31ba7d052dde990d7d8e5450f4bbb6e913558b3d6c2301", size = 199713, upload-time = "2025-07-26T12:02:14.4Z" }, + { url = "https://files.pythonhosted.org/packages/72/8b/4546f3ab60f78c514ffb7d01a0bd743f90de36f0019d1be84d0a708a580a/contourpy-1.3.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:fde6c716d51c04b1c25d0b90364d0be954624a0ee9d60e23e850e8d48353d07a", size = 292189, upload-time = "2025-07-26T12:02:16.095Z" }, + { url = "https://files.pythonhosted.org/packages/fd/e1/3542a9cb596cadd76fcef413f19c79216e002623158befe6daa03dbfa88c/contourpy-1.3.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:cbedb772ed74ff5be440fa8eee9bd49f64f6e3fc09436d9c7d8f1c287b121d77", size = 273251, upload-time = "2025-07-26T12:02:17.524Z" }, + { url = "https://files.pythonhosted.org/packages/b1/71/f93e1e9471d189f79d0ce2497007731c1e6bf9ef6d1d61b911430c3db4e5/contourpy-1.3.3-cp314-cp314-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:22e9b1bd7a9b1d652cd77388465dc358dafcd2e217d35552424aa4f996f524f5", size = 335810, upload-time = "2025-07-26T12:02:18.9Z" }, + { url = "https://files.pythonhosted.org/packages/91/f9/e35f4c1c93f9275d4e38681a80506b5510e9327350c51f8d4a5a724d178c/contourpy-1.3.3-cp314-cp314-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a22738912262aa3e254e4f3cb079a95a67132fc5a063890e224393596902f5a4", size = 382871, upload-time = "2025-07-26T12:02:20.418Z" }, + { url = "https://files.pythonhosted.org/packages/b5/71/47b512f936f66a0a900d81c396a7e60d73419868fba959c61efed7a8ab46/contourpy-1.3.3-cp314-cp314-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:afe5a512f31ee6bd7d0dda52ec9864c984ca3d66664444f2d72e0dc4eb832e36", size = 386264, upload-time = "2025-07-26T12:02:21.916Z" }, + { url = "https://files.pythonhosted.org/packages/04/5f/9ff93450ba96b09c7c2b3f81c94de31c89f92292f1380261bd7195bea4ea/contourpy-1.3.3-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f64836de09927cba6f79dcd00fdd7d5329f3fccc633468507079c829ca4db4e3", size = 363819, upload-time = "2025-07-26T12:02:23.759Z" }, + { url = "https://files.pythonhosted.org/packages/3e/a6/0b185d4cc480ee494945cde102cb0149ae830b5fa17bf855b95f2e70ad13/contourpy-1.3.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:1fd43c3be4c8e5fd6e4f2baeae35ae18176cf2e5cced681cca908addf1cdd53b", size = 1333650, upload-time = "2025-07-26T12:02:26.181Z" }, + { url = "https://files.pythonhosted.org/packages/43/d7/afdc95580ca56f30fbcd3060250f66cedbde69b4547028863abd8aa3b47e/contourpy-1.3.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:6afc576f7b33cf00996e5c1102dc2a8f7cc89e39c0b55df93a0b78c1bd992b36", size = 1404833, upload-time = "2025-07-26T12:02:28.782Z" }, + { url = "https://files.pythonhosted.org/packages/e2/e2/366af18a6d386f41132a48f033cbd2102e9b0cf6345d35ff0826cd984566/contourpy-1.3.3-cp314-cp314-win32.whl", hash = "sha256:66c8a43a4f7b8df8b71ee1840e4211a3c8d93b214b213f590e18a1beca458f7d", size = 189692, upload-time = "2025-07-26T12:02:30.128Z" }, + { url = "https://files.pythonhosted.org/packages/7d/c2/57f54b03d0f22d4044b8afb9ca0e184f8b1afd57b4f735c2fa70883dc601/contourpy-1.3.3-cp314-cp314-win_amd64.whl", hash = "sha256:cf9022ef053f2694e31d630feaacb21ea24224be1c3ad0520b13d844274614fd", size = 232424, upload-time = "2025-07-26T12:02:31.395Z" }, + { url = "https://files.pythonhosted.org/packages/18/79/a9416650df9b525737ab521aa181ccc42d56016d2123ddcb7b58e926a42c/contourpy-1.3.3-cp314-cp314-win_arm64.whl", hash = "sha256:95b181891b4c71de4bb404c6621e7e2390745f887f2a026b2d99e92c17892339", size = 198300, upload-time = "2025-07-26T12:02:32.956Z" }, + { url = "https://files.pythonhosted.org/packages/1f/42/38c159a7d0f2b7b9c04c64ab317042bb6952b713ba875c1681529a2932fe/contourpy-1.3.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:33c82d0138c0a062380332c861387650c82e4cf1747aaa6938b9b6516762e772", size = 306769, upload-time = "2025-07-26T12:02:34.2Z" }, + { url = "https://files.pythonhosted.org/packages/c3/6c/26a8205f24bca10974e77460de68d3d7c63e282e23782f1239f226fcae6f/contourpy-1.3.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ea37e7b45949df430fe649e5de8351c423430046a2af20b1c1961cae3afcda77", size = 287892, upload-time = "2025-07-26T12:02:35.807Z" }, + { url = "https://files.pythonhosted.org/packages/66/06/8a475c8ab718ebfd7925661747dbb3c3ee9c82ac834ccb3570be49d129f4/contourpy-1.3.3-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d304906ecc71672e9c89e87c4675dc5c2645e1f4269a5063b99b0bb29f232d13", size = 326748, upload-time = "2025-07-26T12:02:37.193Z" }, + { url = "https://files.pythonhosted.org/packages/b4/a3/c5ca9f010a44c223f098fccd8b158bb1cb287378a31ac141f04730dc49be/contourpy-1.3.3-cp314-cp314t-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ca658cd1a680a5c9ea96dc61cdbae1e85c8f25849843aa799dfd3cb370ad4fbe", size = 375554, upload-time = "2025-07-26T12:02:38.894Z" }, + { url = "https://files.pythonhosted.org/packages/80/5b/68bd33ae63fac658a4145088c1e894405e07584a316738710b636c6d0333/contourpy-1.3.3-cp314-cp314t-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ab2fd90904c503739a75b7c8c5c01160130ba67944a7b77bbf36ef8054576e7f", size = 388118, upload-time = "2025-07-26T12:02:40.642Z" }, + { url = "https://files.pythonhosted.org/packages/40/52/4c285a6435940ae25d7410a6c36bda5145839bc3f0beb20c707cda18b9d2/contourpy-1.3.3-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b7301b89040075c30e5768810bc96a8e8d78085b47d8be6e4c3f5a0b4ed478a0", size = 352555, upload-time = "2025-07-26T12:02:42.25Z" }, + { url = "https://files.pythonhosted.org/packages/24/ee/3e81e1dd174f5c7fefe50e85d0892de05ca4e26ef1c9a59c2a57e43b865a/contourpy-1.3.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:2a2a8b627d5cc6b7c41a4beff6c5ad5eb848c88255fda4a8745f7e901b32d8e4", size = 1322295, upload-time = "2025-07-26T12:02:44.668Z" }, + { url = "https://files.pythonhosted.org/packages/3c/b2/6d913d4d04e14379de429057cd169e5e00f6c2af3bb13e1710bcbdb5da12/contourpy-1.3.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:fd6ec6be509c787f1caf6b247f0b1ca598bef13f4ddeaa126b7658215529ba0f", size = 1391027, upload-time = "2025-07-26T12:02:47.09Z" }, + { url = "https://files.pythonhosted.org/packages/93/8a/68a4ec5c55a2971213d29a9374913f7e9f18581945a7a31d1a39b5d2dfe5/contourpy-1.3.3-cp314-cp314t-win32.whl", hash = "sha256:e74a9a0f5e3fff48fb5a7f2fd2b9b70a3fe014a67522f79b7cca4c0c7e43c9ae", size = 202428, upload-time = "2025-07-26T12:02:48.691Z" }, + { url = "https://files.pythonhosted.org/packages/fa/96/fd9f641ffedc4fa3ace923af73b9d07e869496c9cc7a459103e6e978992f/contourpy-1.3.3-cp314-cp314t-win_amd64.whl", hash = "sha256:13b68d6a62db8eafaebb8039218921399baf6e47bf85006fd8529f2a08ef33fc", size = 250331, upload-time = "2025-07-26T12:02:50.137Z" }, + { url = "https://files.pythonhosted.org/packages/ae/8c/469afb6465b853afff216f9528ffda78a915ff880ed58813ba4faf4ba0b6/contourpy-1.3.3-cp314-cp314t-win_arm64.whl", hash = "sha256:b7448cb5a725bb1e35ce88771b86fba35ef418952474492cf7c764059933ff8b", size = 203831, upload-time = "2025-07-26T12:02:51.449Z" }, + { url = "https://files.pythonhosted.org/packages/a5/29/8dcfe16f0107943fa92388c23f6e05cff0ba58058c4c95b00280d4c75a14/contourpy-1.3.3-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:cd5dfcaeb10f7b7f9dc8941717c6c2ade08f587be2226222c12b25f0483ed497", size = 278809, upload-time = "2025-07-26T12:02:52.74Z" }, + { url = "https://files.pythonhosted.org/packages/85/a9/8b37ef4f7dafeb335daee3c8254645ef5725be4d9c6aa70b50ec46ef2f7e/contourpy-1.3.3-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:0c1fc238306b35f246d61a1d416a627348b5cf0648648a031e14bb8705fcdfe8", size = 261593, upload-time = "2025-07-26T12:02:54.037Z" }, + { url = "https://files.pythonhosted.org/packages/0a/59/ebfb8c677c75605cc27f7122c90313fd2f375ff3c8d19a1694bda74aaa63/contourpy-1.3.3-pp311-pypy311_pp73-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:70f9aad7de812d6541d29d2bbf8feb22ff7e1c299523db288004e3157ff4674e", size = 302202, upload-time = "2025-07-26T12:02:55.947Z" }, + { url = "https://files.pythonhosted.org/packages/3c/37/21972a15834d90bfbfb009b9d004779bd5a07a0ec0234e5ba8f64d5736f4/contourpy-1.3.3-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5ed3657edf08512fc3fe81b510e35c2012fbd3081d2e26160f27ca28affec989", size = 329207, upload-time = "2025-07-26T12:02:57.468Z" }, + { url = "https://files.pythonhosted.org/packages/0c/58/bd257695f39d05594ca4ad60df5bcb7e32247f9951fd09a9b8edb82d1daa/contourpy-1.3.3-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:3d1a3799d62d45c18bafd41c5fa05120b96a28079f2393af559b843d1a966a77", size = 225315, upload-time = "2025-07-26T12:02:58.801Z" }, +] + +[[package]] +name = "cuda-bindings" +version = "13.3.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cuda-pathfinder" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/51/6b/457ca12dad3ee9bfcc9a545cfd6b64b359ba49de40f776f6e028e678f262/cuda_bindings-13.3.1-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c5879712accf6e14bb01aa5e67440eb84998b8d104b509cc7a6dc0b8f656a474", size = 6053539, upload-time = "2026-05-29T23:11:43.19Z" }, + { url = "https://files.pythonhosted.org/packages/95/7a/c5e3c34a409b148f5c0f5a4ea374158f95d488862c1dffedf9aa5c639df9/cuda_bindings-13.3.1-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:04436a9364059c84b8f9636f359eccda1cf814341f5b670c71d80d2f79dbc708", size = 6674166, upload-time = "2026-05-29T23:11:45.478Z" }, + { url = "https://files.pythonhosted.org/packages/ce/67/5e7dba1ba576dd73da5dee894ca076ca5e959450dfff66d6d510a255d1f7/cuda_bindings-13.3.1-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c7855c4868aabc0cfae28abbe83d56734bdfbd08f08fc234ac1912a12858bf49", size = 6025351, upload-time = "2026-05-29T23:11:49.685Z" }, + { url = "https://files.pythonhosted.org/packages/39/2a/6d2e9047d1fb243dbaa364b01e0297534b9ed7fd27dba1c9f361519cf69b/cuda_bindings-13.3.1-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e32d08f71ebcdf00f0f41eab2eb37e8da94c8ed411cc9f7f7a019ce6b34abe3a", size = 6657965, upload-time = "2026-05-29T23:11:52.227Z" }, + { url = "https://files.pythonhosted.org/packages/cc/6e/2394f8163360f8391f8f1b7e72d300a82724edb81a7b7084c799fbd4c91f/cuda_bindings-13.3.1-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9efb21c1ee64981e184b9e0ba5eb3179e5ba3d4b51665a6cb52b8ef3d01a7cbf", size = 5920504, upload-time = "2026-05-29T23:11:56.883Z" }, + { url = "https://files.pythonhosted.org/packages/34/c2/ef9b6a63f7dc432712a462c816662e662e00d38caa9b861c8c2588195d03/cuda_bindings-13.3.1-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2732904099e0a4d4db774a5fc6d91ee95fae065b4d2ecabb4968c5fe2406c9d7", size = 6476660, upload-time = "2026-05-29T23:11:59.188Z" }, + { url = "https://files.pythonhosted.org/packages/b1/81/bff68ce829999c1e4209c761bbf903b1c06ec570416ddb25020864ad5907/cuda_bindings-13.3.1-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1ab2f74ed65bfef4163ba07a8db16f1085e0729291db12a2423aff84ee8278b8", size = 6013639, upload-time = "2026-05-29T23:12:03.509Z" }, + { url = "https://files.pythonhosted.org/packages/d4/e0/c8a1f0c8f9ffdea4f5fe6dbab89b326cef4d85caf489dad39e209da89416/cuda_bindings-13.3.1-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:efd4c814d311ec08c981f6dded1dbe7d4b371067ee4f6c14cccec4bde9590f80", size = 6534419, upload-time = "2026-05-29T23:12:05.633Z" }, + { url = "https://files.pythonhosted.org/packages/52/b8/83b1f563925b290f2d11a01a77a84013ba56052fe3653a5bef3ccfbb43d6/cuda_bindings-13.3.1-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c3c772dfff49681541d59630c90f858e173ac926b9c593a2b7123f2a1043cc76", size = 5809771, upload-time = "2026-05-29T23:12:10.422Z" }, + { url = "https://files.pythonhosted.org/packages/12/20/e79b4bfe98f075195afb6343d41c498f9dbd2d161d7021d4d28bceb83581/cuda_bindings-13.3.1-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:36febb7c1079d68a981dbbd8d5a67235b399802b82075c9388624719607e52b9", size = 6358584, upload-time = "2026-05-29T23:12:12.767Z" }, +] + +[[package]] +name = "cuda-pathfinder" +version = "1.5.6" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d2/53/8fc9b0cdc5b7f62746e6a01b85b6461e5ae27f871010a5fcf8fa6950766d/cuda_pathfinder-1.5.6-py3-none-any.whl", hash = "sha256:7e4c07c117b78ba1fb35dac4c444d21f3677b1b1ff56175c53a8e3025c5b43c0", size = 52972, upload-time = "2026-06-30T00:58:04.34Z" }, +] + +[[package]] +name = "cuda-toolkit" +version = "13.0.3.0" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d1/c7/a79086a62c98befcdb8349656c6f114e2db3b8b2422f6e25c97a7f2a9a3c/cuda_toolkit-13.0.3.0-py2.py3-none-any.whl", hash = "sha256:d693caaa261214ddd7dbb60d68e71cbed884e68c2be7509778f3051da0b91c3f", size = 2512, upload-time = "2026-04-14T00:50:08.173Z" }, +] + +[package.optional-dependencies] +cublas = [ + { name = "nvidia-cublas", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine == 'AMD64' and sys_platform == 'win32')" }, + { name = "nvidia-cuda-nvrtc", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine == 'AMD64' and sys_platform == 'win32')" }, +] +cudart = [ + { name = "nvidia-cuda-runtime", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine == 'AMD64' and sys_platform == 'win32')" }, +] +cufft = [ + { name = "nvidia-cufft", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine == 'AMD64' and sys_platform == 'win32')" }, + { name = "nvidia-nvjitlink", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine == 'AMD64' and sys_platform == 'win32')" }, +] +cufile = [ + { name = "nvidia-cufile", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, +] +cupti = [ + { name = "nvidia-cuda-cupti", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine == 'AMD64' and sys_platform == 'win32')" }, +] +curand = [ + { name = "nvidia-curand", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine == 'AMD64' and sys_platform == 'win32')" }, +] +cusolver = [ + { name = "nvidia-cublas", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine == 'AMD64' and sys_platform == 'win32')" }, + { name = "nvidia-cusolver", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine == 'AMD64' and sys_platform == 'win32')" }, + { name = "nvidia-cusparse", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine == 'AMD64' and sys_platform == 'win32')" }, + { name = "nvidia-nvjitlink", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine == 'AMD64' and sys_platform == 'win32')" }, +] +cusparse = [ + { name = "nvidia-cusparse", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine == 'AMD64' and sys_platform == 'win32')" }, + { name = "nvidia-nvjitlink", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine == 'AMD64' and sys_platform == 'win32')" }, +] +nvjitlink = [ + { name = "nvidia-nvjitlink", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine == 'AMD64' and sys_platform == 'win32')" }, +] +nvrtc = [ + { name = "nvidia-cuda-nvrtc", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine == 'AMD64' and sys_platform == 'win32')" }, +] +nvtx = [ + { name = "nvidia-nvtx", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux') or (platform_machine == 'AMD64' and sys_platform == 'win32')" }, +] + +[[package]] +name = "cycler" +version = "0.12.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a9/95/a3dbbb5028f35eafb79008e7522a75244477d2838f38cbb722248dabc2a8/cycler-0.12.1.tar.gz", hash = "sha256:88bb128f02ba341da8ef447245a9e138fae777f6a23943da4540077d3601eb1c", size = 7615, upload-time = "2023-10-07T05:32:18.335Z" } +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 = "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 = "decorator" +version = "5.3.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/60/8b/32f9823da46cde7df2087faa08cd98d01b908f8dcab982cdba9c84e85355/decorator-5.3.1.tar.gz", hash = "sha256:4cbcdd55a6efadb9dbea26b858f4fb3264567b52d69ca0d25b721b553f60ea82", size = 58084, upload-time = "2026-05-18T06:03:28.057Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/05/7f/798705f5296a58ca505d600456748d1be48078eac8a7050d8a98bc9edb89/decorator-5.3.1-py3-none-any.whl", hash = "sha256:f47fe6fdbd2edd623ecfe36875d37aba411624e2670dd395dddae1358689bb3c", size = 10365, upload-time = "2026-05-18T06:03:26.517Z" }, +] + +[[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.21.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/20/b5/23b216d9d985a956623b6bd12d4086b60f0059b27799f23016af04a74ea1/fastjsonschema-2.21.2.tar.gz", hash = "sha256:b1eb43748041c880796cd077f1a07c3d94e93ae84bba5ed36800a33554ae05de", size = 374130, upload-time = "2025-08-14T18:49:36.666Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cb/a8/20d0723294217e47de6d9e2e40fd4a9d2f7c4b6ef974babd482a59743694/fastjsonschema-2.21.2-py3-none-any.whl", hash = "sha256:1c797122d0a86c5cace2e54bf4e819c36223b552017172f32c5c024a6b77e463", size = 24024, upload-time = "2025-08-14T18:49:34.776Z" }, +] + +[[package]] +name = "filelock" +version = "3.31.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/99/2c/c603f8aedff281295f7afce455d5c05f33459c7bf684abb46228f844a1f0/filelock-3.31.2.tar.gz", hash = "sha256:e6d35965c709527915a184837a8421826d18bc3f9d7e9a5a0c8114a782475d66", size = 200476, upload-time = "2026-07-21T04:04:46.471Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/29/4c/c0ec6b645dcfefdd158313edb68c676d36c3f93ce8d2d9f0725d6341e506/filelock-3.31.2-py3-none-any.whl", hash = "sha256:18a4179901809ad1905c6631d907f1c3a41806c0d3506f7f9862565576a81a16", size = 97486, upload-time = "2026-07-21T04:04:44.903Z" }, +] + +[[package]] +name = "fonttools" +version = "4.63.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/84/69/c97f2c18e0db87d2c7b15da1974dace76ae938f1cfa22e2727a648b7ed43/fonttools-4.63.0.tar.gz", hash = "sha256:caeb583deeb5168e694b65cda8b4ee62abedfa66cf88488734466f2366b9c4e0", size = 3597189, upload-time = "2026-05-14T12:04:30.958Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/75/2b/a7f1545bdf5da69c4bda0cea2a5781f0ad2a6623e0277267672db43c5fe6/fonttools-4.63.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:2b8ae05d9eacf6081414d759c0a352769ac28ce31280d6bb8e77b03f9e3c449f", size = 2881793, upload-time = "2026-05-14T12:02:56.645Z" }, + { url = "https://files.pythonhosted.org/packages/49/50/965308c703f085f225db2886813b27e015b8b3438c350b22dd65b52c2a2c/fonttools-4.63.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:79cdc9f567aec74a72918fd060283911406750cbc9fd28c1316023deb6ce31a9", size = 2428130, upload-time = "2026-05-14T12:02:58.891Z" }, + { url = "https://files.pythonhosted.org/packages/d8/38/6937fbd7f2dc3a6b48725851bc2c15ec949b9af14d9bbcb5fe83cdf9bdf9/fonttools-4.63.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2c14b4fd138c4bafcca294765c547914e1aa431ae1ca94ab99d8db08c958bd3b", size = 5111952, upload-time = "2026-05-14T12:03:01.263Z" }, + { url = "https://files.pythonhosted.org/packages/0b/43/a81f20050a3115b57d62c8e781446949512eac36690dc384ccea65ff4cc1/fonttools-4.63.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d76ac49f929aecaf82d83250b8347e099d7aecba0f4726c1d9b6df3b8bb5fe18", size = 5082308, upload-time = "2026-05-14T12:03:03.211Z" }, + { url = "https://files.pythonhosted.org/packages/67/00/cdd9d4944ca6ae280d01e69cc37bde3bf663630b837a6fc6d2cd65d80e0e/fonttools-4.63.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:dcf076a4474fe0d7367e5bbf5b052c7284fa1feca729c04176ce513521afd8a0", size = 5087932, upload-time = "2026-05-14T12:03:05.147Z" }, + { url = "https://files.pythonhosted.org/packages/f5/f1/0aa0dbea778c75adbef223c42019fd47d22262b905974d62d829545d485f/fonttools-4.63.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:7dd683fef0663e9f0f45cf541d788d24caa3ec9db50796b588e1757d8b3bc007", size = 5213271, upload-time = "2026-05-14T12:03:07.238Z" }, + { url = "https://files.pythonhosted.org/packages/a8/99/253e4056e1f0e67b9390125a154b73b5eb73ad521bece95c004858fdeec2/fonttools-4.63.0-cp311-cp311-win32.whl", hash = "sha256:afefc1ed0a59785a7fb06ea7e1678e849c193e1e387db783579bc7b3056fcfcb", size = 2304473, upload-time = "2026-05-14T12:03:09.271Z" }, + { url = "https://files.pythonhosted.org/packages/08/60/defa5e69641db890a63be281f41345f4c33b157824eaf0b9fad3e08b0dcb/fonttools-4.63.0-cp311-cp311-win_amd64.whl", hash = "sha256:063e08bd17bd5a90127a14123de0d6a952dbc847695fd98b63c043d58057f90c", size = 2356389, upload-time = "2026-05-14T12:03:11.53Z" }, + { url = "https://files.pythonhosted.org/packages/08/ef/b3c6b9b5be2f82416d73fe2ed2e96e2793cd80e7510bd6a17ca79cdd88ec/fonttools-4.63.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:37dd23e621e3b0aef1baa70a303b80aaf38449632cfc8fd2a55fb285bbccfc02", size = 2881131, upload-time = "2026-05-14T12:03:13.386Z" }, + { url = "https://files.pythonhosted.org/packages/44/a0/c815bea63117fa63e4e1c01f8a1110d2112fa003f838e6467094ec2432ce/fonttools-4.63.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:a9faff9e0c1f76f9fd55899d2ce785832efebab37eb8ae13995853aef178bef0", size = 2426704, upload-time = "2026-05-14T12:03:15.801Z" }, + { url = "https://files.pythonhosted.org/packages/44/04/0b91d8e916e92ad1fac9e4624760baf0fd5ff2ead614c2f68fb21373f03f/fonttools-4.63.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ef3048ef05dbb552b89817713d9cac912e00d0fde4a3105c00d29e52e10c89af", size = 5044298, upload-time = "2026-05-14T12:03:18.085Z" }, + { url = "https://files.pythonhosted.org/packages/77/c7/2342da9830e3e9d4870305ca5d2091d2a83284f2953079b7bdd3b5e029d8/fonttools-4.63.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:58dc6bb86a78d782f00f9190ca02c119cf5bbe2807536e361e18d42019f877d8", size = 4999800, upload-time = "2026-05-14T12:03:20.161Z" }, + { url = "https://files.pythonhosted.org/packages/e6/6d/67fe16c48d7ce050979b33f47e0d28a318f02da030602e944c34f7a16ef3/fonttools-4.63.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:ee08ebfa58f6e1aeff5697ab9582105bb620008c1caafb681e4c557e7483027b", size = 4982666, upload-time = "2026-05-14T12:03:22.87Z" }, + { url = "https://files.pythonhosted.org/packages/f2/00/3bbab338c07c71fa56269953845e92c951a61457bbbb0f1022551ea266d9/fonttools-4.63.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:27fdc65af8da6f88b9c6121c47a464cbe359fcfff7ff6fc2d37a1f395d755b78", size = 5133598, upload-time = "2026-05-14T12:03:25.168Z" }, + { url = "https://files.pythonhosted.org/packages/62/f2/aa27c7f98db5b064883dadcc5283947e81e034de42e22a33675878d98b54/fonttools-4.63.0-cp312-cp312-win32.whl", hash = "sha256:af2fd1664d00a397d75f806985ddb36282091c2131a73a6485c23b4a34722263", size = 2292575, upload-time = "2026-05-14T12:03:27.496Z" }, + { url = "https://files.pythonhosted.org/packages/87/36/cccb9bc2a6ab63d1b2980374f0dca72ce95ae267c9b4cfe77455bb70d0d4/fonttools-4.63.0-cp312-cp312-win_amd64.whl", hash = "sha256:59ac449f8cca9b4ffa08d2e7bbadad87ce710d69d1eda5c3c1ce579baa987272", size = 2343211, upload-time = "2026-05-14T12:03:30.057Z" }, + { url = "https://files.pythonhosted.org/packages/0f/8d/d8fec3dcde2963f8c908fb315e5ff2cd0ac34f82394bbbf73a2aa5145ce3/fonttools-4.63.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:cd7e9857e5e63738b9d9fd707bc1f59c8b09e5177726d23664db393c59bb08bd", size = 2876062, upload-time = "2026-05-14T12:03:32.554Z" }, + { url = "https://files.pythonhosted.org/packages/ef/71/d935dc54e4ff121bfdd11e08702db63a7e6f25af21d8a3d7b7212df53641/fonttools-4.63.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:c2a2a42198b696a6f48fad91709afb55176e66a5e566131219dba372fb7f8c59", size = 2424594, upload-time = "2026-05-14T12:03:34.86Z" }, + { url = "https://files.pythonhosted.org/packages/8e/40/e76320afa1df918e146155ef239b1719ee266092e96f5423bfd075affba1/fonttools-4.63.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1e874792a8212b44583ea02189d9e693906b2f78b261f372f95d6c563210ac1d", size = 5024840, upload-time = "2026-05-14T12:03:36.745Z" }, + { url = "https://files.pythonhosted.org/packages/ce/36/0b805d8c485f872f65a509cbe3b58a5d0d17bee855333b54a150c79d3061/fonttools-4.63.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:22135da48a348785c5e2d5d2d9d6bec5ed44adacbaeb9db12d9493bf6c6bfa68", size = 4975801, upload-time = "2026-05-14T12:03:38.833Z" }, + { url = "https://files.pythonhosted.org/packages/c8/26/2cee03d0aa083ab022da5c07aff9ed3f689da1defb81ad6917c9627896da/fonttools-4.63.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ccf41f2efdf56994d22d73bef4ced1052161958169428d06ba9724ea9e9a64be", size = 4965009, upload-time = "2026-05-14T12:03:41.494Z" }, + { url = "https://files.pythonhosted.org/packages/7e/48/cc4b66d9058c0d0982c833fad10127c4b0e9324606aafa41382295ca4102/fonttools-4.63.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9ced0bd02ac751dd6319b0da88aaef24414e3b0dbc32bb4f24944821a3741a27", size = 5105892, upload-time = "2026-05-14T12:03:43.525Z" }, + { url = "https://files.pythonhosted.org/packages/d8/1f/a98a30a814b9ddef3a2e706025f90b9e0bc94890e6cb15254bc86547d11a/fonttools-4.63.0-cp313-cp313-win32.whl", hash = "sha256:85be818f5506e8a7753153def2c9550178f0ecae6a47b5e0e8dbb23f7cc90380", size = 2291313, upload-time = "2026-05-14T12:03:45.594Z" }, + { url = "https://files.pythonhosted.org/packages/92/46/5177b01f3b4abfdd4409f31cca4ab279c9343a26efbe9ec78c97fc612e02/fonttools-4.63.0-cp313-cp313-win_amd64.whl", hash = "sha256:ba04cb5891d4c0c21b6da95eda8d7b090021508a294fff33464fc7d241e0856b", size = 2342299, upload-time = "2026-05-14T12:03:47.414Z" }, + { url = "https://files.pythonhosted.org/packages/27/d2/23d25e3f247b328be58d04a4c9f894178a0d1eda7d42867cfb388adaf416/fonttools-4.63.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:fd1e3094f42d806d3d7c79162fc59e5910fcbe3a7360c385b8da969bc4493745", size = 2875338, upload-time = "2026-05-14T12:03:50.052Z" }, + { url = "https://files.pythonhosted.org/packages/cd/58/7dfa0c761cb3b2964e2a84c4dc986c926a87de0cb9fb60d5b28ded3f2914/fonttools-4.63.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:6e528da43bc3791085f8cb6141b1d13e459226790240340fcbb4625649238b03", size = 2422661, upload-time = "2026-05-14T12:03:52.154Z" }, + { url = "https://files.pythonhosted.org/packages/dd/87/64cfa18a7a1621d17b7f4502b2b0ed8a135a90c3db51ea590ee99043e76b/fonttools-4.63.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b2248c5decb223562f7902ff6325077a073f608ee8e33e88ad88db734eb9f49", size = 5010526, upload-time = "2026-05-14T12:03:54.647Z" }, + { url = "https://files.pythonhosted.org/packages/36/e1/a8933a72c45a87177fbde2696e0d0755c8c9062f8c077a961c6215fa27b1/fonttools-4.63.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:308f957cdeaf8abe4e5f2f124902ef405448af92c90f80e302a3b771c2e6116b", size = 4923946, upload-time = "2026-05-14T12:03:56.984Z" }, + { url = "https://files.pythonhosted.org/packages/27/60/872e6e233b8c5e8b41413796ff18b7fe479661bd40147e071b450dfad7a1/fonttools-4.63.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:bf00f21eb5fb721dbaf73d1e9da6d02a1af7768f2ebcf9798be98beab8ba90f6", size = 4962489, upload-time = "2026-05-14T12:03:59.443Z" }, + { url = "https://files.pythonhosted.org/packages/30/c4/83c24f2ec38b90cfda84bf4b1a1f49df80e84a1db4e7ac6e0d41bf23bc39/fonttools-4.63.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:c1aaa4b9c75798400ac043ce04d74e7830376c85095a5a6ed7cba2f17a266bf4", size = 5071870, upload-time = "2026-05-14T12:04:02.122Z" }, + { url = "https://files.pythonhosted.org/packages/de/40/3ae22b60ff1d41ce0bd044b31238cdc72cef99f28b976f1e128ebd618c9b/fonttools-4.63.0-cp314-cp314-win32.whl", hash = "sha256:22693918177bd9ceabec4736d338045f357769416fc6b0b2508eefef75b08616", size = 2295026, upload-time = "2026-05-14T12:04:04.47Z" }, + { url = "https://files.pythonhosted.org/packages/c3/d4/98078064ccc76b45cb0f6c002452011e93c4bd26f6850344f0951cc1fe89/fonttools-4.63.0-cp314-cp314-win_amd64.whl", hash = "sha256:7d782fac32985914c351556f68ac0855391572bcd87de50e05970d3cd4c96fc5", size = 2347454, upload-time = "2026-05-14T12:04:06.752Z" }, + { url = "https://files.pythonhosted.org/packages/49/4e/652d1580c5f4e39f7d103b0c793e4773129ad633dce4addd0cf4dfebde02/fonttools-4.63.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:6db5140a60a5d731d21ec076745b40a310607731b0a565b50776393188649001", size = 2958152, upload-time = "2026-05-14T12:04:08.706Z" }, + { url = "https://files.pythonhosted.org/packages/0e/55/ad864c9a9b219f552eb46b32cd7906c466e5a578ba0c3abfcc0fe7413eb6/fonttools-4.63.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:7d76edbff9014094dbf03bd2d074709dfa6ec7aba13d838c937a2b33d2d6a86e", size = 2460809, upload-time = "2026-05-14T12:04:10.783Z" }, + { url = "https://files.pythonhosted.org/packages/ea/2b/0aa8db70f18cf52e49b4ed5ecec68547f981160bf5ded3b5aed6faa0a6f9/fonttools-4.63.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0eac00b9118c3c2f87d272e45341871c5b3066baa3c86897fa634a7c3fb59096", size = 5148649, upload-time = "2026-05-14T12:04:12.747Z" }, + { url = "https://files.pythonhosted.org/packages/7f/63/18e4369c25043096f1048e0c9915951adc4f842bd81c6b18155824d6fa99/fonttools-4.63.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:51394295f1a51de8b5f30bdb1e1b9a4231536c7064ef5c6e211eec19fa36036f", size = 4932147, upload-time = "2026-05-14T12:04:14.806Z" }, + { url = "https://files.pythonhosted.org/packages/a1/3f/67f3eac2ffd8a98446c5022f8ed3864eac878a5ff7af8df4c8286dba16cc/fonttools-4.63.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:9e12f105d2b6342c559c298afb674006bb2893afc7102dcf8a1b55b0486b4e40", size = 5027237, upload-time = "2026-05-14T12:04:17.675Z" }, + { url = "https://files.pythonhosted.org/packages/1a/ba/4e6214cb38a7b04779e97bb7636de9a5c7f20af7018d03dee0b64c08510a/fonttools-4.63.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:796f27556dbe094c4824f75ca85267e4df776c79036c8441469a4df37038c196", size = 5053933, upload-time = "2026-05-14T12:04:20.818Z" }, + { url = "https://files.pythonhosted.org/packages/34/3b/214dcc19ee31d3d38fb5ad2755c11ef0514e5dc300bbaf41c0b69f393799/fonttools-4.63.0-cp314-cp314t-win32.whl", hash = "sha256:948428a275741f0b64b113c955425a953314f4b9ab9997f73a72c83e68e569c8", size = 2359326, upload-time = "2026-05-14T12:04:24.22Z" }, + { url = "https://files.pythonhosted.org/packages/dd/1e/3ff1a9b523058c2eeb6a9d50f5574e2a738200d0d94107d5bc4105e8da3f/fonttools-4.63.0-cp314-cp314t-win_amd64.whl", hash = "sha256:6d4741eb179121cab9eea4cb2393d24492373a260d7945006358c08cfbf45419", size = 2425829, upload-time = "2026-05-14T12:04:26.829Z" }, + { 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 = "fsspec" +version = "2026.6.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/10/a1/ae4e3e5003468d6391d2c77b6fa1cd73bd5d13511d81c642d7b28ac90ed4/fsspec-2026.6.0.tar.gz", hash = "sha256:f5bac145310fe30e16e1471bd6840b2d990d609e872251d7e674241822abf01a", size = 313646, upload-time = "2026-06-16T01:57:28.105Z" } +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]] +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.15.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "decorator" }, + { 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/53/59/165d3b4d75cc34add3122c4417ecb229085140ac573103c223cd01dde96f/ipython-9.15.0.tar.gz", hash = "sha256:da2819ce2aa83135257df830660b1176d986c3d2876db24df01974fa955b2756", size = 4442580, upload-time = "2026-06-26T11:03:35.913Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/40/3a/948263ca3b9d65bb2b1b0c521b3a49fad5d59ada58724bd87d2bd5ff3f36/ipython-9.15.0-py3-none-any.whl", hash = "sha256:515ad9c3cdf0c932a5a9f6245419e8aba706b7bd03c3e1d3a1c83d9351d6aa6e", size = 630895, upload-time = "2026-06-26T11:03:33.809Z" }, +] + +[[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 = "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" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markupsafe" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/df/bf/f7da0350254c0ed7c72f3e33cef02e048281fec7ecec5f032d4aac52226b/jinja2-3.1.6.tar.gz", hash = "sha256:0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d", size = 245115, upload-time = "2025-03-05T20:05:02.478Z" } +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 = "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]] +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-client" +version = "8.9.1" +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/7d/dc/5512503b088997c2250b8bf18258fba9d9ce5ead641183700960d3c9d342/jupyter_client-8.9.1.tar.gz", hash = "sha256:a58f730dd9e728ba16ba1d62ebccf7ffe1ebbdbce4e95cfae941b7321ae1f4fa", size = 359256, upload-time = "2026-06-09T13:15:01.033Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3f/6f/56d39bf385c5c27988aebaf0c18a2a17e960575740100973511018bd904e/jupyter_client-8.9.1-py3-none-any.whl", hash = "sha256:0b7a295bc46e8751e9adae84781f726c851c1d911bd793edc4a3bde942e3da81", size = 109828, upload-time = "2026-06-09T13:14:58.835Z" }, +] + +[[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 = "kiwisolver" +version = "1.5.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d0/67/9c61eccb13f0bdca9307614e782fec49ffdde0f7a2314935d489fa93cd9c/kiwisolver-1.5.0.tar.gz", hash = "sha256:d4193f3d9dc3f6f79aaed0e5637f45d98850ebf01f7ca20e69457f3e8946b66a", size = 103482, upload-time = "2026-03-09T13:15:53.382Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/12/dd/a495a9c104be1c476f0386e714252caf2b7eca883915422a64c50b88c6f5/kiwisolver-1.5.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:9eed0f7edbb274413b6ee781cca50541c8c0facd3d6fd289779e494340a2b85c", size = 122798, upload-time = "2026-03-09T13:12:58.963Z" }, + { url = "https://files.pythonhosted.org/packages/11/60/37b4047a2af0cf5ef6d8b4b26e91829ae6fc6a2d1f74524bcb0e7cd28a32/kiwisolver-1.5.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:3c4923e404d6bcd91b6779c009542e5647fef32e4a5d75e115e3bbac6f2335eb", size = 66216, upload-time = "2026-03-09T13:13:00.155Z" }, + { url = "https://files.pythonhosted.org/packages/0a/aa/510dc933d87767584abfe03efa445889996c70c2990f6f87c3ebaa0a18c5/kiwisolver-1.5.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:0df54df7e686afa55e6f21fb86195224a6d9beb71d637e8d7920c95cf0f89aac", size = 63911, upload-time = "2026-03-09T13:13:01.671Z" }, + { url = "https://files.pythonhosted.org/packages/80/46/bddc13df6c2a40741e0cc7865bb1c9ed4796b6760bd04ce5fae3928ef917/kiwisolver-1.5.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:2517e24d7315eb51c10664cdb865195df38ab74456c677df67bb47f12d088a27", size = 1438209, upload-time = "2026-03-09T13:13:03.385Z" }, + { url = "https://files.pythonhosted.org/packages/fd/d6/76621246f5165e5372f02f5e6f3f48ea336a8f9e96e43997d45b240ed8cd/kiwisolver-1.5.0-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ff710414307fefa903e0d9bdf300972f892c23477829f49504e59834f4195398", size = 1248888, upload-time = "2026-03-09T13:13:05.231Z" }, + { url = "https://files.pythonhosted.org/packages/b2/c1/31559ec6fb39a5b48035ce29bb63ade628f321785f38c384dee3e2c08bc1/kiwisolver-1.5.0-cp311-cp311-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6176c1811d9d5a04fa391c490cc44f451e240697a16977f11c6f722efb9041db", size = 1266304, upload-time = "2026-03-09T13:13:06.743Z" }, + { url = "https://files.pythonhosted.org/packages/5e/ef/1cb8276f2d29cc6a41e0a042f27946ca347d3a4a75acf85d0a16aa6dcc82/kiwisolver-1.5.0-cp311-cp311-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:50847dca5d197fcbd389c805aa1a1cf32f25d2e7273dc47ab181a517666b68cc", size = 1319650, upload-time = "2026-03-09T13:13:08.607Z" }, + { url = "https://files.pythonhosted.org/packages/4c/e4/5ba3cecd7ce6236ae4a80f67e5d5531287337d0e1f076ca87a5abe4cd5d0/kiwisolver-1.5.0-cp311-cp311-manylinux_2_39_riscv64.whl", hash = "sha256:01808c6d15f4c3e8559595d6d1fe6411c68e4a3822b4b9972b44473b24f4e679", size = 970949, upload-time = "2026-03-09T13:13:10.299Z" }, + { url = "https://files.pythonhosted.org/packages/5a/69/dc61f7ae9a2f071f26004ced87f078235b5507ab6e5acd78f40365655034/kiwisolver-1.5.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:f1f9f4121ec58628c96baa3de1a55a4e3a333c5102c8e94b64e23bf7b2083309", size = 2199125, upload-time = "2026-03-09T13:13:11.841Z" }, + { url = "https://files.pythonhosted.org/packages/e5/7b/abbe0f1b5afa85f8d084b73e90e5f801c0939eba16ac2e49af7c61a6c28d/kiwisolver-1.5.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:b7d335370ae48a780c6e6a6bbfa97342f563744c39c35562f3f367665f5c1de2", size = 2293783, upload-time = "2026-03-09T13:13:14.399Z" }, + { url = "https://files.pythonhosted.org/packages/8a/80/5908ae149d96d81580d604c7f8aefd0e98f4fd728cf172f477e9f2a81744/kiwisolver-1.5.0-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:800ee55980c18545af444d93fdd60c56b580db5cc54867d8cbf8a1dc0829938c", size = 1960726, upload-time = "2026-03-09T13:13:16.047Z" }, + { url = "https://files.pythonhosted.org/packages/84/08/a78cb776f8c085b7143142ce479859cfec086bd09ee638a317040b6ef420/kiwisolver-1.5.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:c438f6ca858697c9ab67eb28246c92508af972e114cac34e57a6d4ba17a3ac08", size = 2464738, upload-time = "2026-03-09T13:13:17.897Z" }, + { url = "https://files.pythonhosted.org/packages/b1/e1/65584da5356ed6cb12c63791a10b208860ac40a83de165cb6a6751a686e3/kiwisolver-1.5.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:8c63c91f95173f9c2a67c7c526b2cea976828a0e7fced9cdcead2802dc10f8a4", size = 2270718, upload-time = "2026-03-09T13:13:19.421Z" }, + { url = "https://files.pythonhosted.org/packages/be/6c/28f17390b62b8f2f520e2915095b3c94d88681ecf0041e75389d9667f202/kiwisolver-1.5.0-cp311-cp311-win_amd64.whl", hash = "sha256:beb7f344487cdcb9e1efe4b7a29681b74d34c08f0043a327a74da852a6749e7b", size = 73480, upload-time = "2026-03-09T13:13:20.818Z" }, + { url = "https://files.pythonhosted.org/packages/d8/0e/2ee5debc4f77a625778fec5501ff3e8036fe361b7ee28ae402a485bb9694/kiwisolver-1.5.0-cp311-cp311-win_arm64.whl", hash = "sha256:ad4ae4ffd1ee9cd11357b4c66b612da9888f4f4daf2f36995eda64bd45370cac", size = 64930, upload-time = "2026-03-09T13:13:21.997Z" }, + { url = "https://files.pythonhosted.org/packages/4d/b2/818b74ebea34dabe6d0c51cb1c572e046730e64844da6ed646d5298c40ce/kiwisolver-1.5.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:4e9750bc21b886308024f8a54ccb9a2cc38ac9fa813bf4348434e3d54f337ff9", size = 123158, upload-time = "2026-03-09T13:13:23.127Z" }, + { url = "https://files.pythonhosted.org/packages/bf/d9/405320f8077e8e1c5c4bd6adc45e1e6edf6d727b6da7f2e2533cf58bff71/kiwisolver-1.5.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:72ec46b7eba5b395e0a7b63025490d3214c11013f4aacb4f5e8d6c3041829588", size = 66388, upload-time = "2026-03-09T13:13:24.765Z" }, + { url = "https://files.pythonhosted.org/packages/99/9f/795fedf35634f746151ca8839d05681ceb6287fbed6cc1c9bf235f7887c2/kiwisolver-1.5.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ed3a984b31da7481b103f68776f7128a89ef26ed40f4dc41a2223cda7fb24819", size = 64068, upload-time = "2026-03-09T13:13:25.878Z" }, + { url = "https://files.pythonhosted.org/packages/c4/13/680c54afe3e65767bed7ec1a15571e1a2f1257128733851ade24abcefbcc/kiwisolver-1.5.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:bb5136fb5352d3f422df33f0c879a1b0c204004324150cc3b5e3c4f310c9049f", size = 1477934, upload-time = "2026-03-09T13:13:27.166Z" }, + { url = "https://files.pythonhosted.org/packages/c8/2f/cebfcdb60fd6a9b0f6b47a9337198bcbad6fbe15e68189b7011fd914911f/kiwisolver-1.5.0-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b2af221f268f5af85e776a73d62b0845fc8baf8ef0abfae79d29c77d0e776aaf", size = 1278537, upload-time = "2026-03-09T13:13:28.707Z" }, + { url = "https://files.pythonhosted.org/packages/f2/0d/9b782923aada3fafb1d6b84e13121954515c669b18af0c26e7d21f579855/kiwisolver-1.5.0-cp312-cp312-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b0f172dc8ffaccb8522d7c5d899de00133f2f1ca7b0a49b7da98e901de87bf2d", size = 1296685, upload-time = "2026-03-09T13:13:30.528Z" }, + { url = "https://files.pythonhosted.org/packages/27/70/83241b6634b04fe44e892688d5208332bde130f38e610c0418f9ede47ded/kiwisolver-1.5.0-cp312-cp312-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:6ab8ba9152203feec73758dad83af9a0bbe05001eb4639e547207c40cfb52083", size = 1346024, upload-time = "2026-03-09T13:13:32.818Z" }, + { url = "https://files.pythonhosted.org/packages/e4/db/30ed226fb271ae1a6431fc0fe0edffb2efe23cadb01e798caeb9f2ceae8f/kiwisolver-1.5.0-cp312-cp312-manylinux_2_39_riscv64.whl", hash = "sha256:cdee07c4d7f6d72008d3f73b9bf027f4e11550224c7c50d8df1ae4a37c1402a6", size = 987241, upload-time = "2026-03-09T13:13:34.435Z" }, + { url = "https://files.pythonhosted.org/packages/ec/bd/c314595208e4c9587652d50959ead9e461995389664e490f4dce7ff0f782/kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:7c60d3c9b06fb23bd9c6139281ccbdc384297579ae037f08ae90c69f6845c0b1", size = 2227742, upload-time = "2026-03-09T13:13:36.4Z" }, + { url = "https://files.pythonhosted.org/packages/c1/43/0499cec932d935229b5543d073c2b87c9c22846aab48881e9d8d6e742a2d/kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:e315e5ec90d88e140f57696ff85b484ff68bb311e36f2c414aa4286293e6dee0", size = 2323966, upload-time = "2026-03-09T13:13:38.204Z" }, + { url = "https://files.pythonhosted.org/packages/3d/6f/79b0d760907965acfd9d61826a3d41f8f093c538f55cd2633d3f0db269f6/kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:1465387ac63576c3e125e5337a6892b9e99e0627d52317f3ca79e6930d889d15", size = 1977417, upload-time = "2026-03-09T13:13:39.966Z" }, + { url = "https://files.pythonhosted.org/packages/ab/31/01d0537c41cb75a551a438c3c7a80d0c60d60b81f694dac83dd436aec0d0/kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:530a3fd64c87cffa844d4b6b9768774763d9caa299e9b75d8eca6a4423b31314", size = 2491238, upload-time = "2026-03-09T13:13:41.698Z" }, + { url = "https://files.pythonhosted.org/packages/e4/34/8aefdd0be9cfd00a44509251ba864f5caf2991e36772e61c408007e7f417/kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:1d9daea4ea6b9be74fe2f01f7fbade8d6ffab263e781274cffca0dba9be9eec9", size = 2294947, upload-time = "2026-03-09T13:13:43.343Z" }, + { url = "https://files.pythonhosted.org/packages/ad/cf/0348374369ca588f8fe9c338fae49fa4e16eeb10ffb3d012f23a54578a9e/kiwisolver-1.5.0-cp312-cp312-win_amd64.whl", hash = "sha256:f18c2d9782259a6dc132fdc7a63c168cbc74b35284b6d75c673958982a378384", size = 73569, upload-time = "2026-03-09T13:13:45.792Z" }, + { url = "https://files.pythonhosted.org/packages/28/26/192b26196e2316e2bd29deef67e37cdf9870d9af8e085e521afff0fed526/kiwisolver-1.5.0-cp312-cp312-win_arm64.whl", hash = "sha256:f7c7553b13f69c1b29a5bde08ddc6d9d0c8bfb84f9ed01c30db25944aeb852a7", size = 64997, upload-time = "2026-03-09T13:13:46.878Z" }, + { url = "https://files.pythonhosted.org/packages/9d/69/024d6711d5ba575aa65d5538042e99964104e97fa153a9f10bc369182bc2/kiwisolver-1.5.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:fd40bb9cd0891c4c3cb1ddf83f8bbfa15731a248fdc8162669405451e2724b09", size = 123166, upload-time = "2026-03-09T13:13:48.032Z" }, + { url = "https://files.pythonhosted.org/packages/ce/48/adbb40df306f587054a348831220812b9b1d787aff714cfbc8556e38fccd/kiwisolver-1.5.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:c0e1403fd7c26d77c1f03e096dc58a5c726503fa0db0456678b8668f76f521e3", size = 66395, upload-time = "2026-03-09T13:13:49.365Z" }, + { url = "https://files.pythonhosted.org/packages/a8/3a/d0a972b34e1c63e2409413104216cd1caa02c5a37cb668d1687d466c1c45/kiwisolver-1.5.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:dda366d548e89a90d88a86c692377d18d8bd64b39c1fb2b92cb31370e2896bbd", size = 64065, upload-time = "2026-03-09T13:13:50.562Z" }, + { url = "https://files.pythonhosted.org/packages/2b/0a/7b98e1e119878a27ba8618ca1e18b14f992ff1eda40f47bccccf4de44121/kiwisolver-1.5.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:332b4f0145c30b5f5ad9374881133e5aa64320428a57c2c2b61e9d891a51c2f3", size = 1477903, upload-time = "2026-03-09T13:13:52.084Z" }, + { url = "https://files.pythonhosted.org/packages/18/d8/55638d89ffd27799d5cc3d8aa28e12f4ce7a64d67b285114dbedc8ea4136/kiwisolver-1.5.0-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0c50b89ffd3e1a911c69a1dd3de7173c0cd10b130f56222e57898683841e4f96", size = 1278751, upload-time = "2026-03-09T13:13:54.673Z" }, + { url = "https://files.pythonhosted.org/packages/b8/97/b4c8d0d18421ecceba20ad8701358453b88e32414e6f6950b5a4bad54e65/kiwisolver-1.5.0-cp313-cp313-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4db576bb8c3ef9365f8b40fe0f671644de6736ae2c27a2c62d7d8a1b4329f099", size = 1296793, upload-time = "2026-03-09T13:13:56.287Z" }, + { url = "https://files.pythonhosted.org/packages/c4/10/f862f94b6389d8957448ec9df59450b81bec4abb318805375c401a1e6892/kiwisolver-1.5.0-cp313-cp313-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0b85aad90cea8ac6797a53b5d5f2e967334fa4d1149f031c4537569972596cb8", size = 1346041, upload-time = "2026-03-09T13:13:58.269Z" }, + { url = "https://files.pythonhosted.org/packages/a3/6a/f1650af35821eaf09de398ec0bc2aefc8f211f0cda50204c9f1673741ba9/kiwisolver-1.5.0-cp313-cp313-manylinux_2_39_riscv64.whl", hash = "sha256:d36ca54cb4c6c4686f7cbb7b817f66f5911c12ddb519450bbe86707155028f87", size = 987292, upload-time = "2026-03-09T13:13:59.871Z" }, + { url = "https://files.pythonhosted.org/packages/de/19/d7fb82984b9238115fe629c915007be608ebd23dc8629703d917dbfaffd4/kiwisolver-1.5.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:38f4a703656f493b0ad185211ccfca7f0386120f022066b018eb5296d8613e23", size = 2227865, upload-time = "2026-03-09T13:14:01.401Z" }, + { url = "https://files.pythonhosted.org/packages/7f/b9/46b7f386589fd222dac9e9de9c956ce5bcefe2ee73b4e79891381dda8654/kiwisolver-1.5.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:3ac2360e93cb41be81121755c6462cff3beaa9967188c866e5fce5cf13170859", size = 2324369, upload-time = "2026-03-09T13:14:02.972Z" }, + { url = "https://files.pythonhosted.org/packages/92/8b/95e237cf3d9c642960153c769ddcbe278f182c8affb20cecc1cc983e7cc5/kiwisolver-1.5.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:c95cab08d1965db3d84a121f1c7ce7479bdd4072c9b3dafd8fecce48a2e6b902", size = 1977989, upload-time = "2026-03-09T13:14:04.503Z" }, + { url = "https://files.pythonhosted.org/packages/1b/95/980c9df53501892784997820136c01f62bc1865e31b82b9560f980c0e649/kiwisolver-1.5.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:fc20894c3d21194d8041a28b65622d5b86db786da6e3cfe73f0c762951a61167", size = 2491645, upload-time = "2026-03-09T13:14:06.106Z" }, + { url = "https://files.pythonhosted.org/packages/cb/32/900647fd0840abebe1561792c6b31e6a7c0e278fc3973d30572a965ca14c/kiwisolver-1.5.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:7a32f72973f0f950c1920475d5c5ea3d971b81b6f0ec53b8d0a956cc965f22e0", size = 2295237, upload-time = "2026-03-09T13:14:08.891Z" }, + { url = "https://files.pythonhosted.org/packages/be/8a/be60e3bbcf513cc5a50f4a3e88e1dcecebb79c1ad607a7222877becaa101/kiwisolver-1.5.0-cp313-cp313-win_amd64.whl", hash = "sha256:0bf3acf1419fa93064a4c2189ac0b58e3be7872bf6ee6177b0d4c63dc4cea276", size = 73573, upload-time = "2026-03-09T13:14:12.327Z" }, + { url = "https://files.pythonhosted.org/packages/4d/d2/64be2e429eb4fca7f7e1c52a91b12663aeaf25de3895e5cca0f47ef2a8d0/kiwisolver-1.5.0-cp313-cp313-win_arm64.whl", hash = "sha256:fa8eb9ecdb7efb0b226acec134e0d709e87a909fa4971a54c0c4f6e88635484c", size = 64998, upload-time = "2026-03-09T13:14:13.469Z" }, + { url = "https://files.pythonhosted.org/packages/b0/69/ce68dd0c85755ae2de490bf015b62f2cea5f6b14ff00a463f9d0774449ff/kiwisolver-1.5.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:db485b3847d182b908b483b2ed133c66d88d49cacf98fd278fadafe11b4478d1", size = 125700, upload-time = "2026-03-09T13:14:14.636Z" }, + { url = "https://files.pythonhosted.org/packages/74/aa/937aac021cf9d4349990d47eb319309a51355ed1dbdc9c077cdc9224cb11/kiwisolver-1.5.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:be12f931839a3bdfe28b584db0e640a65a8bcbc24560ae3fdb025a449b3d754e", size = 67537, upload-time = "2026-03-09T13:14:15.808Z" }, + { url = "https://files.pythonhosted.org/packages/ee/20/3a87fbece2c40ad0f6f0aefa93542559159c5f99831d596050e8afae7a9f/kiwisolver-1.5.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:16b85d37c2cbb3253226d26e64663f755d88a03439a9c47df6246b35defbdfb7", size = 65514, upload-time = "2026-03-09T13:14:18.035Z" }, + { url = "https://files.pythonhosted.org/packages/f0/7f/f943879cda9007c45e1f7dba216d705c3a18d6b35830e488b6c6a4e7cdf0/kiwisolver-1.5.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4432b835675f0ea7414aab3d37d119f7226d24869b7a829caeab49ebda407b0c", size = 1584848, upload-time = "2026-03-09T13:14:19.745Z" }, + { url = "https://files.pythonhosted.org/packages/37/f8/4d4f85cc1870c127c88d950913370dd76138482161cd07eabbc450deff01/kiwisolver-1.5.0-cp313-cp313t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1b0feb50971481a2cc44d94e88bdb02cdd497618252ae226b8eb1201b957e368", size = 1391542, upload-time = "2026-03-09T13:14:21.54Z" }, + { url = "https://files.pythonhosted.org/packages/04/0b/65dd2916c84d252b244bd405303220f729e7c17c9d7d33dca6feeff9ffc4/kiwisolver-1.5.0-cp313-cp313t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:56fa888f10d0f367155e76ce849fa1166fc9730d13bd2d65a2aa13b6f5424489", size = 1404447, upload-time = "2026-03-09T13:14:23.205Z" }, + { url = "https://files.pythonhosted.org/packages/39/5c/2606a373247babce9b1d056c03a04b65f3cf5290a8eac5d7bdead0a17e21/kiwisolver-1.5.0-cp313-cp313t-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:940dda65d5e764406b9fb92761cbf462e4e63f712ab60ed98f70552e496f3bf1", size = 1455918, upload-time = "2026-03-09T13:14:24.74Z" }, + { url = "https://files.pythonhosted.org/packages/d5/d1/c6078b5756670658e9192a2ef11e939c92918833d2745f85cd14a6004bdf/kiwisolver-1.5.0-cp313-cp313t-manylinux_2_39_riscv64.whl", hash = "sha256:89fc958c702ee9a745e4700378f5d23fddbc46ff89e8fdbf5395c24d5c1452a3", size = 1072856, upload-time = "2026-03-09T13:14:26.597Z" }, + { url = "https://files.pythonhosted.org/packages/cb/c8/7def6ddf16eb2b3741d8b172bdaa9af882b03c78e9b0772975408801fa63/kiwisolver-1.5.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9027d773c4ff81487181a925945743413f6069634d0b122d0b37684ccf4f1e18", size = 2333580, upload-time = "2026-03-09T13:14:28.237Z" }, + { url = "https://files.pythonhosted.org/packages/9e/87/2ac1fce0eb1e616fcd3c35caa23e665e9b1948bb984f4764790924594128/kiwisolver-1.5.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:5b233ea3e165e43e35dba1d2b8ecc21cf070b45b65ae17dd2747d2713d942021", size = 2423018, upload-time = "2026-03-09T13:14:30.018Z" }, + { url = "https://files.pythonhosted.org/packages/67/13/c6700ccc6cc218716bfcda4935e4b2997039869b4ad8a94f364c5a3b8e63/kiwisolver-1.5.0-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:ce9bf03dad3b46408c08649c6fbd6ca28a9fce0eb32fdfffa6775a13103b5310", size = 2062804, upload-time = "2026-03-09T13:14:32.888Z" }, + { url = "https://files.pythonhosted.org/packages/1b/bd/877056304626943ff0f1f44c08f584300c199b887cb3176cd7e34f1515f1/kiwisolver-1.5.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:fc4d3f1fb9ca0ae9f97b095963bc6326f1dbfd3779d6679a1e016b9baaa153d3", size = 2597482, upload-time = "2026-03-09T13:14:34.971Z" }, + { url = "https://files.pythonhosted.org/packages/75/19/c60626c47bf0f8ac5dcf72c6c98e266d714f2fbbfd50cf6dab5ede3aaa50/kiwisolver-1.5.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:f443b4825c50a51ee68585522ab4a1d1257fac65896f282b4c6763337ac9f5d2", size = 2394328, upload-time = "2026-03-09T13:14:36.816Z" }, + { url = "https://files.pythonhosted.org/packages/47/84/6a6d5e5bb8273756c27b7d810d47f7ef2f1f9b9fd23c9ee9a3f8c75c9cef/kiwisolver-1.5.0-cp313-cp313t-win_arm64.whl", hash = "sha256:893ff3a711d1b515ba9da14ee090519bad4610ed1962fbe298a434e8c5f8db53", size = 68410, upload-time = "2026-03-09T13:14:38.695Z" }, + { url = "https://files.pythonhosted.org/packages/e4/d7/060f45052f2a01ad5762c8fdecd6d7a752b43400dc29ff75cd47225a40fd/kiwisolver-1.5.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:8df31fe574b8b3993cc61764f40941111b25c2d9fea13d3ce24a49907cd2d615", size = 123231, upload-time = "2026-03-09T13:14:41.323Z" }, + { url = "https://files.pythonhosted.org/packages/c2/a7/78da680eadd06ff35edef6ef68a1ad273bad3e2a0936c9a885103230aece/kiwisolver-1.5.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:1d49a49ac4cbfb7c1375301cd1ec90169dfeae55ff84710d782260ce77a75a02", size = 66489, upload-time = "2026-03-09T13:14:42.534Z" }, + { url = "https://files.pythonhosted.org/packages/49/b2/97980f3ad4fae37dd7fe31626e2bf75fbf8bdf5d303950ec1fab39a12da8/kiwisolver-1.5.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:0cbe94b69b819209a62cb27bdfa5dc2a8977d8de2f89dfd97ba4f53ed3af754e", size = 64063, upload-time = "2026-03-09T13:14:44.759Z" }, + { url = "https://files.pythonhosted.org/packages/e7/f9/b06c934a6aa8bc91f566bd2a214fd04c30506c2d9e2b6b171953216a65b6/kiwisolver-1.5.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:80aa065ffd378ff784822a6d7c3212f2d5f5e9c3589614b5c228b311fd3063ac", size = 1475913, upload-time = "2026-03-09T13:14:46.247Z" }, + { url = "https://files.pythonhosted.org/packages/6b/f0/f768ae564a710135630672981231320bc403cf9152b5596ec5289de0f106/kiwisolver-1.5.0-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4e7f886f47ab881692f278ae901039a234e4025a68e6dfab514263a0b1c4ae05", size = 1282782, upload-time = "2026-03-09T13:14:48.458Z" }, + { url = "https://files.pythonhosted.org/packages/e2/9f/1de7aad00697325f05238a5f2eafbd487fb637cc27a558b5367a5f37fb7f/kiwisolver-1.5.0-cp314-cp314-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5060731cc3ed12ca3a8b57acd4aeca5bbc2f49216dd0bec1650a1acd89486bcd", size = 1300815, upload-time = "2026-03-09T13:14:50.721Z" }, + { url = "https://files.pythonhosted.org/packages/5a/c2/297f25141d2e468e0ce7f7a7b92e0cf8918143a0cbd3422c1ad627e85a06/kiwisolver-1.5.0-cp314-cp314-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:7a4aa69609f40fce3cbc3f87b2061f042eee32f94b8f11db707b66a26461591a", size = 1347925, upload-time = "2026-03-09T13:14:52.304Z" }, + { url = "https://files.pythonhosted.org/packages/b9/d3/f4c73a02eb41520c47610207b21afa8cdd18fdbf64ffd94674ae21c4812d/kiwisolver-1.5.0-cp314-cp314-manylinux_2_39_riscv64.whl", hash = "sha256:d168fda2dbff7b9b5f38e693182d792a938c31db4dac3a80a4888de603c99554", size = 991322, upload-time = "2026-03-09T13:14:54.637Z" }, + { url = "https://files.pythonhosted.org/packages/7b/46/d3f2efef7732fcda98d22bf4ad5d3d71d545167a852ca710a494f4c15343/kiwisolver-1.5.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:413b820229730d358efd838ecbab79902fe97094565fdc80ddb6b0a18c18a581", size = 2232857, upload-time = "2026-03-09T13:14:56.471Z" }, + { url = "https://files.pythonhosted.org/packages/3f/ec/2d9756bf2b6d26ae4349b8d3662fb3993f16d80c1f971c179ce862b9dbae/kiwisolver-1.5.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:5124d1ea754509b09e53738ec185584cc609aae4a3b510aaf4ed6aa047ef9303", size = 2329376, upload-time = "2026-03-09T13:14:58.072Z" }, + { url = "https://files.pythonhosted.org/packages/8f/9f/876a0a0f2260f1bde92e002b3019a5fabc35e0939c7d945e0fa66185eb20/kiwisolver-1.5.0-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:e4415a8db000bf49a6dd1c478bf70062eaacff0f462b92b0ba68791a905861f9", size = 1982549, upload-time = "2026-03-09T13:14:59.668Z" }, + { url = "https://files.pythonhosted.org/packages/6c/4f/ba3624dfac23a64d54ac4179832860cb537c1b0af06024936e82ca4154a0/kiwisolver-1.5.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:d618fd27420381a4f6044faa71f46d8bfd911bd077c555f7138ed88729bfbe79", size = 2494680, upload-time = "2026-03-09T13:15:01.364Z" }, + { url = "https://files.pythonhosted.org/packages/39/b7/97716b190ab98911b20d10bf92eca469121ec483b8ce0edd314f51bc85af/kiwisolver-1.5.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5092eb5b1172947f57d6ea7d89b2f29650414e4293c47707eb499ec07a0ac796", size = 2297905, upload-time = "2026-03-09T13:15:03.925Z" }, + { url = "https://files.pythonhosted.org/packages/a3/36/4e551e8aa55c9188bca9abb5096805edbf7431072b76e2298e34fd3a3008/kiwisolver-1.5.0-cp314-cp314-win_amd64.whl", hash = "sha256:d76e2d8c75051d58177e762164d2e9ab92886534e3a12e795f103524f221dd8e", size = 75086, upload-time = "2026-03-09T13:15:07.775Z" }, + { url = "https://files.pythonhosted.org/packages/70/15/9b90f7df0e31a003c71649cf66ef61c3c1b862f48c81007fa2383c8bd8d7/kiwisolver-1.5.0-cp314-cp314-win_arm64.whl", hash = "sha256:fa6248cd194edff41d7ea9425ced8ca3a6f838bfb295f6f1d6e6bb694a8518df", size = 66577, upload-time = "2026-03-09T13:15:09.139Z" }, + { url = "https://files.pythonhosted.org/packages/17/01/7dc8c5443ff42b38e72731643ed7cf1ed9bf01691ae5cdca98501999ed83/kiwisolver-1.5.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:d1ffeb80b5676463d7a7d56acbe8e37a20ce725570e09549fe738e02ca6b7e1e", size = 125794, upload-time = "2026-03-09T13:15:10.525Z" }, + { url = "https://files.pythonhosted.org/packages/46/8a/b4ebe46ebaac6a303417fab10c2e165c557ddaff558f9699d302b256bc53/kiwisolver-1.5.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:bc4d8e252f532ab46a1de9349e2d27b91fce46736a9eedaa37beaca66f574ed4", size = 67646, upload-time = "2026-03-09T13:15:12.016Z" }, + { url = "https://files.pythonhosted.org/packages/60/35/10a844afc5f19d6f567359bf4789e26661755a2f36200d5d1ed8ad0126e5/kiwisolver-1.5.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:6783e069732715ad0c3ce96dbf21dbc2235ab0593f2baf6338101f70371f4028", size = 65511, upload-time = "2026-03-09T13:15:13.311Z" }, + { url = "https://files.pythonhosted.org/packages/f8/8a/685b297052dd041dcebce8e8787b58923b6e78acc6115a0dc9189011c44b/kiwisolver-1.5.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:e7c4c09a490dc4d4a7f8cbee56c606a320f9dc28cf92a7157a39d1ce7676a657", size = 1584858, upload-time = "2026-03-09T13:15:15.103Z" }, + { url = "https://files.pythonhosted.org/packages/9e/80/04865e3d4638ac5bddec28908916df4a3075b8c6cc101786a96803188b96/kiwisolver-1.5.0-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2a075bd7bd19c70cf67c8badfa36cf7c5d8de3c9ddb8420c51e10d9c50e94920", size = 1392539, upload-time = "2026-03-09T13:15:16.661Z" }, + { url = "https://files.pythonhosted.org/packages/ba/01/77a19cacc0893fa13fafa46d1bba06fb4dc2360b3292baf4b56d8e067b24/kiwisolver-1.5.0-cp314-cp314t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:bdd3e53429ff02aa319ba59dfe4ceeec345bf46cf180ec2cf6fd5b942e7975e9", size = 1405310, upload-time = "2026-03-09T13:15:18.229Z" }, + { url = "https://files.pythonhosted.org/packages/53/39/bcaf5d0cca50e604cfa9b4e3ae1d64b50ca1ae5b754122396084599ef903/kiwisolver-1.5.0-cp314-cp314t-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3cdcb35dc9d807259c981a85531048ede628eabcffb3239adf3d17463518992d", size = 1456244, upload-time = "2026-03-09T13:15:20.444Z" }, + { url = "https://files.pythonhosted.org/packages/d0/7a/72c187abc6975f6978c3e39b7cf67aeb8b3c0a8f9790aa7fd412855e9e1f/kiwisolver-1.5.0-cp314-cp314t-manylinux_2_39_riscv64.whl", hash = "sha256:70d593af6a6ca332d1df73d519fddb5148edb15cd90d5f0155e3746a6d4fcc65", size = 1073154, upload-time = "2026-03-09T13:15:22.039Z" }, + { url = "https://files.pythonhosted.org/packages/c7/ca/cf5b25783ebbd59143b4371ed0c8428a278abe68d6d0104b01865b1bbd0f/kiwisolver-1.5.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:377815a8616074cabbf3f53354e1d040c35815a134e01d7614b7692e4bf8acfa", size = 2334377, upload-time = "2026-03-09T13:15:23.741Z" }, + { url = "https://files.pythonhosted.org/packages/4a/e5/b1f492adc516796e88751282276745340e2a72dcd0d36cf7173e0daf3210/kiwisolver-1.5.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:0255a027391d52944eae1dbb5d4cc5903f57092f3674e8e544cdd2622826b3f0", size = 2425288, upload-time = "2026-03-09T13:15:25.789Z" }, + { url = "https://files.pythonhosted.org/packages/e6/e5/9b21fbe91a61b8f409d74a26498706e97a48008bfcd1864373d32a6ba31c/kiwisolver-1.5.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:012b1eb16e28718fa782b5e61dc6f2da1f0792ca73bd05d54de6cb9561665fc9", size = 2063158, upload-time = "2026-03-09T13:15:27.63Z" }, + { url = "https://files.pythonhosted.org/packages/b1/02/83f47986138310f95ea95531f851b2a62227c11cbc3e690ae1374fe49f0f/kiwisolver-1.5.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:0e3aafb33aed7479377e5e9a82e9d4bf87063741fc99fc7ae48b0f16e32bdd6f", size = 2597260, upload-time = "2026-03-09T13:15:29.421Z" }, + { url = "https://files.pythonhosted.org/packages/07/18/43a5f24608d8c313dd189cf838c8e68d75b115567c6279de7796197cfb6a/kiwisolver-1.5.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:e7a116ae737f0000343218c4edf5bd45893bfeaff0993c0b215d7124c9f77646", size = 2394403, upload-time = "2026-03-09T13:15:31.517Z" }, + { url = "https://files.pythonhosted.org/packages/3b/b5/98222136d839b8afabcaa943b09bd05888c2d36355b7e448550211d1fca4/kiwisolver-1.5.0-cp314-cp314t-win_amd64.whl", hash = "sha256:1dd9b0b119a350976a6d781e7278ec7aca0b201e1a9e2d23d9804afecb6ca681", size = 79687, upload-time = "2026-03-09T13:15:33.204Z" }, + { url = "https://files.pythonhosted.org/packages/99/a2/ca7dc962848040befed12732dff6acae7fb3c4f6fc4272b3f6c9a30b8713/kiwisolver-1.5.0-cp314-cp314t-win_arm64.whl", hash = "sha256:58f812017cd2985c21fbffb4864d59174d4903dd66fa23815e74bbc7a0e2dd57", size = 70032, upload-time = "2026-03-09T13:15:34.411Z" }, + { url = "https://files.pythonhosted.org/packages/1c/fa/2910df836372d8761bb6eff7d8bdcb1613b5c2e03f260efe7abe34d388a7/kiwisolver-1.5.0-graalpy312-graalpy250_312_native-macosx_10_13_x86_64.whl", hash = "sha256:5ae8e62c147495b01a0f4765c878e9bfdf843412446a247e28df59936e99e797", size = 130262, upload-time = "2026-03-09T13:15:35.629Z" }, + { url = "https://files.pythonhosted.org/packages/0f/41/c5f71f9f00aabcc71fee8b7475e3f64747282580c2fe748961ba29b18385/kiwisolver-1.5.0-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:f6764a4ccab3078db14a632420930f6186058750df066b8ea2a7106df91d3203", size = 138036, upload-time = "2026-03-09T13:15:36.894Z" }, + { url = "https://files.pythonhosted.org/packages/fa/06/7399a607f434119c6e1fdc8ec89a8d51ccccadf3341dee4ead6bd14caaf5/kiwisolver-1.5.0-graalpy312-graalpy250_312_native-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c31c13da98624f957b0fb1b5bae5383b2333c2c3f6793d9825dd5ce79b525cb7", size = 194295, upload-time = "2026-03-09T13:15:38.22Z" }, + { url = "https://files.pythonhosted.org/packages/b5/91/53255615acd2a1eaca307ede3c90eb550bae9c94581f8c00081b6b1c8f44/kiwisolver-1.5.0-graalpy312-graalpy250_312_native-win_amd64.whl", hash = "sha256:1f1489f769582498610e015a8ef2d36f28f505ab3096d0e16b4858a9ec214f57", size = 75987, upload-time = "2026-03-09T13:15:39.65Z" }, + { url = "https://files.pythonhosted.org/packages/e9/eb/5fcbbbf9a0e2c3a35effb88831a483345326bbc3a030a3b5b69aee647f84/kiwisolver-1.5.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:ec4c85dc4b687c7f7f15f553ff26a98bfe8c58f5f7f0ac8905f0ba4c7be60232", size = 59532, upload-time = "2026-03-09T13:15:47.047Z" }, + { url = "https://files.pythonhosted.org/packages/c3/9b/e17104555bb4db148fd52327feea1e96be4b88e8e008b029002c281a21ab/kiwisolver-1.5.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:12e91c215a96e39f57989c8912ae761286ac5a9584d04030ceb3368a357f017a", size = 57420, upload-time = "2026-03-09T13:15:48.199Z" }, + { url = "https://files.pythonhosted.org/packages/48/44/2b5b95b7aa39fb2d8d9d956e0f3d5d45aef2ae1d942d4c3ffac2f9cfed1a/kiwisolver-1.5.0-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:be4a51a55833dc29ab5d7503e7bcb3b3af3402d266018137127450005cdfe737", size = 79892, upload-time = "2026-03-09T13:15:49.694Z" }, + { url = "https://files.pythonhosted.org/packages/52/7d/7157f9bba6b455cfb4632ed411e199fc8b8977642c2b12082e1bd9e6d173/kiwisolver-1.5.0-pp311-pypy311_pp73-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:daae526907e262de627d8f70058a0f64acc9e2641c164c99c8f594b34a799a16", size = 77603, upload-time = "2026-03-09T13:15:50.945Z" }, + { url = "https://files.pythonhosted.org/packages/0a/dd/8050c947d435c8d4bc94e3252f4d8bb8a76cfb424f043a8680be637a57f1/kiwisolver-1.5.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:59cd8683f575d96df5bb48f6add94afc055012c29e28124fcae2b63661b9efb1", size = 73558, upload-time = "2026-03-09T13:15:52.112Z" }, +] + +[[package]] +name = "markupsafe" +version = "3.0.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7e/99/7690b6d4034fffd95959cbe0c02de8deb3098cc577c67bb6a24fe5d7caa7/markupsafe-3.0.3.tar.gz", hash = "sha256:722695808f4b6457b320fdc131280796bdceb04ab50fe1795cd540799ebe1698", size = 80313, upload-time = "2025-09-27T18:37:40.426Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/08/db/fefacb2136439fc8dd20e797950e749aa1f4997ed584c62cfb8ef7c2be0e/markupsafe-3.0.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:1cc7ea17a6824959616c525620e387f6dd30fec8cb44f649e31712db02123dad", size = 11631, upload-time = "2025-09-27T18:36:18.185Z" }, + { url = "https://files.pythonhosted.org/packages/e1/2e/5898933336b61975ce9dc04decbc0a7f2fee78c30353c5efba7f2d6ff27a/markupsafe-3.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4bd4cd07944443f5a265608cc6aab442e4f74dff8088b0dfc8238647b8f6ae9a", size = 12058, upload-time = "2025-09-27T18:36:19.444Z" }, + { url = "https://files.pythonhosted.org/packages/1d/09/adf2df3699d87d1d8184038df46a9c80d78c0148492323f4693df54e17bb/markupsafe-3.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b5420a1d9450023228968e7e6a9ce57f65d148ab56d2313fcd589eee96a7a50", size = 24287, upload-time = "2025-09-27T18:36:20.768Z" }, + { url = "https://files.pythonhosted.org/packages/30/ac/0273f6fcb5f42e314c6d8cd99effae6a5354604d461b8d392b5ec9530a54/markupsafe-3.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0bf2a864d67e76e5c9a34dc26ec616a66b9888e25e7b9460e1c76d3293bd9dbf", size = 22940, upload-time = "2025-09-27T18:36:22.249Z" }, + { url = "https://files.pythonhosted.org/packages/19/ae/31c1be199ef767124c042c6c3e904da327a2f7f0cd63a0337e1eca2967a8/markupsafe-3.0.3-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:bc51efed119bc9cfdf792cdeaa4d67e8f6fcccab66ed4bfdd6bde3e59bfcbb2f", size = 21887, upload-time = "2025-09-27T18:36:23.535Z" }, + { url = "https://files.pythonhosted.org/packages/b2/76/7edcab99d5349a4532a459e1fe64f0b0467a3365056ae550d3bcf3f79e1e/markupsafe-3.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:068f375c472b3e7acbe2d5318dea141359e6900156b5b2ba06a30b169086b91a", size = 23692, upload-time = "2025-09-27T18:36:24.823Z" }, + { url = "https://files.pythonhosted.org/packages/a4/28/6e74cdd26d7514849143d69f0bf2399f929c37dc2b31e6829fd2045b2765/markupsafe-3.0.3-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:7be7b61bb172e1ed687f1754f8e7484f1c8019780f6f6b0786e76bb01c2ae115", size = 21471, upload-time = "2025-09-27T18:36:25.95Z" }, + { url = "https://files.pythonhosted.org/packages/62/7e/a145f36a5c2945673e590850a6f8014318d5577ed7e5920a4b3448e0865d/markupsafe-3.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f9e130248f4462aaa8e2552d547f36ddadbeaa573879158d721bbd33dfe4743a", size = 22923, upload-time = "2025-09-27T18:36:27.109Z" }, + { url = "https://files.pythonhosted.org/packages/0f/62/d9c46a7f5c9adbeeeda52f5b8d802e1094e9717705a645efc71b0913a0a8/markupsafe-3.0.3-cp311-cp311-win32.whl", hash = "sha256:0db14f5dafddbb6d9208827849fad01f1a2609380add406671a26386cdf15a19", size = 14572, upload-time = "2025-09-27T18:36:28.045Z" }, + { url = "https://files.pythonhosted.org/packages/83/8a/4414c03d3f891739326e1783338e48fb49781cc915b2e0ee052aa490d586/markupsafe-3.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:de8a88e63464af587c950061a5e6a67d3632e36df62b986892331d4620a35c01", size = 15077, upload-time = "2025-09-27T18:36:29.025Z" }, + { url = "https://files.pythonhosted.org/packages/35/73/893072b42e6862f319b5207adc9ae06070f095b358655f077f69a35601f0/markupsafe-3.0.3-cp311-cp311-win_arm64.whl", hash = "sha256:3b562dd9e9ea93f13d53989d23a7e775fdfd1066c33494ff43f5418bc8c58a5c", size = 13876, upload-time = "2025-09-27T18:36:29.954Z" }, + { url = "https://files.pythonhosted.org/packages/5a/72/147da192e38635ada20e0a2e1a51cf8823d2119ce8883f7053879c2199b5/markupsafe-3.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:d53197da72cc091b024dd97249dfc7794d6a56530370992a5e1a08983ad9230e", size = 11615, upload-time = "2025-09-27T18:36:30.854Z" }, + { url = "https://files.pythonhosted.org/packages/9a/81/7e4e08678a1f98521201c3079f77db69fb552acd56067661f8c2f534a718/markupsafe-3.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1872df69a4de6aead3491198eaf13810b565bdbeec3ae2dc8780f14458ec73ce", size = 12020, upload-time = "2025-09-27T18:36:31.971Z" }, + { url = "https://files.pythonhosted.org/packages/1e/2c/799f4742efc39633a1b54a92eec4082e4f815314869865d876824c257c1e/markupsafe-3.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3a7e8ae81ae39e62a41ec302f972ba6ae23a5c5396c8e60113e9066ef893da0d", size = 24332, upload-time = "2025-09-27T18:36:32.813Z" }, + { url = "https://files.pythonhosted.org/packages/3c/2e/8d0c2ab90a8c1d9a24f0399058ab8519a3279d1bd4289511d74e909f060e/markupsafe-3.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d6dd0be5b5b189d31db7cda48b91d7e0a9795f31430b7f271219ab30f1d3ac9d", size = 22947, upload-time = "2025-09-27T18:36:33.86Z" }, + { url = "https://files.pythonhosted.org/packages/2c/54/887f3092a85238093a0b2154bd629c89444f395618842e8b0c41783898ea/markupsafe-3.0.3-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:94c6f0bb423f739146aec64595853541634bde58b2135f27f61c1ffd1cd4d16a", size = 21962, upload-time = "2025-09-27T18:36:35.099Z" }, + { url = "https://files.pythonhosted.org/packages/c9/2f/336b8c7b6f4a4d95e91119dc8521402461b74a485558d8f238a68312f11c/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:be8813b57049a7dc738189df53d69395eba14fb99345e0a5994914a3864c8a4b", size = 23760, upload-time = "2025-09-27T18:36:36.001Z" }, + { url = "https://files.pythonhosted.org/packages/32/43/67935f2b7e4982ffb50a4d169b724d74b62a3964bc1a9a527f5ac4f1ee2b/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:83891d0e9fb81a825d9a6d61e3f07550ca70a076484292a70fde82c4b807286f", size = 21529, upload-time = "2025-09-27T18:36:36.906Z" }, + { url = "https://files.pythonhosted.org/packages/89/e0/4486f11e51bbba8b0c041098859e869e304d1c261e59244baa3d295d47b7/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:77f0643abe7495da77fb436f50f8dab76dbc6e5fd25d39589a0f1fe6548bfa2b", size = 23015, upload-time = "2025-09-27T18:36:37.868Z" }, + { url = "https://files.pythonhosted.org/packages/2f/e1/78ee7a023dac597a5825441ebd17170785a9dab23de95d2c7508ade94e0e/markupsafe-3.0.3-cp312-cp312-win32.whl", hash = "sha256:d88b440e37a16e651bda4c7c2b930eb586fd15ca7406cb39e211fcff3bf3017d", size = 14540, upload-time = "2025-09-27T18:36:38.761Z" }, + { url = "https://files.pythonhosted.org/packages/aa/5b/bec5aa9bbbb2c946ca2733ef9c4ca91c91b6a24580193e891b5f7dbe8e1e/markupsafe-3.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:26a5784ded40c9e318cfc2bdb30fe164bdb8665ded9cd64d500a34fb42067b1c", size = 15105, upload-time = "2025-09-27T18:36:39.701Z" }, + { url = "https://files.pythonhosted.org/packages/e5/f1/216fc1bbfd74011693a4fd837e7026152e89c4bcf3e77b6692fba9923123/markupsafe-3.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:35add3b638a5d900e807944a078b51922212fb3dedb01633a8defc4b01a3c85f", size = 13906, upload-time = "2025-09-27T18:36:40.689Z" }, + { url = "https://files.pythonhosted.org/packages/38/2f/907b9c7bbba283e68f20259574b13d005c121a0fa4c175f9bed27c4597ff/markupsafe-3.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e1cf1972137e83c5d4c136c43ced9ac51d0e124706ee1c8aa8532c1287fa8795", size = 11622, upload-time = "2025-09-27T18:36:41.777Z" }, + { url = "https://files.pythonhosted.org/packages/9c/d9/5f7756922cdd676869eca1c4e3c0cd0df60ed30199ffd775e319089cb3ed/markupsafe-3.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:116bb52f642a37c115f517494ea5feb03889e04df47eeff5b130b1808ce7c219", size = 12029, upload-time = "2025-09-27T18:36:43.257Z" }, + { url = "https://files.pythonhosted.org/packages/00/07/575a68c754943058c78f30db02ee03a64b3c638586fba6a6dd56830b30a3/markupsafe-3.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:133a43e73a802c5562be9bbcd03d090aa5a1fe899db609c29e8c8d815c5f6de6", size = 24374, upload-time = "2025-09-27T18:36:44.508Z" }, + { url = "https://files.pythonhosted.org/packages/a9/21/9b05698b46f218fc0e118e1f8168395c65c8a2c750ae2bab54fc4bd4e0e8/markupsafe-3.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ccfcd093f13f0f0b7fdd0f198b90053bf7b2f02a3927a30e63f3ccc9df56b676", size = 22980, upload-time = "2025-09-27T18:36:45.385Z" }, + { url = "https://files.pythonhosted.org/packages/7f/71/544260864f893f18b6827315b988c146b559391e6e7e8f7252839b1b846a/markupsafe-3.0.3-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:509fa21c6deb7a7a273d629cf5ec029bc209d1a51178615ddf718f5918992ab9", size = 21990, upload-time = "2025-09-27T18:36:46.916Z" }, + { url = "https://files.pythonhosted.org/packages/c2/28/b50fc2f74d1ad761af2f5dcce7492648b983d00a65b8c0e0cb457c82ebbe/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a4afe79fb3de0b7097d81da19090f4df4f8d3a2b3adaa8764138aac2e44f3af1", size = 23784, upload-time = "2025-09-27T18:36:47.884Z" }, + { url = "https://files.pythonhosted.org/packages/ed/76/104b2aa106a208da8b17a2fb72e033a5a9d7073c68f7e508b94916ed47a9/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:795e7751525cae078558e679d646ae45574b47ed6e7771863fcc079a6171a0fc", size = 21588, upload-time = "2025-09-27T18:36:48.82Z" }, + { url = "https://files.pythonhosted.org/packages/b5/99/16a5eb2d140087ebd97180d95249b00a03aa87e29cc224056274f2e45fd6/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8485f406a96febb5140bfeca44a73e3ce5116b2501ac54fe953e488fb1d03b12", size = 23041, upload-time = "2025-09-27T18:36:49.797Z" }, + { url = "https://files.pythonhosted.org/packages/19/bc/e7140ed90c5d61d77cea142eed9f9c303f4c4806f60a1044c13e3f1471d0/markupsafe-3.0.3-cp313-cp313-win32.whl", hash = "sha256:bdd37121970bfd8be76c5fb069c7751683bdf373db1ed6c010162b2a130248ed", size = 14543, upload-time = "2025-09-27T18:36:51.584Z" }, + { url = "https://files.pythonhosted.org/packages/05/73/c4abe620b841b6b791f2edc248f556900667a5a1cf023a6646967ae98335/markupsafe-3.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:9a1abfdc021a164803f4d485104931fb8f8c1efd55bc6b748d2f5774e78b62c5", size = 15113, upload-time = "2025-09-27T18:36:52.537Z" }, + { url = "https://files.pythonhosted.org/packages/f0/3a/fa34a0f7cfef23cf9500d68cb7c32dd64ffd58a12b09225fb03dd37d5b80/markupsafe-3.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:7e68f88e5b8799aa49c85cd116c932a1ac15caaa3f5db09087854d218359e485", size = 13911, upload-time = "2025-09-27T18:36:53.513Z" }, + { url = "https://files.pythonhosted.org/packages/e4/d7/e05cd7efe43a88a17a37b3ae96e79a19e846f3f456fe79c57ca61356ef01/markupsafe-3.0.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:218551f6df4868a8d527e3062d0fb968682fe92054e89978594c28e642c43a73", size = 11658, upload-time = "2025-09-27T18:36:54.819Z" }, + { url = "https://files.pythonhosted.org/packages/99/9e/e412117548182ce2148bdeacdda3bb494260c0b0184360fe0d56389b523b/markupsafe-3.0.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:3524b778fe5cfb3452a09d31e7b5adefeea8c5be1d43c4f810ba09f2ceb29d37", size = 12066, upload-time = "2025-09-27T18:36:55.714Z" }, + { url = "https://files.pythonhosted.org/packages/bc/e6/fa0ffcda717ef64a5108eaa7b4f5ed28d56122c9a6d70ab8b72f9f715c80/markupsafe-3.0.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4e885a3d1efa2eadc93c894a21770e4bc67899e3543680313b09f139e149ab19", size = 25639, upload-time = "2025-09-27T18:36:56.908Z" }, + { url = "https://files.pythonhosted.org/packages/96/ec/2102e881fe9d25fc16cb4b25d5f5cde50970967ffa5dddafdb771237062d/markupsafe-3.0.3-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8709b08f4a89aa7586de0aadc8da56180242ee0ada3999749b183aa23df95025", size = 23569, upload-time = "2025-09-27T18:36:57.913Z" }, + { url = "https://files.pythonhosted.org/packages/4b/30/6f2fce1f1f205fc9323255b216ca8a235b15860c34b6798f810f05828e32/markupsafe-3.0.3-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b8512a91625c9b3da6f127803b166b629725e68af71f8184ae7e7d54686a56d6", size = 23284, upload-time = "2025-09-27T18:36:58.833Z" }, + { url = "https://files.pythonhosted.org/packages/58/47/4a0ccea4ab9f5dcb6f79c0236d954acb382202721e704223a8aafa38b5c8/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9b79b7a16f7fedff2495d684f2b59b0457c3b493778c9eed31111be64d58279f", size = 24801, upload-time = "2025-09-27T18:36:59.739Z" }, + { url = "https://files.pythonhosted.org/packages/6a/70/3780e9b72180b6fecb83a4814d84c3bf4b4ae4bf0b19c27196104149734c/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:12c63dfb4a98206f045aa9563db46507995f7ef6d83b2f68eda65c307c6829eb", size = 22769, upload-time = "2025-09-27T18:37:00.719Z" }, + { url = "https://files.pythonhosted.org/packages/98/c5/c03c7f4125180fc215220c035beac6b9cb684bc7a067c84fc69414d315f5/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:8f71bc33915be5186016f675cd83a1e08523649b0e33efdb898db577ef5bb009", size = 23642, upload-time = "2025-09-27T18:37:01.673Z" }, + { url = "https://files.pythonhosted.org/packages/80/d6/2d1b89f6ca4bff1036499b1e29a1d02d282259f3681540e16563f27ebc23/markupsafe-3.0.3-cp313-cp313t-win32.whl", hash = "sha256:69c0b73548bc525c8cb9a251cddf1931d1db4d2258e9599c28c07ef3580ef354", size = 14612, upload-time = "2025-09-27T18:37:02.639Z" }, + { url = "https://files.pythonhosted.org/packages/2b/98/e48a4bfba0a0ffcf9925fe2d69240bfaa19c6f7507b8cd09c70684a53c1e/markupsafe-3.0.3-cp313-cp313t-win_amd64.whl", hash = "sha256:1b4b79e8ebf6b55351f0d91fe80f893b4743f104bff22e90697db1590e47a218", size = 15200, upload-time = "2025-09-27T18:37:03.582Z" }, + { url = "https://files.pythonhosted.org/packages/0e/72/e3cc540f351f316e9ed0f092757459afbc595824ca724cbc5a5d4263713f/markupsafe-3.0.3-cp313-cp313t-win_arm64.whl", hash = "sha256:ad2cf8aa28b8c020ab2fc8287b0f823d0a7d8630784c31e9ee5edea20f406287", size = 13973, upload-time = "2025-09-27T18:37:04.929Z" }, + { url = "https://files.pythonhosted.org/packages/33/8a/8e42d4838cd89b7dde187011e97fe6c3af66d8c044997d2183fbd6d31352/markupsafe-3.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:eaa9599de571d72e2daf60164784109f19978b327a3910d3e9de8c97b5b70cfe", size = 11619, upload-time = "2025-09-27T18:37:06.342Z" }, + { url = "https://files.pythonhosted.org/packages/b5/64/7660f8a4a8e53c924d0fa05dc3a55c9cee10bbd82b11c5afb27d44b096ce/markupsafe-3.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c47a551199eb8eb2121d4f0f15ae0f923d31350ab9280078d1e5f12b249e0026", size = 12029, upload-time = "2025-09-27T18:37:07.213Z" }, + { url = "https://files.pythonhosted.org/packages/da/ef/e648bfd021127bef5fa12e1720ffed0c6cbb8310c8d9bea7266337ff06de/markupsafe-3.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f34c41761022dd093b4b6896d4810782ffbabe30f2d443ff5f083e0cbbb8c737", size = 24408, upload-time = "2025-09-27T18:37:09.572Z" }, + { url = "https://files.pythonhosted.org/packages/41/3c/a36c2450754618e62008bf7435ccb0f88053e07592e6028a34776213d877/markupsafe-3.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:457a69a9577064c05a97c41f4e65148652db078a3a509039e64d3467b9e7ef97", size = 23005, upload-time = "2025-09-27T18:37:10.58Z" }, + { url = "https://files.pythonhosted.org/packages/bc/20/b7fdf89a8456b099837cd1dc21974632a02a999ec9bf7ca3e490aacd98e7/markupsafe-3.0.3-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e8afc3f2ccfa24215f8cb28dcf43f0113ac3c37c2f0f0806d8c70e4228c5cf4d", size = 22048, upload-time = "2025-09-27T18:37:11.547Z" }, + { url = "https://files.pythonhosted.org/packages/9a/a7/591f592afdc734f47db08a75793a55d7fbcc6902a723ae4cfbab61010cc5/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:ec15a59cf5af7be74194f7ab02d0f59a62bdcf1a537677ce67a2537c9b87fcda", size = 23821, upload-time = "2025-09-27T18:37:12.48Z" }, + { url = "https://files.pythonhosted.org/packages/7d/33/45b24e4f44195b26521bc6f1a82197118f74df348556594bd2262bda1038/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:0eb9ff8191e8498cca014656ae6b8d61f39da5f95b488805da4bb029cccbfbaf", size = 21606, upload-time = "2025-09-27T18:37:13.485Z" }, + { url = "https://files.pythonhosted.org/packages/ff/0e/53dfaca23a69fbfbbf17a4b64072090e70717344c52eaaaa9c5ddff1e5f0/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:2713baf880df847f2bece4230d4d094280f4e67b1e813eec43b4c0e144a34ffe", size = 23043, upload-time = "2025-09-27T18:37:14.408Z" }, + { url = "https://files.pythonhosted.org/packages/46/11/f333a06fc16236d5238bfe74daccbca41459dcd8d1fa952e8fbd5dccfb70/markupsafe-3.0.3-cp314-cp314-win32.whl", hash = "sha256:729586769a26dbceff69f7a7dbbf59ab6572b99d94576a5592625d5b411576b9", size = 14747, upload-time = "2025-09-27T18:37:15.36Z" }, + { url = "https://files.pythonhosted.org/packages/28/52/182836104b33b444e400b14f797212f720cbc9ed6ba34c800639d154e821/markupsafe-3.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:bdc919ead48f234740ad807933cdf545180bfbe9342c2bb451556db2ed958581", size = 15341, upload-time = "2025-09-27T18:37:16.496Z" }, + { url = "https://files.pythonhosted.org/packages/6f/18/acf23e91bd94fd7b3031558b1f013adfa21a8e407a3fdb32745538730382/markupsafe-3.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:5a7d5dc5140555cf21a6fefbdbf8723f06fcd2f63ef108f2854de715e4422cb4", size = 14073, upload-time = "2025-09-27T18:37:17.476Z" }, + { url = "https://files.pythonhosted.org/packages/3c/f0/57689aa4076e1b43b15fdfa646b04653969d50cf30c32a102762be2485da/markupsafe-3.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:1353ef0c1b138e1907ae78e2f6c63ff67501122006b0f9abad68fda5f4ffc6ab", size = 11661, upload-time = "2025-09-27T18:37:18.453Z" }, + { url = "https://files.pythonhosted.org/packages/89/c3/2e67a7ca217c6912985ec766c6393b636fb0c2344443ff9d91404dc4c79f/markupsafe-3.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1085e7fbddd3be5f89cc898938f42c0b3c711fdcb37d75221de2666af647c175", size = 12069, upload-time = "2025-09-27T18:37:19.332Z" }, + { url = "https://files.pythonhosted.org/packages/f0/00/be561dce4e6ca66b15276e184ce4b8aec61fe83662cce2f7d72bd3249d28/markupsafe-3.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1b52b4fb9df4eb9ae465f8d0c228a00624de2334f216f178a995ccdcf82c4634", size = 25670, upload-time = "2025-09-27T18:37:20.245Z" }, + { url = "https://files.pythonhosted.org/packages/50/09/c419f6f5a92e5fadde27efd190eca90f05e1261b10dbd8cbcb39cd8ea1dc/markupsafe-3.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fed51ac40f757d41b7c48425901843666a6677e3e8eb0abcff09e4ba6e664f50", size = 23598, upload-time = "2025-09-27T18:37:21.177Z" }, + { url = "https://files.pythonhosted.org/packages/22/44/a0681611106e0b2921b3033fc19bc53323e0b50bc70cffdd19f7d679bb66/markupsafe-3.0.3-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f190daf01f13c72eac4efd5c430a8de82489d9cff23c364c3ea822545032993e", size = 23261, upload-time = "2025-09-27T18:37:22.167Z" }, + { url = "https://files.pythonhosted.org/packages/5f/57/1b0b3f100259dc9fffe780cfb60d4be71375510e435efec3d116b6436d43/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e56b7d45a839a697b5eb268c82a71bd8c7f6c94d6fd50c3d577fa39a9f1409f5", size = 24835, upload-time = "2025-09-27T18:37:23.296Z" }, + { url = "https://files.pythonhosted.org/packages/26/6a/4bf6d0c97c4920f1597cc14dd720705eca0bf7c787aebc6bb4d1bead5388/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:f3e98bb3798ead92273dc0e5fd0f31ade220f59a266ffd8a4f6065e0a3ce0523", size = 22733, upload-time = "2025-09-27T18:37:24.237Z" }, + { url = "https://files.pythonhosted.org/packages/14/c7/ca723101509b518797fedc2fdf79ba57f886b4aca8a7d31857ba3ee8281f/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5678211cb9333a6468fb8d8be0305520aa073f50d17f089b5b4b477ea6e67fdc", size = 23672, upload-time = "2025-09-27T18:37:25.271Z" }, + { url = "https://files.pythonhosted.org/packages/fb/df/5bd7a48c256faecd1d36edc13133e51397e41b73bb77e1a69deab746ebac/markupsafe-3.0.3-cp314-cp314t-win32.whl", hash = "sha256:915c04ba3851909ce68ccc2b8e2cd691618c4dc4c4232fb7982bca3f41fd8c3d", size = 14819, upload-time = "2025-09-27T18:37:26.285Z" }, + { url = "https://files.pythonhosted.org/packages/1a/8a/0402ba61a2f16038b48b39bccca271134be00c5c9f0f623208399333c448/markupsafe-3.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4faffd047e07c38848ce017e8725090413cd80cbc23d86e55c587bf979e579c9", size = 15426, upload-time = "2025-09-27T18:37:27.316Z" }, + { url = "https://files.pythonhosted.org/packages/70/bc/6f1c2f612465f5fa89b95bead1f44dcb607670fd42891d8fdcd5d039f4f4/markupsafe-3.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:32001d6a8fc98c8cb5c947787c5d08b0a50663d139f1305bac5885d98d9b40fa", size = 14146, upload-time = "2025-09-27T18:37:28.327Z" }, +] + +[[package]] +name = "matplotlib" +version = "3.11.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "contourpy" }, + { name = "cycler" }, + { name = "fonttools" }, + { name = "kiwisolver" }, + { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12'" }, + { name = "numpy", version = "2.5.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" }, + { name = "packaging" }, + { name = "pillow" }, + { name = "pyparsing" }, + { name = "python-dateutil" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/49/64/f9a391af28f518b11ad45a8a712353c94a0aefce09d3703200e5c54b610a/matplotlib-3.11.1.tar.gz", hash = "sha256:69647db5746941c793d6e445a4cd349323ffb87d9cc958c2ad84a659b4832d30", size = 32612045, upload-time = "2026-07-18T03:39:46.63Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6e/d0/791aa183dd88491555cf7d4be0b52b0bcf6c3c2a2c22c815a2e819bf53e2/matplotlib-3.11.1-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:b7cf158e7add54a8d51ac9b5a84abd6d4e13ed4951b4f25f1c5139f41c2addb2", size = 9440302, upload-time = "2026-07-18T03:38:03.844Z" }, + { url = "https://files.pythonhosted.org/packages/35/74/82bbdf683a301f4478384c8aaba6903631a2ca18294b2d7655c9a542bffb/matplotlib-3.11.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d2ace7273b9a5061a3b420918a16fae1f2dc5dfee1abcc13aba71b5d94b1820c", size = 9268549, upload-time = "2026-07-18T03:38:06.144Z" }, + { url = "https://files.pythonhosted.org/packages/f0/f0/9b4298911303f74e6d83e64a81d996c0616405ec95046fac7f17e4258b9e/matplotlib-3.11.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:aee55e9041211bf84302ab55ec3965df18dd90ae19f8b58332a7feaf208bfe83", size = 10024922, upload-time = "2026-07-18T03:38:08.236Z" }, + { url = "https://files.pythonhosted.org/packages/84/6f/0bc3c3d05b021db44c14bc379a7c0df7d57302aa15380c16fd4e63fd6a9b/matplotlib-3.11.1-cp311-cp311-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:96f4bdeea33a8d15a071dbfe6d119451b1d719c733ac666d65357082901a9099", size = 10832170, upload-time = "2026-07-18T03:38:10.276Z" }, + { url = "https://files.pythonhosted.org/packages/db/4d/e375f39acdb2af5a9342730618608e39790ec842e6f1b392863028781459/matplotlib-3.11.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:b4c78ceb2f11bcac7389d305cda17aeb1f4586a857854ab5780bd3dd8dbfc407", size = 10916701, upload-time = "2026-07-18T03:38:12.512Z" }, + { url = "https://files.pythonhosted.org/packages/bc/be/fa26ed085b41298f64a8f9b7592c671bbf1acc8b0df124c1c5de96b859f8/matplotlib-3.11.1-cp311-cp311-win_amd64.whl", hash = "sha256:7f33a781e12b1e53b278deb2f5373c2e55ec4f10727be3440c0cfb5cda9f944f", size = 9315331, upload-time = "2026-07-18T03:38:14.949Z" }, + { url = "https://files.pythonhosted.org/packages/b6/f3/eb5bdf3b6e191b200db298b08bbc1638b7f3c82cdc8680f9d88bf72559ae/matplotlib-3.11.1-cp311-cp311-win_arm64.whl", hash = "sha256:67e4c3cd578c65ebd81bdc09a1b6592ceafee6dfafe116dc85dfcb647b5bbb18", size = 9003475, upload-time = "2026-07-18T03:38:17.205Z" }, + { url = "https://files.pythonhosted.org/packages/f2/6c/7ef7ebcb2bd9739b2b66b18b076e077f44bb46fdbe28ca0506edb3c62c79/matplotlib-3.11.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:e15ef41507f3d525f46154ac9e3ae785dacde9f20e593a25de8986267892ef74", size = 9453849, upload-time = "2026-07-18T03:38:19.593Z" }, + { url = "https://files.pythonhosted.org/packages/eb/f8/6d0c312c8d9738e7d9677f09fe5c986b3239e651a7b73a2deb38b65e4a71/matplotlib-3.11.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:21a67b961a6d597bca54fae826cd20695ba4a6e4d05424a08da6e13e3176fd6b", size = 9283113, upload-time = "2026-07-18T03:38:21.95Z" }, + { url = "https://files.pythonhosted.org/packages/c9/cf/b4ad2cc81b6672ea29ea04e64e350a9f9b493b0908ccd884c67eeff8f7b2/matplotlib-3.11.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ba8f811b8ddfac493734d6af0b2dff96919d0c28ca0d641858dab4262777c6ea", size = 10035615, upload-time = "2026-07-18T03:38:24.315Z" }, + { url = "https://files.pythonhosted.org/packages/88/90/4e10e033d9b66589d8ed98b84c95cdbb57033d57c1f41339d7393dbd2f2e/matplotlib-3.11.1-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c52f7ad20ef476806ed212380b1d54d20310c8b86bdc2c9a68b51f0024a44472", size = 10842559, upload-time = "2026-07-18T03:38:26.285Z" }, + { url = "https://files.pythonhosted.org/packages/88/eb/799612d0f8cd3e816a10fec59329fca52cd2353264df80378dfc541ae855/matplotlib-3.11.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:8b14eb22961fe865efb0e4ff167e333e428908b00115a8d800ccb65ee108e481", size = 10927532, upload-time = "2026-07-18T03:38:28.532Z" }, + { url = "https://files.pythonhosted.org/packages/88/89/56649bbaa2fd12e20f3be03dbcc135b0c8676d88bac17977599e3eb442a0/matplotlib-3.11.1-cp312-cp312-win_amd64.whl", hash = "sha256:88a2a27dd9691ae448dfae4b26f59036be90c3c28757edd3553a29559d00859f", size = 9333886, upload-time = "2026-07-18T03:38:30.477Z" }, + { url = "https://files.pythonhosted.org/packages/c1/11/4d124efbbad677b7b7552f6f85a3bd432d4232f95400cea98fcd2ae36ef3/matplotlib-3.11.1-cp312-cp312-win_arm64.whl", hash = "sha256:480194afceca4df2f137c2721227d3cba67121fbf4397b69cee7f83714b0a58a", size = 9007545, upload-time = "2026-07-18T03:38:32.833Z" }, + { url = "https://files.pythonhosted.org/packages/04/6c/4798363b7fb5644e309fe1fac30216e9146c9f70859d80d588c18caf5317/matplotlib-3.11.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:6771b0cd7838c6a857a7209814158c0ad09bfef878db3033dd82d70ad101f191", size = 9454341, upload-time = "2026-07-18T03:38:35.001Z" }, + { url = "https://files.pythonhosted.org/packages/59/98/6acadbe7f98df19d274bc107ac58bb439fa75df82c33dc110d71a4a8501f/matplotlib-3.11.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2abdee5ffa2fe11b2d19f7a5c63b785fb7c28cc46c7bc1814156341d9d1a33e1", size = 9283627, upload-time = "2026-07-18T03:38:37.061Z" }, + { url = "https://files.pythonhosted.org/packages/24/ea/65cec46fe241390ccea1b1754207ee28eb71c5ab866bd5f22fe47e538fa4/matplotlib-3.11.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b0a19dcf73406d3746d25a5ed42d713604c9a3e024d129b102852b0d941cb9f3", size = 10035860, upload-time = "2026-07-18T03:38:39.663Z" }, + { url = "https://files.pythonhosted.org/packages/c7/10/63fdccccbabe002fb0960876baabc5e3f24d9c1bb4cfb25651457f74b3a0/matplotlib-3.11.1-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7389b77ed2ab0552f46d9a90b81b7b8e6dfcdc42adc36c37a0865799843e0e3e", size = 10843594, upload-time = "2026-07-18T03:38:42.144Z" }, + { url = "https://files.pythonhosted.org/packages/98/51/a1155945bff7b91381875022ac1522c5dfdac0d006be8e7df389b3134eae/matplotlib-3.11.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:c90be0b73568da4f662afac580956a76e308437e641b4a45aa08925eeb67d95f", size = 10927962, upload-time = "2026-07-18T03:38:44.302Z" }, + { url = "https://files.pythonhosted.org/packages/0d/3a/3d5e1f42dc761bf53401a62a83ff93389b37de9d2c093b2a3aa49ac34f1b/matplotlib-3.11.1-cp313-cp313-win_amd64.whl", hash = "sha256:68408341f2312836fbbdf6b3c78047f65b2d8752f5fd221c3e72d348f5b34f8b", size = 9334074, upload-time = "2026-07-18T03:38:46.616Z" }, + { url = "https://files.pythonhosted.org/packages/e2/db/3f5ea5a5b64060ef5e1ff60a19170423e41ce21b8497a6fe15a36e0b43e3/matplotlib-3.11.1-cp313-cp313-win_arm64.whl", hash = "sha256:0c1f44890d435c1b4ef52f701ad5828cb450ea97bcc83918fda6be74965d6cd2", size = 9007662, upload-time = "2026-07-18T03:38:49.112Z" }, + { url = "https://files.pythonhosted.org/packages/98/6e/c7ae5e0531425b69c0826b00ebbc264c85cab853f1cd6e096c9983c2cdc1/matplotlib-3.11.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:5e510088c27a89d53580a752f959146893563e63c330e161d159b0fee652af6f", size = 9503790, upload-time = "2026-07-18T03:38:51.527Z" }, + { url = "https://files.pythonhosted.org/packages/92/79/15be162e0a2ed546939674e2e97d0e33ec2447d86d4d4e611fa295bb178c/matplotlib-3.11.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:1524e2bdd48a93557aa47ddcfe9c225dfdd57d5a01a5c49128c20f0632980ee1", size = 9336148, upload-time = "2026-07-18T03:38:53.564Z" }, + { url = "https://files.pythonhosted.org/packages/6a/7f/36ffe144fc4aacfe0e3ed2318f72b6755d1e73b041d619b4d393e60f5a66/matplotlib-3.11.1-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:11664c551345553db92e61cae6cf1376f138f8c47cafdf13b64b18f3e3e9e464", size = 10049244, upload-time = "2026-07-18T03:38:55.911Z" }, + { url = "https://files.pythonhosted.org/packages/ab/5f/55812d68c0a840d3a463638f48c00ab1fe338518ec49a640cb6473b444af/matplotlib-3.11.1-cp313-cp313t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5e1f8922ba31959cf6a9dfb51be64b7f7bc582801a3957dc0c2f3afcd3537adf", size = 10860798, upload-time = "2026-07-18T03:38:58.282Z" }, + { url = "https://files.pythonhosted.org/packages/7a/64/cca444b4eb5e6c768c44fc5e1f0b5211f20ca2b282778051996e996a2bdf/matplotlib-3.11.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:83235693abde86e5e0129998f80ee39fc7f58e6d56a88fafb28a9278833e9d5f", size = 10943282, upload-time = "2026-07-18T03:39:00.465Z" }, + { url = "https://files.pythonhosted.org/packages/e5/0f/a49c329d394f2e9ef38506982107e8b04ecf94dd41a9d8423ff82cc737c7/matplotlib-3.11.1-cp313-cp313t-win_amd64.whl", hash = "sha256:9a076f4fc5cdc43fdf510f5981418d25c2db4973418d9f22d8bb3dc8045ada78", size = 9383532, upload-time = "2026-07-18T03:39:02.468Z" }, + { url = "https://files.pythonhosted.org/packages/e4/50/103e86afb806d8f64d04ede14e4cfc09dbfc25f512421ff85fdd6ebd59cf/matplotlib-3.11.1-cp313-cp313t-win_arm64.whl", hash = "sha256:216fbb93a74add02ddb4cb38ef5348f59ac00b3e84567eaf16598772d40e150a", size = 9059665, upload-time = "2026-07-18T03:39:04.607Z" }, + { url = "https://files.pythonhosted.org/packages/35/04/3079499fa8cb661ea66d13d6439d5a3ae6710a7afd5c7f72e08914f275f8/matplotlib-3.11.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:30c492d4ba9448595b6fd8708c6725963f8148e25c0d8842948da5b05f0ee8d3", size = 9456022, upload-time = "2026-07-18T03:39:07.041Z" }, + { url = "https://files.pythonhosted.org/packages/53/a2/69acfe84ec1f32930e801a5782a07fc5c79c8c6599a507b806d859d5da8e/matplotlib-3.11.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:ac104be2768ffdd8655db9e71b768cbb45f2b9aa7b450cf1595e8f65d3822319", size = 9285475, upload-time = "2026-07-18T03:39:09.562Z" }, + { url = "https://files.pythonhosted.org/packages/d3/b3/31b15a2ca56d4ddd6aaa1c884c2f51cf9a61cfaf5ca6f6fbd6343d38e6df/matplotlib-3.11.1-cp314-cp314-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6be943cb68bc6660ead58c55b3aa6366cba2ef7feb06460fbcce32360376f19f", size = 10847102, upload-time = "2026-07-18T03:39:11.532Z" }, + { url = "https://files.pythonhosted.org/packages/64/0d/a17e966e620545c1548125af0b29ac812dd17b197a18a7462ac12fa859ee/matplotlib-3.11.1-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5af0dcda57d471440a7b5b623e70e0a61003518443d9098f211a96ecfbbc25be", size = 11131087, upload-time = "2026-07-18T03:39:13.764Z" }, + { url = "https://files.pythonhosted.org/packages/97/c5/5e100efdd67abb7de20befaa333612ef9bfc63417fb71398f904f25d083c/matplotlib-3.11.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:3d3fd84082b1afbd9398466c81309e20045be20d48fe0fb18c43504d164cbbb2", size = 10929036, upload-time = "2026-07-18T03:39:16.888Z" }, + { url = "https://files.pythonhosted.org/packages/ce/04/d719a0a36930ecc8dfc801ff340f9dcfc4223f8ca5d39d06b4020032fff8/matplotlib-3.11.1-cp314-cp314-win_amd64.whl", hash = "sha256:9601a1e90be21e4884c53b4f3dc3ee0544654946f9975258d691f1c2e2f119c6", size = 9489571, upload-time = "2026-07-18T03:39:19.449Z" }, + { url = "https://files.pythonhosted.org/packages/48/65/facabdc2f1f6caba7e856db64dfedddca25f7608df07d96a1c8fd114fd3b/matplotlib-3.11.1-cp314-cp314-win_arm64.whl", hash = "sha256:ae30c6109848ac0f9fa36c5d6270938487614c47ba31860bd5361266dabc5685", size = 9164486, upload-time = "2026-07-18T03:39:21.424Z" }, + { url = "https://files.pythonhosted.org/packages/88/dd/18da6cd01cf96354534f98c468a25380c68ce582a2c9dd0cae12b04af4f2/matplotlib-3.11.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:dadfe80797174e2984aae3be0b77594a3c72d2c0a40fbd4a0de48d2728caf3ae", size = 9504876, upload-time = "2026-07-18T03:39:23.633Z" }, + { url = "https://files.pythonhosted.org/packages/79/b0/f0b63555a18b79d038c81fd6126f35fc4dfce0eaff48d96103348c7cf935/matplotlib-3.11.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:89b193b255f4f6f7948dbcee3691f4f341ab05d9a8874a67b45ddb4182922eda", size = 9336120, upload-time = "2026-07-18T03:39:25.797Z" }, + { url = "https://files.pythonhosted.org/packages/c6/dd/f210ec7c4a6f198d5567237048a93d0811fb5a1f1691f13320e592f95b41/matplotlib-3.11.1-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:191163532cdefcb1571ca38a6d7e6474baccde64495783e6ba47aa07ec4b9bbb", size = 10858033, upload-time = "2026-07-18T03:39:27.999Z" }, + { url = "https://files.pythonhosted.org/packages/ec/d2/d6d5324507c5fbb316db48e258c09c2807f3de03d9af47017e120070926f/matplotlib-3.11.1-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9fdf1c818ab05d0e74002091ddaf414478a3a449ec9d51c8976d45be7e3a01e2", size = 11141827, upload-time = "2026-07-18T03:39:30.092Z" }, + { url = "https://files.pythonhosted.org/packages/0f/68/3c22e9320bdce2c4d2f1320643ef706db7a24cb7420eea28b97a2d67f5a8/matplotlib-3.11.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:b937b9dba5f5f6c1e31c47abe2186c865c0914fd18f2ce0dfc39c9adcef5951d", size = 10943061, upload-time = "2026-07-18T03:39:32.356Z" }, + { url = "https://files.pythonhosted.org/packages/f6/4a/907ed190ee81a9df581e0ed5456134fc0f7cb55ffcfda2f9e54ca900761c/matplotlib-3.11.1-cp314-cp314t-win_amd64.whl", hash = "sha256:f2912f647f3fbe1ccf085f91e213936f9101bead81a5e670565b1f1b3712f4fb", size = 9540074, upload-time = "2026-07-18T03:39:34.789Z" }, + { url = "https://files.pythonhosted.org/packages/23/d4/97c19b77e0a6e3b48581185bb65088f431cd20186076cc0f650a1757ea46/matplotlib-3.11.1-cp314-cp314t-win_arm64.whl", hash = "sha256:54d47b8ae8b579633a3902ca5b4ad6c1e132a5626d64447b2e22a66394e79987", size = 9213472, upload-time = "2026-07-18T03:39:37.141Z" }, + { url = "https://files.pythonhosted.org/packages/ee/38/ceb1d637c4db6d06141f3739e93af3321e7caaabe69b57ae48ffe3ee95b1/matplotlib-3.11.1-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:427258425f9a3fc4ed79a91f9e9b9aaf5a82cb6571e85dc14063cc6fbb993741", size = 9438045, upload-time = "2026-07-18T03:39:39.491Z" }, + { url = "https://files.pythonhosted.org/packages/89/25/72ad8b58602d3a6ef1dfc4b65ecd01634ab65a2bdf494c9fe0e966dbf081/matplotlib-3.11.1-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:1ac697e591c11b6ad04679a73c2d2f9980fe9d9f0311fb414a2e329706343dfb", size = 9266127, upload-time = "2026-07-18T03:39:41.597Z" }, + { url = "https://files.pythonhosted.org/packages/8a/6d/69552382fcc8e93d1f2763ef2665980a900a48b7f3a4c57ed290726d1cbc/matplotlib-3.11.1-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:e4b9ac2f1f607ecda2af90a5232beee2af7582fce1cc30c4b6a1b012dc21ee99", size = 10019439, upload-time = "2026-07-18T03:39:43.78Z" }, +] + +[[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 = "mpmath" +version = "1.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e0/47/dd32fa426cc72114383ac549964eecb20ecfd886d1e5ccf5340b55b02f57/mpmath-1.3.0.tar.gz", hash = "sha256:7a28eb2a9774d00c7bc92411c19a89209d5da7c4c9a9e227be8330a23a25b91f", size = 508106, upload-time = "2023-03-07T16:47:11.061Z" } +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 = "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 = "nbformat" +version = "5.10.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "fastjsonschema" }, + { name = "jsonschema" }, + { name = "jupyter-core" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/6d/fd/91545e604bc3dad7dca9ed03284086039b294c6b3d75c0d2fa45f9e9caf3/nbformat-5.10.4.tar.gz", hash = "sha256:322168b14f937a5d11362988ecac2a4952d3d8e3a2cbeb2319584631226d5b3a", size = 142749, upload-time = "2024-04-04T11:20:37.371Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a9/82/0340caa499416c78e5d8f5f05947ae4bc3cba53c9f038ab6e9ed964e22f1/nbformat-5.10.4-py3-none-any.whl", hash = "sha256:3b48d6c8fbca4b299bf3982ea7db1af21580e4fec269ad087b9e81588891200b", size = 78454, upload-time = "2024-04-04T11:20:34.895Z" }, +] + +[[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" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/6a/51/63fe664f3908c97be9d2e4f1158eb633317598cfa6e1fc14af5383f17512/networkx-3.6.1.tar.gz", hash = "sha256:26b7c357accc0c8cde558ad486283728b65b6a95d85ee1cd66bafab4c8168509", size = 2517025, upload-time = "2025-12-08T17:02:39.908Z" } +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 = "numpy" +version = "2.4.6" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.12'", +] +sdist = { url = "https://files.pythonhosted.org/packages/d0/ad/fed0499ce6a338d2a03ebae59cd15093910c8875328855781952abf6c2fe/numpy-2.4.6.tar.gz", hash = "sha256:f3a3570c4a2a16746ac2c31a7c7c7b0c186b95ce902e33db6f28094ed7387dda", size = 20735807, upload-time = "2026-05-18T23:37:14.07Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b3/49/ec46835a70be8fa6446c495126ac84fdb28cb2558e1620ffb87a10c8b64c/numpy-2.4.6-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:0280e0356c0829a18d9de1cb7eee50ec22ca639878d7240307ca0943d73cd2c4", size = 16969194, upload-time = "2026-05-18T23:33:13.503Z" }, + { url = "https://files.pythonhosted.org/packages/0e/0d/f5957185c0ee2f3e12f78715aa9e3b353fd83633316c8532b38faa37e3f6/numpy-2.4.6-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:110f8b71aacb688ec69062bb7f6938a0f8acb01b7c1c4beb453c65b6d234584d", size = 14964111, upload-time = "2026-05-18T23:33:17.795Z" }, + { url = "https://files.pythonhosted.org/packages/ad/40/40a40ee0ddf7ceb782c49af278894b686e586d65d8c1889c8b5da01a3d7d/numpy-2.4.6-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:4cfe66903cc32a9921a6733d96b19bb6abf310397581bbad89c228f5abaf0ee8", size = 5469159, upload-time = "2026-05-18T23:33:20.654Z" }, + { url = "https://files.pythonhosted.org/packages/63/13/f9a8046535cb21deae82f8d03de9617e08882d274fad2539630761888228/numpy-2.4.6-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:8155154c7c691289fe18f510b5d4657c68c67989f293f0535a91360392ff6538", size = 6798936, upload-time = "2026-05-18T23:33:22.987Z" }, + { url = "https://files.pythonhosted.org/packages/33/a8/6fa8c1a345a8c85dbb21932c447bee07c30a2c2a3f31e369c0a84b300147/numpy-2.4.6-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0ab0a9c4ffb1a6d95ef519fe4247dba8eb6b18ad93999f76b7f657039acabd47", size = 15966692, upload-time = "2026-05-18T23:33:26.62Z" }, + { url = "https://files.pythonhosted.org/packages/02/03/74fe2a4cb3817d94d86402f2506554130a2f01414e299b5a843e5a8a957f/numpy-2.4.6-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:89cd468399cfd2504718f0ba50e410dca55a170b61a02ad92bb18c8a65186e93", size = 16918164, upload-time = "2026-05-18T23:33:29.955Z" }, + { url = "https://files.pythonhosted.org/packages/c5/80/3615be3313f7e7696609bc194b9f0101da809df79e859bdb84e0cd043f46/numpy-2.4.6-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:c2d37ab77531417474168eb79d6d80b14f821a966818505d03013d0833edb7a8", size = 17322877, upload-time = "2026-05-18T23:33:34.724Z" }, + { url = "https://files.pythonhosted.org/packages/ca/ac/a691e0fe2675e370d0e08ff905adc49a1c8830e8cae03efe4477e92cd55d/numpy-2.4.6-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f407cb6b8e9d6d8c626bc73c945db1706035af8fd632295547bf1c9e46d092d6", size = 18651487, upload-time = "2026-05-18T23:33:38.217Z" }, + { url = "https://files.pythonhosted.org/packages/15/a7/9bc1cd626d7bf6869bfedf27b91b6ab5dd607758bf8e959d6fa80c6a59cb/numpy-2.4.6-cp311-cp311-win32.whl", hash = "sha256:ddea102b48f9e339f3948bf22040944184627a30fdf7f858667673b9c5f033c8", size = 6233945, upload-time = "2026-05-18T23:33:41.331Z" }, + { url = "https://files.pythonhosted.org/packages/c5/31/7fc6239c12bce7e931463251cca4426c465e1876ba3cc785402ef4dd8f4e/numpy-2.4.6-cp311-cp311-win_amd64.whl", hash = "sha256:1e254a00cdf42b1e4d5b3d68d33af63268d41340d8885df2ab6470f2e1500147", size = 12608406, upload-time = "2026-05-18T23:33:44.131Z" }, + { url = "https://files.pythonhosted.org/packages/27/83/140f85a466595a16382996a1bf06b2b54bcd597488921b0c9daaeeda72af/numpy-2.4.6-cp311-cp311-win_arm64.whl", hash = "sha256:ed9749eef4cbd126da3dc1d6bcb3a57f5eb7ac6a6484146bdbf743f552dfc577", size = 10479528, upload-time = "2026-05-18T23:33:50.725Z" }, + { url = "https://files.pythonhosted.org/packages/95/2a/3d7b5ac8aac24feaf9ad7ed58f45b0bbc06d37e4338ae84c9f2298b570f9/numpy-2.4.6-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:001fbb8e08d942dd57599e781f2472269ee7f2755fae407b4f67b2f0b17da3f1", size = 16689119, upload-time = "2026-05-18T23:33:54.065Z" }, + { url = "https://files.pythonhosted.org/packages/ea/12/92c4c131527599e8288d6918e888d88726f84d805d784b771f32408aeaef/numpy-2.4.6-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ebfb099f8dcf083deef3ac1ca4c1503f387cf76296fcb3816b66f5ecb5f54fdb", size = 14699246, upload-time = "2026-05-18T23:33:57.621Z" }, + { url = "https://files.pythonhosted.org/packages/ad/fe/c0a6b7b2ca128a8fb228575147073b660656734b8ebe4d76c8fd748dcc79/numpy-2.4.6-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:3213d622a0283a39a93d188f3cf72b26862df52fbb4ca3697f51705016523d41", size = 5204410, upload-time = "2026-05-18T23:34:00.302Z" }, + { url = "https://files.pythonhosted.org/packages/f3/d4/9770d14ba719432bb90a421bfd443872ed0f70f7264b64bec12ea363d5fd/numpy-2.4.6-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:357cc07a6d7b0b182ff02249616a03742827ebb1277546b5c7cd7f7620a45698", size = 6551240, upload-time = "2026-05-18T23:34:02.852Z" }, + { url = "https://files.pythonhosted.org/packages/c9/c6/50a46a6205feba2343f1d6d17438107c5dc491ed1c736e6ea68689fd906b/numpy-2.4.6-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5f9fb9157b4ce2971008323afe46053787b526ef624fea915b261468a8421a0f", size = 15671012, upload-time = "2026-05-18T23:34:05.485Z" }, + { url = "https://files.pythonhosted.org/packages/99/60/14115e6364fa676c5397c2ad3004e527e9aa487abf5d0706ec81bbd08529/numpy-2.4.6-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:90f9849678c75fe7afa2d348ac842c168b0a4d3d61919687216dfc547976d853", size = 16645538, upload-time = "2026-05-18T23:34:09.265Z" }, + { url = "https://files.pythonhosted.org/packages/ae/c5/693cbe59e57db94d2231fa519ca3978dc9e19da5a8f088588f5c6e947ff2/numpy-2.4.6-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:c1a2af6c6ef86344a6b0db6b97834208bf598db514f2b155042439b62605601a", size = 17020706, upload-time = "2026-05-18T23:34:13.053Z" }, + { url = "https://files.pythonhosted.org/packages/ef/fc/85b7c4eff9b4966ade25c2273cf7e7012e92366c032058653934b37de044/numpy-2.4.6-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e5805d5a22fd19c8ccff10a9561f9df94436b0545619ea579db2d3c35294bce2", size = 18368541, upload-time = "2026-05-18T23:34:17.024Z" }, + { url = "https://files.pythonhosted.org/packages/f6/81/e1b27545deedce7f4a0b348618c6b62d74e36a4dc9ccd42f3eb2f85eee32/numpy-2.4.6-cp312-cp312-win32.whl", hash = "sha256:e3eeb0aabd6bd5ce64faae67e9935203a6991b4bc2a485a767fbafb2c5125f45", size = 5962825, upload-time = "2026-05-18T23:34:20.3Z" }, + { url = "https://files.pythonhosted.org/packages/ab/ca/feab00bd44aa5fe1ad2c18f08b4d3bb92e26484b0b1d1443897809ed528c/numpy-2.4.6-cp312-cp312-win_amd64.whl", hash = "sha256:d8e8286dd7cea7895157318d1b91cdacac64c479f3cbc8dce548331728484751", size = 12321687, upload-time = "2026-05-18T23:34:23.095Z" }, + { url = "https://files.pythonhosted.org/packages/63/cf/5a6d34850a39d1093558564f77ee8e8e0bee5061151b8f05a55711001ec7/numpy-2.4.6-cp312-cp312-win_arm64.whl", hash = "sha256:4081eb135ac24158bd51cdfbef16f1c64df7063b1143f24731387137c092bec8", size = 10221482, upload-time = "2026-05-18T23:34:25.876Z" }, + { url = "https://files.pythonhosted.org/packages/fb/82/bdab26d7438c6791ca31b7c024ca37c1eab8b726ba236129005cd4a06e45/numpy-2.4.6-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:511dbaf848decaaaf4b4ca48032619fb3138710c4bf7da7617765edad1ef96b0", size = 16684648, upload-time = "2026-05-18T23:34:29.41Z" }, + { url = "https://files.pythonhosted.org/packages/1b/30/a80189bcc7f5e4258b3fbc3968d909d1756f54d023299ecc39ad6fdb9ef8/numpy-2.4.6-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:bf162abab1c1a736333192707cef898e735a5ca00f38f27eeedf44b39d9e85eb", size = 14693902, upload-time = "2026-05-18T23:34:33.013Z" }, + { url = "https://files.pythonhosted.org/packages/97/12/70b5d0d7c15e1ebb8a6a84a8caa1d19e181d84fb58bb6d70aca29099dec1/numpy-2.4.6-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:043191bfa8eab18c776647b62723ac9dddece59743b13f49b2016094129c2b3f", size = 5198992, upload-time = "2026-05-18T23:34:36.132Z" }, + { url = "https://files.pythonhosted.org/packages/ba/8c/ebd2a8f8a83541f8d38cc5667e8c2b69cecfd30da6e45693e8158857d44b/numpy-2.4.6-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:6180d8b35af935aed8ece3a85e0a43f87393ae0ac87c8d2c8bd2c993f7270ef3", size = 6546944, upload-time = "2026-05-18T23:34:38.484Z" }, + { url = "https://files.pythonhosted.org/packages/bb/c5/7b863a97a91671a0338f4253bd3b5a3d3852f0692dae91711c9f4a10e787/numpy-2.4.6-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:72fbe16c6fac95aedf5937fa873445cec2110be35d8a4e9433d7501fd98dae6b", size = 15669392, upload-time = "2026-05-18T23:34:41.257Z" }, + { url = "https://files.pythonhosted.org/packages/a5/9d/3584b9984ca4c047aea75214ce1a4c4c73d849bd71b604264b7f5653f8a8/numpy-2.4.6-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a7830bab239b79cda9c08c2da014761cafb48da6150e1da17ac06283f43b6089", size = 16633220, upload-time = "2026-05-18T23:34:45.075Z" }, + { url = "https://files.pythonhosted.org/packages/05/ae/7c67fba23bd98caec7c99261f3a16072ade14813486b0282cb29846de832/numpy-2.4.6-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ef4aea96ce4d3b074422cb4f2f64e216bf9e213004bb58ecfdf50ea02ea8eb9a", size = 17020800, upload-time = "2026-05-18T23:34:49.065Z" }, + { url = "https://files.pythonhosted.org/packages/d9/5d/3b6725cb31d983c5e66916f5d36f6d7e5521129e4c4404d64f918292a5b6/numpy-2.4.6-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:dfa20cc6ca228e6b155b11da03825975ce66aea520985dbbddf0f2a5a495c605", size = 18357600, upload-time = "2026-05-18T23:34:52.709Z" }, + { url = "https://files.pythonhosted.org/packages/f7/da/2ccc6c2fe8898dee01d90c75c5f5f914a23daf99e3e0f59516a08760c8b5/numpy-2.4.6-cp313-cp313-win32.whl", hash = "sha256:56b39e5e0622a09a25bf5baf62f4bcf0cb8a41ae6e2819cf49bbc5a74c083f91", size = 5961134, upload-time = "2026-05-18T23:34:55.618Z" }, + { url = "https://files.pythonhosted.org/packages/b5/cd/9cc4dc876fb065d5c220aae4d5e14826b2715331bb7618ce1fb07a679d99/numpy-2.4.6-cp313-cp313-win_amd64.whl", hash = "sha256:c4fc99836233ea196540b17ab0983aff60ed07941751930f5f4d05bc3b3b7359", size = 12318598, upload-time = "2026-05-18T23:34:58.928Z" }, + { url = "https://files.pythonhosted.org/packages/39/1e/c0bcba1f8694116485fe28fd1be698c278fcda4141c5b0e53a2aed8b12a8/numpy-2.4.6-cp313-cp313-win_arm64.whl", hash = "sha256:a7c711e21628b52034bb5ab8d1bce291f752fcc5e92accc615778acee1ff4778", size = 10222272, upload-time = "2026-05-18T23:35:02.167Z" }, + { url = "https://files.pythonhosted.org/packages/63/6d/cc5619247c8f4204e507f5883528372e4ac4bb189e579fb859a12e480b1f/numpy-2.4.6-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:112b06a867b235ef466ed3508ddf0238050df9c727cafb5301ac385b899189a1", size = 14821197, upload-time = "2026-05-18T23:35:05.468Z" }, + { url = "https://files.pythonhosted.org/packages/00/58/f1c39161c87d9e9bed660f1ed4bafc0e403d5ec9650b6dd77aead07d489b/numpy-2.4.6-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:eaf7fa2de5c0be8ae6ff8e9bea2ccd725e980541244521d8d4b5f3354a27babe", size = 5326287, upload-time = "2026-05-18T23:35:08.693Z" }, + { url = "https://files.pythonhosted.org/packages/af/57/3917ab0fd97f271a8694513581b8a36c655f111c446852c302f04ccdb6fc/numpy-2.4.6-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:7265a2f3d436e54ef9f2b52b5c937e6be778781bd97a590319d7348f1c1ca997", size = 6646763, upload-time = "2026-05-18T23:35:11.459Z" }, + { url = "https://files.pythonhosted.org/packages/eb/0f/037e64c494b67581ae18193d770adef354c41f3f2c8ebf865602d949bf8f/numpy-2.4.6-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f74a575920ab21fe304421a3fc28793d82e299cae9eccb37084e9fc7f3617c20", size = 15728070, upload-time = "2026-05-18T23:35:14.79Z" }, + { url = "https://files.pythonhosted.org/packages/21/a6/5d2bae9c9542eb4df16dc9c46dc79c186e9bad53805dfa5399a6023c6db0/numpy-2.4.6-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ede83e07a75dd06bc501566c1eca2afc0d61677c1472ac9ad93fdee6e638a48d", size = 16681752, upload-time = "2026-05-18T23:35:18.836Z" }, + { url = "https://files.pythonhosted.org/packages/92/14/23d1dfb410ae362cd59ce53e936b1513d545eb40db3949ced632e19a459e/numpy-2.4.6-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:68bb27509ac1b9a3443094260f6326150663b06abe40b73a2f81160623da5b67", size = 17086024, upload-time = "2026-05-18T23:35:22.52Z" }, + { url = "https://files.pythonhosted.org/packages/4b/6e/23595a2c642cdf3bc567877064bdd7f91c8b0038a4453cf2daf7248eafe9/numpy-2.4.6-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:a0df0043bdb289bde1f62da130d20df23d58b45429f752bc7a8fc5325a225ecd", size = 18403398, upload-time = "2026-05-18T23:35:26.398Z" }, + { url = "https://files.pythonhosted.org/packages/8a/90/0ac3bc947217e66dec77e7cbc6a1979d1af70b6461b82f620d3bccd5e4c8/numpy-2.4.6-cp313-cp313t-win32.whl", hash = "sha256:29a287e0cf63ff528da061de6b9f64a4618da591ca1046aafc54062e40ca7eab", size = 6084971, upload-time = "2026-05-18T23:35:29.387Z" }, + { url = "https://files.pythonhosted.org/packages/77/71/5673e351671a1d2bd6063b91b44f70c0affea7d1516fa7a6572941ba4aa1/numpy-2.4.6-cp313-cp313t-win_amd64.whl", hash = "sha256:25c692919ac5a01f170a3bfcd62d745b24fd095c353d50812637d6fcab442e75", size = 12458532, upload-time = "2026-05-18T23:35:32.175Z" }, + { url = "https://files.pythonhosted.org/packages/3f/88/19d3503c5046e688f049274b27a3ef3d771152fa80d3ba3d01a3dff61abe/numpy-2.4.6-cp313-cp313t-win_arm64.whl", hash = "sha256:1e978ec1e8bd0e0e4de6bb75de9d30cbb74db6b6a2bb727618613703ca0167dd", size = 10291881, upload-time = "2026-05-18T23:35:35.465Z" }, + { url = "https://files.pythonhosted.org/packages/f8/91/3ab2044d05fd16d343c5ac2e69b127f1b2854040dd20b193257c78028bd3/numpy-2.4.6-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:06ca2f61ec4385a07a6977c55ba998a4466c123642b4a32694d3128fce18c079", size = 16683458, upload-time = "2026-05-18T23:35:38.353Z" }, + { url = "https://files.pythonhosted.org/packages/8e/62/764ce66fa4147ae6d73071a3abf804ffe606f174618697c571acdf26a7c9/numpy-2.4.6-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:38efbc8de75c7a0fc1ac190162d892787f3f47b57cc291231aafee36b80982b7", size = 14704559, upload-time = "2026-05-18T23:35:42.14Z" }, + { url = "https://files.pythonhosted.org/packages/60/61/23f27c172f022e04025b7dc2367f4d63c1a398120607ec896228649a6f48/numpy-2.4.6-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:d581b735e177fdcdce6fed8e7e8880a3fb6ee4e3653a3ac6af01c6f4c03effc5", size = 5209716, upload-time = "2026-05-18T23:35:45.377Z" }, + { url = "https://files.pythonhosted.org/packages/03/71/21cf70dc6ea3e3acb95fc53a265b2fc248b981f0194ceb5b475271b8809d/numpy-2.4.6-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:0a041d3d761dc3c35cc56ce0351506a02bcbc25f7b169f652435141a17db9096", size = 6543947, upload-time = "2026-05-18T23:35:47.926Z" }, + { url = "https://files.pythonhosted.org/packages/d5/91/64288395ee1799bd2e0b04a305dce9666da90c961e1f3fe982a05ee1c036/numpy-2.4.6-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:40fdc1ae7125e518ea98e53e69a4ebc27e1fd50510c47b7ea130cf21e5e1d42b", size = 15685197, upload-time = "2026-05-18T23:35:50.863Z" }, + { url = "https://files.pythonhosted.org/packages/f3/eb/ebffaa97dc55502df69584a8f0dcf07f69a3e0b3e2323670a2722db9aa39/numpy-2.4.6-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a2c306dea656c12c68f51f4cea133cbe78ca7435eb28c735eac1d3ebe73be6e8", size = 16638245, upload-time = "2026-05-18T23:35:54.752Z" }, + { url = "https://files.pythonhosted.org/packages/b8/0b/54f9da33128d7e350fab89c7455902eeae70349ee52bddb448dc4a576f45/numpy-2.4.6-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:33111801a01c12a8a1e3721f0a9232f8cfc8ae2c6b7098167e6f623c6073f402", size = 17036587, upload-time = "2026-05-18T23:35:58.355Z" }, + { url = "https://files.pythonhosted.org/packages/b6/f0/fdebc1052db1cc37c64beb22072d67cd6d1c71adca1299f53dec2b5e20d3/numpy-2.4.6-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:ae506e6902902557576a26ff33eda8695e7ecb3cb36c3b573a0765dee114ebdb", size = 18363226, upload-time = "2026-05-18T23:36:02.845Z" }, + { url = "https://files.pythonhosted.org/packages/aa/b4/298628d98c72b57e57f7165ae6a481a1deaf6f3c28262a6e4c739c275930/numpy-2.4.6-cp314-cp314-win32.whl", hash = "sha256:aaf159caa35993cb1f56fb9b8e4610d35758e7ca005412eb1daa856a78c9c4b1", size = 6010196, upload-time = "2026-05-18T23:36:05.92Z" }, + { url = "https://files.pythonhosted.org/packages/df/ac/46de6dda46478f7942f839e094970be2d4a861e005c4b3bf07c92e291a09/numpy-2.4.6-cp314-cp314-win_amd64.whl", hash = "sha256:b507f5c4c1d508876d1819b6bf9a49d365b96320b5d4993426b33a23ca4b8261", size = 12450334, upload-time = "2026-05-18T23:36:09.107Z" }, + { url = "https://files.pythonhosted.org/packages/78/92/b8b798ac784102c0da830d2257d59358e3d3d90d1e2b3f2575dad976c5cf/numpy-2.4.6-cp314-cp314-win_arm64.whl", hash = "sha256:6f41ae150c4e32db4f3310cdaf64b1593a03dbabe29eec77fc9b50fe64061df6", size = 10495678, upload-time = "2026-05-18T23:36:12.766Z" }, + { url = "https://files.pythonhosted.org/packages/30/34/ec28d1aa8115971537c01469ab2011ee96827930f0a124de1000cc2a7ed7/numpy-2.4.6-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ece3d2cfe132e7d51f44a832b303895e6f2d499c5e74dfbdb06ee246147a304a", size = 14823672, upload-time = "2026-05-18T23:36:16.473Z" }, + { url = "https://files.pythonhosted.org/packages/16/bd/f6d1fede4e54e8042a7ff97bb495510f3c220f94bcd9e8b228e87c92cc0d/numpy-2.4.6-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:e3e5193ef5a3dc73bceee50f7fdc2c90dbb76c42df8d8fae3d1067a583df579e", size = 5328731, upload-time = "2026-05-18T23:36:19.767Z" }, + { url = "https://files.pythonhosted.org/packages/f4/f0/e105b9e2fd728a9910103884decd6951d9dd73896b914a98d9a231de02ee/numpy-2.4.6-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:17f9ade344e7d9b464a084d69bcf18fc691cb1db67c62ed80820bf4926d78f0e", size = 6649805, upload-time = "2026-05-18T23:36:22.266Z" }, + { url = "https://files.pythonhosted.org/packages/82/dd/1206a7ca6ab15e3f02069707ca96222e202af681bb73756da7527f3cb837/numpy-2.4.6-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9cd5ffd25db4e7ba6a375693b3fc0fc1791ec636c17db3720da19bde7180ec43", size = 15730496, upload-time = "2026-05-18T23:36:25.713Z" }, + { url = "https://files.pythonhosted.org/packages/51/e7/38d3ea825dcab85a591734decb2f6c67caa7c8367d374df1a1c3842f9b07/numpy-2.4.6-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7d92c3819208a60205a12a245c91ad70cb0a85336659b19b834205573ac8456e", size = 16679616, upload-time = "2026-05-18T23:36:29.652Z" }, + { url = "https://files.pythonhosted.org/packages/93/b7/caabfdf53edf663e0b4eb74d7d405d83baef09eb5e83bcd32d601d72b93e/numpy-2.4.6-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e85b752a1e912b70eaad4fafbd4d1238007ab221de2009b9a2f5ae7461239895", size = 17085145, upload-time = "2026-05-18T23:36:33.449Z" }, + { url = "https://files.pythonhosted.org/packages/f9/45/68d7c33a6bcf3e5aa3bdbd57a367e6f615286dfd6482f97e8ffeb734306e/numpy-2.4.6-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:29cb7f67d10b479ff07c17d33e39f78c07f71c40ef30d63c153d340e96cd3fb4", size = 18403813, upload-time = "2026-05-18T23:36:37.369Z" }, + { url = "https://files.pythonhosted.org/packages/9c/50/0753655aa844c99cd9e018aacf76f130f1bd81d881bb74bc0aef5d73a8ba/numpy-2.4.6-cp314-cp314t-win32.whl", hash = "sha256:260a5d70215b61ab4fadf5c7baacd64821842975eea312125ed3c39a6391b063", size = 6156982, upload-time = "2026-05-18T23:36:40.817Z" }, + { url = "https://files.pythonhosted.org/packages/b2/d4/7c67becf668f973cb490cec3e98dfd799d866f9c989a54d355672cfa0db6/numpy-2.4.6-cp314-cp314t-win_amd64.whl", hash = "sha256:81a1cca95ed5bb92aa8b10dd2cdc9a0d3853a50fad926c28b5d7e8ea54389627", size = 12638908, upload-time = "2026-05-18T23:36:43.996Z" }, + { url = "https://files.pythonhosted.org/packages/43/bb/e1c71a4295b1b1d1393d50dbb4f2a36283c6859d9d3892e84f00ec5a91d5/numpy-2.4.6-cp314-cp314t-win_arm64.whl", hash = "sha256:0c9136e14ed34a9e343a31c533d78a9813a69a3148332bce5e9821cb2f996e66", size = 10565867, upload-time = "2026-05-18T23:36:47.114Z" }, + { url = "https://files.pythonhosted.org/packages/de/12/b422cc84439adc0d00de605bf4a308890ae5c26f2c71fbd73e5d08fbb0dd/numpy-2.4.6-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:55cced7c52e981362f708ad635198e97a752dfba412cc03c23bbf3bd8d5cd662", size = 16847511, upload-time = "2026-05-18T23:36:50.673Z" }, + { url = "https://files.pythonhosted.org/packages/44/53/f481bef68011740f8849418d82db07230e825013f31f4eef5ba5b805316a/numpy-2.4.6-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:d6da64deb6b8ed903e7560180a92f2d804ee1ba5eeb849ac2748b8c1aba1f6d7", size = 14889064, upload-time = "2026-05-18T23:36:53.879Z" }, + { url = "https://files.pythonhosted.org/packages/7f/57/42ed575c10ced8af951d426bc4e1f8aff16fd851db33f067036215a7f860/numpy-2.4.6-pp311-pypy311_pp73-macosx_14_0_arm64.whl", hash = "sha256:68a5124b13fa6cc2086764a20005d30bc0548146f7f5322f02fce212ca14317f", size = 5394157, upload-time = "2026-05-18T23:36:57.194Z" }, + { url = "https://files.pythonhosted.org/packages/6a/ef/f66cc724fcc36c1e364c67f51ae9146090b8b584f27d58b97fdae3edd737/numpy-2.4.6-pp311-pypy311_pp73-macosx_14_0_x86_64.whl", hash = "sha256:948424b06129ce883307e8cff868c31396d8dc7630a59c61d70d98dbe70f222c", size = 6708728, upload-time = "2026-05-18T23:36:59.575Z" }, + { url = "https://files.pythonhosted.org/packages/1a/9c/c531f2293b91265d8b48e9b329f54fdd7ffae73cb4134ea10cca4237e9cc/numpy-2.4.6-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5dbbdb29840ca3d91ee0fece42fc29278886d908280bfec0a5846c6f901a3eb0", size = 15798374, upload-time = "2026-05-18T23:37:02.674Z" }, + { url = "https://files.pythonhosted.org/packages/1a/b0/413077f6b1153ed3cba361401c6783bbad6114804a000cc22eb71c13e190/numpy-2.4.6-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8ad03c0965fb3c692200e74d458ca28c1dbb4ce96f9a479a8aa041ad5fabca02", size = 16747286, upload-time = "2026-05-18T23:37:06.327Z" }, + { url = "https://files.pythonhosted.org/packages/15/ce/e5ec180bc41812edcd8daeb8639d205622c0e8c02259d8ab25a0201b3c2a/numpy-2.4.6-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:2803abfebfc990042cd494d8ce2d5f82e9d847af6d35ec486923aa19dbad5e73", size = 12504263, upload-time = "2026-05-18T23:37:09.715Z" }, +] + +[[package]] +name = "numpy" +version = "2.5.1" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", +] +sdist = { url = "https://files.pythonhosted.org/packages/22/fd/89965aa4ac08c74998539fcbf24fa3540f3e15237fbeb6bcf9c908f4aade/numpy-2.5.1.tar.gz", hash = "sha256:a48a113e6afea91f5608793bafa7ef2ad481fefbda87ec5069f483de61cb9fa3", size = 20755553, upload-time = "2026-07-04T17:08:00.933Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/62/7b/14687aa674250e5e546f616f486b0d56d3631cd5b2415739141ce40bdcea/numpy-2.5.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:2c889b56fe48b1018f764b0eec8df59ab654e9148aa91faa12596043500de277", size = 16801574, upload-time = "2026-07-04T17:06:12.423Z" }, + { url = "https://files.pythonhosted.org/packages/e1/19/cc5bb2a3f2913d27d6dbb2c78d25921fabaedc6741d4a5a615a11f3c5bf3/numpy-2.5.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ab451b59c5643c570974c43aef780703ef1d3b4965d2be07afd530615a9358d1", size = 11772250, upload-time = "2026-07-04T17:06:15.726Z" }, + { url = "https://files.pythonhosted.org/packages/42/77/fdf34a71dd30f54979b18603bee915e0aaf825b07afe79acd60b04b691e2/numpy-2.5.1-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:78798bd5b9ad744056af8efa90e3b9ddaa53272a0848a483084a1cc0a13b2dc0", size = 5331516, upload-time = "2026-07-04T17:06:17.913Z" }, + { url = "https://files.pythonhosted.org/packages/ce/e2/eb7efa015b4cce41e2517bf182a7fce0d7d5b9d9ed76a29bfa0f4fe4505c/numpy-2.5.1-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:2ae0ca40bcb22d6ba59c1dfd5446f49940b0f2d821fde133f10dda11f816b84e", size = 6664863, upload-time = "2026-07-04T17:06:20.02Z" }, + { url = "https://files.pythonhosted.org/packages/a9/4b/a2b32dd94ee9ffbeecb28152240042a3949db33b1c834d44090b80e1b3b8/numpy-2.5.1-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:61ac47e772e6b8ea489e1d2f441a34c5c3ac17327e7ce294cbdf535795ad4e75", size = 15167977, upload-time = "2026-07-04T17:06:21.621Z" }, + { url = "https://files.pythonhosted.org/packages/b8/a9/6e73d68500f80773f65f0654ea932019d6694329a0eb0ed0533de38df376/numpy-2.5.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:59fda5e192b570217ec2580c96f00e9a7e12ef6866a900eb089b62c1a32545ca", size = 16672469, upload-time = "2026-07-04T17:06:24.064Z" }, + { url = "https://files.pythonhosted.org/packages/24/7d/ad3e59015135f5261c95fd4cafeff159c955febd83a99a1d9250c4233815/numpy-2.5.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:f7119ebff1a9829e9f431a4f9d28e703023bb6b9fe7c8f724467dbfc27c94ab3", size = 16527531, upload-time = "2026-07-04T17:06:26.69Z" }, + { url = "https://files.pythonhosted.org/packages/83/d0/a39b2fbcde9cb17a1dac678f254b33a6336298af9df338824c685425d5e8/numpy-2.5.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e824c2acf8862052246be5a44c15da1777940c60d010dd2aab897824d9c430f9", size = 18431940, upload-time = "2026-07-04T17:06:29.521Z" }, + { url = "https://files.pythonhosted.org/packages/04/12/cff070947791c1ed425ff76413189adbdc2fbe215eba7ce7fa454a03c7f8/numpy-2.5.1-cp312-cp312-win32.whl", hash = "sha256:08d60c810432eb83360958dea0999ac4cfb94531ea8efcbf0b7f277c2068aeb2", size = 6066764, upload-time = "2026-07-04T17:06:32.571Z" }, + { url = "https://files.pythonhosted.org/packages/65/66/53f31807a48a750f9d748da273bc3fcedd12b27ff1f3e373bfec55ef2dc0/numpy-2.5.1-cp312-cp312-win_amd64.whl", hash = "sha256:f7d60026c0bdb1380e83bfa7a0419c4577ee4b9a08880afcb6dadeb74c649fa2", size = 12430966, upload-time = "2026-07-04T17:06:34.926Z" }, + { url = "https://files.pythonhosted.org/packages/2b/2a/d1a88066b1c14186f5d3c0d18c94f17b064511982bab0578d49ee9d43c29/numpy-2.5.1-cp312-cp312-win_arm64.whl", hash = "sha256:17a25e09640602e10bc8de0e6fa2b3fd68eedd84ba6d7842dc8f32f9ab87bd0b", size = 10350488, upload-time = "2026-07-04T17:06:37.785Z" }, + { url = "https://files.pythonhosted.org/packages/eb/07/ec2a3f0c91761581d4b7104a740791800025983f9a4dc4e73f91a99aeac4/numpy-2.5.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:0bfebd8695f9863592fe744be833a258120b14a9f39da255e8aa8fade2c0ddd1", size = 16796419, upload-time = "2026-07-04T17:06:40.37Z" }, + { url = "https://files.pythonhosted.org/packages/ab/ab/ddb499fc4f8780354395face5b65c7fd107bcd6e1d667a5f07d046956f6f/numpy-2.5.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:30b44a6b53a7ae63c54c089a8726e5563ed302716c5b7ccc85afade40b0e7ff6", size = 11765832, upload-time = "2026-07-04T17:06:42.768Z" }, + { url = "https://files.pythonhosted.org/packages/88/b3/3c28c558a09fc72100c646dac6d2fce8e834c471b0edca01a29996706117/numpy-2.5.1-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:6165343f81b56ef8f514f396989e529b61d9dc709b99421b07e9f3e698e2287d", size = 5325143, upload-time = "2026-07-04T17:06:45.466Z" }, + { url = "https://files.pythonhosted.org/packages/5e/0e/ce19b985bb15c596f4f05954e76cccc77c845083b3b8f938a6c68e523128/numpy-2.5.1-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:4939237038ada79308dda3204ac6462df056b5672b2e25db1149cf873668b3e1", size = 6659749, upload-time = "2026-07-04T17:06:47.288Z" }, + { url = "https://files.pythonhosted.org/packages/2e/20/1ee6614d64332a1bba6411f38e68cb79eec1b2459e20a623777c5c5492a2/numpy-2.5.1-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1c6759f538fb912fc46de0a6b1758ccf7b57bc7c7ebebc23974fdac3de8db0cd", size = 15164716, upload-time = "2026-07-04T17:06:49.494Z" }, + { url = "https://files.pythonhosted.org/packages/ed/a7/2bcd3fdbb87804755c35b729bf8709d62025c5f4cfd7d5b2415997097515/numpy-2.5.1-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9726558e8db4a5bf7929a70ae50f63abda4daf0efe810e3bfbab95976f75fc1a", size = 16661440, upload-time = "2026-07-04T17:06:52.061Z" }, + { url = "https://files.pythonhosted.org/packages/fc/d7/a41e3310c886fe457d36e670bbf24fae411aca8a7b6ad92a32afd924077c/numpy-2.5.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:3935f3b419b244a02732676fa5317a9193cc596a4c0646db07e5b421229ac9f7", size = 16526305, upload-time = "2026-07-04T17:06:54.605Z" }, + { url = "https://files.pythonhosted.org/packages/53/75/4333a9a707c1edd3a4e1a0c58eca52c0f31e55089fa80db02b5565b24df7/numpy-2.5.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:dc932a65ded7ce9013d120845a2514dcccb1a67bfc8deb8d37633762951904a6", size = 18423008, upload-time = "2026-07-04T17:06:57.54Z" }, + { url = "https://files.pythonhosted.org/packages/ee/90/e314a32b1c11a2ffe818ddad3a57b50b4b6e1b6c487192eb50cdef0415d0/numpy-2.5.1-cp313-cp313-win32.whl", hash = "sha256:4b4ff1608417eb7a59da7b967bbb798cacfe071d2caf526a24281cd562072ed9", size = 6063885, upload-time = "2026-07-04T17:07:00.14Z" }, + { url = "https://files.pythonhosted.org/packages/10/70/800b3fca480af32df9e8ea9f3d4a0c8feb4b32d7f195d174eabbda4829ad/numpy-2.5.1-cp313-cp313-win_amd64.whl", hash = "sha256:6c3fe51bc6a16453d452997053454f309e8e0ed7b42d6b361ce4ac8c32913d74", size = 12425674, upload-time = "2026-07-04T17:07:02.387Z" }, + { url = "https://files.pythonhosted.org/packages/8b/0b/196350c122f50f6ca56846f2d71efd5e0d24b7b2e07355e019b2e2c7a11e/numpy-2.5.1-cp313-cp313-win_arm64.whl", hash = "sha256:f7feb014281029e628ba2d5a007407443b06e418b6fe451d1e2adcbc8eba0107", size = 10350256, upload-time = "2026-07-04T17:07:04.878Z" }, + { url = "https://files.pythonhosted.org/packages/db/f4/731b6085a83faf6ca843394cbd5e217280c214399f7e8b21b9f552af0ae2/numpy-2.5.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:7c786fe9a5bbe360022e584c5a34cf6b54265c71bd7ec8ac3d8fec38968071f8", size = 16795063, upload-time = "2026-07-04T17:07:07.374Z" }, + { url = "https://files.pythonhosted.org/packages/bf/64/0e215f2048dd11a55bb989ed41b3585ef57452404e638d703a211a3e4157/numpy-2.5.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:32985c896d897419ef8da6917872d80b78ad0ea26d85b23245c7366ffde76d75", size = 11776652, upload-time = "2026-07-04T17:07:09.907Z" }, + { url = "https://files.pythonhosted.org/packages/b5/59/2b844c7a6e9deff69b404a66221e1542937734f65d5e6e39411876053862/numpy-2.5.1-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:efd736408cc97c79b9e6917338dfc8f06013b2274f992e96b1d9a81a71e2a2c2", size = 5335944, upload-time = "2026-07-04T17:07:12.227Z" }, + { url = "https://files.pythonhosted.org/packages/86/51/9bf7cb2cabcebc9e017e4ec7e6322b378317a542c08b4cb68479c1efc716/numpy-2.5.1-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:ab84dc6b074fa881cae55bea94cc4f68e285181ba7f32497bf7dee6b1496165b", size = 6656266, upload-time = "2026-07-04T17:07:14.368Z" }, + { url = "https://files.pythonhosted.org/packages/83/3e/fb7615b211b82a32f44d5180a6d421b61f84d4fadd578b48ba4ac34e189f/numpy-2.5.1-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:caf3e317d33d60c37986b452613f4ab51246d0691350c03d0cb4a898627f4a95", size = 15179720, upload-time = "2026-07-04T17:07:16.272Z" }, + { url = "https://files.pythonhosted.org/packages/41/5f/0f992cb24560673496c5d68de61913b57166ce530ffda07c1f280e0cc464/numpy-2.5.1-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:54ad769f17bc2d833b620851989f62054fb9ab93c969d9e1dc3c8e3d56beea21", size = 16664835, upload-time = "2026-07-04T17:07:19.021Z" }, + { url = "https://files.pythonhosted.org/packages/a2/2f/97d6475ee91afe2587797d09446f9d3e475ad4cb681662d824809327b75a/numpy-2.5.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c12afb53450fa976d4c681c50a7423729a4c51c0465ed9f32b8a9cabbc472373", size = 16539135, upload-time = "2026-07-04T17:07:22.015Z" }, + { url = "https://files.pythonhosted.org/packages/c4/5b/4db81e4ba0be7e2776b1de68c82aa862c7f8ec27e1b4927d4ae075e20678/numpy-2.5.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:e8c11c405efc5ff6816d5983c96cdfa215bab3428961243af3ff59b228490438", size = 18426684, upload-time = "2026-07-04T17:07:24.941Z" }, + { url = "https://files.pythonhosted.org/packages/1f/64/c0ba2d90724d450279a7df8f32057241070250a26a7e2b5337d77347f481/numpy-2.5.1-cp314-cp314-win32.whl", hash = "sha256:f2479a47f8d5932d1718168a681ad6e536a9df484c83cfcf9de365e164537ace", size = 6116103, upload-time = "2026-07-04T17:07:27.622Z" }, + { url = "https://files.pythonhosted.org/packages/c1/1a/837f9ed7405adcd7a40538792eb169eddd8fa5630c16a1ef49dae71a30f4/numpy-2.5.1-cp314-cp314-win_amd64.whl", hash = "sha256:24d0eb82c0541d3415a33425db64ae439dffccd7b4dbcb30e7c35120205c506a", size = 12562177, upload-time = "2026-07-04T17:07:29.887Z" }, + { url = "https://files.pythonhosted.org/packages/22/ed/49707938b6dd0a78a9178dd93227dc89e4c11af47f5c798d70366e8d0483/numpy-2.5.1-cp314-cp314-win_arm64.whl", hash = "sha256:5a4c988b38d261deeeaad9954e3deb091ad905c94e8bb6708654ef1d97f286b0", size = 10627739, upload-time = "2026-07-04T17:07:32.568Z" }, + { url = "https://files.pythonhosted.org/packages/a6/c7/bb4b882cfe7f299cbc8b66e42e7dd78cf9d14e40f9469fc5e3db7e15b3bd/numpy-2.5.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:a33276be12fa045805f477f22482088b66bb758ffbe89a9d21457de863a32e22", size = 11894709, upload-time = "2026-07-04T17:07:34.941Z" }, + { url = "https://files.pythonhosted.org/packages/40/3f/5af7f4a7f6224aef48017aa82bb6174c7a659d724be0c75017b7e64a55b4/numpy-2.5.1-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:f089d7b00756190aacf1f5d34bdf38c3c430ac82b4f868f8cede73380460fce7", size = 5453810, upload-time = "2026-07-04T17:07:37.495Z" }, + { url = "https://files.pythonhosted.org/packages/20/c9/3474309bc94d634d3f9c3eddf03250ecb8c22cd948ef16fef69a77cc5d7b/numpy-2.5.1-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:09e9bfd8d2cf479c7d174804fb3811c53a8e9f20a37444008606b57d6b7a826d", size = 6761189, upload-time = "2026-07-04T17:07:39.563Z" }, + { url = "https://files.pythonhosted.org/packages/90/8a/558ae39fdd55d7e7f7fef9a84a6e964ac6b23edbd2a07e52bb084500507d/numpy-2.5.1-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e68d8dd1e7eba712948f2053a29ec86917bc70ba1358df869d9f06649ef9cf09", size = 15225039, upload-time = "2026-07-04T17:07:41.682Z" }, + { url = "https://files.pythonhosted.org/packages/63/27/ca7392b2d030277bdf0273e7d23255b3ee57d57a7c170a6f4fb3981e1e5d/numpy-2.5.1-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:99d5095fa265a0c4152e7bb12759e14381ef5496152f1ce58f44bdf55c44beb4", size = 16701306, upload-time = "2026-07-04T17:07:44.611Z" }, + { url = "https://files.pythonhosted.org/packages/02/42/03d53ae7996c44d4374a8262e9dc41671fd56cbb98f7d47ef85cf5da4c6b/numpy-2.5.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:ab87a91b3cc3382b8956095bd8f95e00cf679bb81554339be1a2ba404a1473c1", size = 16589955, upload-time = "2026-07-04T17:07:47.694Z" }, + { url = "https://files.pythonhosted.org/packages/7b/15/6c1784ae469640e65db111e9a34b3d0f14d91e8a38b9ce34810ced370dbb/numpy-2.5.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:224ca51130ef7da85bea2191625181cb4f337f9cb64b471f10c1a12aa8b60077", size = 18464252, upload-time = "2026-07-04T17:07:50.684Z" }, + { url = "https://files.pythonhosted.org/packages/94/a8/f98e50356cf167df656c526c2dfeec2d7dde182f2a3da4b458a5938e2776/numpy-2.5.1-cp314-cp314t-win32.whl", hash = "sha256:6eab239876581b2b3c5a242281b6007bbdbcd1c7085d7709bb57c5929b11e6bf", size = 6263298, upload-time = "2026-07-04T17:07:53.445Z" }, + { url = "https://files.pythonhosted.org/packages/72/ac/96ae880cdecad0b3275d9359fcec72667b49a4863c9f12942e43679dda02/numpy-2.5.1-cp314-cp314t-win_amd64.whl", hash = "sha256:83ce9c80d5b521b0d77ddcbe5447c218d247929b6cc056ca5351342accfff0af", size = 12748623, upload-time = "2026-07-04T17:07:55.384Z" }, + { url = "https://files.pythonhosted.org/packages/a1/5a/4d2b1601df3602dba7a14f3348ba9bfe94a18adb428e693df6154c293831/numpy-2.5.1-cp314-cp314t-win_arm64.whl", hash = "sha256:5a6db61f9aaa57e369905c67d852045d3c4f7126405b29d09b19dec118e9c9cb", size = 10697674, upload-time = "2026-07-04T17:07:58.506Z" }, +] + +[[package]] +name = "nvidia-cublas" +version = "13.1.1.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "nvidia-cuda-nvrtc" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/a7/a1/0bd24ee8c8d03adac032fd2909426a00c88f8c57961b1277ded97f91119f/nvidia_cublas-13.1.1.3-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:b7a210458267ac818974c53038fbec2e969d5c99f305ab15c72522fa9f001dd5", size = 542848918, upload-time = "2026-04-08T18:46:22.985Z" }, + { url = "https://files.pythonhosted.org/packages/3b/cd/154ca20c38269e05eff77c1464e6c1da89f50a6390b565e9d82e06bc11e1/nvidia_cublas-13.1.1.3-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:37936a16db8fe4ac1f065c2139360608a543a09275cb1a1af612e08cfa065436", size = 423138758, upload-time = "2026-04-08T18:46:58.655Z" }, +] + +[[package]] +name = "nvidia-cuda-cupti" +version = "13.0.85" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2a/2a/80353b103fc20ce05ef51e928daed4b6015db4aaa9162ed0997090fe2250/nvidia_cuda_cupti-13.0.85-py3-none-manylinux_2_25_aarch64.whl", hash = "sha256:796bd679890ee55fb14a94629b698b6db54bcfd833d391d5e94017dd9d7d3151", size = 10310827, upload-time = "2025-09-04T08:26:42.012Z" }, + { url = "https://files.pythonhosted.org/packages/33/6d/737d164b4837a9bbd202f5ae3078975f0525a55730fe871d8ed4e3b952b0/nvidia_cuda_cupti-13.0.85-py3-none-manylinux_2_25_x86_64.whl", hash = "sha256:4eb01c08e859bf924d222250d2e8f8b8ff6d3db4721288cf35d14252a4d933c8", size = 10715597, upload-time = "2025-09-04T08:26:51.312Z" }, +] + +[[package]] +name = "nvidia-cuda-nvrtc" +version = "13.0.88" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c3/68/483a78f5e8f31b08fb1bb671559968c0ca3a065ac7acabfc7cee55214fd6/nvidia_cuda_nvrtc-13.0.88-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl", hash = "sha256:ad9b6d2ead2435f11cbb6868809d2adeeee302e9bb94bcf0539c7a40d80e8575", size = 90215200, upload-time = "2025-09-04T08:28:44.204Z" }, + { url = "https://files.pythonhosted.org/packages/b7/dc/6bb80850e0b7edd6588d560758f17e0550893a1feaf436807d64d2da040f/nvidia_cuda_nvrtc-13.0.88-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d27f20a0ca67a4bb34268a5e951033496c5b74870b868bacd046b1b8e0c3267b", size = 43015449, upload-time = "2025-09-04T08:28:20.239Z" }, +] + +[[package]] +name = "nvidia-cuda-runtime" +version = "13.0.96" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/87/4f/17d7b9b8e285199c58ce28e31b5c5bbaa4d8271af06a89b6405258245de2/nvidia_cuda_runtime-13.0.96-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ef9bcbe90493a2b9d810e43d249adb3d02e98dd30200d86607d8d02687c43f55", size = 2261060, upload-time = "2025-10-09T08:55:15.78Z" }, + { url = "https://files.pythonhosted.org/packages/2e/24/d1558f3b68b1d26e706813b1d10aa1d785e4698c425af8db8edc3dced472/nvidia_cuda_runtime-13.0.96-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7f82250d7782aa23b6cfe765ecc7db554bd3c2870c43f3d1821f1d18aebf0548", size = 2243632, upload-time = "2025-10-09T08:55:36.117Z" }, +] + +[[package]] +name = "nvidia-cudnn-cu13" +version = "9.20.0.48" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "nvidia-cublas" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/56/c5/83384d846b2fd17c44bd499b36c75a45ed4f095fbbb2252294e89cea5c5c/nvidia_cudnn_cu13-9.20.0.48-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:e31454ae00094b0c55319d9d15b6fa2fc50a9e1c0f5c8c80fb75258234e731e1", size = 444574296, upload-time = "2026-03-09T19:28:27.751Z" }, + { url = "https://files.pythonhosted.org/packages/6e/5e/edb9c0ae051602c3ccaffe424256463636d639e27d7f302dde9975ef9e7a/nvidia_cudnn_cu13-9.20.0.48-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:0c45dd8eeb50b603f07995b1b300c62ffe6a1980482b82b3bcf94a4ca9d49304", size = 366173588, upload-time = "2026-03-09T19:29:34.474Z" }, +] + +[[package]] +name = "nvidia-cufft" +version = "12.0.0.61" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "nvidia-nvjitlink" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/8b/ae/f417a75c0259e85c1d2f83ca4e960289a5f814ed0cea74d18c353d3e989d/nvidia_cufft-12.0.0.61-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:2708c852ef8cd89d1d2068bdbece0aa188813a0c934db3779b9b1faa8442e5f5", size = 214053554, upload-time = "2025-09-04T08:31:38.196Z" }, + { url = "https://files.pythonhosted.org/packages/a8/2f/7b57e29836ea8714f81e9898409196f47d772d5ddedddf1592eadb8ab743/nvidia_cufft-12.0.0.61-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:6c44f692dce8fd5ffd3e3df134b6cdb9c2f72d99cf40b62c32dde45eea9ddad3", size = 214085489, upload-time = "2025-09-04T08:31:56.044Z" }, +] + +[[package]] +name = "nvidia-cufile" +version = "1.15.1.6" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3f/70/4f193de89a48b71714e74602ee14d04e4019ad36a5a9f20c425776e72cd6/nvidia_cufile-1.15.1.6-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:08a3ecefae5a01c7f5117351c64f17c7c62efa5fffdbe24fc7d298da19cd0b44", size = 1223672, upload-time = "2025-09-04T08:32:22.779Z" }, + { url = "https://files.pythonhosted.org/packages/ab/73/cc4a14c9813a8a0d509417cf5f4bdaba76e924d58beb9864f5a7baceefbf/nvidia_cufile-1.15.1.6-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:bdc0deedc61f548bddf7733bdc216456c2fdb101d020e1ab4b88d232d5e2f6d1", size = 1136992, upload-time = "2025-09-04T08:32:14.119Z" }, +] + +[[package]] +name = "nvidia-curand" +version = "10.4.0.35" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1e/72/7c2ae24fb6b63a32e6ae5d241cc65263ea18d08802aaae087d9f013335a2/nvidia_curand-10.4.0.35-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:133df5a7509c3e292aaa2b477afd0194f06ce4ea24d714d616ff36439cee349a", size = 61962106, upload-time = "2025-08-04T10:21:41.128Z" }, + { url = "https://files.pythonhosted.org/packages/a5/9f/be0a41ca4a4917abf5cb9ae0daff1a6060cc5de950aec0396de9f3b52bc5/nvidia_curand-10.4.0.35-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:1aee33a5da6e1db083fe2b90082def8915f30f3248d5896bcec36a579d941bfc", size = 59544258, upload-time = "2025-08-04T10:22:03.992Z" }, +] + +[[package]] +name = "nvidia-cusolver" +version = "12.0.4.66" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "nvidia-cublas" }, + { name = "nvidia-cusparse" }, + { name = "nvidia-nvjitlink" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/c8/c3/b30c9e935fc01e3da443ec0116ed1b2a009bb867f5324d3f2d7e533e776b/nvidia_cusolver-12.0.4.66-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:02c2457eaa9e39de20f880f4bd8820e6a1cfb9f9a34f820eb12a155aa5bc92d2", size = 223467760, upload-time = "2025-09-04T08:33:04.222Z" }, + { url = "https://files.pythonhosted.org/packages/5f/67/cba3777620cdacb99102da4042883709c41c709f4b6323c10781a9c3aa34/nvidia_cusolver-12.0.4.66-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:0a759da5dea5c0ea10fd307de75cdeb59e7ea4fcb8add0924859b944babf1112", size = 200941980, upload-time = "2025-09-04T08:33:22.767Z" }, +] + +[[package]] +name = "nvidia-cusparse" +version = "12.6.3.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "nvidia-nvjitlink" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/f8/94/5c26f33738ae35276672f12615a64bd008ed5be6d1ebcb23579285d960a9/nvidia_cusparse-12.6.3.3-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:80bcc4662f23f1054ee334a15c72b8940402975e0eab63178fc7e670aa59472c", size = 162155568, upload-time = "2025-09-04T08:33:42.864Z" }, + { url = "https://files.pythonhosted.org/packages/fa/18/623c77619c31d62efd55302939756966f3ecc8d724a14dab2b75f1508850/nvidia_cusparse-12.6.3.3-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:2b3c89c88d01ee0e477cb7f82ef60a11a4bcd57b6b87c33f789350b59759360b", size = 145942937, upload-time = "2025-09-04T08:33:58.029Z" }, +] + +[[package]] +name = "nvidia-cusparselt-cu13" +version = "0.8.1" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/46/e1/cdc1797eadf82d3a9a575a19b33fdc871a97edbec42c00b5b5e914f4aff4/nvidia_cusparselt_cu13-0.8.1-py3-none-manylinux2014_aarch64.whl", hash = "sha256:4dca476c50bf4780d46cd0bfbd82e2bc10a08e4fef7950917ce8d7578d22a23f", size = 221051344, upload-time = "2025-09-05T18:49:51.289Z" }, + { url = "https://files.pythonhosted.org/packages/34/7d/2661f2fb3ac4302f3a246f5fc030213ac60c1fe0bce84f9783dbd831dbb7/nvidia_cusparselt_cu13-0.8.1-py3-none-manylinux2014_x86_64.whl", hash = "sha256:786ce87568c303fadb5afcc7102d454cd3040d75f6f8626f5db460d1871f4dd0", size = 170148586, upload-time = "2025-09-05T18:50:50.248Z" }, +] + +[[package]] +name = "nvidia-nccl-cu13" +version = "2.29.7" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/72/0d/daf50d44177ee0cbc7ff0a0c91eb5ff676c82be42f9a970bc7597f440c3a/nvidia_nccl_cu13-2.29.7-py3-none-manylinux_2_18_aarch64.whl", hash = "sha256:674a12383e3c38a1bcccae7d4f3633b37852230b6047883cb2f4c2d1b36d9bf5", size = 206014712, upload-time = "2026-03-03T05:34:20.843Z" }, + { url = "https://files.pythonhosted.org/packages/67/f4/58e4e91b6919367c7aafb8e36fce9aad1a3047e536bf7e2fd560927d3a4c/nvidia_nccl_cu13-2.29.7-py3-none-manylinux_2_18_x86_64.whl", hash = "sha256:edd81538446786ec3b73972543e53bb43bcaf0bfc8ef76cb679fcc390ffe136d", size = 205976000, upload-time = "2026-03-03T05:36:24.472Z" }, +] + +[[package]] +name = "nvidia-nvjitlink" +version = "13.3.33" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f0/ee/580ca6f29dcab0221db8706badca1bbbb084f1975c4d4e83329c3a7e31f0/nvidia_nvjitlink-13.3.33-py3-none-manylinux2010_x86_64.manylinux_2_12_x86_64.whl", hash = "sha256:26a6de7fb4c8fdaa7703d3dad720d6d427ddfea5c48a528fd97c11733ad830e5", size = 40742423, upload-time = "2026-05-26T16:54:51.613Z" }, + { url = "https://files.pythonhosted.org/packages/69/30/45414e35ff2eee7db3da037e5707037ccf9d2b5218ffbdb055ea4d5aa98a/nvidia_nvjitlink-13.3.33-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ce48b37dfeb3cb1eae4cf85adacb47d7a6539ea2272870c9a3628ce275c2037e", size = 39168635, upload-time = "2026-05-26T16:54:13.906Z" }, +] + +[[package]] +name = "nvidia-nvshmem-cu13" +version = "3.4.5" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/dc/0f/05cc9c720236dcd2db9c1ab97fff629e96821be2e63103569da0c9b72f19/nvidia_nvshmem_cu13-3.4.5-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:6dc2a197f38e5d0376ad52cd1a2a3617d3cdc150fd5966f4aee9bcebb1d68fe9", size = 60215947, upload-time = "2025-09-06T00:32:20.022Z" }, + { url = "https://files.pythonhosted.org/packages/3c/35/a9bf80a609e74e3b000fef598933235c908fcefcef9026042b8e6dfde2a9/nvidia_nvshmem_cu13-3.4.5-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:290f0a2ee94c9f3687a02502f3b9299a9f9fe826e6d0287ee18482e78d495b80", size = 60412546, upload-time = "2025-09-06T00:32:41.564Z" }, +] + +[[package]] +name = "nvidia-nvtx" +version = "13.0.85" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c2/f3/d86c845465a2723ad7e1e5c36dcd75ddb82898b3f53be47ebd429fb2fa5d/nvidia_nvtx-13.0.85-py3-none-manylinux1_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:4936d1d6780fbe68db454f5e72a42ff64d1fd6397df9f363ae786930fd5c1cd4", size = 148047, upload-time = "2025-09-04T08:29:01.761Z" }, + { 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 = "packaging" +version = "26.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d7/f1/e7a6dd94a8d4a5626c03e4e99c87f241ba9e350cd9e6d75123f992427270/packaging-26.2.tar.gz", hash = "sha256:ff452ff5a3e828ce110190feff1178bb1f2ea2281fa2075aadb987c2fb221661", size = 228134, upload-time = "2026-04-24T20:15:23.917Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/df/b2/87e62e8c3e2f4b32e5fe99e0b86d576da1312593b39f47d8ceef365e95ed/packaging-26.2-py3-none-any.whl", hash = "sha256:5fc45236b9446107ff2415ce77c807cee2862cb6fac22b8a73826d0693b0980e", size = 100195, upload-time = "2026-04-24T20:15:22.081Z" }, +] + +[[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 = "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" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1c/3d/bb7fca845737cf9d7dbde16ed1843984665ff2e0a518f5db43e77ec540b9/pillow-12.3.0.tar.gz", hash = "sha256:3b8182a766685eaa002637e28b4ec8d6b18819a0c71f579bf0dbaa5830297cce", size = 47025035, upload-time = "2026-07-01T11:56:38.965Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fb/c8/0a78b0e02d7ac54bc03e5321c9220da52f0c2ea83b21f7c40e7f3169c502/pillow-12.3.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:00808c5e14ef63ac5161091d242999076604ff74b883423a11e5d7bbb38bf756", size = 5392415, upload-time = "2026-07-01T11:53:47.162Z" }, + { url = "https://files.pythonhosted.org/packages/b2/5b/a02d30018abd97ced9f5a6c63d28597694a00d066516b9c1c6de45859fc9/pillow-12.3.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:37d6d0a00072fd2948eb22bce7e1475f34569d90c87c59f7a2ec59541b77f7a6", size = 4785266, upload-time = "2026-07-01T11:53:49.079Z" }, + { url = "https://files.pythonhosted.org/packages/c8/98/766667a4be768150a202836acd9fad19c06824ca86c4286d3cf6b274964e/pillow-12.3.0-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bcb46e2f9feff8d06323983bd83ed00c201fdcab3d74973e7072a889b3979fcd", size = 6263814, upload-time = "2026-07-01T11:53:51.32Z" }, + { url = "https://files.pythonhosted.org/packages/3b/2d/ede717bc1144f63886c21fd349bb95860b0d1a21149ff16f2bb362b612b6/pillow-12.3.0-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:23d27a3e0307ec2244cc51e7287b919aa68d097504ebe19df4e76a98a3eea5bd", size = 6934408, upload-time = "2026-07-01T11:53:53.487Z" }, + { url = "https://files.pythonhosted.org/packages/a3/48/9c58b685e69d49c31af6c8eb9012055fab7e665785165c84796e2c73ce72/pillow-12.3.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:4f883547d4b7f0495ebe7056b0cc2aea76094e7a4abc8e933540f3271df27d9c", size = 6337160, upload-time = "2026-07-01T11:53:55.457Z" }, + { url = "https://files.pythonhosted.org/packages/ff/fa/dc2a5c0ba6df93f67c31d34b808b7ce440b40cdbf96f0b81cde1d1e6fa93/pillow-12.3.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:236ff70b9312fb68943c703aa842ca6a758abfa45ac187a5e7c1452e96ef72b5", size = 7045172, upload-time = "2026-07-01T11:53:57.736Z" }, + { url = "https://files.pythonhosted.org/packages/86/a5/444817a4d4c4c2417df00513086ca196f388d8f9ef40c2e4ccd1ad1af54b/pillow-12.3.0-cp311-cp311-win32.whl", hash = "sha256:10e41f0fbf1eec8cfd234b8fe17a4caac7c9d0db4c204d3c173a8f9f6ef3232b", size = 6472232, upload-time = "2026-07-01T11:53:59.767Z" }, + { url = "https://files.pythonhosted.org/packages/63/c6/4bad1b18d132a50b27e1365e1ab163616f7a5bb56d330f66f9d1d9d4f9d4/pillow-12.3.0-cp311-cp311-win_amd64.whl", hash = "sha256:8e95e1385e4998ae9694eeaa4730ba5457ff61185b3a55e2e7bea0880aef452a", size = 7233653, upload-time = "2026-07-01T11:54:02.066Z" }, + { url = "https://files.pythonhosted.org/packages/fd/16/00f91ab7760dc842f5aad55217e80fc4a7067a0604535249bc8a2d6d9870/pillow-12.3.0-cp311-cp311-win_arm64.whl", hash = "sha256:ebaea975e03d3141d9d3a507df75c9b3ec90fa9d2ffd07567b3a978d9d790b26", size = 2568195, upload-time = "2026-07-01T11:54:04.622Z" }, + { url = "https://files.pythonhosted.org/packages/37/bf/fb3ebff8ddcb76aac5a01389251bbbb9519922a9b520d8247c1ca864a25d/pillow-12.3.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:ba09209fbe443b4acccebe845d8a138b89a8f4fbaeedd44953490b5315d5e965", size = 5345969, upload-time = "2026-07-01T11:54:06.397Z" }, + { url = "https://files.pythonhosted.org/packages/d8/66/9a386a92561f402389a4fc70c18838bf6d35eb5eb5c6850b4b2dc64f5048/pillow-12.3.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ffd0c5368496f41b0944be820fcb7a838aa6e623d250b01acf2643939c3f99d7", size = 4780323, upload-time = "2026-07-01T11:54:09.351Z" }, + { url = "https://files.pythonhosted.org/packages/25/27/ac8f99618ffd3dde21db0f4d4b1d2ab00c0880595bfd17df103f7f39fd0c/pillow-12.3.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d9c7f76c0673154f044e9d78c8655fb4213f6ca31a836df48b40fe5d187717b9", size = 6266838, upload-time = "2026-07-01T11:54:11.71Z" }, + { url = "https://files.pythonhosted.org/packages/84/21/a35af28dcc61f37ed850a2d64c65c701321dfbf25085e469d5559360cbbf/pillow-12.3.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:78cb2c6865a35ab8ff8b75fd122f6033b92a62c82801110e48ddd6c936a45d91", size = 6940830, upload-time = "2026-07-01T11:54:13.732Z" }, + { url = "https://files.pythonhosted.org/packages/eb/51/8b08617af3ad95e33ce6d7dd2c99ed6c8298f7fb131636303956be022e25/pillow-12.3.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e491916b378fba47242221bb9ead245211b70d504f495d105d17b14a24b4907c", size = 6344383, upload-time = "2026-07-01T11:54:15.756Z" }, + { url = "https://files.pythonhosted.org/packages/1d/72/cf78ac9780bb93c28328f408973845a309d4d145041665f734572ced1b52/pillow-12.3.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:0dd2064cbc55aaec028ef5fbb60fa47bb6c3e7918e07ff17935284b227a9d2df", size = 7052934, upload-time = "2026-07-01T11:54:17.721Z" }, + { url = "https://files.pythonhosted.org/packages/20/20/25e0f4dc178a6bc0696793720055519a0de89e7661dae886992decbd2f81/pillow-12.3.0-cp312-cp312-win32.whl", hash = "sha256:dbce0b29841537a2fa4a214c2bbf14de3587c9680caa9b4e217568472490b28f", size = 6472684, upload-time = "2026-07-01T11:54:19.839Z" }, + { url = "https://files.pythonhosted.org/packages/45/89/da2f7971a317f83d807fdd4065c0af40208e59e692cc43d315a71a0e96d1/pillow-12.3.0-cp312-cp312-win_amd64.whl", hash = "sha256:a2b55dd6b2a4c4b7d87ffa56bdb33fdc5fdb9a462173861a7bc097f17d91cb09", size = 7227137, upload-time = "2026-07-01T11:54:22.025Z" }, + { url = "https://files.pythonhosted.org/packages/de/47/4845a0a6c0dbf1db8456bd9fc791f13c5ced7ced20606d08a0aacfd25b49/pillow-12.3.0-cp312-cp312-win_arm64.whl", hash = "sha256:331b624368d4f1d069149002f25f44bc61c8919ce8ddb3c45bdad8f6e2d89510", size = 2568267, upload-time = "2026-07-01T11:54:24.051Z" }, + { url = "https://files.pythonhosted.org/packages/9d/ac/31fb64e1e7efb5a4b50cd3d92049ba89ac6e4d8d3bb6a74e15048ca3353e/pillow-12.3.0-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:21900ce7ba264168cd50defae43cd75d25c833ad4ad6e73ffc5596d12e25ac89", size = 4161684, upload-time = "2026-07-01T11:54:25.934Z" }, + { url = "https://files.pythonhosted.org/packages/87/b4/9805e23d2b4d77842b468513841fda254ee42f0289d25088340e4ff46e2d/pillow-12.3.0-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:4e8c2a84d977f50b9daed6eeaf3baef67d00d5d74d932288f02cb94518ee3ace", size = 4255487, upload-time = "2026-07-01T11:54:27.935Z" }, + { url = "https://files.pythonhosted.org/packages/df/39/ecf519435a200c693fe053a6ee4d835b41cf963a4dfc2551c4e637cb2a71/pillow-12.3.0-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:ae26d61dfa7a47befdc7572b521024e8745f3d809bd95ca9505a7bba9ef849ec", size = 3696433, upload-time = "2026-07-01T11:54:29.813Z" }, + { url = "https://files.pythonhosted.org/packages/42/92/2fc3ffad878ae8dd5469ec1bc8eb83b71f48e13efdf68f02709003982a32/pillow-12.3.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:7a743ff716f746fc19a9557f60dab1600d4613255f8a7aeb3cdde4db7eb15a66", size = 5345889, upload-time = "2026-07-01T11:54:31.97Z" }, + { url = "https://files.pythonhosted.org/packages/10/76/8803c13605b763d33d156c4678fc77f8443389c0c51c8aef707bb02015f4/pillow-12.3.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:d69141514cc30b774ceea5e3ed3a6635c8d8a96edf664689b890f4089111fb35", size = 4780109, upload-time = "2026-07-01T11:54:34.026Z" }, + { url = "https://files.pythonhosted.org/packages/1f/01/e18aff37cb0b4aac47ac90f016d347a49aca667ef97f190b06ac2aabc928/pillow-12.3.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f7401aebd7f581d7f83a439d87d474999317ee099218e5ad25d125290990ba65", size = 6263736, upload-time = "2026-07-01T11:54:36.131Z" }, + { url = "https://files.pythonhosted.org/packages/f7/62/de5bdd77d935331f4f802edc11e4d82950f642caad6cb2f949837b8560e2/pillow-12.3.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0847a763afefb695bc912d7c131e7e0632d4edc1d8698f58ddabec8e46b8b6d3", size = 6937129, upload-time = "2026-07-01T11:54:38.216Z" }, + { url = "https://files.pythonhosted.org/packages/70/4d/105627a13300c5e0df1d174230b32fd1273062c96f7745fd552b945d1e1d/pillow-12.3.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:571b9fcb07b97ef3a492028fb3d2dc0993ca23a06138b0315286566d29ef718a", size = 6339562, upload-time = "2026-07-01T11:54:40.354Z" }, + { url = "https://files.pythonhosted.org/packages/6b/1d/f13de01a553988ab895ba1c722e06cf3144d4f57656fd5b81b6d881f1179/pillow-12.3.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:756c768d0c9c2955feb7a56c37ea24aea2e369f8d36a88da270b6a9f19e62b5e", size = 7049439, upload-time = "2026-07-01T11:54:42.489Z" }, + { url = "https://files.pythonhosted.org/packages/c9/f9/066794cca041b969964f779ee5fa66a9498bbf34248ac39c5d7954e4198f/pillow-12.3.0-cp313-cp313-win32.whl", hash = "sha256:a876864214e136f0eb367788dbd7df045f4806801518e2cfe9e13229cfe06d8f", size = 6473287, upload-time = "2026-07-01T11:54:44.9Z" }, + { url = "https://files.pythonhosted.org/packages/a6/9b/7a58e61d62be561da3a356fe2384d4059a6345fc130e23ef1c36a5b81d24/pillow-12.3.0-cp313-cp313-win_amd64.whl", hash = "sha256:1cca606cd25738df4ed873d5ad46bbdb3d83b5cbca291f6b4ff13a4df6b0bbe8", size = 7239691, upload-time = "2026-07-01T11:54:47.141Z" }, + { url = "https://files.pythonhosted.org/packages/aa/b0/c4ed4f0ef8f8fa5ee8351537db6650bb8189f7e118842978dd6589065692/pillow-12.3.0-cp313-cp313-win_arm64.whl", hash = "sha256:b629de27fda84b42cde7edef0d85f13b958b47f6e9bbcbba9b673c562a89bd8b", size = 2568185, upload-time = "2026-07-01T11:54:49.137Z" }, + { url = "https://files.pythonhosted.org/packages/dc/01/001f65b68192f0228cc1dbbc8d2530ab5d58b61037ba0587f946fea607cd/pillow-12.3.0-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:9cf95fe4d0f84c82d282745d9bb08ad9f926efa00be4697e767b814ce40d4330", size = 4161736, upload-time = "2026-07-01T11:54:51.156Z" }, + { url = "https://files.pythonhosted.org/packages/1a/d2/0219746d0fd16fc8a84498e79452375be3797d3ce4044596ce565164b84f/pillow-12.3.0-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:8728f216dcdb6e6d555cf971cb34076139ad74b31fc2c14da4fafc741c5f6217", size = 4255435, upload-time = "2026-07-01T11:54:53.414Z" }, + { url = "https://files.pythonhosted.org/packages/c8/02/8d0bc62ef0302318c46ff2a512822d2610e81c7aa46c9b3abe6cbaca5ad0/pillow-12.3.0-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:a45650e8ce7fafffd731db8550230db6b0d306d181a90b67d3e6bca2f1990930", size = 3696262, upload-time = "2026-07-01T11:54:55.739Z" }, + { url = "https://files.pythonhosted.org/packages/85/e2/73c77d218410b14f5f2d565e8a998d5317b7b9c75368d29985139f7a46f0/pillow-12.3.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:ba54cfebe86920a559a7c4d6b9050791c20513650a1952ebe3368c7dc70306f8", size = 5350344, upload-time = "2026-07-01T11:54:57.657Z" }, + { url = "https://files.pythonhosted.org/packages/c7/da/32c752228ae345f489e3a42499d817b6c3996da7e8a3bc7a04fc806b243b/pillow-12.3.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:e158cb00350dc278f3b91551101aa7d12415a66ebf2c91d8d5ac14e56ddd3ad0", size = 4780131, upload-time = "2026-07-01T11:54:59.713Z" }, + { url = "https://files.pythonhosted.org/packages/b1/9d/8b2c807dbef61a5197c047afe99823787eb66f63daf9fb2432f91d6f0462/pillow-12.3.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e9aeb04d6aef139de265b29683e119b638208f88cf73cdd1658aa07221165321", size = 6263757, upload-time = "2026-07-01T11:55:01.778Z" }, + { url = "https://files.pythonhosted.org/packages/5c/44/c85361f65dbe00eea8576ee467c768d25129989efb76e94f205e9ca9bb46/pillow-12.3.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:251bf95b67017e27b13d82f5b326234ca62d70f9cf4c2b9032de2358a3b12c7b", size = 6936962, upload-time = "2026-07-01T11:55:03.93Z" }, + { url = "https://files.pythonhosted.org/packages/18/7e/e483414b35800b86b6f08dbbc7803fb5cd52c4d6f897f47d53ea2c7e6f65/pillow-12.3.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:fe3cca2e4e8a592be0f269a1ca4835c25199d9f3ce815c8491048f785b0a0198", size = 6339171, upload-time = "2026-07-01T11:55:05.989Z" }, + { url = "https://files.pythonhosted.org/packages/f0/f4/68c491844841ede6bed70189546b3ee9731cf9f2cbad396faff5e1ccba45/pillow-12.3.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:23aceaa007d6172b02c277f0cd359c79492bbb14f7072b4ede9fbcaf20648130", size = 7048116, upload-time = "2026-07-01T11:55:08.131Z" }, + { url = "https://files.pythonhosted.org/packages/a3/34/77f3f793fed8efc7d243f21b33c5a3f0d1c97ee70346d3db855587e155ff/pillow-12.3.0-cp314-cp314-win32.whl", hash = "sha256:af8d94b0db561cf68b88a267c5c44b49e134f525d0dc2cb7ed413a66bc23559a", size = 6467209, upload-time = "2026-07-01T11:55:10.408Z" }, + { url = "https://files.pythonhosted.org/packages/f1/e0/492879f69d94f91f60fc8cd05ba03650e9520afebb2fb7aa12777d7c7f38/pillow-12.3.0-cp314-cp314-win_amd64.whl", hash = "sha256:fdafc9cce40277e0f7a0feabce0ee50dd2fa1800f3b38015e51296b5e814048d", size = 7237707, upload-time = "2026-07-01T11:55:12.745Z" }, + { url = "https://files.pythonhosted.org/packages/c9/ac/6b11f2875f1c2ac040d84e1bbf9cf22a88038f901ca1037898b280b38365/pillow-12.3.0-cp314-cp314-win_arm64.whl", hash = "sha256:e91206ee562682b51b98ef4b26a6ef48fd84e15fd4c4bc5ec768eb641d206838", size = 2565995, upload-time = "2026-07-01T11:55:14.736Z" }, + { url = "https://files.pythonhosted.org/packages/52/69/c2208e56af9bfc1913afb24020297a691eb1d4ef688474c8a04913f65e04/pillow-12.3.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:164b31cd1a0490ab6efae01aa5df49da7061be0af1b30e035b6e9a1bfe34ee6e", size = 5352503, upload-time = "2026-07-01T11:55:17.076Z" }, + { url = "https://files.pythonhosted.org/packages/07/70/e5686d753e898a45d778ff1718dba8516ead6ab6b95d85fc8c4b70650cf2/pillow-12.3.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:5afb51d599ea772b8365ae807ae557f18bccfe46ab261fd1c2a9ed700fc6eb17", size = 4782956, upload-time = "2026-07-01T11:55:19.448Z" }, + { url = "https://files.pythonhosted.org/packages/d5/37/25c6692f06927ee973ff18c8d9ee98ad0b4d84ee67a09610c2dd1447958e/pillow-12.3.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3edce1d53195db527e0191f84b71d02022de0540bf43a16ed734ed7537b07385", size = 6322855, upload-time = "2026-07-01T11:55:21.613Z" }, + { url = "https://files.pythonhosted.org/packages/cc/91/420637fcb8f1bc11029e403b4538e6694744428d8246118e45719f944556/pillow-12.3.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bf16ba1b4d0b6b7c8e534936632270cf70eb00dbe09005bc345b2677b726855c", size = 6989642, upload-time = "2026-07-01T11:55:24.006Z" }, + { url = "https://files.pythonhosted.org/packages/10/08/b94d7811281ccf0d143a1cf768d1c49e1e54af63e7b708ab2ee3eb87face/pillow-12.3.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:24870b09b224f7ae3c39ed07d10e819d06f8720bc551847b1d623832b5b0e28d", size = 6391281, upload-time = "2026-07-01T11:55:26.252Z" }, + { url = "https://files.pythonhosted.org/packages/d2/87/24233f785f55474dc02ce3e739c5528a77e3a862e9333d1dd7a25cc31f70/pillow-12.3.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:30f2aa603c41533cc25c05acd0da21636e84a315768feb631c937177db558931", size = 7096716, upload-time = "2026-07-01T11:55:28.318Z" }, + { url = "https://files.pythonhosted.org/packages/23/26/fcb2f6e37175b04f53570b59937867e2b80ee1685e744023153028fc14f9/pillow-12.3.0-cp314-cp314t-win32.whl", hash = "sha256:4b0a7fe987b14c31ebda6083f74f22b561fd3739bc0ac51e019622e3d72668c7", size = 6474125, upload-time = "2026-07-01T11:55:30.956Z" }, + { url = "https://files.pythonhosted.org/packages/90/de/3634abee5f1c9e13c56787b7d5517b0ba8d6de51700b95578cf338349c9f/pillow-12.3.0-cp314-cp314t-win_amd64.whl", hash = "sha256:962864dc93511324d51ddbb5b9f8731bf71675b93ca612a07441896f4688fb8c", size = 7242939, upload-time = "2026-07-01T11:55:34.044Z" }, + { url = "https://files.pythonhosted.org/packages/ce/2a/fd13f8eb24de5714a6eb444a3d67e2842c6c576e159a43793adf23051351/pillow-12.3.0-cp314-cp314t-win_arm64.whl", hash = "sha256:0740a512dc522224c77d9aa5a8d70d8b7d73fb91f2c21125d8d025d3b8990e45", size = 2567506, upload-time = "2026-07-01T11:55:35.988Z" }, + { url = "https://files.pythonhosted.org/packages/5d/dc/8fdce34ec725a33c81c6ba122b904d6b9024e50ea9ac7bede62fab54506c/pillow-12.3.0-cp315-cp315-ios_13_0_arm64_iphoneos.whl", hash = "sha256:0feb2e9d6ad6c9e3c06effe9d00f3f1e618a6643273576b016f591e9315a7139", size = 4162063, upload-time = "2026-07-01T11:55:37.941Z" }, + { url = "https://files.pythonhosted.org/packages/76/66/2044b9a63d3b84ff048228dfcb7cd9bf0df983e8470971bf7d4c57b693de/pillow-12.3.0-cp315-cp315-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:9e881fca225083806662a5c43d627d215f258ff43c890f831966c7d7ba9c7402", size = 4255549, upload-time = "2026-07-01T11:55:40.022Z" }, + { url = "https://files.pythonhosted.org/packages/52/7e/1f67e6f4ece6b582ee4b539decbcc9f848dc245a93ed8cd7338bafef72f1/pillow-12.3.0-cp315-cp315-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:4998562bf62a445225f22e07c896bb04b35b1b1f2eb6d760584c9c51d7a5f78c", size = 3696331, upload-time = "2026-07-01T11:55:41.98Z" }, + { url = "https://files.pythonhosted.org/packages/12/40/d306fc2c8e4d45d7f175c77edca7063be7b86fe7fe6e68f4353bf71d808c/pillow-12.3.0-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:dc624f6bc473dacdf7ef7eb8678d0d08edf15cd94fad6ae5c7d6cc67a4e4902f", size = 5350370, upload-time = "2026-07-01T11:55:44.028Z" }, + { url = "https://files.pythonhosted.org/packages/dd/44/668fb1437e8ce420f62d6106eb66e44a5971602a4d794615bdf79315d82d/pillow-12.3.0-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:71d6097b330eea8fd15097780c8e89cb1a8ce7838669f48c5bacd6f663dd4701", size = 4780147, upload-time = "2026-07-01T11:55:46.073Z" }, + { url = "https://files.pythonhosted.org/packages/0c/08/93fa2e70e30a2d81547e481b6ee2bb9522117221fb1e0ce4b5df70967677/pillow-12.3.0-cp315-cp315-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:28ce87c5ab450a9dd970b52e5aca5fe63ed432d18a2eaddd1979a00a1ba24ace", size = 6273659, upload-time = "2026-07-01T11:55:48.264Z" }, + { url = "https://files.pythonhosted.org/packages/f8/6d/043e96ff814fc31a33077e4cba86082167db520c93632afdf2042febbb0c/pillow-12.3.0-cp315-cp315-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6b02afb9b97f65fbca5f31db6a2a3ba21aa93030225f150fa3f249717e938fb4", size = 6947439, upload-time = "2026-07-01T11:55:50.503Z" }, + { url = "https://files.pythonhosted.org/packages/af/92/ba71d2ee2ac0edf3fa33bd9d5ee9ee080da70b1766f3ca3934f9938ddac9/pillow-12.3.0-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:1182d52bc2d5e5d7d0949503aa7e36d12f42205dc287e4883f407b1988820d39", size = 6353577, upload-time = "2026-07-01T11:55:52.697Z" }, + { url = "https://files.pythonhosted.org/packages/0f/ce/e63064e2122923ff687c8ad792d0d736a7b3920a56a46982e81a7fdd25d6/pillow-12.3.0-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:e795b7eb908249c4e43c7c99fac7c2c75dab0c43566e37db472a355f63693d71", size = 7060394, upload-time = "2026-07-01T11:55:55.149Z" }, + { url = "https://files.pythonhosted.org/packages/54/76/a09cc3ccc8d773a7283d34c38bec1708f9e3cc932093cbc4c5e71ac4060b/pillow-12.3.0-cp315-cp315-win32.whl", hash = "sha256:57b3d78c95ba9059768b10e28b813002261d3f3dfc55cc48b0c988f625175827", size = 6467375, upload-time = "2026-07-01T11:55:57.769Z" }, + { url = "https://files.pythonhosted.org/packages/3e/03/1846c49ba3b1d5550392a4bbd06d6fb4578e1cd91a803198b5c90f5f7d53/pillow-12.3.0-cp315-cp315-win_amd64.whl", hash = "sha256:fa4ecea169a355be7a3ade2c783e2ed12f0e40d2c5621cda8b3297faf7fbb9f5", size = 7237048, upload-time = "2026-07-01T11:55:59.975Z" }, + { url = "https://files.pythonhosted.org/packages/fb/bb/89f35dcc79610423f9f195504d7def7f0d1416a711541b42867e25fe3412/pillow-12.3.0-cp315-cp315-win_arm64.whl", hash = "sha256:877c3f311ff35410f690861c4409e7ccbf0cd2f878e50628a28e5a0bb689e658", size = 2566006, upload-time = "2026-07-01T11:56:02.143Z" }, + { url = "https://files.pythonhosted.org/packages/30/88/707027ba09942dfa2c28759b5c222d769290a41c6d20ea60ec250801941f/pillow-12.3.0-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:e9871b1ffbfa9656b60aeee92ed5136a5742696006fa322b29ea3d8da0ecc9cf", size = 5352509, upload-time = "2026-07-01T11:56:04.2Z" }, + { url = "https://files.pythonhosted.org/packages/b0/6d/00352fa25332c2569cd387851f568cc5a4b75a9adbfb37ac4fbce4c02eec/pillow-12.3.0-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:53aa02d20d10c3d814d536aa4e5ac9b84ca0ff5a88377963b085ad6822f93e64", size = 4783167, upload-time = "2026-07-01T11:56:06.631Z" }, + { url = "https://files.pythonhosted.org/packages/13/4f/9e049dfa21af7c22427275720e2490267ba8138120add5c4c574deb69782/pillow-12.3.0-cp315-cp315t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:446c34dcc4324b084a53b705127dc15717b22c5e140ae0a3c38349d4efec071e", size = 6329237, upload-time = "2026-07-01T11:56:08.868Z" }, + { url = "https://files.pythonhosted.org/packages/36/16/cf6eeaae8d0fce8dd390a33437cf68c5d5bd73834a2bc6e2f14efda0ab45/pillow-12.3.0-cp315-cp315t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:cf1845d02ad822a369a49f2bb9345b1614744267682e7a03527dc3bf6eea1777", size = 6997047, upload-time = "2026-07-01T11:56:11.379Z" }, + { url = "https://files.pythonhosted.org/packages/1e/69/dbf769bdd55f48bf5733cac28edc6364ffaa072ec9ba336266e4fe66be55/pillow-12.3.0-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:186941b6aef820ad110fb01fb06eb925374dc3a21b17e37ec9a53b250c6fe2d1", size = 6400440, upload-time = "2026-07-01T11:56:13.908Z" }, + { url = "https://files.pythonhosted.org/packages/a0/e1/ffc9cfc2eea0d178da8018e18e959301ad9d6bc9f3edb7181e748a474b97/pillow-12.3.0-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:f13c32a3abd6079a66d9526e18dad9b6d280384d49d7c54040cd57b6424041d9", size = 7105895, upload-time = "2026-07-01T11:56:16.575Z" }, + { url = "https://files.pythonhosted.org/packages/18/f0/a5595c1e8c3ae44b9828cb2f0fa8155e5095ef04d6327b8f61cf44a3df85/pillow-12.3.0-cp315-cp315t-win32.whl", hash = "sha256:1657923d2d45afb66526e5b933e5b3052e6bdea196c90d3abb2424e18c77dae8", size = 6474384, upload-time = "2026-07-01T11:56:18.855Z" }, + { url = "https://files.pythonhosted.org/packages/e4/04/62bcd9f844984c5938d3b05264a61d797a29d3e0812341a8204af70bbdee/pillow-12.3.0-cp315-cp315t-win_amd64.whl", hash = "sha256:8cd2f7bdda092d99c9fc2fb7391354f306d01443d22785d0cbfafa2e2c8bb418", size = 7243537, upload-time = "2026-07-01T11:56:21.214Z" }, + { url = "https://files.pythonhosted.org/packages/3d/68/1f3066acedf37673694a7141381d8f811ae97f30d34413d236abe7d489f1/pillow-12.3.0-cp315-cp315t-win_arm64.whl", hash = "sha256:06ff022112bc9cbf83b60f8e028d94ad87b60621706487e65f673de61610ab59", size = 2567491, upload-time = "2026-07-01T11:56:23.506Z" }, + { url = "https://files.pythonhosted.org/packages/75/18/2e8b40223153ccbc60df07f9e8928dc0c76202aa4e55ae9f53962b6510d6/pillow-12.3.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:b3c777e849237620b022f7f297dd67705f9f5cf1685f09f02e46f93e92725468", size = 5302510, upload-time = "2026-07-01T11:56:25.736Z" }, + { url = "https://files.pythonhosted.org/packages/46/3e/51fabf59d5ab801ceab709453d3ab6b180083496579549de4c45ced6528a/pillow-12.3.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:b343699e8308bdc51978310e1c959c584e7869cc8c40780058c87da7781a1e94", size = 4736058, upload-time = "2026-07-01T11:56:28.041Z" }, + { url = "https://files.pythonhosted.org/packages/bf/20/22fe9384b7949e25fb1293bcfc84fb82590ff4ea6b37c95b24d26d793d86/pillow-12.3.0-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fbd139c8447d25dd750ab79ee274cc5e1fe80fc56340ab10b18a195e1b6eca3e", size = 5237776, upload-time = "2026-07-01T11:56:30.263Z" }, + { url = "https://files.pythonhosted.org/packages/08/14/f6ba68107680ffa74b39985f3f30884e41318fbc4250caa423c79b4788bb/pillow-12.3.0-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e7e480451b9fa137494bccd3a7d69adbe8ac65a87d97be61e11f1b1050a5bac3", size = 5860358, upload-time = "2026-07-01T11:56:32.68Z" }, + { 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.10.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/52/cd/4f25b2f95b23f5d2c9c1fe43e49841bff5800562149b2666afc09309aa8f/platformdirs-4.10.1.tar.gz", hash = "sha256:ceab4084426fe6319ce18e86deada8ab1b7487c7aee7040c55e277c9ae793695", size = 31678, upload-time = "2026-07-18T03:53:43.808Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ec/73/6fd0bb9ce84138c3857f12e9de63bc901852975a092d545f18087a204aa2/platformdirs-4.10.1-py3-none-any.whl", hash = "sha256:0e4eff26be2d75293977f7cddc153fd9b8eaa7fb0c7b64ffe4076cb443117443", size = 22906, upload-time = "2026-07-18T03:53:42.576Z" }, +] + +[[package]] +name = "prompt-toolkit" +version = "3.0.52" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "wcwidth" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a1/96/06e01a7b38dce6fe1db213e061a4602dd6032a8a97ef6c1a862537732421/prompt_toolkit-3.0.52.tar.gz", hash = "sha256:28cde192929c8e7321de85de1ddbe736f1375148b02f2e17edd840042b1be855", size = 434198, upload-time = "2025-08-27T15:24:02.057Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/84/03/0d3ce49e2505ae70cf43bc5bb3033955d2fc9f932163e84dc0779cc47f48/prompt_toolkit-3.0.52-py3-none-any.whl", hash = "sha256:9aac639a3bbd33284347de5ad8d68ecc044b91a762dc39b7c21095fcd6a19955", size = 391431, upload-time = "2025-08-27T15:23:59.498Z" }, +] + +[[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 = "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 = "pygments" +version = "2.20.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/c3/b2/bc9c9196916376152d655522fdcebac55e66de6603a76a02bca1b6414f6c/pygments-2.20.0.tar.gz", hash = "sha256:6757cd03768053ff99f3039c1a36d6c0aa0b263438fcab17520b30a303a82b5f", size = 4955991, upload-time = "2026-03-29T13:29:33.898Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f4/7e/a72dd26f3b0f4f2bf1dd8923c85f7ceb43172af56d63c7383eb62b332364/pygments-2.20.0-py3-none-any.whl", hash = "sha256:81a9e26dd42fd28a23a2d169d86d7ac03b46e2f8b59ed4698fb4785f946d0176", size = 1231151, upload-time = "2026-03-29T13:29:30.038Z" }, +] + +[[package]] +name = "pyparsing" +version = "3.3.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f3/91/9c6ee907786a473bf81c5f53cf703ba0957b23ab84c264080fb5a450416f/pyparsing-3.3.2.tar.gz", hash = "sha256:c777f4d763f140633dcb6d8a3eda953bf7a214dc4eff598413c070bcdc117cbc", size = 6851574, upload-time = "2026-01-21T03:57:59.36Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/10/bd/c038d7cc38edc1aa5bf91ab8068b63d4308c66c4c8bb3cbba7dfbc049f9c/pyparsing-3.3.2-py3-none-any.whl", hash = "sha256:850ba148bd908d7e2411587e247a1e4f0327839c40e2e5e6d05a007ecc69911d", size = 122781, upload-time = "2026-01-21T03:57:55.912Z" }, +] + +[[package]] +name = "python-dateutil" +version = "2.9.0.post0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "six" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432, upload-time = "2024-03-01T18:36:20.211Z" } +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 = "pyzmq" +version = "27.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cffi", marker = "implementation_name == 'pypy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/04/0b/3c9baedbdf613ecaa7aa07027780b8867f57b6293b6ee50de316c9f3222b/pyzmq-27.1.0.tar.gz", hash = "sha256:ac0765e3d44455adb6ddbf4417dcce460fc40a05978c08efdf2948072f6db540", size = 281750, upload-time = "2025-09-08T23:10:18.157Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/06/5d/305323ba86b284e6fcb0d842d6adaa2999035f70f8c38a9b6d21ad28c3d4/pyzmq-27.1.0-cp311-cp311-macosx_10_15_universal2.whl", hash = "sha256:226b091818d461a3bef763805e75685e478ac17e9008f49fce2d3e52b3d58b86", size = 1333328, upload-time = "2025-09-08T23:07:45.946Z" }, + { url = "https://files.pythonhosted.org/packages/bd/a0/fc7e78a23748ad5443ac3275943457e8452da67fda347e05260261108cbc/pyzmq-27.1.0-cp311-cp311-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:0790a0161c281ca9723f804871b4027f2e8b5a528d357c8952d08cd1a9c15581", size = 908803, upload-time = "2025-09-08T23:07:47.551Z" }, + { url = "https://files.pythonhosted.org/packages/7e/22/37d15eb05f3bdfa4abea6f6d96eb3bb58585fbd3e4e0ded4e743bc650c97/pyzmq-27.1.0-cp311-cp311-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c895a6f35476b0c3a54e3eb6ccf41bf3018de937016e6e18748317f25d4e925f", size = 668836, upload-time = "2025-09-08T23:07:49.436Z" }, + { url = "https://files.pythonhosted.org/packages/b1/c4/2a6fe5111a01005fc7af3878259ce17684fabb8852815eda6225620f3c59/pyzmq-27.1.0-cp311-cp311-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5bbf8d3630bf96550b3be8e1fc0fea5cbdc8d5466c1192887bd94869da17a63e", size = 857038, upload-time = "2025-09-08T23:07:51.234Z" }, + { url = "https://files.pythonhosted.org/packages/cb/eb/bfdcb41d0db9cd233d6fb22dc131583774135505ada800ebf14dfb0a7c40/pyzmq-27.1.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:15c8bd0fe0dabf808e2d7a681398c4e5ded70a551ab47482067a572c054c8e2e", size = 1657531, upload-time = "2025-09-08T23:07:52.795Z" }, + { url = "https://files.pythonhosted.org/packages/ab/21/e3180ca269ed4a0de5c34417dfe71a8ae80421198be83ee619a8a485b0c7/pyzmq-27.1.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:bafcb3dd171b4ae9f19ee6380dfc71ce0390fefaf26b504c0e5f628d7c8c54f2", size = 2034786, upload-time = "2025-09-08T23:07:55.047Z" }, + { url = "https://files.pythonhosted.org/packages/3b/b1/5e21d0b517434b7f33588ff76c177c5a167858cc38ef740608898cd329f2/pyzmq-27.1.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:e829529fcaa09937189178115c49c504e69289abd39967cd8a4c215761373394", size = 1894220, upload-time = "2025-09-08T23:07:57.172Z" }, + { url = "https://files.pythonhosted.org/packages/03/f2/44913a6ff6941905efc24a1acf3d3cb6146b636c546c7406c38c49c403d4/pyzmq-27.1.0-cp311-cp311-win32.whl", hash = "sha256:6df079c47d5902af6db298ec92151db82ecb557af663098b92f2508c398bb54f", size = 567155, upload-time = "2025-09-08T23:07:59.05Z" }, + { url = "https://files.pythonhosted.org/packages/23/6d/d8d92a0eb270a925c9b4dd039c0b4dc10abc2fcbc48331788824ef113935/pyzmq-27.1.0-cp311-cp311-win_amd64.whl", hash = "sha256:190cbf120fbc0fc4957b56866830def56628934a9d112aec0e2507aa6a032b97", size = 633428, upload-time = "2025-09-08T23:08:00.663Z" }, + { url = "https://files.pythonhosted.org/packages/ae/14/01afebc96c5abbbd713ecfc7469cfb1bc801c819a74ed5c9fad9a48801cb/pyzmq-27.1.0-cp311-cp311-win_arm64.whl", hash = "sha256:eca6b47df11a132d1745eb3b5b5e557a7dae2c303277aa0e69c6ba91b8736e07", size = 559497, upload-time = "2025-09-08T23:08:02.15Z" }, + { url = "https://files.pythonhosted.org/packages/92/e7/038aab64a946d535901103da16b953c8c9cc9c961dadcbf3609ed6428d23/pyzmq-27.1.0-cp312-abi3-macosx_10_15_universal2.whl", hash = "sha256:452631b640340c928fa343801b0d07eb0c3789a5ffa843f6e1a9cee0ba4eb4fc", size = 1306279, upload-time = "2025-09-08T23:08:03.807Z" }, + { url = "https://files.pythonhosted.org/packages/e8/5e/c3c49fdd0f535ef45eefcc16934648e9e59dace4a37ee88fc53f6cd8e641/pyzmq-27.1.0-cp312-abi3-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:1c179799b118e554b66da67d88ed66cd37a169f1f23b5d9f0a231b4e8d44a113", size = 895645, upload-time = "2025-09-08T23:08:05.301Z" }, + { url = "https://files.pythonhosted.org/packages/f8/e5/b0b2504cb4e903a74dcf1ebae157f9e20ebb6ea76095f6cfffea28c42ecd/pyzmq-27.1.0-cp312-abi3-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3837439b7f99e60312f0c926a6ad437b067356dc2bc2ec96eb395fd0fe804233", size = 652574, upload-time = "2025-09-08T23:08:06.828Z" }, + { url = "https://files.pythonhosted.org/packages/f8/9b/c108cdb55560eaf253f0cbdb61b29971e9fb34d9c3499b0e96e4e60ed8a5/pyzmq-27.1.0-cp312-abi3-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:43ad9a73e3da1fab5b0e7e13402f0b2fb934ae1c876c51d0afff0e7c052eca31", size = 840995, upload-time = "2025-09-08T23:08:08.396Z" }, + { url = "https://files.pythonhosted.org/packages/c2/bb/b79798ca177b9eb0825b4c9998c6af8cd2a7f15a6a1a4272c1d1a21d382f/pyzmq-27.1.0-cp312-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:0de3028d69d4cdc475bfe47a6128eb38d8bc0e8f4d69646adfbcd840facbac28", size = 1642070, upload-time = "2025-09-08T23:08:09.989Z" }, + { url = "https://files.pythonhosted.org/packages/9c/80/2df2e7977c4ede24c79ae39dcef3899bfc5f34d1ca7a5b24f182c9b7a9ca/pyzmq-27.1.0-cp312-abi3-musllinux_1_2_i686.whl", hash = "sha256:cf44a7763aea9298c0aa7dbf859f87ed7012de8bda0f3977b6fb1d96745df856", size = 2021121, upload-time = "2025-09-08T23:08:11.907Z" }, + { url = "https://files.pythonhosted.org/packages/46/bd/2d45ad24f5f5ae7e8d01525eb76786fa7557136555cac7d929880519e33a/pyzmq-27.1.0-cp312-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:f30f395a9e6fbca195400ce833c731e7b64c3919aa481af4d88c3759e0cb7496", size = 1878550, upload-time = "2025-09-08T23:08:13.513Z" }, + { url = "https://files.pythonhosted.org/packages/e6/2f/104c0a3c778d7c2ab8190e9db4f62f0b6957b53c9d87db77c284b69f33ea/pyzmq-27.1.0-cp312-abi3-win32.whl", hash = "sha256:250e5436a4ba13885494412b3da5d518cd0d3a278a1ae640e113c073a5f88edd", size = 559184, upload-time = "2025-09-08T23:08:15.163Z" }, + { url = "https://files.pythonhosted.org/packages/fc/7f/a21b20d577e4100c6a41795842028235998a643b1ad406a6d4163ea8f53e/pyzmq-27.1.0-cp312-abi3-win_amd64.whl", hash = "sha256:9ce490cf1d2ca2ad84733aa1d69ce6855372cb5ce9223802450c9b2a7cba0ccf", size = 619480, upload-time = "2025-09-08T23:08:17.192Z" }, + { url = "https://files.pythonhosted.org/packages/78/c2/c012beae5f76b72f007a9e91ee9401cb88c51d0f83c6257a03e785c81cc2/pyzmq-27.1.0-cp312-abi3-win_arm64.whl", hash = "sha256:75a2f36223f0d535a0c919e23615fc85a1e23b71f40c7eb43d7b1dedb4d8f15f", size = 552993, upload-time = "2025-09-08T23:08:18.926Z" }, + { url = "https://files.pythonhosted.org/packages/60/cb/84a13459c51da6cec1b7b1dc1a47e6db6da50b77ad7fd9c145842750a011/pyzmq-27.1.0-cp313-cp313-android_24_arm64_v8a.whl", hash = "sha256:93ad4b0855a664229559e45c8d23797ceac03183c7b6f5b4428152a6b06684a5", size = 1122436, upload-time = "2025-09-08T23:08:20.801Z" }, + { url = "https://files.pythonhosted.org/packages/dc/b6/94414759a69a26c3dd674570a81813c46a078767d931a6c70ad29fc585cb/pyzmq-27.1.0-cp313-cp313-android_24_x86_64.whl", hash = "sha256:fbb4f2400bfda24f12f009cba62ad5734148569ff4949b1b6ec3b519444342e6", size = 1156301, upload-time = "2025-09-08T23:08:22.47Z" }, + { url = "https://files.pythonhosted.org/packages/a5/ad/15906493fd40c316377fd8a8f6b1f93104f97a752667763c9b9c1b71d42d/pyzmq-27.1.0-cp313-cp313t-macosx_10_15_universal2.whl", hash = "sha256:e343d067f7b151cfe4eb3bb796a7752c9d369eed007b91231e817071d2c2fec7", size = 1341197, upload-time = "2025-09-08T23:08:24.286Z" }, + { url = "https://files.pythonhosted.org/packages/14/1d/d343f3ce13db53a54cb8946594e567410b2125394dafcc0268d8dda027e0/pyzmq-27.1.0-cp313-cp313t-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:08363b2011dec81c354d694bdecaef4770e0ae96b9afea70b3f47b973655cc05", size = 897275, upload-time = "2025-09-08T23:08:26.063Z" }, + { url = "https://files.pythonhosted.org/packages/69/2d/d83dd6d7ca929a2fc67d2c3005415cdf322af7751d773524809f9e585129/pyzmq-27.1.0-cp313-cp313t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d54530c8c8b5b8ddb3318f481297441af102517602b569146185fa10b63f4fa9", size = 660469, upload-time = "2025-09-08T23:08:27.623Z" }, + { url = "https://files.pythonhosted.org/packages/3e/cd/9822a7af117f4bc0f1952dbe9ef8358eb50a24928efd5edf54210b850259/pyzmq-27.1.0-cp313-cp313t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6f3afa12c392f0a44a2414056d730eebc33ec0926aae92b5ad5cf26ebb6cc128", size = 847961, upload-time = "2025-09-08T23:08:29.672Z" }, + { url = "https://files.pythonhosted.org/packages/9a/12/f003e824a19ed73be15542f172fd0ec4ad0b60cf37436652c93b9df7c585/pyzmq-27.1.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:c65047adafe573ff023b3187bb93faa583151627bc9c51fc4fb2c561ed689d39", size = 1650282, upload-time = "2025-09-08T23:08:31.349Z" }, + { url = "https://files.pythonhosted.org/packages/d5/4a/e82d788ed58e9a23995cee70dbc20c9aded3d13a92d30d57ec2291f1e8a3/pyzmq-27.1.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:90e6e9441c946a8b0a667356f7078d96411391a3b8f80980315455574177ec97", size = 2024468, upload-time = "2025-09-08T23:08:33.543Z" }, + { url = "https://files.pythonhosted.org/packages/d9/94/2da0a60841f757481e402b34bf4c8bf57fa54a5466b965de791b1e6f747d/pyzmq-27.1.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:add071b2d25f84e8189aaf0882d39a285b42fa3853016ebab234a5e78c7a43db", size = 1885394, upload-time = "2025-09-08T23:08:35.51Z" }, + { url = "https://files.pythonhosted.org/packages/4f/6f/55c10e2e49ad52d080dc24e37adb215e5b0d64990b57598abc2e3f01725b/pyzmq-27.1.0-cp313-cp313t-win32.whl", hash = "sha256:7ccc0700cfdf7bd487bea8d850ec38f204478681ea02a582a8da8171b7f90a1c", size = 574964, upload-time = "2025-09-08T23:08:37.178Z" }, + { url = "https://files.pythonhosted.org/packages/87/4d/2534970ba63dd7c522d8ca80fb92777f362c0f321900667c615e2067cb29/pyzmq-27.1.0-cp313-cp313t-win_amd64.whl", hash = "sha256:8085a9fba668216b9b4323be338ee5437a235fe275b9d1610e422ccc279733e2", size = 641029, upload-time = "2025-09-08T23:08:40.595Z" }, + { url = "https://files.pythonhosted.org/packages/f6/fa/f8aea7a28b0641f31d40dea42d7ef003fded31e184ef47db696bc74cd610/pyzmq-27.1.0-cp313-cp313t-win_arm64.whl", hash = "sha256:6bb54ca21bcfe361e445256c15eedf083f153811c37be87e0514934d6913061e", size = 561541, upload-time = "2025-09-08T23:08:42.668Z" }, + { url = "https://files.pythonhosted.org/packages/87/45/19efbb3000956e82d0331bafca5d9ac19ea2857722fa2caacefb6042f39d/pyzmq-27.1.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:ce980af330231615756acd5154f29813d553ea555485ae712c491cd483df6b7a", size = 1341197, upload-time = "2025-09-08T23:08:44.973Z" }, + { url = "https://files.pythonhosted.org/packages/48/43/d72ccdbf0d73d1343936296665826350cb1e825f92f2db9db3e61c2162a2/pyzmq-27.1.0-cp314-cp314t-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:1779be8c549e54a1c38f805e56d2a2e5c009d26de10921d7d51cfd1c8d4632ea", size = 897175, upload-time = "2025-09-08T23:08:46.601Z" }, + { url = "https://files.pythonhosted.org/packages/2f/2e/a483f73a10b65a9ef0161e817321d39a770b2acf8bcf3004a28d90d14a94/pyzmq-27.1.0-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7200bb0f03345515df50d99d3db206a0a6bee1955fbb8c453c76f5bf0e08fb96", size = 660427, upload-time = "2025-09-08T23:08:48.187Z" }, + { url = "https://files.pythonhosted.org/packages/f5/d2/5f36552c2d3e5685abe60dfa56f91169f7a2d99bbaf67c5271022ab40863/pyzmq-27.1.0-cp314-cp314t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:01c0e07d558b06a60773744ea6251f769cd79a41a97d11b8bf4ab8f034b0424d", size = 847929, upload-time = "2025-09-08T23:08:49.76Z" }, + { url = "https://files.pythonhosted.org/packages/c4/2a/404b331f2b7bf3198e9945f75c4c521f0c6a3a23b51f7a4a401b94a13833/pyzmq-27.1.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:80d834abee71f65253c91540445d37c4c561e293ba6e741b992f20a105d69146", size = 1650193, upload-time = "2025-09-08T23:08:51.7Z" }, + { url = "https://files.pythonhosted.org/packages/1c/0b/f4107e33f62a5acf60e3ded67ed33d79b4ce18de432625ce2fc5093d6388/pyzmq-27.1.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:544b4e3b7198dde4a62b8ff6685e9802a9a1ebf47e77478a5eb88eca2a82f2fd", size = 2024388, upload-time = "2025-09-08T23:08:53.393Z" }, + { url = "https://files.pythonhosted.org/packages/0d/01/add31fe76512642fd6e40e3a3bd21f4b47e242c8ba33efb6809e37076d9b/pyzmq-27.1.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:cedc4c68178e59a4046f97eca31b148ddcf51e88677de1ef4e78cf06c5376c9a", size = 1885316, upload-time = "2025-09-08T23:08:55.702Z" }, + { url = "https://files.pythonhosted.org/packages/c4/59/a5f38970f9bf07cee96128de79590bb354917914a9be11272cfc7ff26af0/pyzmq-27.1.0-cp314-cp314t-win32.whl", hash = "sha256:1f0b2a577fd770aa6f053211a55d1c47901f4d537389a034c690291485e5fe92", size = 587472, upload-time = "2025-09-08T23:08:58.18Z" }, + { url = "https://files.pythonhosted.org/packages/70/d8/78b1bad170f93fcf5e3536e70e8fadac55030002275c9a29e8f5719185de/pyzmq-27.1.0-cp314-cp314t-win_amd64.whl", hash = "sha256:19c9468ae0437f8074af379e986c5d3d7d7bfe033506af442e8c879732bedbe0", size = 661401, upload-time = "2025-09-08T23:08:59.802Z" }, + { url = "https://files.pythonhosted.org/packages/81/d6/4bfbb40c9a0b42fc53c7cf442f6385db70b40f74a783130c5d0a5aa62228/pyzmq-27.1.0-cp314-cp314t-win_arm64.whl", hash = "sha256:dc5dbf68a7857b59473f7df42650c621d7e8923fb03fa74a526890f4d33cc4d7", size = 575170, upload-time = "2025-09-08T23:09:01.418Z" }, + { url = "https://files.pythonhosted.org/packages/4c/c6/c4dcdecdbaa70969ee1fdced6d7b8f60cfabe64d25361f27ac4665a70620/pyzmq-27.1.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:18770c8d3563715387139060d37859c02ce40718d1faf299abddcdcc6a649066", size = 836265, upload-time = "2025-09-08T23:09:49.376Z" }, + { url = "https://files.pythonhosted.org/packages/3e/79/f38c92eeaeb03a2ccc2ba9866f0439593bb08c5e3b714ac1d553e5c96e25/pyzmq-27.1.0-pp311-pypy311_pp73-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:ac25465d42f92e990f8d8b0546b01c391ad431c3bf447683fdc40565941d0604", size = 800208, upload-time = "2025-09-08T23:09:51.073Z" }, + { url = "https://files.pythonhosted.org/packages/49/0e/3f0d0d335c6b3abb9b7b723776d0b21fa7f3a6c819a0db6097059aada160/pyzmq-27.1.0-pp311-pypy311_pp73-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:53b40f8ae006f2734ee7608d59ed661419f087521edbfc2149c3932e9c14808c", size = 567747, upload-time = "2025-09-08T23:09:52.698Z" }, + { url = "https://files.pythonhosted.org/packages/a1/cf/f2b3784d536250ffd4be70e049f3b60981235d70c6e8ce7e3ef21e1adb25/pyzmq-27.1.0-pp311-pypy311_pp73-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f605d884e7c8be8fe1aa94e0a783bf3f591b84c24e4bc4f3e7564c82ac25e271", size = 747371, upload-time = "2025-09-08T23:09:54.563Z" }, + { url = "https://files.pythonhosted.org/packages/01/1b/5dbe84eefc86f48473947e2f41711aded97eecef1231f4558f1f02713c12/pyzmq-27.1.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:c9f7f6e13dff2e44a6afeaf2cf54cee5929ad64afaf4d40b50f93c58fc687355", size = 544862, upload-time = "2025-09-08T23:09:56.509Z" }, +] + +[[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 = "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 = "setuptools" +version = "83.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/34/26/f5d29e25ffdb535afef2d35cdb55b325298f96debd670da4c325e08d70f4/setuptools-83.0.0.tar.gz", hash = "sha256:025bccbbf0fa05b6192bc64ae1e7b16e001fd6d6d4d5de03c97b1c1ade523bef", size = 1154254, upload-time = "2026-07-04T15:31:22.699Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5d/40/e1e72872c6354b306daef1703549e8e83b4d43cfea356311bf722a043752/setuptools-83.0.0-py3-none-any.whl", hash = "sha256:29b23c360f22f414dc7336bb39178cc7bcbf6021ed2733cde173f09dba19abb3", size = 1008090, upload-time = "2026-07-04T15:31:20.885Z" }, +] + +[[package]] +name = "six" +version = "1.17.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031, upload-time = "2024-12-04T17:35:28.174Z" } +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 = "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" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "mpmath" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/83/d3/803453b36afefb7c2bb238361cd4ae6125a569b4db67cd9e79846ba2d68c/sympy-1.14.0.tar.gz", hash = "sha256:d3d3fe8df1e5a0b42f0e7bdf50541697dbe7d23746e894990c030e2b05e72517", size = 7793921, upload-time = "2025-04-27T18:05:01.611Z" } +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 = "torch" +version = "2.13.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cuda-bindings", marker = "python_full_version < '3.15' and sys_platform == 'linux'" }, + { name = "cuda-toolkit", extra = ["cublas", "cudart", "cufft", "cufile", "cupti", "curand", "cusolver", "cusparse", "nvjitlink", "nvrtc", "nvtx"], marker = "sys_platform == 'linux'" }, + { name = "filelock" }, + { name = "fsspec" }, + { name = "jinja2" }, + { name = "networkx" }, + { name = "nvidia-cudnn-cu13", marker = "sys_platform == 'linux'" }, + { name = "nvidia-cusparselt-cu13", marker = "sys_platform == 'linux'" }, + { name = "nvidia-nccl-cu13", marker = "sys_platform == 'linux'" }, + { name = "nvidia-nvshmem-cu13", marker = "sys_platform == 'linux'" }, + { name = "setuptools" }, + { name = "sympy" }, + { name = "triton", marker = "python_full_version < '3.15' and sys_platform == 'linux'" }, + { name = "typing-extensions" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/5b/fe/cba54dc58523434919b66f13a667e36e436deddd77ca519e96553617d4ec/torch-2.13.0-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:e76f9bcecc52b8ff711239a2f7547d5353df95878ab232f0773c1d95928b92f8", size = 111187938, upload-time = "2026-07-08T16:05:17.065Z" }, + { url = "https://files.pythonhosted.org/packages/c2/59/1e3160e18e12aa3038390efab3ce02b36a9d4d6a527ecdd8520dca2e68d8/torch-2.13.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:092790c696a760c729fd5722835f50b9d81fd7c8f141571f3f3cf4081a8f664c", size = 427199369, upload-time = "2026-07-08T16:04:51.054Z" }, + { url = "https://files.pythonhosted.org/packages/01/79/1f2d34ad7034ee1c7ffc1cf8bf0f8213af2a81df6ecdb3997ecec107c09d/torch-2.13.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:60fcdcb2f3876e21146cb4524ef06397d727ca9ad5f020818547e25075fe3cb7", size = 526574961, upload-time = "2026-07-08T16:04:07.075Z" }, + { url = "https://files.pythonhosted.org/packages/6c/fd/0f2ce40f58aefbdb3392f9acce3c8171940943ae2d661f70558bfa73befb/torch-2.13.0-cp311-cp311-win_amd64.whl", hash = "sha256:a0d8b11f16a48d60e2015d8213aa0390744cbebb98e58b62b3514dddc656e330", size = 122015870, upload-time = "2026-07-08T16:05:27.59Z" }, + { url = "https://files.pythonhosted.org/packages/c4/3a/ed0f4d4d1dcde03bced7aac9a28e800abcdc0cbd06b6775044c9fbd877b7/torch-2.13.0-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:2fe228aba290d14b9f31b049be550dbd469c3fd3013d7a19705b30454da97027", size = 111213045, upload-time = "2026-07-08T16:05:22.997Z" }, + { url = "https://files.pythonhosted.org/packages/df/a9/f6a2a4d763ff1df02e9a64c477029db614295bc9367f4131223791ccc243/torch-2.13.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:572df8be8ffb4599c88cbd6a0726f1f854f4da65d2e3c09f0e2c2283333cd6d4", size = 427210998, upload-time = "2026-07-08T16:04:37.708Z" }, + { url = "https://files.pythonhosted.org/packages/f3/82/fea946351658e6534db52d2cc12bc53087cbf87f9440c5f180f367c1950b/torch-2.13.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:796633c4cdf0fe2cdced72d8f88f22e73dbcfce83132763162f6d4bff13b820b", size = 526605292, upload-time = "2026-07-08T16:04:22.81Z" }, + { url = "https://files.pythonhosted.org/packages/21/d6/e8f3c6f7e01f626f77259de9860d2a78bc84c40539e28e79b7e98b0bb659/torch-2.13.0-cp312-cp312-win_amd64.whl", hash = "sha256:024c6cc0c1b085f2f91f20a3dc27b0471d021c31ce84b81be3afdc39f791fd9d", size = 122057313, upload-time = "2026-07-08T16:03:53.43Z" }, + { url = "https://files.pythonhosted.org/packages/0d/fa/c1c10b7aff4a9a3e8956d4f0a5f468fa6db7abc3208805719076772b4833/torch-2.13.0-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:33449899ce5496c1b84b4853179d94fd102028ae1407314d9fb956bb79e70d09", size = 111213743, upload-time = "2026-07-08T16:03:28.579Z" }, + { url = "https://files.pythonhosted.org/packages/11/18/9ecb37b56293a0be8d80f810bf672a72fe7e02f8b475d5ef1b9bf8a0d748/torch-2.13.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:1e09d6a722504957c694faceca843acde562786df1144ebcc5a74075ec7f6005", size = 427213008, upload-time = "2026-07-08T16:03:44.106Z" }, + { url = "https://files.pythonhosted.org/packages/d4/5a/7c50ba1b7b713d71d34669c6d13dab0a11531a3eceb0307a5162dbfec0f7/torch-2.13.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:a3a9a21312872af8a26950b2c15680335a386a1f56ed03e780653d78b9607e9e", size = 526602329, upload-time = "2026-07-08T16:03:12.649Z" }, + { url = "https://files.pythonhosted.org/packages/91/3d/e7adcc6aaf36961cd18f56cf8ad0f3058c3a5c84ccf391762176c94581b8/torch-2.13.0-cp313-cp313-win_amd64.whl", hash = "sha256:49b58f1e2c52440abb6f17c28f0335fe6c6d01ad1a7f55b0183b81e4b34d64e6", size = 122057920, upload-time = "2026-07-08T16:03:01.808Z" }, + { url = "https://files.pythonhosted.org/packages/36/76/6dcc7f0c07052102dd36f83cbc5800842a909c8c3fbf1a7f8a5844954de9/torch-2.13.0-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:d849b390e07d8d333ce8ecaf91b273c656c598379a19c9acf1318a883f6b391c", size = 111227066, upload-time = "2026-07-08T16:03:33.6Z" }, + { url = "https://files.pythonhosted.org/packages/e9/09/2c10e8cd0e00fa5d23c052df6ce467eaa7182399f5e0f824f1e4ff42ccae/torch-2.13.0-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:a3893dc2da0a972a8ca5d698c85a9f967559ac5f8ee1797b77408aa8734d073c", size = 427226309, upload-time = "2026-07-08T16:02:53.127Z" }, + { url = "https://files.pythonhosted.org/packages/76/c6/22c2102bbef14ca6a6cb4c20e42f088e49c5f812be4e160ae57502e325f9/torch-2.13.0-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:49f1ea385c754e54919408a9bb3b5a72b0b755bbe2c916c1d6f70afbec4908a2", size = 526614507, upload-time = "2026-07-08T16:02:16.441Z" }, + { url = "https://files.pythonhosted.org/packages/2b/0c/7d1deb6bce5bc3e6042caf39100ac768eba3b9a098e1dddd16f75bd6489b/torch-2.13.0-cp314-cp314-win_amd64.whl", hash = "sha256:4f8573e3ce9ebcd53fe922f01077a6085ccdfbe5f12fd215883a9d87d7a744fd", size = 122051871, upload-time = "2026-07-08T16:03:23.521Z" }, + { url = "https://files.pythonhosted.org/packages/f4/ce/aa8b7f9949d32e0f2f624f342bc3b48112c1b8a130288465938bc83bcbf9/torch-2.13.0-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:c28def70706c2f9ecc752574766e8ae4da9b810ab6676b611166761a78a9f1e1", size = 111537025, upload-time = "2026-07-08T16:02:44.28Z" }, + { url = "https://files.pythonhosted.org/packages/69/d1/491e3a0389430946145888b0203f2b6a759ce2a61481b96a85c2da4f2ced/torch-2.13.0-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:31061ff56ed8fbf26c749806905aeb749ebeb819810fd5d52508aa5afd90dddc", size = 427219769, upload-time = "2026-07-08T16:02:31.18Z" }, + { url = "https://files.pythonhosted.org/packages/9a/1d/38006e045bf0a1fc28ef01e757c554e59e59a8770c284bc4f47b14e60441/torch-2.13.0-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:cc26eead4cf51d0b544e31e364dcf000846549c273bd148936fe9d24d29acb92", size = 526571320, upload-time = "2026-07-08T16:01:59.348Z" }, + { url = "https://files.pythonhosted.org/packages/56/94/655c91992a882bd5071aa0b5d22a07dbb130d801e872be97c0b627a7c693/torch-2.13.0-cp314-cp314t-win_amd64.whl", hash = "sha256:a7de8a313090dc5c7d7ba4bfe5c3be222528f9a4dba1acc83bddb1157360c4b8", size = 122306773, upload-time = "2026-07-08T16:02:39.832Z" }, +] + +[[package]] +name = "tornado" +version = "6.5.7" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/64/24/95ec527ad67b76d59299e5465b3935d05e4294b7e0290a3924b7487df30b/tornado-6.5.7.tar.gz", hash = "sha256:66c513a76cda70d53907bc27cf1447557699c2e95aa48ba27a442ff61c3ddfc2", size = 519252, upload-time = "2026-06-08T17:34:51.232Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/02/dc/c7043cab6fed8ae159fc1923ce829ada35c4dbd797d408a43858ffaf9639/tornado-6.5.7-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:148b2eb15c2c765a50796172c1e499649b35f30d2e3c3d3e15913cfa56bfb163", size = 448543, upload-time = "2026-06-08T17:34:38.052Z" }, + { url = "https://files.pythonhosted.org/packages/92/4f/090b1431e5a43df696feceffc268c5383cc079ecb5f08ce58f917109aafe/tornado-6.5.7-cp39-abi3-macosx_10_9_x86_64.whl", hash = "sha256:9da38de27f1da3b78a966f0dae12b5a1ea9afe72ca805d84ff06508272ddf100", size = 446707, upload-time = "2026-06-08T17:34:39.594Z" }, + { url = "https://files.pythonhosted.org/packages/37/d8/ef374952fd5da67d4463122c2b8e5a96536ec10b4b339254c6dcde81d01c/tornado-6.5.7-cp39-abi3-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:8d759e71906ee783f8867b93bf26a265743da4c1e2f4a018464c1ba019862972", size = 449774, upload-time = "2026-06-08T17:34:41.204Z" }, + { url = "https://files.pythonhosted.org/packages/35/37/d434c73f4c6e014b745b9b37085f34f40c022f007efff3d7fe65991899f3/tornado-6.5.7-cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8a46347a18f23fb92b396beebe0fb78f61dda0cc302445202c16203d8a18848b", size = 450745, upload-time = "2026-06-08T17:34:42.531Z" }, + { url = "https://files.pythonhosted.org/packages/b6/2b/56b9aff361d7f1ab728a805ec7d7ea835f8807afa9f5cc690ea0e630efb9/tornado-6.5.7-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:7778b30bef919231265e91c69963ce0f49a1e9c07ac900bbe75b19ce2575ba92", size = 450578, upload-time = "2026-06-08T17:34:43.787Z" }, + { url = "https://files.pythonhosted.org/packages/02/30/a7444fb23aa76860a14198fab96ac79f1866b0a6e19e26c4381b0938e50f/tornado-6.5.7-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:e726f0c75da7726eec023aa62751ff8878bd2737e34fbdd33b1ae5897d2200f5", size = 449985, upload-time = "2026-06-08T17:34:45.326Z" }, + { url = "https://files.pythonhosted.org/packages/5c/42/5f0e56c01e8d9d36f4e23f367b85ae6cae0c1ecddd5e6977d8388ad27488/tornado-6.5.7-cp39-abi3-win32.whl", hash = "sha256:f8de3bf12d3efdd0cbe7c8887868198f8a91415e3f29fcf258d9b8eb7b1d9ae4", size = 451047, upload-time = "2026-06-08T17:34:46.784Z" }, + { url = "https://files.pythonhosted.org/packages/c9/a4/b393076ffb21b469eec5b328a0534cf03a3b90bfc6b1f09507cdd075d938/tornado-6.5.7-cp39-abi3-win_amd64.whl", hash = "sha256:de942f843533a039ef9fa3d9c88c7cd8a7c94553fb5ad0154270989b3d99a2c4", size = 451485, upload-time = "2026-06-08T17:34:48.248Z" }, + { url = "https://files.pythonhosted.org/packages/71/2e/7b1c769803121b809112cf9a00681c472eae1d80e32d7ec0e0bd61d0d0e1/tornado-6.5.7-cp39-abi3-win_arm64.whl", hash = "sha256:ff934fce95643af5f11efdae618eaa73d469dc588641e5c8d19295a0c65c4796", size = 450506, upload-time = "2026-06-08T17:34:49.702Z" }, +] + +[[package]] +name = "traitlets" +version = "5.15.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/57/a9/a2584b8313b89f94869ddb3c4074617a691de1812a614d2d50e32ca5a7a6/traitlets-5.15.1.tar.gz", hash = "sha256:7b1c07854fe25acb39e009bae49f11b79ff6cbb2f27999104e9110e7a6b53722", size = 163344, upload-time = "2026-06-03T12:26:06.181Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/96/8d/1080ee4c231f361b6ce4470d556c8c435b67c7e0753aaa641497ee92f88b/traitlets-5.15.1-py3-none-any.whl", hash = "sha256:770a53705f84b81ac107e83a1b3328ff2dae16094d8fc3cfc004e4b22dfd8e92", size = 85858, upload-time = "2026-06-03T12:26:04.395Z" }, +] + +[[package]] +name = "triton" +version = "3.7.1" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7b/f9/19d842d06a08559534fa1eaab6ca551b1bcf40f06620bddec1babaa2772d/triton-3.7.1-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d4a0e1cd4c4a76370ed74a8432a53cea28716827d19e40ffc732233e35ceb3f6", size = 184664887, upload-time = "2026-06-17T20:03:42.913Z" }, + { url = "https://files.pythonhosted.org/packages/cd/5e/fce69606f7f240297f163e25539906732b199530d486ce67ae319877e821/triton-3.7.1-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6744957e9fd610a29680ec2346057d0c86948ed3812468670719f391e94b44a5", size = 197701306, upload-time = "2026-06-17T19:53:13.673Z" }, + { url = "https://files.pythonhosted.org/packages/94/fa/f856e24deb462d5f18bd4b5a746957862ab9b6ee5834bda60605ec348366/triton-3.7.1-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9497f2e696ee368862a181a90b2dcc03ca978cc4f602abd67c7d81022a6988e1", size = 184692359, upload-time = "2026-06-17T20:03:48.288Z" }, + { url = "https://files.pythonhosted.org/packages/c4/6f/fb96d15db6f36d6eae4cafb998c2e0353bf59d7c4ea1662d7497f269134a/triton-3.7.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7e40869937a68206ec70d7f25bb7ec6433cb083f9135e1f36dbd318dc449a728", size = 197719725, upload-time = "2026-06-17T19:53:20.419Z" }, + { url = "https://files.pythonhosted.org/packages/00/42/c5089d4d9327fcd1e862c599cc2927f39418f84dd11a84cb2ccff9d4787a/triton-3.7.1-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:cdbfc09d9ec58bc5e68321525653220de7515c199e7a8097a97c85e62b52cd0a", size = 184694629, upload-time = "2026-06-17T20:03:53.444Z" }, + { url = "https://files.pythonhosted.org/packages/07/42/2c3ac59253ae8892b6f307875263dd23dc875cdf732d3aea40d6d41fb7cb/triton-3.7.1-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:58c0e131da05134a2a4788ccbcc0c1105cf0f54c8e98f19e34cd465396dc15eb", size = 197729241, upload-time = "2026-06-17T19:53:27.801Z" }, + { url = "https://files.pythonhosted.org/packages/40/71/e01aa7ad573883ed9456f130226babdec70b005e098c4d6226a6238e761b/triton-3.7.1-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fe4ea396a06171f1f1f58cbd39c70b09294398f7dd7c620939bab54ad6f934fa", size = 184705764, upload-time = "2026-06-17T20:03:59.064Z" }, + { url = "https://files.pythonhosted.org/packages/a4/09/5683146fda6a2b569deb78ccfd8fbfea8bfe55f726b081c0a6bb18dd6f28/triton-3.7.1-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2020153b08280415ec0da6607834e79166442147e78e144df06b508c75b186d2", size = 197729537, upload-time = "2026-06-17T19:53:35.516Z" }, + { url = "https://files.pythonhosted.org/packages/e9/f8/448220c3092019f9fdfab39ec47985968181d67da34b44f6a7f6280a5cbb/triton-3.7.1-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c58e4c61f0c73b5dba3b5d19b4a7093c32f90dc18b2a7f121a7c16ccd31107b7", size = 184814760, upload-time = "2026-06-17T20:04:04.984Z" }, + { 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 = "typing-extensions" +version = "4.16.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f6/cc/6253133b5bb138fc3306cebfbda2c520f545d36b5be2c7255cc528bb45d6/typing_extensions-4.16.0.tar.gz", hash = "sha256:dc983d19a509c94dba722ee6abd33940f7c05a89e243c47e907eb4db6f1a43e5", size = 113555, upload-time = "2026-07-02T08:40:05.92Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/49/d3/b8441a820a491ddfc024b0b0cf0393375b75ea13866d9c66727e54c2fc80/typing_extensions-4.16.0-py3-none-any.whl", hash = "sha256:481caa481374e813c1b176ada14e97f1f67a4539ce9cfeb3f350d78d6370c2e8", size = 45571, upload-time = "2026-07-02T08:40:04.659Z" }, +] + +[[package]] +name = "wcwidth" +version = "0.8.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/34/74/c6428f875774288bec1396f5bfcbc2d925700a4dad61727fd5f2b12f249d/wcwidth-0.8.2.tar.gz", hash = "sha256:91fbef97204b96a3d4d421609b80340b760cf33e26da123ff243d76b1fda8dda", size = 1466253, upload-time = "2026-06-29T18:11:11.601Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/96/42/3e5985a0a7e57de470b320c6d6a1a67c844f6737a587f3d44dd13d1819e7/wcwidth-0.8.2-py3-none-any.whl", hash = "sha256:d63947694a0539a1d51e01eda7caf800c291020e6cdd7e28ad7b14dd33ad4f85", size = 323166, upload-time = "2026-06-29T18:11:09.888Z" }, +]