diff --git a/.github/workflows/pytest.yaml b/.github/workflows/pytest.yaml index d057cc2..01875fb 100644 --- a/.github/workflows/pytest.yaml +++ b/.github/workflows/pytest.yaml @@ -1,13 +1,36 @@ name: Run tests +# Triggers cover both `master` and `main` so CI keeps working through the +# default-branch rename (master -> main); drop `master` after the rename. on: push: branches: - - master - main + - master pull_request: jobs: + lint: + name: lint (ruff + mypy) + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + with: + fetch-depth: 0 + + - uses: prefix-dev/setup-pixi@v0.9.1 + with: + environments: lint + + - name: ruff check + run: pixi run -e lint lint + + - name: ruff format --check + run: pixi run -e lint format-check + + - name: mypy + run: pixi run -e lint typecheck + test: name: ${{ matrix.os }}-${{ matrix.dependencies }} runs-on: ${{ matrix.os }} diff --git a/.gitignore b/.gitignore index f8750ea..ef1bc34 100644 --- a/.gitignore +++ b/.gitignore @@ -50,3 +50,7 @@ papers/ SESSION_NOTES.md REVIEW_2026-07.md MCP_PLAN.md +ISSUE_REPLIES.md + +# Local AI-session handoff notes (not tracked) +.ai/ diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml new file mode 100644 index 0000000..34db521 --- /dev/null +++ b/.pre-commit-config.yaml @@ -0,0 +1,10 @@ +# Contributor convenience: `pip install pre-commit && pre-commit install`. +# CI enforces the same checks via the `lint` job (ruff check + format + mypy). +repos: + - repo: https://github.com/astral-sh/ruff-pre-commit + # Keep close to the CI lint env's ruff so pre-commit and CI agree on formatting. + rev: v0.15.21 + hooks: + - id: ruff-check + args: [--fix] + - id: ruff-format diff --git a/AGENTS.md b/AGENTS.md index 635468e..578ad49 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -4,32 +4,36 @@ Guidance for AI agents and human contributors working in this repo. (`CLAUDE.md` ## Project Structure & Module Organization Core library in `src/tcpyPI/`: -- `pi.py` — the BE02 PI algorithm (`pi()`, `cape()`, entropy solver). Numba-compiled. -- `utilities.py` — thermodynamic helpers, unit/longitude conversions, PI efficiency/disequilibrium. -- `constants.py` — meteorological constants; `numba.py` — the `@njit` wrapper. -- `analyses.py` — Wing et al. (2015) PI log-decomposition API. -- `vi.py` — TE12 ventilation index + entropy-deficit (`chi_m`). `gpi.py` — genesis potential index (`en04`, `e10`). `pdi.py` — power dissipation index. `relative_intensity.py` — ν = V/V_PI. (VI/GPI/PDI are experimental.) +- `pi.py` — the BE02 PI algorithm (`pi()`, `cape()`, entropy solver), the whole-field fast path `pi_field()` (parallel guvectorize; ~2 orders of magnitude over per-column loops), and the Wing et al. (2015) log-decomposition `pi_log_decomposition()`. Numba-compiled. `cape()` keeps the original pcmin.m per-call structure line-for-line (an environment-setup hoist was certified bit-identical but reverted: negligible speed gain did not justify structural drift from the MATLAB reference). +- `utilities.py` — thermodynamic helpers, unit/longitude conversions, PI efficiency/disequilibrium (`decompose_pi` scalar core). +- `constants.py` — meteorological constants (fully documented, incl. the deliberate modified `CL=2500`); `numba.py` — the `@njit`/`guvectorize` wrapper (graceful pure-Python fallback when Numba is absent). +- `vi.py` — TE12 ventilation index + entropy-deficit (`chi_m`) + `vi_log_decomposition`. `gpi.py` — genesis potential index (`en04`, `e10`) + `gpi_log_decomposition`. `pdi.py` — power dissipation index. `relative_intensity.py` — ν = V/V_PI. (VI/GPI/PDI are experimental.) Sample workflow in `run_sample.py` (writes `data/raw_sample_output.nc`, `data/full_sample_output.nc`). Tests in `tests/`. Notebooks in `notebooks/`; figures in `figures/`; legacy BE02 MATLAB in `matlab_scripts/`. ## Build, Test, and Development Commands -- `pip install -e .` (Python 3.10+). Optional extras: `.[xarray]`, `.[demo]`. -- Tests use pixi. **Note:** a stale `pixi` shim may shadow the real binary — use `~/.pixi/bin/pixi` if `pixi` fails with a module error. - - `pixi run -e test-latest basic-tests` — core suite + doctests (49 tests). - - `pixi run -e test-xarray-latest xarray-tests` — sample-output regression (2 tests). - - `pixi run -e test-min basic-tests` — minimum supported floor (py3.10 / numpy 1.26 / numba 0.59). +- `pip install -e .` (Python 3.11+). Optional extras: `.[xarray]`, `.[demo]`. +- Tests and tooling use pixi. **Note:** a stale `pixi` shim may shadow the real binary — use `~/.pixi/bin/pixi` if `pixi` fails with a module error. + - `pixi run -e test-latest basic-tests` — core suite + doctests. + - `pixi run -e test-xarray-latest xarray-tests` — sample-output regression (rtol=1e-13 pins). + - `pixi run -e test-min basic-tests` — minimum supported floor (py3.11 / numpy 1.26 / numba 0.59). +- Lint/format/type-check (enforced by the CI `lint` job on every push/PR): + - `pixi run -e lint lint` (ruff check) · `pixi run -e lint format-check` / `format` (ruff format) · `pixi run -e lint typecheck` (mypy). + - Contributors can also `pip install pre-commit && pre-commit install` (ruff + ruff-format hooks). - Data: `pixi run download-era5` (needs a CDS API key in `~/.cdsapirc`) then `pixi run build-sample` regenerates `data/sample_data.nc` + `data/era5_demo_subset.nc`. `python run_sample.py` regenerates the output artifacts. +- Benchmarks: the `bench` pixi env adds Skyborn for the optional comparison in `notebooks/clock_pypi.ipynb`. To run that notebook in JupyterHub, register the env as a kernel: `pixi run -e bench python -m ipykernel install --user --name tcpypi-bench --display-name "tcpyPI (bench)"`. ## Data Policy -- Track only the small samples (`sample_data.nc` ~6 MB, `era5_demo_subset.nc`, run_sample outputs). `.gitignore` uses an explicit allowlist — do **not** commit raw ERA5 downloads or other large `.nc`. -- The tracked sample is regional (North Atlantic), subsampled to ~2° (decimation, no interpolation), SST masked to ocean. Regenerate a wider/global sample by widening the `area` in `data/download_era5.py`. +- Track only the small samples (`sample_data.nc` ~6 MB, `era5_demo_subset.nc`, run_sample outputs, the MATLAB reference). `.gitignore` uses an explicit allowlist — do **not** commit raw ERA5 downloads or other large `.nc`. +- The tracked sample is regional (North Atlantic 2024), subsampled to ~2° (decimation, no interpolation), SST masked to ocean; humidity is stored as the **true water-vapor mixing ratio `r`** (converted from ERA5 specific humidity via `r = q/(1−q)`), with ERA5 relative humidity as `rh`. Regenerate a wider/global sample by widening the `area` in `data/download_era5.py`. ## Coding Style & Scientific Invariants -- PEP 8, 4-space indent, snake_case. Document units for scientific quantities; prefer keyword args for flags. +- PEP 8 via ruff (line length 100); snake_case. Document units for scientific quantities; prefer keyword-only args for flags on new APIs (see `pi_field`). - **Never enable Numba `fastmath`** anywhere: the PI/CAPE missing-value logic relies on IEEE NaN semantics (`NaN > 0` is False, min/max NaN propagation). `@njit` already defaults to `cache=True` (see `numba.py`); don't remove it. -- `pi()` expects SST/T in °C, MSL/P in hPa, mixing ratio in g/kg, profiles ordered surface→top (the wrapper now sorts to descending pressure, so any order is accepted). -- Keep changes test-pinned: `pi()` doctests pin outputs to ~13 sig figs; `tests/test_run_sample.py` pins the sample outputs at `rtol=1e-13`. +- **Kernel-change policy (bit-for-bit identicality):** the compiled PI/CAPE kernels implement the published GMD-2021/pcmin algorithm and any change to them must be *math-by-math identical* — proven, not asserted. Acceptable transforms: selections (scalar `min`/`max` with preserved argument order), hoisting/deduplicating pure computations, memory-layout changes. **Never** reorder/reassociate arithmetic. Certify with the byte-equality harness (`.ai/bit_identity_harness.py`: old-commit worktree vs working tree over the full sample × option combos through both entry points, direct `cape()` calls, and a 50k fuzz corpus), and re-certify on the final post-`ruff format` bytes. +- `pi()`/`pi_field()` expect SST/T in °C, MSL/P in hPa, mixing ratio in g/kg; any vertical profile order is accepted (sorted internally to decreasing pressure). NaN P/MSL → `IFL=3`; NaN SST → `IFL=0`; period-2 solver oscillations with amplitude ≲1 hPa are rescued to the cycle midpoint (`IFL=1`; documented divergence from pcmin.m, which returns missing for those soundings). Flags tripped by the environmental-CAPE call persist (#78), so `IFL∈{0,3}` can accompany finite outputs — **`IFL==1` is the trustworthy-output gate**. +- Keep changes test-pinned: `pi()` doctests pin outputs to ~13 sig figs; `tests/test_run_sample.py` pins the sample outputs at `rtol=1e-13`; `tests/test_oscillation_rescue.py` pins bit-identity of a converging control profile; `tests/test_pi_field.py` pins `pi_field == pi` exact equality. ## Commit & Pull Request Guidelines - Imperative commit summaries; group related changes. Reference issues/PRs; note any data or API changes. -- Run `basic-tests` (and `xarray-tests` when touching `run_sample.py`/data) before pushing. Do not commit large binaries. +- Before pushing, run `basic-tests`, the lint tasks, and (when touching `run_sample.py`/data) `xarray-tests`. Do not commit large binaries. diff --git a/README.md b/README.md index 90b869c..a122a22 100644 --- a/README.md +++ b/README.md @@ -14,7 +14,7 @@ The goals in developing and maintaining pyPI are to: * carefully document the BE02 algorithm and its Python implementation, and to * demonstrate and encourage the use of potential intensity theory in tropical cyclone climatology analysis. -If you have any questions, comments, or feedback, please [contact the developer](mailto:dgilford@climatecentral.org) or open an [Issue](https://github.com/dgilford/pyPI/issues) in the repository. A paper detailing pyPI is published [at Geoscientific Model Development](https://gmd.copernicus.org/articles/14/2351/2021/gmd-14-2351-2021.pdf). +If you have any questions, comments, or feedback, please [contact the developer](mailto:dgilford@climatecentral.org) or open an [Issue](https://github.com/dgilford/tcpyPI/issues) in the repository. A paper detailing pyPI is published [at Geoscientific Model Development](https://gmd.copernicus.org/articles/14/2351/2021/gmd-14-2351-2021.pdf). ## Citation pyPI was developed by [Daniel Gilford](https://github.com/dgilford) and is archived on Zenodo. A machine-readable [`CITATION.cff`](CITATION.cff) is included. @@ -39,21 +39,26 @@ The description includes the pyPI background, a PI computation derivation, valid ## Getting Started -pyPI requires **Python 3.10+** to run. +pyPI requires **Python 3.11+** to run. To get pyPI up and running on your system, clone the repository and ensure that you have the required dependencies. ### Installation -pyPI is packaged using the python package manager [pip](https://pip.pypa.io/en/stable/). - [![PyPI version](https://badge.fury.io/py/tcpypi.svg)](https://badge.fury.io/py/tcpypi) +[![conda-forge](https://img.shields.io/conda/vn/conda-forge/tcpypi.svg)](https://anaconda.org/conda-forge/tcpypi) -To install tcpypi from the command line: +Install from [PyPI](https://pypi.org/project/tcpypi/): ```bash pip install tcpypi ``` +or from [conda-forge](https://anaconda.org/conda-forge/tcpypi): + +```bash +conda install -c conda-forge tcpypi +``` + ### tcpyPI Dependencies Core (installed automatically): [NumPy](https://numpy.org/) (`>=1.26`) and [Numba](http://numba.pydata.org/) (`>=0.59`). @@ -93,7 +98,7 @@ from tcpyPI import pi ds = xr.open_dataset("data/sample_data.nc") # dims: month, p, lat, lon vmax, pmin, ifl, t0, otl = xr.apply_ufunc( - pi, ds.sst, ds.msl, ds.p, ds.t, ds.q, + pi, ds.sst, ds.msl, ds.p, ds.t, ds.r, kwargs=dict(CKCD=0.9), input_core_dims=[[], [], ["p"], ["p"], ["p"]], output_core_dims=[[], [], [], [], []], @@ -289,11 +294,12 @@ and examine the outputs locally produced in [full_sample_output.nc](./data/full_ * **[run_sample.py](run_sample.py)** - Example script that computes PI and accompanying analyses over the entire sample dataset #### Data -* [sample_data.nc](./data/sample_data.nc) - Sample state variables from ERA5 2024 monthly means over the North Atlantic (12 months; ~2° subsample; SST masked to ocean). Includes the core PI inputs (SST, MSL, T, q) plus winds, RH, and vorticity for the GPI/ventilation-index analyses. Built by [data/build_sample_data_era5_oct2024.py](./data/build_sample_data_era5_oct2024.py) from the (untracked, regenerable) ERA5 downloads. +* [sample_data.nc](./data/sample_data.nc) - Sample state variables from ERA5 2024 monthly means over the North Atlantic (12 months; ~2° subsample; SST masked to ocean). Includes the core PI inputs (SST, MSL, T, and the true water-vapor mixing ratio `r = q/(1−q)` converted from ERA5 specific humidity) plus winds, RH, and vorticity for the GPI/ventilation-index analyses. Built by [data/build_sample_data_era5_oct2024.py](./data/build_sample_data_era5_oct2024.py) from the (untracked, regenerable) ERA5 downloads. * [era5_demo_subset.nc](./data/era5_demo_subset.nc) - Small single-column ERA5 environment (Hurricane Milton 2024 reference location) used by the ventilation-index and GPI demo notebooks. * [mdr.json](./data/mdr.json) - Main Development Region definitions from [Gilford et al. (2017)](https://journals.ametsoc.org/doi/abs/10.1175/JCLI-D-16-0827.1) * [raw_sample_output.nc](./data/raw_sample_output.nc) - Sample outputs from pi.py *only*, created by run_sample.py * [full_sample_output.nc](./data/full_sample_output.nc) - Full set of sample outputs from pi.py plus analyses (efficiency, disequilibrium, log decomposition) +* [matlab_pi_reference_2024.nc](./data/matlab_pi_reference_2024.nc) - BE02 MATLAB (pc_min) reference outputs for the 2024 sample, generated by [reference_calculations.m](./matlab_scripts/reference_calculations.m) and used by verify_pi.ipynb #### Validation and Testing Notebooks * **[test_pi_calc.ipynb](./notebooks/test_pi_calc.ipynb)** - Single call of pi.py on the 2024 sample plus a quick run-time check diff --git a/data/build_sample_data_era5_oct2024.py b/data/build_sample_data_era5_oct2024.py index e23e8bf..d0baa8a 100644 --- a/data/build_sample_data_era5_oct2024.py +++ b/data/build_sample_data_era5_oct2024.py @@ -13,7 +13,7 @@ from __future__ import annotations import argparse -from datetime import datetime, timezone +from datetime import UTC, datetime from pathlib import Path import numpy as np @@ -22,7 +22,9 @@ from tcpyPI.utilities import convert_lon_to360 -def _subset_latlon(ds: xr.Dataset, lat_min: float, lat_max: float, lon_min: float, lon_max: float) -> xr.Dataset: +def _subset_latlon( + ds: xr.Dataset, lat_min: float, lat_max: float, lon_min: float, lon_max: float +) -> xr.Dataset: lat = ds["lat"] lon = ds["lon"] @@ -55,9 +57,10 @@ def build_sample_data( Handles any number of monthly-mean time steps: the ``valid_time`` axis is mapped to an integer ``month`` coordinate (1-12), so a 12-month 2024 download yields a full seasonal cycle and a single-month download yields a one-element ``month`` - axis. Includes the wind/humidity/vorticity fields (``u, v, r, vo``) needed for the - seasonal GPI/ventilation-index analyses alongside the core PI inputs - (``sst, msl, t, q``). + axis. Includes the wind/humidity/vorticity fields (``u, v, rh, vo``) needed for + the seasonal GPI/ventilation-index analyses alongside the core PI inputs + (``sst, msl, t, r`` — with ``r`` the true water-vapor mixing ratio converted + from ERA5 specific humidity via ``r = q/(1-q)``; see GitHub issue #60). Spatial resolution is reduced by strided subsampling (decimation, no interpolation) with ``subsample_factor`` (8 -> ~2 deg from ERA5's 0.25 deg); the @@ -91,7 +94,10 @@ def build_sample_data( # gridpoint values (no interpolation/averaging). Use xESMF if conservative # regridding is ever needed instead. if subsample_factor > 1: - sub = {"lat": slice(None, None, subsample_factor), "lon": slice(None, None, subsample_factor)} + sub = { + "lat": slice(None, None, subsample_factor), + "lon": slice(None, None, subsample_factor), + } pl = pl.isel(sub) sl = sl.isel(sub) @@ -112,44 +118,49 @@ def build_sample_data( "sst": sst_c, "msl": sl["msl"] / 100.0, "t": pl["t"] - 273.15, - "q": pl["q"] * 1000.0, + # True water-vapor mixing ratio from ERA5 specific humidity: + # r = q/(1-q), converted to g/kg (matches pi()'s documented R input; + # see GitHub issue #60). + "r": (pl["q"] / (1.0 - pl["q"])) * 1000.0, "u": pl["u"], "v": pl["v"], - "r": pl["r"], + "rh": pl["r"], "vo": pl["vo"], }, attrs={ "title": "pyPI sample dataset (ERA5 monthly means, 2024)", "source": f"{pl_path.name} + {sl_path.name}", - "history": f"{datetime.now(timezone.utc).isoformat()}: created by data/build_sample_data_era5_oct2024.py", + "history": f"{datetime.now(UTC).isoformat()}: created by data/build_sample_data_era5_oct2024.py", "notes": ( - "Core PI inputs in pyPI units: SST/T in C, MSL in hPa, q in g/kg " - "(specific humidity used directly as the mixing-ratio input, following " - "the original pyPI sample convention). u/v [m/s], r [%], vo [s^-1] are " - "included for the seasonal GPI/ventilation-index analyses. Native ERA5 " - "0.25deg subsampled (decimated) to ~2deg; SST masked to ocean " + "Core PI inputs in pyPI units: SST/T in C, MSL in hPa, r in g/kg " + "(true water-vapor mixing ratio, r = q/(1-q) from ERA5 specific " + "humidity). u/v [m/s], rh [%], vo [s^-1] are included for the " + "seasonal GPI/ventilation-index analyses. Native ERA5 0.25deg " + "subsampled (decimated) to ~2deg; SST masked to ocean " "(land fraction < 0.5)." ), }, ) - out["month"].attrs.update({"standard_name": "Month", "units": "month number (1-12)"}) + out["month"].attrs.update({"long_name": "calendar month of 2024 (1-12)", "units": "1"}) out["p"].attrs.update({"standard_name": "Atmospheric Pressure", "units": "hPa"}) out["lat"].attrs.update({"standard_name": "Latitude", "units": "degrees_north"}) out["lon"].attrs.update({"standard_name": "Longitude", "units": "degrees_east"}) - out["lsm"].attrs.update({ - "standard_name": "land_area_fraction", - "long_name": "Land fraction (native ERA5 land-sea mask at the subsampled points)", - "units": "1", - }) + out["lsm"].attrs.update( + { + "standard_name": "land_area_fraction", + "long_name": "Land fraction (native ERA5 land-sea mask at the subsampled points)", + "units": "1", + } + ) out["sst"].attrs.update({"standard_name": "Sea Surface Temperature", "units": "degrees C"}) out["msl"].attrs.update({"standard_name": "Mean Sea Level Pressure", "units": "hPa"}) out["t"].attrs.update({"standard_name": "Atmospheric Temperature", "units": "degrees C"}) - out["q"].attrs.update({"standard_name": "Specific Humidity", "units": "g/kg"}) + out["r"].attrs.update({"standard_name": "Water Vapor Mixing Ratio", "units": "g/kg"}) out["u"].attrs.update({"standard_name": "Eastward Wind", "units": "m/s"}) out["v"].attrs.update({"standard_name": "Northward Wind", "units": "m/s"}) - out["r"].attrs.update({"standard_name": "Relative Humidity", "units": "%"}) + out["rh"].attrs.update({"standard_name": "Relative Humidity", "units": "%"}) out["vo"].attrs.update({"standard_name": "Relative Vorticity", "units": "s-1"}) encoding = {var: {"zlib": True, "complevel": 4} for var in out.data_vars} @@ -190,16 +201,18 @@ def build_era5_demo_subset( # single-month October file. pl_full = xr.open_dataset(pl_path)[["t", "q", "u", "v", "r", "vo"]] # Normalize longitude to 0-360 (a regional `area` download returns -180..180). - pl_full = pl_full.assign_coords(longitude=convert_lon_to360(pl_full["longitude"])).sortby("longitude") + pl_full = pl_full.assign_coords(longitude=convert_lon_to360(pl_full["longitude"])).sortby( + "longitude" + ) oct_idx = int(np.argmax(pl_full["valid_time"].dt.month.values == 10)) pl = pl_full.isel(valid_time=oct_idx, drop=True) pl = pl.drop_vars(["number", "expver"], errors="ignore") - pl = pl.sortby("pressure_level", ascending=False).sel( - pressure_level=slice(p_max, p_min) - ) + pl = pl.sortby("pressure_level", ascending=False).sel(pressure_level=slice(p_max, p_min)) sl_full = xr.open_dataset(sl_path)[["sst", "msl"]] - sl_full = sl_full.assign_coords(longitude=convert_lon_to360(sl_full["longitude"])).sortby("longitude") + sl_full = sl_full.assign_coords(longitude=convert_lon_to360(sl_full["longitude"])).sortby( + "longitude" + ) sl_oct = int(np.argmax(sl_full["valid_time"].dt.month.values == 10)) sl = sl_full.isel(valid_time=sl_oct, drop=True) sl = sl.drop_vars(["number", "expver"], errors="ignore") @@ -218,8 +231,7 @@ def build_era5_demo_subset( "milton_lon_convention": "degrees_east (0-360)", "milton_time": milton_time, "units_note": ( - "Native ERA5 units: t[K], q[kg/kg], u/v[m/s], r[%], vo[s^-1], " - "sst[K], msl[Pa]." + "Native ERA5 units: t[K], q[kg/kg], u/v[m/s], r[%], vo[s^-1], sst[K], msl[Pa]." ), "caveat": ( "This is an October-2024 MONTHLY-MEAN (climatological) column - a valid " @@ -248,8 +260,12 @@ def main() -> None: parser = argparse.ArgumentParser( description="Build the pyPI 2024 sample and demo subset from ERA5 monthly means." ) - parser.add_argument("--pl", default="data/era5_pl_monthlymeans_2024.nc", help="Pressure-level ERA5 NetCDF") - parser.add_argument("--sl", default="data/era5_sl_monthlymeans_2024.nc", help="Single-level ERA5 NetCDF") + parser.add_argument( + "--pl", default="data/era5_pl_monthlymeans_2024.nc", help="Pressure-level ERA5 NetCDF" + ) + parser.add_argument( + "--sl", default="data/era5_sl_monthlymeans_2024.nc", help="Single-level ERA5 NetCDF" + ) parser.add_argument("--out", default="data/sample_data.nc", help="Output NetCDF path") parser.add_argument( "--demo-out", @@ -260,8 +276,18 @@ def main() -> None: parser.add_argument("--lat-max", type=float, default=50.0) parser.add_argument("--lon-min", type=float, default=250.0) parser.add_argument("--lon-max", type=float, default=320.0) - parser.add_argument("--subsample", type=int, default=8, help="Strided decimation factor for lat/lon (8 -> ~2 deg from 0.25; 1 = full native)") - parser.add_argument("--land-frac-max", type=float, default=0.5, help="Mask SST where land fraction >= this (ocean-only PI)") + parser.add_argument( + "--subsample", + type=int, + default=8, + help="Strided decimation factor for lat/lon (8 -> ~2 deg from 0.25; 1 = full native)", + ) + parser.add_argument( + "--land-frac-max", + type=float, + default=0.5, + help="Mask SST where land fraction >= this (ocean-only PI)", + ) parser.add_argument("--p-min", type=float, default=50.0) parser.add_argument("--p-max", type=float, default=1000.0) args = parser.parse_args() @@ -294,4 +320,3 @@ def main() -> None: if __name__ == "__main__": main() - diff --git a/data/download_era5.py b/data/download_era5.py index 8d780a0..7b8c248 100644 --- a/data/download_era5.py +++ b/data/download_era5.py @@ -14,23 +14,58 @@ request = { "product_type": ["monthly_averaged_reanalysis"], "variable": [ - "temperature", # t -> TC (after K->C) - "specific_humidity", # q -> R (g/kg) + "temperature", # t -> TC (after K->C) + "specific_humidity", # q -> R (g/kg) "u_component_of_wind", # u (shear, hodograph) "v_component_of_wind", # v (shear, hodograph) - "relative_humidity", # r (GPI en04 midlevel RH) - "vorticity", # vo (GPI absolute vorticity) + "relative_humidity", # r (GPI en04 midlevel RH) + "vorticity", # vo (GPI absolute vorticity) ], "pressure_level": [ - "50", "70", "100", "125", "150", "175", "200", "225", "250", - "300", "350", "400", "450", "500", "550", "600", "650", "700", - "750", "775", "800", "825", "850", "875", "900", "925", "950", - "975", "1000", + "50", + "70", + "100", + "125", + "150", + "175", + "200", + "225", + "250", + "300", + "350", + "400", + "450", + "500", + "550", + "600", + "650", + "700", + "750", + "775", + "800", + "825", + "850", + "875", + "900", + "925", + "950", + "975", + "1000", ], "year": ["2024"], "month": [ - "01", "02", "03", "04", "05", "06", - "07", "08", "09", "10", "11", "12", + "01", + "02", + "03", + "04", + "05", + "06", + "07", + "08", + "09", + "10", + "11", + "12", ], "time": ["00:00"], # North Atlantic region [North, West, South, East] (lon in -180..180): diff --git a/data/download_era5_sl.py b/data/download_era5_sl.py index 4067976..67be00e 100644 --- a/data/download_era5_sl.py +++ b/data/download_era5_sl.py @@ -14,14 +14,24 @@ request = { "product_type": ["monthly_averaged_reanalysis"], "variable": [ - "sea_surface_temperature", # sst -> SSTC (after K->C) - "mean_sea_level_pressure", # msl -> MSL (after Pa->hPa) - "land_sea_mask", # lsm (land fraction after coarsening) + "sea_surface_temperature", # sst -> SSTC (after K->C) + "mean_sea_level_pressure", # msl -> MSL (after Pa->hPa) + "land_sea_mask", # lsm (land fraction after coarsening) ], "year": ["2024"], "month": [ - "01", "02", "03", "04", "05", "06", - "07", "08", "09", "10", "11", "12", + "01", + "02", + "03", + "04", + "05", + "06", + "07", + "08", + "09", + "10", + "11", + "12", ], "time": ["00:00"], # North Atlantic region [North, West, South, East] (lon in -180..180). diff --git a/data/full_sample_output.nc b/data/full_sample_output.nc index d18c4de..16ee561 100644 Binary files a/data/full_sample_output.nc and b/data/full_sample_output.nc differ diff --git a/data/matlab_pi_reference_2024.nc b/data/matlab_pi_reference_2024.nc index d98b482..542a43d 100644 Binary files a/data/matlab_pi_reference_2024.nc and b/data/matlab_pi_reference_2024.nc differ diff --git a/data/raw_sample_output.nc b/data/raw_sample_output.nc index 1be66e1..6af7b72 100644 Binary files a/data/raw_sample_output.nc and b/data/raw_sample_output.nc differ diff --git a/data/sample_data.nc b/data/sample_data.nc index d830814..d4925e1 100644 Binary files a/data/sample_data.nc and b/data/sample_data.nc differ diff --git a/matlab_scripts/reference_calculations.m b/matlab_scripts/reference_calculations.m index bfb09e8..43878c1 100644 --- a/matlab_scripts/reference_calculations.m +++ b/matlab_scripts/reference_calculations.m @@ -31,7 +31,7 @@ end out_file = fullfile(out_dir, 'matlab_pi_reference_2024.nc'); -%% Load the pyPI sample (already in pyPI units: SST/T in C, MSL in hPa, q in g/kg) +%% Load the pyPI sample (already in pyPI units: SST/T in C, MSL in hPa, r in g/kg) p = ncread(in_file, 'p'); % [np] hPa lat = ncread(in_file, 'lat'); % [nlat] degrees north @@ -40,7 +40,7 @@ sst = ncread(in_file, 'sst'); % [nlon,nlat,nmon] C (NaN over land) msl = ncread(in_file, 'msl'); % [nlon,nlat,nmon] hPa T = ncread(in_file, 't'); % [nlon,nlat,np,nmon] C -q = ncread(in_file, 'q'); % [nlon,nlat,np,nmon] g/kg +r = ncread(in_file, 'r'); % [nlon,nlat,np,nmon] g/kg (water-vapor mixing ratio) nlon = length(lon); nlat = length(lat); nmon = length(month); @@ -60,7 +60,7 @@ if (~isnan(sst(x, y, m)) && sst(x, y, m) > 0) [PMIN(x, y, m), VMAX(x, y, m), TO(x, y, m), LNB(x, y, m), IFL(x, y, m)] = ... pc_min(squeeze(sst(x, y, m)), squeeze(msl(x, y, m)), ... - squeeze(p), squeeze(T(x, y, :, m)), squeeze(q(x, y, :, m))); + squeeze(p), squeeze(T(x, y, :, m)), squeeze(r(x, y, :, m))); end end end diff --git a/notebooks/clock_pypi.ipynb b/notebooks/clock_pypi.ipynb index 5492dd8..0afed12 100644 --- a/notebooks/clock_pypi.ipynb +++ b/notebooks/clock_pypi.ipynb @@ -50,7 +50,7 @@ "import time\n", "import random\n", "# load PI calculation module\n", - "from tcpyPI import pi" + "from tcpyPI import pi, pi_field" ] }, { @@ -88,9 +88,9 @@ "output_type": "stream", "text": [ "First pi() call in a fresh Python process:\n", - " no cache (must compile): 3.17 s\n", - " cached (cache=True): 0.25 s\n", - " speedup from caching: 13x\n" + " no cache (must compile): 1.93 s\n", + " cached (cache=True): 0.01 s\n", + " speedup from caching: 302x\n" ] } ], @@ -138,7 +138,16 @@ "cell_type": "code", "execution_count": 4, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/dgilford/tcpyPI/.pixi/envs/bench/lib/python3.14/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + } + ], "source": [ "# data location\n", "dat_loc = repo_root / \"data\" / \"sample_data.nc\"\n", @@ -169,9 +178,7 @@ "\n", "\n", "\n", - "
<xarray.Dataset> Size: 8MB\n",
        "Dimensions:  (lat: 26, lon: 36, month: 12, p: 29)\n",
        "Coordinates:\n",
@@ -540,32 +467,32 @@
        "    sst      (month, lat, lon) float32 45kB ...\n",
        "    msl      (month, lat, lon) float32 45kB ...\n",
        "    t        (month, p, lat, lon) float32 1MB ...\n",
-       "    q        (month, p, lat, lon) float32 1MB ...\n",
+       "    r        (month, p, lat, lon) float32 1MB ...\n",
        "    u        (month, p, lat, lon) float32 1MB ...\n",
        "    v        (month, p, lat, lon) float32 1MB ...\n",
-       "    r        (month, p, lat, lon) float32 1MB ...\n",
+       "    rh       (month, p, lat, lon) float32 1MB ...\n",
        "    vo       (month, p, lat, lon) float32 1MB ...\n",
        "Attributes:\n",
        "    title:    pyPI sample dataset (ERA5 monthly means, 2024)\n",
        "    source:   era5_pl_monthlymeans_2024.nc + era5_sl_monthlymeans_2024.nc\n",
-       "    history:  2026-07-10T22:33:41.949974+00:00: created by data/build_sample_...\n",
-       "    notes:    Core PI inputs in pyPI units: SST/T in C, MSL in hPa, q in g/kg...
  • title :
    pyPI sample dataset (ERA5 monthly means, 2024)
    source :
    era5_pl_monthlymeans_2024.nc + era5_sl_monthlymeans_2024.nc
    history :
    2026-07-11T16:30:08.453192+00:00: created by data/build_sample_data_era5_oct2024.py
    notes :
    Core PI inputs in pyPI units: SST/T in C, MSL in hPa, r in g/kg (true water-vapor mixing ratio, r = q/(1-q) from ERA5 specific humidity). u/v [m/s], rh [%], vo [s^-1] are included for the seasonal GPI/ventilation-index analyses. Native ERA5 0.25deg subsampled (decimated) to ~2deg; SST masked to ocean (land fraction < 0.5).
  • " ], "text/plain": [ " Size: 8MB\n", @@ -580,16 +507,16 @@ " sst (month, lat, lon) float32 45kB ...\n", " msl (month, lat, lon) float32 45kB ...\n", " t (month, p, lat, lon) float32 1MB ...\n", - " q (month, p, lat, lon) float32 1MB ...\n", + " r (month, p, lat, lon) float32 1MB ...\n", " u (month, p, lat, lon) float32 1MB ...\n", " v (month, p, lat, lon) float32 1MB ...\n", - " r (month, p, lat, lon) float32 1MB ...\n", + " rh (month, p, lat, lon) float32 1MB ...\n", " vo (month, p, lat, lon) float32 1MB ...\n", "Attributes:\n", " title: pyPI sample dataset (ERA5 monthly means, 2024)\n", " source: era5_pl_monthlymeans_2024.nc + era5_sl_monthlymeans_2024.nc\n", - " history: 2026-07-10T22:33:41.949974+00:00: created by data/build_sample_...\n", - " notes: Core PI inputs in pyPI units: SST/T in C, MSL in hPa, q in g/kg..." + " history: 2026-07-11T16:30:08.453192+00:00: created by data/build_sample_...\n", + " notes: Core PI inputs in pyPI units: SST/T in C, MSL in hPa, r in g/kg..." ] }, "execution_count": 4, @@ -674,7 +601,7 @@ "# get the profile and input values\n", "p1 = np.asarray(ds.p)\n", "t1 = np.asarray(sel.t)\n", - "q1 = np.asarray(sel.q)\n", + "r1 = np.asarray(sel.r)\n", "sst1 = float(sel.sst)\n", "msl1 = float(sel.msl)\n", "print(f\"lat={float(sel.lat):.1f}, lon={float(sel.lon):.1f}, month={want_mon}, \"\n", @@ -721,7 +648,7 @@ "RP=0.622*ES0/(PP-ES0)\n", "# convert to the proper units for CAPE module\n", "t1k=t1+273.15\n", - "q1gg=q1*0.001" + "r1gg=r1*0.001" ] }, { @@ -730,7 +657,7 @@ "metadata": {}, "outputs": [], "source": [ - "(CAPED,TOB,LNB,IFLAG)=cape(TP,RP,PP,t1k,q1gg,p1,ascent_flag=0,ptop=50,miss_handle=0)" + "(CAPED,TOB,LNB,IFLAG)=cape(TP,RP,PP,t1k,r1gg,p1,ascent_flag=0,ptop=50,miss_handle=0)" ] }, { @@ -739,7 +666,7 @@ "metadata": {}, "outputs": [], "source": [ - "(VMAX,PMIN,IFL,TO,LNB)=pi(sst1,msl1,p1,t1,q1,CKCD=0.9,ascent_flag=0,diss_flag=1,V_reduc=0.8,miss_handle=0)" + "(VMAX,PMIN,IFL,TO,LNB)=pi(sst1,msl1,p1,t1,r1,CKCD=0.9,ascent_flag=0,diss_flag=1,V_reduc=0.8,miss_handle=0)" ] }, { @@ -758,12 +685,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "Average Module Runtime per run = 0.00014907360076904297\n" + "Average Module Runtime per run = 0.00012182950973510742\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
    " ] @@ -779,7 +706,7 @@ "time_check=np.zeros((nruns,))\n", "for i in range(nruns):\n", " start = time.time()\n", - " check=pi(sst1,msl1,p1,t1,q1,CKCD=0.9,ascent_flag=0,diss_flag=1,V_reduc=0.8,miss_handle=0)\n", + " check=pi(sst1,msl1,p1,t1,r1,CKCD=0.9,ascent_flag=0,diss_flag=1,V_reduc=0.8,miss_handle=0)\n", " end = time.time()\n", " time_check[i,]=end - start\n", " \n", @@ -809,10 +736,10 @@ "output_type": "stream", "text": [ "------- pyPI PI -------\n", - "VMAX = 73.77275178055163 m/s\n", - "PMIN = 931.1306481458636 hPa\n", - "To = 196.88959203639646 K\n", - "LNB = 99.05681989994771 hPa\n", + "VMAX = 72.82983387567924 m/s\n", + "PMIN = 930.9261353951322 hPa\n", + "To = 196.90530306766843 K\n", + "LNB = 98.95581689049399 hPa\n", "IFL = 1\n" ] } @@ -843,9 +770,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python (attribution-dev, pixi)", + "display_name": "tcpyPI (pixi)", "language": "python", - "name": "attribution-dev-pixi" + "name": "tcpypi-pixi" }, "language_info": { "codemirror_mode": { @@ -857,7 +784,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.13.9" + "version": "3.14.2" } }, "nbformat": 4, diff --git a/notebooks/ventilation_index_demo.ipynb b/notebooks/ventilation_index_demo.ipynb index 381819b..f47b082 100644 --- a/notebooks/ventilation_index_demo.ipynb +++ b/notebooks/ventilation_index_demo.ipynb @@ -699,9 +699,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python (attribution-dev, pixi)", + "display_name": "tcpyPI (pixi)", "language": "python", - "name": "attribution-dev-pixi" + "name": "tcpypi-pixi" }, "language_info": { "codemirror_mode": { @@ -713,7 +713,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.13.9" + "version": "3.14.2" } }, "nbformat": 4, diff --git a/notebooks/verify_pi.ipynb b/notebooks/verify_pi.ipynb index 8642d51..1c3a3f5 100644 --- a/notebooks/verify_pi.ipynb +++ b/notebooks/verify_pi.ipynb @@ -99,7 +99,7 @@ "SST,MSL,Ta,R,P=np.asarray(python_in_ds.sst), \\\n", " np.asarray(python_in_ds.msl), \\\n", " np.asarray(python_in_ds.t), \\\n", - " np.asarray(python_in_ds.q), \\\n", + " np.asarray(python_in_ds.r), \\\n", " np.asarray(python_in_ds.p)" ] }, @@ -137,7 +137,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "1.0154027938842773\n" + "2.141742706298828\n" ] } ], @@ -200,7 +200,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "VMAX: The maximum absolute difference across all points is 0.18902926700830136\n" + "VMAX: The maximum absolute difference across all points is 0.11029867619424749\n" ] } ], @@ -222,7 +222,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
    " ] @@ -258,7 +258,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1wAAAI9CAYAAAAuOnmPAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAhItJREFUeJzt3Qn8TPX+x/Gvfc2+hMKVKJSy5ZKlhKgQKrotpLRQpI1IhNRVt7JUitTlSoslS1IpslyiQiGSZM2WPUuY/+Pz7X9+d37zO2fWMzNneT0fj8mv38w5c+Y75zfzfZ/vli0QCAQUAAAAAMB22e3fJQAAAACAwAUAAAAASUQLFwAAAAAkCYELAAAAAJKEwAUAAAAASULgAgAAAIAkIXABAAAAQJIQuAAAAAAgSQhcAAAAAJAkBC4AAAAASBICFwAAAAAkCYHLxM8//6yeeOIJVa9ePVW0aFGVK1cuVbJkSVW9enV13XXXqeeee04tW7ZMnTlzJlnvC0J06dJFZcuWTTVt2tQTZfP222/r1xN6y549uypSpIiqVauW6tOnj9q0aVPE7RcsWGDrMeTNm1eVKlVKVa1aVbVv314NGzZMrV27NuL+Bg0apLevWLFi2MdNnTpVXXPNNapEiRIqR44cpttE8xg407p161TOnDlV6dKl1R9//GHreZ8qXvu8SYbQ97JNmzZRbdeuXbtM28l+otG7d++MbeS72cqWLVtMz7FYbsZnqh2fs/G8hmj+ZuQmf2fFixdXjRs3ViNGjFCHDh1SXjRu3Dj9emvUqGHbeyCfM0AqEbhCjBw5UlWrVk3985//VCtWrFAHDx5Up0+fVvv27dMViY8//lj169dP/f3vf1ffffedcqJoK75wnkAgoL805dx66aWX9BfMhAkTUnoMJ0+eVHv37lUbN25U06dPVwMGDNDH0ahRI7Vq1aqE9v3qq6+qjh07qvnz56v9+/ers2fPxvUYONejjz6qL0bJRav8+fM76rznszF5PvnkE/25EY78Pct3aKzkO3jy5MkZ/y/fzevXr1dukozXIH9nv//+u1q0aJF6/PHH9d/NDz/8oLxm5syZ+t+2bdsmvK++ffuqfPnyqTFjxqjNmzfbcHRAdAhcQeTDsFevXurUqVPq/PPPVy+88IL65ptv1O7du9WuXbvU0qVL9e+uvPLKKIsXiEwqIEeOHNE3qXRu2LBBtyrlyZNHh5977rlHn3upPIZff/1VLV++XI0aNUo1bNhQP2bx4sXqiiuuSKgiLK9LGOFNLmjIc8rFjFgeA2f6/PPP1dy5c3Xr1v333+/48x72KFSokPrzzz/Vu+++G/Zxcr88Th4fCzlXQsPcO++8Y/rYChUqZJxXobfgsPf6669bPk4+e+wWy2sIt4/g4/ztt9/Uf//7X9WtWzd9kXX79u26pVH+frxCWsnlc8WuwHXuueeq++67T9fz5OI5kCoEriD9+/fX/0rL0OrVq9Ujjzyiu7hI9yr5I5VWLfmdXE2Sq0jly5dP2RsF75KrbQULFtQ3qYhUqVJFPfnkk2rs2LEZVzGfffbZlB6DnNvS5aVnz546aM2ZM0cVK1ZMf0l1795dtz6ZtR5IS4V06TEjlY2dO3fqn6U7R82aNVXhwoX1cxotIdE8Bs41ZMgQ/a+EJTmnnH7ewx7SIi3+/e9/h32ccf9NN90U0/6NYCKfQUYYmjRpkmnrtwQP47wKvQWfkxLsrR4n3ZjtFstriOZvRm5yYaN+/fq6y51cLBa//PKL7pngFZ9++qk6fvy4KlOmjKpbt64t+3zooYf0efL+++/rCz1AKhC4/t9PP/2UUVGUyoKM3QpHxnNJEAOS5Y477lB/+9vf9M9ffvllWscMtm7dWnfrkDED0jVGvrAkXMUieDyPjNeJ9zFwJuke9dVXX+mfb7vtNk+c94jOP/7xDz0OT3qEWHWTk4qtdKOTx8VyfkiXudmzZ+ufb7nlFt2aI3bs2JHR8uF0qXgN9957b8bPUs5e6054ww036JBkB7mo3qBBA/3zG2+8Ycs+gUgIXP8vuKn/nHPOUYmQCoJcyZMJNuSqTO7cufXAVhmALd0YpEtFtIO1lyxZojp06KDKli2rJzOQD4oHHnhAdx0IJYN6ZdvBgwfr/5duYaGDbM3Gddl5vPKF27lzZ1WuXDl9Ne7CCy/UV62DB/OeOHFCj9OoXbu2br2Q8m7SpInuihStWMolWa9VJk6Rioa0Bsl+7B4zJ88lwd4IIjL+IZ2ka+Gdd96pf5bufdLqFc34GGPQd/Dvr7rqqiwD5yM9JnTQeqrfy3ifL/S5vv/+e12O0m1ZrrJL67lUwtasWRO2/I1j+M9//qMnHjjvvPP0uS8Ti1x22WW6NdIIPFbbxlte0TBapuTvWiZcsfO8P3bsmG4Fk/tkDEYkzZo104+VHgqJfDYaEnnP5PifeuopfSxyEcH4vJJg+fXXX1tuZ+d5k2zyOSxlHq6Vy2jhkb9rOXejJd0QpWVdSJnJ536BAgXCPpfTpOI1BPe4CZ2sxi6p/r6X1j8jqJp1J5SeRtLj4qKLLtLlKX9bcm7VqVNHt/iZ9cQwGKFfzksvdcGEgwWgrVu3Ti7X69sNN9wQd6ls27YtUKtWrYx9md3q1q0b2L17t+n2d955p35MkyZNAm+++WYgR44cpvsoVKhQYMmSJZm2/fLLL8M+r9wqVKiQtOP997//HciVK5fpPuQ5Dh06FNi3b1+gfv36po/Jli1b4J133rG9XJLxWseMGZPlGELLNpwJEyZkbCfvm5Xrr78+43F79uyJeXs7jiHYf//734xtHnzwwUz3Pf3006blEPw8VrdoHhN8jKl+LxN5vuDneu+99wJ58+Y13V5+/8UXX1iW/ZYtWwKXX355xHIyk2h5RaNs2bJ6PwMGDEjKeX/PPffo/y9Tpkzg9OnTYctJPkvksaNHj47rs9Gu92zhwoWBokWLhn3evn37mm5r1zEkS/B7uX79+sDEiRP1z+eff37gzJkzmR579uzZQPny5fX98hn/008/ZfrbD0fOS3nchRdemPG722+/Xf8uf/78gcOHD0d9zMHnQaTntetzNtHXEO0xBNdhhg4dGkiGVH3fGxYtWqQfW7BgwcCJEycy3ffuu+8GcubMGfZvq3r16pb7/uWXXzIe9/HHH9tWRoAVAlfQF8J5552X8Qd41113BdauXRvTmSMfmvKBKtsXLlw4MHz48MD3338f+P333wObN28OjBw5MlCkSBF9f+PGjbN8KQV/oJUrVy6QO3duXcGaO3eurnTIPl544YVAgQIF9GOKFSsW+O233zK2lUrIkSNHAv369dP3yxec/H/w7dixY0k5Xqls5cmTJ9CsWTP9pbB3797Azz//nHEsRkWsTZs2+sNzxIgRgU2bNgX2798f+PzzzwMXXXRRRmCS39lZLna/1tKlS+sP+r///e/6GKSSun379sDs2bOjPlei/RK94IIL9GPy5cuXqZKZrsB16tSpjIpf7dq1owpcf/75pz735O8p+Asu+LyUL9NIjzFef6rfy0SfL/jclbJr0KCBfm3yXDt37gyMHz9en/dG2ZmFCXmuv/3tb/ox2bNnD3Tv3l1fWJDzX/azePFiXf7yNx/KjvKKJLgCPXPmzKSc98uXL8/YdtasWZbbGuehlLW8xng+G+14z+TzTT7rjM+1l156SZe3vGfz5s3LqITL7cUXX8yyvR3HkMrAJeVnvF75TA82f/58/Xv5jD569GjUgSs4RDzzzDMZv//ss88yfi/l4OTAlehriPYY+vTpk/E4+VtJhlR93xseffRR/bj27dtn+v2BAwcyzrVKlSrpsG/sX87FTz75RF8QvPrqq8O+Hvn8l3088cQTtpURYIXAFXLFJPQKiXzZ3XjjjfqKkVytlAqnlV69eult5Iqm/NGbWbVqlf6gksd98MEHlh9ocqtRo4auCISSD2rjCu59992X5X6rim+yj/e6664z/dL/xz/+oe+XVgSp3ErlMNSGDRsyXtPYsWNtLxe7X+uVV14ZOHnyZCBe0XyJTp48OeMxLVu2jHl7O47BjPFlKV+6sZx3wVcUrZ4vmsek+r1M9PmCn6t58+amnyHvv/9+xmOkshDq3nvvzbhfzgsrEm7tPv5oSIXROL7Qix12nveXXnqpaQUs+MJZxYoV9WM6d+4c92ejHe9Zu3bt9H3SCrBs2bIs9//xxx+BevXqZYRDqbTafQypDFzijjvu0P8vx272WqRVR0QbuKQiLI+Rz3X5bDDIRQHjAqlcJHBy4Er0NQQfQ+hFKAnfcm7JBRi5ECOPke/bZEnV972hSpUq+jGhLWFyUcc4DvnsipcEQtmHtMIByUbgCiGVDaNrjNmtRIkS+sqNXKULJv9vtLD885//DFvoXbp00Y+TL+RwH2hz5syx3IdUOOQxcpUntLIYTaUiGce7ceNG0+3larTxmHBfBtJiYrQu2lkuyXitZhWoWFh9kUuFUa5eS6uDcczyxRT6ZZ/OwGV0EZFKYqoDV6rfSzueL/i5rAKPVFyMVqbgq+BCuuYYYejmm28OewzJOP5oPPLII3pbea5knvdyvxFigrvYhrakmLWyxBu44nnPpCJsVIDNLooZ5Nwznudf//qXrceQjsAlZW58/hothsEtX3JRLNrAJYFELnjKYxo1ahQ2yEjLoRMDlx2vIZru1nKTVuFXXnklrhbqaKXq+17IOWUEN+maGGzatGkZzxF6XywefvjhjPMVSDYmzTCZ3lYWw/vggw/0AFGZqjh4ZhxZAHno0KF6PaLgiTZkvRgZ2C2uvvpqdfToUcvbpZdeqh+3cuVKy7F1MgC0ZcuWlvfLoFsh+4tnMVq7j7dSpUp6wKyZCy64IOPncK/JeJyseWZnudj9WmWiAXn/7RI8OYTM4CUD0GUWQDlmmRVQ1sIyBik7gTE7oV0zRsUi1e+lnc8nM+/J4G4zMg218fcja+sEk2n5jUHd8pmUzvKyYnwWypTXyTzvZaC7DIyXCT5kSu1Qb731lv5XJqWQ15uoeN8zKXdjuu9wU6DLuSfrRglZbsTOY0gHY0IMOZ+mTZumfyf/yv/LxAqxvCcye5/M4mdMNBHK+J18Hk2cOFE5USpfg8yyLBNRyOQqyZaK7/uPPvpI/yvrnsrndDD5rDK+f2TGR6ulSCIxPq/k/JTJPYBkInCZkBmgJHjJAq8yla0svPrJJ5+ou+++W8/sJdauXatnxzEEr+UgM+TITDxWN1lfSIQughhMPszCrQVSrVq1jJ/j+bCx+3ilsmQleO2TaB4na27YWS52v1b5skkmeX3yZSTnm8wC1aNHD+UkxgxUsVSu7ZLq99LO5wt37gtjnbHQGcZ+/vnnjJ9lNsJ0lpedgSue816W6zAuqoQuwH348OGMSn7Xrl1tuSAQ73smsyAajBkXrRj3W32Ox3sMxixuobMxxnqT2UejJcFZZvsMnn3P+NeYOj5axqyGErDNQqt81svMd8HP4TR2vwZZJuH/eybpm8w8KheBZSY/+fuWeooElNAZXe2Wiu97I3DJQs6h5HPC+HyQx8lFCVmzUWYqlhkhpUyiERzk4vncA2KRM6ZH+5RMRyxXauQmK5TLB5pcDZkxY4batm2bnqY3eBrUaIWbilQWNQwn+H5ZcT5Wdh9vtAtFRvO4cOs7xVMudr9Wuxfg/fjjjzMWwpQKiZMX+JWWBVlYM5qKYDKk+r208/mk1SYaoee/BIl4l6ywu7yccN5LIJOp8eVKvrTGSUVTSEVLKm+yr1hbAq3E+54FfyZH+swy3lOrz/F4j0FcfPHFCVckY/08klab559/Xk/JLetBGVNzm7XwWJGyMBbvlVZA4zMnlHwXSziXixLSEiz/7xSpeA1yrktokKUepPXw8ssv1xdZ5ILDpk2bkrKAcyq+7/fs2aOWL19uOR28GDlypG7peuWVV/QFcFkeQW6vvfaa/puRgPviiy/qJTCiee509NiAvxC4YiRXo6QJe8yYMfr/v/32Wx24gr9UDxw4kPCirUY3ICvSBJ7IumF2H2+qxFMuTn+tcqUvUqXMKaSCa1TIjYUjUynV76UTzh254BNciYvlXEnV8RuLwMsCr8k+76WbobR0y2L10oXQCFxGi9c111yTaU2idAj+TJbPJGPNpXCfWYmu/2hV4ZV12lJJWm1kzTH5bpQ1mqRrpfx/pJa+YO+//35Gy8fChQt1kIimNclJgSvVr0H+nqQVceDAgbq1VAJLOj6j7TBr1ix93sg5E9xFMZgEpHvuuUff5ML3f//7X90tV7aVFma5ACNde2VogdXnXvDnVar/TuA/dCmMQ/AXh9GNI/hDQb5oErVx40bdXcDK+vXrM36OZ8Fdu483VeIpF7e+VicaN25cxs8tWrRI+fOn+r10wrlTuXLljJ9jHa+ZquMvWbJkzIErEXLRS0ilSnobyN+9cUXcuC+dgj+T5ep7ONLtL3QbtzNas4zusLG0bgV3xYs34DhBOl6DLIZt1q3VbcJ1JzQjF71vvvlmPe5TxuAPHz48owzefvtty+2Mzyu52CHdPoFkInDFQa6mGIxuVY0bN9Zjv4IHbifakvPZZ59Z3m+MVZArxKHjOnLlyqX/DRdM7D7eVImnXNz6Wp1myZIlGeMMatSooVq1apXyY0j1e+mEc0eueBuVgVgrcak6fuMilPx9pmLyBukyKN2GZHytdNsyXpt0r7LqghTtZ6MdpGXB6E714YcfWj5OQqJRMTa6V3qBtGwZXSHlX/n/aEmFWbrWiQcffDDTmCWzm1G+0vXWqKinW7pew/bt2zN+TkaLaSrIRWyZbESE+1sO183yiSeeyGg9D74IG8q4IBBL6ysQLwJX0B/ek08+qfbv3x+2wLZu3arefPPNjK4+9evXz/hZmrbF5MmT9S0cuSob6QpU3759TQdCy8DZqVOnZszaZUzkEdo0Ln33T58+bbrvZBxvqsRaLm5+rU4hs1/J1UY5n6TSKlcS09HnPdXvpRPOHak4Ga027733nr4KbiX07z1Vx9+kSZOMn7/++muVbKVLl1bXX3+9/vmNN97ImLFQulQZAdNMNJ+NdrX4GVfnpVXYbOZHKWuZlVFIoL799tuVV0gXUxlLJJVd+dfochoNuahjjK259dZbIz5ezgOjy1g8rUrJkI7XIGHNuCAmoaNevXrKjeSCqrTySWud1WuQ8XCnTp2y3IfMfGgMPwid4TCY0Soe/PkFJAuB6//JH7g0Q8vUtdI0Lc3Q0tVDZruRZmfpyiMDgWUMlzEDztNPP53py33YsGF6kLJ80EqFX75AZcCwXPGV8RNy1Uv6F8sVLxljIFPPW5HjWLdunb5CPW/ePP2cUhF66aWX9Be5PIfMCGY2g5QxpkHG2sgU9jIAVSoXcgu+smvn8aZKvOXixtea6vPfmB5cvrjlSqkMeJexinLlvXXr1vrvQEKsVCDTOU19qt9LJ5w7cgxG90CpwN1///16zIKc/xIeli1bpv/WzaZqTsXxyyxh0q0nVYFLGEFSZmQzWtUidSeM9rPRDiNGjNBX2WWimebNm+uLFPJZJe/Zp59+qit5RlnJe+S1MSQyA6hMZx/LrK7B06PLdsYFzXDkO9iYuVIq6+GWFUmEfO/I31m4m3R5T+ZrCP6clpuM6ZSLwHIhpmHDhhkzXcrEMmYhV7qtyoUyJ3dfDe5OaHVRT0KpfFb16tVLzZkzR79uae2WICZlIeM45X2Q4Cn1OTOyze7du/XPBC6kRNJX+nIJWcQvd+7cUS0wKKunywKaZn777bdAkyZNotqPLOJptbCg7OP111/PWDwz9FaoUKHAkiVLLF9P06ZNTbcLXfDTzuO1Es2Ct5H2ZUe5pOK1RivRBTXtXvg4mtuVV14ZWLVqleX+UrHwcbrey0SeL9rnMvYvjzfz66+/Bi677LKIz5+M8opGnz599PayoGkyz1uDLPB63nnnZeyvTp06UW0XzWejXe/ZwoULA0WLFg1b3n379jXd1q5jSOXCx9GyWvhYysv4/YABA6Le3xdffJGxXbgFvhNZ+DiaW9u2bW1/DbEew0033RQ4ceKE6XPIOR7uMzqSZH/fy990yZIl9e9nz54d8bsm3E0WTB4zZozlPl577TX9uOLFi1uWF2AnZin8f3JlWK4US6uJzCj03Xff6WlV5QqwXGUpXLiwqlq1qm5ZkfEDVov+SVcXueIqV11k6mK5Ci1XUeQKqqwhIwspy9WXG2+8MWOhUSv33nuvvjItrTdy9UxaGGSKUxk7079/f73ApJWZM2eq5557Tl+5livY0gXPbPpVO483VeItFze+1nSQVizpiiZlIn3bpVVAyiR4jbN0S/V76YRzR67oStc06T4nV3FlEgw596UrkrT8Skuk1dXcVBy/rEv4r3/9S09x/eOPP1ou1msXuXot018PGTJE//9dd90V1XbRfjbaQb4vpNVDpq6WtZLk+aR1TbpLyfvVs2dPWxdRd7vg7nTRdMUzSAuFfO5Ly7zs47HHHlN+eA1SN5EZMGU7OY9kchKrxaXlvDOWCHDq7IXyuSTHKK+pWbNmlo/r3bu3HkcsLfXymbhz5069nXx3Seud9MCQNbnCfWcZ3ZDvvPPOsN2QAdsEXECumGTLli1QuHBh05vVFULx448/Bjp06BAoUaKEvtIoV+nnzJkTcCo7W1EAIJWuuuoq/fn15JNPpuT5hg8frp8vX758gQMHDqTkOQE3mj9/vv5bkZ48mzdvDjjRY489po+xffv2KalTynNJHRF/WbZsWaBFixaBYsWK6Zv8/N///jeh4tm5c2egS5cugdKlS+v6eq1atQLvvPNOxO0OHToU6NWrV6BcuXJ6u2rVqgVeeukl3QoajrRWSgtopUqVdI8n+XfgwIGOaMV0zRgumQ1Q+uia3YwpQEOtXr1aX2GUlg+5aiR95+VqqIxVkIHWAAD7DBgwQP87fvx404lt7GZM+SzjX5y2vh7gJDJuUPTo0UOPufTCdPDxkkWTpVVbegRIzyUo3burXbt26r777tO9H+QmP0uvB1mkPh5S75aWVynjn376SfcYk7q3lL9MUmdFxpHLmETpxSDzJ0g9XyZE++STT8JOLiTjZWURcHku6dFx6NAhPZma9Cy49tprw060khIBF5CrEZJyY3H27NnA5ZdfbtpPW/qPS3rfvn17wGlo4QLgZq1bt9ZXjl944YWkPo+M8TDGayxevDipzwW4nbQsFClSJLB///6An+3atUu3iEtL388//5zuw3GEP/74I1C2bFk9jjDUokWLAmXKlAkcO3Ys5v3KmEaz+Q72798fOPfccwMrVqww3U5atszGpJ48eTJQvXr1wIcffmi6nbSAyRhdqf+Hat68edK/kzzTwhXPmkGSps0WXJSFRNu3b59pEVcAgD2z88kaVPKv3a1cMpOgjEVZunSpHv9kjEeRq6EArMnYSqkTySy+fibjN2W2R2npi2UGTS+T1iOZl+Cqq64yXQdSxnLHOnuttG7JGLtHHnkky33FihXTn98yC3Io+XyXHhIDBw7Mcp+M0evXr58aPXq06XPK72X2cLPZLeX3VtulimcDl0ytKovmSZOkGbnPaGIHANhDBqrLZBwyVXv+/PltLVaZGl/WrDKmwJbB7jLdOgBE4+WXX9bdCWWCH/yvvizdCa3EU1+WfcrEJ1YLcLe12KdcTJPPeaswLGvWyeQqoRfzZEkAmUTKaop/+c6QpRSku2G6eDZwrV27NmPNFTN169bV62oAANxFxmvJbGzST79WrVrpPhwAcK1k1Jcj7bN69eq6xVXGWcWyncwYLmMQQ4OTbCffBVZrtwnZbzrr/a4JXPLGSNOmNEXKl61MOSxNwpJqzcgCk+EW95NFAU+cOKEXDnQSGQQuV1+kIgEA+B9p1ZLPR/k+kO4q0SwqCwCwFqm+LEuSyALbdu4zW7Zs6vzzz8+y30jbWR1PvNulkivW4ZLxADfccINe/0pmHZRuJBs2bFBvvfWWTrTS/zR07QlpOgw3a5W82bLWkDzOqsnT6E8qN8PZs2d1s2Xx4sXDJmkAAACkh1yckYvqMsu11fCSdJEL/smaNU9ed2j9VOrNVuuNRaovy33ymFhE2qfVfuX/K1SooOLZLp7nSyVXBC5JwVOmTMkyTuCFF17Q/TI7deqkfv7550zBSUKSDLALR04+OenDkSnnBw8enOArAAAAQKpt27ZNLw7tFFLvLF+hgNq752xS9l+wYMEswUImjRg0aJDp4yPVl6WuLOHQLMhZibcOfjLF26WSKwJXOLJGwNixY/UMKnfddVeWEyQceYNkAHY4MiNKnz59Mv5f+ptKs6T8AUsLGQAAv+64kEIIUaFc+gaoW+F9SsyC4+6Y2a9pvs3q6NGzqkG9fWF7MaWD1E0lbC39uqQqWNDenlJHjwZUg3p7s9RRrVq3jPvkmKwCixFmYunVFW8dPE8C28n6XZG2S+d6ja4PXKJ58+bqu+++y5LwZbG0cOTNkceFY9UMKycygQsAIC4ptFtt2V6Gwvh/Fc/b5ciy4H1KzA3nbFGf/1FZOd1yVUVdUXCj/tmpwz8kbJ1zjt1dHc/GXEc16stW9eFw90XaZzgHTfabyHaRZiCU7dLZ0umsTq1xkqsXx44dy/Q76QMqA6ytyCrakpCdduUDAOBOTg0Zqeb0cnD68TndNfk3KTdwS2tcukWqL8tEE9Kzy859BgIB3QoXut9I21kdT7zbpZInApcssCazDoZOObly5UrLbVasWKHHgQEAYBe/V+bd8vrdcpxO5ZbQhciSUV+OtM+1a9eqokWL6mneY9lOeqZJsJKFmkO3+/bbb3WQC7f4dzrr/Z4IXDNnzlQNGjTI0s1w1qxZloUv97Vo0SJFRwgA8Asq8+7A+5QYQpc3SH35o48+srw/nvqy7POLL76wnBVwlsU+pS6/efNmyyWf5syZo5cDyZ8/f6bfy9pcsmzUV199ZbqdLJZcoECBLEEtlVwfuF566SX9hrZu3TrT72X2QknOEydOzLKNvJkylfzdd9+dwiMFAPiFHyvzbnzNbjxmJyF0uV+HDh3Uxo0b1cKFC7Pct3TpUvX999+rm266KaZ9ylgpWa7pX//6V5b7Dhw4oEaNGqXX0g0lcybIBHhDhgzJct+ff/6pZw7v2bOn6XPK75955hnT++T3VtuliisClxTw9OnT1Z49ezJarGS16HvvvVcNGzZMvffeeypnzszzf8ggyQkTJqjHH39cr9cls5PIGlpyQrVs2VI9++yzqly5cml6RQAAr/NTZd7Nr9XNx+4EhC53y5cvn64nd+7cWbd0nT59Wt/k544dO6px48ZlaVGKhoSq8ePHq3/+85+6YUTq79LtT1q2ZF3dOnXqmG4nSzFJN8ZHH31U7d+/X/9OAmGbNm3UJZdcogOiGQlwUve//fbb1Y4dOzKGHN15553q+PHj6sEHH1Tp5IrAJatHS0vVFVdcoZsMpeWqffv2+gRYvXq1ql27tul2NWvW1AFLmiAlXMlixf3791cvv/yy6t69e8pfBwDAX/xQmffCa/TCa0gnQpe7SUOENGy8+uqrek4EucnP06ZNy9KDLNill16qFi9ebLmG7rJly9T69evVBRdcoMdsSc8yCT7S6GFF6viyT2nRknq8TOXerl07HdTMeq0ZcuXKpev78lyNGjXS+2nSpImeUGPevHkR1+lKtmyBcCPMYDpgT95EWY+LaeEBANHw6pTxXgsqXn2fUskp08YfP3paPVR7mePqa0Y9cs26UrZPC3/kyFl1abU9jnvNcEkLFwAAbua1YCJ4TQAQHQIXAAAp4KWA4qXX4qfXlgp0LwSyInABAJAiXqjMe+E1ROKH15hMhC4gMwIXAACIip+CiJ9eazIQuoD/IXABAJBCbq3Iu/W4E+HH1wzAfgQuAABSzG0Vebcdr538/NoTRSsX8BcCFwAAaarIyxTawTcnInBQBokgdAEELgAA0ubuKosy/b/Tghdhi7KwA6ELfkcLFwAADgpdwgmtXoQtALAHgQsAAAeGLkM6QhdhK6st28uk/H3wCie12gLpQOACAMDhoSuVCFtZEbbiR9gCCFwAADg+dKWq0krYyoqwFT/CFvAXWrgAAHCQdIUuwlZWhK34EbaA/yFwAQDg8+6FhK2sCFvxI2wBmRG4AABw0eyFdiNsZUXYih9hC8iKwAUAgE9bughbWRG23B+2Fh2sopYedMaxACInxQAAgLND17iNjTJVau1YSJawlRVhy51hSwIW4GQELgAAfBa6CFtZEbbcE7YIWHAbAhcAAC4MXfEibGVF2HJ22CJgwe0YwwUAgAvHdDllvIzbEbbil8xzUEKWcQPcjsAFAIBPJtKgdSszwpZzwxbgJQQuAABcGrpiqfQStuAGhC14EYELAACPhy7CVla0bjmvdYuwBa8icAEA4OHuhYStrAhb8SNsAbEjcAEA4PLQZVUJJmxlRdiKH2ELiA+BCwAAD7Z0EbayImzFj7AFxI91uAAA8AAJWEagcELYItx4B2ELSAwtXAAAeICTAo6TjgWJIWwBiaOFCwAAlwsNOPL/6WrlImx5A+tsAfahhQsAABezCjjpCD6ELW8gbAH2ooULAACXihRwUtnSRdjyBroQAvYjcAEA4ELRBpx0di+Ee9CqBSQPXQoBAHCZWFuTkt36lOz9JzMMgLAFJBuBCwAAF4k33CQrFKUqbBG6klu+dlt0sIq+ASBwAQDgGomGG7vDUapbtuT/CV7JK1+7ELSAzGjhAgDABewKN07bTzxhgOCV3PJNBGELyIpJMwAAcLhktEwlMpGGU8ZsyeOuyb8pqcfiRXaHLUJW7BYcr6Ty5bC3Gn78+Gml1B5b9wl7ELgAAHCwZI69iid0OSVshT6e4JWc8g2HoAVEh8AFAIBDpWJ2wVhCl9PCltm2BK/klG8wghYQG8ZwAQDgQKlaSDiW9bzcEAaYVCN55cLMg0B8aOECAMCnYSvali63hK3Q/dHalXjZ0poFJI7ABQCAj8NWpNDltrBltm+/Bq9EypagBdiHLoUAAMA0XLk5bKXjeZwk3tdMt0HAfrRwAQDg89Yts5YuJxyLnfzU2hVP2KJFC0geWrgAAHAAJwWcVBxLulqdvN7aRdgCnIcWLgCA7wQHikQWAPZi2PJD6PFqaxdhC3AmAhcAQPl9nFI6Q5efwla6g1ak43FzACNsAc5F4AIA+IZVuElX6CJsOT+0uCGEEbYAZyNwAQB8IVK4SXXoSlbYClf5Tkd4cFqrltdawQhbgPMRuAAAnhdtuElV6EpH2IrmfkRXxk4JXYQtwB2YpRAA4Gmxhptkd/NLV9hyKydOV+6EsiZsAe5B4AIAeFa84SZZoYiwFd8CvE5cjDedoYuwBbgLgQsAgBSEI8JWdMKFK0IXYQtwI8ZwAQA8yUkzABK2Ios2TBmPa1Rko/LbmC5atgB3ooULAOA5dgUcO/ZD2Aov3u6CTmrtSkX3QsIW4F4ELgCApzipKyBhy5od47KcNLbLCRNpBHNKuQAgcAEAPMRJk10QtlIXkpwSvJIVumLdrxPKAsD/0MIFAPAEJ03nTthKTyjyYugibAHux6QZAADXS9UEGdEsjJzusGUVOtI1yUSqQ1AyJtUIfQ2R9m3XRBqELcAbCFwAAFdL9WyE4UKXU8NWpPu8SF5vPKErmnKKZt+Jhi7CFuAdBC4AgGula+p3s9Dl5LDlV5Fau5JdZvGGLsIW4C0ELgCAK6V7na3g0EXYcrZkBKt4W9AiIWwB3sOkGQAA10l32Ao+DsKWf0UT5GIJUIQtwJsIXAAAV3FK2EomuhH6L3QRtgDvInABAFyDsPU/jNnyTugibAHeRuACALiCH8JWtAhb3gldhC3A+whcAADHG7exkfKDaCrfhC3vhC7CFuAPzFIIAHBF2DIqp3YsKGvsz659hXsO+Eu0a3TFuk8A7kXgAgC4qmXLzhDjtkBExdsd7JwynvcccD+6FAIAHMkv3QijRcXbf+8X7zngDQQuAIDjELYyo+Ltr/dNtuM9B7yDwAUAcBTCVmZUvP31/vF+A95D4AIAOAZhC14UbYgibAHeROACADgCYSsrKuD+eS95rwHvInABANKOsJUVFXB/vKeM1wK8z7WBa926dapw4cIqW7ZsasuWLZaP27Bhg+rYsaMqWbKkKlasmGrUqJH6+OOPU3qsAABrd37djeIJQdjyx3vL+wwvOXv2rHrllVdUtWrVdB39/PPPV7169VKHDh1KaL9z587V9feiRYuqEiVKqA4dOqgff/wx4nbLly9XLVu2VMWLF9c3+XnZsmUxPffevXv1tnnz5lULFizwX+B68MEHVZ8+fcI+ZvXq1apx48aqVatWavv27Wrfvn1qyJAhets33ngjZccKAAiPiidl4Se0asGLunbtqubMmaOmT5+uQ9a3336rcuXKpRo0aKAOHjwY1z7Hjx+vevTooevv+/fv1/X51q1bqyZNmuj9W5k3b55q166duu+++9Tu3bv1TX6+8cYbY2p4eeKJJ1SbNm3Uueeeq3y38PF7772nfvnlF/2mDho0yPQxgUBAv/HPP/+86tKlS8bvmzZtqt+EK664Ql133XWqXLlyKTxyAIBV61Zo6LJr4VgAQHLNmDFDtyhJY0eePHn076R32QsvvKAOHz6snnrqKTVq1KiY9rlr1y712GOPqaVLl6qLLrpI/05amrp166by5cun6/mrVq3Svd2CHT9+XN11111q8uTJ6qqrrsr4vYQtOaabb75Zbdq0SeXPnz/s80trmIRHaU2T3OCrwHX06FH1yCOPqDFjxuhCt7JkyRJ14MABdccdd2S5r3Llyqp9+/Zq3Lhx6umnn07yEQMA4ulKaNbqFS6EpbOVzK5wSEsfADcaPXq06tu3b0bYCjZgwABVvXp1NWLEiLB1d7PWLWldMsJWsFtvvVU3unz11Ve6tSvY1KlT1YUXXpgpbBmuvPJKfSwffPCBuvPOO8N2j5SWNXmO0qVLq0S5LnBJk2KNGjVU27Ztwz7us88+04/Jnt2816TcN3z4cAIXALho3JZTA4lTjwsAku3EiRO6oeP99983vb98+fKqatWqatGiRap58+ZR71fq8g8//LDl/RLGPv300yyBS7aT7oRWJAPIduEC19ixY9WpU6d06LKDq8ZwSZPeq6++qkaOHBnxsWvXrlV16tSxvL9u3bp64g0AQGoxSQYAeId0z5MhOjI5nZ317rVx1uUTzQAy54O0ykkXyJw57WmbclULl0x2IUmzSpXIVxJ//fVXVbFiRcv7S5UqpRP5kSNH1DnnnGP5uJMnT+qbQfqhAgDiQ9gCgOQKratKNz+zrn52iVTnNlq5tm7dqqJ17Ngx/TrKli0b8z4jHU+kY5GukdISJ/M+2MU1gUv6Wq5fv14Pyot2rFeRIkUs75cBdoUKFdKPCxe4pNvh4MGD4zpmAMD/ELYA4C9LD1ZWuU/ntrU4Th09JVM96OnYg8l8BVaTzNkhUp1byP3hlnEy26fU062GBhn7lMfFejxW24mvv/5ad420uxecKwKXpFyZKENmOilQoEBU20irVO7c4U9kSfvSyhVOv379Mk0/L2k79EQGAIRH2AKA1Ni2bZsOK4Zktm7ZWee2a5+RtpXtZHyWzGgePMOhMVHGk08+qc477zzlu8A1dOhQValSJdWpU6eotzEKMxx5QyLNlpLsZlgA8DrCFgCkjoSt4MCVbHbVue3ap7GtVegyAlnodPJvvvmmbliJtM6vJwPXhg0b9CQZMrd/LAoWLBhxkTUpVHkcACA5CFsA4FwPPfSQmjZtWszbTZkyRU+xHm2d++DBgzHVueWxUk8PbYWKZp/G8Vg9n9l9sqhy//791aRJkyK2rHkycEnKvOeee/RU8LGoUKGC7itqnAyhZMVpScXhxm8BAOJH2AIAZ5NGjWhm/46mzh3O1q1bTdfTsiJDiKSVbseOHZbd+2SfMgGG1fHEst3AgQN1Zrj22mtVMmR3w1STb731lh7gZnYTl156qf75tddey9hOFjVbuXKl5X5XrFihqlWrlpLXAAB+Q9gCAH+oXLmyDkYHDhywtd5dPc66fDzb/fTTT2r+/PmWeUNC2vXXX69/lvkdPBe4pEuhNClK85/ZTaxZs0b/fP/992dsJ9M5zpo1SzdFmpH7WrRokbLXAQB+QdgCAP+QHmMNGzZUM2fONL1/+/btuj7fqFGjmPYrdfmPPvrI8v7Zs2eb1uUjbWeWAWQhZFkqyipvSIuYPJ/8LDOYey5wxUve+MKFC6uJEydmuW/z5s1q6tSp6u67707LsQGAVxG2AMB/evbsqZ577rlMa9cGT37XpUuXmCbNEN26ddPBaePGjaZjyGRyjMaNG2e5r0OHDnqbhQsXZrlv6dKl6vvvv1c33XSTSiXPBi4ZYDdhwgT1+OOP6y6JcgLIdI9S+C1btlTPPvusXhUbAGAPwhYA+FO7du1UvXr1VNu2bTMC0r59+3Q9fNGiRWrIkCEx77NMmTJqxIgRqnXr1rr+LvV4mQZe6ve9e/fW/5pNqJEvXz5d9+/cubMObKdPn9Y3+bljx45q3LhxKn/+/CqVPBu4RM2aNfUbNGfOHB2uihcvrmcgefnll1X37t3TfXgA4BmELQDwNwlArVq10uFLeplddtllOiAtWbLEciHixYsX67kYwrVyjRo1StffpR4vE2FIl8AFCxaoWrVqWW4njSvTp09Xr776qipVqpS+yc8yI6MEuFTLFrAa5ARTMp5MTqJDhw6ldI0DAHAqwhYApzl19JSa0myS4+prRj2y0/zbVO6CuX3xmuHxFi4AQHIRtgAACI/ABQCIC2ELAIDICFwAgJgRtgAAiA6BCwAQE8IWAADRI3ABAKJG2AIAIDYELgBAVAhbAADEjsAFAIiIsAUAQHxyxrkdAMAFCEoAAKQXLVwAAAAAkCQELgAAAABIEgIXAAAAACQJgQsAAAAAkoTABQAAAABJQuACAAAAgCQhcAEAAABAkhC4AAAAACBJCFwAAAAAkCQELgAAAABIEgIXAAAAACQJgQsAAAAAkoTABQAAAABJQuACAAAAgCQhcAEAUmb13rKUNgDAVwhcAICUhy6CFwDAL3Km+wAAAP4UHLpqltyZ1mMBACBZaOECAKREuFYtWr0AAF5F4AIAOAbBCwDgNXQpBAAkFeO1AAB+RgsXAMBRYYvxXAAALyFwAQCSgpYtAADoUggAsBlBCwCA/6GFCwDgmLBFd0IAgNcwaQYAIGG0agEAYI4WLgCAI8IWrVsAAC+ihQsAEBdatQAAiIzABQCIGWELAOL3w/4yKsfxPLYW4Zk/Ttq6P9iHwAUASHvQojshAMCrGMMFAIgKrVoAAMSOwAUASGvYonULAOBlBC4AQFi0bAEAED8CFwDAEmELAIDEELgAAGkLW3QnBAB4HYELAJAFLVsAANiDwAUASEvYonULAOAHBC4AQAZatgAAsBeBCwA86s6vuzm21YnWLQCAXxC4AMCD4glbBsIQAAD2IXABgMckErZSEboIdAAAPyFwAYCH2BG2DAQjAAASR+ACAI+wM2wlK3QR4gAAfkPgAgAPSEbYCg5JBCUAAOKTM87tAAA+CFvBCF0AAMSOFi4AcLFUhS0AABAfAhcAuBRhCwAA5yNwAYALEbYAAHAHAhcAuAxhCwAA9yBwAYCLELYAAHAXAhcAuARhCwAA9yFwAYALELYAAHAnAhcAOBxhCwAA9yJwAYCDEbYAAHA3AhcAOBRhCwAA9yNwAYADEbYAAPCGnOk+AADwmsvmPBXxMTVL7kzJsQAAgPSihQsAUoywBQCAfxC4ACCFCFsAAPgLgQsAUoSwBQCA/xC4ACAFCFsAAPgTgQsAkoywBQCAfxG4ACCJCFsAAPgbgQsAkoSwBQAACFwAkASELQAAIAhcAEDYAgAASULgAgAAAAA/B67Dhw+r8ePHqxtvvFGdf/75qlChQqpw4cKqQYMGaty4cSoQCFhuu2HDBtWxY0dVsmRJVaxYMdWoUSP18ccfp/T4AQAAAC87e/aseuWVV1S1atV0PV3q7L169VKHDh1KaL9z587V9feiRYuqEiVKqA4dOqgff/wx4nbLly9XLVu2VMWLF9c3+XnZsmURt/voo49U06ZN9Ws455xz1AUXXKBfx/79+70duDp16qRWrFihX+xPP/2kA9jmzZtVjx491LBhw9T9999vut3q1atV48aNVatWrdT27dvVvn371JAhQ9SDDz6o3njjjZS/DgAAAMCLunbtqubMmaOmT5+uQ9a3336rcuXKpRtIDh48GNc+pcFF6vtSf5fAI/X51q1bqyZNmuj9W5k3b55q166duu+++9Tu3bv1TX6WxptwDS8vvviievTRR/Vt586dOnPMnz9fnT59WtWrV0/9/vvvcb2ObIFwzUMOcerUKZU7d27T+3799Vd18cUX6xR7ySWXZPxeXlbt2rXVQw89pLp06ZJpm02bNqkrrrhCrVmzRpUrVy6mY5GCl8QrJ5K0tAFAqDu/7kahAEAanTp6Sk1pNslx9TWjHlnj/cdUjvx5bN33mT9Oqh9uHpGW1zxjxgzVt29f3diRJ0/m19W9e3f9u1GjRsW0z127dqnq1aurpUuXqosuuijTfZMnT1bPP/+8WrVqlcqWLVum+44fP64qV66sJk2apK666qpM9y1evFjdfPPNOgvkz58/030S6CpWrKi+/vprnS1Cde7cWVWpUkUNHjxYebKFyypsiQoVKuiUu2DBgky/X7JkiTpw4IC64447smwjb0L79u11d0QAAAAA8Rs9erQOXKFhSwwYMEC9/fbb6sSJEzG3brVp0yZL2BK33nqrDlZfffVVlvumTp2qLrzwwixhS1x55ZU6xH3wwQdZ7pPsUL58edOwJaR1LJouia4NXJHImxv6Jn722Weqbdu2Knt285co93366acpOkIAAADAe6QOLmFFwpGZ8uXLq6pVq6pFixbFtF+py0u3QCvyfGZ1+UjbWWWAkydPhp0XQsaohbaK+SZwSSuWNDXKAL1ga9euVXXq1LHcrm7dumrdunUpOEIAAADAm6R7ngzRkcnp7Kx3r42zLh/vdpIlNm7cqLc3Iy1nzZs3V74KXDJoTQbmyQs/99xz1bXXXptlbJf0w7RSqlQpnciPHDmSgqMFAHdbvbdsug8BAOBAkercRivX1q1bVbSOHTumx7uVLVs25n1GOh6r7aSroUy0d8MNN6hp06bpRh2ZLENmRLz77rt1C9g999yj4pFTuax/qPQDlUk0pN+mkLFY8vscOXJkeuzRo0dVkSJFLPclA+xkQKE8TqZ8tCKFKzeDvPmA3zlxUoh36o1P9yF4PmyZha6aJXem4YgAAFZC66oy9MZsbJVdItW5hdy/ZcsWFcs+pZ5uNTTI2Kc8LtbjsdpOvPvuu+ree+/VU8+LnDlz6tBVo0YNPVuhzLro+Raunj176mklpZAkmf773//WKVb6aoaSkBRusg2rsV+hhg8frmeTMW6ypgDgZ04MW0iu4FAlPwffAACxO7i7oDrw2zm23mSfQuqqwXVXqcsmk111brv2GWlb2U4ab8zGa0kPOikz6UX3xx9/6MetX79eTwkvN5kq3vMtXAZJu3Iy3X777brZT/ppyqJkDRs2zFKY4cgbkjdv3rCP6devn+rTp0+mqwaELgB+Q7gCAHfYtm1bpmnhk9m6ZWed2659GttahS4jkIVOJy8NOjL1uyx8LAssG2SWRJkxUdb9ffLJJ/WMi74IXKHNgrLWlnQrDA5cBQsWjLjImoQneVw4yW6GBdyE1i0AAJxNwla063BJHVrGK8VqypQpeor1aOvcBw8ejFjnDiaPlXq6tEKFBqNI+zSOx+r5rO57/fXXVcuWLTOFrWAyrEmWlnrrrbfCdnX0ZOAKTp6h63NJX1HjZAglK05LKg43fgvA/xC2AADwlpEjR+pbIow6dzhbt241XU/LSoECBXRo3LFjhzrvvPMs9ykTYFgdT6zbLV++3HT9XoPMxCi54bfffgs7mYfrx3BZkZkGz5w5k2WmkZUrV1pus2LFiixTyQMwR9gCAABmpNVHgpHM6mdnvbt6nHX5eLeTPGHVmmaQ+2UijVjZHrhkMJm8ELOVn5NFnis0Nct08bNmzbJcwEzua9GiRYqOEHAvwhYAALAiPcZkWM/MmTNN79++fbvasGGDatSoUUyFKHV5GU9lZfbs2aZ1+UjbWWUAmUr+u+++C5txZMbCkiVLqrQFrtdee01deOGFekKJ+vXrq6uvvjrT/Y888ohq0KBBTHPwi82bN4dtppTFyaQ7oUygEUzeeJllZOLEiab7lMXLZE59ANYIWwAAIJqZxJ977rlMSykZhg4dqrp06RLTpBmiW7duOjjJYsRmY8hkjoXGjRtnuU+mdJdtFi5cmOW+pUuXqu+//17ddNNNWe6TpaZkHJfMVGhGXkfHjh0jtoIlJXBJC9Itt9yiC1qCjKRDGYgW2rJ0xRVXqGXLlsU8ME/W25LCHDx4sF7J2tivNF1Kn1MZo3Xbbbeptm3bZtpOCmPChAnq8ccf14Pb5AQ4e/asLnwZEPfss8/qvpgAzBG2AABANNq1a6enTZf6uBGQ9u3bp+vhixYtUkOGDIm5IMuUKaNGjBihWrdurevvUo+XaeClft+7d2/9r1n4yZcvn677GzMOSquU3ORnCUzjxo1T+fPnz7KdtHpJg1HTpk3VF198kTFcSRp+ZG2uefPm6dAVj4QDl7QuffDBB7ov5KpVq9TPP/+sLr300iyPu+666/TixDKvfSykH+a3336rFxqTgitevLgeRFe3bl31+eef6wKVNGqmZs2a+g2S55RwJdv2799fvfzyy6p79+5xv2bA6whbAAAgFhKAWrVqpcOX9DK77LLLdEBasmSJ5ULEixcvNs0Nwa1co0aN0vV3qcfLRBjSJXDBggWqVq1alttJ48r06dPVq6++qkqVKqVv8rM0/EiAsyJr/Pbo0UNP/y6zFcpxN2vWTE/iIZNqxNOdUGQLWA1yitLf//53PWbrhx9+yBhHJX00pckudCILuf/PP//UocytZIpKOYkOHToU9ZSbgJu4NWy9Uy/zTKXp5NYyBACvOHX0lJrSbJLj6mtGPfK8UYNV9nyxdbGL5OzxE2r7g0877jXDhhYuGUNVqVKlqKZ6LFq0qNq1axflDjgUQQEAAMBhgUv6U0a7MLCkehYRBpyJsAUAAODAwPW3v/1NT2Zx9OjRsI+TRcJkSsiLL7440acEYDPCFgAAQHIkHLjatGmjZwAcOHBg2MfJtPAyXOzGG29M9CkB2IiwBQAA4ODA9eijj6qyZcuqV155Rc9p/8knn+gZScQvv/yiF0G75ppr1Lvvvqtbwx544AE7jhuADQhbAAAAyZUz0R3IRBgyL73Muy+LCQevs1W5cmX9r7RsycQaMj27TKsIIP0IWwAAAC5o4TLWylqzZo1u5WrSpIkqVqyYXnNLpr2UaeNfeOEFtXr1alW1alU7ng5AgghbAAAALmnhMsiKzQ8++KC+AXAuwhYAAIALAxfgRYQTd71XTlj8mHMGAADY3qUQAJwg3WEn3c8PAABc3sJ19dVXJ/yE2bJlU/Pnz094PwDgpJYuwhYAAEg4cC1YsCBskDJmJAx3n/EzAHgldBG2AACALYHryy+/NP394sWL1TPPPKOniL/rrrvUxRdfrEqXLq327Nmj1q9fr9566y114MABvThyw4YNY3lKAHB06CJsAQAA2wKXTPke6ptvvlHDhg1THTp0UBMmTFB58uTJ8pinn35ade3aVQ0dOlQtWbIklqcEAMeGLsIWAABI+qQZgwYNUrly5VLjxo0zDVsid+7c6s0339SPk/AFAKmSrFBE2AIAACkJXP/973/1gsayDlc4cr88bunSpYk+JQCkNRwRtgAAQMoC14kTJ9TOnTujeqw8Th4PAKlmV0gibAEAgJQGrksvvVTt2rVLvf7662EfN3bsWB245PEAkA6JhiXCFgAASHngeuyxx/R07z179lSdO3dWCxcu1LMTyu/k36+++krdeuutqkePHnpKeHk8AKRLvKGJsAUAANISuG688Ub13HPP6TD1/vvv68WRy5Qpo3LmzKn/veqqq9SUKVP0Y2U2Q3k8AKRTrOGJsAUAANIWuMTjjz+uVqxYoVuySpYsqVu3jJv8/z/+8Q/19ddfq759+9rxdACQsGhDFGELAACkbB2ucC677DI1ceJE/fOhQ4fU0aNHVcGCBVXhwoXtegoASOk6XYQtAADgiBauUBKyypUrR9gC4HhWoYqwBQAAHBu4AMBNQsMVYQsAADimS+Fdd90V0+Nlco3x46278ABAOrsXErYAAICjAtfbb78dVcgSMokGgQuAUxG2AMC9Vu8tm/HzmT9OpvVYAFsD14QJEyzvO3bsmNq0aZOeFv73339X/fv3V+XLl0/0KQEAAOBzwQEL8HTguvPOOyM+ZujQofpxr732mlq5cmWiTwkAAACfImjBbVIyaUb+/PnVm2++qaeLl1YuAAAAIFaELbhRymYpLFKkiKpWrZr65JNPUvWUAAAAAOCfaeF/++03dfDgwVQ+JQAAADyA1i24VcoCl3Qp3LFjh6pcuXKqnhIAAAAeQNiCryfNeOaZZyzvk2ng9+7dq1asWKEny5Ap4Xv06JHoUwIAAMAnCFtQfg9cgwYN0kFKwlU4efPm1RNm3HfffYk+JQAAAAD4I3ANHDgwY2HjUPL7AgUKqEqVKqmrrrpKT5wBAAAARIPWLXiBLS1cAAAAgJ0IW/CKhAPX1q1bdXfBUqVKRXzsnj171IkTJ1T58uUTfVoAAAB4lNfDVu7duVSOvLls3eeZE2ds3R8cNEthxYoV1U033RTVY2+55RbdvRAAAAAA/CDhFi4RacKMeB8LAAAAf/B6qxb8y5bAFa3Dhw+rPHnypPIpAQAA4FCELPhBSgLXyZMn1cKFC9WaNWvUhRdemIqnBAAAgMMQsOBHMQeuwYMHZ1nseMmSJSpHjhxRdSfs1KlTrE8JAAAAFyJgAXEELglNweOwoln0OF++fHqyDJk0o2/fvpQ7AACARxGygAQDl6y7Fbz2Vvbs2dWVV16pvvrqq1h3BQAAAAcgJAEOnhb+6aefVl27drXnaHzkzq+7pfsQAAAAACQZgSuNYYvQBQAAnKBmyZ3pPgTAs1I6LTyyhiz5/3fqjadoAA+Rv2kuqADwU+iiSyJgU+C6+uqr9b8VKlRQEyZMyPS7aMkkG/Pnz1d+ZFUBI3QB3mFcQCF0AfBjWCN4AQkGrgULFuh/L7rooiy/iyVw+VGkq92ELsD9QlurCV0A/Bi8CF1AAoHryy+/1P/mz58/y+9g7bI5TymlykZsqid0Ae5l1TWY0AUAgL/FFLiaNGkS1e8QGraiR+gC3CfSOExCFwA/oZULsHnSjK1bt6q8efOqUqVKRXzsnj171IkTJ1T58uWVH8QatgCkT6MiG+Pa7u4qi6J6HKELAAB/Snha+IoVK6qbbropqsfecsstqlKlSsoPEglbzG4GuEO0YQsA/IZp5gEbA5cIBAJJeayfW7YIXYCzW7fiCVssAQEAgP/YEriidfjwYZUnTx7lZXZ2IyR0Ad4JWwZCFwC/oJULSGHgOnnypPr000/VmjVrdBdEr0rGmC1CF+CdsGUgdAEA4B8xB67BgwerHDlyZNzEkiVLMv0u9CbTyLdq1UqdOXNGderUSXlRMifIIHQB3glbBkIXAD+glQuII3DJGKzgmyxkHPq70JvMYlitWjX1zDPPqCeffNJz5Z6K2QgJXYB3wpaB0AUAgPfFHLgGDRqkzp49m3GTQHXllVdm+l3o7dixY+r7779XAwYMUDlzJjwTvW+nfid0Ad4JWwZCFwCvo5ULfpfwGK6nn35ade3aVflROtbZInQB3glbBkIXAADeldOOwOVHDecNVTnyp2fGRQldVNAAe8PWNfk3ZfldxfN2payYWRgZgNdbuVbvLZvuwwC8Py087ENLF+CdsGXgQgoAAN5j24CqRYsWqf/85z9q9erV6vfff1d//vmn6eNkko2ff/5Z+ZFc2bGzHzMtXYB3wpaBli4AXkUrF/zKlsDVo0cP9frrr+sJNCKRwOVXDBoFnD9mywkIXQAAeEfCgWvSpEnqtdde09O+jxw5UvXt21d98803auPGjWrbtm26xevll19We/bsUS+99JJq2bKl8iPCFpzEjq5rbujWuuhglbhC15btZdLayuWGsgUAACkawzVu3DjdajVlyhR19dVXqzx5/ppI4oILLlBNmzZVvXr1Uj/99JO67rrr1EMPPaT27t2r/IawBSexa5yQW8YbSegK5/M/KisnsTtsyfvklvcKAAAvSjhwrVmzRpUvX17VqFEjU5fB4O6FsvbWm2++qXLkyKGGDRum/ISwBSexu+Lt5dAlrVxeCFtmPwMAABcFruPHj6tSpUpl/H++fPn0vwcPHsz0uMKFC+tuh0uXLlV+CVqELThJsircXgpdobdxGxt5ImyF+x0ApArTwsOvEg5c5557rjpw4EDG/5cp89dV4XXr1mV5rHQnPHz4sPI6ghacJtkVba+ELjOpCF2pCFvR3AcAABwYuKpWrap27tyZ0YXwyiuv1D8///zzmaaGnzhxotq6dauqVKmS8jLCFpwmVRVst1TknRa6Uhm2YnkMAABwSOCSyTD++OMP9dVXX+n/79Spk27lmjNnjg5jN910k2rcuLHq0qWLHt913333Ka8ibMFpUl2xdktF3imhKx1hCwAAuCxw3XzzzWrIkCEqV65c+v8LFiyoZs+erVuytmzZoqZOnaoWL16sJ8x49NFH1YMPPqi8iLAFp0lX5dstlf50h650hy23vE8AACi/B67SpUur/v37qwYNGmT87vLLL1cbNmzQE2RMnjxZTZ8+Xa/Jdeedd+pZDb2GsAWnSXdlOt3P7/TQle6wleh2ABArJsyAn2VP2o6zZ1f169fXXQzbtm2rg1mTJk1UrVq1lJcQtuA0TqlEO+U4nBa6nBK27NoeAACkKXBZCV6fy81qFN9F2ILjOK3y7LTjSXfoclrYsns/AADAAYEr3pA2bdo03VImE3IUKlRIjxF74IEHdFfFcKRrY8eOHVXJkiVVsWLFVKNGjdTHH3+csmMHUsWplWanHleqQ5dTw1ay9gcA8JezZ8+qV155Ra+7K+vvnn/++apXr17q0KFDCe137ty5uv5etGhRVaJECdWhQwf1448/RtxOlqIaNWqUuuiii9R5550X1XN9/vnn6tZbb9WPP+ecc/S/d9xxh+lyV54KXDKVfJ06dXSByQv+6aef9BsnE3EUL15cjxf7/vvvTbddvXq1niGxVatWavv27Wrfvn16gg+ZuOONN95I+WsBksXplWWnH19w6Ir1Fk2QcnrYSvZ+AQDe17VrVz1LuczdIHX1b7/9Vk+q16BBA3Xw4MG49jl+/HjVo0cPXX/fv3+/rs+3bt1aD1OS/ZuRrCCNMhdccIFauXKlGjp0aMTnkeO75ppr1GOPPaZatmyp55w4cuSI+u677/RwKFn2av78+SpeOZXDScHK7IadO3fO9PuyZcvqwhd9+vRRn332WZZWMXnjZT0wmZLe0LRpUzVv3jx1xRVX6Cnty5Url6JXAihfV5LlOO0OHk4hr8sr6515+X0CkB5MmOF9M2bMUMuXL9eNHXny5NG/k95lL7zwgm5peuqpp3TjSSx27dqlA5BMwietVCJv3ryqW7duKl++fLqev2rVKr3sVLCZM2fq1rX169frFjGZNT0SCXNt2rRRPXv21PNQGOQ19O7dW7d2ydJWEuY82cIlqTg0bAWTpkpZA+zEiROZfr9kyRJ14MAB3SoWqnLlyqp9+/Zq3LhxSTlmIFXcErbceryxsAopdoYXr4Q6AIC3jB49WvXt2zcjbAUbMGCAevvtt7PU1aNp3ZIQZIStYNLt7/jx4xnrAAd75JFHVL9+/XTYipa0hj300EOZwlYwabyRnnKbNm1SngxckUhhSp/OvXv3Zvq9tHjJmC+rgpP7Pv300xQdJWA/t1aK3Xrc0QgNV24MW+l6PgCAO0mQkoYOCUdmypcvr6pWraoWLVoU036lLt+uXTvL++X5UlWXl/WE5TVIq1tKuhT++9//VvE6efKkSoZTp07pBZeDrV27NuybVLdu3YQHwAHp4vbKsB+6F7o5bPnhfQIA2ENafWSIjkxOF6ne3bx586j3K3V5mcch3D6nTJmiUkVyTGjeSFrgkia10L6S0ZJxVfFua+Wbb77RM4hIK1ewX3/9VVWsWNFyu1KlSulELgPipF9muMINDorSD9WvY0fgDF55v71cmfdC2PLD+wQg+Ri/lXqhdVXp5mfW1c8ukercRiuXTIQXrWPHjunXIXM22LXPRPz2229q586d6pJLLklN4JIXZ3doipf03ezevbvuMxrq6NGjqkiRIpbbymuQ6eXlceEC1/Dhw9XgwYNtO2a4S7oruwAAuFnNkjsJXSby71EqR257y/rMqb/+lQkjgj399NNq0KBBKlki1bmF3B/N5BXB+5R6utXQIGOf8rhUTHd/991363kjcuaMb77BmLeKpbCS/eJvu+02VaFCBT1wLpS0SuXOHf5MlrQfaQCfDLqTWRANkrZDT+R0o5ULbkSrSfTllM7gz/sEIFGErtSSNWolrBiS2bplZ5072fuMl+QAmStCZkyMl2snzZD59aUZ8Z133rF8E2RsV6Q3U6aXDEf2Iydt8M2JqBTBTThf3VFevE8A7AxdSI3QemuyA5ddde5k7zMe0tNNppmXae9lTTHPrsNlRroQysLHCxcutOwOKIPaIi2yJq1V8Q5+c6J0XwkHokEl3h1/37xPAOxGS5fzyFTo06ZNi3k7maxCFgOOts598ODBmOrc8lipp4eb/yHWfcbqtdde09Pdy9TzZcqUSWhfrgtcw4YNUx9++KGeWrJ48eKWj5OuhtL90TgZQu3evVun4nDjt9yI0AUnoxLvjtDF+wQgWQhdzjJy5Eh9S4RR5w5n69atputpWSlQoIBunduxY4eeHM9qnzK3RDJMnDhRj3v78ssv9RpdiXJVl8IxY8aosWPHqvnz50dMmtWrV1crV660vH/FihWqWrVqyouoLMGJOC/dUY68TwCSje6F3lK5cmUdjA4cOGBrvbt6muryH330kXr44YfV3Llzbdu/awLXpEmTdOvW559/rpN0JDLP/6xZs3RTpBm5r0WLFsqrqDTBSTgf3VGevE8AUhm6CF7eID3GGjZsqMc6mdm+fbvasGGDatSoUUz7lbq8hB8rs2fPtr0u/8UXX6hu3brp11KrVi3b9uuKwCUv+pFHHlHz5s1TVapUiWobeeMLFy6smwRDbd68WU2dOlVP8ehlVJ7gBJyH7ihX3icA6UDo8oaePXuq5557LtPatYahQ4fqdXxjneBCgo8Ero0bN5qOIZOJNRo3bqzs8vXXX6tbbrlFvffee6pBgwbKTo4PXDI5hgQjaZGKZbExGWA3YcIE9fjjj6u33npLnwAylbxMtNGyZUv17LPP6lWxvY5KFDj/vMuuv28+JwCkE6HL/dq1a6fq1aun2rZtmxGQ9u3bp+vhixYtUkOGDIl5nzJ8aMSIEap169a6/i71eJkGXur3vXv31v/atTawHHObNm10ZmjWrJmym+MDl3QhlFlIpMlQFjizupk1+9WsWVO/QXPmzNHhSibZ6N+/v3r55Zf1gsl+QWUKnHfelejfN58PAJyA0OV+EoBatWqlw5f0Mrvssst0QFqyZInlwsjSsHLppZeGbeUaNWqUrr9LPV4m0JBGmAULFoTt8tepU6eMjCD737lzZ6bcIFkg2NKlS3VAvP3228PmjRIlSsRVNtkCVoOcYEqmqJSTqNP821TugjYvEZ5kTBmPVKES746/b94nAE6zem9ZW/Zz5o+T6oebR6hDhw45ag1Vox5Zo/uzKkdue9eQOnPqhPrhjScd95rhghYu2IfKFVKB88wd5c77BMCJaOmCFxG4fIZKFji/vCvav28+BwA4GaELXkPg8iEqW+C88u/fN3//ANw0bTzhC15A4PIpKl3gfPLf3zd/9wDcHr4IYHAjApePUfkC55F//r75ewfgFYQvuA2By+eohIHzx7v4+wbgdYQvuEHOdB8AnFEpY8p4xHPewPl4nwD4RXB3w29/LZ7WYwGC0cIFjUoZAADwihrFd6X7EIAMBC5kIHQBAAAA9iJwIRNCF1JJurLSnRUAAHgZgQtZELqQCsFBi9AFAAC8isAFU4QuJJNZwCJ0AQAALyJwwRKhC8kQLlgRugAAgNcQuACkTDSBitAFAAC8hMCFsGjlgl1iCVKELgAA4BUELkRE6EKi4glQhC4AAOAFBC5EhdCFeCUSnAhdAADA7QhciBqhC+kITIQuAADgZgQuxITQhXQEJUIXAABwKwIXYkboQjoCEqELAAC4EYELcSF0IR0IXQAAwG0IXIgboQvpCEWELgAA4CYELiSE0IV0hCFCFwAAcAsCFxJG6EI6QhChCwAAuAGBC7YgdPlbusIPoQsAADhdznQfALzDaaHLSZVxKRsnHY+dvPq6AAAA7EALFzzLKQHQOA6nHI+dQcsJYcsJxwAAAGCFwAVPS3fICX3+dB+PVxG6AACAUxG44HnpCjlWz0voSg5CFwAAcCICF3wh1SEn0vMRupKD0AUAAJyGwAXfSFXIifZ5CF3JQegCAABOQuCCryQ75MS6f0JXchC6AACAUxC44DvJCjnx7pfQlRyELgAA4AQELviS3SEn0f0RupKD0AUAANKNwAXfsivkEJacjdAFAADSKWdanx1IMwlLiVTI7QxbiR4LrEm5EowBAE5RYNcZlTPXGVv3efpPe/cH+9DCBd9z0tgrQkHyEGYBAEA6ELgAh80uSOhKHkIXAABINQIX4MD1swhdyUPoAgAAqUTgAmIIOqkMQoSu5CF0AQCAVCFwAVEGnXQEIEJX8hC6AABAKhC4gCiCTjqDD6EreQhdAAAg2QhcQISg44TA44Rj8CpCFwAASCYCF+CSoOOkY/EaQhcAAEgWAhfgIoSu5CF0AQCAZMiZlL0CSGroIhzArew6d7n4AABwC1q4ABeisgk3svNCARcdAABuQeACXIrQBTdJRkAidAEA3IDABbgYoQtukMxgROgCADgdgQtwOUIXnCwVgYjQBQBwMgIX4AGELjhRKoMQoQsA4FQELsAjCF1wknQEIEIXAMCJCFyAhxC64ATpDD6ELgCA0xC4AI8hdCGdnBB4nHAMAAAYCFyABxG64Peg46RjAQD4G4EL8ChCF/wecJx4TAAA/yFwAR5G6EIqEGwAALBG4AI8jtAFP4ctpx8fAMD7CFwAAE8jdAEA0onABfgArVzwe5Bx07ECALyFwAX4BKELfg8wbjxmAID7EbgAHyF0we/Bxc3HDgBwp5zpPgAA7g1dVF79xwvvubwGLj4AAFKFwAUgblJp9UIFHNHx0nvtxNdCCAQAb6JLIYCEUEn0BycGFK+hjAHAmwhcABJG6PI2ggBlDQCIH4ELgC0IXd5E2AIAIDEELgC2IXR5C2GLcgcAJI7ABcBWhC5vIGxR/gAAexC4ANiO0OVuhC1n4H0AAG8gcAFICkKXO1HJdxbeDwBwPwIXgKQhdLkLlXtn4n0BAHcjcAFIKkKXO1CpdzbeHwBwLwIXgKQjdDkblXl34H0CAHdyVeA6fPiwGjVqlLrooovUeeedF9U2GzZsUB07dlQlS5ZUxYoVU40aNVIff/xx0o8VQGaELmeiEu8uvF8AnOrs2bPqlVdeUdWqVVOFCxdW559/vurVq5c6dOhQQvudO3eurr8XLVpUlShRQnXo0EH9+OOPSckNhnnz5qnrr79elSpVShUpUkRVrVpV3XfffTpXeDZw/fTTT+qBBx5QF1xwgVq5cqUaOnRoVNutXr1aNW7cWLVq1Upt375d7du3Tw0ZMkQ9+OCD6o033kj6cQOAk1F5dyfeNwBO1LVrVzVnzhw1ffp0HbK+/fZblStXLtWgQQN18ODBuPY5fvx41aNHD11/379/v67Pt27dWjVp0kTv387cYHj88cfVo48+qu666y61adMmfezz58/XQTKaoGcmp3KBmTNn6pS8fv16nWy3bNkScZtAIKDf+Oeff1516dIl4/dNmzbVqfWKK65Q1113nSpXrlySjx5AcCsXlUVn4H1w//tHqzEAp5gxY4Zavny5buzIkyeP/p30LnvhhRd0S9NTTz2lW5tisWvXLvXYY4+ppUuX6lYqkTdvXtWtWzeVL18+Xc9ftWqVypYtW8K5wfD222+rL7/8Ui1evFi30hmkheyhhx5S8XJFC9cjjzyi+vXrpwstWkuWLFEHDhxQd9xxR5b7KleurNq3b6/GjRtn85ECiIRKYvoRtryB9xGAU4wePVr17ds3I2wFGzBggA4yJ06ciLl1q02bNhlhK9itt96qjh8/rr766itbcoM4c+aMDoaSD4LDlh1cEbji8dlnn6m2bduq7NnNX6Lc9+mnn6b8uAAQutKJSrq38H4CSDcJUtLQIeHITPny5fUYqEWLFsVcl2/Xrp3l/fJ8dtblFyxYoLsN1qxZU9nNs4Fr7dq1qk6dOpb3161bV61bty6lxwTgf2jpSj0q597E+wognWSckwzRkcnp7Kx3r01xXX7ZsmWqYcOGKhk8G7h+/fVXVbFiRcv7ZdYRSeRHjhwJu5+TJ0/qvqfBN8DvVu8tm3FLBKErdaiUexvvLwBDaL1V6rLprHMbrVxbt25V0Tp27Jg+9rJly9q2z0hkQgx5HZINBg4cqC699FJVvHhx3er1zDPP6C6M8fJs4Dp69KiextGKDLArVKiQflw4w4cP1/04jZsMwgP8LDRkeSV0OeU4koHKuD/wPgPuUWD7MVVgq8237cf0vqWuGlx3lbpsOuvcQu6PVOcOJo+VerrV0KB49hmJzP0gY9BatGihJ+WQmQllhnOZEERa0q6++uq4Q5crZimMh6T53Llzh32MFGqkAXwy6K5Pnz4Z/y9pm9AFv0o0XDl19kKnhi0q0EjnOePUvwsA4W3btk2HFYPZRBZOrHMne5+RSJh68cUX9YR7PXv2zPh9lSpV1JQpU/R4MpkARB4TK8+2cMmbcOrUqYhvpkwvGWk/ctIG3wA/Che27Ahi6arcObVSSdgCAMQjtN6a7MBlV5072fuMRPYl3SNlgWMz0s1w7NixEY/LV4GrYMGCERdZk9YqeRyA9LRsuSX8pBphC07AeQh4n6wtJWtMxXqTdapiqXMfPHgwpjq3PFbq6bKurl37jES6X9avX1/lzGneAfDyyy/X/8az+LFnuxRWqFBBL3R25ZVXmt6/e/dunWTPOeeclB8b4MWwJY+rWXKnq7oXOjHgUcmFk7DAMuBtI0eO1Dc76tzhbN261XQ9LSsFChTQrXM7duzQAc9qnzJxhl0uuOACtX379rDzP8Q7bsyzLVzVq1dXK1eutLx/xYoVetYRAOlv2UpHECJsAdHhIgCAcCpXrqyDkUw6YWe9u3qK6/K1a9cO21InrW1yf8mSJWPet2cDV/PmzdWsWbMsmyLlPpmFBICzwlYqAhFhC4gNoQuAFekxJutXzZw50/T+7du3qw0bNqhGjRrFXJf/6KOPLO+fPXu2rXX5Zs2aqTVr1qgzZ86Y3i/3yWuVgBkrzwYueeOlL+bEiROz3Ld582Y1depUdffdd6fl2ACvhi27Q1oyghFhC4gPoQuAFZnV77nnnjNd82vo0KGqS5cuMU9w0a1bNx24Nm7cmOU+mTVQJtZo3LixbW+KDDNq06aNGjdunOn98jpkQg3pWhgrzwYuKYwJEyaoxx9/XL311lv6BDh79qxauHChatmypXr22Wf1qtgAnNWylcyARNgCEkPoAmBGpkyvV6+eatu2bUZAkjWspB6+aNEiNWTIkJgLrkyZMmrEiBGqdevWuv4u9XiZBl7q971799b/xhN+wpHjfPPNN9XLL7+sF0A2ptnv2rWrHjPWv3//uPbrmsDVqVMnPVBNbrLy886dOzP+X25SMKFq1qyp36A5c+bocCWrRUtByWO7d++u3FoZjuUGeIEdQYmwBdiD0AXAjASgVq1a6fAlvcwuu+wyHZCWLFliuTCyzHYo9fpwrVyjRo3S9Xepx8sEGjIsaMGCBapWrVq25gYhsx5++eWXuhukbFe0aFHdFbJ06dJ6IWRZEDke2QLh5ltEFjJFpZxENd5/TOXIn8eWWdnMpCssJev1wB3sOu+SdR7FW9EjbAH2c+LfFWA4dfSUmtJskjp06JCj1lA16pFXX95X5cxh3xpS4vSZE+qL755z3GuGh6eFd2IF1awS6rRWqEjHQyDzLqedi3ZNGe/ESiEtBPACpowHgOgQuFLIDRXaRF4DYcy93HRuxhK6CFtAchG6AMBDY7jgfIwbc6dkhK1kB7hoghRhC0gNWmwBIDwCF2xH8HIPN7VsxRKoCFtAahG6AMAagQtJ4+bKvB944f0xC1aELSA9CF0AYI7AhaSitcuZ5ZCKY0nV6w0OWIQtIL0IXQCQFZNmICWMyrffJtYIDR3B/5/qsnBS4LObE4OWoPIJP2IiDQDIjMCFlPJL8Iom3KQifKU7ZMnze/29BpAVoQsA/ofAhbTwavCKN+DYFb7SHbAAwEDoAoC/ELiQVmYBwW0hzO6QE08YdXLQSmc3Sjcu1Ax4CaELAAhccKBkhge7KvypnHQi3DE7OWiZ8WP4InTB7whdAPyOFi74SriAEikApCvcmAUvtwUtP3UrNUPogt8RugD4GYELcEmIcfrxxcsvE2sQuuB3hC4AfsU6XADSzmnrlPlt+nogVRjTCMCPCFwAHIPQBXgfoQuA3xC4ADgKoQsAAHgJgQuA4xC6AG+jlQuAnxC4ADiSH8Z1MaYLfkboAuAXBC4Ajub10AX4GaELgB8QuAA4npdDF61c8DtCFwCvI3ABcAUvdzEkdMHvCF0AvIzABcBVCF2ANxG6AHgVgQuA6xC6AG8idAHwIgIXAFcidAHeROgC4DUELgCu5dVxXYzpgt8RugB4CYELgGeCl5fCF6ELfkfoAuAVOdN9AABgJ7PQVbPkzqQUcjQBL1nPDfgldHHxAYDbEbgAeF46W76M5yZ4Ad5o6SIAAogVXQoBIAW81N0R8DOnBUAAzkfgAoAUIXQB3kDoAhALAhcApBChC/AGQheAaDGGK04HdxdU2fPlVW5R9Nwj6T4EAP+PcV2ANzCpB4BoELh84sBv5yR1/wQ6IL7gxWQagLsRugBEQuBCygJdKkJZ6HEQBOF0hC7A/QhdAMIhcMExocwsHCXaMkcAgxsQugD3I3QBsELggm+6PVo9B61gcALGdQHuR+gCYIbABd8jhMFJaO0C3I3QhWhk27JLZcue29bCynb2FIXvUEwLD1iEsNAbkCpMHQ+4G1PGAwhG4AISCGEEMSQLoQtwN0IXAAOBC0gQQQwAYIbQBUAwhgtIknhav5jAAwC8hTFdAAhcgIM4ZT2zaDipO6VTygQAUhW6rLods5g64DwELsBlgoNOqoOGk0KW2XERvAD4IXSFG+Npdh8hDEgvAhfgYqkKGk4NWmbHSegC4NXQFe9kOoQwIL0IXIAHJKPVyy0hKxStXQC8FrqSMWspIQxIHQIX4DGJhC+3hiwztHYB8IJULhER/Fx0QwTsQ+ACPCw0QAUHMC+FKy+2dq26bki6DwGAj0n4InQB9iBwAT7ih5DlhdYuwhYAJzBavAheQGIIXAB8wcmhK7gyw0KpAJyG1i4gMQQuAL7hhNAV7koxYQuAUxG6gPgRuAD4SqrGdcXaBYewBcDpCF1AfLLHuR0AuFoyx7MRtgB4VSpnTQS8gsAFwLeSEboYXA7A658phC4gNnQphGfl+S2XLfs5ee6ftuwHzpTuqePpSgjAjeheCESPwAVPsitsxbovwpl7pWNCDcIWADcjdAHRoUshYCMJZ2Y3uEMq1ykjbAHwAroXApERuOA5Tgw4TjwmpA9hC4CXELqA8Ahc8BQnBxsnHxtS18pF2ALg1dBF8ALMMYYLnkGgib2cGHOW2vFchC0AXhccupw4wyKQDrRwwRPcErbSfZyhz88YM3uFq1wQtgD4Da1ewF9o4QJSTEJOOlqWwoU9Wr2S28pF2ALgZ+lo9fphf5mUPA8QDQIXXC/drUapCl1G5T+eMUaxlJHxWLob2oOwBSBRElK8Mj7KeB12Bi/zsjlp2/6BRBG44GpuDFtuKSNavRJv5SJsAYC9rV5eCZ7wFwIXXM1ohXFb8Iql9Si0wh9rS5c8VzzlQwtXYqGLsAUAibV6Ea7gFQSuOBUpfVTlyJ/6cTh+EkvXudBw4MQAlkjIivSYSGUV/Ny0XMUm2rAVXFEgbAEIRz4j7vy6m2+7FVrx+uuDfxG44JqKbiIBzA0S6boWb/iC/QhbAKL9rCB0JU+N4rvUD5yKcAgCF3wRwJwqGWs9xRK+7HqeRHnhvZQrs6uuG5LuwwDg8dAFwH0IXHAttwawZISsaJ4rlvJJ5TE6WSzlQNgCkIrQ5YeuhYmSMjp1NN1HAfwPgQuekUgASyRgRPM8iezfavamWL9wnRyi5NgSDczpWt9MELYAJILQBXgbgSuBvsG5C+a2992AqXiv5KUqYNj9PNFOj+u12ZzsCF3pQNgCYAdCF+BdBC44nlkAcXu4CGbX4o9eKKd4Q5cx86KdrVzRBGnCFgA7MaYrcXYuqAzYhcAFV7Krm53XvwhiaQVL55eU0983M4QtAOkOXYznAtyBwAVP4cqWO8snuNKQaNfCVIzlImwBSCZCF+At2dN9AADCa1Rko+nNy2Ew0XFxiS58He75CVsAnLamn1MvpqUa5QCn8kUL1/Lly9XAgQPVypUr9f/XqVNHDR48WNWvXz/ufTYosknlK+iL4nOURQerKC+KJ0BF2saNZWVnS1cyELYApBItXXCTs2fPqlGjRqmxY8eqHTt2qEKFCqn27durZ555RhUuXDju/c6dO1c9++yz6ocfflA5cuRQTZo0UcOGDVMXXXSR6eMDgYCaPn26euedd9TXX3+tjh07pkqUKKGuvfZa1a9fP3X++eeHfb4NGzao/v37q4ULF6ozZ86o6tWr6+1at24d92vwfGKYN2+e6tKli3r11VfVDTfcoH83a9YsdeONN6rx48cnVHhwZjBxatBIdauUm1rBEnnPrFqz7O5aSNgCkA6ELrhF165d1a5du3TYqVq1qtq7d696/vnnVYMGDdSSJUtUkSJFYt6n1NUlXL311luqcePG6tSpU+o///mPDl0SxGrVqpXp8Vu3btV1fAl7PXv21I8tUKCAPq7XXntNXX755erLL79Ul1xyienzrV69WrVo0UIHPNk2V65c6quvvlLdunVT27dvV927d4+rbLIFJAZ61PHjx1XlypXVpEmT1FVXXZXpvsWLF6ubb75Zbdq0SeXPnz/qfR4+fFin9JHf1KeFC0hS6AqeRCNSK1e47oPxBC6r7oQELgDpFMviyG6ciMju7oSnjp5SU5pNUocOHdKVb6cw6pHNit6pcma3d3mh02dPqfkH3knLa54xY4bq27evDix58uTJdF/37t3176T1KxYSkqR1aenSpVlasyZPnqzD3KpVq1S2bNkyfi+P/fXXX1Xnzp1N9/nUU0+pZcuWqc8++yzLfRKJateurR566CHdWBNM8sIVV1yh1qxZo8qVK6di5ekxXFOnTlUXXnhhlrAlrrzySv0mfvDBB2k5NgDWLXJ2jedKdCyXgbAFIN0Y0wUnGz16tA5coWFLDBgwQL399tvqxIkTMbdutWnTxrTr4K233qobVqT1KZi0plmFLdGrVy+9jdmxSCvcgQMH1B133JHlPmnAke6R48aNU/HwdOCS9NquXTvL+9u2bas+/fTTlB4TEK9r8m/SN7+wcxKNRBC2ADgFoQtOJOFFwoqEIzPly5fXXQwXLVpkaz1eni/WeryM5SpatKju7mj2fJINsmfPbntu8PQYrrVr16p77rnH8v66devq9ByPpvk2q3PyezqvwqG8GLo+/6NyRitXLOO5omnBimUsV2iwI2wBcBrGdGXF7ITpJd3tpJtdsWLFwta5161bp5o3bx5TPV4mugu3zylTpsR8vDIOrGDBgqbPFy7gGa8hHp5ODNKHs2LFipb3S+KWwXUAnBMindK1kLAFwKlo6YKb6tvx1LllZkEZ71a2bFlb6/HffPONOu+883QrV6yvo1SpUro178iR2Osjnm7hOnr0aNgZUeQ+eUw4J0+e1DeDDET8a99nbTxSAMePn84ohDo516mlB/9q9bo43xb1w/4y+udChU6qg7v/d1XqzIkzURfc2eORW7nO/PHX3/qSlgP0Bz0AOJVMChGt4M9Rv5TFn8f++p1T54Y7HTil1Nkk7PP/J+YIJuOqzMZWpaq+LeT+LVu2qFj2KRN/WHXvi7YeH0zGfMkEHjLWLJ7XIZNzyDHJ4845J7ZlazwduCQo5c5tPQOMnHzSrCh/jMEznAQbPny4XrMrVIN6+2w9VgB7QopgWcqLZPv//1tYjeDtAACX+CHMffv3709oDSi7Sb303HPPVQt/ezcp+5eucqHrTD399NNq0KBBKl31baPOHcukGXbvU9YIu+2221SFChX0hBupeE7fBC4jUFkVnlGwVmFLyEJnffr0yfj/gwcP6jdLmjCd9AfsFXJVRj4otm3b5qhpXL2EMqZ83Y5zmPJ1O87h5JMeSdLlLNy4onTImzev+uWXX3T9NBnMGhGS2bpl7D/S6zl58qR+7ena5wMPPKDr7l988UXKntM3gUtSvgQks4FxItx9kZphJWwRCJJHypbyTS7KmPJ1O85hytftOIeTL1yXtHSRCns8lfZkkDWnpk2bFvN2MlmFLLEUXN8O52AUde5g8li5MBGuF1q0+5QuhLL+7sKFC8N2BYzmdcgxxfI6fBG4pCVK+ovK4DgzknTl6gcAAADgNyNHjtQ3O+rb4WzdutV0PS0rBQoU0BckduzYkVA9ftiwYerDDz/UU9IXL148qtdhBMlQu3fv1kE51vFbwnmx30aysPHKlSst71+xYoWqVq1aSo8JAAAA8ApZFFiCkSwabGedu3qC9fgxY8aosWPHqvnz56syZcqkNTd4OnDJXP8fffSR5f2zZs1SLVq0iGmf0r1QBh8muz+sX1G+lLHbcQ5Txm7HOUwZewHncepIq0/Dhg3VzJkzTe/fvn272rBhg2rUqJGt9fjZs2db1uMnTZqkW7c+//xz3XIV7fNJNrCa2TKe3GDIFnDqfJk2kOkfJXVPnjxZNWnSJNN9S5cuVR07dtSLteXPnz9txwgAAAC42YwZM/REc6tWrcrSKHHfffepXLlyqVGjRsW0z127dulWp2XLlqkqVapkGUMmM4nL84WO8ZLgd8899+iwdckll0T9fBKJateurXr37q3uuOOOTPdt3rxZ1atXT61evVov8hwrT7dw5cuXT7311luqc+fOOiGfPn1a3+RnCVvjxo0jbAEAAAAJaNeunQ4kbdu2VRs3btS/27dvn3r88cf1+KkhQ4bEvE/pBjhixAjVunVrPeGFTO0uU7JPmDBBhyL5NzRsyeQYd999t26NiiVsCdmX7FOOWfKDzEgozynP3bJlS/Xss8/GFbY838JlWL58uRo4cKDueynq1q2r19aqX79+ug8NAAAAcD0JJ9KKJeOmZEyXTC7Rvn179cwzz1guKCwBSaZsX7NmjeV+586dq7sHrl27VuXIkUM1btxYhx+zSThkvTG5L1LvtUqVKqlvv/3W9D7p/vjkk0/qoHXmzBndyiatd9ddd52Kly8CFwAAAACkg6e7FAIAAABAOvkmcElDnizsJn1LpU+ozO0vzYnSjLlt27aw/TmlGdTs9o9//CPiYL+uXbuqc889Vz9eBuL9+9//Vl4Ub/ka5s2bp66//npVqlQpXVZVq1bVgyylWdeKn8o3njLeuXOn5blr3KTJ/aqrrrJ8Tso4+vNYxoY2bdpUL4ou3SguuOAC1atXL7V///6w2/mpjBP5nFiwYIFq1qyZKlq0qP6cuPrqq/WA6Ej8VL7Gopzjx49XN954ozr//PN1Gcs52aBBAz1uOVynFvm8lfHNJUuWVMWKFdMzin388ccRn5Myjr6MZfzJ22+/rerUqaPrFzKuPBp+KuN4z2H5PLj11lv1mk3yGSz/ysQH69ati/icfipfpEnAB3799ddArVq1Ak2bNg18+OGHgSNHjgTOnj0b2LFjR2DAgAGB4sWLB9asWWO6rRTRn3/+GfNzbtu2LXD++ecHhg8fHjh8+LB+vpUrVwZq164d6NevX8BLEilf8dhjjwVq1KgRmDp1auDQoUMZ5ffKK68EZsyYEfB7+dpRxla6d+8e6N27t+l9lHH0ZfzCCy8EKleuHJg1a1bg6NGjertffvkl8MADDwQqVaoU2L9/v+/LOJFzePLkyYFy5coFpk2bFjh16pT+nfy9N2zYMPDOO+9Ynt9+O4dFq1atAvfee2/gyy+/DBw/flz/bt++fYFJkyYFKlasqO8zs2rVqkCpUqUC48aNC5w4cSJw5swZvQ85f8eOHWv5fJRxdGUs5/kTTzwRKF26dKBdu3aBzz//POr6hd/KONZz+MCBA4FmzZoFLrvsssDbb7+d8Xm7Z8+ewEsvvRQoWrSoLm8rfitfpIcvAteSJUv0F7YV+bK/5pprbA1cbdu2DTz99NNZfi8fBOeee25gxYoVAa9IpHwnTJgQqFOnTuDgwYMxPaefyjfRMrYilaoiRYoEvv32W9P7KePoylgqAgULFgysW7fOtBw7deoUGDhwoO/LON5zeO/evYFixYoFvvvuuyz3SbiVizW7du3yffkaTp48aVnGW7ZsCeTLly9LsJUK5uWXX64/j0P99NNPuvy3b99OGSdQxhMnTgz07dtXX3iItX7ht8/iWMt306ZN+gKtXCQwIxcR5IKYFb+VL9LDF4ErEvlCz507d8aVlEQDl1wtkQqYXCkxM3To0ECXLl0Cfi/f06dPB8477zx9ZTUWlG/0ZRzO+++/ryurlHFiZfzRRx8FqlWrZrnde++9F2jRokWW33MeR1e+L7/8cuDGG2+0LN/Ro0cHnnrqKco3Stdee21g5MiRmX63aNEi3XJgVWG9++67A4MGDaKMEyhjM9HUL/iciL98g+sacnFRLh5QvkgX34zhCqdEiRJ6XMDevXtt2d9nn32mxxpIH2IzMn7h008/VX4vXxmTUa1aNVWzZs2Y9kf5Rl/G4Uj/9NCF/Sjj2MtY1ukIN2ZDpsk1m56W8zi68pVlPWTshhW5T9ZboXyjIwuSyjii0HNRvpeyZ88e03cW53D0ZRwvyjjx8pVpxGVcuIzTonyRLgSu/3fq1ClVsGBBWwpV1gmQAbFWZD7/AwcOqEOHDik/l6+sHN6wYcOY90X5Rl/GVqRSK1/kVhO/UMbRl7FcNJBFHqXMzEydOlU1b96cMo6zfOVclSBmRe77/vvv1Z9//sk5HIF87yxdulSfs7H8vcvalWYTD/A5EX0Zx4sytqd85cKY2fcj5YtUIXAppb755hs9m43Vl7qsLl28eHE9S47MPNalS5ewC7T9+uuvqmLFipb3y8xEMvPO1q1blZ/L98cff9TldOTIEb0w9aWXXqrLWT5IZZG848ePm+6P8o2+jK1MnjxZNWnSRJUtW5YyTvA8lgsorVq1UjfccIOegU8qBDLzmJzfstq9fNHfc889nMdxlm+BAgXU77//brmd3CcLU27ZsiXT7/mcyFxGc+bM0cFfZmG79tprYyormRVSWhTks5oyjq+M48V5nHj5/vbbb3rW3ksuuYTyRdr4PnBJpb579+6qb9++pgUkFakePXqozZs364qUtApceOGFepVrqbSaOXr0qOWK2ga5Xx7n5/KV8pSuAS1atFD58uVT8+fPV/v27VMzZszQV1Nl2mez0EX5Rl/G4boT3n777Zb3U8axlfG7776r/v73v6sOHTro6bTlfL744ot1dziZxjhXrlyUcZzlK60rixcvttzWuC+0x4Dfz+HRo0dnLP0gF7Jk2Y0KFSroJTiki1UsZSUXCWVq7tCyooyjL+N4+bmMYzmHw3XplgtfskRHzpw5s9zv5/JFavk6cMkf4m233ab/gGXtBjOyBkn79u1165b0b5c1Y/r3768++eQTdf/99+urT6Hkinbu3LlT1sfbreUrlawXX3xRd2vr16+fXvtFvtirVKmipkyZokqXLq0GDBiQZTvKN/oyNiNhVrrAyXlthTKOrYzl6qt8RsgV2D/++EN3jVu/fr2qV6+evsnVVco4vvKVtXFkvOfKlSuz3CctLhMmTNAXwUI/T/1+Dvfs2VMdPHhQVxSlN4VcZJHvK7loGCresqKMoy/jePm5jGM5h6306dNHd0t+7LHHTO/3c/kitXwduGSxTfkjfuedd2Letn79+qpz5856cT6zP06pcIUjf+R58+ZVfi5fef3y4SkLHJuRboZjx47NUpaUb/RlbEa+tKQlxmwiB8o49vNYKgPyWSDdYFu3bq1bt+TCwUUXXaQ/H6SV/Mknn6SM4yxf6fYqrYRt2rTRF2LkQo10IZRxHNdcc4164okn9ARFoecznxN/kQuF0oVdWrRlYVg5T5csWWJLWVHG0ZdxvCjj+Mt3+PDhaubMmbrXjFkvA8oXqeTbwCVdV6QrirRUWc0mGIn0Jf7uu++y/F4GZspVmXDkfrsm6XBr+UqLgARXs2Z+cfnll+t/ZSxMMMo3+jI2a034z3/+Yzk7IWUc+3n8+uuv63GeMsueGWmlfe+993TZU8axl6+46aab9OQjkyZN0i1hchsyZIh64YUXVKdOnXQLY2i3ID4nspIyeuihh3RXrVjL6vDhw1m+syjj6Ms4XpRxfOX72muv6cdIa1iZMmUoX6SdLwPXsGHD1Icffqj/EKVfcLykgnDs2LEsv5fKQOgA7mAyhfS2bdtU+fLllZ/LVyYgkfEuVqSVwKzvtN/LN5Fz+IsvvtDl2rRp07CPo4yjL2MZp2VcHDBTrlw5/VkhA7cp4/jPYRkjN3v2bLVnzx61fft2NXfuXNWoUSM9O6EELjlnKd/IpOU1dMbBSH/vu3fv1q1boaGYz4noyzhelHHs5Ttx4kQ1aNAg/dki9QzKF07gu8A1ZswY3U1NJmgId9UjGvKlL7M3hZJZy8zGGwRPQyozcUkLj5/Lt3bt2mGvqkpwkvtlbFcwP5dvouewdCeU8TJW6+0YKOPoy1jGEUmIDUfuD23J9XMZ2/k5LGUoM5yGDqL3c/lGOl+lS2YsZbVixQrTabgp4+jLOF6UcWzl+9FHH6mHH35YX5CJZup4yhep4qvAJd1R5Kqq9AEOvRoaD/nDNluQU7oaSkuC1aw2skinzMzn9/KVxaFlen2rD065T66qVq5cOdPv/Vq+iZ7D0ho7ffr0iN0JBWUcfRnLdNpmXYsNMmGGTBMfeuHAr2Vs9+ewdCs0m2zDr+UbyVdffaVbCELLSsrDagFvq7KijKMv43hRxtGXr/y9d+vWTY/bqlWrFuULZwn4xEcffRQoVapUYM2aNbbsb+rUqYGiRYsGfv/9d9P727ZtGxg8eHCW38vjy5QpE1ixYkXAS+It3969ewdef/110/s6duwY6N+/v+l9fitfO87hd955J1C3bt2oH08ZR2fevHmBsmXLBvbv3296//333x/o3r07ZZyEz+HJkycHqlSpEjhx4gTlGwgEfv7558Avv/xiWV4//PBDoECBAoEZM2Zk+v3Zs2cDl19+uf6MMNtn8eLFA9u3b6eMEyhjM1IF+/PPPyM+zk+fxfGW7/LlywMlSpQIfP755zE/p5/KF+nji8C1aNGiQMmSJfUfZCxee+21wMSJEwM7duwInDlzRv9u8+bNgX79+gXOOeecwJw5cyy33bp1a6B8+fKB559/PnDkyBH9hfbNN98E6tSpo7f3knjLV0jZ1K5dO/DSSy8FDh8+nFF2Xbp0CdSrVy/wxx9/BPxevomWsaFZs2aBUaNGRf14yjh6t912W+CSSy4JzJ8/P3D69Gn9O6k0SNCqVKlSYM+ePb4v40TO4Z49ewYWL16sPw/ks/inn34K9OnTJ1ChQoXAhg0bOIeDKqPnn39+YNCgQbqM5HNRSFh65ZVXAkWKFAnce++9puW1atWqQOnSpQPjx4/XAVbKecGCBYHKlSsHxo4dSxnbUMbxBi4/fRbHU77yGSDn7syZM+N6Tj+VL9LHF4Hr6aefDuTKlStQuHDhsDe5whds7ty5gU6dOgUuvPBC3ZolIatixYqBu+++O/Djjz9GfN6dO3fq4CBXdI39m11B9Gv5GiRoPfLII7ps5cNUKlFPPPGE/uALxy/la0cZy5dVnjx5Anv37o3peSnj6MpYvqClpfaKK67Q57A8ToLWww8/HLHM/VLGiZzDY8aMCTRp0kSXUaFChQIXXXSRrggdOHAg4vP6pXwNcr4NGzZMVxaN7y25Sn/DDTcEpk2bFnZb+V5r3769btGS87hhw4aB2bNnR3xOyji6Mn7ssccynesSuIL/Xz4vKOPYz+EJEyYEcuTIEfGzRc5ryhfpkk3+k+5ujQAAAADgRb6aNAMAAAAAUonABQAAAABJQuACAAAAgCQhcAEAAABAkhC4AAAAACBJCFwAAAAAkCQELgAAAABIEgIXAAAAACQJgQsAAAAAkoTABQAAAABJQuACAB9bsGCBypYtm2ratKlyCiceEwAA8SJwAUAMKlasqMPA22+/7flyGzRokL4BAID4EbgAwMfy58+vqlatqsqXL5/lvsGDB+sbAACIX84EtgUAuFy9evXUjz/+mO7DAADAs2jhAgAAAIAkIXABQBJt3bpV3X///epvf/ubypMnjypRooRq1aqVmjt3runjZcyUjBGTfw8dOqR69+6tu/vJtpUrV1ZDhgxRp0+fNt02EAio119/XdWsWVPly5dPlS5dWt16661q8+bNesyZ7LdLly4RJ6gwjsEgPwfftmzZkuVYzVg9p2H69OmqQYMGqkCBAqp48eLq+uuvVytXroxYpr///rvq37+/qlGjht72nHPOUfXr11dvvvmmOnv2bMTtAQBIJboUAkCSLF++XF177bXq4MGDOhhccsklavfu3eqTTz7Rt6eeeko988wzpttK2Pr73/+ufvrpJx0scuTIoX7++Wc1cOBAHeIkXIS6++671VtvvaV/loBXrFgxHWrkuXr06BH1cUvAa9iwoVqyZIn+f/k5WN68eVWi/vnPf6onnnhC/1ymTBlVtmxZtXDhQnXllVeqAQMGWG63du1a1bJlS7Vjxw6VO3duHUJPnjypvv76a13en376qXr//fczBUYAANKJFi4ASII//vhD3XzzzTpsyb+7du3SrTfbtm3TLT8SoKS1yqqla8yYMapkyZLq119/Vd9995365Zdf1MyZM/V248aNyzLu6sMPP9RhS1rCZsyYoVu15PkkmNStW1c9//zzUR/7XXfdpRYvXpzx//Jz8O3cc89NoGSUfj1PPvmkDkWjR4/WxyjHKmXUrl07yxB67Ngx1bZtW/34hx56SO3du1cHsE2bNqkffvhBVa9eXZfDq6++mtDxAQBgJwIXACTB5MmTdUuUdOt75513dLc3w5133qnuvfde/fPw4cNNt8+ZM6f6z3/+o1t+DDfccIMOHCI0qL344ov6X2k1Mx4jpJVrypQpuoXNKf71r3+pM2fOqI4dO+qWN6M1qmDBgjqMFi1a1HQ7CZTSynfjjTeqV155RRUqVCjjvmrVqukyl33J/gEAcAoCFwAkgXRtE/fcc49pF7xevXrpf5cuXapbbkJJV8Tzzjsvy++ltUpIC5bhyJEjujud6Nq1a5ZtJMBIy5HTykbGtoWSspIWNjPTpk3L6Dpp5tJLL9XrpEnZbN++3dZjBgAgXozhAoAk2LhxY0bLi5kLL7xQj0E6deqUbrWRsBDsggsuMN2uVKlS+t+jR49m/E661MmEGTLxRHCLWLDQ/aeLdLHcs2eP/vniiy82fYzV77///nv9r4xje/bZZ00fs2/fPv2vdDs0C6wAAKQagQsAksAIREZACiVd32SMlgQDaaEKZdUFMHv2vzomSMAyGC1kwd0WQ4W7L5WCg6K8fjPSDdNqIhHxzTffRHye48ePx32MAADYiS6FAJAEMh5JGK05oSQwyaQPdoQhI5wFh5lQZqEuUcbYq+DwF8ysq6RRLsJ4/aGsyszYVmZulOcMdwue5h4AgHQicAFAElSpUkX/u27dOtP7JTRId0KZddCq+2C0ZGp0afmS7nQy01+47nh2MoKeVXCSro6hihQpktHqFzrTomH9+vWmvze6Z8qMhAAAuAWBCwCSQNaKErJe1okTJ7LcP3LkyIw1rhKdQVBayK644gr9s8zyZ9YVT6aKj5Usnhyue16lSpX0vytWrDBt3ZLZEc00b95c/yuLNIeSNbWMtcRCtW/fPqPsrFrVAABwGgIXACRB586d9QLCstBxly5dMnX3mzRpkho7dqz+uW/fvrY8X58+ffS/srbXrFmzMn5/4MAB1alTp7DdDa0YgUoWJDZz1VVX6VkFZQ2tN954I9PEGPKa9+/fb7rdww8/rFvkZIFiCV1GeJKQJjMU/v7776bbyVT6ckxffvml+sc//pGlNU9eo+zTKAsAAJyAwAUAcXjwwQdViRIlLG8yNblU/gsXLqzee+89vViwTOkuIez2229Xp0+fVgMGDFCtWrWypfxlTSsJK9Ia1aZNG91NUZ6vXLlyesr4xx9/XD9OujBG65ZbbtH/Xn/99apWrVp6XJTcfvvtt4zp5vv3758RhmRWwDp16uiZEhctWpRxX6jatWuroUOH6qAlU8PLdnKsZcqUUVOnTtWzEFqN4ZozZ47629/+pt599129nXQzrF+/vqpatarurijHLFPtAwDgFMxSCABxkNaUcK1GEqikm9/q1av14saffPKJWrNmje4+2KJFC70OV+vWrW0te+m+KIHntdde09PSy0QZsljysGHD1Lx582KeoENa32SBYukaKGPRpLufCO4iKaFRFlceM2aMHrP1559/6vAn07Z//vnnlvvu16+fHuc2YsQIXS4SFBs1aqQGDx4ctlwvuugiXaavvvqqmj59uh7vJeFWwlqTJk10mXbo0CHq1wgAQLJlC9ARHgB80SI3evRo9dJLL6nevXun+3AAAPANuhQCgMdJi9GHH36YMUkHAABIHQIXAHjEyy+/rFatWpXpd7KwsnSxk3FXMg5LxkoBAIDUoUshAHiETGghMwrKRB0ym5+MuZK1rs6ePasn8pDZ/WrUqJHuwwQAwFeYNAMAPEIm4pCZA7/99lsdtGSIrsxWKDMhyiyFMmMhAABILVq4AAAAACBJGMMFAAAAAElC4AIAAACAJCFwAQAAAECSELgAAAAAIEkIXAAAAACQJAQuAAAAAEgSAhcAAAAAJAmBCwAAAABUcvwfZf91Jb+cGqIAAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
    " ] @@ -292,7 +292,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA68AAAI9CAYAAADVQU4VAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAArltJREFUeJzt3Qm8jOX///HLlj2RLSEqKaQSkZSElBYiKYXsUVIqW2TLrqKypFCUkqyFSKRs0W7LEtn37Pty/o/39fvP+c56zpkzM2e21/PxmMc5556Ze6655z733J/7uq7PJ11CQkKCAQAAAAAggqUPdwMAAAAAAEgOwSsAAAAAIOIRvAIAAAAAIh7BKwAAAAAg4hG8AgAAAAAiHsErAAAAACDiEbwCAAAAACIewSsAAAAAIOIRvAIAAAAAIh7BKwAAAAAg4hG8AgAAAAAiHsEros7HH39s0qVLl3h79NFHU/S8unXrujxP64lmzz77rH0f9957b6rX0atXL7uOYsWKmUjx0ksvJX5Gd9xxR7ibgyD9nzpu6dOnN1dccYUpV66c6dixo9m8eXOyz//hhx+C2oYsWbKY/Pnzm5IlS5p69eqZfv36mbVr1wbl/2Xq1KmmRo0aJm/evCZDhgw+H5/SxyGyrFu3zmTMmNEUKFDAnDp1Kuj7fTR9f8SytD7P8Od7799///W6j/lzcxxTg3GcTe37SO5/Rjf9r1155ZXmnnvuMUOGDDFHjx41seijjz6y77dMmTJB+ww6duxoYhXBK6Let99+aw4cOJDkYw4dOmTmzJljokEkBpRp5cKFC2bSpEmJf69atcqsX78+rG1CcCUkJNgTkN9//92888479st6/PjxabqZz549a48ZGzduNNOnTzfdu3e37bj77rvNH3/8ker1jhw50jz++OPm+++/t8ecS5cuBfQ4RJ5XX33VXLx40XTu3Nlky5Yt4vb7eP7+iNbzjFj53gvF+9D/2n///Wd++ukn06lTJ/t/s2bNGhNrZs2aZX/WqVMn4HV16dLFZM2a1YwYMcJs2bLFxCKCV0S1yy+/3Jw/f958/vnnST5O9+txejwil7743U8QPvnkk7C1B8H7XI8fP25vOoHfsGGD7e3MnDmzDSRbtWplli1blqZt2LZtm/n555/Ne++9Z+666y77mCVLlpiKFSumOqjQexJHEHzkyBH7euqtS83jEFkWLFhg5s6da3td27ZtGxX7PSL/PMPf771rrrkmcb9yvzkHz6NHj/b5OB17IvH72/l/Rre9e/ea5cuXmxYtWtiLMjt37rS94Pr/iRUawaFjS7CC14IFC5rnnnvOnDt3znTt2tXEIoJXRDX1XsiECROSfJzj/gYNGqRJu5A6ji+6PHnyJH65fvrpp/RMRTldBc6RI4e96cTuhhtuMN26dTMffPBB4tX1/v37p2kbihYtaoe1vfDCCzZonT17tt3v9IXfunVr2yvqrVdLPWgatudOJ227d++2v2u41i233GJy5cplX8+5hy6lj0Pk6du3r/2poFP7UzTs94j88wx/v/cUxDn2K/eb836piyS+HqepCpH4/e38P6ObLhRVqlTJDqvt0KGDfczWrVvtiJlYMX/+fHP69Glz1VVXmQoVKgRlnS+++KLdT7788kt70SzWELwiqj399NN2LtGvv/7qc3iK/nE1fEWPe+aZZ9K8jUgZDQ365ptv7O8NGza0V1pl165diVclEVuaNGliihcvbn9ftGiRPZkPl9q1a9uhW5pjpeFv+vJXoJpSzvMfNbcx0Mchsuj75ccff7S/B/o9Ekn7PcJ7nhEr33tp8T7atGmT+Lu2dawNGX7kkUdswBkMxYoVM5UrV7a/jxkzxsQagldEtUKFCpnq1asneVXUcTWwWrVqpnDhwsmuU/NWevToYRNr6ORSyV10INAJx8qVK/1KgrF69WrTtGlTU6RIEXsVVMM5dGD/66+/PJ6rZAl6bu/eve3fGtbonrwgqXlM/rxWUk6ePGl7CfR6mjuRHG1/PVbbKxAacqVeL9G2rl+/vsmePXuSn+2xY8dsb5Vev2fPnsm+hvYBPbZ8+fJe79dJpF7roYcesldBL7vsMpssQp+nhmBpSFhKPvcVK1bYEx717mkdzp+brkIvXLjQJlXQl4uGgOnzyp07t73qqvehfTA5SjCkkyT9D2gf1Ws1b9488eRKr6k2qbfQl9S+32BR+0qXLp0Y1KXkfYeShg/rf0g0hFe9scnNJ3QkG3Fe5tjPnBOhpPRxwfp8/NknA329QI573trw2Wef2cQ3Ol5r31ZSq1tvvdX2kjsCyLTenx29pbfffrtN9BXs/T7Q4244vz9S+50ZzP0m2s4zAvnei0Rp8T507HLwliwtGNz3SV2weOqpp8zVV19te4VLlChhR084J446c+aMnceuY4NG0eTMmdNUrVrVTjFIjs4HHEG/tyHDmt+rkUA33nij3Z763ypcuLA9h1FPtLcRQg6OiyjaN2NpmLWVAESZ8ePHqzvE3tavX58wceJE+3uRIkUSLl686PLYS5cuJRQtWtTe/8knnyRs2rQp8blaj7vFixcn5M6dO/Ex3m5dunTx2bamTZvax1StWjVh8uTJCVmyZPG6Di1fuHChy3MXLVqU5Ovqds011wTltRx69uzpsV5p1aqVXX7VVVclXLhwwef7/ffffxPSpUtnH/v+++8nBKJChQp2PSVKlEhc1rhxY7ssW7ZsCceOHfP6vIYNG9rHXHvttUmuf8eOHQnp06e3jx02bJjX+8uVK5fk9lcb9+3b5/Fc589ixIgRCRkyZPD5uc2YMSPZz7lgwYIJv//+u8/38uWXXyZkypTJ63O1rebOnWtfU3/rM/a1PVL7fv39P9W+7cvDDz+c+Lj9+/f7/fxgtMHZ8uXLE5/Tvn37ZP9fnF/D102vndLHBevz8WefDPT1gnEschxPbrvttmS3Uzj250KFCtl1dO/ePWT7fSDH3XB8fwT6nRmsNkTbeUYwvvd8cd4PknvtYB1nA30fKW3DunXrEh/35ptvJoSC8z45YcIEn9+zOtYcPXo04eDBgwmVKlXy+hj9j2p/SMpPP/1kH5sjR46EM2fOuNz3+eefJ2TMmDHJ/63SpUv7XPfWrVsTHzdnzpyEWELwiqjj/qVy8uRJ+4+vvxcsWODy2O+//94uz549e8KJEyeS/FLZvHlz4nouv/zyhHfeeSdhy5Yt9sRi3rx5iQdn3d56660kD3xXX321/cKtXLmyPWjohGn37t0JY8eOtet2nEg4n6Do9+PHjyd07drV3q8vQ/3tfNN7DcZrJRe8/vzzz4nv9euvv/b5WTier9f/77//ElLL+UupT58+icu/++67xOV6P9588803iY9ZsmSJz9cYOHCgfYy+DNxPYPXFqi9d3Z8rV66EAQMGJKxevdq+J+0D7777bsIVV1xh77/nnns8Tl4cn0WBAgXs+u+8804bQOp1du7cadvooO2pL0btXzrx036nL8A1a9YkfPDBBwk33HCDXVfx4sUTTp8+7fE+/vrrr8QvVL3euHHj7Gvs3bs3YerUqfb5efLkSWyvt+A10PebEik9IbnuuuvsY7Jmzeqyj4YreD137lziSfTtt9+e7P/L+fPn7f/m2rVrXU4UnP9v9b5S+rhgfT7+7JPB2v8DORbptbTP6zG6yNS6deuEpUuX2uOv1qP/bW1/HRfTen92/t6YNWtWyPb7QI674fj+CPQ7MxhtiLbzjGB970VS8Bro+0hpGzp27Jj4OP2vhIJjn9TFqsyZMydUr17dtunAgQMJ//zzT+L/l+NC1qOPPmr3iyFDhtj/h0OHDtn948Ybb0z8v9AyX1599VX7uHr16rksP3z4cOL+pgvzunjiWP/69esTvv32W3tx9b777kvy/ej4r3V07tw5IZYQvCLquH+pSJMmTezfOvB4OxDpCqAk9aVSt25du1yBwYoVKzxe99SpUwl33HFH4kmDDmbuHK+nW82aNe2JsLdeM8djdABKaUCZ1q9VtmxZrwdV56vNxYoVs4956qmnEgKhA6vjSqWuFjroJLNw4cKJJ53eKCjInz+/fUybNm18vkaZMmXsYx566CGP+zp06GDvUw+CY59y98cff9gvMz1uypQpPj+LKlWqJJw9ezYhtXSS6TixVWDq7sEHH0w86dVJgzvtl45t5it4DfT9pkRKTkgmTZqU+JhatWr5/fxgtMEbx4mHTmBS+v/ifJU7qddKyeOC8fn4s08Gc/9P7bFI/7uO+7Vf+KL/92C3Pzk68Xa0TReJQrnfB3rcTcvvj0C/M4PRhmg7zwjW914kBa+Bvg/nNrhf0NOFDO1bupjlGDn19NNPJ4SK8z6pcwVvF0z0+rpfo1l0YdDbRfMNGzYkjo7QRWlfHBer3XtodZHM0Q4du1Lr0UcftetQ73AsYc4rYoLmWMjUqVMT50Lop/52vt+X/fv3J06aV6IBlctwp/kO7777buIch4kTJya5Tj02U6ZMHsvr1auXmKgluTm0KRWK12rZsqX9+fXXX3utb6dEI46sq47kDKmhOR/KSChVqlRxmZel5Beapyeq86Ysg+6UYEdzUkSZ9RzzbpypHImjNlzjxo1d7tNcM2UyFKWV19wSb5QV1vE6mpPny9ChQ+1cu9RShkV9bvLdd9+53KeyAfPmzbO/KxX+TTfd5PF8zQ/U/DNfgv1+/aWLpnv27LElapS1VVI6zy+tOP5nlIQkrYXi80lqnwz266XmWKS565oTLE888UTi63ij//dQtt8bRwkjzTlT9tNQ7vdpddwN9DML9ndmWn5fhus8I5jfe5Ei2O9DifM0Z9Rxc2QbVtIhJTkbPnx4ms0F1jxWb1mZn3zyycQ59pqT7Si15kyZxR3z0VWSzZu///7b1hrXa2ievjMlDXTwZw61u+uuu87+jLXauASviAmOJAknTpww06ZNs8v0U39rov19992X5PNVa8+Rzj2pNPf6glaCHcfB2BcdZH2dROlApUn/jmAkUKF6LU32V3IAJTlxfDk5GzdunP2pL6vktm9SlIlQGQl9ffk7lunkz9fJjyMgPXz4sEeSHXE8TwlRVCPO/bPXCbDofWif8XUrW7asfdwvv/zitR1KDuPtJM6dvpiUREFtURIKR9Ipx23IkCH2ce4p7pV0x7GfKqGNL0nVigvm+00p58REOqFRAhRl81U7FIzohN6RICMSOLIMByvzoz+C/fkkt08G8/VSeyxSqSJHQhElTPFHWuzPjiBSJUBCvd+n1XE30M8smN+Zafl9Gc7zjGB/70WCtHwfumijJEhK7BVq1157beJ+5ysglFq1avlch+NxumjlzcyZMxODfh2nnelY5fj+0cUhb+XZUsJxzNI+qgtIsYLgFTHB+Qqf46qc46cjzX1SlJnRwZEF0hfH/UkdTHSSkhRHPcdgZMwL1Wsp+60yBsr48eM9ekocX97NmjUL6CTfkaVRJ2zeToJKlSpls/iJryuuul+PE/cvSJ1gffHFF/Z3rd+9PqNzgKgMfs5Xfd1vqssp3npEHF94ydFzdUKnk3T1ruzYscPWePPGOaOh+z7n62RPdLXaVxmWYL7f1NIJqb7Y1cukbI7PP/+8iSSO7e5vsBIMwf58ktsng/l6qT0W/fPPP4m/K6uwP9Jif05t8Jqa/T6tjruBfmbB/M4M5DtMPUruWZX9vSWVkT2Y5xnB/t6LBMF+HxpZ8P+nNNqbejcPHjxoM/Lq//vbb7+1wZ57ZvZgS2qfdD6HSMnjfH2/O4JX9wvqouOE4/igx+kCj0aPtGvXzmZ21jZJCeegONjf4+HkOv4GiGK6wjdo0CCbOlw1wBwpxFMylOf48eMuwzaTopMg9+ckN7TNF3/qSIbjtXSSpSF2utKp3gpHiRkdPHVA1pe1vz0lzrQNHcXGFdD5GlakLyud7OkkV700+ttb76uGDarnVT2wOgkU7Qe7d+9OfExyAWJK+Eo77zjJSor2x99++81+bvoiUm2366+/3vYKO4Z29uvXzwwcONBl6JDj6qmDowyBL9qPjxw5EtL3m1Jz5sxJLFqvfSYl2ylc1OPl2A+TO6kOhWB/Pslt62C+XmqPRQrK3I+vKRWO/TnU+32oj7vB+MyC+Z0ZyHeYpk4EelLuz/EokPOMUHzvhVNavA/t6wrANKxWPdu33XabvWClizebN2/2Oqw3GFK63pQ8ztt+q2H3juHEvkZKaSi9emA1VFql8VQySrdRo0bZ/xldLHjrrbdsWbCUvHY4RhKFCsErYoau8GmOgQIDzW1Sj5v+Tu6qsPsJkwKEpAIDRwDh70lWNNKQNg2d2bRpkx2u5jiJcvQI1KhRw6X2mr80R9VxVXLx4sX2iyklV3q9ffnpyvfrr79u57xqvY6C5o6eWA1du+eeezye53zipaDXV49lMGzZssVeORYNGdS8VW989ZI7t1VDD1Oyn4bz/TpfgU7uBDdSKFhwBDeOIu9pKa0/n3DsD+504cb5hNiffSUt2p8/f/5UzYFO7X4f6uNuMETKd6aCB83zj4bzjFB874VTWr8P/T/pe/6NN96wvfgK/sJxjA4GjbrSvqP9xnkYsjMFm5ofr5tGaC1fvtwOvf/666/tyAddzNLwfeX08HXccz5mpeX/SagxbBgxxXH10zEMLaVXQ52TDOgKV1IcE9+TKvgeSxxJQXSg1JyJ9evXJ14xDDRhiGPIUWq/MJ2psL0KgzsHrAoCHVeGNZfM25VH5y8OnZCEkr5kHJJKSuNrTo/zPuc+H9b9qq63Xte0fr/RyJH8R+6///40f/20/nwiYX/QyANv/yOR0v58+fKleQKvUB53gyGevzNTe54Riu+9cArH+yhYsKDXoevRJqkhw97o/EbJ7HTRe8uWLWbAgAGJ28CR7M4bxzFLF440tDtWELwipiggcAxBcs5CmxxdvXMM//jqq698Pk4nD44DpmM4WLA5Mi5qrkck0PA0bUsFQwoEHQlDNJQnqcRAydEBWEOIpH379i7zXLzdHJ+Lhhg6DvzuHCcRS5cutetXex1X/b0NGRb1xmbOnNn+7nhvoeI8XNHX57t9+3bz448/er1PWRcd86p8bYPk7kvL9xtttN845mWVKVPGPPjgg2nehrT+fCJhf1BPjOPEyt8T4rRov6NXTaMd0ippUGqPu2n1/RFJ35nRcp4Rqu+9cAjX+9i5c2fi79E6+k0X1ZXoSlJzDpU+fXrTuXPnxFEdurDli+MCiz8jA6IBwStiioZ3qUdK/8z66RjulZIr644rYOp58ZaNUle/lSlSdKLlKxgKlGNoh+bxuM95DAcl/3n44Yft70pX78iAqeE7jpPG1FCQ4JiP0ahRo2QfrzY4hsb4OsFVohPH/CW109HWChUqmJIlS/ocsugoXTFp0iR7S4r2g9Re8XVOnuPtC1zzLdUWXyeeuursyG6oeS/eel8PHTpk3nzzTZ9tSMv3G02UxVLHAP3PKQDQFe5wzBFK688nEvYHnYQ6ehMnT55se2d8cT8mpkX7HSM60rJcS2qPu2n1/RFJ35nRcp4Rqu+9cAjH+1Dg67i4qADujjvuMNFIJfDU+6zvc1/vQfOHvZX9c9izZ09ilnX3TMXOHKM1nI9hsYDgFTFHAYIysaYk86szlSfRlSwFEDVr1rQnrzrJUVa3+fPn239+x4mLEuqEav6AY36TeukUhGgIqE5CdAtXb6zj5FAZ/hw9D4EMXXNOm6/PST2KydEJmyMLpw7+3tLP6yTYcSVTJ1SOOqnJDevS56nEH2qXhhfrJEuJOPReNY9OV5k1z0RXmDXXbMqUKan+bB37ZYcOHWxCBl0Z1Ymm5sJqH9O+5sic7I2ShSi40tVbzY3TkCElpNJ+MmPGDNuLpd7mpOb+pdX7jSQ6WXCUTNFJkK7gK+HKiBEjbI+Q6gtqiJWSZmnfCWfpnrT+fCJhf1AbHEOAdTLctm1bO8dLx1/9f6hMlI6H3spXhLr9yvSpYXtpXWs0NcfdtPz+iJTvzGg5zwjV916wqJ6x/s+SuqkuaSjfh/NxWjfNgddoJF3UUj1VR8ZqJTXzdtFAQ9N10TGSh6g7Dxn2dYFUAb6OVTpPUBJKvW+NwlBQO3nyZDvvXZ+DgngNJ/ZGz9m3b19MBq9680BUGT9+vC732dv69ev9eu6mTZsSn6v1uFu8eHFC7ty5Ex/j7dalSxef62/atKl9TNWqVZNsh+7X4/R4b+69916vr33NNdcE9bV69uzpsV5vLl68mFC4cOHEdpQvXz4hENrOjnV17949xc9buHBh4vMGDx7s9TFz58512WaZMmVKOHDgQLLr3rt3b+K2Su727rvvujw3pZ+F471nzZrV57pfffXVZD+XyZMn2/fl7fla95w5cxKKFi1q/+7bt2/Q36+//6eLFi1K8+e7ryMltypVqiT88ccfPteX1OeydevWFLU3pY8L9PPxZ58M9PWCddzbtm1bwq233prs64dieyWnY8eO9rm33357yPfbQI+7afX9Eeh3ZrDaEC3nGaH83nPQPufttYN1jKxTp07Q34e/bWjQoEHCmTNnvL6G9nFfx+iUSMk+mdJjuLd16X86X758dvk333yT7HdNUrcMGTIkjBgxwuc6Ro0aZR935ZVX+txe0YqeV8Bt/pSuLHbv3t3WG9SQNF0xVKZaXdHXlUfHRPlQmjVrlunWrZu5+eabbRbHcKc419U9paZ3aN68eUDrcx42lJIhRw66eqgi8e7rcKYeAOekDg888ECKrvhrmJ56OFRPTnOYdOVW2Q3Vy6krvOrRVD3AP//80/bgBLKPqTfiySeftOvV+tVeDavSa6s3Izm60qrkNNp2eq56C7Vd1OOk3kTN1XTM9XXO5BqO9xuJtL20T6gXr27duraHSklnlMlRtfQiQVp/PpGwP6inQcNPNZpA+7DapNfXEFUdj/W6+ozC0f7WrVvbnyr58ffff5tIPu6m5fdHpHxnRoNQfu/F6vvQvqveffVyN23a1I6o0LQCb0PnNdrAUTYpUrMQazSJ2qj/y+rVq/t83EsvvWRHiKgigUZTqGybjmV6XunSpW0NWJXNUbk9XxxTDbTdApniFYnSKYINdyMARD7VHVUdVZ0QaphqOEpqIGU0/NUxD2bq1KmmXr16bDogQKozuWjRIhsYahhsWuC4C6TMwoULbUCoi5O6wKTh/pGmU6dO9gK1vpP13Rwq//77rx3SrRBP28JXzo9oRc8rgBRxpGPXvBUC18imnheH22+/PaxtAWKFehdl7NixPmsxBxvHXSBlNM9a1CsZiYFrakrkpNa7775rA1eN0oq1wFXoeQWQLCUMcGS+VHp8JU5AeHtW8+TJ4/U+JWjQMCMlJKpYsaIdtgcgOB566CEzZ84cM3ToUPPKK6+EdLNy3AVSThdqlZxNSRB9fT/Gg71799peVyVoU0Zsf5OXRgOCVwBe6cCnDJWa46XyDBqGonkkqoWJ8FJGZc1/0XwjfWHnypXLZvjUfCANZ9yxY0diVkdlJQQQvIysZcuWtXOmdaLsKM0VLBx3AQTipZdeMsOHDzcvv/yyefvtt2NyYxK8AvBKCU+c6yFqwv+yZctMuXLl2GJhpl5w9coklehl2LBhMZdoCYh1HHcBIGkZk7kfQJzT/FYFrOrRI3CNDG+88YbNOLh48WKza9cum71QPbFXX321rU+qoFX3A4hOHHcBwDt6XgEAAAAAEY+eVwTk0qVLtmxKzpw5w16LFAAAAED4KNPx8ePHbX1aTWMKNoJXBESBa5EiRdiKAAAAACwljyxcuLAJNoJXBEQ9ro4d9PLLL2dr/n/nz5+3Ncfuv/9+OxcRSA77DPzFPgP2GYQaxxmkppyfau06YoRgI3hFQBxDhRW4Ery6HuxVQkHbhOAVKcE+A3+xz4B9BqHGcQap2WckVNMJgz8QGQAAAACAICN4BQAAAABEPIJXAAAAAEDEI3gFAAAAAEQ8glcAAAAAQMQjeAUAAAAARDyCVwAAAABAxCN4BQAAAABEPIJXAAAAAEDEI3gFAAAAAEQ8glcAAAAAQMQjeAUAAAAARDyCVwAAAABAxCN4BQAAAABEPIJXAAAAAEDEI3gFAABA3NqwYYOZPXu2OXnyZLibAiAZBK8AAACISyNGjDClS5c2Dz/8sLn++uvN3Llzw90kAEkgeAUAAEDcGTdunHnhhRfMxYsX7d979+41tWvXNs8//zy9sECEIngFAABAXJk8ebJp1aqV1/tGjhxpypUrZ1auXJnm7QKQNIJXAAAAxI2vv/7aPPPMM+bSpUs+H7Nx40ZTuXJl06dPH3PhwoU0bR8A3wheAQAAEBe+//5706BBA4+AtE6dOiZbtmwuyzScuGfPnuauu+6ywSyA8CN4BQAAQMxbvny5DVLPnj3rsrx9+/Zm+vTp5vfffzd33HGHx/M0fPi2224zo0ePNgkJCWnYYgDuCF4BAAAQ0xSYPvjggx6JmJo1a2aGDRtm0qVLZ2644QazZMkS06tXL5MhQwaXx506dcq0bdvWPPTQQzaxE4DwIHgFAABAzFq/fr25//77zdGjR12WP/HEE+bDDz806dP/73Q4U6ZMdqjwsmXLTIkSJTzWpVI6ZcqUMdOmTUuTtgNwRfAKAACAmLRlyxZTo0YNc/DgQZfl6kGdOHGiRw+rg4YPq7e2Xbt2HvcdOnTI1K9f3/baHjt2LGRtB+CJ4BUAAAAxZ9euXTZw3b17t8vyatWqmSlTppjLLrssyednz57djBgxwsyZM8cULFjQ4/6PP/7YlC1b1vz0009BbzsA7wheAQAAEFP2799vA9etW7e6LK9UqZKZNWuWyZo1a4rXpbmyq1evNvXq1fO4b9u2baZq1aqmS5cuHomgAAQfwSsAAABixuHDh+0c17///ttl+a233mp7UXPkyOH3OvPmzWu++uor88knn5icOXO63KcMxIMGDTIVK1Y0a9asCbj9AHwjeAUAAEBMOH78uKldu7b5888/XZbfeOONZt68eSZ37typXrcyEjdp0sT89ddf5p577vG4X695++23m7fffttcunQp1a8DwDeCVwAAAES906dP2zquK1ascFlevHhxs2DBApM/f/6gvE6xYsXMwoULzeDBg212Ymfnzp0zr7zyih2yvH379qC8HoD/IXgFAABAVFPQ2KBBA7No0SKX5YUKFTLff/+9ufrqq4P6espS/Nprr5lVq1bZ0jnu1A4lc/rss8/ssGIAwUHwCgAAgKh18eJF07hxYzN79myPearqcVXPa6jccsstNoB99dVX7bBiZ6or+8wzz5gnn3zS/PfffyFrAxBPCF4BAAAQlTS3tFWrVubLL790WZ4rVy4zf/58c9NNN4W8DVmyZDFDhgyxQ4mLFi3qcb/advPNN9v2AAgMwSsAAACijobjvvTSS2b8+PEe9Vnnzp1rbrvttjRtz7333muTOakX2J1qzdaqVcu0b9/enDp1Kk3bBaSVLVu2mH/++Sekr0HwCgAAgKjTvXt3895777ksy5w5s63jeuedd4alTerxnTBhgu1tzZMnj8f977//vs1I/Ouvv4alfUAovfjii6Zy5cohfQ2CVwAAAESVAQMGmP79+7ssy5gxo63Fet9995lwU/Ko1atX23qz7lR/tlKlSubNN980Fy5cCEv7gGDT/HLNO9cc9FAieAUAAEDUUG9rt27dXJalT5/efPrpp+bhhx82kUKZjr/99lvb25o1a1aX+xS09ujRw9aL3bx5c9jaCASDAlaViEoLBK8AAACICprfqqGJ7j788EPTsGFDE2mUgfj55583v/32mylfvrzH/cuXLze33nqrbT8ldRCtPvnkEzvfOy0QvAIAACDiTZkyxbRs2dJj+fDhw03z5s1NJLvxxhvNsmXLbG+reomdnTx50rRu3do8+uijZt++fWFrI5AaJ06csPPP0wrBKwAAACKa5tI1atTIlsZx1q9fP689sZEoU6ZMpk+fPmbp0qXm+uuv97j/m2++sSV1Zs6cGZb2AakxdOhQs2fPHpNWCF4BAAAQsRYtWmTq16/vkdyoS5cuHnNfo4GSNf3++++mTZs2HvcdOHDA1K1b1/YwHz9+PCztA1Jq165dZvDgwS7LQp0wjeAVAAAAEWnFihXmkUceMWfPnnVZ/sILL3hkG44mOXLkMKNHj7a9rfnz5/e4f+zYsXYurHppgUjVvXt3c/r06cS/NSS+V69eIX1NglcAAABEnD/++MM8+OCDdk6os2effdbOc1UypGj30EMPmTVr1tjeVndbtmyx2Yhff/11c+7cubC0D/BFoweUqMmZRgyUKlXKhBLBKwAAiBmbNm0yX375pdm/f3+4m4IAqBaqaqQeOXLEZfnjjz9uM/O6Jz2KZvny5TPTpk0z48aNsz2yzjTHVz3MGmq8bt26sLURcKbM2CqN45whW/uu5nSHWuz85wMAgLiloWsdOnQwN9xwgy2ZUrx4cds7p/qDiC5bt241NWrUsPM/ndWuXdt89tlnJmPGjCbWqBe5WbNmttxIlSpVvPZylStXzu7T7kmrgLSm4e6ai+6sa9eupkCBAiF/bYJXAAAQ1X799Vd7Yv/uu+8mLjt16pR56aWX7LBL9eIhehLAVK9e3f50du+995qvvvrKXHbZZSaW6aLLDz/8YAYMGGCzEzvTvF/t07Vq1TI7d+4MWxsR386fP29ee+01l2VFihQxL7/8cpq8PsErAACISso+q1IpGlLpK0BVbU0lvhk0aJBHtlpEFvW0qsdVPa/OKlasaGbNmmWyZs1q4kGGDBlsJuWff/7Z6/zBBQsW2JI6X3zxRVjah/j2wQcfmA0bNrgs09D2tPr/JHgFAABRZ/PmzbZXVdkukwtK1WOlYEBB7urVq9OsjUg5zW3VHFf3ixC33HKLmTt3rsmZM2fcbc7bbrvNjirw1qOl7fXUU0/Z2reHDx8OS/sQf44cOeKRTbh8+fJ2P0wrBK8AACBqKEHImDFjbG/q8uXLPe6//fbb7bzI6667zuM+BQK6v3fv3mRvjSAnTpyw81mVXdhZyZIlzfz5803u3LlNvMqSJYt5++23bW9r4cKFPe7//PPPbS/s999/H5b2Ib7079/fHDp0yGXZW2+9laYJ1AheAQBAVNi7d6+t+dmmTRuP8ik6eerRo4cNaNULoMQ3yobpflKl+VrqOVBvgYJZhNeZM2dMnTp1PC5EFCtWzAZs3mqgxiPNA9Y+7a2HS/ODNdxaPbTONTeBYNJwfiUMc/bYY4/ZETBpieAVAABEvOnTp9septmzZ3vcd/3115ulS5faMg2OJDfZsmUzQ4cOtctvuukmj+do+LDmUipDpgIopD1dSGjQoIFZuHChy/KrrrrKZ09jPFMPtEYVqLf1iiuu8Lh/2LBh9qKMMhMDwaapF871hpX1W7kE0hrBKwAAiFjHjh0zzZs3N/Xq1TMHDx70uP+5556zw001n9UbLdfJ/Ouvv24T4ThTGZ2BAwfaIchK7IS0o23fuHFjW3LDWd68eW3g6m3YN/7Pk08+aS++qLfVnWrB6qKMshVTJgrBopERqp/t7IUXXjAlSpQwaY3gFQAARKQff/zRJuwZP368x32qJ6jAZ9SoUSZ79uxJridz5szmzTffNKtWrbLrc6fMmaqtqWGX7sOREXyqU9q6dWszefJkl+WXX365mTdvntcMu3ClXmltK5WH0rxY9x7tbt26mapVq5otW7aw6RBwnoGOHTt6jALQNI1wIHgFAAARRdmBO3fubGt7/vvvvx73a57VmjVrzEMPPeR39lYFsH379vWooakTNA27LFu2rFm0aFHA7wHeaTvrIsG4ceNclmuYt7IKq14vUkbzudu3b59Y59idhszrYo22tbY7kBrqcV2xYoXLMgWuefLkMeFA8AoAACKGhkPecccdZvDgwR4n3CqX8vHHH5upU6fa4aWpoaBV5XV+++03U6FCBY/71VN13333mbZt29ohywgunfSqt9DZZZddZmbOnGkqV67M5k4F9VRrWKeGxrsnKFMm5xYtWtgLPvv372f7wi/KB6C5ru45Bp5//nkTLgSvAAAgIoaSquSCEs4oq6o7ZbTU8qZNm5p06dIF/HplypSx81yHDBniMexSRo8ebR/z7bffBvxa+D9K7tKvXz+XzaGkL1999ZXX+ZtIOV0A0NB4DbW/9tprPe7XxQElPHOfYwwk5b333vMY/aL/Y+1v4ULwCgAAwmrbtm22FMirr77qUX9VJ0kKMJWRVuVTgkmBk17zzz//tHNe3e3YscM8+OCDplmzZubw4cNBfe14M2LECI8eHF2EmDhxoi1/hOC46667bAKzli1betynnldHqSn1yAJJOXDggL0g4uzuu++2vfjhRPAKAADCQsOCJ0yYYOeZ/vDDDx73q6dIc1QVYLpnCg6mG264wSxevNj2MnhL/qShyhqaqd4r+O+TTz6xmUndffjhhzZzLoJLw+u1bbW/5suXz+P+MWPG2Azb7rV1AWe9e/f2mDqh0THBGPkSCIJXAACQ5lT2RjU+NQzY/QRJJ0evvfaaDVwV2KYFzRVUgKU5t5rz6m7v3r2mbt265qmnnrI9EkgZDQlWqSN3So6luZgInUcffdQmNvPWs/3PP//Y0Qaag6zsxICzv//+206dcPb00097zROQ1gheAQBAmlJWWfWqKvGSu2uuucZm+1XCJpW4SWvFixe3dUbVO6UeLHdffPGF7YVVmRcyuCZtzpw5NtjXfGZnyvbcoUOHIH9y8CZ//vy2B1Y9se6jCvS5aFjonXfeaYMVwKFTp04udYKVF6B///4mEhC8AgCANKEaqu3atTO1a9e2PZnu1AurpEyqTxlO6vlt1aqVWbt2rW2rt15jDXetX7++2bNnT1jaGOk0DFzb58KFCx4nxcqKi7TdnzUHVnO7Fai6U6kdlZF6//33uSADo/wCX3/9tcuWUHmrokWLRsTWIXgFAAAh9/PPP9sT5FGjRnncd+WVV9peWM0tvfzyyyPm0yhSpIjNzqp5ublz5/a4f/r06bYXVnM66YV1/aw1VFVlNpzpwsXAgQPDPmcuXl133XU2G7EyPitZmTN9VqoZ+8ADD5jdu3eHrY0Ir4sXL5pXXnnFo/fePdlaOBG8AgCAkNF8up49e9osqJs2bfK4Xz2bmpdXr169iPwUFGg1btzYrFu3zmuWzSNHjphnn33Wvo/t27ebeKfePQVA7tlsmzRpYhNiEbiGl4LWbt262QsMN910k8f98+fPtyWipkyZEpb2IbwmTpxos1U769OnT0RdVCR4BQAAIbFhwwZTuXJle/LjPH9KsmXLZhOCqGezYMGCEf8JqI3qHf7yyy+9ZnBVPVid9H/wwQceczzj6fOuWbOmDeidafjw2LFjbVIsRIZy5crZ4cIvvviix30qC/XEE0/YizbunyVie1pHt27dXJZpZEmkJVbjKAIAAIJKQ2hV11PDhH/55ReP+ytWrGiv7qveZDT1xKmtypCsXthGjRp53H/8+HHz3HPPmRo1apgtW7aYePLvv//a9+2eiVl1cidNmuQxTBXhlzVrVjN8+HDb21qoUCGP+z/99FNz++232wzciH1Dhw71mMOv0jiR9r9L8AoAAIJG8+UUsKjszOnTp13uU61W9cIuWbLElChRImq3et68ec1nn31ms7heddVVHvcrW7KyKSswcO9xjtXPvHr16mbnzp0uy5V4S73Vl112WdjahuSpt1wBasOGDT3u27Fjh3njjTdsIIvY/h8ePHiwy7L777/fTgGINASvAAAgKDRPTkNn582b53FfyZIlzYoVK2xdyUi7kh9IHU31wnqrY3rq1Cnz0ksvmXvuuSemy5Cop1XBj3tP8x133GEzlqp3D5EvT548tgyULsrkypXLYySFkm1pbjpiU/fu3e0xy0FD/NUTG4kIXgEAQEA0L07z4zRPTvPl3CmL6W+//WbKly8fc1v6iiuusPM5FbB7KyWxbNkyc+utt5pBgwZ5lI2Jhc+9Vq1aNoB3VrZsWVvL11udXEQ2DYdXL+x9993nkY1YPbPOAQ5iwx9//GEzvTvTPFeNHolEBK8AACCgmoAKVrwNK9Q8OgV17777rk3QFMs0xE49U+qhcnf27FlbaqJSpUoxM39QyV0eeugh8/vvv7ssv+GGG+wcSvXkITqpRNR3331n528700UKbwmeEL0SEhLMq6++6lLqK0eOHHZ6R6QieAUAAH5TT0zHjh3tXEfNi3OnXlgFagrq4oV6GpWo6ocffrA1Nd0pu6sS4PTu3ducO3fORPNnX6dOHdur7Oyaa64xCxYsMAUKFAhb2xAcGjY6bNgwO2rAmUYZfP7552zmGDFnzhzz/fffuyzr3LlzRGeAJ3gFAAB+UW+bhgC/8847HvdpvpzmzWn+XLz2vilR0V9//WWDe/dsyqp726tXL1OhQgUbzEYbtV8XJtxPeHWyq8BVvXaIDZkzZ7b/y1myZHFZ3rp1a7N58+awtQvB+19Wr6uzq6++2h63IhnBKwAASBFlzh04cKAtdbN27VqP+zVPTr2tmjcXTSVwQkHDpFVmQr2TN910k8f9Cm61HVVXUT2Z0fL5N2nSxCZicnbllVfawPX6668PW9sQGsoK3rZtW5dlJ06csPNfNRwe0evDDz/0SCY3YMCAiJ/iQfAKAACSpWyy6lHs2rWrvWLv3kOjIYaaJ0fPmyvNc1WyKgWpKhXkHgzqZFH1cJcvXx7Re6HmxGkOpHrUnV1++eV2XnPp0qXD1jaElv7vmzZt6rJM+7SGlyI6HT161PTs2dNlmaY0PP300ybSxV3weunSJVt3rVSpUnZok75kO3ToYD/EQCir3t13321y585t67/Vr18/Ranxf/75Z5upT1ctddPvKiWQFF3NVnZDbzd/djpd6dVVUl1hcc8yBgCAI2jRPLdbbrnFLF261GOjKPDSiay+SzVPDp407LJfv35m5cqVNrmVO50v3HXXXXa4XiRmc9U+oLZ99NFHLst1/qA5czrpRWzTxSn3EQQ6n541a1bY2oTU69+/vzl48KDLMo0UiYZjeOS3MMiaNWtmZs+ebaZPn24DVn3hZsqUyVSuXNmmfE8Nfak///zzpm/fvubQoUO2SHft2rXtlSqt3xddqaxbt669krlv3z570++PPfaY/TJIinY4tdf9prkJKaVixAreVYsNAAB3+/fvt99TLVu2tEMFnekkR72JuuCqC8JIXrly5cyqVatsJk+de7gHiJpDrOBWCZ8iiXpoFLw4u+yyy8zMmTNt0I3Ylz17djN58mSP+a86r/aWsA2R699///X4f9ZxXnFLVEiII9OnT08oWbJkwpkzZzzua9WqVcILL7zg9zp3796dkDt37oT169d73PfZZ58llC1bNuHSpUse9506dSqhUKFCCQsXLvS476effkq46qqrEk6ePOn1NfWxnT9/PiEQW7duTciZM2fC6tWrE6pWrZowfvz4VK3n6NGjtj36if85d+5cwowZM+xPICXYZxBp+8zMmTMT8uXLZ4/x7rdrr702YcmSJSF53Xih798KFSp43b66tW3bNuHYsWNh32cGDRrk0bYMGTLY9SD2ue8zo0eP9tgf7rrrroDPS5F2nnzySZfPL2PGjAkbNmwI2voPHjwY0tggrnpe33//fVtnTXNz3HXv3t0OnfU3aYJ6XR999FFz4403etynhBWnT582P/74o8d9U6dOtZPgq1Wr5nFflSpV7NyRKVOmmFB56aWXbAHiMmXKhOw1AADR5/jx46ZVq1a2FMqBAwc87lcvrIra0+MWGH3/KpmTRkF5Oy8ZNWqUfYxGaYXLyJEjPeY1aurSxIkT7f6B+KNMww0aNHBZpukEyqCNyLdixQqPeeuqTa36zNEiboJXBaX651Kg6U3RokVNyZIlzU8//eTXepWcQl3tvuj1VKzb3+fpS8Hb84JB83O183KgAQA40/ek6jq6z22U/Pnz22GiylCpeqYIXMaMGc1rr71m/vzzT68XA7Zv324eeOAB07x5c3P48OE03eQTJkywU6LcffDBB+app55K07YgcujihY4BxYsX95hDqYzTiFwJ/3/uujPly3njjTdMNImb4FX1qFS7KKmac6q5tm7dOr/Wq1IBqnXn7zpT+7xAKa35iy++aEsdKGEVAADnzp2z81fvuecem1XY24VYlcDxdQEYgdHFc43Sevfdd72WqRg/frydV6yLB2lBo8M0l9Hd22+/bXvlEd90/qjeO118cQ6MnnnmGZu/BZHpq6++8shq3qNHD5swNprETfC6bds2U6xYsSQfo95XXeVMqZMnT5pjx46ZQoUK+b3O5NqTXFscGYp1ALnuuuvMs88+a2vGJWfIkCE2G7J7ynMAQHzSxVTVG1XJFmXkd5YjRw47PWbGjBm25xWhowRY7du3txcJVC/X3d69e+2ILfV6ehvOHczRWXoN932hd+/e5uWXXw7Z6yK6KNmnOkKcKXBVHWD3fQfhd/bsWY8pANdee63X0RWR7n+XTGKcsiSqazwpul8ZuPxZp+qbJZVWWut0z9CYkvb4ep48+OCDds5R9erV7dAttfnzzz+3V8w1P0Vzbb1RwDxo0CCzePHiVBeP187vXJRawbuo5p973b945tgWbBOwzyBSjzM6wVQuiNdff93luO6gLPzjxo2zJzgXLlwIuL1IGVUBUACpbd+pUyc7B9mZerw0PFPZQjX30J/v8+T2GfX+1qtXz+N+DTVUzhC+0+JPUvvMCy+8YL7//nu7vzpoypsuhGnfReQYNmyY2bp1q8dQb8Uwwf6/DvVxIm6CV30xK617UpQwwZ+ETYGsM7nn6nkaxqVhGO5fTO5ldHRioZMPBbPqkdW8mWuuucZjnbpiqjqwStWfWjog6eqrOx2svA11inea2wywzyDSjjPqudMQVfXyudNQQPW8qZdP9UdTUrMcwXfVVVfZYbpK3ORedk/l8jREUxcflEAnqSlRKd1nNm7caOe+uZ+zaM6t6tg7ByiIP76OMzpW/Pzzz+a///5LXKb9SMcRb8lMkfaOHTtmy3M5U81exRrJleZMjVDXqo6b4NURDCZFAaV7/apQrdPxXF8BrCO49eeKaqVKlexBREO83HdSZStUj6u+nALRtWtXl8ne+ofQVeL777/f9kLjf1eddKCvWbOmRy0/wBv2GaTFPqMLouq5e/XVV22tc3eaV6nM+0rahMigYZiq4f7KK694JG1S8sUNGzaYoUOH2mA2uXMGX/uMph1pjqt74KoL3jqnSGqEGWJbSo4zmj6n80DHcGH91EjAlStX+n1hBcH38ssvewSUSsqn/DqhcOjQIWPiPXhVgqFp06b5/Tx9QavsjGPezpEjR5J8vO7X41JKj1Xw5q13NLl1Otrj6/X8bYuDDi468XCmIFnbsF+/fgFPylbQ7S2lvw5oBGme2C7wF/sMQrXPqGekbdu25ssvv/R6vy5M6nvCn4u4SBsKLDVlSCUtpk+f7nKfAlqVvlMyFmUC1gVlf/YZXdSuXbu2R2Cs4cM6n3BOyoP4ldRxRiP/1NvqXMVCeVuee+45e/6e2qlqCNyGDRvsccGZOro0LSRUQh0PRMWlNA1t2rlzp983R+AqGkab3HxW/aMpUVJKZc+e3fY27tq1y+91Jtcef9vioDmwSiTlbPjw4TYQ1tAiAED80dSOm2++2WvgqmBH89beeustAtcIVrBgQZsFePLkySZfvnwe92tYr2rEjxkzxl5UTwmdhyjw2L9/v8dQ4UmTJhG4IsW6d+9u7r33XpdlSvQ2YsQItmIYderUySVngTqgNAUwmkVF8BoM119/vQ0yk6qTtmrVKjtkyh/6ovjll1/8Xmdqn5ccBe3uGSF1VVVXXjR0Q4mg3G9LliyxV3P1u4YIAQBig4aKKYOt8iHs3r3b434NNdWQUW/ZbRF51IP1xBNP2AzR3mqtKrlTmzZtTI0aNbyWPHK2Z88e+zidNzhT8kcFyd5GWQG+ZMiQwQ5vV0ULZxru/vvvv7PhwmDRokVm1qxZHkOIveXFiSZxE7xqGJQSGbl/iA46eCvAU1ICf4fpJlV37ZtvvrHzAPx93tdff+31ecnROt2HAqiYtDIXayiyt5t6qDU3Qb/rwAMAiH66QKoEfUrq404XM9ULO3HixGQz8SPyqOdVPaPq2VJiJ3cLFy60Pe0aueatbIkSPilw/eeff1yWaw6czj9IwIjU0NzXCRMmeExda9iwoUfWbITWpUuX7IUD9+OGctdEu7gJXh0pvVWTyltJgDfffNPWSvV3ro/mmShg9JYISXNudeVSVzHd1a9f3z5HSZTcLVu2zGaAVAp8f2hewU8//WQaN27s1/MAALFDQ8SUtO/OO++0F2Xd6cJoar5jEHnq1Klje2E1J9Zbr3uHDh3sOYjzfqCpRQ899JBZt26dy+PLlCljhx6TfBGB0NxsJYRztmnTJjvCL6XD2RG4iRMnevR463shFv6/4yp4Vdp/FVXWwd4RbOrqo8aDK+jr27ev3+vUFc8hQ4bYZAcKRHWlQ9n6xo8fb1566SX709tE9axZs9oabhr2o+BXJxu66ffHH3/cZgHzduVz9OjR5tNPP7XDvxxXU1W3qVu3bjb41n25c+dO1fYBAEQ3nSRqNE3Pnj09arPqe0e9sN9++63tIUFs0He+zif0uXpL1rR06VJzyy23mMGDB9skk7pY735SW6JECZtRNtCkjoAo8ZvOt53p/PSTTz5hA6WBU6dO2RKazjQVsWXLljGx/eMqeBUFk7oqpEA2V65cthyAgk0d3H0NndKc0LJlyybZ+/ree+/ZHUUH/sKFC9thNz/88EOSNVU1B0lZAzVkV/NUddPv6kFVMOxNsWLFzOzZs+2keM0r0BUUzVVSzT7Nk/X1PABA7FKPhi5u6jtNNRfdaTioApbnn3+ezJ8xSucUa9assRml3WnEWefOnU3x4sXN+vXrXe5TcsgFCxbYhFBAMKjUo0Yf6jzbmY4/7vsfgu+tt97ySCarjrZYyRyeLoE+fARAV3F1cFK9wFgYihDMumgq/KyLCZQQAvsMQnmcue2222xJCg359JZERVlAdXGVY1H80MVzXVhPLmmTAlaNPFNSSyDY5zMq3+Q+PUGdQapPrJEgCL49e/bYkRTOlUeUZ2fevHlpduFSdV7VwRaq2CDuel4BAIgVypGgET7eAledwGhUkWovErjGF43OUhZpZRb1dcKqpF0aKkzgilDRNDhdWHOm/dI9kRCCp0ePHi6Bq/7/hw4dGlMjbgheAQCIwlEvzZs3t/MYdZXbnYaOaphwxYoVw9I+hJ9q0b/99tv2AsaNN97oURNePTFK0gSEkvZB96l3o0aNsuWYEFx//vmnnf/uTN8TSU19jEYErwAARBGVnlDGYCVA8TYMVEP8lD9BwQugrNO6kKEeGe0fyp2hnvry5cuzcRByGh48efJkjySkGtauhKMIjoSEBJvl2Xk2qL4DUpOMNtIRvAIAEEX69+/vNSmTSrCpBI6SEgLOVAZQZTK2b99uhg0b5pEJFggl9fyPGDHCZZnmQ6rihubUInBz5861idecKUmbtzrQ0Y7gFQCAKBoWpjIUzpQQY8KECWbKlCk2SQYARJqmTZuaZ555xmWZLsK5l3SB/y5cuOBRW/fqq6+O2bnFBK8AAEQB9VConrdz/db06dOb+fPnm8aNG8dUQg4AsUXHJ01nUCI59xIu3hLOIeU+/PBDjxJEusjpPlQ7VhC8AgAQBQYOHGj++OMPj6HCSdUTB4BIoURhmv+qOrDOmjRpYnbv3h22dkV78r6ePXu6LNN3gi5oxiqCVwAAIpzmsron3ihVqpR54oknwtYmAPCX6lKrdIuzgwcP2iHFFy9eZIP6acCAAebAgQMuy9566y07KidWxe47AwAghoYLOyc2yZAhgxk7diz1WwFEnRdeeMHUrVvXZdmiRYs85vMjadu2bTPvvPOOy7JHH33U1nmOZQSvAABEMM0J++2331yWderUydx+++1haxMABDL/VRffihYt6rK8d+/eZvHixWzYFOratas5e/Zs4t8ZM2a0tb9jHcErAAARau3atfaEztlNN91k3njjjbC1CQAClSdPHvP555/bUSQOly5dMo0aNbLDiJG0lStX2u3nrG3btqZkyZIxv+kIXgEAiEDKKtysWTNz7ty5xGWaxzR+/HhbtxMAolnlypU95vIrcZOmSSQkJIStXZEuISHBdOzY0WVZrly54uaiJsErAAARSEk3Vq1a5bJMtfwqVqwYtjYBQDB17tzZ1KxZ02XZ7NmzPeZy4n+mTp1qli5d6rJJevToETd1vgleAQCIMKrZ517+QMPB3IcQA0A002iSiRMnmgIFCrgs79Kli8fFOxg7x1UBv7Nrr73WJsGKFwSvAABEEJWL0HBh50QcSnDCcGEAsUiB66effmqPcw7Krt6wYUNz9OjRsLYt0owYMcJs2bLFowZ45syZTbwgeAUAIIJouNzPP//sskzzm+68886wtQkAQqlGjRo2e66zrVu3mtatWzP/9f87dOiQxxxhzRt+/PHH42rnJHgFACBCbNiwwc5dclaiRAmPExYAiDWaFnHXXXe5LPvyyy/Nhx9+GLY2RZI+ffqYI0eOeORGcO6xjgcErwAARMhw4ebNm5szZ84kLtNJybhx40zWrFnD2jYACDXVKZ00aZLJnTu3y/IOHTqY1atXx/UHsHHjRjNy5EiXZU8++aSpVKmSiTcErwAARIB3333XLFu2zOOkrUqVKmFrEwCkpaJFi5qPP/7YZZku6Gn+68mTJ+P2w1CSJpVPc9Ac1wEDBph4RPAKAECYbdq0ybz++usuy6677jrTr1+/sLUJAMLh0UcfNS+++KJHBnb3ZfFi8eLFZsaMGS7LXnrpJVOsWDETjwheAQAIo0uXLtnhwqdPn3ZZruHC2bJlC1u7ACBcBg8ebMqVK+dxTNSw4nj7flDCPmd58+b1SG4VTwheAQAIo/fff98sWbLEZVn79u3NPffcE7Y2AUA4aVjsF198YXLkyOGyvE2bNnakSrz47LPPzG+//eaR2CpXrlwmXhG8AgAQJv/884/HFfTixYvH7VwmAHDOtP7BBx+4bJATJ07YREXOdbBj1alTpzy+H2666SZbPiieEbwCABCm4WAtWrSwJyjOxo4da7Jnz85nAiDuNWrUyE6rcKaeyE6dOsX8tnn77bfNrl27XJYNGTLEZmWOZwSvAACEwahRo2wiDmft2rUz1apV4/MAAKdM7OpxdF82c+bMmN1Ge/fuNQMHDnRZVr16dVO7dm0T7wheAQBIY1u3brWlD5xdc801ZtCgQXwWAOBEI1G+/PJLkyVLFpft0qxZM7N9+/aY3FY9evRwKQ2kmt9vvfWW/RnvCF4BAAjDcGH3moUaLuyenAQAYEyZMmXM8OHDXTbF4cOH7bBi5/qnsWD16tU2s7J7oH7LLbeErU2RhOAVAIA0NGbMGLNo0SKPDJoaEgYA8K5Vq1bmiSeecFm2dOlS07Nnz5jaZK+++qq9yOmgkml9+/YNa5siCcErAABpZNu2bea1115zWVakSBFb0xAA4JuGzOri37XXXuuyXNnZFyxYEBOb7ttvvzXz5893WabkVIUKFQpbmyINwSsAAGkgISHBtGzZ0pZ6cPbRRx+Zyy+/nM8AAJKh+qaq/5opUyaXY+szzzxj9u3bF9XbT8OfX3nlFZdlClrVE4v/IXgFACANKEh17x1QMHv//fez/QEghSpUqOCRiVeBa+PGjV2G20Yb5T1Yt26dy7J+/fpROs0NwSsAACGmjJjuV9QLFy5shg4dyrYHAD+9/PLL5qGHHnJZ9t1330VtxvZjx46ZN954w2XZrbfeapo0aRK2NkUqglcAAEJIQ9pat25tjh8/7rJcc7c0BA4A4P/8148//thcffXVHiVmlMQp2qgnef/+/S7LVBonfXpCNXdsEQAAQmj8+PFm3rx5HmUPHnzwQbY7AKRS3rx5zaRJk1wCvIsXL5qnnnrK/Pfff1E1Muedd95xWfbII4+Y++67L2xtimQErwAAhMjOnTtNx44dPRJwvP3222xzAAjQPffc41EqZ8eOHbaWtka9RINu3bqZM2fOJP6dIUMGMtAngeAVAIAQ0ImT6rcePXrUY7jwFVdcwTYHgCB4/fXXTbVq1VyWzZgxw7z//vsRv31XrlxpPvvsM5dlbdu2NTfeeGPY2hRXweupU6fMoUOHouZKBwAAoTJhwgQzZ84cl2VKvuGeZAQAkHrqqfz0009Nvnz5XJarxMxvv/0WsZtW8ZJ7Ij/lQXDvSUaQgldlxdKOoiQUpUqVsmmcc+bMafLnz29rL+nnAw88YFM8r1q1KrUvAwBA1Nm9e7d56aWXXJYVLFjQY14TACBwmo6hC4bOzp07Zxo2bOiRLC9STJ8+3SxZssSjF1lzeRHE4FXd202bNrU7iX6qbt3ff/9tTp8+ba8g6KYaSwcPHjTz58+3aZ8rVapkbrnlFvPee+/Z3lkAAGJ9uPCRI0dcln/wwQcmT548YWsXAMQydZq99tprLss2b95sh+FG2qhQBdadOnVyWVasWDHTvn37sLUp5oLXjRs3mvr165s777zTTJw40WTLls00atTIDB8+3Cxbtsxs3brVzuvRh7F3715bZPerr76yO1HlypXNmjVr7FXo6667zn6BR3MRYQAAfNH8pW+++cZl2dNPP20effRRNhoAhJBGfFasWNHjmKyyOpFkxIgR5p9//nFZphq1WbJkCVubokXGlD6wdOnS9qe639XjWqNGDTvG3BsNGdZNk43r1atnl+3atct8/vnnZtSoUaZdu3Z2bqyyawEAECt08fbFF190WVagQAF7oRcAEFqauvjFF1+YW2+91SVZ3gsvvGBHgt50001h/whUxqdv374uy9Q52KBBg7C1KSZ7XpVkQsODVU+pVq1aPgNXX1REWBOn1YOrmndFihRJTXsBAIhIGpb23HPPmcOHD7ss10XbK6+8MmztAoB4ouG3mtboTNMW1QGnaY7hpsDV/XvirbfeMunSpQtbm2IyeB07dqwd8hsoBb0KhBs3bhzwugAAiBS62j9z5kyXZU8++aR57LHHwtYmAIhHjz/+uL2Y6Gz16tUedbfT2qZNmzxK+CioVs8rUoY6rwAABGjfvn0eiTZUtkGJCgEAae/tt982ZcuWdVk2evRoM2XKlLB9HJ07dzYXLlxI/Puyyy4zAwYMCFt7olH6UH+Z//7772QYBgDE9HBhRy4HZyNHjqTkAQCESdasWc3kyZNtkllnLVu2tIlm09qPP/5oy+M469ChgylevHiatyVug9eff/7Zdr/Pnj3bowZsnTp1bDmd8uXL29p2mucKAECs0VX8adOmuSxT4g0NWwMAhI+Sxyqzr3ucoikdqpCSVlRlxX3Isuq5krw2jYNXTYZWBsWcOXO6LFd5nK+//tpOPL7iiivMiRMnTKtWrexYcwAAYsWBAwfM888/73FC4j6nCQAQHqqS8swzz7gsW7lypXn99dfTrA1KePvrr7+6LOvVq5eNk5CGwevSpUtN9uzZzT333JO4TIGq6sAqoFVtVw2jGjZsmL3ioExaAADECpVfOHjwoMsyBa4qFwcACD91pmkaR4kSJVyWDx061MydOzfkr68Mx+49rCVLljStW7cO+WvHovSBzml1L3mzePFic+bMGZs5S131ji93XYnWMGMAAGLB1KlTzZdffumyTLXNn3jiibC1CQDgSZ1qOl4rQZIzVUDZtWtXSDfZO++8Y3bs2OGybMiQIbYmLdI4eD1+/LjHJOglS5bYKxw1a9b834ukT29rLrl/cAAARCP1tipJk7M8efLYq/vU6gOAyHPrrbd6jALVsVxDii9evBiS19y7d69HNuH77rvPPPzwwyF5vXgQUPCqouvbtm2zmRYdFixYYH9WrVrV5bHnz5/3uNoBAEA0evHFF83+/ftdlqksToECBcLWJgBA0pSjwL329g8//GDefPPNkGy6nj172imVDrq4qQCai5xhCl4rVapk57R++OGHiYGrJiPfcsstLvN9FNxu3rzZXHXVVYG8HAAAYadSB59//rnLMmXYf+qpp8LWJgBA8hQ0jh071hQtWtRleZ8+fezUx2BS7h8lt3VPHqUeYIQpeH3llVfsTtC2bVs7p/WBBx6wf2u5e12jkydPmgoVKgTycgAAhJUu2Oo7z1nu3LnNqFGjuJIOAFFAx2xdgMyQIUPiMiWWbdSokc0gHyyvvvqqXa+DplqGqoc3ngQUvFapUsUmrChVqpQNTq+99lqbZfHpp592edzo0aPtz/vvvz+w1gIAEEYvvfSSTVboTCXjGFkEANGjcuXKHoHk7t27zbPPPusScKbWvHnz7M29lOjVV18d8LrjXUDBq2OolOq3Kg30xo0bPa5Iy5gxY8zhw4dtQWAAAKLRrFmzzKeffuqyTEk33OsHAgAiX6dOnTw61ubMmWOzAwfiwoULHqNQdYFTwSvSOHht3769mT9/vjl37pzf6alz5cplsw4DABBtdAH2ueeec1mm4vIffPABw4UBIAopLpkwYYIpWLCgy/IuXbqYlStXpnq948aNM2vXrnVZ1q9fP5M9e/ZUrxP/41c0OWLECPPggw/aLMOqZacPRymgAQCIZS+//LLZs2ePyzJdnS9UqFDY2gQACIwyxGtEjXP2X/WcarTo0aNHU1VGtEePHi7LlMhW9WQRHH4Fr8omrPIA+rKeMWOGadWqlSlcuLBNxKQsXco0DABALJk9e7b55JNPXJbpQq6yRgIAolv16tVNt27dXJZt3brVxjnO5UBTYtCgQR5l1FQaxzk5FNIweFVRXV1p3rBhg70NHjzY3H333eavv/4yvXr1MnfccYediNy6dWszc+ZMc+rUqQCbBwBA+Bw5csR+pzm7/PLLbS4H6vQBQGxQHKNEtM6mTJlij/UptWPHDhuouudFUHCM4En1JNQSJUrYyciLFi2yaaWVclopps+fP29rGmlYsYYX165d24wcOdJs27YtiM0GACD09D2nDJTO3n77bTvqCAAQGzJmzGgmTZpk8uTJ45FhXolpU0K9t2fOnEn8W72tQ4YMCXpb411QMijpKnTDhg3NxIkTbQmBJUuW2Axe119/vfn222/NCy+8YMvo3HzzzfaDXbp0aTBeFgCAkNH3l3I7OFNmyubNm7PVASDGFClSxIwfP95lmYLRJ554wpYETcovv/zikY2+TZs25sYbbwxJW+NZ0NP/ahiVaicNGDDAXqlQj+t7771nv/D/+ecfM3DgQHPPPfcE+2UBAAgaJerQfCf3zPkffvghw4UBIEY9+uijpkOHDi7L/v77b1txxRfNi3UvjaOOPQ1FRvClT4urGM8//7yZO3euOXTokJk+fbpp2bJlqF8WAIBUUz2+nTt3uiwbOnSoKVq0KFsVAGKYki6VK1fOZZl6ZD/77DOvj1cS2x9//NFl2euvv27y5csX0nbGqzQtvJo1a1ZTp04dWxcPAIBIpHrm6mF1VqNGDY+eWABA7MmcObOZPHmyHW3jTLW+N23a5LLs3Llzdqqks2uuucZWZ0FoZAzGStRdrozDW7ZsMSdOnEgyrTR1jgAAkUo1+tyD1Bw5cjBcGADiiPL2qLNNyWgdFOMox8/y5cttgCujRo0ymzdvdnmupkhmyZIlzdscLwIOXlX7Tl3j7sXbfSF4BQBEKl1B3759u8sylYUrVqxY2NoEAEh7Tz31lPn+++/N2LFjE5f9/vvvdlrJu+++a/777z/Tu3dvl+dUqlTJBriI0OBVgWuzZs3s76rvWrZsWTu+m9p3AIBoo5OU0aNHuyyrVq2azRgJAIg/ClLV07pu3brEZUpEe99999l5rocPH3Z5vOq8EgdFcPCq2kX6gPr162evVqdPn6ZTaFPl0qVLdqfTUIBdu3bZbGCqSdunTx+TK1euVK9XCan69+9v1qxZY+s6Va1a1W6X5FJk//zzz+aNN96wKbalfPny9iqOrtz4om3uq60PPfSQzwnlDitXrrT/XPqnO3XqlK3He9ddd9nx+RUqVEjR+wWAWKLhYO7JBLNnz26vuEfDdxsAIPiyZctm57/q/Ni5hqs679zL5zRo0MBWXEFoBfSNrNI3hQoVMl26dImaL3ftbLNnz7ZZj1UK4bfffjOZMmWyO9uRI0dStU6d3Cijct++fW1GZWWorF27tg1gtX5f5s2bZ+rWrWsngKs+rm76/bHHHjNz5sxJ8jUPHjxo2+t+Sy5wVeCu4QwPPvigWbt2rd0GuqJUvXp1O28ZAOKRvsf+/fdfj3lLxYsXD1ubAADhV6ZMGdsD60zn3OfPn0/8+7LLLrPfGYjwntcCBQqYvHnzmmihVNbq6fzzzz8TJ1prmLPKHxw7dsz06NHDBnf+0FxfjX1ftmxZYi+rJmm3aNHCZldWsPzHH394DCE4ffq0LXQ/adIkOyzNQYGr2qSCyJoAris+wfLDDz+YYcOGmSVLlthh3s6f47PPPhu01wGAaKJj44gRI1yWqR55u3btwtYmAEDk0MgcTS1RL6w3Gr147bXXpnm74lFA3aUqe6PeO/U2RoP333/fXl13BK7Ounfvbj7++GOXIQEp7XVVQWNvw4OVoUxBqnvtJ5k6daopUaKES+DqUKVKFVO6dGkzZcoUE0wa2q3g1TlwBYB4pmFfutjoTBcex40bFzUjigAAoaVOqDFjxngNUDX9TslrkTYC+mbu2bOnKVKkiB2GqiGvkUxB6dKlS22g6Y0Kz5csWdL89NNPfq33u+++s0N/fdHrqWagv8/ThQFvzwtkiLd6lx955JGgrRMAol23bt1smTdnAwYMMNddd13Y2gQAiDzKk6OeV003dI+HrrjiirC1K94ENGw4T548NiBs3Lix/aLXPEr99DXUVVctNDQ3HDQEVz2OarMvmoytbGI1a9ZM8XrV86wkS0mt84svvvD6vKQK3ut5zqm5A7VixQomkQOAE42KcZ/HpJEv7du3ZzsBADzonP+jjz6yWejVMabpfspXgyiq86qsvZpDqay1GgrrK2hNSEgIa/C6bdu2ZOv0qffVvb5fcsPN1JuppFX+rjO59iTXllq1atm5tBcuXLDzju+++27TsWNHW67Im7///tu+3rlz5+zcrokTJ9r1K2uxeoA1bDp37tzJvmcAiAX6zlLeAWfKV8BwYQBAUpo0aWJL5SgG0KhNVRlBlASvmkOqMi9y5513mltvvTVi67yqDEJyXfq63z3bZHLr1BCCpOZFaZ16nL/t8fU8UQ+3Jo4rQ3DOnDltmz///HObYGTkyJF2rq071aHSHFuVBbrhhhvMrFmzTOHChW0Aq7I5Ks2jIdP58+dP8j2fPXvW3hz0jyvKuOacdS3eObYF2wTsM5E7XFjTKZypZJou8kXL/y3HGbDPgONMeCjZqW4qwakb/ifU36EBB68KVBU4KTtuJFPApTTWSVEiJ38SNgWyzuSeq+epl9TRY+3MvYyOJo9roriCWfXIqmbrNddc4/IYJY5SGR0FuMqu7NzDO3z4cNOhQwfTtm1bn73nznPBVIfWnebnBjMzcqzQ3GaAfSayrF+/3mO4sK6ea9pLcmXKIhHHGbDPgOMMImlkU8QGr+q101XqSA9cnYPBpCig1LCxtFin47m+AlhHcOtPL7Z6T5966ik7V1Y9CM7UBg0z/vbbb70+V8OGNfx5165dSWYj7tq1qx2e7NzzqqRd999/v+2Fxv+uOumEUvOn3Sf2A96wz6QNXchTeTNdGHQ+Hn/11Vc2gI0m7DNgnwHHGUSaUFehCSh4veqqq9IkYFHtpGnTpvn9PCVKUvINyZEjhy0onBTdr8ellB6r4M1b72hy63S0x9fr+dsWBwVLKvnjTnNbb7rpJp8JqzTcW8OKf/311ySDV53keSs1pACNIM0T2wX+Yp8J/XDhTZs2uSzr27evLUIfrdhnwD4DjjOIFKGOBwIKXtXjqvmS6oHV8NNQ0fAu9yFe/tIw2uTms+p9eKvX6kv27Nlt8K7eSs0f9bVOb9vG0R5/n5cczYFVIil3Gg6XVKZl0f2+5tkCQLRbvny5efvtt12WVaxY0WU0CQAAiOE6ryrpolqmf/31l4lk119/vQ0ylbjIl1WrVplSpUr5td7SpUubX375xe91pvZ5ydm5c6fXpEu33357sj3P2jbqgQWAWKPcA8ou7JxYQ6NIxo8fT6ZIAACiREA9r+3atTPFixc3U6ZMMeXKlTO33XZbsnVeg1m71B+a86lERsqy27RpU69B34YNG2zJGX+H6c6cOdOWm/Hmm2++seWEvD1P2+Kll17y+ryvv/7aa9bg5KgtStzkTpmgjx8/bgNYb1mONT59y5YtNsgFgFjTq1cvWzLMfZmmUwAAgDgIXjW30lHDVTRfUjdfwhm8ygsvvGATDj355JMe8zbffPNN8+yzz/qVsElatGhhe1E3btxoS9C4z7nV6yjDr7v69eubzp07m8WLF5uqVau63Lds2TKzevVq06BBA7/aonnBKnfjbc6rtG/f3gwaNMhmDHY3cOBA26bkhhYDQLRZuXKlGTJkiEeh+VdffTVsbQIAAGkcvGq4VTRR7+j06dNNnTp17BxaBZsHDx40gwcPtkHf0qVLU5W0SidFtWvXtoG5em6VRVjlgxQoq+yCt2ROWbNmNePGjbPZgUeNGmUeeughu3z27Nm2ZM1HH33ktQd79OjRNpGTiiMXLFjQ1pjdunWr+fDDD23pIgXMuXPn9hm8q50qq/Pyyy+bvHnzmgMHDth5y9ouCpoBIJYoc3uzZs1chgsrk7u+vzJmDOgrEAAApLGAvrm9Db+NdDphee+992wgqzmwSnBUr149G7h6G04rS5YssUOkfc3rVe+ryswoKFy7dq2dP6Xe1h9++CHJBFCqyaqg8Y033rAnV6I5xOpBVdkbb1Sa6JNPPrGlcBR4X7hwwVx55ZWmRo0adp5sUqUe1C4NY1bvq4ZQK3BVT7OCeSUyYb4rgFijY+W6detclumYG83ZhQEAiFfpEpyL3QF+UqkgleE5evQodV7d6i+q11093ZQQQkqwzwSfkuLpQuDFixcTlyk/w4oVK2Li/5J9Buwz4DiDSKM8OhrdGarYIKBswwAARPJwYefAVQGrRt/EQuAKAEA8SnHwqmGzysgbDJqXOWnSpKCsCwAAd/369TNr1qxxWda9e3dTtmxZNhYAALEevI4ZM8bWSm3ZsqX58ccf/X4hza9UQiGVJXj66adtkiEAAILtt99+M/379/coF6YkegAAIA4SNv3xxx+2tIsy5GrYlRIUPfjgg+aOO+6wtUGVdVdlVpTFUWOc//vvP7N+/Xo750gJj5S8SMO3lFzonXfesRl1AQAIJmV7dx8urKzCDBcGACCOgldlZlQZF5WUUQ/qzJkzbTmX5Oq2OvJBqde2VatW5rnnnrMZfgEACDbVsXbPDN+tWzfb8woAAOKsVI7qmOqmMi0q86IhxKoPumPHDlu2xUHZpXSyUKVKFXP//ffb0jEAAITKn3/+ad58802XZTfffLMtYwYAAOK4zqtSIKsnVTeHI0eOmDNnziQOHwYAIK3Kxjz77LMuF1FV2/rjjz/m+wgAgHgPXr254oorgrk6AABSZNCgQTY3g7MuXbrYuq4AACA2UOcVABDVVq9ebfr06eOyrHTp0qZHjx5haxMAAAg+glcAQNTSMGFlF9awYffhwpkzZw5r2wAAQHARvAIAotaQIUPMr7/+6rLstddeM+XLlw9bmwAAQGgQvAIAotLatWtNr169XJbddNNNpmfPnmFrEwAACB2CVwBA1A4XPnfuXOKy9OnTm/Hjx5ssWbKEtW0AACA0CF4BAFHn7bffNqtWrXJZ9sorr5iKFSuGrU0AACC0CF4BAFFl/fr15o033nBZVrJkSdO7d++wtQkAAIQewSsAIGpcvHjRNG/e3Jw9ezZxWbp06exw4axZs4a1bQAAILQyBmMlmnM0ZcoUs3jxYrNr1y5z5swZ8/333yfev3z5cnP8+HFTvXp1W8IAAIDUGDZsmFmxYoXLso4dO5o777yTDQoAQIwLOHjVSUTDhg3Nzp07TUJCQuJVcGczZ8605QzmzJljatWqFehLAgDi0IYNG0z37t1dlpUoUcL07ds3bG0CAABRMmx4y5Yt5oEHHjA7duww9erVM5988okpXbq0x+OeeeYZG9hOnTo1kJcDAMT5cGGN7HHQhdJx48YxXBgAgDgRUPD65ptvmmPHjpl+/frZYcONGzc2V1xxhcfjypQpY/LkyeORGRIAgJR47733zLJly1yWdejQwVSpUoUNCABAnAgoeP3uu+9Mrly5TJcuXZJ9bLFixezQYgAA/LFp0ybTrVs3l2XXXXedvXAKAADiR0DB64EDB+wJhPscV2+UqOnEiROBvBwAIM5cunTJtGjRwpw+fdpluYYLZ8uWLWztAgAAURa8aoiwsgunxD///GMKFCgQyMsBAOLMiBEjzE8//eSyrH379uaee+4JW5sAAEAUBq933HGH2b9/v8eJhbsZM2aY//77z9x9992BvBwAII6sXr3aY1pK8eLFzYABA8LWJgAAEKXB6/PPP2+zCCsD5F9//eX1MT/++KNp3bq1HVqsxwMAkJyff/7ZVK1a1Zw6dcpl+dixY0327NnZgAAAxKGAglfVbH3xxRftkODy5cubSpUqmY0bN9r7mjRpYsqVK2eqVatmDh48aK+e634AAJKyYMECU716dXP48GGX5e3atbPfKQAAID5lDHQFw4YNMzfddJPp1auXWblyZeLyTz/91P7Mmzev6dOnj3nuuecCfSkAQIybNm2aeeqpp8y5c+dclleuXNkMHjw4bO0CAAAxELxKmzZt7NDh5cuX2zlKR48eNTly5DClSpWy81wzZ84cjJcBAMQwZRBu1aqVzTDs7IEHHjBfffUVw4UBAIhzQQleJVOmTDb7IxkgAQD+euutt8yrr77qsbxhw4ZmwoQJ5rLLLmOjAgAQ5wKa8woAQCCU9O/111/3GrhqVM9nn31G4AoAAAIPXmfNmmWuvfZae8U8Kbpfj5szZ04gLwcAiCEXL160SZj69+/vcV/Xrl3NqFGjTIYMGcLSNgAAEGPBq4Zybdu2zTz22GNJPq5OnTrm33//tY8HAEAJmZ555hkzevRoj42hxEwKaFViDQAAIChzXn///XeTP39+26ualOuvv94UKFDA/PLLL4G8HAAgBqh26+OPP27mzp3rsjx9+vTmgw8+MC1btgxb2wAAQIz2vO7evdsULVo0RY8tUqSI2bNnTyAvBwCIckeOHDH333+/R+CqpH+TJ08mcAUAAKHpec2ePbs5cOBAih578OBBSuYAQBzbt2+fqVWrlvnzzz9dlmfLls3MmDHD1KxZM2xtAwAAMd7zevPNN9s5r8kNB9b9mvNapkyZQF4OABCl9B1QpUoVj8A1d+7cZsGCBQSuAAAgtMFro0aNbJmDp59+2mzZssXrY7Zu3WrvV+INPR4AEF/WrVtnA9fNmze7LC9YsKBZvHixufPOO8PWNgAAECfDhps3b24++eQTs2zZMturWq9ePVOxYkVzxRVX2HlNK1assEPBTp8+bSpXrmxatWoVvJYDACLeqlWrzIMPPmgOHTrkslyJ/r777rtkE/4BAAAEJXhV/b1vvvnGNGvWzMycOdNMmjTJfP7554n3q1dWVEpn7Nix1OsDgDiyaNEi8+ijj5oTJ064LNfFzvnz55urrroqbG0DAABxFryKelmnT59u57UqgF2/fr05duyYyZkzpyldurSpW7euKVeuXHBaCwCICvo+aNiwoTl79qzL8kqVKpnZs2ebPHnyhK1tAAAgToNXh/Lly9sbACC+aTpJixYtzMWLF12WK5vwtGnTTI4cOcLWNgAAEKcJmwAAcDZ8+HDz7LPPegSujz/+uPn6668JXAEAQPh7XuXw4cN2bpNjrqs3RYsWDeZLAgAigI77PXv2NH379vW4T72wH3zwAXkPAABAeIPXjRs3ml69eplvv/3WHD16NMnHqlzOhQsXAn1JAEAEuXTpkunQoYN5//33Pe577bXXzKBBg+zxHwAAIGzB6x9//GGqVq2a2NuaJUsWky9fPpM+PaORASAenD9/3mac/+yzzzzuGzBggOnSpUtY2gUAAGJPQMFrt27dzPHjx0316tXNO++8Y8sfAADig2p4P/HEE7ZkmjP1so4aNcq0adMmbG0DAACxJ6DgddmyZTb5xowZM0z27NmD1yoAQETTNBHVcP3xxx9dlmfKlMlMnDjRlskBAACImOBV85xKlixJ4AoAceTAgQPmgQceML/99pvL8qxZs9pSOLoPAAAg2AKanHrrrbeaPXv2BK81AICItn37dnP33Xd7BK65cuUy3333HYErAACIzOC1a9euNnjVEDEAQGzbsGGDqVKliv3prECBAmbx4sXmrrvuClvbAABA7AsoeH3wwQfNyJEjTbt27czLL79s1qxZYxN4AABii3paFbju2LHDZXmxYsXMkiVLzC233BK2tgEAgPgQ0JzXDBkyJP7+7rvv2ltSqPMKANFHvaqPPPKIzS7vrFSpUmb+/Pnm6quvDlvbAABA/AgoeFVt11A+HgAQXiqD06BBA3PmzBmX5RUqVDBz5841V155ZdjaBgAA4kvA2YYBALHps88+M02bNjUXL150WX7ffffZEmk5c+YMW9sAAED8CWjOKwAgNr3//vvmmWee8Qhc69ata2bPnk3gCgAA0hzBKwDAZXpHnz59TPv27T22yrPPPmumTJlismTJwhYDAADRNWzYYd++feajjz6yST127dpl50b9888/ifdreNn+/ftNkyZNOOkBgAilqSAdO3Y0w4cP97hPGeWHDh1q0qfnmicAAIjS4FWBqa7GKwulIyGTsgo7W7dunenRo4fJly+feeyxxwJ9SQBAkF24cMG0bNnSfPLJJx73vfnmm6Zbt24ex3YAAIC0FNAl9D/++MM0bNjQnDp1yl6tV8/r7bff7vG4p556yga2U6dODeTlAAAhoNEyjz/+uEfgqmB1xIgR5vXXXydwBQAA0d3z2r9/f3u1XkOGmzVrZpd5mwtVvHhxU6BAAfPXX38F8nIAgCDTqJk6deqYRYsWuSzPmDGjDWYbNWrENgcAANEfvP7444+2xp8jcE1KkSJFzObNmwN5OQBAEB08eNA8+OCD5pdffnFZrouQX331lXnooYfY3gAAIDaGDR8+fNgULVo0RY/VsOGzZ88G8nIAgCDZuXOnufvuuz0C18svv9zMnz+fwBUAAMRWz6sSMG3bti3Zx6lO4MaNG02hQoUCeTkAQBBs2rTJ1KhRw2zfvt3jmD5v3jxz2223sZ0BAEBs9bxWqVLF/Pfff2bmzJlJPu7jjz+286ruu+++QF4OABAgJdrTsds9cNUomiVLlhC4AgCA2AxeX3nlFfuzdevWZvbs2V4fM2HCBNOhQweb/EM/AQDhoeC0atWqtu62sxtvvNHed8MNN/DRAACA2Bw2XKFCBVu0/tVXXzWPPvqoyZ8/vy25IPfcc49Zv3697ZmV999/35QqVSo4rQYA+GXOnDm2HM7p06ddlqu82dy5c+2QYQAAgJjteZWXX37Z9rreeuutZt++febo0aM2OZOu4h86dMiULl3afPPNN6Zt27bBaTEAwC+ff/65LYfjHriqF3bhwoUErgAAID6CV3nggQfMr7/+av7991/z9ddfm08//dTMmDHDJmlSbVeVYogUly5dMsOHD7e9wLly5bIlfDScWUF3INRzocyduXPnNnnz5jX169c3f//9d7LP+/nnn02tWrVsySHd9PuKFSuSfE66dOnMFVdc4fX29NNPJ1veqHbt2va1cubMad9/ixYtUpR4C0D0GTVqlD0uqCa3s0ceecQet5RdGAAAIOaDVyVgUiB07ty5xIQfqguoovYaRnz99debSKOatOopnj59ug1Yf/vtN5MpUyZTuXJlc+TIkVStc+zYseb55583ffv2tb3NKkGh7aJeDa3fF2X1rFu3rnnuuedsr7Vu+v2xxx6zQ/ySq8+o9rrfPvvsM5/PmTJlinnyySftieyWLVtsEq2VK1eawoULmzvuuMP8888/qXr/ACKPRsD079/ftGvXzv7urHHjxmbq1Kkma9asYWsfAABAms55Xb58uR0WfNlll5looN5g9XT++eefJnPmzHaZ5nlp3u6xY8dMjx49zHvvvefXOvfs2WNee+01s2zZMpv0RLJkyWJ7M3ViqGBZ2T3VW+pMw/eaN29uJk2aZKpVq5a4XIGr2vTEE0+YzZs3m2zZsgXlvatc0YsvvmgTaNWsWTNx+VVXXWV69+5tL0D06dPHfPLJJ0F5PQDho2BVx6W33nrL47727dubYcOGmfTpgzLwBgAAIM0EdPainlZHgqZooKRRXbp0SQxcnXXv3t2W9PH3/ajXVb3MjsDVmXqgFaRqqK479XqUKFHCJXB1UBkLXRRQT2mwrF271va0qrajNwqakxuuDCDyaXhwy5YtvQauvXr1stMmCFwBAEDcBa+OeZ2a2xrpFJQuXbrUBpq+AvGSJUuan376ya/1fvfdd3bory96vfnz5/v9PCVX8fa81Dp79qz96T580HkucLB6eQGEh/7PGzZsaMaNG+dxn4LWnj17eowCAQAAiIvgVb2VyjKsQEtDcSOZhuBeffXVJk+ePEmW/lm3bp3fPZrly5f3e52pfV5qaf6xhgb7Coi/+uorl+HEAKLLiRMnbM6BadOmuSzPkCGDnS6gaQMAAABxO+f1hRdesENfFfiUK1fODnW96aabTPbs2b0+Xlf8Ncw2HJRNt1ixYkk+Rr2v27dvT/E6T548aefKFipUyO91Jtee5NqirMSaS6shgspurEzHHTt2NGXLlvX6eGVBbtOmjWnSpIkZNGiQefjhh20gr9f44IMP7JxdZR4FEH2UKE6Bq+b0O9MUiS+//NLniBMAAIC4CV41R1QBqWMo6po1a+zNl3AGr+qVUCmZpOh+lfvxZ50qM5HU/DGtU4/ztz2+nicqPaQ5bdWrV7flbtRm1XG85557zMiRI+1cW2/eeecd2wvTunVrG/RmzJjR/lSP9A8//GBLB6VkWKJjCLIoeJfz58/bG/6PY1uwTRDqfWb37t02u7n7SA0dG9QLq6zn7IexieMM2GfAcQaRJtTnHAEFr+PHjzfRQgFXclmR1UvhT8KmQNaZ3HP1PA3z1YUB9zlq7mV0rr32WvP666/bYFY9snfddZe55pprPNapYFhzW1VORwFwjhw5bM+rAt5KlSqZxYsX297zpAwYMMBmJ3an4cjMmTVe5zYDodpnlO1c81j379/vEbhquUaHJFd2C9GP4wzYZ8BxBpHi1KlTkRu8Nm3a1EQLRzCYFAWUKnOTFut0PNdXAOsIbv1JrqIA9KmnnrK92yp740xBa7169ewQYQ31dlCQq2HEGkKsWrXqgU1K165d7fBk557XIkWKmPvvv9/2QuN/V510Qql5xKojDAR7n/nrr7/sVAD3wFV1m1XLWlM4ENs4zoB9BhxnEIlTmSI2eE0rSjTinoQkJb744gtbdkbUy3jkyJEkH6/79biU0mMVvHnrHU1unY72+Ho9f9vioBNfDed2p+2nObbOgauzl156ybz55pt2CGJSc3gVdHsrNaSTbYI0T2wXhGKf0Rx1zXF1P6bp/1sBsLeRF4hdHGfAPgOOM4gUoY4Hgha87tixw5aZ2bVrl61t+sYbb7hcHVaAl9wQW1/effddewuETuaSm8+qIbTe6rX6osRU6m3Ue1Zvh691KvmSr/b4+7zkaLighgq6UyKX2267zefzFJCqp0ZtSip4BRBe8+bNs6Mo3IflKPO77sufP3/Y2gYAABCxpXLk4MGDtq5g8eLFTePGjU2XLl085kQ2a9bMZM2a1fz6668mXFQqRkHm4cOHfT5m1apVplSpUn6tV3NEf/nlF7/XmdrnJWfnzp1eT16PHz+e7BBk3a8kTgAikzIHP/LIIx6Bq7KNa8g/gSsAAIhlAQWvCoiUyXLKlCk2Y+2zzz5rf7pTZlz1vKZm6G+waN6pEhnNmjXLZ9C3YcMGexLo7zDdmTNn+rz/m2++sfNB/X3e119/7fV5ydE6K1eu7LFcQ4Z///13n8/THNu///7b3HDDDX6/JoDQ+/DDD82TTz7pkcVPmYa//fbbFGULBwAAiNvgdfDgwWb9+vWmfv36NvBRoiBvc61UwkU9r4sWLTLhpLq0AwcOdCn14qD5ngq+/UnYJC1atLAB48aNG73OudVwXL1/d9pmeo4y/Hqbz7Z69WrToEEDv9qiiwMauq0ecHd169a1vTZbtmzx+tzhw4fbhE/JlRMCkPaUVE0lrhxlyRxUFmvGjBlk+gYAAHEhoOD1q6++ssHZRx99ZINTny+SPr0dtqt5nOGkAO6OO+4wderUSQw2Ney5U6dONujr27ev3+u86qqrzJAhQ2zvhwJRZfVVaRyVEVISJP30NlxX22vcuHE2O7CCX9Vb1U2/P/7443abeis9M3r0aPPpp5/axEp6Ldm6davp1q2bDb51X+7cuT2ep7m8ak+1atXsya4jgN+7d6/p3r27GTp0qHnvvff8fv8AQkfBaufOne10DHft2rUzEydOJFEaAACIGwEFr0ruo2GmKRmupkBMgWK4KZhUjVMFsmq3kpwo2Fy6dKnPXsclS5aYsmXLJtn7qsBPtVavvPJKm4RJw341B61cuXI+n6earNOnT7d1VjVXTTf9rh5UBcPeaPivymDce++9Jm/evDZh1H333WcOHDhg58n6ep4oOFeQql5WBd16vxUqVDD79u2zzw1kyHBSc4kB+O/ixYu2FI5GuLjTBaf333/fXhgEAACIFwFl59EQW817TYk9e/ZExJwsnex16NDB3lJK5XZUUzEpCoh181fFihVthtCUeuCBB+wttTQU2d/hyCmhIcfqLVb5DgCB0cgIDf9XPgF3b7/9tnn55ZfZxAAAIO4EdNleGXNVImfbtm1JPu6PP/6wQ4Zvv/32QF4OEUzDjx9++GE7dJleWCD1VOrq0Ucf9QhcdeFNUw0IXAEAQLwKKHh95pln7NA2JRJxL93goEBGw2o177NJkyaBvByiwCeffGLKlCljhzYD8M+JEyfsCI758+e7LFeNbOUYUNkxAACAeBVQ8NqqVStbWua7774zN998s00qovmToh6Cjh07mpIlS9oSLSoNozIPiH1KJkUvLOAfTa3QvPkVK1a4LM+ePbuZM2eOeeyxx9ikAAAgrgUUvGbIkMHWMW3YsKHNeKusu5s3b7YZMhXYDhs2zCZpeuKJJ8zUqVOD12pEnJw5c3osoxcWSBkdP5V4zX0KRp48eczChQtN9erV2ZQAACDuBZSwyRG0fP7557ZUizLnqj7p0aNHTY4cOUypUqVsbwFzXWOfeovU0+6efMrRC9u0aVPzzjvveC3jA8QzlbxS3ed//vnHZXmhQoXsqBYdRwEAAOBHtuEJEyaYAgUK2PIu3mjYsG6ITyoPNHfu3MTh4seOHfPohdWJ+JgxY8hIDDhZsGCBnVrh7LrrrrPLVRoLAAAAfg4bVhbZ/v37uyy79tprmceKRErKpeRca9as8XqRg7mwgCfVdnY/rqq2NIErAABAKoNXBSYXLlxwWfbvv//agARwVqRIEdsLq7qvl19+ucfGYS4s8H9Uauzrr7922RwqhVOwYEE2EQAAQGqD17x589o5WefPn0/pUxDH6IUFkvfhhx/aOa8OWbJkMY0aNWLTAQAABDLntVq1ambKlCm2NI5+z5o1q12+fft206dPnxQHND169EjpSyKGemGZCwu40oVABa/O7r33Xq+ZuwEAAOBH8Dpo0CCzcuXKxJuDgtdevXolG7SqfA7Ba3z3wt5///22hBIZiQFjZsyYYfbu3euyKR544AE2DQAAQKDB6zXXXGP+/vtvG3jo56lTp0zv3r1N0aJFTbNmzVK6GsQxemGB/xk1apTL5qhcuTJJmgAAAIJV5/Wyyy4zjzzyiL2JI3jt2bOnP6tBHKMXFjBm/fr1ZtGiRS6bonXr1mwaAACAYCRs0rzWjz/+2GXZ+PHjzeuvv57SVQCJyEiMeDZ69GiPhHj169cPW3sAAABiKnjVvFYl3XGm4cLutV+BYGckbtq0qTl8+DAbFjHh5MmTtlyUM/0fZM6cOWxtAgAAiKngNX369F7L5CgRExDKXtgJEyaYMmXKmNmzZ7OhEfW++OILc/ToUZeLOG3atAlrmwAAAGIqeC1YsKDZsGGDOXHiRGhbhLhELyzigS72jRw50iPDcPHixcPWJgAAgJhL2PTggw+asWPHmlKlSpm77rorsc7rpk2bTPPmzVMcoGgdQGozEqsXdsGCBWbMmDHmoYceYkMiqqxatcr89ttvLsvatWsXtvYAAADEbJ1XZchctmyZmTx5cuLyffv2eSRy8oXgFcGsC9ukSRMzbNgwkzt3bjYsorI8jkqQ6cIgAAAAghi85smTxyxZssSsXr06sc6rEjbdcMMNpmvXrildDZBi9MIilvz33392vqt7eZwMGTKErU0AAAAxW+dVbr75ZnsTBa/58+e32WCBUKAXFrFCI1TOnDmT+HemTJnsCAMAAAAEOWGTN4sWLTLvvvtuIKsAUoSMxIhmly5d8qjtqrquBQoUCFubAAAA4ip4rVq1qrn11luD1xogCWQkRrRauHChTW7nrG3btmFrDwAAQEwPG96+fXviULerrrrKZZk/ihYt6vdzAGfMhUW0cS+PU7p0aXP33XeHrT0AAAAxHbwWK1bM9nzdeOONZu3atS7LUkqPvXDhQupaCrjtS2QkRjTYtWuXmTVrlkevqz/HTgAAAPgRvKrHVCdbjl5X52VAuHthx48fb15++WXqwiLifPjhh+bixYuJf2fPnt00btw4rG0CAACIRikOXv/9998ULQPSmi6gNG/e3NSsWdOWHvn2229d7qcuLMLl/PnzNnh19vTTT5vLL788bG0CAACIy4RNQKT1ws6ZM8eMHTvWa3AwYcIEU6ZMGTN79uywtA/xR8OFdfHEGYmaAAAAUofgFTHZC7tmzRrzwAMPeNzv6IVVbeLDhw+HpY2IH6NGjXL5+8477yRDOwAAQKiHDXtz5swZs3z5crNq1Sqzf/9+c/z4cdvjlT9/fnPHHXeYSpUqmcyZMwfyEkBAvbDMhUW4bNy40Xz//fcuy+h1BQAASOPgVclH+vfvb4YPH55k71WePHlMx44dTefOnU369HTyIm0xFxbhNHr0aJe/r7zyStOgQYOwtQcAACDa+R1Rnj592tSoUcP06tXL/PfffyZjxoymXLlypk6dOqZRo0bm0UcftcPiMmTIYA4dOmS6d+9u7r//fnP27NnQvAMgGcyFRVo7deqU7fV3puHsWbJk4cMAAABIq+D1lVdeMYsXLzbZsmUz77zzjg1QNWx42rRpZuLEiWb69Onm119/NQcPHjRDhw61j1u0aJF57bXXUttGIGDMhUVamjx5sjly5IjLsjZt2vAhAAAApFXwumPHDjNmzBhbp3DJkiWmQ4cOJkeOHF4fq7mvGjL8448/mqxZs9ohdDt37gykrUDA6IVFOBI11apVy1x33XVsfAAAgLQKXtWzeunSJdOlSxdzyy23pOg5t912m53zeuHCBfPpp5+mtp1A0NALi1D65Zdf7GgUZ+3atWOjAwAApGXwqszCjhN/f7Ro0cL+XLp0qX+tA0KIXlikRa+r9rOHHnqIjQ0AAJCWwatqZ1599dXmqquu8utFChUqZJ+3du1af9sHhBS9sAgmZV///PPPXZa1bt3aJrADAABAGgavSkCiGq6pUaBAgSTL6gDhRC8sgmHChAk2I7uDsrG3bNmSjQsAAJDWwevx48dt9uDUUNImPR+IVPTCIhAJCQkeQ4br1atnChYsyIYFAABI6+BVyZoCPbkDIh29sEgNlQTbsGGDy7K2bduyMQEAAIIko79POHr0qC1/k5rnAdHWC1uzZk07Z/Hbb791uX/37t3m4YcfNk2aNDHDhg0zuXPnDltbERnce11vuukmU7Vq1bC1BwAAwMR78KqkTdWqVQtNa4AI7YUdP368efnll82xY8c85jguWLDA1j8mo2z80sWM6dOne/S66iIIAAAAwjBs2DH0N7U3IBoxFxbJ+eijj8zFixcT/1ZuAPXKAwAAIIxzXgO5OZ/cAdGGubDw5sKFC7bn3VmjRo1Mrly52GAAAADh7HkF4llKe2H1mBMnToSljUhb33zzjdm1a5fLMhI1AQAABB/BKxCCXthPP/3UtG/f3ixZsoTtG+NGjhzp8nfFihVNuXLlwtYeAACAWEXwCoSoF/bw4cOmbt26Zs+ePWzjGLVp0ybz3XffuSyj1xUAACA0CF6BEPbCKjtxr1692MYx6oMPPnD5WyWTnnjiibC1BwAAIJYRvAJB7IVdu3atR21PBbXr169nO8eY06dPm3Hjxrks0z6QNWvWsLUJAAAglhG8AkFUuHBhM2nSJJcARlm2u3btynaOMV9++aUdGu6sTZs2YWsPAABArCN4BYKsUKFCpkOHDi7LZs6caZYuXcq2jiGjRo1y+btmzZqmRIkSYWsPAABArCN4BULg1Vdf9Zj/+tprr5mEhAS2dwz47bffzM8//+yyjERNAAAAoUXwCoSAAlf3xD3Lly8306dPZ3vHYK/r1VdfbR555JGwtQcAACAeELwCIVKrVi1z7bXXuizT3Nfz58+zzaPY0aNH7bxmZ61btzYZM2YMW5sAAADigV9nW8qkGWhGVmVeBeJBpkyZTJ8+fcwzzzyTuGzjxo3mo48+YohpFJswYYI5depU4t8ZMmQwLVu2DGubAAAA4oFfwevHH39sA1B/5+05nkPwinjz+OOPm2HDhplffvklcVnv3r1N48aNTY4cOcLaNvhPxzH3IcOPPfaYTdIFAACACApemzRpYgNQACmTPn16M3jwYHPfffclLtu3b5956623TM+ePdmMUWbx4sUeNXtJ1AQAABChPa8A/FOtWjVTu3ZtM2fOnMRlQ4YMsTVBCxYsyOaMIu69riVLlrSfLwAAAEKPhE1AGhg4cKDLqIWTJ0/a+bCIHnv37jXTpk1zWfbcc88xGgUAACCSg1clK5k5c6YZOnSovc2YMcOejAPw7uabbzbPPvusy7IxY8aYDRs2sMmihBJtXbhwIfHvrFmzmqZNm4a1TQAAAPHE79oOs2fPNs2aNTOHDh1yWZ4nTx7z4Ycfmrp16wazfUDMUE/r559/bs6cOWP/vnjxounWrZuZOnVquJuGZOiz0sUGZ0899ZTJnTs32w4AACASe17XrVtns6cePHjQXHbZZaZ06dKmVKlS9ncFs08++aT566+/QtdaIIoVLlzYdOjQwWWZhqEuX748bG1Cyi/a7dixw2UZiZoAAAAiOHhVhtSzZ8+amjVrmn///dcGqqtXrzZbt2411atXN+fOnTNvv/126FoLRLkuXbrYUQrOOnXq5Hf5KaStkSNHuvxdoUIFU758eT4GAACASA1eVSYic+bM5tNPPzUFChRIXK6MqZ999pntgdVjAHh3xRVXmO7du7ssW7JkiZk1axabLEL9888/Zt68eS7L6HUFAACI8OB19+7dpkSJEiZfvnwe9+XPn9/ep4ycAHxr166dKVasmEePrHMyIESODz74wOMCRMOGDcPWHgAAgHjlV/CqRDM6cfNF92noMADfNHqhX79+Lsv+/vtvM378eDZbhNExb9y4cS7LlDU6W7ZsYWsTAABAvKLOKxAGSm5Wrlw5l2VvvPEGJacizJQpUzwyq6u2KwAAAKIgeN2/f7+ZMGGC15vuk4kTJ/p8TLhdunTJDB8+3GZJzpUrlylSpIjNAHv06NGA1jt37lxz991329IZefPmNfXr17e9acn5+eefTa1atcyVV15pb/p9xYoVKXpNzcN7+OGH7ZBt9XqXLFnSnlgnVTt0z549ttSR5inrObfffntEfC7xJn369GbQoEEuyzTk/p133glbm+Bp1KhRLn8rMZ3+zwAAABAGCX5Ily5dQvr06VN9y5AhQ0K4NWnSJKFmzZoJf//9t/17//79Ca+88kpCqVKlEg4fPpyqdX700UcJxYsXT1i0aFHCxYsXE06fPm2X5c+fP+HXX3/1+bxvv/02oWDBggnTpk1LOH/+vL3pdy2bPXt2kq/52muvJZQpUyZh6tSpCUePHrXLduzYkTB8+PCEGTNmeH2O7i9SpEjCgAEDEo4dO5Zw6dKlhF9++SXh9ttvT+jatWuq3rteW7uRow34P+fOnbOfg34mpVatWnb7OW45c+ZM2LdvH5sxAvz+++8un41uX331Vdj3GYB9BhxnkFb4boK/Dh48GNLYIKM/gW7RokVNunTpTLSaMWOG7en8888/7bxDUfKpoUOHmmPHjpkePXqY9957z691qifztddeM8uWLTM33nijXZYlSxbTokULkzVrVtvL+ccff3hst9OnT5vmzZubSZMmmWrVqiUuf+yxx2ybnnjiCbN582avc+s+/vhjs2jRIpulVr3HznVEX3zxRZ9tfeGFF+xrKjmQg3pe58+fb2v21qtXj/IfaUy9r9r+jlI5x48fN3379vV7P0Toe10LFSpkHn30UTY1AABANAwbVm1X1XQN5BZO77//vg3cHIGrM5UvUVCoBC3+GDt2rD2hdQSuzho1amSD1B9//NHjvqlTp9rszM6Bq0OVKlVsMKn5du4uXrxog+yPPvrIJXBNzs6dO833339vXnnlFY/7VHdUge2IESNSvD4Exy233GKeeeYZl2WjR4+2Fy4QPrqYpfJfzlq1amUyZcoUtjYBAADEu7hJ2KSgdOnSpT57TtSrrLlsP/30k1/r/e6770zdunV93q/XU8+av8+rU6eO1+f98MMPdr6ugh5/26n5ejlz5vTr9RB66ml1vqCikjmvv/46mz6MNG//5MmTiX9nyJDBBq8AAAAIn7gJXtWTdfXVV9teRl8qVKhg1q1b59d6165dm+RQW1/rTO3zlMzprrvu8quNKXk99fQePnw44MRV8N8111xj2rdv77Lsyy+/NCtXrmRzhoGGcLsPGdZFKB0/AAAAED5xE7xu27bNFCtWLMnHqPd1+/btKV6nemY0vFBz4fxdZ3Lt8fU8ZTDW8zQ3UqVVypYta7MUqze2T58+dpiyN8m9nubkKvOyP+8fwdOtWzebqdpZp06dEufCIu1o9IUu9jhr164dHwEAAECY+ZWwKZqdOHHCloZJiu7XvF5/1nn55ZfbsidJrVOP87c9vp6n3lENMb3//vttb5Dmsao0z6ZNm2wwe99995mFCxfaZFH+vF5Sr+ns7Nmz9uag4F3Onz9vb/g/jm2R0m2SI0cO07lzZ5dkWosXLzazZs0ytWvXZrOmIfe539dff70tgxXq/dvffQZgnwHHGYQaxxn4K9TnMXETvCrguuyyy5J8jIJCfxI2BbLO5J6r5507d872vDlnKlbP6ltvvWWaNGlikyw53HDDDeaLL76w82iVfEqPCVZbnQ0YMMD07t3bY7nmy3rLjBzvNNc4pa699lqbafrAgQOJy5Q9Wkm6NOcSoXfkyBEzbdo0l2UKXL/99tuI3GcA9hlwnEFa4LsJKXXq1CkTSnETvDqCwaQowFOZm7RYp+O5vgJKR7DpXmJH61qzZo157rnnvD5Pva/33HOPDTKd1x2s99+1a1fTsWNHl55XDTdWT7B6ofG/q0460NesWdOvDLXq+VY5IwcN4z506JB59tln2bRpYODAgTZhloP+H/S/lNRc+XDvM4hf7DNgnwHHGUQanbeaeA9e1fvk3huSEuqJVNkZx7BM9aokRffrcSmlxyp4c+8dTck6He3x9Xq+7lN5nEqVKpmMGb1/dLfddlvi3FjNh3V/vUDfv4Jgb6WGdLLNCbcJeLs0bdrUDB8+3NYidlBP99NPP03Pdoiph1slqJw9+eSTpkCBAiYt8b8E9hlwnEGk4bsJKRXqeCAqgtd3333X3gLN6JrcfFb1cnmr1+pL9uzZbW/jrl27TOHChX2uU8mXfLXH3+ddd911tmarLwqivc1dTe79KwDfsWOH19dE2tH86UGDBpkHHnggcZn2LwW06vVG6MydO9cjYVnbtm3Z5AAAABEibrINK+mKggAlPPJl1apVNmuvP1Ri5pdffvF7nal93u23355kD6qCUN2vuZP+vJ6yqyrbrXp2EV4agl2jRg2P4awHDx4MW5vigXt5nHLlytmSVQAAAIgMcRO8au6a6qMqe6s36s3csGGDTc7iD81Pmzlzps/7v/nmGxuM+Pu8r7/+2uvzqlevbv766y87xNEb3af3qmDd/fWUhdhXNmFfr4e0p95z9b460/D0fv368XGEyNatW23Pq3t5HF/TAQAAAJD24iZ4FWXnVQ+Wc6kXhzfffNMmxfEnYZO0aNHCBqEbN270OudW80OVQMld/fr17XNUDsXdsmXLzOrVq02DBg087suZM6ctkeM+N8/5fSiZk/tJt4Ynq4zO22+/7fEc9Ua/99575vnnn0/2/SJtqNevUaNGHiVctmzZwkcQAh988IFLTV2NQNB8VwAAAESOuApeVUbmjjvuMHXq1EkMNjUUs1OnTuann34yffv29XudV111lRkyZIitxalA9NKlS7bczPjx481LL71kf3rrvVEd1nHjxpmnnnrKBr/KcKqbfn/88cdtcOqr9Iza+eGHH5phw4aZ48eP22War9qsWTM7Z+/111/3+jwFqGPHjjWDBw+2PbA6Wf/tt99sj6sC9/Lly/v9/hE6uhDhnDFamUVVBgnBpYtZ+r9wT5ylOe0AAACIHHEVvIqCyQcffNAGsupdufXWW22wuXTpUpvoyJslS5a4ZO711vuqwFBB45VXXml7OTUM94cffrA9aL7UqlXLTJ8+3YwcOdLkz5/f3vS7MisrGPZFGYEXLVpkhzqrXZqrquHOyor6/fff28DYG5W0WbFihVm/fr1N/KTntWzZ0rRv3970798/ye2GtFe8eHGP3vDPP//c/Prrr3wcQfTVV195zCcmURMAAEDkSZfgPFYO8JPmYuoiwNGjR6nz6kS9pHPmzLEXIQJJGa5aWbrQoO3roOHfCxYsYD5mkKicli5eOVSrVs3OD4/WfQbxg30G7DPgOINIo3PXvHnzhiw2iLueVyCaqCffvUSOAqt58+aFrU2xRHPLnQNXodcVAAAgMhG8AhHuxRdf9KgH3LlzZ58Zp5H68jgFCxa0UwoAAAAQeQhegQinOcx9+vTxKIn06aefhq1NsUDJziZOnOiyrFWrVgzZBQAAiFAEr0AUaNKkiSlTpozLsh49ethkY0gdBf/OdY/Tp09vg1cAAABEJoJXIApkyJDBDBo0yGWZyiMpyzX8pzx17kOGH3nkEZuRGwAAAJGJ4BWIEirxdO+997osU4mj//77L2xtilZK0qRkTc7atWsXtvYAAAAgeQSvQJRIly6dGTx4sMuyI0eOUKM3Fdx7XVWOqEaNGoF9QAAAAAgpglcgilSoUME0bNjQZZmGDv/7779ha1O0OXDggPnqq69clj333HN2zisAAAAiF2drQJTp16+fS0bcc+fO2eRNSJlx48bZbeaQOXNm06xZMzYfAABAhCN4BaKMhri2bdvWZdlnn31mfv/997C1KVqoNu7o0aNdlqkn+8orrwxbmwAAAJAyBK9AFOrevbvJmTOnS/bczp07h7VN0WDevHkeQ6zdLwQAAAAgMhG8AlEoX758HsHqd999Z29IeaKmW2+91VSsWJFNBgAAEAUIXoEo9fLLL5tChQq5LOvUqZO5dOlS2NoUydTjOnv2bI/yOMriDAAAgMhH8ApEqWzZspnevXu7LPvjjz/MpEmTwtamSDZmzBg7vNrh8ssvN40aNQprmwAAAJByBK9AFHv22WfNTTfd5DEf9syZM2FrUyRSduGxY8e6LGvSpInJnj172NoEAAAA/xC8AlEsY8aMZtCgQS7Ltm3bZkaOHBm2NkWiadOmmf3793vUdgUAAED0IHgFotzDDz9s7r77bpdlb775pjl8+HDY2hRp3IP5qlWrmtKlS4etPQAAAPAfwSsQ5ZRwaPDgwS7LFLgOHDgwbG2KJGvWrDE//fSTyzLK4wAAAEQfglcgBlSqVMk8/vjjLsuGDx9utm/fbuLd6NGjXf4uUKCAeeyxx8LWHgAAAKQOwSsQI/r372/nwDqcPXvWvPHGGyaenThxwkyYMMFlWcuWLc1ll10WtjYBAAAgdQhegRhRokQJ07p1a5dlCtz++usvE68+++wzc/z48cS/06dP77GNAAAAEB0IXoEYop7WHDlyJP6tuqZdunQx8UjvfdSoUS7LHnroIVO0aNGwtQkAAACpR/AKxBDN53zttddcls2dO9csXLjQxJsVK1aYP//802UZiZoAAACiF8ErEGM6duxog1hnnTp1MpcuXTLxXB6nePHiplatWmFrDwAAAAJD8ArEGA0b7t27t8uyX3/91Xz55ZcmXhw8eNDj/T733HN2zisAAACiE2dyQAxq0aKFKVmypMuybt262QzE8WD8+PHm3LlziX8ru3CzZs3C2iYAAAAEhuAViEEqmTNgwACXZVu3bvWoeRqLNDza/X0+8cQTJl++fGFrEwAAAAJH8ArEqLp165rKlSu7LOvbt685evSoiWXz5883W7ZscVlGoiYAAIDoR/AKxKh06dKZIUOGuCw7dOiQGTRokIll7uVxypYta+68886wtQcAAADBQfAKxDD1vKoH1tmwYcPMrl27TCzavn27+eabbzx6XRXIAwAAILoRvAIxTnNfM2TIkPj36dOnTc+ePU0sGjNmjEtJoJw5c5qnn346rG0CAABAcBC8AjHuxhtvNC1btvTIxrt27VoTS5Rd+KOPPnJZ1rhxYxvAAgAAIPoRvAJxQD2t2bJlS/xbvZNdunQxsWTGjBlm3759LstI1AQAABA7CF6BOHDVVVeZV1991WWZ5oYuXrzYxGqiprvvvtuUKVMmbO0BAABAcBG8AnFCwWv+/PldlnXq1MkkJCSYaLdu3Trzww8/uCyj1xUAACC2ELwCcUJzP9944w2XZStXrjRfffWViXajR492+TtfvnymXr16YWsPAAAAgo/gFYgjrVu3NiVKlHBZ1q1bN5vsKFqdPHnSfPLJJy7LWrRoYTJnzhy2NgEAACD4CF6BOJIpUybTv39/l2WbN2+2JWai1aRJk8yxY8cS/1ZN1zZt2oS1TQAAAAg+glcgztSvX99UrFjRZVmfPn1cAsBoofm67omaateubYoVKxa2NgEAACA0CF6BOKOeycGDB7ssO3DggBk6dKiJNpqz+/vvv7ssI1ETAABAbCJ4BeLQPffcYx555BGXZW+99ZbZs2ePiSbuva7qcX3ggQfC1h4AAACEDsErEKcGDhxo0qf/3yHg1KlTplevXiZaHDp0yHzxxRcuyzTXNUOGDGFrEwAAAEKH4BWIU6VKlTLNmzd3WTZ27Fizfv16Ew0+/vhjc/bsWZdkVO7vBwAAALGD4BWIY7179zZZs2ZN/PvixYuma9euJtJdunTJo7br448/bvLnzx+2NgEAACC0CF6BOFaoUCHz8ssvuyybOXOmWbp0qYlkCxYssCV+nLVr1y5s7QEAAEDoEbwCca5Tp04mb968Lstee+01W4YmWhI1lSlTxtx1111haw8AAABCj+AViHO5cuUyPXr0cFm2fPlyM336dBOJdu7caWbNmuVRHkclgAAAABC7CF4BmOeee85ce+21LltCc1/Pnz8fcVvnww8/tHNeHXLkyGGeeeaZsLYJAAAAoUfwCsBcdtllpn///i5bYuPGjeajjz6KqK2jYFrBqzMFrpdffnnY2gQAAIC0QfAKwGrQoIEpX768RzbiEydORMwWUjKpPXv2eAwZBgAAQOwjeAXwfweD9OnN4MGDXbbGvn37zFtvvRWxiZoqV65sypYtG7b2AAAAIO0QvAJIVK1aNVO7dm2XLTJkyBCzd+/esG+lv//+2yxcuNBlGeVxAAAA4gfBKwAXAwcOdMnce/LkSdOnT5+wb6XRo0e7/K3yPo8//njY2gMAAIC0RfAKwMXNN99smjZt6rJszJgxZsOGDWHbUqdOnTKffPKJy7LmzZubzJkzh61NAAAASFsErwA8qKc1S5YsiX9fvHjRdOvWLWxb6osvvjBHjhxJ/Fs9w23atAlbewAAAJD2CF4BeChSpIjp0KGDy7Jp06aZ5cuXh2VrjRw50uXvBx54wKMuLQAAAGIbwSsAr7p06WLy5MnjsqxTp04mISEhTbfYqlWrzK+//uqyjPI4AAAA8YfgFYBXV1xxhenevbvLsiVLlphZs2aFtTxO0aJFPTIiAwAAIPYRvALwSaVoihUr5tEje+HChTTZav/995/5/PPPXZZprmuGDBnS5PUBAAAQOQheAfikbL79+vXzqLc6fvz4NNlqyjB85syZxL8zZcpkWrRokSavDQAAgMhC8AogSU8++aQpV66cy7I33njD1n8NJc2tda/tWq9ePVOgQIGQvi4AAAAiE8ErgKQPEunTm0GDBrks27t3r3nnnXdCuuUWLlxoNm7c6DGMGQAAAPGJ4BVAsmrUqGFq1arlsmzw4MFm//79aVYep3Tp0ubuu+8O2esBAAAgshG8AkgR9b6mS5cu8e/jx4+bvn37hmTr7dq1y8ycOdNl2XPPPefy+gAAAIgvBK8AUuSWW24xzzzzjMsyzUndvHlz0LfgRx99ZC5evJj4d7Zs2Uzjxo2D/joAAACIHgSvAFJMPa3KQOygkjmvv/56ULfg+fPnzZgxY1yWKWjOlStXUF8HAAAA0YXgFUCKXXPNNaZ9+/Yuy7788kuzcuXKoG3Fr7/+2uzevdtlWdu2bYO2fgAAAEQnglcAfunatau54oorXJZ16tTJlrYJhlGjRrn8XalSJXPrrbcGZd0AAACIXnEXvF66dMkMHz7clCpVyg5DLFKkiOnQoYM5evRoQOudO3euzYSaO3dukzdvXlO/fn3z999/J/u8n3/+2WZxvfLKK+1Nv69YsSJFrzlv3jzz8MMPm/z589tgomTJkjapzYYNG7w+Xr1jrVq1MsWKFTOXX365rZepdi5fvtzv94v4lSdPHo+hwosXLzZz5swJeN0qjbNgwQKXZZTHAQAAQFwGr82aNTOzZ88206dPtwHrb7/9ZjJlymQqV65sjhw5kqp1jh071jz//PN2PuChQ4fMzp07Te3atU3VqlXt+pMKPuvWrWsDzn379tmbfn/ssceSDQTU0/Xqq6+a5s2b24Q5avv3339vg3L3oFmJb5588knTqFEjc9ttt9lg9dixY/ZxderUsW345JNPUvXeEZ9eeOEFU7RoUZdlnTt3dkmylBpKAOVMF3QaNGgQ0DoBAAAQGzKaODJjxgzb0/nnn38mJp3Jly+fGTp0qA3mevToYd577z2/1rlnzx7z2muvmWXLlpkbb7zRLsuSJYtp0aKFyZo1qw2W//jjD48SH6dPn7aB56RJk0y1atUSlytwVZueeOIJG5Qqy6q7jz/+2CxatMgsWbLEJYlN4cKFzYsvvujx+LNnz5obbrjBBqjOyXbUS9ykSRNz9dVXm8cff9zesmfP7tf7R3zSPq6LNU2bNk1ctnbtWruPab9ODf1PaN92pv8fvRYAAAAQVz2v77//vunSpYtLAOfQvXt3e+J85swZv3tdH3300cTA1Zl6OnVC/uOPP3rcN3XqVFOiRAmXwNWhSpUqpnTp0mbKlCke96lnS0G2SomkNPuqAuA+ffp4fd9SvXp1O3ya4cPwx9NPP23L5zh74403zKlTp1K1ISdPnmwOHz7ssqxNmzZ8KAAAAIiv4FVB6dKlS22g6Y2GQGrO6E8//eTXer/77js77NYXvd78+fP9fp6G83p73g8//GCHBrsHDYHSOtWLDKRUhgwZzKBBg1yW7dq1y84pT42RI0e6/K3539dffz0fCAAAAOIreNUQXA2PVbIZXypUqGDWrVvn13o1VLJ8+fJ+rzO1z1Myp7vuussEm4YW58iRI+jrRWy7//77bc+9s4EDB5qDBw/6tZ5ff/3VrFq1ymUZ5XEAAAAQl3Net23bZrPsJkW9r9u3b0/xOk+ePGnnyhYqVMjvdSbXHl/PU5KlmjVrmuPHj5shQ4bYebzq7VLmYCVl0vxbzbX1t1dac4E/+OCDFAW5ujno/cv58+ftDf/HsS3iYZv079/fVKxY0WWf0HxYzSVPqREjRrj8rfnbCozjYfvF4z6D4GCfAfsMQo3jDPwV6vOYuAleT5w44VGb0p3u//fff/1ap0rOpE+fPsl16nH+tsfX8zQnUHNXdWKvIcnKMKzSPJs2bbLzDe+77z6zcOFCvwLYjh07JpbcSc6AAQNM7969PZZriLO35FLxTsPD48E999zjMrdbQ4A1FL1gwYLJPlf7+WeffeaxPm/D5uNBvOwzCB72GbDPINQ4ziClUpv7JKXiJnhVb+Fll12W5GMUFPqTsCmQdSb3XD3v3LlzJiEhwSVTsRJAvfXWWzZLsMqVOCib8BdffGHn0Sr5lB6TEsOGDTPffvut+f3331P0+K5du9pg17mXTcmeFEwrkMf/rjrpQK9ecpViinU33XSTufnmm+0+KxcuXLAZsSdOnJjsc5Xh2/E8yZgxox16nJLAN5bE2z6DwLHPgH0GocZxBv5S2dBQipvg1REMJkUBpT9lOQJZp+O5vgJYR3DrXmJH61qzZo2tB+uNel/Va6Ue0uQCa/V29evXzyaBSmnmYrXbW9ZinWxzwm3idrvo4olqHb/zzjsu2YM1jP3222/3+TxdnPnwww9dlqlclC6IxKt42WcQPOwzYJ9BqHGcQUqF+hwmKhI2qXap5sD5e1MdVAclIzpy5EiSr6P7/UlapMeq51En4P6uM7n2+HqegsxKlSrZ3ilvbrvttsS5sUmZNWuW3a6zZ8+2ZXmAQL3++useF0E6deqU5P+HLpy476skagIAAEDU9ry+++679haIa665Jtn5rEqQ5K1eqy/Zs2e3Q2WVMEnBsq91KvmSr/b4+7zrrrvO7Ny502eb1FPra76sg+bJPvvss2b69Onmjjvu8Pk4wB9XXnmlraOsoeUOmn89b94888ADD6SoPI7+/+699142PAAAAKKz5zUYVC9SQaYSHvmiUh1KMuMP9Vr+8ssvfq8ztc/TEMykemzVy6X78+XL5/V+ZRV+4okn7JDhqlWr+lwPkBodOnTwuCDTuXNnc/HiRY/Hqq6wsmW797q6D5UHAAAA4ip41VxR1UfVcFlv1Ju5YcMGc/fdd/u1XiVXmTlzps/7v/nmG5vMyN/nff31116fp5qaf/31l9dgQHSf3quCdXeaK/vII4/YOYYPPvhgEu8KSB1lue7Tp4/HPvnpp596PPajjz6yiZ0clK1aicgAAACAuA5eRdl5lcXUuU6pw5tvvmmH0vqTsElatGhhg9CNGzd63Kfsv0pupARK7urXr2+fs3jxYo/7li1bZlavXm0aNGjgcV/OnDltiRyd+Huj96FkTu69V//884+pVauWzUJcr149v94j4A8FoGXKlHFZ1qNHD5es2wpax4wZ4/KYRo0aJVvOCgAAAPErroJXlZHRHM86deokBpsHDx60SWV++ukn07dvX7/XedVVV5khQ4aY2rVr20D00qVL9iR9/Pjx5qWXXrI/vQ2DVA/VuHHjzFNPPWWDX53M66bfH3/8cRuc+qqbqnaq91Rlbo4fP26X7dixwzRr1szOlVXiHGcHDhywvbgqodO4cWO/3yPgjwwZMphBgwa5LNP+qZI4ziMS3Oduk6gJAAAASYmr4FUUTGrIrAJZZUa99dZbbbC5dOlSn70+ylpctmzZJHtfdWKuoFFJazTnT8N+lUm1XLlyPp+nnlAlTVLSmvz589ubfp82bZoNhn1RFmLV0NTJv9qVO3duO9y5QIECNhmTAmNna9euNVu3brWJdPQek7rt3r07RdsRSIr+x9wTL/Xv39/8999/9vdRo0a53KeLSkn9rwAAAADpEpKqYwEkQ6WCdBHg6NGjNvMy/lfUe86cOfYiRLzW7FTSMfds1q+88ood1l6iRAmPi0oath/P2GfAPgOOM4g0fDfBX4cOHTJ58+YNWWwQFaVyAESfChUqmIYNG5rJkycnLtMIBQ0hdqaRA3ocAAAAkJS4GzYMIO3069fPpef53Llz5ssvv3R5jOZquw91BwAAANwRvAIImeuuu84OE05KcvcDAAAAQvAKIKRUJkclnrxRvWP3+a8AAACANwSvAEIqX758pnPnzl7vozwOAAAAUorgFUDIqeaxaiI7u/rqq80jjzzC1gcAAECKELwCCLns2bPbOq/OXn75ZZMxIwnPAQAAkDKcOQJIE6rjevLkSTNjxgxz99132+AVAAAASCmCVwBp5vnnn7c3AAAAwF8MGwYAAAAARDyCVwAAAABAxCN4BQAAAABEPIJXAAAAAEDEI3gFAAAAAEQ8glcAAAAAQMQjeAUAAAAARDyCVwAAAABAxCN4BQAAAABEPIJXAAAAAEDEI3gFAAAAAEQ8glcAAAAAQMQjeAUAAAAARDyCVwAAAABAxCN4BQAAAABEPIJXAAAAAEDEI3gFAAAAAES8jOFuAKJbQkKC/Xns2LFwNyWinD9/3pw6dcpul0yZMoW7OYgC7DNgnwHHGUQavpvgr+PHj7vECMFG8Iqg7KBFihRhSwIAAAAwhw4dMrly5Qr6lkiXEKqwGHHh0qVLZvfu3SZnzpwmXbp04W5OxFCPqwL6HTt2mMsvvzzczUEUYJ8B+ww4ziDS8N0Efx09etQULVrUHD582FxxxRUm2Oh5RUDSp09vChcuzFb0QYErwSv8wT4Df7HPgH0GocZxBqmJEUKBhE0AAAAAgIhH8AoAAAAAiHgEr0AIZM6c2fTs2dP+BNhnwHEGkYDvJrDPINqPMyRsAgAAAABEPHpeAQAAAAARj+AVAAAAABDxCF4BAAAAABGP4BUAAAAAEPEIXoEgSUhIMNOmTTN16tQxV111lS3ofe2115p27dqZHTt2sJ2RrHXr1plcuXKZdOnSmX///ZctBp+++OILc99995m8efOaPHnymDJlypiOHTua3bt3s9XgYdy4caZixYr2eylnzpzmpptuMm+88YY5deoUWyuOHTt2zLz33nvmxhtvNIULF07RczZs2GAef/xxky9fPnvsufvuu82cOXNC3lZE5z6zYMEC06hRI/tYHXv0s0mTJvZ8J7UIXoEg2L59uylfvrz9h9Y/5aZNm8zRo0fNkiVLzJVXXmluu+02s3r1arY1ktS+fXsbgAC+XLx40Z4IvP/++6Zbt2722HPw4EEzc+ZMeyLJRQ94O66MGDHCDBkyxOzfv98cOXLEXmj9+++/TbVq1cz58+fZaHFG5yi6sH7dddeZX375xbz55pspet6ff/5p7rnnHvPggw+anTt32mNP37597T42ZsyYkLcb4ePvPqPjTI0aNcxrr71matWqZf766y9z/Phx8/vvv5ty5cqZKlWqmO+//z5VbaFUDhAEy5YtM9u2bTNPPfWU1/t79OhhVqxYYb777ju2N7yaPHmy6dq1q70amTVrVrN161ZTrFgxthZc9OrVy544KPi47LLL2DpI0po1a2ywoUA1f/78LvddunTJ9pq1bNnSNGvWjC0ZR9566y1z7tw506pVKzt6Qxe9FEwoIE1qdNntt99uXnzxRfPss8+63Ld582bbs68A5eqrr06Dd4BI32f++ecfM3v2bPPCCy+Y9Ok9+0rHjh1rBg4caINifxG8AmlAVyd1QFdvbJYsWdjmcHHixAk7BEe9Ixp2rmHDBK9wd/jwYVOiRAk7ikNTE4DkvPvuu2bevHn2JNKbwYMH25PMDz74gI0Zx1ISvGokWePGje3+4i0YUVCjIaE9e/YMcWsRLftMcqOIFASvWrXKXH/99X49l2HDQBrQP2ju3LnNgQMH2N7woGFXmrOowBXwRb2t9evXJ3BFip09e9b2mPmi3tds2bKxRZEsjRzTd5S3wFV03/z589mSSJEMGTKYkiVLmj179hh/EbwCaUTDLXLkyMH2hgsN5xs5cqTtIQGSoqkHd911FxsJKVaqVCk7rWXv3r1eez5mzJhhatasyRZFstauXWtze/hSoUKFgJLwID4vruVIxXkxwSuQBn799Vc7nEa9r4AzJbp4/vnnzQ033MCGQbIXOjQPWiM4OnToYDPGOhLC6eKHghHAmRLraJ/RT2X9VMIUnTAqaUq9evXsvlO7dm02GpKlvB5J5WHQnOozZ87YfQxIji6oKTv+zTffbPxF8AqE2OnTp03r1q1Nly5d2NZwMWXKFLN+/Xqb0AtIyZxXjeBQiZzSpUvbnlgFsuPHjzezZs0yDRo0sMNAAQcN8Zw7d64pWLCg7WFVKa7s2bPbbJ+aa68MxEBKaH+54oorfN6vXA0qxaTHAUnR95QSxekibMaMGY2/CF6BEP+DPvPMM+aaa66x5S0Ah5MnT5pXXnnFDB061J5MAim5EKbyOAMGDLAXxBSIKDi59dZbbYCisjlK+gU40wUO1RxfvHix7XXVTaOBNFyvatWqBBtIEe03yWU4z5w5s+19BZKikoA6LqmMTmoQvAIhpJpYOqH85JNP2M5woRppOqF88skn2TJIEWUq19Dghx9+2OO+TJky2cBWtaYBhx07dtjeDZW5UMkc7SdKlKKeV813LVCggL2ABiRHgalGfiQX4FJRAUnRxVeNFNLxR8ej1CB4BUJEw4SVWv7bb781OXPmZDsj0YYNG+wcxffff5+tghRTT6tKE/ii+1QzTyW5ABk0aJCt4eotoNAwz9dff91MmjSJjYVkqaf+yJEjST7m2LFjJKaET6NGjbLnPcpcHUi5N4JXIAT69etnvvrqK/sPqoQqgPuQGdXEU3kcIKWuu+46kydPHp/3O+7TkHRAfv75Z5uUyRfdp0Q8QHI0/Um1PX3Zt2+fvUjCxXp4M3HiRNOrVy97XqzvskAQvAJBpjlnKvj+/fffU48RXm3evNmMGzfOJr/wdpOyZcva33WlEpDbb789yZ4PJXTSHNikAlzEF2V+VQ+rL7pPw4iB5ChJ3C+//OLz/lWrVtnSTIC7mTNnmpdfftnmZgjGPkLwCgTRp59+antdVZJAVykBX8OGNbxKgYi3m/z111/297Zt27IRYWmuq2p2+qL7lLyJOWdwUGkTlcXxRfeVLFmSDYZkKVv1119/bRISErzer/vuv/9+tiRcLFy40LRo0cLOc9Vc+2AgeAWCRP+Yyh47b948anYCCLrrr7/eFCpUyB5j3CmR08CBA7nYAReq5apkTUqk405BiC62PvHEE2w1JOuuu+6y8+41/NPdli1bzNSpU235E8Bh5cqVpmHDhmby5MmmcuXKJlgIXoEgUGImHbR15TE1BZcBICVGjhxp50xPmDAhsSTF33//bR599FGTP39+e4UbcFCyJg0jV4+YTiQdvWZr16419evXt+UqNJwPSI6GmKumdKdOney0F10QUTlAlWCqVauW6d+/v7n66qvZkLA2btxov5e0r1SvXt0EE8ErEAQaJqwhnjpB8DWPUbdgDZkAEJ+UoVHDsHTBTD2xOq7UqVPHlkFRkrik5jci/qgUhTLe165d29YGzp07t91nGjRoYOfVL1q0iGHmcUpl2hznJtoXdu/e7XK+MmzYMI/n3HLLLTZYnT17tg1UlZBSGav1WO1fiG1P+rHPaBrLwYMHTePGjZM8L86bN6/f7UiX4GvwOgAAAAAAEYKeVwAAAABAxCN4BQAAAABEPIJXAAAAAEDEI3gFAAAAAEQ8glcAAAAAQMQjeAUAAAAARDyCVwAAAABAxCN4BQAAAABEPIJXAAAAAEDEI3gFAAAAAEQ8glcAABCxevXqZdKlS2d/AgDiG8ErAAAxoFixYjbI0+2VV15J8rHDhw9PfKxu4XLkyBEblA4bNixsbQAARA+CVwAAYsykSZPMxYsXfd7/6aefmkig4LV3794ErwCAFCF4BQAghpQsWdLs3bvXLFiwwOv9GzZsML/88ot9HAAA0YTgFQCAGPLMM88k2bs6ceJE+7Nx48Zp2i4AAAJF8AoAQAypWrWqKVKkiJk+fbo5efKky30JCQnms88+M1mzZjX16tXzuQ4978033zRly5Y12bNnN5dffrmpWLGiGTFihLlw4YLH43/44Qc7d/bee+81ly5dsnNqy5QpY7JkyWIKFChgWrRoYQ4cOODynGeffdYUL17c/r5t2zaXObi+5uEePXrUvPTSS6Zo0aImc+bM5vrrrzd9+/b12iYAQOwheAUAIIYo8Hv66adtAKoA1tmSJUvMv//+a+rWrWty5szp9fkKMu+8807To0cPs3btWhsgFi5c2KxcudK88MILpnbt2ubMmTM+X189ugowz507Z5/733//mXHjxplq1aqZs2fPJj7uhhtuMOXLl7e/KxC96667XG7eAle1SwH0lVdeaQoVKmT++ecf88Ybb5i2bdsGsMUAANGC4BUAgBjjGBLsGCLsz5BhBYKrV682pUuXNhs3bjR//vmnWbdunVm1apXtRf3uu+9Mz549vT532bJlthf2559/ts9ds2aNDYAV/Orn+PHjEx/brVs3M2XKFPt7wYIFbWDtfHOnoDVfvny2l/b33383W7duNbNmzTIZMmQwH330kfn7779TubUAANGC4BUAgBhTqlQpc9ttt5nvv//e7Nmzxy5Tr6eCxfz585uaNWt6fd6mTZvMtGnTEgPd6667LvE+9ZK+9957iYHk8ePHPZ5//vx5+5g77rjDpYe1U6dO9ve5c+em+j1lzJjRDnlWj6vDI488YurUqRPwugEA0YHgFQCAGKTeVZXL+fzzz+3f33zzjS1N89RTT9lA0Bv1qmpebJUqVWzw665+/fq2F1VDkpcuXepxf+7cub3Opa1QoYL9uWXLllS/nwceeMC+dijWDQCIDgSvAADEIAWpGlLrGCrs+OnIRuyNhvo6em69SZ8+vbnxxhtdHuvMuafWmXp75cSJE36/j7RYNwAgOhC8AgAQgzSPtEaNGuaPP/4wP/74ox1Wq8DTkSTJG0cA6AgIvdG8V/E2bFiZiX0FvaJe3dQK5boBANGB4BUAgBjlSMykn8r+m1xt1xw5ctif+/fv9/mYffv22Z++shUDABAqBK8AAMSoxx57zAak27dvTyyhkxQlVxJlF/ZGNVwdWX0djw2Er3quAAB44z1jAwAAiHrZsmUzr7zyii09U6JECXPNNdck+fj777/fBpR6vMrRuCdtUibinTt32iG83mqx+itr1qz25+nTpwNeFwAg9tHzCgBADOvVq5dZsGCBGTVqVLKPvf766xOzBTdp0sQlg+9vv/1mXnzxRfv7Cy+8EJRhw6rbqvVomPL69esDXh8AILbR8woAABIpyFUm4dWrV9uhwWXKlLH1Wx1DiZUESgFxMKiXt0GDBmbcuHGmXLly9rUciZl++OEHPhUAgAuCVwAA4NIbunz5cvP222+bL7/80gayyuireqrqjW3Tpo3JlClT0LbY8OHDbe/rzJkzzZ9//mkDZQAAvEmXQG55AAAAAECEY84rAAAAACDiEbwCAAAAACIewSsAAAAAIOIRvAIAAAAAIh7BKwAAAAAg4hG8AgAAAAAiHsErAAAAACDiEbwCAAAAACIewSsAAAAAIOIRvAIAAAAAIh7BKwAAAAAg4hG8AgAAAAAiHsErAAAAAMBEuv8H8sZiOo1PctUAAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
    " ] @@ -304,7 +304,7 @@ "source": [ "plt.figure(figsize=(10,6))\n", "plt.plot(np.arange(12)+1,diff_VMAX.mean(dim=['lat','lon']),color='k',lw=3)\n", - "plt.xlabel(python_in_ds.month.standard_name)\n", + "plt.xlabel(python_in_ds.month.long_name)\n", "plt.ylabel('PI Difference (m/s)')\n", "plt.title('Monthly Average PI Difference (Python$-$MATLAB, m/s)')\n", "plt.grid()\n", @@ -326,7 +326,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
    " ] @@ -378,7 +378,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "PMIN: The maximum absolute difference across all points is 0.31259276608238906\n" + "PMIN: The maximum absolute difference across all points is 0.3001142356515629\n" ] } ], @@ -400,7 +400,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
    " ] @@ -436,7 +436,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
    " ] @@ -469,7 +469,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
    " ] @@ -481,7 +481,7 @@ "source": [ "plt.figure(figsize=(10,6))\n", "plt.plot(np.arange(12)+1,diff_PMIN.mean(dim=['lat','lon']),color='k',lw=3)\n", - "plt.xlabel(python_in_ds.month.standard_name)\n", + "plt.xlabel(python_in_ds.month.long_name)\n", "plt.ylabel('$P_{min}$ Difference (hPa)')\n", "plt.title('Monthly Average $P_{min}$ Difference (Python$-$MATLAB, hPa)')\n", "plt.grid()\n", @@ -503,7 +503,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
    " ] @@ -555,7 +555,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "T0: The maximum absolute difference across all points is 0.1797758138505685\n" + "T0: The maximum absolute difference across all points is 0.179813043123346\n" ] } ], @@ -577,7 +577,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
    " ] @@ -613,7 +613,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
    " ] @@ -646,7 +646,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA6AAAAI9CAYAAAAkShWYAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAtMxJREFUeJzs3QWcVOX3+PFDd4d0h4I0CEq3INKpgICAgUFICoIgrSiIWIQiLd0lSEgIEiKggDTS3bn/13l+/9nv5O7OzuzEzuf9es1rd+/MvfPMnbsz99znec6JExYWFiYAAAAAAMSwuDH9BAAAAAAAEIACAAAAAHyGHlAAAAAAgE8QgAIAAAAAfIIAFAAAAADgEwSgAAAAAACfIAAFAAAAAPgEASgAAAAAwCcIQAEAAAAAPkEACgAAAADwCQJQAAAAAIBPEIAiaPzwww8SJ06c8Fv9+vWjtF7Dhg1t1tPtBLN27dqZ11GlSpVob2PQoEFmG7ly5ZJA0bVr1/D36LnnnvN3cxANffr0sflfc/f21FNP+eSzw3JLnDixZMyYUQoWLCiNGzeWoUOHyv79+732PzRv3jypUaOGpE+fXuLFi+fy8VF9HALLgQMHJH78+Oa4vXPnTpSPu7hx40rq1KmlZMmS0r17dzly5IgE+3dKbObrcw93vguPHz/u0Weu3n799VeH12lZ5uvvdFf/M3rT/7V06dJJpUqVZPTo0XL9+nWP2xjVtkS2P3r27Bn+2Oeff96mbZb9oP/r+B8CUAStlStXysWLFyN8zOXLl2X58uUSDAIxKPSVR48eyYwZM8L/3rFjhxw8eNCvbYL7fv/9d492W5kyZXy62+/fv28+Qw4dOiQLFiyQ/v37y7PPPisVK1aUPXv2eLTtCRMmSNOmTeWXX34xn0NPnjzx6HEIPB988IE8fvxYevfuLUmTJo3yemFhYeYEdffu3fL555+bY27KlCleb18of6cE67lHbPkujInXof9rV65ckU2bNkmvXr3M/81ff/0l/qT/y++++658+umn5m8NjtesWSOpUqWyuTCbJEkS+eqrr+To0aN+bG1gIQBFUEqZMqU8fPhQZs6cGeHj9H59nD4egUu/qO2/0H/88Ue/tQfRs3TpUrl586bD7cSJE+GPeeutt5w+Rm/aE+iLY83yfBoEaNu2b98uX375pZQvX948ZvPmzVK2bFmPggLtTVWWYPbatWvmObXXLDqPQ2BZu3atrFixwvR+6jHt7nH3zz//mPc+UaJE5kJIp06dZMuWLT5pOwL33MPd78KcOXO6/Dy1DoC/+eYbl4/Tz55A/E63/p/R27lz52Tr1q3y+uuvmwsrp0+fNr3R+v/jr+DzjTfekPHjx5u/dRSLfiYkT57c5nGZMmWSN998Ux48eCB9+/b1S1sDEQEogpL2GKipU6dG+DjL/c2aNfNJuxA9li+mtGnThn8ZTps2jd6gIKO9QPrla3/7999/wx9TunRpp4/Rm56MxzS9Em15Pj05zJEjhxke9s4775jAc9myZeY41JOFzp07m55JV71LegKiQ+Ds6YnXf//9Z37XYVfFihUzV8T1Oa17yqL6OASeIUOGmJ8aOOox5e5xV6BAAenXr598++234b07w4YNi/F2I7DPPdz9LtRAzNXnqfVxqZ+trh6nw/4D8Tvd+n9Gb3qxp1y5cjJx4kR5//33zWOOHTtmRq/4mv6/6tD177//3vz90ksvmQuwrj6333vvPfNezZkzx1x8AgEogtSrr75q5tH88ccfLod16D+5DvvQx7Vu3drnbUTU6JAa/eBWLVq0MFc31ZkzZ0wvA4Kf9XBWDbICWd26dWXx4sVmvpEOI9MTBw003WE9H1Dn+nn6OAQW/c7ZuHGj+d3T75a2bdtK7ty5ze/r1683J7YIzXOP2PJd6IvXoT2PFrqvfUm/F/R9tVxk0PwBGgRHdAFVh8G/8MIL5vfvvvvOZ20NZPSAIihlyZJFqlevHuGVSMsVuKpVq0q2bNki3abO2RgwYIBJDKEng5qgRD809AQhsrlt9kkc9u3bJ6+99ppkz57dfCjpEAz9IP7zzz8d1tXJ7bruxx9/bP7WIYH2k+8jmsPjznNF5Pbt2+bKvD6fzlmIjO5/fazuL0/oUCXtbVK6r5s0aSLJkiWL8L29ceOGudKozz9w4MBIn0OPAX2s9r45oyd9+lx6FTNz5sySMGFCk+xA308duqRDqaLyvm/bts2coGivmm7D+n3TK7/r1q0zCQn0i0iHTun7lSZNGjP3UV+HHoOR0SQ5+uWn/wN6jOpzdejQIfxkSJ9T26Q9dK5E9/VG1969e81PDep03k6g06G4+j+ldCis9opGZX6dJWmF9TLLsWedzCKqj/PWe+bOcerp83nyWeisDdOnTzfJXPQzXI93TdRUvHhx02NtCQK91faosvRalipVyiSw8oTuq8KFC4dfkNDPAE8/i/35nRLd71FvHjfBdu7hyXdhIPLF69DPLgtnCcBiir6u5s2by6xZs8zfrVq1ktmzZ0uCBAkiXddyMUKPj/t+GjYcUMKAIDFlyhTthjC3gwcPhv3000/m9+zZs4c9fvzY5rFPnjwJy5Ejh7n/xx9/DDt8+HD4urodexs2bAhLkyZN+GOc3fr06eOyba+99pp5TOXKlcNmz54dljhxYqfb0OXr1q2zWXf9+vURPq/ecubM6ZXnshg4cKDDdlWnTp3M8syZM4c9evTI5es9fvx4WJw4ccxjx48fH+aJMmXKmO3kz58/fFmbNm3MsqRJk4bduHHD6XotWrQwj8mTJ0+E2z916lRY3LhxzWO/+OILp/eXLFkywv2vbTx//rzDutbvxVdffRUWL148l+/bwoULI32fM2XKFLZ7926Xr2XOnDlhCRIkcLqu7qsVK1aY59S/9T12tT+i+3qjq1ixYma7hQsXDvP3Z4f+v0XF1q1bw9d59913o/Q/ZP08rm76/FF9nLfeM3eOU0+fzxufT5bPmBIlSkS6n/xxfGfJksVsp3///l457urVqxf+uAsXLnj8WeyP7xRPv0e91YZgO/fwxnehK9bHQWTPHd3PSW+/jqi24cCBA+GP++STT8Jign1b7t27F/bSSy+FL2vfvr3D+x+RY8eOha+7fPnysFBHAIqgYf8lcPv27bDkyZObv9euXWvz2F9++cUsT5YsWditW7ci/BI4cuRI+HZSpkwZ9vnnn4cdPXrUnAisWrUq/MNUb5999lmEX55Zs2Y1X5AvvPCC+YDRk5z//vsvbNKkSWbbli9+6xMK/f3mzZthffv2Nffrl5f+bX3T1+qN54osAN2+fXv4a12yZInL98Kyvj7/lStXwqLL+ktk8ODB4cvXrFkTvlxfjzNLly4Nf8zmzZtdPseIESPMY+LHj+9w0qlfhPolqfenSpUqbPjw4WH79u0zr0mPgXHjxoWlTp3a3F+pUiWHLxvLe/HUU0+Z7T///PMmCNTnOX36tGmjhe5PPbnS40tP1PS4u3TpUthff/0V9u2334YVKFDAbCt37txhd+/edXgdf/75Z3jwqc83efJk8xznzp0Lmzdvnlk/bdq04e11FoB6+nqj48GDB2EJEyY023z11VfD/CE6J1babstJcKlSpaL0P/Tw4UPz/7p//36bEw3r/2X9f4zq47z1nrlznHrrf8KTzyd9Lv0/0MfoxaPOnTuH/fbbb+YzWbej/++6//Wz0tfHt/V3yeLFi71y3OXNm9c8JkmSJOH7w5PPYn98p3j6PeqNNgTbuYe3vgsDKQD19HVEtQ3du3cPf5z+r8QE67bosVizZs3wv9966y1zscFd+hms6/fu3Tss1BGAImjYfwmotm3bmr/1y8vZl5ledVMRfQk0bNjQLNeT+23btjk87507d8Kee+658C/5ixcvOjzG8nx60w8pPXl11ntleczKlSujHBT6+rmKFi1q7mvcuLHT59cP3Vy5cpnHtGrVKswT+iGs29Er+Hp10EJPDLNlyxZ+ouiMnsRnzJjRPOaNN95w+RzPPvuseYxeubT3/vvvm/v0qr3lmLK3Z8+esESJEpnH/fzzzy7fiwoVKoTdv38/LLr0pNByIqrBpb06deqEn6Tql7w9PS4t+8xVAOrp642OvXv3hrdp1KhRYf4Q3ROrp59+2qyjPV7u/A9ZX+mO6Pmi8jhvvGfuHKfe/J+I7ueT/j9b7p8xY4bLtupngDfbHhV68mxpm1788fS409dneUzt2rW9+lnsy+8UT79HvdGGYDv38NZ3YSAFoJ6+Dvugz/qiiV6M0GNLL0hZRjXF5EVN67ZYRj3orVu3btHeZv369c02ypUrFxbqmAOKoKbzC5SWb7DMA9CflnIOlvtduXDhgkk4onSivJZecJaJbdy4ceb3e/fuyU8//RThNvWxzuYD6ER1S6IRT+slxuRzdezY0fxcsmSJ01pnmijDkvnTklwgOnROpGbFUxUqVLCZk6TJG3SOmtKaX5rpzp7OJ9T5F0ozy1nmnNgnv7HUCWvTpo3NfTrPSrPpKU2N/vTTTzttpybNsTyPzkdzReuA6Vyz6NIsf/q+Ka0jZk3Tz69atcr8runcn3nmGYf1dW6czr1yxduvNzYmILJn+R/SpBr+EBPvWUTHqbefLzqfTzq/W+fIKp1rZXkeZ/QzIKba7oqlPI7OadOsnNGhF//Pnj1rSv9oFl3lbL6nrz6LPX3PvP096svvUH+de3jzuzBQePt1aEK4FClShN8sWXA1iY8m7ho7dqzP5sZaspVnzJhRPvroo2hvJ2/evObnX36uXxoICEAR1CyT/G/duiXz5883y/Sn/p01a1apVq1ahOtr3TVLWvCI0qXrF6omjbF8eLqiH4quTnw01Xn+/PnDAwpPxdRz6UR5TRyhiTosXybWJk+ebH7ql0tk+zcimg1Ps+K5+rK2LNOTNVcnK5ag8urVq04TxVjW04QeWi/M/r3Xk1alr0OPGVe3okWLmsft3LnTaTs0wYmzky5n2fM0AYG2RZMoWBIpWW6jR482j7NP065JYyzHqSZkcaVBgwYu7/Pm641OAiKlyWOiuk7t2rXNPtXEUZpk6dKlS+Jrluy3+t74g7ffs8iOU28+X3Q/n7QUjiVBhyamiSpfHd+WQFDLS7jDOsmUnoxrMhvNsKxt1kBag1FLAh5ffxZ7+p5583vUl9+h/jz38PZ3YSDw5evQCy9ac1OTVfmC5btLL7a8+OKLpi5pdFg+N27dumUuxIQyAlAENeurapYrYZaflnTpEdHsgBaWTISuWO53VvfPQk8qImKpEeWNrG0x9VyalVWz1qkpU6Y49E5Yvmzbt2/v0Ym5JVOgnmA5O2kpVKiQyTKpXF3l1Pv1ccr+C01PiCyZ6nT79rX6rIM8DXKsr7Ta37RGo3LWC6Hy5MkT6evVdfUETE+qtUfj1KlTcvfuXaeP1UL11qyPOVcnZ0qvELsq5+HN1xudHlDNYqlXjyOj2Xz1REWvbm/fvt0ECRqw65e+r7+wLe+Du8GGt3j7PYvsOPXm80X388m6ZmxUL1h4u+0xEYA6C6a0N0R7ObWkR5cuXfz2Wezpe+bN71FPvte0V8k+26+7t4iyh3vz3MPb34WBwNuvQ3v4//9UQXPT7NZ6IVJLvOj/+MqVK01Pq33G8Jjw2WefhY+c0O8l7Z21XPByh14EtLjohe/XYEYAiqBnuaqmBeO1HpSlcHxUhsBYX8XSIZAR0RMX+3UiGhIWEXfrCvr6uSxDv/TqonUvgaZX16BJv1zd6Z2wp/vQUjxagzIdjqOBiv1Nv1wsJ6XaMxJRL6j2gGpPqIUeB5ZhM/bDb50FeVHhKnW6q+LT1vR43LVrl3nftOdDh9nq69ayBbo/9GYZgqc9pdb0aqmFJZ29K66OY2++3uj0gEY1mOjXr5+MGjXKJtDWXt8aNWqEF/32Be11sgwTi+ykOKZ4+z2L7Dj15vNF9/NJAyv7z9yo8NfxHVXLly8P/z/XE1f9Hz9y5Ig5pi09sv74LPbGe+bN71FPvtd0aoKe1Hty69Wrl/ji3CMmvgv9yRevQ491DeC0vJIGp1oCSb8b9QJMTNfP1efWoNkyTUbbrhdGXV1EjspxG8dPI2sCRdT+04EAplfVtOaYntzrFSrt+dK/I7sSa3+Cox9kEZ3cW4IAd06KgpUOBdOhTocPHzbDvCz1My1X4TUYsK7D5S6ds2n54N6wYYOUKFEiSldXLV9e1vRq84cffmjmgOp2LQWqLT2iOuSrUqVKDutZnyhp4Oqq59Abjh49aq7WKh1qp/M4nXHVW23dVj15jcpx6s/Xa3H69Onw2qZRmf+pr1/r/NWqVcvhPj3J6Ny5s7z77rviC3qybwlQLAXEfc3X75k/jhF7Olze+qQ2soDG12239OK7Oy9YR2BE9bX48rPYGwLle1R7lXUufDCce8TEd6E/+fp16P+TfvfrfEztTddeyZj+nNaLIzqqSoNQ7YXVut6NGjWSRYsWmVq1UWH9uZHeh8dqIKIHFLGC5YqjZfhWVK9AWk+S379/f4SPtUwaj6iAd2xiSWqhV9p16KMOjdQPeev7PB2qE90vOGtaqLxy5co2QacGMparsTqPytmVRksyAKUnEDHJOhFPRElVXM1nsT7m7OeHWtP5KdeuXXN6ny9fb3Tnf+oxpo9z9n7p1e6TJ0+Kr1gS2ihnAbEv+Po988cxYi9fvnxO/28Cpe0ZMmTweWKqmPws9oZQ/h6N7rlHTHwX+pM/XodO63A2DDwmaXKsuXPnhn8naHJATZamI2aiwvK5kSJFCjNUOZQRgCJW0JN6y9Ad6+yokdErZnrVVOmHiiv6ZW/5gKtYsaLEBEvWv5geShJVOqxL96UGNBrMWRJe6BCYiJLdRKU30DL0RnuzrOd4OLtZ3hcdmqdXGp2xfOn/9ttvZvvaXsuVdmfDb5X2ilquWlpeW0yxHurn6v3V4Grjxo1O79PMf5Y5Ra72QWT3+fL1RjcDrs6LjejEVOfERWeopbv0OLLMUXr22WelTp064g++fs/8cYzY0x4Ry4mZOye1vmq7pXdLRyL4KhFOdD+LffWdEkjfo8Fy7hFT34X+4K/XoSNsLHw5Mk0/ZxYuXBieNEwzQL/yyitR+j+zXKgo7EYveWxFAIpYQYdFac+QXhnWn1FJdmK5mm3Jjqo9Hs6yIuoVZ52zp/TEyFVA4ynLcAydh2I/B9AfNKFNvXr1zO+a9tyShVGHvUR1uIkzemJvmQehH9qR0TZYhtO5OiHVRB2W+W3aTktby5QpY3rOXA31s5RAmDFjhrlFRI+D6F5ltU7+4uwLV6+ealtcfYHplV7NCqu+/vprp72gOtT1k08+cdkGX75e+x5QHS5VoECBSB+vJ/URnUjofdFJ/OAOzayonwn6P6gn8Dpk2l9zdXz9nvnjGHH2Hlt69WbPnm16SVyx/pz0Vdstoy18WQokup/FvvpOCaTv0WA594ip70J/8Mfr0ODVcpFQL84+99xz4kv6nabDcMuXL2/+1qD6tddeC88G7Ypl5EJlq8+RUEUAilhDT/I1cUlUMpJa09IXOjdHg4CaNWuaE049MdFsa6tXrzYfFJYTjaFDh8bYuH3L3B7tLdNAQodT6kmD3vzVK2o5odMsc5ar/Z4M+bJOv67vk/bsRUZPsCyZIDVxj9bPc3bSaukJ0BMgSx3NyIZD6fupiSu0XTpUV0+KNJGEvladR6ZXdjVjrV7V1XlWP//8c7TfW8tx+f7775s6d3olVE8MdW6oHmN6rFky+jozcuRIExDp8GK98qq1EjXJkh4nejVWe4601zeiuW++er32PaDai2jpIfE3HfJlKcehJzF6FV0TiHz11VemV0azG+owKa2VqceSfWkMX/P1e+br53PVBsuQWj2hfeutt2Tr1q3mM1n/Z7QskX5GWkpy+LLtWiZEh/37uhZldD6LffmdEijfo8Fy7hFT34XeovVu9f8sotuhQ4di9HVYf1brTeeE60ghvTClgZ8lk7Im6nIW+OtoGr14GFPDvXWusyYX0wvdlrrC+n/qKvGjtvf8+fPm98oEoOafAAgKU6ZM0f9qczt48KBb6x4+fDh8Xd2OvQ0bNoSlSZMm/DHObn369HG5/ddee808pnLlyhG2Q+/Xx+njnalSpYrT586ZM6dXn2vgwIEO23Xm8ePHYdmyZQtvR+nSpcM8ofvZsq3+/ftHeb1169aFrzdq1Cinj1mxYoXNPkuQIEHYxYsXI932uXPnwvdVZLdx48bZrBvV98Ly2pMkSeJy2x988EGk78vs2bPN63K2vm57+fLlYTly5DB/DxkyxOuv1x23bt0Kixs3rtlOp06dorTOggULwrp37+7y/hIlSoRdu3bNo8+OqNwqVKgQtmfPngi3GdF7dezYsfBtrV+/3uU2ovo4T98zd45TT5/PW5+FJ06cCCtevHikz+/tfRUVeozq+qVKlYrycRfR+xsV0f0s9tV3iqffo95qQ7Cce8Tkd6GFHnPOnttbn5MNGjTw+utwtw3NmjULu3fvntPn0GM8ou9Td/ZHRP+/V65csfmseuutt5w+7uuvvzb3p0uXzmWbQwk9oMD/nz+kV/P69+9vkqDocC69SqcZVPVKul7tGz58eIzvK51LoGUoihQpYq6u+TtNtw5t0eyjFh06dPBoe9bDbaIyVMdCrxZq0W/7bVjTq+7WSQm0bmRUrrLr8DbtVdDhNDp/R6+W6vAa7W3Uq6ras6i14XQ4qScZWPUY0x6Ali1bmu3q9rW9OhxJn1t7ECKjyQ40wYruO11Xe+l0v2hPj/bi6VxFy9xX62yi/ni9mlDJMhwpKvM/lfYsRVRnV3uxUqVKJd6i+0+PEe1J01Iv2kukSVQ2bdoU5Tb7gq/eM389nzPaQ6lDObWnX49rbZM+vw731M9ofV59n/zRds3GrLR+599//y2B/Fnsy++UQPkeDQYx+V0YW1+HHrvay669zTrcVUc36BB9Z8PQtdffUmczprPjam4C7cm1zOvUaTLdunVzeJxl6Ly2PZEH05hiizgahfq7EQAC14gRI6Rv377mJE6HfPqjNAOiRoeOWgpdz5s3L7xmWbDQ4cV6omxJ1GBN51fp8CZXiZoAX6pWrZqpRajBnQ4p9QU+i4Go0RIp1atXNxcZ9SKRDp33J72wqkOUNeTS9hR0kZsilNADCiBC2gOhdM4GwWdg094Oi1KlSkmw0URSRYsWNant7Wndw6ZNm/qlXYA97eVTkyZNclm/19v4LAaiRucdqy5duvg9+FSa90GDTx3FRPD5fwhAAbi0bNmy8Iyrb775JnvKzyKqPajJDQYMGGB+L1u2rBn2FoyGDRsmvXr1ssn0q0mW1q5dGz70EQiEHlBNWKX/dzrkLqbxWQxEnQ6J1QvmlgtF/qRJw7755hvTG8sQ9P9hCC4AG5odUbMk6vwmTfOvQ0d0DoXWRoR/aaZfncumc220h1PnQ2qWSZ0Lo8MAtY6m5cu3Ro0aQft2afbc3r17m7qHejxqr6hmAdb5f0Cg0EyhemzqPGLNsGspBeUtfBYDwa9r164yduxYMy90zJgx/m5OwCAABWBDk3ZY18fTyfJbtmyRkiVLsqf8TBMWaU9IRIlKvvjiixhLDAPAd/gsBhBbxfd3AwAEJh2+okGn9qwRfAaGjz76yGTa27Bhg5w5c8Zk+dMe0axZs5p6lRp4WjLxAYgd+CwGENvQAwoAAAAA8Al6QEOc1unT0hopUqTwe81JAAAAAP6jGXtv3rwpWbJkMVN7YgIBaIjT4FOLvwMAAACA0sSG2bJlk5hAABritOfTcpClTJnS380JGA8fPjR1pGrVqmXm2AEcM+BzBv7GdxM4ZuCLkm9aP9USI8QEAtAQZxl2q8EnAajtl7ym1Nd9QgCKqOCYgbs4ZsAxg5jG5wyic8yomJyaFzMDewEAAAAAsEMACgAAAADwCQJQAAAAAIBPEIACAAAAAHyCABQAAAAA4BNBGYBu375dateuLenSpTM3/X3btm0ebfPs2bPSvn17yZQpk6ROnVpKlSolU6dOjXS9GzduSNeuXU2dHF2vcOHC8sUXX8iTJ09crnP69Gn58MMP5dlnnzXr6K1y5coyffr0CJ9r0KBBkjhx4vB17G/79u2L1msHAAAAAF8IugB01apV0rBhQ3nzzTfl/Pnz5qa/N2rUSJYvXx6tbWpAWLZsWSlYsKAcPnxYrl69Kt99952MGzdO+vXrF2HwWb58eYkbN67s2bNHrl27JvPmzZOVK1dKmzZtnK7z6aefmuBW15k7d66ptaPB78cffyyjRo2S119/PcK2fvDBB+Z5nN2KFCkSrdcPAAAAAL4QVHVA7969Kx06dJAZM2ZI1apVw5dr8JkhQwZp3ry5HDlyxNRvdMc777xjttunT5/wZRokrl692vRoNm7cWEqXLu2w3kcffWQeN2bMmPBlTz/9tCxevFhKlixpgtEmTZrYrHP//n3Zu3ev6Wm1SJIkiVSpUkV++eUXKVCggGmLBrYAAAAAEJsEVQ+oBnT58+e3CT4tKlSoYILFn3/+2e3eTw38evTo4XBf2rRpTXD61VdfOdyngeSkSZNMEGovYcKE0rdvXxk/frzDfTr01jr4tJY+fXpp3bq1rFixwq3XAAAAAADBIKgC0DVr1pjht640aNDA9Fq6u83q1atLihQp3Nrmli1bJG/evJInTx6n69WrV0+2bt0qd+7ccas9hQoVMkNyAQAAACC2CaoAdP/+/U6HwlqUKVNGDhw44NVtaq+qzgm9fv26W+ulSpVKcufObeaUukN7VpMnT+7WOgAAAAAQDIIqAD1x4oTkypXL5f05cuSQkydPenWbceLEkezZsztsN7L1otuetWvXmoy4rsyfP9/ME02ZMqWZ96pDjzVZ0oMHD9x6HgAAAADwtaBKQnTr1i1TbsQVvU8f481tutqu/p0zZ06314vInDlzTBIlHfbrTMaMGaVFixYmsZH2zN6+fVt+++03GTp0qEnMpMFrZL2n2sOqN+tMvurhw4fmhv9j2RfsE0QVxwzcxTEDjhnEND5n4C5fnPsGVQCqgZMm+HElUaJEpicwLCzM9Fx6Y5uW7d67d88r67mi80U7d+5sgsh48eI5fczbb79t87cGm1oDtWbNmtK0aVNTouWbb76J8HmGDx9uSr7Y03mu7mYPDgU6RxjgmAGfMwgkfDeBYwYxxd38NbE+ALUEmK4CP0tQGNXg03qbEdHtJk6c2CvrOaPzSevXry8TJkyIcF6pK1pTVDPuaobgzz//3JR1cUWz83bv3t2mB1SHGNeqVcsM68X/rv7oF7wG9wkSJGC3IFIcM3AXxww4ZhDT+JyBuy5fviwxLagCUO3xu3btmsthphHdF9k2I+Jsu9Fdz96///5rgr/BgwfLK6+8ItGVJUsWk5FXkzBpbVJXNHDWmz0Nsgi0/ufUqVOya9cuU5+VnmG4g/8luItjBhwziGl8ziCqfBEPBFUSIp1zefz4cZf3a8IfTfzjzW3qcF4NRuy3G9l6UWnPmTNnpEaNGtK1a1d56623xFNaSkbnhcIzGzdulCJFipiLAs8884wJRAEAAACEWACqiXd27tzp8v4dO3aYOpre3KYOj02TJo0pq+LOejq0VQNUHRbrzKVLl8zwzjZt2kjPnj3FG06fPm0SFcGzoSodO3YMH/+uNVm1TqweWwAAAABCKADVgG3RokUu71+yZIkZzuruNtetW+cyW62rbb7wwgty9OhROXbsmNP1li1bJuXKlXM6fFOD0xdffNEkENJeNm/YvXu3CZq0RAuib9KkSQ61W3UotfZUa6IoAAAAACESgGr5kUOHDsmGDRsc7tuyZYvs27dPmjVr5tY2s2XLJtWqVZMxY8Y43Hf16lX58ssvpUuXLg736TzKDh06yJAhQ5z2omm22XfeecfhPs2KqwmHSpYsaRIGecPdu3dNhlx9Pk1IhOjR4cvOMgRbLhrohYhNmzaxewEAAIBoCqpoRbO7Tp48WVq1amV6Qh89emRu+ruWIZk4cWK0EsZokKk9X6NGjTI9oTrvU+f9acDRrl07l5lpNVjRoZla/sSSMUoDZA0wdQ6hBsz2tJ2aMCiycin2zp8/L7169ZI//vgjfJ6nBrPa0/r888+b+Z/9+vVz+7Xjf7744gs5d+6cy12ix4b2XK9fv57dBgAAAMT2AFTpsNUFCxaYkiU631Fv+vv8+fOlbt26LtcrWrSobN682el9WoZk27ZtcvDgQcmbN6+Z86nzAN99910ZNmyYy23qvFDdpvZ4FitWTFKnTi0NGzY0getPP/3kdB0NGJcuXSpp06Y1j3d1mzNnjs16yZIlM/VB33//fcmXL595TObMmWXEiBGm93PFihWR1iWFazonVy9AWNP3tE6dOjbLdJizHmdaNxUAAABALC7DYlG2bFlZtWqVW+v8+eefEd6vwdyUKVPcbosGoWPHjjW3qNDe1ejQci46rBcxQy806DBba6+99pp06tRJWrdubTP32DKMOrKLHgAAAACCvAcU8LYTJ07IV199ZbNMh3lrXVWd66u90fbDqe/fvy+NGjWSxYsX84YAAAAAUUQAipD30UcfyYMHD2wK8A4aNCj8bx3aPGvWLGnZsqXNvtJ1NDCdN29eyO9DAAAAICoIQBHSdGi2/Xzdt956S3Lnzm2zLH78+OZxWrfVmibBatGihcyePdsn7QUAAACCGQEoQlrfvn1t5uVqNuH+/fs7fawGoTpPWMvvWHv8+LG88sorMm3atBhvLwAAABDMCEARsrSe7PLly22WaUmdDBkyuFxHMxF///338sYbb9gsf/LkibRt2zZaiawAAACAUEEAipCkvZ69e/e2WaYlfbp37x7punHjxpWvv/7alOmx36b2jn733Xdeby8AAAAQGxCAIiQtXLhQtm/fbrNs4MCBptxNVMSJE8eU3nEWsGrv6Pjx473WVgAAACC2IABFyNHEQTr301revHlNzU93aBD66aefSp8+fRzu097Rzz//3OO2AgAAALEJAShCjs7T/Oeff2yWDR061JRfcZcGocOGDTOlXOxp7+jIkSM9aisAAAAQmxCAIqTcuXPHpsanKlmypDRr1iza29Qg9OOPP5YhQ4Y43Ke9o5988km0tw0AAADEJgSgCCnjxo2T//77z2aZ9lJqYiFPafkWZz2eAwYMMD2k1uVeAAAAgFBEAIqQceXKFRkxYoTNspo1a0qNGjW89hy9evWSMWPGOCzX3tF+/foRhAIAACCkEYAiZAwfPlyuX79us8w+IPWGbt26Oc2Cq8+ldUbpCQUAAECoIgBFSDh58qR8+eWXNstatmxp5n/GhC5dusi3337rsFx7R9977z2CUAAAAIQkAlCEBE08dP/+/fC/48eP7zRpkDd17txZJk+ebJIUWdPe0bfeekuePHkSo88PAAAABBoCUMR6+/fvlx9//NFm2RtvvCH58uWL8edu3769TJ061SHJkfaOduzYUR4/fhzjbQAAAAACBQEoYj1N/mPd25gsWTKTmdZXWrduLTNmzJB48eI51CNt166dPHr0yGdtAQAAAPyJABSx2ubNm2Xx4sU2y3r06CFPPfWUT9vRokULmTNnjhn6a23atGnSpk0befjwoU/bAwAAAPgDAShiLc0227t3b5tlGTJkMAGoPzRu3Fjmz58vCRMmtFk+a9YsadWqlTx48MAv7QIAAAB8hQAUsdaSJUtky5YtNsv69+8vKVOm9FubXn75ZVm4cKEkSpTIZvm8efOkefPmNomSAAAAgNiGABSxkib36du3r82y3Llzm+RD/lanTh1ZunSpJEmSxGb5okWLTC/pvXv3/NY2AAAAICYRgCJW0syzBw4csFn2ySefOPQ8+kuNGjVk+fLlJiGSNV1Wv359uXPnjt/aBgAAAMQUAlDEOnfv3pWPPvrIZlnx4sWlZcuWEkiqVKkiK1eulOTJk9ssX7NmjdSrV09u377tt7YBAAAAMYEAFLHO+PHj5fTp0zbLRowY4VCLMxBUqFDBBJz281LXr19vhurevHnTb20DAAAAvC3wzsgBD1y9elWGDx9us6xq1apSq1atgN2v5cqVk7Vr10rq1Kltlm/atElq164t169f91vbAAAAAG8iAEWsMnLkSBOE2i+LEyeOBLIyZcrIunXrJG3atDbLt27dKjVr1nR4TQAAAEAwIgBFrHHmzBkZO3aszbJmzZqZ4C4YlChRwgy91Vql1nbs2CHVq1eXy5cv+61tAAAAgDcQgCLWGDRokE0Jk3jx4pnMt8GkaNGi8uuvv8pTTz1ls3z37t1mKPGFCxf81jYAAADAUwSgiBUOHjwokydPtlnWqVMnKVCggASbQoUKyYYNGyRLliw2y/ft22eC0HPnzvmtbQAAAIAnCEARK3z44Yfy5MmT8L+TJk3qUIolmBQsWNAEodmzZ7dZrrVNtXzLf//957e2AQAAANFFAIqgp4l6FixYYLOsW7dukjlzZglm+fLlM0Forly5bJb/888/UrlyZTl16pTf2gYAAABEBwEoglpYWJj07t3bZlm6dOmkZ8+eEhvkzp3bBKF58+a1WX7kyBEThB4/ftxvbQMAAADcRQCKoLZ8+XJTL9N+OG6qVKkktsiRI4cJQu3nsx47dswEof/++6/f2gYAAAC4gwAUQevx48fSp08fm2U5c+aUt99+W2KbrFmzmiBUExRZO3nypAlCDx065Le2AQAAAFFFAIqgNX36dPnrr79slg0ZMkQSJUoksVGmTJlMndAiRYo41D/VIFQzAQMAAACBjAAUQUnrfQ4YMMBmmQZmr7zyisRmGTNmlHXr1knx4sVtlmtpFg1CtVQLAAAAEKgIQBGUJkyYYIafWhsxYoTEixdPYrv06dPLL7/8IqVLl7ZZfvHiRVMndM+ePX5rGwAAABARAlAEnevXr8vQoUNtllWqVEnq1KkjoSJt2rSydu1aKVeunM3yy5cvS7Vq1eSPP/7wW9sAAAAAVwhAEXRGjRolV65csVk2cuRIiRMnjoQSzfS7atUqqVChgs3yq1evSvXq1WX79u1+axsAAADgDAEogsrZs2fl888/t1nWuHFjh57AUJEyZUpZsWKFVKlSxaGXuGbNmvLbb7/5rW0AAACAPQJQBJWPP/5Y7t69G/533LhxHYbjhprkyZPLsmXLpEaNGjbLb968KbVr1zblWwAAAIBAQACKoPHPP//IxIkTbZa9/vrr8vTTT0uoS5o0qSxZssRhHuzt27fNMk1aBAAAAPgbASiCRv/+/eXx48fhfydOnFgGDhzo1zYFEt0fCxYskJdfftlmufYY16tXT1auXOm3tgEAAACKABRB4ffff5e5c+faLOvatatkzZrVb20KRIkSJTL7SefF2tdNbdCggSxdutRvbQMAAAAIQBHwwsLCpHfv3jbL0qRJ47AM/ydhwoQya9YsadGihc0uefDggQlMtZcUAAAA8AcCUAQ8LTXy66+/2izr16+fpE6d2m9tCnQJEiSQadOmSevWrW2WP3z4UJo1ayZz5szxW9sAAAAQughAEdCePHkiffr0sVmWPXt2eeedd/zWpmARP358+eGHH6Rdu3Y2y3UebatWrWT69Ol+axsAAABCEwEoAtrMmTNl7969DqVYNOEOIhcvXjyZNGmSdOrUySGwb9Omjfz444/sRgAAAPgMASgC1v37903mW2uFCxeWtm3b+q1NwUhrpX7zzTfSpUsXh7m17du3dyhtAwAAAMQUAlAErG+//VaOHz9us2z48OGmVw/uB6FffvmlyRxsH4Rq7+jXX3/NLgUAAECMIwBFQLpx44YMGTLEZln58uVNPUtET5w4cWTMmDHSq1cvh/vefvttGTt2LLsWAAAAMYoAFAHp008/lUuXLtksGzlypAmiEH26/0aMGOEwtFlp76judwAAACCmEIAi4Jw7d8701Flr0KCB6QGFd4JQ7V0ePHiww309e/aUYcOGsZsBAAAQIwhAEXA0OLp9+7bN/EWCIu8bMGCAmVNr78MPP5RBgwaZ+aEAAACANxGAIqAcOXJEvvvuO5tlWseyUKFCfmtTbKY1Vj/77DOH5VrqRofpEoQCAADAmwhAEVA06Hn06FH434kSJTK9cYg53bt3Nxly7WmvsyYsIggFAACAtxCAImD88ccfMnv2bJtl7733nmTPnt1vbQoV77zzjqkVak+TEmlyIoJQAAAAeAMBKAJqOKi11KlTOyxDzHnjjTdk0qRJDpmGx40bJ126dJEnT56w+wEAAOARAlAEhDVr1sjatWttlmnwmTZtWr+1KRR16NBBfvzxR5P4ydrXX39tAlSCUAAAAHiCABR+p0GNfU9n1qxZzfBb+F6bNm1k2rRpEi9ePJvlEydONAHq48ePeVsAAAAQLQSg8Ls5c+bIrl27bJZp4qEkSZL4rU2hrlWrVjJr1iyJHz++zXLtHW3btq1NoigAAAAgqghA4VcPHjwwdSetPf3006b0CvyradOmMnfuXEmQIIHN8hkzZsgrr7wiDx8+9FvbAAAAEJwIQOFX33//vRw9etRm2fDhwx163uAfDRo0kIULF5pyONZ+/vlnadKkidy7d4+3BgAAAFFGAAq/uXXrlgwePNhm2fPPP2+CHgSOunXryuLFiyVx4sQ2y5csWSIvvfSSeR8BAACAqCAAhd+MGTNGLly4YLNsxIgRDmVA4H+1atWSZcuWSdKkSW2Wr1u3TmrWrClXr171W9sAAAAQPAhA4RcaeI4ePdpmmfamVapUiXckQFWrVk1WrVolKVOmtFm+bds2qVKlipw/f95vbQMAAEBwIACFX3zyySc2Qze111PnfiKwVahQQdavXy/p06e3Wf7nn3+aiwcnT570W9sAAAAQ+AhA4XOadOibb76xWaalPYoUKcK7EQRKliwpGzdulCxZstgsP3TokAlQDx8+7Le2AQAAILARgMLnBgwYYFPCI2HChPLxxx/zTgSRZ555RjZv3ix58uSxWX7q1CmpWLGi6REFAAAA7BGAwqd2795t6khae+eddyRnzpy8E0Emd+7csmnTJilUqJDNcp0LWrlyZdm+fbvf2gYAAIDARAAKn+rbt6/N35rQpl+/frwLQUqH4W7YsEFKlSpls/zatWtSvXp1M18UAAAAsCAAhc9oyQ7Nomqtd+/eki5dOt6FIKYJifS9tc9gfPv2balTp46pFwoAAAAoAlD4RFhYmAk2rWXOnFnef/993oFYQHuyV6xYIS+++KLN8vv370vjxo1l1qxZfmsbAAAAAgcBKHxi7ty5snPnTptlAwcOlGTJkvEOxBJJkyaVRYsWSdOmTW2WP3r0SF555RX57rvv/NY2AAAABAYCUMQ4zXhrP8+zQIEC0qFDB/Z+LKMZjWfOnCnt27d36AF/44035LPPPvNb2wAAAOB/BKCIcZMmTZIjR47YLBs6dKgkSJCAvR8LxY8fXyZOnCjvvfeew30ffPCBfPTRRyYgBQAAQOghAEWM0kQ09jU+n3vuOWnSpAl7PhaLGzeufPHFF6bmq70hQ4ZIt27d5MmTJ35pGwAAAPyHABQxSoOQc+fO2SwbOXKkxIkThz0fy+l7PHjwYBk9erTDfWPHjpWOHTvK48eP/dI2AAAA+EdQBqBa4L527dqmfIfe9Pdt27Z5tM2zZ8+aeWuZMmWS1KlTm7qGU6dOjXS9GzduSNeuXSVbtmxmvcKFC5ugK6LendOnT8uHH34ozz77rFlHb5UrV5bp06dH+ny6XT15L1SokKRKlUqyZ89uMslev35dAs2lS5dMsGlNs6RWqVLFb22C7+mw22+//dbhosOUKVOkVatW8uDBA94WAACAEBF0AajWkWzYsKG8+eabcv78eXPT3xs1aiTLly+P1jY1ICxbtqwULFhQDh8+LFevXjUZO8eNG+eQPMc++CxfvrwZbrhnzx65du2azJs3T1auXClt2rRxus6nn35qgltdRzPDXrlyxQS/Okx11KhR8vrrr0fYVg2Sly1bJgsWLDBB565du8xcyhdeeME8fyDReZ43b94M/1sDkBEjRvi1TfCPzp07mwssOj/U2s8//2z+n+/cucNbAwAAEAKCKgC9e/euyZw6Y8YME3Dqyaze9Hc9kdUhfdE5kX3nnXfMdvv06SMpUqQwgZIGiatXrza9NPblQyw0mYo+bsyYMZI+fXqz7Omnn5bFixfL3r17TTBqT+si6n06D04fq4FokiRJTK/gL7/8YgLL3377zenzLVy40PT+LlmyxATLKkOGDCao1UDY2Xw7fzl+/LhMmDDBZtmrr74qxYoV81ub4F/a2zl//nxJlCiRzXJL/VC9oAMAAIDYLagCUA3o8ufPL1WrVnW4r0KFCmb4qwai7vZ+auDXo0cPh/vSpk1rgtOvvvrKaSCp2V01CHVWiqJv374yfvx4h/t06K0O83VGg9jWrVubE3JndHsaJNufwKv+/fvLDz/8IPfu3ZNAoPvFemil9tLqfECEtpdfftkc3/b1Xzdt2iTVq1c3w7YBAAAQewVVALpmzRozXM+VBg0amF5Ld7epJ77a8+nONrds2SJ58+aVPHnyOF2vXr16snXrVrd7ZHVupw7JtaeBpfaM1q9f3+l6OXLkML2ieiLvb3/++adMmzbNZtnbb78tuXPn9lubEDj0ApJe9EmTJo3Nch1poHOh//vvP7+1DQAAADErqALQ/fv3S+nSpV3eX6ZMGTlw4IBXt6m9qjon1D7JT2TraYIgDbh0Tqk7tGc1efLkDsu1jmbWrFlNr6w3X39M0N5f6zqPGtxrzy9goXOuf/31V3nqqadsdooevxUrVpRjx46xswAAAGKhoApAT5w4Ibly5XJ5v/YCnjx50qvb1PmgmmnWfruRrRfd9qxdu9b0Arnbzug+n7dt2LDBIRlUz549zVxVwFrRokVNj70et9aOHj1qhtQfPHiQHQYAABDL2KakDHC3bt0yJUtc0fv0Md7cpqvt6t85c+Z0e72IzJkzx/R06rDf6LZTk/9E1sOqNwtL4peHDx+amye017NXr142y7SHS+fRerptX7O0N9jaHWz0osq6detMEiI99i10GG6lSpVMxucSJUpIMOCYAccM+JxBoOG7Ce7yxblvUAWgGjhpgh9XNDmPJr7RQMi+5mB0t2nZrn1yn+iu54rOF9VSFdoDGi9ePK+1097w4cNNyRd7Os81adKk4gl9Db///rvNMg2mN27cKMFK5wgj5mkSrUGDBtlcQNGERDpfVO/TudHBgmMGHDPgcwaBhu8mRJUvSuMFVQBqCTBdBWKWIC2qwaf1NiOi202cOLFX1nNG55NqciEtW+JqXqm3nk/nZ3bv3t2mB1SHGNeqVUtSpkwp0fXo0SOH3s98+fLJ559/bjLgBuPVH/2wrlmzZlC2PxjVqVPH/B9oqSHrD0EtWaTZrfUYDWQcM+CYAZ8zCDR8N8Fdly9flpgWVAGoJue5du2a0yQ9KqL7IttmRJxtN7rr2fv333/NibWWKHnllVe83k5ngayzMi4aZHkSaGkJmEOHDtks++STTzzuVfU3T/cLoi5jxoxmBID2muuwXOv6v1rrd9asWdK4ceOA36UcM+CYAZ8zCDR8NyGqfHHeG1RJiHTOZURzHDUBj31CE0+3qcN5T5065bDdyNaLSnvOnDkjNWrUkK5du8pbb73lUTuj8nwxRXupBg4caLOsVKlS0qxZM5+3BcFNL6DovE/7ckN6BVePpx9//NFvbQMAAECIBaBaEkVrBbqyY8cOt+eKRbZNHR6r9Qq1rIo76+nQVg0Y8+fP7/R+nd+mwzvbtGljssRGRoezasCqJWG8+fq9Ydy4cQ61S0eOHClx4wbV4YUAocPI586d6zAi4MmTJ9KuXTsZP36839oGAAAAzwRVhKAB26JFi1zev2TJErfniek2dbifq2y1rrb5wgsvmHIRruoVai9OuXLlnA5B1eBUs37Wrl3bDL2N6kl5+fLlZfHixU7vP336tPzzzz+mhqIvXblyRUaMGOGwT6tXr+7TdiD2Df/46aef5I033nC4791335Vhw4bZ1JoFAABAcAiqALRJkyZmnqHWmrS3ZcsW2bdvn9vDPrNlyybVqlWTMWPGONynvY1ffvmldOnSxeE+nUfZoUMHkyDFng4X1GyzWn7Enmap1eGFJUuWNAl63KHb02DPuoyK9XxL7R2KStIjb9LXef36dZtl9gEpEB3ag/711187JLdSH374ofTp04cgFAAAIMgEVQCaJEkSmTx5srRq1cr0hGrmVb3p702bNpWJEydGK+mNBpmTJk2SUaNGmZ5Q7VnZtWuX6fnUoM5VZlotZ6LDXj/44IPwjFEaIGuAWaRIERMw29N2ZsmSRb755hu329mwYUN57rnnTJIWS8IfHcqrJ+ibNm1yGgzHJJ1zqvvOWsuWLU1wDXiDZrTWCxpDhw51uE//X99++20zNBcAAADBIagCUKXDVhcsWGBKlmjWTL3p7/Pnz5e6deu6XK9o0aKyefNmp/dpGZJt27bJwYMHJW/evGbOZ8eOHcOH+rmi80J1m9rjWaxYMUmdOrUJEjVw1eGDrobmLl26VNKmTWse7+o2Z84cp+tPmTLFlKvQ59HnL168uOlV/e2338x6vqSJh6x7Y+PHj296YgFvB6H9+vUzc43t6YWctm3b+qRoMgAAAEKsDItF2bJlZdWqVW6t8+eff0Z4f+bMmU1w5y4NAseOHWtuUeHpvDUdlvj++++bmz/99ddfMnXqVJtlb775pgnggZigF4S0Vq0Ofbfu9Zw+fboZuaBlWnw9BB0AAACxvAcUgUF7pKyDgGTJkkn//v392ibEfq+99poZHWBfo0qH4derV89lMjEAAAAEBgJQuE2HHWt2YGs6D/app55ibyLG6dxqPf50Tri1X375xQx/v3btGu8CAABAgCIAhVt0CHHv3r1tlmXIkEF69OjBnoRP54LrMHwdkmtt69atUqVKFblw4QLvBgAAQAAiAIVbtA6plryxNmDAAEmRIgV7Ej6lNW/Xr18v6dKls1m+d+9ec9+pU6d4RwAAAAIMASiiTEve6NxPa7lz55Y33niDvQi/0JI/GzduNKWNrGmZogoVKsjhw4d5ZwAAAAIIASiiTLPeHjhwwGaZll1JmDAhexF+U6hQITMvWS+G2Nep1Z7Qffv2+a1tAAAAsEUAiii5e/eufPTRRzbLtAZpy5Yt2YPwOw0+N23aZIJRa+fPn5fKlSvL77//7re2AQAA4H8IQBEl48ePlzNnztgsGzlypKlLCgSCrFmzyoYNG6RUqVI2y69evSrVq1eXX3/91W9tAwAAwP8hekCk9AR+2LBhNsuqVasmNWvWZO8hoKRPn96UY9Ght9a0PuiLL74oS5cu9VvbAAAAQACKKNCeTvvaiiNGjJA4ceKw/xBwUqVKJStXrjQBp7X79+9Lo0aNZPbs2X5rGwAAQKijBxQROn36tIwdO9ZmWbNmzaRMmTLsOQSspEmTyqJFi6Rp06YOmZxbtWol33//vd/aBgAAEMoIQBGhQYMGyb1798L/jhcvngwdOpS9hoCn2Zlnzpwp7dq1s1keFhYmnTt3ljFjxvitbQAAAKGKABQuHTx4UKZMmWKzTE/c8+fPz15DUIgfP75MmjRJ3nvvPYf7evToIQMHDjQBKQAAAHyDABQu9evXT548eWIzrNG+FAsQ6DRT8xdffCH9+/d3uG/w4MHSvXt3glAAAAAfIQCFU1u3bpWFCxfaLNMT9UyZMrHHEHQ0YdaQIUNk1KhRDvdpcNqxY0d5/PixX9oGAAAQSghA4UCHJPbu3dtmWbp06aRnz57sLQQ1PYa/+eYbhwzOkydPNsmJHjx44Le2AQAAhAICUDhYtmyZbNq0yWaZDl9MmTIlewtB74033pDp06ebhFrWfv75Z2nYsKHcuXPHb20DAACI7QhAYUOHIfbt29dmWc6cOeWtt95iTyHW0N7OBQsWSKJEiWyWr1ixQurUqSM3btzwW9sAAABiMwJQ2Jg2bZr89ddfNst07pz9iToQ7F5++WVZvny5JEuWzGb5xo0bpXr16nL58mW/tQ0AACC2iu/pBh4+fCg7duyQzZs3y4kTJ+TixYty9+5dSZ8+vWTIkEFKliwpFStWlKxZs3qnxYgxWu/TPstt0aJF5ZVXXmGvI1aqVq2arF271vR6Xrt2LXz5zp07pXLlyrJmzRrJnDmzX9sIAAAQm0Q7AF2/fr1MnDjRZErVwEU5q6dnSfbxzDPPSIcOHaRt27YmOEXgmTBhgpw8edJm2fDhwx3mygGxSbly5WTDhg1Ss2ZNuXDhQvjy/fv3m4tnGqDmypXLr20EAAAI2QB0yZIlZo7gwYMHTcCphd6LFy8uZcqUMT0FadOmlSRJksiVK1fM7cCBA6aHVH9+8MEHprZk586dZcCAAaaHFIHh+vXrMnToUJtl2gOkPUNAbKc9/Zp4q0aNGnLq1Knw5f/++69UqFDBBKFPP/20X9sIAAAQcgFopUqV5LfffjMBZvPmzaVly5ZSu3ZtSZw4caTr6oncrFmzZObMmTJ+/Hj58ccfZerUqdKgQQNP2g8vGTt2rLlgYG3kyJEO5SqA2KpAgQJmKoEGoYcPHw5ffubMGdMTunr1ailRooRf2wgAABBSSYg0OY32XJ4+fdoEkho8RiX4VHnz5pUPP/zQbOOXX36RUqVKyZ9//hnddsPLvvrqK5u/GzduLGXLlmU/I6TkyJHD9IRqj6i1S5cuSdWqVc0FOAAAAPioB1STDKVIkUI8pSdyert586bH24J3WObxKp3zOWzYMHYtQtJTTz0lv/76qxl+vn37dpth6rVq1TLz3nW+KAAAAGK4B1SDz7Nnz4onunXrZrM9BB5NFlWwYEF/NwPwmzRp0pgMuJol19qdO3ekXr16poYoAAAAfFAHVHsurTNFuqNjx44ybty4aK0L39D5vQMHDmR3I+TpBbJly5aZeqHWHjx4IM2aNZOffvop5PcRAABAjAeghw4dcjsIffz4saklOXnyZEp6BLiuXbtSsxX4/3SO+7x586RVq1YOn2laUkpLFwEAACAGA9CSJUuaEiyaKVITc0RGews0oY1mwE2QIIHMmDHD3aeED4cd9urVi/0NWNHPLe3t1PJR9rp06WJq5QIAACCGAlCth6elCDSbrQah9qU7rN29e9fMl9LaodqToMk7mjZt6u5Twkc0S3Hq1KnZ34AdTcz1zTffSM+ePR32jdY27tOnj6mLDAAAAC8HoBqgaBBarFgxU0ZFg9CrV686PE4z3GrGSH1s8uTJZfny5SarJAJT1qxZTW8OAOe0Jq7Wxv3kk08c7tPl7733njx58oTdBwAA4M0A1DJUU2t5FilSRPbs2WMCTS1RYKG9opaaeRqwajbJKlWqROep4MPez6jWdAVCOQjV/5WxY8c63Pftt9+a5Y8ePfJL2wAAAGJdHVBradOmlXXr1plA848//jBBqAaat2/fNjXyDhw4IBkyZJDVq1eb3lIEtpYtW/q7CUDQ0N7OlClTyuuvv27T67lhwwbJnj275MuXT/LmzWtu1r9rjVENYgEAAEJVtANQlS5dOtMTqkHozp07TeCpvZ///vuvGdKpw2+pJxk8c9wARF27du3M9ALN8P3w4cPw5ZcvXza37du3O6yTLFkyyZMnT3hAan3LmTOnxI/v0UcyAABAwPP4bEd7OdevX2+G2O7YscMs0xMsDUz1hAoAYitNqqZBqGb61qRrkdERIvv27TM3ZxeB9DPTWXCqNw1eAQAAQi4AnTp1qtPlWhNvwIABZniZDkvToWiu6GMBIDZ48cUXzVSDjh07yj///BPt7Wht0aNHj5qbTmewp8N3rYfzWt/Sp0/P0F4AABA7A1AddhbZHKb+/fu7vE/XJQAFEJtUqFBB9u7dKxMnTpRs2bLJiRMnzFQEy02DSq2J7Inz58+bmyZ3s5ciRQqXPac6J5Uh9gAAIGgD0Bw5cnClHQDsxI0b1wSfdevWlQQJEjj0bp45c8YmKLW+WWcRjw4te6UZyfVmT9uSK1cup8GpTpdIkiQJ7yUAAAjcAPT48eMx0xIAiKW0B1Iv3ulNk7ZZCwsLC0/e5uz233//efTcmiDp8OHD5uZMlixZXA7t1WznAAAA3kTKRQDwI52WoBnF9fbcc8853H/nzh05duyY0+BULwhaZ+CNDg1w9bZx40aH+7SOs6uhvZrpXHt9AQAA3EEACgABLGnSpFK4cGFzs6dDe0+dOmUTlB45ciT891u3bnn03NeuXTN1nvVmL1GiRJI7d26nwaku1/sBAADsEYACQBAP7dX5nXqrXr26w9DeixcvuhzaqwmNPHH//n35+++/zc1Zr67Oh9Vg1DK8t3bt2lKiRAmPnhMAAIRYAPr2229Lv379zImFp2bNmiVPnjwxRdwBAN6lQWDGjBnN7fnnn3e4X3tHNTuvs+BUs/hq72p0afCrPbN6+/XXX82yvn37ypQpU0wmdQAAELrcCkC/++47mTx5srRu3dqUUqlUqZJbT6ZX42fPni1fffWVHDp0SAYPHuxuewEAXpA8eXIpWrSoudnTeaUnT5502Xuq81KjQ0t0tWnThrIwAACEMLcCUE3x37t3bxOE6pVszZ5Yp04dkzijVKlSkjlzZpM1MWHChKasgGZ2PHjwoOzcuVM2b95sroTrVXVNtvH555/LW2+9FXOvDAAQLVq6xTKf01nvpg7ftZ5ran27dOmSy+1qKRr9HrAfLgwAAEKHWwHos88+K8uWLZNNmzbJ+PHjZdGiRabw+qRJkyJcT09YlM4F6tSpk7z55pumcDoAIPiG9mbKlMncKlSo4HD/jRs3bALSb7/91mTxtfjpp58IQAEACGHRSkJUsWJFc9Mr3QsWLDDp+7ds2WLm+zx69Cj8cSlTppTixYubk5RatWq5PWQXABBc9HNfkw1ZEg5pb2qPHj3C7583b55MmDDBZPcFAAChx6MsuOnTpzc9mnqzTtt/79698KG4AIDQ1apVK+nZs6dJOmdJfrRw4UIS0AEAEKK8XkVcC5fr0CyCTwCA5gaoWbOmzY7QYbgAACA0eT0ABQDAmma+tbZ69Wo5d+4cOwkAgBBEAAoAiFENGzaUZMmShf+tw3FnzpzJXgcAIAQRgAIAYpQGn02aNLFZxjBcAABCEwEoAMDnw3B3794t+/fvZ88DABBiCEABADGuatWqkiVLFptl9IICABB6CEABADEuXrx48uqrr9osmz59enh5FgAAEBoIQAEAfhmGe/r0admwYQN7HwCAEEIACgDwiSJFikixYsVsljEMFwCA0OLVAPTUqVMyY8YMGT16tAwePNjmvocPH8qDBw+8+XQAgCDvBZ07d67cuXPHb+0BAABBGIBeunRJWrRoIblz5zYnF3369JGPP/7Y5jHt27eXJEmSyB9//OGNpwQABKFWrVpJ3Lj/++q5efOmLF682K9tAgAAQRSA6slD5cqV5eeff5asWbNKu3btzE97HTt2lLCwMJk/f76nTwkACFKaCbd69eo2yxiGCwBA6PA4AB01apQcPHjQFBn/+++/ZdKkSZIzZ06Hx1WqVMn0gK5fv97TpwQAxKJhuKtWrZLz58/7rT0AACCIAlCdv5MoUSKZOHGiCTBdPlHcuJIvXz45efKkp08JAAhijRo1kqRJk4b//fjxY5k1a5Zf2wQAAIIkAD1+/LgUKFBAUqVKFelj9YRD54sCAEJX8uTJpXHjxjbLGIYLAEBo8DgATZw4sZkHGhVnz56NUqAKAAitYbiaoE6ncwAAgNjN4wC0cOHCpvzKiRMnInzcnj17zPDbUqVKefqUAIAgp4mIMmfObLOMXlAAAGI/jwPQ1q1bm/k7nTt3dlnL7erVq/L6669LnDhxpG3btp4+JQAgyMWLF09eeeUVm2XTp0+XJ0+e+K1NAAAgCALQTp06ScWKFWXNmjVSpEgRUwPUks1w8uTJ0r17dylYsKDs3r1batasKS1btvRGuwEAsWwYro6S2bhxo9/aAwAAgiAA1avYS5culRYtWsixY8dk9OjRcuTIEVPzU4PTL774wiQeat68ucybN887rQYABL1ixYqZC5fWGIYLAEDsFt8bG0mRIoXMnDlT+vXrJwsWLJB9+/bJ9evXTabDQoUKmZT7zP0EADjrBe3Vq5dNaa/x48dHWNYLAACEeABqoVey7a9mAwDgis4D7d27txk1o27cuCGLFy82o2oAAIDvaB4GTS4b8ENwAQCIrqxZs5qMuNYYhgsAgO/NmjVLypQpE/gBqF6pzpMnj3z22WcRPk7v18ctX77c06cEAMTiZEQrV66Uixcv+q09AACEmvv375vplI8ePQr8AHTq1KmmBqjO84xIgwYN5Pjx4+bxAABYNG7cWJImTRr+t5b20quwAADAN7766isT0/mCxwGollfJmDGj6d2MSL58+eSpp56SnTt3evqUAIBYRBPW2V/EZBguAAC+cfXqVfnkk0989GxeCED/++8/yZEjR5Qemz17djl79qynTwkAiOXDcHfs2CH//POP39oDAECoGD58uAlCgyYATZYsWZTn6mg90ESJEnn6lACAWEYTEekoGWv0ggIAELN02O24cePElzwOQLXsijY8sqG1er/OAX322Wc9fUoAQCwTP358U5LF2rRp00xKeAAAEDMGDBhgEhBZxIsXTwI+ANUTBq3f9uqrr8rRo0edPubYsWPm/jhx4jicYAAA4GwYrl7c3Lx5MzsHAIAYoLl89GKvtQ4dOkjAB6DayBdeeEEOHz5sejdbt24tX375pRk6pT818NTlev/zzz8vnTp18rjR27dvl9q1a0u6dOnMTX/ftm2bR9vUuant27eXTJkySerUqaVUqVJRytirRdO7du0q2bJlM+sVLlxYvvjiiyhdtdfXoSdcOix54sSJkT5+0KBBkjhxYvM8zm779u2L8usFgEBTvHhx8xlqjWG4AADEjN69e5uORIsUKVJIjx49JOADUO2mXbp0qSmzcu/ePZkxY4YJyNq1a2d+zpw5U+7evWsyHOrjPO3WXbVqlTRs2FDefPNNOX/+vLnp77r96NYYPX36tJQtW1YKFixoAmWdhPvdd9+Z8dBaDyei4LN8+fISN25c2bNnj1y7dk3mzZtnatjZX8m30MD0hx9+kNKlS5uAt1y5cvLyyy9Hua0ffPCBeR5nNx0ODQDBSkfJ2H92/vzzz+a7BQAAeM/q1atlzZo1Nsv69Okj6dOnl5gW3xsb0d63BQsWmHmeixYtkoMHD5rgTKNovZqtAWPJkiU9fh4NZLXHVYPcqlWrhi/X4DNDhgzSvHlzOXLkiE09uah45513zHZ1p1toD6i+Mdp+rVGnAaO9jz76yDxuzJgx4cuefvppWbx4sXm9Gow2adLEZp1bt27JwoULZeTIkSbphiXbIwBAzKiZvn37hl+RvX79uixZskSaNWvG7gEAwAu03navXr1slmXJksV0Hmq8FRQBqIUGac4CNW/RgC5//vw2wadFhQoVTLCoV8tfe+01t3o/f/nlF6fDvNKmTWuCUy3MOmXKFJv7dLLupEmTZO/evQ7rJUyY0JxAjR8/3iEATZkypQlAAQCOdDqDfsavW7cufJl+PhOAAgDgHdOnT3eIYYYMGWI68XwRgHo8BNeXtJtYe1Nd0WHA2mvp7ja1J1J7a93Z5pYtWyRv3rySJ08ep+vVq1dPtm7dKnfu3HGrPQAQ6uyH4a5YsSLK5b4AAIBrOq2lf//+Nsu0E8+dDryAC0B1/uSpU6fk5MmTLm/RtX///gh7WMuUKSMHDhzw6jb1DdHXpMPA3FkvVapUkjt3bjOnFAAQdTpyJEmSJOF/P3r0SGbPns0uBADAQ5okVmM1azo10BflV7wagB46dMiUV9EhqzpxNVeuXCb4cnZz1WMYFZqSX7ftSo4cOdwOcCPbpibFyJ49u8N2I1svuu2JzPz586VAgQJmKK/Oe9Whx5os6cGDB159HgDwFx2RYj/ahWy4AAB45vLlyzJ06FCbZVWqVJG6deuKL3k8B1Szv1auXNkk19GkEVomRAMjzQzrbfocmvDIFb1PH+PNbbrarv6dM2dOt9fzRMaMGaVFixamd0B7Zm/fvi2//fabOZA0MdPatWslefLkEW5D565aF5vVZFHq4cOH5ob/Y9kX7BNEFceMd7Vq1cpkUbf4/fff5a+//jLZymMLjhlwzIDPGfjSJ5984jCqc9iwYWakkYUvzn09DkC1TMnNmzfNPMrPP//c1PyMKRo4aYIfV7SepvYEaiCsPZfe2KZlu/ZlAKK7nifefvttm7812NQaqDVr1pSmTZuaEi3ffPNNhNsYPny4fPzxxw7LdZ6ru9mDQ4F9emqAY8Z3Gfr0Ip6WmLIYPHiwyZIb2/A5A44Z8DmDmKalKzVBqrWKFSvKhQsXbEpZ+iJ/jccBqCbj0UBIM7smS5ZMYpIlwHQV+FmCwqgGn9bbjIhuV3t2vbFeTNDeZj2gNEOwXgSwnjtlT7Pzdu/e3aYHVIcY16pVywzrxf+u/uhJoQb3CRIkYLcgUhwz3te2bVszxcBCS1bpUNyYGGHjDxwz4JgBnzPw5XeqdU+nnt9+//33DtMjdZhuwAegT548MUOiYjr4VBro6tVwV8NMI7ovsm1GxNl2o7teTNHaPXoAaRImrU3qigbOerOnByGBliP2C9zFMeM9mpHPOgA9fvy4GYqrV2xjE44ZcMyAzxnEpD/++ENmzZpls6xLly5Op7X4Ih7w+DJy8eLF5ezZs+ILOudST0Bc0YQ/mvjHm9vU4byaKcp+u5GtF932eJq4Q+eFAkBsUKJECSlUqJDNsmnTpvmtPQAABJuwsDDp2bOnQ7UO+1IsvuRxAKpDOjUA9UWGQk28s3PnTpf36/As+5MVT7ep5VbSpElj3ih31tOhrRqg6rBYXzl9+rRJVAQAsYFOp7CvCTpnzhyvzq0HACA2W7lypaxfv94hfkuXLl3wBqB16tSRCRMmmAQ53bp1M1kK7969KzFB5+MtWrTI5f1Lliwxcxnd3ea6detcZqt1tc0XXnhBjh49KseOHXO63rJly6RcuXI+S+yze/duM2lYS7QAQGxhn3RIpzbo5ysAAIg8oV+vXr1slmXLlk3ee+898SePA1AtWqrBpwY/OlenWLFiZt6jLnd2ix8/+tNOtfyI1hzdsGGD02RI+/btk2bNmrm1TX0TqlWrJmPGjHG47+rVq6ZYq46RtqfzKDt06CBDhgxxmlhCs82+88474gsa8Ot7oM8XW5JzAIDSJGlao8waNUEBAIjc1KlTTeegfSmWiBKW+kJcb4wrduemSYuiS3fW5MmTTX047QnVTE5609+1DMnEiROj1eOoQeakSZNk1KhR4fVMd+3aZXo+27VrJ6VLl3a6npYz0WG/Wv7EkjFKA+T69etLkSJFTMDszdTJegVDJxFb5nnqMDTtCXj++efN/E8tiQMAsY39MFxNF++LLH0AAASrO3fuyIABA2yWFS1aVFq3bi3+5nEAqgGluzdPaN3LBQsWmGG/Ot9Rb/r7/PnzpW7dui7X0x2+efNml1fYt23bJgcPHpS8efOaOZ8dO3aUd9991xRndUXnheo2tcdTe361Zl3Dhg1N4BrRFfo9e/aYx1puM2bMMF3hlr8zZcrksI5mGdYe5Pfff1/y5ctnHpc5c2YZMWKE6f1csWJFpHVJASAY6QVG65JW+pk7e/Zsv7YJAIBANnbsWDlz5ozNMu1s03jC3zwuw+IPZcuWlVWrVrm1zp9//hnh/RrMTZkyxe22aBCqb7De3MkcHFkJF3s6rFmH9QJAqNEaxQ0aNLAJOvUin158AwAAti5evOgQN9SoUcPtXDkxhQmDAICgG4aro1YOHz7st/YAABCoPvnkE7l586ZD76dml491AajWy9ThpKNHj5bBgwfb3KdDph48eODNpwMAhAi9apshQwabZdQEBQDA1pEjR8z0RGs671NrawcKrwSgly5dkhYtWkju3LnNVeo+ffqYBD3W2rdvb5IIaRIdAADckSBBApOAzj4A1aRxAADg/3z44YcmSauF5ojRHtFA4nEAqt27lStXlp9//lmyZs1qssbqT3ua1EdPFDRZEAAAng7D1VrMWoILAACI/P777zJnzhybXaFJVXPmzBm7AlAdT6zZY7XkyN9//23KmTh7kZUqVTI9oOvXr/f0KQEAIahUqVLy9NNP2yyjJigAAGI6+rRkozWtmhGIZRo9DkDnzp0riRIlMjU4IypqGjduXFM+5OTJk54+JQAgBGnyBPteUL3Se//+fb+1CQCAQLBs2TLZsGGDw3DctGnTSqwLQI8fPy4FChQw5UgikzRpUjNfFACA6Hj11Vdt/r569ar50gUAIFQ9evRIevfubbMsR44c8s4770gg8jgA1eLg9ml+XTl79myUAlUAAJzRKR6ad8Aaw3ABAKHshx9+kAMHDtgsGzp0qInTYmUAWrhwYVN+5cSJExE+bs+ePWb4rc7hAQAguuyH4WoP6OXLl9mhAICQc/v2bfnoo49slhUvXlxeeeUVCVQeB6BaV+bx48fSuXNnuXPnjtPH6BCp119/3czfadu2radPCQAIYU2bNrW5qqt1pu2z/gEAEAo+//xzM8rU2ujRo03+nUDlccs6deokFStWlDVr1kiRIkVMDdDz58+b+yZPnizdu3eXggULyu7du6VmzZrSsmVLb7QbABCidCpH/fr1HWqCAgAQSi5cuCAjR460WVa7dm2pUaOGBDKPA9B48eLJ0qVLpUWLFnLs2DETcR85csSkAtbg9IsvvjCJh5o3by7z5s3zTqsBACHNfhiu1gP9999//dYeAAB8bfDgwXLr1q3wv3W0qX1AGojie2MjKVKkkJkzZ5o6MwsWLJB9+/bJ9evXJXny5FKoUCFp1KgRcz8BAF6jV3jTp09vk1lde0EHDhzIXgYAxHqHDh2Sb7/91maZTnUsVqyYxPoA1FLXM1u2bGYIrt4AAIhJCRIkMFM6xo8fb5MNVxMx6BVgAABis379+pnyKxaJEiWSIUOGSDDweAhurly5pGzZst5pDQAA0RyGq0Nwt23bxv4DAMRqW7dudZja2LVrV8mePbuERACqySC0LlsgZ1oCAMQ+ZcqUkQIFCtgsoyYoACA2CwsLk549e9osS5s2rUkEGyw8jhp1yK1lGC4AAL6iQ23te0Fnz54tDx484E0AAMRKixYtkt9++81m2YABAyR16tQSMgHo+++/L+fOnTMlVwAA8CWtRW3typUrsnz5ct4EAECs8/DhQ+ndu7fNsty5c8tbb70lwcTjALRJkyYyYsQI6dKli3Tr1k127dold+/e9U7rAACIJA+B1qK2xjBcAEBsNGnSJJP91tqwYcNMAqJgEt8bdUAtxo0bZ26RDZmyztgEAIAndBjupk2bwv/W2tRXr16VNGnSsGMBALHCrVu3ZNCgQTbLSpUqJc2bN5dgE9cbE2HduT158sQ7LQcAQESaNWtmc/VX54DOmTOHfQMAiDU+++wzOX/+vM2y0aNHB2UiWI9brAGluzcAALxFEy+8/PLLNssYhgsAiC3OnTtngk1rdevWlapVq0owCr6QGQAAO/bZcDVD4NGjR9lPAICg9/HHH8vt27fD/9Zez5EjR0qw8moAeurUKZkxY4aJ0AcPHuyQtYnU+ACAmPDiiy9KunTpbJZNmzaNnQ0ACGp///23fP/99zbL2rVrJ88++6yEdAB66dIladGihUkDrFehtRCqRurW2rdvL0mSJJE//vjDG08JAEC4hAkTSsuWLR2G4WruAQAAglXfvn3l8ePH4X9rPGUfZ4VcAHrz5k2pXLmy/Pzzz5I1a1YTketPex07djQnAvPnz/f0KQEAiHQY7pEjR2T79u3sKQBAUNq8ebMsXLjQZpmWvcyWLZuEdAA6atQoOXjwoKkHql3EWp8mZ86cDo+rVKmSidjXr1/v6VMCAODgueeek/z589ssIxkRACAYhYWFSc+ePW2WpU+fXnr16iXBzuMAdO7cuSb9/cSJE02A6fKJ4saVfPnyycmTJz19SgAAnNaZtu8FnTVrFvkHAABBZ/78+bJt2zabZR999JGkSpVKJNQD0OPHj0uBAgWitDOSJk1q5osCABATWrdubfP3lStXZOXKlexsAEDQePjwocmpYy1v3rzyxhtvSGzgcQCaOHFiMw80Ks6ePRsronYAQGDSZHgVKlSwWcYwXABAMPnuu+9MHgNrw4cPNwn3YgOPA9DChQub8isnTpyI8HF79uwxw29LlSrl6VMCABDlXtAlS5bItWvX2GMAgIB348YNhyy3muOgadOmElvE9cYXvaYG7ty5s9y5c8fpY65evSqvv/66mZ/Ttm1bT58SAACXmjdvbnOV+P79+yZTOwAAgW706NFy8eJFh2UaR8UWHgegnTp1kooVK8qaNWukSJEiZrzy+fPnzX2TJ0+W7t27S8GCBWX37t1Ss2ZNhzptAAB4U5o0aaRevXo2yxiGCwAIdP/995989tlnNsvq169vqonEJh4HoPHixZOlS5dKixYt5NixYyZC1zHLmjpYg9MvvvjCJB7SK9Lz5s3zTqsBAIiAfTbcTZs2maR5AAAEqoEDB8rdu3dtqoiMGDFCYpv43thIihQpZObMmdKvXz9ZsGCB7Nu3T65fvy7JkyeXQoUKSaNGjZj7CQDwmbp160ratGlNFlyLadOmSf/+/XkXAAAB58CBA2b0qLWOHTvKM888IyEdgG7cuNFksS1WrJjT+3UIrt4AAPAnnQOqI3O+/vprm2G4H374YayaRwMAiB369OkjT548sSlfOWjQIImN3BqCW6VKFXnvvfdsllWrVk26du3q7XYBAODVYbiHDh2SHTt2sFcBAAFlw4YNJmO7tR49ekjmzJlFQj0A1avG1pG5+vXXX2XXrl3ebhcAAB4pV66c5MuXz2YZyYgAAIEkLCxMevbsabMsQ4YMDstCNgBNnTp1pPU+AQAIBHrR1L4m6KxZs+Thw4d+axMAANa0TJj96Bwdeqs5dmIrt+aAPv/887JixQpp0qSJ1KpVS5IkSWKWX7hwQaZOnRrl7VALFADgCxqAWs+h0azsK1eulJdffpk3AADgVw8ePJC+ffvaLMufP7+pJBKbuRWADhs2TLZs2WIy3S5cuDB8+eHDh6V9+/ZR3g4BKADAF/LmzSsvvPCC+e6yHoZLAAoA8LdvvvlGjh49arNMy64kSJBAYjO3AtCiRYvKP//8Y4Yw/f3336ZOzQ8//CAZM2aUF198MeZaCQCAB8mIrAPQxYsXy7Vr18y0EgAA/OH69esyePBgh9GmWr4ytnO7DqhOin333XfD/9YAVLuKp0yZ4u22AQDgsebNm8v7779vhjqp+/fvy9y5c019NQAA/GHkyJFy+fJlm2WjR48OiVJhcd2tA7p3716bZQMHDpQOHTp4u10AAHhF2rRp5aWXXrJZRjZcAIC/nD59Wj7//HObZdrzWb58eQkFHtcB1TIsu3fv9na7AACIsZqgekH1+PHj7GEAgM999NFHcu/evfC/48WLJ8OHDw+Zd8LjOqBaOJUAFAAQyOrWrStp0qSxWTZjxgy/tQcAEJr27dtnpjBa69y5sxQsWFBCBXVAAQCxXqJEiaRFixYOw3C1ADgAAL7Su3dvm++eZMmSmSmNoYQ6oACAkKkJqinvLTSb+x9//CGlS5f2a7sAAKHhl19+kRUrVtgs69Wrlzz11FMSSqgDCgAICVoPNE+ePDY117QXlAAUABDTdBqjBpvWMmXKJN27d5dQQx1QAEBI0DwG2gtqXXdt5syZ8umnn8b6ot8AAP+aNWuW7Nq1y2bZxx9/LMmTJ5dQQx1QAEDIsA9AL168KKtXr3Yo0wIAgLdo/ekPP/zQZtnTTz8dsqUs3UpC5IxOmm3fvr13WgMAQAzKnz+/lCtXzmYZNUEBADFpwoQJDqW/Ro4cKfHju90XGCt4/KpDLWsTACD4a4Ju27Yt/O9FixbJ9evXJVWqVH5tFwAg9rl69aoMGTLEZlmFChXk5ZdfllDlVgB68uRJ81PnymTOnNlmmTty5Mjh9joAAHiDlmPp2rWrPHz40PytxcDnzZsXskOhAAAxZ8SIESYItTZ69GiTlyBUuRWA5sqVy+wsHbO8f/9+m2VRpY999OiR+y0FAMAL0qVLJ3Xr1jU9n9bDcAlAAQDepB11Y8eOtVnWtGlTh6kgoSa+uz2XGkBaej+tlwEAEEzDcK0D0F9//dWcKDBCBwDgLQMGDDAJiCx0zuewYcNCfge7FYDaT551tQwAgEBWr149SZ06tVy7di182fTp06Vv375+bRcAIHbYs2ePQ5K7N9980yTDC3UeZ8EFACDYJEqUSJo3b26zTE8UwsLC/NYmAEDs0bt3b5vvlBQpUpgeURCAAgBCeBiutYMHDzoUCQcAwF1aX1pv9gFpxowZ2ZneKMNy5swZs4N37NghFy5ckJs3b0rKlCnNDn7uueekVq1aNnNGAQAIBOXLl5fcuXPLsWPHbHpBS5Uq5dd2AQCC15MnT6RXr142y7JkySLdunXzW5tiTQCqgaamsZ82bVp4VlvrbmZNTPTNN9+Yki2vvfaafPbZZ5I8eXLvtBoAAA/p91Tr1q1t6rPNnDlTPv3005AtDg4A8IzmE9i7d6/NssGDB0vSpEnZtf9ftL5hr1y5IhUrVpS///7bBJ0a1T///POSPXt2SZYsmdy6dctkE9y6daucO3dOJk6caH7fuHGjSfoAAECgDMO1DkB1JI+O6tEyLQAAuEPrSn/44Yc2ywoXLmw64+BhAPrGG2+YuTI6tHbChAlSv359p6VYNDhdsGCBvPvuu6Zu6FtvvWWuLgMAEAg0G2HZsmVl+/btNsNwCUABAO768ssv5dSpUzbLRo4cyagaT7PgauA5b948yZAhg2zbtk0aNGjgsg6oLm/cuLFs2bLFFP6eM2eO/PPPP+4+JQAAMUaH4VpbuHCh3Lhxgz0OAIiyy5cvy9ChQ22WValShQua3ghAZ8yYYQLL/v37myG3UZEzZ07zeO0R1fUBAAgULVu2tLk6rUOo5s+f79c2AQCCy7Bhw+T69es2y0aNGuWyoy6UuR2AWoYpvfrqq26tZ3m89poCABAo0qdPL3Xq1LFZZl88HAAAV44fPy7jx493uLhZpkwZdpo3AlBNPKQ9mmnTpnVrPR2CmytXLrM+AACBXBN0/fr1cvr0ab+1BwAQPHSk54MHD8L/1iog9sNx4UEAql3LerU4OnS9a9euRWtdAABiyssvvyypUqUK/1unjGgqfQAAIrJr1y6H74suXbpInjx52HHeCkC1xErixIklOhIlSmTWBwAgkOj3WrNmzRyG4VrXtwYAwJp+R/Ts2dNmmV7M1B5ReDEA5csYABAKw3C1fNiePXv81h4AQGBbtWqVrFu3zmZZnz59zNRDeLkOqBbqnjp1arTWAwAgEFWoUMHkODhx4oRNL2iJEiX82i4AQOB5/Pix9OrVy2ZZtmzZ5P333/dbm2J1AHr48GFp3769RKf3lFTEAIBAFDduXFMT1DpxhJYO0zT61mVaAADQC5T79u2z2RFDhgyRJEmSsHMi4fY3ao4cOQgiAQCxdhiudQB6/vx5Wbt2rbz44ot+bRcAIHDcvXvXYZ5nkSJFHKZywEsBqNa5AQAgNipYsKCp27Zjxw6bq9wEoAAAi7Fjx8qZM2dsdoiOlokXLx47KSaSEAEAEJvZX8FesGCB3Lx502/tAQAEjkuXLsnw4cNtllWvXl1q167ttzYFGwJQAACstGzZ0mbOpw61mj9/PvsIACCffPKJ3Lhxw6H3kzw3UUcACgCAlQwZMjgMudVhuACA0Pbvv//KhAkTbJa9+uqrUrJkSb+1KRgRgAIAEMkwXK3zdvr0afYTAISwDz/8UB4+fBj+d8KECU2PKEIgAN2+fbsZZ61FXvWmv2/bts2jbZ49e9aUlsmUKZOkTp1aSpUqFaVap9oF37VrV1P3R9crXLiwfPHFF/LkyZMovQ49yUmUKJFMnDgxSu3U7erE50KFCkmqVKkke/bspt7Q9evXo7Q+ACByL7/8sqRMmdKmjJiWZAEAhKbff/9dZs+ebbPs3XfflVy5cvmtTcEq6ALQVatWScOGDeXNN9806fH1pr83atRIli9fHq1t6lXtsmXLmuyHWuP06tWr8t1338m4ceOkX79+EQaf5cuXN7Xj9uzZI9euXZN58+bJypUrXaZh1gDyhx9+kNKlS5uAt1y5cuZEJ6p0nWXLlpmkGBp07tq1SxIkSCAvvPCCeX4AgOe0jluzZs0chuFqIAoACC362d+rVy+bZdrxFFGcgFgSgGoiiA4dOpir0BpwapIIvenvP//8s3Ts2FHu3Lnj9nbfeecds90+ffpIihQpzCRi7QFdvXq1TJkyRXbu3Ol0vY8++sg8bsyYMZI+fXqz7Omnn5bFixfL3r17TTBq79atW7Jw4UIZOXKkHDhwQLp06SLJkyePUjt1Pe01XbJkiQmWLXOVPv30UxMIDxgwwO3XDgBwrnXr1jZ///XXX+azHQAQWrTzZ8OGDQ7DcdOmTeu3NgWzoApANaDLnz+/VK1a1eG+ChUqmOGvGoi62/v5yy+/SI8ePRzu04NKg9OvvvrK4b779+/LpEmTTBBqT8eD9+3bV8aPH+9wnw7p0kBS0zW7S7enQbIO2bWnxXC1Z/XevXtubxcA4KhSpUqSI0cOm2XTpk1jVwFACHn06JH07t3bZpl+N2iMgBAIQNesWWOG37rSoEED02vp7jY1GNSeT3e2uWXLFsmbN6/kyZPH6Xr16tWTrVu3RqtH1hkNLH/77TepX7++0/v1H0F7RTdt2uSV5wOAUKfTKzS7oTUdgfP48WO/tQkA4Fs//vijGbVobejQoZI4cWLeilAIQPfv32/mTrpSpkwZhwPE021qr6rOCbVP8hPZepogKHfu3GZOqTccOXJEsmbNGmFXf3RePwDANfv5/JqwTkfNAABiv9u3bzuMdixevLi88sorfmtTbPC/StsxQIOh48ePhxdr1eGnmilKM7hGx4kTJyLMNKW9gCdPnnR7m3oguaLzQTXTrG63SJEiUW6LdXuKFSvmVptctTOqzwcA8I5nnnnGzPX/448/bJIR1apVi10MALGcVrb477//bJaNHj3ajJBBgAWgmmBn0aJFpkeuQIECpjdQHTt2zGSI1cytOpTUPptUZDSBj2acckXv08d4c5uutqt/58yZ0+31oiuq7dSAPyI6d1VvFpaLA1rTyLquUaiz7Av2CThmoFe6rQPQ+fPnmyzpUU0gx+cM+G6Cv3A+E30XLlwwMY01vfhYuXLlWH1++NAHr83rAejHH39skvDoHMmIjBgxQgYNGmRuUaWBk27bFU3O8+DBA5MqWXsuvbFNy3btk/tEd73o8tbzDR8+3LxH9nSea9KkST1uZ2yjc4QBjpnQpvWm9Wq3pb6zzu3Xz1FnCfGig88ZcMwgpvE54z4tyXjz5s3wvzW2qFOnTrTLPgaLO17KX+PTAFQP8M2bN0f6OM3mqplr3QlALQGmq0DMEqRFNfi03mZEdLv2E42ju150eev5NDtv9+7dbXpAdYixXtGxLroe6vTqjx7LNWvWNHVWAY6Z0KbFx1esWGGTB0CHYXmCzxlwzCCm8TkTPZrDxT4JqSal0/KJsd3ly5eDLwCNFy9ejDxW6XCna9euuRz2FNF9kW0zIs62G931ostbz6eBrLMyLhpkEWg5Yr/AXRwzsVPbtm1tAtB169bJxYsXJUuWLB5vm2MGHDOIaXzOuGfgwIGm/IqFnjtr5ttQOFdO4IPX6PUZtNmyZZONGzdG+jgtF6KPdYfOuYxojqMm4LGv2ebpNnU476lTpxy2G9l60W1PdNvp7ecDANiW5LIu16XDcbUkCwAgdtm2bZvMnTvXZtn777/POXYgB6Djx4+XTz/9VDp16iQLFy6UgwcPmuxRmrpef9dlnTt3No/56quv3Nq2lkTZuXOny/t37NjhdobdyLapw6zSpEkTnkgpquvp0FYNGPPnzy/ekC9fPjlz5owpCePN1w8AiFySJEmkadOmNss0Gy4AIPbQjqeePXvaLNMSiDqFDX4MQDNlyiTdunVzeb8Ga4sXL5b33nvPBEwTJ0408zy1ho7+rsveffddkyU3sqyu9nQ+nq7nypIlS9xOja/b1KFUrrLVutrmCy+8IEePHjWZfZ1ZtmyZlCtXzmuJfXRuZ/ny5c2+deb06dPyzz//SMWKFb3yfACAiGuC/vnnn+YGAIgd9DzbPpdN//793Y5Z4OU5oJqS2DodvStaM9O6bqY3NGnSRHr37i0bNmwwKZCtadbdffv2SbNmzdzapg4DrlatmowZM8ah0Kz2Nn755ZdOgz4dC96hQwcZMmSITJ482WHCt2ab1fHj3vTOO++YKzAtW7Z0mMf5ySefSLt27byW9AgAYEu/dzRpm07LsO4F9TQZEQDA/3TOp8YZ1nLlyiVvv/2239oUW8UNtiFQGuy1atXK9ITqgaI3/V2HRmkPa3R6HDXInDRpkowaNcr0hGr3u9Yq1Z5PDepKly7tdD1Nw6/DXj/44IPwjFGHDh0yNU41+NaA2ZsaNmwozz33nJmLpM+jLl26ZOqp6pxaDYYBADFDS7FoFkRrOg/08ePH7HIACHIaC+hoQmvDhg1zmrwTIRSAqtq1a8uCBQtkwoQJkjFjRnPT37UweN26dV2uV7RoUZflYfSKtk441jmqefPmNcOIO3bsaIYK64Hnis4L1W1qj2exYsVM97wGiRq4RjQ3aM+ePeaxlpuewOiQZcvfOszZlSlTppgaRPo8+vzFixc3tT9/++03hgcAgI+H4WqOA53GAQAIXtoBZT9ysVSpUtKiRQu/tSk283oZFl8oW7asrFq1yq11IpunkzlzZhPcuUuDwLFjx5pbVGnQGFlJlYiuwGsmLr0BAHxLE72VLFnSjJKx0AuOmk8AABCcPvvsMzl//rzNMp1eoefd8D72KgAAHvSC6gic27dvsw8BIAidO3fOYS6/jqqsWrWq39oU20UrANXyI/qmdO3a1fQaalKi+/fve791AAAEGE0EZ31VXINPnRoCAAg+gwcPtrmIqJ/vI0eO9GubYrtoDcHVYFMz0W7cuDF8Wbx48UzNS50LqfMt9afesmTJ4s32AgDgVzpPX+f6r1y5MnzZtGnTpHXr1n5tFwDAPZp06LvvvrNZpglIn332WXZloAWgBQsWlE6dOsnevXvNTZP3PHjwwPzU2+zZs22Kt1oHpPp7iRIlvPkaAADw+TBc6wB0zZo1cvbsWZNPAAAQHLS8oXUmc624oVUuEIABaPr06aVbt27hf2splL///js8INWbJv3RybxanmT9+vXy66+/msfGiRPHPB4AgGClmciTJ09uMieqJ0+eyMyZM6V79+7+bhoAIAq0goT99AmNb7Jly8b+C4YsuPHjxzdd1XqzrpF24cIFm4BUy4/Y19cBACDYaM1prfX8448/2mTDJQAFgMAXFhYmPXv2dOhg69Wrl9/aFEpitAyL1ujU1PTW6em1ZiYAALFhGK51AKoXWf/66y/mDgFAgNOez61bt9osGzBggCmviFhYhiVBggS+fkoAALyuSpUqkjVrVptl2gsKAAhc2hnWp08fm2V58uSRN998029tCjVuB6ClSpWSxIkTx0xrAAAIEpr93XraiZo+fbpNQgsAQODQpKkdOnSQw4cP2ywfPny4JEyY0G/tCjVuB6A7duyQ1atXx0xrAAAIsmG41s6cOROedA8AEDhu3rwp9erVM2WzrJUpU0aaNWvmt3aFIp8PwQUAILbQ5HvFixe3WcYwXAAILOfOnZPKlSubkln2iVTHjRtnqnTAdwhAAQDwYi/ovHnz5M6dO+xTAAgAhw4dkueff152797tkM188eLFUq5cOb+1LVQRgAIA4IFWrVpJ3Lj/+zrV2qALFy5knwKAn23fvl1eeOEFOX78uM3yDBkymOkSderU8VvbQhkBKAAAHsicObNNuTHFMFwA8K+lS5dK1apV5fLlyw4Zb7ds2WLmfsI/CEABAPDyMFxN1qdzjgAAvjdx4kRp0KCB3L1712Z56dKlTfCZL18+3hY/IgAFAMBDDRs2lGTJkoX//eTJE5k5cyb7FQB8KCwsTD7++GPp1KmT+Ry2Vrt2bVm/fr089dRTvCd+RgAKAICHNPhs0qSJzTKG4QKA7zx69EjeeOMNGTRokMN9r732mixZskSSJ0/OWxIACEABAIiBYbiacXH//v3sWwCIYZp5vHHjxvL999873NevXz+ZMmWKJEiQgPchQBCAAgDgBZrsIkuWLDbL6AUFgJh16dIlqVatmunhtKa1Pb/66isZOnQodT4DDAEoAABeEC9ePHnllVdslk2fPt1hHhIAwDuOHTsm5cuXN+VWrCVKlMjUZH777bfZ1QGIABQAgBgahnv69GnZsGED+xcAvEynOWiNz0OHDtksT5Mmjaxdu1YaNWrEPg9QBKAAAHhJ0aJFzc0aw3ABwLvWrFkjlSpVcih3lT17dtm8ebNUqFCBXR7ACEABAIjBXtC5c+eaBBkAAM9NmzZN6tatK7du3bJZXqRIEdm6dasUKlSI3RzgCEABAPAinQcaN+7/vl5v3rwpixcvZh8DgIc1PkeNGmUu8mnJFWtVqlSRTZs2SdasWdnHQYAAFAAAL9JMuNWrV7dZxjBcAIi+x48fS9euXaV3794O97Vo0UJWrlwpqVKlYhcHCQJQAABieBjuqlWr5Pz58+xnAHDTvXv3pGXLljJu3DiH+7p16yYzZswwWW8RPAhAAQDwMs2+mDRpUpur97NmzWI/A4Abrl27Ji+++KKZS2/v008/lTFjxthMeUBw4B0DAMDLkidPLo0bN7ZZxjBcAIg6LWOl2WztS1klSJDA9Hr26NGD3RmkCEABAPDBMNw//vhDDh48yL4GgEj89ddf8vzzz8v+/fttlqdIkUJWrFghrVq1Yh8GMQJQAABigCYiypw5s80yekEBIGIbN26UihUrmh5Qa5kyZTL32Sd5Q/AhAAUAIAbEixfPlGSxNn36dHny5An7GwCc0LmetWrVMnM/rRUsWNDU+CxevDj7LRYgAAUAwEfDcE+ePGmu4AMAbH355ZfSvHlzuX//vs1yHYr722+/Sa5cudhlsQQBKAAAMaRYsWJSpEgRm2UMwwWA/wkLC5M+ffrIe++9Z363Vr9+fVm7dq2kS5eOXRaLEIACAODDXlAdYnb37l32OYCQ9+DBA3nttddk5MiRDvvijTfekHnz5tmUtELsQAAKAEAM0nmgceLECf/7xo0bsnjxYvY5gJB28+ZNefnll52OChkyZIh8/fXXEj9+fL+0DTGLABQAgBiUNWtWqVatms0yhuECCGXnzp2TKlWqyOrVqx2St02aNEn69+9vc+EOsQsBKAAAPh6Gu3LlSrlw4QL7HUDIOXTokLzwwguya9cum+U61FZHh3To0MFvbYNvEIACABDDGjduLEmSJAn/+/Hjx/Lzzz+z3wGElO3bt0v58uXl2LFjNsvTp08v69evl7p16/qtbfAdAlAAAGJYihQppFGjRg41QQEgVCxdulSqVq0qly5dslmeJ08eU+Pzueee81vb4FsEoAAA+GEY7s6dO+XMmTPsewCx3sSJE6Vhw4YOGcBLlSolW7ZskXz58vmtbfA9AlAAAHygRo0a8tRTT9ks+/XXX9n3AGItres5ePBg6dSpk5l6YK127drmM9D+cxGxHwEoAAA+oOUEtCSLNT35evLkCfsfQKzz6NEjU8tz4MCBDve1bdtWlixZIsmTJ/dL2+BfBKAAAPhpGO7Fixflt99+Y/8DiFXu3Lljkq99//33Dvf169dPfvjhB0mQIIFf2gb/IwAFAMBHihcvLoULF7ZZRjIiALGJJhmqXr266eG0pnU9x48fL0OHDqXGZ4gjAAUAwEf0BMy+F3Tq1KnStGlTmT9/vty7d4/3AkDQ0vIqWmZl27ZtNssTJUokc+fOlS5duvitbQgcBKAAAPjQq6++anP1X+dJzZs3T5o0aWKScWgR9rVr1zok7ACAQLZ792554YUX5NChQzbLU6dObT7TdEguoAhAAQDwoWzZskm9evWc3nfjxg2ZMmWK1KxZ0zyua9eu8vvvv5tMkgAQqDTArFy5spw7d85mefbs2c089woVKvitbQg8BKAAAPjYd999J82aNTOZcV3RE7mxY8dK2bJlpUCBAiaT5N9//+3TdgJAZHQee506deTmzZs2y4sUKSJbt26VQoUKsRNhgwAUAAAfy5Qpkzlp097Or7/+WqpUqRJhUo4jR46YWnrPPPOMKdz+2WefyenTp33aZgCwpiMzRo8eLa1btzZTCazpZ9rGjRsla9as7DQ4IAAFAMBPUqRIIa+//rqsX79eTp48KZ9++qmUKFEiwnV27dolH3zwgeTIkUOqVq1qyhxcuXLFZ20GAK1f3K1bN+nVq5fDzmjevLmsXLnSzP0EnCEABQAgAOiczx49epgA88CBAzJgwADJmzdvhL0Pv/76q3Tu3Nn0qDZo0EBmz55t6u8BQEzRbN0tW7Y0UwTs6bz1mTNnmqy3gCsEoAAABBgdaqtDbg8fPizbt2+X999/32TIdeXhw4eyePFic1Koj9NSLytWrDDLAcBbrl27Ji+++KL8/PPPDvfpcNwxY8ZI3LiEF4gYRwgAAAFK54U+99xz8sUXX8iZM2dkzZo10r59e0mZMqXLdW7duiXTpk2TunXrmvlX77zzjmzZsoVMugA8ovPOK1asKBs2bLBZniBBAjOnXacGRDSXHbAgAAUAIAjEixdPatSoIZMnT5bz58+H1w6NaKjbxYsX5auvvjKF4fPkySP9+vWTv/76y6ftBhD89u/fL88//7zD54fOY9fRFq+88orf2obgQwAKAECQSZw4sSnqPnfuXBOMWmqHRjT07fjx4zJ8+HBTGqFo0aIyYsQIOXHihE/bDSD4bNq0ydTxtM+8rXPPNdNt9erV/dY2BCcCUAAAgliqVKmkXbt2snr1ajNMVxOD6LDdiOzbt0/69u0ruXLlMieWEyZMML2lCFyPHz+Wf//9Vy5cuODvpiCE6EgLvbilcz+tFSxY0NT4LF68uN/ahuBFAAoAQCyhPRLvvfeeSVykCYw0kZGeKEbkt99+ky5dukjmzJnNvFGdy6XzSOE/WlZHMxyPGzdOOnbsaC4o6FBHTU6lWY87dOggDx484C1CjBo/frw0a9ZM7t+/b7Nch+Lq54ZewAKiI3601gIAAAEtX758ppRL//79Zc+ePTJjxgxTHkF7SV31sOlcLr0lSZLElHXReV21a9eWhAkT+rz9oUCzFP/zzz/y559/2txcvUcWmmTqxo0bMmfOHMpdwOu0xJPOF9dh+vbq169vPkeSJk3Knke0EYACABCLaVbKEiVKmNvIkSPNfC4NRrWMwtWrV52uc/fuXZk1a5a5pUmTxvSCaDCqGTApsRC9E3qdq2sfaB48eDDaPZladqdRo0Yyf/58MycY8NZFkddff11++uknh/u0912TmsWPT/gAz3AEAQAQIjR4rFy5srl9+eWXsmrVKhOMLlq0yASdzmiQ+t1335lbtmzZTK1RDUZ17hclFxzdu3dPDhw44BBsxsQcW+2t1h6phQsX0iMFj928eVOaNm1q5pPb0+H8OpqC/3l4AwEoAAAhSIfVvvzyy+amcz41CNX5n3ryqcNxndEsmJ9++qm5Pf300yYQbdWqlRnuG4q9mqdOnXIINA8dOuRy/7n7/hQqVMhkLLbcNLht0aKFzcUCrQ370ksvyZIlSyR58uQePy9C07lz58xxtGvXLofyT99++63pFQW8hQAUAIAQp4HLq6++am7aU6fDc7VnVBONuPL333/LRx99ZG6aJEfXbd68uUmEFNtogK71D+2DzevXr3tl+9qzbB1o6q1AgQKSIEECh+GRgwYNkmHDhtk8tyYsqlOnjixfvtwkKwLcoQnLdK73sWPHbJbrPE+dZ6yBKeBNBKAAACBchgwZ5O233zY3rR2q80A1GNXSLa78/vvv5tatWzdTE1B7RnV+opaICSZPnjyRo0ePOgSaWv7EG/SE/tlnn7UJNLUua9q0aaO8Dc1qvHLlSpOx2HoO7+bNm6VWrVrmvmDb7/Af/b/VAPPSpUs2y9OnTy/Lli2LtKQTEB0EoAAAwCkts9CnTx9z0wBUs19qMHrixAmXAZwOCdXbm2++KfXq1TPBqAZLgZYoR4M3fU3Wgab+fefOHa9sP2/evDZBpv7MkyePGdLoqVKlSsm6deukRo0acvny5fDl27ZtM8t0GLUmjwIiogGmjlqwP+Zz585t5ofnz5+fHYgYQQAKAAAipUGU3oYOHWoK0GsgOnv2bIeeEwutHahF7PWWMmVKadKkiQlGq1at6pUgLKoePXpk5mXa92rq/E1v0N5G++GzhQsXjvGhsJoESofeao/zhQsXwpfv3LlTqlWrZi4CaC8W4MykSZPkjTfecJivXLJkSTOU+6mnnmLHIcYQgAIAgCjTLJgvvPCCuX3++efyyy+/mORFCxYskNu3bztdR2tWTpkyxdx0jqgm0tE5o6VLl/ZqVk0NxOwDTc1Iq8GwNzII6/BX+2Aze/bsfssMqsN5NQjVgFOTyFho3VddtnbtWsmYMaNf2obATZ41ZMgQGThwoMN9Og9U538zjxgxjQAUAABEiybJefHFF81Nh/FpJlbtGdXyIJowxxkNlMaOHWtumj3XkklXs+pGlQaUWkPTPtjUWpveoD2HxYoVswk0n3nmGUmSJIkEGm3Xhg0bTMB55syZ8OU6nLhKlSrmAkHmzJn92kYEBh0N0KVLF1NSyV7btm1l4sSJDomvgJhAAAoAALySYEd7NvV25coVM/RWg1ENjrTXxZkjR46Y+oJ606F/Gozq+poVVul6WvrFfq6mZuD1RqkTPdm2L3WiNx1+GEz1DjVjriUIPXnyZPhyDdI1CNX5olmzZvVrG+FfeoGoTZs25iKRvb59+5qh9cF0zCO4EYACAACv0qyunTp1MjcNIHWuqAaj9jUGrel9euvZs6dUrFjRnAxrsGmd6dUTGoDZB5o6pDa29Pho0iMNQnWOrWYvttD5r5UrVzZBaI4cOfzaRviHDoHX4bXbt2+3Wa7/Y+PGjZN33nmHtwY+RQAKAABijPZm9ujRw9y051Iz6eqcUVelTbTXc+PGjdF+Ph0m66zUSbp06SQUshbrvtMg1Hr/6u8ahK5fv948BqFDL0ZoD6f18GyVKFEic1GocePGfmsbQhcBKAAA8Amd5/nxxx/LoEGDTLZWDUS1zmh0525quQj7Xk3tCfRllt1Ao0mRtCdUs+P+888/NoFIpUqVTBCq+wixn44o0Bqf1gmqVOrUqWXx4sVmpAHgDwSgAADAp3ToX5kyZczts88+M0GR9sbovFEdLmhPs3LaB5ray6nlXeB8uLGlRItmAbbQ0jMahOpwXB1+jNhr8uTJ8vbbbztkgNYRCStXrjSlggB/IQAFAAB+o72VNWrUMLcJEybIsmXLTO+oJjWyZKLNmTMnCVLcpOVuNAjV/apzaS3++++/8Oy4moAJscvdu3fNnE4NQO3pRRvNUG1J8gX4CwEoAAAICIkTJ5YmTZqYGzyXIUMG09tZs2ZN2b17d/hyHZJpCUJ1fixih6NHj5r/Ha0Da097vhctWmSG3wL+FtffDQAAAEDM0ORLGmjqcGdrFy9eNMmKrANTBC8tr1KqVCmnwWe9evVk+fLlBJ8IGASgAAAAsViaNGlkzZo18vzzz9ssv3z5sqkdumPHDr+1DZ559OiR9OvXT+rXry/Xrl2zuS9ZsmQybdo06dixoyRMmJBdjYBBAAoAABDLpUqVSlatWuWQ+VSDFp0nunXrVr+1DdFz4cIFU99z+PDhDvc988wz5sJC8+bN2b0IOASgAAAAIUCzCWsSGh16a00zD9eqVUs2b97st7bBPVu2bJESJUqYOb72WrRoIb///rsJQoFAFJQB6Pbt280VH53XoDf9fdu2bR5t8+zZs9K+fXuTNU4naOs4+qlTp0a6nn5od+3a1WQU0/U0rfUXX3whT548iXA9TYutddC0FpdeldSfAwcOdEiXbU0frwka9Hmc3fbt2xet1w4AAEKDDstcunSpCTit3bp1y5xPaeZcBK6wsDAZO3asVK5c2WQ0thY/fnwZN26czJw5U5InT+63NgKxLgDV4SMNGzaUN9980xSu1pv+3qhRIzPBOjpOnz4tZcuWNTWxDh8+LFevXpXvvvvO/BPruPqIgs/y5ctL3LhxzaRvHcaiNcy0vlKbNm1crvfw4UNTGFifSz/or1+/bmqgafayF198UR48eOBy3Q8++MA8j7MbmewAAEBktMSNZkStW7euzfI7d+6YZTpfFIHn5s2b0rJlS9PxoXM/7Wu/bty4Ud59911KFiHgxQ222kYdOnQwxao14NQrPXrT33/++WczyVo/PN2l9ZJ0u3369DHDU7RAtvaArl69WqZMmWLqkTnz0UcfmceNGTNG0qdPb5Y9/fTTsnjxYtm7d68JRp356quv5PHjx2ZiePbs2c2yHDlyyE8//SQJEiSQL7/80u3XAAAAEFU6omr+/PnSoEEDh3Otl19+2QzVReA4cOCAPPfcczJnzhyH+6pXry67du1ySDIFBKqgCkA1oMufP7/D3AVVoUIFM/xVA1F3ez81PXmPHj0c7kubNq0JTjVgtKdDZSdNmmSCUHuaaaxv374yfvx4p8+py3W4rQa69nS5q/UAAAC8JVGiROa8qWnTpg7nODraTC+ow/90SK0Gn3///bfDfR9++KEZHZgxY0a/tA2I9QGoDgnRD0RX9Cqe9lq6u029cqQ9n+5sUyd/67zNPHnyOF1Pay5pRjn7Htljx47JlStXzNh9Z3RIr87D0OG5AAAAMUlHXmmA06pVK5vlOh2oSZMmppcU/qHvgQ6pfeWVV+T27ds292nuD639+cknn0i8ePF4ixBUgioA3b9/v5QuXdrl/VpkWYcoeHOb2quqc0J1nqY762liody5czsEkrpeyZIlIxyfr9t193UAAABEh05n0mlA9vkrdJ6hlvGYPXs2O9bHTp06ZTornI2K0+y3f/zxh+nsAIJRUAWgJ06ckFy5crm8X+dRnjx50qvb1EBR52nabzey9Vy1J7rrWeiVyAIFCkjKlCklQ4YMZuixJkuKKHERAABARLQXTfNevP766zbLNWeF9sBp3gr4xtq1a01nhbMKD5rvREfhuRqBBwSD+BJEdGiqDjlwRe/Tx3hzm662q3/nzJkzWutF5/mUju/X2k46JEZ7ZnU4xm+//SZDhw41iZn0AyuytNs6r8O61Itm8rVk5tUb/o9lX7BPEFUcM3AXxwwC8ZjRvBcajGo1AAstLde2bVtz/qA/ETN0P48cOdKU3dNyK/ZJozRJ5WuvvebWMcDnDNzli3PfoApA9YNPE/xENJleewL1nzaiIa7ubNOy3Xv37vl1PfX222/b/K3BptbsqlmzpkkgoCVavvnmmwi3PXz4cPn4448dlus8V03LDlukooe7OGbAMYNg/5ypU6eOnDlzRpYtWxa+TM+ttPdNh37quQe8X2JF63s6q7zw1FNPSe/evc3It+iWHOS7CVEVnYoisToAtQSYrgI4S3AX1eDTepsR0e3qlSdvrWfpdYxovch6Sa1pHVKdI6AZgj///HNJkiSJy8dqdt7u3buH/61t0SHGWpBah/Xif1d/9MNag3tN0ABEhmMG7uKYQSAfM1oPVIOeL774wmb5119/bUrOvfXWWzH6/KFES6hobc/jx4873KfzPCdPnuzWeaE1PmfgrsuXL0tMC6oAVHv8rl275nKYaUT3RbbNiDjbrifrRZbhVtfLli2buCNLlixmPoAmL9LapK5oAKw3e/pFRqDliP0Cd3HMgGMGseVzRuuc64X0ESNG2Cx///33zdzQbt26xXgbYjPtVdaSflryz3p6lKVzYdiwYdKzZ0/zu6f4bkJU+eKzJaiSEOmcS2dXhyw0cY8m8PHmNvXDQTOR2W83svVctSe660WFlpKxT9MNAAAQHTqiTIMgZzXPdTTVqFGj2LEeDHPs0KGDdOrUySH41JwfmtdDe6C9EXwCgSaojmpNvONsbLzFjh07pFChQl7dppZNSZMmjSmr4s56OrRVA00dFmu/ng61sJ9cbk3nV7j7OtTp06cpRAwAALwahGruiCFDhjjcpwGS1qGEe44cOSIvvPCC/PDDDw736XI9T6xatSq7FbFWUAWgOudh0aJFLu/Xgrw6l9Hdba5bt85l9lxX29QPiKNHj8qxY8ecrqcT98uVK+eQ2Edrg6ZNm1Y2btzodL2tW7dKsmTJHALXyOzevdtcTdMSLQAAAN7Uv39/k6HV3oABA0wPaUQX1vE/eh6r9d737t3rsFt0SPOvv/4qWbNmZZchVguqAFTLjxw6dEg2bNjgcJ/WRNq3b580a9bMrW3qXMtq1aqZeQ72rl69alJed+nSxeE+nUepQyecXRHUCd+abVbH9DujywcPHuz0Pl3uaj1X7t69azLk6noM1QAAADGhV69eJtmhPT0X6tevH0FoBB49eiR9+vSRhg0byvXr1x3yg8yZM8eci5KPA6EgqAJQze6qmcBatWplriDpP7Pe9HctQzJx4sRolRLRIFMngetcBu0J1at4OvxBez7btWtnrlQ5o0NSdNivlj+xZIzSALl+/fpSpEgREzA7owGtDmlp06aNSXNuGT6rtZ00mHz33Xcd1jl//rz54NfhuZZ5nlqqRXtan3/+eTP/Uz/8AQAAYopma9XM+/Y0UZGeD9ETKk7P4XTEnbMeZJ1ypeeS7nagAMEsqAJQpbWnFixYIBMmTDDzHfWmv8+fP9+kDHelaNGisnnzZqf3aRmSbdu2ycGDByVv3rxmzqfWutJAUCffu6LzQnWb2uNZrFgxkyJbr2xp4PrTTz+5XE+vbmngqM9VsWJFs53KlSubBEWrVq1yWmZGh+VqYWjNPJcvXz7zXJkzZzYf+Nr7uWLFikjriwIAAHhKL6R/9913DmXvtAfvvffeIwi1oueJJUqUMENr7WmHyvbt201ZGyCUxAnjUlVI02RJGgDrcBDqgP6PXlTQYs96UYPhMIgKjhm4i2MGwX7MaBIdnY5kfyr5xhtvmM6BUJ4WpPtEa6hqGRUtWWNN3zsdyqwdCO7Uro8NxwwCn47qTJ8+fYzGBkFVBxQAAACBQacpaVDTtm1befLkSfjyb7/9Vh48eCDff/+9Gb0Vihf3X3/9dZk7d67T3CO6vGzZsn5pGxAIQvfSFAAAADzy6quvysyZMx0CzSlTpkj79u0dev9iu7/++kvKlCnjNPjUeaCaY4TgE6GOABQAAADR1rx5c/n5558dhnhqPozWrVubhJGhYPr06Sa41ISUzsrVaL6ODBky+KVtQCAhAAUAAIBHGjVqJPPmzXNIiDhr1ixp2bKlmYsYW92/f98kZtJgW2uyW9PElpp4UsvsheJwZMAZAlAAAAB47OWXXzal8bRWujUNTLXMiAZqsc3JkyelUqVKJumSvVKlSpkhtxFVaQBCEQEoAAAAvOLFF1+UpUuXmtrt1jQwbdy4salhHlusXr1aSpYsKb///rvDfZ07dzYlWHLlyuWXtgGBjAAUAAAAXlOjRg0z31FrmFvTciD169d3GKYabDTjrw6p1WBbS1ZYS5w4sSlPo5mA9XcAjghAAQAA4FWVK1eWVatWSYoUKWyWr1mzRurVqye3b98Oyj2uAae2f+DAgQ71T/PmzSvbtm2T1157zW/tA4IBASgAAAC8rnz58maYqn0x+/Xr10udOnXk5s2bQbXXd+zYYYbcau+uvYYNG8rOnTulWLFifmkbEEwIQAEAABAjypUrJ7/88oukTp3aZvmmTZukdu3acv369YDf89rTqUNqK1SoYJIOWYsbN66MGjVK5s+f7/AaAThHAAoAAIAYU7p0aVm3bp2kS5fOZvnWrVulZs2acvXq1YDd+zpftV27dvLmm2/KgwcPbO576qmnTHDds2dPiRMnjt/aCAQbAlAAAADEqBIlSpihtxkyZHAY1lq9enWHZD6B4PDhw6YHd+rUqQ73aW/o7t27pUqVKn5pGxDMCEABAAAQ44oUKSK//vqrZMqUyWa5BnJVq1aVCxcuBMy7sGDBAtNzu2/fPof7evToYXp0M2fO7Je2AcGOABQAAAA+UahQIdmwYYNkzZrVZrkGehqEnjt3zq/vxKNHj6RXr16mZumNGzds7tOMvnPnzpVPP/1UEiRI4Lc2AsGOABQAAAA+U6BAAROE5siRw2b5gQMHTPmWM2fO+OXdOHv2rBkOPHr0aIf7nn32WZPltkmTJn5pGxCbEIACAADAp7RmpgahuXLlsll+6NAhE4TaZ5uNaRs3bjQlVvSnvdatW5v6nho4A/AcASgAAAB8ToNPDfg0GLX277//miD0+PHjPimxokNqq1Wr5jD8V4fZTpgwwSQhSpYsWYy3BQgVBKAAAADwi+zZs5ue0IIFC9os1+BTg1ANRmOK1iBt2rSpKaPy+PFjm/t0ePDmzZvlrbfeosQK4GUEoAAAAPAbTUik2XE1QZE1HYarQagOy/U2TXpUpkwZmT9/vsN9tWrVkj/++EOee+45rz8vAAJQAAAA+JmWZtEgtGjRojbLNSGRBqEHDx702nP99NNPUrZsWVPn01qcOHFk4MCBsnz5ckmfPr3Xng+ALXpAAQAA4HcZMmQw9TVLlChhs1znZmoQ6qwmpzvu379vhtS2bdtW7t69a3Nf2rRpTeA5aNAgiRcvnkfPAyBiBKAAAAAICOnSpZNffvnFDI+1dvHiRVMndM+ePdHa7okTJ6RChQryzTffONxXunRp2bVrl7z44ovRbjeAqCMABQAAQMBIkyaNrFmzRp5//nmb5ZcvXzbZarUepztWrlxpSqw4W097RDXZUM6cOT1uN4CoIQAFAABAQEmVKpWsWrVKKlasaLP86tWrUr16dVOXMzKa2VaH1NatW1euXLlic1+SJElMeRUts5IoUSKvtx+AawSgAAAACDgpUqSQFStWmKG31m7cuGEy1WrPpSuXLl0ygefHH39san1ay58/v2zfvl3atGkTY20H4BoBKAAAAAJSsmTJZOnSpSbgtHbz5k0zZ1Mz59r7/fffzZDb1atXO9zXuHFj2bFjhxQpUiRG2w3ANQJQAAAABKykSZPKokWLTI+mtdu3b5tla9euNX9rT6cOqdVkQ6dOnbJ5rGa2/fTTT2Xu3LlmeC8A/yEABQAAQEBLnDixzJ8/Xxo0aGCzXMup1KtXT+bNm2fKq3Tp0kUePnzoUGNUy7v06NHD1PoE4F/x/fz8AAAAQKQ0WdCcOXPklVdeMQGndX3Ppk2bOl2nUqVKMnv2bBOEAggM9IACAAAgKCRMmFBmzZolLVu2jPSxPXv2NDVFCT6BwEIPKAAAAIJG/Pjx5aeffpIECRKYn/ZSpkwpP/zwgzRq1Mgv7QMQMQJQAAAABF0QOmXKFBOETp48OXy5ZrfV4blaagVAYCIABQAAQNDRzLbff/+9PPvss7J48WIpX7689OvXz2TNBRC4CEABAAAQlOLGjSvdunUzNwDBgSREAAAAAACfIAAFAAAAAPgEASgAAAAAwCcIQAEAAAAAPkEACgAAAADwCQJQAAAAAIBPEIACAAAAAHyCABQAAAAA4BMEoAAAAAAAnyAABQAAAAD4BAEoAAAAAMAnCEABAAAAAD5BAAoAAAAA8AkCUAAAAACATxCAAgAAAAB8ggAUAAAAAOATBKAAAAAAAJ+I75unQaAKCwszP2/cuOHvpgSUhw8fyp07d8x+SZAggb+bgyDAMQOOGfA5g0DDdxPcdfPmTZsYISYQgIY4y0GWPXt2fzcFAAAAQAC4fPmypEqVKka2HScsJsNbBLwnT57If//9JylSpJA4ceL4uzkBQ3s+NSg/deqUpEyZ0t/NQRDgmAHHDPicQaDhuwnuun79uuTIkUOuXr0qqVOnlphAD2iIixs3rmTLls3fzQhYGnwSgIJjBnzOIJDw3QSOGfgiRoixbcfYlgEAAAAAsEIACgAAAADwCQJQwIlEiRLJwIEDzU8gKjhm4C6OGXDMIKbxOYNAPGZIQgQAAAAA8Al6QAEAAAAAPkEACgAAAADwCQJQAAAAAIBPEIACAAAAAHyCABT4/8LCwmT+/PnSoEEDyZw5syn0nSdPHnn77bfl1KlT7CdE6sCBA5IqVSqJEyeOHD9+nD0Gl2bNmiXVqlWT9OnTS9q0aeXZZ5+V7t27y3///cdeg4PJkydL2bJlzfdSihQp5JlnnpGPPvpI7ty5w94KYTdu3JAvv/xSnn76acmWLVuU1vnnn3+kadOmkiFDBvPZU7FiRVm+fHmMtxXBecysXbtWXnnlFfNY/ezRn23btjXnO54gAAVE5OTJk1K6dGnzT6n/WIcPH5br16/L5s2bJV26dFKiRAnZt28f+woRevfdd00QAbjy+PFj82U+fvx46devn/nsuXTpkixatMicDHLhAs4+V7766isZPXq0XLhwQa5du2Yulv79999StWpVefjwITstxOg5il4cz5s3r+zcuVM++eSTKK23d+9eqVSpktSpU0dOnz5tPnuGDBlijrHvvvsuxtuN4Dlmrl27JjVq1JCePXtK7dq15c8//5SbN2/K7t27pWTJklKhQgX55Zdfot0eyrAAIrJlyxY5ceKEtGrVyun+GDBggGzbtk3WrFnD/oJTs2fPlr59+5qrgkmSJJFjx45Jrly52FuwMWjQIPPlrwFEwoQJ2TuI0F9//WUCBg02M2bMaHPfkydPTO9Vx44dpX379uzJEPLZZ5/JgwcPpFOnTmYUhV640oBAg8qIRnmVKlVK3nvvPWnXrp3NfUeOHDE97BpkZM2a1QevAIF+zPz777+ybNkyeeeddyRuXMf+ykmTJsmIESNMYBsdBKBAFOhVQv1Q1l7RxIkTs89g49atW2Y4i/ZS6BBuHYJLAAp7V69elfz585vRFDrMH4jMuHHjZNWqVeZE0JlRo0aZE8Vvv/2WnRnCohKA6oiuNm3amOPFWUChgYkOrxw4cGAMtxbBcsxENppHA9kdO3ZIvnz53F6fIbhAFOg/WZo0aeTixYvsLzjQIUw6h0+DT8AV7fVs0qQJwSei7P79+6bnyhXtBU2aNCl7FJHSEVz6HeUs+FR63+rVq9mTiJJ48eJJwYIF5ezZsxIdBKBAFOnQheTJk7O/YEOHxk2YMMH0VAAR0WH85cuXZychygoVKmSmiJw7d85pD8TChQulZs2a7FFEav/+/SbXhStlypTxOLEMQu8CWfJonhcTgAJR8Mcff5ihKdoLCljT5A1dunSRAgUKsGMQ6cUKnResIynef/99k8nUkuRML2BoQAFY02QxeszoT81GqUlA9KRPE4E0btzYHDt169ZlpyFSmuciorwEOsf43r175hgDIqMXxTRre5EiRSQ6CECBSNy9e1c6d+4sffr0YV/Bxs8//ywHDx40SaqAqMwB1ZEUWn6lcOHCpkdUg9EpU6bI4sWLpVmzZmZIJRB+khY3rqxYsUIyZcpkejq1zFOyZMlMFkqde66ZcYGo0OMlderULu/X3AVa5kcfB0REv6c0+ZleSI0fP75EBwEoEMk/WevWrSVnzpymdAJgcfv2benRo4d8+umn5oQQiMrFLC29Mnz4cHNRS4MJDTCKFy9uggwtyaKJrABrepFCa1Jv2LDB9H7qTUfl6NC3ypUrEzAgSvS4iSzzdqJEiUwvKBARLTenn0taoiW6CECBCGjNJD0p/PHHH9lPsKE1tPSksGXLluwZRIlm0NZhtvXq1XO4L0GCBCY41VrEgMWpU6dML4OWUNByLHqcaPIP7QHV+Z9PPfWUuQgGREaDSx2BEVmQSqZ/REQvoOqIHf380c+j6CIABVzQIbeatnzlypWSIkUK9hPC/fPPP2bO3vjx49kriDLt8dS0967ofVpTTcs9AWrkyJGmxqezoECHTH744YcyY8YMdhYipT3m165di/AxN27cINkiXPr666/NeY9mVPa0lBgBKODE0KFDZe7cueafTJOEAPbDT7RmmpZeAaIqb968kjZtWpf3W+7T4d2A2r59u0k05Irep8llgMjoVCKt/ejK+fPnzYUOLrjDmZ9++kkGDRpkzov1u8xTBKCAHZ2DpUW9f/nlF+r1wakjR47I5MmTTUIHZzdVtGhR87teMQRUqVKlIuyB0CRFOic0oiAVoUUzkmpPpyt6nw7JBSKjic927tzp8v4dO3aYsj+AvUWLFkm3bt1MrgJvHSMEoICVadOmmd5PTXevVwsBV0NwdaiSBhPOburPP/80v7/11lvsRBg691NrOrqi92lCIuZgwULLZmjJFVf0Pi0GD0RGsygvWbJEwsLCnN6v99WqVYsdCRvr1q2T119/3cz71Lnn3kIACvx/+s+lWU1XrVpFTUcAXpcvXz7JkiWL+Yyxp8mJRowYwQUL2NBan5qASJPD2NNAQi+YNm/enL2GSJUvX97MQ9ehlPaOHj0q8+bNM6U1AIvff/9dWrRoIbNnz5YXXnhBvIkAFBAxyYb0g1evAEa3qC4ARGbChAlmDvHUqVPDyx38/fffUr9+fVMIXq80AxaagEiHZGvPlJ4MWnqv9u/fL02aNDGlEHRoHBAZHa6tNYd79eplppDoRQ0tNaflfWrXri3Dhg2TrFmzsiNhHDp0yHwv6bFSvXp18TYCUEDEDLnV4ZL6Je9qXp/evDn8AEDo0cyBOqRJL3ppj6h+rjRo0MCU2NDEZxHN90Po0TIHmom9bt26pnZsmjRpzDHTrFkzM898/fr1DNkOUVoCzHJuosfCf//9Z3O+8sUXXzisU6xYMRNwLlu2zASbmmRRMynrY/X4QuzW0o1jRqeEXLp0Sdq0aRPheXH69Omj1ZY4Ya4GgwMAAAAA4EX0gAIAAAAAfIIAFAAAAADgEwSgAAAAAACfIAAFAAAAAPgEASgAAAAAwCcIQAEAAAAAPkEACgAAAADwCQJQAAAAAIBPEIACAAAAAHyCABQAAAAA4BMEoAAQi8SJE8fcAtnx48dNG3PlyuXvpoSUQNzv3377rRQrVkwSJ04ccG0LdPfu3ZOcOXNKoUKF5MmTJxIbdejQQeLHjy9///23v5sCwIsIQAEAiAV++OEHGTRokAk0g8H3338vb775pvz1119SoEABKV++vJQpUybS9W7evCnTpk2T1q1bm/WSJEkiSZMmlcKFC0vPnj3l7NmzEa6vwdq4ceOkRIkSkixZMkmbNq3UqFFDVqxY4fTxjx8/llWrVsm7774rJUuWlBQpUkiiRIlM8Ne2bVvZtWuXW6+7f//+4ReKPvnkE4muL7/8Uk6ePGm2Fzeu7encgQMHZPz48aZ9Tz/9tLlfn0/3myfOnTsnU6dOlXfeeUeee+45sx90ux07doxwvUOHDsnw4cOlVq1akilTJkmQIIHZ71WrVpUpU6a4DKD79etnfvbt29ejdgMIMGEAgFhDP9YD/aP92LFjpo05c+b0d1NilcqVK5v9un79+qDY7yVKlDDtmTt3rlvrtW7dOvw4T5EiRVjx4sXD8ufPHxYvXjyzLF26dGG///6703UfPXoU9tJLL5nHxY0bN6xo0aJhuXPnDt/e6NGjHdaZOHFi+P3x48cPK1SoUFixYsXCkiRJEr7s22+/jVLbDxw4EJYwYcLw7Q0ZMiQsOq5fvx6WJk2asDx58pjXZK9Bgwbhz2F9++mnn8I88fnnnzvd7uuvv+5yHW2f9WOzZcsWVrp06bCMGTOGL6tVq1bY3bt3na7fsmVL85itW7d61HYAgYMeUAAA4HOWYZV169Z1e92GDRvK2rVr5cqVK7J7927Tw/bPP/+YXrnLly9LkyZN5O7duw7rjR49WpYtWyZPPfWU6bncu3evHD16VKZPn256CXv16iU7duywWUev62jP508//STXrl2T/fv3y549e0xvYLt27eTRo0fy9ttvy59//hlhm3U7b7zxhun9q1atmnhC23v16lVp06aNxIsXz+H+rFmzmn0wYsQIWbdunZQrV068IWXKlFKzZk358MMPZdGiRaZXODL6ulOnTm16av/99185deqU2cfnz5+X2bNnmx7s1atXm/udee2118zPr776yiuvAUAA8HcEDADwHnpAQ1ew9YBG91i9fPmyy/tOnjwZ3sM4f/58m/vu379veg31vhkzZjis26lTJ3Nf/fr1bZZfuXIl7MmTJ06f7+HDh2HPPvusWe+9996LsN3ff/+9edzIkSPDXnvtNY96QC29x3///bdbx4anPaD2Bg4cGGkPqO473YeujBgxwmxD35vHjx873cfp06c3Pc5Xr171WtsB+A89oADgI9pTovPedN5TunTpTOKVPHnymJ4K7U2wpr0rOserdu3aJjGLPjZNmjRSuXJl0xMTHXrOP2vWLNODoc+v87f0+d977z3zfPZ+/fVXM7+rSpUqZo7W2LFj5dlnnzVt0R6k119/XS5evOjy+TZs2GDm1mmvSapUqczrXrNmTYRt3LZtm+mFKl26tGTMmNG0MXv27KanR3uenNF5j9pO/ant0flpus+0p0l7qNxNzjNx4kQzP1DnFWpPku4fnXdomQ/42WefmfmG2nOTLVs26dOnjzx48MDl9rXH7cUXX5T06dOb15M7d27TY6Y9Qc5oO7Q92i7dH3Xq1DHvvc5XrFixounRcvY+6f5Wup8tcwz1pnNDndH5gLqf9XXqfLxmzZqZ3sDo0F5Hfd8KFixo9ou2V48b7an7v1jT8fVZRKWt1rStruixonMelfaKWlu/fr3pNdTjsWnTpg7r6vGsdL6n5f1W+lpcJfbSBDmW3kz757Omx2Xv3r1NwqBu3bqJJ/R5tNc3b968Zn8HOt13ug9d0XmhSt8bZ58nuo/1c1B7tBcvXhyjbQXgGwSgAOADenKlJ+SdO3c2AYMmMilSpIjcvn1b5s+fL++//77N4zUI0sBn06ZN5gRMH6snzhs3bjSJRd566y23nv/hw4fSokULadWqlRm6qEHkM888Y4bBaaCrQwwjOoHWALBr164m0MqXL58Z+jh58mQT7Ny/f9/h8Rro6on5L7/8IgkTJjTJYnSIogZiOuzOFU0so8MkNfjSIFfbaEk6owlqdN+5oievGlB98803JuDVk31nwxMj0qNHD+nUqZN5Tj3Bv3Dhgtk/OuRTg3ANXD744AMTVGkSmv/++09Gjhxp1nFGk6fUq1fPBDUamOn7qNv8+uuvTfbXnTt3umzL0qVLpVKlSma4orZFA+rNmzebk3Hr/aCvVRP46PGh9CKB/m256X501i59Ty9dumTemzt37sjcuXOlQoUKZpk7jhw5YgJ2y/um+12DRA2I9f3UiwDWQai+j9oui8jaGp3ssEr3tzUN5pUO09V9aa9UqVLm/0KPZx1i6+nzWdOgU/9nJkyY4PS53aGfAZbXERtY9l9E+9DyWi2vHUCQ82PvKwCEjIYNG5phZnnz5g3btm2bzX2HDx8OGzVqlM2yTZs2ha1bt84hwcjevXvDnnnmGbOtX3/9NcrDGvv06WOW69C93bt3hy+/c+dO2Ntvv23u08Qg1nQopy5PkCBBWJYsWcK2b98eft8///xjkono/V9//bXNeqdPnw5Lnjy5uU+fV4fQqQcPHoR169bNbM/VUNAff/wx7N9//7VZputrIhhN9qJJV+yH6VmGAWoSmueffz7s1KlT4fe5SmzibGiqbj9VqlRha9euDb9v3759JqmN3q/vob5m6/2n+8gy5HP//v02212yZEn4dqdNm2aTQKZRo0bmvly5cpn3wJruF8t+Hz58ePgxoPvv1VdfNfeVLVs22kNwtT0pU6YMW758efh9Z8+eNQl59P7evXuHRZUOr9TjRtfT5z937lz4fStWrAhLliyZuW/ChAk+GS6+Z8+e8O3u3LnT5j7LvuvcubPL9TWZkT5m0qRJUXo+Pb4yZcpk1vn000+dPkaPJ71fkydZeDIEt3379hE+X6ANwY1M165dzTZ0KLMrW7ZsMY8pWLBgtJ8HQOAgAAWAGKYZOfXkKVGiRGGHDh3yeHuWE1qdsxaVk/oLFy6Y59agwzo4s9CArkyZMma9jRs3OgSgeps3b57DeuPGjXM6Z65///5muW7TGUug4+5cREv2099++83pSbC+xjNnzoS5yxKY6U2zfNrr27dv+P0LFixwmaVzzJgxNsvLly9vlr///vsO69y+fdvMa3MW7FgC0JdfftlhvYsXL5rXqffbz6uLagCqt88++8zh/sWLF5v79P2JqjVr1oTvew1i7emFFct7bT+P0tsBqAbqFStWNNusVq2aw/1169aNNMB+7rnn3AruLMdG2rRpnc5P1AA1X7585sKGdXDuSQCqr03XnT59etAHoHqBx3IBZ+rUqS4fZzl2EydO7EFrAQQKhuACQAyzzO9s1KiR5M+fP8rr6TBQnTOqWSB1npTO/9MhkjrnUGkGz6hYvny5GVaoQzd1zqI9zf6pw0SVZR6hNZ2/1bhxY4fllpqN9vMGdbipcjVMWOc/RpYddeDAgeY5ddiyvma9Wdrm6nXrfNMsWbKIp4Xv7RUvXtz81GGlOhTXng4/td8Pt27dkq1bt5rfnWUK1XmXlmG7mgHUGWe1FXUeqWWuanTna1rPd4zK+xkRS9t1/qjWd7SndT513uuJEydMltqYpDUjdci6Dm//7rvvXA711CHhrmhblbMMus7m9mqWWaXDvjXTqz2t86lDlIcOHeqV4cXKMkQ6ormwwUAzCuv8dx3Wr5mQdUi4K5bXqu+h/m8BCG7x/d0AAIjtDh48aH66UwpBk4xoUKhzDF3ROWVRsW/fvvA5cBrIOaNzQdWZM2cc7tP5h85okiBlf0JomUuq8zedcbVcabF6LcfgqjB9RK87ou1GRYYMGcLnUdovj2g/WO633g8adOhrsCR6ckYTGSlXc28j2u8azEX3RFyDWJ036my79q8jMpa267xPZzQY1MRAuj/0sZYEQd6mAeCoUaPMfOmZM2c63Xc6v1NFlDDKMp85ovmcSufutmzZ0sxt1fm0GoA7+7/XebE6v9rdOdsRsQTSlmA5GOl+1os5ekzo/4HO8Y6I9fuhFweSJ0/ug1YCiCkEoAAQw27cuGF+OushcUYzrTZv3twEn9ozoNkz9SRN19ekOnoyrz2pmlgoKq5fv25+atZVV5lXLZz1/Gj2VWe051TZZzm1BDCWwMyeq54gTTCivVj6GjUQrV+/vkn0o72FmklTA1PtSXL1ul21M6r0eZyxZECN7H7r/WC9D1xlULXsB+uMq57s96iKbLvusLxOS/Dq6nXqMevqdXpKk1p16dIlPIvuSy+95PRxlkysmhDMFct9EWVt1cBSMxPra9ekYsOGDXPZ06+ZrzXhVHT2bWS9gdqD6E0aRJ89e9ZhuSa+8ibdJ5oQTUc0aG++9qJHtL+tLzrpexzsPb8ACEABIMZpL5A7J4y///67OWHX4Esz5Nr3dEQWRNqz9BZo8XgdEhjT9Pk06NWstM56ojQLrDNaskP17Pn/2rt31yi6MADjG9FC1EIEL3hBLBS8IGpAEiGFhaTxDxBRtLeQkA9sLFRQCxEJilhIQEUFLUQE7bRQwcJOtAgipLew0MZiPp7Dd4bdyZndSbI7yeZ7frCQvczOZWfDnnnf877/5GnG89nvhRSPOceAgWJqEBqjzvH86EdxP8s+017vJ+nlpG4Sbb5z507j5MmTpa+N6e9lKcYMjKanp1teW0SVX9oYkQZLBJTBZbssBj53LqSUXRSigvLt27dDlJhqx1XEwX7VDIiqWD+p0r3Ed+Hs2bNhWsKmTZtCRe4qafNxXxl8zraytaTFxzmgktRjMdUytoHohB+5sS1EKs2u6tzPKKZHfvnypVEH2nrEuZztUpLL9nt4eDj5/Gz3eyHRqoaoF6mGZQOe2Nc0Hq/5Kou09lLc9q9fvyafJ+oZLxx0az+bI+a0xSEiTsS809ziw4cP5xd4UlH0z58/h8+LOaJx3m8zeuUyz5g0ddLjHzx40DGySTYDA/DiLabREkXlfrt+ukVx28q+R3PF9++/4pQtt26iRy/ptvQhpidwWZp5UTy/SGeW1P8cgEpSj8XCNS9evGh8//694+vjfKcYOWrGD+dbt27Nav2kJPKjmmjR1NRUo9diY3nm5aWURY3a7Tdpev00ACUyGAfS9BFNpTrT6xUUh+qGePyqFNDplrjtz549CwO0onv37oVBHdH8Xbt2dW29DBaPHz8e9pU5mKmIeRE9a0n1JCWenqdF9+/fz/epGK0lAkfkk+8v78P+durnScZDakDHjcJiuHLlSrgfL75UEedxt+shuxiRgUEfVI7tmzdv8gtzVXDRABRik9T/HIBKUo8RyaQCLlEP5o4VU+1It71x40Z+n2JFFFP58OFDiLI0p+2RYpgaoLVDitv58+fD4JUf1+/evWt5nh/A/MCjUMp8Kqs2Vz5lnuGnT58aFy9eDKmNYP2k18bIX9kPayqL/vjxI3+c40V12lhEpl8wdxf86H78+HFLVPD06dMh6sUcOFI5uyEWO0pVMu6Vo0ePhuq5DDJPnDjRkorLRYNLly6FvxkgditCSwGm0dHRMJAk6lk2B7OIbILx8fHw99jYWMsFDT4fBqBsIwOlZr9//w4XccggIIr68uXLBT0XubDB94sBaIykLnY3b94MnxMXSV69etUYHByc1fL8L2y+uCWpzy10HxhJ+j+gZ+PQ0FDe+3D79u3Z4OBgtmHDhmRPzPHx8fy127Ztyw4dOpStXLkyW7FiRXb37t3SPpplvRX//v2b99HktnHjxtDzcP/+/dmaNWvyx799+zajDyg9BNv15kttx6NHj7KBgYHwPP0u6QlKr8Rly5Zl169fTy7369evbMeOHeE5egPu27cvNJ7n/u7du7OxsbHwN70HU70Ii49X1W4/qhyHycnJ8Dy9HYsuXLiQH9utW7eGz3zVqlXh/tq1a0OP2KLYB5TtSinr90kP17iunTt3ZiMjI+G1r1+/rrSfc+3NOTU1lW3ZsiXvB3rw4MHQ+zK+16lTp2b0AJ3runDs2LGwHOfX8PBw6LeauhX7q8bvwejoaFiec5Gep/Gc43bt2rUZy1y9ejV/fu/evaXrO3fuXOV9mE8fUNB3k+WfP3+efP7JkyfZunXr8tvy5cvD61evXt3y+GxNT0+3LM//pPi5Nz/+/v37fBl688b/BevXry89ftxSvWTpXczye/bsmfX2SlqcrIIrSTUg9Y/IFH09ibYQTSFlkUIczGOLKXkRLSXo2UkaK1HJP3/+hPlnRGfm0k+QiOrDhw9DlIptYD4qRVLYLubmDQ0Nhe3o1jw9IrWbN29uXL58OUQwmQ/K/C2q3LKOVMokLVCouMlzpAsT6eI9iFbRF5QoSr9hbuKRI0caExMTIWJF9JrPnMI5HAuKz3QL6YmcW6RoE2WOLVLOnDnT6PV8V84lCupQXIZ1E20cGRkJvU45F7o5PzW2SmEM+/Hjx9LX8X1JfQ+IwFH4Z3JyMqSkk0pLJJfzLFVBN66v0zxq3rsuVN8lYkvhLnppFhEZ/fnz54zHmXM6nz6azGlNvS/HqPk4Nc+xpe1NnEtKhLxdwapURPfp06dh+VRfXEn9aYBR6EJvhCRJkqojHfXt27dhEE0q91JE+j5zhxk0M//W/p/S0uAcUEmSpD5DxJmIZNU5sP2ICC8ZIGRAOPiUlg5TcCVJkvrMgQMHQjo9Ka30Qe3UEqYfkbpNpWBSjiUtHabgSpIkSZJqsfQul0mSJEmSFiUHoJIkSZKkWjgAlSRJkiTVwgGoJEmSJKkWDkAlSZIkSbVwACpJkiRJqoUDUEmSJElSLRyASpIkSZJq4QBUkiRJklQLB6CSJEmSpEYd/gWIQefpNEBTOwAAAABJRU5ErkJggg==", "text/plain": [ "
    " ] @@ -658,7 +658,7 @@ "source": [ "plt.figure(figsize=(10,6))\n", "plt.plot(np.arange(12)+1,diff_To.mean(dim=['lat','lon']),color='k',lw=3)\n", - "plt.xlabel(python_in_ds.month.standard_name)\n", + "plt.xlabel(python_in_ds.month.long_name)\n", "plt.ylabel('$T_{0}$ Difference (K)')\n", "plt.title('Monthly Average $T_{0}$ Difference (Python$-$MATLAB, K)')\n", "plt.grid()\n", @@ -680,7 +680,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
    " ] @@ -732,7 +732,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "LNB: The maximum absolute difference across all points is 1.0734801114239758\n" + "LNB: The maximum absolute difference across all points is 1.0737024154310575\n" ] } ], @@ -754,7 +754,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
    " ] @@ -790,7 +790,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAzsAAAI9CAYAAAAdAWaGAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAi1RJREFUeJzt3Qn8lOP+//ErpZ1WKaWSkpO9BUcRkYSjneIgDlnDsbZRITmOnyW7U0JOx1ahE5IQSZ2yFSWlnSi078v8H5/rnPv7n+98556573vu/X49H4/R1yz33HPNPTPX+762UqlUKqUAAAAAIGb2CXoHAAAAAMALhB0AAAAAsUTYAQAAABBLhB0AAAAAsUTYAQAAABBLhB0AAAAAsUTYAQAAABBLhB0AAAAAsUTYAQAAABBLhB0AAAAAsUTYAQAAABBLvoSdm266SZUqVUpfjj/+eD+eMlaGDBmiy65hw4aubZP3JB6ef/75os/WRx995PixcvnHP/6R8/6yfeO+7777bt7tpV/KlCmjatSooU455RT197//XW3YsMH2a7XyXOXLl1e1atVSTZs2VV27dlXDhg1T3377rWufsXHjxqkzzjhD1axZU5UuXTrrY6zcB+Ezf/58fZweeOCBauvWrZaPuX322UdVrVpVNW/eXN18881q8eLFKki9e/fW+3XqqacGuh9hlvlennfeeZYe17lz52KPk+24+Xu7bNky0+9Qqxfjd6CQ34ZCXkNQvwl+fC7C8B1gvA/yPAhR2Nm9e7caO3Zs0f/Pnj1bLViwwOunBe8JbLrnnnvUjh07PCm3PXv2qN9//1198skn6vbbb1dHHnmk+uabb1x/Htn/tWvXqu+//15NmDBBDRo0SD/XySefrL766quCtv3kk0+q7t27q6lTp6rffvtN7d2719F9EE633nqrPk7vuOMOVbFiRcuPS6VSuqL25Zdfqocfflgfb6NHj47ESS/8l5y8ke+NXOTz/PbbbyeyDuTFa/DrN8EPfn0HiH79+qkKFSqoJ554Qi1ZssST54gjz8OOfDlkfom88MILXj8tcuA9QTYrV65Uzz77rGvH2KZNm4ouP//8s/rss8/UX/7yF11hW7VqlT6b6ka4Sn8u+cFZvny5mjVrlnrsscdU69at9X2mT5+uTjjhhIJ+gKSVSBjBaf369fo5pUXAzn0QPu+//7565513dKvONddcY/uYW7hwoX7vy5Urp4/pK6+8Us2YMcOXfUdh9t9/f7Vr1y71r3/9K+f95Ha5n9zfq9/bBg0aFPveTL+kB62nn37a9H7y3RPGOoOfvwl+COo7oHbt2urqq69WO3fuVP3793d9+3HledgxPhDVq1cv+hC+9NJLnPEMEO8JMh166KH63/vuu09t27at4AKSM0+VK1cuukgl8sQTT1QjR45UN954o77P0qVLdeuLm88lFZH69evrbhbXX3+9DjmTJk3S3z/y49CnTx/d6pLtrLmcnZNuJNnID/1PP/2k/5buA8ccc4yqUqWKfk6jFcDKfRDeVk0hFRQ5nuwec4cddpgaMGCAeuaZZ4rOWstnCeEnLbHixRdfzHk/4/YePXp49nsrlf707830S/pxKRVqs/tJ19kw1hn8/E3wQ5DfATfccIM+Vl599VUdshBw2JEmyn//+9/67wsuuEAnePHjjz/qM2nwH+8Jsrnrrrv0v3K2TZrHvXTVVVcV6w7htbPPPlu99dZbuo+4dMeQHwoJNnakj+GQvtlO74Pwke44H3/8sf77z3/+c0HbuuSSS9Qhhxyi//7www91hQfhdtFFF+kxF59//rlp1yypUMp3ldzPzjESh99bP16D378JXvLjO0C6sp500kn6b7d6Y8Sdp2FHmn3lbKpxAHTr1k1VqlTJ0lmUzMFk8+bNU5deeqk6+OCD9VkNacqTD97cuXM93YY8VrYh28p38Mn95AxxOjnz8cEHH+hBZXJwSjO1PHe1atVUq1at1ODBg3VfYL84eU82btyoz0zL65P9zee0007T923ZsmXW2+XDL891zjnnqDp16qiyZcvqgYpS1tI8L10FrLyfM2fO1D9UciZftpHel92tcpfB7fLjdtBBB+nB7/Jcl19+edGPotn77sbr9ZO0hPzpT3/Sf//tb39Tmzdv9uy5pAwN2QaCe0G6s8lnX0iXMmntsTIewhiQmn69cXynD1LOd5/MAcKFHBN2PgeFPp8b36Hp+/DPf/5TD/KuV6+e/jzJJA7HHnusboUzAoffnyHjTGyLFi30xBaFkLI64ogjio5t+Y7ZsmWLPvMrt0l/+3xOP/10fV8Z7Jw+McjQoUP1/0s3zcwB0rnG8RTynsn+33nnnXpfJMDLeybPJb8d//nPf0wf5+Zx4zX5bpcyz/UbaLRsyOdajl0/6kBh4cdrCOI3watjMtt3gBf1QSN0y7EZla5/gUp5qFWrVnL6NNWkSZOi6y6++GJ9XcWKFVMbN240feyll16q79e2bdvUK6+8kipfvrz+/8yLXP/BBx94tg15rNxHtpVLgwYN9P0GDx5c7Po33ngj63OmX2rXrp368ssvTbct25T7yXME9Z5ccMEF+j6NGjXKuf2VK1em9tlnH33fRx55JOvtzZs3z1keso+//PJLzvfziSeeSJUuXbrY49LLx41yf/XVV1P77rtv1sdKWb3zzjum77sbr9eK0aNHF23nww8/dPzYBQsWpL766qtUqVKl9P/fe++9Je4v2zfuL6/d6b7Mnz+/6H7Znser1/3ZZ58VPaZv376WPmPpz2N2sXKf9H0s9Jiw8zko9Pnc+A4Vy5YtSx133HF5yymIz9BBBx2ktzFo0CBXjrlzzz236H5r1qzR11155ZX6/+vUqZPavXt3znIyPoOPP/54ic+d2SX9PXfrPZs2bVqqWrVqOZ+3X79+WR/r1j54JfO7b8yYMfrvgw8+OLVnz55i9927d2+qfv36+vYXXnghtWjRomKffa/qQJnSj4N8z1vob4Nbr8HP34R83DgmC/kOcKteYli6dGnRY95++22HpZIcnrXsyJlvozny4osvLrpezgwYife1117Lux2Zwk/St5xZkgFhv/zyi+4XP2rUKH22bPv27eqyyy7L2VToxjackv6zbdu21TN0TJs2Te/Lr7/+qmcdkTOK0s9Tug7JNLmyH14q5D0x7i+zf3z66aemzyFnbuXshXQZ6tWrV7HbZCBfu3bt1BdffKHHMgwfPlyfXZFmctnuiBEj9NlD2UfpF23WH/i7777TfXylNUIGFcv7KYMb07tfFVrusl9ytlzOGEvf4ueee04/hzxGphaWs3tye67pMt16vX6RMSZy1k48+OCDenC9F6SPtqF9+/bKL3LmXs5MC6sDR+XsmbyP6dNXZw60leM8332Mfu5uHhNWPgduPV8h36Hr1q3TZ8RlpiLpBiTjpuQ7ZM2aNXo7Mq5Kzmimn911e//NyOsyxlm5tSyC0eorffpljIO44oor9L+rV6/W75UZmUBDuljKcXrhhRfq6+TYkXIwBiNLOWUOSs82AUYh79kPP/ygW9HkvZP7yveolLe8Z5MnT9ZnocX999+vHnrooVD+9tohvwMy9kImaZGuR+nk/1esWKFbM4zvRz/rQEHy6zX4+ZvgxzGZ7TvA7fqgtLBK3UTItpCHVynqjjvu0IlTzlJJAjXIWZN69erp20455ZS8KVwu7du3T+3cuTPrmXfjPu+++64n2yi0ZSefTZs2pQ499FD92Oeee87Tlp1C3pNdu3alatWqpe9z1VVXmT7HkUceqe9zzjnnlLjtxhtv1LfJ2UI5m5aNtC6UK1dO3++1114zfT/btGmT2rFjR8qpfOXesWNHfVuFChX0WadMa9euLSozs/e90Nfrd8uOkNdqtMxlnum207IjZ5qkjI2LnHWfOXNmqk+fPkXbv+iii2y/3kJf9+GHH64fI2fz7XzG0s+imT2flfu4cUzY+Ry4+Zlz+h0q3xfG7WPHjjXdV/mOcXv/8xk1alTRvv38888FH3Py+oz7dOjQodhtRx99tL6+a9euWR8rLQgNGzbU9+nVq5fj3wE33rPOnTvr26RlWz63mbZu3Zo6/vjji86Ey/eh2/vgpWzffZdccknW33rjtUhrhrDaslNoHSgMLTuFvgY/fxPyceOYLPQ7wI36YLrzzjtP3/fEE0+09TxJ5EnLjpxdk5k6RJs2bYr1J5Yze3JGXMj86jL7Rj5y9m7fffctcb2kX2MgcK7+w25twwtyNkn2QUyZMsWz5yn0PUlvqZEZQIw+vOlkql1jnvz0s0BC+q0bZ2/kDOXhhx9u2rpgPI+0EpmRlgfpt+9FucuZFTl7KWSKxz/84Q8lHi9jDaQvuxm3X69f5LUaZ5QfffRRfdbJ6aQA++23X9HFmHlHBlPK4E3ZdhB91o3PurQM+M2LYyLX58Dt53PyHSrj/YyFF88///wSrb2Z3zFe7n82RouInLU3zpLaJS0x0mIjU53LbG4i2/gco3Vn4sSJWdd0kRYEYzZAYxB4oZy8Z9J6IxN6GPshU7ZnkjPWsm0hZ6DHjBnj6j4EwWitkJZ7Y9yI/Cv/n357EHWgILj9GsL0m+D2MWn1O8Dt+qAxi2pU1yfykydhR2bokJk6zL4gjOvkAMn1JSnkQ2D2IydNgk2aNCmqoHq5jULIDFAyiEzmkJcuCMZgf+MiqwcLL6cQdOM9MQKMdG3IHOAtjMdJU3DmitTSbUgqL0K6pcgAeLPL0Ucfre83Z86crPshA5Oz/QC7Ve4y4NvoDiODqc106tTJ9DY3X6/fpEuRVDyle8wDDzzg+valQiddeaQ7kt+MWdjk/feb28dEvs+Bm8/n9DtUuqgZg2fzTfLi5f6bMUJHelcTK9InoJCKnwxyl1n+ZH/lsyOVnsyV2qVLpHRPk66xRiUynXSVFVKplNdbKKfvmZS78f2Xa5plOfZkgLVR4XVzH4JgTD4gx9P48eP1dfKv/H/dunVtvSdu1oGC4udr8PM3wa1j0sl3gNv1QeN7S45Rr4dBRJ0nYceYuUS+2LN9WTZr1kz3nxf5krwcQLkY61fkmsHDjW04JT+m8qMgP/RyRk/6BJutY5Jr/EcY3hO5Xe4nMr/c5Mfx5Zdf1n/L9jPXqkj/4MosbelneDIvskaJMFvRulGjRp6We/paK2ZfikLOTJlNMezm6/Vb48aNi2Yuk/EfTioicpZafgSNi/R/llYimcJUykNWLJezhZmzlHnNeK/tVm7d4PYxke9z4ObzOf0OlbEfBpl1zQ4/PkNOw062SpKcZZXWG5nC+LrrritxH5lxyRjzkbm4rbSAGRVsGS/gRhh3+p7JbG8GY1YpM8btZutTFfLbK2erM2eds3vJNUtmpvTWCuM30PjXmJ46iDpQUNx+DWH5TfCqPmjlO8Dt+qCc8ErfNswV7zfgAjkbbCwKJW+qWfOmHNRyQMiPoZz9k/+30rXBTK51M9zYhlNy9kMG18o+XHvttXp6X6lMSuuH0f1EVt2VgZ6S+L3g5nsirTvSpURadqSFR37AhSzUaAz0zezC5jTImU2naGWBxkLKPX3aZWOKzVzNztkG8rv5eoNad0cCrXzhy8JoRpcVp6SiIF/MMuhZzpAed9xxujIrFTsZpOnFQniZ5Iy6cezn+8HzgtvHRL7PgZvP5/Q7VCrxBgkldoT5MyQDm41JJ+TYtrporFSEpKudnMGWVihjen6Z3lcqPbItuy1gZpy+Z/J7kf79lovxnqY/xo19MLrUFlqBs7uYr/xuyNT78nsmA/ONBYjtdGFzuw4UBD9eQ1C/CW7VB518B7hdH0zfxyB6KyQ67Mh4DiOpygwRcgBbOYMQpg96OqsHULYDU2avkbMVQpo0ZfxHNl7PK+/meyJnuAYOHKjH7Mh2jcXAjJYe6dZwyimnlHhc+o+mhCQvF10stNzT91WapHMFHrP1aPx8vV6Q5nXpeywtO9Kn+vbbb3dt29LqJ8eRBCo5Izxr1qyiBdK8JJVLozLsx/MFfUyE4RiUH/H0ClS+yrPf+1+rVi1HY7iM1dPtkm4t0k1m0aJFutuaEXaMlp4zzjgj66x0fkoPpfL9ZuX7z26QtUIquzI20k/SWiGzdEmFVMaBSY8F+f98LVxxqwP5/RqC+k0ohN3vAC/qg+nfW35/VlTSu7EZTZ9OP1hhY0xVm2v/5IxxtjNQMmDfkGtgrtf9VN18T2QBLpk6MT3gyIfTOAsk/dKzBURjIJ2QHxIvFVru6QMxc/WblYG8ZtMz+/l6vSKhVr7QJSDcc889rm5bFnDL1m3GS+nTm5555pnKb34fE2E4BuWsZbbPZVj2/4ADDvB9wgpj8gFpzZF+9jJNrVTu0m8LUvr3X/p06tkYA6NzLWoaNUYrjtEF006rTlzqQEG8hiB+E/zkRX3Q+N6Skw1GXRU+hB1JrtKUKfr27Vusf2a2y+uvv17U1eHNN99UYSSrdRtrWpiRpu5ss5Old6kwm7Nd5u/PtXJ4GN8T48tf1sqQ7UvQMc7wZevCJqS1R1YKTh+I65VCy11miDH6Z+c6LnPd5ufr9fLYv+aaa4rOPMt77RZZD8bgxVnhTHKsGv3KjzzySNWxY0flN7+PiTAcg3Km1/gRtluB8mP/jTP20oLr1yB56aYm3VjkRIl8dxqvTbr05Jr0xJg9yus1aeSMutGFyPg9yEYCmlEpNbrzxIFURI2uTtnWi4t7HSio1+D3b4LfvKgPGoHcTstjUrkadqQyYfQhNKavzeXcc88t6prg5EyCH6TiK+bOnZv17KJU8s26+KQPIM72JSAtQtJVyMsfLy/eExlka/RPlVmFjJmFZKG5pk2bmnZnMaZkHDt2rL7kImc8nZ7dKbTc5QxThw4d9N9PPfVU1tad3377Td17772m++Dn6/WSTJ0pTfVSZjJ2xw3yo2gEDwmVbi3maEZm+ZGZb6SrqVQYpQtBEP2b/T4mwnAMSqXFaK145ZVX9Nlfq12B/dh/o5Xaz+mPZWIT+Z4V0kXU+P6UbjxGuMvG6KYivQi8Gt9ptHYZs2lKa2i2Ge6krGXmKSFh1uwkVxRJ10b5zpcWN/nX6OqYlDpQEK/B79+EIHhRHzRahNO/x+Bx2EmfflDeVCMk5CJf7MbsNDKnuMxTHjYyC4nR71ymIZYzcTKDiOyrnNGQ1ykD87P1J5f+2MYBLiudyyBvSeLyYyV9N+UAfe+994pmOHObV++JVGCMM5DyY2jMB5+vuV8G3smgU9kv6e4mP5DSKiZnVKVPvpxRkhlK5GyS9Ft3ujKzG+Uug1SlYixd9KSfvawVIu+zdF1744039BlrCbq5xhH49XrT1wyRabNzXb7//nvbFR/Zv8yZtfKR7gzpUwPLeA05ayUV3tatWxfN3iQDtu1UJvI9l/xoyhlCGVws443kjLOs7yDN/TIAVI7XbNOB+sXvY8Lv5zPbB6NLmlSepLXws88+09+j8pmU41JOHBhTvvq5/zINrXTN9XutFyPEycxTRotSvi5sxvgeOUMs5SXfRRJ65OL2CTOZ/tY4ySEr2ssJAgmS8p7Jd6d8hxrlJe9R3MYLyO+HzMRpZebPKNSBrP42ePkaCv1NkK6ScpIqql0m3a4PSnn98ssv+m/CjgVurU46bdq0olVjM1dez+WDDz4oetwDDzxQYrXbtm3b5ny83J5t1WO3tiH+9a9/pUqXLl20n+mXqlWrpj7++GO9qrX8v6xynVkuFSpUyPpYudx66615V8a2unK21+9JunfeeafY65CVtjNX0c5GVik3yjvfZcSIEY7eT7fK/ZVXXtGvK9vjZduyInT9+vX1/99zzz2uv14r0ld0tnLp1KlT1searU4vfv/991SVKlWKbUfe/0L3pUePHqnt27fbfs1OnqtNmzapr776ynR7+Y4FWT0838rZVu7jxjFh53NQ6PO59R26fPny1LHHHpv3+b0or3xuvvlm/dgWLVp4viJ9thXo5dKyZUtLjzv11FOzvu7049at90y+Q6tVq5azvPv165f1sW7tg1esfvdls2jRoqLHynb8+L0Vcsxle143fxvcfg1u/iYYdSy79SA3j8lCvwPcqJcYnnrqKX2/GjVqOP4dTRLXWnbSmy+tNH0aJJHKQl6Z2wiTnj176hlJZJpA6VctZ4jl7ILMpiGDznL1V5Z+53IGTLYhZyuktUC6SUnTr8wvbywg5QUv3xM525c+oPCss86ydHZPunDI2Ux57dIXWspRBsFLuUj5SIuJrI3w9ddfF7UoOOFGucuK79J1UcpOHivvu5SLnF2WlgMZ92GMVUqfdSqI1+slmV7cWMfEKTkjJ2eK5WyprOEjZ+elS1OubjtOyHskx6G0EkhLrJwBl0HWsujhMccco8LA72MiDMegtLpIdyhpIZXPjeyTPL+0HMr6O/K8ZgtTer3/ffr00f/KFLq5xma6SbrqyBS7hssvv9zS49566y01YMAAddRRR+lZ0rzsjinfoXK2f9CgQfo9ku84+bzKjJvSyiatAcOHD/fs+aMmDnUgP1+Dnd8Eac00JoEK+yxtubhZHzS6v0rZuf07GkupCJAzpqVKldJnl7NdzM4uie+++y7VrVu3VM2aNfVZKjnDO2nSJF/3H/H022+/FZ2RGTduXNC7A8Ch0047TX+OBwwY4FsZDh8+XD+nnOldt26db88LRM3UqVP1Z6Vs2bKpJUuWpJLOqBNLmUgd1y0zZ85MnXnmmanq1avri/z92WefFbTN3bt36/qR8R0rLaNWbNiwIXXjjTem6tatq+v5zZo1Sz388MO6VdwJ16ee9oosAiiz12S7mJ1dkjN9kqTlTKL045f+xjKFrpz9k4GhQCHkLKvBWEkaQPRI64UYNWqU5+ueGaSVS8h4h6itwwX4ScayiOuuu06Ps0s6Ge8j46uk94nZpFB2TZ48WfeGkB5LMhZILvJ3ly5d9AKqdkndXMbzyfv15JNP6glNjPGR+cjYWxnHJS3g0ntKtjVu3Dg9tsnxZCipiKRYSXd27N27N3Xcccdl7dsqyVJS66pVq1zcS8Sx5caMjCMw+tyfcMIJvu4XAPedffbZ+vP84IMPel68//73v4tahadPn+758wFR1rx5cz0+OtdvclKsXr1atwZLK9cPP/zgyja3bt2aOuigg/TYq0yffPJJqk6dOqktW7bY2uaUKVNS1157bWr+/PlF18k4JCstO9Kik23M1I4dO1JHHHFE6vXXX0/FtmXHyboaMltPthnCZKG7rl27FltkEMgkfeq7d++uxo8fr2cikrMLixcvVs8884yeZttYFyDXFNQAokH6y8v6MvKvF607MmOajD2YMWOGuv7664vGH8gZTADmZDyd1OeqV6+e+GK6//779cx20splZ7bAXKTVRMa5nnbaaSVukzGRso6P3ZkuzzjjDD0jqsymaYd8R0oL+1133ZV1TG7//v3V448/ruz678pZMSRTIMr0yMbikJnkNun+NnjwYN/3DdEglRPpqiZfBNnIsfXII4/oDzWAaJMpX71cv0am305fB0gGFcuUzgBgldQ55OJ2fblz586mt0t9WboSymQIXpOTQfJdaRbkZDIHmaZfTkgZ6z1aEduWHZmByViXIBs5My9zzwNm5MyCLBh7wgkn6JlmpHIis8dIH9mrrrpKLzQb1hnUAISTjM9p166dnmGuefPmQe8OgIT7NkT15Xz7UqVKFT0OaNGiRfFs2ZEmTGlOkwLfu3evnq7v9NNPV7feemvWAWtyBi3X4lMy7Z+sAi0LW8kimUAmWcU5jis5A/CfsWgiAITJ8jz1ZVk6QBaADcO+pO+PneUkIhF2pB+1rHHTu3dvPbuanGFfuHCheu655/SZMelmJGfK0uVb3V7meJd1A+R+ucKO9B+Ui0GClqzGLuvteLnGAQAAAJyRGcvkhLbM5ms2pCEocrJ9586dnr3uzPppuXLlTNfjyVdfltuMNQW9Js8ja3nl4mR/IhF2ZLq6l19+uUT/6gcffFAP7pQFmn744YdioUUCigxmykXeeDngcpFxPUOHDi3wFQAAAMBvK1euLFr0NAyk3lm/QSW1ds1eT7Yv3e0zw8DgwYP14svZ5KsvS11Zglm2EOU2t+rukQw7ucgc4DI7lswUkb4KtfHm5CvU8uXL57yPzPyQvnr8hg0bdBOafHikZQgAgK4Nb4h9IaQa1rF1/wkf9VdhE/X3ye574LYt9Sp5s906pV3f5p6d29WC5+8O3VAFqZtK0JnxnwNU5cruhofNm1PqpOPXlqijljNp1TFuk30yCxlGAPGjN5NbdffYhR3Rvn179eWXX5ZItjJVcL6Fi+R+uZg1/clBRNgBAIj3f39enVWzTywLI3VIXduPmTw7nDOdRv19SpW2V8lzW5XVe/S/W+q7G3pKl3U/7BjCOuRAgs5++7ndvW6v7Tpq5f/Vl83qw7luc5uVuruT/QlXJ0aHJLVv2bKl2HXS5y/XgFBZHVaSYdgSPwAgmt799dlQBJN8F7vbikvQCdP75IST98IrlVZs0RdEX4M89WWZDEB6NIVhX5zuTyzCjizuKLOrpZNFkObMmWP6mNmzZ+txPwAAxKEibbUybCUQOa1Yhz3oRDXwhCnopCP0RN8RIaov59sX6ZElYUgWQU1c2JGFH2Ul6syubRMnTtQDqrKR284880yf9hAAkBRBVKTDWhkOs6gEnii8t4Se6Grfvr168803TW/3s74sdfklS5aopUuXZr190qRJ6sQTT7S1oGgsws7DDz+sZ504++yzi10vs7TJ4kNjxowp8RgpSJmu+oorrvBxTwEASeFXRbqQVhg3yNgNY/xGVFp1ohh4AK9069ZNff/992ratGklbpsxY4aaN2+e6tGjhy9vgIyRl8nG7rnnnhK37dq1S8+QfP3119vebiTCjry4CRMmqDVr1hS11MjiorKK/bBhw9Qrr7yiypQpU2JA2ujRo9Xtt9+u1+OR2RtkjRx5Mzt06KDuu+8+Vbdu+M+WAACiyeuKdFhCTlSDThQCTxRaddIxjid6KlSooOvJvXr10i08u3fv1hf5u3v37mrkyJG2W1IKIcu9SNe5W2+9Vf3222/6Oglj5513njrqqKN0OItl2JHVVKWF5oQTTlDVq1fXLTZdu3bVhf/111+rFi1aZH2crK4q4UaavSTYyEKgAwcOVI888ojq0ye6s7EAAJJdkQ6iEmwEnMyZuKaPu1VFXRgDT9SCjoHAEz0dOnTQjQpPPvmkHgMvF/l7/PjxJXpOpTv66KPV9OnTs972+OOP6wVAjYtMLNC8efOi/5cglY3U8WWb0pIj9Xi5b+fOnXVXumy9tawolTIb1ALTwVHyRsh6O0w9DQCwws3pjv2uBOeaZjgOQSddmKaljmrYcTI19eaDvFln55tnB4SuvmbUI+fOr+X61NObNu1VRzdbE7rXHLRYrLMDAEDYWw7cqEjnqgA7Wfsk11n4fNuLW9Bx831KctAxjiu31+IBnIpENzYAAJLeVcrtoGM8zuyStKATli5tUQ86BrqzISwIOwAAhLwi7UXQcSrOQScsgQeAewg7AACEGEEnGKyXVDhadxAGhB0AAEJaiSboJCfwRL37WqmlP2a9nsCDoBF2AAAIWSU632KhdF3zD13a8occI+iYBR4gSIQdAABCVInOd4Y/V9DxYgrfJIzRieoCsUHOeJYecvKhdQdBIuwAABCSSrQbQUf+tXPJhaBj/l6FJehYmT3Pz5BDdzaEDWEHAIAIVKK9qtCaBR+CDjJ50U3Ni9ZIIB2LigIAEIHFLL1YqLHyT3uyXk/QKcmrxUYlQDhp3Qmia1j6fpoFH7PXwiKjCAphBwCAEAUep92aJLjkOktuFmwyEXT8CzqZwSFKM7JlCz52g44brTpba2e/fs/2gjeNmCDsAAAQosDTodXQglt3rAabTAQd/4NO1EOPcDJzYL6gYxZiALsYswMAQIhMnj3Y8WMl5BB0ohl00sV9CudcQUdCDkEHbiLsAAAQocDjxVgNWnTCE3ScTO0cVtladfIFHcBthB0AAGLWwmMHQSd8QSddVAOP3QkJCDrwCmEHAICIBR63WncIOuEOOlFt5bE7ToegAy8RdgAASGALD0HHftCRgfhBTh4QhcDj5cxrgBOEHQAAIhh4CmndIeg4CzrZ/vZbmFt5nAQdWnXgNcIOAAAJauEh6BQWdHJd56cwh550BB0EjbADAEBE+DVpQZI4CTrpt4Ul9AQZfKRFh5nXEFYsKgoAQMQCj7HwqNVFRg206lgPOnZCjNw3DK0s6fvgVwizO+uak65rO2rvsv0ce7fZfwziiZYdAAAS0MJD0LHOSVAIuoUniBafXEHH6YQEEmwyL0AhCDsAAEQ48FiZqICgY71Vp5DQErbA42XwcRp0crXqEGzgBcIOAAAxbuEh6FgLOm6Nvwlr4MkWfJyGH4IOooSwAwBAxAOPWesOQcd60HFTGCYusMpu4CHoIGoIOwAAxLCFh6ATTNDxa9thmXHNwBTTCCtmYwMAIAYk3LTp9mDR30E7tu/Drm2r8k978t4n39ilzBYMv4KI8TxhmK3NqxnXnE5GIBinA68RdgAAiAE9HbWDaYDDHnTSK9O5Qo9UyHMFnqBbWbI9f9AByI8ysTvNNOA2urEBABBxxro7BqOFJw5Bx04LQr6uVmFjjO3xM4jZfU5adRB1hB0AAGIQdDIrpUEEHi+DTnrgsRJ6osbL4ON0214GHcAvhB0AAGLSopPJz8DjR9BJF0Tg8avlKD2cOA0/hT4+ioERyIYxOwAAxDDopAeeMExY4IV8Y3mMCruVhVezPc7p7ZnsPn+m9MCSa5yPW61CVl6flVYdxusgDAg7AADENOj4FXi8bNWRCnPFn/NXvO1OXuBny0Wu57IbhDKDTxATL7jRfY1Z2OAXurEBABDjoON1lzavg47xb75WAquTF4RtEoNC9seLoBOmsgHcQNgBACDmQcerwOP3OB0rgSeqg+bDEMTc6r4m6MKGsCDsAACQgKDjduDxOuiYVZbdaOUJuyBCj5tBBwgTxuwAABDxoGO3YlzoGJ6ggo6dsTxWFiINO6cTLDh9Hr+CDuN1lPpoWyNVobS71fBt23Yrpda4us04IOwAAJCAFh23Ao/VoCMhw0kF2U73J+O++UJPUIHHyuu3sm/pYcSt4ONlyxFd2BAmhB0AABIWdJwGHjtBx89KcpCtPIW2eNjdN6utPW6GGbqvIcoIOwAAJDDo2A08QQSdzO5O5X7eN+/jrYSeMHIaerwW5jIDrGCCAgAAEhp0rE5aEJYWHStjPaLehSrKM8pZKf9872G12pv0BXALYQcAgAQHHSGVa7NAU0jQsRJ+zCrHZpViuT5fhdnKjG1BMfYtCtNoB/38gBsIOwAARJib3Zkyg01QLTpWWnCi1MpjFnDCHHqCDjq07sAthB0AABLcqpPJCDheBx03piW22soTZLixOo12WEOPm6x0YQPcRtgBACAEwhB0DH4EHSsTElgVhm5tdsJNvm0EHXqcbt/tMib8wA3MxgYASJyzavYp+vvdX59VUQ06bnRhC3trgVR41/28nyvbyjdFdSHb9VuQ6wcBUULLDgAgsUEn2/9HIehIyPFr6uGgg5KVoJNrSmqDhBwvgo6x7TiVv9MQla+M5X3K9V7Je515AQpF2AEAJIZZsAkq8NgNOmEJOW5UuLNViq2EFieP8SOMuPUcdrfjZeApJPTk4uR9tsIIU3Ip+4s3z4HoIewAABIhX6DxO/DYCTphDDlhCDxhCTpBPJdfLWxOQ0+hrTx2w41XAQrRR9gBAMSe1SDjV+CxGnTCHnLyVbidVsKtVFzDFnTSn9Pp8xayv153KQw69GQGG8INrCLsAABizW6A8TrwWAk6UQo5hc4U5qSCH9agU8jzu7G/foyh8iv0EGzgFsIOACC2nAYXrwJPvqDjd8jxqnLsRuAxCzRRCDpB7odfs+sFNYkBYBdhBwAAHwJPrqAT1ZYcryvdmZXefJVgL2dcc8rK/ri9z34GHq9CD+AWwg4AIJaCnlI6rAuGhlWhZ/vDXHGOcwuP1zO3AYUi7AAAYsetoOPGdvJtI24tOoVwOjub1QqzUSlPv/jFbB+9rOz7vWCs03KllQdeKuPp1gEAiHiLjmzv3V+fdfzY1CF1TW8n6BTOTtCxc70XAUL2dWvt4v/vNdlfP0OdIf05rZaZUR7pZQQUipYdAEBseNV1zcl2CTrO2AkAVu7rdgtOoduKe5c2N1p8jJYeurjBDYQdAEAseD1Gx872gwo6lVZsiUwF2I9B/V61aLgRePyuyIfl/XYafACnCDsAgMjzazICK8+TL+igcEEGHb+2H+fAYyD0wA+EHQBApPk961qu57OyL4zTcR5orJ7l9yuIBBl4ZFyLcYly4LHb2kNLD+wi7AAAIiuo6aWzPa9xHRMSuCc92BQ6EYFX/J7VLVvAiUPgMdgNPXRxQz6EHQBAJAW9jk768xcadKTyWWgF1M54nSixU6ENsqXFj+fOFWriFHgEXdzgFqaeBgBETtBBJ9t+FBJ00v+O4liQoIWlzGQ/vAgRVoOM3M9OS4ebx1u+sO20+6axf1bKlamrkQ1hBwAQKWEJOunc7LpWaAVUKp35njPsZ/XtsFpW6ZVxL8dNuR147LbY+B14rLYo5rqflffDbujZs9PSbiEBCDsAgNgHHbuzo5Va+qOKM69aIPzmpJLuxwQRbpZv5kKkVu5vhx9Bx+52cr1HdkIPIAg7AIBIBx0vpnl2a5t+zbyWWVm00roT9cBjt5Lu9yx4QQQeP4NO0KJ+/MI/hB0AQOhZmQAgbAodo1CoOAeeqFTS3WyFyDceJYigI8dXXCfGQHwwGxsAINSMRTqTEHTcFseKaFSCjlf7nG12uiS16MTxdcBbtOwAAEIfdKLEbtAptHUlX6DJ18LjReuO1UqoneeNesXW7bEmTteXiXo5xqV1Ev4h7AAAQqlDq6FKRSzohJXXgcdpBdrK4+I2HXeQlfMolKOTVlECD3Ih7AAAwhl0IqjQ7mtBL4pptRLu535GoYJuVxAzinlVjozbQdgxZgcAECpJDTpej8mxct9cFWJjRfs4ho+g+FWeSXjPkvAa4QwtOwCA0CDoeMvqDG3IXYZuh1svW3qS9H7SnQ3ZEHYAAIkMOkZltdAZy9yo9PpZIbUSeGCtHMMcepIUcoBcCDsAgEQFnczKaVQr/oWENAKPe2UextATxaDjVvnRuoPYjNmZP3++qlKliipVqpRatmyZ6f0WLlyounfvrg444ABVvXp1dfLJJ6u3337b130FAAQfdKQyFdVg44U4rsETdHm6XaZOxvQEEXQK/Vy5/bmMYtgL2qxZs1SHDh1UjRo19EX+njlzZkHbXL16tbrssstU7dq1VdWqVVWLFi3Uiy++mPdxc+fOVT169FAHHnig2m+//fTjL7jgAjVv3rxkhZ2+ffuqm2++Oed9vv76a3XKKaeojh07qlWrVqlff/1V3XPPPfqxzz77rG/7CgAIDiHHHIHH/bLyKvS4eb8kfDYrrY5WWQRp8uTJqnPnzurqq69Wv/zyi77I3126dHHcQCD17hNOOEE1bdpULVq0SK1bt07XvUeMGKEGDBhg+rhPP/1UnX766br+Lg0bmzZtUt9++6066aST1GmnneYogJVKpVIpFTGvvPKK6t+/vy6EChUqqKVLl6qGDRsWu4+8LEmQN9xwg+rdu3ex2xYvXqzfAEmOdevaW8Nh48aNukVpw4YNav/993fl9QBAUnnVqhP3Fhy3K9NxLy831utxWuZul61Z17agg47d8vH6mNu9a7uaNfHO0NXXjHrkiM9PVBUquzuaZNvm3eqGFjNtveZt27apxo0bq5deekmHiXTTp09X559/vq43V6xY0da+SHg69thj1ZAhQ4pd//vvv6sjjjhCTZw4UbVs2bLE41q1aqX69OmjrrzyyhK3PfPMM2rs2LFq2rRp8W7Z2bx5s7rlllvUww8/rMqXL58zGUqKvOSSS0rcJm9q165d1ciRIz3eWwCAn0GHVpzgw5PRsuHmxa2A4HQMTKHjo7zu2hZ00LGDz2i4jBs3TjVp0qRE0BFt2rTRweS1116z3aozdepUXV/PJENKrr/+evXEE09kDYJz5szRQSkbaWly0rITubAj3dCOPPJI1alTp5z3mzJlir7PPvtkf4ly23vvvefRXgIA/Aw6VKAK57RS7nYwMXsOpzIDjp8LefoxnidqQQfhMmXKFNNw4bS+LNuUrmgy3sbONnfs2KH/Net0tnfvXtstTJELO99995168skndX+/fKR/X7bmsfRmMukGBwCIbtBJYsgJepyNH+HG7HntMgs2dgKPF61ecZTrc5jEz2lUfOtBfTnfNqW1SHpfSXe7dDKZWM2aNdX48eOzPu71119X7du3V7GeelomFrjuuuvUYYcdlve+y5cvLzGOJ12tWrXU9u3b9cAns+RppEwjaRpNbACAYIMOFSdvZJuSOkyV87hMme3FdNVhlYTXGDaZddVy5crpi5P6cv369dWKFStsPb9sU8brmJGZlA8++GC93aOOOqrYbf369VO33nqr2rp1q+rZs6eeiU1mdfvnP/+pxxU5mTAhMmFH+gsuWLBAvfHGG5bH9sg0d7kKWgZvyf1yhZ3hw4eroUP9XegOAOLI70VD4UyYwk0hgSdf642VCQu8LoskhR4UN2N9Y1V2d1lXi2Xn5p1KqZk6SKQbPHhwiYkCrNaX5Ta5jx35tplruzLORxojBg0apP8uU6aM2r17t66rS/e4evXqqVh2Y9uyZYt+wQ8++KCqVMnaF4K0xpQtm/sgkpQrBZqLzPomzWzGZeXKlbb2HQBA0ElKEAlTOeQLMkEHnaCey+/XEIfXFjVSV02vu/bv399xfVnqyjt37jQdR+Nkm7nq4PJY2efHH39cLxmza9cu3bJz5513qjPPPFN9+OGHKpYtO/fee69q1KiRbs6yynhzcpECzTWjW76mPwBAMC06cenOZAeVRvvHgASabC08YQo6cTim85VXlF9bFEnPJatTT5f7X33ZLJwYwUV6RPlRB5dZlGXYiswEZ5CubLfddpvuUnfFFVfodXvMJiCLZMvOwoUL9YQEkvDsqFy5slq/fn3ePo1yPwCAN+i6Vrg4D2oPooUnjEEnDM/tx2KrCJ/KeerLcpvdurKVOni27cq002vXri0WdNJdcMEFqnTp0rannw592Ln55pv1wkIy3bQdDRo0UMuWLTO9XVaHlUSZa7wOACC8QScJlackvEa/Ak/UpmmOYwjneA6fBnnqyzKJgLSouLlN6RInXe0ytztr1ix13HHH5dy2THyQa9uRDDuyautzzz2nBzJlu4ijjz5a//3UU08Vm9ZOEqKZ2bNnq2bNmvnyGgAgaWjRKRwVQ//LKgxlHoZ98HqR1Si8xqQ4woP6cr5tytTU1apVU1WqVCl2vcyQnK+7nNwukxbEKuxINzbpbibNXdkuYu7cufrva665puhxMg/3xIkTTQdUyW0y0AkA4K423R70rX9+XCtNcX1dYS6zMJV5mPYlzsESSteX33zzTdOicFJflm1+8MEHprO4mW1TpsD+8ssvc25bbm/atGm8wo5TrVu31olxzJgxJW5bsmSJGjdunB7kBABwN+gYCDzOUAn0v+zCWOZJ2Kcwvsak6datm/r+++/VtGnTStw2Y8YMNW/ePNWjRw9b25Tpodu1a6ceeuihErfJYqKPPfaYXjczkwQgaUn67LPPsm731Vdf1WN2pEdX7GZjc0KauUaPHq06dOig5+e+6KKL1L777qs++eQTHXLuu+8+Vbdu3aB3EwBiGXTSA0/cKzSFvL4wL+AZVXZn/gpzmYdpFjOvyilMrzGJKlSooIeL9OrVSw8HOeecc/T1kyZN0j2mRo4cqSpWrGh7uxJoZKIBGR9/7bXX6qVjpFXmqquuUr1791YtW7Ys8Zjq1avrgHTuuefqf7t3764fJwHphRdeUHfffbd66623bM0MF+uWHXHMMcfopCpvmASbGjVqqIEDB6pHHnlE9enTJ+jdA4BYBx0/BVVhdaPrVPoF/r4vUSjzMOyjH4urhuF1JlWHDh3UhAkT1JNPPqlq1aqlL/L3+PHj1dlnn236OGlhmT59etbbZGFTmTVtwYIF6tBDD9VjdKSxQaaVlgYHM3IfacGRi3RrkzH5MmZIJi/4+OOPTWdqy6VUys4qQdDjh6R7nCx4ZHUOcwBIetDxoyLj99lhKmfhl+uYiNr7F1Trh9/l5Nbr3L1ru5o18c7Q1deMemTPqX9WZSvnXnjTrp2bd6qXT38pdK85aLFu2QEAhKNFx4+KGivew+oxEbWgExTKCXFA2AEA+NJ1LS6BhwpgtGS+X1F9//wO81EtJyATYQcAELkxOkGhAhhNcRkXlYQwH/TzI34IOwAA34JOlFt3qIQhDLw8DjnGEUeEHQCAry06UZtmNg4tAogXL45HjnHEVWzX2QEAuOvYvg8rdVBp/Xfln/aEunjdWruDCiCifoxzDCPpCDsAAGtBx0V+LDZaaOCxun+llv6Y9frUISxcDW8RZID8CDsAEGMdWg01vc1KENj8v5acbNcX2rrjR+AJKujku81AIAIAbxF2AAC2udGNza+Zpey27vgZwDIDEeEHSRe1MX0IP8IOACSUUanPVbkwQs1ml8fq+L1miNUKVBAtTQQcgJAD7zAbGwAknJUKvoScsE9KkEtYu8sRdACCDrxFyw4AwLXZy8IcPPK9Rj/3i5ADEHLgD8IOAMDzwBOWlhWz10jQQdSkH8dh+XzZwdgc+IVubAAATypNxmKcYauIZe5PIftnp4VG7kuLDrwIClEKDrKvfuzvljrZZ5JE8tCyAwCwPXFBNmELNVZaePzYZwIO3JLrMxnmqdz9DmV6QpWdu3x5LoQfYQcA4LhbW9grV7kQdBAlUWq9CXLfzdYGQ3IRdgAAtgJPlAOOX2jNQRBhIYytOwQdBI2wAwDIKWyVp7Aj6CDIoBCWwON3SxQtOjBD2AEAwAWEHIQlLAQdeAg6CBPCDgAABSDkIIxhIYjAQ8hBGBF2AAAAQsDtsOBX4Ali8gS6rcEq1tkBAAAImFeBwesgQtBB2NGyAwAAEBBfFtj0oIUnqKmwadGBXYQdAAAAlyr4dkJFVNfOIeggSgg7AAAALq5148aCvWFs3QkynNGiA6cIOwAQY0blpJBKTqmlP2a9nlnIkBReTBwQhEICD0EHUUXYAQDYDjpmtxGAEDdR7WoG4L+YjQ0AYkzO4vq11gZBB3EU5OKcYQpvQZZD5Z/2BPbciD7CDgAAgMcVfePEg58nINwWdOAh9MAJurEBAApGqw7izuqkAlENMlYFMblCOgk8TFYAOwg7AAAANiv6UQ41hc7MRuBBlNCNDQBQEFp1kCRudUOLclgKw/7TrQ1WEXYAAKYIMgDCGngE43iQD2EHAOAYYQiIJrfG3YQl8BB6YIawAwBwhKADICyBRxB4kA0TFAAAAAQg6IH+cXwtUZmt7Zvf6qjS28q5us09W3e4ur24oGUHAGAbrToAwtzCU2k1C5Hivwg7AICcCDZAPIWhJQbwGmEHAGAL4QeIX2uIW+L2ehB9jNkBAFhG0EnW2X4qrgCijpYdAACgQ05mt6Zs1yFevHh/CckIE8IOAMRYqaU/6osbaNWJJyuBhsDjLcIB4B26sQFAAmQGHrvBhaATP3YDjHF/KuaI0lTUAGEHABIoW2sPgSYZCq2AEnriR95TL0IsgQdhQNgBALjS+oPwc/NMu1cV5KQiGADeYMwOAMTUWTX7hGa8D8LBzXBC0IkPL99LjhMEjbADADFUaNAx0LoTP25UPqnAekPK1c+y9ev5OF4QJLqxAUDMuBV0EF+FdJmi4uo9o4zjNC20l68JyIWWHQCIETeDDq068ebkrD5BJ9rdDsPw/oVhH5AshB0AiAladOBV5TMsFeUkKrTsw/jehW1/EG+EHQCIAbeDDq06yZKr8knFNByctMKF+b0L874hXhizAwARR9CBV2MqqJCGS75xL1F7vxjHAz8QdgAgwui6BrdFrcKcRJkTTET9PWONIXiJsAMAEeVF0KH7GhANUQ84mQg88AphBwAiiBYdAHEOcExRDbcQdgAgYrwKOrTqAIhLy9XuPdtd2xdEG7OxAUCEEHQAALCOsAMAEUHXNQAA7CHsAEDCgw7d1wAAcUXYAYCQo0UHAABnCDsAkOCgQ6sOACDOCDsAEFIEHQAACkPYAYAQousaAACFY50dAHDZYcMeLvq74s8lb6/8056860mU4l0BAKBgtOwAgEccB52lP3r+njBWBwCQBIQdAAgo6GTjR9ABACApCDsAEFDQyWzVIegAAOAuwg4AeIygAwBAMAg7AOAhgg4AAMEh7ACARwg6AAAEi7ADAB4g6AAAEDzCDgC4jKADAEA4EHYAwGNhm3WNNXYAAElB2AGABAUdAACSJBJhZ+PGjWrUqFGqS5cu6uCDD1b777+/qlKlijrppJPUyJEjVSqVMn3swoULVffu3dUBBxygqlevrk4++WT19ttv+7r/AJIpM+gAABBGs2bNUh06dFA1atTQF/l75syZBW1z9erV6rLLLlO1a9dWVatWVS1atFAvvviipcdK/V0eW79+fV3nb9CggerWrZuaMmVKPMNOz5491ezZs9WNN96oFi1apMPPkiVL1HXXXaeGDRumrrnmmqyP+/rrr9Upp5yiOnbsqFatWqV+/fVXdc8996i+ffuqZ5991vfXASDZQYdWHQBA2EyePFl17txZXX311eqXX37RF/lbGhmcNhBIvfuEE05QTZs21XX3devW6br3iBEj1IABA3I+dsKECapdu3bq2GOP1fX/DRs2qC+//FJdeOGF6quvvrK9L6VSuZpFQmLnzp2qbNmyWW9bvny5+sMf/qAT6VFHHVV0vbwsSZA33HCD6t27d7HHLF68WL8Bc+fOVXXr1rW1LxK0JGFKwUsLEwBk6tBqaKiDDmN2AHhBvufC8v2ye8929cGX94euvmbUI4989TZVumI5V7e9Z+sO9c35f7f1mrdt26YaN26sXnrpJXXaaacVu2369Onq/PPP1/XmihUr2toXCU8SVoYMGVLs+t9//10dccQRauLEiaply5ZZW3RkP9577z115JFHKjdEomXHLOgIadZq27at+uijj4pd/+mnn+oUeckll5R4jLypXbt21V3gAMBrYQo6AODl95z8a1wQfuPGjVNNmjQpEXREmzZtdDB57bXXbLfqTJ06Vd1yyy0lbpMhJddff7164oknsj72zjvvVP3793ct6EQm7ORTrlw5tX379mLXSZ++Tp06qX32yf4S5TZJjQDgJX7wgcI/Q9kuCD/er/CbMmWKboUx46S+LNs8/fTT1X777Wdrm1u2bFHTpk1TV111lXJT5MOOtN7MmDFDNWvWrNj13377bdbmMUOrVq3U/PnzfdhDAEkVxgpZWLqYAIV+hghB0fquI/iE07ce1JfzbVNai6T+Lt3t0sl4HLktV4+uRIUd6fM3adIk1b59ez3Lw1lnnVViLE/Dhg1NH1+rVi3dGrRp0yYf9hZA0oQx6ABJ+AwRgsL/PhF8wmN5nvqyzIa2YsUKV7dZqlQpPbty5na/++47/bi9e/eqF154QZ144om6vi77cOWVV+rucU6UURHy+OOPq0GDBukJC2RAlZCxN3J96dKli9138+bNepq7XAUtg7fkfmbNbGLHjh36kj6wDEi6Y/s+XOK6yj/tUUGaPu5WFRYEHSB8nyFjm7Ruul+mbm2D98YdmXXVcuXK6Us2+erLcpvcx4582zTbrrT2yJgemW1ZGiNk0oRDDz1UrV27Vs/kJpOLffDBB3qGt9iGHRnQJBdJfD/++KOelODRRx/VfQMzJyKQgJKvGSzbWJ9Mw4cPV0OHlpxZCUiqMAYdRHO2JCCIkwV8Btwj3yVuvl9JCqTrf6ms9qlQ3tVt7t22r/5XWk3SDR48uMSsaFbry1JXlkYGmeVYGgqscFoHl4aMTz75RO//66+/XnS9tO5IY0elSpXURRddpObMmaNi341NJh2Qgrj44ovV+++/r+6++249+1q2Nyffm1G+fO4DTWaEkD6FxmXlypWuvAYgDiTkEHQAuMHPiQdofUWcSV01ve7av39/0/vmqy8bwcVq0LGyTbM6uPz/f/7zHx3OspEWn2XLlumx+rEPO5nNYLKWjnRlS1e5cmW1fv36vM18cr98b5h0d0u/AEnVptuDRQHHjZCTbeFNeI+KHsImiGOSWd0QV5n11nImXdis1Jfltnx1ZbvbNNuurD8kl/R1M9NJ6Dr++OOT0bKT6fDDDy8xU4SsvyPpz4ysDisJMtd4HQDFg45bJOQYQYfAEwwCD8Ii6GMx6OePOre7nCWhC1uYNMhTX5ZJBGSCADe3KV3ipPUpc7syPqdatWo5ty1jeuyOIYpF2JFBTHv2FD/LLFPX5Up+s2fPLjFdNQBvg056yAGAsASNsOxHkknIIej47wgP6sv5tilTU0uokVacdMcdd1zeicBkEoMDDjgg2LDz008/6YL5+OOPlV/kuaR1J51MST1x4kSdHrOR284880yf9hBIdtDJF3IIQMGggocghe34C9v+JCngEHKC0759e/Xmm2+a3u6kvizblFnTzFpgzLYprTYSrMzW9dm9e7fOGDIldSBh56mnnlJNmjTREwfITrRr167Y7bfccos66aSTbM/VvWTJkpxNYZIOR40apScrSNe6dWudGMeMGZN1m+PGjVNXXHGFrX0BkqbQoENLTvhRwUMQx1xYj7uw7lfY2Q0rBJzw6Natm/r+++/VtGnTStwmEwHMmzdP9ejRw9Y269Wrp3PAQw89lLVl5rHHHtOTDWRz6623qnvvvTfrbc8884w67LDDTMf0eBZ2pOXkggsu0FNCS4iQxYBkwFFmi4rMjT1z5kw1fvx4W9uXaehOOeUUPf3z4sWLi7YrU0+PGDFCtWnTRv35z39WnTp1KvY4mTVi9OjR6vbbb1fPPfecnvVBpqyWN7NDhw7qvvvuU3Xr0i8U8CLoOAk5tO4EhwoeONb8+zyYLXqaeYkjQk74VKhQQdeTe/XqpVt4pPVELvJ39+7d1ciRI1XFihVtb1cCjTRGPPDAA7qFR+rvX3zxhW7R6d27t2rZsmXWx0l9XsbUS4OEsYiodG37v//7PzVs2DC9TbsKDjvypK+99ppudvrqq6/UDz/8oI4++ugS9zvnnHP0wp+TJk2y3e9PCmfffffVb0SNGjX0zBKtWrXS007LG/T0009nfewxxxyjw408pwQbeezAgQPVI488ovr06eP4NQNx5zToFNqSQ+AB4itKFXi3A4eTEBOnQETICbcOHTqoCRMmqCeffFKvaSMX+VsaKM4++2zTx0l9f/r06Vlvk55e0sixYMGCookHJMD07dtXNzjkyxbNmzfXzy1198aNG+ssIMvM2F1QVJRKmQ1qseiPf/yj7j/3zTffFI2bOfnkk3XTV+akAXL7rl27dCCKKkmX0j1O5i1nGmrEkZOg42ZI2VK/kqPHTR93qwqLs2pG82QK/ebhlShVzN36XPj5msPy2c18zUHu1+4929UHX94fuvqaUY+s99hQDxYV3a5W9R0cutcctDKFbkDGzDRq1KjEBAHZSKr7+uuvC31KAB7p0GqochY13CPByWngQWGSsrJ8eoUsCa83aFEOOk4+F0GtGRSmYzkM+1Jq2eqgdwFxCTsyDibXYkWZadbqfQH4H3SAOLFS6TTuE4bKWRRFPci4FSbCUA5hCDxBP3+Y3g/EKOwccsgheuIAGXyUa4XVn3/+WS1cuFCvfAogXMIWdGjdSXaFKYiKTdRDjxtlkO21U2ksXhbpZRTGsoni59dNYXxPEIOwc95556nhw4eru+66K+sUc+lTT8vwoC5duhT6lABiHHQMBJ7ghLHC5FclJiqhx4vyoKIYjzKKyjGcxPcGEQ07Mh/2Cy+8oB599FG1cuVK9Ze//EVt375d37Z06VI9P7dMES2LC8nYnmuvvdaN/QYQ46CD5AlbRSVMFcawlQ2iIYwnLbzA5wOehx2ZdGDy5Ml6XmxZqDN9HR2ZKk5Ii44EHZkCulIlBh4DYRCFoEPrTrwqSlGslPg9mUEUywjhFffAw+cFvoQdYy2cuXPn6nmxZZ5uac2Rae9kDI+sv9O1a1d11VVXEXSAkIhC0EG0K0pxrIS42doTx/JBOMUx8PD5ge9hR8jqqrJQkFwAhFfUgg6tO+GvKCWt4mEn9CStbBBOYeqWWSg+Uwgs7ABxX2DTzYUzk85u1yArgUfeqzAsLBrVBUWtoqJBWSC6ot7Kw/cPnCDsAHkQcqLzIxV04JFWs1IqfqhgAPER1UV1+R6CL2GnXbt2qlClSpVSU6dOLXg7gB8IOt7/MFk902i1O1tQgSdq3QMBICrBh6AD38LORx99lDPEGDOv5brN+BtA/Dj9QYp64CHoAIi6sAYfgg58DTsffvhh1uunT5+u7r77bj0N9eWXX67+8Ic/qAMPPFCtWbNGLViwQD333HNq3bp1euHR1q1bF7zTAFRif4jCFngIOgDiJizBh6AD38NO27ZtS1z3+eefq2HDhqlu3bqp0aNHq3LlypW4z+DBg9Vll12m7r33XvXpp58WtscAYvnDY2fgbFgCD0EHQNyFJfgATu2jCjRkyBC17777qpEjR2YNOqJs2bLqH//4h76fBB8A0fiBy7z48Zxuj6dKn1HPTQQdAEkT1t8DwNPZ2D777DPVtGlTvc5OLnK73G/GjBmFPiWAGP+gRKGFh6ADIOkKafEJ2+8O4q3gsLN9+3b1008/Wbqv3E/uD8A+fhzCEXgIOgBQHL9PiHU3tqOPPlqtXr1aPf300znv98wzz+iwI/cHEL4uA2Fi9/X61aXNqy5xAAAgpGHntttu01NKX3/99apXr15q2rRpehY2uU7+/fjjj9WFF16orrvuOj3ttNwfgLmkBpywBx6rj2MALwAAMerG1qVLF3X//fergQMHqldffVVfMknw2WefffSsbXJ/AMUlPdj4zW6XNlp0AABIaMuOuP3229Xs2bN1C84BBxygw41xkf+/6KKL1H/+8x/Vr18/N54OiAVacKyVkRetO3YCDEEHAIAEt+wYjj32WDVmzBj994YNG9TmzZtV5cqVVZUqVdx6CiDyaMFxVmZ2uoZZnbDASgsPQQcAgGhzpWUnkwScunXrEnSA/2EMjr/stPAc2/fhrNcTdAAAiD5Pwg6A/4/WnGDKsJDAkyvoWG01AgAAMejGdvnll9u6v8zINmrUqEKfFogEgo67ZWl3pjMrXdoq/7RHbT6otA48Xz32V1p0AACIkYLDzvPPP28p4AiZsICwgyQg5ESTBJ7KQe8EAAAIT9gZPXq06W1btmxRixcvVi+//LL6/fff9fTU9evXL/QpgVAj6ES3dQcAAMRLwWHn0ksvzXufe++9V9/vqaeeUnPmzCn0KYHQIeDEI/BY3Va+/QMAAAmaoKBixYrqH//4h56SWlp3gDitkUPlNpjy93LCAqfb4FgAACCm6+zkU7VqVdWsWTP17rvv+vWUgGuoxCanhSfXY/PtDwD4yfgO5PsHCMnU0z///LNav369n08JFISWm/hx0sJD0AEQNukne+ye+AGSxLewI93YfvzxR9W4cWO/nhJAzDk9m2kn8BB0AIQN4QbwsRvb3XffbXqbTDW9du1aNXv2bD0xgUw7fd111xX6lABQUHc2q13aCDoAwsbs+06upzsb4EHYGTJkiA4xEmxyKV++vJ6c4Oqrry70KQGgGOMH3skYHpEt9BB0AEQNgQfwIOzcddddRYuGZpLrK1WqpBo1aqROO+00PUkBAIS9lceNmdsAwG1Wvt8IPIAHLTsAEIdWHgk8VoKOH11FmGUJQLbvBAA+h50VK1boLmq1atXKe981a9ao7du3q/r16xf6tADgydTUYQo6xt/0wweSze53Gd8b4Vf2l31V6fL7urrNPdutLY6dNAXPxtawYUPVo0cPS/e94IILdJc2AIji1OF+B51c1wGA3e8SIIlcWVQ03+QETu8LJPVHhzP54RjLk7kNr+XaR7q1AclUyHcXLTyAS2HHqo0bN6py5cpR7kCBP26EIf/G8vhV3lb3i8oLkBxutM7wnYGk82VR0R07dqj33ntPzZ07V3d7A6Li3V+fDWVXAtkmXRScsRtcwhR00u/P+w/EG59xIKCwM3ToUFW6dOmii/j000+LXZd5qVixourYsaPas2eP6tmzp0u7DkQn8HiFSq+3Y3nCGHTceiyA5OC7AklmO+zImJv0i7GgaK6LzNbWrFkzdffdd6sBAwZ480oAjwMPoSd+coWZsAcdN7cBIFy86hEAJNE+TtbV2bt3b9FFwkybNm2KXZd52bJli5o3b54aNGiQKlPG12FCgKvCHHgELT3utPJEJeikb4uKDBAPXn6W+Z5AEhU8Zmfw4MHqsssuc2dvEqRDq6FB7wJiGngElV/noSdqQceP7QLwB59hwH1l3Ag7cBZ05N/Jsyk/AAAAILKzscG8RYcWnug5q2YfFXZ+tVAgXK1/vOdAtHn9GeY7Aklkq2WnXbt2+t8GDRqo0aNHF7vOKpnQYOrUqSqJzIINLTzREZWgg+CDjvxrdry4schp5vYAxIPb3w/p2wWSyFbY+eijj/S/hx9+eInr7ISdJMrXgkPgCb+wBx1+yMLXouNH4OF9B+LHq8ADJJGtsPPhhx/qf2XdnMzrYM5qVzUCT3iFOehQ2Q131zUvAw/vPRBfbgaeJH5XpBrWUWpd0HuByIWdtm3bWroOzsfkEHhgVRJ/vKI6RseLwMP7D8SfG4Enid8Vusz2bA96NxCXCQpWrFih1qxZY+m+cj+5f1Iw+UA8hLFVJ4k/XlGfjCDX/ey+n7z/QHIU8nlP2ncFyy7Ak7DTsGFD1aNHD0v3veCCC1SjRo1UEhQSdAhJ4RGmoOPnOjDwf9Y1q+8r7z+QPE4+90n7rmCMEzydejqVSnly36hyI6wQeOLD6Q9OerhJ2o9WXINOvsfkep85DgBYlbTfDIIOQrPOzsaNG1W5cuVUnLkZUgg8yUK4SUaLjpPAk7SKC4CSaP3NjqCDUISdHTt2qPfee0/NnTtXd3uLKy/CCYEnvgg3ye26ZifwEHQAWP0+SNr3BUEHnoSdoUOHqtKlSxddxKefflrsusyLTFXdsWNHtWfPHtWzZ08VR16GEgJPPBBuos/NMTpWAk/SKi4A8jP7Xkja9wVBB56FHRlzk36RRUIzr8u8lC9fXjVr1kzdfffdasCAASpu/AgjBJ5oS9qPUBy5GXS83CaA5P2mJOk3hhnX4HnYGTJkiNq7d2/RRcJMmzZtil2XedmyZYuaN2+eGjRokCpTxtbSPqHnZwgh8ADB8DKUEHgAOGEEnKQFHcD3MTuDBw9Wl112mUqiIMIHgQfwlx9hhMADwAmCDpAfYcehLqcOV0Eh8CBoSelG4GcIIfAAQHZJ+L1BTKaehnsIPAhDyInzD1AQ4YPAAwDFxfl3Bv5wbQDNJ598ov75z3+qr7/+Wv3+++9q165dWe8nExr88MMPbj2tSnrgmTx7cNC7gQRI2o9NkKFDnvusmn0Ce34ACIuk/fYgxGHnuuuuU08//bSerCAfCTsAooMfG/8ReAAkHb89CE3Yeemll9RTTz2lp5YeMWKE6tevn/r888/V999/r1auXKlbeh555BG1Zs0a9fDDD6sOHTq4s+cAAm25MLpSyg9S3AbJSstKkK07tOwAABCSMTsjR47UrTUvv/yyateunSpXrpy+/tBDD1WnnnqquvHGG9WiRYvUOeeco2644Qa1du1aN/YbgENuVeLpQhmNoCPvN2OBAABJVXDYmTt3rqpfv7468sgji3VTS+/SJmvr/OMf/1ClS5dWw4YNK/QpATjkdqVXAk/cWnWCbF3xIuhk+xsAgKQoOOxs27ZN1apVq+j/K1SooP9dv359sftVqVJFd3WbMWNGoU8JwAGvKrtxrkT7GXi8DDq5rgMAIM4KDju1a9dW69atK/r/OnXq6H/nz59f4r7ShW3jxo2FPiUAm7yu5Ma5Eu1H4PEj6Fi5DQCAuCk47DRt2lT99NNPRd3W2rRpo//+29/+Vmz66TFjxqgVK1aoRo0aFfqUAGzwq3Ib50q0l4HHz6Bj5z4AAMRBwWFHJh7YunWr+vjjj/X/9+zZU7fuTJo0SQehHj16qFNOOUX17t1bj+e5+uqr3dhvABb4XamNcyXai8ATRNABACBJCg47559/vrrnnnvUvvvuq/+/cuXK6t///rduwVm2bJkaN26cmj59up6c4NZbb1V9+/Z1Y78BhLTiG+cKt5vhJOigE+f3CQAA18LOgQceqAYOHKhOOumkouuOO+44tXDhQj0ZwdixY9WECRP0mjuXXnqpnr0NiIqoLmoWdEU26Of3khshJeigU+jjAABITNgx3fA++6gTTzxRd2vr1KmTDkVt27ZVzZs39+opAU9ELfCEpQIblv3wQiFhJSxBx63HAwCQyLBjJn39HSAqohJ4wlZxDdv+uMlJaAlb0HF7OwAAqKSHHacBafz48bqFSCY/2H///fWYoGuvvVZ3j8tFutN1795dHXDAAap69erq5JNPVm+//bZv+474CHvgCWuFNaz75QY74SWsQcer7QEAomPWrFmqQ4cOqkaNGvoif8+cObOgba5evVpddtllepmaqlWrqhYtWqgXX3zR9nak7l6xYkU1ZMiQeIYdma66ZcuW6rHHHlOXXHKJWrRokdqwYYOe9EDeDBkfNG/evKyP/frrr/VMcB07dlSrVq1Sv/76q55MQSZJePbZ6P+wx3XlesSvohr2/SuElRAT9qDj9XYBAOE1efJk1blzZz1j8i+//KIv8neXLl0cNxBIvfuEE07QMzNL3V3W5JS694gRI9SAAQMsb0fC0Zo1a/T+ORX6sCOFJbO4ffjhh6pbt256tjeZwvqggw7SweWaa65RN998c9bWIEmTst7PX/7yF1WuXDk9jujUU0/Vb2r//v3Vjz8SFhD91p2oVFCjsp9hXXjUwAKxAAC3bNu2TV1++eV6QjEJN2XKlNEX+fu1115TV1xxhV5ixq7rr79eb7dfv35qv/3203V3adl577331OjRo9WcOXPybmPjxo3q9ttv1wGpbNmy8Q07Mstbr169TG+/8cYb9Ro/27dvL3b9p59+qlOktAZlaty4seratasaOXKkiipadYITpsATtQARtf11I/C4GYRYIBYA4KZx48apJk2aqNNOO63EbW3atFFHHHGEDj12GyqmTp2qbrnllhK3yZASCUJPPPFE3u3cdddd6o9//KPuUleI0IedfGrWrKmqVaum1q5dW+z6KVOm6DE+0pqTjdwm6RKIauCJanCI6n5bkRlsohh0gno+AID/pkyZkrOLmJP6smzz9NNP1y06TrcpQ1RGjRqlHnroIVWoMnYf4GRgkWHHjh3KCzt37tTd29J9++23Od+8Vq1aqfnz53uyP0hO4AmqhS3qFVHZfz+7fvlJXpfbry/IBWLj+j4BAJSuL1955ZU568sSOuxuU8bbm5HWIul9JWPwq1SpkvU+0vojLUOHHHKI/2Gnd+/eut+dEzKOxuljzXz++eeqXr16unUn3fLly1XDhg1NH1erVi3d9W3Tpk2mydMIaOkhTfoPBi29gm1UrJAccXm/41yRjkPQScL7BABxlFlXLVeunL5kk6++XL9+fT1ZmB2yzWOPPdb0dskCBx98sN7uUUcdVeL2l156Sd92xx13KDfYDjvyot0OLIUMqurTp48e/JRp8+bNepo7M/IaZApruV+usDN8+HA1dOhQ1/YZ0TJ59uCgdwEAAMRMxTVKlXY+5j6rPTv/+68EiXSDBw82nbY5X31ZbpP72JFvm7m2K0HttttuU0899ZSqUKGCCiTsLFu2TIXB3r171Z///GfVoEEDdeGFF5a4XVpj8s3cICk3c2KDTDJrW/psb/ImZB5EfsrWbYrWHUQRrQXWyynI1h3eJwCIFlmDUk7oG8qZtOpYqS/LY2W4iJ3eWYXUwSWUHXPMMQVNNV1w2AkLWVBUmrg++OCDnG9OvjejfPnyOe+Tq+nPb7nGhwRdIQLsoAJtT1Cfb94nAIgeCTrpYScXo75sFk6M4GKnV5fTOriM9XnmmWfUl19+qdwUydnYpNuaLCr67rvvmnZBkwkL1q9fn3M70kqTObFBGEnIsTIQnooJooDjNBrlxvsEIMkzniZF5Tz1ZbnNbl3ZSh0823ZlUoK+ffuqww47TCU67AwbNky9/vrrelq7GjVqmN5Purfl6nInq8NKosw1XicM7M72RQUFYcbxGY3y430CgGRokKe+LL2oZLy+m9uULnHS1S59u7KWz6JFi9SgQYOU2yIVdmQBImnekoWK6tSpk/O+Mq1drtVZZ8+erZo1a6bCzOm0xlRUEEYcl9EoR94nAEiOIzyoL+fbpnRXk1mU06edXrhwoZ6OWmZYlskLMi9jx45V999/v/775JNPjmfYkWnopFXn/fff14kxn/bt26uJEyfq9JiN3HbmmWeqsCp0/RYqLAgTjsdolCfvEwAkS/v27dWbb75peruT+rJsU8bUm83ilm2b0qKzZcsW3b0t20UmI5NhLPL3J598Er+w89Zbb+mFhSZPnmy5H1/r1q11YhwzZkyJ25YsWaLGjRunrrjiChVGbi1UScUFYcBxGI1y5X0CgOTp1q2b+v7779W0adNK3DZjxgw1b9481aNHD1vblNaZdu3aqYceeqjEbdJ689hjj6nrrrtO+SX0YUcmIpBQIikw28JDZmTWiNGjR6vbb79dPffcc3rWB5muWt7MDh06qPvuu0/VrVs3tkHHQAUGQeL4i0b58j4BCAsmJ/BXhQoVdD25V69euoVn9+7d+iJ/d+/eXY0cOVJVrFjR9nYl0IwaNUo98MADuoVHelp98cUXukWnd+/eqmXLlsovoQ870m1NmqykcLL14TMuzZs3L/FYmadbws2kSZN0sJEJDQYOHKgeeeQRvRhp3IOOgYoMgsBxF41y5n0CgGTr0KGDmjBhgnryySdVrVq19EX+Hj9+vDr77LNNH3f00UfrRolsZE3KmTNnqgULFqhDDz1Uj9GRxguZbU0aHPxUKmU2qAWm01VL97h2x/VTZUqXD33QScc6PPALFWj/Ofl88z4BiGvLzu4929UHX96vNmzYYHnNGT/rkUf2uU+VLutePVLs2bldffPsgNC95qCFvmUnCfwIOoKKDTjO4svu55vvAwBAEhB2IrBYqJuo4IDjK76sfr75HgAAJAVhJyB+h5x0VHTAcRVf+T7ffP4BhBWTE8ALhJ0EtOZkQ4UHHE/xZfb55nMPAEgawk7CQk46Kj7gOIqvzM83n3cAQBIRdhIYctJRAQLHT3zx+QYAJF2ZoHcgrsIccLJViJiWGk6OG4Qf7xOAKGC8DrxCy07CWnLMUCECAABA3BB2XBTFkJOOwAMAAIIQ9ToUwouwk+DWnGwIPPCTdJ+kCyUAQMSlLoVwIewUKI4fTAIPrPavznXJJz3kEHgAAIAXCDsFiGPQMRB4UKhcQShbuCHwAADiXLdCMAg7DpVatlrFHYEHXpg8e7DpbQQeAACBB24i7AAIRdAxEHgAAIBbCDvIidYd+Bl0DAQeAEg2WnfgFsIO8iLwwM+gYyDwAACAQhF2YAmBB34GHQOBBwCSi9YduIGwA8sIPPAz6BgIPAAAwCnCDmwh8MDPoGMg8ABAMtG6g0IRdmAbgQd+Bh0DgQcAkonAg0IQduAIgQdBIPAAAAA7CDtwjMADv1p10hF4ACB5aN2BU4QdFITAk1xb6lcquvgVdAwEHgAAYAVhBwUj8EACj19Bx0DgAYBkoXUHThB24AoCT7JNH3drIM9L4AEAALmUyXkrEOHAE6aKsJRNmPYnDkEHAJDM1p3UIXWD3g1ECC07iK2whC9jP8KyP26GnDAEnbiGSABAdnRngx2EHcRa0AEj8/mD3p+4IvAAQLIQeGAVYQexF1TAMHteAo83CDwAkCwEHlhB2EEi+B0w8j0fgccbBB4ASBYCD/Ih7CAx/AoYVp+HwOMNAg8AJAuBB7kQdpAoXgcMu9sn8HiDwAMAyULggRnCDhLHq4DhdLsEHm8QeAAgWQg8yIawg0RyO2AUuj0CjzcIPACQLAQeZCLsILHcChgElXAj8ABAshB4kK5Msf8DEkaCSiGVYTeDTqH7AnNSroRSAEiOUstWqzCrtHqPKrPvHle3uXuXu9uLC1p2kHhhGmtDhdw7BEkAAJKHsAOEbBY1Ao93CDwAACQLYQcI4fo4BB7vEHgAAEgOwg5gI2T4GUIIPN4h8AAAkAyEHcBiyAgifBB4vEPgAQAg/gg7gIWQEWToIPB4h8ADAEC8EXaAPCEjDGEjDPsQVwQeAADii7ADRCRkhGlf4obAAwBAPBF2gAgh8HiHwAMAQPyUCXoHANgPPFTMEVVuHbsEfwCAFbTsABFERQ9R5GZIJ/ADAKwg7AARReBBlHgRTgg8AIB8CDtAhBF4EAVehhICDwAgF8IOEHEEHoSZH2GEwAMAMEPYAWKAwIMw8jOEEHgAANkQdoCYIPAgTIIIHwQeAEAmwg4QIwQehEGQoYPAAwBIR9gBYobAgyCFIWyEYR8AAOFA2AFiiMCDpIeMMO0LACA4hB0gpgg8SHq4COM+AQD8RdgBYozAAz8QKgAAYUXYAWKOwIMkB52w7x8AwFuEHQBArBF4ACC5CDtAAtC6g6SHiCjtKwDAPYQdICEIPEh6eIjiPgMACkPYARKEwIOkh4Yo7zsAwL4yDh4DIMLcDDxUHJMnDu+5vAaCPwAkA2EHgGNSYYxD5RfWxOm9DuNrIYABgPvoxgagIFTQkiGM4SBuKGMAcB9hB0DBCDzxRiWcsgaAqCLsAHAFgSeeCDoAgCgj7ABwDYEnXgg6lDsARB1hB4CrCDzxQNCh/AEgDgg7AFxH4Ik2gk448D4AQOEIOwA8QeCJJirY4cL7AQCFIewA8AyBJ1qoWIcT7wsAOEfYAeApAk80UKEON94fAHCGsAPAcwSecKMiHQ28TwAQ87CzceNG9dhjj6nDDz9c1atXz9JjFi5cqLp3764OOOAAVb16dXXyySert99+2/N9BVAcgSecqEBHC+8XAC/MmjVLdejQQdWoUUNf5O+ZM2cWtM3Vq1eryy67TNWuXVtVrVpVtWjRQr344os5H/Pdd9+pm266SR122GGqSpUqel86duyo3nnnnXiHnUWLFqlrr71WHXrooWrOnDnq3nvvtfS4r7/+Wp1yyim6kFatWqV+/fVXdc8996i+ffuqZ5991vP9BoAwo+IcTbxvANw0efJk1blzZ3X11VerX375RV/k7y5dujhuIJB69wknnKCaNm2q6/Hr1q3Tde8RI0aoAQMGZH3MX//6V3X66aergw46SL333ntqw4YNatmyZeqaa67ROUDq8E6UURHw1ltvqYMPPlgtWLBA1axZU7/wfFKplE6Tf/vb31Tv3r2Lrj/11FP1mypvwDnnnKPq1q3r8d4DSG/doaIWDrwP0X//aC0FUKht27apyy+/XI0dO1addtppRddL0JFeUeeff75avHixqlixoq3tXn/99Xq7/fr1K7pOWnYkxBxxxBGqa9euqmXLlsUeI88hdf3999+/6Lr99ttPnXfeebqlp3nz5uqSSy5RDRo0iF/Lzi233KL69++vg45Vn376qU6RUiiZGjdurAt55MiRLu8pgHyooAWPoBMPvI8ACjVu3DjVpEmTYkHH0KZNGx1MXnvtNdutOlOnTtX190wypESC0BNPPFHitmHDhhULOulkCMsZZ5yhpkyZouyKRNhxQgqjU6dOap99sr9EuU3SJQD/EXiCQwU5Xng/ARRaX+7cubPp7U7qy7JN6Y4mrTJubVM0a9ZMjwOyK7Zh59tvvy3RPJauVatWav78+b7uE4D/j8DjPyrG8cT7CiBM9eVv82xTWouk95WMybFjx44dqnLlysqu2Iad5cuXq4YNG5reXqtWLbV9+3a1adOmvAUrs8ClXwC4g8DjHyrE8cb7C8CQWW/dsWOH4/py/fr11YoVK2wVbr5tlipVSo/Ft7NdGYv/wQcfqLZt26pYTlDgxObNm/U0d7kKWvoFyv3MmtnE8OHD1dChQz3aSwBhmbQgzsErDOUL7zFpARAdlVZtUWVK73F1m7v3bNf/SpBIN3jwYDVkyBBH9WW5Te5jR75tOtnu3//+d3XggQfqSQrsim3YkRRbtmzZnPcpV66cbt3JRSZGuPnmm4v+XxJy5kEEINqBJ6xBh5CCII+ZsH4uAOS2cuXKYgP9y5Ur57i+LI/duXOnblmRhgI/6+CG8ePHqwceeEB9/vnnyonYhh3jzcn3ZpQvXz7vdnIdJACiHXjCWqEj6AAAnJCgYzarmVl92SycGMHFatBJ32ahdXDx4Ycf6ims33jjDdtTTsd+zI4MYFq/fn3O+0grjZOBTgCSFTz8RtBBGHAcAvFXOU99WW6zW1e2Uge3st3//Oc/qnv37mrMmDF6nUynYht2JP3lWnxUVoeVRJlrvA6AeAeeMIYrKpgIE45HIN4a5KkvyyQCMkmBm9uULnHS1S7XdufNm6fOOeccvR7Pn/70J1WI2IYdmdZuzpw5prfPnj1bz9cNIHz8CCEEHcAaAg8QX0d4UF/Ot02ZmrpatWqqSpUqWW//4YcfVIcOHdT999+vevbsqQoV27DTvn17NXHiRJ0es5HbzjzzTN/3C0DwYYSgA9hD4AHiW19+8803TW93Ul+Wbco00WazreXa5o8//qgff8cdd6i//OUvyg2xDTutW7fWiVH6+WVasmSJGjdunLriiisC2TcAwYUSgg7gDIEHiJ9u3bqp77//Xk2bNq3EbTNmzNDdyXr06GFrm/Xq1VPt2rVTDz30UInbZDHRxx57TF133XUlbvvtt9900JGQc+ONNyq3xDbsyKwRo0ePVrfffrt67rnn9KwPe/fu1W+mNI3dd999qm7dukHvJgAfwwlBBygMgQeIlwoVKuh6cq9evXQLz+7du/VF/pbJAUaOHKkqVqxoe7sSaEaNGqWnjJYWHulp9cUXX+gWnd69e6uWLVsWu79MQ33WWWep8847Tw0cONDFVxihsCN99mQBIrkcffTR6qeffir6f7k88sgjJR5zzDHH6HAzadIkHWxq1KihC1Du26dP+AYmA/AupBB0AHcQeIB46dChg5owYYJ68sknVa1atfRF/pb1bc4++2zTx0l9fPr06VlvkzUpZ86cqRYsWKAOPfRQPUZHelT17dtXNzhk+vnnn/U4n6effrpY/T7bRbZrR6mU2aAWmE5XLd3jTq92qSqzT+4FkwCEo5JF0AHcF8bPFWDYvXenmrruBbVhwwbLa874WY9sd1w/VaZ0/nVm7Ni9Z7v64Mv7Q/eagxaZlh0AcFK5CmOFjDPjiAOOYwBRQNgBECl2wgtBB/AWgQdA2BF2AESOlRBD0AH8QeABEGaEHQCRlCvMEHQAfxF4AIQVYQdAZGULNQQdIBgEHgBhRNgBEGnp4YagAwSLwAMgbAg7ACJPQg5BBwgHAg+AMCHsAAAAVxF4AIQFYQcAALiOwAMgDAg7AOCRMHatA/xE4AEQNMIOAHiIwIOkI/AACBJhBwA8RuBB0hF4AASFsAMAPiDwIOkIPACCQNgBAJ8QeJB0BB4AfiPsAICPCDxIOgIPAD8RdgDAZwQeAAD8QdgBgAAQeJBktO4A8AthBwACQuBBkhF4APiBsAMAAAJB4AHgNcIOAASI1h0kHYEHgJcIOwAQMAIPko7AA8ArhB0ACAECD5KOwAPAC4QdAAgJAg+SjsADwG2EHQAIEQIPko7AA8BNhB0ACBkCD5KOwAPALYQdAAghAg+SjsADwA2EHQAAEEoEHgCFKlPwFgAAABISeGh1BaKFlh0AAICIhi8AuRF2AAAAbCDwANFB2AEAALCJwANEA2EHsZM6pG7RBQAArxB4gPAj7CBWMgMOgQcA4CUCDxBuhB3EhlmwIfAAALxE4AHCi7CDWMgXaAg8AAAvEXiAcCLsIPKsBhkCDwDASwQeIHxYVBSRZjfAyP1LLf3Rs/0BACSbBB4WHkU+pZatVqX2KetqQZXau5OCz4KWHUSW05YaWnjih9n3AIQJLTxAeBB2EEmFBhYCTzxDDu8rgLAg8ADhQNhB5LhVoaViHG3Mvgcg7Ag8QPAIO4gUtwMK3Z+ix8p7xvsKICwIPECwCDuIXdDZUr9S0cXtbSN6E1IAQNAIPEBwCDuIXdDJ9f9uPAf8V0hLDe8rgDAg8ADBIOwgtkEn3/WFPBf848Z7wvsKIAwIPID/CDsINbcqqQSeaHIzpBB4AIQBgQfwF2EHoUXlFAAAAIUg7CARKq3YYuv+BK1wKLX0R5VUnP0FAKBwhB2EkpOwYTfQIFmiFJwIOgAAuIOwg9Bxu1XFaQiidSc+IYWgAwBAMpUJegcQnFyV+ShVDjODjZ3JCBANcjwmIXzSogMAgLsIOw6lGtZRqdLlXX0z3A4YhVQOnTzW2P8wVUoL7domryWqwS9unAaeqLx/BB0AANxH2AmRMIWEKO+/2607BJ7oIugAAJBshB3ElpsTFmQGuShUovOFzyi8hqR2ZwMAAO4g7CCWvJ6ZLb3C7XVo8Kpy7+drCCLwROU10X0NAADvEHaAELT6BN1aEdXgE3UEHQAAvEXYAVyWK/wEHWri0mUvX+tOGPc5E0EHAADvEXYAj0Uh4ESx1ccs8IRpH80QdAAA8AeLigKwTMKFcQmDKASbTAQdAAD8Q8sOgNi0+IRlP8wQdAAA8BctOwAi3eJjBByCDgAAyETLDoDIt/gQdAAAQDaEHQCJ6urmN7quAQAQHMIOAF8kMfgQdAAACBZhB4DvvBrbE6YQRdABACB4TFAQgC31KxW7AIjX1NgEHQB8RwDhQNjxWbZwQ/AB4hN8CDoA+K4AwoNubAEEnc0HlS66rvJPe7Lex1BpxRaf9g6IL7/GCxF0ANj9zjirZh8KDfAQLTsBBZ2ttVWJ4GP2OLq7IYzCcFw66RLqVWsPQQcA3x1A+NCyE2DQkX8r/vzf6zNbeHJtR9DigyClH4vZQoYXx6eVMCP3sfrcbrb2EHQAFPodQgsP4A3CTgBBZ0ftXfrvcj/vazvwZG5XEHzgJ6uhI5Pd49Rpq5GdwONG8CHoAHADgQfwBmEnoKAj5O9CAk/68xB44IdCuq3lCkBud4cr5DOR2cUtV/gh6ABwE4EHcB9jdgIIOtVqb9IXYVxndQwPEBQvxue4Me5HPjPGJXPbbs/qlj7eh6ADwAt8twDuIuwEEHQMRuiR2+Qi95NLtoqb1ecEvJDt+AoymJsFHK8CTyYqIwC8xHcM4B7CTgBB55gDfiq6pF9faCsPgSfegpr9LFfQMQsdXrHyXF4HnsmzB7u6PQDIhsADuCMRYWfWrFmqQ4cOqkaNGvoif8+cOTOwoCNOrvp9sf8n8MDKsZX5d5hadLwMPna361XgIegA8BOBB1GuK69evVpddtllqnbt2qpq1aqqRYsW6sUXX8z7uI0bN6qbbrpJ1atXTz/uiCOOUI888ojau3evo/2IfdiZPHmy6ty5s7r66qvVL7/8oi/yd5cuXdTbb78daNAh8MDOsZXvujB1XXMr+FjZhtH902gRTX+sm2VG0AEQBAIPolhXXrVqlTrhhBNU06ZN1aJFi9S6devUs88+q0aMGKEGDBiQM+i0bt1a7bPPPuqrr75S69evV+PGjVPvvvuuuvjiix3tS6lUKpVSMbVt2zbVuHFj9dJLL6nTTjut2G3Tp09X559/vlq8eLGqWLGi5W3Km1ClShXV7rh+qkzp8o6CzhkVF+u/39/aWP/7yfrD9L9frz1I/7vu5/30vzJTm5CZ2oTdmdqYoS368lXQvXqPvRqjY+UYtvo8meHGYHxezJ7TaZkRdgAEiXV47Nm9d6eauu4FtWHDBrX//vursDDqkadXu1SV2ads4K95mwd1ZSHh6dhjj1VDhgwpdv3vv/+uW2omTpyoWrZsWeJx0qIjAef5558vdv3OnTtV8+bN1dChQ1W3bt1s7UusW3YkCTZp0qTEmyfatGmjC/u1114r6DmcBh1h/E0LT/HyZOxR8WPLyvEXRNAxCxtOW2qstgRla8XJtV9utPAQdAAEjRYeRKWuvGrVKjV16lR1yy23lLitevXq6vrrr1dPPPFEidt27NihRo0ape66664St5UtW1b1799fPf7448quWIedKVOm6GRpplOnTuq9994LJOgYCDzmZUvosXccBhF0zLqQ2enm5kbISV+/Kn3/0p/PaZkRdACEBYEHUagrT5kyRZ1++ulqv/32s7XNGTNmqEMPPVQ1atQo6+POPfdc9dlnn6mtW7fa2p9Yh51vv/02axOZoVWrVmr+/PmOtr2lXuFBx6/AExVBjU0JI7uv241yKrRFx0nosSJfyDE+H04CT75yI+gACBsCD8JeV/42zzaltUjG8Eh3OzuPk+5/hxxyiB4DZEcZFWPLly9XDRs2NL29fv36asWKFY637zToNKy3Wv+7bFWdouvMwtDX6n/jeJSRjv87jkep0pbHQBSymnwYRH3/7Qrb9NLprIQZ4z6ZY2fsyvVcmcEm83pjvFvmvhivKf1zY3Z8EXQAhDnwMIYHYa0rL1++XI/XMVOqVCl18MEH6+0eddRRlvclfX+OOeYYy/sT67CzefNmPWWdGblN7pOL9B+Ui8FIoRtr7FKld25XW2sppbYrtXfbLlX1wM1qz1aljqyxWu3crNRJVRerbZuV2rTn/0+V16DuIj04TVTff6H+d/mPTYpu37Ztt/535+ad+t89W//73Hu3/bfytmf7fytpe/57s9q9y9qkBRvqlFaVVoU7MOzeVTrS++8G3WK4a7ujxzoto2zPuaVOaaV2ZrSU/O9Yt2rT/z56FdfY3qWcz7XzwF1Kbcv9eONzUvT///u8GDI/N7v3FH+yCR/1L/qcAkAYyWB05Cif1H/LJ6zzcOn92+vBNv83CUK6cuXK6YtXdWW72zTbrvx/gwYNbD8u0WFHQooMaDIjb7zM7iAfBEmZ2QwfPlzP/JBpwfN3l7hu1f/+/eZ//76cdYtV8uy1UTN0fx2g0Psy6B1IaBlQ7iVUqXJ/AG8EAMBtv/32m+7+FBZSL5V1Z6b9/C9Ptl+5cmXdapJu8ODBJWZFc7OubHebxna3b9/uyuMSHXaMN8is4IxCzfXmycwPN998c9H/y3R4kjqlCS1MH564kLMR8iFduXJlqKaKjBPKmPKNOo5hyjfqOIa9Jz1xpMuTzP4VJuXLl1dLly7V9VMvZAsl5UxaddyqK5ttMxfZrpSFG49LdNiRdCvhRP7NJtdt+Zr+JOhQGfeOlC3l6y3KmPKNOo5hyjfqOIa9J4tTho1U1u1W2MNcVzbbZi7Ztuv0cfmE7whwkbTALFu2zPR2aZ2R1A8AAAAkTQMP6sr5timtT9KDJ3O7+R7ndH9iHXZkars5c+aY3j579mzVrFkzX/cJAAAAiGtd+Yg825QppqtVq1ZiOEi+x0n3TwlDsgiqHbEOO+3bt1dvvvmm6e0TJ05UZ555pq1tSpc2GeiVq/8jnKN8vUcZU75RxzFM+UYdxzBlHOe6cvv27dUHH3xgOmua2TZPOukktWTJEj2mKZtJkyapE088UVWsWNHW/pRKhXVOPhds27ZNNW7cWI0dO1a1bdu2xCqt3bt3V4sXL7ZdaAAAAEDUbfOorty5c2fVvHlzdddddxW7XhYTlRact956K+sCojfddJNuwXnuueeKXb9r1y7VokUL3eDQrVs3W/sS65adChUq6MLq1auXTq27d+/WF/lb3ryRI0cSdAAAAJBIFTyqKz/22GNq1KhR6oEHHtAtPNK28sUXX+gWnd69e2cNOkKWe5Guc7feequeNlx8//336rzzztMLkNoNOrFv2THMmjVLJ0spPNGqVStdmNIUBgAAACTZLAd15aOPPlo9+eSTqk2bNllvX716tRowYIB6++239ZTRjRo10i03l1xySd5pw2Vfxo0bp4PSQQcdpK688kp14403OppdLxFhBwAAAEDyxLobGwAAAIDkSkzYkQas8ePHq06dOqk6derohbykOe3aa6/Vc32bkRVjq1atmvVy0UUX5XxOab677LLLVO3atfX9ZWDViy++qOLIafkaJk+erM4991xVq1YtXVZNmzZVV199tVq4cKHpY5JUvk7K+KeffjI9do2L9MM97bTTTJ+TMrZ+HEv/5lNPPVVPpbnffvupQw89VDe5G32OKePCvic++ugjdfrpp+vpSuV7ol27dur999/P+7lJ2jEsA3uln3yXLl3UwQcfrMtYjkmZ5Uj63ufqzCHft9JH/4ADDtCrzp988sm6+0k+lLH1Mt6+fbt6/vnn9XgFqV/I2AgrklTGTo9h+T648MILVb169fR3sPwr3aXmz5+f9zmTVL6JlEqA5cuXp5o3b5469dRTU6+//npq06ZNqb1796Z+/PHH1KBBg1I1atRIzZ07N+tjpYh27dpl+zlXrlyZOvjgg1PDhw9Pbdy4UT/fnDlzUi1atEj1798/FSeFlK+47bbbUkceeWRq3LhxqQ0bNhSV36OPPpp64403UkkvXzfK2EyfPn1SN910U9bbKGPrZfzggw+mGjdunJo4cWJq8+bN+nFLly5NXXvttalGjRqlfvvtt8SXcSHH8NixY1N169ZNjR8/PrVz5059nXzeW7dunXrhhRdMj++kHcOiY8eOqauuuir14YcfprZt26av+/XXX1MvvfRSqmHDhvq2bL766qtUrVq1UiNHjkxt3749tWfPHr0NOX6feeYZ0+ejjK2VsRznd9xxR+rAAw9Mde7cOfX+++9brl8krYztHsPr1q1LnX766aljjz029fzzzxd9365Zsyb18MMPp6pVq6bL20zSyjeJEhF2Pv30U/1jaUZ+aM844wxXw06nTp1SgwcPLnG9fAhr166dmj17diouCinf0aNHp1q2bJlav369redMUvkWWsZmpEJTtWrV1BdffJH1dsrYWhnLj3DlypVT8+fPz1qOPXv2TN11112JL2Onx/DatWtT1atXT3355ZclbpNgKSdKVq9enfjyNezYscO0jJctW5aqUKFCiVAplbvjjjtOfx9nWrRokS7/VatWUcYFlPGYMWNS/fr106Hfbv0iad/Fdst38eLF+uSoBPRsJMDLySgzSSvfJEpE2MlHfkzLli1bdAah0LAjZwmk8iNnCLK59957U717904lvXx3796dqlevnj6jaAfla72Mc3n11Vd1RZEyLqyM33zzzVSzZs1MH/fKK6+kzjzzzBLXcxxbK99HHnkk1aVLF9Pyffzxx1N33nkn5WvRWWedlRoxYkSx6z755BN9xtyssnjFFVekhgwZQhkXUMbZWKlf8D3hvHzT6xpyYk+CO+WbTIkZs5NLzZo1dT/wtWvXurK9KVOm6L7l0mc0G+mv/t5776mkl6/0wW/WrJk65phjbG2P8rVexrlIf2Sz6R8pY+tlLNNp5uqjv3fv3qxrFFDG1spXpkOVvvpm5DZZjZvytaZcuXJ63EjmsSi/S2ZTupr9ZnEMWy9jpyjjwsu3dOnSehywjMuhfJOJsPM/O3fuVJUrV3alUL/99lvTxZKErBwrK8jKPOJJLt+ZM2eq1q1b294W5Wu9jM1IhVJ+RM0m2aCMrZexBHZZ8EzKLBtZJ6B9+/aUscPylWNVQpAZuW3evHl6dW2O4dzkd0dWRJdj1k5ZyXob2QZ58z1hvYydoozdKV85KZXt95HyTQbCjlLq888/17N2mP2gdujQQdWoUUPPBiIzLMnKr3PnzjUt1OXLl6uGDRua3i4zsMgMIytWrFBJLt/vvvtOl9OmTZv04lGyOJWUs3yJ3X333Wrbtm1Zt0f5Wi9jM2PHjlVt27bVC3VRxoUdx3LyomPHjupPf/qTnmlMfoxlhiU5vq+44gr9IyuLoXEcOyvfSpUqqd9//930cXLbnj171LJly4pdz/dE8TKaNGmSDt0y29RZZ51lq6xk9js5ky7f1ZSxszJ2iuO48PL9+eef9eykRx11FOWbUIkPO1Kh7tOnj+rXr1/WApJKzHXXXaeWLFmiKzFyNrxJkybqlFNO0RXGbGS1V5m6MBe5Xe6X5PKV8pTm6DPPPFNVqFBBTZ06Vf3666/qjTfe0GcRZWrZbIGH8rVexrm6sF188cWmt1PG9sr4X//6l/rjH/+ounXrpqfsleP5D3/4g+6CJVOl7rvvvpSxw/KVVoXp06ebPta4LbOlPOnH8OOPP140vbycRJKp/Rs0aKCn+ZduPXbKSk7QyfS/mWVFGVsvY6eSXMZ2juFc3YjlpJMsA1CmTJkStye5fJMk0WFHPgR//vOf9YdH5mbPRtYY6Nq1q27Vkf7MsibEwIED1bvvvquuueYafdYlk5zJLVu2rG99eqNavlLB+b//+z/dlap///56bQf5UT3ssMPUyy+/rA488EA1aNCgEo+jfK2XcTYSJKXblRzXZihje2UsZx3lO0LOPG7dulV3x1qwYIE6/vjj9UXOKlLGzspX1r6Q8X1z5swpcZu0NIwePVqfgMr8Pk36MXz99der9evX60qa9CKQExzyeyUn7DI5LSvK2HoZO5XkMrZzDJu5+eabdVfY2267LevtSS7fJEl02JGF7OQD9MILL9h+7Iknnqh69eqlF77K9sGQyk4u8gErX768SnL5yuuXLy5ZPDQb6dr2zDPPlChLytd6GWcjPxjSApFt0DxlbP84lh9i+S6Qrpdnn322btWR0H744Yfr7wdpHR4wYABl7LB8paultI6dd955+iSInCSRbmvSb/+MM85Qd9xxh54MJvN45nviv+QknXSblpZcWXRRjtNPP/3UlbKijK2XsVOUsfPyHT58uHrrrbd0b5FsreuUb3IkNuxIdwnp/iAtNGazpuUjfUe//PLLEtfLIDg5G5GL3O7WhAhRLV85Ey6hMVvTsjjuuOP0vzL2IR3la72Ms51F/+c//2k6CxtlbP84fvrpp/W4PplNLBtpnXzllVd02VPG9stX9OjRQ0/08NJLL+kWILncc8896sEHH1Q9e/bULWuZXVH4nihJyuiGG27Q3YPslpWsap/5m0UZWy9jpyhjZ+X71FNP6ftIK1CdOnUo34RLZNgZNmyYev311/WHQPqBOiU/zlu2bClxvfwQZw6WTSfT1K5cuVLVr19fJbl8ZbIHGd9gRs6OZ+srm/TyLeQY/uCDD3S5nnrqqTnvRxlbL2MZl2ME82zq1q2rvytkkCxl7PwYljFR//73v9WaNWvUqlWr1DvvvKNOPvlkPQubhB05Zinf/KTFMXNmtXyf919++UW36mQGUr4nrJexU5Sx/fIdM2aMGjJkiP5ukXoG5YvEhZ0nnnhCd42SwfC50r4V8oMrs9RkktmZsvUvT5/qUGYckpaNJJdvixYtcp5NlNAit8tYnnRJLt9Cj2HpwibjI8zW0zBQxtbLWMaNSIDMRW7PbMFMchm7+T0sZSgzOWYOWE5y+eY7XqUboJ2ymj17dtapfilj62XsFGVsr3zffPNN9de//lWfDLEyPTXlmwyJCjvSBULOJkqfz8yzgE7IhyrbYnfSvU3OoJvN3iEL4MkMZEkvX1l4VabwNvvSktvkbGLjxo2LXZ/U8i30GJZWyAkTJuTtwiYoY+tlLFP2ZuvOapDJCWQq6szQntQydvt7WLqyZZvYIKnlm8/HH3+sz4xnlpWUh9niuGZlRRlbL2OnKGPr5Suf97/85S96nE7z5s0pX/x/qYR48803U7Vq1UrNnTvXle2NGzcuVa1atdTvv/+e9fZOnTqlhg4dWuJ6uX+dOnVSs2fPTsWJ0/K96aabUk8//XTW27p3754aOHBg1tuSVr5uHMMvvPBCqlWrVpbvTxlbM3ny5NRBBx2U+u2337Lefs0116T69OlDGXvwPTx27NjUYYcdltq+fTvlm0qlfvjhh9TSpUtNy+ubb75JVapUKfXGG28Uu37v3r2p4447Tn9HZNtmjRo1UqtWraKMCyjjbKQKtmvXrrz3S9J3sdPynTVrVqpmzZqp999/3/ZzJql8kyoRYeeTTz5JHXDAAfrDYMdTTz2VGjNmTOrHH39M7dmzR1+3ZMmSVP/+/VP77bdfatKkSaaPXbFiRap+/fqpv/3tb6lNmzbpH5PPP/881bJlS/34OHFavkLKpkWLFqmHH344tXHjxqKy6927d+r4449Pbd26NZX08i20jA2nn3566rHHHrN8f8rYuj//+c+po446KjV16tTU7t279XXygy0hp1GjRqk1a9YkvowLOYavv/761PTp0/X3gXwXL1q0KHXzzTenGjRokFq4cCHHcFpF8OCDD04NGTJEl5F8LwoJKo8++miqatWqqauuuipreX311VepAw88MDVq1CgdHqWcP/roo1Tjxo1TzzzzDGXsQhk7DTtJ+i52Ur7yHSDH7ltvveXoOZNUvkmViLAzePDg1L777puqUqVKzouc2Ur3zjvvpHr27Jlq0qSJbsWRgNOwYcPUFVdckfruu+/yPu9PP/2kK+1yJtPYfrYzZ0ktX4OEnFtuuUWXrXyRSQXmjjvu0F86uSSlfN0oY/mhKFeuXGrt2rW2npcytlbG8uMoLZQnnHCCPoblfhJy/vrXv+Yt86SUcSHH8BNPPJFq27atLqP9998/dfjhh+tKyLp16/I+b1LK1yDH27Bhw3RFzfjdkrPTf/rTn1Ljx4/P+Vj5XevatatuyZHjuHXr1ql///vfeZ+TMrZWxrfddluxY13CTvr/y/cFZWz/GB49enSqdOnSeb9b5LimfJOplPwnrVcbAAAAAMRCoiYoAAAAAJAchB0AAAAAsUTYAQAAABBLhB0AAAAAsUTYAQAAABBLhB0AAAAAsUTYAQAAABBLhB0AAAAAsUTYAQAAABBLhB0AAAAAsUTYAYAE++ijj1SpUqXUqaeeqsIijPsEAIgmwg4A2NCwYUNdEX/++edjX25DhgzRFwAAooqwAwAJVrFiRdW0aVNVv379ErcNHTpUXwAAiKoyQe8AACA4xx9/vPruu+94CwAAsUTLDgAAAIBYIuwAgIdWrFihrrnmGnXIIYeocuXKqZo1a6qOHTuqd955J+v9ZYyMjAmSfzds2KBuuukm3cVMHtu4cWN1zz33qN27d2d9bCqVUk8//bQ65phjVIUKFdSBBx6oLrzwQrVkyRI9xki227t377yTARj7YJC/0y/Lli0rsa/ZmD2nYcKECeqkk05SlSpVUjVq1FDnnnuumjNnTt4y/f3339XAgQPVkUceqR+73377qRNPPFH94x//UHv37s37eABActCNDQA8MmvWLHXWWWep9evX60r5UUcdpX755Rf17rvv6sudd96p7r777qyPlaDzxz/+US1atEhX6kuXLq1++OEHddddd+kAJRX7TFdccYV67rnn9N8SrqpXr64DhTzXddddZ3m/JVy1bt1affrpp/r/5e905cuXV4V64IEH1B133KH/rlOnjjrooIPUtGnTVJs2bdSgQYNMH/ftt9+qDh06qB9//FGVLVtWB8AdO3ao//znP7q833vvPfXqq68WC2sAgOSiZQcAPLB161Z1/vnn66Aj/65evVq3WqxcuVK3eEh4kVYasxaeJ554Qh1wwAFq+fLl6ssvv1RLly5Vb731ln7cyJEjS4yzef3113XQkRagN954Q7fmyPNJKGjVqpX629/+ZnnfL7/8cjV9+vSi/5e/0y+1a9cuoGSUfj0DBgzQgeTxxx/X+yj7KmXUuXNn0wC4ZcsW1alTJ33/G264Qa1du1aHn8WLF6tvvvlGHXHEEbocnnzyyYL2DwAQH4QdAPDA2LFjdQuMdCV74YUXdFcrw6WXXqquuuoq/ffw4cOzPr5MmTLqn//8p27xMPzpT3/SlX2RGZL+7//+T/8rrUXGfYS07rz88su6ZSksHnroIbVnzx7VvXt33eJktMJUrlxZB8Fq1aplfZyEOWnd6tKli3r00UfV/vvvX3Rbs2bNdJnLtmT7AAAIwg4AeEC6U4krr7wya7evG2+8Uf87Y8YM3WKRSbq/1atXr8T10kojpOXGsGnTJt2FS1x22WUlHiPhQVpMwlY2MpYpk5SVtCxlM378+KLuetkcffTReh0kKZtVq1a5us8AgGhizA4AeOD7778vanHIpkmTJnrMyc6dO3VrhVTU0x166KFZH1erVi397+bNm4uuk25cMjmBDPJPbwlKl7n9oEi3vjVr1ui///CHP2S9j9n18+bN0//KuKX77rsv631+/fVX/a90dcsWFgEAyULYAQAPGGHECCeZpLuVjMmRSrm0zGQy63a2zz7/bZCXcGMwWobSu8plynWbn9JDmrz+bKTrn9mkDeLzzz/P+zzbtm1zvI8AgPigGxsAeEDGnwijFSOThBUZYO9GEDGCUXqQyJQtUBXKGGuTHrzSZeueZ5SLMF5/JrMyMx4rM9TJc+a6pE+lDQBILsIOAHjgsMMO0//Onz8/6+1SYZcubDK7mlmXNatk+mVp8ZEuXDKjWa4uYG4yQpZZaJHudZmqVq1a1NqVOaOcYcGCBVmvN7oEysxrAABYQdgBAA/IWjBC1sPZvn17idtHjBhRtIZNoTOlScvQCSecoP+W2cyydf+S6ajtkoVJc3UJa9Sokf539uzZWVt1ZBa4bNq3b6//lQVQM8maOcZaQZm6du1aVHZmrUkAAKQj7ACAB3r16qUX55RFRHv37l2si9lLL72knnnmGf13v379XHm+m2++Wf8ra/dMnDix6Pp169apnj175uziZsYIM7LYZzannXaanj1N1sh59tlni01CIK/5t99+y/q4v/71r7olShb/lMBjBBcJSDIT2++//571cTJdt+zThx9+qC666KISrVjyGmWbRlkAAEDYAQAH+vbtq2rWrGl6kemPpeJdpUoV9corr+iFOGXaaAlAF198sdq9e7caNGiQ6tixoyvlL2vWSFCQVpjzzjtPd42T56tbt66elvr222/X95Nuc1ZdcMEF+t9zzz1XNW/eXI+DkcvPP/9cNKX1wIEDi4KIzH7WsmVLPSPcJ598UnRbphYtWqh7771XhxyZfloeJ/tap04dNW7cOD3bmtmYnUmTJqlDDjlE/etf/9KPk65tJ554omratKnuIif7LNN5AwAgmI0NAByQVoRcrSUSZqRr2ddff60XDn333XfV3LlzdZe1M888U6+zc/bZZ7ta9tJlTsLGU089pae+lkkJZCHSYcOGqcmTJ9ueDEFanWTxT+mOJmOPpIuZSO+WJ4FNFi594okn9BidXbt26eAlU0O///77ptvu37+/Htf097//XZeLhLSTTz5ZDR06NGe5Hn744bpMn3zySTVhwgQ9vkeCpQSltm3b6jLt1q2b5dcIAIi3Uik6PgNAIlqiHn/8cfXwww+rm266KejdAQDAF3RjA4CYk5aS119/vWhCBAAAkoKwAwAx8cgjj6ivvvqq2HWyaKl065JxNjLuRsbGAACQFHRjA4CYkMkDZOY0mRRBZi2TMTayls3evXv1pAkyi9mRRx4Z9G4CAOAbJigAgJiQSQ9khrQvvvhChxwZkimzssmMbzIbm8zMBgBAktCyAwAAACCWGLMDAAAAIJYIOwAAAABiibADAAAAIJYIOwAAAABiibADAAAAIJYIOwAAAABiibADAAAAIJYIOwAAAABUHP0/7Jb0rM9asoMAAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
    " ] @@ -824,7 +824,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
    " ] @@ -836,7 +836,7 @@ "source": [ "plt.figure(figsize=(10,6))\n", "plt.plot(np.arange(12)+1,diff_LNB.mean(dim=['lat','lon']),color='k',lw=3)\n", - "plt.xlabel(python_in_ds.month.standard_name)\n", + "plt.xlabel(python_in_ds.month.long_name)\n", "plt.ylabel('LNB Difference (hPa)')\n", "plt.title('Monthly Average LNB Difference (Python$-$MATLAB, hPa)')\n", "plt.grid()\n", @@ -858,7 +858,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
    " ] @@ -1127,9 +1127,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python (attribution-dev, pixi)", + "display_name": "tcpyPI (pixi)", "language": "python", - "name": "attribution-dev-pixi" + "name": "tcpypi-pixi" }, "language_info": { "codemirror_mode": { @@ -1141,7 +1141,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.13.9" + "version": "3.14.2" } }, "nbformat": 4, diff --git a/pixi.lock b/pixi.lock index 5d189fe..c79b071 100644 --- a/pixi.lock +++ b/pixi.lock @@ -1,5 +1,801 @@ version: 6 environments: + bench: + channels: + - url: https://conda.anaconda.org/conda-forge/ + indexes: + - https://pypi.org/simple + packages: + linux-64: + - conda: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-20_gnu.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/_python_abi3_support-1.0-hd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/alsa-lib-1.2.16.1-hb03c661_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/asttokens-3.0.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-auth-0.10.3-hdc83ae9_4.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-cal-0.9.14-h6e18c7b_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-common-0.14.1-hb03c661_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-compression-0.3.2-haaf8e00_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-http-0.11.0-h434eaf2_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-io-0.26.3-ha0b0e19_6.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-s3-0.12.6-hd767fb6_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-c-sdkutils-0.2.7-haaf8e00_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/aws-checksums-0.2.10-haaf8e00_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/brotli-1.2.0-hed03a55_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/brotli-bin-1.2.0-hb03c661_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-hda65f42_9.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/c-ares-1.34.6-hb03c661_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.6.17-hbd8a1cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cached-property-1.5.2-hd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cached_property-1.5.2-pyha770c72_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cairo-1.18.4-he90730b_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/comm-0.2.3-pyhe01879c_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/contourpy-1.3.3-py314h97ea11e_4.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cpython-3.14.6-py314hd8ed1ab_100.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cycler-0.12.1-pyhcf101f3_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cyrus-sasl-2.1.28-hac629b4_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/dbus-1.16.2-h24cb091_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/debugpy-1.8.21-py314h42812f9_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/decorator-5.3.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/double-conversion-3.4.0-hecca717_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.3.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/execnet-2.1.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/executing-2.2.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-dejavu-sans-mono-2.37-hab24e00_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-inconsolata-3.000-h77eed37_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-source-code-pro-2.038-h77eed37_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-ubuntu-0.83-h77eed37_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/fontconfig-2.18.1-h27c8c51_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/fonts-conda-ecosystem-1-0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/fonts-conda-forge-1-hc364b38_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/fonttools-4.63.0-pyh7db6752_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/freetype-2.14.3-ha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/fribidi-1.0.16-hb03c661_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/graphite2-1.3.15-hecca717_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/h5netcdf-1.8.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/h5py-3.16.0-nompi_py314hddf7a69_102.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/harfbuzz-14.2.1-ha770c72_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/hdf5-2.1.0-nompi_hc8ae080_109.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/icu-78.3-h33c6efd_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.3.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ipykernel-7.3.0-pyha191276_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ipython-9.15.0-pyh53cf698_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ipython_pygments_lexers-1.1.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jedi-0.20.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_client-8.9.1-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_core-5.9.1-pyhc90fa1f_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/keyutils-1.6.3-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/kiwisolver-1.5.0-py314h97ea11e_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/krb5-1.22.2-hbde042b_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/lcms2-2.19.1-h0c24ade_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.45.1-default_hbd61a6d_102.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/lerc-4.1.0-hdb68285_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libaec-1.1.5-h088129d_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libblas-3.11.0-8_h4a7cf45_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libbrotlicommon-1.2.0-hb03c661_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libbrotlidec-1.2.0-hb03c661_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libbrotlienc-1.2.0-hb03c661_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcblas-3.11.0-8_h0358290_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libclang-cpp22.1-22.1.8-default_h6c227bf_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libclang13-22.1.8-default_h9692865_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcups-2.3.3-h7a8fb5f_6.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcurl-8.21.0-hae6b9f4_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libdeflate-1.25-h17f619e_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libdrm-2.4.127-hb03c661_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libedit-3.1.20250104-pl5321h7949ede_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libegl-1.7.0-ha4b6fd6_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libegl-devel-1.7.0-ha4b6fd6_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libev-4.33-hd590300_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.8.1-hecca717_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libffi-3.5.2-h3435931_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libfreetype-2.14.3-ha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libfreetype6-2.14.3-h73754d4_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-15.2.0-he0feb66_19.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-15.2.0-h69a702a_19.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-15.2.0-h69a702a_19.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran5-15.2.0-h68bc16d_19.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgl-1.7.0-ha4b6fd6_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgl-devel-1.7.0-ha4b6fd6_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libglib-2.88.2-h0d30a3d_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libglvnd-1.7.0-ha4b6fd6_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libglx-1.7.0-ha4b6fd6_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libglx-devel-1.7.0-ha4b6fd6_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-15.2.0-he0feb66_19.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libharfbuzz-14.2.1-h17a8019_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libharfbuzz-devel-14.2.1-h17a8019_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libiconv-1.18-h3b78370_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libjpeg-turbo-3.2.0-hb03c661_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/liblapack-3.11.0-8_h47877c9_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libllvm22-22.1.8-hf7376ad_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/liblzma-5.8.3-hb03c661_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libmpdec-4.0.0-hb03c661_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libnghttp2-1.68.1-h877daf1_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libntlm-1.8-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenblas-0.3.33-pthreads_h94d23a6_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libopengl-1.7.0-ha4b6fd6_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libpciaccess-0.19-hb03c661_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libpng-1.6.58-h421ea60_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libpq-18.4-hd5a49e9_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libpsl-0.22.0-hd9031aa_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libraqm-0.10.5-h6406941_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libsodium-1.0.22-h280c20c_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.53.3-h0c1763c_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libssh2-1.11.1-hcf80075_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-15.2.0-h934c35e_19.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-15.2.0-hdf11a46_19.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libtiff-4.7.2-h9d88235_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.42.2-h5347b49_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libvulkan-loader-1.4.341.0-h5279c79_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libwebp-base-1.6.0-hd42ef1d_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libxcb-1.17.0-h8a09558_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libxcrypt-4.4.36-hd590300_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libxkbcommon-1.13.2-hca5e8e5_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libxml2-16-2.15.3-hca6bf5a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libxml2-2.15.3-h49c6c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libxslt-1.1.43-h711ed8c_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.2-h25fd6f3_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/llvmlite-0.47.0-py314h946fb2a_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/matplotlib-3.11.0-py314hdafbbf9_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/matplotlib-base-3.11.0-py314had63eae_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/matplotlib-inline-0.2.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/munkres-1.1.4-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.6-hdb14827_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nest-asyncio2-1.7.2-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/numba-0.65.1-py314h8169c2f_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/numpy-2.4.6-py314h2b28147_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/openjpeg-2.5.4-h55fea9a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/openldap-2.6.13-hbde042b_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.6.3-h35e630c_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pandas-3.0.3-py314hb4ffadd_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/parso-0.8.7-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pcre2-10.47-haa7fec5_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pexpect-4.9.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pillow-12.3.0-py314h8ec4b1a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pixman-0.46.4-h54a6638_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/platformdirs-4.10.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.6.0-pyhf9edf01_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/prompt-toolkit-3.0.52-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/psutil-7.2.2-py314h0f05182_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pthread-stubs-0.4-hb9d3cd8_1002.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ptyprocess-0.7.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pure_eval-0.2.3-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pygments-2.20.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pyparsing-3.3.2-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pyside6-6.11.1-py314h3987850_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-9.1.1-pyhc364b38_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-xdist-3.8.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/python-3.14.6-habeac84_100_cp314.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python-dateutil-2.9.0.post0-pyhe01879c_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python-gil-3.14.6-h4df99d1_100.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pyzmq-27.1.0-py312hda471dd_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/qhull-2020.2-h434a139_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/qt6-main-6.11.1-pl5321h16c4a6b_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/readline-8.3-h853b02a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/s2n-1.7.5-h7e3ee7f_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/six-1.17.0-pyhe01879c_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/stack_data-0.6.3-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/tk-8.6.13-noxft_h366c992_103.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/tornado-6.5.7-py314h5bd0f2a_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/traitlets-5.15.1-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.16.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/unicodedata2-17.0.1-py314h5bd0f2a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/wayland-1.25.0-hd6090a7_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/wcwidth-0.8.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/xarray-2026.7.0-pyhc364b38_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xcb-util-0.4.1-h4f16b4b_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xcb-util-cursor-0.1.6-hb03c661_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xcb-util-image-0.4.0-hb711507_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xcb-util-keysyms-0.4.1-hb711507_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xcb-util-renderutil-0.3.10-hb711507_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xcb-util-wm-0.4.2-hb711507_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xkeyboard-config-2.48-h280c20c_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libice-1.1.2-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libsm-1.2.6-he73a12e_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libx11-1.8.13-he1eb515_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxau-1.0.12-hb03c661_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxcomposite-0.4.7-hb03c661_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxcursor-1.2.3-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxdamage-1.1.6-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxdmcp-1.1.5-hb03c661_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxext-1.3.7-hb03c661_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxfixes-6.0.2-hb03c661_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxi-1.8.3-hb03c661_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxrandr-1.5.5-hb03c661_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxrender-0.9.12-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxtst-1.2.5-hb9d3cd8_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxxf86vm-1.1.7-hb03c661_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-xorgproto-2025.1-hb03c661_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/zeromq-4.3.5-h09e67af_11.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/zlib-ng-2.3.3-hceb46e0_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/zstd-1.5.7-hb78ec9c_6.conda + - pypi: https://files.pythonhosted.org/packages/ef/2f/c5464532e965badff2f4c4c1a3a83f5697f0d7c407ed0cda44aaa99bb451/certifi-2026.6.17-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/7f/89/648397f9936e0b330999c4e776ebf296ec3c6a65f9901687dbca4ab820da/cftime-1.6.5-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl + - pypi: https://files.pythonhosted.org/packages/f4/c4/b3e049d2aa3766180c78507110543d9d50894cc97f57de543f1be521dcdc/charset_normalizer-3.4.9-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl + - pypi: https://files.pythonhosted.org/packages/fb/e2/79c688af8b210d232694e31e59da9f6ec747bae31c3f5946e4e9b98860d5/click-8.4.2-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/88/39/799be3f2f0f38cc727ee3b4f1445fe6d5e4133064ec2e4115069418a5bb6/cloudpickle-3.1.2-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/90/aa/ceeb81d9dc886d445416310f0eff5c3978f20224b4143e96e36b7e85b011/dask-2026.7.0-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/27/cd/c883e1a7c447479d6e13985565080e3fea88ab5a107c21684c813dba1875/flexcache-0.3-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/fe/5e/3be305568fe5f34448807976dc82fc151d76c3e0e03958f34770286278c1/flexparser-0.4-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/e5/22/4222d7ddf3da30f363edaa98e329c2bce6c65497c9cb2810931c8b2c0fbc/fsspec-2026.6.0-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/1e/5e/d4e9f1a599fb8e573b7b87160658329fbf28d19eac2718f51fc3def3aa5a/idna-3.18-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/7b/91/984aca2ec129e2757d1e4e3c81c3fcda9d0f85b74670a094cc443d9ee949/joblib-1.5.3-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/db/bc/83e112abc66cd466c6b83f99118035867cecd41802f8d044638aa78a106e/locket-1.0.0-py2.py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/89/c3/6b05cc23afc9c466634ba815bfddf529677f8c7e03f5814ccd387dac0ade/metpy-1.7.1-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/f4/4e/afc8c31605cb8be1d3bb4438c4d979daa104dab6306cd2b87abe9c3a7299/narwhals-2.23.0-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/37/dc/44d21524cf1b1c64254f92e22395a7a10f70c18f3a13a18ac9db258760f7/netcdf4-1.7.4-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl + - pypi: https://files.pythonhosted.org/packages/71/e7/40fb618334dcdf7c5a316c0e7343c5cd82d3d866edc100d98e29bc945ecd/partd-1.4.2-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/f1/70/ba4b949bdc0490ab78d545459acd7702b211dfccf7eb89bbc1060f52818d/patsy-1.0.2-py2.py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/1b/dd/a9fe6a0a09512da23951c68bf36466aeecd89def3183dc095edbc807ddc5/pint-0.25.3-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/2a/2d/d4bf65e47cea8ff2c794a600c4fd1273a7902f268757c531e0ee9f18aa58/pooch-1.9.0-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/05/1e/ada6fb15a1d75b5bd9b554355a69a798c55a7dcc93b8d41596265c1772e3/pyproj-3.7.2-cp314-cp314-manylinux_2_28_x86_64.whl + - pypi: https://files.pythonhosted.org/packages/88/f9/16491d7ed2a919954993e48aa941b200f38040928474c9e85ea9e64222c3/pyyaml-6.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl + - pypi: https://files.pythonhosted.org/packages/a0/f4/c67b0b3f1b9245e8d266f0f112c500d50e5b4e83cb6f3b71b6528104182a/requests-2.34.2-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/f0/af/4d72d9e475ac83719160c662619e4bf7b95c19507cd582e7d0167a3c3dae/scikit_learn-1.9.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl + - pypi: https://files.pythonhosted.org/packages/7f/c4/bc41eb19b0fd0db868f4132920879019318d80cc522ad8f2bca4611af808/scipy-1.18.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl + - pypi: https://files.pythonhosted.org/packages/d3/78/417531e464cf9507b2092da31fb86dde4019a25390b204e0d67953ccb444/skyborn-0.4.2-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl + - pypi: https://files.pythonhosted.org/packages/34/0e/2408735aca9e764643196212f9069912100151414dd617d39ffc72d77eee/statsmodels-0.14.6-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl + - pypi: https://files.pythonhosted.org/packages/32/d5/f9a850d79b0851d1d4ef6456097579a9005b31fea68726a4ae5f2d82ddd9/threadpoolctl-3.6.0-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/fb/12/5911ae3eeec47800503a238d971e51722ccea5feb8569b735184d5fcdbc0/toolz-1.1.0-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/22/2a/5e5e750890ada51017d18d0d4c30da696e5b5bd3180947729927628fc3cb/tqdm-4.68.4-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/7f/3e/5db95bcf282c52709639744ca2a8b149baccf648e39c8cc87553df9eae0c/urllib3-2.7.0-py3-none-any.whl + - pypi: . + osx-64: + - conda: https://conda.anaconda.org/conda-forge/osx-64/_openmp_mutex-4.5-7_kmp_llvm.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/_python_abi3_support-1.0-hd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/appnope-0.1.4-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/asttokens-3.0.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/aws-c-auth-0.10.3-h9b4a110_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/aws-c-cal-0.9.14-hc007558_3.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/aws-c-common-0.14.1-ha1e9b39_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/aws-c-compression-0.3.2-h5e26a95_3.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/aws-c-http-0.11.0-heebfa22_3.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/aws-c-io-0.26.3-he261773_6.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/aws-c-s3-0.12.6-hafada3a_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/aws-c-sdkutils-0.2.7-h5e26a95_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/aws-checksums-0.2.10-h5e26a95_3.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/brotli-1.2.0-hf139dec_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/brotli-bin-1.2.0-h8616949_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/bzip2-1.0.8-h500dc9f_9.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/c-ares-1.34.6-hb5e19a0_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.6.17-hbd8a1cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cached-property-1.5.2-hd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cached_property-1.5.2-pyha770c72_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/cairo-1.18.4-h7656bdc_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/comm-0.2.3-pyhe01879c_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/contourpy-1.3.3-py314h22a2ed9_4.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cpython-3.14.6-py314hd8ed1ab_100.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cycler-0.12.1-pyhcf101f3_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/debugpy-1.8.21-py314h2883b87_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/decorator-5.3.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.3.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/execnet-2.1.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/executing-2.2.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-dejavu-sans-mono-2.37-hab24e00_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-inconsolata-3.000-h77eed37_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-source-code-pro-2.038-h77eed37_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-ubuntu-0.83-h77eed37_3.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/fontconfig-2.18.1-h7a4440b_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/fonts-conda-ecosystem-1-0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/fonts-conda-forge-1-hc364b38_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/fonttools-4.63.0-pyh7db6752_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/freetype-2.14.3-h694c41f_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/fribidi-1.0.16-h8616949_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/graphite2-1.3.15-hcc62823_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/h5netcdf-1.8.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/h5py-3.16.0-nompi_py314h58ac280_102.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/hdf5-2.1.0-nompi_h46fb815_109.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/icu-78.3-h25d91c4_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.3.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ipykernel-7.3.0-pyh01cf8df_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ipython-9.15.0-pyh53cf698_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ipython_pygments_lexers-1.1.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jedi-0.20.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_client-8.9.1-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_core-5.9.1-pyhc90fa1f_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/kiwisolver-1.5.0-py314hd6e1bd6_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/krb5-1.22.2-h3ddfcb2_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/lcms2-2.19.1-h5ea7634_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/lerc-4.1.0-h35c7297_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libaec-1.1.5-he7c3a48_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libblas-3.11.0-8_he492b99_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libbrotlicommon-1.2.0-h8616949_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libbrotlidec-1.2.0-h8616949_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libbrotlienc-1.2.0-h8616949_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libcblas-3.11.0-8_h9b27e0a_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libcurl-8.21.0-h06afde3_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libcxx-22.1.8-h19cb2f5_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libdeflate-1.25-h517ebb2_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libedit-3.1.20250104-pl5321ha958ccf_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libev-4.33-h10d778d_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libexpat-2.8.1-hcc62823_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libffi-3.5.2-hd1f9c09_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libfreetype-2.14.3-h694c41f_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libfreetype6-2.14.3-h58fbd8d_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libgcc-15.2.0-h08519bb_19.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libgfortran-15.2.0-h7e5c614_19.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libgfortran5-15.2.0-hd16e46c_19.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libglib-2.88.2-hf28f236_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libharfbuzz-14.2.1-h97ceea7_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libiconv-1.18-h57a12c2_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libintl-0.25.1-h3184127_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libjpeg-turbo-3.2.0-ha1e9b39_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/liblapack-3.11.0-8_h859234e_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/liblzma-5.8.3-hbb4bfdb_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libmpdec-4.0.0-hf3981d6_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libnghttp2-1.68.1-h70048d4_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libopenblas-0.3.33-openmp_h9e49c7b_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libpng-1.6.58-he930e7c_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libpsl-0.22.0-h87879e4_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libraqm-0.10.5-h1888d0e_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libsodium-1.0.22-ha3d0635_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libsqlite-3.53.3-h8f8c405_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libssh2-1.11.1-hed3591d_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libtiff-4.7.2-h95d6d7f_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libwebp-base-1.6.0-hb807250_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libxcb-1.17.0-hf1f96e2_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libzlib-1.3.2-hbb4bfdb_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/llvm-openmp-22.1.8-h0d3cbff_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/llvmlite-0.47.0-py314hf43a1d0_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/matplotlib-3.11.0-py314hee6578b_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/matplotlib-base-3.11.0-py314h75ce844_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/matplotlib-inline-0.2.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/munkres-1.1.4-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/ncurses-6.6-hcc0dc9a_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nest-asyncio2-1.7.2-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/numba-0.65.1-py314h34b395f_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/numpy-2.4.6-py314h7b24d9b_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/openjpeg-2.5.4-h52bb76a_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/openssl-3.6.3-hc881268_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/pandas-3.0.3-py314h99bb933_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/parso-0.8.7-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/pcre2-10.47-h13923f0_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pexpect-4.9.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/pillow-12.3.0-py314hc904d5e_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/pixman-0.46.4-ha059160_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/platformdirs-4.10.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.6.0-pyhf9edf01_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/prompt-toolkit-3.0.52-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/psutil-7.2.2-py314hd330473_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/pthread-stubs-0.4-h00291cd_1002.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ptyprocess-0.7.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pure_eval-0.2.3-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pygments-2.20.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pyparsing-3.3.2-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-9.1.1-pyhc364b38_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-xdist-3.8.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/python-3.14.6-h7c6738f_100_cp314.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python-dateutil-2.9.0.post0-pyhe01879c_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python-gil-3.14.6-h4df99d1_100.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/pyzmq-27.1.0-py312h2ac7433_3.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/qhull-2020.2-h3c5361c_5.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/readline-8.3-h68b038d_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/six-1.17.0-pyhe01879c_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/stack_data-0.6.3-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/tk-8.6.13-h7142dee_3.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/tornado-6.5.7-py314h217eccc_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/traitlets-5.15.1-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.16.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/unicodedata2-17.0.1-py314h4f144dc_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/wcwidth-0.8.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/xarray-2026.7.0-pyhc364b38_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/xorg-libxau-1.0.12-h8616949_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/xorg-libxdmcp-1.1.5-h8616949_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/zeromq-4.3.5-h84953be_11.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/zlib-ng-2.3.3-h8bce59a_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/zstd-1.5.7-h3eecb57_6.conda + - pypi: https://files.pythonhosted.org/packages/ef/2f/c5464532e965badff2f4c4c1a3a83f5697f0d7c407ed0cda44aaa99bb451/certifi-2026.6.17-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/ea/6c/a9618f589688358e279720f5c0fe67ef0077fba07334ce26895403ebc260/cftime-1.6.5-cp314-cp314-macosx_10_15_x86_64.whl + - pypi: https://files.pythonhosted.org/packages/7e/8d/496817fa0944239ecae662dd57ea765cfeaec6a735f9f025d4b7b72e7143/charset_normalizer-3.4.9-cp314-cp314-macosx_10_15_universal2.whl + - pypi: https://files.pythonhosted.org/packages/fb/e2/79c688af8b210d232694e31e59da9f6ec747bae31c3f5946e4e9b98860d5/click-8.4.2-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/88/39/799be3f2f0f38cc727ee3b4f1445fe6d5e4133064ec2e4115069418a5bb6/cloudpickle-3.1.2-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/90/aa/ceeb81d9dc886d445416310f0eff5c3978f20224b4143e96e36b7e85b011/dask-2026.7.0-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/27/cd/c883e1a7c447479d6e13985565080e3fea88ab5a107c21684c813dba1875/flexcache-0.3-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/fe/5e/3be305568fe5f34448807976dc82fc151d76c3e0e03958f34770286278c1/flexparser-0.4-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/e5/22/4222d7ddf3da30f363edaa98e329c2bce6c65497c9cb2810931c8b2c0fbc/fsspec-2026.6.0-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/1e/5e/d4e9f1a599fb8e573b7b87160658329fbf28d19eac2718f51fc3def3aa5a/idna-3.18-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/7b/91/984aca2ec129e2757d1e4e3c81c3fcda9d0f85b74670a094cc443d9ee949/joblib-1.5.3-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/db/bc/83e112abc66cd466c6b83f99118035867cecd41802f8d044638aa78a106e/locket-1.0.0-py2.py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/89/c3/6b05cc23afc9c466634ba815bfddf529677f8c7e03f5814ccd387dac0ade/metpy-1.7.1-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/f4/4e/afc8c31605cb8be1d3bb4438c4d979daa104dab6306cd2b87abe9c3a7299/narwhals-2.23.0-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/38/de/38ed7e1956943d28e8ea74161e97c3a00fb98d6d08943b4fd21bae32c240/netcdf4-1.7.4-cp311-abi3-macosx_13_0_x86_64.whl + - pypi: https://files.pythonhosted.org/packages/71/e7/40fb618334dcdf7c5a316c0e7343c5cd82d3d866edc100d98e29bc945ecd/partd-1.4.2-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/f1/70/ba4b949bdc0490ab78d545459acd7702b211dfccf7eb89bbc1060f52818d/patsy-1.0.2-py2.py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/1b/dd/a9fe6a0a09512da23951c68bf36466aeecd89def3183dc095edbc807ddc5/pint-0.25.3-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/2a/2d/d4bf65e47cea8ff2c794a600c4fd1273a7902f268757c531e0ee9f18aa58/pooch-1.9.0-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/42/17/c2b050d3f5b71b6edd0d96ae16c990fdc42a5f1366464a5c2772146de33a/pyproj-3.7.2-cp314-cp314-macosx_13_0_x86_64.whl + - pypi: https://files.pythonhosted.org/packages/9d/8c/f4bd7f6465179953d3ac9bc44ac1a8a3e6122cf8ada906b4f96c60172d43/pyyaml-6.0.3-cp314-cp314-macosx_10_13_x86_64.whl + - pypi: https://files.pythonhosted.org/packages/a0/f4/c67b0b3f1b9245e8d266f0f112c500d50e5b4e83cb6f3b71b6528104182a/requests-2.34.2-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/f4/7d/c9a35cf59b20a86fec24d306f1547b78dec194b08d367ce2a3e4854169d9/scikit_learn-1.9.0-cp314-cp314-macosx_10_15_x86_64.whl + - pypi: https://files.pythonhosted.org/packages/78/b5/915a19b3de2f7430062b509653563db1633ddbb6f021b06731521115d4e2/scipy-1.18.0-cp314-cp314-macosx_10_15_x86_64.whl + - pypi: https://files.pythonhosted.org/packages/0e/0f/e1e6e952b7916b9897b63ac53894b7a5d1d8616be6884d48bee7103cd8c9/skyborn-0.4.2.tar.gz + - pypi: https://files.pythonhosted.org/packages/71/de/09540e870318e0c7b58316561d417be45eff731263b4234fdd2eee3511a8/statsmodels-0.14.6-cp314-cp314-macosx_10_15_x86_64.whl + - pypi: https://files.pythonhosted.org/packages/32/d5/f9a850d79b0851d1d4ef6456097579a9005b31fea68726a4ae5f2d82ddd9/threadpoolctl-3.6.0-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/fb/12/5911ae3eeec47800503a238d971e51722ccea5feb8569b735184d5fcdbc0/toolz-1.1.0-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/22/2a/5e5e750890ada51017d18d0d4c30da696e5b5bd3180947729927628fc3cb/tqdm-4.68.4-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/7f/3e/5db95bcf282c52709639744ca2a8b149baccf648e39c8cc87553df9eae0c/urllib3-2.7.0-py3-none-any.whl + - pypi: . + osx-arm64: + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/_openmp_mutex-4.5-7_kmp_llvm.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/_python_abi3_support-1.0-hd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/appnope-0.1.4-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/asttokens-3.0.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-auth-0.10.3-hc187ab6_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-cal-0.9.14-h3623c0d_3.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-common-0.14.1-h84a0fba_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-compression-0.3.2-h35327cf_3.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-http-0.11.0-he9547b6_3.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-io-0.26.3-h63484d5_6.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-s3-0.12.6-hc78c590_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-c-sdkutils-0.2.7-h35327cf_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/aws-checksums-0.2.10-h35327cf_3.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/brotli-1.2.0-h7d5ae5b_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/brotli-bin-1.2.0-hc919400_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/bzip2-1.0.8-hd037594_9.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/c-ares-1.34.6-hc919400_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.6.17-hbd8a1cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cached-property-1.5.2-hd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cached_property-1.5.2-pyha770c72_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cairo-1.18.4-he0f2337_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/comm-0.2.3-pyhe01879c_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/contourpy-1.3.3-py314hf8a3a22_4.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cpython-3.14.6-py314hd8ed1ab_100.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cycler-0.12.1-pyhcf101f3_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/debugpy-1.8.21-py314he609de1_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/decorator-5.3.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.3.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/execnet-2.1.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/executing-2.2.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-dejavu-sans-mono-2.37-hab24e00_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-inconsolata-3.000-h77eed37_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-source-code-pro-2.038-h77eed37_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-ubuntu-0.83-h77eed37_3.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/fontconfig-2.18.1-h2b252f5_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/fonts-conda-ecosystem-1-0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/fonts-conda-forge-1-hc364b38_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/fonttools-4.63.0-pyh7db6752_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/freetype-2.14.3-hce30654_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/fribidi-1.0.16-hc919400_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/graphite2-1.3.15-hf6b4638_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/h5netcdf-1.8.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/h5py-3.16.0-nompi_py314h658a3ac_102.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/hdf5-2.1.0-nompi_h26123ac_109.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/icu-78.3-hef89b57_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.3.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ipykernel-7.3.0-pyh01cf8df_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ipython-9.15.0-pyh53cf698_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ipython_pygments_lexers-1.1.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jedi-0.20.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_client-8.9.1-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_core-5.9.1-pyhc90fa1f_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/kiwisolver-1.5.0-py314hf8a3a22_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/krb5-1.22.2-hfd3d5f3_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/lcms2-2.19.1-hdfa7624_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/lerc-4.1.0-h1eee2c3_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libaec-1.1.5-h8664d51_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libblas-3.11.0-8_h51639a9_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libbrotlicommon-1.2.0-hc919400_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libbrotlidec-1.2.0-hc919400_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libbrotlienc-1.2.0-hc919400_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcblas-3.11.0-8_hb0561ab_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcurl-8.21.0-h1359186_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-22.1.8-h55c6f16_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libdeflate-1.25-hc11a715_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libedit-3.1.20250104-pl5321hafb1f1b_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libev-4.33-h93a5062_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libexpat-2.8.1-hf6b4638_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libffi-3.5.2-hcf2aa1b_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libfreetype-2.14.3-hce30654_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libfreetype6-2.14.3-hdfa99f5_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgcc-15.2.0-hcbb3090_19.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran-15.2.0-h07b0088_19.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran5-15.2.0-hdae7583_19.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libglib-2.88.2-ha08bb59_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libharfbuzz-14.2.1-h5a65909_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libiconv-1.18-h23cfdf5_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libintl-0.25.1-h493aca8_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libjpeg-turbo-3.2.0-h84a0fba_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblapack-3.11.0-8_hd9741b5_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblzma-5.8.3-h8088a28_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libmpdec-4.0.0-h84a0fba_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libnghttp2-1.68.1-h8f3e76b_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenblas-0.3.33-openmp_he657e61_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libpng-1.6.58-h132b30e_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libpsl-0.22.0-hb427e8f_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libraqm-0.10.5-h45af499_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsodium-1.0.22-h1a92334_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsqlite-3.53.3-h1b79a29_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libssh2-1.11.1-h1590b86_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libtiff-4.7.2-h282da08_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libwebp-base-1.6.0-h07db88b_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libxcb-1.17.0-hdb1d25a_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libzlib-1.3.2-h8088a28_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-openmp-22.1.8-hc7d1edf_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvmlite-0.47.0-py314hc7e35b3_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/matplotlib-3.11.0-py314he55896b_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/matplotlib-base-3.11.0-py314hf6804ef_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/matplotlib-inline-0.2.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/munkres-1.1.4-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ncurses-6.6-h1d4f5a5_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nest-asyncio2-1.7.2-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/numba-0.65.1-py314hb38061f_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/numpy-2.4.6-py314hb79c6fa_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openjpeg-2.5.4-hd9e9057_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openssl-3.6.3-hd24854e_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pandas-3.0.3-py314he609de1_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/parso-0.8.7-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pcre2-10.47-h30297fc_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pexpect-4.9.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pillow-12.3.0-py314hab283cf_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pixman-0.46.4-h81086ad_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/platformdirs-4.10.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.6.0-pyhf9edf01_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/prompt-toolkit-3.0.52-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/psutil-7.2.2-py314ha14b1ff_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pthread-stubs-0.4-hd74edd7_1002.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ptyprocess-0.7.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pure_eval-0.2.3-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pygments-2.20.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pyparsing-3.3.2-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-9.1.1-pyhc364b38_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-xdist-3.8.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/python-3.14.6-h156bc91_100_cp314.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python-dateutil-2.9.0.post0-pyhe01879c_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python-gil-3.14.6-h4df99d1_100.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pyzmq-27.1.0-py312h022ad19_3.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/qhull-2020.2-h420ef59_5.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/readline-8.3-h46df422_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/six-1.17.0-pyhe01879c_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/stack_data-0.6.3-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/tk-8.6.13-h010d191_3.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/tornado-6.5.7-py314h6c2aa35_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/traitlets-5.15.1-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.16.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/unicodedata2-17.0.1-py314h6c2aa35_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/wcwidth-0.8.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/xarray-2026.7.0-pyhc364b38_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/xorg-libxau-1.0.12-hc919400_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/xorg-libxdmcp-1.1.5-hc919400_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/zeromq-4.3.5-h10816f8_11.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/zlib-ng-2.3.3-hed4e4f5_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/zstd-1.5.7-hbf9d68e_6.conda + - pypi: https://files.pythonhosted.org/packages/ef/2f/c5464532e965badff2f4c4c1a3a83f5697f0d7c407ed0cda44aaa99bb451/certifi-2026.6.17-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/d8/e3/da3c36398bfb730b96248d006cabaceed87e401ff56edafb2a978293e228/cftime-1.6.5-cp314-cp314-macosx_11_0_arm64.whl + - pypi: https://files.pythonhosted.org/packages/7e/8d/496817fa0944239ecae662dd57ea765cfeaec6a735f9f025d4b7b72e7143/charset_normalizer-3.4.9-cp314-cp314-macosx_10_15_universal2.whl + - pypi: https://files.pythonhosted.org/packages/fb/e2/79c688af8b210d232694e31e59da9f6ec747bae31c3f5946e4e9b98860d5/click-8.4.2-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/88/39/799be3f2f0f38cc727ee3b4f1445fe6d5e4133064ec2e4115069418a5bb6/cloudpickle-3.1.2-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/90/aa/ceeb81d9dc886d445416310f0eff5c3978f20224b4143e96e36b7e85b011/dask-2026.7.0-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/27/cd/c883e1a7c447479d6e13985565080e3fea88ab5a107c21684c813dba1875/flexcache-0.3-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/fe/5e/3be305568fe5f34448807976dc82fc151d76c3e0e03958f34770286278c1/flexparser-0.4-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/e5/22/4222d7ddf3da30f363edaa98e329c2bce6c65497c9cb2810931c8b2c0fbc/fsspec-2026.6.0-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/1e/5e/d4e9f1a599fb8e573b7b87160658329fbf28d19eac2718f51fc3def3aa5a/idna-3.18-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/7b/91/984aca2ec129e2757d1e4e3c81c3fcda9d0f85b74670a094cc443d9ee949/joblib-1.5.3-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/db/bc/83e112abc66cd466c6b83f99118035867cecd41802f8d044638aa78a106e/locket-1.0.0-py2.py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/89/c3/6b05cc23afc9c466634ba815bfddf529677f8c7e03f5814ccd387dac0ade/metpy-1.7.1-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/f4/4e/afc8c31605cb8be1d3bb4438c4d979daa104dab6306cd2b87abe9c3a7299/narwhals-2.23.0-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/34/b6/0370bb3af66a12098da06dc5843f3b349b7c83ccbdf7306e7afa6248b533/netcdf4-1.7.4.tar.gz + - pypi: https://files.pythonhosted.org/packages/71/e7/40fb618334dcdf7c5a316c0e7343c5cd82d3d866edc100d98e29bc945ecd/partd-1.4.2-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/f1/70/ba4b949bdc0490ab78d545459acd7702b211dfccf7eb89bbc1060f52818d/patsy-1.0.2-py2.py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/1b/dd/a9fe6a0a09512da23951c68bf36466aeecd89def3183dc095edbc807ddc5/pint-0.25.3-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/2a/2d/d4bf65e47cea8ff2c794a600c4fd1273a7902f268757c531e0ee9f18aa58/pooch-1.9.0-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/04/90/67bd7260b4ea9b8b20b4f58afef6c223ecb3abf368eb4ec5bc2cdef81b49/pyproj-3.7.2.tar.gz + - pypi: https://files.pythonhosted.org/packages/bd/9c/4d95bb87eb2063d20db7b60faa3840c1b18025517ae857371c4dd55a6b3a/pyyaml-6.0.3-cp314-cp314-macosx_11_0_arm64.whl + - pypi: https://files.pythonhosted.org/packages/a0/f4/c67b0b3f1b9245e8d266f0f112c500d50e5b4e83cb6f3b71b6528104182a/requests-2.34.2-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/3c/a7/552a7821597c632b907f7bfe8f36f9f572777af8ef8a48353041cf8e091a/scikit_learn-1.9.0-cp314-cp314-macosx_12_0_arm64.whl + - pypi: https://files.pythonhosted.org/packages/d7/88/b72def7262e150d16be13fca37a96481138d624e700340bc3362a7588929/scipy-1.18.0-cp314-cp314-macosx_12_0_arm64.whl + - pypi: https://files.pythonhosted.org/packages/0e/0f/e1e6e952b7916b9897b63ac53894b7a5d1d8616be6884d48bee7103cd8c9/skyborn-0.4.2.tar.gz + - pypi: https://files.pythonhosted.org/packages/ab/f0/63c1bfda75dc53cee858006e1f46bd6d6f883853bea1b97949d0087766ca/statsmodels-0.14.6-cp314-cp314-macosx_11_0_arm64.whl + - pypi: https://files.pythonhosted.org/packages/32/d5/f9a850d79b0851d1d4ef6456097579a9005b31fea68726a4ae5f2d82ddd9/threadpoolctl-3.6.0-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/fb/12/5911ae3eeec47800503a238d971e51722ccea5feb8569b735184d5fcdbc0/toolz-1.1.0-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/22/2a/5e5e750890ada51017d18d0d4c30da696e5b5bd3180947729927628fc3cb/tqdm-4.68.4-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/7f/3e/5db95bcf282c52709639744ca2a8b149baccf648e39c8cc87553df9eae0c/urllib3-2.7.0-py3-none-any.whl + - pypi: . + win-64: + - conda: https://conda.anaconda.org/conda-forge/win-64/_openmp_mutex-4.5-20_gnu.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/_python_abi3_support-1.0-hd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/asttokens-3.0.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/aws-c-auth-0.10.3-h0a1c2aa_4.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/aws-c-cal-0.9.14-h92e57be_3.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/aws-c-common-0.14.1-hfd05255_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/aws-c-compression-0.3.2-h4c63076_3.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/aws-c-http-0.11.0-h2c07012_3.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/aws-c-io-0.26.3-hf70332f_6.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/aws-c-s3-0.12.6-hcb9225d_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/aws-c-sdkutils-0.2.7-h4c63076_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/aws-checksums-0.2.10-h4c63076_3.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/brotli-1.2.0-h2d644bc_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/brotli-bin-1.2.0-hfd05255_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/bzip2-1.0.8-h0ad9c76_9.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.6.17-h4c7d964_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cached-property-1.5.2-hd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cached_property-1.5.2-pyha770c72_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/cairo-1.18.4-h477c42c_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/comm-0.2.3-pyhe01879c_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/contourpy-1.3.3-py314hf309875_4.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cpython-3.14.6-py314hd8ed1ab_100.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cycler-0.12.1-pyhcf101f3_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/debugpy-1.8.21-py314hb98de8c_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/decorator-5.3.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/double-conversion-3.4.0-hac47afa_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.3.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/execnet-2.1.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/executing-2.2.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-dejavu-sans-mono-2.37-hab24e00_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-inconsolata-3.000-h77eed37_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-source-code-pro-2.038-h77eed37_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-ubuntu-0.83-h77eed37_3.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/fontconfig-2.18.1-hd47e2ca_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/fonts-conda-ecosystem-1-0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/fonts-conda-forge-1-hc364b38_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/fonttools-4.63.0-pyh7db6752_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/freetype-2.14.3-h57928b3_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/fribidi-1.0.16-hfd05255_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/glib-2.88.2-h395db07_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/glib-tools-2.88.2-h74ecf4c_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/graphite2-1.3.15-hac47afa_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/h5netcdf-1.8.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/h5py-3.16.0-nompi_py314h02517ec_102.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/harfbuzz-14.2.1-h57928b3_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/hdf5-2.1.0-nompi_h0065017_109.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/icu-78.3-h637d24d_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.3.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ipykernel-7.3.0-pyh6dadd2b_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ipython-9.15.0-pyhe2676ad_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ipython_pygments_lexers-1.1.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jedi-0.20.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_client-8.9.1-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_core-5.9.1-pyh6dadd2b_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/kiwisolver-1.5.0-py314hf309875_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/krb5-1.22.2-h719d79b_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/lcms2-2.19.1-hf2c6c5f_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/lerc-4.1.0-hd936e49_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libaec-1.1.5-haf901d7_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libblas-3.11.0-8_h8455456_mkl.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libbrotlicommon-1.2.0-hfd05255_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libbrotlidec-1.2.0-hfd05255_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libbrotlienc-1.2.0-hfd05255_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libcblas-3.11.0-8_h2a3cdd5_mkl.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libclang13-22.1.8-default_hf735972_3.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libcurl-8.21.0-h51a1c48_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libdeflate-1.25-h51727cc_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libexpat-2.8.1-hac47afa_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libffi-3.5.2-h3d046cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libfreetype-2.14.3-h57928b3_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libfreetype6-2.14.3-hdbac1cb_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libgcc-15.2.0-h8ee18e1_19.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libglib-2.88.2-h7ce1215_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libgomp-15.2.0-h8ee18e1_19.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libharfbuzz-14.2.1-h03b5201_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libharfbuzz-devel-14.2.1-h03b5201_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libhwloc-2.13.0-default_h049141e_1000.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libiconv-1.18-hc1393d2_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libintl-0.22.5-h5728263_3.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libintl-devel-0.22.5-h5728263_3.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libjpeg-turbo-3.2.0-hfd05255_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/liblapack-3.11.0-8_hf9ab0e9_mkl.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/liblzma-5.8.3-hfd05255_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libmpdec-4.0.0-hfd05255_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libpng-1.6.58-h7351971_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libpsl-0.22.0-hc1744f7_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libraqm-0.10.5-h50d6d30_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libsodium-1.0.22-h6a83c73_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libsqlite-3.53.3-hf5d6505_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libssh2-1.11.1-h9aa295b_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libtiff-4.7.2-h8f73337_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libvulkan-loader-1.4.341.0-h477610d_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libwebp-base-1.6.0-h4d5522a_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libwinpthread-12.0.0.r4.gg4f2fc60ca-h57928b3_10.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libxcb-1.17.0-h0e4246c_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libxml2-16-2.15.3-h3cfd58e_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libxml2-2.15.3-h8ef44ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libxslt-1.1.43-h0fbe4c1_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libzlib-1.3.2-hfd05255_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/llvm-openmp-22.1.8-h4fa8253_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/llvmlite-0.47.0-py314hb492ee6_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/matplotlib-3.11.0-py314h86ab7b2_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/matplotlib-base-3.11.0-py314hd0c49b1_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/matplotlib-inline-0.2.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/mkl-2026.1.0-hac47afa_233.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/munkres-1.1.4-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/nest-asyncio2-1.7.2-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/numba-0.65.1-py314h36f8cf2_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/numpy-2.4.6-py314h02f10f6_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/onemkl-license-2026.1.0-h57928b3_233.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/openjpeg-2.5.4-h0e57b4f_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/openssl-3.6.3-hf411b9b_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/pandas-3.0.3-py314hf700ef7_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/parso-0.8.7-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/pcre2-10.47-hd2b5f0e_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/pillow-12.3.0-py314h61b30b5_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/pixman-0.46.4-h5112557_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/platformdirs-4.10.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.6.0-pyhf9edf01_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/prompt-toolkit-3.0.52-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/psutil-7.2.2-py314hc5dbbe4_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/pthread-stubs-0.4-h0e40799_1002.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pure_eval-0.2.3-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pygments-2.20.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pyparsing-3.3.2-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/pyside6-6.11.1-py314h447aaf0_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-9.1.1-pyhc364b38_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-xdist-3.8.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/python-3.14.6-h4b44e0e_100_cp314.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python-dateutil-2.9.0.post0-pyhe01879c_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python-gil-3.14.6-h4df99d1_100.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python-tzdata-2026.3-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/pywin32-312-py314hcaaf0b2_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/pyzmq-27.1.0-py312h343a6d4_3.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/qhull-2020.2-hc790b64_5.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/qt6-main-6.11.1-pl5321hfcac499_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/six-1.17.0-pyhe01879c_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/stack_data-0.6.3-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/tbb-2023.0.0-hd3d4ead_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/tk-8.6.13-h6ed50ae_3.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/tornado-6.5.7-py314h5a2d7ad_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/traitlets-5.15.1-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.16.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/ucrt-10.0.26100.0-h57928b3_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/unicodedata2-17.0.1-py314h5a2d7ad_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vc-14.5-h1b7c187_39.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.51.36231-h1b9f54f_39.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vcomp14-14.51.36231-h1b9f54f_39.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/wcwidth-0.8.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/xarray-2026.7.0-pyhc364b38_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/xorg-libxau-1.0.12-hba3369d_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/xorg-libxdmcp-1.1.5-hba3369d_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/zeromq-4.3.5-h3a581c9_11.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/zlib-1.3.2-hfd05255_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/zlib-ng-2.3.3-h0261ad2_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/zstd-1.5.7-h534d264_6.conda + - pypi: https://files.pythonhosted.org/packages/ef/2f/c5464532e965badff2f4c4c1a3a83f5697f0d7c407ed0cda44aaa99bb451/certifi-2026.6.17-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/22/d5/e605e4b28363e7a9ae98ed12cabbda5b155b6009270e6a231d8f10182a17/cftime-1.6.5-cp314-cp314-win_amd64.whl + - pypi: https://files.pythonhosted.org/packages/49/fd/a1d26144398c67486422a72bf5812cda22cb4ccfcd95a290fb41ceb4b8e2/charset_normalizer-3.4.9-cp314-cp314-win_amd64.whl + - pypi: https://files.pythonhosted.org/packages/fb/e2/79c688af8b210d232694e31e59da9f6ec747bae31c3f5946e4e9b98860d5/click-8.4.2-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/88/39/799be3f2f0f38cc727ee3b4f1445fe6d5e4133064ec2e4115069418a5bb6/cloudpickle-3.1.2-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/90/aa/ceeb81d9dc886d445416310f0eff5c3978f20224b4143e96e36b7e85b011/dask-2026.7.0-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/27/cd/c883e1a7c447479d6e13985565080e3fea88ab5a107c21684c813dba1875/flexcache-0.3-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/fe/5e/3be305568fe5f34448807976dc82fc151d76c3e0e03958f34770286278c1/flexparser-0.4-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/e5/22/4222d7ddf3da30f363edaa98e329c2bce6c65497c9cb2810931c8b2c0fbc/fsspec-2026.6.0-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/1e/5e/d4e9f1a599fb8e573b7b87160658329fbf28d19eac2718f51fc3def3aa5a/idna-3.18-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/7b/91/984aca2ec129e2757d1e4e3c81c3fcda9d0f85b74670a094cc443d9ee949/joblib-1.5.3-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/db/bc/83e112abc66cd466c6b83f99118035867cecd41802f8d044638aa78a106e/locket-1.0.0-py2.py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/89/c3/6b05cc23afc9c466634ba815bfddf529677f8c7e03f5814ccd387dac0ade/metpy-1.7.1-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/f4/4e/afc8c31605cb8be1d3bb4438c4d979daa104dab6306cd2b87abe9c3a7299/narwhals-2.23.0-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/18/68/e89b4fa9242e59326c849c39ce0f49eb68499603c639405a8449900a4f15/netcdf4-1.7.4-cp311-abi3-win_amd64.whl + - pypi: https://files.pythonhosted.org/packages/71/e7/40fb618334dcdf7c5a316c0e7343c5cd82d3d866edc100d98e29bc945ecd/partd-1.4.2-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/f1/70/ba4b949bdc0490ab78d545459acd7702b211dfccf7eb89bbc1060f52818d/patsy-1.0.2-py2.py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/1b/dd/a9fe6a0a09512da23951c68bf36466aeecd89def3183dc095edbc807ddc5/pint-0.25.3-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/2a/2d/d4bf65e47cea8ff2c794a600c4fd1273a7902f268757c531e0ee9f18aa58/pooch-1.9.0-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/04/b2/5a6610554306a83a563080c2cf2c57565563eadd280e15388efa00fb5b33/pyproj-3.7.2-cp314-cp314-win_amd64.whl + - pypi: https://files.pythonhosted.org/packages/23/20/bb6982b26a40bb43951265ba29d4c246ef0ff59c9fdcdf0ed04e0687de4d/pyyaml-6.0.3-cp314-cp314-win_amd64.whl + - pypi: https://files.pythonhosted.org/packages/a0/f4/c67b0b3f1b9245e8d266f0f112c500d50e5b4e83cb6f3b71b6528104182a/requests-2.34.2-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/a2/d5/6a58eea2cb9abbb9b3f2bb8b2cfb3243d1152d69f442d256c7af71304769/scikit_learn-1.9.0-cp314-cp314-win_amd64.whl + - pypi: https://files.pythonhosted.org/packages/93/3e/902d836831474b0ab5a37d16404f7bc5fafd9efba632890e271ba952635f/scipy-1.18.0-cp314-cp314-win_amd64.whl + - pypi: https://files.pythonhosted.org/packages/52/83/fbb44fd413ea8b735c07c335d6f0e3f430e61fd9d062186f30d4b70c68b8/skyborn-0.4.2-cp314-cp314-win_amd64.whl + - pypi: https://files.pythonhosted.org/packages/26/33/f1652d0c59fa51de18492ee2345b65372550501ad061daa38f950be390b6/statsmodels-0.14.6-cp314-cp314-win_amd64.whl + - pypi: https://files.pythonhosted.org/packages/32/d5/f9a850d79b0851d1d4ef6456097579a9005b31fea68726a4ae5f2d82ddd9/threadpoolctl-3.6.0-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/fb/12/5911ae3eeec47800503a238d971e51722ccea5feb8569b735184d5fcdbc0/toolz-1.1.0-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/22/2a/5e5e750890ada51017d18d0d4c30da696e5b5bd3180947729927628fc3cb/tqdm-4.68.4-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/7f/3e/5db95bcf282c52709639744ca2a8b149baccf648e39c8cc87553df9eae0c/urllib3-2.7.0-py3-none-any.whl + - pypi: . default: channels: - url: https://conda.anaconda.org/conda-forge/ @@ -661,6 +1457,210 @@ environments: - conda: https://conda.anaconda.org/conda-forge/win-64/zlib-ng-2.3.2-h0261ad2_1.conda - conda: https://conda.anaconda.org/conda-forge/win-64/zstd-1.5.7-h534d264_6.conda - pypi: . + lint: + channels: + - url: https://conda.anaconda.org/conda-forge/ + indexes: + - https://pypi.org/simple + packages: + linux-64: + - conda: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-20_gnu.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ast-serialize-0.6.0-py314h8632213_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-hda65f42_9.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.6.17-hbd8a1cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/importlib-metadata-9.0.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.45.1-default_hbd61a6d_102.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libblas-3.11.0-8_h4a7cf45_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcblas-3.11.0-8_h0358290_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.8.1-hecca717_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libffi-3.5.2-h3435931_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-15.2.0-he0feb66_19.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-15.2.0-h69a702a_19.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran5-15.2.0-h68bc16d_19.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-15.2.0-he0feb66_19.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/liblapack-3.11.0-8_h47877c9_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/liblzma-5.8.3-hb03c661_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libmpdec-4.0.0-hb03c661_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenblas-0.3.33-pthreads_h94d23a6_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.53.3-h0c1763c_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-15.2.0-h934c35e_19.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.42.2-h5347b49_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.2-h25fd6f3_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/llvmlite-0.47.0-py314h47fec7e_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/mypy-2.2.0-py314h9e9664a_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.6-hdb14827_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/numba-0.65.1-py314hf734fe3_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/numpy-2.4.6-py314hd4f4903_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.6.3-h35e630c_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pathspec-1.1.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/psutil-7.2.2-py314h3f2afee_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pyproject_hooks-1.2.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/python-3.14.6-hf9ea5aa_0_cp314t.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python-build-1.5.0-pyhc364b38_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/python-librt-0.13.0-py314h3f2afee_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314t.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/readline-8.3-h853b02a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ruff-0.15.21-h6a952e8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/tk-8.6.13-noxft_h366c992_103.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.16.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/zipp-4.1.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/zstd-1.5.7-hb78ec9c_6.conda + - pypi: https://files.pythonhosted.org/packages/03/36/98ddbcf3e4f04a6dd07e1c67249955920579ba4af6bb6868e3088f4ed282/numba-0.65.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl + - pypi: 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 + - pypi: . + osx-64: + - conda: https://conda.anaconda.org/conda-forge/osx-64/_openmp_mutex-4.5-7_kmp_llvm.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/ast-serialize-0.6.0-py314hc2b2ee7_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/bzip2-1.0.8-h500dc9f_9.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.6.17-hbd8a1cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/icu-78.3-h25d91c4_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/importlib-metadata-9.0.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libblas-3.11.0-8_he492b99_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libcblas-3.11.0-8_h9b27e0a_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libcxx-22.1.8-h19cb2f5_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libexpat-2.8.1-hcc62823_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libffi-3.5.2-hd1f9c09_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libgcc-15.2.0-h08519bb_19.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libgfortran-15.2.0-h7e5c614_19.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libgfortran5-15.2.0-hd16e46c_19.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/liblapack-3.11.0-8_h859234e_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/liblzma-5.8.3-hbb4bfdb_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libmpdec-4.0.0-hf3981d6_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libopenblas-0.3.33-openmp_h9e49c7b_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libsqlite-3.53.3-h8f8c405_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libzlib-1.3.2-hbb4bfdb_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/llvm-openmp-22.1.8-h0d3cbff_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/llvmlite-0.47.0-py314h81801d0_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/mypy-2.2.0-py314hd9f0251_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/ncurses-6.6-hcc0dc9a_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/numba-0.65.1-py314ha90515b_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/numpy-2.4.6-py314h5af6b61_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/openssl-3.6.3-hc881268_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pathspec-1.1.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/psutil-7.2.2-py314h5a675f6_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pyproject_hooks-1.2.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/python-3.14.6-ha91e2d8_0_cp314t.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python-build-1.5.0-pyhc364b38_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/python-librt-0.13.0-py314hef6ada0_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314t.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/readline-8.3-h68b038d_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/ruff-0.15.21-h1ddadc8_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/tk-8.6.13-h7142dee_3.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.16.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/zipp-4.1.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/zstd-1.5.7-h3eecb57_6.conda + - pypi: https://files.pythonhosted.org/packages/f6/c5/db2ac3685833d626c0dcae6bd2330cd68433e1fd248d15f70998160d3ad7/numba-0.65.1.tar.gz + - pypi: https://files.pythonhosted.org/packages/d0/ad/fed0499ce6a338d2a03ebae59cd15093910c8875328855781952abf6c2fe/numpy-2.4.6.tar.gz + - pypi: . + osx-arm64: + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/_openmp_mutex-4.5-7_kmp_llvm.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/_python_abi3_support-1.0-hd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ast-serialize-0.6.0-py310h3b8a9b8_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/bzip2-1.0.8-hd037594_9.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.6.17-hbd8a1cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cpython-3.14.6-py314hd8ed1ab_100.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/importlib-metadata-9.0.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libblas-3.11.0-8_h51639a9_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcblas-3.11.0-8_hb0561ab_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-22.1.8-h55c6f16_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libexpat-2.8.1-hf6b4638_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libffi-3.5.2-hcf2aa1b_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgcc-15.2.0-hcbb3090_19.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran-15.2.0-h07b0088_19.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran5-15.2.0-hdae7583_19.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblapack-3.11.0-8_hd9741b5_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblzma-5.8.3-h8088a28_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libmpdec-4.0.0-h84a0fba_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libopenblas-0.3.33-openmp_he657e61_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsqlite-3.53.3-h1b79a29_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libzlib-1.3.2-h8088a28_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-openmp-22.1.8-hc7d1edf_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvmlite-0.47.0-py314hc7e35b3_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/mypy-2.2.0-py314h2fbedac_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ncurses-6.6-h1d4f5a5_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/numba-0.65.1-py314hb38061f_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/numpy-2.4.6-py314hb79c6fa_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openssl-3.6.3-hd24854e_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pathspec-1.1.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/psutil-7.2.2-py314ha14b1ff_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pyproject_hooks-1.2.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/python-3.14.6-h156bc91_100_cp314.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python-build-1.5.0-pyhc364b38_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python-gil-3.14.6-h4df99d1_100.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/python-librt-0.13.0-py314ha14b1ff_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/readline-8.3-h46df422_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ruff-0.15.21-h80928e0_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/tk-8.6.13-h010d191_3.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.16.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/zipp-4.1.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/zstd-1.5.7-hbf9d68e_6.conda + - pypi: . + win-64: + - conda: https://conda.anaconda.org/conda-forge/win-64/ast-serialize-0.6.0-py314ha9b8041_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/bzip2-1.0.8-h0ad9c76_9.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.6.17-h4c7d964_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/importlib-metadata-9.0.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libblas-3.11.0-8_h8455456_mkl.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libcblas-3.11.0-8_h2a3cdd5_mkl.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libexpat-2.8.1-hac47afa_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libffi-3.5.2-h3d046cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libhwloc-2.13.0-default_h049141e_1000.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libiconv-1.18-hc1393d2_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/liblapack-3.11.0-8_hf9ab0e9_mkl.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/liblzma-5.8.3-hfd05255_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libmpdec-4.0.0-hfd05255_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libsqlite-3.53.3-hf5d6505_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libwinpthread-12.0.0.r4.gg4f2fc60ca-h57928b3_10.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libxml2-16-2.15.3-h692994f_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libxml2-2.15.3-hbc0d294_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libzlib-1.3.2-hfd05255_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/llvm-openmp-22.1.8-h4fa8253_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/llvmlite-0.47.0-py314hf48658c_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/mkl-2026.1.0-hac47afa_233.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/mypy-2.2.0-py314h72baafe_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/numba-0.65.1-py314h01db6d0_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/numpy-2.4.6-py314hffb9209_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/onemkl-license-2026.1.0-h57928b3_233.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/openssl-3.6.3-hf411b9b_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pathspec-1.1.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/psutil-7.2.2-py314h8f04a7f_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pyproject_hooks-1.2.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/python-3.14.6-h7c1dbca_0_cp314t.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python-build-1.5.0-pyhc364b38_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/python-librt-0.13.0-py314h8f04a7f_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314t.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/ruff-0.15.21-h45713df_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/tbb-2023.0.0-hd3d4ead_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/tk-8.6.13-h6ed50ae_3.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.16.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/ucrt-10.0.26100.0-h57928b3_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vc-14.5-h1b7c187_39.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vc14_runtime-14.51.36231-h1b9f54f_39.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/vcomp14-14.51.36231-h1b9f54f_39.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/zipp-4.1.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/zstd-1.5.7-h534d264_6.conda + - pypi: . minimal: channels: - url: https://conda.anaconda.org/conda-forge/ @@ -1005,7 +2005,7 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-64/libblas-3.11.0-8_h4a7cf45_openblas.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libcblas-3.11.0-8_h0358290_openblas.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.8.1-hecca717_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libffi-3.7.0-h3435931_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libffi-3.5.2-h3435931_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-15.2.0-he0feb66_19.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-15.2.0-h69a702a_19.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-15.2.0-h69a702a_19.conda @@ -1022,18 +2022,18 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.42.2-h5347b49_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libxcrypt-4.4.36-hd590300_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.2-h25fd6f3_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/llvmlite-0.42.0-py310h1b8f574_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/llvmlite-0.42.0-py311ha6695c7_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.6-hdb14827_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/numba-0.59.1-py310h7dc5dd1_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/numpy-1.26.4-py310hb13e2d6_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/numba-0.59.1-py311h96b013e_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/numpy-1.26.4-py311h64a7726_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.6.3-h35e630c_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.6.0-pyhf9edf01_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/pygments-2.20.0-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-9.1.1-pyhc364b38_2.conda - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-xdist-3.8.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/python-3.10.20-h267e890_1_cpython.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.10-8_cp310.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/python-3.11.15-h7508c33_1_cpython.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.11-8_cp311.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/readline-8.3-h853b02a_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/tk-8.6.13-noxft_h366c992_103.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda @@ -1054,7 +2054,7 @@ environments: - conda: https://conda.anaconda.org/conda-forge/osx-64/libcblas-3.11.0-8_h9b27e0a_openblas.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libcxx-22.1.8-h19cb2f5_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libexpat-2.8.1-hcc62823_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libffi-3.7.0-h8c408c4_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libffi-3.5.2-hd1f9c09_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libgcc-15.2.0-h08519bb_19.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libgfortran-15.2.0-h7e5c614_19.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libgfortran5-15.2.0-hd16e46c_19.conda @@ -1065,18 +2065,18 @@ environments: - conda: https://conda.anaconda.org/conda-forge/osx-64/libsqlite-3.53.3-h8f8c405_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libzlib-1.3.2-hbb4bfdb_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/llvm-openmp-22.1.8-h0d3cbff_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/llvmlite-0.42.0-py310h7d48a1f_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/llvmlite-0.42.0-py311hb5c2e0a_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/ncurses-6.6-hcc0dc9a_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/numba-0.59.1-py310h1d5af72_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/numpy-1.26.4-py310h4bfa8fc_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/numba-0.59.1-py311h97119f7_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/numpy-1.26.4-py311hc43a94b_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/openssl-3.6.3-hc881268_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.6.0-pyhf9edf01_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/pygments-2.20.0-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-9.1.1-pyhc364b38_2.conda - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-xdist-3.8.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/python-3.10.20-hea035f4_1_cpython.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.10-8_cp310.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/python-3.11.15-ha9537fe_1_cpython.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.11-8_cp311.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/readline-8.3-h68b038d_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/tk-8.6.13-h7142dee_3.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda @@ -1095,7 +2095,7 @@ environments: - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcblas-3.11.0-8_hb0561ab_openblas.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-22.1.8-h55c6f16_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libexpat-2.8.1-hf6b4638_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libffi-3.7.0-hcf2aa1b_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libffi-3.5.2-hcf2aa1b_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgcc-15.2.0-hcbb3090_19.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran-15.2.0-h07b0088_19.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran5-15.2.0-hdae7583_19.conda @@ -1106,18 +2106,18 @@ environments: - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsqlite-3.53.3-h1b79a29_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libzlib-1.3.2-h8088a28_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-openmp-22.1.8-hc7d1edf_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvmlite-0.42.0-py310hf7687f1_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvmlite-0.42.0-py311hf5d242d_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ncurses-6.6-h1d4f5a5_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/numba-0.59.1-py310hdf1f89a_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/numpy-1.26.4-py310hd45542a_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/numba-0.59.1-py311h00351ea_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/numpy-1.26.4-py311h7125741_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openssl-3.6.3-hd24854e_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.6.0-pyhf9edf01_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/pygments-2.20.0-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-9.1.1-pyhc364b38_2.conda - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-xdist-3.8.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/python-3.10.20-hac0b6dc_1_cpython.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.10-8_cp310.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/python-3.11.15-h0c9c016_1_cpython.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.11-8_cp311.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/readline-8.3-h46df422_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/tk-8.6.13-h010d191_3.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda @@ -1135,7 +2135,7 @@ environments: - conda: https://conda.anaconda.org/conda-forge/win-64/libblas-3.11.0-8_h8455456_mkl.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libcblas-3.11.0-8_h2a3cdd5_mkl.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libexpat-2.8.1-hac47afa_1.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libffi-3.7.0-h3d046cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libffi-3.5.2-h3d046cb_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libhwloc-2.13.0-default_h049141e_1000.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libiconv-1.18-hc1393d2_2.conda - conda: https://conda.anaconda.org/conda-forge/win-64/liblapack-3.11.0-8_hf9ab0e9_mkl.conda @@ -1146,10 +2146,10 @@ environments: - conda: https://conda.anaconda.org/conda-forge/win-64/libxml2-2.15.3-h8ef44ab_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libzlib-1.3.2-hfd05255_2.conda - conda: https://conda.anaconda.org/conda-forge/win-64/llvm-openmp-22.1.8-h4fa8253_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/llvmlite-0.42.0-py310hb84602e_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/llvmlite-0.42.0-py311h5bc0dda_1.conda - conda: https://conda.anaconda.org/conda-forge/win-64/mkl-2026.1.0-hac47afa_233.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/numba-0.59.1-py310h9ccaf4f_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/numpy-1.26.4-py310hf667824_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/numba-0.59.1-py311h2c0921f_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/numpy-1.26.4-py311h0b4df5a_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/onemkl-license-2026.1.0-h57928b3_233.conda - conda: https://conda.anaconda.org/conda-forge/win-64/openssl-3.6.3-hf411b9b_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda @@ -1157,8 +2157,8 @@ environments: - conda: https://conda.anaconda.org/conda-forge/noarch/pygments-2.20.0-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-9.1.1-pyhc364b38_2.conda - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-xdist-3.8.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/python-3.10.20-hc20f281_1_cpython.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.10-8_cp310.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_1_cpython.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.11-8_cp311.conda - conda: https://conda.anaconda.org/conda-forge/win-64/tbb-2023.0.0-hd3d4ead_2.conda - conda: https://conda.anaconda.org/conda-forge/win-64/tk-8.6.13-h6ed50ae_3.conda - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda @@ -1451,7 +2451,7 @@ environments: - conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.3.1-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/execnet-2.1.2-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/h5netcdf-1.8.1-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/h5py-3.16.0-nompi_py310hb9a6f38_102.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/h5py-3.16.0-nompi_py311hfef529e_102.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/hdf5-2.1.0-nompi_hc8ae080_109.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/icu-78.3-h33c6efd_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.3.0-pyhd8ed1ab_0.conda @@ -1465,7 +2465,7 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-64/libedit-3.1.20250104-pl5321h7949ede_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libev-4.33-hd590300_2.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.8.1-hecca717_1.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/libffi-3.7.0-h3435931_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libffi-3.5.2-h3435931_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-15.2.0-he0feb66_19.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-15.2.0-h69a702a_19.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-15.2.0-h69a702a_19.conda @@ -1485,21 +2485,21 @@ environments: - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.42.2-h5347b49_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libxcrypt-4.4.36-hd590300_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.2-h25fd6f3_2.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/llvmlite-0.42.0-py310h1b8f574_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/llvmlite-0.42.0-py311ha6695c7_1.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.6-hdb14827_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/numba-0.59.1-py310h7dc5dd1_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/numpy-1.26.4-py310hb13e2d6_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/numba-0.59.1-py311h96b013e_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/numpy-1.26.4-py311h64a7726_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.6.3-h35e630c_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/pandas-2.3.3-py310h0158d43_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pandas-2.3.3-py311hed34c8f_2.conda - conda: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.6.0-pyhf9edf01_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/pygments-2.20.0-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-9.1.1-pyhc364b38_2.conda - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-xdist-3.8.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/linux-64/python-3.10.20-h267e890_1_cpython.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/python-3.11.15-h7508c33_1_cpython.conda - conda: https://conda.anaconda.org/conda-forge/noarch/python-dateutil-2.9.0.post0-pyhe01879c_2.conda - conda: https://conda.anaconda.org/conda-forge/noarch/python-tzdata-2026.3-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.10-8_cp310.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.11-8_cp311.conda - conda: https://conda.anaconda.org/conda-forge/noarch/pytz-2026.2-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/readline-8.3-h853b02a_0.conda - conda: https://conda.anaconda.org/conda-forge/linux-64/s2n-1.7.5-h7e3ee7f_1.conda @@ -1531,7 +2531,7 @@ environments: - conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.3.1-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/execnet-2.1.2-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/h5netcdf-1.8.1-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/h5py-3.16.0-nompi_py310h05ade02_102.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/h5py-3.16.0-nompi_py311ha7e68cf_102.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/hdf5-2.1.0-nompi_h46fb815_109.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/icu-78.3-h25d91c4_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.3.0-pyhd8ed1ab_0.conda @@ -1544,7 +2544,7 @@ environments: - conda: https://conda.anaconda.org/conda-forge/osx-64/libedit-3.1.20250104-pl5321ha958ccf_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libev-4.33-h10d778d_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libexpat-2.8.1-hcc62823_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/libffi-3.7.0-h8c408c4_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/libffi-3.5.2-hd1f9c09_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libgcc-15.2.0-h08519bb_19.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libgfortran-15.2.0-h7e5c614_19.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libgfortran5-15.2.0-hd16e46c_19.conda @@ -1558,21 +2558,21 @@ environments: - conda: https://conda.anaconda.org/conda-forge/osx-64/libssh2-1.11.1-hed3591d_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/libzlib-1.3.2-hbb4bfdb_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/llvm-openmp-22.1.8-h0d3cbff_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/llvmlite-0.42.0-py310h7d48a1f_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/llvmlite-0.42.0-py311hb5c2e0a_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/ncurses-6.6-hcc0dc9a_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/numba-0.59.1-py310h1d5af72_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/numpy-1.26.4-py310h4bfa8fc_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/numba-0.59.1-py311h97119f7_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/numpy-1.26.4-py311hc43a94b_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/openssl-3.6.3-hc881268_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/pandas-2.3.3-py310h39ce848_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/pandas-2.3.3-py311hca9a5ca_2.conda - conda: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.6.0-pyhf9edf01_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/pygments-2.20.0-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-9.1.1-pyhc364b38_2.conda - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-xdist-3.8.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-64/python-3.10.20-hea035f4_1_cpython.conda + - conda: https://conda.anaconda.org/conda-forge/osx-64/python-3.11.15-ha9537fe_1_cpython.conda - conda: https://conda.anaconda.org/conda-forge/noarch/python-dateutil-2.9.0.post0-pyhe01879c_2.conda - conda: https://conda.anaconda.org/conda-forge/noarch/python-tzdata-2026.3-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.10-8_cp310.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.11-8_cp311.conda - conda: https://conda.anaconda.org/conda-forge/noarch/pytz-2026.2-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-64/readline-8.3-h68b038d_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/six-1.17.0-pyhe01879c_1.conda @@ -1603,7 +2603,7 @@ environments: - conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.3.1-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/execnet-2.1.2-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/h5netcdf-1.8.1-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/h5py-3.16.0-nompi_py310hcf53ec8_102.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/h5py-3.16.0-nompi_py311hf10ccac_102.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/hdf5-2.1.0-nompi_h26123ac_109.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/icu-78.3-hef89b57_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.3.0-pyhd8ed1ab_0.conda @@ -1616,7 +2616,7 @@ environments: - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libedit-3.1.20250104-pl5321hafb1f1b_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libev-4.33-h93a5062_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libexpat-2.8.1-hf6b4638_1.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libffi-3.7.0-hcf2aa1b_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libffi-3.5.2-hcf2aa1b_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgcc-15.2.0-hcbb3090_19.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran-15.2.0-h07b0088_19.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgfortran5-15.2.0-hdae7583_19.conda @@ -1630,21 +2630,21 @@ environments: - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libssh2-1.11.1-h1590b86_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libzlib-1.3.2-h8088a28_2.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvm-openmp-22.1.8-hc7d1edf_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvmlite-0.42.0-py310hf7687f1_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvmlite-0.42.0-py311hf5d242d_1.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ncurses-6.6-h1d4f5a5_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/numba-0.59.1-py310hdf1f89a_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/numpy-1.26.4-py310hd45542a_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/numba-0.59.1-py311h00351ea_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/numpy-1.26.4-py311h7125741_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openssl-3.6.3-hd24854e_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pandas-2.3.3-py310h25f4b65_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pandas-2.3.3-py311hdb8e4fa_2.conda - conda: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.6.0-pyhf9edf01_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/pygments-2.20.0-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-9.1.1-pyhc364b38_2.conda - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-xdist-3.8.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/osx-arm64/python-3.10.20-hac0b6dc_1_cpython.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/python-3.11.15-h0c9c016_1_cpython.conda - conda: https://conda.anaconda.org/conda-forge/noarch/python-dateutil-2.9.0.post0-pyhe01879c_2.conda - conda: https://conda.anaconda.org/conda-forge/noarch/python-tzdata-2026.3-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.10-8_cp310.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.11-8_cp311.conda - conda: https://conda.anaconda.org/conda-forge/noarch/pytz-2026.2-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/osx-arm64/readline-8.3-h46df422_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/six-1.17.0-pyhe01879c_1.conda @@ -1673,7 +2673,7 @@ environments: - conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.3.1-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/execnet-2.1.2-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/h5netcdf-1.8.1-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/h5py-3.16.0-nompi_py310h6359f78_102.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/h5py-3.16.0-nompi_py311ha643933_102.conda - conda: https://conda.anaconda.org/conda-forge/win-64/hdf5-2.1.0-nompi_h0065017_109.conda - conda: https://conda.anaconda.org/conda-forge/win-64/icu-78.3-h637d24d_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.3.0-pyhd8ed1ab_0.conda @@ -1683,7 +2683,7 @@ environments: - conda: https://conda.anaconda.org/conda-forge/win-64/libcblas-3.11.0-8_h2a3cdd5_mkl.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libcurl-8.21.0-h51a1c48_2.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libexpat-2.8.1-hac47afa_1.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/libffi-3.7.0-h3d046cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/libffi-3.5.2-h3d046cb_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libhwloc-2.13.0-default_h049141e_1000.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libiconv-1.18-hc1393d2_2.conda - conda: https://conda.anaconda.org/conda-forge/win-64/liblapack-3.11.0-8_hf9ab0e9_mkl.conda @@ -1696,22 +2696,22 @@ environments: - conda: https://conda.anaconda.org/conda-forge/win-64/libxml2-2.15.3-h8ef44ab_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/libzlib-1.3.2-hfd05255_2.conda - conda: https://conda.anaconda.org/conda-forge/win-64/llvm-openmp-22.1.8-h4fa8253_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/llvmlite-0.42.0-py310hb84602e_1.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/llvmlite-0.42.0-py311h5bc0dda_1.conda - conda: https://conda.anaconda.org/conda-forge/win-64/mkl-2026.1.0-hac47afa_233.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/numba-0.59.1-py310h9ccaf4f_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/numpy-1.26.4-py310hf667824_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/numba-0.59.1-py311h2c0921f_0.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/numpy-1.26.4-py311h0b4df5a_0.conda - conda: https://conda.anaconda.org/conda-forge/win-64/onemkl-license-2026.1.0-h57928b3_233.conda - conda: https://conda.anaconda.org/conda-forge/win-64/openssl-3.6.3-hf411b9b_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.2-pyhc364b38_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/pandas-2.3.3-py310hed136d8_2.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/pandas-2.3.3-py311h11fd7f3_2.conda - conda: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.6.0-pyhf9edf01_1.conda - conda: https://conda.anaconda.org/conda-forge/noarch/pygments-2.20.0-pyhd8ed1ab_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-9.1.1-pyhc364b38_2.conda - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-xdist-3.8.0-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/win-64/python-3.10.20-hc20f281_1_cpython.conda + - conda: https://conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_1_cpython.conda - conda: https://conda.anaconda.org/conda-forge/noarch/python-dateutil-2.9.0.post0-pyhe01879c_2.conda - conda: https://conda.anaconda.org/conda-forge/noarch/python-tzdata-2026.3-pyhd8ed1ab_0.conda - - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.10-8_cp310.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.11-8_cp311.conda - conda: https://conda.anaconda.org/conda-forge/noarch/pytz-2026.2-pyhcf101f3_0.conda - conda: https://conda.anaconda.org/conda-forge/noarch/six-1.17.0-pyhe01879c_1.conda - conda: https://conda.anaconda.org/conda-forge/win-64/tbb-2023.0.0-hd3d4ead_2.conda @@ -1782,6 +2782,21 @@ packages: purls: [] size: 8325 timestamp: 1764092507920 +- conda: https://conda.anaconda.org/conda-forge/win-64/_openmp_mutex-4.5-20_gnu.conda + build_number: 20 + sha256: 8a1cee28bd0ee7451ada1cd50b64720e57e17ff994fc62dd8329bef570d382e4 + md5: 1626967b574d1784b578b52eaeb071e7 + depends: + - libgomp >=7.5.0 + - libwinpthread >=12.0.0.r4.gg4f2fc60ca + constrains: + - openmp_impl <0.0a0 + - msys2-conda-epoch <0.0a0 + license: BSD-3-Clause + license_family: BSD + purls: [] + size: 52252 + timestamp: 1770943776666 - conda: https://conda.anaconda.org/conda-forge/win-64/_openmp_mutex-4.5-2_gnu.conda build_number: 8 sha256: 1a62cd1f215fe0902e7004089693a78347a30ad687781dfda2289cab000e652d @@ -1819,6 +2834,17 @@ packages: purls: [] size: 584660 timestamp: 1768327524772 +- conda: https://conda.anaconda.org/conda-forge/linux-64/alsa-lib-1.2.16.1-hb03c661_0.conda + sha256: cf93ca0f1f107e95a35969a4622684e08fcb8cf37f8cf4a1e9e424828386c921 + md5: 8904e09bda369377b3dd07e2ac828c5d + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + license: LGPL-2.1-or-later + license_family: LGPL + purls: [] + size: 592377 + timestamp: 1781521980743 - conda: https://conda.anaconda.org/conda-forge/noarch/appnope-0.1.4-pyhd8ed1ab_1.conda sha256: 8f032b140ea4159806e4969a68b4a3c0a7cab1ad936eb958a2b5ffe5335e19bf md5: 54898d0f524c9dee622d44bbb081a8ab @@ -1830,6 +2856,67 @@ packages: - pkg:pypi/appnope?source=hash-mapping size: 10076 timestamp: 1733332433806 +- conda: https://conda.anaconda.org/conda-forge/linux-64/ast-serialize-0.6.0-py314h8632213_0.conda + sha256: 0289ccbb6422356cd2c3e97e31072cc0c88b87bf5c7f6d0e46b1164f204a1b74 + md5: 87cb3a8c4fe1937cda3a08f4e8f9e261 + depends: + - python + - libgcc >=14 + - __glibc >=2.17,<3.0.a0 + - python_abi 3.14.* *_cp314t + constrains: + - __glibc >=2.17 + license: MIT + license_family: MIT + purls: [] + size: 1113351 + timestamp: 1782863834793 +- conda: https://conda.anaconda.org/conda-forge/osx-64/ast-serialize-0.6.0-py314hc2b2ee7_0.conda + sha256: df68b8c0cbfd7c63ca19e84e0ba34617e6152fd60d66bd2f51661598feacc766 + md5: 110459dd0f6ab46bf4d6122c8ddc27b5 + depends: + - python + - __osx >=11.0 + - python_abi 3.14.* *_cp314t + constrains: + - __osx >=11.0 + license: MIT + license_family: MIT + purls: [] + size: 1102177 + timestamp: 1782863912929 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/ast-serialize-0.6.0-py310h3b8a9b8_0.conda + noarch: python + sha256: 0efbe4158ee4d5ff4108ad1b8c677e85eb1a8f3bb48fe2277579860d38e48315 + md5: 9bc9209a773faadbdca5fe45d9aa9cdc + depends: + - python >=3.10 + - __osx >=11.0 + - _python_abi3_support 1.* + - cpython >=3.10 + constrains: + - __osx >=11.0 + license: MIT + license_family: MIT + purls: + - pkg:pypi/ast-serialize?source=compressed-mapping + size: 1077921 + timestamp: 1782863843092 +- conda: https://conda.anaconda.org/conda-forge/win-64/ast-serialize-0.6.0-py314ha9b8041_0.conda + sha256: f48023dfb7b5b76e6fdf4b7bc94dd6e78950241a734041a76fed3752ae8b71b6 + md5: a49c870f5def87e81a59dd436a36adaf + depends: + - python + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + - ucrt >=10.0.20348.0 + - python_abi 3.14.* *_cp314t + license: MIT + license_family: MIT + purls: + - pkg:pypi/ast-serialize?source=hash-mapping + size: 1069557 + timestamp: 1782863863419 - conda: https://conda.anaconda.org/conda-forge/noarch/asttokens-3.0.0-pyhd8ed1ab_1.conda sha256: 93b14414b3b3ed91e286e1cbe4e7a60c4e1b1c730b0814d1e452a8ac4b9af593 md5: 8f587de4bcf981e26228f268df374a9b @@ -1843,6 +2930,19 @@ packages: - pkg:pypi/asttokens?source=hash-mapping size: 28206 timestamp: 1733250564754 +- conda: https://conda.anaconda.org/conda-forge/noarch/asttokens-3.0.1-pyhd8ed1ab_0.conda + sha256: ee4da0f3fe9d59439798ee399ef3e482791e48784873d546e706d0935f9ff010 + md5: 9673a61a297b00016442e022d689faa6 + depends: + - python >=3.10 + constrains: + - astroid >=2,<5 + license: Apache-2.0 + license_family: Apache + purls: + - pkg:pypi/asttokens?source=hash-mapping + size: 28797 + timestamp: 1763410017955 - conda: https://conda.anaconda.org/conda-forge/noarch/attrs-26.1.0-pyhcf101f3_0.conda sha256: 1b6124230bb4e571b1b9401537ecff575b7b109cc3a21ee019f65e083b8399ab md5: c6b0543676ecb1fb2d7643941fe375f2 @@ -2748,29 +3848,69 @@ packages: sha256: 06525fa0c4e4f56e771a3b986d0fdf0f0fc5a3270830ee47e127a5105bde1b9a md5: bb6c4808bfa69d6f7f6b07e5846ced37 depends: - - __glibc >=2.17,<3.0.a0 + - __glibc >=2.17,<3.0.a0 + - fontconfig >=2.15.0,<3.0a0 + - fonts-conda-ecosystem + - icu >=78.1,<79.0a0 + - libexpat >=2.7.3,<3.0a0 + - libfreetype >=2.14.1 + - libfreetype6 >=2.14.1 + - libgcc >=14 + - libglib >=2.86.3,<3.0a0 + - libpng >=1.6.53,<1.7.0a0 + - libstdcxx >=14 + - libxcb >=1.17.0,<2.0a0 + - libzlib >=1.3.1,<2.0a0 + - pixman >=0.46.4,<1.0a0 + - xorg-libice >=1.1.2,<2.0a0 + - xorg-libsm >=1.2.6,<2.0a0 + - xorg-libx11 >=1.8.12,<2.0a0 + - xorg-libxext >=1.3.6,<2.0a0 + - xorg-libxrender >=0.9.12,<0.10.0a0 + license: LGPL-2.1-only or MPL-1.1 + purls: [] + size: 989514 + timestamp: 1766415934926 +- conda: https://conda.anaconda.org/conda-forge/osx-64/cairo-1.18.4-h7656bdc_1.conda + sha256: 88e7e1efb6a0f6b1477e617338e0ed3d27d4572a3283f8341ce6143b7118e31a + md5: 9917add2ab43df894b9bb6f5bf485975 + depends: + - __osx >=10.13 - fontconfig >=2.15.0,<3.0a0 - fonts-conda-ecosystem - icu >=78.1,<79.0a0 + - libcxx >=19 - libexpat >=2.7.3,<3.0a0 - libfreetype >=2.14.1 - libfreetype6 >=2.14.1 - - libgcc >=14 - libglib >=2.86.3,<3.0a0 - libpng >=1.6.53,<1.7.0a0 - - libstdcxx >=14 - - libxcb >=1.17.0,<2.0a0 - libzlib >=1.3.1,<2.0a0 - pixman >=0.46.4,<1.0a0 - - xorg-libice >=1.1.2,<2.0a0 - - xorg-libsm >=1.2.6,<2.0a0 - - xorg-libx11 >=1.8.12,<2.0a0 - - xorg-libxext >=1.3.6,<2.0a0 - - xorg-libxrender >=0.9.12,<0.10.0a0 license: LGPL-2.1-only or MPL-1.1 purls: [] - size: 989514 - timestamp: 1766415934926 + size: 896676 + timestamp: 1766416262450 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/cairo-1.18.4-he0f2337_1.conda + sha256: cde9b79ee206fe3ba6ca2dc5906593fb7a1350515f85b2a1135a4ce8ec1539e3 + md5: 36200ecfbbfbcb82063c87725434161f + depends: + - __osx >=11.0 + - fontconfig >=2.15.0,<3.0a0 + - fonts-conda-ecosystem + - icu >=78.1,<79.0a0 + - libcxx >=19 + - libexpat >=2.7.3,<3.0a0 + - libfreetype >=2.14.1 + - libfreetype6 >=2.14.1 + - libglib >=2.86.3,<3.0a0 + - libpng >=1.6.53,<1.7.0a0 + - libzlib >=1.3.1,<2.0a0 + - pixman >=0.46.4,<1.0a0 + license: LGPL-2.1-only or MPL-1.1 + purls: [] + size: 900035 + timestamp: 1766416416791 - conda: https://conda.anaconda.org/conda-forge/win-64/cairo-1.18.4-h477c42c_1.conda sha256: 9ee4ad706c5d3e1c6c469785d60e3c2b263eec569be0eac7be33fbaef978bccc md5: 52ea1beba35b69852d210242dd20f97d @@ -2806,6 +3946,11 @@ packages: - pkg:pypi/cdsapi?source=hash-mapping size: 17643 timestamp: 1759286472486 +- pypi: https://files.pythonhosted.org/packages/ef/2f/c5464532e965badff2f4c4c1a3a83f5697f0d7c407ed0cda44aaa99bb451/certifi-2026.6.17-py3-none-any.whl + name: certifi + version: 2026.6.17 + sha256: 2227dcbaafe0d2f59279d1762ddddc37783ed4354594f194ffc31d20f41fc3db + requires_python: '>=3.7' - conda: https://conda.anaconda.org/conda-forge/noarch/certifi-2026.6.17-pyhd8ed1ab_0.conda sha256: 6c13620e458ba43278379d0cdacc30c497336bddfda81681fd50d114a65c702f md5: c13824fedced67005d3832c152fe9c2f @@ -2816,6 +3961,49 @@ packages: - pkg:pypi/certifi?source=compressed-mapping size: 133877 timestamp: 1781719949728 +- pypi: https://files.pythonhosted.org/packages/22/d5/e605e4b28363e7a9ae98ed12cabbda5b155b6009270e6a231d8f10182a17/cftime-1.6.5-cp314-cp314-win_amd64.whl + name: cftime + version: 1.6.5 + sha256: e645b095dc50a38ac454b7e7f0742f639e7d7f6b108ad329358544a6ff8c9ba2 + requires_dist: + - numpy>=1.21.2 + requires_python: '>=3.10' +- pypi: https://files.pythonhosted.org/packages/7f/89/648397f9936e0b330999c4e776ebf296ec3c6a65f9901687dbca4ab820da/cftime-1.6.5-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl + name: cftime + version: 1.6.5 + sha256: bff865b4ea4304f2744a1ad2b8149b8328b321dd7a2b9746ef926d229bd7cd49 + requires_dist: + - numpy>=1.21.2 + requires_python: '>=3.10' +- pypi: https://files.pythonhosted.org/packages/d8/e3/da3c36398bfb730b96248d006cabaceed87e401ff56edafb2a978293e228/cftime-1.6.5-cp314-cp314-macosx_11_0_arm64.whl + name: cftime + version: 1.6.5 + sha256: e62e9f2943e014c5ef583245bf2e878398af131c97e64f8cd47c1d7baef5c4e2 + requires_dist: + - numpy>=1.21.2 + requires_python: '>=3.10' +- pypi: https://files.pythonhosted.org/packages/ea/6c/a9618f589688358e279720f5c0fe67ef0077fba07334ce26895403ebc260/cftime-1.6.5-cp314-cp314-macosx_10_15_x86_64.whl + name: cftime + version: 1.6.5 + sha256: c69ce3bdae6a322cbb44e9ebc20770d47748002fb9d68846a1e934f1bd5daf0b + requires_dist: + - numpy>=1.21.2 + requires_python: '>=3.10' +- pypi: https://files.pythonhosted.org/packages/49/fd/a1d26144398c67486422a72bf5812cda22cb4ccfcd95a290fb41ceb4b8e2/charset_normalizer-3.4.9-cp314-cp314-win_amd64.whl + name: charset-normalizer + version: 3.4.9 + sha256: 16b65ea0f2465b6fb52aa22de5eca612aa964ddfec00a912e26f4656cbef890b + requires_python: '>=3.7' +- pypi: https://files.pythonhosted.org/packages/7e/8d/496817fa0944239ecae662dd57ea765cfeaec6a735f9f025d4b7b72e7143/charset_normalizer-3.4.9-cp314-cp314-macosx_10_15_universal2.whl + name: charset-normalizer + version: 3.4.9 + sha256: 0327fcd59a935777d83410750c50600ee9571af2846f71ce40f25b13da1ef380 + requires_python: '>=3.7' +- pypi: https://files.pythonhosted.org/packages/f4/c4/b3e049d2aa3766180c78507110543d9d50894cc97f57de543f1be521dcdc/charset_normalizer-3.4.9-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl + name: charset-normalizer + version: 3.4.9 + sha256: c25fe15c70c59eb7c5ce8c06a1f3fa1da0ecc5ea1e7a5922c40fd2fa9b0d5046 + requires_python: '>=3.7' - conda: https://conda.anaconda.org/conda-forge/noarch/charset-normalizer-3.4.9-pyhd8ed1ab_0.conda sha256: 8d8813ef655b4e75e4fb897abd83ad548882efad7b4e836b021b797f42780799 md5: d154b40b109e503430979e8a8d099eaf @@ -2827,6 +4015,18 @@ packages: - pkg:pypi/charset-normalizer?source=compressed-mapping size: 61418 timestamp: 1783505332569 +- pypi: https://files.pythonhosted.org/packages/fb/e2/79c688af8b210d232694e31e59da9f6ec747bae31c3f5946e4e9b98860d5/click-8.4.2-py3-none-any.whl + name: click + version: 8.4.2 + sha256: e6f9f66136c816745b9d65817da91d61d957fb16e02e4dcd0552553c5a197b76 + requires_dist: + - colorama ; sys_platform == 'win32' + requires_python: '>=3.10' +- pypi: https://files.pythonhosted.org/packages/88/39/799be3f2f0f38cc727ee3b4f1445fe6d5e4133064ec2e4115069418a5bb6/cloudpickle-3.1.2-py3-none-any.whl + name: cloudpickle + version: 3.1.2 + sha256: 9acb47f6afd73f60dc1df93bb801b472f05ff42fa6c84167d25cb206be1fbf4a + requires_python: '>=3.8' - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_1.conda sha256: ab29d57dc70786c1269633ba3dff20288b81664d3ff8d21af995742e2bb03287 md5: 962b9857ee8e7018c22f2776ffa0b2d7 @@ -2850,6 +4050,34 @@ packages: - pkg:pypi/comm?source=hash-mapping size: 12103 timestamp: 1733503053903 +- conda: https://conda.anaconda.org/conda-forge/noarch/comm-0.2.3-pyhe01879c_0.conda + sha256: 576a44729314ad9e4e5ebe055fbf48beb8116b60e58f9070278985b2b634f212 + md5: 2da13f2b299d8e1995bafbbe9689a2f7 + depends: + - python >=3.9 + - python + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/comm?source=hash-mapping + size: 14690 + timestamp: 1753453984907 +- conda: https://conda.anaconda.org/conda-forge/linux-64/contourpy-1.3.3-py314h97ea11e_4.conda + sha256: b0314a7f1fb4a294b1a8bcf5481d4a8d9412a9fee23b7e3f93fb10e4d504f2cc + md5: 95bede9cdb7a30a4b611223d52a01aa4 + depends: + - numpy >=1.25 + - python + - libstdcxx >=14 + - libgcc >=14 + - __glibc >=2.17,<3.0.a0 + - python_abi 3.14.* *_cp314 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/contourpy?source=hash-mapping + size: 324013 + timestamp: 1769155968691 - conda: https://conda.anaconda.org/conda-forge/linux-64/contourpy-1.3.3-py314h9891dd4_3.conda sha256: 54c79736927c787e535db184bb7f3bce13217cb7d755c50666cfc0da7c6c86f3 md5: 72d57382d0f63c20a16b1d514fcde6ff @@ -2881,6 +4109,21 @@ packages: - pkg:pypi/contourpy?source=hash-mapping size: 270248 timestamp: 1762525788641 +- conda: https://conda.anaconda.org/conda-forge/osx-64/contourpy-1.3.3-py314h22a2ed9_4.conda + sha256: 3ddca2f889e37e4b26c2e86d245fc56769b00334bfaf1caf612140eec77ce71d + md5: 511f02f632e1fb0555da3cb4261851d9 + depends: + - numpy >=1.25 + - python + - libcxx >=19 + - __osx >=10.13 + - python_abi 3.14.* *_cp314 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/contourpy?source=hash-mapping + size: 301747 + timestamp: 1769156235399 - conda: https://conda.anaconda.org/conda-forge/osx-arm64/contourpy-1.3.3-py314h784bc60_3.conda sha256: e5ca7f079f9bd49a9fce837dfe9014d96603600a29e5575cce19895d3639182c md5: d75fae59fe0c8863de391e95959b2c65 @@ -2897,6 +4140,22 @@ packages: - pkg:pypi/contourpy?source=hash-mapping size: 262199 timestamp: 1762525837746 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/contourpy-1.3.3-py314hf8a3a22_4.conda + sha256: 754ab72f1c1ae99ef7c57995f59224dc9632cbd6731fe7e6277437fd01d43156 + md5: cddc851000ce131d757678c2f329eaad + depends: + - numpy >=1.25 + - python + - python 3.14.* *_cp314 + - __osx >=11.0 + - libcxx >=19 + - python_abi 3.14.* *_cp314 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/contourpy?source=hash-mapping + size: 290405 + timestamp: 1769156069514 - conda: https://conda.anaconda.org/conda-forge/win-64/contourpy-1.3.3-py314h909e829_3.conda sha256: f014eb687eb8dd25cec124594f4e48cf85803ff1db85a2a1f95719f9ec6434d2 md5: 3647d90eea49efc6076729ef0ae81075 @@ -2913,6 +4172,22 @@ packages: - pkg:pypi/contourpy?source=hash-mapping size: 227536 timestamp: 1762525688384 +- conda: https://conda.anaconda.org/conda-forge/win-64/contourpy-1.3.3-py314hf309875_4.conda + sha256: f141bcbf8e490b49b2f53f517173d13a64d75e43cfae170e0d931cb0b66f4bce + md5: c26934035616f7d578f9da0491aed3d8 + depends: + - numpy >=1.25 + - python + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + - ucrt >=10.0.20348.0 + - python_abi 3.14.* *_cp314 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/contourpy?source=hash-mapping + size: 247437 + timestamp: 1769155978556 - conda: https://conda.anaconda.org/conda-forge/noarch/cpython-3.14.2-py314hd8ed1ab_100.conda noarch: generic sha256: 9e345f306446500956ffb1414b773f5476f497d7a2b5335a59edd2c335209dbb @@ -2924,6 +4199,17 @@ packages: purls: [] size: 49298 timestamp: 1765020324943 +- conda: https://conda.anaconda.org/conda-forge/noarch/cpython-3.14.6-py314hd8ed1ab_100.conda + noarch: generic + sha256: 7a548856ef5307890a8cadfc196655117658f8c24589ce175caa4c1c2ded9d13 + md5: b28fe35fd43d5f425c0dccbe5b5039fd + depends: + - python >=3.14,<3.15.0a0 + - python_abi * *_cp314 + license: Python-2.0 + purls: [] + size: 49333 + timestamp: 1781254618863 - conda: https://conda.anaconda.org/conda-forge/noarch/cycler-0.12.1-pyhcf101f3_2.conda sha256: bb47aec5338695ff8efbddbc669064a3b10fe34ad881fb8ad5d64fbfa6910ed1 md5: 4c2a8fef270f6c69591889b93f9f55c1 @@ -2936,6 +4222,22 @@ packages: - pkg:pypi/cycler?source=compressed-mapping size: 14778 timestamp: 1764466758386 +- conda: https://conda.anaconda.org/conda-forge/linux-64/cyrus-sasl-2.1.28-hac629b4_1.conda + sha256: 7684da83306bb69686c0506fb09aa7074e1a55ade50c3a879e4e5df6eebb1009 + md5: af491aae930edc096b58466c51c4126c + depends: + - __glibc >=2.17,<3.0.a0 + - krb5 >=1.22.2,<1.23.0a0 + - libgcc >=13 + - libntlm >=1.8,<2.0a0 + - libstdcxx >=13 + - libxcrypt >=4.4.36 + - openssl >=3.5.5,<4.0a0 + license: BSD-3-Clause-Attribution + license_family: BSD + purls: [] + size: 210103 + timestamp: 1771943128249 - conda: https://conda.anaconda.org/conda-forge/linux-64/cyrus-sasl-2.1.28-hd9c7081_0.conda sha256: ee09ad7610c12c7008262d713416d0b58bf365bc38584dce48950025850bdf3f md5: cae723309a49399d2949362f4ab5c9e4 @@ -2952,6 +4254,37 @@ packages: purls: [] size: 209774 timestamp: 1750239039316 +- pypi: https://files.pythonhosted.org/packages/90/aa/ceeb81d9dc886d445416310f0eff5c3978f20224b4143e96e36b7e85b011/dask-2026.7.0-py3-none-any.whl + name: dask + version: 2026.7.0 + sha256: 68def8b467529ab8425ef9fcc6735dcaefaaf715d5e19ae219485f99a394dbef + requires_dist: + - click>=8.1 + - cloudpickle>=3.0.0 + - fsspec>=2021.9.0 + - packaging>=20.0 + - partd>=1.4.0 + - pyyaml>=5.4.1 + - toolz>=0.12.0 + - importlib-metadata>=4.13.0 ; python_full_version < '3.12' + - numpy>=1.24 ; extra == 'array' + - dask[array] ; extra == 'dataframe' + - pandas>=2.0 ; extra == 'dataframe' + - pyarrow>=16.0 ; extra == 'dataframe' + - distributed>=2026.7.0,<2026.7.1 ; extra == 'distributed' + - bokeh>=3.1.0 ; extra == 'diagnostics' + - jinja2>=2.10.3 ; extra == 'diagnostics' + - dask[array,dataframe,diagnostics,distributed] ; extra == 'complete' + - lz4>=4.3.2 ; extra == 'complete' + - pandas[test] ; extra == 'test' + - pytest ; extra == 'test' + - pytest-cov ; extra == 'test' + - pytest-mock ; extra == 'test' + - pytest-rerunfailures ; extra == 'test' + - pytest-timeout ; extra == 'test' + - pytest-xdist ; extra == 'test' + - pre-commit ; extra == 'test' + requires_python: '>=3.10' - conda: https://conda.anaconda.org/conda-forge/linux-64/dbus-1.16.2-h24cb091_1.conda sha256: 8bb557af1b2b7983cf56292336a1a1853f26555d9c6cecf1e5b2b96838c9da87 md5: ce96f2f470d39bd96ce03945af92e280 @@ -2981,6 +4314,21 @@ packages: - pkg:pypi/debugpy?source=hash-mapping size: 2888322 timestamp: 1765704065377 +- conda: https://conda.anaconda.org/conda-forge/linux-64/debugpy-1.8.21-py314h42812f9_0.conda + sha256: c16696b23e1d75b6eea7d0c8b9c31c03d1987eeb61852f09b6d4042ca015acd3 + md5: a7eb8029c4fe320c0179085707017c2d + depends: + - python + - libgcc >=14 + - libstdcxx >=14 + - __glibc >=2.17,<3.0.a0 + - python_abi 3.14.* *_cp314 + license: MIT + license_family: MIT + purls: + - pkg:pypi/debugpy?source=hash-mapping + size: 2842115 + timestamp: 1780390153580 - conda: https://conda.anaconda.org/conda-forge/osx-64/debugpy-1.8.12-py313h14b76d3_0.conda sha256: 8fdb27f2de750ad6d5c9fe9efe1f939d1aee9ede7e59c90e5d20454ab1464685 md5: cca7def5d30d08e0d16191ce4558aab4 @@ -2995,6 +4343,20 @@ packages: - pkg:pypi/debugpy?source=hash-mapping size: 2600782 timestamp: 1737269952447 +- conda: https://conda.anaconda.org/conda-forge/osx-64/debugpy-1.8.21-py314h2883b87_0.conda + sha256: b5856795fcb21ae23ab23ec68cd6ab65d63ae24721dfa7cc0e6a845e341f274d + md5: fd360becf1092353288125e00fe26d6f + depends: + - python + - __osx >=11.0 + - libcxx >=19 + - python_abi 3.14.* *_cp314 + license: MIT + license_family: MIT + purls: + - pkg:pypi/debugpy?source=hash-mapping + size: 2790917 + timestamp: 1780390287062 - conda: https://conda.anaconda.org/conda-forge/osx-arm64/debugpy-1.8.19-py314hf820bb6_0.conda sha256: 5c263dafa3660660087443ad37e32e0597067cf098b351230a76adf83e462e12 md5: 45961f5d077fca30eeff1a1973aca63d @@ -3010,6 +4372,21 @@ packages: - pkg:pypi/debugpy?source=hash-mapping size: 2776268 timestamp: 1765840821598 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/debugpy-1.8.21-py314he609de1_0.conda + sha256: fd6df772cdb30d01fa0d405ed637f420a9f2194fe931f967e8c67d95b504f8b4 + md5: da29307f59fb7a63f686ec20724fecf9 + depends: + - python + - libcxx >=19 + - __osx >=11.0 + - python 3.14.* *_cp314 + - python_abi 3.14.* *_cp314 + license: MIT + license_family: MIT + purls: + - pkg:pypi/debugpy?source=hash-mapping + size: 2776045 + timestamp: 1780390212997 - conda: https://conda.anaconda.org/conda-forge/win-64/debugpy-1.8.19-py314hb98de8c_0.conda sha256: 0ad7f50f664ede3aafcd23458ce4f669f63e32f7efb74c0938260bdb829679df md5: 3361deac30d356844406fbe6def54d5b @@ -3025,6 +4402,21 @@ packages: - pkg:pypi/debugpy?source=hash-mapping size: 4021751 timestamp: 1765840833937 +- conda: https://conda.anaconda.org/conda-forge/win-64/debugpy-1.8.21-py314hb98de8c_0.conda + sha256: daa9397ffba6722f27c21b2f0a02b197f3ba9baedb484a155539743ec5ea3ac3 + md5: 945786ac874b8e821a675fbdd885f844 + depends: + - python + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + - ucrt >=10.0.20348.0 + - python_abi 3.14.* *_cp314 + license: MIT + license_family: MIT + purls: + - pkg:pypi/debugpy?source=hash-mapping + size: 4022782 + timestamp: 1780390190830 - conda: https://conda.anaconda.org/conda-forge/noarch/decorator-5.1.1-pyhd8ed1ab_1.conda sha256: 84e5120c97502a3785e8c3241c3bf51f64b4d445f13b4d2445db00d9816fe479 md5: d622d8d7ee8868870f9cbe259f381181 @@ -3036,6 +4428,17 @@ packages: - pkg:pypi/decorator?source=hash-mapping size: 14068 timestamp: 1733236549190 +- conda: https://conda.anaconda.org/conda-forge/noarch/decorator-5.3.1-pyhd8ed1ab_0.conda + sha256: 430bd9d731b265f0bedb3183ac3ecfaa1656390c092b6e864ff8cc1229843c8c + md5: 61dcf784d59ef0bd62c57d982b154ace + depends: + - python >=3.10 + license: BSD-2-Clause + license_family: BSD + purls: + - pkg:pypi/decorator?source=compressed-mapping + size: 16102 + timestamp: 1779115228886 - conda: https://conda.anaconda.org/conda-forge/linux-64/double-conversion-3.4.0-hecca717_0.conda sha256: 40cdd1b048444d3235069d75f9c8e1f286db567f6278a93b4f024e5642cfaecc md5: dbe3ec0f120af456b3477743ffd99b74 @@ -3129,6 +4532,39 @@ packages: - pkg:pypi/executing?source=hash-mapping size: 28348 timestamp: 1733569440265 +- conda: https://conda.anaconda.org/conda-forge/noarch/executing-2.2.1-pyhd8ed1ab_0.conda + sha256: 210c8165a58fdbf16e626aac93cc4c14dbd551a01d1516be5ecad795d2422cad + md5: ff9efb7f7469aed3c4a8106ffa29593c + depends: + - python >=3.10 + license: MIT + license_family: MIT + purls: + - pkg:pypi/executing?source=hash-mapping + size: 30753 + timestamp: 1756729456476 +- pypi: https://files.pythonhosted.org/packages/27/cd/c883e1a7c447479d6e13985565080e3fea88ab5a107c21684c813dba1875/flexcache-0.3-py3-none-any.whl + name: flexcache + version: '0.3' + sha256: d43c9fea82336af6e0115e308d9d33a185390b8346a017564611f1466dcd2e32 + requires_dist: + - typing-extensions + - pytest ; extra == 'test' + - pytest-mpl ; extra == 'test' + - pytest-cov ; extra == 'test' + - pytest-subtests ; extra == 'test' + requires_python: '>=3.9' +- pypi: https://files.pythonhosted.org/packages/fe/5e/3be305568fe5f34448807976dc82fc151d76c3e0e03958f34770286278c1/flexparser-0.4-py3-none-any.whl + name: flexparser + version: '0.4' + sha256: 3738b456192dcb3e15620f324c447721023c0293f6af9955b481e91d00179846 + requires_dist: + - typing-extensions + - pytest ; extra == 'test' + - pytest-mpl ; extra == 'test' + - pytest-cov ; extra == 'test' + - pytest-subtests ; extra == 'test' + requires_python: '>=3.9' - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-dejavu-sans-mono-2.37-hab24e00_0.tar.bz2 sha256: 58d7f40d2940dd0a8aa28651239adbf5613254df0f75789919c4e6762054403b md5: 0c96522c6bdaed4b1566d11387caaf45 @@ -3176,6 +4612,52 @@ packages: purls: [] size: 265599 timestamp: 1730283881107 +- conda: https://conda.anaconda.org/conda-forge/linux-64/fontconfig-2.18.1-h27c8c51_0.conda + sha256: 2e50bdcebdf70a865b81f2456bbc586386451ec601c60f2b6cd22b8c40a2d384 + md5: e0e050cfa9fa85fe39632ab11cb7f3e0 + depends: + - __glibc >=2.17,<3.0.a0 + - libexpat >=2.8.1,<3.0a0 + - libfreetype >=2.14.3 + - libfreetype6 >=2.14.3 + - libgcc >=14 + - libuuid >=2.42.1,<3.0a0 + - libzlib >=1.3.2,<2.0a0 + license: MIT + license_family: MIT + purls: [] + size: 281880 + timestamp: 1780450077431 +- conda: https://conda.anaconda.org/conda-forge/osx-64/fontconfig-2.18.1-h7a4440b_0.conda + sha256: 134aed823beae85798607e32b78aa1368afbfbea145a43c974d88269f1013287 + md5: 17925ae2a399d859c0b978934df591e3 + depends: + - __osx >=11.0 + - libexpat >=2.8.1,<3.0a0 + - libfreetype >=2.14.3 + - libfreetype6 >=2.14.3 + - libintl >=0.25.1,<1.0a0 + - libzlib >=1.3.2,<2.0a0 + license: MIT + license_family: MIT + purls: [] + size: 247884 + timestamp: 1780450811484 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/fontconfig-2.18.1-h2b252f5_0.conda + sha256: 8607d8d0b32f9f6fc61ea8c06b537486b78428a04516658222fa4d1d521af765 + md5: 9d928e6a62192141fb6540a3125b1345 + depends: + - __osx >=11.0 + - libexpat >=2.8.1,<3.0a0 + - libfreetype >=2.14.3 + - libfreetype6 >=2.14.3 + - libintl >=0.25.1,<1.0a0 + - libzlib >=1.3.2,<2.0a0 + license: MIT + license_family: MIT + purls: [] + size: 248677 + timestamp: 1780450500773 - conda: https://conda.anaconda.org/conda-forge/win-64/fontconfig-2.15.0-h765892d_1.conda sha256: ed122fc858fb95768ca9ca77e73c8d9ddc21d4b2e13aaab5281e27593e840691 md5: 9bb0026a2131b09404c59c4290c697cd @@ -3192,6 +4674,24 @@ packages: purls: [] size: 192355 timestamp: 1730284147944 +- conda: https://conda.anaconda.org/conda-forge/win-64/fontconfig-2.18.1-hd47e2ca_0.conda + sha256: 9217184c4a8e82101b0e512b059ae3ff67e3913133b9031edad89ab5341284e4 + md5: abd79bad98c99c1a116154d6de74ea89 + depends: + - libexpat >=2.8.1,<3.0a0 + - libfreetype >=2.14.3 + - libfreetype6 >=2.14.3 + - libiconv >=1.18,<2.0a0 + - libintl >=0.22.5,<1.0a0 + - libzlib >=1.3.2,<2.0a0 + - ucrt >=10.0.20348.0 + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + license: MIT + license_family: MIT + purls: [] + size: 202630 + timestamp: 1780450217840 - conda: https://conda.anaconda.org/conda-forge/noarch/fonts-conda-ecosystem-1-0.tar.bz2 sha256: a997f2f1921bb9c9d76e6fa2f6b408b7fa549edd349a77639c9fe7a23ea93e61 md5: fee5683a3f04bd15cbd8318b096a27ab @@ -3231,6 +4731,22 @@ packages: - pkg:pypi/fonttools?source=hash-mapping size: 834764 timestamp: 1765632669874 +- conda: https://conda.anaconda.org/conda-forge/noarch/fonttools-4.63.0-pyh7db6752_0.conda + sha256: c9752235f1ff7061d834e5e4a3d0adf71ebeeff2b3fad82dab607edce7f70c91 + md5: 0509ee74d95e5b98eb6fe2a47760e399 + depends: + - brotli + - munkres + - python >=3.10 + - unicodedata2 >=15.1.0 + track_features: + - fonttools_no_compile + license: MIT + license_family: MIT + purls: + - pkg:pypi/fonttools?source=hash-mapping + size: 846038 + timestamp: 1778770337113 - conda: https://conda.anaconda.org/conda-forge/osx-64/fonttools-4.61.1-py313h0f4d31d_0.conda sha256: 5375b893af274c09b265e65af8ff49016e0d23c8e03509d830be09eda46585e9 md5: 77978c974cba250d6ee95a4c29aad08e @@ -3256,6 +4772,16 @@ packages: purls: [] size: 173114 timestamp: 1757945422243 +- conda: https://conda.anaconda.org/conda-forge/linux-64/freetype-2.14.3-ha770c72_0.conda + sha256: c934c385889c7836f034039b43b05ccfa98f53c900db03d8411189892ced090b + md5: 8462b5322567212beeb025f3519fb3e2 + depends: + - libfreetype 2.14.3 ha770c72_0 + - libfreetype6 2.14.3 h73754d4_0 + license: GPL-2.0-only OR FTL + purls: [] + size: 173839 + timestamp: 1774298173462 - conda: https://conda.anaconda.org/conda-forge/osx-64/freetype-2.14.1-h694c41f_0.conda sha256: 9f8282510db291496e89618fc66a58a1124fe7a6276fbd57ed18c602ce2576e9 md5: ca641fdf8b7803f4b7212b6d66375930 @@ -3264,28 +4790,237 @@ packages: - libfreetype6 2.14.1 h6912278_0 license: GPL-2.0-only OR FTL purls: [] - size: 173969 - timestamp: 1757945973505 -- conda: https://conda.anaconda.org/conda-forge/osx-arm64/freetype-2.14.1-hce30654_0.conda - sha256: 14427aecd72e973a73d5f9dfd0e40b6bc3791d253de09b7bf233f6a9a190fd17 - md5: 1ec9a1ee7a2c9339774ad9bb6fe6caec + size: 173969 + timestamp: 1757945973505 +- conda: https://conda.anaconda.org/conda-forge/osx-64/freetype-2.14.3-h694c41f_1.conda + sha256: c67130a919d3c7733fce056cc2ce8cec2935e295547d5d70bcbf35e4351d543b + md5: 48fc845b770770e9c7db8743f6d53d44 + depends: + - libfreetype 2.14.3 h694c41f_1 + - libfreetype6 2.14.3 h58fbd8d_1 + license: GPL-2.0-only OR FTL + purls: [] + size: 174300 + timestamp: 1780934162319 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/freetype-2.14.1-hce30654_0.conda + sha256: 14427aecd72e973a73d5f9dfd0e40b6bc3791d253de09b7bf233f6a9a190fd17 + md5: 1ec9a1ee7a2c9339774ad9bb6fe6caec + depends: + - libfreetype 2.14.1 hce30654_0 + - libfreetype6 2.14.1 h6da58f4_0 + license: GPL-2.0-only OR FTL + purls: [] + size: 173399 + timestamp: 1757947175403 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/freetype-2.14.3-hce30654_1.conda + sha256: 96b33f1e2a32c602b167f43719e3acf89ec742b4a1e25e99ffd0e6f99b38d277 + md5: 7bd06ab4ed807154c2d9031eb5ebf025 + depends: + - libfreetype 2.14.3 hce30654_1 + - libfreetype6 2.14.3 hdfa99f5_1 + license: GPL-2.0-only OR FTL + purls: [] + size: 173518 + timestamp: 1780933616544 +- conda: https://conda.anaconda.org/conda-forge/win-64/freetype-2.14.1-h57928b3_0.conda + sha256: a9b3313edea0bf14ea6147ea43a1059d0bf78771a1336d2c8282891efc57709a + md5: d69c21967f35eb2ce7f1f85d6b6022d3 + depends: + - libfreetype 2.14.1 h57928b3_0 + - libfreetype6 2.14.1 hdbac1cb_0 + license: GPL-2.0-only OR FTL + purls: [] + size: 184553 + timestamp: 1757946164012 +- conda: https://conda.anaconda.org/conda-forge/win-64/freetype-2.14.3-h57928b3_1.conda + sha256: a0e419e96146159f12344c870dca608d11bca36841f228092b986ffc2e1e0f02 + md5: e77293b32225b136a8be300f93d0e89f + depends: + - libfreetype 2.14.3 h57928b3_1 + - libfreetype6 2.14.3 hdbac1cb_1 + - zlib + license: GPL-2.0-only OR FTL + purls: [] + size: 185584 + timestamp: 1780934817461 +- conda: https://conda.anaconda.org/conda-forge/linux-64/fribidi-1.0.16-hb03c661_0.conda + sha256: 858283ff33d4c033f4971bf440cebff217d5552a5222ba994c49be990dacd40d + md5: f9f81ea472684d75b9dd8d0b328cf655 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + license: LGPL-2.1-or-later + purls: [] + size: 61244 + timestamp: 1757438574066 +- conda: https://conda.anaconda.org/conda-forge/osx-64/fribidi-1.0.16-h8616949_0.conda + sha256: 53dd0a6c561cf31038633aaa0d52be05da1f24e86947f06c4e324606c72c7413 + md5: 4422491d30462506b9f2d554ab55e33d + depends: + - __osx >=10.13 + license: LGPL-2.1-or-later + purls: [] + size: 60923 + timestamp: 1757438791418 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/fribidi-1.0.16-hc919400_0.conda + sha256: d856dc6744ecfba78c5f7df3378f03a75c911aadac803fa2b41a583667b4b600 + md5: 04bdce8d93a4ed181d1d726163c2d447 + depends: + - __osx >=11.0 + license: LGPL-2.1-or-later + purls: [] + size: 59391 + timestamp: 1757438897523 +- conda: https://conda.anaconda.org/conda-forge/win-64/fribidi-1.0.16-hfd05255_0.conda + sha256: 15011071ee56c216ffe276c8d734427f1f893f275ef733f728d13f610ed89e6e + md5: c27bd87e70f970010c1c6db104b88b18 + depends: + - ucrt >=10.0.20348.0 + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + license: LGPL-2.1-or-later + purls: [] + size: 64394 + timestamp: 1757438741305 +- pypi: https://files.pythonhosted.org/packages/e5/22/4222d7ddf3da30f363edaa98e329c2bce6c65497c9cb2810931c8b2c0fbc/fsspec-2026.6.0-py3-none-any.whl + name: fsspec + version: 2026.6.0 + sha256: 02e0b71817df9b2169dc30a16832045764def1191b43dcff5bb85bdee212d2a1 + requires_dist: + - adlfs ; extra == 'abfs' + - adlfs ; extra == 'adl' + - pyarrow>=1 ; extra == 'arrow' + - dask ; extra == 'dask' + - distributed ; extra == 'dask' + - pre-commit ; extra == 'dev' + - ruff>=0.5 ; extra == 'dev' + - numpydoc ; extra == 'doc' + - sphinx ; extra == 'doc' + - sphinx-design ; extra == 'doc' + - sphinx-rtd-theme ; extra == 'doc' + - yarl ; extra == 'doc' + - dropbox ; extra == 'dropbox' + - dropboxdrivefs ; extra == 'dropbox' + - requests ; extra == 'dropbox' + - adlfs ; extra == 'full' + - aiohttp!=4.0.0a0,!=4.0.0a1 ; extra == 'full' + - dask ; extra == 'full' + - distributed ; extra == 'full' + - dropbox ; extra == 'full' + - dropboxdrivefs ; extra == 'full' + - fusepy ; extra == 'full' + - gcsfs>2024.2.0 ; extra == 'full' + - libarchive-c ; extra == 'full' + - ocifs ; extra == 'full' + - panel ; extra == 'full' + - paramiko ; extra == 'full' + - pyarrow>=1 ; extra == 'full' + - pygit2 ; extra == 'full' + - requests ; extra == 'full' + - s3fs>2024.2.0 ; extra == 'full' + - smbprotocol ; extra == 'full' + - tqdm ; extra == 'full' + - fusepy ; extra == 'fuse' + - gcsfs>2024.2.0 ; extra == 'gcs' + - pygit2 ; extra == 'git' + - requests ; extra == 'github' + - gcsfs ; extra == 'gs' + - panel ; extra == 'gui' + - pyarrow>=1 ; extra == 'hdfs' + - aiohttp!=4.0.0a0,!=4.0.0a1 ; extra == 'http' + - libarchive-c ; extra == 'libarchive' + - ocifs ; extra == 'oci' + - s3fs>2024.2.0 ; extra == 's3' + - paramiko ; extra == 'sftp' + - smbprotocol ; extra == 'smb' + - paramiko ; extra == 'ssh' + - aiohttp!=4.0.0a0,!=4.0.0a1 ; extra == 'test' + - numpy ; extra == 'test' + - pytest ; extra == 'test' + - pytest-asyncio!=0.22.0 ; extra == 'test' + - pytest-benchmark ; extra == 'test' + - pytest-cov ; extra == 'test' + - pytest-mock ; extra == 'test' + - pytest-recording ; extra == 'test' + - pytest-rerunfailures ; extra == 'test' + - requests ; extra == 'test' + - aiobotocore>=2.5.4,<3.0.0 ; extra == 'test-downstream' + - dask[dataframe,test] ; extra == 'test-downstream' + - moto[server]>4,<5 ; extra == 'test-downstream' + - pytest-timeout ; extra == 'test-downstream' + - xarray ; extra == 'test-downstream' + - adlfs ; extra == 'test-full' + - aiohttp!=4.0.0a0,!=4.0.0a1 ; extra == 'test-full' + - backports-zstd ; python_full_version < '3.14' and extra == 'test-full' + - cloudpickle ; extra == 'test-full' + - dask ; extra == 'test-full' + - distributed ; extra == 'test-full' + - dropbox ; extra == 'test-full' + - dropboxdrivefs ; extra == 'test-full' + - fastparquet ; extra == 'test-full' + - fusepy ; extra == 'test-full' + - gcsfs ; extra == 'test-full' + - jinja2 ; extra == 'test-full' + - kerchunk ; extra == 'test-full' + - libarchive-c ; extra == 'test-full' + - lz4 ; extra == 'test-full' + - notebook ; extra == 'test-full' + - numpy ; extra == 'test-full' + - ocifs ; extra == 'test-full' + - pandas<3.0.0 ; extra == 'test-full' + - panel ; extra == 'test-full' + - paramiko ; extra == 'test-full' + - pyarrow ; extra == 'test-full' + - pyarrow>=1 ; extra == 'test-full' + - pyftpdlib ; extra == 'test-full' + - pygit2 ; extra == 'test-full' + - pytest ; extra == 'test-full' + - pytest-asyncio!=0.22.0 ; extra == 'test-full' + - pytest-benchmark ; extra == 'test-full' + - pytest-cov ; extra == 'test-full' + - pytest-mock ; extra == 'test-full' + - pytest-recording ; extra == 'test-full' + - pytest-rerunfailures ; extra == 'test-full' + - python-snappy ; extra == 'test-full' + - requests ; extra == 'test-full' + - smbprotocol ; extra == 'test-full' + - tqdm ; extra == 'test-full' + - urllib3 ; extra == 'test-full' + - zarr<3.2.0 ; extra == 'test-full' + - zstandard ; python_full_version < '3.14' and extra == 'test-full' + - tqdm ; extra == 'tqdm' + requires_python: '>=3.10' +- conda: https://conda.anaconda.org/conda-forge/win-64/glib-2.88.2-h395db07_0.conda + sha256: b67107959a71dbf9f5c2e95511f18095d9ac6f0001f0de4a1b6e14282162989e + md5: 7d203837b88a2255b32dca555d37ca50 depends: - - libfreetype 2.14.1 hce30654_0 - - libfreetype6 2.14.1 h6da58f4_0 - license: GPL-2.0-only OR FTL + - python * + - packaging + - libglib ==2.88.2 h7ce1215_0 + - glib-tools ==2.88.2 h74ecf4c_0 + - libintl-devel + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + - ucrt >=10.0.20348.0 + - libintl >=0.22.5,<1.0a0 + license: LGPL-2.1-or-later purls: [] - size: 173399 - timestamp: 1757947175403 -- conda: https://conda.anaconda.org/conda-forge/win-64/freetype-2.14.1-h57928b3_0.conda - sha256: a9b3313edea0bf14ea6147ea43a1059d0bf78771a1336d2c8282891efc57709a - md5: d69c21967f35eb2ce7f1f85d6b6022d3 + size: 75973 + timestamp: 1782463965040 +- conda: https://conda.anaconda.org/conda-forge/win-64/glib-tools-2.88.2-h74ecf4c_0.conda + sha256: c604b6ca42c6271f281b1c0616e0d50bd800f8fc913a91a2753c2551b3b6b16c + md5: 63c615f0c525ee64f72e557e583b6257 depends: - - libfreetype 2.14.1 h57928b3_0 - - libfreetype6 2.14.1 hdbac1cb_0 - license: GPL-2.0-only OR FTL + - libglib ==2.88.2 h7ce1215_0 + - libffi + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + - ucrt >=10.0.20348.0 + - libintl >=0.22.5,<1.0a0 + license: LGPL-2.1-or-later purls: [] - size: 184553 - timestamp: 1757946164012 + size: 251644 + timestamp: 1782463965040 - conda: https://conda.anaconda.org/conda-forge/linux-64/graphite2-1.3.14-hecca717_2.conda sha256: 25ba37da5c39697a77fce2c9a15e48cf0a84f1464ad2aafbe53d8357a9f6cc8c md5: 2cd94587f3a401ae05e03a6caf09539d @@ -3298,6 +5033,40 @@ packages: purls: [] size: 99596 timestamp: 1755102025473 +- conda: https://conda.anaconda.org/conda-forge/linux-64/graphite2-1.3.15-hecca717_0.conda + sha256: 885fa7d1d7e2ad9ed0a700ee0d81ceb49de278253082d517959b22d6336eecce + md5: cf09e9fc938518e91d0706572cadf17a + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - libstdcxx >=14 + license: LGPL-2.0-or-later + license_family: LGPL + purls: [] + size: 100054 + timestamp: 1780454302233 +- conda: https://conda.anaconda.org/conda-forge/osx-64/graphite2-1.3.15-hcc62823_0.conda + sha256: aaebae3c0e713579e52de6fd4eec54a172e28c7f90d90da4583e91b1634a7fee + md5: 6a0525cf3166f16b9e156fb6b2cac5c0 + depends: + - __osx >=11.0 + - libcxx >=19 + license: LGPL-2.0-or-later + license_family: LGPL + purls: [] + size: 85964 + timestamp: 1780454502704 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/graphite2-1.3.15-hf6b4638_0.conda + sha256: c0a060d7b7a05669043ef3f68c7a1025c8594e1ab73735afb64c35e8baa41da5 + md5: 0d576cff278a2e60456d5b2c0a1ffda3 + depends: + - __osx >=11.0 + - libcxx >=19 + license: LGPL-2.0-or-later + license_family: LGPL + purls: [] + size: 82245 + timestamp: 1780454628763 - conda: https://conda.anaconda.org/conda-forge/win-64/graphite2-1.3.14-hac47afa_2.conda sha256: 5f1714b07252f885a62521b625898326ade6ca25fbc20727cfe9a88f68a54bfd md5: b785694dd3ec77a011ccf0c24725382b @@ -3310,6 +5079,18 @@ packages: purls: [] size: 96336 timestamp: 1755102441729 +- conda: https://conda.anaconda.org/conda-forge/win-64/graphite2-1.3.15-hac47afa_0.conda + sha256: 88b6601f8edae59834b59b521e293ff3b58361dc1603240f5a8328c24e6936ad + md5: ff9a9bfe791f56b0227597a7651a6af0 + depends: + - ucrt >=10.0.20348.0 + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + license: LGPL-2.0-or-later + license_family: LGPL + purls: [] + size: 97308 + timestamp: 1780454389458 - conda: https://conda.anaconda.org/conda-forge/noarch/h2-4.3.0-pyhcf101f3_0.conda sha256: 84c64443368f84b600bfecc529a1194a3b14c3656ee2e832d15a20e0329b6da3 md5: 164fc43f0b53b6e3a7bc7dce5e4f1dc9 @@ -3368,23 +5149,40 @@ packages: - pkg:pypi/h5py?source=hash-mapping size: 1291384 timestamp: 1764016672412 -- conda: https://conda.anaconda.org/conda-forge/linux-64/h5py-3.16.0-nompi_py310hb9a6f38_102.conda - sha256: 5b5a401c2ee28b1f7eb3a060f51a01b9656c9b01a8960132cd5935afc1704dd4 - md5: 7f5d5bf2d5d86f6b77682895f44b271e +- conda: https://conda.anaconda.org/conda-forge/linux-64/h5py-3.16.0-nompi_py311hfef529e_102.conda + sha256: 9495b6fe2a7b1cf0fded3c53252e964d968fa1fc87cf1ce76c4d9c5e8ab22385 + md5: 5737f2130791c91aee8374ee0d4465de depends: - __glibc >=2.17,<3.0.a0 - cached-property - hdf5 >=2.1.0,<3.0a0 - libgcc >=14 - - numpy >=1.21,<3 - - python >=3.10,<3.11.0a0 - - python_abi 3.10.* *_cp310 + - numpy >=1.23,<3 + - python >=3.11,<3.12.0a0 + - python_abi 3.11.* *_cp311 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/h5py?source=hash-mapping + size: 1359434 + timestamp: 1775581283533 +- conda: https://conda.anaconda.org/conda-forge/linux-64/h5py-3.16.0-nompi_py314hddf7a69_102.conda + sha256: 48e18f20bc1ff15433299dd77c20a4160eb29572eea799ae5a73632c6c3d7dfd + md5: d93afa30018997705dd04513eeb5ac0f + depends: + - __glibc >=2.17,<3.0.a0 + - cached-property + - hdf5 >=2.1.0,<3.0a0 + - libgcc >=14 + - numpy >=1.23,<3 + - python >=3.14,<3.15.0a0 + - python_abi 3.14.* *_cp314 license: BSD-3-Clause license_family: BSD purls: - pkg:pypi/h5py?source=hash-mapping - size: 1259075 - timestamp: 1775581270235 + size: 1345557 + timestamp: 1775581268685 - conda: https://conda.anaconda.org/conda-forge/osx-64/h5py-3.13.0-nompi_py313h6c54384_100.conda sha256: 635c765c81ce0cf59e21028bd06fbc48918b93d38b3411fbde02867919cae815 md5: 0ff889df1c1d8b2f39edf320c5f17443 @@ -3401,22 +5199,38 @@ packages: - pkg:pypi/h5py?source=hash-mapping size: 1218424 timestamp: 1739952606094 -- conda: https://conda.anaconda.org/conda-forge/osx-64/h5py-3.16.0-nompi_py310h05ade02_102.conda - sha256: d2b8d17218bc9eb98cf31a23a66542b37c8b3751c5d56d8f07a5d7da285fb2e5 - md5: 3278edbbb6ecb6453b7de7fdb5eeb210 +- conda: https://conda.anaconda.org/conda-forge/osx-64/h5py-3.16.0-nompi_py311ha7e68cf_102.conda + sha256: 0a4c211e80ffec89f568910b87790471319a59d9ab04db8e32b6d22f2eee351a + md5: f29ebc1fb2896ab15bf2712cf530e843 depends: - __osx >=11.0 - cached-property - hdf5 >=2.1.0,<3.0a0 - - numpy >=1.21,<3 - - python >=3.10,<3.11.0a0 - - python_abi 3.10.* *_cp310 + - numpy >=1.23,<3 + - python >=3.11,<3.12.0a0 + - python_abi 3.11.* *_cp311 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/h5py?source=hash-mapping + size: 1196742 + timestamp: 1775581895921 +- conda: https://conda.anaconda.org/conda-forge/osx-64/h5py-3.16.0-nompi_py314h58ac280_102.conda + sha256: ed5dbbcfe97862078f8703d28d2dee53985f29ef5629f5dca93a8ed5dddcdbd7 + md5: fce5f9ac23f2f8b9fa16cff36c9f33b0 + depends: + - __osx >=11.0 + - cached-property + - hdf5 >=2.1.0,<3.0a0 + - numpy >=1.23,<3 + - python >=3.14,<3.15.0a0 + - python_abi 3.14.* *_cp314 license: BSD-3-Clause license_family: BSD purls: - pkg:pypi/h5py?source=hash-mapping - size: 1106896 - timestamp: 1775581866927 + size: 1207617 + timestamp: 1775581905623 - conda: https://conda.anaconda.org/conda-forge/osx-arm64/h5py-3.15.1-nompi_py314h1c8d760_101.conda sha256: 1add46ebafbab228bbb2db615740b5763f139f65aa110a2996f08695b5fed7d3 md5: 81e42cd3fcea0984435a3c21857e0d50 @@ -3434,23 +5248,40 @@ packages: - pkg:pypi/h5py?source=hash-mapping size: 1157833 timestamp: 1764017977683 -- conda: https://conda.anaconda.org/conda-forge/osx-arm64/h5py-3.16.0-nompi_py310hcf53ec8_102.conda - sha256: 52ac401df6ff7b6c55837f00c5f9c836180ec40df8173696eacdc0b6bd62e15e - md5: 736594a0045aa58223c24d868062b6f9 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/h5py-3.16.0-nompi_py311hf10ccac_102.conda + sha256: 3d8437c0633c9055228db8d1fa00daceea5137075bdbce4bb0f7747466da0b09 + md5: 3921ef0b72feb738aa5f4107bb6bb084 depends: - __osx >=11.0 - cached-property - hdf5 >=2.1.0,<3.0a0 - - numpy >=1.21,<3 - - python >=3.10,<3.11.0a0 - - python >=3.10,<3.11.0a0 *_cpython - - python_abi 3.10.* *_cp310 + - numpy >=1.23,<3 + - python >=3.11,<3.12.0a0 + - python >=3.11,<3.12.0a0 *_cpython + - python_abi 3.11.* *_cp311 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/h5py?source=hash-mapping + size: 1193405 + timestamp: 1775582985212 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/h5py-3.16.0-nompi_py314h658a3ac_102.conda + sha256: 0762ed080bf45ca475da96796a8883a6c719603c44fa9b07a5883785649a4a0f + md5: ab9a6c652fd25407c9cf67b9b6b87496 + depends: + - __osx >=11.0 + - cached-property + - hdf5 >=2.1.0,<3.0a0 + - numpy >=1.23,<3 + - python >=3.14,<3.15.0a0 + - python >=3.14,<3.15.0a0 *_cp314 + - python_abi 3.14.* *_cp314 license: BSD-3-Clause license_family: BSD purls: - pkg:pypi/h5py?source=hash-mapping - size: 1108137 - timestamp: 1775583257878 + size: 1203956 + timestamp: 1775583125726 - conda: https://conda.anaconda.org/conda-forge/win-64/h5py-3.15.1-nompi_py314hc249e69_101.conda sha256: 7a05562f2cf290b50de67eefef6ea704ec2356551a2683b767c511680562eeaa md5: 4019722f94eac6540faf77d20cc4190d @@ -3469,15 +5300,33 @@ packages: - pkg:pypi/h5py?source=hash-mapping size: 1059478 timestamp: 1764017347777 -- conda: https://conda.anaconda.org/conda-forge/win-64/h5py-3.16.0-nompi_py310h6359f78_102.conda - sha256: 49219e91c11029754b60d972fc4a642da38aa4a23d0d6f894a603141e3393c89 - md5: f8fc5762c29c355bc08fdccb9056a721 +- conda: https://conda.anaconda.org/conda-forge/win-64/h5py-3.16.0-nompi_py311ha643933_102.conda + sha256: 4fbbaa9a7e2a76c2bb9c5e57283da819c38b1bcfacf42d44b88b14df96c58e7a + md5: f7dbec60ea42ffbf02383600033411d2 depends: - cached-property - hdf5 >=2.1.0,<3.0a0 - - numpy >=1.21,<3 - - python >=3.10,<3.11.0a0 - - python_abi 3.10.* *_cp310 + - numpy >=1.23,<3 + - python >=3.11,<3.12.0a0 + - python_abi 3.11.* *_cp311 + - ucrt >=10.0.20348.0 + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/h5py?source=hash-mapping + size: 1118145 + timestamp: 1775581977376 +- conda: https://conda.anaconda.org/conda-forge/win-64/h5py-3.16.0-nompi_py314h02517ec_102.conda + sha256: 5ee88f1f691829d2430761a26a690c3d880e7cd41e40a4057131360a8904e0bd + md5: 19bdd6358ce2be9ef29f92b1564db61d + depends: + - cached-property + - hdf5 >=2.1.0,<3.0a0 + - numpy >=1.23,<3 + - python >=3.14,<3.15.0a0 + - python_abi 3.14.* *_cp314 - ucrt >=10.0.20348.0 - vc >=14.3,<15 - vc14_runtime >=14.44.35208 @@ -3485,8 +5334,8 @@ packages: license_family: BSD purls: - pkg:pypi/h5py?source=hash-mapping - size: 1008813 - timestamp: 1775581480372 + size: 1101679 + timestamp: 1775582027560 - conda: https://conda.anaconda.org/conda-forge/linux-64/harfbuzz-12.3.0-h6083320_0.conda sha256: eb0ff4632c76d5840ad8f509dc55694f79d9ac9bea5529944640e28e490361b0 md5: 1ea5ed29aea252072b975a232b195146 @@ -3507,6 +5356,16 @@ packages: purls: [] size: 2062122 timestamp: 1766937132307 +- conda: https://conda.anaconda.org/conda-forge/linux-64/harfbuzz-14.2.1-ha770c72_1.conda + sha256: 853beec89ff91cbbf630f1d305b69153eb28a3cb78af95ddc1fb4d30e524c6f4 + md5: 72e956a71241633d8c80aa198fd08784 + depends: + - libharfbuzz-devel 14.2.1 h17a8019_1 + license: MIT + license_family: MIT + purls: [] + size: 11039 + timestamp: 1782800611635 - conda: https://conda.anaconda.org/conda-forge/win-64/harfbuzz-12.3.0-h5a1b470_0.conda sha256: 158ebfb3ae932162e794da869505761d2d32677a3b80377abef1a3e3499d0c61 md5: 0eb57e84ceeb62c0189827fe7966bdc5 @@ -3527,6 +5386,16 @@ packages: purls: [] size: 1143524 timestamp: 1766937684751 +- conda: https://conda.anaconda.org/conda-forge/win-64/harfbuzz-14.2.1-h57928b3_1.conda + sha256: c8bf564f2c415b82f056eff98b8967fb75c86821398998f20289397b5acf1ef7 + md5: e706de885f817f9832c56f1c9ad7ce71 + depends: + - libharfbuzz-devel 14.2.1 h03b5201_1 + license: MIT + license_family: MIT + purls: [] + size: 11542 + timestamp: 1782801047786 - conda: https://conda.anaconda.org/conda-forge/linux-64/hdf5-1.14.6-nompi_h2d575fe_101.conda sha256: b685b9d68e927f446bead1458c0fbf5ac02e6a471ed7606de427605ac647e8d3 md5: d1f61f912e1968a8ac9834b62fde008d @@ -3787,6 +5656,15 @@ packages: purls: [] size: 14954024 timestamp: 1773822508646 +- pypi: https://files.pythonhosted.org/packages/1e/5e/d4e9f1a599fb8e573b7b87160658329fbf28d19eac2718f51fc3def3aa5a/idna-3.18-py3-none-any.whl + name: idna + version: '3.18' + sha256: 7f952cbe720b688055e3f87de14f5c3e5fdaa8bc3928985c4077ca689de849a2 + requires_dist: + - ruff>=0.6.2 ; extra == 'all' + - mypy>=1.11.2 ; extra == 'all' + - pytest>=8.3.2 ; extra == 'all' + requires_python: '>=3.9' - conda: https://conda.anaconda.org/conda-forge/noarch/idna-3.18-pyhcf101f3_0.conda sha256: c75632ea624aa450a394f570749420c5a2e0997d0216bc29d5d45b0f39df0426 md5: 577b04680ae422adb86fc60d7b940659 @@ -3811,6 +5689,19 @@ packages: - pkg:pypi/importlib-metadata?source=compressed-mapping size: 29141 timestamp: 1737420302391 +- conda: https://conda.anaconda.org/conda-forge/noarch/importlib-metadata-9.0.0-pyhcf101f3_0.conda + sha256: 43e2a5497cad1598ff88a3e69f69bc88b7b8f141fa63c60eab5db296317318b8 + md5: ffc17e785d64e12fc311af9184221839 + depends: + - python >=3.10 + - zipp >=3.20 + - python + license: Apache-2.0 + license_family: APACHE + purls: + - pkg:pypi/importlib-metadata?source=compressed-mapping + size: 34766 + timestamp: 1779714582554 - conda: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.0.0-pyhd8ed1ab_1.conda sha256: 0ec8f4d02053cd03b0f3e63168316530949484f80e16f5e2fb199a1d117a89ca md5: 6837f3eff7dcea42ecd714ce1ac2b108 @@ -3914,6 +5805,88 @@ packages: - pkg:pypi/ipykernel?source=hash-mapping size: 119568 timestamp: 1719845667420 +- conda: https://conda.anaconda.org/conda-forge/noarch/ipykernel-7.3.0-pyh01cf8df_0.conda + sha256: 994d3cb6b9b88a6533f567c50d20f2f6edc40ae3540ce2ee9629492182ab3403 + md5: a1ddab91145f7f06eee769d2f3ac69cd + depends: + - appnope + - __osx + - comm >=0.1.1 + - debugpy >=1.6.5 + - ipython >=7.23.1 + - jupyter_client >=8.9.0 + - jupyter_core >=5.1,!=6.0.* + - matplotlib-inline >=0.1 + - nest-asyncio2 >=1.7.0 + - packaging >=22 + - psutil >=5.7 + - python >=3.10 + - pyzmq >=25 + - tornado >=6.4.1 + - traitlets >=5.4.0 + - python + constrains: + - appnope >=0.1.2 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/ipykernel?source=hash-mapping + size: 137725 + timestamp: 1781101860049 +- conda: https://conda.anaconda.org/conda-forge/noarch/ipykernel-7.3.0-pyh6dadd2b_0.conda + sha256: e3ff0b3d5db5c31830030406f50ac2c9a5c31b86f1c2cef87a6042f0a4c77eb7 + md5: dd5c51d5c42381ba4a2e0ce32e02ba17 + depends: + - __win + - comm >=0.1.1 + - debugpy >=1.6.5 + - ipython >=7.23.1 + - jupyter_client >=8.9.0 + - jupyter_core >=5.1,!=6.0.* + - matplotlib-inline >=0.1 + - nest-asyncio2 >=1.7.0 + - packaging >=22 + - psutil >=5.7 + - python >=3.10 + - pyzmq >=25 + - tornado >=6.4.1 + - traitlets >=5.4.0 + - python + constrains: + - appnope >=0.1.2 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/ipykernel?source=compressed-mapping + size: 138046 + timestamp: 1781101760172 +- conda: https://conda.anaconda.org/conda-forge/noarch/ipykernel-7.3.0-pyha191276_0.conda + sha256: 305ad9226363ff5f259c404dd9a7508183a2e150739b2adc43db7d817234da66 + md5: 2b47a10e4d98334f8171ff60aea05ff3 + depends: + - __linux + - comm >=0.1.1 + - debugpy >=1.6.5 + - ipython >=7.23.1 + - jupyter_client >=8.9.0 + - jupyter_core >=5.1,!=6.0.* + - matplotlib-inline >=0.1 + - nest-asyncio2 >=1.7.0 + - packaging >=22 + - psutil >=5.7 + - python >=3.10 + - pyzmq >=25 + - tornado >=6.4.1 + - traitlets >=5.4.0 + - python + constrains: + - appnope >=0.1.2 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/ipykernel?source=compressed-mapping + size: 138635 + timestamp: 1781101665847 - conda: https://conda.anaconda.org/conda-forge/noarch/ipython-8.32.0-pyh907856f_0.conda sha256: b1b940cfe85d5f0aaed83ef8c9f07ee80daa68acb05feeb5142d620472b01e0d md5: 9de86472b8f207fb098c69daaad50e67 @@ -3962,6 +5935,66 @@ packages: - pkg:pypi/ipython?source=hash-mapping size: 636000 timestamp: 1738421304330 +- conda: https://conda.anaconda.org/conda-forge/noarch/ipython-9.15.0-pyh53cf698_0.conda + sha256: d9fa14ec35119901bf702a9a3e8a5570daef2aada7d03878e4c24d9de912302b + md5: 2f4ea7f616b30363d8dde5cc15e7af2e + depends: + - __unix + - decorator >=5.1.0 + - ipython_pygments_lexers >=1.0.0 + - jedi >=0.18.2 + - matplotlib-inline >=0.1.6 + - prompt-toolkit >=3.0.41,<3.1.0 + - psutil >=7 + - pygments >=2.14.0 + - python >=3.11 + - stack_data >=0.6.0 + - traitlets >=5.13.0 + - typing_extensions >=4.6 + - pexpect >4.6 + - python + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/ipython?source=compressed-mapping + size: 658801 + timestamp: 1782482716877 +- conda: https://conda.anaconda.org/conda-forge/noarch/ipython-9.15.0-pyhe2676ad_0.conda + sha256: c3df12e766572060be653933aae5f6a09ccebfa86cff3b10b9b880ace29088d9 + md5: a4c278221ad4da75ba1637f8d230e658 + depends: + - __win + - decorator >=5.1.0 + - ipython_pygments_lexers >=1.0.0 + - jedi >=0.18.2 + - matplotlib-inline >=0.1.6 + - prompt-toolkit >=3.0.41,<3.1.0 + - psutil >=7 + - pygments >=2.14.0 + - python >=3.11 + - stack_data >=0.6.0 + - traitlets >=5.13.0 + - typing_extensions >=4.6 + - colorama >=0.4.4 + - python + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/ipython?source=hash-mapping + size: 657739 + timestamp: 1782482745122 +- conda: https://conda.anaconda.org/conda-forge/noarch/ipython_pygments_lexers-1.1.1-pyhd8ed1ab_0.conda + sha256: 894682a42a7d659ae12878dbcb274516a7031bbea9104e92f8e88c1f2765a104 + md5: bd80ba060603cc228d9d81c257093119 + depends: + - pygments + - python >=3.9 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/ipython-pygments-lexers?source=hash-mapping + size: 13993 + timestamp: 1737123723464 - conda: https://conda.anaconda.org/conda-forge/noarch/jedi-0.19.2-pyhd8ed1ab_1.conda sha256: 92c4d217e2dc68983f724aa983cca5464dcb929c566627b26a2511159667dba8 md5: a4f4c5dc9b80bc50e0d3dc4e6e8f1bd9 @@ -3973,6 +6006,23 @@ packages: - pkg:pypi/jedi?source=hash-mapping size: 843646 timestamp: 1733300981994 +- conda: https://conda.anaconda.org/conda-forge/noarch/jedi-0.20.0-pyhcf101f3_0.conda + sha256: 744143551c1c7b528b82533fb641b9d7db20b2203abc4c2635c387fa6c089fc3 + md5: c2b3d37aa1411031126036ee76a8a861 + depends: + - python >=3.10 + - parso >=0.8.6,<0.9.0 + - python + license: Apache-2.0 AND MIT + purls: + - pkg:pypi/jedi?source=compressed-mapping + size: 2715215 + timestamp: 1782251948616 +- pypi: https://files.pythonhosted.org/packages/7b/91/984aca2ec129e2757d1e4e3c81c3fcda9d0f85b74670a094cc443d9ee949/joblib-1.5.3-py3-none-any.whl + name: joblib + version: 1.5.3 + sha256: 5fc3c5039fc5ca8c0276333a188bbd59d6b7ab37fe6632daa76bc7f9ec18e713 + requires_python: '>=3.9' - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_client-8.6.3-pyhd8ed1ab_1.conda sha256: 19d8bd5bb2fde910ec59e081eeb59529491995ce0d653a5209366611023a0b3a md5: 4ebae00eae9705b0c3d6d1018a81d047 @@ -3990,6 +6040,24 @@ packages: - pkg:pypi/jupyter-client?source=hash-mapping size: 106342 timestamp: 1733441040958 +- conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_client-8.9.1-pyhcf101f3_0.conda + sha256: 48b18974cc93b2c0d2681563237034e521f51d1878f0bbc6a5a67ca31b1608a6 + md5: 49440e66df843bee2273937e8032ec43 + depends: + - jupyter_core >=5.1 + - python >=3.10 + - python-dateutil >=2.8.2 + - pyzmq >=25.0 + - tornado >=6.4.1 + - traitlets >=5.3 + - typing_extensions >=4.13.0 + - python + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/jupyter-client?source=compressed-mapping + size: 117954 + timestamp: 1781019994076 - conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_core-5.7.2-pyh31011fe_1.conda sha256: 732b1e8536bc22a5a174baa79842d79db2f4956d90293dd82dc1b3f6099bcccd md5: 0a2980dada0dd7fd0998f0342308b1b1 @@ -4020,6 +6088,42 @@ packages: - pkg:pypi/jupyter-core?source=hash-mapping size: 58269 timestamp: 1727164026641 +- conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_core-5.9.1-pyh6dadd2b_0.conda + sha256: ed709a6c25b731e01563521ef338b93986cd14b5bc17f35e9382000864872ccc + md5: a8db462b01221e9f5135be466faeb3e0 + depends: + - __win + - pywin32 + - platformdirs >=2.5 + - python >=3.10 + - traitlets >=5.3 + - python + constrains: + - pywin32 >=300 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/jupyter-core?source=hash-mapping + size: 64679 + timestamp: 1760643889625 +- conda: https://conda.anaconda.org/conda-forge/noarch/jupyter_core-5.9.1-pyhc90fa1f_0.conda + sha256: 1d34b80e5bfcd5323f104dbf99a2aafc0e5d823019d626d0dce5d3d356a2a52a + md5: b38fe4e78ee75def7e599843ef4c1ab0 + depends: + - __unix + - python + - platformdirs >=2.5 + - python >=3.10 + - traitlets >=5.3 + - python + constrains: + - pywin32 >=300 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/jupyter-core?source=hash-mapping + size: 65503 + timestamp: 1760643864586 - conda: https://conda.anaconda.org/conda-forge/linux-64/keyutils-1.6.1-h166bdaf_0.tar.bz2 sha256: 150c05a6e538610ca7c43beb3a40d65c90537497a4f6a5f4d15ec0451b6f5ebb md5: 30186d27e2c9fa62b45fb1476b7200e3 @@ -4054,6 +6158,21 @@ packages: - pkg:pypi/kiwisolver?source=hash-mapping size: 78071 timestamp: 1762488742381 +- conda: https://conda.anaconda.org/conda-forge/linux-64/kiwisolver-1.5.0-py314h97ea11e_0.conda + sha256: e3488ea4a336f29e57de8f282bf40c0505cfc482e03004615e694b48e7d9c79f + md5: 7397e418cab519b8d789936cf2dde6f6 + depends: + - python + - libstdcxx >=14 + - libgcc >=14 + - __glibc >=2.17,<3.0.a0 + - python_abi 3.14.* *_cp314 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/kiwisolver?source=hash-mapping + size: 77363 + timestamp: 1773067048780 - conda: https://conda.anaconda.org/conda-forge/osx-64/kiwisolver-1.4.9-py313ha1c5e85_2.conda sha256: 011e58aac5a2c0e22643b81339c3f35bff7ec52c46ef403ced227ac87aaab313 md5: cadc416f7c960ce1436bb6cc8a0f75e4 @@ -4061,13 +6180,27 @@ packages: - python - __osx >=10.13 - libcxx >=19 - - python_abi 3.13.* *_cp313 + - python_abi 3.13.* *_cp313 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/kiwisolver?source=hash-mapping + size: 69575 + timestamp: 1762488825063 +- conda: https://conda.anaconda.org/conda-forge/osx-64/kiwisolver-1.5.0-py314hd6e1bd6_0.conda + sha256: 87166a4d188103feea2c9b5f1379c63c40200e2f0087aeaafdc6fc9735911a74 + md5: 25a8718587d3d0d9114b25dfa93b864c + depends: + - python + - libcxx >=19 + - __osx >=11.0 + - python_abi 3.14.* *_cp314 license: BSD-3-Clause license_family: BSD purls: - pkg:pypi/kiwisolver?source=hash-mapping - size: 69575 - timestamp: 1762488825063 + size: 69873 + timestamp: 1773067281489 - conda: https://conda.anaconda.org/conda-forge/osx-arm64/kiwisolver-1.4.9-py314h42813c9_2.conda sha256: c4d7e6653d343e768110ec77ac1c6c89f313f77a19a1f2cd60b7c7b8b0758bdf md5: 9aa431bf603c231e8c77a1b0842a85ed @@ -4083,6 +6216,21 @@ packages: - pkg:pypi/kiwisolver?source=hash-mapping size: 68534 timestamp: 1762489024029 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/kiwisolver-1.5.0-py314hf8a3a22_0.conda + sha256: 840de1b0ba2fa646475bc53ba0f723c8a13e66139633a070831b8279deaa7c64 + md5: eb1465d8a644ef290d18fb86af6e9bc4 + depends: + - python + - python 3.14.* *_cp314 + - libcxx >=19 + - __osx >=11.0 + - python_abi 3.14.* *_cp314 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/kiwisolver?source=hash-mapping + size: 69284 + timestamp: 1773067285911 - conda: https://conda.anaconda.org/conda-forge/win-64/kiwisolver-1.4.9-py314hf309875_2.conda sha256: ded907ab1ce24abcff20bc239e770ae7ef4cff6fdcfb8cc24ca59ebe736a1d3f md5: e9d93271b021332f5492ff5478601614 @@ -4101,6 +6249,21 @@ packages: - pkg:pypi/kiwisolver?source=hash-mapping size: 73670 timestamp: 1762488752873 +- conda: https://conda.anaconda.org/conda-forge/win-64/kiwisolver-1.5.0-py314hf309875_0.conda + sha256: 37cbc49fd7255532d09fb3bc9cc699554693e632fa90678a9b3d0ed12557d0d7 + md5: 0508c8dabeab91311e5c59b5e3f6d278 + depends: + - python + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + - ucrt >=10.0.20348.0 + - python_abi 3.14.* *_cp314 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/kiwisolver?source=hash-mapping + size: 73330 + timestamp: 1773067062280 - conda: https://conda.anaconda.org/conda-forge/linux-64/krb5-1.21.3-h659f571_0.conda sha256: 99df692f7a8a5c27cd14b5fb1374ee55e756631b9c3d659ed3ee60830249b238 md5: 3f43953b7d3fb3aaa1d0d0723d91e368 @@ -4227,6 +6390,19 @@ packages: purls: [] size: 249959 timestamp: 1768184673131 +- conda: https://conda.anaconda.org/conda-forge/linux-64/lcms2-2.19.1-h0c24ade_1.conda + sha256: 112b5b9462572d970f4abd2912f76a25ee7db158b1e7260163d91dd8a630db84 + md5: 8b3ce45e929cd8e8e5f4d18586b56d8b + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - libjpeg-turbo >=3.1.4.1,<4.0a0 + - libtiff >=4.7.1,<4.8.0a0 + license: MIT + license_family: MIT + purls: [] + size: 251971 + timestamp: 1780211695895 - conda: https://conda.anaconda.org/conda-forge/osx-64/lcms2-2.17-h72f5680_0.conda sha256: bcb81543e49ff23e18dea79ef322ab44b8189fb11141b1af99d058503233a5fc md5: bf210d0c63f2afb9e414a858b79f0eaa @@ -4239,6 +6415,18 @@ packages: purls: [] size: 226001 timestamp: 1739161050843 +- conda: https://conda.anaconda.org/conda-forge/osx-64/lcms2-2.19.1-h5ea7634_1.conda + sha256: 8bae1207dc7cf0e670ae920a549b1d55486514213ca808b8119067cbad0db43a + md5: f8c168eefc1f75ada2e2cd8f2e6212f5 + depends: + - __osx >=11.0 + - libjpeg-turbo >=3.1.4.1,<4.0a0 + - libtiff >=4.7.1,<4.8.0a0 + license: MIT + license_family: MIT + purls: [] + size: 229477 + timestamp: 1780211969520 - conda: https://conda.anaconda.org/conda-forge/osx-arm64/lcms2-2.18-hdfa7624_0.conda sha256: d768da024ab74a4b30642401877fa914a68bdc238667f16b1ec2e0e98b2451a6 md5: 6631a7bd2335bb9699b1dbc234b19784 @@ -4251,6 +6439,18 @@ packages: purls: [] size: 211756 timestamp: 1768184994800 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/lcms2-2.19.1-hdfa7624_1.conda + sha256: ccb5598fad3694e79bf54f0eb812e3b3c3dd63d1497e631f5978800eadb9bcc4 + md5: d2f2c7c10e2957647d45589b7701a453 + depends: + - __osx >=11.0 + - libjpeg-turbo >=3.1.4.1,<4.0a0 + - libtiff >=4.7.1,<4.8.0a0 + license: MIT + license_family: MIT + purls: [] + size: 213747 + timestamp: 1780212240694 - conda: https://conda.anaconda.org/conda-forge/win-64/lcms2-2.18-hf2c6c5f_0.conda sha256: 7eeb18c5c86db146b62da66d9e8b0e753a52987f9134a494309588bbeceddf28 md5: b6c68d6b829b044cd17a41e0a8a23ca1 @@ -4265,6 +6465,20 @@ packages: purls: [] size: 522238 timestamp: 1768184858107 +- conda: https://conda.anaconda.org/conda-forge/win-64/lcms2-2.19.1-hf2c6c5f_1.conda + sha256: 5ed63a32639a130564a870becb679fd52dfb816666a61ed3c023917389010480 + md5: 1df4012c8a2478699d07bc26af66d41e + depends: + - libjpeg-turbo >=3.1.4.1,<4.0a0 + - libtiff >=4.7.1,<4.8.0a0 + - ucrt >=10.0.20348.0 + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + license: MIT + license_family: MIT + purls: [] + size: 523194 + timestamp: 1780211799997 - conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.43-h712a8e2_2.conda sha256: 7c91cea91b13f4314d125d1bedb9d03a29ebbd5080ccdea70260363424646dbe md5: 048b02e3962f066da18efe3a21b77672 @@ -4302,6 +6516,18 @@ packages: purls: [] size: 264243 timestamp: 1745264221534 +- conda: https://conda.anaconda.org/conda-forge/linux-64/lerc-4.1.0-hdb68285_0.conda + sha256: f84cb54782f7e9cea95e810ea8fef186e0652d0fa73d3009914fa2c1262594e1 + md5: a752488c68f2e7c456bcbd8f16eec275 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - libstdcxx >=14 + license: Apache-2.0 + license_family: Apache + purls: [] + size: 261513 + timestamp: 1773113328888 - conda: https://conda.anaconda.org/conda-forge/osx-64/lerc-4.0.0-hcca01a6_1.conda sha256: cc1f1d7c30aa29da4474ec84026ec1032a8df1d7ec93f4af3b98bb793d01184e md5: 21f765ced1a0ef4070df53cb425e1967 @@ -4313,6 +6539,17 @@ packages: purls: [] size: 248882 timestamp: 1745264331196 +- conda: https://conda.anaconda.org/conda-forge/osx-64/lerc-4.1.0-h35c7297_0.conda + sha256: f918716c71c8bebbc0c40e1050878aa512fea92c1d17c363ca35650bc60f6c35 + md5: d2fe7e177d1c97c985140bd54e2a5e33 + depends: + - __osx >=11.0 + - libcxx >=19 + license: Apache-2.0 + license_family: Apache + purls: [] + size: 215089 + timestamp: 1773114468701 - conda: https://conda.anaconda.org/conda-forge/osx-arm64/lerc-4.0.0-hd64df32_1.conda sha256: 12361697f8ffc9968907d1a7b5830e34c670e4a59b638117a2cdfed8f63a38f8 md5: a74332d9b60b62905e3d30709df08bf1 @@ -4324,6 +6561,17 @@ packages: purls: [] size: 188306 timestamp: 1745264362794 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/lerc-4.1.0-h1eee2c3_0.conda + sha256: 66e5ffd301a44da696f3efc2f25d6d94f42a9adc0db06c44ad753ab844148c51 + md5: 095e5749868adab9cae42d4b460e5443 + depends: + - __osx >=11.0 + - libcxx >=19 + license: Apache-2.0 + license_family: Apache + purls: [] + size: 164222 + timestamp: 1773114244984 - conda: https://conda.anaconda.org/conda-forge/win-64/lerc-4.0.0-h6470a55_1.conda sha256: 868a3dff758cc676fa1286d3f36c3e0101cca56730f7be531ab84dc91ec58e9d md5: c1b81da6d29a14b542da14a36c9fbf3f @@ -4336,6 +6584,18 @@ packages: purls: [] size: 164701 timestamp: 1745264384716 +- conda: https://conda.anaconda.org/conda-forge/win-64/lerc-4.1.0-hd936e49_0.conda + sha256: 45df58fca800b552b17c3914cc9ab0d55a82c5172d72b5c44a59c710c06c5473 + md5: 54b231d595bc1ff9bff668dd443ee012 + depends: + - ucrt >=10.0.20348.0 + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + license: Apache-2.0 + license_family: Apache + purls: [] + size: 172395 + timestamp: 1773113455582 - conda: https://conda.anaconda.org/conda-forge/linux-64/libaec-1.1.3-h59595ed_0.conda sha256: 2ef420a655528bca9d269086cf33b7e90d2f54ad941b437fb1ed5eca87cee017 md5: 5e97e271911b8b2001a8b71860c32faa @@ -4836,6 +7096,19 @@ packages: purls: [] size: 21054217 timestamp: 1767834505759 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libclang-cpp22.1-22.1.8-default_h6c227bf_3.conda + sha256: ccb8bd0a8f2d57675b6a60dabb0cc8becb35c2748ac4ec920d7f7625b93c16d8 + md5: 864e6d29ec7378b89ff5b5c9c629099e + depends: + - libstdcxx >=14 + - libgcc >=14 + - __glibc >=2.17,<3.0.a0 + - libllvm22 >=22.1.8,<22.2.0a0 + license: Apache-2.0 WITH LLVM-exception + license_family: APACHE + purls: [] + size: 24175081 + timestamp: 1782358841320 - conda: https://conda.anaconda.org/conda-forge/linux-64/libclang13-21.1.8-default_h746c552_1.conda sha256: 4507075f64c65b45b049e5b19842186d25c99af4b4922910f231776e46d33799 md5: e00afd65b88a3258212661b32c1469cb @@ -4849,6 +7122,20 @@ packages: purls: [] size: 12348581 timestamp: 1767834784207 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libclang13-22.1.8-default_h9692865_3.conda + sha256: b90ed8467a692788477c06bc0359fac52ed5651d801ddef189ba4b7ecf3ce38c + md5: 2a913525f4201f1adab2711fcf6f89b3 + depends: + - libclang-cpp22.1 ==22.1.8 default_h6c227bf_3 + - libstdcxx >=14 + - libgcc >=14 + - __glibc >=2.17,<3.0.a0 + - libllvm22 >=22.1.8,<22.2.0a0 + license: Apache-2.0 WITH LLVM-exception + license_family: APACHE + purls: [] + size: 14283567 + timestamp: 1782358841320 - conda: https://conda.anaconda.org/conda-forge/win-64/libclang13-21.1.8-default_ha2db4b5_1.conda sha256: a2e28d6196f83eddb1c62f19ec9c0a95c3ff74660bc732a54ab00332a4b59318 md5: 2dfbc5aaac3424065eb81ec9a9f49761 @@ -4863,6 +7150,36 @@ packages: purls: [] size: 28993550 timestamp: 1767841215595 +- conda: https://conda.anaconda.org/conda-forge/win-64/libclang13-22.1.8-default_hf735972_3.conda + sha256: 34a25466769d1233d8f36a78d5f9f40279bae3fc4b70852acbd04b159ac4d183 + md5: c45c5a60b68368f62415941c1d9f0ab7 + depends: + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + - ucrt >=10.0.20348.0 + - libzlib >=1.3.2,<2.0a0 + - libxml2 + - libxml2-16 >=2.14.6 + - zstd >=1.5.7,<1.6.0a0 + license: Apache-2.0 WITH LLVM-exception + license_family: APACHE + purls: [] + size: 34917944 + timestamp: 1782358781159 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libcups-2.3.3-h7a8fb5f_6.conda + sha256: 205c4f19550f3647832ec44e35e6d93c8c206782bdd620c1d7cf66237580ff9c + md5: 49c553b47ff679a6a1e9fc80b9c5a2d4 + depends: + - __glibc >=2.17,<3.0.a0 + - krb5 >=1.22.2,<1.23.0a0 + - libgcc >=14 + - libstdcxx >=14 + - libzlib >=1.3.1,<2.0a0 + license: Apache-2.0 + license_family: Apache + purls: [] + size: 4518030 + timestamp: 1770902209173 - conda: https://conda.anaconda.org/conda-forge/linux-64/libcups-2.3.3-hb8b1518_5.conda sha256: cb83980c57e311783ee831832eb2c20ecb41e7dee6e86e8b70b8cef0e43eab55 md5: d4a250da4737ee127fb1fa6452a9002e @@ -5070,6 +7387,16 @@ packages: purls: [] size: 69911 timestamp: 1745260530684 +- conda: https://conda.anaconda.org/conda-forge/osx-64/libdeflate-1.25-h517ebb2_0.conda + sha256: 025f8b1e85dd8254e0ca65f011919fb1753070eb507f03bca317871a884d24de + md5: 31aa65919a729dc48180893f62c25221 + depends: + - __osx >=10.13 + license: MIT + license_family: MIT + purls: [] + size: 70840 + timestamp: 1761980008502 - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libdeflate-1.25-hc11a715_0.conda sha256: 5e0b6961be3304a5f027a8c00bd0967fc46ae162cffb7553ff45c70f51b8314c md5: a6130c709305cd9828b4e1bd9ba0000c @@ -5104,6 +7431,18 @@ packages: purls: [] size: 310785 timestamp: 1757212153962 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libdrm-2.4.127-hb03c661_0.conda + sha256: 7d3187c11b7ae66c5595a8afd5a7ce352a490527fdf6614cab129bc7f2c16ba3 + md5: d8d16b9b32a3c5df7e5b3350e2cbe058 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - libpciaccess >=0.19,<0.20.0a0 + license: MIT + license_family: MIT + purls: [] + size: 311505 + timestamp: 1778975798004 - conda: https://conda.anaconda.org/conda-forge/linux-64/libedit-3.1.20250104-pl5321h7949ede_0.conda sha256: d789471216e7aba3c184cd054ed61ce3f6dac6f87a50ec69291b9297f8c18724 md5: c277e0a4d549b03ac1e9d6cbbe3d017b @@ -5151,6 +7490,28 @@ packages: purls: [] size: 44840 timestamp: 1731330973553 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libegl-1.7.0-ha4b6fd6_3.conda + sha256: 9a25ea93e8272785405a21d30f84e620befb1d545f6dfaae18f06103b5df0443 + md5: 75e9f795be506c96dd43cb09c7c8d557 + depends: + - __glibc >=2.17,<3.0.a0 + - libglvnd 1.7.0 ha4b6fd6_3 + license: LicenseRef-libglvnd + purls: [] + size: 46500 + timestamp: 1779728188901 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libegl-devel-1.7.0-ha4b6fd6_3.conda + sha256: e4b46919c9bb65930bce238bd2736110ed7b8c30e5cd5394e4e1edb48de54843 + md5: 5bc6d55503483aabe8a90c5e7f49a2a4 + depends: + - __glibc >=2.17,<3.0.a0 + - libegl 1.7.0 ha4b6fd6_3 + - libgl-devel 1.7.0 ha4b6fd6_3 + - xorg-libx11 + license: LicenseRef-libglvnd + purls: [] + size: 31718 + timestamp: 1779728222280 - conda: https://conda.anaconda.org/conda-forge/linux-64/libev-4.33-hd590300_2.conda sha256: 1cd6048169fa0395af74ed5d8f1716e22c19a81a8a36f934c110ca3ad4dd27b4 md5: 172bf1cd1ff8629f2b1179945ed45055 @@ -5279,28 +7640,28 @@ packages: purls: [] size: 71631 timestamp: 1781203724164 -- conda: https://conda.anaconda.org/conda-forge/linux-64/libffi-3.5.2-h9ec8514_0.conda - sha256: 25cbdfa65580cfab1b8d15ee90b4c9f1e0d72128f1661449c9a999d341377d54 - md5: 35f29eec58405aaf55e01cb470d8c26a +- conda: https://conda.anaconda.org/conda-forge/linux-64/libffi-3.5.2-h3435931_0.conda + sha256: 31f19b6a88ce40ebc0d5a992c131f57d919f73c0b92cd1617a5bec83f6e961e6 + md5: a360c33a5abe61c07959e449fa1453eb depends: - __glibc >=2.17,<3.0.a0 - libgcc >=14 license: MIT license_family: MIT purls: [] - size: 57821 - timestamp: 1760295480630 -- conda: https://conda.anaconda.org/conda-forge/linux-64/libffi-3.7.0-h3435931_0.conda - sha256: ac38603008bf1e99b8ed379b1a656a67a70e2841f2b6a069c630cdf6316012d2 - md5: 0abe40a9880086ca4d2e5daf09dceff9 + size: 58592 + timestamp: 1769456073053 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libffi-3.5.2-h9ec8514_0.conda + sha256: 25cbdfa65580cfab1b8d15ee90b4c9f1e0d72128f1661449c9a999d341377d54 + md5: 35f29eec58405aaf55e01cb470d8c26a depends: - __glibc >=2.17,<3.0.a0 - libgcc >=14 license: MIT license_family: MIT purls: [] - size: 67576 - timestamp: 1783520858222 + size: 57821 + timestamp: 1760295480630 - conda: https://conda.anaconda.org/conda-forge/osx-64/libffi-3.4.6-h281671d_0.conda sha256: 7805fdc536a3da7fb63dc48e040105cd4260c69a1d2bf5804dadd31bde8bab51 md5: b8667b0d0400b8dcb6844d8e06b2027d @@ -5311,16 +7672,26 @@ packages: purls: [] size: 47258 timestamp: 1739260651925 -- conda: https://conda.anaconda.org/conda-forge/osx-64/libffi-3.7.0-h8c408c4_0.conda - sha256: 525e9b574d6a62b73ccd4cb616495fccd11e80c7e6f4fd7e97a9dd5804bf4c0e - md5: b85d1868b8d9af5306443978da2961d6 +- conda: https://conda.anaconda.org/conda-forge/osx-64/libffi-3.5.2-hd1f9c09_0.conda + sha256: 951958d1792238006fdc6fce7f71f1b559534743b26cc1333497d46e5903a2d6 + md5: 66a0dc7464927d0853b590b6f53ba3ea + depends: + - __osx >=10.13 + license: MIT + license_family: MIT + purls: [] + size: 53583 + timestamp: 1769456300951 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libffi-3.5.2-hcf2aa1b_0.conda + sha256: 6686a26466a527585e6a75cc2a242bf4a3d97d6d6c86424a441677917f28bec7 + md5: 43c04d9cb46ef176bb2a4c77e324d599 depends: - __osx >=11.0 license: MIT license_family: MIT purls: [] - size: 61307 - timestamp: 1783521470318 + size: 40979 + timestamp: 1769456747661 - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libffi-3.5.2-he5f378a_0.conda sha256: 9b8acdf42df61b7bfe8bdc545c016c29e61985e79748c64ad66df47dbc2e295f md5: 411ff7cd5d1472bba0f55c0faf04453b @@ -5331,16 +7702,18 @@ packages: purls: [] size: 40251 timestamp: 1760295839166 -- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libffi-3.7.0-hcf2aa1b_0.conda - sha256: 2c6ac9a6cd65af89b2bd448518bb1e13b44a2e48c0d469398e37bcfc0092e832 - md5: 92e8690d170d46d768c32553458c0105 +- conda: https://conda.anaconda.org/conda-forge/win-64/libffi-3.5.2-h3d046cb_0.conda + sha256: 59d01f2dfa8b77491b5888a5ab88ff4e1574c9359f7e229da254cdfe27ddc190 + md5: 720b39f5ec0610457b725eb3f396219a depends: - - __osx >=11.0 + - ucrt >=10.0.20348.0 + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 license: MIT license_family: MIT purls: [] - size: 43734 - timestamp: 1783521647536 + size: 45831 + timestamp: 1769456418774 - conda: https://conda.anaconda.org/conda-forge/win-64/libffi-3.5.2-h52bdfb6_0.conda sha256: ddff25aaa4f0aa535413f5d831b04073789522890a4d8626366e43ecde1534a3 md5: ba4ad812d2afc22b9a34ce8327a0930f @@ -5353,18 +7726,6 @@ packages: purls: [] size: 44866 timestamp: 1760295760649 -- conda: https://conda.anaconda.org/conda-forge/win-64/libffi-3.7.0-h3d046cb_0.conda - sha256: 2ea8d2fe7b84ca37653777e15ac1e7abd35f0c90d3efbe7f6c4de9b489606369 - md5: 92bdfc0e5012660892b0e0eaf3069a5c - depends: - - ucrt >=10.0.20348.0 - - vc >=14.3,<15 - - vc14_runtime >=14.44.35208 - license: MIT - license_family: MIT - purls: [] - size: 50247 - timestamp: 1783521107166 - conda: https://conda.anaconda.org/conda-forge/linux-64/libfreetype-2.14.1-ha770c72_0.conda sha256: 4641d37faeb97cf8a121efafd6afd040904d4bca8c46798122f417c31d5dfbec md5: f4084e4e6577797150f9b04a4560ceb0 @@ -5374,6 +7735,15 @@ packages: purls: [] size: 7664 timestamp: 1757945417134 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libfreetype-2.14.3-ha770c72_0.conda + sha256: 38f014a7129e644636e46064ecd6b1945e729c2140e21d75bb476af39e692db2 + md5: e289f3d17880e44b633ba911d57a321b + depends: + - libfreetype6 >=2.14.3 + license: GPL-2.0-only OR FTL + purls: [] + size: 8049 + timestamp: 1774298163029 - conda: https://conda.anaconda.org/conda-forge/osx-64/libfreetype-2.14.1-h694c41f_0.conda sha256: 035e23ef87759a245d51890aedba0b494a26636784910c3730d76f3dc4482b1d md5: e0e2edaf5e0c71b843e25a7ecc451cc9 @@ -5383,6 +7753,15 @@ packages: purls: [] size: 7780 timestamp: 1757945952392 +- conda: https://conda.anaconda.org/conda-forge/osx-64/libfreetype-2.14.3-h694c41f_1.conda + sha256: 9029ed0c940be8161c86f5338eacfad1f61af216cdc508e386a648f6ef893a28 + md5: 7cec36e11e7c5a674a1d8c1d5082479e + depends: + - libfreetype6 >=2.14.3 + license: GPL-2.0-only OR FTL + purls: [] + size: 8394 + timestamp: 1780934152050 - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libfreetype-2.14.1-hce30654_0.conda sha256: 9de25a86066f078822d8dd95a83048d7dc2897d5d655c0e04a8a54fca13ef1ef md5: f35fb38e89e2776994131fbf961fa44b @@ -5392,6 +7771,15 @@ packages: purls: [] size: 7810 timestamp: 1757947168537 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libfreetype-2.14.3-hce30654_1.conda + sha256: d5637b01941c0fc8f5cbb1f170c238f4ee153b3c1708b9d50f4f1305438ff051 + md5: 0582e67cd14cfed773be2f3b1aba08e0 + depends: + - libfreetype6 >=2.14.3 + license: GPL-2.0-only OR FTL + purls: [] + size: 8365 + timestamp: 1780933612390 - conda: https://conda.anaconda.org/conda-forge/win-64/libfreetype-2.14.1-h57928b3_0.conda sha256: 2029702ec55e968ce18ec38cc8cf29f4c8c4989a0d51797164dab4f794349a64 md5: 3235024fe48d4087721797ebd6c9d28c @@ -5401,6 +7789,15 @@ packages: purls: [] size: 8109 timestamp: 1757946135015 +- conda: https://conda.anaconda.org/conda-forge/win-64/libfreetype-2.14.3-h57928b3_1.conda + sha256: 035d0c67bf9f7a16f4a1764f420c120f1a995d071bb265fcc66ef688ef709d7b + md5: e45b52fb9a81c9e2708465a706e05952 + depends: + - libfreetype6 >=2.14.3 + license: GPL-2.0-only OR FTL + purls: [] + size: 8711 + timestamp: 1780934891782 - conda: https://conda.anaconda.org/conda-forge/linux-64/libfreetype6-2.14.1-h73754d4_0.conda sha256: 4a7af818a3179fafb6c91111752954e29d3a2a950259c14a2fc7ba40a8b03652 md5: 8e7251989bca326a28f4a5ffbd74557a @@ -5415,6 +7812,20 @@ packages: purls: [] size: 386739 timestamp: 1757945416744 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libfreetype6-2.14.3-h73754d4_0.conda + sha256: 16f020f96da79db1863fcdd8f2b8f4f7d52f177dd4c58601e38e9182e91adf1d + md5: fb16b4b69e3f1dcfe79d80db8fd0c55d + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - libpng >=1.6.55,<1.7.0a0 + - libzlib >=1.3.2,<2.0a0 + constrains: + - freetype >=2.14.3 + license: GPL-2.0-only OR FTL + purls: [] + size: 384575 + timestamp: 1774298162622 - conda: https://conda.anaconda.org/conda-forge/osx-64/libfreetype6-2.14.1-h6912278_0.conda sha256: f5f28092e368efc773bcd1c381d123f8b211528385a9353e36f8808d00d11655 md5: dfbdc8fd781dc3111541e4234c19fdbd @@ -5428,6 +7839,19 @@ packages: purls: [] size: 374993 timestamp: 1757945949585 +- conda: https://conda.anaconda.org/conda-forge/osx-64/libfreetype6-2.14.3-h58fbd8d_1.conda + sha256: cc94862c51e68626fadddf68b523e5f752149186ccc498fa37976504e2e7ff55 + md5: 112cb22521fa3abf19bc0c93938576f5 + depends: + - __osx >=11.0 + - libpng >=1.6.58,<1.7.0a0 + - libzlib >=1.3.2,<2.0a0 + constrains: + - freetype >=2.14.3 + license: GPL-2.0-only OR FTL + purls: [] + size: 365107 + timestamp: 1780934149073 - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libfreetype6-2.14.1-h6da58f4_0.conda sha256: cc4aec4c490123c0f248c1acd1aeab592afb6a44b1536734e20937cda748f7cd md5: 6d4ede03e2a8e20eb51f7f681d2a2550 @@ -5441,6 +7865,19 @@ packages: purls: [] size: 346703 timestamp: 1757947166116 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libfreetype6-2.14.3-hdfa99f5_1.conda + sha256: abbfffd8a8c776bb8b59a10c8247fc3aa6b17ba0051e9f6d199dca38479f214f + md5: a0bb0678f67c464938d3693fa96f6884 + depends: + - __osx >=11.0 + - libpng >=1.6.58,<1.7.0a0 + - libzlib >=1.3.2,<2.0a0 + constrains: + - freetype >=2.14.3 + license: GPL-2.0-only OR FTL + purls: [] + size: 338442 + timestamp: 1780933611662 - conda: https://conda.anaconda.org/conda-forge/win-64/libfreetype6-2.14.1-hdbac1cb_0.conda sha256: 223710600b1a5567163f7d66545817f2f144e4ef8f84e99e90f6b8a4e19cb7ad md5: 6e7c5c5ab485057b5d07fd8188ba5c28 @@ -5456,6 +7893,21 @@ packages: purls: [] size: 340264 timestamp: 1757946133889 +- conda: https://conda.anaconda.org/conda-forge/win-64/libfreetype6-2.14.3-hdbac1cb_1.conda + sha256: 0bbd19c9f7c4d0232b31892e6a4d1f82b8d19d1b84d89725f1f491b336447758 + md5: 4e4d54f9f98383d977ba56ef39ebf46d + depends: + - libpng >=1.6.58,<1.7.0a0 + - libzlib >=1.3.2,<2.0a0 + - ucrt >=10.0.20348.0 + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + constrains: + - freetype >=2.14.3 + license: GPL-2.0-only OR FTL + purls: [] + size: 340411 + timestamp: 1780934813224 - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-14.2.0-h77fa898_1.conda sha256: 53eb8a79365e58849e7b1a068d31f4f9e718dc938d6f2c03e960345739a03569 md5: 3cb76c3f10d3bc7f1105b2fc9db984df @@ -5525,6 +7977,21 @@ packages: purls: [] size: 819696 timestamp: 1765260437409 +- conda: https://conda.anaconda.org/conda-forge/win-64/libgcc-15.2.0-h8ee18e1_19.conda + sha256: 80e80ef5e31b00b12539db3c5aaecde60dab91381abfc1060e323d5c3b016dce + md5: cc5d690fc1c629038f13c68e88e65f44 + depends: + - _openmp_mutex >=4.5 + - libwinpthread >=12.0.0.r4.gg4f2fc60ca + constrains: + - msys2-conda-epoch <0.0a0 + - libgcc-ng ==15.2.0=*_19 + - libgomp 15.2.0 h8ee18e1_19 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + purls: [] + size: 821854 + timestamp: 1778273037795 - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-14.2.0-h69a702a_1.conda sha256: 3a76969c80e9af8b6e7a55090088bc41da4cffcde9e2c71b17f44d37b7cb87f7 md5: e39480b9ca41323497b05492a63bc35b @@ -5697,6 +8164,28 @@ packages: purls: [] size: 134712 timestamp: 1731330998354 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libgl-1.7.0-ha4b6fd6_3.conda + sha256: ec353b3076ed8e357ed961d0e9ff6997491cade0e603de5bd18a2e301ac78ebd + md5: f25206d7322c0e9648e8b83694d143ab + depends: + - __glibc >=2.17,<3.0.a0 + - libglvnd 1.7.0 ha4b6fd6_3 + - libglx 1.7.0 ha4b6fd6_3 + license: LicenseRef-libglvnd + purls: [] + size: 133469 + timestamp: 1779728207669 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libgl-devel-1.7.0-ha4b6fd6_3.conda + sha256: 41d7d864ad1f199bdb06ff6cc3931455c8af62f1d2071a08c6fa08affbcb678f + md5: 63e43d278ee5084813fe3c2edf4834ce + depends: + - __glibc >=2.17,<3.0.a0 + - libgl 1.7.0 ha4b6fd6_3 + - libglx-devel 1.7.0 ha4b6fd6_3 + license: LicenseRef-libglvnd + purls: [] + size: 115664 + timestamp: 1779728218325 - conda: https://conda.anaconda.org/conda-forge/linux-64/libglib-2.86.3-h6548e54_0.conda sha256: 82d6c2ee9f548c84220fb30fb1b231c64a53561d6e485447394f0a0eeeffe0e6 md5: 034bea55a4feef51c98e8449938e9cee @@ -5713,6 +8202,54 @@ packages: purls: [] size: 3946542 timestamp: 1765221858705 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libglib-2.88.2-h0d30a3d_0.conda + sha256: 4bee10e62796f01e4fa2b5849135b1cc061337fe9cf5eb9bd79e9664922ae0e4 + md5: 889febc66cd9e4190f80ef9718fa239b + depends: + - libgcc >=14 + - __glibc >=2.17,<3.0.a0 + - libiconv >=1.18,<2.0a0 + - libzlib >=1.3.2,<2.0a0 + - libffi >=3.5.2,<3.6.0a0 + - pcre2 >=10.47,<10.48.0a0 + constrains: + - glib >2.66 + license: LGPL-2.1-or-later + purls: [] + size: 4754220 + timestamp: 1782463895250 +- conda: https://conda.anaconda.org/conda-forge/osx-64/libglib-2.88.2-hf28f236_0.conda + sha256: 445e6806480103c6411993e7c2fd5ad1c6cb14ef1fee9386b44adeb536834d07 + md5: 6ed62b59574adb4c9629ed6932a51de7 + depends: + - __osx >=11.0 + - libiconv >=1.18,<2.0a0 + - libzlib >=1.3.2,<2.0a0 + - libintl >=0.25.1,<1.0a0 + - pcre2 >=10.47,<10.48.0a0 + - libffi >=3.5.2,<3.6.0a0 + constrains: + - glib >2.66 + license: LGPL-2.1-or-later + purls: [] + size: 4510929 + timestamp: 1782464244345 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libglib-2.88.2-ha08bb59_0.conda + sha256: 68ac66904a284a7dfbb3bdf9225380eaf20750b2d414215e6d7af5caa3ed1a63 + md5: 03123cafdc96cef79fc8a615f9119b79 + depends: + - __osx >=11.0 + - pcre2 >=10.47,<10.48.0a0 + - libiconv >=1.18,<2.0a0 + - libintl >=0.25.1,<1.0a0 + - libzlib >=1.3.2,<2.0a0 + - libffi >=3.5.2,<3.6.0a0 + constrains: + - glib >2.66 + license: LGPL-2.1-or-later + purls: [] + size: 4437447 + timestamp: 1782463971075 - conda: https://conda.anaconda.org/conda-forge/win-64/libglib-2.86.3-h0c9aed9_0.conda sha256: 84b74fc81fff745f3d21a26c317ace44269a563a42ead3500034c27e407e1021 md5: c2d5b6b790ef21abac0b5331094ccb56 @@ -5726,11 +8263,29 @@ packages: - vc >=14.3,<15 - vc14_runtime >=14.44.35208 constrains: - - glib 2.86.3 *_0 + - glib 2.86.3 *_0 + license: LGPL-2.1-or-later + purls: [] + size: 3818991 + timestamp: 1765222145992 +- conda: https://conda.anaconda.org/conda-forge/win-64/libglib-2.88.2-h7ce1215_0.conda + sha256: 20d4a182b8aa1d71b331579fae281bb3ccb1a199257ce15fadc53786031a7408 + md5: 5be116480ef34a5646894d7f7cd7ae41 + depends: + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + - ucrt >=10.0.20348.0 + - libintl >=0.22.5,<1.0a0 + - libzlib >=1.3.2,<2.0a0 + - libiconv >=1.18,<2.0a0 + - pcre2 >=10.47,<10.48.0a0 + - libffi >=3.5.2,<3.6.0a0 + constrains: + - glib >2.66 license: LGPL-2.1-or-later purls: [] - size: 3818991 - timestamp: 1765222145992 + size: 4518265 + timestamp: 1782463965040 - conda: https://conda.anaconda.org/conda-forge/linux-64/libglvnd-1.7.0-ha4b6fd6_2.conda sha256: 1175f8a7a0c68b7f81962699751bb6574e6f07db4c9f72825f978e3016f46850 md5: 434ca7e50e40f4918ab701e3facd59a0 @@ -5740,6 +8295,15 @@ packages: purls: [] size: 132463 timestamp: 1731330968309 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libglvnd-1.7.0-ha4b6fd6_3.conda + sha256: e019ebe4e3f5cdf23e2f5e58ddf7ade27988c53820115b17b98f218ebcc87748 + md5: eb83f3f8cecc3e9bff9e250817fc69b6 + depends: + - __glibc >=2.17,<3.0.a0 + license: LicenseRef-libglvnd + purls: [] + size: 133586 + timestamp: 1779728183422 - conda: https://conda.anaconda.org/conda-forge/linux-64/libglx-1.7.0-ha4b6fd6_2.conda sha256: 2d35a679624a93ce5b3e9dd301fff92343db609b79f0363e6d0ceb3a6478bfa7 md5: c8013e438185f33b13814c5c488acd5c @@ -5751,6 +8315,29 @@ packages: purls: [] size: 75504 timestamp: 1731330988898 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libglx-1.7.0-ha4b6fd6_3.conda + sha256: 2f74713c9ca408ea84e88a30a9028153e7b553e8bb42e06139eac9a753c27da9 + md5: ec3c4350aa0261bf7f87b8ca15c8e80e + depends: + - __glibc >=2.17,<3.0.a0 + - libglvnd 1.7.0 ha4b6fd6_3 + - xorg-libx11 >=1.8.13,<2.0a0 + license: LicenseRef-libglvnd + purls: [] + size: 76586 + timestamp: 1779728199059 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libglx-devel-1.7.0-ha4b6fd6_3.conda + sha256: a17ae2d4cb2de04a20882ae14ec3cc1958e868a4dec81e3d7eca30115ee50e94 + md5: 16b6330783ce0d1ae8d22782173b32c9 + depends: + - __glibc >=2.17,<3.0.a0 + - libglx 1.7.0 ha4b6fd6_3 + - xorg-libx11 >=1.8.13,<2.0a0 + - xorg-xorgproto + license: LicenseRef-libglvnd + purls: [] + size: 27363 + timestamp: 1779728211402 - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-15.2.0-he0feb66_19.conda sha256: 5abe4ab9d93f6c9757d654f1969ae2267d4505315c1f2f8fe705fd60af084f1b md5: faac990cb7aedc7f3a2224f2c9b0c26c @@ -5773,6 +8360,143 @@ packages: purls: [] size: 663567 timestamp: 1765260367147 +- conda: https://conda.anaconda.org/conda-forge/win-64/libgomp-15.2.0-h8ee18e1_19.conda + sha256: 4dc958ced2fc7f42bc675b07e2c9abe3e150875ffdf62ca551d94fc6facf1fd7 + md5: f1147651e3fdd585e2f442c0c2fc8f2d + depends: + - libwinpthread >=12.0.0.r4.gg4f2fc60ca + constrains: + - msys2-conda-epoch <0.0a0 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + purls: [] + size: 664640 + timestamp: 1778272979661 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libharfbuzz-14.2.1-h17a8019_1.conda + sha256: 821c315f6b5171aa89e735be2ad84e74eb3f898fc7610ee36cfecd95dfa789e8 + md5: fb4669c3990b94ea32fbb81f433e9aa6 + depends: + - __glibc >=2.17,<3.0.a0 + - cairo >=1.18.4,<2.0a0 + - graphite2 >=1.3.15,<2.0a0 + - icu >=78.3,<79.0a0 + - libfreetype >=2.14.3 + - libfreetype6 >=2.14.3 + - libgcc >=14 + - libglib >=2.88.2,<3.0a0 + - libpng >=1.6.58,<1.7.0a0 + - libstdcxx >=14 + - libzlib >=1.3.2,<2.0a0 + license: MIT + license_family: MIT + purls: [] + size: 1297668 + timestamp: 1782800580119 +- conda: https://conda.anaconda.org/conda-forge/osx-64/libharfbuzz-14.2.1-h97ceea7_1.conda + sha256: 33ec741f9f4bfe132c03e18c2a5822a9ad850c8813fa1a40b94f1f4df8fcde58 + md5: eeb8ef2f2d2ba6d3ff5ba4e7fdf4b73c + depends: + - __osx >=11.0 + - cairo >=1.18.4,<2.0a0 + - graphite2 >=1.3.15,<2.0a0 + - icu >=78.3,<79.0a0 + - libcxx >=19 + - libfreetype >=2.14.3 + - libfreetype6 >=2.14.3 + - libglib >=2.88.2,<3.0a0 + - libpng >=1.6.58,<1.7.0a0 + - libzlib >=1.3.2,<2.0a0 + license: MIT + license_family: MIT + purls: [] + size: 1013958 + timestamp: 1782801064703 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libharfbuzz-14.2.1-h5a65909_1.conda + sha256: 75860db66af9748572038d1e3a2260eca56ee4b38b9523e042fac8caf4277529 + md5: e8d6e86663316dfbdec7dac532824516 + depends: + - __osx >=11.0 + - cairo >=1.18.4,<2.0a0 + - graphite2 >=1.3.15,<2.0a0 + - icu >=78.3,<79.0a0 + - libcxx >=19 + - libfreetype >=2.14.3 + - libfreetype6 >=2.14.3 + - libglib >=2.88.2,<3.0a0 + - libpng >=1.6.58,<1.7.0a0 + - libzlib >=1.3.2,<2.0a0 + license: MIT + license_family: MIT + purls: [] + size: 900474 + timestamp: 1782800553099 +- conda: https://conda.anaconda.org/conda-forge/win-64/libharfbuzz-14.2.1-h03b5201_1.conda + sha256: 634a64cf43f1ce5a4139334bcdbde54d6854ae33d881ae1774377965e21051a5 + md5: 005469a341088900ca235892d3154c24 + depends: + - cairo >=1.18.4,<2.0a0 + - graphite2 >=1.3.15,<2.0a0 + - icu >=78.3,<79.0a0 + - libexpat >=2.8.1,<3.0a0 + - libfreetype >=2.14.3 + - libfreetype6 >=2.14.3 + - libglib >=2.88.2,<3.0a0 + - libpng >=1.6.58,<1.7.0a0 + - libzlib >=1.3.2,<2.0a0 + - ucrt >=10.0.20348.0 + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + license: MIT + license_family: MIT + purls: [] + size: 1008194 + timestamp: 1782801000396 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libharfbuzz-devel-14.2.1-h17a8019_1.conda + sha256: 6d8e793042affd18ca1784b7794fab14d16f54f984777ce6ab86bacaa465ab0d + md5: 99cf21100441e51272f1cd6fe0632a20 + depends: + - __glibc >=2.17,<3.0.a0 + - cairo >=1.18.4,<2.0a0 + - freetype + - graphite2 >=1.3.15,<2.0a0 + - icu >=78.3,<79.0a0 + - libfreetype >=2.14.3 + - libfreetype6 >=2.14.3 + - libgcc >=14 + - libglib >=2.88.2,<3.0a0 + - libharfbuzz 14.2.1 h17a8019_1 + - libpng >=1.6.58,<1.7.0a0 + - libstdcxx >=14 + - libzlib >=1.3.2,<2.0a0 + license: MIT + license_family: MIT + purls: [] + size: 1970690 + timestamp: 1782800603897 +- conda: https://conda.anaconda.org/conda-forge/win-64/libharfbuzz-devel-14.2.1-h03b5201_1.conda + sha256: d04bac65245bf76ae23a18148b941d8215085d38a6d391971966ccda8a996b99 + md5: de077ebf9cbc0c1da6510fdf1bbc6baa + depends: + - cairo >=1.18.4,<2.0a0 + - freetype + - glib + - graphite2 >=1.3.15,<2.0a0 + - icu >=78.3,<79.0a0 + - libexpat >=2.8.1,<3.0a0 + - libfreetype >=2.14.3 + - libfreetype6 >=2.14.3 + - libglib >=2.88.2,<3.0a0 + - libharfbuzz 14.2.1 h03b5201_1 + - libpng >=1.6.58,<1.7.0a0 + - libzlib >=1.3.2,<2.0a0 + - ucrt >=10.0.20348.0 + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + license: MIT + license_family: MIT + purls: [] + size: 321750 + timestamp: 1782801035822 - conda: https://conda.anaconda.org/conda-forge/linux-64/libhwloc-2.11.2-default_h0d58e46_1001.conda sha256: d14c016482e1409ae1c50109a9ff933460a50940d2682e745ab1c172b5282a69 md5: 804ca9e91bcaea0824a341d55b1684f2 @@ -5815,6 +8539,16 @@ packages: purls: [] size: 2396128 timestamp: 1770954127918 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libiconv-1.18-h3b78370_2.conda + sha256: c467851a7312765447155e071752d7bf9bf44d610a5687e32706f480aad2833f + md5: 915f5995e94f60e9a4826e0b0920ee88 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + license: LGPL-2.1-only + purls: [] + size: 790176 + timestamp: 1754908768807 - conda: https://conda.anaconda.org/conda-forge/linux-64/libiconv-1.18-h4ce23a2_0.conda sha256: 659a83c0c184a30336ca512d670a7db56bfb5e289caa9ee641e6f78fd2326463 md5: 0743bcd51fc4e6e0367e0aaf41e9bebc @@ -5834,6 +8568,24 @@ packages: purls: [] size: 671575 timestamp: 1739867181172 +- conda: https://conda.anaconda.org/conda-forge/osx-64/libiconv-1.18-h57a12c2_2.conda + sha256: a1c8cecdf9966921e13f0ae921309a1f415dfbd2b791f2117cf7e8f5e61a48b6 + md5: 210a85a1119f97ea7887188d176db135 + depends: + - __osx >=10.13 + license: LGPL-2.1-only + purls: [] + size: 737846 + timestamp: 1754908900138 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libiconv-1.18-h23cfdf5_2.conda + sha256: de0336e800b2af9a40bdd694b03870ac4a848161b35c8a2325704f123f185f03 + md5: 4d5a7445f0b25b6a3ddbb56e790f5251 + depends: + - __osx >=11.0 + license: LGPL-2.1-only + purls: [] + size: 750379 + timestamp: 1754909073836 - conda: https://conda.anaconda.org/conda-forge/win-64/libiconv-1.18-hc1393d2_2.conda sha256: 0dcdb1a5f01863ac4e8ba006a8b0dc1a02d2221ec3319b5915a1863254d7efa7 md5: 64571d1dd6cdcfa25d0664a5950fdaa2 @@ -5845,6 +8597,26 @@ packages: purls: [] size: 696926 timestamp: 1754909290005 +- conda: https://conda.anaconda.org/conda-forge/osx-64/libintl-0.25.1-h3184127_1.conda + sha256: 8c352744517bc62d24539d1ecc813b9fdc8a785c780197c5f0b84ec5b0dfe122 + md5: a8e54eefc65645193c46e8b180f62d22 + depends: + - __osx >=10.13 + - libiconv >=1.18,<2.0a0 + license: LGPL-2.1-or-later + purls: [] + size: 96909 + timestamp: 1753343977382 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libintl-0.25.1-h493aca8_0.conda + sha256: 99d2cebcd8f84961b86784451b010f5f0a795ed1c08f1e7c76fbb3c22abf021a + md5: 5103f6a6b210a3912faf8d7db516918c + depends: + - __osx >=11.0 + - libiconv >=1.18,<2.0a0 + license: LGPL-2.1-or-later + purls: [] + size: 90957 + timestamp: 1751558394144 - conda: https://conda.anaconda.org/conda-forge/win-64/libintl-0.22.5-h5728263_3.conda sha256: c7e4600f28bcada8ea81456a6530c2329312519efcf0c886030ada38976b0511 md5: 2cf0cf76cc15d360dfa2f17fd6cf9772 @@ -5854,6 +8626,16 @@ packages: purls: [] size: 95568 timestamp: 1723629479451 +- conda: https://conda.anaconda.org/conda-forge/win-64/libintl-devel-0.22.5-h5728263_3.conda + sha256: be1f3c48bc750bca7e68955d57180dfd826d6f9fa7eb32994f6cb61b813f9a6a + md5: 7537784e9e35399234d4007f45cdb744 + depends: + - libiconv >=1.17,<2.0a0 + - libintl 0.22.5 h5728263_3 + license: LGPL-2.1-or-later + purls: [] + size: 40746 + timestamp: 1723629745649 - conda: https://conda.anaconda.org/conda-forge/linux-64/libjpeg-turbo-3.1.2-hb03c661_0.conda sha256: cc9aba923eea0af8e30e0f94f2ad7156e2984d80d1e8e7fe6be5a1f257f0eb32 md5: 8397539e3a0bbd1695584fb4f927485a @@ -5866,6 +8648,18 @@ packages: purls: [] size: 633710 timestamp: 1762094827865 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libjpeg-turbo-3.2.0-hb03c661_0.conda + sha256: 716332fd31b3808da7a4235a05212a9e9da05e854864c3def2dea0b5d2bf7610 + md5: 466badda5536d85ddc63ee9404f29735 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + constrains: + - jpeg <0.0.0a + license: IJG AND BSD-3-Clause AND Zlib + purls: [] + size: 652868 + timestamp: 1783731886811 - conda: https://conda.anaconda.org/conda-forge/osx-64/libjpeg-turbo-3.1.2-h8616949_0.conda sha256: ebe2877abc046688d6ea299e80d8322d10c69763f13a102010f90f7168cc5f54 md5: 48dda187f169f5a8f1e5e07701d5cdd9 @@ -5877,6 +8671,17 @@ packages: purls: [] size: 586189 timestamp: 1762095332781 +- conda: https://conda.anaconda.org/conda-forge/osx-64/libjpeg-turbo-3.2.0-ha1e9b39_0.conda + sha256: 5c48ea89073ba28eb93df264587973d3905827e5b536a5320604ae3baaa73e13 + md5: d86c1b9259377fb4dcd76fe7472bd2d2 + depends: + - __osx >=11.0 + constrains: + - jpeg <0.0.0a + license: IJG AND BSD-3-Clause AND Zlib + purls: [] + size: 613600 + timestamp: 1783732260943 - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libjpeg-turbo-3.1.2-hc919400_0.conda sha256: 6c061c56058bb10374daaef50e81b39cf43e8aee21f0037022c0c39c4f31872f md5: f0695fbecf1006f27f4395d64bd0c4b8 @@ -5888,6 +8693,17 @@ packages: purls: [] size: 551197 timestamp: 1762095054358 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libjpeg-turbo-3.2.0-h84a0fba_0.conda + sha256: e2b4fce7cf48705dc182a0aa6c478a47b16202aeb712242caf9c9ab6a19778fa + md5: 8f05a69b7e870574a2d366043f1515b1 + depends: + - __osx >=11.0 + constrains: + - jpeg <0.0.0a + license: IJG AND BSD-3-Clause AND Zlib + purls: [] + size: 558409 + timestamp: 1783732115664 - conda: https://conda.anaconda.org/conda-forge/win-64/libjpeg-turbo-3.1.2-hfd05255_0.conda sha256: 795e2d4feb2f7fc4a2c6e921871575feb32b8082b5760726791f080d1e2c2597 md5: 56a686f92ac0273c0f6af58858a3f013 @@ -5901,6 +8717,19 @@ packages: purls: [] size: 841783 timestamp: 1762094814336 +- conda: https://conda.anaconda.org/conda-forge/win-64/libjpeg-turbo-3.2.0-hfd05255_0.conda + sha256: 3d6635efa9497b9c5ba7957df8067c0a980d5cb10a6ea136931809eb410f8a99 + md5: cf219146d5bf2fee5907409ff9f5ac89 + depends: + - ucrt >=10.0.20348.0 + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + constrains: + - jpeg <0.0.0a + license: IJG AND BSD-3-Clause AND Zlib + purls: [] + size: 991057 + timestamp: 1783731990693 - conda: https://conda.anaconda.org/conda-forge/linux-64/liblapack-3.11.0-8_h47877c9_openblas.conda build_number: 8 sha256: 168e327d737059553e15cc6ec36d76b9bbb3931c2a7721555fd68b4c9348b247 @@ -6087,6 +8916,22 @@ packages: purls: [] size: 44333366 timestamp: 1765959132513 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libllvm22-22.1.8-hf7376ad_1.conda + sha256: e9b5f301d6b001a9b8ce782157f56b75c92c4fbc9eba95dc6345c1139251d13b + md5: 298bb2483fc7d15396147cf1c1465359 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - libstdcxx >=14 + - libxml2 + - libxml2-16 >=2.14.6 + - libzlib >=1.3.2,<2.0a0 + - zstd >=1.5.7,<1.6.0a0 + license: Apache-2.0 WITH LLVM-exception + license_family: Apache + purls: [] + size: 44320272 + timestamp: 1781788728739 - conda: https://conda.anaconda.org/conda-forge/linux-64/liblzma-5.8.1-hb9d3cd8_2.conda sha256: f2591c0069447bbe28d4d696b7fcb0c5bd0b4ac582769b89addbcf26fb3430d8 md5: 1a580f7796c7bf6393fddb8bbbde58dc @@ -6190,6 +9035,27 @@ packages: purls: [] size: 89991 timestamp: 1723817448345 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libmpdec-4.0.0-hb03c661_1.conda + sha256: fe171ed5cf5959993d43ff72de7596e8ac2853e9021dec0344e583734f1e0843 + md5: 2c21e66f50753a083cbe6b80f38268fa + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + license: BSD-2-Clause + license_family: BSD + purls: [] + size: 92400 + timestamp: 1769482286018 +- conda: https://conda.anaconda.org/conda-forge/osx-64/libmpdec-4.0.0-hf3981d6_1.conda + sha256: 1096c740109386607938ab9f09a7e9bca06d86770a284777586d6c378b8fb3fd + md5: ec88ba8a245855935b871a7324373105 + depends: + - __osx >=10.13 + license: BSD-2-Clause + license_family: BSD + purls: [] + size: 79899 + timestamp: 1769482558610 - conda: https://conda.anaconda.org/conda-forge/osx-64/libmpdec-4.0.0-hfdf4475_0.conda sha256: 791be3d30d8e37ec49bcc23eb8f1e1415d911a7c023fa93685f2ea485179e258 md5: ed625b2e59dff82859c23dd24774156b @@ -6200,6 +9066,16 @@ packages: purls: [] size: 76561 timestamp: 1723817691512 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libmpdec-4.0.0-h84a0fba_1.conda + sha256: 1089c7f15d5b62c622625ec6700732ece83be8b705da8c6607f4dabb0c4bd6d2 + md5: 57c4be259f5e0b99a5983799a228ae55 + depends: + - __osx >=11.0 + license: BSD-2-Clause + license_family: BSD + purls: [] + size: 73690 + timestamp: 1769482560514 - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libmpdec-4.0.0-h99b78c6_0.conda sha256: f7917de9117d3a5fe12a39e185c7ce424f8d5010a6f97b4333e8a1dcb2889d16 md5: 7476305c35dd9acef48da8f754eedb40 @@ -6222,6 +9098,18 @@ packages: purls: [] size: 88657 timestamp: 1723861474602 +- conda: https://conda.anaconda.org/conda-forge/win-64/libmpdec-4.0.0-hfd05255_1.conda + sha256: 40dcd0b9522a6e0af72a9db0ced619176e7cfdb114855c7a64f278e73f8a7514 + md5: e4a9fc2bba3b022dad998c78856afe47 + depends: + - ucrt >=10.0.20348.0 + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + license: BSD-2-Clause + license_family: BSD + purls: [] + size: 89411 + timestamp: 1769482314283 - conda: https://conda.anaconda.org/conda-forge/linux-64/libnghttp2-1.67.0-had1ee68_0.conda sha256: a4a7dab8db4dc81c736e9a9b42bdfd97b087816e029e221380511960ac46c690 md5: b499ce4b026493a13774bcf0f4c33849 @@ -6441,6 +9329,16 @@ packages: purls: [] size: 50757 timestamp: 1731330993524 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libopengl-1.7.0-ha4b6fd6_3.conda + sha256: 90777039b48529283df5f16383fc399866024257a8bd93de583f4730db1ab30a + md5: c2bd8055a2e2dce7a7f32cfd02101fb6 + depends: + - __glibc >=2.17,<3.0.a0 + - libglvnd 1.7.0 ha4b6fd6_3 + license: LicenseRef-libglvnd + purls: [] + size: 51767 + timestamp: 1779728204026 - conda: https://conda.anaconda.org/conda-forge/linux-64/libpciaccess-0.18-hb9d3cd8_0.conda sha256: 0bd91de9b447a2991e666f284ae8c722ffb1d84acb594dbd0c031bd656fa32b2 md5: 70e3400cbbfa03e96dcde7fc13e38c7b @@ -6452,6 +9350,17 @@ packages: purls: [] size: 28424 timestamp: 1749901812541 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libpciaccess-0.19-hb03c661_0.conda + sha256: f41721636a7c2e51bc2c642e1127955ab9c81145470714fdaac44d4d09e4af41 + md5: 33082e13b4769b48cfeb648e15bfe3fc + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + license: MIT + license_family: MIT + purls: [] + size: 29147 + timestamp: 1773533027610 - conda: https://conda.anaconda.org/conda-forge/linux-64/libpng-1.6.54-h421ea60_0.conda sha256: 5de60d34aac848a9991a09fcdea7c0e783d00024aefec279d55e87c0c44742cd md5: d361fa2a59e53b61c2675bfa073e5b7e @@ -6463,6 +9372,17 @@ packages: purls: [] size: 317435 timestamp: 1768285668880 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libpng-1.6.58-h421ea60_0.conda + sha256: 377cfe037f3eeb3b1bf3ad333f724a64d32f315ee1958581fc671891d63d3f89 + md5: eba48a68a1a2b9d3c0d9511548db85db + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - libzlib >=1.3.2,<2.0a0 + license: zlib-acknowledgement + purls: [] + size: 317729 + timestamp: 1776315175087 - conda: https://conda.anaconda.org/conda-forge/osx-64/libpng-1.6.54-h07817ec_0.conda sha256: c0efdf9b34132e7d4e0051bf65a97f1b9e1125c7f8a9067a35ec119af367eb38 md5: 3d43dcdfcc3971939c80f855cf2df235 @@ -6473,6 +9393,16 @@ packages: purls: [] size: 298894 timestamp: 1768285676981 +- conda: https://conda.anaconda.org/conda-forge/osx-64/libpng-1.6.58-he930e7c_0.conda + sha256: a669b22978e546484d18d99a210801b1823360a266d7035c713d8d1facd035f7 + md5: 9744d43d5200f284260637304a069ddd + depends: + - __osx >=11.0 + - libzlib >=1.3.2,<2.0a0 + license: zlib-acknowledgement + purls: [] + size: 299206 + timestamp: 1776315286816 - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libpng-1.6.54-h132b30e_0.conda sha256: 1c271c0ec73b69f7570c5da67d0e47ddf7ff079bc1ca2dfaccd267ea39314b06 md5: 1b80fd1eecb98f1cb7de4239f5d7dc15 @@ -6483,6 +9413,16 @@ packages: purls: [] size: 288910 timestamp: 1768285694469 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libpng-1.6.58-h132b30e_0.conda + sha256: 66eae34546df1f098a67064970c92aa14ae7a7505091889e00468294d2882c36 + md5: 2259ae0949dbe20c0665850365109b27 + depends: + - __osx >=11.0 + - libzlib >=1.3.2,<2.0a0 + license: zlib-acknowledgement + purls: [] + size: 289546 + timestamp: 1776315246750 - conda: https://conda.anaconda.org/conda-forge/win-64/libpng-1.6.54-h7351971_0.conda sha256: 6e269361aa18a57bd2e593e480d83d93fc5f839d33d3bfc31b4ffe10edf6751c md5: 638ecb69e44b6a588afd5633e81f9e61 @@ -6495,6 +9435,18 @@ packages: purls: [] size: 383094 timestamp: 1768285706434 +- conda: https://conda.anaconda.org/conda-forge/win-64/libpng-1.6.58-h7351971_0.conda + sha256: 218913aeee391460bd0e341b834dbd9c6fa6ae0a4276c0c300266cc99a816a28 + md5: 52f1280563f3b48b5f75414cd2d15dd1 + depends: + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + - ucrt >=10.0.20348.0 + - libzlib >=1.3.2,<2.0a0 + license: zlib-acknowledgement + purls: [] + size: 385227 + timestamp: 1776315248638 - conda: https://conda.anaconda.org/conda-forge/linux-64/libpq-18.1-hb80d175_3.conda sha256: 21adefed86a36622dd500d7862cb980c5bdaab6ed3f4930a9b9afceabc7a6d58 md5: c39da2ad0e7dd600d1eb3146783b057d @@ -6509,6 +9461,20 @@ packages: purls: [] size: 2761692 timestamp: 1766448056465 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libpq-18.4-hd5a49e9_1.conda + sha256: f7232cb79a31f5a5bcd499aea930b469cde8b96d26db9541022493fd274d2a6e + md5: 6c9103e7ea739a3bb3505da49a4708c1 + depends: + - __glibc >=2.17,<3.0.a0 + - icu >=78.3,<79.0a0 + - krb5 >=1.22.2,<1.23.0a0 + - libgcc >=14 + - openldap >=2.6.13,<2.7.0a0 + - openssl >=3.5.7,<4.0a0 + license: PostgreSQL + purls: [] + size: 2709008 + timestamp: 1782580447454 - conda: https://conda.anaconda.org/conda-forge/linux-64/libpsl-0.22.0-hd9031aa_0.conda sha256: cd11890a2c1f14d0342bfcbd81f97152d61dc71c27c7085efc13705a8f64f7c9 md5: e2834a423b3967e7b3b1e901c4a5f42f @@ -6559,6 +9525,65 @@ packages: purls: [] size: 85552 timestamp: 1782394903537 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libraqm-0.10.5-h6406941_1.conda + sha256: 7c9e562842f193f772ef0ba681f238a2d9e5ef637588b6e46eb30cc6aa1940c8 + md5: fa63517815747363c41b439ff9301db1 + depends: + - __glibc >=2.28,<3.0.a0 + - libgcc >=14 + - libharfbuzz >=14.2.1 + - libfreetype >=2.14.3 + - libfreetype6 >=2.14.3 + - fribidi >=1.0.16,<2.0a0 + license: MIT + license_family: MIT + purls: [] + size: 29441 + timestamp: 1782807076031 +- conda: https://conda.anaconda.org/conda-forge/osx-64/libraqm-0.10.5-h1888d0e_1.conda + sha256: ad1bf7d798c5ea5ed246a3e47d5c11028a71f846f90dda8d1e3e53b32364b7a8 + md5: 4652bf9d34e607edca7e220d2df74ce4 + depends: + - __osx >=11.0 + - fribidi >=1.0.16,<2.0a0 + - libfreetype >=2.14.3 + - libfreetype6 >=2.14.3 + - libharfbuzz >=14.2.1 + license: MIT + license_family: MIT + purls: [] + size: 28241 + timestamp: 1782807441485 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libraqm-0.10.5-h45af499_1.conda + sha256: 7d88c506b9899d60e57f7456b02f54c7330029f2ad56c6df96357f981aa1bd96 + md5: fa1a27aaaa10e92be48372fa01573f7c + depends: + - __osx >=11.0 + - libharfbuzz >=14.2.1 + - libfreetype >=2.14.3 + - libfreetype6 >=2.14.3 + - fribidi >=1.0.16,<2.0a0 + license: MIT + license_family: MIT + purls: [] + size: 27026 + timestamp: 1782807229285 +- conda: https://conda.anaconda.org/conda-forge/win-64/libraqm-0.10.5-h50d6d30_1.conda + sha256: 79ca55f7202daa560bffafcf7aef435e48618fe91a5243b8e4a6ed4edfbe63bc + md5: e5ab537cdd3462f26be2803209142913 + depends: + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + - ucrt >=10.0.20348.0 + - libfreetype >=2.14.3 + - libfreetype6 >=2.14.3 + - libharfbuzz >=14.2.1 + - fribidi >=1.0.16,<2.0a0 + license: MIT + license_family: MIT + purls: [] + size: 29296 + timestamp: 1782807186901 - conda: https://conda.anaconda.org/conda-forge/linux-64/libsodium-1.0.20-h4ab18f5_0.conda sha256: 0105bd108f19ea8e6a78d2d994a6d4a8db16d19a41212070d2d1d48a63c34161 md5: a587892d3c13b6621a6091be690dbca2 @@ -6568,6 +9593,16 @@ packages: purls: [] size: 205978 timestamp: 1716828628198 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libsodium-1.0.22-h280c20c_1.conda + sha256: b677bbf1c339d894757c3dcfbb2f88649e499e4991d70ae09a1466da9a6c92d6 + md5: 965e4d531b588b2e42f66fd8e48b056c + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + license: ISC + purls: [] + size: 269272 + timestamp: 1779163468406 - conda: https://conda.anaconda.org/conda-forge/osx-64/libsodium-1.0.20-hfdf4475_0.conda sha256: d3975cfe60e81072666da8c76b993af018cf2e73fe55acba2b5ba0928efaccf5 md5: 6af4b059e26492da6013e79cbcb4d069 @@ -6577,6 +9612,15 @@ packages: purls: [] size: 210249 timestamp: 1716828641383 +- conda: https://conda.anaconda.org/conda-forge/osx-64/libsodium-1.0.22-ha3d0635_1.conda + sha256: 07f0f37463564d93530fc23e2a77cc1aad58ba8724b1842f8713dbf6cde17cb0 + md5: bf0ce6af8f7628e34cdb399f6aa82e53 + depends: + - __osx >=11.0 + license: ISC + purls: [] + size: 281370 + timestamp: 1779164249823 - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsodium-1.0.20-h99b78c6_0.conda sha256: fade8223e1e1004367d7101dd17261003b60aa576df6d7802191f8972f7470b1 md5: a7ce36e284c5faaf93c220dfc39e3abd @@ -6586,6 +9630,15 @@ packages: purls: [] size: 164972 timestamp: 1716828607917 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsodium-1.0.22-h1a92334_1.conda + sha256: 202be45db5726757a8ea1f374f85aacc18c504f5ff15b2558496dff4c8779c48 + md5: 9ed5ab909c449bdcae72322e44875a18 + depends: + - __osx >=11.0 + license: ISC + purls: [] + size: 247352 + timestamp: 1779164136206 - conda: https://conda.anaconda.org/conda-forge/win-64/libsodium-1.0.20-hc70643c_0.conda sha256: 7bcb3edccea30f711b6be9601e083ecf4f435b9407d70fc48fbcf9e5d69a0fc6 md5: 198bb594f202b205c7d18b936fa4524f @@ -6595,8 +9648,19 @@ packages: - vc14_runtime >=14.29.30139 license: ISC purls: [] - size: 202344 - timestamp: 1716828757533 + size: 202344 + timestamp: 1716828757533 +- conda: https://conda.anaconda.org/conda-forge/win-64/libsodium-1.0.22-h6a83c73_1.conda + sha256: de45b71224da77a1c3a7dd48d8885eb957c9f05455d4f0828463293e7144330f + md5: 7d5abf7ca1bd00b43d273f44d93d05dc + depends: + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + - ucrt >=10.0.20348.0 + license: ISC + purls: [] + size: 280234 + timestamp: 1779164124739 - conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.51.2-hf4e2dac_0.conda sha256: 04596fcee262a870e4b7c9807224680ff48d4d0cc0dac076a602503d3dc6d217 md5: da5be73701eecd0e8454423fd6ffcf30 @@ -6845,6 +9909,24 @@ packages: purls: [] size: 435273 timestamp: 1762022005702 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libtiff-4.7.2-h9d88235_0.conda + sha256: b31346e1c01ab40a170e91147092ee8fd92b1dee3c66ee47ef025571c879b159 + md5: c1fcb4a88bc15a9f77ad8d27d7af1df9 + depends: + - __glibc >=2.17,<3.0.a0 + - lerc >=4.1.0,<5.0a0 + - libdeflate >=1.25,<1.26.0a0 + - libgcc >=14 + - libjpeg-turbo >=3.1.4.1,<4.0a0 + - liblzma >=5.8.3,<6.0a0 + - libstdcxx >=14 + - libwebp-base >=1.6.0,<2.0a0 + - libzlib >=1.3.2,<2.0a0 + - zstd >=1.5.7,<1.6.0a0 + license: HPND + purls: [] + size: 452337 + timestamp: 1783084902636 - conda: https://conda.anaconda.org/conda-forge/osx-64/libtiff-4.7.0-hb77a491_3.conda sha256: bb50df7cfc1acb11eae63c5f4fdc251d381cda96bf02c086c3202c83a5200032 md5: 6f2f9df7b093d6b33bc0c334acc7d2d9 @@ -6862,6 +9944,23 @@ packages: purls: [] size: 400099 timestamp: 1734398943635 +- conda: https://conda.anaconda.org/conda-forge/osx-64/libtiff-4.7.2-h95d6d7f_0.conda + sha256: 8e43d2a3538f45848c61cdda4baa6728ce0a48bc665b306de5a31dd3464a30c1 + md5: c92fd887c114aac4612bfc14b1516776 + depends: + - __osx >=11.0 + - lerc >=4.1.0,<5.0a0 + - libcxx >=19 + - libdeflate >=1.25,<1.26.0a0 + - libjpeg-turbo >=3.1.4.1,<4.0a0 + - liblzma >=5.8.3,<6.0a0 + - libwebp-base >=1.6.0,<2.0a0 + - libzlib >=1.3.2,<2.0a0 + - zstd >=1.5.7,<1.6.0a0 + license: HPND + purls: [] + size: 418681 + timestamp: 1783085828393 - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libtiff-4.7.1-h4030677_1.conda sha256: e9248077b3fa63db94caca42c8dbc6949c6f32f94d1cafad127f9005d9b1507f md5: e2a72ab2fa54ecb6abab2b26cde93500 @@ -6879,6 +9978,23 @@ packages: purls: [] size: 373892 timestamp: 1762022345545 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libtiff-4.7.2-h282da08_0.conda + sha256: 253153cabf9469170e02b21a6bc9aa598048e7c34966b1103af52d27d2a708a4 + md5: 6fa87106b3c041ad6d965a9411e79b94 + depends: + - __osx >=11.0 + - lerc >=4.1.0,<5.0a0 + - libcxx >=19 + - libdeflate >=1.25,<1.26.0a0 + - libjpeg-turbo >=3.1.4.1,<4.0a0 + - liblzma >=5.8.3,<6.0a0 + - libwebp-base >=1.6.0,<2.0a0 + - libzlib >=1.3.2,<2.0a0 + - zstd >=1.5.7,<1.6.0a0 + license: HPND + purls: [] + size: 387825 + timestamp: 1783085754081 - conda: https://conda.anaconda.org/conda-forge/win-64/libtiff-4.7.1-h8f73337_1.conda sha256: f1b8cccaaeea38a28b9cd496694b2e3d372bb5be0e9377c9e3d14b330d1cba8a md5: 549845d5133100142452812feb9ba2e8 @@ -6896,6 +10012,23 @@ packages: purls: [] size: 993166 timestamp: 1762022118895 +- conda: https://conda.anaconda.org/conda-forge/win-64/libtiff-4.7.2-h8f73337_0.conda + sha256: ec6d66308a6d6abaf3225f2f185113e6172e77eb0fa8622af982d7a5d6d47a2c + md5: e83f459471905a04ebe15e21d063c49d + depends: + - lerc >=4.1.0,<5.0a0 + - libdeflate >=1.25,<1.26.0a0 + - libjpeg-turbo >=3.1.4.1,<4.0a0 + - liblzma >=5.8.3,<6.0a0 + - libzlib >=1.3.2,<2.0a0 + - ucrt >=10.0.20348.0 + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + - zstd >=1.5.7,<1.6.0a0 + license: HPND + purls: [] + size: 1014598 + timestamp: 1783085017197 - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.41.3-h5347b49_0.conda sha256: 1a7539cfa7df00714e8943e18de0b06cceef6778e420a5ee3a2a145773758aee md5: db409b7c1720428638e7c0d509d3e1b5 @@ -6934,6 +10067,22 @@ packages: purls: [] size: 197672 timestamp: 1759972155030 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libvulkan-loader-1.4.341.0-h5279c79_0.conda + sha256: a68280d57dfd29e3d53400409a39d67c4b9515097eba733aa6fe00c880620e2b + md5: 31ad065eda3c2d88f8215b1289df9c89 + depends: + - __glibc >=2.17,<3.0.a0 + - libstdcxx >=14 + - libgcc >=14 + - xorg-libx11 >=1.8.12,<2.0a0 + - xorg-libxrandr >=1.5.5,<2.0a0 + constrains: + - libvulkan-headers 1.4.341.0.* + license: Apache-2.0 + license_family: APACHE + purls: [] + size: 199795 + timestamp: 1770077125520 - conda: https://conda.anaconda.org/conda-forge/win-64/libvulkan-loader-1.4.328.1-h477610d_0.conda sha256: 934d676c445c1ea010753dfa98680b36a72f28bec87d15652f013c91a1d8d171 md5: 4403eae6c81f448d63a7f66c0b330536 @@ -6951,6 +10100,20 @@ packages: purls: [] size: 280488 timestamp: 1759972163692 +- conda: https://conda.anaconda.org/conda-forge/win-64/libvulkan-loader-1.4.341.0-h477610d_0.conda + sha256: 0f0965edca8b255187604fc7712c53fe9064b31a1845a7dfb2b63bf660de84a7 + md5: 804880b2674119b84277d6c16b01677d + depends: + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + - ucrt >=10.0.20348.0 + constrains: + - libvulkan-headers 1.4.341.0.* + license: Apache-2.0 + license_family: APACHE + purls: [] + size: 282251 + timestamp: 1770077165680 - conda: https://conda.anaconda.org/conda-forge/linux-64/libwebp-base-1.6.0-hd42ef1d_0.conda sha256: 3aed21ab28eddffdaf7f804f49be7a7d701e8f0e46c856d801270b470820a37b md5: aea31d2e5b1091feca96fcfe945c3cf9 @@ -7107,6 +10270,23 @@ packages: purls: [] size: 837922 timestamp: 1764794163823 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libxkbcommon-1.13.2-hca5e8e5_0.conda + sha256: 046f2ff4acebd8729fac03e99c8c307dfb48b6a32894ba8c11576e78f6e76e43 + md5: dc8b067e22b414172bedd8e3f03f3c95 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - libstdcxx >=14 + - libxcb >=1.17.0,<2.0a0 + - libxml2 + - libxml2-16 >=2.14.6 + - xkeyboard-config + - xorg-libxau >=1.0.12,<2.0a0 + license: MIT/X11 Derivative + license_family: MIT + purls: [] + size: 851166 + timestamp: 1780213397575 - conda: https://conda.anaconda.org/conda-forge/linux-64/libxml2-2.15.1-he237659_1.conda sha256: 047be059033c394bd32ae5de66ce389824352120b3a7c0eff980195f7ed80357 md5: 417955234eccd8f252b86a265ccdab7f @@ -7123,6 +10303,22 @@ packages: purls: [] size: 45402 timestamp: 1766327161688 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libxml2-2.15.3-h49c6c72_0.conda + sha256: 3bc5551720c58591f6ea1146f7d1539c734ed1c40e7b9f5cb8cb7e900c509aba + md5: 995d8c8bad2a3cc8db14675a153dec2b + depends: + - __glibc >=2.17,<3.0.a0 + - icu >=78.3,<79.0a0 + - libgcc >=14 + - libiconv >=1.18,<2.0a0 + - liblzma >=5.8.3,<6.0a0 + - libxml2-16 2.15.3 hca6bf5a_0 + - libzlib >=1.3.2,<2.0a0 + license: MIT + license_family: MIT + purls: [] + size: 46810 + timestamp: 1776376751152 - conda: https://conda.anaconda.org/conda-forge/osx-64/libxml2-2.13.6-he8ee3e7_0.conda sha256: 6238384f6d5b68e231f0b83d081aec23c8ac2a17458c097fc81baa089a06ab94 md5: 0f7ae42cd61056bfb1298f53caaddbc7 @@ -7172,6 +10368,24 @@ packages: purls: [] size: 43684 timestamp: 1776376992865 +- conda: https://conda.anaconda.org/conda-forge/win-64/libxml2-2.15.3-hbc0d294_0.conda + sha256: da68af9d9d28d65a6916db1bef68f8a25c64c4fdcf759f32a2d2f2f143220adf + md5: e3b5acbb857a12f5d59e8d174bc536c0 + depends: + - libiconv >=1.18,<2.0a0 + - liblzma >=5.8.3,<6.0a0 + - libxml2-16 2.15.3 h692994f_0 + - libzlib >=1.3.2,<2.0a0 + - ucrt >=10.0.20348.0 + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + constrains: + - icu <0.0a0 + license: MIT + license_family: MIT + purls: [] + size: 43916 + timestamp: 1776376994334 - conda: https://conda.anaconda.org/conda-forge/linux-64/libxml2-16-2.15.1-hca6bf5a_1.conda sha256: 8331284bf9ae641b70cdc0e5866502dd80055fc3b9350979c74bb1d192e8e09e md5: 3fdd8d99683da9fe279c2f4cecd1e048 @@ -7189,6 +10403,23 @@ packages: purls: [] size: 555747 timestamp: 1766327145986 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libxml2-16-2.15.3-hca6bf5a_0.conda + sha256: 3d44f737c5ae52d5af32682cc1530df433f401f8e58a7533926536244127572a + md5: e79d2c2f24b027aa8d5ab1b1ba3061e7 + depends: + - __glibc >=2.17,<3.0.a0 + - icu >=78.3,<79.0a0 + - libgcc >=14 + - libiconv >=1.18,<2.0a0 + - liblzma >=5.8.3,<6.0a0 + - libzlib >=1.3.2,<2.0a0 + constrains: + - libxml2 2.15.3 + license: MIT + license_family: MIT + purls: [] + size: 559775 + timestamp: 1776376739004 - conda: https://conda.anaconda.org/conda-forge/win-64/libxml2-16-2.15.1-h3cfd58e_1.conda sha256: a857e941156b7f462063e34e086d212c6ccbc1521ebdf75b9ed66bd90add57dc md5: 07d73826fde28e7dbaec52a3297d7d26 @@ -7225,6 +10456,24 @@ packages: purls: [] size: 519871 timestamp: 1776376969852 +- conda: https://conda.anaconda.org/conda-forge/win-64/libxml2-16-2.15.3-h692994f_0.conda + sha256: 8038084c60eda2006d0122d05e3364fe8db0a18935ca6ed0168b5ba5aa33f904 + md5: f7d6fcda29570e20851b78d92ea2154e + depends: + - libiconv >=1.18,<2.0a0 + - liblzma >=5.8.3,<6.0a0 + - libzlib >=1.3.2,<2.0a0 + - ucrt >=10.0.20348.0 + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + constrains: + - libxml2 2.15.3 + - icu <0.0a0 + license: MIT + license_family: MIT + purls: [] + size: 518869 + timestamp: 1776376971242 - conda: https://conda.anaconda.org/conda-forge/linux-64/libxslt-1.1.43-h711ed8c_1.conda sha256: 0694760a3e62bdc659d90a14ae9c6e132b525a7900e59785b18a08bb52a5d7e5 md5: 87e6096ec6d542d1c1f8b33245fe8300 @@ -7431,22 +10680,22 @@ packages: purls: [] size: 348002 timestamp: 1781737042070 -- conda: https://conda.anaconda.org/conda-forge/linux-64/llvmlite-0.42.0-py310h1b8f574_1.conda - sha256: 2b25157b0724cbfc84b58e83a466d84afb8a5f09889a224c821d86adb4541ba1 - md5: e2a5e9f92629c8e4c8611883a35745b4 +- conda: https://conda.anaconda.org/conda-forge/linux-64/llvmlite-0.42.0-py311ha6695c7_1.conda + sha256: 21d3d7d7cd5cd42d9783d828c885a5bc6f4caf91c95afedcf097ed18b5b08a15 + md5: d6e13a53b4f0cc38f4a348f47bfd5b97 depends: - libgcc-ng >=12 - libllvm14 >=14.0.6,<14.1.0a0 - libstdcxx-ng >=12 - libzlib >=1.2.13,<2.0.0a0 - - python >=3.10,<3.11.0a0 - - python_abi 3.10.* *_cp310 + - python >=3.11,<3.12.0a0 + - python_abi 3.11.* *_cp311 license: BSD-2-Clause license_family: BSD purls: - pkg:pypi/llvmlite?source=hash-mapping - size: 3328102 - timestamp: 1706921747584 + size: 3410396 + timestamp: 1706921725407 - conda: https://conda.anaconda.org/conda-forge/linux-64/llvmlite-0.46.0-py314h946fb2a_0.conda sha256: 99f15d69f059aa9c7d06cc45a6519a2375cc7a93ca85127964d6325a89a2b519 md5: 7ee180b967506bbd108ca9d5ff45eace @@ -7464,21 +10713,55 @@ packages: - pkg:pypi/llvmlite?source=hash-mapping size: 34123266 timestamp: 1765279959565 -- conda: https://conda.anaconda.org/conda-forge/osx-64/llvmlite-0.42.0-py310h7d48a1f_1.conda - sha256: 1df7c833b97ad3094cecd3f7e247e1ae61c8368dff011ec52b67b3796a83b32f - md5: 0c57dbd48571b4ea3847b7298082a0d0 +- conda: https://conda.anaconda.org/conda-forge/linux-64/llvmlite-0.47.0-py314h47fec7e_1.conda + sha256: 22c6716f1ad3471a9784410843b2586cf128112e72a034e6b139f9a239899d1c + md5: 5b7abf339789e84d930688a083bcc6e1 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - libstdcxx >=14 + - libzlib >=1.3.2,<2.0a0 + - python >=3.14,<3.15.0a0 + - python_abi 3.14.* *_cp314t + - zstd >=1.5.7,<1.6.0a0 + license: BSD-2-Clause + license_family: BSD + purls: + - pkg:pypi/llvmlite?source=hash-mapping + size: 34121209 + timestamp: 1776076738851 +- conda: https://conda.anaconda.org/conda-forge/linux-64/llvmlite-0.47.0-py314h946fb2a_1.conda + sha256: e77292afb920e8b46f75c98a370d79aa4a922ff1ebed38c54381ad5d613c834e + md5: 22feb934c64b2d62b3b2b278eb40629e + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - libstdcxx >=14 + - libzlib >=1.3.2,<2.0a0 + - python >=3.14,<3.15.0a0 + - python_abi 3.14.* *_cp314 + - zstd >=1.5.7,<1.6.0a0 + license: BSD-2-Clause + license_family: BSD + purls: + - pkg:pypi/llvmlite?source=hash-mapping + size: 34134565 + timestamp: 1776076748673 +- conda: https://conda.anaconda.org/conda-forge/osx-64/llvmlite-0.42.0-py311hb5c2e0a_1.conda + sha256: c6d43a902949414215bd93e19564d621fd35b1004acf3b774bb436770a9d64e7 + md5: 5f479bbbdd84efb9f6ed247555e9e61e depends: - libcxx >=16 - libllvm14 >=14.0.6,<14.1.0a0 - libzlib >=1.2.13,<2.0.0a0 - - python >=3.10,<3.11.0a0 - - python_abi 3.10.* *_cp310 + - python >=3.11,<3.12.0a0 + - python_abi 3.11.* *_cp311 license: BSD-2-Clause license_family: BSD purls: - pkg:pypi/llvmlite?source=hash-mapping - size: 307622 - timestamp: 1706921895845 + size: 382168 + timestamp: 1706921944078 - conda: https://conda.anaconda.org/conda-forge/osx-64/llvmlite-0.44.0-py313h07923c2_0.conda sha256: b80cf0da2a27043886e810a5bec06f200c2c1716450e371c609a7dd4ec9aedb1 md5: a4795a93ab5e6b75523f82e23056e1d2 @@ -7495,22 +10778,54 @@ packages: - pkg:pypi/llvmlite?source=hash-mapping size: 415146 timestamp: 1738108747294 -- conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvmlite-0.42.0-py310hf7687f1_1.conda - sha256: 491d27b8454b4945df993feb66b22527e43a493ef0a53b30019c8beb31ce0889 - md5: 46b8c7ae6c4817568b0fb78aadf3be97 +- conda: https://conda.anaconda.org/conda-forge/osx-64/llvmlite-0.47.0-py314h81801d0_1.conda + sha256: e03c3dc7f3c3986126125a78a26809e932f89606f833b055f05991e71fd0b872 + md5: 397bf42b402c7de06fadf567846e8d99 + depends: + - __osx >=11.0 + - libcxx >=19 + - libzlib >=1.3.2,<2.0a0 + - python >=3.14,<3.15.0a0 + - python_abi 3.14.* *_cp314t + - zstd >=1.5.7,<1.6.0a0 + license: BSD-2-Clause + license_family: BSD + purls: + - pkg:pypi/llvmlite?source=hash-mapping + size: 25993050 + timestamp: 1776077537826 +- conda: https://conda.anaconda.org/conda-forge/osx-64/llvmlite-0.47.0-py314hf43a1d0_1.conda + sha256: 42f64fd8ad94981bdf8cef0a6897cb7ad7ed61baf9064d8a91e285e21e7ce780 + md5: 3184407147c2917aa4fbb7ce3848efd0 + depends: + - __osx >=11.0 + - libcxx >=19 + - libzlib >=1.3.2,<2.0a0 + - python >=3.14,<3.15.0a0 + - python_abi 3.14.* *_cp314 + - zstd >=1.5.7,<1.6.0a0 + license: BSD-2-Clause + license_family: BSD + purls: + - pkg:pypi/llvmlite?source=hash-mapping + size: 26003082 + timestamp: 1776077079350 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvmlite-0.42.0-py311hf5d242d_1.conda + sha256: ba30520627cd2d83ad9148a1b6fe47245eee6418a427ae7e3877b8f6a8e6190a + md5: 22911c08b0f895185d4c0292c0ac2893 depends: - libcxx >=16 - libllvm14 >=14.0.6,<14.1.0a0 - libzlib >=1.2.13,<2.0.0a0 - - python >=3.10,<3.11.0a0 - - python >=3.10,<3.11.0a0 *_cpython - - python_abi 3.10.* *_cp310 + - python >=3.11,<3.12.0a0 + - python >=3.11,<3.12.0a0 *_cpython + - python_abi 3.11.* *_cp311 license: BSD-2-Clause license_family: BSD purls: - pkg:pypi/llvmlite?source=hash-mapping - size: 306724 - timestamp: 1706921994701 + size: 379911 + timestamp: 1706921964220 - conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvmlite-0.46.0-py314ha398f32_0.conda sha256: 10ee25664d790b117d84701506b60caba147f7bf599215cbd688037aaa42ff81 md5: b9eefe6197dafc779b784731fa507f60 @@ -7528,13 +10843,30 @@ packages: - pkg:pypi/llvmlite?source=hash-mapping size: 24330524 timestamp: 1765280789928 -- conda: https://conda.anaconda.org/conda-forge/win-64/llvmlite-0.42.0-py310hb84602e_1.conda - sha256: 9bf1ff1cb94911c473cc9a307032a303b5ccbf27937e238e4dcb3fc32b880c2a - md5: 95715a60c993dd0a9e732be74c5e46f2 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/llvmlite-0.47.0-py314hc7e35b3_1.conda + sha256: 54dbf3a5acc8eb4d0902345145bdf0a658a3ac118ab3d10424c899fb899cda46 + md5: c555bb3e65064bf7807d0419eb0ae120 + depends: + - __osx >=11.0 + - libcxx >=19 + - libzlib >=1.3.2,<2.0a0 + - python >=3.14,<3.15.0a0 + - python >=3.14,<3.15.0a0 *_cp314 + - python_abi 3.14.* *_cp314 + - zstd >=1.5.7,<1.6.0a0 + license: BSD-2-Clause + license_family: BSD + purls: + - pkg:pypi/llvmlite?source=hash-mapping + size: 24327499 + timestamp: 1776077303342 +- conda: https://conda.anaconda.org/conda-forge/win-64/llvmlite-0.42.0-py311h5bc0dda_1.conda + sha256: cd8b0fa4d488cb0fd995dbba71915a0a35fb248c857c632013efc3008d956039 + md5: b35d44a8c735e61ebe05769f06ae8d12 depends: - libzlib >=1.2.13,<2.0.0a0 - - python >=3.10,<3.11.0a0 - - python_abi 3.10.* *_cp310 + - python >=3.11,<3.12.0a0 + - python_abi 3.11.* *_cp311 - ucrt >=10.0.20348.0 - vc >=14.2,<15 - vc14_runtime >=14.29.30139 @@ -7543,8 +10875,8 @@ packages: license_family: BSD purls: - pkg:pypi/llvmlite?source=hash-mapping - size: 17039935 - timestamp: 1706922362200 + size: 17139776 + timestamp: 1706922311632 - conda: https://conda.anaconda.org/conda-forge/win-64/llvmlite-0.46.0-py314hb492ee6_0.conda sha256: 8f8bb4cd5a93aaf576e6861846f09dcff8f37032b02704e830d9afd3e6676d6b md5: de5f7e2de23118d72f43c99fe7f2a942 @@ -7562,6 +10894,45 @@ packages: - pkg:pypi/llvmlite?source=hash-mapping size: 22926897 timestamp: 1765280131964 +- conda: https://conda.anaconda.org/conda-forge/win-64/llvmlite-0.47.0-py314hb492ee6_1.conda + sha256: 9caf2c3ec4b747554421bbe0adb5e5dbfec45463638b7e3407d1ba02167bf472 + md5: ad66bb59a59cfa219311bf5072c1a087 + depends: + - libzlib >=1.3.2,<2.0a0 + - python >=3.14,<3.15.0a0 + - python_abi 3.14.* *_cp314 + - ucrt >=10.0.20348.0 + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + - zstd >=1.5.7,<1.6.0a0 + license: BSD-2-Clause + license_family: BSD + purls: + - pkg:pypi/llvmlite?source=hash-mapping + size: 22909282 + timestamp: 1776076971549 +- conda: https://conda.anaconda.org/conda-forge/win-64/llvmlite-0.47.0-py314hf48658c_1.conda + sha256: 5c7e98ba6f5d82ed90fe926e8cce32f1077675b2800b0e1677fa18b33c72e40a + md5: 2291156c23bda834956557c88a76e7fc + depends: + - libzlib >=1.3.2,<2.0a0 + - python >=3.14,<3.15.0a0 + - python_abi 3.14.* *_cp314t + - ucrt >=10.0.20348.0 + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + - zstd >=1.5.7,<1.6.0a0 + license: BSD-2-Clause + license_family: BSD + purls: + - pkg:pypi/llvmlite?source=hash-mapping + size: 22915183 + timestamp: 1776076967030 +- pypi: https://files.pythonhosted.org/packages/db/bc/83e112abc66cd466c6b83f99118035867cecd41802f8d044638aa78a106e/locket-1.0.0-py2.py3-none-any.whl + name: locket + version: 1.0.0 + sha256: b6c819a722f7b6bd955b80781788e4a66a55628b858d347536b7e81325a3a5e3 + requires_python: '>=2.7,!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*' - conda: https://conda.anaconda.org/conda-forge/linux-64/matplotlib-3.10.8-py314hdafbbf9_0.conda sha256: 0c9417291ada8df3415ad13d52db38707adaba42584246264294e0faaaa54f77 md5: 8286e3966eac286d5ac7c7a4afbac812 @@ -7576,6 +10947,21 @@ packages: purls: [] size: 17473 timestamp: 1763055464987 +- conda: https://conda.anaconda.org/conda-forge/linux-64/matplotlib-3.11.0-py314hdafbbf9_1.conda + sha256: bd375b8d5999ebd47d3eecd3ca7d0cb6b13156b83181bb99c9704b758114058d + md5: 23f8baa07d5e4f97b86cde417babf32b + depends: + - matplotlib-base >=3.11.0,<3.11.1.0a0 + - pyside6 >=6.7.2 + - python >=3.14,<3.15.0a0 + - python_abi 3.14.* *_cp314 + - tornado >=5 + license: PSF-2.0 + license_family: PSF + purls: + - pkg:pypi/matplotlib?source=compressed-mapping + size: 14828 + timestamp: 1782829552189 - conda: https://conda.anaconda.org/conda-forge/osx-64/matplotlib-3.10.8-py313habf4b1d_0.conda sha256: cea48c750f812eaf7c8b1edaff9d4b30bdad99f28f4421f1ab49e24c74db360d md5: 37dffad2937d7c8b7fc47003ddd31eac @@ -7589,6 +10975,19 @@ packages: purls: [] size: 17433 timestamp: 1763055798218 +- conda: https://conda.anaconda.org/conda-forge/osx-64/matplotlib-3.11.0-py314hee6578b_1.conda + sha256: a9786beb9206b889d1cfd412be47f2e4e379bed4110cf4565a107abab74b94f4 + md5: 8d625c2863ffd4cf58b4722036a9b71f + depends: + - matplotlib-base >=3.11.0,<3.11.1.0a0 + - python >=3.14,<3.15.0a0 + - python_abi 3.14.* *_cp314 + - tornado >=5 + license: PSF-2.0 + license_family: PSF + purls: [] + size: 14868 + timestamp: 1782830016954 - conda: https://conda.anaconda.org/conda-forge/osx-arm64/matplotlib-3.10.8-py314he55896b_0.conda sha256: 070b99e48cd6dda06086116626203c100e6f34af771b34384848ce5abeaf683e md5: ad9a3f773f13989b92b41c0eabed5a38 @@ -7602,6 +11001,19 @@ packages: purls: [] size: 17538 timestamp: 1763055987021 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/matplotlib-3.11.0-py314he55896b_1.conda + sha256: 5bf2ba8c93eacbd59f9174b70fb649d697b7ee8bcffeb6b32b65de4e766454bb + md5: 11593c3fa1f88016c3ef29f677d0f0e6 + depends: + - matplotlib-base >=3.11.0,<3.11.1.0a0 + - python >=3.14,<3.15.0a0 + - python_abi 3.14.* *_cp314 + - tornado >=5 + license: PSF-2.0 + license_family: PSF + purls: [] + size: 14817 + timestamp: 1782829699763 - conda: https://conda.anaconda.org/conda-forge/win-64/matplotlib-3.10.8-py314h86ab7b2_0.conda sha256: e7b6349b12f7d98ab7b595e01e486d3544083c694e8ee2c45a0b8f17016a7a0a md5: e786fc5fefad7779cb2d954dd214fa37 @@ -7613,12 +11025,56 @@ packages: - tornado >=5 license: PSF-2.0 license_family: PSF - purls: [] - size: 18016 - timestamp: 1763056036732 -- conda: https://conda.anaconda.org/conda-forge/linux-64/matplotlib-base-3.10.8-py314h1194b4b_0.conda - sha256: ee773261fbd6c76fc8174b0e4e1ce272b0bbaa56610f130e9d3d1f575106f04f - md5: b8683e6068099b69c10dbfcf7204203f + purls: [] + size: 18016 + timestamp: 1763056036732 +- conda: https://conda.anaconda.org/conda-forge/win-64/matplotlib-3.11.0-py314h86ab7b2_1.conda + sha256: 280067b6b6dd6cef3125c517933ce4bd442a957fffa3ae0ca518379ba04c0fb6 + md5: 3aef2aea79e121dde8f8432ad8180a77 + depends: + - matplotlib-base >=3.11.0,<3.11.1.0a0 + - pyside6 >=6.7.2 + - python >=3.14,<3.15.0a0 + - python_abi 3.14.* *_cp314 + - tornado >=5 + license: PSF-2.0 + license_family: PSF + purls: [] + size: 15319 + timestamp: 1782829747462 +- conda: https://conda.anaconda.org/conda-forge/linux-64/matplotlib-base-3.10.8-py314h1194b4b_0.conda + sha256: ee773261fbd6c76fc8174b0e4e1ce272b0bbaa56610f130e9d3d1f575106f04f + md5: b8683e6068099b69c10dbfcf7204203f + depends: + - __glibc >=2.17,<3.0.a0 + - contourpy >=1.0.1 + - cycler >=0.10 + - fonttools >=4.22.0 + - freetype + - kiwisolver >=1.3.1 + - libfreetype >=2.14.1 + - libfreetype6 >=2.14.1 + - libgcc >=14 + - libstdcxx >=14 + - numpy >=1.23 + - numpy >=1.23,<3 + - packaging >=20.0 + - pillow >=8 + - pyparsing >=2.3.1 + - python >=3.14,<3.15.0a0 + - python-dateutil >=2.7 + - python_abi 3.14.* *_cp314 + - qhull >=2020.2,<2020.3.0a0 + - tk >=8.6.13,<8.7.0a0 + license: PSF-2.0 + license_family: PSF + purls: + - pkg:pypi/matplotlib?source=hash-mapping + size: 8473358 + timestamp: 1763055439346 +- conda: https://conda.anaconda.org/conda-forge/linux-64/matplotlib-base-3.11.0-py314had63eae_1.conda + sha256: 666a19f61a40c5936bd0f07965b159ced727256fa7e2a4ff9dd5f0146aad86f1 + md5: 5866f3034ce42e8d512e7640f43270fd depends: - __glibc >=2.17,<3.0.a0 - contourpy >=1.0.1 @@ -7626,12 +11082,13 @@ packages: - fonttools >=4.22.0 - freetype - kiwisolver >=1.3.1 - - libfreetype >=2.14.1 - - libfreetype6 >=2.14.1 + - libfreetype >=2.14.3 + - libfreetype6 >=2.14.3 - libgcc >=14 + - libraqm >=0.10.5,<0.11.0a0 - libstdcxx >=14 - numpy >=1.23 - - numpy >=1.23,<3 + - numpy >=1.25,<3 - packaging >=20.0 - pillow >=8 - pyparsing >=2.3.1 @@ -7643,9 +11100,9 @@ packages: license: PSF-2.0 license_family: PSF purls: - - pkg:pypi/matplotlib?source=hash-mapping - size: 8473358 - timestamp: 1763055439346 + - pkg:pypi/matplotlib?source=compressed-mapping + size: 9004007 + timestamp: 1782829533688 - conda: https://conda.anaconda.org/conda-forge/osx-64/matplotlib-base-3.10.8-py313h4ad75b8_0.conda sha256: d25d81b6022b6d012ea13f3feb41792e3b7de058e73bce05066a72acd0ce77ef md5: 5a0ed440de10c49cfed0178d3e59d994 @@ -7674,6 +11131,35 @@ packages: - pkg:pypi/matplotlib?source=hash-mapping size: 8305842 timestamp: 1763055757075 +- conda: https://conda.anaconda.org/conda-forge/osx-64/matplotlib-base-3.11.0-py314h75ce844_1.conda + sha256: cceb91421cc0238e7070c8aeee2c9d14f443bf55ee1524eca9730ee97e44a461 + md5: e62b6de805945c4ef994d7f745d5772b + depends: + - __osx >=11.0 + - contourpy >=1.0.1 + - cycler >=0.10 + - fonttools >=4.22.0 + - freetype + - kiwisolver >=1.3.1 + - libcxx >=19 + - libfreetype >=2.14.3 + - libfreetype6 >=2.14.3 + - libraqm >=0.10.5,<0.11.0a0 + - numpy >=1.23 + - numpy >=1.25,<3 + - packaging >=20.0 + - pillow >=8 + - pyparsing >=2.3.1 + - python >=3.14,<3.15.0a0 + - python-dateutil >=2.7 + - python_abi 3.14.* *_cp314 + - qhull >=2020.2,<2020.3.0a0 + license: PSF-2.0 + license_family: PSF + purls: + - pkg:pypi/matplotlib?source=compressed-mapping + size: 8988367 + timestamp: 1782829965885 - conda: https://conda.anaconda.org/conda-forge/osx-arm64/matplotlib-base-3.10.8-py314hd63e3f0_0.conda sha256: 198dcc0ed83e78bc7bf48e6ef8d4ecd220e9cf1f07db98508251b2bc0be067f9 md5: c84152e510d41378b8758826655b6ed7 @@ -7703,6 +11189,35 @@ packages: - pkg:pypi/matplotlib?source=hash-mapping size: 8286510 timestamp: 1763055937766 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/matplotlib-base-3.11.0-py314hf6804ef_1.conda + sha256: a55f1d61cb9265187477a90dd9d3b4a82a1d559d291846af5f4719815822fff4 + md5: 839648f58bc9c220a496ad342adc34d9 + depends: + - __osx >=11.0 + - contourpy >=1.0.1 + - cycler >=0.10 + - fonttools >=4.22.0 + - freetype + - kiwisolver >=1.3.1 + - libcxx >=19 + - libfreetype >=2.14.3 + - libfreetype6 >=2.14.3 + - libraqm >=0.10.5,<0.11.0a0 + - numpy >=1.23 + - numpy >=1.25,<3 + - packaging >=20.0 + - pillow >=8 + - pyparsing >=2.3.1 + - python >=3.14,<3.15.0a0 + - python-dateutil >=2.7 + - python_abi 3.14.* *_cp314 + - qhull >=2020.2,<2020.3.0a0 + license: PSF-2.0 + license_family: PSF + purls: + - pkg:pypi/matplotlib?source=compressed-mapping + size: 8826632 + timestamp: 1782829663874 - conda: https://conda.anaconda.org/conda-forge/win-64/matplotlib-base-3.10.8-py314hfa45d96_0.conda sha256: 82a50284275e8a1818cd3323846f3032dc89bd23a3f80dcf44e34a62b016256b md5: 9d491a60700e0e90e92607fcc4e2566c @@ -7732,6 +11247,36 @@ packages: - pkg:pypi/matplotlib?source=hash-mapping size: 8185296 timestamp: 1763055983613 +- conda: https://conda.anaconda.org/conda-forge/win-64/matplotlib-base-3.11.0-py314hd0c49b1_1.conda + sha256: 94bc6fb3f0dc6337ca3b5dcb3d65da3ede1f24ce14d1e597ed83585bffe59dfc + md5: 99da493a14f3e26e8069e12281ce504f + depends: + - contourpy >=1.0.1 + - cycler >=0.10 + - fonttools >=4.22.0 + - freetype + - kiwisolver >=1.3.1 + - libfreetype >=2.14.3 + - libfreetype6 >=2.14.3 + - libraqm >=0.10.5,<0.11.0a0 + - numpy >=1.23 + - numpy >=1.25,<3 + - packaging >=20.0 + - pillow >=8 + - pyparsing >=2.3.1 + - python >=3.14,<3.15.0a0 + - python-dateutil >=2.7 + - python_abi 3.14.* *_cp314 + - qhull >=2020.2,<2020.3.0a0 + - ucrt >=10.0.20348.0 + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + license: PSF-2.0 + license_family: PSF + purls: + - pkg:pypi/matplotlib?source=compressed-mapping + size: 8747069 + timestamp: 1782829728451 - conda: https://conda.anaconda.org/conda-forge/noarch/matplotlib-inline-0.1.7-pyhd8ed1ab_1.conda sha256: 69b7dc7131703d3d60da9b0faa6dd8acbf6f6c396224cf6aef3e855b8c0c41c6 md5: af6ab708897df59bd6e7283ceab1b56b @@ -7744,6 +11289,51 @@ packages: - pkg:pypi/matplotlib-inline?source=hash-mapping size: 14467 timestamp: 1733417051523 +- conda: https://conda.anaconda.org/conda-forge/noarch/matplotlib-inline-0.2.2-pyhd8ed1ab_0.conda + sha256: 35b43d7343f74452307fd018a1cca92b8f68961ff8e2ab6a81ce0a703c9a3764 + md5: 9acc1c385be401d533ff70ef5b50dae6 + depends: + - python >=3.10 + - traitlets + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/matplotlib-inline?source=compressed-mapping + size: 15725 + timestamp: 1778264403247 +- pypi: https://files.pythonhosted.org/packages/89/c3/6b05cc23afc9c466634ba815bfddf529677f8c7e03f5814ccd387dac0ade/metpy-1.7.1-py3-none-any.whl + name: metpy + version: 1.7.1 + sha256: b184a1786a730f7926ec5fa58618cd0935a21f8088a13b268dd7267f9e104efc + requires_dist: + - matplotlib>=3.5.0 + - numpy>=1.23.0 + - pandas>=1.4.0 + - pint>=0.17 + - pooch>=1.2.0 + - pyproj>=3.3.0 + - scipy>=1.8.0 + - traitlets>=5.1.0 + - xarray>=2022.6.0 + - metpy[examples] ; extra == 'doc' + - myst-parser ; extra == 'doc' + - netcdf4 ; extra == 'doc' + - sphinx ; extra == 'doc' + - sphinx-gallery>=0.4 ; extra == 'doc' + - sphinx-design ; extra == 'doc' + - pydata-sphinx-theme ; extra == 'doc' + - geopandas>=0.6.0 ; extra == 'examples' + - metpy[extras] ; extra == 'examples' + - netcdf4 ; extra == 'test' + - packaging>=21.0 ; extra == 'test' + - pytest>=7.0 ; extra == 'test' + - pytest-mpl ; extra == 'test' + - vcrpy>=4.3.1 ; extra == 'test' + - cartopy>=0.21.0 ; extra == 'extras' + - dask>=2020.12.0 ; extra == 'extras' + - shapely>=1.6.4 ; extra == 'extras' + - boto3>=1.26.45 ; extra == 'extras' + requires_python: '>=3.10' - conda: https://conda.anaconda.org/conda-forge/linux-64/mkl-2024.2.2-ha957f24_16.conda sha256: 77906b0acead8f86b489da46f53916e624897338770dbf70b04b8f673c9273c1 md5: 1459379c79dda834673426504d52b319 @@ -7809,6 +11399,116 @@ packages: - pkg:pypi/munkres?source=hash-mapping size: 15851 timestamp: 1749895533014 +- conda: https://conda.anaconda.org/conda-forge/linux-64/mypy-2.2.0-py314h9e9664a_0.conda + sha256: a2059e9cc877695504736a94b4ac634d9c095486f7b266e8597025cb56cec5b6 + md5: 9a633e68f0473a272138bdf928320e6d + depends: + - ast-serialize >=0.6.0,<1.0.0 + - mypy_extensions >=1.0.0 + - pathspec >=1.0.0 + - python + - python-librt >=0.12.0 + - typing_extensions >=4.6.0 + - psutil >=4.0 + - libgcc >=14 + - __glibc >=2.17,<3.0.a0 + - python_abi 3.14.* *_cp314t + license: MIT + license_family: MIT + purls: [] + size: 26199870 + timestamp: 1783529106832 +- conda: https://conda.anaconda.org/conda-forge/osx-64/mypy-2.2.0-py314hd9f0251_0.conda + sha256: 6122188b7a78a180ab7eb1cd659de146465cb080f0f2dfde64da2149fd2e4676 + md5: 8396154b512a579db0e73da1d2d1169e + depends: + - ast-serialize >=0.6.0,<1.0.0 + - mypy_extensions >=1.0.0 + - pathspec >=1.0.0 + - python + - python-librt >=0.12.0 + - typing_extensions >=4.6.0 + - psutil >=4.0 + - __osx >=11.0 + - python_abi 3.14.* *_cp314t + license: MIT + license_family: MIT + purls: [] + size: 15696714 + timestamp: 1783529398678 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/mypy-2.2.0-py314h2fbedac_0.conda + sha256: f751aa73f329e330429827863c60fe7e99262f23d0ea5483c20e96f224fc51a3 + md5: 8159fa5faa15cf0c770dd08394474e4d + depends: + - ast-serialize >=0.6.0,<1.0.0 + - mypy_extensions >=1.0.0 + - pathspec >=1.0.0 + - python + - python-librt >=0.12.0 + - typing_extensions >=4.6.0 + - psutil >=4.0 + - __osx >=11.0 + - python_abi 3.14.* *_cp314 + license: MIT + license_family: MIT + purls: + - pkg:pypi/mypy?source=hash-mapping + size: 13627485 + timestamp: 1783529137799 +- conda: https://conda.anaconda.org/conda-forge/win-64/mypy-2.2.0-py314h72baafe_0.conda + sha256: 92fb496c7e5f6570f17922ec7b233c526e25481fb43f2cf2f4843db71435c0f0 + md5: d1a2ae57514a16f29db34f3dd7278cdf + depends: + - ast-serialize >=0.6.0,<1.0.0 + - mypy_extensions >=1.0.0 + - pathspec >=1.0.0 + - python + - python-librt >=0.12.0 + - typing_extensions >=4.6.0 + - psutil >=4.0 + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + - ucrt >=10.0.20348.0 + - python_abi 3.14.* *_cp314t + license: MIT + license_family: MIT + purls: + - pkg:pypi/mypy?source=hash-mapping + size: 12209501 + timestamp: 1783529288410 +- conda: https://conda.anaconda.org/conda-forge/noarch/mypy_extensions-1.1.0-pyha770c72_0.conda + sha256: 6ed158e4e5dd8f6a10ad9e525631e35cee8557718f83de7a4e3966b1f772c4b1 + md5: e9c622e0d00fa24a6292279af3ab6d06 + depends: + - python >=3.9 + license: MIT + license_family: MIT + purls: + - pkg:pypi/mypy-extensions?source=hash-mapping + size: 11766 + timestamp: 1745776666688 +- pypi: https://files.pythonhosted.org/packages/f4/4e/afc8c31605cb8be1d3bb4438c4d979daa104dab6306cd2b87abe9c3a7299/narwhals-2.23.0-py3-none-any.whl + name: narwhals + version: 2.23.0 + sha256: 769e7b9ab102c93d8fa019f6b4cd1a657909b04a20bf6210e5a35aae06814ae9 + requires_dist: + - cudf-cu12>=24.10.0 ; sys_platform == 'linux' and extra == 'cudf' + - dask[dataframe]>=2024.8 ; extra == 'dask' + - duckdb>=1.1 ; extra == 'duckdb' + - ibis-framework>=6.0.0 ; extra == 'ibis' + - rich>=12.4.4 ; extra == 'ibis' + - packaging>=21.3 ; extra == 'ibis' + - pyarrow-hotfix>=0.7 ; extra == 'ibis' + - modin>=0.22.0 ; extra == 'modin' + - pandas>=1.3.4 ; extra == 'pandas' + - polars>=0.20.4 ; extra == 'polars' + - pyarrow>=13.0.0 ; extra == 'pyarrow' + - pyspark>=3.5.0 ; extra == 'pyspark' + - pyspark[connect]>=3.5.0 ; extra == 'pyspark-connect' + - narwhals[duckdb] ; extra == 'sql' + - sqlparse>=0.5.5 ; extra == 'sql' + - sqlframe>=3.22.0,!=3.39.3 ; extra == 'sqlframe' + requires_python: '>=3.10' - conda: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.5-h2d0b736_3.conda sha256: 3fde293232fa3fca98635e1167de6b7c7fda83caf24b9d6c91ec9eefb4f4d586 md5: 47e340acb35de30501a76c7c799c41d7 @@ -7876,31 +11576,121 @@ packages: - pkg:pypi/nest-asyncio?source=hash-mapping size: 11543 timestamp: 1733325673691 -- conda: https://conda.anaconda.org/conda-forge/linux-64/numba-0.59.1-py310h7dc5dd1_0.conda - sha256: d2c631345a40f0ffbe18d312ef665e1ae1a4942ecff46334df2de49b8277bf81 - md5: b757b5ecfa1cad38328fa73e236b6563 +- conda: https://conda.anaconda.org/conda-forge/noarch/nest-asyncio2-1.7.2-pyhcf101f3_0.conda + sha256: e6768ceef038f4d7e083de7e393f5dd7d672b937e2bda570b740f6399b686689 + md5: fcd832bfd4749e9b246112b6894f97fc + depends: + - python >=3.10 + - python + license: BSD-2-Clause + license_family: BSD + purls: + - pkg:pypi/nest-asyncio2?source=hash-mapping + size: 15903 + timestamp: 1770973502283 +- pypi: https://files.pythonhosted.org/packages/18/68/e89b4fa9242e59326c849c39ce0f49eb68499603c639405a8449900a4f15/netcdf4-1.7.4-cp311-abi3-win_amd64.whl + name: netcdf4 + version: 1.7.4 + sha256: 9476e1f23161ae5159cd1548c50c8a37922e77d76583e247133f256ef7b825fc + requires_dist: + - cftime + - certifi + - numpy>=2.3.0 ; platform_machine == 'ARM64' and sys_platform == 'win32' + - numpy>=1.21.2 ; platform_machine != 'ARM64' or sys_platform != 'win32' + - cython ; extra == 'tests' + - packaging ; extra == 'tests' + - pytest ; extra == 'tests' + - typing-extensions>=4.15.0 ; extra == 'tests' + - mpi4py ; extra == 'parallel' + requires_python: '>=3.10' +- pypi: https://files.pythonhosted.org/packages/34/b6/0370bb3af66a12098da06dc5843f3b349b7c83ccbdf7306e7afa6248b533/netcdf4-1.7.4.tar.gz + name: netcdf4 + version: 1.7.4 + sha256: cdbfdc92d6f4d7192ca8506c9b3d4c1d9892969ff28d8e8e1fc97ca08bf12164 + requires_dist: + - cftime + - certifi + - numpy>=2.3.0 ; platform_machine == 'ARM64' and sys_platform == 'win32' + - numpy>=1.21.2 ; platform_machine != 'ARM64' or sys_platform != 'win32' + - cython ; extra == 'tests' + - packaging ; extra == 'tests' + - pytest ; extra == 'tests' + - typing-extensions>=4.15.0 ; extra == 'tests' + - mpi4py ; extra == 'parallel' + requires_python: '>=3.10' +- pypi: https://files.pythonhosted.org/packages/37/dc/44d21524cf1b1c64254f92e22395a7a10f70c18f3a13a18ac9db258760f7/netcdf4-1.7.4-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl + name: netcdf4 + version: 1.7.4 + sha256: 86fac03a8c5b250d57866e7d98918a64742e4b0de1681c5c86bac5726bab8aee + requires_dist: + - cftime + - certifi + - numpy>=2.3.0 ; platform_machine == 'ARM64' and sys_platform == 'win32' + - numpy>=1.21.2 ; platform_machine != 'ARM64' or sys_platform != 'win32' + - cython ; extra == 'tests' + - packaging ; extra == 'tests' + - pytest ; extra == 'tests' + - typing-extensions>=4.15.0 ; extra == 'tests' + - mpi4py ; extra == 'parallel' + requires_python: '>=3.10' +- pypi: https://files.pythonhosted.org/packages/38/de/38ed7e1956943d28e8ea74161e97c3a00fb98d6d08943b4fd21bae32c240/netcdf4-1.7.4-cp311-abi3-macosx_13_0_x86_64.whl + name: netcdf4 + version: 1.7.4 + sha256: dec70e809cc65b04ebe95113ee9c85ba46a51c3a37c058d2b2b0cadc4d3052d8 + requires_dist: + - cftime + - certifi + - numpy>=2.3.0 ; platform_machine == 'ARM64' and sys_platform == 'win32' + - numpy>=1.21.2 ; platform_machine != 'ARM64' or sys_platform != 'win32' + - cython ; extra == 'tests' + - packaging ; extra == 'tests' + - pytest ; extra == 'tests' + - typing-extensions>=4.15.0 ; extra == 'tests' + - mpi4py ; extra == 'parallel' + requires_python: '>=3.10' +- pypi: https://files.pythonhosted.org/packages/03/36/98ddbcf3e4f04a6dd07e1c67249955920579ba4af6bb6868e3088f4ed282/numba-0.65.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl + name: numba + version: 0.65.1 + sha256: 78abc28feff2c2ff8307fff3975b6438352759c9acb797ecd6b1fb6e7e39e31d + requires_dist: + - llvmlite>=0.47.0.dev0,<0.48 + - numpy>=1.22 + - numpy>=1.22,<2.5 + requires_python: '>=3.10' +- pypi: https://files.pythonhosted.org/packages/f6/c5/db2ac3685833d626c0dcae6bd2330cd68433e1fd248d15f70998160d3ad7/numba-0.65.1.tar.gz + name: numba + version: 0.65.1 + sha256: 19357146c32fe9ed25059ab915e8465fb13951cf6b0aace3826b76886373ab23 + requires_dist: + - llvmlite>=0.47.0.dev0,<0.48 + - numpy>=1.22 + - numpy>=1.22,<2.5 + requires_python: '>=3.10' +- conda: https://conda.anaconda.org/conda-forge/linux-64/numba-0.59.1-py311h96b013e_0.conda + sha256: d04a4ae9207492a7e40135eef2a0c79da2d6ed53baf4b72a0ff533dd5fd838a9 + md5: cd581f19ea0c298ec6ef612fdf7d041c depends: - _openmp_mutex >=4.5 - libgcc-ng >=12 - libstdcxx-ng >=12 - llvmlite >=0.42.0,<0.43.0a0 - - numpy >=1.22.4,<2.0a0 - - python >=3.10,<3.11.0a0 - - python_abi 3.10.* *_cp310 + - numpy >=1.23.5,<2.0a0 + - python >=3.11,<3.12.0a0 + - python_abi 3.11.* *_cp311 constrains: + - tbb >=2021.6.0 - cudatoolkit >=11.2 - - cuda-python >=11.6 - cuda-version >=11.2 - - numpy >=1.22.3,<1.27 - - libopenblas !=0.3.6 + - cuda-python >=11.6 - scipy >=1.0 - - tbb >=2021.6.0 + - libopenblas !=0.3.6 + - numpy >=1.22.3,<1.27 license: BSD-2-Clause license_family: BSD purls: - pkg:pypi/numba?source=hash-mapping - size: 4313101 - timestamp: 1711475336305 + size: 5727056 + timestamp: 1711475359733 - conda: https://conda.anaconda.org/conda-forge/linux-64/numba-0.63.1-py314h8169c2f_0.conda sha256: 6ab91790aeee336cc4526b02b477eb0f261df6bd9645f44a138b1e8a3ccc5e60 md5: 9dfbe6bd11b1c77f618b347ec654b37b @@ -7927,31 +11717,82 @@ packages: - pkg:pypi/numba?source=hash-mapping size: 5797268 timestamp: 1765466862046 -- conda: https://conda.anaconda.org/conda-forge/osx-64/numba-0.59.1-py310h1d5af72_0.conda - sha256: a209aa01362bc96eda9cfd013400518fbf348845cd8a76235e4919f63336ec88 - md5: 48c2d28c10aa78b8db76f0eee9c08626 +- conda: https://conda.anaconda.org/conda-forge/linux-64/numba-0.65.1-py314h8169c2f_1.conda + sha256: 750f8893a16721394969c030e7778212b99c54aab137a9744cafdb70a6fd513d + md5: d74691e038386bb543a574122c72d834 + depends: + - __glibc >=2.17,<3.0.a0 + - _openmp_mutex >=4.5 + - libgcc >=14 + - libstdcxx >=14 + - llvmlite >=0.47.0,<0.48.0a0 + - numpy >=1.22.3,<2.5 + - numpy >=1.23,<3 + - python >=3.14,<3.15.0a0 + - python_abi 3.14.* *_cp314 + constrains: + - scipy >=1.0 + - tbb >=2021.6.0 + - cudatoolkit >=11.2 + - libopenblas !=0.3.6 + - cuda-python >=11.6 + - cuda-version >=11.2 + license: BSD-2-Clause + license_family: BSD + purls: + - pkg:pypi/numba?source=hash-mapping + size: 5793221 + timestamp: 1778390483212 +- conda: https://conda.anaconda.org/conda-forge/linux-64/numba-0.65.1-py314hf734fe3_1.conda + sha256: 6417bc216467e87647efcf83e15ec6abdc0d2b0f02405834314ed0e6643dba07 + md5: e0286b20ee43f0fd9ebcc21a2fa4d350 + depends: + - __glibc >=2.17,<3.0.a0 + - _openmp_mutex >=4.5 + - libgcc >=14 + - libstdcxx >=14 + - llvmlite >=0.47.0,<0.48.0a0 + - numpy >=1.22.3,<2.5 + - numpy >=1.23,<3 + - python >=3.14,<3.15.0a0 + - python_abi 3.14.* *_cp314t + constrains: + - cuda-version >=11.2 + - cuda-python >=11.6 + - tbb >=2021.6.0 + - cudatoolkit >=11.2 + - libopenblas !=0.3.6 + - scipy >=1.0 + license: BSD-2-Clause + license_family: BSD + purls: [] + size: 5818333 + timestamp: 1778390486523 +- conda: https://conda.anaconda.org/conda-forge/osx-64/numba-0.59.1-py311h97119f7_0.conda + sha256: 39c5d0402fe93521fd4593dddead61be6307590177aab6eb14a19c8aff8072e3 + md5: a7d40eca79cb5ee19a95f041627da7cc depends: - libcxx >=16 - llvm-openmp >=16.0.6 - llvm-openmp >=18.1.2 - llvmlite >=0.42.0,<0.43.0a0 - - numpy >=1.22.4,<2.0a0 - - python >=3.10,<3.11.0a0 - - python_abi 3.10.* *_cp310 + - numpy >=1.23.5,<2.0a0 + - python >=3.11,<3.12.0a0 + - python_abi 3.11.* *_cp311 constrains: - - tbb >=2021.6.0 + - cuda-version >=11.2 + - scipy >=1.0 + - numpy >=1.22.3,<1.27 - libopenblas !=0.3.6 - cudatoolkit >=11.2 - - scipy >=1.0 - - cuda-version >=11.2 - cuda-python >=11.6 - - numpy >=1.22.3,<1.27 + - tbb >=2021.6.0 license: BSD-2-Clause license_family: BSD purls: - pkg:pypi/numba?source=hash-mapping - size: 4306388 - timestamp: 1711475580226 + size: 5694560 + timestamp: 1711475607780 - conda: https://conda.anaconda.org/conda-forge/osx-64/numba-0.61.0-py313h7d106be_1.conda sha256: af6134f6cffbf9997e1274ffabf6bcd59fa21f5a1661765f0b083560cdce58dc md5: dadca85b8ee715fab749829acc3203a4 @@ -7978,32 +11819,81 @@ packages: - pkg:pypi/numba?source=hash-mapping size: 5864957 timestamp: 1739224943288 -- conda: https://conda.anaconda.org/conda-forge/osx-arm64/numba-0.59.1-py310hdf1f89a_0.conda - sha256: 40ebaa41d0aa057f6ffeb58742fde256e13e410d8a7a18941d951b2f90ba7ea8 - md5: 8664b3ab76986782e3a8ad26f4af8fdd +- conda: https://conda.anaconda.org/conda-forge/osx-64/numba-0.65.1-py314h34b395f_1.conda + sha256: 6ddfd37869aaca05a1154a55a88c64e509b1bee2272e609d6caccae42cce070b + md5: af9134924a0f620b0e80cf339b8abaed + depends: + - __osx >=11.0 + - libcxx >=19 + - llvm-openmp >=19.1.7 + - llvmlite >=0.47.0,<0.48.0a0 + - numpy >=1.22.3,<2.5 + - numpy >=1.23,<3 + - python >=3.14,<3.15.0a0 + - python_abi 3.14.* *_cp314 + constrains: + - cudatoolkit >=11.2 + - scipy >=1.0 + - cuda-version >=11.2 + - tbb >=2021.6.0 + - cuda-python >=11.6 + - libopenblas !=0.3.6 + license: BSD-2-Clause + license_family: BSD + purls: + - pkg:pypi/numba?source=hash-mapping + size: 5788064 + timestamp: 1778390801185 +- conda: https://conda.anaconda.org/conda-forge/osx-64/numba-0.65.1-py314ha90515b_1.conda + sha256: 56b018afdce94413c885b47c28a5f650f17fc6085479992a06ad0dbdfbd0646b + md5: 56e1c5449063298dd6216353754d7cc1 + depends: + - __osx >=11.0 + - libcxx >=19 + - llvm-openmp >=19.1.7 + - llvmlite >=0.47.0,<0.48.0a0 + - numpy >=1.22.3,<2.5 + - numpy >=1.23,<3 + - python >=3.14,<3.15.0a0 + - python_abi 3.14.* *_cp314t + constrains: + - cudatoolkit >=11.2 + - cuda-version >=11.2 + - scipy >=1.0 + - cuda-python >=11.6 + - libopenblas !=0.3.6 + - tbb >=2021.6.0 + license: BSD-2-Clause + license_family: BSD + purls: [] + size: 5813291 + timestamp: 1778390953956 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/numba-0.59.1-py311h00351ea_0.conda + sha256: 08fb0c631d4398db7ad6aca6028cf61ea1b7729b37fbfc39156bd8041e721ea6 + md5: 19ab43dae40c315f94f73127edc1ecec depends: - libcxx >=16 - llvm-openmp >=16.0.6 - llvm-openmp >=18.1.2 - llvmlite >=0.42.0,<0.43.0a0 - - numpy >=1.22.4,<2.0a0 - - python >=3.10,<3.11.0a0 - - python >=3.10,<3.11.0a0 *_cpython - - python_abi 3.10.* *_cp310 + - numpy >=1.23.5,<2.0a0 + - python >=3.11,<3.12.0a0 + - python >=3.11,<3.12.0a0 *_cpython + - python_abi 3.11.* *_cp311 constrains: - - tbb >=2021.6.0 + - cudatoolkit >=11.2 - scipy >=1.0 - cuda-python >=11.6 + - tbb >=2021.6.0 - cuda-version >=11.2 - - numpy >=1.22.3,<1.27 - libopenblas >=0.3.18, !=0.3.20 - - cudatoolkit >=11.2 + - numpy >=1.22.3,<1.27 license: BSD-2-Clause license_family: BSD purls: - pkg:pypi/numba?source=hash-mapping - size: 4292616 - timestamp: 1711475805806 + size: 5714812 + timestamp: 1711475878723 - conda: https://conda.anaconda.org/conda-forge/osx-arm64/numba-0.63.1-py314h945de62_0.conda sha256: 4e6acf20fafec2b390e73c54bb348f71ef2fd0092e179e370fdf4ad4c2862baa md5: 4f9128c2986d86725aa0dd5a5dfff168 @@ -8011,51 +11901,77 @@ packages: - __osx >=11.0 - libcxx >=19 - llvm-openmp >=19.1.7 - - llvm-openmp >=21.1.7 - - llvmlite >=0.46.0,<0.47.0a0 - - numpy >=1.22.3,<2.4 + - llvm-openmp >=21.1.7 + - llvmlite >=0.46.0,<0.47.0a0 + - numpy >=1.22.3,<2.4 + - numpy >=1.23,<3 + - python >=3.14,<3.15.0a0 + - python >=3.14,<3.15.0a0 *_cp314 + - python_abi 3.14.* *_cp314 + constrains: + - scipy >=1.0 + - libopenblas >=0.3.18,!=0.3.20 + - cudatoolkit >=11.2 + - cuda-version >=11.2 + - cuda-python >=11.6 + - tbb >=2021.6.0 + license: BSD-2-Clause + license_family: BSD + purls: + - pkg:pypi/numba?source=hash-mapping + size: 5780959 + timestamp: 1765466926700 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/numba-0.65.1-py314hb38061f_1.conda + sha256: 86ab4c3273761dec812c198fcb658c3b8f86b39bb0a3b409a62baff9f19db927 + md5: 606140802769e37d32f5e83a485e5a4b + depends: + - __osx >=11.0 + - libcxx >=19 + - llvm-openmp >=19.1.7 + - llvmlite >=0.47.0,<0.48.0a0 + - numpy >=1.22.3,<2.5 - numpy >=1.23,<3 - python >=3.14,<3.15.0a0 - python >=3.14,<3.15.0a0 *_cp314 - python_abi 3.14.* *_cp314 constrains: - - scipy >=1.0 - - libopenblas >=0.3.18,!=0.3.20 - cudatoolkit >=11.2 + - libopenblas >=0.3.18,!=0.3.20 + - tbb >=2021.6.0 - cuda-version >=11.2 - cuda-python >=11.6 - - tbb >=2021.6.0 + - scipy >=1.0 license: BSD-2-Clause license_family: BSD purls: - pkg:pypi/numba?source=hash-mapping - size: 5780959 - timestamp: 1765466926700 -- conda: https://conda.anaconda.org/conda-forge/win-64/numba-0.59.1-py310h9ccaf4f_0.conda - sha256: fa83e95a18ab1011fb628f536609c86304cc6578035592de7078f78491e7b334 - md5: 62a19ec9b0e89bf270c6bf163cf21bb4 + size: 5766480 + timestamp: 1778390893034 +- conda: https://conda.anaconda.org/conda-forge/win-64/numba-0.59.1-py311h2c0921f_0.conda + sha256: 444faaee93e210d2a24853b8fdb646afa57ee72378f1156bf3d9f0e67be0087b + md5: 37f04eaa0e229a07b03f219f10be11ef depends: - llvmlite >=0.42.0,<0.43.0a0 - - numpy >=1.22.4,<2.0a0 - - python >=3.10,<3.11.0a0 - - python_abi 3.10.* *_cp310 + - numpy >=1.23.5,<2.0a0 + - python >=3.11,<3.12.0a0 + - python_abi 3.11.* *_cp311 - ucrt >=10.0.20348.0 - vc >=14.2,<15 - vc14_runtime >=14.29.30139 constrains: - libopenblas !=0.3.6 - - numpy >=1.22.3,<1.27 + - scipy >=1.0 - cuda-version >=11.2 + - numpy >=1.22.3,<1.27 - tbb >=2021.6.0 - cudatoolkit >=11.2 - - scipy >=1.0 - cuda-python >=11.6 license: BSD-2-Clause license_family: BSD purls: - pkg:pypi/numba?source=hash-mapping - size: 4293611 - timestamp: 1711475788866 + size: 5740925 + timestamp: 1711475788949 - conda: https://conda.anaconda.org/conda-forge/win-64/numba-0.63.1-py314h36f8cf2_0.conda sha256: 1bbfc2793e04aaac5d289e6e5bec8b020b4419c4af1e161ab409c6995d1cc89d md5: a77827229f4dfdbae9d503707d41a277 @@ -8081,25 +11997,85 @@ packages: - pkg:pypi/numba?source=hash-mapping size: 5775759 timestamp: 1765466860567 -- conda: https://conda.anaconda.org/conda-forge/linux-64/numpy-1.26.4-py310hb13e2d6_0.conda - sha256: 028fe2ea8e915a0a032b75165f11747770326f3d767e642880540c60a3256425 - md5: 6593de64c935768b6bad3e19b3e978be +- conda: https://conda.anaconda.org/conda-forge/win-64/numba-0.65.1-py314h01db6d0_1.conda + sha256: 0cc1bc61b2859f81577933c551f9128755137d8804d9ba6b17b6a627c4014cb0 + md5: 73b63809cc2e3cb6588c097603c67dc8 + depends: + - llvmlite >=0.47.0,<0.48.0a0 + - numpy >=1.22.3,<2.5 + - numpy >=1.23,<3 + - python >=3.14,<3.15.0a0 + - python_abi 3.14.* *_cp314t + - ucrt >=10.0.20348.0 + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + constrains: + - cuda-version >=11.2 + - tbb >=2021.6.0 + - scipy >=1.0 + - cudatoolkit >=11.2 + - libopenblas !=0.3.6 + - cuda-python >=11.6 + license: BSD-2-Clause + license_family: BSD + purls: + - pkg:pypi/numba?source=hash-mapping + size: 5794902 + timestamp: 1778390612795 +- conda: https://conda.anaconda.org/conda-forge/win-64/numba-0.65.1-py314h36f8cf2_1.conda + sha256: 3998df5608bb2309ac7857bfb6b2f2d804f2f10d5e62173db0aada1660346705 + md5: b7a863d5eaa15a4fb5970165f413f411 + depends: + - llvmlite >=0.47.0,<0.48.0a0 + - numpy >=1.22.3,<2.5 + - numpy >=1.23,<3 + - python >=3.14,<3.15.0a0 + - python_abi 3.14.* *_cp314 + - ucrt >=10.0.20348.0 + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + constrains: + - cudatoolkit >=11.2 + - libopenblas !=0.3.6 + - cuda-python >=11.6 + - scipy >=1.0 + - cuda-version >=11.2 + - tbb >=2021.6.0 + license: BSD-2-Clause + license_family: BSD + purls: + - pkg:pypi/numba?source=hash-mapping + size: 5787391 + timestamp: 1778390612597 +- pypi: 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 + name: numpy + version: 2.4.6 + sha256: 7d92c3819208a60205a12a245c91ad70cb0a85336659b19b834205573ac8456e + requires_python: '>=3.11' +- pypi: https://files.pythonhosted.org/packages/d0/ad/fed0499ce6a338d2a03ebae59cd15093910c8875328855781952abf6c2fe/numpy-2.4.6.tar.gz + name: numpy + version: 2.4.6 + sha256: f3a3570c4a2a16746ac2c31a7c7c7b0c186b95ce902e33db6f28094ed7387dda + requires_python: '>=3.11' +- conda: https://conda.anaconda.org/conda-forge/linux-64/numpy-1.26.4-py311h64a7726_0.conda + sha256: 3f4365e11b28e244c95ba8579942b0802761ba7bb31c026f50d1a9ea9c728149 + md5: a502d7aad449a1206efb366d6a12c52d depends: - libblas >=3.9.0,<4.0a0 - libcblas >=3.9.0,<4.0a0 - libgcc-ng >=12 - liblapack >=3.9.0,<4.0a0 - libstdcxx-ng >=12 - - python >=3.10,<3.11.0a0 - - python_abi 3.10.* *_cp310 + - python >=3.11,<3.12.0a0 + - python_abi 3.11.* *_cp311 constrains: - numpy-base <0a0 license: BSD-3-Clause license_family: BSD purls: - pkg:pypi/numpy?source=hash-mapping - size: 7009070 - timestamp: 1707225917496 + size: 8065890 + timestamp: 1707225944355 - conda: https://conda.anaconda.org/conda-forge/linux-64/numpy-2.3.5-py314h2b28147_1.conda sha256: 81425306df4f0ddba159e80c8d91323a34df335079ca93a194201e57b337231c md5: ab17cb5f388fa17c08937cb9cc24e7b6 @@ -8120,24 +12096,63 @@ packages: - pkg:pypi/numpy?source=hash-mapping size: 8983076 timestamp: 1766383421113 -- conda: https://conda.anaconda.org/conda-forge/osx-64/numpy-1.26.4-py310h4bfa8fc_0.conda - sha256: 914476e2d3273fdf9c0419a7bdcb7b31a5ec25949e4afbc847297ff3a50c62c8 - md5: cd6a2298387f558c9ea70ee73a189791 +- conda: https://conda.anaconda.org/conda-forge/linux-64/numpy-2.4.6-py314h2b28147_0.conda + sha256: bc61ae892973751a6b0e6ecea57ed6d7053224bddcb007165d6ceb1d7344ad47 + md5: f49b5f950379e0b97c35ca97682f7c6a + depends: + - python + - libstdcxx >=14 + - libgcc >=14 + - __glibc >=2.17,<3.0.a0 + - liblapack >=3.9.0,<4.0a0 + - python_abi 3.14.* *_cp314 + - libblas >=3.9.0,<4.0a0 + - libcblas >=3.9.0,<4.0a0 + constrains: + - numpy-base <0a0 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/numpy?source=hash-mapping + size: 8928909 + timestamp: 1779169198391 +- conda: https://conda.anaconda.org/conda-forge/linux-64/numpy-2.4.6-py314hd4f4903_0.conda + sha256: 3d78afff730eddaf4e2981d0e3f4cee9106c72366da52136648c6c9c463c9555 + md5: 642b9fc455d2a90572f767487bd6352d + depends: + - python + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - libstdcxx >=14 + - libblas >=3.9.0,<4.0a0 + - libcblas >=3.9.0,<4.0a0 + - liblapack >=3.9.0,<4.0a0 + - python_abi 3.14.* *_cp314t + constrains: + - numpy-base <0a0 + license: BSD-3-Clause + license_family: BSD + purls: [] + size: 8978806 + timestamp: 1779169197952 +- conda: https://conda.anaconda.org/conda-forge/osx-64/numpy-1.26.4-py311hc43a94b_0.conda + sha256: dc9628197125ee1d02b2e7a859a769d26291d747ed79337309b8a9e67a8b8e00 + md5: bb02b8801d17265160e466cf8bbf28da depends: - libblas >=3.9.0,<4.0a0 - libcblas >=3.9.0,<4.0a0 - libcxx >=16 - liblapack >=3.9.0,<4.0a0 - - python >=3.10,<3.11.0a0 - - python_abi 3.10.* *_cp310 + - python >=3.11,<3.12.0a0 + - python_abi 3.11.* *_cp311 constrains: - numpy-base <0a0 license: BSD-3-Clause license_family: BSD purls: - pkg:pypi/numpy?source=hash-mapping - size: 6491938 - timestamp: 1707226191321 + size: 7504319 + timestamp: 1707226235372 - conda: https://conda.anaconda.org/conda-forge/osx-64/numpy-2.1.3-py313h7ca3f3b_0.conda sha256: fe86adfc262259f1b156301d45d49d81801b1dec732e5b1dbc647cafe4659475 md5: b827b0af2098c63435b27b7f4e4d50dd @@ -8157,25 +12172,62 @@ packages: - pkg:pypi/numpy?source=hash-mapping size: 7638660 timestamp: 1730588470617 -- conda: https://conda.anaconda.org/conda-forge/osx-arm64/numpy-1.26.4-py310hd45542a_0.conda - sha256: e3078108a4973e73c813b89228f4bd8095ec58f96ca29f55d2e45a6223a9a1db - md5: 267ee89a3a0b8c8fa838a2353f9ea0c0 +- conda: https://conda.anaconda.org/conda-forge/osx-64/numpy-2.4.6-py314h5af6b61_0.conda + sha256: 22cb0b3b59184d6b1f9da460b602792de9d13426dd07112908a6dad48060b224 + md5: 5da2fc2fdfe8312e324c089fc0437ac2 + depends: + - python + - __osx >=11.0 + - libcxx >=19 + - libblas >=3.9.0,<4.0a0 + - libcblas >=3.9.0,<4.0a0 + - liblapack >=3.9.0,<4.0a0 + - python_abi 3.14.* *_cp314t + constrains: + - numpy-base <0a0 + license: BSD-3-Clause + license_family: BSD + purls: [] + size: 8224189 + timestamp: 1779169282330 +- conda: https://conda.anaconda.org/conda-forge/osx-64/numpy-2.4.6-py314h7b24d9b_0.conda + sha256: 8127ecc9ffbb291830cd6849a8e4f8d9027b130672d277c9444b1d36949f0a38 + md5: e04ed878a4f06bb20201dabf7a25f9ee + depends: + - python + - libcxx >=19 + - __osx >=11.0 + - libblas >=3.9.0,<4.0a0 + - python_abi 3.14.* *_cp314 + - liblapack >=3.9.0,<4.0a0 + - libcblas >=3.9.0,<4.0a0 + constrains: + - numpy-base <0a0 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/numpy?source=hash-mapping + size: 8155498 + timestamp: 1779169315894 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/numpy-1.26.4-py311h7125741_0.conda + sha256: 160a52a01fea44fe9753a2ed22cf13d7b55c8a89ea0b8738546fdbf4795d6514 + md5: 3160b93669a0def35a7a8158ebb33816 depends: - libblas >=3.9.0,<4.0a0 - libcblas >=3.9.0,<4.0a0 - libcxx >=16 - liblapack >=3.9.0,<4.0a0 - - python >=3.10,<3.11.0a0 - - python >=3.10,<3.11.0a0 *_cpython - - python_abi 3.10.* *_cp310 + - python >=3.11,<3.12.0a0 + - python >=3.11,<3.12.0a0 *_cpython + - python_abi 3.11.* *_cp311 constrains: - numpy-base <0a0 license: BSD-3-Clause license_family: BSD purls: - pkg:pypi/numpy?source=hash-mapping - size: 5475744 - timestamp: 1707226187124 + size: 6652352 + timestamp: 1707226297967 - conda: https://conda.anaconda.org/conda-forge/osx-arm64/numpy-2.3.5-py314hae46ccb_1.conda sha256: bc9dfe41ba4898365a82c485416fd4a572f86d94e606d89379766de70d34fc79 md5: d421394cf6758a6f27ead1530cfdfa6a @@ -8196,15 +12248,34 @@ packages: - pkg:pypi/numpy?source=hash-mapping size: 6861028 timestamp: 1766383292611 -- conda: https://conda.anaconda.org/conda-forge/win-64/numpy-1.26.4-py310hf667824_0.conda - sha256: 20ca447a8f840c01961f2bdf0847fc7b7785a62968e867d7aa4ca8a66d70f9ad - md5: 93e881c391880df90e74e43a4b67c16d +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/numpy-2.4.6-py314hb79c6fa_0.conda + sha256: 538064b78042cd2751664f00c6255ecce81b38e9fa6dd9c1863327e6c759ed4a + md5: e64e47cb372d92e3425816a2918f4605 + depends: + - python + - __osx >=11.0 + - libcxx >=19 + - libblas >=3.9.0,<4.0a0 + - python_abi 3.14.* *_cp314 + - liblapack >=3.9.0,<4.0a0 + - libcblas >=3.9.0,<4.0a0 + constrains: + - numpy-base <0a0 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/numpy?source=hash-mapping + size: 6995531 + timestamp: 1779169217034 +- conda: https://conda.anaconda.org/conda-forge/win-64/numpy-1.26.4-py311h0b4df5a_0.conda + sha256: 14116e72107de3089cc58119a5ce5905c22abf9a715c9fe41f8ac14db0992326 + md5: 7b240edd44fd7a0991aa409b07cee776 depends: - libblas >=3.9.0,<4.0a0 - libcblas >=3.9.0,<4.0a0 - liblapack >=3.9.0,<4.0a0 - - python >=3.10,<3.11.0a0 - - python_abi 3.10.* *_cp310 + - python >=3.11,<3.12.0a0 + - python_abi 3.11.* *_cp311 - ucrt >=10.0.20348.0 - vc >=14.2,<15 - vc14_runtime >=14.29.30139 @@ -8214,8 +12285,8 @@ packages: license_family: BSD purls: - pkg:pypi/numpy?source=hash-mapping - size: 5977469 - timestamp: 1707226445438 + size: 7104093 + timestamp: 1707226459646 - conda: https://conda.anaconda.org/conda-forge/win-64/numpy-2.3.5-py314h06c3c77_1.conda sha256: 111a7af69521dce54ce6b4d89ef767ade9f3769576353a526174792de8702b5d md5: 71dabea9914329c08b4864955c3793fc @@ -8236,6 +12307,46 @@ packages: - pkg:pypi/numpy?source=compressed-mapping size: 7584934 timestamp: 1766383321713 +- conda: https://conda.anaconda.org/conda-forge/win-64/numpy-2.4.6-py314h02f10f6_0.conda + sha256: de0eee21d902fb45a58454e3739e04ede7d02bf7575ca0ae9f959f20fa15c76b + md5: df95e6c7325bbae2571e5cef5f9c8096 + depends: + - python + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + - ucrt >=10.0.20348.0 + - libcblas >=3.9.0,<4.0a0 + - liblapack >=3.9.0,<4.0a0 + - libblas >=3.9.0,<4.0a0 + - python_abi 3.14.* *_cp314 + constrains: + - numpy-base <0a0 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/numpy?source=hash-mapping + size: 7318163 + timestamp: 1779169232086 +- conda: https://conda.anaconda.org/conda-forge/win-64/numpy-2.4.6-py314hffb9209_0.conda + sha256: 1a5b5e4bfecbc5de8cbf2ae04a2a31f45ceeac454be96eb931abc9a78a06b24c + md5: 42e4fcaa6afcb0d68a9b73c3eff251da + depends: + - python + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + - ucrt >=10.0.20348.0 + - python_abi 3.14.* *_cp314t + - liblapack >=3.9.0,<4.0a0 + - libblas >=3.9.0,<4.0a0 + - libcblas >=3.9.0,<4.0a0 + constrains: + - numpy-base <0a0 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/numpy?source=hash-mapping + size: 7482657 + timestamp: 1779169231603 - conda: https://conda.anaconda.org/conda-forge/win-64/onemkl-license-2026.1.0-h57928b3_233.conda sha256: 96dec1c878d6e6f835be8ed57152a37be9a5104ac79c2425815d71c64cf13ee4 md5: 1566e2ce8c3bc23a2feb866c4d9e91e3 @@ -8273,6 +12384,20 @@ packages: purls: [] size: 336370 timestamp: 1754297904811 +- conda: https://conda.anaconda.org/conda-forge/osx-64/openjpeg-2.5.4-h52bb76a_0.conda + sha256: 9a37ecf9c086f3a50d0132e6087dcbe7ea978d80e2da267fa3199c486529b311 + md5: 46e628da6e796c948fa8ec9d6d10bda3 + depends: + - __osx >=11.0 + - libcxx >=19 + - libpng >=1.6.55,<1.7.0a0 + - libtiff >=4.7.1,<4.8.0a0 + - libzlib >=1.3.1,<2.0a0 + license: BSD-2-Clause + license_family: BSD + purls: [] + size: 335227 + timestamp: 1772625294157 - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openjpeg-2.5.4-hbfb3c88_0.conda sha256: dd73e8f1da7dd6a5494c5586b835cbe2ec68bace55610b1c4bf927400fe9c0d7 md5: 6bf3d24692c157a41c01ce0bd17daeea @@ -8287,6 +12412,35 @@ packages: purls: [] size: 319967 timestamp: 1758489514651 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/openjpeg-2.5.4-hd9e9057_0.conda + sha256: 60aca8b9f94d06b852b296c276b3cf0efba5a6eb9f25feb8708570d3a74f00e4 + md5: 4b5d3a91320976eec71678fad1e3569b + depends: + - __osx >=11.0 + - libcxx >=19 + - libpng >=1.6.55,<1.7.0a0 + - libtiff >=4.7.1,<4.8.0a0 + - libzlib >=1.3.1,<2.0a0 + license: BSD-2-Clause + license_family: BSD + purls: [] + size: 319697 + timestamp: 1772625397692 +- conda: https://conda.anaconda.org/conda-forge/win-64/openjpeg-2.5.4-h0e57b4f_0.conda + sha256: 24342dee891a49a9ba92e2018ec0bde56cc07fdaec95275f7a55b96f03ea4252 + md5: e723ab7cc2794c954e1b22fde51c16e4 + depends: + - libpng >=1.6.55,<1.7.0a0 + - libtiff >=4.7.1,<4.8.0a0 + - libzlib >=1.3.1,<2.0a0 + - ucrt >=10.0.20348.0 + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + license: BSD-2-Clause + license_family: BSD + purls: [] + size: 245594 + timestamp: 1772624841727 - conda: https://conda.anaconda.org/conda-forge/win-64/openjpeg-2.5.4-h24db6dd_0.conda sha256: 226c270a7e3644448954c47959c00a9bf7845f6d600c2a643db187118d028eee md5: 5af852046226bb3cb15c7f61c2ac020a @@ -8317,6 +12471,21 @@ packages: purls: [] size: 780253 timestamp: 1748010165522 +- conda: https://conda.anaconda.org/conda-forge/linux-64/openldap-2.6.13-hbde042b_0.conda + sha256: 21c4f6c7f41dc9bec2ea2f9c80440d9a4d45a6f2ac13243e658f10dcf1044146 + md5: 680608784722880fbfe1745067570b00 + depends: + - __glibc >=2.17,<3.0.a0 + - cyrus-sasl >=2.1.28,<3.0a0 + - krb5 >=1.22.2,<1.23.0a0 + - libgcc >=14 + - libstdcxx >=14 + - openssl >=3.5.6,<4.0a0 + license: OLDAP-2.8 + license_family: BSD + purls: [] + size: 786149 + timestamp: 1775741359582 - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.6.0-h26f9b46_0.conda sha256: a47271202f4518a484956968335b2521409c8173e123ab381e775c358c67fe6d md5: 9ee58d5c534af06558933af3c845a780 @@ -8434,58 +12603,58 @@ packages: - pkg:pypi/packaging?source=hash-mapping size: 91574 timestamp: 1777103621679 -- conda: https://conda.anaconda.org/conda-forge/linux-64/pandas-2.3.3-py310h0158d43_2.conda - sha256: b9e88fa02fd5e99f54c168df622eda9ddf898cc15e631179963aca51d97244bf - md5: 0610ed073acc4737d036125a5a6dbae2 +- conda: https://conda.anaconda.org/conda-forge/linux-64/pandas-2.3.3-py311hed34c8f_2.conda + sha256: a2af9dbc4827db418a73127d4001bb3c2ee19adcd2d4387d6bc049c3780d2a62 + md5: 2366b5470cf61614c131e356efe9f74c depends: - __glibc >=2.17,<3.0.a0 - libgcc >=14 - libstdcxx >=14 - - numpy >=1.21,<3 - numpy >=1.22.4 - - python >=3.10,<3.11.0a0 + - numpy >=1.23,<3 + - python >=3.11,<3.12.0a0 - python-dateutil >=2.8.2 - python-tzdata >=2022.7 - - python_abi 3.10.* *_cp310 + - python_abi 3.11.* *_cp311 - pytz >=2020.1 constrains: - - odfpy >=1.4.1 - - pyarrow >=10.0.1 - - pyqt5 >=5.15.9 - - numexpr >=2.8.4 + - matplotlib >=3.6.3 - fsspec >=2022.11.0 - - bottleneck >=1.3.6 - - beautifulsoup4 >=4.11.2 + - zstandard >=0.19.0 + - xarray >=2022.12.0 + - lxml >=4.9.2 + - pyqt5 >=5.15.9 + - sqlalchemy >=2.0.0 - pandas-gbq >=0.19.0 - - s3fs >=2022.11.0 + - psycopg2 >=2.9.6 + - odfpy >=1.4.1 - gcsfs >=2022.11.0 - - sqlalchemy >=2.0.0 - - pytables >=3.8.0 - - html5lib >=1.1 - - python-calamine >=0.1.7 - - lxml >=4.9.2 + - pyxlsb >=1.0.10 - qtpy >=2.3.0 - - scipy >=1.10.0 - - numba >=0.56.4 - openpyxl >=3.1.0 + - fastparquet >=2022.12.0 + - beautifulsoup4 >=4.11.2 + - html5lib >=1.1 + - pytables >=3.8.0 + - tabulate >=0.9.0 + - pyarrow >=10.0.1 - blosc >=1.21.3 - pyreadstat >=1.2.0 - - zstandard >=0.19.0 - - xarray >=2022.12.0 - - matplotlib >=3.6.3 - - tabulate >=0.9.0 - - fastparquet >=2022.12.0 - - psycopg2 >=2.9.6 - - xlsxwriter >=3.0.5 - xlrd >=2.0.1 + - numexpr >=2.8.4 + - bottleneck >=1.3.6 + - scipy >=1.10.0 - tzdata >=2022.7 - - pyxlsb >=1.0.10 + - s3fs >=2022.11.0 + - python-calamine >=0.1.7 + - xlsxwriter >=3.0.5 + - numba >=0.56.4 license: BSD-3-Clause license_family: BSD purls: - pkg:pypi/pandas?source=hash-mapping - size: 12391209 - timestamp: 1764615007370 + size: 15180047 + timestamp: 1764615050121 - conda: https://conda.anaconda.org/conda-forge/linux-64/pandas-2.3.3-py314ha0b5721_2.conda sha256: 0a86a582b906d9cfd4d2c59180898fe9d714b55eea7ced71630a1fedae206c62 md5: fe3a5c8be07a7b82058bdeb39d33d93b @@ -8518,26 +12687,83 @@ packages: - python-calamine >=0.1.7 - sqlalchemy >=2.0.0 - pyqt5 >=5.15.9 - - bottleneck >=1.3.6 - - zstandard >=0.19.0 - - numexpr >=2.8.4 - - tzdata >=2022.7 - - scipy >=1.10.0 - - gcsfs >=2022.11.0 + - bottleneck >=1.3.6 + - zstandard >=0.19.0 + - numexpr >=2.8.4 + - tzdata >=2022.7 + - scipy >=1.10.0 + - gcsfs >=2022.11.0 + - pyxlsb >=1.0.10 + - matplotlib >=3.6.3 + - pytables >=3.8.0 + - beautifulsoup4 >=4.11.2 + - pyreadstat >=1.2.0 + - fastparquet >=2022.12.0 + - xlrd >=2.0.1 + - xarray >=2022.12.0 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/pandas?source=hash-mapping + size: 15178918 + timestamp: 1764615084415 +- conda: https://conda.anaconda.org/conda-forge/linux-64/pandas-3.0.3-py314hb4ffadd_0.conda + sha256: 8e4b161f3f7fbdf17f842b518ff3794b6af9378a90d095719d7153360d126dc1 + md5: bc2e1390314b1269e66fb1966fbcae5d + depends: + - python + - numpy >=1.26.0 + - python-dateutil >=2.8.2 + - libstdcxx >=14 + - libgcc >=14 + - __glibc >=2.17,<3.0.a0 + - numpy >=1.23,<3 + - python_abi 3.14.* *_cp314 + constrains: + - adbc-driver-postgresql >=1.2.0 + - adbc-driver-sqlite >=1.2.0 + - beautifulsoup4 >=4.12.3 + - blosc >=1.21.3 + - bottleneck >=1.4.2 + - fastparquet >=2024.11.0 + - fsspec >=2024.10.0 + - gcsfs >=2024.10.0 + - html5lib >=1.1 + - hypothesis >=6.116.0 + - jinja2 >=3.1.5 + - lxml >=5.3.0 + - matplotlib >=3.9.3 + - numba >=0.60.0 + - numexpr >=2.10.2 + - odfpy >=1.4.1 + - openpyxl >=3.1.5 + - psycopg2 >=2.9.10 + - pyarrow >=13.0.0 + - pyiceberg >=0.8.1 + - pymysql >=1.1.1 + - pyqt5 >=5.15.9 + - pyreadstat >=1.2.8 + - pytables >=3.10.1 + - pytest >=8.3.4 + - pytest-xdist >=3.6.1 + - python-calamine >=0.3.0 + - pytz >=2024.2 - pyxlsb >=1.0.10 - - matplotlib >=3.6.3 - - pytables >=3.8.0 - - beautifulsoup4 >=4.11.2 - - pyreadstat >=1.2.0 - - fastparquet >=2022.12.0 + - qtpy >=2.4.2 + - scipy >=1.14.1 + - s3fs >=2024.10.0 + - sqlalchemy >=2.0.36 + - tabulate >=0.9.0 + - xarray >=2024.10.0 - xlrd >=2.0.1 - - xarray >=2022.12.0 + - xlsxwriter >=3.2.0 + - zstandard >=0.23.0 license: BSD-3-Clause license_family: BSD purls: - - pkg:pypi/pandas?source=hash-mapping - size: 15178918 - timestamp: 1764615084415 + - pkg:pypi/pandas?source=compressed-mapping + size: 15303815 + timestamp: 1778602611222 - conda: https://conda.anaconda.org/conda-forge/osx-64/pandas-2.2.3-py313h38cdd20_1.conda sha256: baf98a0c2a15a3169b7c0443c04b37b489575477f5cf443146f283e1259de01f md5: ab61fb255c951a0514616e92dd2e18b2 @@ -8557,109 +12783,165 @@ packages: - pkg:pypi/pandas?source=hash-mapping size: 14632093 timestamp: 1726878912764 -- conda: https://conda.anaconda.org/conda-forge/osx-64/pandas-2.3.3-py310h39ce848_1.conda - sha256: 17fca5beb36d65f437c211618b3efafcb0138b5869d163e53aad5195e2fadd6c - md5: a5aac9e71de785129f7bf4616ad54ffb +- conda: https://conda.anaconda.org/conda-forge/osx-64/pandas-2.3.3-py311hca9a5ca_2.conda + sha256: f0dd9bca13b82972ce260941437a1e2efc1b71766b44cc73ac8b878f7d352e9c + md5: bd00254b6a77b575177c78f64c5fb366 depends: - __osx >=10.13 - libcxx >=19 - - numpy >=1.21,<3 - numpy >=1.22.4 - - python >=3.10,<3.11.0a0 + - numpy >=1.23,<3 + - python >=3.11,<3.12.0a0 - python-dateutil >=2.8.2 - python-tzdata >=2022.7 - - python_abi 3.10.* *_cp310 + - python_abi 3.11.* *_cp311 - pytz >=2020.1 constrains: - - pyreadstat >=1.2.0 - - tzdata >=2022.7 - - tabulate >=0.9.0 - matplotlib >=3.6.3 - - odfpy >=1.4.1 - - beautifulsoup4 >=4.11.2 + - zstandard >=0.19.0 + - tabulate >=0.9.0 + - pyarrow >=10.0.1 + - fastparquet >=2022.12.0 - openpyxl >=3.1.0 - - xarray >=2022.12.0 - - blosc >=1.21.3 - - numba >=0.56.4 - html5lib >=1.1 + - pyqt5 >=5.15.9 + - odfpy >=1.4.1 - xlrd >=2.0.1 + - numexpr >=2.8.4 + - xlsxwriter >=3.0.5 + - fsspec >=2022.11.0 + - xarray >=2022.12.0 + - pandas-gbq >=0.19.0 - lxml >=4.9.2 - qtpy >=2.3.0 + - tzdata >=2022.7 + - blosc >=1.21.3 + - beautifulsoup4 >=4.11.2 + - pyxlsb >=1.0.10 + - pytables >=3.8.0 + - pyreadstat >=1.2.0 - scipy >=1.10.0 - - pyqt5 >=5.15.9 - gcsfs >=2022.11.0 - - s3fs >=2022.11.0 - - fastparquet >=2022.12.0 - - fsspec >=2022.11.0 - - pytables >=3.8.0 - - zstandard >=0.19.0 - - pandas-gbq >=0.19.0 - bottleneck >=1.3.6 - - sqlalchemy >=2.0.0 + - s3fs >=2022.11.0 + - python-calamine >=0.1.7 - psycopg2 >=2.9.6 - - xlsxwriter >=3.0.5 + - sqlalchemy >=2.0.0 + - numba >=0.56.4 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/pandas?source=hash-mapping + size: 14375008 + timestamp: 1764615325020 +- conda: https://conda.anaconda.org/conda-forge/osx-64/pandas-3.0.3-py314h99bb933_0.conda + sha256: 99b33ca5a648e9cddc08cba4e425b66cb00dbba992f44f795794ed10cbb95f8f + md5: b8c2b629ee4792726d4c10c136457ad1 + depends: + - python + - numpy >=1.26.0 + - python-dateutil >=2.8.2 + - __osx >=11.0 + - libcxx >=19 + - numpy >=1.23,<3 + - python_abi 3.14.* *_cp314 + constrains: + - adbc-driver-postgresql >=1.2.0 + - adbc-driver-sqlite >=1.2.0 + - beautifulsoup4 >=4.12.3 + - blosc >=1.21.3 + - bottleneck >=1.4.2 + - fastparquet >=2024.11.0 + - fsspec >=2024.10.0 + - gcsfs >=2024.10.0 + - html5lib >=1.1 + - hypothesis >=6.116.0 + - jinja2 >=3.1.5 + - lxml >=5.3.0 + - matplotlib >=3.9.3 + - numba >=0.60.0 + - numexpr >=2.10.2 + - odfpy >=1.4.1 + - openpyxl >=3.1.5 + - psycopg2 >=2.9.10 + - pyarrow >=13.0.0 + - pyiceberg >=0.8.1 + - pymysql >=1.1.1 + - pyqt5 >=5.15.9 + - pyreadstat >=1.2.8 + - pytables >=3.10.1 + - pytest >=8.3.4 + - pytest-xdist >=3.6.1 + - python-calamine >=0.3.0 + - pytz >=2024.2 - pyxlsb >=1.0.10 - - numexpr >=2.8.4 - - pyarrow >=10.0.1 - - python-calamine >=0.1.7 + - qtpy >=2.4.2 + - scipy >=1.14.1 + - s3fs >=2024.10.0 + - sqlalchemy >=2.0.36 + - tabulate >=0.9.0 + - xarray >=2024.10.0 + - xlrd >=2.0.1 + - xlsxwriter >=3.2.0 + - zstandard >=0.23.0 license: BSD-3-Clause license_family: BSD purls: - pkg:pypi/pandas?source=hash-mapping - size: 11773386 - timestamp: 1759266667139 -- conda: https://conda.anaconda.org/conda-forge/osx-arm64/pandas-2.3.3-py310h25f4b65_1.conda - sha256: 231f393393c76a483aec78d2c24c48cb97c3dd8328382ba529e8c4c0e7c81922 - md5: 6aa7000c6851bdfbb9a3fe7319f5b5e2 + size: 14597208 + timestamp: 1778602856255 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/pandas-2.3.3-py311hdb8e4fa_2.conda + sha256: dd0c4ade846921acbf6ded79b7589e72f58689129dabc8290deec455539e9235 + md5: da2e5c7c0a3061398c8a1e225f2e339e depends: - __osx >=11.0 - libcxx >=19 - - numpy >=1.21,<3 - numpy >=1.22.4 - - python >=3.10,<3.11.0a0 - - python >=3.10,<3.11.0a0 *_cpython + - numpy >=1.23,<3 + - python >=3.11,<3.12.0a0 + - python >=3.11,<3.12.0a0 *_cpython - python-dateutil >=2.8.2 - python-tzdata >=2022.7 - - python_abi 3.10.* *_cp310 + - python_abi 3.11.* *_cp311 - pytz >=2020.1 constrains: - - pytables >=3.8.0 - - openpyxl >=3.1.0 + - sqlalchemy >=2.0.0 + - xarray >=2022.12.0 - bottleneck >=1.3.6 - - zstandard >=0.19.0 - - pyxlsb >=1.0.10 + - tzdata >=2022.7 + - pyarrow >=10.0.1 + - lxml >=4.9.2 + - tabulate >=0.9.0 - matplotlib >=3.6.3 - - sqlalchemy >=2.0.0 - - beautifulsoup4 >=4.11.2 + - qtpy >=2.3.0 + - pytables >=3.8.0 - odfpy >=1.4.1 - - python-calamine >=0.1.7 - html5lib >=1.1 + - openpyxl >=3.1.0 + - psycopg2 >=2.9.6 + - numba >=0.56.4 + - s3fs >=2022.11.0 + - fastparquet >=2022.12.0 + - gcsfs >=2022.11.0 + - python-calamine >=0.1.7 - fsspec >=2022.11.0 - - blosc >=1.21.3 - - pyqt5 >=5.15.9 - - qtpy >=2.3.0 + - pandas-gbq >=0.19.0 + - beautifulsoup4 >=4.11.2 + - xlsxwriter >=3.0.5 - numexpr >=2.8.4 + - pyxlsb >=1.0.10 - pyreadstat >=1.2.0 - - scipy >=1.10.0 - - pandas-gbq >=0.19.0 - - lxml >=4.9.2 - - pyarrow >=10.0.1 - - s3fs >=2022.11.0 - xlrd >=2.0.1 - - numba >=0.56.4 - - xlsxwriter >=3.0.5 - - tabulate >=0.9.0 - - xarray >=2022.12.0 - - psycopg2 >=2.9.6 - - fastparquet >=2022.12.0 - - tzdata >=2022.7 - - gcsfs >=2022.11.0 + - blosc >=1.21.3 + - zstandard >=0.19.0 + - pyqt5 >=5.15.9 + - scipy >=1.10.0 license: BSD-3-Clause license_family: BSD purls: - pkg:pypi/pandas?source=hash-mapping - size: 11619840 - timestamp: 1759266892769 + size: 14124254 + timestamp: 1764615503256 - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pandas-2.3.3-py314ha3d490a_2.conda sha256: f71fc63904d80ef7bf4e882b420426e167e02cf68b9bd71ea6beb0a9d0c37430 md5: 6e2f31aca92c525a884c509738aca93a @@ -8712,58 +12994,115 @@ packages: - pkg:pypi/pandas?source=hash-mapping size: 14130201 timestamp: 1764615862386 -- conda: https://conda.anaconda.org/conda-forge/win-64/pandas-2.3.3-py310hed136d8_2.conda - sha256: 9880f0d721e2ce487cfa0ceeb564b5db080fd3da958ea2d2ad1fb24e8d4de005 - md5: fcec00cec231a3217c53341f74846c26 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/pandas-3.0.3-py314he609de1_0.conda + sha256: 90d84a2a6e7e9826f28f71ff34c7daacd0819c96eb3951f1ab59ef460a75fb58 + md5: 703276fc0e3693ff6a7566f1ac6865ab + depends: + - python + - numpy >=1.26.0 + - python-dateutil >=2.8.2 + - libcxx >=19 + - python 3.14.* *_cp314 + - __osx >=11.0 + - python_abi 3.14.* *_cp314 + - numpy >=1.23,<3 + constrains: + - adbc-driver-postgresql >=1.2.0 + - adbc-driver-sqlite >=1.2.0 + - beautifulsoup4 >=4.12.3 + - blosc >=1.21.3 + - bottleneck >=1.4.2 + - fastparquet >=2024.11.0 + - fsspec >=2024.10.0 + - gcsfs >=2024.10.0 + - html5lib >=1.1 + - hypothesis >=6.116.0 + - jinja2 >=3.1.5 + - lxml >=5.3.0 + - matplotlib >=3.9.3 + - numba >=0.60.0 + - numexpr >=2.10.2 + - odfpy >=1.4.1 + - openpyxl >=3.1.5 + - psycopg2 >=2.9.10 + - pyarrow >=13.0.0 + - pyiceberg >=0.8.1 + - pymysql >=1.1.1 + - pyqt5 >=5.15.9 + - pyreadstat >=1.2.8 + - pytables >=3.10.1 + - pytest >=8.3.4 + - pytest-xdist >=3.6.1 + - python-calamine >=0.3.0 + - pytz >=2024.2 + - pyxlsb >=1.0.10 + - qtpy >=2.4.2 + - scipy >=1.14.1 + - s3fs >=2024.10.0 + - sqlalchemy >=2.0.36 + - tabulate >=0.9.0 + - xarray >=2024.10.0 + - xlrd >=2.0.1 + - xlsxwriter >=3.2.0 + - zstandard >=0.23.0 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/pandas?source=compressed-mapping + size: 14368928 + timestamp: 1778602917992 +- conda: https://conda.anaconda.org/conda-forge/win-64/pandas-2.3.3-py311h11fd7f3_2.conda + sha256: 7a4695b360b6a38f477c4e6deaa02e244ef77465e0c2a3b727d12c26bc0e9676 + md5: 6d7622c147fa008da95fe7dd7431a868 depends: - - numpy >=1.21,<3 - numpy >=1.22.4 - - python >=3.10,<3.11.0a0 + - numpy >=1.23,<3 + - python >=3.11,<3.12.0a0 - python-dateutil >=2.8.2 - python-tzdata >=2022.7 - - python_abi 3.10.* *_cp310 + - python_abi 3.11.* *_cp311 - pytz >=2020.1 - ucrt >=10.0.20348.0 - vc >=14.3,<15 - vc14_runtime >=14.44.35208 constrains: - - pyxlsb >=1.0.10 - - tabulate >=0.9.0 - - fastparquet >=2022.12.0 - - blosc >=1.21.3 - - fsspec >=2022.11.0 - - xlsxwriter >=3.0.5 + - pandas-gbq >=0.19.0 + - openpyxl >=3.1.0 + - html5lib >=1.1 - numba >=0.56.4 + - xarray >=2022.12.0 - psycopg2 >=2.9.6 - - pandas-gbq >=0.19.0 + - s3fs >=2022.11.0 + - scipy >=1.10.0 - xlrd >=2.0.1 + - qtpy >=2.3.0 + - fsspec >=2022.11.0 + - pyxlsb >=1.0.10 + - sqlalchemy >=2.0.0 - bottleneck >=1.3.6 - pyqt5 >=5.15.9 - - s3fs >=2022.11.0 - - xarray >=2022.12.0 + - lxml >=4.9.2 - zstandard >=0.19.0 - beautifulsoup4 >=4.11.2 - - pytables >=3.8.0 - - pyarrow >=10.0.1 - - lxml >=4.9.2 - - python-calamine >=0.1.7 - - sqlalchemy >=2.0.0 + - blosc >=1.21.3 - numexpr >=2.8.4 - - matplotlib >=3.6.3 - - gcsfs >=2022.11.0 - tzdata >=2022.7 - - odfpy >=1.4.1 - - qtpy >=2.3.0 - - html5lib >=1.1 - - scipy >=1.10.0 - - openpyxl >=3.1.0 + - xlsxwriter >=3.0.5 + - matplotlib >=3.6.3 + - fastparquet >=2022.12.0 + - pyarrow >=10.0.1 - pyreadstat >=1.2.0 + - python-calamine >=0.1.7 + - pytables >=3.8.0 + - tabulate >=0.9.0 + - odfpy >=1.4.1 + - gcsfs >=2022.11.0 license: BSD-3-Clause license_family: BSD purls: - pkg:pypi/pandas?source=hash-mapping - size: 11572977 - timestamp: 1764615208050 + size: 14211779 + timestamp: 1764615555643 - conda: https://conda.anaconda.org/conda-forge/win-64/pandas-2.3.3-py314hd8fd7ce_2.conda sha256: a1c87d34f72d6ae3f78203c60cf1b1adfb8d5cf55a3fc90f47e9f9ed50eb8b91 md5: 95cf7fc22f898b6faeb1d62ce2f5b82c @@ -8816,6 +13155,64 @@ packages: - pkg:pypi/pandas?source=hash-mapping size: 14046781 timestamp: 1764615388271 +- conda: https://conda.anaconda.org/conda-forge/win-64/pandas-3.0.3-py314hf700ef7_0.conda + sha256: 7f9912ba70e53805432f8e3a980fec5d13fe851989f68a70889394a2b4438ac2 + md5: 33451badee17d4162840339efdab40ad + depends: + - python + - numpy >=1.26.0 + - python-dateutil >=2.8.2 + - python-tzdata + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + - ucrt >=10.0.20348.0 + - python_abi 3.14.* *_cp314 + - numpy >=1.23,<3 + constrains: + - adbc-driver-postgresql >=1.2.0 + - adbc-driver-sqlite >=1.2.0 + - beautifulsoup4 >=4.12.3 + - blosc >=1.21.3 + - bottleneck >=1.4.2 + - fastparquet >=2024.11.0 + - fsspec >=2024.10.0 + - gcsfs >=2024.10.0 + - html5lib >=1.1 + - hypothesis >=6.116.0 + - jinja2 >=3.1.5 + - lxml >=5.3.0 + - matplotlib >=3.9.3 + - numba >=0.60.0 + - numexpr >=2.10.2 + - odfpy >=1.4.1 + - openpyxl >=3.1.5 + - psycopg2 >=2.9.10 + - pyarrow >=13.0.0 + - pyiceberg >=0.8.1 + - pymysql >=1.1.1 + - pyqt5 >=5.15.9 + - pyreadstat >=1.2.8 + - pytables >=3.10.1 + - pytest >=8.3.4 + - pytest-xdist >=3.6.1 + - python-calamine >=0.3.0 + - pytz >=2024.2 + - pyxlsb >=1.0.10 + - qtpy >=2.4.2 + - scipy >=1.14.1 + - s3fs >=2024.10.0 + - sqlalchemy >=2.0.36 + - tabulate >=0.9.0 + - xarray >=2024.10.0 + - xlrd >=2.0.1 + - xlsxwriter >=3.2.0 + - zstandard >=0.23.0 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/pandas?source=compressed-mapping + size: 14062915 + timestamp: 1778602665890 - conda: https://conda.anaconda.org/conda-forge/noarch/parso-0.8.4-pyhd8ed1ab_1.conda sha256: 17131120c10401a99205fc6fe436e7903c0fa092f1b3e80452927ab377239bcc md5: 5c092057b6badd30f75b06244ecd01c9 @@ -8827,6 +13224,51 @@ packages: - pkg:pypi/parso?source=hash-mapping size: 75295 timestamp: 1733271352153 +- conda: https://conda.anaconda.org/conda-forge/noarch/parso-0.8.7-pyhcf101f3_0.conda + sha256: 611882f7944b467281c46644ffde6c5145d1a7730388bcde26e7e86819b0998e + md5: 39894c952938276405a1bd30e4ce2caf + depends: + - python >=3.10 + - python + license: MIT + license_family: MIT + purls: + - pkg:pypi/parso?source=hash-mapping + size: 82472 + timestamp: 1777722955579 +- pypi: https://files.pythonhosted.org/packages/71/e7/40fb618334dcdf7c5a316c0e7343c5cd82d3d866edc100d98e29bc945ecd/partd-1.4.2-py3-none-any.whl + name: partd + version: 1.4.2 + sha256: 978e4ac767ec4ba5b86c6eaa52e5a2a3bc748a2ca839e8cc798f1cc6ce6efb0f + requires_dist: + - locket + - toolz + - numpy>=1.20.0 ; extra == 'complete' + - pandas>=1.3 ; extra == 'complete' + - pyzmq ; extra == 'complete' + - blosc ; extra == 'complete' + requires_python: '>=3.9' +- conda: https://conda.anaconda.org/conda-forge/noarch/pathspec-1.1.1-pyhd8ed1ab_0.conda + sha256: 6eaee417d33f298db79bc7185ab1208604c0e6cf51dade34cd513c6f9db9c6f3 + md5: 11adc78451c998c0fd162584abfa3559 + depends: + - python >=3.10 + license: MPL-2.0 + license_family: MOZILLA + purls: + - pkg:pypi/pathspec?source=hash-mapping + size: 56559 + timestamp: 1777271601895 +- pypi: https://files.pythonhosted.org/packages/f1/70/ba4b949bdc0490ab78d545459acd7702b211dfccf7eb89bbc1060f52818d/patsy-1.0.2-py2.py3-none-any.whl + name: patsy + version: 1.0.2 + sha256: 37bfddbc58fcf0362febb5f54f10743f8b21dd2aa73dec7e7ef59d1b02ae668a + requires_dist: + - numpy>=1.4 + - pytest ; extra == 'test' + - pytest-cov ; extra == 'test' + - scipy ; extra == 'test' + requires_python: '>=3.6' - conda: https://conda.anaconda.org/conda-forge/linux-64/pcre2-10.47-haa7fec5_0.conda sha256: 5e6f7d161356fefd981948bea5139c5aa0436767751a6930cb1ca801ebb113ff md5: 7a3bff861a6583f1889021facefc08b1 @@ -8840,6 +13282,30 @@ packages: purls: [] size: 1222481 timestamp: 1763655398280 +- conda: https://conda.anaconda.org/conda-forge/osx-64/pcre2-10.47-h13923f0_0.conda + sha256: 8d64a9d36073346542e5ea042ef8207a45a0069a2e65ce3323ee3146db78134c + md5: 08f970fb2b75f5be27678e077ebedd46 + depends: + - __osx >=10.13 + - bzip2 >=1.0.8,<2.0a0 + - libzlib >=1.3.1,<2.0a0 + license: BSD-3-Clause + license_family: BSD + purls: [] + size: 1106584 + timestamp: 1763655837207 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/pcre2-10.47-h30297fc_0.conda + sha256: 5e2e443f796f2fd92adf7978286a525fb768c34e12b1ee9ded4000a41b2894ba + md5: 9b4190c4055435ca3502070186eba53a + depends: + - __osx >=11.0 + - bzip2 >=1.0.8,<2.0a0 + - libzlib >=1.3.1,<2.0a0 + license: BSD-3-Clause + license_family: BSD + purls: [] + size: 850231 + timestamp: 1763655726735 - conda: https://conda.anaconda.org/conda-forge/win-64/pcre2-10.47-hd2b5f0e_0.conda sha256: 3e9e02174edf02cb4bcdd75668ad7b74b8061791a3bc8bdb8a52ae336761ba3e md5: 77eaf2336f3ae749e712f63e36b0f0a1 @@ -8899,6 +13365,29 @@ packages: - pkg:pypi/pillow?source=hash-mapping size: 1072995 timestamp: 1767353193452 +- conda: https://conda.anaconda.org/conda-forge/linux-64/pillow-12.3.0-py314h8ec4b1a_0.conda + sha256: bcab128df8980514061a78b9c67f5004954048f584da20df8c5a78de9e3f5abb + md5: 233e62a8eb894b79b5c93f4f8dec4dcd + depends: + - python + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - libfreetype >=2.14.3 + - libfreetype6 >=2.14.3 + - libtiff >=4.7.1,<4.8.0a0 + - openjpeg >=2.5.4,<3.0a0 + - libxcb >=1.17.0,<2.0a0 + - zlib-ng >=2.3.3,<2.4.0a0 + - libwebp-base >=1.6.0,<2.0a0 + - python_abi 3.14.* *_cp314 + - libjpeg-turbo >=3.1.4.1,<4.0a0 + - lcms2 >=2.19.1,<3.0a0 + - tk >=8.6.13,<8.7.0a0 + license: HPND + purls: + - pkg:pypi/pillow?source=compressed-mapping + size: 1108174 + timestamp: 1782912080163 - conda: https://conda.anaconda.org/conda-forge/osx-64/pillow-11.3.0-py313hcfd0557_3.conda sha256: ebd4febd2b4a0d766cab6450f2ac5442b5a319c5f01f744823e5bdfa899b6e0c md5: 9fe2ebb0ad526ad057cf21d20d53d466 @@ -8918,9 +13407,31 @@ packages: - libjpeg-turbo >=3.1.0,<4.0a0 license: HPND purls: - - pkg:pypi/pillow?source=hash-mapping - size: 974619 - timestamp: 1758208807855 + - pkg:pypi/pillow?source=hash-mapping + size: 974619 + timestamp: 1758208807855 +- conda: https://conda.anaconda.org/conda-forge/osx-64/pillow-12.3.0-py314hc904d5e_0.conda + sha256: c9bc8bd9e7966d8045bb1a23393671ae756cac7ca8b95d1f65a6376fabd8bd2f + md5: c0727ce890a59a6a956dcbce49ee01e5 + depends: + - python + - __osx >=11.0 + - libfreetype >=2.14.3 + - libfreetype6 >=2.14.3 + - lcms2 >=2.19.1,<3.0a0 + - python_abi 3.14.* *_cp314 + - zlib-ng >=2.3.3,<2.4.0a0 + - libxcb >=1.17.0,<2.0a0 + - libjpeg-turbo >=3.1.4.1,<4.0a0 + - libwebp-base >=1.6.0,<2.0a0 + - libtiff >=4.7.1,<4.8.0a0 + - tk >=8.6.13,<8.7.0a0 + - openjpeg >=2.5.4,<3.0a0 + license: HPND + purls: + - pkg:pypi/pillow?source=compressed-mapping + size: 1029929 + timestamp: 1782912253167 - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pillow-12.1.0-py314hab283cf_0.conda sha256: 3f88f2600862583c8bed3d37f4b95f0f96a459e9fdd36ca680472bc89a46e7bb md5: 1f9dae6213643ac883e300c11df611eb @@ -8944,6 +13455,29 @@ packages: - pkg:pypi/pillow?source=hash-mapping size: 995543 timestamp: 1767353279681 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/pillow-12.3.0-py314hab283cf_0.conda + sha256: dd7303ea135116cc1182c109825459a9eeb77d244d3899f03dd8d83a8db956f9 + md5: 4f25498ea1962ab24097fed8700e91ae + depends: + - python + - python 3.14.* *_cp314 + - __osx >=11.0 + - zlib-ng >=2.3.3,<2.4.0a0 + - openjpeg >=2.5.4,<3.0a0 + - libfreetype >=2.14.3 + - libfreetype6 >=2.14.3 + - libxcb >=1.17.0,<2.0a0 + - libtiff >=4.7.1,<4.8.0a0 + - libjpeg-turbo >=3.1.4.1,<4.0a0 + - libwebp-base >=1.6.0,<2.0a0 + - python_abi 3.14.* *_cp314 + - tk >=8.6.13,<8.7.0a0 + - lcms2 >=2.19.1,<3.0a0 + license: HPND + purls: + - pkg:pypi/pillow?source=compressed-mapping + size: 1019767 + timestamp: 1782912213683 - conda: https://conda.anaconda.org/conda-forge/win-64/pillow-12.1.0-py314h61b30b5_0.conda sha256: b30a83db337dab8579a46e3da7906851f53d6cf8c09695aef6d2a38b17636c1c md5: 17dbdfedee39f31166b7e548f3ccc58a @@ -8968,6 +13502,92 @@ packages: - pkg:pypi/pillow?source=hash-mapping size: 973387 timestamp: 1767353195064 +- conda: https://conda.anaconda.org/conda-forge/win-64/pillow-12.3.0-py314h61b30b5_0.conda + sha256: c9dc3212ed0021974541072ee3765a5097a0721191c34ee485d7d7e94449648f + md5: 09b8e6ac8f4a257b59e5d3025f3c9c1d + depends: + - python + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + - ucrt >=10.0.20348.0 + - python_abi 3.14.* *_cp314 + - libfreetype >=2.14.3 + - libfreetype6 >=2.14.3 + - libwebp-base >=1.6.0,<2.0a0 + - libtiff >=4.7.1,<4.8.0a0 + - openjpeg >=2.5.4,<3.0a0 + - lcms2 >=2.19.1,<3.0a0 + - libxcb >=1.17.0,<2.0a0 + - libjpeg-turbo >=3.1.4.1,<4.0a0 + - tk >=8.6.13,<8.7.0a0 + - zlib-ng >=2.3.3,<2.4.0a0 + license: HPND + purls: + - pkg:pypi/pillow?source=compressed-mapping + size: 989058 + timestamp: 1782912129930 +- pypi: https://files.pythonhosted.org/packages/1b/dd/a9fe6a0a09512da23951c68bf36466aeecd89def3183dc095edbc807ddc5/pint-0.25.3-py3-none-any.whl + name: pint + version: 0.25.3 + sha256: 27eb25143bd5de9fcc4d5a4b484f16faf6b4615aa93ece6b3373a8c1a3c1b97d + requires_dist: + - flexcache>=0.3 + - flexparser>=0.4 + - platformdirs>=2.1.0 + - typing-extensions>=4.0.0 + - babel<=2.8 ; extra == 'all' + - dask<2025.3.0 ; extra == 'all' + - matplotlib ; extra == 'all' + - numpy>=1.23 ; extra == 'all' + - pint-pandas>=0.3 ; extra == 'all' + - scipy ; extra == 'all' + - uncertainties>=3.1.6 ; extra == 'all' + - xarray ; extra == 'all' + - babel<=2.8 ; extra == 'babel' + - pytest ; extra == 'codspeed' + - pytest-benchmark ; extra == 'codspeed' + - pytest-codspeed ; extra == 'codspeed' + - pytest-cov ; extra == 'codspeed' + - pytest-mpl ; extra == 'codspeed' + - pytest-subtests ; extra == 'codspeed' + - dask<2025.3.0 ; extra == 'dask' + - babel ; extra == 'docs' + - commonmark==0.8.1 ; extra == 'docs' + - currencyconverter ; extra == 'docs' + - docutils ; extra == 'docs' + - graphviz ; extra == 'docs' + - ipykernel ; extra == 'docs' + - ipython<=8.12 ; extra == 'docs' + - jupyter-client ; extra == 'docs' + - nbsphinx ; extra == 'docs' + - pooch ; extra == 'docs' + - pygments>=2.4 ; extra == 'docs' + - recommonmark==0.5.0 ; extra == 'docs' + - sciform ; extra == 'docs' + - scipy ; extra == 'docs' + - serialize ; extra == 'docs' + - sparse ; extra == 'docs' + - sphinx-book-theme>=1.1.0 ; extra == 'docs' + - sphinx-copybutton ; extra == 'docs' + - sphinx-design ; extra == 'docs' + - sphinx>=6,<8.2 ; extra == 'docs' + - matplotlib ; extra == 'matplotlib' + - numpy>=1.23 ; extra == 'numpy' + - pint-pandas>=0.3 ; extra == 'pandas' + - scipy ; extra == 'scipy' + - pytest ; extra == 'test' + - pytest-benchmark ; extra == 'test' + - pytest-cov ; extra == 'test' + - pytest-subtests ; extra == 'test' + - pytest ; extra == 'test-all' + - pytest-benchmark ; extra == 'test-all' + - pytest-cov ; extra == 'test-all' + - pytest-mpl ; extra == 'test-all' + - pytest-subtests ; extra == 'test-all' + - pytest-mpl ; extra == 'test-mpl' + - uncertainties>=3.1.6 ; extra == 'uncertainties' + - xarray ; extra == 'xarray' + requires_python: '>=3.11' - conda: https://conda.anaconda.org/conda-forge/linux-64/pixman-0.46.4-h54a6638_1.conda sha256: 43d37bc9ca3b257c5dd7bf76a8426addbdec381f6786ff441dc90b1a49143b6a md5: c01af13bdc553d1a8fbfff6e8db075f0 @@ -8981,6 +13601,28 @@ packages: purls: [] size: 450960 timestamp: 1754665235234 +- conda: https://conda.anaconda.org/conda-forge/osx-64/pixman-0.46.4-ha059160_1.conda + sha256: ff8b679079df25aa3ed5daf3f4e3a9c7ee79e7d4b2bd8a21de0f8e7ec7207806 + md5: 742a8552e51029585a32b6024e9f57b4 + depends: + - __osx >=10.13 + - libcxx >=19 + license: MIT + license_family: MIT + purls: [] + size: 390942 + timestamp: 1754665233989 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/pixman-0.46.4-h81086ad_1.conda + sha256: 29c9b08a9b8b7810f9d4f159aecfd205fce051633169040005c0b7efad4bc718 + md5: 17c3d745db6ea72ae2fce17e7338547f + depends: + - __osx >=11.0 + - libcxx >=19 + license: MIT + license_family: MIT + purls: [] + size: 248045 + timestamp: 1754665282033 - conda: https://conda.anaconda.org/conda-forge/win-64/pixman-0.46.4-h5112557_1.conda sha256: 246fce4706b3f8b247a7d6142ba8d732c95263d3c96e212b9d63d6a4ab4aff35 md5: 08c8fa3b419df480d985e304f7884d35 @@ -8996,6 +13638,18 @@ packages: purls: [] size: 542795 timestamp: 1754665193489 +- conda: https://conda.anaconda.org/conda-forge/noarch/platformdirs-4.10.0-pyhcf101f3_0.conda + sha256: 9e5e1fd3506ccfc4d444fc4d2d39b0ed097d5d0e3bd3d4bdf6bcc81aaf66860d + md5: 2c5ef45db85d34799771629bd5860fd7 + depends: + - python >=3.10 + - python + license: MIT + license_family: MIT + purls: + - pkg:pypi/platformdirs?source=compressed-mapping + size: 26308 + timestamp: 1779972894916 - conda: https://conda.anaconda.org/conda-forge/noarch/platformdirs-4.3.6-pyhd8ed1ab_1.conda sha256: bb50f6499e8bc1d1a26f17716c97984671121608dc0c3ecd34858112bce59a27 md5: 577852c7e53901ddccc7e6a9959ddebe @@ -9030,6 +13684,20 @@ packages: - pkg:pypi/pluggy?source=hash-mapping size: 25877 timestamp: 1764896838868 +- pypi: https://files.pythonhosted.org/packages/2a/2d/d4bf65e47cea8ff2c794a600c4fd1273a7902f268757c531e0ee9f18aa58/pooch-1.9.0-py3-none-any.whl + name: pooch + version: 1.9.0 + sha256: f265597baa9f760d25ceb29d0beb8186c243d6607b0f60b83ecf14078dbc703b + requires_dist: + - platformdirs>=2.5.0 + - packaging>=20.0 + - requests>=2.19.0 + - tqdm>=4.41.0,<5.0.0 ; extra == 'progress' + - paramiko>=2.7.0 ; extra == 'sftp' + - xxhash>=1.4.3 ; extra == 'xxhash' + - pytest-httpserver ; extra == 'test' + - pytest-localftpserver ; extra == 'test' + requires_python: '>=3.9' - conda: https://conda.anaconda.org/conda-forge/noarch/prompt-toolkit-3.0.50-pyha770c72_0.conda sha256: 0749c49a349bf55b8539ce5addce559b77592165da622944a51c630e94d97889 md5: 7d823138f550b14ecae927a5ff3286de @@ -9044,6 +13712,20 @@ packages: - pkg:pypi/prompt-toolkit?source=hash-mapping size: 271905 timestamp: 1737453457168 +- conda: https://conda.anaconda.org/conda-forge/noarch/prompt-toolkit-3.0.52-pyha770c72_0.conda + sha256: 4817651a276016f3838957bfdf963386438c70761e9faec7749d411635979bae + md5: edb16f14d920fb3faf17f5ce582942d6 + depends: + - python >=3.10 + - wcwidth + constrains: + - prompt_toolkit 3.0.52 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/prompt-toolkit?source=hash-mapping + size: 273927 + timestamp: 1756321848365 - conda: https://conda.anaconda.org/conda-forge/linux-64/psutil-7.2.1-py314h0f05182_0.conda sha256: 324455a702ef721290de6e51d9af4f7ca057546d6398bbc6e88454db17cdaf6b md5: 28af9719e28f0054e9aee68153899293 @@ -9058,6 +13740,34 @@ packages: - pkg:pypi/psutil?source=hash-mapping size: 228170 timestamp: 1767012382363 +- conda: https://conda.anaconda.org/conda-forge/linux-64/psutil-7.2.2-py314h0f05182_0.conda + sha256: f15574ed6c8c8ed8c15a0c5a00102b1efe8b867c0bd286b498cd98d95bd69ae5 + md5: 4f225a966cfee267a79c5cb6382bd121 + depends: + - python + - libgcc >=14 + - __glibc >=2.17,<3.0.a0 + - python_abi 3.14.* *_cp314 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/psutil?source=hash-mapping + size: 231303 + timestamp: 1769678156552 +- conda: https://conda.anaconda.org/conda-forge/linux-64/psutil-7.2.2-py314h3f2afee_0.conda + sha256: 60aa6c81bd15c6db888b568f6dda051970e10a414154cc8747a6c1ef0816fd28 + md5: d71965c9f50c361ead9696f14c3af653 + depends: + - python + - libgcc >=14 + - __glibc >=2.17,<3.0.a0 + - python_abi 3.14.* *_cp314t + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/psutil?source=hash-mapping + size: 232395 + timestamp: 1769678157420 - conda: https://conda.anaconda.org/conda-forge/osx-64/psutil-6.1.1-py313h63b0ddb_0.conda sha256: 6ce8a7a64fb72fa8b1b3f20058ea345534be3a7b4729768d320f56be67047fc7 md5: 8538f25c72edf35a53a7281bb7501209 @@ -9071,6 +13781,32 @@ packages: - pkg:pypi/psutil?source=hash-mapping size: 501460 timestamp: 1735327516357 +- conda: https://conda.anaconda.org/conda-forge/osx-64/psutil-7.2.2-py314h5a675f6_0.conda + sha256: 5f723d569e6fb03b9bd5ad3744e631c6eda086f85fc11b87bcdfc2f1dc901608 + md5: 950f0e0025606dd4f10d5e478d5edc48 + depends: + - python + - __osx >=10.13 + - python_abi 3.14.* *_cp314t + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/psutil?source=hash-mapping + size: 243911 + timestamp: 1769678309883 +- conda: https://conda.anaconda.org/conda-forge/osx-64/psutil-7.2.2-py314hd330473_0.conda + sha256: 3194ce0d94c810cb1809da851261be34e1cae72ca345445b29e61766b38ee6cc + md5: d465805e603072c341554159939be5b8 + depends: + - python + - __osx >=10.13 + - python_abi 3.14.* *_cp314 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/psutil?source=hash-mapping + size: 242816 + timestamp: 1769678225798 - conda: https://conda.anaconda.org/conda-forge/osx-arm64/psutil-7.2.1-py314ha14b1ff_0.conda sha256: 686b643b97df8e7076b971820fb9b5d2ed0ea8a5a82922910da1600a6f462b79 md5: 6d799fc0d0178eb63202bf99ff7bc24f @@ -9085,6 +13821,20 @@ packages: - pkg:pypi/psutil?source=hash-mapping size: 241751 timestamp: 1767012600474 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/psutil-7.2.2-py314ha14b1ff_0.conda + sha256: e0f31c053eb11803d63860c213b2b1b57db36734f5f84a3833606f7c91fedff9 + md5: fc4c7ab223873eee32080d51600ce7e7 + depends: + - python + - __osx >=11.0 + - python 3.14.* *_cp314 + - python_abi 3.14.* *_cp314 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/psutil?source=hash-mapping + size: 245502 + timestamp: 1769678303655 - conda: https://conda.anaconda.org/conda-forge/win-64/psutil-7.2.1-py314hc5dbbe4_0.conda sha256: d776855d47e14d8b1521a3949c1d1dc3848c690170253ecc439264e219859e22 md5: 65df3730bedf9c24f54414c8316f8e72 @@ -9100,6 +13850,36 @@ packages: - pkg:pypi/psutil?source=hash-mapping size: 245991 timestamp: 1767012412984 +- conda: https://conda.anaconda.org/conda-forge/win-64/psutil-7.2.2-py314h8f04a7f_0.conda + sha256: 3189d8ba29c76902f8f49650537e1062927aa22d2e67b54b1700c6c35347033a + md5: cf22d3d710d26bdf848625f7b668b734 + depends: + - python + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + - ucrt >=10.0.20348.0 + - python_abi 3.14.* *_cp314t + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/psutil?source=hash-mapping + size: 251992 + timestamp: 1769678173524 +- conda: https://conda.anaconda.org/conda-forge/win-64/psutil-7.2.2-py314hc5dbbe4_0.conda + sha256: 17c8274ce5a32c9793f73a5a0094bd6188f3a13026a93147655143d4df034214 + md5: fd539ac231820f64066839251aa9fa48 + depends: + - python + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + - ucrt >=10.0.20348.0 + - python_abi 3.14.* *_cp314 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/psutil?source=hash-mapping + size: 249950 + timestamp: 1769678167309 - conda: https://conda.anaconda.org/conda-forge/linux-64/pthread-stubs-0.4-hb9d3cd8_1002.conda sha256: 9c88f8c64590e9567c6c80823f0328e58d3b1efb0e1c539c0315ceca764e0973 md5: b3c17d95b5a10c6e64a21fa17573e70e @@ -9198,6 +13978,58 @@ packages: - pkg:pypi/pyparsing?source=compressed-mapping size: 110235 timestamp: 1766475444791 +- conda: https://conda.anaconda.org/conda-forge/noarch/pyparsing-3.3.2-pyhcf101f3_0.conda + sha256: 417fba4783e528ee732afa82999300859b065dc59927344b4859c64aae7182de + md5: 3687cc0b82a8b4c17e1f0eb7e47163d5 + depends: + - python >=3.10 + - python + license: MIT + license_family: MIT + purls: + - pkg:pypi/pyparsing?source=hash-mapping + size: 110893 + timestamp: 1769003998136 +- pypi: https://files.pythonhosted.org/packages/04/90/67bd7260b4ea9b8b20b4f58afef6c223ecb3abf368eb4ec5bc2cdef81b49/pyproj-3.7.2.tar.gz + name: pyproj + version: 3.7.2 + sha256: 39a0cf1ecc7e282d1d30f36594ebd55c9fae1fda8a2622cee5d100430628f88c + requires_dist: + - certifi + requires_python: '>=3.11' +- pypi: https://files.pythonhosted.org/packages/04/b2/5a6610554306a83a563080c2cf2c57565563eadd280e15388efa00fb5b33/pyproj-3.7.2-cp314-cp314-win_amd64.whl + name: pyproj + version: 3.7.2 + sha256: 5a964da1696b8522806f4276ab04ccfff8f9eb95133a92a25900697609d40112 + requires_dist: + - certifi + requires_python: '>=3.11' +- pypi: https://files.pythonhosted.org/packages/05/1e/ada6fb15a1d75b5bd9b554355a69a798c55a7dcc93b8d41596265c1772e3/pyproj-3.7.2-cp314-cp314-manylinux_2_28_x86_64.whl + name: pyproj + version: 3.7.2 + sha256: 85def3a6388e9ba51f964619aa002a9d2098e77c6454ff47773bb68871024281 + requires_dist: + - certifi + requires_python: '>=3.11' +- pypi: https://files.pythonhosted.org/packages/42/17/c2b050d3f5b71b6edd0d96ae16c990fdc42a5f1366464a5c2772146de33a/pyproj-3.7.2-cp314-cp314-macosx_13_0_x86_64.whl + name: pyproj + version: 3.7.2 + sha256: 2aaa328605ace41db050d06bac1adc11f01b71fe95c18661497763116c3a0f02 + requires_dist: + - certifi + requires_python: '>=3.11' +- conda: https://conda.anaconda.org/conda-forge/noarch/pyproject_hooks-1.2.0-pyhd8ed1ab_1.conda + sha256: 065ac44591da9abf1ff740feb25929554b920b00d09287a551fcced2c9791092 + md5: d4582021af437c931d7d77ec39007845 + depends: + - python >=3.9 + - tomli >=1.1.0 + license: MIT + license_family: MIT + purls: + - pkg:pypi/pyproject-hooks?source=hash-mapping + size: 15528 + timestamp: 1733710122949 - conda: https://conda.anaconda.org/conda-forge/linux-64/pyside6-6.10.1-py314hf36963e_0.conda sha256: 400bf53007d7fd70b4a7e060db51ebf42dbd93b7d0319944f69be6eb94b065da md5: 7092c03811619ce1344ea40c31328264 @@ -9224,6 +14056,31 @@ packages: - pkg:pypi/shiboken6?source=hash-mapping size: 11719157 timestamp: 1765812030250 +- conda: https://conda.anaconda.org/conda-forge/linux-64/pyside6-6.11.1-py314h3987850_1.conda + sha256: e410d0d4151f418dc75ea2dc38dfb0e7a136090b6874e5ca1c699fa840b4994d + md5: 5d2051f0630a568926943fc53c0aaa4c + depends: + - python + - qt6-main 6.11.1.* + - libstdcxx >=14 + - libgcc >=14 + - __glibc >=2.17,<3.0.a0 + - libvulkan-loader >=1.4.341.0,<2.0a0 + - libgl >=1.7.0,<2.0a0 + - libopengl >=1.7.0,<2.0a0 + - libxslt >=1.1.43,<2.0a0 + - libegl >=1.7.0,<2.0a0 + - python_abi 3.14.* *_cp314 + - qt6-main >=6.11.1,<6.12.0a0 + - libclang13 >=22.1.5 + - libxml2 + - libxml2-16 >=2.14.6 + license: LGPL-3.0-only + license_family: LGPL + purls: + - pkg:pypi/pyside6?source=compressed-mapping + size: 13821776 + timestamp: 1778933872780 - conda: https://conda.anaconda.org/conda-forge/win-64/pyside6-6.10.1-py314h2c9462b_0.conda sha256: 1439f051b7c5a0d7915552c13d786d9f96e915fcd96d4166d0bd88f9b1b91e44 md5: b814621e074091a546da1dc32ab1b20a @@ -9247,6 +14104,29 @@ packages: - pkg:pypi/shiboken6?source=hash-mapping size: 8996723 timestamp: 1765812737093 +- conda: https://conda.anaconda.org/conda-forge/win-64/pyside6-6.11.1-py314h447aaf0_1.conda + sha256: 070802d5e1e1c1feb24d481efbd90b300fb0ecc1ce4312a3bbcbaae4393c05f9 + md5: 638be6b8674e7acf7a84132903cf4c8e + depends: + - python + - qt6-main 6.11.1.* + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + - ucrt >=10.0.20348.0 + - libxslt >=1.1.43,<2.0a0 + - libxml2 + - libxml2-16 >=2.14.6 + - qt6-main >=6.11.1,<6.12.0a0 + - python_abi 3.14.* *_cp314 + - libvulkan-loader >=1.4.341.0,<2.0a0 + - libclang13 >=22.1.5 + license: LGPL-3.0-only + license_family: LGPL + purls: + - pkg:pypi/pyside6?source=hash-mapping + - pkg:pypi/shiboken6?source=hash-mapping + size: 11579652 + timestamp: 1778933912020 - conda: https://conda.anaconda.org/conda-forge/noarch/pysocks-1.7.1-pyh09c184e_7.conda sha256: d016e04b0e12063fbee4a2d5fbb9b39a8d191b5a0042f0b8459188aedeabb0ca md5: e2fd202833c4a981ce8a65974fe4abd1 @@ -9342,16 +14222,16 @@ packages: - pkg:pypi/pytest-xdist?source=hash-mapping size: 39300 timestamp: 1751452761594 -- conda: https://conda.anaconda.org/conda-forge/linux-64/python-3.10.20-h267e890_1_cpython.conda +- conda: https://conda.anaconda.org/conda-forge/linux-64/python-3.11.15-h7508c33_1_cpython.conda build_number: 1 - sha256: c15d8585b7a52fdb734bd16dbdcae4b81ed59268862d3a2588eb8ed69c8cbc52 - md5: c5eace1c2d8dae0bb08c094617ea8cc7 + sha256: e830c8c69605674a997ee280d79c0f05ff5c1ed80ce3743678b2f663f410dfb9 + md5: fa29f621acaa9c0db5fd2c0ffc65312c depends: - __glibc >=2.17,<3.0.a0 - bzip2 >=1.0.8,<2.0a0 - ld_impl_linux-64 >=2.36.1 - libexpat >=2.8.1,<3.0a0 - - libffi >=3.4,<4.0a0 + - libffi >=3.5.2,<3.6.0a0 - libgcc >=14 - liblzma >=5.8.3,<6.0a0 - libnsl >=2.0.1,<2.1.0a0 @@ -9365,11 +14245,11 @@ packages: - tk >=8.6.13,<8.7.0a0 - tzdata constrains: - - python_abi 3.10.* *_cp310 + - python_abi 3.11.* *_cp311 license: Python-2.0 purls: [] - size: 25403213 - timestamp: 1781149348162 + size: 30907259 + timestamp: 1781149782225 - conda: https://conda.anaconda.org/conda-forge/linux-64/python-3.14.2-h32b2ec7_100_cp314.conda build_number: 100 sha256: a120fb2da4e4d51dd32918c149b04a08815fd2bd52099dad1334647984bb07f1 @@ -9398,15 +14278,72 @@ packages: size: 36790521 timestamp: 1765021515427 python_site_packages_path: lib/python3.14/site-packages -- conda: https://conda.anaconda.org/conda-forge/osx-64/python-3.10.20-hea035f4_1_cpython.conda +- conda: https://conda.anaconda.org/conda-forge/linux-64/python-3.14.6-habeac84_100_cp314.conda + build_number: 100 + sha256: 6d28ac2b061179deb434d3d57afa98ffd20ec3c5d44ab8048a1ca33424b22d38 + md5: 0b9b2f83b5b600e1ac38becde8d0dd44 + depends: + - __glibc >=2.17,<3.0.a0 + - bzip2 >=1.0.8,<2.0a0 + - ld_impl_linux-64 >=2.36.1 + - libexpat >=2.8.1,<3.0a0 + - libffi >=3.5.2,<3.6.0a0 + - libgcc >=14 + - liblzma >=5.8.3,<6.0a0 + - libmpdec >=4.0.0,<5.0a0 + - libsqlite >=3.53.2,<4.0a0 + - libuuid >=2.42.1,<3.0a0 + - libzlib >=1.3.2,<2.0a0 + - ncurses >=6.6,<7.0a0 + - openssl >=3.5.7,<4.0a0 + - python_abi 3.14.* *_cp314 + - readline >=8.3,<9.0a0 + - tk >=8.6.13,<8.7.0a0 + - tzdata + - zstd >=1.5.7,<1.6.0a0 + license: Python-2.0 + purls: [] + size: 36717183 + timestamp: 1781255094700 + python_site_packages_path: lib/python3.14/site-packages +- conda: https://conda.anaconda.org/conda-forge/linux-64/python-3.14.6-hf9ea5aa_0_cp314t.conda + sha256: a159d818da436041a3fcdb6681b1a3b12ed78338519662de31af03d891763241 + md5: 054621389e1cfbef617475720307fa8b + depends: + - __glibc >=2.17,<3.0.a0 + - bzip2 >=1.0.8,<2.0a0 + - ld_impl_linux-64 >=2.36.1 + - libexpat >=2.8.1,<3.0a0 + - libffi >=3.5.2,<3.6.0a0 + - libgcc >=14 + - liblzma >=5.8.3,<6.0a0 + - libmpdec >=4.0.0,<5.0a0 + - libsqlite >=3.53.2,<4.0a0 + - libuuid >=2.42.1,<3.0a0 + - libzlib >=1.3.2,<2.0a0 + - ncurses >=6.6,<7.0a0 + - openssl >=3.5.7,<4.0a0 + - python_abi 3.14.* *_cp314t + - readline >=8.3,<9.0a0 + - tk >=8.6.13,<8.7.0a0 + - tzdata + - zstd >=1.5.7,<1.6.0a0 + track_features: + - py_freethreading + license: Python-2.0 + purls: [] + size: 47723357 + timestamp: 1781255054001 + python_site_packages_path: lib/python3.14t/site-packages +- conda: https://conda.anaconda.org/conda-forge/osx-64/python-3.11.15-ha9537fe_1_cpython.conda build_number: 1 - sha256: 9bc83a907d13a532f3a38ddc666a58d612cf548347d5e8eec2ce1ad1dacbe420 - md5: b0564ca60a54a4087fcd11326e1169e2 + sha256: 0cf3e36f0f9b6d40b844ed048ff495f9d381c200eb150d9152d847e5f56fac06 + md5: c652cafe724fd91cd8d56c1729c7676b depends: - __osx >=11.0 - bzip2 >=1.0.8,<2.0a0 - libexpat >=2.8.1,<3.0a0 - - libffi >=3.4,<4.0a0 + - libffi >=3.5.2,<3.6.0a0 - liblzma >=5.8.3,<6.0a0 - libsqlite >=3.53.2,<4.0a0 - libzlib >=1.3.2,<2.0a0 @@ -9416,11 +14353,11 @@ packages: - tk >=8.6.13,<8.7.0a0 - tzdata constrains: - - python_abi 3.10.* *_cp310 + - python_abi 3.11.* *_cp311 license: Python-2.0 purls: [] - size: 13071051 - timestamp: 1781151393975 + size: 15650410 + timestamp: 1781150619639 - conda: https://conda.anaconda.org/conda-forge/osx-64/python-3.13.2-h534c281_101_cp313.conda build_number: 101 sha256: 19abb6ba8a1af6985934a48f05fccd29ecc54926febdb8b3803f30134c518b34 @@ -9445,15 +14382,66 @@ packages: size: 13961675 timestamp: 1739802065430 python_site_packages_path: lib/python3.13/site-packages -- conda: https://conda.anaconda.org/conda-forge/osx-arm64/python-3.10.20-hac0b6dc_1_cpython.conda +- conda: https://conda.anaconda.org/conda-forge/osx-64/python-3.14.6-h7c6738f_100_cp314.conda + build_number: 100 + sha256: f8261699d80fb6e653fc56c9b89ca4c3dd1aa374a10d11af64a089cf4b2b0d4a + md5: ecfbc87d80647d5076839d8d1006ac5f + depends: + - __osx >=11.0 + - bzip2 >=1.0.8,<2.0a0 + - libexpat >=2.8.1,<3.0a0 + - libffi >=3.5.2,<3.6.0a0 + - liblzma >=5.8.3,<6.0a0 + - libmpdec >=4.0.0,<5.0a0 + - libsqlite >=3.53.2,<4.0a0 + - libzlib >=1.3.2,<2.0a0 + - ncurses >=6.6,<7.0a0 + - openssl >=3.5.7,<4.0a0 + - python_abi 3.14.* *_cp314 + - readline >=8.3,<9.0a0 + - tk >=8.6.13,<8.7.0a0 + - tzdata + - zstd >=1.5.7,<1.6.0a0 + license: Python-2.0 + purls: [] + size: 14368118 + timestamp: 1781256031540 + python_site_packages_path: lib/python3.14/site-packages +- conda: https://conda.anaconda.org/conda-forge/osx-64/python-3.14.6-ha91e2d8_0_cp314t.conda + sha256: becf51f5427fc0c1e68a64fa5467fe62116fff6ed098033c7844c7a9ce18e833 + md5: 1bc59acd81f34797a157b4d05bbe8c5d + depends: + - __osx >=11.0 + - bzip2 >=1.0.8,<2.0a0 + - libexpat >=2.8.1,<3.0a0 + - libffi >=3.5.2,<3.6.0a0 + - liblzma >=5.8.3,<6.0a0 + - libmpdec >=4.0.0,<5.0a0 + - libsqlite >=3.53.2,<4.0a0 + - libzlib >=1.3.2,<2.0a0 + - ncurses >=6.6,<7.0a0 + - openssl >=3.5.7,<4.0a0 + - python_abi 3.14.* *_cp314t + - readline >=8.3,<9.0a0 + - tk >=8.6.13,<8.7.0a0 + - tzdata + - zstd >=1.5.7,<1.6.0a0 + track_features: + - py_freethreading + license: Python-2.0 + purls: [] + size: 16822275 + timestamp: 1781257301733 + python_site_packages_path: lib/python3.14t/site-packages +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/python-3.11.15-h0c9c016_1_cpython.conda build_number: 1 - sha256: 3c9e084162759c4029212b96147a179b0ad8076abfca85f00984d2aaa10c70f9 - md5: 7f498ade7b9aa9e327ad23931e6c6d4a + sha256: a44be5222fe8d3c072ecd22491d37316724b70be6b8e8dabdc1a25e6d293fba8 + md5: 91607d75cdf9fafc95061e3763582657 depends: - __osx >=11.0 - bzip2 >=1.0.8,<2.0a0 - libexpat >=2.8.1,<3.0a0 - - libffi >=3.4,<4.0a0 + - libffi >=3.5.2,<3.6.0a0 - liblzma >=5.8.3,<6.0a0 - libsqlite >=3.53.2,<4.0a0 - libzlib >=1.3.2,<2.0a0 @@ -9463,11 +14451,11 @@ packages: - tk >=8.6.13,<8.7.0a0 - tzdata constrains: - - python_abi 3.10.* *_cp310 + - python_abi 3.11.* *_cp311 license: Python-2.0 purls: [] - size: 12888297 - timestamp: 1781148720732 + size: 15389700 + timestamp: 1781148926804 - conda: https://conda.anaconda.org/conda-forge/osx-arm64/python-3.14.2-h40d2674_100_cp314.conda build_number: 100 sha256: 1a93782e90b53e04c2b1a50a0f8bf0887936649d19dba6a05b05c4b44dae96b7 @@ -9493,14 +14481,39 @@ packages: size: 13575758 timestamp: 1765021280625 python_site_packages_path: lib/python3.14/site-packages -- conda: https://conda.anaconda.org/conda-forge/win-64/python-3.10.20-hc20f281_1_cpython.conda +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/python-3.14.6-h156bc91_100_cp314.conda + build_number: 100 + sha256: 984081c9fae3a3944c6f2707bbbbc70e8b961f02cdb7c640d9745e2636235632 + md5: 4841be3d0cf616a860efc6e60af66f8b + depends: + - __osx >=11.0 + - bzip2 >=1.0.8,<2.0a0 + - libexpat >=2.8.1,<3.0a0 + - libffi >=3.5.2,<3.6.0a0 + - liblzma >=5.8.3,<6.0a0 + - libmpdec >=4.0.0,<5.0a0 + - libsqlite >=3.53.2,<4.0a0 + - libzlib >=1.3.2,<2.0a0 + - ncurses >=6.6,<7.0a0 + - openssl >=3.5.7,<4.0a0 + - python_abi 3.14.* *_cp314 + - readline >=8.3,<9.0a0 + - tk >=8.6.13,<8.7.0a0 + - tzdata + - zstd >=1.5.7,<1.6.0a0 + license: Python-2.0 + purls: [] + size: 14059371 + timestamp: 1781254578985 + python_site_packages_path: lib/python3.14/site-packages +- conda: https://conda.anaconda.org/conda-forge/win-64/python-3.11.15-h0159041_1_cpython.conda build_number: 1 - sha256: 71e2cdc0f87a0a2c5db7beb82469559bba1ce88a4fafe4e2d169172c2db45d1f - md5: 62018eccb570c1fb288b550f804fb940 + sha256: 32716d8df907696e856cbd4cdcc5fe89ddae01c7c9a8cc99bd42260bf6d9a4a2 + md5: 06b84fcf19e4d5101a1d105d15dcfc88 depends: - bzip2 >=1.0.8,<2.0a0 - libexpat >=2.8.1,<3.0a0 - - libffi >=3.4,<4.0a0 + - libffi >=3.5.2,<3.6.0a0 - liblzma >=5.8.3,<6.0a0 - libsqlite >=3.53.2,<4.0a0 - libzlib >=1.3.2,<2.0a0 @@ -9511,11 +14524,11 @@ packages: - vc >=14.3,<15 - vc14_runtime >=14.44.35208 constrains: - - python_abi 3.10.* *_cp310 + - python_abi 3.11.* *_cp311 license: Python-2.0 purls: [] - size: 16128204 - timestamp: 1781148776322 + size: 18439395 + timestamp: 1781148714198 - conda: https://conda.anaconda.org/conda-forge/win-64/python-3.14.2-h4b44e0e_100_cp314.conda build_number: 100 sha256: 6857d7c97cc71fe9ba298dcb1d3b66cc7df425132ab801babd655faa3df48f32 @@ -9541,6 +14554,74 @@ packages: size: 16833248 timestamp: 1765020224759 python_site_packages_path: Lib/site-packages +- conda: https://conda.anaconda.org/conda-forge/win-64/python-3.14.6-h4b44e0e_100_cp314.conda + build_number: 100 + sha256: f1acb89cb1a6bec9a94ae9f8e7411839de009cd64d3ac6a6aec4f3d8a481099a + md5: 8333e3ca6f8d1ebcd30b678dd53f0a25 + depends: + - bzip2 >=1.0.8,<2.0a0 + - libexpat >=2.8.1,<3.0a0 + - libffi >=3.5.2,<3.6.0a0 + - liblzma >=5.8.3,<6.0a0 + - libmpdec >=4.0.0,<5.0a0 + - libsqlite >=3.53.2,<4.0a0 + - libzlib >=1.3.2,<2.0a0 + - openssl >=3.5.7,<4.0a0 + - python_abi 3.14.* *_cp314 + - tk >=8.6.13,<8.7.0a0 + - tzdata + - ucrt >=10.0.20348.0 + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + - zstd >=1.5.7,<1.6.0a0 + license: Python-2.0 + purls: [] + size: 18481352 + timestamp: 1781256034828 + python_site_packages_path: Lib/site-packages +- conda: https://conda.anaconda.org/conda-forge/win-64/python-3.14.6-h7c1dbca_0_cp314t.conda + sha256: c53df5f2e8135cb3443279fd6b4de66ba81a20ee03188f7afc2affb711eb78cd + md5: e6cd651d30b56b0cce64b626c209dc30 + depends: + - bzip2 >=1.0.8,<2.0a0 + - libexpat >=2.8.1,<3.0a0 + - libffi >=3.5.2,<3.6.0a0 + - liblzma >=5.8.3,<6.0a0 + - libmpdec >=4.0.0,<5.0a0 + - libsqlite >=3.53.2,<4.0a0 + - libzlib >=1.3.2,<2.0a0 + - openssl >=3.5.7,<4.0a0 + - python_abi 3.14.* *_cp314t + - tk >=8.6.13,<8.7.0a0 + - tzdata + - ucrt >=10.0.20348.0 + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + - zstd >=1.5.7,<1.6.0a0 + license: Python-2.0 + purls: [] + size: 17928931 + timestamp: 1781256814063 + python_site_packages_path: Lib/site-packages +- conda: https://conda.anaconda.org/conda-forge/noarch/python-build-1.5.0-pyhc364b38_0.conda + sha256: eb8d5e44fddee9033eb7cfdd5ea584b7594b50e31c7602bef553af0fd4ee9266 + md5: fa587158c0d768127faa1a3b4df01e5d + depends: + - python >=3.10 + - colorama + - importlib-metadata >=4.6 + - packaging >=24.0 + - pyproject_hooks + - tomli >=1.1.0 + - python + constrains: + - build <0 + license: MIT + license_family: MIT + purls: + - pkg:pypi/build?source=hash-mapping + size: 28946 + timestamp: 1778048948266 - conda: https://conda.anaconda.org/conda-forge/noarch/python-dateutil-2.9.0.post0-pyhe01879c_2.conda sha256: d6a17ece93bbd5139e02d2bd7dbfa80bee1a4261dced63f65f679121686bf664 md5: 5b8d21249ff20967101ffa321cab24e8 @@ -9576,6 +14657,71 @@ packages: purls: [] size: 49287 timestamp: 1765020424843 +- conda: https://conda.anaconda.org/conda-forge/noarch/python-gil-3.14.6-h4df99d1_100.conda + sha256: 84c129bdd6abcecac42a948f2670d17fe735d02d3a5a483a9b1f1bc33ba38c28 + md5: 224f69f177eb5aae6c9a6052846bf609 + depends: + - cpython 3.14.6.* + - python_abi * *_cp314 + license: Python-2.0 + purls: [] + size: 49315 + timestamp: 1781254664376 +- conda: https://conda.anaconda.org/conda-forge/linux-64/python-librt-0.13.0-py314h3f2afee_0.conda + sha256: 9e833b92ecfa5855814d8378b448d6a654887d6454a844ebe3e21db8e94ebf72 + md5: 1c32847dee864bcda57d7ed1f6647318 + depends: + - python + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - python_abi 3.14.* *_cp314t + license: MIT + license_family: MIT + purls: + - pkg:pypi/librt?source=compressed-mapping + size: 169035 + timestamp: 1783529451535 +- conda: https://conda.anaconda.org/conda-forge/osx-64/python-librt-0.13.0-py314hef6ada0_0.conda + sha256: 77361e92e0d323fd61f8851ccf7fa1d5ccc8f9f5cea95002ca3fe56360556542 + md5: bc2f56cabbee5354b26d1abafe007a6a + depends: + - python + - __osx >=11.0 + - python_abi 3.14.* *_cp314t + license: MIT + license_family: MIT + purls: [] + size: 142307 + timestamp: 1783529622063 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/python-librt-0.13.0-py314ha14b1ff_0.conda + sha256: 0d5b3b303a091063a42ac72ddf39a9c31216217773cc15b2fc54f349cbc96f91 + md5: e5d073b8e272361036e77d0a00145965 + depends: + - python + - __osx >=11.0 + - python 3.14.* *_cp314 + - python_abi 3.14.* *_cp314 + license: MIT + license_family: MIT + purls: + - pkg:pypi/librt?source=hash-mapping + size: 135028 + timestamp: 1783529652113 +- conda: https://conda.anaconda.org/conda-forge/win-64/python-librt-0.13.0-py314h8f04a7f_0.conda + sha256: 182d19c9285b5cf3902439b40d2b0635b1a78c717004a0209b01cb326d10f445 + md5: 75c1aa014e65b275f8ae17f22d202788 + depends: + - python + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + - ucrt >=10.0.20348.0 + - python_abi 3.14.* *_cp314t + license: MIT + license_family: MIT + purls: + - pkg:pypi/librt?source=hash-mapping + size: 118382 + timestamp: 1783529491474 - conda: https://conda.anaconda.org/conda-forge/noarch/python-tzdata-2025.1-pyhd8ed1ab_0.conda sha256: 1597d6055d34e709ab8915091973552a0b8764c8032ede07c4e99670da029629 md5: 392c91c42edd569a7ec99ed8648f597a @@ -9593,21 +14739,22 @@ packages: depends: - python >=3.10 license: Apache-2.0 + license_family: APACHE purls: - pkg:pypi/tzdata?source=compressed-mapping size: 146862 timestamp: 1783704822814 -- conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.10-8_cp310.conda +- conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.11-8_cp311.conda build_number: 8 - sha256: 7ad76fa396e4bde336872350124c0819032a9e8a0a40590744ff9527b54351c1 - md5: 05e00f3b21e88bb3d658ac700b2ce58c + sha256: fddf123692aa4b1fc48f0471e346400d9852d96eeed77dbfdd746fa50a8ff894 + md5: 8fcb6b0e2161850556231336dae58358 constrains: - - python 3.10.* *_cpython + - python 3.11.* *_cpython license: BSD-3-Clause license_family: BSD purls: [] - size: 6999 - timestamp: 1752805924192 + size: 7003 + timestamp: 1752805919375 - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314.conda build_number: 8 sha256: ad6d2e9ac39751cc0529dd1566a26751a0bf2542adb0c232533d32e176e21db5 @@ -9619,6 +14766,17 @@ packages: purls: [] size: 6989 timestamp: 1752805904792 +- conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.14-8_cp314t.conda + build_number: 8 + sha256: d9ed2538fba61265a330ee1b1afe99a4bb23ace706172b9464546c7e01259d63 + md5: 3251796e09870c978e0f69fa05e38fb6 + constrains: + - python 3.14.* *_cp314t + license: BSD-3-Clause + license_family: BSD + purls: [] + size: 7020 + timestamp: 1752805919426 - conda: https://conda.anaconda.org/conda-forge/osx-64/python_abi-3.13-5_cp313.conda build_number: 5 sha256: 075ad768648e88b78d2a94099563b43d3082e7c35979f457164f26d1079b7b5c @@ -9671,6 +14829,59 @@ packages: - pkg:pypi/pywin32?source=hash-mapping size: 6713155 timestamp: 1756487145487 +- conda: https://conda.anaconda.org/conda-forge/win-64/pywin32-312-py314hcaaf0b2_0.conda + sha256: 71f9617186f5e2273bcefc4f3a258df5784886077ad36fe14f1d16b1c2c506eb + md5: 4d49ac91c23c4b1878daf5ea9e7c767a + depends: + - python + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + - ucrt >=10.0.20348.0 + - python_abi 3.14.* *_cp314 + license: PSF-2.0 + license_family: PSF + purls: + - pkg:pypi/pywin32?source=compressed-mapping + size: 4472831 + timestamp: 1781362876741 +- pypi: https://files.pythonhosted.org/packages/23/20/bb6982b26a40bb43951265ba29d4c246ef0ff59c9fdcdf0ed04e0687de4d/pyyaml-6.0.3-cp314-cp314-win_amd64.whl + name: pyyaml + version: 6.0.3 + sha256: 4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac + requires_python: '>=3.8' +- pypi: https://files.pythonhosted.org/packages/88/f9/16491d7ed2a919954993e48aa941b200f38040928474c9e85ea9e64222c3/pyyaml-6.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl + name: pyyaml + version: 6.0.3 + sha256: c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5 + requires_python: '>=3.8' +- pypi: https://files.pythonhosted.org/packages/9d/8c/f4bd7f6465179953d3ac9bc44ac1a8a3e6122cf8ada906b4f96c60172d43/pyyaml-6.0.3-cp314-cp314-macosx_10_13_x86_64.whl + name: pyyaml + version: 6.0.3 + sha256: 8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac + requires_python: '>=3.8' +- pypi: https://files.pythonhosted.org/packages/bd/9c/4d95bb87eb2063d20db7b60faa3840c1b18025517ae857371c4dd55a6b3a/pyyaml-6.0.3-cp314-cp314-macosx_11_0_arm64.whl + name: pyyaml + version: 6.0.3 + sha256: 34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310 + requires_python: '>=3.8' +- conda: https://conda.anaconda.org/conda-forge/linux-64/pyzmq-27.1.0-py312hda471dd_3.conda + noarch: python + sha256: 970b2a1d12983d8d1cc05d914ad88a0b6ef1fa14038c9649aa834dd6ebee65d7 + md5: acd216255e1370e9aeab5351b831f07c + depends: + - python + - libgcc >=14 + - libstdcxx >=14 + - __glibc >=2.17,<3.0.a0 + - _python_abi3_support 1.* + - cpython >=3.12 + - zeromq >=4.3.5,<4.4.0a0 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/pyzmq?source=hash-mapping + size: 210896 + timestamp: 1779483879367 - conda: https://conda.anaconda.org/conda-forge/linux-64/pyzmq-27.1.0-py312hfb55c3c_0.conda noarch: python sha256: a00a41b66c12d9c60e66b391e9a4832b7e28743348cf4b48b410b91927cd7819 @@ -9705,6 +14916,40 @@ packages: - pkg:pypi/pyzmq?source=hash-mapping size: 370198 timestamp: 1738271364103 +- conda: https://conda.anaconda.org/conda-forge/osx-64/pyzmq-27.1.0-py312h2ac7433_3.conda + noarch: python + sha256: 341551703ca138175ef37867c954dc5f72e3bec005b0d35e35db08db4d3fd26d + md5: 8380cc6b19de487e907529361f00f2ba + depends: + - python + - libcxx >=19 + - __osx >=11.0 + - _python_abi3_support 1.* + - cpython >=3.12 + - zeromq >=4.3.5,<4.4.0a0 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/pyzmq?source=compressed-mapping + size: 192531 + timestamp: 1779484028794 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/pyzmq-27.1.0-py312h022ad19_3.conda + noarch: python + sha256: 086cc67ec57afb7c9c09b5e09e7356b536b5b1af6c2e97117dc022cd22f0d472 + md5: 73f22bde4991f30ae2bfac3811577c15 + depends: + - python + - libcxx >=19 + - __osx >=11.0 + - zeromq >=4.3.5,<4.4.0a0 + - _python_abi3_support 1.* + - cpython >=3.12 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/pyzmq?source=hash-mapping + size: 191432 + timestamp: 1779484184540 - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pyzmq-27.1.0-py312hd65ceae_0.conda noarch: python sha256: ef33812c71eccf62ea171906c3e7fc1c8921f31e9cc1fbc3f079f3f074702061 @@ -9722,6 +14967,24 @@ packages: - pkg:pypi/pyzmq?source=hash-mapping size: 191115 timestamp: 1757387128258 +- conda: https://conda.anaconda.org/conda-forge/win-64/pyzmq-27.1.0-py312h343a6d4_3.conda + noarch: python + sha256: d7e65c44ea8a92f80cc0e424b4b7dbe63b8a9ec04ea774b7d4f7aed4c34cce4c + md5: ebbda9a4e5161d6e1f98146ad057dc10 + depends: + - python + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + - ucrt >=10.0.20348.0 + - _python_abi3_support 1.* + - cpython >=3.12 + - zeromq >=4.3.5,<4.3.6.0a0 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/pyzmq?source=compressed-mapping + size: 182831 + timestamp: 1779483925948 - conda: https://conda.anaconda.org/conda-forge/win-64/pyzmq-27.1.0-py312hbb5da91_0.conda noarch: python sha256: fd46b30e6a1e4c129045e3174446de3ca90da917a595037d28595532ab915c5d @@ -9849,6 +15112,79 @@ packages: purls: [] size: 57241105 timestamp: 1766486406643 +- conda: https://conda.anaconda.org/conda-forge/linux-64/qt6-main-6.11.1-pl5321h16c4a6b_1.conda + sha256: aefbc43bde188ff4027d480da99c7fa9e8e6341e9762e065190239cb9b99bb1c + md5: 331d660aef48fec733a878dd1f8f4206 + depends: + - libxcb + - xcb-util + - xcb-util-wm + - xcb-util-keysyms + - xcb-util-image + - xcb-util-renderutil + - xcb-util-cursor + - libgl-devel + - libegl-devel + - libgcc >=14 + - __glibc >=2.17,<3.0.a0 + - libstdcxx >=14 + - xcb-util >=0.4.1,<0.5.0a0 + - xorg-libx11 >=1.8.13,<2.0a0 + - pcre2 >=10.47,<10.48.0a0 + - libbrotlicommon >=1.2.0,<1.3.0a0 + - libbrotlienc >=1.2.0,<1.3.0a0 + - libbrotlidec >=1.2.0,<1.3.0a0 + - fontconfig >=2.18.1,<3.0a0 + - fonts-conda-ecosystem + - xorg-libxxf86vm >=1.1.7,<2.0a0 + - xorg-libxrandr >=1.5.5,<2.0a0 + - libsqlite >=3.53.2,<4.0a0 + - libpq >=18.4,<19.0a0 + - xorg-libice >=1.1.2,<2.0a0 + - libtiff >=4.7.1,<4.8.0a0 + - libfreetype >=2.14.3 + - libfreetype6 >=2.14.3 + - wayland >=1.25.0,<2.0a0 + - libzlib >=1.3.2,<2.0a0 + - libvulkan-loader >=1.4.341.0,<2.0a0 + - xorg-libxext >=1.3.7,<2.0a0 + - xcb-util-keysyms >=0.4.1,<0.5.0a0 + - libpng >=1.6.58,<1.7.0a0 + - harfbuzz >=14.2.1 + - xcb-util-cursor >=0.1.6,<0.2.0a0 + - xorg-libxcursor >=1.2.3,<2.0a0 + - libcups >=2.3.3,<2.4.0a0 + - libxcb >=1.17.0,<2.0a0 + - libjpeg-turbo >=3.1.4.1,<4.0a0 + - libdrm >=2.4.127,<2.5.0a0 + - xorg-libxcomposite >=0.4.7,<1.0a0 + - xcb-util-image >=0.4.0,<0.5.0a0 + - xcb-util-wm >=0.4.2,<0.5.0a0 + - zstd >=1.5.7,<1.6.0a0 + - krb5 >=1.22.2,<1.23.0a0 + - xcb-util-renderutil >=0.3.10,<0.4.0a0 + - icu >=78.3,<79.0a0 + - xorg-libxdamage >=1.1.6,<2.0a0 + - xorg-libsm >=1.2.6,<2.0a0 + - alsa-lib >=1.2.16,<1.3.0a0 + - openssl >=3.5.6,<4.0a0 + - libglib >=2.88.1,<3.0a0 + - libgl >=1.7.0,<2.0a0 + - libxkbcommon >=1.13.2,<2.0a0 + - libwebp-base >=1.6.0,<2.0a0 + - double-conversion >=3.4.0,<3.5.0a0 + - dbus >=1.16.2,<2.0a0 + - xorg-libxtst >=1.2.5,<2.0a0 + - libegl >=1.7.0,<2.0a0 + - libxml2 + - libxml2-16 >=2.14.6 + constrains: + - qt ==6.11.1 + license: LGPL-3.0-only + license_family: LGPL + purls: [] + size: 60185421 + timestamp: 1780593127053 - conda: https://conda.anaconda.org/conda-forge/win-64/qt6-main-6.10.1-h68b6638_4.conda sha256: d1f389aa0c0653d5af83e60da79ca6414d329707f236f110ff5e3329edb94f5a md5: c4a3cf4e79a59cb46ad2d56b74c89e57 @@ -9879,6 +15215,40 @@ packages: purls: [] size: 85571611 timestamp: 1766493849766 +- conda: https://conda.anaconda.org/conda-forge/win-64/qt6-main-6.11.1-pl5321hfcac499_1.conda + sha256: c0f0552a879e18282799431c7d2769b269839ac3b3735082e754df3c6fa0728d + md5: a8d735f3faf356a24acf9eea0a940a0f + depends: + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + - ucrt >=10.0.20348.0 + - krb5 >=1.22.2,<1.23.0a0 + - libglib >=2.88.1,<3.0a0 + - libpng >=1.6.58,<1.7.0a0 + - double-conversion >=3.4.0,<3.5.0a0 + - libbrotlicommon >=1.2.0,<1.3.0a0 + - libbrotlienc >=1.2.0,<1.3.0a0 + - libbrotlidec >=1.2.0,<1.3.0a0 + - libwebp-base >=1.6.0,<2.0a0 + - openssl >=3.5.6,<4.0a0 + - icu >=78.3,<79.0a0 + - libjpeg-turbo >=3.1.4.1,<4.0a0 + - pcre2 >=10.47,<10.48.0a0 + - libzlib >=1.3.2,<2.0a0 + - zstd >=1.5.7,<1.6.0a0 + - libfreetype >=2.14.3 + - libfreetype6 >=2.14.3 + - libvulkan-loader >=1.4.341.0,<2.0a0 + - libtiff >=4.7.1,<4.8.0a0 + - libsqlite >=3.53.1,<4.0a0 + - harfbuzz >=14.2.0 + constrains: + - qt ==6.11.1 + license: LGPL-3.0-only + license_family: LGPL + purls: [] + size: 89576886 + timestamp: 1780400596481 - conda: https://conda.anaconda.org/conda-forge/linux-64/readline-8.2-h8228510_1.conda sha256: 5435cf39d039387fbdc977b0a762357ea909a7694d9528ab40f005e9208744d7 md5: 47d31b792659ce70f470b5c82fdfb7a4 @@ -9944,6 +15314,18 @@ packages: purls: [] size: 313930 timestamp: 1765813902568 +- pypi: https://files.pythonhosted.org/packages/a0/f4/c67b0b3f1b9245e8d266f0f112c500d50e5b4e83cb6f3b71b6528104182a/requests-2.34.2-py3-none-any.whl + name: requests + version: 2.34.2 + sha256: 2a0d60c172f83ac6ab31e4554906c0f3b3588d37b5cb939b1c061f4907e278e0 + requires_dist: + - charset-normalizer>=2,<4 + - idna>=2.5,<4 + - urllib3>=1.26,<3 + - certifi>=2023.5.7 + - pysocks>=1.5.6,!=1.5.7 ; extra == 'socks' + - chardet>=3.0.2,<8 ; extra == 'use-chardet-on-py3' + requires_python: '>=3.10' - conda: https://conda.anaconda.org/conda-forge/noarch/requests-2.34.2-pyhcf101f3_0.conda sha256: 1715246b19c9f85ee022933b4845f2fc14ac9184981b7b7d9b728bec8e9588da md5: 4a85203c1d80c1059086ae860836ffb9 @@ -9959,9 +15341,70 @@ packages: license: Apache-2.0 license_family: APACHE purls: - - pkg:pypi/requests?source=compressed-mapping - size: 68709 - timestamp: 1778851103479 + - pkg:pypi/requests?source=compressed-mapping + size: 68709 + timestamp: 1778851103479 +- conda: https://conda.anaconda.org/conda-forge/linux-64/ruff-0.15.21-h6a952e8_0.conda + noarch: python + sha256: 2926c4f0adb88058e3d797c39cccc965bb4f1e0a3f582403b57fa83ea2f7e4af + md5: 469696f9c70885af30a0af1ce2e8c3a6 + depends: + - python + - libgcc >=14 + - __glibc >=2.17,<3.0.a0 + constrains: + - __glibc >=2.17 + license: MIT + license_family: MIT + purls: + - pkg:pypi/ruff?source=compressed-mapping + size: 9356259 + timestamp: 1783653725254 +- conda: https://conda.anaconda.org/conda-forge/osx-64/ruff-0.15.21-h1ddadc8_0.conda + noarch: python + sha256: d4b11da12053af472ed32eafc744b4eaa490ff8e4394b806b3f45778ca0c918e + md5: 3542ffffbe904a0a33eed5d345e314c1 + depends: + - python + - __osx >=11.0 + constrains: + - __osx >=10.13 + license: MIT + license_family: MIT + purls: + - pkg:pypi/ruff?source=hash-mapping + size: 9348629 + timestamp: 1783653896015 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/ruff-0.15.21-h80928e0_0.conda + noarch: python + sha256: 030f59aa0d9f4b0b1cc0583fb18a260a70d4f3c2b548e8378b109f2c750fad4b + md5: 802c895a8f535ce9342dc0c968a05ded + depends: + - python + - __osx >=11.0 + constrains: + - __osx >=11.0 + license: MIT + license_family: MIT + purls: + - pkg:pypi/ruff?source=hash-mapping + size: 8557660 + timestamp: 1783653958411 +- conda: https://conda.anaconda.org/conda-forge/win-64/ruff-0.15.21-h45713df_0.conda + noarch: python + sha256: 739964d918762bfc0c95d9d3863b6f632a0161a340a6d1d92ded8f11955e928d + md5: b0df8296d8d29cfcf267c64d48dd5d53 + depends: + - python + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + - ucrt >=10.0.20348.0 + license: MIT + license_family: MIT + purls: + - pkg:pypi/ruff?source=hash-mapping + size: 9846351 + timestamp: 1783653785431 - conda: https://conda.anaconda.org/conda-forge/linux-64/s2n-1.7.5-h7e3ee7f_1.conda sha256: 7369ac21f3561e2203f5b1600ef0671270057380783ca4b9e15f679ba25db575 md5: fa1c00d999e83ec20173c9775f71a1f1 @@ -9974,6 +15417,446 @@ packages: purls: [] size: 392607 timestamp: 1783164766248 +- pypi: https://files.pythonhosted.org/packages/3c/a7/552a7821597c632b907f7bfe8f36f9f572777af8ef8a48353041cf8e091a/scikit_learn-1.9.0-cp314-cp314-macosx_12_0_arm64.whl + name: scikit-learn + version: 1.9.0 + sha256: 24360002ae845e7866522b0a5bbf690802e7bc388cac8663502e78aa98598aa2 + requires_dist: + - numpy>=1.24.1 + - scipy>=1.10.0 + - joblib>=1.4.0 + - narwhals>=2.0.1 + - threadpoolctl>=3.5.0 + - numpy>=1.24.1 ; extra == 'build' + - scipy>=1.10.0 ; extra == 'build' + - cython>=3.1.2 ; extra == 'build' + - meson-python>=0.17.1 ; extra == 'build' + - numpy>=1.24.1 ; extra == 'install' + - scipy>=1.10.0 ; extra == 'install' + - joblib>=1.4.0 ; extra == 'install' + - narwhals>=2.0.1 ; extra == 'install' + - threadpoolctl>=3.5.0 ; extra == 'install' + - matplotlib>=3.6.1 ; extra == 'benchmark' + - pandas>=1.5.0 ; extra == 'benchmark' + - memory-profiler>=0.57.0 ; extra == 'benchmark' + - matplotlib>=3.6.1 ; extra == 'docs' + - scikit-image>=0.22.0 ; extra == 'docs' + - pandas>=1.5.0 ; extra == 'docs' + - rich>=14.1.0 ; extra == 'docs' + - seaborn>=0.13.0 ; extra == 'docs' + - memory-profiler>=0.57.0 ; extra == 'docs' + - sphinx>=7.3.7 ; extra == 'docs' + - sphinx-copybutton>=0.5.2 ; extra == 'docs' + - sphinx-gallery>=0.17.1 ; extra == 'docs' + - numpydoc>=1.2.0 ; extra == 'docs' + - pillow>=12.1.1 ; extra == 'docs' + - pooch>=1.8.0 ; extra == 'docs' + - sphinx-prompt>=1.4.0 ; extra == 'docs' + - sphinxext-opengraph>=0.9.1 ; extra == 'docs' + - plotly>=5.22.0 ; extra == 'docs' + - polars>=0.20.30 ; extra == 'docs' + - sphinx-design>=0.6.0 ; extra == 'docs' + - sphinxcontrib-sass>=0.3.4 ; extra == 'docs' + - pydata-sphinx-theme>=0.15.3 ; extra == 'docs' + - sphinx-remove-toctrees>=1.0.0.post1 ; extra == 'docs' + - towncrier>=24.8.0 ; extra == 'docs' + - matplotlib>=3.6.1 ; extra == 'examples' + - scikit-image>=0.22.0 ; extra == 'examples' + - pandas>=1.5.0 ; extra == 'examples' + - rich>=14.1.0 ; extra == 'examples' + - seaborn>=0.13.0 ; extra == 'examples' + - pooch>=1.8.0 ; extra == 'examples' + - plotly>=5.22.0 ; extra == 'examples' + - matplotlib>=3.6.1 ; extra == 'tests' + - pandas>=1.5.0 ; extra == 'tests' + - rich>=14.1.0 ; extra == 'tests' + - pytest>=7.1.2 ; extra == 'tests' + - pytest-cov>=2.9.0 ; extra == 'tests' + - ruff>=0.12.2 ; extra == 'tests' + - mypy>=1.15 ; extra == 'tests' + - pyamg>=5.0.0 ; extra == 'tests' + - polars>=0.20.30 ; extra == 'tests' + - pyarrow>=13.0.0 ; extra == 'tests' + - numpydoc>=1.2.0 ; extra == 'tests' + - pooch>=1.8.0 ; extra == 'tests' + - conda-lock==3.0.1 ; extra == 'maintenance' + requires_python: '>=3.11' +- pypi: https://files.pythonhosted.org/packages/a2/d5/6a58eea2cb9abbb9b3f2bb8b2cfb3243d1152d69f442d256c7af71304769/scikit_learn-1.9.0-cp314-cp314-win_amd64.whl + name: scikit-learn + version: 1.9.0 + sha256: 64fa347efc1c839c487433e40c5144d38c336e8a2b59c81aa8660373945c2673 + requires_dist: + - numpy>=1.24.1 + - scipy>=1.10.0 + - joblib>=1.4.0 + - narwhals>=2.0.1 + - threadpoolctl>=3.5.0 + - numpy>=1.24.1 ; extra == 'build' + - scipy>=1.10.0 ; extra == 'build' + - cython>=3.1.2 ; extra == 'build' + - meson-python>=0.17.1 ; extra == 'build' + - numpy>=1.24.1 ; extra == 'install' + - scipy>=1.10.0 ; extra == 'install' + - joblib>=1.4.0 ; extra == 'install' + - narwhals>=2.0.1 ; extra == 'install' + - threadpoolctl>=3.5.0 ; extra == 'install' + - matplotlib>=3.6.1 ; extra == 'benchmark' + - pandas>=1.5.0 ; extra == 'benchmark' + - memory-profiler>=0.57.0 ; extra == 'benchmark' + - matplotlib>=3.6.1 ; extra == 'docs' + - scikit-image>=0.22.0 ; extra == 'docs' + - pandas>=1.5.0 ; extra == 'docs' + - rich>=14.1.0 ; extra == 'docs' + - seaborn>=0.13.0 ; extra == 'docs' + - memory-profiler>=0.57.0 ; extra == 'docs' + - sphinx>=7.3.7 ; extra == 'docs' + - sphinx-copybutton>=0.5.2 ; extra == 'docs' + - sphinx-gallery>=0.17.1 ; extra == 'docs' + - numpydoc>=1.2.0 ; extra == 'docs' + - pillow>=12.1.1 ; extra == 'docs' + - pooch>=1.8.0 ; extra == 'docs' + - sphinx-prompt>=1.4.0 ; extra == 'docs' + - sphinxext-opengraph>=0.9.1 ; extra == 'docs' + - plotly>=5.22.0 ; extra == 'docs' + - polars>=0.20.30 ; extra == 'docs' + - sphinx-design>=0.6.0 ; extra == 'docs' + - sphinxcontrib-sass>=0.3.4 ; extra == 'docs' + - pydata-sphinx-theme>=0.15.3 ; extra == 'docs' + - sphinx-remove-toctrees>=1.0.0.post1 ; extra == 'docs' + - towncrier>=24.8.0 ; extra == 'docs' + - matplotlib>=3.6.1 ; extra == 'examples' + - scikit-image>=0.22.0 ; extra == 'examples' + - pandas>=1.5.0 ; extra == 'examples' + - rich>=14.1.0 ; extra == 'examples' + - seaborn>=0.13.0 ; extra == 'examples' + - pooch>=1.8.0 ; extra == 'examples' + - plotly>=5.22.0 ; extra == 'examples' + - matplotlib>=3.6.1 ; extra == 'tests' + - pandas>=1.5.0 ; extra == 'tests' + - rich>=14.1.0 ; extra == 'tests' + - pytest>=7.1.2 ; extra == 'tests' + - pytest-cov>=2.9.0 ; extra == 'tests' + - ruff>=0.12.2 ; extra == 'tests' + - mypy>=1.15 ; extra == 'tests' + - pyamg>=5.0.0 ; extra == 'tests' + - polars>=0.20.30 ; extra == 'tests' + - pyarrow>=13.0.0 ; extra == 'tests' + - numpydoc>=1.2.0 ; extra == 'tests' + - pooch>=1.8.0 ; extra == 'tests' + - conda-lock==3.0.1 ; extra == 'maintenance' + requires_python: '>=3.11' +- pypi: https://files.pythonhosted.org/packages/f0/af/4d72d9e475ac83719160c662619e4bf7b95c19507cd582e7d0167a3c3dae/scikit_learn-1.9.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl + name: scikit-learn + version: 1.9.0 + sha256: 1fea2cc5677ab49d6f5bade978c866da44957b712d92e9635e8b4f723013c3cb + requires_dist: + - numpy>=1.24.1 + - scipy>=1.10.0 + - joblib>=1.4.0 + - narwhals>=2.0.1 + - threadpoolctl>=3.5.0 + - numpy>=1.24.1 ; extra == 'build' + - scipy>=1.10.0 ; extra == 'build' + - cython>=3.1.2 ; extra == 'build' + - meson-python>=0.17.1 ; extra == 'build' + - numpy>=1.24.1 ; extra == 'install' + - scipy>=1.10.0 ; extra == 'install' + - joblib>=1.4.0 ; extra == 'install' + - narwhals>=2.0.1 ; extra == 'install' + - threadpoolctl>=3.5.0 ; extra == 'install' + - matplotlib>=3.6.1 ; extra == 'benchmark' + - pandas>=1.5.0 ; extra == 'benchmark' + - memory-profiler>=0.57.0 ; extra == 'benchmark' + - matplotlib>=3.6.1 ; extra == 'docs' + - scikit-image>=0.22.0 ; extra == 'docs' + - pandas>=1.5.0 ; extra == 'docs' + - rich>=14.1.0 ; extra == 'docs' + - seaborn>=0.13.0 ; extra == 'docs' + - memory-profiler>=0.57.0 ; extra == 'docs' + - sphinx>=7.3.7 ; extra == 'docs' + - sphinx-copybutton>=0.5.2 ; extra == 'docs' + - sphinx-gallery>=0.17.1 ; extra == 'docs' + - numpydoc>=1.2.0 ; extra == 'docs' + - pillow>=12.1.1 ; extra == 'docs' + - pooch>=1.8.0 ; extra == 'docs' + - sphinx-prompt>=1.4.0 ; extra == 'docs' + - sphinxext-opengraph>=0.9.1 ; extra == 'docs' + - plotly>=5.22.0 ; extra == 'docs' + - polars>=0.20.30 ; extra == 'docs' + - sphinx-design>=0.6.0 ; extra == 'docs' + - sphinxcontrib-sass>=0.3.4 ; extra == 'docs' + - pydata-sphinx-theme>=0.15.3 ; extra == 'docs' + - sphinx-remove-toctrees>=1.0.0.post1 ; extra == 'docs' + - towncrier>=24.8.0 ; extra == 'docs' + - matplotlib>=3.6.1 ; extra == 'examples' + - scikit-image>=0.22.0 ; extra == 'examples' + - pandas>=1.5.0 ; extra == 'examples' + - rich>=14.1.0 ; extra == 'examples' + - seaborn>=0.13.0 ; extra == 'examples' + - pooch>=1.8.0 ; extra == 'examples' + - plotly>=5.22.0 ; extra == 'examples' + - matplotlib>=3.6.1 ; extra == 'tests' + - pandas>=1.5.0 ; extra == 'tests' + - rich>=14.1.0 ; extra == 'tests' + - pytest>=7.1.2 ; extra == 'tests' + - pytest-cov>=2.9.0 ; extra == 'tests' + - ruff>=0.12.2 ; extra == 'tests' + - mypy>=1.15 ; extra == 'tests' + - pyamg>=5.0.0 ; extra == 'tests' + - polars>=0.20.30 ; extra == 'tests' + - pyarrow>=13.0.0 ; extra == 'tests' + - numpydoc>=1.2.0 ; extra == 'tests' + - pooch>=1.8.0 ; extra == 'tests' + - conda-lock==3.0.1 ; extra == 'maintenance' + requires_python: '>=3.11' +- pypi: https://files.pythonhosted.org/packages/f4/7d/c9a35cf59b20a86fec24d306f1547b78dec194b08d367ce2a3e4854169d9/scikit_learn-1.9.0-cp314-cp314-macosx_10_15_x86_64.whl + name: scikit-learn + version: 1.9.0 + sha256: 9656acd4e93f74e0b66c8a36c88830a99252dfa900044d36bc2212ae89a47162 + requires_dist: + - numpy>=1.24.1 + - scipy>=1.10.0 + - joblib>=1.4.0 + - narwhals>=2.0.1 + - threadpoolctl>=3.5.0 + - numpy>=1.24.1 ; extra == 'build' + - scipy>=1.10.0 ; extra == 'build' + - cython>=3.1.2 ; extra == 'build' + - meson-python>=0.17.1 ; extra == 'build' + - numpy>=1.24.1 ; extra == 'install' + - scipy>=1.10.0 ; extra == 'install' + - joblib>=1.4.0 ; extra == 'install' + - narwhals>=2.0.1 ; extra == 'install' + - threadpoolctl>=3.5.0 ; extra == 'install' + - matplotlib>=3.6.1 ; extra == 'benchmark' + - pandas>=1.5.0 ; extra == 'benchmark' + - memory-profiler>=0.57.0 ; extra == 'benchmark' + - matplotlib>=3.6.1 ; extra == 'docs' + - scikit-image>=0.22.0 ; extra == 'docs' + - pandas>=1.5.0 ; extra == 'docs' + - rich>=14.1.0 ; extra == 'docs' + - seaborn>=0.13.0 ; extra == 'docs' + - memory-profiler>=0.57.0 ; extra == 'docs' + - sphinx>=7.3.7 ; extra == 'docs' + - sphinx-copybutton>=0.5.2 ; extra == 'docs' + - sphinx-gallery>=0.17.1 ; extra == 'docs' + - numpydoc>=1.2.0 ; extra == 'docs' + - pillow>=12.1.1 ; extra == 'docs' + - pooch>=1.8.0 ; extra == 'docs' + - sphinx-prompt>=1.4.0 ; extra == 'docs' + - sphinxext-opengraph>=0.9.1 ; extra == 'docs' + - plotly>=5.22.0 ; extra == 'docs' + - polars>=0.20.30 ; extra == 'docs' + - sphinx-design>=0.6.0 ; extra == 'docs' + - sphinxcontrib-sass>=0.3.4 ; extra == 'docs' + - pydata-sphinx-theme>=0.15.3 ; extra == 'docs' + - sphinx-remove-toctrees>=1.0.0.post1 ; extra == 'docs' + - towncrier>=24.8.0 ; extra == 'docs' + - matplotlib>=3.6.1 ; extra == 'examples' + - scikit-image>=0.22.0 ; extra == 'examples' + - pandas>=1.5.0 ; extra == 'examples' + - rich>=14.1.0 ; extra == 'examples' + - seaborn>=0.13.0 ; extra == 'examples' + - pooch>=1.8.0 ; extra == 'examples' + - plotly>=5.22.0 ; extra == 'examples' + - matplotlib>=3.6.1 ; extra == 'tests' + - pandas>=1.5.0 ; extra == 'tests' + - rich>=14.1.0 ; extra == 'tests' + - pytest>=7.1.2 ; extra == 'tests' + - pytest-cov>=2.9.0 ; extra == 'tests' + - ruff>=0.12.2 ; extra == 'tests' + - mypy>=1.15 ; extra == 'tests' + - pyamg>=5.0.0 ; extra == 'tests' + - polars>=0.20.30 ; extra == 'tests' + - pyarrow>=13.0.0 ; extra == 'tests' + - numpydoc>=1.2.0 ; extra == 'tests' + - pooch>=1.8.0 ; extra == 'tests' + - conda-lock==3.0.1 ; extra == 'maintenance' + requires_python: '>=3.11' +- pypi: https://files.pythonhosted.org/packages/78/b5/915a19b3de2f7430062b509653563db1633ddbb6f021b06731521115d4e2/scipy-1.18.0-cp314-cp314-macosx_10_15_x86_64.whl + name: scipy + version: 1.18.0 + sha256: 4c256ee70c0d1a8a2ace807e199ccd4e3f57037433842abb3fb36bc17eaa9578 + requires_dist: + - numpy>=2.0.0,<2.8 + - pytest>=8.0.0 ; extra == 'test' + - pytest-cov ; extra == 'test' + - pytest-timeout ; extra == 'test' + - pytest-xdist ; extra == 'test' + - asv ; extra == 'test' + - mpmath ; extra == 'test' + - gmpy2 ; extra == 'test' + - threadpoolctl ; extra == 'test' + - scikit-umfpack ; extra == 'test' + - pooch ; extra == 'test' + - hypothesis>=6.30 ; extra == 'test' + - array-api-strict>=2.3.1 ; extra == 'test' + - cython ; extra == 'test' + - meson ; extra == 'test' + - ninja ; sys_platform != 'emscripten' and extra == 'test' + - scipy-doctest>=2.0.0 ; extra == 'test' + - sphinx>=5.0.0,<8.2.0 ; extra == 'doc' + - intersphinx-registry ; extra == 'doc' + - pydata-sphinx-theme>=0.15.2 ; extra == 'doc' + - sphinx-copybutton ; extra == 'doc' + - sphinx-design>=0.4.0 ; extra == 'doc' + - matplotlib>=3.5 ; extra == 'doc' + - numpydoc ; extra == 'doc' + - jupytext ; extra == 'doc' + - myst-nb>=1.2.0 ; extra == 'doc' + - pooch ; extra == 'doc' + - jupyterlite-sphinx>=0.19.1 ; extra == 'doc' + - jupyterlite-pyodide-kernel ; extra == 'doc' + - linkify-it-py ; extra == 'doc' + - tabulate ; extra == 'doc' + - click<8.3.0 ; extra == 'dev' + - spin ; extra == 'dev' + - mypy==1.19.1 ; extra == 'dev' + - pyrefly==0.63.0 ; extra == 'dev' + - typing-extensions ; extra == 'dev' + - types-psutil ; extra == 'dev' + - pycodestyle ; extra == 'dev' + - ruff>=0.12.0 ; extra == 'dev' + - cython-lint>=0.12.2 ; extra == 'dev' + requires_python: '>=3.12' +- pypi: https://files.pythonhosted.org/packages/7f/c4/bc41eb19b0fd0db868f4132920879019318d80cc522ad8f2bca4611af808/scipy-1.18.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl + name: scipy + version: 1.18.0 + sha256: 8ca01e8ae69f1b18e9a58d91afead31be3cef0dd905a10249dac559ee15460a0 + requires_dist: + - numpy>=2.0.0,<2.8 + - pytest>=8.0.0 ; extra == 'test' + - pytest-cov ; extra == 'test' + - pytest-timeout ; extra == 'test' + - pytest-xdist ; extra == 'test' + - asv ; extra == 'test' + - mpmath ; extra == 'test' + - gmpy2 ; extra == 'test' + - threadpoolctl ; extra == 'test' + - scikit-umfpack ; extra == 'test' + - pooch ; extra == 'test' + - hypothesis>=6.30 ; extra == 'test' + - array-api-strict>=2.3.1 ; extra == 'test' + - cython ; extra == 'test' + - meson ; extra == 'test' + - ninja ; sys_platform != 'emscripten' and extra == 'test' + - scipy-doctest>=2.0.0 ; extra == 'test' + - sphinx>=5.0.0,<8.2.0 ; extra == 'doc' + - intersphinx-registry ; extra == 'doc' + - pydata-sphinx-theme>=0.15.2 ; extra == 'doc' + - sphinx-copybutton ; extra == 'doc' + - sphinx-design>=0.4.0 ; extra == 'doc' + - matplotlib>=3.5 ; extra == 'doc' + - numpydoc ; extra == 'doc' + - jupytext ; extra == 'doc' + - myst-nb>=1.2.0 ; extra == 'doc' + - pooch ; extra == 'doc' + - jupyterlite-sphinx>=0.19.1 ; extra == 'doc' + - jupyterlite-pyodide-kernel ; extra == 'doc' + - linkify-it-py ; extra == 'doc' + - tabulate ; extra == 'doc' + - click<8.3.0 ; extra == 'dev' + - spin ; extra == 'dev' + - mypy==1.19.1 ; extra == 'dev' + - pyrefly==0.63.0 ; extra == 'dev' + - typing-extensions ; extra == 'dev' + - types-psutil ; extra == 'dev' + - pycodestyle ; extra == 'dev' + - ruff>=0.12.0 ; extra == 'dev' + - cython-lint>=0.12.2 ; extra == 'dev' + requires_python: '>=3.12' +- pypi: https://files.pythonhosted.org/packages/93/3e/902d836831474b0ab5a37d16404f7bc5fafd9efba632890e271ba952635f/scipy-1.18.0-cp314-cp314-win_amd64.whl + name: scipy + version: 1.18.0 + sha256: 2d8bbdc6c817f5b4006a54d799d4f5bab6f910193cbb9a1ff310833d4d270f61 + requires_dist: + - numpy>=2.0.0,<2.8 + - pytest>=8.0.0 ; extra == 'test' + - pytest-cov ; extra == 'test' + - pytest-timeout ; extra == 'test' + - pytest-xdist ; extra == 'test' + - asv ; extra == 'test' + - mpmath ; extra == 'test' + - gmpy2 ; extra == 'test' + - threadpoolctl ; extra == 'test' + - scikit-umfpack ; extra == 'test' + - pooch ; extra == 'test' + - hypothesis>=6.30 ; extra == 'test' + - array-api-strict>=2.3.1 ; extra == 'test' + - cython ; extra == 'test' + - meson ; extra == 'test' + - ninja ; sys_platform != 'emscripten' and extra == 'test' + - scipy-doctest>=2.0.0 ; extra == 'test' + - sphinx>=5.0.0,<8.2.0 ; extra == 'doc' + - intersphinx-registry ; extra == 'doc' + - pydata-sphinx-theme>=0.15.2 ; extra == 'doc' + - sphinx-copybutton ; extra == 'doc' + - sphinx-design>=0.4.0 ; extra == 'doc' + - matplotlib>=3.5 ; extra == 'doc' + - numpydoc ; extra == 'doc' + - jupytext ; extra == 'doc' + - myst-nb>=1.2.0 ; extra == 'doc' + - pooch ; extra == 'doc' + - jupyterlite-sphinx>=0.19.1 ; extra == 'doc' + - jupyterlite-pyodide-kernel ; extra == 'doc' + - linkify-it-py ; extra == 'doc' + - tabulate ; extra == 'doc' + - click<8.3.0 ; extra == 'dev' + - spin ; extra == 'dev' + - mypy==1.19.1 ; extra == 'dev' + - pyrefly==0.63.0 ; extra == 'dev' + - typing-extensions ; extra == 'dev' + - types-psutil ; extra == 'dev' + - pycodestyle ; extra == 'dev' + - ruff>=0.12.0 ; extra == 'dev' + - cython-lint>=0.12.2 ; extra == 'dev' + requires_python: '>=3.12' +- pypi: https://files.pythonhosted.org/packages/d7/88/b72def7262e150d16be13fca37a96481138d624e700340bc3362a7588929/scipy-1.18.0-cp314-cp314-macosx_12_0_arm64.whl + name: scipy + version: 1.18.0 + sha256: 2ef3abc54a4ffc53765374b0d5728532dfdd2585ed23f6b11c206a1f0b1b9af8 + requires_dist: + - numpy>=2.0.0,<2.8 + - pytest>=8.0.0 ; extra == 'test' + - pytest-cov ; extra == 'test' + - pytest-timeout ; extra == 'test' + - pytest-xdist ; extra == 'test' + - asv ; extra == 'test' + - mpmath ; extra == 'test' + - gmpy2 ; extra == 'test' + - threadpoolctl ; extra == 'test' + - scikit-umfpack ; extra == 'test' + - pooch ; extra == 'test' + - hypothesis>=6.30 ; extra == 'test' + - array-api-strict>=2.3.1 ; extra == 'test' + - cython ; extra == 'test' + - meson ; extra == 'test' + - ninja ; sys_platform != 'emscripten' and extra == 'test' + - scipy-doctest>=2.0.0 ; extra == 'test' + - sphinx>=5.0.0,<8.2.0 ; extra == 'doc' + - intersphinx-registry ; extra == 'doc' + - pydata-sphinx-theme>=0.15.2 ; extra == 'doc' + - sphinx-copybutton ; extra == 'doc' + - sphinx-design>=0.4.0 ; extra == 'doc' + - matplotlib>=3.5 ; extra == 'doc' + - numpydoc ; extra == 'doc' + - jupytext ; extra == 'doc' + - myst-nb>=1.2.0 ; extra == 'doc' + - pooch ; extra == 'doc' + - jupyterlite-sphinx>=0.19.1 ; extra == 'doc' + - jupyterlite-pyodide-kernel ; extra == 'doc' + - linkify-it-py ; extra == 'doc' + - tabulate ; extra == 'doc' + - click<8.3.0 ; extra == 'dev' + - spin ; extra == 'dev' + - mypy==1.19.1 ; extra == 'dev' + - pyrefly==0.63.0 ; extra == 'dev' + - typing-extensions ; extra == 'dev' + - types-psutil ; extra == 'dev' + - pycodestyle ; extra == 'dev' + - ruff>=0.12.0 ; extra == 'dev' + - cython-lint>=0.12.2 ; extra == 'dev' + requires_python: '>=3.12' - conda: https://conda.anaconda.org/conda-forge/noarch/six-1.17.0-pyhd8ed1ab_0.conda sha256: 41db0180680cc67c3fa76544ffd48d6a5679d96f4b71d7498a759e94edc9a2db md5: a451d576819089b0d672f18768be0f65 @@ -9997,6 +15880,102 @@ packages: - pkg:pypi/six?source=hash-mapping size: 18455 timestamp: 1753199211006 +- pypi: https://files.pythonhosted.org/packages/0e/0f/e1e6e952b7916b9897b63ac53894b7a5d1d8616be6884d48bee7103cd8c9/skyborn-0.4.2.tar.gz + name: skyborn + version: 0.4.2 + sha256: 5476347cd6dfcfeb5e53948b0e74f61120a4c13c0b1b9bc6dd9478bd2604876c + requires_dist: + - numpy + - pandas + - xarray + - matplotlib + - netcdf4 + - metpy + - tqdm + - statsmodels + - scipy + - scikit-learn + - dask + - skyborn-cdo>=2.6.0.3 ; (platform_machine == 'AMD64' and sys_platform == 'win32' and extra == 'cdo') or (platform_machine == 'arm64' and sys_platform == 'darwin' and extra == 'cdo') or (platform_machine == 'x86_64' and sys_platform == 'linux' and extra == 'cdo') + - cfgrib ; extra == 'grib' + - eccodes ; extra == 'grib' + - pytest>=7.4.4 ; extra == 'dev' + - pytest-cov>=4.1.0 ; extra == 'dev' + - black>=22.12.0 ; extra == 'dev' + - flake8>=5.0.4 ; extra == 'dev' + - mypy>=1.19.1 ; extra == 'dev' + - jupyterlab>=3.6.8 ; extra == 'dev' + - pymannkendall>=1.4.3 ; extra == 'dev' + - sphinx>=5.3.0 ; extra == 'docs' + - sphinx-book-theme>=1.1.4 ; extra == 'docs' + - myst-nb>=0.17.2 ; extra == 'docs' + - sphinx-copybutton>=0.5.2 ; extra == 'docs' + - toml>=0.10.2 ; extra == 'docs' + requires_python: '>=3.9' +- pypi: https://files.pythonhosted.org/packages/52/83/fbb44fd413ea8b735c07c335d6f0e3f430e61fd9d062186f30d4b70c68b8/skyborn-0.4.2-cp314-cp314-win_amd64.whl + name: skyborn + version: 0.4.2 + sha256: 12edf7add9d4e424f73edd609c7292065568e4300ec2186bfdd091cbc3cea4c7 + requires_dist: + - numpy + - pandas + - xarray + - matplotlib + - netcdf4 + - metpy + - tqdm + - statsmodels + - scipy + - scikit-learn + - dask + - skyborn-cdo>=2.6.0.3 ; (platform_machine == 'AMD64' and sys_platform == 'win32' and extra == 'cdo') or (platform_machine == 'arm64' and sys_platform == 'darwin' and extra == 'cdo') or (platform_machine == 'x86_64' and sys_platform == 'linux' and extra == 'cdo') + - cfgrib ; extra == 'grib' + - eccodes ; extra == 'grib' + - pytest>=7.4.4 ; extra == 'dev' + - pytest-cov>=4.1.0 ; extra == 'dev' + - black>=22.12.0 ; extra == 'dev' + - flake8>=5.0.4 ; extra == 'dev' + - mypy>=1.19.1 ; extra == 'dev' + - jupyterlab>=3.6.8 ; extra == 'dev' + - pymannkendall>=1.4.3 ; extra == 'dev' + - sphinx>=5.3.0 ; extra == 'docs' + - sphinx-book-theme>=1.1.4 ; extra == 'docs' + - myst-nb>=0.17.2 ; extra == 'docs' + - sphinx-copybutton>=0.5.2 ; extra == 'docs' + - toml>=0.10.2 ; extra == 'docs' + requires_python: '>=3.9' +- pypi: https://files.pythonhosted.org/packages/d3/78/417531e464cf9507b2092da31fb86dde4019a25390b204e0d67953ccb444/skyborn-0.4.2-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl + name: skyborn + version: 0.4.2 + sha256: 72a870383ef471b8c773c1f2d10b4c2ab9b2fa873245ffaaa0f86905113fe735 + requires_dist: + - numpy + - pandas + - xarray + - matplotlib + - netcdf4 + - metpy + - tqdm + - statsmodels + - scipy + - scikit-learn + - dask + - skyborn-cdo>=2.6.0.3 ; (platform_machine == 'AMD64' and sys_platform == 'win32' and extra == 'cdo') or (platform_machine == 'arm64' and sys_platform == 'darwin' and extra == 'cdo') or (platform_machine == 'x86_64' and sys_platform == 'linux' and extra == 'cdo') + - cfgrib ; extra == 'grib' + - eccodes ; extra == 'grib' + - pytest>=7.4.4 ; extra == 'dev' + - pytest-cov>=4.1.0 ; extra == 'dev' + - black>=22.12.0 ; extra == 'dev' + - flake8>=5.0.4 ; extra == 'dev' + - mypy>=1.19.1 ; extra == 'dev' + - jupyterlab>=3.6.8 ; extra == 'dev' + - pymannkendall>=1.4.3 ; extra == 'dev' + - sphinx>=5.3.0 ; extra == 'docs' + - sphinx-book-theme>=1.1.4 ; extra == 'docs' + - myst-nb>=0.17.2 ; extra == 'docs' + - sphinx-copybutton>=0.5.2 ; extra == 'docs' + - toml>=0.10.2 ; extra == 'docs' + requires_python: '>=3.9' - conda: https://conda.anaconda.org/conda-forge/noarch/stack_data-0.6.3-pyhd8ed1ab_1.conda sha256: 570da295d421661af487f1595045760526964f41471021056e993e73089e9c41 md5: b1b505328da7a6b246787df4b5a49fbc @@ -10011,6 +15990,142 @@ packages: - pkg:pypi/stack-data?source=hash-mapping size: 26988 timestamp: 1733569565672 +- pypi: https://files.pythonhosted.org/packages/26/33/f1652d0c59fa51de18492ee2345b65372550501ad061daa38f950be390b6/statsmodels-0.14.6-cp314-cp314-win_amd64.whl + name: statsmodels + version: 0.14.6 + sha256: 151b73e29f01fe619dbce7f66d61a356e9d1fe5e906529b78807df9189c37721 + requires_dist: + - numpy>=1.22.3,<3 + - scipy>=1.8,!=1.9.2 + - pandas>=1.4,!=2.1.0 + - patsy>=0.5.6 + - packaging>=21.3 + - cython>=3.0.10 ; extra == 'build' + - cython>=3.0.10 ; extra == 'develop' + - cython>=3.0.10,<4 ; extra == 'develop' + - setuptools-scm[toml]~=8.0 ; extra == 'develop' + - matplotlib>=3 ; extra == 'develop' + - colorama ; extra == 'develop' + - joblib ; extra == 'develop' + - jinja2 ; extra == 'develop' + - pytest>=7.3.0,<8 ; extra == 'develop' + - pytest-randomly ; extra == 'develop' + - pytest-xdist ; extra == 'develop' + - pytest-cov ; extra == 'develop' + - pywinpty ; os_name == 'nt' and extra == 'develop' + - flake8 ; extra == 'develop' + - isort ; extra == 'develop' + - sphinx ; extra == 'docs' + - nbconvert ; extra == 'docs' + - jupyter-client ; extra == 'docs' + - ipykernel ; extra == 'docs' + - matplotlib ; extra == 'docs' + - nbformat ; extra == 'docs' + - numpydoc ; extra == 'docs' + - pandas-datareader ; extra == 'docs' + requires_python: '>=3.9' +- pypi: https://files.pythonhosted.org/packages/34/0e/2408735aca9e764643196212f9069912100151414dd617d39ffc72d77eee/statsmodels-0.14.6-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl + name: statsmodels + version: 0.14.6 + sha256: 3414e40c073d725007a6603a18247ab7af3467e1af4a5e5a24e4c27bc26673b4 + requires_dist: + - numpy>=1.22.3,<3 + - scipy>=1.8,!=1.9.2 + - pandas>=1.4,!=2.1.0 + - patsy>=0.5.6 + - packaging>=21.3 + - cython>=3.0.10 ; extra == 'build' + - cython>=3.0.10 ; extra == 'develop' + - cython>=3.0.10,<4 ; extra == 'develop' + - setuptools-scm[toml]~=8.0 ; extra == 'develop' + - matplotlib>=3 ; extra == 'develop' + - colorama ; extra == 'develop' + - joblib ; extra == 'develop' + - jinja2 ; extra == 'develop' + - pytest>=7.3.0,<8 ; extra == 'develop' + - pytest-randomly ; extra == 'develop' + - pytest-xdist ; extra == 'develop' + - pytest-cov ; extra == 'develop' + - pywinpty ; os_name == 'nt' and extra == 'develop' + - flake8 ; extra == 'develop' + - isort ; extra == 'develop' + - sphinx ; extra == 'docs' + - nbconvert ; extra == 'docs' + - jupyter-client ; extra == 'docs' + - ipykernel ; extra == 'docs' + - matplotlib ; extra == 'docs' + - nbformat ; extra == 'docs' + - numpydoc ; extra == 'docs' + - pandas-datareader ; extra == 'docs' + requires_python: '>=3.9' +- pypi: https://files.pythonhosted.org/packages/71/de/09540e870318e0c7b58316561d417be45eff731263b4234fdd2eee3511a8/statsmodels-0.14.6-cp314-cp314-macosx_10_15_x86_64.whl + name: statsmodels + version: 0.14.6 + sha256: 00781869991f8f02ad3610da6627fd26ebe262210287beb59761982a8fa88cae + requires_dist: + - numpy>=1.22.3,<3 + - scipy>=1.8,!=1.9.2 + - pandas>=1.4,!=2.1.0 + - patsy>=0.5.6 + - packaging>=21.3 + - cython>=3.0.10 ; extra == 'build' + - cython>=3.0.10 ; extra == 'develop' + - cython>=3.0.10,<4 ; extra == 'develop' + - setuptools-scm[toml]~=8.0 ; extra == 'develop' + - matplotlib>=3 ; extra == 'develop' + - colorama ; extra == 'develop' + - joblib ; extra == 'develop' + - jinja2 ; extra == 'develop' + - pytest>=7.3.0,<8 ; extra == 'develop' + - pytest-randomly ; extra == 'develop' + - pytest-xdist ; extra == 'develop' + - pytest-cov ; extra == 'develop' + - pywinpty ; os_name == 'nt' and extra == 'develop' + - flake8 ; extra == 'develop' + - isort ; extra == 'develop' + - sphinx ; extra == 'docs' + - nbconvert ; extra == 'docs' + - jupyter-client ; extra == 'docs' + - ipykernel ; extra == 'docs' + - matplotlib ; extra == 'docs' + - nbformat ; extra == 'docs' + - numpydoc ; extra == 'docs' + - pandas-datareader ; extra == 'docs' + requires_python: '>=3.9' +- pypi: https://files.pythonhosted.org/packages/ab/f0/63c1bfda75dc53cee858006e1f46bd6d6f883853bea1b97949d0087766ca/statsmodels-0.14.6-cp314-cp314-macosx_11_0_arm64.whl + name: statsmodels + version: 0.14.6 + sha256: 73f305fbf31607b35ce919fae636ab8b80d175328ed38fdc6f354e813b86ee37 + requires_dist: + - numpy>=1.22.3,<3 + - scipy>=1.8,!=1.9.2 + - pandas>=1.4,!=2.1.0 + - patsy>=0.5.6 + - packaging>=21.3 + - cython>=3.0.10 ; extra == 'build' + - cython>=3.0.10 ; extra == 'develop' + - cython>=3.0.10,<4 ; extra == 'develop' + - setuptools-scm[toml]~=8.0 ; extra == 'develop' + - matplotlib>=3 ; extra == 'develop' + - colorama ; extra == 'develop' + - joblib ; extra == 'develop' + - jinja2 ; extra == 'develop' + - pytest>=7.3.0,<8 ; extra == 'develop' + - pytest-randomly ; extra == 'develop' + - pytest-xdist ; extra == 'develop' + - pytest-cov ; extra == 'develop' + - pywinpty ; os_name == 'nt' and extra == 'develop' + - flake8 ; extra == 'develop' + - isort ; extra == 'develop' + - sphinx ; extra == 'docs' + - nbconvert ; extra == 'docs' + - jupyter-client ; extra == 'docs' + - ipykernel ; extra == 'docs' + - matplotlib ; extra == 'docs' + - nbformat ; extra == 'docs' + - numpydoc ; extra == 'docs' + - pandas-datareader ; extra == 'docs' + requires_python: '>=3.9' - conda: https://conda.anaconda.org/conda-forge/linux-64/tbb-2021.13.0-hceb3a55_1.conda sha256: 65463732129899770d54b1fbf30e1bb82fdebda9d7553caf08d23db4590cd691 md5: ba7726b8df7b9d34ea80e82b097a4893 @@ -10052,8 +16167,8 @@ packages: timestamp: 1778673901757 - pypi: . name: tcpypi - version: 1.5.dev33+g2590db137.d20260710 - sha256: 1585d0d0ad5c76b4f87d92d08372d795a9df097629e8cb2f9c5f5aed87b633be + version: 1.4.3.dev27+gce66c8b63.d20260711 + sha256: eca3b0c01439645d3aa446eeae613e7348f5d5f0b1c85c6486819838d46f32da requires_dist: - numba>=0.59 - numpy>=1.26 @@ -10063,8 +16178,13 @@ packages: - xarray ; extra == 'demo' - h5netcdf ; extra == 'xarray' - xarray ; extra == 'xarray' - requires_python: '>=3.10' + requires_python: '>=3.11' editable: true +- pypi: https://files.pythonhosted.org/packages/32/d5/f9a850d79b0851d1d4ef6456097579a9005b31fea68726a4ae5f2d82ddd9/threadpoolctl-3.6.0-py3-none-any.whl + name: threadpoolctl + version: 3.6.0 + sha256: 43a0b8fd5a2928500110039e43a5eed8480b918967083ea48dc3ab9f13c4a7fb + requires_python: '>=3.9' - conda: https://conda.anaconda.org/conda-forge/linux-64/tk-8.6.13-noxft_h366c992_103.conda sha256: cafeec44494f842ffeca27e9c8b0c27ed714f93ac77ddadc6aaf726b5554ebac md5: cffd3bdd58090148f4cfcd831f4b26ab @@ -10179,6 +16299,11 @@ packages: - pkg:pypi/tomli?source=hash-mapping size: 21561 timestamp: 1774492402955 +- pypi: https://files.pythonhosted.org/packages/fb/12/5911ae3eeec47800503a238d971e51722ccea5feb8569b735184d5fcdbc0/toolz-1.1.0-py3-none-any.whl + name: toolz + version: 1.1.0 + sha256: 15ccc861ac51c53696de0a5d6d4607f99c210739caf987b5d2054f3efed429d8 + requires_python: '>=3.9' - conda: https://conda.anaconda.org/conda-forge/linux-64/tornado-6.5.3-py314h5bd0f2a_0.conda sha256: b8f9f9ae508d79c9c697eb01b6a8d2ed4bc1899370f44aa6497c8abbd15988ea md5: e35f08043f54d26a1be93fdbf90d30c3 @@ -10193,6 +16318,20 @@ packages: - pkg:pypi/tornado?source=hash-mapping size: 905436 timestamp: 1765458949518 +- conda: https://conda.anaconda.org/conda-forge/linux-64/tornado-6.5.7-py314h5bd0f2a_0.conda + sha256: bbb7056f7c5fd606df16ed73ee68687050de2c02fd69a3f69a1cb533a7ed2ae8 + md5: 4a8e5889712641aabdf6695e292857fe + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - python >=3.14,<3.15.0a0 + - python_abi 3.14.* *_cp314 + license: Apache-2.0 + license_family: Apache + purls: + - pkg:pypi/tornado?source=hash-mapping + size: 918368 + timestamp: 1781006801436 - conda: https://conda.anaconda.org/conda-forge/osx-64/tornado-6.4.2-py313h63b0ddb_0.conda sha256: 209dbf187e031dd3c565ff2da0f17847e84e8edb7648efecac28e61744345a41 md5: 74a3a14f82dc65fa19f4fd4e2eb8da93 @@ -10206,6 +16345,19 @@ packages: - pkg:pypi/tornado?source=hash-mapping size: 862737 timestamp: 1732616091334 +- conda: https://conda.anaconda.org/conda-forge/osx-64/tornado-6.5.7-py314h217eccc_0.conda + sha256: 5049ba4872765887bae8cce3673c785754d94ea23e0a2ea20158e76108a3fe4f + md5: b30f2eeef4987aa26f697978d17e867c + depends: + - __osx >=11.0 + - python >=3.14,<3.15.0a0 + - python_abi 3.14.* *_cp314 + license: Apache-2.0 + license_family: Apache + purls: + - pkg:pypi/tornado?source=compressed-mapping + size: 915832 + timestamp: 1781007541495 - conda: https://conda.anaconda.org/conda-forge/osx-arm64/tornado-6.5.4-py314h0612a62_0.conda sha256: affbc6300e1baef5848f6e69569733a3e7a118aa642487c853f53d6f2bd23b89 md5: 83e1a2d7b0c1352870bbe9d9406135cf @@ -10220,6 +16372,20 @@ packages: - pkg:pypi/tornado?source=hash-mapping size: 909298 timestamp: 1765836779269 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/tornado-6.5.7-py314h6c2aa35_0.conda + sha256: 1a4f3d940cf239acde2fc61674b7cf80219a7f22a369e92b95b245be2d47caf1 + md5: cc1d84777343f00f01c08a2d9550f639 + depends: + - __osx >=11.0 + - python >=3.14,<3.15.0a0 + - python >=3.14,<3.15.0a0 *_cp314 + - python_abi 3.14.* *_cp314 + license: Apache-2.0 + license_family: Apache + purls: + - pkg:pypi/tornado?source=hash-mapping + size: 915857 + timestamp: 1781007345425 - conda: https://conda.anaconda.org/conda-forge/win-64/tornado-6.5.4-py314h5a2d7ad_0.conda sha256: 40fde32a4992ab0f875618f97d9aadf263d39c6c92ace7572c6b0a71c655abe1 md5: 00157f40fd3ea957a2616e9ffda6b84f @@ -10235,6 +16401,35 @@ packages: - pkg:pypi/tornado?source=hash-mapping size: 908399 timestamp: 1765836848636 +- conda: https://conda.anaconda.org/conda-forge/win-64/tornado-6.5.7-py314h5a2d7ad_0.conda + sha256: 6b9f5a195ca148f7c6b9a4a0a026631979b3112c43cd7c1064085ff833dfa4f0 + md5: b1b9bf11a82e608c5649d7462de94c5f + depends: + - python >=3.14,<3.15.0a0 + - python_abi 3.14.* *_cp314 + - ucrt >=10.0.20348.0 + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + license: Apache-2.0 + license_family: Apache + purls: + - pkg:pypi/tornado?source=hash-mapping + size: 919275 + timestamp: 1781006902968 +- pypi: https://files.pythonhosted.org/packages/22/2a/5e5e750890ada51017d18d0d4c30da696e5b5bd3180947729927628fc3cb/tqdm-4.68.4-py3-none-any.whl + name: tqdm + version: 4.68.4 + sha256: 5168118b2368f48c561afda8020fd79195b1bdb0bdf8086b88442c267a315dc2 + requires_dist: + - colorama ; sys_platform == 'win32' + - requests ; extra == 'discord' + - envwrap ; extra == 'discord' + - slack-sdk ; extra == 'slack' + - envwrap ; extra == 'slack' + - requests ; extra == 'telegram' + - envwrap ; extra == 'telegram' + - ipywidgets>=6 ; extra == 'notebook' + requires_python: '>=3.8' - conda: https://conda.anaconda.org/conda-forge/noarch/tqdm-4.68.4-pyh8f84b5b_0.conda sha256: 1964320e89c00a531705449187f4b8ed85f935c73f13ba55de3a6b35b05443fa md5: 54772f97dc361b1659ef0b34d71d39b4 @@ -10277,6 +16472,18 @@ packages: - pkg:pypi/traitlets?source=hash-mapping size: 110051 timestamp: 1733367480074 +- conda: https://conda.anaconda.org/conda-forge/noarch/traitlets-5.15.1-pyhcf101f3_0.conda + sha256: b89a823edf524956b94a2a4db974866e4501f05c68976eff458c5dcf07f88431 + md5: 37e3be7b6e2977d37b8fa5da229f5dc0 + depends: + - python >=3.10 + - python + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/traitlets?source=compressed-mapping + size: 115158 + timestamp: 1780507822178 - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.12.2-pyha770c72_1.conda sha256: 337be7af5af8b2817f115b3b68870208b30c31d3439bec07bfb2d8f4823e3568 md5: d17f13df8b65464ca316cbc000a3cb64 @@ -10347,6 +16554,33 @@ packages: - pkg:pypi/unicodedata2?source=hash-mapping size: 409745 timestamp: 1763055060898 +- conda: https://conda.anaconda.org/conda-forge/linux-64/unicodedata2-17.0.1-py314h5bd0f2a_0.conda + sha256: ff1c1d7c23b91c9b0eb93a3e1380f4e2ac6c37ea2bba4f932a5484e9a55bba30 + md5: 494fdf358c152f9fdd0673c128c2f3dd + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - python >=3.14,<3.15.0a0 + - python_abi 3.14.* *_cp314 + license: Apache-2.0 + license_family: Apache + purls: + - pkg:pypi/unicodedata2?source=hash-mapping + size: 409562 + timestamp: 1770909102180 +- conda: https://conda.anaconda.org/conda-forge/osx-64/unicodedata2-17.0.1-py314h4f144dc_0.conda + sha256: 972155e67125f230bef47883d6613c1d6ca32fd6e807e1df0d4d8799b1abfd57 + md5: 773e3141f292d9698e706da094ada8c1 + depends: + - __osx >=10.13 + - python >=3.14,<3.15.0a0 + - python_abi 3.14.* *_cp314 + license: Apache-2.0 + license_family: Apache + purls: + - pkg:pypi/unicodedata2?source=hash-mapping + size: 406478 + timestamp: 1770909238815 - conda: https://conda.anaconda.org/conda-forge/osx-arm64/unicodedata2-17.0.0-py314h0612a62_1.conda sha256: 48c51dd2ef696f7a1a3635716585a8e383a8c00e719305cfda2b480c36ee1283 md5: c673decfe1f120b0717d0aa193b10060 @@ -10361,6 +16595,20 @@ packages: - pkg:pypi/unicodedata2?source=hash-mapping size: 416770 timestamp: 1763055099322 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/unicodedata2-17.0.1-py314h6c2aa35_0.conda + sha256: 09bfbee5a2bcf4df06f21a2aa9eb40a7af97864a569beb5ea85fd6baf6e03ce7 + md5: 4fffb3ba871bb05f34ffb705534dfef5 + depends: + - __osx >=11.0 + - python >=3.14,<3.15.0a0 + - python >=3.14,<3.15.0a0 *_cp314 + - python_abi 3.14.* *_cp314 + license: Apache-2.0 + license_family: Apache + purls: + - pkg:pypi/unicodedata2?source=hash-mapping + size: 416130 + timestamp: 1770909728445 - conda: https://conda.anaconda.org/conda-forge/win-64/unicodedata2-17.0.0-py314h5a2d7ad_1.conda sha256: 47e061aec1487519c398e1c999ac3680f068f9e1d8574c8b365eac4787773250 md5: 1f90bb13fa5ced89ca4dcc0af3bbebf3 @@ -10376,6 +16624,32 @@ packages: - pkg:pypi/unicodedata2?source=hash-mapping size: 405783 timestamp: 1763054877424 +- conda: https://conda.anaconda.org/conda-forge/win-64/unicodedata2-17.0.1-py314h5a2d7ad_0.conda + sha256: 9041e463044944460f73f9528f2ec491180f0ffe857e3555aa8160b81050b8d9 + md5: d6b580a13384df5155c6ca19ee66854e + depends: + - python >=3.14,<3.15.0a0 + - python_abi 3.14.* *_cp314 + - ucrt >=10.0.20348.0 + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + license: Apache-2.0 + license_family: Apache + purls: + - pkg:pypi/unicodedata2?source=hash-mapping + size: 406126 + timestamp: 1770909191618 +- pypi: https://files.pythonhosted.org/packages/7f/3e/5db95bcf282c52709639744ca2a8b149baccf648e39c8cc87553df9eae0c/urllib3-2.7.0-py3-none-any.whl + name: urllib3 + version: 2.7.0 + sha256: 9fb4c81ebbb1ce9531cce37674bbc6f1360472bc18ca9a553ede278ef7276897 + requires_dist: + - brotli>=1.2.0 ; platform_python_implementation == 'CPython' and extra == 'brotli' + - brotlicffi>=1.2.0.0 ; platform_python_implementation != 'CPython' and extra == 'brotli' + - h2>=4,<5 ; extra == 'h2' + - pysocks>=1.5.6,!=1.5.7,<2.0 ; extra == 'socks' + - backports-zstd>=1.0.0 ; python_full_version < '3.14' and extra == 'zstd' + requires_python: '>=3.10' - conda: https://conda.anaconda.org/conda-forge/noarch/urllib3-2.7.0-pyhd8ed1ab_0.conda sha256: feff959a816f7988a0893201aa9727bbb7ee1e9cec2c4f0428269b489eb93fb4 md5: cbb88288f74dbe6ada1c6c7d0a97223e @@ -10489,6 +16763,20 @@ packages: purls: [] size: 329779 timestamp: 1761174273487 +- conda: https://conda.anaconda.org/conda-forge/linux-64/wayland-1.25.0-hd6090a7_0.conda + sha256: ea374d57a8fcda281a0a89af0ee49a2c2e99cc4ac97cf2e2db7064e74e764bdb + md5: 996583ea9c796e5b915f7d7580b51ea6 + depends: + - __glibc >=2.17,<3.0.a0 + - libexpat >=2.7.4,<3.0a0 + - libffi >=3.5.2,<3.6.0a0 + - libgcc >=14 + - libstdcxx >=14 + license: MIT + license_family: MIT + purls: [] + size: 334139 + timestamp: 1773959575393 - conda: https://conda.anaconda.org/conda-forge/noarch/wcwidth-0.2.13-pyhd8ed1ab_1.conda sha256: f21e63e8f7346f9074fd00ca3b079bd3d2fa4d71f1f89d5b6934bf31446dc2a5 md5: b68980f2495d096e71c7fd9d7ccf63e6 @@ -10500,6 +16788,17 @@ packages: - pkg:pypi/wcwidth?source=hash-mapping size: 32581 timestamp: 1733231433877 +- conda: https://conda.anaconda.org/conda-forge/noarch/wcwidth-0.8.2-pyhd8ed1ab_0.conda + sha256: 4acf845da404e84cef1acccc66cc0156af1b83a5b5d7077b2ca19b705c561e57 + md5: 99f7755ec8648a042b0dbe906234f888 + depends: + - python >=3.10 + license: MIT + license_family: MIT + purls: + - pkg:pypi/wcwidth?source=compressed-mapping + size: 132415 + timestamp: 1782771807703 - conda: https://conda.anaconda.org/conda-forge/noarch/win_inet_pton-1.1.0-pyh7428d3b_8.conda sha256: 93807369ab91f230cf9e6e2a237eaa812492fe00face5b38068735858fba954f md5: 46e441ba871f524e2b067929da3051c2 @@ -10581,6 +16880,44 @@ packages: - pkg:pypi/xarray?source=hash-mapping size: 879913 timestamp: 1749743321359 +- conda: https://conda.anaconda.org/conda-forge/noarch/xarray-2026.7.0-pyhc364b38_0.conda + sha256: 47244c233aeb55de993fe79eebbbb2adc14b388bb0bf2f9dfbaa8aa6610b6345 + md5: f72531e6cf99c98d47306ec917f5e6b9 + depends: + - python >=3.11 + - numpy >=1.26 + - packaging >=24.2 + - pandas >=2.2 + - python + constrains: + - bottleneck >=1.4 + - cartopy >=0.23 + - cftime >=1.6 + - dask-core >=2024.6 + - distributed >=2024.6 + - flox >=0.9 + - h5netcdf >=1.3 + - h5py >=3.11 + - hdf5 >=1.14 + - iris >=3.9 + - matplotlib-base >=3.8 + - nc-time-axis >=1.4 + - netcdf4 >=1.6.0 + - numba >=0.60 + - numbagg >=0.8 + - pint >=0.24 + - pydap >=3.5.0 + - scipy >=1.13 + - seaborn-base >=0.13 + - sparse >=0.15 + - toolz >=0.12 + - zarr >=2.18 + license: Apache-2.0 + license_family: APACHE + purls: + - pkg:pypi/xarray?source=compressed-mapping + size: 1027069 + timestamp: 1783633473025 - conda: https://conda.anaconda.org/conda-forge/linux-64/xcb-util-0.4.1-h4f16b4b_2.conda sha256: ad8cab7e07e2af268449c2ce855cbb51f43f4664936eff679b1f3862e6e4b01d md5: fdc27cb255a7a2cc73b7919a968b48f0 @@ -10665,6 +17002,18 @@ packages: purls: [] size: 396975 timestamp: 1759543819846 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xkeyboard-config-2.48-h280c20c_0.conda + sha256: 3b04afd5d1a65d2d27ac2d49a63b01ab8bcd875776779ec63e337370ed38afdc + md5: b233b41be0bf210989d57160ed39b394 + depends: + - libgcc >=14 + - __glibc >=2.17,<3.0.a0 + - xorg-libx11 >=1.8.13,<2.0a0 + license: MIT + license_family: MIT + purls: [] + size: 441670 + timestamp: 1782027360439 - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libice-1.1.2-hb9d3cd8_0.conda sha256: c12396aabb21244c212e488bbdc4abcdef0b7404b15761d9329f5a4a39113c4b md5: fb901ff28063514abb6046c9ec2c4a45 @@ -10701,6 +17050,18 @@ packages: purls: [] size: 835896 timestamp: 1741901112627 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libx11-1.8.13-he1eb515_0.conda + sha256: 516d4060139dbb4de49a4dcdc6317a9353fb39ebd47789c14e6fe52de0deee42 + md5: 861fb6ccbc677bb9a9fb2468430b9c6a + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - libxcb >=1.17.0,<2.0a0 + license: MIT + license_family: MIT + purls: [] + size: 839652 + timestamp: 1770819209719 - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxau-1.0.12-hb03c661_1.conda sha256: 6bc6ab7a90a5d8ac94c7e300cc10beb0500eeba4b99822768ca2f2ef356f731b md5: b2895afaf55bf96a8c8282a2e47a5de0 @@ -10757,6 +17118,19 @@ packages: purls: [] size: 13603 timestamp: 1727884600744 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxcomposite-0.4.7-hb03c661_0.conda + sha256: 048c103000af9541c919deef03ae7c5e9c570ffb4024b42ecb58dbde402e373a + md5: f2ba4192d38b6cef2bb2c25029071d90 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - xorg-libx11 >=1.8.12,<2.0a0 + - xorg-libxfixes >=6.0.2,<7.0a0 + license: MIT + license_family: MIT + purls: [] + size: 14415 + timestamp: 1770044404696 - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxcursor-1.2.3-hb9d3cd8_0.conda sha256: 832f538ade441b1eee863c8c91af9e69b356cd3e9e1350fff4fe36cc573fc91a md5: 2ccd714aa2242315acaf0a67faea780b @@ -10840,6 +17214,18 @@ packages: purls: [] size: 50060 timestamp: 1727752228921 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxext-1.3.7-hb03c661_0.conda + sha256: 79c60fc6acfd3d713d6340d3b4e296836a0f8c51602327b32794625826bd052f + md5: 34e54f03dfea3e7a2dcf1453a85f1085 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - xorg-libx11 >=1.8.12,<2.0a0 + license: MIT + license_family: MIT + purls: [] + size: 50326 + timestamp: 1769445253162 - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxfixes-6.0.2-hb03c661_0.conda sha256: 83c4c99d60b8784a611351220452a0a85b080668188dce5dfa394b723d7b64f4 md5: ba231da7fccf9ea1e768caf5c7099b84 @@ -10866,6 +17252,20 @@ packages: purls: [] size: 47179 timestamp: 1727799254088 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxi-1.8.3-hb03c661_0.conda + sha256: 495f99c8eacfa4ae2d8fed2a7f2105777af89acdc204df145d2bbbc380ac631b + md5: adba2e334082bb218db806d4c12277c9 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - xorg-libx11 >=1.8.13,<2.0a0 + - xorg-libxext >=1.3.7,<2.0a0 + - xorg-libxfixes >=6.0.2,<7.0a0 + license: MIT + license_family: MIT + purls: [] + size: 47717 + timestamp: 1779111857071 - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxrandr-1.5.4-hb9d3cd8_0.conda sha256: ac0f037e0791a620a69980914a77cb6bb40308e26db11698029d6708f5aa8e0d md5: 2de7f99d6581a4a7adbff607b5c278ca @@ -10880,6 +17280,20 @@ packages: purls: [] size: 29599 timestamp: 1727794874300 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxrandr-1.5.5-hb03c661_0.conda + sha256: 80ed047a5cb30632c3dc5804c7716131d767089f65877813d4ae855ee5c9d343 + md5: e192019153591938acf7322b6459d36e + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - xorg-libx11 >=1.8.12,<2.0a0 + - xorg-libxext >=1.3.6,<2.0a0 + - xorg-libxrender >=0.9.12,<0.10.0a0 + license: MIT + license_family: MIT + purls: [] + size: 30456 + timestamp: 1769445263457 - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxrender-0.9.12-hb9d3cd8_0.conda sha256: 044c7b3153c224c6cedd4484dd91b389d2d7fd9c776ad0f4a34f099b3389f4a1 md5: 96d57aba173e878a2089d5638016dc5e @@ -10919,6 +17333,44 @@ packages: purls: [] size: 17819 timestamp: 1734214575628 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxxf86vm-1.1.7-hb03c661_0.conda + sha256: 64db17baaf36fa03ed8fae105e2e671a7383e22df4077486646f7dbf12842c9f + md5: 665d152b9c6e78da404086088077c844 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - xorg-libx11 >=1.8.12,<2.0a0 + - xorg-libxext >=1.3.6,<2.0a0 + license: MIT + license_family: MIT + purls: [] + size: 18701 + timestamp: 1769434732453 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-xorgproto-2025.1-hb03c661_0.conda + sha256: 7a8c64938428c2bfd016359f9cb3c44f94acc256c6167dbdade9f2a1f5ca7a36 + md5: aa8d21be4b461ce612d8f5fb791decae + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + license: MIT + license_family: MIT + purls: [] + size: 570010 + timestamp: 1766154256151 +- conda: https://conda.anaconda.org/conda-forge/linux-64/zeromq-4.3.5-h09e67af_11.conda + sha256: dc9f28dedcb5f35a127fad2d847674d2833369dd616d294e423b8997df31d8a8 + md5: 96b08867e21d4694fa5c2c226e6581b0 + depends: + - libgcc >=14 + - __glibc >=2.17,<3.0.a0 + - libstdcxx >=14 + - krb5 >=1.22.2,<1.23.0a0 + - libsodium >=1.0.22,<1.0.23.0a0 + license: MPL-2.0 + license_family: MOZILLA + purls: [] + size: 311184 + timestamp: 1779123989774 - conda: https://conda.anaconda.org/conda-forge/linux-64/zeromq-4.3.5-h3b0a872_7.conda sha256: a4dc72c96848f764bb5a5176aa93dd1e9b9e52804137b99daeebba277b31ea10 md5: 3947a35e916fcc6b9825449affbf4214 @@ -10946,6 +17398,32 @@ packages: purls: [] size: 292112 timestamp: 1731585246902 +- conda: https://conda.anaconda.org/conda-forge/osx-64/zeromq-4.3.5-h84953be_11.conda + sha256: 2ba9b6a3131b5a97641068559d38c044f37fd29b54c10dd6d073f1cf81fc4e4c + md5: 8a622d1db89d80a94477b1c03824d611 + depends: + - libcxx >=19 + - __osx >=11.0 + - krb5 >=1.22.2,<1.23.0a0 + - libsodium >=1.0.22,<1.0.23.0a0 + license: MPL-2.0 + license_family: MOZILLA + purls: [] + size: 260817 + timestamp: 1779124180318 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/zeromq-4.3.5-h10816f8_11.conda + sha256: 01fd50d2801b23b59fafea6bf704a6c5faf0f5969104400eae0e6572cb2e5304 + md5: d31c0e54c4f9c51100ec8c812ee925d1 + depends: + - libcxx >=19 + - __osx >=11.0 + - krb5 >=1.22.2,<1.23.0a0 + - libsodium >=1.0.22,<1.0.23.0a0 + license: MPL-2.0 + license_family: MOZILLA + purls: [] + size: 245404 + timestamp: 1779124076307 - conda: https://conda.anaconda.org/conda-forge/osx-arm64/zeromq-4.3.5-hc1bb282_7.conda sha256: 9e585569fe2e7d3bea71972cd4b9f06b1a7ab8fa7c5139f92a31cbceecf25a8a md5: f7e6b65943cb73bce0143737fded08f1 @@ -10959,6 +17437,20 @@ packages: purls: [] size: 281565 timestamp: 1731585108039 +- conda: https://conda.anaconda.org/conda-forge/win-64/zeromq-4.3.5-h3a581c9_11.conda + sha256: c3e279cb309b153152fcdd6ee6d039ad996d563c849f06be39d85b8e3351df25 + md5: f016c0c5f9c01549b259146614786192 + depends: + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + - ucrt >=10.0.20348.0 + - libsodium >=1.0.22,<1.0.23.0a0 + - krb5 >=1.22.2,<1.23.0a0 + license: MPL-2.0 + license_family: MOZILLA + purls: [] + size: 265717 + timestamp: 1779124031378 - conda: https://conda.anaconda.org/conda-forge/win-64/zeromq-4.3.5-ha9f60a1_7.conda sha256: 15cc8e2162d0a33ffeb3f7b7c7883fd830c54a4b1be6a4b8c7ee1f4fef0088fb md5: e03f2c245a5ee6055752465519363b1c @@ -10984,6 +17476,31 @@ packages: - pkg:pypi/zipp?source=hash-mapping size: 21809 timestamp: 1732827613585 +- conda: https://conda.anaconda.org/conda-forge/noarch/zipp-4.1.0-pyhcf101f3_0.conda + sha256: 210bd31c22bb88f5e2a167df24c95bb5f152b2ada7502f9b8c49d1f5366db423 + md5: ba3dcdc8584155c97c648ae9c044b7a3 + depends: + - python >=3.10 + - python + license: MIT + license_family: MIT + purls: + - pkg:pypi/zipp?source=hash-mapping + size: 24190 + timestamp: 1779159948016 +- conda: https://conda.anaconda.org/conda-forge/win-64/zlib-1.3.2-hfd05255_2.conda + sha256: ef408f85f664a4b9c9dac3cb2e36154d9baa15a88984ea800e11060e0f2394a1 + md5: 5187ecf958be3c39110fe691cbd6873e + depends: + - libzlib 1.3.2 hfd05255_2 + - ucrt >=10.0.20348.0 + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + license: Zlib + license_family: Other + purls: [] + size: 850351 + timestamp: 1774072891049 - conda: https://conda.anaconda.org/conda-forge/linux-64/zlib-ng-2.3.2-hceb46e0_1.conda sha256: f2b6a175677701a0b6ce556b3bd362dc94a4e36ffcd10e3860e52ca036b4ad96 md5: 40feea2979654ed579f1cda7c63ccb94 @@ -10996,6 +17513,29 @@ packages: purls: [] size: 122303 timestamp: 1766076745735 +- conda: https://conda.anaconda.org/conda-forge/linux-64/zlib-ng-2.3.3-hceb46e0_1.conda + sha256: ea4e50c465d70236408cb0bfe0115609fd14db1adcd8bd30d8918e0291f8a75f + md5: 2aadb0d17215603a82a2a6b0afd9a4cb + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - libstdcxx >=14 + license: Zlib + license_family: Other + purls: [] + size: 122618 + timestamp: 1770167931827 +- conda: https://conda.anaconda.org/conda-forge/osx-64/zlib-ng-2.3.3-h8bce59a_1.conda + sha256: 4a1beb656761c7d8c9a53474bfd3932c30d82af5d93a32b8ef626c01c059d981 + md5: b3ecb6480fd46194e3f7dd0ff4445dff + depends: + - __osx >=10.13 + - libcxx >=19 + license: Zlib + license_family: Other + purls: [] + size: 120464 + timestamp: 1770168263684 - conda: https://conda.anaconda.org/conda-forge/osx-arm64/zlib-ng-2.3.2-hed4e4f5_1.conda sha256: ab481487381a6a6213d667e883252e52b8ca867b3b466c31a058126f964efffe md5: 75f39a44c08cb5dc4ea847698de34ba3 @@ -11007,6 +17547,17 @@ packages: purls: [] size: 94882 timestamp: 1766076931977 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/zlib-ng-2.3.3-hed4e4f5_1.conda + sha256: a339606a6b224bb230ff3d711e801934f3b3844271df9720165e0353716580d4 + md5: d99c2a23a31b0172e90f456f580b695e + depends: + - __osx >=11.0 + - libcxx >=19 + license: Zlib + license_family: Other + purls: [] + size: 94375 + timestamp: 1770168363685 - conda: https://conda.anaconda.org/conda-forge/win-64/zlib-ng-2.3.2-h0261ad2_1.conda sha256: e058e925bed8d9e5227cecc098e02992813046fd89206194435e975a9f6eff56 md5: bc2fba648e1e784c549e20bbe1a8af40 @@ -11019,6 +17570,18 @@ packages: purls: [] size: 123890 timestamp: 1766076739436 +- conda: https://conda.anaconda.org/conda-forge/win-64/zlib-ng-2.3.3-h0261ad2_1.conda + sha256: 71332532332d13b5dbe57074ddcf82ae711bdc132affa5a2982a29ffa06dc234 + md5: 46a21c0a4e65f1a135251fc7c8663f83 + depends: + - ucrt >=10.0.20348.0 + - vc >=14.3,<15 + - vc14_runtime >=14.44.35208 + license: Zlib + license_family: Other + purls: [] + size: 124542 + timestamp: 1770167984883 - conda: https://conda.anaconda.org/conda-forge/linux-64/zstd-1.5.7-hb78ec9c_6.conda sha256: 68f0206ca6e98fea941e5717cec780ed2873ffabc0e1ed34428c061e2c6268c7 md5: 4a13eeac0b5c8e5b8ab496e6c4ddd829 diff --git a/pyproject.toml b/pyproject.toml index 162d2ad..3566a2d 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,22 +1,23 @@ [build-system] -requires = ["hatchling", "hatch-vcs"] +requires = ["hatchling", "hatch-vcs", "hatch-fancy-pypi-readme"] build-backend = "hatchling.build" [project] name = "tcpyPI" -dynamic = ["version"] +# `readme` is dynamic: hatch-fancy-pypi-readme rewrites the README's relative +# links/images to absolute GitHub URLs so they render on PyPI (see below). +dynamic = ["version", "readme"] description = "tcpyPI: Tropical cyclone potential intensity calculations in Python" -readme = "README.md" -requires-python = ">=3.10" +requires-python = ">=3.11" license = {file = "LICENSE" } authors = [ { name = "Daniel M. Gilford, PhD", email = "dgilford@climatecentral.org" } ] classifiers = [ "Programming Language :: Python :: 3", - "Programming Language :: Python :: 3.10", "Programming Language :: Python :: 3.11", "Programming Language :: Python :: 3.12", + "Programming Language :: Python :: 3.13", "License :: OSI Approved :: MIT License", "Operating System :: OS Independent", "Intended Audience :: Science/Research", @@ -39,20 +40,41 @@ Issues = "https://github.com/dgilford/tcpyPI/issues" # Configure hatch-vcs to extract version information from version control (e.g. Git tags) [tool.hatch.version] -source = "vcs" - +source = "vcs" + +# Assemble the PyPI long description from README.md, rewriting relative links and +# images to absolute GitHub URLs (PyPI does not resolve relative paths). +[tool.hatch.metadata.hooks.fancy-pypi-readme] +content-type = "text/markdown" + +[[tool.hatch.metadata.hooks.fancy-pypi-readme.fragments]] +path = "README.md" + +# HTML -> raw.githubusercontent URLs (render inline on PyPI) +[[tool.hatch.metadata.hooks.fancy-pypi-readme.substitutions]] +pattern = '(]*src=")\./' +replacement = '\g<1>https://raw.githubusercontent.com/dgilford/tcpyPI/main/' + +# Markdown links [text](relative/path) -> absolute repo blob URLs; skip links that +# are already absolute (http/https), in-page anchors (#), or mailto:. +[[tool.hatch.metadata.hooks.fancy-pypi-readme.substitutions]] +pattern = '\]\((?!https?://|#|mailto:)\.?/?([^)]+)\)' +replacement = '](https://github.com/dgilford/tcpyPI/blob/main/\g<1>)' + +# Keep the sdist lean via an explicit allowlist. (An `exclude` list is NOT enough +# here: hatchling treats the .gitignore `!data/*.nc` negations as force-includes +# that override target excludes, which silently shipped ~12 MB of sample netCDF.) +# README.md and LICENSE must be included: the fancy-pypi-readme metadata hook and +# the license reference re-run when building a wheel from the sdist. [tool.hatch.build.targets.sdist] -exclude = [ - "/.github", - "/data", - "/dist", - "/figures", - "/matlab_scripts", - "/notebooks", - "/tests", - "/pyPI_Users_Guide_v1.3.pdf", - "/run_sample.py", -] +only-include = [ + "src", + "README.md", + "LICENSE", + "CITATION.cff", + "AGENTS.md", + "CLAUDE.md", +] [tool.hatch.build.targets.wheel] packages = ["src/tcpyPI"] @@ -60,6 +82,44 @@ packages = ["src/tcpyPI"] [tool.pytest.ini_options] addopts = ["--doctest-modules", "-v"] +[tool.ruff] +line-length = 100 +target-version = "py311" +extend-exclude = ["notebooks", ".pixi", ".ipynb_checkpoints"] + +[tool.ruff.lint] +select = [ + "E", # pycodestyle errors + "F", # pyflakes + "W", # pycodestyle warnings + "I", # isort (import ordering) + "UP", # pyupgrade + "NPY", # numpy-specific rules +] +# E501: long lines in scientific docstrings/comments are fine (the formatter +# handles code lines); E741: single-letter names (P, T, R, l...) are the +# domain-standard meteorological notation used throughout. +ignore = ["E501", "E741"] + +[tool.ruff.lint.per-file-ignores] +# The package namespace is assembled by re-exports (including the historical +# star imports); silence the unused/star-import rules there. +"src/tcpyPI/__init__.py" = ["F401", "F403"] +# run_sample.py deliberately inserts the local src/ checkout onto sys.path +# before importing tcpyPI. +"run_sample.py" = ["E402"] + +[tool.mypy] +python_version = "3.11" +ignore_missing_imports = true +follow_imports = "silent" +warn_unused_ignores = true +# The njit-compiled numerical kernels are intentionally untyped; type-checking +# targets the pure-Python API surface. +[[tool.mypy.overrides]] +module = "tcpyPI.pi" +ignore_errors = true + # Pixi is used for managing Conda environments in the development of tcpyPI. # It is not required for the installation or usage of tcpyPI. @@ -86,9 +146,9 @@ basic-tests = "python -m pytest -n auto --ignore run_sample.py --ignore tests/te xarray-tests = "python -m pytest -n auto tests/test_run_sample.py" [tool.pixi.feature.min-dependency-versions.dependencies] -# Pinned to the declared support floor (requires-python >=3.10) so CI keeps the +# Pinned to the declared support floor (requires-python >=3.11) so CI keeps the # minimum-version claim honest. Update in lockstep with the [project] dependencies. -python = "3.10.*" +python = "3.11.*" numba = "0.59.*" numpy = "1.26.*" @@ -112,6 +172,23 @@ numpy = "*" download-era5 = { cmd = "python download_era5.py && python download_era5_sl.py", cwd = "data" } build-sample = "python data/build_sample_data_era5_oct2024.py" +# Benchmark-only environment: adds Skyborn (compiled-Fortran PI backend, issue #86) +# for the optional three-way comparison in notebooks/clock_pypi.ipynb. Not used by +# the package or CI. +[tool.pixi.feature.bench.pypi-dependencies] +skyborn = "*" + +[tool.pixi.feature.lint.dependencies] +ruff = "*" +mypy = "*" +python-build = "*" + +[tool.pixi.feature.lint.tasks] +lint = "ruff check src tests run_sample.py data" +format-check = "ruff format --check src tests run_sample.py data" +format = "ruff format src tests run_sample.py data" +typecheck = "mypy src/tcpyPI" + [tool.pixi.target.osx-64.dependencies] # Workaround for duplicate LD_RPATH issue on MacOS 15.4 # @@ -128,6 +205,8 @@ libgfortran5 = ">=14" [tool.pixi.environments] default = {features = ["test", "xarray", "notebook", "data"], solve-group = "default"} +bench = {features = ["test", "xarray", "notebook", "bench"], solve-group = "bench"} +lint = {features = ["lint"], solve-group = "lint"} minimal = {features = [], solve-group = "default"} # CI test environments, test-latest = {features = ["test"], solve-group = "default"} diff --git a/run_sample.py b/run_sample.py index 042d70a..1d74adb 100644 --- a/run_sample.py +++ b/run_sample.py @@ -19,15 +19,15 @@ sys.path.insert(0, str(_SRC_DIR)) # load in pyPI modules -from tcpyPI import pi, pi_log_decomposition -from tcpyPI.utilities import pi_efficiency, pi_diseq_resid +from tcpyPI import pi_field, pi_log_decomposition +from tcpyPI.utilities import pi_diseq_resid, pi_efficiency # define the sample data locations datdir = "./data/" _FN = datdir + "sample_data.nc" - -def run_sample_dataset(fn, dim='p',CKCD=0.9,outflow_source="cape_star"): + +def run_sample_dataset(fn, dim="p", CKCD=0.9, outflow_source="cape_star"): """Calculate potential intensity over the sample dataset with xarray. Parameters @@ -47,13 +47,19 @@ def run_sample_dataset(fn, dim='p',CKCD=0.9,outflow_source="cape_star"): Dataset containing PI outputs (`vmax`, `pmin`, `ifl`, `t0`, `otl`) and the state variables used in the calculation. """ - + # open the sample data file ds = xr.open_dataset(fn) - # calculate PI over the whole data set using the xarray universal function + # calculate PI over the whole dataset in one whole-field call: pi_field is a + # compiled, multithreaded generalized ufunc (same per-column math as pi()), + # so no `vectorize=True` per-column Python loop is needed. result = xr.apply_ufunc( - pi, - ds['sst'], ds['msl'], ds[dim], ds['t'], ds['q'], + pi_field, + ds["sst"], + ds["msl"], + ds[dim], + ds["t"], + ds["r"], kwargs=dict( CKCD=CKCD, ascent_flag=0, @@ -63,41 +69,60 @@ def run_sample_dataset(fn, dim='p',CKCD=0.9,outflow_source="cape_star"): outflow_source=outflow_source, ), input_core_dims=[ - [], [], [dim, ], [dim, ], [dim, ], - ], - output_core_dims=[ - [], [], [], [], [] + [], + [], + [ + dim, + ], + [ + dim, + ], + [ + dim, + ], ], - vectorize=True + output_core_dims=[[], [], [], [], []], ) # store the result in an xarray data structure vmax, pmin, ifl, t0, otl = result - out_ds=xr.Dataset({ - 'vmax': vmax, - 'pmin': pmin, - 'ifl': ifl, - 't0': t0, - 'otl': otl, - # merge the state data into the same data structure - 'sst': ds.sst, - 't': ds.t, - 'q': ds.q, - 'msl': ds.msl, - 'lsm': ds.lsm, - }) - + out_ds = xr.Dataset( + { + "vmax": vmax, + "pmin": pmin, + "ifl": ifl, + "t0": t0, + "otl": otl, + # merge the state data into the same data structure + "sst": ds.sst, + "t": ds.t, + "r": ds.r, + "msl": ds.msl, + "lsm": ds.lsm, + } + ) + # add names and units to the structure - out_ds.vmax.attrs['standard_name'],out_ds.vmax.attrs['units']='Maximum Potential Intensity','m/s' - out_ds.pmin.attrs['standard_name'],out_ds.pmin.attrs['units']='Minimum Central Pressure','hPa' - out_ds.ifl.attrs['standard_name']='pyPI Flag' - out_ds.t0.attrs['standard_name'],out_ds.t0.attrs['units']='Outflow Temperature','K' - out_ds.otl.attrs['standard_name'],out_ds.otl.attrs['units']='Outflow Temperature Level','hPa' + out_ds.vmax.attrs["standard_name"], out_ds.vmax.attrs["units"] = ( + "Maximum Potential Intensity", + "m/s", + ) + out_ds.pmin.attrs["standard_name"], out_ds.pmin.attrs["units"] = ( + "Minimum Central Pressure", + "hPa", + ) + out_ds.ifl.attrs["standard_name"] = "pyPI Flag" + out_ds.t0.attrs["standard_name"], out_ds.t0.attrs["units"] = "Outflow Temperature", "K" + out_ds.otl.attrs["standard_name"], out_ds.otl.attrs["units"] = ( + "Outflow Temperature Level", + "hPa", + ) # return the output from pi.py as an xarray data structure return out_ds -def run_sample_analyses(ds,CKCD=0.9): + +def run_sample_analyses(ds, CKCD=0.9): """Compute analysis diagnostics (including log decomposition) on PI outputs. Parameters @@ -112,48 +137,61 @@ def run_sample_analyses(ds,CKCD=0.9): xarray.Dataset Dataset of diagnostics: `eff`, `diseq`, `lnpi`, `lneff`, `lndiseq`, `lnCKCD`. """ - + # calculate PI analyses over the whole data set using the xarray universal function efficiency = xr.apply_ufunc( pi_efficiency, - ds['sst']+273.15, ds['t0'], + ds["sst"] + 273.15, + ds["t0"], input_core_dims=[ - [], [], + [], + [], ], output_core_dims=[ [], ], - vectorize=True + vectorize=True, ) - + diseq = xr.apply_ufunc( pi_diseq_resid, - ds['vmax'], ds['sst']+273.15, ds['t0'], + ds["vmax"], + ds["sst"] + 273.15, + ds["t0"], kwargs=dict(CKCD=CKCD), input_core_dims=[ - [], [], [], + [], + [], + [], ], output_core_dims=[ [], ], - vectorize=True + vectorize=True, ) - + result = xr.apply_ufunc( pi_log_decomposition, - ds['vmax'], ds['sst']+273.15, ds['t0'], + ds["vmax"], + ds["sst"] + 273.15, + ds["t0"], kwargs=dict(CKCD=CKCD, sst_units="K"), input_core_dims=[ - [], [], [], + [], + [], + [], ], output_core_dims=[ - [], [], [], [], + [], + [], + [], + [], ], - vectorize=True + vectorize=True, ) lnpi, lneff, lndiseq, lnCKCD = result - + # `lnCKCD` is constant in space/time, but `pi_log_decomposition` broadcasts it to # the input shape. Collapse it to a scalar so the output stays compact and # robust to input dimensionality. @@ -161,43 +199,52 @@ def run_sample_analyses(ds,CKCD=0.9): for dim in list(getattr(lnCKCD_scalar, "dims", ())): lnCKCD_scalar = lnCKCD_scalar.isel({dim: 0}) - out_ds = xr.Dataset({ - 'eff': efficiency, - 'diseq': diseq, - 'lnpi': lnpi, - 'lneff': lneff, - 'lndiseq': lndiseq, - 'lnCKCD': lnCKCD_scalar - }) - + out_ds = xr.Dataset( + { + "eff": efficiency, + "diseq": diseq, + "lnpi": lnpi, + "lneff": lneff, + "lndiseq": lndiseq, + "lnCKCD": lnCKCD_scalar, + } + ) + # add names and units (where applicable) - out_ds.eff.attrs['standard_name'],out_ds.eff.attrs['units']='Tropical Cyclone Efficiency','unitless fraction' - out_ds.diseq.attrs['standard_name'],out_ds.diseq.attrs['units']='Thermodynamic Disequilibrium','J/kg' - out_ds.lnpi.attrs['standard_name']='Natural log(Potential Intensity)' - out_ds.lneff.attrs['standard_name']='Natural log(Tropical Cyclone Efficiency)' - out_ds.lndiseq.attrs['standard_name']='Natural log(Thermodynamic Disequilibrium)' - out_ds.lnCKCD.attrs['standard_name'],out_ds.lnCKCD.attrs['units']='Natural log(Ck/CD)','unitless constant' + out_ds.eff.attrs["standard_name"], out_ds.eff.attrs["units"] = ( + "Tropical Cyclone Efficiency", + "unitless fraction", + ) + out_ds.diseq.attrs["standard_name"], out_ds.diseq.attrs["units"] = ( + "Thermodynamic Disequilibrium", + "J/kg", + ) + out_ds.lnpi.attrs["standard_name"] = "Natural log(Potential Intensity)" + out_ds.lneff.attrs["standard_name"] = "Natural log(Tropical Cyclone Efficiency)" + out_ds.lndiseq.attrs["standard_name"] = "Natural log(Thermodynamic Disequilibrium)" + out_ds.lnCKCD.attrs["standard_name"], out_ds.lnCKCD.attrs["units"] = ( + "Natural log(Ck/CD)", + "unitless constant", + ) # return the output from pi.py as an xarray data structure return out_ds - - -if __name__ == "__main__": +if __name__ == "__main__": # Execute PI analysis over the whole dataset and save the output - print('Beginning PI computations...') + print("Beginning PI computations...") ds = run_sample_dataset(_FN) - ds.to_netcdf(datdir+'raw_sample_output.nc', engine="h5netcdf") - print('...PI computation complete and saved\n') - + ds.to_netcdf(datdir + "raw_sample_output.nc", engine="h5netcdf") + print("...PI computation complete and saved\n") + # Perform PI analyses over the whole dataset - print('Performing PI analyses...') - ds2 = run_sample_analyses(ds,CKCD=0.9) - + print("Performing PI analyses...") + ds2 = run_sample_analyses(ds, CKCD=0.9) + # merge the arrays and save the output - ds3=ds.merge(ds2) - ds3.to_netcdf(datdir+'full_sample_output.nc', engine="h5netcdf") + ds3 = ds.merge(ds2) + ds3.to_netcdf(datdir + "full_sample_output.nc", engine="h5netcdf") del ds, ds2 - print('...PI analyses complete and saved') - print('pyPI sample run finished!') + print("...PI analyses complete and saved") + print("pyPI sample run finished!") diff --git a/src/tcpyPI/__init__.py b/src/tcpyPI/__init__.py index 086cb86..47f5741 100644 --- a/src/tcpyPI/__init__.py +++ b/src/tcpyPI/__init__.py @@ -7,22 +7,27 @@ __author__ = "Daniel M. Gilford " # TODO: Re-factor module-wide implicit imports -from .pi import * from .constants import * -from .utilities import * - -# PI log-decomposition (Wing et al. 2015) -from .pi import pi_log_decomposition -# Ventilation Index (TE12) diagnostics -from .vi import ventilation_index, vi, vi_log_decomposition -from .vi import entropy_deficit_te12, entropy_deficit_te12_from_profile +# Genesis Potential Index (GPI) (EXPERIMENTAL) +from .gpi import genesis_potential_index, gpi, gpi_log_decomposition # Power Dissipation Index (PDI) (EXPERIMENTAL) -from .pdi import power_dissipation_index, pdi +from .pdi import pdi, power_dissipation_index +from .pi import * + +# PI log-decomposition (Wing et al. 2015) +from .pi import pi_log_decomposition # Relative intensity from .relative_intensity import relative_intensity +from .utilities import * -# Genesis Potential Index (GPI) (EXPERIMENTAL) -from .gpi import genesis_potential_index, gpi, gpi_log_decomposition +# Ventilation Index (TE12) diagnostics +from .vi import ( + entropy_deficit_te12, + entropy_deficit_te12_from_profile, + ventilation_index, + vi, + vi_log_decomposition, +) diff --git a/src/tcpyPI/constants.py b/src/tcpyPI/constants.py index 4db99b0..bf1bac8 100644 --- a/src/tcpyPI/constants.py +++ b/src/tcpyPI/constants.py @@ -14,7 +14,12 @@ Specific heat of liquid water [J/kg/K]. Set to Emanuel's **modified** value of 2500 (rather than the physical ~4190) for internal consistency with the pcmin entropy formulation; this is why :func:`tcpyPI.utilities.Lv` is not the standard - Kirchhoff latent heat. + Kirchhoff latent heat. Sensitivity (quantified on the ERA5 September 2024 North + Atlantic sample, columns with VMAX > 40 m/s): switching to the physical 4190 + raises VMAX by ~+1.2 m/s (+1.8%) on average (up to ~+5.5 m/s on marginal + columns) and deepens PMIN by ~5-6 hPa. The 2500 value is retained deliberately + to remain consistent with BE02/pcmin.m and the published validation + (cf. the historical `checkCL` exploration). CPVMCL : float ``CPV - CL`` [J/kg/K]; sets the temperature dependence of the latent heat. RV : float @@ -42,20 +47,20 @@ # # Thermodynamic Constants -CPD = 1005.7 # [J/kg/K] Specific heat of dry air at constant pressure -CPV = 1870.0 # [J/kg/K] Specific heat of water vapor at constant pressure +CPD = 1005.7 # [J/kg/K] Specific heat of dry air at constant pressure +CPV = 1870.0 # [J/kg/K] Specific heat of water vapor at constant pressure # CL = 4190.0 # [J/kg/K] Specific heat of liquid water (physical value; unused) -CL = 2500.0 # [J/kg/K] Modified specific heat of liquid water (Emanuel/pcmin value) -CPVMCL = CPV - CL # [J/kg/K] CPV - CL -RV = 461.5 # [J/kg/K] gas constant of water vapor -RD = 287.04 # [J/kg/K] gas constant of dry air -EPS = RD / RV # [unitless] epsilon, the ratio of gas constants (~0.622) -ALV0 = 2.501e6 # [J/kg] latent heat of vaporization at 0 degrees C +CL = 2500.0 # [J/kg/K] Modified specific heat of liquid water (Emanuel/pcmin value) +CPVMCL = CPV - CL # [J/kg/K] CPV - CL +RV = 461.5 # [J/kg/K] gas constant of water vapor +RD = 287.04 # [J/kg/K] gas constant of dry air +EPS = RD / RV # [unitless] epsilon, the ratio of gas constants (~0.622) +ALV0 = 2.501e6 # [J/kg] latent heat of vaporization at 0 degrees C # pLCL Empirical Parameters (E94 4.6.24; see utilities.e_pLCL) -A = 1669.0 # [unitless] empirical LCL-pressure parameter -B = 122.0 # [unitless] empirical LCL-pressure parameter +A = 1669.0 # [unitless] empirical LCL-pressure parameter +B = 122.0 # [unitless] empirical LCL-pressure parameter # PI Auxiliaries -b = 2.0 # [unitless] azimuthal-velocity exponent, V=V_m(r/r_m)**b (Emanuel 1995, Eq. 25) -ptop = 50 # [hPa] default pressure below which the sounding is ignored +b = 2.0 # [unitless] azimuthal-velocity exponent, V=V_m(r/r_m)**b (Emanuel 1995, Eq. 25) +ptop = 50 # [hPa] default pressure below which the sounding is ignored diff --git a/src/tcpyPI/gpi.py b/src/tcpyPI/gpi.py index 28f1b5a..7c16a25 100644 --- a/src/tcpyPI/gpi.py +++ b/src/tcpyPI/gpi.py @@ -21,7 +21,7 @@ from __future__ import annotations -from typing import Any, Optional +from typing import Any import numpy as np @@ -39,9 +39,9 @@ def _gpi_en04_numba(abs_vort, rh_mid, v_shear, v_pot): # Published GPIs use the magnitude |eta| (e.g. |1e5 eta|^{3/2}), so take abs() # to accept signed absolute vorticity (f+zeta is negative in the S. Hemisphere). - eta = 1.0e5 * abs(abs_vort) # scaled to O(1) for typical tropical values - rh = rh_mid / 50.0 # normalize humidity - vp = v_pot / 70.0 # normalize potential intensity + eta = 1.0e5 * abs(abs_vort) # scaled to O(1) for typical tropical values + rh = rh_mid / 50.0 # normalize humidity + vp = v_pot / 70.0 # normalize potential intensity shear_term = (1.0 + 0.1 * v_shear) ** (-2.0) # stronger shear reduces genesis return (eta**1.5) * (rh**3.0) * (vp**3.0) * shear_term @@ -98,7 +98,7 @@ def genesis_potential_index( v_pot: Any = None, *, formulation: str = "en04", - chi: Optional[Any] = None, + chi: Any | None = None, ): """Compute the Genesis Potential Index (GPI). @@ -167,9 +167,7 @@ def genesis_potential_index( raise ValueError("v_shear and v_pot are required.") return _broadcast_apply(_gpi_e10_numba, abs_vort, chi, v_shear, v_pot) - raise ValueError( - f"Invalid formulation={formulation!r}; expected one of: 'en04', 'e10'." - ) + raise ValueError(f"Invalid formulation={formulation!r}; expected one of: 'en04', 'e10'.") # Short alias matching the module name. @@ -183,7 +181,7 @@ def gpi_log_decomposition( v_pot: Any = None, *, formulation: str = "en04", - chi: Optional[Any] = None, + chi: Any | None = None, ): """Additive log-space decomposition of the Genesis Potential Index. @@ -222,6 +220,7 @@ def gpi_log_decomposition( >>> round(d["lngpi"] - (d["vorticity"] + d["humidity"] + d["pi"] + d["shear"]), 12) 0.0 """ + def _s(a): return float(a) if a.ndim == 0 else a @@ -243,8 +242,13 @@ def _s(a): pi_t = np.where(bad, np.nan, 3.0 * np.log(vp / 70.0)) sh = np.where(bad, np.nan, -2.0 * np.log(1.0 + 0.1 * vsh)) lngpi = vort + hum + pi_t + sh - return {"lngpi": _s(lngpi), "vorticity": _s(vort), "humidity": _s(hum), - "pi": _s(pi_t), "shear": _s(sh)} + return { + "lngpi": _s(lngpi), + "vorticity": _s(vort), + "humidity": _s(hum), + "pi": _s(pi_t), + "shear": _s(sh), + } if formulation == "e10": if chi is None: @@ -268,9 +272,12 @@ def _s(a): pi_t = np.where(bad, np.nan, 2.0 * np.log(vp_excess)) sh = np.where(bad, np.nan, -4.0 * np.log(25.0 + vsh)) lngpi = vort + chi_t + pi_t + sh - return {"lngpi": _s(lngpi), "vorticity": _s(vort), "chi": _s(chi_t), - "pi": _s(pi_t), "shear": _s(sh)} - - raise ValueError( - f"Invalid formulation={formulation!r}; expected one of: 'en04', 'e10'." - ) + return { + "lngpi": _s(lngpi), + "vorticity": _s(vort), + "chi": _s(chi_t), + "pi": _s(pi_t), + "shear": _s(sh), + } + + raise ValueError(f"Invalid formulation={formulation!r}; expected one of: 'en04', 'e10'.") diff --git a/src/tcpyPI/numba.py b/src/tcpyPI/numba.py index ff1de99..703f602 100644 --- a/src/tcpyPI/numba.py +++ b/src/tcpyPI/numba.py @@ -31,9 +31,7 @@ def wrapper(*args, **kwargs): result = float(result) elif isinstance(result, tuple): # Cast components to float - result = tuple( - float(x) if isinstance(x, np.floating) else x for x in result - ) + result = tuple(float(x) if isinstance(x, np.floating) else x for x in result) return result return wrapper @@ -45,9 +43,33 @@ def wrapper(*args, **kwargs): if os.getenv("TCPYPI_DISABLE_NUMBA") == "1": + _numba_available = False +else: + try: + import numba as nb + + _numba_available = True + except ImportError: + # Graceful degradation: tcpyPI remains importable and correct without + # Numba, just slow (roadmap issue #75, "make numba a lazy dependency"). + import warnings + + warnings.warn( + "Numba is not installed; tcpyPI will run in pure-Python mode " + "(orders of magnitude slower). Install it with `pip install numba` " + "to enable the compiled kernels.", + RuntimeWarning, + stacklevel=2, + ) + _numba_available = False + +if not _numba_available: njit = noop_njit + # No pure-Python generalized-ufunc equivalent; consumers (pi_field) fall back + # to a per-column loop when this is None. + guvectorize = None else: - import numba as nb + guvectorize = nb.guvectorize def njit(*args, **kwargs): """``numba.njit`` with on-disk caching enabled by default. diff --git a/src/tcpyPI/pdi.py b/src/tcpyPI/pdi.py index 1f34f84..0e216bc 100644 --- a/src/tcpyPI/pdi.py +++ b/src/tcpyPI/pdi.py @@ -119,4 +119,3 @@ def power_dissipation_index( # Short alias matching the module name. pdi = power_dissipation_index - diff --git a/src/tcpyPI/pi.py b/src/tcpyPI/pi.py index c1ba4b6..f594db7 100644 --- a/src/tcpyPI/pi.py +++ b/src/tcpyPI/pi.py @@ -21,7 +21,7 @@ Revised 8/4/16 by D. Gilford to include lack of convergence if SST < 5C for TO/LNB Revised 8/5/16 by D. Gilford to fix the "cape()" function output and include LNB Revised 10/3/16 by D. Gilford to set LNB to the pressure-weighted crossing of buoyancy from negative to positive (the zero-line) - Revised 1/7/2017 by Luke Davis to fix and improper definition of JMIN, which should be the lowest profile level at or above the parcel level in the calculation of CAPE. Kerry is grateful to Luke and to Tim Merlis for pointing out this error. In practice, the error was usually less than 1 hPa in central pressure. + Revised 1/7/2017 by Luke Davis to fix and improper definition of JMIN, which should be the lowest profile level at or above the parcel level in the calculation of CAPE. Kerry is grateful to Luke and to Tim Merlis for pointing out this error. In practice, the error was usually less than 1 hPa in central pressure. --Converted to Python 04/2020 Revised 4/10/2020 by D. Rothenberg (daniel@danielrothenberg.com) for Numba optimization Revised 4/13/2020 by D. Gilford to add new handling of missing profile data @@ -42,23 +42,26 @@ - `cape()` now retains all levels with pressure > ptop (previously the level nearest ptop could be dropped when no level fell exactly at ptop). - Under miss_handle=0, the parcel is now lifted from the lowest valid level (previously a NaN in the lowest level(s) produced a NaN parcel and unconverged output). - Moved the PI log-decomposition into this module as `pi_log_decomposition` (from the former analyses.py) and removed the redundant run-and-decompose wrapper, matching the `vi_log_decomposition`/`gpi_log_decomposition` APIs. + - Initialized the output flag before the environmental-CAPE call (as in pcmin.m) so a flag tripped by that call is no longer overwritten (GitHub issue #78). + - Added a period-2 oscillation rescue to the minimum-pressure iteration: marginal near-neutral soundings whose fixed-point map locks into a 2-cycle (previously non-convergent, IFL=2) are collapsed to the cycle midpoint and converge (IFL=1). Previously-converging profiles are unchanged bit-for-bit. """ # doctest: +ELLIPSIS # import required packages import numpy as np -from .numba import njit -from . import constants -from . import utilities + +from . import constants, utilities +from .numba import guvectorize, njit + # define the function to calculate CAPE @njit() -def cape(TP,RP,PP,T,R,P,ascent_flag=0,ptop=50,miss_handle=1): +def cape(TP, RP, PP, T, R, P, ascent_flag=0, ptop=50, miss_handle=1): """Calculate the CAPE of a parcel given parcel and environmental conditions. function [CAPED,TOB,LNB,IFLAG]= cape(TP,RP,PP,T,R,P,ascent_flag=0,ptop=50,miss_handle=1) - This function calculates the CAPE of a parcel given parcel pressure PP (hPa), + This function calculates the CAPE of a parcel given parcel pressure PP (hPa), temperature TP (K) and mixing ratio RP (gram/gram) and given a sounding of temperature (T in K) and mixing ratio (R in gram/gram) as a function of pressure (P in hPa). CAPED is the calculated value of CAPE following @@ -123,83 +126,82 @@ def cape(TP,RP,PP,T,R,P,ascent_flag=0,ptop=50,miss_handle=1): # # *** Handle missing values *** # - + # find if any values are missing in the temperature or mixing ratio array - valid_i=~np.isnan(T) - first_valid=np.where(valid_i)[0][0] + valid_i = ~np.isnan(T) + first_valid = np.where(valid_i)[0][0] # Are there missing values? If so, assess according to flag - if (np.sum(valid_i) != len(P)): + if np.sum(valid_i) != len(P): # if not allowed, set IFLAG=3 and return missing CAPE - if (miss_handle != 0): - CAPED=np.nan - TOB=np.nan - LNB=np.nan - IFLAG=3 + if miss_handle != 0: + CAPED = np.nan + TOB = np.nan + LNB = np.nan + IFLAG = 3 # Return the unsuitable values - return(CAPED,TOB,LNB,IFLAG) + return (CAPED, TOB, LNB, IFLAG) else: # if allowed, but there are missing values between the lowest existing level # and ptop, then set IFLAG=3 and return missing CAPE - if np.sum(np.isnan(T[first_valid:len(P)])>0): - CAPED=np.nan - TOB=np.nan - LNB=np.nan - IFLAG=3 + if np.sum(np.isnan(T[first_valid : len(P)]) > 0): + CAPED = np.nan + TOB = np.nan + LNB = np.nan + IFLAG = 3 # Return the unsuitable values - return(CAPED,TOB,LNB,IFLAG) + return (CAPED, TOB, LNB, IFLAG) else: - first_lvl=first_valid + first_lvl = first_valid else: - first_lvl=0 + first_lvl = 0 # Populate new environmental profiles removing values above ptop and # find new number, N, of profile levels with which to calculate CAPE. # Keep every level with P > ptop (matching pcmin); with the profile ordered # by decreasing pressure these are the leading N entries. Using argmin(|P-ptop|) # would drop the topmost retained level whenever no level sits exactly at ptop. - N=int(np.count_nonzero(P > ptop)) + N = int(np.count_nonzero(P > ptop)) - P=P[first_lvl:N] - T=T[first_lvl:N] - R=R[first_lvl:N] - nlvl=len(P) + P = P[first_lvl:N] + T = T[first_lvl:N] + R = R[first_lvl:N] + nlvl = len(P) TVRDIF = np.zeros((nlvl,)) - + # # *** Run checks *** # - + # CHECK: is the input profile ordered with increasing pressure? If not, return missing CAPE - if (P[2]-P[1] > 0): - CAPED=0 - TOB=np.nan - LNB=np.nan - IFLAG=0 + if P[2] - P[1] > 0: + CAPED = 0 + TOB = np.nan + LNB = np.nan + IFLAG = 0 # Return the unsuitable values - return(CAPED,TOB,LNB,IFLAG) + return (CAPED, TOB, LNB, IFLAG) # CHECK: Is the input parcel suitable? If not, return missing CAPE - if ((RP < 1e-6) or (TP < 200)): - CAPED=0 - TOB=np.nan - LNB=np.nan - IFLAG=0 + if (RP < 1e-6) or (TP < 200): + CAPED = 0 + TOB = np.nan + LNB = np.nan + IFLAG = 0 # Return the unsuitable values - return(CAPED,TOB,LNB,IFLAG) - + return (CAPED, TOB, LNB, IFLAG) + # # *** Define various parcel quantities, including reversible *** # *** entropy, S *** - # - TPC=utilities.T_ktoC(TP) # Parcel temperature in Celsius - ESP=utilities.es_cc(TPC) # Parcel's saturated vapor pressure - EVP=utilities.ev(RP,PP) # Parcel's partial vapor pressure - RH=EVP/ESP # Parcel's relative humidity - RH=min([RH,1.0]) # ensure that the relatively humidity does not exceed 1.0 + # + TPC = utilities.T_ktoC(TP) # Parcel temperature in Celsius + ESP = utilities.es_cc(TPC) # Parcel's saturated vapor pressure + EVP = utilities.ev(RP, PP) # Parcel's partial vapor pressure + RH = EVP / ESP # Parcel's relative humidity + RH = min(RH, 1.0) # ensure that the relatively humidity does not exceed 1.0 # calculate reversible total specific entropy per unit mass of dry air (E94, EQN. 4.5.9) - S=utilities.entropy_S(TP,RP,PP) - - + S = utilities.entropy_S(TP, RP, PP) + # # *** Estimate lifted condensation level pressure, PLCL *** # Based on E94 "calcsound.f" code at http://texmex.mit.edu/pub/emanuel/BOOK/ @@ -209,130 +211,132 @@ def cape(TP,RP,PP,T,R,P,ascent_flag=0,ptop=50,miss_handle=1): # see https://journals.ametsoc.org/doi/pdf/10.1175/JAS-D-17-0102.1 # and Python PLCL code at http://romps.berkeley.edu/papers/pubdata/2016/lcl/lcl.py # - PLCL=utilities.e_pLCL(TP,RH,PP) - + PLCL = utilities.e_pLCL(TP, RH, PP) + # Initial default values before loop - CAPED=0 - TOB=T[0] - IFLAG=1 + CAPED = 0 + TOB = T[0] + IFLAG = 1 # Values to help loop - NCMAX=0 - jmin=int(1e6) - + jmin = int(1e6) + # # *** Begin updraft loop *** # # loop over each level in the profile for j in range(nlvl): - # jmin is the index of the lowest pressure level evaluated in the loop - jmin=int(min([jmin,j])) - + jmin = int(min(jmin, j)) + # # *** Calculate Parcel quantities BELOW lifted condensation level *** # - if (P[j] >= PLCL): + if P[j] >= PLCL: # Parcel temperature at this pressure - TG=TP*(P[j]/PP)**(constants.RD/constants.CPD) + TG = TP * (P[j] / PP) ** (constants.RD / constants.CPD) # Parcel Mixing ratio - RG=RP + RG = RP # Parcel and Environmental Density Temperatures at this pressure (E94, EQN. 4.3.1 and 6.3.7) - TLVR=utilities.Trho(TG,RG,RG) - TVENV=utilities.Trho(T[j],R[j],R[j]) + TLVR = utilities.Trho(TG, RG, RG) + TVENV = utilities.Trho(T[j], R[j], R[j]) # Bouyancy of the parcel in the environment (Proxy of E94, EQN. 6.1.5) - TVRDIF[j,]=TLVR-TVENV - + TVRDIF[j,] = TLVR - TVENV + # # *** Calculate Parcel quantities ABOVE lifted condensation level *** - # + # else: TG, RG, IFLAG = solve_temperature_from_entropy(S=S, P=P[j], RP=RP, T_initial=T[j]) if IFLAG == 2: # Did not converge - CAPED=0 - TOB=T[0] - LNB=P[0] + CAPED = 0 + TOB = T[0] + LNB = P[0] # Return the uncoverged values - return(CAPED,TOB,LNB,IFLAG) + return (CAPED, TOB, LNB, IFLAG) # # *** Calculate buoyancy *** # # Parcel total mixing ratio: either reversible (ascent_flag=0) or pseudo-adiabatic (ascent_flag=1) - RMEAN=ascent_flag*RG+(1-ascent_flag)*RP + RMEAN = ascent_flag * RG + (1 - ascent_flag) * RP # Parcel and Environmental Density Temperatures at this pressure (E94, EQN. 4.3.1 and 6.3.7) - TLVR=utilities.Trho(TG,RMEAN,RG) - TENV=utilities.Trho(T[j],R[j],R[j]) + TLVR = utilities.Trho(TG, RMEAN, RG) + TENV = utilities.Trho(T[j], R[j], R[j]) # Bouyancy of the parcel in the environment (Proxy of E94, EQN. 6.1.5) - TVRDIF[j,]=TLVR-TENV - + TVRDIF[j,] = TLVR - TENV # # *** Begin loop to find Positive areas (PA) and Negative areas (NA) *** # *** and CAPE from reversible ascent *** - NA=0.0 - PA=0.0 - + NA = 0.0 + PA = 0.0 + # # *** Find maximum level of positive buoyancy, INB *** # - INB=0 - for j in range(nlvl-1, jmin, -1): - if (TVRDIF[j] > 0): - INB=max([INB,j]) - - # CHECK: Is the LNB higher than the surface? If not, return zero CAPE - if (INB==0): - CAPED=0 - TOB=T[0] - LNB=P[INB] -# TOB=np.nan - LNB=0 + INB = 0 + for j in range(nlvl - 1, jmin, -1): + if TVRDIF[j] > 0: + INB = max(INB, j) + + # CHECK: Is the LNB higher than the surface? If not, return zero CAPE + if INB == 0: + CAPED = 0 + TOB = T[0] + LNB = P[INB] + # TOB=np.nan + LNB = 0 # Return the unconverged values - return(CAPED,TOB,LNB,IFLAG) - + return (CAPED, TOB, LNB, IFLAG) + # if check is passed, continue with the CAPE calculation else: - - # - # *** Find positive and negative areas and CAPE *** - # via E94, EQN. 6.3.6) - # - for j in range(jmin+1, INB+1, 1): - PFAC=constants.RD*(TVRDIF[j]+TVRDIF[j-1])*(P[j-1]-P[j])/(P[j]+P[j-1]) - PA=PA+max([PFAC,0.0]) - NA=NA-min([PFAC,0.0]) + # + # *** Find positive and negative areas and CAPE *** + # via E94, EQN. 6.3.6) + # + for j in range(jmin + 1, INB + 1, 1): + PFAC = ( + constants.RD * (TVRDIF[j] + TVRDIF[j - 1]) * (P[j - 1] - P[j]) / (P[j] + P[j - 1]) + ) + PA = PA + max(PFAC, 0.0) + NA = NA - min(PFAC, 0.0) - # - # *** Find area between parcel pressure and first level above it *** - # - PMA=(PP+P[jmin]) - PFAC=constants.RD*(PP-P[jmin])/PMA - PA=PA+PFAC*max([TVRDIF[jmin],0.0]) - NA=NA-PFAC*min([TVRDIF[jmin],0.0]) - - # - # *** Find residual positive area above INB and TO *** - # and finalize estimate of LNB and its temperature - # - PAT=0.0 - TOB=T[INB] - LNB=P[INB] - if (INB < nlvl-1): - PINB=(P[INB+1]*TVRDIF[INB]-P[INB]*TVRDIF[INB+1])/(TVRDIF[INB]-TVRDIF[INB+1]) - LNB=PINB - PAT=constants.RD*TVRDIF[INB]*(P[INB]-PINB)/(P[INB]+PINB) - TOB=(T[INB]*(PINB-P[INB+1])+T[INB+1]*(P[INB]-PINB))/(P[INB]-P[INB+1]) - - # - # *** Find CAPE *** - # - CAPED=PA+PAT-NA - CAPED=max([CAPED,0.0]) + # + # *** Find area between parcel pressure and first level above it *** + # + PMA = PP + P[jmin] + PFAC = constants.RD * (PP - P[jmin]) / PMA + PA = PA + PFAC * max(TVRDIF[jmin], 0.0) + NA = NA - PFAC * min(TVRDIF[jmin], 0.0) + + # + # *** Find residual positive area above INB and TO *** + # and finalize estimate of LNB and its temperature + # + PAT = 0.0 + TOB = T[INB] + LNB = P[INB] + if INB < nlvl - 1: + PINB = (P[INB + 1] * TVRDIF[INB] - P[INB] * TVRDIF[INB + 1]) / ( + TVRDIF[INB] - TVRDIF[INB + 1] + ) + LNB = PINB + PAT = constants.RD * TVRDIF[INB] * (P[INB] - PINB) / (P[INB] + PINB) + TOB = (T[INB] * (PINB - P[INB + 1]) + T[INB + 1] * (P[INB] - PINB)) / ( + P[INB] - P[INB + 1] + ) + + # + # *** Find CAPE *** + # + CAPED = PA + PAT - NA + CAPED = max(CAPED, 0.0) # set the flag to OK if procedure reached this point - IFLAG=1 - # Return the calculated outputs to the above program level - return(CAPED,TOB,LNB,IFLAG) + IFLAG = 1 + # Return the calculated outputs to the above program level + return (CAPED, TOB, LNB, IFLAG) @njit() @@ -380,64 +384,64 @@ def solve_temperature_from_entropy(S, P, RP, T_initial): TG: 292.676..., RG: 0.0144..., IFLAG: 1 """ # Initial default values before loop - TGNEW=T_initial - TJC=utilities.T_ktoC(T_initial) - ES=utilities.es_cc(TJC) - RG=utilities.rv(ES,P) - + TGNEW = T_initial + TJC = utilities.T_ktoC(T_initial) + ES = utilities.es_cc(TJC) + RG = utilities.rv(ES, P) + # # *** Iteratively calculate lifted parcel temperature and mixing *** # *** ratio for reversible ascent *** # - + # set loop counter and initial condition - NC=0 - TG=0 + NC = 0 + TG = 0 # loop until loop converges or bails out - while ((np.abs(TGNEW-TG)) > 0.001): - + while (np.abs(TGNEW - TG)) > 0.001: # Parcel temperature and mixing ratio during this iteration - TG=TGNEW - TC=utilities.T_ktoC(TG) - ENEW=utilities.es_cc(TC) - RG=utilities.rv(ENEW,P) - + TG = TGNEW + TC = utilities.T_ktoC(TG) + ENEW = utilities.es_cc(TC) + RG = utilities.rv(ENEW, P) + # increase iteration count in the loop NC += 1 - + # # *** Calculate estimates of the rates of change of the entropy *** # *** with temperature at constant pressure *** # - ALV=utilities.Lv(TC) + ALV = utilities.Lv(TC) # calculate the rate of change of entropy with temperature, s_ell - SL=(constants.CPD+RP*constants.CL+ALV*ALV*RG/(constants.RV*TG*TG))/TG - EM=utilities.ev(RG,P) + SL = (constants.CPD + RP * constants.CL + ALV * ALV * RG / (constants.RV * TG * TG)) / TG + EM = utilities.ev(RG, P) # calculate the saturated entropy, s_k, noting r_T=RP and # the last term vanishes with saturation, i.e. RH=1 - SG=(constants.CPD+RP*constants.CL)*np.log(TG)-constants.RD*np.log(P-EM)+ALV*RG/TG - # convergence speed (AP, step in entropy fraction) varies as a function of + SG = ( + (constants.CPD + RP * constants.CL) * np.log(TG) + - constants.RD * np.log(P - EM) + + ALV * RG / TG + ) + # convergence speed (AP, step in entropy fraction) varies as a function of # number of iterations - if (NC < 3): + if NC < 3: # converge slowly with a smaller step - AP=0.3 + AP = 0.3 else: # speed the process with a larger step when nearing convergence - AP=1.0 + AP = 1.0 # find the new temperature in the iteration - TGNEW=TG+AP*(S-SG)/SL - + TGNEW = TG + AP * (S - SG) / SL + # # *** If the routine does not converge, set IFLAG=2 and bail out *** # - if (NC > 500) or (ENEW > (P-1)): + if (NC > 500) or (ENEW > (P - 1)): IFLAG = 2 # Did not converge return TG, RG, IFLAG - - # store the number of iterations - NCMAX=NC IFLAG = 1 # Success return TG, RG, IFLAG @@ -469,181 +473,236 @@ def _pi_numba( """ # convert units - SSTK=utilities.T_Ctok(SSTC) # SST in kelvin - T=utilities.T_Ctok(TC) # Temperature profile in kelvin - R=R*0.001 # Mixing ratio profile in g/g + SSTK = utilities.T_Ctok(SSTC) # SST in kelvin + T = utilities.T_Ctok(TC) # Temperature profile in kelvin + R = R * 0.001 # Mixing ratio profile in g/g + + # CHECK 0: is MSL missing? If so, set IFL=3 and return missing PI. + # (Mirrors the pi() wrapper guard with the same precedence; needed for the + # whole-field pi_field path, where per-cell MSL NaNs reach this compiled core + # directly. Untaken for valid MSL, so existing results are unchanged.) + if np.isnan(MSL): + VMAX = np.nan + PMIN = np.nan + IFL = 3 + TO = np.nan + OTL = np.nan + return (VMAX, PMIN, IFL, TO, OTL) # CHECK 1a: do SSTs exceed 5C? # CHECK 1b: are SSTs less than 100C (if not, indicative of input in kelvin) # If not, set IFL=0 and return missing PI - if (SSTC <= 5.0 or SSTC>100): - VMAX=np.nan - PMIN=np.nan - IFL=0 - TO=np.nan - OTL=np.nan - return(VMAX,PMIN,IFL,TO,OTL) + if SSTC <= 5.0 or SSTC > 100: + VMAX = np.nan + PMIN = np.nan + IFL = 0 + TO = np.nan + OTL = np.nan + return (VMAX, PMIN, IFL, TO, OTL) # CHECK 1c: are SSTs missing? If so, set IFL=0 and return missing PI - elif (np.isnan(SSTC)==True): - VMAX=np.nan - PMIN=np.nan - IFL=0 - TO=np.nan - OTL=np.nan - return(VMAX,PMIN,IFL,TO,OTL) + elif np.isnan(SSTC): + VMAX = np.nan + PMIN = np.nan + IFL = 0 + TO = np.nan + OTL = np.nan + return (VMAX, PMIN, IFL, TO, OTL) # CHECK 2a: do Temperature profiles exceed 100K? # CHECK 2b: are Temperatures in Celsius less than 100C (if not, indicative of input in kelvin) # If not, set IFL=0 and return missing PI - if (np.min(T) <= 100 or np.max(TC)>100): - VMAX=np.nan - PMIN=np.nan - IFL=0 - TO=np.nan - OTL=np.nan - return(VMAX,PMIN,IFL,TO,OTL) - + if np.min(T) <= 100 or np.max(TC) > 100: + VMAX = np.nan + PMIN = np.nan + IFL = 0 + TO = np.nan + OTL = np.nan + return (VMAX, PMIN, IFL, TO, OTL) + # Set Missing mixing ratios to zero g/g, following Kerry's BE02 algorithm - R[np.isnan(R)]=0. - + R[np.isnan(R)] = 0.0 + # Saturated water vapor pressure # from Clausius-Clapeyron relation/August-Roche-Magnus formula - ES0=utilities.es_cc(SSTC) + ES0 = utilities.es_cc(SSTC) # define the level from which parcels are lifted. Normally the lowest level # (index 0). Under miss_handle=0 (ignore-NaN), skip any leading missing # temperature levels (e.g. sub-surface levels over topography) so the parcel is # lifted from the lowest *valid* level rather than a NaN. - NK=0 + NK = 0 if miss_handle == 0: valid_T = ~np.isnan(T) if np.any(valid_T): NK = int(np.where(valid_T)[0][0]) # - # *** Find environmental CAPE *** + # *** Find environmental CAPE *** # - TP=T[NK] - RP=R[NK] - PP=P[NK] - result = cape(TP,RP,PP,T,R,P,ascent_flag,ptop,miss_handle) + # Default flag for the CAPE calculations. Initialized BEFORE the environmental + # CAPE call (as in pcmin.m) so a flag tripped by CAPEA is not clobbered by a + # later reset (see GitHub issue #78). + IFL = 1 + TP = T[NK] + RP = R[NK] + PP = P[NK] + result = cape(TP, RP, PP, T, R, P, ascent_flag, ptop, miss_handle) CAPEA = result[0] IFLAG = result[3] # if the CAPE function tripped a flag, set the output IFL to it - if (IFLAG != 1): - IFL=int(IFLAG) - + if IFLAG != 1: + IFL = int(IFLAG) + # # *** Begin iteration to find mimimum pressure *** # - + # set loop counter and initial condition - NP=0 # loop counter - PM=970.0 - PMOLD=PM # initial condition from minimum pressure - PNEW=0.0 # initial condition from minimum pressure - IFL=int(1) # Default flag for CAPE calculation + NP = 0 # loop counter + PM = 970.0 + PMOLD = PM # initial condition from minimum pressure + PNEW = 0.0 # initial condition from minimum pressure - TO_ENV=np.nan - OTL_ENV=np.nan + TO_ENV = np.nan + OTL_ENV = np.nan # loop until convergence or bail out - while (np.abs(PNEW-PMOLD) > 0.5): - + while np.abs(PNEW - PMOLD) > 0.5: # # *** Find CAPE at radius of maximum winds *** # - TP=T[NK] - PP=min([PM,1000.0]) + TP = T[NK] + PP = min(PM, 1000.0) # find the mixing ratio with the average of the lowest level pressure and MSL - RP=constants.EPS*R[NK]*MSL/(PP*(constants.EPS+R[NK])-R[NK]*MSL) - CAPEM, TOB_ENV, LNB_ENV, IFLAG = cape( - TP,RP,PP,T,R,P,ascent_flag,ptop,miss_handle - ) + RP = constants.EPS * R[NK] * MSL / (PP * (constants.EPS + R[NK]) - R[NK] * MSL) + CAPEM, TOB_ENV, LNB_ENV, IFLAG = cape(TP, RP, PP, T, R, P, ascent_flag, ptop, miss_handle) # if the CAPE function tripped a different flag, set the output IFL to it - if (IFLAG != 1): - IFL=int(IFLAG) - TO_ENV=TOB_ENV - OTL_ENV=LNB_ENV - + if IFLAG != 1: + IFL = int(IFLAG) + TO_ENV = TOB_ENV + OTL_ENV = LNB_ENV + # # *** Find saturation CAPE at radius of maximum winds *** # *** Note that TO and OTL are found with this assumption *** # - TP=SSTK - PP=min([PM,1000.0]) - RP=utilities.rv(ES0,PP) - result = cape(TP,RP,PP,T,R,P,ascent_flag,ptop,miss_handle) + TP = SSTK + PP = min(PM, 1000.0) + RP = utilities.rv(ES0, PP) + result = cape(TP, RP, PP, T, R, P, ascent_flag, ptop, miss_handle) CAPEMS, TOMS, LNBS, IFLAG = result # if the CAPE function tripped a flag, set the output IFL to it - if (IFLAG != 1): - IFL=int(IFLAG) + if IFLAG != 1: + IFL = int(IFLAG) # Store the outflow temperature and level of neutral bouyancy at the outflow level (OTL) - TO=TOMS - OTL=LNBS + TO = TOMS + OTL = LNBS # Optionally use CAPEenv (final-iteration) outflow definition. if outflow_source_flag == 1: - TO=TO_ENV - OTL=OTL_ENV + TO = TO_ENV + OTL = OTL_ENV # Calculate the proxy for TC efficiency (BE02, EQN. 1-3) - RAT=SSTK/TO + RAT = SSTK / TO # If dissipative heating is "off", TC efficiency proxy is set to 1.0 (BE02, pg. 3) - if (diss_flag == 0): - RAT=1.0 - + if diss_flag == 0: + RAT = 1.0 + # # *** Initial estimate of pressure at the radius of maximum winds *** # - RS0=RP + RS0 = RP # Lowest level and Sea-surface Density Temperature (E94, EQN. 4.3.1 and 6.3.7) - TV0=utilities.Trho(T[NK],R[NK],R[NK]) - TVSST=utilities.Trho(SSTK,RS0,RS0) + TV0 = utilities.Trho(T[NK], R[NK], R[NK]) + TVSST = utilities.Trho(SSTK, RS0, RS0) # Average Surface Density Temperature, e.g. 1/2*[Tv(Tsfc)+Tv(sst)] - TVAV=0.5*(TV0+TVSST) + TVAV = 0.5 * (TV0 + TVSST) # Converge toward CAPE*-CAPEM (BE02, EQN 3-4) - CAT=(CAPEM-CAPEA)+0.5*CKCD*RAT*(CAPEMS-CAPEM) - CAT=max([CAT,0.0]) + CAT = (CAPEM - CAPEA) + 0.5 * CKCD * RAT * (CAPEMS - CAPEM) + CAT = max(CAT, 0.0) # Iterate on pressure - PNEW=MSL*np.exp(-CAT/(constants.RD*TVAV)) - + PNEW = MSL * np.exp(-CAT / (constants.RD * TVAV)) + + # + # *** Rescue persistent period-2 oscillations *** + # + # At this point PM is the current iterate x_n and PMOLD is x_(n-1), i.e. + # the state two iterations back relative to PNEW = x_(n+1). For marginal + # (near-zero environmental CAPE) soundings the fixed-point map can lock + # into a period-2 cycle whose amplitude exceeds the 0.5 hPa tolerance, + # which in BE02/pcmin.m runs to the iteration cap and returns missing. + # When PNEW returns to within eps of x_(n-1) while the step is still + # super-tolerance, collapse to the cycle midpoint and continue; the loop + # then exits through the normal convergence path (IFL=1). Convergent + # trajectories exit within ~10 iterations and never reach this branch, + # so all previously-converging results are unchanged bit-for-bit. + if (NP >= 10) and (np.abs(PNEW - PMOLD) < 1e-5) and (np.abs(PNEW - PM) > 0.5): + PNEW = 0.5 * (PNEW + PM) + # # *** Test for convergence (setup for possible next while iteration) *** # - # store the previous step's pressure - PMOLD=PM + # store the previous step's pressure + PMOLD = PM # store the current step's pressure - PM=PNEW - + PM = PNEW + # increase iteration count in the loop NP += 1 # # *** If the routine does not converge, set IFL=2 and return missing PI *** # - if (NP > 200) or (PM < 400): - VMAX=np.nan - PMIN=np.nan - IFL=2 - TO=np.nan - OTL=np.nan - return(VMAX,PMIN,IFL,TO,OTL) - + if (NP > 200) or (PM < 400): + VMAX = np.nan + PMIN = np.nan + IFL = 2 + TO = np.nan + OTL = np.nan + return (VMAX, PMIN, IFL, TO, OTL) + # Once converged, set potential intensity at the radius of maximum winds - CATFAC=0.5*(1.+1/constants.b) - CAT=(CAPEM-CAPEA)+CKCD*RAT*CATFAC*(CAPEMS-CAPEM) - CAT=max([CAT,0.0]) - + CATFAC = 0.5 * (1.0 + 1 / constants.b) + CAT = (CAPEM - CAPEA) + CKCD * RAT * CATFAC * (CAPEMS - CAPEM) + CAT = max(CAT, 0.0) + # Calculate the minimum pressure at the eye of the storm # BE02 EQN. 4 - PMIN=MSL*np.exp(-CAT/(constants.RD*TVAV)) - + PMIN = MSL * np.exp(-CAT / (constants.RD * TVAV)) + # Calculate the potential intensity at the radius of maximum winds - # BE02 EQN. 3, reduced by some fraction (default 20%) to account for the reduction + # BE02 EQN. 3, reduced by some fraction (default 20%) to account for the reduction # of 10-m winds from gradient wind speeds (Emanuel 2000, Powell 1980) - FAC=max([0.0,(CAPEMS-CAPEM)]) - VMAX=V_reduc*np.sqrt(CKCD*RAT*FAC) - + FAC = max(0.0, (CAPEMS - CAPEM)) + VMAX = V_reduc * np.sqrt(CKCD * RAT * FAC) + # Return the calculated outputs to the above program level - return(VMAX,PMIN,IFL,TO,OTL) + return (VMAX, PMIN, IFL, TO, OTL) + + +def _outflow_source_flag(outflow_source): + """Map the ``outflow_source`` keyword to the compiled core's integer flag. + + Shared by :func:`pi` and :func:`pi_field` so the accepted values and error + message cannot drift between the two entry points. + """ + if outflow_source == "cape_star": + return 0 + if outflow_source == "cape_env": + return 1 + raise ValueError( + f"Invalid outflow_source={outflow_source!r}; expected 'cape_star' or 'cape_env'." + ) + + +def _sort_profile_descending(P, TC, R): + """Sort profile arrays to decreasing pressure along the trailing level axis. + + Shared by :func:`pi` (1-D profiles) and :func:`pi_field` (N-D fields with the + level dimension last); already-descending input is returned untouched. + """ + order = np.argsort(P)[::-1] + if np.array_equal(order, np.arange(P.size)): + return P, TC, R + return P[order], np.take(TC, order, axis=-1), np.take(R, order, axis=-1) def pi( @@ -742,9 +801,26 @@ def pi( Status flag: - ``1``: success - - ``0``: no convergence - - ``2``: CAPE routine failed to converge - - ``3``: CAPE routine failed due to missing data + - ``0``: invalid input (e.g. SST <= 5 C, Kelvin-like units, improper sounding) + - ``2``: routine did not converge (pressure iteration or CAPE solver) + - ``3``: missing data in the input profile + + Notes on flag semantics: + + - For marginal (near-zero CAPE) soundings whose pressure iteration + locks into a persistent period-2 oscillation, the solver collapses + the cycle to its midpoint and converges (``IFL=1``) when the cycle + amplitude is at most ~1 hPa (twice the convergence tolerance) — + which covers the observed marginal cases. Larger-amplitude cycles + fail safe and still return ``IFL=2``. This is a documented, + deliberate improvement over pcmin.m, which returns missing for all + such soundings. + - A flag tripped by the *environmental*-CAPE calculation persists + (see GitHub issue #78), so ``IFL=0`` or ``IFL=3`` can accompany + finite ``VMAX``/``PMIN`` on an otherwise-converged column (e.g. a + degenerate near-dry surface parcel). Treat ``IFL==1`` as the + "fully trustworthy output" gate. (pcmin.m collapses these cases to + its generic non-convergence flag instead.) - TO : float Outflow temperature (K). - OTL : float @@ -817,35 +893,24 @@ def pi( >>> pi(SSTC, MSL, P, TC, R + nan_in_levels) (82.4845..., 900.2039..., 1, 197.1666..., 84.9169...) """ - if outflow_source == "cape_star": - outflow_source_flag = 0 - elif outflow_source == "cape_env": - outflow_source_flag = 1 - else: - raise ValueError( - f"Invalid outflow_source={outflow_source!r}; expected 'cape_star' or 'cape_env'." - ) + outflow_source_flag = _outflow_source_flag(outflow_source) P = np.asarray(P) TC = np.asarray(TC) R = np.asarray(R) - # Guard against NaNs the Numba core cannot flag safely. A NaN in the pressure - # array or in MSL poisons the CAPE integration and the pressure-convergence - # loop, which can otherwise exit early and return numerically plausible values - # with IFL=1. Fail fast to IFL=3 (missing data), matching NaN handling of the - # temperature profile. - if np.any(np.isnan(P)) or np.any(np.isnan(np.asarray(MSL, dtype=float))): + # Guard against NaNs in the shared pressure array, which poison the CAPE + # integration (the loop can otherwise exit early and return numerically + # plausible values with IFL=1). Fail fast to IFL=3 (missing data). NaN MSL is + # handled by CHECK 0 inside the compiled core, the single owner of that policy + # for both pi() and pi_field(). + if np.any(np.isnan(P)): return (np.nan, np.nan, 3, np.nan, np.nan) # Order-agnostic: the algorithm requires lowest index = lowest level # (decreasing pressure). Sort the profile here so any input ordering is # accepted; already-descending input is left untouched. - order = np.argsort(P)[::-1] - if not np.array_equal(order, np.arange(P.size)): - P = P[order] - TC = TC[order] - R = R[order] + P, TC, R = _sort_profile_descending(P, TC, R) return _pi_numba( SSTC, @@ -863,6 +928,216 @@ def pi( ) +if guvectorize is not None: + # Whole-field generalized ufunc around the compiled per-column core. Processing + # the entire field inside compiled, multithreaded code removes the per-column + # Python-loop overhead of xarray.apply_ufunc(..., vectorize=True) (the speedup + # highlighted by GitHub issue #86). Same per-column math as pi(): results are + # bit-identical for identical (float64) inputs. + @guvectorize( + [ + "void(float64, float64, float64[:], float64[:], float64[:], " + "float64, int64, int64, float64, float64, int64, int64, " + "float64[:], float64[:], int64[:], float64[:], float64[:])" + ], + "(),(),(n),(n),(n),(),(),(),(),(),(),()->(),(),(),(),()", + target="parallel", + cache=True, + ) + def _pi_field_gufunc( + sstc, + msl, + p, + tc, + r, + ckcd, + ascent_flag, + diss_flag, + v_reduc, + ptop, + miss_handle, + outflow_source_flag, + vmax, + pmin, + ifl, + to, + otl, + ): + res = _pi_numba( + sstc, + msl, + p, + tc, + r, + ckcd, + ascent_flag, + diss_flag, + v_reduc, + ptop, + miss_handle, + outflow_source_flag, + ) + vmax[0] = res[0] + pmin[0] = res[1] + ifl[0] = res[2] + to[0] = res[3] + otl[0] = res[4] +else: # pragma: no cover - exercised only with TCPYPI_DISABLE_NUMBA=1 + _pi_field_gufunc = None + + +def pi_field( + SSTC, + MSL, + P, + TC, + R, + *, + CKCD=0.9, + ascent_flag=0, + diss_flag=1, + V_reduc=0.8, + ptop=50, + miss_handle=1, + outflow_source="cape_star", +): + r"""Calculate potential intensity over a whole gridded field at once. + + A fast, compiled, multithreaded path over many columns: the entire field is + processed inside a Numba generalized ufunc (``target='parallel'``), removing + the per-column Python-loop overhead of ``xarray.apply_ufunc(pi, ..., + vectorize=True)``. The per-column math is identical to :func:`pi` (the same + compiled core), so for identical float64 inputs the results are bit-identical. + Motivated by the whole-field benchmark in GitHub issue #86 — implemented + natively so only tcpyPI code executes. + + Parameters + ---------- + SSTC : array-like + Sea surface temperatures (C); any shape (e.g. ``(month, lat, lon)``). + NaN cells (e.g. land) return missing with ``IFL=0``. + MSL : array-like + Mean sea level pressures (hPa), broadcastable against `SSTC`. + NaN cells return missing with ``IFL=3``. + P : array + 1-D pressure levels (hPa), shared by all columns. Any vertical order is + accepted (sorted internally to decreasing pressure). + TC, R : array-like + Temperature (C) and mixing ratio (g/kg) profiles. The **level dimension + must be the last (trailing) axis**; leading axes broadcast against `SSTC`. + (With xarray, ``xr.apply_ufunc(pi_field, ..., input_core_dims=[[], [], + ['p'], ['p'], ['p']], ...)`` arranges this automatically — no + ``vectorize=True`` needed.) + CKCD, ascent_flag, diss_flag, V_reduc, ptop, miss_handle, outflow_source + As in :func:`pi`. + + Returns + ------- + tuple of numpy.ndarray + ``(VMAX, PMIN, IFL, TO, OTL)`` with the broadcast field shape; `IFL` is an + integer array. See :func:`pi` for definitions, units, and flag meanings. + + Notes + ----- + Inputs are converted to float64 (use :func:`pi` directly if you need another + precision path). If Numba is disabled/unavailable, falls back to a per-column + loop over :func:`pi` (slow but correct). + + Examples + -------- + >>> field = pi_field(np.array([[30.0, np.nan]]), 1010.0, + ... np.array([1000., 900, 800, 700, 600, 500, 400, 300, 200, 100, 50]), + ... np.array([28., 22, 16, 11, 5, -2, -11, -27, -49, -79, -64]), + ... np.array([18., 12, 9, 4, 1.7, 1.7, 0.2, 0.1, 0.05, 0.003, 0.002])) + >>> field[2].tolist() # IFL: ocean cell converges, NaN-SST cell is missing + [[1, 0]] + """ + outflow_source_flag = _outflow_source_flag(outflow_source) + + SSTC = np.asarray(SSTC, dtype=np.float64) + MSL = np.asarray(MSL, dtype=np.float64) + # ascontiguousarray for the profile arrays: xarray.apply_ufunc hands us + # transposed (strided) views; a contiguous layout lets the parallel gufunc + # stream each column from adjacent memory. Memory layout only — values (and + # therefore results) are unchanged. + P = np.ascontiguousarray(P, dtype=np.float64) + TC = np.ascontiguousarray(TC, dtype=np.float64) + R = np.ascontiguousarray(R, dtype=np.float64) + + if P.ndim != 1: + raise ValueError( + "pi_field expects a single 1-D pressure-level array shared by all " + "columns; for per-column pressure grids call pi() per column." + ) + if TC.shape[-1] != P.size or R.shape[-1] != P.size: + raise ValueError( + "The level dimension of TC and R must be the last axis and match P " + f"(got P: {P.size}, TC: {TC.shape[-1]}, R: {R.shape[-1]})." + ) + + field_shape = np.broadcast_shapes(SSTC.shape, MSL.shape, TC.shape[:-1], R.shape[:-1]) + + # Global guard (mirrors pi()): a NaN anywhere in the shared pressure array + # poisons every column, so return an all-missing field with IFL=3. + if np.any(np.isnan(P)): + nanfield = np.full(field_shape, np.nan) + return ( + nanfield, + nanfield.copy(), + np.full(field_shape, 3, dtype=np.int64), + nanfield.copy(), + nanfield.copy(), + ) + + # Order-agnostic: sort the shared profile to decreasing pressure once. + P, TC, R = _sort_profile_descending(P, TC, R) + + if _pi_field_gufunc is None: + # Pure-Python fallback (TCPYPI_DISABLE_NUMBA=1 or Numba unavailable). + b_sst, b_msl = np.broadcast_arrays( + np.broadcast_to(SSTC, field_shape), np.broadcast_to(MSL, field_shape) + ) + b_tc = np.broadcast_to(TC, field_shape + (P.size,)) + b_r = np.broadcast_to(R, field_shape + (P.size,)) + vmax = np.full(field_shape, np.nan) + pmin = np.full(field_shape, np.nan) + ifl = np.zeros(field_shape, dtype=np.int64) + to = np.full(field_shape, np.nan) + otl = np.full(field_shape, np.nan) + for idx in np.ndindex(field_shape): + out = pi( + b_sst[idx], + b_msl[idx], + P, + b_tc[idx], + b_r[idx], + CKCD=CKCD, + ascent_flag=ascent_flag, + diss_flag=diss_flag, + V_reduc=V_reduc, + ptop=ptop, + miss_handle=miss_handle, + outflow_source=outflow_source, + ) + vmax[idx], pmin[idx], ifl[idx], to[idx], otl[idx] = out + return (vmax, pmin, ifl, to, otl) + + return _pi_field_gufunc( + SSTC, + MSL, + P, + TC, + R, + float(CKCD), + int(ascent_flag), + int(diss_flag), + float(V_reduc), + float(ptop), + int(miss_handle), + int(outflow_source_flag), + ) + + def pi_log_decomposition(pi, sst, t0, CKCD=0.9, *, sst_units="K"): r"""Log-decompose potential intensity into efficiency, disequilibrium, and Ck/Cd. diff --git a/src/tcpyPI/relative_intensity.py b/src/tcpyPI/relative_intensity.py index 2a7f8a1..52184f1 100644 --- a/src/tcpyPI/relative_intensity.py +++ b/src/tcpyPI/relative_intensity.py @@ -11,7 +11,7 @@ from __future__ import annotations -from typing import Any, Optional +from typing import Any import numpy as np @@ -21,7 +21,7 @@ def relative_intensity( v_pot: Any, *, nan_policy: str = "propagate", - clip: Optional[tuple[float, float]] = None, + clip: tuple[float, float] | None = None, ): """Compute relative intensity ν = V / V_PI. diff --git a/src/tcpyPI/utilities.py b/src/tcpyPI/utilities.py index 44753a3..5be7ee2 100644 --- a/src/tcpyPI/utilities.py +++ b/src/tcpyPI/utilities.py @@ -8,6 +8,7 @@ # ---------------------- Longitude conversion ---------------------- % + def convert_lon_to180(lon360): """Convert longitudes from 0-360E to 180W-180E. @@ -33,7 +34,8 @@ def convert_lon_to180(lon360): 0 """ lon180 = -((-lon360 + 180) % 360 - 180) - return(lon180) + return lon180 + def convert_lon_to360(lon180): """Convert longitudes from 180W-180E to 0-360E. @@ -62,10 +64,12 @@ def convert_lon_to360(lon180): 180 """ lon360 = lon180 % 360 - return(lon360) + return lon360 + # ---------------------- Unit Conversions ---------------------- % + @njit() def T_ktoC(Tk): """Convert kelvin to degrees Celsius. @@ -87,7 +91,8 @@ def T_ktoC(Tk): >>> T_ktoC(283.15) 10.0 """ - return (Tk-273.15) + return Tk - 273.15 + @njit() def T_Ctok(TC): @@ -110,10 +115,12 @@ def T_Ctok(TC): >>> T_Ctok(10) 283.15 """ - return (TC+273.15) + return TC + 273.15 + # ---------------------- Thermodynamic Calculations ---------------------- % + @njit() def es_cc(TC): """Calculate saturated water vapor pressure from Clausius-Clapeyron relation/August-Roche-Magnus formula. @@ -135,12 +142,20 @@ def es_cc(TC): >>> es_cc(0) 6.112... """ - return 6.112*np.exp(17.67*TC/(243.5+TC)) + return 6.112 * np.exp(17.67 * TC / (243.5 + TC)) + @njit() def Lv(TC): """Calculate latent heat of vaporization as a function of temperature. + NOTE: this is Emanuel's pseudoadiabat-tuned latent heat, not the standard + Kirchhoff relation. Its temperature slope is ``CPVMCL = CPV - CL`` with the + modified ``CL = 2500`` J/kg/K from :mod:`tcpyPI.constants` (physical CL would + give a ~2320 J/kg/K slope), so ``Lv(30)`` is ~2% above the physical value. + This is deliberate and internally consistent with the BE02/pcmin entropy + formulation; do not use this function as a general-purpose latent heat. + Parameters ---------- TC : float @@ -158,10 +173,11 @@ def Lv(TC): >>> Lv(20) 2488400.0 """ - return constants.ALV0+constants.CPVMCL*TC + return constants.ALV0 + constants.CPVMCL * TC + @njit() -def ev(R,P): +def ev(R, P): """Calculate parcel vapor pressure. Parameters @@ -183,10 +199,11 @@ def ev(R,P): >>> ev(0.02, 1000) 31.154... """ - return R*P/(constants.EPS+R) + return R * P / (constants.EPS + R) + @njit() -def rv(E,P): +def rv(E, P): """Calculate parcel mixing ratio. Parameters @@ -208,10 +225,11 @@ def rv(E,P): >>> rv(31.250, 1000) 0.020063... """ - return constants.EPS*E/(P-E) + return constants.EPS * E / (P - E) + @njit() -def entropy_S(T,R,P): +def entropy_S(T, R, P): """Calculate total specific entropy per unit mass of dry air (E94, EQN. 4.5.9). Parameters @@ -235,15 +253,21 @@ def entropy_S(T,R,P): >>> entropy_S(290, 0.005, 900) 3868.01... """ - EV=ev(R,P) - ES=es_cc(T-273.15) - RH=min([EV/ES,1.0]) - ALV=Lv(T-273.15) - S=(constants.CPD+R*constants.CL)*np.log(T)-constants.RD*np.log(P-EV)+ALV*R/T-R*constants.RV*np.log(RH) - return(S) + EV = ev(R, P) + ES = es_cc(T - 273.15) + RH = min(EV / ES, 1.0) + ALV = Lv(T - 273.15) + S = ( + (constants.CPD + R * constants.CL) * np.log(T) + - constants.RD * np.log(P - EV) + + ALV * R / T + - R * constants.RV * np.log(RH) + ) + return S + @njit() -def Trho(T,RT,R): +def Trho(T, RT, R): """Calculate density temperature in K. Parameters @@ -267,10 +291,11 @@ def Trho(T,RT,R): >>> Trho(290, 0.01, 0.005) 289.43... """ - return T*(1.+R/constants.EPS)/(1.+RT) + return T * (1.0 + R / constants.EPS) / (1.0 + RT) + @njit() -def e_pLCL(TP,RH,PP): +def e_pLCL(TP, RH, PP): """Calculate empirical lifting condensation level pressure (pLCL). Parameters @@ -294,12 +319,14 @@ def e_pLCL(TP,RH,PP): >>> e_pLCL(290, 0.7, 900) 830.83... """ - return PP*(RH**(TP/(constants.A-constants.B*RH-TP))) + return PP * (RH ** (TP / (constants.A - constants.B * RH - TP))) + # ---------------------- Analyses ---------------------- % + @njit() -def pi_efficiency(sstk,t0): +def pi_efficiency(sstk, t0): """Calculate TC efficiency. Parameters @@ -321,11 +348,12 @@ def pi_efficiency(sstk,t0): >>> pi_efficiency(295, 210) 0.404... """ - efficiency=(sstk-t0)/t0 - return(efficiency) + efficiency = (sstk - t0) / t0 + return efficiency + @njit() -def pi_diseq_resid(pi,sstk,t0,CKCD=0.9): +def pi_diseq_resid(pi, sstk, t0, CKCD=0.9): """Calculate TC air-sea thermodynamic disequilibrium as a residual from Bister and Emanuel (1998; BE98) EQN. 21. Parameters @@ -351,12 +379,13 @@ def pi_diseq_resid(pi,sstk,t0,CKCD=0.9): >>> pi_diseq_resid(50, 295, 210, 0.9) 6862.74... """ - efficiency=(sstk-t0)/t0 - diseq=pi**2/(CKCD*efficiency) - return(diseq) + efficiency = (sstk - t0) / t0 + diseq = pi**2 / (CKCD * efficiency) + return diseq + @njit() -def decompose_pi(pi,sstk,t0,CKCD=0.9): +def decompose_pi(pi, sstk, t0, CKCD=0.9): """Perform decomposition of TC PI terms from Wing et al. (2015), EQN. 2. Parameters @@ -394,21 +423,19 @@ def decompose_pi(pi,sstk,t0,CKCD=0.9): (nan, -0.693..., nan, -0.105...) """ # the natural log of Ck/CD is a constant - lnCKCD=np.log(CKCD) + lnCKCD = np.log(CKCD) # calculate efficiency with SST (K) and Outflow temperature (K) - efficiency=(sstk-t0)/t0 + efficiency = (sstk - t0) / t0 # Is efficiency greater than 0? If not, return missing - if (efficiency>0): - # calculate disequilibrium with the BE98 equality - diseq=pi**2/(CKCD*efficiency) - lneff=np.log(efficiency) + if efficiency > 0: + lneff = np.log(efficiency) # Is potential intensity greater than 0? If not, return missing - if pi>0: - lnpi=2*np.log(pi) + if pi > 0: + lnpi = 2 * np.log(pi) # the log of disequilibrium is calculated as a residual - lndiseq=lnpi-lneff-lnCKCD - return(lnpi,lneff,lndiseq,lnCKCD) + lndiseq = lnpi - lneff - lnCKCD + return (lnpi, lneff, lndiseq, lnCKCD) else: - return(np.nan,lneff,np.nan,lnCKCD) + return (np.nan, lneff, np.nan, lnCKCD) else: - return(np.nan,np.nan,np.nan,lnCKCD) + return (np.nan, np.nan, np.nan, lnCKCD) diff --git a/src/tcpyPI/vi.py b/src/tcpyPI/vi.py index 78454fe..ce49e8d 100644 --- a/src/tcpyPI/vi.py +++ b/src/tcpyPI/vi.py @@ -29,13 +29,12 @@ entropy. """ -from typing import Any, Optional, Tuple +from typing import Any import numpy as np +from . import constants, utilities from .numba import njit -from . import utilities -from . import constants @njit() @@ -110,7 +109,7 @@ def entropy_deficit_te12( out = np.empty_like(s_m_star_arr, dtype=float) it = np.nditer( [s_m_star_arr, s_m_arr, s_sst_star_arr, s_b_arr, out], - op_flags=[["readonly"]] * 4 + [["writeonly"]], + op_flags=[["readonly"]] * 4 + [["writeonly"]], # type: ignore[arg-type] # per-operand flag lists are valid at runtime ) for sm_star, sm, sst_star, sb, o in it: o[...] = _chi_m_te12_numba(float(sm_star), float(sm), float(sst_star), float(sb)) @@ -393,13 +392,13 @@ def entropy_deficit_te12_from_profile( *, T_units: str = "K", q_units: str = "g/kg", - SST: Optional[Any] = None, + SST: Any | None = None, SST_units: str = "K", - psfc_hpa: Optional[Any] = None, - T2m: Optional[Any] = None, - q2m: Optional[Any] = None, + psfc_hpa: Any | None = None, + T2m: Any | None = None, + q2m: Any | None = None, sb_source: str = "t2m", - sb_fallback: Tuple[str, ...] = ("layer_1000_900", "lowest_level"), + sb_fallback: tuple[str, ...] = ("layer_1000_900", "lowest_level"), p_mid_hpa: float = 600.0, s_m_star_source: str = "env_T_at_pmid", entropy_method: str = "emanuel94", @@ -543,9 +542,7 @@ def _sb_flag(name: str) -> int: elif entropy_method == "bryan2008": entropy_method_flag = 1 else: - raise ValueError( - "Invalid entropy_method; expected 'emanuel94' or 'bryan2008'." - ) + raise ValueError("Invalid entropy_method; expected 'emanuel94' or 'bryan2008'.") return float( _chi_m_te12_from_profile_numba( @@ -607,9 +604,7 @@ def ventilation_index( if formulation == "te12": formulation_flag = 0 else: - raise ValueError( - f"Invalid formulation={formulation!r}; expected one of: 'te12'." - ) + raise ValueError(f"Invalid formulation={formulation!r}; expected one of: 'te12'.") if chi_m is None: missing = [ @@ -640,7 +635,7 @@ def ventilation_index( out = np.empty_like(v_shear_arr, dtype=float) it = np.nditer( [v_shear_arr, v_pot_arr, chi_arr, out], - op_flags=[["readonly"]] * 3 + [["writeonly"]], + op_flags=[["readonly"]] * 3 + [["writeonly"]], # type: ignore[arg-type] # per-operand flag lists are valid at runtime ) for vs, vp, ch, o in it: o[...] = _vi_numba(float(vs), float(vp), float(ch), formulation_flag=formulation_flag) diff --git a/tests/test_gpi_api.py b/tests/test_gpi_api.py index 6d226f8..b440bd8 100644 --- a/tests/test_gpi_api.py +++ b/tests/test_gpi_api.py @@ -5,9 +5,9 @@ def test_gpi_en04_scalar_matches_hand_calc(): abs_vort = 2.0e-5 # s^-1 - rh_mid = 60.0 # % - v_shear = 10.0 # m/s - v_pot = 60.0 # m/s + rh_mid = 60.0 # % + v_shear = 10.0 # m/s + v_pot = 60.0 # m/s eta = 1.0e5 * abs_vort rh = rh_mid / 50.0 @@ -22,9 +22,9 @@ def test_gpi_en04_scalar_matches_hand_calc(): def test_gpi_e10_scalar_matches_hand_calc(): # Emanuel (2010, JAMES, Eq. 11): |eta|^3 chi^-4/3 max(Vp-35,0)^2 (25+Vshear)^-4 abs_vort = 5.0e-5 # s^-1 - chi = 1.2 # nondimensional midlevel entropy deficit - v_shear = 10.0 # m/s - v_pot = 60.0 # m/s + chi = 1.2 # nondimensional midlevel entropy deficit + v_shear = 10.0 # m/s + v_pot = 60.0 # m/s expected = ( (abs(abs_vort) ** 3.0) @@ -40,23 +40,17 @@ def test_gpi_e10_scalar_matches_hand_calc(): def test_gpi_e10_threshold_invalid_chi_and_missing_chi(): # V_pot below the 35 m/s threshold -> exactly zero. - z = tcpyPI.genesis_potential_index( - 5.0e-5, v_shear=10.0, v_pot=30.0, formulation="e10", chi=1.2 - ) + z = tcpyPI.genesis_potential_index(5.0e-5, v_shear=10.0, v_pot=30.0, formulation="e10", chi=1.2) assert z == 0.0 # Non-positive chi (entropy deficit) -> NaN (chi^-4/3 undefined). assert np.isnan( - tcpyPI.genesis_potential_index( - 5.0e-5, v_shear=10.0, v_pot=60.0, formulation="e10", chi=0.0 - ) + tcpyPI.genesis_potential_index(5.0e-5, v_shear=10.0, v_pot=60.0, formulation="e10", chi=0.0) ) # e10 without chi raises. with np.testing.assert_raises(ValueError): - tcpyPI.genesis_potential_index( - 5.0e-5, v_shear=10.0, v_pot=60.0, formulation="e10" - ) + tcpyPI.genesis_potential_index(5.0e-5, v_shear=10.0, v_pot=60.0, formulation="e10") def test_gpi_broadcasting_and_invalid_inputs(): @@ -84,9 +78,7 @@ def test_gpi_broadcasting_and_invalid_inputs(): np.testing.assert_allclose(out2[0], pos, rtol=0, atol=0) # NaN vorticity still yields NaN. - assert np.isnan( - tcpyPI.genesis_potential_index(np.nan, 60.0, 10.0, 60.0, formulation="en04") - ) + assert np.isnan(tcpyPI.genesis_potential_index(np.nan, 60.0, 10.0, 60.0, formulation="en04")) with np.testing.assert_raises(ValueError): tcpyPI.genesis_potential_index(2.0e-5, 60.0, 10.0, 60.0, formulation="nope") diff --git a/tests/test_indices_api_dev.py b/tests/test_indices_api_dev.py index ef85516..674cade 100644 --- a/tests/test_indices_api_dev.py +++ b/tests/test_indices_api_dev.py @@ -196,9 +196,9 @@ def test_chi_m_te12_from_profile_moist_adiabat_from_sst_runs_bryan2008(): def test_gpi_en04_scalar_matches_hand_calc(): # Example values in typical ranges. abs_vort = 2.0e-5 # s^-1 - rh_mid = 60.0 # % - v_shear = 10.0 # m/s - v_pot = 60.0 # m/s + rh_mid = 60.0 # % + v_shear = 10.0 # m/s + v_pot = 60.0 # m/s eta = 1.0e5 * abs_vort rh = rh_mid / 50.0 @@ -206,9 +206,7 @@ def test_gpi_en04_scalar_matches_hand_calc(): shear_term = (1.0 + 0.1 * v_shear) ** (-2.0) expected = (eta**1.5) * (rh**3.0) * (vp**3.0) * shear_term - out = tcpyPI.genesis_potential_index( - abs_vort, rh_mid, v_shear, v_pot, formulation="en04" - ) + out = tcpyPI.genesis_potential_index(abs_vort, rh_mid, v_shear, v_pot, formulation="en04") np.testing.assert_allclose(out, expected, rtol=0, atol=0) @@ -236,8 +234,12 @@ def test_pdi_e05_si_and_scaled(): dt = 3600.0 # seconds core = float(np.sum((vmax**3.0) * dt)) - out_si = tcpyPI.power_dissipation_index(vmax, dt, formulation="e05_si", wind_units="m/s", dt_units="s") - out_scaled = tcpyPI.power_dissipation_index(vmax, dt, formulation="e05_1e11", wind_units="m/s", dt_units="s") + out_si = tcpyPI.power_dissipation_index( + vmax, dt, formulation="e05_si", wind_units="m/s", dt_units="s" + ) + out_scaled = tcpyPI.power_dissipation_index( + vmax, dt, formulation="e05_1e11", wind_units="m/s", dt_units="s" + ) np.testing.assert_allclose(out_si, core, rtol=0, atol=0) np.testing.assert_allclose(out_scaled, core / 1.0e11, rtol=0, atol=0) diff --git a/tests/test_log_decomposition_api.py b/tests/test_log_decomposition_api.py index 8554667..0471557 100644 --- a/tests/test_log_decomposition_api.py +++ b/tests/test_log_decomposition_api.py @@ -26,7 +26,7 @@ def test_pi_log_decomposition_vectorized_inputs(): assert np.isfinite(lneff[0]) assert np.isfinite(lndiseq[0]) - assert np.isnan(lnpi[1]) # pi <= 0 + assert np.isnan(lnpi[1]) # pi <= 0 assert np.isfinite(lneff[1]) assert np.isnan(lndiseq[1]) @@ -38,15 +38,39 @@ def test_pi_log_decomposition_from_pi_outputs_closes(): # reconstruct 2*ln(vmax). This replaces the former run-and-decompose wrapper. SSTC = 30 MSL = 1010 - level_data = np.array([ - [1000, 28, 18], [975, 25, 18], [950, 24, 16], [925, 23, 13], [900, 22, 12], - [875, 20, 11], [850, 19, 10], [825, 18, 10], [800, 16, 9], [775, 15, 8], - [750, 13, 7], [700, 11, 4], [650, 8, 3], [600, 5, 1.7], [550, 2, 1.2], - [500, -2, 1.7], [450, -6, 0.7], [400, -11, 0.2], [350, -18, 0.15], - [300, -27, 0.10], [250, -37, 0.11], [225, -43, 0.08], [200, -49, 0.05], - [175, -57, 0.03], [150, -65, 0.014], [125, -73, 0.005], [100, -79, 0.003], - [70, -73, 0.002], [50, -64, 0.002], - ]) + level_data = np.array( + [ + [1000, 28, 18], + [975, 25, 18], + [950, 24, 16], + [925, 23, 13], + [900, 22, 12], + [875, 20, 11], + [850, 19, 10], + [825, 18, 10], + [800, 16, 9], + [775, 15, 8], + [750, 13, 7], + [700, 11, 4], + [650, 8, 3], + [600, 5, 1.7], + [550, 2, 1.2], + [500, -2, 1.7], + [450, -6, 0.7], + [400, -11, 0.2], + [350, -18, 0.15], + [300, -27, 0.10], + [250, -37, 0.11], + [225, -43, 0.08], + [200, -49, 0.05], + [175, -57, 0.03], + [150, -65, 0.014], + [125, -73, 0.005], + [100, -79, 0.003], + [70, -73, 0.002], + [50, -64, 0.002], + ] + ) P, TC, R = level_data[:, 0], level_data[:, 1], level_data[:, 2] vmax, pmin, ifl, t0, otl = tcpyPI.pi(SSTC, MSL, P, TC, R, CKCD=0.9) diff --git a/tests/test_numba_fallback.py b/tests/test_numba_fallback.py new file mode 100644 index 0000000..9a2958c --- /dev/null +++ b/tests/test_numba_fallback.py @@ -0,0 +1,59 @@ +"""tcpyPI must remain importable and correct when Numba is unavailable. + +Runs a fresh interpreter with the `numba` import blocked and checks that +importing tcpyPI warns (RuntimeWarning), and that pi() and pi_field() still +produce correct (pure-Python) results. +""" + +import subprocess +import sys +from pathlib import Path + +_SRC = str(Path(__file__).resolve().parents[1] / "src") + +_SCRIPT = r""" +import sys + +class _BlockNumba: + def find_spec(self, name, path=None, target=None): + if name == "numba" or name.startswith("numba."): + raise ImportError("numba import blocked for fallback test") + return None + +sys.meta_path.insert(0, _BlockNumba()) +sys.path.insert(0, {src!r}) + +import warnings +with warnings.catch_warnings(record=True) as caught: + warnings.simplefilter("always") + import tcpyPI +assert any( + issubclass(w.category, RuntimeWarning) and "pure-Python" in str(w.message) + for w in caught +), "expected a pure-Python-mode RuntimeWarning on import without numba" + +import numpy as np +P = np.array([1000.0, 900, 800, 700, 600, 500, 400, 300, 200, 100, 50]) +TC = np.array([28.0, 22, 16, 11, 5, -2, -11, -27, -49, -79, -64]) +R = np.array([18.0, 12, 9, 4, 1.7, 1.7, 0.2, 0.1, 0.05, 0.003, 0.002]) + +vmax, pmin, ifl, to, otl = tcpyPI.pi(30.0, 1010.0, P, TC, R) +assert ifl == 1 and np.isfinite(vmax), (vmax, ifl) + +# pi_field falls back to a per-column loop and must match pi() exactly. +fv, fp, fi, ft, fo = tcpyPI.pi_field(np.array([[30.0, np.nan]]), 1010.0, P, TC, R) +assert fi[0, 0] == 1 and fi[0, 1] == 0 +assert fv[0, 0] == vmax +print("fallback OK") +""" + + +def test_import_and_compute_without_numba(): + proc = subprocess.run( + [sys.executable, "-c", _SCRIPT.format(src=_SRC)], + capture_output=True, + text=True, + timeout=300, + ) + assert proc.returncode == 0, f"stdout:\n{proc.stdout}\nstderr:\n{proc.stderr}" + assert "fallback OK" in proc.stdout diff --git a/tests/test_oscillation_rescue.py b/tests/test_oscillation_rescue.py new file mode 100644 index 0000000..c5b4104 --- /dev/null +++ b/tests/test_oscillation_rescue.py @@ -0,0 +1,98 @@ +"""Tests for the period-2 oscillation rescue in the minimum-pressure iteration. + +The problematic/control profiles are real adjacent-day soundings (1995) copied +verbatim from notebooks/illustrate_numerical_instability.ipynb. Before the rescue, +the problematic profile locked into a period-2 pressure cycle (~961.0 <-> ~961.7 +hPa, amplitude above the 0.5 hPa tolerance) and returned NaN with IFL=2; the +control profile converged normally. The rescue collapses a detected 2-cycle to its +midpoint so the loop exits through the normal convergence path, while leaving all +previously-converging profiles bit-identical. +""" + +import numpy as np + +import tcpyPI + +PI_OPTIONS = dict(CKCD=0.9, ascent_flag=0, diss_flag=1, ptop=50, miss_handle=1) + +# fmt: off +PROFILE_PROBLEMATIC = np.array([ + [1000.0, 20.266, 9.65], [975.0, 18.11, 9.517], [950.0, 15.978, 9.459], + [925.0, 13.94, 9.205], [900.0, 12.576, 7.784], [875.0, 11.213, 6.561], + [850.0, 9.669, 5.952], [825.0, 8.084, 5.517], [800.0, 6.516, 4.976], + [775.0, 4.993, 4.332], [750.0, 4.374, 3.102], [700.0, 4.93, 1.207], + [650.0, 1.852, 1.521], [600.0, -2.047, 1.263], [550.0, -6.917, 0.857], + [500.0, -13.015, 0.556], [450.0, -19.698, 0.33], [400.0, -26.881, 0.211], + [350.0, -34.178, 0.104], [300.0, -42.822, 0.073], [250.0, -51.573, 0.037], + [225.0, -54.68, 0.027], [200.0, -57.207, 0.018], [175.0, -58.943, 0.01], + [150.0, -60.751, 0.005], [125.0, -63.255, 0.004], [100.0, -63.277, 0.003], + [70.0, -61.5, 0.003], [50.0, -58.453, 0.003], [30.0, -53.327, 0.003], + [20.0, -50.156, 0.003], [10.0, -46.602, 0.003], [7.0, -42.283, 0.003], + [5.0, -35.389, 0.003], [3.0, -22.349, 0.003], [2.0, -14.944, 0.004], + [1.0, -11.886, 0.004], +]) +SST_PROBLEMATIC, MSL_PROBLEMATIC = 25.267, 1012.9 + +PROFILE_CONTROL = np.array([ + [1000.0, 21.326, 11.215], [975.0, 19.192, 11.011], [950.0, 17.315, 10.556], + [925.0, 15.676, 9.931], [900.0, 14.286, 8.639], [875.0, 12.957, 7.58], + [850.0, 11.495, 6.97], [825.0, 10.019, 6.439], [800.0, 8.575, 5.734], + [775.0, 6.993, 5.198], [750.0, 5.373, 4.752], [700.0, 3.13, 3.122], + [650.0, 0.534, 2.562], [600.0, -2.573, 1.442], [550.0, -6.616, 0.865], + [500.0, -12.233, 0.61], [450.0, -18.954, 0.42], [400.0, -26.098, 0.292], + [350.0, -33.337, 0.184], [300.0, -40.639, 0.112], [250.0, -49.373, 0.057], + [225.0, -52.236, 0.03], [200.0, -55.706, 0.017], [175.0, -57.323, 0.01], + [150.0, -60.084, 0.005], [125.0, -65.224, 0.004], [100.0, -65.651, 0.003], + [70.0, -63.457, 0.003], [50.0, -59.522, 0.003], [30.0, -53.504, 0.003], + [20.0, -49.926, 0.003], [10.0, -45.925, 0.003], [7.0, -41.476, 0.003], + [5.0, -34.68, 0.003], [3.0, -23.495, 0.003], [2.0, -16.575, 0.004], + [1.0, -12.898, 0.004], +]) +SST_CONTROL, MSL_CONTROL = 25.292, 1011.4 +# fmt: on + + +def _run(profile, sst, msl): + P, TC, R = profile[:, 0], profile[:, 1], profile[:, 2] + return tcpyPI.pi(sst, msl, P, TC, R, **PI_OPTIONS) + + +def test_problematic_1995_profile_rescued(): + # Previously: period-2 oscillation -> NaN with IFL=2. The rescue collapses the + # cycle to its midpoint and the solver converges through the normal path. + vmax, pmin, ifl, to, otl = _run(PROFILE_PROBLEMATIC, SST_PROBLEMATIC, MSL_PROBLEMATIC) + assert ifl == 1 + assert np.isfinite(vmax) and 60.0 < vmax < 90.0 + assert np.isfinite(pmin) and 925.0 < pmin < 950.0 + assert np.isfinite(to) and np.isfinite(otl) + + +def test_control_1995_profile_bit_identical(): + # The adjacent-day control profile converged before the rescue existed; its + # outputs are pinned here (values captured pre-rescue) to guard bit-identity + # for converging profiles. + vmax, pmin, ifl, to, otl = _run(PROFILE_CONTROL, SST_CONTROL, MSL_CONTROL) + assert ifl == 1 + np.testing.assert_allclose(vmax, 68.98260512391965, rtol=1e-13) + np.testing.assert_allclose(pmin, 943.0252390748838, rtol=1e-13) + np.testing.assert_allclose(to, 214.15121722308447, rtol=1e-13) + np.testing.assert_allclose(otl, 159.82630589536842, rtol=1e-13) + + +def test_fuzz_marginal_profiles(): + # Stress test around the marginal regime: perturb the problematic sounding and + # require self-consistent outputs — valid flags, and never NaN-with-success. + rng = np.random.default_rng(0) + P = PROFILE_PROBLEMATIC[:, 0] + for _ in range(300): + tc = PROFILE_PROBLEMATIC[:, 1] + rng.uniform(-0.5, 0.5, P.size) + r = PROFILE_PROBLEMATIC[:, 2] * rng.uniform(0.8, 1.2, P.size) + sst = SST_PROBLEMATIC + rng.uniform(-0.5, 0.5) + msl = MSL_PROBLEMATIC + rng.uniform(-5.0, 5.0) + vmax, pmin, ifl, to, otl = tcpyPI.pi(sst, msl, P, tc, r, **PI_OPTIONS) + assert ifl in (0, 1, 2, 3) + if ifl == 1: + assert np.isfinite(vmax) and np.isfinite(pmin) + assert np.isfinite(to) and np.isfinite(otl) + else: + assert np.isnan(vmax) diff --git a/tests/test_outflow_source.py b/tests/test_outflow_source.py index 50a67a0..bdf1a41 100644 --- a/tests/test_outflow_source.py +++ b/tests/test_outflow_source.py @@ -50,12 +50,8 @@ def _example_profile(): def test_pi_outflow_source_cape_star_and_cape_env_smoke(): SSTC, MSL, P, TC, R = _example_profile() - vmax1, pmin1, ifl1, t01, otl1 = tcpyPI.pi( - SSTC, MSL, P, TC, R, outflow_source="cape_star" - ) - vmax2, pmin2, ifl2, t02, otl2 = tcpyPI.pi( - SSTC, MSL, P, TC, R, outflow_source="cape_env" - ) + vmax1, pmin1, ifl1, t01, otl1 = tcpyPI.pi(SSTC, MSL, P, TC, R, outflow_source="cape_star") + vmax2, pmin2, ifl2, t02, otl2 = tcpyPI.pi(SSTC, MSL, P, TC, R, outflow_source="cape_env") assert ifl1 == 1 assert ifl2 == 1 @@ -73,4 +69,3 @@ def test_pi_outflow_source_invalid_value_raises(): SSTC, MSL, P, TC, R = _example_profile() with pytest.raises(ValueError): tcpyPI.pi(SSTC, MSL, P, TC, R, outflow_source="not_a_real_mode") - diff --git a/tests/test_pdi_api.py b/tests/test_pdi_api.py index 8ca4f08..6f7e860 100644 --- a/tests/test_pdi_api.py +++ b/tests/test_pdi_api.py @@ -23,9 +23,7 @@ def test_pdi_knots_hours_matches_ms_seconds(): vmax_kt = np.array([20.0, 30.0, 40.0]) dt_h = 1.0 - out_kt_h = tcpyPI.power_dissipation_index( - vmax_kt, dt_h, wind_units="kt", dt_units="h" - ) + out_kt_h = tcpyPI.power_dissipation_index(vmax_kt, dt_h, wind_units="kt", dt_units="h") vmax_ms = vmax_kt * 0.5144444444444445 out_ms_s = tcpyPI.power_dissipation_index( diff --git a/tests/test_pi_field.py b/tests/test_pi_field.py new file mode 100644 index 0000000..a804608 --- /dev/null +++ b/tests/test_pi_field.py @@ -0,0 +1,98 @@ +"""Tests for the whole-field fast path pi_field() (see GitHub issue #86). + +pi_field wraps the same compiled per-column core as pi() in a parallel +generalized ufunc, so for identical float64 inputs the outputs must be +EXACTLY equal (bit-for-bit) — that is the acceptance criterion here. +""" + +import numpy as np + +import tcpyPI + +# Compact ocean sounding (from the pi() docstring example, thinned). +P = np.array( + [1000.0, 975, 950, 925, 900, 850, 800, 750, 700, 600, 500, 400, 300, 250, 200, 150, 100, 70, 50] +) +TC = np.array([28.0, 25, 24, 23, 22, 19, 16, 13, 11, 5, -2, -11, -27, -37, -49, -65, -79, -73, -64]) +R = np.array( + [18.0, 18, 16, 13, 12, 10, 9, 7, 4, 1.7, 1.7, 0.2, 0.1, 0.05, 0.014, 0.003, 0.002, 0.002, 0.002] +) + + +def _field_inputs(nlat=4, nlon=5): + """Build a small synthetic field with varied SSTs and per-cell profiles.""" + rng = np.random.default_rng(42) + sst = 24.0 + 8.0 * rng.random((nlat, nlon)) + msl = 1005.0 + 10.0 * rng.random((nlat, nlon)) + tc = TC + rng.uniform(-1.0, 1.0, (nlat, nlon, P.size)) + r = R * rng.uniform(0.8, 1.2, (nlat, nlon, P.size)) + return sst, msl, tc, r + + +def _loop_pi(sst, msl, tc, r, **kw): + outs = [np.empty(sst.shape) for _ in range(5)] + for idx in np.ndindex(sst.shape): + vals = tcpyPI.pi(sst[idx], msl[idx], P, tc[idx], r[idx], **kw) + for o, v in zip(outs, vals): + o[idx] = v + return outs + + +def _assert_exact(field_outs, loop_outs): + for got, ref in zip(field_outs, loop_outs): + np.testing.assert_array_equal(np.asarray(got, dtype=float), ref) + + +def test_pi_field_exact_equality_with_pi(): + sst, msl, tc, r = _field_inputs() + field = tcpyPI.pi_field(sst, msl, P, tc, r, CKCD=0.9) + loop = _loop_pi(sst, msl, tc, r, CKCD=0.9) + _assert_exact(field, loop) + assert field[2].dtype == np.int64 # IFL is an integer array + + +def test_pi_field_nan_cells_and_flags(): + sst, msl, tc, r = _field_inputs() + sst[0, 0] = np.nan # land-like cell -> IFL=0 + msl[1, 1] = np.nan # missing MSL cell -> IFL=3 + vmax, pmin, ifl, to, otl = tcpyPI.pi_field(sst, msl, P, tc, r) + assert ifl[0, 0] == 0 and np.isnan(vmax[0, 0]) + assert ifl[1, 1] == 3 and np.isnan(vmax[1, 1]) + # other cells unaffected — still exactly equal to the per-column path + loop = _loop_pi(sst, msl, tc, r) + _assert_exact((vmax, pmin, ifl, to, otl), loop) + + +def test_pi_field_order_agnostic_profiles(): + sst, msl, tc, r = _field_inputs(2, 2) + ref = tcpyPI.pi_field(sst, msl, P, tc, r) + rev = tcpyPI.pi_field(sst, msl, P[::-1], tc[..., ::-1], r[..., ::-1]) + _assert_exact(rev, [np.asarray(x, dtype=float) for x in ref]) + + +def test_pi_field_nan_pressure_returns_missing_field(): + sst, msl, tc, r = _field_inputs(2, 2) + Pbad = P.copy() + Pbad[3] = np.nan + vmax, pmin, ifl, to, otl = tcpyPI.pi_field(sst, msl, Pbad, tc, r) + assert np.all(ifl == 3) and np.all(np.isnan(vmax)) + + +def test_pi_field_broadcasting_scalars_and_shared_profile(): + # scalar MSL + shared 1-D profile broadcast across an SST grid + sst = np.array([[28.0, 30.0]]) + out = tcpyPI.pi_field(sst, 1010.0, P, TC, R) + assert out[0].shape == (1, 2) + ref0 = tcpyPI.pi(28.0, 1010.0, P, TC, R) + ref1 = tcpyPI.pi(30.0, 1010.0, P, TC, R) + assert out[0][0, 0] == ref0[0] and out[0][0, 1] == ref1[0] + + +def test_pi_field_input_validation(): + sst, msl, tc, r = _field_inputs(2, 2) + with np.testing.assert_raises(ValueError): + tcpyPI.pi_field(sst, msl, np.stack([P, P]), tc, r) # 2-D pressure array + with np.testing.assert_raises(ValueError): + tcpyPI.pi_field(sst, msl, P[:-1], tc, r) # level-dim mismatch + with np.testing.assert_raises(ValueError): + tcpyPI.pi_field(sst, msl, P, tc, r, outflow_source="nope") diff --git a/tests/test_relative_intensity_api.py b/tests/test_relative_intensity_api.py index df56b09..a477c38 100644 --- a/tests/test_relative_intensity_api.py +++ b/tests/test_relative_intensity_api.py @@ -14,6 +14,7 @@ def test_relative_intensity_masks_invalid_pi(): def test_relative_intensity_clip(): - out = tcpyPI.relative_intensity(np.array([10.0, 200.0]), np.array([20.0, 20.0]), clip=(0.0, 2.0)) + out = tcpyPI.relative_intensity( + np.array([10.0, 200.0]), np.array([20.0, 20.0]), clip=(0.0, 2.0) + ) np.testing.assert_allclose(out, np.array([0.5, 2.0]), rtol=0, atol=0) - diff --git a/tests/test_run_sample.py b/tests/test_run_sample.py index 4c03226..cdd242e 100644 --- a/tests/test_run_sample.py +++ b/tests/test_run_sample.py @@ -44,6 +44,4 @@ def test_run_sample_analyses(): # Only compare the analysis variables (not the input variables) analysis_vars = ["eff", "diseq", "lnpi", "lneff", "lndiseq", "lnCKCD"] for var in analysis_vars: - xr.testing.assert_allclose( - ds_out[var], expected_ds[var], rtol=1e-13, atol=1e-9 - ) + xr.testing.assert_allclose(ds_out[var], expected_ds[var], rtol=1e-13, atol=1e-9) diff --git a/tests/test_vi_api.py b/tests/test_vi_api.py index eef2b8c..89f523d 100644 --- a/tests/test_vi_api.py +++ b/tests/test_vi_api.py @@ -152,7 +152,6 @@ def test_chi_m_te12_from_profile_moist_adiabat_from_sst_runs(): assert np.isfinite(out) - def test_vi_log_decomposition_closure_and_handcalc(): us, vp, ch = 12.0, 75.0, 0.5 d = tcpyPI.vi_log_decomposition(us, vp, ch)