diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 3e1b655..0e1e3e7 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -2,11 +2,10 @@ name: CI on: push: - branches: - - main + branches: [main, rewrite] pull_request: - branches: - - main + branches: [main, rewrite] + workflow_dispatch: concurrency: group: ${{ github.workflow }}-${{ github.ref }} @@ -15,162 +14,67 @@ concurrency: jobs: format: runs-on: ubuntu-latest - steps: - uses: actions/checkout@v4 - - uses: actions/setup-python@v5 with: python-version: "3.12" - cache: 'pip' - + cache: "pip" - name: Install validation dependencies run: | python -m pip install --upgrade pip setuptools wheel + python -m pip install torch --index-url https://download.pytorch.org/whl/cpu # pocomc's, without CUDA python -m pip install -e '.[validation]' - - name: Check source formatting and imports run: | - python -m isort --check-only src test - python -m black --check src test - python -m ruff check src test - + python -m isort --check-only src test examples/*.py + python -m black --check src test examples/*.py + python -m ruff check src test examples/*.py - name: Check notebook formatting and imports run: | - python -m nbqa isort --check examples/*.ipynb - python -m black --check --ipynb examples/*.ipynb - python -m ruff check examples/*.ipynb + if [ -d examples ] && ls examples/*.ipynb >/dev/null 2>&1; then + python -m nbqa isort --check examples/*.ipynb + python -m black --check --ipynb examples/*.ipynb + python -m ruff check examples/*.ipynb + else + echo "no notebooks yet" + fi tests: + # the fast tier: unit tests and the sampler-free / short-chain recipe assertions runs-on: ubuntu-latest - strategy: - fail-fast: false - matrix: - python-version: ["3.12"] - steps: - uses: actions/checkout@v4 - - - uses: actions/setup-python@v5 - with: - python-version: ${{ matrix.python-version }} - cache: 'pip' - - - name: Install validation dependencies - run: | - python -m pip install --upgrade pip setuptools wheel - python -m pip install -e '.[validation]' - - - name: Locate x4i3 database directory - run: echo "X4I3_DATA_DIR=$(python -c 'import importlib.util, pathlib; print(pathlib.Path(importlib.util.find_spec("x4i3").origin).parent / "data")')" >> "$GITHUB_ENV" - - - name: Restore EXFOR database cache - uses: actions/cache@v4 with: - path: ${{ env.X4I3_DATA_DIR }} - key: exfor-db-${{ runner.os }}-${{ hashFiles('requirements.txt') }} - - - name: Warm EXFOR database - run: python -c "import x4i3" - - - name: Run unit tests - run: python -m pytest test - - notebooks: - runs-on: ubuntu-latest - timeout-minutes: 60 - - steps: - - uses: actions/checkout@v4 - + fetch-depth: 0 - uses: actions/setup-python@v5 with: python-version: "3.12" - cache: 'pip' - + cache: "pip" - name: Install validation dependencies run: | python -m pip install --upgrade pip setuptools wheel - python -m pip install -e '.[validation]' pytest-xdist - - - name: Locate x4i3 database directory - run: echo "X4I3_DATA_DIR=$(python -c 'import importlib.util, pathlib; print(pathlib.Path(importlib.util.find_spec("x4i3").origin).parent / "data")')" >> "$GITHUB_ENV" - - - name: Restore EXFOR database cache - uses: actions/cache@v4 - with: - path: ${{ env.X4I3_DATA_DIR }} - key: exfor-db-${{ runner.os }}-${{ hashFiles('requirements.txt') }} - - # single serial download; the concurrent notebook kernels spawned by - # xdist must find the database already in place (x4i3 downloads at - # import time outside pytest, so parallel kernels would race it) - - name: Warm EXFOR database - run: python -c "import x4i3" - - - name: Run notebooks with pytest - run: python -m pytest -n 4 --nbmake --nbmake-timeout=1200 examples + python -m pip install torch --index-url https://download.pytorch.org/whl/cpu # pocomc's, without CUDA + python -m pip install -e '.[validation]' + - name: Run the fast tier + # the ten slowest tests are listed so the few-minute budget stays visible + run: python -m pytest --durations=10 docs: runs-on: ubuntu-latest - steps: - uses: actions/checkout@v4 - + with: + fetch-depth: 0 - uses: actions/setup-python@v5 with: python-version: "3.12" - cache: 'pip' - + cache: "pip" - name: Install docs dependencies run: | python -m pip install --upgrade pip setuptools wheel python -m pip install -e '.[docs]' - - - name: Locate x4i3 database directory - run: echo "X4I3_DATA_DIR=$(python -c 'import importlib.util, pathlib; print(pathlib.Path(importlib.util.find_spec("x4i3").origin).parent / "data")')" >> "$GITHUB_ENV" - - - name: Restore EXFOR database cache - uses: actions/cache@v4 - with: - path: ${{ env.X4I3_DATA_DIR }} - key: exfor-db-${{ runner.os }}-${{ hashFiles('requirements.txt') }} - - - name: Warm EXFOR database - run: python -c "import x4i3" - - name: Build HTML docs run: | - test -L docs/examples || ln -sf ../examples docs/examples - sphinx-build docs docs/_build/html -W --keep-going - - build: - runs-on: ubuntu-latest - - steps: - - uses: actions/checkout@v4 - - - uses: actions/setup-python@v5 - with: - python-version: "3.12" - cache: 'pip' - - - name: Build distributions - run: | - python -m pip install --upgrade pip build - python -m build - - - name: Install wheel - run: python -m pip install "$(ls -t dist/*.whl | head -n 1)" - - - name: Locate x4i3 database directory - run: echo "X4I3_DATA_DIR=$(python -c 'import importlib.util, pathlib; print(pathlib.Path(importlib.util.find_spec("x4i3").origin).parent / "data")')" >> "$GITHUB_ENV" - - - name: Restore EXFOR database cache - uses: actions/cache@v4 - with: - path: ${{ env.X4I3_DATA_DIR }} - key: exfor-db-${{ runner.os }}-${{ hashFiles('requirements.txt') }} - - - name: Wheel smoke test - run: python -c "import rxmc; import rxmc.config; import rxmc.walker" + if [ -d examples ]; then test -L docs/examples || ln -sf ../examples docs/examples; fi + sphinx-build -W --keep-going docs docs/_build/html diff --git a/.github/workflows/converged.yml b/.github/workflows/converged.yml new file mode 100644 index 0000000..bdcf24b --- /dev/null +++ b/.github/workflows/converged.yml @@ -0,0 +1,49 @@ +name: Converged tier + +# The numeric claims that need a converged sampler, and a quick run of the +# example notebooks. +# Required for pushes and pull requests into main; run by hand on any branch +# with workflow_dispatch. There is deliberately no schedule. + +on: + push: + branches: [main] + pull_request: + branches: [main] + workflow_dispatch: + +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: true + +jobs: + converged: + runs-on: ubuntu-latest + timeout-minutes: 180 + steps: + - uses: actions/checkout@v4 + with: + fetch-depth: 0 + - uses: actions/setup-python@v5 + with: + python-version: "3.12" + cache: "pip" + - name: Install validation dependencies + run: | + python -m pip install --upgrade pip setuptools wheel + python -m pip install torch --index-url https://download.pytorch.org/whl/cpu # pocomc's, without CUDA + python -m pip install -e '.[validation]' pytest-xdist + - name: Run the converged tier + run: python -m pytest -m slow --durations=10 + - name: Run the notebooks + # quick: every sampler budget cut tenfold, to check that each cell + # runs; the committed outputs are full runs (examples/run.py), and + # nbmake does not write over them + env: + RXMC_EXAMPLES_QUICK: "1" + run: | + if [ -d examples ] && ls examples/*.ipynb >/dev/null 2>&1; then + python -m pytest -n 4 --nbmake --nbmake-timeout=900 examples + else + echo "no notebooks yet" + fi diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml index 0848e25..bda7d57 100644 --- a/.github/workflows/docs.yml +++ b/.github/workflows/docs.yml @@ -33,7 +33,7 @@ jobs: - name: Build HTML docs run: | - test -L docs/examples || ln -sf ../examples docs/examples + if [ -d examples ]; then test -L docs/examples || ln -sf ../examples docs/examples; fi sphinx-build docs docs/_build/html -W --keep-going - name: Upload pages artifact diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml new file mode 100644 index 0000000..2e64c02 --- /dev/null +++ b/.github/workflows/publish.yml @@ -0,0 +1,53 @@ +name: Publish to PyPI + +# Trusted publishing: no token in the repository. Register the pending +# publisher on pypi.org (project rxmc, owner beykyle, repository rxmc, +# workflow publish.yml, environment pypi) before the first tag. Only 1.x and +# later tags publish (0.x lives on tag v0.1.0 and branch legacy/0.x), and the +# build refuses a tag that does not name the version setuptools_scm builds. +on: + push: + tags: ["v[1-9]*"] + +jobs: + build: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + with: + fetch-depth: 0 + - uses: actions/setup-python@v5 + with: + python-version: "3.12" + - name: Build sdist and wheel + run: | + python -m pip install --upgrade pip build + python -m build + - name: Check the tag names the built version + run: | + python - <<'EOF' + import glob, os + from packaging.version import Version + tag = os.environ["GITHUB_REF_NAME"].removeprefix("v") + built = os.path.basename(glob.glob("dist/*.whl")[0]).split("-")[1] + if Version(tag) != Version(built): + raise SystemExit(f"tag v{tag} builds version {built}: not publishing") + print(f"publishing {built}") + EOF + - uses: actions/upload-artifact@v4 + with: + name: dist + path: dist/ + + publish: + needs: build + runs-on: ubuntu-latest + environment: pypi + permissions: + id-token: write + steps: + - uses: actions/download-artifact@v4 + with: + name: dist + path: dist/ + - uses: pypa/gh-action-pypi-publish@release/v1 diff --git a/.gitignore b/.gitignore index 48ef535..b7e7e17 100644 --- a/.gitignore +++ b/.gitignore @@ -119,7 +119,7 @@ ipython_config.py # Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control. # This is especially recommended for binary packages to ensure reproducibility, and is more # commonly ignored for libraries. -uv.lock +#uv.lock # agent/session config .claude/ @@ -217,3 +217,6 @@ cython_debug/ .cursorignore .cursorindexingignore docs/jupyter_execute/ + +# cluster job logs (the result files themselves are committed) +benchmarks/results/hpc/logs/ diff --git a/README.md b/README.md index cd0cf6d..4bfd37c 100644 --- a/README.md +++ b/README.md @@ -1,301 +1,169 @@ # rxmc -> **The 1.0 rewrite is in progress on branch [`rewrite`](https://github.com/beykyle/rxmc/tree/rewrite)**, guided by -> [`docs/groundup_design.md`](docs/groundup_design.md) and [`docs/recipes.md`](docs/recipes.md). -> This 0.x package is preserved at tag `v0.1.0` and on branch `legacy/0.x`. - -`rxmc` is an orchestration layer for Bayesian calibration of reaction models to -large data sets with flexible, composable covariance modeling. - -It is built around two complementary workflows: - -1. **External-sampler orchestration** via `rxmc.config.CalibrationConfig` - for drivers such as - [`black-box-bayes`](https://github.com/beykyle/black-box-bayes/). -2. **In-package end-to-end prototyping** via `rxmc.walker.Walker` - for smaller problems where you want to run the full MCMC workflow locally. - -The package composes: - -- curated experimental data as `Observation` objects, -- model predictions via `PhysicalModel`, -- uncertainty declared as additive covariance `Term`s (statistical, - systematic, unknown-noise, and Gaussian-process discrepancy modes) via - `rxmc.covariance`, -- maximal blocks of mutually-correlated data via `Constraint`, -- and full calibration problems via `Evidence`. +`rxmc` calibrates reaction models to experimental data by Bayesian +inference, with the error model declared as part of the problem: which +errors are statistical and which are correlated, whether a normalisation is +inferred or marginalised, whether the model is allowed a discrepancy, which +points are held out. A reviewer can read the declaration and write down the +likelihood. The library owns no sampler: a compiled problem exposes the +densities and the prior transform that pocomc, emcee, dynesty or +black-box-bayes need. The densities are written in JAX, so `jax.grad` works through the +posterior (the reaction solver included) for HMC, optimisation or a Laplace +approximation. ## Quickstart +Declare, compile, hand to a sampler, read the chain back by name. + ```python +import emcee import numpy as np from scipy import stats -import rxmc - -# measured data: pure data plus (optional) reported systematics as metadata -obs = rxmc.observation.Observation( - x=x, y=y, y_stat_err=y_err, y_sys_err_normalization=0.04 -) - -# a constraint owns one multivariate likelihood over its stacked observations; -# every correlated mode is an explicit covariance term - nothing is folded in -# silently. Here: the reported normalisation systematic plus an unknown -# constant noise inferred alongside the model -log_eps = rxmc.params.Parameter("log_eps") -constraint = rxmc.constraint.Constraint( - [obs], - model, - extra_terms=[*obs.systematic_terms(), rxmc.covariance.noise_term(log_eps)], -) -evidence = rxmc.evidence.Evidence([constraint]) - -# calibrate with the in-package Gibbs walker (or wrap in CalibrationConfig -# for emcee / dynesty) -prior = stats.multivariate_normal(mean=prior_mean, cov=prior_cov) -walker = rxmc.walker.Walker( - rxmc.param_sampling.BatchedAdaptiveMetropolisSampler( - params=model.params, - starting_location=prior.mean, - prior=prior, - initial_proposal_cov=prior.cov / 100, - ), - evidence, - rng=np.random.default_rng(1), -) -walker.walk(n_steps=10_000, burnin=1_000, batch_size=1_000) -``` - -> **Note — behavior change from pre-0.1 versions:** an `Observation`'s -> reported systematic errors are never folded into the covariance -> automatically. The default constraint covariance is the statistical diagonal -> only; systematics enter explicitly, e.g. via -> `obs.systematic_terms()` passed to `Constraint(extra_terms=...)`. - -> **Note — jitr:** this version requires -> [jitr](https://github.com/beykyle/lagrange-rmatrix) ≥ 3.0 (workspaces take -> potential *arrays* on `ws.radial_grid()`); `requirements.txt` pins -> `jitr>=3.0` from PyPI. Python ≥ 3.12. - - -## Installation - -### Development / local use -```bash -git clone git@github.com:beykyle/rxmc.git -cd rxmc -pip install -ve . -``` +import rxmc as rx -It is strongly recommended to use an isolated environment. +# a model with parameters and priors +m = rx.Parameter("m", prior=stats.norm(0.0, 5.0)) +b = rx.Parameter("b", prior=stats.norm(0.0, 5.0)) +line = rx.Model(lambda x, m, b: m * x + b, [m, b]) -### `venv` +# data with reported statistical errors +rng = np.random.default_rng(0) +x = np.linspace(0.0, 1.0, 20) +data = rx.Dataset(x, 0.6 * x + 2.0 + rng.normal(0.0, 0.1, x.size), np.full(x.size, 0.1)) -```bash -python -m venv .rxmc -source .rxmc/bin/activate -pip install -r requirements.txt -pip install -ve . -``` +# one comparison, one likelihood, one compiled problem +problem = rx.Problem([rx.Constraint([rx.Comparison(data, line)])]) +print(problem.names) # ['m', 'b'] -### `uv`: +sampler = emcee.EnsembleSampler(16, problem.ndim, problem.log_posterior) +sampler.run_mcmc(problem.sample_prior(16, rng=1), 1000) +samples = sampler.get_chain(discard=300, flat=True) +print(samples[:, problem.columns(m)].mean(), samples[:, problem.columns(b)].mean()) -```bash -uv env create -uv env use python -uv install -e . +# the posterior predictive on the data points, with the error model +draws = rx.diagnostics.predictive_draws(problem, samples[::20], n_rep=2, return_draws=True) +print(rx.diagnostics.coverage_curve(draws, data.y, [0.68])) ``` -### Optional extras - -Install the example notebook runtime dependencies with: +The error model is a sum of covariance *terms* on the constraint. A +normalisation the experiment did not report, inferred alongside the model: -```bash -pip install -ve '.[examples]' -``` +```python +from rxmc import terms as T -Install the full validation toolchain with: +log_eta = rx.Parameter("log_eta", prior=stats.norm(-2.0, 1.0)) +problem = rx.Problem([rx.Constraint([rx.Comparison(data, line)], terms=[T.normalization(log_eta)])]) +print(problem.names) # ['m', 'b', 'log_eta'] -```bash -pip install -ve '.[validation]' +# the densities are JAX: exact gradients and Hessians of the log posterior +theta = np.array([0.6, 2.0, -2.0]) +print(problem.grad_log_posterior(theta), problem.hessian_log_posterior(theta).shape) ``` -## Supported workflow 1: external samplers with `CalibrationConfig` - -`CalibrationConfig` packages a calibration problem into a flat parameter space -for external drivers. It exposes the interface expected by -`black-box-bayes`-style tooling: - -- `ndim` -- `starting_location(nwalkers)` -- `log_posterior(theta)` -- `log_likelihood(theta)` -- `prior_transform(u)` -- `log_posterior_batch(thetas)` (optional convenience interface) -- `parameter_names` +Models, terms and transforms are plain callables written with `jax.numpy` +(`jnp.exp`, not `np.exp`), so that gradients flow through them; importing +`rxmc` enables JAX's 64-bit mode. -Typical flow: +## A reaction model -1. Build `Observation` objects from your measurements. -2. Define a `PhysicalModel`. -3. Declare correlated uncertainty as covariance `Term`s (and pick a - likelihood functional: Gaussian, Student-t, or chi-squared). -4. Combine them into `Constraint` objects and then `Evidence`. -5. Wrap the problem in `ParameterConfig` and `CalibrationConfig`. -6. Hand the resulting object to an external sampler. +A jitr optical potential is a `Model` whose solver is built from the +dataset's kinematics. EXFOR measurements arrive through +`from_measurement`, which converts units and keeps the reported systematics +as inert metadata until asked for. Optical-model posteriors are correlated +and sometimes multimodal, so drive them with a sampler that starts from the +prior, pocomc by preference ([benchmarks](docs/benchmarks.md)); the example +uses dynesty at a toy budget for brevity. -This is the recommended path for larger production calibrations. - -## Supported workflow 2: in-package MCMC with `Walker` - -`Walker` is the smaller-scale, in-package path. It coordinates: - -- one sampler for the physical-model parameters, and -- optional additional samplers for parametric likelihood sectors. - -It alternates between these sectors in a Gibbs-style workflow and is useful -for: - -- prototyping new likelihood models, -- validating new observation/model compositions, -- and running smaller end-to-end inference problems without introducing an - external orchestration layer. - -## Core concepts - -### `Observation` - -Pure measured data — `x`, `y`, and the statistical error on `y` — plus the -measurement's reported systematic magnitudes retained as inert metadata -(`y_sys_err_normalization`, `y_sys_err_offset`). It contributes only its -statistical diagonal by default; `obs.systematic_terms()` turns the -metadata into explicit covariance terms when you ask. - -An observation also owns its **comparison space**: `Observation(x, y, -transform=rxmc.transforms.log)` takes raw `y`, compares in log space (errors -propagated by the delta method) and the constraint transforms the model -prediction to match. A point-level `mask` (or `obs.masked_where(...)`) selects -which points enter a likelihood — fit/held-out splits without rebuilding -anything. - -### `PhysicalModel` - -Maps model parameters to predicted observables for a given `Observation`. -A parametric `transform=` (e.g. `rxmc.transforms.scale()` or -`per_observation_scaling(observations)`) adds latent normalization parameters -(Kennedy–O'Hagan style) to any model. - -### Covariance `Term`s (`rxmc.covariance`) - -Every uncertainty beyond the statistical diagonal is an explicit additive -contribution to the constraint's stacked covariance. There is one generic -`Term(fn, params, kind=...)` — `fn` is a numpy-style callable of the term's -local `x`/`y`/`ym` and its parameters, `kind` is `"diag"`, `"mode"` or -`"matrix"`, and an optional `coords` transform changes the coordinate the term -lives in. Factory helpers cover the common modes in one line: - -- `normalization_term` / `offset_term` / `systematic_term` — correlated - modes, fixed magnitude or free nuisance, prediction-, unit- or user-basis - scaled, -- `noise_term` / `noise_fraction_term` — unknown statistical noise (with an - optional parametric basis, e.g. noise growing with angle), -- `model_error_term` — uncorrelated model error, -- `kernel_term` — Gaussian-process model discrepancy using sklearn kernels, - optionally in transformed coordinates and with a parametric amplitude. - -A term whose support spans several observations *couples* them (correlated -datasets); referencing the same `Parameter` object in two terms *shares* one -sampled value between them. `support=None` (the default) means the whole -constraint. - -### Likelihood functionals - -`GaussianLikelihood` (default), `StudentT` (heavy-tailed, with a -degrees-of-freedom parameter), and `Chi2` are thin functionals over the same -stacked covariance. - -### `Constraint` - -The maximal block of mutually-correlated data: observations, a physical model, -a covariance assembled from terms, and a likelihood functional. - -### `Evidence` +```python +from types import SimpleNamespace -Aggregates multiple independent constraints that share the same physical-model -parameterization. +import dynesty +import jitr +from jitr.optical_potentials.potential_forms import thomas_safe, woods_saxon_safe -### Model comparison (`rxmc.model_comparison`) +reaction = jitr.reactions.ElasticReaction(target=(40, 20), projectile=(1, 0)) +R = 1.2 * 40 ** (1 / 3) -Sampler-agnostic posterior-predictive draws, coverage/sharpness checks, -held-out scoring on `constraint.complement()`, and log-evidence bookkeeping -(`logz_summary`, `compare_logz`, `log_jacobian` for comparing fits done in -different comparison spaces). -## Examples and tutorials +def central(r, V, W, a): + return -(V + 1j * W) * woods_saxon_safe(r, R, a) -The `examples/` directory contains richer notebooks and demos. The most useful -entry points are: -- `examples/linear_calibration_demo.ipynb` for the basic workflow, -- `examples/systematic_err_demo.ipynb` for the error-model catalog and - systematic-error handling, -- `examples/measurement_to_calibration.ipynb` for the EXFOR-measurement → - calibration path (units, retained systematics, guardrails), -- `examples/30s_optical_potential_calibration.ipynb` for a realistic optical - potential calibration example, -- `examples/correlated_observations.ipynb` for correlated datasets and shared - systematics (including across cross-section experiments), -- `examples/gp_discrepancy.ipynb` for Gaussian-process model discrepancy, -- `examples/robust_likelihoods.ipynb` for Student-t vs Gaussian likelihoods, -- `examples/normalization_inference.ipynb` for normalization-focused modeling, -- `examples/sampling_algos.ipynb` for sampling comparisons. +def spin_orbit(r, Vso, Rso, aso): + return Vso * thomas_safe(r, Rso, aso) / jitr.utils.constants.WAVENUMBER_PION**2 -## Documentation -The full API reference and rendered example notebooks are hosted at -**https://beykyle.github.io/rxmc/**. +params = [ + rx.Parameter("V", prior=stats.norm(48.0, 5.0), bounds=(0.0, np.inf)), + rx.Parameter("W", prior=stats.norm(4.0, 3.0), bounds=(0.0, np.inf)), + rx.Parameter("a", prior=stats.norm(0.65, 0.1), bounds=(0.3, 1.2)), +] +omp = rx.reactions.ElasticXS( + "dXS/dA", central, spin_orbit, lambda ws, *v: (tuple(v), (6.0, R, 0.45)), params, lmax=10 +) -To build the documentation locally: +# an EXFOR-shaped measurement (exfor_tools.Distribution has these fields); here mock data +angles = np.linspace(10.0, 150.0, 12) +true_params = (48.0, 4.0, 0.65) +truth = omp.bind(np.deg2rad(angles), {"reaction": reaction, "Elab": 14.1})(*true_params) +measurement = SimpleNamespace( + x=angles, y=1e3 * truth * (1 + rng.normal(0, 0.05, angles.size)), Einc=14.1, + quantity="dXS/dA", y_units="mb/sr", statistical_err=1e3 * truth * 0.05, + systematic_norm_err=0.04, systematic_offset_err=None, subentry="mock", +) +d = rx.from_measurement(measurement, reaction=reaction) +comp = rx.Comparison(d, omp) +problem = rx.Problem([rx.Constraint([comp], terms=comp.reported_terms())]) -```bash -pip install -ve '.[docs]' -cd docs && make html -# then open docs/_build/html/index.html +sampler = dynesty.NestedSampler(problem.log_likelihood, problem.prior_transform, problem.ndim, nlive=50) +sampler.run_nested(dlogz=5.0, print_progress=False) +print(problem.names, sampler.results.logz[-1]) ``` -## Testing +## Where to go next -Run the full validation matrix with: +- [`docs/recipes.md`](docs/recipes.md): every supported use case with its + spelling and expected behaviour. Each recipe is a test under + `test/recipes/`. +- [`examples/`](examples/): eight notebooks, the tutorials for the recipes, + from a line to an error-model comparison on real $\alpha$ + $^{44}$Ca data and a + hierarchical calibration. +- [`docs/design.md`](docs/design.md): the maintainer's description of the + library, its rules and its testing tiers. +- The documentation website, including API reference, at + https://beykyle.github.io/rxmc/. -```bash -python -m isort --check-only src test -python -m black --check src test -python -m ruff check src test -python -m nbqa isort --check examples/*.ipynb -python -m black --check --ipynb examples/*.ipynb -python -m ruff check examples/*.ipynb -python -m pytest -``` +## Installation -If you want to apply the formatting fixes locally instead of only checking them: +Python 3.12 or later; the runtime dependencies are `numpy`, `scipy`, `jax`, +`tinygp` (Gaussian-process kernels), `jitr` and `exfor-tools`. `jitr` is +taken from its `jax-core` branch (the JAX solver of the next jitr release) +until that release is on PyPI; the 1.0 pre-releases wait on it, since PyPI +does not accept a git dependency. For a GPU, install a CUDA build of `jax` +first. Install from GitHub: ```bash -python -m isort src test -python -m black src test -python -m ruff check --fix src test -python -m nbqa isort examples/*.ipynb -python -m black --ipynb examples/*.ipynb +git clone git@github.com:beykyle/rxmc.git +cd rxmc +python -m venv .venv && source .venv/bin/activate +pip install -e '.[examples]' # or '.[validation]' to run the tests ``` -Run only the unit tests with: - -```bash -python -m pytest test -``` +1.0 is a rewrite and does not run 0.x code. The 0.x package is preserved at +tag [`v0.1.0`](https://github.com/beykyle/rxmc/tree/v0.1.0) and on branch +[`legacy/0.x`](https://github.com/beykyle/rxmc/tree/legacy/0.x); pin it with +`pip install git+https://github.com/beykyle/rxmc@v0.1.0`. -Run only the notebooks with: +## Validation ```bash -python -m pytest examples +python -m isort --check-only src test && python -m black --check src test && python -m ruff check src test +python -m pytest # fast tier +python -m pytest -m slow # converged tier: required on pushes and PRs to main +RXMC_EXAMPLES_QUICK=1 python -m pytest -n 4 --nbmake examples # the notebooks, quick, same workflow +python examples/run.py # the notebooks at full budget, outputs written: what is committed +sphinx-build -W docs docs/_build/html ``` +The three Python blocks of this README are executed by `test/test_readme.py`. diff --git a/benchmarks/README.md b/benchmarks/README.md new file mode 100644 index 0000000..4d7d248 --- /dev/null +++ b/benchmarks/README.md @@ -0,0 +1,54 @@ +# Benchmarks + +Two benchmarks of the JAX rxmc, and the tools to run them locally or on a +cluster. [`docs/benchmarks.md`](../docs/benchmarks.md) has the set-up, the +scoring and the results; this file is a map of the directory. + +## The problems: `problems.py` + +`PROBLEMS[name]()` returns a compiled `rxmc.Problem` and a fixed set of +parameter points. They span the cost regimes and posterior geometries the +benchmarks care about: + +| problem | parameters | what it exercises | +|---|---|---| +| `linear` | 2 | a line with reported errors: per-call overhead | +| `modes` | 9 | free normalisations, offsets and a shared mode: the Woodbury path, a funnel | +| `gp`, `gp500` | 4 | a dense GP discrepancy over 100 or 500 points: Cholesky-bound, a funnel | +| `elastic` | 5 | `ElasticXS` at four energies: the reaction solver, one mode | +| `ias` | 4 | an `IsobaricAnalogPN` prediction | +| `hierarchy` | 33 | 30 lines with non-centred intercepts: high dimension | +| `omp` | 9 | exactly `local_optical_model_calibration`'s log-space p + 40Ca problem: two separated islands | +| `alpha_gp` | 9 | exactly `alpha_ca_error_model_comparison`'s power-of-q GP problem: two families of potentials and GP hyperparameters | +| `n40ca_gp` | 7 | exactly the GP rung of `gp_discrepancy`'s cross-section ladder (`n40ca_ladder()` builds all three rungs) | + +## The density benchmark: `bench_log_posterior.py`, `compare.py` + +Times `log_posterior`, its gradient and the batched densities on every +problem; `compare.py` sets two saved runs side by side (the numpy rxmc +against the JAX one: `results/numpy-jitr3.json`, `results/jax-jitr4.json`). + +## The sampler benchmark + +| file | what it does | +|---|---| +| `bench_samplers.py` | runs the samplers (emcee, dynesty, pocomc and NUTS everywhere; ptemcee, HMC and PyMC on the optical models) at the budgets in `BUDGETS`, scores them against the references, and prints the tables (`--report ... --markdown`); `--reference` computes references | +| `reference.py` | the reference posteriors: exact quadrature (`linear`, `gp`, `hierarchy`), a long NUTS run (`modes`, `elastic`), or three pooled pocomc runs checked against pooled dynesty runs, three on `omp` and fifty on `alpha_gp` and `n40ca_gp` | +| `sweep_pocomc.py` | sampler settings swept on a problem, several seeds per setting (pocomc's resolution; dynesty's settings too on `gp`, `modes` and `elastic`), and their tables (`--report`, `--grid`) | +| `gp_seed_check.py` | `gp_discrepancy`'s ladder rerun with other seeds | +| `merge_results.py` | merges per-job result files into `results/samplers.json` and `results/references.json` | +| `results/` | the committed results the docs are built from | +| `hpc/` | running any subset of the above as SLURM array jobs: see [`hpc/README.md`](hpc/README.md) | + +Locally: + +```bash +python benchmarks/bench_samplers.py --out benchmarks/results/samplers.json --problems linear gp +python benchmarks/bench_samplers.py --out benchmarks/results/samplers.json --problems omp --only pocomc +python benchmarks/bench_samplers.py --report benchmarks/results/samplers.json --markdown +python benchmarks/bench_samplers.py --reference --problems modes +python benchmarks/sweep_pocomc.py n40ca_gp --out sweep.json --settings 1024/512 --seeds 0 +``` + +The three optical-model problems take hours per sampler and reference; run +them on a cluster. diff --git a/benchmarks/bench_log_posterior.py b/benchmarks/bench_log_posterior.py new file mode 100644 index 0000000..6698ace --- /dev/null +++ b/benchmarks/bench_log_posterior.py @@ -0,0 +1,151 @@ +"""Time and record ``Problem.log_posterior`` on the benchmark problems. + +Runs against whichever rxmc is importable (the numpy baseline or the JAX +rewrite) and writes one JSON file:: + + python benchmarks/bench_log_posterior.py --out benchmarks/results/numpy.json + python benchmarks/bench_log_posterior.py --out benchmarks/results/jax.json + python benchmarks/compare.py benchmarks/results/numpy.json benchmarks/results/jax.json + +Recorded per problem: the values at the fixed parameter points (the value +regression), the first-call latency, the steady-state per-call time, the +gradient cost (``value_and_grad`` in JAX, a central finite difference of +``2 * ndim`` calls in the baseline), batch throughput at several batch sizes +and, with ``--emcee``, the wall time of a fixed emcee budget. Timings are the +median and interquartile range over repeated calls after warm-up. +""" + +from __future__ import annotations + +import argparse +import json +import platform +import sys +import time +from pathlib import Path + +import numpy as np + +sys.path.insert(0, str(Path(__file__).parent)) +from problems import JAX, PROBLEMS, rxmc # noqa: E402 + +BATCHES = (1, 32, 256) + + +def _block(v): + """Wait for an asynchronous JAX result; a no-op on numpy values.""" + return v.block_until_ready() if hasattr(v, "block_until_ready") else v + + +def _timeit(fn, n_calls, min_time=0.2): + times = [] + t_start = time.perf_counter() + while len(times) < n_calls or (time.perf_counter() - t_start) < min_time: + t0 = time.perf_counter() + _block(fn()) + times.append(time.perf_counter() - t0) + if len(times) >= 20 * n_calls: + break + q1, med, q3 = np.percentile(times, [25, 50, 75]) + return {"median": med, "iqr": q3 - q1, "n": len(times)} + + +def _fd_grad(f, theta, h=1e-6): + g = np.empty_like(theta) + for i in range(len(theta)): + e = np.zeros_like(theta) + e[i] = h * max(1.0, abs(theta[i])) + g[i] = (float(f(theta + e)) - float(f(theta - e))) / (2 * e[i]) + return g + + +def bench(name, n_calls, emcee_steps): + t0 = time.perf_counter() + problem, thetas = PROBLEMS[name]() + build = time.perf_counter() - t0 + out = {"ndim": problem.ndim, "names": problem.names, "build_s": build} + + t0 = time.perf_counter() + _block(problem.log_posterior(thetas[0])) + out["first_call_s"] = time.perf_counter() - t0 + out["values"] = [float(problem.log_posterior(t)) for t in thetas] + out["thetas"] = np.asarray(thetas).tolist() + + rotation = iter(np.tile(np.arange(len(thetas)), 10**6)) + out["log_posterior"] = _timeit( + lambda: problem.log_posterior(thetas[next(rotation)]), n_calls + ) + + if JAX: + vg = problem.value_and_grad_log_posterior + t0 = time.perf_counter() + _block(vg(thetas[0])[1]) + out["grad_first_call_s"] = time.perf_counter() - t0 + out["grad"] = _timeit(lambda: vg(thetas[next(rotation)])[1], n_calls) + out["grad_method"] = "value_and_grad" + else: + out["grad"] = _timeit( + lambda: _fd_grad(problem.log_posterior, thetas[next(rotation)]), + max(5, n_calls // (2 * problem.ndim)), + ) + out["grad_method"] = "central finite difference" + + out["batch"] = {} + rng = np.random.default_rng(1) + for b in BATCHES: + batch = thetas[rng.integers(0, len(thetas), b)] + _block(problem.log_posterior_batch(batch)) # warm-up / compile + t = _timeit(lambda: problem.log_posterior_batch(batch), max(3, n_calls // b)) + out["batch"][str(b)] = {**t, "theta_per_s": b / t["median"]} + + if emcee_steps: + import emcee + + nwalkers = max(32, 2 * problem.ndim + 2) + p0 = problem.sample_prior(nwalkers, rng=3) + sampler = emcee.EnsembleSampler( + nwalkers, problem.ndim, lambda t: float(problem.log_posterior(t)) + ) + t0 = time.perf_counter() + sampler.run_mcmc(p0, emcee_steps, progress=False) + out["emcee"] = { + "nwalkers": nwalkers, + "steps": emcee_steps, + "wall_s": time.perf_counter() - t0, + } + return out + + +def main(argv=None): + ap = argparse.ArgumentParser(description=__doc__.splitlines()[0]) + ap.add_argument("--out", required=True, type=Path) + ap.add_argument("--problems", nargs="*", default=list(PROBLEMS)) + ap.add_argument("--calls", type=int, default=200) + ap.add_argument("--emcee", type=int, default=0, help="emcee steps (0: skip)") + args = ap.parse_args(argv) + + results = { + "backend": "jax" if JAX else "numpy", + "rxmc": getattr(rxmc, "__version__", "?"), + "python": platform.python_version(), + "machine": platform.machine(), + "processor": platform.processor(), + "problems": {}, + } + try: + import jitr + + results["jitr"] = getattr(jitr, "__version__", "?") + except ImportError: + pass + for name in args.problems: + print(f"[{results['backend']}] {name} ...", flush=True) + emcee_steps = args.emcee if name in ("linear", "gp", "elastic") else 0 + results["problems"][name] = bench(name, args.calls, emcee_steps) + args.out.parent.mkdir(parents=True, exist_ok=True) + args.out.write_text(json.dumps(results, indent=1)) + print(f"wrote {args.out}") + + +if __name__ == "__main__": + main() diff --git a/benchmarks/bench_samplers.py b/benchmarks/bench_samplers.py new file mode 100644 index 0000000..b30326a --- /dev/null +++ b/benchmarks/bench_samplers.py @@ -0,0 +1,754 @@ +"""Compare samplers on the benchmark problems, per effective sample. + +JAX rxmc only (the gradient samplers need the gradient):: + + python benchmarks/bench_samplers.py --out benchmarks/results/samplers.json + python benchmarks/bench_samplers.py --out ... --problems omp --only ptemcee pocomc + python benchmarks/bench_samplers.py --report benchmarks/results/samplers.json --markdown + python benchmarks/bench_samplers.py --reference --problems omp + +emcee, dynesty, pocomc and blackjax NUTS run on every problem; the optical +model ``omp`` also runs ptemcee, blackjax HMC and PyMC's NUTS and HMC (the +``samplers`` extra). docs/benchmarks.md explains the set-up and the scoring. + +Each sampler starts the way it is usually used, and pays for the search: + +* ensemble samplers (emcee, ptemcee) and HMC and NUTS (blackjax, PyMC) from + a small ball about the posterior mode, ``rx.optimize.find_map`` (L-BFGS-B + with the exact gradient), the gradient samplers on + ``log_posterior_unconstrained``. Not the maximum of the likelihood: on + the hierarchy that is a ridge (the likelihood sees only ``mu + tau * + eta_j``), not a point. The exception is the hierarchy, whose MAP is far + from the bulk of its posterior: the non-centred mode shrinks the + ``eta_j`` toward their prior and inflates ``tau`` to compensate (1.27 at + the MAP, against a posterior of 0.31 +/- 0.04), so emcee and NUTS start + there from prior draws; +* nested sampling (dynesty) and preconditioned Monte Carlo (pocomc) from the + prior, as their algorithms do; pocomc samples the unit cube with + ``log_likelihood(prior_transform(u))``, the prior exactly. + +A ball is ``to_theta(to_unconstrained(start) + 0.01 N(0, I))``, inside the +support. A search's wall time and calls are charged to every sampler +that starts from it. + +A call is one evaluation of the log density and, for a gradient sampler +(and the MAP search), its gradient. Calls are recorded by phase: the start +search, warm-up (emcee's and ptemcee's discarded burn-in, NUTS's and HMC's +adaptation, pocomc's tempering from the prior), sampling, and pocomc's +evidence step. ESS per thousand calls does not depend on the machine; the +wall time per call shows what a call costs (a gradient, PyMC's overhead, +pocomc's flow training). + +Recorded per sampler: wall time, calls, the smallest bulk and tail ESS and +the largest rank-normalised split R-hat over the parameters (Vehtari et al. +2021: ``blackjax.diagnostics.ess_bulk``, ``ess_tail`` and ``rhat``) for every +chain-based sampler, walkers taken as chains for the ensembles (which +flatters them), the ensembles' integrated autocorrelation time tau (flagged under the +50 tau emcee asks for), the evidence where the algorithm gives one, and the +posterior means and standard deviations. A chain-based run with R-hat above +1.01, or an ensemble run shorter than 50 tau, has not converged. + +Every run is scored against a reference posterior (``reference.py``, written +by ``--reference`` to ``results/references.json``): exact quadrature where the +problem is linear-Gaussian given a few parameters, pooled high-resolution +pocomc runs on the two-island ``omp``, a long NUTS run otherwise. Its bias is the largest error of a posterior mean, and its width +error the largest of ``|log(sd / sd_ref)|``, both over the parameters and in +reference standard deviations. A run is correct if it converged and both +are at most ``TOLERANCE``; ESS rates are reported only for correct runs. + +The ESS of the weighted draws of dynesty and pocomc is Kish's, from the +importance weights alone. It ignores the correlation between particles that +share an ancestor (pocomc's resampling, dynesty's random walks from live +points), so it overstates their ESS, and pocomc stops once Kish's ESS reaches +its target, so its ESS is near that target by construction. The bias and +width columns are the check that matters for them. +""" + +from __future__ import annotations + +import argparse +import json +import sys +import time +from pathlib import Path + +import blackjax +import dynesty +import emcee +import jax +import numpy as np +from problems import PROBLEMS + +import rxmc as rx + +REFERENCES = Path(__file__).parent / "results" / "references.json" + +#: per problem: the samplers, and their budgets +COMMON = ("emcee", "dynesty", "pocomc", "NUTS") +EXTRA = ("ptemcee", "HMC", "PyMC NUTS", "PyMC HMC") +BUDGETS = { + # 12000 steps: rank-normalised R-hat was 1.019 at 3000 and 1.010 at 6000 + "linear": dict(samplers=COMMON, emcee=12000, warmup=1000, draws=1000, chains=4), + "gp": dict(samplers=COMMON, emcee=3000, warmup=1000, draws=1000, chains=4), + "modes": dict(samplers=COMMON, emcee=3000, warmup=1000, draws=1000, chains=4), + "elastic": dict(samplers=COMMON, emcee=1500, warmup=500, draws=500, chains=4), + "hierarchy": dict( + samplers=COMMON, + starts=dict(NUTS="prior", emcee="prior"), # the MAP is far from the bulk + emcee=6000, + warmup=1000, + draws=3000, # at 1000 the rank-normalised R-hat was 1.021 + chains=4, + ), + "omp": dict( + samplers=COMMON + EXTRA, + emcee=3000, + ptemcee=2000, + temps=8, + warmup=300, + draws=1000, + chains=2, + hmc_steps=20, + # two islands: at 1024/512 pocomc's split between them swings from + # seed to seed (docs/benchmarks.md) + pocomc=dict(n_effective=4096, n_active=2048), + ), +} +# the two GP optical-model problems of the notebooks, at omp's budgets +BUDGETS["alpha_gp"] = dict(BUDGETS["omp"]) +BUDGETS["n40ca_gp"] = dict(BUDGETS["omp"]) +RHAT_MAX = 1.01 +#: largest bias and width error, in reference standard deviations +TOLERANCE = 0.1 +#: the settings of the samplers that start from the prior: every setting +#: swept is correct on ``elastic`` and none on both funnels, gp and modes +#: (docs/benchmarks.md). The optical-model problems set their own pocomc +#: resolution in ``BUDGETS`` +DYNESTY = dict(nlive=500, sample="rwalk") +POCOMC = dict(n_effective=1024, n_active=512) + + +# -- shared pieces ------------------------------------------------------------- + + +def _calls(warmup=0, sampling=0, evidence=0): + """A run's calls by phase. A call is one evaluation of the log density + and, for a gradient sampler, its gradient: emcee's burn-in, NUTS's + warm-up and pocomc's tempering are ``warmup``; pocomc's importance + sampling for the evidence is ``evidence``; ``search`` is filled by + ``_charge``.""" + return dict( + search=0, warmup=int(warmup), sampling=int(sampling), evidence=int(evidence) + ) + + +def _summary(chains, wall, calls): + """``chains``: (n_chains, n_draws, ndim).""" + flat = chains.reshape(-1, chains.shape[-1]) + ess = np.asarray(blackjax.diagnostics.ess_bulk(chains)) + ess_tail = np.asarray(blackjax.diagnostics.ess_tail(chains)) + rhat = np.asarray(blackjax.diagnostics.rhat(chains)) + return dict( + wall_s=wall, + calls=calls, + min_ess=float(ess.min()), + min_ess_tail=float(ess_tail.min()), + max_rhat=float(rhat.max()), + mean=flat.mean(0).tolist(), + sd=flat.std(0).tolist(), + mcse=(flat.std(0) / np.sqrt(ess)).tolist(), + ) + + +def _weighted(samples, weights, wall, calls, logz=None, logz_err=None): + """Summary of importance-weighted draws; ESS is Kish's.""" + w = weights / weights.sum() + mean = w @ samples + sd = np.sqrt(w @ (samples - mean) ** 2) + ess = 1.0 / np.sum(w**2) + return dict( + wall_s=wall, + calls=calls, + min_ess=float(ess), + logz=logz, + logz_err=logz_err, + mean=mean.tolist(), + sd=sd.tolist(), + mcse=(sd / np.sqrt(ess)).tolist(), + ) + + +def _ball(problem, start, n, seed): + z = problem.to_unconstrained(start) + dz = 0.01 * np.random.default_rng(seed).standard_normal((n, problem.ndim)) + return np.array([problem.to_theta(z + d) for d in dz]) + + +def _charge(out, search): + """Charge a start search's wall time and calls to a sampler (none for + prior draws). An L-BFGS-B step evaluates the density and its gradient, + one call.""" + if search is None: + return out + out["wall_s"] += search.wall + out["start_search_s"] = search.wall + out["calls"]["search"] = int(search.nfev) + return out + + +def _tau(kept): + """emcee's integrated autocorrelation time of ``kept`` (steps, walkers, dim).""" + tau = float(np.max(emcee.autocorr.integrated_time(kept, quiet=True))) + return dict(tau=tau, tau_reliable=len(kept) > 50 * tau) + + +# -- ensemble samplers, from the MAP or the prior ------------------------------- + + +def _walkers(problem, start, n, seed): + """A ball about ``start``, or prior draws if it is None.""" + if start is None: + return problem.sample_prior(n, rng=seed) + return _ball(problem, start.x, n, seed) + + +def run_emcee(problem, b, start, seed=0): + n_walkers = max(32, 2 * problem.ndim + 2) + steps = b["emcee"] + t0 = time.perf_counter() + sampler = emcee.EnsembleSampler( + n_walkers, problem.ndim, problem.log_posterior_batch, vectorize=True + ) + sampler.random_state = np.random.RandomState(seed).get_state() + sampler.run_mcmc(_walkers(problem, start, n_walkers, seed), steps, progress=False) + wall = time.perf_counter() - t0 + kept = sampler.get_chain(discard=steps // 3) + burn = n_walkers * (steps // 3) + calls = _calls(warmup=burn, sampling=n_walkers * steps - burn) + out = _summary(np.swapaxes(kept, 0, 1), wall, calls) + out.update(walkers=n_walkers, steps=steps, **_tau(kept)) + return _charge(out, start) + + +def run_ptemcee(problem, b, start, seed=0): + import ptemcee + + n_walkers = max(32, 2 * problem.ndim + 2) + steps, temps = b["ptemcee"], b["temps"] + betas = ptemcee.make_ladder(problem.ndim, temps, Tmax=np.inf) # to beta = 0 + + def mapper(_, points): + """Every proposal, at every temperature, in one vmapped call each for + the prior and the likelihood; ptemcee's own rule: log L = 0 where the + prior is -inf.""" + points = np.asarray(points) + lp = problem.log_prior_batch(points) + ll = np.where(np.isfinite(lp), problem.log_likelihood_batch(points), 0.0) + return zip(ll, lp) + + t0 = time.perf_counter() + sampler = ptemcee.Sampler( + n_walkers, + problem.ndim, + problem.log_likelihood, # what mapper's ignored evaluator would call + problem.log_prior, + betas=betas, + adaptive=True, + mapper=mapper, + ) + x0 = _walkers(problem, start, temps * n_walkers, seed) + x0 = x0.reshape(temps, n_walkers, -1) + chain = sampler.chain(x0, random=np.random.RandomState(seed)) + chain.run(steps) + wall = time.perf_counter() - t0 + kept = chain.x[steps // 3 :, 0] # the beta = 1 walkers, (steps, walkers, dim) + burn = temps * n_walkers * (steps // 3) # every rung counts + calls = _calls(warmup=burn, sampling=temps * n_walkers * steps - burn) + out = _summary(np.swapaxes(kept, 0, 1), wall, calls) + logz, logz_err = _ti_log_evidence(chain, fburnin=1 / 3) + out.update( + walkers=n_walkers, + temps=temps, + steps=steps, + logz=float(logz), + logz_err=float(logz_err), + **_tau(kept), + ) + return _charge(out, start) + + +def _ti_log_evidence(chain, fburnin): + """``chain.log_evidence_estimate`` of ptemcee, which calls ``np.trapz`` + (removed in NumPy 2): thermodynamic integration of the mean log + likelihood over the final ladder, its error the difference from every + other rung.""" + start = int(chain.logl.shape[0] * fburnin + 0.5) + logls = chain.logl[start:].mean(axis=(0, 2)) + betas = chain.betas[-1] + order = np.argsort(betas)[::-1] + betas, logls = betas[order], logls[order] + if betas[-1] != 0: # the hottest rung stands in at beta = 0 + betas2 = np.concatenate((betas[::2], [0])) + logls2 = np.concatenate((logls[::2], [logls[-1]])) + betas, logls = np.concatenate((betas, [0])), np.append(logls, logls[-1]) + else: + betas2 = np.concatenate((betas[:-1:2], [0])) + logls2 = np.concatenate((logls[:-1:2], [logls[-1]])) + logz = -np.trapezoid(logls, betas) + return logz, abs(logz + np.trapezoid(logls2, betas2)) + + +# -- nested and preconditioned Monte Carlo, from the prior ----------------------- + + +def run_dynesty(problem, b, seed=0, summary=None, **settings): + t0 = time.perf_counter() + sampler = dynesty.NestedSampler( + problem.log_likelihood, + problem.prior_transform, + problem.ndim, + rstate=np.random.default_rng(seed), + **(DYNESTY | settings), + ) + sampler.run_nested(dlogz=0.5, print_progress=False) + wall = time.perf_counter() - t0 + res = sampler.results + weights = np.exp(res.logwt - res.logz[-1]) + out = _weighted( + res.samples, + weights, + wall, + _calls(sampling=np.sum(res.ncall)), + float(res.logz[-1]), + float(res.logzerr[-1]), + ) + if summary is not None: + out.update(summary(np.asarray(res.samples), weights)) + return out + + +def run_pocomc(problem, b, seed=0, summary=None, **settings): + """``summary(theta, weights) -> dict``, if given, adds to the result + anything the moments cannot show (a mode's share, say). ``n_total`` and + ``n_evidence`` among ``settings`` go to ``run`` (pocomc's defaults + otherwise, 4096 each); the rest configure the sampler.""" + import pocomc + from scipy import stats + + def log_likelihood(u): # every particle in one vmapped call + return problem.log_likelihood_batch(problem.prior_transform_batch(u)) + + prior = pocomc.Prior([stats.uniform(0.0, 1.0)] * problem.ndim) + settings = POCOMC | b.get("pocomc", {}) | settings + lengths = {k: settings.pop(k) for k in ("n_total", "n_evidence") if k in settings} + t0 = time.perf_counter() + sampler = pocomc.Sampler( + prior, log_likelihood, vectorize=True, random_state=seed, **settings + ) + sampler.run(progress=False, **lengths) + wall = time.perf_counter() - t0 + u, weights, _, _ = sampler.posterior() + logz, logz_err = sampler.evidence() + theta = problem.prior_transform_batch(u) + # the cumulative calls of each iteration: tempering until beta first + # reaches 1, then sampling at beta = 1, then the evidence's draws + beta, cumulative = (sampler.particles.get(k) for k in ("beta", "calls")) + tempered = int(cumulative[np.argmax(np.asarray(beta) >= 1.0)]) + calls = _calls( + warmup=tempered, + sampling=cumulative[-1] - tempered, + evidence=sampler.calls - cumulative[-1], + ) + out = _weighted(theta, weights, wall, calls, float(logz), float(logz_err)) + if summary is not None: + out.update(summary(np.asarray(theta), np.asarray(weights))) + return out + + +# -- HMC and NUTS, from the MAP --------------------------------------------------- + + +def _blackjax_chain(problem, kernel, key, z0, warmup, draws, **fixed): + logdensity = problem.log_posterior_unconstrained + k_warm, k_draw = jax.random.split(key) + adapt = blackjax.window_adaptation(kernel, logdensity, **fixed) + (state, tuned), warm_info = adapt.run(k_warm, z0, num_steps=warmup) + step = jax.jit(kernel(logdensity, **tuned).step) + + def one_step(state, key): + state, info = step(key, state) + return state, (state.position, info.is_divergent, info.num_integration_steps) + + _, (zs, divergent, n_leapfrog) = jax.lax.scan( + one_step, state, jax.random.split(k_draw, draws) + ) + warm = int(warm_info.info.num_integration_steps.sum()) + return zs, int(divergent.sum()), warm, int(n_leapfrog.sum()) + + +def _run_blackjax(problem, b, mode, kernel, seed=0, **fixed): + """From a ball about ``mode``, or from prior draws if it is None.""" + if mode is None: + starts = problem.sample_prior(b["chains"], rng=seed) + else: + starts = _ball(problem, mode.x, b["chains"], seed) + keys = jax.random.split(jax.random.key(seed), b["chains"]) + t0 = time.perf_counter() + chains, divergent, warm, draw = [], 0, 0, 0 + for key, theta0 in zip(keys, starts): + zs, div, n_warm, n_draw = _blackjax_chain( + problem, + kernel, + key, + problem.to_unconstrained(theta0), + b["warmup"], + b["draws"], + **fixed, + ) + chains.append(np.asarray(jax.vmap(problem.to_theta)(zs))) + divergent, warm, draw = divergent + div, warm + n_warm, draw + n_draw + wall = time.perf_counter() - t0 + out = _summary(np.stack(chains), wall, _calls(warmup=warm, sampling=draw)) + out.update(divergences=divergent, warmup=b["warmup"], draws=b["draws"], **fixed) + return _charge(out, mode) + + +def run_nuts(problem, b, mode, seed=0): + return _run_blackjax(problem, b, mode, blackjax.nuts, seed) + + +def run_hmc(problem, b, mode, seed=0): + return _run_blackjax( + problem, b, mode, blackjax.hmc, seed, num_integration_steps=b["hmc_steps"] + ) + + +def _pymc_logdensity(problem): + """A PyTensor Op for ``log_posterior_unconstrained``, its gradient a second + Op on ``jax.grad`` (PyMC's black-box likelihood pattern). PyMC runs both + at every point; the pair is one call, counted by the gradient Op.""" + import pytensor.tensor as pt + from pytensor.graph.basic import Apply + from pytensor.graph.op import Op + + value = jax.jit(problem.log_posterior_unconstrained) + grad = jax.jit(jax.grad(problem.log_posterior_unconstrained)) + + class Grad(Op): + calls = 0 + + def make_node(self, z): + z = pt.as_tensor_variable(z) + return Apply(self, [z], [z.type()]) + + def perform(self, node, inputs, outputs): + Grad.calls += 1 + outputs[0][0] = np.asarray(grad(inputs[0]), dtype=float) + + class LogDensity(Op): + def make_node(self, z): + z = pt.as_tensor_variable(z) + return Apply(self, [z], [pt.dscalar()]) + + def perform(self, node, inputs, outputs): + outputs[0][0] = np.asarray(value(inputs[0]), dtype=float) + + def grad(self, inputs, output_grads): + return [output_grads[0] * Grad()(inputs[0])] + + return LogDensity(), Grad + + +def _run_pymc(problem, b, mode, step, seed=0): + import pymc as pm + + op, grads = _pymc_logdensity(problem) + starts = _ball(problem, mode.x, b["chains"], seed) + t0 = time.perf_counter() + with pm.Model(): + z = pm.Flat("z", shape=problem.ndim) + pm.Potential("logp", op(z)) + idata = pm.sample( + draws=b["draws"], + tune=b["warmup"], + chains=b["chains"], + cores=1, # a forked process under JAX can deadlock + step=step(), + initvals=[{"z": problem.to_unconstrained(s)} for s in starts], + random_seed=seed, + progressbar=False, + compute_convergence_checks=False, + ) + wall = time.perf_counter() - t0 + zs = idata.posterior["z"].values + chains = np.array([[problem.to_theta(z) for z in chain] for chain in zs]) + stats = idata.sample_stats + # leapfrog steps of the kept draws; the rest went to tuning + drawn = int(stats["tree_size" if "tree_size" in stats else "n_steps"].sum()) + out = _summary(chains, wall, _calls(warmup=grads.calls - drawn, sampling=drawn)) + out.update( + divergences=int(stats["diverging"].sum()) if "diverging" in stats else None, + warmup=b["warmup"], + draws=b["draws"], + ) + return _charge(out, mode) + + +def run_pymc_nuts(problem, b, mode, seed=0): + import pymc as pm + + return _run_pymc(problem, b, mode, pm.NUTS, seed) + + +def run_pymc_hmc(problem, b, mode, seed=0): + import pymc as pm + + return _run_pymc(problem, b, mode, lambda: pm.HamiltonianMC(path_length=2.0), seed) + + +# -- the table -------------------------------------------------------------------- + + +def converged(r): + """R-hat at most ``RHAT_MAX`` and, for an ensemble, a run longer than + 50 tau: walkers that swap or stretch toward one another can agree with + each other long before they have explored the posterior.""" + return r.get("max_rhat", 1.0) <= RHAT_MAX and r.get("tau_reliable", True) + + +def errors(r, ref): + """``(bias, width error)`` of run ``r`` against ``ref``: the largest + ``|mean - mean_ref|`` and ``|log(sd / sd_ref)|`` over the parameters, + in reference standard deviations.""" + sd = np.asarray(ref["sd"]) + bias = np.abs(np.subtract(r["mean"], ref["mean"])) / sd + return float(bias.max()), float(np.abs(np.log(np.divide(r["sd"], sd))).max()) + + +def resolution(ref): + """How far the reference itself may be off, in its standard deviations: + the larger of the bias and width gaps between it and its independent + check (the pooled dynesty runs), or 0 for a reference without such a + check (the exact and NUTS references).""" + check = (ref or {}).get("corroboration") + return max(check["bias"], check["width"]) if check else 0.0 + + +def verdict(e, ref): + """``"ok"``, ``"wrong"`` or ``"unresolved"`` for an error ``e`` against + ``TOLERANCE``: within the reference's :func:`resolution` of the tolerance + on either side, the reference cannot tell.""" + r = resolution(ref) + if not e <= TOLERANCE + r: # NaN included + return "wrong" + return "ok" if e <= TOLERANCE - r else "unresolved" + + +MARK = {"ok": "", "wrong": " ✗", "unresolved": " ?"} + + +def correct(r, ref): + """Converged, and (given a reference) not shown wrong by it: within + ``TOLERANCE``, or within the reference's resolution of it.""" + return converged(r) and ( + ref is None or verdict(max(errors(r, ref)), ref) != "wrong" + ) + + +PHASES = ("search", "warmup", "sampling", "evidence") +HEAD = ( + "wall time", + "calls", + "search", + "warm-up", + "sampling", + "evidence", + "ms/call", +) + ("bias", "width", "min ESS", "ESS/s", "ESS/1k calls", "R-hat", "τ (steps)", "log Z") + + +def _row(v, ref): + """One sampler's cells under ``HEAD``; ESS only when correct.""" + ok = correct(v, ref) + bias = width = "—" + if ref is not None: + b, w = errors(v, ref) + bias = f"{b:.2f}" + MARK[verdict(b, ref)] + width = f"{w:.2f}" + MARK[verdict(w, ref)] + total = sum(v["calls"].values()) + share = [f"{100 * v['calls'][k] / total:.0f}%" for k in PHASES] + rhat = v.get("max_rhat") + rhat = "—" if rhat is None else f"{rhat:.3f}" + ("" if rhat <= RHAT_MAX else " ✗") + tau = "" + if "tau" in v: + tau = f"{v['tau']:.0f}" + ("" if v["tau_reliable"] else " (< 50 τ)") + logz = "" if v.get("logz") is None else f"{v['logz']:.1f} ± {v['logz_err']:.2f}" + rates = ("—", "—", "—") + if ok: + ess = v["min_ess"] + rates = (f"{ess:.0f}", f"{ess / v['wall_s']:.2f}", f"{1e3 * ess / total:.2f}") + cost = (f"{v['wall_s']:.0f} s", str(total), *share) + per_call = f"{1e3 * v['wall_s'] / total:.2f}" + return (*cost, per_call, bias, width, *rates, rhat, tau, logz) + + +def _reference_cells(ref): + logz = "" + if ref.get("logz") is not None and ref["method"] == "quadrature": + logz = f"{ref['logz']:.2f} (exact)" + elif ref.get("logz") is not None: + logz = f"{ref['logz']:.2f} ± {ref['logz_err']:.2f}" + return ("",) * (len(HEAD) - 1) + (logz,) + + +def usable_reference(name, names, ref): + """``ref`` if it may score runs of problem ``name`` with parameters + ``names``: it must name the same parameters (a reference of a redefined + problem is refused), and a rejected or uncorroborated reference is + flagged. None if there is no reference.""" + if ref is None: + return None + if ref.get("names") is None: + raise ValueError( + f"{name}: the reference does not name its parameters, so it cannot be " + "matched to the runs; rerun it (bench_samplers.py --reference)" + ) + if names is not None and ref["names"] != list(names): + raise ValueError( + f"{name}: the reference's parameters {ref['names']} are not the " + f"run's {list(names)}; rerun the reference for this problem" + ) + for flag, meaning in ( + ("accepted", "its pocomc runs disagree"), + ("corroborated", "the dynesty check disagrees"), + ): + if ref.get(flag) is False: + print( + f"WARNING: {name}'s reference is not {flag}: {meaning}", + file=sys.stderr, + ) + return ref + + +def _reference_flags(ref): + flags = [f for f in ("accepted", "corroborated") if ref.get(f) is False] + return "".join(f" (NOT {f.upper()})" for f in flags) + + +def report(results, markdown=False, refs=None): + """Print the comparison table of a run, scored against ``refs``.""" + refs = refs or {} + if markdown: + print("| problem | sampler | " + " | ".join(HEAD) + " |") + print("|" + "---|" * (len(HEAD) + 2)) + else: + print(f"{'':>12s} " + " ".join(f"{h:>10s}" for h in HEAD)) + for name, d in results.items(): + ref = usable_reference(name, d.get("names"), refs.get(name)) + if not markdown: + print(f"{name} ({d['ndim']} parameters)") + for sampler, v in d["samplers"].items(): + if markdown: + cells = (f"{name} ({d['ndim']})", sampler, *_row(v, ref)) + print("| " + " | ".join(cells) + " |") + else: + print( + f"{sampler:>12s} " + " ".join(f"{c:>10s}" for c in _row(v, ref)), + flush=True, + ) + if ref is None: + print(" (no reference: bias not scored)") + elif markdown: + cells = ( + f"{name} ({d['ndim']})", + f"reference: {ref['method']}{_reference_flags(ref)}", + ) + print("| " + " | ".join(cells + _reference_cells(ref)) + " |") + else: + logz = "" if ref.get("logz") is None else f", log Z = {ref['logz']:.2f}" + print(f" reference: {ref['method']}{_reference_flags(ref)}{logz}") + + +RUNNERS = { + "emcee": (run_emcee, "map"), + "ptemcee": (run_ptemcee, "map"), + "dynesty": (run_dynesty, None), + "pocomc": (run_pocomc, None), + "NUTS": (run_nuts, "map"), + "HMC": (run_hmc, "map"), + "PyMC NUTS": (run_pymc_nuts, "map"), + "PyMC HMC": (run_pymc_hmc, "map"), +} + + +def main(argv=None): + ap = argparse.ArgumentParser(description=__doc__.splitlines()[0]) + ap.add_argument("--out", type=Path) + ap.add_argument("--problems", nargs="*", default=list(BUDGETS)) + ap.add_argument("--report", type=Path, help="print a saved run and exit") + ap.add_argument("--markdown", action="store_true") + ap.add_argument( + "--reference", + action="store_true", + help="compute the problems' reference posteriors into --references", + ) + ap.add_argument( + "--references", + type=Path, + default=REFERENCES, + help=f"the references file to read and, with --reference, to write " + f"(default {REFERENCES.name}; give each parallel job its own and merge " + "them with merge_results.py)", + ) + ap.add_argument( + "--only", + nargs="*", + choices=list(RUNNERS), + help="re-run these samplers into the saved --out file, keeping the rest", + ) + args = ap.parse_args(argv) + refs = json.loads(args.references.read_text()) if args.references.exists() else {} + if args.report: + problems = json.loads(args.report.read_text())["problems"] + return report(problems, args.markdown, refs) + if args.reference: + from reference import reference + + for name in args.problems: + t0 = time.perf_counter() + problem = PROBLEMS[name]()[0] + refs[name] = reference(name, problem) + refs[name]["names"] = problem.names + refs[name]["wall_s"] = time.perf_counter() - t0 + print(f"{name}: {refs[name]['method']}, {refs[name]['wall_s']:.0f} s") + args.references.write_text(json.dumps(refs, indent=1)) + return None + saved = {} + if args.out and args.out.exists(): + saved = json.loads(args.out.read_text())["problems"] + results = dict(saved) + for name in args.problems: + problem, _ = PROBLEMS[name]() + b = BUDGETS[name] + todo = [s for s in b["samplers"] if not args.only or s in args.only] + start_of = {s: b.get("starts", {}).get(s, RUNNERS[s][1]) for s in todo} + starts = {"prior": None} + if "map" in start_of.values(): + starts["map"] = rx.optimize.find_map(problem, rng=0) + r = dict(saved.get(name, {}).get("samplers", {})) if args.only else {} + for sampler in todo: + run, start = RUNNERS[sampler][0], start_of[sampler] + r[sampler] = run(problem, b, starts[start]) if start else run(problem, b) + r[sampler]["start"] = start or "prior" + one = {name: dict(ndim=problem.ndim, samplers={sampler: r[sampler]})} + report(one, refs=refs) + r = {k: r[k] for k in b["samplers"] if k in r} + results[name] = dict(ndim=problem.ndim, names=problem.names, samplers=r) + report({name: results[name]}, refs=refs) + meta = dict(jax=jax.__version__, blackjax=blackjax.__version__) + if args.out: + args.out.write_text(json.dumps(dict(meta=meta, problems=results), indent=1)) + + +if __name__ == "__main__": + main() diff --git a/benchmarks/compare.py b/benchmarks/compare.py new file mode 100644 index 0000000..5f99249 --- /dev/null +++ b/benchmarks/compare.py @@ -0,0 +1,55 @@ +"""Side-by-side table of two ``bench_log_posterior.py`` result files. + + python benchmarks/compare.py BASELINE.json CANDIDATE.json + +Ratios are candidate / baseline times (below 1 is faster), and the value +column is the largest relative difference of ``log_posterior`` at the shared +parameter points. +""" + +from __future__ import annotations + +import json +import sys + +import numpy as np + + +def _ms(t): + return 1e3 * t["median"] + + +def main(base_path, cand_path): + base, cand = (json.load(open(p)) for p in (base_path, cand_path)) + print(f"baseline: {base['backend']} rxmc {base['rxmc']} jitr {base.get('jitr')}") + print(f"candidate: {cand['backend']} rxmc {cand['rxmc']} jitr {cand.get('jitr')}") + head = ( + f"{'problem':<9}{'max rel dV':>11}{'first(s)':>16}{'call ms':>20}" + f"{'ratio':>7}{'grad ms':>20}{'ratio':>7}{'B=256 θ/s':>22}{'emcee s':>16}" + ) + print(head) + print("-" * len(head)) + for name, b in base["problems"].items(): + c = cand["problems"].get(name) + if c is None: + continue + vb, vc = np.array(b["values"]), np.array(c["values"]) + rel = float(np.max(np.abs(vc - vb) / np.maximum(1.0, np.abs(vb)))) + first = f"{b['first_call_s']:.2f}/{c['first_call_s']:.2f}" + call = f"{_ms(b['log_posterior']):.3f}/{_ms(c['log_posterior']):.3f}" + r_call = c["log_posterior"]["median"] / b["log_posterior"]["median"] + grad = f"{_ms(b['grad']):.3f}/{_ms(c['grad']):.3f}" + r_grad = c["grad"]["median"] / b["grad"]["median"] + tb, tc = b["batch"]["256"]["theta_per_s"], c["batch"]["256"]["theta_per_s"] + batch = f"{tb:.0f}/{tc:.0f}" + em = "" + if "emcee" in b and "emcee" in c: + em = f"{b['emcee']['wall_s']:.1f}/{c['emcee']['wall_s']:.1f}" + print( + f"{name:<9}{rel:>11.1e}{first:>16}{call:>20}{r_call:>7.2f}" + f"{grad:>20}{r_grad:>7.2f}{batch:>22}{em:>16}" + ) + + +if __name__ == "__main__": + main(*sys.argv[1:3]) diff --git a/benchmarks/gp_seed_check.py b/benchmarks/gp_seed_check.py new file mode 100644 index 0000000..8b2db43 --- /dev/null +++ b/benchmarks/gp_seed_check.py @@ -0,0 +1,101 @@ +"""gp_discrepancy's cross-section ladder under other seeds. + +The notebook fits its three rungs with pocomc at 4096/2048 and seeds 10, 11 +and 12. This reruns the ladder at the notebook's settings with three other +sets of seeds and records what the notebook quotes: each rung's +log Z, the differences between rungs, and the medians and 68 % intervals of +the four volume parameters:: + + python benchmarks/gp_seed_check.py --out results/hpc/gp_seed_check.json +""" + +from __future__ import annotations + +import argparse +import json +from pathlib import Path + +import numpy as np +from bench_samplers import run_pocomc +from problems import RUNGS, n40ca_ladder + +#: the notebook's resolution for the ladder +SETTINGS = dict(n_effective=4096, n_active=2048) +#: the notebook uses 10 + rung; these are three other sets +SEED_SETS = (20, 30, 40) +VOLUME = ("Vv", "Wv", "Rv", "av") + + +def _quantiles(x, w, qs=(0.16, 0.5, 0.84)): + """Weighted quantiles, each draw's weight centred on its value (equal + weights give the usual midpoint median).""" + order = np.argsort(x) + w = w[order] / w.sum() + cdf = np.cumsum(w) - 0.5 * w + return [float(np.interp(q, cdf, x[order])) for q in qs] + + +def volume_summary(problem): + cols = [problem.names.index(n) for n in VOLUME] + + def summary(theta, weights): + return { + "volume": { + n: _quantiles(theta[:, c], weights) for n, c in zip(VOLUME, cols) + } + } + + return summary + + +def run_rung(base, i, settings=SETTINGS, ladder=None): + """Rung ``i`` of the ladder at seed ``base + i``, as the notebook seeds them; + only that rung is built unless a whole ``ladder`` is given.""" + rung = RUNGS[i] + problem = (ladder or n40ca_ladder([rung]))[rung] + r = run_pocomc(problem, {}, base + i, summary=volume_summary(problem), **settings) + # as the notebook prints it: a density of the cross sections, not their logs + logz = r["logz"] + problem.log_jacobian() + print(f"seeds {base}+: {rung}: log Z {logz:.2f}", flush=True) + return rung, dict( + logz=logz, logz_err=r["logz_err"], wall_s=r["wall_s"], volume=r["volume"] + ) + + +def with_differences(rungs): + """The rungs of one seed set, with the log Z differences between them.""" + names = list(rungs) + return { + **rungs, + "delta_logz": { + f"{b} - {a}": rungs[b]["logz"] - rungs[a]["logz"] + for a, b in zip(names, names[1:]) + }, + } + + +def check(seed_sets=SEED_SETS, out=None, settings=SETTINGS): + ladder = n40ca_ladder() + if out: + out.parent.mkdir(parents=True, exist_ok=True) + results = json.loads(out.read_text()) if out and out.exists() else {} + for base in seed_sets: + if str(base) in results: + continue # resume + rungs = dict(run_rung(base, i, settings, ladder) for i in range(len(RUNGS))) + results[str(base)] = with_differences(rungs) + if out: + out.write_text(json.dumps(results, indent=1)) + return results + + +def main(argv=None): + ap = argparse.ArgumentParser(description=__doc__.splitlines()[0]) + ap.add_argument("--out", type=Path) + ap.add_argument("--seed-sets", type=int, nargs="*", default=list(SEED_SETS)) + args = ap.parse_args(argv) + check(tuple(args.seed_sets), args.out) + + +if __name__ == "__main__": + main() diff --git a/benchmarks/hpc/README.md b/benchmarks/hpc/README.md new file mode 100644 index 0000000..587962b --- /dev/null +++ b/benchmarks/hpc/README.md @@ -0,0 +1,116 @@ +# Running the benchmark on a cluster + +Every independent run of the sampler benchmark can be a SLURM array task of +its own. Each task writes `benchmarks/results/hpc///.json` +and nothing else, so any number can run at once; nothing here touches the +committed `results/samplers.json` or `results/references.json` until you +merge (step 4). + +## The pieces + +| file | what it does | +|---|---| +| `task.py` | runs one task: `task.py KIND PROBLEM INDEX` (INDEX defaults to `$SLURM_ARRAY_TASK_ID`); `--list` shows what each index of a job is, `--count` how many there are | +| `submit.py` | submits any subset as array jobs, one per (kind, problem) | +| `job.sbatch` | the SLURM script every task runs in: resources, then `env.sh`, then the task | +| `env.sh` | site settings: modules, the venv, thread counts | +| `assemble.py` | after the runs: pools references, joins the sweep and seed-check pieces | + +The kinds of task: + +| kind | problems | tasks per problem | +|---|---|---| +| `ref` | any | `omp`: 6 (three pocomc runs at 8192/4096, pooled into the reference, and three dynesty runs, rslice with 1000 live points, pooled into an independent check of it); `alpha_gp`, `n40ca_gp`: 53 (the same, with fifty dynesty runs: single runs scatter too much for three to check the pool); every other problem: 1 (quadrature or a long NUTS run) | +| `run` | any | one per sampler the problem runs (4, or 8 for the three optical models) | +| `sweep` | any | `gp`, `modes`, `elastic`: 21, seven settings at three seeds each (dynesty rwalk with 200 and 500 live points, rslice with 250 and 500; pocomc at 512/256, 1024/512 and 2048/1024); every other problem: 9, pocomc at 1024/512, 2048/1024 and 4096/2048 | +| `seed` | `gp` only | 9: `gp_discrepancy`'s ladder, one rung at one of three other seed sets | + +A sampler run is not split further: its chains are scored together (R-hat +needs all of them), and the benchmark times a sampler as a user runs it. + +## Selecting what to run + +```bash +# the three optical-model problems, every kind (172 tasks in 10 arrays) +python benchmarks/hpc/submit.py --problems omp alpha_gp n40ca_gp --kinds ref run sweep seed +# every problem (default kinds: ref run sweep) +python benchmarks/hpc/submit.py --all +# a subset: two samplers on omp; one sweep setting; one seed set of the gp check +python benchmarks/hpc/submit.py --problems omp --kinds run --samplers NUTS pocomc +python benchmarks/hpc/submit.py --problems alpha_gp --kinds sweep --settings 1024/512 +python benchmarks/hpc/submit.py --kinds seed --seed-sets 20 +python benchmarks/hpc/submit.py --problems gp --kinds sweep --settings "dynesty rslice 250" +# by array index (for any kind): the dynesty runs added to alpha_gp's reference +python benchmarks/hpc/submit.py --problems alpha_gp --kinds ref --indices 12-52 +``` + +Add `--dry-run` to see the `sbatch` lines first, and `@` (step 2) +for your site's account, partition and the like. A selection keeps each +task's array index, so its result lands in the same file whichever subset +produced it, and a failed task is rerun by selecting it again (or with +`sbatch --array= ...` from the dry run). `--time` overrides the +per-task walltimes in `submit.py`'s `TIME` table, which are about twice an +8-core laptop's or a cluster run's: a population-reference pocomc or +dynesty run up to 50 min on `alpha_gp` (25 on `n40ca_gp`), a sampler run +up to about 30 min on `omp` (PyMC is the slowest), a sweep run 5 to 40 min. + +## Steps + +1. Check out the commit to run and build an environment: + + ```bash + git clone https://github.com/beykyle/rxmc.git && cd rxmc + git checkout + python3.12 -m venv ~/rxmc-venv && source ~/rxmc-venv/bin/activate + pip install -e ".[validation,samplers]" + ``` + + `validation` brings the samplers the benchmark drives (blackjax, emcee, + dynesty, pocomc) and `samplers` adds ptemcee and PyMC. If torch would + pull CUDA wheels you don't want, install it from the CPU index first. + +2. Put your site's settings in a file outside the repository, one argument + per line, for `submit.py` to read as `@file` (nothing in the repository + needs editing): + + ``` + # ~/rxmc-hpc/site.args + --account=my-account + --partition=my-partition + --constraint=my-node-feature + --venv=~/rxmc-venv + --sbatch=--qos=my-qos + ``` + + Every line is optional: `--account`, `--partition` and `--constraint` go to + `sbatch` as they are, `--venv` is exported to the job as `RXMC_VENV` (else + it is inherited from your shell, else `~/rxmc-venv`), and `--sbatch` + passes any other `sbatch` option. Each task + runs through `srun --cpu-bind=cores`, so its threads (XLA's included, + which ignore `OMP_NUM_THREADS`) stay on its own cores and the wall times + stay comparable when tasks share a node; if your site forbids `srun` + inside a batch job, take that line out of `job.sbatch` and rely on its + cgroups. A node constraint naming one CPU generation keeps the wall times + comparable across tasks too. + +3. With the environment active, submit (`submit.py` above), adding + `@$HOME/rxmc-hpc/site.args` to each command line. Logs go to + `benchmarks/results/hpc/logs/-_.out`. + +4. Bring back `benchmarks/results/hpc/` (everything but `logs/`): commit it + on a branch and push, or copy it into the same place locally. Then: + + ```bash + python benchmarks/hpc/assemble.py # references; sweep and seed-check tables + python benchmarks/merge_results.py benchmarks/results/hpc/references.json \ + benchmarks/results/hpc/run/*/*.json + python benchmarks/bench_samplers.py --report benchmarks/results/samplers.json --markdown + python benchmarks/sweep_pocomc.py --report benchmarks/results/hpc/sweep_alpha_gp.json + ``` + + A population reference whose dynesty pool disagrees with it, on log Z + (beyond twice the combined error), on the mode share (by more than 0.03) + or on the moments (by more than 0.2 sd), is saved with + `"corroborated": false` and the failed checks named; one whose own pocomc + runs disagree is saved with `"accepted": false`. Look at either before + trusting anything scored against it. diff --git a/benchmarks/hpc/assemble.py b/benchmarks/hpc/assemble.py new file mode 100644 index 0000000..036aebe --- /dev/null +++ b/benchmarks/hpc/assemble.py @@ -0,0 +1,107 @@ +"""Assemble the cluster tasks' pieces into the files the benchmark reads. + +:: + + python benchmarks/hpc/assemble.py + +* each problem's reference, whole or pooled from its parts + (``reference.pool_parts``), goes into ``results/hpc/references.json``; a + pool that misses its agreement bar is kept, marked ``accepted: false``; +* the sweep pieces of each problem become ``results/hpc/sweep_.json``; +* the seed-check pieces become ``results/hpc/gp_seed_check.json``, with each + seed set's log Z differences. + +Then ``merge_results.py`` folds ``results/hpc/references.json`` and the +sampler pieces (``results/hpc/run/*/*.json``) into the committed results. +A missing piece is reported and its problem skipped, so a partial set of +results can still be looked at. +""" + +from __future__ import annotations + +import json +import sys +from pathlib import Path + +HERE = Path(__file__).resolve().parent +sys.path.insert(0, str(HERE.parent)) +sys.path.insert(0, str(HERE)) +OUT = HERE.parent / "results" / "hpc" + + +def _pieces(kind, problem): + from task import tasks + + want = len(tasks(kind, problem)) + paths = [OUT / kind / problem / f"{i}.json" for i in range(want)] + missing = [p.name for p in paths if not p.exists()] + if missing: + print(f"{kind} {problem}: missing {missing}; skipped") + return None + return [json.loads(p.read_text()) for p in paths] + + +def references(): + from reference import POPULATION, pool_parts + + refs = {} + for problem_dir in sorted((OUT / "ref").glob("*")): + problem = problem_dir.name + parts = _pieces("ref", problem) + if parts is None: + continue + if parts[0]["part"] == "whole": # quadrature or a long NUTS run + refs[problem] = parts[0]["result"] + continue + spec = POPULATION[problem] + runs = [p["result"] for p in parts if p["part"] == "pocomc"] + dyn = [p["result"] for p in parts if p["part"] == "dynesty"] + settings = {k: spec[k] for k in ("n_effective", "n_active")} + print(f"{problem}:") + # not strict: a pool that misses its own agreement bar is kept, marked + # accepted: false, with every run, rather than lose the other problems + refs[problem] = pool_parts( + runs, spec["agree"], settings, dyn, names=parts[0]["names"], strict=False + ) + if not refs[problem]["accepted"]: + print( + f" WARNING: {problem}'s pocomc runs disagree; marked accepted: false" + ) + refs[problem]["wall_s"] = sum(r["wall_s"] for r in runs + dyn) + (OUT / "references.json").write_text(json.dumps(refs, indent=1)) + return refs + + +def sweeps(): + for problem_dir in sorted((OUT / "sweep").glob("*")): + pieces = _pieces("sweep", problem_dir.name) + if pieces is None: + continue + runs = [r for p in pieces for r in p["runs"]] + merged = dict(problem=pieces[0]["problem"], names=pieces[0]["names"], runs=runs) + (OUT / f"sweep_{problem_dir.name}.json").write_text( + json.dumps(merged, indent=1) + ) + + +def seed_check(): + from gp_seed_check import with_differences + + pieces = _pieces("seed", "gp") + if pieces is None: + return + by_base = {} + for p in pieces: + by_base.setdefault(str(p["base"]), {})[p["rung"]] = p["result"] + out = {base: with_differences(rungs) for base, rungs in by_base.items()} + (OUT / "gp_seed_check.json").write_text(json.dumps(out, indent=1)) + + +def main(): + references() + sweeps() + seed_check() + + +if __name__ == "__main__": + main() diff --git a/benchmarks/hpc/env.sh b/benchmarks/hpc/env.sh new file mode 100644 index 0000000..9cba8fc --- /dev/null +++ b/benchmarks/hpc/env.sh @@ -0,0 +1,19 @@ +# The environment of every cluster task. Sourced by job.sbatch. + +# The venv: submit.py --venv exports RXMC_VENV to the job (else it is inherited +# from the submitting shell, else ~/rxmc-venv). It must hold +# rxmc[validation,samplers] and be built from a Python that the compute nodes +# can reach at the same path; no module load is done here, since Lmod's +# `module` can trip job.sbatch's `set -u`. +RXMC_VENV="${RXMC_VENV:-$HOME/rxmc-venv}" + +source "$RXMC_VENV/bin/activate" +# BLAS and torch threads to the job's cores; XLA's threads are kept on those +# cores by job.sbatch's srun --cpu-bind +export OMP_NUM_THREADS="${SLURM_CPUS_PER_TASK:-8}" +export MKL_NUM_THREADS="$OMP_NUM_THREADS" # torch reads OMP_NUM_THREADS too +export XLA_PYTHON_CLIENT_PREALLOCATE=false +# a PyTensor (PyMC) compile cache per task: concurrent tasks sharing one in +# $HOME over NFS can stall on its lock +export PYTENSOR_FLAGS="compiledir=${TMPDIR:-/tmp}/pytensor-${SLURM_JOB_ID:-0}-${SLURM_ARRAY_TASK_ID:-0}" +export MPLBACKEND=Agg diff --git a/benchmarks/hpc/job.sbatch b/benchmarks/hpc/job.sbatch new file mode 100644 index 0000000..d3cdcc2 --- /dev/null +++ b/benchmarks/hpc/job.sbatch @@ -0,0 +1,26 @@ +#!/bin/bash +# One benchmark task: the command line comes after the script. submit.py +# submits each kind of run as an array job, e.g. +# sbatch --array=0-3 --job-name=ref_omp --time=3:00:00 job.sbatch \ +# python benchmarks/hpc/task.py ref omp +# and task.py runs the piece $SLURM_ARRAY_TASK_ID stands for. + +#SBATCH --cpus-per-task=8 +#SBATCH --mem=16G +#SBATCH --output=benchmarks/results/hpc/logs/%x-%A_%a.out +# Site settings (account, partition, node constraint, venv) are not set here: +# submit.py passes them on the sbatch command line (its --account, --partition, +# --constraint, --venv and --sbatch options, or an @file of them). +set -euo pipefail +cd "${SLURM_SUBMIT_DIR:-$(pwd)}" +source benchmarks/hpc/env.sh +echo "$(date -Is) $(git rev-parse --short HEAD) task ${SLURM_ARRAY_TASK_ID:-} $*" +if [[ -n "${SLURM_JOB_ID:-}" ]] && command -v srun >/dev/null; then + # bind the task to its allocated cores: XLA does not read OMP_NUM_THREADS, + # and binding keeps all its threads on the task's cores, so tasks sharing + # a node do not collide (and the wall times stay comparable) + srun --ntasks=1 --cpus-per-task="${SLURM_CPUS_PER_TASK:-8}" --cpu-bind=cores "$@" +else + "$@" +fi +echo "$(date -Is) done" diff --git a/benchmarks/hpc/submit.py b/benchmarks/hpc/submit.py new file mode 100644 index 0000000..00764e9 --- /dev/null +++ b/benchmarks/hpc/submit.py @@ -0,0 +1,188 @@ +"""Submit any subset of the benchmark as SLURM array jobs, one task per run. + +:: + + python benchmarks/hpc/submit.py --all --dry-run # everything + python benchmarks/hpc/submit.py --problems omp alpha_gp --kinds ref run + python benchmarks/hpc/submit.py --problems omp --kinds run --samplers NUTS pocomc + python benchmarks/hpc/submit.py --problems alpha_gp --kinds sweep --settings 1024/512 + python benchmarks/hpc/submit.py --kinds seed --seed-sets 20 + python benchmarks/hpc/submit.py --problems alpha_gp --kinds ref --indices 12-52 + +One array job per (kind, problem), whose tasks are the selected entries of +``task.py KIND PROBLEM --list``; selecting samplers, settings, seeds or seed +sets keeps their array indices, so a result lands in the same file whatever +subset produced it. Kinds: ``ref``, ``run``, ``sweep`` (any problem) and +``seed`` (gp_discrepancy's ladder; ``--problems`` does not apply). Run it +from inside the repository with the environment active. + +Site settings are options, not edits to ``job.sbatch``: ``--account``, +``--partition``, ``--constraint``, ``--venv`` (the venv ``env.sh`` +activates; default ``~/rxmc-venv``) and ``--sbatch`` for any other ``sbatch`` +option. Keep them in a file outside the repository, one argument per line, +and pass it as ``@file``:: + + # ~/rxmc-hpc/site.args + --account=my-account + --constraint=my-node-feature + + python benchmarks/hpc/submit.py @$HOME/rxmc-hpc/site.args --all --dry-run +""" + +from __future__ import annotations + +import argparse +import shlex +import subprocess +import sys +from pathlib import Path + +HERE = Path(__file__).resolve().parent +sys.path.insert(0, str(HERE)) +sys.path.insert(0, str(HERE.parent)) + +from task import tasks # noqa: E402 + +#: walltime per task, about twice the 8-core-laptop estimates; problems not +#: listed take the kind's default +TIME = { + "ref": {"omp": "4:00:00", "alpha_gp": "2:00:00", "n40ca_gp": "1:00:00", + "hierarchy": "3:00:00", "elastic": "2:00:00", "default": "1:00:00"}, + "run": {"omp": "2:00:00", "alpha_gp": "3:00:00", "n40ca_gp": "1:00:00", + "hierarchy": "3:00:00", "default": "1:00:00"}, + "sweep": {"omp": "3:00:00", "alpha_gp": "4:00:00", "n40ca_gp": "1:00:00", + "hierarchy": "3:00:00", "default": "1:00:00"}, + "seed": {"default": "1:00:00"}, +} # fmt: skip + + +def _selected(kind, entry, args): + if kind == "run": + return not args.samplers or entry in args.samplers + if kind == "sweep": + from sweep_pocomc import label + + s, seed = entry + wanted = {label(w) for w in args.settings or ()} + return (not wanted or label(s) in wanted) and ( + not args.seeds or seed in args.seeds + ) + if kind == "seed": + return not args.seed_sets or entry[0] in args.seed_sets + return True + + +def site_options(args): + """The site's ``sbatch`` options: account, partition, constraint, the venv + (exported to ``env.sh`` as ``RXMC_VENV``) and any others given.""" + opts = [ + f"--{name}={value}" + for name in ("account", "partition", "constraint") + if (value := getattr(args, name, None)) + ] + if venv := getattr(args, "venv", None): + opts.append(f"--export=ALL,RXMC_VENV={Path(venv).expanduser().resolve()}") + return opts + list(getattr(args, "sbatch", None) or []) + + +def indices(spec): + """Array indices from ``"3,5,12-52"``.""" + out = set() + for part in spec.split(","): + lo, _, hi = part.partition("-") + out.update(range(int(lo), int(hi or lo) + 1)) + return out + + +def commands(args): + """The sbatch command lines for the selection, one per array job.""" + from bench_samplers import BUDGETS + + jobs = [] + for kind in args.kinds: + for problem in ["gp"] if kind == "seed" else (args.problems or list(BUDGETS)): + indices = [ + i + for i, e in enumerate(tasks(kind, problem)) + if _selected(kind, e, args) + and (not getattr(args, "indices", None) or i in args.indices) + ] + if not indices: + continue + time = args.time or TIME[kind].get(problem, TIME[kind]["default"]) + jobs.append( + [ + "sbatch", + f"--array={','.join(map(str, indices))}", + f"--job-name={kind}_{problem}", + f"--time={time}", + *site_options(args), + str(HERE / "job.sbatch"), + "python", + str(HERE / "task.py"), + kind, + problem, + ] + ) + return jobs + + +def parse_args(argv=None): + """The command line, ``@file`` arguments read in place.""" + ap = argparse.ArgumentParser( + description=__doc__.splitlines()[0], fromfile_prefix_chars="@" + ) + from bench_samplers import BUDGETS + + ap.add_argument("--problems", nargs="*", choices=list(BUDGETS)) + ap.add_argument( + "--all", action="store_true", help="every benchmark problem (else --problems)" + ) + ap.add_argument( + "--kinds", nargs="*", default=["ref", "run", "sweep"], + choices=["ref", "run", "sweep", "seed"], + ) # fmt: skip + ap.add_argument("--samplers", nargs="*", help="run: these samplers only") + ap.add_argument( + "--settings", nargs="*", + help="sweep: these settings only, by label ('pocomc 1024/512' or 1024/512, " + "'dynesty rslice 250')", + ) # fmt: skip + ap.add_argument("--seeds", type=int, nargs="*", help="sweep: these seeds only") + ap.add_argument("--seed-sets", type=int, nargs="*", help="seed: these sets only") + ap.add_argument( + "--indices", type=indices, + help="these array indices only, of every job selected (e.g. 12-52)", + ) # fmt: skip + ap.add_argument("--time", help="walltime per task, overriding the table") + site = ap.add_argument_group("site settings (or put them in an @file)") + site.add_argument("--account", help="sbatch --account") + site.add_argument("--partition", help="sbatch --partition") + site.add_argument("--constraint", help="sbatch --constraint (node features)") + site.add_argument( + "--venv", help="the venv env.sh activates (default $RXMC_VENV or ~/rxmc-venv)" + ) + site.add_argument( + "--sbatch", action="append", metavar="OPTION", + help="any other sbatch option, as --sbatch=--qos=x (repeatable)", + ) # fmt: skip + ap.add_argument("--dry-run", action="store_true", help="print, don't submit") + args = ap.parse_args(argv) + if not (args.problems or args.all or args.kinds == ["seed"]): + ap.error("name --problems, or --all for every problem") + return args + + +def main(argv=None): + args = parse_args(argv) + (HERE.parent / "results" / "hpc" / "logs").mkdir(parents=True, exist_ok=True) + for cmd in commands(args): + print(shlex.join(cmd)) + if not args.dry_run: + subprocess.run( + cmd, check=True, cwd=HERE.parents[1] + ) # job.sbatch uses relative paths + + +if __name__ == "__main__": + main() diff --git a/benchmarks/hpc/task.py b/benchmarks/hpc/task.py new file mode 100644 index 0000000..64a5d84 --- /dev/null +++ b/benchmarks/hpc/task.py @@ -0,0 +1,139 @@ +"""One cluster task: the run that SLURM array index ``i`` of a job stands for. + +:: + + python benchmarks/hpc/task.py KIND PROBLEM [INDEX] # INDEX defaults to + # $SLURM_ARRAY_TASK_ID + python benchmarks/hpc/task.py KIND PROBLEM --count # how many tasks + python benchmarks/hpc/task.py KIND PROBLEM --list # what each one is + +KIND is + +* ``ref`` -- PROBLEM's reference: for a population reference (``omp`` and + the GP problems) one part of it, a pocomc seed or one of the + dynesty seeds that check them (pooled later by assemble.py); + otherwise the whole reference, quadrature or a long NUTS run; +* ``run`` -- one sampler of the benchmark on PROBLEM; +* ``sweep`` -- one (setting, seed) of the settings sweep (pocomc's + resolution; dynesty's settings too on gp, modes and elastic); +* ``seed`` -- one (seed set, rung) of gp_discrepancy's ladder (PROBLEM is + always ``gp``). + +Every task writes ``benchmarks/results/hpc///.json`` and +nothing else, so any number of them can run at once. +""" + +from __future__ import annotations + +import argparse +import json +import os +import sys +from pathlib import Path + +HERE = Path(__file__).resolve().parent +BENCH = HERE.parent +sys.path.insert(0, str(BENCH)) +OUT = BENCH / "results" / "hpc" + + +def tasks(kind, problem): + """The runs a KIND job of PROBLEM is made of, in array-index order.""" + if kind == "ref": + from reference import POPULATION + + if problem not in POPULATION: + return [("whole", None)] + spec = POPULATION[problem] + dyn = spec.get("corroborate", {}).get("seeds", ()) + return [("pocomc", seed) for seed in spec["seeds"]] + [ + ("dynesty", seed) for seed in dyn + ] + if kind == "run": + from bench_samplers import BUDGETS + + return list(BUDGETS[problem]["samplers"]) + if kind == "sweep": + from sweep_pocomc import SEEDS, settings_for + + return [(s, seed) for s in settings_for(problem) for seed in SEEDS] + if kind == "seed": + from gp_seed_check import SEED_SETS + + return [(base, i) for base in SEED_SETS for i in range(3)] + raise ValueError(f"unknown kind {kind!r}") + + +def run(kind, problem, index): + if kind == "seed" and problem != "gp": + raise ValueError("seed tasks belong to gp_discrepancy's ladder: use 'gp'") + task = tasks(kind, problem)[index] + out = OUT / kind / problem / f"{index}.json" + out.parent.mkdir(parents=True, exist_ok=True) + if kind == "ref": + import time + + from problems import PROBLEMS, mode_share + from reference import POPULATION, dynesty_part, pocomc_part + + spec = POPULATION.get(problem) + p, _ = PROBLEMS[problem]() + part, seed = task + summary = mode_share(problem, p) + if part == "whole": + from reference import reference + + t0 = time.perf_counter() + result = reference(problem, p) + result["wall_s"] = time.perf_counter() - t0 + result["names"] = p.names + elif part == "pocomc": + settings = {k: spec[k] for k in ("n_effective", "n_active")} + result = pocomc_part(p, seed, settings, summary) + else: + settings = {k: v for k, v in spec["corroborate"].items() if k != "seeds"} + result = dynesty_part(p, seed, settings, summary) + out.write_text( + json.dumps(dict(problem=problem, part=part, names=p.names, result=result)) + ) + elif kind == "run": + import bench_samplers + + bench_samplers.main( + ["--problems", problem, "--only", task, "--out", str(out), + "--references", str(OUT / "no-references.json")] + ) # fmt: skip + elif kind == "sweep": + import sweep_pocomc + + sweep_pocomc.sweep(problem, [task[0]], (task[1],), out) + elif kind == "seed": + import gp_seed_check + + base, i = task + rung, result = gp_seed_check.run_rung(base, i) + out.write_text(json.dumps(dict(base=base, rung=rung, result=result))) + print(f"{kind} {problem} task {index} ({task}) -> {out}") + + +def main(argv=None): + ap = argparse.ArgumentParser(description=__doc__.splitlines()[0]) + ap.add_argument("kind", choices=["ref", "run", "sweep", "seed"]) + ap.add_argument("problem") + ap.add_argument("index", nargs="?", type=int) + ap.add_argument("--count", action="store_true") + ap.add_argument("--list", action="store_true") + args = ap.parse_args(argv) + todo = tasks(args.kind, args.problem) + if args.count: + return print(len(todo)) + if args.list: + return print("\n".join(f"{i}: {t}" for i, t in enumerate(todo))) + index = args.index + if index is None: + index = int(os.environ["SLURM_ARRAY_TASK_ID"]) + run(args.kind, args.problem, index) + + +if __name__ == "__main__": + main() diff --git a/benchmarks/merge_results.py b/benchmarks/merge_results.py new file mode 100644 index 0000000..c384cdb --- /dev/null +++ b/benchmarks/merge_results.py @@ -0,0 +1,105 @@ +"""Merge per-job benchmark results into the committed result files. + +On a cluster each job writes a file of its own (``bench_samplers.py --out`` +for samplers, ``--reference --references`` for references), so jobs never +race on one file. This merges them:: + + python benchmarks/hpc/assemble.py + python benchmarks/merge_results.py benchmarks/results/hpc/references.json \ + benchmarks/results/hpc/run/*/*.json + +A sampler file holds ``{"meta": ..., "problems": {name: {"ndim", "names", +"samplers": {...}}}}`` and is merged sampler by sampler into +``results/samplers.json``; a references file holds ``{name: reference}`` and +is merged problem by problem into ``results/references.json``. Entries from +the inputs replace the committed ones; two inputs that both carry the same +sampler on the same problem (or the same reference) are refused, since one +would silently win. Problems and samplers no input mentions are left as +they are. A problem whose parameter names change (a redefined problem) +loses the sampler rows no input replaces, since they belong to the old +problem; anything that is neither a sampler file nor a file of references +(a sweep, say) is refused. +""" + +from __future__ import annotations + +import argparse +import json +from pathlib import Path + +RESULTS = Path(__file__).parent / "results" + + +def merge(inputs, samplers_path, references_path): + samplers = json.loads(samplers_path.read_text()) if samplers_path.exists() else {} + samplers.setdefault("problems", {}) + references = ( + json.loads(references_path.read_text()) if references_path.exists() else {} + ) + seen = {} + for path in inputs: + data = json.loads(Path(path).read_text()) + if "problems" in data: # a sampler run + for name, entry in data["problems"].items(): + into = samplers["problems"].setdefault( + name, + dict(ndim=entry["ndim"], names=entry.get("names"), samplers={}), + ) + new_names = entry.get("names") + if new_names is not None and into.get("names") not in (None, new_names): + # a redefined problem: the old rows belong to the old problem + print( + f"{name}: parameters changed; its old sampler rows and " + "reference are dropped" + ) + if ("reference", name) not in seen: + references.pop(name, None) + into["samplers"] = { + s: r + for s, r in into["samplers"].items() + if ("sampler", name, s) in seen + } + into["ndim"] = entry["ndim"] + if new_names is not None: + into["names"] = new_names + for sampler, row in entry["samplers"].items(): + key = ("sampler", name, sampler) + if key in seen: + raise ValueError( + f"{name}/{sampler} is in {seen[key]} and {path}" + ) + seen[key] = path + into["samplers"][sampler] = row + if "meta" in data: + samplers["meta"] = data["meta"] + else: # references + for name, ref in data.items(): + if not (isinstance(ref, dict) and {"mean", "sd", "method"} <= set(ref)): + raise ValueError( + f"{path}: {name!r} is not a reference (a sweep or seed-check " + "file?); give merge_results.py references and sampler runs only" + ) + key = ("reference", name) + if key in seen: + raise ValueError( + f"the {name} reference is in {seen[key]} and {path}" + ) + seen[key] = path + references[name] = ref + return samplers, references + + +def main(argv=None): + ap = argparse.ArgumentParser(description=__doc__.splitlines()[0]) + ap.add_argument("inputs", nargs="+", type=Path) + ap.add_argument("--samplers", type=Path, default=RESULTS / "samplers.json") + ap.add_argument("--references", type=Path, default=RESULTS / "references.json") + args = ap.parse_args(argv) + samplers, references = merge(args.inputs, args.samplers, args.references) + args.samplers.write_text(json.dumps(samplers, indent=1)) + args.references.write_text(json.dumps(references, indent=1)) + print(f"merged {len(args.inputs)} files into {args.samplers} and {args.references}") + + +if __name__ == "__main__": + main() diff --git a/benchmarks/problems.py b/benchmarks/problems.py new file mode 100644 index 0000000..95204f3 --- /dev/null +++ b/benchmarks/problems.py @@ -0,0 +1,517 @@ +"""Benchmark problems, buildable against both the numpy and the JAX rxmc. + +Each builder returns ``(problem, thetas)``: a compiled :class:`rxmc.Problem` +and a fixed ``(k, ndim)`` array of parameter points (seeded prior draws) at +which values are recorded and timings taken. The problems span the cost +regimes of the performance comparison in the JAX rewrite plan: + +* ``linear`` -- recipe 01: a line with reported errors (overhead-bound) +* ``modes`` -- recipes 04/37: several comparisons, free normalisations + and an offset per comparison, one shared mode (Woodbury) +* ``gp`` -- recipe 07: a dense GP discrepancy over N points +* ``elastic`` -- recipes 15/26: ElasticXS at several energies with a + proportional model error (solver-bound) +* ``ias`` -- an IsobaricAnalogPN prediction at one energy +* ``omp`` -- exactly the log-space p + 40Ca problem of the notebook + ``local_optical_model_calibration``: EXFOR C0076002 + (Gross et al. 1967) at 35.8 MeV, seven potential + parameters and two median-one log-space errors (9 + parameters; JAX rxmc only) +* ``alpha_gp`` -- exactly the power-of-q problem of + ``alpha_ca_error_model_comparison``: two log-space errors + and a Matern GP whose amplitude grows with q (9 + parameters, two families of potentials; JAX only) +* ``n40ca_gp`` -- exactly the "GP, growing amplitude" rung of + ``gp_discrepancy``'s cross-section ladder (7 parameters; + JAX only) +* ``hierarchy`` -- recipe 38 at scale: 30 lines sharing a slope, their + intercepts non-centred about a common mean (33 + parameters; the sampler benchmark's high-dimensional case) + +The only API difference the builders branch on is the GP kernel (sklearn in +the numpy rxmc, tinygp in the JAX one). +""" + +from __future__ import annotations + +import numpy as np +from scipy import stats + +import rxmc +from rxmc import Comparison, Constraint, Dataset, Model, Parameter, Problem +from rxmc import terms as T + +JAX = hasattr(Problem, "grad_log_posterior") +N_THETA = 8 + + +def _thetas(problem, seed=0): + return problem.sample_prior(N_THETA, rng=seed) + + +def _line(prefix=""): + m = Parameter(f"{prefix}m", prior=stats.norm(0, 5)) + b = Parameter(f"{prefix}b", prior=stats.norm(0, 5)) + return Model(lambda x, m, b: m * x + b, [m, b]) + + +def _line_data(rng, n, label, x=None): + x = np.linspace(0.5, 2.5, n) if x is None else x + y = 2.0 * x + 1.0 + rng.normal(0, 0.1, n) + return Dataset(x, y, 0.1 * np.ones(n), label=label) + + +def linear(): + d = _line_data(np.random.default_rng(0), 8, "d") + p = Problem([Constraint([Comparison(d, _line())])]) + return p, _thetas(p) + + +def modes(n_comparisons=6, n=20): + rng = np.random.default_rng(1) + model = _line() + comps = [ + Comparison(_line_data(rng, n, f"d{i}"), model) for i in range(n_comparisons) + ] + terms = [] + for i, c in enumerate(comps): + eta = Parameter(f"log_eta{i}", bounds=(-6.0, 0.0)) + terms.append(T.normalization(eta, on=c)) + terms.append(T.offset(magnitude=0.02, on=c)) + shared = Parameter("log_s", bounds=(-6.0, 0.0)) + terms.append(T.systematic(shared, T.x_basis(2.5))) + p = Problem([Constraint(comps, terms=terms)]) + return p, _thetas(p) + + +def gp(n=100): + rng = np.random.default_rng(2) + d = _line_data(rng, n, "d") + if JAX: + import jax.numpy as jnp + import tinygp + + # the same parameterisation the sklearn kernel derives: log variance + # and log length scale, sklearn's bounds in log space + params = [ + Parameter("discrepancy_k1__constant_value", bounds=(-12.0, 2.0)), + Parameter("discrepancy_k2__length_scale", bounds=(-3.0, 1.0)), + ] + term = T.kernel( + lambda log_var, log_ell: ( + jnp.exp(log_var) * tinygp.kernels.ExpSquared(scale=jnp.exp(log_ell)) + ), + params, + ) + else: + from sklearn.gaussian_process.kernels import RBF, ConstantKernel + + term = T.kernel( + ConstantKernel(0.1, (np.exp(-12.0), np.exp(2.0))) + * RBF(1.0, (np.exp(-3.0), np.exp(1.0))), + ) + p = Problem([Constraint([Comparison(d, _line())], terms=[term])]) + return p, _thetas(p) + + +def _ca40(): + import jitr + from jitr.optical_potentials.potential_forms import thomas_safe, woods_saxon_safe + + A, Z = 40, 20 + R = 1.2 * A ** (1 / 3) + mso = 1.0 / jitr.utils.constants.WAVENUMBER_PION + + def central(r, Vv, Wv, Rv, av): + return -(Vv + 1j * Wv) * woods_saxon_safe(r, Rv, av) + + def spin_orbit(r, Vso, Rso, aso): + return Vso * mso**2 * thomas_safe(r, Rso, aso) + + return jitr, A, Z, R, central, spin_orbit + + +def _omp_params(R): + return [ + Parameter("Vv", bounds=(40.0, 56.0)), + Parameter("Wv", bounds=(1.0, 8.0)), + Parameter("Rv", bounds=(0.9 * R, 1.1 * R)), + Parameter("av", bounds=(0.5, 0.8)), + ] + + +def elastic(energies=(10.0, 14.1, 20.0, 26.0), n=30): + from rxmc.reactions import ElasticXS + + jitr, A, Z, R, central, spin_orbit = _ca40() + rxn = jitr.reactions.ElasticReaction(target=(A, Z), projectile=(1, 0)) + model = ElasticXS( + "dXS/dA", + central, + spin_orbit, + lambda ws, *x: (tuple(x), (6.0, R, 0.45)), + _omp_params(R), + lmax=20, + ) + angles = np.linspace(0.2, 2.8, n) + truth = (48.0, 3.5, R, 0.7) + comps = [] + for E in energies: + meta = {"reaction": rxn, "Elab": E} + y = model.bind(angles, meta)(*truth) + y = np.asarray(y) * (1 + 0.05 * np.random.default_rng(int(E)).normal(size=n)) + comps.append( + Comparison(Dataset(angles, y, 0.03 * y, label=f"E{E}", meta=meta), model) + ) + log_c = Parameter("log_c", bounds=(-6.0, 0.0)) + constraints = [ + Constraint([c], terms=[T.proportional_error(log_c, on=c)]) for c in comps + ] + p = Problem(constraints) + return p, _thetas(p) + + +def ias(n=20): + from jitr.optical_potentials.potential_forms import coulomb_charged_sphere + + from rxmc.reactions import IsobaricAnalogPN + + jitr, _, _, _, central, spin_orbit = _ca40() + A, Z = 48, 20 + R = 1.2 * A ** (1 / 3) + rxn = jitr.reactions.Reaction( + target=(A, Z), projectile=(1, 1), product=(1, 0), residual=(A, Z + 1) + ) + model = IsobaricAnalogPN( + coulomb_charged_sphere, + central, + spin_orbit, + central, + spin_orbit, + lambda ws, Vv, Wv, Rv, av: ( + (Z, R), + (Vv + 4.0, Wv, Rv, av), + (6.0, R, 0.45), + (Vv - 4.0, Wv, Rv, av), + (6.0, R, 0.45), + ), + _omp_params(R), + lmax=20, + ) + angles = np.linspace(0.2, 2.6, n) + meta = {"reaction": rxn, "Elab": 25.0, "ExIAS": 6.7} + y = np.asarray(model.bind(angles, meta)(48.0, 3.5, R, 0.7)) + d = Dataset(angles, y, 0.05 * y, label="ias", meta=meta) + p = Problem([Constraint([Comparison(d, model)])]) + return p, _thetas(p) + + +def hierarchy(n_groups=30, n=5): + """``y_j = m x + mu + tau eta_j``, ``eta_j ~ N(0, 1)``, ``tau`` half-normal.""" + rng = np.random.default_rng(5) + m = Parameter("m", prior=stats.norm(0, 5)) + mu = Parameter("mu", prior=stats.norm(0, 5)) + tau = Parameter("tau", prior=stats.halfnorm(scale=1.0), bounds=(0.0, np.inf)) + x = np.linspace(0.0, 1.0, n) + comps = [] + for j in range(n_groups): + eta = Parameter(f"eta_{j}", prior=stats.norm(0, 1)) + y = 0.8 * x + 1.0 + 0.3 * rng.normal() + rng.normal(0, 0.1, n) + model = Model( + lambda x, m, mu, tau, eta: m * x + mu + tau * eta, [m, mu, tau, eta] + ) + comps.append(Comparison(Dataset(x, y, 0.1 * np.ones(n), label=f"g{j}"), model)) + p = Problem([Constraint(comps)]) + return p, _thetas(p) + + +def omp(): + import jitr + import pandas as pd + from jitr.optical_potentials.potential_forms import ( + coulomb_charged_sphere, + thomas_safe, + woods_saxon_prime_safe, + woods_saxon_safe, + ) + + from rxmc import transforms as tf + + here = __import__("pathlib").Path(__file__).resolve().parents[1] + df = pd.read_csv( + here / "examples" / "data" / "p40ca_elastic_35p8mev_gross1967.csv", + comment="#", + ) + measurement = { + "x": df["angle_cm_deg"].to_numpy(), + "y": df["dxs_mb_sr"].to_numpy(), + "statistical_err": df["stat_err_mb_sr"].to_numpy(), + "Einc": 35.8, + "quantity": "dXS/dA", + "y_units": "mb/sr", + "x_units": "CM-degrees", + "systematic_norm_err": 0.0, + "systematic_offset_err": 0.0, + "subentry": "C0076002", + } + reaction = jitr.reactions.ElasticReaction(target=(40, 20), projectile=(1, 1)) + data = rxmc.from_measurement(measurement, reaction=reaction) + A13, mso = 40 ** (1 / 3), 1.0 / jitr.utils.constants.WAVENUMBER_PION + + def central(r, Vv, Wv, Rv, av, Wd, Rd, ad): + surface = -4 * ad * woods_saxon_prime_safe(r, Rd, ad) + return -(Vv + 1j * Wv) * woods_saxon_safe(r, Rv, av) - 1j * Wd * surface + + def spin_orbit(r, Vso, Rso, aso): + return Vso * mso**2 * thomas_safe(r, Rso, aso) + + def coulomb(r): + return coulomb_charged_sphere(r, 20, 1.3 * A13) + + names = ["Vv", "Wv", "Rv", "av", "Wd", "Rd", "ad"] + start = [45.0, 3.0, 1.18 * A13, 0.68, 6.0, 1.28 * A13, 0.55] + sd = [8.0, 3.0, 0.25, 0.15, 5.0, 0.25, 0.15] + lower = [0.0, 0.0, 1.0, 0.2, 0.0, 1.0, 0.2] + params = [ + Parameter(n, prior=stats.norm(m, s), bounds=(lo, np.inf)) + for n, m, s, lo in zip(names, start, sd, lower) + ] + model = rxmc.reactions.ElasticXS( + "dXS/dA", + central, + spin_orbit, + lambda ws, *x: (tuple(x), (5.5, 1.0 * A13, 0.6)), + params, + coulomb=coulomb, + lmax=30, + ) + # median-one point-to-point and common errors, as log-space sds + log_sigma_A = Parameter("log_sigma_A", prior=_log_uniform(0.05, 2.0)) + log_sigma_B = Parameter("log_sigma_B", prior=_log_uniform(0.05, 2.0)) + errors = [T.noise(log_sigma_A), T.offset(log_sigma_B)] + p = Problem([Constraint([Comparison(data, model, space=tf.log)], terms=errors)]) + return p, _thetas(p) + + +def _log_uniform(lo, hi): + return stats.uniform(np.log(lo), np.log(hi) - np.log(lo)) + + +def alpha_gp(): + """alpha_ca_error_model_comparison's power-of-q model, exactly as the + notebook builds it: 44Ca(a,a) at 29 MeV, every fourth angle, in log + space, with point-to-point and common log-space errors and a Matern GP + in u = theta / pi whose amplitude grows as sin(theta / 2) ** p.""" + import jax.numpy as jnp + import jitr + import pandas as pd + import tinygp + from jitr.optical_potentials.potential_forms import ( + coulomb_charged_sphere, + woods_saxon_safe, + ) + + from rxmc import transforms as tf + + here = __import__("pathlib").Path(__file__).resolve().parents[1] + df = pd.read_csv(here / "examples" / "data" / "alpha_ca_ratio_ruth.csv") + df = df[df["target"] == "Ca44"].iloc[::4] + reaction = jitr.reactions.ElasticReaction(target=(44, 20), projectile=(4, 2)) + meta = {"reaction": reaction, "Elab": 29.0, "quantity": "dXS/dRuth"} + angles = np.deg2rad(df["angle_cm_deg"].to_numpy()) + ratio = df["ratio_to_rutherford"].to_numpy() + data = Dataset( + angles, ratio, np.zeros(ratio.size), label="44Ca(a,a) 29 MeV", meta=meta + ) + A13 = 44 ** (1 / 3) + + def central(r, V, W, R, a): + return -(V + 1j * W) * woods_saxon_safe(r, R * A13, a) + + def coulomb(r): + return coulomb_charged_sphere( + r, reaction.target.Z * reaction.projectile.Z, 1.3 * A13 + ) + + params = [ + Parameter("V", prior=stats.norm(150.0, 20.0), bounds=(0.0, np.inf)), + Parameter("W", prior=stats.norm(20.0, 10.0), bounds=(0.0, np.inf)), + Parameter("r", prior=stats.norm(1.4, 0.3), bounds=(0.8, 2.0)), + Parameter("a", prior=stats.norm(0.5, 0.2), bounds=(0.2, 1.0)), + ] + model = rxmc.reactions.ElasticXS( + "dXS/dRuth", + central, + None, + lambda ws, *x: (tuple(x), (), ()), + params, + coulomb=coulomb, + lmax=30, + ) + log_sigma_A = Parameter("log_sigma_A", prior=_log_uniform(0.05, 2.0)) + log_sigma_B = Parameter("log_sigma_B", prior=_log_uniform(0.05, 2.0)) + + def by_angle(x): + return np.asarray(x, dtype=float) / np.pi + + u = np.sort(by_angle(angles)) + log_ell = Parameter( + "log_ell", prior=_log_uniform(np.median(np.diff(u)), u[-1] - u[0]) + ) + log_A_q = Parameter("log_A_q", prior=_log_uniform(0.05, 2.0)) + power = Parameter("p", prior=stats.uniform(0.0, 16.0)) + + def power_of_q(c, log_amplitude, p): + return jnp.exp(log_amplitude) * jnp.sin(0.5 * jnp.pi * c.x) ** p + + gp = T.kernel( + lambda log_ell: tinygp.kernels.Matern52(scale=jnp.exp(log_ell)), + coords=by_angle, + amplitude=power_of_q, + amplitude_params=(log_A_q, power), + params=[log_ell], + ) + comp = Comparison(data, model, space=tf.log) + terms = [T.noise(log_sigma_A), T.offset(log_sigma_B), gp] + p = Problem([Constraint([comp], terms=terms, statistical=False)]) + return p, _thetas(p) + + +RUNGS = ("bare", "proportional error", "GP, growing amplitude") + + +def n40ca_ladder(rungs=RUNGS): + """gp_discrepancy's cross-section ladder, exactly as the notebook builds + it: mock n + 40Ca data at 14.1 MeV from a potential with volume and + surface absorption (seed 2024), fitted in log space with a volume-only + potential under three error models. Returns ``{rung: problem}`` for the + ``rungs`` asked for (each compiled only if asked for).""" + import jax.numpy as jnp + import jitr + import tinygp + from jitr.optical_potentials.potential_forms import ( + thomas_safe, + woods_saxon_prime_safe, + woods_saxon_safe, + ) + + from rxmc import transforms as tf + + rng = np.random.default_rng(2024) + reaction = jitr.reactions.ElasticReaction(target=(40, 20), projectile=(1, 0)) + R40 = 40 ** (1 / 3) + mso = 1.0 / jitr.utils.constants.WAVENUMBER_PION + + def full_central(r, Vv, Wv, Rv, av, Wd, Rd, ad): + return -(Vv + 1j * Wv) * woods_saxon_safe(r, Rv, av) - 1j * Wd * ( + -4 * ad + ) * woods_saxon_prime_safe(r, Rd, ad) + + def volume_central(r, Vv, Wv, Rv, av): + return -(Vv + 1j * Wv) * woods_saxon_safe(r, Rv, av) + + def spin_orbit(r, Vso, Rso, aso): + return Vso * mso**2 * thomas_safe(r, Rso, aso) + + so_args = (6.0, 1.1 * R40, 0.45) + full_truth = np.array([48.0, 3.5, 1.1 * R40, 0.7, 21.0, 1.2 * R40, 0.5]) + omp_full = rxmc.reactions.ElasticXS( + "dXS/dA", + full_central, + spin_orbit, + lambda ws, *x: (tuple(x), so_args), + [ + Parameter(n, prior=stats.norm(0, 1)) + for n in ("Vv", "Wv", "Rv", "av", "Wd", "Rd", "ad") + ], + lmax=10, + ) + volume_params = [ + Parameter("Vv", prior=stats.norm(48.0, 8.0)), + Parameter("Wv", prior=stats.norm(4.0, 4.0), bounds=(0.0, 30.0)), + Parameter("Rv", prior=stats.norm(1.15 * R40, 0.2)), + Parameter("av", prior=stats.norm(0.65, 0.1), bounds=(0.3, 1.2)), + ] + omp_vol = rxmc.reactions.ElasticXS( + "dXS/dA", + volume_central, + spin_orbit, + lambda ws, *x: (tuple(x), so_args), + volume_params, + lmax=10, + ) + angles = np.deg2rad(np.linspace(5.0, 160.0, 25)) + meta = {"reaction": reaction, "Elab": 14.1} + y_full = omp_full.bind(angles, meta)(*full_truth) + y = y_full * (1 + rng.normal(0.0, 0.04, angles.size)) + d_xs = Dataset(angles, y, 0.04 * y, label="n+40Ca 14.1 MeV", meta=meta) + comp = Comparison(d_xs, omp_vol, space=tf.log) + gamma = Parameter("log_gamma_xs", prior=stats.norm(np.log(0.05), 1.0)) + amp = Parameter("log_A_xs", prior=stats.norm(np.log(0.05), 1.5)) + slope = Parameter("amp_slope_xs", prior=stats.norm(0.0, 1.5)) + spacing, span = np.diff(angles).min(), angles.max() - angles.min() + ell = Parameter( + "log_ell_xs", prior=stats.uniform(np.log(spacing), np.log(span / spacing)) + ) + gp = T.kernel( + lambda log_ell: tinygp.kernels.Matern52(scale=jnp.exp(log_ell)), + params=[ell], + jitter=1e-6, + amplitude=T.exp_growth_amplitude(np.pi), + amplitude_params=(amp, slope), + ) + terms = { + "bare": [], + "proportional error": [T.noise(gamma)], # relative, in log space + "GP, growing amplitude": [gp], + } + return {r: Problem([Constraint([comp], terms=terms[r])]) for r in rungs} + + +def n40ca_gp(): + """The ladder's "GP, growing amplitude" rung (7 parameters).""" + p = n40ca_ladder(["GP, growing amplitude"])["GP, growing amplitude"] + return p, _thetas(p) + + +def mode_share(name, problem): + """``summary(theta, weights)`` for the problems with two modes: the + weighted share of draws away from the main one, counted as the notebooks + count it; None for the other problems.""" + cols = {n: i for i, n in enumerate(problem.names)} + if name == "omp": # the island away from the MAP, as local_optical counts it + + def away(t): + return (t[:, cols["Rd"]] < 4.37) & (t[:, cols["ad"]] > 0.34) + + label = "share away from the MAP island" + elif name == "alpha_gp": # the deeper family, as alpha_ca counts it + + def away(t): + return t[:, cols["V"]] > 145.0 + + label = "share in the deeper family" + else: + return None + + def summary(theta, weights): + w = weights / weights.sum() + return {"mode_share": float(w @ away(theta)), "mode_share_label": label} + + return summary + + +PROBLEMS = { + "linear": linear, + "modes": modes, + "gp": gp, + "gp500": lambda: gp(500), + "elastic": elastic, + "ias": ias, + "hierarchy": hierarchy, + "omp": omp, + "alpha_gp": alpha_gp, + "n40ca_gp": n40ca_gp, +} + +__all__ = ["PROBLEMS", "JAX", "rxmc"] diff --git a/benchmarks/reference.py b/benchmarks/reference.py new file mode 100644 index 0000000..2a42a70 --- /dev/null +++ b/benchmarks/reference.py @@ -0,0 +1,304 @@ +"""Reference posteriors the sampler benchmark scores bias against. + +Three problems are linear-Gaussian once a few parameters are fixed: their +log posterior is quadratic in the remaining (linear) columns, so it can be +integrated over those exactly and over the rest on a grid. That gives the +posterior moments and the evidence to quadrature accuracy:: + + linear no grid: (m, b) is Gaussian + gp (log variance, log length scale) on a grid; (m, b) Gaussian + hierarchy tau on a grid; (m, mu, eta_j) Gaussian + +The others have no closed form. ``modes`` and ``elastic`` have one mode, +and their reference is one long blackjax NUTS run from a ball about the MAP, +with a seed of its own, so the benchmarked NUTS row is not scored against +itself. ``omp`` has two separated islands, and a NUTS chain stays in the +island it starts in, so R-hat cannot see an island no chain visited; its +reference pools several pocomc runs at four times the benchmark's +resolution, each with a seed of its own, accepted only if they agree. ``python bench_samplers.py --reference`` writes them all to +``results/references.json``. +""" + +from __future__ import annotations + +import itertools + +import numpy as np +from scipy.special import logsumexp + +#: per problem: the grid columns and their nodes (the rest are integrated +#: exactly), or None for a long NUTS run; the nodes are cell midpoints, so +#: a grid with a closed end (tau = 0) never evaluates on the boundary +GRIDS = { + "linear": {}, + "gp": {2: (-12.0, 2.0, 100), 3: (-3.0, 1.0, 100)}, + "hierarchy": {2: (0.0, 6.0, 4000)}, +} +#: per problem: pocomc runs pooled into the reference, and how closely each +#: must agree with the pool (bias and width, in posterior standard +#: deviations); then dynesty runs, pooled the same way, that check the pool +#: from an independent algorithm. One dynesty run is too noisy for that +#: (0.12 to 0.37 sd on omp), so three are pooled; rslice is the setting of the +#: sweep that does best on the funnels. The check is recorded, not enforced +#: (``CORROBORATION`` has its bars). +POPULATION = { + name: dict( + n_effective=8192, + n_active=4096, + seeds=(2000, 2001, 2002), + agree=0.05, + corroborate=dict(nlive=1000, sample="rslice", seeds=(3000, 3001, 3002)), + ) + for name in ("omp", "alpha_gp", "n40ca_gp") +} +# alpha_gp's and n40ca_gp's single dynesty runs scatter too much for three to +# check the pool: alpha_gp's in the share of the deeper family (0.55 to 0.90, +# about 0.1 sd, against a bar of 0.03), and both in their moments (the pools' +# gaps of 0.16 and 0.15 sd set those references' resolution). Fifty pooled +# put the share's standard error near 0.015 +for _name in ("alpha_gp", "n40ca_gp"): + POPULATION[_name]["corroborate"]["seeds"] = tuple(range(3000, 3050)) +#: the pooled dynesty runs corroborate the pooled pocomc ones if their log Z +#: agree within twice the combined error, their mode shares (where a problem +#: has two modes) within ``share``, and their moments within ``moments`` sd +CORROBORATION = dict(share=0.03, moments=0.2) +#: smaller steps than the benchmark's NUTS (target acceptance 0.8), to stay +#: clear of divergences +NUTS = dict(chains=4, warmup=1000, draws=3000, seed=1000, target_acceptance_rate=0.95) + + +def _midpoints(lo, hi, n): + edges = np.linspace(lo, hi, n + 1) + return 0.5 * (edges[1:] + edges[:-1]), (hi - lo) / n + + +def conditional_gaussian(problem, grid, x0=None): + """Exact moments and log Z of a posterior quadratic in every column not in + ``grid`` (``{column: (lo, hi, n)}``) given the grid columns. + + At each grid node, one Newton step over the linear block from ``x0`` lands + on the conditional mode, and the Hessian there is the conditional + precision, both exact for a quadratic. The conditional normalisers weight + the nodes; moments mix over them. + """ + cols = sorted(grid) + lin = np.array([k for k in range(problem.ndim) if k not in grid]) + x0 = np.zeros(lin.size) if x0 is None else np.asarray(x0, float) + axes = [_midpoints(*grid[k]) for k in cols] + cell = np.prod([h for _, h in axes]) if axes else 1.0 + nodes = list(itertools.product(*[v for v, _ in axes])) or [()] + log_z, means, variances = [], [], [] + theta = np.empty(problem.ndim) + for node in nodes: + theta[cols] = node + theta[lin] = x0 + f, g = problem.value_and_grad_log_posterior(theta) + precision = -problem.hessian_log_posterior(theta)[np.ix_(lin, lin)] + step = np.linalg.solve(precision, g[lin]) + _, logdet = np.linalg.slogdet(precision) + log_z.append( + f + 0.5 * g[lin] @ step + 0.5 * lin.size * np.log(2 * np.pi) - 0.5 * logdet + ) + means.append(x0 + step) + variances.append(np.diag(np.linalg.inv(precision))) + log_z, means, variances = map(np.asarray, (log_z, means, variances)) + w = np.exp(log_z - log_z.max()) + w /= w.sum() + mean, sd = np.empty(problem.ndim), np.empty(problem.ndim) + mean[lin] = w @ means + sd[lin] = np.sqrt(w @ (variances + (means - mean[lin]) ** 2)) + pts = np.array(nodes, float).reshape(len(nodes), len(cols)) + mean[cols] = w @ pts + sd[cols] = np.sqrt(w @ (pts - mean[cols]) ** 2) + return dict( + method="quadrature", + mean=mean.tolist(), + sd=sd.tolist(), + logz=float(logsumexp(log_z) + np.log(cell)), + ) + + +def long_nuts(problem): + """Window-adapted NUTS chains, much longer than the benchmark's; accepted + only if they converged without divergences. They start about the MAP: a + chain started from a prior draw can be trapped in a minor mode (on + ``modes``, one with a log posterior 40 below the main one).""" + import blackjax + import jax + from bench_samplers import RHAT_MAX, _ball, _blackjax_chain, _summary + + import rxmc as rx + + b = NUTS + keys = jax.random.split(jax.random.key(b["seed"]), b["chains"]) + mode = rx.optimize.find_map(problem, rng=b["seed"]) + starts = _ball(problem, mode.x, b["chains"], b["seed"]) + chains, divergent = [], 0 + for key, theta0 in zip(keys, starts): + zs, div, _, _ = _blackjax_chain( + problem, + blackjax.nuts, + key, + problem.to_unconstrained(theta0), + b["warmup"], + b["draws"], + target_acceptance_rate=b["target_acceptance_rate"], + ) + chains.append(np.asarray(jax.vmap(problem.to_theta)(zs))) + divergent += div + s = _summary(np.stack(chains), 0.0, {}) + if s["max_rhat"] > RHAT_MAX or divergent: + raise RuntimeError( + f"reference NUTS: R-hat {s['max_rhat']:.3f}, {divergent} divergences" + ) + return dict( + method=f"NUTS, {b['chains']} x {b['draws']} draws", + mean=s["mean"], + sd=s["sd"], + logz=None, + min_ess=s["min_ess"], + max_rhat=s["max_rhat"], + ) + + +def long_pocomc(problem, seeds, agree, corroborate=None, name=None, **settings): + """pocomc runs at ``settings``, one per seed, pooled with equal weight; + accepted only if every run is within ``agree`` of the pool. The + evidence is the runs' mean, its error their half-spread or the largest + quoted error, whichever is larger. + + With ``corroborate`` (dynesty settings and ``seeds``), dynesty runs are + pooled the same way and compared with the pocomc pool (``CORROBORATION``). + The comparison is recorded either way, ``corroborated`` true or false, so + both answers survive for a person to judge. + + On a cluster every run is a separate task (``pocomc_part``, + ``dynesty_part``) and ``pool_parts`` assembles them.""" + from problems import mode_share + + summary = mode_share(name, problem) if name else None + runs = [pocomc_part(problem, seed, settings, summary) for seed in seeds] + dynesty = [] + if corroborate: + d_settings = {k: v for k, v in corroborate.items() if k != "seeds"} + dynesty = [ + dynesty_part(problem, seed, d_settings, summary) + for seed in corroborate["seeds"] + ] + return pool_parts(runs, agree, settings, dynesty, names=problem.names) + + +def pocomc_part(problem, seed, settings, summary=None): + """One pocomc run of a population reference; logged as it ends.""" + from bench_samplers import run_pocomc + + r = run_pocomc(problem, {}, seed, summary=summary, **settings) + r["seed"] = seed + print( + f" pocomc seed {seed}: {r['wall_s']:.0f} s, log Z {r['logz']:.2f}, " + f"mean {np.round(r['mean'], 3).tolist()}, sd {np.round(r['sd'], 3).tolist()}", + flush=True, + ) + return r + + +def dynesty_part(problem, seed, settings, summary=None): + """One of the dynesty runs that check a population reference.""" + from bench_samplers import run_dynesty + + d = run_dynesty(problem, {}, seed, summary=summary, **settings) + d.update(seed=seed, method=f"dynesty {settings}") + print( + f" dynesty seed {seed}: {d['wall_s']:.0f} s, log Z {d['logz']:.2f}", flush=True + ) + return d + + +def _pool(runs): + """Equal-weight pool of runs: means, sds (within-run variances plus the + spread of the means), log Z and its error (half-spread or the largest + quoted error), and the mean mode share where the runs have one.""" + mean = np.mean([r["mean"] for r in runs], axis=0) + var = np.mean( + [np.square(r["sd"]) + np.square(np.subtract(r["mean"], mean)) for r in runs], + axis=0, + ) + logz = np.array([r["logz"] for r in runs]) + pool = dict( + mean=mean.tolist(), + sd=np.sqrt(var).tolist(), + logz=float(logz.mean()), + logz_err=float(max(np.ptp(logz) / 2, max(r["logz_err"] for r in runs))), + ) + if all("mode_share" in r for r in runs): + pool["mode_share"] = float(np.mean([r["mode_share"] for r in runs])) + pool["mode_share_label"] = runs[0]["mode_share_label"] + return pool + + +def _summarised(r): + keep = ("seed", "mean", "sd", "logz", "logz_err", "wall_s", "mode_share") + return {k: r[k] for k in keep if k in r} + + +def pool_parts(runs, agree, settings, dynesty=(), names=None, strict=True): + """The reference from its parts: the pocomc ``runs`` pooled and checked + against ``agree``, and the ``dynesty`` runs pooled and compared with it. + A run outside ``agree`` raises if ``strict``; otherwise (assembling cluster + results) the reference is returned with ``accepted: False``.""" + from bench_samplers import errors + + pool = _pool(runs) + worst = max(max(errors(r, pool)) for r in runs) + accepted = worst <= agree + if not accepted and strict: + raise RuntimeError(f"reference pocomc: a run is {worst:.3f} sd from the pool") + out = dict( + method=f"pocomc {settings['n_effective']}/{settings['n_active']}, {len(runs)} runs", + **pool, + max_disagreement=float(worst), + accepted=bool(accepted), + runs=[_summarised(r) for r in runs], + ) + if names is not None: + out["names"] = list(names) + if dynesty: + d = _pool(dynesty) + bias, width = errors(d, pool) + combined = float(np.hypot(pool["logz_err"], d["logz_err"])) + checks = { + "log Z": abs(d["logz"] - pool["logz"]) <= 2 * combined, + "moments": max(bias, width) <= CORROBORATION["moments"], + } + if "mode_share" in d and "mode_share" in pool: + share_gap = abs(d["mode_share"] - pool["mode_share"]) + checks["mode share"] = share_gap <= CORROBORATION["share"] + out["corroboration"] = dict( + method=f"{dynesty[0]['method']}, {len(dynesty)} runs pooled", + **d, + bias=bias, + width=width, + logz_combined_err=combined, + checks={k: bool(v) for k, v in checks.items()}, + runs=[_summarised(r) for r in dynesty], + ) + out["corroborated"] = all(checks.values()) + failed = [k for k, v in checks.items() if not v] + print( + f" dynesty pool: bias {bias:.3f}, width {width:.3f}, log Z " + f"{d['logz']:.2f} against {pool['logz']:.2f}" + + (f", mode share {d['mode_share']:.3f} against {pool['mode_share']:.3f}" + if "mode_share" in d and "mode_share" in pool else "") + + (": agrees" if not failed else f": WARNING: disagrees on {failed}"), + flush=True, + ) # fmt: skip + return out + + +def reference(name, problem): + """The reference posterior of benchmark problem ``name``.""" + if name in GRIDS: + return conditional_gaussian(problem, GRIDS[name]) + if name in POPULATION: + return long_pocomc(problem, name=name, **POPULATION[name]) + return long_nuts(problem) diff --git a/benchmarks/results/hpc/gp_seed_check.json b/benchmarks/results/hpc/gp_seed_check.json new file mode 100644 index 0000000..a65775a --- /dev/null +++ b/benchmarks/results/hpc/gp_seed_check.json @@ -0,0 +1,263 @@ +{ + "20": { + "bare": { + "logz": -467.1986190267969, + "logz_err": 0.00935650207815213, + "wall_s": 425.88291022810154, + "volume": { + "Vv": [ + 26.39869081996731, + 26.814852309968852, + 27.248393554405368 + ], + "Wv": [ + 16.387744289728683, + 16.620174183996554, + 16.868270510924173 + ], + "Rv": [ + 4.409219641999574, + 4.43174260978977, + 4.453047150239135 + ], + "av": [ + 0.6533276696879841, + 0.6588542210689285, + 0.6648971904696395 + ] + } + }, + "proportional error": { + "logz": 91.11353850567609, + "logz_err": 0.010601958424161291, + "wall_s": 257.2846498340368, + "volume": { + "Vv": [ + 27.586361201266364, + 30.060032443731835, + 32.84700465999116 + ], + "Wv": [ + 16.891551770600966, + 18.208471122435636, + 19.706773498610485 + ], + "Rv": [ + 4.150877344127975, + 4.271534935758702, + 4.383714274319776 + ], + "av": [ + 0.6551305982809059, + 0.690228828305402, + 0.7237985505455151 + ] + } + }, + "GP, growing amplitude": { + "logz": 103.91938638563427, + "logz_err": 0.02422968981047238, + "wall_s": 324.78381155617535, + "volume": { + "Vv": [ + 42.30161794702271, + 43.70266361832251, + 45.198550648788185 + ], + "Wv": [ + 12.678707453078912, + 13.649520071334589, + 14.719613208928612 + ], + "Rv": [ + 4.227380873132531, + 4.293731575765284, + 4.357330709323412 + ], + "av": [ + 0.46349099718700365, + 0.4854369604345872, + 0.5085200368470595 + ] + } + }, + "delta_logz": { + "proportional error - bare": 558.312157532473, + "GP, growing amplitude - proportional error": 12.80584787995818 + } + }, + "30": { + "bare": { + "logz": -467.2247872466171, + "logz_err": 0.010348937661289888, + "wall_s": 398.62346221809275, + "volume": { + "Vv": [ + 26.396505176817247, + 26.818071720246106, + 27.240299614240463 + ], + "Wv": [ + 16.385464705354682, + 16.620483571162094, + 16.864325087453032 + ], + "Rv": [ + 4.40964164686341, + 4.431349109736608, + 4.453184149983517 + ], + "av": [ + 0.6531163011133486, + 0.6591593210482388, + 0.6648669071105917 + ] + } + }, + "proportional error": { + "logz": 91.13986392466816, + "logz_err": 0.016766580272858843, + "wall_s": 278.46467625908554, + "volume": { + "Vv": [ + 27.820497726474084, + 30.212532836764044, + 33.07058968958621 + ], + "Wv": [ + 16.973869328555743, + 18.26580072341679, + 19.79591543488248 + ], + "Rv": [ + 4.14233444911613, + 4.264924246854586, + 4.37658331794029 + ], + "av": [ + 0.6564152097597707, + 0.6915084952412663, + 0.726436092645128 + ] + } + }, + "GP, growing amplitude": { + "logz": 103.9718637909213, + "logz_err": 0.07226342202215824, + "wall_s": 318.41482994914986, + "volume": { + "Vv": [ + 42.35256522429208, + 43.735308806529744, + 45.31000916048041 + ], + "Wv": [ + 12.673784463194893, + 13.645367187920415, + 14.66979860652851 + ], + "Rv": [ + 4.221096591898084, + 4.2896026337782756, + 4.352590814066096 + ], + "av": [ + 0.4648064520519378, + 0.48644429112589305, + 0.5110368137323804 + ] + } + }, + "delta_logz": { + "proportional error - bare": 558.3646511712852, + "GP, growing amplitude - proportional error": 12.831999866253142 + } + }, + "40": { + "bare": { + "logz": -467.1888714701149, + "logz_err": 0.006240353690193166, + "wall_s": 430.61750060203485, + "volume": { + "Vv": [ + 26.389061357046838, + 26.814091828028356, + 27.235845160572538 + ], + "Wv": [ + 16.384679800786344, + 16.62006984559167, + 16.8603734180845 + ], + "Rv": [ + 4.410074372864557, + 4.4315616330831284, + 4.452616987045888 + ], + "av": [ + 0.6533108334351164, + 0.658955821950662, + 0.6647111939488038 + ] + } + }, + "proportional error": { + "logz": 91.13581670518784, + "logz_err": 0.007225881330004171, + "wall_s": 248.46190755907446, + "volume": { + "Vv": [ + 27.459115335166285, + 29.906191938804618, + 32.74119838944099 + ], + "Wv": [ + 16.775368010146916, + 18.122628027891384, + 19.612299963690074 + ], + "Rv": [ + 4.155881908081867, + 4.278418485997045, + 4.394882702832725 + ], + "av": [ + 0.6529105756688098, + 0.6887333255238938, + 0.7233617600580754 + ] + } + }, + "GP, growing amplitude": { + "logz": 103.93177254706498, + "logz_err": 0.015571699513681403, + "wall_s": 312.8228339899797, + "volume": { + "Vv": [ + 42.08771062452891, + 43.59531105570342, + 45.14164364272251 + ], + "Wv": [ + 12.725108943331891, + 13.685301994898728, + 14.692784503614023 + ], + "Rv": [ + 4.229011311219274, + 4.297795725801073, + 4.365363793987383 + ], + "av": [ + 0.4610779264850028, + 0.4843189888026725, + 0.5080713272497523 + ] + } + }, + "delta_logz": { + "proportional error - bare": 558.3246881753028, + "GP, growing amplitude - proportional error": 12.795955841877145 + } + } +} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/alpha_gp/0.json b/benchmarks/results/hpc/ref/alpha_gp/0.json new file mode 100644 index 0000000..5c9598b --- /dev/null +++ b/benchmarks/results/hpc/ref/alpha_gp/0.json @@ -0,0 +1 @@ +{"problem": "alpha_gp", "part": "pocomc", "names": ["V", "W", "r", "a", "log_sigma_A", "log_sigma_B", "log_ell", "log_A_q", "p"], "result": {"wall_s": 1916.138335942058, "calls": {"search": 0, "warmup": 774144, "sampling": 0, "evidence": 4096}, "min_ess": 15879.968569076134, "logz": -84.53085505152227, "logz_err": 0.010752965731570916, "mean": [156.8785555103583, 27.084545266633093, 1.2949127736646193, 0.6087120605094569, -0.7227072567074655, -0.9316473871610929, -3.7103949456299055, 0.3687829414566313, 8.009230708265191], "sd": [20.209887821553867, 2.4362592655920334, 0.02591123388018143, 0.016808298456851233, 0.10518896180442683, 0.7578834072315861, 0.28290802006322957, 0.2340100304599236, 3.386179474805629], "mcse": [0.16037589153431311, 0.019332974788279274, 0.00020561901535427182, 0.00013338252413837875, 0.0008347287069531444, 0.006014196030529141, 0.002245021166889353, 0.0018569903798751762, 0.026871081965530216], "mode_share": 0.7388912281610726, "mode_share_label": "share in the deeper family", "seed": 2000}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/alpha_gp/1.json b/benchmarks/results/hpc/ref/alpha_gp/1.json new file mode 100644 index 0000000..e8614fd --- /dev/null +++ b/benchmarks/results/hpc/ref/alpha_gp/1.json @@ -0,0 +1 @@ +{"problem": "alpha_gp", "part": "pocomc", "names": ["V", "W", "r", "a", "log_sigma_A", "log_sigma_B", "log_ell", "log_A_q", "p"], "result": {"wall_s": 1860.9660312659107, "calls": {"search": 0, "warmup": 696320, "sampling": 0, "evidence": 4096}, "min_ess": 16254.16911115586, "logz": -84.5240567170944, "logz_err": 0.014698470842069744, "mean": [156.87994947919742, 27.07086370722465, 1.2948506648103246, 0.6088069645653363, -0.7223079285328061, -0.9227154032774394, -3.7081077138705, 0.37081806005134144, 8.020414799227787], "sd": [20.2181779157913, 2.4194654122845995, 0.02581627166683903, 0.016793939425374386, 0.10580297106742258, 0.7545306780598743, 0.28452537496843255, 0.23052603572312544, 3.369362709178061], "mcse": [0.1585840945778098, 0.018977413957258854, 0.00020249352264641002, 0.0001317256030320844, 0.000829880340367592, 0.005918266468406579, 0.0022317144087716746, 0.0018081630700860754, 0.02642806571218792], "mode_share": 0.7385990858823233, "mode_share_label": "share in the deeper family", "seed": 2001}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/alpha_gp/10.json b/benchmarks/results/hpc/ref/alpha_gp/10.json new file mode 100644 index 0000000..c5c1c06 --- /dev/null +++ b/benchmarks/results/hpc/ref/alpha_gp/10.json @@ -0,0 +1 @@ +{"problem": "alpha_gp", "part": "dynesty", "names": ["V", "W", "r", "a", "log_sigma_A", "log_sigma_B", "log_ell", "log_A_q", "p"], "result": {"wall_s": 2875.0876061839517, "calls": {"search": 0, "warmup": 0, "sampling": 1181776, "evidence": 0}, "min_ess": 6999.223782566096, "logz": -84.02183755119567, "logz_err": 0.23912199981526341, "mean": [160.99841770026336, 27.40448536891458, 1.2911358112376625, 0.6076928068655332, -0.7224908084477776, -0.9052122766138084, -3.7110756601273396, 0.3769317063569782, 8.053636608850468], "sd": [17.515780354746326, 2.3820585663356977, 0.02465902171266932, 0.01644394549904426, 0.10593060232317225, 0.7520234578269029, 0.28109033999369437, 0.22969777163443195, 3.378046979895328], "mcse": [0.2093652263369713, 0.028472624158800572, 0.0002947480247845384, 0.00019655363915015717, 0.0012661830693368415, 0.008988897912046327, 0.003359858451180512, 0.002745565711225046, 0.04037762270357896], "mode_share": 0.8278044572654997, "mode_share_label": "share in the deeper family", "seed": 3007, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/alpha_gp/11.json b/benchmarks/results/hpc/ref/alpha_gp/11.json new file mode 100644 index 0000000..591a123 --- /dev/null +++ b/benchmarks/results/hpc/ref/alpha_gp/11.json @@ -0,0 +1 @@ +{"problem": "alpha_gp", "part": "dynesty", "names": ["V", "W", "r", "a", "log_sigma_A", "log_sigma_B", "log_ell", "log_A_q", "p"], "result": {"wall_s": 2682.265818547923, "calls": {"search": 0, "warmup": 0, "sampling": 1192089, "evidence": 0}, "min_ess": 7148.415317065815, "logz": -84.1551222001456, "logz_err": 0.22741348205969047, "mean": [159.22010953303044, 27.28697256437662, 1.2923225529808018, 0.6085520806862227, -0.7216569112134016, -0.9452581880320303, -3.7080525102909463, 0.3784186184267962, 8.079298532003122], "sd": [19.0849984756615, 2.38339983958914, 0.025899672555182413, 0.01653809553346347, 0.10576194562063879, 0.7640031085732, 0.29374600487673524, 0.23306747437997172, 3.3574979668693827], "mcse": [0.225728939509275, 0.02818980147696266, 0.0003063298971165447, 0.0001956052954907241, 0.0012509056186632433, 0.009036291603583185, 0.0034742981117064785, 0.0027566192312243627, 0.03971100424411765], "mode_share": 0.7860332718680059, "mode_share_label": "share in the deeper family", "seed": 3008, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/alpha_gp/12.json b/benchmarks/results/hpc/ref/alpha_gp/12.json new file mode 100644 index 0000000..71ba0b3 --- /dev/null +++ b/benchmarks/results/hpc/ref/alpha_gp/12.json @@ -0,0 +1 @@ +{"problem": "alpha_gp", "part": "dynesty", "names": ["V", "W", "r", "a", "log_sigma_A", "log_sigma_B", "log_ell", "log_A_q", "p"], "result": {"wall_s": 2833.55410412699, "calls": {"search": 0, "warmup": 0, "sampling": 1220631, "evidence": 0}, "min_ess": 6992.677695735592, "logz": -84.63961945228941, "logz_err": 0.23878867437925277, "mean": [155.3063553799417, 26.991669968116433, 1.2958127687969154, 0.6095871157701005, -0.721502163939222, -0.9285800365826257, -3.7088418547748923, 0.3736231905042132, 8.12145894564049], "sd": [20.933757024793053, 2.461757397608303, 0.02587346135106598, 0.016589550936467797, 0.10783832140394009, 0.7509432638738239, 0.2851112750837159, 0.23368103947136057, 3.393014751854307], "mcse": [0.2503372190330612, 0.029439029989764623, 0.0003094088822046638, 0.00019838684673391637, 0.0012895891288641093, 0.008980186791464957, 0.0034095152453950464, 0.002794484596947008, 0.04057551045955911], "mode_share": 0.7034441077229117, "mode_share_label": "share in the deeper family", "seed": 3009, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/alpha_gp/13.json b/benchmarks/results/hpc/ref/alpha_gp/13.json new file mode 100644 index 0000000..365f472 --- /dev/null +++ b/benchmarks/results/hpc/ref/alpha_gp/13.json @@ -0,0 +1 @@ +{"problem": "alpha_gp", "part": "dynesty", "names": ["V", "W", "r", "a", "log_sigma_A", "log_sigma_B", "log_ell", "log_A_q", "p"], "result": {"wall_s": 2788.0256429337896, "calls": {"search": 0, "warmup": 0, "sampling": 1245777, "evidence": 0}, "min_ess": 7231.984419536928, "logz": -84.79868345852779, "logz_err": 0.22890025543128578, "mean": [163.12063951664535, 27.538722614483063, 1.2906840103073172, 0.6059377206585473, -0.7287969042137526, -0.9418116317895356, -3.71035896549328, 0.3726765712953878, 8.158332744388572], "sd": [15.176868883888108, 2.2241353016290057, 0.02407315695963394, 0.016690477563964697, 0.10812708542728128, 0.7676258698171972, 0.29151031769107444, 0.232880822730492, 3.412121349630975], "mcse": [0.17846515818826603, 0.026153659326839954, 0.00028307681892494516, 0.00019626371825962367, 0.0012714689408499587, 0.009026530658887479, 0.003427876682487444, 0.002738451072192659, 0.04012321520850144], "mode_share": 0.8791872711094684, "mode_share_label": "share in the deeper family", "seed": 3010, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/alpha_gp/14.json b/benchmarks/results/hpc/ref/alpha_gp/14.json new file mode 100644 index 0000000..31e0f14 --- /dev/null +++ b/benchmarks/results/hpc/ref/alpha_gp/14.json @@ -0,0 +1 @@ +{"problem": "alpha_gp", "part": "dynesty", "names": ["V", "W", "r", "a", "log_sigma_A", "log_sigma_B", "log_ell", "log_A_q", "p"], "result": {"wall_s": 2591.552704587113, "calls": {"search": 0, "warmup": 0, "sampling": 1224449, "evidence": 0}, "min_ess": 7245.291551738504, "logz": -84.7037004903802, "logz_err": 0.2275487879017086, "mean": [156.34340835517068, 26.9621430423351, 1.2958335533590637, 0.6085424439599016, -0.7248357296876888, -0.9162144545947323, -3.7005144391002958, 0.38429932864786626, 8.246337608877598], "sd": [20.357997226227745, 2.429216502065792, 0.02559795627949606, 0.016686663518461587, 0.10676431540922625, 0.7542851347764941, 0.28526514804634256, 0.22659698890394125, 3.399688583913854], "mcse": [0.23917022810760702, 0.02853896964743299, 0.0003007304193247528, 0.0001960385923878451, 0.0012542906547447568, 0.008861507629554729, 0.003351357688638226, 0.002662111253990709, 0.0399402890703787], "mode_share": 0.7284700240201466, "mode_share_label": "share in the deeper family", "seed": 3011, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/alpha_gp/15.json b/benchmarks/results/hpc/ref/alpha_gp/15.json new file mode 100644 index 0000000..800f8ce --- /dev/null +++ b/benchmarks/results/hpc/ref/alpha_gp/15.json @@ -0,0 +1 @@ +{"problem": "alpha_gp", "part": "dynesty", "names": ["V", "W", "r", "a", "log_sigma_A", "log_sigma_B", "log_ell", "log_A_q", "p"], "result": {"wall_s": 2663.0582647961564, "calls": {"search": 0, "warmup": 0, "sampling": 1184871, "evidence": 0}, "min_ess": 7171.360939019392, "logz": -84.3482874109922, "logz_err": 0.2283969344261856, "mean": [156.66773258934546, 27.049494135389804, 1.294725645933369, 0.6090813365532447, -0.723103710053029, -0.9435031920724252, -3.7029278734053137, 0.3767836692513785, 8.11823521992168], "sd": [20.175779855338536, 2.4278164990104085, 0.02532967501218099, 0.016927693069028804, 0.1086198068994079, 0.7519929921298538, 0.28982154251355335, 0.23521467134134671, 3.393308009293439], "mcse": [0.23824815154775508, 0.028669166561773353, 0.0002991085496683133, 0.00019989272348234526, 0.0012826502073678481, 0.008880000755182556, 0.0034223929522259645, 0.0027775610690538174, 0.040070290548518135], "mode_share": 0.7332125433989597, "mode_share_label": "share in the deeper family", "seed": 3012, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/alpha_gp/16.json b/benchmarks/results/hpc/ref/alpha_gp/16.json new file mode 100644 index 0000000..20d1eb7 --- /dev/null +++ b/benchmarks/results/hpc/ref/alpha_gp/16.json @@ -0,0 +1 @@ +{"problem": "alpha_gp", "part": "dynesty", "names": ["V", "W", "r", "a", "log_sigma_A", "log_sigma_B", "log_ell", "log_A_q", "p"], "result": {"wall_s": 2724.6785172251984, "calls": {"search": 0, "warmup": 0, "sampling": 1208306, "evidence": 0}, "min_ess": 7294.785129019966, "logz": -84.68381281074666, "logz_err": 0.23592999865689412, "mean": [158.4363255688864, 27.122474485645547, 1.294058583286062, 0.6079366902986453, -0.7225725457281809, -0.927812087338135, -3.705742905091299, 0.3732395133443839, 8.00935753084637], "sd": [19.02440802805679, 2.374281658178547, 0.02496746896599317, 0.017337788181584136, 0.10664130226507859, 0.7722263538053604, 0.2959703683648675, 0.23809916192720723, 3.3774639360211114], "mcse": [0.22274342840042322, 0.02779879593367564, 0.00029232655374951714, 0.00020299598151758385, 0.001248588089604578, 0.009041455865227973, 0.0034653091153901503, 0.0027877358154176856, 0.039544352460199675], "mode_share": 0.7737825532805336, "mode_share_label": "share in the deeper family", "seed": 3013, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/alpha_gp/17.json b/benchmarks/results/hpc/ref/alpha_gp/17.json new file mode 100644 index 0000000..dbd05aa --- /dev/null +++ b/benchmarks/results/hpc/ref/alpha_gp/17.json @@ -0,0 +1 @@ +{"problem": "alpha_gp", "part": "dynesty", "names": ["V", "W", "r", "a", "log_sigma_A", "log_sigma_B", "log_ell", "log_A_q", "p"], "result": {"wall_s": 5655.227152842097, "calls": {"search": 0, "warmup": 0, "sampling": 1215086, "evidence": 0}, "min_ess": 7116.821431984717, "logz": -84.59475259337496, "logz_err": 0.2318495493991218, "mean": [159.4361076772126, 27.318086703146246, 1.2926825155098831, 0.607962569664182, -0.7230544878020726, -0.9202604381852815, -3.7125013165110627, 0.3696464387958733, 8.032565301625526], "sd": [18.48958792436217, 2.3891832591227518, 0.024925457386213393, 0.016676005717332534, 0.10517075511211202, 0.7372023200010842, 0.2913945385189369, 0.23558498851021087, 3.4129822665421052], "mcse": [0.21917155940361316, 0.028320859434243135, 0.0002954609581637364, 0.00019767374982303303, 0.0012466712885042448, 0.008738636184406626, 0.0034541275700764305, 0.0027925732858454927, 0.040456750503849635], "mode_share": 0.7951815963513276, "mode_share_label": "share in the deeper family", "seed": 3014, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/alpha_gp/18.json b/benchmarks/results/hpc/ref/alpha_gp/18.json new file mode 100644 index 0000000..0ec77ed --- /dev/null +++ b/benchmarks/results/hpc/ref/alpha_gp/18.json @@ -0,0 +1 @@ +{"problem": "alpha_gp", "part": "dynesty", "names": ["V", "W", "r", "a", "log_sigma_A", "log_sigma_B", "log_ell", "log_A_q", "p"], "result": {"wall_s": 2791.7348075599875, "calls": {"search": 0, "warmup": 0, "sampling": 1233911, "evidence": 0}, "min_ess": 7035.621655609165, "logz": -84.72212122120276, "logz_err": 0.23866911548468148, "mean": [158.90815787851167, 27.259131686125784, 1.293588248420121, 0.6077544263540835, -0.7240603409065712, -0.9327995527177698, -3.717255687865592, 0.35984242804981303, 7.841435301852021], "sd": [19.133565580435416, 2.391146004912704, 0.02594498458356838, 0.01674481137835389, 0.10739101659151623, 0.7674238234602426, 0.28998315613891046, 0.23836863447709725, 3.371956388654496], "mcse": [0.22811018186918688, 0.028507219303345554, 0.0003093158526606598, 0.00019963147761582102, 0.0012803146503366032, 0.009149219323724136, 0.0034571763536580917, 0.002841828530803458, 0.04020043111344853], "mode_share": 0.7837920320960401, "mode_share_label": "share in the deeper family", "seed": 3015, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/alpha_gp/19.json b/benchmarks/results/hpc/ref/alpha_gp/19.json new file mode 100644 index 0000000..60e02a6 --- /dev/null +++ b/benchmarks/results/hpc/ref/alpha_gp/19.json @@ -0,0 +1 @@ +{"problem": "alpha_gp", "part": "dynesty", "names": ["V", "W", "r", "a", "log_sigma_A", "log_sigma_B", "log_ell", "log_A_q", "p"], "result": {"wall_s": 2662.824847020209, "calls": {"search": 0, "warmup": 0, "sampling": 1213059, "evidence": 0}, "min_ess": 6954.241074655679, "logz": -84.53754787096658, "logz_err": 0.23915838802686723, "mean": [155.65902820576855, 27.053865514549866, 1.2952513604608893, 0.6095459095312298, -0.7188957924452078, -0.9014855509084173, -3.7078559250895418, 0.3664551054444499, 8.127685150973287], "sd": [20.76699436667709, 2.460630449620805, 0.026107378314423325, 0.016928751474699032, 0.10495530003633355, 0.7660314240971486, 0.2844068755705314, 0.23357235991707903, 3.426033858269698], "mcse": [0.24902834032939364, 0.02950675991978357, 0.00031306779292167444, 0.0002030018792877263, 0.0012585761673225622, 0.009185900030346987, 0.0034104777490210547, 0.002800893384470884, 0.0410834380061388], "mode_share": 0.7110701495814729, "mode_share_label": "share in the deeper family", "seed": 3016, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/alpha_gp/2.json b/benchmarks/results/hpc/ref/alpha_gp/2.json new file mode 100644 index 0000000..70e6034 --- /dev/null +++ b/benchmarks/results/hpc/ref/alpha_gp/2.json @@ -0,0 +1 @@ +{"problem": "alpha_gp", "part": "pocomc", "names": ["V", "W", "r", "a", "log_sigma_A", "log_sigma_B", "log_ell", "log_A_q", "p"], "result": {"wall_s": 1778.2113279250334, "calls": {"search": 0, "warmup": 700416, "sampling": 0, "evidence": 4096}, "min_ess": 14994.241552153599, "logz": -84.52588741300796, "logz_err": 0.013892527125909937, "mean": [156.99278687415418, 27.071748497793408, 1.2951256470256431, 0.6084473300776139, -0.7216934326634947, -0.9277722600955896, -3.708462599215657, 0.3678788276084441, 7.9746994089807295], "sd": [20.069968743865562, 2.427796856847879, 0.025693968587523815, 0.01686801660700836, 0.10467165279680032, 0.7554457096046183, 0.28378202448329254, 0.23566802198365705, 3.346138285794625], "mcse": [0.163902072324767, 0.019826684390953458, 0.00020983065551757838, 0.0001377532228963881, 0.0008548045602860151, 0.006169372703726642, 0.002317515412949812, 0.0019245907991563974, 0.02732635044559371], "mode_share": 0.7425900037612424, "mode_share_label": "share in the deeper family", "seed": 2002}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/alpha_gp/20.json b/benchmarks/results/hpc/ref/alpha_gp/20.json new file mode 100644 index 0000000..55d95d8 --- /dev/null +++ b/benchmarks/results/hpc/ref/alpha_gp/20.json @@ -0,0 +1 @@ +{"problem": "alpha_gp", "part": "dynesty", "names": ["V", "W", "r", "a", "log_sigma_A", "log_sigma_B", "log_ell", "log_A_q", "p"], "result": {"wall_s": 2657.477834840771, "calls": {"search": 0, "warmup": 0, "sampling": 1205202, "evidence": 0}, "min_ess": 7103.398567687183, "logz": -84.49067148958065, "logz_err": 0.23630519764477265, "mean": [162.87289434749212, 27.562163538849614, 1.2896902662458951, 0.6069853178171145, -0.7213863229694062, -0.9478921087533881, -3.7173890508422374, 0.3712604347708056, 7.970890168843371], "sd": [15.681430990115018, 2.2355723847146978, 0.023841706750082996, 0.016368034993680395, 0.10753382804443266, 0.7639244886936757, 0.2883086795381806, 0.2329423578615634, 3.35462882141772], "mcse": [0.18605982129327786, 0.02652501539243472, 0.00028288130719979925, 0.00019420636214679765, 0.001275886418882392, 0.009063946647311773, 0.003420775911712975, 0.0027638557669053244, 0.03980259450886263], "mode_share": 0.869687654115215, "mode_share_label": "share in the deeper family", "seed": 3017, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/alpha_gp/21.json b/benchmarks/results/hpc/ref/alpha_gp/21.json new file mode 100644 index 0000000..69d420b --- /dev/null +++ b/benchmarks/results/hpc/ref/alpha_gp/21.json @@ -0,0 +1 @@ +{"problem": "alpha_gp", "part": "dynesty", "names": ["V", "W", "r", "a", "log_sigma_A", "log_sigma_B", "log_ell", "log_A_q", "p"], "result": {"wall_s": 2772.1560445260257, "calls": {"search": 0, "warmup": 0, "sampling": 1221466, "evidence": 0}, "min_ess": 7065.878548355543, "logz": -84.76937622756702, "logz_err": 0.239538051595605, "mean": [160.45248776501742, 27.451343664407545, 1.2913198959788585, 0.607927775489163, -0.7205990488822087, -0.9230105704226366, -3.7319431723356775, 0.36656857757757405, 8.146590818169635], "sd": [17.88424872458873, 2.321277403237323, 0.024920810655904842, 0.016370488863966127, 0.10531645561120542, 0.7602098020413204, 0.28828287544879616, 0.2371761150687841, 3.409337469292532], "mcse": [0.21275884157701597, 0.02761493081969166, 0.0002964688586007349, 0.0001947504924799109, 0.0012528905988670523, 0.009043788158427293, 0.003429539119675127, 0.0028215507550167986, 0.04055896905048635], "mode_share": 0.8182102396841809, "mode_share_label": "share in the deeper family", "seed": 3018, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/alpha_gp/22.json b/benchmarks/results/hpc/ref/alpha_gp/22.json new file mode 100644 index 0000000..d567715 --- /dev/null +++ b/benchmarks/results/hpc/ref/alpha_gp/22.json @@ -0,0 +1 @@ +{"problem": "alpha_gp", "part": "dynesty", "names": ["V", "W", "r", "a", "log_sigma_A", "log_sigma_B", "log_ell", "log_A_q", "p"], "result": {"wall_s": 2639.407041187864, "calls": {"search": 0, "warmup": 0, "sampling": 1200591, "evidence": 0}, "min_ess": 6799.985053214408, "logz": -84.46573777254066, "logz_err": 0.23492200029583196, "mean": [164.60256063825253, 27.713015008578004, 1.2883734247675516, 0.6063434373251843, -0.7265948916235251, -0.937881514684631, -3.719797462134813, 0.37581820082739303, 8.201032989915898], "sd": [13.579583572251558, 2.1606520864128087, 0.02307750371919603, 0.015841768580661098, 0.10330211383384788, 0.7529764160581467, 0.288344378960387, 0.23138549559386834, 3.3729443879902576], "mcse": [0.16467682045605164, 0.026201784009728706, 0.00027985614701068454, 0.00019210987335389266, 0.001252723514092752, 0.009131190320756594, 0.0034966930518104513, 0.0028059643737461232, 0.04090300372128593], "mode_share": 0.9083280695994057, "mode_share_label": "share in the deeper family", "seed": 3019, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/alpha_gp/23.json b/benchmarks/results/hpc/ref/alpha_gp/23.json new file mode 100644 index 0000000..5c0283b --- /dev/null +++ b/benchmarks/results/hpc/ref/alpha_gp/23.json @@ -0,0 +1 @@ +{"problem": "alpha_gp", "part": "dynesty", "names": ["V", "W", "r", "a", "log_sigma_A", "log_sigma_B", "log_ell", "log_A_q", "p"], "result": {"wall_s": 2616.0876129330136, "calls": {"search": 0, "warmup": 0, "sampling": 1198213, "evidence": 0}, "min_ess": 7211.3338223562005, "logz": -84.50026414841236, "logz_err": 0.22858285202275816, "mean": [146.55838074020497, 26.32895606447688, 1.3024245397484546, 0.6129995512360802, -0.7224867126448545, -0.8837401972498717, -3.699122678451525, 0.36705607651478855, 7.97405256799699], "sd": [22.84734863072531, 2.5878360122878257, 0.026858637241359277, 0.017005644654438344, 0.1067017663624111, 0.7494707890565813, 0.2869151480565618, 0.2441022764045477, 3.400163929762545], "mcse": [0.2690469100647498, 0.03047396413971647, 0.00031628323597337804, 0.00020025589060180233, 0.0012565038071704782, 0.008825654269060004, 0.003378669240052541, 0.0028745113609416712, 0.040039814413563676], "mode_share": 0.5071786542764218, "mode_share_label": "share in the deeper family", "seed": 3020, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/alpha_gp/24.json b/benchmarks/results/hpc/ref/alpha_gp/24.json new file mode 100644 index 0000000..b4f2b5a --- /dev/null +++ b/benchmarks/results/hpc/ref/alpha_gp/24.json @@ -0,0 +1 @@ +{"problem": "alpha_gp", "part": "dynesty", "names": ["V", "W", "r", "a", "log_sigma_A", "log_sigma_B", "log_ell", "log_A_q", "p"], "result": {"wall_s": 2591.661661247257, "calls": {"search": 0, "warmup": 0, "sampling": 1198729, "evidence": 0}, "min_ess": 7043.532644561265, "logz": -84.30704401259557, "logz_err": 0.23587012516629077, "mean": [163.72492191937937, 27.540286568433807, 1.2904416376485046, 0.6054901226946344, -0.7250171023069939, -0.961549592941256, -3.6999093627589628, 0.37129286447563337, 7.972728338275005], "sd": [14.727135239545376, 2.2564701683285797, 0.024786165989858496, 0.016469882132660832, 0.10462320127761035, 0.7706081603950512, 0.28814244172641246, 0.23389705880309952, 3.389897831205568], "mcse": [0.17547813462060188, 0.02688650369028308, 0.00029533443548599065, 0.00019624347485449725, 0.0012466161204884526, 0.009182022186258645, 0.0034333016813348147, 0.0027869520381534943, 0.04039162663333701], "mode_share": 0.8932163016391246, "mode_share_label": "share in the deeper family", "seed": 3021, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/alpha_gp/25.json b/benchmarks/results/hpc/ref/alpha_gp/25.json new file mode 100644 index 0000000..04b37aa --- /dev/null +++ b/benchmarks/results/hpc/ref/alpha_gp/25.json @@ -0,0 +1 @@ +{"problem": "alpha_gp", "part": "dynesty", "names": ["V", "W", "r", "a", "log_sigma_A", "log_sigma_B", "log_ell", "log_A_q", "p"], "result": {"wall_s": 2562.6737098312005, "calls": {"search": 0, "warmup": 0, "sampling": 1172709, "evidence": 0}, "min_ess": 6944.372174194503, "logz": -84.22419406647667, "logz_err": 0.23224760901652927, "mean": [160.21766525830947, 27.313514432388, 1.2925351109505705, 0.6073890343759074, -0.7256711509789673, -0.9322040878728046, -3.705073869424344, 0.3865559477192151, 8.105254817274268], "sd": [17.822194342007702, 2.244328412536697, 0.024129469546859544, 0.016636411221425205, 0.10649021450411267, 0.7532508909943384, 0.2822159477991818, 0.2291443137655243, 3.2613381289846717], "mcse": [0.21386744495725427, 0.026932081090757665, 0.0002895551412542495, 0.00019963797346761445, 0.0012778892235095498, 0.009039057726411632, 0.003386608995713687, 0.00274974607341171, 0.039136261192237114], "mode_share": 0.8134049287207986, "mode_share_label": "share in the deeper family", "seed": 3022, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/alpha_gp/26.json b/benchmarks/results/hpc/ref/alpha_gp/26.json new file mode 100644 index 0000000..a9f9484 --- /dev/null +++ b/benchmarks/results/hpc/ref/alpha_gp/26.json @@ -0,0 +1 @@ +{"problem": "alpha_gp", "part": "dynesty", "names": ["V", "W", "r", "a", "log_sigma_A", "log_sigma_B", "log_ell", "log_A_q", "p"], "result": {"wall_s": 2741.4676114018075, "calls": {"search": 0, "warmup": 0, "sampling": 1225166, "evidence": 0}, "min_ess": 7013.575246212276, "logz": -84.9828288881904, "logz_err": 0.23875739824540043, "mean": [154.22988987565546, 26.927461302211317, 1.2963887386832178, 0.610265399191069, -0.7231248241213648, -0.9126387114834102, -3.7158152774847664, 0.3738851388481331, 8.11069680858564], "sd": [21.33662109686993, 2.5339009386142095, 0.025908671020789493, 0.016979360175675237, 0.10650692509679446, 0.7561399977115059, 0.28659620248790174, 0.23309301117133088, 3.4119361147571983], "mcse": [0.2547744745437801, 0.03025658454778164, 0.00030936801171473446, 0.00020274567126665866, 0.0012717686532283353, 0.009028850900236727, 0.0034221630765055664, 0.0027832968102768254, 0.04074095082195249], "mode_share": 0.6777895412758969, "mode_share_label": "share in the deeper family", "seed": 3023, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/alpha_gp/27.json b/benchmarks/results/hpc/ref/alpha_gp/27.json new file mode 100644 index 0000000..687af9e --- /dev/null +++ b/benchmarks/results/hpc/ref/alpha_gp/27.json @@ -0,0 +1 @@ +{"problem": "alpha_gp", "part": "dynesty", "names": ["V", "W", "r", "a", "log_sigma_A", "log_sigma_B", "log_ell", "log_A_q", "p"], "result": {"wall_s": 2635.870913216844, "calls": {"search": 0, "warmup": 0, "sampling": 1210205, "evidence": 0}, "min_ess": 7177.1860924600605, "logz": -84.72469695690226, "logz_err": 0.23936774564758748, "mean": [153.62055618632968, 26.78417521683285, 1.2983997061220276, 0.6091171502671576, -0.7207140402042328, -0.9279144258263111, -3.7029138319680888, 0.358028228024975, 7.884837726452231], "sd": [21.418791790805358, 2.5061968492033784, 0.026676770150008116, 0.01775121332451289, 0.10555358799973781, 0.7723886301621866, 0.2955302296053888, 0.2428768988573913, 3.425730933348549], "mcse": [0.2528237482452328, 0.029582718177782238, 0.0003148880238565499, 0.00020953228045900532, 0.0012459364664202338, 0.009117143043681566, 0.0034883881919372845, 0.0028668772977971557, 0.040436740947293826], "mode_share": 0.6706497531359986, "mode_share_label": "share in the deeper family", "seed": 3024, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/alpha_gp/28.json b/benchmarks/results/hpc/ref/alpha_gp/28.json new file mode 100644 index 0000000..2535874 --- /dev/null +++ b/benchmarks/results/hpc/ref/alpha_gp/28.json @@ -0,0 +1 @@ +{"problem": "alpha_gp", "part": "dynesty", "names": ["V", "W", "r", "a", "log_sigma_A", "log_sigma_B", "log_ell", "log_A_q", "p"], "result": {"wall_s": 2658.734697677195, "calls": {"search": 0, "warmup": 0, "sampling": 1218539, "evidence": 0}, "min_ess": 7330.268722347528, "logz": -84.50728259179247, "logz_err": 0.22434070797818934, "mean": [155.3576330437849, 26.94617303566052, 1.296610789764296, 0.6091593571015939, -0.7206946249844651, -0.9254255865884787, -3.694660804017364, 0.37001508060250554, 8.07872917383517], "sd": [22.366650436309534, 2.4992487728774417, 0.02553909732559296, 0.0181570293768271, 0.10382835995910406, 0.7486266139364461, 0.286142680636899, 0.2346736304310194, 3.360642916891107], "mcse": [0.26124079840108916, 0.029191038089884578, 0.00029829473996473255, 0.00021207274037305464, 0.0012127074516423422, 0.008743902663743253, 0.003342125033834318, 0.002740970390361101, 0.03925205704133391], "mode_share": 0.6855985536856692, "mode_share_label": "share in the deeper family", "seed": 3025, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/alpha_gp/29.json b/benchmarks/results/hpc/ref/alpha_gp/29.json new file mode 100644 index 0000000..e5bc208 --- /dev/null +++ b/benchmarks/results/hpc/ref/alpha_gp/29.json @@ -0,0 +1 @@ +{"problem": "alpha_gp", "part": "dynesty", "names": ["V", "W", "r", "a", "log_sigma_A", "log_sigma_B", "log_ell", "log_A_q", "p"], "result": {"wall_s": 2727.274063028861, "calls": {"search": 0, "warmup": 0, "sampling": 1235509, "evidence": 0}, "min_ess": 7305.191752997547, "logz": -84.5659866724663, "logz_err": 0.22222493555329073, "mean": [154.54072461447373, 26.914751300759693, 1.2969848078603279, 0.6092677558957659, -0.721409660794297, -0.9437119118371886, -3.7100469076622793, 0.37070023394227325, 8.135548453703366], "sd": [21.38432766637463, 2.5286046684885575, 0.026908408569110236, 0.016581203914590684, 0.10492436403182637, 0.7505003562953333, 0.2849957169049016, 0.23777428798370717, 3.400264013507102], "mcse": [0.2501956705617172, 0.029584560734765356, 0.00031482716832305997, 0.00019399933899511305, 0.0012276103334538488, 0.008780820366654639, 0.0033344370517835297, 0.0027819484602250332, 0.03978293581256713], "mode_share": 0.6895252185289699, "mode_share_label": "share in the deeper family", "seed": 3026, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/alpha_gp/3.json b/benchmarks/results/hpc/ref/alpha_gp/3.json new file mode 100644 index 0000000..17c5f0a --- /dev/null +++ b/benchmarks/results/hpc/ref/alpha_gp/3.json @@ -0,0 +1 @@ +{"problem": "alpha_gp", "part": "dynesty", "names": ["V", "W", "r", "a", "log_sigma_A", "log_sigma_B", "log_ell", "log_A_q", "p"], "result": {"wall_s": 2693.0728099420667, "calls": {"search": 0, "warmup": 0, "sampling": 1223727, "evidence": 0}, "min_ess": 7180.74263136787, "logz": -85.01107970830559, "logz_err": 0.23611497500574624, "mean": [155.0363082727781, 26.96539502958844, 1.2956310782922478, 0.6100767794597716, -0.7187127856976515, -0.9237462379140806, -3.715516036567462, 0.3599844485481908, 7.936014178529925], "sd": [20.94112355426644, 2.477375170861742, 0.025896217223534412, 0.017472846296503423, 0.10737074155989607, 0.7614975431419349, 0.2960561666556353, 0.2387152145491169, 3.3654879919721172], "mcse": [0.24712421260115253, 0.029235269388978087, 0.00030559880295489335, 0.00020619540168104552, 0.0012670719360225193, 0.008986360271405928, 0.0034937307389881506, 0.0028170556025083433, 0.039715804545038286], "mode_share": 0.694953866005275, "mode_share_label": "share in the deeper family", "seed": 3000, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/alpha_gp/30.json b/benchmarks/results/hpc/ref/alpha_gp/30.json new file mode 100644 index 0000000..e2d4ce5 --- /dev/null +++ b/benchmarks/results/hpc/ref/alpha_gp/30.json @@ -0,0 +1 @@ +{"problem": "alpha_gp", "part": "dynesty", "names": ["V", "W", "r", "a", "log_sigma_A", "log_sigma_B", "log_ell", "log_A_q", "p"], "result": {"wall_s": 2653.8005257407203, "calls": {"search": 0, "warmup": 0, "sampling": 1204539, "evidence": 0}, "min_ess": 7089.6309831810095, "logz": -84.43234300513713, "logz_err": 0.23863017482663604, "mean": [158.3803404233768, 27.178685941151443, 1.2949186995599027, 0.6071124698220179, -0.723646901941957, -0.9389026817546344, -3.7168921264751167, 0.36057340121547043, 7.975897703914162], "sd": [19.138801814592295, 2.4569447853339894, 0.02611028455845442, 0.01711408357089224, 0.10656539004901021, 0.7563270654057285, 0.28594727783815826, 0.24152687275029433, 3.424021606875366], "mcse": [0.22730182880353872, 0.029179885365129395, 0.0003100985886270287, 0.00020325527855115993, 0.0012656230144373042, 0.008982512427149971, 0.0033960505899826394, 0.002868491999299747, 0.04066536560884397], "mode_share": 0.777800094931181, "mode_share_label": "share in the deeper family", "seed": 3027, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/alpha_gp/31.json b/benchmarks/results/hpc/ref/alpha_gp/31.json new file mode 100644 index 0000000..dee716f --- /dev/null +++ b/benchmarks/results/hpc/ref/alpha_gp/31.json @@ -0,0 +1 @@ +{"problem": "alpha_gp", "part": "dynesty", "names": ["V", "W", "r", "a", "log_sigma_A", "log_sigma_B", "log_ell", "log_A_q", "p"], "result": {"wall_s": 2659.12876476394, "calls": {"search": 0, "warmup": 0, "sampling": 1201973, "evidence": 0}, "min_ess": 7275.055499126329, "logz": -84.06077143325636, "logz_err": 0.22574277783005617, "mean": [163.6297554708925, 27.696209654765973, 1.2890011679086453, 0.6067998429217873, -0.7225732505197283, -0.9365985993968523, -3.712197347207983, 0.3692444518973431, 8.05133841367845], "sd": [14.847590009878896, 2.1579149531552937, 0.02319226106022582, 0.01575061636979743, 0.10477785710033082, 0.7659724876929488, 0.2898552173731284, 0.23408042679005098, 3.363454982587375], "mcse": [0.17407556417044873, 0.02529974646743489, 0.0002719098470365204, 0.00018466279233064276, 0.0012284326665253542, 0.008980386234094277, 0.0033983097902355753, 0.002744397058891438, 0.03943369417301008], "mode_share": 0.8873748837963811, "mode_share_label": "share in the deeper family", "seed": 3028, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/alpha_gp/32.json b/benchmarks/results/hpc/ref/alpha_gp/32.json new file mode 100644 index 0000000..dbd8230 --- /dev/null +++ b/benchmarks/results/hpc/ref/alpha_gp/32.json @@ -0,0 +1 @@ +{"problem": "alpha_gp", "part": "dynesty", "names": ["V", "W", "r", "a", "log_sigma_A", "log_sigma_B", "log_ell", "log_A_q", "p"], "result": {"wall_s": 2633.308246606961, "calls": {"search": 0, "warmup": 0, "sampling": 1199633, "evidence": 0}, "min_ess": 7091.847446264214, "logz": -84.5774665986919, "logz_err": 0.23101144709837396, "mean": [157.64167454846213, 27.16640705731838, 1.2946400716449256, 0.6080855957317933, -0.7189055134903761, -0.9177480335414973, -3.7097871208263427, 0.37054039834703895, 8.154966941504673], "sd": [19.57786160190162, 2.438559962025036, 0.025529856372291625, 0.017037402397691987, 0.10612861083521659, 0.7678025140092074, 0.2915458336624528, 0.2369307056137222, 3.445883729019674], "mcse": [0.23247998111575247, 0.028957012029656254, 0.00030315775277223015, 0.00020231295267161283, 0.0012602386279212281, 0.009117375410404884, 0.0034620006659787563, 0.002813465897698955, 0.040918615144963574], "mode_share": 0.7583224350931193, "mode_share_label": "share in the deeper family", "seed": 3029, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/alpha_gp/33.json b/benchmarks/results/hpc/ref/alpha_gp/33.json new file mode 100644 index 0000000..244f437 --- /dev/null +++ b/benchmarks/results/hpc/ref/alpha_gp/33.json @@ -0,0 +1 @@ +{"problem": "alpha_gp", "part": "dynesty", "names": ["V", "W", "r", "a", "log_sigma_A", "log_sigma_B", "log_ell", "log_A_q", "p"], "result": {"wall_s": 2675.2336292089894, "calls": {"search": 0, "warmup": 0, "sampling": 1203228, "evidence": 0}, "min_ess": 6969.933347532352, "logz": -84.45700670817473, "logz_err": 0.23443255365848842, "mean": [160.7431706871559, 27.42808702025613, 1.2915181033677408, 0.6077355350387634, -0.7248430749634354, -0.933013592378232, -3.7345306991035634, 0.36556313698926457, 7.952697011716893], "sd": [17.63030498064033, 2.304080797800829, 0.025021653964747925, 0.016769433181065434, 0.10598101000185044, 0.766779293068402, 0.2929550925746424, 0.2402676045627046, 3.3831325455230994], "mcse": [0.21117646347212796, 0.02759836741156285, 0.0002997103226688993, 0.0002008649083211115, 0.001269444567860342, 0.009184511530098464, 0.0035090272388365634, 0.002877934503923077, 0.04052329027804928], "mode_share": 0.8228406394949976, "mode_share_label": "share in the deeper family", "seed": 3030, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/alpha_gp/34.json b/benchmarks/results/hpc/ref/alpha_gp/34.json new file mode 100644 index 0000000..f764fdd --- /dev/null +++ b/benchmarks/results/hpc/ref/alpha_gp/34.json @@ -0,0 +1 @@ +{"problem": "alpha_gp", "part": "dynesty", "names": ["V", "W", "r", "a", "log_sigma_A", "log_sigma_B", "log_ell", "log_A_q", "p"], "result": {"wall_s": 2595.760058631975, "calls": {"search": 0, "warmup": 0, "sampling": 1186323, "evidence": 0}, "min_ess": 7183.117328522444, "logz": -84.57010470850983, "logz_err": 0.23267183873739863, "mean": [153.75434981953427, 26.847094001202066, 1.2970580230285036, 0.6101631617186526, -0.7221286693512192, -0.8999063715191188, -3.7100628039203403, 0.36973945029726707, 8.044145282950854], "sd": [21.40052061912164, 2.506002759950248, 0.026184786621634662, 0.017407823430158783, 0.10675487987423898, 0.7442607833307798, 0.2903581217296295, 0.23608917536402632, 3.412200063287317], "mcse": [0.25250376528958135, 0.02956821209985554, 0.0003089531013259237, 0.00020539411352842583, 0.001259595951474038, 0.008781498987481571, 0.0034259222158190303, 0.002785605396452999, 0.040260392690239066], "mode_share": 0.6681328808597061, "mode_share_label": "share in the deeper family", "seed": 3031, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/alpha_gp/35.json b/benchmarks/results/hpc/ref/alpha_gp/35.json new file mode 100644 index 0000000..2995594 --- /dev/null +++ b/benchmarks/results/hpc/ref/alpha_gp/35.json @@ -0,0 +1 @@ +{"problem": "alpha_gp", "part": "dynesty", "names": ["V", "W", "r", "a", "log_sigma_A", "log_sigma_B", "log_ell", "log_A_q", "p"], "result": {"wall_s": 2730.162583360914, "calls": {"search": 0, "warmup": 0, "sampling": 1190503, "evidence": 0}, "min_ess": 7250.572747881922, "logz": -84.45575317152658, "logz_err": 0.23923244022830606, "mean": [149.03798151917238, 26.455418414041556, 1.3005999607591705, 0.6121402268768293, -0.7231471882544115, -0.9094091710263917, -3.6982600263933185, 0.3652972118228499, 7.870029492993725], "sd": [22.71925749146818, 2.545996080535587, 0.027053045572032752, 0.017490092568823574, 0.10528824661031994, 0.7497468714678474, 0.29362797520742995, 0.24157801532565046, 3.4003301858691457], "mcse": [0.26681360853659597, 0.029900026522558288, 0.0003177093579616181, 0.00020540260673921132, 0.001236498905175051, 0.008804982660216, 0.0034483494745287877, 0.0028370778418419403, 0.03993327543597604], "mode_share": 0.5597929569866532, "mode_share_label": "share in the deeper family", "seed": 3032, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/alpha_gp/36.json b/benchmarks/results/hpc/ref/alpha_gp/36.json new file mode 100644 index 0000000..46871df --- /dev/null +++ b/benchmarks/results/hpc/ref/alpha_gp/36.json @@ -0,0 +1 @@ +{"problem": "alpha_gp", "part": "dynesty", "names": ["V", "W", "r", "a", "log_sigma_A", "log_sigma_B", "log_ell", "log_A_q", "p"], "result": {"wall_s": 2630.8231329726987, "calls": {"search": 0, "warmup": 0, "sampling": 1201433, "evidence": 0}, "min_ess": 7147.05445861145, "logz": -84.66227727378664, "logz_err": 0.2399338752532776, "mean": [154.76170946609395, 26.933452806987667, 1.2964610453797614, 0.6095301765887766, -0.7228158011095016, -0.897947155843875, -3.702402865162996, 0.36264667643483434, 7.862600504409481], "sd": [21.138259037081617, 2.501495525198889, 0.026430060242874233, 0.017442835577214866, 0.10709091146380821, 0.7601380179300004, 0.2896228202076251, 0.23873821548248228, 3.35180161088544], "mcse": [0.2500378005356032, 0.029589401760720262, 0.00031263284831351684, 0.0002063258017218958, 0.0012667446222884618, 0.008991432916650955, 0.003425857012282644, 0.0028239590686403165, 0.039647404317796335], "mode_share": 0.6920954009842146, "mode_share_label": "share in the deeper family", "seed": 3033, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/alpha_gp/37.json b/benchmarks/results/hpc/ref/alpha_gp/37.json new file mode 100644 index 0000000..876795b --- /dev/null +++ b/benchmarks/results/hpc/ref/alpha_gp/37.json @@ -0,0 +1 @@ +{"problem": "alpha_gp", "part": "dynesty", "names": ["V", "W", "r", "a", "log_sigma_A", "log_sigma_B", "log_ell", "log_A_q", "p"], "result": {"wall_s": 2635.6637302399613, "calls": {"search": 0, "warmup": 0, "sampling": 1210947, "evidence": 0}, "min_ess": 7219.24704608767, "logz": -84.538016278866, "logz_err": 0.22305673931890616, "mean": [153.28389951446871, 26.887407627991827, 1.2970347334827752, 0.6106345585880676, -0.7214049597725186, -0.8891162637212283, -3.7093336596393343, 0.36463321154245165, 7.903040529290636], "sd": [21.67796543248705, 2.55847331753451, 0.026227917070369065, 0.017127208998702854, 0.10482707688282172, 0.7561582183450484, 0.2912619321962309, 0.24042097773290108, 3.348861527359169], "mcse": [0.25513648472395917, 0.03011167678667672, 0.0003086866516050979, 0.00020157684588393014, 0.0012337510170438047, 0.00889952289685675, 0.0034279760130574654, 0.0028296088626815507, 0.03941406589002493], "mode_share": 0.6557272974482112, "mode_share_label": "share in the deeper family", "seed": 3034, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/alpha_gp/38.json b/benchmarks/results/hpc/ref/alpha_gp/38.json new file mode 100644 index 0000000..ae1d00d --- /dev/null +++ b/benchmarks/results/hpc/ref/alpha_gp/38.json @@ -0,0 +1 @@ +{"problem": "alpha_gp", "part": "dynesty", "names": ["V", "W", "r", "a", "log_sigma_A", "log_sigma_B", "log_ell", "log_A_q", "p"], "result": {"wall_s": 2638.0561971752904, "calls": {"search": 0, "warmup": 0, "sampling": 1204487, "evidence": 0}, "min_ess": 7077.6397966084805, "logz": -84.56604170922252, "logz_err": 0.23414546453001328, "mean": [161.22881519866397, 27.445460420780066, 1.2907668574798206, 0.6079040901752887, -0.7260971082813036, -0.9366622530485578, -3.71394679074058, 0.3719841112357928, 8.083558748223851], "sd": [17.336464418930852, 2.3244154102401833, 0.0241982971970979, 0.01650693198865165, 0.10805646659483781, 0.7715536202234763, 0.2871702172550281, 0.2389168513763518, 3.381865836620472], "mcse": [0.2060707275761844, 0.027629276835387725, 0.0002876342366593241, 0.0001962104499944987, 0.0012844184461391537, 0.009171109635819049, 0.003413462755608625, 0.0028398967750064576, 0.04019871276385664], "mode_share": 0.8296838448902183, "mode_share_label": "share in the deeper family", "seed": 3035, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/alpha_gp/39.json b/benchmarks/results/hpc/ref/alpha_gp/39.json new file mode 100644 index 0000000..1af22b0 --- /dev/null +++ b/benchmarks/results/hpc/ref/alpha_gp/39.json @@ -0,0 +1 @@ +{"problem": "alpha_gp", "part": "dynesty", "names": ["V", "W", "r", "a", "log_sigma_A", "log_sigma_B", "log_ell", "log_A_q", "p"], "result": {"wall_s": 2563.6894302037545, "calls": {"search": 0, "warmup": 0, "sampling": 1204799, "evidence": 0}, "min_ess": 7215.32816977893, "logz": -84.23020409136946, "logz_err": 0.22549878358431863, "mean": [156.62370269123633, 26.941412734278856, 1.2956426893627624, 0.6085028759730736, -0.7289882479461661, -0.929254457750406, -3.6933064634695416, 0.38343648346970316, 8.057129699814956], "sd": [20.41557891793273, 2.4769450491699505, 0.026230308649734514, 0.01660620193796169, 0.10478418635023572, 0.7460661485530546, 0.2874101976889709, 0.23261240961728225, 3.4098735531843705], "mcse": [0.24034420504277562, 0.029160054249280736, 0.0003087986241188331, 0.00019549797826469615, 0.00123358108386924, 0.00878312959451783, 0.0033835619240787825, 0.0027384501266061235, 0.04014303741916463], "mode_share": 0.7325510521567073, "mode_share_label": "share in the deeper family", "seed": 3036, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/alpha_gp/4.json b/benchmarks/results/hpc/ref/alpha_gp/4.json new file mode 100644 index 0000000..e210a88 --- /dev/null +++ b/benchmarks/results/hpc/ref/alpha_gp/4.json @@ -0,0 +1 @@ +{"problem": "alpha_gp", "part": "dynesty", "names": ["V", "W", "r", "a", "log_sigma_A", "log_sigma_B", "log_ell", "log_A_q", "p"], "result": {"wall_s": 2636.1515113138594, "calls": {"search": 0, "warmup": 0, "sampling": 1198485, "evidence": 0}, "min_ess": 7087.338101231971, "logz": -84.74751070345754, "logz_err": 0.24083548954130415, "mean": [148.75030343708653, 26.451619379396192, 1.3002841100864992, 0.6126134761458646, -0.7193340209575875, -0.8920772452925648, -3.6971926192482827, 0.3710694794025508, 7.966812618096597], "sd": [22.717944614091152, 2.576690930978656, 0.026778478536716104, 0.017317696364374514, 0.10620310818411594, 0.7580134725131048, 0.2983931036008246, 0.23684614176087893, 3.3405251605008126], "mcse": [0.26985313062663063, 0.03060699927715071, 0.0003180858299156465, 0.00020570675114108856, 0.001261524390194441, 0.009003997152451374, 0.003544436547051614, 0.0028133563100320486, 0.03968013778583795], "mode_share": 0.5538147037815653, "mode_share_label": "share in the deeper family", "seed": 3001, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/alpha_gp/40.json b/benchmarks/results/hpc/ref/alpha_gp/40.json new file mode 100644 index 0000000..462f694 --- /dev/null +++ b/benchmarks/results/hpc/ref/alpha_gp/40.json @@ -0,0 +1 @@ +{"problem": "alpha_gp", "part": "dynesty", "names": ["V", "W", "r", "a", "log_sigma_A", "log_sigma_B", "log_ell", "log_A_q", "p"], "result": {"wall_s": 2675.513078021817, "calls": {"search": 0, "warmup": 0, "sampling": 1200123, "evidence": 0}, "min_ess": 7350.059425096377, "logz": -84.58925162298434, "logz_err": 0.22852313866078616, "mean": [144.0678362845529, 26.042817129909295, 1.3051391452179817, 0.613197046824574, -0.7172387281205835, -0.887856046216102, -3.6840650052984323, 0.37065602971907996, 7.931022108757693], "sd": [22.590509280805485, 2.533759537624829, 0.02677302057310649, 0.01791534871054794, 0.10643039505484748, 0.7681380495412262, 0.29080458363127354, 0.2319018822700051, 3.364395131797485], "mcse": [0.2634999860714468, 0.029554251945962878, 0.0003122855912813922, 0.00020896802621911384, 0.0012414243196526532, 0.008959707939255653, 0.003391999834260543, 0.0027049475506959377, 0.0392429431026918], "mode_share": 0.4555256814404153, "mode_share_label": "share in the deeper family", "seed": 3037, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/alpha_gp/41.json b/benchmarks/results/hpc/ref/alpha_gp/41.json new file mode 100644 index 0000000..23a23e8 --- /dev/null +++ b/benchmarks/results/hpc/ref/alpha_gp/41.json @@ -0,0 +1 @@ +{"problem": "alpha_gp", "part": "dynesty", "names": ["V", "W", "r", "a", "log_sigma_A", "log_sigma_B", "log_ell", "log_A_q", "p"], "result": {"wall_s": 5171.534605517983, "calls": {"search": 0, "warmup": 0, "sampling": 1168755, "evidence": 0}, "min_ess": 7134.830746361095, "logz": -83.66049572685058, "logz_err": 0.22072009714833773, "mean": [160.27652466713585, 27.309445100001238, 1.2920865547809488, 0.60780558908447, -0.7255385524811129, -0.9235242371818891, -3.708693392034448, 0.37155038164157567, 8.102861877766559], "sd": [18.02566189655809, 2.3284372838368714, 0.02420522059367362, 0.01597106003692982, 0.10548892295118917, 0.7502933297181419, 0.28615254761972064, 0.23941708291174113, 3.306297583262367], "mcse": [0.21340244123051216, 0.027565933693553344, 0.0002865610813547621, 0.00018907839392963915, 0.0012488636372825592, 0.00888258246047509, 0.0033877065140137212, 0.0028344140847005065, 0.03914263896392382], "mode_share": 0.8125753564056867, "mode_share_label": "share in the deeper family", "seed": 3038, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/alpha_gp/42.json b/benchmarks/results/hpc/ref/alpha_gp/42.json new file mode 100644 index 0000000..506c5ac --- /dev/null +++ b/benchmarks/results/hpc/ref/alpha_gp/42.json @@ -0,0 +1 @@ +{"problem": "alpha_gp", "part": "dynesty", "names": ["V", "W", "r", "a", "log_sigma_A", "log_sigma_B", "log_ell", "log_A_q", "p"], "result": {"wall_s": 5347.867223539855, "calls": {"search": 0, "warmup": 0, "sampling": 1179523, "evidence": 0}, "min_ess": 6867.59884165956, "logz": -84.12118215125084, "logz_err": 0.23500739564790626, "mean": [163.31062249099344, 27.632804803708332, 1.2900350824576994, 0.6061498614794507, -0.7254210238036592, -0.94613701416777, -3.727731680550379, 0.376318406376312, 8.285420956916427], "sd": [14.827421348508633, 2.1329609716153604, 0.023179041519020196, 0.016092975005376212, 0.10324307968399776, 0.7542578955225954, 0.2850310725319668, 0.23537433850876063, 3.423531001161995], "mcse": [0.17892176334269244, 0.02573833502215462, 0.0002797003527247649, 0.00019419313700702248, 0.0012458291590836173, 0.009101592887263898, 0.0034394559179373326, 0.0028402505534681597, 0.04131158002385142], "mode_share": 0.8847651240395688, "mode_share_label": "share in the deeper family", "seed": 3039, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/alpha_gp/43.json b/benchmarks/results/hpc/ref/alpha_gp/43.json new file mode 100644 index 0000000..2c603c8 --- /dev/null +++ b/benchmarks/results/hpc/ref/alpha_gp/43.json @@ -0,0 +1 @@ +{"problem": "alpha_gp", "part": "dynesty", "names": ["V", "W", "r", "a", "log_sigma_A", "log_sigma_B", "log_ell", "log_A_q", "p"], "result": {"wall_s": 2605.9408513358794, "calls": {"search": 0, "warmup": 0, "sampling": 1200935, "evidence": 0}, "min_ess": 6877.163644938911, "logz": -84.55008217982956, "logz_err": 0.23549613895250002, "mean": [158.56315171322035, 27.147572583981976, 1.2933606438312146, 0.6085096888671061, -0.725880662681902, -0.8977815210334394, -3.712819602213269, 0.3802065787537221, 8.236970018930856], "sd": [19.175793068410947, 2.3999625545126433, 0.024761788932468075, 0.016472463668614944, 0.10489514307956178, 0.7643867857461637, 0.28827540262032303, 0.2316994704268894, 3.3194083511573456], "mcse": [0.23123238311652305, 0.028940083932411993, 0.00029859142955162356, 0.0001986341329563491, 0.0012648840037595222, 0.009217401202666998, 0.0034761852145547955, 0.0027939611427025973, 0.04002727297049451], "mode_share": 0.7728373130219467, "mode_share_label": "share in the deeper family", "seed": 3040, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/alpha_gp/44.json b/benchmarks/results/hpc/ref/alpha_gp/44.json new file mode 100644 index 0000000..092bfe0 --- /dev/null +++ b/benchmarks/results/hpc/ref/alpha_gp/44.json @@ -0,0 +1 @@ +{"problem": "alpha_gp", "part": "dynesty", "names": ["V", "W", "r", "a", "log_sigma_A", "log_sigma_B", "log_ell", "log_A_q", "p"], "result": {"wall_s": 2798.990286985878, "calls": {"search": 0, "warmup": 0, "sampling": 1218258, "evidence": 0}, "min_ess": 7267.458057469762, "logz": -84.39098412612533, "logz_err": 0.22038611360580618, "mean": [159.49022440637222, 27.274611389524853, 1.2928980806458787, 0.6077603424729481, -0.7278807084591835, -0.9521992707937945, -3.717544061583465, 0.37216970691513385, 8.115912257671551], "sd": [18.46102562963265, 2.4054051456757337, 0.024946564389653605, 0.01658586326967642, 0.1063334199978835, 0.7627919816063206, 0.28671829285339523, 0.23020785612306655, 3.401715099267042], "mcse": [0.216553176343189, 0.028216098885221932, 0.0002926304239975682, 0.0001945569788753784, 0.001247321807246429, 0.008947770823784456, 0.0033632885993850874, 0.0027004048129690996, 0.03990310313953682], "mode_share": 0.7971209446463361, "mode_share_label": "share in the deeper family", "seed": 3041, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/alpha_gp/45.json b/benchmarks/results/hpc/ref/alpha_gp/45.json new file mode 100644 index 0000000..3deb170 --- /dev/null +++ b/benchmarks/results/hpc/ref/alpha_gp/45.json @@ -0,0 +1 @@ +{"problem": "alpha_gp", "part": "dynesty", "names": ["V", "W", "r", "a", "log_sigma_A", "log_sigma_B", "log_ell", "log_A_q", "p"], "result": {"wall_s": 2697.9971779710613, "calls": {"search": 0, "warmup": 0, "sampling": 1200182, "evidence": 0}, "min_ess": 7161.469129474587, "logz": -84.39147338666402, "logz_err": 0.23226489450500332, "mean": [155.1489394960966, 26.835128773823374, 1.2970303072589282, 0.6088231857040185, -0.7235902314526594, -0.9567653373431511, -3.6937466971535073, 0.37458497295120907, 7.929556278971399], "sd": [21.192291270092298, 2.497294990592225, 0.02723034868481024, 0.01700375320855362, 0.10636206405893042, 0.7546259219421391, 0.28708658330759795, 0.23575464664131215, 3.353583212078727], "mcse": [0.2504245212899227, 0.0295099710818601, 0.0003217748825288575, 0.0002009295126758364, 0.001256856497294157, 0.008917244145375685, 0.003392437338525294, 0.0027858594323089615, 0.03962853566834158], "mode_share": 0.7010442666292129, "mode_share_label": "share in the deeper family", "seed": 3042, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/alpha_gp/46.json b/benchmarks/results/hpc/ref/alpha_gp/46.json new file mode 100644 index 0000000..9254fd8 --- /dev/null +++ b/benchmarks/results/hpc/ref/alpha_gp/46.json @@ -0,0 +1 @@ +{"problem": "alpha_gp", "part": "dynesty", "names": ["V", "W", "r", "a", "log_sigma_A", "log_sigma_B", "log_ell", "log_A_q", "p"], "result": {"wall_s": 5709.132166139316, "calls": {"search": 0, "warmup": 0, "sampling": 1243517, "evidence": 0}, "min_ess": 7518.760567127312, "logz": -84.77663594255115, "logz_err": 0.2158876064641667, "mean": [149.93253931500712, 26.55725959509663, 1.3001898998640113, 0.6113434663412065, -0.7148848083179139, -0.9048699716298392, -3.69828932639993, 0.37042948275738197, 8.055609871265634], "sd": [22.525497943559138, 2.6290377335851893, 0.02735328183694533, 0.01747535092349906, 0.10774020872855931, 0.7545372928091905, 0.29794432367429413, 0.2379148460821288, 3.4348246199006707], "mcse": [0.25977734426601906, 0.030319615669193174, 0.00031545419907547, 0.00020153606656768161, 0.001242523710876484, 0.008701769637536027, 0.0034360698856548285, 0.002743774500858321, 0.039612425883463004], "mode_share": 0.5847271447575885, "mode_share_label": "share in the deeper family", "seed": 3043, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/alpha_gp/47.json b/benchmarks/results/hpc/ref/alpha_gp/47.json new file mode 100644 index 0000000..35b63fb --- /dev/null +++ b/benchmarks/results/hpc/ref/alpha_gp/47.json @@ -0,0 +1 @@ +{"problem": "alpha_gp", "part": "dynesty", "names": ["V", "W", "r", "a", "log_sigma_A", "log_sigma_B", "log_ell", "log_A_q", "p"], "result": {"wall_s": 2567.3886513290927, "calls": {"search": 0, "warmup": 0, "sampling": 1190913, "evidence": 0}, "min_ess": 7119.821503919217, "logz": -84.35656510212708, "logz_err": 0.22724282530756537, "mean": [158.22715477362885, 27.09961032335545, 1.294106991351419, 0.6081377843234732, -0.7239676569237445, -0.9420536806653654, -3.703566989447918, 0.38365274926727955, 8.241930916842687], "sd": [19.52767879400126, 2.4713365353330063, 0.026178331826003938, 0.01679410532691444, 0.10694529605102517, 0.7580293669009169, 0.29622537525374043, 0.23091893915589268, 3.4213837989703073], "mcse": [0.23142808938036596, 0.02928851394072014, 0.00031024687478567133, 0.00019903173078893405, 0.001267439197172241, 0.008983622166602721, 0.0035106513858684817, 0.002736686190629369, 0.040547794952253725], "mode_share": 0.76773124415442, "mode_share_label": "share in the deeper family", "seed": 3044, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/alpha_gp/48.json b/benchmarks/results/hpc/ref/alpha_gp/48.json new file mode 100644 index 0000000..825e8f4 --- /dev/null +++ b/benchmarks/results/hpc/ref/alpha_gp/48.json @@ -0,0 +1 @@ +{"problem": "alpha_gp", "part": "dynesty", "names": ["V", "W", "r", "a", "log_sigma_A", "log_sigma_B", "log_ell", "log_A_q", "p"], "result": {"wall_s": 2743.050127318129, "calls": {"search": 0, "warmup": 0, "sampling": 1259047, "evidence": 0}, "min_ess": 7253.033061708689, "logz": -85.29352359091388, "logz_err": 0.23948222609283032, "mean": [156.1724997966866, 27.03568153399806, 1.2948828457345942, 0.6094907964780742, -0.7235386506243842, -0.9266478532817944, -3.7053849470841413, 0.37376400770840446, 8.10223384365531], "sd": [20.43649892623883, 2.4236219958318994, 0.02527543199046779, 0.0171517567944592, 0.10568614440071038, 0.7578829126318118, 0.2918145796289204, 0.23865665192698515, 3.429629655512064], "mcse": [0.23996431802340784, 0.028458044671713634, 0.00029678282088486273, 0.00020139504505839714, 0.0012409612652918007, 0.00889902213327679, 0.003426471767139855, 0.002802294117407747, 0.04027053480775789], "mode_share": 0.7212459145477795, "mode_share_label": "share in the deeper family", "seed": 3045, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/alpha_gp/49.json b/benchmarks/results/hpc/ref/alpha_gp/49.json new file mode 100644 index 0000000..cc62a5b --- /dev/null +++ b/benchmarks/results/hpc/ref/alpha_gp/49.json @@ -0,0 +1 @@ +{"problem": "alpha_gp", "part": "dynesty", "names": ["V", "W", "r", "a", "log_sigma_A", "log_sigma_B", "log_ell", "log_A_q", "p"], "result": {"wall_s": 2602.4534906758927, "calls": {"search": 0, "warmup": 0, "sampling": 1187367, "evidence": 0}, "min_ess": 7101.711156119568, "logz": -83.91278215246038, "logz_err": 0.2321352869721951, "mean": [163.99106633599428, 27.68615895572654, 1.2885229100407207, 0.6068741520750033, -0.7242133263890064, -0.9214189691458405, -3.7152368033207672, 0.3785014331330474, 8.17956522418655], "sd": [14.438614027503148, 2.2030542662845987, 0.022685857335890958, 0.0157520803718874, 0.10527373462729434, 0.7670586568195835, 0.28981535876978853, 0.23094288734855653, 3.429251243417513], "mcse": [0.1713341777741029, 0.026142293892378165, 0.0002691991562584645, 0.00018692027736235743, 0.001249218846713343, 0.009102214659963314, 0.0034390611250181874, 0.0027404576118781896, 0.040692821419879975], "mode_share": 0.8926953637031425, "mode_share_label": "share in the deeper family", "seed": 3046, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/alpha_gp/5.json b/benchmarks/results/hpc/ref/alpha_gp/5.json new file mode 100644 index 0000000..bf3a2a9 --- /dev/null +++ b/benchmarks/results/hpc/ref/alpha_gp/5.json @@ -0,0 +1 @@ +{"problem": "alpha_gp", "part": "dynesty", "names": ["V", "W", "r", "a", "log_sigma_A", "log_sigma_B", "log_ell", "log_A_q", "p"], "result": {"wall_s": 2748.1917490730993, "calls": {"search": 0, "warmup": 0, "sampling": 1223425, "evidence": 0}, "min_ess": 7240.245083984671, "logz": -84.96554847346898, "logz_err": 0.23441027840668432, "mean": [159.62198959223858, 27.321985375758146, 1.2930118520546583, 0.6074286498983196, -0.7211987452398998, -0.8981363214501887, -3.7165815372794855, 0.36229233802144495, 8.006574912874683], "sd": [18.250330092532945, 2.356832851685547, 0.02475406477745071, 0.016684462868590967, 0.10694245590346353, 0.7762582246018198, 0.2896553926023016, 0.23831390376500267, 3.3513333656815933], "mcse": [0.21448359988150806, 0.02769823843105943, 0.00029091752851856455, 0.0001960810374388182, 0.0012568212632893168, 0.009122829976557367, 0.0034041209674257862, 0.002800739697428614, 0.039385920201437635], "mode_share": 0.8027537260999038, "mode_share_label": "share in the deeper family", "seed": 3002, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/alpha_gp/50.json b/benchmarks/results/hpc/ref/alpha_gp/50.json new file mode 100644 index 0000000..8cf707a --- /dev/null +++ b/benchmarks/results/hpc/ref/alpha_gp/50.json @@ -0,0 +1 @@ +{"problem": "alpha_gp", "part": "dynesty", "names": ["V", "W", "r", "a", "log_sigma_A", "log_sigma_B", "log_ell", "log_A_q", "p"], "result": {"wall_s": 2670.7196222217754, "calls": {"search": 0, "warmup": 0, "sampling": 1214645, "evidence": 0}, "min_ess": 7322.3315260850895, "logz": -84.51864440685225, "logz_err": 0.23359807008680755, "mean": [155.2545418450634, 26.941835937145164, 1.2967601987637225, 0.6088248034942918, -0.7223923421183592, -0.9664914663757967, -3.7131477803189106, 0.37330328357598647, 7.916336733928793], "sd": [20.8029945659277, 2.549482847907821, 0.026845598320402966, 0.017555517329534098, 0.10590247395134182, 0.7612729830662024, 0.2952829674358481, 0.24078058448393724, 3.3994455558168704], "mcse": [0.2431090697814317, 0.02979390306594285, 0.0003137244695573033, 0.0002051582272921924, 0.00123760316565342, 0.00889642912593372, 0.0034507516361709225, 0.0028138229681217543, 0.03972678280658902], "mode_share": 0.7053345320063371, "mode_share_label": "share in the deeper family", "seed": 3047, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/alpha_gp/51.json b/benchmarks/results/hpc/ref/alpha_gp/51.json new file mode 100644 index 0000000..0465dbf --- /dev/null +++ b/benchmarks/results/hpc/ref/alpha_gp/51.json @@ -0,0 +1 @@ +{"problem": "alpha_gp", "part": "dynesty", "names": ["V", "W", "r", "a", "log_sigma_A", "log_sigma_B", "log_ell", "log_A_q", "p"], "result": {"wall_s": 2860.4783395826817, "calls": {"search": 0, "warmup": 0, "sampling": 1173229, "evidence": 0}, "min_ess": 7257.46272996631, "logz": -84.02451828037454, "logz_err": 0.2322909116621228, "mean": [156.46253756920711, 27.029547465803336, 1.2955968552047408, 0.6084526678530948, -0.7260215512623832, -0.9475830516688591, -3.7116295697235375, 0.3674005483680849, 7.919946328716183], "sd": [20.21819171204333, 2.507428377847784, 0.025808596240116416, 0.016975532712428208, 0.10606634677308571, 0.7599041972793411, 0.2885034331306497, 0.23826689071589977, 3.309074605827779], "mcse": [0.23732850481655843, 0.02943310837708352, 0.00030295071113766055, 0.00019926499137434478, 0.0012450454446930848, 0.008920032489191711, 0.0033865584714262847, 0.0027968636229327706, 0.038843124039611744], "mode_share": 0.7329568515558, "mode_share_label": "share in the deeper family", "seed": 3048, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/alpha_gp/52.json b/benchmarks/results/hpc/ref/alpha_gp/52.json new file mode 100644 index 0000000..56e2e67 --- /dev/null +++ b/benchmarks/results/hpc/ref/alpha_gp/52.json @@ -0,0 +1 @@ +{"problem": "alpha_gp", "part": "dynesty", "names": ["V", "W", "r", "a", "log_sigma_A", "log_sigma_B", "log_ell", "log_A_q", "p"], "result": {"wall_s": 2788.7204725639895, "calls": {"search": 0, "warmup": 0, "sampling": 1162568, "evidence": 0}, "min_ess": 6791.811927944193, "logz": -83.8608598664329, "logz_err": 0.23661110116859632, "mean": [161.55750981567812, 27.435531758753495, 1.291672661503469, 0.6065921243573046, -0.7277398975092492, -0.9278978273878169, -3.7095162369120227, 0.37714912727203237, 8.204435694785015], "sd": [16.82065710051113, 2.3021883301368034, 0.02420310043047749, 0.015504019055493153, 0.1052298843164069, 0.7555953446149325, 0.28095594869868645, 0.23222283262753535, 3.401513152093643], "mcse": [0.20410334948767306, 0.02793495798199679, 0.0002936825735361365, 0.00018812714633191732, 0.0012768687766975735, 0.009168461123228892, 0.003409144473086383, 0.002817812507773848, 0.04127426315869602], "mode_share": 0.8456989773335915, "mode_share_label": "share in the deeper family", "seed": 3049, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/alpha_gp/6.json b/benchmarks/results/hpc/ref/alpha_gp/6.json new file mode 100644 index 0000000..61b051c --- /dev/null +++ b/benchmarks/results/hpc/ref/alpha_gp/6.json @@ -0,0 +1 @@ +{"problem": "alpha_gp", "part": "dynesty", "names": ["V", "W", "r", "a", "log_sigma_A", "log_sigma_B", "log_ell", "log_A_q", "p"], "result": {"wall_s": 2984.7373787555844, "calls": {"search": 0, "warmup": 0, "sampling": 1362459, "evidence": 0}, "min_ess": 7140.434257560701, "logz": -84.1225660277727, "logz_err": 0.23617010472374617, "mean": [173.14246638872424, 28.281369517831635, 1.2887566528236576, 0.5997921312787519, -0.7384473729868871, -1.1195125608013665, -3.7175619872768, 0.37385735261995184, 8.02609561265403], "sd": [24.223874026616325, 2.4583109451594374, 0.021557059451404088, 0.019590565119377817, 0.10829455554598387, 0.8101921326740164, 0.27328127476454644, 0.2103319464714634, 3.1892977129968876], "mcse": [0.28666936660766107, 0.029092061855969558, 0.00025510983800805835, 0.0002318380160038605, 0.0012815758375937113, 0.009587948866022602, 0.0032340561982946254, 0.0024891033451577603, 0.03774268122033281], "mode_share": 0.9046727236311667, "mode_share_label": "share in the deeper family", "seed": 3003, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/alpha_gp/7.json b/benchmarks/results/hpc/ref/alpha_gp/7.json new file mode 100644 index 0000000..c4edf7d --- /dev/null +++ b/benchmarks/results/hpc/ref/alpha_gp/7.json @@ -0,0 +1 @@ +{"problem": "alpha_gp", "part": "dynesty", "names": ["V", "W", "r", "a", "log_sigma_A", "log_sigma_B", "log_ell", "log_A_q", "p"], "result": {"wall_s": 2764.8887593662366, "calls": {"search": 0, "warmup": 0, "sampling": 1210439, "evidence": 0}, "min_ess": 6851.840864216588, "logz": -84.50191198965852, "logz_err": 0.23907937103614066, "mean": [161.3437253760176, 27.52356842262279, 1.2911510908860964, 0.6072977460206239, -0.7236321333295125, -0.9206903359234555, -3.728978418081405, 0.3608831487372646, 8.115511692053937], "sd": [17.13508311375271, 2.2669489646131464, 0.024126638833439414, 0.015986557083297666, 0.10382582058208888, 0.7393336790116669, 0.28256036641792415, 0.24292216607614814, 3.4168138881395236], "mcse": [0.20700583216846066, 0.027386599398898433, 0.00029146954911094236, 0.00019313069744497253, 0.0012543009127815995, 0.008931756120350758, 0.00341356055292325, 0.0029346986417823667, 0.04127790904681358], "mode_share": 0.8378594299359057, "mode_share_label": "share in the deeper family", "seed": 3004, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/alpha_gp/8.json b/benchmarks/results/hpc/ref/alpha_gp/8.json new file mode 100644 index 0000000..f412762 --- /dev/null +++ b/benchmarks/results/hpc/ref/alpha_gp/8.json @@ -0,0 +1 @@ +{"problem": "alpha_gp", "part": "dynesty", "names": ["V", "W", "r", "a", "log_sigma_A", "log_sigma_B", "log_ell", "log_A_q", "p"], "result": {"wall_s": 2820.0456958909926, "calls": {"search": 0, "warmup": 0, "sampling": 1242116, "evidence": 0}, "min_ess": 7118.043576621609, "logz": -85.19284963807665, "logz_err": 0.24014555565239531, "mean": [163.18726931649934, 27.642603898357127, 1.2894704931300205, 0.6069508002916163, -0.7194440900708137, -0.9242497377694652, -3.7221442121012873, 0.35938301890513114, 7.91808975724129], "sd": [15.157956097192223, 2.2368342186470134, 0.02340221655337931, 0.01640354511042065, 0.10834743262079445, 0.7606404606023083, 0.29112107424180533, 0.23530974300351196, 3.347862010890444], "mcse": [0.179663693520494, 0.026512670635692917, 0.0002773809764052157, 0.00019442736754687675, 0.0012842166716474778, 0.009015692730384314, 0.003450589718334465, 0.0027890711173916296, 0.03968142211369395], "mode_share": 0.8767547506252499, "mode_share_label": "share in the deeper family", "seed": 3005, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/alpha_gp/9.json b/benchmarks/results/hpc/ref/alpha_gp/9.json new file mode 100644 index 0000000..148f904 --- /dev/null +++ b/benchmarks/results/hpc/ref/alpha_gp/9.json @@ -0,0 +1 @@ +{"problem": "alpha_gp", "part": "dynesty", "names": ["V", "W", "r", "a", "log_sigma_A", "log_sigma_B", "log_ell", "log_A_q", "p"], "result": {"wall_s": 2798.0343245019903, "calls": {"search": 0, "warmup": 0, "sampling": 1222600, "evidence": 0}, "min_ess": 7218.340291616132, "logz": -84.48467558283114, "logz_err": 0.23414002268649434, "mean": [159.53485490427767, 27.28674866076614, 1.2929778612141096, 0.6077288939164318, -0.7269578702030975, -0.9063900071764145, -3.7060132265569683, 0.37703326064266895, 8.014746367361827], "sd": [18.670126735050363, 2.431458816999211, 0.025822257982887085, 0.01624059162574942, 0.10717939477269488, 0.7618372068682919, 0.2894011289402667, 0.23107712819421916, 3.381885689612925], "mcse": [0.21974985136908098, 0.028618590608842847, 0.00030393137841429845, 0.00019115390305328577, 0.0012615155968336933, 0.008966924293151636, 0.003406289414804891, 0.002719808242123149, 0.0398052401135807], "mode_share": 0.7976430964287943, "mode_share_label": "share in the deeper family", "seed": 3006, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/n40ca_gp/0.json b/benchmarks/results/hpc/ref/n40ca_gp/0.json new file mode 100644 index 0000000..cfda660 --- /dev/null +++ b/benchmarks/results/hpc/ref/n40ca_gp/0.json @@ -0,0 +1 @@ +{"problem": "n40ca_gp", "part": "pocomc", "names": ["Vv", "Wv", "Rv", "av", "log_ell_xs", "log_A_xs", "amp_slope_xs"], "result": {"wall_s": 640.7687541219639, "calls": {"search": 0, "warmup": 446464, "sampling": 0, "evidence": 4096}, "min_ess": 14402.883300742618, "logz": -11.346640683324653, "logz_err": 0.008829612327629072, "mean": [43.56719223186605, 13.721765783171005, 4.298119872652306, 0.4844611351201628, -1.272366219282795, -1.8032225972846545, 2.2300364828257138], "sd": [1.7200111153884834, 1.061834140539834, 0.07065073255673113, 0.02644065108920894, 0.20915348375756906, 0.482459366500779, 0.6755908989364604], "mcse": [0.014331991191691764, 0.008847732094927362, 0.0005886971704022634, 0.00022031670326011144, 0.0017427712298522492, 0.0040200922710180356, 0.005629360604775835], "seed": 2000}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/n40ca_gp/1.json b/benchmarks/results/hpc/ref/n40ca_gp/1.json new file mode 100644 index 0000000..816b8b6 --- /dev/null +++ b/benchmarks/results/hpc/ref/n40ca_gp/1.json @@ -0,0 +1 @@ +{"problem": "n40ca_gp", "part": "pocomc", "names": ["Vv", "Wv", "Rv", "av", "log_ell_xs", "log_A_xs", "amp_slope_xs"], "result": {"wall_s": 633.3055904699722, "calls": {"search": 0, "warmup": 487424, "sampling": 0, "evidence": 4096}, "min_ess": 14386.924300568662, "logz": -11.346479090928366, "logz_err": 0.007952768122234433, "mean": [43.5887574095278, 13.72474651565375, 4.296511409510507, 0.48525235399999167, -1.2752161744136792, -1.7992840974518884, 2.2223893655881257], "sd": [1.768604828830274, 1.0725806337226362, 0.0709547289440926, 0.02754096948724118, 0.20962414303124668, 0.4802143788094155, 0.6754740862616965], "mcse": [0.014745069611292632, 0.008942232798507397, 0.0005915580464761065, 0.00022961235072531215, 0.0017476615074310188, 0.004003604608821294, 0.005631508101863727], "seed": 2001}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/n40ca_gp/10.json b/benchmarks/results/hpc/ref/n40ca_gp/10.json new file mode 100644 index 0000000..24533fb --- /dev/null +++ b/benchmarks/results/hpc/ref/n40ca_gp/10.json @@ -0,0 +1 @@ +{"problem": "n40ca_gp", "part": "dynesty", "names": ["Vv", "Wv", "Rv", "av", "log_ell_xs", "log_A_xs", "amp_slope_xs"], "result": {"wall_s": 1208.8542942550266, "calls": {"search": 0, "warmup": 0, "sampling": 1102121, "evidence": 0}, "min_ess": 7394.167463623151, "logz": -10.95616272966126, "logz_err": 0.24764373444092155, "mean": [43.27805435134456, 13.812063586626735, 4.312450878654405, 0.4801404218316396, -1.300427700693842, -1.884601318225866, 2.3039543132898572], "sd": [1.7507199422039392, 1.0664913514823, 0.07430683007595126, 0.02561933665206919, 0.21886423502515245, 0.46850229756652884, 0.6486604734595018], "mcse": [0.02035973109236899, 0.012402598842383799, 0.0008641399701931836, 0.00029793617609928424, 0.0025452483080986546, 0.00544837615924091, 0.0075434982440759765], "seed": 3007, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/n40ca_gp/11.json b/benchmarks/results/hpc/ref/n40ca_gp/11.json new file mode 100644 index 0000000..2625604 --- /dev/null +++ b/benchmarks/results/hpc/ref/n40ca_gp/11.json @@ -0,0 +1 @@ +{"problem": "n40ca_gp", "part": "dynesty", "names": ["Vv", "Wv", "Rv", "av", "log_ell_xs", "log_A_xs", "amp_slope_xs"], "result": {"wall_s": 1242.5232465650188, "calls": {"search": 0, "warmup": 0, "sampling": 1135602, "evidence": 0}, "min_ess": 8262.579813620448, "logz": -11.538222983807266, "logz_err": 0.24039412583606726, "mean": [43.71502143065437, 13.69100264381236, 4.291588876534214, 0.4861817346523326, -1.270867540295385, -1.766630598137311, 2.186608002240662], "sd": [1.6622243287055765, 1.102096955311076, 0.072038366878623, 0.025467561793216655, 0.20931644219436965, 0.46372593741929335, 0.6573332938558806], "mcse": [0.018286550961655323, 0.012124447819672651, 0.0007925123248233342, 0.00028017509944847676, 0.002302743210527093, 0.0051015665216877695, 0.007231490099924675], "seed": 3008, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/n40ca_gp/12.json b/benchmarks/results/hpc/ref/n40ca_gp/12.json new file mode 100644 index 0000000..d3931b6 --- /dev/null +++ b/benchmarks/results/hpc/ref/n40ca_gp/12.json @@ -0,0 +1 @@ +{"problem": "n40ca_gp", "part": "dynesty", "names": ["Vv", "Wv", "Rv", "av", "log_ell_xs", "log_A_xs", "amp_slope_xs"], "result": {"wall_s": 1205.3371413829736, "calls": {"search": 0, "warmup": 0, "sampling": 1096104, "evidence": 0}, "min_ess": 7992.9574877123705, "logz": -11.196398888570267, "logz_err": 0.2393942599479111, "mean": [43.77673461417868, 13.700509930730044, 4.289910496349014, 0.4866101926370263, -1.2641329731104327, -1.7573454748512616, 2.186827588032421], "sd": [1.561246425654861, 1.0800193467963126, 0.07040321385935762, 0.024273350697896188, 0.21188738021428744, 0.4548004338586409, 0.6428544320824617], "mcse": [0.01746295382100874, 0.012080301782589582, 0.0007874785506464014, 0.00027150384164416206, 0.0023700163376736577, 0.005087063031011818, 0.007190496693293022], "seed": 3009, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/n40ca_gp/13.json b/benchmarks/results/hpc/ref/n40ca_gp/13.json new file mode 100644 index 0000000..c20115b --- /dev/null +++ b/benchmarks/results/hpc/ref/n40ca_gp/13.json @@ -0,0 +1 @@ +{"problem": "n40ca_gp", "part": "dynesty", "names": ["Vv", "Wv", "Rv", "av", "log_ell_xs", "log_A_xs", "amp_slope_xs"], "result": {"wall_s": 1233.201237477013, "calls": {"search": 0, "warmup": 0, "sampling": 1120717, "evidence": 0}, "min_ess": 8078.734328329857, "logz": -11.509084345310134, "logz_err": 0.24487311481182605, "mean": [43.69078881380422, 13.675209992531647, 4.294459191961428, 0.4851811759892041, -1.2718857830444117, -1.7890424919094987, 2.2273669305461086], "sd": [1.6318308130453132, 1.0876432460224863, 0.07366205502147787, 0.024974938942400462, 0.20834380126811014, 0.48424202880993433, 0.6606004705162517], "mcse": [0.01815530152892599, 0.012100820090893664, 0.0008195437967368073, 0.000277864312611926, 0.0023179759221767663, 0.005387543840783632, 0.007349659435582611], "seed": 3010, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/n40ca_gp/14.json b/benchmarks/results/hpc/ref/n40ca_gp/14.json new file mode 100644 index 0000000..fc6be35 --- /dev/null +++ b/benchmarks/results/hpc/ref/n40ca_gp/14.json @@ -0,0 +1 @@ +{"problem": "n40ca_gp", "part": "dynesty", "names": ["Vv", "Wv", "Rv", "av", "log_ell_xs", "log_A_xs", "amp_slope_xs"], "result": {"wall_s": 1235.1236483319663, "calls": {"search": 0, "warmup": 0, "sampling": 1111461, "evidence": 0}, "min_ess": 8278.355574986761, "logz": -11.244794115029938, "logz_err": 0.24432400793400602, "mean": [43.60975826191982, 13.719473504332724, 4.289551573391981, 0.4892769066373272, -1.2705446692075573, -1.7342782110977626, 2.1390999601633585], "sd": [2.4681016211013227, 1.1314580965774785, 0.07600237069120615, 0.03377725013151341, 0.20696023136801145, 0.48716519415630805, 0.6891835800957763], "mcse": [0.027126327394446176, 0.012435591184110962, 0.000835324272103414, 0.0003712378524927512, 0.002274651475336693, 0.0053543186548235065, 0.0075746554634214805], "seed": 3011, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/n40ca_gp/15.json b/benchmarks/results/hpc/ref/n40ca_gp/15.json new file mode 100644 index 0000000..53d1f6f --- /dev/null +++ b/benchmarks/results/hpc/ref/n40ca_gp/15.json @@ -0,0 +1 @@ +{"problem": "n40ca_gp", "part": "dynesty", "names": ["Vv", "Wv", "Rv", "av", "log_ell_xs", "log_A_xs", "amp_slope_xs"], "result": {"wall_s": 1230.9246317869984, "calls": {"search": 0, "warmup": 0, "sampling": 1117595, "evidence": 0}, "min_ess": 8050.399807370469, "logz": -11.359427481097418, "logz_err": 0.24167564734551947, "mean": [43.82618671330784, 13.712013743910662, 4.287386037387245, 0.48764838285548634, -1.2690736324453133, -1.7713433131278378, 2.1877408582898097], "sd": [1.618473522338044, 1.0941782457124172, 0.07263836579305594, 0.025400928838897562, 0.19709874745650957, 0.4829717364183414, 0.6903500798873458], "mcse": [0.018038352696133412, 0.012194931110201186, 0.0008095754693305532, 0.00028310065433972563, 0.002196722203679066, 0.005382858850352191, 0.007694150106838053], "seed": 3012, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/n40ca_gp/16.json b/benchmarks/results/hpc/ref/n40ca_gp/16.json new file mode 100644 index 0000000..eaefbb8 --- /dev/null +++ b/benchmarks/results/hpc/ref/n40ca_gp/16.json @@ -0,0 +1 @@ +{"problem": "n40ca_gp", "part": "dynesty", "names": ["Vv", "Wv", "Rv", "av", "log_ell_xs", "log_A_xs", "amp_slope_xs"], "result": {"wall_s": 1246.8475659950636, "calls": {"search": 0, "warmup": 0, "sampling": 1134203, "evidence": 0}, "min_ess": 8248.27954018989, "logz": -11.503004165066164, "logz_err": 0.2401387228276592, "mean": [43.53563777338296, 13.73929461571445, 4.298105296496811, 0.4848102833565959, -1.2783582426673028, -1.8077589152729825, 2.236928507586092], "sd": [1.883474095053936, 1.103666266176018, 0.07565232949576496, 0.02810285514022882, 0.20798324027922827, 0.48293385472976447, 0.6596684552448862], "mcse": [0.02073852983738679, 0.012152232861452323, 0.0008329915960276641, 0.0003094345185696353, 0.002290058910570599, 0.0053174812343307724, 0.0072634680656370595], "seed": 3013, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/n40ca_gp/17.json b/benchmarks/results/hpc/ref/n40ca_gp/17.json new file mode 100644 index 0000000..31ce321 --- /dev/null +++ b/benchmarks/results/hpc/ref/n40ca_gp/17.json @@ -0,0 +1 @@ +{"problem": "n40ca_gp", "part": "dynesty", "names": ["Vv", "Wv", "Rv", "av", "log_ell_xs", "log_A_xs", "amp_slope_xs"], "result": {"wall_s": 1193.0571655089734, "calls": {"search": 0, "warmup": 0, "sampling": 1088045, "evidence": 0}, "min_ess": 7979.405667796607, "logz": -11.084466496464758, "logz_err": 0.24581791038631845, "mean": [43.807120444687484, 13.693921367166137, 4.288596905710254, 0.48693533595894395, -1.2622930032860495, -1.7577138627891749, 2.169840703513909], "sd": [1.5399098921123302, 1.0592050585166248, 0.06968805133946548, 0.023987291001009433, 0.2023267760731105, 0.49018499077737, 0.6863471076709199], "mcse": [0.01723891929050647, 0.011857544788427349, 0.0007801409022094155, 0.0002685319288371255, 0.002264999387885158, 0.00548750257187927, 0.007683490089268455], "seed": 3014, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/n40ca_gp/18.json b/benchmarks/results/hpc/ref/n40ca_gp/18.json new file mode 100644 index 0000000..1a526c7 --- /dev/null +++ b/benchmarks/results/hpc/ref/n40ca_gp/18.json @@ -0,0 +1 @@ +{"problem": "n40ca_gp", "part": "dynesty", "names": ["Vv", "Wv", "Rv", "av", "log_ell_xs", "log_A_xs", "amp_slope_xs"], "result": {"wall_s": 1283.1568422319833, "calls": {"search": 0, "warmup": 0, "sampling": 1164552, "evidence": 0}, "min_ess": 8553.48471894446, "logz": -12.193798815892638, "logz_err": 0.24829451716794204, "mean": [43.81172141688906, 13.67673660208023, 4.285694053148974, 0.48798216107750375, -1.249672204149435, -1.7072199574829405, 2.1308674709643576], "sd": [1.7596440772631727, 1.1218216924281672, 0.07645741648147311, 0.02774282394632116, 0.20272473279912395, 0.4841244978416692, 0.6785596843879129], "mcse": [0.01902625399474519, 0.012129762338160049, 0.0008267002654429185, 0.00029997089852123614, 0.002191972971745533, 0.005234624308422832, 0.007336966078866683], "seed": 3015, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/n40ca_gp/19.json b/benchmarks/results/hpc/ref/n40ca_gp/19.json new file mode 100644 index 0000000..389fa6a --- /dev/null +++ b/benchmarks/results/hpc/ref/n40ca_gp/19.json @@ -0,0 +1 @@ +{"problem": "n40ca_gp", "part": "dynesty", "names": ["Vv", "Wv", "Rv", "av", "log_ell_xs", "log_A_xs", "amp_slope_xs"], "result": {"wall_s": 1241.0421020310605, "calls": {"search": 0, "warmup": 0, "sampling": 1139174, "evidence": 0}, "min_ess": 8536.266478917809, "logz": -11.452006570599256, "logz_err": 0.2259855021344347, "mean": [43.70387989866226, 13.745520318127856, 4.293728292080306, 0.48592213775281917, -1.278417041363774, -1.7934715421955074, 2.21353915535013], "sd": [1.6715715928055548, 1.0805003102006683, 0.0734804872358054, 0.02586239602686326, 0.21037203918844183, 0.4713779026648803, 0.6557230339953096], "mcse": [0.01809218416720272, 0.01169474923419816, 0.0007953129339406195, 0.0002799205453939365, 0.0022769528346908326, 0.005101938716874821, 0.007097190419351717], "seed": 3016, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/n40ca_gp/2.json b/benchmarks/results/hpc/ref/n40ca_gp/2.json new file mode 100644 index 0000000..f63ff18 --- /dev/null +++ b/benchmarks/results/hpc/ref/n40ca_gp/2.json @@ -0,0 +1 @@ +{"problem": "n40ca_gp", "part": "pocomc", "names": ["Vv", "Wv", "Rv", "av", "log_ell_xs", "log_A_xs", "amp_slope_xs"], "result": {"wall_s": 598.1245579579845, "calls": {"search": 0, "warmup": 434176, "sampling": 0, "evidence": 4096}, "min_ess": 14584.239407305251, "logz": -11.33571824175814, "logz_err": 0.009205750713685073, "mean": [43.64091845720561, 13.72593668199885, 4.295120055919713, 0.4853920846172816, -1.2724714005964133, -1.786468422978889, 2.2094619754791824], "sd": [1.6395438703788003, 1.0606787664020407, 0.06921934496604427, 0.02585659807967027, 0.20612412949733824, 0.47736338010738955, 0.673143420445319], "mcse": [0.01357629134947142, 0.008782981792091384, 0.0005731728264529249, 0.000214106322604642, 0.001706816930470727, 0.003952821540791744, 0.0055739839360528735], "seed": 2002}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/n40ca_gp/20.json b/benchmarks/results/hpc/ref/n40ca_gp/20.json new file mode 100644 index 0000000..0e47968 --- /dev/null +++ b/benchmarks/results/hpc/ref/n40ca_gp/20.json @@ -0,0 +1 @@ +{"problem": "n40ca_gp", "part": "dynesty", "names": ["Vv", "Wv", "Rv", "av", "log_ell_xs", "log_A_xs", "amp_slope_xs"], "result": {"wall_s": 1219.2673423220403, "calls": {"search": 0, "warmup": 0, "sampling": 1128060, "evidence": 0}, "min_ess": 8469.417083777651, "logz": -11.73973717107672, "logz_err": 0.2421789796056163, "mean": [43.914648504982814, 13.67148857147585, 4.282961295892786, 0.4888065654357596, -1.2519751106831911, -1.694077456984327, 2.114387366207379], "sd": [1.6252898495921904, 1.1050272943052923, 0.07317554758058538, 0.0253389345238508, 0.1993368785667893, 0.4775564800935445, 0.6721596495022871], "mcse": [0.017660543418250456, 0.012007324425441494, 0.0007951319793976703, 0.00027533510619226275, 0.002166012172949103, 0.005189170998314606, 0.007303746268402333], "seed": 3017, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/n40ca_gp/21.json b/benchmarks/results/hpc/ref/n40ca_gp/21.json new file mode 100644 index 0000000..59b198c --- /dev/null +++ b/benchmarks/results/hpc/ref/n40ca_gp/21.json @@ -0,0 +1 @@ +{"problem": "n40ca_gp", "part": "dynesty", "names": ["Vv", "Wv", "Rv", "av", "log_ell_xs", "log_A_xs", "amp_slope_xs"], "result": {"wall_s": 1247.1665258139838, "calls": {"search": 0, "warmup": 0, "sampling": 1134866, "evidence": 0}, "min_ess": 8343.133385111145, "logz": -11.438718860915845, "logz_err": 0.2416829222146869, "mean": [43.684703503154424, 13.726532508372502, 4.293579858908982, 0.485739799935159, -1.2723423058233612, -1.7794652674949853, 2.2020627015809047], "sd": [1.6507173375315822, 1.088767459039104, 0.07279589012370569, 0.02565688623886426, 0.20515544907075484, 0.4849925663126707, 0.6810040041546508], "mcse": [0.018072079120305423, 0.011919843098511181, 0.0007969705388300613, 0.0002808919901349004, 0.0022460450516092892, 0.0053097061694821306, 0.007455642443745876], "seed": 3018, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/n40ca_gp/22.json b/benchmarks/results/hpc/ref/n40ca_gp/22.json new file mode 100644 index 0000000..085af39 --- /dev/null +++ b/benchmarks/results/hpc/ref/n40ca_gp/22.json @@ -0,0 +1 @@ +{"problem": "n40ca_gp", "part": "dynesty", "names": ["Vv", "Wv", "Rv", "av", "log_ell_xs", "log_A_xs", "amp_slope_xs"], "result": {"wall_s": 2374.0736664300784, "calls": {"search": 0, "warmup": 0, "sampling": 1107916, "evidence": 0}, "min_ess": 7787.897193333523, "logz": -11.28587178204334, "logz_err": 0.24865489170848115, "mean": [43.552226628385824, 13.746131220282406, 4.300320234715255, 0.4839276978751418, -1.29912088346445, -1.841749007255673, 2.2638442948512543], "sd": [1.654581885304905, 1.1080296502186462, 0.07352295995346364, 0.025418149579137808, 0.22121947162931938, 0.47277174235042396, 0.6450502778093485], "mcse": [0.018749002213825198, 0.012555710025258168, 0.000833130201156799, 0.00028802741463761027, 0.0025067628264013207, 0.005357243737942075, 0.0073094291640013655], "seed": 3019, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/n40ca_gp/23.json b/benchmarks/results/hpc/ref/n40ca_gp/23.json new file mode 100644 index 0000000..ef8605a --- /dev/null +++ b/benchmarks/results/hpc/ref/n40ca_gp/23.json @@ -0,0 +1 @@ +{"problem": "n40ca_gp", "part": "dynesty", "names": ["Vv", "Wv", "Rv", "av", "log_ell_xs", "log_A_xs", "amp_slope_xs"], "result": {"wall_s": 2698.916866186075, "calls": {"search": 0, "warmup": 0, "sampling": 1162511, "evidence": 0}, "min_ess": 8251.084129994106, "logz": -12.076571775820007, "logz_err": 0.2512981790914582, "mean": [43.732539970840016, 13.690917267318765, 4.284126790310573, 0.4899936647676803, -1.2574795715842682, -1.6993013291509382, 2.1081115462246904], "sd": [2.0819750842478895, 1.1697751923668545, 0.07687912837062388, 0.03403675950431354, 0.20654761646778372, 0.47846364785765044, 0.6723719157980415], "mcse": [0.02292028535213182, 0.012877954885122384, 0.000846355738457084, 0.00037470776965737456, 0.002273865015994887, 0.005267365312145848, 0.007402084822940061], "seed": 3020, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/n40ca_gp/24.json b/benchmarks/results/hpc/ref/n40ca_gp/24.json new file mode 100644 index 0000000..53640e7 --- /dev/null +++ b/benchmarks/results/hpc/ref/n40ca_gp/24.json @@ -0,0 +1 @@ +{"problem": "n40ca_gp", "part": "dynesty", "names": ["Vv", "Wv", "Rv", "av", "log_ell_xs", "log_A_xs", "amp_slope_xs"], "result": {"wall_s": 1230.6493399753235, "calls": {"search": 0, "warmup": 0, "sampling": 1130683, "evidence": 0}, "min_ess": 8569.919713287863, "logz": -11.632774630574401, "logz_err": 0.24048473404730733, "mean": [43.78615560526788, 13.68759382899415, 4.286736399537174, 0.4881491954726758, -1.2672519256849206, -1.7177770422528553, 2.1203872290452512], "sd": [1.8004411062461372, 1.1450640777070926, 0.07603397340977461, 0.028926691178387937, 0.2058763870320605, 0.4812997522166705, 0.656462493354124], "mcse": [0.019448698473309666, 0.012369194361695025, 0.000821333070792592, 0.00031247147857670765, 0.002223914884119268, 0.005199089114143449, 0.007091229503696964], "seed": 3021, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/n40ca_gp/25.json b/benchmarks/results/hpc/ref/n40ca_gp/25.json new file mode 100644 index 0000000..f77ec56 --- /dev/null +++ b/benchmarks/results/hpc/ref/n40ca_gp/25.json @@ -0,0 +1 @@ +{"problem": "n40ca_gp", "part": "dynesty", "names": ["Vv", "Wv", "Rv", "av", "log_ell_xs", "log_A_xs", "amp_slope_xs"], "result": {"wall_s": 1218.6569001958705, "calls": {"search": 0, "warmup": 0, "sampling": 1112852, "evidence": 0}, "min_ess": 8042.564964576484, "logz": -11.149572195251087, "logz_err": 0.23851036195312217, "mean": [43.53544780535106, 13.73050656192565, 4.300814248923584, 0.4833540164621793, -1.2861474178369703, -1.8400313196518363, 2.28133919429163], "sd": [1.6784714050623375, 1.090854228598583, 0.07381488275572519, 0.02559127973607512, 0.21779853346446107, 0.45614301684599645, 0.6383068661534999], "mcse": [0.01871615607139142, 0.012163804478295603, 0.0008230887114793014, 0.0002853610637407492, 0.0024286093478545897, 0.005086320725164768, 0.0071175778701609545], "seed": 3022, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/n40ca_gp/26.json b/benchmarks/results/hpc/ref/n40ca_gp/26.json new file mode 100644 index 0000000..3dfc9f2 --- /dev/null +++ b/benchmarks/results/hpc/ref/n40ca_gp/26.json @@ -0,0 +1 @@ +{"problem": "n40ca_gp", "part": "dynesty", "names": ["Vv", "Wv", "Rv", "av", "log_ell_xs", "log_A_xs", "amp_slope_xs"], "result": {"wall_s": 1298.1542010549456, "calls": {"search": 0, "warmup": 0, "sampling": 1124589, "evidence": 0}, "min_ess": 8577.209208661405, "logz": -11.125878410684217, "logz_err": 0.2292984255736507, "mean": [43.81416006963357, 13.686154360137122, 4.287716666329644, 0.48751340645388413, -1.2667703222434665, -1.749390302880168, 2.159951341086709], "sd": [1.6409903918074311, 1.0814290456713287, 0.06970489341388623, 0.025620087144759714, 0.20208544390851974, 0.46564548274017353, 0.6639807735456031], "mcse": [0.017718748206922468, 0.011676831905638193, 0.0007526451473190311, 0.0002766353023294727, 0.00218203660105245, 0.005027850926827489, 0.007169394896781792], "seed": 3023, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/n40ca_gp/27.json b/benchmarks/results/hpc/ref/n40ca_gp/27.json new file mode 100644 index 0000000..d74a8e7 --- /dev/null +++ b/benchmarks/results/hpc/ref/n40ca_gp/27.json @@ -0,0 +1 @@ +{"problem": "n40ca_gp", "part": "dynesty", "names": ["Vv", "Wv", "Rv", "av", "log_ell_xs", "log_A_xs", "amp_slope_xs"], "result": {"wall_s": 1322.2990707849385, "calls": {"search": 0, "warmup": 0, "sampling": 1177738, "evidence": 0}, "min_ess": 8486.487797581485, "logz": -11.540927853961145, "logz_err": 0.23742179539410013, "mean": [43.28319592325252, 13.806521466517598, 4.294654460755931, 0.4909841124236277, -1.2804477800348626, -1.7897516614420492, 2.199793397334258], "sd": [3.128813860591252, 1.2033354326459451, 0.07695938480252057, 0.04325677163510923, 0.21581826451129804, 0.49865396664902056, 0.7325145024209972], "mcse": [0.033963757495445834, 0.013062391897081761, 0.0008354060033272713, 0.0004695589342515576, 0.002342740580152173, 0.005412965792157748, 0.007951558012282183], "seed": 3024, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/n40ca_gp/28.json b/benchmarks/results/hpc/ref/n40ca_gp/28.json new file mode 100644 index 0000000..c4d38aa --- /dev/null +++ b/benchmarks/results/hpc/ref/n40ca_gp/28.json @@ -0,0 +1 @@ +{"problem": "n40ca_gp", "part": "dynesty", "names": ["Vv", "Wv", "Rv", "av", "log_ell_xs", "log_A_xs", "amp_slope_xs"], "result": {"wall_s": 1266.3550127730705, "calls": {"search": 0, "warmup": 0, "sampling": 1110557, "evidence": 0}, "min_ess": 7452.302053439971, "logz": -10.955725927409414, "logz_err": 0.2513640142554386, "mean": [43.228312637394644, 13.74045987549343, 4.312040588216139, 0.48108463179368616, -1.2815195531316532, -1.9324324616821094, 2.406135250882503], "sd": [2.211088276236884, 1.0289244013253838, 0.07563152550674591, 0.028683993969307063, 0.196584905034812, 0.46369809494459363, 0.6799093628726366], "mcse": [0.02561302404673366, 0.011918956704103423, 0.0008761079791858555, 0.0003322724991073649, 0.0022772197537273067, 0.005371432060801202, 0.007876001626897734], "seed": 3025, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/n40ca_gp/29.json b/benchmarks/results/hpc/ref/n40ca_gp/29.json new file mode 100644 index 0000000..b1a1a96 --- /dev/null +++ b/benchmarks/results/hpc/ref/n40ca_gp/29.json @@ -0,0 +1 @@ +{"problem": "n40ca_gp", "part": "dynesty", "names": ["Vv", "Wv", "Rv", "av", "log_ell_xs", "log_A_xs", "amp_slope_xs"], "result": {"wall_s": 1188.7009869210888, "calls": {"search": 0, "warmup": 0, "sampling": 1091512, "evidence": 0}, "min_ess": 8192.478818220363, "logz": -11.482314762511074, "logz_err": 0.2525032963504758, "mean": [43.9653072903439, 13.692851705878935, 4.280915711930681, 0.48955781936926007, -1.2526814006323752, -1.6895549190296588, 2.105535240332168], "sd": [1.5818169093431076, 1.127081621957749, 0.07175823538492003, 0.024680392128826844, 0.21076264016558302, 0.4900251742191631, 0.6755452986328606], "mcse": [0.01747626213053631, 0.01245224637029796, 0.000792800812916062, 0.0002726744162236328, 0.0023285521384312662, 0.005413906214197806, 0.007463573470625035], "seed": 3026, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/n40ca_gp/3.json b/benchmarks/results/hpc/ref/n40ca_gp/3.json new file mode 100644 index 0000000..2a446e7 --- /dev/null +++ b/benchmarks/results/hpc/ref/n40ca_gp/3.json @@ -0,0 +1 @@ +{"problem": "n40ca_gp", "part": "dynesty", "names": ["Vv", "Wv", "Rv", "av", "log_ell_xs", "log_A_xs", "amp_slope_xs"], "result": {"wall_s": 1334.630270184949, "calls": {"search": 0, "warmup": 0, "sampling": 1174111, "evidence": 0}, "min_ess": 8704.848196460774, "logz": -12.177582190802257, "logz_err": 0.24689773209131172, "mean": [43.86350465157741, 13.613350602769225, 4.2801884004979245, 0.49061836857899627, -1.2549020023920017, -1.684654261954729, 2.0995189980483357], "sd": [2.11651250135529, 1.1464758731028168, 0.07664195520330816, 0.03057126107834519, 0.19825012259046437, 0.4801133607365389, 0.6948607729261731], "mcse": [0.02268507592114873, 0.012288088166948579, 0.0008214591557663893, 0.0003276670362794626, 0.0021248724396675705, 0.005145921903174224, 0.007447614591628751], "seed": 3000, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/n40ca_gp/30.json b/benchmarks/results/hpc/ref/n40ca_gp/30.json new file mode 100644 index 0000000..ed3de69 --- /dev/null +++ b/benchmarks/results/hpc/ref/n40ca_gp/30.json @@ -0,0 +1 @@ +{"problem": "n40ca_gp", "part": "dynesty", "names": ["Vv", "Wv", "Rv", "av", "log_ell_xs", "log_A_xs", "amp_slope_xs"], "result": {"wall_s": 1297.1201639719075, "calls": {"search": 0, "warmup": 0, "sampling": 1179646, "evidence": 0}, "min_ess": 8484.26457311157, "logz": -12.043201957814523, "logz_err": 0.24764806525200142, "mean": [43.237884365761246, 13.710284415596076, 4.294428485245295, 0.49093815013993636, -1.2728502346909376, -1.743208386727275, 2.1457859705122457], "sd": [3.278531584921585, 1.1681048072433362, 0.08119318898776164, 0.04382746592306667, 0.21202846946434786, 0.49648854134237486, 0.7183500323436094], "mcse": [0.03559362908435446, 0.012681619244386539, 0.000881480070619909, 0.0004758162382657451, 0.00230190330700074, 0.005390165849384472, 0.007798822107301433], "seed": 3027, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/n40ca_gp/31.json b/benchmarks/results/hpc/ref/n40ca_gp/31.json new file mode 100644 index 0000000..0dabee3 --- /dev/null +++ b/benchmarks/results/hpc/ref/n40ca_gp/31.json @@ -0,0 +1 @@ +{"problem": "n40ca_gp", "part": "dynesty", "names": ["Vv", "Wv", "Rv", "av", "log_ell_xs", "log_A_xs", "amp_slope_xs"], "result": {"wall_s": 1251.5538921830012, "calls": {"search": 0, "warmup": 0, "sampling": 1141709, "evidence": 0}, "min_ess": 8665.163054005254, "logz": -12.032065310194248, "logz_err": 0.24660316347530628, "mean": [44.02763540582919, 13.644462850974294, 4.276488727650422, 0.49105331462361645, -1.2491787096936808, -1.6390695512790139, 2.047277261322359], "sd": [1.7148526069740821, 1.1623072339935536, 0.07570163125184382, 0.02778961540350414, 0.20618265619125828, 0.48459175183237596, 0.6832761022624944], "mcse": [0.018422070006086432, 0.012486265668623465, 0.0008132365107209967, 0.0002985342520538318, 0.002214949151285057, 0.005205802026554587, 0.007340199465641764], "seed": 3028, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/n40ca_gp/32.json b/benchmarks/results/hpc/ref/n40ca_gp/32.json new file mode 100644 index 0000000..3b5b9fe --- /dev/null +++ b/benchmarks/results/hpc/ref/n40ca_gp/32.json @@ -0,0 +1 @@ +{"problem": "n40ca_gp", "part": "dynesty", "names": ["Vv", "Wv", "Rv", "av", "log_ell_xs", "log_A_xs", "amp_slope_xs"], "result": {"wall_s": 1183.6415254999883, "calls": {"search": 0, "warmup": 0, "sampling": 1084416, "evidence": 0}, "min_ess": 7482.462360058322, "logz": -10.566432697254713, "logz_err": 0.23647210477683506, "mean": [43.291155024181656, 13.796398752412072, 4.31206406869457, 0.4800434812503849, -1.2909337352807704, -1.8782590618797301, 2.3038729421569286], "sd": [1.6220273201822708, 1.0294542268662719, 0.07038640436561884, 0.024864033487750355, 0.20612640180028657, 0.4553672088979788, 0.6477204192179822], "mcse": [0.01875149482784268, 0.011901036049389397, 0.0008137041102760407, 0.00028744139481723765, 0.002382930366922277, 0.00526428609196304, 0.007487991071253501], "seed": 3029, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/n40ca_gp/33.json b/benchmarks/results/hpc/ref/n40ca_gp/33.json new file mode 100644 index 0000000..51c93df --- /dev/null +++ b/benchmarks/results/hpc/ref/n40ca_gp/33.json @@ -0,0 +1 @@ +{"problem": "n40ca_gp", "part": "dynesty", "names": ["Vv", "Wv", "Rv", "av", "log_ell_xs", "log_A_xs", "amp_slope_xs"], "result": {"wall_s": 1275.9793411010178, "calls": {"search": 0, "warmup": 0, "sampling": 1141991, "evidence": 0}, "min_ess": 8326.893796102542, "logz": -11.454888968130936, "logz_err": 0.23643365902992927, "mean": [43.588480952577804, 13.701858999828428, 4.295785385522357, 0.48510122409948253, -1.2489288058759875, -1.7026286792301655, 2.1316673983109427], "sd": [1.8990135139198345, 1.0641927539243992, 0.07633923282547166, 0.02748984157523734, 0.21381503956942305, 0.4883188604393866, 0.6511242348013017], "mcse": [0.020810692999510053, 0.011662154340602929, 0.0008365776896815046, 0.0003012525447734029, 0.002343131902190979, 0.005351333108471845, 0.0071354661015660395], "seed": 3030, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/n40ca_gp/34.json b/benchmarks/results/hpc/ref/n40ca_gp/34.json new file mode 100644 index 0000000..6f49109 --- /dev/null +++ b/benchmarks/results/hpc/ref/n40ca_gp/34.json @@ -0,0 +1 @@ +{"problem": "n40ca_gp", "part": "dynesty", "names": ["Vv", "Wv", "Rv", "av", "log_ell_xs", "log_A_xs", "amp_slope_xs"], "result": {"wall_s": 1261.6493149530143, "calls": {"search": 0, "warmup": 0, "sampling": 1162240, "evidence": 0}, "min_ess": 7843.596560065519, "logz": -11.855265470717185, "logz_err": 0.2490843635169071, "mean": [43.5325415323224, 13.71621584701654, 4.298950224877192, 0.48425376546621557, -1.2762998104671066, -1.8307349690789685, 2.2679165498297715], "sd": [1.7204355190905178, 1.0701019364510445, 0.0735840116798548, 0.028903209351044686, 0.20466175726730398, 0.4956467254698851, 0.6955563273146662], "mcse": [0.019425883347593976, 0.01208279831290713, 0.0008308561473414015, 0.0003263536279007389, 0.002310888945428163, 0.005596475638729441, 0.007853706765620838], "seed": 3031, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/n40ca_gp/35.json b/benchmarks/results/hpc/ref/n40ca_gp/35.json new file mode 100644 index 0000000..92f84ac --- /dev/null +++ b/benchmarks/results/hpc/ref/n40ca_gp/35.json @@ -0,0 +1 @@ +{"problem": "n40ca_gp", "part": "dynesty", "names": ["Vv", "Wv", "Rv", "av", "log_ell_xs", "log_A_xs", "amp_slope_xs"], "result": {"wall_s": 1301.0490616718307, "calls": {"search": 0, "warmup": 0, "sampling": 1172512, "evidence": 0}, "min_ess": 8911.064666819591, "logz": -12.282501877796955, "logz_err": 0.24856781011911944, "mean": [43.80548828998113, 13.664309785766964, 4.286261639013012, 0.48756050854627914, -1.2634243799479214, -1.7077633324013406, 2.115194225175444], "sd": [1.8328564157579392, 1.1563976165796122, 0.08184350031494599, 0.02864355642532756, 0.20893607771282424, 0.4986895280249155, 0.6885600800296213], "mcse": [0.019416173602172446, 0.012250177746391176, 0.0008670005989898084, 0.00030343253260665183, 0.002213342584695381, 0.005282815591265587, 0.007294189514486507], "seed": 3032, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/n40ca_gp/36.json b/benchmarks/results/hpc/ref/n40ca_gp/36.json new file mode 100644 index 0000000..635627e --- /dev/null +++ b/benchmarks/results/hpc/ref/n40ca_gp/36.json @@ -0,0 +1 @@ +{"problem": "n40ca_gp", "part": "dynesty", "names": ["Vv", "Wv", "Rv", "av", "log_ell_xs", "log_A_xs", "amp_slope_xs"], "result": {"wall_s": 1251.7857860750519, "calls": {"search": 0, "warmup": 0, "sampling": 1141131, "evidence": 0}, "min_ess": 8882.388326434035, "logz": -11.762480596073527, "logz_err": 0.24624102948935644, "mean": [43.901894705401496, 13.677666748574735, 4.278343308569338, 0.49168815493319723, -1.2546105670677565, -1.6567095668881908, 2.0574835015032016], "sd": [2.170842123753842, 1.2100324060414167, 0.07774129967135439, 0.03315669220868005, 0.21123734394847446, 0.4831610024357838, 0.6702769572898939], "mcse": [0.023033681757930514, 0.012839027330714068, 0.0008248726779732114, 0.000351808493175799, 0.0022413300823028396, 0.005126571226056825, 0.007111961738236505], "seed": 3033, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/n40ca_gp/37.json b/benchmarks/results/hpc/ref/n40ca_gp/37.json new file mode 100644 index 0000000..18f486d --- /dev/null +++ b/benchmarks/results/hpc/ref/n40ca_gp/37.json @@ -0,0 +1 @@ +{"problem": "n40ca_gp", "part": "dynesty", "names": ["Vv", "Wv", "Rv", "av", "log_ell_xs", "log_A_xs", "amp_slope_xs"], "result": {"wall_s": 1281.4383820788935, "calls": {"search": 0, "warmup": 0, "sampling": 1160194, "evidence": 0}, "min_ess": 7864.423846306449, "logz": -11.80875628777826, "logz_err": 0.2485611576986709, "mean": [43.47715595580879, 13.674155125872248, 4.296522904395616, 0.4859004658367291, -1.264331637328232, -1.778214409627821, 2.2088037311102404], "sd": [2.188373395436522, 1.1032697322415206, 0.07476660525490007, 0.032715625739426386, 0.20201819902334567, 0.45485899914448596, 0.6438677774693808], "mcse": [0.024676750531403634, 0.012440798269685511, 0.0008430905209332768, 0.00036891114493262914, 0.0022780174126125975, 0.005129125620087994, 0.007260444928161758], "seed": 3034, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/n40ca_gp/38.json b/benchmarks/results/hpc/ref/n40ca_gp/38.json new file mode 100644 index 0000000..78ccd63 --- /dev/null +++ b/benchmarks/results/hpc/ref/n40ca_gp/38.json @@ -0,0 +1 @@ +{"problem": "n40ca_gp", "part": "dynesty", "names": ["Vv", "Wv", "Rv", "av", "log_ell_xs", "log_A_xs", "amp_slope_xs"], "result": {"wall_s": 1280.2561507229693, "calls": {"search": 0, "warmup": 0, "sampling": 1179128, "evidence": 0}, "min_ess": 8741.846288818493, "logz": -12.127051846396768, "logz_err": 0.23495263357703966, "mean": [43.83356801895904, 13.673685588287075, 4.280005489373067, 0.4918980116268821, -1.2571522044554038, -1.7078951948985597, 2.1372396513947094], "sd": [2.2522214528722913, 1.177610423780548, 0.07704416281964468, 0.03405131533542319, 0.2115924165189924, 0.4847560212983791, 0.6734445754604994], "mcse": [0.024088486178650118, 0.012595054709604765, 0.0008240207679666014, 0.00036419359995711265, 0.0022630727517157444, 0.0051846760913193185, 0.007202782092044567], "seed": 3035, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/n40ca_gp/39.json b/benchmarks/results/hpc/ref/n40ca_gp/39.json new file mode 100644 index 0000000..538b320 --- /dev/null +++ b/benchmarks/results/hpc/ref/n40ca_gp/39.json @@ -0,0 +1 @@ +{"problem": "n40ca_gp", "part": "dynesty", "names": ["Vv", "Wv", "Rv", "av", "log_ell_xs", "log_A_xs", "amp_slope_xs"], "result": {"wall_s": 1186.1582289150683, "calls": {"search": 0, "warmup": 0, "sampling": 1088268, "evidence": 0}, "min_ess": 7761.383848793997, "logz": -10.881899352497788, "logz_err": 0.24818532136468935, "mean": [43.63476607194968, 13.704936666694827, 4.295478800646791, 0.484685934388037, -1.2652595219137075, -1.771495347722798, 2.19752782254279], "sd": [1.5921008223429276, 1.082975473270905, 0.07091654723024746, 0.024691355190720382, 0.20523970008909054, 0.462326669705431, 0.6583202620140526], "mcse": [0.018071782264372248, 0.012292749727876064, 0.0008049668604530483, 0.0002802691817986287, 0.0023296559614590802, 0.005247825258725525, 0.007472529546109304], "seed": 3036, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/n40ca_gp/4.json b/benchmarks/results/hpc/ref/n40ca_gp/4.json new file mode 100644 index 0000000..c3c691a --- /dev/null +++ b/benchmarks/results/hpc/ref/n40ca_gp/4.json @@ -0,0 +1 @@ +{"problem": "n40ca_gp", "part": "dynesty", "names": ["Vv", "Wv", "Rv", "av", "log_ell_xs", "log_A_xs", "amp_slope_xs"], "result": {"wall_s": 1272.7058295130264, "calls": {"search": 0, "warmup": 0, "sampling": 1131976, "evidence": 0}, "min_ess": 8266.251044472923, "logz": -11.62639478115365, "logz_err": 0.2323095386650202, "mean": [43.65903901799406, 13.728564647336153, 4.2946504176091755, 0.4850803203582831, -1.270483634494769, -1.7688786955662252, 2.1920897834915354], "sd": [1.6106292908463407, 1.0973267824768798, 0.07376627959417903, 0.02461015110796583, 0.21414120185835417, 0.4867352456550508, 0.6729684308572398], "mcse": [0.017715005748554193, 0.012069288923341057, 0.000811341302736191, 0.0002706823791347496, 0.002355298418750142, 0.005353508547129595, 0.007401851989769173], "seed": 3001, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/n40ca_gp/40.json b/benchmarks/results/hpc/ref/n40ca_gp/40.json new file mode 100644 index 0000000..196c6b2 --- /dev/null +++ b/benchmarks/results/hpc/ref/n40ca_gp/40.json @@ -0,0 +1 @@ +{"problem": "n40ca_gp", "part": "dynesty", "names": ["Vv", "Wv", "Rv", "av", "log_ell_xs", "log_A_xs", "amp_slope_xs"], "result": {"wall_s": 1252.7791947519872, "calls": {"search": 0, "warmup": 0, "sampling": 1136548, "evidence": 0}, "min_ess": 8570.974395890187, "logz": -11.899566974328277, "logz_err": 0.24079455673778985, "mean": [43.75937472269489, 13.648612371007424, 4.288390931860504, 0.48682292916974107, -1.2626427583834905, -1.7258316509503708, 2.1387135805907875], "sd": [1.828899666024829, 1.139378735710667, 0.07899562786103138, 0.02817186098021161, 0.21023177069777157, 0.4859029430134008, 0.6701291869472069], "mcse": [0.01975489754960778, 0.012307022967032625, 0.0008532729073397026, 0.00030429893874687705, 0.002270822817106212, 0.005248490683551979, 0.007238414265730589], "seed": 3037, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/n40ca_gp/41.json b/benchmarks/results/hpc/ref/n40ca_gp/41.json new file mode 100644 index 0000000..a0fd174 --- /dev/null +++ b/benchmarks/results/hpc/ref/n40ca_gp/41.json @@ -0,0 +1 @@ +{"problem": "n40ca_gp", "part": "dynesty", "names": ["Vv", "Wv", "Rv", "av", "log_ell_xs", "log_A_xs", "amp_slope_xs"], "result": {"wall_s": 1236.8057141320314, "calls": {"search": 0, "warmup": 0, "sampling": 1145702, "evidence": 0}, "min_ess": 8648.346051710818, "logz": -11.962618196368858, "logz_err": 0.24764865273221306, "mean": [43.807420341295504, 13.691236220908994, 4.286186232882652, 0.4876588628538749, -1.2531506431318928, -1.6760611771751486, 2.069057113350925], "sd": [1.6858945674377943, 1.1270910505542393, 0.07485139330407346, 0.02600832328194021, 0.2059451159764634, 0.49649361660310454, 0.7002223749827643], "mcse": [0.018128583935945172, 0.01211971680084263, 0.0008048841205400045, 0.0002796699632091597, 0.002214547334861756, 0.005338842876710598, 0.007529557508447395], "seed": 3038, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/n40ca_gp/42.json b/benchmarks/results/hpc/ref/n40ca_gp/42.json new file mode 100644 index 0000000..65a166c --- /dev/null +++ b/benchmarks/results/hpc/ref/n40ca_gp/42.json @@ -0,0 +1 @@ +{"problem": "n40ca_gp", "part": "dynesty", "names": ["Vv", "Wv", "Rv", "av", "log_ell_xs", "log_A_xs", "amp_slope_xs"], "result": {"wall_s": 1222.1656831169967, "calls": {"search": 0, "warmup": 0, "sampling": 1143939, "evidence": 0}, "min_ess": 8368.316866903575, "logz": -11.26250758497472, "logz_err": 0.2297579112149907, "mean": [43.526297500209935, 13.77134561683191, 4.291547919557328, 0.48906400552260726, -1.2770463046068083, -1.776657500211774, 2.190598533165245], "sd": [2.3819995354307526, 1.1676043307223878, 0.07470594013953263, 0.03874956905316134, 0.20683760545531427, 0.4613166741111253, 0.6576607141609135], "mcse": [0.02603889883063443, 0.012763701499376187, 0.0008166502085353882, 0.0004235920676296385, 0.0022610514413251783, 0.0050428969558518845, 0.0071892376745665626], "seed": 3039, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/n40ca_gp/43.json b/benchmarks/results/hpc/ref/n40ca_gp/43.json new file mode 100644 index 0000000..70b850f --- /dev/null +++ b/benchmarks/results/hpc/ref/n40ca_gp/43.json @@ -0,0 +1 @@ +{"problem": "n40ca_gp", "part": "dynesty", "names": ["Vv", "Wv", "Rv", "av", "log_ell_xs", "log_A_xs", "amp_slope_xs"], "result": {"wall_s": 1163.6777579180198, "calls": {"search": 0, "warmup": 0, "sampling": 1079204, "evidence": 0}, "min_ess": 7598.732621197994, "logz": -10.61516715926587, "logz_err": 0.2395045382337993, "mean": [43.38669814303522, 13.854741569544217, 4.3100021703444416, 0.4812424126970997, -1.3144481477205971, -1.9260288758673694, 2.3418109659846236], "sd": [1.5450952855955364, 1.0299547198126384, 0.06989485300897316, 0.023197568208786587, 0.22840640060489528, 0.47924151211528293, 0.6517669459551966], "mcse": [0.017724936412327058, 0.011815376104276094, 0.0008018158081787722, 0.00026611654650339565, 0.0026202195842762108, 0.005497735581476941, 0.007476903062492808], "seed": 3040, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/n40ca_gp/44.json b/benchmarks/results/hpc/ref/n40ca_gp/44.json new file mode 100644 index 0000000..10349c0 --- /dev/null +++ b/benchmarks/results/hpc/ref/n40ca_gp/44.json @@ -0,0 +1 @@ +{"problem": "n40ca_gp", "part": "dynesty", "names": ["Vv", "Wv", "Rv", "av", "log_ell_xs", "log_A_xs", "amp_slope_xs"], "result": {"wall_s": 1211.2422900719102, "calls": {"search": 0, "warmup": 0, "sampling": 1122376, "evidence": 0}, "min_ess": 7763.444818745141, "logz": -11.457875374844054, "logz_err": 0.2513213734621126, "mean": [43.64146099413022, 13.702041241848734, 4.296053521227209, 0.4847617523420827, -1.2721553299166675, -1.8085806335150139, 2.2432579907636114], "sd": [1.6160234669765443, 1.0685310497843297, 0.07170117133468697, 0.02479498231169865, 0.21033434278980023, 0.4848866737640874, 0.6590504287373449], "mcse": [0.018340890914346215, 0.012127182447017451, 0.0008137650156409696, 0.00028140808292396503, 0.002387167832324815, 0.005503171068404038, 0.007479824561669061], "seed": 3041, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/n40ca_gp/45.json b/benchmarks/results/hpc/ref/n40ca_gp/45.json new file mode 100644 index 0000000..7e00b2b --- /dev/null +++ b/benchmarks/results/hpc/ref/n40ca_gp/45.json @@ -0,0 +1 @@ +{"problem": "n40ca_gp", "part": "dynesty", "names": ["Vv", "Wv", "Rv", "av", "log_ell_xs", "log_A_xs", "amp_slope_xs"], "result": {"wall_s": 1253.7491824120516, "calls": {"search": 0, "warmup": 0, "sampling": 1146000, "evidence": 0}, "min_ess": 8137.341875531039, "logz": -11.53699073324621, "logz_err": 0.23903132168741692, "mean": [43.66416187414712, 13.68025738193878, 4.293621140388393, 0.48568940876829236, -1.267426398050301, -1.7391961740590336, 2.1474404138059358], "sd": [1.7445494460436446, 1.111245865314263, 0.07169922031790557, 0.027337789908082995, 0.2055249241557467, 0.46838123393190634, 0.6717956141693314], "mcse": [0.019339355733216625, 0.012318813402002601, 0.0007948279887777736, 0.0003030554652327864, 0.0022783645538418944, 0.005192281206081376, 0.0074472491404009265], "seed": 3042, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/n40ca_gp/46.json b/benchmarks/results/hpc/ref/n40ca_gp/46.json new file mode 100644 index 0000000..e09b3e4 --- /dev/null +++ b/benchmarks/results/hpc/ref/n40ca_gp/46.json @@ -0,0 +1 @@ +{"problem": "n40ca_gp", "part": "dynesty", "names": ["Vv", "Wv", "Rv", "av", "log_ell_xs", "log_A_xs", "amp_slope_xs"], "result": {"wall_s": 1242.398315712111, "calls": {"search": 0, "warmup": 0, "sampling": 1157911, "evidence": 0}, "min_ess": 8493.841915407113, "logz": -11.77475482955212, "logz_err": 0.2387268524010463, "mean": [43.71241974242191, 13.706419292203684, 4.2910124508836045, 0.4864393779388837, -1.2650822364979029, -1.7537880077009589, 2.1741985892648517], "sd": [1.7375799786159203, 1.0977543278669337, 0.07669028135021949, 0.027743100918445267, 0.2064243668119189, 0.49137256325013706, 0.6782438031463593], "mcse": [0.018853531758731827, 0.01191113291959689, 0.0008321243757505591, 0.000301025242399635, 0.002239798111949172, 0.005331615431011874, 0.007359253237349534], "seed": 3043, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/n40ca_gp/47.json b/benchmarks/results/hpc/ref/n40ca_gp/47.json new file mode 100644 index 0000000..cfccc7a --- /dev/null +++ b/benchmarks/results/hpc/ref/n40ca_gp/47.json @@ -0,0 +1 @@ +{"problem": "n40ca_gp", "part": "dynesty", "names": ["Vv", "Wv", "Rv", "av", "log_ell_xs", "log_A_xs", "amp_slope_xs"], "result": {"wall_s": 1218.6381054650992, "calls": {"search": 0, "warmup": 0, "sampling": 1119838, "evidence": 0}, "min_ess": 8157.414890783402, "logz": -11.280988084099477, "logz_err": 0.2371353816734623, "mean": [43.54083351383592, 13.66172692112492, 4.294814154790625, 0.4862289553737458, -1.2687101912774832, -1.7432954703772157, 2.154285568188953], "sd": [2.19635004879517, 1.096538275895466, 0.0743925993218794, 0.029345701301716192, 0.21043149363689034, 0.462651336638424, 0.6562323545721466], "mcse": [0.024317855998503387, 0.012140806018011895, 0.0008236703974651977, 0.00032491384459489676, 0.002329884875418195, 0.005122447848447467, 0.007265765267607633], "seed": 3044, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/n40ca_gp/48.json b/benchmarks/results/hpc/ref/n40ca_gp/48.json new file mode 100644 index 0000000..4b46762 --- /dev/null +++ b/benchmarks/results/hpc/ref/n40ca_gp/48.json @@ -0,0 +1 @@ +{"problem": "n40ca_gp", "part": "dynesty", "names": ["Vv", "Wv", "Rv", "av", "log_ell_xs", "log_A_xs", "amp_slope_xs"], "result": {"wall_s": 1269.402395599056, "calls": {"search": 0, "warmup": 0, "sampling": 1106331, "evidence": 0}, "min_ess": 8391.33253267555, "logz": -11.204699585550665, "logz_err": 0.24146684704867039, "mean": [43.7597906072468, 13.70728307730612, 4.288839979303332, 0.4871899076285384, -1.2570346984397722, -1.699590966778598, 2.1017890132565995], "sd": [1.671872838274928, 1.1146721669966586, 0.07183420435144602, 0.026620381712219397, 0.20829548994364594, 0.4977524691685829, 0.6896055843881882], "mcse": [0.01825104669810813, 0.012168349952935824, 0.0007841801051642486, 0.00029060214307476253, 0.00227386355405437, 0.005433728780633824, 0.007528098690168018], "seed": 3045, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/n40ca_gp/49.json b/benchmarks/results/hpc/ref/n40ca_gp/49.json new file mode 100644 index 0000000..230518c --- /dev/null +++ b/benchmarks/results/hpc/ref/n40ca_gp/49.json @@ -0,0 +1 @@ +{"problem": "n40ca_gp", "part": "dynesty", "names": ["Vv", "Wv", "Rv", "av", "log_ell_xs", "log_A_xs", "amp_slope_xs"], "result": {"wall_s": 1293.348359940108, "calls": {"search": 0, "warmup": 0, "sampling": 1128920, "evidence": 0}, "min_ess": 7855.156925369317, "logz": -11.495882486616084, "logz_err": 0.2522541870950044, "mean": [43.60955226044399, 13.674868136759324, 4.296526075428371, 0.484485589496908, -1.2662485333973201, -1.7779380637101514, 2.215123180573599], "sd": [1.7451553033059144, 1.0928314827431047, 0.0765258710845322, 0.02716456143663582, 0.20048760634951893, 0.47400999683953887, 0.6657340636169531], "mcse": [0.019690495661137772, 0.01233036024275017, 0.0008634373856013385, 0.00030649632046588485, 0.0022620911362208397, 0.0053482299073464, 0.007511442486688173], "seed": 3046, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/n40ca_gp/5.json b/benchmarks/results/hpc/ref/n40ca_gp/5.json new file mode 100644 index 0000000..a5be477 --- /dev/null +++ b/benchmarks/results/hpc/ref/n40ca_gp/5.json @@ -0,0 +1 @@ +{"problem": "n40ca_gp", "part": "dynesty", "names": ["Vv", "Wv", "Rv", "av", "log_ell_xs", "log_A_xs", "amp_slope_xs"], "result": {"wall_s": 1269.7501324790064, "calls": {"search": 0, "warmup": 0, "sampling": 1155074, "evidence": 0}, "min_ess": 8908.950276145026, "logz": -11.718260344536716, "logz_err": 0.23028881662247125, "mean": [43.85000570485298, 13.674268053457672, 4.28254546995636, 0.489631738400541, -1.2618163122544772, -1.718165743717051, 2.1374332492790957], "sd": [1.8227656525500626, 1.1764136119365507, 0.07685155166161006, 0.03125705634094876, 0.20886987063911486, 0.4946172656041681, 0.6907647215154945], "mcse": [0.019311569384315247, 0.012463693870784985, 0.0008142155137327554, 0.00033115766222235426, 0.0022129037781116697, 0.005240298241319221, 0.00731841245149713], "seed": 3002, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/n40ca_gp/50.json b/benchmarks/results/hpc/ref/n40ca_gp/50.json new file mode 100644 index 0000000..fc638a8 --- /dev/null +++ b/benchmarks/results/hpc/ref/n40ca_gp/50.json @@ -0,0 +1 @@ +{"problem": "n40ca_gp", "part": "dynesty", "names": ["Vv", "Wv", "Rv", "av", "log_ell_xs", "log_A_xs", "amp_slope_xs"], "result": {"wall_s": 1244.0161672239192, "calls": {"search": 0, "warmup": 0, "sampling": 1144438, "evidence": 0}, "min_ess": 8632.3732825954, "logz": -11.321184905190824, "logz_err": 0.2249335752441206, "mean": [43.56480786381398, 13.794718697563699, 4.287949224133771, 0.4915847775113247, -1.276728669789923, -1.763290567709397, 2.188722182040668], "sd": [2.5516528853819738, 1.2107074644011702, 0.07410477893780702, 0.0403161169593581, 0.215735581949076, 0.46529171671157304, 0.6583807027181927], "mcse": [0.027463538260833486, 0.013030891059573243, 0.000797592589230416, 0.00043392391927000735, 0.002321970375760845, 0.005007952663766912, 0.007086176855355774], "seed": 3047, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/n40ca_gp/51.json b/benchmarks/results/hpc/ref/n40ca_gp/51.json new file mode 100644 index 0000000..e703254 --- /dev/null +++ b/benchmarks/results/hpc/ref/n40ca_gp/51.json @@ -0,0 +1 @@ +{"problem": "n40ca_gp", "part": "dynesty", "names": ["Vv", "Wv", "Rv", "av", "log_ell_xs", "log_A_xs", "amp_slope_xs"], "result": {"wall_s": 1299.424837754108, "calls": {"search": 0, "warmup": 0, "sampling": 1176752, "evidence": 0}, "min_ess": 8720.681069263266, "logz": -12.303954991131734, "logz_err": 0.24624768865355226, "mean": [43.82376463048388, 13.635449359332153, 4.284666459665998, 0.48835181508815073, -1.2512036284795955, -1.7308403860960024, 2.1685415890378636], "sd": [1.8622041445754913, 1.1471967038218727, 0.0793073804241348, 0.029096813204289102, 0.20353472645587178, 0.5068687489141555, 0.7236220850852049], "mcse": [0.019941236627195394, 0.012284647199120853, 0.0008492555684227586, 0.0003115804671008833, 0.002179532332118859, 0.005427755968898776, 0.007748838530610208], "seed": 3048, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/n40ca_gp/52.json b/benchmarks/results/hpc/ref/n40ca_gp/52.json new file mode 100644 index 0000000..50c173b --- /dev/null +++ b/benchmarks/results/hpc/ref/n40ca_gp/52.json @@ -0,0 +1 @@ +{"problem": "n40ca_gp", "part": "dynesty", "names": ["Vv", "Wv", "Rv", "av", "log_ell_xs", "log_A_xs", "amp_slope_xs"], "result": {"wall_s": 1251.5673218080774, "calls": {"search": 0, "warmup": 0, "sampling": 1132548, "evidence": 0}, "min_ess": 8456.783535047898, "logz": -11.60903610933466, "logz_err": 0.24180623267430582, "mean": [43.76879587192873, 13.669720584089147, 4.289036258329024, 0.4867802100913037, -1.2480165273423915, -1.7226618779943277, 2.162595752923612], "sd": [1.6609462291858939, 1.0977333618135647, 0.07520060619362715, 0.02626707239058236, 0.2130348169783368, 0.49680293936891107, 0.6789077964039715], "mcse": [0.018061464667473517, 0.011936974226083518, 0.0008177465759409438, 0.0002856334489124361, 0.002316583614920431, 0.005402335475066311, 0.0073825804603155866], "seed": 3049, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/n40ca_gp/6.json b/benchmarks/results/hpc/ref/n40ca_gp/6.json new file mode 100644 index 0000000..4207ff4 --- /dev/null +++ b/benchmarks/results/hpc/ref/n40ca_gp/6.json @@ -0,0 +1 @@ +{"problem": "n40ca_gp", "part": "dynesty", "names": ["Vv", "Wv", "Rv", "av", "log_ell_xs", "log_A_xs", "amp_slope_xs"], "result": {"wall_s": 1202.652240928961, "calls": {"search": 0, "warmup": 0, "sampling": 1105456, "evidence": 0}, "min_ess": 7837.8535568070365, "logz": -11.546373333308322, "logz_err": 0.2547131915439554, "mean": [43.76343629776936, 13.683402872005876, 4.28861353034318, 0.48708101017948474, -1.2606005582047894, -1.7305040360276611, 2.143809272581293], "sd": [1.6692705426300734, 1.0858725940082474, 0.07444447942813548, 0.02746523072931969, 0.2018164103745195, 0.48601019471638235, 0.6757381138448649], "mcse": [0.018855070348793503, 0.012265360004252874, 0.0008408798099828861, 0.00031023063327484266, 0.002279596097800324, 0.005489677183885342, 0.007632728996601908], "seed": 3003, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/n40ca_gp/7.json b/benchmarks/results/hpc/ref/n40ca_gp/7.json new file mode 100644 index 0000000..78c9fa5 --- /dev/null +++ b/benchmarks/results/hpc/ref/n40ca_gp/7.json @@ -0,0 +1 @@ +{"problem": "n40ca_gp", "part": "dynesty", "names": ["Vv", "Wv", "Rv", "av", "log_ell_xs", "log_A_xs", "amp_slope_xs"], "result": {"wall_s": 1251.7241517269285, "calls": {"search": 0, "warmup": 0, "sampling": 1136478, "evidence": 0}, "min_ess": 8594.938790775033, "logz": -11.875079372876257, "logz_err": 0.24797031509799095, "mean": [43.88154286964037, 13.695661332011795, 4.284799330436668, 0.488470746005194, -1.272392498313646, -1.7376565907072437, 2.1491373772572238], "sd": [1.7488280905779696, 1.1393859522381267, 0.07887731850651272, 0.026970848148067928, 0.20553601636500848, 0.48355689937295016, 0.6692137740755333], "mcse": [0.01886364985198015, 0.012289931620541268, 0.0008508063917696047, 0.0002909197527287761, 0.0022170043273944786, 0.0052158631728438905, 0.007218442097479673], "seed": 3004, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/n40ca_gp/8.json b/benchmarks/results/hpc/ref/n40ca_gp/8.json new file mode 100644 index 0000000..143f643 --- /dev/null +++ b/benchmarks/results/hpc/ref/n40ca_gp/8.json @@ -0,0 +1 @@ +{"problem": "n40ca_gp", "part": "dynesty", "names": ["Vv", "Wv", "Rv", "av", "log_ell_xs", "log_A_xs", "amp_slope_xs"], "result": {"wall_s": 1216.5220271740109, "calls": {"search": 0, "warmup": 0, "sampling": 1105726, "evidence": 0}, "min_ess": 8223.98008283527, "logz": -11.48819235752476, "logz_err": 0.24733428869862456, "mean": [43.830053055903676, 13.702027654766338, 4.286167718591822, 0.48757837579502433, -1.2729407248535645, -1.737942847444878, 2.141927747243757], "sd": [1.6738384251851768, 1.131668161720444, 0.07512384263891987, 0.02602157244474594, 0.20776716815457782, 0.47562544715328586, 0.6647076096922615], "mcse": [0.01845748433532866, 0.01247895080759331, 0.0008283936656336226, 0.0002869409368030151, 0.0022910570064039876, 0.005244741134045994, 0.007329757824212557], "seed": 3005, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/n40ca_gp/9.json b/benchmarks/results/hpc/ref/n40ca_gp/9.json new file mode 100644 index 0000000..cc9a51a --- /dev/null +++ b/benchmarks/results/hpc/ref/n40ca_gp/9.json @@ -0,0 +1 @@ +{"problem": "n40ca_gp", "part": "dynesty", "names": ["Vv", "Wv", "Rv", "av", "log_ell_xs", "log_A_xs", "amp_slope_xs"], "result": {"wall_s": 1211.0836269139545, "calls": {"search": 0, "warmup": 0, "sampling": 1110694, "evidence": 0}, "min_ess": 7553.854763849148, "logz": -10.858815703691715, "logz_err": 0.24555390449510403, "mean": [43.066408761053495, 13.849427077915399, 4.321123472418126, 0.4775949022951496, -1.3029579701661682, -1.8826994172752876, 2.285994713916897], "sd": [1.8953224389666694, 1.0898340553515298, 0.07984017683838834, 0.028761218292154247, 0.21093869866744047, 0.4617500283433338, 0.6613726590271967], "mcse": [0.02180714388332016, 0.012539379878259893, 0.0009186227040786271, 0.0003309199599296345, 0.002427012131460384, 0.005312789580911684, 0.0076096016378951106], "seed": 3006, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/omp/0.json b/benchmarks/results/hpc/ref/omp/0.json new file mode 100644 index 0000000..3cf8e10 --- /dev/null +++ b/benchmarks/results/hpc/ref/omp/0.json @@ -0,0 +1 @@ +{"problem": "omp", "part": "pocomc", "names": ["Vv", "Wv", "Rv", "av", "Wd", "Rd", "ad", "log_sigma_A", "log_sigma_B"], "result": {"wall_s": 1346.1900505349913, "calls": {"search": 0, "warmup": 425984, "sampling": 0, "evidence": 4096}, "min_ess": 17818.730547863903, "logz": -6.625555110790021, "logz_err": 0.04285668527886685, "mean": [45.83690023007923, 3.3499479652623574, 3.9593525662306273, 0.7913258315476238, 9.087755914411451, 4.415845255029297, 0.32130909164955024, -1.6348678271767232, -1.8600525749738654], "sd": [2.491160434438235, 1.2563769597671544, 0.13032522516764705, 0.04564899098723714, 1.1476523528968996, 0.10719830112514711, 0.058796732492895146, 0.12081510732177256, 0.8351708187731082], "mcse": [0.018662220539770614, 0.009411992732434543, 0.0009763153188976978, 0.00034197377472957875, 0.008597495776131482, 0.0008030628254327458, 0.0004404684554360088, 0.000905071446305068, 0.006256578979361989], "mode_share": 0.1296755210222584, "mode_share_label": "share away from the MAP island", "seed": 2000}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/omp/1.json b/benchmarks/results/hpc/ref/omp/1.json new file mode 100644 index 0000000..a3d5c62 --- /dev/null +++ b/benchmarks/results/hpc/ref/omp/1.json @@ -0,0 +1 @@ +{"problem": "omp", "part": "pocomc", "names": ["Vv", "Wv", "Rv", "av", "Wd", "Rd", "ad", "log_sigma_A", "log_sigma_B"], "result": {"wall_s": 1377.9200871120265, "calls": {"search": 0, "warmup": 512000, "sampling": 0, "evidence": 4096}, "min_ess": 13507.086287835824, "logz": -6.660922779454295, "logz_err": 0.009755565591117104, "mean": [45.82916664790854, 3.357775211074856, 3.958704981568321, 0.7914083607384362, 9.05659244602436, 4.415832632219078, 0.32232178445231274, -1.6351207382497588, -1.8473968649380048], "sd": [2.5130322877143128, 1.264028838090728, 0.13254790456832388, 0.046000095104070396, 1.1669222119545026, 0.1085316299053715, 0.060097863418464875, 0.12091333500702547, 0.8512827653192674], "mcse": [0.021623063880583528, 0.010876173953895006, 0.0011404914380647147, 0.00039580191619937807, 0.010040632448743342, 0.0009338464841779564, 0.000517104354821477, 0.0010403832770685567, 0.007324753328848158], "mode_share": 0.1324468933466646, "mode_share_label": "share away from the MAP island", "seed": 2001}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/omp/2.json b/benchmarks/results/hpc/ref/omp/2.json new file mode 100644 index 0000000..1d461e3 --- /dev/null +++ b/benchmarks/results/hpc/ref/omp/2.json @@ -0,0 +1 @@ +{"problem": "omp", "part": "pocomc", "names": ["Vv", "Wv", "Rv", "av", "Wd", "Rd", "ad", "log_sigma_A", "log_sigma_B"], "result": {"wall_s": 1586.5622286959842, "calls": {"search": 0, "warmup": 598016, "sampling": 0, "evidence": 4096}, "min_ess": 13425.47794552535, "logz": -6.656413852176085, "logz_err": 0.012252888546165389, "mean": [45.79403551835792, 3.345909019848918, 3.9608865443221863, 0.7909252308089381, 9.056711853297045, 4.416467482496564, 0.3222719585403955, -1.6337756400776575, -1.8522651748435808], "sd": [2.5353109583264497, 1.2561976608776715, 0.1324330480971392, 0.04583708004348447, 1.1757466837087716, 0.10943575916427457, 0.06072694521457943, 0.12000111958333923, 0.8518679325415246], "mcse": [0.021880959174697904, 0.010841593076676986, 0.001142961225043223, 0.0003955961590529683, 0.010147262252595646, 0.0009444835043454411, 0.0005241028934460337, 0.001035667672203148, 0.007352032062559854], "mode_share": 0.13105860196711935, "mode_share_label": "share away from the MAP island", "seed": 2002}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/omp/3.json b/benchmarks/results/hpc/ref/omp/3.json new file mode 100644 index 0000000..e01d969 --- /dev/null +++ b/benchmarks/results/hpc/ref/omp/3.json @@ -0,0 +1 @@ +{"problem": "omp", "part": "dynesty", "names": ["Vv", "Wv", "Rv", "av", "Wd", "Rd", "ad", "log_sigma_A", "log_sigma_B"], "result": {"wall_s": 2540.7718005697243, "calls": {"search": 0, "warmup": 0, "sampling": 1097096, "evidence": 0}, "min_ess": 7520.35311325527, "logz": -6.212821986919609, "logz_err": 0.2316291405838807, "mean": [46.34507836399587, 3.3021781072839422, 3.934218827283109, 0.7990678859085422, 9.238897902898843, 4.425344550945001, 0.3167147188606561, -1.644011282984124, -1.9133246581639793], "sd": [2.434282497135053, 1.2386771011002746, 0.12274874132356249, 0.04268930863897815, 1.0051456817187017, 0.08650722043039001, 0.04933484603646904, 0.12045464107179688, 0.8281524165783354], "mcse": [0.028070610617791997, 0.014283643179081746, 0.001415461075521439, 0.0004922661859327404, 0.011590706123421385, 0.0009975467116848176, 0.0005688983323046133, 0.0013890069581536805, 0.009549731407637936], "mode_share": 0.08722285490287002, "mode_share_label": "share away from the MAP island", "seed": 3000, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/omp/4.json b/benchmarks/results/hpc/ref/omp/4.json new file mode 100644 index 0000000..37e63bb --- /dev/null +++ b/benchmarks/results/hpc/ref/omp/4.json @@ -0,0 +1 @@ +{"problem": "omp", "part": "dynesty", "names": ["Vv", "Wv", "Rv", "av", "Wd", "Rd", "ad", "log_sigma_A", "log_sigma_B"], "result": {"wall_s": 2837.3212025309913, "calls": {"search": 0, "warmup": 0, "sampling": 1165635, "evidence": 0}, "min_ess": 8912.71068461286, "logz": -6.710243989484923, "logz_err": 0.22312147252441222, "mean": [45.65211872111922, 3.2409399617911943, 3.969588516259301, 0.7871140282685902, 9.051565913971437, 4.41269035842489, 0.32608005075093294, -1.6219744519558736, -1.8837595212440095], "sd": [2.5037838849794296, 1.2385052790626514, 0.13098277120937696, 0.04559884633123559, 1.2269570213319905, 0.11099359625871304, 0.062424531595431036, 0.12447294806937895, 0.8353099133405114], "mcse": [0.026521124562721817, 0.013118765151681205, 0.0013874242148670588, 0.0004830020237457697, 0.012996441182909518, 0.0011756905257284086, 0.0006612267089599835, 0.0013184694494765966, 0.008847951451833102], "mode_share": 0.1451228032396339, "mode_share_label": "share away from the MAP island", "seed": 3001, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/ref/omp/5.json b/benchmarks/results/hpc/ref/omp/5.json new file mode 100644 index 0000000..eb5c93b --- /dev/null +++ b/benchmarks/results/hpc/ref/omp/5.json @@ -0,0 +1 @@ +{"problem": "omp", "part": "dynesty", "names": ["Vv", "Wv", "Rv", "av", "Wd", "Rd", "ad", "log_sigma_A", "log_sigma_B"], "result": {"wall_s": 2781.856348440051, "calls": {"search": 0, "warmup": 0, "sampling": 1127665, "evidence": 0}, "min_ess": 8556.781458492615, "logz": -6.288459462305533, "logz_err": 0.21569970074017808, "mean": [45.65100266976815, 3.3925588661438257, 3.9680694750483583, 0.7908226853725405, 9.060707974114234, 4.415671850026497, 0.3180883624347295, -1.629639454867176, -1.8004310167938267], "sd": [2.456123619680096, 1.2755564106152009, 0.12691766032048202, 0.04585633638371601, 1.050953994928581, 0.10488785015375705, 0.05812108349729781, 0.11975320742314625, 0.8903757644654113], "mcse": [0.02655186317877306, 0.01378937078740074, 0.001372040203838907, 0.0004957287816395846, 0.011361311970186245, 0.0011338874900608397, 0.000628316524647606, 0.0012945890643455292, 0.009625385011712183], "mode_share": 0.12994420543338278, "mode_share_label": "share away from the MAP island", "seed": 3002, "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}"}} \ No newline at end of file diff --git a/benchmarks/results/hpc/references.json b/benchmarks/results/hpc/references.json new file mode 100644 index 0000000..6232738 --- /dev/null +++ b/benchmarks/results/hpc/references.json @@ -0,0 +1,3225 @@ +{ + "alpha_gp": { + "method": "pocomc 8192/4096, 3 runs", + "mean": [ + 156.9170972879033, + 27.07571915721705, + 1.2949630285001958, + 0.608655451717469, + -0.722236205967922, + -0.9273783501780407, + -3.708988419572021, + 0.36915994303880567, + 8.001448305491236 + ], + "sd": [ + 20.166197160230762, + 2.4278582406642055, + 0.02580757990512527, + 0.016824137006172777, + 0.10522303757128866, + 0.7559634352193809, + 0.2837410231660738, + 0.23341443601937567, + 3.367323057781327 + ], + "logz": -84.52693306054154, + "logz_err": 0.014698470842069744, + "mode_share": 0.740026772601546, + "mode_share_label": "share in the deeper family", + "max_disagreement": 0.0124517596188911, + "accepted": true, + "runs": [ + { + "seed": 2000, + "mean": [ + 156.8785555103583, + 27.084545266633093, + 1.2949127736646193, + 0.6087120605094569, + -0.7227072567074655, + -0.9316473871610929, + -3.7103949456299055, + 0.3687829414566313, + 8.009230708265191 + ], + "sd": [ + 20.209887821553867, + 2.4362592655920334, + 0.02591123388018143, + 0.016808298456851233, + 0.10518896180442683, + 0.7578834072315861, + 0.28290802006322957, + 0.2340100304599236, + 3.386179474805629 + ], + "logz": -84.53085505152227, + "logz_err": 0.010752965731570916, + "wall_s": 1916.138335942058, + "mode_share": 0.7388912281610726 + }, + { + "seed": 2001, + "mean": [ + 156.87994947919742, + 27.07086370722465, + 1.2948506648103246, + 0.6088069645653363, + -0.7223079285328061, + -0.9227154032774394, + -3.7081077138705, + 0.37081806005134144, + 8.020414799227787 + ], + "sd": [ + 20.2181779157913, + 2.4194654122845995, + 0.02581627166683903, + 0.016793939425374386, + 0.10580297106742258, + 0.7545306780598743, + 0.28452537496843255, + 0.23052603572312544, + 3.369362709178061 + ], + "logz": -84.5240567170944, + "logz_err": 0.014698470842069744, + "wall_s": 1860.9660312659107, + "mode_share": 0.7385990858823233 + }, + { + "seed": 2002, + "mean": [ + 156.99278687415418, + 27.071748497793408, + 1.2951256470256431, + 0.6084473300776139, + -0.7216934326634947, + -0.9277722600955896, + -3.708462599215657, + 0.3678788276084441, + 7.9746994089807295 + ], + "sd": [ + 20.069968743865562, + 2.427796856847879, + 0.025693968587523815, + 0.01686801660700836, + 0.10467165279680032, + 0.7554457096046183, + 0.28378202448329254, + 0.23566802198365705, + 3.346138285794625 + ], + "logz": -84.52588741300796, + "logz_err": 0.013892527125909937, + "wall_s": 1778.2113279250334, + "mode_share": 0.7425900037612424 + } + ], + "names": [ + "V", + "W", + "r", + "a", + "log_sigma_A", + "log_sigma_B", + "log_ell", + "log_A_q", + "p" + ], + "corroboration": { + "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}, 50 runs pooled", + "mean": [ + 157.84862923859987, + 27.15899635059207, + 1.2942094127035682, + 0.6083999304307361, + -0.7233850729641486, + -0.92866986779389, + -3.7097575917384233, + 0.3712189128397781, + 8.050595127754706 + ], + "sd": [ + 20.046456307989263, + 2.440779789417403, + 0.02557497390105194, + 0.016985898053751256, + 0.10618886321822738, + 0.760490038346363, + 0.2891812457383863, + 0.23540763952744176, + 3.382462196834573 + ], + "logz": -84.49533387047751, + "logz_err": 0.816513932031647, + "mode_share": 0.7556519883749424, + "mode_share_label": "share in the deeper family", + "bias": 0.046192742404285864, + "width": 0.018991707545024068, + "logz_combined_err": 0.816646218534609, + "checks": { + "log Z": true, + "moments": true, + "mode share": true + }, + "runs": [ + { + "seed": 3000, + "mean": [ + 155.0363082727781, + 26.96539502958844, + 1.2956310782922478, + 0.6100767794597716, + -0.7187127856976515, + -0.9237462379140806, + -3.715516036567462, + 0.3599844485481908, + 7.936014178529925 + ], + "sd": [ + 20.94112355426644, + 2.477375170861742, + 0.025896217223534412, + 0.017472846296503423, + 0.10737074155989607, + 0.7614975431419349, + 0.2960561666556353, + 0.2387152145491169, + 3.3654879919721172 + ], + "logz": -85.01107970830559, + "logz_err": 0.23611497500574624, + "wall_s": 2693.0728099420667, + "mode_share": 0.694953866005275 + }, + { + "seed": 3001, + "mean": [ + 148.75030343708653, + 26.451619379396192, + 1.3002841100864992, + 0.6126134761458646, + -0.7193340209575875, + -0.8920772452925648, + -3.6971926192482827, + 0.3710694794025508, + 7.966812618096597 + ], + "sd": [ + 22.717944614091152, + 2.576690930978656, + 0.026778478536716104, + 0.017317696364374514, + 0.10620310818411594, + 0.7580134725131048, + 0.2983931036008246, + 0.23684614176087893, + 3.3405251605008126 + ], + "logz": -84.74751070345754, + "logz_err": 0.24083548954130415, + "wall_s": 2636.1515113138594, + "mode_share": 0.5538147037815653 + }, + { + "seed": 3002, + "mean": [ + 159.62198959223858, + 27.321985375758146, + 1.2930118520546583, + 0.6074286498983196, + -0.7211987452398998, + -0.8981363214501887, + -3.7165815372794855, + 0.36229233802144495, + 8.006574912874683 + ], + "sd": [ + 18.250330092532945, + 2.356832851685547, + 0.02475406477745071, + 0.016684462868590967, + 0.10694245590346353, + 0.7762582246018198, + 0.2896553926023016, + 0.23831390376500267, + 3.3513333656815933 + ], + "logz": -84.96554847346898, + "logz_err": 0.23441027840668432, + "wall_s": 2748.1917490730993, + "mode_share": 0.8027537260999038 + }, + { + "seed": 3003, + "mean": [ + 173.14246638872424, + 28.281369517831635, + 1.2887566528236576, + 0.5997921312787519, + -0.7384473729868871, + -1.1195125608013665, + -3.7175619872768, + 0.37385735261995184, + 8.02609561265403 + ], + "sd": [ + 24.223874026616325, + 2.4583109451594374, + 0.021557059451404088, + 0.019590565119377817, + 0.10829455554598387, + 0.8101921326740164, + 0.27328127476454644, + 0.2103319464714634, + 3.1892977129968876 + ], + "logz": -84.1225660277727, + "logz_err": 0.23617010472374617, + "wall_s": 2984.7373787555844, + "mode_share": 0.9046727236311667 + }, + { + "seed": 3004, + "mean": [ + 161.3437253760176, + 27.52356842262279, + 1.2911510908860964, + 0.6072977460206239, + -0.7236321333295125, + -0.9206903359234555, + -3.728978418081405, + 0.3608831487372646, + 8.115511692053937 + ], + "sd": [ + 17.13508311375271, + 2.2669489646131464, + 0.024126638833439414, + 0.015986557083297666, + 0.10382582058208888, + 0.7393336790116669, + 0.28256036641792415, + 0.24292216607614814, + 3.4168138881395236 + ], + "logz": -84.50191198965852, + "logz_err": 0.23907937103614066, + "wall_s": 2764.8887593662366, + "mode_share": 0.8378594299359057 + }, + { + "seed": 3005, + "mean": [ + 163.18726931649934, + 27.642603898357127, + 1.2894704931300205, + 0.6069508002916163, + -0.7194440900708137, + -0.9242497377694652, + -3.7221442121012873, + 0.35938301890513114, + 7.91808975724129 + ], + "sd": [ + 15.157956097192223, + 2.2368342186470134, + 0.02340221655337931, + 0.01640354511042065, + 0.10834743262079445, + 0.7606404606023083, + 0.29112107424180533, + 0.23530974300351196, + 3.347862010890444 + ], + "logz": -85.19284963807665, + "logz_err": 0.24014555565239531, + "wall_s": 2820.0456958909926, + "mode_share": 0.8767547506252499 + }, + { + "seed": 3006, + "mean": [ + 159.53485490427767, + 27.28674866076614, + 1.2929778612141096, + 0.6077288939164318, + -0.7269578702030975, + -0.9063900071764145, + -3.7060132265569683, + 0.37703326064266895, + 8.014746367361827 + ], + "sd": [ + 18.670126735050363, + 2.431458816999211, + 0.025822257982887085, + 0.01624059162574942, + 0.10717939477269488, + 0.7618372068682919, + 0.2894011289402667, + 0.23107712819421916, + 3.381885689612925 + ], + "logz": -84.48467558283114, + "logz_err": 0.23414002268649434, + "wall_s": 2798.0343245019903, + "mode_share": 0.7976430964287943 + }, + { + "seed": 3007, + "mean": [ + 160.99841770026336, + 27.40448536891458, + 1.2911358112376625, + 0.6076928068655332, + -0.7224908084477776, + -0.9052122766138084, + -3.7110756601273396, + 0.3769317063569782, + 8.053636608850468 + ], + "sd": [ + 17.515780354746326, + 2.3820585663356977, + 0.02465902171266932, + 0.01644394549904426, + 0.10593060232317225, + 0.7520234578269029, + 0.28109033999369437, + 0.22969777163443195, + 3.378046979895328 + ], + "logz": -84.02183755119567, + "logz_err": 0.23912199981526341, + "wall_s": 2875.0876061839517, + "mode_share": 0.8278044572654997 + }, + { + "seed": 3008, + "mean": [ + 159.22010953303044, + 27.28697256437662, + 1.2923225529808018, + 0.6085520806862227, + -0.7216569112134016, + -0.9452581880320303, + -3.7080525102909463, + 0.3784186184267962, + 8.079298532003122 + ], + "sd": [ + 19.0849984756615, + 2.38339983958914, + 0.025899672555182413, + 0.01653809553346347, + 0.10576194562063879, + 0.7640031085732, + 0.29374600487673524, + 0.23306747437997172, + 3.3574979668693827 + ], + "logz": -84.1551222001456, + "logz_err": 0.22741348205969047, + "wall_s": 2682.265818547923, + "mode_share": 0.7860332718680059 + }, + { + "seed": 3009, + "mean": [ + 155.3063553799417, + 26.991669968116433, + 1.2958127687969154, + 0.6095871157701005, + -0.721502163939222, + -0.9285800365826257, + -3.7088418547748923, + 0.3736231905042132, + 8.12145894564049 + ], + "sd": [ + 20.933757024793053, + 2.461757397608303, + 0.02587346135106598, + 0.016589550936467797, + 0.10783832140394009, + 0.7509432638738239, + 0.2851112750837159, + 0.23368103947136057, + 3.393014751854307 + ], + "logz": -84.63961945228941, + "logz_err": 0.23878867437925277, + "wall_s": 2833.55410412699, + "mode_share": 0.7034441077229117 + }, + { + "seed": 3010, + "mean": [ + 163.12063951664535, + 27.538722614483063, + 1.2906840103073172, + 0.6059377206585473, + -0.7287969042137526, + -0.9418116317895356, + -3.71035896549328, + 0.3726765712953878, + 8.158332744388572 + ], + "sd": [ + 15.176868883888108, + 2.2241353016290057, + 0.02407315695963394, + 0.016690477563964697, + 0.10812708542728128, + 0.7676258698171972, + 0.29151031769107444, + 0.232880822730492, + 3.412121349630975 + ], + "logz": -84.79868345852779, + "logz_err": 0.22890025543128578, + "wall_s": 2788.0256429337896, + "mode_share": 0.8791872711094684 + }, + { + "seed": 3011, + "mean": [ + 156.34340835517068, + 26.9621430423351, + 1.2958335533590637, + 0.6085424439599016, + -0.7248357296876888, + -0.9162144545947323, + -3.7005144391002958, + 0.38429932864786626, + 8.246337608877598 + ], + "sd": [ + 20.357997226227745, + 2.429216502065792, + 0.02559795627949606, + 0.016686663518461587, + 0.10676431540922625, + 0.7542851347764941, + 0.28526514804634256, + 0.22659698890394125, + 3.399688583913854 + ], + "logz": -84.7037004903802, + "logz_err": 0.2275487879017086, + "wall_s": 2591.552704587113, + "mode_share": 0.7284700240201466 + }, + { + "seed": 3012, + "mean": [ + 156.66773258934546, + 27.049494135389804, + 1.294725645933369, + 0.6090813365532447, + -0.723103710053029, + -0.9435031920724252, + -3.7029278734053137, + 0.3767836692513785, + 8.11823521992168 + ], + "sd": [ + 20.175779855338536, + 2.4278164990104085, + 0.02532967501218099, + 0.016927693069028804, + 0.1086198068994079, + 0.7519929921298538, + 0.28982154251355335, + 0.23521467134134671, + 3.393308009293439 + ], + "logz": -84.3482874109922, + "logz_err": 0.2283969344261856, + "wall_s": 2663.0582647961564, + "mode_share": 0.7332125433989597 + }, + { + "seed": 3013, + "mean": [ + 158.4363255688864, + 27.122474485645547, + 1.294058583286062, + 0.6079366902986453, + -0.7225725457281809, + -0.927812087338135, + -3.705742905091299, + 0.3732395133443839, + 8.00935753084637 + ], + "sd": [ + 19.02440802805679, + 2.374281658178547, + 0.02496746896599317, + 0.017337788181584136, + 0.10664130226507859, + 0.7722263538053604, + 0.2959703683648675, + 0.23809916192720723, + 3.3774639360211114 + ], + "logz": -84.68381281074666, + "logz_err": 0.23592999865689412, + "wall_s": 2724.6785172251984, + "mode_share": 0.7737825532805336 + }, + { + "seed": 3014, + "mean": [ + 159.4361076772126, + 27.318086703146246, + 1.2926825155098831, + 0.607962569664182, + -0.7230544878020726, + -0.9202604381852815, + -3.7125013165110627, + 0.3696464387958733, + 8.032565301625526 + ], + "sd": [ + 18.48958792436217, + 2.3891832591227518, + 0.024925457386213393, + 0.016676005717332534, + 0.10517075511211202, + 0.7372023200010842, + 0.2913945385189369, + 0.23558498851021087, + 3.4129822665421052 + ], + "logz": -84.59475259337496, + "logz_err": 0.2318495493991218, + "wall_s": 5655.227152842097, + "mode_share": 0.7951815963513276 + }, + { + "seed": 3015, + "mean": [ + 158.90815787851167, + 27.259131686125784, + 1.293588248420121, + 0.6077544263540835, + -0.7240603409065712, + -0.9327995527177698, + -3.717255687865592, + 0.35984242804981303, + 7.841435301852021 + ], + "sd": [ + 19.133565580435416, + 2.391146004912704, + 0.02594498458356838, + 0.01674481137835389, + 0.10739101659151623, + 0.7674238234602426, + 0.28998315613891046, + 0.23836863447709725, + 3.371956388654496 + ], + "logz": -84.72212122120276, + "logz_err": 0.23866911548468148, + "wall_s": 2791.7348075599875, + "mode_share": 0.7837920320960401 + }, + { + "seed": 3016, + "mean": [ + 155.65902820576855, + 27.053865514549866, + 1.2952513604608893, + 0.6095459095312298, + -0.7188957924452078, + -0.9014855509084173, + -3.7078559250895418, + 0.3664551054444499, + 8.127685150973287 + ], + "sd": [ + 20.76699436667709, + 2.460630449620805, + 0.026107378314423325, + 0.016928751474699032, + 0.10495530003633355, + 0.7660314240971486, + 0.2844068755705314, + 0.23357235991707903, + 3.426033858269698 + ], + "logz": -84.53754787096658, + "logz_err": 0.23915838802686723, + "wall_s": 2662.824847020209, + "mode_share": 0.7110701495814729 + }, + { + "seed": 3017, + "mean": [ + 162.87289434749212, + 27.562163538849614, + 1.2896902662458951, + 0.6069853178171145, + -0.7213863229694062, + -0.9478921087533881, + -3.7173890508422374, + 0.3712604347708056, + 7.970890168843371 + ], + "sd": [ + 15.681430990115018, + 2.2355723847146978, + 0.023841706750082996, + 0.016368034993680395, + 0.10753382804443266, + 0.7639244886936757, + 0.2883086795381806, + 0.2329423578615634, + 3.35462882141772 + ], + "logz": -84.49067148958065, + "logz_err": 0.23630519764477265, + "wall_s": 2657.477834840771, + "mode_share": 0.869687654115215 + }, + { + "seed": 3018, + "mean": [ + 160.45248776501742, + 27.451343664407545, + 1.2913198959788585, + 0.607927775489163, + -0.7205990488822087, + -0.9230105704226366, + -3.7319431723356775, + 0.36656857757757405, + 8.146590818169635 + ], + "sd": [ + 17.88424872458873, + 2.321277403237323, + 0.024920810655904842, + 0.016370488863966127, + 0.10531645561120542, + 0.7602098020413204, + 0.28828287544879616, + 0.2371761150687841, + 3.409337469292532 + ], + "logz": -84.76937622756702, + "logz_err": 0.239538051595605, + "wall_s": 2772.1560445260257, + "mode_share": 0.8182102396841809 + }, + { + "seed": 3019, + "mean": [ + 164.60256063825253, + 27.713015008578004, + 1.2883734247675516, + 0.6063434373251843, + -0.7265948916235251, + -0.937881514684631, + -3.719797462134813, + 0.37581820082739303, + 8.201032989915898 + ], + "sd": [ + 13.579583572251558, + 2.1606520864128087, + 0.02307750371919603, + 0.015841768580661098, + 0.10330211383384788, + 0.7529764160581467, + 0.288344378960387, + 0.23138549559386834, + 3.3729443879902576 + ], + "logz": -84.46573777254066, + "logz_err": 0.23492200029583196, + "wall_s": 2639.407041187864, + "mode_share": 0.9083280695994057 + }, + { + "seed": 3020, + "mean": [ + 146.55838074020497, + 26.32895606447688, + 1.3024245397484546, + 0.6129995512360802, + -0.7224867126448545, + -0.8837401972498717, + -3.699122678451525, + 0.36705607651478855, + 7.97405256799699 + ], + "sd": [ + 22.84734863072531, + 2.5878360122878257, + 0.026858637241359277, + 0.017005644654438344, + 0.1067017663624111, + 0.7494707890565813, + 0.2869151480565618, + 0.2441022764045477, + 3.400163929762545 + ], + "logz": -84.50026414841236, + "logz_err": 0.22858285202275816, + "wall_s": 2616.0876129330136, + "mode_share": 0.5071786542764218 + }, + { + "seed": 3021, + "mean": [ + 163.72492191937937, + 27.540286568433807, + 1.2904416376485046, + 0.6054901226946344, + -0.7250171023069939, + -0.961549592941256, + -3.6999093627589628, + 0.37129286447563337, + 7.972728338275005 + ], + "sd": [ + 14.727135239545376, + 2.2564701683285797, + 0.024786165989858496, + 0.016469882132660832, + 0.10462320127761035, + 0.7706081603950512, + 0.28814244172641246, + 0.23389705880309952, + 3.389897831205568 + ], + "logz": -84.30704401259557, + "logz_err": 0.23587012516629077, + "wall_s": 2591.661661247257, + "mode_share": 0.8932163016391246 + }, + { + "seed": 3022, + "mean": [ + 160.21766525830947, + 27.313514432388, + 1.2925351109505705, + 0.6073890343759074, + -0.7256711509789673, + -0.9322040878728046, + -3.705073869424344, + 0.3865559477192151, + 8.105254817274268 + ], + "sd": [ + 17.822194342007702, + 2.244328412536697, + 0.024129469546859544, + 0.016636411221425205, + 0.10649021450411267, + 0.7532508909943384, + 0.2822159477991818, + 0.2291443137655243, + 3.2613381289846717 + ], + "logz": -84.22419406647667, + "logz_err": 0.23224760901652927, + "wall_s": 2562.6737098312005, + "mode_share": 0.8134049287207986 + }, + { + "seed": 3023, + "mean": [ + 154.22988987565546, + 26.927461302211317, + 1.2963887386832178, + 0.610265399191069, + -0.7231248241213648, + -0.9126387114834102, + -3.7158152774847664, + 0.3738851388481331, + 8.11069680858564 + ], + "sd": [ + 21.33662109686993, + 2.5339009386142095, + 0.025908671020789493, + 0.016979360175675237, + 0.10650692509679446, + 0.7561399977115059, + 0.28659620248790174, + 0.23309301117133088, + 3.4119361147571983 + ], + "logz": -84.9828288881904, + "logz_err": 0.23875739824540043, + "wall_s": 2741.4676114018075, + "mode_share": 0.6777895412758969 + }, + { + "seed": 3024, + "mean": [ + 153.62055618632968, + 26.78417521683285, + 1.2983997061220276, + 0.6091171502671576, + -0.7207140402042328, + -0.9279144258263111, + -3.7029138319680888, + 0.358028228024975, + 7.884837726452231 + ], + "sd": [ + 21.418791790805358, + 2.5061968492033784, + 0.026676770150008116, + 0.01775121332451289, + 0.10555358799973781, + 0.7723886301621866, + 0.2955302296053888, + 0.2428768988573913, + 3.425730933348549 + ], + "logz": -84.72469695690226, + "logz_err": 0.23936774564758748, + "wall_s": 2635.870913216844, + "mode_share": 0.6706497531359986 + }, + { + "seed": 3025, + "mean": [ + 155.3576330437849, + 26.94617303566052, + 1.296610789764296, + 0.6091593571015939, + -0.7206946249844651, + -0.9254255865884787, + -3.694660804017364, + 0.37001508060250554, + 8.07872917383517 + ], + "sd": [ + 22.366650436309534, + 2.4992487728774417, + 0.02553909732559296, + 0.0181570293768271, + 0.10382835995910406, + 0.7486266139364461, + 0.286142680636899, + 0.2346736304310194, + 3.360642916891107 + ], + "logz": -84.50728259179247, + "logz_err": 0.22434070797818934, + "wall_s": 2658.734697677195, + "mode_share": 0.6855985536856692 + }, + { + "seed": 3026, + "mean": [ + 154.54072461447373, + 26.914751300759693, + 1.2969848078603279, + 0.6092677558957659, + -0.721409660794297, + -0.9437119118371886, + -3.7100469076622793, + 0.37070023394227325, + 8.135548453703366 + ], + "sd": [ + 21.38432766637463, + 2.5286046684885575, + 0.026908408569110236, + 0.016581203914590684, + 0.10492436403182637, + 0.7505003562953333, + 0.2849957169049016, + 0.23777428798370717, + 3.400264013507102 + ], + "logz": -84.5659866724663, + "logz_err": 0.22222493555329073, + "wall_s": 2727.274063028861, + "mode_share": 0.6895252185289699 + }, + { + "seed": 3027, + "mean": [ + 158.3803404233768, + 27.178685941151443, + 1.2949186995599027, + 0.6071124698220179, + -0.723646901941957, + -0.9389026817546344, + -3.7168921264751167, + 0.36057340121547043, + 7.975897703914162 + ], + "sd": [ + 19.138801814592295, + 2.4569447853339894, + 0.02611028455845442, + 0.01711408357089224, + 0.10656539004901021, + 0.7563270654057285, + 0.28594727783815826, + 0.24152687275029433, + 3.424021606875366 + ], + "logz": -84.43234300513713, + "logz_err": 0.23863017482663604, + "wall_s": 2653.8005257407203, + "mode_share": 0.777800094931181 + }, + { + "seed": 3028, + "mean": [ + 163.6297554708925, + 27.696209654765973, + 1.2890011679086453, + 0.6067998429217873, + -0.7225732505197283, + -0.9365985993968523, + -3.712197347207983, + 0.3692444518973431, + 8.05133841367845 + ], + "sd": [ + 14.847590009878896, + 2.1579149531552937, + 0.02319226106022582, + 0.01575061636979743, + 0.10477785710033082, + 0.7659724876929488, + 0.2898552173731284, + 0.23408042679005098, + 3.363454982587375 + ], + "logz": -84.06077143325636, + "logz_err": 0.22574277783005617, + "wall_s": 2659.12876476394, + "mode_share": 0.8873748837963811 + }, + { + "seed": 3029, + "mean": [ + 157.64167454846213, + 27.16640705731838, + 1.2946400716449256, + 0.6080855957317933, + -0.7189055134903761, + -0.9177480335414973, + -3.7097871208263427, + 0.37054039834703895, + 8.154966941504673 + ], + "sd": [ + 19.57786160190162, + 2.438559962025036, + 0.025529856372291625, + 0.017037402397691987, + 0.10612861083521659, + 0.7678025140092074, + 0.2915458336624528, + 0.2369307056137222, + 3.445883729019674 + ], + "logz": -84.5774665986919, + "logz_err": 0.23101144709837396, + "wall_s": 2633.308246606961, + "mode_share": 0.7583224350931193 + }, + { + "seed": 3030, + "mean": [ + 160.7431706871559, + 27.42808702025613, + 1.2915181033677408, + 0.6077355350387634, + -0.7248430749634354, + -0.933013592378232, + -3.7345306991035634, + 0.36556313698926457, + 7.952697011716893 + ], + "sd": [ + 17.63030498064033, + 2.304080797800829, + 0.025021653964747925, + 0.016769433181065434, + 0.10598101000185044, + 0.766779293068402, + 0.2929550925746424, + 0.2402676045627046, + 3.3831325455230994 + ], + "logz": -84.45700670817473, + "logz_err": 0.23443255365848842, + "wall_s": 2675.2336292089894, + "mode_share": 0.8228406394949976 + }, + { + "seed": 3031, + "mean": [ + 153.75434981953427, + 26.847094001202066, + 1.2970580230285036, + 0.6101631617186526, + -0.7221286693512192, + -0.8999063715191188, + -3.7100628039203403, + 0.36973945029726707, + 8.044145282950854 + ], + "sd": [ + 21.40052061912164, + 2.506002759950248, + 0.026184786621634662, + 0.017407823430158783, + 0.10675487987423898, + 0.7442607833307798, + 0.2903581217296295, + 0.23608917536402632, + 3.412200063287317 + ], + "logz": -84.57010470850983, + "logz_err": 0.23267183873739863, + "wall_s": 2595.760058631975, + "mode_share": 0.6681328808597061 + }, + { + "seed": 3032, + "mean": [ + 149.03798151917238, + 26.455418414041556, + 1.3005999607591705, + 0.6121402268768293, + -0.7231471882544115, + -0.9094091710263917, + -3.6982600263933185, + 0.3652972118228499, + 7.870029492993725 + ], + "sd": [ + 22.71925749146818, + 2.545996080535587, + 0.027053045572032752, + 0.017490092568823574, + 0.10528824661031994, + 0.7497468714678474, + 0.29362797520742995, + 0.24157801532565046, + 3.4003301858691457 + ], + "logz": -84.45575317152658, + "logz_err": 0.23923244022830606, + "wall_s": 2730.162583360914, + "mode_share": 0.5597929569866532 + }, + { + "seed": 3033, + "mean": [ + 154.76170946609395, + 26.933452806987667, + 1.2964610453797614, + 0.6095301765887766, + -0.7228158011095016, + -0.897947155843875, + -3.702402865162996, + 0.36264667643483434, + 7.862600504409481 + ], + "sd": [ + 21.138259037081617, + 2.501495525198889, + 0.026430060242874233, + 0.017442835577214866, + 0.10709091146380821, + 0.7601380179300004, + 0.2896228202076251, + 0.23873821548248228, + 3.35180161088544 + ], + "logz": -84.66227727378664, + "logz_err": 0.2399338752532776, + "wall_s": 2630.8231329726987, + "mode_share": 0.6920954009842146 + }, + { + "seed": 3034, + "mean": [ + 153.28389951446871, + 26.887407627991827, + 1.2970347334827752, + 0.6106345585880676, + -0.7214049597725186, + -0.8891162637212283, + -3.7093336596393343, + 0.36463321154245165, + 7.903040529290636 + ], + "sd": [ + 21.67796543248705, + 2.55847331753451, + 0.026227917070369065, + 0.017127208998702854, + 0.10482707688282172, + 0.7561582183450484, + 0.2912619321962309, + 0.24042097773290108, + 3.348861527359169 + ], + "logz": -84.538016278866, + "logz_err": 0.22305673931890616, + "wall_s": 2635.6637302399613, + "mode_share": 0.6557272974482112 + }, + { + "seed": 3035, + "mean": [ + 161.22881519866397, + 27.445460420780066, + 1.2907668574798206, + 0.6079040901752887, + -0.7260971082813036, + -0.9366622530485578, + -3.71394679074058, + 0.3719841112357928, + 8.083558748223851 + ], + "sd": [ + 17.336464418930852, + 2.3244154102401833, + 0.0241982971970979, + 0.01650693198865165, + 0.10805646659483781, + 0.7715536202234763, + 0.2871702172550281, + 0.2389168513763518, + 3.381865836620472 + ], + "logz": -84.56604170922252, + "logz_err": 0.23414546453001328, + "wall_s": 2638.0561971752904, + "mode_share": 0.8296838448902183 + }, + { + "seed": 3036, + "mean": [ + 156.62370269123633, + 26.941412734278856, + 1.2956426893627624, + 0.6085028759730736, + -0.7289882479461661, + -0.929254457750406, + -3.6933064634695416, + 0.38343648346970316, + 8.057129699814956 + ], + "sd": [ + 20.41557891793273, + 2.4769450491699505, + 0.026230308649734514, + 0.01660620193796169, + 0.10478418635023572, + 0.7460661485530546, + 0.2874101976889709, + 0.23261240961728225, + 3.4098735531843705 + ], + "logz": -84.23020409136946, + "logz_err": 0.22549878358431863, + "wall_s": 2563.6894302037545, + "mode_share": 0.7325510521567073 + }, + { + "seed": 3037, + "mean": [ + 144.0678362845529, + 26.042817129909295, + 1.3051391452179817, + 0.613197046824574, + -0.7172387281205835, + -0.887856046216102, + -3.6840650052984323, + 0.37065602971907996, + 7.931022108757693 + ], + "sd": [ + 22.590509280805485, + 2.533759537624829, + 0.02677302057310649, + 0.01791534871054794, + 0.10643039505484748, + 0.7681380495412262, + 0.29080458363127354, + 0.2319018822700051, + 3.364395131797485 + ], + "logz": -84.58925162298434, + "logz_err": 0.22852313866078616, + "wall_s": 2675.513078021817, + "mode_share": 0.4555256814404153 + }, + { + "seed": 3038, + "mean": [ + 160.27652466713585, + 27.309445100001238, + 1.2920865547809488, + 0.60780558908447, + -0.7255385524811129, + -0.9235242371818891, + -3.708693392034448, + 0.37155038164157567, + 8.102861877766559 + ], + "sd": [ + 18.02566189655809, + 2.3284372838368714, + 0.02420522059367362, + 0.01597106003692982, + 0.10548892295118917, + 0.7502933297181419, + 0.28615254761972064, + 0.23941708291174113, + 3.306297583262367 + ], + "logz": -83.66049572685058, + "logz_err": 0.22072009714833773, + "wall_s": 5171.534605517983, + "mode_share": 0.8125753564056867 + }, + { + "seed": 3039, + "mean": [ + 163.31062249099344, + 27.632804803708332, + 1.2900350824576994, + 0.6061498614794507, + -0.7254210238036592, + -0.94613701416777, + -3.727731680550379, + 0.376318406376312, + 8.285420956916427 + ], + "sd": [ + 14.827421348508633, + 2.1329609716153604, + 0.023179041519020196, + 0.016092975005376212, + 0.10324307968399776, + 0.7542578955225954, + 0.2850310725319668, + 0.23537433850876063, + 3.423531001161995 + ], + "logz": -84.12118215125084, + "logz_err": 0.23500739564790626, + "wall_s": 5347.867223539855, + "mode_share": 0.8847651240395688 + }, + { + "seed": 3040, + "mean": [ + 158.56315171322035, + 27.147572583981976, + 1.2933606438312146, + 0.6085096888671061, + -0.725880662681902, + -0.8977815210334394, + -3.712819602213269, + 0.3802065787537221, + 8.236970018930856 + ], + "sd": [ + 19.175793068410947, + 2.3999625545126433, + 0.024761788932468075, + 0.016472463668614944, + 0.10489514307956178, + 0.7643867857461637, + 0.28827540262032303, + 0.2316994704268894, + 3.3194083511573456 + ], + "logz": -84.55008217982956, + "logz_err": 0.23549613895250002, + "wall_s": 2605.9408513358794, + "mode_share": 0.7728373130219467 + }, + { + "seed": 3041, + "mean": [ + 159.49022440637222, + 27.274611389524853, + 1.2928980806458787, + 0.6077603424729481, + -0.7278807084591835, + -0.9521992707937945, + -3.717544061583465, + 0.37216970691513385, + 8.115912257671551 + ], + "sd": [ + 18.46102562963265, + 2.4054051456757337, + 0.024946564389653605, + 0.01658586326967642, + 0.1063334199978835, + 0.7627919816063206, + 0.28671829285339523, + 0.23020785612306655, + 3.401715099267042 + ], + "logz": -84.39098412612533, + "logz_err": 0.22038611360580618, + "wall_s": 2798.990286985878, + "mode_share": 0.7971209446463361 + }, + { + "seed": 3042, + "mean": [ + 155.1489394960966, + 26.835128773823374, + 1.2970303072589282, + 0.6088231857040185, + -0.7235902314526594, + -0.9567653373431511, + -3.6937466971535073, + 0.37458497295120907, + 7.929556278971399 + ], + "sd": [ + 21.192291270092298, + 2.497294990592225, + 0.02723034868481024, + 0.01700375320855362, + 0.10636206405893042, + 0.7546259219421391, + 0.28708658330759795, + 0.23575464664131215, + 3.353583212078727 + ], + "logz": -84.39147338666402, + "logz_err": 0.23226489450500332, + "wall_s": 2697.9971779710613, + "mode_share": 0.7010442666292129 + }, + { + "seed": 3043, + "mean": [ + 149.93253931500712, + 26.55725959509663, + 1.3001898998640113, + 0.6113434663412065, + -0.7148848083179139, + -0.9048699716298392, + -3.69828932639993, + 0.37042948275738197, + 8.055609871265634 + ], + "sd": [ + 22.525497943559138, + 2.6290377335851893, + 0.02735328183694533, + 0.01747535092349906, + 0.10774020872855931, + 0.7545372928091905, + 0.29794432367429413, + 0.2379148460821288, + 3.4348246199006707 + ], + "logz": -84.77663594255115, + "logz_err": 0.2158876064641667, + "wall_s": 5709.132166139316, + "mode_share": 0.5847271447575885 + }, + { + "seed": 3044, + "mean": [ + 158.22715477362885, + 27.09961032335545, + 1.294106991351419, + 0.6081377843234732, + -0.7239676569237445, + -0.9420536806653654, + -3.703566989447918, + 0.38365274926727955, + 8.241930916842687 + ], + "sd": [ + 19.52767879400126, + 2.4713365353330063, + 0.026178331826003938, + 0.01679410532691444, + 0.10694529605102517, + 0.7580293669009169, + 0.29622537525374043, + 0.23091893915589268, + 3.4213837989703073 + ], + "logz": -84.35656510212708, + "logz_err": 0.22724282530756537, + "wall_s": 2567.3886513290927, + "mode_share": 0.76773124415442 + }, + { + "seed": 3045, + "mean": [ + 156.1724997966866, + 27.03568153399806, + 1.2948828457345942, + 0.6094907964780742, + -0.7235386506243842, + -0.9266478532817944, + -3.7053849470841413, + 0.37376400770840446, + 8.10223384365531 + ], + "sd": [ + 20.43649892623883, + 2.4236219958318994, + 0.02527543199046779, + 0.0171517567944592, + 0.10568614440071038, + 0.7578829126318118, + 0.2918145796289204, + 0.23865665192698515, + 3.429629655512064 + ], + "logz": -85.29352359091388, + "logz_err": 0.23948222609283032, + "wall_s": 2743.050127318129, + "mode_share": 0.7212459145477795 + }, + { + "seed": 3046, + "mean": [ + 163.99106633599428, + 27.68615895572654, + 1.2885229100407207, + 0.6068741520750033, + -0.7242133263890064, + -0.9214189691458405, + -3.7152368033207672, + 0.3785014331330474, + 8.17956522418655 + ], + "sd": [ + 14.438614027503148, + 2.2030542662845987, + 0.022685857335890958, + 0.0157520803718874, + 0.10527373462729434, + 0.7670586568195835, + 0.28981535876978853, + 0.23094288734855653, + 3.429251243417513 + ], + "logz": -83.91278215246038, + "logz_err": 0.2321352869721951, + "wall_s": 2602.4534906758927, + "mode_share": 0.8926953637031425 + }, + { + "seed": 3047, + "mean": [ + 155.2545418450634, + 26.941835937145164, + 1.2967601987637225, + 0.6088248034942918, + -0.7223923421183592, + -0.9664914663757967, + -3.7131477803189106, + 0.37330328357598647, + 7.916336733928793 + ], + "sd": [ + 20.8029945659277, + 2.549482847907821, + 0.026845598320402966, + 0.017555517329534098, + 0.10590247395134182, + 0.7612729830662024, + 0.2952829674358481, + 0.24078058448393724, + 3.3994455558168704 + ], + "logz": -84.51864440685225, + "logz_err": 0.23359807008680755, + "wall_s": 2670.7196222217754, + "mode_share": 0.7053345320063371 + }, + { + "seed": 3048, + "mean": [ + 156.46253756920711, + 27.029547465803336, + 1.2955968552047408, + 0.6084526678530948, + -0.7260215512623832, + -0.9475830516688591, + -3.7116295697235375, + 0.3674005483680849, + 7.919946328716183 + ], + "sd": [ + 20.21819171204333, + 2.507428377847784, + 0.025808596240116416, + 0.016975532712428208, + 0.10606634677308571, + 0.7599041972793411, + 0.2885034331306497, + 0.23826689071589977, + 3.309074605827779 + ], + "logz": -84.02451828037454, + "logz_err": 0.2322909116621228, + "wall_s": 2860.4783395826817, + "mode_share": 0.7329568515558 + }, + { + "seed": 3049, + "mean": [ + 161.55750981567812, + 27.435531758753495, + 1.291672661503469, + 0.6065921243573046, + -0.7277398975092492, + -0.9278978273878169, + -3.7095162369120227, + 0.37714912727203237, + 8.204435694785015 + ], + "sd": [ + 16.82065710051113, + 2.3021883301368034, + 0.02420310043047749, + 0.015504019055493153, + 0.1052298843164069, + 0.7555953446149325, + 0.28095594869868645, + 0.23222283262753535, + 3.401513152093643 + ], + "logz": -83.8608598664329, + "logz_err": 0.23661110116859632, + "wall_s": 2788.7204725639895, + "mode_share": 0.8456989773335915 + } + ] + }, + "corroborated": true, + "wall_s": 151526.67097179964 + }, + "n40ca_gp": { + "method": "pocomc 8192/4096, 3 runs", + "mean": [ + 43.59895603286648, + 13.724149660274534, + 4.296583779360842, + 0.485035191245812, + -1.2733512647642957, + -1.7963250392384775, + 2.220629274631007 + ], + "sd": [ + 1.7104949748096125, + 1.0650461079067588, + 0.07028969719232937, + 0.026625055665343005, + 0.20831053760680046, + 0.4800701934175172, + 0.6747905034112969 + ], + "logz": -11.342946005337055, + "logz_err": 0.009205750713685073, + "max_disagreement": 0.042364712248810193, + "accepted": true, + "runs": [ + { + "seed": 2000, + "mean": [ + 43.56719223186605, + 13.721765783171005, + 4.298119872652306, + 0.4844611351201628, + -1.272366219282795, + -1.8032225972846545, + 2.2300364828257138 + ], + "sd": [ + 1.7200111153884834, + 1.061834140539834, + 0.07065073255673113, + 0.02644065108920894, + 0.20915348375756906, + 0.482459366500779, + 0.6755908989364604 + ], + "logz": -11.346640683324653, + "logz_err": 0.008829612327629072, + "wall_s": 640.7687541219639 + }, + { + "seed": 2001, + "mean": [ + 43.5887574095278, + 13.72474651565375, + 4.296511409510507, + 0.48525235399999167, + -1.2752161744136792, + -1.7992840974518884, + 2.2223893655881257 + ], + "sd": [ + 1.768604828830274, + 1.0725806337226362, + 0.0709547289440926, + 0.02754096948724118, + 0.20962414303124668, + 0.4802143788094155, + 0.6754740862616965 + ], + "logz": -11.346479090928366, + "logz_err": 0.007952768122234433, + "wall_s": 633.3055904699722 + }, + { + "seed": 2002, + "mean": [ + 43.64091845720561, + 13.72593668199885, + 4.295120055919713, + 0.4853920846172816, + -1.2724714005964133, + -1.786468422978889, + 2.2094619754791824 + ], + "sd": [ + 1.6395438703788003, + 1.0606787664020407, + 0.06921934496604427, + 0.02585659807967027, + 0.20612412949733824, + 0.47736338010738955, + 0.673143420445319 + ], + "logz": -11.33571824175814, + "logz_err": 0.009205750713685073, + "wall_s": 598.1245579579845 + } + ], + "names": [ + "Vv", + "Wv", + "Rv", + "av", + "log_ell_xs", + "log_A_xs", + "amp_slope_xs" + ], + "corroboration": { + "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}, 50 runs pooled", + "mean": [ + 43.6612308080938, + 13.70908002326348, + 4.29212803499743, + 0.4867055623948784, + -1.2690073287163621, + -1.760463557949741, + 2.18006271440875 + ], + "sd": [ + 1.919810969381398, + 1.1153700168374379, + 0.07540774161480943, + 0.029130297776965366, + 0.20882070600554717, + 0.4841155951845646, + 0.6762933065360258 + ], + "logz": -11.52591858849597, + "logz_err": 0.8687611469385104, + "bias": 0.07470049542848377, + "width": 0.1154439401632449, + "logz_combined_err": 0.8688099195313774, + "checks": { + "log Z": true, + "moments": true + }, + "runs": [ + { + "seed": 3000, + "mean": [ + 43.86350465157741, + 13.613350602769225, + 4.2801884004979245, + 0.49061836857899627, + -1.2549020023920017, + -1.684654261954729, + 2.0995189980483357 + ], + "sd": [ + 2.11651250135529, + 1.1464758731028168, + 0.07664195520330816, + 0.03057126107834519, + 0.19825012259046437, + 0.4801133607365389, + 0.6948607729261731 + ], + "logz": -12.177582190802257, + "logz_err": 0.24689773209131172, + "wall_s": 1334.630270184949 + }, + { + "seed": 3001, + "mean": [ + 43.65903901799406, + 13.728564647336153, + 4.2946504176091755, + 0.4850803203582831, + -1.270483634494769, + -1.7688786955662252, + 2.1920897834915354 + ], + "sd": [ + 1.6106292908463407, + 1.0973267824768798, + 0.07376627959417903, + 0.02461015110796583, + 0.21414120185835417, + 0.4867352456550508, + 0.6729684308572398 + ], + "logz": -11.62639478115365, + "logz_err": 0.2323095386650202, + "wall_s": 1272.7058295130264 + }, + { + "seed": 3002, + "mean": [ + 43.85000570485298, + 13.674268053457672, + 4.28254546995636, + 0.489631738400541, + -1.2618163122544772, + -1.718165743717051, + 2.1374332492790957 + ], + "sd": [ + 1.8227656525500626, + 1.1764136119365507, + 0.07685155166161006, + 0.03125705634094876, + 0.20886987063911486, + 0.4946172656041681, + 0.6907647215154945 + ], + "logz": -11.718260344536716, + "logz_err": 0.23028881662247125, + "wall_s": 1269.7501324790064 + }, + { + "seed": 3003, + "mean": [ + 43.76343629776936, + 13.683402872005876, + 4.28861353034318, + 0.48708101017948474, + -1.2606005582047894, + -1.7305040360276611, + 2.143809272581293 + ], + "sd": [ + 1.6692705426300734, + 1.0858725940082474, + 0.07444447942813548, + 0.02746523072931969, + 0.2018164103745195, + 0.48601019471638235, + 0.6757381138448649 + ], + "logz": -11.546373333308322, + "logz_err": 0.2547131915439554, + "wall_s": 1202.652240928961 + }, + { + "seed": 3004, + "mean": [ + 43.88154286964037, + 13.695661332011795, + 4.284799330436668, + 0.488470746005194, + -1.272392498313646, + -1.7376565907072437, + 2.1491373772572238 + ], + "sd": [ + 1.7488280905779696, + 1.1393859522381267, + 0.07887731850651272, + 0.026970848148067928, + 0.20553601636500848, + 0.48355689937295016, + 0.6692137740755333 + ], + "logz": -11.875079372876257, + "logz_err": 0.24797031509799095, + "wall_s": 1251.7241517269285 + }, + { + "seed": 3005, + "mean": [ + 43.830053055903676, + 13.702027654766338, + 4.286167718591822, + 0.48757837579502433, + -1.2729407248535645, + -1.737942847444878, + 2.141927747243757 + ], + "sd": [ + 1.6738384251851768, + 1.131668161720444, + 0.07512384263891987, + 0.02602157244474594, + 0.20776716815457782, + 0.47562544715328586, + 0.6647076096922615 + ], + "logz": -11.48819235752476, + "logz_err": 0.24733428869862456, + "wall_s": 1216.5220271740109 + }, + { + "seed": 3006, + "mean": [ + 43.066408761053495, + 13.849427077915399, + 4.321123472418126, + 0.4775949022951496, + -1.3029579701661682, + -1.8826994172752876, + 2.285994713916897 + ], + "sd": [ + 1.8953224389666694, + 1.0898340553515298, + 0.07984017683838834, + 0.028761218292154247, + 0.21093869866744047, + 0.4617500283433338, + 0.6613726590271967 + ], + "logz": -10.858815703691715, + "logz_err": 0.24555390449510403, + "wall_s": 1211.0836269139545 + }, + { + "seed": 3007, + "mean": [ + 43.27805435134456, + 13.812063586626735, + 4.312450878654405, + 0.4801404218316396, + -1.300427700693842, + -1.884601318225866, + 2.3039543132898572 + ], + "sd": [ + 1.7507199422039392, + 1.0664913514823, + 0.07430683007595126, + 0.02561933665206919, + 0.21886423502515245, + 0.46850229756652884, + 0.6486604734595018 + ], + "logz": -10.95616272966126, + "logz_err": 0.24764373444092155, + "wall_s": 1208.8542942550266 + }, + { + "seed": 3008, + "mean": [ + 43.71502143065437, + 13.69100264381236, + 4.291588876534214, + 0.4861817346523326, + -1.270867540295385, + -1.766630598137311, + 2.186608002240662 + ], + "sd": [ + 1.6622243287055765, + 1.102096955311076, + 0.072038366878623, + 0.025467561793216655, + 0.20931644219436965, + 0.46372593741929335, + 0.6573332938558806 + ], + "logz": -11.538222983807266, + "logz_err": 0.24039412583606726, + "wall_s": 1242.5232465650188 + }, + { + "seed": 3009, + "mean": [ + 43.77673461417868, + 13.700509930730044, + 4.289910496349014, + 0.4866101926370263, + -1.2641329731104327, + -1.7573454748512616, + 2.186827588032421 + ], + "sd": [ + 1.561246425654861, + 1.0800193467963126, + 0.07040321385935762, + 0.024273350697896188, + 0.21188738021428744, + 0.4548004338586409, + 0.6428544320824617 + ], + "logz": -11.196398888570267, + "logz_err": 0.2393942599479111, + "wall_s": 1205.3371413829736 + }, + { + "seed": 3010, + "mean": [ + 43.69078881380422, + 13.675209992531647, + 4.294459191961428, + 0.4851811759892041, + -1.2718857830444117, + -1.7890424919094987, + 2.2273669305461086 + ], + "sd": [ + 1.6318308130453132, + 1.0876432460224863, + 0.07366205502147787, + 0.024974938942400462, + 0.20834380126811014, + 0.48424202880993433, + 0.6606004705162517 + ], + "logz": -11.509084345310134, + "logz_err": 0.24487311481182605, + "wall_s": 1233.201237477013 + }, + { + "seed": 3011, + "mean": [ + 43.60975826191982, + 13.719473504332724, + 4.289551573391981, + 0.4892769066373272, + -1.2705446692075573, + -1.7342782110977626, + 2.1390999601633585 + ], + "sd": [ + 2.4681016211013227, + 1.1314580965774785, + 0.07600237069120615, + 0.03377725013151341, + 0.20696023136801145, + 0.48716519415630805, + 0.6891835800957763 + ], + "logz": -11.244794115029938, + "logz_err": 0.24432400793400602, + "wall_s": 1235.1236483319663 + }, + { + "seed": 3012, + "mean": [ + 43.82618671330784, + 13.712013743910662, + 4.287386037387245, + 0.48764838285548634, + -1.2690736324453133, + -1.7713433131278378, + 2.1877408582898097 + ], + "sd": [ + 1.618473522338044, + 1.0941782457124172, + 0.07263836579305594, + 0.025400928838897562, + 0.19709874745650957, + 0.4829717364183414, + 0.6903500798873458 + ], + "logz": -11.359427481097418, + "logz_err": 0.24167564734551947, + "wall_s": 1230.9246317869984 + }, + { + "seed": 3013, + "mean": [ + 43.53563777338296, + 13.73929461571445, + 4.298105296496811, + 0.4848102833565959, + -1.2783582426673028, + -1.8077589152729825, + 2.236928507586092 + ], + "sd": [ + 1.883474095053936, + 1.103666266176018, + 0.07565232949576496, + 0.02810285514022882, + 0.20798324027922827, + 0.48293385472976447, + 0.6596684552448862 + ], + "logz": -11.503004165066164, + "logz_err": 0.2401387228276592, + "wall_s": 1246.8475659950636 + }, + { + "seed": 3014, + "mean": [ + 43.807120444687484, + 13.693921367166137, + 4.288596905710254, + 0.48693533595894395, + -1.2622930032860495, + -1.7577138627891749, + 2.169840703513909 + ], + "sd": [ + 1.5399098921123302, + 1.0592050585166248, + 0.06968805133946548, + 0.023987291001009433, + 0.2023267760731105, + 0.49018499077737, + 0.6863471076709199 + ], + "logz": -11.084466496464758, + "logz_err": 0.24581791038631845, + "wall_s": 1193.0571655089734 + }, + { + "seed": 3015, + "mean": [ + 43.81172141688906, + 13.67673660208023, + 4.285694053148974, + 0.48798216107750375, + -1.249672204149435, + -1.7072199574829405, + 2.1308674709643576 + ], + "sd": [ + 1.7596440772631727, + 1.1218216924281672, + 0.07645741648147311, + 0.02774282394632116, + 0.20272473279912395, + 0.4841244978416692, + 0.6785596843879129 + ], + "logz": -12.193798815892638, + "logz_err": 0.24829451716794204, + "wall_s": 1283.1568422319833 + }, + { + "seed": 3016, + "mean": [ + 43.70387989866226, + 13.745520318127856, + 4.293728292080306, + 0.48592213775281917, + -1.278417041363774, + -1.7934715421955074, + 2.21353915535013 + ], + "sd": [ + 1.6715715928055548, + 1.0805003102006683, + 0.0734804872358054, + 0.02586239602686326, + 0.21037203918844183, + 0.4713779026648803, + 0.6557230339953096 + ], + "logz": -11.452006570599256, + "logz_err": 0.2259855021344347, + "wall_s": 1241.0421020310605 + }, + { + "seed": 3017, + "mean": [ + 43.914648504982814, + 13.67148857147585, + 4.282961295892786, + 0.4888065654357596, + -1.2519751106831911, + -1.694077456984327, + 2.114387366207379 + ], + "sd": [ + 1.6252898495921904, + 1.1050272943052923, + 0.07317554758058538, + 0.0253389345238508, + 0.1993368785667893, + 0.4775564800935445, + 0.6721596495022871 + ], + "logz": -11.73973717107672, + "logz_err": 0.2421789796056163, + "wall_s": 1219.2673423220403 + }, + { + "seed": 3018, + "mean": [ + 43.684703503154424, + 13.726532508372502, + 4.293579858908982, + 0.485739799935159, + -1.2723423058233612, + -1.7794652674949853, + 2.2020627015809047 + ], + "sd": [ + 1.6507173375315822, + 1.088767459039104, + 0.07279589012370569, + 0.02565688623886426, + 0.20515544907075484, + 0.4849925663126707, + 0.6810040041546508 + ], + "logz": -11.438718860915845, + "logz_err": 0.2416829222146869, + "wall_s": 1247.1665258139838 + }, + { + "seed": 3019, + "mean": [ + 43.552226628385824, + 13.746131220282406, + 4.300320234715255, + 0.4839276978751418, + -1.29912088346445, + -1.841749007255673, + 2.2638442948512543 + ], + "sd": [ + 1.654581885304905, + 1.1080296502186462, + 0.07352295995346364, + 0.025418149579137808, + 0.22121947162931938, + 0.47277174235042396, + 0.6450502778093485 + ], + "logz": -11.28587178204334, + "logz_err": 0.24865489170848115, + "wall_s": 2374.0736664300784 + }, + { + "seed": 3020, + "mean": [ + 43.732539970840016, + 13.690917267318765, + 4.284126790310573, + 0.4899936647676803, + -1.2574795715842682, + -1.6993013291509382, + 2.1081115462246904 + ], + "sd": [ + 2.0819750842478895, + 1.1697751923668545, + 0.07687912837062388, + 0.03403675950431354, + 0.20654761646778372, + 0.47846364785765044, + 0.6723719157980415 + ], + "logz": -12.076571775820007, + "logz_err": 0.2512981790914582, + "wall_s": 2698.916866186075 + }, + { + "seed": 3021, + "mean": [ + 43.78615560526788, + 13.68759382899415, + 4.286736399537174, + 0.4881491954726758, + -1.2672519256849206, + -1.7177770422528553, + 2.1203872290452512 + ], + "sd": [ + 1.8004411062461372, + 1.1450640777070926, + 0.07603397340977461, + 0.028926691178387937, + 0.2058763870320605, + 0.4812997522166705, + 0.656462493354124 + ], + "logz": -11.632774630574401, + "logz_err": 0.24048473404730733, + "wall_s": 1230.6493399753235 + }, + { + "seed": 3022, + "mean": [ + 43.53544780535106, + 13.73050656192565, + 4.300814248923584, + 0.4833540164621793, + -1.2861474178369703, + -1.8400313196518363, + 2.28133919429163 + ], + "sd": [ + 1.6784714050623375, + 1.090854228598583, + 0.07381488275572519, + 0.02559127973607512, + 0.21779853346446107, + 0.45614301684599645, + 0.6383068661534999 + ], + "logz": -11.149572195251087, + "logz_err": 0.23851036195312217, + "wall_s": 1218.6569001958705 + }, + { + "seed": 3023, + "mean": [ + 43.81416006963357, + 13.686154360137122, + 4.287716666329644, + 0.48751340645388413, + -1.2667703222434665, + -1.749390302880168, + 2.159951341086709 + ], + "sd": [ + 1.6409903918074311, + 1.0814290456713287, + 0.06970489341388623, + 0.025620087144759714, + 0.20208544390851974, + 0.46564548274017353, + 0.6639807735456031 + ], + "logz": -11.125878410684217, + "logz_err": 0.2292984255736507, + "wall_s": 1298.1542010549456 + }, + { + "seed": 3024, + "mean": [ + 43.28319592325252, + 13.806521466517598, + 4.294654460755931, + 0.4909841124236277, + -1.2804477800348626, + -1.7897516614420492, + 2.199793397334258 + ], + "sd": [ + 3.128813860591252, + 1.2033354326459451, + 0.07695938480252057, + 0.04325677163510923, + 0.21581826451129804, + 0.49865396664902056, + 0.7325145024209972 + ], + "logz": -11.540927853961145, + "logz_err": 0.23742179539410013, + "wall_s": 1322.2990707849385 + }, + { + "seed": 3025, + "mean": [ + 43.228312637394644, + 13.74045987549343, + 4.312040588216139, + 0.48108463179368616, + -1.2815195531316532, + -1.9324324616821094, + 2.406135250882503 + ], + "sd": [ + 2.211088276236884, + 1.0289244013253838, + 0.07563152550674591, + 0.028683993969307063, + 0.196584905034812, + 0.46369809494459363, + 0.6799093628726366 + ], + "logz": -10.955725927409414, + "logz_err": 0.2513640142554386, + "wall_s": 1266.3550127730705 + }, + { + "seed": 3026, + "mean": [ + 43.9653072903439, + 13.692851705878935, + 4.280915711930681, + 0.48955781936926007, + -1.2526814006323752, + -1.6895549190296588, + 2.105535240332168 + ], + "sd": [ + 1.5818169093431076, + 1.127081621957749, + 0.07175823538492003, + 0.024680392128826844, + 0.21076264016558302, + 0.4900251742191631, + 0.6755452986328606 + ], + "logz": -11.482314762511074, + "logz_err": 0.2525032963504758, + "wall_s": 1188.7009869210888 + }, + { + "seed": 3027, + "mean": [ + 43.237884365761246, + 13.710284415596076, + 4.294428485245295, + 0.49093815013993636, + -1.2728502346909376, + -1.743208386727275, + 2.1457859705122457 + ], + "sd": [ + 3.278531584921585, + 1.1681048072433362, + 0.08119318898776164, + 0.04382746592306667, + 0.21202846946434786, + 0.49648854134237486, + 0.7183500323436094 + ], + "logz": -12.043201957814523, + "logz_err": 0.24764806525200142, + "wall_s": 1297.1201639719075 + }, + { + "seed": 3028, + "mean": [ + 44.02763540582919, + 13.644462850974294, + 4.276488727650422, + 0.49105331462361645, + -1.2491787096936808, + -1.6390695512790139, + 2.047277261322359 + ], + "sd": [ + 1.7148526069740821, + 1.1623072339935536, + 0.07570163125184382, + 0.02778961540350414, + 0.20618265619125828, + 0.48459175183237596, + 0.6832761022624944 + ], + "logz": -12.032065310194248, + "logz_err": 0.24660316347530628, + "wall_s": 1251.5538921830012 + }, + { + "seed": 3029, + "mean": [ + 43.291155024181656, + 13.796398752412072, + 4.31206406869457, + 0.4800434812503849, + -1.2909337352807704, + -1.8782590618797301, + 2.3038729421569286 + ], + "sd": [ + 1.6220273201822708, + 1.0294542268662719, + 0.07038640436561884, + 0.024864033487750355, + 0.20612640180028657, + 0.4553672088979788, + 0.6477204192179822 + ], + "logz": -10.566432697254713, + "logz_err": 0.23647210477683506, + "wall_s": 1183.6415254999883 + }, + { + "seed": 3030, + "mean": [ + 43.588480952577804, + 13.701858999828428, + 4.295785385522357, + 0.48510122409948253, + -1.2489288058759875, + -1.7026286792301655, + 2.1316673983109427 + ], + "sd": [ + 1.8990135139198345, + 1.0641927539243992, + 0.07633923282547166, + 0.02748984157523734, + 0.21381503956942305, + 0.4883188604393866, + 0.6511242348013017 + ], + "logz": -11.454888968130936, + "logz_err": 0.23643365902992927, + "wall_s": 1275.9793411010178 + }, + { + "seed": 3031, + "mean": [ + 43.5325415323224, + 13.71621584701654, + 4.298950224877192, + 0.48425376546621557, + -1.2762998104671066, + -1.8307349690789685, + 2.2679165498297715 + ], + "sd": [ + 1.7204355190905178, + 1.0701019364510445, + 0.0735840116798548, + 0.028903209351044686, + 0.20466175726730398, + 0.4956467254698851, + 0.6955563273146662 + ], + "logz": -11.855265470717185, + "logz_err": 0.2490843635169071, + "wall_s": 1261.6493149530143 + }, + { + "seed": 3032, + "mean": [ + 43.80548828998113, + 13.664309785766964, + 4.286261639013012, + 0.48756050854627914, + -1.2634243799479214, + -1.7077633324013406, + 2.115194225175444 + ], + "sd": [ + 1.8328564157579392, + 1.1563976165796122, + 0.08184350031494599, + 0.02864355642532756, + 0.20893607771282424, + 0.4986895280249155, + 0.6885600800296213 + ], + "logz": -12.282501877796955, + "logz_err": 0.24856781011911944, + "wall_s": 1301.0490616718307 + }, + { + "seed": 3033, + "mean": [ + 43.901894705401496, + 13.677666748574735, + 4.278343308569338, + 0.49168815493319723, + -1.2546105670677565, + -1.6567095668881908, + 2.0574835015032016 + ], + "sd": [ + 2.170842123753842, + 1.2100324060414167, + 0.07774129967135439, + 0.03315669220868005, + 0.21123734394847446, + 0.4831610024357838, + 0.6702769572898939 + ], + "logz": -11.762480596073527, + "logz_err": 0.24624102948935644, + "wall_s": 1251.7857860750519 + }, + { + "seed": 3034, + "mean": [ + 43.47715595580879, + 13.674155125872248, + 4.296522904395616, + 0.4859004658367291, + -1.264331637328232, + -1.778214409627821, + 2.2088037311102404 + ], + "sd": [ + 2.188373395436522, + 1.1032697322415206, + 0.07476660525490007, + 0.032715625739426386, + 0.20201819902334567, + 0.45485899914448596, + 0.6438677774693808 + ], + "logz": -11.80875628777826, + "logz_err": 0.2485611576986709, + "wall_s": 1281.4383820788935 + }, + { + "seed": 3035, + "mean": [ + 43.83356801895904, + 13.673685588287075, + 4.280005489373067, + 0.4918980116268821, + -1.2571522044554038, + -1.7078951948985597, + 2.1372396513947094 + ], + "sd": [ + 2.2522214528722913, + 1.177610423780548, + 0.07704416281964468, + 0.03405131533542319, + 0.2115924165189924, + 0.4847560212983791, + 0.6734445754604994 + ], + "logz": -12.127051846396768, + "logz_err": 0.23495263357703966, + "wall_s": 1280.2561507229693 + }, + { + "seed": 3036, + "mean": [ + 43.63476607194968, + 13.704936666694827, + 4.295478800646791, + 0.484685934388037, + -1.2652595219137075, + -1.771495347722798, + 2.19752782254279 + ], + "sd": [ + 1.5921008223429276, + 1.082975473270905, + 0.07091654723024746, + 0.024691355190720382, + 0.20523970008909054, + 0.462326669705431, + 0.6583202620140526 + ], + "logz": -10.881899352497788, + "logz_err": 0.24818532136468935, + "wall_s": 1186.1582289150683 + }, + { + "seed": 3037, + "mean": [ + 43.75937472269489, + 13.648612371007424, + 4.288390931860504, + 0.48682292916974107, + -1.2626427583834905, + -1.7258316509503708, + 2.1387135805907875 + ], + "sd": [ + 1.828899666024829, + 1.139378735710667, + 0.07899562786103138, + 0.02817186098021161, + 0.21023177069777157, + 0.4859029430134008, + 0.6701291869472069 + ], + "logz": -11.899566974328277, + "logz_err": 0.24079455673778985, + "wall_s": 1252.7791947519872 + }, + { + "seed": 3038, + "mean": [ + 43.807420341295504, + 13.691236220908994, + 4.286186232882652, + 0.4876588628538749, + -1.2531506431318928, + -1.6760611771751486, + 2.069057113350925 + ], + "sd": [ + 1.6858945674377943, + 1.1270910505542393, + 0.07485139330407346, + 0.02600832328194021, + 0.2059451159764634, + 0.49649361660310454, + 0.7002223749827643 + ], + "logz": -11.962618196368858, + "logz_err": 0.24764865273221306, + "wall_s": 1236.8057141320314 + }, + { + "seed": 3039, + "mean": [ + 43.526297500209935, + 13.77134561683191, + 4.291547919557328, + 0.48906400552260726, + -1.2770463046068083, + -1.776657500211774, + 2.190598533165245 + ], + "sd": [ + 2.3819995354307526, + 1.1676043307223878, + 0.07470594013953263, + 0.03874956905316134, + 0.20683760545531427, + 0.4613166741111253, + 0.6576607141609135 + ], + "logz": -11.26250758497472, + "logz_err": 0.2297579112149907, + "wall_s": 1222.1656831169967 + }, + { + "seed": 3040, + "mean": [ + 43.38669814303522, + 13.854741569544217, + 4.3100021703444416, + 0.4812424126970997, + -1.3144481477205971, + -1.9260288758673694, + 2.3418109659846236 + ], + "sd": [ + 1.5450952855955364, + 1.0299547198126384, + 0.06989485300897316, + 0.023197568208786587, + 0.22840640060489528, + 0.47924151211528293, + 0.6517669459551966 + ], + "logz": -10.61516715926587, + "logz_err": 0.2395045382337993, + "wall_s": 1163.6777579180198 + }, + { + "seed": 3041, + "mean": [ + 43.64146099413022, + 13.702041241848734, + 4.296053521227209, + 0.4847617523420827, + -1.2721553299166675, + -1.8085806335150139, + 2.2432579907636114 + ], + "sd": [ + 1.6160234669765443, + 1.0685310497843297, + 0.07170117133468697, + 0.02479498231169865, + 0.21033434278980023, + 0.4848866737640874, + 0.6590504287373449 + ], + "logz": -11.457875374844054, + "logz_err": 0.2513213734621126, + "wall_s": 1211.2422900719102 + }, + { + "seed": 3042, + "mean": [ + 43.66416187414712, + 13.68025738193878, + 4.293621140388393, + 0.48568940876829236, + -1.267426398050301, + -1.7391961740590336, + 2.1474404138059358 + ], + "sd": [ + 1.7445494460436446, + 1.111245865314263, + 0.07169922031790557, + 0.027337789908082995, + 0.2055249241557467, + 0.46838123393190634, + 0.6717956141693314 + ], + "logz": -11.53699073324621, + "logz_err": 0.23903132168741692, + "wall_s": 1253.7491824120516 + }, + { + "seed": 3043, + "mean": [ + 43.71241974242191, + 13.706419292203684, + 4.2910124508836045, + 0.4864393779388837, + -1.2650822364979029, + -1.7537880077009589, + 2.1741985892648517 + ], + "sd": [ + 1.7375799786159203, + 1.0977543278669337, + 0.07669028135021949, + 0.027743100918445267, + 0.2064243668119189, + 0.49137256325013706, + 0.6782438031463593 + ], + "logz": -11.77475482955212, + "logz_err": 0.2387268524010463, + "wall_s": 1242.398315712111 + }, + { + "seed": 3044, + "mean": [ + 43.54083351383592, + 13.66172692112492, + 4.294814154790625, + 0.4862289553737458, + -1.2687101912774832, + -1.7432954703772157, + 2.154285568188953 + ], + "sd": [ + 2.19635004879517, + 1.096538275895466, + 0.0743925993218794, + 0.029345701301716192, + 0.21043149363689034, + 0.462651336638424, + 0.6562323545721466 + ], + "logz": -11.280988084099477, + "logz_err": 0.2371353816734623, + "wall_s": 1218.6381054650992 + }, + { + "seed": 3045, + "mean": [ + 43.7597906072468, + 13.70728307730612, + 4.288839979303332, + 0.4871899076285384, + -1.2570346984397722, + -1.699590966778598, + 2.1017890132565995 + ], + "sd": [ + 1.671872838274928, + 1.1146721669966586, + 0.07183420435144602, + 0.026620381712219397, + 0.20829548994364594, + 0.4977524691685829, + 0.6896055843881882 + ], + "logz": -11.204699585550665, + "logz_err": 0.24146684704867039, + "wall_s": 1269.402395599056 + }, + { + "seed": 3046, + "mean": [ + 43.60955226044399, + 13.674868136759324, + 4.296526075428371, + 0.484485589496908, + -1.2662485333973201, + -1.7779380637101514, + 2.215123180573599 + ], + "sd": [ + 1.7451553033059144, + 1.0928314827431047, + 0.0765258710845322, + 0.02716456143663582, + 0.20048760634951893, + 0.47400999683953887, + 0.6657340636169531 + ], + "logz": -11.495882486616084, + "logz_err": 0.2522541870950044, + "wall_s": 1293.348359940108 + }, + { + "seed": 3047, + "mean": [ + 43.56480786381398, + 13.794718697563699, + 4.287949224133771, + 0.4915847775113247, + -1.276728669789923, + -1.763290567709397, + 2.188722182040668 + ], + "sd": [ + 2.5516528853819738, + 1.2107074644011702, + 0.07410477893780702, + 0.0403161169593581, + 0.215735581949076, + 0.46529171671157304, + 0.6583807027181927 + ], + "logz": -11.321184905190824, + "logz_err": 0.2249335752441206, + "wall_s": 1244.0161672239192 + }, + { + "seed": 3048, + "mean": [ + 43.82376463048388, + 13.635449359332153, + 4.284666459665998, + 0.48835181508815073, + -1.2512036284795955, + -1.7308403860960024, + 2.1685415890378636 + ], + "sd": [ + 1.8622041445754913, + 1.1471967038218727, + 0.0793073804241348, + 0.029096813204289102, + 0.20353472645587178, + 0.5068687489141555, + 0.7236220850852049 + ], + "logz": -12.303954991131734, + "logz_err": 0.24624768865355226, + "wall_s": 1299.424837754108 + }, + { + "seed": 3049, + "mean": [ + 43.76879587192873, + 13.669720584089147, + 4.289036258329024, + 0.4867802100913037, + -1.2480165273423915, + -1.7226618779943277, + 2.162595752923612 + ], + "sd": [ + 1.6609462291858939, + 1.0977333618135647, + 0.07520060619362715, + 0.02626707239058236, + 0.2130348169783368, + 0.49680293936891107, + 0.6789077964039715 + ], + "logz": -11.60903610933466, + "logz_err": 0.24180623267430582, + "wall_s": 1251.5673218080774 + } + ] + }, + "corroborated": true, + "wall_s": 66745.42214257247 + }, + "omp": { + "method": "pocomc 8192/4096, 3 runs", + "mean": [ + 45.82003413211523, + 3.3512107320620435, + 3.959648030707045, + 0.7912198076983327, + 9.067020071244286, + 4.416048456581646, + 0.3219676115474195, + -1.6345880685013798, + -1.8532382049184835 + ], + "sd": [ + 2.5133017487386224, + 1.2588827489577652, + 0.13177586287033038, + 0.04582943233155777, + 1.163591939646596, + 0.10839286460470092, + 0.05988105579228054, + 0.12057862646819352, + 0.8461585984577359 + ], + "logz": -6.6476305808068, + "logz_err": 0.04285668527886685, + "mode_share": 0.1310603387786808, + "mode_share_label": "share away from the MAP island", + "max_disagreement": 0.01827390768580351, + "accepted": true, + "runs": [ + { + "seed": 2000, + "mean": [ + 45.83690023007923, + 3.3499479652623574, + 3.9593525662306273, + 0.7913258315476238, + 9.087755914411451, + 4.415845255029297, + 0.32130909164955024, + -1.6348678271767232, + -1.8600525749738654 + ], + "sd": [ + 2.491160434438235, + 1.2563769597671544, + 0.13032522516764705, + 0.04564899098723714, + 1.1476523528968996, + 0.10719830112514711, + 0.058796732492895146, + 0.12081510732177256, + 0.8351708187731082 + ], + "logz": -6.625555110790021, + "logz_err": 0.04285668527886685, + "wall_s": 1346.1900505349913, + "mode_share": 0.1296755210222584 + }, + { + "seed": 2001, + "mean": [ + 45.82916664790854, + 3.357775211074856, + 3.958704981568321, + 0.7914083607384362, + 9.05659244602436, + 4.415832632219078, + 0.32232178445231274, + -1.6351207382497588, + -1.8473968649380048 + ], + "sd": [ + 2.5130322877143128, + 1.264028838090728, + 0.13254790456832388, + 0.046000095104070396, + 1.1669222119545026, + 0.1085316299053715, + 0.060097863418464875, + 0.12091333500702547, + 0.8512827653192674 + ], + "logz": -6.660922779454295, + "logz_err": 0.009755565591117104, + "wall_s": 1377.9200871120265, + "mode_share": 0.1324468933466646 + }, + { + "seed": 2002, + "mean": [ + 45.79403551835792, + 3.345909019848918, + 3.9608865443221863, + 0.7909252308089381, + 9.056711853297045, + 4.416467482496564, + 0.3222719585403955, + -1.6337756400776575, + -1.8522651748435808 + ], + "sd": [ + 2.5353109583264497, + 1.2561976608776715, + 0.1324330480971392, + 0.04583708004348447, + 1.1757466837087716, + 0.10943575916427457, + 0.06072694521457943, + 0.12000111958333923, + 0.8518679325415246 + ], + "logz": -6.656413852176085, + "logz_err": 0.012252888546165389, + "wall_s": 1586.5622286959842, + "mode_share": 0.13105860196711935 + } + ], + "names": [ + "Vv", + "Wv", + "Rv", + "av", + "Wd", + "Rd", + "ad", + "log_sigma_A", + "log_sigma_B" + ], + "corroboration": { + "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}, 3 runs pooled", + "mean": [ + 45.88273325162775, + 3.3118923117396544, + 3.9572922728635898, + 0.7923348665165576, + 9.117057263661504, + 4.417902253132129, + 0.3202943773487728, + -1.6318750632690577, + -1.8658383987339384 + ], + "sd": [ + 2.4864870387002194, + 1.252583482041367, + 0.12797338516395437, + 0.04501597064489701, + 1.1019006570189591, + 0.10147588391353503, + 0.05703789383284276, + 0.12192070363317091, + 0.853073329289609 + ], + "logz": -6.403841812903355, + "logz_err": 0.24871100128265677, + "mode_share": 0.12076328785862889, + "mode_share_label": "share away from the MAP island", + "bias": 0.04300235392865907, + "width": 0.06594108881888648, + "logz_combined_err": 0.252376420515296, + "checks": { + "log Z": true, + "moments": true, + "mode share": true + }, + "runs": [ + { + "seed": 3000, + "mean": [ + 46.34507836399587, + 3.3021781072839422, + 3.934218827283109, + 0.7990678859085422, + 9.238897902898843, + 4.425344550945001, + 0.3167147188606561, + -1.644011282984124, + -1.9133246581639793 + ], + "sd": [ + 2.434282497135053, + 1.2386771011002746, + 0.12274874132356249, + 0.04268930863897815, + 1.0051456817187017, + 0.08650722043039001, + 0.04933484603646904, + 0.12045464107179688, + 0.8281524165783354 + ], + "logz": -6.212821986919609, + "logz_err": 0.2316291405838807, + "wall_s": 2540.7718005697243, + "mode_share": 0.08722285490287002 + }, + { + "seed": 3001, + "mean": [ + 45.65211872111922, + 3.2409399617911943, + 3.969588516259301, + 0.7871140282685902, + 9.051565913971437, + 4.41269035842489, + 0.32608005075093294, + -1.6219744519558736, + -1.8837595212440095 + ], + "sd": [ + 2.5037838849794296, + 1.2385052790626514, + 0.13098277120937696, + 0.04559884633123559, + 1.2269570213319905, + 0.11099359625871304, + 0.062424531595431036, + 0.12447294806937895, + 0.8353099133405114 + ], + "logz": -6.710243989484923, + "logz_err": 0.22312147252441222, + "wall_s": 2837.3212025309913, + "mode_share": 0.1451228032396339 + }, + { + "seed": 3002, + "mean": [ + 45.65100266976815, + 3.3925588661438257, + 3.9680694750483583, + 0.7908226853725405, + 9.060707974114234, + 4.415671850026497, + 0.3180883624347295, + -1.629639454867176, + -1.8004310167938267 + ], + "sd": [ + 2.456123619680096, + 1.2755564106152009, + 0.12691766032048202, + 0.04585633638371601, + 1.050953994928581, + 0.10488785015375705, + 0.05812108349729781, + 0.11975320742314625, + 0.8903757644654113 + ], + "logz": -6.288459462305533, + "logz_err": 0.21569970074017808, + "wall_s": 2781.856348440051, + "mode_share": 0.12994420543338278 + } + ] + }, + "corroborated": true, + "wall_s": 12470.621717883769 + } +} \ No newline at end of file diff --git a/benchmarks/results/hpc/run/alpha_gp/0.json b/benchmarks/results/hpc/run/alpha_gp/0.json new file mode 100644 index 0000000..e9c8da4 --- /dev/null +++ b/benchmarks/results/hpc/run/alpha_gp/0.json @@ -0,0 +1,75 @@ +{ + "meta": { + "jax": "0.12.0.1", + "blackjax": "1.7.1" + }, + "problems": { + "alpha_gp": { + "ndim": 9, + "names": [ + "V", + "W", + "r", + "a", + "log_sigma_A", + "log_sigma_B", + "log_ell", + "log_A_q", + "p" + ], + "samplers": { + "emcee": { + "wall_s": 166.165595975006, + "calls": { + "search": 1744, + "warmup": 32000, + "sampling": 64000, + "evidence": 0 + }, + "min_ess": 53.37927341605181, + "min_ess_tail": 389.76467484476353, + "max_rhat": 1.6048051058274935, + "mean": [ + 169.63243123940967, + 27.451191870235014, + 1.2843067812400888, + 0.6056368657184741, + -0.7397550923444113, + -0.9474784886521671, + -3.5764775426791067, + 0.6774217069894385, + 9.862864905741365 + ], + "sd": [ + 4.611952770878312, + 1.8021585740993236, + 0.020606193535398016, + 0.01442123744551132, + 0.1089701106364004, + 0.7765059647343666, + 0.24314379657717025, + 0.054392975262741595, + 3.1928660852770103 + ], + "mcse": [ + 0.2979854152886711, + 0.13102004051610847, + 0.0014592288085324978, + 0.0010075951933882481, + 0.007155140492782249, + 0.04258418424211884, + 0.013508076515018131, + 0.007444859156939617, + 0.19594113080973632 + ], + "walkers": 32, + "steps": 3000, + "tau": 163.97415864496037, + "tau_reliable": false, + "start_search_s": 8.633430437999777, + "start": "map" + } + } + } + } +} \ No newline at end of file diff --git a/benchmarks/results/hpc/run/alpha_gp/1.json b/benchmarks/results/hpc/run/alpha_gp/1.json new file mode 100644 index 0000000..4056875 --- /dev/null +++ b/benchmarks/results/hpc/run/alpha_gp/1.json @@ -0,0 +1,70 @@ +{ + "meta": { + "jax": "0.12.0.1", + "blackjax": "1.7.1" + }, + "problems": { + "alpha_gp": { + "ndim": 9, + "names": [ + "V", + "W", + "r", + "a", + "log_sigma_A", + "log_sigma_B", + "log_ell", + "log_A_q", + "p" + ], + "samplers": { + "dynesty": { + "wall_s": 583.9535172400065, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 274264, + "evidence": 0 + }, + "min_ess": 3620.3903008264865, + "logz": -84.61087809698172, + "logz_err": 0.3102913374579773, + "mean": [ + 163.02837684354068, + 27.778174525440996, + 1.2889133919149358, + 0.6074284263254781, + -0.7186881645020988, + -0.9026900969906381, + -3.7161723304147256, + 0.3575584524023259, + 8.001019521109765 + ], + "sd": [ + 15.482998157195711, + 2.0803218210278915, + 0.0229305639624505, + 0.016236986764532654, + 0.10586897612534911, + 0.7480571339949461, + 0.2873481775835243, + 0.24141178083816545, + 3.289118425082392 + ], + "mcse": [ + 0.2573222651451831, + 0.034574254791153794, + 0.00038109832475385224, + 0.0002698533043123895, + 0.0017595070714721511, + 0.012432460058656848, + 0.004775630868803581, + 0.004012183276605166, + 0.0546640511663183 + ], + "start": "prior" + } + } + } + } +} \ No newline at end of file diff --git a/benchmarks/results/hpc/run/alpha_gp/2.json b/benchmarks/results/hpc/run/alpha_gp/2.json new file mode 100644 index 0000000..52fb5fa --- /dev/null +++ b/benchmarks/results/hpc/run/alpha_gp/2.json @@ -0,0 +1,70 @@ +{ + "meta": { + "jax": "0.12.0.1", + "blackjax": "1.7.1" + }, + "problems": { + "alpha_gp": { + "ndim": 9, + "names": [ + "V", + "W", + "r", + "a", + "log_sigma_A", + "log_sigma_B", + "log_ell", + "log_A_q", + "p" + ], + "samplers": { + "pocomc": { + "wall_s": 1048.4590793251991, + "calls": { + "search": 0, + "warmup": 438272, + "sampling": 0, + "evidence": 4096 + }, + "min_ess": 7624.787567236035, + "logz": -84.52805111876745, + "logz_err": 0.01451255179244961, + "mean": [ + 156.60965185420247, + 27.083739424565632, + 1.294941360357847, + 0.608973291874042, + -0.7212795636302209, + -0.9289959437922514, + -3.709787847137401, + 0.3673958819488922, + 7.915460039017284 + ], + "sd": [ + 20.24651456794636, + 2.4271554714157815, + 0.025518287909190925, + 0.016809943592638824, + 0.10433998758984042, + 0.7550012728491438, + 0.2857228851302393, + 0.23659184764290847, + 3.32078148272165 + ], + "mcse": [ + 0.23186564026022985, + 0.027796090803792275, + 0.000292238653944751, + 0.00019250959570177984, + 0.0011949147072239364, + 0.008646369869686253, + 0.0032721345432268558, + 0.0027094797008134137, + 0.038030008674904026 + ], + "start": "prior" + } + } + } + } +} \ No newline at end of file diff --git a/benchmarks/results/hpc/run/alpha_gp/3.json b/benchmarks/results/hpc/run/alpha_gp/3.json new file mode 100644 index 0000000..7aeb718 --- /dev/null +++ b/benchmarks/results/hpc/run/alpha_gp/3.json @@ -0,0 +1,74 @@ +{ + "meta": { + "jax": "0.12.0.1", + "blackjax": "1.7.1" + }, + "problems": { + "alpha_gp": { + "ndim": 9, + "names": [ + "V", + "W", + "r", + "a", + "log_sigma_A", + "log_sigma_B", + "log_ell", + "log_A_q", + "p" + ], + "samplers": { + "NUTS": { + "wall_s": 779.6173506230116, + "calls": { + "search": 1744, + "warmup": 108660, + "sampling": 109428, + "evidence": 0 + }, + "min_ess": 704.7949092717204, + "min_ess_tail": 396.76858313875437, + "max_rhat": 1.0076293846263553, + "mean": [ + 169.0168508830326, + 27.999696465182623, + 1.2845393182084937, + 0.6052594888429003, + -0.7278653794150144, + -0.9550100927370497, + -3.710084307932723, + 0.39195581469525004, + 8.25236553664251 + ], + "sd": [ + 4.8395557823986675, + 1.95976936444366, + 0.021421555756394508, + 0.014979722768714695, + 0.1030637814184032, + 0.7589472840466936, + 0.2740234292867173, + 0.22864409361087518, + 3.452556915287604 + ], + "mcse": [ + 0.17313446170945632, + 0.06398860536087854, + 0.0007873493312907622, + 0.0005508456647427851, + 0.0027157253074529446, + 0.02019690305285082, + 0.00852530728313697, + 0.0086124875638174, + 0.12039766959383225 + ], + "divergences": 0, + "warmup": 300, + "draws": 1000, + "start_search_s": 8.92593070998555, + "start": "map" + } + } + } + } +} \ No newline at end of file diff --git a/benchmarks/results/hpc/run/alpha_gp/4.json b/benchmarks/results/hpc/run/alpha_gp/4.json new file mode 100644 index 0000000..cc7f915 --- /dev/null +++ b/benchmarks/results/hpc/run/alpha_gp/4.json @@ -0,0 +1,78 @@ +{ + "meta": { + "jax": "0.12.0.1", + "blackjax": "1.7.1" + }, + "problems": { + "alpha_gp": { + "ndim": 9, + "names": [ + "V", + "W", + "r", + "a", + "log_sigma_A", + "log_sigma_B", + "log_ell", + "log_A_q", + "p" + ], + "samplers": { + "ptemcee": { + "wall_s": 859.0433235039236, + "calls": { + "search": 1744, + "warmup": 170496, + "sampling": 341504, + "evidence": 0 + }, + "min_ess": 62.5228182443612, + "min_ess_tail": 646.6770734798642, + "max_rhat": 1.446638683250899, + "mean": [ + 162.4243294042789, + 26.697427154414378, + 1.2902798062781693, + 0.607937679973119, + -0.7301546716060922, + -0.9774685473939297, + -3.546702538079116, + 0.6931083464785269, + 9.833075369735115 + ], + "sd": [ + 17.223396948892123, + 2.169207624491634, + 0.02592758210923228, + 0.017012167734316942, + 0.1037235172018952, + 0.7459368423388808, + 0.2676547610600329, + 9.057225521260815e-05, + 3.1167081060765174 + ], + "mcse": [ + 0.2210804046942114, + 0.026093382917047128, + 0.00033137226407576735, + 0.00019638984273120174, + 0.0012849868787806215, + 0.009221521766003252, + 0.0032546785557961396, + 1.145449399086702e-05, + 0.037680991135575416 + ], + "walkers": 32, + "temps": 8, + "steps": 2000, + "logz": -89.35697034343099, + "logz_err": 4.86782960831539, + "tau": 121.28581056230007, + "tau_reliable": false, + "start_search_s": 8.880032461951487, + "start": "map" + } + } + } + } +} \ No newline at end of file diff --git a/benchmarks/results/hpc/run/alpha_gp/5.json b/benchmarks/results/hpc/run/alpha_gp/5.json new file mode 100644 index 0000000..d7d5a36 --- /dev/null +++ b/benchmarks/results/hpc/run/alpha_gp/5.json @@ -0,0 +1,75 @@ +{ + "meta": { + "jax": "0.12.0.1", + "blackjax": "1.7.1" + }, + "problems": { + "alpha_gp": { + "ndim": 9, + "names": [ + "V", + "W", + "r", + "a", + "log_sigma_A", + "log_sigma_B", + "log_ell", + "log_A_q", + "p" + ], + "samplers": { + "HMC": { + "wall_s": 203.4178415259812, + "calls": { + "search": 1744, + "warmup": 12000, + "sampling": 40000, + "evidence": 0 + }, + "min_ess": 202.80325169856414, + "min_ess_tail": 266.67137106392977, + "max_rhat": 1.0135569206023398, + "mean": [ + 168.43287755394684, + 27.98178789569105, + 1.2868735664008186, + 0.6037094961811927, + -0.7228759055986412, + -0.9550464443744845, + -3.71270258646312, + 0.37249154985520305, + 8.049277425649974 + ], + "sd": [ + 4.862328377431697, + 2.00201173818871, + 0.022457517528032666, + 0.015612468192075074, + 0.10744749475088079, + 0.7980066698388555, + 0.291631928034708, + 0.2345294636058762, + 3.4654747517294506 + ], + "mcse": [ + 0.2858666949209848, + 0.12861089105557316, + 0.0015533158759512477, + 0.0010963118528339389, + 0.003738013927023074, + 0.03006341881739586, + 0.01578741588434424, + 0.010441191099474703, + 0.2197540002217163 + ], + "divergences": 0, + "warmup": 300, + "draws": 1000, + "num_integration_steps": 20, + "start_search_s": 8.865733193990309, + "start": "map" + } + } + } + } +} \ No newline at end of file diff --git a/benchmarks/results/hpc/run/alpha_gp/6.json b/benchmarks/results/hpc/run/alpha_gp/6.json new file mode 100644 index 0000000..23b57c1 --- /dev/null +++ b/benchmarks/results/hpc/run/alpha_gp/6.json @@ -0,0 +1,74 @@ +{ + "meta": { + "jax": "0.12.0.1", + "blackjax": "1.7.1" + }, + "problems": { + "alpha_gp": { + "ndim": 9, + "names": [ + "V", + "W", + "r", + "a", + "log_sigma_A", + "log_sigma_B", + "log_ell", + "log_A_q", + "p" + ], + "samplers": { + "PyMC NUTS": { + "wall_s": 3037.328953217948, + "calls": { + "search": 1744, + "warmup": 61225, + "sampling": 77800, + "evidence": 0 + }, + "min_ess": 460.3261926314152, + "min_ess_tail": 435.75158750605954, + "max_rhat": 1.0092975869743244, + "mean": [ + 168.7371462532302, + 28.095345808790142, + 1.2851529289350512, + 0.6048223135655674, + -0.7209838803414215, + -0.9381471589018388, + -3.720228480768489, + 0.36824972527630007, + 8.174248210342698 + ], + "sd": [ + 4.8406154983918785, + 1.956888389640902, + 0.021176083760158726, + 0.014737492014638958, + 0.10727537862486333, + 0.768957193083262, + 0.28587301572594964, + 0.24117596217359777, + 3.3245557990431314 + ], + "mcse": [ + 0.22214636167411345, + 0.07247217906018755, + 0.0009815666162991921, + 0.0006868956076236367, + 0.002969703642491974, + 0.023896574835145356, + 0.01129234857740955, + 0.008430101900280719, + 0.10202181015722014 + ], + "divergences": 0, + "warmup": 300, + "draws": 1000, + "start_search_s": 24.37066104396945, + "start": "map" + } + } + } + } +} \ No newline at end of file diff --git a/benchmarks/results/hpc/run/alpha_gp/7.json b/benchmarks/results/hpc/run/alpha_gp/7.json new file mode 100644 index 0000000..fd96252 --- /dev/null +++ b/benchmarks/results/hpc/run/alpha_gp/7.json @@ -0,0 +1,74 @@ +{ + "meta": { + "jax": "0.12.0.1", + "blackjax": "1.7.1" + }, + "problems": { + "alpha_gp": { + "ndim": 9, + "names": [ + "V", + "W", + "r", + "a", + "log_sigma_A", + "log_sigma_B", + "log_ell", + "log_A_q", + "p" + ], + "samplers": { + "PyMC HMC": { + "wall_s": 867.5749648273923, + "calls": { + "search": 1744, + "warmup": 105349, + "sampling": 41120, + "evidence": 0 + }, + "min_ess": 642.1287693310289, + "min_ess_tail": 426.49428554492005, + "max_rhat": 1.0019782817766703, + "mean": [ + 168.62165272977666, + 28.03689004176751, + 1.285432492564679, + 0.6046692730087844, + -0.7276272323944933, + -0.907064051400087, + -3.7256235567346923, + 0.3735394122696315, + 8.085893426406946 + ], + "sd": [ + 4.655846294203766, + 1.9303446782266507, + 0.020947504987067746, + 0.014566565446151026, + 0.09942581778547532, + 0.7747949208801906, + 0.2823009703677893, + 0.23543020769722023, + 3.3167997873948556 + ], + "mcse": [ + 0.1748760847207188, + 0.06290182371708503, + 0.0008266491784218725, + 0.0005726760130002551, + 0.002000215140951069, + 0.016560522779997238, + 0.009100526456621776, + 0.008021370855011853, + 0.08837001197579034 + ], + "divergences": 2, + "warmup": 300, + "draws": 1000, + "start_search_s": 15.023620477411896, + "start": "map" + } + } + } + } +} \ No newline at end of file diff --git a/benchmarks/results/hpc/run/n40ca_gp/0.json b/benchmarks/results/hpc/run/n40ca_gp/0.json new file mode 100644 index 0000000..3a2cdc8 --- /dev/null +++ b/benchmarks/results/hpc/run/n40ca_gp/0.json @@ -0,0 +1,67 @@ +{ + "meta": { + "jax": "0.12.0.1", + "blackjax": "1.7.1" + }, + "problems": { + "n40ca_gp": { + "ndim": 7, + "names": [ + "Vv", + "Wv", + "Rv", + "av", + "log_ell_xs", + "log_A_xs", + "amp_slope_xs" + ], + "samplers": { + "emcee": { + "wall_s": 41.09689370309934, + "calls": { + "search": 778, + "warmup": 32000, + "sampling": 64000, + "evidence": 0 + }, + "min_ess": 485.42878962228025, + "min_ess_tail": 1712.2570798783267, + "max_rhat": 1.0454143387593746, + "mean": [ + 43.62137221729963, + 13.720037467081932, + 4.296804196865033, + 0.48465282328690157, + -1.2651853921781757, + -1.7914905833223087, + 2.2516945417687104 + ], + "sd": [ + 1.6875381174250461, + 1.0903021914740778, + 0.07669578987143871, + 0.026047234195283365, + 0.20943305466582576, + 0.49803117193873436, + 0.6982480133378612 + ], + "mcse": [ + 0.0586406759559441, + 0.04017008016204191, + 0.0027358734324242746, + 0.0008927603593203183, + 0.009505664069959717, + 0.017796817358649443, + 0.024101604168519666 + ], + "walkers": 32, + "steps": 3000, + "tau": 65.12651537397433, + "tau_reliable": false, + "start_search_s": 2.7908549271523952, + "start": "map" + } + } + } + } +} \ No newline at end of file diff --git a/benchmarks/results/hpc/run/n40ca_gp/1.json b/benchmarks/results/hpc/run/n40ca_gp/1.json new file mode 100644 index 0000000..3cb9df7 --- /dev/null +++ b/benchmarks/results/hpc/run/n40ca_gp/1.json @@ -0,0 +1,62 @@ +{ + "meta": { + "jax": "0.12.0.1", + "blackjax": "1.7.1" + }, + "problems": { + "n40ca_gp": { + "ndim": 7, + "names": [ + "Vv", + "Wv", + "Rv", + "av", + "log_ell_xs", + "log_A_xs", + "amp_slope_xs" + ], + "samplers": { + "dynesty": { + "wall_s": 283.54432407487184, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 278094, + "evidence": 0 + }, + "min_ess": 3843.195777188117, + "logz": -11.915705799828652, + "logz_err": 0.3363576952566165, + "mean": [ + 43.53479784480955, + 13.687687614899206, + 4.299874134164965, + 0.48338110707442844, + -1.2661535570206617, + -1.8002074822598002, + 2.2435916641384446 + ], + "sd": [ + 1.7074109408799056, + 1.084812370184361, + 0.0762219892908915, + 0.027184506419138638, + 0.2029827485118998, + 0.4497839009121225, + 0.6356672955825668 + ], + "mcse": [ + 0.027541767370622052, + 0.01749880431537677, + 0.0012295155473783723, + 0.00043850565435363476, + 0.0032742578285712433, + 0.0072553380497776265, + 0.01025377099377444 + ], + "start": "prior" + } + } + } + } +} \ No newline at end of file diff --git a/benchmarks/results/hpc/run/n40ca_gp/2.json b/benchmarks/results/hpc/run/n40ca_gp/2.json new file mode 100644 index 0000000..1b7a8ba --- /dev/null +++ b/benchmarks/results/hpc/run/n40ca_gp/2.json @@ -0,0 +1,62 @@ +{ + "meta": { + "jax": "0.12.0.1", + "blackjax": "1.7.1" + }, + "problems": { + "n40ca_gp": { + "ndim": 7, + "names": [ + "Vv", + "Wv", + "Rv", + "av", + "log_ell_xs", + "log_A_xs", + "amp_slope_xs" + ], + "samplers": { + "pocomc": { + "wall_s": 335.92207670304924, + "calls": { + "search": 0, + "warmup": 276480, + "sampling": 0, + "evidence": 4096 + }, + "min_ess": 7180.300088780893, + "logz": -11.35233651837971, + "logz_err": 0.010368892853628514, + "mean": [ + 43.61952472425906, + 13.732510878830029, + 4.296781131282306, + 0.48491101219874144, + -1.2782037642255066, + -1.796844699335886, + 2.214137790291506 + ], + "sd": [ + 1.6628138873891458, + 1.0660093502221633, + 0.07194432713310954, + 0.025985932612258792, + 0.2042591934536338, + 0.48050086827043087, + 0.6680072502286669 + ], + "mcse": [ + 0.019623313644259472, + 0.012580262881956069, + 0.0008490343429082856, + 0.0003066669756948012, + 0.002410517646179656, + 0.005670519903592199, + 0.007883333118211253 + ], + "start": "prior" + } + } + } + } +} \ No newline at end of file diff --git a/benchmarks/results/hpc/run/n40ca_gp/3.json b/benchmarks/results/hpc/run/n40ca_gp/3.json new file mode 100644 index 0000000..25337f3 --- /dev/null +++ b/benchmarks/results/hpc/run/n40ca_gp/3.json @@ -0,0 +1,66 @@ +{ + "meta": { + "jax": "0.12.0.1", + "blackjax": "1.7.1" + }, + "problems": { + "n40ca_gp": { + "ndim": 7, + "names": [ + "Vv", + "Wv", + "Rv", + "av", + "log_ell_xs", + "log_A_xs", + "amp_slope_xs" + ], + "samplers": { + "NUTS": { + "wall_s": 94.41112445713952, + "calls": { + "search": 778, + "warmup": 46389, + "sampling": 48288, + "evidence": 0 + }, + "min_ess": 491.2964672357652, + "min_ess_tail": 463.68879148901203, + "max_rhat": 1.0047101788842845, + "mean": [ + 43.55303001943829, + 13.703014001423654, + 4.300296224180379, + 0.48322547649377967, + -1.2775471532572347, + -1.8403651874436695, + 2.2889275682449766 + ], + "sd": [ + 1.68069675979444, + 1.095629835028646, + 0.07641834698149594, + 0.025520076548930626, + 0.2153779827915109, + 0.47940453132061284, + 0.6763736636876725 + ], + "mcse": [ + 0.07542873395027143, + 0.03712053120752365, + 0.0034020542491934934, + 0.0011513573880815946, + 0.007108314004870394, + 0.017477388842804073, + 0.021278609949374465 + ], + "divergences": 0, + "warmup": 300, + "draws": 1000, + "start_search_s": 2.6331109800376, + "start": "map" + } + } + } + } +} \ No newline at end of file diff --git a/benchmarks/results/hpc/run/n40ca_gp/4.json b/benchmarks/results/hpc/run/n40ca_gp/4.json new file mode 100644 index 0000000..b6f1baa --- /dev/null +++ b/benchmarks/results/hpc/run/n40ca_gp/4.json @@ -0,0 +1,70 @@ +{ + "meta": { + "jax": "0.12.0.1", + "blackjax": "1.7.1" + }, + "problems": { + "n40ca_gp": { + "ndim": 7, + "names": [ + "Vv", + "Wv", + "Rv", + "av", + "log_ell_xs", + "log_A_xs", + "amp_slope_xs" + ], + "samplers": { + "ptemcee": { + "wall_s": 224.83903706120327, + "calls": { + "search": 778, + "warmup": 170496, + "sampling": 341504, + "evidence": 0 + }, + "min_ess": 4418.491493356643, + "min_ess_tail": 5202.396888625849, + "max_rhat": 1.0077203575450586, + "mean": [ + 43.35488813773201, + 13.81555280988057, + 4.304807316232701, + 0.4833808083232561, + -1.2871542592951617, + -1.8469366522865287, + 2.2662224722828492 + ], + "sd": [ + 1.9544164670979307, + 1.0913407129653634, + 0.0793241846756245, + 0.0309061907823314, + 0.21313215173899208, + 0.5007107187591511, + 0.6867392390968479 + ], + "mcse": [ + 0.028022168578579785, + 0.012856535664399813, + 0.00119335211002356, + 0.00046097124928276946, + 0.00268404567775654, + 0.007281496369217014, + 0.010209954520959914 + ], + "walkers": 32, + "temps": 8, + "steps": 2000, + "logz": -17.38024954996489, + "logz_err": 21.772857487744556, + "tau": 8.975807627705452, + "tau_reliable": true, + "start_search_s": 2.606151465792209, + "start": "map" + } + } + } + } +} \ No newline at end of file diff --git a/benchmarks/results/hpc/run/n40ca_gp/5.json b/benchmarks/results/hpc/run/n40ca_gp/5.json new file mode 100644 index 0000000..a5d409f --- /dev/null +++ b/benchmarks/results/hpc/run/n40ca_gp/5.json @@ -0,0 +1,67 @@ +{ + "meta": { + "jax": "0.12.0.1", + "blackjax": "1.7.1" + }, + "problems": { + "n40ca_gp": { + "ndim": 7, + "names": [ + "Vv", + "Wv", + "Rv", + "av", + "log_ell_xs", + "log_A_xs", + "amp_slope_xs" + ], + "samplers": { + "HMC": { + "wall_s": 55.98467552475631, + "calls": { + "search": 778, + "warmup": 12000, + "sampling": 40000, + "evidence": 0 + }, + "min_ess": 721.6795864726267, + "min_ess_tail": 877.2220885214015, + "max_rhat": 1.0026773321561282, + "mean": [ + 43.52784886204173, + 13.71388500537304, + 4.301764921954218, + 0.4830027522846823, + -1.277559733476414, + -1.828460722940568, + 2.2727491795362234 + ], + "sd": [ + 1.6540766591432534, + 1.0754297561619388, + 0.07392227077905184, + 0.02479088292252604, + 0.2122410968147478, + 0.48724476620246415, + 0.6757486054653791 + ], + "mcse": [ + 0.060417654258251595, + 0.026065983068517734, + 0.0027517127035367782, + 0.0008960605126449429, + 0.005339497757599164, + 0.015123253149474944, + 0.017253516046483636 + ], + "divergences": 0, + "warmup": 300, + "draws": 1000, + "num_integration_steps": 20, + "start_search_s": 3.3320546047762036, + "start": "map" + } + } + } + } +} \ No newline at end of file diff --git a/benchmarks/results/hpc/run/n40ca_gp/6.json b/benchmarks/results/hpc/run/n40ca_gp/6.json new file mode 100644 index 0000000..ac38a9b --- /dev/null +++ b/benchmarks/results/hpc/run/n40ca_gp/6.json @@ -0,0 +1,66 @@ +{ + "meta": { + "jax": "0.12.0.1", + "blackjax": "1.7.1" + }, + "problems": { + "n40ca_gp": { + "ndim": 7, + "names": [ + "Vv", + "Wv", + "Rv", + "av", + "log_ell_xs", + "log_A_xs", + "amp_slope_xs" + ], + "samplers": { + "PyMC NUTS": { + "wall_s": 139.20244341949, + "calls": { + "search": 778, + "warmup": 36904, + "sampling": 46992, + "evidence": 0 + }, + "min_ess": 625.5913489323723, + "min_ess_tail": 667.1303248148098, + "max_rhat": 1.0042452492409042, + "mean": [ + 43.491735286141136, + 13.719324268979308, + 4.303566943971951, + 0.4824798916109016, + -1.282683847267811, + -1.8369897902851458, + 2.2738473067518252 + ], + "sd": [ + 1.6620633844642203, + 1.0497082914627671, + 0.07500924346463571, + 0.0247979398991766, + 0.20943436194736947, + 0.493120376222092, + 0.6795633918294639 + ], + "mcse": [ + 0.06633215181926733, + 0.029900777369091126, + 0.0029804989422732085, + 0.0009914486731681343, + 0.006609874460616724, + 0.017729033463307547, + 0.025751109911651023 + ], + "divergences": 0, + "warmup": 300, + "draws": 1000, + "start_search_s": 2.586575933266431, + "start": "map" + } + } + } + } +} \ No newline at end of file diff --git a/benchmarks/results/hpc/run/n40ca_gp/7.json b/benchmarks/results/hpc/run/n40ca_gp/7.json new file mode 100644 index 0000000..8762349 --- /dev/null +++ b/benchmarks/results/hpc/run/n40ca_gp/7.json @@ -0,0 +1,66 @@ +{ + "meta": { + "jax": "0.12.0.1", + "blackjax": "1.7.1" + }, + "problems": { + "n40ca_gp": { + "ndim": 7, + "names": [ + "Vv", + "Wv", + "Rv", + "av", + "log_ell_xs", + "log_A_xs", + "amp_slope_xs" + ], + "samplers": { + "PyMC HMC": { + "wall_s": 106.38749700132757, + "calls": { + "search": 778, + "warmup": 39233, + "sampling": 21140, + "evidence": 0 + }, + "min_ess": 654.8807380807436, + "min_ess_tail": 692.4326376373216, + "max_rhat": 1.0029859005502124, + "mean": [ + 43.59224051837716, + 13.736480255134593, + 4.299273360289709, + 0.48363883652352635, + -1.2753412707647096, + -1.801201044410682, + 2.24537521408511 + ], + "sd": [ + 1.6357817634958687, + 1.0838424894146599, + 0.07298399020261225, + 0.024113046274629738, + 0.2017377473284159, + 0.49238635252139634, + 0.6869096439072709 + ], + "mcse": [ + 0.06270582720817715, + 0.03324771210957765, + 0.0028519801283471615, + 0.0009040602177887595, + 0.00684189997161433, + 0.01772296240664249, + 0.022372287883302918 + ], + "divergences": 0, + "warmup": 300, + "draws": 1000, + "start_search_s": 2.7437847647815943, + "start": "map" + } + } + } + } +} \ No newline at end of file diff --git a/benchmarks/results/hpc/run/omp/0.json b/benchmarks/results/hpc/run/omp/0.json new file mode 100644 index 0000000..69d94e0 --- /dev/null +++ b/benchmarks/results/hpc/run/omp/0.json @@ -0,0 +1,75 @@ +{ + "meta": { + "jax": "0.12.0.1", + "blackjax": "1.7.1" + }, + "problems": { + "omp": { + "ndim": 9, + "names": [ + "Vv", + "Wv", + "Rv", + "av", + "Wd", + "Rd", + "ad", + "log_sigma_A", + "log_sigma_B" + ], + "samplers": { + "emcee": { + "wall_s": 183.3095257228706, + "calls": { + "search": 876, + "warmup": 32000, + "sampling": 64000, + "evidence": 0 + }, + "min_ess": 53.985223173423535, + "min_ess_tail": 337.71724370196233, + "max_rhat": 1.5927663322026995, + "mean": [ + 46.03100318095825, + 3.07929591348816, + 3.946376080688598, + 0.7995540024439179, + 9.412814405883646, + 4.4465197742045985, + 0.3044394883167146, + -1.654385169070702, + -2.9234559532893853 + ], + "sd": [ + 2.003401613708527, + 1.0987943926561647, + 0.09233848396033632, + 0.0359589632454637, + 0.6247028531925346, + 0.0506915058374228, + 0.03203706862021923, + 0.11560103020758336, + 0.23380748020235576 + ], + "mcse": [ + 0.11449235862878943, + 0.054467667767347266, + 0.005255518964245706, + 0.001873998903737896, + 0.035370254665103865, + 0.0025755271682890496, + 0.001442283775295129, + 0.006023436691817287, + 0.03182152222720434 + ], + "walkers": 32, + "steps": 3000, + "tau": 169.92065726841378, + "tau_reliable": false, + "start_search_s": 5.632592704962008, + "start": "map" + } + } + } + } +} \ No newline at end of file diff --git a/benchmarks/results/hpc/run/omp/1.json b/benchmarks/results/hpc/run/omp/1.json new file mode 100644 index 0000000..b7325f2 --- /dev/null +++ b/benchmarks/results/hpc/run/omp/1.json @@ -0,0 +1,70 @@ +{ + "meta": { + "jax": "0.12.0.1", + "blackjax": "1.7.1" + }, + "problems": { + "omp": { + "ndim": 9, + "names": [ + "Vv", + "Wv", + "Rv", + "av", + "Wd", + "Rd", + "ad", + "log_sigma_A", + "log_sigma_B" + ], + "samplers": { + "dynesty": { + "wall_s": 564.5745539650088, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 255013, + "evidence": 0 + }, + "min_ess": 4116.9695679152, + "logz": -6.416208833399547, + "logz_err": 0.31702450127285803, + "mean": [ + 46.315232318467906, + 3.3138074104089585, + 3.9383183068012793, + 0.7973035359938518, + 9.19931142522417, + 4.416747300697775, + 0.3199353318946708, + -1.6354042032797913, + -1.927058551774978 + ], + "sd": [ + 2.4851563273897432, + 1.2447048097370987, + 0.1259180135014079, + 0.0434896853071639, + 1.1314650134232822, + 0.09660832177071606, + 0.05443689100478373, + 0.1336700823175724, + 0.8069516737836944 + ], + "mcse": [ + 0.03873155064336246, + 0.0193989194333724, + 0.0019624519645264657, + 0.0006777935578433128, + 0.017634059469661637, + 0.0015056558277615046, + 0.0008484074734379163, + 0.002083269171329496, + 0.01257646823881179 + ], + "start": "prior" + } + } + } + } +} \ No newline at end of file diff --git a/benchmarks/results/hpc/run/omp/2.json b/benchmarks/results/hpc/run/omp/2.json new file mode 100644 index 0000000..a3d6682 --- /dev/null +++ b/benchmarks/results/hpc/run/omp/2.json @@ -0,0 +1,70 @@ +{ + "meta": { + "jax": "0.12.0.1", + "blackjax": "1.7.1" + }, + "problems": { + "omp": { + "ndim": 9, + "names": [ + "Vv", + "Wv", + "Rv", + "av", + "Wd", + "Rd", + "ad", + "log_sigma_A", + "log_sigma_B" + ], + "samplers": { + "pocomc": { + "wall_s": 807.2303060659906, + "calls": { + "search": 0, + "warmup": 307200, + "sampling": 0, + "evidence": 4096 + }, + "min_ess": 6815.42927035514, + "logz": -6.685416953322681, + "logz_err": 0.012461176043330564, + "mean": [ + 45.71500677709557, + 3.3518412825560846, + 3.9651911254169474, + 0.7895701545899648, + 9.001866525855602, + 4.413858809206461, + 0.32404354636388677, + -1.6260660654523065, + -1.8528349297575661 + ], + "sd": [ + 2.533443877728667, + 1.257216432392475, + 0.13407327224522073, + 0.0467272007243898, + 1.224323610418969, + 0.11359262480744094, + 0.06392954679710527, + 0.12171861863294449, + 0.8423448891556087 + ], + "mcse": [ + 0.030687724064007754, + 0.015228721387973286, + 0.0016240358111696749, + 0.0005660087656645356, + 0.014830289098518168, + 0.0013759527718144504, + 0.0007743815874088025, + 0.0014743833147031495, + 0.010203363000213664 + ], + "start": "prior" + } + } + } + } +} \ No newline at end of file diff --git a/benchmarks/results/hpc/run/omp/3.json b/benchmarks/results/hpc/run/omp/3.json new file mode 100644 index 0000000..0331b14 --- /dev/null +++ b/benchmarks/results/hpc/run/omp/3.json @@ -0,0 +1,74 @@ +{ + "meta": { + "jax": "0.12.0.1", + "blackjax": "1.7.1" + }, + "problems": { + "omp": { + "ndim": 9, + "names": [ + "Vv", + "Wv", + "Rv", + "av", + "Wd", + "Rd", + "ad", + "log_sigma_A", + "log_sigma_B" + ], + "samplers": { + "NUTS": { + "wall_s": 625.7669758679112, + "calls": { + "search": 876, + "warmup": 81863, + "sampling": 78792, + "evidence": 0 + }, + "min_ess": 3.1387580096539747, + "min_ess_tail": 75.1023641868547, + "max_rhat": 1.6943674913518298, + "mean": [ + 44.12337510757033, + 3.5395355773853585, + 4.063308981144169, + 0.759385210013522, + 8.322162677633386, + 4.317541577828031, + 0.3577244165718097, + -1.5993896151983003, + -1.7750907900094466 + ], + "sd": [ + 3.0852536163526163, + 1.4043253351316642, + 0.16504513041455643, + 0.05804909880473977, + 1.445036689159153, + 0.15352896247388081, + 0.0708107106435624, + 0.13213221961597643, + 0.8919425968190124 + ], + "mcse": [ + 1.6594079195035336, + 0.07968077921557346, + 0.0931587812399935, + 0.03189291660946422, + 0.7574624366931417, + 0.08321080010335914, + 0.03689370659117112, + 0.03886870785480621, + 0.02866882784852053 + ], + "divergences": 0, + "warmup": 300, + "draws": 1000, + "start_search_s": 5.625878345919773, + "start": "map" + } + } + } + } +} \ No newline at end of file diff --git a/benchmarks/results/hpc/run/omp/4.json b/benchmarks/results/hpc/run/omp/4.json new file mode 100644 index 0000000..1f68fd9 --- /dev/null +++ b/benchmarks/results/hpc/run/omp/4.json @@ -0,0 +1,78 @@ +{ + "meta": { + "jax": "0.12.0.1", + "blackjax": "1.7.1" + }, + "problems": { + "omp": { + "ndim": 9, + "names": [ + "Vv", + "Wv", + "Rv", + "av", + "Wd", + "Rd", + "ad", + "log_sigma_A", + "log_sigma_B" + ], + "samplers": { + "ptemcee": { + "wall_s": 927.4509301020298, + "calls": { + "search": 876, + "warmup": 170496, + "sampling": 341504, + "evidence": 0 + }, + "min_ess": 56.454004951527075, + "min_ess_tail": 590.2173048443929, + "max_rhat": 1.534660689836785, + "mean": [ + 45.629870582102185, + 3.1727181634061994, + 3.9696151092552, + 0.7899744804086718, + 9.123799826490998, + 4.427705401183557, + 0.3172077681817499, + -1.6249213582177293, + -2.9955537435979824 + ], + "sd": [ + 2.2603088992017053, + 1.1623333749669797, + 0.11592392755581832, + 0.0443949350245106, + 1.0743581154482607, + 0.0932185302630395, + 0.06308597815595574, + 0.12668251913796336, + 0.0005510034051969917 + ], + "mcse": [ + 0.030060971584452093, + 0.014838527154470161, + 0.001562136005646143, + 0.0006069798947629324, + 0.013086229509965457, + 0.0010699736430770529, + 0.0007799209601231984, + 0.0020134775496871717, + 7.333425836580016e-05 + ], + "walkers": 32, + "temps": 8, + "steps": 2000, + "logz": -11.953658854672948, + "logz_err": 2.344806177711348, + "tau": 97.46997819265792, + "tau_reliable": false, + "start_search_s": 5.622346699004993, + "start": "map" + } + } + } + } +} \ No newline at end of file diff --git a/benchmarks/results/hpc/run/omp/5.json b/benchmarks/results/hpc/run/omp/5.json new file mode 100644 index 0000000..9ab8b9f --- /dev/null +++ b/benchmarks/results/hpc/run/omp/5.json @@ -0,0 +1,75 @@ +{ + "meta": { + "jax": "0.12.0.1", + "blackjax": "1.7.1" + }, + "problems": { + "omp": { + "ndim": 9, + "names": [ + "Vv", + "Wv", + "Rv", + "av", + "Wd", + "Rd", + "ad", + "log_sigma_A", + "log_sigma_B" + ], + "samplers": { + "HMC": { + "wall_s": 213.51569985994138, + "calls": { + "search": 876, + "warmup": 12000, + "sampling": 40000, + "evidence": 0 + }, + "min_ess": 577.622697649186, + "min_ess_tail": 378.2684439658823, + "max_rhat": 1.0051036263906123, + "mean": [ + 46.30296429612228, + 3.2299681547253924, + 3.933098518899915, + 0.8014397479973022, + 9.42359498133739, + 4.440161263783986, + 0.3064086552141723, + -1.6472671108748314, + -1.8663844997727799 + ], + "sd": [ + 2.1117418325496033, + 1.1800855334121654, + 0.09795240893060006, + 0.03522292853354909, + 0.6100037173200725, + 0.050967404909348035, + 0.030655323471972907, + 0.1169876732465711, + 0.8859196245852299 + ], + "mcse": [ + 0.08407327536564183, + 0.045688832446253276, + 0.004075613534262863, + 0.0014259598819454343, + 0.0175097164487086, + 0.00168502531685712, + 0.0010106486549011976, + 0.0022405258908357495, + 0.0158090890116802 + ], + "divergences": 0, + "warmup": 300, + "draws": 1000, + "num_integration_steps": 20, + "start_search_s": 5.669675156939775, + "start": "map" + } + } + } + } +} \ No newline at end of file diff --git a/benchmarks/results/hpc/run/omp/6.json b/benchmarks/results/hpc/run/omp/6.json new file mode 100644 index 0000000..552b807 --- /dev/null +++ b/benchmarks/results/hpc/run/omp/6.json @@ -0,0 +1,74 @@ +{ + "meta": { + "jax": "0.12.0.1", + "blackjax": "1.7.1" + }, + "problems": { + "omp": { + "ndim": 9, + "names": [ + "Vv", + "Wv", + "Rv", + "av", + "Wd", + "Rd", + "ad", + "log_sigma_A", + "log_sigma_B" + ], + "samplers": { + "PyMC NUTS": { + "wall_s": 613.3576898110332, + "calls": { + "search": 876, + "warmup": 47938, + "sampling": 57740, + "evidence": 0 + }, + "min_ess": 498.6175588130325, + "min_ess_tail": 316.56344761222925, + "max_rhat": 1.0063164831539773, + "mean": [ + 46.370932135501384, + 3.3677258252948907, + 3.9298273951186427, + 0.803856920170553, + 9.404883951802764, + 4.440584617942902, + 0.3030710581015199, + -1.6462095241764922, + -1.8651091065871597 + ], + "sd": [ + 2.1086574464008114, + 1.2322892559394885, + 0.09543365526244633, + 0.03526731547165308, + 0.6325536686956763, + 0.05467843336633138, + 0.033836017093490024, + 0.12000412864871537, + 0.8200239406803693 + ], + "mcse": [ + 0.07731343738669215, + 0.050710990808763255, + 0.0033960454643685157, + 0.001474988952559132, + 0.02366099765300281, + 0.0023334855419760406, + 0.0015152889339828616, + 0.0036805428091531978, + 0.018852235647785754 + ], + "divergences": 0, + "warmup": 300, + "draws": 1000, + "start_search_s": 5.566087043029256, + "start": "map" + } + } + } + } +} \ No newline at end of file diff --git a/benchmarks/results/hpc/run/omp/7.json b/benchmarks/results/hpc/run/omp/7.json new file mode 100644 index 0000000..26410dc --- /dev/null +++ b/benchmarks/results/hpc/run/omp/7.json @@ -0,0 +1,74 @@ +{ + "meta": { + "jax": "0.12.0.1", + "blackjax": "1.7.1" + }, + "problems": { + "omp": { + "ndim": 9, + "names": [ + "Vv", + "Wv", + "Rv", + "av", + "Wd", + "Rd", + "ad", + "log_sigma_A", + "log_sigma_B" + ], + "samplers": { + "PyMC HMC": { + "wall_s": 727.1244522660272, + "calls": { + "search": 876, + "warmup": 104157, + "sampling": 25280, + "evidence": 0 + }, + "min_ess": 538.1536270451218, + "min_ess_tail": 762.341137473228, + "max_rhat": 1.006604690727678, + "mean": [ + 46.295649878341294, + 3.3505439333179035, + 3.93295395220897, + 0.8027134846723524, + 9.357011517961027, + 4.440959854151545, + 0.30417923175829487, + -1.647309023123504, + -1.866013209778152 + ], + "sd": [ + 2.0449975566806042, + 1.1786693075259704, + 0.09692935671728896, + 0.03567548323946401, + 0.5903003496695618, + 0.04898293757656547, + 0.030387607758827626, + 0.11934064327201321, + 0.8843120352332337 + ], + "mcse": [ + 0.08387119158059082, + 0.04750128938904647, + 0.0041431171661474855, + 0.001537859743916016, + 0.018620327910523995, + 0.0016579622264449177, + 0.0011386911579033794, + 0.002657796521789365, + 0.016007731563021592 + ], + "divergences": 0, + "warmup": 300, + "draws": 1000, + "start_search_s": 5.385184327024035, + "start": "map" + } + } + } + } +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/alpha_gp/0.json b/benchmarks/results/hpc/sweep/alpha_gp/0.json new file mode 100644 index 0000000..1914b7f --- /dev/null +++ b/benchmarks/results/hpc/sweep/alpha_gp/0.json @@ -0,0 +1,66 @@ +{ + "problem": "alpha_gp", + "names": [ + "V", + "W", + "r", + "a", + "log_sigma_A", + "log_sigma_B", + "log_ell", + "log_A_q", + "p" + ], + "runs": [ + { + "wall_s": 375.59827178902924, + "calls": { + "search": 0, + "warmup": 114688, + "sampling": 18944, + "evidence": 4096 + }, + "min_ess": 4500.585303487641, + "logz": -84.7494035351787, + "logz_err": 0.032658386800430046, + "mean": [ + 166.44392587578045, + 27.949968820098658, + 1.2877646823231133, + 0.6047728334560087, + -0.7154217387533758, + -0.9613850067458929, + -3.728765376709877, + 0.3683103196281828, + 8.11044797718979 + ], + "sd": [ + 8.985812016783223, + 1.9259891528295514, + 0.020271738562976486, + 0.015955206915692802, + 0.10531083954189711, + 0.7157262404814888, + 0.2799940917102756, + 0.22340922181985348, + 3.265500025734423 + ], + "mcse": [ + 0.13394386609897946, + 0.028709084133170977, + 0.0003021735854924846, + 0.00023783071521032287, + 0.001569779221290744, + 0.010668723042449915, + 0.004173634064289293, + 0.0033301714788629725, + 0.04867603477306723 + ], + "mode_share": 0.9594325020606757, + "mode_share_label": "share in the deeper family", + "n_effective": 1024, + "n_active": 512, + "seed": 100 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/alpha_gp/1.json b/benchmarks/results/hpc/sweep/alpha_gp/1.json new file mode 100644 index 0000000..522e200 --- /dev/null +++ b/benchmarks/results/hpc/sweep/alpha_gp/1.json @@ -0,0 +1,66 @@ +{ + "problem": "alpha_gp", + "names": [ + "V", + "W", + "r", + "a", + "log_sigma_A", + "log_sigma_B", + "log_ell", + "log_A_q", + "p" + ], + "runs": [ + { + "wall_s": 401.293140011956, + "calls": { + "search": 0, + "warmup": 132608, + "sampling": 24064, + "evidence": 4096 + }, + "min_ess": 4567.646732081971, + "logz": -84.55398520395693, + "logz_err": 0.025609067557337873, + "mean": [ + 157.52168463746497, + 27.285843507007314, + 1.2945148301803613, + 0.6081819348722768, + -0.7112462915599317, + -0.9040121958373252, + -3.7072869258970362, + 0.3532206660079889, + 7.646598419707208 + ], + "sd": [ + 19.62878682405043, + 2.3421927294306806, + 0.02478122156341419, + 0.016635088594391025, + 0.10690172060302704, + 0.73239062752245, + 0.2968998197418686, + 0.24203791268806704, + 3.277152314991682 + ], + "mcse": [ + 0.29043383176416976, + 0.03465583559679012, + 0.00036667091038151473, + 0.00024613811161705085, + 0.0015817521793490576, + 0.010836686862322177, + 0.0043930250540022186, + 0.0035812706635575545, + 0.048489797797979704 + ], + "mode_share": 0.7573023699592512, + "mode_share_label": "share in the deeper family", + "n_effective": 1024, + "n_active": 512, + "seed": 101 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/alpha_gp/2.json b/benchmarks/results/hpc/sweep/alpha_gp/2.json new file mode 100644 index 0000000..ec8b6a2 --- /dev/null +++ b/benchmarks/results/hpc/sweep/alpha_gp/2.json @@ -0,0 +1,66 @@ +{ + "problem": "alpha_gp", + "names": [ + "V", + "W", + "r", + "a", + "log_sigma_A", + "log_sigma_B", + "log_ell", + "log_A_q", + "p" + ], + "runs": [ + { + "wall_s": 430.938125903951, + "calls": { + "search": 0, + "warmup": 146432, + "sampling": 22016, + "evidence": 4096 + }, + "min_ess": 4543.118944726405, + "logz": -84.53861487858781, + "logz_err": 0.03455256967059559, + "mean": [ + 152.21468665244797, + 26.717372396931026, + 1.3026084318606552, + 0.6065581128871051, + -0.7049527200650276, + -0.959555400962045, + -3.7077422932806146, + 0.32145376147737137, + 7.484664703850772 + ], + "sd": [ + 21.1809871273061, + 2.3793050681157415, + 0.024707246704200093, + 0.017991682958127423, + 0.10837545183813306, + 0.7754649771232618, + 0.29215953035651, + 0.2463274204905509, + 3.2886431852440405 + ], + "mcse": [ + 0.314245554487178, + 0.03529986756189858, + 0.00036656187899776797, + 0.00026692837087113327, + 0.0016078808674486952, + 0.011504960569440628, + 0.004334539890127954, + 0.0036545651235327693, + 0.04879099803262714 + ], + "mode_share": 0.6607763442951172, + "mode_share_label": "share in the deeper family", + "n_effective": 1024, + "n_active": 512, + "seed": 102 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/alpha_gp/3.json b/benchmarks/results/hpc/sweep/alpha_gp/3.json new file mode 100644 index 0000000..665864c --- /dev/null +++ b/benchmarks/results/hpc/sweep/alpha_gp/3.json @@ -0,0 +1,66 @@ +{ + "problem": "alpha_gp", + "names": [ + "V", + "W", + "r", + "a", + "log_sigma_A", + "log_sigma_B", + "log_ell", + "log_A_q", + "p" + ], + "runs": [ + { + "wall_s": 632.4390710460721, + "calls": { + "search": 0, + "warmup": 243712, + "sampling": 11264, + "evidence": 4096 + }, + "min_ess": 5096.733400318381, + "logz": -84.52930933146715, + "logz_err": 0.035551544497456164, + "mean": [ + 155.46834886317708, + 27.22281723706611, + 1.2959994633140528, + 0.6088027043443077, + -0.7077963724293433, + -0.9618767935041194, + -3.7317269231389525, + 0.3411574037662179, + 7.806847390953757 + ], + "sd": [ + 20.541039600567093, + 2.3853112248610273, + 0.025372869493032243, + 0.01679497154012058, + 0.10598353920087082, + 0.732569712535845, + 0.2945368902458477, + 0.23611040534406771, + 3.3534721278235375 + ], + "mcse": [ + 0.28772424643008326, + 0.03341174001024809, + 0.00035540507669582617, + 0.00023525199425945698, + 0.0014845418997060827, + 0.010261314548610267, + 0.004125662889501807, + 0.0033072663201548893, + 0.04697304808641122 + ], + "mode_share": 0.7159454133970534, + "mode_share_label": "share in the deeper family", + "n_effective": 2048, + "n_active": 1024, + "seed": 100 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/alpha_gp/4.json b/benchmarks/results/hpc/sweep/alpha_gp/4.json new file mode 100644 index 0000000..7e09360 --- /dev/null +++ b/benchmarks/results/hpc/sweep/alpha_gp/4.json @@ -0,0 +1,66 @@ +{ + "problem": "alpha_gp", + "names": [ + "V", + "W", + "r", + "a", + "log_sigma_A", + "log_sigma_B", + "log_ell", + "log_A_q", + "p" + ], + "runs": [ + { + "wall_s": 586.4094659200637, + "calls": { + "search": 0, + "warmup": 227328, + "sampling": 5120, + "evidence": 4096 + }, + "min_ess": 5060.107380800517, + "logz": -84.12588965709446, + "logz_err": 0.2416267188982504, + "mean": [ + 158.9372242182714, + 27.318751116277227, + 1.2933099319705146, + 0.6078167043902418, + -0.7114462849594567, + -0.9818719288220419, + -3.715539867723702, + 0.3535119710261057, + 7.657371203828229 + ], + "sd": [ + 18.810275637694428, + 2.2689829697140222, + 0.02470707526693685, + 0.016414010080208253, + 0.10473528741047577, + 0.7181208030094027, + 0.2819046687851437, + 0.23523814000165588, + 3.223291242212792 + ], + "mcse": [ + 0.2644327813434941, + 0.03189711246443176, + 0.000347329340491257, + 0.00023074634429129612, + 0.001472357124808033, + 0.010095263085877628, + 0.00396298475771347, + 0.003306951840410806, + 0.04531267296000807 + ], + "mode_share": 0.7884868367500323, + "mode_share_label": "share in the deeper family", + "n_effective": 2048, + "n_active": 1024, + "seed": 101 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/alpha_gp/5.json b/benchmarks/results/hpc/sweep/alpha_gp/5.json new file mode 100644 index 0000000..efc8492 --- /dev/null +++ b/benchmarks/results/hpc/sweep/alpha_gp/5.json @@ -0,0 +1,66 @@ +{ + "problem": "alpha_gp", + "names": [ + "V", + "W", + "r", + "a", + "log_sigma_A", + "log_sigma_B", + "log_ell", + "log_A_q", + "p" + ], + "runs": [ + { + "wall_s": 528.1705428800778, + "calls": { + "search": 0, + "warmup": 203776, + "sampling": 4096, + "evidence": 4096 + }, + "min_ess": 4940.169028873489, + "logz": -84.56501789663889, + "logz_err": 0.023888898575943562, + "mean": [ + 157.41542256130202, + 27.246609079844877, + 1.294240267713694, + 0.6086035148691455, + -0.7175741310616923, + -0.904936555615476, + -3.717225738317766, + 0.3468733686403497, + 7.7191601079989525 + ], + "sd": [ + 19.7372256809072, + 2.3748917637886113, + 0.02485957324890199, + 0.016544329250462637, + 0.10458868041611209, + 0.7486518491616891, + 0.2829135832530519, + 0.2271277253969014, + 3.2046617160621453 + ], + "mcse": [ + 0.28081170257290644, + 0.03378881157856829, + 0.0003536899867347101, + 0.00023538471616318918, + 0.0014880371685627948, + 0.01065145648108056, + 0.0040251576527871764, + 0.0032314634438168847, + 0.04559437720409446 + ], + "mode_share": 0.7525193458018515, + "mode_share_label": "share in the deeper family", + "n_effective": 2048, + "n_active": 1024, + "seed": 102 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/alpha_gp/6.json b/benchmarks/results/hpc/sweep/alpha_gp/6.json new file mode 100644 index 0000000..18c92fe --- /dev/null +++ b/benchmarks/results/hpc/sweep/alpha_gp/6.json @@ -0,0 +1,66 @@ +{ + "problem": "alpha_gp", + "names": [ + "V", + "W", + "r", + "a", + "log_sigma_A", + "log_sigma_B", + "log_ell", + "log_A_q", + "p" + ], + "runs": [ + { + "wall_s": 928.0525154052302, + "calls": { + "search": 0, + "warmup": 370688, + "sampling": 0, + "evidence": 4096 + }, + "min_ess": 7591.175519425091, + "logz": -84.49650306094308, + "logz_err": 0.02278276331526999, + "mean": [ + 156.19714762734523, + 27.01614938479876, + 1.2958564124106242, + 0.6085762872624819, + -0.7205319510945096, + -0.9114492601215906, + -3.7083135793402584, + 0.37326350791553436, + 8.05033568370641 + ], + "sd": [ + 20.382916231315313, + 2.430891205390173, + 0.025551563454839336, + 0.016849339235211362, + 0.10523186839562108, + 0.7482306806173664, + 0.28341526171191206, + 0.23166219759473983, + 3.3498349369959057 + ], + "mcse": [ + 0.2339439417406383, + 0.027900437016854223, + 0.0002932668419191859, + 0.0001933874815397881, + 0.0012077937136091084, + 0.008587781687783135, + 0.003252885049513876, + 0.0026588917426029557, + 0.03844756954538856 + ], + "mode_share": 0.7263897957126952, + "mode_share_label": "share in the deeper family", + "n_effective": 4096, + "n_active": 2048, + "seed": 100 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/alpha_gp/7.json b/benchmarks/results/hpc/sweep/alpha_gp/7.json new file mode 100644 index 0000000..582bcd2 --- /dev/null +++ b/benchmarks/results/hpc/sweep/alpha_gp/7.json @@ -0,0 +1,66 @@ +{ + "problem": "alpha_gp", + "names": [ + "V", + "W", + "r", + "a", + "log_sigma_A", + "log_sigma_B", + "log_ell", + "log_A_q", + "p" + ], + "runs": [ + { + "wall_s": 1088.5490216268227, + "calls": { + "search": 0, + "warmup": 452608, + "sampling": 0, + "evidence": 4096 + }, + "min_ess": 7657.833008579278, + "logz": -84.51597167544634, + "logz_err": 0.016932283455287158, + "mean": [ + 156.8453638318768, + 27.069337735167153, + 1.2947977933314174, + 0.608864295465577, + -0.7212573961084257, + -0.9447888636666276, + -3.709663436515888, + 0.37087162575912946, + 7.984688061244383 + ], + "sd": [ + 20.124807978571543, + 2.4152088074968368, + 0.025493284790083705, + 0.016973670807841564, + 0.1045604599454184, + 0.7561228271572354, + 0.28373174082829894, + 0.2335199026487719, + 3.359391388802531 + ], + "mcse": [ + 0.22997403194777516, + 0.027599533274913275, + 0.0002913217108461862, + 0.00019396475816265874, + 0.001194853167372607, + 0.008640510527814872, + 0.003242313293091932, + 0.0026685230293562226, + 0.03838907598006265 + ], + "mode_share": 0.7374598373006163, + "mode_share_label": "share in the deeper family", + "n_effective": 4096, + "n_active": 2048, + "seed": 101 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/alpha_gp/8.json b/benchmarks/results/hpc/sweep/alpha_gp/8.json new file mode 100644 index 0000000..06dbddc --- /dev/null +++ b/benchmarks/results/hpc/sweep/alpha_gp/8.json @@ -0,0 +1,66 @@ +{ + "problem": "alpha_gp", + "names": [ + "V", + "W", + "r", + "a", + "log_sigma_A", + "log_sigma_B", + "log_ell", + "log_A_q", + "p" + ], + "runs": [ + { + "wall_s": 942.568611101713, + "calls": { + "search": 0, + "warmup": 378880, + "sampling": 0, + "evidence": 4096 + }, + "min_ess": 6865.934284607006, + "logz": -84.55184157348796, + "logz_err": 0.017504616918066897, + "mean": [ + 155.52395681032212, + 27.007224688111556, + 1.2965403828410718, + 0.6086332939584448, + -0.7155945846885606, + -0.950464641315256, + -3.713809950933923, + 0.3565088551716134, + 7.952657958707909 + ], + "sd": [ + 20.639809673594932, + 2.473469531150617, + 0.025899911082942408, + 0.017179816436940002, + 0.10530954454456168, + 0.7469538918871339, + 0.290820580453847, + 0.23355354918815963, + 3.335311683241913 + ], + "mcse": [ + 0.2490897558795925, + 0.029850852863150725, + 0.0003125708342750239, + 0.000207333127097981, + 0.001270919119760811, + 0.009014548366766554, + 0.0035097429935453885, + 0.0028186207853707563, + 0.0402519202502112 + ], + "mode_share": 0.7141050424314309, + "mode_share_label": "share in the deeper family", + "n_effective": 4096, + "n_active": 2048, + "seed": 102 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/elastic/0.json b/benchmarks/results/hpc/sweep/elastic/0.json new file mode 100644 index 0000000..6ffcaaa --- /dev/null +++ b/benchmarks/results/hpc/sweep/elastic/0.json @@ -0,0 +1,50 @@ +{ + "problem": "elastic", + "names": [ + "Vv", + "Wv", + "Rv", + "av", + "log_c" + ], + "runs": [ + { + "wall_s": 274.03448850894347, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 92338, + "evidence": 0 + }, + "min_ess": 909.00204475289, + "logz": 496.03580291296845, + "logz_err": 0.5007124421250798, + "mean": [ + 47.64856751415197, + 3.5022901135738853, + 4.1235994165356935, + 0.6923162056033074, + -3.0825195013237576 + ], + "sd": [ + 0.14796176294991006, + 0.03209596654612512, + 0.008108679967956427, + 0.0033568465033058234, + 0.08795398532030799 + ], + "mcse": [ + 0.0049075763757947645, + 0.0010645548149719344, + 0.0002689476352285339, + 0.00011133944519416078, + 0.0029172462662604777 + ], + "sampler": "dynesty", + "setting": "dynesty rwalk 200", + "seed": 100, + "sample": "rwalk", + "nlive": 200 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/elastic/1.json b/benchmarks/results/hpc/sweep/elastic/1.json new file mode 100644 index 0000000..bd97ebe --- /dev/null +++ b/benchmarks/results/hpc/sweep/elastic/1.json @@ -0,0 +1,50 @@ +{ + "problem": "elastic", + "names": [ + "Vv", + "Wv", + "Rv", + "av", + "log_c" + ], + "runs": [ + { + "wall_s": 282.490432714927, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 92991, + "evidence": 0 + }, + "min_ess": 939.2080104816725, + "logz": 495.6450878477409, + "logz_err": 0.5079034602974412, + "mean": [ + 47.65338779041746, + 3.5001739550506183, + 4.123117056867896, + 0.6922450126455817, + -3.0829597512959475 + ], + "sd": [ + 0.15126542764808004, + 0.03318040460182434, + 0.008294687390886556, + 0.0035113881372716327, + 0.096790824630981 + ], + "mcse": [ + 0.004935814000426511, + 0.0010826816683751298, + 0.00027065691605585306, + 0.00011457713106261711, + 0.003158299386412947 + ], + "sampler": "dynesty", + "setting": "dynesty rwalk 200", + "seed": 101, + "sample": "rwalk", + "nlive": 200 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/elastic/10.json b/benchmarks/results/hpc/sweep/elastic/10.json new file mode 100644 index 0000000..602cf92 --- /dev/null +++ b/benchmarks/results/hpc/sweep/elastic/10.json @@ -0,0 +1,50 @@ +{ + "problem": "elastic", + "names": [ + "Vv", + "Wv", + "Rv", + "av", + "log_c" + ], + "runs": [ + { + "wall_s": 1141.9505353140412, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 380393, + "evidence": 0 + }, + "min_ess": 2424.6396387775335, + "logz": 495.92048259561363, + "logz_err": 0.33548957350307557, + "mean": [ + 47.65322082105977, + 3.501765259905312, + 4.123429709857102, + 0.6922724814902125, + -3.0830815653587447 + ], + "sd": [ + 0.14818176607047281, + 0.03279243023584373, + 0.008104603303677406, + 0.0035057324868646065, + 0.09437903958335257 + ], + "mcse": [ + 0.003009339364530765, + 0.0006659628494400663, + 0.00016459178752170668, + 7.119593087599331e-05, + 0.0019166903360411807 + ], + "sampler": "dynesty", + "setting": "dynesty rslice 500", + "seed": 101, + "sample": "rslice", + "nlive": 500 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/elastic/11.json b/benchmarks/results/hpc/sweep/elastic/11.json new file mode 100644 index 0000000..dcb8d08 --- /dev/null +++ b/benchmarks/results/hpc/sweep/elastic/11.json @@ -0,0 +1,50 @@ +{ + "problem": "elastic", + "names": [ + "Vv", + "Wv", + "Rv", + "av", + "log_c" + ], + "runs": [ + { + "wall_s": 1136.4918976819608, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 378243, + "evidence": 0 + }, + "min_ess": 2342.977933268166, + "logz": 495.82236424669475, + "logz_err": 0.3443471528918057, + "mean": [ + 47.64817403392361, + 3.501543845410961, + 4.123736563617882, + 0.6921116851567884, + -3.0828903088073143 + ], + "sd": [ + 0.14862389251515934, + 0.032372685185353724, + 0.008101149290157957, + 0.003514646332009541, + 0.09206416811558217 + ], + "mcse": [ + 0.003070467693911788, + 0.0006687974749192283, + 0.00016736418861085402, + 7.261018289411401e-05, + 0.001901982576165713 + ], + "sampler": "dynesty", + "setting": "dynesty rslice 500", + "seed": 102, + "sample": "rslice", + "nlive": 500 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/elastic/12.json b/benchmarks/results/hpc/sweep/elastic/12.json new file mode 100644 index 0000000..4c8688a --- /dev/null +++ b/benchmarks/results/hpc/sweep/elastic/12.json @@ -0,0 +1,50 @@ +{ + "problem": "elastic", + "names": [ + "Vv", + "Wv", + "Rv", + "av", + "log_c" + ], + "runs": [ + { + "wall_s": 242.08345339191146, + "calls": { + "search": 0, + "warmup": 31232, + "sampling": 16640, + "evidence": 4096 + }, + "min_ess": 4105.015424143376, + "logz": 495.9558069708043, + "logz_err": 0.006435698285810845, + "mean": [ + 47.65365105253516, + 3.501376039575128, + 4.123498942699237, + 0.6921994565064251, + -3.084296406925438 + ], + "sd": [ + 0.15173488272040409, + 0.03282338177791061, + 0.008318626170964268, + 0.0036226960564476685, + 0.09376329812264159 + ], + "mcse": [ + 0.002368252675951383, + 0.0005123018539682017, + 0.0001298357262115322, + 5.6542434251257486e-05, + 0.0014634418777265976 + ], + "sampler": "pocomc", + "setting": "pocomc 512/256", + "seed": 100, + "n_effective": 512, + "n_active": 256 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/elastic/13.json b/benchmarks/results/hpc/sweep/elastic/13.json new file mode 100644 index 0000000..af79d43 --- /dev/null +++ b/benchmarks/results/hpc/sweep/elastic/13.json @@ -0,0 +1,50 @@ +{ + "problem": "elastic", + "names": [ + "Vv", + "Wv", + "Rv", + "av", + "log_c" + ], + "runs": [ + { + "wall_s": 238.92506827099714, + "calls": { + "search": 0, + "warmup": 32768, + "sampling": 16896, + "evidence": 4096 + }, + "min_ess": 4113.894998625182, + "logz": 495.94490894618366, + "logz_err": 0.008348406651532978, + "mean": [ + 47.65442100176697, + 3.50246491817577, + 4.123262239554605, + 0.6923044656123671, + -3.0814659689067994 + ], + "sd": [ + 0.15232378817860756, + 0.0328271306240558, + 0.008356741630333933, + 0.0036093264431911695, + 0.09323118280648361 + ], + "mcse": [ + 0.0023748770485862583, + 0.0005118071183904683, + 0.00013028978688197162, + 5.6272934341282335e-05, + 0.0014535654536115524 + ], + "sampler": "pocomc", + "setting": "pocomc 512/256", + "seed": 101, + "n_effective": 512, + "n_active": 256 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/elastic/14.json b/benchmarks/results/hpc/sweep/elastic/14.json new file mode 100644 index 0000000..50df9ab --- /dev/null +++ b/benchmarks/results/hpc/sweep/elastic/14.json @@ -0,0 +1,50 @@ +{ + "problem": "elastic", + "names": [ + "Vv", + "Wv", + "Rv", + "av", + "log_c" + ], + "runs": [ + { + "wall_s": 246.12204775004648, + "calls": { + "search": 0, + "warmup": 32512, + "sampling": 17920, + "evidence": 4096 + }, + "min_ess": 4092.8187600565775, + "logz": 495.95422889552077, + "logz_err": 0.0071286374940756365, + "mean": [ + 47.654790524362554, + 3.5024869088014654, + 4.123219212139516, + 0.6922693036129394, + -3.0840663554609398 + ], + "sd": [ + 0.1535797463315844, + 0.0334717308299908, + 0.00834716175752581, + 0.003589278257384712, + 0.09370017210205174 + ], + "mcse": [ + 0.002400615960601328, + 0.0005231990101477497, + 0.00013047508033757257, + 5.610426425053316e-05, + 0.0014646340681773683 + ], + "sampler": "pocomc", + "setting": "pocomc 512/256", + "seed": 102, + "n_effective": 512, + "n_active": 256 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/elastic/15.json b/benchmarks/results/hpc/sweep/elastic/15.json new file mode 100644 index 0000000..ab4ebf3 --- /dev/null +++ b/benchmarks/results/hpc/sweep/elastic/15.json @@ -0,0 +1,50 @@ +{ + "problem": "elastic", + "names": [ + "Vv", + "Wv", + "Rv", + "av", + "log_c" + ], + "runs": [ + { + "wall_s": 310.3885606629774, + "calls": { + "search": 0, + "warmup": 62976, + "sampling": 15872, + "evidence": 4096 + }, + "min_ess": 4492.624145484327, + "logz": 495.94733412488057, + "logz_err": 0.008675703169783142, + "mean": [ + 47.65211189898632, + 3.501982589796204, + 4.123420847079423, + 0.6922205838406534, + -3.082104670442744 + ], + "sd": [ + 0.1533338101239784, + 0.03222191479308301, + 0.008388731875437228, + 0.0035641850694762005, + 0.09484229401981524 + ], + "mcse": [ + 0.0022876410654111795, + 0.00048073008442975834, + 0.00012515444251634715, + 5.317533114886118e-05, + 0.0014149855557760082 + ], + "sampler": "pocomc", + "setting": "pocomc 1024/512", + "seed": 100, + "n_effective": 1024, + "n_active": 512 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/elastic/16.json b/benchmarks/results/hpc/sweep/elastic/16.json new file mode 100644 index 0000000..327d3eb --- /dev/null +++ b/benchmarks/results/hpc/sweep/elastic/16.json @@ -0,0 +1,50 @@ +{ + "problem": "elastic", + "names": [ + "Vv", + "Wv", + "Rv", + "av", + "log_c" + ], + "runs": [ + { + "wall_s": 276.7233874190133, + "calls": { + "search": 0, + "warmup": 54272, + "sampling": 14336, + "evidence": 4096 + }, + "min_ess": 4485.94209081558, + "logz": 495.9371713506923, + "logz_err": 0.011429031230759295, + "mean": [ + 47.655907530089856, + 3.502253430457345, + 4.123309879035739, + 0.6923381044274516, + -3.081386322167644 + ], + "sd": [ + 0.1533198095515109, + 0.032117795211468035, + 0.008335500301040147, + 0.003608239884380529, + 0.09194952591826622 + ], + "mcse": [ + 0.0022891351793153554, + 0.00047953343482282735, + 0.00012445284814871922, + 5.3872678807164905e-05, + 0.001372848656129824 + ], + "sampler": "pocomc", + "setting": "pocomc 1024/512", + "seed": 101, + "n_effective": 1024, + "n_active": 512 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/elastic/17.json b/benchmarks/results/hpc/sweep/elastic/17.json new file mode 100644 index 0000000..1dcd2d1 --- /dev/null +++ b/benchmarks/results/hpc/sweep/elastic/17.json @@ -0,0 +1,50 @@ +{ + "problem": "elastic", + "names": [ + "Vv", + "Wv", + "Rv", + "av", + "log_c" + ], + "runs": [ + { + "wall_s": 275.5099334400147, + "calls": { + "search": 0, + "warmup": 55808, + "sampling": 9728, + "evidence": 4096 + }, + "min_ess": 4538.406027328578, + "logz": 495.9612014969373, + "logz_err": 0.009020924094894134, + "mean": [ + 47.65150680572021, + 3.5019641580456398, + 4.123473002997184, + 0.6922393780745044, + -3.082862949962321 + ], + "sd": [ + 0.15257533177696, + 0.032707076345247006, + 0.008395373342067506, + 0.0035652179422271087, + 0.09390793112892473 + ], + "mcse": [ + 0.002264814565173496, + 0.00048550091307841993, + 0.00012462017027089977, + 5.292177594853609e-05, + 0.0013939609223134924 + ], + "sampler": "pocomc", + "setting": "pocomc 1024/512", + "seed": 102, + "n_effective": 1024, + "n_active": 512 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/elastic/18.json b/benchmarks/results/hpc/sweep/elastic/18.json new file mode 100644 index 0000000..42cec57 --- /dev/null +++ b/benchmarks/results/hpc/sweep/elastic/18.json @@ -0,0 +1,50 @@ +{ + "problem": "elastic", + "names": [ + "Vv", + "Wv", + "Rv", + "av", + "log_c" + ], + "runs": [ + { + "wall_s": 424.4322154899128, + "calls": { + "search": 0, + "warmup": 104448, + "sampling": 3072, + "evidence": 4096 + }, + "min_ess": 4492.936177085541, + "logz": 495.9634740044973, + "logz_err": 0.008624160746280689, + "mean": [ + 47.65487253188052, + 3.502244405161914, + 4.12329597851229, + 0.6922856643130126, + -3.0806595275145834 + ], + "sd": [ + 0.15057093632107618, + 0.03282005921229859, + 0.008205202051488374, + 0.003545654942404293, + 0.09125433215319735 + ], + "mcse": [ + 0.0022463427713865216, + 0.0004896370081063571, + 0.00012241204555454963, + 5.289703673434559e-05, + 0.0013614082132884114 + ], + "sampler": "pocomc", + "setting": "pocomc 2048/1024", + "seed": 100, + "n_effective": 2048, + "n_active": 1024 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/elastic/19.json b/benchmarks/results/hpc/sweep/elastic/19.json new file mode 100644 index 0000000..200a1b1 --- /dev/null +++ b/benchmarks/results/hpc/sweep/elastic/19.json @@ -0,0 +1,50 @@ +{ + "problem": "elastic", + "names": [ + "Vv", + "Wv", + "Rv", + "av", + "log_c" + ], + "runs": [ + { + "wall_s": 443.992216182407, + "calls": { + "search": 0, + "warmup": 102400, + "sampling": 0, + "evidence": 4096 + }, + "min_ess": 4200.963261653794, + "logz": 495.9531711010714, + "logz_err": 0.008926310105722616, + "mean": [ + 47.656748218625275, + 3.502056613160312, + 4.123233662904203, + 0.69226913217533, + -3.0826132909994843 + ], + "sd": [ + 0.15304129483139492, + 0.03246501946777132, + 0.008348324095990027, + 0.003573020001030836, + 0.09293240430697979 + ], + "mcse": [ + 0.0023612076938791444, + 0.0005008886904262684, + 0.00012880266798686647, + 5.512657434134165e-05, + 0.001433813718722625 + ], + "sampler": "pocomc", + "setting": "pocomc 2048/1024", + "seed": 101, + "n_effective": 2048, + "n_active": 1024 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/elastic/2.json b/benchmarks/results/hpc/sweep/elastic/2.json new file mode 100644 index 0000000..01d0b9f --- /dev/null +++ b/benchmarks/results/hpc/sweep/elastic/2.json @@ -0,0 +1,50 @@ +{ + "problem": "elastic", + "names": [ + "Vv", + "Wv", + "Rv", + "av", + "log_c" + ], + "runs": [ + { + "wall_s": 290.040280230809, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 92938, + "evidence": 0 + }, + "min_ess": 1008.9573445031515, + "logz": 496.04433878706004, + "logz_err": 0.48551785768797523, + "mean": [ + 47.656266285818546, + 3.5015112513886786, + 4.12304005041177, + 0.6922632141105077, + -3.0789686958726943 + ], + "sd": [ + 0.1494939613049042, + 0.03221265219088451, + 0.008164204226116016, + 0.003523537418119209, + 0.0952435771694986 + ], + "mcse": [ + 0.004706382786930345, + 0.0010141217107983577, + 0.000257026236400332, + 0.00011092833254929089, + 0.002998467150401848 + ], + "sampler": "dynesty", + "setting": "dynesty rwalk 200", + "seed": 102, + "sample": "rwalk", + "nlive": 200 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/elastic/20.json b/benchmarks/results/hpc/sweep/elastic/20.json new file mode 100644 index 0000000..d58908e --- /dev/null +++ b/benchmarks/results/hpc/sweep/elastic/20.json @@ -0,0 +1,50 @@ +{ + "problem": "elastic", + "names": [ + "Vv", + "Wv", + "Rv", + "av", + "log_c" + ], + "runs": [ + { + "wall_s": 392.74843109585345, + "calls": { + "search": 0, + "warmup": 95232, + "sampling": 3072, + "evidence": 4096 + }, + "min_ess": 4535.368392897874, + "logz": 495.94978701649956, + "logz_err": 0.012454674155863169, + "mean": [ + 47.656154727061946, + 3.5024250242207104, + 4.123275337193139, + 0.6923177545563206, + -3.0811489654470114 + ], + "sd": [ + 0.1513136165961228, + 0.03227327821439749, + 0.00836363366517318, + 0.0035608340816939005, + 0.09235264949671027 + ], + "mcse": [ + 0.002246837827751597, + 0.0004792220551518946, + 0.00012419059777366625, + 5.2874400156938566e-05, + 0.0013713334665454693 + ], + "sampler": "pocomc", + "setting": "pocomc 2048/1024", + "seed": 102, + "n_effective": 2048, + "n_active": 1024 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/elastic/3.json b/benchmarks/results/hpc/sweep/elastic/3.json new file mode 100644 index 0000000..7448b2e --- /dev/null +++ b/benchmarks/results/hpc/sweep/elastic/3.json @@ -0,0 +1,50 @@ +{ + "problem": "elastic", + "names": [ + "Vv", + "Wv", + "Rv", + "av", + "log_c" + ], + "runs": [ + { + "wall_s": 712.0838796827011, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 230048, + "evidence": 0 + }, + "min_ess": 2425.055239739554, + "logz": 496.09544091000726, + "logz_err": 0.33563162383279105, + "mean": [ + 47.65262182957615, + 3.5018188093258935, + 4.123397413742452, + 0.6922973676261066, + -3.081223419643918 + ], + "sd": [ + 0.15180059103335192, + 0.03243478417968313, + 0.00843000203413271, + 0.0035583361662877514, + 0.0910591499848336 + ], + "mcse": [ + 0.0030825678502856444, + 0.0006586431730116099, + 0.00017118545501941236, + 7.225803662580833e-05, + 0.001849110114175479 + ], + "sampler": "dynesty", + "setting": "dynesty rwalk 500", + "seed": 100, + "sample": "rwalk", + "nlive": 500 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/elastic/4.json b/benchmarks/results/hpc/sweep/elastic/4.json new file mode 100644 index 0000000..41f2130 --- /dev/null +++ b/benchmarks/results/hpc/sweep/elastic/4.json @@ -0,0 +1,50 @@ +{ + "problem": "elastic", + "names": [ + "Vv", + "Wv", + "Rv", + "av", + "log_c" + ], + "runs": [ + { + "wall_s": 717.2311589857563, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 232613, + "evidence": 0 + }, + "min_ess": 2372.9787198349304, + "logz": 495.90035616158684, + "logz_err": 0.3395291582411657, + "mean": [ + 47.65232881196425, + 3.5012608729029866, + 4.1233862167315225, + 0.6922760324723187, + -3.080159369865762 + ], + "sd": [ + 0.15309830139008831, + 0.032509842827727994, + 0.008428409824800934, + 0.0036548979090173937, + 0.09129227239447818 + ], + "mcse": [ + 0.0031428485287306766, + 0.0006673719484323765, + 0.00017302096219814572, + 7.502885670003786e-05, + 0.0018740755539044874 + ], + "sampler": "dynesty", + "setting": "dynesty rwalk 500", + "seed": 101, + "sample": "rwalk", + "nlive": 500 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/elastic/5.json b/benchmarks/results/hpc/sweep/elastic/5.json new file mode 100644 index 0000000..50920b0 --- /dev/null +++ b/benchmarks/results/hpc/sweep/elastic/5.json @@ -0,0 +1,50 @@ +{ + "problem": "elastic", + "names": [ + "Vv", + "Wv", + "Rv", + "av", + "log_c" + ], + "runs": [ + { + "wall_s": 700.5826396960765, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 230503, + "evidence": 0 + }, + "min_ess": 2442.245265314445, + "logz": 495.98116436561395, + "logz_err": 0.3348094062787077, + "mean": [ + 47.64889753898469, + 3.5013828545532424, + 4.123565588408864, + 0.6921091514366082, + -3.0803497163060576 + ], + "sd": [ + 0.15199393860539043, + 0.03329590649774805, + 0.008327263134466883, + 0.003665025839142302, + 0.09252609485726562 + ], + "mcse": [ + 0.0030756125956601234, + 0.0006737460082159083, + 0.0001685030049141331, + 7.416216552918586e-05, + 0.0018722748116230285 + ], + "sampler": "dynesty", + "setting": "dynesty rwalk 500", + "seed": 102, + "sample": "rwalk", + "nlive": 500 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/elastic/6.json b/benchmarks/results/hpc/sweep/elastic/6.json new file mode 100644 index 0000000..b2a634f --- /dev/null +++ b/benchmarks/results/hpc/sweep/elastic/6.json @@ -0,0 +1,50 @@ +{ + "problem": "elastic", + "names": [ + "Vv", + "Wv", + "Rv", + "av", + "log_c" + ], + "runs": [ + { + "wall_s": 568.8961415539961, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 187543, + "evidence": 0 + }, + "min_ess": 1239.8963540578925, + "logz": 496.19159255017144, + "logz_err": 0.4508020161296289, + "mean": [ + 47.64885776197835, + 3.5025853381901486, + 4.123668621993126, + 0.6920491987473151, + -3.079710978819507 + ], + "sd": [ + 0.1570800850888368, + 0.033362382540834366, + 0.008610806949174755, + 0.0037013923734366527, + 0.09463030484125243 + ], + "mcse": [ + 0.004460961102125019, + 0.0009474675972113648, + 0.0002445407056945008, + 0.00010511687329596785, + 0.0026874323931026455 + ], + "sampler": "dynesty", + "setting": "dynesty rslice 250", + "seed": 100, + "sample": "rslice", + "nlive": 250 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/elastic/7.json b/benchmarks/results/hpc/sweep/elastic/7.json new file mode 100644 index 0000000..d184577 --- /dev/null +++ b/benchmarks/results/hpc/sweep/elastic/7.json @@ -0,0 +1,50 @@ +{ + "problem": "elastic", + "names": [ + "Vv", + "Wv", + "Rv", + "av", + "log_c" + ], + "runs": [ + { + "wall_s": 527.2133273669751, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 185544, + "evidence": 0 + }, + "min_ess": 1211.3751329366166, + "logz": 496.22821897692967, + "logz_err": 0.4401789868016732, + "mean": [ + 47.66153808907705, + 3.503148408157161, + 4.122817486659775, + 0.6924108256121795, + -3.0864361489362317 + ], + "sd": [ + 0.14735055074438258, + 0.03236089455340982, + 0.008127821306184967, + 0.003574134790228415, + 0.09221340919366691 + ], + "mcse": [ + 0.00423362548000659, + 0.0009297821219195222, + 0.00023352577377534455, + 0.00010269081479809726, + 0.002649444042037048 + ], + "sampler": "dynesty", + "setting": "dynesty rslice 250", + "seed": 101, + "sample": "rslice", + "nlive": 250 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/elastic/8.json b/benchmarks/results/hpc/sweep/elastic/8.json new file mode 100644 index 0000000..60aa622 --- /dev/null +++ b/benchmarks/results/hpc/sweep/elastic/8.json @@ -0,0 +1,50 @@ +{ + "problem": "elastic", + "names": [ + "Vv", + "Wv", + "Rv", + "av", + "log_c" + ], + "runs": [ + { + "wall_s": 555.4467242809478, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 184112, + "evidence": 0 + }, + "min_ess": 1211.5539925687563, + "logz": 496.5239615543617, + "logz_err": 0.4471719500231492, + "mean": [ + 47.65496209774057, + 3.5021178222066527, + 4.123114451030975, + 0.6923306552244296, + -3.0847733173999092 + ], + "sd": [ + 0.15095098504429003, + 0.032358687257244376, + 0.008300602349723917, + 0.003563150545097143, + 0.09358672854890045 + ], + "mcse": [ + 0.004336751774245067, + 0.0009296500737237426, + 0.00023847245486278886, + 0.00010236766221709945, + 0.002688703296378972 + ], + "sampler": "dynesty", + "setting": "dynesty rslice 250", + "seed": 102, + "sample": "rslice", + "nlive": 250 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/elastic/9.json b/benchmarks/results/hpc/sweep/elastic/9.json new file mode 100644 index 0000000..882fe23 --- /dev/null +++ b/benchmarks/results/hpc/sweep/elastic/9.json @@ -0,0 +1,50 @@ +{ + "problem": "elastic", + "names": [ + "Vv", + "Wv", + "Rv", + "av", + "log_c" + ], + "runs": [ + { + "wall_s": 1148.4892376849893, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 382191, + "evidence": 0 + }, + "min_ess": 2472.7794624838543, + "logz": 495.7260625584274, + "logz_err": 0.33720117817194334, + "mean": [ + 47.65150775891206, + 3.5014689293746115, + 4.123455780825264, + 0.6922140231810403, + -3.081042488019189 + ], + "sd": [ + 0.15555405113486523, + 0.033216431296899517, + 0.0084074462070437, + 0.003616645089115512, + 0.09467748852140902 + ], + "mcse": [ + 0.003128157660034534, + 0.0006679751073170087, + 0.00016907188891589922, + 7.272993507147063e-05, + 0.0019039434125331877 + ], + "sampler": "dynesty", + "setting": "dynesty rslice 500", + "seed": 100, + "sample": "rslice", + "nlive": 500 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/gp/0.json b/benchmarks/results/hpc/sweep/gp/0.json new file mode 100644 index 0000000..0750e81 --- /dev/null +++ b/benchmarks/results/hpc/sweep/gp/0.json @@ -0,0 +1,46 @@ +{ + "problem": "gp", + "names": [ + "m", + "b", + "discrepancy_k1__constant_value", + "discrepancy_k2__length_scale" + ], + "runs": [ + { + "wall_s": 22.984976318199188, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 50322, + "evidence": 0 + }, + "min_ess": 869.6871736359544, + "logz": 81.65101468900163, + "logz_err": 0.3858456801676129, + "mean": [ + 1.9886938117275705, + 1.009814705392353, + -8.643749466203314, + -0.6769998522019952 + ], + "sd": [ + 0.04612876313489615, + 0.10544434617041898, + 2.3598480110893933, + 1.0953701361733053 + ], + "mcse": [ + 0.0015641927815475435, + 0.0035755410274592235, + 0.08002072836206053, + 0.03714320401599667 + ], + "sampler": "dynesty", + "setting": "dynesty rwalk 200", + "seed": 100, + "sample": "rwalk", + "nlive": 200 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/gp/1.json b/benchmarks/results/hpc/sweep/gp/1.json new file mode 100644 index 0000000..2e69816 --- /dev/null +++ b/benchmarks/results/hpc/sweep/gp/1.json @@ -0,0 +1,46 @@ +{ + "problem": "gp", + "names": [ + "m", + "b", + "discrepancy_k1__constant_value", + "discrepancy_k2__length_scale" + ], + "runs": [ + { + "wall_s": 26.32070751709398, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 57919, + "evidence": 0 + }, + "min_ess": 1081.1692072001274, + "logz": 79.69657303732797, + "logz_err": 0.41659859829266155, + "mean": [ + 1.9851591110976, + 1.0056374188556685, + -7.6546797190224085, + -0.39832499174989044 + ], + "sd": [ + 0.07908794612622544, + 0.19667020534804455, + 3.005331546396816, + 1.0816199849534374 + ], + "mcse": [ + 0.002405267943767293, + 0.005981246998914309, + 0.09139986537776391, + 0.032894846870778496 + ], + "sampler": "dynesty", + "setting": "dynesty rwalk 200", + "seed": 101, + "sample": "rwalk", + "nlive": 200 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/gp/10.json b/benchmarks/results/hpc/sweep/gp/10.json new file mode 100644 index 0000000..f06ce93 --- /dev/null +++ b/benchmarks/results/hpc/sweep/gp/10.json @@ -0,0 +1,46 @@ +{ + "problem": "gp", + "names": [ + "m", + "b", + "discrepancy_k1__constant_value", + "discrepancy_k2__length_scale" + ], + "runs": [ + { + "wall_s": 98.82883791299537, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 217213, + "evidence": 0 + }, + "min_ess": 2819.907825037753, + "logz": 80.07109949343977, + "logz_err": 0.27809334139239017, + "mean": [ + 1.985669825526598, + 1.0051828961397862, + -7.369608555895612, + -0.2334310719930581 + ], + "sd": [ + 0.08403858212869804, + 0.20564123159750175, + 2.9868522083657725, + 1.0479297488523227 + ], + "mcse": [ + 0.0015825639197183433, + 0.003872511711754791, + 0.05624660029665779, + 0.01973398133244878 + ], + "sampler": "dynesty", + "setting": "dynesty rslice 500", + "seed": 101, + "sample": "rslice", + "nlive": 500 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/gp/11.json b/benchmarks/results/hpc/sweep/gp/11.json new file mode 100644 index 0000000..65cb22f --- /dev/null +++ b/benchmarks/results/hpc/sweep/gp/11.json @@ -0,0 +1,46 @@ +{ + "problem": "gp", + "names": [ + "m", + "b", + "discrepancy_k1__constant_value", + "discrepancy_k2__length_scale" + ], + "runs": [ + { + "wall_s": 98.49168167309836, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 216658, + "evidence": 0 + }, + "min_ess": 2617.2959295166816, + "logz": 80.13040916950214, + "logz_err": 0.2777401809182048, + "mean": [ + 1.9862282336449362, + 1.0064511324771663, + -7.772152582655095, + -0.38908957311292347 + ], + "sd": [ + 0.0772239229637985, + 0.1929910136599818, + 2.928449038471651, + 1.0807443551334135 + ], + "mcse": [ + 0.001509473333265886, + 0.0037723386419550218, + 0.05724153295699974, + 0.021124992379839086 + ], + "sampler": "dynesty", + "setting": "dynesty rslice 500", + "seed": 102, + "sample": "rslice", + "nlive": 500 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/gp/12.json b/benchmarks/results/hpc/sweep/gp/12.json new file mode 100644 index 0000000..e5cb47a --- /dev/null +++ b/benchmarks/results/hpc/sweep/gp/12.json @@ -0,0 +1,46 @@ +{ + "problem": "gp", + "names": [ + "m", + "b", + "discrepancy_k1__constant_value", + "discrepancy_k2__length_scale" + ], + "runs": [ + { + "wall_s": 82.78955620899796, + "calls": { + "search": 0, + "warmup": 24832, + "sampling": 43520, + "evidence": 4096 + }, + "min_ess": 4270.276894314467, + "logz": 80.38696688825641, + "logz_err": 0.030362892399673096, + "mean": [ + 1.9848774091614338, + 0.9982636565848231, + -6.517337740835355, + -0.12111242360338463 + ], + "sd": [ + 0.11438715866230946, + 0.28554463208881603, + 3.058874358690021, + 0.9058341534308871 + ], + "mcse": [ + 0.0017504481623277243, + 0.004369643256705076, + 0.046809458881371946, + 0.01386183333679785 + ], + "sampler": "pocomc", + "setting": "pocomc 512/256", + "seed": 100, + "n_effective": 512, + "n_active": 256 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/gp/13.json b/benchmarks/results/hpc/sweep/gp/13.json new file mode 100644 index 0000000..d4e3132 --- /dev/null +++ b/benchmarks/results/hpc/sweep/gp/13.json @@ -0,0 +1,46 @@ +{ + "problem": "gp", + "names": [ + "m", + "b", + "discrepancy_k1__constant_value", + "discrepancy_k2__length_scale" + ], + "runs": [ + { + "wall_s": 79.16744253830984, + "calls": { + "search": 0, + "warmup": 20736, + "sampling": 18432, + "evidence": 4096 + }, + "min_ess": 4182.12125097962, + "logz": 81.42120745504137, + "logz_err": 0.805099066240288, + "mean": [ + 1.9848278547507545, + 1.0056727904105243, + -6.487621893889062, + -0.005858459126843666 + ], + "sd": [ + 0.08108714683038556, + 0.19272783672749366, + 2.420443466209787, + 0.6786795133810675 + ], + "mcse": [ + 0.0012538734581620467, + 0.002980204983991835, + 0.037428001081484905, + 0.010494613039066375 + ], + "sampler": "pocomc", + "setting": "pocomc 512/256", + "seed": 101, + "n_effective": 512, + "n_active": 256 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/gp/14.json b/benchmarks/results/hpc/sweep/gp/14.json new file mode 100644 index 0000000..ed82839 --- /dev/null +++ b/benchmarks/results/hpc/sweep/gp/14.json @@ -0,0 +1,46 @@ +{ + "problem": "gp", + "names": [ + "m", + "b", + "discrepancy_k1__constant_value", + "discrepancy_k2__length_scale" + ], + "runs": [ + { + "wall_s": 82.26889659801964, + "calls": { + "search": 0, + "warmup": 28672, + "sampling": 30208, + "evidence": 4096 + }, + "min_ess": 4123.157124222895, + "logz": 80.56521429928226, + "logz_err": 0.1817185729129094, + "mean": [ + 1.9835248476824767, + 1.007642428417107, + -7.222377156871866, + -0.021005266538375894 + ], + "sd": [ + 0.08438778635583488, + 0.20677707948387372, + 3.011543976006008, + 0.7506931073463755 + ], + "mcse": [ + 0.001314209651041197, + 0.003220234173769506, + 0.04690015378663168, + 0.011690887618318206 + ], + "sampler": "pocomc", + "setting": "pocomc 512/256", + "seed": 102, + "n_effective": 512, + "n_active": 256 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/gp/15.json b/benchmarks/results/hpc/sweep/gp/15.json new file mode 100644 index 0000000..505b6c7 --- /dev/null +++ b/benchmarks/results/hpc/sweep/gp/15.json @@ -0,0 +1,46 @@ +{ + "problem": "gp", + "names": [ + "m", + "b", + "discrepancy_k1__constant_value", + "discrepancy_k2__length_scale" + ], + "runs": [ + { + "wall_s": 65.43069717299659, + "calls": { + "search": 0, + "warmup": 44032, + "sampling": 37888, + "evidence": 4096 + }, + "min_ess": 4543.984700908694, + "logz": 80.26818813549805, + "logz_err": 0.10722720887979408, + "mean": [ + 1.9834333844221137, + 1.0034470622501803, + -6.1491412175619375, + 0.09445499095097333 + ], + "sd": [ + 0.10325678213823816, + 0.2520666030865473, + 2.813330452178692, + 0.6914388023395533 + ], + "mcse": [ + 0.0015317932677545523, + 0.0037393565598123155, + 0.04173518249723099, + 0.010257353372391953 + ], + "sampler": "pocomc", + "setting": "pocomc 1024/512", + "seed": 100, + "n_effective": 1024, + "n_active": 512 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/gp/16.json b/benchmarks/results/hpc/sweep/gp/16.json new file mode 100644 index 0000000..c2dad15 --- /dev/null +++ b/benchmarks/results/hpc/sweep/gp/16.json @@ -0,0 +1,46 @@ +{ + "problem": "gp", + "names": [ + "m", + "b", + "discrepancy_k1__constant_value", + "discrepancy_k2__length_scale" + ], + "runs": [ + { + "wall_s": 72.89770616299938, + "calls": { + "search": 0, + "warmup": 64512, + "sampling": 35840, + "evidence": 4096 + }, + "min_ess": 4458.970402556144, + "logz": 80.33785784519652, + "logz_err": 0.04885379938257019, + "mean": [ + 1.9844295466195818, + 0.9998697665823755, + -6.375396109269953, + -0.16660387364037021 + ], + "sd": [ + 0.09341799677446712, + 0.23494083361010487, + 2.6450603406635653, + 0.9280891586511231 + ], + "mcse": [ + 0.0013989856358161423, + 0.0035183675826480697, + 0.03961122642555603, + 0.01389864315806526 + ], + "sampler": "pocomc", + "setting": "pocomc 1024/512", + "seed": 101, + "n_effective": 1024, + "n_active": 512 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/gp/17.json b/benchmarks/results/hpc/sweep/gp/17.json new file mode 100644 index 0000000..1b98445 --- /dev/null +++ b/benchmarks/results/hpc/sweep/gp/17.json @@ -0,0 +1,46 @@ +{ + "problem": "gp", + "names": [ + "m", + "b", + "discrepancy_k1__constant_value", + "discrepancy_k2__length_scale" + ], + "runs": [ + { + "wall_s": 74.68741836491972, + "calls": { + "search": 0, + "warmup": 69120, + "sampling": 27648, + "evidence": 4096 + }, + "min_ess": 4428.208615398064, + "logz": 80.52614264754641, + "logz_err": 0.06201162395347509, + "mean": [ + 1.9858578207122703, + 1.0062711518928742, + -7.658629081550243, + -0.3582146316965624 + ], + "sd": [ + 0.0795534303107213, + 0.1927638411896209, + 3.0137688644975005, + 0.9732469457472572 + ], + "mcse": [ + 0.0011954870463849526, + 0.0028967534681221783, + 0.04528933100977153, + 0.014625442448303338 + ], + "sampler": "pocomc", + "setting": "pocomc 1024/512", + "seed": 102, + "n_effective": 1024, + "n_active": 512 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/gp/18.json b/benchmarks/results/hpc/sweep/gp/18.json new file mode 100644 index 0000000..27ab26f --- /dev/null +++ b/benchmarks/results/hpc/sweep/gp/18.json @@ -0,0 +1,46 @@ +{ + "problem": "gp", + "names": [ + "m", + "b", + "discrepancy_k1__constant_value", + "discrepancy_k2__length_scale" + ], + "runs": [ + { + "wall_s": 81.07028435892425, + "calls": { + "search": 0, + "warmup": 99328, + "sampling": 17408, + "evidence": 4096 + }, + "min_ess": 5076.51180603087, + "logz": 80.42659930253285, + "logz_err": 0.02545482579820508, + "mean": [ + 1.985024454041959, + 1.0081870385983536, + -7.284772291949094, + -0.2779758339342051 + ], + "sd": [ + 0.07297729050857235, + 0.1801097872959796, + 2.838559614920184, + 1.0338479464200976 + ], + "mcse": [ + 0.0010242477878275825, + 0.0025278692853406737, + 0.039839632109350424, + 0.014510219065292472 + ], + "sampler": "pocomc", + "setting": "pocomc 2048/1024", + "seed": 100, + "n_effective": 2048, + "n_active": 1024 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/gp/19.json b/benchmarks/results/hpc/sweep/gp/19.json new file mode 100644 index 0000000..c6ffefe --- /dev/null +++ b/benchmarks/results/hpc/sweep/gp/19.json @@ -0,0 +1,46 @@ +{ + "problem": "gp", + "names": [ + "m", + "b", + "discrepancy_k1__constant_value", + "discrepancy_k2__length_scale" + ], + "runs": [ + { + "wall_s": 84.72822909802198, + "calls": { + "search": 0, + "warmup": 105472, + "sampling": 10240, + "evidence": 4096 + }, + "min_ess": 5000.445755158273, + "logz": 80.27316810248178, + "logz_err": 0.04359529679086668, + "mean": [ + 1.9861676289978625, + 1.0062619025330601, + -7.064969177086303, + -0.29361047230507337 + ], + "sd": [ + 0.07050520968869152, + 0.1692513075108274, + 2.489681098342304, + 0.9566689247891524 + ], + "mcse": [ + 0.0009970497945786792, + 0.0023934682576074915, + 0.035207838380016364, + 0.01352873864431354 + ], + "sampler": "pocomc", + "setting": "pocomc 2048/1024", + "seed": 101, + "n_effective": 2048, + "n_active": 1024 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/gp/2.json b/benchmarks/results/hpc/sweep/gp/2.json new file mode 100644 index 0000000..07d2f49 --- /dev/null +++ b/benchmarks/results/hpc/sweep/gp/2.json @@ -0,0 +1,46 @@ +{ + "problem": "gp", + "names": [ + "m", + "b", + "discrepancy_k1__constant_value", + "discrepancy_k2__length_scale" + ], + "runs": [ + { + "wall_s": 23.934322617016733, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 53229, + "evidence": 0 + }, + "min_ess": 985.9802158086194, + "logz": 80.91640218808502, + "logz_err": 0.39554513871784686, + "mean": [ + 1.9875052320811508, + 1.0076166361908303, + -8.08203651757797, + -0.42046471783566786 + ], + "sd": [ + 0.0578066137188785, + 0.13930458417030958, + 2.6524623959141835, + 1.1158104892674439 + ], + "mcse": [ + 0.0018409560861091842, + 0.0044364062440745925, + 0.08447245871693833, + 0.03553500160294842 + ], + "sampler": "dynesty", + "setting": "dynesty rwalk 200", + "seed": 102, + "sample": "rwalk", + "nlive": 200 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/gp/20.json b/benchmarks/results/hpc/sweep/gp/20.json new file mode 100644 index 0000000..cf70e0b --- /dev/null +++ b/benchmarks/results/hpc/sweep/gp/20.json @@ -0,0 +1,46 @@ +{ + "problem": "gp", + "names": [ + "m", + "b", + "discrepancy_k1__constant_value", + "discrepancy_k2__length_scale" + ], + "runs": [ + { + "wall_s": 79.06404565600678, + "calls": { + "search": 0, + "warmup": 120832, + "sampling": 0, + "evidence": 4096 + }, + "min_ess": 4159.4024529531835, + "logz": 80.2675664519748, + "logz_err": 0.1504050708482348, + "mean": [ + 1.9864436262313607, + 1.003879605116358, + -7.1384631221237855, + 0.04494459014552588 + ], + "sd": [ + 0.07738595727888326, + 0.1884319165981073, + 2.8488873631906886, + 0.6467598793923378 + ], + "mcse": [ + 0.0011999045149095767, + 0.002921722692714315, + 0.0441732961607253, + 0.010028306512362606 + ], + "sampler": "pocomc", + "setting": "pocomc 2048/1024", + "seed": 102, + "n_effective": 2048, + "n_active": 1024 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/gp/3.json b/benchmarks/results/hpc/sweep/gp/3.json new file mode 100644 index 0000000..3eb673e --- /dev/null +++ b/benchmarks/results/hpc/sweep/gp/3.json @@ -0,0 +1,46 @@ +{ + "problem": "gp", + "names": [ + "m", + "b", + "discrepancy_k1__constant_value", + "discrepancy_k2__length_scale" + ], + "runs": [ + { + "wall_s": 62.154148363973945, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 140322, + "evidence": 0 + }, + "min_ess": 2617.511122238438, + "logz": 80.26485265025148, + "logz_err": 0.2756256912998115, + "mean": [ + 1.986483378703321, + 1.0080958677321048, + -7.806147656849368, + -0.3440868095503301 + ], + "sd": [ + 0.07304266836531359, + 0.18457187760714197, + 2.8796012261330692, + 1.1078197552899927 + ], + "mcse": [ + 0.0014276848875587052, + 0.0036076239576864513, + 0.0562844053311996, + 0.02165333712695499 + ], + "sampler": "dynesty", + "setting": "dynesty rwalk 500", + "seed": 100, + "sample": "rwalk", + "nlive": 500 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/gp/4.json b/benchmarks/results/hpc/sweep/gp/4.json new file mode 100644 index 0000000..25081bf --- /dev/null +++ b/benchmarks/results/hpc/sweep/gp/4.json @@ -0,0 +1,46 @@ +{ + "problem": "gp", + "names": [ + "m", + "b", + "discrepancy_k1__constant_value", + "discrepancy_k2__length_scale" + ], + "runs": [ + { + "wall_s": 64.49020975490566, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 145110, + "evidence": 0 + }, + "min_ess": 2893.5511003348133, + "logz": 79.87947634647942, + "logz_err": 0.2807153555032956, + "mean": [ + 1.986135167505337, + 1.000945166579118, + -7.200811110274364, + -0.28077409797507036 + ], + "sd": [ + 0.09263225208375066, + 0.23098658324056612, + 3.1378878824773326, + 1.0660067633694288 + ], + "mcse": [ + 0.001722053518910444, + 0.004294090336170216, + 0.05833401162568109, + 0.019817295345285854 + ], + "sampler": "dynesty", + "setting": "dynesty rwalk 500", + "seed": 101, + "sample": "rwalk", + "nlive": 500 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/gp/5.json b/benchmarks/results/hpc/sweep/gp/5.json new file mode 100644 index 0000000..418b85e --- /dev/null +++ b/benchmarks/results/hpc/sweep/gp/5.json @@ -0,0 +1,46 @@ +{ + "problem": "gp", + "names": [ + "m", + "b", + "discrepancy_k1__constant_value", + "discrepancy_k2__length_scale" + ], + "runs": [ + { + "wall_s": 61.4921385810012, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 140241, + "evidence": 0 + }, + "min_ess": 2637.018788160004, + "logz": 80.27307753190296, + "logz_err": 0.27443458481993516, + "mean": [ + 1.9866825651334385, + 1.0086531403988774, + -7.818408722132779, + -0.4519651873574019 + ], + "sd": [ + 0.07051368362760856, + 0.17101882872458427, + 2.8170993825912722, + 1.1410857503855873 + ], + "mcse": [ + 0.0013731462359000703, + 0.0033303303536287828, + 0.0548587056349308, + 0.022220901282877945 + ], + "sampler": "dynesty", + "setting": "dynesty rwalk 500", + "seed": 102, + "sample": "rwalk", + "nlive": 500 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/gp/6.json b/benchmarks/results/hpc/sweep/gp/6.json new file mode 100644 index 0000000..518e5ab --- /dev/null +++ b/benchmarks/results/hpc/sweep/gp/6.json @@ -0,0 +1,46 @@ +{ + "problem": "gp", + "names": [ + "m", + "b", + "discrepancy_k1__constant_value", + "discrepancy_k2__length_scale" + ], + "runs": [ + { + "wall_s": 50.41558026301209, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 110736, + "evidence": 0 + }, + "min_ess": 1413.8826023992613, + "logz": 80.0008893241213, + "logz_err": 0.3718627977934116, + "mean": [ + 1.9849139409681507, + 1.0039050210257365, + -7.401196453980242, + -0.3423101695579602 + ], + "sd": [ + 0.09380919270274933, + 0.23344349568945355, + 3.1064691538497238, + 1.1082291492386809 + ], + "mcse": [ + 0.002494817163913176, + 0.006208334418731987, + 0.08261527832084195, + 0.029472901571921607 + ], + "sampler": "dynesty", + "setting": "dynesty rslice 250", + "seed": 100, + "sample": "rslice", + "nlive": 250 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/gp/7.json b/benchmarks/results/hpc/sweep/gp/7.json new file mode 100644 index 0000000..9075372 --- /dev/null +++ b/benchmarks/results/hpc/sweep/gp/7.json @@ -0,0 +1,46 @@ +{ + "problem": "gp", + "names": [ + "m", + "b", + "discrepancy_k1__constant_value", + "discrepancy_k2__length_scale" + ], + "runs": [ + { + "wall_s": 50.25375888007693, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 108074, + "evidence": 0 + }, + "min_ess": 1306.7598646764993, + "logz": 79.91112755961167, + "logz_err": 0.37140784216601697, + "mean": [ + 1.9857505610485917, + 1.0080858942469668, + -7.827795470726175, + -0.4821083136667426 + ], + "sd": [ + 0.07624020509993198, + 0.17592585590299908, + 2.888463694495175, + 1.1072037500229308 + ], + "mcse": [ + 0.0021090465350573637, + 0.0048666686603595225, + 0.07990409179158248, + 0.030628776897013682 + ], + "sampler": "dynesty", + "setting": "dynesty rslice 250", + "seed": 101, + "sample": "rslice", + "nlive": 250 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/gp/8.json b/benchmarks/results/hpc/sweep/gp/8.json new file mode 100644 index 0000000..03a8152 --- /dev/null +++ b/benchmarks/results/hpc/sweep/gp/8.json @@ -0,0 +1,46 @@ +{ + "problem": "gp", + "names": [ + "m", + "b", + "discrepancy_k1__constant_value", + "discrepancy_k2__length_scale" + ], + "runs": [ + { + "wall_s": 46.00912691594567, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 100189, + "evidence": 0 + }, + "min_ess": 1175.3990980140331, + "logz": 81.15485911168184, + "logz_err": 0.35652932566189144, + "mean": [ + 1.987820040407194, + 1.0082602298824583, + -8.375636794603233, + -0.6418880138730712 + ], + "sd": [ + 0.05040943017939141, + 0.11867099071622399, + 2.43755590484482, + 1.1535867780727906 + ], + "mcse": [ + 0.0014703445350492987, + 0.003461400814243296, + 0.07109874066838737, + 0.033647871217911345 + ], + "sampler": "dynesty", + "setting": "dynesty rslice 250", + "seed": 102, + "sample": "rslice", + "nlive": 250 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/gp/9.json b/benchmarks/results/hpc/sweep/gp/9.json new file mode 100644 index 0000000..5ba6f37 --- /dev/null +++ b/benchmarks/results/hpc/sweep/gp/9.json @@ -0,0 +1,46 @@ +{ + "problem": "gp", + "names": [ + "m", + "b", + "discrepancy_k1__constant_value", + "discrepancy_k2__length_scale" + ], + "runs": [ + { + "wall_s": 100.00869192101527, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 220408, + "evidence": 0 + }, + "min_ess": 2722.0340301721485, + "logz": 79.94943907177611, + "logz_err": 0.27845558089058353, + "mean": [ + 1.9850871205501293, + 1.0062645880677104, + -7.6009231125663606, + -0.3432467505013782 + ], + "sd": [ + 0.08594673243550294, + 0.21127440066622447, + 3.044293883063151, + 1.088177259830067 + ], + "mcse": [ + 0.0016473375384078337, + 0.0040494878776603715, + 0.05834985751527752, + 0.02085704945100807 + ], + "sampler": "dynesty", + "setting": "dynesty rslice 500", + "seed": 100, + "sample": "rslice", + "nlive": 500 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/modes/0.json b/benchmarks/results/hpc/sweep/modes/0.json new file mode 100644 index 0000000..61180c7 --- /dev/null +++ b/benchmarks/results/hpc/sweep/modes/0.json @@ -0,0 +1,66 @@ +{ + "problem": "modes", + "names": [ + "m", + "b", + "log_eta0", + "log_eta1", + "log_eta2", + "log_eta3", + "log_eta4", + "log_eta5", + "log_s" + ], + "runs": [ + { + "wall_s": 29.43201130197849, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 86829, + "evidence": 0 + }, + "min_ess": 1563.7868176973654, + "logz": 102.45776858406965, + "logz_err": 0.40812562354812865, + "mean": [ + 1.9645424347292435, + 1.0058394944313525, + -4.526339368560601, + -4.246011851491037, + -4.4541786630981415, + -4.600487469941477, + -4.497313525508788, + -4.6637746923673955, + -2.1700012358478595 + ], + "sd": [ + 0.14559924333109453, + 0.024728741689397617, + 1.1448986456259551, + 1.3381392481825392, + 1.1654334454180117, + 1.0924999516793121, + 1.147871072766975, + 1.0232033019220834, + 1.5003062115649002 + ], + "mcse": [ + 0.0036818860550528604, + 0.0006253357304759624, + 0.028951979840947856, + 0.03383861155375945, + 0.02947125996403026, + 0.027626931604904408, + 0.029027146014822088, + 0.025874571066719292, + 0.03793945897169565 + ], + "sampler": "dynesty", + "setting": "dynesty rwalk 200", + "seed": 100, + "sample": "rwalk", + "nlive": 200 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/modes/1.json b/benchmarks/results/hpc/sweep/modes/1.json new file mode 100644 index 0000000..a114f33 --- /dev/null +++ b/benchmarks/results/hpc/sweep/modes/1.json @@ -0,0 +1,66 @@ +{ + "problem": "modes", + "names": [ + "m", + "b", + "log_eta0", + "log_eta1", + "log_eta2", + "log_eta3", + "log_eta4", + "log_eta5", + "log_s" + ], + "runs": [ + { + "wall_s": 29.71863283100538, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 87951, + "evidence": 0 + }, + "min_ess": 1469.357233382725, + "logz": 103.01891659061636, + "logz_err": 0.4296863376080223, + "mean": [ + 1.9835275455520556, + 1.0038727459731105, + -4.779310357150201, + -4.52285759861352, + -4.711373301512654, + -4.626665031138085, + -4.485681645774478, + -4.469870507628545, + -3.400191161259549 + ], + "sd": [ + 0.07791496922766308, + 0.02491196807305364, + 0.9109250576214468, + 1.1194060892356752, + 1.0957329311206891, + 1.0761587685427028, + 1.1818423907226845, + 1.1913392368183506, + 1.5845970144018744 + ], + "mcse": [ + 0.0020326247333462984, + 0.0006498967138607815, + 0.02376396757516616, + 0.029202764580327247, + 0.02858518560701933, + 0.028074540125349413, + 0.03083158599833152, + 0.031079337161608378, + 0.04133854015200456 + ], + "sampler": "dynesty", + "setting": "dynesty rwalk 200", + "seed": 101, + "sample": "rwalk", + "nlive": 200 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/modes/10.json b/benchmarks/results/hpc/sweep/modes/10.json new file mode 100644 index 0000000..193730e --- /dev/null +++ b/benchmarks/results/hpc/sweep/modes/10.json @@ -0,0 +1,66 @@ +{ + "problem": "modes", + "names": [ + "m", + "b", + "log_eta0", + "log_eta1", + "log_eta2", + "log_eta3", + "log_eta4", + "log_eta5", + "log_s" + ], + "runs": [ + { + "wall_s": 185.20441342692357, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 508726, + "evidence": 0 + }, + "min_ess": 4291.437516998859, + "logz": 102.74756623646088, + "logz_err": 0.27599165404015813, + "mean": [ + 1.9738785554103773, + 1.0020751697561556, + -4.592140674687335, + -4.62458996979158, + -4.649750090350991, + -4.592628903091976, + -4.628784897274323, + -4.609309534695094, + -2.813734937211096 + ], + "sd": [ + 0.13975646947326617, + 0.025634735482362832, + 1.091258988387172, + 1.1077929940122853, + 1.0768216840671854, + 1.1183925582051881, + 1.0859485232824762, + 1.0967742522315849, + 1.7389588584115223 + ], + "mcse": [ + 0.00213339132193042, + 0.0003913158541008798, + 0.016658137291090468, + 0.016910529929873554, + 0.016437750929983803, + 0.017072332945867092, + 0.016577072706298997, + 0.016742328141561815, + 0.026545316661987013 + ], + "sampler": "dynesty", + "setting": "dynesty rslice 500", + "seed": 101, + "sample": "rslice", + "nlive": 500 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/modes/11.json b/benchmarks/results/hpc/sweep/modes/11.json new file mode 100644 index 0000000..df200e9 --- /dev/null +++ b/benchmarks/results/hpc/sweep/modes/11.json @@ -0,0 +1,66 @@ +{ + "problem": "modes", + "names": [ + "m", + "b", + "log_eta0", + "log_eta1", + "log_eta2", + "log_eta3", + "log_eta4", + "log_eta5", + "log_s" + ], + "runs": [ + { + "wall_s": 178.85885525401682, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 522124, + "evidence": 0 + }, + "min_ess": 4236.799848526785, + "logz": 102.80133957787659, + "logz_err": 0.27357426513624417, + "mean": [ + 1.9730694732990612, + 1.003397194818426, + -4.744648552545356, + -4.739332641522288, + -4.627751365622674, + -4.700760637970112, + -4.695479748497482, + -4.65024857539509, + -2.8535750704780316 + ], + "sd": [ + 0.12605561151776848, + 0.026039316692319948, + 1.0080934879065022, + 1.013023849822358, + 1.069785109677819, + 1.044466505791791, + 1.0569344129114655, + 1.0524066177130222, + 1.7150922267827005 + ], + "mcse": [ + 0.0019366146356419114, + 0.0004000466238772188, + 0.015487518399764732, + 0.015563264421146035, + 0.01643529768686118, + 0.016046323501187655, + 0.01623787016153115, + 0.016168308843768964, + 0.02634926496227316 + ], + "sampler": "dynesty", + "setting": "dynesty rslice 500", + "seed": 102, + "sample": "rslice", + "nlive": 500 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/modes/12.json b/benchmarks/results/hpc/sweep/modes/12.json new file mode 100644 index 0000000..826f324 --- /dev/null +++ b/benchmarks/results/hpc/sweep/modes/12.json @@ -0,0 +1,66 @@ +{ + "problem": "modes", + "names": [ + "m", + "b", + "log_eta0", + "log_eta1", + "log_eta2", + "log_eta3", + "log_eta4", + "log_eta5", + "log_s" + ], + "runs": [ + { + "wall_s": 146.2750993950758, + "calls": { + "search": 0, + "warmup": 36096, + "sampling": 35584, + "evidence": 4096 + }, + "min_ess": 4118.531392141875, + "logz": 102.7610653634819, + "logz_err": 0.044537840190031076, + "mean": [ + 1.9580067258503397, + 1.0018975791038671, + -4.589864682546934, + -4.521650145020765, + -4.509486166537767, + -4.435932186499563, + -4.514702052580689, + -4.4152938448013215, + -2.108771485627809 + ], + "sd": [ + 0.15943631228272742, + 0.02540957555108519, + 0.9915298571802732, + 1.0601335868430588, + 1.085802896329623, + 1.060940143469906, + 1.0753118264536294, + 1.1023602039316351, + 1.4925577141006916 + ], + "mcse": [ + 0.0024843687078358037, + 0.00039593712043818136, + 0.015450217800417849, + 0.016519214923938975, + 0.0169191992708366, + 0.016531782851634664, + 0.01675572530848467, + 0.017177198570390816, + 0.023257334709142104 + ], + "sampler": "pocomc", + "setting": "pocomc 512/256", + "seed": 100, + "n_effective": 512, + "n_active": 256 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/modes/13.json b/benchmarks/results/hpc/sweep/modes/13.json new file mode 100644 index 0000000..738ec57 --- /dev/null +++ b/benchmarks/results/hpc/sweep/modes/13.json @@ -0,0 +1,66 @@ +{ + "problem": "modes", + "names": [ + "m", + "b", + "log_eta0", + "log_eta1", + "log_eta2", + "log_eta3", + "log_eta4", + "log_eta5", + "log_s" + ], + "runs": [ + { + "wall_s": 162.56426696199924, + "calls": { + "search": 0, + "warmup": 30720, + "sampling": 28928, + "evidence": 4096 + }, + "min_ess": 4069.254497922273, + "logz": 102.67031610741469, + "logz_err": 0.10374103378878223, + "mean": [ + 1.9744536451949601, + 1.004268771454221, + -4.423150973993142, + -4.612509365549422, + -4.413495440597669, + -4.602053077457784, + -4.49507874424305, + -4.415472127382857, + -2.040946003873158 + ], + "sd": [ + 0.1636746830313235, + 0.026057925057120967, + 1.044133515250475, + 1.0611417030257548, + 1.0687758706205785, + 1.0471737931818992, + 1.0919870618566998, + 1.040855531638324, + 1.4094327281161343 + ], + "mcse": [ + 0.002565807571971717, + 0.0004084909173683089, + 0.01636811283188133, + 0.016634737676793833, + 0.01675441290486042, + 0.016415773031937152, + 0.01711827767077981, + 0.016316726294775607, + 0.02209463980017637 + ], + "sampler": "pocomc", + "setting": "pocomc 512/256", + "seed": 101, + "n_effective": 512, + "n_active": 256 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/modes/14.json b/benchmarks/results/hpc/sweep/modes/14.json new file mode 100644 index 0000000..72bc583 --- /dev/null +++ b/benchmarks/results/hpc/sweep/modes/14.json @@ -0,0 +1,66 @@ +{ + "problem": "modes", + "names": [ + "m", + "b", + "log_eta0", + "log_eta1", + "log_eta2", + "log_eta3", + "log_eta4", + "log_eta5", + "log_s" + ], + "runs": [ + { + "wall_s": 178.51217581995297, + "calls": { + "search": 0, + "warmup": 26112, + "sampling": 56320, + "evidence": 4096 + }, + "min_ess": 4196.1476060874575, + "logz": 103.18900600473226, + "logz_err": 0.24375060886749747, + "mean": [ + 1.9715951443768562, + 1.002734909723908, + -4.476116955848928, + -4.561523681270372, + -4.522225681093748, + -4.595522442640101, + -4.439150254885991, + -4.448643105499786, + -2.190885067296905 + ], + "sd": [ + 0.15366164195611173, + 0.02584888088249777, + 1.0252743510997002, + 1.0775090144030965, + 1.1225627606862731, + 1.0488114837502303, + 1.064566993787294, + 1.0612684641030237, + 1.5085700388978731 + ], + "mcse": [ + 0.002372138767334928, + 0.0003990399403066956, + 0.015827587187259178, + 0.016633955440541696, + 0.017329468886913172, + 0.016190939707260064, + 0.016434164077911574, + 0.016383243301329627, + 0.023288424013663045 + ], + "sampler": "pocomc", + "setting": "pocomc 512/256", + "seed": 102, + "n_effective": 512, + "n_active": 256 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/modes/15.json b/benchmarks/results/hpc/sweep/modes/15.json new file mode 100644 index 0000000..7e5bb0b --- /dev/null +++ b/benchmarks/results/hpc/sweep/modes/15.json @@ -0,0 +1,66 @@ +{ + "problem": "modes", + "names": [ + "m", + "b", + "log_eta0", + "log_eta1", + "log_eta2", + "log_eta3", + "log_eta4", + "log_eta5", + "log_s" + ], + "runs": [ + { + "wall_s": 137.58785951393656, + "calls": { + "search": 0, + "warmup": 71680, + "sampling": 14336, + "evidence": 4096 + }, + "min_ess": 4279.187269670499, + "logz": 102.8032604725658, + "logz_err": 0.023472259460433277, + "mean": [ + 1.9675434889467673, + 1.003932298596809, + -4.599012840677852, + -4.631601984868476, + -4.640868245768982, + -4.5815325970114955, + -4.639818124118522, + -4.60398271298903, + -2.6870883320226273 + ], + "sd": [ + 0.13663027815110204, + 0.025573061507027862, + 1.023664953910807, + 1.057125209994795, + 1.0642496431014656, + 1.0775562060489416, + 1.055553297647299, + 1.05420640490398, + 1.6753915111930988 + ], + "mcse": [ + 0.0020886530572604817, + 0.00039093276997572487, + 0.015648661223039245, + 0.01616016472806213, + 0.01626907520669732, + 0.016472491270530097, + 0.016136135065129644, + 0.01611554525382132, + 0.025611538301135335 + ], + "sampler": "pocomc", + "setting": "pocomc 1024/512", + "seed": 100, + "n_effective": 1024, + "n_active": 512 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/modes/16.json b/benchmarks/results/hpc/sweep/modes/16.json new file mode 100644 index 0000000..82e5229 --- /dev/null +++ b/benchmarks/results/hpc/sweep/modes/16.json @@ -0,0 +1,66 @@ +{ + "problem": "modes", + "names": [ + "m", + "b", + "log_eta0", + "log_eta1", + "log_eta2", + "log_eta3", + "log_eta4", + "log_eta5", + "log_s" + ], + "runs": [ + { + "wall_s": 126.86267836298794, + "calls": { + "search": 0, + "warmup": 50688, + "sampling": 23552, + "evidence": 4096 + }, + "min_ess": 4251.55277248858, + "logz": 102.85673437469788, + "logz_err": 0.060428054488579075, + "mean": [ + 1.969509829788818, + 1.0023479406686933, + -4.575054308832494, + -4.591831728330616, + -4.528380180388163, + -4.591922484418022, + -4.557542706778456, + -4.587050179071464, + -2.3731790224661853 + ], + "sd": [ + 0.13828578784920773, + 0.0254204498271989, + 1.032666196119018, + 1.0528448586016668, + 1.1022120596363414, + 1.0669215627393067, + 1.042131146615402, + 1.0430378195684813, + 1.5050101433287908 + ], + "mcse": [ + 0.0021208197606118156, + 0.0003898606874623488, + 0.01583748343852385, + 0.016146953462895287, + 0.01690407346133361, + 0.016362840813025203, + 0.01598264263642951, + 0.01599654782470092, + 0.02308158561726853 + ], + "sampler": "pocomc", + "setting": "pocomc 1024/512", + "seed": 101, + "n_effective": 1024, + "n_active": 512 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/modes/17.json b/benchmarks/results/hpc/sweep/modes/17.json new file mode 100644 index 0000000..2ecaaf0 --- /dev/null +++ b/benchmarks/results/hpc/sweep/modes/17.json @@ -0,0 +1,66 @@ +{ + "problem": "modes", + "names": [ + "m", + "b", + "log_eta0", + "log_eta1", + "log_eta2", + "log_eta3", + "log_eta4", + "log_eta5", + "log_s" + ], + "runs": [ + { + "wall_s": 132.2072902600048, + "calls": { + "search": 0, + "warmup": 66560, + "sampling": 24576, + "evidence": 4096 + }, + "min_ess": 4284.869514950464, + "logz": 102.70235906057306, + "logz_err": 0.04022333086319149, + "mean": [ + 1.965921686343233, + 1.0019178890082192, + -4.618194683478484, + -4.562206809125744, + -4.609570451854811, + -4.68839558948692, + -4.572834500589567, + -4.5581062930525, + -2.2336315155728697 + ], + "sd": [ + 0.15593076147298168, + 0.025356895493366647, + 1.045651792327711, + 1.0629689091681416, + 1.0701149966507375, + 1.028131533372372, + 1.088371300410333, + 1.0983726397110092, + 1.504593301538549 + ], + "mcse": [ + 0.0023821165102552947, + 0.00038737115648622596, + 0.015974169400266004, + 0.016238718803770053, + 0.01634788785300201, + 0.01570651664382966, + 0.01662678498780183, + 0.01677957302813301, + 0.02298530777992465 + ], + "sampler": "pocomc", + "setting": "pocomc 1024/512", + "seed": 102, + "n_effective": 1024, + "n_active": 512 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/modes/18.json b/benchmarks/results/hpc/sweep/modes/18.json new file mode 100644 index 0000000..9a2a460 --- /dev/null +++ b/benchmarks/results/hpc/sweep/modes/18.json @@ -0,0 +1,66 @@ +{ + "problem": "modes", + "names": [ + "m", + "b", + "log_eta0", + "log_eta1", + "log_eta2", + "log_eta3", + "log_eta4", + "log_eta5", + "log_s" + ], + "runs": [ + { + "wall_s": 172.11443201696966, + "calls": { + "search": 0, + "warmup": 120832, + "sampling": 16384, + "evidence": 4096 + }, + "min_ess": 5081.3339227779725, + "logz": 102.85423224354182, + "logz_err": 0.026371705379028092, + "mean": [ + 1.9782872420292381, + 1.002939231007228, + -4.639122710872615, + -4.61131440112952, + -4.622693724771879, + -4.6169606680618385, + -4.618817584219522, + -4.618994752223562, + -2.8005090012351 + ], + "sd": [ + 0.12939311865286515, + 0.026002869412998952, + 1.054712499330981, + 1.0811005969788048, + 1.068939236936365, + 1.062227809838132, + 1.0699524256250632, + 1.0386080967657225, + 1.7167818381933961 + ], + "mcse": [ + 0.0018151909287875197, + 0.00036478116589453574, + 0.014796030741021303, + 0.015166216079909324, + 0.014995610481554601, + 0.014901459249133853, + 0.015009823995658153, + 0.014570110183928736, + 0.024083868229161132 + ], + "sampler": "pocomc", + "setting": "pocomc 2048/1024", + "seed": 100, + "n_effective": 2048, + "n_active": 1024 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/modes/19.json b/benchmarks/results/hpc/sweep/modes/19.json new file mode 100644 index 0000000..82fca0d --- /dev/null +++ b/benchmarks/results/hpc/sweep/modes/19.json @@ -0,0 +1,66 @@ +{ + "problem": "modes", + "names": [ + "m", + "b", + "log_eta0", + "log_eta1", + "log_eta2", + "log_eta3", + "log_eta4", + "log_eta5", + "log_s" + ], + "runs": [ + { + "wall_s": 147.9441037880024, + "calls": { + "search": 0, + "warmup": 90112, + "sampling": 4096, + "evidence": 4096 + }, + "min_ess": 4801.661413177842, + "logz": 102.81068383137543, + "logz_err": 0.03295716603070791, + "mean": [ + 1.9772086814139722, + 1.0024047110336798, + -4.654222023869904, + -4.662722445773021, + -4.505214621066947, + -4.576061439198491, + -4.617699513668963, + -4.5494911922922405, + -2.677161828924589 + ], + "sd": [ + 0.12578418303712477, + 0.025285389027426605, + 1.045669234122866, + 1.0535051612491544, + 1.1017717937114064, + 1.06124902243897, + 1.0288540847430905, + 1.0502157056669215, + 1.6331499022778877 + ], + "mcse": [ + 0.0018152241758606308, + 0.00036490000849374735, + 0.01509032398114214, + 0.015203406278267868, + 0.015899954572475894, + 0.01531515994798096, + 0.014847660198320834, + 0.015155935291422673, + 0.02356840990527622 + ], + "sampler": "pocomc", + "setting": "pocomc 2048/1024", + "seed": 101, + "n_effective": 2048, + "n_active": 1024 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/modes/2.json b/benchmarks/results/hpc/sweep/modes/2.json new file mode 100644 index 0000000..c752f6e --- /dev/null +++ b/benchmarks/results/hpc/sweep/modes/2.json @@ -0,0 +1,66 @@ +{ + "problem": "modes", + "names": [ + "m", + "b", + "log_eta0", + "log_eta1", + "log_eta2", + "log_eta3", + "log_eta4", + "log_eta5", + "log_s" + ], + "runs": [ + { + "wall_s": 30.791228907066397, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 89703, + "evidence": 0 + }, + "min_ess": 1557.3342148655242, + "logz": 102.48850115348017, + "logz_err": 0.396582713356139, + "mean": [ + 1.9653879562860703, + 0.9996660179931638, + -4.500326021933837, + -4.518504578608792, + -4.535366693515718, + -4.437140131442027, + -4.50080240761271, + -4.479464813533842, + -1.7520343964321212 + ], + "sd": [ + 0.1632264939262589, + 0.02355754916837671, + 1.105771492862936, + 1.1180802755609236, + 1.0857249789003984, + 1.1356817174419729, + 1.132113558410776, + 1.1293771454989536, + 1.2419089278040407 + ], + "mcse": [ + 0.004136182945267248, + 0.0005969517004179129, + 0.028020409433095073, + 0.028332315765503442, + 0.02751242787220111, + 0.028778338846495423, + 0.02868792118098148, + 0.028618580082334824, + 0.031470151708820324 + ], + "sampler": "dynesty", + "setting": "dynesty rwalk 200", + "seed": 102, + "sample": "rwalk", + "nlive": 200 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/modes/20.json b/benchmarks/results/hpc/sweep/modes/20.json new file mode 100644 index 0000000..4a7747c --- /dev/null +++ b/benchmarks/results/hpc/sweep/modes/20.json @@ -0,0 +1,66 @@ +{ + "problem": "modes", + "names": [ + "m", + "b", + "log_eta0", + "log_eta1", + "log_eta2", + "log_eta3", + "log_eta4", + "log_eta5", + "log_s" + ], + "runs": [ + { + "wall_s": 173.67949237395078, + "calls": { + "search": 0, + "warmup": 143360, + "sampling": 19456, + "evidence": 4096 + }, + "min_ess": 5105.118427391755, + "logz": 102.80198811763502, + "logz_err": 0.029649914399326367, + "mean": [ + 1.9729184953708936, + 1.0032824767926876, + -4.575414318045652, + -4.557771180776811, + -4.640038919209219, + -4.596798497496228, + -4.648318743376063, + -4.600460851976112, + -2.655299631348325 + ], + "sd": [ + 0.13598113796098682, + 0.025751414701815717, + 1.0614722454031573, + 1.1157402057348742, + 1.056024690658009, + 1.0478799328952484, + 1.066215521844294, + 1.0653443545535588, + 1.6111857566725354 + ], + "mcse": [ + 0.0019031620131272292, + 0.0003604111200984545, + 0.014856131414488811, + 0.015615653817241833, + 0.014779888639859497, + 0.014665896406725984, + 0.014922517265319993, + 0.014910324600074893, + 0.022549800466227603 + ], + "sampler": "pocomc", + "setting": "pocomc 2048/1024", + "seed": 102, + "n_effective": 2048, + "n_active": 1024 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/modes/3.json b/benchmarks/results/hpc/sweep/modes/3.json new file mode 100644 index 0000000..30c2dce --- /dev/null +++ b/benchmarks/results/hpc/sweep/modes/3.json @@ -0,0 +1,66 @@ +{ + "problem": "modes", + "names": [ + "m", + "b", + "log_eta0", + "log_eta1", + "log_eta2", + "log_eta3", + "log_eta4", + "log_eta5", + "log_s" + ], + "runs": [ + { + "wall_s": 82.10787473910023, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 231669, + "evidence": 0 + }, + "min_ess": 4001.345789959648, + "logz": 102.3675847980749, + "logz_err": 0.27559399931277095, + "mean": [ + 1.9722328018894593, + 1.0033328282507603, + -4.587946923445265, + -4.6239826226162535, + -4.4853624511550985, + -4.597067878171428, + -4.524732104053027, + -4.615641016377707, + -2.777246560507108 + ], + "sd": [ + 0.13355375279106743, + 0.025423968018369564, + 1.1305487725959331, + 1.1175179482398836, + 1.158019908545971, + 1.0998313032052915, + 1.1086516265557578, + 1.0557971865055682, + 1.7385062974359167 + ], + "mcse": [ + 0.00211131510095042, + 0.00040192062358021866, + 0.01787253930390793, + 0.017666538531441428, + 0.018306823050784838, + 0.017386935151032477, + 0.017526373253638535, + 0.01669081172804951, + 0.027483575131101463 + ], + "sampler": "dynesty", + "setting": "dynesty rwalk 500", + "seed": 100, + "sample": "rwalk", + "nlive": 500 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/modes/4.json b/benchmarks/results/hpc/sweep/modes/4.json new file mode 100644 index 0000000..208f5d3 --- /dev/null +++ b/benchmarks/results/hpc/sweep/modes/4.json @@ -0,0 +1,66 @@ +{ + "problem": "modes", + "names": [ + "m", + "b", + "log_eta0", + "log_eta1", + "log_eta2", + "log_eta3", + "log_eta4", + "log_eta5", + "log_s" + ], + "runs": [ + { + "wall_s": 78.4886231450364, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 226522, + "evidence": 0 + }, + "min_ess": 3877.4778197426285, + "logz": 102.45562504614705, + "logz_err": 0.29208544744417475, + "mean": [ + 1.9901233604654744, + 1.0059035523954574, + -4.691499088868208, + -4.381115038498604, + -4.686899830460219, + -4.631494544222449, + -4.583109140093579, + -4.553789171556547, + -3.1628230381488485 + ], + "sd": [ + 0.10236824139904745, + 0.026040849420288906, + 1.0299400821068891, + 1.237466336361591, + 1.0541140381016179, + 1.0672555042341454, + 1.0929681458263736, + 1.0930133897793122, + 1.7008335715328224 + ], + "mcse": [ + 0.0016439574832345686, + 0.00041819658801588904, + 0.016540068307538607, + 0.019872784919517363, + 0.01692828398179251, + 0.017139326110620596, + 0.01755225192610369, + 0.017552978510188635, + 0.027314116560411866 + ], + "sampler": "dynesty", + "setting": "dynesty rwalk 500", + "seed": 101, + "sample": "rwalk", + "nlive": 500 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/modes/5.json b/benchmarks/results/hpc/sweep/modes/5.json new file mode 100644 index 0000000..37c3426 --- /dev/null +++ b/benchmarks/results/hpc/sweep/modes/5.json @@ -0,0 +1,66 @@ +{ + "problem": "modes", + "names": [ + "m", + "b", + "log_eta0", + "log_eta1", + "log_eta2", + "log_eta3", + "log_eta4", + "log_eta5", + "log_s" + ], + "runs": [ + { + "wall_s": 82.61249051894993, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 234281, + "evidence": 0 + }, + "min_ess": 4270.4113310264565, + "logz": 102.81675190448404, + "logz_err": 0.27573837450052463, + "mean": [ + 1.9768326572084751, + 1.0040873395688907, + -4.619008989844818, + -4.666050174473226, + -4.709011244926993, + -4.687822100497837, + -4.526514048641702, + -4.607642091702034, + -2.7251280544105967 + ], + "sd": [ + 0.12841178492915387, + 0.02585350740580906, + 1.1185834078770993, + 1.0429581165900423, + 1.0368273977851485, + 1.0350784659615488, + 1.1670020783808468, + 1.1161694770849462, + 1.7467993351003395 + ], + "mcse": [ + 0.001965033815274452, + 0.000395625808985459, + 0.01711723127979355, + 0.0159599679121748, + 0.01586615199200671, + 0.015839388792851128, + 0.017858162689500124, + 0.01708029186931086, + 0.026730566543131946 + ], + "sampler": "dynesty", + "setting": "dynesty rwalk 500", + "seed": 102, + "sample": "rwalk", + "nlive": 500 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/modes/6.json b/benchmarks/results/hpc/sweep/modes/6.json new file mode 100644 index 0000000..7395e3e --- /dev/null +++ b/benchmarks/results/hpc/sweep/modes/6.json @@ -0,0 +1,66 @@ +{ + "problem": "modes", + "names": [ + "m", + "b", + "log_eta0", + "log_eta1", + "log_eta2", + "log_eta3", + "log_eta4", + "log_eta5", + "log_s" + ], + "runs": [ + { + "wall_s": 91.58628450299148, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 257432, + "evidence": 0 + }, + "min_ess": 2031.057420729087, + "logz": 102.32979575753612, + "logz_err": 0.3861435520358524, + "mean": [ + 1.9729975451378505, + 1.0017072710968185, + -4.547808486864792, + -4.734242391775856, + -4.626785473782198, + -4.604707213272206, + -4.573981032882256, + -4.4821205015248955, + -2.451385495354942 + ], + "sd": [ + 0.1458230423882545, + 0.025529765034323, + 1.1121874606035915, + 0.9822344249128173, + 1.0070171571711197, + 1.031422491753062, + 1.0711314282900333, + 1.1521473297383997, + 1.6512372203555257 + ], + "mcse": [ + 0.0032356761971220286, + 0.0005664814811622034, + 0.024678393990924547, + 0.021794858320280382, + 0.02234476384655746, + 0.02288629527325296, + 0.02376739923776643, + 0.025565065913838867, + 0.03663940130587116 + ], + "sampler": "dynesty", + "setting": "dynesty rslice 250", + "seed": 100, + "sample": "rslice", + "nlive": 250 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/modes/7.json b/benchmarks/results/hpc/sweep/modes/7.json new file mode 100644 index 0000000..34ef696 --- /dev/null +++ b/benchmarks/results/hpc/sweep/modes/7.json @@ -0,0 +1,66 @@ +{ + "problem": "modes", + "names": [ + "m", + "b", + "log_eta0", + "log_eta1", + "log_eta2", + "log_eta3", + "log_eta4", + "log_eta5", + "log_s" + ], + "runs": [ + { + "wall_s": 81.73667582706548, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 240525, + "evidence": 0 + }, + "min_ess": 1977.835025879452, + "logz": 102.8784846041329, + "logz_err": 0.373769694289238, + "mean": [ + 1.9593517398591394, + 1.0008317247891034, + -4.624734886350306, + -4.586507006581476, + -4.601180020355411, + -4.661637986477078, + -4.516653928436162, + -4.6081220657307576, + -2.4378448083796993 + ], + "sd": [ + 0.17051537033454323, + 0.026091484036924534, + 1.1145710199820973, + 1.1190304770486674, + 1.1258685214690662, + 1.0735104219597578, + 1.2386483425571768, + 1.142022310431794, + 1.6430056277307044 + ], + "mcse": [ + 0.0038341447152570474, + 0.0005866833320486997, + 0.0250618262603468, + 0.025162099940726226, + 0.025315857644948002, + 0.024138553041024857, + 0.02785178243673796, + 0.025679085689794073, + 0.036944008814817686 + ], + "sampler": "dynesty", + "setting": "dynesty rslice 250", + "seed": 101, + "sample": "rslice", + "nlive": 250 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/modes/8.json b/benchmarks/results/hpc/sweep/modes/8.json new file mode 100644 index 0000000..2a56627 --- /dev/null +++ b/benchmarks/results/hpc/sweep/modes/8.json @@ -0,0 +1,66 @@ +{ + "problem": "modes", + "names": [ + "m", + "b", + "log_eta0", + "log_eta1", + "log_eta2", + "log_eta3", + "log_eta4", + "log_eta5", + "log_s" + ], + "runs": [ + { + "wall_s": 89.70834151597228, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 250099, + "evidence": 0 + }, + "min_ess": 1987.603654801205, + "logz": 103.00463997669563, + "logz_err": 0.39157194605562107, + "mean": [ + 1.987478516114519, + 1.004082456106899, + -4.627564535707644, + -4.664213998093018, + -4.7256261045178585, + -4.669647293244919, + -4.622239057549823, + -4.521443647125972, + -2.9596880529940464 + ], + "sd": [ + 0.13510770318760673, + 0.025524836452747623, + 1.0478193525454655, + 1.0411264223581356, + 1.0098166441106093, + 1.0168878253548586, + 1.0875770867779935, + 1.162194318390569, + 1.751075591424115 + ], + "mcse": [ + 0.003030506485521554, + 0.0005725297713374507, + 0.023502903747351298, + 0.023352779306913714, + 0.022650491548327396, + 0.022809100273924923, + 0.02439468170374224, + 0.026068368688262872, + 0.03927715305085612 + ], + "sampler": "dynesty", + "setting": "dynesty rslice 250", + "seed": 102, + "sample": "rslice", + "nlive": 250 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/modes/9.json b/benchmarks/results/hpc/sweep/modes/9.json new file mode 100644 index 0000000..78dc110 --- /dev/null +++ b/benchmarks/results/hpc/sweep/modes/9.json @@ -0,0 +1,66 @@ +{ + "problem": "modes", + "names": [ + "m", + "b", + "log_eta0", + "log_eta1", + "log_eta2", + "log_eta3", + "log_eta4", + "log_eta5", + "log_s" + ], + "runs": [ + { + "wall_s": 182.0591302079847, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 519385, + "evidence": 0 + }, + "min_ess": 4213.164701116909, + "logz": 102.75128305991362, + "logz_err": 0.2830834688142277, + "mean": [ + 1.983483363108581, + 1.00288185197747, + -4.7050603874830355, + -4.608544909090749, + -4.620131722082805, + -4.688397049534176, + -4.5079183350213965, + -4.547609527003879, + -2.7546487209063772 + ], + "sd": [ + 0.12559093261253743, + 0.025733896986881527, + 1.0472866851500515, + 1.1089378545847417, + 1.0616239614179488, + 1.0337891682602507, + 1.1671335172734814, + 1.1062838263431813, + 1.6935244746994882 + ], + "mcse": [ + 0.0019348801401173907, + 0.00039646179204161125, + 0.016134717419113435, + 0.017084528212558295, + 0.016355600491936174, + 0.01592677185467093, + 0.01798110274732031, + 0.017043639699119602, + 0.026090791785167974 + ], + "sampler": "dynesty", + "setting": "dynesty rslice 500", + "seed": 100, + "sample": "rslice", + "nlive": 500 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/n40ca_gp/0.json b/benchmarks/results/hpc/sweep/n40ca_gp/0.json new file mode 100644 index 0000000..aaca26c --- /dev/null +++ b/benchmarks/results/hpc/sweep/n40ca_gp/0.json @@ -0,0 +1,56 @@ +{ + "problem": "n40ca_gp", + "names": [ + "Vv", + "Wv", + "Rv", + "av", + "log_ell_xs", + "log_A_xs", + "amp_slope_xs" + ], + "runs": [ + { + "wall_s": 144.62501071300358, + "calls": { + "search": 0, + "warmup": 84992, + "sampling": 22528, + "evidence": 4096 + }, + "min_ess": 4332.052254001436, + "logz": -11.334152805309108, + "logz_err": 0.020615190979930823, + "mean": [ + 44.07242451129369, + 13.583469191124076, + 4.27591913780138, + 0.4908616277930356, + -1.2704082741826692, + -1.710931465968952, + 2.118485597419149 + ], + "sd": [ + 1.6357966781673174, + 1.1096866010671849, + 0.0741865725783155, + 0.02601403891181752, + 0.20323989653433908, + 0.49141466509402276, + 0.6730151572043326 + ], + "mcse": [ + 0.024853209382453813, + 0.01685984194326949, + 0.0011271415612123471, + 0.0003952400469984151, + 0.003087892138951709, + 0.007466228369453221, + 0.01022534575525863 + ], + "n_effective": 1024, + "n_active": 512, + "seed": 100 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/n40ca_gp/1.json b/benchmarks/results/hpc/sweep/n40ca_gp/1.json new file mode 100644 index 0000000..6c959c0 --- /dev/null +++ b/benchmarks/results/hpc/sweep/n40ca_gp/1.json @@ -0,0 +1,56 @@ +{ + "problem": "n40ca_gp", + "names": [ + "Vv", + "Wv", + "Rv", + "av", + "log_ell_xs", + "log_A_xs", + "amp_slope_xs" + ], + "runs": [ + { + "wall_s": 149.79632453306112, + "calls": { + "search": 0, + "warmup": 77824, + "sampling": 23040, + "evidence": 4096 + }, + "min_ess": 4335.952729357508, + "logz": -11.398904825051748, + "logz_err": 0.017611947817528912, + "mean": [ + 44.21226150401244, + 13.563336566872927, + 4.268126768085496, + 0.49252309593606325, + -1.2560328078549865, + -1.637601849283182, + 2.0469911610409826 + ], + "sd": [ + 1.7137990557106195, + 1.1851253531230042, + 0.08017584544299226, + 0.026140668963201406, + 0.19659512437094367, + 0.5032650740298302, + 0.6520260709973993 + ], + "mcse": [ + 0.026026611522126392, + 0.017997907670666575, + 0.0012175905779908155, + 0.00039698530219556223, + 0.0029855921043351573, + 0.007642835681804844, + 0.009901994749968609 + ], + "n_effective": 1024, + "n_active": 512, + "seed": 101 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/n40ca_gp/2.json b/benchmarks/results/hpc/sweep/n40ca_gp/2.json new file mode 100644 index 0000000..a89e49a --- /dev/null +++ b/benchmarks/results/hpc/sweep/n40ca_gp/2.json @@ -0,0 +1,56 @@ +{ + "problem": "n40ca_gp", + "names": [ + "Vv", + "Wv", + "Rv", + "av", + "log_ell_xs", + "log_A_xs", + "amp_slope_xs" + ], + "runs": [ + { + "wall_s": 128.79138583992608, + "calls": { + "search": 0, + "warmup": 66560, + "sampling": 13824, + "evidence": 4096 + }, + "min_ess": 4168.453692176353, + "logz": -11.324409412555383, + "logz_err": 0.01846495757676833, + "mean": [ + 43.87613991272912, + 13.634817283354176, + 4.28522719261365, + 0.48768678358110473, + -1.2622397834909884, + -1.759431820629838, + 2.190040322224494 + ], + "sd": [ + 1.492237526125855, + 1.039286385309068, + 0.06707506603581977, + 0.023279842414646628, + 0.19567623961784306, + 0.4627399226507841, + 0.6460563092970016 + ], + "mcse": [ + 0.023112688524719944, + 0.016097103906770847, + 0.0010388996938615878, + 0.00036057245392508104, + 0.0030307534147846083, + 0.007167199264816334, + 0.010006515708647551 + ], + "n_effective": 1024, + "n_active": 512, + "seed": 102 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/n40ca_gp/3.json b/benchmarks/results/hpc/sweep/n40ca_gp/3.json new file mode 100644 index 0000000..30fdcba --- /dev/null +++ b/benchmarks/results/hpc/sweep/n40ca_gp/3.json @@ -0,0 +1,56 @@ +{ + "problem": "n40ca_gp", + "names": [ + "Vv", + "Wv", + "Rv", + "av", + "log_ell_xs", + "log_A_xs", + "amp_slope_xs" + ], + "runs": [ + { + "wall_s": 206.17314592108596, + "calls": { + "search": 0, + "warmup": 174080, + "sampling": 9216, + "evidence": 4096 + }, + "min_ess": 5181.220041187816, + "logz": -11.347361814647424, + "logz_err": 0.010227041435954454, + "mean": [ + 43.684128713345686, + 13.723107625344054, + 4.294165169994603, + 0.48574506288216346, + -1.270152269965843, + -1.778247750586169, + 2.207053313620734 + ], + "sd": [ + 1.5753694821189324, + 1.0720079956027586, + 0.07095148584099692, + 0.024388074081700985, + 0.20593173078447816, + 0.48329807835145905, + 0.6627225470334341 + ], + "mcse": [ + 0.021886000748912827, + 0.014892993714112873, + 0.0009857016337296957, + 0.000338814109118532, + 0.002860930128030591, + 0.006714273841664795, + 0.00920694879856772 + ], + "n_effective": 2048, + "n_active": 1024, + "seed": 100 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/n40ca_gp/4.json b/benchmarks/results/hpc/sweep/n40ca_gp/4.json new file mode 100644 index 0000000..5a23697 --- /dev/null +++ b/benchmarks/results/hpc/sweep/n40ca_gp/4.json @@ -0,0 +1,56 @@ +{ + "problem": "n40ca_gp", + "names": [ + "Vv", + "Wv", + "Rv", + "av", + "log_ell_xs", + "log_A_xs", + "amp_slope_xs" + ], + "runs": [ + { + "wall_s": 189.51980330608785, + "calls": { + "search": 0, + "warmup": 154624, + "sampling": 0, + "evidence": 4096 + }, + "min_ess": 4098.462571848329, + "logz": -11.397021611328839, + "logz_err": 0.023419433045406716, + "mean": [ + 44.09627089988894, + 13.657928371175595, + 4.275116339257853, + 0.4914576572145512, + -1.280358979729719, + -1.7027815704796987, + 2.083496298359686 + ], + "sd": [ + 1.531350304380624, + 1.1004539753142195, + 0.06790282419867609, + 0.02371524499398422, + 0.20236621170281516, + 0.46737183114175335, + 0.6492780157271696 + ], + "mcse": [ + 0.023920159021177737, + 0.017189426880122018, + 0.0010606628334307588, + 0.000370439363129087, + 0.0031610219755711082, + 0.007300490613381579, + 0.010141920722332895 + ], + "n_effective": 2048, + "n_active": 1024, + "seed": 101 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/n40ca_gp/5.json b/benchmarks/results/hpc/sweep/n40ca_gp/5.json new file mode 100644 index 0000000..5f4fb25 --- /dev/null +++ b/benchmarks/results/hpc/sweep/n40ca_gp/5.json @@ -0,0 +1,56 @@ +{ + "problem": "n40ca_gp", + "names": [ + "Vv", + "Wv", + "Rv", + "av", + "log_ell_xs", + "log_A_xs", + "amp_slope_xs" + ], + "runs": [ + { + "wall_s": 199.04840506997425, + "calls": { + "search": 0, + "warmup": 176128, + "sampling": 0, + "evidence": 4096 + }, + "min_ess": 4094.345297579111, + "logz": -11.359706526848722, + "logz_err": 0.01571045863766961, + "mean": [ + 43.80914340496279, + 13.70492276919293, + 4.2878473931625525, + 0.4878704916872498, + -1.2795490636821587, + -1.7660092237564844, + 2.176793366002216 + ], + "sd": [ + 1.649760062025042, + 1.0771726504697405, + 0.06972420009465033, + 0.02508471557250889, + 0.20681973740323661, + 0.48121611657892105, + 0.6665927260534057 + ], + "mcse": [ + 0.025782709345748153, + 0.016834223352552538, + 0.0010896607493325705, + 0.00039202787454612414, + 0.0032322113373785054, + 0.0075205210453540795, + 0.01041761581179797 + ], + "n_effective": 2048, + "n_active": 1024, + "seed": 102 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/n40ca_gp/6.json b/benchmarks/results/hpc/sweep/n40ca_gp/6.json new file mode 100644 index 0000000..6949dba --- /dev/null +++ b/benchmarks/results/hpc/sweep/n40ca_gp/6.json @@ -0,0 +1,56 @@ +{ + "problem": "n40ca_gp", + "names": [ + "Vv", + "Wv", + "Rv", + "av", + "log_ell_xs", + "log_A_xs", + "amp_slope_xs" + ], + "runs": [ + { + "wall_s": 305.0943130510859, + "calls": { + "search": 0, + "warmup": 231424, + "sampling": 0, + "evidence": 4096 + }, + "min_ess": 7436.020244564779, + "logz": -11.359356555634282, + "logz_err": 0.014559620006617511, + "mean": [ + 43.76488178944507, + 13.676440288282677, + 4.289739939344295, + 0.48677371812606024, + -1.2708667992709894, + -1.7645719099821093, + 2.1881415623638505 + ], + "sd": [ + 1.6196365672573416, + 1.0674141261303545, + 0.06891813930889269, + 0.02573543726774675, + 0.20728480236867544, + 0.47595686583245006, + 0.6637111858068505 + ], + "mcse": [ + 0.018782235937286264, + 0.012378347318819883, + 0.0007992143293296701, + 0.00029844291273972413, + 0.0024037936306260366, + 0.005519469201151959, + 0.007696776139816314 + ], + "n_effective": 4096, + "n_active": 2048, + "seed": 100 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/n40ca_gp/7.json b/benchmarks/results/hpc/sweep/n40ca_gp/7.json new file mode 100644 index 0000000..522ff75 --- /dev/null +++ b/benchmarks/results/hpc/sweep/n40ca_gp/7.json @@ -0,0 +1,56 @@ +{ + "problem": "n40ca_gp", + "names": [ + "Vv", + "Wv", + "Rv", + "av", + "log_ell_xs", + "log_A_xs", + "amp_slope_xs" + ], + "runs": [ + { + "wall_s": 321.5998195960419, + "calls": { + "search": 0, + "warmup": 268288, + "sampling": 0, + "evidence": 4096 + }, + "min_ess": 7244.266595536664, + "logz": -11.350569564305953, + "logz_err": 0.009763644989937112, + "mean": [ + 43.63301314762665, + 13.70660323474642, + 4.2960141161956535, + 0.48474994831914114, + -1.276357169229324, + -1.806230095820826, + 2.2386251192947175 + ], + "sd": [ + 1.5936494293678745, + 1.0523112713488407, + 0.07050181123390262, + 0.02459668491126154, + 0.20643825136666138, + 0.47809207319892033, + 0.6653928604930763 + ], + "mcse": [ + 0.018723868371593507, + 0.012363658761823982, + 0.0008283293735599887, + 0.00028898770467900063, + 0.0024254535371587287, + 0.00561712813565877, + 0.007817734632021442 + ], + "n_effective": 4096, + "n_active": 2048, + "seed": 101 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/n40ca_gp/8.json b/benchmarks/results/hpc/sweep/n40ca_gp/8.json new file mode 100644 index 0000000..ec5ba71 --- /dev/null +++ b/benchmarks/results/hpc/sweep/n40ca_gp/8.json @@ -0,0 +1,56 @@ +{ + "problem": "n40ca_gp", + "names": [ + "Vv", + "Wv", + "Rv", + "av", + "log_ell_xs", + "log_A_xs", + "amp_slope_xs" + ], + "runs": [ + { + "wall_s": 337.5938152529998, + "calls": { + "search": 0, + "warmup": 253952, + "sampling": 0, + "evidence": 4096 + }, + "min_ess": 7248.995329158626, + "logz": -11.342750601935213, + "logz_err": 0.01140104711549229, + "mean": [ + 43.755073027919046, + 13.695946575771991, + 4.290441203780875, + 0.4865775545266369, + -1.274599878027347, + -1.7727917897941912, + 2.186078862668791 + ], + "sd": [ + 1.55116046980391, + 1.064813687391233, + 0.06903765249871367, + 0.024349169759182106, + 0.203660801195424, + 0.48182263971959755, + 0.6716192958022217 + ], + "mcse": [ + 0.01821871820741622, + 0.012506469118848198, + 0.0008108622937861424, + 0.00028598631222413664, + 0.002392040552287348, + 0.005659112045393004, + 0.007888315187938496 + ], + "n_effective": 4096, + "n_active": 2048, + "seed": 102 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/omp/0.json b/benchmarks/results/hpc/sweep/omp/0.json new file mode 100644 index 0000000..1c5c4b2 --- /dev/null +++ b/benchmarks/results/hpc/sweep/omp/0.json @@ -0,0 +1,66 @@ +{ + "problem": "omp", + "names": [ + "Vv", + "Wv", + "Rv", + "av", + "Wd", + "Rd", + "ad", + "log_sigma_A", + "log_sigma_B" + ], + "runs": [ + { + "wall_s": 263.87480871006846, + "calls": { + "search": 0, + "warmup": 58368, + "sampling": 18432, + "evidence": 4096 + }, + "min_ess": 4512.851477618101, + "logz": -8.86339171024635, + "logz_err": 0.027007687553196737, + "mean": [ + 42.05108749026544, + 3.7522967272486536, + 4.17134166846228, + 0.7097420091423998, + 6.752520250027441, + 4.232022418366619, + 0.4390428928064158, + -1.528808289934837, + -1.7062885944941968 + ], + "sd": [ + 2.3422696646009387, + 1.4783296108721302, + 0.14873656703550608, + 0.03392150773446276, + 1.308250379581879, + 0.17695541973772733, + 0.08696884721975551, + 0.12055829079587317, + 0.8156678355650312 + ], + "mcse": [ + 0.034866742423085816, + 0.022006235463704, + 0.0022140745150300953, + 0.0005049514539914144, + 0.019474456634589563, + 0.002634136937181209, + 0.0012946077220192945, + 0.0017946161091845713, + 0.012141932568762203 + ], + "mode_share": 0.8233203987760397, + "mode_share_label": "share away from the MAP island", + "n_effective": 1024, + "n_active": 512, + "seed": 100 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/omp/1.json b/benchmarks/results/hpc/sweep/omp/1.json new file mode 100644 index 0000000..916c226 --- /dev/null +++ b/benchmarks/results/hpc/sweep/omp/1.json @@ -0,0 +1,66 @@ +{ + "problem": "omp", + "names": [ + "Vv", + "Wv", + "Rv", + "av", + "Wd", + "Rd", + "ad", + "log_sigma_A", + "log_sigma_B" + ], + "runs": [ + { + "wall_s": 348.1126649630023, + "calls": { + "search": 0, + "warmup": 98304, + "sampling": 23552, + "evidence": 4096 + }, + "min_ess": 4208.950918969597, + "logz": -6.671232887748438, + "logz_err": 0.039477240756340425, + "mean": [ + 45.123227156969925, + 3.2763360204856493, + 4.0003892337761195, + 0.775604199843696, + 8.803657306227587, + 4.387075176415484, + 0.3398931229624953, + -1.605169397318233, + -1.7706435452572307 + ], + "sd": [ + 2.62260272977306, + 1.261987904161631, + 0.14144193860586404, + 0.04847113904041719, + 1.4011647787882244, + 0.13116266693175133, + 0.07323270905111395, + 0.12633753113884372, + 0.7985881878384136 + ], + "mcse": [ + 0.04042458575232878, + 0.019452179192461228, + 0.002180174569040864, + 0.0007471302055809077, + 0.021597440249049346, + 0.0020217307092277497, + 0.0011288030372668264, + 0.0019473564574919926, + 0.01230937355230477 + ], + "mode_share": 0.22741141956348374, + "mode_share_label": "share away from the MAP island", + "n_effective": 1024, + "n_active": 512, + "seed": 101 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/omp/2.json b/benchmarks/results/hpc/sweep/omp/2.json new file mode 100644 index 0000000..9c94c5c --- /dev/null +++ b/benchmarks/results/hpc/sweep/omp/2.json @@ -0,0 +1,66 @@ +{ + "problem": "omp", + "names": [ + "Vv", + "Wv", + "Rv", + "av", + "Wd", + "Rd", + "ad", + "log_sigma_A", + "log_sigma_B" + ], + "runs": [ + { + "wall_s": 230.89461113407742, + "calls": { + "search": 0, + "warmup": 59392, + "sampling": 12800, + "evidence": 4096 + }, + "min_ess": 4092.3152852602, + "logz": -8.814071353085664, + "logz_err": 0.04072728272355799, + "mean": [ + 41.779272497407824, + 3.8553100634224453, + 4.197072312490713, + 0.7114928693541048, + 6.926695103462257, + 4.206432747250137, + 0.42233412309358787, + -1.5382402141603864, + -1.7633457692453933 + ], + "sd": [ + 1.964613594413729, + 1.5540673916378178, + 0.10433841582331135, + 0.033556230623413244, + 1.2332136468361923, + 0.13737486640262256, + 0.0772802934677644, + 0.11765754650295118, + 0.8156270622029332 + ], + "mcse": [ + 0.030710904109744152, + 0.024293232409863093, + 0.0016310215364607346, + 0.00052455209710978, + 0.019277636153238624, + 0.002147448414882236, + 0.001208048080808299, + 0.0018392266238584092, + 0.012749908973373214 + ], + "mode_share": 0.8524985697418922, + "mode_share_label": "share away from the MAP island", + "n_effective": 1024, + "n_active": 512, + "seed": 102 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/omp/3.json b/benchmarks/results/hpc/sweep/omp/3.json new file mode 100644 index 0000000..871f788 --- /dev/null +++ b/benchmarks/results/hpc/sweep/omp/3.json @@ -0,0 +1,66 @@ +{ + "problem": "omp", + "names": [ + "Vv", + "Wv", + "Rv", + "av", + "Wd", + "Rd", + "ad", + "log_sigma_A", + "log_sigma_B" + ], + "runs": [ + { + "wall_s": 476.7943695569411, + "calls": { + "search": 0, + "warmup": 163840, + "sampling": 16384, + "evidence": 4096 + }, + "min_ess": 4549.36435442321, + "logz": -6.617389263759373, + "logz_err": 0.04692940849065874, + "mean": [ + 45.4103146761612, + 3.3391967018991346, + 3.9850407875073217, + 0.78371602437486, + 9.007296498957793, + 4.402795200779112, + 0.32546860590794635, + -1.6125038996586176, + -1.8132992575084443 + ], + "sd": [ + 2.499931628763858, + 1.249075384548825, + 0.13069248701993835, + 0.04602662157865416, + 1.2336277902033295, + 0.11496889907246997, + 0.06364249582312397, + 0.11897032258842154, + 0.8383635074215807 + ], + "mcse": [ + 0.037064041287204016, + 0.018518819111320965, + 0.0019376496857354377, + 0.0006823917033864187, + 0.018289792737950693, + 0.0017045314251547998, + 0.0009435650422069168, + 0.0017638566181706393, + 0.01242959579183507 + ], + "mode_share": 0.16884666003203835, + "mode_share_label": "share away from the MAP island", + "n_effective": 2048, + "n_active": 1024, + "seed": 100 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/omp/4.json b/benchmarks/results/hpc/sweep/omp/4.json new file mode 100644 index 0000000..beea4e8 --- /dev/null +++ b/benchmarks/results/hpc/sweep/omp/4.json @@ -0,0 +1,66 @@ +{ + "problem": "omp", + "names": [ + "Vv", + "Wv", + "Rv", + "av", + "Wd", + "Rd", + "ad", + "log_sigma_A", + "log_sigma_B" + ], + "runs": [ + { + "wall_s": 405.97872379701585, + "calls": { + "search": 0, + "warmup": 143360, + "sampling": 0, + "evidence": 4096 + }, + "min_ess": 4392.159539590856, + "logz": -6.6939520959513406, + "logz_err": 0.07501363082424031, + "mean": [ + 45.2905660985585, + 3.2954964751022637, + 3.990282811417834, + 0.7797358735463686, + 8.868049800542815, + 4.395737897550481, + 0.33522224468859635, + -1.6056648432703051, + -1.6615762927037627 + ], + "sd": [ + 2.6053059376094114, + 1.2798772349110987, + 0.14006259336707552, + 0.0480098152677036, + 1.3532354993439129, + 0.12532980871827645, + 0.07217373811481971, + 0.12071845735393888, + 0.7833248569834879 + ], + "mcse": [ + 0.03931150546549025, + 0.019312089297862448, + 0.0021134068460738295, + 0.0007244209165796857, + 0.020418993393676855, + 0.0018911036087140777, + 0.0010890307581185729, + 0.0018215228497922326, + 0.011819602048278657 + ], + "mode_share": 0.20493082490192527, + "mode_share_label": "share away from the MAP island", + "n_effective": 2048, + "n_active": 1024, + "seed": 101 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/omp/5.json b/benchmarks/results/hpc/sweep/omp/5.json new file mode 100644 index 0000000..50ed524 --- /dev/null +++ b/benchmarks/results/hpc/sweep/omp/5.json @@ -0,0 +1,66 @@ +{ + "problem": "omp", + "names": [ + "Vv", + "Wv", + "Rv", + "av", + "Wd", + "Rd", + "ad", + "log_sigma_A", + "log_sigma_B" + ], + "runs": [ + { + "wall_s": 448.97729953494854, + "calls": { + "search": 0, + "warmup": 155648, + "sampling": 11264, + "evidence": 4096 + }, + "min_ess": 4599.97272350572, + "logz": -6.684693775435266, + "logz_err": 0.01978567993538673, + "mean": [ + 45.49188171113266, + 3.2887171188295388, + 3.9757121772928463, + 0.7862788382712822, + 8.995464578553326, + 4.412448648575912, + 0.3244439086271585, + -1.626317572577889, + -1.864788321181459 + ], + "sd": [ + 2.4289286187049144, + 1.2547034266579047, + 0.1287251838758626, + 0.04533315530537782, + 1.1875053918062863, + 0.11176155306667206, + 0.06160219222673534, + 0.11836452396392895, + 0.8315489934455609 + ], + "mcse": [ + 0.03581270486921253, + 0.01849964761057812, + 0.0018979549188396473, + 0.0006684028913979822, + 0.01750886370223288, + 0.0016478390862863864, + 0.0009082774654320092, + 0.001745194869483319, + 0.012260557373824796 + ], + "mode_share": 0.14641190953835315, + "mode_share_label": "share away from the MAP island", + "n_effective": 2048, + "n_active": 1024, + "seed": 102 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/omp/6.json b/benchmarks/results/hpc/sweep/omp/6.json new file mode 100644 index 0000000..6f5900a --- /dev/null +++ b/benchmarks/results/hpc/sweep/omp/6.json @@ -0,0 +1,66 @@ +{ + "problem": "omp", + "names": [ + "Vv", + "Wv", + "Rv", + "av", + "Wd", + "Rd", + "ad", + "log_sigma_A", + "log_sigma_B" + ], + "runs": [ + { + "wall_s": 841.4690177430166, + "calls": { + "search": 0, + "warmup": 317440, + "sampling": 0, + "evidence": 4096 + }, + "min_ess": 7316.152205892808, + "logz": -6.66309700327866, + "logz_err": 0.03648714379591066, + "mean": [ + 45.415020084770724, + 3.3092064063533577, + 3.9815837347550396, + 0.7836091212261396, + 8.906496365933606, + 4.407169361733292, + 0.32934479049798404, + -1.6164334629638715, + -1.8900977100035607 + ], + "sd": [ + 2.55400359570628, + 1.2648927491617075, + 0.13560376794344578, + 0.046833112238850505, + 1.302973751583771, + 0.12130326028619139, + 0.06739233572041435, + 0.12001424110898187, + 0.8298230641766933 + ], + "mcse": [ + 0.02985933548635418, + 0.014788098581760894, + 0.0015853691071712659, + 0.0005475347069052204, + 0.015233310729812948, + 0.0014181791875951923, + 0.0007878964480973594, + 0.0014031090224140036, + 0.00970161722137836 + ], + "mode_share": 0.16387110537427135, + "mode_share_label": "share away from the MAP island", + "n_effective": 4096, + "n_active": 2048, + "seed": 100 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/omp/7.json b/benchmarks/results/hpc/sweep/omp/7.json new file mode 100644 index 0000000..e500984 --- /dev/null +++ b/benchmarks/results/hpc/sweep/omp/7.json @@ -0,0 +1,66 @@ +{ + "problem": "omp", + "names": [ + "Vv", + "Wv", + "Rv", + "av", + "Wd", + "Rd", + "ad", + "log_sigma_A", + "log_sigma_B" + ], + "runs": [ + { + "wall_s": 889.2742078829324, + "calls": { + "search": 0, + "warmup": 360448, + "sampling": 0, + "evidence": 4096 + }, + "min_ess": 6805.041721355122, + "logz": -6.642639607659658, + "logz_err": 0.0268872199841963, + "mean": [ + 45.69867165455911, + 3.324744944734124, + 3.9678173973317303, + 0.7881502937683748, + 9.032487295004163, + 4.4082531918156445, + 0.3254306009743239, + -1.6258841927822651, + -1.8171773370099056 + ], + "sd": [ + 2.5505644412691253, + 1.2679488189430386, + 0.13394673076797906, + 0.046551358469489566, + 1.1965254275920538, + 0.11094728055671099, + 0.06286579791996326, + 0.12118003841870806, + 0.8546770453860644 + ], + "mcse": [ + 0.030918677160323517, + 0.015370440971570311, + 0.001623740870171932, + 0.0005643089822017831, + 0.014504626039336051, + 0.0013449349068953124, + 0.0007620773185978826, + 0.0014689793465007754, + 0.01036064143883459 + ], + "mode_share": 0.15165694144522446, + "mode_share_label": "share away from the MAP island", + "n_effective": 4096, + "n_active": 2048, + "seed": 101 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep/omp/8.json b/benchmarks/results/hpc/sweep/omp/8.json new file mode 100644 index 0000000..6f7882a --- /dev/null +++ b/benchmarks/results/hpc/sweep/omp/8.json @@ -0,0 +1,66 @@ +{ + "problem": "omp", + "names": [ + "Vv", + "Wv", + "Rv", + "av", + "Wd", + "Rd", + "ad", + "log_sigma_A", + "log_sigma_B" + ], + "runs": [ + { + "wall_s": 824.2170109839644, + "calls": { + "search": 0, + "warmup": 327680, + "sampling": 0, + "evidence": 4096 + }, + "min_ess": 6888.773445352978, + "logz": -6.688901760708451, + "logz_err": 0.017633137038440362, + "mean": [ + 45.77825820360296, + 3.3846103855522496, + 3.9619471571943436, + 0.7907733086609615, + 9.01528723419832, + 4.413032663526841, + 0.32360524607951857, + -1.63069320879831, + -1.8477578464025821 + ], + "sd": [ + 2.5182164025056473, + 1.2498204024013653, + 0.13238026540469466, + 0.04648555097983795, + 1.1954407216137652, + 0.11175886759831885, + 0.06277096806197893, + 0.1213511102664614, + 0.8370990634389822 + ], + "mcse": [ + 0.03034045555549794, + 0.015058324746706568, + 0.0015949691833234546, + 0.0005600760888036684, + 0.014403137096266092, + 0.0013465145219154644, + 0.0007562891595674855, + 0.0014620856110644151, + 0.010085696727472743 + ], + "mode_share": 0.14014277469637912, + "mode_share_label": "share away from the MAP island", + "n_effective": 4096, + "n_active": 2048, + "seed": 102 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep_alpha_gp.json b/benchmarks/results/hpc/sweep_alpha_gp.json new file mode 100644 index 0000000..ce0554a --- /dev/null +++ b/benchmarks/results/hpc/sweep_alpha_gp.json @@ -0,0 +1,466 @@ +{ + "problem": "alpha_gp", + "names": [ + "V", + "W", + "r", + "a", + "log_sigma_A", + "log_sigma_B", + "log_ell", + "log_A_q", + "p" + ], + "runs": [ + { + "wall_s": 375.59827178902924, + "calls": { + "search": 0, + "warmup": 114688, + "sampling": 18944, + "evidence": 4096 + }, + "min_ess": 4500.585303487641, + "logz": -84.7494035351787, + "logz_err": 0.032658386800430046, + "mean": [ + 166.44392587578045, + 27.949968820098658, + 1.2877646823231133, + 0.6047728334560087, + -0.7154217387533758, + -0.9613850067458929, + -3.728765376709877, + 0.3683103196281828, + 8.11044797718979 + ], + "sd": [ + 8.985812016783223, + 1.9259891528295514, + 0.020271738562976486, + 0.015955206915692802, + 0.10531083954189711, + 0.7157262404814888, + 0.2799940917102756, + 0.22340922181985348, + 3.265500025734423 + ], + "mcse": [ + 0.13394386609897946, + 0.028709084133170977, + 0.0003021735854924846, + 0.00023783071521032287, + 0.001569779221290744, + 0.010668723042449915, + 0.004173634064289293, + 0.0033301714788629725, + 0.04867603477306723 + ], + "mode_share": 0.9594325020606757, + "mode_share_label": "share in the deeper family", + "n_effective": 1024, + "n_active": 512, + "seed": 100 + }, + { + "wall_s": 401.293140011956, + "calls": { + "search": 0, + "warmup": 132608, + "sampling": 24064, + "evidence": 4096 + }, + "min_ess": 4567.646732081971, + "logz": -84.55398520395693, + "logz_err": 0.025609067557337873, + "mean": [ + 157.52168463746497, + 27.285843507007314, + 1.2945148301803613, + 0.6081819348722768, + -0.7112462915599317, + -0.9040121958373252, + -3.7072869258970362, + 0.3532206660079889, + 7.646598419707208 + ], + "sd": [ + 19.62878682405043, + 2.3421927294306806, + 0.02478122156341419, + 0.016635088594391025, + 0.10690172060302704, + 0.73239062752245, + 0.2968998197418686, + 0.24203791268806704, + 3.277152314991682 + ], + "mcse": [ + 0.29043383176416976, + 0.03465583559679012, + 0.00036667091038151473, + 0.00024613811161705085, + 0.0015817521793490576, + 0.010836686862322177, + 0.0043930250540022186, + 0.0035812706635575545, + 0.048489797797979704 + ], + "mode_share": 0.7573023699592512, + "mode_share_label": "share in the deeper family", + "n_effective": 1024, + "n_active": 512, + "seed": 101 + }, + { + "wall_s": 430.938125903951, + "calls": { + "search": 0, + "warmup": 146432, + "sampling": 22016, + "evidence": 4096 + }, + "min_ess": 4543.118944726405, + "logz": -84.53861487858781, + "logz_err": 0.03455256967059559, + "mean": [ + 152.21468665244797, + 26.717372396931026, + 1.3026084318606552, + 0.6065581128871051, + -0.7049527200650276, + -0.959555400962045, + -3.7077422932806146, + 0.32145376147737137, + 7.484664703850772 + ], + "sd": [ + 21.1809871273061, + 2.3793050681157415, + 0.024707246704200093, + 0.017991682958127423, + 0.10837545183813306, + 0.7754649771232618, + 0.29215953035651, + 0.2463274204905509, + 3.2886431852440405 + ], + "mcse": [ + 0.314245554487178, + 0.03529986756189858, + 0.00036656187899776797, + 0.00026692837087113327, + 0.0016078808674486952, + 0.011504960569440628, + 0.004334539890127954, + 0.0036545651235327693, + 0.04879099803262714 + ], + "mode_share": 0.6607763442951172, + "mode_share_label": "share in the deeper family", + "n_effective": 1024, + "n_active": 512, + "seed": 102 + }, + { + "wall_s": 632.4390710460721, + "calls": { + "search": 0, + "warmup": 243712, + "sampling": 11264, + "evidence": 4096 + }, + "min_ess": 5096.733400318381, + "logz": -84.52930933146715, + "logz_err": 0.035551544497456164, + "mean": [ + 155.46834886317708, + 27.22281723706611, + 1.2959994633140528, + 0.6088027043443077, + -0.7077963724293433, + -0.9618767935041194, + -3.7317269231389525, + 0.3411574037662179, + 7.806847390953757 + ], + "sd": [ + 20.541039600567093, + 2.3853112248610273, + 0.025372869493032243, + 0.01679497154012058, + 0.10598353920087082, + 0.732569712535845, + 0.2945368902458477, + 0.23611040534406771, + 3.3534721278235375 + ], + "mcse": [ + 0.28772424643008326, + 0.03341174001024809, + 0.00035540507669582617, + 0.00023525199425945698, + 0.0014845418997060827, + 0.010261314548610267, + 0.004125662889501807, + 0.0033072663201548893, + 0.04697304808641122 + ], + "mode_share": 0.7159454133970534, + "mode_share_label": "share in the deeper family", + "n_effective": 2048, + "n_active": 1024, + "seed": 100 + }, + { + "wall_s": 586.4094659200637, + "calls": { + "search": 0, + "warmup": 227328, + "sampling": 5120, + "evidence": 4096 + }, + "min_ess": 5060.107380800517, + "logz": -84.12588965709446, + "logz_err": 0.2416267188982504, + "mean": [ + 158.9372242182714, + 27.318751116277227, + 1.2933099319705146, + 0.6078167043902418, + -0.7114462849594567, + -0.9818719288220419, + -3.715539867723702, + 0.3535119710261057, + 7.657371203828229 + ], + "sd": [ + 18.810275637694428, + 2.2689829697140222, + 0.02470707526693685, + 0.016414010080208253, + 0.10473528741047577, + 0.7181208030094027, + 0.2819046687851437, + 0.23523814000165588, + 3.223291242212792 + ], + "mcse": [ + 0.2644327813434941, + 0.03189711246443176, + 0.000347329340491257, + 0.00023074634429129612, + 0.001472357124808033, + 0.010095263085877628, + 0.00396298475771347, + 0.003306951840410806, + 0.04531267296000807 + ], + "mode_share": 0.7884868367500323, + "mode_share_label": "share in the deeper family", + "n_effective": 2048, + "n_active": 1024, + "seed": 101 + }, + { + "wall_s": 528.1705428800778, + "calls": { + "search": 0, + "warmup": 203776, + "sampling": 4096, + "evidence": 4096 + }, + "min_ess": 4940.169028873489, + "logz": -84.56501789663889, + "logz_err": 0.023888898575943562, + "mean": [ + 157.41542256130202, + 27.246609079844877, + 1.294240267713694, + 0.6086035148691455, + -0.7175741310616923, + -0.904936555615476, + -3.717225738317766, + 0.3468733686403497, + 7.7191601079989525 + ], + "sd": [ + 19.7372256809072, + 2.3748917637886113, + 0.02485957324890199, + 0.016544329250462637, + 0.10458868041611209, + 0.7486518491616891, + 0.2829135832530519, + 0.2271277253969014, + 3.2046617160621453 + ], + "mcse": [ + 0.28081170257290644, + 0.03378881157856829, + 0.0003536899867347101, + 0.00023538471616318918, + 0.0014880371685627948, + 0.01065145648108056, + 0.0040251576527871764, + 0.0032314634438168847, + 0.04559437720409446 + ], + "mode_share": 0.7525193458018515, + "mode_share_label": "share in the deeper family", + "n_effective": 2048, + "n_active": 1024, + "seed": 102 + }, + { + "wall_s": 928.0525154052302, + "calls": { + "search": 0, + "warmup": 370688, + "sampling": 0, + "evidence": 4096 + }, + "min_ess": 7591.175519425091, + "logz": -84.49650306094308, + "logz_err": 0.02278276331526999, + "mean": [ + 156.19714762734523, + 27.01614938479876, + 1.2958564124106242, + 0.6085762872624819, + -0.7205319510945096, + -0.9114492601215906, + -3.7083135793402584, + 0.37326350791553436, + 8.05033568370641 + ], + "sd": [ + 20.382916231315313, + 2.430891205390173, + 0.025551563454839336, + 0.016849339235211362, + 0.10523186839562108, + 0.7482306806173664, + 0.28341526171191206, + 0.23166219759473983, + 3.3498349369959057 + ], + "mcse": [ + 0.2339439417406383, + 0.027900437016854223, + 0.0002932668419191859, + 0.0001933874815397881, + 0.0012077937136091084, + 0.008587781687783135, + 0.003252885049513876, + 0.0026588917426029557, + 0.03844756954538856 + ], + "mode_share": 0.7263897957126952, + "mode_share_label": "share in the deeper family", + "n_effective": 4096, + "n_active": 2048, + "seed": 100 + }, + { + "wall_s": 1088.5490216268227, + "calls": { + "search": 0, + "warmup": 452608, + "sampling": 0, + "evidence": 4096 + }, + "min_ess": 7657.833008579278, + "logz": -84.51597167544634, + "logz_err": 0.016932283455287158, + "mean": [ + 156.8453638318768, + 27.069337735167153, + 1.2947977933314174, + 0.608864295465577, + -0.7212573961084257, + -0.9447888636666276, + -3.709663436515888, + 0.37087162575912946, + 7.984688061244383 + ], + "sd": [ + 20.124807978571543, + 2.4152088074968368, + 0.025493284790083705, + 0.016973670807841564, + 0.1045604599454184, + 0.7561228271572354, + 0.28373174082829894, + 0.2335199026487719, + 3.359391388802531 + ], + "mcse": [ + 0.22997403194777516, + 0.027599533274913275, + 0.0002913217108461862, + 0.00019396475816265874, + 0.001194853167372607, + 0.008640510527814872, + 0.003242313293091932, + 0.0026685230293562226, + 0.03838907598006265 + ], + "mode_share": 0.7374598373006163, + "mode_share_label": "share in the deeper family", + "n_effective": 4096, + "n_active": 2048, + "seed": 101 + }, + { + "wall_s": 942.568611101713, + "calls": { + "search": 0, + "warmup": 378880, + "sampling": 0, + "evidence": 4096 + }, + "min_ess": 6865.934284607006, + "logz": -84.55184157348796, + "logz_err": 0.017504616918066897, + "mean": [ + 155.52395681032212, + 27.007224688111556, + 1.2965403828410718, + 0.6086332939584448, + -0.7155945846885606, + -0.950464641315256, + -3.713809950933923, + 0.3565088551716134, + 7.952657958707909 + ], + "sd": [ + 20.639809673594932, + 2.473469531150617, + 0.025899911082942408, + 0.017179816436940002, + 0.10530954454456168, + 0.7469538918871339, + 0.290820580453847, + 0.23355354918815963, + 3.335311683241913 + ], + "mcse": [ + 0.2490897558795925, + 0.029850852863150725, + 0.0003125708342750239, + 0.000207333127097981, + 0.001270919119760811, + 0.009014548366766554, + 0.0035097429935453885, + 0.0028186207853707563, + 0.0402519202502112 + ], + "mode_share": 0.7141050424314309, + "mode_share_label": "share in the deeper family", + "n_effective": 4096, + "n_active": 2048, + "seed": 102 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep_elastic.json b/benchmarks/results/hpc/sweep_elastic.json new file mode 100644 index 0000000..b27f436 --- /dev/null +++ b/benchmarks/results/hpc/sweep_elastic.json @@ -0,0 +1,810 @@ +{ + "problem": "elastic", + "names": [ + "Vv", + "Wv", + "Rv", + "av", + "log_c" + ], + "runs": [ + { + "wall_s": 274.03448850894347, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 92338, + "evidence": 0 + }, + "min_ess": 909.00204475289, + "logz": 496.03580291296845, + "logz_err": 0.5007124421250798, + "mean": [ + 47.64856751415197, + 3.5022901135738853, + 4.1235994165356935, + 0.6923162056033074, + -3.0825195013237576 + ], + "sd": [ + 0.14796176294991006, + 0.03209596654612512, + 0.008108679967956427, + 0.0033568465033058234, + 0.08795398532030799 + ], + "mcse": [ + 0.0049075763757947645, + 0.0010645548149719344, + 0.0002689476352285339, + 0.00011133944519416078, + 0.0029172462662604777 + ], + "sampler": "dynesty", + "setting": "dynesty rwalk 200", + "seed": 100, + "sample": "rwalk", + "nlive": 200 + }, + { + "wall_s": 282.490432714927, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 92991, + "evidence": 0 + }, + "min_ess": 939.2080104816725, + "logz": 495.6450878477409, + "logz_err": 0.5079034602974412, + "mean": [ + 47.65338779041746, + 3.5001739550506183, + 4.123117056867896, + 0.6922450126455817, + -3.0829597512959475 + ], + "sd": [ + 0.15126542764808004, + 0.03318040460182434, + 0.008294687390886556, + 0.0035113881372716327, + 0.096790824630981 + ], + "mcse": [ + 0.004935814000426511, + 0.0010826816683751298, + 0.00027065691605585306, + 0.00011457713106261711, + 0.003158299386412947 + ], + "sampler": "dynesty", + "setting": "dynesty rwalk 200", + "seed": 101, + "sample": "rwalk", + "nlive": 200 + }, + { + "wall_s": 290.040280230809, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 92938, + "evidence": 0 + }, + "min_ess": 1008.9573445031515, + "logz": 496.04433878706004, + "logz_err": 0.48551785768797523, + "mean": [ + 47.656266285818546, + 3.5015112513886786, + 4.12304005041177, + 0.6922632141105077, + -3.0789686958726943 + ], + "sd": [ + 0.1494939613049042, + 0.03221265219088451, + 0.008164204226116016, + 0.003523537418119209, + 0.0952435771694986 + ], + "mcse": [ + 0.004706382786930345, + 0.0010141217107983577, + 0.000257026236400332, + 0.00011092833254929089, + 0.002998467150401848 + ], + "sampler": "dynesty", + "setting": "dynesty rwalk 200", + "seed": 102, + "sample": "rwalk", + "nlive": 200 + }, + { + "wall_s": 712.0838796827011, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 230048, + "evidence": 0 + }, + "min_ess": 2425.055239739554, + "logz": 496.09544091000726, + "logz_err": 0.33563162383279105, + "mean": [ + 47.65262182957615, + 3.5018188093258935, + 4.123397413742452, + 0.6922973676261066, + -3.081223419643918 + ], + "sd": [ + 0.15180059103335192, + 0.03243478417968313, + 0.00843000203413271, + 0.0035583361662877514, + 0.0910591499848336 + ], + "mcse": [ + 0.0030825678502856444, + 0.0006586431730116099, + 0.00017118545501941236, + 7.225803662580833e-05, + 0.001849110114175479 + ], + "sampler": "dynesty", + "setting": "dynesty rwalk 500", + "seed": 100, + "sample": "rwalk", + "nlive": 500 + }, + { + "wall_s": 717.2311589857563, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 232613, + "evidence": 0 + }, + "min_ess": 2372.9787198349304, + "logz": 495.90035616158684, + "logz_err": 0.3395291582411657, + "mean": [ + 47.65232881196425, + 3.5012608729029866, + 4.1233862167315225, + 0.6922760324723187, + -3.080159369865762 + ], + "sd": [ + 0.15309830139008831, + 0.032509842827727994, + 0.008428409824800934, + 0.0036548979090173937, + 0.09129227239447818 + ], + "mcse": [ + 0.0031428485287306766, + 0.0006673719484323765, + 0.00017302096219814572, + 7.502885670003786e-05, + 0.0018740755539044874 + ], + "sampler": "dynesty", + "setting": "dynesty rwalk 500", + "seed": 101, + "sample": "rwalk", + "nlive": 500 + }, + { + "wall_s": 700.5826396960765, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 230503, + "evidence": 0 + }, + "min_ess": 2442.245265314445, + "logz": 495.98116436561395, + "logz_err": 0.3348094062787077, + "mean": [ + 47.64889753898469, + 3.5013828545532424, + 4.123565588408864, + 0.6921091514366082, + -3.0803497163060576 + ], + "sd": [ + 0.15199393860539043, + 0.03329590649774805, + 0.008327263134466883, + 0.003665025839142302, + 0.09252609485726562 + ], + "mcse": [ + 0.0030756125956601234, + 0.0006737460082159083, + 0.0001685030049141331, + 7.416216552918586e-05, + 0.0018722748116230285 + ], + "sampler": "dynesty", + "setting": "dynesty rwalk 500", + "seed": 102, + "sample": "rwalk", + "nlive": 500 + }, + { + "wall_s": 568.8961415539961, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 187543, + "evidence": 0 + }, + "min_ess": 1239.8963540578925, + "logz": 496.19159255017144, + "logz_err": 0.4508020161296289, + "mean": [ + 47.64885776197835, + 3.5025853381901486, + 4.123668621993126, + 0.6920491987473151, + -3.079710978819507 + ], + "sd": [ + 0.1570800850888368, + 0.033362382540834366, + 0.008610806949174755, + 0.0037013923734366527, + 0.09463030484125243 + ], + "mcse": [ + 0.004460961102125019, + 0.0009474675972113648, + 0.0002445407056945008, + 0.00010511687329596785, + 0.0026874323931026455 + ], + "sampler": "dynesty", + "setting": "dynesty rslice 250", + "seed": 100, + "sample": "rslice", + "nlive": 250 + }, + { + "wall_s": 527.2133273669751, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 185544, + "evidence": 0 + }, + "min_ess": 1211.3751329366166, + "logz": 496.22821897692967, + "logz_err": 0.4401789868016732, + "mean": [ + 47.66153808907705, + 3.503148408157161, + 4.122817486659775, + 0.6924108256121795, + -3.0864361489362317 + ], + "sd": [ + 0.14735055074438258, + 0.03236089455340982, + 0.008127821306184967, + 0.003574134790228415, + 0.09221340919366691 + ], + "mcse": [ + 0.00423362548000659, + 0.0009297821219195222, + 0.00023352577377534455, + 0.00010269081479809726, + 0.002649444042037048 + ], + "sampler": "dynesty", + "setting": "dynesty rslice 250", + "seed": 101, + "sample": "rslice", + "nlive": 250 + }, + { + "wall_s": 555.4467242809478, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 184112, + "evidence": 0 + }, + "min_ess": 1211.5539925687563, + "logz": 496.5239615543617, + "logz_err": 0.4471719500231492, + "mean": [ + 47.65496209774057, + 3.5021178222066527, + 4.123114451030975, + 0.6923306552244296, + -3.0847733173999092 + ], + "sd": [ + 0.15095098504429003, + 0.032358687257244376, + 0.008300602349723917, + 0.003563150545097143, + 0.09358672854890045 + ], + "mcse": [ + 0.004336751774245067, + 0.0009296500737237426, + 0.00023847245486278886, + 0.00010236766221709945, + 0.002688703296378972 + ], + "sampler": "dynesty", + "setting": "dynesty rslice 250", + "seed": 102, + "sample": "rslice", + "nlive": 250 + }, + { + "wall_s": 1148.4892376849893, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 382191, + "evidence": 0 + }, + "min_ess": 2472.7794624838543, + "logz": 495.7260625584274, + "logz_err": 0.33720117817194334, + "mean": [ + 47.65150775891206, + 3.5014689293746115, + 4.123455780825264, + 0.6922140231810403, + -3.081042488019189 + ], + "sd": [ + 0.15555405113486523, + 0.033216431296899517, + 0.0084074462070437, + 0.003616645089115512, + 0.09467748852140902 + ], + "mcse": [ + 0.003128157660034534, + 0.0006679751073170087, + 0.00016907188891589922, + 7.272993507147063e-05, + 0.0019039434125331877 + ], + "sampler": "dynesty", + "setting": "dynesty rslice 500", + "seed": 100, + "sample": "rslice", + "nlive": 500 + }, + { + "wall_s": 1141.9505353140412, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 380393, + "evidence": 0 + }, + "min_ess": 2424.6396387775335, + "logz": 495.92048259561363, + "logz_err": 0.33548957350307557, + "mean": [ + 47.65322082105977, + 3.501765259905312, + 4.123429709857102, + 0.6922724814902125, + -3.0830815653587447 + ], + "sd": [ + 0.14818176607047281, + 0.03279243023584373, + 0.008104603303677406, + 0.0035057324868646065, + 0.09437903958335257 + ], + "mcse": [ + 0.003009339364530765, + 0.0006659628494400663, + 0.00016459178752170668, + 7.119593087599331e-05, + 0.0019166903360411807 + ], + "sampler": "dynesty", + "setting": "dynesty rslice 500", + "seed": 101, + "sample": "rslice", + "nlive": 500 + }, + { + "wall_s": 1136.4918976819608, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 378243, + "evidence": 0 + }, + "min_ess": 2342.977933268166, + "logz": 495.82236424669475, + "logz_err": 0.3443471528918057, + "mean": [ + 47.64817403392361, + 3.501543845410961, + 4.123736563617882, + 0.6921116851567884, + -3.0828903088073143 + ], + "sd": [ + 0.14862389251515934, + 0.032372685185353724, + 0.008101149290157957, + 0.003514646332009541, + 0.09206416811558217 + ], + "mcse": [ + 0.003070467693911788, + 0.0006687974749192283, + 0.00016736418861085402, + 7.261018289411401e-05, + 0.001901982576165713 + ], + "sampler": "dynesty", + "setting": "dynesty rslice 500", + "seed": 102, + "sample": "rslice", + "nlive": 500 + }, + { + "wall_s": 242.08345339191146, + "calls": { + "search": 0, + "warmup": 31232, + "sampling": 16640, + "evidence": 4096 + }, + "min_ess": 4105.015424143376, + "logz": 495.9558069708043, + "logz_err": 0.006435698285810845, + "mean": [ + 47.65365105253516, + 3.501376039575128, + 4.123498942699237, + 0.6921994565064251, + -3.084296406925438 + ], + "sd": [ + 0.15173488272040409, + 0.03282338177791061, + 0.008318626170964268, + 0.0036226960564476685, + 0.09376329812264159 + ], + "mcse": [ + 0.002368252675951383, + 0.0005123018539682017, + 0.0001298357262115322, + 5.6542434251257486e-05, + 0.0014634418777265976 + ], + "sampler": "pocomc", + "setting": "pocomc 512/256", + "seed": 100, + "n_effective": 512, + "n_active": 256 + }, + { + "wall_s": 238.92506827099714, + "calls": { + "search": 0, + "warmup": 32768, + "sampling": 16896, + "evidence": 4096 + }, + "min_ess": 4113.894998625182, + "logz": 495.94490894618366, + "logz_err": 0.008348406651532978, + "mean": [ + 47.65442100176697, + 3.50246491817577, + 4.123262239554605, + 0.6923044656123671, + -3.0814659689067994 + ], + "sd": [ + 0.15232378817860756, + 0.0328271306240558, + 0.008356741630333933, + 0.0036093264431911695, + 0.09323118280648361 + ], + "mcse": [ + 0.0023748770485862583, + 0.0005118071183904683, + 0.00013028978688197162, + 5.6272934341282335e-05, + 0.0014535654536115524 + ], + "sampler": "pocomc", + "setting": "pocomc 512/256", + "seed": 101, + "n_effective": 512, + "n_active": 256 + }, + { + "wall_s": 246.12204775004648, + "calls": { + "search": 0, + "warmup": 32512, + "sampling": 17920, + "evidence": 4096 + }, + "min_ess": 4092.8187600565775, + "logz": 495.95422889552077, + "logz_err": 0.0071286374940756365, + "mean": [ + 47.654790524362554, + 3.5024869088014654, + 4.123219212139516, + 0.6922693036129394, + -3.0840663554609398 + ], + "sd": [ + 0.1535797463315844, + 0.0334717308299908, + 0.00834716175752581, + 0.003589278257384712, + 0.09370017210205174 + ], + "mcse": [ + 0.002400615960601328, + 0.0005231990101477497, + 0.00013047508033757257, + 5.610426425053316e-05, + 0.0014646340681773683 + ], + "sampler": "pocomc", + "setting": "pocomc 512/256", + "seed": 102, + "n_effective": 512, + "n_active": 256 + }, + { + "wall_s": 310.3885606629774, + "calls": { + "search": 0, + "warmup": 62976, + "sampling": 15872, + "evidence": 4096 + }, + "min_ess": 4492.624145484327, + "logz": 495.94733412488057, + "logz_err": 0.008675703169783142, + "mean": [ + 47.65211189898632, + 3.501982589796204, + 4.123420847079423, + 0.6922205838406534, + -3.082104670442744 + ], + "sd": [ + 0.1533338101239784, + 0.03222191479308301, + 0.008388731875437228, + 0.0035641850694762005, + 0.09484229401981524 + ], + "mcse": [ + 0.0022876410654111795, + 0.00048073008442975834, + 0.00012515444251634715, + 5.317533114886118e-05, + 0.0014149855557760082 + ], + "sampler": "pocomc", + "setting": "pocomc 1024/512", + "seed": 100, + "n_effective": 1024, + "n_active": 512 + }, + { + "wall_s": 276.7233874190133, + "calls": { + "search": 0, + "warmup": 54272, + "sampling": 14336, + "evidence": 4096 + }, + "min_ess": 4485.94209081558, + "logz": 495.9371713506923, + "logz_err": 0.011429031230759295, + "mean": [ + 47.655907530089856, + 3.502253430457345, + 4.123309879035739, + 0.6923381044274516, + -3.081386322167644 + ], + "sd": [ + 0.1533198095515109, + 0.032117795211468035, + 0.008335500301040147, + 0.003608239884380529, + 0.09194952591826622 + ], + "mcse": [ + 0.0022891351793153554, + 0.00047953343482282735, + 0.00012445284814871922, + 5.3872678807164905e-05, + 0.001372848656129824 + ], + "sampler": "pocomc", + "setting": "pocomc 1024/512", + "seed": 101, + "n_effective": 1024, + "n_active": 512 + }, + { + "wall_s": 275.5099334400147, + "calls": { + "search": 0, + "warmup": 55808, + "sampling": 9728, + "evidence": 4096 + }, + "min_ess": 4538.406027328578, + "logz": 495.9612014969373, + "logz_err": 0.009020924094894134, + "mean": [ + 47.65150680572021, + 3.5019641580456398, + 4.123473002997184, + 0.6922393780745044, + -3.082862949962321 + ], + "sd": [ + 0.15257533177696, + 0.032707076345247006, + 0.008395373342067506, + 0.0035652179422271087, + 0.09390793112892473 + ], + "mcse": [ + 0.002264814565173496, + 0.00048550091307841993, + 0.00012462017027089977, + 5.292177594853609e-05, + 0.0013939609223134924 + ], + "sampler": "pocomc", + "setting": "pocomc 1024/512", + "seed": 102, + "n_effective": 1024, + "n_active": 512 + }, + { + "wall_s": 424.4322154899128, + "calls": { + "search": 0, + "warmup": 104448, + "sampling": 3072, + "evidence": 4096 + }, + "min_ess": 4492.936177085541, + "logz": 495.9634740044973, + "logz_err": 0.008624160746280689, + "mean": [ + 47.65487253188052, + 3.502244405161914, + 4.12329597851229, + 0.6922856643130126, + -3.0806595275145834 + ], + "sd": [ + 0.15057093632107618, + 0.03282005921229859, + 0.008205202051488374, + 0.003545654942404293, + 0.09125433215319735 + ], + "mcse": [ + 0.0022463427713865216, + 0.0004896370081063571, + 0.00012241204555454963, + 5.289703673434559e-05, + 0.0013614082132884114 + ], + "sampler": "pocomc", + "setting": "pocomc 2048/1024", + "seed": 100, + "n_effective": 2048, + "n_active": 1024 + }, + { + "wall_s": 443.992216182407, + "calls": { + "search": 0, + "warmup": 102400, + "sampling": 0, + "evidence": 4096 + }, + "min_ess": 4200.963261653794, + "logz": 495.9531711010714, + "logz_err": 0.008926310105722616, + "mean": [ + 47.656748218625275, + 3.502056613160312, + 4.123233662904203, + 0.69226913217533, + -3.0826132909994843 + ], + "sd": [ + 0.15304129483139492, + 0.03246501946777132, + 0.008348324095990027, + 0.003573020001030836, + 0.09293240430697979 + ], + "mcse": [ + 0.0023612076938791444, + 0.0005008886904262684, + 0.00012880266798686647, + 5.512657434134165e-05, + 0.001433813718722625 + ], + "sampler": "pocomc", + "setting": "pocomc 2048/1024", + "seed": 101, + "n_effective": 2048, + "n_active": 1024 + }, + { + "wall_s": 392.74843109585345, + "calls": { + "search": 0, + "warmup": 95232, + "sampling": 3072, + "evidence": 4096 + }, + "min_ess": 4535.368392897874, + "logz": 495.94978701649956, + "logz_err": 0.012454674155863169, + "mean": [ + 47.656154727061946, + 3.5024250242207104, + 4.123275337193139, + 0.6923177545563206, + -3.0811489654470114 + ], + "sd": [ + 0.1513136165961228, + 0.03227327821439749, + 0.00836363366517318, + 0.0035608340816939005, + 0.09235264949671027 + ], + "mcse": [ + 0.002246837827751597, + 0.0004792220551518946, + 0.00012419059777366625, + 5.2874400156938566e-05, + 0.0013713334665454693 + ], + "sampler": "pocomc", + "setting": "pocomc 2048/1024", + "seed": 102, + "n_effective": 2048, + "n_active": 1024 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep_gp.json b/benchmarks/results/hpc/sweep_gp.json new file mode 100644 index 0000000..9fe6e39 --- /dev/null +++ b/benchmarks/results/hpc/sweep_gp.json @@ -0,0 +1,746 @@ +{ + "problem": "gp", + "names": [ + "m", + "b", + "discrepancy_k1__constant_value", + "discrepancy_k2__length_scale" + ], + "runs": [ + { + "wall_s": 22.984976318199188, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 50322, + "evidence": 0 + }, + "min_ess": 869.6871736359544, + "logz": 81.65101468900163, + "logz_err": 0.3858456801676129, + "mean": [ + 1.9886938117275705, + 1.009814705392353, + -8.643749466203314, + -0.6769998522019952 + ], + "sd": [ + 0.04612876313489615, + 0.10544434617041898, + 2.3598480110893933, + 1.0953701361733053 + ], + "mcse": [ + 0.0015641927815475435, + 0.0035755410274592235, + 0.08002072836206053, + 0.03714320401599667 + ], + "sampler": "dynesty", + "setting": "dynesty rwalk 200", + "seed": 100, + "sample": "rwalk", + "nlive": 200 + }, + { + "wall_s": 26.32070751709398, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 57919, + "evidence": 0 + }, + "min_ess": 1081.1692072001274, + "logz": 79.69657303732797, + "logz_err": 0.41659859829266155, + "mean": [ + 1.9851591110976, + 1.0056374188556685, + -7.6546797190224085, + -0.39832499174989044 + ], + "sd": [ + 0.07908794612622544, + 0.19667020534804455, + 3.005331546396816, + 1.0816199849534374 + ], + "mcse": [ + 0.002405267943767293, + 0.005981246998914309, + 0.09139986537776391, + 0.032894846870778496 + ], + "sampler": "dynesty", + "setting": "dynesty rwalk 200", + "seed": 101, + "sample": "rwalk", + "nlive": 200 + }, + { + "wall_s": 23.934322617016733, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 53229, + "evidence": 0 + }, + "min_ess": 985.9802158086194, + "logz": 80.91640218808502, + "logz_err": 0.39554513871784686, + "mean": [ + 1.9875052320811508, + 1.0076166361908303, + -8.08203651757797, + -0.42046471783566786 + ], + "sd": [ + 0.0578066137188785, + 0.13930458417030958, + 2.6524623959141835, + 1.1158104892674439 + ], + "mcse": [ + 0.0018409560861091842, + 0.0044364062440745925, + 0.08447245871693833, + 0.03553500160294842 + ], + "sampler": "dynesty", + "setting": "dynesty rwalk 200", + "seed": 102, + "sample": "rwalk", + "nlive": 200 + }, + { + "wall_s": 62.154148363973945, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 140322, + "evidence": 0 + }, + "min_ess": 2617.511122238438, + "logz": 80.26485265025148, + "logz_err": 0.2756256912998115, + "mean": [ + 1.986483378703321, + 1.0080958677321048, + -7.806147656849368, + -0.3440868095503301 + ], + "sd": [ + 0.07304266836531359, + 0.18457187760714197, + 2.8796012261330692, + 1.1078197552899927 + ], + "mcse": [ + 0.0014276848875587052, + 0.0036076239576864513, + 0.0562844053311996, + 0.02165333712695499 + ], + "sampler": "dynesty", + "setting": "dynesty rwalk 500", + "seed": 100, + "sample": "rwalk", + "nlive": 500 + }, + { + "wall_s": 64.49020975490566, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 145110, + "evidence": 0 + }, + "min_ess": 2893.5511003348133, + "logz": 79.87947634647942, + "logz_err": 0.2807153555032956, + "mean": [ + 1.986135167505337, + 1.000945166579118, + -7.200811110274364, + -0.28077409797507036 + ], + "sd": [ + 0.09263225208375066, + 0.23098658324056612, + 3.1378878824773326, + 1.0660067633694288 + ], + "mcse": [ + 0.001722053518910444, + 0.004294090336170216, + 0.05833401162568109, + 0.019817295345285854 + ], + "sampler": "dynesty", + "setting": "dynesty rwalk 500", + "seed": 101, + "sample": "rwalk", + "nlive": 500 + }, + { + "wall_s": 61.4921385810012, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 140241, + "evidence": 0 + }, + "min_ess": 2637.018788160004, + "logz": 80.27307753190296, + "logz_err": 0.27443458481993516, + "mean": [ + 1.9866825651334385, + 1.0086531403988774, + -7.818408722132779, + -0.4519651873574019 + ], + "sd": [ + 0.07051368362760856, + 0.17101882872458427, + 2.8170993825912722, + 1.1410857503855873 + ], + "mcse": [ + 0.0013731462359000703, + 0.0033303303536287828, + 0.0548587056349308, + 0.022220901282877945 + ], + "sampler": "dynesty", + "setting": "dynesty rwalk 500", + "seed": 102, + "sample": "rwalk", + "nlive": 500 + }, + { + "wall_s": 50.41558026301209, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 110736, + "evidence": 0 + }, + "min_ess": 1413.8826023992613, + "logz": 80.0008893241213, + "logz_err": 0.3718627977934116, + "mean": [ + 1.9849139409681507, + 1.0039050210257365, + -7.401196453980242, + -0.3423101695579602 + ], + "sd": [ + 0.09380919270274933, + 0.23344349568945355, + 3.1064691538497238, + 1.1082291492386809 + ], + "mcse": [ + 0.002494817163913176, + 0.006208334418731987, + 0.08261527832084195, + 0.029472901571921607 + ], + "sampler": "dynesty", + "setting": "dynesty rslice 250", + "seed": 100, + "sample": "rslice", + "nlive": 250 + }, + { + "wall_s": 50.25375888007693, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 108074, + "evidence": 0 + }, + "min_ess": 1306.7598646764993, + "logz": 79.91112755961167, + "logz_err": 0.37140784216601697, + "mean": [ + 1.9857505610485917, + 1.0080858942469668, + -7.827795470726175, + -0.4821083136667426 + ], + "sd": [ + 0.07624020509993198, + 0.17592585590299908, + 2.888463694495175, + 1.1072037500229308 + ], + "mcse": [ + 0.0021090465350573637, + 0.0048666686603595225, + 0.07990409179158248, + 0.030628776897013682 + ], + "sampler": "dynesty", + "setting": "dynesty rslice 250", + "seed": 101, + "sample": "rslice", + "nlive": 250 + }, + { + "wall_s": 46.00912691594567, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 100189, + "evidence": 0 + }, + "min_ess": 1175.3990980140331, + "logz": 81.15485911168184, + "logz_err": 0.35652932566189144, + "mean": [ + 1.987820040407194, + 1.0082602298824583, + -8.375636794603233, + -0.6418880138730712 + ], + "sd": [ + 0.05040943017939141, + 0.11867099071622399, + 2.43755590484482, + 1.1535867780727906 + ], + "mcse": [ + 0.0014703445350492987, + 0.003461400814243296, + 0.07109874066838737, + 0.033647871217911345 + ], + "sampler": "dynesty", + "setting": "dynesty rslice 250", + "seed": 102, + "sample": "rslice", + "nlive": 250 + }, + { + "wall_s": 100.00869192101527, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 220408, + "evidence": 0 + }, + "min_ess": 2722.0340301721485, + "logz": 79.94943907177611, + "logz_err": 0.27845558089058353, + "mean": [ + 1.9850871205501293, + 1.0062645880677104, + -7.6009231125663606, + -0.3432467505013782 + ], + "sd": [ + 0.08594673243550294, + 0.21127440066622447, + 3.044293883063151, + 1.088177259830067 + ], + "mcse": [ + 0.0016473375384078337, + 0.0040494878776603715, + 0.05834985751527752, + 0.02085704945100807 + ], + "sampler": "dynesty", + "setting": "dynesty rslice 500", + "seed": 100, + "sample": "rslice", + "nlive": 500 + }, + { + "wall_s": 98.82883791299537, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 217213, + "evidence": 0 + }, + "min_ess": 2819.907825037753, + "logz": 80.07109949343977, + "logz_err": 0.27809334139239017, + "mean": [ + 1.985669825526598, + 1.0051828961397862, + -7.369608555895612, + -0.2334310719930581 + ], + "sd": [ + 0.08403858212869804, + 0.20564123159750175, + 2.9868522083657725, + 1.0479297488523227 + ], + "mcse": [ + 0.0015825639197183433, + 0.003872511711754791, + 0.05624660029665779, + 0.01973398133244878 + ], + "sampler": "dynesty", + "setting": "dynesty rslice 500", + "seed": 101, + "sample": "rslice", + "nlive": 500 + }, + { + "wall_s": 98.49168167309836, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 216658, + "evidence": 0 + }, + "min_ess": 2617.2959295166816, + "logz": 80.13040916950214, + "logz_err": 0.2777401809182048, + "mean": [ + 1.9862282336449362, + 1.0064511324771663, + -7.772152582655095, + -0.38908957311292347 + ], + "sd": [ + 0.0772239229637985, + 0.1929910136599818, + 2.928449038471651, + 1.0807443551334135 + ], + "mcse": [ + 0.001509473333265886, + 0.0037723386419550218, + 0.05724153295699974, + 0.021124992379839086 + ], + "sampler": "dynesty", + "setting": "dynesty rslice 500", + "seed": 102, + "sample": "rslice", + "nlive": 500 + }, + { + "wall_s": 82.78955620899796, + "calls": { + "search": 0, + "warmup": 24832, + "sampling": 43520, + "evidence": 4096 + }, + "min_ess": 4270.276894314467, + "logz": 80.38696688825641, + "logz_err": 0.030362892399673096, + "mean": [ + 1.9848774091614338, + 0.9982636565848231, + -6.517337740835355, + -0.12111242360338463 + ], + "sd": [ + 0.11438715866230946, + 0.28554463208881603, + 3.058874358690021, + 0.9058341534308871 + ], + "mcse": [ + 0.0017504481623277243, + 0.004369643256705076, + 0.046809458881371946, + 0.01386183333679785 + ], + "sampler": "pocomc", + "setting": "pocomc 512/256", + "seed": 100, + "n_effective": 512, + "n_active": 256 + }, + { + "wall_s": 79.16744253830984, + "calls": { + "search": 0, + "warmup": 20736, + "sampling": 18432, + "evidence": 4096 + }, + "min_ess": 4182.12125097962, + "logz": 81.42120745504137, + "logz_err": 0.805099066240288, + "mean": [ + 1.9848278547507545, + 1.0056727904105243, + -6.487621893889062, + -0.005858459126843666 + ], + "sd": [ + 0.08108714683038556, + 0.19272783672749366, + 2.420443466209787, + 0.6786795133810675 + ], + "mcse": [ + 0.0012538734581620467, + 0.002980204983991835, + 0.037428001081484905, + 0.010494613039066375 + ], + "sampler": "pocomc", + "setting": "pocomc 512/256", + "seed": 101, + "n_effective": 512, + "n_active": 256 + }, + { + "wall_s": 82.26889659801964, + "calls": { + "search": 0, + "warmup": 28672, + "sampling": 30208, + "evidence": 4096 + }, + "min_ess": 4123.157124222895, + "logz": 80.56521429928226, + "logz_err": 0.1817185729129094, + "mean": [ + 1.9835248476824767, + 1.007642428417107, + -7.222377156871866, + -0.021005266538375894 + ], + "sd": [ + 0.08438778635583488, + 0.20677707948387372, + 3.011543976006008, + 0.7506931073463755 + ], + "mcse": [ + 0.001314209651041197, + 0.003220234173769506, + 0.04690015378663168, + 0.011690887618318206 + ], + "sampler": "pocomc", + "setting": "pocomc 512/256", + "seed": 102, + "n_effective": 512, + "n_active": 256 + }, + { + "wall_s": 65.43069717299659, + "calls": { + "search": 0, + "warmup": 44032, + "sampling": 37888, + "evidence": 4096 + }, + "min_ess": 4543.984700908694, + "logz": 80.26818813549805, + "logz_err": 0.10722720887979408, + "mean": [ + 1.9834333844221137, + 1.0034470622501803, + -6.1491412175619375, + 0.09445499095097333 + ], + "sd": [ + 0.10325678213823816, + 0.2520666030865473, + 2.813330452178692, + 0.6914388023395533 + ], + "mcse": [ + 0.0015317932677545523, + 0.0037393565598123155, + 0.04173518249723099, + 0.010257353372391953 + ], + "sampler": "pocomc", + "setting": "pocomc 1024/512", + "seed": 100, + "n_effective": 1024, + "n_active": 512 + }, + { + "wall_s": 72.89770616299938, + "calls": { + "search": 0, + "warmup": 64512, + "sampling": 35840, + "evidence": 4096 + }, + "min_ess": 4458.970402556144, + "logz": 80.33785784519652, + "logz_err": 0.04885379938257019, + "mean": [ + 1.9844295466195818, + 0.9998697665823755, + -6.375396109269953, + -0.16660387364037021 + ], + "sd": [ + 0.09341799677446712, + 0.23494083361010487, + 2.6450603406635653, + 0.9280891586511231 + ], + "mcse": [ + 0.0013989856358161423, + 0.0035183675826480697, + 0.03961122642555603, + 0.01389864315806526 + ], + "sampler": "pocomc", + "setting": "pocomc 1024/512", + "seed": 101, + "n_effective": 1024, + "n_active": 512 + }, + { + "wall_s": 74.68741836491972, + "calls": { + "search": 0, + "warmup": 69120, + "sampling": 27648, + "evidence": 4096 + }, + "min_ess": 4428.208615398064, + "logz": 80.52614264754641, + "logz_err": 0.06201162395347509, + "mean": [ + 1.9858578207122703, + 1.0062711518928742, + -7.658629081550243, + -0.3582146316965624 + ], + "sd": [ + 0.0795534303107213, + 0.1927638411896209, + 3.0137688644975005, + 0.9732469457472572 + ], + "mcse": [ + 0.0011954870463849526, + 0.0028967534681221783, + 0.04528933100977153, + 0.014625442448303338 + ], + "sampler": "pocomc", + "setting": "pocomc 1024/512", + "seed": 102, + "n_effective": 1024, + "n_active": 512 + }, + { + "wall_s": 81.07028435892425, + "calls": { + "search": 0, + "warmup": 99328, + "sampling": 17408, + "evidence": 4096 + }, + "min_ess": 5076.51180603087, + "logz": 80.42659930253285, + "logz_err": 0.02545482579820508, + "mean": [ + 1.985024454041959, + 1.0081870385983536, + -7.284772291949094, + -0.2779758339342051 + ], + "sd": [ + 0.07297729050857235, + 0.1801097872959796, + 2.838559614920184, + 1.0338479464200976 + ], + "mcse": [ + 0.0010242477878275825, + 0.0025278692853406737, + 0.039839632109350424, + 0.014510219065292472 + ], + "sampler": "pocomc", + "setting": "pocomc 2048/1024", + "seed": 100, + "n_effective": 2048, + "n_active": 1024 + }, + { + "wall_s": 84.72822909802198, + "calls": { + "search": 0, + "warmup": 105472, + "sampling": 10240, + "evidence": 4096 + }, + "min_ess": 5000.445755158273, + "logz": 80.27316810248178, + "logz_err": 0.04359529679086668, + "mean": [ + 1.9861676289978625, + 1.0062619025330601, + -7.064969177086303, + -0.29361047230507337 + ], + "sd": [ + 0.07050520968869152, + 0.1692513075108274, + 2.489681098342304, + 0.9566689247891524 + ], + "mcse": [ + 0.0009970497945786792, + 0.0023934682576074915, + 0.035207838380016364, + 0.01352873864431354 + ], + "sampler": "pocomc", + "setting": "pocomc 2048/1024", + "seed": 101, + "n_effective": 2048, + "n_active": 1024 + }, + { + "wall_s": 79.06404565600678, + "calls": { + "search": 0, + "warmup": 120832, + "sampling": 0, + "evidence": 4096 + }, + "min_ess": 4159.4024529531835, + "logz": 80.2675664519748, + "logz_err": 0.1504050708482348, + "mean": [ + 1.9864436262313607, + 1.003879605116358, + -7.1384631221237855, + 0.04494459014552588 + ], + "sd": [ + 0.07738595727888326, + 0.1884319165981073, + 2.8488873631906886, + 0.6467598793923378 + ], + "mcse": [ + 0.0011999045149095767, + 0.002921722692714315, + 0.0441732961607253, + 0.010028306512362606 + ], + "sampler": "pocomc", + "setting": "pocomc 2048/1024", + "seed": 102, + "n_effective": 2048, + "n_active": 1024 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep_modes.json b/benchmarks/results/hpc/sweep_modes.json new file mode 100644 index 0000000..5987d37 --- /dev/null +++ b/benchmarks/results/hpc/sweep_modes.json @@ -0,0 +1,1066 @@ +{ + "problem": "modes", + "names": [ + "m", + "b", + "log_eta0", + "log_eta1", + "log_eta2", + "log_eta3", + "log_eta4", + "log_eta5", + "log_s" + ], + "runs": [ + { + "wall_s": 29.43201130197849, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 86829, + "evidence": 0 + }, + "min_ess": 1563.7868176973654, + "logz": 102.45776858406965, + "logz_err": 0.40812562354812865, + "mean": [ + 1.9645424347292435, + 1.0058394944313525, + -4.526339368560601, + -4.246011851491037, + -4.4541786630981415, + -4.600487469941477, + -4.497313525508788, + -4.6637746923673955, + -2.1700012358478595 + ], + "sd": [ + 0.14559924333109453, + 0.024728741689397617, + 1.1448986456259551, + 1.3381392481825392, + 1.1654334454180117, + 1.0924999516793121, + 1.147871072766975, + 1.0232033019220834, + 1.5003062115649002 + ], + "mcse": [ + 0.0036818860550528604, + 0.0006253357304759624, + 0.028951979840947856, + 0.03383861155375945, + 0.02947125996403026, + 0.027626931604904408, + 0.029027146014822088, + 0.025874571066719292, + 0.03793945897169565 + ], + "sampler": "dynesty", + "setting": "dynesty rwalk 200", + "seed": 100, + "sample": "rwalk", + "nlive": 200 + }, + { + "wall_s": 29.71863283100538, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 87951, + "evidence": 0 + }, + "min_ess": 1469.357233382725, + "logz": 103.01891659061636, + "logz_err": 0.4296863376080223, + "mean": [ + 1.9835275455520556, + 1.0038727459731105, + -4.779310357150201, + -4.52285759861352, + -4.711373301512654, + -4.626665031138085, + -4.485681645774478, + -4.469870507628545, + -3.400191161259549 + ], + "sd": [ + 0.07791496922766308, + 0.02491196807305364, + 0.9109250576214468, + 1.1194060892356752, + 1.0957329311206891, + 1.0761587685427028, + 1.1818423907226845, + 1.1913392368183506, + 1.5845970144018744 + ], + "mcse": [ + 0.0020326247333462984, + 0.0006498967138607815, + 0.02376396757516616, + 0.029202764580327247, + 0.02858518560701933, + 0.028074540125349413, + 0.03083158599833152, + 0.031079337161608378, + 0.04133854015200456 + ], + "sampler": "dynesty", + "setting": "dynesty rwalk 200", + "seed": 101, + "sample": "rwalk", + "nlive": 200 + }, + { + "wall_s": 30.791228907066397, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 89703, + "evidence": 0 + }, + "min_ess": 1557.3342148655242, + "logz": 102.48850115348017, + "logz_err": 0.396582713356139, + "mean": [ + 1.9653879562860703, + 0.9996660179931638, + -4.500326021933837, + -4.518504578608792, + -4.535366693515718, + -4.437140131442027, + -4.50080240761271, + -4.479464813533842, + -1.7520343964321212 + ], + "sd": [ + 0.1632264939262589, + 0.02355754916837671, + 1.105771492862936, + 1.1180802755609236, + 1.0857249789003984, + 1.1356817174419729, + 1.132113558410776, + 1.1293771454989536, + 1.2419089278040407 + ], + "mcse": [ + 0.004136182945267248, + 0.0005969517004179129, + 0.028020409433095073, + 0.028332315765503442, + 0.02751242787220111, + 0.028778338846495423, + 0.02868792118098148, + 0.028618580082334824, + 0.031470151708820324 + ], + "sampler": "dynesty", + "setting": "dynesty rwalk 200", + "seed": 102, + "sample": "rwalk", + "nlive": 200 + }, + { + "wall_s": 82.10787473910023, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 231669, + "evidence": 0 + }, + "min_ess": 4001.345789959648, + "logz": 102.3675847980749, + "logz_err": 0.27559399931277095, + "mean": [ + 1.9722328018894593, + 1.0033328282507603, + -4.587946923445265, + -4.6239826226162535, + -4.4853624511550985, + -4.597067878171428, + -4.524732104053027, + -4.615641016377707, + -2.777246560507108 + ], + "sd": [ + 0.13355375279106743, + 0.025423968018369564, + 1.1305487725959331, + 1.1175179482398836, + 1.158019908545971, + 1.0998313032052915, + 1.1086516265557578, + 1.0557971865055682, + 1.7385062974359167 + ], + "mcse": [ + 0.00211131510095042, + 0.00040192062358021866, + 0.01787253930390793, + 0.017666538531441428, + 0.018306823050784838, + 0.017386935151032477, + 0.017526373253638535, + 0.01669081172804951, + 0.027483575131101463 + ], + "sampler": "dynesty", + "setting": "dynesty rwalk 500", + "seed": 100, + "sample": "rwalk", + "nlive": 500 + }, + { + "wall_s": 78.4886231450364, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 226522, + "evidence": 0 + }, + "min_ess": 3877.4778197426285, + "logz": 102.45562504614705, + "logz_err": 0.29208544744417475, + "mean": [ + 1.9901233604654744, + 1.0059035523954574, + -4.691499088868208, + -4.381115038498604, + -4.686899830460219, + -4.631494544222449, + -4.583109140093579, + -4.553789171556547, + -3.1628230381488485 + ], + "sd": [ + 0.10236824139904745, + 0.026040849420288906, + 1.0299400821068891, + 1.237466336361591, + 1.0541140381016179, + 1.0672555042341454, + 1.0929681458263736, + 1.0930133897793122, + 1.7008335715328224 + ], + "mcse": [ + 0.0016439574832345686, + 0.00041819658801588904, + 0.016540068307538607, + 0.019872784919517363, + 0.01692828398179251, + 0.017139326110620596, + 0.01755225192610369, + 0.017552978510188635, + 0.027314116560411866 + ], + "sampler": "dynesty", + "setting": "dynesty rwalk 500", + "seed": 101, + "sample": "rwalk", + "nlive": 500 + }, + { + "wall_s": 82.61249051894993, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 234281, + "evidence": 0 + }, + "min_ess": 4270.4113310264565, + "logz": 102.81675190448404, + "logz_err": 0.27573837450052463, + "mean": [ + 1.9768326572084751, + 1.0040873395688907, + -4.619008989844818, + -4.666050174473226, + -4.709011244926993, + -4.687822100497837, + -4.526514048641702, + -4.607642091702034, + -2.7251280544105967 + ], + "sd": [ + 0.12841178492915387, + 0.02585350740580906, + 1.1185834078770993, + 1.0429581165900423, + 1.0368273977851485, + 1.0350784659615488, + 1.1670020783808468, + 1.1161694770849462, + 1.7467993351003395 + ], + "mcse": [ + 0.001965033815274452, + 0.000395625808985459, + 0.01711723127979355, + 0.0159599679121748, + 0.01586615199200671, + 0.015839388792851128, + 0.017858162689500124, + 0.01708029186931086, + 0.026730566543131946 + ], + "sampler": "dynesty", + "setting": "dynesty rwalk 500", + "seed": 102, + "sample": "rwalk", + "nlive": 500 + }, + { + "wall_s": 91.58628450299148, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 257432, + "evidence": 0 + }, + "min_ess": 2031.057420729087, + "logz": 102.32979575753612, + "logz_err": 0.3861435520358524, + "mean": [ + 1.9729975451378505, + 1.0017072710968185, + -4.547808486864792, + -4.734242391775856, + -4.626785473782198, + -4.604707213272206, + -4.573981032882256, + -4.4821205015248955, + -2.451385495354942 + ], + "sd": [ + 0.1458230423882545, + 0.025529765034323, + 1.1121874606035915, + 0.9822344249128173, + 1.0070171571711197, + 1.031422491753062, + 1.0711314282900333, + 1.1521473297383997, + 1.6512372203555257 + ], + "mcse": [ + 0.0032356761971220286, + 0.0005664814811622034, + 0.024678393990924547, + 0.021794858320280382, + 0.02234476384655746, + 0.02288629527325296, + 0.02376739923776643, + 0.025565065913838867, + 0.03663940130587116 + ], + "sampler": "dynesty", + "setting": "dynesty rslice 250", + "seed": 100, + "sample": "rslice", + "nlive": 250 + }, + { + "wall_s": 81.73667582706548, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 240525, + "evidence": 0 + }, + "min_ess": 1977.835025879452, + "logz": 102.8784846041329, + "logz_err": 0.373769694289238, + "mean": [ + 1.9593517398591394, + 1.0008317247891034, + -4.624734886350306, + -4.586507006581476, + -4.601180020355411, + -4.661637986477078, + -4.516653928436162, + -4.6081220657307576, + -2.4378448083796993 + ], + "sd": [ + 0.17051537033454323, + 0.026091484036924534, + 1.1145710199820973, + 1.1190304770486674, + 1.1258685214690662, + 1.0735104219597578, + 1.2386483425571768, + 1.142022310431794, + 1.6430056277307044 + ], + "mcse": [ + 0.0038341447152570474, + 0.0005866833320486997, + 0.0250618262603468, + 0.025162099940726226, + 0.025315857644948002, + 0.024138553041024857, + 0.02785178243673796, + 0.025679085689794073, + 0.036944008814817686 + ], + "sampler": "dynesty", + "setting": "dynesty rslice 250", + "seed": 101, + "sample": "rslice", + "nlive": 250 + }, + { + "wall_s": 89.70834151597228, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 250099, + "evidence": 0 + }, + "min_ess": 1987.603654801205, + "logz": 103.00463997669563, + "logz_err": 0.39157194605562107, + "mean": [ + 1.987478516114519, + 1.004082456106899, + -4.627564535707644, + -4.664213998093018, + -4.7256261045178585, + -4.669647293244919, + -4.622239057549823, + -4.521443647125972, + -2.9596880529940464 + ], + "sd": [ + 0.13510770318760673, + 0.025524836452747623, + 1.0478193525454655, + 1.0411264223581356, + 1.0098166441106093, + 1.0168878253548586, + 1.0875770867779935, + 1.162194318390569, + 1.751075591424115 + ], + "mcse": [ + 0.003030506485521554, + 0.0005725297713374507, + 0.023502903747351298, + 0.023352779306913714, + 0.022650491548327396, + 0.022809100273924923, + 0.02439468170374224, + 0.026068368688262872, + 0.03927715305085612 + ], + "sampler": "dynesty", + "setting": "dynesty rslice 250", + "seed": 102, + "sample": "rslice", + "nlive": 250 + }, + { + "wall_s": 182.0591302079847, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 519385, + "evidence": 0 + }, + "min_ess": 4213.164701116909, + "logz": 102.75128305991362, + "logz_err": 0.2830834688142277, + "mean": [ + 1.983483363108581, + 1.00288185197747, + -4.7050603874830355, + -4.608544909090749, + -4.620131722082805, + -4.688397049534176, + -4.5079183350213965, + -4.547609527003879, + -2.7546487209063772 + ], + "sd": [ + 0.12559093261253743, + 0.025733896986881527, + 1.0472866851500515, + 1.1089378545847417, + 1.0616239614179488, + 1.0337891682602507, + 1.1671335172734814, + 1.1062838263431813, + 1.6935244746994882 + ], + "mcse": [ + 0.0019348801401173907, + 0.00039646179204161125, + 0.016134717419113435, + 0.017084528212558295, + 0.016355600491936174, + 0.01592677185467093, + 0.01798110274732031, + 0.017043639699119602, + 0.026090791785167974 + ], + "sampler": "dynesty", + "setting": "dynesty rslice 500", + "seed": 100, + "sample": "rslice", + "nlive": 500 + }, + { + "wall_s": 185.20441342692357, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 508726, + "evidence": 0 + }, + "min_ess": 4291.437516998859, + "logz": 102.74756623646088, + "logz_err": 0.27599165404015813, + "mean": [ + 1.9738785554103773, + 1.0020751697561556, + -4.592140674687335, + -4.62458996979158, + -4.649750090350991, + -4.592628903091976, + -4.628784897274323, + -4.609309534695094, + -2.813734937211096 + ], + "sd": [ + 0.13975646947326617, + 0.025634735482362832, + 1.091258988387172, + 1.1077929940122853, + 1.0768216840671854, + 1.1183925582051881, + 1.0859485232824762, + 1.0967742522315849, + 1.7389588584115223 + ], + "mcse": [ + 0.00213339132193042, + 0.0003913158541008798, + 0.016658137291090468, + 0.016910529929873554, + 0.016437750929983803, + 0.017072332945867092, + 0.016577072706298997, + 0.016742328141561815, + 0.026545316661987013 + ], + "sampler": "dynesty", + "setting": "dynesty rslice 500", + "seed": 101, + "sample": "rslice", + "nlive": 500 + }, + { + "wall_s": 178.85885525401682, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 522124, + "evidence": 0 + }, + "min_ess": 4236.799848526785, + "logz": 102.80133957787659, + "logz_err": 0.27357426513624417, + "mean": [ + 1.9730694732990612, + 1.003397194818426, + -4.744648552545356, + -4.739332641522288, + -4.627751365622674, + -4.700760637970112, + -4.695479748497482, + -4.65024857539509, + -2.8535750704780316 + ], + "sd": [ + 0.12605561151776848, + 0.026039316692319948, + 1.0080934879065022, + 1.013023849822358, + 1.069785109677819, + 1.044466505791791, + 1.0569344129114655, + 1.0524066177130222, + 1.7150922267827005 + ], + "mcse": [ + 0.0019366146356419114, + 0.0004000466238772188, + 0.015487518399764732, + 0.015563264421146035, + 0.01643529768686118, + 0.016046323501187655, + 0.01623787016153115, + 0.016168308843768964, + 0.02634926496227316 + ], + "sampler": "dynesty", + "setting": "dynesty rslice 500", + "seed": 102, + "sample": "rslice", + "nlive": 500 + }, + { + "wall_s": 146.2750993950758, + "calls": { + "search": 0, + "warmup": 36096, + "sampling": 35584, + "evidence": 4096 + }, + "min_ess": 4118.531392141875, + "logz": 102.7610653634819, + "logz_err": 0.044537840190031076, + "mean": [ + 1.9580067258503397, + 1.0018975791038671, + -4.589864682546934, + -4.521650145020765, + -4.509486166537767, + -4.435932186499563, + -4.514702052580689, + -4.4152938448013215, + -2.108771485627809 + ], + "sd": [ + 0.15943631228272742, + 0.02540957555108519, + 0.9915298571802732, + 1.0601335868430588, + 1.085802896329623, + 1.060940143469906, + 1.0753118264536294, + 1.1023602039316351, + 1.4925577141006916 + ], + "mcse": [ + 0.0024843687078358037, + 0.00039593712043818136, + 0.015450217800417849, + 0.016519214923938975, + 0.0169191992708366, + 0.016531782851634664, + 0.01675572530848467, + 0.017177198570390816, + 0.023257334709142104 + ], + "sampler": "pocomc", + "setting": "pocomc 512/256", + "seed": 100, + "n_effective": 512, + "n_active": 256 + }, + { + "wall_s": 162.56426696199924, + "calls": { + "search": 0, + "warmup": 30720, + "sampling": 28928, + "evidence": 4096 + }, + "min_ess": 4069.254497922273, + "logz": 102.67031610741469, + "logz_err": 0.10374103378878223, + "mean": [ + 1.9744536451949601, + 1.004268771454221, + -4.423150973993142, + -4.612509365549422, + -4.413495440597669, + -4.602053077457784, + -4.49507874424305, + -4.415472127382857, + -2.040946003873158 + ], + "sd": [ + 0.1636746830313235, + 0.026057925057120967, + 1.044133515250475, + 1.0611417030257548, + 1.0687758706205785, + 1.0471737931818992, + 1.0919870618566998, + 1.040855531638324, + 1.4094327281161343 + ], + "mcse": [ + 0.002565807571971717, + 0.0004084909173683089, + 0.01636811283188133, + 0.016634737676793833, + 0.01675441290486042, + 0.016415773031937152, + 0.01711827767077981, + 0.016316726294775607, + 0.02209463980017637 + ], + "sampler": "pocomc", + "setting": "pocomc 512/256", + "seed": 101, + "n_effective": 512, + "n_active": 256 + }, + { + "wall_s": 178.51217581995297, + "calls": { + "search": 0, + "warmup": 26112, + "sampling": 56320, + "evidence": 4096 + }, + "min_ess": 4196.1476060874575, + "logz": 103.18900600473226, + "logz_err": 0.24375060886749747, + "mean": [ + 1.9715951443768562, + 1.002734909723908, + -4.476116955848928, + -4.561523681270372, + -4.522225681093748, + -4.595522442640101, + -4.439150254885991, + -4.448643105499786, + -2.190885067296905 + ], + "sd": [ + 0.15366164195611173, + 0.02584888088249777, + 1.0252743510997002, + 1.0775090144030965, + 1.1225627606862731, + 1.0488114837502303, + 1.064566993787294, + 1.0612684641030237, + 1.5085700388978731 + ], + "mcse": [ + 0.002372138767334928, + 0.0003990399403066956, + 0.015827587187259178, + 0.016633955440541696, + 0.017329468886913172, + 0.016190939707260064, + 0.016434164077911574, + 0.016383243301329627, + 0.023288424013663045 + ], + "sampler": "pocomc", + "setting": "pocomc 512/256", + "seed": 102, + "n_effective": 512, + "n_active": 256 + }, + { + "wall_s": 137.58785951393656, + "calls": { + "search": 0, + "warmup": 71680, + "sampling": 14336, + "evidence": 4096 + }, + "min_ess": 4279.187269670499, + "logz": 102.8032604725658, + "logz_err": 0.023472259460433277, + "mean": [ + 1.9675434889467673, + 1.003932298596809, + -4.599012840677852, + -4.631601984868476, + -4.640868245768982, + -4.5815325970114955, + -4.639818124118522, + -4.60398271298903, + -2.6870883320226273 + ], + "sd": [ + 0.13663027815110204, + 0.025573061507027862, + 1.023664953910807, + 1.057125209994795, + 1.0642496431014656, + 1.0775562060489416, + 1.055553297647299, + 1.05420640490398, + 1.6753915111930988 + ], + "mcse": [ + 0.0020886530572604817, + 0.00039093276997572487, + 0.015648661223039245, + 0.01616016472806213, + 0.01626907520669732, + 0.016472491270530097, + 0.016136135065129644, + 0.01611554525382132, + 0.025611538301135335 + ], + "sampler": "pocomc", + "setting": "pocomc 1024/512", + "seed": 100, + "n_effective": 1024, + "n_active": 512 + }, + { + "wall_s": 126.86267836298794, + "calls": { + "search": 0, + "warmup": 50688, + "sampling": 23552, + "evidence": 4096 + }, + "min_ess": 4251.55277248858, + "logz": 102.85673437469788, + "logz_err": 0.060428054488579075, + "mean": [ + 1.969509829788818, + 1.0023479406686933, + -4.575054308832494, + -4.591831728330616, + -4.528380180388163, + -4.591922484418022, + -4.557542706778456, + -4.587050179071464, + -2.3731790224661853 + ], + "sd": [ + 0.13828578784920773, + 0.0254204498271989, + 1.032666196119018, + 1.0528448586016668, + 1.1022120596363414, + 1.0669215627393067, + 1.042131146615402, + 1.0430378195684813, + 1.5050101433287908 + ], + "mcse": [ + 0.0021208197606118156, + 0.0003898606874623488, + 0.01583748343852385, + 0.016146953462895287, + 0.01690407346133361, + 0.016362840813025203, + 0.01598264263642951, + 0.01599654782470092, + 0.02308158561726853 + ], + "sampler": "pocomc", + "setting": "pocomc 1024/512", + "seed": 101, + "n_effective": 1024, + "n_active": 512 + }, + { + "wall_s": 132.2072902600048, + "calls": { + "search": 0, + "warmup": 66560, + "sampling": 24576, + "evidence": 4096 + }, + "min_ess": 4284.869514950464, + "logz": 102.70235906057306, + "logz_err": 0.04022333086319149, + "mean": [ + 1.965921686343233, + 1.0019178890082192, + -4.618194683478484, + -4.562206809125744, + -4.609570451854811, + -4.68839558948692, + -4.572834500589567, + -4.5581062930525, + -2.2336315155728697 + ], + "sd": [ + 0.15593076147298168, + 0.025356895493366647, + 1.045651792327711, + 1.0629689091681416, + 1.0701149966507375, + 1.028131533372372, + 1.088371300410333, + 1.0983726397110092, + 1.504593301538549 + ], + "mcse": [ + 0.0023821165102552947, + 0.00038737115648622596, + 0.015974169400266004, + 0.016238718803770053, + 0.01634788785300201, + 0.01570651664382966, + 0.01662678498780183, + 0.01677957302813301, + 0.02298530777992465 + ], + "sampler": "pocomc", + "setting": "pocomc 1024/512", + "seed": 102, + "n_effective": 1024, + "n_active": 512 + }, + { + "wall_s": 172.11443201696966, + "calls": { + "search": 0, + "warmup": 120832, + "sampling": 16384, + "evidence": 4096 + }, + "min_ess": 5081.3339227779725, + "logz": 102.85423224354182, + "logz_err": 0.026371705379028092, + "mean": [ + 1.9782872420292381, + 1.002939231007228, + -4.639122710872615, + -4.61131440112952, + -4.622693724771879, + -4.6169606680618385, + -4.618817584219522, + -4.618994752223562, + -2.8005090012351 + ], + "sd": [ + 0.12939311865286515, + 0.026002869412998952, + 1.054712499330981, + 1.0811005969788048, + 1.068939236936365, + 1.062227809838132, + 1.0699524256250632, + 1.0386080967657225, + 1.7167818381933961 + ], + "mcse": [ + 0.0018151909287875197, + 0.00036478116589453574, + 0.014796030741021303, + 0.015166216079909324, + 0.014995610481554601, + 0.014901459249133853, + 0.015009823995658153, + 0.014570110183928736, + 0.024083868229161132 + ], + "sampler": "pocomc", + "setting": "pocomc 2048/1024", + "seed": 100, + "n_effective": 2048, + "n_active": 1024 + }, + { + "wall_s": 147.9441037880024, + "calls": { + "search": 0, + "warmup": 90112, + "sampling": 4096, + "evidence": 4096 + }, + "min_ess": 4801.661413177842, + "logz": 102.81068383137543, + "logz_err": 0.03295716603070791, + "mean": [ + 1.9772086814139722, + 1.0024047110336798, + -4.654222023869904, + -4.662722445773021, + -4.505214621066947, + -4.576061439198491, + -4.617699513668963, + -4.5494911922922405, + -2.677161828924589 + ], + "sd": [ + 0.12578418303712477, + 0.025285389027426605, + 1.045669234122866, + 1.0535051612491544, + 1.1017717937114064, + 1.06124902243897, + 1.0288540847430905, + 1.0502157056669215, + 1.6331499022778877 + ], + "mcse": [ + 0.0018152241758606308, + 0.00036490000849374735, + 0.01509032398114214, + 0.015203406278267868, + 0.015899954572475894, + 0.01531515994798096, + 0.014847660198320834, + 0.015155935291422673, + 0.02356840990527622 + ], + "sampler": "pocomc", + "setting": "pocomc 2048/1024", + "seed": 101, + "n_effective": 2048, + "n_active": 1024 + }, + { + "wall_s": 173.67949237395078, + "calls": { + "search": 0, + "warmup": 143360, + "sampling": 19456, + "evidence": 4096 + }, + "min_ess": 5105.118427391755, + "logz": 102.80198811763502, + "logz_err": 0.029649914399326367, + "mean": [ + 1.9729184953708936, + 1.0032824767926876, + -4.575414318045652, + -4.557771180776811, + -4.640038919209219, + -4.596798497496228, + -4.648318743376063, + -4.600460851976112, + -2.655299631348325 + ], + "sd": [ + 0.13598113796098682, + 0.025751414701815717, + 1.0614722454031573, + 1.1157402057348742, + 1.056024690658009, + 1.0478799328952484, + 1.066215521844294, + 1.0653443545535588, + 1.6111857566725354 + ], + "mcse": [ + 0.0019031620131272292, + 0.0003604111200984545, + 0.014856131414488811, + 0.015615653817241833, + 0.014779888639859497, + 0.014665896406725984, + 0.014922517265319993, + 0.014910324600074893, + 0.022549800466227603 + ], + "sampler": "pocomc", + "setting": "pocomc 2048/1024", + "seed": 102, + "n_effective": 2048, + "n_active": 1024 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep_n40ca_gp.json b/benchmarks/results/hpc/sweep_n40ca_gp.json new file mode 100644 index 0000000..9045466 --- /dev/null +++ b/benchmarks/results/hpc/sweep_n40ca_gp.json @@ -0,0 +1,392 @@ +{ + "problem": "n40ca_gp", + "names": [ + "Vv", + "Wv", + "Rv", + "av", + "log_ell_xs", + "log_A_xs", + "amp_slope_xs" + ], + "runs": [ + { + "wall_s": 144.62501071300358, + "calls": { + "search": 0, + "warmup": 84992, + "sampling": 22528, + "evidence": 4096 + }, + "min_ess": 4332.052254001436, + "logz": -11.334152805309108, + "logz_err": 0.020615190979930823, + "mean": [ + 44.07242451129369, + 13.583469191124076, + 4.27591913780138, + 0.4908616277930356, + -1.2704082741826692, + -1.710931465968952, + 2.118485597419149 + ], + "sd": [ + 1.6357966781673174, + 1.1096866010671849, + 0.0741865725783155, + 0.02601403891181752, + 0.20323989653433908, + 0.49141466509402276, + 0.6730151572043326 + ], + "mcse": [ + 0.024853209382453813, + 0.01685984194326949, + 0.0011271415612123471, + 0.0003952400469984151, + 0.003087892138951709, + 0.007466228369453221, + 0.01022534575525863 + ], + "n_effective": 1024, + "n_active": 512, + "seed": 100 + }, + { + "wall_s": 149.79632453306112, + "calls": { + "search": 0, + "warmup": 77824, + "sampling": 23040, + "evidence": 4096 + }, + "min_ess": 4335.952729357508, + "logz": -11.398904825051748, + "logz_err": 0.017611947817528912, + "mean": [ + 44.21226150401244, + 13.563336566872927, + 4.268126768085496, + 0.49252309593606325, + -1.2560328078549865, + -1.637601849283182, + 2.0469911610409826 + ], + "sd": [ + 1.7137990557106195, + 1.1851253531230042, + 0.08017584544299226, + 0.026140668963201406, + 0.19659512437094367, + 0.5032650740298302, + 0.6520260709973993 + ], + "mcse": [ + 0.026026611522126392, + 0.017997907670666575, + 0.0012175905779908155, + 0.00039698530219556223, + 0.0029855921043351573, + 0.007642835681804844, + 0.009901994749968609 + ], + "n_effective": 1024, + "n_active": 512, + "seed": 101 + }, + { + "wall_s": 128.79138583992608, + "calls": { + "search": 0, + "warmup": 66560, + "sampling": 13824, + "evidence": 4096 + }, + "min_ess": 4168.453692176353, + "logz": -11.324409412555383, + "logz_err": 0.01846495757676833, + "mean": [ + 43.87613991272912, + 13.634817283354176, + 4.28522719261365, + 0.48768678358110473, + -1.2622397834909884, + -1.759431820629838, + 2.190040322224494 + ], + "sd": [ + 1.492237526125855, + 1.039286385309068, + 0.06707506603581977, + 0.023279842414646628, + 0.19567623961784306, + 0.4627399226507841, + 0.6460563092970016 + ], + "mcse": [ + 0.023112688524719944, + 0.016097103906770847, + 0.0010388996938615878, + 0.00036057245392508104, + 0.0030307534147846083, + 0.007167199264816334, + 0.010006515708647551 + ], + "n_effective": 1024, + "n_active": 512, + "seed": 102 + }, + { + "wall_s": 206.17314592108596, + "calls": { + "search": 0, + "warmup": 174080, + "sampling": 9216, + "evidence": 4096 + }, + "min_ess": 5181.220041187816, + "logz": -11.347361814647424, + "logz_err": 0.010227041435954454, + "mean": [ + 43.684128713345686, + 13.723107625344054, + 4.294165169994603, + 0.48574506288216346, + -1.270152269965843, + -1.778247750586169, + 2.207053313620734 + ], + "sd": [ + 1.5753694821189324, + 1.0720079956027586, + 0.07095148584099692, + 0.024388074081700985, + 0.20593173078447816, + 0.48329807835145905, + 0.6627225470334341 + ], + "mcse": [ + 0.021886000748912827, + 0.014892993714112873, + 0.0009857016337296957, + 0.000338814109118532, + 0.002860930128030591, + 0.006714273841664795, + 0.00920694879856772 + ], + "n_effective": 2048, + "n_active": 1024, + "seed": 100 + }, + { + "wall_s": 189.51980330608785, + "calls": { + "search": 0, + "warmup": 154624, + "sampling": 0, + "evidence": 4096 + }, + "min_ess": 4098.462571848329, + "logz": -11.397021611328839, + "logz_err": 0.023419433045406716, + "mean": [ + 44.09627089988894, + 13.657928371175595, + 4.275116339257853, + 0.4914576572145512, + -1.280358979729719, + -1.7027815704796987, + 2.083496298359686 + ], + "sd": [ + 1.531350304380624, + 1.1004539753142195, + 0.06790282419867609, + 0.02371524499398422, + 0.20236621170281516, + 0.46737183114175335, + 0.6492780157271696 + ], + "mcse": [ + 0.023920159021177737, + 0.017189426880122018, + 0.0010606628334307588, + 0.000370439363129087, + 0.0031610219755711082, + 0.007300490613381579, + 0.010141920722332895 + ], + "n_effective": 2048, + "n_active": 1024, + "seed": 101 + }, + { + "wall_s": 199.04840506997425, + "calls": { + "search": 0, + "warmup": 176128, + "sampling": 0, + "evidence": 4096 + }, + "min_ess": 4094.345297579111, + "logz": -11.359706526848722, + "logz_err": 0.01571045863766961, + "mean": [ + 43.80914340496279, + 13.70492276919293, + 4.2878473931625525, + 0.4878704916872498, + -1.2795490636821587, + -1.7660092237564844, + 2.176793366002216 + ], + "sd": [ + 1.649760062025042, + 1.0771726504697405, + 0.06972420009465033, + 0.02508471557250889, + 0.20681973740323661, + 0.48121611657892105, + 0.6665927260534057 + ], + "mcse": [ + 0.025782709345748153, + 0.016834223352552538, + 0.0010896607493325705, + 0.00039202787454612414, + 0.0032322113373785054, + 0.0075205210453540795, + 0.01041761581179797 + ], + "n_effective": 2048, + "n_active": 1024, + "seed": 102 + }, + { + "wall_s": 305.0943130510859, + "calls": { + "search": 0, + "warmup": 231424, + "sampling": 0, + "evidence": 4096 + }, + "min_ess": 7436.020244564779, + "logz": -11.359356555634282, + "logz_err": 0.014559620006617511, + "mean": [ + 43.76488178944507, + 13.676440288282677, + 4.289739939344295, + 0.48677371812606024, + -1.2708667992709894, + -1.7645719099821093, + 2.1881415623638505 + ], + "sd": [ + 1.6196365672573416, + 1.0674141261303545, + 0.06891813930889269, + 0.02573543726774675, + 0.20728480236867544, + 0.47595686583245006, + 0.6637111858068505 + ], + "mcse": [ + 0.018782235937286264, + 0.012378347318819883, + 0.0007992143293296701, + 0.00029844291273972413, + 0.0024037936306260366, + 0.005519469201151959, + 0.007696776139816314 + ], + "n_effective": 4096, + "n_active": 2048, + "seed": 100 + }, + { + "wall_s": 321.5998195960419, + "calls": { + "search": 0, + "warmup": 268288, + "sampling": 0, + "evidence": 4096 + }, + "min_ess": 7244.266595536664, + "logz": -11.350569564305953, + "logz_err": 0.009763644989937112, + "mean": [ + 43.63301314762665, + 13.70660323474642, + 4.2960141161956535, + 0.48474994831914114, + -1.276357169229324, + -1.806230095820826, + 2.2386251192947175 + ], + "sd": [ + 1.5936494293678745, + 1.0523112713488407, + 0.07050181123390262, + 0.02459668491126154, + 0.20643825136666138, + 0.47809207319892033, + 0.6653928604930763 + ], + "mcse": [ + 0.018723868371593507, + 0.012363658761823982, + 0.0008283293735599887, + 0.00028898770467900063, + 0.0024254535371587287, + 0.00561712813565877, + 0.007817734632021442 + ], + "n_effective": 4096, + "n_active": 2048, + "seed": 101 + }, + { + "wall_s": 337.5938152529998, + "calls": { + "search": 0, + "warmup": 253952, + "sampling": 0, + "evidence": 4096 + }, + "min_ess": 7248.995329158626, + "logz": -11.342750601935213, + "logz_err": 0.01140104711549229, + "mean": [ + 43.755073027919046, + 13.695946575771991, + 4.290441203780875, + 0.4865775545266369, + -1.274599878027347, + -1.7727917897941912, + 2.186078862668791 + ], + "sd": [ + 1.55116046980391, + 1.064813687391233, + 0.06903765249871367, + 0.024349169759182106, + 0.203660801195424, + 0.48182263971959755, + 0.6716192958022217 + ], + "mcse": [ + 0.01821871820741622, + 0.012506469118848198, + 0.0008108622937861424, + 0.00028598631222413664, + 0.002392040552287348, + 0.005659112045393004, + 0.007888315187938496 + ], + "n_effective": 4096, + "n_active": 2048, + "seed": 102 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/hpc/sweep_omp.json b/benchmarks/results/hpc/sweep_omp.json new file mode 100644 index 0000000..a6115aa --- /dev/null +++ b/benchmarks/results/hpc/sweep_omp.json @@ -0,0 +1,466 @@ +{ + "problem": "omp", + "names": [ + "Vv", + "Wv", + "Rv", + "av", + "Wd", + "Rd", + "ad", + "log_sigma_A", + "log_sigma_B" + ], + "runs": [ + { + "wall_s": 263.87480871006846, + "calls": { + "search": 0, + "warmup": 58368, + "sampling": 18432, + "evidence": 4096 + }, + "min_ess": 4512.851477618101, + "logz": -8.86339171024635, + "logz_err": 0.027007687553196737, + "mean": [ + 42.05108749026544, + 3.7522967272486536, + 4.17134166846228, + 0.7097420091423998, + 6.752520250027441, + 4.232022418366619, + 0.4390428928064158, + -1.528808289934837, + -1.7062885944941968 + ], + "sd": [ + 2.3422696646009387, + 1.4783296108721302, + 0.14873656703550608, + 0.03392150773446276, + 1.308250379581879, + 0.17695541973772733, + 0.08696884721975551, + 0.12055829079587317, + 0.8156678355650312 + ], + "mcse": [ + 0.034866742423085816, + 0.022006235463704, + 0.0022140745150300953, + 0.0005049514539914144, + 0.019474456634589563, + 0.002634136937181209, + 0.0012946077220192945, + 0.0017946161091845713, + 0.012141932568762203 + ], + "mode_share": 0.8233203987760397, + "mode_share_label": "share away from the MAP island", + "n_effective": 1024, + "n_active": 512, + "seed": 100 + }, + { + "wall_s": 348.1126649630023, + "calls": { + "search": 0, + "warmup": 98304, + "sampling": 23552, + "evidence": 4096 + }, + "min_ess": 4208.950918969597, + "logz": -6.671232887748438, + "logz_err": 0.039477240756340425, + "mean": [ + 45.123227156969925, + 3.2763360204856493, + 4.0003892337761195, + 0.775604199843696, + 8.803657306227587, + 4.387075176415484, + 0.3398931229624953, + -1.605169397318233, + -1.7706435452572307 + ], + "sd": [ + 2.62260272977306, + 1.261987904161631, + 0.14144193860586404, + 0.04847113904041719, + 1.4011647787882244, + 0.13116266693175133, + 0.07323270905111395, + 0.12633753113884372, + 0.7985881878384136 + ], + "mcse": [ + 0.04042458575232878, + 0.019452179192461228, + 0.002180174569040864, + 0.0007471302055809077, + 0.021597440249049346, + 0.0020217307092277497, + 0.0011288030372668264, + 0.0019473564574919926, + 0.01230937355230477 + ], + "mode_share": 0.22741141956348374, + "mode_share_label": "share away from the MAP island", + "n_effective": 1024, + "n_active": 512, + "seed": 101 + }, + { + "wall_s": 230.89461113407742, + "calls": { + "search": 0, + "warmup": 59392, + "sampling": 12800, + "evidence": 4096 + }, + "min_ess": 4092.3152852602, + "logz": -8.814071353085664, + "logz_err": 0.04072728272355799, + "mean": [ + 41.779272497407824, + 3.8553100634224453, + 4.197072312490713, + 0.7114928693541048, + 6.926695103462257, + 4.206432747250137, + 0.42233412309358787, + -1.5382402141603864, + -1.7633457692453933 + ], + "sd": [ + 1.964613594413729, + 1.5540673916378178, + 0.10433841582331135, + 0.033556230623413244, + 1.2332136468361923, + 0.13737486640262256, + 0.0772802934677644, + 0.11765754650295118, + 0.8156270622029332 + ], + "mcse": [ + 0.030710904109744152, + 0.024293232409863093, + 0.0016310215364607346, + 0.00052455209710978, + 0.019277636153238624, + 0.002147448414882236, + 0.001208048080808299, + 0.0018392266238584092, + 0.012749908973373214 + ], + "mode_share": 0.8524985697418922, + "mode_share_label": "share away from the MAP island", + "n_effective": 1024, + "n_active": 512, + "seed": 102 + }, + { + "wall_s": 476.7943695569411, + "calls": { + "search": 0, + "warmup": 163840, + "sampling": 16384, + "evidence": 4096 + }, + "min_ess": 4549.36435442321, + "logz": -6.617389263759373, + "logz_err": 0.04692940849065874, + "mean": [ + 45.4103146761612, + 3.3391967018991346, + 3.9850407875073217, + 0.78371602437486, + 9.007296498957793, + 4.402795200779112, + 0.32546860590794635, + -1.6125038996586176, + -1.8132992575084443 + ], + "sd": [ + 2.499931628763858, + 1.249075384548825, + 0.13069248701993835, + 0.04602662157865416, + 1.2336277902033295, + 0.11496889907246997, + 0.06364249582312397, + 0.11897032258842154, + 0.8383635074215807 + ], + "mcse": [ + 0.037064041287204016, + 0.018518819111320965, + 0.0019376496857354377, + 0.0006823917033864187, + 0.018289792737950693, + 0.0017045314251547998, + 0.0009435650422069168, + 0.0017638566181706393, + 0.01242959579183507 + ], + "mode_share": 0.16884666003203835, + "mode_share_label": "share away from the MAP island", + "n_effective": 2048, + "n_active": 1024, + "seed": 100 + }, + { + "wall_s": 405.97872379701585, + "calls": { + "search": 0, + "warmup": 143360, + "sampling": 0, + "evidence": 4096 + }, + "min_ess": 4392.159539590856, + "logz": -6.6939520959513406, + "logz_err": 0.07501363082424031, + "mean": [ + 45.2905660985585, + 3.2954964751022637, + 3.990282811417834, + 0.7797358735463686, + 8.868049800542815, + 4.395737897550481, + 0.33522224468859635, + -1.6056648432703051, + -1.6615762927037627 + ], + "sd": [ + 2.6053059376094114, + 1.2798772349110987, + 0.14006259336707552, + 0.0480098152677036, + 1.3532354993439129, + 0.12532980871827645, + 0.07217373811481971, + 0.12071845735393888, + 0.7833248569834879 + ], + "mcse": [ + 0.03931150546549025, + 0.019312089297862448, + 0.0021134068460738295, + 0.0007244209165796857, + 0.020418993393676855, + 0.0018911036087140777, + 0.0010890307581185729, + 0.0018215228497922326, + 0.011819602048278657 + ], + "mode_share": 0.20493082490192527, + "mode_share_label": "share away from the MAP island", + "n_effective": 2048, + "n_active": 1024, + "seed": 101 + }, + { + "wall_s": 448.97729953494854, + "calls": { + "search": 0, + "warmup": 155648, + "sampling": 11264, + "evidence": 4096 + }, + "min_ess": 4599.97272350572, + "logz": -6.684693775435266, + "logz_err": 0.01978567993538673, + "mean": [ + 45.49188171113266, + 3.2887171188295388, + 3.9757121772928463, + 0.7862788382712822, + 8.995464578553326, + 4.412448648575912, + 0.3244439086271585, + -1.626317572577889, + -1.864788321181459 + ], + "sd": [ + 2.4289286187049144, + 1.2547034266579047, + 0.1287251838758626, + 0.04533315530537782, + 1.1875053918062863, + 0.11176155306667206, + 0.06160219222673534, + 0.11836452396392895, + 0.8315489934455609 + ], + "mcse": [ + 0.03581270486921253, + 0.01849964761057812, + 0.0018979549188396473, + 0.0006684028913979822, + 0.01750886370223288, + 0.0016478390862863864, + 0.0009082774654320092, + 0.001745194869483319, + 0.012260557373824796 + ], + "mode_share": 0.14641190953835315, + "mode_share_label": "share away from the MAP island", + "n_effective": 2048, + "n_active": 1024, + "seed": 102 + }, + { + "wall_s": 841.4690177430166, + "calls": { + "search": 0, + "warmup": 317440, + "sampling": 0, + "evidence": 4096 + }, + "min_ess": 7316.152205892808, + "logz": -6.66309700327866, + "logz_err": 0.03648714379591066, + "mean": [ + 45.415020084770724, + 3.3092064063533577, + 3.9815837347550396, + 0.7836091212261396, + 8.906496365933606, + 4.407169361733292, + 0.32934479049798404, + -1.6164334629638715, + -1.8900977100035607 + ], + "sd": [ + 2.55400359570628, + 1.2648927491617075, + 0.13560376794344578, + 0.046833112238850505, + 1.302973751583771, + 0.12130326028619139, + 0.06739233572041435, + 0.12001424110898187, + 0.8298230641766933 + ], + "mcse": [ + 0.02985933548635418, + 0.014788098581760894, + 0.0015853691071712659, + 0.0005475347069052204, + 0.015233310729812948, + 0.0014181791875951923, + 0.0007878964480973594, + 0.0014031090224140036, + 0.00970161722137836 + ], + "mode_share": 0.16387110537427135, + "mode_share_label": "share away from the MAP island", + "n_effective": 4096, + "n_active": 2048, + "seed": 100 + }, + { + "wall_s": 889.2742078829324, + "calls": { + "search": 0, + "warmup": 360448, + "sampling": 0, + "evidence": 4096 + }, + "min_ess": 6805.041721355122, + "logz": -6.642639607659658, + "logz_err": 0.0268872199841963, + "mean": [ + 45.69867165455911, + 3.324744944734124, + 3.9678173973317303, + 0.7881502937683748, + 9.032487295004163, + 4.4082531918156445, + 0.3254306009743239, + -1.6258841927822651, + -1.8171773370099056 + ], + "sd": [ + 2.5505644412691253, + 1.2679488189430386, + 0.13394673076797906, + 0.046551358469489566, + 1.1965254275920538, + 0.11094728055671099, + 0.06286579791996326, + 0.12118003841870806, + 0.8546770453860644 + ], + "mcse": [ + 0.030918677160323517, + 0.015370440971570311, + 0.001623740870171932, + 0.0005643089822017831, + 0.014504626039336051, + 0.0013449349068953124, + 0.0007620773185978826, + 0.0014689793465007754, + 0.01036064143883459 + ], + "mode_share": 0.15165694144522446, + "mode_share_label": "share away from the MAP island", + "n_effective": 4096, + "n_active": 2048, + "seed": 101 + }, + { + "wall_s": 824.2170109839644, + "calls": { + "search": 0, + "warmup": 327680, + "sampling": 0, + "evidence": 4096 + }, + "min_ess": 6888.773445352978, + "logz": -6.688901760708451, + "logz_err": 0.017633137038440362, + "mean": [ + 45.77825820360296, + 3.3846103855522496, + 3.9619471571943436, + 0.7907733086609615, + 9.01528723419832, + 4.413032663526841, + 0.32360524607951857, + -1.63069320879831, + -1.8477578464025821 + ], + "sd": [ + 2.5182164025056473, + 1.2498204024013653, + 0.13238026540469466, + 0.04648555097983795, + 1.1954407216137652, + 0.11175886759831885, + 0.06277096806197893, + 0.1213511102664614, + 0.8370990634389822 + ], + "mcse": [ + 0.03034045555549794, + 0.015058324746706568, + 0.0015949691833234546, + 0.0005600760888036684, + 0.014403137096266092, + 0.0013465145219154644, + 0.0007562891595674855, + 0.0014620856110644151, + 0.010085696727472743 + ], + "mode_share": 0.14014277469637912, + "mode_share_label": "share away from the MAP island", + "n_effective": 4096, + "n_active": 2048, + "seed": 102 + } + ] +} \ No newline at end of file diff --git a/benchmarks/results/jax-jitr4.json b/benchmarks/results/jax-jitr4.json new file mode 100644 index 0000000..c3498a3 --- /dev/null +++ b/benchmarks/results/jax-jitr4.json @@ -0,0 +1,679 @@ +{ + "backend": "jax", + "rxmc": "0.1.0b1.dev3+g5cc80f2b7", + "python": "3.12.3", + "machine": "x86_64", + "processor": "x86_64", + "problems": { + "linear": { + "ndim": 2, + "names": [ + "m", + "b" + ], + "build_s": 0.3370785790029913, + "first_call_s": 0.06167102500330657, + "values": [ + -8019.891789430371, + -327561.4042753656, + -36551.64366423493, + -519.2350744245873, + -7985.287055473152, + -50984.42596746107, + -12560.666773105197, + -6918.22966809168 + ], + "thetas": [ + [ + 1.7517461362828193, + -3.06729089351764 + ], + [ + -8.697494433829668, + -10.657056603131993 + ], + [ + 4.450059264843312, + 6.789603544403578 + ], + [ + 1.3528066012552167, + 3.0564555296558287 + ], + [ + 0.5478524387039049, + 7.573366634505017 + ], + [ + 4.49837819018014, + -13.88776214065867 + ], + [ + 5.343648919023343, + -9.15263575570495 + ], + [ + 3.0588563004340257, + -4.660244629498544 + ] + ], + "log_posterior": { + "median": 9.791797492653131e-05, + "iqr": 1.1902593541890383e-06, + "n": 1960 + }, + "grad_first_call_s": 0.13547213497804478, + "grad": { + "median": 0.00010945447138510644, + "iqr": 1.5862606232985854e-06, + "n": 1752 + }, + "grad_method": "value_and_grad", + "batch": { + "1": { + "median": 8.789100684225559e-05, + "iqr": 1.7225102055817842e-06, + "n": 2143, + "theta_per_s": 11377.728347051172 + }, + "32": { + "median": 0.00010182950063608587, + "iqr": 2.106701140291989e-05, + "n": 120, + "theta_per_s": 314250.7799813367 + }, + "256": { + "median": 0.000242390000494197, + "iqr": 6.755396316293627e-05, + "n": 60, + "theta_per_s": 1056149.178918496 + } + }, + "emcee": { + "nwalkers": 32, + "steps": 500, + "wall_s": 1.8925493250135332 + } + }, + "modes": { + "ndim": 9, + "names": [ + "m", + "b", + "log_eta0", + "log_eta1", + "log_eta2", + "log_eta3", + "log_eta4", + "log_eta5", + "log_s" + ], + "build_s": 0.3324334360077046, + "first_call_s": 0.44335633097216487, + "values": [ + -8550.483572527375, + -27532.4694814895, + -2904.004272313598, + -9777.549484707095, + -7395.215524671726, + -11306.627119795376, + -74854.48518848616, + -4422.162080374845 + ], + "thetas": [ + [ + 1.7517461362828193, + -3.06729089351764, + -5.754158856382832, + -5.900834186828826, + -1.120378564798365, + -0.5234665363336699, + -2.360185345396921, + -1.6230206340960098, + -2.738250051207463 + ], + [ + 7.573366634505017, + 4.49837819018014, + -5.983568998979111, + -0.8555743404745844, + -5.798486548167213, + -1.6220673214203352, + -4.946066276384646, + -0.8209264659006807, + -2.75123267850545 + ], + [ + -2.626146627849628, + -0.9751181904431134, + -5.830081973127222, + -5.254300341002616, + -1.9762535118382178, + -2.1168629305544995, + -2.307689331112477, + -3.6979346744286996, + -0.016740385264734314 + ], + [ + 10.356577460718519, + 2.4162655379083544, + -2.097244342393102, + -1.8693196165743595, + -3.666471456125377, + -5.189420969865533, + -1.6710699588355098, + -2.8478740651456445, + -4.138548746646266 + ], + [ + -0.17756476642328936, + 6.119044431308362, + -0.3957389042625019, + -3.8532288197455786, + -2.5708210156214344, + -4.068783653544347, + -2.4341998188018192, + -3.9725326469572004, + -3.6502859968310326 + ], + [ + 6.13994235389932, + -3.74120183072457, + -2.2608771318837455, + -5.495907938505691, + -1.004135114079613, + -1.2774101550678996, + -4.563783342042287, + -0.7410946151357773, + -5.648591791168834 + ], + [ + -2.115419002658594, + -5.176177605728167, + -3.297963800104278, + -1.2220543782762343, + -4.616146746037515, + -5.687872193613543, + -3.572688961070831, + -4.808921732944468, + -5.455481726285269 + ], + [ + 1.0137193747181157, + -2.640771354216867, + -1.9680307322618438, + -4.80290733619072, + -0.34732133696101286, + -3.8093389905310286, + -5.367028322578623, + -2.2253510907617446, + -0.4370726815927952 + ] + ], + "log_posterior": { + "median": 0.00020427050185389817, + "iqr": 5.318380135577172e-05, + "n": 956 + }, + "grad_first_call_s": 1.275322353001684, + "grad": { + "median": 0.0003849764761980623, + "iqr": 6.605823000427336e-05, + "n": 508 + }, + "grad_method": "value_and_grad", + "batch": { + "1": { + "median": 0.00020215101540088654, + "iqr": 8.170097135007381e-05, + "n": 913, + "theta_per_s": 4946.796819283325 + }, + "32": { + "median": 0.0012086039932910353, + "iqr": 0.0002019575040321797, + "n": 120, + "theta_per_s": 26476.82795823289 + }, + "256": { + "median": 0.006206254009157419, + "iqr": 0.0006797059904783964, + "n": 31, + "theta_per_s": 41248.714542180875 + } + } + }, + "gp": { + "ndim": 4, + "names": [ + "m", + "b", + "discrepancy_k1__constant_value", + "discrepancy_k2__length_scale" + ], + "build_s": 0.4480789419612847, + "first_call_s": 0.20807403401704505, + "values": [ + -97837.40032172018, + -2742.231223517278, + -289.1538178750732, + -765.6621188878796, + -61811.51232121967, + -10172.420777258365, + 71.36436981333786, + 8.093004688093076 + ], + "thetas": [ + [ + 1.7517461362828193, + -3.06729089351764, + -11.426370664893275, + -2.9338894578858836 + ], + [ + 4.450059264843312, + 6.789603544403578, + -3.5070991392594824, + -0.0820137560640064 + ], + [ + 0.5478524387039049, + 7.573366634505017, + -0.5780502422985503, + -2.9890459993194076 + ], + [ + 5.343648919023343, + -9.15263575570495, + -1.7848237499807826, + -2.297377517589764 + ], + [ + 5.473567694543734, + 0.520578325294422, + -7.804033532476613, + -1.3092511152093662 + ], + [ + -9.530418686749139, + -5.7691904722888605, + -2.611258194289176, + -0.41124195370299965 + ], + [ + 1.4669126516823798, + -1.4791814423938718, + 1.9609391010489539, + 0.9233413551049203 + ], + [ + 2.4162655379083544, + 1.9328035654534945, + -2.361745772006838, + -1.4443143040835849 + ] + ], + "log_posterior": { + "median": 0.0002688595268409699, + "iqr": 7.161252142395824e-05, + "n": 742 + }, + "grad_first_call_s": 0.5728218809817918, + "grad": { + "median": 0.0011583374871406704, + "iqr": 0.00010740746802184731, + "n": 200 + }, + "grad_method": "value_and_grad", + "batch": { + "1": { + "median": 0.0002697105228435248, + "iqr": 5.3932759328745306e-05, + "n": 712, + "theta_per_s": 3707.678845664319 + }, + "32": { + "median": 0.004739578464068472, + "iqr": 0.000827605981612578, + "n": 40, + "theta_per_s": 6751.655288038227 + }, + "256": { + "median": 0.057709853048436344, + "iqr": 0.0015455200045835227, + "n": 4, + "theta_per_s": 4435.984263989325 + } + }, + "emcee": { + "nwalkers": 32, + "steps": 500, + "wall_s": 4.568462218972854 + } + }, + "gp500": { + "ndim": 4, + "names": [ + "m", + "b", + "discrepancy_k1__constant_value", + "discrepancy_k2__length_scale" + ], + "build_s": 0.17512583505595103, + "first_call_s": 0.21240012295311317, + "values": [ + -474769.8576942996, + -2600.2872422515347, + 14.71420026249504, + -441.6880122096346, + -101354.73750212124, + -10562.071539915289, + 410.73564776996363, + 340.0178894282743 + ], + "thetas": [ + [ + 1.7517461362828193, + -3.06729089351764, + -11.426370664893275, + -2.9338894578858836 + ], + [ + 4.450059264843312, + 6.789603544403578, + -3.5070991392594824, + -0.0820137560640064 + ], + [ + 0.5478524387039049, + 7.573366634505017, + -0.5780502422985503, + -2.9890459993194076 + ], + [ + 5.343648919023343, + -9.15263575570495, + -1.7848237499807826, + -2.297377517589764 + ], + [ + 5.473567694543734, + 0.520578325294422, + -7.804033532476613, + -1.3092511152093662 + ], + [ + -9.530418686749139, + -5.7691904722888605, + -2.611258194289176, + -0.41124195370299965 + ], + [ + 1.4669126516823798, + -1.4791814423938718, + 1.9609391010489539, + 0.9233413551049203 + ], + [ + 2.4162655379083544, + 1.9328035654534945, + -2.361745772006838, + -1.4443143040835849 + ] + ], + "log_posterior": { + "median": 0.00529245100915432, + "iqr": 0.0016868167294887826, + "n": 200 + }, + "grad_first_call_s": 0.6673716180375777, + "grad": { + "median": 0.032323260995326564, + "iqr": 0.005959002010058612, + "n": 200 + }, + "grad_method": "value_and_grad", + "batch": { + "1": { + "median": 0.006647953996434808, + "iqr": 0.002268129523145035, + "n": 200, + "theta_per_s": 150.42222021035104 + }, + "32": { + "median": 0.2623053260031156, + "iqr": 0.006888356772833504, + "n": 6, + "theta_per_s": 121.995235428883 + }, + "256": { + "median": 1.7463378820102662, + "iqr": 0.03157010150607675, + "n": 3, + "theta_per_s": 146.59247940341882 + } + } + }, + "elastic": { + "ndim": 5, + "names": [ + "Vv", + "Wv", + "Rv", + "av", + "log_c" + ], + "build_s": 1.7336852570297197, + "first_call_s": 0.9253108990378678, + "values": [ + 121.14477908651796, + -217.07435211201974, + -228.14433382203245, + -13673.65775664295, + -519.3536060859159, + -6371.417493223199, + -309.28703778633985, + -4884.5094363131975 + ], + "thetas": [ + [ + 50.19138699714327, + 2.8885069963470924, + 3.727178640204773, + 0.5049582906585587, + -1.120378564798365 + ], + [ + 54.60408923644355, + 5.246450430370259, + 4.292310399605348, + 0.6630874974396269, + -0.38956545727339087 + ], + [ + 53.05365686594452, + 1.0191695011910367, + 4.397295575802055, + 0.5100756725916393, + -1.6220673214203352 + ], + [ + 42.810489929640944, + 7.042252456449206, + 4.137973162910062, + 0.5899135671612155, + -3.4638766728140493 + ], + [ + 40.45311473832741, + 1.8699829354969477, + 4.243988821644184, + 0.6941568534722751, + -2.307689331112477 + ], + [ + 46.13884086819014, + 7.980469550524477, + 4.49860636656143, + 0.7056625953442084, + -2.097244342393102 + ], + [ + 51.01514768913504, + 3.7224499678537266, + 3.8044336963745025, + 0.7164465020582246, + -2.8478740651456445 + ], + [ + 44.96387000894329, + 4.400847511822524, + 4.423629389588867, + 0.780213054786875, + -3.8532288197455786 + ] + ], + "log_posterior": { + "median": 0.0026432820013724267, + "iqr": 0.000549271993804723, + "n": 200 + }, + "grad_first_call_s": 2.832550788007211, + "grad": { + "median": 0.005974242958473042, + "iqr": 0.0008694392308825627, + "n": 200 + }, + "grad_method": "value_and_grad", + "batch": { + "1": { + "median": 0.0027810829924419522, + "iqr": 0.0005913364730076864, + "n": 200, + "theta_per_s": 359.57215326463233 + }, + "32": { + "median": 0.09463775850599632, + "iqr": 0.011044991202652454, + "n": 6, + "theta_per_s": 338.13142349490937 + }, + "256": { + "median": 0.7726789449807256, + "iqr": 0.07552945701172575, + "n": 3, + "theta_per_s": 331.31483867000657 + } + }, + "emcee": { + "nwalkers": 32, + "steps": 500, + "wall_s": 45.3881356070051 + } + }, + "ias": { + "ndim": 4, + "names": [ + "Vv", + "Wv", + "Rv", + "av" + ], + "build_s": 2.186302444024477, + "first_call_s": 0.5200966330012307, + "values": [ + -14505.286848334667, + -1009.7120062470839, + -1314.6909246958232, + -38099.47606430648, + -362.804083327852, + -4259.486175897251, + -14589.415017011312, + -544.8414449121766 + ], + "thetas": [ + [ + 50.19138699714327, + 2.8885069963470924, + 3.9607183208879944, + 0.5049582906585587 + ], + [ + 53.012323827204355, + 7.389289040944052, + 4.454099053555138, + 0.7188489682951995 + ], + [ + 48.69799986344677, + 7.5455069665143775, + 4.636582541603595, + 0.5008215500510445 + ], + [ + 53.71846842540111, + 1.2350990271382505, + 4.561399010459811, + 0.5526966861807677 + ], + [ + 53.81086275759819, + 4.790228541743642, + 4.186394551659246, + 0.6268061663592975 + ], + [ + 40.45311473832741, + 1.8699829354969477, + 4.509911088835404, + 0.6941568534722751 + ], + [ + 49.84616178370006, + 3.685742879833184, + 4.794764821173129, + 0.7942506016328691 + ], + [ + 50.96867175169112, + 5.553214933874714, + 4.5254560314878605, + 0.6166764271937312 + ] + ], + "log_posterior": { + "median": 0.0021284190006554127, + "iqr": 0.0003097807493759319, + "n": 200 + }, + "grad_first_call_s": 1.8105040760128759, + "grad": { + "median": 0.004114198993192986, + "iqr": 0.0005495935183716938, + "n": 200 + }, + "grad_method": "value_and_grad", + "batch": { + "1": { + "median": 0.00204990099882707, + "iqr": 0.0002250777615699917, + "n": 200, + "theta_per_s": 487.82843687192144 + }, + "32": { + "median": 0.070194176514633, + "iqr": 0.0067913990205852315, + "n": 6, + "theta_per_s": 455.8782735107539 + }, + "256": { + "median": 0.5689912190428004, + "iqr": 0.0046437319833785295, + "n": 3, + "theta_per_s": 449.9190698068458 + } + } + } + }, + "jitr": "3.0.2.dev42+g4eb3261ad" +} \ No newline at end of file diff --git a/benchmarks/results/numpy-jitr3.json b/benchmarks/results/numpy-jitr3.json new file mode 100644 index 0000000..64a96f3 --- /dev/null +++ b/benchmarks/results/numpy-jitr3.json @@ -0,0 +1,673 @@ +{ + "backend": "numpy", + "rxmc": "0.1.0b1.dev3+g5cc80f2b7", + "python": "3.12.3", + "machine": "x86_64", + "processor": "x86_64", + "problems": { + "linear": { + "ndim": 2, + "names": [ + "m", + "b" + ], + "build_s": 0.0021039629937149584, + "first_call_s": 0.00033241999335587025, + "values": [ + -8019.891789430369, + -327561.4042753656, + -36551.64366423493, + -519.2350744245874, + -7985.287055473151, + -50984.425967461066, + -12560.666773105197, + -6918.229668091679 + ], + "thetas": [ + [ + 1.7517461362828193, + -3.06729089351764 + ], + [ + -8.697494433829668, + -10.657056603131993 + ], + [ + 4.450059264843312, + 6.789603544403578 + ], + [ + 1.3528066012552167, + 3.0564555296558287 + ], + [ + 0.5478524387039049, + 7.573366634505017 + ], + [ + 4.49837819018014, + -13.88776214065867 + ], + [ + 5.343648919023343, + -9.15263575570495 + ], + [ + 3.0588563004340257, + -4.660244629498544 + ] + ], + "log_posterior": { + "median": 0.0001582810073159635, + "iqr": 5.425012204796076e-06, + "n": 1191 + }, + "grad": { + "median": 0.0006600165215786546, + "iqr": 4.1362232877872884e-05, + "n": 298 + }, + "grad_method": "central finite difference", + "batch": { + "1": { + "median": 0.00016045401571318507, + "iqr": 4.662491846829653e-06, + "n": 1195, + "theta_per_s": 6232.315193578707 + }, + "32": { + "median": 0.005129455006681383, + "iqr": 0.0002028129529207945, + "n": 39, + "theta_per_s": 6238.47951845144 + }, + "256": { + "median": 0.041558230004739016, + "iqr": 0.0012720749946311116, + "n": 5, + "theta_per_s": 6160.031357707186 + } + }, + "emcee": { + "nwalkers": 32, + "steps": 500, + "wall_s": 2.86937139503425 + } + }, + "modes": { + "ndim": 9, + "names": [ + "m", + "b", + "log_eta0", + "log_eta1", + "log_eta2", + "log_eta3", + "log_eta4", + "log_eta5", + "log_s" + ], + "build_s": 0.0032332679838873446, + "first_call_s": 0.001314739987719804, + "values": [ + -8550.483572527273, + -27532.46948148927, + -2904.0042723137726, + -9777.54948470756, + -7395.215524671729, + -11306.627119795383, + -74854.48518848604, + -4422.162080374816 + ], + "thetas": [ + [ + 1.7517461362828193, + -3.06729089351764, + -5.754158856382832, + -5.900834186828826, + -1.120378564798365, + -0.5234665363336699, + -2.360185345396921, + -1.6230206340960098, + -2.738250051207463 + ], + [ + 7.573366634505017, + 4.49837819018014, + -5.983568998979111, + -0.8555743404745844, + -5.798486548167213, + -1.6220673214203352, + -4.946066276384646, + -0.8209264659006807, + -2.75123267850545 + ], + [ + -2.626146627849628, + -0.9751181904431134, + -5.830081973127222, + -5.254300341002616, + -1.9762535118382178, + -2.1168629305544995, + -2.307689331112477, + -3.6979346744286996, + -0.016740385264734314 + ], + [ + 10.356577460718519, + 2.4162655379083544, + -2.097244342393102, + -1.8693196165743595, + -3.666471456125377, + -5.189420969865533, + -1.6710699588355098, + -2.8478740651456445, + -4.138548746646266 + ], + [ + -0.17756476642328936, + 6.119044431308362, + -0.3957389042625019, + -3.8532288197455786, + -2.5708210156214344, + -4.068783653544347, + -2.4341998188018192, + -3.9725326469572004, + -3.6502859968310326 + ], + [ + 6.13994235389932, + -3.74120183072457, + -2.2608771318837455, + -5.495907938505691, + -1.004135114079613, + -1.2774101550678996, + -4.563783342042287, + -0.7410946151357773, + -5.648591791168834 + ], + [ + -2.115419002658594, + -5.176177605728167, + -3.297963800104278, + -1.2220543782762343, + -4.616146746037515, + -5.687872193613543, + -3.572688961070831, + -4.808921732944468, + -5.455481726285269 + ], + [ + 1.0137193747181157, + -2.640771354216867, + -1.9680307322618438, + -4.80290733619072, + -0.34732133696101286, + -3.8093389905310286, + -5.367028322578623, + -2.2253510907617446, + -0.4370726815927952 + ] + ], + "log_posterior": { + "median": 0.001375571999233216, + "iqr": 0.0012556850124383345, + "n": 200 + }, + "grad": { + "median": 0.030447211989667267, + "iqr": 0.03378926997538656, + "n": 11 + }, + "grad_method": "central finite difference", + "batch": { + "1": { + "median": 0.0014193685201462358, + "iqr": 7.71042105043307e-05, + "n": 200, + "theta_per_s": 704.538663360641 + }, + "32": { + "median": 0.052148532995488495, + "iqr": 0.01226879027672112, + "n": 6, + "theta_per_s": 613.6318351039406 + }, + "256": { + "median": 0.5076875319937244, + "iqr": 0.09504556050524116, + "n": 3, + "theta_per_s": 504.24716753367983 + } + } + }, + "gp": { + "ndim": 4, + "names": [ + "m", + "b", + "discrepancy_k1__constant_value", + "discrepancy_k2__length_scale" + ], + "build_s": 0.20556638098787516, + "first_call_s": 0.0013360870070755482, + "values": [ + -97837.4003217202, + -2742.231223517278, + -289.1538178750733, + -765.6621188878797, + -61811.51232121969, + -10172.420777258363, + 71.36436981334343, + 8.09300468809309 + ], + "thetas": [ + [ + 1.7517461362828193, + -3.06729089351764, + -11.426370664893275, + -2.9338894578858836 + ], + [ + 4.450059264843312, + 6.789603544403578, + -3.5070991392594824, + -0.0820137560640064 + ], + [ + 0.5478524387039049, + 7.573366634505017, + -0.5780502422985503, + -2.9890459993194076 + ], + [ + 5.343648919023343, + -9.15263575570495, + -1.7848237499807826, + -2.297377517589764 + ], + [ + 5.473567694543734, + 0.520578325294422, + -7.804033532476613, + -1.3092511152093662 + ], + [ + -9.530418686749139, + -5.7691904722888605, + -2.611258194289176, + -0.41124195370299965 + ], + [ + 1.4669126516823798, + -1.4791814423938718, + 1.9609391010489539, + 0.9233413551049203 + ], + [ + 2.4162655379083544, + 1.9328035654534945, + -2.361745772006838, + -1.4443143040835849 + ] + ], + "log_posterior": { + "median": 0.0007866559899412096, + "iqr": 8.648625225760043e-05, + "n": 238 + }, + "grad": { + "median": 0.006377615995006636, + "iqr": 0.0007540334918303415, + "n": 30 + }, + "grad_method": "central finite difference", + "batch": { + "1": { + "median": 0.000771016493672505, + "iqr": 5.265978688839823e-05, + "n": 254, + "theta_per_s": 1296.9891152870166 + }, + "32": { + "median": 0.026094842003658414, + "iqr": 0.001183375992695801, + "n": 8, + "theta_per_s": 1226.2959858317479 + }, + "256": { + "median": 0.20458028395660222, + "iqr": 0.001986587973078713, + "n": 3, + "theta_per_s": 1251.3424805603725 + } + }, + "emcee": { + "nwalkers": 32, + "steps": 500, + "wall_s": 10.346444643975701 + } + }, + "gp500": { + "ndim": 4, + "names": [ + "m", + "b", + "discrepancy_k1__constant_value", + "discrepancy_k2__length_scale" + ], + "build_s": 0.001790060952771455, + "first_call_s": 0.009948407008778304, + "values": [ + -474769.85769429954, + -2600.2872422515347, + 14.714200262492994, + -441.6880122096344, + -101354.73750212124, + -10562.071539915283, + 410.7356477698297, + 340.01788942827466 + ], + "thetas": [ + [ + 1.7517461362828193, + -3.06729089351764, + -11.426370664893275, + -2.9338894578858836 + ], + [ + 4.450059264843312, + 6.789603544403578, + -3.5070991392594824, + -0.0820137560640064 + ], + [ + 0.5478524387039049, + 7.573366634505017, + -0.5780502422985503, + -2.9890459993194076 + ], + [ + 5.343648919023343, + -9.15263575570495, + -1.7848237499807826, + -2.297377517589764 + ], + [ + 5.473567694543734, + 0.520578325294422, + -7.804033532476613, + -1.3092511152093662 + ], + [ + -9.530418686749139, + -5.7691904722888605, + -2.611258194289176, + -0.41124195370299965 + ], + [ + 1.4669126516823798, + -1.4791814423938718, + 1.9609391010489539, + 0.9233413551049203 + ], + [ + 2.4162655379083544, + 1.9328035654534945, + -2.361745772006838, + -1.4443143040835849 + ] + ], + "log_posterior": { + "median": 0.010763357509858906, + "iqr": 0.0016847577498992905, + "n": 200 + }, + "grad": { + "median": 0.0895568510168232, + "iqr": 0.012436878983862698, + "n": 25 + }, + "grad_method": "central finite difference", + "batch": { + "1": { + "median": 0.01087379700038582, + "iqr": 0.003935328961233608, + "n": 200, + "theta_per_s": 91.96419612804233 + }, + "32": { + "median": 0.28505945802317, + "iqr": 0.047629135253373533, + "n": 6, + "theta_per_s": 112.25728211901321 + }, + "256": { + "median": 2.9276101629948243, + "iqr": 0.19597399450140074, + "n": 3, + "theta_per_s": 87.4433362870016 + } + } + }, + "elastic": { + "ndim": 5, + "names": [ + "Vv", + "Wv", + "Rv", + "av", + "log_c" + ], + "build_s": 16.56209777999902, + "first_call_s": 0.005945393000729382, + "values": [ + 121.1447625245349, + -217.0740586347388, + -228.14433835134164, + -13673.657821259441, + -519.3535827082534, + -6371.417673902804, + -309.28698854305617, + -4884.509848544204 + ], + "thetas": [ + [ + 50.19138699714327, + 2.8885069963470924, + 3.727178640204773, + 0.5049582906585587, + -1.120378564798365 + ], + [ + 54.60408923644355, + 5.246450430370259, + 4.292310399605348, + 0.6630874974396269, + -0.38956545727339087 + ], + [ + 53.05365686594452, + 1.0191695011910367, + 4.397295575802055, + 0.5100756725916393, + -1.6220673214203352 + ], + [ + 42.810489929640944, + 7.042252456449206, + 4.137973162910062, + 0.5899135671612155, + -3.4638766728140493 + ], + [ + 40.45311473832741, + 1.8699829354969477, + 4.243988821644184, + 0.6941568534722751, + -2.307689331112477 + ], + [ + 46.13884086819014, + 7.980469550524477, + 4.49860636656143, + 0.7056625953442084, + -2.097244342393102 + ], + [ + 51.01514768913504, + 3.7224499678537266, + 3.8044336963745025, + 0.7164465020582246, + -2.8478740651456445 + ], + [ + 44.96387000894329, + 4.400847511822524, + 4.423629389588867, + 0.780213054786875, + -3.8532288197455786 + ] + ], + "log_posterior": { + "median": 0.007019748009042814, + "iqr": 0.0007727155170869082, + "n": 200 + }, + "grad": { + "median": 0.06961964999209158, + "iqr": 0.008491224740282632, + "n": 20 + }, + "grad_method": "central finite difference", + "batch": { + "1": { + "median": 0.00641543252277188, + "iqr": 0.0001583989942446351, + "n": 200, + "theta_per_s": 155.87413575787025 + }, + "32": { + "median": 0.21469539450481534, + "iqr": 0.005164084228454158, + "n": 6, + "theta_per_s": 149.04837653274524 + }, + "256": { + "median": 1.8008029150078073, + "iqr": 0.012771376495948061, + "n": 3, + "theta_per_s": 142.158810309839 + } + }, + "emcee": { + "nwalkers": 32, + "steps": 500, + "wall_s": 106.41425286600133 + } + }, + "ias": { + "ndim": 4, + "names": [ + "Vv", + "Wv", + "Rv", + "av" + ], + "build_s": 8.98134007799672, + "first_call_s": 0.005154884012881666, + "values": [ + -85468.86566733834, + -1772.1080863647041, + -1183.0384338299161, + -246113.44829727596, + -338.9875329748652, + -8397.313094647914, + -5989.707733103512, + -1890.4807305847157 + ], + "thetas": [ + [ + 50.19138699714327, + 2.8885069963470924, + 3.9607183208879944, + 0.5049582906585587 + ], + [ + 53.012323827204355, + 7.389289040944052, + 4.454099053555138, + 0.7188489682951995 + ], + [ + 48.69799986344677, + 7.5455069665143775, + 4.636582541603595, + 0.5008215500510445 + ], + [ + 53.71846842540111, + 1.2350990271382505, + 4.561399010459811, + 0.5526966861807677 + ], + [ + 53.81086275759819, + 4.790228541743642, + 4.186394551659246, + 0.6268061663592975 + ], + [ + 40.45311473832741, + 1.8699829354969477, + 4.509911088835404, + 0.6941568534722751 + ], + [ + 49.84616178370006, + 3.685742879833184, + 4.794764821173129, + 0.7942506016328691 + ], + [ + 50.96867175169112, + 5.553214933874714, + 4.5254560314878605, + 0.6166764271937312 + ] + ], + "log_posterior": { + "median": 0.005232540483120829, + "iqr": 0.0006159277545521036, + "n": 200 + }, + "grad": { + "median": 0.04263956600334495, + "iqr": 0.005502995976712555, + "n": 25 + }, + "grad_method": "central finite difference", + "batch": { + "1": { + "median": 0.00493909401120618, + "iqr": 0.00021100846061017364, + "n": 200, + "theta_per_s": 202.46628181831048 + }, + "32": { + "median": 0.167140343983192, + "iqr": 0.0019227722514187917, + "n": 6, + "theta_per_s": 191.45587018307197 + }, + "256": { + "median": 1.3386166369891725, + "iqr": 0.04519093199633062, + "n": 3, + "theta_per_s": 191.2422070114094 + } + } + } + }, + "jitr": "3.0.1" +} \ No newline at end of file diff --git a/benchmarks/results/references.json b/benchmarks/results/references.json new file mode 100644 index 0000000..ad3e5fa --- /dev/null +++ b/benchmarks/results/references.json @@ -0,0 +1,3443 @@ +{ + "linear": { + "method": "quadrature", + "mean": [ + 2.047650281818148, + 0.9636758286739218 + ], + "sd": [ + 0.05399593708143001, + 0.08837021160422669 + ], + "logz": 0.6379342790241234, + "wall_s": 0.9132480730186217, + "names": [ + "m", + "b" + ] + }, + "gp": { + "method": "quadrature", + "mean": [ + 1.9867679070878934, + 1.0102798932002484, + -8.344813675388666, + -0.5691803403991103 + ], + "sd": [ + 0.06514022047213826, + 0.15853088821514771, + 2.7060566587169648, + 1.15399627516947 + ], + "logz": 80.48157859901941, + "wall_s": 322.9984175330028, + "names": [ + "m", + "b", + "discrepancy_k1__constant_value", + "discrepancy_k2__length_scale" + ] + }, + "hierarchy": { + "method": "quadrature", + "mean": [ + 0.8038223875160653, + 0.928976560313388, + 0.3086592882654772, + -0.5475145822901437, + -0.27092152691820837, + -0.7808924173260858, + -0.470313734402847, + 0.47623882291963215, + -1.1396649321508157, + -0.8566066453812734, + -1.8887208811664415, + -0.05695333507745703, + 0.17665835344657993, + 1.113621082687518, + 0.42615799654604625, + 0.08067091721426435, + 0.9593398281808774, + -1.0965029514137279, + 0.010655890569522845, + -0.24194502860304448, + 0.41212219253183796, + 1.8836222662409332, + -0.3762804426523522, + 1.823399965034255, + 0.2712713566562759, + 1.2922041828343933, + 1.0214180190936482, + 0.355582206963312, + 0.1289372371050936, + -0.040209866964356085, + 0.6146531625906037, + -1.1360871969261426, + -2.1324705109328623 + ], + "sd": [ + 0.02309370286174219, + 0.058641807105023994, + 0.04371056017606459, + 0.2438170141369989, + 0.23573454678455186, + 0.25446212614063807, + 0.2410432506486415, + 0.24118905298928214, + 0.27665087187776455, + 0.25859571341845605, + 0.3395896053234433, + 0.23316545723176335, + 0.23417453792074294, + 0.2747218088563842, + 0.2395854984212066, + 0.23327708572635378, + 0.26459563293078403, + 0.2736515210109539, + 0.23304681069125435, + 0.23519360987787813, + 0.239166305403242, + 0.3389552527031623, + 0.23819926772654026, + 0.333282535601443, + 0.23571040132479443, + 0.28776616483408063, + 0.2685339250876543, + 0.23761372425276409, + 0.23364457283708823, + 0.23310486398366664, + 0.24647267573092857, + 0.2763991121014526, + 0.36342494233540773 + ], + "logz": 73.96556060447234, + "wall_s": 11.356523881026078, + "names": [ + "m", + "mu", + "tau", + "eta_0", + "eta_1", + "eta_2", + "eta_3", + "eta_4", + "eta_5", + "eta_6", + "eta_7", + "eta_8", + "eta_9", + "eta_10", + "eta_11", + "eta_12", + "eta_13", + "eta_14", + "eta_15", + "eta_16", + "eta_17", + "eta_18", + "eta_19", + "eta_20", + "eta_21", + "eta_22", + "eta_23", + "eta_24", + "eta_25", + "eta_26", + "eta_27", + "eta_28", + "eta_29" + ] + }, + "modes": { + "method": "NUTS, 4 x 3000 draws", + "mean": [ + 1.9751114924146644, + 1.0030568022697681, + -4.670309711285699, + -4.619930260705713, + -4.653935897581963, + -4.648421083771645, + -4.663504696592485, + -4.639770726832958, + -2.953914040017989 + ], + "sd": [ + 0.12173622862598416, + 0.026011649821272853, + 1.068542768060515, + 1.1061641352501443, + 1.0455995133415183, + 1.0668107117441759, + 1.049861735935169, + 1.0631176101824555, + 1.7226199316605026 + ], + "logz": null, + "min_ess": 2474.9120668723353, + "max_rhat": 1.0012106429457597, + "wall_s": 131.74165477394126, + "names": [ + "m", + "b", + "log_eta0", + "log_eta1", + "log_eta2", + "log_eta3", + "log_eta4", + "log_eta5", + "log_s" + ] + }, + "elastic": { + "method": "NUTS, 4 x 3000 draws", + "mean": [ + 47.6541941257886, + 3.501641808517596, + 4.123273083340433, + 0.6922667578731504, + -3.08299659805421 + ], + "sd": [ + 0.1529030928612455, + 0.03280298437149017, + 0.0084040137864517, + 0.0035931752710477317, + 0.09326907168032994 + ], + "logz": null, + "min_ess": 3919.8569937460893, + "max_rhat": 1.0009644643750073, + "wall_s": 1498.965707179159, + "names": [ + "Vv", + "Wv", + "Rv", + "av", + "log_c" + ] + }, + "alpha_gp": { + "method": "pocomc 8192/4096, 3 runs", + "mean": [ + 156.9170972879033, + 27.07571915721705, + 1.2949630285001958, + 0.608655451717469, + -0.722236205967922, + -0.9273783501780407, + -3.708988419572021, + 0.36915994303880567, + 8.001448305491236 + ], + "sd": [ + 20.166197160230762, + 2.4278582406642055, + 0.02580757990512527, + 0.016824137006172777, + 0.10522303757128866, + 0.7559634352193809, + 0.2837410231660738, + 0.23341443601937567, + 3.367323057781327 + ], + "logz": -84.52693306054154, + "logz_err": 0.014698470842069744, + "mode_share": 0.740026772601546, + "mode_share_label": "share in the deeper family", + "max_disagreement": 0.0124517596188911, + "accepted": true, + "runs": [ + { + "seed": 2000, + "mean": [ + 156.8785555103583, + 27.084545266633093, + 1.2949127736646193, + 0.6087120605094569, + -0.7227072567074655, + -0.9316473871610929, + -3.7103949456299055, + 0.3687829414566313, + 8.009230708265191 + ], + "sd": [ + 20.209887821553867, + 2.4362592655920334, + 0.02591123388018143, + 0.016808298456851233, + 0.10518896180442683, + 0.7578834072315861, + 0.28290802006322957, + 0.2340100304599236, + 3.386179474805629 + ], + "logz": -84.53085505152227, + "logz_err": 0.010752965731570916, + "wall_s": 1916.138335942058, + "mode_share": 0.7388912281610726 + }, + { + "seed": 2001, + "mean": [ + 156.87994947919742, + 27.07086370722465, + 1.2948506648103246, + 0.6088069645653363, + -0.7223079285328061, + -0.9227154032774394, + -3.7081077138705, + 0.37081806005134144, + 8.020414799227787 + ], + "sd": [ + 20.2181779157913, + 2.4194654122845995, + 0.02581627166683903, + 0.016793939425374386, + 0.10580297106742258, + 0.7545306780598743, + 0.28452537496843255, + 0.23052603572312544, + 3.369362709178061 + ], + "logz": -84.5240567170944, + "logz_err": 0.014698470842069744, + "wall_s": 1860.9660312659107, + "mode_share": 0.7385990858823233 + }, + { + "seed": 2002, + "mean": [ + 156.99278687415418, + 27.071748497793408, + 1.2951256470256431, + 0.6084473300776139, + -0.7216934326634947, + -0.9277722600955896, + -3.708462599215657, + 0.3678788276084441, + 7.9746994089807295 + ], + "sd": [ + 20.069968743865562, + 2.427796856847879, + 0.025693968587523815, + 0.01686801660700836, + 0.10467165279680032, + 0.7554457096046183, + 0.28378202448329254, + 0.23566802198365705, + 3.346138285794625 + ], + "logz": -84.52588741300796, + "logz_err": 0.013892527125909937, + "wall_s": 1778.2113279250334, + "mode_share": 0.7425900037612424 + } + ], + "names": [ + "V", + "W", + "r", + "a", + "log_sigma_A", + "log_sigma_B", + "log_ell", + "log_A_q", + "p" + ], + "corroboration": { + "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}, 50 runs pooled", + "mean": [ + 157.84862923859987, + 27.15899635059207, + 1.2942094127035682, + 0.6083999304307361, + -0.7233850729641486, + -0.92866986779389, + -3.7097575917384233, + 0.3712189128397781, + 8.050595127754706 + ], + "sd": [ + 20.046456307989263, + 2.440779789417403, + 0.02557497390105194, + 0.016985898053751256, + 0.10618886321822738, + 0.760490038346363, + 0.2891812457383863, + 0.23540763952744176, + 3.382462196834573 + ], + "logz": -84.49533387047751, + "logz_err": 0.816513932031647, + "mode_share": 0.7556519883749424, + "mode_share_label": "share in the deeper family", + "bias": 0.046192742404285864, + "width": 0.018991707545024068, + "logz_combined_err": 0.816646218534609, + "checks": { + "log Z": true, + "moments": true, + "mode share": true + }, + "runs": [ + { + "seed": 3000, + "mean": [ + 155.0363082727781, + 26.96539502958844, + 1.2956310782922478, + 0.6100767794597716, + -0.7187127856976515, + -0.9237462379140806, + -3.715516036567462, + 0.3599844485481908, + 7.936014178529925 + ], + "sd": [ + 20.94112355426644, + 2.477375170861742, + 0.025896217223534412, + 0.017472846296503423, + 0.10737074155989607, + 0.7614975431419349, + 0.2960561666556353, + 0.2387152145491169, + 3.3654879919721172 + ], + "logz": -85.01107970830559, + "logz_err": 0.23611497500574624, + "wall_s": 2693.0728099420667, + "mode_share": 0.694953866005275 + }, + { + "seed": 3001, + "mean": [ + 148.75030343708653, + 26.451619379396192, + 1.3002841100864992, + 0.6126134761458646, + -0.7193340209575875, + -0.8920772452925648, + -3.6971926192482827, + 0.3710694794025508, + 7.966812618096597 + ], + "sd": [ + 22.717944614091152, + 2.576690930978656, + 0.026778478536716104, + 0.017317696364374514, + 0.10620310818411594, + 0.7580134725131048, + 0.2983931036008246, + 0.23684614176087893, + 3.3405251605008126 + ], + "logz": -84.74751070345754, + "logz_err": 0.24083548954130415, + "wall_s": 2636.1515113138594, + "mode_share": 0.5538147037815653 + }, + { + "seed": 3002, + "mean": [ + 159.62198959223858, + 27.321985375758146, + 1.2930118520546583, + 0.6074286498983196, + -0.7211987452398998, + -0.8981363214501887, + -3.7165815372794855, + 0.36229233802144495, + 8.006574912874683 + ], + "sd": [ + 18.250330092532945, + 2.356832851685547, + 0.02475406477745071, + 0.016684462868590967, + 0.10694245590346353, + 0.7762582246018198, + 0.2896553926023016, + 0.23831390376500267, + 3.3513333656815933 + ], + "logz": -84.96554847346898, + "logz_err": 0.23441027840668432, + "wall_s": 2748.1917490730993, + "mode_share": 0.8027537260999038 + }, + { + "seed": 3003, + "mean": [ + 173.14246638872424, + 28.281369517831635, + 1.2887566528236576, + 0.5997921312787519, + -0.7384473729868871, + -1.1195125608013665, + -3.7175619872768, + 0.37385735261995184, + 8.02609561265403 + ], + "sd": [ + 24.223874026616325, + 2.4583109451594374, + 0.021557059451404088, + 0.019590565119377817, + 0.10829455554598387, + 0.8101921326740164, + 0.27328127476454644, + 0.2103319464714634, + 3.1892977129968876 + ], + "logz": -84.1225660277727, + "logz_err": 0.23617010472374617, + "wall_s": 2984.7373787555844, + "mode_share": 0.9046727236311667 + }, + { + "seed": 3004, + "mean": [ + 161.3437253760176, + 27.52356842262279, + 1.2911510908860964, + 0.6072977460206239, + -0.7236321333295125, + -0.9206903359234555, + -3.728978418081405, + 0.3608831487372646, + 8.115511692053937 + ], + "sd": [ + 17.13508311375271, + 2.2669489646131464, + 0.024126638833439414, + 0.015986557083297666, + 0.10382582058208888, + 0.7393336790116669, + 0.28256036641792415, + 0.24292216607614814, + 3.4168138881395236 + ], + "logz": -84.50191198965852, + "logz_err": 0.23907937103614066, + "wall_s": 2764.8887593662366, + "mode_share": 0.8378594299359057 + }, + { + "seed": 3005, + "mean": [ + 163.18726931649934, + 27.642603898357127, + 1.2894704931300205, + 0.6069508002916163, + -0.7194440900708137, + -0.9242497377694652, + -3.7221442121012873, + 0.35938301890513114, + 7.91808975724129 + ], + "sd": [ + 15.157956097192223, + 2.2368342186470134, + 0.02340221655337931, + 0.01640354511042065, + 0.10834743262079445, + 0.7606404606023083, + 0.29112107424180533, + 0.23530974300351196, + 3.347862010890444 + ], + "logz": -85.19284963807665, + "logz_err": 0.24014555565239531, + "wall_s": 2820.0456958909926, + "mode_share": 0.8767547506252499 + }, + { + "seed": 3006, + "mean": [ + 159.53485490427767, + 27.28674866076614, + 1.2929778612141096, + 0.6077288939164318, + -0.7269578702030975, + -0.9063900071764145, + -3.7060132265569683, + 0.37703326064266895, + 8.014746367361827 + ], + "sd": [ + 18.670126735050363, + 2.431458816999211, + 0.025822257982887085, + 0.01624059162574942, + 0.10717939477269488, + 0.7618372068682919, + 0.2894011289402667, + 0.23107712819421916, + 3.381885689612925 + ], + "logz": -84.48467558283114, + "logz_err": 0.23414002268649434, + "wall_s": 2798.0343245019903, + "mode_share": 0.7976430964287943 + }, + { + "seed": 3007, + "mean": [ + 160.99841770026336, + 27.40448536891458, + 1.2911358112376625, + 0.6076928068655332, + -0.7224908084477776, + -0.9052122766138084, + -3.7110756601273396, + 0.3769317063569782, + 8.053636608850468 + ], + "sd": [ + 17.515780354746326, + 2.3820585663356977, + 0.02465902171266932, + 0.01644394549904426, + 0.10593060232317225, + 0.7520234578269029, + 0.28109033999369437, + 0.22969777163443195, + 3.378046979895328 + ], + "logz": -84.02183755119567, + "logz_err": 0.23912199981526341, + "wall_s": 2875.0876061839517, + "mode_share": 0.8278044572654997 + }, + { + "seed": 3008, + "mean": [ + 159.22010953303044, + 27.28697256437662, + 1.2923225529808018, + 0.6085520806862227, + -0.7216569112134016, + -0.9452581880320303, + -3.7080525102909463, + 0.3784186184267962, + 8.079298532003122 + ], + "sd": [ + 19.0849984756615, + 2.38339983958914, + 0.025899672555182413, + 0.01653809553346347, + 0.10576194562063879, + 0.7640031085732, + 0.29374600487673524, + 0.23306747437997172, + 3.3574979668693827 + ], + "logz": -84.1551222001456, + "logz_err": 0.22741348205969047, + "wall_s": 2682.265818547923, + "mode_share": 0.7860332718680059 + }, + { + "seed": 3009, + "mean": [ + 155.3063553799417, + 26.991669968116433, + 1.2958127687969154, + 0.6095871157701005, + -0.721502163939222, + -0.9285800365826257, + -3.7088418547748923, + 0.3736231905042132, + 8.12145894564049 + ], + "sd": [ + 20.933757024793053, + 2.461757397608303, + 0.02587346135106598, + 0.016589550936467797, + 0.10783832140394009, + 0.7509432638738239, + 0.2851112750837159, + 0.23368103947136057, + 3.393014751854307 + ], + "logz": -84.63961945228941, + "logz_err": 0.23878867437925277, + "wall_s": 2833.55410412699, + "mode_share": 0.7034441077229117 + }, + { + "seed": 3010, + "mean": [ + 163.12063951664535, + 27.538722614483063, + 1.2906840103073172, + 0.6059377206585473, + -0.7287969042137526, + -0.9418116317895356, + -3.71035896549328, + 0.3726765712953878, + 8.158332744388572 + ], + "sd": [ + 15.176868883888108, + 2.2241353016290057, + 0.02407315695963394, + 0.016690477563964697, + 0.10812708542728128, + 0.7676258698171972, + 0.29151031769107444, + 0.232880822730492, + 3.412121349630975 + ], + "logz": -84.79868345852779, + "logz_err": 0.22890025543128578, + "wall_s": 2788.0256429337896, + "mode_share": 0.8791872711094684 + }, + { + "seed": 3011, + "mean": [ + 156.34340835517068, + 26.9621430423351, + 1.2958335533590637, + 0.6085424439599016, + -0.7248357296876888, + -0.9162144545947323, + -3.7005144391002958, + 0.38429932864786626, + 8.246337608877598 + ], + "sd": [ + 20.357997226227745, + 2.429216502065792, + 0.02559795627949606, + 0.016686663518461587, + 0.10676431540922625, + 0.7542851347764941, + 0.28526514804634256, + 0.22659698890394125, + 3.399688583913854 + ], + "logz": -84.7037004903802, + "logz_err": 0.2275487879017086, + "wall_s": 2591.552704587113, + "mode_share": 0.7284700240201466 + }, + { + "seed": 3012, + "mean": [ + 156.66773258934546, + 27.049494135389804, + 1.294725645933369, + 0.6090813365532447, + -0.723103710053029, + -0.9435031920724252, + -3.7029278734053137, + 0.3767836692513785, + 8.11823521992168 + ], + "sd": [ + 20.175779855338536, + 2.4278164990104085, + 0.02532967501218099, + 0.016927693069028804, + 0.1086198068994079, + 0.7519929921298538, + 0.28982154251355335, + 0.23521467134134671, + 3.393308009293439 + ], + "logz": -84.3482874109922, + "logz_err": 0.2283969344261856, + "wall_s": 2663.0582647961564, + "mode_share": 0.7332125433989597 + }, + { + "seed": 3013, + "mean": [ + 158.4363255688864, + 27.122474485645547, + 1.294058583286062, + 0.6079366902986453, + -0.7225725457281809, + -0.927812087338135, + -3.705742905091299, + 0.3732395133443839, + 8.00935753084637 + ], + "sd": [ + 19.02440802805679, + 2.374281658178547, + 0.02496746896599317, + 0.017337788181584136, + 0.10664130226507859, + 0.7722263538053604, + 0.2959703683648675, + 0.23809916192720723, + 3.3774639360211114 + ], + "logz": -84.68381281074666, + "logz_err": 0.23592999865689412, + "wall_s": 2724.6785172251984, + "mode_share": 0.7737825532805336 + }, + { + "seed": 3014, + "mean": [ + 159.4361076772126, + 27.318086703146246, + 1.2926825155098831, + 0.607962569664182, + -0.7230544878020726, + -0.9202604381852815, + -3.7125013165110627, + 0.3696464387958733, + 8.032565301625526 + ], + "sd": [ + 18.48958792436217, + 2.3891832591227518, + 0.024925457386213393, + 0.016676005717332534, + 0.10517075511211202, + 0.7372023200010842, + 0.2913945385189369, + 0.23558498851021087, + 3.4129822665421052 + ], + "logz": -84.59475259337496, + "logz_err": 0.2318495493991218, + "wall_s": 5655.227152842097, + "mode_share": 0.7951815963513276 + }, + { + "seed": 3015, + "mean": [ + 158.90815787851167, + 27.259131686125784, + 1.293588248420121, + 0.6077544263540835, + -0.7240603409065712, + -0.9327995527177698, + -3.717255687865592, + 0.35984242804981303, + 7.841435301852021 + ], + "sd": [ + 19.133565580435416, + 2.391146004912704, + 0.02594498458356838, + 0.01674481137835389, + 0.10739101659151623, + 0.7674238234602426, + 0.28998315613891046, + 0.23836863447709725, + 3.371956388654496 + ], + "logz": -84.72212122120276, + "logz_err": 0.23866911548468148, + "wall_s": 2791.7348075599875, + "mode_share": 0.7837920320960401 + }, + { + "seed": 3016, + "mean": [ + 155.65902820576855, + 27.053865514549866, + 1.2952513604608893, + 0.6095459095312298, + -0.7188957924452078, + -0.9014855509084173, + -3.7078559250895418, + 0.3664551054444499, + 8.127685150973287 + ], + "sd": [ + 20.76699436667709, + 2.460630449620805, + 0.026107378314423325, + 0.016928751474699032, + 0.10495530003633355, + 0.7660314240971486, + 0.2844068755705314, + 0.23357235991707903, + 3.426033858269698 + ], + "logz": -84.53754787096658, + "logz_err": 0.23915838802686723, + "wall_s": 2662.824847020209, + "mode_share": 0.7110701495814729 + }, + { + "seed": 3017, + "mean": [ + 162.87289434749212, + 27.562163538849614, + 1.2896902662458951, + 0.6069853178171145, + -0.7213863229694062, + -0.9478921087533881, + -3.7173890508422374, + 0.3712604347708056, + 7.970890168843371 + ], + "sd": [ + 15.681430990115018, + 2.2355723847146978, + 0.023841706750082996, + 0.016368034993680395, + 0.10753382804443266, + 0.7639244886936757, + 0.2883086795381806, + 0.2329423578615634, + 3.35462882141772 + ], + "logz": -84.49067148958065, + "logz_err": 0.23630519764477265, + "wall_s": 2657.477834840771, + "mode_share": 0.869687654115215 + }, + { + "seed": 3018, + "mean": [ + 160.45248776501742, + 27.451343664407545, + 1.2913198959788585, + 0.607927775489163, + -0.7205990488822087, + -0.9230105704226366, + -3.7319431723356775, + 0.36656857757757405, + 8.146590818169635 + ], + "sd": [ + 17.88424872458873, + 2.321277403237323, + 0.024920810655904842, + 0.016370488863966127, + 0.10531645561120542, + 0.7602098020413204, + 0.28828287544879616, + 0.2371761150687841, + 3.409337469292532 + ], + "logz": -84.76937622756702, + "logz_err": 0.239538051595605, + "wall_s": 2772.1560445260257, + "mode_share": 0.8182102396841809 + }, + { + "seed": 3019, + "mean": [ + 164.60256063825253, + 27.713015008578004, + 1.2883734247675516, + 0.6063434373251843, + -0.7265948916235251, + -0.937881514684631, + -3.719797462134813, + 0.37581820082739303, + 8.201032989915898 + ], + "sd": [ + 13.579583572251558, + 2.1606520864128087, + 0.02307750371919603, + 0.015841768580661098, + 0.10330211383384788, + 0.7529764160581467, + 0.288344378960387, + 0.23138549559386834, + 3.3729443879902576 + ], + "logz": -84.46573777254066, + "logz_err": 0.23492200029583196, + "wall_s": 2639.407041187864, + "mode_share": 0.9083280695994057 + }, + { + "seed": 3020, + "mean": [ + 146.55838074020497, + 26.32895606447688, + 1.3024245397484546, + 0.6129995512360802, + -0.7224867126448545, + -0.8837401972498717, + -3.699122678451525, + 0.36705607651478855, + 7.97405256799699 + ], + "sd": [ + 22.84734863072531, + 2.5878360122878257, + 0.026858637241359277, + 0.017005644654438344, + 0.1067017663624111, + 0.7494707890565813, + 0.2869151480565618, + 0.2441022764045477, + 3.400163929762545 + ], + "logz": -84.50026414841236, + "logz_err": 0.22858285202275816, + "wall_s": 2616.0876129330136, + "mode_share": 0.5071786542764218 + }, + { + "seed": 3021, + "mean": [ + 163.72492191937937, + 27.540286568433807, + 1.2904416376485046, + 0.6054901226946344, + -0.7250171023069939, + -0.961549592941256, + -3.6999093627589628, + 0.37129286447563337, + 7.972728338275005 + ], + "sd": [ + 14.727135239545376, + 2.2564701683285797, + 0.024786165989858496, + 0.016469882132660832, + 0.10462320127761035, + 0.7706081603950512, + 0.28814244172641246, + 0.23389705880309952, + 3.389897831205568 + ], + "logz": -84.30704401259557, + "logz_err": 0.23587012516629077, + "wall_s": 2591.661661247257, + "mode_share": 0.8932163016391246 + }, + { + "seed": 3022, + "mean": [ + 160.21766525830947, + 27.313514432388, + 1.2925351109505705, + 0.6073890343759074, + -0.7256711509789673, + -0.9322040878728046, + -3.705073869424344, + 0.3865559477192151, + 8.105254817274268 + ], + "sd": [ + 17.822194342007702, + 2.244328412536697, + 0.024129469546859544, + 0.016636411221425205, + 0.10649021450411267, + 0.7532508909943384, + 0.2822159477991818, + 0.2291443137655243, + 3.2613381289846717 + ], + "logz": -84.22419406647667, + "logz_err": 0.23224760901652927, + "wall_s": 2562.6737098312005, + "mode_share": 0.8134049287207986 + }, + { + "seed": 3023, + "mean": [ + 154.22988987565546, + 26.927461302211317, + 1.2963887386832178, + 0.610265399191069, + -0.7231248241213648, + -0.9126387114834102, + -3.7158152774847664, + 0.3738851388481331, + 8.11069680858564 + ], + "sd": [ + 21.33662109686993, + 2.5339009386142095, + 0.025908671020789493, + 0.016979360175675237, + 0.10650692509679446, + 0.7561399977115059, + 0.28659620248790174, + 0.23309301117133088, + 3.4119361147571983 + ], + "logz": -84.9828288881904, + "logz_err": 0.23875739824540043, + "wall_s": 2741.4676114018075, + "mode_share": 0.6777895412758969 + }, + { + "seed": 3024, + "mean": [ + 153.62055618632968, + 26.78417521683285, + 1.2983997061220276, + 0.6091171502671576, + -0.7207140402042328, + -0.9279144258263111, + -3.7029138319680888, + 0.358028228024975, + 7.884837726452231 + ], + "sd": [ + 21.418791790805358, + 2.5061968492033784, + 0.026676770150008116, + 0.01775121332451289, + 0.10555358799973781, + 0.7723886301621866, + 0.2955302296053888, + 0.2428768988573913, + 3.425730933348549 + ], + "logz": -84.72469695690226, + "logz_err": 0.23936774564758748, + "wall_s": 2635.870913216844, + "mode_share": 0.6706497531359986 + }, + { + "seed": 3025, + "mean": [ + 155.3576330437849, + 26.94617303566052, + 1.296610789764296, + 0.6091593571015939, + -0.7206946249844651, + -0.9254255865884787, + -3.694660804017364, + 0.37001508060250554, + 8.07872917383517 + ], + "sd": [ + 22.366650436309534, + 2.4992487728774417, + 0.02553909732559296, + 0.0181570293768271, + 0.10382835995910406, + 0.7486266139364461, + 0.286142680636899, + 0.2346736304310194, + 3.360642916891107 + ], + "logz": -84.50728259179247, + "logz_err": 0.22434070797818934, + "wall_s": 2658.734697677195, + "mode_share": 0.6855985536856692 + }, + { + "seed": 3026, + "mean": [ + 154.54072461447373, + 26.914751300759693, + 1.2969848078603279, + 0.6092677558957659, + -0.721409660794297, + -0.9437119118371886, + -3.7100469076622793, + 0.37070023394227325, + 8.135548453703366 + ], + "sd": [ + 21.38432766637463, + 2.5286046684885575, + 0.026908408569110236, + 0.016581203914590684, + 0.10492436403182637, + 0.7505003562953333, + 0.2849957169049016, + 0.23777428798370717, + 3.400264013507102 + ], + "logz": -84.5659866724663, + "logz_err": 0.22222493555329073, + "wall_s": 2727.274063028861, + "mode_share": 0.6895252185289699 + }, + { + "seed": 3027, + "mean": [ + 158.3803404233768, + 27.178685941151443, + 1.2949186995599027, + 0.6071124698220179, + -0.723646901941957, + -0.9389026817546344, + -3.7168921264751167, + 0.36057340121547043, + 7.975897703914162 + ], + "sd": [ + 19.138801814592295, + 2.4569447853339894, + 0.02611028455845442, + 0.01711408357089224, + 0.10656539004901021, + 0.7563270654057285, + 0.28594727783815826, + 0.24152687275029433, + 3.424021606875366 + ], + "logz": -84.43234300513713, + "logz_err": 0.23863017482663604, + "wall_s": 2653.8005257407203, + "mode_share": 0.777800094931181 + }, + { + "seed": 3028, + "mean": [ + 163.6297554708925, + 27.696209654765973, + 1.2890011679086453, + 0.6067998429217873, + -0.7225732505197283, + -0.9365985993968523, + -3.712197347207983, + 0.3692444518973431, + 8.05133841367845 + ], + "sd": [ + 14.847590009878896, + 2.1579149531552937, + 0.02319226106022582, + 0.01575061636979743, + 0.10477785710033082, + 0.7659724876929488, + 0.2898552173731284, + 0.23408042679005098, + 3.363454982587375 + ], + "logz": -84.06077143325636, + "logz_err": 0.22574277783005617, + "wall_s": 2659.12876476394, + "mode_share": 0.8873748837963811 + }, + { + "seed": 3029, + "mean": [ + 157.64167454846213, + 27.16640705731838, + 1.2946400716449256, + 0.6080855957317933, + -0.7189055134903761, + -0.9177480335414973, + -3.7097871208263427, + 0.37054039834703895, + 8.154966941504673 + ], + "sd": [ + 19.57786160190162, + 2.438559962025036, + 0.025529856372291625, + 0.017037402397691987, + 0.10612861083521659, + 0.7678025140092074, + 0.2915458336624528, + 0.2369307056137222, + 3.445883729019674 + ], + "logz": -84.5774665986919, + "logz_err": 0.23101144709837396, + "wall_s": 2633.308246606961, + "mode_share": 0.7583224350931193 + }, + { + "seed": 3030, + "mean": [ + 160.7431706871559, + 27.42808702025613, + 1.2915181033677408, + 0.6077355350387634, + -0.7248430749634354, + -0.933013592378232, + -3.7345306991035634, + 0.36556313698926457, + 7.952697011716893 + ], + "sd": [ + 17.63030498064033, + 2.304080797800829, + 0.025021653964747925, + 0.016769433181065434, + 0.10598101000185044, + 0.766779293068402, + 0.2929550925746424, + 0.2402676045627046, + 3.3831325455230994 + ], + "logz": -84.45700670817473, + "logz_err": 0.23443255365848842, + "wall_s": 2675.2336292089894, + "mode_share": 0.8228406394949976 + }, + { + "seed": 3031, + "mean": [ + 153.75434981953427, + 26.847094001202066, + 1.2970580230285036, + 0.6101631617186526, + -0.7221286693512192, + -0.8999063715191188, + -3.7100628039203403, + 0.36973945029726707, + 8.044145282950854 + ], + "sd": [ + 21.40052061912164, + 2.506002759950248, + 0.026184786621634662, + 0.017407823430158783, + 0.10675487987423898, + 0.7442607833307798, + 0.2903581217296295, + 0.23608917536402632, + 3.412200063287317 + ], + "logz": -84.57010470850983, + "logz_err": 0.23267183873739863, + "wall_s": 2595.760058631975, + "mode_share": 0.6681328808597061 + }, + { + "seed": 3032, + "mean": [ + 149.03798151917238, + 26.455418414041556, + 1.3005999607591705, + 0.6121402268768293, + -0.7231471882544115, + -0.9094091710263917, + -3.6982600263933185, + 0.3652972118228499, + 7.870029492993725 + ], + "sd": [ + 22.71925749146818, + 2.545996080535587, + 0.027053045572032752, + 0.017490092568823574, + 0.10528824661031994, + 0.7497468714678474, + 0.29362797520742995, + 0.24157801532565046, + 3.4003301858691457 + ], + "logz": -84.45575317152658, + "logz_err": 0.23923244022830606, + "wall_s": 2730.162583360914, + "mode_share": 0.5597929569866532 + }, + { + "seed": 3033, + "mean": [ + 154.76170946609395, + 26.933452806987667, + 1.2964610453797614, + 0.6095301765887766, + -0.7228158011095016, + -0.897947155843875, + -3.702402865162996, + 0.36264667643483434, + 7.862600504409481 + ], + "sd": [ + 21.138259037081617, + 2.501495525198889, + 0.026430060242874233, + 0.017442835577214866, + 0.10709091146380821, + 0.7601380179300004, + 0.2896228202076251, + 0.23873821548248228, + 3.35180161088544 + ], + "logz": -84.66227727378664, + "logz_err": 0.2399338752532776, + "wall_s": 2630.8231329726987, + "mode_share": 0.6920954009842146 + }, + { + "seed": 3034, + "mean": [ + 153.28389951446871, + 26.887407627991827, + 1.2970347334827752, + 0.6106345585880676, + -0.7214049597725186, + -0.8891162637212283, + -3.7093336596393343, + 0.36463321154245165, + 7.903040529290636 + ], + "sd": [ + 21.67796543248705, + 2.55847331753451, + 0.026227917070369065, + 0.017127208998702854, + 0.10482707688282172, + 0.7561582183450484, + 0.2912619321962309, + 0.24042097773290108, + 3.348861527359169 + ], + "logz": -84.538016278866, + "logz_err": 0.22305673931890616, + "wall_s": 2635.6637302399613, + "mode_share": 0.6557272974482112 + }, + { + "seed": 3035, + "mean": [ + 161.22881519866397, + 27.445460420780066, + 1.2907668574798206, + 0.6079040901752887, + -0.7260971082813036, + -0.9366622530485578, + -3.71394679074058, + 0.3719841112357928, + 8.083558748223851 + ], + "sd": [ + 17.336464418930852, + 2.3244154102401833, + 0.0241982971970979, + 0.01650693198865165, + 0.10805646659483781, + 0.7715536202234763, + 0.2871702172550281, + 0.2389168513763518, + 3.381865836620472 + ], + "logz": -84.56604170922252, + "logz_err": 0.23414546453001328, + "wall_s": 2638.0561971752904, + "mode_share": 0.8296838448902183 + }, + { + "seed": 3036, + "mean": [ + 156.62370269123633, + 26.941412734278856, + 1.2956426893627624, + 0.6085028759730736, + -0.7289882479461661, + -0.929254457750406, + -3.6933064634695416, + 0.38343648346970316, + 8.057129699814956 + ], + "sd": [ + 20.41557891793273, + 2.4769450491699505, + 0.026230308649734514, + 0.01660620193796169, + 0.10478418635023572, + 0.7460661485530546, + 0.2874101976889709, + 0.23261240961728225, + 3.4098735531843705 + ], + "logz": -84.23020409136946, + "logz_err": 0.22549878358431863, + "wall_s": 2563.6894302037545, + "mode_share": 0.7325510521567073 + }, + { + "seed": 3037, + "mean": [ + 144.0678362845529, + 26.042817129909295, + 1.3051391452179817, + 0.613197046824574, + -0.7172387281205835, + -0.887856046216102, + -3.6840650052984323, + 0.37065602971907996, + 7.931022108757693 + ], + "sd": [ + 22.590509280805485, + 2.533759537624829, + 0.02677302057310649, + 0.01791534871054794, + 0.10643039505484748, + 0.7681380495412262, + 0.29080458363127354, + 0.2319018822700051, + 3.364395131797485 + ], + "logz": -84.58925162298434, + "logz_err": 0.22852313866078616, + "wall_s": 2675.513078021817, + "mode_share": 0.4555256814404153 + }, + { + "seed": 3038, + "mean": [ + 160.27652466713585, + 27.309445100001238, + 1.2920865547809488, + 0.60780558908447, + -0.7255385524811129, + -0.9235242371818891, + -3.708693392034448, + 0.37155038164157567, + 8.102861877766559 + ], + "sd": [ + 18.02566189655809, + 2.3284372838368714, + 0.02420522059367362, + 0.01597106003692982, + 0.10548892295118917, + 0.7502933297181419, + 0.28615254761972064, + 0.23941708291174113, + 3.306297583262367 + ], + "logz": -83.66049572685058, + "logz_err": 0.22072009714833773, + "wall_s": 5171.534605517983, + "mode_share": 0.8125753564056867 + }, + { + "seed": 3039, + "mean": [ + 163.31062249099344, + 27.632804803708332, + 1.2900350824576994, + 0.6061498614794507, + -0.7254210238036592, + -0.94613701416777, + -3.727731680550379, + 0.376318406376312, + 8.285420956916427 + ], + "sd": [ + 14.827421348508633, + 2.1329609716153604, + 0.023179041519020196, + 0.016092975005376212, + 0.10324307968399776, + 0.7542578955225954, + 0.2850310725319668, + 0.23537433850876063, + 3.423531001161995 + ], + "logz": -84.12118215125084, + "logz_err": 0.23500739564790626, + "wall_s": 5347.867223539855, + "mode_share": 0.8847651240395688 + }, + { + "seed": 3040, + "mean": [ + 158.56315171322035, + 27.147572583981976, + 1.2933606438312146, + 0.6085096888671061, + -0.725880662681902, + -0.8977815210334394, + -3.712819602213269, + 0.3802065787537221, + 8.236970018930856 + ], + "sd": [ + 19.175793068410947, + 2.3999625545126433, + 0.024761788932468075, + 0.016472463668614944, + 0.10489514307956178, + 0.7643867857461637, + 0.28827540262032303, + 0.2316994704268894, + 3.3194083511573456 + ], + "logz": -84.55008217982956, + "logz_err": 0.23549613895250002, + "wall_s": 2605.9408513358794, + "mode_share": 0.7728373130219467 + }, + { + "seed": 3041, + "mean": [ + 159.49022440637222, + 27.274611389524853, + 1.2928980806458787, + 0.6077603424729481, + -0.7278807084591835, + -0.9521992707937945, + -3.717544061583465, + 0.37216970691513385, + 8.115912257671551 + ], + "sd": [ + 18.46102562963265, + 2.4054051456757337, + 0.024946564389653605, + 0.01658586326967642, + 0.1063334199978835, + 0.7627919816063206, + 0.28671829285339523, + 0.23020785612306655, + 3.401715099267042 + ], + "logz": -84.39098412612533, + "logz_err": 0.22038611360580618, + "wall_s": 2798.990286985878, + "mode_share": 0.7971209446463361 + }, + { + "seed": 3042, + "mean": [ + 155.1489394960966, + 26.835128773823374, + 1.2970303072589282, + 0.6088231857040185, + -0.7235902314526594, + -0.9567653373431511, + -3.6937466971535073, + 0.37458497295120907, + 7.929556278971399 + ], + "sd": [ + 21.192291270092298, + 2.497294990592225, + 0.02723034868481024, + 0.01700375320855362, + 0.10636206405893042, + 0.7546259219421391, + 0.28708658330759795, + 0.23575464664131215, + 3.353583212078727 + ], + "logz": -84.39147338666402, + "logz_err": 0.23226489450500332, + "wall_s": 2697.9971779710613, + "mode_share": 0.7010442666292129 + }, + { + "seed": 3043, + "mean": [ + 149.93253931500712, + 26.55725959509663, + 1.3001898998640113, + 0.6113434663412065, + -0.7148848083179139, + -0.9048699716298392, + -3.69828932639993, + 0.37042948275738197, + 8.055609871265634 + ], + "sd": [ + 22.525497943559138, + 2.6290377335851893, + 0.02735328183694533, + 0.01747535092349906, + 0.10774020872855931, + 0.7545372928091905, + 0.29794432367429413, + 0.2379148460821288, + 3.4348246199006707 + ], + "logz": -84.77663594255115, + "logz_err": 0.2158876064641667, + "wall_s": 5709.132166139316, + "mode_share": 0.5847271447575885 + }, + { + "seed": 3044, + "mean": [ + 158.22715477362885, + 27.09961032335545, + 1.294106991351419, + 0.6081377843234732, + -0.7239676569237445, + -0.9420536806653654, + -3.703566989447918, + 0.38365274926727955, + 8.241930916842687 + ], + "sd": [ + 19.52767879400126, + 2.4713365353330063, + 0.026178331826003938, + 0.01679410532691444, + 0.10694529605102517, + 0.7580293669009169, + 0.29622537525374043, + 0.23091893915589268, + 3.4213837989703073 + ], + "logz": -84.35656510212708, + "logz_err": 0.22724282530756537, + "wall_s": 2567.3886513290927, + "mode_share": 0.76773124415442 + }, + { + "seed": 3045, + "mean": [ + 156.1724997966866, + 27.03568153399806, + 1.2948828457345942, + 0.6094907964780742, + -0.7235386506243842, + -0.9266478532817944, + -3.7053849470841413, + 0.37376400770840446, + 8.10223384365531 + ], + "sd": [ + 20.43649892623883, + 2.4236219958318994, + 0.02527543199046779, + 0.0171517567944592, + 0.10568614440071038, + 0.7578829126318118, + 0.2918145796289204, + 0.23865665192698515, + 3.429629655512064 + ], + "logz": -85.29352359091388, + "logz_err": 0.23948222609283032, + "wall_s": 2743.050127318129, + "mode_share": 0.7212459145477795 + }, + { + "seed": 3046, + "mean": [ + 163.99106633599428, + 27.68615895572654, + 1.2885229100407207, + 0.6068741520750033, + -0.7242133263890064, + -0.9214189691458405, + -3.7152368033207672, + 0.3785014331330474, + 8.17956522418655 + ], + "sd": [ + 14.438614027503148, + 2.2030542662845987, + 0.022685857335890958, + 0.0157520803718874, + 0.10527373462729434, + 0.7670586568195835, + 0.28981535876978853, + 0.23094288734855653, + 3.429251243417513 + ], + "logz": -83.91278215246038, + "logz_err": 0.2321352869721951, + "wall_s": 2602.4534906758927, + "mode_share": 0.8926953637031425 + }, + { + "seed": 3047, + "mean": [ + 155.2545418450634, + 26.941835937145164, + 1.2967601987637225, + 0.6088248034942918, + -0.7223923421183592, + -0.9664914663757967, + -3.7131477803189106, + 0.37330328357598647, + 7.916336733928793 + ], + "sd": [ + 20.8029945659277, + 2.549482847907821, + 0.026845598320402966, + 0.017555517329534098, + 0.10590247395134182, + 0.7612729830662024, + 0.2952829674358481, + 0.24078058448393724, + 3.3994455558168704 + ], + "logz": -84.51864440685225, + "logz_err": 0.23359807008680755, + "wall_s": 2670.7196222217754, + "mode_share": 0.7053345320063371 + }, + { + "seed": 3048, + "mean": [ + 156.46253756920711, + 27.029547465803336, + 1.2955968552047408, + 0.6084526678530948, + -0.7260215512623832, + -0.9475830516688591, + -3.7116295697235375, + 0.3674005483680849, + 7.919946328716183 + ], + "sd": [ + 20.21819171204333, + 2.507428377847784, + 0.025808596240116416, + 0.016975532712428208, + 0.10606634677308571, + 0.7599041972793411, + 0.2885034331306497, + 0.23826689071589977, + 3.309074605827779 + ], + "logz": -84.02451828037454, + "logz_err": 0.2322909116621228, + "wall_s": 2860.4783395826817, + "mode_share": 0.7329568515558 + }, + { + "seed": 3049, + "mean": [ + 161.55750981567812, + 27.435531758753495, + 1.291672661503469, + 0.6065921243573046, + -0.7277398975092492, + -0.9278978273878169, + -3.7095162369120227, + 0.37714912727203237, + 8.204435694785015 + ], + "sd": [ + 16.82065710051113, + 2.3021883301368034, + 0.02420310043047749, + 0.015504019055493153, + 0.1052298843164069, + 0.7555953446149325, + 0.28095594869868645, + 0.23222283262753535, + 3.401513152093643 + ], + "logz": -83.8608598664329, + "logz_err": 0.23661110116859632, + "wall_s": 2788.7204725639895, + "mode_share": 0.8456989773335915 + } + ] + }, + "corroborated": true, + "wall_s": 151526.67097179964 + }, + "n40ca_gp": { + "method": "pocomc 8192/4096, 3 runs", + "mean": [ + 43.59895603286648, + 13.724149660274534, + 4.296583779360842, + 0.485035191245812, + -1.2733512647642957, + -1.7963250392384775, + 2.220629274631007 + ], + "sd": [ + 1.7104949748096125, + 1.0650461079067588, + 0.07028969719232937, + 0.026625055665343005, + 0.20831053760680046, + 0.4800701934175172, + 0.6747905034112969 + ], + "logz": -11.342946005337055, + "logz_err": 0.009205750713685073, + "max_disagreement": 0.042364712248810193, + "accepted": true, + "runs": [ + { + "seed": 2000, + "mean": [ + 43.56719223186605, + 13.721765783171005, + 4.298119872652306, + 0.4844611351201628, + -1.272366219282795, + -1.8032225972846545, + 2.2300364828257138 + ], + "sd": [ + 1.7200111153884834, + 1.061834140539834, + 0.07065073255673113, + 0.02644065108920894, + 0.20915348375756906, + 0.482459366500779, + 0.6755908989364604 + ], + "logz": -11.346640683324653, + "logz_err": 0.008829612327629072, + "wall_s": 640.7687541219639 + }, + { + "seed": 2001, + "mean": [ + 43.5887574095278, + 13.72474651565375, + 4.296511409510507, + 0.48525235399999167, + -1.2752161744136792, + -1.7992840974518884, + 2.2223893655881257 + ], + "sd": [ + 1.768604828830274, + 1.0725806337226362, + 0.0709547289440926, + 0.02754096948724118, + 0.20962414303124668, + 0.4802143788094155, + 0.6754740862616965 + ], + "logz": -11.346479090928366, + "logz_err": 0.007952768122234433, + "wall_s": 633.3055904699722 + }, + { + "seed": 2002, + "mean": [ + 43.64091845720561, + 13.72593668199885, + 4.295120055919713, + 0.4853920846172816, + -1.2724714005964133, + -1.786468422978889, + 2.2094619754791824 + ], + "sd": [ + 1.6395438703788003, + 1.0606787664020407, + 0.06921934496604427, + 0.02585659807967027, + 0.20612412949733824, + 0.47736338010738955, + 0.673143420445319 + ], + "logz": -11.33571824175814, + "logz_err": 0.009205750713685073, + "wall_s": 598.1245579579845 + } + ], + "names": [ + "Vv", + "Wv", + "Rv", + "av", + "log_ell_xs", + "log_A_xs", + "amp_slope_xs" + ], + "corroboration": { + "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}, 50 runs pooled", + "mean": [ + 43.6612308080938, + 13.70908002326348, + 4.29212803499743, + 0.4867055623948784, + -1.2690073287163621, + -1.760463557949741, + 2.18006271440875 + ], + "sd": [ + 1.919810969381398, + 1.1153700168374379, + 0.07540774161480943, + 0.029130297776965366, + 0.20882070600554717, + 0.4841155951845646, + 0.6762933065360258 + ], + "logz": -11.52591858849597, + "logz_err": 0.8687611469385104, + "bias": 0.07470049542848377, + "width": 0.1154439401632449, + "logz_combined_err": 0.8688099195313774, + "checks": { + "log Z": true, + "moments": true + }, + "runs": [ + { + "seed": 3000, + "mean": [ + 43.86350465157741, + 13.613350602769225, + 4.2801884004979245, + 0.49061836857899627, + -1.2549020023920017, + -1.684654261954729, + 2.0995189980483357 + ], + "sd": [ + 2.11651250135529, + 1.1464758731028168, + 0.07664195520330816, + 0.03057126107834519, + 0.19825012259046437, + 0.4801133607365389, + 0.6948607729261731 + ], + "logz": -12.177582190802257, + "logz_err": 0.24689773209131172, + "wall_s": 1334.630270184949 + }, + { + "seed": 3001, + "mean": [ + 43.65903901799406, + 13.728564647336153, + 4.2946504176091755, + 0.4850803203582831, + -1.270483634494769, + -1.7688786955662252, + 2.1920897834915354 + ], + "sd": [ + 1.6106292908463407, + 1.0973267824768798, + 0.07376627959417903, + 0.02461015110796583, + 0.21414120185835417, + 0.4867352456550508, + 0.6729684308572398 + ], + "logz": -11.62639478115365, + "logz_err": 0.2323095386650202, + "wall_s": 1272.7058295130264 + }, + { + "seed": 3002, + "mean": [ + 43.85000570485298, + 13.674268053457672, + 4.28254546995636, + 0.489631738400541, + -1.2618163122544772, + -1.718165743717051, + 2.1374332492790957 + ], + "sd": [ + 1.8227656525500626, + 1.1764136119365507, + 0.07685155166161006, + 0.03125705634094876, + 0.20886987063911486, + 0.4946172656041681, + 0.6907647215154945 + ], + "logz": -11.718260344536716, + "logz_err": 0.23028881662247125, + "wall_s": 1269.7501324790064 + }, + { + "seed": 3003, + "mean": [ + 43.76343629776936, + 13.683402872005876, + 4.28861353034318, + 0.48708101017948474, + -1.2606005582047894, + -1.7305040360276611, + 2.143809272581293 + ], + "sd": [ + 1.6692705426300734, + 1.0858725940082474, + 0.07444447942813548, + 0.02746523072931969, + 0.2018164103745195, + 0.48601019471638235, + 0.6757381138448649 + ], + "logz": -11.546373333308322, + "logz_err": 0.2547131915439554, + "wall_s": 1202.652240928961 + }, + { + "seed": 3004, + "mean": [ + 43.88154286964037, + 13.695661332011795, + 4.284799330436668, + 0.488470746005194, + -1.272392498313646, + -1.7376565907072437, + 2.1491373772572238 + ], + "sd": [ + 1.7488280905779696, + 1.1393859522381267, + 0.07887731850651272, + 0.026970848148067928, + 0.20553601636500848, + 0.48355689937295016, + 0.6692137740755333 + ], + "logz": -11.875079372876257, + "logz_err": 0.24797031509799095, + "wall_s": 1251.7241517269285 + }, + { + "seed": 3005, + "mean": [ + 43.830053055903676, + 13.702027654766338, + 4.286167718591822, + 0.48757837579502433, + -1.2729407248535645, + -1.737942847444878, + 2.141927747243757 + ], + "sd": [ + 1.6738384251851768, + 1.131668161720444, + 0.07512384263891987, + 0.02602157244474594, + 0.20776716815457782, + 0.47562544715328586, + 0.6647076096922615 + ], + "logz": -11.48819235752476, + "logz_err": 0.24733428869862456, + "wall_s": 1216.5220271740109 + }, + { + "seed": 3006, + "mean": [ + 43.066408761053495, + 13.849427077915399, + 4.321123472418126, + 0.4775949022951496, + -1.3029579701661682, + -1.8826994172752876, + 2.285994713916897 + ], + "sd": [ + 1.8953224389666694, + 1.0898340553515298, + 0.07984017683838834, + 0.028761218292154247, + 0.21093869866744047, + 0.4617500283433338, + 0.6613726590271967 + ], + "logz": -10.858815703691715, + "logz_err": 0.24555390449510403, + "wall_s": 1211.0836269139545 + }, + { + "seed": 3007, + "mean": [ + 43.27805435134456, + 13.812063586626735, + 4.312450878654405, + 0.4801404218316396, + -1.300427700693842, + -1.884601318225866, + 2.3039543132898572 + ], + "sd": [ + 1.7507199422039392, + 1.0664913514823, + 0.07430683007595126, + 0.02561933665206919, + 0.21886423502515245, + 0.46850229756652884, + 0.6486604734595018 + ], + "logz": -10.95616272966126, + "logz_err": 0.24764373444092155, + "wall_s": 1208.8542942550266 + }, + { + "seed": 3008, + "mean": [ + 43.71502143065437, + 13.69100264381236, + 4.291588876534214, + 0.4861817346523326, + -1.270867540295385, + -1.766630598137311, + 2.186608002240662 + ], + "sd": [ + 1.6622243287055765, + 1.102096955311076, + 0.072038366878623, + 0.025467561793216655, + 0.20931644219436965, + 0.46372593741929335, + 0.6573332938558806 + ], + "logz": -11.538222983807266, + "logz_err": 0.24039412583606726, + "wall_s": 1242.5232465650188 + }, + { + "seed": 3009, + "mean": [ + 43.77673461417868, + 13.700509930730044, + 4.289910496349014, + 0.4866101926370263, + -1.2641329731104327, + -1.7573454748512616, + 2.186827588032421 + ], + "sd": [ + 1.561246425654861, + 1.0800193467963126, + 0.07040321385935762, + 0.024273350697896188, + 0.21188738021428744, + 0.4548004338586409, + 0.6428544320824617 + ], + "logz": -11.196398888570267, + "logz_err": 0.2393942599479111, + "wall_s": 1205.3371413829736 + }, + { + "seed": 3010, + "mean": [ + 43.69078881380422, + 13.675209992531647, + 4.294459191961428, + 0.4851811759892041, + -1.2718857830444117, + -1.7890424919094987, + 2.2273669305461086 + ], + "sd": [ + 1.6318308130453132, + 1.0876432460224863, + 0.07366205502147787, + 0.024974938942400462, + 0.20834380126811014, + 0.48424202880993433, + 0.6606004705162517 + ], + "logz": -11.509084345310134, + "logz_err": 0.24487311481182605, + "wall_s": 1233.201237477013 + }, + { + "seed": 3011, + "mean": [ + 43.60975826191982, + 13.719473504332724, + 4.289551573391981, + 0.4892769066373272, + -1.2705446692075573, + -1.7342782110977626, + 2.1390999601633585 + ], + "sd": [ + 2.4681016211013227, + 1.1314580965774785, + 0.07600237069120615, + 0.03377725013151341, + 0.20696023136801145, + 0.48716519415630805, + 0.6891835800957763 + ], + "logz": -11.244794115029938, + "logz_err": 0.24432400793400602, + "wall_s": 1235.1236483319663 + }, + { + "seed": 3012, + "mean": [ + 43.82618671330784, + 13.712013743910662, + 4.287386037387245, + 0.48764838285548634, + -1.2690736324453133, + -1.7713433131278378, + 2.1877408582898097 + ], + "sd": [ + 1.618473522338044, + 1.0941782457124172, + 0.07263836579305594, + 0.025400928838897562, + 0.19709874745650957, + 0.4829717364183414, + 0.6903500798873458 + ], + "logz": -11.359427481097418, + "logz_err": 0.24167564734551947, + "wall_s": 1230.9246317869984 + }, + { + "seed": 3013, + "mean": [ + 43.53563777338296, + 13.73929461571445, + 4.298105296496811, + 0.4848102833565959, + -1.2783582426673028, + -1.8077589152729825, + 2.236928507586092 + ], + "sd": [ + 1.883474095053936, + 1.103666266176018, + 0.07565232949576496, + 0.02810285514022882, + 0.20798324027922827, + 0.48293385472976447, + 0.6596684552448862 + ], + "logz": -11.503004165066164, + "logz_err": 0.2401387228276592, + "wall_s": 1246.8475659950636 + }, + { + "seed": 3014, + "mean": [ + 43.807120444687484, + 13.693921367166137, + 4.288596905710254, + 0.48693533595894395, + -1.2622930032860495, + -1.7577138627891749, + 2.169840703513909 + ], + "sd": [ + 1.5399098921123302, + 1.0592050585166248, + 0.06968805133946548, + 0.023987291001009433, + 0.2023267760731105, + 0.49018499077737, + 0.6863471076709199 + ], + "logz": -11.084466496464758, + "logz_err": 0.24581791038631845, + "wall_s": 1193.0571655089734 + }, + { + "seed": 3015, + "mean": [ + 43.81172141688906, + 13.67673660208023, + 4.285694053148974, + 0.48798216107750375, + -1.249672204149435, + -1.7072199574829405, + 2.1308674709643576 + ], + "sd": [ + 1.7596440772631727, + 1.1218216924281672, + 0.07645741648147311, + 0.02774282394632116, + 0.20272473279912395, + 0.4841244978416692, + 0.6785596843879129 + ], + "logz": -12.193798815892638, + "logz_err": 0.24829451716794204, + "wall_s": 1283.1568422319833 + }, + { + "seed": 3016, + "mean": [ + 43.70387989866226, + 13.745520318127856, + 4.293728292080306, + 0.48592213775281917, + -1.278417041363774, + -1.7934715421955074, + 2.21353915535013 + ], + "sd": [ + 1.6715715928055548, + 1.0805003102006683, + 0.0734804872358054, + 0.02586239602686326, + 0.21037203918844183, + 0.4713779026648803, + 0.6557230339953096 + ], + "logz": -11.452006570599256, + "logz_err": 0.2259855021344347, + "wall_s": 1241.0421020310605 + }, + { + "seed": 3017, + "mean": [ + 43.914648504982814, + 13.67148857147585, + 4.282961295892786, + 0.4888065654357596, + -1.2519751106831911, + -1.694077456984327, + 2.114387366207379 + ], + "sd": [ + 1.6252898495921904, + 1.1050272943052923, + 0.07317554758058538, + 0.0253389345238508, + 0.1993368785667893, + 0.4775564800935445, + 0.6721596495022871 + ], + "logz": -11.73973717107672, + "logz_err": 0.2421789796056163, + "wall_s": 1219.2673423220403 + }, + { + "seed": 3018, + "mean": [ + 43.684703503154424, + 13.726532508372502, + 4.293579858908982, + 0.485739799935159, + -1.2723423058233612, + -1.7794652674949853, + 2.2020627015809047 + ], + "sd": [ + 1.6507173375315822, + 1.088767459039104, + 0.07279589012370569, + 0.02565688623886426, + 0.20515544907075484, + 0.4849925663126707, + 0.6810040041546508 + ], + "logz": -11.438718860915845, + "logz_err": 0.2416829222146869, + "wall_s": 1247.1665258139838 + }, + { + "seed": 3019, + "mean": [ + 43.552226628385824, + 13.746131220282406, + 4.300320234715255, + 0.4839276978751418, + -1.29912088346445, + -1.841749007255673, + 2.2638442948512543 + ], + "sd": [ + 1.654581885304905, + 1.1080296502186462, + 0.07352295995346364, + 0.025418149579137808, + 0.22121947162931938, + 0.47277174235042396, + 0.6450502778093485 + ], + "logz": -11.28587178204334, + "logz_err": 0.24865489170848115, + "wall_s": 2374.0736664300784 + }, + { + "seed": 3020, + "mean": [ + 43.732539970840016, + 13.690917267318765, + 4.284126790310573, + 0.4899936647676803, + -1.2574795715842682, + -1.6993013291509382, + 2.1081115462246904 + ], + "sd": [ + 2.0819750842478895, + 1.1697751923668545, + 0.07687912837062388, + 0.03403675950431354, + 0.20654761646778372, + 0.47846364785765044, + 0.6723719157980415 + ], + "logz": -12.076571775820007, + "logz_err": 0.2512981790914582, + "wall_s": 2698.916866186075 + }, + { + "seed": 3021, + "mean": [ + 43.78615560526788, + 13.68759382899415, + 4.286736399537174, + 0.4881491954726758, + -1.2672519256849206, + -1.7177770422528553, + 2.1203872290452512 + ], + "sd": [ + 1.8004411062461372, + 1.1450640777070926, + 0.07603397340977461, + 0.028926691178387937, + 0.2058763870320605, + 0.4812997522166705, + 0.656462493354124 + ], + "logz": -11.632774630574401, + "logz_err": 0.24048473404730733, + "wall_s": 1230.6493399753235 + }, + { + "seed": 3022, + "mean": [ + 43.53544780535106, + 13.73050656192565, + 4.300814248923584, + 0.4833540164621793, + -1.2861474178369703, + -1.8400313196518363, + 2.28133919429163 + ], + "sd": [ + 1.6784714050623375, + 1.090854228598583, + 0.07381488275572519, + 0.02559127973607512, + 0.21779853346446107, + 0.45614301684599645, + 0.6383068661534999 + ], + "logz": -11.149572195251087, + "logz_err": 0.23851036195312217, + "wall_s": 1218.6569001958705 + }, + { + "seed": 3023, + "mean": [ + 43.81416006963357, + 13.686154360137122, + 4.287716666329644, + 0.48751340645388413, + -1.2667703222434665, + -1.749390302880168, + 2.159951341086709 + ], + "sd": [ + 1.6409903918074311, + 1.0814290456713287, + 0.06970489341388623, + 0.025620087144759714, + 0.20208544390851974, + 0.46564548274017353, + 0.6639807735456031 + ], + "logz": -11.125878410684217, + "logz_err": 0.2292984255736507, + "wall_s": 1298.1542010549456 + }, + { + "seed": 3024, + "mean": [ + 43.28319592325252, + 13.806521466517598, + 4.294654460755931, + 0.4909841124236277, + -1.2804477800348626, + -1.7897516614420492, + 2.199793397334258 + ], + "sd": [ + 3.128813860591252, + 1.2033354326459451, + 0.07695938480252057, + 0.04325677163510923, + 0.21581826451129804, + 0.49865396664902056, + 0.7325145024209972 + ], + "logz": -11.540927853961145, + "logz_err": 0.23742179539410013, + "wall_s": 1322.2990707849385 + }, + { + "seed": 3025, + "mean": [ + 43.228312637394644, + 13.74045987549343, + 4.312040588216139, + 0.48108463179368616, + -1.2815195531316532, + -1.9324324616821094, + 2.406135250882503 + ], + "sd": [ + 2.211088276236884, + 1.0289244013253838, + 0.07563152550674591, + 0.028683993969307063, + 0.196584905034812, + 0.46369809494459363, + 0.6799093628726366 + ], + "logz": -10.955725927409414, + "logz_err": 0.2513640142554386, + "wall_s": 1266.3550127730705 + }, + { + "seed": 3026, + "mean": [ + 43.9653072903439, + 13.692851705878935, + 4.280915711930681, + 0.48955781936926007, + -1.2526814006323752, + -1.6895549190296588, + 2.105535240332168 + ], + "sd": [ + 1.5818169093431076, + 1.127081621957749, + 0.07175823538492003, + 0.024680392128826844, + 0.21076264016558302, + 0.4900251742191631, + 0.6755452986328606 + ], + "logz": -11.482314762511074, + "logz_err": 0.2525032963504758, + "wall_s": 1188.7009869210888 + }, + { + "seed": 3027, + "mean": [ + 43.237884365761246, + 13.710284415596076, + 4.294428485245295, + 0.49093815013993636, + -1.2728502346909376, + -1.743208386727275, + 2.1457859705122457 + ], + "sd": [ + 3.278531584921585, + 1.1681048072433362, + 0.08119318898776164, + 0.04382746592306667, + 0.21202846946434786, + 0.49648854134237486, + 0.7183500323436094 + ], + "logz": -12.043201957814523, + "logz_err": 0.24764806525200142, + "wall_s": 1297.1201639719075 + }, + { + "seed": 3028, + "mean": [ + 44.02763540582919, + 13.644462850974294, + 4.276488727650422, + 0.49105331462361645, + -1.2491787096936808, + -1.6390695512790139, + 2.047277261322359 + ], + "sd": [ + 1.7148526069740821, + 1.1623072339935536, + 0.07570163125184382, + 0.02778961540350414, + 0.20618265619125828, + 0.48459175183237596, + 0.6832761022624944 + ], + "logz": -12.032065310194248, + "logz_err": 0.24660316347530628, + "wall_s": 1251.5538921830012 + }, + { + "seed": 3029, + "mean": [ + 43.291155024181656, + 13.796398752412072, + 4.31206406869457, + 0.4800434812503849, + -1.2909337352807704, + -1.8782590618797301, + 2.3038729421569286 + ], + "sd": [ + 1.6220273201822708, + 1.0294542268662719, + 0.07038640436561884, + 0.024864033487750355, + 0.20612640180028657, + 0.4553672088979788, + 0.6477204192179822 + ], + "logz": -10.566432697254713, + "logz_err": 0.23647210477683506, + "wall_s": 1183.6415254999883 + }, + { + "seed": 3030, + "mean": [ + 43.588480952577804, + 13.701858999828428, + 4.295785385522357, + 0.48510122409948253, + -1.2489288058759875, + -1.7026286792301655, + 2.1316673983109427 + ], + "sd": [ + 1.8990135139198345, + 1.0641927539243992, + 0.07633923282547166, + 0.02748984157523734, + 0.21381503956942305, + 0.4883188604393866, + 0.6511242348013017 + ], + "logz": -11.454888968130936, + "logz_err": 0.23643365902992927, + "wall_s": 1275.9793411010178 + }, + { + "seed": 3031, + "mean": [ + 43.5325415323224, + 13.71621584701654, + 4.298950224877192, + 0.48425376546621557, + -1.2762998104671066, + -1.8307349690789685, + 2.2679165498297715 + ], + "sd": [ + 1.7204355190905178, + 1.0701019364510445, + 0.0735840116798548, + 0.028903209351044686, + 0.20466175726730398, + 0.4956467254698851, + 0.6955563273146662 + ], + "logz": -11.855265470717185, + "logz_err": 0.2490843635169071, + "wall_s": 1261.6493149530143 + }, + { + "seed": 3032, + "mean": [ + 43.80548828998113, + 13.664309785766964, + 4.286261639013012, + 0.48756050854627914, + -1.2634243799479214, + -1.7077633324013406, + 2.115194225175444 + ], + "sd": [ + 1.8328564157579392, + 1.1563976165796122, + 0.08184350031494599, + 0.02864355642532756, + 0.20893607771282424, + 0.4986895280249155, + 0.6885600800296213 + ], + "logz": -12.282501877796955, + "logz_err": 0.24856781011911944, + "wall_s": 1301.0490616718307 + }, + { + "seed": 3033, + "mean": [ + 43.901894705401496, + 13.677666748574735, + 4.278343308569338, + 0.49168815493319723, + -1.2546105670677565, + -1.6567095668881908, + 2.0574835015032016 + ], + "sd": [ + 2.170842123753842, + 1.2100324060414167, + 0.07774129967135439, + 0.03315669220868005, + 0.21123734394847446, + 0.4831610024357838, + 0.6702769572898939 + ], + "logz": -11.762480596073527, + "logz_err": 0.24624102948935644, + "wall_s": 1251.7857860750519 + }, + { + "seed": 3034, + "mean": [ + 43.47715595580879, + 13.674155125872248, + 4.296522904395616, + 0.4859004658367291, + -1.264331637328232, + -1.778214409627821, + 2.2088037311102404 + ], + "sd": [ + 2.188373395436522, + 1.1032697322415206, + 0.07476660525490007, + 0.032715625739426386, + 0.20201819902334567, + 0.45485899914448596, + 0.6438677774693808 + ], + "logz": -11.80875628777826, + "logz_err": 0.2485611576986709, + "wall_s": 1281.4383820788935 + }, + { + "seed": 3035, + "mean": [ + 43.83356801895904, + 13.673685588287075, + 4.280005489373067, + 0.4918980116268821, + -1.2571522044554038, + -1.7078951948985597, + 2.1372396513947094 + ], + "sd": [ + 2.2522214528722913, + 1.177610423780548, + 0.07704416281964468, + 0.03405131533542319, + 0.2115924165189924, + 0.4847560212983791, + 0.6734445754604994 + ], + "logz": -12.127051846396768, + "logz_err": 0.23495263357703966, + "wall_s": 1280.2561507229693 + }, + { + "seed": 3036, + "mean": [ + 43.63476607194968, + 13.704936666694827, + 4.295478800646791, + 0.484685934388037, + -1.2652595219137075, + -1.771495347722798, + 2.19752782254279 + ], + "sd": [ + 1.5921008223429276, + 1.082975473270905, + 0.07091654723024746, + 0.024691355190720382, + 0.20523970008909054, + 0.462326669705431, + 0.6583202620140526 + ], + "logz": -10.881899352497788, + "logz_err": 0.24818532136468935, + "wall_s": 1186.1582289150683 + }, + { + "seed": 3037, + "mean": [ + 43.75937472269489, + 13.648612371007424, + 4.288390931860504, + 0.48682292916974107, + -1.2626427583834905, + -1.7258316509503708, + 2.1387135805907875 + ], + "sd": [ + 1.828899666024829, + 1.139378735710667, + 0.07899562786103138, + 0.02817186098021161, + 0.21023177069777157, + 0.4859029430134008, + 0.6701291869472069 + ], + "logz": -11.899566974328277, + "logz_err": 0.24079455673778985, + "wall_s": 1252.7791947519872 + }, + { + "seed": 3038, + "mean": [ + 43.807420341295504, + 13.691236220908994, + 4.286186232882652, + 0.4876588628538749, + -1.2531506431318928, + -1.6760611771751486, + 2.069057113350925 + ], + "sd": [ + 1.6858945674377943, + 1.1270910505542393, + 0.07485139330407346, + 0.02600832328194021, + 0.2059451159764634, + 0.49649361660310454, + 0.7002223749827643 + ], + "logz": -11.962618196368858, + "logz_err": 0.24764865273221306, + "wall_s": 1236.8057141320314 + }, + { + "seed": 3039, + "mean": [ + 43.526297500209935, + 13.77134561683191, + 4.291547919557328, + 0.48906400552260726, + -1.2770463046068083, + -1.776657500211774, + 2.190598533165245 + ], + "sd": [ + 2.3819995354307526, + 1.1676043307223878, + 0.07470594013953263, + 0.03874956905316134, + 0.20683760545531427, + 0.4613166741111253, + 0.6576607141609135 + ], + "logz": -11.26250758497472, + "logz_err": 0.2297579112149907, + "wall_s": 1222.1656831169967 + }, + { + "seed": 3040, + "mean": [ + 43.38669814303522, + 13.854741569544217, + 4.3100021703444416, + 0.4812424126970997, + -1.3144481477205971, + -1.9260288758673694, + 2.3418109659846236 + ], + "sd": [ + 1.5450952855955364, + 1.0299547198126384, + 0.06989485300897316, + 0.023197568208786587, + 0.22840640060489528, + 0.47924151211528293, + 0.6517669459551966 + ], + "logz": -10.61516715926587, + "logz_err": 0.2395045382337993, + "wall_s": 1163.6777579180198 + }, + { + "seed": 3041, + "mean": [ + 43.64146099413022, + 13.702041241848734, + 4.296053521227209, + 0.4847617523420827, + -1.2721553299166675, + -1.8085806335150139, + 2.2432579907636114 + ], + "sd": [ + 1.6160234669765443, + 1.0685310497843297, + 0.07170117133468697, + 0.02479498231169865, + 0.21033434278980023, + 0.4848866737640874, + 0.6590504287373449 + ], + "logz": -11.457875374844054, + "logz_err": 0.2513213734621126, + "wall_s": 1211.2422900719102 + }, + { + "seed": 3042, + "mean": [ + 43.66416187414712, + 13.68025738193878, + 4.293621140388393, + 0.48568940876829236, + -1.267426398050301, + -1.7391961740590336, + 2.1474404138059358 + ], + "sd": [ + 1.7445494460436446, + 1.111245865314263, + 0.07169922031790557, + 0.027337789908082995, + 0.2055249241557467, + 0.46838123393190634, + 0.6717956141693314 + ], + "logz": -11.53699073324621, + "logz_err": 0.23903132168741692, + "wall_s": 1253.7491824120516 + }, + { + "seed": 3043, + "mean": [ + 43.71241974242191, + 13.706419292203684, + 4.2910124508836045, + 0.4864393779388837, + -1.2650822364979029, + -1.7537880077009589, + 2.1741985892648517 + ], + "sd": [ + 1.7375799786159203, + 1.0977543278669337, + 0.07669028135021949, + 0.027743100918445267, + 0.2064243668119189, + 0.49137256325013706, + 0.6782438031463593 + ], + "logz": -11.77475482955212, + "logz_err": 0.2387268524010463, + "wall_s": 1242.398315712111 + }, + { + "seed": 3044, + "mean": [ + 43.54083351383592, + 13.66172692112492, + 4.294814154790625, + 0.4862289553737458, + -1.2687101912774832, + -1.7432954703772157, + 2.154285568188953 + ], + "sd": [ + 2.19635004879517, + 1.096538275895466, + 0.0743925993218794, + 0.029345701301716192, + 0.21043149363689034, + 0.462651336638424, + 0.6562323545721466 + ], + "logz": -11.280988084099477, + "logz_err": 0.2371353816734623, + "wall_s": 1218.6381054650992 + }, + { + "seed": 3045, + "mean": [ + 43.7597906072468, + 13.70728307730612, + 4.288839979303332, + 0.4871899076285384, + -1.2570346984397722, + -1.699590966778598, + 2.1017890132565995 + ], + "sd": [ + 1.671872838274928, + 1.1146721669966586, + 0.07183420435144602, + 0.026620381712219397, + 0.20829548994364594, + 0.4977524691685829, + 0.6896055843881882 + ], + "logz": -11.204699585550665, + "logz_err": 0.24146684704867039, + "wall_s": 1269.402395599056 + }, + { + "seed": 3046, + "mean": [ + 43.60955226044399, + 13.674868136759324, + 4.296526075428371, + 0.484485589496908, + -1.2662485333973201, + -1.7779380637101514, + 2.215123180573599 + ], + "sd": [ + 1.7451553033059144, + 1.0928314827431047, + 0.0765258710845322, + 0.02716456143663582, + 0.20048760634951893, + 0.47400999683953887, + 0.6657340636169531 + ], + "logz": -11.495882486616084, + "logz_err": 0.2522541870950044, + "wall_s": 1293.348359940108 + }, + { + "seed": 3047, + "mean": [ + 43.56480786381398, + 13.794718697563699, + 4.287949224133771, + 0.4915847775113247, + -1.276728669789923, + -1.763290567709397, + 2.188722182040668 + ], + "sd": [ + 2.5516528853819738, + 1.2107074644011702, + 0.07410477893780702, + 0.0403161169593581, + 0.215735581949076, + 0.46529171671157304, + 0.6583807027181927 + ], + "logz": -11.321184905190824, + "logz_err": 0.2249335752441206, + "wall_s": 1244.0161672239192 + }, + { + "seed": 3048, + "mean": [ + 43.82376463048388, + 13.635449359332153, + 4.284666459665998, + 0.48835181508815073, + -1.2512036284795955, + -1.7308403860960024, + 2.1685415890378636 + ], + "sd": [ + 1.8622041445754913, + 1.1471967038218727, + 0.0793073804241348, + 0.029096813204289102, + 0.20353472645587178, + 0.5068687489141555, + 0.7236220850852049 + ], + "logz": -12.303954991131734, + "logz_err": 0.24624768865355226, + "wall_s": 1299.424837754108 + }, + { + "seed": 3049, + "mean": [ + 43.76879587192873, + 13.669720584089147, + 4.289036258329024, + 0.4867802100913037, + -1.2480165273423915, + -1.7226618779943277, + 2.162595752923612 + ], + "sd": [ + 1.6609462291858939, + 1.0977333618135647, + 0.07520060619362715, + 0.02626707239058236, + 0.2130348169783368, + 0.49680293936891107, + 0.6789077964039715 + ], + "logz": -11.60903610933466, + "logz_err": 0.24180623267430582, + "wall_s": 1251.5673218080774 + } + ] + }, + "corroborated": true, + "wall_s": 66745.42214257247 + }, + "omp": { + "method": "pocomc 8192/4096, 3 runs", + "mean": [ + 45.82003413211523, + 3.3512107320620435, + 3.959648030707045, + 0.7912198076983327, + 9.067020071244286, + 4.416048456581646, + 0.3219676115474195, + -1.6345880685013798, + -1.8532382049184835 + ], + "sd": [ + 2.5133017487386224, + 1.2588827489577652, + 0.13177586287033038, + 0.04582943233155777, + 1.163591939646596, + 0.10839286460470092, + 0.05988105579228054, + 0.12057862646819352, + 0.8461585984577359 + ], + "logz": -6.6476305808068, + "logz_err": 0.04285668527886685, + "mode_share": 0.1310603387786808, + "mode_share_label": "share away from the MAP island", + "max_disagreement": 0.01827390768580351, + "accepted": true, + "runs": [ + { + "seed": 2000, + "mean": [ + 45.83690023007923, + 3.3499479652623574, + 3.9593525662306273, + 0.7913258315476238, + 9.087755914411451, + 4.415845255029297, + 0.32130909164955024, + -1.6348678271767232, + -1.8600525749738654 + ], + "sd": [ + 2.491160434438235, + 1.2563769597671544, + 0.13032522516764705, + 0.04564899098723714, + 1.1476523528968996, + 0.10719830112514711, + 0.058796732492895146, + 0.12081510732177256, + 0.8351708187731082 + ], + "logz": -6.625555110790021, + "logz_err": 0.04285668527886685, + "wall_s": 1346.1900505349913, + "mode_share": 0.1296755210222584 + }, + { + "seed": 2001, + "mean": [ + 45.82916664790854, + 3.357775211074856, + 3.958704981568321, + 0.7914083607384362, + 9.05659244602436, + 4.415832632219078, + 0.32232178445231274, + -1.6351207382497588, + -1.8473968649380048 + ], + "sd": [ + 2.5130322877143128, + 1.264028838090728, + 0.13254790456832388, + 0.046000095104070396, + 1.1669222119545026, + 0.1085316299053715, + 0.060097863418464875, + 0.12091333500702547, + 0.8512827653192674 + ], + "logz": -6.660922779454295, + "logz_err": 0.009755565591117104, + "wall_s": 1377.9200871120265, + "mode_share": 0.1324468933466646 + }, + { + "seed": 2002, + "mean": [ + 45.79403551835792, + 3.345909019848918, + 3.9608865443221863, + 0.7909252308089381, + 9.056711853297045, + 4.416467482496564, + 0.3222719585403955, + -1.6337756400776575, + -1.8522651748435808 + ], + "sd": [ + 2.5353109583264497, + 1.2561976608776715, + 0.1324330480971392, + 0.04583708004348447, + 1.1757466837087716, + 0.10943575916427457, + 0.06072694521457943, + 0.12000111958333923, + 0.8518679325415246 + ], + "logz": -6.656413852176085, + "logz_err": 0.012252888546165389, + "wall_s": 1586.5622286959842, + "mode_share": 0.13105860196711935 + } + ], + "names": [ + "Vv", + "Wv", + "Rv", + "av", + "Wd", + "Rd", + "ad", + "log_sigma_A", + "log_sigma_B" + ], + "corroboration": { + "method": "dynesty {'nlive': 1000, 'sample': 'rslice'}, 3 runs pooled", + "mean": [ + 45.88273325162775, + 3.3118923117396544, + 3.9572922728635898, + 0.7923348665165576, + 9.117057263661504, + 4.417902253132129, + 0.3202943773487728, + -1.6318750632690577, + -1.8658383987339384 + ], + "sd": [ + 2.4864870387002194, + 1.252583482041367, + 0.12797338516395437, + 0.04501597064489701, + 1.1019006570189591, + 0.10147588391353503, + 0.05703789383284276, + 0.12192070363317091, + 0.853073329289609 + ], + "logz": -6.403841812903355, + "logz_err": 0.24871100128265677, + "mode_share": 0.12076328785862889, + "mode_share_label": "share away from the MAP island", + "bias": 0.04300235392865907, + "width": 0.06594108881888648, + "logz_combined_err": 0.252376420515296, + "checks": { + "log Z": true, + "moments": true, + "mode share": true + }, + "runs": [ + { + "seed": 3000, + "mean": [ + 46.34507836399587, + 3.3021781072839422, + 3.934218827283109, + 0.7990678859085422, + 9.238897902898843, + 4.425344550945001, + 0.3167147188606561, + -1.644011282984124, + -1.9133246581639793 + ], + "sd": [ + 2.434282497135053, + 1.2386771011002746, + 0.12274874132356249, + 0.04268930863897815, + 1.0051456817187017, + 0.08650722043039001, + 0.04933484603646904, + 0.12045464107179688, + 0.8281524165783354 + ], + "logz": -6.212821986919609, + "logz_err": 0.2316291405838807, + "wall_s": 2540.7718005697243, + "mode_share": 0.08722285490287002 + }, + { + "seed": 3001, + "mean": [ + 45.65211872111922, + 3.2409399617911943, + 3.969588516259301, + 0.7871140282685902, + 9.051565913971437, + 4.41269035842489, + 0.32608005075093294, + -1.6219744519558736, + -1.8837595212440095 + ], + "sd": [ + 2.5037838849794296, + 1.2385052790626514, + 0.13098277120937696, + 0.04559884633123559, + 1.2269570213319905, + 0.11099359625871304, + 0.062424531595431036, + 0.12447294806937895, + 0.8353099133405114 + ], + "logz": -6.710243989484923, + "logz_err": 0.22312147252441222, + "wall_s": 2837.3212025309913, + "mode_share": 0.1451228032396339 + }, + { + "seed": 3002, + "mean": [ + 45.65100266976815, + 3.3925588661438257, + 3.9680694750483583, + 0.7908226853725405, + 9.060707974114234, + 4.415671850026497, + 0.3180883624347295, + -1.629639454867176, + -1.8004310167938267 + ], + "sd": [ + 2.456123619680096, + 1.2755564106152009, + 0.12691766032048202, + 0.04585633638371601, + 1.050953994928581, + 0.10488785015375705, + 0.05812108349729781, + 0.11975320742314625, + 0.8903757644654113 + ], + "logz": -6.288459462305533, + "logz_err": 0.21569970074017808, + "wall_s": 2781.856348440051, + "mode_share": 0.12994420543338278 + } + ] + }, + "corroborated": true, + "wall_s": 12470.621717883769 + } +} \ No newline at end of file diff --git a/benchmarks/results/samplers.json b/benchmarks/results/samplers.json new file mode 100644 index 0000000..471706a --- /dev/null +++ b/benchmarks/results/samplers.json @@ -0,0 +1,2347 @@ +{ + "meta": { + "jax": "0.12.0.1", + "blackjax": "1.7.1" + }, + "problems": { + "linear": { + "ndim": 2, + "names": [ + "m", + "b" + ], + "samplers": { + "emcee": { + "wall_s": 5.751884620869532, + "calls": { + "search": 75, + "warmup": 128000, + "sampling": 256000, + "evidence": 0 + }, + "min_ess": 7619.306420139592, + "min_ess_tail": 21023.231275396083, + "max_rhat": 1.005523011334059, + "mean": [ + 2.0476058556005428, + 0.963726969388148 + ], + "sd": [ + 0.05422236037479533, + 0.08841381993978638 + ], + "mcse": [ + 0.0006211846269423508, + 0.0010072977950586984 + ], + "walkers": 32, + "steps": 12000, + "tau": 32.526117345213194, + "tau_reliable": true, + "start_search_s": 0.2530290570575744, + "start": "map" + }, + "dynesty": { + "wall_s": 34.33870627207216, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 93609, + "evidence": 0 + }, + "min_ess": 1605.4390512454213, + "logz": 0.6943274825751568, + "logz_err": 0.23955699494970095, + "mean": [ + 2.046586969665276, + 0.9657277739969466 + ], + "sd": [ + 0.055368740874417, + 0.09030349955283723 + ], + "mcse": [ + 0.0013818717423264555, + 0.0022537600150288667 + ], + "start": "prior" + }, + "pocomc": { + "wall_s": 26.87749108998105, + "calls": { + "search": 0, + "warmup": 37376, + "sampling": 12288, + "evidence": 4096 + }, + "min_ess": 4292.430780405221, + "logz": 0.5605443554099239, + "logz_err": 0.06408536848894843, + "mean": [ + 2.0469725986417595, + 0.9653159032649905 + ], + "sd": [ + 0.05406378432943437, + 0.08774677060124386 + ], + "mcse": [ + 0.000825191587219625, + 0.0013393050043375367 + ], + "start": "prior" + }, + "NUTS": { + "wall_s": 5.5108118589269, + "calls": { + "search": 75, + "warmup": 30616, + "sampling": 31454, + "evidence": 0 + }, + "min_ess": 731.5705370453154, + "min_ess_tail": 1027.2901540056168, + "max_rhat": 1.0034417053280837, + "mean": [ + 2.049294715833188, + 0.9610976422582483 + ], + "sd": [ + 0.05346391605352642, + 0.08862894496188967 + ], + "mcse": [ + 0.0019652759165478878, + 0.0032767814485383812 + ], + "divergences": 0, + "warmup": 1000, + "draws": 1000, + "start_search_s": 0.23100660694763064, + "start": "map" + } + } + }, + "gp": { + "ndim": 4, + "names": [ + "m", + "b", + "discrepancy_k1__constant_value", + "discrepancy_k2__length_scale" + ], + "samplers": { + "emcee": { + "wall_s": 18.01441535889171, + "calls": { + "search": 329, + "warmup": 32000, + "sampling": 64000, + "evidence": 0 + }, + "min_ess": 431.30949558722364, + "min_ess_tail": 217.42003627099714, + "max_rhat": 1.0619654689549818, + "mean": [ + 1.9890930342210722, + 1.0009598688806478, + -8.530915226761058, + -0.5247928061076327 + ], + "sd": [ + 0.04818373622326732, + 0.15230361942914228, + 2.579101633252545, + 1.1351954608223078 + ], + "mcse": [ + 0.0023200960404265664, + 0.0072919978588313695, + 0.11174833888575132, + 0.041359018521147616 + ], + "walkers": 32, + "steps": 3000, + "tau": 81.51159258084026, + "tau_reliable": false, + "start_search_s": 1.1421969069633633, + "start": "map" + }, + "dynesty": { + "wall_s": 70.8777202720521, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 139598, + "evidence": 0 + }, + "min_ess": 2576.3075034731405, + "logz": 80.26924973436864, + "logz_err": 0.27653555154059467, + "mean": [ + 1.9862696498030554, + 1.0074103122136013, + -7.790187960505114, + -0.33909299048181407 + ], + "sd": [ + 0.07175068872064058, + 0.1765922298854126, + 2.894644818621186, + 1.0958623850108262 + ], + "mcse": [ + 0.00141360224081386, + 0.0034791466998772367, + 0.057029088848118956, + 0.021590225135069543 + ], + "start": "prior" + }, + "pocomc": { + "wall_s": 72.60820942395367, + "calls": { + "search": 0, + "warmup": 71168, + "sampling": 24576, + "evidence": 4096 + }, + "min_ess": 4481.75990420192, + "logz": 80.23638046333384, + "logz_err": 0.040784806054603835, + "mean": [ + 1.9840719290228273, + 1.003421829364101, + -6.708981706507074, + -0.4858226801928048 + ], + "sd": [ + 0.09682940615746213, + 0.24183562481117393, + 2.8776090449386076, + 1.0878433094605005 + ], + "mcse": [ + 0.001446381888434717, + 0.003612401248607877, + 0.042984066202231615, + 0.01624957668024792 + ], + "start": "prior" + }, + "NUTS": { + "wall_s": 210.93266720697284, + "calls": { + "search": 329, + "warmup": 166275, + "sampling": 78849, + "evidence": 0 + }, + "min_ess": 360.9244368641358, + "min_ess_tail": 310.5888138840718, + "max_rhat": 1.0178840759200083, + "mean": [ + 1.9814943686813002, + 1.0204125546474536, + -8.352962264371532, + -0.5162881905372352 + ], + "sd": [ + 0.059149405756690816, + 0.12576374386369804, + 2.644797727628307, + 1.1319552047444252 + ], + "mcse": [ + 0.001915546255039725, + 0.00443246101780241, + 0.13921445108156363, + 0.04708338634377505 + ], + "divergences": 31, + "warmup": 1000, + "draws": 1000, + "start_search_s": 1.1421969069633633, + "start": "map" + } + } + }, + "elastic": { + "ndim": 5, + "names": [ + "Vv", + "Wv", + "Rv", + "av", + "log_c" + ], + "samplers": { + "emcee": { + "wall_s": 161.74304080707952, + "calls": { + "search": 212, + "warmup": 16000, + "sampling": 32000, + "evidence": 0 + }, + "min_ess": 374.5299241000524, + "min_ess_tail": 1461.2552650677449, + "max_rhat": 1.0706704537180376, + "mean": [ + 47.6476448236025, + 3.5014694059163554, + 4.123832805485592, + 0.6922878288341151, + -3.0824715193415044 + ], + "sd": [ + 0.1534027977662727, + 0.03385638889520301, + 0.00832853204587029, + 0.0036736058210115946, + 0.09457446398761823 + ], + "mcse": [ + 0.006525344246921467, + 0.0017494332370931035, + 0.00035407745889031654, + 0.00015060942851586326, + 0.0038662320376691354 + ], + "walkers": 32, + "steps": 1500, + "tau": 41.27172558665897, + "tau_reliable": false, + "start_search_s": 6.101493319962174, + "start": "map" + }, + "dynesty": { + "wall_s": 646.3123045129469, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 232479, + "evidence": 0 + }, + "min_ess": 2398.888780871301, + "logz": 495.8810290498452, + "logz_err": 0.3389015848051943, + "mean": [ + 47.65561986116824, + 3.5022117642859096, + 4.123151378709859, + 0.692404224813916, + -3.081321858876649 + ], + "sd": [ + 0.1514539340418415, + 0.032159938452550656, + 0.008268825019834065, + 0.003581087310107125, + 0.09251603318704359 + ], + "mcse": [ + 0.003092256435400842, + 0.0006566140210958208, + 0.00016882577228876378, + 7.311556712255348e-05, + 0.001888912960962496 + ], + "start": "prior" + }, + "pocomc": { + "wall_s": 312.1209353999002, + "calls": { + "search": 0, + "warmup": 68096, + "sampling": 12288, + "evidence": 4096 + }, + "min_ess": 4500.878638951258, + "logz": 495.9510794680431, + "logz_err": 0.008473665836485102, + "mean": [ + 47.65201698398503, + 3.501864408240275, + 4.123404005764285, + 0.6922378123191555, + -3.0832672534743524 + ], + "sd": [ + 0.15069961395064224, + 0.031899740676498735, + 0.00834530800586042, + 0.0035833072400545374, + 0.09450630312195336 + ], + "mcse": [ + 0.0022462779208502056, + 0.00047548683957435536, + 0.00012439236322395924, + 5.341157635343028e-05, + 0.0014086792694342932 + ], + "start": "prior" + }, + "NUTS": { + "wall_s": 324.2278139409609, + "calls": { + "search": 212, + "warmup": 25760, + "sampling": 23012, + "evidence": 0 + }, + "min_ess": 672.6131035973871, + "min_ess_tail": 730.0091509719899, + "max_rhat": 1.0034198427829317, + "mean": [ + 47.66369978308773, + 3.501867269803845, + 4.122849186785542, + 0.6924552171506095, + -3.0819297827718115 + ], + "sd": [ + 0.15011269294910462, + 0.03274791479314341, + 0.00826912320094101, + 0.0035844752570495853, + 0.0928400853201299 + ], + "mcse": [ + 0.005788083052716493, + 0.000963123534015013, + 0.00031443471235444685, + 0.0001337757680486569, + 0.0026510785684523445 + ], + "divergences": 0, + "warmup": 500, + "draws": 500, + "start_search_s": 6.101493319962174, + "start": "map" + } + } + }, + "hierarchy": { + "ndim": 33, + "names": [ + "m", + "mu", + "tau", + "eta_0", + "eta_1", + "eta_2", + "eta_3", + "eta_4", + "eta_5", + "eta_6", + "eta_7", + "eta_8", + "eta_9", + "eta_10", + "eta_11", + "eta_12", + "eta_13", + "eta_14", + "eta_15", + "eta_16", + "eta_17", + "eta_18", + "eta_19", + "eta_20", + "eta_21", + "eta_22", + "eta_23", + "eta_24", + "eta_25", + "eta_26", + "eta_27", + "eta_28", + "eta_29" + ], + "samplers": { + "emcee": { + "wall_s": 10.771327713038772, + "calls": { + "search": 0, + "warmup": 136000, + "sampling": 272000, + "evidence": 0 + }, + "min_ess": 126.38198085374317, + "min_ess_tail": 202.6664186901459, + "max_rhat": 1.5035074656816505, + "mean": [ + 0.8027910514503115, + 0.9502511591023681, + 0.3711006207986874, + -0.5162715516642639, + -0.3083351281290607, + -0.6380428200274079, + -0.406638573813322, + 0.40016841956102367, + -0.9577210900089389, + -0.7244617580578222, + -1.6508203218851112, + -0.06910246645760611, + 0.23830865486924682, + 0.8971018590089489, + 0.30445310271723675, + 0.07261456627929655, + 0.7472257416654987, + -0.8590000207796584, + -0.008539381622517224, + -0.3058208230560939, + 0.3237524382430236, + 1.5474548281853384, + -0.3556560195973728, + 1.4106116075856372, + 0.12792913994006694, + 0.9932400448860456, + 0.6991255296992893, + 0.2765106597717161, + 0.09157371663491914, + -0.11293711119045885, + 0.4782948068774634, + -1.0753202618313813, + -1.868953285658783 + ], + "sd": [ + 0.02615074729498565, + 0.06954127853138593, + 0.07834005728406221, + 0.19695900237771666, + 0.21214011724186763, + 0.24196374389941053, + 0.20936838709212865, + 0.23030657336238797, + 0.2625546922505471, + 0.2502760120441757, + 0.3287612449529705, + 0.2239947380060947, + 0.22102685608950087, + 0.3314343041323715, + 0.25130068039616243, + 0.20451909975361637, + 0.30614912085571894, + 0.31229471876766884, + 0.2064749207353514, + 0.2653248280908834, + 0.23165126372241554, + 0.42635396287036637, + 0.2102916388282893, + 0.4469471115007518, + 0.2822084629015122, + 0.37795950306146714, + 0.41236998045914264, + 0.24212522442268564, + 0.20729489259215234, + 0.22715056694468988, + 0.275754517464038, + 0.2518254016960398, + 0.35225599893448406 + ], + "mcse": [ + 0.0013791765122627597, + 0.005001258789988069, + 0.006776410958348318, + 0.011721074772479719, + 0.013416053431865567, + 0.018126756766243545, + 0.013248308368842875, + 0.01607335111274055, + 0.01995129549943328, + 0.017746981173901163, + 0.025528220420706158, + 0.014081741952936754, + 0.014753477188754983, + 0.024429336863169778, + 0.018515285376835604, + 0.013220452805745863, + 0.02416102005944163, + 0.025202755559803235, + 0.013847818540852532, + 0.016406311453988142, + 0.01623962920669497, + 0.03684030134956836, + 0.01397309185252729, + 0.03975699543155619, + 0.021835875911066407, + 0.032225259707530325, + 0.03396914034307456, + 0.015764819921593218, + 0.012719007253212115, + 0.01547664224875595, + 0.019626329449527597, + 0.014815653957332725, + 0.028413257720531687 + ], + "walkers": 68, + "steps": 6000, + "tau": 518.089753690494, + "tau_reliable": false, + "start": "prior" + }, + "dynesty": { + "wall_s": 4256.048463908024, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 1926706, + "evidence": 0 + }, + "min_ess": 6371.733989842281, + "logz": 76.23058286177901, + "logz_err": 0.5525016858702801, + "mean": [ + 0.803216049779778, + 0.9295994438765431, + 0.3086324906402463, + -0.5426919312408629, + -0.2760577505684509, + -0.7748951460792335, + -0.4697632614168194, + 0.4755743681240099, + -1.124763962380327, + -0.8589483813643186, + -1.8899500290504818, + -0.0644812079979702, + 0.18449714591854782, + 1.1111607735355717, + 0.4248047722601464, + 0.08603437834164333, + 0.9533501753307364, + -1.0991907190780834, + 0.004988573016460784, + -0.2378740846172056, + 0.39907028998065885, + 1.8826461521238496, + -0.37450967637973015, + 1.8138772998107198, + 0.2671443864641538, + 1.2942764116837189, + 1.034916795014615, + 0.35364055042683135, + 0.13066128587543963, + -0.036804928281228465, + 0.6099591020286105, + -1.137110114722166, + -2.1237194511264406 + ], + "sd": [ + 0.02306128885042992, + 0.0535703323155546, + 0.03938696768255649, + 0.22502001428376878, + 0.2203416714041414, + 0.23888891473592203, + 0.2241620269037746, + 0.22875317520250832, + 0.25645704357169846, + 0.24401753511040472, + 0.30598832695906, + 0.21614118074627073, + 0.21186143194539492, + 0.25752456772235643, + 0.23032270679358383, + 0.22098792222857272, + 0.24782292278190768, + 0.25162137369756793, + 0.21747036713733492, + 0.2177135132168783, + 0.22482211447711195, + 0.3161534715742561, + 0.21514904780744967, + 0.3146534753869201, + 0.22174985899606203, + 0.2647628783521715, + 0.2543630416704517, + 0.21923535085741214, + 0.21828809903547025, + 0.2156797129407932, + 0.23022254321680496, + 0.2546213494582728, + 0.32615692007372155 + ], + "mcse": [ + 0.0002889047998956711, + 0.0006711128002579692, + 0.0004934279298363723, + 0.0028189821748822743, + 0.0027603733207870753, + 0.0029927275338641345, + 0.0028082335704162405, + 0.002865750077370373, + 0.00321281569887347, + 0.0030569773272143947, + 0.0038333285248656167, + 0.0027077508537234818, + 0.0026541354647944405, + 0.0032261893161560913, + 0.002885412690903838, + 0.002768469354201585, + 0.0031046500644534725, + 0.0031522359001289967, + 0.002724402495824886, + 0.0027274485558222905, + 0.002816502946404959, + 0.003960674359264159, + 0.0026953217145708947, + 0.0039418828640811615, + 0.002778014665860979, + 0.0033168686661981615, + 0.00318658268110137, + 0.002746513674075815, + 0.002734646791880121, + 0.0027019697256666564, + 0.0028841578721340018, + 0.0031898186823602747, + 0.004085994513993969 + ], + "start": "prior" + }, + "pocomc": { + "wall_s": 3410.4384390990017, + "calls": { + "search": 0, + "warmup": 611328, + "sampling": 47616, + "evidence": 4096 + }, + "min_ess": 4294.9780676311575, + "logz": 73.87843433287414, + "logz_err": 0.1718412218882078, + "mean": [ + 0.8040008138002168, + 0.9334594443534312, + 0.3250115363172606, + -0.5211300949696517, + -0.26252627513362753, + -0.7386372162548869, + -0.4543069503232156, + 0.4345618173511661, + -1.0974421091362883, + -0.8197337025944115, + -1.78059201699897, + -0.07301651667974984, + 0.15462629446330445, + 1.0284176294163703, + 0.3935827516812709, + 0.05100460408920303, + 0.8881832680173047, + -1.0445627236323443, + -0.00803667987272235, + -0.23490120456608582, + 0.381937299587742, + 1.7499311781723241, + -0.38035362422430913, + 1.6918756672791624, + 0.23299745266373478, + 1.191602249887226, + 0.9331462757920566, + 0.32450281337718223, + 0.1037716075571193, + -0.05653220537532838, + 0.5642763254146665, + -1.0861867890507113, + -2.0091730567794857 + ], + "sd": [ + 0.02234772940721588, + 0.05131855635337766, + 0.0400236776506804, + 0.20805233962227856, + 0.20331940900896475, + 0.21293817221319625, + 0.20310454168190736, + 0.20276410433820924, + 0.24123654632004082, + 0.22405541272292406, + 0.2874195680372004, + 0.2045268347569059, + 0.19489812656848104, + 0.2237883895519909, + 0.206602259568763, + 0.20282580768691028, + 0.22920908084070782, + 0.23863708441799855, + 0.20130679477666005, + 0.19945456675303505, + 0.20639810576728665, + 0.27460466973286934, + 0.2050416261274661, + 0.2713318795864637, + 0.2011265345617283, + 0.23480255737432135, + 0.22476473341772632, + 0.20219693982020315, + 0.20168887777032166, + 0.19961377198511096, + 0.20166442228317097, + 0.23824503433679897, + 0.29839970739601074 + ], + "mcse": [ + 0.00034099886144405955, + 0.0007830580444474211, + 0.0006107120889551869, + 0.0031746227833357467, + 0.0031024040840207, + 0.003249174578748629, + 0.003099125472912028, + 0.0030939308178095453, + 0.003680972958589234, + 0.0034188099939238678, + 0.004385669061563915, + 0.00312082791571401, + 0.0029739056727603346, + 0.0034147355487930803, + 0.0031524963454215714, + 0.0030948723350111783, + 0.003497448630019818, + 0.003641308367488654, + 0.0030716940664955905, + 0.0030434313452283924, + 0.003149381209534861, + 0.004190129476683881, + 0.0031286829987984496, + 0.004140190724816351, + 0.0030689435173487252, + 0.0035827982015454334, + 0.00342963335521122, + 0.003085276584917809, + 0.0030775241829893796, + 0.0030458606212360162, + 0.0030771510223374632, + 0.003635326165499268, + 0.004553212481820401 + ], + "start": "prior" + }, + "NUTS": { + "wall_s": 40.77717145695351, + "calls": { + "search": 0, + "warmup": 120315, + "sampling": 286352, + "evidence": 0 + }, + "min_ess": 535.8246348436193, + "min_ess_tail": 1060.3876039252514, + "max_rhat": 1.0056386798269044, + "mean": [ + 0.8033484025623592, + 0.9256971003602739, + 0.3110838982702691, + -0.5322059263416608, + -0.25766569081356594, + -0.7649395192096277, + -0.45459411322482507, + 0.48284913630510073, + -1.1217194223088869, + -0.8409282536694709, + -1.8630540706769425, + -0.04567983210685972, + 0.18691823021628973, + 1.1173869531456047, + 0.43444407942014746, + 0.09235096483429857, + 0.963407401701028, + -1.0791507710752524, + 0.023998605564975448, + -0.22840832538591, + 0.4223232232661158, + 1.8810884368807086, + -0.3616643117210727, + 1.8203640802684304, + 0.2796806211324334, + 1.2949151983347076, + 1.0256829236574136, + 0.3640304268004758, + 0.1406421021544462, + -0.029565190765842585, + 0.6205818429216325, + -1.1164054324754584, + -2.1064172668834185 + ], + "sd": [ + 0.023166919943200553, + 0.05936465251067829, + 0.04425880280383768, + 0.2442538891998871, + 0.23866339340159765, + 0.2552031634142391, + 0.24146483993445814, + 0.24428179969511865, + 0.27838875228509125, + 0.25824106755923365, + 0.3409333229238375, + 0.2348230092005369, + 0.23511669384889897, + 0.2757492840973589, + 0.2403076351081507, + 0.2337680793207468, + 0.2670011945213993, + 0.2748494387560378, + 0.2338551564908469, + 0.234808004839924, + 0.2386932294747579, + 0.34101700774571253, + 0.23824666403495656, + 0.3352080221533983, + 0.23498243484811454, + 0.2899526501346479, + 0.26948000058595784, + 0.2379518979769217, + 0.23465772200282303, + 0.23294515518448405, + 0.24710686076553637, + 0.27534904060617366, + 0.3656608398410779 + ], + "mcse": [ + 0.0003086025065960531, + 0.00256458201131982, + 0.0016074666483472254, + 0.00853594496202279, + 0.008367077072152075, + 0.008871441681300484, + 0.008670889005756768, + 0.00859341902379646, + 0.010125067535965879, + 0.009189246772798745, + 0.012563195544206785, + 0.008044957058828302, + 0.00833242994442667, + 0.009768914066656361, + 0.008593601781648304, + 0.008110213167063477, + 0.009632982064946288, + 0.009788493002450785, + 0.008032245936328699, + 0.007964630197402801, + 0.008485123350124286, + 0.012322759531167436, + 0.008139219222312978, + 0.012310342317672961, + 0.008216829023212382, + 0.010352647905080635, + 0.009700424634466865, + 0.008211902911953733, + 0.007985704981953565, + 0.008042325695760159, + 0.008633905963924679, + 0.009651277111882368, + 0.013424551102964968 + ], + "divergences": 0, + "warmup": 1000, + "draws": 3000, + "start": "prior" + } + } + }, + "modes": { + "ndim": 9, + "names": [ + "m", + "b", + "log_eta0", + "log_eta1", + "log_eta2", + "log_eta3", + "log_eta4", + "log_eta5", + "log_s" + ], + "samplers": { + "emcee": { + "wall_s": 9.58178106090054, + "calls": { + "search": 478, + "warmup": 32000, + "sampling": 64000, + "evidence": 0 + }, + "min_ess": 79.50532086804616, + "min_ess_tail": 54.81758861735301, + "max_rhat": 1.318685983808114, + "mean": [ + 1.9699701220882688, + 1.003594655270466, + -5.059522172164415, + -4.5938842495393954, + -4.947004273865318, + -4.712772009188851, + -4.613833733554773, + -4.6972536677945005, + -2.7738484757739617 + ], + "sd": [ + 0.1551184797400631, + 0.02585798231779662, + 0.9462733008698329, + 1.1326181780401712, + 0.9276191845517036, + 1.0094512599043888, + 1.1390953692552512, + 1.072729580700837, + 1.761880663985657 + ], + "mcse": [ + 0.01562659009649777, + 0.002101012529740489, + 0.09982941469677363, + 0.10235351030152215, + 0.09008689170651349, + 0.08470020038957275, + 0.10861519236904595, + 0.09691858568354282, + 0.19759611067927224 + ], + "walkers": 32, + "steps": 3000, + "tau": 176.50239334506426, + "tau_reliable": false, + "start_search_s": 2.1909321469720453, + "start": "map" + }, + "dynesty": { + "wall_s": 92.07290192192886, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 222314, + "evidence": 0 + }, + "min_ess": 3826.916669847732, + "logz": 103.17722522146175, + "logz_err": 0.28635000644602604, + "mean": [ + 1.9822840612312882, + 0.9996290502579623, + -4.6071520783186175, + -4.648625889158654, + -4.7041997915132425, + -4.637879384373065, + -4.639013158446257, + -4.597844508029893, + -3.179745538506487 + ], + "sd": [ + 0.09760981515670632, + 0.025635916123473875, + 1.0874876577913604, + 1.0401656019436514, + 1.0067467451507115, + 1.0414688502903136, + 1.0342080207249558, + 1.100507503141126, + 1.6849072026538778 + ], + "mcse": [ + 0.0015778618925607177, + 0.00041440438205084723, + 0.017579229415651713, + 0.01681426875590806, + 0.016274053199287358, + 0.016835335755158488, + 0.016717964502470803, + 0.017789695113096665, + 0.027236511648961726 + ], + "start": "prior" + }, + "pocomc": { + "wall_s": 130.16772677295376, + "calls": { + "search": 0, + "warmup": 56832, + "sampling": 30208, + "evidence": 4096 + }, + "min_ess": 4207.126681619904, + "logz": 102.71127859570015, + "logz_err": 0.07749626851596199, + "mean": [ + 1.9626580841289534, + 1.0036603309083483, + -4.519273696671407, + -4.611833933927941, + -4.540371001413093, + -4.512136767727362, + -4.580197362946662, + -4.52234598693987, + -1.9370408070139111 + ], + "sd": [ + 0.16346358320784626, + 0.02587119283637139, + 1.0663761065700605, + 1.0372405469244295, + 1.075469927031885, + 1.0679016640166863, + 1.0559929801794454, + 1.085243214105966, + 1.3455106046299934 + ], + "mcse": [ + 0.0025201606140705856, + 0.00039886291457557303, + 0.016440598026942106, + 0.015991407519509872, + 0.01658079982424505, + 0.016464117943219725, + 0.016280518664511436, + 0.01673147713518339, + 0.02074408724597226 + ], + "start": "prior" + }, + "NUTS": { + "wall_s": 61.353238494019024, + "calls": { + "search": 478, + "warmup": 235209, + "sampling": 104786, + "evidence": 0 + }, + "min_ess": 851.3780552716622, + "min_ess_tail": 484.56914146177377, + "max_rhat": 1.0076271733907476, + "mean": [ + 1.9794631901965671, + 1.0017212286341577, + -4.6472249976102065, + -4.638347952072286, + -4.6329195547061195, + -4.6445158877848005, + -4.6581482126410565, + -4.631417399931555, + -2.9255270947776255 + ], + "sd": [ + 0.12496721825416116, + 0.026062168173662068, + 1.0893226947360468, + 1.0671045602108393, + 1.0884503530150111, + 1.1017008950188112, + 1.0467758048874933, + 1.0945344119610292, + 1.714783470603872 + ], + "mcse": [ + 0.003789130603529543, + 0.0004316333072638536, + 0.016939182640779878, + 0.018831104123845213, + 0.020320478755371647, + 0.021486292411171965, + 0.017979468165540104, + 0.018348104842372977, + 0.05876896775534618 + ], + "divergences": 2, + "warmup": 1000, + "draws": 1000, + "start_search_s": 2.1909321469720453, + "start": "map" + } + } + }, + "alpha_gp": { + "ndim": 9, + "names": [ + "V", + "W", + "r", + "a", + "log_sigma_A", + "log_sigma_B", + "log_ell", + "log_A_q", + "p" + ], + "samplers": { + "emcee": { + "wall_s": 166.165595975006, + "calls": { + "search": 1744, + "warmup": 32000, + "sampling": 64000, + "evidence": 0 + }, + "min_ess": 53.37927341605181, + "min_ess_tail": 389.76467484476353, + "max_rhat": 1.6048051058274935, + "mean": [ + 169.63243123940967, + 27.451191870235014, + 1.2843067812400888, + 0.6056368657184741, + -0.7397550923444113, + -0.9474784886521671, + -3.5764775426791067, + 0.6774217069894385, + 9.862864905741365 + ], + "sd": [ + 4.611952770878312, + 1.8021585740993236, + 0.020606193535398016, + 0.01442123744551132, + 0.1089701106364004, + 0.7765059647343666, + 0.24314379657717025, + 0.054392975262741595, + 3.1928660852770103 + ], + "mcse": [ + 0.2979854152886711, + 0.13102004051610847, + 0.0014592288085324978, + 0.0010075951933882481, + 0.007155140492782249, + 0.04258418424211884, + 0.013508076515018131, + 0.007444859156939617, + 0.19594113080973632 + ], + "walkers": 32, + "steps": 3000, + "tau": 163.97415864496037, + "tau_reliable": false, + "start_search_s": 8.633430437999777, + "start": "map" + }, + "dynesty": { + "wall_s": 583.9535172400065, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 274264, + "evidence": 0 + }, + "min_ess": 3620.3903008264865, + "logz": -84.61087809698172, + "logz_err": 0.3102913374579773, + "mean": [ + 163.02837684354068, + 27.778174525440996, + 1.2889133919149358, + 0.6074284263254781, + -0.7186881645020988, + -0.9026900969906381, + -3.7161723304147256, + 0.3575584524023259, + 8.001019521109765 + ], + "sd": [ + 15.482998157195711, + 2.0803218210278915, + 0.0229305639624505, + 0.016236986764532654, + 0.10586897612534911, + 0.7480571339949461, + 0.2873481775835243, + 0.24141178083816545, + 3.289118425082392 + ], + "mcse": [ + 0.2573222651451831, + 0.034574254791153794, + 0.00038109832475385224, + 0.0002698533043123895, + 0.0017595070714721511, + 0.012432460058656848, + 0.004775630868803581, + 0.004012183276605166, + 0.0546640511663183 + ], + "start": "prior" + }, + "pocomc": { + "wall_s": 1048.4590793251991, + "calls": { + "search": 0, + "warmup": 438272, + "sampling": 0, + "evidence": 4096 + }, + "min_ess": 7624.787567236035, + "logz": -84.52805111876745, + "logz_err": 0.01451255179244961, + "mean": [ + 156.60965185420247, + 27.083739424565632, + 1.294941360357847, + 0.608973291874042, + -0.7212795636302209, + -0.9289959437922514, + -3.709787847137401, + 0.3673958819488922, + 7.915460039017284 + ], + "sd": [ + 20.24651456794636, + 2.4271554714157815, + 0.025518287909190925, + 0.016809943592638824, + 0.10433998758984042, + 0.7550012728491438, + 0.2857228851302393, + 0.23659184764290847, + 3.32078148272165 + ], + "mcse": [ + 0.23186564026022985, + 0.027796090803792275, + 0.000292238653944751, + 0.00019250959570177984, + 0.0011949147072239364, + 0.008646369869686253, + 0.0032721345432268558, + 0.0027094797008134137, + 0.038030008674904026 + ], + "start": "prior" + }, + "NUTS": { + "wall_s": 779.6173506230116, + "calls": { + "search": 1744, + "warmup": 108660, + "sampling": 109428, + "evidence": 0 + }, + "min_ess": 704.7949092717204, + "min_ess_tail": 396.76858313875437, + "max_rhat": 1.0076293846263553, + "mean": [ + 169.0168508830326, + 27.999696465182623, + 1.2845393182084937, + 0.6052594888429003, + -0.7278653794150144, + -0.9550100927370497, + -3.710084307932723, + 0.39195581469525004, + 8.25236553664251 + ], + "sd": [ + 4.8395557823986675, + 1.95976936444366, + 0.021421555756394508, + 0.014979722768714695, + 0.1030637814184032, + 0.7589472840466936, + 0.2740234292867173, + 0.22864409361087518, + 3.452556915287604 + ], + "mcse": [ + 0.17313446170945632, + 0.06398860536087854, + 0.0007873493312907622, + 0.0005508456647427851, + 0.0027157253074529446, + 0.02019690305285082, + 0.00852530728313697, + 0.0086124875638174, + 0.12039766959383225 + ], + "divergences": 0, + "warmup": 300, + "draws": 1000, + "start_search_s": 8.92593070998555, + "start": "map" + }, + "ptemcee": { + "wall_s": 859.0433235039236, + "calls": { + "search": 1744, + "warmup": 170496, + "sampling": 341504, + "evidence": 0 + }, + "min_ess": 62.5228182443612, + "min_ess_tail": 646.6770734798642, + "max_rhat": 1.446638683250899, + "mean": [ + 162.4243294042789, + 26.697427154414378, + 1.2902798062781693, + 0.607937679973119, + -0.7301546716060922, + -0.9774685473939297, + -3.546702538079116, + 0.6931083464785269, + 9.833075369735115 + ], + "sd": [ + 17.223396948892123, + 2.169207624491634, + 0.02592758210923228, + 0.017012167734316942, + 0.1037235172018952, + 0.7459368423388808, + 0.2676547610600329, + 9.057225521260815e-05, + 3.1167081060765174 + ], + "mcse": [ + 0.2210804046942114, + 0.026093382917047128, + 0.00033137226407576735, + 0.00019638984273120174, + 0.0012849868787806215, + 0.009221521766003252, + 0.0032546785557961396, + 1.145449399086702e-05, + 0.037680991135575416 + ], + "walkers": 32, + "temps": 8, + "steps": 2000, + "logz": -89.35697034343099, + "logz_err": 4.86782960831539, + "tau": 121.28581056230007, + "tau_reliable": false, + "start_search_s": 8.880032461951487, + "start": "map" + }, + "HMC": { + "wall_s": 203.4178415259812, + "calls": { + "search": 1744, + "warmup": 12000, + "sampling": 40000, + "evidence": 0 + }, + "min_ess": 202.80325169856414, + "min_ess_tail": 266.67137106392977, + "max_rhat": 1.0135569206023398, + "mean": [ + 168.43287755394684, + 27.98178789569105, + 1.2868735664008186, + 0.6037094961811927, + -0.7228759055986412, + -0.9550464443744845, + -3.71270258646312, + 0.37249154985520305, + 8.049277425649974 + ], + "sd": [ + 4.862328377431697, + 2.00201173818871, + 0.022457517528032666, + 0.015612468192075074, + 0.10744749475088079, + 0.7980066698388555, + 0.291631928034708, + 0.2345294636058762, + 3.4654747517294506 + ], + "mcse": [ + 0.2858666949209848, + 0.12861089105557316, + 0.0015533158759512477, + 0.0010963118528339389, + 0.003738013927023074, + 0.03006341881739586, + 0.01578741588434424, + 0.010441191099474703, + 0.2197540002217163 + ], + "divergences": 0, + "warmup": 300, + "draws": 1000, + "num_integration_steps": 20, + "start_search_s": 8.865733193990309, + "start": "map" + }, + "PyMC NUTS": { + "wall_s": 3037.328953217948, + "calls": { + "search": 1744, + "warmup": 61225, + "sampling": 77800, + "evidence": 0 + }, + "min_ess": 460.3261926314152, + "min_ess_tail": 435.75158750605954, + "max_rhat": 1.0092975869743244, + "mean": [ + 168.7371462532302, + 28.095345808790142, + 1.2851529289350512, + 0.6048223135655674, + -0.7209838803414215, + -0.9381471589018388, + -3.720228480768489, + 0.36824972527630007, + 8.174248210342698 + ], + "sd": [ + 4.8406154983918785, + 1.956888389640902, + 0.021176083760158726, + 0.014737492014638958, + 0.10727537862486333, + 0.768957193083262, + 0.28587301572594964, + 0.24117596217359777, + 3.3245557990431314 + ], + "mcse": [ + 0.22214636167411345, + 0.07247217906018755, + 0.0009815666162991921, + 0.0006868956076236367, + 0.002969703642491974, + 0.023896574835145356, + 0.01129234857740955, + 0.008430101900280719, + 0.10202181015722014 + ], + "divergences": 0, + "warmup": 300, + "draws": 1000, + "start_search_s": 24.37066104396945, + "start": "map" + }, + "PyMC HMC": { + "wall_s": 867.5749648273923, + "calls": { + "search": 1744, + "warmup": 105349, + "sampling": 41120, + "evidence": 0 + }, + "min_ess": 642.1287693310289, + "min_ess_tail": 426.49428554492005, + "max_rhat": 1.0019782817766703, + "mean": [ + 168.62165272977666, + 28.03689004176751, + 1.285432492564679, + 0.6046692730087844, + -0.7276272323944933, + -0.907064051400087, + -3.7256235567346923, + 0.3735394122696315, + 8.085893426406946 + ], + "sd": [ + 4.655846294203766, + 1.9303446782266507, + 0.020947504987067746, + 0.014566565446151026, + 0.09942581778547532, + 0.7747949208801906, + 0.2823009703677893, + 0.23543020769722023, + 3.3167997873948556 + ], + "mcse": [ + 0.1748760847207188, + 0.06290182371708503, + 0.0008266491784218725, + 0.0005726760130002551, + 0.002000215140951069, + 0.016560522779997238, + 0.009100526456621776, + 0.008021370855011853, + 0.08837001197579034 + ], + "divergences": 2, + "warmup": 300, + "draws": 1000, + "start_search_s": 15.023620477411896, + "start": "map" + } + } + }, + "n40ca_gp": { + "ndim": 7, + "names": [ + "Vv", + "Wv", + "Rv", + "av", + "log_ell_xs", + "log_A_xs", + "amp_slope_xs" + ], + "samplers": { + "emcee": { + "wall_s": 41.09689370309934, + "calls": { + "search": 778, + "warmup": 32000, + "sampling": 64000, + "evidence": 0 + }, + "min_ess": 485.42878962228025, + "min_ess_tail": 1712.2570798783267, + "max_rhat": 1.0454143387593746, + "mean": [ + 43.62137221729963, + 13.720037467081932, + 4.296804196865033, + 0.48465282328690157, + -1.2651853921781757, + -1.7914905833223087, + 2.2516945417687104 + ], + "sd": [ + 1.6875381174250461, + 1.0903021914740778, + 0.07669578987143871, + 0.026047234195283365, + 0.20943305466582576, + 0.49803117193873436, + 0.6982480133378612 + ], + "mcse": [ + 0.0586406759559441, + 0.04017008016204191, + 0.0027358734324242746, + 0.0008927603593203183, + 0.009505664069959717, + 0.017796817358649443, + 0.024101604168519666 + ], + "walkers": 32, + "steps": 3000, + "tau": 65.12651537397433, + "tau_reliable": false, + "start_search_s": 2.7908549271523952, + "start": "map" + }, + "dynesty": { + "wall_s": 283.54432407487184, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 278094, + "evidence": 0 + }, + "min_ess": 3843.195777188117, + "logz": -11.915705799828652, + "logz_err": 0.3363576952566165, + "mean": [ + 43.53479784480955, + 13.687687614899206, + 4.299874134164965, + 0.48338110707442844, + -1.2661535570206617, + -1.8002074822598002, + 2.2435916641384446 + ], + "sd": [ + 1.7074109408799056, + 1.084812370184361, + 0.0762219892908915, + 0.027184506419138638, + 0.2029827485118998, + 0.4497839009121225, + 0.6356672955825668 + ], + "mcse": [ + 0.027541767370622052, + 0.01749880431537677, + 0.0012295155473783723, + 0.00043850565435363476, + 0.0032742578285712433, + 0.0072553380497776265, + 0.01025377099377444 + ], + "start": "prior" + }, + "pocomc": { + "wall_s": 335.92207670304924, + "calls": { + "search": 0, + "warmup": 276480, + "sampling": 0, + "evidence": 4096 + }, + "min_ess": 7180.300088780893, + "logz": -11.35233651837971, + "logz_err": 0.010368892853628514, + "mean": [ + 43.61952472425906, + 13.732510878830029, + 4.296781131282306, + 0.48491101219874144, + -1.2782037642255066, + -1.796844699335886, + 2.214137790291506 + ], + "sd": [ + 1.6628138873891458, + 1.0660093502221633, + 0.07194432713310954, + 0.025985932612258792, + 0.2042591934536338, + 0.48050086827043087, + 0.6680072502286669 + ], + "mcse": [ + 0.019623313644259472, + 0.012580262881956069, + 0.0008490343429082856, + 0.0003066669756948012, + 0.002410517646179656, + 0.005670519903592199, + 0.007883333118211253 + ], + "start": "prior" + }, + "NUTS": { + "wall_s": 94.41112445713952, + "calls": { + "search": 778, + "warmup": 46389, + "sampling": 48288, + "evidence": 0 + }, + "min_ess": 491.2964672357652, + "min_ess_tail": 463.68879148901203, + "max_rhat": 1.0047101788842845, + "mean": [ + 43.55303001943829, + 13.703014001423654, + 4.300296224180379, + 0.48322547649377967, + -1.2775471532572347, + -1.8403651874436695, + 2.2889275682449766 + ], + "sd": [ + 1.68069675979444, + 1.095629835028646, + 0.07641834698149594, + 0.025520076548930626, + 0.2153779827915109, + 0.47940453132061284, + 0.6763736636876725 + ], + "mcse": [ + 0.07542873395027143, + 0.03712053120752365, + 0.0034020542491934934, + 0.0011513573880815946, + 0.007108314004870394, + 0.017477388842804073, + 0.021278609949374465 + ], + "divergences": 0, + "warmup": 300, + "draws": 1000, + "start_search_s": 2.6331109800376, + "start": "map" + }, + "ptemcee": { + "wall_s": 224.83903706120327, + "calls": { + "search": 778, + "warmup": 170496, + "sampling": 341504, + "evidence": 0 + }, + "min_ess": 4418.491493356643, + "min_ess_tail": 5202.396888625849, + "max_rhat": 1.0077203575450586, + "mean": [ + 43.35488813773201, + 13.81555280988057, + 4.304807316232701, + 0.4833808083232561, + -1.2871542592951617, + -1.8469366522865287, + 2.2662224722828492 + ], + "sd": [ + 1.9544164670979307, + 1.0913407129653634, + 0.0793241846756245, + 0.0309061907823314, + 0.21313215173899208, + 0.5007107187591511, + 0.6867392390968479 + ], + "mcse": [ + 0.028022168578579785, + 0.012856535664399813, + 0.00119335211002356, + 0.00046097124928276946, + 0.00268404567775654, + 0.007281496369217014, + 0.010209954520959914 + ], + "walkers": 32, + "temps": 8, + "steps": 2000, + "logz": -17.38024954996489, + "logz_err": 21.772857487744556, + "tau": 8.975807627705452, + "tau_reliable": true, + "start_search_s": 2.606151465792209, + "start": "map" + }, + "HMC": { + "wall_s": 55.98467552475631, + "calls": { + "search": 778, + "warmup": 12000, + "sampling": 40000, + "evidence": 0 + }, + "min_ess": 721.6795864726267, + "min_ess_tail": 877.2220885214015, + "max_rhat": 1.0026773321561282, + "mean": [ + 43.52784886204173, + 13.71388500537304, + 4.301764921954218, + 0.4830027522846823, + -1.277559733476414, + -1.828460722940568, + 2.2727491795362234 + ], + "sd": [ + 1.6540766591432534, + 1.0754297561619388, + 0.07392227077905184, + 0.02479088292252604, + 0.2122410968147478, + 0.48724476620246415, + 0.6757486054653791 + ], + "mcse": [ + 0.060417654258251595, + 0.026065983068517734, + 0.0027517127035367782, + 0.0008960605126449429, + 0.005339497757599164, + 0.015123253149474944, + 0.017253516046483636 + ], + "divergences": 0, + "warmup": 300, + "draws": 1000, + "num_integration_steps": 20, + "start_search_s": 3.3320546047762036, + "start": "map" + }, + "PyMC NUTS": { + "wall_s": 139.20244341949, + "calls": { + "search": 778, + "warmup": 36904, + "sampling": 46992, + "evidence": 0 + }, + "min_ess": 625.5913489323723, + "min_ess_tail": 667.1303248148098, + "max_rhat": 1.0042452492409042, + "mean": [ + 43.491735286141136, + 13.719324268979308, + 4.303566943971951, + 0.4824798916109016, + -1.282683847267811, + -1.8369897902851458, + 2.2738473067518252 + ], + "sd": [ + 1.6620633844642203, + 1.0497082914627671, + 0.07500924346463571, + 0.0247979398991766, + 0.20943436194736947, + 0.493120376222092, + 0.6795633918294639 + ], + "mcse": [ + 0.06633215181926733, + 0.029900777369091126, + 0.0029804989422732085, + 0.0009914486731681343, + 0.006609874460616724, + 0.017729033463307547, + 0.025751109911651023 + ], + "divergences": 0, + "warmup": 300, + "draws": 1000, + "start_search_s": 2.586575933266431, + "start": "map" + }, + "PyMC HMC": { + "wall_s": 106.38749700132757, + "calls": { + "search": 778, + "warmup": 39233, + "sampling": 21140, + "evidence": 0 + }, + "min_ess": 654.8807380807436, + "min_ess_tail": 692.4326376373216, + "max_rhat": 1.0029859005502124, + "mean": [ + 43.59224051837716, + 13.736480255134593, + 4.299273360289709, + 0.48363883652352635, + -1.2753412707647096, + -1.801201044410682, + 2.24537521408511 + ], + "sd": [ + 1.6357817634958687, + 1.0838424894146599, + 0.07298399020261225, + 0.024113046274629738, + 0.2017377473284159, + 0.49238635252139634, + 0.6869096439072709 + ], + "mcse": [ + 0.06270582720817715, + 0.03324771210957765, + 0.0028519801283471615, + 0.0009040602177887595, + 0.00684189997161433, + 0.01772296240664249, + 0.022372287883302918 + ], + "divergences": 0, + "warmup": 300, + "draws": 1000, + "start_search_s": 2.7437847647815943, + "start": "map" + } + } + }, + "omp": { + "ndim": 9, + "names": [ + "Vv", + "Wv", + "Rv", + "av", + "Wd", + "Rd", + "ad", + "log_sigma_A", + "log_sigma_B" + ], + "samplers": { + "emcee": { + "wall_s": 183.3095257228706, + "calls": { + "search": 876, + "warmup": 32000, + "sampling": 64000, + "evidence": 0 + }, + "min_ess": 53.985223173423535, + "min_ess_tail": 337.71724370196233, + "max_rhat": 1.5927663322026995, + "mean": [ + 46.03100318095825, + 3.07929591348816, + 3.946376080688598, + 0.7995540024439179, + 9.412814405883646, + 4.4465197742045985, + 0.3044394883167146, + -1.654385169070702, + -2.9234559532893853 + ], + "sd": [ + 2.003401613708527, + 1.0987943926561647, + 0.09233848396033632, + 0.0359589632454637, + 0.6247028531925346, + 0.0506915058374228, + 0.03203706862021923, + 0.11560103020758336, + 0.23380748020235576 + ], + "mcse": [ + 0.11449235862878943, + 0.054467667767347266, + 0.005255518964245706, + 0.001873998903737896, + 0.035370254665103865, + 0.0025755271682890496, + 0.001442283775295129, + 0.006023436691817287, + 0.03182152222720434 + ], + "walkers": 32, + "steps": 3000, + "tau": 169.92065726841378, + "tau_reliable": false, + "start_search_s": 5.632592704962008, + "start": "map" + }, + "dynesty": { + "wall_s": 564.5745539650088, + "calls": { + "search": 0, + "warmup": 0, + "sampling": 255013, + "evidence": 0 + }, + "min_ess": 4116.9695679152, + "logz": -6.416208833399547, + "logz_err": 0.31702450127285803, + "mean": [ + 46.315232318467906, + 3.3138074104089585, + 3.9383183068012793, + 0.7973035359938518, + 9.19931142522417, + 4.416747300697775, + 0.3199353318946708, + -1.6354042032797913, + -1.927058551774978 + ], + "sd": [ + 2.4851563273897432, + 1.2447048097370987, + 0.1259180135014079, + 0.0434896853071639, + 1.1314650134232822, + 0.09660832177071606, + 0.05443689100478373, + 0.1336700823175724, + 0.8069516737836944 + ], + "mcse": [ + 0.03873155064336246, + 0.0193989194333724, + 0.0019624519645264657, + 0.0006777935578433128, + 0.017634059469661637, + 0.0015056558277615046, + 0.0008484074734379163, + 0.002083269171329496, + 0.01257646823881179 + ], + "start": "prior" + }, + "pocomc": { + "wall_s": 807.2303060659906, + "calls": { + "search": 0, + "warmup": 307200, + "sampling": 0, + "evidence": 4096 + }, + "min_ess": 6815.42927035514, + "logz": -6.685416953322681, + "logz_err": 0.012461176043330564, + "mean": [ + 45.71500677709557, + 3.3518412825560846, + 3.9651911254169474, + 0.7895701545899648, + 9.001866525855602, + 4.413858809206461, + 0.32404354636388677, + -1.6260660654523065, + -1.8528349297575661 + ], + "sd": [ + 2.533443877728667, + 1.257216432392475, + 0.13407327224522073, + 0.0467272007243898, + 1.224323610418969, + 0.11359262480744094, + 0.06392954679710527, + 0.12171861863294449, + 0.8423448891556087 + ], + "mcse": [ + 0.030687724064007754, + 0.015228721387973286, + 0.0016240358111696749, + 0.0005660087656645356, + 0.014830289098518168, + 0.0013759527718144504, + 0.0007743815874088025, + 0.0014743833147031495, + 0.010203363000213664 + ], + "start": "prior" + }, + "NUTS": { + "wall_s": 625.7669758679112, + "calls": { + "search": 876, + "warmup": 81863, + "sampling": 78792, + "evidence": 0 + }, + "min_ess": 3.1387580096539747, + "min_ess_tail": 75.1023641868547, + "max_rhat": 1.6943674913518298, + "mean": [ + 44.12337510757033, + 3.5395355773853585, + 4.063308981144169, + 0.759385210013522, + 8.322162677633386, + 4.317541577828031, + 0.3577244165718097, + -1.5993896151983003, + -1.7750907900094466 + ], + "sd": [ + 3.0852536163526163, + 1.4043253351316642, + 0.16504513041455643, + 0.05804909880473977, + 1.445036689159153, + 0.15352896247388081, + 0.0708107106435624, + 0.13213221961597643, + 0.8919425968190124 + ], + "mcse": [ + 1.6594079195035336, + 0.07968077921557346, + 0.0931587812399935, + 0.03189291660946422, + 0.7574624366931417, + 0.08321080010335914, + 0.03689370659117112, + 0.03886870785480621, + 0.02866882784852053 + ], + "divergences": 0, + "warmup": 300, + "draws": 1000, + "start_search_s": 5.625878345919773, + "start": "map" + }, + "ptemcee": { + "wall_s": 927.4509301020298, + "calls": { + "search": 876, + "warmup": 170496, + "sampling": 341504, + "evidence": 0 + }, + "min_ess": 56.454004951527075, + "min_ess_tail": 590.2173048443929, + "max_rhat": 1.534660689836785, + "mean": [ + 45.629870582102185, + 3.1727181634061994, + 3.9696151092552, + 0.7899744804086718, + 9.123799826490998, + 4.427705401183557, + 0.3172077681817499, + -1.6249213582177293, + -2.9955537435979824 + ], + "sd": [ + 2.2603088992017053, + 1.1623333749669797, + 0.11592392755581832, + 0.0443949350245106, + 1.0743581154482607, + 0.0932185302630395, + 0.06308597815595574, + 0.12668251913796336, + 0.0005510034051969917 + ], + "mcse": [ + 0.030060971584452093, + 0.014838527154470161, + 0.001562136005646143, + 0.0006069798947629324, + 0.013086229509965457, + 0.0010699736430770529, + 0.0007799209601231984, + 0.0020134775496871717, + 7.333425836580016e-05 + ], + "walkers": 32, + "temps": 8, + "steps": 2000, + "logz": -11.953658854672948, + "logz_err": 2.344806177711348, + "tau": 97.46997819265792, + "tau_reliable": false, + "start_search_s": 5.622346699004993, + "start": "map" + }, + "HMC": { + "wall_s": 213.51569985994138, + "calls": { + "search": 876, + "warmup": 12000, + "sampling": 40000, + "evidence": 0 + }, + "min_ess": 577.622697649186, + "min_ess_tail": 378.2684439658823, + "max_rhat": 1.0051036263906123, + "mean": [ + 46.30296429612228, + 3.2299681547253924, + 3.933098518899915, + 0.8014397479973022, + 9.42359498133739, + 4.440161263783986, + 0.3064086552141723, + -1.6472671108748314, + -1.8663844997727799 + ], + "sd": [ + 2.1117418325496033, + 1.1800855334121654, + 0.09795240893060006, + 0.03522292853354909, + 0.6100037173200725, + 0.050967404909348035, + 0.030655323471972907, + 0.1169876732465711, + 0.8859196245852299 + ], + "mcse": [ + 0.08407327536564183, + 0.045688832446253276, + 0.004075613534262863, + 0.0014259598819454343, + 0.0175097164487086, + 0.00168502531685712, + 0.0010106486549011976, + 0.0022405258908357495, + 0.0158090890116802 + ], + "divergences": 0, + "warmup": 300, + "draws": 1000, + "num_integration_steps": 20, + "start_search_s": 5.669675156939775, + "start": "map" + }, + "PyMC NUTS": { + "wall_s": 613.3576898110332, + "calls": { + "search": 876, + "warmup": 47938, + "sampling": 57740, + "evidence": 0 + }, + "min_ess": 498.6175588130325, + "min_ess_tail": 316.56344761222925, + "max_rhat": 1.0063164831539773, + "mean": [ + 46.370932135501384, + 3.3677258252948907, + 3.9298273951186427, + 0.803856920170553, + 9.404883951802764, + 4.440584617942902, + 0.3030710581015199, + -1.6462095241764922, + -1.8651091065871597 + ], + "sd": [ + 2.1086574464008114, + 1.2322892559394885, + 0.09543365526244633, + 0.03526731547165308, + 0.6325536686956763, + 0.05467843336633138, + 0.033836017093490024, + 0.12000412864871537, + 0.8200239406803693 + ], + "mcse": [ + 0.07731343738669215, + 0.050710990808763255, + 0.0033960454643685157, + 0.001474988952559132, + 0.02366099765300281, + 0.0023334855419760406, + 0.0015152889339828616, + 0.0036805428091531978, + 0.018852235647785754 + ], + "divergences": 0, + "warmup": 300, + "draws": 1000, + "start_search_s": 5.566087043029256, + "start": "map" + }, + "PyMC HMC": { + "wall_s": 727.1244522660272, + "calls": { + "search": 876, + "warmup": 104157, + "sampling": 25280, + "evidence": 0 + }, + "min_ess": 538.1536270451218, + "min_ess_tail": 762.341137473228, + "max_rhat": 1.006604690727678, + "mean": [ + 46.295649878341294, + 3.3505439333179035, + 3.93295395220897, + 0.8027134846723524, + 9.357011517961027, + 4.440959854151545, + 0.30417923175829487, + -1.647309023123504, + -1.866013209778152 + ], + "sd": [ + 2.0449975566806042, + 1.1786693075259704, + 0.09692935671728896, + 0.03567548323946401, + 0.5903003496695618, + 0.04898293757656547, + 0.030387607758827626, + 0.11934064327201321, + 0.8843120352332337 + ], + "mcse": [ + 0.08387119158059082, + 0.04750128938904647, + 0.0041431171661474855, + 0.001537859743916016, + 0.018620327910523995, + 0.0016579622264449177, + 0.0011386911579033794, + 0.002657796521789365, + 0.016007731563021592 + ], + "divergences": 0, + "warmup": 300, + "draws": 1000, + "start_search_s": 5.385184327024035, + "start": "map" + } + } + } + } +} \ No newline at end of file diff --git a/benchmarks/sweep_pocomc.py b/benchmarks/sweep_pocomc.py new file mode 100644 index 0000000..7c718c1 --- /dev/null +++ b/benchmarks/sweep_pocomc.py @@ -0,0 +1,217 @@ +"""Sampler settings swept on one benchmark problem: pocomc's resolution, and on +the problems the prior-started samplers' defaults are chosen on, dynesty's. + +Each setting runs at several seeds, and every run's moments, evidence, cost +and (on the problems with separated modes) the share of its draws in the +minor mode are saved; scoring against the reference waits for ``--report``, +so a sweep need not wait for its reference:: + + python benchmarks/sweep_pocomc.py alpha_gp --out results/hpc/sweep_alpha_gp.json + python benchmarks/sweep_pocomc.py --report results/hpc/sweep_alpha_gp.json + python benchmarks/sweep_pocomc.py --grid results/hpc/sweep_{gp,modes,elastic}.json + +A setting is named by its label, ``"pocomc 1024/512"`` (or just ``1024/512``) +or ``"dynesty rslice 250"``. ``docs/benchmarks.md``'s sweep tables are these +reports: ``--report`` per problem, ``--grid`` the worst over the seeds of +several problems side by side. +""" + +from __future__ import annotations + +import argparse +import json +from pathlib import Path + +from bench_samplers import ( + BUDGETS, + MARK, + REFERENCES, + errors, + run_dynesty, + run_pocomc, + usable_reference, + verdict, +) +from problems import PROBLEMS, mode_share + +#: pocomc's (n_effective, n_active): the sweep on every problem but those below +SETTINGS = [(1024, 512), (2048, 1024), (4096, 2048)] +#: on the problems where the defaults of the samplers that start from the +#: prior are chosen (bench_samplers.DYNESTY, POCOMC): dynesty's and pocomc's +#: defaults and the settings about them +PRIOR_PROBLEMS = ("gp", "modes", "elastic") +PRIOR_SETTINGS = [ + ("dynesty", dict(sample="rwalk", nlive=200)), + ("dynesty", dict(sample="rwalk", nlive=500)), + ("dynesty", dict(sample="rslice", nlive=250)), + ("dynesty", dict(sample="rslice", nlive=500)), + ("pocomc", dict(n_effective=512, n_active=256)), + ("pocomc", dict(n_effective=1024, n_active=512)), + ("pocomc", dict(n_effective=2048, n_active=1024)), +] +SEEDS = (100, 101, 102) + + +def setting(s): + """``(sampler, settings)`` of a setting given as that pair, a pocomc + ``(n_effective, n_active)`` pair, or a label.""" + if isinstance(s, str): + words = s.split() + if len(words) == 1: + words = ["pocomc", *words] + if words[0] == "pocomc" and len(words) == 2: + ne, na = (int(v) for v in words[1].split("/")) + return "pocomc", dict(n_effective=ne, n_active=na) + if words[0] == "dynesty" and len(words) == 3: + return "dynesty", dict(sample=words[1], nlive=int(words[2])) + raise ValueError(f"not a setting: {s!r}") + if isinstance(s[0], str): + return s[0], dict(s[1]) + return "pocomc", dict(n_effective=int(s[0]), n_active=int(s[1])) + + +def label(s): + """A setting's label, ``"pocomc 1024/512"`` or ``"dynesty rslice 250"``.""" + sampler, kw = setting(s) + if sampler == "pocomc": + return f"pocomc {kw['n_effective']}/{kw['n_active']}" + return f"dynesty {kw['sample']} {kw['nlive']}" + + +def run_label(r): + """The label of a saved run (one saved before dynesty was swept is pocomc).""" + return r.get("setting") or label((r["n_effective"], r["n_active"])) + + +def settings_for(name): + """The settings swept on problem ``name``.""" + if name in PRIOR_PROBLEMS: + return list(PRIOR_SETTINGS) + return [setting(s) for s in SETTINGS] + + +def sweep(name, settings=None, seeds=SEEDS, out=None, **lengths): + """``settings`` (default ``settings_for(name)``) as :func:`setting` reads + them; ``lengths`` (``n_total``, ``n_evidence``) shorten pocomc runs, for + tests.""" + problem, _ = PROBLEMS[name]() + summary = mode_share(name, problem) + if out: + out.parent.mkdir(parents=True, exist_ok=True) + saved = json.loads(out.read_text()) if out and out.exists() else {} + runs = saved.get("runs", []) + done = {(run_label(r), r["seed"]) for r in runs} + for s in settings_for(name) if settings is None else settings: + sampler, kw = setting(s) + name_s = label(s) + for seed in seeds: + if (name_s, seed) in done: + continue # resume an interrupted sweep + if sampler == "pocomc": + r = run_pocomc( + problem, BUDGETS[name], seed, summary=summary, **kw, **lengths + ) + else: + r = run_dynesty(problem, BUDGETS[name], seed, summary=summary, **kw) + r.update(sampler=sampler, setting=name_s, seed=seed, **kw) + runs.append(r) + share = f", mode share {r['mode_share']:.2f}" if "mode_share" in r else "" + print( + f"{name} {name_s} seed {seed}: {r['wall_s']:.0f} s, " + f"log Z {r['logz']:.2f}{share}", + flush=True, + ) + if out: # each run is saved as it ends + out.write_text( + json.dumps( + dict(problem=name, names=problem.names, runs=runs), indent=1 + ) + ) + return dict(problem=name, names=problem.names, runs=runs) + + +def _by_setting(runs): + """Runs grouped by label, in the order the labels first appear.""" + groups = {} + for r in runs: + groups.setdefault(run_label(r), []).append(r) + return groups + + +def report(saved, refs): + name = saved["problem"] + ref = usable_reference(name, saved.get("names"), refs.get(name)) + print(f"| {name} | bias / width per seed | mode share | log Z | wall time |") + print("|---|---|---|---|---|") + for name_s, rs in _by_setting(saved["runs"]).items(): + if ref is None: + scores = "no reference" + else: + pairs = [errors(r, ref) for r in rs] + scores = ", ".join( + f"{b:.2f} / {w:.2f}" + MARK[verdict(max(b, w), ref)] for b, w in pairs + ) + share = ", ".join(f"{r['mode_share']:.2f}" for r in rs if "mode_share" in r) + logz = ", ".join(f"{r['logz']:.2f}" for r in rs) + wall = ( + f"{min(r['wall_s'] for r in rs):.0f}–{max(r['wall_s'] for r in rs):.0f} s" + ) + print(f"| {name_s} | {scores} | {share or '—'} | {logz} | {wall} |") + + +def grid(saved, refs): + """Several problems' sweeps side by side: per setting and problem, the + worst bias and the worst width error over the seeds.""" + cells, order = {}, [] + names = [s["problem"] for s in saved] + for s in saved: + ref = usable_reference(s["problem"], s.get("names"), refs.get(s["problem"])) + for name_s, rs in _by_setting(s["runs"]).items(): + if name_s not in order: + order.append(name_s) + if ref is None: + cells[name_s, s["problem"]] = "no reference" + continue + b, w = (max(e) for e in zip(*(errors(r, ref) for r in rs))) + cells[name_s, s["problem"]] = ( + f"{b:.2f} / {w:.2f}" + MARK[verdict(max(b, w), ref)] + ) + print("| setting | " + " | ".join(f"`{n}`" for n in names) + " |") + print("|---|" + "---|" * len(names)) + for name_s in order: + row = [cells.get((name_s, n), "") for n in names] + print(f"| {name_s} | " + " | ".join(row) + " |") + + +def main(argv=None): + ap = argparse.ArgumentParser(description=__doc__.splitlines()[0]) + ap.add_argument("problem", nargs="?", choices=list(PROBLEMS)) + ap.add_argument("--out", type=Path) + ap.add_argument("--seeds", type=int, nargs="*", default=list(SEEDS)) + ap.add_argument( + "--settings", + nargs="*", + help="labels, e.g. 'pocomc 1024/512' (or 1024/512), 'dynesty rslice 250' " + "(default: the problem's own, settings_for)", + ) + ap.add_argument("--report", type=Path, help="print a saved sweep and exit") + ap.add_argument( + "--grid", type=Path, nargs="+", help="print saved sweeps side by side and exit" + ) + ap.add_argument("--references", type=Path, default=REFERENCES) + args = ap.parse_args(argv) + if args.report or args.grid: + refs = ( + json.loads(args.references.read_text()) if args.references.exists() else {} + ) + if args.grid: + return grid([json.loads(p.read_text()) for p in args.grid], refs) + return report(json.loads(args.report.read_text()), refs) + if args.problem is None: + ap.error("give a problem to sweep, or --report or --grid") + settings = [setting(s) for s in args.settings] if args.settings else None + return sweep(args.problem, settings, tuple(args.seeds), args.out) + + +if __name__ == "__main__": + main() diff --git a/docs/Makefile b/docs/Makefile index b5d3962..99002fc 100644 --- a/docs/Makefile +++ b/docs/Makefile @@ -8,7 +8,7 @@ help: @$(SPHINXBUILD) -M help $(SOURCEDIR) $(BUILDDIR) $(SPHINXOPTS) $(O) html: - test -L examples || ln -sf ../examples examples + if [ -d ../examples ]; then test -L examples || ln -sf ../examples examples; fi $(SPHINXBUILD) -b html $(SOURCEDIR) $(BUILDDIR)/html $(SPHINXOPTS) $(O) @echo @echo "Build finished. Open $(BUILDDIR)/html/index.html to view." diff --git a/docs/api.rst b/docs/api.rst index c1d869c..aa833c8 100644 --- a/docs/api.rst +++ b/docs/api.rst @@ -1,54 +1,29 @@ -API Reference +API reference ============= -Configuration -------------- +The public surface, in the order the design document introduces it. Every +name below is importable from ``rxmc`` or the module shown. -High-level configuration objects for assembling a calibration problem and -handing it to an external sampler (emcee, dynesty, etc.). +Building blocks +--------------- .. autosummary:: :toctree: generated/ :nosignatures: - rxmc.config.CalibrationConfig - rxmc.config.ParameterConfig - -Priors ------- - -Prior distribution classes that satisfy the generic prior protocol required by -:class:`~rxmc.config.ParameterConfig`. Any user-defined class with ``logpdf``, -``rvs``, and (optionally) ``prior_transform`` methods can be used directly. - -.. autosummary:: - :toctree: generated/ - :nosignatures: - - rxmc.priors.IndependentPrior - rxmc.priors.TruncatedNormalPrior - -Core building blocks --------------------- - -.. autosummary:: - :toctree: generated/ - :nosignatures: - - rxmc.constraint.Constraint - rxmc.evidence.Evidence - rxmc.observation.Observation rxmc.params.Parameter - rxmc.physical_model.PhysicalModel - rxmc.physical_model.Polynomial + rxmc.data.Dataset + rxmc.data.from_measurement + rxmc.model.Model + rxmc.model.Predictor + rxmc.model.polynomial + rxmc.constraint.Comparison + rxmc.constraint.Constraint + rxmc.problem.Problem Transforms ---------- -One low-level, numpy-style transform type shared by observations (the -comparison space, e.g. ``transform=log``), models (parametric transforms such -as a latent normalisation) and covariance terms (coordinate transforms). - .. autosummary:: :toctree: generated/ :nosignatures: @@ -59,139 +34,140 @@ as a latent normalisation) and covariance terms (coordinate transforms). rxmc.transforms.log rxmc.transforms.exp rxmc.transforms.scale - rxmc.transforms.per_observation_scaling Covariance terms ---------------- -The stacked covariance of a :class:`~rxmc.constraint.Constraint` is assembled -additively from :class:`~rxmc.covariance.Term` objects — a single generic type: -a numpy-style callable of a :class:`~rxmc.covariance.TermContext` (the term's -local ``x``/``y``/``ym``) and its parameters, plus a ``kind`` -(``"diag"``/``"mode"``/``"matrix"``). The factory helpers build the common -terms in one line; anything else is a direct ``Term(fn, params, kind=...)``. -A :class:`~rxmc.covariance.StackContext` bundles the stacked ``x``/``y``/``ym`` -that a :class:`~rxmc.covariance.ConstraintCovariance` is evaluated on. - .. autosummary:: :toctree: generated/ :nosignatures: - rxmc.covariance.Term - rxmc.covariance.TermContext - rxmc.covariance.statistical_term - rxmc.covariance.normalization_term - rxmc.covariance.offset_term - rxmc.covariance.noise_term - rxmc.covariance.noise_fraction_term - rxmc.covariance.model_error_term - rxmc.covariance.systematic_term - rxmc.covariance.kernel_term - rxmc.covariance.ones - rxmc.covariance.ym - rxmc.covariance.averaging - rxmc.covariance.x_basis - rxmc.covariance.exp_growth - rxmc.covariance.constant_amplitude - rxmc.covariance.exp_growth_amplitude - rxmc.covariance.stacked_supports - rxmc.covariance.ConstraintCovariance - rxmc.covariance.StackContext + rxmc.terms.Term + rxmc.terms.TermContext + rxmc.terms.KernelTerm + rxmc.terms.statistical + rxmc.terms.offset + rxmc.terms.normalization + rxmc.terms.noise + rxmc.terms.proportional_error + rxmc.terms.systematic + rxmc.terms.kernel + rxmc.terms.kernel_params + rxmc.terms.ones + rxmc.terms.ym + rxmc.terms.averaging + rxmc.terms.x_basis + rxmc.terms.exp_growth + rxmc.terms.constant_amplitude + rxmc.terms.exp_growth_amplitude Likelihood functionals ---------------------- -Thin functionals of the pre-computed Mahalanobis statistics -``(d2, logdet, n)``; all covariance modeling lives on the -:class:`~rxmc.covariance.ConstraintCovariance`. - .. autosummary:: :toctree: generated/ :nosignatures: - rxmc.likelihood_model.Likelihood - rxmc.likelihood_model.GaussianLikelihood - rxmc.likelihood_model.StudentT - rxmc.likelihood_model.Chi2 - rxmc.likelihood_model.mahalanobis_distance_sqr_cholesky - rxmc.likelihood_model.log_likelihood - -Predictive utilities --------------------- + rxmc.likelihood.Likelihood + rxmc.likelihood.Gaussian + rxmc.likelihood.Chi2 -Posterior-predictive helpers, including Gaussian-process discrepancy -propagation. +The structured covariance +------------------------- .. autosummary:: :toctree: generated/ :nosignatures: - rxmc.predictive.predictive_band - rxmc.predictive.gp_posterior_predictive - rxmc.predictive.total_predictive_band - -Model comparison ----------------- + rxmc.covariance.StructuredCovariance + rxmc.covariance.chol_logdet + rxmc.problem.CompiledConstraint + rxmc.problem.ParameterIndex -Sampler-agnostic posterior-predictive checks, held-out scoring, and -nested-sampling evidence bookkeeping. +Point estimates +--------------- .. autosummary:: :toctree: generated/ :nosignatures: - rxmc.model_comparison.predictive_draws - rxmc.model_comparison.coverage_curve - rxmc.model_comparison.coverage_error - rxmc.model_comparison.sharpness - rxmc.model_comparison.heldout_log_predictive - rxmc.model_comparison.log_posterior_predictive - rxmc.model_comparison.logz_summary - rxmc.model_comparison.compare_logz - rxmc.model_comparison.log_jacobian - rxmc.model_comparison.split_samples + rxmc.optimize.find_map + rxmc.optimize.find_mle -Sampling --------- +Diagnostics +----------- .. autosummary:: :toctree: generated/ :nosignatures: - rxmc.walker.Walker - rxmc.param_sampling.Sampler - rxmc.param_sampling.MetropolisHastingsSampler - rxmc.param_sampling.AdaptiveMetropolisSampler - rxmc.param_sampling.BatchedAdaptiveMetropolisSampler - rxmc.proposal.ProposalDistribution - rxmc.proposal.NormalProposalDistribution - rxmc.proposal.HalfNormalProposalDistribution - rxmc.proposal.LogspaceNormalProposalDistribution - -Sampling algorithms -------------------- + rxmc.diagnostics.predictive_draws + rxmc.diagnostics.coverage_curve + rxmc.diagnostics.coverage_error + rxmc.diagnostics.sharpness + rxmc.diagnostics.heldout_log_predictive + rxmc.diagnostics.log_posterior_predictive + rxmc.diagnostics.logz_summary + rxmc.diagnostics.compare_logz -Low-level sampling functions used internally by the sampler classes. +Predictive +---------- .. autosummary:: :toctree: generated/ :nosignatures: - rxmc.metropolis_hastings.metropolis_hastings - rxmc.adaptive_metropolis.adaptive_metropolis + rxmc.predictive.grid_draws + rxmc.predictive.gp_predictive_draws + rxmc.predictive.gp_posterior_predictive + rxmc.predictive.predictive_band -Domain-specific models ----------------------- +Reactions +--------- + +.. autosummary:: + :toctree: generated/ + :nosignatures: + + rxmc.reactions.elastic.ElasticXS + rxmc.reactions.ias.IsobaricAnalogPN + rxmc.reactions.elastic.rutherford + rxmc.reactions.elastic.momentum_transfer + rxmc.reactions.elastic.set_up_solver + rxmc.reactions.ias.set_up_solver -Reaction-physics observation and model classes for elastic differential -cross sections and isobaric-analog (p,n) cross sections. +Units +----- .. autosummary:: :toctree: generated/ :nosignatures: - rxmc.elastic_diffxs_observation.ElasticDifferentialXSObservation - rxmc.elastic_diffxs_observation.momentum_transfer - rxmc.elastic_diffxs_model.ElasticDifferentialXSModel - rxmc.ias_pn_observation.IsobaricAnalogPNObservation - rxmc.ias_pn_model.IsobaricAnalogPNXSModel + rxmc.units.parse_unit + rxmc.units.check_angle_grid + +Module overviews +---------------- + +The rules each module enforces, as its docstring states them. + +The compile step +~~~~~~~~~~~~~~~~ + +.. automodule:: rxmc.problem + :no-members: + +.. autodata:: rxmc.problem.JAX_LOGPDFS + :no-value: + +Covariance terms +~~~~~~~~~~~~~~~~ + +.. automodule:: rxmc.terms + :no-members: + +The structured covariance +~~~~~~~~~~~~~~~~~~~~~~~~~ + +.. automodule:: rxmc.covariance + :no-members: diff --git a/docs/benchmarks.md b/docs/benchmarks.md new file mode 100644 index 0000000..e39506e --- /dev/null +++ b/docs/benchmarks.md @@ -0,0 +1,483 @@ +# Benchmarks + +Two benchmarks live in `benchmarks/`: one times the densities, the other +compares samplers on them. Both build their problems from +`benchmarks/problems.py` and write JSON to `benchmarks/results/`, which is +checked in, so the tables below (all but the dynesty and pocomc settings +sweep) can be regenerated without a rerun. + +## Set-up + +From the repository root: + +```bash +uv sync --managed-python --extra examples --extra samplers +``` + +- `--managed-python` uses uv's own CPython, which ships the Python headers. + PyMC's PyTensor needs them (and a C++ compiler) to compile its graphs; with + a system Python that lacks `pyconfig.h` it falls back to pure Python and + the PyMC timings suffer. +- The `samplers` extra adds ptemcee, PyMC and pocomc. pocomc brings torch, + which `uv` takes from PyTorch's CPU index (`[tool.uv.sources]` in + `pyproject.toml`), avoiding about 3 GB of CUDA wheels. With pip, install + torch first: `pip install torch --index-url https://download.pytorch.org/whl/cpu`. +- Run on an otherwise idle machine; every number is a wall time. + +## The problems + +| name | parameters | what it exercises | +|---|---|---| +| `linear` | 2 | a line with reported errors (recipe 1): per-call overhead | +| `modes` | 9 | six comparisons with free normalisations, an offset each and one shared mode (recipes 4, 37): the Woodbury path | +| `gp`, `gp500` | 4 | a dense GP discrepancy over 100 or 500 points (recipe 7): Cholesky-bound | +| `elastic` | 5 | `ElasticXS` at four energies with a proportional model error (recipes 15, 26): the reaction solver | +| `ias` | 4 | an `IsobaricAnalogPN` prediction at one energy | +| `hierarchy` | 33 | 30 lines sharing a slope, their intercepts non-centred about a common mean (recipe 38): high dimension | +| `omp` | 9 | exactly the log-space p + $^{40}$Ca problem of `local_optical_model_calibration`: EXFOR C0076002 (Gross et al. 1967) at 35.8 MeV, seven potential parameters and two median-one log-space errors; its posterior has two separated islands | +| `alpha_gp` | 9 | exactly the power-of-$q$ problem of `alpha_ca_error_model_comparison`: $^{44}$Ca($\alpha$,$\alpha$) at 29 MeV, a four-parameter potential, two log-space errors and a Matérn GP whose amplitude grows with $q$; two families of potentials and GP hyperparameters at once | +| `n40ca_gp` | 7 | exactly the "GP, growing amplitude" rung of `gp_discrepancy`'s cross-section ladder: mock n + $^{40}$Ca data fitted by a volume-only potential with a GP discrepancy | + +## Densities: `bench_log_posterior.py` + +```bash +python benchmarks/bench_log_posterior.py --out benchmarks/results/jax-jitr4.json +python benchmarks/bench_log_posterior.py --out ... --problems linear gp --emcee 500 +python benchmarks/compare.py benchmarks/results/numpy-jitr3.json benchmarks/results/jax-jitr4.json +``` + +For each problem it records `log_posterior` at fixed parameter points (a +value regression), the first-call latency (compilation), the steady-state +time per call, the gradient's cost, the throughput of `log_posterior_batch` +at batch sizes 1, 32 and 256, and, with `--emcee N`, the wall time of 32 +walkers for `N` steps. Timings are medians over repeated calls after +warm-up. `compare.py` prints two runs side by side, with time ratios and +the largest relative difference of the values. + +The script runs against whichever rxmc is importable. The baseline +`numpy-jitr3.json` is the numpy rxmc 0.x (tag `v0.1.0`) on jitr 3.0.1, +whose gradient is a central finite difference of `2 ndim` calls; to +reproduce it, install that rxmc and jitr in a separate environment and run +this script there. + +Against that baseline (same machine, CPU): + +| problem | `log_posterior` | gradient (FD baseline to autodiff) | vmap, 256 rows | emcee $32 \times 500$ | +|---|---|---|---|---| +| line, reported errors | 0.16 to 0.10 ms | 0.66 to 0.11 ms | 6.2k to 1.06M evaluations/s | 2.9 to 1.9 s | +| 6 comparisons, 13 modes | 1.38 to 0.20 ms | 30.4 to 0.39 ms | 0.5k to 41k evaluations/s | | +| GP, N = 100 | 0.79 to 0.27 ms | 6.4 to 1.2 ms | 1.3k to 4.4k evaluations/s | 10.3 to 4.6 s | +| GP, N = 500 | 10.8 to 5.3 ms | 90 to 32 ms | 87 to 147 evaluations/s | | +| elastic, 4 energies | 7.0 to 2.6 ms | 70 to 6.0 ms | 142 to 331 evaluations/s | 106 to 45 s | +| (p,n) IAS, 1 energy | 5.2 to 2.1 ms | 43 to 4.1 ms | 191 to 450 evaluations/s | | + +The first call of a new problem pays compilation, 0.1 to 1 s. Values agree +to 1e-13 except for the reaction models, where jitr v4 solves every partial +wave up to `lmax` (elastic agrees to 1e-6). + +## Samplers: `bench_samplers.py` + +```bash +# everything (a day or more: the optical-model problems are meant for a cluster, see below) +python benchmarks/bench_samplers.py --out benchmarks/results/samplers.json +# some problems +python benchmarks/bench_samplers.py --out benchmarks/results/samplers.json --problems linear gp +# re-run some samplers into the saved file, keeping the others' results +python benchmarks/bench_samplers.py --out benchmarks/results/samplers.json --problems omp --only pocomc NUTS +# print a saved run, or the Markdown table below +python benchmarks/bench_samplers.py --report benchmarks/results/samplers.json --markdown +# recompute the reference posteriors (many hours for the three optical-model problems) +python benchmarks/bench_samplers.py --reference +``` + +emcee, dynesty, pocomc and NUTS run on every problem; `omp`, `alpha_gp` +and `n40ca_gp` also run ptemcee, HMC and PyMC's NUTS and HMC. The results +are written after each problem, so an interrupted run keeps what it +finished. + +The three optical-model problems, their references and the pocomc +settings sweeps (`benchmarks/sweep_pocomc.py`) take many hours; they are +meant to run as independent cluster jobs, each writing a file of its own +that `benchmarks/merge_results.py` merges afterwards. +`benchmarks/hpc/README.md` is the runbook. + +### The samplers and their starts + +Each sampler starts the way it is usually used, and pays for the search +that finds its start: the search's wall time and evaluations are added to +its own. + +| sampler | start | budget on `omp` | +|---|---|---| +| [emcee](https://emcee.readthedocs.io/) | a ball about the MAP (`rx.optimize.find_map`, L-BFGS-B) | 32 walkers $\times$ 3000 steps | +| [ptemcee](https://github.com/NuclearTalent/ptemcee_2025) | the same ball, at every temperature | 32 walkers $\times$ 8 temperatures $\times$ 2000 steps, adaptive ladder | +| [dynesty](https://dynesty.readthedocs.io/) | the prior | rwalk, 500 live points, to $\Delta\log Z$ = 0.5 | +| [pocomc](https://pocomc.readthedocs.io/) | the prior (the unit cube, with `log_likelihood(prior_transform(u))`) | `n_effective` = 4096, `n_active` = 2048 (eight times its defaults; 1024 and 512 on the other problems) | +| NUTS ([blackjax](https://blackjax-devs.github.io/blackjax/)) | the same ball as emcee | 2 chains $\times$ (300 warm-up + 1000 draws) | +| HMC (blackjax) | the same | as NUTS, 20 leapfrog steps | +| NUTS, HMC ([PyMC](https://www.pymc.io/)) | the same | as blackjax; HMC with path length 2 | + +A ball is `to_theta(to_unconstrained(start) + 0.01 N(0, I))`, inside the +support. The gradient samplers run on `log_posterior_unconstrained` +(recipe 41); PyMC calls it through a PyTensor Op whose gradient is +`jax.grad`. Every chain sampler starts about the MAP rather than the +maximum of the likelihood, because on `hierarchy` the likelihood depends on +`mu + tau * eta_j` alone, so its maximum is a ridge, not a point. On +`hierarchy` emcee and NUTS start from prior draws instead, because its MAP +is far from the bulk of the posterior: the non-centred mode shrinks the +`eta_j` toward their prior and inflates $\tau$ to compensate, putting $\tau$ at 1.27 +against a posterior of $0.31 \pm 0.04$. The other problems' budgets are in +`BUDGETS` at the top of the script. + +dynesty runs rwalk with 500 live points, and pocomc 1024/512, on every +problem but the three optical-model ones, where pocomc runs at 4096/2048 +(below). Every setting of this sweep, the defaults included, is correct on +`elastic`; none is correct on the funnels, `gp` and `modes`, on more than +one seed of three. Bias / width, the worst over seeds 100, 101 and 102 +(`sweep_pocomc.py --grid` on `benchmarks/results/hpc/sweep_{gp,modes,elastic}.json`, +run on the cluster): + +| setting | `gp` | `modes` | `elastic` | +|---|---|---|---| +| dynesty rwalk, 200 live points (default) | 0.26 / 0.41 ✗ | 0.70 / 0.45 ✗ | 0.04 / 0.07 | +| dynesty rwalk, 500 | 0.42 / 0.38 ✗ | 0.22 / 0.17 ✗ | 0.04 / 0.02 | +| dynesty rslice, 250 | 0.35 / 0.39 ✗ | 0.30 / 0.34 ✗ | 0.06 / 0.04 | +| dynesty rslice, 500 | 0.36 / 0.29 ✗ | 0.15 / 0.14 ✗ | 0.06 / 0.04 | +| pocomc 512/256 (default) | 0.69 / 0.59 ✗ | 0.53 / 0.30 ✗ | 0.03 / 0.02 | +| pocomc 1024/512 | 0.81 / 0.51 ✗ | 0.42 / 0.25 ✗ | 0.02 / 0.02 | +| pocomc 2048/1024 | 0.53 / 0.58 ✗ | 0.17 / 0.11 ✗ | 0.03 / 0.02 | + +On the funnels a run's error scatters from seed to seed as much as from +setting to setting: dynesty rslice with 250 live points is 0.35 / 0.39, +0.19 / 0.16 and 0.06 / 0.29 on `gp`, so one run says little about a +setting. (An earlier sweep on one local machine, whose files were not +kept, found that setting correct on `gp`; these seeds do not reproduce it.) +More resolution helps on `modes`, where pocomc 2048/1024 is correct on +one seed (0.09 / 0.06) and dynesty rslice's worst halves from 250 to 500 +live points, but not visibly on `gp` (see the discussion). + +The three optical-model problems need much more. `omp` has two islands, +about 87 % of its posterior in a narrow one about the MAP and the rest in a +broader one; `alpha_gp` has two families of potentials, about 74 % of its +posterior in the deeper one; `n40ca_gp` has one mode. A run that +under-samples a narrow island puts too much weight on the other: at +1024/512 pocomc put 23 to 85 % of its draws away from `omp`'s MAP island, +and its log Z was low by up to 2.2 as a result. Each seed below (100, 101, +102) is a separate run, scored against the reference (next section; ? marks +an error the reference cannot resolve); the share is of `omp`'s minor +island (0.131 in the reference) and of `alpha_gp`'s deeper family (0.740): + +| problem | pocomc | bias / width, each seed | share | log Z | wall time | +|---|---|---|---|---|---| +| `omp` | 1024/512 | 1.99 / 0.49 ✗, 0.34 / 0.20 ✗, 1.93 / 0.31 ✗ | 0.82, 0.23, 0.85 | -8.86, -6.67, -8.81 | 231–348 s | +| `omp` | 2048/1024 | 0.19 / 0.06 ✗, 0.25 / 0.19 ✗, 0.13 / 0.03 ? | 0.17, 0.20, 0.15 | -6.62, -6.69, -6.68 | 406–477 s | +| `omp` | 4096/2048 | 0.17 / 0.12 ✗, 0.07 / 0.05 ?, 0.04 / 0.05 ? | 0.16, 0.15, 0.14 | -6.66, -6.64, -6.69 | 824–889 s | +| `alpha_gp` | 1024/512 | 0.47 / 0.81 ✗, 0.11 / 0.05 ?, 0.30 / 0.07 ✗ | 0.96, 0.76, 0.66 | -84.75, -84.55, -84.54 | 376–431 s | +| `alpha_gp` | 2048/1024 | 0.14 / 0.04 ?, 0.10 / 0.07 ?, 0.10 / 0.05 ? | 0.72, 0.79, 0.75 | -84.53, -84.13, -84.57 | 528–632 s | +| `alpha_gp` | 4096/2048 | 0.04 / 0.01, 0.02 / 0.01, 0.07 / 0.02 ? | 0.73, 0.74, 0.71 | -84.50, -84.52, -84.55 | 928–1089 s | +| `n40ca_gp` | 1024/512 | 0.29 / 0.05 ✗, 0.40 / 0.13 ✗, 0.16 / 0.14 ? | | -11.33, -11.40, -11.32 | 129–150 s | +| `n40ca_gp` | 2048/1024 | 0.05 / 0.09 ?, 0.31 / 0.12 ✗, 0.12 / 0.06 ? | | -11.35, -11.40, -11.36 | 190–206 s | +| `n40ca_gp` | 4096/2048 | 0.10 / 0.05 ?, 0.03 / 0.08 ?, 0.09 / 0.10 ? | | -11.36, -11.35, -11.34 | 305–338 s | + +(Wall times on 8 cores of a cluster node; references -6.65, -84.53, +-11.34.) 4096/2048, the benchmark's setting on all three, is wrong on one +seed of nine, `omp`'s seed 100 (0.17 / 0.12), so a user should run it more +than once and compare the runs. Every lower setting is wrong on at least +one seed of each problem except 2048/1024 on `alpha_gp`, which its +reference cannot tell from 4096/2048; the mode share separates them a +little (0.72 to 0.79 against 0.71 to 0.74, the reference 0.740). Below +4096/2048 the evidence holds up better than the moments: at 2048/1024 +log Z is within 0.06 of the reference on `omp` and `n40ca_gp` while the +moments are up to 0.31 sd off. + +dynesty is wrong on the two problems with separated modes at the +benchmark's setting (0.20 / 0.12 on `omp`, 0.30 / 0.26 on `alpha_gp`), and +even the references' check, rslice with 1000 live points, scatters from +run to run (next section). On `n40ca_gp`, with one mode, it is within the +reference's resolution. + +### How they are scored + +- **Calls.** A call is one evaluation of the log density and, for the + gradient samplers and the MAP search, its gradient. Each run's calls are + split by phase: + + | phase | what it is | + |---|---| + | search | the MAP search that found the start (each L-BFGS-B step is one value-and-gradient call) | + | warm-up | emcee's and ptemcee's discarded burn-in (every rung of ptemcee's ladder), NUTS's and HMC's step-size and mass-matrix adaptation, pocomc's tempering from the prior until $\beta$ reaches 1 | + | sampling | the calls that produced the kept draws: post-burn-in steps, post-warm-up trajectories, dynesty's whole run, pocomc's iterations at $\beta$ = 1 | + | evidence | pocomc's importance sampling of its normalizing flow for log Z | + +- **Time per call.** Wall time over calls: what a call costs on this + machine, sampler overhead included. emcee, ptemcee and pocomc hand over + many points at once and evaluate them in one `jax.vmap` call + (`log_posterior_batch`; `log_prior_batch` and `log_likelihood_batch` + through ptemcee's `mapper`; `log_likelihood_batch` on + `prior_transform_batch` for pocomc), which removes the per-point Python + overhead. On a reaction model the solver dominates and batching buys + nothing: on this CPU a vmapped `elastic` row costs about 3.0 ms against + 2.6 ms for a single call. The batch densities run in chunks of at most + `BATCH_CHUNK` = 256 rows, since a reaction model holds every row's + partial-wave solutions at once (about 3 MB a row for `elastic`). dynesty cannot batch: each live point's replacement is a + sequential walk, so it parallelises only across processes (`pool`, + `queue_size`), which the benchmark does not use. pocomc's time also + includes training its normalizing flow. A gradient call costs a few + value calls; blackjax evaluates `value_and_grad` once, while PyMC + evaluates the value and the gradient as two Ops, repeating the forward + pass, and adds PyTensor's own overhead. +- **ESS.** The smallest rank-normalised bulk effective sample size over + the parameters ([Vehtari et al. 2021](https://arxiv.org/abs/1903.08008), + `blackjax.diagnostics.ess_bulk`) across chains (the walkers, for the + ensembles). It is reported per second of wall time, start search and + compilation included, and per thousand calls. ESS per call does not + depend on the machine; ESS per second is what a user waits for. +- **Bias and width.** Every run is scored against a reference posterior + (`benchmarks/reference.py`, saved in `benchmarks/results/references.json`): + its bias is the largest $|\mu - \mu_\mathrm{ref}|$ over the parameters, + and its width error the largest $|\log(\sigma / \sigma_\mathrm{ref})|$, + both in reference standard deviations. The tolerance is `TOLERANCE` = 0.1. + A reference checked against an independent algorithm (next section) has a + resolution $r$, the larger of the bias and width gaps between the two: an + error more than $r$ above the tolerance is marked ✗, and one within $r$ of + it, on either side, ? (the reference cannot tell). $r$ is 0 for the + exact and NUTS references, 0.07 on `omp`, 0.05 on `alpha_gp` and 0.12 on + `n40ca_gp`. +- **The ESS of weighted draws is optimistic.** For dynesty and pocomc it is + [Kish's](https://en.wikipedia.org/wiki/Effective_sample_size) ESS of the + importance weights. That ignores the correlation between particles that + share an ancestor (pocomc's resampling, dynesty's random walks from live + points), so it overstates their ESS, and pocomc stops when Kish's ESS + reaches its `n_total` target, so its ESS sits near that target by + construction. The bias and width columns are the check that matters: + pocomc on `gp` reports an ESS of about 4500 with means 0.6 sd off. +- **Correct.** A run is correct if it converged (next) and neither error + is marked ✗; ESS is reported only for correct runs. A ? means correct as + far as the reference can tell. +- **Convergence.** A run has not converged (✗, and no ESS) if its + rank-normalised split [R-hat](https://arxiv.org/abs/1903.08008) + (`blackjax.diagnostics.rhat`) exceeds + 1.01 or, for an ensemble, its kept chain is shorter than 50 times emcee's + integrated autocorrelation time $\tau$. The second rule matters: walkers that + swap or stretch toward one another can agree, and pass R-hat, long before + they have explored the posterior. +- **Evidence.** log Z for dynesty, pocomc and ptemcee (thermodynamic + integration over its ladder), against the exact value where there is one. + +### The references + +| problem | reference | how | +|---|---|---| +| `linear`, `gp`, `hierarchy` | exact moments and log Z | the log posterior is quadratic in all but a few parameters (none; the GP's log variance and log length scale; the hierarchy's $\tau$). At each node of a grid over those, one Newton step over the rest lands on the conditional mode, and the Hessian there is the conditional precision, both exact for a quadratic; the conditional normalisers weight the nodes. | +| `modes`, `elastic` | moments | one long blackjax NUTS run, 4 chains $\times$ (1000 warm-up + 3000 draws) at target acceptance 0.95, from a ball about the MAP with a seed of its own, accepted only with a rank-normalised R-hat $\le$ 1.01 and no divergences (R-hat 1.001, 1.001; min bulk ESS 2475, 3920). Chains started from prior draws can stick in a minor mode: on `modes`, one with a log posterior 40 below the main one. | +| `omp`, `alpha_gp`, `n40ca_gp` | moments and log Z | three pocomc runs at 8192/4096, sixteen times its defaults, each with a seed of its own, pooled; accepted only if every run is within 0.05 of the pool; then checked against dynesty runs (rslice, 1000 live points; three on `omp`, fifty on `alpha_gp` and `n40ca_gp`), pooled the same way (log Z's error is half the runs' range or the largest quoted error, whichever is larger), on log Z (within twice the combined error), the mode share (within 0.03) and the moments (within 0.2 sd). A NUTS reference cannot work on `omp`: its chains stay in the island they start in. All three are accepted (their pocomc runs agree to 0.018, 0.012 and 0.042); all three are corroborated (below). | + +The benchmarked NUTS rows on `modes` and `elastic`, and the pocomc rows on +the three optical-model problems, are scored against runs that share their +algorithm, not their draws. On `gp` and `hierarchy`, where the reference is +exact, NUTS's means agree to 0.08. On the optical-model problems dynesty, +an independent algorithm, checks the reference, and the larger of the two +moment gaps is the reference's resolution $r$: + +| problem | log Z, pocomc / dynesty | moments, bias / width | mode share, pocomc / dynesty | corroborated | +|---|---|---|---|---| +| `omp` | -6.65 ± 0.04 / -6.40 ± 0.25 | 0.04 / 0.07 | 0.131 / 0.121 away from the MAP island | yes | +| `alpha_gp` | -84.53 ± 0.01 / -84.50 ± 0.82 | 0.05 / 0.02 | 0.740 / 0.756 in the deeper family | yes | +| `n40ca_gp` | -11.34 ± 0.01 / -11.53 ± 0.87 | 0.07 / 0.12 | (one mode) | yes | + +`alpha_gp` needed fifty dynesty runs. Single runs put 0.46 to 0.91 of the +mass in the deeper family, so nine pooled (0.787) carried a standard error +of 0.035 on the share and could not test the 0.03 bar; fifty carry 0.015, +and their 0.756 is 0.016 from pocomc's 0.740 (whose three runs agree on +0.739 to 0.743, and the sweep's 4096/2048 runs on 0.71 to 0.74). The +moment gap fell with it, from 0.16 at nine runs to 0.05: it was dynesty's +noise, not pocomc's bias. `n40ca_gp` has fifty too, which move its gap +from 0.15 / 0.09 at three runs to 0.07 / 0.12. + +The log Z check is looser than it looks at fifty runs: a pool's error is +half the runs' range, which grows with their number (0.82 and 0.87 above). +Against the standard error of the fifty runs' mean, dynesty agrees on +`alpha_gp` (-84.50 ± 0.05 against -84.53) but not on `n40ca_gp`, where it is +0.18 below pocomc (-11.53 ± 0.06 against -11.34), about three standard +errors; the benchmark's dynesty run is low there too. The moments and the +share are unaffected. + +### Results + +> The `omp`, `alpha_gp` and `n40ca_gp` rows ran on a cluster (8 cores of an +> AMD EPYC "amd20" node per sampler, `benchmarks/hpc/`), the others on one +> local machine: compare wall times within a problem, not +> across these two groups; calls and ESS per thousand calls do not depend on +> the machine. + +| problem | sampler | wall time | calls | search | warm-up | sampling | evidence | ms/call | bias | width | min ESS | ESS/s | ESS/1k calls | R-hat | τ (steps) | log Z | +|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---| +| linear (2) | emcee | 6 s | 384075 | 0% | 33% | 67% | 0% | 0.01 | 0.00 | 0.00 | 7619 | 1324.66 | 19.84 | 1.006 | 33 | | +| linear (2) | dynesty | 34 s | 93609 | 0% | 0% | 100% | 0% | 0.37 | 0.02 | 0.03 | 1605 | 46.75 | 17.15 | — | | 0.7 ± 0.24 | +| linear (2) | pocomc | 27 s | 53760 | 0% | 70% | 23% | 8% | 0.50 | 0.02 | 0.01 | 4292 | 159.70 | 79.84 | — | | 0.6 ± 0.06 | +| linear (2) | NUTS | 6 s | 62145 | 0% | 49% | 51% | 0% | 0.09 | 0.03 | 0.01 | 732 | 132.75 | 11.77 | 1.003 | | | +| linear (2) | reference: quadrature | | | | | | | | | | | | | | | 0.64 (exact) | +| gp (4) | emcee | 18 s | 96329 | 0% | 33% | 66% | 0% | 0.19 | 0.07 | 0.30 ✗ | — | — | — | 1.062 ✗ | 82 (< 50 τ) | | +| gp (4) | dynesty | 71 s | 139598 | 0% | 0% | 100% | 0% | 0.51 | 0.20 ✗ | 0.11 ✗ | — | — | — | — | | 80.3 ± 0.28 | +| gp (4) | pocomc | 73 s | 99840 | 0% | 71% | 25% | 4% | 0.73 | 0.60 ✗ | 0.42 ✗ | — | — | — | — | | 80.2 ± 0.04 | +| gp (4) | NUTS | 211 s | 245453 | 0% | 68% | 32% | 0% | 0.86 | 0.08 | 0.23 ✗ | — | — | — | 1.018 ✗ | | | +| gp (4) | reference: quadrature | | | | | | | | | | | | | | | 80.48 (exact) | +| elastic (5) | emcee | 162 s | 48212 | 0% | 33% | 66% | 0% | 3.35 | 0.07 | 0.03 | — | — | — | 1.071 ✗ | 41 (< 50 τ) | | +| elastic (5) | dynesty | 646 s | 232479 | 0% | 0% | 100% | 0% | 2.78 | 0.04 | 0.02 | 2399 | 3.71 | 10.32 | — | | 495.9 ± 0.34 | +| elastic (5) | pocomc | 312 s | 84480 | 0% | 81% | 15% | 5% | 3.69 | 0.02 | 0.03 | 4501 | 14.42 | 53.28 | — | | 496.0 ± 0.01 | +| elastic (5) | NUTS | 324 s | 48984 | 0% | 53% | 47% | 0% | 6.62 | 0.06 | 0.02 | 673 | 2.07 | 13.73 | 1.003 | | | +| elastic (5) | reference: NUTS, 4 x 3000 draws | | | | | | | | | | | | | | | | +| hierarchy (33) | emcee | 11 s | 408000 | 0% | 33% | 67% | 0% | 0.03 | 1.43 ✗ | 0.58 ✗ | — | — | — | 1.504 ✗ | 518 (< 50 τ) | | +| hierarchy (33) | dynesty | 4256 s | 1926706 | 0% | 0% | 100% | 0% | 2.21 | 0.05 | 0.11 ✗ | — | — | — | — | | 76.2 ± 0.55 | +| hierarchy (33) | pocomc | 3410 s | 663040 | 0% | 92% | 7% | 1% | 5.14 | 0.39 ✗ | 0.21 ✗ | — | — | — | — | | 73.9 ± 0.17 | +| hierarchy (33) | NUTS | 41 s | 406667 | 0% | 30% | 70% | 0% | 0.10 | 0.08 | 0.01 | 536 | 13.14 | 1.32 | 1.006 | | | +| hierarchy (33) | reference: quadrature | | | | | | | | | | | | | | | 73.97 (exact) | +| modes (9) | emcee | 10 s | 96478 | 0% | 33% | 66% | 0% | 0.10 | 0.36 ✗ | 0.24 ✗ | — | — | — | 1.319 ✗ | 177 (< 50 τ) | | +| modes (9) | dynesty | 92 s | 222314 | 0% | 0% | 100% | 0% | 0.41 | 0.13 ✗ | 0.22 ✗ | — | — | — | — | | 103.2 ± 0.29 | +| modes (9) | pocomc | 130 s | 91136 | 0% | 62% | 33% | 4% | 1.43 | 0.59 ✗ | 0.29 ✗ | — | — | — | — | | 102.7 ± 0.08 | +| modes (9) | NUTS | 61 s | 340473 | 0% | 69% | 31% | 0% | 0.18 | 0.05 | 0.04 | 851 | 13.88 | 2.50 | 1.008 | | | +| modes (9) | reference: NUTS, 4 x 3000 draws | | | | | | | | | | | | | | | | +| alpha_gp (9) | emcee | 166 s | 97744 | 2% | 33% | 65% | 0% | 1.70 | 1.32 ✗ | 1.48 ✗ | — | — | — | 1.605 ✗ | 164 (< 50 τ) | | +| alpha_gp (9) | dynesty | 584 s | 274264 | 0% | 0% | 100% | 0% | 2.13 | 0.30 ✗ | 0.26 ✗ | — | — | — | — | | -84.6 ± 0.31 | +| alpha_gp (9) | pocomc | 1048 s | 442368 | 0% | 99% | 0% | 1% | 2.37 | 0.03 | 0.01 | 7625 | 7.27 | 17.24 | — | | -84.5 ± 0.01 | +| alpha_gp (9) | NUTS | 780 s | 219832 | 1% | 49% | 50% | 0% | 3.55 | 0.60 ✗ | 1.43 ✗ | — | — | — | 1.008 | | | +| alpha_gp (9) | ptemcee | 859 s | 513744 | 0% | 33% | 66% | 0% | 1.67 | 1.39 ✗ | 7.85 ✗ | — | — | — | 1.447 ✗ | 121 (< 50 τ) | -89.4 ± 4.87 | +| alpha_gp (9) | HMC | 203 s | 53744 | 3% | 22% | 74% | 0% | 3.78 | 0.57 ✗ | 1.42 ✗ | — | — | — | 1.014 ✗ | | | +| alpha_gp (9) | PyMC NUTS | 3037 s | 140769 | 1% | 43% | 55% | 0% | 21.58 | 0.59 ✗ | 1.43 ✗ | — | — | — | 1.009 | | | +| alpha_gp (9) | PyMC HMC | 868 s | 148213 | 1% | 71% | 28% | 0% | 5.85 | 0.58 ✗ | 1.47 ✗ | — | — | — | 1.002 | | | +| alpha_gp (9) | reference: pocomc 8192/4096, 3 runs | | | | | | | | | | | | | | | -84.53 ± 0.01 | +| n40ca_gp (7) | emcee | 41 s | 96778 | 1% | 33% | 66% | 0% | 0.42 | 0.05 ? | 0.09 ? | — | — | — | 1.045 ✗ | 65 (< 50 τ) | | +| n40ca_gp (7) | dynesty | 284 s | 278094 | 0% | 0% | 100% | 0% | 1.02 | 0.06 ? | 0.08 ? | 3843 | 13.55 | 13.82 | — | | -11.9 ± 0.34 | +| n40ca_gp (7) | pocomc | 336 s | 280576 | 0% | 99% | 0% | 1% | 1.20 | 0.02 ? | 0.03 ? | 7180 | 21.37 | 25.59 | — | | -11.4 ± 0.01 | +| n40ca_gp (7) | NUTS | 94 s | 95455 | 1% | 49% | 51% | 0% | 0.99 | 0.10 ? | 0.08 ? | 491 | 5.20 | 5.15 | 1.005 | | | +| n40ca_gp (7) | ptemcee | 225 s | 512778 | 0% | 33% | 67% | 0% | 0.44 | 0.14 ? | 0.15 ? | 4418 | 19.65 | 8.62 | 1.008 | 9 | -17.4 ± 21.77 | +| n40ca_gp (7) | HMC | 56 s | 52778 | 1% | 23% | 76% | 0% | 1.06 | 0.08 ? | 0.07 ? | 722 | 12.89 | 13.67 | 1.003 | | | +| n40ca_gp (7) | PyMC NUTS | 139 s | 84674 | 1% | 44% | 55% | 0% | 1.64 | 0.10 ? | 0.07 ? | 626 | 4.49 | 7.39 | 1.004 | | | +| n40ca_gp (7) | PyMC HMC | 106 s | 61151 | 1% | 64% | 35% | 0% | 1.74 | 0.05 ? | 0.10 ? | 655 | 6.16 | 10.71 | 1.003 | | | +| n40ca_gp (7) | reference: pocomc 8192/4096, 3 runs | | | | | | | | | | | | | | | -11.34 ± 0.01 | +| omp (9) | emcee | 183 s | 96876 | 1% | 33% | 66% | 0% | 1.89 | 1.26 ✗ | 1.29 ✗ | — | — | — | 1.593 ✗ | 170 (< 50 τ) | | +| omp (9) | dynesty | 565 s | 255013 | 0% | 0% | 100% | 0% | 2.21 | 0.20 ✗ | 0.12 ? | — | — | — | — | | -6.4 ± 0.32 | +| omp (9) | pocomc | 807 s | 311296 | 0% | 99% | 0% | 1% | 2.59 | 0.07 ? | 0.07 ? | 6815 | 8.44 | 21.89 | — | | -6.7 ± 0.01 | +| omp (9) | NUTS | 626 s | 161531 | 1% | 51% | 49% | 0% | 3.87 | 0.91 ✗ | 0.35 ✗ | — | — | — | 1.694 ✗ | | | +| omp (9) | ptemcee | 927 s | 512876 | 0% | 33% | 67% | 0% | 1.81 | 1.35 ✗ | 7.34 ✗ | — | — | — | 1.535 ✗ | 97 (< 50 τ) | -12.0 ± 2.34 | +| omp (9) | HMC | 214 s | 52876 | 2% | 23% | 76% | 0% | 4.04 | 0.31 ✗ | 0.75 ✗ | — | — | — | 1.005 | | | +| omp (9) | PyMC NUTS | 613 s | 106554 | 1% | 45% | 54% | 0% | 5.76 | 0.32 ✗ | 0.68 ✗ | — | — | — | 1.006 | | | +| omp (9) | PyMC HMC | 727 s | 130313 | 1% | 80% | 19% | 0% | 5.58 | 0.30 ✗ | 0.79 ✗ | — | — | — | 1.007 | | | +| omp (9) | reference: pocomc 8192/4096, 3 runs | | | | | | | | | | | | | | | -6.65 ± 0.04 | + +Which sampler is correct (? included), and fastest among those that are, +on each problem: + +| problem | correct | fastest correct | +|---|---|---| +| `linear` | all four | emcee and NUTS, 6 s each; emcee with ten times the ESS per second | +| `gp` | none at these budgets | emcee's means are closest (0.07), but its widths are 0.30 off and its kept chain is 25 $\tau$, not 50 | +| `modes` | NUTS | NUTS, 61 s | +| `elastic` | dynesty, pocomc, NUTS | pocomc, 312 s (NUTS 324 s, dynesty 646 s) | +| `hierarchy` | NUTS | NUTS, 41 s, at 3000 draws per chain | +| `omp` | pocomc (?) | pocomc, 807 s, at 4096/2048 | +| `alpha_gp` | pocomc | pocomc, 1048 s, at 4096/2048 | +| `n40ca_gp` | all but emcee, each within the reference's resolution (?) | HMC, 56 s (NUTS 94 s, PyMC HMC 106 s, PyMC NUTS 139 s, ptemcee 225 s, dynesty 284 s, pocomc 336 s); with log Z, pocomc (dynesty's is 1.7 errors low) | + +- **Funnels defeat the samplers that start from the prior.** `gp`, `modes` + and `hierarchy` each have a scale parameter that, when small, pins the + others into a narrow neck: the GP's log variance against its bound, the + shared normalisation mode's width, the hierarchy's $\tau$. dynesty and + pocomc under-visit the neck and come out wrong, in the means or the widths + depending on the problem (on `gp` both bias the log variance, by 0.20 and + 0.60; on `hierarchy` both come out too narrow, by 0.11 and 0.21). More + resolution narrows the error only slowly, and on `hierarchy` it costs an + hour (dynesty misses the width by 0.11 after 71 min, pocomc is 0.39 off + after 57 min). NUTS, adapting a step size to the neck, is correct on + `modes` and `hierarchy` in about a minute (on `hierarchy` with 3000 draws + per chain; 1000 give an R-hat of 1.021). On `gp` it is not: 31 of its + transitions diverge in the neck and its widths come out 0.23 too narrow, + while its means agree. emcee on `gp`, started at the MAP, has its means + within the tolerance but its widths 0.30 off, and its kept chain is + 25 $\tau$. +- **Separated modes defeat the samplers that start at the MAP, and R-hat + seldom tells.** On `omp` and `alpha_gp` the gradient samplers, started + from a ball about the MAP, stay in the island or family they start in. + On `omp`, blackjax's HMC and PyMC's NUTS and HMC are 0.30 to 0.32 sd off + in their means and 0.68 to 0.79 in their widths, while their + rank-normalised R-hats are 1.005 to 1.007; on `alpha_gp` all four are + 0.57 to 0.60 off in their means and 1.42 to 1.47 in their widths, with + R-hats of 1.002 to 1.014. Chains that never visit an island agree with + one another about it. blackjax's NUTS on `omp` is the exception: its two + chains disagree (R-hat 1.69, min ESS 3), and it is 0.91 off. Only + pocomc, at eight times its default resolution, is not shown wrong on + both; at lower resolutions it weighs the islands differently from seed to + seed (the sweep above). On the one-mode problems the gradient samplers do + well: on `n40ca_gp` every converged sampler is within the reference's + resolution, and on `elastic` NUTS, pocomc and dynesty are correct. +- **The ensembles do not converge in these budgets** outside `linear`, where + emcee needs 12 000 steps for the rank-normalised R-hat to pass (3000 + and 6000 steps give 1.019 and 1.010). emcee is short of 50 $\tau$ everywhere else, and on + `omp`, `alpha_gp` and `hierarchy` it is 1.3, 1.3 and 1.4 sd off, with + R-hats of 1.59, 1.61 and 1.50. ptemcee, started at the MAP, is 14 and 11 $\tau$ + long on `omp` and `alpha_gp`, with R-hats of 1.54 and 1.45, and 1.4 sd + off on both; its $\beta$ = 1 walkers have collapsed in one parameter each + (`log_sigma_B` on `omp`, `log_A_q` on `alpha_gp`), to an sd 1/1500 and + 1/2600 of the reference's (width errors of 7.3 and 7.9). On `n40ca_gp` it + converges (149 $\tau$, R-hat 1.008), 0.14 / 0.15 from the reference, within + its resolution. +- **Evidence.** Against the exact log Z, dynesty is within its error on + `linear` and `gp` ($80.3 \pm 0.28$ against 80.48) but 4 errors high on + `hierarchy` ($76.2 \pm 0.55$ against 73.97); pocomc is within its error on + `hierarchy`, 1.2 errors low on `linear` and 6 errors low on `gp` ($80.2 \pm 0.04$), where its + posterior is biased too. Against the optical-model references (pooled + pocomc, checked by dynesty), dynesty's evidence is right even where its + posterior is not: $-6.42 \pm 0.32$ against -6.65 on `omp`, $-84.61 \pm 0.31$ + against -84.53 on `alpha_gp`, though 1.7 errors low on `n40ca_gp` + ($-11.92 \pm 0.34$ against -11.34). ptemcee's thermodynamic integration is + 2.3, 1.0 and 0.3 errors low on the three ($-11.95 \pm 2.34$, $-89.36 \pm 4.87$, + $-17.4 \pm 21.8$), errors too wide to say much. Like Kish's ESS, pocomc's + log Z error leaves out the correlation between its particles. +- **Cost per call.** On a reaction model the solver dominates whatever the + sampler: a call costs 1.7 to 2.6 ms on `omp` and `alpha_gp` and 0.4 to + 1.2 ms on `n40ca_gp` (the cluster), and 2.8 to 3.7 ms on `elastic` (the + local machine). A gradient call costs 3.6 to 4.0 ms in blackjax on `omp` + and `alpha_gp`, and 5.6 to 5.8 ms in PyMC on `omp`, which repeats the + forward pass for its gradient Op; the two give the same answers (NUTS on + `alpha_gp` is 0.60 / 1.43 off in blackjax and 0.59 / 1.43 in PyMC). + PyMC's NUTS on `alpha_gp`, at 21.6 ms a call, is an unexplained outlier. + On the cheap densities emcee, evaluating its walkers in one batch, pays + 0.015 to 0.19 ms per point; dynesty, which cannot batch, pays 3 to 84 + times more, and pocomc 0.5 to 5 ms, its per-call time including the + training of its normalizing flow. pocomc spends 62 to 99 % of its calls + tempering from the prior to the posterior. + +## `gp_discrepancy` under other seeds: `gp_seed_check.py` + +The notebook fits its three-rung cross-section ladder with pocomc at +4096/2048 and seeds 10, 11 and 12, one run per rung. `gp_seed_check.py` +reruns the ladder at the same settings with three other seed sets (20 + i, +30 + i, 40 + i for rung i) to see how much of what the notebook quotes is +the seed's (`results/hpc/gp_seed_check.json`; wall times on one local +machine): + +| seeds | log Z: bare | proportional error | GP, growing amplitude | $\Delta\log Z$: proportional - bare | GP - proportional | +|---|---|---|---|---|---| +| notebook (10-12) | -467.21 ± 0.01 | 91.12 ± 0.01 | 103.91 ± 0.04 | 558.3 | 12.8 | +| 20-22 | -467.20 ± 0.01 | 91.11 ± 0.01 | 103.92 ± 0.02 | 558.3 | 12.8 | +| 30-32 | -467.22 ± 0.01 | 91.14 ± 0.02 | 103.97 ± 0.07 | 558.4 | 12.8 | +| 40-42 | -467.19 ± 0.01 | 91.14 ± 0.01 | 103.93 ± 0.02 | 558.3 | 12.8 | + +The volume parameters' medians, and the notebook's 68 % intervals in +brackets: + +| rung | seeds | $V_v$ | $W_v$ | $R_v$ | $a_v$ | +|---|---|---|---|---|---| +| bare | notebook | 26.82 [26.41, 27.25] | 16.63 [16.39, 16.86] | 4.431 [4.409, 4.452] | 0.659 [0.653, 0.665] | +| bare | 20, 30, 40 | 26.81, 26.82, 26.81 | 16.62, 16.62, 16.62 | 4.432, 4.431, 4.432 | 0.659, 0.659, 0.659 | +| proportional error | notebook | 29.98 [27.49, 32.80] | 18.18 [16.82, 19.66] | 4.277 [4.153, 4.391] | 0.690 [0.655, 0.725] | +| proportional error | 20, 30, 40 | 30.06, 30.21, 29.91 | 18.21, 18.27, 18.12 | 4.272, 4.265, 4.278 | 0.690, 0.692, 0.689 | +| GP, growing amplitude | notebook | 43.80 [42.46, 45.36] | 13.64 [12.69, 14.60] | 4.288 [4.221, 4.347] | 0.487 [0.466, 0.511] | +| GP, growing amplitude | 20, 30, 40 | 43.70, 43.74, 43.60 | 13.65, 13.65, 13.69 | 4.294, 4.290, 4.298 | 0.485, 0.486, 0.484 | + +Every number the notebook quotes holds under other seeds: each rung's log Z +moves by at most 0.06 from the notebook's, the evidence for the GP over the +proportional error is 12.8 in every set, and every median moves by at most +0.16 of its 68 % interval's half-width (the GP rung's $R_v$). The GP +rung's medians in every set, the notebook's included, lie within 0.12 +posterior standard deviations of `n40ca_gp`'s reference. diff --git a/docs/bugs_found.md b/docs/bugs_found.md deleted file mode 100644 index f9949fb..0000000 --- a/docs/bugs_found.md +++ /dev/null @@ -1,209 +0,0 @@ -# Bugs and inconsistencies found during the architecture review - -Found while reading the `api_generalisation` branch (head `b8bc7d8`) for the -ground-up design comparison in `groundup_design.md`. Every item was verified -by reading the code at the cited lines (line numbers refer to `b8bc7d8`). -Items are grouped by how sure I am that they are wrong rather than merely -fragile. - -**Status:** every item except 11 is fixed on this branch; each carries a -**Resolution** line. Item 11 is a design-level change and is deferred to -`groundup_design.md`. - -## Confirmed bugs - -### 1. `IsobaricAnalogPNObservation` silently drops two solver arguments - -- **Where:** `src/rxmc/ias_pn_observation.py:52-53` (constructor signature) - and `:113-120` (the `set_up_solver` call). -- **What:** the constructor accepts `wavelengths_beyond_range` and - `zeros_per_node`, documents them (`:92-94`), and `set_up_solver` takes them - (`:209-210`), but the call inside `__init__` never forwards them. The - defaults are always used. The elastic observation forwards both - (`src/rxmc/elastic_diffxs_observation.py:149-150`). -- **Why it matters:** a user tuning the Lagrange basis size for the (p,n) IAS - channel gets no effect and no error. -- **Fix:** add the two keyword arguments to the `set_up_solver` call. -- **Resolution:** forwarded; `test_reaction_observation.py::TestSolverSettingsForwarding` - asserts the kwargs reach `set_up_solver` for both reaction observations. - -### 2. `BatchedAdaptiveMetropolisSampler` adapts its proposal during burn-in - -- **Where:** `src/rxmc/param_sampling.py:376-388`. -- **What:** the class docstring (`:304`), the `sample` docstring (`:354`) and - the `burn` parameter docstring (`:366-368`) all say the proposal covariance - is replaced only after *non-burn* batches. The code recomputes - `self.proposal_cov` and `self.args` unconditionally; only `record_batch` is - guarded by `if not burn`. -- **Why it matters:** burn-in batches feed the adaptation, so the behaviour - differs from what the docstring promises and from `AdaptiveMetropolisSampler`. - Either the doc or the code is wrong. Adapting during burn-in is arguably - the *better* behaviour, so the likely fix is to the docstrings. -- **Fix:** decide, then make the docstrings and the `if not burn:` guard agree. -- **Resolution:** kept the code behaviour (adapt after every batch, burn-in - included) and fixed the three docstrings. `sample` now also refreshes - `self.proposal` so it never goes stale; pinned by - `test_sampler.py::TestSamplerPriors::test_batched_adaptive_updates_proposal_after_burn_batch`. - -### 3. `Parameter` defines `__eq__` without `__hash__` - -- **Where:** `src/rxmc/params.py:39-48`. -- **What:** defining `__eq__` sets `__hash__ = None`, so `Parameter` objects - are unhashable. Every uniqueness check in the package keys on `id(p)` or - `p.name` for this reason (`covariance.py`, `constraint.py`, `evidence.py`), - and nothing documents it. -- **Why it matters:** `set(model.params)` or `{p: value}` raises `TypeError` - at runtime. It is a trap for anyone extending the package, and it is the - root reason the by-identity routing needs `id()` bookkeeping. -- **Fix:** either drop `__eq__` (identity is the sharing semantics anyway) or - add `__hash__ = object.__hash__`. See `groundup_design.md` §2.1. -- **Resolution:** value-based `__hash__` consistent with the existing value - `__eq__`; `bounds` is coerced to a 2-tuple of floats so the hash is stable; - `__repr__` added. Identity routing in `covariance.py` / `evidence.py` is - untouched. New `test/test_params.py`. - -### 4. Two independent pint `UnitRegistry` instances - -- **Where:** `src/rxmc/elastic_diffxs_observation.py:24` and - `src/rxmc/ias_pn_observation.py:12`. -- **What:** each module builds its own registry. pint refuses to combine - quantities from different registries. -- **Why it matters:** latent today because no code path mixes the two, but any - helper that takes a quantity from one module into the other will raise. - `DEFAULT_LMAX = 20` is likewise duplicated (`:27` and `:14`). -- **Fix:** one `ureg` in a shared module (`observation_from_measurement.py` - is the natural home; its docstring already says it holds what the two share). -- **Resolution:** `ureg`, `DEFAULT_LMAX`, `XS_UNIT`, `RUTHERFORD_UNIT` and - `MB_PER_B` live in `observation_from_measurement.py` (now exported from - `rxmc`); both observation modules import and re-export them. - `test_reaction_observation.py::TestSharedUnits`. - -## Inconsistencies between the two sampler front ends - -`CalibrationConfig` and `Walker` are meant to be two drivers over the same -posterior. They are not. - -### 5. `Walker.log_posterior` evaluates the likelihood when the prior is `-inf` - -- **Where:** `src/rxmc/walker.py:140-143` versus - `src/rxmc/config.py:405-411`. -- **What:** the config path short-circuits on a non-finite prior and skips - the forward model. The walker path always calls `Evidence.log_likelihood` - first. The Gibbs conditional has the same split: - `config.conditional_posterior` (`config.py:579-583`) short-circuits, - the inline closure at `walker.py:130-132` does not. -- **Why it matters:** out-of-bounds proposals cost a full reaction-model - solve in the walker. With bounds also enforced inside the kernels this is - a performance bug, not a correctness bug, but it is a silent divergence. -- **Resolution:** `Walker.log_posterior` and the Gibbs closure evaluate the - prior first and return `-inf` without touching the likelihood. - `test_sampler.py::TestWalkerPosterior::test_*_skips_likelihood_when_prior_neg_inf`. - -### 6. Tempering exists only on the config path - -- **Where:** `config.py:245-252, 384, 583`; no counterpart in `walker.py`. -- **What:** `likelihood_scaling` scales the likelihood (and the Gibbs - conditionals) in `CalibrationConfig`. `Walker` has no such knob; the only - way to temper is `Evidence(weights=...)`. `examples/overconfidence.ipynb` - demonstrates both and prints a check that they agree. -- **Why it matters:** two names for one concept, with one of them reachable - from only one driver. -- **Resolution:** `Walker(..., likelihood_scaling=)` added with the same - semantics as the config (scales the likelihood in the model block and the - Gibbs conditionals, never the prior). - `test_sampler.py::TestWalkerPosterior::test_*_applies_likelihood_scaling*`. - -### 7. List-of-scipy priors are accepted by one driver and rejected by the other - -- **Where:** `config.py:133-135, 153-155, 184-185` (list branches in - `ParameterConfig`) versus `param_sampling.py:66-70` (`_validate_object` - requires `prior.logpdf`) and `walker.py:131, 160` (calls - `sampler.prior.logpdf` directly). -- **What:** `ParameterConfig` special-cases a plain list of frozen scipy - distributions in three places. A `Sampler` built with the same list fails - at construction because a list has no `logpdf`. -- **Why it matters:** the prior protocol is documented as one thing and - implemented as two. `IndependentPrior` already exists to wrap a list; - `ParameterConfig` could wrap in `__init__` and delete all three branches. -- **Resolution:** `rxmc.priors.as_prior` wraps a list/tuple in - `IndependentPrior`; both `ParameterConfig.__init__` and `Sampler.__init__` - call it, and the four list branches in `ParameterConfig` are gone. - Behaviour change: `x0` for a list prior is now seeded (`IndependentPrior` - default seed) instead of drawing from numpy's global state, and - `config.prior` returns the wrapper. Tests in `test_config.py`, - `test_sampler.py`, `test_priors.py`. - -### 8. `ParameterConfig._infer_dim` misreads priors whose `mean` is a method - -- **Where:** `src/rxmc/config.py:92-98`. -- **What:** if the prior has no integer `dim`, the fallback is - `int(np.size(dist.mean))`. For any object whose `mean` is a *method* this - is `1`, regardless of the true dimension. -- **Why it matters:** a custom multi-dimensional prior exposing `mean()` is - reported as one-dimensional and rejected at `config.py:109-113` with a - misleading message. Frozen scipy multivariate distributions happen to - expose `mean` as an array, which is why the tests pass. -- **Fix:** call `mean` if callable, or require `dim` and drop the guess. -- **Resolution:** an integer `dim` wins; otherwise `mean` is called when it - is a method. `test_config.py::test_infer_dim_calls_mean_method`. - -## Fragile, not wrong - -These are not bugs today but each is one refactor away from becoming one. - -### 9. Unit conventions split across model and observation with no shared constant - -- `elastic_diffxs_model.py:166` and `ias_pn_model.py:124, 170` divide by a - bare `1000` (mb/sr to b/sr). The matching assumption lives in the - observation as `ureg.millibarn / ureg.steradian` - (`elastic_diffxs_observation.py:204`). Nothing ties them together. -- **Resolution:** both models divide by `MB_PER_B`, derived from the shared - registry next to `XS_UNIT` / `RUTHERFORD_UNIT`, which the observations now - use. `test_reaction_observation.py::TestSharedUnits::test_unit_constants_agree`. - -### 10. Model and observation compatibility is checked by string, or not at all - -- `elastic_diffxs_model.py:137, 174` compare `observation.quantity` to - `self.quantity`. `ias_pn_model.py:135, 159` reach straight for - `observation.constraint_workspace` with no check. Pairing an elastic model - with an IAS observation fails inside jitr with a shape error. -- **Resolution:** each model checks `isinstance` against its observation class - first in `evaluate` and `visualizable_model_prediction` and raises a named - `ValueError` (a string check cannot work: both observations report - `quantity == "dXS/dA"`). `test_reaction_models.py::TestObservationTypeChecks`. - -### 11. Masked views share solver workspaces by reference, routed by `id()` - -- `observation.py:204` uses `copy.copy`, so a masked view of a reaction - observation shares both jitr workspaces and every array with its root. - `transforms.py:281, 301` route `per_observation_scaling` by - `id(obs.identity)`, and `test_holds_observation_references` exists only to - stop id recycling. Any deep copy, pickle, or reconstruction of an - observation breaks the routing with a `KeyError` at evaluation time. -- **Deferred:** design-level; see `groundup_design.md` §2.3–2.4 (bind-time - predictors, blocks without identity keys). - -### 12. The burn-in loop in `Walker.walk` duplicates the main loop - -- `walker.py:207-221` versus `:229-241`: identical bodies apart from - `burn=True` and the progress string. Any change to one must be mirrored. -- **Resolution:** one `_run_batch(steps, burn)` sweep plus `_batch_message`; - the burn-in line prints no acceptance fraction because nothing is recorded - during burn-in. `test_sampler.py::TestWalkerPosterior::test_burn_message_has_no_acceptance_fraction`. - -### 13. `prior_transform` clips the unit cube only at the top level - -- `config.py:492-506` clips `u` to `[eps, 1-eps]`; `ParameterConfig.prior_transform` - and `IndependentPrior.prior_transform` (`priors.py:273-277`) do not. - Calling either directly with an exact `0.0` or `1.0` returns `±inf`. - (`TruncatedNormalPrior` is finite at the boundary by construction.) -- **Resolution:** `rxmc.priors.clip_unit_cube` is applied in all four - transforms. `test_priors.py::TestUnitCubeClipping`, - `test_config.py::test_prior_transform_boundary_finite`. - -## Already fixed on this branch - -- The `_rows` row-count check in `model_comparison.py` was reported by an - earlier read as unable to fire. At `b8bc7d8` it is called without `n` for - the model samples and with `n` for the covariance samples (`:138, 143`), - which is correct. diff --git a/docs/conf.py b/docs/conf.py index 22f4d51..4770fd5 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -47,6 +47,9 @@ # myst-nb — notebooks are pre-executed; never re-run them during the build nb_execution_mode = "off" +# $...$, $$...$$ and amsmath environments in Markdown and notebooks become +# math nodes, so MathJax loads and renders them +myst_enable_extensions = ["dollarmath", "amsmath"] # MathJax — enable $...$ inline and \[...\] display delimiters used in docstrings mathjax3_config = { diff --git a/docs/design.md b/docs/design.md index fe892ce..e088146 100644 --- a/docs/design.md +++ b/docs/design.md @@ -1,245 +1,862 @@ -# Design: the stacked covariance model - -This page records the architecture of `rxmc`'s covariance layer — the design -that replaced the pre-0.1 "likelihood model zoo" — and the decisions locked in -during that refactor. - -## The two mechanisms - -Two different things hide under "share a covariance," and they live on -different axes: - -- **(A) Correlating observations** is a statement about **covariance - structure** — off-diagonal blocks coupling observation *i* and *j*. -- **(B) Two covariance terms sharing a parameter** is a statement about - **parameter wiring** — the observations stay independent; one θ component - feeds two different terms. - -**A couples the data; B couples the parameters.** They get distinct -mechanisms: - -- **A — the covariance owns the stacked block.** A - {class}`~rxmc.constraint.Constraint` is the maximal block of - mutually-correlated data: it owns one multivariate likelihood over the - stacked vector `y = [y1; y2; ...]` of its observations. A *coupling* term is - simply one whose `support` spans more than one observation block. -- **B — parameter routing by identity.** - {class}`~rxmc.covariance.ConstraintCovariance` deduplicates the - {class}`~rxmc.params.Parameter` objects its terms reference **by identity** - (gather, not slice): referencing the *same* object in two terms yields one - entry in the sampled vector, gathered into both. - -The normalization example shows why both are needed: two datasets with -*independent* flux measurements of the same *magnitude* are case B (two -block-local `normalization_term`s sharing one `Parameter`); two datasets -normalized by the *same* uncertain flux are case A (one `normalization_term` -whose support spans both blocks). This is the D'Agostini / Barlow -correlated-systematics distinction. - -## Terms and the assembled covariance - -There is exactly one term type. A {class}`~rxmc.covariance.Term` is a -numpy-style callable `fn(c, *values) -> array` of a -{class}`~rxmc.covariance.TermContext` `c` — the term's local view of the -stacked `x`, `y` and `ym` on its `support` — and the sampled values of the -`Parameter`s it declares, plus a `kind` saying how the array enters the -covariance: - -| `kind` | `fn` returns | contribution | -|------------|-------------------------------|---------------------------------| -| `"diag"` | standard-deviation vector `v` | `Σ_ii += v_i²` | -| `"mode"` | mode vector `v` | `Σ += v vᵀ` (one correlated mode) | -| `"matrix"` | symmetric block `M` | `Σ_block += M` | - -A plain array instead of `fn` is a fixed contribution (factored once and -cached). `support=None` (the default) means *the whole constraint* and is -bound when the term is added to a `ConstraintCovariance`; an explicit support -places a term on a subset of a multi-observation constraint. A `coords` -transform (see below) is applied to `x[support]` before `fn` sees it, so a -kernel can live in momentum transfer rather than angle without the term -knowing. - -The factory helpers are one-line conveniences over this single type: -`statistical_term`, `normalization_term`, `offset_term`, `noise_term`, -`noise_fraction_term`, `model_error_term`, `systematic_term` (a mode with a -user basis), and `kernel_term` (sklearn kernels; one parameter per free -hyperparameter *element*, plus an optional parametric `amplitude` so that -`Σ += a aᵀ ∘ K`). Bases are ordinary callables of the `TermContext` -(`ones`, `ym`, `averaging`, `x_basis(scale)`, or parametric ones like -`exp_growth(scale)` whose extra parameters are passed as `basis_params`). -Anything the helpers cannot say is a direct `Term`: +# Design: declare, then compile + +`rxmc` calibrates reaction models to experimental data by Bayesian +inference, with the error model declared as part of the problem. Every +statistical choice a study makes, which errors are statistical and which +are correlated, whether a normalisation is inferred or marginalised, +whether the model is allowed a discrepancy, which points are held out, +appears in the declaration, so that a reviewer can read the declaration and +write down the likelihood. The library owns no sampler: a compiled +`Problem` exposes the densities and the prior transform that pocomc, emcee, +dynesty or `black-box-bayes` need, and their gradients and Hessians for +gradient-based samplers and optimisers. + +The numerical backend is JAX. Everything a density evaluation runs, the +models (the `jitr` solver included), the covariance terms, the structured +covariance, the likelihood and the prior's log density, is written in +`jax.numpy` and compiled once per problem with `jax.jit`, so `jax.grad`, +`jax.hessian` and `jax.vmap` work through `Problem.log_posterior`. What +needs no derivative stays numpy and scipy: the compile step's bookkeeping, +the prior transform and prior draws, diagnostics and predictive draws. + +This document is the maintainer's description of the library. Read it +with `recipes.md`, which states every supported use case with its spelling +and expected behaviour, one test per recipe, and with the notebooks in +`examples/`, which are the tutorials for the recipes. + +The mechanics rest on one rule: + +> **Everything the user constructs is an immutable declaration. +> `Problem` is the only compile step.** + +## 1. Rules for the maintainer + +The review checklist for every change. + +1. **Specs hold no caches and no solver state.** `Parameter`, `Dataset`, + `Term`, `Comparison` and `Constraint` are frozen dataclasses with + `eq=False`; identity is the equality, for every spec. `Model` is a + plain class with the same contract. Anything expensive or grid-dependent + lives in the objects `Problem` builds, or in a cache a reaction model + drops on pickling. +2. **Exactly one function walks the parameter graph:** `Problem.__init__`. + Nothing else assigns slots, checks names, resolves supports or decides + which prior covers which slot. +3. **Gather, never split.** Every callable node receives one integer + gather array at compile time and is evaluated as `node(*theta[gather])`. + There is no parameter count to carry around and no chain slicing by + position; `problem.columns(params)` is how a caller finds a column. +4. **Every user-supplied callable has one shape:** `fn(context, *values)`, + where `context` is the grid `x` (models, transforms) or a `TermContext` + (terms, bases, amplitudes) and `values` are the sampled values of the + parameters the node declares, in declaration order. (Kernel builders are + the exception: `build(*values)` returns a tinygp kernel.) +5. **Sharing is spelled by passing the same `Parameter` object.** Inside a + term, between terms, between a model and a term, across constraints. + There is no second identity notion and no value equality anywhere. +6. **One factorisation path.** `StructuredCovariance` is the only way a + covariance is factored. The dense matrix exists as a display method and + as the reference in tests. +7. **Fail at compile, and name the dataset.** A singular constant + covariance, duplicate parameter names, a slot no prior covers, an `on=` + that references a comparison outside its constraint, a non-finite value + in comparison space: all raised by `Problem`, never mid-chain. +8. **Nothing is folded into a covariance silently.** A dataset's reported + systematics become terms only when asked, through + `comparison.reported_terms()`; `test/test_regression.py` pins the + covariance with both reported terms added. +9. **A term on several comparisons sees the gathered stack.** Its + `TermContext` carries `segments`, `labels` and `split()` so that a basis + which differentiates or smooths along the grid stays within one + comparison. Nothing is ever split for the term. +10. **A covariance that reads the prediction is the generative model's + marginal likelihood.** Its log-determinant pulls the posterior mode + toward smaller predictions, and a flat prior on a prediction-scaled + covariance has a `1/rho` tail. That is a property of the model, not a + bug; the Peelle-safe *evaluation* is the estimate-built refit (recipes + 27 and 37 state both, with numbers). +11. **A `Problem` pickles with `dill`.** `black-box-bayes` ships it to + every MPI rank by path. A round trip of a reaction problem is in the + suite. +12. **Correctness lives in tests that pin numbers**, not in defensive + branches: the closed-form likelihoods, delta-method errors under `log`, + the regression log-likelihood `1.195784087817536`, dense-versus- + structured equality on every error-model form, and the closed forms of + the reference papers. Every recipe in `recipes.md` is a test under + `test/recipes/` (`test/test_recipes_index.py` enforces the mapping), + and every notebook names the recipes it teaches + (`test/test_notebooks_index.py`). + +## 2. The API, module by module + +Modules in dependency order. Signatures are the ones in the source; the +docstrings carry the details. + +### 2.1 `params.py` ```python -# noise growing with angle: sigma(theta) = eps * exp(l * theta / pi) -Term(lambda c, e, l: np.exp(e) * np.exp(l * c.x / np.pi), (log_eps, slope), kind="diag") -# the same thing through the helper -noise_term(log_eps, basis=exp_growth(np.pi), basis_params=(slope,)) -``` - -{class}`~rxmc.covariance.ConstraintCovariance` assembles the terms. It is -constructed with the true observation block boundaries -(`blocks=stacked_supports(observations)`), from which two structural facts are -decided **once, conservatively**: - -- `block_diagonal` — true only if every off-diagonal-capable term - (`couples_offdiagonal`, i.e. `kind != "diag"`) provably sits inside a single - block. With no blocks supplied, any coupling-capable term forces the dense - path; there is no guessing from support shape. -- `is_constant` — true when no term depends on parameters or context; the - Cholesky factors (dense and per-block) are then computed once and cached - read-only. - -`ConstraintCovariance.stacked_distance(ctx, params)` owns the dispatch between -the block-diagonal fast path (factor each block separately, `O(Σ nᵢ³)`) and a -single dense Cholesky — and is the seam where a future low-rank (Woodbury) -path would slot in. - -## Transforms are one low-level type - -{class}`~rxmc.transforms.Transform` is a numpy-style callable -`fn(a, *values)` with an optional tuple of `Parameter`s, an optional analytic -derivative and inverse, and composition via `|`. Anything callable is accepted -wherever a transform is expected. The same type serves three roles, so there -is no wrapper class per use: - -- **Comparison space, on the observation.** `Observation(x, y, - transform=log)` takes *raw* `y`, stores `y_raw`, `y = log(y_raw)`, and the - delta-method statistical error `|t′(y_raw)|·σ`; the `Constraint` applies the - same transform to the model prediction, so the model is written once, in - physical space, and can never be double-transformed. `obs.log_jacobian` - (`Σ log|t′|`) is the constant needed to compare evidences across comparison - spaces. Parametric transforms are rejected here. -- **Parametric model transforms, on the model.** `PhysicalModel(params, - transform=scale())` appends the transform's parameters to the model's and - applies it after `evaluate` (unlike the former `ScaledModel`, which prepended a - `log normalization` parameter, the scale parameters come *last* and default to - `log_rho` / `log_rho_i`). This is the Kennedy–O'Hagan latent scale ρ (it - changes the *mean*, so it is not a covariance term); - `per_observation_scaling(observations)` gives one ρᵢ per dataset, routed by - observation identity. -- **Coordinates, on a term.** `Term(..., coords=q)` / `kernel_term(kernel, - coords=q)` evaluate the term in transformed coordinates; a parametric - `coords` contributes its parameters to the term. - -## Masks: hold-out as part of support - -Which points *enter* a likelihood is a property of the support machinery, not -of the data: `Observation(..., mask=)` (or `obs.masked(mask)`, -`obs.masked_where(lambda x: x < cut)`) marks points active at the point level -without rebuilding anything — a reaction observation keeps its solver -workspace — and `Constraint(..., mask=)` selects observations at the -constraint level. The two combine into `constraint.active`, the stacked -indices the residual and the factorisation are restricted to; `n_data_pts` is -the active count. Terms are always authored over the full stack, so the same -term list describes the fit and the held-out views: `constraint.complement()` -is the held-out counterpart (every inactive point becomes active), sharing the -`Term`/`Parameter` objects so a posterior sample of the fit scores it directly -(see {mod}`rxmc.model_comparison`). - -## Observations are leaves - -An {class}`~rxmc.observation.Observation` is pure data — `x`, `y`, -`y_stat_err` — plus the measurement's reported systematic magnitudes retained -as **inert metadata** (`y_sys_err_normalization` fractional, -`y_sys_err_offset` absolute in internal units). It emits only its statistical -diagonal automatically. Every correlated mode is an explicit term: -`obs.systematic_terms()` converts the metadata on request (propagated to the -comparison space by the delta method when the observation has a transform), and -**nothing is ever folded into a covariance silently** — a deliberate behavior -change from pre-0.1 versions, pinned by regression tests. - -The reaction observation classes' `from_measurement` constructors keep this -contract across unit conversion: dimensionful errors (statistical, offset) are -divided by the unit normalization (retained as `obs.norm`; a per-angle array -in the Rutherford-conversion cases), the fractional normalization error passes -through untouched. - -## Constraints, likelihood functionals, and parameters - -`Constraint(observations, physical_model, likelihood=GaussianLikelihood(), -extra_terms=(), include_statistical_term=True, mask=None)` builds the stacked covariance -from each observation's statistical term plus the explicit `extra_terms` -(`include_statistical_term=False` composes the entire covariance from -`extra_terms`, e.g. to let a `noise_term` *replace* reported statistics). - -A likelihood ({class}`~rxmc.likelihood_model.Likelihood`: -`GaussianLikelihood`, `StudentT`, `Chi2`) is a thin functional of the -pre-computed `(d2, logdet, n)` statistics. The constraint's parameter vector -is the **full tuple** — covariance parameters followed by likelihood -parameters (e.g. Student-t `nu`) — and every method (`log_likelihood`, `chi2`, -`covariance_matrix`, `marginal_log_likelihood`) takes it in that order, -validating the count. - -Mean renormalization (a Kennedy–O'Hagan latent scale ρ) is **not** a -covariance term: it changes the mean, so it lives on the model side as a -parametric transform (`PhysicalModel(..., transform=rxmc.transforms.scale())` -or `per_observation_scaling(observations)`), flowing through the ordinary -model-parameter machinery. - -## Model comparison lives outside the sampler - -{mod}`rxmc.model_comparison` consumes a constraint plus posterior *samples* and -never touches a sampler: posterior-predictive draws from `N(ym(θ), Σ(θ))` on -the active points (or the model-only predictive), empirical coverage curves and -sharpness, held-out log predictive scores on `constraint.complement()`, and -nested-sampling evidence bookkeeping (`logz_summary` with replicate-based -errors — the sampler's own error is a lower bound — and `compare_logz` with a -conservative tie verdict). `log_jacobian` supplies the comparison-space -constant for comparing evidences of, say, a log-space and a linear-space fit -of the same data. - -## Error-model recipes - -The motivating study — comparing error models for α+Ca elastic scattering data -without reported uncertainties — becomes one term list per model: - -| error model | `extra_terms` | -|----------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------| -| constant noise (log space) | `[noise_term(log_err)]` with `Observation(..., transform=log)` | -| fractional noise (linear space) | `[noise_fraction_term(log_err)]` | -| noise growing with angle | `[noise_term(log_err, basis=exp_growth(np.pi), basis_params=(slope,))]` | -| + rank-one mode ∝ θ | `[..., systematic_term(log_sys, basis=x_basis(np.pi))]` | -| + rank-one offset / normalisation | `[..., offset_term(parameter=log_sys)]` / `[..., normalization_term(parameter=log_sys)]` | -| GP discrepancy in angle, constant amplitude | `[..., kernel_term(Matern(1.0, nu=2.5), coords=lambda x: x/np.pi, amplitude=constant_amplitude, amplitude_params=(log_A,))]` | -| GP with angle-growing amplitude | `[..., kernel_term(..., amplitude=exp_growth_amplitude(1.0), amplitude_params=(log_A, slope))]` | -| GP in momentum transfer with amplitude `A q^{r/2}` | `[..., kernel_term(RBF(1.0), coords=lambda x: 2*k*np.sin(x/2), amplitude=lambda c, lA, r: np.exp(lA)*c.x**(r/2), amplitude_params=(log_A, r))]` | -| heavy tails | any of the above with `likelihood=StudentT()` | - -Fit/held-out splits are `obs.masked_where(lambda x: x < cut)` and -`constraint.complement()`; evidences are compared with -`compare_logz(logz_summary(...), logz_summary(...))` after adding -`log_jacobian` to the log-space fits. - -## Scope decisions (locked) - -- **Constraint = maximal correlated block.** {class}`~rxmc.evidence.Evidence` - stays a weighted sum over *independent* constraints, so factorization cost - is bounded at the block level. -- **Covariance/likelihood parameters are constraint-scoped.** Case-A and - case-B sharing both happen *within* a constraint. Sharing a `Parameter` - object across constraints, or duplicating a parameter name anywhere in an - `Evidence`, is a hard error — the sanctioned model for a systematic shared - between datasets is one constraint with a cross-block coupling term. -- **Tempering is consistent**: `Evidence` weights and - `CalibrationConfig.likelihood_scaling` apply to the likelihood only (never - the prior), including inside the Gibbs conditionals. -- **Fail fast**: constant covariances are factored eagerly at `Constraint` - construction, so a singular covariance (e.g. an EXFOR subentry with no - statistical error and no covering term) raises a named, actionable error - instead of a `LinAlgError` mid-chain. - -## Known limitations - -- **No low-rank fast path yet.** Cross-block couplings are typically low rank, - and the design anticipates a Woodbury / matrix-determinant-lemma update on - top of the block-diagonal base; today they take the dense `O(N³)` path. - `ConstraintCovariance.stacked_distance` is the seam. -- **Non-constant block-diagonal covariances still assemble the dense `N×N` - matrix** before factoring its blocks (per-term `add_to` writes into the full - matrix by design). -- **Masked rows are still assembled.** The full `N×N` covariance is built and - then restricted to the active rows; a held-out view pays for the inactive - rows' terms (cheap next to the forward model, but not free for large dense - kernels). -- Multi-mode systematics on `Observation` are deferred; the factory helpers - accept a `mask=` argument directly for masked (partial-support) terms. +@dataclass(eq=False, frozen=True) +class Parameter: + name: str + bounds: tuple[float, float] = (-inf, inf) + prior: object | None = None # frozen scipy univariate: logpdf, cdf, ppf, rvs + logpdf: Callable | None = None # jnp prior density when its family is not in JAX_LOGPDFS + unit: str = "" + latex: str | None = None + label -> str # latex, falling back to name +``` + +A parameter *is* its object; it keys dictionaries and is matched by +identity everywhere. It may carry its own marginal prior. The rules, +enforced once at compile: + +| declared | prior used | +|---|---| +| `prior=dist` | `dist` truncated to `bounds` (log-density `-inf` outside; `ppf` rescaled between `cdf(lo)` and `cdf(hi)`) | +| finite `bounds`, no `prior` | uniform on `bounds` | +| neither | must be covered by a joint prior given to `Problem`, else a compile error naming the parameter | + +### 2.2 `transforms.py` + +```python +class Transform: # fn(a, *values) -> array; params; derivative; inverse + def __call__(self, a, *values) + def derivative(self, a, *values) + def __or__(self, other) # (f | g)(a) = g(f(a)); params f + g + n_params, is_identity, inverse + +identity, log, exp # parameter-free; identity.inverse is identity, log/exp are inverses +def scale(parameter=None, log=True, name=None) -> Transform # rho * a; default Parameter("log_rho") +def as_transform(t) -> Transform # None -> identity; callable -> parameter-free Transform +``` + +One type, three roles: the comparison space of a `Comparison`, a mean +transform composed onto a `Model`, and the coordinates a `Term` is +evaluated in. `is_identity` is an object-identity test on the singleton, +the only fast path. `fn` is written with `jax.numpy`; without an analytic +`derivative=` the derivative is taken by automatic differentiation +(elementwise), not by finite differences. + +### 2.3 `units.py` and `data.py` + +```python +# units.py +XS_UNIT = "b/sr"; RUTHERFORD_UNIT = "mb/sr"; MB_PER_B = 1000.0; DEFAULT_LMAX = 20 +def parse_unit(label) -> (factor, kind) # the exfor_tools / x4i3 label vocabulary; kind is + # "differential" or "dimensionless"; anything else raises +def check_angle_grid(angles_rad, name) +``` + +```python +# data.py +@dataclass(eq=False, frozen=True) +class Dataset: + x: ndarray # radians for reaction data + y: ndarray # physical units + y_err: ndarray # statistical, physical units; zeros allowed + norm_err: float | ndarray | None = None # reported fractional normalisation, inert + offset_err: float | ndarray | None = None # reported absolute offset, physical units, inert + label: str = "" + meta: Mapping = {} # reaction, Elab, ExIAS, quantity, k, eta, ... + n -> int + +def from_measurement(measurement, *, reaction=None, quantity=None, ExIAS=None) -> Dataset +``` + +`Dataset` is pure data: no comparison transform, no mask, no solver +workspace. `from_measurement` is the one EXFOR adapter. It reads the +`exfor_tools.Distribution` fields (`x, y, Einc, quantity, y_units, +statistical_err, systematic_norm_err, systematic_offset_err, subentry`) from +any object shaped like one, converts angles to radians and the cross +section through `parse_unit`, scales every dimensionful error with the data +and leaves the fractional normalisation error alone, and fills `meta` with +the kinematics. `dXS/dA` and `dXS/dRuth` convert into each other through +the closed-form Rutherford cross section of the kinematics, which makes the +conversion a per-angle factor; a neutron projectile or a missing reaction +is a named error. `rxmc` never imports `exfor_tools`. + +### 2.4 `model.py` + +```python +class Model: # fn(x, *values) -> y in physical space + params: tuple[Parameter, ...] + def bind(self, x, meta=None) -> Predictor # generic: closes over x; reaction models override + def __or__(self, transform) -> Model # mean transform; its params appended + def __add__(self, other) -> Model # additive mean discrepancy; params left then right + def __mul__(self, other) -> Model # multiplicative correction; scale() is its constant case + +class Predictor: # a model bound to a grid + params, x + def __call__(self, *values) -> array # jax + +def polynomial(order) -> Model # a_0 + a_1 x + ...; params a0..an, no priors +``` + +- `omp | scale(rho_1)` is a model with parameters `omp.params + (rho_1,)`; + per-dataset Kennedy and O'Hagan scales are distinct `rho_i` objects on + distinct comparisons. +- `omp + delta` with `delta = Model(fn, phi)` is the explicit, sampled mean + discrepancy; `omp * g` the multiplicative one (an additive discrepancy in + log space). Both bind each side to the same grid and combine the + predictors, so a reaction model and a plain function combine without + special cases. Composition is left to right: `(omp + delta) | scale(rho)` + scales the sum. +- Plotting on a fine grid is `model.bind(x_fine, d.meta)(*row[problem.columns(model.params)])`. + +### 2.5 `terms.py` + +```python +@dataclass(eq=False, frozen=True) +class TermContext: + x: ndarray # coords(x) on the support + y: ndarray # data on the support, comparison space + ym: ndarray | None # prediction on the support; None while a constant term is evaluated + __len__ + meta(key) -> ndarray # the owning dataset's meta[key], one value per point + segments -> tuple[slice, ...] # rows of each spanned comparison within the gathered support + labels -> tuple[str, ...] # their labels, in the same order + split(a) -> list # a[s] for s in segments + +@dataclass(eq=False, frozen=True) +class Term: + fn: Callable | ndarray # fn(c: TermContext, *values) -> vector | matrix + params: tuple[Parameter, ...] = () + kind: "diag" | "mode" | "matrix" = "matrix" + on: Comparison | Dataset | sequence | None = None # None = whole constraint + coords: Transform = identity # applied to x before fn sees it; its params appended + constant: bool = False # fn reads neither ym nor parameters; evaluated once + +@dataclass(eq=False, frozen=True) +class KernelTerm(Term): # what kernel() returns + build, n_kernel, amplitude, jitter +``` + +| `kind` | `fn` returns | contribution | +|---|---|---| +| `"diag"` | standard-deviation vector `v` | $\Sigma_{ii} \mathrel{+}= v_i^2$ | +| `"mode"` | vector `v` | $\Sigma \mathrel{+}= v v^\mathsf{T}$ | +| `"matrix"` | symmetric block `M` | $\Sigma_\mathrm{block} \mathrel{+}= M$ | + +Support is a reference, not integer indices: `on=comp` places the term on +that comparison, `on=[c1, c2]` spans both (case A), `on=None` is the whole +constraint; a `Dataset` also resolves. A term is stateless and may sit in +two constraints. An array-valued `fn` is a fixed contribution checked for +shape and symmetry at construction. + +The factories: + +```python +statistical(y_err, on=None) +offset(parameter=None, magnitude=None, mask=None, log=True, on=None) +normalization(parameter=None, magnitude=None, mask=None, log=True, on=None) +noise(parameter, log=True, basis=None, basis_params=(), on=None, coords=None) +proportional_error(parameter, averaging=False, log=True, on=None) +systematic(parameter, basis, log=True, basis_params=(), on=None, coords=None) +kernel(build, params=(), coords=None, amplitude=None, amplitude_params=(), + jitter=1e-10, on=None) -> KernelTerm # build(*values) -> tinygp kernel +kernel_params(names, bounds=None, prefix="discrepancy") -> list[Parameter] +# bases and amplitudes: ones, ym, averaging, x_basis(scale), exp_growth(scale, base=ones), +# constant_amplitude, exp_growth_amplitude(scale) +``` + +`noise` and `proportional_error` are additive on top of the reported diagonal; +`Constraint(statistical=False)` makes them replace it. `normalization` +reads `c.ym`, never `c.y`. `proportional_error` and `normalization` are +fractions of the prediction, which is a relative error only in linear +space, so a `Constraint` refuses them on a comparison with another +`space` (`Term(relative=True)`). In log space a multiplicative error is +additive, $\log y(1+\epsilon) \approx \log y + \epsilon$, so the same +fractional sizes are written directly: + +| uncertainty | linear space | log space | +|---|---|---| +| uncorrelated, a fraction $\gamma$ of each point | `proportional_error(log_gamma)` | `noise(log_gamma)` | +| a normalisation, a fraction $\eta$ shared by every point | `normalization(log_eta)` | `offset(log_eta)` | +| a reported normalisation or offset | `comp.reported_terms()` | `comp.reported_terms()` (delta method) | + +`kernel` takes a builder `build(*values) -> +tinygp kernel` and the parameters it consumes; the builder owns the +parameterisation (log space, sums and products of kernels, an anisotropic +metric through `tinygp.transforms.Linear`), and a tinygp kernel object +itself is a fixed kernel. tinygp kernels carry no hyperparameter metadata, +so the parameters are declared, by hand or with `kernel_params`; passing +the same objects to several `kernel` calls shares hyperparameters between +per-comparison kernels. Every term `fn`, basis and amplitude is written +with `jax.numpy`. + +Hierarchy is sharing plus `meta`: a hyperparameter shared by several +datasets is one object placed in one term per comparison, and anything +dataset-specific the term needs comes from `c.meta(key)`. A discrepancy +correlated *across* datasets is one `matrix` term spanning them that builds +its inputs from `c.meta("Elab")` and `c.x`; it takes the dense path. + +### 2.6 `likelihood.py` + +```python +class Likelihood: # functional of (d2, logdet, n); no parameters of its own + def log_likelihood(self, d2, logdet, n) + def chi2(self, d2, logdet, n) # d2 +class Gaussian(Likelihood) +class Chi2(Likelihood) # -d2/2, no log-determinant +``` + +Both are exported from the package (`rx.Gaussian`, `rx.Chi2`). There +is no multivariate t: it is one global error scale with a heavy-tailed +prior, not a robust likelihood (recipe 9). + +### 2.7 `constraint.py` + +```python +@dataclass(eq=False, frozen=True) +class Comparison: # one dataset, one model, one comparison space + data: Dataset + model: Model # bound at construction: model.bind(data.x, data.meta) + space: Transform = identity # parameter-free + predictor, y, y_err, log_jac # derived once: space(data.y), delta-method errors, per-point Jacobian + n; predict(*values); log_jacobian(mask=None) + def reported_terms(self) -> list[Term] # offset then normalisation modes from the dataset's + # reported errors, delta-method propagated, on=self + +@dataclass(eq=False, frozen=True) +class Constraint: # the maximal block of mutually correlated data: one likelihood + comparisons: tuple[Comparison, ...] + terms: tuple[Term, ...] = () + likelihood: Likelihood = Gaussian() + weight: float = 1.0 # tempering; multiplies this constraint's log-likelihood only + statistical: bool = True # add each comparison's y_err diagonal + masks: tuple[ndarray, ...] | None = None + offsets, active, n_total, n_active, log_jacobian, support(on) + def masked(self, masks); def masked_where(self, predicate); def complement(self) +``` + +The comparison space lives on the comparison because it is a modelling +choice. Masks live on the constraint: `masked`, `masked_where` and +`complement` return a `Constraint` with the same `Comparison`, `Term` and +`Parameter` objects and new masks, so a held-out problem built from +`complement()` shares every parameter with the fit and a posterior sample +scores it directly. `weight` is the one tempering knob. Eager checks +here need nothing from the parameter graph: distinct comparisons, an +array-valued term of the right shape for its `on`, a non-finite comparison +space caught at compile with the comparison's label. + +### 2.8 How the pieces thread + +There are exactly two parametric entry points; everything else is fixed +when the comparison is built. + +| stage | space | what enters | parametric | +|---|---|---|---| +| 1. `Predictor` | physical | $f(x; \alpha)$ on the data grid | model parameters | +| 2. mean modifications, composed on the `Model` | physical | `\| scale(rho)`, `* g(x, phi)`, `+ delta(x, phi)` | $\rho$, $\phi$ | +| 3. `space` | physical to comparison | `y = space(data.y)`, `ym = space(step 2)`, `y_err = \|space'\| * data.y_err`, `log_jacobian` | none | +| 4. `Term`s, seeing `TermContext(x, y, ym)` | comparison | statistical diagonal; experimental terms (noise, reported modes, USU); model-discrepancy terms (kernel, bases) | term parameters, and `ym` | +| 5. `Likelihood` | comparison | functional of `y - ym` and $\Sigma$ | none | + +Experimental and model-discrepancy terms are one mechanism; the difference +is what the user means. A term that reads `ym` sees the prediction after +the mean modifications and after `space`, so a reported normalisation +error applies to the measured scale and `reported_terms()` gets that for +free. Mean-side discrepancy is physical-space and `x`-aware; covariance- +side discrepancy is comparison-space and `ym`-aware. The normalisation +stays on the mean rather than dividing the data: dividing would make +`space` parametric, and in linear space a data-side normalisation is what +Peelle's Pertinent Puzzle warns about (recipe 27). + +### 2.9 `problem.py`: the compile step + +```python +class Problem: + def __init__(self, constraints, priors=()): # priors: [(params, joint), ...] + index: ParameterIndex; constraints: tuple[CompiledConstraint, ...]; priors + ndim, names, bounds, params + def columns(self, params) -> ndarray + def log_prior / log_likelihood / log_posterior / chi2 (theta) # float, or a tracer under JAX + def grad_log_posterior / value_and_grad_log_posterior / hessian_log_posterior (theta) + def grad_log_likelihood / value_and_grad_log_likelihood (theta) + def prior_transform(self, u); def sample_prior(self, n, rng=None) # numpy/scipy + def predict(self, theta, physical=False) -> list[list[ndarray]] # per constraint, per comparison + def log_jacobian(self) -> float + NDIM, parameter_names, starting_location(n), log_posterior_batch(thetas) # black-box-bayes spellings +``` + +`Problem.__init__` is the only place that walks the graph. For each +constraint it stacks the comparisons (comparison space, one slice each), +registers every predictor's and term's parameters in +first-seen order through `index.add_all`, which returns the gather array +for that node, resolves each term's `on` to rows, and builds the +`StructuredCovariance`, whose constant parts are factored eagerly so a +singular block is reported with its label. Parameters that only a joint +prior block mentions, a hyperprior's hyperparameter, get slots after every +constraint. Names are then checked unique and the prior assembled. +Compile the same declarations twice and you get two independent problems. + +**The densities.** The last step of `__init__` compiles the pure-JAX +densities once with `jax.jit`; every index they use is numpy fixed at +compile, so the traced function sees only `theta`. On a concrete `theta` +the public methods return Python floats, and under a JAX transformation the +tracer, so `jax.grad(problem.log_posterior)` works. `log_posterior` +evaluates the prior first and runs the likelihood under `lax.cond`: outside +the prior's support the forward models do not run and the gradient is zero. +A non-finite prediction or a singular covariance gives `-inf`; NaN-prone +pieces are evaluated at a safe input, so a rejected `theta` keeps a finite +gradient (a user model must take its logs safely itself). Pickling drops +the compiled functions and unpickling rebuilds them. + +**Prior assembly.** Each slot is covered by its parameter's marginal or by +exactly one joint block `(params, joint)`, where `joint` has +`logpdf(values)` over those parameters in that order and optionally +`prior_transform(u)` and `rvs(size=n, random_state=rng)` (scipy's +spelling); `scipy.stats.multivariate_normal` qualifies and is whitened for +the unit-cube map, and renormalised by its mass inside any bounds (a custom +joint's `logpdf` must already be normalised on its truncated support). A +joint that declares its dimension (`dim`) must match +its parameters, and a one-parameter block holding a scipy univariate +distribution is that parameter's marginal. A hyperprior is a joint +block that includes its hyperparameter, whose `logpdf` is +`sum log p(child | hyper) + log p(hyper)` and whose `prior_transform` draws +the hyperparameter first (recipe 24). A slot no prior covers, or covered +twice, is a compile error naming it. + +The prior's log density is JAX. A scipy marginal is translated to an +equal JAX density for the families in `problem.JAX_LOGPDFS` (normal, +uniform, truncated normal, gamma, beta, lognormal, half-normal, Cauchy, +half-Cauchy, Student-t, exponential, Laplace, logistic, inverse gamma), +with the truncation mass still computed by scipy at compile; any other +family needs `Parameter(logpdf=...)`, its density in `jax.numpy`. A +frozen multivariate normal joint is translated; a custom joint's `logpdf` +must be `jax.numpy` and is checked at compile with `jax.eval_shape`. The +unit-cube map and the draws stay scipy. + +**`CompiledConstraint`** holds the stacked `x`, `y`, `y_err`, the offsets +and active rows, the predictors with their gathers, the covariance, the +likelihood and its gather, the weight and the Jacobian; it exposes +`ym(theta)`, `log_likelihood`, `chi2` and `matrix(theta)`, the dense +covariance on the active rows for display and tests. + +### 2.10 `covariance.py`: the structured covariance + +The three term kinds are a decomposition: + +``` +Σ = diag(D) + blockdiag(M_b) + U Uᵀ (+ dense fallback) +``` + +`D` is the sum of squares of every `diag` term; `M_b` one dense block per +comparison from the `matrix` terms inside it; `U` has one column per +`mode` term scattered onto its support, a mode spanning comparisons being +a column with entries in several blocks. A `matrix` term that crosses +comparisons forces the dense path for that constraint. With +`B = blockdiag(M_b + diag(D_b))` and per-block Cholesky factors, + +``` +z = L⁻¹ r, W = L⁻¹ U, S = I + WᵀW +d2 = zᵀz − (Wᵀz)ᵀ S⁻¹ (Wᵀz), logdet Σ = Σ_b logdet B_b + logdet S +``` + +at cost $O(\sum_b n_b^3 + N r^2 + r^3)$. Masking slices rows before assembly. +Constant parts are evaluated once at compile; a constraint whose +covariance is entirely constant caches its factors. The layout (each +entry's active positions, its block, its positions inside the block) is +numpy, fixed at compile; assembly is functional `.at[].add` updates and the +factors are `jnp.linalg.cholesky` and `solve_triangular`, so the whole +distance is differentiable. A parametric covariance that is not positive +definite at some `theta` gives a NaN log-determinant (`chol_logdet` +substitutes the identity factor and zeroes its tangent, so the gradient +stays finite), which the compiled constraint reads as `-inf`. `B` must be positive +definite: a comparison covered only by modes is singular in `B` even when +$\Sigma$ is not, and compile says so with the label and the remedies. A +constraint boundary is about the likelihood functional and the weight, not +about cost. + +```python +class StructuredCovariance: + def distance(self, ym, theta=()) -> (d2, logdet) # active rows + def matrix(self, ym, theta=()) -> ndarray # dense, active rows + dense: bool # whether a cross-comparison matrix term forced it +``` + +### 2.11 `diagnostics.py` and `predictive.py` + +Everything takes `(problem, samples)` with `samples` of shape +`(n, problem.ndim)` in `problem.names` order, which is what emcee's +`get_chain(flat=True)`, dynesty's `samples_equal()` and `black-box-bayes` +give. + +```python +predictive_draws(problem, samples, constraint=0, *, terms=None, statistical=True, + n_rep=1, rng=None, model_only=False, given=None, + levels=(16, 50, 84), return_draws=False, physical=False) +coverage_curve(draws, y, levels=None); coverage_error(draws, y, levels=None) +sharpness(draws, percentiles=(16, 84), transform=None) +heldout_log_predictive(heldout_problem, samples, *, given=None) +log_posterior_predictive(logp_samples, logw=None) +logz_summary(logz, logzerr); compare_logz(a, b, sigma=2.0) + +gp_posterior_predictive(kernel, theta, X_train, residuals, X_pred, *, train_noise_var=None, jitter=1e-10) +predictive_band(draws, levels=(16, 50, 84)) +grid_draws(problem, predictor, x_pred, samples, constraint=0, *, comparison=None, + terms=None, model_only=False, joint=True, physical=False, + n_rep=1, rng=None, levels=(16, 50, 84), return_draws=False) +gp_predictive_draws(problem, term, predictor, x_pred, samples, *, terms=None, + conditioned=False, joint=True, noise_std=0.0, train_noise_var=None, + physical=False, n_rep=1, rng=None, levels=(16, 50, 84), return_draws=False) +``` + +A held-out problem built from `complement()` has the *marginal* +covariance of its rows, which is the right density when no term spans the +split and `ll(fit) + ll(held) = ll(full)` then holds. When a term does +span it (a GP over several experiments), `given=fit_problem` makes both +functions compute the Gaussian conditional $p(y_\mathrm{held} \mid y_\mathrm{fit}, \alpha)$ under +the full covariance; without a spanning term it equals the marginal. + +The three draw functions share one return convention: a percentile band +`(len(levels), n_points)` by default, the draws with `return_draws=True`. +Coverage, sharpness and held-out scoring consume draws. + +`predictive_draws` works at the measured points, where every term is +defined. `grid_draws` is its counterpart on a grid that was never +measured: per row it evaluates the predictor there, re-evaluates every +selected term from its own definition in a `TermContext` whose `x` is the +grid, whose `y` and `ym` are the model's prediction and whose `meta` is the +predictor's, sums the pieces into one covariance and draws `ym + L z`. +At the measured points, with +every term a function, it draws from the same distribution as +`predictive_draws`. A term that is an array — the statistical diagonals the +compiler builds, a fixed `Term(array)`, a per-point magnitude — has no value +at a new `x`, and `grid_draws` raises and names it rather than drop it: +leaving the reported errors out silently would hand back a band narrower +than the one the likelihood used. With several comparisons in the +constraint, `terms=None` needs `comparison=`, which also fixes the +comparison space. + +`gp_predictive_draws` locates the `KernelTerm` in the problem and takes +its constraint, rows, comparison space and parameter columns from there; +unconditioned it is `grid_draws` on that constraint. A kernel term +declares a *mean-zero* discrepancy, so the likelihood is the marginal +$y \sim \mathcal{N}(y_m(\alpha), \Sigma(\alpha))$; the matching predictive draws whole correlated curves +$y_m(\alpha) + L(\alpha) z$ from the inferred covariance about the model's own +prediction. `conditioned=True` instead conditions the discrepancy on the +residuals with every *other* term of the constraint as the regression noise +— regression on top of the model rather than a statement about its error. +`joint=False` falls back to per-point draws; the joint draws make a +functional summary well posed. + +`terms=` (on the three draw functions, `CompiledConstraint.matrix` and +`StructuredCovariance.matrix`, with `statistical=` for the diagonals the +compiler builds at the measured points) chooses which pieces of the error +model a draw carries: the model alone, model plus discrepancy, and model plus +discrepancy plus experimental uncertainty are different objects, and only +the last is comparable with data. Percentiles come back in the comparison +space, or in physical units with `physical=True`. + +### 2.12 `reactions/` + +```python +class ElasticXS(Model): + def __init__(self, quantity, central, spin_orbit, args_from_params, params, coulomb=None, + *, lmax=DEFAULT_LMAX, wavelengths_beyond_range=2.0, zeros_per_node=5) + def bind(self, x, meta) -> Predictor # reads meta["reaction"], meta["Elab"] +class IsobaricAnalogPN(Model): + def __init__(self, U_p_coulomb, U_p_central, U_p_spin_orbit, U_n_central, U_n_spin_orbit, + args_from_params, params, *, lmax=..., wavelengths_beyond_range=..., zeros_per_node=...) + def bind(self, x, meta) -> Predictor # reads reaction, Elab, ExIAS +def rutherford(kinematics, angles_rad) -> ndarray # mb/sr, closed form +def momentum_transfer(angles_rad, k) -> array # 2 k sin(theta/2), for coords= +``` + +`ElasticXS` evaluates `central(r, *args)`, `spin_orbit(r, *args)` and, +when given, `coulomb(r, *args)` on the workspace's mesh `ws.r`, where +`args_from_params(ws, *values)` returns two or three argument tuples, +solves with jitr's JAX R-matrix core (`ws.xs(Potential(...))`) and +extracts `dXS/dA` (b/sr), `dXS/dRuth` or `Ay`; the potentials are +`jax.numpy` (jitr's potential forms are), so the prediction is +differentiable in the potential parameters. The spin-orbit potential +multiplies `l.sigma` for a spin-1/2 projectile. `IsobaricAnalogPN` is the +DWBA (p,n) cross section of `jitr.xs.quasielastic_pn` with its default +isovector Lane coupling. The workspace at one energy is cached per model +instance and kinematics and moved to a new grid with `ws.at_angles`, so a +plotting grid reuses the data grid's solver; the cache is dropped on +pickling. The +model owns its solver and the data does not, so a masked view or an +unpickled problem cannot lose a workspace. There is no compound-elastic +hook: that contribution is subtracted from `data.y` as preprocessing +(recipe 20). + +## 3. Worked example: an error-model comparison + +The $\alpha$ + $^{44}$Ca study in its full form: real data without reported errors, one +potential, a ladder of covariances compared by evidence and by held-out +prediction. The notebook `examples/alpha_ca_error_model_comparison.ipynb` is +a shorter cut of it, two Gaussian-process amplitudes on top of the `jitr` +error model, with its predictives on a fine grid. + +```python +import numpy as np, rxmc as rx +from rxmc import terms as T, transforms as tf +import jax.numpy as jnp, tinygp +from scipy import stats + +data = rx.Dataset(angles_rad, ratio_to_rutherford, np.zeros(n), label="44Ca(a,a) 29 MeV", + meta={"reaction": reaction, "Elab": 29.0}) +omp = rx.reactions.ElasticXS("dXS/dRuth", central, spin_orbit, args_from_params, params, + coulomb=coulomb, lmax=30) +comp_log = rx.Comparison(data, omp, space=tf.log) +comp_lin = rx.Comparison(data, omp) +log_eps = rx.Parameter("log_eps", prior=stats.uniform(np.log(0.05), np.log(40))) +log_eta = rx.Parameter("log_eta", prior=stats.uniform(np.log(0.05), np.log(40))) +gp = T.kernel(lambda le: tinygp.kernels.Matern52(scale=jnp.exp(le)), [log_ell], + on=comp_log, coords=lambda x: x / np.pi, + amplitude=T.constant_amplitude, amplitude_params=(log_A,)) +ladder = { + "L0": rx.Constraint([comp_log], terms=[T.noise(log_eps)], statistical=False), + "E0": rx.Constraint([comp_lin], terms=[T.proportional_error(log_eps)], statistical=False), + "L2n": rx.Constraint([comp_log], terms=[T.noise(log_eps), T.offset(log_eta)], statistical=False), + "Lgp": rx.Constraint([comp_log], terms=[T.noise(log_eps), gp], statistical=False), +} +logz = {} +for name, c in ladder.items(): + p = rx.Problem([c]) + res = smc(p) # pocomc on the unit cube, recipe 16 + logz[name] = rx.diagnostics.logz_summary(res.logz + p.log_jacobian(), res.logz_err) +verdict = rx.diagnostics.compare_logz(logz["Lgp"], logz["L2n"]) + +fit = ladder["Lgp"].masked_where(lambda x: x < np.deg2rad(90)) +p_fit, p_held = rx.Problem([fit]), rx.Problem([fit.complement()]) +samples = run(p_fit) # rows in p_fit.names order +# the GP spans the cut, so score and draw from p(y_held | y_fit, theta): given= +lp = rx.diagnostics.heldout_log_predictive(p_held, samples, given=p_fit) +score = rx.diagnostics.log_posterior_predictive(lp) +draws = rx.diagnostics.predictive_draws(p_held, samples, n_rep=4, given=p_fit, return_draws=True) +``` + +The labels `L0`, `E0`, `L2n`, `Lgp` are the error-model ladder of recipe +18, whose table defines every label. The same problem runs under emcee +from `p.sample_prior` and `p.log_posterior`, and under `black-box-bayes` +from a `dill` pickle and a six-line module that forwards +`starting_location`, `log_posterior`, `log_likelihood` and +`prior_transform`. Reaction problems are driven by pocomc by preference: +affine-invariant ensembles mix poorly on optical-model posteriors, and the +p + $^{40}$Ca benchmark posterior has two separated islands, which gradient +samplers started at the MAP do not leave (and R-hat seldom notices). +pocomc, at eight times its default resolution, is the only benchmarked +sampler not shown wrong there, and even it is wrong on one seed of three; +below that it weighs the islands differently from run to run, so run it +more than once and compare ([benchmarks](benchmarks.md)). +With gradients available, HMC/NUTS (blackjax, numpyro) on `log_posterior_unconstrained`, +or a MAP by `rx.optimize.find_map` followed by a Laplace approximation from +`p.hessian_log_posterior`, are the alternatives. + +### Parallel sampling + +JAX is multithreaded, and a process started with `fork` (Python's default +on Linux) from a process that has JAX loaded can deadlock; JAX warns when it +happens. In order of preference: + +1. **No pool.** `Problem.log_posterior_batch` is one `jax.vmap` call over + the rows, and XLA already uses the cores: emcee's `vectorize=True`, or a + batched likelihood for a nested sampler. +2. **A spawn pool.** `multiprocessing.get_context("spawn")` (or + `"forkserver"`). Models and terms hold closures the standard `pickle` + cannot serialise, so send the problem once per worker as `dill` bytes + through the pool's `initializer` (recipe 16); each worker compiles its + own densities on first use. +3. **MPI.** `mpirun`/`srun` start every rank as a fresh interpreter, so the + fork problem does not arise (do not `MPI.Comm.Spawn` from a JAX-loaded + process, and do not mix fork pools into a rank). Each rank compiles its + own densities, and each rank's XLA thread pool defaults to every core, so + with several ranks on a node limit the threads per rank. On GPUs set + `XLA_PYTHON_CLIENT_PREALLOCATE=false` or pin one device per rank. + + ```bash + XLA_FLAGS="--xla_cpu_multi_thread_eigen=false" OMP_NUM_THREADS=1 mpirun -n 8 python run.py + ``` + +### Performance + +[Benchmarks](benchmarks.md) has the set-up, the commands and the full tables. +In short, against the numpy rxmc on jitr 3.0.1 (same machine, CPU), a call +of `log_posterior` is 1.5 to 7 times faster, the gradient (autodiff against +a finite difference) 3 to 80 times faster, and `jax.vmap` raises the +throughput of the cheap densities a hundredfold. + +Scored against exact or long-run reference posteriors, no sampler is best +everywhere. NUTS is the only one correct on the funnel-shaped `modes` and +`hierarchy` problems, in about a minute. On the single-mode reaction +problems the gradient samplers do well: on `elastic` pocomc, NUTS and +dynesty are correct, pocomc fastest, and on `n40ca_gp` every converged +sampler is within its reference's resolution, HMC fastest. On the +two-island `omp` and the two-family `alpha_gp` only pocomc is, at eight +times its default resolution, and it gives the evidence. emcee, at 12 000 +steps, matches NUTS's time on the line with ten times NUTS's effective +draws per second, but is short of 50 autocorrelation times on everything +harder. Each example notebook uses the fastest sampler that is correct on +its benchmark analogue, among those whose evidence agrees with the +reference where the notebook compares evidences; on the GP toys, where none is correct at the +benchmark's budgets, the notebooks run emcee long and check it. + +## 4. Capability map + +Every statistical capability the library supports, its spelling, and the +test that pins it. Recipe numbers refer to `recipes.md`. + +| capability | spelling | pinned by | +|---|---|---| +| user-defined model `y = m x + b` | `Model(lambda x, m, b: m*x + b, [m, b])` | test_model | +| `polynomial(order)` | `polynomial(order)` | test_model | +| statistical diagonal only; `chi2` | default `Constraint`; `problem.chi2(theta)` | test_problem, recipe 1 | +| unknown proportional / constant noise | `proportional_error(log_eps)`, `noise(log_eps)` | test_terms, recipe 2 | +| inferred noise replacing reported statistics | `Constraint(statistical=False, terms=[noise(...)])` | test_constraint, recipe 2 | +| reported normalisation / offset as modes | `comparison.reported_terms()`; `normalization(magnitude=)`, `offset(magnitude=)` | test_constraint, test_regression, recipe 3 | +| free normalisation / offset nuisance | `normalization(log_eta)`, `offset(log_omega)` | test_terms, recipe 4 | +| fixed dense covariance; fixed diagonal | `Term(C, on=comp)`, `Term(sig, kind="diag", on=comp)` | test_terms, recipe 19 | +| case B: one parameter, two block-local terms | `normalization(log_eta, on=c1), normalization(log_eta, on=c2)` (or any term, e.g. `noise(log_eps, on=...)`); or two constraints sharing the parameter | test_problem, recipe 5 | +| case A: one mode across comparisons | `normalization(log_eta, on=[c1, c2])` | test_covariance, test_regression, recipe 5 | +| per-dataset Kennedy and O'Hagan scale | `Comparison(d_i, omp \| scale(rho_i))` | test_model, recipe 6 | +| sampled mean discrepancy | `omp + Model(delta_fn, phi)`; alone or with `kernel` | test_model, recipe 8 | +| multiplicative `x`-dependent correction | `omp * Model(g_fn, phi)` | test_model | +| GP discrepancy in `x` or momentum transfer, with amplitude | `kernel(build, params, on=comp, coords=..., amplitude=..., amplitude_params=...)` | test_terms::TestStudyForms, recipe 7 | +| posterior predictive on a new grid, error model included | `grid_draws(problem, predictor, x_pred, samples)`; `model_only=True`; `comparison=` | test_predictive::TestGridDraws, recipe 40 | +| point-by-point errors refused on a new grid | `grid_draws` raises naming the term | test_predictive, recipe 40 | +| GP discrepancy on a grid from the problem alone; GP regression instead | `gp_predictive_draws(problem, term, predictor, x_pred, samples)`; `conditioned=True` | test_predictive, recipe 7 | +| band by default, draws on request | `levels=`, `return_draws=True` on all three draw functions | test_predictive, test_diagnostics | +| choosing which terms a predictive draw carries | `terms=[...]`, `statistical=False` | test_predictive, test_diagnostics, recipe 17 | +| hyperparameters shared across datasets, values from `meta` | same objects in one term per comparison; `c.meta("Elab")`; `kernel(params=)` | test_terms, test_problem, recipe 22 | +| discrepancy correlated across energies | one `matrix` term `on=comps` from `c.meta` and `c.x`; dense path | test_covariance, recipe 23 | +| term spanning comparisons reading its pieces | `c.segments`, `c.labels`, `c.split(a)` | test_terms, test_covariance, recipe 37 | +| correlated normalisations between quantities | one comparison per quantity, a spanning `matrix` term from `c.split(c.ym)`; the reference's closed forms | test_recipe_37 | +| Peelle's Pertinent Puzzle | `normalization()` reads `c.ym`; the estimate-built refit; the log-determinant pull of the live term | recipes 27, 37 | +| unaccounted-for model error per data type (KDUQ) | `proportional_error(delta_T, averaging=True, on=comp)`; scalings as `Constraint(weight=)` | test_terms, recipe 26 | +| tempering | `Constraint(weight=)` | test_problem, recipe 12 | +| a pure chi-squared functional | `Chi2()` | test_likelihood, recipe 9 | +| log-space comparison, delta-method errors, Jacobian | `Comparison(d, m, space=log)`; `problem.log_jacobian()` | test_constraint, recipe 10 | +| masks, hold-out, complement | `masked_where`, `complement()`, `heldout_log_predictive` | test_constraint, test_diagnostics, recipe 11 | +| held-out scoring under a spanning term | `heldout_log_predictive(held, s, given=fit)`, `predictive_draws(..., given=fit)` | test_diagnostics, recipe 30 | +| stacking by leave-one-dataset-out | `Constraint.masked` dropping a block; `log_posterior_predictive` | recipe 28 | +| cut posterior by multiple imputation | stage-1 and per-draw stage-2 problems | recipe 29 | +| simulation-based calibration | `sample_prior`, `predictive_draws`, `dataclasses.replace(d, y=)` | recipe 31 | +| emulator as `Model`, its variance as a `diag` term sharing parameters | recipe 32 | test_terms | +| MAP, MLE and Laplace | `rx.optimize.find_map` (L-BFGS-B, exact gradient), `find_mle` (the same, on the likelihood), both within `problem.support`, reporting `n_success` and warning when the best search did not converge, `options=` passed to scipy; `hessian_log_posterior` | test_optimize, recipe 33 | +| global error scale and USU modes | `diag` term closing over `comp.y_err` with `statistical=False`; `offset(parameter=, on=technique)` | recipe 34 | +| energy-dependent parameters | per-comparison `Model` instances closing over `meta`, shared objects | test_model, recipe 35 | +| discrepancy on a physical basis | `systematic` modes or `omp + Model(basis_sum)` | recipe 36 | +| hierarchy: joint block with a sampled hyperparameter | `Problem(priors=[(children + [hyper], obj)])` | test_problem, recipe 24 | +| classic normal hierarchical model | marginalised, non-centred, centred | recipe 38 | +| SafeBayes | `replace(c, weight=eta)` and prefix masks | recipe 25 | +| joint MVN prior; truncated marginals; `prior_transform` | `Problem(priors=[(omp.params, mvn)])`; `Parameter(prior=, bounds=)` | test_problem, recipe 13 | +| prior family without a JAX translation | `Parameter(prior=dist, logpdf=f)`, `f` in `jax.numpy`; `JAX_LOGPDFS` | test_problem, recipe 13 | +| gradients: MAP, Laplace | `grad_log_posterior`, `value_and_grad_log_posterior`, `hessian_log_posterior`; `jax.grad(problem.log_posterior)` | test_autodiff, recipe 33 | +| HMC/NUTS on bounded parameters | `log_posterior_unconstrained`, `to_theta`, `to_unconstrained`; blackjax `window_adaptation` + `nuts` | test_autodiff, recipe 41 | +| parallel sampling | `log_posterior_batch` (emcee `vectorize=True`); spawn pool with a `dill` initializer; MPI | recipe 16 | +| pocomc, emcee, dynesty, black-box-bayes drivers | the flat interface; `dill` round trip | test_problem, recipe 16 | +| batched densities and prior transform | `log_posterior_batch`, `log_prior_batch`, `log_likelihood_batch`, `prior_transform_batch` (one `jax.vmap` call; emcee `vectorize=True`, pocomc, ptemcee's `mapper`) | test_problem, recipe 16 | +| EXFOR to dataset with unit conversion | `from_measurement(m, reaction=, quantity=)` | test_measurement, recipe 14 | +| elastic `dXS/dA`, `dXS/dRuth`, `Ay`; (p,n) IAS | `ElasticXS`, `IsobaricAnalogPN` | test_reactions, recipe 15 | +| singular-covariance guard naming the dataset | compile-time in `Problem` | test_covariance, recipe 21 | +| covariance heat maps; fine-grid plotting | `problem.constraints[i].matrix(theta)`; `model.bind(x_fine, meta)` | notebooks | + +## 5. Testing + +Two tiers, chosen per assertion. + +- **Fast tier**, `pytest`: every unit test and every recipe test's + sampler-free assertions. Most expected-behaviour bullets are structural + or analytic: names and columns, a covariance equal to a hand-built + matrix, `chi2` identities, `ll(fit) + ll(held) = ll(full)`, compile-time + errors. Where a recipe says "run a sampler", the fast tier uses + `test/recipes/oracle.py`, the closed-form posterior of a linear-Gaussian + problem, through `common.linear_posterior` and `common.oracle_samples`; + exact rows stand in for a chain, so coverage, held-out scores, stacking + weights and calibration ranks are pinned exactly. Seeded short chains + appear only for ordering claims with a wide margin. Budget: a few + minutes, zero tolerated flakiness; a flaky assertion is demoted, never + loosened. +- **Converged tier**, `pytest -m slow`, then `RXMC_EXAMPLES_QUICK=1 + pytest -n 4 --nbmake --nbmake-timeout=900 examples`: the numeric claims + that need a converged sampler, and a quick run of the notebooks (section + 6). It is the "Converged tier" + workflow, required on pushes and pull requests into `main`, also run by + hand with `workflow_dispatch`; there is no scheduled run. + +Three index tests keep the documents honest: `test_recipes_index.py` +(one file per `## NN.` heading, each quoting its recipe; the recipe-18 +legend equal to the tests' legend), `test_notebooks_index.py` (each +notebook cites the recipes of the design's table, all eight exist), and +`test_regression.py` (the regression pins). `test/helpers.py` holds the dense +references and `STUDY_LEGEND`, the labelled error-model forms of recipe +18 built against hand-written matrices. + +## 6. Notebooks + +The notebooks in `examples/` each name the recipes they teach in their +first cell. The committed notebooks are full runs, and the documentation +shows them as committed (`nb_execution_mode = "off"`): a changed notebook is +rerun with `python examples/run.py ` before it is committed, and +`test_notebooks_index.py` refuses one whose cells did not all run, in order +and without error, at full budget. CI only checks that every cell still +runs: the converged tier sets `RXMC_EXAMPLES_QUICK=1`, which cuts every +sampler budget wrapped in `examples/budget.py`'s `budget` tenfold and +caps NUTS's trees at $2^5$ leapfrog steps (`QUICK_NUTS`). +Runtimes are the full runs' wall times on an eight-core laptop, one kernel +at a time (`examples/run.py`, rxmc on jitr's jax-core branch). + +| notebook | recipes | driver | content | runtime | +|---|---|---|---|---| +| `linear_calibration` | 1, 2, 17, 33, 40 | emcee | the whole workflow on a line with an inferred constant noise; prior and posterior predictive on a new grid with `grid_draws`, the model's band against a measurement's, and why reported per-point errors cannot go there; coverage of both | 15 s | +| `normalization_and_covariance_structure` | 2, 3, 4, 5, 6, 17, 19, 27, 33, 40, 41 | NUTS | where a $\chi^2$ comes from; six treatments of four experiments' normalisations on a quartic with a free, non-zero constant term, one experiment tightly mis-quoted, scored by the constant term, the width of each band of the curve, and the empirical coverage of each predictive of the data; the prediction-built mode's sign-flipped basin and why the chains start about the MAP; Peelle's puzzle in a two-point case against recipe 27's closed form; a gallery of covariance structures from `matrix(theta)`, including recipe 5's shared magnitude against one shared mode | 318 s | +| `gp_discrepancy` | 2, 7, 10, 16, 17, 18, 33, 40 | emcee, pocomc | mean-zero discrepancies with amplitudes growing in $x$, priors stated and the growth slope centred on zero: four rungs on a toy line, three on n + $^{40}$Ca missing its surface absorption (pocomc at eight times its default resolution), every parameter's pull read; the three predictive objects (model plus discrepancy, plus experimental, and the conditioned regression it does not use), the band split into line and discrepancy, and why pointwise coverage on one correlated realisation says little | 1256 s | +| `robust_likelihoods` | 12, 17, 33, 34, 39, 40 | emcee | four treatments of the same three gross outliers in shared figures: Gaussian, a global error scale (one inferred factor on every reported error, so its centre stays the Gaussian's), tempering at KDUQ's $k/N$ (the same inflation for a fixed covariance) and the iterative rejection loop (the only one that moves the line, including the round that over-rejects and recovers); tempering a correctly specified 200-point line, with the prior on the corner plot and the predictive coverage | 64 s | +| `local_optical_model_calibration` | 10, 14, 15, 16, 17, 18, 21, 40 | pocomc | EXFOR C0076002, Gross et al. (1967), p + $^{40}$Ca at 35.8 MeV, measured cross sections with statistical errors and no systematics, read from a plain dict: the unit contract (mb/sr in, a ratio to Rutherford on request); a KD03 sanity check before fitting; log-space residuals with median-one point-to-point and common log-space errors (`noise` and `offset`, after jitr) against linear residuals with the reported errors alone, compared by evidence with the Jacobian, by the model-only and full predictives, and by in-sample coverage curves with a binomial band; a posterior in two islands (about 85 % of the mass about the MAP), which pocomc at eight times its default resolution weighs as the benchmark's runs of the same problem do; why a gradient sampler started at the MAP is no check here; `n_seeds` for the run-to-run spread; the singular guard | 1332 s | +| `alpha_ca_error_model_comparison` | 7, 10, 11, 13, 17, 18, 40 | pocomc | real $^{44}$Ca($\alpha,\alpha$) data without reported errors, in log space with median-one point-to-point and common log-space errors (`noise` and `offset`, after jitr); a Matérn GP in angle, its length-scale prior spanning the median point spacing to the full range, with a constant amplitude against one growing as an inferred power of q (uniform on [0, 16]), by evidence; one pocomc run per model, with `n_seeds` for the run-to-run spread, checked against the benchmark's runs of the same problem; the solver's accuracy checked in the notebook; the error terms, all log-space standard deviations, compared directly, with their posterior correlations; the model only and the full predictive on a fine grid, their coverage with a binomial band and at the 216 angles the fit never saw, and the discrepancy envelope, each draw minus its own potential, that says *where* the potential fails; the weight between the two families of potentials | 1763 s | +| `hierarchical_calibration` | 11, 17, 22, 24, 30, 35, 38, 40, 41 | NUTS | eight schools, with the shrinkage explained rather than assumed; a hierarchy on the physics parameters recovering most of the held-out predictive power a misspecified energy dependence threw away, with the per-dataset coefficients it used drawn against the truth, its conservative over-coverage, and each $\tau_k$ against its prior | 294 s | +| `gradient_based_sampling` | 7, 16, 33, 38, 41 | NUTS, emcee | the same problems under two samplers, scored by effective draws per second once rank-normalised split R-hat, emcee's autocorrelation time and the divergence count say the run can be trusted: a 33-parameter hierarchy, both samplers started from prior draws, which NUTS samples in about 40 s and emcee has not mixed in $\tau$ and the $\eta_j$ after a minute; a 5-parameter GP discrepancy where NUTS needs a 0.99 target acceptance to stop diverging and emcee, run three times past the length at which its $50\tau$ rule passes, is six times faster; a MAP and a Laplace approximation from the exact gradient and Hessian, and the non-Gaussian width Laplace misses | 366 s | + +## 7. Layout and dependencies + +``` +src/rxmc/ + __init__.py re-exports + params.py transforms.py units.py data.py model.py terms.py + likelihood.py constraint.py covariance.py problem.py + diagnostics.py predictive.py + reactions/ elastic.py ias.py +test/ one file per module, the index tests, test_regression.py, helpers.py +test/recipes/ one file per recipe; common.py, oracle.py +examples/ the notebooks and plotstyle.py; data/ (committed measurements) +docs/ this document, recipes.md, benchmarks.md, examples.rst, api.rst +``` + +Runtime dependencies: `numpy`, `scipy`, `jax`, `tinygp`, `jitr` (jax-core +branch) and `exfor-tools`. Importing `rxmc` turns on `jax_enable_x64` for +the process. +Extras: `examples` (emcee, dynesty, pocomc with a CPU torch, blackjax, corner, +matplotlib, dill, jupyter, ipykernel, tqdm), `validation` (examples plus pytest, nbmake, nbqa, ruff, +black, isort, build, and scikit-learn, which the tests use as an +independent reference for the kernels), `docs` (sphinx, the pydata theme, +myst-nb), `samplers` (ptemcee and PyMC: the sampler benchmark's extra +samplers). Python 3.12 or later. + +## 8. Open questions and non-goals + +- **Term-level partial masks.** The factories accept `mask=`; a first-class + `on=(comparison, point_mask)` would be tidier. Not needed yet. +- **Workspace caching across models.** The workspace at one energy is + cached per model instance; two models on one kinematics still build two. A factor + of a few in setup time, not in solve time. +- **Cross-constraint modes.** `U` is per constraint so that constraints + stay independent and weights stay meaningful. A mode that couples two + constraints is a reason to merge them. +- **The log-determinant pull.** A prediction-scaled covariance biases the + mode down by an amount that grows with the normalisation error (5 to 9 % + at 20 %). Whether to offer the estimate-built refit as a helper rather + than a pattern is open. +- **Known non-goals.** The closing section of `recipes.md` lists the + calibration classes the design rules out (non-elliptical likelihoods, + chain-dependent masks, per-point latents, per-point likelihood factors, + mixture likelihoods) with the size of the addition each would need. + +## 9. Release path + +0.x is preserved at tag `v0.1.0` and branch `legacy/0.x`. Releases are +tags `vX.Y.Z`, published to PyPI by trusted publishing on tag push, with a +GitHub Release and a Pages rebuild. 1.0 is published once jitr's JAX +release is on PyPI, since PyPI does not accept a git dependency. diff --git a/docs/examples.rst b/docs/examples.rst index abeccd8..0d86ece 100644 --- a/docs/examples.rst +++ b/docs/examples.rst @@ -1,43 +1,48 @@ Examples ======== -The following notebooks demonstrate the main workflows and features of ``rxmc``. -They are rendered with their pre-computed outputs; to run them locally, install -the example dependencies first: +The notebooks below are the tutorials for the recipes in :doc:`recipes`; +each names the recipes it teaches in its first cell. They are rendered with +their committed outputs, which are full runs (``python examples/run.py``); +the converged-tier CI workflow only checks that they still run, with every +sampler budget cut tenfold. +To run them yourself, install the example dependencies first:: -.. code-block:: bash + pip install -e '.[examples]' + jupyter lab examples - pip install -ve '.[examples]' - jupyter lab +Calibration basics +------------------ -Basic calibration ------------------ +.. toctree:: + :maxdepth: 1 + + examples/linear_calibration.ipynb + examples/normalization_and_covariance_structure.ipynb + +Beyond the Gaussian +------------------- .. toctree:: :maxdepth: 1 - examples/linear_calibration_demo.ipynb - examples/systematic_err_demo.ipynb + examples/gp_discrepancy.ipynb examples/robust_likelihoods.ipynb -Realistic nuclear physics calibration --------------------------------------- +Reactions and studies +--------------------- .. toctree:: :maxdepth: 1 - examples/30s_optical_potential_calibration.ipynb - examples/measurement_to_calibration.ipynb - examples/calibration_config_emcee_dynesty.ipynb + examples/local_optical_model_calibration.ipynb + examples/alpha_ca_error_model_comparison.ipynb + examples/hierarchical_calibration.ipynb -Advanced topics ---------------- +Samplers +-------- .. toctree:: :maxdepth: 1 - examples/correlated_observations.ipynb - examples/gp_discrepancy.ipynb - examples/normalization_inference.ipynb - examples/sampling_algos.ipynb - examples/overconfidence.ipynb + examples/gradient_based_sampling.ipynb diff --git a/docs/groundup_design.md b/docs/groundup_design.md deleted file mode 100644 index fb9ce02..0000000 --- a/docs/groundup_design.md +++ /dev/null @@ -1,1100 +0,0 @@ -# A ground-up rxmc: declare, then compile - -This document guides a rewrite of `rxmc` from a blank repository. It is the -plan of record for that rewrite, not a comparison with the current code: the -current `api_generalisation` branch stays where it is as the reference -implementation, and `design.md` / `bugs_found.md` remain the record of how -it was designed and what was found wrong with it. `recipes.md` is the -companion: one short user story per use case the rewrite must support, -each with the spelling below and the behaviour a user should expect. - -The *concepts* of `design.md` survive unchanged: evidence as a weighted sum -over independent constraints; a constraint as the maximal block of mutually -correlated data; one `Term` type with three kinds; the likelihood as a -functional of `(d2, logdet, n)`; the comparison space owned by the data side; -masks as part of support; and the case A (couple the data) / case B (share -a parameter) distinction. The *mechanics* are rebuilt around one rule: - -> **Everything the user constructs is an immutable declaration. -> `Problem` is the only compile step.** - -Three goals drive every choice below, in this order: - -1. **The maintainer.** The smallest implementation that covers every - capability the current notebooks and tests demonstrate, with no - lifecycle rules to remember. Budget: about 2,300 lines of package code - in 14 modules, down from 6,199 in 23. -2. **The user.** Declaring a problem, including each statistical modelling - choice in it, reads as a statement of the model. A reviewer should be - able to read the declaration and write down the likelihood. -3. **External samplers only.** emcee, dynesty and the `black-box-bayes` - CLI are the calibration drivers. The in-package Gibbs walker and its - samplers are not carried over. - -## 1. Rules for the maintainer - -These are the review checklist for every change in the new repository. - -1. **Specs hold no caches and no solver state.** `Parameter`, `Dataset`, - `Model`, `Term`, `Comparison`, `Constraint` are frozen dataclasses with - `eq=False`: identity is the equality, for every spec, not only - `Parameter`. (A generated `__eq__` would try to compare the arrays - they hold and raise.) Anything expensive or grid-dependent lives in - the objects `Problem` builds. -2. **Exactly one function walks the parameter graph:** `Problem.__init__`. - Nothing else assigns slots, checks names, resolves supports, or decides - which prior covers which slot. -3. **Gather, never split.** Every callable node receives one integer - gather array at compile time and is evaluated as `node(*theta[gather])`. - There is no `n_model_params`, no `indices[:-1]`, no `split_params`. -4. **Every user-supplied callable has one shape:** `fn(context, *values)`, - where `context` is the grid `x` (models, transforms) or a `TermContext` - (terms, bases, amplitudes) and `values` are the sampled values of the - parameters the node declares, in declaration order. -5. **Sharing is spelled by passing the same `Parameter` object.** Inside a - term, between terms, between a model and a term, across constraints. - There is no second identity notion and no value-equality anywhere. -6. **One factorisation path.** `StructuredCovariance` is the only way a - covariance is factored. The dense matrix exists as a display method - and as the reference in tests. -7. **Fail at compile, and name the dataset.** Singular constant - covariance, duplicate parameter names, a slot no prior covers, an `on=` - that references a block outside its constraint, a non-finite value in - comparison space: all raised by `Problem`, never mid-chain. -8. **Nothing is folded into a covariance silently.** A dataset's reported - systematics become terms only when the user asks - (`block.reported_terms()`). -9. **A `Problem` pickles with `dill`.** `black-box-bayes` ships it to every - MPI rank by path. A round-trip test on a reaction problem is part of - the suite. -10. **Correctness lives in tests that pin numbers**, not in defensive - branches: the closed-form Student-t, delta-method errors under `log`, - the regression log-likelihood `1.195784087817536`, dense-versus- - structured equality on every error-model form. **Every recipe in - `recipes.md` is a test** under `test/recipes/`, one file per recipe - named `test_recipe_NN_.py`, whose docstring quotes the recipe's - intent and whose assertions are its *Expected behaviour* bullets. A - CI check fails when a `## NN.` heading in `recipes.md` has no test - file, or a test file has no heading. - -## 2. The API skeleton - -Read top to bottom. Module names are the package layout of §6. Type hints -are the documentation; the prose says only what the signature cannot. - -### 2.1 `params.py` - -```python -@dataclass(eq=False, frozen=True) -class Parameter: - name: str - bounds: tuple[float, float] = (-inf, inf) - prior: object | None = None # frozen scipy univariate: logpdf, cdf, ppf, rvs - unit: str = "" - latex: str | None = None -``` - -`eq=False` keeps identity hashing: a parameter *is* its object, and it can -key a dict. A parameter may carry its own marginal prior. The rules, enforced -once at compile: - -| declared | prior used | -|---|---| -| `prior=dist` | `dist` truncated to `bounds` (log-density `-inf` outside; `ppf` rescaled between `cdf(lo)` and `cdf(hi)`) | -| finite `bounds`, no `prior` | uniform on `bounds` | -| neither | must be covered by a joint prior given to `Problem`, else a compile error naming the parameter | - -This replaces `IndependentPrior`, `TruncatedNormalPrior`, `as_prior` and the -list-of-scipy-distributions form with no classes at all. - -### 2.2 `transforms.py` - -Harvested from the current module minus `per_observation_scaling` and the -`contextual` flag. - -```python -class Transform: - fn: Callable # fn(a, *values) -> array - params: tuple[Parameter, ...] - derivative: Callable | None # d fn / d a, elementwise; finite difference fallback - inverse: Transform | None # parameter-free transforms only - def __call__(self, a, *values) -> ndarray - def __or__(self, other) -> Transform # (f | g)(a) = g(f(a)); params f + g - -identity, log, exp # parameter-free singletons -def scale(parameter=None, log=True) -> Transform # rho * a; default Parameter("log_rho") -def as_transform(t) -> Transform # None -> identity; callable -> parameter-free Transform -``` - -One type, three roles: the comparison space of a `Comparison`, a mean transform -composed onto a `Model`, and the coordinates a `Term` is evaluated in. - -### 2.3 `units.py` and `data.py` - -```python -# units.py — the one pint registry and the unit contract -ureg = UnitRegistry() -XS_UNIT = ureg.barn / ureg.steradian # every cross section stored in b/sr -RUTHERFORD_UNIT = ureg.millibarn / ureg.steradian # what jitr reports -MB_PER_B = 1000.0 -DEFAULT_LMAX = 20 -def check_angle_grid(angles_rad, name) -> None -``` - -```python -# data.py -@dataclass(frozen=True) -class Dataset: - x: ndarray # angles in radians for reaction data - y: ndarray # physical units (b/sr, dimensionless, ...) - y_err: ndarray # statistical, physical units - norm_err: float | ndarray | None = None # reported fractional normalisation - offset_err: float | ndarray | None = None # reported absolute offset, physical units - label: str = "" - meta: Mapping = field(default_factory=dict) # kinematics: reaction, Elab, ExIAS, quantity, k, ... - -def from_measurement(measurement, *, reaction=None, quantity=None, ExIAS=None) -> Dataset -``` - -`Dataset` is pure data. No comparison transform, no mask, no solver -workspace, no identity key. - -`from_measurement` is the single EXFOR adapter. It reads the -`exfor_tools.Distribution` fields (`x, y, Einc, quantity, y_units, -statistical_err, systematic_norm_err, systematic_offset_err, subentry`), -converts units once through `ureg`, divides every dimensionful error by the -conversion factor `norm`, passes the fractional normalisation error through -untouched, converts angles to radians, and fills `meta` with `reaction`, -`Elab`, `quantity`, `k` (and `ExIAS` for the (p,n) channel). The -`dXS/dA` ↔ `dXS/dRuth` conversions need the Rutherford cross section on -the data grid. In jitr that is a closed form of the kinematics, -`10 * eta**2 / (4 * k**2 * sin(theta/2)**4)` mb/sr -(`DifferentialWorkspace.rutherford_xs`), so `from_measurement` computes it -from `reaction.kinematics(Elab)` with no workspace. A per-angle `norm` -array is the result in those cases, exactly as today. - -### 2.4 `model.py` - -A model is a spec of "observables from parameters". A predictor is that -model bound to a grid. - -```python -class Model: - params: tuple[Parameter, ...] - def __init__(self, fn, params): ... # fn(x, *values) -> y, physical space - def bind(self, x, meta=None) -> Predictor: ... # generic: closes over x - def __or__(self, transform) -> Model: ... # mean transform; its params appended - def __add__(self, other) -> Model: ... # additive mean discrepancy; params concatenated - def __mul__(self, other) -> Model: ... # multiplicative x-dependent correction; scale() is its constant case - -class Predictor: - params: tuple[Parameter, ...] - x: ndarray - def __call__(self, *values) -> ndarray # physical space, on x - -def polynomial(order) -> Model # a_0 + a_1 x + ... ; params a0..an -``` - -- `Model.__or__` composes at the model level, so `omp | scale(rho_1)` is a - model whose parameters are `omp.params + (rho_1,)`; `bind` composes the - bound predictor with the transform. Per-dataset Kennedy–O'Hagan scales - are distinct `rho_i` objects on distinct comparisons. No routing table. -- `Model.__add__` is the explicit mean discrepancy: `omp + delta` with - `delta = Model(lambda x, *phi: ..., phi_params)` predicts - `omp(x) + delta(x)` in physical space, with parameters - `omp.params + delta.params` (a parameter object in both is shared, as - everywhere). `bind` binds both sides to the same grid and sums. This is - the Kennedy–O'Hagan *sampled* discrepancy, in contrast to `kernel`, which - marginalises it into the covariance; the two may be used together. A - reaction model and a plain-function model add without special cases - because addition happens on the bound predictors. Composition is - left-to-right: `(omp + delta) | scale(rho)` scales the sum, - `(omp | scale(rho)) + delta` scales only the model. -- `Model.__mul__` is the multiplicative counterpart: `omp * g` with - `g = Model(lambda x, *phi: ..., phi)` predicts `omp(x) · g(x)`. An - additive discrepancy in log space is exactly this, and `scale(rho)` is - the constant case `omp * Model(lambda x, r: np.exp(r), [rho])`, kept as - a helper. `+` and `*` share one binary-composition implementation; the - parametric use of `|` remains for non-separable transforms only. -- Plotting on a fine grid is `omp.bind(x_fine, d.meta)(*values)`. This - replaces `visualization_workspace` and `visualizable_model_prediction`. -- Reaction models subclass `Model` and override only `bind`. - -```python -# reactions/elastic.py -class ElasticXS(Model): - def __init__(self, quantity, central, spin_orbit, args_from_params, params, - coulomb=None, *, lmax=DEFAULT_LMAX, wavelengths_beyond_range=2.0, - zeros_per_node=5): ... - def bind(self, x, meta) -> Predictor - # reads meta["reaction"], meta["Elab"]; - # builds the jitr IntegralWorkspace + DifferentialWorkspace on x - # (set_up_solver, harvested); returns a Predictor that evaluates the - # potentials on ws.radial_grid(), solves, and extracts dXS/dA | dXS/dRuth | Ay - -def momentum_transfer(x, k) -> ndarray # q = 2 k sin(x/2), for coords= - -# reactions/ias.py -class IsobaricAnalogPN(Model): - def __init__(self, U_p_coulomb, U_p_central, U_p_spin_orbit, U_n_central, - U_n_spin_orbit, args_from_params, params, *, lmax=..., ...): ... - def bind(self, x, meta) -> Predictor # reads reaction, Elab, ExIAS -``` - -The model owns its solver; the data does not. A masked view, a copy, or an -unpickled problem cannot lose a workspace, because nothing routes on the -identity of a data object. The predictor is a pure function of the -potential: there is no `compound_correction` hook. A compound-elastic -contribution is subtracted from `data.y` as preprocessing (recipe 20), -which keeps the model free of data-side state and works on any grid. Optional, not in v0: cache the -`IntegralWorkspace` on the model instance keyed on -`(Elab, lmax, wavelengths_beyond_range, zeros_per_node)` so two datasets at -one energy solve the basis once. - -### 2.5 `terms.py` - -```python -@dataclass(frozen=True) -class TermContext: - x: ndarray # coords(x) on the support - y: ndarray # data on the support, comparison space - ym: ndarray | None # prediction on the support; None while factoring constant parts - def __len__(self) -> int - def meta(self, key) -> ndarray # the owning block's data.meta[key], one value per point; - # for a term spanning blocks, the per-point concatenation - -@dataclass(frozen=True) -class Term: - fn: Callable | ndarray # fn(c: TermContext, *values) -> vector | matrix - params: tuple[Parameter, ...] = () - kind: Literal["diag", "mode", "matrix"] = "matrix" - on: Comparison | Dataset | Sequence[Comparison | Dataset] | None = None # None = whole constraint - coords: Transform = identity # applied to x before fn sees it; its params appended - constant: bool = False # fn reads neither ym nor parameters -``` - -| `kind` | `fn` returns | contribution | -|---|---|---| -| `"diag"` | standard-deviation vector `v` | `Σ_ii += v_i²` | -| `"mode"` | vector `v` | `Σ += v vᵀ` | -| `"matrix"` | symmetric block `M` | `Σ_block += M` | - -- **Support is a reference, not integer indices.** `on=b1` places the term - on that block, `on=[b1, b2]` spans both (case A), `on=None` is the whole - constraint. `on=` also accepts a block's `Dataset`, and compile resolves - `block is target or block.data is target`, so a term written against a - block still resolves after `masked`/`complement` rebuild the constraint. - `stacked_supports` and `support=np.arange(...)` are gone. -- **A term is stateless.** No `bind`, no cache. The same object may be - placed in two constraints. - -The factory helpers keep their bodies and signatures with `support=` renamed -`on=`: - -```python -statistical(y_err, on=None) -offset(magnitude=None, parameter=None, mask=None, log=True, on=None) -normalization(magnitude=None, parameter=None, mask=None, log=True, on=None) -noise(parameter, log=True, basis=None, basis_params=(), on=None, coords=None) -noise_fraction(parameter, log=True, on=None) -model_error(parameter, averaging=True, log=True, on=None) -systematic(parameter, basis, log=True, basis_params=(), on=None, coords=None) -kernel(kernel, coords=None, amplitude=None, amplitude_params=(), jitter=1e-10, - prefix="discrepancy", params=None, on=None) -# params=: the hyperparameter Parameter objects, one per free element in kernel.theta order; -# None derives fresh ones named f"{prefix}_{name}". Pass the same objects to share -# hyperparameters between per-block kernels. Two kernel terms with derived -# names and the same prefix fail compile on the duplicate name; the error says -# to pass prefix= (distinct kernels) or params= (one shared kernel). -# bases and amplitudes: ones, ym, averaging, x_basis(scale), exp_growth(scale, base=ones), -# constant_amplitude, exp_growth_amplitude(scale) -``` - -**Hierarchy is sharing plus `meta`.** A hyperparameter shared by several -datasets is one `Parameter` object placed in one term per block; anything -dataset-specific the term needs (energy, excitation energy, a flag) comes -from `c.meta(key)`. A discrepancy correlated *across* datasets, such as a -GP over energy and angle, is one `matrix` term spanning the blocks whose -`fn` builds its inputs from `c.meta("Elab")` and `c.x`. It takes the dense -path; there is no Kronecker structure because real data share no angle -grid. Recipes 22–24 spell all three out. - -### 2.6 `likelihood.py` - -Harvested. A likelihood is a functional of `(d2, logdet, n, *values)` with -optional parameters that are ordinary nodes in the index. - -```python -class Likelihood: - params: tuple[Parameter, ...] = () - def log_likelihood(self, d2, logdet, n, *values) -> float - def chi2(self, d2, logdet, n, *values) -> float # d2 - -class Gaussian(Likelihood): ... -class StudentT(Likelihood): # StudentT(nu=None) -> Parameter("nu", bounds=(1, inf)) - # two constraints with the default each derive a "nu"; - # compile fails on the duplicate name and says to pass nu= -class Chi2(Likelihood): ... # -0.5 d2, no log-determinant -``` - -### 2.7 `constraint.py` - -A block is the unit the residual is formed on: one dataset, one model, one -comparison space. A constraint is a tuple of comparisons plus the terms, -the likelihood functional, the tempering weight, and the active-point -masks. Each comparison is one block of the stacked covariance (§2.9), so -"block" below and in §2.9 means that. - -```python -@dataclass(frozen=True) -class Comparison: - data: Dataset - model: Model # bound at construction: model.bind(data.x, data.meta) - space: Transform = identity # parameter-free comparison transform - # derived, computed once in __post_init__ / cached_property: - predictor: Predictor - y: ndarray # space(data.y) - y_err: ndarray # |space'(data.y)| * data.y_err (delta method) - log_jacobian_all: ndarray # log |space'(data.y)| per point - def reported_terms(self) -> list[Term] # offset then normalisation modes from data.norm_err / - # data.offset_err, delta-method propagated, on=self - -@dataclass(frozen=True) -class Constraint: - comparisons: tuple[Comparison, ...] - terms: tuple[Term, ...] = () - likelihood: Likelihood = Gaussian() - weight: float = 1.0 # tempering; multiplies the log-likelihood only - statistical: bool = True # add each block's y_err diagonal - masks: tuple[ndarray, ...] | None = None # active points per block; None = all active - def masked(self, masks) -> Constraint - def masked_where(self, predicate) -> Constraint # masks = [predicate(comp.data.x) for comp in comparisons] - def complement(self) -> Constraint # every inactive point active, and vice versa -``` - -- The comparison transform lives on the block because it is a modelling - choice: a Gaussian in log space is a different distribution from one in - linear space. Terms are authored in comparison space, as today. -- **Masks live on the constraint, not on the block or the data.** - `masked`, `masked_where`, `complement` return a `Constraint` with the same - `Comparison`, `Term`, and `Parameter` objects and new masks. No `copy.copy`, - no identity key. A held-out problem built from `complement()` shares - every parameter with the fit, so a posterior sample scores it directly. -- `weight` subsumes both `Evidence(weights=)` and - `CalibrationConfig.likelihood_scaling`: one knob, honoured by every driver. -- Eager checks here need nothing from the parameter graph: comparisons are - distinct, an array-valued term has the right shape for its `on`, the - comparison space is finite on every active point (named block). - -### 2.7b How the pieces thread - -There are exactly two parametric entry points. Everything else is a -constant fixed when the comparison is built. - -| stage | space | what enters | parametric | -|---|---|---|---| -| 1. `Predictor` | physical | `f(x; θ)` on the data grid | model parameters | -| 2. mean modifications, composed on the `Model` | physical | `\| scale(ρ)`, `* g(x; φ)`, `+ δ(x; φ)` | ρ, φ | -| 3. `space` | physical → comparison | `y = space(data.y)`, `ym = space(step 2)`, `y_err = \|space'\| · data.y_err`, `log_jacobian` | none | -| 4. `Term`s, seeing `TermContext(x, y, ym)` | comparison | statistical diagonal; experimental terms (noise, reported modes, USU); model-discrepancy terms (kernel, EFT truncation) | term parameters, and `ym` | -| 5. `Likelihood` | comparison | functional of `y − ym` and Σ | Student-t ν only | - -Two rules follow. Experimental and model-discrepancy covariance terms -are one mechanism; the difference is what the user means, not what the -code does. A term that reads `ym` sees the prediction *after* the mean -modifications and *after* `space`, which is right: a reported -normalisation error applies to the measured scale, so its mode is -`η · ρ f`, and `Comparison.reported_terms()` gets that for free. And: -mean-side discrepancy is physical-space and `x`-aware; covariance-side -discrepancy is comparison-space and `ym`-aware; neither sees the other. -That is why the normalisation stays on the mean rather than dividing the -data: dividing the data would make `space` parametric, with a -ρ-dependent Jacobian and ρ-dependent error propagation, and in linear -space it is the data-side normalisation that Peelle's Pertinent Puzzle -warns about (recipe 27). - -### 2.8 `problem.py` — the compile step - -```python -class Problem: - def __init__(self, constraints, priors=()): # priors: [(params, joint), ...] - index: ParameterIndex # slot(p), slots(ps), names, bounds, ndim - constraints: tuple[CompiledConstraint, ...] - priors: tuple # the (params, joint) pairs as given; reuse for a held-out Problem - ndim: int - names: list[str] - bounds: ndarray # (ndim, 2) - - def log_prior(self, theta) -> float - def log_likelihood(self, theta) -> float # sum_c c.weight * c.log_likelihood(theta) - def log_posterior(self, theta) -> float # prior first; -inf short-circuits the forward model - def prior_transform(self, u) -> ndarray # unit cube -> theta (dynesty, bbb) - def sample_prior(self, n, rng=None) -> ndarray # (n, ndim) - def predict(self, theta, physical=False) -> list[list[ndarray]] # per constraint, per block - def chi2(self, theta) -> float - def log_jacobian(self) -> float # sum over constraints, active points - def columns(self, params) -> ndarray # chain columns of these parameters - - # black-box-bayes spellings of the same six things - NDIM, parameter_names, starting_location(n), log_posterior_batch(thetas) -``` - -`Problem.__init__` is the only place that walks the graph. It produces -`index`, the compiled constraints, and the assembled prior. Compile the -same declarations twice and you get two independent problems; nothing -user-facing is mutated. - -```python -def compile(constraints, priors): - index = ParameterIndex() # ordered: Parameter -> slot, first seen - compiled = [] - for c in constraints: - y, y_err, offsets = stack(c.comparisons) # comparison space, one slice per comparison - active = concatenate(offsets[i][mask_i] for each block) - preds = [(offsets[i], index.add_all(b.predictor.params), b.predictor) for i, b in ...] - terms = ([statistical(comp.y_err, on=comp) for comp in c.comparisons] if c.statistical else []) + list(c.terms) - resolved = [(resolve(t.on, c.comparisons, offsets), index.add_all(t.params), t) for t in terms] - like_gather = index.add_all(c.likelihood.params) - cov = StructuredCovariance(resolved, offsets, active, blocks=c.comparisons) - cov.factor_constant_parts() # eager; names the block on failure - compiled.append(CompiledConstraint(...)) - index.check_names_unique() - prior = assemble_prior(index, priors) # every slot covered exactly once - return index, tuple(compiled), prior -``` - -`index.add_all(params)` returns the gather array for a node, adding unseen -parameters in first-seen order (block predictors, then terms, then the -likelihood, constraint by constraint). That is the whole routing story. - -**Prior assembly.** Each slot is covered by its parameter's marginal -(§2.1) or by exactly one joint block from `priors`. A joint block is -`(params, joint)` where `joint` is any object with `logpdf(values)` over -those parameters in that order, optionally `prior_transform(u)` and -`rvs(n)`; `scipy.stats.multivariate_normal` qualifies. A hyperprior is a -joint block that *includes its hyperparameter*: the children carry no -marginal, the block's `logpdf` is `sum_i log p(child_i | hyper) + log p(hyper)`, -and its `prior_transform` draws the hyperparameter first (recipe 24). `log_prior` sums -marginal log-densities and joint `logpdf`s. `prior_transform` maps each -marginal slot through its rescaled `ppf`; a joint `scipy.stats.multivariate_normal` -block is whitened, `theta = mu + L Φ⁻¹(u)` with `L Lᵀ = cov`; any other joint -must expose `prior_transform(u)` or `Problem.prior_transform` raises a clear -error naming it. A parameter with finite `bounds` inside a joint block is -truncated in `log_prior` only (`-inf` outside the bounds); a truncated joint -has no unit-cube map, so `prior_transform` raises for that problem and names -the parameter. `sample_prior` draws marginals and joints and scatters them -into columns. - -**`CompiledConstraint`** is today's `Constraint` plus `ConstraintCovariance` -minus the parameter splitting: - -```python -class CompiledConstraint: - y, y_err, x: ndarray # stacked, comparison space, all points - offsets: tuple[slice, ...] - active: ndarray - predictors: list[(slice, gather, Predictor)] - covariance: StructuredCovariance - likelihood: Likelihood; like_gather: ndarray - weight: float - log_jacobian: float - def ym(self, theta) -> ndarray - def log_likelihood(self, theta) -> float - def chi2(self, theta) -> float - def matrix(self, theta) -> ndarray # dense, active rows; display and tests -``` - -### 2.9 `covariance.py` — the structured covariance - -The three term kinds already describe a decomposition: - -``` -Σ = diag(D) + blockdiag(M_b) + U Uᵀ (+ dense fallback) -``` - -- `D`: length-`N` vector, the sum of squares of every `"diag"` term. -- `M_b`: one dense block per observation block, the sum of `"matrix"` - terms whose support lies inside block `b`. -- `U`: `N × r`, one column per `"mode"` term, scattered onto its support - and zero elsewhere. A mode spanning several blocks (case A) is a column - with entries in several blocks. -- A `"matrix"` term that crosses block boundaries (a GP kernel over the - union of two datasets) forces the dense path for that constraint. - -With `B = blockdiag(M_b + diag(D_b))` and per-block Cholesky `L_b`: - -``` -z = L⁻¹ r (block by block) -W = L⁻¹ U (block by block, N × r) -S = I_r + Wᵀ W (r × r) -d2 = zᵀz − (Wᵀz)ᵀ S⁻¹ (Wᵀz) -logdet Σ = Σ_b logdet B_b + logdet S -``` - -Cost `O(Σ_b n_b³ + N r² + r³)` instead of `O(N³)`. Consequences: - -- All three "known limitations" of `design.md` are gone: no dense assembly - for block-diagonal covariances, a low-rank path exists, and masking is - slicing rows out of `D`, `U`, and `M_b` before assembly. -- The block path is the only path. `uses_block_path`, `block_diagonal`, - `cholesky` versus `block_cholesky`, and the dispatch in - `stacked_distance` do not exist. -- Each of `D`, `U`, `M_b` is a constant part (evaluated once at compile) - plus a parametric part. When everything is constant the factors are - cached. -- A constraint boundary is now about the likelihood functional and the - weight, not about cost: a coupling mode across blocks is essentially free. -- `B` must be positive definite. A block covered only by modes is singular - in `B` even when `Σ` is not; compile reports it with the comparison's label - and the remedies (reported terms, a noise term, `statistical=True`). - -```python -class StructuredCovariance: - def __init__(self, resolved_terms, offsets, active, blocks): ... - def factor_constant_parts(self) -> None - def distance(self, y, ym, theta) -> tuple[float, float] # (d2, logdet) on active rows - def matrix(self, y, ym, theta) -> ndarray # dense, active rows -``` - -### 2.10 `diagnostics.py` and `predictive.py` - -Harvested statistics with the entry points retargeted to `(problem, -samples)`, where `samples` has shape `(n, ndim)` in `problem.index` order. -That is what emcee's `get_chain(flat=True)`, dynesty's `samples_equal()`, -and bbb's `InferenceData["theta"]` all give. Column selection goes through -`problem.columns(...)`; `split_samples`, `n_model_params`, `theta_cols` are -gone. - -```python -# diagnostics.py -predictive_draws(problem, samples, constraint=0, *, n_rep=1, rng=None, model_only=False) -coverage_curve(draws, y, levels=None); coverage_error(draws, y, levels=None) -sharpness(draws, percentiles=(16, 84), transform=None) -heldout_log_predictive(heldout_problem, samples) # Problem([fit.complement()], priors=...) -log_posterior_predictive(logp_samples, logw=None) -logz_summary(logz, logzerr); compare_logz(a, b, sigma=2.0) - -# predictive.py -gp_posterior_predictive(kernel, theta, X_train, residuals, X_pred, *, train_noise_var=None, jitter=1e-10) -predictive_band(draws, levels=(16, 50, 84)) -total_predictive_band(problem, term, predictor, x_pred, samples, *, noise_std=0.0, - train_noise_var=None, levels=(16, 84), n_draws=400, rng=None) -# term is the kernel Term; its columns and the predictor's come from problem.columns -``` - -## 3. Worked example: the α+Ca study shape - -Two datasets without reported errors, compared in log space, one noise -magnitude shared between them (case B), one normalisation mode coupling them -(case A), one latent scale per dataset, one held out below an angular cut, -nested sampling, then held-out scoring. - -```python -import numpy as np, dynesty, rxmc as rx -from rxmc import terms as T, transforms as tf -from scipy import stats - -d1 = rx.from_measurement(m1, reaction=reaction, quantity="dXS/dA") -d2 = rx.from_measurement(m2, reaction=reaction, quantity="dXS/dA") - -omp = rx.reactions.ElasticXS("dXS/dA", central, spin_orbit, args_from_params, params=omp_params) -rho1 = rx.Parameter("log_rho_1", prior=stats.norm(0, 0.1)) -rho2 = rx.Parameter("log_rho_2", prior=stats.norm(0, 0.1)) -comp1 = rx.Comparison(d1, omp | tf.scale(rho1), space=tf.log) -comp2 = rx.Comparison(d2, omp | tf.scale(rho2), space=tf.log) - -log_eps = rx.Parameter("log_eps", prior=stats.norm(-2, 1)) -log_eta = rx.Parameter("log_eta", prior=stats.norm(-2, 1)) -c = rx.Constraint( - comparisons=[comp1, comp2], - terms=[ - T.noise(log_eps, on=comp1), # case B: one magnitude, two comparisons - T.noise(log_eps, on=comp2), - T.normalization(log_eta, on=[comp1, comp2]), # case A: one mode across both - ], - likelihood=rx.StudentT(), - statistical=False, # no reported errors: the noise term is the diagonal -) -fit = c.masked_where(lambda x: x < cut) -held = fit.complement() - -problem = rx.Problem([fit], priors=[(omp.params, stats.multivariate_normal(mu, cov))]) -sampler = dynesty.NestedSampler(problem.log_likelihood, problem.prior_transform, problem.ndim) -sampler.run_nested() -res = sampler.results -samples = res.samples_equal() - -heldout = rx.Problem([held], priors=problem.priors) # same Parameter objects -lp = rx.diagnostics.heldout_log_predictive(heldout, samples) -score = rx.diagnostics.log_posterior_predictive(lp) -logz = rx.diagnostics.logz_summary(res.logz[-1], res.logzerr[-1]) -# to compare with a linear-space fit of the same data: logz_raw = logz + problem.log_jacobian() -``` - -The same problem under emcee: - -```python -import emcee -p0 = problem.sample_prior(32, rng=np.random.default_rng(1)) -sampler = emcee.EnsembleSampler(32, problem.ndim, problem.log_posterior) -sampler.run_mcmc(p0, 5000) -samples = sampler.get_chain(discard=1000, thin=10, flat=True) -band = rx.predictive.predictive_band( - [omp.bind(x_fine, d1.meta)(*s[problem.columns(omp.params)]) for s in samples[::20]] -) -``` - -And under `black-box-bayes`, which needs a pickle and a six-line module: - -```python -# make_problem.py -import dill -with open("problem.pkl", "wb") as f: - dill.dump(problem, f) - -# posterior.py -import dill -def init_posterior(path): - global P, NDIM, parameter_names - P = dill.load(open(path, "rb")); NDIM = P.ndim; parameter_names = P.names -def starting_location(n): return P.sample_prior(n) -def log_posterior(theta): return P.log_posterior(theta) -def log_likelihood(theta): return P.log_likelihood(theta) -def prior_transform(u): return P.prior_transform(u) -``` - -Compare with the current spelling of the same study: `Observation(..., -transform=log)` per dataset, `stacked_supports` to place the terms, -`per_observation_scaling([obs1, obs2])` with `obs` passed to three places, -`Constraint(...)`, `Evidence([...])`, `ParameterConfig` twice with a -`TruncatedNormalPrior` because the MVN prior has no unit-cube map, -`CalibrationConfig`, and `split_samples` to read the chain back. - -## 4. Capability map - -Every statistical capability a current notebook or test demonstrates, and -its spelling in the new API. This table is the acceptance list for the -rewrite: a capability is done when its row has a test. - -| capability (where it is demonstrated today) | new spelling | pinned by | -|---|---|---| -| user-defined model `y = m x + b` (linear_calibration_demo) | `Model(lambda x, m, b: m*x + b, [m, b])` | test_model | -| `Polynomial(order)` (normalization_inference) | `polynomial(order)` | test_model | -| statistical diagonal only; `chi2 / n` (linear_calibration_demo) | default `Constraint`; `problem.chi2(theta)` | test_problem | -| unknown fractional / constant noise (systematic_err_demo, sampling_algos) | `noise_fraction(log_eps)`, `noise(log_eps)` | test_terms::TestFactories | -| inferred noise *replacing* reported statistics (prose today) | `Constraint(statistical=False, terms=[noise(...)])` | test_constraint | -| reported normalisation / offset as fixed modes (measurement_to_calibration) | `block.reported_terms()`; `normalization(magnitude=)`, `offset(magnitude=)` | test_constraint::reported_terms, regression number | -| free normalisation / offset nuisance (systematic_err_demo) | `normalization(parameter=log_eta)`, `offset(parameter=log_omega)` | test_terms | -| fixed dense covariance; fixed diagonal (systematic_err_demo, normalization_inference gallery) | `Term(C, on=b)`, `Term(sig, kind="diag", on=b)` | test_terms::TestTermKinds | -| case B: one parameter, two block-local terms (systematic_err_demo, correlated_observations) | `noise_fraction(log_eps, on=b1), noise_fraction(log_eps, on=b2)`; or two constraints sharing `log_eps` | test_problem::sharing | -| case A: one mode across blocks (correlated_observations) | `normalization(log_eta, on=[b1, b2])` | test_covariance::case_a, regression | -| per-dataset Kennedy–O'Hagan scale ρᵢ (normalization_inference) | `Comparison(d_i, omp \| scale(rho_i))` | test_model, test_constraint | -| single global ρ (test only) | `omp \| scale(rho)` on every block | test_model | -| sampled mean discrepancy `y = f(x; θ) + δ(x; φ)` (new) | `omp + Model(delta_fn, phi)`; alone or alongside `kernel` | test_model (params order, shared parameter, `\|` precedence) | -| multiplicative `x`-dependent correction, i.e. an additive discrepancy in log space (new) | `omp * Model(g_fn, phi)`; `scale(rho)` is the constant case | test_model (`omp * const(rho)` equals `omp \| scale(rho)`) | -| hyperparameters shared across datasets, per-dataset values from `meta` (new) | one term per block with the same `Parameter` objects; `c.meta("Elab")`; `kernel(params=)` | test_terms (`meta` on one block and on a union), test_problem (one slot per shared object) | -| discrepancy correlated across energies: GP over (E, θ) (new) | one `matrix` `Term` with `on=comps` building inputs from `c.meta` and `c.x`; dense path | test_covariance (dense fallback equals hand-built product kernel) | -| unaccounted-for model error per data type, KDUQ (new, reference) | `model_error(delta_T, averaging=True, on=b)` with one `delta_T` per type; the `k/N` democratic and per-type federal scalings are `Constraint(weight=)`; recipe 26 | test_terms (shared object gives one column per type) | -| Peelle's Pertinent Puzzle avoidance (new, reference) | `normalization()` reads `c.ym`; the `t0` variant as a constant `mode`; recipe 27 | test_terms (data-built mode reproduces the `1/(1+n s²)` bias; prediction-built does not) | -| stacking by leave-one-dataset-out (new, reference) | `Constraint.masked` dropping a block, `heldout_log_predictive`; recipe 28 | test_diagnostics | -| cut / modular posterior by multiple imputation (new, reference) | stage-1 `Problem`, per-draw stage-2 `Problem` with the module fixed by closure; per-module `weight`; recipe 29 | test_problem (stage-1 marginal unchanged) | -| leave-one-experiment-out prediction (new, reference) | block masks, `complement`, `predictive_draws`, `coverage_curve`; recipe 30 | test_diagnostics | -| simulation-based calibration of the sampler (new, reference) | `sample_prior`, `predictive_draws`, `dataclasses.replace(d, y=)`; recipe 31 | test_problem (rank uniformity on the linear problem) | -| emulator as `Model`, emulator variance as a `diag` term sharing the model's parameters (new, reference) | recipe 32 | test_terms (a term declaring model parameters receives them) | -| MAP + Laplace (new, reference) | `scipy.optimize` on `log_posterior`, `problem.bounds`; recipe 33 | test_problem | -| global error scale and USU modes (new, reference) | `diag` term scaling `c.meta("y_err")` with `statistical=False`; `offset(parameter=, on=blocks_of_technique)`; recipe 34 | test_terms | -| energy-dependent parameters (new, reference) | per-block `Model` instances closing over `meta`, shared coefficient objects; recipe 35 | test_model | -| discrepancy on a physical basis, Legendre (new, reference) | `systematic` modes or `omp + Model(basis_sum)`; recipe 36 | test_terms | -| correlated systematics between observables of one measurement (new, reference) | two blocks, one constraint, spanning mode; recipe 37 | test_covariance | -| classic normal hierarchical model, BDA3 ch. 5 (new, reference) | marginalised as `noise(log_tau)`, non-centred as a `Model` over `[mu, log_tau, *etas]`, centred as a joint block; recipe 38 | test_problem (marginalised and non-centred agree on `mu, tau`; a parameter on a fully masked block is sampled from its prior) | -| SafeBayes: learn the tempering exponent (new, reference) | driver loop over `replace(c, weight=η)` and `c.masked(prefix)`; next-point density as a log-likelihood difference; recipe 25 | test_problem (`replace` keeps names; `ll(prefix i+1) − ll(prefix i)` equals the Gaussian conditional) | -| hyperprior: per-dataset parameters with a sampled spread (new) | joint block `(children + [hyper], obj)` with `logpdf` and `prior_transform` | test_problem (children uncovered without the block; `prior_transform` round trip) | -| GP discrepancy in x / in momentum transfer with amplitude (gp_discrepancy, TestStudyForms) | `kernel(k, on=b, coords=lambda x: momentum_transfer(x, k), amplitude=..., amplitude_params=...)` | test_terms::TestStudyForms | -| angle-growing noise, mode ∝ θ, `exp_growth`, `x_basis` (TestStudyForms) | same helpers with `on=` | test_terms::TestStudyForms | -| direct two-parameter `Term` escape hatch (TestStudyForms) | `Term(lambda c, e, l: ..., (e, l), kind="diag")` | test_terms | -| Student-t with bounded ν; `Chi2` (robust_likelihoods) | `StudentT(nu=Parameter("nu", bounds=(1, 100)))`; `Chi2()` | test_likelihood closed forms | -| log-space comparison, delta-method errors, `log_jacobian` (tests) | `Comparison(d, m, space=log)`; `problem.log_jacobian()` | test_constraint::TestComparisonSpace | -| masks, `masked_where`, `complement`, held-out scoring (tests) | `Constraint.masked_where`, `.complement()`; `heldout_log_predictive` | test_constraint::TestMask (partition, `ll(fit)+ll(held)==ll(full)`) | -| tempering, two spellings (overconfidence) | `Constraint(weight=)` only | test_problem | -| joint MVN prior over the optical set (most notebooks) | `Problem(..., priors=[(omp.params, mvn)])` | test_problem::priors | -| truncated-normal / bounded independent priors (calibration_config_emcee_dynesty) | `Parameter(prior=stats.norm(...), bounds=(lo, hi))` | test_problem::priors | -| nested-sampling `prior_transform`, now including joint MVN | `problem.prior_transform` | test_problem (round trip, finite at 0 and 1) | -| emcee, dynesty, black-box-bayes drivers | flat interface on `Problem`; dill round trip | test_problem::drivers | -| EXFOR → dataset with unit conversion; per-angle Rutherford `norm` (measurement_to_calibration, tests) | `from_measurement(m, reaction=, quantity=)` | test_data (both conversion directions) | -| elastic `dXS/dA`, `dXS/dRuth`, `Ay` | `ElasticXS(quantity, ...)`; a compound-elastic contribution is subtracted from the data as preprocessing | test_reactions | -| (p,n) IAS channel (tests) | `IsobaricAnalogPN(...)` | test_reactions (Lane term) | -| solver settings reach jitr | `ElasticXS(..., lmax=, wavelengths_beyond_range=, zeros_per_node=)` | test_reactions | -| singular-covariance guard naming the dataset (measurement_to_calibration) | compile-time in `Problem` | test_problem | -| duplicate-name / same-object validation | `ParameterIndex.check_names_unique`; sharing across constraints is legal | test_problem | -| covariance heat-maps (normalization_inference, correlated_observations) | `problem.constraints[i].matrix(theta)` | test_covariance dense equality | -| predictive draws, coverage, sharpness, evidence bookkeeping (tests) | `diagnostics.*` | test_diagnostics | -| GP conditioning; total predictive band (gp_discrepancy) | `predictive.*` | test_predictive vs sklearn | -| fine-grid plotting (every reaction notebook) | `omp.bind(x_fine, d.meta)(*s[problem.columns(omp.params)])` | test_model | - -Four rows are new rather than ported. The sampled mean discrepancy: today a -model-side correction that depends on `x` cannot be written, because the -model transform sees only the prediction. The three hierarchical rows: -today a term cannot read its dataset's metadata, `kernel_term` cannot share -hyperparameters between calls, and a prior cannot depend on a sampled -hyperparameter. - -**Dropped, deliberately:** `Walker`, `MetropolisHastingsSampler`, -`AdaptiveMetropolisSampler`, `BatchedAdaptiveMetropolisSampler`, `proposal`, -`marginal_log_likelihood`, `conditional_posterior`, `predict_parametric`, -`weighted_marginal_log_likelihood`, `CalibrationConfig`, `ParameterConfig`, -`Evidence`, `per_observation_scaling`, `identity` keys, `stacked_supports`, -`split_samples`, `likelihood_scaling`, `IndependentPrior`, -`TruncatedNormalPrior`, the two `Observation` subclasses, `n_dof`. - -## 5. Harvest table - -What comes across from `src/rxmc` on `api_generalisation`, by file. - -### Lift verbatim (about 1,100 lines) - -| current file | pieces | destination | -|---|---|---| -| `transforms.py` | `Transform` (minus `contextual`, `_unpack`), `as_transform`, `identity`, `log`, `exp`, `_safe_log`, `_reciprocal`, `scale` | `transforms.py` | -| `likelihood_model.py` | `Likelihood`, `GaussianLikelihood`→`Gaussian`, `StudentT`, `Chi2`, `log_likelihood` | `likelihood.py` | -| `covariance.py` | `TermContext`, `chol_logdet`, `as_2d`, bases `ones`, `ym`, `averaging`, `x_basis`, `exp_growth`, `constant_amplitude`, `exp_growth_amplitude`; helpers `_masked`, `_full`, `_coefficient`, `_scaled_term`, `_kernel_params`; factories `statistical_term`, `offset_term`, `normalization_term`, `noise_term`, `noise_fraction_term`, `model_error_term`, `systematic_term`, `kernel_term` (drop the `_term` suffix, `support=`→`on=`) | `terms.py` | -| `observation_from_measurement.py` | `ureg`, `XS_UNIT`, `RUTHERFORD_UNIT`, `MB_PER_B`, `DEFAULT_LMAX`, `check_angle_grid`, `measurement_kwargs` | `units.py`, `data.py` | -| `elastic_diffxs_observation.py` | `set_up_solver`, the `calculate_normalization` conversion table, `momentum_transfer` | `reactions/elastic.py`, `data.py` | -| `ias_pn_observation.py` | `set_up_solver` | `reactions/ias.py` | -| `elastic_diffxs_model.py` | `_xs` body, `extract_dXS_dA`, `extract_dXS_dRuth`, `extract_Ay` | `reactions/elastic.py` | -| `ias_pn_model.py` | `_xs` body | `reactions/ias.py` | -| `predictive.py` | `gp_posterior_predictive`, `_gp_condition`, `_gp_posterior_mean_var`, `_train_noise_matrix`, `predictive_band` | `predictive.py` | -| `model_comparison.py` | `_psd_factor`, `_rows`, `coverage_curve`, `coverage_error`, `sharpness`, `log_posterior_predictive`, `logz_summary`, `compare_logz` | `diagnostics.py` | -| `priors.py` | `clip_unit_cube` | `problem.py` | - -### Lift with edits - -| current | change | -|---|---| -| `Observation.systematic_terms` | → `Comparison.reported_terms`; same delta-method logic (offset at `y_raw`, normalisation at `ym_raw`), `on=self` | -| `Observation.__init__` transform handling and `_check_finite` | → `Comparison.__post_init__`; error names `data.label` | -| `Constraint._validate_constant_covariance` message | → compile error raised by `StructuredCovariance.factor_constant_parts`, remedies updated to the new spellings | -| `model_comparison.predictive_draws`, `heldout_log_predictive` | take `(problem, samples)`; read `CompiledConstraint.ym`, `.matrix`, `.log_likelihood` | -| `predictive.total_predictive_band` | take `(problem, term, predictor, ...)`; columns from `problem.columns` | -| `ParameterConfig.prior_transform` cursor | → per-slot map in `assemble_prior` | -| `ElasticDifferentialXSObservation.from_measurement`, `IsobaricAnalogPNObservation.from_measurement` | one free `from_measurement`; Rutherford from kinematics | -| `PhysicalModel.Polynomial` | → `polynomial(order)` factory | - -### Rewrite - -`params.py` (identity semantics, `prior`), the `Term` class body (state -removed), `ConstraintCovariance` → `StructuredCovariance`, `constraint.py`, -`evidence.py` + `config.py` → `problem.py`, `physical_model.py` → -`model.py`, the two observation classes → `from_measurement` + `Model.bind`. - -### Drop - -`walker.py`, `param_sampling.py`, `metropolis_hastings.py`, -`adaptive_metropolis.py`, `proposal.py`, `IndependentPrior`, -`TruncatedNormalPrior`, `as_prior`. - -### Tests to port by body - -The bodies below encode behaviour, not API, and port with renamed calls: - -- `test_covariance.py`: `TestTermKinds`, `TestTermCoords`, `TestFactories` - (including `test_old_observation_covariance_equivalence`), - `TestKernelTerm`, `TestStudyForms` (every α+Ca error-model form against - a hand-built dense matrix), `test_custom_term_direct`. -- `test_likelihood_model.py`: the closed-form Student-t and `Chi2` values. -- `test_constraint.py`: `TestComparisonSpaceTransform` (delta method, - `log_jacobian == -Σ log y`, `-inf` likelihood and `+inf` chi2 for a - non-positive prediction), `TestMask` (complement partition, - `ll(fit) + ll(held) == ll(full)`, shared parameters), `TestSingularCovarianceGuard`, - `TestSharedParameterCaseB`, `TestStackedConstraint` (case A differs from - the independent spelling). -- `test_observation.py`: `test_systematic_terms_propagated_by_delta_method`, - offset-then-normalisation order, zero magnitudes skipped. -- `test_regression.py`: all three pins, including `1.195784087817536`. -- `test_model_comparison.py`, `test_predictive.py` (GP matches sklearn's - `GaussianProcessRegressor`). -- `test_reaction_observation.py`: both Rutherford conversion directions, - `TestSolverSettingsForwarding`, `TestSharedUnits`. -- `test_reaction_models.py`: finite non-negative cross sections through - real jitr solves; the Lane-term note for the IAS test. -- `test_config.py::test_black_box_bayes_interface`, - `test_priors.py::TestUnitCubeClipping`. - -New tests the old suite could not have: dense-versus-structured equality on -every `TestStudyForms` form, with masks, with a cross-block kernel (dense -fallback), and with a mode-only block (singular `B`); a parameter shared -across two constraints; a `dill` round trip of an elastic `Problem` with -equal `log_posterior`; MVN `prior_transform` round trip and finiteness at -exactly 0 and 1; `Constraint.weight` scaling the likelihood only. - -The ported bodies are unit tests of modules. The recipe tests under -`test/recipes/` are the acceptance suite, and §9 lists which recipes each -milestone unlocks. Recipe tests use synthetic data and the generic `Model` -wherever the recipe does not require a reaction model, so they stay fast; -reaction recipes patch `set_up_solver` as the current -`test_reaction_observation.py` does, except for one real-solve smoke test. - -## 6. Repository layout and budget - -``` -rxmc/ - __init__.py re-exports; nothing else - params.py ~40 transforms.py ~230 units.py ~60 - data.py ~180 model.py ~120 terms.py ~380 - likelihood.py ~90 constraint.py ~170 covariance.py ~260 - problem.py ~320 diagnostics.py ~250 predictive.py ~200 - reactions/ - __init__.py - elastic.py ~170 ias.py ~120 -test/ unit tests, one file per module, plus test_regression.py -test/recipes/ one file per recipe in docs/recipes.md (~38), the acceptance suite; - oracle.py holds the closed-form linear-Gaussian posterior used by the fast tier -examples/ 9 notebooks (§7) -docs/ design.md rewritten from this document once the code lands -``` - -Runtime dependencies: `numpy`, `scipy`, `pint`, `jitr>=3.0`, -`exfor-tools`. `pandas` and `scikit-learn` leave `requirements.txt` -(neither is imported; kernels stay duck-typed and sklearn moves to the -`examples` extra). Extras: `examples` (emcee, dynesty, corner, matplotlib, -scikit-learn, dill, jupyter), `validation` (examples + pytest, nbmake, -ruff, black, isort). Python ≥ 3.12. Validation is the current contract: -ruff/black/isort on `src test`, nbqa on `examples`, `pytest test`, then -`pytest --nbmake examples`. `pyproject` registers the `slow` marker and -deselects it by default (`addopts = -m "not slow"`, §9). - -## 7. Notebooks - -Nine notebooks, each naming the current one it inherits. Every notebook -is driven by emcee or dynesty. - -| notebook | inherits | driver | new content | -|---|---|---|---| -| `linear_calibration` | linear_calibration_demo | emcee | prior predictive, posterior, predictive band with `problem.columns` | -| `error_models` | systematic_err_demo | emcee | the five-model ladder; two-constraint section with case B via shared `Parameter` | -| `normalization_and_covariance_structure` | normalization_inference | emcee | ρᵢ as `omp \| scale(rho_i)`; the four-case gallery via `matrix(theta)` | -| `correlated_observations` | correlated_observations | emcee | case A vs B, toy and n+⁴⁰Ca | -| `gp_discrepancy` | gp_discrepancy | emcee | `kernel` term; `total_predictive_band(problem, term, ...)`; the same defect fit with a sampled `omp + delta` mean correction for contrast | -| `robust_likelihoods` | robust_likelihoods | emcee | Student-t vs Gaussian; ν bounded on the `Parameter` | -| `measurement_to_calibration` | measurement_to_calibration + 30s_optical_potential_calibration + the tempering/coverage section of overconfidence | dynesty | `from_measurement`, `reported_terms`, the singular-covariance error, `Constraint(weight=)`, `coverage_curve` | -| `alpha_ca_error_model_comparison` | **new** (the `design.md` recipe table) | dynesty | log space, `Parameter(prior=)`, masks, `complement`, `heldout_log_predictive`, `logz_summary` / `compare_logz` with `log_jacobian`, shared noise (B) and coupled normalisation (A) across two datasets, the bbb shim shown but not run | -| `hierarchical_calibration` | **new** (recipes 24, 35, 38) | dynesty | hierarchy on the physics parameters; see below | - -**`hierarchical_calibration` in detail.** The truth is -`y = a0(E) + a1(E) x + a2(E) x²`, measured by J synthetic datasets at known -energies `E_j` (in `meta`) plus one held-out dataset at a new energy. The -true coefficient mappings `a_k(E)` are a smooth trend plus non-monotonic -bumps. Three fits of the same data: - -1. the correct mapping form with global `φ`; -2. a misspecified smooth mapping `a_k(E; φ) = φ_k0 + φ_k1 E` with global `φ`; -3. the same smooth mapping plus a per-dataset deviation vector in parameter - space, non-centred `δ_j = τ ⊙ η_j`, `η_jk ~ N(0, 1)`, - `τ_k ~ HalfNormal`, so the inter-dataset covariance is diagonal with a - learned spread (a full covariance through an LKJ-style joint block is - the named extension). - -Mechanics: one `Model` per block closing over `E_j` (recipe 35). The -held-out block is fully masked, so its `η_new` is sampled from the prior -only, driven by `τ`; `complement()`, `predictive_draws` and -`heldout_log_predictive` then score the new energy with no extra code. The -notebook states this design property explicitly. Plots: the coefficient -mappings against `E` with the truth; per-dataset residuals for case 2; -empirical coverage curves in-sample and on the held-out energy for all -three cases; sharpness; the posterior of `τ`; the held-out log predictive -per case. Expected: case 1 covers in and out of sample; case 2 -under-covers both and shows structured per-dataset residuals; case 3 -recovers coverage with wider, longer-tailed bands at the new energy (a -scale mixture over `τ`), a `τ` posterior away from zero, and the best -held-out score of the misspecified pair. Caveat stated in the notebook: -with few datasets `φ` and `δ_j` trade off, and the hyperprior on `τ` is -what resolves it. - -Dropped: `sampling_algos` (in-package samplers), `calibration_config_emcee_dynesty` -(every notebook is now this), `overconfidence` as a standalone. - -## 8. Gaps: what exists nowhere today - -- **G1 `ParameterIndex` and compile** (`problem.py`): first-seen slot - assignment, `on=` resolution against comparisons and datasets, `masks` → - `active`, name uniqueness, prior coverage. About 120 lines. -- **G2 Prior assembly**: marginal truncation to `bounds`, uniform default, - the joint-block protocol including hyperprior blocks, - joint blocks, `log_prior`, `prior_transform` (rescaled `ppf`; MVN - whitening; other joints must supply their own), `sample_prior`. About - 100 lines. -- **G3 `StructuredCovariance`**: new linear algebra. Verified against the - dense matrix on every `TestStudyForms` case, with masks, with a - cross-block kernel, and with a mode-only block. About 260 lines. -- **G4 Stateless `Term`, `Comparison`, `Constraint` masks**: including - `reported_terms` under a comparison transform and the complement - partition property. -- **G5 Rutherford in `from_measurement`**: resolved, it is a closed form of - `reaction.kinematics(Elab)`; no workspace needed. -- **G6 `dill` picklability**: a test round-trips an elastic `Problem` and - compares `log_posterior`. If a jitr workspace does not pickle, - `Predictor.__reduce__` rebuilds it from `(model, x, meta)`; the factory - closures in `terms.py` pickle under `dill` as they are. -- **G7 Analysis on `(problem, samples)`**: `predictive_draws`, - `heldout_log_predictive`, `total_predictive_band` selecting columns via - `problem.columns`. -- **G8 The α+Ca and hierarchical notebooks** and the bbb `posterior.py` shim. -- **G9 Docs**: `design.md` rewritten from this document; API reference - regenerated; README quickstart in the new spelling. - -## 9. Milestones - -Each step is testable on its own in the new repository. Every milestone -lists the modules it delivers, the unit tests it ports, and the recipe -tests it unlocks: a recipe test lands in the first milestone where every -object it uses exists. A milestone is done when its unit tests and every -recipe test it unlocks pass. - -0. **Bootstrap.** A branch `rewrite` of *this* repository, cut from - `main` after the 0.x close-out (§11), developed in a git worktree at - `~/el/rxmc-ng` with its own virtual environment (`jitr>=3.0` from PyPI, - Python ≥ 3.12). Its first commit removes `src/`, `test/` and - `examples/` and keeps `docs/` (this document and `recipes.md` are the - plan of record) and the configuration. Files that move mostly intact - (`transforms`, `likelihood`, `units`, the term factories) come over by - `git mv` in a commit of their own before any edit, so blame survives - the harvest. Then: a `pyproject` in the current shape with the `slow` - marker registered and deselected by default; ruff, black and isort - configuration carried over; the CI workflow (fast tier on pull - requests, `pytest -m slow` and nbmake on a schedule); a trusted- - publishing workflow that uploads to PyPI on tag push. -1. **`params`, `transforms`, `units`, `likelihood`, `terms`** (verbatim - harvest plus the stateless `Term`). Ported: `TestTermKinds`, - `TestTermCoords`, `TestFactories`, `TestKernelTerm`, `TestStudyForms` - (term values against hand-built matrices), the closed-form Student-t - and `Chi2`, `TestUnitCubeClipping`, `TestSharedUnits`. Recipe tests - unlocked: none end to end (there is no `Problem` yet). The term-level - halves of recipes 19 (fixed-array shape and symmetry checks, a custom - callable) and 27 (a `normalization` mode evaluates from `c.ym`, a - data-built mode from `c.y`) are written here as unit tests and reused - by those recipe tests later. -2. **`data`** (without `from_measurement`), **`model`** (generic and - `polynomial`), **`constraint`** (`Comparison`, `Constraint`, masks, - `reported_terms`). Ported: `TestComparisonSpaceTransform` at block - level, delta-method `reported_terms`, `TestMask` construction and the - `complement` partition of active sets, name and shape validation. - Recipe tests unlocked: none (no likelihood without the covariance). -3. **`covariance`.** New: dense-versus-structured equality on every - `TestStudyForms` form, with masks, with a cross-block kernel (dense - fallback), and with a mode-only block (singular `B` error). No recipe - tests yet. -4. **`problem`**: index, compile, priors, flat interface; emcee and - dynesty smoke tests on the linear problem; `dill` round trip. The - acceptance suite starts here, all on synthetic data with generic - models. Recipe tests unlocked: - - core: 1, 2, 4, 5, 6, 8, 9, 10, 11, 12, 13, 16, 19, 20, 21; - - hierarchy and sharing: 22, 23, 24, 38; - - driver loops needing only `log_likelihood`, `log_prior`, - `sample_prior`: 25 (SafeBayes), 26 (KDUQ weights), 27 (Peelle), 29 - (cut posterior), 32 (an emulator term sees the model's parameters), - 33 (MAP and Laplace), 34, 35, 36. - - Regression pins carried here: `1.195784087817536`, the old-covariance - equivalence, `ll(fit) + ll(held) == ll(full)`, and "a parameter on a - fully masked block is sampled from its prior", which recipe 38 and the - hierarchical notebook rely on. -5. **`reactions/elastic`, `reactions/ias`, `from_measurement`.** Ported: - both Rutherford conversion directions, `TestSolverSettingsForwarding`, - real-solve smoke tests, the Lane-term IAS check. Recipe tests - unlocked: 3, 14, 15, 37; the reaction variants of 7 and 22 - (momentum-transfer coordinates, an energy-running amplitude) run - against a patched solver. -6. **`diagnostics`, `predictive`.** Ported: GP-versus-sklearn, - `predictive_draws` covariance recovery, `heldout_log_predictive`, - `logz_summary` and `compare_logz`. Recipe tests unlocked: 7 - (`total_predictive_band` finds the kernel columns itself), 17, 18, 28, - 30, 31. -7. **CI wiring.** The heading-to-file check between `recipes.md` and - `test/recipes/`; `pytest test` runs both suites; the fast tier must - finish in a few minutes on a laptop (patched solvers, small `J` and - `n`). -8. **Notebooks 1–9.** Each notebook names the recipes it is the tutorial - for: `linear_calibration` (1, 17); `error_models` (2, 4, 5, 19); - `normalization_and_covariance_structure` (3, 6, 27); - `correlated_observations` (5, 37); `gp_discrepancy` (7, 8, 36); - `robust_likelihoods` (9, 34); `measurement_to_calibration` (12, 14, - 15, 16, 21, 26); `alpha_ca_error_model_comparison` (10, 11, 13, 18, - 25); `hierarchical_calibration` (22, 24, 35, 38, and 30 for the - held-out energy). A recipe without a notebook is fine; a notebook must - cite at least one recipe. -9. **`design.md` and README** rewritten from this document. - -### Fast and converged tiers - -Recipe tests must be fast in CI, but some expected behaviours only hold -for a converged sampler. The resolution is two tiers with a strong -preference for assertions that need no sampler at all. - -- **Prefer sampler-free assertions.** Most expected-behaviour bullets are - structural or analytic: names and columns, a covariance equal to a - hand-built matrix, `chi2` identities, `ll(fit) + ll(held) == ll(full)`, - a mode built from `c.ym`, `prior_transform` round trips, compile-time - errors. These are exact and form the core of every recipe test. -- **Linear-Gaussian oracle.** `test/recipes/oracle.py` computes the - closed-form posterior and predictive of any recipe instantiated with a - linear model and Gaussian terms. Tests compare `log_posterior` and - `predictive_draws` statistics against it without sampling. This covers - the coverage-type claims of recipes 1, 6, 12, 17, 26 and the - marginalised form of 38 exactly. -- **Seeded short chains, qualitative assertions.** Ordering claims ("case - 2 under-covers and case 3 recovers"; "the Student-t covers the truth - and the Gaussian does not") use a seeded 16-walker, few-hundred-step - emcee run on a toy problem and assert only the ordering, with a wide - margin. -- **Converged tier.** Tests marked `slow` hold the numeric claims - (coverage within 0.05 of nominal, `τ` recovered within its interval, - evidence differences), record the seed, R-hat and effective sample - size so a failure is diagnosable, and run the notebooks through nbmake. - They are deselected by default; pull-request CI runs the fast tier and a - scheduled job runs `pytest -m slow`. -- **Rules.** The fast tier has a budget of a few minutes and zero - tolerated flakiness. A flaky fast assertion is demoted to `slow`, never - loosened until it passes. Every recipe test file has at least one fast - test; a slow test is optional and holds the numbers. Which tier pins - each bullet is decided per recipe as the implementation lands. - -## 10. Open questions - -- **Term-level partial masks.** The factories accept `mask=` for a partial - support today. `on=(block, point_mask)` would make it a first-class - support form; whether that is worth the extra spelling is a matter of - taste. v0 keeps `mask=` on the factories. -- **Workspace caching across datasets at one energy.** Correct without - it; a factor of a few in setup time with it. Not in v0. -- **Cross-constraint modes.** `U` is per constraint so that constraints - stay independent and weights stay meaningful. A mode that couples two - constraints is, as today, a reason to merge them. -- **Known non-goals.** The closing section of `recipes.md`, "What this API - does not express", lists the calibration classes the skeleton rules out - (non-elliptical likelihoods, chain-dependent masks, per-point latents, - per-point likelihood factors, mixture likelihoods) with the size of the - addition each would need. Revisit when a study needs one. - -## 11. Release path: from 0.x to 1.0 in the same repository - -The GitHub repository, its pull-request history, collaborator branches and -Pages documentation are kept. `rxmc` is not on PyPI, so the name is free -and version history there starts at 1.0. - -1. **Close out 0.x.** Merge `api_generalisation` into `main` by pull - request. Tag the merge `v0.1.0` and add a branch `legacy/0.x` at the - same commit: the last state of the old design, with this plan in its - tree, reachable by name forever. -2. **Rewrite on a branch.** `rewrite` is cut from that `main` (§9, - milestone 0). History stays linear; no orphan branch and no force - push. The README on `main` carries a one-line banner pointing at the - branch while the rewrite is in progress. -3. **Pre-releases by tag.** setuptools_scm reads the version from tags. - Tag `v1.0.0a1` after milestone 4, `v1.0.0b1` after milestone 6, - `v1.0.0rc1` after milestone 8; each tag push publishes to PyPI as a - pre-release (installable with `pip install --pre rxmc`). Publishing - `a1` early claims the PyPI name; try TestPyPI once first. -4. **Release.** Pull request `rewrite` into `main`, ordinary merge, tag - `v1.0.0`, GitHub Release, PyPI publish, Pages rebuild from `main`. The - README then notes that 0.x lives at `v0.1.0` and `legacy/0.x`. -5. **Old branches.** Collaborators' branches are left alone; superseded - ones may be deleted after 1.0. diff --git a/docs/index.rst b/docs/index.rst index b34b31e..9368e2e 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -1,31 +1,29 @@ rxmc ==== -``rxmc`` is an orchestration layer for Bayesian calibration of reaction models -to large data sets with flexible, composable covariance modeling. +``rxmc`` calibrates reaction models to experimental data by Bayesian +inference, with the error model, statistical and systematic, experimental +and theoretical, declared explicitly as part of the problem, and the +calibration driven by external samplers (pocomc, emcee, dynesty, black-box-bayes) +and, with JAX gradients, by HMC or optimisers. -It is built around two complementary workflows: +- :doc:`recipes` states every supported use case with its spelling and the + behaviour to expect; each recipe is a test. +- :doc:`examples` are the tutorials for the recipes. +- :doc:`design` is the maintainer's description of the library, and + :doc:`benchmarks` says how fast it is and how the samplers compare. +- :doc:`api` is the reference. -1. **External-sampler orchestration** via :class:`~rxmc.config.CalibrationConfig` - for drivers such as `black-box-bayes `_. -2. **In-package end-to-end prototyping** via :class:`~rxmc.walker.Walker` - for smaller problems where you want to run the full MCMC workflow locally. - -The package composes curated experimental data (:class:`~rxmc.observation.Observation`), -model predictions (:class:`~rxmc.physical_model.PhysicalModel`), uncertainty -declared as additive covariance :class:`~rxmc.covariance.Term` s (statistical, -systematic, unknown-noise, and Gaussian-process discrepancy modes), maximal -blocks of mutually-correlated data (:class:`~rxmc.constraint.Constraint`), and -full calibration problems (:class:`~rxmc.evidence.Evidence`). +This is ``rxmc`` 1.0, a rewrite that does not run 0.x code; +:doc:`installation` says how to pin 0.x. .. toctree:: :maxdepth: 1 :caption: Contents installation - design - groundup_design recipes - bugs_found - api examples + design + benchmarks + api diff --git a/docs/installation.rst b/docs/installation.rst index 54b6fa0..0b40f38 100644 --- a/docs/installation.rst +++ b/docs/installation.rst @@ -1,59 +1,42 @@ Installation ============ -Requirements ------------- - -``rxmc`` requires Python 3.10 or later. Core dependencies are listed in -``requirements.txt`` and are installed automatically. - -Development / local use ------------------------ +``rxmc`` requires Python 3.12 or later. The runtime dependencies are +``numpy``, ``scipy``, ``jax``, ``tinygp``, ``jitr`` and ``exfor-tools``, +installed automatically. ``jitr`` is taken from its ``jax-core`` branch, the +JAX solver of the next jitr release, until that release is on PyPI; the rxmc +1.0 pre-releases wait on it too, since PyPI does not accept a git dependency. +Importing ``rxmc`` turns on JAX's 64-bit mode for the process. For a GPU, +install a CUDA build of ``jax`` first (see the JAX installation guide). +Install from GitHub: .. code-block:: bash git clone git@github.com:beykyle/rxmc.git cd rxmc - pip install -ve . - -It is strongly recommended to use an isolated environment. - -``venv`` --------- - -.. code-block:: bash - - python -m venv .rxmc - source .rxmc/bin/activate - pip install -r requirements.txt - pip install -ve . - -``uv`` ------- - -.. code-block:: bash - - uv env create - uv env use python - uv install -e . - -Optional extras ---------------- - -Install example notebook runtime dependencies: - -.. code-block:: bash - - pip install -ve '.[examples]' - -Install the full validation toolchain (formatting, linting, testing): - -.. code-block:: bash - - pip install -ve '.[validation]' - -Install documentation build dependencies: + python -m venv .venv && source .venv/bin/activate + pip install -e '.[examples]' + +Extras: + +=============== ============================================================= +``examples`` emcee, dynesty, pocomc, blackjax, corner, matplotlib, dill, + jupyter: everything the notebooks use (pocomc brings torch; + with ``uv`` it comes from PyTorch's CPU wheels, with ``pip`` + install ``torch`` from ``--index-url + https://download.pytorch.org/whl/cpu`` first) +``validation`` ``examples`` plus pytest, nbmake, nbqa, ruff, black, isort, + and scikit-learn (a reference for the kernel tests) +``docs`` sphinx, the pydata theme, myst-nb +``samplers`` ptemcee and PyMC: the extra samplers of + ``benchmarks/bench_samplers.py`` (:doc:`benchmarks`) +=============== ============================================================= + +The 0.x package, which 1.0 replaces without backwards compatibility, is +preserved at tag `v0.1.0 `_ and +on branch `legacy/0.x `_. +Pin it with: .. code-block:: bash - pip install -ve '.[docs]' + pip install git+https://github.com/beykyle/rxmc@v0.1.0 diff --git a/docs/recipes.md b/docs/recipes.md index 3eaa9f6..2b43f54 100644 --- a/docs/recipes.md +++ b/docs/recipes.md @@ -1,21 +1,22 @@ # Recipes -Short user stories for the ground-up `rxmc` described in `groundup_design.md`. +Short user stories for `rxmc`, whose design is described in `design.md`. Each recipe says what a user wants, how it is spelled, and what behaviour -they should expect. Together they are the minimal set of use cases the -rewrite must support; every one of them is backed by a notebook or a test -in the current repository, or by a design decision recorded in the design -document. Every recipe is also a test: `test/recipes/test_recipe_NN_.py` +they should expect. Every recipe is also a test: `test/recipes/test_recipe_NN_.py` asserts its *Expected behaviour* bullets, and the richest recipes are -tutorial notebooks (design document §7 and §9). Snippets assume: +tutorial notebooks (design document §6). Snippets assume: ```python -import numpy as np, rxmc as rx +import numpy as np, jax.numpy as jnp, jax.scipy.stats as jst, tinygp, rxmc as rx from rxmc import terms as T, transforms as tf from scipy import stats -from sklearn.gaussian_process.kernels import Matern, RBF ``` +Models, terms, transforms and custom priors are callables written with +`jax.numpy` (`jnp.exp`, not `np.exp`): the densities are JAX, so gradients +flow through every piece of the declaration. `np` is fine for constants +built outside those callables. + --- ## 1. Fit a model to data with reported statistical errors @@ -36,7 +37,7 @@ Expected behaviour: equals `sum(((y - ym) / y_err)**2)` exactly. - `problem.ndim == 2`, `problem.names == ["m", "b"]`, in declaration order. - `problem.log_posterior`, `problem.sample_prior(n)`, `problem.prior_transform` - are all that emcee or dynesty need (recipe 16). + are all that emcee, dynesty or pocomc need (recipe 16). ## 2. Infer an unknown noise level @@ -46,8 +47,8 @@ infer the noise magnitude alongside the model.* ```python log_eps = rx.Parameter("log_eps", prior=stats.norm(-2, 2)) c = rx.Constraint([rx.Comparison(d, line)], terms=[T.noise(log_eps)], statistical=False) -# or fractional noise: T.noise_fraction(log_eps) -# or model error on the average of data and prediction: T.model_error(log_gamma) +# or an error proportional to the prediction: T.proportional_error(log_eps) +# or proportional to the average of data and prediction: T.proportional_error(log_gamma, averaging=True) # or noise growing along x: T.noise(log_eps, basis=T.exp_growth(np.pi), basis_params=(slope,)) ``` @@ -55,9 +56,9 @@ Expected behaviour: - With `statistical=False` the inferred noise *replaces* the reported errors; with the default `statistical=True` it is *added* to them. -- The posterior of `log_eps` reflects the residual scatter. In the - `sampling_algos` scenario its truth is recovered. -- `noise_fraction` and `model_error` scale with the prediction, so the +- The posterior of `log_eps` reflects the residual scatter; in + `linear_calibration` it recovers the truth. +- `proportional_error` scales with the prediction, so the covariance changes with the model parameters. That is allowed and costs nothing extra. @@ -78,8 +79,8 @@ Expected behaviour: prediction-scaled normalisation mode. Zero magnitudes yield no term. - Without the call, neither systematic enters the covariance. Nothing is folded in silently. -- Re-adding both terms reproduces the pre-0.1 auto-folded covariance to - the last digit (`test_regression`, log-likelihood `1.195784087817536`). +- Adding both terms reproduces the regression pin to the last digit + (`test_regression`, log-likelihood `1.195784087817536`). - Under `space=tf.log` the modes are propagated by the delta method: the offset at the data, the normalisation at the prediction. @@ -93,6 +94,11 @@ log_eta = rx.Parameter("log_eta", prior=stats.norm(-3, 1)) c = rx.Constraint([comp], terms=[T.normalization(parameter=log_eta)]) # absolute offset instead: T.offset(parameter=log_omega) # a mode with any shape: T.systematic(log_s, basis=T.x_basis(np.pi)) + +# one magnitude per dataset: a parameter and a comparison-local mode each +etas = [rx.Parameter(f"log_eta_{i}", prior=stats.norm(-3, 1)) for i in range(len(comps))] +c_each = rx.Constraint(comps, terms=[T.normalization(parameter=e, on=cmp) + for e, cmp in zip(etas, comps)]) ``` Expected behaviour: @@ -100,6 +106,13 @@ Expected behaviour: - One rank-one mode `exp(log_eta)**2 * outer(ym, ym)` is added. - The model parameters decorrelate from the overall scale of the data; the data's normalisation pull moves into `log_eta`. +- One magnitude per dataset is the same spelling with one parameter and one + `on=` per comparison: each mode stays inside its own block, so the + datasets remain independent, and each `log_eta_i` is inferred from its own + dataset's scatter about the prediction. This is what to do when an + experiment reports no systematic uncertainty at all; recipe 5 shares one + magnitude between datasets instead, and recipe 6 puts the scale on the + *mean* rather than in the covariance. ## 5. Share an error model between datasets, or couple them @@ -126,7 +139,7 @@ Expected behaviour: - All three spellings have exactly one nuisance parameter. - Case B's covariance is block diagonal; case A's has a non-zero off-diagonal block. The two likelihoods differ, and treating case A - data as case B is overconfident (`correlated_observations`). + data as case B is overconfident. - Sharing is by object: two `Parameter("log_eta")` objects would be two parameters and a compile error for the duplicate name. - Case A costs no more than case B: the cross-comparison mode goes through the @@ -150,10 +163,12 @@ Expected behaviour: parameters follow the model's in `problem.names`. - A masked or held-out view of the comparison keeps the same `rho_i` because the comparison, not the data, carries the model. -- Fitting the ρᵢ recovers the true normalisations by MAP - (`normalization_inference`); folding the reported σ_sys in as fixed - normalisation modes (recipe 3) gives statistically the same model - posterior. +- Fitting the $\rho_i$ recovers normalisations that are consistent with + their quoted widths; one tightly mis-quoted dataset sets the overall scale + through its prior and biases them all + (`normalization_and_covariance_structure`). Folding the reported + $\sigma_\text{sys}$ in as fixed normalisation modes (recipe 3) gives nearly + the same model posterior. ## 7. Absorb model deficiency with a Gaussian process @@ -162,25 +177,61 @@ angle or in momentum transfer, learned from the residuals.* ```python log_A = rx.Parameter("log_A", prior=stats.norm(0, 2)) -gp = T.kernel(Matern(1.0, nu=2.5), on=comp, coords=lambda x: x / np.pi, +log_ell = T.kernel_params(["length_scale"], [(np.log(1e-5), np.log(1e5))]) +gp = T.kernel(lambda le: tinygp.kernels.Matern52(scale=jnp.exp(le)), log_ell, + on=comp, coords=lambda x: x / np.pi, amplitude=T.constant_amplitude, amplitude_params=(log_A,)) # in momentum transfer with amplitude A q^(r/2): q = lambda x: rx.reactions.momentum_transfer(x, d.meta["k"]) -gp_q = T.kernel(RBF(1.0), on=comp, coords=q, amplitude=lambda c, lA, r: np.exp(lA) * c.x ** (r / 2), +gp_q = T.kernel(lambda le: tinygp.kernels.ExpSquared(scale=jnp.exp(le)), log_ell, + on=comp, coords=q, amplitude=lambda c, lA, r: jnp.exp(lA) * c.x ** (r / 2), amplitude_params=(log_A, r)) -c = rx.Constraint([comp], terms=[gp]) -band = rx.predictive.total_predictive_band(problem, gp, omp.bind(x_fine, d.meta), x_fine, samples) +eps = T.noise(rx.Parameter("log_eps", prior=stats.norm(-3, 1))) +c = rx.Constraint([comp], terms=[eps, gp]) +pred = omp.bind(x_fine, d.meta) +# the model's own prediction with correlated draws from the inferred covariance +band = rx.predictive.grid_draws(problem, pred, x_fine, samples, terms=[gp]) +# what a measurement would show: the experimental terms too (recipe 40) +full = rx.predictive.grid_draws(problem, pred, x_fine, samples, terms=[gp, eps]) +# GP regression on the residuals instead +fit = rx.predictive.gp_predictive_draws(problem, gp, pred, x_fine, samples, terms=[gp], + conditioned=True) ``` Expected behaviour: -- One parameter per free kernel hyperparameter element, named - `discrepancy_`, sampled in sklearn's log-theta space. +- The kernel is a tinygp kernel built from the sampled values by the + builder passed to `kernel()`; the builder owns the parameterisation (here + a log length scale), so sums, products and anisotropic metrics are one + lambda. The hyperparameters are declared: `kernel_params(names, + bounds)` gives `discrepancy_` with a uniform prior on the bounds, + or pass any `Parameter` objects. A tinygp kernel object itself is a + fixed kernel. +- `kernel()` returns a `KernelTerm`, a `Term` that also carries its builder, + so the predictive band can be built from the term alone. - The model parameters relax from their biased values toward the truth - (`gp_discrepancy`); the learned discrepancy tracks the true defect. -- `total_predictive_band` finds the kernel's columns from the term itself; - no column arithmetic. -- Every error-model form of the α+Ca study reproduces a hand-built dense + (`gp_discrepancy`, on the toy). The mean-zero envelope describes how far + the model may stray; it is not a fit to the defect and need not contain it + (in `gp_discrepancy` it does over most of the toy's data range and over + half of the cross section's grid), and on a model with missing physics some + parameters can stay confidently wrong. +- The kernel declares a **mean-zero** discrepancy, so the likelihood is the + marginal $y \sim \mathcal{N}(y_m(\alpha), \Sigma(\alpha))$ and $\alpha$ is inferred with the discrepancy + integrated out. `grid_draws` with the kernel among its `terms` matches + that: whole correlated curves drawn from the inferred covariance about the model's own + prediction, one per posterior row. That is a statement about where and by + how much *the model* fails. +- `gp_predictive_draws(..., conditioned=True)` gives the other object, the GP posterior mean given the + residuals — data-driven regression on top of the model, which interpolates + the residuals rather than describing the model's error. + `gp_posterior_predictive` is the same conditioning on bare arrays. +- `gp_predictive_draws` finds the kernel's constraint, rows and columns + from the term itself; no column arithmetic. Unconditioned it is exactly + `grid_draws` on that constraint. Both predict in the comparison space + (`physical=True` maps back), and `return_draws=True` gives the + draws themselves, which is what a functional summary (a simultaneous band, + an extremum, an integral) needs — well posed only because the draw is joint. +- Every error-model form of the $\alpha$ + Ca study reproduces a hand-built dense matrix (`TestStudyForms`). ## 8. Sample a mean discrepancy explicitly @@ -205,26 +256,30 @@ Expected behaviour: its constant special case. - The GP of recipe 7 may be used alongside it. -## 9. Heavy tails +## 9. Choose the likelihood functional -*A few points are gross outliers. I do not want them to drag the fit; I -want a likelihood that widens instead of breaking.* +*I want the same covariance under a different functional of the residual: +the Gaussian, or a pure chi-squared objective.* ```python -nu = rx.Parameter("nu", bounds=(1.0, 100.0)) # uniform on the bounds -c = rx.Constraint([comp], likelihood=rx.StudentT(nu=nu)) +c = rx.Constraint([comp]) # rx.Gaussian(), the default +c_chi2 = rx.Constraint([comp], likelihood=rx.Chi2()) # drops the log-determinant ``` Expected behaviour: -- Same covariance, different functional. The Gaussian version puts the - truth at several σ; the Student-t version covers it - (`robust_likelihoods`), and the posterior of `nu` is small. -- The multivariate t applies one radial tail to the whole stacked residual - of the constraint. A comparison that needs Gaussian tails goes in its own - constraint. -- `rx.Chi2()` drops the log-determinant for a pure chi-squared objective. -- The Student-t value is pinned to its closed form (`test_likelihood`). +- Same covariance, different functional. A likelihood is a functional of + the Mahalanobis distance, the log-determinant and the number of points, + and has no parameters of its own. +- `rx.Chi2()` is `-chi2 / 2`: it ignores the log-determinant, so it is only + right when nothing in the covariance is inferred. With an inferred error + term it rewards inflating the errors without limit. +- rxmc has no heavy-tailed likelihood. For outliers, reject them (recipe + 39); to widen every error bar, infer a global error scale (recipe 34) or + temper the likelihood (recipe 12). A multivariate t of the whole residual + is exactly a global error scale with a heavy-tailed prior, so it does not + down-weight individual points. +- Both values are pinned to their closed forms (`test_likelihood`). ## 10. Compare in log space @@ -269,7 +324,12 @@ Expected behaviour: - `fit` and `held` share every `Comparison`, `Term`, and `Parameter`; the two problems have identical `names`, so a chain from one scores the other. - Active sets are disjoint, their union is every point, and - `ll(fit) + ll(held) == ll(full)` for a block-local covariance. + `ll(fit) + ll(held) == ll(full)` for a block-local covariance. When a term + spans the split (a GP over several experiments), the held-out problem's + own likelihood is the *marginal* of its rows; pass the fitted problem as + `given=` to `heldout_log_predictive` / `predictive_draws` for the + conditional `p(y_held | y_fit, theta)` under the full covariance (recipes + 28 and 30). - Terms are authored once over all points; masking selects rows, it never rebuilds anything. @@ -287,7 +347,8 @@ Expected behaviour: - The log-likelihood of that constraint is multiplied by `weight`; the prior is never touched. One knob, honoured by every driver. - Empirical coverage of the posterior predictive (recipe 17) moves toward - the nominal level as the weight decreases (`overconfidence`). + the nominal level as the weight decreases, for an overconfident + predictive (`overconfidence`). ## 13. Declare priors @@ -297,7 +358,7 @@ to work with nested sampling.* ```python log_eps = rx.Parameter("log_eps", prior=stats.halfnorm(scale=1)) # marginal -nu = rx.Parameter("nu", bounds=(1, 100)) # uniform on bounds +width = rx.Parameter("width", bounds=(1, 100)) # uniform on bounds V = rx.Parameter("V", prior=stats.norm(50, 5), bounds=(30, 70)) # truncated marginal problem = rx.Problem([c], priors=[(omp.params, stats.multivariate_normal(mu, cov))]) # joint block ``` @@ -311,6 +372,12 @@ Expected behaviour: `u = 0` and `u = 1`. - `problem.sample_prior(n)` gives an `(n, ndim)` array suitable as emcee's starting positions. +- The log density is JAX. Scipy marginals of the families in + `rx.problem.JAX_LOGPDFS` (norm, uniform, truncnorm, gamma, beta, lognorm, + halfnorm, cauchy, halfcauchy, t, expon, laplace, logistic, invgamma) are + translated; any other family needs `Parameter(..., logpdf=f)` with `f` + written in `jax.numpy`, or compile names the parameter. A custom joint's + `logpdf` must be `jax.numpy` too, and is checked at compile. ## 14. From an EXFOR measurement to a dataset @@ -321,6 +388,10 @@ units with nothing lost.* ```python d = rx.from_measurement(m, reaction=reaction, quantity="dXS/dA") # or "dXS/dRuth", "Ay" d_ias = rx.from_measurement(m, reaction=reaction, ExIAS=Ex) # (p,n) IAS channel +d_dict = rx.from_measurement({"x": deg, "y": y, "statistical_err": dy, "Einc": E, + "quantity": "dXS/dRuth", "y_units": "no-dim", + "systematic_norm_err": 0.0, "systematic_offset_err": 0.0}, + reaction=reaction) # or a plain dict ``` Expected behaviour: @@ -335,6 +406,10 @@ Expected behaviour: is everything a reaction model needs to bind. - Incompatible units, or a quantity the measurement cannot be converted to, raise at conversion time. +- Angles must be in the CM frame: a measurement whose `x_units` is + `LAB-degrees` raises; convert it to CM first. +- Any object with the `Distribution` field names works, and so does a + `dict` with those keys; a missing field raises, naming it. ## 15. Evaluate a reaction model on any grid @@ -345,9 +420,10 @@ grid for plotting, with the solver set up once per grid.* omp = rx.reactions.ElasticXS("dXS/dA", central, spin_orbit, args_from_params, params, lmax=20, wavelengths_beyond_range=2.0, zeros_per_node=5) comp = rx.Comparison(d, omp) # bound to d.x, d.meta -fine = omp.bind(np.deg2rad(np.linspace(0.5, 179.5, 200)), d.meta) -ys = [fine(*s[problem.columns(omp.params)]) for s in samples[::50]] -band = rx.predictive.predictive_band(ys, levels=(5, 50, 95)) +x_fine = np.deg2rad(np.linspace(0.5, 179.5, 200)) +fine = omp.bind(x_fine, d.meta) +band = rx.predictive.grid_draws(problem, fine, x_fine, samples[::50], model_only=True, + levels=(5, 50, 95)) ``` Expected behaviour: @@ -362,10 +438,20 @@ Expected behaviour: ## 16. Drive the calibration with an external sampler -*I want to use emcee, dynesty, or the `black-box-bayes` CLI, and read the -chain back without positional arithmetic.* +*I want to use pocomc, emcee, dynesty, or the `black-box-bayes` CLI, and +read the chain back without positional arithmetic.* ```python +# pocomc: sample the unit cube, so the evidence is the problem's own +def log_likelihood(u): # rows of the unit cube + return problem.log_likelihood_batch(problem.prior_transform_batch(u)) +smc = pocomc.Sampler(pocomc.Prior([stats.uniform(0, 1)] * problem.ndim), + log_likelihood, vectorize=True, + n_effective=4096, n_active=2048) # 8x the defaults +smc.run(); u, _, _ = smc.posterior(resample=True) +samples = problem.prior_transform_batch(u) +logz = rx.diagnostics.logz_summary(*smc.evidence()) + # emcee p0 = problem.sample_prior(32) sampler = emcee.EnsembleSampler(32, problem.ndim, problem.log_posterior) @@ -382,10 +468,32 @@ dill.dump(problem, open("problem.pkl", "wb")) # posterior.py delegates si Expected behaviour: -- Chains from all three are `(n, ndim)` arrays in `problem.names` order. +- Chains from all of them are `(n, ndim)` arrays in `problem.names` order. Every analysis function takes `(problem, samples)`. -- `log_posterior` evaluates the prior first and never calls the forward - model when the prior is `-inf`. +- `log_posterior` evaluates the prior first and never runs the forward + model when the prior is `-inf` (a `lax.cond` inside the compiled density). +- On a concrete `theta` the densities return Python floats; they are + compiled with `jax.jit` once per problem, and `grad_log_posterior`, + `value_and_grad_log_posterior` and `hessian_log_posterior` serve + gradient-based samplers (HMC/NUTS in blackjax or numpyro) and optimisers. +- Gradient samplers (HMC/NUTS in blackjax or numpyro) take + `log_posterior_unconstrained`: recipe 41. +- pocomc samples a prior of its own; given the unit cube and the likelihood + of `prior_transform(u)` it samples the problem's prior exactly, whatever + its marginals, and its evidence is the problem's. It is the sampler the + reaction notebooks use: on the p + $^{40}$Ca optical model, whose posterior has + two separated islands, it is the only benchmarked sampler not shown wrong + against the reference, at eight times its default `n_effective` and + `n_active`, and even there it is wrong on one seed of three. Below that, + how it weighs the islands changes from run to run, so run it more than + once and compare ([benchmarks](benchmarks.md)). +- Parallelism: `log_posterior_batch` with emcee's `vectorize=True` needs no + pool, and `log_prior_batch`, `log_likelihood_batch` and + `prior_transform_batch` serve other vectorised samplers (pocomc above; + ptemcee through its `mapper`), the densities each one `jax.vmap` call + over the rows. dynesty cannot batch its calls (each live point's walk + is sequential); for process pools and MPI see the design document, + "Parallel sampling" (fork-started pools can deadlock under JAX). - `dill.loads(dill.dumps(problem)).log_posterior(theta)` equals `problem.log_posterior(theta)`, workspaces included. - `problem.NDIM`, `problem.parameter_names`, `problem.starting_location`, @@ -397,16 +505,32 @@ Expected behaviour: contain 68 % of the points, and how wide are they?* ```python -draws = rx.diagnostics.predictive_draws(problem, samples, constraint=0, n_rep=4) +band = rx.diagnostics.predictive_draws(problem, samples, constraint=0, n_rep=4) # (16, 50, 84) % +phys = rx.diagnostics.predictive_draws(problem, samples, n_rep=4, physical=True) # in the data's units +draws = rx.diagnostics.predictive_draws(problem, samples, n_rep=4, return_draws=True) cov = rx.diagnostics.coverage_curve(draws, problem.constraints[0].y[problem.constraints[0].active]) err = rx.diagnostics.coverage_error(draws, y_active) width = rx.diagnostics.sharpness(draws, transform=np.exp) # widths in physical space for a log fit +# the model plus its discrepancy alone, without the experimental uncertainty +model_side = rx.diagnostics.predictive_draws(problem, samples, terms=[gp], statistical=False) ``` Expected behaviour: - Draws are `ym(theta) + L z` on the active points in comparison space; `model_only=True` returns `ym(theta)` and assembles no covariance. +- The return is a percentile band by default, the draws with + `return_draws=True` — the convention `grid_draws` and + `gp_predictive_draws` share. Coverage and sharpness need the draws. + At points that were never measured, use `grid_draws` (recipe 40). +- `terms=` and `statistical=` choose which pieces of the error model a draw + carries; the default is all of them. Model plus discrepancy and model plus + discrepancy plus experimental uncertainty are different objects, and only + the second is what measured data should be compared against — so a coverage + or sharpness check always uses the default. The first answers a different + question: what the fit says about the *model's* prediction. The same two + arguments select on `constraints[i].matrix(theta)`; `given=` conditions + under the full covariance and cannot be combined with a selection. - Coverage is near nominal for a correct error model and clearly below it for an overconfident one. - `logz_summary` reports the max of the replicate half-range and the @@ -415,17 +539,17 @@ Expected behaviour: ## 18. Compare error models by evidence -*The α+Ca study: several error models for data without reported errors. +*The $\alpha$ + Ca study: several error models for data without reported errors. I want the evidence for each, comparable across comparison spaces.* ```python models = { "L0": rx.Constraint([comp_log], terms=[T.noise(log_eps)], statistical=False), - "E0": rx.Constraint([comp_lin], terms=[T.noise_fraction(log_eps)], statistical=False), - "L2y": rx.Constraint([comp_log], terms=[T.noise(log_eps), T.normalization(log_sys)], statistical=False), + "E0": rx.Constraint([comp_lin], terms=[T.proportional_error(log_eps)], statistical=False), + "L2n": rx.Constraint([comp_log], terms=[T.noise(log_eps), T.offset(log_sys)], statistical=False), "Lgp": rx.Constraint([comp_log], terms=[T.noise(log_eps), gp], statistical=False), - "L0t": rx.Constraint([comp_log], terms=[T.noise(log_eps)], statistical=False, likelihood=rx.StudentT()), } +# the labels are defined in the table below this block logz = {} for name, c in models.items(): p = rx.Problem([c.masked_where(lambda x: x < cut)], priors=priors) @@ -434,6 +558,26 @@ for name, c in models.items(): verdict = rx.diagnostics.compare_logz(logz["Lgp"], logz["L0"]) ``` +The error-model ladder of the study, in the words a reader needs. All +forms are covariances of the residual in log space unless stated; `theta` +is the scattering angle in radians and `u = theta / pi`. + +| label | error model | +|---|---| +| `L0` | constant noise: `sigma = err` on every point | +| `E0` | fractional noise in linear space: `sigma_i = err * ym_i` | +| `L1` | noise growing with angle: `sigma(theta) = err * exp(slope * u)` | +| `L2` | `L0` plus one correlated mode proportional to angle, `sys * u` | +| `L2n` | `L0` plus a free correlated offset mode, `sys * 1` (in log space, a normalisation) | +| `L12` | `L1` plus the angle mode of `L2` | +| `Lgp` | `L0` plus a Matérn(5/2) Gaussian process in `u` with constant amplitude | +| `Lgpn` | `L0` plus the Gaussian process with an angle-growing amplitude | +| `LKp` | noise, an offset mode, and an RBF Gaussian process in momentum transfer `q = 2 k sin(theta/2)` with amplitude `A q^(r/2)` | + +The test suite builds every covariance row of this table against a +hand-built dense matrix, and a test compares the table above with the +legend the tests carry, so the two cannot drift. + Expected behaviour: - The same `log_eps` object is reused across models without conflict: @@ -451,7 +595,7 @@ model no helper expresses.* ```python fixed = rx.Term(C, on=comp) # any symmetric PD matrix stat = rx.Term(sig, kind="diag", on=comp) # a fixed std-dev vector -custom = rx.Term(lambda c, e, l: np.exp(e) * np.exp(l * c.x / np.pi), (log_e, slope), kind="diag") +custom = rx.Term(lambda c, e, l: jnp.exp(e) * jnp.exp(l * c.x / np.pi), (log_e, slope), kind="diag") ``` Expected behaviour: @@ -459,10 +603,13 @@ Expected behaviour: - A plain array is a fixed contribution, factored once. Shape and symmetry are checked at construction against the term's `on`. - A callable sees a `TermContext` with `x` (through `coords`), `y`, `ym`, - and `len(c)`; it returns a vector for `diag`/`mode` or a matrix. + `len(c)`, per-point `c.meta(key)`, and, for a term spanning several + comparisons, `c.segments`/`c.labels`/`c.split(a)` giving the rows of + each comparison in the gathered stack; it returns a vector for + `diag`/`mode` or a matrix. - Fitting correlated data with the correct `Term(C)` instead of its diagonal is the difference between an honest and an overconfident - posterior (`normalization_inference` gallery). + posterior (`normalization_and_covariance_structure` gallery). ## 20. Preprocess instead of asking for a feature @@ -529,8 +676,9 @@ log_A0 = rx.Parameter("log_A0", prior=stats.norm(0, 2)) p = rx.Parameter("p", prior=stats.norm(0, 1)) ell = rx.Parameter("gp_length", prior=stats.norm(0, 1)) -amp = lambda c, lA, p: np.exp(lA) * (c.meta("Elab") / 50.0) ** p -terms = [T.kernel(Matern(1.0, nu=2.5), on=comp, params=[ell], +amp = lambda c, lA, p: jnp.exp(lA) * (c.meta("Elab") / 50.0) ** p +matern52 = lambda le: tinygp.kernels.Matern52(scale=jnp.exp(le)) +terms = [T.kernel(matern52, [ell], on=comp, amplitude=amp, amplitude_params=(log_A0, p)) for comp in comps] c = rx.Constraint(comps, terms=terms) ``` @@ -543,26 +691,28 @@ Expected behaviour: - `c.meta("Elab")` is the comparison's energy broadcast to every point of the support, so the amplitude function is written once and works on any comparison. On a term spanning comparisons it is the per-point concatenation. -- Without `params=[ell]`, each `kernel` call would derive its own length - scale, one per dataset. That is also a legitimate model; it is just not - this one. +- With one `kernel_params(["length_scale"], [(-3, 1)], prefix=f"gp{i}")` per call, + each dataset has its own length scale. That is also a legitimate model; + it is just not this one. Two calls declaring the same name with distinct + objects fail compile on the duplicate name. - The comparisons stay uncorrelated, so the constraint is on the structured path. ## 23. A discrepancy correlated across energies and angles *I believe the model's defect varies smoothly in both energy and angle. I -want one GP over (E, θ) that correlates the datasets at different +want one GP over $(E, \theta)$ that correlates the datasets at different energies.* ```python -kE, kθ = RBF(10.0), Matern(0.3, nu=2.5) lE, lθ, log_A = (rx.Parameter(n, prior=stats.norm(0, 1)) for n in ("log_lE", "log_ltheta", "log_A")) def fn(c, lE, lθ, lA): E, θ = c.meta("Elab")[:, None], c.x[:, None] - K = kE.clone_with_theta([lE])(E) * kθ.clone_with_theta([lθ])(θ) # separable product - return np.exp(2 * lA) * K + 1e-10 * np.eye(len(c)) + kE = tinygp.kernels.ExpSquared(scale=jnp.exp(lE)) + kθ = tinygp.kernels.Matern52(scale=jnp.exp(lθ)) + K = kE(E, E) * kθ(θ, θ) # separable product + return jnp.exp(2 * lA) * K + 1e-10 * jnp.eye(len(c)) md = rx.Term(fn, (lE, lθ, log_A), kind="matrix", on=comps) c = rx.Constraint(comps, terms=[md]) @@ -579,7 +729,7 @@ Expected behaviour: one-dimensional kernels is the factorised form. There is no Kronecker speed-up because datasets share no angle grid. - The dense matrix equals the hand-built product kernel on the stacked - `(E, θ)` inputs. + $(E, \theta)$ inputs. ## 24. Per-dataset parameters drawn from a sampled hyperprior @@ -591,10 +741,11 @@ rhos = [rx.Parameter(f"log_rho_{i}") for i in range(len(comps))] # no margina log_tau = rx.Parameter("log_tau") class RhoHierarchy: - def logpdf(self, v): # v ordered as (rhos..., log_tau) + def logpdf(self, v): # v ordered as (rhos..., log_tau); jax.numpy *r, lt = v - return (stats.norm(0, np.exp(lt)).logpdf(r).sum() - + stats.halfnorm(scale=0.3).logpdf(np.exp(lt)) + lt) # hyperprior on tau, with Jacobian + tau = jnp.exp(lt) + return (jst.norm.logpdf(jnp.stack(r), scale=tau).sum() # jst = jax.scipy.stats + + jnp.log(2.0) + jst.norm.logpdf(tau, scale=0.3) + lt) # half-normal hyperprior, Jacobian def prior_transform(self, u): # hyperparameter first, children given it lt = np.log(stats.halfnorm(scale=0.3).ppf(u[-1])) return np.append(stats.norm(0, np.exp(lt)).ppf(u[:-1]), lt) @@ -617,9 +768,9 @@ Expected behaviour: ## 25. SafeBayes: learn the tempering exponent -*I suspect my model is misspecified and want the tempering exponent η +*I suspect my model is misspecified and want the tempering exponent $\eta$ chosen by the data rather than by hand, following Grünwald's SafeBayes -(arXiv:1412.3730): minimise the prequential log-loss of the η-generalised +(arXiv:1412.3730): minimise the prequential log-loss of the $\eta$-generalised posterior over prefixes of the data.* ```python @@ -645,20 +796,20 @@ final = rx.Problem([replace(c, weight=eta_hat)], priors) Expected behaviour: - `replace(c, weight=eta)` and `c.masked(...)` share every comparison, term and - parameter with `c`, so no workspace is rebuilt across the `n × |η|` + parameter with `c`, so no workspace is rebuilt across the $n \times |\eta|$ problems and every problem has the same `names`. -- `after.log_likelihood(θ) − before.log_likelihood(θ)` is - `log p(y_i | y__F = qbar_1 N_1 / (1 + + xi)` with `xi = (q_1 - q_1')^2 sigma_N1^2 var(alpha_1) / (N_1^2 sigma_1^2 + sigma_1'^2)`, and `_F` is pulled down through `c` even though + `alpha_2` was measured once; the variances and the covariance are + deflated in their normalisation parts (eqs. 13-17). The fast tier pins + these closed forms exactly. +- With the covariance built from the *estimate* (`C_I`, eq. 12: the + weighted means, in rxmc a constant term built from a first estimate and + refit, recipe 27) the means are `qbar_i N_i` and the variances + `var(alpha_i) N_i^2 + sigma_Ni^2 qbar_i^2`, with covariance + `c qbar_1 qbar_2 sigma_N1 sigma_N2` (eqs. 18-22): no puzzle. +- The *live* term reading `c.ym` is the generative model's marginal + likelihood, not `C_I`: its covariance grows with the prediction, so the + log-determinant pulls the mode below the exact values (5 % in the + two-quantity case, 9 % in the five-quantity one, against 23 % and about + 30 % for `C_F`), and under a flat prior the `1 / rho` tail pulls the mean + above them. A proper prior on the quantities, or the refit, removes the pull. +- The five-quantity numerical study of the reference (its Table I: `q_i` + = {1.0, 1.5}, {1.8}, {2.2, 2.4}, {1.9, 1.5}, {1.4, 1.2}; `N_i` = 1, 1.1, + 1.25, 1.15, 1.05; `sigma_i = 0.1 q_i`, `sigma_Ni = 0.2 N_i`, `c = 0.8`) + reproduces its Fig. 1: `C_F` gives lower means and smaller standard + deviations on every lattice point, `C_I` agrees with the exact values + (both exact in the fast tier, being generalised least squares). +- Analysing powers are *not* an instance of this recipe: a ratio of cross + sections has a fixed normalisation, so nothing correlated can be inferred + for it. The real-data case of the reference (`237Np(n,f)` measured + relative to `235U(n,f)` by three experiments, converted with the standard + and its covariance) has the same structure with the standard's covariance + as `B`. Reference: Neudecker, Frühwirth, Kawano, Leeb, *Adequate treatment of -correlated experimental data in nuclear data evaluations*, Nucl. Data Sheets -118, 364 (2014). +correlated experimental data in nuclear data evaluations avoiding Peelle's +Pertinent Puzzle*, Nucl. Data Sheets 118, 364 (2014). ## 38. The classic normal hierarchical model (eight schools) *Several groups each report an estimate `y_j` with a known standard error -`σ_j`. I believe the group effects `θ_j` are drawn from a common -distribution `N(μ, τ²)` and want to learn `μ`, `τ`, and the shrunken -`θ_j`.* +$\sigma_j$. I believe the group effects $\theta_j$ are drawn from a common +distribution $\mathcal{N}(\mu, \tau^2)$ and want to learn $\mu$, $\tau$, and the shrunken +$\theta_j$.* ```python d = rx.Dataset(x=np.arange(J), y=estimates, y_err=std_errors) # x is the group index @@ -1075,19 +1294,19 @@ mu = rx.Parameter("mu", prior=stats.norm(0, 25)) log_tau = rx.Parameter("log_tau", prior=stats.norm(1, 1)) # 1. marginalised: integrate the theta_j out; y_j ~ N(mu, sigma_j^2 + tau^2) -c_marg = rx.Constraint([rx.Comparison(d, rx.Model(lambda x, mu: np.full(len(x), mu), [mu]))], +c_marg = rx.Constraint([rx.Comparison(d, rx.Model(lambda x, mu: jnp.full(len(x), mu), [mu]))], terms=[T.noise(log_tau)]) # theta_j afterwards, from the conditional normal at each draw (mu, tau): # mean = (y_j / s_j^2 + mu / tau^2) / (1 / s_j^2 + 1 / tau^2), var = 1 / (1 / s_j^2 + 1 / tau^2) # 2. non-centred: theta_j = mu + tau * eta_j, eta_j ~ N(0, 1); marginal priors only etas = [rx.Parameter(f"eta_{j}", prior=stats.norm(0, 1)) for j in range(J)] -school = rx.Model(lambda x, mu, lt, *eta: mu + np.exp(lt) * np.asarray(eta), [mu, log_tau, *etas]) +school = rx.Model(lambda x, mu, lt, *eta: mu + jnp.exp(lt) * jnp.stack(eta), [mu, log_tau, *etas]) c_nc = rx.Constraint([rx.Comparison(d, school)]) # 3. centred: theta_j as parameters, hyperprior as a joint block including mu, tau (recipe 24) thetas = [rx.Parameter(f"theta_{j}") for j in range(J)] -c_c = rx.Constraint([rx.Comparison(d, rx.Model(lambda x, *th: np.asarray(th), thetas))]) +c_c = rx.Constraint([rx.Comparison(d, rx.Model(lambda x, *th: jnp.stack(th), thetas))]) problem_c = rx.Problem([c_c], priors=[(thetas + [mu, log_tau], SchoolHierarchy())]) ``` @@ -1113,7 +1332,7 @@ Expected behaviour: prediction-scaled `diag` term is expressible but is not the book's model. -The notebook `hierarchical_calibration` (design document §7) is the +The notebook `hierarchical_calibration` (design document §6) is the parameter-space version of this hierarchy: per-dataset deviation vectors on the physics parameters with a hyperprior on their spread, used to repair a misspecified energy dependence. @@ -1123,22 +1342,173 @@ Analysis*, 3rd ed., CRC Press (2013), Chapter 5. --- +## 39. Iterative outlier rejection + +*A few points are gross outliers. I want to reject them and refit, the way +KDUQ does, rather than widen every error bar to accommodate them.* + +```python +mask = np.ones(d.n, dtype=bool) +for _ in range(max_rounds): # an outer loop of problems + p = rx.Problem([c.masked([mask])]) + theta = map_estimate(p) # or a chain, and its posterior mean + pull = np.abs(d.y - p.constraints[0].ym(theta)) / d.y_err + keep = pull < 3.0 + if np.array_equal(keep, mask): + break # the mask has stopped moving + mask = keep +rejected = c.masked([mask]).complement() # what went, for the record +``` + +Expected behaviour: + +- Masks are compiled, so rejection is an *outer* loop: every round is a new + `Problem` over the same `Comparison`, `Term` and `Parameter` objects, and + the parameters keep their columns (recipe 11). A mask that moved inside + the chain would be mutable state inside a spec, which the design refuses + (*What this API does not express*). +- The loop either reaches a fixed point or cycles between two masks; cap the + rounds, and report which points went and after how many rounds. Given the + starting mask and a deterministic fit it is reproducible. +- Rejection and inflation are different answers to the same question. A + global error scale (recipe 34) or tempering (recipe 12) keeps every point + and widens; rejection commits to a subset and fits it tightly. Score them the same way, by holding out + (recipe 11) or by evidence (recipe 18), and note that the evidence of a + fit to a subset is not comparable with the evidence of a fit to all of it. +- Nothing is deleted: the rejected points stay in the declaration and + `complement()` names them, so a later round can take them back. + +Reference: Pruitt, Escher, Rahman, *Uncertainty-quantified phenomenological +optical potentials for single-nucleon scattering*, Phys. Rev. C 107, 014602 +(2023), [arXiv:2211.07741](https://arxiv.org/abs/2211.07741), which rejects +points more than $3\sigma$ from the current model between rounds. + +## 40. Predict on a new grid, error model included + +*I have a posterior, and I want predictions at `x` I never measured — a fine +plotting grid, an extrapolation — carrying the uncertainty my error model +declares, not only the spread of the model curves.* + +```python +log_sigma = rx.Parameter("log_sigma", prior=stats.norm(np.log(0.2), 1.0)) +c = rx.Constraint([comp], terms=[T.noise(log_sigma)], statistical=False) +problem = rx.Problem([c]) +pred = line.bind(x_fine) +model_band = rx.predictive.grid_draws(problem, pred, x_fine, samples, model_only=True) +full_band = rx.predictive.grid_draws(problem, pred, x_fine, samples, n_rep=2) +draws = rx.predictive.grid_draws(problem, pred, x_fine, samples, return_draws=True) +# several experiments in one constraint: say which one the grid stands for +band_a = rx.predictive.grid_draws(problem_ab, pred, x_fine, samples, comparison=comp_a) +``` + +Expected behaviour: + +- For each row the model is evaluated on the grid and every selected term is + re-evaluated there from its own definition, with the model's prediction + standing in for `c.y` and the predictor's `meta` for `c.meta`; one + correlated draw is taken from the sum. At the measured points with + every term a function, it draws from the same distribution as + `predictive_draws`. +- Any term that is a function of the `TermContext` travels: `noise`, + `proportional_error`, `normalization`/`offset`/`systematic` with + a parameter or a scalar magnitude, a `kernel`, a user's + `Term(fn, params, kind="matrix")`, and the normalisation mode + `reported_terms()` builds from a scalar `norm_err`. +- A term that is an array has no value at a new `x`: the reported + statistical errors (`statistical=True`), a fixed `Term(array)`, a per-point + `magnitude=`, a function closing over the measured rows. Drawing it would + invent the error of a measurement nobody made, so `grid_draws` raises and + names the term. The remedies are `predictive_draws` at the data, an + explicit `terms=[...]` (`model_only=True` for the model alone), or an error + model that is a function of `x`, as above. Interpolating reported errors is + a modelling choice, and is written as such a function. +- `model_only=True` and the default are different objects: the uncertainty of + the *curve* and the uncertainty of a *measurement* at that `x`. At the data + the first under-covers and the second is calibrated (recipe 17). A + discrepancy (recipe 7) is a third source, between the two. +- With several comparisons in the constraint, `terms=None` needs + `comparison=`: a term belonging to one experiment, drawn on a grid, means a + future measurement by that experiment. +- The band is the default return, `(len(levels), len(x_pred))`, as for + `predictive_draws` and `gp_predictive_draws`; `return_draws=True` gives the + draws, whole correlated curves, so a functional summary is well posed. + +## 41. Sample with gradients (HMC/NUTS) + +*My problem has many parameters, or a sampler that walks without gradients +mixes slowly on it. I want the No-U-Turn sampler, driven by the exact +gradient of the posterior.* + +```python +import blackjax, jax + +logdensity = problem.log_posterior_unconstrained # the posterior on R^ndim +z0 = problem.to_unconstrained(rx.optimize.find_map(problem, rng=0).x) # start at the MAP +warmup = blackjax.window_adaptation(blackjax.nuts, logdensity) +(state, tuned), _ = warmup.run(jax.random.key(0), z0, num_steps=1000) +step = jax.jit(blackjax.nuts(logdensity, **tuned).step) + +def one_step(state, key): + state, info = step(key, state) + return state, (state.position, info.is_divergent) + +_, (zs, divergent) = jax.lax.scan(one_step, state, jax.random.split(jax.random.key(1), 1000)) +samples = jax.vmap(problem.to_theta)(zs) # rows in problem.names order +``` + +Expected behaviour: + +- `log_posterior_unconstrained(z)` is `log_posterior(to_theta(z))` plus the + log-Jacobian of the map. A parameter's support is its bounds narrowed by + its prior's (a uniform or half-normal prior bounds it without `bounds=`); + with one finite end it is sampled as the log of its distance from it, with + two as the logit of its position between them, unbounded as itself. It is finite, with a + finite gradient, on all of `R^ndim`, so a trajectory never meets the + `-inf` wall `log_posterior` has at a bound, and `to_theta` maps every + draw back inside the bounds. +- The density is compiled once per problem; blackjax traces it once more + inside its own `jit`, and the gradient is the exact one through the + models, the covariance and the reaction solver. +- The chain is read back by name, like any other: `samples[:, + problem.columns(V)]`. Divergences are blackjax's `info.is_divergent`; + a few are a warning that the step size is too large for the geometry, many + are a funnel (a scale parameter near zero) the parametrisation should + remove. +- rxmc owns no sampler: this is blackjax's API, and numpyro's NUTS takes the + same density as `potential_fn=lambda z: -logdensity(z)`. Which sampler to + use is a question of the problem: NUTS for many parameters and a smooth, + unimodal posterior (a hierarchy, recipe 38, started from prior draws + rather than the MAP: a non-centred hierarchy's mode trades small + deviations for a large spread, away from the bulk of the posterior); + emcee for a few; pocomc for + an optical model, whose posterior is correlated and may have several + modes; dynesty or pocomc for the evidence (recipes 16, 18). + The notebook `gradient_based_sampling` compares NUTS and emcee, and the + [benchmarks](benchmarks.md) page every sampler on the same problems. + ## What this API does not express Each item names the assumption that breaks, the nearest workaround, and the size of the addition that would lift it. +- **Reported point-by-point errors at a new `x`.** A statistical error + quoted for each measured point has no value where nothing was measured, so + `grid_draws` refuses to carry it (recipe 40). Workaround: an error model + that is a function of `x` — inferred noise, or an interpolation of the + reported errors written as a `Term` of `c.x` — which is a modelling choice + the user makes explicitly. Addition refused by design: the library would be + inventing the error of a measurement nobody made. - **Non-elliptical likelihoods.** Poisson counts, censored points and upper - limits, and two-component good/bad mixtures `(1 − β) N + β t` (Hanson + limits, and two-component good/bad mixtures $(1 - \beta) \mathcal{N} + \beta t$ (Hanson 2007) are not functionals of `(d2, logdet, n)`. Workaround: none that is faithful. Addition: a `Likelihood` that receives the residual and the factor, plus a second evaluation path in `CompiledConstraint`; about 100 lines. - **Chain-dependent masks.** KDUQ's iterative rejection of points more - than 3σ from the current model, updated during the walk, needs a mask + than $3\sigma$ from the current model, updated during the walk, needs a mask that depends on chain state. Masks are compiled. Workaround: an outer - loop of problems with the mask refit between runs. Addition refused by - design: it is mutable state inside a spec. + loop of problems with the mask refit between runs, which is recipe 39. + Addition refused by design: it is mutable state inside a spec. - **Per-point latent variables.** Errors-in-variables in `x` (Berkson), explicit latent function values on a mesh (Schnabel et al. 2021), or a sampled per-point scale in a scale mixture. Expressible in principle as @@ -1151,11 +1521,11 @@ the size of the addition that would lift it. lines. - **Input-dependent mixture likelihoods.** Bayesian model mixing with a per-point two-component Gaussian likelihood (Semposki et al. 2022). Mean - mixing is a `Model` (`w(x; θ) f1 + (1 − w) f2`); the likelihood form is the first bullet. + mixing is a `Model` ($w(x; \alpha) f_1 + (1 - w) f_2$); the likelihood form is the first bullet. - **Correlation across constraints.** By construction. Merge the constraints. - **A sampled tempering exponent.** `weight` is a float by type; a - sampled `η` is not a coherent posterior. SafeBayes chooses it outside the + sampled $\eta$ is not a coherent posterior. SafeBayes chooses it outside the sampler (recipe 25). - **Nonlinear, non-pointwise comparison maps.** `space` is pointwise so the delta method and the log-Jacobian stay exact. A linear projection is diff --git a/examples/30s_optical_potential_calibration.ipynb b/examples/30s_optical_potential_calibration.ipynb deleted file mode 100644 index ddd5060..0000000 --- a/examples/30s_optical_potential_calibration.ipynb +++ /dev/null @@ -1,497 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "title", - "metadata": {}, - "source": [ - "# 30s optical potential calibration\n", - "\n", - "This notebook demonstrates a small end-to-end adaptive Metropolis calibration\n", - "of an elastic differential cross section model using **mock data** .\n" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "imports", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Using database version X4-2025-12-31 located in: /mnt/home/beyerkyl/x4db/unpack_exfor-2025/X4-2025-12-31\n" - ] - } - ], - "source": [ - "import corner\n", - "import jitr\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "from jitr.optical_potentials.potential_forms import (\n", - " thomas_safe,\n", - " woods_saxon_prime_safe,\n", - " woods_saxon_safe,\n", - ")\n", - "from scipy import stats\n", - "\n", - "import rxmc\n", - "from rxmc.params import Parameter" - ] - }, - { - "cell_type": "markdown", - "id": "model-heading", - "metadata": {}, - "source": [ - "## Reaction and optical model\n" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "model-setup", - "metadata": {}, - "outputs": [], - "source": [ - "Ca40 = (40, 20)\n", - "neutron = (1, 0)\n", - "E_lab = 14.1\n", - "\n", - "rxn = jitr.reactions.ElasticReaction(target=Ca40, projectile=neutron)\n", - "\n", - "mso = 1.0 / jitr.utils.constants.WAVENUMBER_PION\n", - "\n", - "\n", - "def central_potential(r, Vv, Wv, Rv, av, Wd, Rd, ad):\n", - " return -(Vv + 1j * Wv) * woods_saxon_safe(r, Rv, av) + (\n", - " 4j * ad * Wd\n", - " ) * woods_saxon_prime_safe(r, Rd, ad)\n", - "\n", - "\n", - "def spin_orbit_potential(r, Vso, Wso, Rso, aso):\n", - " return (Vso + 1j * Wso) * mso**2 * thomas_safe(r, Rso, aso)\n", - "\n", - "\n", - "R = 1.2 * 40 ** (1 / 3)\n", - "fixed_spin_orbit = (6.0, -3, R, 0.45)\n", - "\n", - "\n", - "def extract_params(ws, *x):\n", - " Vv, Wv, Rv, av, Wd, Rd, ad = x\n", - " central_params = (Vv, Wv, Rv, av, Wd, Rd, ad)\n", - " return central_params, fixed_spin_orbit\n", - "\n", - "\n", - "params = [\n", - " Parameter(\"Vv\", unit=\"MeV\"),\n", - " Parameter(\"Wv\", unit=\"MeV\"),\n", - " Parameter(\"Rv\", unit=\"fm\"),\n", - " Parameter(\"av\", unit=\"fm\"),\n", - " Parameter(\"Wd\", unit=\"MeV\"),\n", - " Parameter(\"Rd\", unit=\"fm\"),\n", - " Parameter(\"ad\", unit=\"fm\"),\n", - "]\n", - "\n", - "omp = rxmc.elastic_diffxs_model.ElasticDifferentialXSModel(\n", - " \"dXS/dA\",\n", - " interaction_central=central_potential,\n", - " interaction_spin_orbit=spin_orbit_potential,\n", - " calculate_interaction_from_params=extract_params,\n", - " params=params,\n", - " model_name=\"minimal_elastic_demo\",\n", - ")" - ] - }, - { - "cell_type": "markdown", - "id": "data-heading", - "metadata": {}, - "source": [ - "## Generate mock data and construct the observation directly\n", - "\n", - "The key API change demonstrated here is that we can create an\n", - "`ElasticDifferentialXSObservation` directly from arrays and metadata, without\n", - "building an `exfor_tools.Distribution` object first.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "mock-data", - "metadata": {}, - "outputs": [], - "source": [ - "angles_deg = np.linspace(2.0, 160.0, 28)\n", - "true_params = np.array(\n", - " [48.0, 3.5, 1.1 * 40 ** (1 / 3), 0.7, 21, 1.2 * 40 ** (1 / 3), 0.5]\n", - ")\n", - "\n", - "template_obs = rxmc.elastic_diffxs_observation.ElasticDifferentialXSObservation(\n", - " x=angles_deg,\n", - " y=np.ones_like(angles_deg, dtype=float),\n", - " Elab=E_lab,\n", - " reaction=rxn,\n", - " quantity=\"dXS/dA\",\n", - " measurement_quantity=\"dXS/dA\",\n", - " y_units=\"barn / steradian\",\n", - " dataset_label=\"template\",\n", - ")\n", - "\n", - "y_true = omp.evaluate(template_obs, *true_params)\n", - "\n", - "rng = np.random.default_rng(42)\n", - "y_stat_err = 0.2 * np.maximum(y_true, 1e-4)\n", - "y_mock = np.clip(y_true + rng.normal(scale=y_stat_err * 1.3), 1e-6, None)\n", - "\n", - "obs = rxmc.elastic_diffxs_observation.ElasticDifferentialXSObservation(\n", - " x=angles_deg,\n", - " y=y_mock,\n", - " Elab=E_lab,\n", - " reaction=rxn,\n", - " quantity=\"dXS/dA\",\n", - " measurement_quantity=\"dXS/dA\",\n", - " y_units=\"barn / steradian\",\n", - " y_stat_err=y_stat_err,\n", - " dataset_label=\"mock elastic dataset\",\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "3aefb01e-0a81-460d-8b2f-5965d57485e4", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 1.0, 'Mock differential cross section data for n + $^{40}$Ca')" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.errorbar(np.rad2deg(obs.x), obs.y, obs.y_stat_err, linestyle=\"none\", marker=\".\")\n", - "plt.xlabel(r\"$\\theta$ [deg]\")\n", - "plt.ylabel(r\"$d\\sigma/d\\Omega$ [mb/Sr]\")\n", - "plt.yscale(\"log\")\n", - "plt.title(\"Mock differential cross section data for n + $^{40}$Ca\")" - ] - }, - { - "cell_type": "markdown", - "id": "inference-heading", - "metadata": {}, - "source": [ - "## Set up the inference problem\n" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "run-inference", - "metadata": {}, - "outputs": [], - "source": [ - "constraint = rxmc.constraint.Constraint(\n", - " observations=[obs],\n", - " physical_model=omp,\n", - " likelihood=rxmc.likelihood_model.GaussianLikelihood(),\n", - ")\n", - "evidence = rxmc.evidence.Evidence(constraints=[constraint])\n", - "\n", - "prior_mean = np.array(\n", - " [50.0, 3, 1.2 * 40 ** (1 / 3), 0.65, 18, 1.2 * 40 ** (1 / 3), 0.65]\n", - ")\n", - "prior_cov = np.diag([7, 7, 0.2, 0.2, 10, 0.2, 0.2]) ** 2\n", - "prior = stats.multivariate_normal(mean=prior_mean, cov=prior_cov)\n", - "\n", - "walker = rxmc.walker.Walker(\n", - " model_sampler=rxmc.param_sampling.BatchedAdaptiveMetropolisSampler(\n", - " params=omp.params,\n", - " prior=prior,\n", - " starting_location=prior_mean,\n", - " initial_proposal_cov=prior_cov / 100,\n", - " ),\n", - " evidence=evidence,\n", - " rng=np.random.default_rng(7),\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "5c055e38-e74b-4840-ab72-8d8fe76f611d", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Burn-in batch 1/1 completed, 1000 steps.\n", - "Batch: 1/20 completed, 1000 steps. \n", - " Model parameter acceptance fraction: 0.172\n", - "Batch: 2/20 completed, 1000 steps. \n", - " Model parameter acceptance fraction: 0.181\n", - "Batch: 3/20 completed, 1000 steps. \n", - " Model parameter acceptance fraction: 0.199\n", - "Batch: 4/20 completed, 1000 steps. \n", - " Model parameter acceptance fraction: 0.202\n", - "Batch: 5/20 completed, 1000 steps. \n", - " Model parameter acceptance fraction: 0.212\n", - "Batch: 6/20 completed, 1000 steps. \n", - " Model parameter acceptance fraction: 0.269\n", - "Batch: 7/20 completed, 1000 steps. \n", - " Model parameter acceptance fraction: 0.250\n", - "Batch: 8/20 completed, 1000 steps. \n", - " Model parameter acceptance fraction: 0.210\n", - "Batch: 9/20 completed, 1000 steps. \n", - " Model parameter acceptance fraction: 0.203\n", - "Batch: 10/20 completed, 1000 steps. \n", - " Model parameter acceptance fraction: 0.181\n", - "Batch: 11/20 completed, 1000 steps. \n", - " Model parameter acceptance fraction: 0.225\n", - "Batch: 12/20 completed, 1000 steps. \n", - " Model parameter acceptance fraction: 0.220\n", - "Batch: 13/20 completed, 1000 steps. \n", - " Model parameter acceptance fraction: 0.172\n", - "Batch: 14/20 completed, 1000 steps. \n", - " Model parameter acceptance fraction: 0.243\n", - "Batch: 15/20 completed, 1000 steps. \n", - " Model parameter acceptance fraction: 0.147\n", - "Batch: 16/20 completed, 1000 steps. \n", - " Model parameter acceptance fraction: 0.222\n", - "Batch: 17/20 completed, 1000 steps. \n", - " Model parameter acceptance fraction: 0.211\n", - "Batch: 18/20 completed, 1000 steps. \n", - " Model parameter acceptance fraction: 0.161\n", - "Batch: 19/20 completed, 1000 steps. \n", - " Model parameter acceptance fraction: 0.218\n", - "Batch: 20/20 completed, 1000 steps. \n", - " Model parameter acceptance fraction: 0.209\n", - "CPU times: user 36.4 s, sys: 15 ms, total: 36.4 s\n", - "Wall time: 36.4 s\n" - ] - }, - { - "data": { - "text/plain": [ - "0.20535" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "%%time\n", - "walker.walk(n_steps=20000, burnin=1000, batch_size=1000, verbose=True)\n", - "samples = walker.model_sampler.chain[40:]\n", - "acceptance_fraction = walker.model_sampler.overall_acceptance_fraction()\n", - "acceptance_fraction" - ] - }, - { - "cell_type": "markdown", - "id": "summary-heading", - "metadata": {}, - "source": [ - "## Posterior summary and predictive band\n" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "posterior-summary", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Vv: truth=48.00 mean=43.94, std=2.62\n", - "Wv: truth=3.50 mean=4.73, std=2.03\n", - "Rv: truth=3.76 mean=3.93, std=0.15\n", - "av: truth=0.70 mean=0.64, std=0.05\n", - "Wd: truth=21.00 mean=18.74, std=2.93\n", - "Rd: truth=4.10 mean=4.10, std=0.08\n", - "ad: truth=0.50 mean=0.50, std=0.05\n" - ] - } - ], - "source": [ - "posterior_mean = np.mean(samples, axis=0)\n", - "posterior_std = np.std(samples, axis=0)\n", - "draw_indices = np.linspace(\n", - " 0, samples.shape[0] - 1, min(60, samples.shape[0]), dtype=int\n", - ")\n", - "posterior_draws = samples[draw_indices]\n", - "y_draws = np.array(\n", - " [omp.visualizable_model_prediction(obs, *draw) for draw in posterior_draws]\n", - ")\n", - "y_mean = np.mean(y_draws, axis=0)\n", - "y_low, y_high = np.percentile(y_draws, [5, 95], axis=0)\n", - "y_true = omp.visualizable_model_prediction(obs, *true_params)\n", - "for i in range(len(params)):\n", - " print(\n", - " f\"{params[i].name}: truth={true_params[i]:1.2f} mean={posterior_mean[i]:1.2f}, std={posterior_std[i]:1.2f}\"\n", - " )" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "f3bb6f33-2d53-49f2-af1f-7b729c8f33c8", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 0, '$i$')" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig, axes = plt.subplots(samples.shape[1] + 1, 1, figsize=(8, 8), sharex=True)\n", - "logp = walker.model_sampler.logp_chain\n", - "for i in range(samples.shape[1]):\n", - " axes[i].plot(samples[:, i])\n", - " axes[i].set_ylabel(f\"${omp.params[i].latex_name}$ [{omp.params[i].unit}]\")\n", - " true_value = true_params[i]\n", - " axes[i].hlines(true_value, 0, len(samples), \"r\", linestyle=\"--\")\n", - "axes[-1].plot(logp)\n", - "axes[-1].set_ylabel(r\"$\\log{\\mathcal{L}(\\alpha_i | \\mathcal{O})}$\")\n", - "\n", - "axes[-1].set_xlabel(r\"$i$\")" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "c7258dd0-20aa-4aaa-b1ce-2f1b217e8275", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABhYAAAYWCAYAAABP0ZNCAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3Xd43XXd//HnSXJOkpM2XemgI+xCkFHKkmUpS0QFxcGwCKLorYg3ggvn7f1TAQfugXiLo4qAIkMUZJS9qYJAoECBdNPTlTYnyTlJzu+PT07PSZpxspq2eT6u61xnfcfnnJPCdX1e38/7HclkMhkkSZIkSZIkSZIKUDTcA5AkSZIkSZIkSdsPgwVJkiRJkiRJklQwgwVJkiRJkiRJklQwgwVJkiRJkiRJklQwgwVJkiRJkiRJklQwgwVJkiRJkiRJklQwgwVJkiRJkiRJklSwkuEewI6ura2N5cuXM3r0aCKRyHAPR9qmZDIZNm7cyNSpUykqMueUJEmSJEmStgcGC0Ns+fLlzJgxY7iHIW3TlixZwvTp04d7GJIkSZIkSZIKYLAwxEaPHg2EidPKysphHs3I1JRq4czv3w3AtZ8+jrKYf/bbivr6embMmLH534kkSZIkSZKkbZ8zrEMsW/6osrLSYGGYxFItlJTFgfA7GCxseywTJkmSJEmSJG0/LGouSZIkSZIkSZIKZrAgSZIkSZIkSZIKZrAgSZIkSZIkSZIKZrAgSZIkSZIkSZIKZrAgSZIkSZIkSZIKZrAgSZIkSZIkSZIKZrAgSZIkSZIkSZIKZrAgSZIkSZIkSZIKZrAgSZIkSZIkSZIKZrAgSZIkSZIkSZIKZrAgSZIkSZIkSZIKZrAgSZIkSZIkSZIKZrAgSZIkSZIkSZIKZrAgSZIkSZIkSZIKVjLcA5B6UldXRyKR2Py8qqqK6urqYRyRJEmSJEmSJI1sBgvaZtXV1VFTU0Mymdz8Wjwep7a21nBBkiRJkiRJkoaJpZC0zUokEiSTSebPn89TTz3F/PnzSSaTHVYwSJIkSZIkSZK2LlcsaJtXU1PD7Nmzh3sYkiRJkiRJkiRcsSBJkiRJkiRJkvrAYEGSJEmSJEmSJBXMYEGSJEmSJEmSJBXMYEGSJEmSJEmSJBXM5s3a7tTW1gJQVVVFdXX1MI9GkiRJkiRJkkYWgwVtN6qqqojH48ybNw+AeDxObW2t4YIkSZIkSZIkbUUGC9qm1NXVkUgkgNzKhKzq6mpqa2tJJBLU1tYyb948EomEwYIkSZIkSZIkbUUGC9pm1NXVUVNTQzKZ3PxaPB6nqqpq8/Pq6mqDBEmSJEmSJEkaRgYL2mYkEgmSySTz58+npqYGsI+CJEmSJEmSJG1rDBa0zampqWH27NnDPQxJkiRJkiRJUheKhnsAkiRJkiRJkiRp+2GwIEmSJEmSJEmSCmawIEmSJEmSJEmSCmawIEmSJEmSJEmSCmawIEmSJEmSJEmSCmawIEmSJEmSJEmSCmawIEmSJEmSJEmSCmawIEmSJEmSJEmSCmawIEmSJEmSJEmSCmawIEmSJEmSJEmSCmawIEmSJEmSJEmSCmawIEmSJEmSJEmSCmawIEmSJEmSJEmSCmawIEmSJEmSJEmSClYy3AOQBqK2tnbz46qqKqqrq4dxNJIkSZIkSZK04zNY0HapqqqKeDzOvHnzNr8Wj8epra01XJAkSZIkSZKkIWSwoO1SdXU1tbW1JBIJIKxcmDdvHolEwmBBkiRJkiRJkoaQwYK2W9XV1YYIkiRJkiRJkrSV2bxZkiRJkiRJkiQVzGBBkiRJkiRJkiQVzGBBkiRJkiRJkiQVzGBBkiRJkiRJkiQVzGBBkiRJkiRJkiQVzGBBkiRJkiRJkiQVzGBBkiRJkiRJkiQVzGBBkiRJkiRJkiQVzGBBkiRJkiRJkiQVzGBBkiRJkiRJkiQVzGBBkiRJkiRJkiQVzGBBkiRJkiRJkiQVzGBBkiRJkiRJkiQVzGBBkiRJkiRJkiQVzGBBkiRJkiRJkiQVzGBBkiRJkiRJkiQVzGBBkiRJkiRJkiQVzGBBkiRJkiRJkiQVzGBBkiRJkiRJkiQVzGBBkiRJkiRJkiQVzGBBkiRJkiRJkiQVzGBBkiRJkiRJkiQVzGBBkiRJkiRJkiQVzGBBkiRJkiRJkiQVzGBBkiRJkiRJkiQVzGBBkiRJkiRJkiQVzGBBkiRJkiRJkiQVzGBBkiRJkiRJkiQVzGBBkiRJkiRJkiQVzGBBkiRJkiRJkiQVzGBBkiRJkiRJkiQVzGBBkiRJkiRJkiQVzGBBkiRJkiRJkiQVzGBBkiRJkiRJkiQVzGBBkiRJkiRJkiQVzGBBkiRJkiRJkiQVzGBBkiRJkiRJkiQVzGBBkiRJkiRJkiQVzGBBkiRJkiRJkiQVzGBBkiRJkiRJkiQVzGBBkiRJkiRJkiQVzGBBkiRJkiRJkiQVrGS4ByDV1dWRSCSora0d7qFIkiRJkiRJknphsKBhVVdXR01NDclkEoB4PE5VVdUwj0qSJEmSJEmS1B2DBQ2rRCJBMplk/vz51NTUUFVVRXV19XAPS5IkSZIkSZLUDYMFbRNqamqYPXv2cA9DkiRJkiRJktQLmzdLkiRJkiRJkqSCGSxIkiRJkiRJkqSCGSxIkiRJkiRJkqSC2WNBO5Ta2loAm0BLkiRJkiRJ0hAxWNAOoaqqing8zrx58wCIx+PU1tYaLkiSJEmSJEnSILMUknYI1dXV1NbW8tRTTzF//nySySSJRGK4hyVJkiRJkiRJOxxXLGiHUV1d7QoFSZIkSZIkSRpirliQJEmSJEmSJEkFM1iQJEmSJEmSJEkFM1iQJEmSJEmSJEkFM1iQJEmSJEmSJEkFM1iQJEmSJEmSJEkFM1iQJEmSJEmSJEkFM1iQJEmSJEmSJEkFM1iQJEmSJEmSJEkFM1iQJEmSJEmSJEkFM1iQJEmSJEmSJEkFM1iQJEmSJEmSJEkFM1iQJEmSJEmSJEkFM1iQJEmSJEmSJEkFM1iQJEmSJEmSJEkFM1iQJEmSJEmSJEkFM1iQJEmSJEmSJEkFM1iQJEmSJEmSJEkFKxnuAWjkqaurI5FIAFBbWzvMo5EkSZIkSZIk9YXBgraquro6ampqSCaTm1+Lx+NUVVUN46gkSZIkSZIkSYUyWNBWlUgkSCaTzJ8/n5qaGgCqqqqorq4e5pFJkiRJkiRJkgphsKBhUVNTw+zZs4d7GJIkSZIkSZKkPrJ5syRJkiRJkiRJKpjBgiRJkiRJkiRJKpjBgiRJkiRJkiRJKpjBgiRJkiRJkiRJKpjBgiRJkiRJkiRJKpjBgiRJkiRJkiRJKljJcA9AGiq1tbUApFrahnkkkiRJkiRJkrTjMFjQDqeqqop4PM68efMAKI6WctxX/jLMo5IkSZIkSZKkHYPBgnY41dXV1NbWkkgkAHjmuVqufW14xyRJkiRJkiRJOwqDBe2Qqqurqa6uBtpLIb22aphHJEmSJEmSJEk7Bps3S5IkSZIkSZKkghksSJIkSZIkSZKkghksSJIkSZIkSZKkghksSJIkSZIkSZKkghksSJIkSZIkSZKkghksSJIkSZIkSZKkghksSJIkSZIkSZKkghksSJIkSZIkSZKkghksSJIkSZIkSZKkghksSJIkSZIkSZKkghksSJIkSZIkSZKkghksSJIkSZIkSZKkghksSJIkSZIkSZKkghksSJIkSZIkSZKkghksSJIkSZIkSZKkghksSJIkSZIkSZKkgpUM9wCkrenf//43sZIiqqqqqK6uHu7hSJIkSZIkSdJ2x2BBO7wJE6qAVQAcddRRtKabicfj1NbWGi5IkiRJkiRJUh9ZCkk7vBkzpm9+/OCDDzJ//nySySSJRGIYRyVJkiRJkiRJ2ydXLGhEmTVrFrES8zRJkiRJkiRJ6i+DBY040eQqDpxSRPn6RbC8h5AhPgHGzth6A5MkSZIkSZKk7YDBgkaWDUvZZ8G5LPzYKLj/Y3B/D9tG43DB44YLkiRJkiRJkpTHYEEjSqRxDcWtTXzgxiRf/sHvqdl77643TCyCG8+H5BqDBUmSJEmSJEnKY7CgEal2dRuNY2fC1Fk9b5hY1PvBLJkkSZIkSZIkaQQxWNCOY/2SsMKgk0hLK3tkXg2PE/WFHSs+IZRCuvH83re1ZJIkSZIkSZKkEcRgQTuG9Uvgp4dCOrnFW6XAT7NPboHW4jISyY09H2/sjBAWdBFUdGDJJEmSJEmSJEkjjMGCdgzJNSFUOO1qqJrZ4a3mllYu/s0jAFx57uEsqnuDJV89ufdjjp1hWCBJkiRJkiRJnRgsaKuoq6sjkUhQW1s7tCeq2rJvQibVwsuRleHxlANIJ54Z2jFIkiRJkiRJ0g7MYEFDrq6ujpqaGpLJUKYoHo9TVVU1zKOSJEmSJEmSJPWHwYKGXCKRIJlMMn/+fGpqaqiqqqK6unq4hzW4Eot63yY+wdJKkiRJkiRJkrZ7Bgvaampqapg9e3bfd1y/pLAmysMhPgGi8dDAuTfReGgIbbggSZIkSZIkaTtmsKBt2/ol8NNDQ2Pm3kTjYaJ/axo7I4QFhQQfN54ftjNYkCRJkiRJkrQdM1jQti25JoQKp10dGjP3ZLhKDY2dYVggSZIkSZIkacQwWND2oWomTJ013KOQJEmSJEmSpBGvaLgHIEmSJEmSJEmSth8GC5IkSZIkSZIkqWAGC5IkSZIkSZIkqWAGC5IkSZIkSZIkqWA2b9aIVVtbC0BVVRXV1dXDPBpJkiRJkiRJ2j4YLGjEqaqqIh6PM2/ePADi8Ti1tbWGC5IkSZIkSZJUAEshacSprq6mtraWp556ivnz55NMJkkkEsM9LEmSJEmSJEnaLrhiQSNSdXW1KxQkSZIkSZIkqR8MFqStKbGo923iE2DsjKEfiyRJkiRJkiT1g8GChkRdXd3m8kLZJslbWL8Ekmt6PlAhE/Hbg/gEiMbhxvN73zYahwseN1yQJEmSJEmStE0yWNCgq6uro6amhmQyufm1eDxOVVVVbqP1S+Cnh0I62cUROonGw8T89mzsjBAWFBKk3Hh+2M5gQZIkSZIkSdI2yGBBgy6RSJBMJpk/fz41NTUAVFVVdexpkFwTQoXTroaqmT0fcEcpDTR2xo7xOSRJkiRJkiSNaAYLGjI1NTXMnj27542qZsLUWVtlPJIkSZIkSZKkgSsa7gFIkiRJkiRJkqTth8GCJEmSJEmSJEkqmMGCJEmSJEmSJEkqmMGCJEmSJEmSJEkqmM2bJaC2tnbz46qqKqqrq4dxNEBiUe/bxCfA2BlDPxZJkiRJkiRJymOwoBGtqqqKeDzOvHnzNr8Wj8epra0dnnAhPgGicbjx/N63jcbhgscNFyRJkiRJkiRtVQYLGnTR5CoOnFJE+fpFsLybaluFXJG/FVRXV1NbW0sikQDCyoV58+aRSCSGJ1gYOyOEBck1PW+XWBTCh+QagwVJkiRJkiRJW5XBggbX+iXss+BcFn5sFNz/Mbi/h22j8XCF/jCrrq4e/tJH+cbOMCyQJEmSJEmStM0yWNDgSq6huLWJD9yY5Ms/+D01e+/d/bb2CJAkSZIkSZKk7Y7BgoZE7eo2GsfOhKmzhnsokiRJkiRJkqRB1E0BfEmSJEmSJEmSpC25YkHanhXSBNuSU5IkSZIkSZIGkcGCCrd+CSTX9LxNIRPd24Ha2loAqqqqtq3GzlnxCaH59Y3n975tNA4XPG64IEmSJEmSJGlQGCyoMOuXwE8PhXSy101bIjESycxWGNTgq6qqIh6PM2/ePADi8Ti1tbXbXrgwdkYICwoJem48P2xnsCBJkiRJkiRpEBgsqDDJNSFUOO1qqJrZ4a0VK1fy3ve8h8amJgASyQxrWsqpqqoajpEOSHV1NbW1tSQSCWpra5k3bx6JRGLbCxYgBAWGBZIkSZIkSZK2MoMF9U3VTJg6q8NLK1Yu5OHXksyfP5+ampqw2bZaQqgA1dXV2+3Yu2UvBkmSJEmSJEmDxGBBg9Y7oaamhtmzZw/SoDQo7MUgSZIkSZIkaZAZLIx0feidQDQeJqrb1dXVbS4ZpG1UX3sx1D3S+7aubJAkSZIkSZJGNIOFHVmhKxG66Z2whbwJ5bq6OmpqakgmQyARj8e3y54KhegpONkuSj4V0ovBlQ2SJEmSJEmSCmSwMMQymQwA9S89AqMqtt6Jk2vgxo9CS2Pv25aUw9h9YdT0HjdbuXIlK5+5H4AXX3yRZDLJL3/5S/baay8mTJjA2LFjqa+vH4zRD6qmVAstTSEAqa+vJxUr7M++tLSU8vJy5s2b1+025eXlzJ8/n6qqKqZMmcKUKVMGZcxbXdEYOPtuaFzb83ZrXoZbPwXP3w0T9hjwaes3NQC5fyeSJEmSJEmStn2RjDN6Q2rp0qXMmOGV3VJPlixZwvTpPQdbkiRJkiRJkrYNBgtDrK2tjeXLlzN69GgikchWPXd9fT0zZsxgyZIlVFZWbtVzbw078ufbkT8b5D5fXV0dkUiEqVOnUlRUNNzDkiRJkiRJklQASyENsaKiomG/EruysnKHnJzO2pE/34782QDGjBmzQ38+SZIkSZIkaUfkJcKSJEmSJEmSJKlgBguSJEmSJEmSJKlgBgs7sNLSUr72ta9RWlo63EMZEjvy59uRPxvs+J9PkiRJkiRJ2pHZvFmSJEmSJEmSJBXMFQuSJEmSJEmSJKlgBguSJEmSJEmSJKlgJcM9gB1dW1sby5cvZ/To0UQikeEejrRNyWQybNy4kalTp1JU1H3O6b8jqXuF/juSJEmSJEkaLAYLQ2z58uXMmDFjuIchbdOWLFnC9OnTu33ff0dS73r7dyRJkiRJkjRYDBaG2OjRo4Ew4VNZWTnMo9nBde5Dnk5CqpEmYpz500cAuPaiYymLFfhn374/sXKIxrvfzivo+62+vp4ZM2Zs/nfSHf8dbTuaUi2c+f27Abj208cV/u9JQ6bQf0eSJEmSJEmDxRmhIZYt21JZWemE6FDrHCwQvu9YqoWSshAMVFZWFj4R2pAKoUJRCVT08NsZLAxYb+WN/He07ej3vycNOcuESZIkSZKkrcVizFJ3YvEQKsR6WK0gSZIkSZIkSSOMl5pK3YnGey6BJEmSJEmSJEkjkCsWJEmSJEmSJElSwQwWJAiNmhsS4V6SJEmSJEmS1C2DBQkglYS2lnAvSZIkSZIkSeqWwYIENmqWJEmSJEmSpALZvFkCGzVLkiRJkiRJUoEMFjR8MpnBPV4k0vvrkUj32/VXoZ9jsM8rSZIkSZIkScPAUkiSJEmSJEmSJKlgBguSJEmSJEmSJKlgBguSJEmSJEmSJKlgBguSJEmSJEmSJKlgBguSJEmSJEmSJKlgBgva9qST0JAI9zuC7OdJNQz3SCRJkiRJkiRpwEqGewDSFlJJaGsJ99F4mJhPJSEWD8+3N/mfJ1Yx3KORhkRdXR2JRAKAqqoqqqurh3lEkiRJkiRJGioGC9r2xOK5IAG2DBq2N50/j7SDqauro6amhmQyrDKKx+PU1tYaLkiSJEmSJO2gLIWkbU80DhVVuRAhFoeiku13Yj77eVytoB1UIpEgmUwyf/585s+fTzKZ3Lx6QZIkSZIkSTseVyxo29ZbGaRCyiRlMh0f5z/fmobrvJHI8JxXI05NTc1wD0GSJEmSJElbgSsWtG3LL4PUn/clSZIkSZIkSYPKYEHbtt7KIG3vZZIkSZIkSZIkaTtjKSRt26I9lDgq5P2hUEj5peE4liRJkiRJkiRtBa5YkPpqoOWX0kloSORCBUs5SZIkSZIkSdqOGCxIfTXQ8kv5YcJglHLKDyokSZIkSZIkaYhZCkk7vnTj4B5voOWXYvGO5Y8GWgIpP6iwnJIkSZIkSZKkIWawoG3HUPUbGOor+fs67sHuC5EfVEhb0ZIlS9m4YS21tbXDPRRJkiRJkiRtRQYL2nb058r7Qib1u3t9sIKM4V4xMBwNrCVg9kGz2bRhHQDxeJyqqioSicQwj0qSJEmSJElDzWBB247+XHlfyKR+tHzL19JJWLcESqLt2wxSaaP+6EvAMVSrOqR+aEwmmT9/PjU1NVRVVVFdXW2wIEmSJEmSNAIYLKhwmUxh20Ui/Tt+f66878+kfiQS9imJQksaRse7HnPzptCfIVo+tGWG+rLioUPj54rCjj/Uv5tGtJqaGmbPnj3cw5AkSZIkSdJWVDTcA9B2Lp2EhsTQ9DEo5NjReC5c6MsYYnEorYRxM7qfoE83QvNGWL8sHL87+ZP9/RGLQ1FJYeFFX7aVJEmSJEmSpCHgigUNzFD2F+jt2NmyQKkklMT6NoZYRe9X/EfLoWFtWNmQbux+Mn+gpZD6slLDfgqSJEmSJEmShpnBggrXVX3/gU6q96S3Y2eDhwiFX8WfboTSaOHnHzstVw6pO4VO9mdXYGSAUVXDHxDYr0GSJEmSJElSPxgsqHBdrSDIn1TPn6gutP5/T3qbsM8GD2WVhU+Mp5NAZeFjiMUHLzRJJUNpJYDUNjCZP5SrTSRJkiRJkiTtsAwWVLjuVhB0VZJoMIKF3mQnw7O9DQqZHC90Aj3V0D7h3qlxcyrZ/4bOsTiUjg4rFnrbd2usJhjK1SaSJEmSJEmSdlgGCypcdysI+lOSaLD09ar7nkoadXXczr0V0o1dv95ZV8FANA5jq/t2/qFcTWC/BkmSJEmSJEn9UDTcA9AOIBYPgUJFVbhtjdUKnc8di+d6GKSTHR/397gtqVxAkBUt7/r1zrLBQEOif+PI/1ySJEmSJEmStA1xxYIGbjiufM9fEVBRFV5rSOSu8k8nYeNqKC6GMbv3/fixCojlrVqAvPsmKInmVi301NS6JdW/lQddfac2W5YkSZIkSZK0DXDFgrYNnVcY9Lb6IL9UUFb+Vf4ZoK0Z2lr7v2ohWh6OFy3PlUBqWBtChZZ0rqxSV2OJtgceo6p6XnnQl5UVXZ1HkiRJkiRJkrYyVywIMplhOl7edh16CpRvOYme/x7kJvuj5bnjRMvDubNX9VdOh5bG3EoDgPVLYezELcs1pRrymjK3vxer6LhduhEqxofHo/K366EJcm+rOQrppZBfdqk/5ZEikb5tL0mSJEmSJEk9MFhQ17Z22Z0OQUEXz/MfQxhXVxPs2ZUFRSUwbgY0rIHm5tz7yQSQgrHTOoYGDWsgtQlio3ruEZEfPGx+bQDfUU+hRFY2fMj2sZAkSZIkSZKkYWSwoK4VciX9QGSDi2h5LiTIn1zv6nkhouWQXBN6G0TL2wOK1tz7kZK8/gjtAUGqAZrWhbJJpaO6GW9jrt9Cf5pTdxXUFBreFBI+SJIkSZIkSdJWYo8FdS2/X8FgyvYU2JTo2Bi5s1SyfRVBH/sJZCfpS2K55srx8bn3J+wGpaM7rn5IN0JpJURHQXxC18fN77fQ22frql9CV/0RCu2ZkO3XAIX3Y5AkSZIkSZKkIeKKBXVtIOV9epKdTI8QVhVEUtCQPWd5LsjosEKgD+NItTd7zgAVo8Pz5Kbc+7FyiFV23CcbFozqoszR5v0qcuPKf97VZ+tqlUdXqw76uhJhqFeRSJIkSZIkSVIBDBa0dWUn08sqcxPlDWuhvLJjiNC5x0JWKrll74Ws7D7Fsdxqi4Y14Ryb92+EWLTTmAoIDbLv55dDyjZ8zq6S6GsT576GN5ZEkiRJkiRJkrQNMFjQ4Oupd0D+ZHomEybmK9pLFfVUZigruSaUA4oUQ3xcCBHW1kGmNZQxGjutiybQeT0WWhqByi2P21MPhWyAALlySKkGWL8s9GvI/1xDuZJgqI8vSZIkSZIkSQUwWNDAdQ4SNiUgtQlio2Bcde/755dA2nzMxo49GLL3yfXQuAHKx4RyR0Xtf8KZlvaeDPWwvg7WLYbVL0JxKcVTD2ZqppXlTIGS8lxQ0HnVQ3c9FLJjKSoJvQ6yoUKmBVqA0fHcd5DVW0NmSZIkSZIkSdpOGSxo4DrX/o+0vx7ptF3nAKKnPgr5pZCy2zXWQ9noMKGfaoB1r4UAYcUzsPoFWPc6tDZvMbzov+dzDbCWMURvewtMnQVTD4RJb4Ki4o6hwebP1JArq9S8Eda/Dk0bIFIUXm9NQ+komFQDrSlINwOZXOjR1z4IPa3ykCRJkiRJkqRtiMGCgv5MbOdfpZ/taQBhgj7bcyBf5wAiPzzoqndC52bOFeMhuRZuuQDeqO16TCVlUDUTJu0NVXtBahNtrz1My9KnGM8GeOHWcINQ8mjaITBtNlRODcfetAo2roANS8PjhkQos1SIkvbmz7EKmLwvHPMFmLJfYfvamFmSJEmSJEnSdsJgQRCJdJzY7q55cSbT8Xl2n2yokA0ZouV5JYXy9unQkLnTsTqXPspfyVAcDbfWFNz6yRAqFJfCxJkhRJi4N0zcCybsAWNmhFUI+cN8cyvvvfJu9mIxlx/RRHT5k7DsibAS4dV7w63nLwgqJsLoyeG8qU3tt4ZwjGxz6JbGcEsmwgqHF2+DmlPg6M/AhN0hWtb9KTKZsCIjPq6XsTD8qxsinZeidKPz30t/t5EkSZIkSZK0TTFYUJANBjqvMih0nw5X3HfRpyB/RUL+KoRsgNAhdKDjYwiT+Ld9BpY8DqWj4dy/hzAhX3aCvwvpSIxn2ZvWNx9NtDQGba0hoFjyKCx5LBx/1GQYPQVGTQkhwqhJ4bWKibleDp1lMiFMSDVAc3vg0LQe/vUHqL0Zam+BF26D/d8fVjCMmd7991k2upvBdwoS+rK6YbhDCO1wlixZOtxDkCRJkiRJ0jAzWFCQLeHTF9FOk9VdBRPZQCGVhJLYlv0UNr4RyheNnQYVE/LG0+k4j/0CnvtL6HHw7l9uGSr0VVExTNk33A75SNfbZNp6P04kEsZfUgbxvPHvfCQc/gm4/zvw8l3w9LXw7F9gn3fBYR+Hqj3DdtkApXOwkpVOwhuLQjmmiomhGXZfQiBLLGkQ1dXVMfug2Rxxye8BKI/Hqaqq6mUvSZIkSZIk7WiKhnsA2s6lk6EPAeR6K6SS0LAmFyq0tYRGzkUlW06cF5eEZszZEkhdeenOMEEPcPzXYY/jhuSjDLrJ+8L7fgtn3ww7HxFKOf3nevjt2+Geb8DGlXkln8pDDwkI32e6vaxUKhlChdbmXDPsaDz3XefL/hbZfSGED/n9L6QBSCQSNCZzf18Ln1pIdXX1MI5IkiRJkiRJw8FgQQOTf0V8VucSR0Ul4Wr+igkdJ7ij5RAbBaWjcg2cs4FE1oal8NePhdUDs+bBoR/dep9tsEw/GM66AebdCNMOChP/j/8CfvdOaFjdMWzJfnf530GkuP376+XK8K5+i+5CCGkQzJjRQ2kvSZIkSZIk7bAshZTnxRdfJJFIcOSRR/b7GM3NzTQ3N29+Xl9fPxhD23Z1VZYnW9YHtuyr0Hnf/NfXLQk9CmKjcq/f883w2rSD4G2XF944eFu02xzY9S2w6Hb4+2dg4wp49QEYvxs0rM2VRGpp6vi9VE5pX+3RSzjQnz4ZkiRJkiRJktRHrlho9+9//5vZs2ezcOHCAR3nsssuY8yYMZtvM2bMGKQRbqO6uiI+Fs/1S2jrpcxRvkin+9UvhtJBACf8PyiODcaIh1ckAnu9DfZ7X3i+7ElIroXk6nAfK+/4ffallFFfSiT15f3+GqrjSpIkSZIkSRpWBgvA008/zZFHHsnHP/5xLrzwwgEd69JLL2XDhg2bb0uWLBmkUW5nUslwa01t2VehO/EJMGpSrgnygm+GEkh7vS2UE9qR7HxUuF/yGDSuC4+7WowxGKWMuiqR1Jf3h+q8kiRJkiRJkrZLI74U0ksvvcRhhx3GZz7zGb7xjW+QTqf529/+xrJly5g4cSJz585l0qRJBR+vtLSU0tLSIRzxdiLdCCWxrq+2TyUhuQYy5FY2ZEsmVUwI7798D9TeCpEiOObSrT78IVd9GBRFYeNyWLsYph8Uvo9UY+g50V/pZK4cUv6qh55KJBVSQin/uLGKwsZiaSZJkiRJkiRphzSig4WWlhZ+8pOfMGrUKGbNmgXAqaeeyvLly2loaOD111/npJNO4uKLL+aYY44Z1rFud6LloRFzJAWp8twkc7oxTFI3bwrbZSedsyWTYvFw/8B3w+sHnAET9x6ezzCUSkfDzBPhhdvgtQdhl6Ny38FAgoX8VQLZYCEa73nFQ2/vdz5uocFCIceVJEmSJEmStN0Z0cFCSUkJn/zkJ2lqauJ73/seF198Mfvvvz/XX389u+++O7W1tZxxxhn85Cc/2bGDhUym69e3uPq9m+22OF4bRMtCuNDWEgKGbKhQHA2HKR0V7kvK2s/VGB5n2mDpE1D3SOip8JbPQfPGws7bmurmc7TmHjdvAApcUdLSVNh2kQIripV0Wvmy/xkhWHjhFjj2i5BKtQcxDQVe5d9F7aShWiWQf9zu/l4kSZIkSZIkjQgjssdCa2tuonnPPffkc5/7HHvuuScHHHAA3//+95k5cybFxcXsu+++/PCHP+TGG2/kP//5zzCOeJgUUiM/lcwFB51Fy0MppAiQ2ghN66A1DfHxMGYajJ0WtkuuhZb2Bs+ZDNx3eXh88Hkwdgdufr3HcRCvgobVIUiJloXgJd3Y8/fak0J6MvSnqfJg9HqQJEmSJEmStEMYcSsWFi1axK233spZZ53FTjvtBMDuu+/ON77xDWpra9lll10AyLRfld3U1MTMmTOZPHnycA15+BRUe7+xYxmjbNPmaDnE2m+pRtiwHNpaYe3rkG6CMVPDe+lGSLeXRSoph5fvhBVPh3I7R31663zO3qQbYfG9sOh22LQKSkqhuDTcl5Tl7otjuec7HQA7H9HzcYujsN974bFfwFO/g2mHQKQ4fHedv9fB1FW5pM2ftYseDZIkSZIkSZKUZ0QFCy+//DKHH34469atY82aNVx88cVUVVUBUF1dzYwZM4hEQnmZ7P3999/P9OnTR2ZD5t5q5KeSYSI6A1SMDq91mBAvD6/FykOQsOp5aEtD4xqIj8u939LSPjEfhQXfCK+9+YJwhfxAZNr6v29rGl59AF78O7xyd/g8fREpgrOuh0k1PW93wBkhWFi8ABrXQtUe0JLa8nvNypaUipZDJNK/EKCnwKin0EGSJEmSJEmSGEHBQkNDA5dddhmnnHIKBx98MBdeeCEtLS187nOf2xwu5Hv22Wf505/+xC9+8QsefPBBxowZMwyj3kak81ch5E02pxvDVfpFJXnNmdsnxEs7TYjHymH0FEi/3h5YlOfeGzUxHOPRn8GaVyA+AQ7/eN/GmMnAhqWw8hlY+Sys/A+8EYKM2Jhqvto6jqWRnSh+/mWYNBPG7QLl48PkfFZTPbx2P7xyD7x6PzRtyL03ZjrsdTJM2S+EDi1N0NIMrc0hCNj8uCmsuFj5H7jra/D++VAS637ck98UjrnyP3DvZfD27wGRjt9rh98iL7iB/oUAPQVGQ9WjQZIkSZIkSdIOY8QEC0VFRRx00EFMmDCB008/nYkTJ3LGGWcAbA4XsqsUXnvtNT772c+yaNEi7rvvPvbbb7/hHPrwyQYKqWSYHO9clidbsicbEmSDhpZUbuI7Vt5x+4l7tE+Yl3c8xhNXw/3fDq/N/SKUVvY8toZECBFWPAMr2yfyG9d1uWnR2lc4EkLgcfetuTdKK2H8rjBuV9i4EpY9GSbqs8rHw8y3hkBhpwM6hhD5Ojdv3vQG/O5UWPUc3PP/4IT/7X5fgMM/CX/9GNTeAomX4J0/hNKxUDF+y23zv/NIBDYlQsPn9Da8wsDySpIkSZIkSdIOZcQEC+Xl5ZxzzjlUVFQA8P73v59MJsOZZ55JJpPhC1/4AhMmTKC1tZWKigp+/vOfU1RURHV19TCPfBhly+JECGFAtLxjKZ5YvOugIZLashxS9v3GteGK/4a1udcWXpMXKnwJDjq3+zE1JODmT8Cyp7Z8rygKE/eCKfvClP1h8r4QLSe1ejG/uvUhprOCt0/fRPH612HjcmiuD6sLVjydO8b43WH3ubD7saGMUVE//omMmgQnfwdu+jg8dyNM2htmfaD77fc9DWKj4NZPwepa+P27wvew3/vD++uWQP0KqNwJxs3I+84j4fFgli7qbymknsIDyytJkiRJkiRJO5QREywAm0OF1tZWioqKOP3008lkMpx11llEIhEuuugivvvd7/Lqq69y7bXXUlZWNswj3so6Tw5ny+KUVbZPCGegYc2WzZo7Bw3NZR1XMkBo4JxuDPe0htUFoybBA9+Dh74ftpn7JTj64u7Ht3ElXH82rF0MRGDC7iFAmLI/7LR/CAW6KDvUFt+Jm4tCaaYT37U/xaWlYSzrX4e1r8K610Kz6N3mwNidczu2NPX/u9zlqNB8+oHvwb1XwIQ9oeYd3W8/80T46L1w0yfgtQfgn1+CJY/DKT8MoUJrY7gfN6Pjfl2VLhrICoH+lkLqKTywvJIkSZIkSZK0QxlRwUJWcXExmUyGtrY2zjjjDCKRCGeffTa33HILr7zyCo8//vjICxVgy8nhrmrxd1X+qHljWIEwdlp7uFDecaVCdru2FmhaD7SxZsNGIvf9jPGLrgvv9xYqbFgK150NG+pg9E7w/t+HMkb5WlOFf9ZoOUzcO9yGykEfgjdqQwPo2y4O5ZTGzuh++9FT4AM3hF4T93wTam+GFf+CE74JFZPCioUtPkcPKwQ2JXJhT6EBQ28Nu7vTU3jQ32NKkiRJkiRJ2iYV9b7JjikSiRCJRMhkMpx++ukcffTRrF69moULF3LggQcO9/CGRyzedcPgzttUTMhtEy2HljSURNtXJCRDyJBq7LhftBza0qHJcbqJoqf/WHiosPZVuPb0ECqMqYYzr9syVNgWRSKhv8KkmrBC44ZzwmqCnhQVh5UO5/0DxlbD+jr487nw6oItVyt0J/s7RsgFRUMtGoeKKgMEbVZbW8vChQupq6sb7qFIkiRJkiRpkI3IFQtZkUiE1tZWPvvZz7JgwQL+/e9/bx+NmjOZoTluV1eW55fVKeliFUe0HMZODWFCuj1UoCX0DIhNax9uBqJlkC6H0lGw8LeMe+WmsP/RF8PBH+q28TKrF8F1Hwjvj6mGky4L50m8tOW2xdGuj5HO+77qV0JJgd9fbyFAVm+T6XO/DDdfEBpM3/QJePuVPTdzLhsLO82Cj9wDf/8MPH8T3Hc5xMd37D9RvGXZp83jicYh1ZC3uqSHz5wtZ1Xoyoaext5Xg3ksbROqqqqIx+PMmzcPgHg8Tm1t7cjuVyNJkiRJkrSDGbErFvK96U1vYuHChey///7DPZRtT7aszvo6WP1y6LHQWTQeJq+Lo7m+BN3MYz937VeILPxteHL0xfDmT3R/7pXP5kKF8bvByd+G+ISBfZ7hMGoSHPuVsIrghdvgiV8Vtl9ZJbz7KnjLZ8Pz2y+FxfcO/viyZaq2xsoG7fCqq6upra3lqaeeYv78+SSTSRKJxHAPS5IkSZIkSYNoxAcLxcXFnHfeecyaNWu4h7JtypbVaVgLyTdCA+EutyuHSAmUjwVKOjZuznr0Z+zb8FB4PPdLPYcKyxbCdfNCqFC1F5x0RbiSf3u10/7hMwPc/1149f7C9otE4OjPwH7vg0wr/OUjkFhU2L7ZwCDd2PN20fLeS2BJfVBdXc3s2bOpqakZ7qFIkiRJkiRpCIz4YAFCSaQRJ52EhkTv5X6ytfPjEyBS3HU5pM3bTQiT1GWjt3z/gSuJPPT98Li3ngqvPwI3nAupTTD9EHjrt6C0i2Nub2adBfu9F8jA3y6Gda8Vtl8kEsonTT8UmuvhTx+AZN7KkVRD+C1TDR33ywYGXYU8+bJ9M+yPIEmSJEmSJKkABgsjVbbEUaHlb8bNgAl7QHxcKIfUOZBIJ3NlkjpPZj/1GyL3fis87i1USLwEN34kHG+Xo+C9v4ZYReGfa1sWicBx/wNTDwwBwa0XFb5vSSm87zcwdmdY/zr84X2w5pXwXncrE2IVIRSC8Ntkb4X85oUGT5IkSZIkSZJGHIOFkSpb4qjQ8jfZFQkAmRZItU9iN6wJvRfWL4fURti4vOME9/JniNz5tfB4zud7DhUAnvg/aGmG6sNDf4Herrbf3pTE4JQfhcdvPA/JtYXvW1EFZ/wBysfDqmfhl3PgyWuguQFaU91/V9ngoWFtYaWRoO/BkyRJkiRJkqQRw2BhpMqWOOpr+ZtsL4VY+yR2ch20NYemzS0t0NYK6U1h8jrVAH89H9INsMvR8JbP9Hzs5BqovSU8PurT4Sr9raF5E2xcCZveCFfpJ9eE3g5NG6CpPryfaghX72e66UrdF6MmQ+W08HjtK33bt2omnH8PVB8RSkXd9mn45xfD997dyo5sSaSK8YWVRoK+B0+SJEmSJEmSRoyS4R6AtjPReMcwIj4uhAujxoWwIbmWZcuXsyLxOjWL/4+KNS+HifTTfgmRXnKsp/8Urryfsn8oFzTIxmTqiaxcARtfD+WE1teF+76sGhg9FY64ECbvM7DBjN8N6pfB2sWhj0RfVE6FeX+BR34K914GL94GK/4VGlzvfuyWAUMsHm6pZMcyVunGsIqhYnxuNUo6GbaLxXNllCRJkiRJkiQpj8HCjiZ/YnhrNOOtmLA5UCDdCBXjWVq/lImv3UbF63eFhs/v+RWMmtTLuBvhX/PD44PODf0I+qKtFZo3hpUGjWvb79dB/XJia1/n+tZXGcMmuKOb/YtjYTVCpg3I3ndh43L455fgTafBAWdAcbRv48yasDu89kCuT0JfFRWHFSC7viX0pFhfFxpeH/0ZmHtp+wqLxrA6IbvqIN0YVpNA+NtoWBtWmzSsDdulG8PfT3Es/A1l/3629t+UJEmSJEmSpG2awcKOJr82/lBOAqeToc9CrDzcp9onrFPlVMfWs1Pd9eH5cV+BnY/o/XiPXQUNq6FyKo9vnMyzv/sjNXvtyX5vqmFU521fvR/qHoGm9ZsDhExTPRG6LlNUBIwB2ojAqMkUjdsZxla339ofd1VGKNWQFzRkwsT7U9fAK/fAs3+G5f8KJZsm7lXQV9bB+N3C/drFfd8334xD4WMPwG2XhDHdfwWMmQZ7ndyxn0L2PjoKIoQgoWJ8bsVCtg9Dhi1LIG2tvylJkiRJkiRJ2wWDhe1RT1fzZ0veDEVt/Pzzppsg0xruY3EyLaPCpHRriin3fz6UNNrzrXDwh7tvFtxUH+43LCPz+C+JAF++P8M3L3ln3ikj7DG9igP3nM7svaZz/K7FHNRwz5ZDA1rbMqxOZli1KUN9uphdZuzEjGlTSZVO4KLXjmEpO3H9PgspW/4orHst3HoyZf8tXxu3ayg39NpDoT/Crf8N+58eXuttlUW2rwLA2F3C/ZrF0NrScbt0gQ2T29r3K47CO38I43aGB74XQoaysTDtoPBeNjQoKoFx1bn9YxW5ckfZVQmjKrdcqQAdw4bB6DORNZjHkiRJkiRJkrRVGCzsaGIVuavvh3rStrGehkgZyZYG4iUR4pXj4MbziWxYElYBvOPKLifbU6kUJ779XSxe/ApvOfwQvjFrObu0prh7cQvfvPlFYrEobz5oFi8tfp0Vq97gpSWreWnJam65/1+85+OjYHwRN9amufP1IhKN8OLKRlY1ZGgrLuUjJx3IHxY8x5LV9UA9v7hwV845aS9eeX2Xwfvc43aFikmhlFH9Mnj6j7DymVDCqXxcYcfIrlioXxZWXRS6X3ciETjqYli9CF64NTR1PvsmYHx7Q+3GXB+FfPnhQWfZlQpFJX3vt2D5JEmSJEmSJGmH1Us3XY1o6SQ0JLq/gr68ksbGRtqaGmhKbmLp9Z8nsuh2KC6Fd18FZWO63O3Xv/099z3wIEuWrWDVwtvYJb2IlrYMl9zVwuc/9VFefepe7rv1WpY/9zCrah/jjis/zuUffyd/OLuaPcYXsbS+jXNvauQXjzXw52caqF0D8945h0X/919cdt4x1F59Ph86Maw2+PODL5DJC1g+9qN/sLGppctx9UmsIqzIqD4ciqKw6lm462uw7MnC9o+Ph0k1QAZe/PvAxwMhXHjH92HymyC5Bv58Hqx+ETYsg/Kuf4vN4UHDmvb7RO43j8W3LItUqPzySZIkSZIkSZJ2KK5YGOl6urK8c239VHJzQ+BMe7Pf8soJLHzsQSKL7+Go1deF/U74OkzZr8vTNTU18Y3LvwPAxR/7IF+YtADYwC//leG8Cz/Ppz56ToftJ02cwImH7c2J+4yDRx+ADFTMejeL/jyTtfVJ1mxoYJedxjNj8jjYuBKAirIYHzt5Ftf88xnu+tdrnPTl6yg7LfR5+MM9z/H408Xc+In9qdmpi74KfRGJwKR9Qj+DJ64ODZQf/TnsfCQccGboY9CTfd4Fb9TCczfBrA8MbCxZsTi89xq45m2w5iV48HtwzJe6DwiypbOyqxlaUrnfPLtKIRsO9GXlwVCW5JIkSZIkSZI0rFyxMNL1dGV55yvWs7X628MFouWQTrLq1eeYnbgx9FzY//QeJ8l/+X/XsGzZcmZMn87l792TiUUboHwcn7jqAT710XPIZDL8+g838J5zL+Btp5/H3FM/wJvPv5KH/vwzyLRxy6IWxp/ze478rx9w9S0P05bJsNOEyi3OUzMjV7rnoeeWbn48ZfwoXliZ5NBvPsFzyzb1/3vLVzkV5n4pBAxE4PWH4J7/B80be95v73eE7/eN52DZU4MzFoAx0+E9vworKV5/CFYsDCFBV8FANB7ey95GVXX8zbv6++htJUv+cS2DJEmSJEmSJO1wDBZGup7K3eRNDr+xejUvvrqExLoN4b0NSyHxCk31q5maeIh426bQe+Dt3+u2iXFrays/+PHPAfji5y8huurp8MYBZ0LpaJYuX8FJ7/8QH/7vS7nxb3dw+933c+9Dj/HY86+za2UoX/St+5sBWLx8DT+4/j6O+eSP2fOMb7DgqZc6nKuyopSD9pwCwPvfsvfm1x++8oPEY0Vsam7l5dXdNJXuj6IS2Pc9MOfzoV/CplXwyE+gNd39PuXjQrgAoeFyw+rBG8+0g2D0lPaxRQvfr3Mg0NXfh2WOJEmSJEmSpBHNUkgjSVdlj6J5V6bnP++039qli0hnSkgky6iaAJnUJsi0UFbUxr4t/4YIcPTFofdAqoG2tjau//ONVM+YwRGHHwbAbf+4g1dfe43x48fxwQ+cCX+8FoDm0btw3XV/5VOX/i8b6jdSVlbK5z55PrvuPIO16zbw4lP3UlnxEtDMjZefT8WkXbjnqUXc/MCz3PrQs7y2Yi3Hfuon/Pe7DuayDx1DeWmYSL/78jN5fVU9M3eewqntCwJW1ydJptooLSni2L0H2DC5K1V7hibK934L1rwMT10Dh5zfbdjC3C+Fxs9rF8PfPg3v/TUwCFf5P3sjbFgSwot939P/40Tb/1YaErBuKVSMt8yRJEmSJEmSNML1e8VCU1PTYI5DW0N3V5r3dgV6KknVuDGUFbcxYUIVRMuJxEYRiVcRX/1vKiNJGD0V9nvf5l0+/6WvcuYHz+PIuScw5/i3cdfdC/jBj38GwPnnnUu8vJyWNYsBOPDdF3DOBZ9lQ/1GDjlwf/614BZm7bcPl//wKi756rf45c0Ps25jWF0QKylmzKhy3j3nAH7z5Q/w2p+/xkdPDf0TfnjTkxx4wa9ZuroegDEVZey/26QOH+XWR8LKhuNrxjG6bIhytcqp8OZPQKQYljwGtTd3v22sAk75CZSOhuUL4d7LB37+thZ46Afh8f5n9FyyqFANa6G1Kdxb5kiSJEmSJEka0fodLEyePJkPf/jD3HvvvYM4HA2p7soe9VQOqf39qolT2LNmfyZOrArbjZkOlTvReO+VYZvDPwElpZt3+edd92x+fP+DD3HC209lwX33U1JSwsfP/zCbVi2mpC1Fa1uGl9e0MrFqPP/v0k/z8D+u5y+33sFp53yCF19eTCwW5cj9dyXTfqz3feUarr7lYTKZ8MroijKu+tzp/P27H2PKuApeXLqWi395d7dfwd+feAWAdx04sW/fXV9N2gcOPDs8rr0V6h7pfttxu8BJ3wYi8Myf4Ok/Dezcz94I616D0srQ9yHT6x69qxgPxWXhXpIkSZIkSdKINqBg4ZprruG4446jurqaSy+9lOeee24wx6bB1t2V5r1dgd7+fiZaTiaTyd2e/QvxxhVQNhYOOqfDLuedMw+A4uJizj/vXMrKygD4wmc+zc47V/PHn30bgKWbinn16QdZVfsYX77kAha98ipfvfwHAFzyiQ+z+sXHefDnFzF5fGjQ3JBs4qNXXMfbP3MVb6zLNUd+2+H7cPs3TwfgxodepO6NDV1+lIUvrwTg5P2qunx/UO16NMx8W3j81G9g6ZPdb7vbHDjiwvD4zq/CsoX9O2f+aoXZ50B8QmjInE7C+jpYV9e/FQwVVTBpZriXJEmSJEmSNKL1uxbMokWLePzxx/n973/P9ddfzxVXXMG3v/1tZs2axbx58zjzzDOZMmXKYI51x5cZjEvLh0CqAdKNUByDaBkvv/wySxcv4ogXrqAU4JCPhKvZW0ODZSJFnP/h87jyRz+lrm4JkyZN5NUXn+OZ/zzL8cfNZf2GehYuuAlOjlI+eXcmTRgN6SSZTIbPfOWbtLW18e63Hct3v/ypcLySMkpjMWiEi844lvN+ci//eLSW/T/4bf7wv+dx3CE1ABwwYwxz95/BgmeW8L0bHuaHH50b9m/tmJ8duPMYpk6e0PvnLrSZ8iM/7f69TCYEL03r4eZPwEnfgtE7db3tLkfCkkdhyePw1/+Cs2+EUZO63hZC+aTOnm5frVA2Ft70XqiYCJk22LAcUpsgWgapcigp23LfSIE5Y3f9IjrbVv+eJUmSJEmSJA1Iv1csABx66KH8+Mc/Zvny5dxyyy28733v44UXXuCSSy5hxowZnHTSSfzhD38YrLGqO+lkaK7b1yvRs/ulGrZ8L9WQey/dCM0boX4FpJtY+urLTKv7K6X1r4bVDId8ZIvd4/E4l372EgBu/+ddTJkymRNPOA6AT3zq0+w2pg2Aibvvv3mf7/3id/zjngcpKSnhii9d1PGA7XPZpx59AFf+9/uo2XUnVq2t58RP/ZBv/ebvtLWF4110yoEA/OjWf3PO92+noSm9xdjKY8WbSykNuUgExu4SvqfUJlhwWfguu9y2CA7/JEzYAxregFs+Ba2pws/V1gL3fy88PuhcGN0eSqQbIdMCzQ2h70O0vOfj9PfvSZIkSZIkSdKIMKBgIau4uJh3vOMd/OlPf2LVqlVcc801zJkzh7vuuotzzjmn9wNoYHprvpwvf9I4u1+6sYvtGnPvRcuhJQ2ZVqhfwe6jG5i55s6w3XFfDeV2uvDCi4sAOHDWAZtfu/TLX+Pa625gr6piACJjZgBw213387lvfB+AK792CXvutnOno4U/1Qu+80cu+M61RIuLec/cA2lry/Cln9/MqZ/9Ges2NfHOQ3fjWx88kqKiCL+7p5ZDLv4jr6zMlUUqjRXz8Etrue6xZb1/V4OlqAjG7w7xKti4Au7/LrRuGXgA4bt+189yzZzv+Ubh5/nPDbDuVSgfD4d9PPTNiJaHW6QExk6H+Pjemy735e9poAwvJEmSJEmSpO3OoAQL+SKRCJFIhKKicOitdmX4SJZtvgy919HPnzTO7tfVFezR8tx7sQoYO41IpJhIURHVtf8Xjr/zkXDQh7od1u3/DOHDSSceD8BPfvYLvv29EB7M2Xda2GjMDP78tzt5xwcvJJPJ8LGz38snzztzi2O1tf8dvbzkDQCeeXkp/3jkOT76rqMojZXwtwf/w0EX/YHaJWu59H2HsuCb72Xq+Apql6zl2C/9efNxPvvugwG45NrnWN/QzeT+QGTaoHkTtDR1fL04CnMvhZJyeON5ePyq7ksFjdsF3v49IBIaOT9zXe/nzV+tcMBZ4TerGA+x8hAkjJkKpaO6/q3TSUiuyf3N9NbMezClugi1JEmSJEmSJG3TBiVYaG1t5bbbbuOss85i8uTJfOhDH+Kee+7h2GOP5Te/+c1gnGLkKqQsTbb5MoQyO6mN3V9tnj9pnN0vVtHFdhUd34tVQPlYWHQHLHsy7PuOH3Rbl7+pqYkXF70EwKz9Q7mjr3/zMgC+9sXPMLZtHQCZMdOZd+EXN+/34298gUinGv4PP/MKr65YA0BFWYzbrvwkB+41g2RTipvue5qHr/4c0yaO5dVV9XzrhscBeMu+03nqBx/goD0msaY+N3l90amz2X1SBcvXNXHw1+7jlVVdlIHqr9YUrHoW1iwK4UFLc8f3x1bD0ReH72zxffD6w90fa7dj4KiLwuO7/jcERj1ZdHtYrVAUhQPO2HIVSjQeQoV045Z/S+lGaGvN/c301sx7MMV6KcskSZIkSZIkaZszoGDhscce48ILL2Tq1Kmccsop/OlPf2KPPfbgiiuuYMmSJfzzn//k7LPPHqyxjkx9KUsTi4cSOrHR3V9t3tOkcX5fhfzHHbZp7w9Q/eZwZX03ysrKOOTggwC46Za/ATB71iwA9i9fFSbhy8cRGTWZ7//PZzfvd8Otd3Y4zrV//Qdv+a/v0tbaCsCVF72fvXaewitLQ2Plc99xODOrJ9OcDo2j33pgroRSUcV4fv3Vj3DEmw/Z/NrC1VF+8MmT2XPvfVjWHOe/fvM0mXRTCGQybd1+noJ1WIXQxYqEqbNgelg1wcaVPR/rsP+CqpnQlobVLxR2/kgEiktzKxNSjbnVCNkAYYvQoRyKintfodBTT47+2hrhhSRJkiRJkqRBVdLfHWfOnMkrr7xCJpNh6tSpXHLJJZx99tnst99+gzk+xeK5skW9icbDVfH9ld9XAcLjhjW5PgvRcpjWPkm/9MkwSV1U3O3hPvKhc3jiyaf41TW/4eKLLuS0d53CP++6m0nL74JJwMy3QVExHz/n/Sxf9Qbf+MHVnP/Zr3PAm2bypr32YP5f/sY5//0V2traGFtRCrSw6/RJHPW5q6hvaOKI/XfnG//1Ln74p7tJrN/E7juN4cw5ewPwRqqU854/nHSmmPITjtg8pisSc4A57HoW7J7exDFPfpzM648QiRBWEpSOgtLKcBtdFL7TTisoulUcg0lvgmQilD4qKet6u/VLwv2E3Xo+XiQC5ePC496aOM88KYQQiUWw4Btw6k/D6+nG0Bsj+xtm7/NF21evdLP6ZLMOZbS6WOWiHVJdXR2JRAKA2traYR6NJEmSJEmStgX9XrGwYsUKzj77bO68806WLFnCt7/9bUOFobA1y9Lk91XIPo4QruZf397seJcjw6qI5vpQ9qcHZ7z/vcTjcV54cRHf/t73OfWd72BaZRGHV20KG+z99s3b/s8lH2fX6mkkG5v41o/+j3Q6zcc+9/9oa2vjtGMOpGpM+PzvufRq/vXiEiaMqeC6b5xPJpPhe38Mqxy++L5DKSkOf9IbWmKkM92HHvtnnufqoq/y+UNbKYoAkeKwYqGpHjYsDaWMXrkbXroD6h6F1S/CplVhYr0nxSUwekq3Da1p3hQaOANM2KPnY0EIKwBaegkWikrgnT8EIlB7M7z0z/B6djVCtL3XQnzCln9LnXssdGdr9l7QNqGuro6amhoOOuggDjroIObNm0d5vO+/f21tLQsXLqSurpeSXpIkSZIkSdou9GnFwne/+13mzp3L7NmzeeONNygvtz56oZpSLcRSvUxKD3uj61KIluaeRkshE4MNy6EkCslNUD6e6NRDKH71HtKLH6R1wr5bHqYtlC2KlVXwta9+lS9+5Wt86X++SXnFaC4+birFRfWsHb038YrpkA7lh771o19TtyJBcayMU08+gVaKOfnEY/nr3+/mwWfrWPfmVsaXwvL1TVRPm8Kvv/xBqiaM59q7n2R1fTNTp0zivW/Zl6bWECykWrteZTA6s4kPZ/7I2zL3ArC8oYhnm6bwloP2IdKSJNJcT1HzBoqaNxBJbSLSmoKGN8INyJTEad75GCjJ+54y0cK+3pYMRatfIQa0jZpMqngUtHTxm6dbcz9BUYxiIJ1qojXv9fAhO/09TZ5NyUEfpuSpX5G586thnLEKKImFqkwNG6GlMTSQbmmE5HqIjw37trWG3yIe6+EDxCAaAyJbnrsr+X/P2d4O2V4P7ZoKOY6GTSKRIJlMMn/+fGpqagAYPWY8n/zjcwXtX1VVRTweZ968eQDE43Fqa2uprh7AyipJkiRJkiQNu0gmU/hsdlFREZFIhMrKSubMmcPcuXM55phjOOCAA4ZyjNu1+vp6xowZw7FfvJ6Ssh3jSu/3tv2N8zN/5BFm8z/Fnyl4v0imjWvaPs1OrOY7kf/irqK3FLzvn1s/wmiSfLjouyyNTO37oDMZ5mQe5eOZ3zKOegBujRzPryNnkIx0/btEM2l243X2yrzCXrzCQZlnGEc990XezLeKPtX3MQBntt3EuZnrWRA5nMuLLux1+y+2/Yg5mUf5WeSD3Fx0Uq/bl2WauKrtc0whwV8jJ/GLog/2a5xbS0tTknu+9X42bNhAZWVlt9tl/x31tp0G18KFCznooIN46qmnmD17NhDCoFOvuAOAmz//VspiPefT2VJKtbW1zJs3r8OxNDj89yFJkiRJkra2Pq1Y+PrXv859993HI488wi233MKtt94KwLhx4zjmmGOYO3cuc+fOZZ999hmSwWrb8HRkH8jAfrxAUaaNtt5q87fbn1p2YjUNlPNA5LA+nbOEcLV+C92XN+rOxEyCC9uu4TD+BcDrTOMHRR/h+chePe6XjkR5kT14MRJKFu2RWcyP2r7KnMyj3J85jAf7+BkAZmZeAeBFdi9o+xRhNUSUdEHbN0XK+FHRh/lW2xWcmrmD+zJvpjYys8/jlAZLdXW1KxQkSZIkSZJ2MH0KFr7yla/wla98hXQ6zWOPPcaCBQtYsGABjz32GDfeeCN//etfAZg4cWKHoGHmTCc2r/30cb1fSVro4pFCmwl3VYomK1tnP53MlcZpawk19OPjOx4n1Rjez7RBcgO0TSPz+wpGpRu46ezJZKbs33H7pnUdnr6xejUf/OinOHDik/CmYq59upG/33YWJx51MB8/6x18/zc3cv/jz2zefvLEcZxw5EGMHzOaivIyMs0NFE1qhmK474efIBUdw0E1u/DQ0y9Rvyl8pn9f9y32WHELABsaW/jukyU8W3MJp2Tu4NzM9ZTTTIoS/hQ5lesjp5COhAn7K1v/h915vevvL7plg+IMMWhr4sttP6K5ZExoeHzgB7r7BTra43hKb1wMTfCh4/fl3Emjut4ur/dCyd1T4Dk497Aqzj50VsftYqO7OdHRtP7jFYqf+zNXjv09qTNvCg2ci6Ph983+3ptP0l6aqKVxi1JFA1LA32l9fT2TvzU4p5MkSZIkSZK0dfQpWMiKRqMcddRRHHXUUZuDhkcffZR77rmHe++9l8cee4wbbriBG264gUgkQkuLddTLYiW9lgwZ2mChGYozYWK5oipvo9FABlLFIXyIlgOpvMdAciXQAk2boGwUNDXDtNnw2gOULn8UqjuVNWktbj99hj/9+a9c+Jkv0ZZcy7svCRPhe7/nC0T+9lX+seAh/rHgISaOH8Pb3zKbtrY2Hlr4HMuXr+S3N9zW4ZDf+FoIZb52/rs4811v5YXXVnD4uf9DazpcyX/7/U/y37s3863bl/H9e5bDuJ1ZsNdlHEioBf8sM/lB0fksiUzrcNyStmbKipq7/v4iXfROKC6GTBGRTBtlbZugpAyK27rev7PU2hC6RIoonbQ7lHTzO0bzVmXEysJLmTTRaKfVGrEeVm+c+HV49V6K1r5C2eM/hsM/CbHS8JumG8PfwqZVUBQFRsHYGUBe8JVOQioZGjX3t3F4AX+nqd7+TUiSJEmSJEna5gzKrF40GuXoo4/m6KOP5oILLuCOO+7giiuu4Nlnnx2Mw2swxOK5ieLupJK5VQ3FsTABDaFx88b1UD4KKIHxu8DOR8BrD8BrD8GbP9Hl4X79uz/ykU9eDMCXT6iirCQFE/fmqFPP465ba5h/zS+58Z8PsnrtBm65+xEAznvvSbzr+CNY+PzLNCSbaGhspLF+HRBWNHzo3XMhFuPcr11FU3OuPNBtD/ybpx9OMP/x1QB8Zk4bB/IcTZTyy8gH+HvkWDJdlGy6ZVELn9274G8xTJYXl+ZWeLT1ITRLLAr343YJgUQhitvDjdZUHwYJlI+Dt34T/voxeOrXsP/7YNzBud84AxSXhZUMXeVZqWT4bKlk/4MFSZIkSZIkSTukAQcLa9eu5b777mPBggXce++9PPdcuEK8tLSUY445hjlz5gx4kMqTfyV5bMtSPd2K9nLleboR0pvatx0VVjZkzxcphqrdQimkaHk4zq5vgfuugLqHoa0Vira8er5qwniKi4tpbW3l1F0agWIuu3Ml3/nK3qxbt569d5vBozf8iMVLVnDdbfdxzV/u4Jq/3MGXP3EW7zzu8NyB1i+Bv10UHkfCeXaZOpGnF9Vt3uTV5W9w74o1FEXgR+/flfP3TUEL/Dnydm4rOr7Lj9yaTjE1uqnQbzCnqDhc6d+Whpbmbj//Flb+p/2L2bPwcxXHwn1LH4MFgL3fATNPgkW3w91fh3NubV+tEGtfuTIBkmtCsJBKdvx7KiSIkiRJkiRJkjQi9TlYWL9+Pffddx/33nsvCxYs4Nlnn6WtrY14PM7hhx/O6aefzpw5czj00EOJxWJDMeaRLf9K8kKChUJL2kTLQ6AQAeITwvYNazpOQrfllfwZt1vYp7ke1rwME7dshHzqO97Gon89zOVX/pipo28G4M+PL2XdunCcFxYv4a0fupQHrv0+b738EJatSvDPB5/ip3+4he9+4WMA1G9s4MG7H+RkIBMphuIYEeCv37uIJ59fzDW33M9tD/yb11esobQkwnUf3otTDxgPaxcD8NbyZ0ivWMWfxl8AwEt/+AKHTk7z5mlFHD81yb67b+j9O+xKUXEIFrq83L8LDavhxX+Ex9MPLfw82XJULU19Gh4QVlccfXEIFrKhRrYUUrQ8/Mbp9pUX6caOf0/Zv5WGRPiIo6pcuSBJkiRJkiQJ6GOwcNBBB/H000+TyWSoqKjgyCOP5IwzzmDOnDkccsghlJRYL33I9fVK8mwQ0ZAIE8OdA4Zs8BAth3EzOu6bPwmdSkKqIbdioXQUTKyB5Qthxb+7DBYAdtt1F3754++RuvpZ2LCYn1/2RSr2OYFYNMbbTn0Pr9Qt59gPfpY7f3MFF579Lv754FNcfd3fGT9mNA899Rz3PPpvjpjayskfrODF1SmOOv4Cdp8+mcamFOs3JVmzfhPJpmYqR5Vz6/m78ZY9x4QTl42FdJKK+sXccU8tRe/5OG2RIp742FgmbHimy7EWLJPJlSYqiva+WqGtFV66K5Qd2vlImH5I4efKBgv5jbf7Ivtbt7bkrXTJ+/3zf+POUklobl/RkRpArwVJkiRJkiRJO5Q+JQH/+te/KCoq4rTTTuOSSy7h0EMPpahoy7r1GkLRPpZAygYRLamua+Zng4d0Y8cJ51Sy45XtDWvCBHm6MVdWaadZ7cHC07D/6T0Po3IibFjMofvsAjWhqcHdv/s2bznrYha9upQjT7+IX192MbPftAcLn3uZL115zeZ9j9ijCkixeF2GNesbWLO+Y/miaZPG8bcffoZZ63INnzdFRtPSHGFsaRt/eneU5W0Xc2PkZCoGYxFNpjWUhYJcqaKeLHkcGteGsOPNHy+8+Tbkfqtsv4u+ai8dRaZ1y98YtgwaOr9XOiqsWIh1EUYNpLGzJEmSJEmSpO1Wn4KF888/n/vuu4+//OUv3HjjjYwePZojjzySOXPmcMwxx3DwwQcbNGxrsiFALNn1Sods8ND5ivVsiZyGNblJ7aLijttNau96vOLp3sdRPi7cN67f/NLO0ybz4J++z1s/dCm1r9Rx4ocuZe/dqznpLeGK/mMOO4C3H3Mob1p7B7x8J4cddhhX77Ybr69M8Ob99mDiuErGjo6z805VlMai8Cg0p9u46sFVfPP2pWRaW7jwsBifPryMqdE3+GTmN2QSBfRC6Enn1Qq9hQQbV8Lyf4XHh38Cysb07Xybg4WGvu2XlV1Nke2P0ddzj63e8nUbO0uSJEmSJEkjWp+ChauuugqAlStXsmDBAhYsWMB9993HP/7xDyKRyObySNmg4ZBDDqG4eIATuRoc3TVvjsZzE875qxRSSahfCdFSKGnvsxCf0HHfaQeF+5X/6b2BcfnYcN+4rsPLM3aaxAPXfp+v/vA3/Pavd/LCK3W88Epoynz7/U/w5e9fw3XvKeO0vYv53z8+xI8eWwDApPGVfO2j7+Zj7zmO4uIi1tU3cM3dy/nhguXUrQ0T/7tPLGOPXWZQvNMkfrLmIE7L/J2pmTf69LVtocNqhWjP27am4eW7gQxU7QXVh/e8fVcGvGKhPejLtA1eI2YbO0uSJEmSJEkjWr+aIkyZMoUzzzyTM888E4AVK1Z0CBruuOMOIpEI8XicI488kttvv31QB73DKrRETqaHhsH5ZWoKLZnU1hrus1eiZzKQboLScmjLhHI6JWXQeTXKTgdASXm4mn7d4m77LAC5FQtN63OvVUwCYELFJH76nW/wra98nt9cfws/ueZPvPxqCBdaWlrZtf0i/yUbI+w5fQKbGlOsWFPPBZf/lt/89S5m7bETf7j7aZJNaQCmjq/ga6cfzIeO3YtoSTFNbcXcuu5Ebsscz80zrib2xjMdA46KSeHK/LKxIVTJ/g75Y81a8UxopDx6J6jaM7w2/eCuP/O//xiOUT4OjrwwF0j0Jn+7/NCn8/6FHg/af+M+lGDqSayib+W4JEmSJEmSJO1QBqXb8k477cRZZ53FWWedRWtrKzfddBNf//rXefbZZ7nzzjsH4xRbTUtLC5lMhmi0l6vRt1X5ZWr6Ovmb38g3DiTXwahxudcjkY5XqRcVw5R9YekTodxPT8FCWbYU0tpuNxlTOZr//sgH+NSHz2Ltug20tLbSkk6z09/Ogkyav1zxCSIVVaRbWrnq1sf50q/v5IkXl/HEi8sA2G/n8Vx48n7MmzOT8tIt/7TbIkW0jdkZ4mMguRbWvhxKFTW8EW4QVmaUVoZbcUluEr2oBJrq28OGCIyZscXxO3ijFl5q/9s/+EP9n4gfaPPmzatIMiEw6kt/B0mSJEmSJEnqwoCDhba2Np566ikWLFjAvffey4MPPkhDQwOZ9qvqq6qqBjzIreX555/n61//OsuXL2ePPfbgxBNP3LwqY7sxkDI1sewkdnu4MHF8eN6wtusGzwBT9g/Bwoqn4YAzuj92Fz0WuhOJRJgwfmz79usgE1YiRNrLKUVLivnkuw/nvXP25Su/votkc5qPveMQjt65hEihE+fx8RA/FFKbYO2rkFwDzRvD52xcu2UAUlJG6GIMjJoE0bLuj51uhCd+HR7vNgem7FfYmLqyuRRSP4OFSF55qkwrpJvzmnJXQKqh43NJkiRJkiRJ6kWfg4VMJsPChQu59957WbBgAQ8++CAbN27cHCSMGzeOU045hblz5zJ37lz2228Ak6pb0aJFizjiiCN45zvfyQknnMDdd9/Nd77zHf75z39yzTXXFHyc5uZmmpubNz+vr68fiuF2r7teCt1JNUBzQ/vEcnmuaXO6MTxPNYbH6aYwmR4t7xguTMw2cP53z+fppsdCrzaE1QiUjg6rBvJMGT+aqz/z7rxtl/bt2ACxUbmJ/0wbNG+C5vpwS64J309rKpQ/yhrby2qFZ66DZALiVbD/6X0fU76BrliI5JWv2rgqhAvFsVxT7nQyPE83GixIkiRJkiRJKkifgoVTTz2V+++/f/NkeSaTYfTo0bztbW9j7ty5HHvsscyaNavwq8a3EZlMht/97neccMIJ/P73vwfgM5/5DNdccw1XXXUVp59+Otddd11Bx7rsssv4+te/PpTDHVzZ0knZICG/HBKEx8XRECyU5E1IZwOGbH+BFf+BlmYoKe36PNkVCxuWwvrXYezOhY1v4/JwXza23x+xYJEiKKsMN8j1WGhNh4Ah1R7A9BTc1D0Ci+8Ljw/9cO577K/W5twYWtO9N4zuLNOad6xUWMFQVAKRVHs/DcLzgY5TkiRJkiRJ0ojRp2Dh1ltvpaKighNOOGHzioSDDz6Yos5NfbczkUiEZcuWsXLlys2vxeNxzjvvPMrKyvjpT3/KpZdeymWXXdbrsS699FIuvvjizc/r6+uZMaOXK9yHUywOmxLQlg6rE2LluZJIqUZoaQz3RKAlFfr/5pdFmrIfjJoMm1bBf26AA+d1fZ6qmTB6Suhp8Pt3w0mXhzJKvY5vVLhvXDd8PQKKo2HFRXbVRXcW3QFP/yk83v3Y3GqO/mpcB7dcGB5P3HuLFRsFefD74X5sdfgus029syWQKkbnVirkN/7uy6oXSZIkSZIkSSNKnxKBBx54gHXr1nH77bfz+c9/nkMPPXS7DxWyJZxmz55Na2srL7zwwub3ysvLed/73scJJ5zAggULeOONN3o9XmlpKZWVlR1u27RYRbhavSgaJprzpRvD60SgbHSYcI5PyF3hnkqGngkHfShs/9CPQjmhrkTL4azrYers0Mvg5gvgkZ9Aa0vP45t+MBSXhl4I/Sl1tDVk2kKgkA0V9jgeDvzAwI7ZvAluPB/WvBKCm1N+3PdQZcnj8NRvw+N3/BBGTcyFCLEKqKjKhQwNifaAqb3xtyRJkiRJkiR1o0+pwJFHHklJyYD7PW9TsmWbTj75ZF566SW+/e1vs3Hjxs3vV1ZWctFFF/HEE0/w8MMPD9cwh072yvW29JblcKLlIUSIj8uFCbE4VEwI769fFkKC/U+H0kpY8xK88PfuzzV6Jzh9Phx0Xnj+zHVw64WwqYfApjgGE2eGx6tr+/85h0qmDR77ZVitALD/+2HWWR17G/RVuhFu+jisei6UkHrP/8GY6X07RksT/P2zQCb8PuN3h/V14ffu6nxtLWE1SlFJ/xp/S5IkSZIkSRoxtu/lBoNo99135/rrr+ePf/wjl156KYlEYvN7sViMAw88kLFjxw7fAIdKKhlK/WQIE8ypxi23iZZDxfiOE87pRiiJQks6NFbe7/3h9Yd+EEoWdac4CnMvhVN/Gq6WX/Us/OW8cHV9dybWhPvVL0Bba/fbbW1tLbDyP7DksdC74NDzYa+3DaxcU2sabv1vWPZkKF102tUwYfe+H+fBH8DaV6BiIhx8fmgm3bxpy1UpkAuQKqrCzTJIkiRJkiRJknpgsJBn7ty53HDDDfzqV7/iox/9KNdeey3PPfcc3/nOd1i6dCm7796PCd5tXSze3syXXO+ErOyV7F1NRgM0ta/sSCXhoHNDyaJlT/UcEmTteSKc9n9QtSc0bYC/fwae/HXXwcG4ncNkd7oxNH7eFrQ0w4qnw9hLyuDoT8PORwzsmG2toSfCaw+EY777FzD5TX0/zspn4dGfh8fHfCn8xk2boKi46ybN2bJIhQYKqQbYtLrr1Q+SJEmSJEmSdng7Vl2jQfDOd76Thx9+mIsvvpgvfOELlJSUEI1G+cc//rHtNGEu9Ir4nlYOZEXjuX4J2QAhuS5X9ijdGB53Vdon0wLJNaHvwugpoeTOv34HT/0aZr6193PvfDic8ze46+vw9B/hqWtCuZ73/Krj+cZWw7SDwoT7+jrY9S1dH2/GoV2/3pKB51Lh8T6nwKt39z42CCWNurJhGdx7WZhYLxsLx34Jxu/W+/Em7Nn9e5kM3PVVeP2h0NfivdfA7nN7Pl5xdMvXWtPwj89CphX2OAH2ODb8nuNmhJUlsThheUon2d+/kMbNqWSuF0NP2w5Ho21JkiRJkiRJQ84VC12YPXs2t9xyC/fddx8333wzDz74IAceeOBwD2topJPQsCY8zvZOyK5SyPZTiMXDJHLDmlxj32g5RNpXOrQ0kYmWM//1SSEQeOWeUOKoECVlcNJl8I7vQ0kpvHI3vHTnlttNmx3uVzwdJs9709YaehSsWVzYOAq1+oUQACQToWfECf9bWKjQk0wG7v82PPuX8P29++e9hwrdeeQnoTxT2Vg45oshpCgfF1YrJNfAuiVdN2fOrk4ppHFzdpWLvRgkSZIkSZKkEckVC92orKyksrJyuIcxNNLJMIGcDQyaN0LD2tBHIZUMYUHp6E77NHYMHGJxqNo9NHAuiUJyDU8s/Bd7jh3HYWPXwMM/hndfVfiY3nQaJF6GR38Kj/w4lErKv+J9/G5hsrxpPbzxPOx0QNfHWb8EXr0XXr0fkmshUkTx7POAY/v0FXVpyWNh4r41HVYfzPlsaFo9UI/9HBb+Njw+4f/B3u/o33ESi+C+74THx3wxlJlKN0JZZXv/jE2Q3gQN5Fai5IcDjRty4VJPogWsapAkSZIkSZK0w3LFwkiUX8oGYOMboaxRw1ooiYVJ466uRm+s7/g8Foex00IIkYHDZ+/Ho427hPeevwnWvda3cR3y4TDZvfI/sPjeju9FimBq+6qRZQs7vte8MWz/98/B3y6C524KoUJxDDJtRJ/6Fee3/YFIpq1v49l8/E3w6M9C/4PWdCjLdOyXBydUWPj7EFYAHHMpvOnd/TvO+iVw08ehtRl2OhB2mQOx8vB9phvDb92aBoq77qcBUD5mIJ9EkiRJkiRJ0gjhioWRKLtSIXs/ehK0pMOKBei6wS9Aed5EerYmf7Q8XOUeLef0eedB5DwyN3+SyGv3w+NXwVsvK3xc8Qkwax48cTU88J3QDLmkNPf+tINg8QJY9Z8QWqx7HVY+A2tehmxoECkOZZN2mxO2f/4WePpa3pu5jZ0yqyD93336qlj1XFh90bQeiMBeJ4feC0XFfTtOV174G9zX/v0cfiEceHb/jrP6Rfi/E8OKhNLRcOj5ITxINYbfKNMK6SYYNTmUMMqGDfm/c/Y1yxtJkiRJkiRJ6oXBwkiXnUgeVd6xl0K2KTPkrmzPTkpnX8srjRTJHifdCAecAa/dH3ot9NWhH4VnrgsT+nd+BU66Ivfe2GoYMwM2LIEHvtdxv7HVoVnxLkdCWd6V9/u9l1R8MjzyE47kSdru+iLscnTHbbqSaQs9D579c+iBUDkVDvsvqJrZ98/UlTWvwD+/Eh7PPiccu78WfCuEClP2h5Muh8rpobFzNjxY+wrUr4LWyTBhj1wpq3yxeCg9tbmHhgGDJEmSJEmSpK4ZLIxE+aWQKqo6XrmercUPucnltpYQKuTX3+/qqvds2DBhz/B87WLY9AaMmlT42EZNglN+An8+NwQMk/aBePtKikgEDj4PHrgyjHH8rmEyfaf9oWJimPzvQtvOR/H5x8bx1bbvM2HDkhAY7HkijJne9RjSSXj5LqhfFp7vNhcOOrfj6omBaE3B7Z8LZYt2Pgre8tmO/ST6YsUzYeUDkdD0eeLeuZUK0fJQDinVDNFYuO9pRUL+34XBgiRJkiRJkqRu2GNhJIrFQ1DQ1SRztBxio6B0VHgcLe+4UiH/GNmgoWFN+2R0+7Zjq2FC+5X9S5/o+/h2mwNzvhAe3/2/odRPVkUVHPcVOOkyOOrTsMdxIVToxQuRPflk0TdpG79HmNB/4W+w4umwGiHfhmXwnxtCqFBcCm/+BBz2scELFQAe+Sm8URuaUZ/4zdA/or/uvTzc7/eerkMFgMopUBwP9z3p6e9CkiRJkiRJktoZLIxE0Xj7SoUuJpBjcRg3A8bOyJXMqZjQ/WRzp5JIVEwIKwxmHBreX/JY/8Z46EdDI+NMKzz5a2hI5I2/HGIVfT7k2sg4Usf9L1TtBWSg7uHQs6GtJZQ+WvokvHBrWLFQPh7e+i3Y9S39G393lj4JT/wqPD7+6zCq91Ckx2O9dEfoK3H4p0Lz7ca1WzZmHjcDdj4k3HclW/4qWwZJkiRJkiRJknpgsKAt9WWiubsVDZP2Cff9DRYiEXjr5aHUUToJj18NLc39O1a+4lgobVR9BBCBxIvw/M3wwm2w7AkgE678f9NpMGbawM+Xr3kT3PGFcI43vRv2PGFgx8uuVtj3vVBcBqmNkKHr36Mn2XCoYU2uFJIkSZIkSZIkdcMeC1tLJrNl2Z3OCq2z39txupNOhknjWDysVuj8fPN2+asQelkZEKvIbZNqCPuUxGDqrPDaymegpbGbmv29fI5oKZz2S/jtO2Djclh0O7zzh92XDtqwtOvXizJA+4qHWCXse1q4LVsIC74JDW+E90pK4Yj/hj2OD8/H7dzz+LKyPSl6c+8VUL88lIo66YpQbqorhZRGqns0rLYoKgmNn0ui0JKGsZO7WF3Szd9V9veHjj00eiuFNJh/p/39W5YkSZIkSZI0bFyxMJLkN+ft6nlWf2vtbw4kmmDym2DU5PB82cL+j3n0FHjnj6A4GhoqP/rz/h+rs2mz4ZQfw8SasErhlJ/mQoXB9vLd8J/rQ2jwzh91HyoU6r4rwv2B82DiTCgdDWPbV1h0Xm2SToZSUulOv3P294dQGit7g663lyRJkiRJkiQMFraebWGSNj8wSCfDrSW1ZYAQbe+tkEr2fdwbV0LjunBVe/Xh4bX+lkPKmnogHPe18PiRn8BLdw7sePkqp4ZVEO/8UVhJMBQ2rQ4rIwAO/2Su/0R/vfoAvP5QKOt09CUd+2DkrzbJ6muA1N32kiRJkiRJkoTBwtaTaux9m8HS3RXq+U2bU8kwMd25DFJWb5PLqYZwjlRDx9eLY9DWGlYtVL85vDbQYAFg3/fAgWeHx7d/AVYvGvgx+2rVs7D4vi0/c08ybXD3/0DTBpiyHxx98cDGkMnAfe29FfY/A0rKO/5G2Z4XkFu50F2A0F0T7/6uWJEkSZIkSZI0IthjYWuJ9aGZ7kDlhwJd9jYgtyKhu8nj3t7vqg9DtBxio4AMRMtC42WAJY9D88ZQrmcg3vJZSLwESx6FWz4JZ/+19x4Qg6X2Vvj7Z8LjklLY80R403ug+rDu98lk4LGrQj+E4lI45ScheBmIf/0elj4BJWWht8Lm36DT75RuD47SjV2HBz2JdhM2SZIkSZIkSRKuWNh6tuZEbSFXnHd3tXpv729eqZCExvpO562AcdUwZlrYb9yuMGZGaG58xxcH9pkg9Fl4x5WhfNGGJXDv5QM/ZqHWvZZ73NIcgoY/nwu/Oj6EB/XLO26fycDDP4InfhWev+USqNpzYGN4+Me5cOPNnwjNpYtKQqCTlW4MIU5yPbSmOr4nSZIkSZIkSYPAYGFH1FtoMBDJNbDpDWhaC+WVXW+TTkJyLRQVw0mXAxF4+lp47cGBn798HLz1svD42T/D4nsHfsxCjNs13E+dDWfdAAecEVZn1C+Dx38Jv30n/PW/4MW/h8n9+y6Hhb8L+xx9SSjl1F+ZDNz1P3DP/wvPD78A5ny+Y2+FrGg5tKShbHSuV4a0DamtrWXhwoXU1dUN91AkSZIkSZLUT5ZCUt9k2u+Ly7e8Wj4r3RRK9BSVwMy3wkHnwlPXhFUL59+T6wHQXzMOhdkfDBP3d34FPnhLCByG0oTdw/3axbDT/uE251J4+U545npY+ngoUbT0CSiKQlsaiMDcL8K+p/X/vMk1cMeX4Lkbw/MjL4KjPh2aY3clFoex00K4sa2sVkgnc2W1LLG0XairqyORSFBbWztox6yqqiIejzNv3jwA4vE4tbW1VFcPUdN0SZIkSZIkDRmDBfUs2wg6Q7g6PnuFfLS8+/4G0bIQLkTLwvOjLoLn/gpvPB/CgIPPG/i4jvx0WAGxdnG4kv/tVw78mD0ZtwsQgab10LAaKiaGz1fzTth9biiFVPs3qL0FNq6ASDGc8HXY6239O19rOoQx938nNH6OFMPhn4SaU6BxXfj+U8lcgJC/MiE2CCsVBjMMKKTnh7YZdXV11NTUkEyGpuDxeJyqqqoBH7e6upra2trNgcW8efNIJBIGC5IkSZIkSdshgwX1LJWEjauhtSk8H1fde8Pkzs1/S8rDpPiCb8C9l8E+74L4+IGNK1oGJ10B154BL/4D9jg+1yx6KETLQ7iw7lVY/UIIFvJVToXDPgqHfgSWPx2adU/cu3/neuUe+OdXYM1L4fmkfeDwT4XvvqU5t2qkQwPtzr0w8kOHfjS4zoYBDYlcSaX+hgK9NQLXNiWRSJBMJpk/fz41NTVUVVUN2uR/dXW1QYIkSZIkSdIOwGBha4lEui9f059jFSKT6X2b3sTiUFwEkVIodPhFxZ2OUQFvOg2euS5Mlt93Bbz9uyFwKERxrOvXdzkSjvwUPPh9uOcbcMafYNTELbdLtwGJ8Dg+HmIF/tm3tXR8PnHvECyseg6qD8+9Pnpqx+0qp3d9vJJuPkdW4qUQKLx8Z/tYq+DYr8CB86ClCRrWhN8gPiF8J/kT9unGjisMOoQOecFCoSsRssduSfV/tUH27zRW0X24MVj/JjToampqmD179nAPQ5IkSZIkSdsgmzerZ9E4TNwrXK1f0c9yKLE4lFXC3C+F509dA6ueHZzxHXkRTNkvlAe6538HJ0zpzsS9wv3qFwb3uE0b4I4vwy+OCqFCUQkc/GH42AOw99tDqADhe4xPyE3S5zfpzi83lN22qKTrlQz523Une+xRVV0fR5IkSZIkSdKIZbCg3uVPYPdVKhmutAfY5agwUZ5pg9svHZwQoDgK7/wRFJfC6w+FXg5DZVJ7aaPVLw7O8dpa4anfwE8Ogcd+Hib893wrfOJRePv3wmfLrjrIX4HQlc5BQne/WXeBQ3cG8ttLkiRJkiRJ2iEZLIwk2UbM6V6uVh/M/ZNroOGNsE/FBDj2q1BSFhovv3Br/8bR2cS9YM7nwuMHr4QNywbnuFucpz1YWPtq/7/DrE2r4NdvhdsuCd/RhD3hrBvgzD/C6J3C9wwhBIiWh1v2cVcKDQAMCiRJkiRJkiQNkMHCSFJoGZxC9+8taEglIbkeGjeE+1QylPI5+MPh/Tu/FibVB8OhH4WpB4ax3HohLH1ycI6blU6GckvFUSADa17u/7EW3we/OgGW/wvKxsAxX4Kzb4Y9jm0/VyM0b4SGtbnmy7GKEAj0pxFzfw00iJIkSZIkSZK0Q7J580iS3+x3MPbPDxq6ugI+3QhlozveR8vhsP+C52+C+mXwlw/DWdd336C5UEXFcPzX4YZzYN1r8NePwu7Hwf6nE2kr4k2ZOiJAZEUDlBS1l2HKQIZwn2qAxjWhbFOy/da4NkysJxMdSxBF46Gxcl81b4S7/ieUPwIYvxu873cwanLHlQjR8hAqlES3bL6caug4ls3NmgtsytwXvf2+kiRJkiRJkkYkg4WRJDrASedo3iR2fqme/KAiO8GdnShvSUPlTu0T3uXhPhaH066GP74f6h6B278AJ38PIpH+jw1gzHT4wF/gsV/As3+GV+6GV+6mFLgyu83NAzh+SRnsNAuO/ypUTu3bvq8+AH+/BDYsCc8P/hAc9zUoHR2epxpzKxRKR8HYabkgJhsmRMtzvRYa66G8MjfpPxQhwECDKEmSJEmSJEk7JIMF9V12EruoJJTn6eq97FX15ZXt203ouN3Oh8O7r4Lrz4Z//yH0STj0YwMfW/lYOOYLsO974NGfwdpXaMtEWF6fJkOEaWNjFEUiQPstQriPloVVCPEJuduoSeHzxatyfQn6Gn40b4J7/h/863fheeU0OPlKmHl8x+3ymzOXjsqVP4IQ4mTfy4YLFePDe9lJ/8EIATqvehhoECVJkiRJkiRph2SwoL7LTmJDmPTOL7+TfS+7YiE7Gd6VXY6Et3wW7rsilAgavwfscdzgjLFqT3jH9wFIpdv48NWLALj5jJmUxQr8sy+ODmwMrz0It30aNiwNzw/8IJz4v7lVCp01bYT4uC1fz4YJ+f0WsrKrR2LxLUOe7PuFlkiy9JEkSZIkSZKkAhgsqO+yV7Jnr6TPn4iOxjsGCT1dQZ9uglnzYM0roXTRTR+Dc24Lqxe2Z12tUnjHD3LNmVONHQOXdCMk1wKtHfsnZHUOE/L1FgZ0brjdU8hg6SNJkiRJkiRJBTBYUP91OxFdYLmg0lFhIv3kb8P612HpE/C7d8LMt8Feb4Pdj22fUC/wz3TcLl2/nmoBwooFxlZDtLiw49FW2GZF7eNra4Gn/wT3Xgb1y8NrB5wJcz4P43YO31W6MdyXxKClKWyTaYXWprBCoq9tJnoLA/Lf7y2E6CnAkCRJkiRJkqR2Bgvqv/wa/H0puZPdPv+q/ZO/C9d/MAQMz/wp3IpLYbc5IWSY+VYYNXnoPstAZDLwwm1wzzcg8WJ4bWw1vO07MO2g3GdMroHUJqAk18wawvdQOS087q5sVGfZhs696dwnoSEBLSmIWe5IkiRJkiRJUv8YLGhw9LU+fyoJbXmlf0ZNhlN+AW88Ayv+Da8/HEKGl/4ZbkTCJP1eb4O9T4aqmWFCv7UZWrK3VFgF0NKcez1aDvGdwrZ9bbxciNceCoHCsifD8/JxcPQlcMiHoaSs47aZ9vtoWcdm1oWUHko1QMOasKIhPiHX7LlxA5SPKex7z4YM9lGQJEmSJEmSNAAGCxocfa3PH4uHyfL8q/aLimDMLjDjzXDKT2B1Lbz4D3j+Flj1nzB5v+zJ0L+gOAatqYJOVQbcTIw3qCJ63V4wrhrGTIcxM3K30VOgqNASScCKZ2DBN+GVe8LzaBze/Ak44pNQFIVNq0OQUDEh951UTIB0vPtVCalkxybN+dKNYbVDSxOkmqBifCjBlA0o+vS920dBkiRJkiRJUv8ZLCinr+WMBnr8/Cv6o3GIroDURmish5ZGmLRPuB32cVj7Krz2ALxyF7z6QNehQnFpWA1QXBr6FRRHw/ka3qCMFNUsh1eXw6tdjK10NFQfATsfCbscCZP3g6JuVjg8+IMQKkCY3J81D47873CMomguBABIkhcWxHtpZt2+CiHduGWwEC2H2ChoS0NJNHyX0Xjff6vOpZEkSZIkSZIkqY8MFkayzhP9fS1nlK+QfXvbZsxOkG6C8vamztltYuUwftewqmD2B0OfgGQiTLRXToamBogUhQn3+ITcZ2uf0G9KZ/j4lTcwiQTfmFtOtGFl6HewYSmsfw3qV0DzRnjpjnCD9qDh8LygYd+wouGBK0NzZoDd5sJRl8CuR4YyRdlQIBsCZAi3zWFBF585f5VCtLxj34l82cbKqQm5BtCWNJIkSZIkSZI0DAwWRrLOk9MDKZNTyL69bROfADt1M7ne+Wr+llRYndDSAiWlYZv8ffKvzM+0sDwyheVMoXXf2UTLK3LvJdfAppWw/BlY9yosXxjKLTVvzOvvQAgaJtXAksfD8zd/Ag48J4Qh2XMn17SPqxzGzgifNftaxeiuP3O6MZyrYS2MndZe2qiHXhDZgCHa0H1YIUmSJEmSJElDyGBhJOs80T+QMjmF7Nt5m3T+1fq9jCH/av50I5SNhqaNodxRUUnoOdDThHy3YyqHojLY5QiYeWIIN9paQ++ExffCyqdh5X/C5P/mUOGTcOj5EB/XMcxINbWXKWqf8E83hl4QLanwONuoOlsWKfu4YS3QAuuXhXABuu+1kJUNGAox1CWuJEmSJEmSJI0oBgsj2XDX2083hkn8/LJH3YmVh1v+vvFx4XF3zZC7kj0fQHJdyCKiZaEEU6x9m6LiUP5o6oHhnMUxWPUsvP4IFMVg16NDiaNop/GURKElDaPKc+NKN0IkFVZbNNZDeWXHlQaxeAgT1i/LhRKpZOjREBvVfXiQylux0Nt3Z9kk9UE0uYoDpxRRvn4RLC/a4v1ISyt7ZF5lA92swpEkSZIkSdIOz2BBQ6unq+V76imQ3TfdCCWdQoXOIUN3+2WP27gp915Rce686ezrJVBSAsn1HVdPpJugpSkEGDsdEG4ra2H90tDvgalhu1QynDNSDGMndQwNYnFItZdJam2EjY0wZlrH8WbDhc0rMpLh9Z4WYGRLQ+WHBd191wMpcaWRZf0S9llwLgs/Ngru/xjcv+UmpcBPgSZKYcMcmLjLVh6kJEmSJEmShpvBwo4s0o/SQD3JZPq+T09Xy8dGhVt30k1hhUFLE5TmbdfdBHqmrf2cjZBpDfcQjrF5G6ClOTR7phham6BsVDhXSTT33oYVIXiIlkFLReixkD1ArDzcby5xlOxY8gg6rjSIVbT3UsgLODqnBrGK8Hvlf0+Z9s/a1SqDrsKC7r7rvpRN0siWXENxaxMfuDHJl3/we2r23nuLTZpbWvn+NX/mC5mf0dy4Bthlqw9TkiRJkiRJw8tgQUOru6vlC6n739W+6SSsWxpCAOhm0r29b0GEsNohUpx7L/EiVE4MQUXFhDARX1QSztGwNlyOvbmsUXEIPvJXVIyZBg3loafD+qXQuDaMYcw0SNeHEkalXZQwipaH1zN0v3IgGwwUlYRjtrVAQyLXWDv/s3ZVxsqVCRoktavbaBw7E6bO2uK9TKqFJZFHIAORxCIoKd7yAPniE0Izc0mSJEmSJO0wDBbUf4WEA931cSik7n9X+6aSuV4Go3var33VAkB8fN6Ym8N9tkdCfkPo8srwmTKEkklVe+Qm6VN55ZUm7Rleq18WPkMEqKjK9UboamFHIasGOgcDqWRYBdHT99T5N7CHgrqzfkkoydWTxKKCDrWB0TRRStkt/9X7xtE4XPB4l+FCbW3t5sdVVVVUV1cXdH5JkiRJkiQNL4MF9d9AmgLnT6IXElBssV9x+0R+N/vFykMppFh5x4n+qplQ0b4KIdsDISvdGCbyS2K5VQz577W1dGy8XDkNittXL6QaQsAQa18J0VkhzZY7BwPROMSSPa9CyP8Nss8L+R41sqxfAj89NNe/owetxWUkkht73GZ1pIqPFH2H/zt3X0p7WrGQWAQ3nh8Cjbxgoaqqing8zrx58za/Fo/Hqa2tNVyQJEmSJEnaDhgsqP8GUnonfxK9IVF4QJEtC9TWEkoXlVd2vV/+8VMtudfHTIXSaNefJRbvvqF0V69XTGgPESLhMxRnA4kuViZ01Wy5w/vdhCS9rULI/w0GEvRox5ZcE/7GTrs6hGs9eH7xCpZ89eReD7k6UkVmygEQ6/v/Rqqrq6mtrSWRSABh5cK8efNIJBIGC5IkSZIkSdsBgwX132CV3slOikOYoO/tivvs9hXjc8+hfXK+fZVCd/sn10JkdPdhSOdVDPmvQ15z5s5BRjeBROf3C1l50JfvtPNvYI8F9aSq674J+dIr27bKUKqrqw0RJEmSJEmStlMGCxp+2cnxvqxcgC0DiFR7X4VUY+71dBKSm/K2aQhXWPdn8j3dCM0bw0qJsdM6HiO/h0K27FG0PPdabz0WBqPxsj0WtK3qpXdD+fpFzKiMbKXBSJIkSZIkaaAMFrTtKHRyvbur+/P7KmzeNq+JM0BruvtVBfnH3xwM5JclKg+hQkm059UHWwQQvTRtBkMB7ZjiE8Lf9Y3n97hZDVB7wSgWJ1dtnXFJkiRJkiRpQAwWNDy66ilQ6OR6dwFEd/s35TWirdyp9+Ciu5UJsXh43lPJIwjvbVgOmRZoWFNYsLDFGPrQ0FraVo2dARc8Hno89ODVJ+9g14XfoiS1YSsNTJIkSZIkSQNhsNBJa2srxcXFwz2MHV93qw4KmVDvy9X9LY1hgn/zvoWsVkiGMKJs9JYrE3rrtQAhSIiPheZN0N/qLjZi1o5i7Ixw60HTqBe20mAkSZIkSZI0GIqGewDbkueff56rrrqKxsbGfh+jubmZ+vr6DrcRJxLp/RaLQ1EXvQ7yJ9T7fN6iLW8ZIJPpuA2R7m/pRiiOhWCgNNvkuYtt2lraw4VukoOKKhg1Kdz3R3ffT4fPW8D3HLFuvSRJkiRJkqTBZbDQ7umnn2bfffelvr6e8vJwVXsmf0K6QJdddhljxozZfJsxo+crdUesWEWYdO98NX4hE+p9Map9gr/gccWhJZV7HI2HFQwNiXBf6Bij8a4/X6EGur8kSZIkSZIkDRFLIQHPPPMMhx9+OJ/73Of4whe+sPn1TCZDJBLZfF+ISy+9lIsvvnjz8/r6esOFvhjsJsbROMRjfds+Fu9YhqhzWaLBGKM9FDRY1i/ptYcBiUW9Hqauro5EIkFtbe0gDUySJEmSJEk7qhEfLLz44ovMmjWLCy64gMsvvxyAH/3oRzz77LOUlJRwyimncNJJJxV8vNLSUkpLS4dquOqrdBKSG3vfLl/n5tDdNYsu9PxdBQj2UNBgWL8EfnpobjVNT6JxiE/o8q26ujpqampIJsNx4vE4VVX9LOMlSZIkSZKkHd6IDxZWrlwJQFVVFStWrOD9738/kUiE0tJSotEoJ598Mj/+8Y+54IILhnmk6lJvV/5nJ/D7cozOKxIGskKhuwBhIGGFlJVcE/5+T7saqmb2vG18QrdNlBOJBMlkkvnz51NTU0NVVRXV1dVDMGBJkiRJkiTtCEZ0sJDJZJgzZw433XQT73rXu/jhD3/I8ccfz5VXXsn06dNpbm7mBz/4ARdffDGHHXYYBx988HAPefhtayV8ervyPxaHdOvAjjEQ3QUIg13ySSNb1UyYOmvAh6mpqWH27NkDH48kSZIkSZJ2aCO2eXNra5hszmQynHLKKfztb39j+vTpXHjhhUyfPh0IZY3e+973MmbMGF5++eXhHO62I38SflvQWyPlHsq/FHyMnnRu7NzV+W3CLBWkbNPrsPzfPd/WLxm+AUqSJEmSJAkYgSsWVq1axeTJkykuLqa1tZXi4mLa2to4+eST2XfffZk4cSKQa9xcVFTE1KlTmTJlyjCPfBuxrZXwGYwr/4ei1FFfbGurQKStrCU2hoZUhl0XfgsWfqvnjaNxuODxbss6SZIkSZIkaeiNqGDhhRdeYP/99+ekk07illtu6RAuAB1qikciEQCuvvpqWltb2XvvvYdlzNscS/jkZAOBCFBW2f/j9CecyA8jYhX9P7e0DUjHJ1Pz003c8dc/UtPTf2sTi+DG80NvCYMFSZL0/9m77/C26quB419NW/Ie2YkTZycQEjIoIaQQ9p4tlDYUKKMtLW1pGQXSUuBtKS3QAi0tq9AWyt4bQkgIBAhkkQRnDzs73kOyNd8/jq41LMnyduLzeR4/UuSrqyvpXvNwzu+co5RSSimlekyfSSzs3r2byy+/nGnTprF27VrOP/98XnzxxRbJBcPSpUt54okneOaZZ1iwYIFWLKiWPC6w2qWNUryEQKqVCO2pAolMRmhiQR0EymqDuHM7Z1aEUkoppZRSSimllOpafSaxsHDhQgYOHMjPfvYzysvLue6666KSCz6fD6tVPo7S0lIWLFjAqlWrWLhwIYcddlgPH30vEari6Pb9BYOd95peN6SlWF3Q2uu2lhBItRIhtgoklc+lt7WkUp2vukxW5idTvqF7jkUppZRSSimllFJKqQh9JrFw9tlnk5GRwTHHHIPP5yMQCHDDDTc0JxesVmtz5UJRURGXXnopV111Ffn5+T196KozZxBU7wD78M5Z5Z+oLZRxvND+odCtsWdopcLBrLoM/n5E4qHgkVIZUK6UUkoppZRSSimlVCfqE4mFQCCA0+nkrLPOAsBqtXLmmWdiMpm4/vrroyoXHnroIU444QRGjRrVw0etmnXGgGSD1db17YOM4zVbIaOw615HHbxcFZJUOO8RKBybfFtngc4bUEoppZRSSimllFLdqk8kFsxmc4vH0tPTOf300zGZTFx33XV861vfYujQodx///1s3ry5B45SJdSZbX/SsjqvgiBRJYW2KVKdpVBnDiillFJKKaWUUkqp3qdPJBaAqBkKBofDwemnn47P5+Oiiy4iLy+PL7/8kuLi4h46ShVXopZD7eEsALutc/aVqJIi3vF2ZjsnpZRSSimllFJKKaWU6kF9IrHg9/uxWq1s27aNt99+myuuuAKbTYLL6enpzJ8/H6fTyeLFi5k4cWIPH61KSW8I1MdWJiQ7ps5s56TUQaqkpASAwsJCioqKEm+YytBqbRGllFJKKaWUUkop1WUO+sSCUamwbds2xo0bx0UXXcSPfvSj5t+/9dZbLFq0iEWLFmlS4UDSGwL1sZUJyY5J2yMpQ3WZzFBIJpXA+UGksLAQp9PJ3LlzAXA6nZSUlLRMLjgL5Np66crWd2pzwk+WanJBKaWUUkoppZRSqgsc1ImFyKTC1KlTmTt3Lg899BAmk6l5mzlz5vDRRx8xcODAHjxS1Wa9MVCf7Jg6s52TOnBVl8Hfj5DqltbYnBJI7wOKioooKSmhvLyckpIS5s6dS3l5ecvEQu4wSRakkph56UrZThMLSimllFJKKaWUUp3uoE0sxCYVzjrrLB566KGoOQuBQACHw4HD4ejBI1Xt0hsD9b3xmFTv4qqQpMJ5j8hg5mT6WCufoqKi5O2PDLnD+tTnopRSSimllFJKKdUbHZSJhciZCkZS4dFHH20xvNlsNvfQESql+rTCsTB4Sk8fBaWlpc1VAkoppZRSSimllFJKpeqgTCxYLBa2b9/OIYccwoUXXsgjjzyCxWLp6cM68AWDrW8TOcDYntH1xxQposVVwscTbdOW/cVK5XNp62sr1cVKS0uZMGECLpe0ZXI6nRQWFvbwUXUyHfKslFJKKaWUUkop1SUOysSC3+/nrrvu4qKLLuKf//ynJhW6U+QA4+5OLCilUlZeXo7L5eLJJ59kwoQJFBYWptaKqJsYVRTtOi4d8qyUUkoppZRSSinVpQ7KxILFYuEPf/gD2dnZ2u6ou/XGocpKqYQmTJjA1KlTe/owmhUWFuJ0Opk7dy4glRQlJSVtSy7okGellFJKKaWUUkqpLnVQJhYAcnNze/oQ+iZbD7RAUqo3qC5LLZCtkioqKqKkpKR59sPcuXMpLy9ve9WCDnlWSimllFJKKaWU6jIHbWJBKaW6TXUZ/P0ImTHSGptTWvX0kANhYHNRUVGvasuklFJKKaWUUkoppaJpYkEppTrKVSFJhfMegcKxybftwWHBB+rA5g7NW1BKKaWUUkoppZRSnU4TC0oplUxbWhwVjoXBU7r8kNqrtw9sjtUp8xZSkUqLqh5MCCmllFJKKaWUUkr1NppYUAcOrys8GNqmw6FVNziAWhwlE9v+qLcNbE4k2bwF4z1BByoZnAXyvb10Zevb2pxw4X/B2UqFhyYglFJKKaWUUkop1QdoYkEdODwuCPjkVhMLqqNSrUQ4AFocxWME3vfv38955513wLU/MsTOWygpKYn7ntpVyZA7DH6ytPXzwFUOz14MT57f+j41AaGUUkoppZRSSqk+QBMLXSwYDAJQW1vbw0fSCULvpVUmU9e8rtcHHjfYHeCP83kmeN1Gjw9fowQga2tr8dg7+bQPBkPVFKFjS5T06OzP5SBgXBfBVs6t5uto46eQmdHxF3ZVwEtXgc/d+rZWB+QeCplDW9+2l1znZWVlzJgxA7db3p/D4eDFF1+ksLCQgoICcnNz2/03qcuvpwTS0tJwOBzNbZGM91RRUcFVV13Fu+++y7hx4xg4cCADBw5MfcfmHMjMSb5N5ki4+ANwVybfzjivHjuv9de1OuC8hzulyqW2vgFo/TpSSimllFJKKaWU6iymoEYiutSOHTsYNkxXpSqVTFlZGUOHJg7c63WkVOtau46UUkoppZRSSimlOosmFrpYIBBg165dZGVlYermFeu1tbUMGzaMsrIysrOzu/W1u8PB/P4O5vcG4fdXWlqKyWRi8ODBmM3mhNv3xHV0sH8H0DfeIxz87zMYDFJXV9fqdaSUUkoppZRSSinVWbQVUhczm809voI0Ozv7oAymGQ7m93cwvzeAnJyclN5fT15HB/t3AH3jPcLB/T5zclpp56SUUkoppZRSSinViXRpo1JKKaWUUkoppZRSSimlUqaJBaWUUkoppZRSSimllFJKpUwTCwextLQ0br31VtLS0nr6ULrEwfz+Dub3BgfG+zsQjrGj+sJ7hL7zPpVSSimllFJKKaW6iw5vVkoppZRSSimllFJKKaVUyrRiQSmllFJKKaWUUkoppZRSKdPEQgJayKGUUkoppZRSSimllFJKtWTt6QPoTfx+PxaLBQCTyUQgEMBs7ljuJRAIsGvXLrKysjCZTJ1xmEodNILBIHV1dQwePDjptabXkVKJ6XWkVMeleh0ppZRSSimllBKaWAjZsGEDf/7zn6mrq6OgoIC///3v7fofy6amJpqampr/vXPnTiZOnNiZh6rUQaesrIyhQ4c2/1uvI6XaLvY6irVr1y6GDRvWjUek1IGntetIKaWUUkoppZTQxAKwZs0ajj32WE499VTS0tJYuHAhN910E3feeScgq9hSXd155513ctttt7V4vKysjOzs7E49bpWaRo+Pi/7yAQBPX3s86TZL8id4XeBxg90BNmfqL9RQAQEfmK2QUdDy97pCuIXa2lqGDRtGVlZW1ON6HfVeLa4neyv/GfE0tO96MsReV3odtZDoOopl/P5Av47afA4qlYJUryOllFJKKaWUUqLP/994TU0Nl19+OZdccgn33HMPjY2N/OpXvyI9Pb15m7a0jLjpppv45S9/2fxv439Us7OzD+hAzoHM7vFhTZeAZnZ2duuJBdr5PTms4HGB3Rk/gKoB0YRirzG9jnqvFtdTa0HdYAeDdLHXlV5HCbX23yrj9wf6ddTmc1CpNtA2YUoppZRSSimVmj7/f+P79++nrq6O733vewCkp6fj9/t57733+Oyzz7Db7fzjH/9g8ODBKVUupKWlkZaW1h2HrnobW4KEgmozvY5UM72ulFJKKaWUUkoppXqdPj+dLicnh8bGRh588EEqKiq49dZbeeKJJzjllFM46aST2Lt3LyeccAJer1dXsSmllFJKKaWUUkoppZTq8/p8xUJubi433HADf/jDH9ixYwcfffQR//73v7nwwgsBOOecc5g6dSovv/wyF1xwQQ8frVJKKaWUUkoppZRSSinVs/p8xYLNZuOKK65g1apV3HvvvYwcOZKjjjoKkKHNXq+XQYMG0b9//x4+UqWUUkoppZRSSimllFKq5/XJxEIwGIz6t9VqJS8vj0GDBmG321m0aBEgA/yefvppTCYTY8eO7YlDVb2N1wUN5XKrlOo6eq0ppZRSSimllFJK9Vp9phXS7t27qaqqYuLEiQlnJVgsFkaPHs3f//53Hn74YYYMGcL777/P/PnzGTx4cDcfseqVPC4I+ORWB8oq1XX0WlNKKaWUUkoppZTqtfpExcLOnTuZNGkS8+bN48svv4y7TTAYJDs7mz//+c+cf/75DBo0iOHDh/PJJ58wZcqU7j1g1XvZnWC2yq1SquvotaaUUkoppZRSSinVa/WJioUNGzZQU1NDTU0NDzzwAD//+c+ZOnUqAIFAAL/fj81mIxgMMnz4cH7xi19gtVoJBAKYzX0i99IzYlpStYvXJSuaDXZny9XNka8TDEKCipWU2DPkJ9H+k0l1u44cn+p7evK8CgbB0yDXYLxrLx7jmo3dPvb44l1rbT22VOj1ppRSSimllFJKKdVmfSJqPnnyZE477TQuvPBC1qxZw7333svatWubf2+z2QB44oknKC0txWqVfEuilkmqFzHapTRUhNumKKW6T2TLoq7YXimllFJKKaWUUkr1Ogd9YsHv9+P3+1m3bh2nn3468+bNY8OGDdx3333MmjWLCy64AIDFixdz5513csstt+D3+wFNLBwQjHYpGQXaNkWpntDWlkXa4kgppZRSSimllFLqgHfQt0Iym83069ePGTNmsGbNGs4991zS0tK45JJLaGpq4sorrwRg9uzZXHfddZx44olYLJYePmqVMluK7VeUUl2jrdegXrNKKaWUUkoppZRSB7yDvmLBqDqwWCwsXLgQgJdeegm/38+wYcNYvHgxS5YsAeCqq66iuLi4pw5VKaWUUkoppZRSSimllOr1DvqKhWAwiMlk4rjjjmPLli1cffXVvPXWWyxbtoyVK1dy/fXXY7fbmTp1Kmlpadr+SCmllFJKKaWUUkoppZRK4qBPLBiJguLiYi677DIGDBjAG2+8QXFxMcXFxZhMJiZPnkx6enoPH6lSSimllFJKKaWUUkop1fsd9IkFw8yZM3n00UeZPn06hx12WHMlwznnnNPTh6aUUkqpHlJaWkp5eXnc3xUWFlJUVNTNR6SUUkoppZRSSvV+fSaxYLPZuPTSSzGbZayEtjxSPcbrAo8L7DrEVnUBPb+USllpaSkTJkzA5XLF/b3T6aSkpESTC0oppZRSSimlVIw+k1gAmpMKqhN5GsJBTHtG5+yzswOjXnfH99Gu103wPjwuCPjkVgO/qrNFnl/Gvzvz+kzE64L6cjABGYW949zWJItqRXl5OS6XiyeffJIJEyZE/a6kpIS5c+dSXl6uiQWllFJKKaWUUipGn0osqA4KBls+1hVB8th9plpdEu/4ABoqUtuusyV6H3ZnONjZkcqZVN9HRz+/9u6vr+mp7yNW5PnVFddn5HG5KsCUJfv2uMBTL4/b2hHI74rzT5N4KkUTJkxg6tSpPX0YSimllFJKKaXUAUMTC6pjIoOYvXWfnREHT7TyOdmK6ETvw57R9avH1cGlLSvvY4P6kedgZ6/gjwza251gz5TrrTP/HnREV/x9UkoppZRSSimllFKaWFAd1J6VyW3ZZ2QgtL3BeEd+x48p0crnZCuiu+KzUX1T7HmWaoIgXpKhM1fwm63hoL3NCXm9rF2MXoNKKaWUUkoppZRSXUKHDqjeLbZffMrPa4CGcrntjNXKdmd0ELW1x5WK5XWFz8m2ij3P2ntddPb56izQwL1SSimllFJKKaVUH6QVC6rnpLLquq2tTDwNMqzZ6wKLXe7b0tr+urESrXzWFdEqVZHJgLZW38SeZ+1t8RO7HyPZEQQyUxi47HWBq65tr6mUUkoppZRSSimlDjqaWFA9J5W2LLY2tkDyumWfQWRlts3RvtftbJ3R0kkd2Dqz339nJbQ8LmgKJQo8KezTuHY6Q2fPe1BKKaWUUkoppZRS3UYTC6rndGag1dMQbgtjtkJGVjiA74kIhHpcEtA0AenZ8pgR4Iw8rs4KdBr79rjAam/fanV1cDCSAaYUpokb53NXB93tTkjLkkRcvOswNvhvd4LX3/p+U0kaVJWBqxychdB/XIfehlJKKaWUUkoppZTqXppYUD2nM9sIGSupzVbIKEy8nasSgi6wZ4Zf23iuuxYc2Z1byWDs20TXzWKIDeJ2xkpwXU3es7qrqsbmhNw4A5fjJcSM69WWQmIhlWHTPjcEfXIbj56DSimllFJKKaWUUr2WJhZU9+qqYKFR/RCv9VEkE7I629soveXtzojnpktyISO/848rPbvrKhVig7idEZTuiXZRKqwzq3nayuuCqh1gtYHZ0jIh5o2o7vG6wdvU8nqOPf5451POUGhwRl9vkX8f9BxUvURJSUmLxwoLCykqipOUU0oppZRSSiml+ghNLKj2a0+SoKuChfaM6P0ZQ5xtDiBieLMjH0yZ0ceRYQytLYegH6p3yHvLSGGYbWu6Y7hzbBC3M4LSPRnYVi3P5/Zq7zVqtYHPC3kDws+LbRlmPGYJhh+PfK3Whk1nFLasLooacN0N56DOPlFJFBYW4nQ6mTt3bovfOZ1OSkpKNLmglFJKKaWUUqrP0sSCar/2JAnaEywMBsP3EwVKvS6oL5eKBGdBeIiz1w02e8TrO8CeJQmH5sRDaP82BzRUAgHw1LchKRBsfZM2bBaVFEn0OXlcsk28IG7sv4MpvnBk7397hgZa26o3tu6JvEat6ak9x5Yu50ymQ54TDMjjTQ3SuigYcZ543GA3S1WDUeUA0ZVDQULnYFBuE52PJlP034dE11+q53MqohIZrZzvwWDnfsepzNpQPaqoqIiSkhLKy8ujHi8pKWHu3LmUl5drYkEppZRSSimlVJ+liQXVfu1JErRnBX8q7VE8LkkGGK8BydsaGS2QYh/LHQINFZKgsDligvztDLTHJgFaE5kUiTzGhgpJfBjvSdvE9C69sXVPVAItgtcVmjeCnE/xElNel5xzkUzW6ESd1QY2oyLIB3VVMgw6lqtCrk97JuQk+Wy6o8InUlv/hvXG71h1qaKiIk0eKKWUUkoppZRScWhiQbVfVwQB4wXyY9ujNJSDzwP2iOCe3SlBSyMh4HXLIOY2vXYoAZBREAo0muS1moP87UwsGImCVIORscFg47hqdoLZLMmF3CEtEw+qZ/XG9lGRlSdG5QFIpYGRiPM4Wp6XXhdU7wKrFRrr5daWCblDweMLb2e2RiQtrJDVP/5xBGNuY3nbmHwzntPR6gFbG1sg9cbvWPWYeLMXQOcvKKWUUkoppZTqGzSxoHqXqNX6oYBfvPYosYF6mxPyhrXcF8jK7Da/dkTgMLbyoT1VDG0ZCh1bTWEcly1d2tBk5GtP+N6ou1fbt5fXBT43mCyhf7vlsagKIDfgg/pqsIYqEuJ17nHmgz30nxEj2RVvgHpGAXjjJDAijyngb1slQCrVA53dnupA+Y5Vl0o2ewF0/oJSSimllFJKqb5BEwuqe8UOgDWC80awHmJWQZPaINhYRnC+oUKCjwZXJXgtEa/tDFcExHttiK588DRA9c5wL/lUg/ttrZ6IZFQw5Axt30rp3tj7X3WtRMmvhgqo3ArpmVLh42mUuQked8w15oBaH1isMmfBmS+PJROvvVjUMbnlmJy0PA9tzvZV4LhrJGmR8DW1dZHqfIlmL4DOX1BKKaWUUkop1XdoYkF1LyPQ564BR064MsFVAU31kJYJuUUSGG0oj18VENUDvjwcjPS4Wg48tjnAVR/+d8AHDTUS6DcCmUZFgNnaMkgZ25bI65akgs8rw22N143dJvI4jH20t31KawHb1mhwtW+ITM41VMZPfrmqZGhwY71ULHgbwGeBzJgWRjYnOHNDcxEcyYP3rfG6JBnnrZeqG1tE5YLXFa6WyCiMfk4qyTBHTvLX7qnWRZrMO+jp7AWllFJKKaWUUn2dJhZU93PXSHAxsjogtge71w1NdRIgzRsaPzjncYW3saWD1d4ygG93RlcgmK3hlkQ2Rygp4JLV1HaH9JuPen5GdGDW2FdmRMLDSEw0VIC3MSKg64xOOnRXu5ZY2he+e/VUUNk4D+v2gacO/H4YODF6G1s6NFZD1kD5d9AvCQZPKCERebzOfLA6WlYqGMmLSMmSa15XKBlnkSqJyNcwWiB5XdHXWSrJsFTO655qXaTJPKWUUkoppZRSSh3kNLGgup8jJxTgj1ihbAxMjkwC1O2D9KzEwTm7M7wy24TsEyTAH1kxYI3YZ2RPeI8roq2RCSxxEhMtXjMm0QDhigSTp2U1Q6oJklSDkJEB3FTbMGlf+O7VU0Fl4zy0pkt1QHpm/G3yhoHJGk6ked3x2yElEplY8LgBS3R7MIieVWLsMy3e8ThbzncwEjMmID1JC7HefF5rMq/XKS0tTdi6SCmllFJKKaWUUm2niQXVdh1ZkZ0o4BYvYJ/VX4L0iYJzNqdUHzRUQkaWJCeMmQqRCYJEveEj2xpl5IeG2noiZi8kGdIc9TtjngOhY8kPv0+PC5pqIS07eYKktSCkkVDwuiISIDq8uVfqiqByKteccQ3ZHPJjIlSVY5yr6aFkQqg6xwjMV++AqrJwFYPBE0o4NDVIcs4Umt4cmfxzV4LLA/jAR3RCzdjOeB1XubQ7a6iCjLzw75wRCUaQ9xn0gdcHB+op3puTHn1QaWkpEyZMwOVyxf290+mksLAw7u+UUkoppZRSSikVnyYWVNt1ZEV2qgG3yJZD8VYzGwFWIwjpcUliwVi1DeHKBewpvEY6uIhOShitZYwgfmQyIep3oeOo2SmtZbzpQEEocWGH9LzkcxIiPxPj/cXOijBeL0h0Cynt5d77dEVQ2UhQNVSE5x0k+s5jk3RVZeCtA1sm5MapmvE2SqKhqQH2roWdy6FiE1Rvh/KNULUFCsbAD94NJy0MQULJOSB3SMtzFsKvZ3NKUsFqg5pdcmvLhNzYJGOoEinog6odiSt9lEpReXk5LpeLJ598kgkTJrT4fWFhoc5LUEoppZRSSiml2kgTCwqCwda3iQxgR67INlYxt3V/smHiX0UG4oP+8ONNDRJgb2oAa5qsyjZ+gkSvjjZ6t1sjEgtBwO+T+xa7BE5f+ZEEUrMHQ9ZgyBkqP9lD5LZglLRkaqqXY/E0gK8R6veD3w3uKqjYCpWboWGfbDd0Ghx7sxyDM1dezxNaLZssSGokbeK1ZHLXSjVE5CBd7eXefimfpz30up76iOqC9HDbr4ZKcGSFroH01vdnCoZvgwG5H/DB9iVQ+hns/goqN0FNGfia4u9j7xr49AGY/avwPkBai5k8oZkjcRJhRqWExy33naFKBb8nNN+BcMLOuOZtDklS1OwEiy2caAu/odQ+v0RiK5F66jxQ3W7ChAlMnTq1pw9DKaWUUkoppZQ6KGhiIcLevXvJz8/HZrO1vnFfExnAzuzXtW14jLY/Bmt6uJ2RzQGuSgh4JVjpCA2YjQo8Et273ROxL3cFWEKByfVvwXu3yHYA1aXyUxbnmCxpkmSAUPKgLvl72PklFB0F408L7XuX9L23Z0FekpWxRtIm9v14XPL8Gnd0NUOqbXe0sqHjuvszNFoRedySTModHEo0hH6fqMWXcayuKonBW9Plx2KDLYvg61dg3ZvSxiiWNR0Kx0DhOOgX+qndCe/cBJ/cD4ecB2n9wtvbHXJONx9zxLVrVNZ43KEKBatsm5EfrvoxrmdvPXgz5TFXpSQscoZEt1SKfX/t/S5iK5GUUkoppZRSSimlVJtpYiFkxYoVTJs2jQ8++IA5c+a0ez9NTU00NYVX/dbW1nbG4fW87hxGagT+3LXgyA4HKo0go80RDgxm5If7xrvKwxULke1oXHvD+w74obEGvnwElj0uj408Fk76PTSUy6ptI8FQUwrVZRJY9TdJRUIkqwOyBkhv+syBkD1IbveugdXPwwe3w9iTwO+FpmqplEjLIimbM34g1YRUSVjTo6sZjPfpdcnxJwq0HmCVDb3yOursz7C14LhxXoO0QLI7oqtVvK5Qu6/0OO2N3BKsD/igYjNs/hDWvwmuivA2zgI59/tNCCURxkNuEZjN0fsKBmHNS7DjC3jvNzDr10neU2hYud8riQG7E+rLJang80GGI/zejPfXWCXXpT1Tkgr+Jrnmsoe0bAlm6FA7NkfihIVSSimllFJKKaWUSokmFoBVq1ZxzDHHcO2118ZNKgSDQUzxWv7Eceedd3Lbbbd19iH2nMjgZ2a/1rfvKGPgsQlJGoAENiu2yOptZ6GsZo4NDHrdofkGEYFGrytcjWCoL4cFN8P2T+TfR10Dx94CZgsUjo3e1vjK/V6o3SXJhqAfsgZJMiEtO34rqMZa2DRfEhErnoLxZ0JaZiiw2s4Boc4CaeNkDOSN1VqgtTsTQ52gV15Hnf0ZtvadGUmjhopw5ULkdtW7pALHUQCFo0Lneygpt+1jqUrY9pG06jI4C2D86TDxHBh+lFQVtBDTGshkgpN/D4+dBBvfxTT2TCA//vvxuqB+H5htksQwWhv53IA3VCWRH6628Lol2ebzybEZFQsEW7YEa6gIVzMY3wUkTqglGr4eb1C8UkoppZRSSimllGqTPp9YWLNmDUcddRS//OUvueOOOwgGg6xfv56dO3dSXFzMyJEjMZlMBAIBzLEreeO46aab+OUvf9n879raWoYNG9aVb6FzJFo9HRn87IpgnCe06tpEOLBotUvA01idXV8ugVVfk2xXvQ3q98KwI8K920H6tvsAm9HaaKf0pDdLEHNycC1pL1wHdbvkPZ55nwRYW2OxQd5w+UlFejbM+gXMvxUW/hGKjpbe8llZ7V/pnmz4s/H7ZEHvrhgo3IV65XXU2meYSnueRLNKkjFW9se2PvI1SqLL1xjat1v298x3YP+68HbOAhh/Bkw8O0kyoRWDD4fDLoCvnsO2+C7GBq9ig2lUzHtzy9wSq0MqFIz8hN0BXkdoZkR9aFtH9CDoDEf4M8koCLdUikyiGdUMDZWSoLM5JamQKDnT3pZHHW15pW3HlFJKKaWUUkop1Qf06cRCU1MTN910E42Njdxxxx0AnHHGGezdu5fly5dz2GGHMX36dB599FHMZnNKlQtpaWmkpaV1x+F3rkSrp7t6pbvXHQ42Gm2AIgOKRoDRZAWzHz7+Kyz7l/zOYodBk2WWwYjZMPDQ0D5DiQWrDXxesKZxTeAxzgh+AHVA7gj49hMw4JCueU8AM34AXzwCNTvgs7/BKX9oX5DR45KV30Ek4HqQJA5a0+PXUXuCw6m054ncxgiOtybRd5s9CFzp4eHgNgeseFKSCvZMOPT8UDJhViiZ0MEhxXPmweYPMdeW8Vd+yyumU8AzE+wRr+91Q87g8L8juWqkndL2j6VCaMLZcOg5YI9T/RAvkebMD1csRG6X7O+TMfA8UqJKhubfJ/geUz0nDrC2Y0oppZRSSimllFLt0acTCzabjZtvvpmNGzcya9YsMjIySEtL45577qFfv368++67PPbYY9xwww386U9/Srkd0gEpUYCuswPWUcG50Iple6a0SvGGhhZH9ZF3S8VA7S5Y8LvwSuzMAVK1sOML+VlyH6TnSBVD8bFya8uGyvWkvXMLZwRlIrNv6mVYT/itvGZXsqbDCb+DF6+ANS/AtMtg6LTWn2d8PkZvea8bmkKJl9aqFlTnaU9wOJUkXOQ2yQLVXhc0Nchq/0Svn1EQWt3fIMknk0mSWQDH/xamX57acacqexD8cBH+t2/BUvIy5wffJvjIbDjxNhh7Svzzs3Y3lLwh8x1KP5WqIsOGt+H9eTDp2zDlIhg4Kfq5kVULRiVDRgHhHmW0/vfJkd3yMaOSoaEy3GoplWRqqufEAdZ2TCmllFJKKaWUUqo9+nRiwWw2M3PmTJ566im+//3v09TUxGuvvcbgwbLiduTIkWzatIklS5ZQX19PZmYXB6N7UmcmEJIFTI3gXIMxaNkBecOkHVJsT3WQAP2KJ2HRH6Xli7MAzrwfxp4MlVtgy0LYugi2LpahzBvflx+AjP7QsA8TsId+3Gu+ittP+gXW7jrrJ5wlq8W3fwIf3w3febr15xifj6si3OIpLVMWm7d32Ky2Zmm79gSHU7mGIrdJ1sbH44o/VyGS1xVuBRb0wcqnoW63zACZMjf1426LjH54z/oHv10/hmsC/2Jg7Q548XI510+/GzL6yUyHdW9ByauweSEEvOHnF4yWbX2NMuC8YT98/g/5GXgYTPkuTPqWXOcNFTKA2pbZviB9oiHNNodUPrgrIRhKPBgD0I3vPN4slFTPiYOsekgppZRSSimllFIqnj6dWDBMnTqVp556ir1799K/f38AAoEA6enpDB8+nMWLF6c0X0GFJFvZ63FJ9YEtHbLs0YkEo22JsVLZ0wBvXw8b35PfjzoOzv6bVCsAFIySnxmXy+vtXi2Jhi0LYcdSaNgHSJXCD1fOptGU3i1vv5nJBCf/AR6ZA+vflgTI0BnJV6kbg6uDyHsyWyF3WPgzgbYHWbU1S9t1R3DY7pT5ISZP9NBx43dGxUIsI6HgqgJ8Mvi4sRaWPyG/P/pasHZtG6kvTVP4oflPvDhtKdYvH4aS12DbYhg0RW4DvvDG/cZLMmHi2dBvXHjg+fG/hU0fwKqnYcO7sOcreOcreO83MPoEGHcKDDoc7BEvbFwHxjUQeS3FJtASDWm2Z8g+0rOlVVpWxL5SGaatlFJKKaWUUkoppfpmYiF2VoLJZOKwww4DaE4gGLcbN25k8uTJ2Gy27j/QA1Wylb3eRnk8EAgPkW2okJ+gX57nccGm9+HD38uqYksanHArHHElmBIkeMxWGDJNfmb/SpISO76AzP74csfSuOr9rnu/yQyYCNMvgy8eg7dugO+/Ko8nSroYg6tjV1tHDaJtY3CztZXWUQOFu2BAtwprEfx2xg9m25xSrRPv+dW7ZDiyr1FuCULpYln935XVCjEaTen4TrgD6+Rvw+s/h71rYMuH8ssBh8gMhYlnQeGY+Duw2CR5MO4UqdBZ8zKs+h/sXiVtkja8Dfkj4TvPhJ9jXAee0ByVyM/O44KmOmlxlDc0fhLAmK8AkJYFmRGtprSFkVJKKaWUUkoppVTK+kxiYffu3VRVVTFx4sS4sxJiKxIqKyu5++67efXVV1m4cGH3JBaCKQ5X7alZD6kenzE7QZ4U/buMfCjfHPpVIFyZ0FQngb7GSvjkflj7kmzTbwKceR/0Hx8OCCZiiVjabLHC8Jly3xPR193vkbYxqQikuF28AHCkWdfCmpegfD2sfg4Ou0gqNoKB8DZel/wEgYyslqutbQ4Jvvo80UNnU2lz1NpK68iV2gdDYqGzr6NU95dsOHJzFU4oedTUIOeNLT3U7ijmfEh0fN5GGUru94aHJHsaYNkTcn/Wz8FiiX+OB/ypvY3qsuh/b/tYEnrDjwodQ8Rx+rww4FC47B1pbdRYDWNOlkoig99Lq9KyYfql8rPva/jqOfmp3AL/+zZc/BLkDJXztLFWBjhHJd+C4RZHVlviqgMjMWG2tmx3lEpFQirX28E8i0cppZRSSimllFIqpE/099m5cyeTJk1i3rx5fPnll61u/84773Dttdfyn//8h3fffZeJEyd2w1H2ERkF4MiDNGeolUuIIwdc5fDC5eGkwhE/hCvel6TCgcyRB8fcKPcX34MEQSOCksYq9IA/OmlgMFZZB5GgdGSCJTIp0F52pwRa+8pKba9L5ht4Grr2dTwuCdJXlUlSKOCTNlcmi/y+oUJuMwpSa7HjCSWfTBbIGSLnisclrYTq94aqFb7becfvbYQFt8Nbv4I3r4VP/94y+WGw2OS1j7w6OqnQHv0nyuDzy9+H3OFQvR3+ex7U7JDfp4fmIhgDnY1KA69bEg5pWYnnkdgc4Yqg9uiM600ppZRSSimllFLqINAnEgsbNmygpqaGmpoaHnjgAZYvX978u0AggNcbvaL20EMPZfbs2Xz00Uccfvjh3X24B7+MfDCngTNPfjIKZZXy/y6Eys0ydPmiZ+Hk37deDXCgmPxdGDhJBkx/cFv07zxuWWXt8yboqe8OB6Vjg6KdkRSwhYbVHgzVCqnoruCw1y0zFGp3yndstspQ4owC+X3QL483b+8KDSxOcFxet1Tl2EMtlLxucFfAl4/J72f9vPNmK1Rtgxd/AOveDLcfW/EfeG+etGDqDjlD4OKXI5IL50LlVqk6ik0MNLcKi/nsPA3RSSR7RuJz3Ug4Jfr8oe8l4ZRSSimllFJKKaUS6BOJhcmTJ3Paaadx4YUXsmbNGu69917Wrl3b/HujzdHjjz/O9u3bGTp0KD/4wQ8YOXJkTx3ygcPrgqpSqC5NHpAzGMHc3CGhdiZOWPc6vHgF+Nwwcg788CMYfXzXHnd3M1vglLvk/sr/Qdnn4SCy3QH2TMgdnGBorCMiKB0TFDWSAvEGQbcWJO2ruis4bHNIWyJrmnzHRuse4zs3WaITSR53y2RD8+9CLXgig+o2hwT+m2crdFK1wsb34IXLJMnnyIezHoDjb5XPbPMH2N+8hpxgbee8Vmuikgul8PJV4K5u+d0Z14gx9Nyo6omcTdKaVBJOxvUGen0ppZRSSimllFKqTzvoEwt+vx+/38+6des4/fTTmTdvHhs2bOC+++5j1qxZXHDBBQAsXryYO++8k1tuuQWfzxd3DoOKo74candIcDOVFeBet8xTqNgENTvh83/Cm7+SFitTvgcXPd2y93lvEAxCxWao29P+fRQdCYeeDwThlaulSsPjDgUrk7TDSbbKGuInEbRlS2LdVaFhd0LBaMgtkqRQ8+DhmO/cqFSAlskGQ0MFeOslcG4E1Ss2wrLH5X5nVSt89Gd4/zdyTIOnwoVPwpDpMO40OPN+SMvCvG8N9wZ+R1awvuOvl4rI5EJNGTz/fWiKSWzYnZJcMBGeQwJta33UloSTXl9KKaWUUkoppZTq4w764c1ms5l+/foxY8YM1qxZw7nnnktaWhqXXHIJTU1NXHnllQDMnj2b6667jhNPPBGr9aD/WDosGBpi+unHC9my7ivGjj+EGSdPYMmSJaxbV8KE8RM46ihjeLIrPGTV5oCGSpknsONLmB9qC3T0L+HYm3rX4NOAD3Yug43zYdN8qCmVyoJLXpdgcXuc8DvYsgiqtsKz35PBziOPg9yh4RY5bRUZ5DSSE0bfeW3Z0rOMtkUGr1uSVA0VoSoGZ7hSwWSRc8BINEQ+17gsTMjzlz4C7/8W/E1QOLZzqhWWPAAf/0XuT70UjrhSAu2GIdPgvEcJvv5zhtbv4deBByBwKmDp+Gu3xkgu/PssadP0zk1w9t+jtzFaRRnJAWM2SbK5JZG/S2V4s0GvL6WUUkoppZRSSvVxB33FglF5YLFYWLhwIQAvvfQSfr+fYcOGsXjxYpYsWQLAVVddRXFxcU8d6oHF42LjhnW89s57rC6t4YvNFVzzqxu49NJLeeaZZ1i7dk3zdlTvlCoFr1sCcblDZAjx/N9CwAvjz+w9SQVPA6x/C964Fv7+DXjmu7DsX5JUAPDUw9s3Jh5i25rsIXDVh1A0U/b14R3w71Ph5R/C16+GW7bE9oZP9BjEX2mdqEVSX9MTLaE8ocRA7Gp2Y9gwRLc8im2LZCQaItv3OAtk9ojNCa9eDe/cKEmFcadKoquj1QpfPAYL75T7R/4EjvxxdFLBkDcCz0l/ppE0prMa6+I7O/a6bZEzBM75u8x8WPk/KHldHjeGZLsqwq2ijL87DfvkNvaaiW2R1NbzRK8vpZRSSimllFJK9XEH/dL8YDCIyWTiuOOOY8uWLVx99dW89dZbLFu2jJUrV3L99ddjt9uZOnUqaWlpvb8FUqhSQFYz9+CwXbuT7aU7yOw3nNLd5ZwyeRqPP/kMwWCQ3bt2ccghh4aON2IwcWZEe5JFd8lQ27wRcOZ9PZNUCPikX7urEnZ+ARvfh+1LJGBrSM+FUXNg9IlyrE99C3YshS8fhxmXt+91s4fA91+Fzx6E5f+VXvZbFsiPPVPazow+HoaFKj6M7zkyGBo7Z0EDnPHFq+boalHfU4LXdNeCLT3cAimS3RFOOjRUhFbVO6FuNzz3fWmhZTLDcb+BWT+T1+qIVU9L+yOAWb+AyRcl3TxYMJp7TVdyc/BvWJc+CEOmwMSzO3YMqSo6Uto+ffwXeP0XMOBQ8PskSWdLl+/Y7pTPzWqDuipwZElyIXdIRHWCI1yxAD1zniillFJKKaWUUkodwA76xIKRKCguLuayyy5jwIABvPHGGxQXF1NcXIzJZGLy5Mmkp6f38JGmKDIA1hWJhcjERbIAm9XB0LGT8diyOb+4mHGjhnP8UVP5ZOkyph85O9wGyQjcZTrC7UM+f0hWG1vscP6jkJ6d+vH5GuGje2DPagkkWtIibh2h++lya00DvxdrXTm/CpSQHazD/uTd0FgJ7iporIn/GrnDYcyJMOp4GDI1euX2nJvhvXmw+G4oni1taNrDbIWjfgYzr4E9X8Hal2HtS1CzA1Y/Jz/2LBh7srS5Kf6mPM9dCxn5cj/V7ypSe55zIOvqljVRn6cjPGTZBKRlhbeLbAcG4MiG+r0yN8HvhbRscFWFB3jbnJLwaqqDun2w4S34+F55vYx+cP5jcv511NpX4M3r5P4RV8E3r5dzsBWLzEcxOrCNC4JvwBs/l1kSAw7p+PGk4thfw+YFsHuVJBfO+KsMR7dlRs9WAPkOGiolydBQGd3+KPLvZ3vPk752PSmllFJKKaWUUkqFHPSJBcPMmTN59NFHmT59OocddlhzJcM555zT04fWNl0dKE22cjcyiGZ1MH78eMaPH8/yFct59cVnmHvRBfzxzj+AMz/6eCOPtWxpuOXKibfDoCmpH5urAl68QuYetIEVOMn4x+7Y35ogPQfyi6UqYcyJUDBGKijirQQ/7DtS2bB1Ebx1HXzvRbB2ICllMsGgyfJz/K2w88tQkuEVqN8Da16Qn9wiOOUuGHx4+Ln15bJS254JeSnOfOhrK7O7upoj6vMMrYK32lu2poqqYghVJFjSAb/c+rwS/DYGO4Psb/OH8NFdMuwcYMTRcN7DkDWo/cfsdUu1UNnnMquAIEyZK+dfGyqHHjd9h/OLarFs/wheuBR+8B448pI/KeCXAcwZ/dqfGLXY4dyH4OFjYdtHUPKqJEWMzzsyiWPPCM91aawErw2wRlcvdERDOTTVQ1pm++euqE5TWlpKeXl5i8dLSkp64GiUUkoppZRSSqmDW59JLNhsNi699FLMZhkr0StbHqVyTLErbZMJBlvfxkgWGO1WolqEBKODdEZw1OMCqwN8bvC42FyyGneTl41bt3HotKNk/kDQFN6/8Xy/F17/eXiuwmEXSmC8NY01ULkVXvuprKZOy5LV/tY08DWFf7wNcutvAp9H7lus+Ow5/Ht1gBqy+OkJI7HnDJQAqCNXVoqbY4bPNoUqGXye+MdzzI2wawXsXQuL74Hjf9v6ewBoqm19m37jZMDzcb+RwO/Xr0DJG1BdKm1wjr4WvvEjqdwwEf4JBkOftatlMD30PTUneRIlplI5X9qip66xVF+3M95v1Odpirl+Io4j8nFrulw/tvToa8tVDSa3BKt9jbDwj7Dqf/J8R54E/iddIO/P2xjed11MtszvleB93W6o3Q21u6BuV+h2tyToIo09FY76qSQbAPauTv6efQBOAiYz3uNuw/LiXDk/X7gMzvqbXE8BP9TugIotUL4BKrfIwPKq7XJ92pzyfkYeG95v9uDUPnOTGQpGwQm3SmJk0V0w5iToF6oeaqqXGRXBYPjvmNcNFhs01kN6Zqg1Uqg6xGROnHBLNgAa2TUEQ7dtlOr51xv/W9ULlZaWMmHCBFyu+HMynE4nhYWF3XxUSimllFJKKaXUwavPJBaA5qSCimAE1Ix+8JEVBh4XlG+SIJ2zEDILo4PSoeeOG1VEyfZ9jBgbCuy5KkNtiZzS3sVbD9YMeP8WGYKcNwLOvD/1gFnZUnjzl9IWJmeoBC/z4wzZjhx2G8HnDfDc2m0AXD1iBDg7uFI5o58kF967Bb78l/SXHzS5Y/uMZbbA8KPkZ84tMkx6/Vvw0Z8koXHGvTLQ1/icQZIKAX84uWAkGrxuWeXtcXXdwNm+2hImNomTKPEXOScjGAg/r/m7c4PVKsH/sk9hyQPgrpTfTfkuHHtLdCVQIuUb5Fqp3dX6cWcNkiHiM6+W4Hp7pOfAGX+RpFfpp/DSFXIeVG2LnlUSyWSW8+WdG2HqpVJtEJvcS8X0y2Hje1LV8fwlcM6DUtETO6PCF/psfcjfDVeV/Du2OsRVEUomlocfi6w0MZlanuOZheBxdl0FmUpZeXk5LpeLJ598kgkTJrT4fWFhIUVFWlWilFJKKaWUUkp1lj6VWFBxGCuuI4eYGgH6hkqpAgBZfB0RCA0GAvLc+nImjR/NIVOPxGxNJ+iuJBjw01RbhQsXTl8T6RYTphX/wbTujdBchcdkroKnrvXjW/28rEoO+KRt0hl/SS3A2tXGnARbPoRN8yXof+mb4c+ws6XnyGf25WMw/zZY/6b0lz/vYQkMG4xkgnFbvVPa65gs4PdI0NTeRS2Q+lqLpfZoDlIHWn5GNgeULYOP/gh7Vslj/SbAKX+EYUektv/ST+GtG+SatTkge6hUAWQPliRC5gDIHiT307I7byV84Vipsnnn11LJY7CkSSA/d4Tc5o+U28wB8Onf4atnYPkTsH+dtEVLtWLBYDJJgvKR46RV1GMnwaHnSyVE9iCpAAn6pJrAniVzXmzOcOLBHnG92jPC309DpczAiKwmMeZnxJ7jOji915kwYQJTp07t6cNQSimllFJKKaUOeppY6OtszuiAuBFcq98rq9+xSJDOWRD1NJO/MTyk1mLH7HVhMtopNdXj8nnYtG0z+3du4/D+PoYuuV+emOpchWBA2gx9+nf599hT5LnWtM54153DaIlUsVEqCY6/tetey2SCGVfAkGnw8g+l9cx/zoaT/g9mXCm/jwxyusolqeDzQt6Arg/8d/XsjwOdpyF8vcTOIfA0wEd/hs//Id+RLUPOrWmXSvueVHz9Ciz4vVQXDZkOp93dcih6vJkhnWXsKVKJULMjlEAYCdlDpBLBF6dy4ehrof8EWPgHKPtMZjSc/zgMmNi2180aCFcugAV3wFfPwZoXYf3b0ipt8vfk75kzDzIi/n4lSgYYSQRjOHrskOfIigWllFJKKaWUUkqpPk4TCyqaEVyzpIM51AIpb1jL7TwuaU3UWAtWBzv3VbKj6iu27thDfW0NI0eOpK6uDouvkYIld4bnKky/IrXjWHQXfP6Q3D/iSjiyA+1aukp6LsyZB29eC188JquiZ17dsWHOrRl8OFz+frg10js3SuD2qGuit7M5QyutLaEqFJes3M7MjrvbDuvLK7e9LpmLEEQC2PFaIXndEvT3esER87z/XSDJKYBxp8HJd0rLL3+CGR+xNr4PH9wefv7xv5XKoO425qTWt4k09hRJQLxzo7Ru+u/ZMPdlGHho2/aTNRDO/rsk3t69BXZ8AYv+CCWvwXefjd7W6wpXK8Ser63Nr+nL57hSSimllFJKKaVUjF4WqVXdzuuCqjKoLguvxs0ogNyhkNk/eqVvJLtTVsOHVkXv3bsTanbwycL5bN9eyldffcWhhx7KIa7PcDTtlzYnZ96XWvuV2l3w5eNy/5Q/wsyf9r6kgmHE0dInniB88hd47ETYuqhrX9NojXTkT+TfmxdIhYIxU8EV0SPeapfWLhZ74vkHRoDb+PHGH37aYvvWtjsQtee9eVwyMNhTn3DOBwB1+6Q1j7GN1w0f3ytJhcwBcOFTcMF/JanQFu4quc0tghPv6JmkQnsVjoVvPQGDp8rA6nduaH9lxeDDpSXZuQ/LgPd9X8OOZdEtjzxu+Q6MGQzG9+1p6PBbUUoppZRSSimllOpLemm0VnUbj0sCok0xQVEjwZCo7YfVAXlDJYCXkc/AwgJsjgwOHVtMdrqVMQMyGZ3lY9T+92T7Y2+WgHgqPvuHrNYuOhImf6dj7687nHg7nP2gJGKqtsGzc+HFK2Dnsq57TZMJhoT6iPvc4aHNsQOczRawpYO7Nvzc2OC50SapoSLUBquVBENkW6WDTbz31lqywe6EtEywZyafs5HVH0zW8Db718GKJ+X+WX+XFfztMWqOJN6qS6F2Z/v20ZPSc6SlV1oO7FkdTiq2h8kEh54LE8+Rf2/5MGa4tkO+A7sjNIdkl1ReJUsIeRoO3kSaUkoppZRSSimlVDtpYqGvszslIJrWSlA0HquD7eUNfLJyPf6MgUw78hiO/ObxTJo4lt2lm5h/57ehsVqG0E66ILV91u6Cr0LtS2b9vG3H01NMJphwJly5EKZfLkHeje/Cf8+B/5wlLVm6or+9sTI94AslEEIVCX5PeEW2s1C+Y0dEC6TY4LndCWarJJLMVpkDkCxxYGx/MPaaN94bhIPJnZFIsTkkCZc7JPwdvX09EITDLpTkQHtl9JO5CgAb3m3/fnqSswDm3Cz3F/9ZZjV0xMSz5LbkNWgKJdVi2yB53GC1SuVVsr99xtyZgzGRppRSSimllFJKKdVOmljo62xOmaGQO6xdgeIdO3bQ2Ohmx75KcBbg8kJe4QBKN67lxAGhFi3H/UYC36mIrFYomtnm4+lRaVlwwu/gB+9JIsVil+HOr/4E/jkLPv8nNNZ03usZiQW/VxIIxspsT2Oon39M4sD4fmP/bXNCRqH8GI/5PInPB2P7g7HfvPHeIBxMbi2RkkorJHtGeL+uClh8N+xfL9/bif/X8eMeF6p22HiAJhZAqpOGHiGf4XvzIBhs/75GHA2OfGkTtXmhPBbbBsnukLkoGfnymonaIdkcLb//zmoHdjC3FVNKKaWUUkoppdRBTRMLqkOGDh1KWdkOvlq1inm/+Q333HMPny3/iu+N90rP9KKZqQ91PRCrFeLpNw5Ovweu/gxmXSursWt3wcI/woMz4f3fQuXWjr+OJU1uPQ3hwKSrItTaqjYc+I9NBCRLDHhcyecx9BWRyYTWEimptkICaTe17RNY8oD8++Q7wZnf8eMddTyYbVCxCco3dnx/hoBfztu3fy2zPPzeztt3LJNZZqpY7LD5A1j3Rvv3ZbbChDPk/qb3Q23C3HL89pjvyBuqSGktKRT5/XdWO7CDua2YUkoppZRSSimlDmrWnj4A1Q4dWclrtHaJChwnGagctX1kQE6OYfigQvLsPuqxsOqLJQzKdZBdtZoJthWy2ZxbZJVwvEP2NUX/e8nfpFph2BGhYa6h3zfWtnxuPL7GBO8h4sWb6sGX4v5SrbJo2J/4d2NOhOJjYOtCWP8WlG+A5f+B5f+FkcfCzJ/AwEnRzzESBq2x2OQ24AvPVAgC9nSwZbYvMWB3hr/vjkrlPO3IudyefUaez/aMxNvZM8K/b+0YbU4ZnNx8kifbPgAf/UnO89EnwPjTwN+UYNMU22cZLbCKj4HN82HTfBg0ueV2u1aktj9/xOvuK5FkBcDK/8G6t7CMPgVb8FS8Jhvs+LL1/4qYU8xf2zNkTsmMK+CzB+H938j7iJ3NYk1xOPWEs+Ra2/AOzJkn14vfKxULHje4qqQVkskaaiXmSPxdG4kJ4++m3SmzSEye8LXXViZT9PWWymB7pZRSSimllFJKqV5CKxb6mraukG1te6+bUcXFZDtsHP2NaRTmpHNG9gYIBmDcaTB0emqv46qANc/L/Zk/Te05BwqrXao2vv8afOsJSSgQlMGyz86F+n3t3G8oARHwhQObGQXScz+jILxdqu1WvC4JlnZ2W5be1O6lu1eIe1xSpWC83ro3YX+JVDeccmfnBpONFfrr3+y8hI0xgDxvBKTnQmM1tjXP8HjgWs4IvN81FQzTr4C8Yvmb8PFf27+f4tnSDslVAbtXRs8PMZIKPp9cK85WWnt5Y84bI7lgsXfsXLJnQGa/5EkupZRSSimllFJKqV5IEwt9TVsH77a2vc3BoYdN5oxzLuCaX97IjT84jwGuEmlrcuxNqR/X2pclSDlwEgz7RurPO5CYTDB8Jpz7EFz2tgy19jXKqur2iBzebHOGVlWHgpxeF7jK5ae+PLVguscFnjpoqku+bVsTBb2p3Ut3D542Bv963VBTBgvvlMfn3AzZQzr3tYqPlfOgdhfsTrE6IZmAXwLyABPOhhPvgMO+QzA9l35Uck3wcdIW3AJbFnZugsFqh+Nvlftrng8nN9oqsh3SmhflO7CG5iU482S+Qs7g8LVTUwbVZfHPa1uc8+ZgHmKulFJKKaWUUkop1QpNLPQ1bR2828r2Lh+Uu4K4/eDyBODTv8kvJn8XCsek9hrBAHz1nNw/7MLUnnOgyx8JR10j91c9LS2a2qp5eLNHbr2hIcLlW+W2oUqCwybiB0BjEwR2pwRb07KSB0vbmijoTQHY7h48bQz+DQbh1Z/J/IuhM2Dq97vgtdJh9Ilyv6QD8wkM5RvkeO2ZUDhWWgmNPJamOXfwgOky9pOPqbEaVv0P3uvkBMPQ6XDot+T+/N/JMPH2mHCW3G6aD03Vcj8jP/xjzFtwVUD1TknEJUosxJ43B/MQc6WUUkoppZRSSqlW6IyFg03cGQpd8TpuaKjAXVXJgiUrWL66hGMGNXJabYmsCp79q9T3tXM5VG+XdiDjTuu6Y+5tRs2B/FFQuRlW/BeO/HHbnm+0QvK6ZYCzzSnJBEcm+LyQkSe/CxL/fIhMEBh9+vOKWn/dts5hsHXxudgbGNedzdFyVbvdCcv+I3M2LHY47W6p6Ols9XslSQew8T04/rdt34ffA3vXyo9R9TD48Oh5IxYbb5hP5N3gsbx8yLvYNr4FoQRDcNXTmOyZkJ4Nadlym54NaTnRj2UNDCfGEjn6WmkXVrUVlj8OR/yw7e/HaIfkroTVL8lME5AZC163fF8mE7iqJQFnsh7856rqFiUlJXEfLywspKgohb+zSimllFJKKaVUL6eJhYNNbLC4q16jfBO4K6ndW8OSRR9Q1Rjk8LRPwAIccQVkD2rD/kKr9TMHdm+v8YAfandA5VZZUZ43HHKGth7w7CwmM3zjh/D2DfD5PySpkjc89edn9g+3cdn+MYw5GXKHRK+4DiKtZeKdD+0d1NwXEgVtZVx3xoDfWJvel9sZV6ReyZOKYFAGKK98Sl7DGPicPTj1fdTtlZZHu1fCvq/DFTAgVQrDZ8V9mtdkwz/iWGzFs2D7J9Quf4lsS6O00/LUATsTv6YzX1orWZMMKk/PgW/eCO/cAF88Bod+W57XFmYrTL8MFt8DS/4KQT8ccyPU7JIZCyAJhfQssKbL9aPntuqAwsJCnE4nc+fOjft7p9NJSUmJJheUUkoppZRSSh3wNLFwsGlLsNgY1msieUsPr4v9u8uorHWRX1BAoaWRoKcBEyZq6+sZMWYiU3cvZJClWga8tnX4cv8Jclu1VY6pCwJ7zqCLYkqxrKuA6s1SJVC1PTqIChLszx4iAf68kTK0Nm+4PBa5ajsYgMYaaSVUv1duXRXhn5xhEkSOfE48E86S+RKln8L78+DbbZi3YHPCxHOkFc3alyWxYAT9XeXJ2yAZz0/ls+6uKpgDmXHdgQxrjqxcCAZh55dyf8xJnfN6Hhd8/Qos+7cMgzYMmQZTvgejT0j+/GAQ1r0u7Yvqdkf/Lj0XBhwCAw6FfuPlvSRjsVE/8EiK7/8vNr+LoblWXvrDlRTl2aCxNjS3o1aul8ZaaNgPrkrY+hGMOTH5vsedAsufkITH0ofh2F8n3z6eY38t7/fje+HTB2DkHMgfIYOb7UiVj68RHLnhpJye56qdioqKKCkpoby8vMXvSkpKmDt3LuXl5ZpYUEoppZRSSil1wNPEwsGmLavJjWG9mMLPiRdA9rioKt+Hzx+gal8jhYNyMAV8mLIHkT9qIDMdQ5j+2b/BhbRASs9p2zFnDoCMfhJw3FciwdGO8nthwzuwcxn2ii28HAgFT5fGbGdNh7xiaYdSXSrVEzVl8rPt4/B2ZhvkDpPtG8qltYqxOjyeXctln0dclfw4TSZZuf3vM6FsKax+XhISqTp8riQWSt6AU+tkPgKEKxnSCjpeBdIdVTAHmthki80pAfiqMvDWgy0znFio3Ax1e6QSZtgRHXvdqm0y7Pur5yRYD3JOTjhTEgr9xqe2n7UvwZoX5L7JIjMUBk+BQVOkXZHJ1KbDeuzlBVTWNgCwt8HL9/76AYseuxWz2QzmmLZPWxZJ66+N78HIY6UqIhGTGWb9Al6+ClY/C4dfDJn92nRsmMxw3C1SnfTVc/DZg3DOPyDDIRUm+KR6wdso1T3xkpteV7gaRa8B1YqioiJNHCillFJKKaWUOuhpYqEvM4b1mgivuE4QQM7PsFLZCHn9h7Bl29eU7dzL4JE2xk4+kqK974Frr6zqPyJxUDwYDLJ69RrmL/iQhYs+YtTwIdx7522YTCZZHb3lQ+nt3tHEQtnn8Pk/oWYHEJ5Qvp988oeOwZJfDAWjpCIhe1C4330wGBriuk2qGapLJZBbvV1WNFduiXkhEzjypD2LsxCcBfIT8Emw/+tXpLVSa3MjcofB0b+AhXfCortg/OmQlWIrqWFHQsFoqNgEX78qiQbo3HZF7W2ZdDBLdK2YYm5BVuaDJBVsRjC7jRrKZUDy+rfDj+UOh6mXyPnSlmTe1kXhpMLki6S6IfI9NNa06dC8Xh/3PvkWALdccS5/feotPl6xnkdfWsBV34pTOTH8KCh5HdxVUqlT/M3kLzD8KDnPyz6Dz/4O5z/SpuNrNvs6WP0CbJ4PNdtldgTIcOog4UHOxmfhdYWTDF4XNNVJNUreME0uKKWUUkoppZRSqs/TxEJfFm9Yr9HOpbpUgm2ZhQAUDi6mwGwFZz7Lly3H4wmwtWwvQ4btImPxvfKcOTfL6mlfU4uX8vl8XHzp5Tzz3PNRjx9/zGzOOPVEab1iJBbaq3o7fP4Q7PhC/p2eC4eejydvLN/9IJc6UxavHleIxRKI/3yTSVpCZRTCkOnhNkbBgPShr94mlRDO0DbOfGkz5Pe23JfZCiv+I6ujswaFg5iJHH4xrHsT9nwF794E5z+e2qpxk0lWqn9wm6wCPzx+X+82i7ciX4UlSrbYnLLyPfLz2rpYbke0EkBPZNsn8MbPoX4fYJKh31MvgZHHSFLMuGZTsWc1LA0F5iecJT8d9PKCLyjdXU7//BzmXXku/fKy+MWf/8MNf/0f3z3taDIzYz4jiw3GniTVA+vflhkOrbUMO/oX8PR3JCGx72voP7HtB1owCiZ9G756Fhb9Gc5/TJI8zoL457fXJe3EjORCQyVYbVq5o5RSSimllFJKKYUmFhQgGQRkNbXNIatyjYHKHmd4lbU1DQJ+iseMY/v27QwfPhzTx3+FxmppwXLot0KBuJYrsm+4cR7PPPc8VquVE+Ycw3sffEggEODF19/ijNNPhYGHyYb71kpQPlLtruSH76mXlcgb35UkgMkiwcpRc8CaTsAfpM4UahG0aznsW5HaxzLw0Oh/m0yhQci18lMVqmAIxElU5I+EgZNhzypYcIe0Nzrk3OSvd9TP4JUfwYZ3pdph/OnJtzdayEz6Niz4P9ixVAbwDpwUc9ztuMw7o/1RqomRztYV+4wVm2zxNMh1U7dbvhdruiSegoFwS60RR0tVjDfFREDtLvjyXzJHgaC07DrxNqlQMX4P0mYpFV+/Ii2Qgn4oGCPVNNs/brldnMRgFL8ZOFbuL76bN57fDMClU+ykf3oPPx0U5O5cGzuqXSz73x0cc8GPW+4jf2Tob81+aVk2cJLMJUnEkQcjZsO2xfDB/8G3H2/9/cbLVcz6hbQb2/iuVEv0nwBeU/x2YTan/C2zOeT3ecNaJpO6Y/5IMNg52yillFJKKaWUUkp1InPrm6g+x+YArDLcFCRollEgwVJgzOjRnHD88YwdkIFz9X9lm+N+k3DV8dcl67j/Hw8D8Ox/HuXtV57j/ddfBODt9z4gEAiEg/gVm1sPbBoCfgkQvv4L2PC2BHH7T5Tg4bhTm4+3R5hMMPEsyC2SNkorn2q9xUx+sbSmAXj/t+CuTu21sgaGh/WueCr6d163tNFJNZhtsDsTD31WLTVUQN1Oae/jbwq3Qtq3TgZp2zJgyNTU91e7C167BpY9AQRh/Jmywt5IKrT5+Mph3RtSXZM9GEYf3+4EzM6K+ub7wWCQBRvl3yeNl+SdxWziiCI5bxZsrMfvj5N4s9hh2Dfk/rZPUguMT7tUKjQ2fyDzSNojfyQcer7c//yfco4nG07tdYUSrQ2SOIgdch+ZgFNKKaWUUkoppZTqQzSxoFqyOyEjH7L6J99u0V0SNC86EsaclHCz626+Fb/fz9lnnMp5Z58JwNFHHUlmZgZ79+1n5VerIaO/BBuDAVnF3Jo9X8E7N8qKbk+drL6efrm0FMoobMu77TpmKxz2HVlt7a6SZIHfk/w5U74rq8ld5VLpkKop35PbtS9Fr2D3uqU3fNWOtiUX4gVRVTRPA1SVStswbyOY08CRD1lDpFrB65KEF8g1YrGntt9N8+HfZ8HuVfL5n/A7mHMT2NqZKPO44MPfy/E68iTp1lrroQT8/gCn/e7l5n9/sKGenTVe0qwmjhoRXvU/dagE629/dy/5Z/yWU657hM+/3h69s6FHyGfSsA/KN7T+4jlDYewpcn/RH9u/Sn/WteEERdX2xMPNvW5oqpeKqERzMTQBp5RSSimllFJKqT5KEwsqPpsDfJ7wit2GCgmOV2yFPWvh/d/IKnyA429NuPr53fcX8PZ787HZbPz597c1P2632znh2GMAeOvd+fL8zFAio35f4uMKBmVuwYe/h5oyGbw6/Qdwyp/av5q7K9kzJOhvTYe9a+Dje5MHRC12OPUuwCQDdo3Bv60Zc6JULrgr4auIORY2B/i84d7wXle4giHyvmo7r1uCzk31QFDOxfxiyB0qCQGPW9rtABTPbn1/viZpafXyj8Ltxb79RNKkXasCPlj8Z5k/YnPA+DM6VMnz5pdb2by7uvnf5zy2DYCjijNwWHzNibNLj8jnjEOyyUozU9vQyLtL13P2zU/Q5PGFd2ZLh6Ez5P62xaklCg6fK8e/40tJwLRHwahw1cLiuxNvZ3NAWqZ8r8mqGpRSSimllFJKKaX6IE0s9GVGYNkT6hPeUBFu6WF3yo/FDrU7oWEfprrdmNwVmL58FNPn/5TtvnlDODgYw+fz8cub5gHw0x9ewZjRo6J+f9rJ0r7nrfc+kAec/eQ2WcXCvq9h6yK5P/ZUOOM+GHNyu1dgd4uMfjDpAlklvfF9WP9W8u2HTINpl8n9926RKo7WWGww4yq5v/rZ8OM2B+QNhbSs8MBho3VLe9u4aEJC2BwSdE7LBLsDHFnh3zVUQM2OcMueESkkFt6+MdT6CPn+z31IVum3V8APSx6QygdLmiQV0rPbvz/ggdfjzyf5xZHp8neidif4GhmSa+P1K4upuvNQVjx2LUP65bC3so5nPoh5/rBvyIr/2l1ynK1xFkgiEeCjuztetbDpfWnF5GmIv50t1AYuUVVDT7dC0mtRKaWUUkoppZRSPUQTCyG7du3igw8+4JlnnmHbtm3t3k9TUxO1tbVRP72OEYyqL5egmNctP8Z9g80hQT9LaIWzJR0cBTQ3kM/oDzOvTvgyjzz+H74uWU9BQT6/+fV1LX5/6knHA/D5F8uo2L9PKhAgefBz3etyO+p46bmelpnim+5hBaNgyly5X/pZ69t/8zrAJG12XJWpvcbUi+U5+9fJ92uIbGsU2bqlvW1cuiGYekBcR/YMCTobg5xNVkkwALiqpAWVMQS937jW92ckzE6/F467JTycuz38Xvj4HqkEMFlg9q/CFUHt9HVpBfNXlmIyh6uT7jprEKdPzOK4kRFtniLafVnMJqaMGcJPzj0KgL88v5hgZDIgLRMGTZH7Ja+ldiBH/gjMNthfIpUY7VEwCgaHZl5UbIzf6ije38RYPd0KqflaTHKMSimllFJKKaWUUl1AEwvA6tWrmT17Nr/5zW+4+OKL+cEPfsCbb77Zrn3deeed5OTkNP8MGzask4+2ExjBKBPRw0vdtdHbeN3yu9yhkkQwerzPvhayh0pv9Pm3tdi94c67/wrA726+gby83Ba/HzpkMJMOmUggEGDtC3fKXAFHvqzYj6dqO+xaIW2TJpzV9vfd0wYfLreVm1rf1p4B6Tly351iYsGRB4Vj5P7OZdG/i6xOMcTOUUh19XM3BFMPiOsIwsFnCCcZAJx5UjFgMFuT7yfgk0QEwIijO3ZMviaZf1L6mbzuMTfA0Okd2ydw90tfAnDGjJHNj/3k6ELeuGokmemRFUMt26L98KyZONJsrNq0ixUbdkb/0ji20k/BVdH6gaTnhv9GpNoqLB7jOzFZ4rc6MhKrydog9fQskuZrUVs1KaWUUkoppZRSqnv1+cTC5s2bOf3007nooot4/fXX2bx5M01NTTz77LOtPzmOm266iZqamuafsrKyTj7iTmAEozIK5ccIEDsiKgUiV+vaQ+1AvE0QaAKfD07+vWy37ImEMxHqG6S9yJxvJm4D8/3vXkCaBUbvDVUiHPnjxENuS16V22FHyjyBA01BKCBbvy8cRE7GmS+3qVYsAAwJBWm3fSzPM1ZbG8mkhsrE1QYeV+JBzw3lsG+D3HZDMPWAuI6gZfDZmElid0C/MeHtTK38qW2sCd/vSLuiYECSCruWy3U05+aErcraYtWW/TzxwVoArj378JYbRL6/OO81P9tJXpZ8Rj5/TGuvzP6QM0yOfcM7qR1Q8Tflduvi1LZPxmpv2erI0xBOrCZqg9Qb9HRiQymllFJKKaWUUn1Wn04sNDU18c9//pNvfvOb3HzzzeTm5lJUVMSvf/1rFixYQEVFCqtnY6SlpZGdnR31021aW3Fu/B7CwSgjEArRAdJ4q3WduWBOk9tRx0H/Q4AgbP4w7ssN6C8zE/btTzwz4eorL+PXx+UzOCNInSlbBh3HU78PSpfI/QlnJ9xfr2bPhKxBcr9ic+vbO0KJhVQrFgCGhNq77FwmK+aNxEJzMik/frWBNzRzobEmPOg5UkMl+Bvlthv06HXUFvaMUHIuFHz2uCEYak1jTQtvl2piIS2r9eqGZDZ9ALtXyoDj434TbjPUQdc//hHBIFwweyxHjB3UcoOoxELLigWvz8/uCkmmFQ3Ibfl8o2ph/VvRlR6JGMOwS5dI26eO8HkkkdBQHp61EK8NktcFVaXSnkxnGiillFJKKaWUUqqP69OJhWAwiM1m47jjjsPpdGKxSDuPwsJC3G43Ho+nlT30Mq31vo/3e+MxCA0pdUa3QYoMQDvzoXCk3NocMPZkeXzz/LgvN6C/9HTfuy9xYsFp8XPjLOklf8v79VTWJjj2dW/IoNaBh0F+ccL99Xr5oQHWlSkkFjpSsbDvawnwNieKnOEKlXgrnD0uWbntyA8Peo6UkS8zNjLyUz+WvsjuCM9aiBq63TLYHsVdLbfpue1/7aY6WPmk3J98EQw4pP37irBodRnvr9iOzWrmj5ckqD6KSpy0fK+7ymvk763VQv+8OHNR+k+Q1l8N5bBjaesHNeBQaf3VVCeJlI6w2lsmEuIlVj0umZnRVJ/4b6zXBfX7Ew+DVkoppZRSSimllDpIdGBp7IEvPT2da6+9ln79ZGV9IBDAbDYzZMgQ+vfvj8MRDip98cUXzJjR8ZYinSLOimAgnBSwO2WbyCGpsb+PfczmoDkgGNUGKaINSOyq69EnwMf3SsVCMAjmUJ/1UCuj/kZiobwyfnsjVzl89g8cQTdbai08uKQK/u/33P/H30Vvt+0j2PyB3O8/AXYta7ErIGHlBAErcI3c//pVsFvibxdr39epbZeR4lDcopmQPxK2fwzlGxOvzDYC0o48uXVVxASpje2CLR/rN06SBp56CdI6C8K/M6oSjO/fuG8Mdfa4IDM7flsVIyEBic+/VI6vPdvEbt/aczrz+FLhaZDkTzAoiZeM0GdutLsymaOPKd73biSP0nPCv0/W2z/ShnfldttieU1HnswNMB43LH0otf0NnBT1z9seXwPAFUf1p9i7jsadNuBY+aXZCqagDFM2mG3RVReuCkpLpZXVsH5ZmBur4r/u8FlSsbDmJblOEskbIbdFM2X7TQsk0RDLktbysXis6fJZG0mFhnL5t3G+G2wOsGfJn8lE301k8jbyOkp27bUmlfM51XNeKaWUUkoppZRSqpN0qGLhk08+6azj6DFGUiEYDGI2y8fh8Xiorq7G7ZZA07x587jqqqsoLy/vseNMiT0DMvsl7gkerx+38Vjkc1IZWgrSviQ9BxqrYeeXLX5tVCzsS1Sx4KqAFf8BoH7SZfiD8OBjT7K2ZEP0djuXS7AuaxDkFiU/pt6uoA0VC+1phWS2htvflC4JzVkIra6ODHrGVq90Ra/2VIdB9/Q+O8rrBk8deOulBZLBSBC01gYJwq2Q2lux0FAO+0rk/vCjw0m+DvpoYw0fbqjBZjFx40lDEm/YSiuksv0yGH5YYZKWViPnyO2e1bLqvzXDZ8nt9k7475DR0gqiKxdiWyTZHeFKosjHDcbfztiKn2TXnlJKKaWUUkoppdQBqEOJhdmzZzN69Gh+97vfsXHjxs46pi4XjLNS2RQRDHO73dTW1mKz2bj99tv505/+xCOPPEJhYWGL5x1UjCAahINsUX3HQ/MYjKCu2RoOBm5q2Q4p3Aop/nBnvnhMAnj9D+Gws3/KOaefhN/v5xc33x7+jprqZRAtwLBvdP/K3GAAfI0S+K3fH/o8XPErCFJhtEKqLm29N3xzK6QEK7wTGTJNbks/D/X7jwhguiXA2zxzITYA2pm6IoDqcfd8UDY22GysZLdlSuDZYJwjKSUWquU2PaftxxMMShUMQTm/sge3fR+RvI3Nd297UyoN+mfaOPmBrymtbIr/nFQTC/2yEr9u1oBQ5UEQtiSoPopkJBb2fBU9/LojWgzjjqje8rqlIqR6Z3gIeuQMBggnKGITdJHXW+y11xuTZUoppZRSSimllFKt6FBi4fLLL6eyspLbb7+d8ePHM3PmTB588MF2DT3uart37+brr6W1jamV4HRGRgbjxo3j5ptv5g9/+AOffvop06dP747D7HrJgliuChmS7Ap9f1GBtHKo3gWu/XJrPH/0CXK76YMWuxs0cAAAny39Aq83JoheswNWPyf3Z/0MTCbuvv1m7HY78xd9wo2/+6MkF9a8CL4mWb1fOCb19xnwQdVW2Pc1tooSfhX4J1cGnsJStxPq9sj7aayRALXfI8FUdxXU7pLBynvWwP51sHettC2qLoX6PVC3W6oN9n4t29Xuhvq9knxIRUY/GeIc8Mk+kzFaIbnbeD0ZiYW9q8Hnle/K+L4coRXjXVGhEKurkhddnRBJxEgouGKCyvYMyB0GuUOjB6Ibn7kpheoBI7HgyG37cVVslHPQbIWiI9v+/Hj7q9jE7t17+HxLDRYz7KzxsH6vm/97uyxq0+2VTdz53m6ueXFH82Nvrq1rsct91fJZ5GS00p5o1HFyu3UR+H3Jt80eJImUYABKP2v9fSUTm1Q1KrgiEw02h1xPVpt890aSrq1irz2tYFBKKaWUUkoppdQBqEOJhUceeYQ9e/bw/PPPc9ZZZ7FixQp++tOfMnjwYM4++2xeeOEFmpoSrHDtRjt37mTSpEnMmzePL79s2bInltfrZeXKlTz33HN8+umnTJs2rRuOspskC2J53BLg9EQMMDUCaQ2VcuuuD/+7Zgf0myjb7l4ZTkiEnHXGaeTn57H26xLuuvsv0a+16C5ZsT/0iOZg6Kji4fz1D78B4M8PPMwLL78GK/4r2w87og298wPSFia0qtzSVM1JwY/4VvBNbHWlULFJkgZ7Vks1RNlSaeW0dy1UbpHkQWN1uKLAZAarQ1aTp2WFAsVBCRy7ymHvGmnH0lqiAOQ9GD3iW2uHZMxHaMvwZggnFio2yWdhsYd7urcWlO/M1dNdlbzoyoRIsvdvrF4PkrxVmMctlSJNoYqGVCoWjNY/ba1YCPig7HO5P2SaJK06g9fNINN+tv0ik7mHh9ukjemXDkBmsJ5DgyU8Mn89haZKrp8RTgLc+tZOat3RcyRmjB0EwNtfbolbMdZs8OHhocyJZqlEGtFJ7ZBihzcbjAoEe0YogTRE/gbYHOEknacBqsugqizx0OZkf3e7o3roIFJaWsrKlSub/71y5UqWL19OSUlJzx2UUkoppZRSSinVB3UosQBgt9s5//zzefnll9m9ezcPPvggM2bM4I033uDCCy9k4MCBXHnllZ1xrO22YcMGampqqKmp4YEHHmD58uXNvwsEAi1W0+fk5HDuuefy2Wefcfjhh3f34XatZEEsu0N6vBvtXIxAmtkiA1pNFigoluClCRkQ7EsQSEPmV/ztL/cAcPsf/shXq2UILFsWwtqXABPM+jl+v59Ply6nsbGJH/9gLvN+9VMA3nz0D9CwX4LIAyam/h7r9kgFgdkGecV4c0bymOk7PG86HZ+jnwQu07JkaGvzkFmTvI4zH7KHQMFoGSDbbzz0nwiFo2W+Q94IGSBdOFaqDyKl0h7JXSUBfwhXJCTiCyXlLLbk28XKGijzKIIBqNoS/r6TBfqNgHp9ee9ePW1vZe5HRyULABur1zPyW84liT1Gk1WuD2g9YFy3F9a9KfcHHNK2422qDydB+rfxuYn0Gw9ZAyl3myh0mvnHKRZ+9g07d8xJ4yeTPZj2fMWLgau4J3AHd59g5cqpdopywv8pufxwC79/b3fULs88cjQZ6Ta27K7ms5KdiV/bbJGWZxCeGZGMMTi9o4mwVOfKGImGjPzw9s0zNupaJiaan5fk7253VA8dJEpLS5kwYQJHH31082NHH30006ZNY+7cuTidzoO/ZaFSSimllFJKKdVLdDixECkvL48f/ehHfPzxx2zevJlf//rXuFwu/vWvf3Xmy7TZ5MmTOe2007jwwgtZs2YN9957L2vXrm3+vc0mgdvHH3+cbdu2MXDgQJ5++mnGjx/fU4fcdZIFsZwFkNk/vFIeJJBmc8pKapsDMgrkx5kvCYadK2W7QVOinxfynQu+xTlnnYHX6+Wyq36Mt6Ea3rlRfjnlIrZ7c5lz1kUcdcr5zDz5PHbv2cdN115N0dDBnDw41FKl/4SIBEAr/B6pOABpT5NRiD9jAM+Zz+JR8/fw5Y2W4O2gyTJ8uuhI6dU+/CgYMlWSCPnFEpy3Z0hQP16lRGNNuHWK2SrPyx3e+vGtekaSHoVjYUgr7bWMCoicdgysHjhJbss3SDDT4wq3RIq3It8IqJvo3aunuzr4mqj/vachevV6a8eYURCu4Mnsn3z7j+8Bn1tW6486vm3HGxkIb+/cj1gWG2T049I3giza5sNhhftOSWfeN9NwBhtIM0l1wl4KKW1II5ieB5kDIVNan/14up0V2yrYuC/cHiwj3c65R40F4KkP17Z8zUgFo+W2ckvrx1q7S26zkwyWTkWy7zZ2pkbs9s0zNrISJyY0edApysvLcblcPPrYY82Pffzxxyxbtoxly5ZRUlJCUVE7/l4qpZRSSimllFKqzTo1sWBYsGABt99+O3//+9/xer2tzjToSn6/H7/fz7p16zj99NOZN28eGzZs4L777mPWrFlccMEFACxevJg777yTefPm4fP5mpMNivBq3sjV4jYn5AyFnUvl36PjB0RNJhP/uP+v5OXlsXzFSjY8eoW0UMoZyvP7RjJ59mks/vQLAFau/pojTzqX7WU7+evvfsk54yWZsNs6LPVjrdkpAVZ7hsxlSIXJlHqbJW+jzFao3wsEpfJh2JFSIdDaPur3wro35P60y1rfvibUzz63De/fMCCUWNizOnoVfqIV+UZAPaOwbwRAjWBxbIIlUf/7RCvRo/YXMVfB64Kq7XI/trIlUlMdfP2a3J9zc9uHk1vs4fuBVmYStEEwGOSz7S5O+5+LSn8oeO7I490yB3P+6+E88yN833I//YeNwpRRKNdBWjbBNGkP9PAZ6cx7Q85fr8/Phh0VfHu2JGqf/agEr8+f8LXJHym31WXg8yQ/0LpOSCy0Nh8lXpukyGSDMWMjb1jrSSfVKcaPG9d8f8qUKUydOpWpU6dqUkEppZRSSimllOpGnZZYWLVqFddffz1Dhw7lxBNP5IknnmDQoEH83//9H1u2pLDytIuYzWb69evHjBkzWLNmDeeeey6/+93vePnll1m9ejVnnHEGALNnz+a6667jjjvuwGq19mgypFvEW7neWp/x2GBzUy1sXij3jSHOcQwcOIDrr/0ZRw61MKHhUwAeLB3LBT+8gZraOo6cfjjzX36SMaNGULpjF7NO/RYTraU4bCbWlfv5+b9T6LUOEuRzhaoIcoraHqRtTcN+aWPkc0vf/JyhUqVgbWUgrWHFfyHgleqOwVNb374mNBA3Z2jbj3VgRGIhchV+opYs8VZUe11SNVFV2jkzF3qTVAfmGp+XsRI93up1kGsm6AvPJ/G4oSZUcZKRpGKhfCMQlBX/Aw9r+/swmaTlF3RqYqG0somKBh9NfnD2HwEFo6mwDOCC/5WzuCxIgyl+AN2U0Q9v0MKIXDPHDPZw2B+/JvPcexh3xcM88vYq+uc6Ka9x8/7yrYlf3FkAadkQ9EP19uQHWhNqq5Q9uH1vFGReTKLZCIbYQc2J/lYqpZRSSimllFJK9REdSizs2LGDu+66i0mTJjF16lTuuecefD4f11xzDUuXLqWkpISbb765R1cRGgkCi8XCwoULAXjppZfw+/0MGzaMxYsXs2TJEgCuuuoqiouLe+pQO4+nQYbBJgsGxwusptpn3LD+fekt7shrta3P+WeewmNnpWM2Qe3wU/jJX18B4LfX/4zFbz3H8cfMYsk7LzJzxlSqqmvY+aG0unhytY/nF61l4cpWklPBoKxwBqlUSOukIbYGV6XMbjCqFArHyvtONXnhqYdN8+V+KtUKEK5YyGlHxYIRpN6/TmZjGEmDtrRk8bhkRb2nrvfOXGivVAfmGp8XSELBVRk/oGwLzVVonk/ikHkVkLwVUkVogLfR/qc9jDZhnZhYeL+kGoAjRmSRbpP/TPzx3R3UNvo5dEiSVfkmM7acgQBcPcNOod2DxyvVCW8s3cTJU+Xva9J2SCZTuGohWTukYBBqjcRCByoWLJbE1QgGY1Czoa1/K5VSSimllFJKKaUOMik2ro9v+HDpKZ+ens4FF1zAxRdfzMknn4zFYumUg+sMwWAQk8nEcccdx5YtW7j66qt56623WLZsGStXruT666/HbrczdepU0tLSerZSIRjsnP1EJg0SDer1uKSffnpEwMyekbyVR2QPd68bNr4j90ceK8FA4/fG0NoIY/e8Cv0s7K0P8PJeCaIOKMzntqsvgIa9ABRaYf6//8QPfvpLjh2+Nbzvj97l5ofeYMkfzk58bDU7JAAO4K6EHZURv0wD45TctRz6pTALAaAwNGPDVQF7QoOnC8dC4bjoxMCh57a+ryUPyOczYjYMnpx8W7NFzgUjsZA3XB5rIcn5kjNEBnE3VsP+Epkp0aqYc9/ulCRKkN47c6G9jPPcSJgkTbQE5XxvqoPGWkkoZWTR8vMPyvcWDILVIdUpIK2QIq9tf8Sw+PL1cps/MvpxCM/waI0tXaponPmQm6S6Zewp4fsBH2xfIn8LbA4YekQ4SL7hHd5dIZ/LycM8sGc1dU1BHlwk19dtswI8aOynehvQsl1RuQsKnfDMtxy48g7hyic3Mr+kkkKzrPx/bcl6vFs/w2aNyG0b7btAkmm7V0pFx4jZ0Ts3KoTcVeHkaf6I1CuHYllD77uhPDyM2UgeGTMUvO7oayDe30rj76oxKL01qf63xjh3ku2/s/7boZRSSimllFJKKZWiDlUsHHPMMTz22GPs3buXp59+mtNOO61XJRUgXLFQXFzMHXfcwcsvv8zrr79OcXEx5557LnfffTc33HAD6enpB0/7o3irsSNbH3lcYLWHV7Ank2jYr9cNe1bJ/VGJ2yABsmp+6cMA/OStRur9ks+qqK7B54teZe10pHP/96diNpn4aLuP4086DZvVzKfr9/H5hn3x9x/ww+5VyY+hvbwu2PEFEISswS2TCqmo3AI7l0v7pBmXp/achn3ga5LntGc1tskUboe05lWoKku+vSfB92xzQuZBOnMh1XZIIMFlv1cScUZLKY9L5ip4XKFgtD965XtTqH1OshkLFZvktmBU+9+HJdQKyd/KPIJIZisMnREOmu9Y2nzsXn+Q9zbLdXnqGLlWn1vrxeWFcQVmThrVej76qdVetlUH6J9hZoStnDEDJHiflW6hINNGfZOfL7fXJd5B3gi5rdqWeBujVVhGP7Cmt3pMCRnJVSOZEFuNYLSCg/jXiKEt51N7JNv/wdaqTCmllFJKKaWUUr1ehxILCxYs4NJLLyUzM3Hbma1bt3LppZd25GU6xcyZM3n00Ud59913mTZtGsHQCs9zzjnn4Gh/FCleu5vIoFRs4iFR8iD2eZEa9oWDoqPmJD6WYADemwcBH8vq+/NiiQ+Px4vDkY7P52fbjj0tntK/ejkAT37l5dFn3+CioyXoet+ba+K/RsXGuFUSHRbwQdlSCdimZcPgKe2b27D6Rbkdc2I4YNoao61T1uBw4LitBh4qt/u/hn3rJQhuBMJjGau0I3/X1YHSnpZqOyRj25whUsFhBJwjV7bbHFJVEtkax5j3kWzGgtHqJ78DiQVzaIBzbMVDayIrFSKSC0vK/NQ2QT+niemDzQSDQf61UvZ92RRb0gSsyyN/VyvdQS5/LZRkadjP4f3l8bpGP8eOzQVgwbrKeLsQeaGqooZ9iYcrd2QGSazIZIKRSIitSGjtemjL+dQeyfbv0VkPSimllFJKKaWU6l6dNrw5VmlpKVdeeSXjx4/nv//9b1e9TMpsNhuXXnophx0mvecPmuqEVEUGpSITD14XVO0I9dKPEzBLFMz66nm5HTkneQ/59W+HBghn8rb/aADKKyoYN0baIX29cVvU5sGKLVC1DY8fnv/ayzOvf8B53xgBwPOfbmFnRcyQVV8j7P061U8hdcEg7Fopq84tdhh2RLiXfVvsXQv7vpbnTrs09ecZbZBy2zFfwWDMWajcDBar9KNPNHDWCKxGtXvp4kBpZzMSZK0N4jW0Zd4EyOeQURD+PKKC0U4ZOhy5L1eF3Ca6PhproV7agHV7xYIhTnLhk1KpVjh5tBWzycTzX/tYUubHaoa5h9lYV+6Pu6tbF7jI/EMVz65pos4TZMFWP//4Uo7p26NcZNqhttHPcePzAViwrirxcdkzw1UI7ur429R0wnyF5teLSCZEzliIvG9cD5C4uqe5kqU8eXVDeyQ7X+0660EppZRSSimllFLdq12JhY8//pg5c+aQnZ1Nfn4+Z599NuvXS69wl8vFL3/5S8aOHctjjz1Gv379uP/++zv1oNvLbO6yPErvFxn0igx2NZSDtw4aa+IHkGODWV63rHpf9T/59+Fzk7/uZ6Fu7NMuJb1Qhnjv21/OhLFjACjZvC1q8xVvPArAgq0+cgsHEggEeHNZGbMnDMTnD/LgOzFJhP3rpZe9vZOGNQcD8llUl0HdLsAUahnTzuD62pflduSxkDUo9ecZFQsdWY094BC5rdkBWf1lJIC7tuV2Riuf2N7tbQ2897SuqLDwuqKrPCLbH8UmGiIFfDLoGRK3QqraGv59Wlb7j9FILNTubF+v/Zjkwg+m2jl9jJXTRlupcAX46VtSMXDz0XYGZJo495nw5+sPjVV56qsmbl/USDAIb27wUu+RiR3vbJIkRa49wK9mplHr9nHc+DwAPtlUQ6M3fpKCYBDMoffVWB1/m1qjYqETEguRIitRoqpSIgZ5JzrPjHOwoTJ526K2JMBScaBco0oppZRSSimllDpotDnSvmzZMk444QQWLVpEfX091dXVvP7668yZM4dNmzZxxBFH8Ne//pXCwkLuu+8+Nm/ezE9+8pOuOHbVVvECr0FkeKkjP/Gg58iVt0agzdh20/zkr2kMVN3yIQMLcgBJLEwcH0osbNrevOkXq0p4bv4XAJww0sL0HFnR/MTCDVx8jFQ4PPR+Ce6miLkMxgrijrRCCgblM6nbA+WboW5vqP2KSYYeOwvat9+G/VCxWfYz4Yy2Pddow1K3u32vDbD9E7l1FoA9SyK91jhtleK1QepMyVptdaauqLAwrhmjyiMy0GwkGYyfyPfnawy3RXInWJnvkAA7DeUypLi9CuTaYPsSWP0C+NpfueA1pzMw08wb33Vy3gQrty1qYr8ryCH9zNzyzTTe2OCjrDacvLjkpXo+KfVyxavhIPmOGj/HDjez/qcZvPqd8HdR1RikrsnPuIFOBubYafIF+GxLnEQXwOYPZBi7yZz4+ksLzUaoKm37+4Xw36b6feEKA2NgtlGJEjtvAZKfZ8bvMvKTtC06yFuMKaWUUkoppZRSqk9oc2LhT3/6Ex6PhzvvvJN9+/axb98+br/9dvbs2cPs2bNZt24d8+bNY9OmTVxzzTWkpaV1xXGr9ogXEMsslFYtmYUtt28oh12rJfBmBMFsDlkhffq9EvRb9TSUvJH4Nc+8D9JzYe9avhGU2Qn7yiuYMM5ILGwDoK7exbd/8hv+9LGbN0udWM0mnjzHzoXT8vH6AqzeXsmI/plU1DXx30URQdj+E+WnPfweCQhXbZNV/Y21QFDeX0YhjD4Bcovat2+AnSvktt84SM9p23NHHiu3pZ9DUzuSJr5G+CRUKXTk1fKdp2WDzxsdJIX4bZA6U3cFUo0V5bG98RNJJeFhXDPGZxYZaDaSDK5KaSVWszu8L18TFI6V+4kGi+cWwZiTgCB8/s/UjjmeoiNh3GlyPe75SgalG22Y2sLm4L9lQ/jTJ034AkHSrCZ+f1w6vzjSzr/OdmC3mHh8pYeBGTA4uIeRwe3srfNx24cuThlt5dZj0njmfAfvzHXy3Uk2xhRYqG0K8o8vPfxqoY37P/dQ6/ZhMpk4bpwkVeLOWdizGtaE5pIccl7iio8xJ8rt1oXgTTCHIRlHrtzW7IquMoDweRRv3kKySh7jd8ZP3LZFB1iLMaWUUkoppZRSSqk42pxY+OSTTzjuuOO48cYbKSwspLCwkHnz5nHMMcewb98+/vSnP3H77beTnp7eFcfb93Tmau94AbFkQbKGSjCboLEuuq+8Mx9GHgMzrpTH3vylrPaPJ2cYHPcbAEbte5vxhWb2RyQW1m0pJRgM8vGXq9i+cw8D+hVw9hN7eOFrL2lWE4+d5OWoYRYefLeEs2fIQNdbnv6SPVWhz8NkgoGTpJVLSoLSs72qFCq3SQDW75X9pGfLTIO8EfIeYwPwbbVLEikMObztz80fCbnDpc3Tto/b/vyVT0m1Q+YAGH2yBPXNFsgd0jKgabT06ap2Kr01kJpKwsMW0+4osv2RkWRw5ss5ZLWGKxtsDigcL/d3r0y8/2/8WG43vgv717XvfZhMMHwmTL9MWoLV74XP/iHzPdroi6213Di/iQe/8LClyk9Wmom/nJzOEUMsALz6nQx2/DyNxwO/5B+Bm1h8iZ33Ls7g5Qud/O7YNC481IbdYmLtPj+Xv+Zm8D11XP1mI6v3S5VDtUsC9ydMlDkLLy3fTzCyfVPtLvjyMSAIw2fBqOMTH+yAQ2W+gtcN2xa3+b3ikGMg4I2uMujodd+atibAlFJKKaWUUkoppXqhNicW9u3bx7Rp01o8PmPGDAAuueSSjh+VCuvJthkZ+ZCWC4WhwbKuyujBvyfcKgOC3ZXw+s8T93cffzqMPBZz0McjZ6ZTU1ND8XCpBKita6CyuhazSU7FQf0L8Afhey+5+WA7ZNhNvDM3g0n9TbyxrIxJw/Mpr23kt88si36N/OIkbyTIzOCX/Mb/F9LwSAWGL7TC2eaErIEyPDdroAQVO2Owd1Md7N8g9wdPbfvzTSYYdZzc37Kgbc+NrFY4/GKZG2G1h+dsxOOJSWB1dUKrN2hrwiNyvoIxl8LmkESDMx98ES26bE4YfqTcT1SxAFA4BsaeKvc//Vv73ochbwQc+WOphPA1wapnYN2b4VX4KQiEruGaRvjPSi9Xve6mwRNssY2LdCrJodEHe+oDePwAJj7a7mfKP+u57LVG/r3KS1GumbvOH83vz5G/IeX10qbpvMP7k24zs3ZXA0u3htohNdXLTBZfIxSMgckXJb8WTaZw1cLG91J+j83Sc+XW3xRdZWAE/CMHN7dFi/Zx3dQKTCmllFJKKaWUUqobtTmx4PP5yMhoudLSeKygoJ396FV8PbnaO6MQ+o+VW48LAv7oxILFDuf8E6zp0hP9y3/F34/JBMffStDq5OgiK9+f6MNisTB4gLRf2lK6i/Q0OwDuxiYAPH7407oRfLTdR5Yd5n8/A5uvnuGFMqT58Q/Xs3Vvgv7sMdLw8LvAvRzNF5iM484oDFUFDJVKBVMnD/bevQoISpDXGPjaVkZiYfOHbRvKG1mtMPl7YEtvfSV27JyFjia0jKBsbw6mtjXhkWioryE9ZgDzUEm2sme1XDuJzPwJmCywZWHyJEQq0rNh+g9gxGz5d+lnsPSR8CDpNijKNfPIci8XvSjf4Zq9fhy/r2Xo/V7OtfyLiyz/ALuTgdl27DYrmC0MybHy1b4AX+z0s/JH2az9SQ43nDKcIXnSEq+iwUcgECTHaeVb0/oD8NjHuyT5tfQhcJWDsxCO+GF4fkoyY06S243vt/1cNVohuRN8NvG+41TEXjs6U0EppZRSSimllFIHoRQiN6rbxFuda/T5bo/IYLQ3tMra7mzfynG7E+rLpW2Irymc6BgwAU64Dd65EebfKi2S8ke1fL4jn+Bxv8H03k3cdUI6NeV7GDliOLv2lrNlXz0jhg0BoNEbXl1dMLiIi9/axotn+5k+2ML7FzuZ/XgZkyeMYlXJZv7vw1oe++OPwq+RFgrset0SaGzYB8jM4gpy+dA0izPHpZNWNCW19xwIpPjZZLZ8bPdXcjvsyPDvnSkmGIxqisFTZLB2/V7YtQIGxMySsMU5LyKrFaZfLu2PjNY9xop7myP8/Rkr7yE6gWVs396EVmQwNdn529bqEJOp9ee0JQmTCmN/tnRpD2byyPdisshjngZ5nyYkuWAcX+FY+Y68DVC5WWZtQMt5G4Mmw6Rvw1fPyIr9i56Rx13lqR1fvHZBY06SYc4f3C7thZY+LEmmIa1Uz+SVA1ug6EiGTxwKrz3FBlcuHPVjdi3bTKPvafr1iziPZ14DlvB1Mgo484uneG3JOv6xYzx/P/9MyCik0OsDPsYfCFI94jTyczK4/OLDePKzv/DMskoe/F4Qa8VGuVbO/ack/RKJHIZdOAayB8t7XHgnzP5l+HeZrcz3aU4sJBiubczRaGtrpNhrp6PXUirXSGdUWSmllFJKKaWUUkq1QbuWaT/55JOcdtppUT9PPfUUQIvHTzvtNE4//fROPWjVDp2xatbb2LJqAeCIK2R1va8RXv6hDEWOwzzjB3y+C7LSTDgW3sqoEcMA2LK9jPTQkO/GxvBzm5o8XPCtb3HKky621tkYmm1m/sUZuCtlnsO/X3qXTdt2tnwhmwPGnwYDDoHCMXhGn8Zc8994xPw9gs5uqKjxNYVXng+b0f79WNOkdz7A1kWpPWfFk6Fqhf4w9iQJdhsBzXgrsI3HIHr1vrGaH9pXedBb5yq0R0MF7N8EnlCQ2SLVNc1zKTxuaTVldUQn7fxN0M+Ys9BKJcKsX8h+t3/Svpka8Qw/Ci74t8wg8TTAFw/DV8/KPIgETIQD1MP7SwKkdH8NwWCQfdVyDvTPSZ7o/Pl5cs4+8d4KqurkXLPbrGRnyNyd/dV1ABwzdQxD++dxxWEBrLuXS9XQyXcmTyrEMlvh2F/L/ZVPwb6S1J+bLgOkqdsbv91RvMHNqYithOmtrcCUUkoppZRSSimlOqBdiYVNmzbxzjvvRP1s2rSJYDDY4nHjR/WwjgZ6PS6w2sDnbbmC19sIJ94BjjwJoH705/j7MJmZ90UOTb4gmbuXcOZICWhv3lZKeroEaxubmpo3r29w8dPL51LvtzLr4UpqyGJUvpmXzoNJIwrx+wPc8bf/xH8tsxWKZkLxMQSyhxLo7FZHyexeJcmVjH4ygLkjRh4rt1sWtr6trxE++avcn3qJBKqNxfvGXAC/J/r7MwYQJ1qV3d6ElD0DMvv1vgG17el376qCQJPc2kOVCnZHeH9et3yukY81VEj7oQGHyGPJBjgD5AyBKXPl/kd/6ryqi8wBcNbf4fDQvrd8CIv/DA37W33qsH7ZmEzgbvKxv8bF3ioJvvfLCZ8r+6rr2b63mkBEdc+cKcVMKh6Aq9HLw2980fx4Ya5U7pRXy35MJhPXnTSUP58Yqiw4+loYMavt73HEbBh7srRTWnBH6jMljIqFxqq2tztSSimllFJKKaWU6uPaHG3dunVrm3+2bNnSFceu2qLN/eRjArB2p7Qayh3SMjnhdYOzQJILAEvuh7LP4+62ggL+b7EkD05P+5J8h4lNW0txpMtq5ujEQgPDhw3hjzdcxe76IDMfqsBtzuSQ/haeOMlN/wwTT746nw1by1L/HLrDjqVyO+yIjrcoKT5GbnetlO8jGaNawVkIQ2dKANwZWpXtdbc+wDmeg6nyANqXKHHmgTlNbm3OcKUCSGskV7kkHZpfww1BvyR1CkPtj3atbP11jvqpJHh2rYBN76d+fK2xWOHIq+HIn0hrpupS+PD3sHN5i03r3Y3N99PsVgblS3ux7Xtr2BdKCOyrCQfhR37vXkZ89x4sJ97K/S99CkjC4JffOgqAO59ezP4qqVDoF0osGBUL1O3h6lE7sZhNPLfeApO/2/73+M3r5e/TvhIZWp0KR+jaaAwdT0N5+KetA5uVUkoppZRSSiml+pg2JxaGDx/erh91gEkWgDV69Rur4F0V0k5k7CnSKz4YgLeui7vbUaNGctfHHnZ6c0gPuvjjCWl8/PkyqqprsVgsNDY2UZCXC8C0yYcC8LNLzmP2jMMo2dPIX8smUe2xMHWQhWU/zOaooSYeevr1rvoU2i4YgB3L5P7QDrRBMmQPkpZIBGVAdsLXDUpCB2DiOTLEN2iKaMfikFX1xndmaG1AbWRCykg2HchB1/YkSjIKoN9ouY3kdclq9/r9MgC4ITQE2KhqyMiHIYfLY3tWy7mR9HX6yeBlkKqf1rZvq4GTYM4t0mrI1yitkXaEKwrK9lTw0gL597B+2WzbU83+Gvmu02wWzGZJkm3dUx139x+sCCeQLz5xCocW96emoZE3PlkNwID8bAB27a+RdkzL/4MNHwu3+bjmnaaOJeGcBdJOCuDTv4M7/jFGMappPHXQVAv1+6B2R8vrIZVB5IkqYdpTIaOUUkoppZRSSil1AOjG/jDqgBIbgDUSDV53dDDaG1qdbbXJdtMvk9u6PXHbuVzzk6vxBuB7T8tg5UunpFGQHuBPf3uEY46SQPz5Z5zMvF/+mDtvkUGsZrOZW67+HgB/fOZjFudfxKbKAEOzgiy61EnRnnepq63twg+jDQJ+8NTL/bwRHd/f8v/KzAaA9NzE2wUDUq0AMOkCSMuWwcKuiuih3UE/VO8MJxdaa4UUqTPmdPSEyOBuZ/a797hDn7NDBjIbcfHIqob+E0LH0ACNKZyj3/iR7HP/OtiS4lyNtnDmw9G/grxi+XdEFcxTb32Cu9HDN8YPYe7xk7j9qcV4fQGOnzKCw0YO4OhDZCYKEZe1KZRsmDOlmH9dd27z4xaLmbNmynyJhcs3ADBikCRmtu+phK0fgauCWn8a5z/nZtbksR1/b5n9Q8cXTC1JsfQRuc0rBiyhA49zPRh/7+rLEycJEl0bB+o1o7pUSUkJy5cvb/FTWlra04emlFJKKaWUUkqlTBMLKjVGosHmiA5G2xxgzwRbptzf9olsP3xW3ODe7KOPZtZRR7FoaxPbvPnYzEGummbj6ZffZMaUSQCUbNzMHb/+BRkZ4eDviUdPZ8yIodTWN7C93spJz1l4fIUHs8nEz6dDzbM/BndVi9frdmYrzRHmBEOsU7bmJekZD9LKZuzJSV7XIiveQVrfFI6SxELksG2bQ2ZkWG3ymCc0H8DmSG0F/4HaFqmrgrv20LmfN0LOf6sjPF/BCD6n54AlNEPASDglk54LM66U+8uekO+vs5kt0Fgj9/OLmx9+9j1pZXTFKVNYuXkP/57/FQC/v2wOALMPLcJiNrF9X3Xzc3Y9ewOlT1/Hgnt+QEFO9Hlx7GTZ98LlGwkGg82JhdrKvc0zQ+5dbqfSHeSUmRM79p6CAVjyN7k/+UL53JPZuwaWPiz3T70LMgslMZE7tOXAZpsDfB5wV0hlQ7zzKNG1caBeM6pLFBYW4nQ6mTt3LtOmTWvxM2HCBE0uKKWUUkoppZQ6YGhiQcUXG4w1VmHbQz36I+87C8KBM2PI8Mhj4u7WZDJxy003AvC7d6Rq4dqjs7GagqzfJK1UPlm6nH37K6KeZzabuXru2QA89PTrnHv6SfzgtUZu+qKAcleAoWn1BNa8DHvWdN7g2/YwmWRoMkgwsr3Wvw3v3iz3p14Cs37e+nOyBspt3R65tTmk5UxzsNst7XnSsuR3rbVBimWs9u9tA5lb01XBXZtTkgveRsAncxZclZJAKN8M1Tvkszc+r6a61PY7/QcSGK/eLsOWO1tjjbRuwtQ8XHzD9t2sXL8dq9XCqTNG8f0/v0YgEOQ7x07kG+OHAJCdkcb0sYOjdpXlTGNY//hB/KMOKcJqMVO6p5JtuysYPjAfgDP77wS/hybnYP7vXamyOfkbHUwsbJwP5etlhsS0y5JvG/DD2zdI9c6402DMSfIdxZ7bRjreJq8AAQAASURBVAskkHMnPUcSc/HOo0SVMJ1ZIaMOeEVFRZSUlLBs2bIWP08++SQul4vy8lZm6SillFJKKaWUUr2EJhZUfJHB2Obe+qH+/FVlUF0WTjoYAeqGCigLDS4u/mbCXZ9y8snMmD6d/610UeNPJ9/m4fyJVj5Y/BmHHzqBQCDAG++3DKheev4pOB3prNmwlUnjRgLw53e3c9O6Sby10YuZAJR9Bhve7tk5ANZQYqG9FQubP4Q3fyWrsCd9C+bcnFprl8xQYqF+r9zanFK1YLFL//+ATx43kkJtaYN0IOvo4PJkPG6pAHHXy20QCT4H/eCtD7VLygxtm0LFAsh8jCN+KPeX/Tv8vXWWyq1ymz2o+bt/7r3PADjhiEO575UvKCktZ0BeBn/7ySlRTz1ucurzcjIcdo4YPxSARcs3Mrq/k1cudHDacLkuHlqfi98f4Ljp4xg+qCDZrpIL+OCzB+X+1IvBkZt8++X/kQHZaVnwzRsSbxeZeLM5pEVV3jBNEqgOKSoqYurUqS1+JkyY0NOHppRSSimllFJKtYkmFlR8kcHY2PkK3noJkka22DFbYc9XEPBC9lDIG5lw1yaTid/fcRveAPz1E1nF/aujM6mrb2D82FEAvPL2fACCwSB3P/IsH366gtzsTOaefQIAH3y6nCMPn4jfH2BI8VguecfGj9904w2YoHYXrHkRKjZ34QeUhKUDiYWypfDaNfJ5jz8dTrwj9aG2RsVCTZnMVvC6wt9NRn7LJEJk5YkKS6V1klEFAtIOqaA41BLMAfZ0Wfluywy3S4K2JbumXSaB7Joy2DS//e8lnqpQYiHiGn02lFiYOn44d78gLZEe/vnpFGRHnxtzJo9o00sdc5hsX7F5GYfufpazx9to8gWpHX4Sv3l2JQC/+u4JbX8Pkb5+Tao7HHlw+Nzk29btgYV/kPuzfgF5RYm3jUy8GRUNmlRQSimllFJKKaWUAsDa0wfQZwSDrbfoSTWA3N2tfuyh5II1Xf5ty5QxAtZ0WVVvS5efUglIMvIYMCfPWZ1wwgkcO3sWDy5dwi2z7UwfEGD6YDM1DY0AvLdwCfV+G+8vWMT1f/wnAP5NH3LZt0/j4Wfe4MV3PuL/fnU5n634mqdfX8BfbrmGi3/1ez7e4ebLGw8lrXqTtJGxpcOsG2BVaLDx9Mtg/cupve/cEaltFwhE/9tILHgbo39nsSXfz66V8NpPJSEx9hQ479FWnhNzHhjDa6tLZcV9WgZkD5GV2T0hlfO0K87ljl5HxvnenHCJsz+j5ZE9E3KGRTxeLt+/zQHOwtD+IhMLKR5bWiYccSUsvgdWPAWTv5v4XKjckto+fXJtUbFJbnOGgq+RDdv3sGZTGVaLmRfmLyUYhO+fPYezLmgZpJ+aNR54MfxAXnHS/4ocd3QNg6qXcs3YMvBCSXmQ77zQwBnnO6htaGTC6OGccvYFrf69iJKWHb5fvz88K+HIn0DWoPDvrGktnzv/VvneBk2Go34m8yZiryOD0erNE6pgMQagt6az/46nuj+llFJKKaWUUkqpbqQVC31VW9q92EIBNqNCIXcI5AyR1diRti6S2+L48xUimUwm7ph3I/sagjy7Vlq9XHOEnSWff8HIEcNpamrinfkfUrJ+Y/NzAoEA35gykSkTR+NubGLpqnVkZ2awYWsZg/oXMG3yIazZ4+FF+7dh+uVgssD6t7G/eQ05wdqUPpZO0Z6KhX0l8NKV8n0UfxPOby2pEEfzjIVQK6RUY/ZtORfaqzteo7PEtk7yuiRhEHnswYjbyN/bnBKsjgxAG4mFphRbIRmmfFfml9SUwdevtvfdRAv4ZX8gQ6eRaxEkzl3nkmt82sTR4ef4msDroq7Bxbd+cVfqr1VdxnENr3LNEXI9VAw6lovez+OrvQHWb5UBtafPmYm5LUmFSE118MJl0vorb4R8XslseBdKXpO/CyfcEUoqpMBoidTZw7+VUkoppZRSSimlDmCaWOhLIoO7qbR7MTSUw67V4NrfctCvxw37N8OWj2HvGnksyXyFSLNmfoMZ0w7nr5/KPi881I7dW8uMaYcD8Mobb3HOmacCMHr4EKxWKyaTiYd+fx1ms5ln31jArGmHAvDEi28z9TAZALtucyl84yo4+wFIy8K8dw1/DfyWYcGdKR1Xh7U1sVCxGV74ATTVwuDD4YL/hqtD2iJzgNy6yiUw7sxP7XltORfaqzteo6t4XRKQj0ws2B2ANTS8OeL3NqdUKkQmFppnLKQ4vNlgc8KMK+T+5/9o/8yOSHW7ZT/W9OYKlzFFAzh6yhj8gQBTx8kMhT88/Dzu3Rtg6SPwyo8JvvRDyv77E07K2sDp49OxB5McSzAAG9+DRX/E3LCXyiYrJz/ZwCNbBpGdkweAKVS50eBubN/78DXByz+E/SXyeZ//r/gVCs3bN8rAZoDDvyfzSCK/T0+otVW889NoiaQtw5RSSimllFJKKaWaaWLhYJNsZXhkcDdyOHNrGirBbILG+paDfr1ucFfA9o/l3wMnSVA7BSaTiV9cfRVf7grw5V4TaRa4apoNm1V6q7zxzvuMGTWS1W8/zucv/7P5eUdMnsAvLvsWAMvXbgDghbcXMXzoEADWrAtVOQyZBuc/SiBrCIPZx18Cv8O8a3lKx9YhRmLBl0IguKZMVl27K6H/IXDuw9LPvT2MioWG/fI9pTqUOfZc6Irqgracb71NZBVCc3WCGxzZkljzuuW7TlTh0N6KBYDDviPXU+0uWJtiC69kqrfLbe5wMIX//P/028cDsGr9Nn72zQJeOMuD46PbpQrJ78FEkIl5Xm46Oo1XzwvyYuBK/uj/PZaNb8vMhoBfduSqhE/ug7UvyQDrQZN5LeMi3tvs5+2Fn1GYnwNI9RFATV07hqwH/PDGtVD2uXy23/oX5LUyVPrLf8m1ljkQpl4OVqt8dwajKsFV0TLBYMwi0fkKSimllFJKKaWUUs00sXCwSbYyPDK4G9vuJVJsYDkjH9JyIb843P7I44bqneCqkgDl7q/kcV8TbHgH/N6UDvdb55zJ4EEDuedjCTD+eLqdkpK19CsspKamloWLP+HQcSPJz82Oet7t1/6AkUWD2VteRV5OFo1NHqpragD4ZOkKgkb/8rwReM55hK8ZQxYN2N76OVRuS+nY2iwYhPIN4Z73ra0wb6yFFy6XVi4Fo6X9UXp28uck4yiQW3dl24PYHlfLapaG8vBjHU02JDvfervIKgSjOiGIJBtMSCLJuC5c5RKYNioYvK5wyx1POxILtnQ44ody/5P7Ycuijr2XqlBiwZEX9fC5syfyuxOy+eziAPfN8XJ0kRWvP4hn0HRqv3EdQ++t4/svu6nMm0LQkYcdL4ezFtv6V2HRXfD6z+C9eTLDoHy9fCZT5sIRP2L6jCMAWFmyicI8SSz4/UZioY2fya4V8NzFsPFdeY1z/wkDDkn+nIAfPv6L3D/qZ9BvFNizWrZyc9eGEwyxlVlKKaWUUkoppZRSKoomFg5G7pr4j7cW3DWCxw3l0cmJjELoP1YSDM3busFbHwqWmmDABHm8fAM8OxfuOwze/w3sXZv0UO12Oz+6/BJe/NrH/iYbg7PMHGHfxAlzZgPwyhtvx31ehtPBI3+4HoDqGmkx89GnX5Kensa+8grWb9oa3tiRx43mW/iYGZgCPih5HRoTfEbt4aqEr1+BN38p79nnlmRLwajEz/F74Z1fywry7CGy6jrV1kXxNNbAZw/K/axBbat68Ljke2yqj65mCSJ97Kt2tDwn+iqjeiGjQJINzoLoaoaAX5INkY8ZQfyG/e17zUnflsSTuxJe+RF8+IfUqmHiMY6l7DPY+L585+vfwv7R77l1FgzJNlPeaOZvq9Io+ms9d6ws5OuadHbWBVmwN5v8k66j6dT7ucL8Z/5muhT/gMlgdUh1gqscAl68WUUw5xYYcTSYTIwtHobVaqG2rgG7TeaGeLySeKypTbFiYdcKePlH8OLlUqlgtsHpf4Gima0/1++RSgSAcaeE/g7GqUBwZMt7MVsTV/t0RTXPgTR/RCmllFJKKaWUUipEEwvdpTuDRo6c9j3PWKkeJH5rnMjWITYH2DIlIO2uguLj4XsvwOHfl2Brw3747B/w8DHwyBxY92bClz35+Dl4A/DnT2WI882z0xiQJyv3X3nj7ea2KbGOO2oqxx81jSDSVmnpitVMmjAGkCRD1Fsz2fmj+ScECsdL4H/tK/Je28vvhZ1fwqd/g9euhlVPQ90uWUU9YjaccDvkFsV/blOd9Iff/IEESM+8LzwfIRXBIFSXwern4a3r4KFvwp9HwxePyO+Pv7VtLYfsTmkpk5YZXc2SWQg+L1htLc+Jvip2hoLxb5Drw++JDkrbnJAR+m6rS9v3mtY0+O6zcPjF8u8V/4VnLoKqbW3f19iTYdRxcn/9mzD/tzIPwevGl17Aj9/yMuTuavYOnMOe+iAPPPUmJZt3ADC+eKg8z2SizDSE180n4Z3xYzj9HuqO/g3ffs3ClH/W88PF+VHns91uY/woaVXU5JWEiLtJbqtbq1iITCjsWCrn4GHfgSs+kCRBKmwOyBkm96u2SkVJcxVOqO2RzSHJGhPh7y/ezIXYirDOSAocyPNHlFJKKaWUUkop1WdZe/oA+gxPN7XWsDvDq87b+9zM7OjVvEbgy+sOtw+xO8A+BNzVYDZDIAj9DoHCsXDMjbDjc1jzsrRF2rManr8UfvoF5I1o8bKHT56Ew+Hg/o9ruGn2AIZmuxm570syMzPYtXsPn6/8mplTD417yJd961Q+WLIMR3oaLncjNqusiP7wk8+56vsXRG3rNdnxnPgH0p//nrQf2vg+jDs19c8nGJRgbtlnklSIbJfSbzwUHwtF30je7qd2lyQVyjfIdmf8ReZSJBPwS+XHjqVQ+pms2K7b3XK7/JGyur34GDm2FvMwXOFzw+OS2RkZ+ZJEyIuTBLE5IW9o+DkHYhujtoj8fFp7r0Zg2uYMVyZY7eG2R0YrJGchFBTLY+1NLIC8xpybYfhMeOdm2Pc1PHk+nHAbDJiY+n5MZphwllQurHlJBi3nDIVRJ2AddBgZa57H88W7LF62FovFTE1dAytKpLXXqGEDE+7zV/94ixdWVAGw6tWPeODGS8lwhAeQTxw9gjXrt1BfL9dMg0tuq2oSDLR2V0vSY1todovZKsc9/QfQf0Lq79dQOFZmLOwtgf4Tw3+Pg6G/axkF0W2QPC6pyLJlRv8tjf37Gtk2zOYMJenaOCOlI3+zlVJKKaWUUkoppXqIJhYi+P1+LBZL1GPBYBCTyZTyPpqammhqamr+d21trdyJ7efdVWwdCAAneq4R+LKmt/xd9iBwpUsveLMV0rLk/ugTYPA0mH0dvH0d7PgCVjwJx81r+bI2G6eeeBwvvfYmL+wczJVFmzm3/3Y+/OZMXn5rPk+8+E7CxMJpc44EwOVuBGDPvnIA3nx/EY2NTaSnp0U/IWsQTDgTVj8nCY/swTBocuLPJBiQvvS7V8HuldCwL/w7Rz4M+waMPSU8ODmZvWslqdCwHzL6wbkPtd4f3tcI/zkbdi6LftxslWTG4MPlGIYfJRUSrspQFUkN5AyKTi5EroxuqAR/Yyi5kGTYdkfOpw5IeB11pcjPJ5XEQsAvLXZsoZXmRvsjkNXuptB2BaPlsZod4SHH7TVyDlz8Mrx1vSS33r4eRp8I3/iRXHepGjFbBjj7vZKQCv2NO3nmodzz1LtUVNczZvhg1m3ZgZSrwOJlX4dml0T/Paysqec/b3wc9diu/dUsL9mKzWph3CQfazdKa7IB/aTdVyAYxGw2s3PPfsp27WXY4IiKnfKN0lasdmd0QiF7cNs+q0iFY6RCqHIzuOvAmSd/kz0RCTibI5yQMyoQYv/0x14Pxt9Gnyd87rQ1sdBD15hSSimllFJKKaVUR2grpJCSkhJ+9rOfceqpp3LzzTfz2muvAbQpqQBw5513kpOT0/wzbFioBUdvDByl2sbDWInrdbesvMjIl2GouUPkvpFA8TaCpwEsNmldArDy/9m77/i2yuvx45+rZUvytpxpO3s4CVmEQNgQwl6FMBtGoLSlQGnpl7a0tPwoUCiUtrQUyiij0IayR9lhhR3IICRx9rATJ7HlbUm2hvX749G1ZFmS5b3O+/VSHctXV1dX95HKOc9zzn/iNnW+8fprALhh2XoqmszkZxg4fXQNAMtee69lhnO07Mx0sjLSWn7fsbuUkcPzqG9w8db7H8d+PTljVWAVYOtyqIua/d8cgKqdqrzRO7+Gj++Bbe+opILRDPnzVRPYRb9TSYpkkgp7V6neE64KNXv64ufaTyoArPm3eqwpFcYcCUf8BC55GX66AZa8CCf9HmZd2LrsUoMzPBNbp8/GD3jVe2nPAWNq674Z/UjccdSTIpubt0fvteD1qPfU6wmXSDLb1DgwWtR5zx6v9tvsg4b9XT/O9BFw3uNw2DWABtvehf/9pOOlkbIKVR+QiM+46lDPg+wMO3OLVI+QrHQ7dmsqxTtKef2jr9vs5olXP6LJ62PO1LFkpatz9+qHq7jwl3/j3P/7CzNOupQNW3ZiNps45tDZAHi9Pg6ZORWAdz7+Kryz7R/A85erpELGaLjg3yoZ2ZWkAqgxB6qxujVd/VvvtaC/35aI3225YB+mfnrd4fJJ0VqVDfOGxlmSfSOEEEIIIYQQQgghBjBJLAAbN27kiCOOIBgMMnnyZHbu3MkFF1zAfffd17KNmqnbvptuuona2tqWW2lpqfqDprV/6wmJkgeRM7TbOzavWzVo9XtQl03o5mtUs+T1m69RBVwt9lDN/jQYf6wKurrKVT13g1HdTJaW22GHH84xRx1BQ6OP5/epWu4nZ2xh2qSx1De4ee6jDZA9LuZt/LixAEwcr+q4zzpIBez/+9q76vkjZxBb7GqG9/E3Q+Hh6jVteQuGHwTGFNizCr78h+pfsOtj1RTZbFMrME74HVz2uipfNPMCtVpg5CwYfXDiW3kxfPxH9R6MOwYu+x8MmwqpmbFvmkHdAl749C/quI//DSx+HI7+Pxh3tFrxkJYH/iZw7giVpDKqx6WmQWOD+rfBqJ63ulQlG/TAd0tD7gSrFboqmWs+znUfdxwlIxhM7hYtXnNz/Tj9HrVCwe9R15E9TyUQgsHQzPYg+FzhfiSeulBvCkM4MF5T0uq6T3iz5sS/2YfBwt/CkhfUv2tL1Sz/srWQV6TK/bS5FbV7q0b1NsnOymDODNWvZOPOMq5dciYAv71/GUGjOXyqJ53AP179AoAfXvNjrHb1+P3BLAAyMtLJzFD3Xbz4bIaNUckEtzfASScuAuCdLzdAZiGs+y+88TOVEBt7JFy5XH12ZIxufbOkJXcLNodv+qqRqh2gGdXqDv1vaG1vFru6Fiz2cImk9nogRG6XzPXXhfEhhBBCCCGEEEII0deGfGKhsbGR3/3ud1x22WU88MAD3Hffffz+97+nsLCQn/70p9x2222AWrmQTHIhJSWFjIyMVrc+lagxaEdmaFtsrUu96PSSMK7qcF15ffusAsguUDOsp52l7l/9ZNyn+OX//RSAX7+4lbIGGJUGv1ikArL3/eMx/P7YzZbHjVGz2ccWqp9er2oM+9pby3HHWemAZoBjfq4Cla4KePYSeP82VS7F61I16IvOglPvhctfV7XsJy7sWJmTYDN8eCe89//Uv2ddDBc8DalJXhNrnla9FNJHqlIw9ty2599VBc1N6ieEyrqYID1P/e6NSCr4fQOmjnu/G0cQeyzZHapRsZ6g8XpUssrXCNaIY06PSCx0pzFHwNI3VADe36RW2Lx6LTR2rnSU3vMgOyOdudNUYmHNxu3835WLSbNbWbNxG//7YGXL9h+u+JSt27aTnp7GxRcsbik95vWqlUlnnnYK1bu+pXrXtzz+93ux2dSKJk9jIycdfwwAn368gubXfwYf/UHtdN6VcOEzYOvG1TQO9Vqo3aPGYnT/kUSS+Zz0ulWT8wE0xoQQQgghhBBCCCG6YsgnFjRNY+vWrS2lVgKBAOPGjeOEE07g3HPP5dZbb+XJJ59s2XbASRQU02doJxMst9jDpV6i9xHwAkH1M16PhtnfVf/e/r7qWRDDSYsWMmvmDKrr3fxn9zAATs3cQl52Bmu/3cDv/3R/zMeNH6PKAA1zqODuis9Wkj9qJC6XmzfefT/xa1p4SzjImD5KNT8+/S9w4TKVeCg8TJW06ShfI7x6HXz9T/X7kTfAafeqUkrJ8DfCJ38OP9YU6hXhiyrLYs8BQ0q4pJHFpspSpYTKvdTsVUkFzaSSPP2xJFdvSrb8V6zHQNuxFL3KwWJVM+Jt2eqnJVSvXy+X1d2JBVDles79Jxx7kzq+zW/Av86MO84SaUksZKYxu2g8ADtK92E0Grj+0rMBuOOB/7Rs/9R//gvApRedT9q2V/nFIV5Om2TC6FX7MRgMaJpGVmYmmqaRnqbKllXX1HLI3FnMLMzktXMCGLa9AwYznPpHVd4r2XGSLHueSiIShJ0rOvbYeCtZIllskJIhY0wIIYQQQgghhBBDxpBPLPj9fvLz89m9ezcVFRUYjUZ27tzJc889x+LFi1m6dCnLli2jsbEx6XJI/UoyQbGu7t9sVaVbvKqBcktNcv3mdUPeFChYoP4eZ9WCpmn88mdq1cI975ezp64Zh8XLi784EYDf3X0fX369ps3jxoUSC/UNDRy1YD5+v5+C0SMB+O+LryU+/pxxcM6jcO6jcN4TMP/7qveBwZj4cYm4KuHZJbD1bRUgPe3PcNiPOlbWpGW1wgiYfIoKTvvcUFOmmjPrvS7suTBskvqp02vFg5pFLUmFsEQreNp7DLQ/lvS6/frNbFPvVWaoR0RtDyQWQK3Amf99+O5zKoBesxv+sxjKN3ZoN+EVC2nkZGUwNl81VV5bvJ0blp5DRpqN9Vt3tWz//kcryE6F303bCm//ih9Mc/G/i238afTrrPuhncvyNsCmN9S1DIwpGI3ZbMbjaaTy2/f4+FIzc0YaqQtYVFmnOZd0z/mIpeBQ9XPPV6GybXFWM3VGT3/OCiGEEEIIIYQQQvQzQz6xYLfbOfHEE3nrrbdYsmQJ119/PTNmzGDx4sVccMEFnHzyyaxevZqGhoaBuWKhN5htqgSIyRwKgIdqjdfuVX0VXJUq2D0ntGph9VNQVxZzV4vPOYtxY8dQXlXHQxtUkO5gzwoevnIeWjDA93/yyzYJnvxRajZ4yZ4yrv/hlQAUb9kGwOvvvEdtKFgaV9owyBrTPfXMq3epgO6+tZCaBef9SzV47ojmQHi1wuxLVdNfb6hxdku5lSRLufh9sUsoRerMLP6BqiPlv7ryGAivLoFwYqHkC6jvhgbO8YycrZp6501V7+myCzs0Q7+mLlwKCWD6RNW3ZMPW3eRkZfCTy77Tavs0XyUrr0ojp/obMKXy5p40NjsDABw03MjxmbvhrZ/DPxfBC1dirtzE8DwHZ00xMezjX5Bh9LJmX4AjnvQSzJ/fDScggREHqZ8H1ofKtnVjYkEIIYQQQgghhBBiiBnSiQU9QH3NNddw8803U1hYSFlZGXfddRcPPPAAAEajkdGjR2O1dqAm91BjtoE9WwWxvR41wzvgVQ1SIdTYFph6ugrgu53w1DmqEW4Uk8nExRecB8B7VSP4Zn8AK41clb+F4mvTma5t5d33P2r1mPXFmwEYW5jPWaedSP7okdTU1pE/agQeTyN/e/jxHnvprexbC/85TzXSzSyAi5+F/EM6vp8DG9QMb0saHHRuOJGgl9mxpCa/L2uM3gTRiYTOzOIfqDozs7yzs9H1fgsAU09R72flNnjkeNj6bsf21RFpw+Ci/6prr6kenl8KXz8Wu2F1FF+oj4nFYqK5uZk1G7cDMKFQ9Yj47pnHt2xbGNzDx5enMjHHQJnbxMqimzn7KSdT/+5i6bpDOee/br5onqlWAGlGKP0SnrmIR46r5b+LrRiCAQLjF3LUE27Wl9ZRUVHRAycD9bq/fQ4+vU/9nj0m1C8mzmf6UEq0CSGEEEIIIYQQQnTSkE4saJpGc3MzAJdccgmPPPIIzzzzDNddd13LNu+++y6OUO1+kYDXA/jBU6PKIpltkJkP9mGqBjyANRMue5Vg+khwbob/XgKNtW12depJiwAo3rabM16xcv1bjTQa7EzM1vjPuTYmffF/sO5ZFaisLeWjjz8GYOExR2IymfjeJRcBtDT8ve+hx3r85bP9ffjvEvBUw/CD4OLnIGd85/ZV8rn6OeIgMFkha1So5FSo7JTREi6FlIjZGnumfXQiQZ+RD0MvoNqdQeTo/hctiSCragb+3RdUkN1dqa6Vd25WDZd7QmoGnP8UzFismhW/fxt88qdQP5T49NyDhsbX326hrLySNLuV4xfMAmBc/ghMZhOTgjv4Y/PvGGkPsqEiyMEPVnPo4h/j9XoZN3YM63c7eWmTnz1Tr1RJjqVvwrSzaQ5qnDzRRIpJg4mLMJ5+L1kOVW5p1+6O94RoV/0+da5fvhoaa2DETDj+FtUYOl5iYSgl2vqpkpISVq9e3eZWXFzc14cmhBBCCCGEEEKIEFNfH0Bvqaqqory8HKPRyJgxY7BYVENeg6F1bsVoVLX1V69ezSOPPMKyZctYsWIFdnsSDY77is+tgmAWW+/X+NZr//tC/RUIgqdONRO22NoGtbMK4ZKX4InTVUmS5y6HC/7dartD588jOzuL6uoazrviMv762JN86cngjV8vxrD6CcbZG+H937Vs/8bRQfbOTiM35XV4cxM/nZ3B3rkWdtZsp+DQKSxfvatnz8E3z8Dy36oA7rhj4Iy/JtcQOx49sTBsevi8+tzhZIIerI7FGypFZbZGnP+oEk8WW/h6gXDSwuUMB1SHSq34yCByV1+zu0r1v/CnQaYtfF713hhpw+DC/8KKu2HNv2DlI7D7czjnIcid2D2vJ5IpBU65G4YVwQd3wNZ3oHYPLPytSnTEoK/i0jR45T11HZ569CGkhD4vzWYT352Xxx+a78COh+YRs8i94G5OqvsrTz69DIBTTjyBJ//9DADTi6aqHWeMghNv59w/f8Z3RuzhkPmHUnTyH8BgYmxBPnvL9rNz5y7mH9KJFT6xXwis/Y9K3jTVqcbQ866Ameer1Qo+T3ic6I3OddHjoyP68rN4kCgpKaGoqAi3O3Zix2azkZvrAA707oEJIYQQQgghhBCilSGRWFi/fj2XXnopfr+fLVu2cPPNN3PTTTe1JBGiuVwuDhw4wNatW/noo4+YOXNmLx9xB3VncDRZbie4qoGgWolgTlXBbq9HrVhIxDGZ4JIX0Z48HfaugheuhPMeB5Mq8WM0GjnphIU889wLpKenk5Zm58t1m/ms+Re8smM7o8qXc/TYVBYUjSSl0YkRHwWZGlQXQ3UxGcDDZ+jlgvZRdoSFnYE/sUmbiGGPG9LzOhc0jBYMwtePwqon1O8zFsOi21TD5q7ss+QL9e+ciYA/nFAIBlRSwZ4bnh2vJxB0rkrwNYA5Lf5rNMcJenYloDpQJfuakwkYB6N+6txV6j0JGCF3Apz4Oxg9D96/VSXXHj1BJQBmnt/VV9OWpqmAeu4EeOUa1cz51Wth4f8Dx6S2LyGiXNLLyz8D4KwTFoQ32LuKh46rxUSANUwn+8h7GDt2Mk88/Hd++L3LeeOtdznnrDN44OF/YjabmThhPDSrVRmbtmzj5S+28T+TiQN/+lvL58S4MQV8+uXX3bdioXYPvPF/sOMD9fuoOWpc6gkFdw3YUH0WPFVq1Ujk+xprfCSbMOiLz+JBxul04na7efrppykqKmrzd4fDwbARo4ANvX9wQgghhBBCCCGEaDHoEwsbN27k2GOPZenSpSxdupQ333yTG2+8kcsuu4yCAtVQNRgMtmrMbLfbOf744znqqKNIS0vrq0NPXlcDwl5X68fr/040695VrQKGwWYw5IRn0FusgBa/zAiqBBUjD4KzH4CXfgC7P4WXfwTfeaglKH/KSSfwzHMv8MFHK/jRFZdw91//wR1/up/Xlj3GGRft53dPrsZq9bLgkDmsX/UFPzz3OG695iKo2wt1eynf8S3Ond8yOdfIqHSNUXzNEcGv4eVnQDOolRN5UyGvSM3ozipUgcdkBfxq5vnm19XvC66Fw6/vegPoqh2q4bUxBcYeBpjC51ZPMLgqwe9RJZF8ntbvuxb1U1/BkMwM6ngJh8Es2decTMDYngNea9vVJEFU4s2cph7b7IPZF0DhofDa9VD6Bbx6nVphMO2sLr+kmPSVNMtvUYH3138GR/0Mxh/T+lBDiYXaBjcbt5VgNBo49ZhQU+Vdn8Bn92MiwOcczB2G68i+62889cjfADhs/iEcNv8QXn/zHQCmTJ6I2WyGJpVY+O9LrwFw4nFHk5Od1fKcYwvV5/DOXV1MLASDsOYpeO9WtXLEmAKH/xjmLVWlvtzVEGgEW5b6fPJUgbsWUkN9MLojYTAUk3M9pKioiLlz58b8W6PX38tHI4QQQgghhBBCiGiDOrHgdDq5+uqrWbJkCffccw+gghXLly9nz549VFZW4nA4yM/PB+APf/gDTU1N/Pa3vyUlJYWUlJS+PPz4ooPXFnvsJEASzVqBtjXF4wXQIp/XnqMC3PZc1dhWL6NjMKn7Ej2XXoJk/HFw9kPw4vdg23I1y/icR8Bg5OTTzwauZs3adTzx2D/568NP8MVXq/l25wGWL1/OBRd9l9ffeJP3V6hyLWOPvhBmXdDyNLmBAIdOm82Bvbu59/8uwZRqZ0pwG4eYt2P1VUL1LnXb8pZ6QGoWjD8WJp6gjsvuAJ8rzmtwqVnfOz5SSYqT7oTZFydxopNIOpR+qX4OnwZGG2SNDgcpLXZ1zpv9Kljd0j8h8n0JNRnW7/d5kp9B3dWkSLRkrr9kr9GOSPZ1RD93olnpyQSMLWnqFi3NAd7Qe6IZVEIIVO+Rc/8JH94Ja5+GV3+s+nKMPlj9Pdn+C8mW3Zp8EhQeplYu7PgQPvy96nWSNwXSRkDGSEakG0k1QTWqP8mokaPImr4Q1jwNn/4VCBKYeha3bTmXgGZi2bPPc81VSzns0HAJow2hZurTi4pCK2wcBINBnnnpDQAuuPAidZ2GjJusZqXv3LUrudcRa0VQ9W6VpNm1Qv0+co4qMWXNUde/ZoDsgtbvr79JJRX8PkhvZ2xEvv+Jrq94n8VCCCGEEEIIIYQQg8ygbt6saRonn3wy11xzTct9t99+O2+//TY/+tGPOOOMM/je977HJ598gsvlYs2aNbz11ltUVVX14VH3Ab15r16TP1bD32h2BwyborZzOdV98R7nDZXt0ZMKzf7wLPqi0+D8J1UN9A0vwYtXQdUOhg0bxiGheuuvvvY6V15xOQC33HobNpuNl154jssvu7TlKRYef1yrpzQajfzq5z/D44c/vbiS5w2nc4fxJ5z/5Qz48TpY/Dgcfh2MOUIFAhtrYOPLKmHwlxnw+Mnw6X2w7xu1KkPnqoBlF6mkgilVrbJIKqmQJD2xUHBY66SCTm/IrCd0ogPgZlvr+5N9P0Xipr3R57Uj4j3WbFWrFE76PUw6EfyNsOxiqC3t3PEnIzUTznsS5v9A/b7+Bfjg9/Daj+Hf5/HIrLV4fp3BTeYnWfsDO/862aNWFb39KyAIcy/Fd8qfCGjhnPTNt97W6imWf/AhADOmT2u5r7a2lk2bVcLhyCMOb7X9mMJCAEpKOvm6Vz0B/zhSJRVMVlhwHZz5ADgmt77+YzUtT8lQCYdkVvOk5UnSQAghhBBCCCGEECJkUK9YyM3N5dprryU9XTXnfOaZZ7jllltYtmwZixYtYv369dx4440sX76cI488kjvvvJPU1FRycnL6+Mh7WXQ5mI4ET/VgncEUnoXsdbVuIByZTDBbwz91k06Es+6Hl69WyYUNL8HEE7j7e8dz/Fdf8fu7/sAHy9/mn489wceffMIbb7zJaaedymOPPswh8w7GZDJRWFjYZob3iSccD8Desn2MD923a9duSB8OU05VN1DHVrZGrZrY9h4c+Fb9XrZGJRdsuaqUTMF8+OIBqClRM6HPfRRGze7YuW6P3l9h+EFtz7N+3hKtCIk2FMsbdVZvl7GJbG5+7qPw+ClwYINKXC19M7yyobsZjLDwNzD2SFWGqW4fNOyHun14q0ux4CfN6GXWCCPgg81vqsctuBaOvhF84USbZjDw3gcfsfz9Dzjh+ONY8cmnvPveB5hMJi46/9yW7TIzM5kzexZr1n7DQ4/8kz/ceXvE39TqiAZXQ8dfy8f3qsbUAAWHwqI7VLLAFmpOHX39x2paHkmaLwshhBBCCCGEEEIkZVAnFoCWpALAggUL+Prrr1vqNh999NEMHz6cVatWEQwGGTduXF8dZv8XL+AWKxirJxLclerfoBIPeqIhVuB2wkI470mCXz2KtnMFbFvOsSyn9OcO/vRxHf/46x/58bXXcPcf7+WXv76Zk08+CaPRyI+u/mHcQ87LU4kOb1M44bBl23YaGhpa984wmCD/EHU79iao3w/b34etb6u68u5K2PCiuoHqx7D4ccjp5uulfj/U7FZlWxyTWp8/VxUE/aCZYq9kEF3XG0kYfRxFN91OSYeLlsEjJ6jkwgvfU9dYR/p+dNSE49QtwvbiTSw4bD7jci2ccfQc9m5ezeITDuWUJT+GySe22cVZp5/KCy+8wKLTzubq71/JN+vWA/C9pZcyYfz4lu00TeO2//dbTj/7XP72wIP89PprGTFiBADWVJVk9HgaO3b8EUmF4IJr0RZch9tgx+12Y9OstHknk3l/pfmyEEIIIYQQQgghRFIGfWIh0pgxYxgzZgygmpR6vV7S0tKYMWNGq+bNIoZ4ATc9WOdzh0sied2q7H+Q1n0X9JJI0UFVUPcVLqB53LHUlG6i9r0/MWzvO4y2ern3xFRqGj9gzczjeTgri/XrN/DwI49y9Q9/kPCQG/wGhk+YQVNEo0+bo4BX3v+S+fMPIdNqYVhmatsHpo9Q5Y2mnwUBL+xdrWrS7/xIrV44/c9gz+vMWUxs+/vqZ/Z4NetaP3+eOjCZob4a0oe1bdgcj8y+7jvxzr0+jmK9h5kFcNF/4InTYes7agXPqX+E1IxeO+ypU6cwvHAia7du46TRC3jsmS95efcGyn59DLV1jdR6/Hh9gZbtf/6b27Hn5fPSK//j8f++SmNtBampqdz8ixvb7PvUU07msEPn88WXK/n9H+7hr3++FwCbTZ0Hj8eT3EH6m1QT6pUPAxA85hdszz6WXR9/QVpOHuNGj8DjqcZmSaLEUTRpviz6WHFxccz7HQ6HWpknhBBCCCGEEEL0E0MqsRBJ0zTuuOMOPv30U2699da+Ppz+r72Amx4w9dSCNTO8QkEv3+N1Q81eFSDXRZZECv07aLCQOW42Hw1bTFXwMA7StjC65GXyU13kfnE7t9x8Ez/9v1/wsxt/wTFHH820aUUxD6e8rpErHvmKWZfd1er++Vf9kX9thH9t/Aqz0cBj318QO7mgM1pUw9vCw+DYX3bkjHVMQzl8ECoPM+E4lYjRz589VJorJbT6JrKMVCLtzb72uaHBqZJAdofUj+9O+rlvcIZX6ehNtfUVC7GMPhi+8w94/koofhX2rYWzHww3dO5hmqbxnTNP5w/3/oVdu0sZPWoUe8vKePrFN3lpXx6+QOuG1795dTuMWsSCqxfR7PfxyX3f5ydXLWH06FEx9337rbdwwsmn8eBDj/C9pZczc+ZBWK1q/Hk8HoLBYOIkr3MrvHI17P8WgOCRP4PDr2PvWy/j93hwNjUxaVQutlRz23MfKV7iR0qHiT7icDiw2WwsWbIk5t9tNhvFxcWSXBBCCCGEEEII0W8M6ubN8Tz//PNce+21PPDAA7z88stMmjSprw+p/2uvea3eJNWe27rskT033Gch6If6crV9ZN8Fnwea6qFmL8amWoxNtUwoGEla9nBSF1yF9/z/UO+FmTleZvvXcOKiE/B4PFy05BIaG2OXT6l1+9oEQaP5As3UerxdOSvdIxiEN36mSh/lTgw31o3sqRB5S3Y2dXuNmxucqlFwQ0XshsWi8yw28HvBU6Wubf386uOnZq9avQOtm5t73TDmSFjyolrBUFMCT54Jn/wFmgMxn6q7nX3GaQC8+c67XLbkQgCeefmNdseTwWTmqX89xR23/jbuNguPP47vnHUmfr+fK39wNX6/H6tVJVn0VWQxBYOw9j/w2CKVVLDlwnceRjvqp2heD4UjckhP0SgaO4ycdCtWi0klzOI1407UqFuIPlBYWEhxcTGrVq1qc3v66adxu904nc6+PkwhhBBCCCGEEKLFkFyxUFRUxHPPPceKFSuYNm1arzxno9ePJaIkT68IJg4EqqB+aDZ7srPg47KAWW82G3reyNcbtIDfAKkO8AXAZIVAALTQYzxNYDITrHGCyczkUTlMLppBs9GCFmzmrcBhnMMXzK15g3v+37Os27CJDcVbuPGm33DPH0KrEvzhwKvXH24wm4jX10yjN07A1p9kIFdLMj9njL0/47r/YN76DkGjBe+JdxPMGAPuqlDiJQDEa+IbmtntrgRXNdizVcC1Reg9CdL6vdB5XOBxg1kDUmJv0xXtXX+ocdER3TqOkji+zo8RC2gpYExX13aKQ51fnwf2bYNmH9RVwQgL+D0R7zXq3zlT4bJ3ML97E8bil+Gju2je8RG+k/9EMCtqxrKWxOsANd6SMHP2bEbmF1B+oJwJE6dgtKTy9Zp1zJ/X/mOLpk3D6w8CEc9lbD0+7v3jH/nwky9Ys24Df/rbg1z9g6swmlMAqKqtJzsr6mupqQ7zOz/HuOlV9TLGHIXvjAcgbXjooybAiHHTGDF2Gvg8NLrr0MxpKgnnc4Mh1rWdos5HzL/F0Y/L5XV0HIleUFOqPpvbY8uFrAJAJRdkRYIQQgghhBBCiIFCCwaTia4NPj6fD7PZ3P6GXVRXV0dmZibH/+pZTKlSYqOzDMFm/tx8C1PZzgrtUO4wXN/Xh9QtRgQP8GDzTdho5BHtIp43nNHXh9Sr/I1u3v/9+dTW1pKREb+XwJAdR8EgJwQ/5trg41hRTcgryWIHY9ipFbKDQnZoYyhlJM1aDzZ67iNTg1u5qfl+RlBBAANPaOfznHY6wWSTeUNER8dRe9v1pdWrV3PwwQezatUq5s6dG3ObRq+fs/7wNgCv/OIkUi39bI5ETSn8fb5KbLXHbINrVrYkF2JJ5pyIrhsI40MIIYQQQggh+pN+9l/jvac3kgqi+zRrBu4zXMn9zTdzdPBL3g2uYaU2p68Pq0sMwWZubP4HNhr5lqm8qJ3W14ck+htNY7l2NBuDk/hp8yPMZBO51JBLDYcEv1HbBMGLmd2MDiUbxvC1NpNSbXTfHnuSDMFmMqkjmxqyqSU7WEs2tYzkACcHP8RIM/vI4y7DtWzSpGydGADclSqpcM4j4JgcfzvnFnjxKij5POHqBmvNFgoy+u+KGSGEEEIIIYQQQ9OQTSz0tmU/Xdh/Z8B1ZNFKV8sntXp8RNNkrwf8HoJeD/gaVVkfk5Vmn5v777+f995+g4ZR+Txrz+aisZV8v+ZuHNk/4vGXlrN+/XoALCkpLD73HGbNPAh/Sg7vV+W1ezh/uuQQJgxPj/3HpEufJDt7OgheF5rrADSUY9zyOqavNhO02Jl80f28NHJm6Hnj7M9dqcrkGEyqfEas9yJuWaQk9EGplzrnfob/Pvntu3UcRV738a7r9q73yPfE7oj9PF53eB968+ZY71vkexup5RjOp9FVgbb7UwxVO9Dq92Co3olWsRGLz80kdjEpuEu9NIMF3zlP0DzhhPB+ku3RoBn4+4MP8otf3sS555zLPx95mKNPP4+8E65p96F/+u5cJgxPp7aulgcfeoS/3v8gdXW1LX9//bVXOT5lHSufuYd0g5vJI7OwBOowJLj0/EXfIeuke7grVb3vmqapUmHuarBlgy2H6IV3qgG0ps6dq1JVDbPlJv+ZFev9SHZ8JPt52o3jra6urkPjSPQSx2QYNTv+32256nPgxasS7qYIKL4mjR3uA916eEIIIYQQQgghRFdIYqGXpFpM/a9cg65DiYUmMAaBJrDECcgn/fi0iPu9YAwStBhCTaKt4PPQbIT/+8mPSbNZKNldys6U4exueJExGQFOd/6debc9zO7qAPf97a+sXPkVTz35BE8B6SMnsODq+9o9HIvZQKolTgmZpMuthLYLNkP1LjiwHqp3Q8MBaNgP9frP/eBtaPs0x91MimMM+GrBYlXnxRdq5GuxhRv+aukR95lC5z/qPfAZISMLDEbo6PXWB4kFb1rHkgTdOo70697nBlcZmMyAsfV1HescR4p8T+IdlyUDiHid3tAY8FWjxoENzEZw1YSac0ftp9UxNMHURa0TGfUHYPcX0FAGdWVQ+iXanpVYXrwczn8KJi1S2yXXdgQ0I3k5WQR8TdRUVZBmS+Ffjz3Kz/6zpt2Hul113H77X7j/wYeorVUJhRkzZlCQn89bb71F/b8vxzzexREjAAwQqAMNmoNBanxmjGl5WB0F7K1ys78hiHnisRx81k3s27WNvRVVjCyYwJgxheBuImhqVufDbCTo86Dpzc7N1nBiwZKutmn20+ozK9b4anUOosYa9OvEgre/freIxLIKVBmkdnox7Pz6bcat/j0mb23C7YQQQgghhBBCiN4k0QgRX6zgmz7j2tLJOvf640HNJDZbQ/tXiQTN71VBwNAsY0MQsOfwo+tuIOj1oHmquOmab/lhfjETsg0Yl1/NpKuXc/Hnn/PF55/x72XLqKhwUtecSjLzsxsaGmgV9E1WUz2UF6skwoENsH8DlG8En6v9x5pSwT4M0oZB0ekwZwnU7gsFtlGJBa9bnQevO3zuzXGCoJGi35/2AqhCnR+TGfw+SO/gOUrmPYmmv0f6ta6PB2tm8o+NHH+aAUbNBH8RZI0Cgxle/B4UvwbPXtI6uZCk7KxsAKqrqwFISU1NtHmL0846l4qdGwCYVlTEb371S86/8GJqqqt4/UeTWTzeRSAIv3qvkabsKZyy+BIuveYXuIKpHHvskZx75qmMysvmP2/8kxRbBhNNAeb5Gzmwbw9+r5+9ZXtVYkGP3Yd+aj4PWnOoOTaon5HXvKcO7DnhA401viJ15n0VojOyChL2VwBoTNvUSwcjhBBCCCGEEEIkTxILIr7OBrcT0R/vcqp96wFA/QbgqgItCKmZama2ycqXK7+keGMxs8Y7OOLUxTy4/E1+GFzFuKwgex89mZqr3+Owww7lsMMOBaC81sMV//gMXyD+NO2Az8ubr77EnBvaKfHiqYa9a6BsNexfpxIJ1btib2swQ+4EGD4d0kZC+nCwZqvXYh+mZkwbDOq12nJC56IyHNhOC5Vq6WwCJ/r9aS+AKsLnOL2Xgsn6e2Rxt36Pk3m/Y40/S+iaSbOG/3bOo/D8Utj8Rji5MOG4pA8xKysLgJrQqoNMqxmz0ZBwPDX7vdRXlTN3zmxuvukXnHXmGRgMBtAg57PbuGR6kEBzkEte8rBsvZ+bf30mT769mnJXkNGjsqmurmHKQXN455138JuzwF3DnIOKABiR5+DAgf3kDQslB+y54FMJyc+/+IIt69cyffI4DllwtPpMiUzYuKrCSbuWcxZjfEkSTgghhBBCCCGEECJpklgQ8XV1dUJ7+25wguYFr7X1c1gzIOBVSYVQTfSNGzfSVF/N9m21LD73fMZNPZhHH/0r3+N9xmX52P/AMRw44bcMX/gj0AwMy7Ty2A8Pp9bjw+tr5oanvgJUTwWL2cCLL77M//vNr9iebeMX1/8QozFGOaS6Mnj/Nlj3HOEp0hHsw2DkTBg+Q9XSTs2G9GGQVQi2WPX2gyqJEAyoGdTeMlUjPjIwDCrpYrHFr9nfET35Hg4WfTU7Pfp5O3oMeiA8VumdZh8cczP4m2D7eyq5cOgPYMF1YM1qd9e56RbOKTJx3owDNN8zkWHWTP5z9I85MOZMvIFgy3gqalzLVVdcysWXLGXLxnUccfAM3n791fB48jfBG9fBt88R1Az8ZrWDZeu3AXDUUUfyt/vvByAnJ5v6hnoWHHYYlU5VFmbBrMmcsPB4APLHTiR/5HAI+CKC/6HPhg0bqG9oYu2WPRxyjL5SxxO+9mOtRon1nksSTgghhBBCCCGEECJpklgQ8XUm4JrsrF+9kW3kqgVoKYlESrr6WbkNjKnMmDKB7Zu+ZfzECWC2Mn7CBI485Rxue7SEX03eysQcA3x+K+x8CRb9DsYewbBMK8MyrTR6w0WRJgxPJ9Vi5MdLz+N3v7yeXbsq2Lp1K1OnTm39Gj5/ED77q/o3QGYBjJgJo+ephEJ2IdiHQ+Yo8HuSO1c+t9o2CPgbwaCpBrR6YgFUE+tgoP3gZqzzHOu+WMclM7MHB5dTleRq9kPacHXt6O+n1wMpVjjuVypBt/Vt+OxvsPopOOJ6OORKVZIrUv0B2PIWbH2Hop0f8cL5oX01VkNjNRnLbyAj72G8R/8KgkbQNP73/FMUjc5g3efvMWLEcP795GPhpILLCc9fAXtWgmYkcOb9HHtYLve8fTr5+fm88+671NbWYrOmkpGR0VJu6bQTj+P04xa0PjafGxrrwWSC2r1qtQ+A2cq06dPZuGED06ZPDzXG1nstRFzbyaxG6e4knIwzIYQQQgghhBBCDGKSWBDdqyOzfvUkgjkisB5ZEqlmLzTWgdHNIdMmMG/6BLQgYLFiBU486jDGjbyNu/9yHzmrP+JXR6WQsX8dPHU2TDoJTrgFHJNiPrXVaqWwsIBNmzZTVrZPJRaCQdjwErz3O6jbqzbMnw8n3QGj54YfXLNXNWI2p6rjDwZUELG91+v1gNECmlG9Zne1WrHQkkzwqCSDr7H94Gas85zsuZeZ2YODvlDBmKquqcgElf5vzQin/wV2roBP/wwVm+C9W+GrR+Hon8OoWbDlHZVQKFvd8nAN2NeUyksbvTz7TT3zRhn57XF2Mio2YXnhUu5lCv80XMR7O3dxw42/BOBnP7me4cOHqx1UbFarJGpKICUD/zn/JDjuGOaMrmXFRx+xf/8+zr/gQgDmzJmDwWDAmprK5198QUFuGvkjh4FmUn0R3FVq3Niy1NgwmtV9qRng87DgsMNYcNhhqmGzqzKcrNS0jgX2u3vliowz0c1SG3ZD2drEG9ly2+3ZIIQQQgghhBBCdAdJLIju1ZFZv5FJhFjsORDwhAKnqICipnouqCC9iUljC5kxcw53fbqOx9aU88oNC1hgKlYztLcth0mLMKWN4sLmBqrIwrA9CFkjIG0Yo0eMYNOmzezbvx/2roZ3boY9qsSL1zoc55xrGbXwahWgjGS2qsCNXqrJ71HHU7dOHWtWfuxAosUaTh6YbapOPKikhKtKvUaLNbkSSLHOc+R9iWZLS3mkwSHNAV6bSnBFv8f67+5q8NTAhONh2pkE1z0LK+5Gq9sL/7u+zS69uUWYp5/J3z8o4eNt5VgzbXiGbebBbzby6Opq/nr+OC6Z1MCMwGb+3Pz/OOZcEzct97CrOZUrLr9U7WTHR/DiVdBURzCrkMZz/oVpxLSW55g4cQLXXHMNfr+fMWPGYLPZ8Pl8lJWV0ehp5LmX38dV7WTGnEM4+7yL1BgLNXNvWanQ8jpDyUl3pUq0WGzhcdnXgX0ZZ6Kb+C2ZuLxBxq3+Paz+feKNzTa4ZqUkF4QQQgghhBBC9DhJLIju1R2zfiPLmYw4SK0k0IP3+kxsi5WguwYtxc6UKVM47cQTePTJf/Odh7fx7QcvYfvsj9j3rIAtb2EClur7fv7hlqd552goPzgN047fwXZny/G7Zyxh37hzyBwxniAqntn6NUastLBYwWIH11ZoqgPNHbrfnfy5MNvAHLlqIS3Jx8QIJuv36c2xYwVV+6qngOhe+vsYjNNQ2esB/Kp8EIDBCLMuhOlnE/z6cbRP/wI+D5XpU9mXOZfGwmMgbThzD55H87r7ycryk5mZQVpaGikmjXUbt3DZUzt5/ZSjufzQbE4MfsjZU4ycMcnOp66x5JiaYNWT8PavIBggMGoenjMepNGUhc3nAyAQ8POPhx5izdq1ZGZm8tvf/Ia1a9dQVlbGlKlTSbWmUlJWQSAQ4OtvNnDW4mBoPIXKpgGanpDTe0u4q8DboP5tiUjYRa5Y6AsyzkQ38dmGU/T3Bt5+6T8URZbti+bcopJ67kpJLAghhBBCCCGE6HGSWBD9j8/TUs5Ea5l970GzRNRNN9swZo0Er4eJE8dxysKjeO6lVzlQXs6Tr3/Jj374NL7yb9D2rSVQt58Pv1pPdrCGuQ4vBrcTzVOJgWZGpBkgqJIKpdlHMPq8O7HaHYzXjGrFBKgArc8TPj6zNfw3nT279eqK5hjlkSJLHrVZRWBtnTjpKpktLSxWcJtUP48QTdPU9TtvKRx0PqvXb8ATMFFXX4/D7mDk8BFo/kbmz5xEmsXInvIqVq1aTW29m+HDHPj9fl5Y/iU1C17gheCp/Nr8JOOa1nN0+m74+3zVNBpomnIWwVPuwWRKIaVZwxRKbnz++efcddcfADjhuKM544wzWLjweFJSUjAaTTgcuezds4cvV65k1qxZ6nghZtm0Vn+zpKkVC5Fl1SSw36+VlJTgdDrb3F9cXNwHR9MBNaUqcJ+Ic0u3P21pXRBP1mQYNbvb9y2EEEIIIYQQQnSGJBZE8qJLAsWjzyRuf4ex725V0scDNWVgMqvnj5zNb7aD2Y7XlMHY8ROYMH4sq9d+y40//wWPP/EkP7/xRs4770r8zRp/WvUBAE9ftAACfmypKTz617t4/P67OWTKKHInHsxv/u8pKusqsTX5sWVmgmZQz+NvVAmBhgOqHBOh2u/6TGo0sOepm88NDU4IeCHV0fqcpdjDr0vfd8upMKhto++H+GWNEr0fFru6QQfej0Ei2deb7PXcX3hdEStl7OH7Y70Or1v1IzCngjVDbWO0hP/eWAcGA45cByWVbqZNmUzBSIdK5Hld5OXmcPAMAx/+9e+MyM0kb9gw9u/fT8HwXD7/ZjMApdposn70Fk0VazC8dyvmfV8D0HTkz2mY9X1sKeoYg81+0DQeffRRrrvuxzQ3N3PaouN45slHMaY5cHvsuFwuNm3ezO53djN90lgWn/Bj9fHgaww3Ym659qNeb+S13h8MtOuqD5SUlFBUVITb7Y75d5vNhsORREm43lZTqhJovtjH3YrZpvoddKN4SReHw0FhYWG3PpcQQgghhBBCCNEeSSyInpWo1n880SV9TGbw+yC97eM3bdrE6m+LqaiowGA0M2L4cFxuNxs3buTypUu5/Y47eO31N9s+h8FI+siJfHOgmQPBRs4aHWDLqg9JzRlFTX0jEydacThCs5/12dLGVCCgEg3NflX33edp/dq8bjBZQnXe49S997pb/67fF690UVdrxXfmPRD9j88DTfWqH0fW6NbB9MjyYXpCrtmvYvB6z4FIoeRdwYQpFEyxgrtSJQAanKBBXU0l7y3/AL/Xi9EUZPKM2cycOZOdWzfh8YcTN/UN9aSOnkfDOc9gLf8aDGYC+fOhydvq6f7xj4e4/nrV08GRnUWqKcif/vYAN/7fjaz/6iM2btnJzj37GTVqNNu3bGD2mGz1QLOt5djdHg8ulwu73Y7dJtfxQOZ0OnG73Tz99NMUFRW1+Xu/DZS7K9Xn6TmPgGNy4m27sYmyw+HAZrOxZMmS2E9ls1FcXEyh/D86IYQQQgghhBC9SP4zVPSsrgbF9VI+6bGD4tt37MBsMrNmzVpMZjMjRozAkmKhurqanTt3sW3bNn7161/DzEvbPLaxUZWICQaDNFQdYNfGNQwbXU2KYwyVlapER2Wlk9xcB3l5jnCCQad527629koQ6eejwRluXq0/1lPXtsRSMvtsT183sRXdw2xVSQWTOZTQikgsRJQPA9R7raGCm7GuGz1553ODu5KKSifVlVXkZFpx5I2ktsFHjVdj5KjRjCwcz6JTz2TixIlYLBY++uQz7vlUJceuvvpHPLvsadA0AoVHxDzs8vJybr31VgAKCwtJSUlhd0UDB95cTuHIPJa/8zb7Dhygzm/hoosuYsLkmWwp3U9pSSmjJs+kaLqa9e1yufD7/Sq5YGunQbkYEIqKipg7d25fH0bHOXq3JFFhYSHFxcVxS0ctWbIEp9NJ4YgYK96EEEIIIYQQQogeIokF0bN6uNb/hPHj2b5jBwaDgXFjx5JihNHDc9i6s5TUlBQ2Fm/i1VdeYWGMxMKq1asBSEtLo6q+EZvdjinFSqbNTFaug8pKJ01NXiornSqxoCcCdC5UoDcyGZBMXXdPnfppsrQO9lszYm/f1Vrx0m9hcAShLXa1UiGq1wDQugeBqxJ8DWBOa/c9d+4rpdpZTnVdPSlZo9i6p5Ka+kbS09OYOq6AGs8IJkyZTmZmJm63B4vFwp7SPYC65t9+6y1+97vb+PmNN7bZdyAQ4LHHHue3v/0ttbW1pKSkMHv2bDRNo7z8AFnZ2ewo3Ud5hZM6T4BmYzPHHnMMU6dO5fU33sDjt+LZtZei6bMBsNvtLSsWAPV+NtWpMZidP3DfVyGSUFhY2D9XcQghhBBCCCGEGLIksSB6VleD4u3Mtp86dSpTJ47B5Ktj3cYtWLQAa1avIsVoZOrYkZgCHtZt2xtz16v1xEJ6JhVNJsr9aWQYU5lYNLMlcKuvWIjJ5wb8ydXbjmTNAL9XlaixRMy81oDUOMmFrpAmtgNz1Ua8ngqxRCa99May0aX+YyRX9ux30lBTTVl5JYGyGiwpKaRlOcjMMvDdiy+ksroOV7OFzVs209TUhMVs4Y033oAZ4ZIsd999N5999hmXX345p59+Gtu3b+fDDz7khRdfbBljudlZjB03HhN+MixGMsfmk5U3kvSc4Rxx4lkUFxczdUIheXYD+BtbEobr1q3j+eefZ9asWZx80kk48vLCZZAsttAKDlO4vNhATx6JvtNHTZmFEEIIIYQQQoiBShILQunpGd2d3X8ys+1dThYeNpsTjj6CN97/jM8//4LMPAcjc7zMmTKWrY8827Kp3x8g6PfS0BBg/fr1AMydO4f9+/YzbFQhRquNoNcNwSC5uTnk5GRjMBgIRjQE1vTmrF4PeGqBDpSf0F9PWkZUH4k4fRlE9xiIqzaiyxv5POEeHtGlkCLZclv1JmgRI7mSkp5Dg9uNKehj+PCReHxBUlJSyMzIIoCRlPRsmj1uUrzVmJqbWbN2F4HmQMsuL7/sEh775z/55JNP+OSTT9A0rdVYSU9P57LvXsCsWbN49/0V5A/PpvjbtQQ1A5htLF26FJvVSjAYRGushmY/zT63ShhOncorr7xCbW0tK1as4LjjjsNZUcGwvDy1c7NNrVTQ39fuSB4NhpUtouP6uCmzEEIIIYQQQggxEEliQSg9PaO7s/tPMNu+JcAfBLMWhICHsfnDSE3PYmfJXgJ56VSW76dgWDgIVF5ezqTxY/j666/x+/2YTCbKy8upq6/jueeeY9r4Ufzvhf8wZ+4hnHXR5Wzbto0dO3cybuxYpkyZ0voALFYgM3GwOjpQGev1dDToHbnP9mayC2UgrtqILG/UXjPmSNElu/TGzhBeJRMyZswY8uwGhmek8uf77ufrjTs44YSFLF26lJWrv2V4Tgb7tn3LN199QrZjBN6AmUAgnFiYXDic67/3XT787Cs2bd9NY2MjqampjBo1EtAYOWIEEyZP48xzzsfV6Oej999hx+69NBuMmFPTsQc9bN64lW82bCY91UT53p2s27SduYceyXcvvpgFCxawYsUKZs2aRYrFgkNPKrSco6j3tbPjKLKx+kBb2SK6ro+aMgshhBBCCCGEEAOZJBaE0tMzuhPtvyOzhGNtm+YAr9r/zOnTeOAvf2RPlZs33niDFStWYM0KByOPO+54CkaPaAmO2u02TGYz1TU1fPXVVzj3jwKvi3WbdvD+l2sZNmwY04qmsXPXrraJBX1meKJzlkygsqNB78h9SmJh8LLY2zZoTkkP39eqVFKi5FYoKWEwgb11WS+7zYZ9ZAF5ubls3lGC1+flq6++YtGiRdTU1PDN5x+wZ/d2DD4X1Y0ai05fjNecyWehx7/13keMzk3n5JNO5PcLT6a8vJyyfWU4ch18+uknNDQ08MUXX1DhdLJnzx527z3A5l17SU1N5dA5s/j222/YvnMXxVv3YDab2bBhA06nky9WrWPYsGFcsXQpV15xRXLnqyvjKPJxnlqwy4z0IamXmzILIYQQQgghhBADmSQWhNKdM7pdznBTYz2QmWj/HZklHGvblpUAKtBqz0wnByujRo+msHAMowvGsTX08Lq6WtZVlrfsrra2jldeebXl95yMNCpr68nMDFL/zSrco4dx6JyDKBw7tu2xtMwMjy5mTzgBAm1miXfZQCzrI9rqSEItOskAsUsl6SKTDfqKh3jXS2j8zJ6/gHfeeReLxcKBAwfIysriy8o6NIudkv1OjigqxOVxYzaZwK8e2hjQ2L57L5MmT+bbNSt5/e33SUtP4/AFhzN58hS2bNlMoDlIQ0M9Ho+b2tpa9bjGRsoqa9i+cxe2DAfp6TXYbHaOOuooli1bRl5eHmvWrGHRCSd0/py1J944smZ2bb9C9LVkekHIygshhBBCCCGEEF0kiQXR/VxVEGgMJRfiND6O1JFAeaJtI0rAWG1B3G43s6ZPobJiP1tDZd+nTJ5Clt1MXU0lVpOB7XsOUFXnatmFUWtG0zQMBgNmvFhTUlh07JFgy0nmlYfpCZAYs8S7TE+kaDESGmLg6GrZnVilkjx1qjl4ZCJBHxc+j0r6xQnK3/vHe/n9nXfS6HFT69zP+WcswlNXzdr1m/A2NfL1l1+wqXgT5e4gzD8IgPS0NPIcNjLsVr5c+TnuukpwV7FzWw71Hi/5+fmMGjWKsr1lTJo0mW+//bbl+TSjhRff+oisrCwmTZzI/PnzmTtnDhMnTmT16tXMmTOn+89Zq/PXDWXJRLtKSkpwOp2t7isuLu6joxnk9FV0L17V/rZmG1yzUpILQgghhBBCCCE6TRILUQKBAEajsa8Po3d1d4DangOuSvUz0b71Jq8dWS2RcNvwc9ltdmbNmk1J8Wq2FldAqLKJ2dDMlPwcMmeMJ1BTytz8VKrIZNWWPWRaU/AHDRiMJlJSrUwYO5GDiiZRUevCubscR14eeQ4HMVcoROuNAGVEk9yEJAHRO5J9P3RdvUYiVzFomtqXPSe87+jrNFZQPnIFgMnK7Nmz+fqrr5g8fgw0Bzj68PlUu5r43ysvkmoMYGvw0uA3kB3a5cKFJ7B3RzG5w0agpVjJzbCTajHR3OTiwN691B/YjbOskHFTpnHUUUezfv16Kiur8Pv9HH74Alas+JjVq1fR1NTEnLlzcXs8zJo1i8MPPxybzdr2GDtyzjpz3cdaGSI6raSkhKKiItzutk2RbTYbDkc3J12HuqwClSxwVybezrlFJR/clZJYEEIIIYQQQgjRaZJYiLBt2zbeffddzjzzTEaPHt2pfTQ1NdHU1NTye11dXXcd3sCRlqduHdGdJU5C5syezZzpk1mzbmPLfVlpKWTlOpg9fTKrPnPipYHcrHRyHMNwudykBqChoQGL2UzeqAUMHzeNvz/8GGPHjuPQ+fNDiYUkDMRmwf3IkBhH3XmNJLOvWEH5yGSDycqpp5zCqaeeQnOjC/werrvhRjZtL6GytgGLxcLEEekcNWsO60MPP/PMM6mpXIDRaMCY5qDqwF5GOrL5eu0Ggl4X9c79NFSU8nF5FSeeeBJHHnlkS4Nnr9dHY2Mj6ekZuFwu8vPzcblc+P1+XC5XOLEQeYx2h4yrAcTpdOJ2u3n66acpKipq9TeHw0FhYWEfHdkgllUgyQIhhBBCCCGEEL1CEgsh69at47jjjuPKK6/E41G1ypubmzEYDASDQbQkZ7/eeeed3HrrrT15qINTd5Y4iWS2MffIhXyxVv06eswExk+egW1YAWNnBanZv5sFx5/G1vsfwmwyk52Tg9fnpbGpiTfffIt9+/YzengOB3ZtxHHicTQHmzFgaNl9steF6BgZRz2gA6V/gmYrmsXGNxu3YrVaMZlMLFy4kJycHPbuOwAZarsXX3iePds3suDQeSw66XSMqWnk5ORwyNF7qdy1nofv/zPltS4IwKGHzmf27NkMHz6crVu3omlwyCGH0NjYyIQJE3C73QwbNgyXy4Xdbm9ZAKJJeaIBr6ioiLlz5/b1YQghhBBCCCGEEKIbGdrfZPDbt28fixcv5oorruDuu+9m4sSJAC3lGzoSPL7pppuora1tuZWWlvbIMQ86Flv7TY59blUj3te2rEY0TdPQ/B40dyUnHXdUy/17D1Tx3icreffDj9m8ez85E+bgM6RQU1PNnr172L17Ny6Xm8pKJ6ZmL9V7tzLWYWfh4fPIMzWiBZoSPGs36cDrHKxkHPWgyOvLbGtZBaBpmrqhYTQaMBg0CgsLKSsrY/LkySxevJht27ZhSUlp2dX6rz/mwK7NfPTecvx1B9i85lP+8dd7+d/Lz2ExGRiWP4ZGUhk3bhwGzUBxcTG7du6ktrYWl8vN6NGjSU1NJTc3l23btrU6TE0LVTOKOMaEr0UIIYQQQgghhBBC9BpZsQBs3LiR3Nxc7rrrLgKBADfccAObNm3C4/Fw3nnncd111wEktXIhJSWFlIjAm0iSPptaDxTGKonU0VUNLic0NYAhvG1zczNGoxENjVSrlR07dnDgwAFGjRrFlClTsdmsbFi/AU3TGJ6bzkmLTuCSJd9VjW9NZtZ99Rnf7thPUVERB0fOwO3OUk49tXpjABkU46gHynt1yzF04Pp6++23CAZVgP+dd95lxIgRaEZLy9+HORyUuWrIGz6cVKuVivID7Nm1DZvNxrZdGZx+9mJGTtnNQVMngLuSD999gz179+Lz+cjJyWHTpk00NTby5ptvctZZZ7WUQiovL8dut6ubLcExylgRovOcW9rfxpYrpZWEEEIIIYQQQsQkiQWgtLQUo9GI0WjkuOOOw2q1Mn/+fDweDz/5yU/YvXs3f/zjH6XsTW9IFCjsaEmUYNRPYPr0aVhMBmpqavD5/Zx++ml8/fUqrFbVSNRsNgMwevRojj3heK644nuQEg7IFm/bTYPbR3FxcevEQmcCnPECz91V+qVV01tpSNvr+kPQO9YxdPL6Wr16NdnZ2ZSW7YdQC5Ull15Oaekexk89CGvOaDIyc0hNz8aans74CROZMeMgDj54HppPHYcZHwaDgbKyMgqG5+LBg8Vqxp6WRl1dHXa7HZfLRVNTU0uvhYSJBSmTJETH2XLV58GLV7W/rdmmGkJLckEIIYQQQgghRBRJLABTpkxhw4YN3HvvvdhsNh5++OGW5s1HHHEEixcv5rjjjuO0007r4yMdAhIFCqNrxEcF5l1ud0t9drvNBmkO8NqA8Mz3/Px89u0pIT09nSnj8jn72IPJMTZiM8Pw0WNJz8igpqaa1FQr02YfAvZc3B5Py34nTZ9NcXFxm0aknQpwxgs8d1dT38j9S2Kh98W7JjqykiHZbTuSpOrA9eV2h6/9uXPn8s033+DfHS5LNf3gw5k6y8v2bdv5cs06tLRcvnP+d7FYzEyZMgXcVTS66nDV1WHLzOGo40/CsW0306ZNo7m+gukTD6fR62fbvhoyMlQTZ4fD0ZJgsNvbuW6lSbpoT00puCsTb5PMzP1+rri4uM19cRtkZxWoZEEy5+XFq9R2klgQQgghhBBCCBFlyCcWgsEgRUVFnHnmmfz73/8mEAi0JBWCwSCLFi1i1qxZ7Ny5s4+PdJDxumIHQjsSKIwKzLtcLgKRs5z1fXn9LQ+ZOXUShfmj+OSTj6ncv4c1Kz+jcHg2Z516En6M2FOMpKeeyt4DleTk5AC0lGdxuVwUFRVRWFjYNuDZmQBnT8+2ltncfSveNREvodSVskUdTVIlmbCIvPZPPHERixYt4qVX/sfD68PbVFVWsWXLFpqbm8nIyGDHju1UVVXjaWxkdtFkPv5sOd8Wb2HyjDmcftppzJ63AICguxLNVQX2HIpLKmhsbKSiogKHw4HNZsVms8Z/vUIko6YU/j4/uR4cZpuayT/AqPFiY8mSJW3+ZrPZKC4ujp9ckGSBEEIIIYQQQoguGPKJBU3TyMrK4owzzuDzzz9n27ZtvPPOO5x44olomkZaWhrZ2dmkpqb29aEOLt1RJiYqcJ7MLOepk8YwoWg2Hrebxvoq3lz+EZrJxIGaJjLtZlIsFhqbmhg18SA2b95Efn4+JSUl2KxWxowd2yrQarNGBT47WlO/p2db6/sfyiW8+kOfg2jxEj5dKVvU0SRSkuPvww8/5Msvv2T+/Pmcf/55AJx66sk8vP7dlm127NxBaWkpqakpHHbYYXzxxRcYDAa2bN7C7Fmz2FRSTq3Hz/bt29ldUkJZWRmpqamkG73kZKaTa1fB0YqKCvLy8lr2++67y1m1ahVz587lpBNPTO51CRHJXak+A855BByTE287QHsJFBYWUlxcjNPpbHV/cXExS5Yswel0xk4sCCGEEEIIIYQQXTTkEwt6Q+bFixfT3NzM7373O6688kpuu+02xo8fz5tvvklxcTELFy7s60MdXLpjNn1UYN5usyWuxw6UVdRgTithxkEzWP/tenbsOYCnzo2zopK9gSZGj3Dg8QWhrIzyA+UYDAYmT54C0JJIiJu80IO1DU7QUL0d0hz9J6A9FPWHPgfR4iWUOlO2KDJxYnckfwxJjr/ib1eT4q9n07erIZRYiOTyeNizZw9ZWVnk5GRTUJBPVfVkPvzgQ7bv2I73317y8/Mxm80cdNBBlJWV4fF4WL9+PaOH5ZCXZSNn1Dhyc1PIy1PHHwz1RFm1ahX19fWsWrVKEguiaxyTYdTsvj6KHlNYWCjJAyGEEEIIIYQQvW7IJBaqqqooLy/HaDQyZswYLBYLoFYsNDc3YzAYOP/883E4HDz77LNcffXVTJo0CU3TeP311xk3blwfvwLRrngz8yPur/f4KCkp5aijjmLBgsN55513eOuttygoVAHW3bt3k5+fT1nZPjIyMli/fgMzZhyEIy8PzWBQ/Ruikwp6JFQP1mpeaKpX93kjAsNDeeVAb4o8z5EB9P5y/uMdh8XeuhdGMBh7u0id7aMR/VzRh4g6xvmzprN29dfMnj0DTTOgaaBphpbt3LVV2Gx2SkpKmThpEprBQFZWNlXV1ezbt5+mJi9nnHEG555zDgA7d+2itLSUrKwsPH5oMqajWayhBuvqOdVzaMydO5dVq1Zx8MEHtz5nyZwXIYQQQgghhBBCCNGjhkRiYf369Vx66aX4/X62bNnCzTffzE033YTRaATAYDDg9/sxmUwcf/zxHH/88fz2t7/FbDZjMpnIzs7u41cwCPXRTPLU0KqDjz/+mIKCAk488UQWLVqEFgpcvvbaa5SXl6smtX4/Y8aMYfr06R17Ev31BJH+Bn2tnQD6gNfDfTROOfMcTjn55Lj7t5s1HA4HxxxzDFlZWQCUlpYyYsQIampqyMnJYd++fezctYtxY8cybNgw7HY7BQUFuN3uVqWPop100kmcdNJJ7R9kfyx3JYQQQgghhBBCCDHIDfrEwsaNGzn22GNZunQpS5cu5c033+TGG2/ksssuo6BA1VMOBoOYTK1PxYgRIzAYDLF2KbpDVwKiXQgkHnH44Xz15ed4PB5WrlxJaWkpBQUFjB07FoCDDjqIrVu3kpGRQXp6esLyEi6Xq6Uskt1mCydLDCZVlsabRMNQMXj1RsDbbOvZxEk7iRlbZi4FBSqZYAuVISsoKEDTNE499VT27NmDx+OhtLSUcaEeJXV1dTQ1NTF27FhsNiu7du1mz5495Ofnt4zDDvG6oakOXJWQXSDJBSGEEEIIIYQQQoheMKgTC06nk6uvvpolS5Zwzz33AFBUVMTy5cvZs2cPlZWVOBwO8vPzAfjDH/6A1+vlN7/5jSQVeprF3vkAYGQvA4utw4HbgoICSktLqampaQl6Op1ONm7cyPTp07FarezcuZPU1FTGhoKhLQmEiDJIkY2c7TZb62RJf6ztL3rXULgGzKnY7XYmTpzYkpwdO3YMY8aMQdPA7Xazfft2Ro8eDagG6xUVFaSkpKgG6DYrpaWlNDY28vHHH/PSSy/h9XpZuHAhhxxySOLn1hM3AH4fmMyD+1wLIYQQQgghhBBC9CODOrGgaRonn3wyixcvbrnv9ttv5+2332b//v04nU6mT5/OzTffzJw5c1izZg0lJSVcc8015OTk9OGRi4Qiexl0InA7ZswYxo4dy65QvfeCggJWrFhBQ0MDxcXFpKSk0NTURHl5ORCVQIhILNjt9tb3RTfa7cESNWIA6OEyRf1Fm3EQIS8vj+zs7Jakg81mbUnW6dsXFBSwZ88empqa2LhxI4FAgJycnPYTC5ErhLILhsS5FkIIIYQQQgghhOgvBnViITc3l2uvvZb09HQAnnnmGW655RaWLVvGokWLWL9+PTfeeCPLly/nyCOP5M477yQ1NVWSCv2dHsCPLDXTCWPHjmXs2LEEg0GmTZvGxo0bKSoqwmq10tTUREFBQUsANFbgtGUFQ6xmstFJBjH0DJFrwGazYrNZY/4t1tiJ3l5f4aD3Y2hsbGTMmDHtP3Fk4maInGsRlhd0kkk92v5vwGSMvZFzS+8eVD9UXFwc836Hw5Gw1F8ryZxHWy5kFXTgyIQQQgghhBBCDHSDOrEAtCQVABYsWMDXX3/N3LlzATj66KMZPnw4q1atIhgMMm7cuL46TNEZ3RhMnDdvHvPmzSMYDKJpWptZ1bpgRBKhoqKCiooK8vLyyHM4AFqaQAsxGAWDwVZjIBgM59X0S9/t9rRKyFVUVAAqoRAMhreLNm3atLjjLiZJJgxdtXt4tPlGUmmCx9rZ1mxTQe8hxuFwYLPZWLJkScy/22w2iouLEycXbLnq/L14VftPaLbBNSsluSCEEEIIIYQQQ8igTyxEGjNmTMtM2GAwiNfrJS0tjRkzZkhAeIjQNK1N/4zI917/d2Q/hfLy8pZSSHqDWlCJhaamJpwVFS2JBSGGEk0LJwo01D8iS4fpY0Ql4Bxqe9p+1mqa+p/oPiZCxKJ5Kkmhibu0H/HTpYtJibdiAYbsTPrCwkKKi4txOp1t/lZcXMySJUtwOp2JEwtZBSpZ4K5M/GTOLSr54K4ckudaCCGEEEIIIYaqIZVYiKRpGnfccQeffvopt956a18fjuisyHJIlp4JSEaWc4nsy5CXl0dFRQWOvLweeV4helu8RuUdEV3+SF+xsHFjMXl5eQyLHi+9MIbF4FSqjSY4YhZYhuz/lUmosLAw+XJH8WQVSLJACCGEEEIIIURMQ/K/xp9//nk+/PBDnnnmGd59910mTZrU14ckOktv4Op1d09Q0utqE+SMDLKWlpbi8XhYuXIlI0eOVAkGWa0gekNkAL6HSgDFa1Qez+6SUsr37aWgoIBxY8cCYLfZWnoo2GxW8vIcbNxY3LJyoU1iobvHsOh1JSUlcWfGCyGEEEIIIYQQYnAakomFoqIinnvuOVasWMG0adP6+nD6Xqzmw7F0d7moZPeX6PgiG7hGbhcZhA1aWu8r0f4ig5wxgrcFBQWUlpZSU1ODx+OhtLSUsWPHsHFjMdu2bWPixIlMj3dN9dV5Fl3TX963eNdmMseXZFKi1WqDGPvduHEjxVu2oX917Nmzh4C3kdLS0tY9aqIeqq/uycvLa3ue4o3heGR89CslJSUUFRXhdrtj/t1ms+GQ5KsQQgghhBBCCDHoDMnEwvTp03n66acxm819fSiiq+I1cG0VhLW0/Xs8kUHOGMaOHcPYsWPYtWt3S0kkgG3btuFyudi2bVs4sdALM8zFENLOtRmTfg363GC0xE2Y6ew2G3Zb/L/r1zlkApCfn9+yYiGRvLw8lVSIxWJXt2QTOKJfcTqduN1unn76aYqKitr83eFwdKwcT01puzX9NeeWjh6m6A3JvC9DtOeFEEIIIYQQQgxGQzKxAEhSYbBrNQu6A4+Ll6gIcbs9uFwuhg0bxpjRw9C8bvB5mDhxYsuKhRbtrH4Qg0Bv9gdo59qMSb8Gg4DB1LGkRAwTJ04MrVhQxhQWMmXi+E7tqzv6OYj+o6ioiLlz53ZtJzWl8Pf5alwlYAEaSaGW9K49n+getlz12fTiVe1va7aphtCSXBBCCCGEEEKIAW/IJhZEBw20BquRQVivv9t226oGvU1rSRxMnzatbQmkzswwFwNLf+8PoF+DaRndktyaPm0aEyZO5pH17wCgaRpajNJEse6LlnQ/B1n5M3S4K9X7fc4j4Jgcd7Mmf4DvPbGeCk1KLPULWQUqWdDOShOcW1TywV0piQUhhBBCCCGEGAQksSCS098DqL2kVQ16M4kTB52ZYS4Glv6ePOrH12CrsZSIrPwZehyTYdTsuH8Oev1UaPt773hE+7IKJFkghBBCCCGEEEOMJBZEcvp7ALWXtKlB352BzoG2KkT068A90K9n+yddAkk+ewaHJHonJFWjX3Sb4uLimPd3uC9GR0kvBiGEEEIIIYQYFCSxIJJjlmB3j5NVIaK7DYbZ/v09eTNElJSU4HQ629wfLzjdSpK9EwD1XttyO3GEIlkOhwObzcaSJUti/t1ms/Hiiy/GbLjepaSD9GIQQgghhBBCiEFFEgtC9BcyM1t0N7mmRDcoKSmhqKgIt7ttYqAgQ+PwsTZGUg5la2PvwLklqd4JgMxU7wWFhYUUFxfHTBRVVFRwzjnncPLJJ8d8rM1mo7i4uHPJhY72Yij5vP1t5XoRQgghhBBCiD4jiQUh+gt9ZnYSjW+FSIrM9hcdkGhVgtvt5umnn6aoqKjlfrP7ANM+uBxjoBFevSDxzs02KFwgQeB+orCwMG5yIF7Sobi4mCVLluB0Oju/aiGZXgyyskEIIYQQQgghBgRJLPSwYDAIQF1dXR8fSQKhY2xXXwW84x2fzw1eD1isCYOnjV4//kY107aurg6vpZ9f9kMosaCPi2A712CfjqO+Gh/JPm9PijHGemw89ffPoX6sw+No6+eQ1rrc2v4DB7jkkktobGyM+dj5hVYOKUhlhD1i1ULjAVxuD5zxV8idmPggrTlgyIRuGMMD7jN9gMnKyiIrK6vN/Q0NDS0/e/Sz2JAJl7wHnqrE21Vug9d+DBvfa//6S0JdgwtofxwJIYQQQgghhFC0oPwXVI/as2cPBQUyk06IREpLS8nPz4/7dxlHQrRPxpEQXdfeOBJCCCGEEEIIoUhioYc1NzdTVlZGeno6Wi/PtK2rq6OgoIDS0lIyMjJ69bl7w2B+fYP5tUH49ZWUlKBpGqNGjcJgMMTdvi/G0WB/D2BovEYY/K8zGAxSX1/f78bRQDrvcqw9Y6Acq36cGzduZMqUKQnHkRBCCCGEEEIIReoH9DCDwdDnM98yMjL69X/Qd9Vgfn2D+bUBZGZmJvX6+nIcDfb3AIbGa4TB/TozMzPb3aavxtFAOu9yrD1joBzr6NGjJakghBBCCCGEEEmS/3oSQgghhBBCCCGEEEIIIUTSJLEghBBCCCGEEEIIIYQQQoikSWJhEEtJSeGWW24hJSWlrw+lRwzm1zeYXxsMjNc3EI6xq4bCa4Sh8zr7m4F03uVYe8ZAOdaBcpxCCCGEEEII0Z9I82YhhBBCCCGEEEIIIYQQQiRNViwIIYQQQgghhBBCCCGEECJpklgQQgghhBBCCCGEEEIIIUTSTH19AINdc3MzZWVlpKeno2laXx+OEP1KMBikvr6eUaNGYTDEz3PKOBIiPhlHQnSdjCMhui7ZcSSEEEIIIQYHSSz0sLKyMgoKCvr6MITo10pLS8nPz4/7dxlHQrRPxpEQXSfjSIiua28cCSGEEEKIwUESCz0sPT0dUP8HOyMjo4+PZpCL04e80evnor+8D8CyaxaQihcsVjDbEu8v2ZmIyfY/7+6ZjX31vN2orq6OgoKClnESz6AaR/39fWvn+FqNp58cT6qlna8Rnxu8nuTGXDL68fXcV4baOGr0+rnoz+8BSV6D3am7vxcS6czYkfHRaUNtHA01rT43frqwdz83hpBkx5EQQgghhBgc5P9V9zB9mXxGRob8B2hPixPIsXj9mFJVUCYjd3jy/zEpiYVe0145iUE1jvr7+9bO8bUaTxkZSYynbn6/BsD13FeGyjjq+DXYjXozsdCZsSPjo8uGyjgaavr0c2MIkjJhQgghhBBDgxS/FEIIIYQQQgghhBBCCCFE0mS6jhi8fG7wuoGUvj4SIZKjX7MWG1jsfX00QgiQcSmEEEIIIYQQQsQgKxbE4OV1Q7NfBYV6m88NLmffPLcYuPRr1juArxu59sVg01/GpYwtIYQQQgghhBD9iCQWxOBlsYHBlHzTy+4M2vSXQJQYWPRr1tINTY77Sk9d+/r49Lq6d79CtKej49Lr6pkEgHyvCCGEEEIIIYToR6QUkhi8zDZ18/qT2z4yaJNsMiIeiy1cOqOnRZbpiD5uKeExsJhjvId9JfLagYh/WxI/rqeu/cjxKdey0LkrQUvv3LhJ9NkZqaPjsju/SyL15veKEEIIIYQQQgjRDkksCKHrzqBNbwaIEwWxJBgrOit6dnTLNdZOYqGnrn0JqopYuhLAH2gJgP6UeBRCCCGEEEIIMeRJYkH0LK9r4MyYH6hBm0RBLAnGDi3dOd6irx3938GuH2an6ONT0/roAES/1JXSYT31+Wixd+93SbIrK4QQQgghhBBCiF4kiQXR/YIRkceemhEaS7yAY+T9HQlKBjsRQU0UAEp2f8keo76dxR4/iBwZ4Grv+SVgOzD11HiLTrTp/3bVd22/A1V3j18RWzLnOXIbuwMsCf6vTGc+x/ubjozr7n69yV7PMj6EEEIIIYQQYsiR5s2iZw2GZrQdIc01RV/qjfHW3Q1phegrA+Xzeqh9jwohhBBCCCGEGBBkxYLoWQO1vFBnSekh0Zd6Y7wNpfEsBreB8nk91L5HhRBCCCGEEEIMCJJYEP3fQKovLQEgMZB0ZmyZrT17TEL0loHweT2Qvv+EEEIIIYQQQgwpUgpJ9H/9sVyFzw0u58AuCzMYXoNIXqz3uz+OrYFExtDQ4nNDQ4Vqkt5bEo1Ruf6EEEIIIYQQQvQhWbHQzZqammhqamr5va6urg+PZpDoj+UqerMpdU/px69BxlEPiPV+98exNZD04zEEMo66XeT7bbH3znMmGqP9/PoTQgghhBBCCDG4yYqFkG3btnH77bdz0UUX8fjjj7N169ZO7efOO+8kMzOz5VZQUNDNRzoEmW1gd/SvwElXm2n2h5mm/bghqIyjHhDr/e6JsdUfru3e0o/HEMg46jb6NQ29/34nGqP9/PoTQgghhBBCCDG4SWIBWL9+PUceeSSrV6+mvLycO+64gwceeICmpiaCwWCH9nXTTTdRW1vbcistLe2hoxbdqqPB0GQCson22R9K0PTHhE3IoB1HXlffBd2j3++eSgD0h2u7t/TjMQSDeBz1Nv2aBkjL677VCl0dg/35+htKCUbRL5SUlLB69WpWr15NSUlJXx+OEEIIIYQQQ8KQL4W0Z88eLrjgApYuXcqdd94JwBNPPMENN9zA9ddfz9ixYzu0v5SUFFJSUnrgSEVMkY0tuxLsiVVSoqNNM6O3T1SmQkrQJDRox1F7pUu663rujmPprMhruyNjSJrUdrtBO456W099Xkcn4brz+u/qeOrqZ5GUaRK9qKSkhKKiItxuNZZsNhvFxcUUFhb28ZEJIYQQQggxuA3pFQvBYJD333+foqIifvCDH9Dc3AzAxRdfzOjRo9m9e3cfH+EQl8yMRz144XJ2ralmZEkJ/XkbnGrfDc7kZl5GB4kSlanozzNNRdd5XbGvx/ZKl3TnbP/2xk9Hy6i07M+TeLvIa7sjryfetjLzeejqjfc+mefoqc/ryDHY3ljp6Lno6GdJ9P67+lkkZZpEL3I6nbjdbp5++mmefvpp3G43Tqezrw9LCCGEEEKIQW9Ir1jQNI0RI0Zw5JFHtlqZEAwGaWhoYN++fX13cL2pg+Week28GY9elwpumq3q5vOA3xd/dmTk63M5wZ7edhtzxKzOmhJoagDNqIIi/hrw1oMlHbITzH6LntVq7uRM0WTfD03r3u26+3kHi86Mj3jXrrmd2b+R15D+vJ2dedzejOGOXp9eNzTVgydGsCbeMeqvx2xtZ98utY8gkJaR+HX01XU61K777tad4yh6v135DuvozPro5+rM+Ix8jN0R3q/+vdbeceq/J3rOjq6yiD4PXV2loX++6AkL/Vjle0b0oKKior4+BCGEEEIIIYaUIZ1YADjxxBM58cQTAZVQ0DQNi8VCdnY2ZrO5Zbtly5YxadIk5s2b11eH2j90Z3mF9h4fLyjp86gAiM+jgjIWO5hdsYMyXhe4G8K/JxNA0uMeZqvavy8UUG0vzhEvUCslXoaezgblLPZw4kEPwHU08KlfbxB7xnDk3/VjTbRfPZEHKoFnMsfYJkEiJalj9oDRoo5XyoYJXW+893pyujPP4XND9Z7wmEj28z3WeNHHvc8THm9ma/j+yHMRuVJPTwIkSpYnI15ivKsBfimJJIQQQgghhBCD1pAuhRRNC/0HtKZp2O12UlNTAdUA8+qrryY7O7svD69/6Gp5hI48Xi8/ASqAopeVMVtDAUiruq+mFFxVrYMwOj0JoUumNEOaA9KGqZ+gjiFtePhYOmooNbMVSneWTkm2pEh0CS+IfQwtQcmq5K7LyDGUNRpS0sJ/c1eq57XYwO9V/+5M2Rp9TEvZMBGpp9/7VqvfOvEcXrdKKvh9sRN48UoXxRvT+ljTx2Zk2bHIc6E/Pkj3fbf0xLnWk5gBryQGhRBCCCGEEGIQGvIrFmLx+XxUVVXh9Xq5/fbbue+++1ixYgUTJkzo60Pre12dQdqRx7ucULsHfE2QPiz0eHvrWd0upypTBOCLkVgwW8EXCP9uSiKAFD3Ts7MljdqbOS4Glr5aeZLs9acnDDQSX2/6GLTnhH+Pu8+IEkX2dDW+vBHjSQ9q2h1qP709M1lWA4n2RCYPYiWem+pVID87v+PXkD520iPK/ujXY4MTvA1gSWtbQi/emNZXT+hjU0+e6ysq9Mfoj7e4u/Z93NO8bjDFWYkkhBBCCCGEEGLAGzKJhUAggNFoTGpbTdPIysriV7/6Fbt372bFihVSAknX2SB7osfHCw66qqCpDgJ+NSM0LUbtabNV9T4IErs2tcUOpIR/93uAjLbb9QQ90GswdX61g+g/+ltJj+hxoycMUjMSH19HxnBkiSI9KOuPmEUdmcDoStJRn6nd0XPb394TkVhfJIIiS+fFSjy7qtSqg85cQ9FjKfJ61CsIdaSSUGTSXOdyxr/Gu/p93NOkjJkQQgghhBBCDGpDIrGwZcsWXnvtNS6++GJGjhwZcxu9vwKoFQuapuF0Ovniiy+YOXNmbx7u0BOvKaU9B/xutcoga3TsprexAjGJmNppItudJKgyuPS39zM6qB4dZOyOIK4+gzoyaRc5hmy5YA59jXQlyNnZOvf97T0RifVFIijWNayz2NV3S2d7LLTZX8T1GJnw64qu9IDoisjPj458x0bq74kPIYQQQgghhBBdMugTC9u2bWPBggVUV1dTWVnJDTfcgMPRevZ4ZFIBwGq18v3vf5/DDjuMyZMn9/YhD26xGsfGakqpl1fp7pn+yQRnumtWrQRVBpf+9n62F1RPJojb3rXe0cRdZ8Qq9ZKs/vaeiMT6IhEU7xqOLJHUXd8zscroJSNRuabeGIMxjyni86M7nl/KlgkhhBBCCCHEoDOoEwsul4s777yTM888k3nz5nHdddfh9/v5+c9/3iq5oCcV7rnnHtxuN7fccguXXnppXx324KYHKzy1YM0MJxCiy0n0dODJ51Y1sDViP39TPbgqIbtAgiCif2ovqB4viOtyqvIveh33js4gjyyF1B06UwZJgpQDU1cTQS2J6ZR2N21/XwlKJHVqf124Jrv7WLrj2Lo7CSRly4QQQgghhBBi0BnUiQWDwcDBBx9Mbm4uF1xwAXl5eVx44YUAbZILVVVVrFq1il27dnHttdeSm5vbV4fdd3ojWNfSODY3/Hukjgae9Jme0WLN/Gz1OLdqrBnrOS22rtXdTlZHzndvB1IlcNt1XT2HXQpUJnisqwoCjeGGtckEDyNnVCcqJ5boeSP3AeF/d6bUiwQphyb9fQ8EWt/fmbGSqERSLO09R1evSU9dONnXWS6nSojbc1uvwujMsenfi1pHmkQkoH/3A1SXxE7qCyGEEEIIIYQYUAZ1YsFqtXLZZZdht6sA8/nnn08wGOSiiy4iGAzyy1/+ktzcXAKBAAaDgQceeICmpqahmVSA3gnWdWfpEq8LnNsgGADNCOnDof4AGM1gSVOJBa8L3A0Rj3GDJSNUgilNBTdiBTQtqaohdHeunIgOTHXkfPd2IFUCt13X1XPYlccneqw9J7xiQf9bZHkyr7ttYq7VjOqsjj+vywnO7ZCaDmnD1H36/uyO8HPFC4xGi55NLYmwoUF/3w1RKxZ64/OqvedIZoVQvGva64agXgKwE8emX/+1e6GxBip3QuG88PP1h14k+ne/ywne+tb3CSGEEEIIIYQYkAZ1YgFoSSroyYMLLriAYDDIxRdfjKZp/OQnP+Gee+5h165dPPPMM+TkdHHG4EDWH4IPHeGqBHcloEHmKNAMYE6F5gAQDAWBXBDwhh/jroS0DBXMyC6MvV+vG4wW9TivG4LBcJIisg62/rvRktys1zbNdjswYzbWexMMtv846NyM0/56LQSD7b/uZF9vd5+/6P3FO4fJPm9n3oPIFTwGU+trKxia5W3LVjf9viaXui6bXOH7vG4gCF4PWKxqXHk96thdzojnc4MlPfx7q2s64nW6q8BghMYGyB6j7ou3XbNX/bRHJXi97ta9GKLLl0UHfXtyfIiO645xqb/vXn/r+zszVtqUH2rneol3bUf+PRgMf2eYU9X9ripoblI/9XHn9bResaMRvjXVR/zNppIG7fUgaXKpcWuygvcApIRW3emJhVgB/FbfZ4nOWzePD4tNfWbES+oLIYQQQgghhBgwBn1iQWc0GgkGgzQ3N3PhhReiaRqXXHIJr776Ktu3b2flypWkpHRD3eaBbKDNHtQAa5ZarZCZrwIrvlAwx2xVwUlQAVadvxFqSlVcyJ4Tu1ySHkDye1sHnqIDUS214V3grg4dT3b8REF0IqEjTTl7+73pr9eCzw1k9PVRJKe9c5ioYWsyj4+1H/2aNJg61pC2sT4cCNUAW04okRBQP+25odnGleEEBYT6LUQkFvRm7NFsOeGfkX/XkyD6fbYcNW5tMRK8iXox9NdEmOgdnfm86ug1E+/ajhT5HaEn4wglG6yWcKKu1XZW9b1hSg2PYW8DuGsgc2Ro29A4jHyNPrdKHmiohIJmhKxRrVckJXus+u/tJhm6QaKkvhBCCCGEEEKIAWXIJBYg3KQ5GAxywQUX8PDDD7N27VpWr17NQQcd1MdHJ9rQyztEBl4jg6i23PDMf4sdGspVGSQ9kRDwqX9bs8P7NKWGyzD44gR09YC/2aVWOPi96t/RiQH9d18N1O9XyQprFax8SAWCDvsRWHPULFX9GHuiMedQ4u3mxsF9qbsatur7cVeqa1ADUtLbbud1g69RBTz14KHXrZJiJpP6m8kEPj/YUAFQPRCqs1jBF5FYiNdvQV9doAcq7bltVyC0ev2h44m1XctxVqljzBzV9u/9NREmek9Hy2HFu2ZclRGlizpYFjH6O8LngdQMQFNj0hcxnhrrwysYoo/FXRMaixEJQ0vUWPN6wO0EfxNkjlbJdVAl/pJJKkYeq8+jVkq4q9S+uiu5ICXKRB8qLi7G4XBQWCiJLCGEEEIIIXrKkEosgEouBAIBbrzxRj744APWrl0rSYX+Si9vEhl4jQxGRtZm1zVUqMCpzwMvXgWAdubD4b9bsyBgUgHY9koQRa9SiH4+/e8NFSoo49wCXz4QKs8E7Hgfjv01TD0t+QahIrHo4NpA5XWp6ztWEkBPniUdII1YYWOyqGRarESFrzF0LTdG9CYIJRP8fhXkdFeHmpZHrFKAUIAwFNyMXE0Q7/2IlTSId9zJjA2fR9WgD/pV0DcyMSJBy6HNXQlaevf1Wagtg6Zatbqto4kFfVWDN7SaANR4bEkgRFzrqTGSf3og3pqpSkfp5ZBiNVG2WEEzqf8XF6+KU6JVUdErMNxVKjHf0UbqiUivHtEHHA4HNpuNJUuWYLPZKC4uluSCEEIIIYQQPWTIJRZ006dPZ/Xq1cycObOvD6V/SmamYU/PRtQDNJHBmPaCkUazamD5v+uhtlTtZtl3OL/5ZF7TFqnHpWfHfmwsZquawap5VZAmOjhTuxc8VbDqcdj5obrPMQUIqkTDGzdAoAlmf1cdW7T2yuF01GCfIdpbrynyPPbEKhOfJ34SIFHJn1giV9i0F6jXSx65qtRPvfyRPbSKwZwaSjxE7MPnhpoylXAAMFvCf3NXAWmtA/0+j/rpbwwnIfT7dfpKhujHxSvFYraqmdh+vzoOlxO8jRHHNAivdZEcfawkKm3Ukc9FU6oqRWRKTbydqzJctiveahyDKXZJIv17zGiB0i+h5Euo3gkH1kPFJsgYBZe+prZ1V7b9ftATfRkj1e8Wa0TyL+IzqyOrokyp4XYKrsr4YzEZ+vmG0GecjE/RewoLCykuLubjjz9myZIlOJ1OSSwIIYQQQgjRQ4ZkYsFoNHLFFVe0lEYSMSQz07AnZiPGCgDpAQo9gBovQGJOhaY6eO06qNsLZrWt5irnSp5hcfB/GD/dDEdeF3+WeHQAJ1ZvBV0wCLs+gY//CI3V6r5DvgfH/1b9+8HDoW6PCoK2lMSIfr3dVA6n5XXIDNFuEXkeeyKxkChB1lL6JGK1QINTBf3sjsRNWNsrgZKarpILRnO4LFLLftzhpEKrxsgeFcD3+8BCuHcJgKsCzMaIYw1dz/7G1te7fn99uVohYU5rHWxsb4WDnoSw5YYTF/oxpct1PqT43OCuD/+uB64TlcOK9bkY/V2jJ7fsOeqmj814SS93lUoax2o0rjdyjhzfzX5wboN9a2HfN+q2fz34XG2Pt3Ib/Oc8OP2vYMtS4ylybOr9TwLe0GsJJe1MltbfJcmuCopMdOrH6qoMj8eOfgbq57ujvV6E6CaFhYUUFRX19WEIIYQQQggx6A3JxAIgSYX2JNPYsrtmiEaKDgDFKocU83EuqNwBL31fJRWyx8IlL0P6CLzfPE/5/24nn/3wyd2w6lE49Acw8wKw5yVOHkDs4EzNbnj9/2Dbu+p3x2Q49Y9QuED9XlemkgoAk05KHNjx1MWe1dqZcyhNbLtHT5/H6ARZdGLLYg81Z3Wq4/A2qO1iBU+TTU7pqxFayrKkti6P5PdAUwP40yAz4jn01Qtp1nBAU+dxQZ619YoEvxcIqqCnnsDTV/40VkOwGTKMbY+vsS520+ZW5y0U5LSExkb6IF2ZI+LTvxN0tlzAq8ZKohJZ0Z+z0d81rVYZRCQKopNe+rWur2iw5ajAf/1+9R1Us1slG/TvAFeF+ltDeeuxozPbYcRBMHIWjJytViG8eJVavfDGDXDK3ZA2ItxI3WxTY9JdpXoxBP2hvilpqoFz5HdNsn19YvWG0LydT67K95AQQgghhBBCDAlDNrEg2pFMM9RkZog2OMOzjSO3jRc0jxWQiBd4j1S5HZ69RJU/0pMKoWaWzdMXc9UbmRwb/Jwbs97CUL0DPrwTvngQ5l4G85aqoIzBFDsBEBmcafbDl/+AD36vXoPRAkf8FA6/Dkwp4cdsCpWxGD0PRs9RgRqXM3bJI2uMlQyR5zDe6oNY57CrTWwHeymlZHVXM+Bkz6erUiUPLGnh60N//zVCQUOiZvlHlRsxW+OvvPG62jZu1rmrodkXTgxE12uPPBdeD3giZovbQtduy0oFrwqyGi2hAGjocZZQ4DYlHXxNscdZ9IqeROWRYiZY5NodtFqVJrO1biAOrT8rIfbnpv45G69MT7zZ/bGC7s1+9bimGvjP+VC2OrnXoScRRs0OJRJmQc5EMEQl2i76L/zrTLW64aO74dxHIeALJ/nMNjB5IDWgEnLmNJXgMNtAM7R9Xv1zQV+VFN2YOrrfgsUG3qiVUx0hzdSFEEIIIYQQYkiQxILoGXqCIHLWY6vyKnGC5rECEnpAKF7QtLY0blJB16wZeV87kuu/9ytSt70OK+5R5SY+u0/1R5i4CNKHgzFFJQj0W+TvaPD531QJC4Axh8Ppf4HscW1f/8ZX1M9JJ6mfPg8QDM8q97pUMNkfej3RpZkiz2G8wE5PlD2SUkrdK9nzqUX9hPD7n5oR+7Gxyo1Ul7RNUEDErOuIxs3BZrWqwFMD3noVoAwG1G3vynCD6caaUDkkCzQHMDYHOb95P0E0jBtHg9msxkmzX42TjNGQmg2541snBcxWsDnUa7Tlhl+DntCITOx53ap/id6XJJngZqJzLUmHgS3yvbU7wGZp/ffoz8roz83Iv0ePG31lUDzRQXezVa3s+fIh+PQvKikHagVDxih1Sx+pbhmj1AqE9NBP+7C2SYRYjZdHzoLzn4JlF8D25fDe/4NT723bwNnvU8/RXpNpffzX7YMUq+qx0t5j9NcdK1HRXWRcCiGEEEIIIcSAJokF0b0iAwV60CY6yONzq1sQSIszW18X2cDZ54GmehUUyRqtAqclX8Lzl0P9vrhJhVYMJlUCaca5sP6FcIJhwwvJv8bUTFh0G8xZooIuAV/rv9eVwZ6v1L+nnRW+X1954XVBzV7whRqEmuPUsNaTLHrgK5nVHV0lJSy6V6LzGZko0wPtQcJNwtub9Rs5NvR9+RrV36IrvZlDzV0b61SiYMtb8OWD6lrtIDNwpf7Lp4k2tEFWIeROhMwCFQB1TIJhRSoBEZk8SEkPl0uq3RNa9WCGAO3Xh9dFn+vIzx5JmA1sCcvuecCe3jZBHf25GZ3YjkxCNPvV57M1o23Jo8iVCmYruMrh5auh5At1/5RTVLmijNGtA//B5q695nFHw9kPwQtXwKonwJoDx9/cehuTWa040nsv+EIrEqKT7/r3Z8bI8IoF/bXriT39O9me23uf/zIuhRBCCCGEEGJAk8SC6F7RgYLoBsx63wSjRdWDNqVCQ4UKjtiy286iNKWqbUHNpHZ5VTDF61K1q5+7DBr2J5dU0PlCx1J0Bkw5FTa/ARWb1extf1PoZ2Pb3/1N4JgCR98IaXnqPmhdAglg8+vqZ8Gh4Jig/q0ZIDVNBZu8LtXA1m9UwR+TJTSbPBQUsthbB3ZandOIIGtPlJvo7yUsNK3trN2eFow1pThJiZJDkbXb7Y62vRJi1WOPpK+kCQZVvfVmP5hTwJyl/t5QHnEcqSpo+O1/Yc1TauzoWsoW2cMJDYsNvfk5ZhsYTep5gs34AwHeW78PjSALi4ZhNKj7aW4GTxVU71QJC58bKjapW7SUDCiYr8bI6Hkq2eDcBp5qdZzWDDCmQsaI8PjQGcyJz7WuVQPuBIHp6Pe3t2ZR92Wfn2BQ3RK91mSPryvjI1mJPpd8bvAZ276OuJ+b1ojfg+Gguy1L3WVKUdey1wXNgXCCIOCHdf+FD38fTv4tug0OOl+dKz1ArzPGuU6j6Q2YY5m8CE66A97+FXzyJ5Wcm7c0/Drc1eq7xBtKeng90OxVx220qM8FT416TWYrWDNVcgFC30VutVqpwanGuDlVlUCKbOqe6P31udVzWqxqlVSkeCsMI0kiWwghhBBCCCEGNEksiOTEC0BFr0iItRIhOtlgsalAhhba3l0NzU3qZ3vlGfSAh7tSlYnoaFIhmsGoEgxFZ3T8sfFseFn9jFytYE4FX7B1wMaSpgIv7mqwEdFIN6qudbza3z1NylR0n1gzc/WgGoRLsUTWfI+7L09EwC7immisV8k5W0440dBYrwLza56GlQ+r8QKqTMsR18OsC9u+t+0kNPzeAH/auAKAo089GqMlRiNmf5MqTVa9G2p2QfUuqNoV+vduaKqDbcvVDVQ5sZGzYdh0yJ+nkhqmiLHi84QDmClJBmxbPme84RVUyRhKs6i787X21eeFnqyONb70998bo0+HTi/50xxjhYGrXH2fuavg43ug5DN1f8GhqgxeVmFPvKLW5l6qEoGf/BneuFGtbpp2pvqbFlRj3BLRJN3brL5nqnfBZ39TiXOCMP07cNCFkDdJfddohvAqwNQ0VVbJnJb4eyYykWC20dLM3etpm1hIpql8f09kCyGEEEIIIYRISBILIjnxAlDRTTONllCt9AQle/TkQrNPBSRs2eEVC4n4QuVRGspV+aOakq4lFXpCTSnsWan+Peao1g1Ho1cbuCrVrE4IzaJNDZeycVWG69O3JG1CM2KlTMXAE2tmrh5Ucznb9kqIRU8o+D1q1r7PE04s+EIBPv0aMaeCp1atnln5EDQcUPfrCYXZ32270qY7mVJUCaTciW1rtDf7VVPaHR/Bjg9g72q1yqF6J2x8Sb22UXNgzBEw9XQYNbN1ADOlnfJpOv2abWpQweHsJIPAQ2kWdXe+1s40m+8OZqta/RZrfFlssZO1yTKaYfOb8MWD4Haq77ejb4T5P2jbK6EnHXmDWs2z6gl46QdgssHouWpMmCISbQEfbHkb1j8Huz5uvY+vHlW3MUfAQYth1KFgz1b9UCJXcbirwIMqvWSJSjJEjkNQn0VBIkorRaxS6KuEuBBCCCGEEEKIXiOJBZGceAGo9ppmQuxZiRYbNLnCMx/tuaFyMZXh+yL53ODcCt8+C8WvqiBLf0sqAHz7nPpZcGiovE2oWW5zQB3/vm9Ct7Ww/1tIHwEn/A6y8sPnyVPTNhjWavZnjHPTEwG7oRRg7WmxxoDPrWZU6w28U9sJmOvXQJDWjY4j+T1QuQM2vASrH4f6qBUKPZ1QSIbBpMofjZ4HR/0MGmth16ew80OVaKgpUcm5PSvh60fhByvULG2vp22gs71rP1ZT7PZ0xyzqgbLapztnjHd3s/mOnMN4ryOyD0k8rkoVTLdmhXudgEpIvXcbbHlT/T5sGpz9D8id0P6xdzdNU30c3JVQ/Bq8eCVc/LwqjaShVlZ88Xe1MsmtN6LWYPyxasUDwOp/wY4PYfen6mZzqF5Dcy9VPYtA9S/yNah/m6xtx5vFGh6HXk+4pGG88m7xVioIIYQQQgghhBgUJLEg4osO7MQK3ETfn2yQymxTpU4ikwleDwT9oXrREaWVvG74/H5V1oFQveecCbDkhf6VVACV9AAVsPHUwK4VsHMF7P5EBVCjVe1QM1Cvek/NENVLJemNnnWJZn/21MoCKVPRs7xu8IaCeMmca7NVBUD1IHnk6gRbaNZxUz3897vhvgbpI+HIn6qEQrI133tbaiZMPRWmna7quVfvVAHQrx4D52Z49xZY/M/E177LGdEbIuI82h3h+3vTUFztE3kNx0oKtJd4iH5Md5xDc2ilmNfdehVYJHcVBJrAXRNOLJRvgmcuVOW80GDBtXDsTSopp/fW6W0GI3znH2p13+5P4JkLYOxRaqxXbgtvlzYMZl0Ms5dA9pjw/VNPV2XI1j4N3/xHrfxb+ZAqkXbeY1B0ZmilQZr6jIkeb9FlkCD8u94fCOInPYUQQgghhBBCDDqSWBDxJRvY6crsXHeVCq7W+9TvxtTw7ElQgYvP74fP/qp+H38czL0MJp/UPwOlKZnq50d3g/vnrf9mtsOIg2DkLHWr2wsf3KECVT4PpPjDta+tUbPX9ZJIrQJk9vDfZGXBwGOxqbrkGglmeUf1U/BZ1Zh0V0NqeuhvqeGg7t6vVKDRkgYLf9t6hUIwRg35/kbTIGe8uhUcBg8fo2ZoV25Xs7Nd1WDQWicMvG7we2N/VvVUcqy9z7yhPiZjfXe0917E6sUT6xz63OCu79jxJFrxZcuB2jIwhPa96xN48Sr1vZRZAGc/CIULOvZ8PcWUChc+BU99B8rWwqb/hf82/jg4+DKYeGL878bsMXDcr+Hon8O2d+Dje9XKuV2fqMSCxQqW0bEfq5dBclUBoQSnLSdc1i8YUOOwo9f8QFndI4QQQgghhBCiDUksiPiSDY51NgHhc0PdvtD9LlWKwhKajq2vYvjqkXBS4bhfq9nX/dkJt8BjJ4XLUYycBRNPgImLVN14vS63vxEeCAWrDjoPMkLBHHOqCs7Ul6sgUvQMW73ZpqsKsiPKJ0lApv+JbmweHTwz2+LX/fe5Vamw6H4KLStXUsPNmvXt3dWwdpn6fcY5MO+Knn19PW34NJi0CLa+q2ZVH/0L8LnCf9eDz3YHWNy9G8hv7zNvqI/JziRWYvXiiXUO9XPfEYlWfNlDqxT8Xvj87/DRH4Cg6kWw+PHW5ZH6g5QMuPx1+PJh1Yy98DAoPDzcnyVWE+poRjMUnaF6Au3/Vn3fQvzG8KB+d1VBY7Uq7WdOVeWSQD1GQ93aa9gcbSiu7hHdpqSkBKfTSXFxcV8fihBCCCGEEEOSJBZEfMkGxzqbgPB6VIAjmKrqNGtGFUzXSyKtuBc+/bN67EBIKoBqqLnkRRXwGXeMKkuhCwbD/17zb1Vmw5YLcy5R99lCpY/8XvX6PZUqeNOqIWkouGMySyCmr7U30za6sXlHgmf6Y4OohqzNvtBMYcLB0WBo5YI5Ra10aayFnR+pvxWd1eWX1y8cerVKLHzzDBzxE7Xqx6Cp8xJ5Pns7kD/UVyS0J9n3I1a5PZ9blbZKtBrEF+jccfkiA+cR+zYY4Z1fq+bhAHMuhVP+oHoI9EemVDjix13fjzW0ws4d+mxptbIjKrFgtoE5tGqhsU6tigKoKVPfR5b0zjVslrEkOqmkpISioiLcbvUda7PZcDgcfXxUQgghhBBCDC2SWBDJixdI7WwCwmJVDSQ1wjMf9WDGQEwq6MYdlfjv/kb49C/q3/N/oPpEmFPDdao1QyjJktK26azFpkpFxSrpIXpXdKIsenzEamwOsYOmsR7b5IKU9HCwr1X5I6ta7aMnF2zZUF6sVrPYcmHsEb1/PnrC2CNh+Aw4sB7W/ReO/EloBUcnVyh0V9mVob4iobvEmq2ezGoQWwcD/voYaqxTTdIjPz9dTnj2Uij5XH32LrpNfS5rHen4PUBZQyuevPUqoe/3qKRdSnrofk/Eailb+Ps5LS9cAgk/VOxW59UxIbxyIlkylkQnOZ1O3G43Tz/9NEVFRTgcDgoL46wCFEIIIYQQQvQISSyI9unBOK8bTJbOz5SP1eg5K0b97Pduh5X/UL8fd7MKJg4ma/4N9fsgbTjMWxoO7rirVPDLaAHHxHAA2esGd6UK+Nhzw/0WorMOLqcK9Ojb6AHUZEtSiNjluuIFomMlDhLNojfb1HsUK2ga67F6bwRQ14ItW/1srFczhwmCv0klo8w21dAVYOppqoHqYKBpcNjV8Mo18NWjsOBHKrEQa3Y7xH+vfG5ocIKnSjWLBglm9gexZqtH3pdMIshdCZoeCI+zrT6TXl8Vps+o3/U5vHil+jxOSYdzHlWl64aK1Cz101Ot+kyYTGrlgSWixFEwoBIMsT7TLFZwm9TjmpvUqqqOJhaE6KKioiLmzp3b14chhBBCCCHEkDRIok9DTGRJnUS6a8alHvTUUAFLsxUV5Q79rU1piSSfN1Yz2Q/vikgq/FolFXye5PYXL5gaiCibEfCrAEgyNEOS2xmT285obrtaIfJ5LLbW57JlRm2laiQK4LO1naXtdanH1e5VZWL0kjmRZXj0n/rzDOagalfGR2SA32JPPHu6TZAtiZIe+koEc2r4+ve51S0I2NPUe+2NnCUcdS34GtQNTZUyMaVAwAub31DbTD0j9tiq2hH+t6ca3vqlunYOOh+mnBwu+2JrJzAYWYam2dd+TXdjSuK/t+y3Mfb9k09WSbiGA/DNsyoZB+rYa/aqMiwtxxPnvfK61XltDoDfB+kRf0/2czLZ6ypZvf053tdivQ6LvW3iM3JcxUvERWqv3FhzQI0RU9R1uPlNePH76rrIHgvnPQF5U6DZ284LSfJ9a6xJbrvIz+ZEUjOS2y7Z8WawhpPanhqVHPD7Ic1Ky3e4xRpKXFpbv3+R3/tZo1FJTg/YcxI/p54oivz/CzH/PwRJn+ZBMz6EEEIIIYQQYgBKMnIqhjSLTQXtbbnhRpc1pVBdCrV7wFUebv7YWT43fHAnfH6/+n2glT9K1pqn1ezY9BEw83x1n7tSvX6zLdwotKYUyreonwCEgj7R9OBqU70KVhtSVXDHbA0ngfTguKsqHHjTZ3r7kgxqDRX6td5Srivq90TMNjVbN1HSxmxTY6hltn2lqlHubVCxPL33SNCvfrY5PmuotnmoH4k5Tb3Hm99W11EyZZA81fDKtbDvG6jcBh/+Hp4+V12bXlfix/YFowUODiUTvvwHNOlJNo9KKvh96hxEXvPRLDZ13tLywk3Pu6Kj40fGW+ckM/70vyfa1udWK8J8bpXQ+eIBeOa7atyNORyueEclFfpSwKeSg89fAS/9sHUisKfoKxaa6tVnSdao8NjwuUMrFaxtz2mrXgw2GDYZ8iaHHxeP/l0UOVkgcl8d5XNDQ0X//NwSQgghhBBCiCFAViyI9rXMIA1NIfR5VEDG16gCEinp4UaO+uzDRLPi9VmLJkt4m+qSgdtTIVn+Rvgk9BqP/BlkjFLB4OZAaMamHtDxqCBkQ7lq/pxVqJIFzTESC5HB1az81rN/9X9rmjrf+mxSS6gkT1MDpKSp/Qslega1xd4zqzt8bnDuUAmEgB9S08IzdC3W8IqFaGYbZIZqmwf9KhjpqYHiV9Xfp5yauAySnlSo2q5WJkz/Dmx8GVwVKqm36gmY/V04+HKw53XrS+6S2RfDZ/eBczNsfx+mnRlOIKQQnvEcrwyL2QbZoeu8vebAyWivD0BXtxdKMvX3bblgNoW3j8XXGDr/Hnj3t+o6B5hzSbhJc7Ov2w67Q1xOWP88fPs8uJ3h+/9zARzyPZh3hVrt1hOsWepnMABmS+vz565S3/P+tPBqLH2cxWrS3N41rn/v+xpVElxPWHSm4XOs55SSf0IIIYQQQgjR6ySxIDrOHJo17ferGcD6THo98NBeAK1l1mJzeJtdK1T5ltEHD86kAoRXK9jzYMopKqkAYDC2DqqYreq+lIzWf4sVfNF/T7PGD6xEBuda+mWEZod2c3WXIaezzYD1VQn+JvU4vw80T3jlSnv70pMPQR8EGlWwHaDozPiPiU4qnPV3yB4Dcy+BLW+r67NmN6x8CFY9DtPPUYHN7LHJv66eYs1WJZtWPwmrn1CJBT0JVF2iAqCWtOSCi90R5E+m7FWy23dXQ+nBJN450e8nyXI/+mP02fClH6ukgmaARb/ruybNwSDs/xbW/As2vRFOGtvzYMZi1ax818fw5YOw7V1YeEvPNGQ3WVXppECTSlCmRJRb0r8bvJ5QOb7QZACfJ9zHJ1J7Y6Ll8Y3h/egrTTrahD3Z5xQCKC4uBiA9s51SXUIIIYQQQogOk8SC6Dg9EGDLVcEBn1vN+NQD33rAINHj9SADqFUP3z6v/j35lJ4//r7y2d/Uz7FHQ0MlmM2h8hP5rbez2CA3onlzZFmeaLFqlEfS+y/oATo9qBpZv190XmeD1BarCu5rqPfHXdW6SWo0vSyJ/r7pN5cTPnoImmoTl0EK+OB/P2mbVAA1dovOUE2fd30C3yyDsjWw7hn49lk46U6YcW5Hz0z3O+RKWP0vlUTZuxpGh5p16nHhZOPD3RGMTCb5k+z2spqhrZbybc7w51Tk51dk35z2+BrVjP+qnbD8FnXfET+BQ3/YI4cek6sC1j2nkgm1e6BuT+vyPSNmqlU5ExaqYw0GYctb8NHdqlzZs5eq0nlH3qCS+d1F09SqhYYDUPK5WvGjf87Yc8ANuKvVd7TBGL/UGLQ/JvRxZ49qoB2vx0IyzDZZqSDicjgc2Gw2lixZAkBaZjaH/+ypPj4qIYQQQgghBhdJLIj4Ys0ajQ4CWGzgtUbd185/6OsBCH2W5nu3QtlqVTN++tk9+pJaNNaqGvP7voF9a1VZIGsWWHPUz9QssOWomdL6Tb8v2abO0Ww5UFsKG15QM8OP/IkKKMXSlVmckaJXkOjBndSMoRnEjLymuyMgpZ9P6Fh5HbMNskLb1exRjWU1U+zyRz636sOAH+r8YMuC5lDg8bP7oL5MbXfI9+KXQVr5MFRshtTM1kmFSJoBxh0N074De1epOvS7VsC7v1H154fPaP919aTscWqlwsZX4PnLYclLqleJLdSzItlSKpGfZdD3gcn+OOu6u8dJR+nnxO+N/flliFix4POAJT3+vsypsPkteP0GtbIld6L67O0N+9erVTab31DJvUhGM0w5DQ46D4ZPb/03TVOr2goPg4/vhU3/g3X/heL/wWE/hHlXqtfVHSYcr5KJL18NBzaq/XtRqxKCoYRnYx1kju7a80SXVNRF92sQopsUFhZSXFyM0+mkuLiYy5Ze2deHJIQQQgghxKAjiQURm88N1XvAZIpILlhjBwE6GwT3uWHVk+F612f9vWfKrjT7GR/czdTgNkxvvgz7VqmZ252RNgLmXwWzLup4TejLX4dP74NP/wp7v4ZnL4N5S+H436g+FfEkO6NTX51gjiiLFL2CpKMzrQeb7q7JHblyoDOzzvVGp3aHSjy1KfviCfXRMEFDDRhNUF4MK+5R1xBARj6cdHv81T51ZWp7gAXXxU4qRNI0yJ8H5z4KL/9QrRB4+lwVxM8YhTltJJc3a5TjwLCzCXILIGN07wSgT7xdraaoKYE3fw5n/0PN4E72uVtKgYVWTPWH2uz9cUx25zjpTJJCPycWd+uki36/N6LfjM8NxPn8DAbVd8zyW1SpvTGHw+LHe/Z8N/tVIuOrR1SCTjdyNhSdDlljIDNfjRlzajjBFYs1W13zM85V/Xn2r1OJhrX/gWN+rlYadTbRrTv9z+p9+epR+PxvULkVTrhNJTkjVwNFlkJK9D3U0dJeXemxIEQ7CgsLKSyUPlJCCCGEEEL0FEksDEbdMdvU61bBTL8fLKZwMkEPAoCquxwr2J1MYMHnho2vqdUKAMf8EqadldyxbXodSr9UQSNCt2AzoIXuaw5NigxC9S5SytbyYHPomDdE7CerEEbOgVGzVHmYxlpVh16/tfxeA42h3xv2w/u3qdnc865QzT+TDVKZbXDsTTDrYnjnZtj8ugrmbHkLTr0XJi2Kc66SnNHZarvQ+95eqaSWxw6ROu89NTs81n6TOafuKtj/jSp3kjFKrdoxW1Xtc3+TasytmdRqGaNZrTzY8AIEvKqE0YLr4IjrEr9n7/5GHcuIg2Dqqcm/Js0Ap9wDz10KBzZA3V6o24sRuEjf5qV/hrdPzVRJjsx8Nbs5M1/9njNe/Ts1q+v17FOz4Lx/wWMnwvb3VI36o36W/OP1gLmGWt0hM6Rj685x0pUkRXTSJVaPhXjXfsALr/8M1oRKn8xZAqfcrcZNT/BUq4D/6idVMg/UNTblFJh7KYyc1fl9j5oDl7wIxa+p8kj1++B/P1V9UU7/S9dWExgt6ryMnKX2ueUtVRrprAdVmT5vo/oc8ntUWSl7O3XqO1raq7tW5wkhhBBCCCGE6HWSWEigubkZg6GLswH7QnfMNtX/Qz89omxIZBKhdq8KdMaaTZ9MYOHARnjn12q7GecmHxz86tFwMiJJGuDCymYmMPOwhZhGHQQjZ6oSKgkfGPXe+5tgw4vwxYOqpNGKe+DLf8AhV6mbLcnGgNlj4IKnYNtyeOP/1OzrZReoxMoxN0FWgdpOP6/JJHOg/ZmfiQLdQ6XOe2dnh7eXJIi132TO6a7P4NVrVLmRjpiwEE6+C3InhEuKxbL9fRWM1Ixw9M87Prs5NVOVHGooV8HS+jJ81Xt487NvGBZ0Mt/hwVBfBk11KvHWWAvlG2Lvy2KHzAKVZMidBPmHwOh5kD68Y8c0arbq+/DGz+CD36tZ6IULknvsUC8FlqzurF3fE0mKyB4LZmvb8emuhGcvgd2f9XyjZucW+Pox1SfI36jus+bArAth9kWQ1sHrOx7NoL4jJp0EX/8TvviHWhHxxGlw6h9h0gld2//s70JmoUoklq2Bfy+Gcx4Fx0T1d72XUnuSaeIcawWe162+3zTUd3NfryQSQgghhBBCCNEuSSyE7Nq1i08//ZSamhqKioo4/vjjMRgMBINBtA4EI5qammhqamr5va6uricON7GeaE4aWRvZ51FJhYAPzMbYpZESzd72e+Gl70NjDYw+GM64L7mAz/oXwkmF6eeoACWaeqxmUMFTjVDwNHS/PY+mvNmc+68ygpqBV448GpPWlOBJEjClqBJIB52ngrVfPKBmmn/yJ5VgmHsZHHp18oHSiSfADz+FD+9Uj9/4CuxcAcf+CqadrYLNPo+qdW2xqaCLfq6hbdmj9iQKdPezOu/9YhxF8rpVA1NXFWTnJz8TVz+nkde/KVQbvWITvHWjep9HzFRlT3weFZz0h0og+RrV7z63WpWTNUaVRplyavtjxt8Ib92k/n3I98AxqXOvXTOoMkjpI4C5BHwB/v6FKvHyyqULSLUY1bmpK1OrGmr3hG/6764KVaqrYpO6bVsOXz6o9p9ZoJIMo+aoRMOwqfF7RejmXaGaza5/Hp6/An6wAuxxmtpGB507m1AYgKt6+sU46kpPi8hzru9DA8zZrbeL/Gyr2KKSCrWlkJIB5zysPmu7UzAIJZ/Blw+p5J1u2DTVZHzaWaFVdD3AnAoLrlHP8ep1qk/QS99XfReOuRGMKe3vI55xR8EVb8OyC6F6FzxzAZx5vyrh5G0ncd1yfO2MD58n/FmaNTr83vo8qgeGvg9JLAghhBBCCCFEvyeJBeDbb79l4cKFLFiwgA0bNpCWlsawYcN46aWXsNvtHUou3Hnnndx6a8dm1HdYe8eil78JBkOlgbqZHljQf0bPpjenqiC8q0r1abCFgkDNfnDXqCBI1Q5V+uWcRwFNrQaIp7YEdn0Cb/1K/T7zAjj8urbnobE+5sODviaC+kzt/d9CRlZyr7M5wSzygvmqDv3OFaocRcUmFSj9+p8w/Ttw8BWQMbL1Y6zZsfd17E2qXMYbP4eKYnjzRtj4Mhz5fzBiugrC+EIzYTVDqDa8Sx1fMBiu0127T5Wv0u/TaUb1Mzp54HKq98ieo2r8d3ewNJlrL842vTKOOkJP7JjMCVYgRL0WfbUJqMc21avSR3aHev+WXajuy58PFz+rxkykyMs7GIRmHxjM6rpv9ob/1hgnWPz536F6pwq4zw8l8pJhNCf+uy8iYFq9E8yG8OOyx7btk+JvUjdXuVr5UL9f9Tg5sFEFL2tLQ03NX1Tbm60w/CBVomzSSapxdKvjC31tnXKXarxeuQ3+dZYKtI6cBY7JKnmjGdU48DWqz57mQOyEReQs7Fh9SvT7a/aq9x+6Z6z0xOz5KHHHkc8NZCR+cHd+d3RoRVTE80Y+DtRnn8HU+vOtsQ4CDephpSvhjVCT5qyxcMHTkDMu8fdLy35q2t8m4IP1L8K6Z9RKBQA0GHukSjiPnK3e17p9ahVDy+twQekX6pzmz1MlvXQzL2j/eUF9VrSiwWl/hpUPqcbOX/9TJdvO/Jvq39CeeKukMkbBJS/BC99TKyKeXwon/wEOvlwlS7wu9TP6fYxe3RlvZYLFpr53TOaosn02sKSpz72eSHB34ftI9D8lJSUUFxf39WEIIYQQQggx5A35xEJlZSWXXHIJV1xxBXfddRe1tbW89NJLXHHFFZx66qk899xzDBs2LOmySDfddBM33HBDy+91dXUUFBT05EvofXpNZK9blZwIooIBxlBjRz3o466G5ib1M3OkakT7/i2w+xMw2+G8JyFtWPvPV7YW3vmNCoRMPhkOv7ZXgnLt0gww/liYeoZKfHz1iAp0rvuvWn1w5E9V0CiZ8jMjZ6vmzisfgk/+Ars/VeUoDv+xqs8NoRUielInVSVpmn2hAE6jSio01aua/LFWH0TPJHVVQaAxlFxwdPl0dKd+N47MNsgu6NiqjsjAmtmqkgpGswqEvnSVKoGVNQYWP9Y2qRBN0zpWG76mVF1LoBJXKWnJJxZ6giklVAYp6j30uqBiM5RvVMnGfevAWw97VqrbqifgwmVtkwugApLnPgqPn6oeX75R3W8wq+31UktjFqjPm8hgdDx6nxJXZesEg88TqjPvC5eHGwDijiOvp/M77czKjc6uiIou76b/O/L4G2ug2Q0bXoJP/6yC3oWHqybNthzVa6GrmhrU6pg1T6nEGKhrevKpMPP80Oq5OGp2w65PIRBKbtTtVYmzkTPbX5nTHqMZFlyrEmof/F6Ngae+o8qkTTi+8/u15cJFy1SPiuLXVNmxur0qQRkMht6Hdt7LmGMpdM3Yc9RKpoC39UqibGmyK9pXUlJCUVERbrcbm82Gw9G//v+LEEIIIYQQQ8mQTyzs3buXQCDAVVddBUBmZiaLFi1i6tSpbN68mdNPP52VK1cm3WshJSWFlJQulCIYCPSAqc+tZob6GtXsYGs22NPD29myVVLBlq2CB2uegm+WAZoqTzFsWvvPdWDD/2fvrMOjONc+fM9ashtXICQQCO7FpRQoUqGUUveeenvq7j31fpVTO3UX6got0hYtlOLukABRiNvuJmvz/fHsZjchspEWSue+rr1mdnfk3Zl5Z5LneZ/fD+bdIwGIzmMkSNpcnfg/G0URCYnU4yFnrYwUz10vEkfpi2DSY4dXL9SHL0jUd4YEdA78Dkv/D3b+JPJIMakSiDWFiVmnsdorjVTlD5oqBtmOs8ofzHNV1x8EDIv1VywcZRyV/ai5Mjo+yQ9bsYygd1ZJUG7p05C9RmRazv24aa+P5qKqsPgJOe+dRols0tGKKQw6DpZXZJIEhYszJJm4/QeReZl3D1z4hV9CKpCEnnDNEjGczVotL2s+HNoqr3UfyHIxqZA0BHpPhV6nNdweXyBbcdQ2QvcFtiNaIIN0BCWUGuxHpibkbBqjJX4s9fWdYI5LXWNf37wt3/9ZVQUsfhD2L5P3x10igfW2MGmuOCgVaVu+9sv0mGPEF6j3dDBHN7yuxyXXY+EueW+JE1P28mwxbC/OCN4bpClSx0qCcsF/IH8HzPq3VBgcf3vLj4MhVKof4rqL3N/yF6TKaMrjIovmDEyc1uc74+1LrjI5dqbw2udSb5IqomPd10ejzSksLMRmszFz5kzGjh1Lp05aQkpDQ0NDQ0NDQ0PjSHGURWiPDOXl5WzZsqXmfWVlJSaTiZdeeomCggKef/75I9i6oxDfSEQVr3SBXsxQ6waBwmIhIU2mexbALw/K55MegZ4nN72fkv3w5UUSlOgwUAIa+qM4F6YoMkr67PclAWIIhaxV8OlZUsEQrMxCXDe45Ac47SUJPh/aCl9eCO9Nhjm3w/qPpJpBb5SKBZ8UVVisBHMqCySh46tkCJQSCSQsHhJ7eKUpCr3yKBotwuk1Hg08zkazVJnojVC8HxxlsOp1CZgrejjzHZHtaWvSF0LGEhm5P/Hho6O6J1gUnVz//c+Gaa+AJV5kk5a/2PA60Skw/Go46x24ZSP8eyWc/ooEmBN6yTIl+2Hbt+LH8ONtYjJdH6Yw6ReWOK/kjrn259D8vlJXzudooDWBXJNFjk1r5Wpac1wMcl56qOmYvrlQkgp6k5h6n/rf1icVXNWw4FF4/yRJTjkqIbYrTHoULvxa/HQaSyoUpctIf19SoV0/6DlVvB66TpDj76iAvb9IpYGtqHXtBYjoAKe/JgkFkGqfLy+RSoOWouhgwgOSYNAZYM98+P5a/+ACj9v//AG/AbMvYRQW500wVEFVSYDPhkWqqOomG3w4bdozSaNJevfurSUVNDQ0NDQ0NDQ0NI4w//jEQlJSEmlpaXz88cc899xzzJ07l5EjR3LiiSdy/vnnM3ToUHbu3Hmkm3l0YTRLkCEsToJ68d1Ap5egQX1Bovyd8O2VMhp50EViPNkUripJKlgLJNB4yjNNy8UcLSg6MXm+8GtJiDgq4deHYOkzzdiGAsddDNevgP7nQkgEOL063ctfkCTDuyeKlrfqEn8F37HXG+QzXyWDT26joUDN0Rj4/LvhM3cuy6kdPIvqKOfOHAVF+yQpBHDSU9DlhLZvR3kuLHxc5oddKcHQvyuWWEkmAmz8DLLXNr2OokBMZ9G7n/pfMXW+Yxec96k/4LrpU/jx1toBUZBqIGuhvyooLP5wA9mW9JW2CsT/VTQV1DVa2saTpTXHxRjKdM98XvA8gq4iRyTFLpsjJuWtTaS5HfDDdbDlKznXycNg+mtw6SxJeDX1HCrZJz5CVaWSAOk+Rbah03uvz1ToeyYk9gUU2P8bfHe1+CO0Fr0Rxt0rCYaQSKmM+ORMKNzTuu0OvBAu+gZCo6Qa78NT5Tjp9LXNnH2DDgL7liVOEgghkf7PjRaI7iTSR/VVspRkQ3W59kzS0NDQ0NDQ0NDQ0NA4yvlHJxZUVSU+Pp5XXnkFgHfffZdbb72VG264gRdeeAGAxMREcnJaMeLvaKKtRgH6RiL6AkI+KQuD6fBgndMOX14swfVOo2Hq88EFftZ/IqOMw9vDaS9IcPbvRkxnOPtDGHWTvF/9lvym5hDRHs54He7cC1ctkBGz3adIoKY4A767Usxr7UXyHuQ7nR5cvkoG70jrhgKif7fA59GIyeKvTgjsA76+Et+NGlPahF5+34y2pDwXvroUKg9K8HLEdW2/j7+a1ONFGgxg0xct24Y5BrpPloBrRHv5THX7DdF9BAZFA5MMgbSkr7RVIP6v4q9KNLb0uFSVYfzucv6tfowRN+4eU+GqhZA0qPVtUlVY9IRIGJnCpKronA/FSydYCb5d8yXoHpYghuL1GSnrjZAyHHpPg/ie8kxe+Chs/FQS8K2l20S4+Dto1xeqy+C7qyBjaeu2mToWLp8vv6c4HebfC+bY2ufPN+jAWEdqy+QzUw9Cgsth8/uZaM8kDQ0NDQ0NDQ0NDQ2No5p/dGJBURQ8Hg/9+vXjww8/ZPXq1fz666888cQTgCQeDh48yIABA45wS9uIwIBRW0sNNBRQWPWmjOCMTIJzPwxOosJhhT/+J/Nj72h7Dfq/Ep1eZFo6j5Zjv+y/Ld9Oh0FS7XH+Z3Dd7xI8LsuGn24XXXmnze9pYY4VKRxf8NQXEIXDz/ufHfj8J8haGAOqE3x9oK4sSOoY+bx4X9sYygbiSyqUZYlB8tkfBhfE+zsw8HyZZixqWMKoKVRVRpFXHJTjM+5er09MQBIo8B5W38hr+PslCVrC0ZxozFkPb52AfvccnOh5TbkM5/R3ZSR9W7BhJmz9VpIIp/5X7tvN5cDvMk3s23QftMRJZU3v0737/0QSG21xr4xKhjPfledE5SH44Vr46VaozG9qzYaJ7yGJFp1RvH9Wvl77+7qDDkD6kN50uFRiQ5gsch+NSflr+5lPzk5DQ0NDQ0NDQ0NDQ0MjaP4xiQWXy4XT6az1mcfjqTFljoyMJCoqis6dOwOwd+9eHnzwQRYvXszll1/+l7f3TyEwYNTWo1LrCyhYC2D5SzI/8eHgEwRr3hXN6ZhUkTRpCaoK+5fDlq/R5awhTi0O3uPgz2D0LTLd/oMYUreWqI5w6Ww5RuXZ8PMDYmJqMPiTCVUVMg00SYW/XvbonyK1ZLL4g9I1GuQBwenYrhIwc1dDwa6222/dpMK5nwRnFl64G/b8CvuWigxLzno4uFXMX4szRNbJWiAST20xirqlJPSWgKbbCbvmtmwbB36Hfb+JNM1Z78k0sGrBYfUb0frMmutLlP5TkmRHW/JEVeH3/8H7J0NpJp7oztyme5TZupPazkNk/zL47VmZH3sHdBnb/G2UZkLpAUkER9VTqVAfOgOM/DeMuU0C9pkr4PvrpEKntd4L5hipXBhyhVQM7J4vMkabPm95n04aDJMflflFj8u9w1bU8P29ob7UEEfq+vM9pzQ0NDQ0NDQ0NDQ0NDSC5ih2wm07tm/fzqOPPkpubi7dunVjypQpXHDBBeh0OtxuN3q9vtby+fn5fPrpp3zyyScsXLiQXr16HaGWtzFGS+1/1gODzYH4gmcqEN7IP/i+4KnRXP92lj7rN17ud1ZwbbSXSpUDwNg7RTKiubiqYcXLkL4IABPwGVBGOMYFadCut/g2xHeXwHxrjT6DIbG3yGJsnyVeC+d+3Ppt+pILH58uEkvz7oQZ70CkQc5dqFc+KjCw70sqBTsaOTAp0dJAT3P32Za0Rfubtb+AZIIvyeALqCmK9IX9yyFvI7Tv3/r9lWU3P6lQVQar3oI9Pwe/n9AokYPpOgE6DGtVk5uNoogc0tJnYNsPMPqm5m9jzTsy7XuG6PE7KsHtDSJaC+UaUd1gLYbojpJcqOuvALX7UuD1VPc6+6uvuyPJn/1by/NkpP2eX+R972k4Tn6RPa+sbrt9FO2FOXdKsL3vmWLO3BIOrJBph+Oa/1zpcZLI5y16QirQ1n8IGz4Wf4buJ0v/07fgTzajBcbdLbJLvz4Mh7aI7NKOH+Hk/4PEFvx9M+wa2P877JojfhQXfiu+SPX9PdBYpUJD186R6D8mC+gq/pp9aWhoaGhoaGhoaGhoHCMc84mF3bt3M3r0aKZNm8bkyZNZuHAhzz33HL/88gsffPABer0eh8OByeQPAkRHR3P55Zdz9dVXk5SUdARb/ydSN8kQiM+IFsBRJ1DmCxo4bFCaA7gAgzcYF7C9gl2wzmtUO/mx4PWpV78ppo0JvSQQ31wqD8HCx0QDWtFBygg8ZTmoZdlEUSlmlgc3+ZfX6SE6VWQjzNFiMBkaJa+QCP98aJTfu6CljL0Dds6BjMUyyrPTqJZvy0fd5MKs6+GS2aB4wOOUUd6tkTZpKJDaHBq71v5s2qL9zSEwmVBfQK3jUG9iYRMcd0nr9lWWDTPPDj6poKqQvlDkS6rKAMWb3FDB5RB5Jne1BNzd1ZKgc1XL91VlkhTbPosQYxj3egayXBkOzslgrCcA39b0mioyYvnb4dB2aNcn+HVLM2G3N4ky9AoxNHfZZQS3yw6GUFAAp1O03Z32+pMK0HCSrLJQkhWmcDGk/auvu7aiJQHdP/O3WgtlhH3JfhnNf9ITMOxqcLrbbh/2Evj6Mjl/SYPhxIdaXgVxYLlMU8dAVXnz10/oBWe9K/eI3fPh0FbIWiWvlf+DHqdIX4hKaf62E3vDBV/Aps9g+Yt+E+bh18CYW5onnaYocPr/4J0t0r8WPAQnP+dPqvr6h2/wgQ9fRZCPhq6dI9F/jN6qSw0NDQ0NDQ0NDQ0NDY2gOaYTC6qq8vHHHzN58mQ++eQTAO68804++OAD3nrrLc477zy+/PLLmqTCBx98wMSJE+nUqROdOnU6kk1vnD9b0sdolgC7LyjgkwmpCRqEydRghIoSiEisHYxzOeCXh2QEcPeTIHm4fFaX6jqBF1sRrHlP5kfdIIEeCF4Tevd80ch2WKUtx10CcWk4XArnLIinE9m81HszxspsGQVbkSejLIvT5dUkCsSlSXAyNNL/cbt+wbUvMgkGnAsbP4PFT8GFX9YfwDKEBLc9n5JZZBJcMgveGisSNvnboPMokXnxSTv4AibWooCATd1AUj1tOZLVBi0l8JgGtr/FkikB/a1ulU5g4ExVwWQGS6z/vdMGDrt8brT4DWbzNjWdpLKXNPxdoPxRWCKccBeU58irPirz4feXRKYFRJYs7US5dupStDfgp6syitteIv4ElQdRnFYmsIIJ6grUz14Tg9ik46Bd//qvk+ggg6CN+U6YwqDLCVKFtOFTmPhQ09szR8t0/UfyG7pOgOSh3n05pR+4HJJ0C4kAC7UrTOrSWNBdAVD9XSiYftOW9/G22JbTBiVZcl+H4AO6bX2PcFXL1F4Kn58vSYXIjiJhlTRIrhNXQGJB9YDaSN92Whv+zu0UY+OS/WK2POqGpp8FdZ9bNZ9XwsEtMh/ZEaKD/Bti+Qv1fx6ZJAnt8hzp77ZiMXfe+CnEdJFKhnb9Dq/qSxvf+P56nybG0b+/4k807pgNEx6s31NCaeA+ZQiB6W/AJ2dINUnq8TDgAkncOaxy33N5/RXs5WD2/k0RmFjwJWJBkkiBUmSBCYrGOJIShxoaGhoaGhoaGhoaGv9wjunEgqIo5OTkcPDgwZrPLBYLV1xxBaGhobz22mvcd999PP3006xYsYKnnnqKRYsW8eGHHx4mj3RMEOxoVJ8MiLWwYVkX3zQkovZ7EImE9IUSkDjxweDbt/ptaWO7/pA2Mfj1VFWMJNd9KEGmyI4w5DLRl/biUEzspSvujqEYdYP961WVQUWuTB02CUL5zK1d1ZLccFglAYEqQddlL8DoGyQQ1VxG3QBbvxcpnL0LoPvk5m+jPqI6SqB4+w+QtRq6eY+fs0p+j61YAt5GsyRwAhM9DUlZwZGtNmgLGpK0aSm1EmwW//uKfPG3KHfJCHhLjCRzHHZQXTI1WmRENEDBzsaD2I1R11PhhLsa9i/xuCXhtvUbCcgqegkqdhwSXPWNosg6YfHyUvtSbStndnYUx6ur6eApkGs5b6MslzQI+p3jD+q3Jb1Pl8TC9h9g/D3BSc04bbBeksoMv9r/ue9+FhZR+/owhUl/Dwxy+qhvFHVNJZe3n/j60d+x3zhsklRwOSGiGW3/M36rwwqzbpTrKjRKRtrHd2/bfQAsfhIyV0rVzbh7W2cCfXCLPH+ikqWvNJYYDBZTmPiLxHWD8HaQvVa8UUr2yWvvryJL1Nz+Fp4Ip70I6YthyVNS/fTDddBnBkz6T/AVhkmDpMJjwcOw8HHoPEaSjNYiGVigIvcFi/dZbKpzv6vvbw3fZ2153w6WY9k7RUNDQ0NDQ0NDQ0ND40/gmE0sqKqKoigMHjyYXbt2sXPnzhqvBLPZzDnnnMPu3btZvHgxJSUljB49mrvvvptJkyYdm0kFODwwVkveyPtPfKCJaS1Zl7DDA3D1/eOvemDhIzI/+FIJiARD9hrY+LnMj7kl+NHlrmpY+YYY0AJ0HAz9zg7Om0FRJCDTUFAmJNw/73GJzNKqd8BWKMmFkf8OfjS2j7AEGPovafOyFyQZ0Bp5pUC6TZKga/oCmHCffGYrgYLdEvC0lUKHvnLuPS5JNoRGBj8yVKPOCFuvsarLAVUl4FFFfiqyvRz3sDgJpPkqFkCSXpZ4uYYObfOPoA+W+oyaG6pSKM6QCqDS/d59J0O3E2sl3JqNoqCaY3lXdz7vqhcye8x2QvI3QO4GqQDKWSfmz/3PhZQRbWesC1KFExYvQcj0xaJJ3xSbv4aqUgn2dj4+uP3Urc7yUd/IfN89VWeQtrWE1ujJ+9Z1toHprO93RTSjHX+WFv7SZ+U+pjPC2e//OUmFDZ9K9RgKTH2+ZYniQPI2yLTDoNa27HAUnVQntOsnlRy56ySBbC+Bde/D8GtbFohPmyCJxj9eFUPn7d9L0mHUDcFvY+gVIu23ex58czlcs9R/3wuLDf66sJfL8g1R37XW1tefw970MhoaGhoaGhoaGhoaGho1BDks7e+H4g1onXrqqezZs4dnn32Wigq/MV9kZCS33nora9asYdEiMfm9+uqr6dKlyxFp719CXa19X1AsUAO5blDNF0h11CMn4RvZG/jdlq9FF9oUDsffHly7ijNg1k0SlO1xcv1yDPVRmQ8/3y9JBUUnngwDzm+Z4XNT6AwSFB57u0yrK+D3l2X0aHMZdhWERovkxrYf2q6NaSfKNG8T5G0WuaeDW8FZKcEoc7g/UaQzSAWDzhD8qHmfqXd918I/BVOADrdPZspkAVMEKCroQyTB4Buh69Pt9gW9FMVv2py3iWZRX1KhPk8FZ5VIgi14WJIKpjAZ1dzvzNYlFeqiKKhRKVJJMPE/MP5+MUZ22sR4duXrct21FToD9Jwq81u+bnp5VYXVb8l83zMlwWAt8stX1b33+fD1D6O59j3OaJHkQWAAszX+JT4CE74tXrcNAqL1/b6g99+CtvvuJ3VHiW/63H/epj4vo+DbmgMrxCQZxPumWzMq5OrD7ZR7Lfjlzv4szNFS0TfieqmwsBZItZ5PQqq5mMJg3D0w+XF5v/otyFga/PqKAlP/K9JPpZkw+yYwmP3JhWCrAMyRjX9f37XWmuuvPupWVGhoaGhoaGhoaGhoaGg0yjGbWPCRlpbGV199xWeffcZ9991HYWFhzXcmk4njjjuOuLh/iGFf3cCRySKjrW1FUJrlDZ6ZawebGwvA1f2uqhwWPCrzo28ObgSv2wE/XA/VZdBhIJz0dHCjnKvKYd49kpQIiYRJj4rGc1uOkK6P0Eg4/lapxHBVwR+vw75lzdtGSASMuFbmV7zs95JoLeGJ0H6AzO/+WQLMIRYwhkPKMNHi98kehcX5X8EGRds6iPN3JrCfGM0QHg/mOIhJlmB/YyagCb1l2pzEgsMqo4GDMWpe9KiMHlZVMQg/5TnoOu7P7xvRneCEu6HPGXJsDm0RU9cFj8LOuRIAbS29p8k0YwlUNrG97DVSPWG0iLeJSm1pt4aSaqYwuXf5vGQauv/B4ffUhoLljdGa5ETNukcgIOobLe52gMmC1WYjv6AAqy3I324tlOSw1f9MpjgD5t4l82NuhQHntXmzqTwEP94iUj19pteWyGoph7bK8yA0CmJSW7+9YDBHw5Ar5Norz4YtX7Vue72nSWIeJGHfkJdEfYRGwVnvS4XJzp/Es8Fhl2dbaW7T/aGx/uijvn7SFom9Wu3QKvc0NDQ0NDQ0NDQ0NDSawzGfWACYMGECX3/9Ne+++y7XXHMNn3/+Odu2beO5554jOzubtLS0I93EI4NPE1x1g6PCX6XgC6qB/x9+OHy0et1gQPZq8SsIjZJR+cGQvkhGOVriYPrrYvwYDHt+lhHIER1kVGv7IA2U2wKjWaQi2g+QoOOC/0gwpTkcd7FI01QchKXPt0273A6o9PqJmGMk8ByRBIk9aicRHDb/yO3m0Jwgjm+k97GqWe1Lzpi8fSg6BeK7SuVCfUFep/eYO21+c9jQJkboBvL7S2IwG9Gh8aSCqvoDtYMvg1E3tk43vrno9FJ1NP4+qV5wO+W+sPI1+PpfMOsGGV1dcqBl24/tIj4Vqhu2fdv4sm6nTA2hkNBTzpfL4T8XtuKGEwaB2JsRYG1J8q0llQJtsW4zUFW15lWTQCgtRDWYUL0eC1arFZfLhdV6eEWT1WajoG7SQa0zrcGbALMVtb0xr6rCoifFU6ddP5jyROsTbk67V1IJSBkZvD9BWxCeCEP+JT4G+dtbVkEXyAl3yTYdFVC4p3nrdhwMvU6V+aJ0uQ+6nOLbUV9FTWA1UGPVkb5kHRx+rf9F17+GhoaGhoaGhoaGhoZG/RyzHgt1mTZtGitWrOD222/n3nvvxWAwYDQamTdvHikpzdTJP9pojc6wyQKOCInlBI4WDPRa8Oma19UdD/RZsBbCrnky33lM8PI6m76Uaf9zRJonGNxO/74GnNd6beyWoDfCsCth0xeiL/3b8yL7Muii4AJVhhA4+Un46jLY9Bn0PElGl7eG7bNlBHBYPPQ+zX88VU9tH4W6BsQ+aRgfDV1HPpPWYH5ffUa3xxK+YxZY2WMMbbhSwVosklTFlWLaDXKtBEPeJr8B8ZQnGk4qgJybdn1ltP6RlKyK7ChmuOU5UJYp7SnYJcmRkv0iATbliZYlBPufA7nrRQ5p+LUNX4+dRkjC0lYE+5dD1/H+a784E0LMklxoqLLKYZXzZmiGtFp9PgzHGL4EwoGCAnSuKmLbJ5MYFk9YWBhWq5WwsMO1/q1WK26XC5vVSpjFe2zC48ERYHjttEn12SnPwdzbYcMnMip/wgNt03CPG359WMzMFR2c9ITch+tDVWHXXCjaK8sGvjxO77wC6KRawFYk3il9p7dNW5tDVIo8Ow4slzYPu8I/GKC56I2S8K5bSRIsZdkyjUuT+350Um2PmUDqyi467SIxaC2G6I4Bvk/H+LNEQ0NDQ0NDQ0NDQ0Pjb8w/JrEAMHjwYGbPnk1xcTGVlZW0b9+e+PgWGm4eTbT2H2+TubaBMzTstdBQwqAwHQ78LvNdTghuv8X7IGulBGn6nxN8ew+sENNKc2zwfgx/Bjo9DLoQYtNg40xY8660a9QNwY1a7TQKBl4gmuLzH4B//dgyA04fa96Vaa/TJYjmtEmw21YKigMcXhmkuufSd67tZWCOapsAzrEaYPUlFBw2MJj8CRmfzn1Dx01BpKnWfySj7TuNgsTeTe/P7YBfHgRUkRhKDcKAuF0/CeQf2gp9ZwT5w/4EFMVrmjxKEoBV5WLuvHu+tG3RYxJEjuncvO32Ok3WLc6Q7TVkgK0zyLLrP5JERtfx/ms/sr1I1/iSb4GJVF8fdNolqeByQniQiVJjC5K7RxFqAxUCqqrW+Bb5Egg2h4pOb8FdaiWhg4rFbMZiluOrWgvBaEE1hKIoCmFhYdisVubMncvGDRsYMXIEZ591NkpItOzAXoGtYB/VDhfmuL6EjrwFwx8vwor/iR9Nc8yE68PlgLl3+pMKU56AxD4NL79vKaz7oHn7GHq5VMccCdJOFEPnykOw48fW9Xtfor650mWqKokYgKiOUhVkMvuTrU6bN8lgOfxvCodVvq+qgNCIOgMYjtFniYaGhoaGhoaGhoaGxjHAPyqxAGLaHBnZDAmSvwOt+cc70MA5MKhdN/gcWJ1QH067yB8AdBkX3L59mtBdxkFkUnDrqKpfdqjnKX+OUXNzUBQYfpWMrP3jVdj6rchsjLsnuLaNuwv2/SajXpc+B5MfaVk7Kg9BzlpAEZklvVEC2ZZYMDlqVyiYLLWvFd+59gWAAr9raTWMKexvHWBtEF8SRsE/KthpEzmXsICKm5ogmlmOg8FrZLp7rnw/9Irg9rf6HZE3McfC+HuDW8dnDl20p/Fk4F9NaCSkTZBk4C8PiP/Brw+L8Wswfiw+QsLFxHnrN1K10FBiAaDvGZJY2PmTSKb5rv2Gkmt174Mup5zXuve+1lSJHeVs37GD9PR00tLS6NPbn/yy2e01FQkJ3oR8QUEBCQkSiN5/4AB5memkROoorahk174cuvQbzuDjjqtJOmzcsIHcvFxmz5rNqFGjWbJkCV9++hFRipURI4Zz1llnYfN4iE87Bb3bjrL6TVj0uCQXjguywqcuDivMulES33ojTH0BepzU8PLlOdLvQJJRUSlS9aV65PnjsvvnfZ/HdgkuUfhnYTRD2iTY+aO0vdtk6SctwdcXm5tYsBXJsw9AFwq2AnCFQ5RF+ktpriTqFMX/90RgxaPeBJZob3LOXLuPNef+oKGhoaGhoaGhoaGhofGX8Y/wWDjmaa3OcEW+yA8ESqfU9VoI1EOuD1uBSEREdw7OvNJph63fy3xzDDoL98ioSL0Juk8Jfr0/m/5ni2SHohepm18elEBlU5jC4eSnZH7TZyKr1BIObpVpbBcZJa4z1ParqGpEJ77GzDn+8OtIM2yujc9XxBLnT8ToTYcHmB12UF21tcUPbZaKlvBE6Hlq0/sqSodVb8j8iQ+Kb0YwhLeTUcceNxTsCG6dvxJDCJz4sFyntkJJLlQ308B8wLky3flT4+umHl9bDsnnL2Itqm3K3JB5rLmBJHTdftES0+ajlPT0dKxWK+np6bU+t1qt/P7777z66qss//13EuLj6dO7N/Fx0g9ycnKoKM5nd/o+liz8lUW/r+bXX3/1b8Bp54Rh/YgyuemZEs+mNX8wZ85PlBXkUVBcxm+//ca1dz3GN3MXU2WMhPH34Bzs9eqZfw+UtsCXw14CX18uSQWjBWa83XhSwe2A5S+Cu1oqf0ZcLwbPfWdAv7PkPl/z/kx5P+BcSB7W/La1NSkjpN/bS2D9xy3fTksrFnzVChEBgwR8BTCOgOqf+hKdte6r3r87Gnv2HEP9TUNDQ0NDQ0NDQ0ND4+/MP65i4Yihqk0bUbbWRLKl6A0SBK07WjcQp10SBw41YDRhQNA0a6VMu46nHjfOw9n5I1SXQXh7MVZtLIgRGBTfMVumycMP/84nxVQXjx44y9vOPyCpb9PtA/9vagq3N4EQliCm1es+gKxV8PODkjTxndeG9Lzje0igatv3MO9e+W3BSCIFLnPIl1joKhIv5lhv0NSbO2yOUXCtffwNZSiCNXxtSX9rqNrDaKbmunfY5TMFMEf45ZO2fC3fD7xQlnU7GvkNHpFucTslYNiun5ic10d44uGfJQ+HXXMkOdHjZPmsPDe43xjdqfHv3QH56N+eBcXZ+PINSR1FtBct99ID8N3VcNHXkqRpClO4GKfHpIpfw47ZEuCti8cNKJLE2fCJ9K/Evt6EnyqSOAZTHRkkCzXn8bBzq/iXhdqJCIfNrw8fk9w6SbOW0NxrWVEaXCctLY29e/eSlpZW46MMIme0c+dOHNXVbNq0ieOPHyNfeQ9XcnIyu0oLiU1MpGxLOqrOSX7+IV597VX69evPgK4dGdS/L3EWHZt2ZKBTHSREhUG7WFwuN1a3EZ3OwOI/NjB49Ils+3EBg3ucwKhO21EyV8CK1+D0V2RnAUnbq6++inZxYlBeVFJCcUkpRcUlROqq+HhKJfFqEYREwMn/J4nXhvrB9lmQtVquKUOIPJd81XGBpAwP7hgvfcY/r6pyX1ZV2bZO7/8u2KTE7nlNLxOeKM/STZ/LPaC+e4OP+O71f272Vl5ZC4JLjvvwmdLHdoEob3LBaPZWKHi9ecLr9DEfgffVun2svmdP3aRDMNVDwfSRI/U3mIaGhoaGhoaGhoaGxt8ULbHwV+G0AUehBJPJIoG6uubNdTGaJangM2H0jci2V0jwdN9S+bzr+OD26xtR2Xta7SBLY1RXSuAHRFO6HgrLq4gOM2HQ66A8TwK04W1kzu3xAGrj7U3sDYMvE7+DrJUS2GmgrbUYdYNUK1TkweKn4KQnm9c2X2IhKsWrDR8g7aIoYC/3VzDUBFDroa7Ey99cM/5PJzAgpnpk6rSL5IrOIP3FWgwl+8RwWNEHJ+my/mPI3y7navTNzQ94dRwiiYXc9c1brzX4ZGEUfZAG5qHQrg/kbYHqcljyNJz4UHD+JIoiI8iX/VckkepLLPjoc4YkFnbOgUmPyGc+mRhnlQR8Pe4A01jv+aybRAK/ZJLOUFuexWj2Gz07bH99YqGNUBSFvn370rdv31oJOkWBMIuFMWPGsHr1alJSUrDZ7IRZLCg6OdepnTuTkBCPzWpjolsh78BeVm/aTk52DocOHqJ8YG9iIszkldrpkJxMubWK40cMJj+1A4ntOrBk1WbSd21lyJCB7Ny6gXUbtvLbwl/QzRjFSFagbvqMeZW9mfP7VpYs+53kc6XS6/NvvsftrK71O7rGKHx8SRjxqo4K1UzEtJcl6doYpZlQuEvmO41p2/ue0+av9nNUSgLNaA4ukdYczLGShDy0VSrgxtza/G3USCE107zZV7GQ2PtwE/v6+lJDBPYxX2Ib/OfD94xSkIS5Zu6soaGhoaGhoaGhoaFxxNASC38VgaP7jyaMFohpYoQy+M0Wa957NeMtMVBx0BtUUIIzbj60TUxXdXroFYQkjI/9v/nlluoEiVRV5clvN/PQlxsJDzVw4/ExPD1Ggk3l7CNMdwpWJQyPJ8jR7LU3LkGnQ9sk6NlppHgqNES7vt4KhO/ESNMSBx0GNr4PU5hIKc2+SYKgPU+F1DHBt/HgFpkm9JLBoC67TEMivBUMkeLD4KyURFJDQZ6/OkhzLEhZ+OR1FPyjfasqpG+A9JvNX8h8r6kQ0aHx7ZXlSJAdYOiVjY86boikQXKtlmbKyGOfvEkrKamo4vtV+yEq4NpUPVBdgVpdLh7VHgUMIRiNIVIR4AsS1ocpXAKRh7ZBxhKwxAdv1NvnDFj+EuRukMqMuLT6l0sd45dDytkAXb0eMGU5EuzV6UFVJCng8yFpiIZM7E1hkpRoav2/OSeMHUuvXr1wuVxYrVa2b9/Onj276dWzF4MHDybMEkaYJYwEywAY1IdQs5lVm/ei0+s5kFvAqkOHOK5fLxJiwknokMLBQ/kcyD7I4pUbKCwuJSomjt37c1i/dQ8btu4AVWXjtl28N8HE2A4Ocr68g9d/rEJvDCG5gTb2S9Txy8UWOkToSC/xYB1/HwNiu1JRaWXF2k0sX72RQ4VFnDBiMFPGjSIxPlbujT4ZusQ+Yj7cVjgCkgo6vSSx3A55KTrxGolKab4ngi/xE5jEUxQ47lKRjsr8A3qcIpUXzcF3r7C1MLEQ10AlRLD4+pgvqVD3eeSwyX2lrsdN+FE4cENDQ0NDQ0NDQ0NDQ+MYR0ss/FWYGqkG+DviG8nutEHmCvks6TjRgXdVNb7uhpkyTT1BAn7BoHogfTEAzs7jyMw6SNbBIrIPFXIgt4DVW/cwe/FGAAy4uLG/XwYokUJe89zPU7qbGXrfXO6/pJozju9HuKUBaaJAqisgd6MEJX3sXy7JhcYMJbucIAHd/cvk95pjoNOIxveVPBT6nikJiXl3w5W/BDfy2WH1G2e3GyDXmi5gxLyieEfRh4LTKjrXlrjaAVCfXA80LD/xZ3C0Jtyag7VIDF8NIWLSDBAaIckda7HIGW33Sng1ZdqsqvDzfXJOE/tIRU9LCIkQia2CnZCzvnFd+SawVjn4aMFWZq/cy8KNB1B1RiY+dDWK6uHZefu4eahKdIjkVTyqilEHeKqgugqqQbUWoBgt0ibfy2jxB0TN0SLLUrhbqg/CEvweCo0Rnij9LGOxmKaPu7v+5XSGADmkb/2JBadd5NhCY/1JgaaMrhszsfd9dwzKqagB0jVhYWFs376dkpIStmzZQmxMDAsWLGD37t307NmTQYMGST9w2Uns2IXwjIOoqkrGvn0cOniQ2d9/g9VeTXbuQVyupqV2DuXnc49dz4orw/jXIBM5Xc6jz9jTeS/APqRfn14kxsfTQc3l1TGFRIfA5kNu3iw9AcfXS9jwnzfZuG03Ho+nZp13PhWPn+EDe/HZyXbSQh2UqhHkq13oYHcQYW6DagKnXSoUQK75kHBvJZm3Ukb1QHGGvMwxkmCI7FA7EeeqlvuBrUi25/Teq33B9w6DalfRxXQWk/T0RbDhY5j8eHBVQD58z7Wqssbl2uriewZFJcs90VcZ53u2BBqlB1bNBX7vq2wwWajR4fJVLFgL/d/5quocNqn60Bm0agUNDQ0NDQ0NDQ0NDY0jgJZY+Kv4q/7prStlE8yyRrPXLDFQazwgeFbzeag/meALCNtKJIABwckguaokeAjQ5/QmF9+flcMTz7yGpTydV8YUUValknTeq9gakHV/5fJhXJBWSbwzh1ybkUc2xvPQwAJSwgp40fMIP44z8uH85dzxyTom9EviiYtG0i25ToJAVSXQk7VapIlUVeRdEnrKyFZbERxYIRJHjY0y7XOGBEMKdsCa96Dv9KalL0b9W/ZbliUa3ZMfa/IYUbATUCE0BuK7yTlxlUqACvzBGKMZSnNqj8z2BXWcAQGasHi/OWYw11Fr+Lsk3OoGvwJRAL1XN90XPLMXg60UDJWw9QdJ6CT0FDPhxhJve3+V/qQ3wdjbmxcQrEvSYLk28ja2KLGQX2rl1dnree2n9RRXVBEalYA5sQvdU2RE883qe5w6RgLO+8p13LdUx7oD5XSLhd5xOkZ01DMyWU/naJ03GGqT/gNyf+kwyB+E90mGrXpTDKsTe0P7/k03st/ZkljYPgvG3tGwTJlPDmnXPJhU4h3trUBIlFyDzZFq+YdjsZix2+X+HxkZSUZGBuvXr6dHz55UVlZiNpuJi4sjPj6ezNx8KioqACgrK2XV6tXs2+83YY6NjWHggIH079+PhIQEVFXFo4LL5UKv16OqKg6Hg759+lBV9RmhOSu4ZWwMucPGwQ7xwIlo34UDJU4M7ixmn1VCmBFWZLmY+pmN0qravgRGgwG9XodHVdEpClXVDoaZ0kkLNVNWpTL4rVz2lX4OQHiokQ6xFpJiwugQG0ZSjIUBqfGcNr0PcdFBVBe4nZKYhtrPVJ1BnhumMAncG0LEa8ReIq/87WLA7naIh5C7uuF9OKziGRFdR+6v/3niOVS0F7LXiE9LsIREyv3H7ZD+GhWElKAvQQJgDPPL8JksfmkjX+K6ugJsxVIVUvf7un3QN4DBWuivXAiLr/1M+rt5AGloaGhoaGhoaGhoaBxDaImFY43mSNk4bKJt7tMWr/UPfkBiwVokoy5N4RBtqe2vUFUigT2Anqc03b6qMr8sRNJxDS7mdDp58e2ZPPrCW9jsVVw12AiYWZbpwuYEnU7x+mH7R9LqFHhu9jZGnBNKfDuYE3Y2B8ZO4xbVym2edxjLamZ0cTOjSxV5mJjnSWX6Ax9xzwXjuOSkISiOSqlOyN0AVaX+xoS3gw4D5JjEpsLOuRJIacrYUqeXEdUFO5qu4vBhCoNTn4EvLoL1n8Cgi5qWsghvJ4kP37lo3w8M9XRtk+Xwkdm+c65Su1Lhr5JE+ruMMm0s+GWJk99hCPUnSpxmCHVBZSEUeyVCek1rejS7tyqHQReK5FdrsHkN0fVBVOYEoKoqnyzcxo2v/0qFXUYs9+yeRpeL/osnYCS1BQkU5pLITdHPUX2aSvbL15Kxt4DNhwzMy4CKaicul5sRyXrGdzFyUvdQesW40Tmsch8ITMz1PxfyNksF1MHNwSUWuo6T+5LNm8Br16/+5VLHiARVRZ5UEA04z5sorZNE/Yej1jI+9897PCpKwLWbkpLCmjVriIqKQm8w0D01GdVWRFJiDE6Xk5KCPGLNCr3SUrHa5H6fmbmf/Hy5Ju+6604uuuACUjp1qrVdQWHjxo0sXrKEn3/+mbVr10przmvHJT1gxbb9vOJNKgAMv/p5AG71vE2YuoQVOQqTP7HVm3x2ulw469y2u8dJ8u6jTQ72lfp/c2WVkz25ZezJLau1vP61xYwf0oszJwxlxoQhdEiIbuho+mdN4Yf3fUUkw0geJhUM5dlQmiUJuPKc2ssazLKs0ZsgNprFt8Vhrf85ZI6GbpPFfDp3Q/MSC4oiknoHN8OOn6Dj0CDW0UFMF/GoWPUGnP6q/xlTVz7MViweNL57aUPyYoEEVikEonkAaWhoaGhoaGhoaGhoHFG0xMKxRkP/gNdXyWCySNLAYPL/Y1/fP/hKnanPX8EYCn/MlJGNKSPFMLYpAoMAbicYQnA6nfwwfzF5hwpxOJ1YbXa+/ulXtu0SaQWdTsHtVbDwxb18XgmR4RZio8LJOVSM0+Uiq8jGgt1uhrcLoQP5AFiVMJ7Q30pXdT+nqIuZqC6nAwVcofuOSy+Gn3bPYu+8VXQPLfbvwBACkUkQkwqhUf42+ySRDObanzdE1iqZJg8N3qgzdaxoY++eBwsfg/NmNh6QjkqGkdfDH6/K8pd8J7JHgecxcMR9oLGm75yHRdQOsDZ0Hf1TaahvBPorGEJrLw8QGyGjkCE43fZD22QaTDCvMarLIcNrqN7MaoXnv13N3e8tAWBwt3bcf94oZq4rw1bHJ+Ej5VxGq+tIIp/R6hqWGkZjtERSVVZAbrmL3HJZbsbgdqzMKGX2LjvMtzP7fDPTehqZuXg7F0wZht5r/ouiyMjrTCQBGQx6o/StjCVS6dNQYkFnECPb+ffA6reg3zn1BzIbq0ypW9HVUIXX3xSr1YrVaiUsLAyLpfZvVxSl1i0oMTGRkBBJWMXFxeIozSU0JIpQvYrRYCQ2TIficdGtSzI9+g7g7nvuZtWK5VhtNiIjI7n/3nsxGAzo9YdXmLz0yv+4//77a32mV+CUFJHEWa4MP2wdi2pjorocgEc3xNGtZ0d6dU+jfbtE4sNNxMdG13oZDHqycg+xPyuXDgXLgI0M7GghOc5IdlFlvccnJT4cBcgsrGTh6u0sXL2dG575mN5dkhjWpwsTh/dh2gnHERPpq0wwSsBd9UjVQeD9oS7GUIjrJt5BxfvkeR0SKebEIRFy/fqqH8Arj+SVCApvwD8lobckFgr3NLzfhjjuEph3F2z+EsbeGZz/w/T/wQenwp6fYeNMGH6NfF63GiiqHtkx398nvuV9/dD394qWQNDQ0NDQ0NDQ0NDQ0Dgq0RILfxFVDhcmRxMj3IPV5q41qrQuJjCaZLBk4P5sFd4R126wmPzLhiV5ZUrcYuxrMAMhtdc1RMtnhlDv5959lB4kZMcPKIBj+A14fOu43I203YQvvFJlt+E26rj0loeYNX/xYYsaQsyoXk3sUEsooNIuPpqrzp3A4D5dGd6/O727JKPT6fB4POSv/pqM/AoqctOBXFLV7Frby1BSeU25nHfVCxmrruIUdRH9dLs5o5cRKAIVPJEpuJIG40noK6MvATwBbSo7iAFwRSThUg1eo+QGfmt1OSEHN6MA1R1Hozo9DSxYB4cb5fh7MKUvRNm/DMeuBXi6nljPggE7HnU7IVu/QynPxrl1Fu5RN4OjSkatGy2i9+87/wQmOLznEmqf84auI2ij61SoaqpP1LN8k/0oiP0CzfgdHho8TrZKKMsHlwOiPCJH5bJ7+5EJXHZMlfnoAEdogvQRZwP9w+MmJH+HXC+xvVEbWi4I9Dt/xeh24InpiiO6JzhV8DQgE1SHQ+Uu9MYQdDqF128+jcRoC1d9vJPho2svl6u053NlOpep33CtOpO16kCW3NSdWIeZ7BIn328p5+VlxazOtLPrmcms2lfGjxsPsaX4ENNQidbbufObDJ4+21uR4/SgN0ZiBNy2UpwN9Zc6x0WfNBRjxhLcB1bhHHiZ/4u610nf8whZ/hJKRR7OTV/i7n0mqG4oK4awGAlk2kq8wdy6/QQ51zV9KOTw9z6OgMdCW/SjotJy3C4XVU43OoOJgsJCCgsLsVgsWCwWSTgYAKeNojIbMfGJ7N2zhw7JnSkvyCEmFJb9vpLypWswGxQiLUbKq9z06NOfbVu3kJtfjN4YwpVXXYPBZKaqugp9Pae4sLgUvdF/PBMTE3n6qknE8y2lRLKRvoet05+dmHCRSzue+2g2PdoHBMJ98lt16JKaygmALrsj/LqRsd0i2PPOGZRWVrNpfyEbMgpYn1HI+vQC9ueXk1smJRB6YwiKTiHEaKCq2snu7CJ2Zxfx6S9r0es/ZcKwXpwxbjBT9QY6GC0YnJW4nQ6c+kiqXSrrc6pYsb+K5fur2FPg4KTBm7np5B6kJoQBeojpcXhjPYDH/+eaoXQfBlQ8IdE4DNG1nlG4vPe/6DR51pZnU2WrPDz51djzKOUETFGd0JVl4lw3E/fQqxte1kficejH3Y9x8WOoS5/F0WEYarsB/vthjexdnXuprRKs3iyky+NP4uqNdf5eaSVB9Mvm9iMNDQ0NDQ0NDQ0NDY1/OoqqBhuF02gJ5eXlREVFceL9X2EIPbZG3J3t+ZGr1c85QEeu1T2DGqQe/I/uSzHh4mLdKxQojRggBzDJ8xt3qW+yhoE8qL+n0WW7qJm86bmXCiycrXun0YBCJzW7ZqTrQuV4MpXkBpfVqW6+8FxPFJXcpXuQzUqfRttxgecH/qV+xXa6c5v+0UaXrY8rPZ9zrvojWXTgOt0zuJTG84ATPcu4W30DK2Yu171ImRLZ7H3+1biqbCx66lzKysqIjGy4vX/nfvSZ+9/EUcoNuifZq3RpcLkUNYd3PXdRRQgzdO/haam/gqryjucuOpHLK8oVzNFNamHLm8aoOnnDcy8p5DFbmcxrusubXKebmsFrngexYuZs3Tu1fucUzxLuUN9mFYN4WN+AGXMduqsZvNrA9uoyzfMLN6ofUkAsl+texKkYg9rH0c6x3o/u8LzJFPW3Bq+xaz2fcKY6jznKibyiu6pZ2+6gHuJDz21UY2S67oOgn2PB0FnN4m3PPTjRc4HudSqUiFZvM0ot52PPzYTi4D7dvaxXBjS47IfuW+hAAffp7mO9EoS0WAAneRZzu/oOhcTwL91LQfUVRfXwhOcZhrKF/SRzk+4JHEobJQb+Aprbj5paTuPPYf369QwZMoR169YxePDgoNcZPnI0Ex/6FoBZ95xEqEkbW/VnoPUPDQ0NDQ0NDY1/Fm33H7TGPwqT6mCGOh+Ar5XTmhWMqfaO7g2lEVPKOni8l6pC06P+s+mAGx0R2IijpNFlM5VkPtCdzwe68xtNKoCMio2ikjLC2Urjvgc61cMpqpha/6S0LLD7uTKdEiJJIY9p6q9NLr9IGcMeUgnDzsXqty3ap0bbolM9RCOyPkXENLpsN3U/ABl0anlSAblOO5GLjVAWKWNavJ1gcCpG/qe7AoDT1AX0VPc2uU4GqVgxE4adruyv9V2FIiPNo6ioZ836Sadzg9ury3xlPAXEkkAxJ6lLgt6HxpHDqDoYo64BYIkyqt5lBqlbAdhIA1JYjXCIeFzoCcFJPMUtb2g9HFBS2EtnjLgZp65seoUgmKHOIxQHu+jKehpPFuxUugPQS22+HNIi5XgKiSGeEiaovwe1jqroeE73b4qJIpVs/q1+GHwFmYaGhoaGhoaGhoaGhsbfDm24zl/E57dN/OtH7jT2D73TLhJIPjNIHw5bgHSBxf8ewOOWz41m9Ktexbi0BDWiIzde8wA3BvoHuB2NNsv4ZjhYrWx+9xbWH1R54bF7ueaScxky+Wx27c3g5qsv4darLyUxwesFULCDNXO2gxNK921iydfnEhVmQa/T4XK7KSkXTewZo7rxyjXjiAkLwbk9Gr2jmC5kUURsg225ueghJkZn1//lkCtqvTVkLoMCCItL5vvUFf4vuo47bFVd3kZMywtRTeHcfNoobtbrgtPYh1reDfptt8Lix7jW+AP/uvAyCE/0L2eOO2xVXeaz8OW5TGMRJ51xOWq7vuKHYTCCyynmzY2ZZIL4SHhcouttOXwfbSmFVF5eTrungtscwOe3ntj6ftTU72tqXWuJSOf41vVtz14hptnVFSKJZI6BsgPo31NRFR0f3nmGGHrbS+vdtGH5QlgHPfoPZdaJQ/zeDE2Ru7HWW+P6eZALpk7D+GKAE/C62DYgCeNj4do9nPnQB7jd/uRdWpyRZyboUI2hzE57ilyl/WHrbVL6skA5nknqcq4qeIxhb1s5fVgKr14+nMxCK9Of+Zn8ShWLEWadb2FUigGjt03DNt7PWz85ibco/DbnKzobOsE86BFuY9ZZiYftC6hXU97401A4sIyXRhbjPm6afFhP/wDQb7gdFj7IjZY5XH3+FaKFH5kkX5bnigSLT1Pe6jXADkuQ8+2wifmsAphjW+dB0oaSSc3uRw08j3wFjAcyM9m7Zw8xMbHExcdhs9mIj49n9erVNT4MU089FZx2VKcNxad/732m/LFuEzu2b8dWlMvWrVtYt2kbO9MPMHLUKOb8+BM6nY5qZzUPPvgQ777zDgBRUdFsWL+O2OgoqhxV6HUi3WXcO5+wOXZyrHq2RxwuExSlltGVLAA2KX3Y9/3TZGxdS1RkJBERYeQdKsDtalziZu+1RnrF6cifeR2L9vvvW2FmE4O7JzG0R0eG9+5I947xxERFEh1uJqTOaOes/FJmLd/Om7NXsD+vBKNex8mDOrA4xUq3PnBO9RecELufHh3CURSFDftKePCrzSzdIV5AOh3cPCKUJyaayStXOWj1MLCdHp0vxzj0SnBVE7JpHrihS7dezIqtJ1mR0LtmVr+vI2yHixN2ct6w0trLBeELot9zEmz9gtuiF3DDpXfJ/ashAjwkdPuj4esLOEVdwpRuFpynvuLvKwZv5YPDDvZikduzeJ/RtmKoKhF/iZDw4O7PR7AfaWhoaGhoaGhoaGho/NPREgt/EaEmw19fdt1YYNcUAXhlGQJNSMMjgYCAk8n7vjQL7AUS/QiNgZWvAKBMuI9Qc51Atbvh4MPHMz9jZNYhesSCWefi9ace4ppLzyUn7xDbd+xAURQOHsyj9+iT6NAugZSk9tgqiuni2c/Ysy2YTXosBpX/u/kcrpgxEbfbzXMfzOah177gm9+2sXL7AeY+PJ1OxhhCHcWkqlmsVQY22J4e0e6GKycCBcBVFcr2AWCITcUQ+J2hnsBGxgI5Pl3GEeo1OcUY5Ch0Y8DxG3A2bP8W5dA2Qpc+DtNf8wdSTPUc524nQPcpKHt+IWTDu7K8xRtAMjVigOm0QWWhBEyNFkDvXb6ea7YNEwuOZvaJNulHSkSAkXkzt+XUQ2S0BNh87ajZnkk0+vUqYAOXDqy5skh4IqGh3uvA1UD/KNwJgKFDXwxGvawfDIE/oTwX8jbIx13HYgj8Tt/w+Sgqs3LV05/gqLIzLMXMKb3DGdnZzKj2DqJ1NqCKqZ57+FyZztfKtMNkUd5WLmKEuoEBcVZuHw7/t3wv6/ccZP59J7LtaiPnfmNjQYab6TOr+eUSCyOTpWEX91N4+Q8nGw96OOfqO1j9yeMA6KrLCTU2cJ3V1486DYcDyzDmrcM43CuVU1//ABhyEax+DaUij9B9v8CI6/xBT1NKHWPZam/gM1zOtynSe49sA9owINpW/cjj9bTpkdaFHmki27Vjxw5wO6koLaZ3j27s3buXbt26yfqmCDxuC4qiYC/Kxm6rxGypJsSgIyYqnF5dh1NeVkJefhHbdu7m99+WEB0VzsKFCxg8eAgvPv8Mjz78AIsWLaJXr14kxMegeFzoPC4Mejk+IbtnA5CbcAJq9eHnfpAqhucZdKJMieTgwYN069yR+V+9T2qnZDwOKwVFxeTk5ZNzMJ+cvHyKS8vQ6RT0Oj06nQ6dew6QQ9dINwtcTnp1SiC7oJzy8gqWrNvFknW76j2GMREWYiLMxESYmTSkOzefdTxXnzKIy//vK75ftpUfVmbQLiSZq/rYaW+y0z5RRdW5ufuzjTz/k/R3ox4uGxjCfWNDmbfHifk/fuPyIUl6vj8/nJQovTyP8jZJ4t4ciyk+FZR6KvgCT2u8nEN9cTr6iv0Qk1r/cg3RbTzsmYuuJIPQAwuh5ykNL2sI6G89ToSpL8K8u9HvmYv+i0w48y1J9hkipL85HVBdLMbWRp23D9pAp4LODWERwd2fj2A/0tDQ0NDQ0NDQ0NDQ+KejSSH9k3HawFoI1mKvCand/53DKt85rPJeBVzV4PbA7y9BdTm06wv9zm7WLh9/+lkqq8V89fkHbuKaS88F4L4nXwCgc0oSn383B5vdTvr+TJasWM3qLXvBKw1j0OmYPmEYz30gwSa9Xs+9V83gj5lP0i7aQnZhJR8t2kGlQWRnOtNANUJzqSqTY6Hom648sBZArgR36dZKfXudHqY8KaOo9y2FHT82vc6JD0k7MxZBwXYIi5dX4Khia6FMfThs4KiEaqn+qLV8a6lvf0dyW0ZLy3+fySKVDoEj1Wu2ZwZTqIwENoZLksbulVYJb9f4dlUV8rfLfOLh5rRBoXpgwydiSNx+AER3CnrVVdsPcLBY5IdmXtSRR09O5JRuBm9SAbaXGDHh5DL1G97w3MtAbzDXR5kSxZvKJQA8OTGUcWkWMvIrufrtlUSHSqXChFQ9FQ6Y8omNTQdlBLlBp/D2aRLE37xjD9uzvcfLaZV7UrAkD5NpzjqprGoMQyiMuknm17xbexS2yQJhcTI1WSA6BWJSWleZ8DdCUZTDXgkJCYSEhJCQkEDfvn2ZPn06ffv2rfl+ydIlvPTyyyz4bQVuD9jsdkpz9uKwlbNp2y5c6MlIry2R9dabbxESYsKgNxAbE8vZZ51Nv779MOgN6PUGQkPNhISEEJq/AWPGQgA+2Vp/YmwQci1uUKTfWMxmlv30OamdRNpOp9PRLiGewQP6MG3KeK677Fzuv+Vq7r3pKu664XLuuP4yXGEdAOgep0NVweX2UDLrAba8dxPv3nkGV506hP5d2xEdHoriDWRXOVzkFZWzff8hft+yn0c//JXO5z7FUzMX8fptM3j+okHodQpvLc3ml3S5lotzM6iwu3hhjj9R8cbUMN4+3ULXWD33Lwx4BgPrct18t91bceR2SmIBoOPg4ALqUclgiZeqw9+ehfUfNVgxVS9GMwz2GqKveqN5skaDLoSLvpGqg0Nb4aPTIX2RVHj5tq3XgyHEm9A2y30zPF6esW31/NHQ0NDQ0NDQ0NDQ0ND402hxYuHqq69m2bJlbdkWjb8ah02CdwoSLA2UyHHaaycbwmIhIkkCFBs/lc9OfLhxaYR6GDd2DFaHBCeG9euG0+nk7see45OvZ6MoCrl5Igtx+3X/YukPHzPztWd55N/n8viN5wPQo3M7MrIP8f5j/6613Z6pHbFWSwDmtGFdCIsSCYVUNavhxrgdwWu5Vx6UaXiiHKvGSF8IqNCun19ipTXEd4eR3t+75GmozG96+cES5GXBoxJwDsR33h0BwXmTBUzhIj/R1kHU+vbX4m3Z225bLaGxpITTLrI65liRnDLH+oNoER0a325FnkgfKXqIP1zuJSjSF0HJPgmcD7ygWatOGtqDYb1SAPj3t3mobicuq7T95VXVbKrqyLPK9RQTRQp5POt5krs8rxOl+kdXL9WNptrSHh0q8/4Vh8WkZ+mOfD7b4sJiVPjxAgvjvcmF8R/ZcHvkPjBnj1cWaWAfBg4cVJNEpKo8+B+Q0FOuX0clFOxsevlBF8g5qciTZIxGgyQkJNCnTx8SEhJQVfWw17x581m1aiVLlq9CF56A2WymR8/uuKsq2blzB1999Q3pmVK5M378eG688UaeefYZqqqqcbqch71cLhclJSVUbv8V3ZcXgruan3Y7eWf2CtzOw2X2fBULG5V+eFwOyooO8fGX3zfrN/YcMhaAHrE6zCFGPrrnLPR6Hf26tOPKU4fyzp0z2PzuTZTMfhDXov+j5KfH2PfFfax/51YWvXgtb995NoO6JVFpr+bZz5fQ9YL/I6vIxg93jGVCn0Q+3iTtLsvbzy0freG/F0vSAeCq2VZGvVvOnN0Ofrk0ggHt9ER4i5tuHB7CNUO9b/K3g6tKZILiuwf3w3QGOP52SBkh77NWwcJHYNfcJiULaxh6udxT8jZB5oqmlw+k00i44md5FtqK4MdbYIvX/8dkgbhukgC1eJN5MSmSzPuHJPI0jhxZWW006ERDQ0NDQ0NDQ0PjH06LEwvvvfce48ePJzU1lQcffJCdO4MI5mgcfdjLJKEQFl9bc9lorp1sMIWBJQbWfywBiU6joeuEZu9u3NjjsXsHInscNk6/9Aaee+19ABLiYnE4nUydNI7nH7mbE0YNY+2mrTzy+lc8+e4PAMREWPjto8cZNai2efLnc5dTaXfSs2MM4/p1JDpCfksn1z6MP99bs9wL3VYzZftd/PHGLdi+vJ5EipputMcNRV7zy/DDNeYPY99vMm1ttUIgQ6+QkezV5bD8xaaXH3uHBFoPboadP9X+rqFR9zGdJMjT1iNF69tfi7dlbrtttQU1VT+F3mScM6DPmMVvAZquWPBVK8R1kxG8zaW6AnbMkvl+Z4m/QzMwGQ18/p9LCDEZWLjHSklxIQZFZU2Om2W5Js7r4WL+958z8EMDH+8Ox4PCJHU57ztvpvTbu7jA/gnvd5lLSFI/UPSYXWVsuSmeSV313PZzFb9nuggzKcy50MLxnfSUVsEf2VJZUFolbXjlsTvR6fXi4wJQVRr8D9AZZBQ3QM7appcPrFpY/uLhyTeQ5JW16MglsY4A9VUsKHVGxu/fv59ly5axf/9+ANwuFw6HJIfi4uKwRMURHR3Hj/MW8O2335GRKQG8q666inlz5/L8c8/RoX0HTCYjRsPhL4PBgLGqgPAfr0bvrmb+Xhdnf2XnrKmTeWJ6F169YgQvXCIVKglqEUnkoyo6LpsxhWlRe6kqK+D+J//LgqXBGQ4D6GM7AzBtUAK2ef9hVF+p9rFXO5mzchfXvvADyec+S/wZT3HCzW9w1xs/8d1vW8grLie1QyxXTh3G+ndv5cenL2dEn07Yq528PH83Z724nPNHd+bGMyVx0SVGR4Irj9tnbuCEXgmcPLADIXpYle3mtE8ruWqWleuGhpBzRwzu/8Twv6lhmI2KVAr4vFQ6DvYn34LBHC1VByfcDbFd5fm98ydY9ERw61viYMB5Mr/mveD36yMqBS6dDb1Pl/vjokdh0xfyXWCFkIbGn0h8fDxmi/86GzxkMJmZmUewRRoaGhoaGhoaGhrHBi1OLCxfvpxrrrkGq9XKU089Rd++fRk+fDj/+9//KCgoaMs2avyZmKPq/9wUdniywWkXSR6QgPWhLc3a1cczP+OeO29ldIpUOWzOKmf+omWEhJi45pJzyC8sIiEulg9e9rsnrtsso1ELyrzBvQbkURav2QrAReN6oigKqw/Y2HTQTagBvhyXyQh1HQBqWRbPzN5JRV46vS3FTTfaVQ275oh2vaKTwExT6L2B4bJGqiWai60IrN5KhWCCSmEJ0GuqzBfU0QevO+q+LaWK6qM10kPN2daf/Tvqw1eNUZYNTq+MlCmg8scXsNY1cc5y1su0ff+WtaM8R6RSLPHQ+fgWbSKtYzwzxvana4xCrMmF26Ny/rc2bj0hjpnryli8KZOSvAP07BDJrbpHqSKEcL0Tx6FdXPvc16zbukfOi/c3dA238+slYSy+zMLMzU5eX1NNiB4sRhiZrGdER7kPZJZ5OLO3gZGD+8POOSKDZAiVa7g5GL33KrczuOUHeoOl5bmQvwNKsmonEepWbWkAkJWVhd1uJytL7m+nn346EyaM5/TTTwdg0/bdfD5rPvuy82rMoAHeffdd+vbrxzXXXsuHH33Enj17an0fiOKqxuQ1+L58lh1Vb+LUU05maL8edG8fSVo78Qeqxoiq06OoHrrpcrjp0hnMmDoFh8PJKeddyciTzuKaOx/h1fc+Y9nKdZSWNVAFE99D7qv2Ukpy9/Hh/PXMeOhT4mc8xWn3f8LbP60lp7CconIbv2/Zz7tzVnPH6z8x9Z736Xr+04Sf/CAPvDOf00b34Y/Xb+TX/17NCb0ScLg8XPvuGjZt3V6zq94do1BVWLw9n/mb8ggzKQxN0mM2wtZ8N/+eYyPp+RJumGNj88GA552jElAgoVfLTlxMKnQd739+qO7gpY06jZSprbBl+zaFSSLPt2+305+4872aSuAdifu7xjFDp06dWL9ufc17u81GYWELr2cNDQ0NDQ0NDQ0NjRpanFgYPXo0b7zxBnl5eXz//ffMmDGDrVu3csstt9CxY0dOO+00vvzyS6qqqtqyvRptiW8keaAEUkM4rKjOKtTRN6N2GiVBjs/Ph+J9ja7mdrv55NPPOWHiSVx21bWc39NFuEnBFZ3GE1+uBODCGVOZ/fNiAB687TpuuO9xQjsNZMjks1i2UhICPvkkXPUbLa/fIe0Y3qM9+w+VM+2JH5n4sY1NhQbCjPCI5wXO9cxm+hM/UmBTGdJBx3+nhDb+m32jwCvyROKmxykS1G4K3+jO7bObli0KBqcdZt0k3g2xaTD+vuDWU/S1p/Vu2wYl2fJb6wZ2/m6BnPokl1r7Gxpb32mTl8vhH2XvsItnicMbjA7xGqTbmkhiZa2SqU+ypLk4vEkNc0yrzEyT4iI5p48kD1fmeMgoUSm1u7n7p0MAPDQ5noEdQ9mldKMKSaCZQ4w4XB5mvLCU+Rtzpeol7USI6YKq6OmbqOeN08yc19fIskw3+VaVr88xY9Qr/JLu5PudLs7oaZC+svptacjQK/3HLlgKd8s0WCkpo0X6NXjPcWXtJEJg1ZbDVttzpi51PWmOYVJSUjCbzaSkpGCz2ejXrx8XnH8B7Tt0YPOWzXz77besWb2G+Ph4zjrrLK688kpGjRpFSEgIGRkZfPzxx1x33XUcd9xgUjqlcM655/LiSy+yY+cOXG4XbrcLa0g7HNHdAJjeNwyHw8FFl1xGt559eOV/r+J2S7VLuRKJu4c3gbr2fRRF4fO3X+SCM6fhcrlYtW4T78z8lpseeJoTzvgXMT3HkDr0JC647m72HQiQQgmNqtnft19+yuXPfscPv+/AVuUkOSGSf08fwc/PXMaGt2/gs4cu5KFLJ3H2uAH07dIOk1GPvdrJM58vJiu/FEVRmDS0B0sensjDZ/bjqsFGrusn19U7G9xst8fy28MTeeCMvnSMNVNsV1mb68buhK4xOjpEKFQ64M211Qx8o5zj3xOZJMB7zTZPfhCQBOe272Dt+zKf0FueI8HeK0oOyDSmS/P3DeLr8N2Vsu/uU+C4i/yJO1s9Hk+BBFaFHUkZPI2/PSkpyUe6CRoaGhoaGhoaGhrHHE2IxQexAYOB6dOnM336dMrLy/nqq6+YOXMm8+bNY968eURERFBaWtoGTdVoc4yWxkeRO6wSJFUQ82aDEYyhZAx9lMSia4iw7ocvLoBrl/krGQJQVZXrb7qVd97/UHZn0PPQlASggo2mYXw/910AunftzAdffE9qSkf69uzGLQ9KxcL6zf5RnpUNJBY8Hg/Pvj+L3ftFw7tjXBgnPfI9+WV2BqTG0/X4s3AVbMBQtJMr1S8wj3Tz5FKFuRdZiAhpIqiy/QcJahgt0PNUkYQIhpQRIluUvw02fAxj7wxuvfpQVfjlQdlWaDRMf018EIJa1ztavrEKh8pCcFaA3SkJCJPNf00EBur/DkaaJou0NVBWozm/wWnzrx/MMXDYQG+S4HN4PFRbxYPE4xLTZqfZX71ibURyq7pCzE2hFYkFb0DbFOS10QBxUWGcEi19eckB6XOfrCvjUIWMnL51XBy+Mc56JLh788m92PLRNiqrXFz19kqyXpuBYgqH9v1REnrB7nkUWD0khOkYn6pjw7XSRo+qctZXEkyc2NUgpvBOGyT2gT7Tm9dwlwNK9st8czwqTBYxZlcUuf6dNnCY/ebNvmvJWiSJj6oKiE+TZEMts3sbGEzyWWCV1zFCoBxSly5d6NJFAsz5+fm4XS5KS0spLCzE7XaTk5OLzW6jZ8+ePPrIowDM//lnKioqWLN6NRvWr+HgwUOUlleSn1/ArFmzmDVrFvfccy8TTzyRa6+5mkkTJ8g1sOK/vHLtBFKmDuXl/73KgQMHuOW2OyitsAHHAeAedBmGnT+KBF3hbkLie/DZ2y/yn7tuYuPWHWzeupXN23ezafsusnIOciA7lwPZuXw/byE3X3kR9918JTHRUby+xsGt3eDC/kbu+rWqRqIr3BzCqh1ZbMk4iEdVsVa5sFY5sFY5qLQ7cDilH3g8KrOWb+PGM8fUHLNHJ0fBQUk6vrnOxfU/2YBdfLc6h10vTOWRs/sxf+4c3lknPhIZJXLPvmqwibJq+H6Hg98zXby5FqZ2t7D9oJ2P31/MpEGpjO2XQogpiD/hHFZY+57fe6TbFOhzevPuFcUZMm1JYkH1wKwboDQTojvDjLfkmeTrQ5ZYWa6+AQ6+xLfBKP3zaJLB09DQ0NDQ0NDQ0NDQ0Gh5xUJ9REZGctVVVzF37lyeeOIJDAYDFRVBmuNqHFnqG3HrtEvQ2VEhyQVFD0Yz+w8W80fqrTgM4VCcDvuW1rvJF195lXfe/xCdTscjD95P7i+vEaNUUKWYGX/bu3g8Hq655FxSOoqxbZdOyfTr1Z0wy+GBg1FDvBIxAYmF/Tn5nHbD09z3sphJXzm5L+c/N5/dOaV0Sojgp4dOJyIsFFfKGP6nXI4bHRf207Pu2nASw4K49J02GQHeZ0bwSQWQIOWQf0nwJHsN5G0Oft26rH0fds+XgMq0l8XYMmi8IWDfyPp624qMtjeGSmC0rqHz3ymQU59MkskiQefGjoGPhkytGzoGvu986xrNYtisM8ih97j8QbPGJERy1ossSVRKy82+q30yTK0LavdrZ+S4DnpcHhWXTip69hT4TV7XZPqD6TokCPrgV5uprHKhUxSuGJ9WW5Nfb8ThlgTC9C9s/HZAEhQuj4qqgkNishh1SNWGziiJuOaOyi7OkGMYEtG0n0UgPvkknQlQxE+lvpHTRrMkFXQ6Sbb6RltbvaOtFfzVDX+3Sp9WEBYWhsFgID4+nvj4eCKjIpl22mkMGdiXk04YRtGhXCoqK1m1aiWff/YZWdlZTJpyMjdcdzUvPPUfThx3PJ07dyYmOhqdTsfCRYs49/wLGDBoCG8vlyoZU9YKHrjtOg5k7OGB+8Qv55NPP61pgxrd2e9ns+a9Gnmfnt27ct6MqTx53838+MmrZK77leKdy/n1q7cZP3oY1dUOnnv9A9JGnsoLb35Ejz4D2FagYjEqXDbQVLP9nZkFrNudy7ItB/h9ayYb9+ayJ7uQ3MJyyq3+isw+qe2YMiwgqVWaCQe9coExXbji3Kn8cMdYYsNNZORXsmjbIQx6Haf1NDHrwggyb4/mztHS5z7e5OCxCWYyb4/msQlmBneQ59Xewmqe+Wolk+//gthzXmLaf77mtdnryMgrqf8EqR7xECnYKUnQoVdC3zOa59EAYgoPENuCxMLylyB9gcibnfW+eD6AN4HrTSYYzf7EcKAsksMmSQWXU5K3bSWpp6GhoaGhoaGhoaGhodEmtLpiwYeqqvz666/MnDmTH374AatVAtQTJjTf4FfjT6C+0di1vrfLyGlrMUR3lACl0QzGCAmaWWJrqhI6depEZibYUidj2vs9bP32MKPijZs2c+e9DwDw32ee4tabboBPzwbgxWWlWB0eLj//TF5/5mH+WLsRgP1ZObRLjOerd15g/qLljBg8gHGjh5FsKBK5hLl3glsSC//7dC73vDQTe5WDEJORe684gzc+/4n8MjtJsWEseuJMUhJESmXZ9lx+0l1ClprE4+5nCDXU79NwGBFJItvQEjPd6E7Q/STYPQ/WfwCnPNf8bRz4Q0ZxA0x4AJKHNm/9GkNateER+/UF4n34KlqcNgmSqUhw5+80ItvoHXUeTNVCfRUPjVX1+L7zSXQ47RAWKx4LDru8j06VZRuTQmqtDBL4pZCCrWZpgMFRpVAJvx3wcPnIOB5fWMyGnCpO6xPOT9sruXBmDqvvjAT8FQsuD0wfmszk/h2YtzGXlXsKGNld/BE+XJLOg59WklOhEmaEbflu9DqFj84IZWSygZRIhfJqiAr1JiOOuwRiOje/4YEySM2RgvIFNu3FENHemzzQgzXge1/lQnya3B/DYv2jrY2hYC+Xz3wyaaWZci8NiZD7wDFMWFgY5lAJhsfFSfJ1//4DOCtLqbZZiYuy8O2cn1nx+wrcHg8Jeg8dY8MYf/wI5vy8gPYxEThcycT17Um1vYIDB7I5kJdPdk4ONz3+OuOvD6dfopPCFTOJn3gj995zFy+89DL7MvZRy+1m6JWw91fY+yuZ7x/i5l9cHCy188Bt/2bapNE1i8VERzHphFFMHDuSuQuWcc8TL7Jt117ueOR5OreLZvFdw6BiLc9OS+Sqq8/AVu3CVu3AVuXEWuVEp1MIs1gICzURbg4hzGwiLFReUeGh/qRazvpaSQUSe2NSFKYPTea8TXm8sWAvny7fz5QBHWra1jFSx7NTzGwvcDN3j5MrZllZfkUED403S8ILld5dO3HZJBO/rN9HXnElP63ay0+r9gLQo2Ms1592HLde29d/XEozoSJXgvrH3w5RLZSC8UkeBuMxFEj6YvjtWZmf+LD0oUACfUxMljrvw7yf2cDYAvknDQ0NDQ0NDQ0NDQ0NjT+dVicW1q1bx8yZM/niiy/Iz89HVVX69OnDJZdcwkUXXURysqZpGjTBGim2hKYkYUzhOB5GAAEAAElEQVQWCZoZjAH/1IfVBJHzCwooLiokLi6e7j17061HL0g3wN7vYddccFf5pRWqSli/dlWNMeeXX32NqWg7/w75A5dH5fU1Du6+9Qb+776bACguFUPNsopKUHScOnkCp04OSEjll/rb7HHx6qdzuPn/PgBg3NC+vP7Qtfzntc/JL7PTr3Mc3z9wOmlJMTWr/7R2PxwHm5S+0O9s2PermCErekkcJPaWY5+9Gg78Lisl9IROoyXIqLobP7Y7Ztf/uSlckhLlubDsv3D2e41vx0dotJgBz7tLkgMDzodhVzdfO993Pbkc3vNuPTwp0JQcFsi61d7KI0cQy/sIpr3N/U2K0vx1AhMGgevW7W/BSIM57d5gc5j/M4fNm3yL848EDgmTl8c72t/mlUJSdIcbkGeJ1wjJw2p/1xy9fl9ioTF5k6I9TW7GWLgNQkWC5aGEXCJNUFIFJ3d2sj1PIaPEyaw1B2CIP7Gw+oXzSUxI4L6PfqfKo2NZeiWD+3TjhreW8O4vYr7eISGG1+6/kuufeIdDRWUYJz9MSXI7sp66mg+nGTHpFYjrBoMvA30TjyWfL0Kt35Yu04Re/u+DuUx857E0SxIBIVEysttaDOZIfyUKSOIg0GPFFAYUSqVPIGqdaV0Ck7zBJOmCeS78Gc+OILfpC6bb7HasViu/LV2Ks8qKumMnZ110Odt3bKe4pAS9TkdKnJkpE8cRYjJQWV5JudVOv379CNdXsz89nQsmDaJ73+NYvXkX38xdxJfbyuiXGMqWr59m6IjLiYiI5LSpU/lu1o/+BpijIXIEnPgQLH6KTrbNvNDXw4Xf2nnqlXeYNvWUw9sMTD1tGiefcirP/+8t7n30/zhwqJRX1sKLfUMxOcvp1zlOZLm8FJaUo9PpiM1ZAAT6uHhfvuLMwEoFkNH+3hH/VofKjr2y7ra9mbCzuFYiTQHevNBBn//bwx9ZLnq8ZuXSodH8e7CBeGMV3VM78uHxw1BVlc37Cpi/LoN5azP4fXsOu3OKufu9xdxy883+BIev0qBdP2jn/y1A8B4mDqu/4iqum79Kqy515RBLs2DW9YAqz92u4yUJFxrlX6YmQWdu4L33ntzQ3y5NDZgIpBXeMxoaGhoaGhoaGhoaGhr102IppCeffJI+ffowfPhwXn75ZRRF4dZbb2X9+vVs3bqVe+65R0sqHE00JWtjtEBMsgQb6lmmsLCQ6moHRUUSYFBVFTVlJA5Le/nnfufcWsuffupJjB4xDICVa9YRuv0rAL7d7iKnAsaNHc2/brqXpP5jmX7pvwEYPey4htsfUDXw0EuSVPjP9eex+IPH6d01mRUbdwHw2vUT6RaQVADolhRdM6+GREqgPrarJAx2z4P9y0SqwZdUSB4GPU5tmUlmrTaboMMgmT+4WUa2B4PTDt9dBfYSaD8QTnqyZUGRmooFxa//3hJMFu91Uf+1cdRjCoPwhNZXWgSOpvVhLZKgvkr9x8YnoaW6Rcv/sG1WwSEJvpM8rOVtq/FYaPlvXL5+B+1CHTjcKsOSdFz6QxUlVdArXsdlg0yc1VsChxsPSkJB75VCSoyWfd56+nGcPbobV0/px70f/867v2xDUeDxG89n37zXmDiiP4eK5Bh0S2nP/733Ayd1gQv6G1EVHYy/v+mkQkMUSv8nvmfz1vMdr6oyb1LI67VgifF6jngDnA3JG9V3Xw2PFzmm8AaM3uuT3AqGIyixpKpqgy+Px4OqqlitVlwuF/0HDMASGUe/ERPYnZFJaWkZERERdO7ciSmnziDEHE7moXKGjZvCuZdczmOPPUZSh2Q6JyVwqNJJlUtlwoTJ3H39pcQOOg2A49tXc9tN1wNw+b8uq7+RQ6+Ai77mUHUIXWN0LL/CwtW9KwPug4dTWlbOZ9/MAiApIYYbL54OnUbJlxlL8Hg8zP99I9NveY52J15DuxOv4cwXljFvYy5uTz3brZtUCKDSoTL1MxtL9rsJN8HLJ4dSYlepqHLXJOEBUmJMPH96exQF0gsd/Gd+Pn9kSNbi8z8yWbBhPy63h4FdE7nnnJEseeZC3r3lZAD6pybUliLz3VvaBVQxNBdftUJYYvDJCLcTvrlcnmEdBsLwa+VeF/gYc9j891Kn3Z8gCIur3Z8a+9ulpX1JQ0NDQ0NDQ0NDQ0NDo01occXCQw89hMVi4cILL+Tiiy9m8uTJ6HRtatnwl5OXl0dWVhbDhw8/0k1pexoajV13xF8Do/7i4+NrKhbAO0rVZCEnYhBdbPNhy9cw4NyA5eP4fcGPZGZls3zhXM46KFJAL61yEBkZwfTzLsPlqj1yO7lDO3an76N719TawRHAWuUiRFUwKCphRoVLzjyV//z7PBRFYf32dHLzi9HrFOzVTjLzy+mUGFmzbpjJP5JSVVVJUvQ+XRIJ2WvkJb8Kuk6ApEHBHtWmiU2Dwj0itbLifzD50caXV1X4+X4JTplj4cx3RMaiJfgCaiHhfv33lmC0HPOSLkFRdzQt+ANlDeV9DCESjKuukKoFc+2kF5V5knQwWiCiQ/3bCIZgKhYaQVVVNm9cz/GDYVuBhz3FKj+nSwKhvFpl1HtW8UEAlh5w00n1oPMOyXe4VExGaBdj4bpT+jNrZTovzd4IwNf3nMpZF54FwOfzlgPQLi6KKoeTD7+Zy/qr5NpWup8kVUItJVAKqTn47neKTs5TRAcJbNbFYZfzVHfUdH33zKYqX+qT3AqGo9BMff+BA2RnZ5OcnExiYiJWq5Xzzz8fi1n6yJy5c6iuriYtLY3+/foyZeo0ouLiSTJG4M7OJj4+nt9+W0pJaRH5RUW0i49l2/5C+ltiKS4uJUwfSlG1nrgQN9sXf8PZ5zi55uqrSE7xe81ce9PtlBQVUlxSQlFxMWX5Nl440cP5/YxckZrLwTdnEHXOq5jjD/enOffy69m8bQcA/bt3Yv7vm2hvMnMW4M7ZwKDTrmZrTmXN8h6Pm+/XZPP9mmwSIkMY3zuRcX0SGd+7HanGIsJKZVuV5mRKDmbiVqGsSmXWLhcfb3KQXqISboLrhpi4e0E1K7LcwHa6xBmZfVUq/TpIf7h2TBwzBkTx07ZyZm0tJzlS7uWfLt/PnA/20jEunA2vXk5ClFwHy7ZmA3DiwAAZMZdDnj3QysSC17i5OTJIK1+H3PVSfXfaKxAaAa4AzxnwJ2rt5VId5JNDqktj/amlfUlDQ0NDQ0NDQ0NDQ0OjTWhxYuGjjz7izDPPJCzsb6S33gibN2/mrLPO4pprrqFjx4507NixRduprq6mutpvMFxeXt5WTRSaU/ofDI0FqwL2lZiQQGLC4SNwld6nwaH5oqVsLYCwhFrfpyR3pHPJ74QYFFbnuFl7EFyucozGw+VM3vzoC9786AtSOnbg+BFDSGqXSLuEOEIcxTz/4Sw2XeohxqxwzYyxPHjnFbjdHrbsOcAp1z0OSGXCyf/5HoABqfGcNrwrecVWPl66l4kPXSft9SUsFB2kjgVLPOz5RSoCep4qUg/B4qqWY2Qv8Rpde18uuwRU2vWT7SYPgz0/i2RS/7Ohff+Gt7nla9jylbTvjDcgqmXXoeAdBRsSUVvC5W/An96PWkKANFgNRgs4qurvi74RueZYr39J4eHXV8VBmUZ0aJ1URyvNm1WPysneuOFHGx1klvlHUOdWqORWyHuDDnYXeUjFP1q7w7/e5/j+qVwxqQ/VLjcX/fcXVBWuPbkfZ43uRn5RGY+++TWvf/kzAKedMISte7J4fJyejpE61PB2KH1Ob1G7AfGvsBbIfHz35q3rO14h4Y33S5NZRlz7ApituQ/7AqWtkfQKkj+7H2VnZ2O328nOzia1c2dJKLjskkQzWejatSv9e3ejsvgQwwcPYP/+/SxavJiIiAjCwsKosleRn38IfWgEvbp3JSc7G0PVAYqKY0nu2p2oqCjyd6whjkMMSdLx6nff8e1339E+yV8N+ekXX+N2Vtdq1wXfws/pLl49JZT2pFP49sm8XTaMwdOvZ8zIYTWDIFwuv8zdzys28fOKTQAsvszC+FQD53R3klVu4V+nj+O6cybjcrl59913+HjZfgrKq/l6VRZfr8riqsFG3pkmyZQXV1Zz+8/b6z1eRh3YHPD8H45an+8rcnLGewdYc3s3YixSKZcYYeCKkbFcMTIWT2kWqB5MlgighIIyOw6nv+1bD8j1P6JnQHKycDd4nJLMbE3Sssa4OcjEQnEGLH1G5k96UnwVHHYIN9dJypn9vjS+980lGCk/DQ0NDQ0NDQ0NDQ0NjT+NFicWLrnkkpp5t9vtlcqprnfZTp2O7tHO6enpTJo0iYsvvpjbb78dvb62BI7H4wm6GuPpp5/m0UebGJXeGpoatdrcgFdjwSqftr61WGSS6vnHv/OoGag73kQ5tBW2/QDDr675zuVyceMd9/FQ1O8QqWOHeRgfvnkOF191A06nk+knT2TEkIHEREVyML+QpX+sZsWaDWTl5PH5dz8dti+7O5IYYNvOPSSMvYziMv9I0t5dk8nIygUkXrd5fyGb94v0kN7YiPlyYm+/oWWwMg8AeZvFk6FBMiWYH9FBpjFdoSQD/ngdZrxR/yoVefCb1+R5wgOQenzw7akPt9M/tRbW9gY4yvnT+1FDtCRgbI6s/3PfiFxzNJQe8PssBFKRJ9OIdi1qrn9frZNC0jnK6Rot859sdlFsV+kWozA+1cDxnfQ4PXDtT1W4PBAWArH4ZZ0cbpXZq/cxe/W+ms8uHNeTm6YO5MpXFvDpb29Q7ZBr8a5/nc6TN13AioU/cc0Q8SZQhvxLfA1aSr5X7iWqU/N/v+8c+6SknDYJgprqBkEtkuzzSa4cieqBxoKoDcgj/dn9KDk5uaZiwSfnk5W+i4M5WbTvmELPHgO4/85bweOiuKSMT76di81mZdvWbYwePRq73UZKp06Eh4ezf68LlysTt8eD2+Vh7fYMsrOyubV/Ir05xKPXnIF7cCwzP/2MgoKCmjZ07tyJPt27MmnCCQzo15e42Fji4mKw2ey8+8XbTCr6hr5xHm6xrOXsOy/gMlsHpp86hciIcCacMJpB/fpQUFRMQXY6BwvLcKseVtvCGM9B7jsxlnv+70lCzP7r6qXLhvDsRYNYvbeYpTvyOXQwj1cmyN8+b61zcPvP1eh1CkqAyYZHlZfTm48bmqTjgn5GzutrRB+TzKiX0kkvdHD+R5m8cmYSafEmDHpJPFXYnYR7PKDAqgzpd69cN4mO8f7n1f58SRh1bR/tPzmHtsq0Xd/WJS2LxBw66MTCwsfAVSUeRb1PD+hjXtmjw5Kz5pZVHLT1IAsNDQ0NDQ0NDQ0NDQ2NZtMq8+Z169Zx//3389tvv+FwOOpdRlGUwyRvjjY+//xzTjjhBF544QU8Hg9vvPEGBQUFGAwG7rnnnsMSDY1x3333cfvtt9e8Ly8vJyXlcAmGFtPUqNXmBryakhnwGToHmpjWWt9MgbkbiWz1azF7+eKbH3j7/U+47QYJJFx6nAXlrDPIyc3jnoefYNb8hcxZsJSiXauIjBAJF6vVxrJVa9myfTeHCoo4mF9A4cFsUpPiiTCtAmDrvkMUl0mERlEUThjSh7joCHZkZDNxYCe+uHsq89fv48fVGdiqXNx+9ij+r/6cl9CchIKPYOI0gean5mgooXF99LIcOXcR7UWTujVYC6SKBCA6xe8NEBjUqc+M+CjhT+9HDdHs/mP264Rbi2oHyXzfhXuTBpX5h68f4k1KlGbL9dLSAKDBLBU09lL//pqDziCeAqqbxZdaGPO+lb0lKntLnNx7fAhpsToKbSr3Lawm0gSPeZ4FoMoQyR/Pn8ZHi3fy8aId5JfZOXt0GkmxYQy740vsDrn3D+2bxhM3ns9JYwYB0K1iJehgfk4EJzdXvqguG2bKNKUFEnaV3ooRc7RMHXawFUBRJcR1qS2LFHhtHG0SLL6gbR3aqh/Vlabz0SU1ldTOnWt9ln2oCGe1k+xDRXTqqQOThcz0XezPziM2LhaTyUhySgoGg54hQ4YwaNAgAD6ZOZP0PbupLCkg2a2yfdt2XG4Xm/cVcmIviA0z8Pprr/LsM//HzM+/4ntvdzpwIJOMvXtY/NtyyvL21Xpe3/LgM3gq76b8o7OJtO6nd/tQvl2cxUtvvNfo731wP5zfMZxOUVZmf/wCzrQpjBvSm/gY6a8mg57jeyVwfK8EsHdEPfA7CnDRgBC2FOp5beXhxuu94iWZcEE/A93jAv6miDTy/RWdGf1yOr/sqqTX07sJMSikRBvJr3TxfxNNXD/URHqxh7wKD5ec2JdrThlYs7rHo1JYJs+Vcpv37zC3S7yDAJIa8S5qCrcT9i2V+Q4DglunTGSZ6DvDW+UT5pUSc8nfE84q/72x5rnUgn50FEqDaWhoaGhoaGhoaGho/NNocWJh48aNjB07FoPBwJQpU/jxxx8ZOHAg7du3Z/369RQUFDB+/Hg61wk6HI1kZWXRvbtIaIwaNYrQ0FCqq6s5ePAgH374Ib/++iudO3cOqnIhJCSEkJBGRsi3lrbW725s1J/P0LmB7e3atYuMjH10yM0lEUQCI4DRI4bRpUtnzvk6iz+uDCPswHKqFjzNXbc+wD0PPwHA0IH9iAj3B7UdTic6RUeYxUxifCwWcyh6ZwXfzl3Im3dK8uHmay7j+GGDSIiJJC46gvJKOx0mXAHAM5ePJT7KzMUT+nDxhD4AVLl1sCm4wxE07QeInnt1pfgnOKz+l9MmUkg++QlV9Y/67DW14W1GJsnUVozIGLVilOnK1+V8tB8A7QeJjjWqBHaMoRIwrRXYaUZi4S8YKfqn96P6cNrkpQLhkf7PfEm1+o6RTx6pJBOclWD0ehz4EjZhcRDplbPyVScE0mmUeGiUZUoFTMqIlrU9rhvkrJXrrCVeBSHh0GUs7PuNAe3h0F0RJL9QQUkVLD3gIi3WxN1jTKzMdnHXGCNdyaKIaP5vVThljk2YDHrOG9uD3bklfL8yA7dHkmoT+ifzxF3XMWpgD39wumAnHXUFVLtUdluGcnLLfrFQniOBT0UHw65q3rqqCrkbZT5R7hWYzJJU0OnAVlI7sRB4bz3aJFhM9cvIHIl+lNS5G9nZ2SQleyvBDGYyC624daF0796dUSNHAuLrEZiwGD96OLqqEvLyi3GoBqKjoyksKiRU8Ur+hEYDEB4ezr8uu5Tvn1tYa78Xn39OvYMAdKZQIk0KWOGBp/9H780VrNmwCafThcvlwuV243Q6cZUfxOXyYKuqZl9OPg8sOsQnM8yMjzxA2kMvUmhTiYkMQ3U7UFW5fDyqiqpC/0R4a2oIA9rpefUkPSd3tfD5FgcxoQpdonWc2MXAoPa6BhM0g5LNfH9FZx6ed4itB6uwOVT2Fjo4sYue64dKNc+Tq01cdfJA/nvVBMptDiLMJnQ6BZ1O4czRPfh6+S4ufPZH1oyYQkf7TjEkN8dAxyEtP5k5a2U7Ee0hZWRw67TrI/4KPgklq7dSSzGA4vQ/c+rzrGkOR1tyT0NDQ0NDQ0NDQ0ND4x9IixMLjz8uuvarVq2id+/e6HQ6ZsyYwcMPP4zdbueOO+7gm2++4f3332+zxv5ZqKrKpk2b+PLLL4mNjeXLL7/EYDBQUVHBmWeeyVlnncXatWv/HubUzQ14NTXqr0bGwCaRFO8/8aqqkpGxD5vNhkPvDbi6qmqt2rVLZ7asXMyjT/+Xq356h8/PDCV088fkmvx6z4P69eL2h5/mYH4h6zdvY3f6/nqbOTRJjr3bFMm15/j12FVV5Y0v51PtcNI/NZ7BaYnB//bWYgiVV1NBeWsBVJfLsj1PaXi58EQZNe52yOj2iPYta5e1ANZ+KPN9ZkB5tpj66o0yot0c7Q2OtjCwc6yOFHXYRJJHZ6h93fvkwKI7NnyuA02cfQkbW5EE1Xzr+PwUAjGFycjeTZ/Dug/bJrHQUiI7QucxsH8ZFqPC3IssjHrPxm8H3FxxHOgUhS/OthBqUKjEwgO6e3n359sO07cHGNevI7dPP47ThnVB1zUg0aGqVG/8hhDgnfVOpt00ueXtBdi7QKYdh0BMavPWLdkHVaVyzsO8VR5Gi1Qq2ErAUsdo+2hLJgTyZ7SrJQlEl53UhHBSOw6WKhovycnJHMrOoGOspdY9Rw2o6kpuH8/4sWP4/Y9VhCWkkJCQQFFRIZ3yvwOKahILAM//90VARtDHxMTw2vNPcvLkE5k9Zx6/LlrCpi3bOHgon5SOSQzp05VnEvejAKHJA7mwZzwXnnNGzbbKyspZv3kraxf/yMZd+4mPjuDy6eMZ0juVkjUvEhNSxCunx3LhF0WUlB9eiQCwMgsmfarw1hmxTO9SxWndDZzWvXl/Xp3UO4KTekfg8ajsK3aQV+pgRGwp4MGKhTEjBzF3TQapl79JcUUVOp1CTHgoseGhGA3yfMwrruTkax5h/XWRGAG6TZL7WUvJWCLTvmeCLsjKzXb9ZOozfVZdklQIi5NrqjRX/laISqrfKD1Yjub+qKGhoaGhoaGhoaGh8Q+hxf9xLl++nNNPP53evXvXfOYLEpjNZl599VVWrFjB/fffz2effdb6lv4J+EZMXnzxxdx33328/PLL9OvXj8jISDweDxaLhRdffJGzzz6btWvXMnTo0CPd5LYnmFF/lYXgqJTgtHc5xVVFt6QY9mVX07n3cbB+sV8SJgCLxcIzjz/Eymmn8uzTZ3L3mBAS171I/0QdW/I9vPnRF4etk5baif69exAZEU54mIVwxc4lg0KhaA76SAm2Z+UV8sOiVXw5fzm/b9gJwJWT+zU4IvSIUpQu0x4nNS67pDNIcqEiD8qyWp5Y8FUrxPeQl70cLAlSqaAYZOobgd8SCaRjdaRofb8rUA6sscoOS5w30OUNpjrtMtLXVuwPsNZXsQAw+FJJLGQskWB3TJfmt91nCl2SAR538EHAukT7/XBGJht4bnIId/1aTecohUfGhxBqUPCo8LD+TvYpnXj0wpGormqcbg8Opxu9XseZo9IaTPC5s9YRUr6PapfKotIUbkxupbfEnl9l2q0FCYrcDTKN6yb3N9/IapO5eQHPY1XrvbEEYsBvVgK/a2CdLqmpdEkIb1D6JjMzi7ysdDomxDL6hInkFZaQkpzM3r176ReZDEUZNXJVHo+HF196maE3i5zROWeezqtvvctFV1x7mOzinr3pVOz5HeXqcA5Vepgw8VxOGDWC1E7JbNq6g3WbtrAnvbaEH8CHs5diCQ3hzqndebRfEef3cnPST09wyGlGSV+ETgcKSq1pxxiLBPirKyBvk/T/FqDTKaTGmohwl2JUPORUqPT830Gszvm1lvN4VIrK7RSV137uWmzZGMvD5HnSdXyL2gDI78heK/N9zwx+vcS+Mj20TfqSz7PEh71EKoKsxa1LLGhoaGhoaGhoaGhoaGgccVqcWCgrK6NrV7+Zn9FopLLSb6ar0+kYP348n3/+eeta+CfiC0L36dOH7t2789lnnxERIYFfX3WC2WwmPDwci+UYChgFEsyov8DR2A6bBIYcNrqndeHQoYNs3riH9lBvYsGHy+XivoXVDEsJYUInB0uubc+N69IIjUqg2uGkuKSUSSeM5l/nzyAu1j9SuKy8goce/g/rVm+kXxos2JLHPW/cwfrtGTXLmIwG7vzXdG447S/Q4G8uLocY90JwwZnIjhKALs2C5GHN319gtcKwqyWREdEOohoZbd9cjpWRooEBYag/OGy0SKVCcyo7TBZ5OW1gCIHwBPm8ocRCTBcJAGYsgfWfwMSHm/9bIpOkrU6baJzHtI0E3Z2jQ7A5ISJE7pduj8qv+xW2de8FwB1nDCZU725w/dLKan78cSk/Ll1H+v4DfHdqOZ2jdDy3wsF1l53XusbZiiBnncx3m9j89X2JhXYDIDRSqhTMkRIIbcuqr78rDSUQnTYoyZJkG/h/s68/KcjxrJtwaaRCKj09nbLyMmwOmDD+BJI6qygKxEaEEfHzu7KQN7Gg0+l4/rln+CJLPn77vY9qqma6pXVlysTxjB4xnKQO7TmQmYVx21fAJjYd8rBj11527Dq8qie1UwpDeiQxuHcXCksq+G7Rag7kFvDYt1sZYjRzek8ju+e+xhznKKrz0qlyeqh2ualyuKl2eah2elBR0esU9IqCQQ+ntXdwdh8jJr1CtUtlXa6bajd0jdGRHKmg18mD1eVW2XGomnVZdtZl21mfbSfa4GDOhXJcL/nOhtUJw3t0YOrwNKYMTqV/agIVNgdFFXZyiio584nvsVY5GdytHbcMFCPnnJAedAyNatm5BziwQq7rxN7yCpZ23sRCWZZ4NNTyKbFDaARUVUBYrPczW4DXj8X//lhL1GloaGhoaGhoaGhoaByDtDixkJiYSElJSc379u3bs2fPnlrLVFVVYbM1YlZ7FKCqKvHx8Tz66KOUl5czb948rr/+et544w2Ki4v54YcfCA0NJSEh4c9vTLCj7QNNgduShsx8faOxDaEyqtdZKZI9RjO7d+0iyek1jHTaQfXUkqzwMWfhMjwqXPOLkVVXhBKrq+Cp4SWc9Ekmu9Ml8D5/0TJWbdzGf594mOSOHfhp/gLu/s+T7Ny9l3emhQImlu0qYP12B4qiMGZAGjPGH8c5k4aS0i4WIpPr/10uFTaJ2TNpJ0J5enDHI2D0dqOERjb83d6FoLolYdC+f9PbikyCHCQZ4WnC9NwYevhnq97yeyv0ni4jRVtiTt0YR2NVSEsIDAhDw8HhYCo7AuWPfH3I129Ub+DdJ4VUX6XHiOsksbDtOxh/rwRRm5PIAIjvLiOlSw9Au3oCgT6JkqYYeL5MC3ZD7noeHufX6L/shyq+2Klj4kPy/oz/LuHEQV3p3aUD3ZIT6RAfxe7MQ2zek83SDbv5asFaHE65jp84MYTOUSFklqlUpp3GlMmTau/X7Qiufb7rfv8yQJV+FZcW3LqB+PwVuh4vfcT3M00W8Wzw0VRFgi8YCmAtbPuAaDD97c/okw1d9w6bJBVcToioU61gCJASsxbW7lO+hFtNk/1tjomJxmazEhsRilKWy9w5P/HHhp0MGzyAM3znJSRa/E+AC847jy+eF4+FaadN5aSJ45gyaSJdu9ZT7TNrHWzdxNip5/HDpEH89sc6cg7mM6BPD4YO7Mvg/r2Jj4sRA3Uv/31AZf22vXz7y++8sWopp3a3MjLByr0fzmLpgYYTaYF8DjyyxMF7p4cytrOB0Z0MpBd72HzIzaxdKiVOEyWuEJbu3snOAhdV3tt9uAm2XC9eLfMzQ7jklP58flwy7brVfn6ERUN74IeZS7BWOQE4sV8Hzu4tCf7bZ+Xx5b8aqX4yNfFcyFwp074z/PewxvD9XRIaBVHJkuA8sAK6nODvD8ZQqcoL91Y0Oe2He/343lsL/deNlmDQ0NDQ0NDQ0NDQ0NA4KmlxYqFPnz7s2rWr5v2YMWP44YcfWLlyJSNHjmTHjh189dVX9OrVq00a2lpcLheqqmI0Gms+85kxezweOnfuzCuvvMIrr7zCzJkz+eKLL+jatSs5OTnMmzfvr0ksHGnq/oMfmGgIi5fgQrlX4sUsow0Hd4mlYqcBbBzmsRBIpxQJ0u/NKWL8Wzr+uDKMVFMmV3Sp5sn8cEYNG8KCJcv4+oefmPPLQnp178b6TVsAiIsKZ3L/OKCESePG0mdKGuMH96RdXCMB/aMBVRVjWZDgSjDBP5+Bc1lW8/dnLYA1Ig/C2DvaNtgYGFxtq8qHI43JIjJfznJQVJEsCm/GNVXrmHiDyy6Hvw+FxXmD1N7zYCsC1+F+BICYOCf2hfxtsHEmjLqx+b8nvqckFgp3Qc9WWSILCT3ktxzcDMCSknZEdTRyotFfmbRg1XZ+Xr6h0c306Z7KNacM5qaYxYCb5Gn38X+po1vfvt1eaZjuJzV/XbcDDm6V+U5j5P4G/nMKtX02mvKhqS+QfqziSw5EeO8FvoBy3QqHxiTTHDZJUiuAJY4eXTqREheG2Qg4K9m1dQPVtmrWrN/MGWleSSFvxUJdPv/kQ0JNjUh/FUqFgrljX6b3OJHpJ5/Y5E9UFIUh/bozpF93VPUyihe+RFzBSj4+vx3/y+5HSIiJEKOBEJPROzWgKAoej4rb48Ht9uCpzMftUVnmcpGXmc20pELSYnWkxQZ6NVXDeDk+BTYod5uIMhuIN9hQjRZOnjIJ9I3/mearfAAIK9mBSR/C75kuMh2tqFYozxEDZhToc0bz10/sK4mF/B1SeVeflJbe5L8+6rtufPfSJqS4jum+pqGhoaGhoaGhoaGhcZTT4sTC1KlTue2228jLy6NDhw7cc889fP/994wZM4bY2FhKSkrweDzcf//9bdneFrF9+3YeffRRcnNz6datG1OmTOGCCy5Ap9PhdrvR6/V4PB6Sk5N55JFHuO2225g7dy5JSUn06dOHzp3bRlbkqKeuVIXTXtu41qfNr0ahGs1gK6FDh47E2JJhJ40mFq6/7hqmTJ7Ib8uWs2z57zy4ZjEvjinjnjEh3PLw04QOmM6mLdu58e4HWf7HatZv2oLZHMrN117B3VN7ELvuRbDD2NEjILYFGvRHgpJ9ElzRGaHzqODWqUksZDe+XH2seFWqFToMhLhe4KiQz9uiYiEwuHqsJBZ8o2EdlTISur4gldMmyQcFCT43pCcfFi8BVqc3IBYW4Zf0MIRKEM3tgMpDYK5jCgySfBh+Ffx0G6z7CIZf0/zfk+A1SS7cLW1pi8RSuz4QEg4ojB+YwvjxUOXRM327fP30DWexZssu9mYXsCfrEJW2atrFRjKgezIDuiVzzsQhjDhhCix8BHLdkDQYXbB9oTGqy2U0NECPFiRRDm0Hd7WMrvaNnob6kwgmb9LA5QAK/Z8dVtkSsJzpGE4uNFTJUFcirTHJNKddKt+8y4UZISwmSvqICvFJndmZu4WBvbtCtVQm0BJZH9XjNzSP69789ZEkQ9zxV8CPm+gUWslzZ3eD5CD8lopqV3DirAJrPh57GdbSQqorSzA4K4hQ7Ohxk2CBBByAVO4oSYObTCoA3HvhOM4e14+V2/YzTbcEcGMZfglLHmnBPcTHzjkyTRneMq+fdn1hz89yLwqsvPJVNapIZUuNTFY9143J1nhi6p+QxNPQ0NDQ0NDQ0NDQ0DjKaXFi4brrruPcc88lJkaCZAMHDmThwoU8+eSTZGRkMGTIEG666SamTp3aZo1tCbt372b06NFMmzaNyZMns3DhQp577jl++eUXPvjgA/R6PQ6HA5PJBIjZsMVi4corrzyi7W4RrR3FVzdgZDRLUgEXlOZAVJJUKhjMYrvgtJNfUoqij/XvvxHS0tJIS0vj8n9dJh/MuxfWvU/o0segQy8G9u/Db3O/5cvvZrNtx26uv/ISkjq0h50/gr1U1rE00+zxz5KNCoZ9v8k0eagYXwdDSxML1gJY+77Mj7wRjEZwuSCsHrmklnCsGTY7rP6R6SHh/sTCYcvZJPEAhwfA6h4Tp10SCL6AmbVIgl+uKgnOlWaKz0J9iQWA3tNgydOSfNjxE3Qa2bzfFNMF9EZJBlbk+a+l1tKIJNhN555I6IUTAJGVs9qrCbfUueayVoqfgc4gCZO2SHikL5YgdGxXiO/W/PV9Mkjt+tU25a7vOvedd49Lzqk5qv6AZuByjQU8j8Xqn+ZiNIMxXBJ2gYnskAgwhJLUcyind+5LaKgZ1pfK9/VI7DVJaZYcb50xeGm7+giNgj7TYfMXsPMn6DBA+npzMIZCdCd00RDRAWrSvWW5ci07rOC0yjQkonbCqwm6dYyjm+Eg7HRDWDzHnX5dUEmJelFVf2Kh12kt24bPwLlor9/7xefBpDNIZVhTf6P4+pPTdrjE2LH2PNLQ0NDQ0NDQ0NDQ0Pib0uLEgtFopF27drU+Gz16NHPmzGl1o9oKVVX5+OOPmTx5Mp988gkAd955Jx988AFvvfUW5513Hl9++WVNUuGDDz5g0qRJpKQchSbAwdDWo/hMYVKpUJojmtq2Ym9AyFvZEBJJbOe+lO21yvLVlc0L5B9/GxTshMwV8OPNcOHXKKGRnH/W9NrL2UsBVXTPm9KdV1UozhD99QMrxP9g3MPAXxzAq8iDzFUy32Vc8OuFeYNJ5TkysjNQ670x/nhNAjAdBkKPk0Ryx4SMktXpW389HCuGzT58fUVnaDzgaLJIUkjh8CDWYSNtAyp+HDbpL84qkXCxxEtioTQLEvvUvy+9CQb/C357Fla8Ip4JzUmk6Q0QmyZ9aut3MOhCsMQGv34rURTl8KSCqxrWeM13+57ZNskO1QObv5b5llQrAOR6TZ87DKw/iVAXXyDTZ0TbUEAzmIDnsVj901zq+C3U4B3Rnpramf37D5DaqSPKSqt/neaSv0OmUcktD7T76DkV9v4qkmbrP4F+ZzUoz9QsFEVM3g0hQAv7q8cFWatlvu+ZrfutBTuk2k4fAmktMEUHSPBKYObvkGeyvUQStKZwud/WlyxoiPr+rjnWnkcaGhoaGhoaGhoaGhp/U4KMWv49URSFnJwcDh48WPOZxWLhiiuu4JZbbmHPnj3cd999AKxYsYKnnnqK+++/H7c7OHPGow6TxT9aus226U0u6Aze4ECFP3iqM9Cxczf6DD9R/smvPCSjOYNFp4epz4uxcVkW/PpQ/YmJ0EiRk1E9MmJU9Ry+jK0Ytn0Pc2+HX+6H3fOgugzKsjCufBldMOaTbUV5Hix9VqRWYrpIgDhYdsyWaWRHJJodBE47bJgp86NvlmCuz+A20Jy4wfW9QZ4mKk6OKYLtK0YLxHSSYFhTgSyTxZ9csBWB6pJX+UFI9Jopr/+o8W0cdzGEJUhy7Ltrmu+10XmMTLNXw5zbYNkLUi3gOUL3tL0LpZomLAH6n9M221zyDBxYLqPQ+85o/voeF6Qvkvm0CU2f18AKg7D4wyWxAjFaGv8e/pz79N8Rn8+C7/4U4PHTrVs3oqKiWLlqDVVmrxSPryKrOUR1lGnJPsha1br2Gkww+DJAgUNbpLooffGR61uB+PqZIQT6nN66be1bJtPU470yaC3A93dAWLzI8/ke675pYLKgKbT+ouElMzOT9evXs2PHjjbZ3o4dO8jMzGyTbWloaGhoaGhoaGj8UzlmEwuqN0A9ePBg3G43O3furPnObDZzzjnnMHnyZBYvXkxJSQmjR4/m7rvv5rHHHkOvb8QI8mgmmKBWSzCFScDUYBS9eUAxmVHCYmUa0R4GnC/LLnwc3M7gtx0aDVNfkMDB3l9h02eHL6M3wZDLZPR+7kbY5TVtdVZJsOiP12Hxk5J0KM8VOZhOo2H4dWAIQZ+/lavVerbbFqgeGYWesRTWfgC/PAS/PCgG11HJcPwtwUu/lBwQfX2ACfcHv96O2ZL0iUoRI1qPS46NMTS4gExzgjzHCqaw4PtKcxIvvuCoirfSwQDmcOh/vlzH+5fDgT8aXt8cDRd/K4mM8hxJLuQ3I4jSdRyMuUVGDKsq5G2E5S/CnNthz69ynfxVVBbAviUyP+wq74jsVrJ9Nqx+S+ZPfbZ5STsfB1ZIItIcK4bXTZ3XxvpHS5Jyvvv0P7VawUdAIgGoSVZjNKMoCjt37qCispJVYZPl+z9ehaL05u2jfX+pLABY/BRUlbeuzSkjYOztEN1ZEsc7ZsFvzzW/XW1J3mYxbQfoNa1hqbVgyfR6l/iSlM2lPBdWvCzzI/8NZXneLwz+hHdzkgWt/bvG10cd1patr3FUkJmZSe/evRkyZAgXX3wxFouF+Pj4Fm/PbLFw8cUX07t3by25oKGhoaGhoaGhodEKjtnEguINyp566qns2bOHZ599loqKiprvIyMjufXWW1mzZg2LFsno1auvvpouXf4mxsB/Fg7r4f+EO6wS/HG5IDxe5q3F4PAGhExmcrqcjdMYCcXpsOGT5u2zfX844S6ZX/oMHNx6+DLxPWDAuTKfvhBWvQkL/gObv5J9gug6j7gOZrwtwdW0CeI3AJypzmOyZ2nz2lUf9lIJ4uyYDSv+B/PvlXas/0jkl8pzABXiusEJd0JIZHDbVVWpcvA4RTqp+0nBt2ntBzIdfKlUgVRVNL58XeoL8vwTqxgaorIQKvNrkmqNHhtfcDQsDqJTID5N5K2SB8Nxl8gyv7/U+P5iUuGS78WM2V4CP/zbL6sVDB2HSGLq5P+DHqeIXru9BDIWSRB03QdwaOufO9JaVWH797KPpMGQ0ky/iPrIWuUPWB5/W8uqFUCSEwDdJgJK0wm1xoKgwSbltP50OEaz11vAVu/x69WrN+Hh4UT0n4ra+XhZ9ud7m++bM/LfkqizFsr131rfnagUeb4MvECSQ5UHYeVrft+Ov5LyPEkYglQYxHVt3faqKyVRAc33ePGx+Am5zjsOhS4ngsEgie7QCP8ywSYL2qLf/BMT58cghYWF2Gw2Zs6cybp169ixYwedOrXcN2X9uvXMnDkTm81GYWFhG7ZUQ0NDQ0NDQ0ND459FK0WHj37S0tL46quvOOWUU7BYLDzyyCM1o5xMJhPHHXcccXHNNAQ+mqlr4NxcQ2enXcxfrcUigQR+jwVLNBjMIm0QONLUaSevuJzq5DPouu9j+O156H9u82QUBl0M2Wtg7wIZXX3RNyKBFEjyMBlpvOcXKNwjn4W3k0Bqx8HQrv/h200ZjqvPWRi2f8vN6nuoRclgbEE+rTwXNn1evzSNIUQkj2K7+l/N1d7OWCwjRXVGmPRo8NUKB7fKcdMZ4LiL5DNfAMdZFZznRqBete96cdpkhH1b+XX8nVHqTBvzMqmrHR/4/vhbJemW+YdULXQe1fA+wxJg+uuSuMpeIxJfEx6EnqcE3+7IJBh0AfQ/G3LWwe6fJQlXuFtepnAJ+ncYKG6ybWGq7OPQVijYJYmutjBsLtoLCx+VCqF+Z4nkV0vwuEQmDcSfobqyad+WxvTcgzWRbWv/m2MBk8VftWAtEpNzvRFUD4rRwojhwxkxfLjIirW/VeS90hfBrjnQtRneGsZQmPgwfH+trJ86FnpMaV3bFZ1UL7TrD1u/FrmxDR/Ld0mDWrftYHFYYfsPoLolkd2pkftJsGSvke1Fd5aKu+aSux42fynzJz8N0Ulec3Tv9031NR9t+RzSjJ6PKXr37s3gwYNbvZ2UlGQqynq3QYs0NDQ0NDQ0NDQ0/tkc84kFgAkTJvD1119zzjnnkJubyznnnMOAAQP45JNPyM7OJi0t7Ug3se2oG8BqbkDLaJakgsHoTxwYjOByQlQCmMxSqWArltH1LjvojHSIi+agZwrOwsUYK7JEtmL8vcG3W1Fg8hMi+1KeDb8+DKe9eHhAsvsUCT5VV0LH4yAyucmgpavPWazafoAxrEVd8QKMuObwpEVDqB7Y9xvs/NE7wluRIGxMZwm+RHeGhO7BmyzXh9MuI2lBJJ9im1E1s85brdBrKpgiwFYiAXBfUsdZ1byAiu96UdF0rX34Rtb6jkVjgSqHze9BUvf7qGSpWlj7nlQtNJZYABkNPfUFWPS4JNMWPgq2QknCNSdQrzfK6OOolP9n77zj2yqv//+WLcmWPOLEziQJIwPCCgkbyt57lDAKFAqle1C6oKVfSgcUun5QoIVCoWWVUVr23ntvQhIgkB1iO4ljSbZkW78/jh7fq+sr6UqWbNk+79dLL62re59773Puo3vOcz5HnLTLXpVAQ7wdPn1GHjXjYOK2MGG29/VmoqsTPrhbXm+2T/8LNrevgYfPk+M6aY44LAsNVBgZpPAYCVR6rWOSCa9FZNW56Y6pSeKLSz/tTrg7n5s2k2D1WzfBIz+HM/fMbzvjZsH2X5FC4s/+ESbNlqB0fwmGxaYr/GJX/Q0uJHukyHvHennd++iWTLmeLnnd0y0TAOLtIum1xWHFCQwaGaRCghTJJDz8c3m99XEix2auhfkGBYo5DhkbLWbgVFEURVEURVEURQFGSGAB4IgjjuCFF17gnHPO4dxzz8Xv9xMIBHjwwQeZMmXKYDcvP7LdIDsdWPk6tII1MHpy39/U2RxoVbUyu7SnC7rEITRp4iQmTdkE6s+Fe74tUkU7fAXqJmTelnNWf6gBjv07/Oso+OgRkVLZ4QyYtm/6ctP3c19fZwYJoEQPv6/4Jhv1XMAmHcvg3TtFKqYy6L68obpenLrLXpP3m3wB9j5PnJJ2/NXZ12PIpKn+8tWwYRXUTYLdvpu7XYZ4VPYFYLuTxaHrD4ojpiqVtVBVl/n3mYitFymfmsL1iwFvkiP9lSXpzzq9ZvM4ncf290YmLBCSRzwqjr941N1BuvPXrayF5W/AJll0zM2M4S9eC0/8Bl65Bl68Ugo7H/oHqB4l33vtf6NTAastj4LuLvjsealrsuRFiHwu2UIfPQaNM6RWwyZ7uPeBRBI+SGnV147vO4q8c7tIL4UbYfaX5NkLbteKeLtIQUWaZVb2F/8hmRZeqAj0/Wx+qqjsFofL9SafwJtXx6Rb/3MLQCST3vrgsHGIuuxHsEYe9uPg7M/BMETXifTQR4/A+mX4X7oc2FG+r/BLZkwm6lKBrb1+KtfylW/BkxdLX7Jn1VV4vO4au7Oz3y+llsnHj0lwYdRGYkdemHOK9IVPnoaXrsqvYHuwRiTPGmySMH6PWQGVLvaxJFX/ZdM9rO+9rm/+/ySrJBAWqbKuTgmKRNdCsNM92JoJ87+ltj53LZJSjCGKoiiKoiiKoiiKJ0ZMYAGkkPM999xDa2sr7e3tTJgwoV/F38oS46gBueH2OqPWjpsjtc92TMBCupDPOAy2OhreuEFmbz59iWQd5MOk7WC/X0jGwuO/EpmjbMEJj8R8IX5Z8UOu9/8fvtaPZab/jlkkWpa+LHUTOjeIo2v374tDtthOvtbFMoMdYN+feZeKAHj3DnG8NmwC9RtLJkkiBjW2wIfd8Z3JQWOWMecw5OI4Gy7YHZjFkKexF6ANhKyMnmCG81g9WqR83r5VslSyBRYMvgqRcmmYCo9dCAsehNXvi1RSoTOjK/0SPNhsL8n++fRZCTIsfwNaFsnj1etg/NayzNRdvBWF3bBSpGpAZnL3p2BzTxfc8z1YM1+CE1+8znumUab1LXhAXm+WClaGx4hjerBQiSTBPuYke1y+r4bwWNjrPLj/B1S+fCWTkhezwjfR+zYq/JIB9M/DZXy6+Tg49pp0p3yhVFSKMx0kuPDUxTDny97sc9W7Uq9n1bvyPjRaZLoCYXHu+4MSbO7ukveVQQmaVQYkeNEfm7CzbqlkS1T4YfJO+f02EYNHL5DXc06VgKM9G8VcI70GFgJhLW6uKIqiKIqiKIoyBBhRgQWQos319UW6ER9q5FtvIRvGERRpFqdBhd+a3bz3uXDTF+GtW2Cnr8O4LfJb9w5nigb9wgdFF/uEmwqbee9gpW88iX0uIPjIj+HT58QhP9NRJDkRgzf+BZ89J+/HzYL9f1kc55OTZFIyIroTMjt8+gH5/fa1f8jrLY+BQFDaHnL0bbuGebRFpCVqGtOdNmYZu8N9uEq22B25xdhX4zwzAaFcgbxgSGzivf9IxsCnz3sLLgBsfzpM3A7u/pY4AG88RoJwWxzRv4BXVa3Ubtj8EMk0WPAgLH4aPv8AVr8rjxevEGdh0+ZUjpnBlsnJfMwmWOLpSJ98419yfCdsK8VbCyXZI47KxU9LYO/Yvxem+W7n0+fFBqpHwfgtJVvBU90Z23Wz2M7O4W5vhZKIWgG6aCsk2iVTZe6X4cN78X38BN/mn/y84qf5rXfMpjKe/Pcb0LxAsuOO/Itko/UXZ3AhlyxSZI1k0Kx6W977qyQrY84p7v0str7/bcyGkUGaODu/+kggmRZtyyU7ZOdvymemTyeiktlYU2e9L9b/EEVRFEVRFEVRFGVQ6YcwvDLksDtVi0mszXqdiELdZNFWT/aI4zxffD44/E+iCb9uiczSLpLcQc9GO4g8C8Dbt0iRWcOaBfDIzySo4POJI/eYIs1odWPRIxLgqAyIgzgf5/Dy16Xt/mrY6UwJvNSkZl/bsx4CIXHqdKyVIFC8XRzh8Ygc27VLZDmjYx0IWzUFhiPBcHH3NVgj63A6AhNRCeYkounvASZsZRXaNrU1vDJpO/jKgxIE6ElIZs8DP4LOtpw/9URoNMw6HA79PRx3vejSj0nVoGlfDZ8+Q+CN6/hzz4X8t+dMgo/9TDIbPnlKMh5WvSPHd+5phQc74lG4+zvwzr8Bn8wyn1iE2g8f/E+ep+0HPUmZBW9IRMU+Ei7XxlJdN2H421uhxGMpSbGYBENBnn0+OPgSkpVBduAdduO1/Nc9aQ58+R7pUx3r4I7TJEhbjDHGBBem7S/j35v/ghVvpS8Tb5fA4lMXp4IKPpHm+tLtIpU2WDP1P0sFFjb2GOg0tK2EFy6X13v9FLrj1neJmGRY2IvYl9KeFEVRFEVRFEVRlAFFAwsjCbtT1Y1szrVs2GfJtzdDIgLbnwG+SnGeL3w4/7ZWj4JjrhbJh48fhw/vz38dmZhxkMxQTfbITOx1S2T2+FO/lf2vGQv7nC9OnsoSJfV0tMGTF8nrHb8KozfJ7/cmW2Hzw2Qmd02T9bA7poI1cr6r6sXpFay1Ztl3touTC0aOc7NYjtx4JBWoiWT4PuUYjbSmskVaLUcpwG7fF4fbZ8/3dTzmonqUBLwO+JVlH7d/OXNbCqV2HGxzHBx5uTg9D/wtzD2N7sm70EIDlfRQsf4z+OQJePXvIh0GUki2UPmyni74zxmw6GE5Pof+oW9WUSEsfsYqKD3zYBg1Mb0POJ2d9mthruumkj+5xppgSMaPYEgCpuGxct2KtED9RLrnfAWA7/dcS+Ub/5CaP/lQNx5Ouk1kyUwA3DjH+4sJLkze0QoutHws33Wsh6d+J9JjyR4YOwtO+Bfs+3Oxt8Fiw0pbYGG3/H775G/kPE7ZCTY/NF2aKRDqG+weaHsyfa3Y10dFURRFURRFURRFAwsjilxO1UJmEjqdBD5kFv3EbWHHM+Wz/34DPv8w//ZO2g52+Ya8NtJExcDnk5nYjdPF2fDUxeIYTSZh6m7iQG2aWbztOUkm4eHzxJkzagrs/I38fr/8dSlsDTD31NzLB0KS0dA4HUZPlWBDICRyFybQoORHIib1N1oWSdaH02llHKM+JHgTXSczeYOpoE5FwAoA5RvIA+nDO5wBp/5XAmFrP4Xn/1//9ikbwRqxx22PJ7HX+Xyp4kpOrvgL8V3OltnW42aJ3TdsDLOOKnw7r14r+vfBWjj+RqnZ0h86N0hGx03HSlZH4wwJKjqvgc7rmLP2gVtWipKZXIGDXGNNICySbUZaLBiSIsDxdojH6NrtbBYzhQY2EHj0Z3DFTpI5k0+AwV8Fh/xegsgAb90E792V335moqJSZI0mzZEAwrt3QE+3ZKjF2yHcBLt8S4LXjdOLs81C2bASbj9N2jVmM6mr4pXlb8C7t8vrgy627MiMKcHUebTb1UDLIGmGhKIoiqIoiqIoSskYcTUWlAwY3WMf+RWDdGrK1zRBZZU4gva/QApSLnkRbj8Vznoyf+3mKbsAf4E1C/P7XS4qg7DHj6TA9NrF8tnkHcXR4ytxvO3NG2HRo+JcPuL/5efYT/bAIz+X11sfJ23OhSnobWbZm0LO6ijNjJsOuL0QdiAk2Qg9PVbWhyneDJY+fDAks5V7uq3PWxfDyreknkG4UWb6Fsqk7eDA30gtknfvkDod/VmfV3w+mmmkZ6MxsHGqDyaT/av10LwQnr9MXu/3C5jcjxoNIFkK934f1i+V91sdC7t+1/0a5LyO2WsflLLGwnAlV1Fqr7UlElGxs461IhnXBdSGIBDkuxW/4aDkU3yn5iF8G1bCQ+dKcOH0e8WuvODzSQC8KwbP/hGeuRRGbQRTds57l/uuuwK2nif9un0VfPIkLH1Jvtvi8NIGr71iggrrl0qQ+9i/S1DEC8kkPJoKymz9Rdhorry2BxF6i9qbeguxdCf/QAQZtI6JoiiKoiiKoihKydCMBUWIR8EfzF18NhNmhiqIdEUgJM77edeLVM/aT+HxX+W/3vFbyvO6z8QpUUyCNaIJvdH2Umh2pwEIKqx8B566RF7v/VOYsE1+v3/737DybclAOOii/BydxqmT6TgWKoU1HHGb5Wo/fsEaaNgoNZO9VgJyRurIrg8fCEP1aPk+ug5aPoH4BilMDiIbVNHP+O6UnWGbefL68V8O3szc/gQVerrgwZ9IVsdm+8BWXyx8XZ3t8OC5kqWwfqkUnT7ictjzp9A0zdv1zZ7dpTOec+O8duSSu/EqSRaPSeHmnm7ADw2Ten+T8AW4r+IAOr/+EhxyiWTutCyCO76SrvPvhV2+LTI+yW4JULQuzu/3mQiGpbg6iJxf5waRpcv3ul8KnEGFeTdA/STvv//gf5JdFAjDfr/s+73beGOkkYIZ7KoUY5BmHCmKoiiKoiiKopQMDSwoQn91jzM538KNcERqFvLr18PiZ/Nbb804CI2RmfpGp7qYBGtg97Nh9++LNEYp6WiDe8+WorszDoQ5HmSM0n6/Hp5K1WXY44d9Nblz6f676V2n/V4dqL242YPz+AVrpLD36KnSz40mvF0fHlKBtlqorktJhQVFQgRgy37IBtnZ/WyomwhtK+D5PxdnnQPJWzdLdlNVPRz028KDFJ8+B9fuK7r2IE7dL/4DJu8M4dEip7N+ef6OS3uBeq+MpECd89pRzKLUXYmUrU1yX5+/SmTBTrlLgnxLXoQHf5pfMWafD/b5uRR0jrfD/T+A2Lr+tx0kg6hhY3qrUE/dxXtWQKnYsKp/QYVEFB6/UF7v9j33miqBkAR4jPwRpKSRUv3C7RqrY5CiKIqiKIqiKMqQQgMLitBfR1C2wMSme8KcU+T1fWdb0jFe8Plg7ObyunlBYW0rB0xdhbZlksFx0EX5O0+f/QNEW0QnfvszrM9NQCHamj0jIViTfeZmsYtqlqNj1Wub3OzBfvwizfD5QitLJ1iTrglvXieiqcyFanGQ1k2E9jXQuV6CEfkWSs1EsAb2/6W8fvcOWPpKcdY7ELR+YhUj3+//JMMgX0yWwi3Hw/plUDcJ5v0TDrhQpI8C1RBrhQ0rxIYSHXJuoq3e+mcoD3k4QzwqdR3WLi0vGygFJbl2tIhEUd14CS5nG5sSMQlCH/onyTp78yZ45er8tlkZlJoL9RtB23J48Mf5Zz644auQIuj45PXUXfu/zv6wYRXc9bXCgwoAL/1VjlH9ZKkV4YaROPIH3cck12usFkpXFEVRFEVRFEUZSmiNhXLCbYalm9Z7fyRHCsWtHV6+Mxx0MXz0BKxbAo//Bg77o6U7n4txs2QWavMicf5kwm3WJECiG1iRWmY8BDzG07y2z1+de5k3bHUVjrk6c1tBHDFOPp8Pr10vr/f+WXofMJITyWRhThn7+atpyu+32cilsz4YFKtNkVbo7pBnc8zc7DLRIfIqXR3inK7ww8ePy3ebHyLPPV3u2/B5nNVsaqLMOAC2+xK8dQs8dgGcfEf+DkMQma1sJHqA1Az++om57Smb3n13Ap7+nRyD6fuLVnuu65vT3j59Du7+tlVLYdr+sONZMG4LSHTKo6dFtlVZJcc1kCqi3dOduy/kq9Fu2h8Mi3PcH0j9voykWJLJ9PGmP+OMz5e7Zks84l1P31dh2U0SK0vILlNnf13hF7kkkjBxO9j9B/DcH+HRC6BpC9hsL2/7keyB8Bg47h9w83FSB+WZ38Ohvy9MIq9uYvrrfc6XYzVuy/TlujPYvxOvdSOy1ezZsFLqsbQtkyyKL90hNSWyUeHY97YV8MLl8nqfn0FV6ry7/X8JVFuBVfN92tjl6Hd2KUazfK7/F177qZcMlnyyXBRFURRFURRFURTNWCh7ii0NUOgs8mztyNXGeAS6OuHg38n7166DxU973/bYLeR5zRDNWFj1rjioQIrSTpyd3++TSXjoPHG0TT9ApDQSHdb3ZpZnbZPlBM3n/Jrz195c3AyDcpx9Wqw21YyBymp5Njbl1v+NHEgiBu2rRQ7rw/vlu1lH9K8Nbux1rjgMN6yEf39JnIDlzKvXwur3oWpUYVk8q94VJ7CZfX3Yn0WapX6C2EvHOkh2WVJGNY0QaoD1K+WcVFTm7guFarQHa2D0FJF3KicbcKPUEjT5rt/IjtU09j328YhknRjM6wq/2OPWx8OWR0ug4D9n5j9uNE6HI6+QANQH/4NHfi7r6i8TtobxW/V/PYXirKngJajgxhO/lmvexDkwdXeRFlu3XIJokRb5zmScxHPURfLSL1QeSVEURVEURVEUpWzRwEK5U2znbCE36WbGYHfcvR32NvY6WW06/2ZG/ca7WRI+93w3cy0AJyaw0LygOA6egaSjDe77gdRV2PwQ2P4r+a9j/r3w6bMyU3v/C1MzeG2ztnMVms0VTDLnz0dxHTjF1FkvFsVqU00TjJspz+aYu8l99MqBBKAyAJ89L87u8JjiySDZqaqFE2+S2g/rlpR3cGHNAnjpKnm97/l9a4bkIhGDu86yCj5/+V7Ydh5s+gVonAZdXSkZpBqoGQ21Y8EfkgyGzjbYsFoc2KXsn8Ea2W45ZSu4UeogYL7rzybbZsYTg3ld0ySPMVMkSDVlFznPt52SHojwwiZfgEP/IJkK79xevODCYOFWqLmQoMLaT+V4gNhshU/Glg3LRWYs2SXyYutWSJH66Fr5LFOAwUu/KMcAtaIoiqIoiqIoigJoYKH8KbZztpCb9HhU5HlMG5xOalOIMZ5yYDudrPaitwdcKBrW65bA47/ytv3Rm4hTPRGDdUu9tzvZM7jSBsmkOKTalktdhUP/kP+M7Ng6eOR8eb3b92Dc5jIrN9P5K6QgpuljNU19f1uOdRLKDXPM7RIk8aj01bWp/uqrFCmeT56S95sfKr8pBfUbwYk3l3dwoTshNUd6EiJdtMXh+a/jsV9C80KpyXDQ7yBQle7ADFSJTEvjZiJF05VyQIcb5NpQVZu5HslIo9RBQBMo6O/6jaRSd8L6rE+R9bBIgJ14s2TvrPsM7jwz/3oJWx45PIILbkGFQiTSAN5IFUXfdC+YtrfUvvBVisQYQGyD2JTfL/YWHg0+v1XI3omXflfMvqnjmaIoiqIoiqIoSlHRwMJIwx4E8HpzbXdWZ3JSm8+TiNMnHrMyEuyzT6vqpL4CwBv/hAUP5t5+RaXIU4AUpnVz7nTFYdV74gB67Jdw8/Fw2Ry4ek8qX/kro5Jt3va1mLz8V/joMamrcNifoXpUfr/vTsiM7Lbl4hDa8avWd/EMDpL+FMR0/jYRhbXLZNbvSJKh8OJ8MssYCaRg2BGQiUmR8kSqUHm4URzgnzwh70tdwNUZXLjxGHjzxvJwpC97Vfr15x+ITex/Qf4Bt7f/Da/+XV4feQU0bJTuwIzHpB6LP/U+uk6cnSDZIuNnpfq6zeGpTsfywxSmN2NJIiYSV9F11jLhxvRrljmH4UY46d8QrIUlL8DDP89/+1selR5cuOlYkUcq9+thT5dkRz36f2L7xQgqfP6h1AoC2Gae2FgwJOsL1Io0nN8vGUEVfmiYlJKyaixtVlA+qKySoiiKoiiKoihKUdHizSORfAvY2gsqmt87ndQm6FBbny4N4yZlMfNgkQR6/Xr47zfEAbrJF7K3YfNDYPV78ps1C2DHM6HlY3FOrpkvr92K4LbHCLx4OTcR4HHf7viafwC1o3Pvc395+Wp44S/yeu+fir52PiR74O7vwMdPiHP0sD8jWkXI8V2/0nKU5jqHzvPnlXjUmnlaVyaOoYHAi32YZWJtUpQ5Hk13UgdC4tBMYn0ej0LNOIithYd/JoGGTXYv3X6Y4MJtX4a1i+HZP8Kr10mB521PtIo+DxSffwDP/gk+e07e+yrhgF9Dzdj81vPqdfDgj+X1zt+E6fv1DQYEQ9Y5sc+grslS2LYci42PdIzskRlLAiEpmJ7MUPDYeQ7HzYJjr4F/nyyB7I13g62Oya8NWx4F+OChn0pNj1XvwnN/hhkHSi2HcVvmHxgrBT1dsPx1qV/00WNynTGM3hS+eG3hQYWFj0gwMN4OozeDCduK5FEwJadUXSfZR/EOsbV4B2QyoVzFmEtJvoXYFUVRFEVRFEVRlKxoYGGkYW7qfeTvWMzmELA7r5NJa2Z0pDnlZHUEGPb/Jaz9TGZw33GaFJLcaG7mbc89TbIdnrxIZp8ueaHvMqEGcfL0PraAz+fT89oNBFe/yyHJp+Dmp2DSXNjmOJk1XlGZ3zHIRecGKUj7yjXyfvfvw3Yn57cOU6z5vTtl5ucxV0vBZ1NXIZFy3nQlSuvwN86XukFwAA0mXpxPZpmaMdZ75/dun51+H9x6Eix/DW49UWZDzz6huO23U78RfOUBeP9/Us9g/VJ5fv0G2PZ4kSAKjZYCw5WB0rRh7WfwwmWw4AF5X+GHrY+DHc6Ehin5reulq+DpS+X1Tl+DA38tr+MxS8vdXIv8tjokiRgEK9Pf93TLc1WdfKZOx/LDBIZMcC5YI9kpBIHP+y5vziHI2BMMw/T9YedvSAbZ/eeIU7xxWn7t2PJICUq8fxe8fatkAX3wP3k0zoCtvyi25K8qfF8LwQQTPnpMZNY61lnfhUbD9ANg5kEwZafCpNeSSXjxKsl8IAkb7w77XCAZJJUp+zLnqLpOggnrVqSCCzH3cWMwA3iFBtkVRVEURVEURVEUVzSwMNIw9RIq/PnfYHt1CARr5GGvt+AMLHQn4NDfw93fhqUvwW0nw6n/tQo1O/H5xHkzcTupzdC2HMZungogzJLfNUztO3O0cTrxaYdw7hW3c0zyIfbkVXwr3oAVb4jTdetjRe++v8VV1yyEt2+RQstm9vTu3xeHVr4883sJTuCDw/8Msw5L/94EGOpqSuskGU5OmHxmyXrZb9dlXOp5xKOWYzSYkpo65Q64+7vw4X1w39nQ+olktfhKpEznr5LgxYwDxAH56nXQskiCC6/fYFuuWqSJqurlUV1nvR41GTbaPj+HbLRFpFM+vM/KJtricNjt+/kHFJJJsQtT7Hnnb8KBvxF7T6SOsQ8I1/X9bSAkDxNIMO/twU/TL4ZLfx8q5LJLM5Y4P2uoAj7ou7w5h2bsiUeh0i9BrCUvwMq34a6vwukPpGcYeaGmSYJZW30RVr4pwbqPnxBbevp3Is213Smw1bGlDU4le2DFm7DwYfjkyfRgQnWDZFL0J5hg6I5LgPudf8v72SfB4X+CDWtE4i1QLcGDXptK7XPDJEsmyQ0N4CmKoiiKoiiKogwbNLAw0ujPTb3X38YjltPOWdTWTucGOPC38MAPYeVbcMuJcNrdUnAzE43T4Ph/un+XSY7C52O+bybzfTPZ+bQJVL9xrQQA2paLXNGr18G0fWHitjB+G5GL8CJt0Z2Axc/A/Htk1qhhzDTY6asik5Evr10PT18ir3c4S4pkOjGz4X1FzrYwlEKqYjDlL2BgZ8nagwlpUi6p7fqr4dir4alL4IXL5fHxE1A3wXJ6+6tFAsv+PhCCjXaQQFohVPhFhmzGQfDpsyIN07wQOtuBJHR1QHsHtK/OvI7qBgIT53B0z2Te8c2C5Dj6lOqJt0sNhHfvlHUCbLInfOEHhbU92SN1U0zh2D1+LA7eaKu8j66VGdKBunStfSOFZA8kmGuR+SzaKuenvdmyK2f/sPfd/gYglXRKZZf2saqjTYJOO30bHv0ZrH5fHOaH/6mwYJ7PJ1lvk+bCHj+STJy3bob2VZKZ88YNMPtLMHnH4vWXZFJsdeHDsOjhdButboDN9hFJsI22l8y9/hJtFemjpS/JMTrg17Dz12Xfw2MgEcp8fcsWoEtEJeNusMYBRVEURVEURVEUpahoYGGkke+sXKdD2MtvjbOhwi+zPDNRGZDH0X+FO78Caz6EG44QB+R2XyqNrETdRMkimHsaLHpEikGvWyKzqj+8T5YJj5EAw4RtYcI20DRTZr0a2tfA/LslOBFtkc98lSK5sV3KoVSI5vb7/4VHfyGvtz0JtjjEdRJ83uTr1C+Fs2+w9esHcpZsIiZBs2ir9CW34JqvAvY5D8ZsCg/8WOqHrH4v97p9lXDM32Tmf6H4fLDpnvIAmckfj0DHeinU3dkmztje5/WSkbPyLehYR+XiJ/kmQBKSt9SKTNfE2WIvq96GN2+W34JkFO11rsyeLoSeLnjwJ/DeXYBPrg1zT03VTQhAbIMEFTo3SPHmRKp/xWN9MxTcApyBEHR1gi+euX/a+64GFoqL0y7tAaH+HGv7WNUdh9g6GDsddj8HHv25ZJdF1sBRV/bPEV9dD7NPlGy6hQ9KBtD6pSK79MYNEsjb/FDJ+imEDSth0aOSabR2sfV5sAY221cyEzbavn+ZCU7WLIA7T5dxMVgLX7wOZuwv39kzFExGgj1g5yQRleugPYOhMqh1TBTPLFmyhObmZubPnz/YTVEURVEURVEUxQUNLJQTxS4A6XV9SRfvtXHwJKKFOQJibZb+fCZ6ukSnuWGyyCD980iRlXj4PMkk2OMHMOdUKXLrBbfizQC+but1sB5GjZPXk3eAvc+VrIOPn4SlL8OKt8QRsvhpeYDMFp+4HUzeHloXy6zRZGqdNeMkmDDnZAlaZMOu+e5k0aNw3w/k9Q5niFwMPqht6n9mglenvukvdmefWx+KR/oGKtyCF/bfZlpnKYqeuq3TTVLFK2724b7h1LbCEGkRxzf0Da6ZfhCPwhZHwKTtoXmBOOgizXIsuzpTMj8pR15XTBx9y16VgufH/UN03/OhzuP+J7vdP+9OwKp3SHzyAm89+wBbsYBwvB0+e14edppmwl4/FVkWr7UbKoPp77s6pYD5h/eJDex7PkzZRTIigrVSY8SXFKeqv1rkWaJAQ42cAzOLOpvTtapOHvb+a8dZk8ZzX/DAYBb89fkGfvtu1whnsDoelSBRpFVqKWQMBOZxHqpHQUVA+sPYzaFmtFxrP3oUrjsAjv+XZKt5rTmUKRAxbnPY7btSd+HZP0mg/P3/wsKHRCJp56+5j2U9XalZ/1FxwMfbRbbpA0cmXGVQaiZsfYwEsTONJ17HC7f6QgsfEamoeLvInx3/Lxn7DImYXB+MbdlrybhlfyQ6JCOqYx0kG8RuK/yDI4Pkpb+XQxFupZclS5Ywa9YsolGRlwyHwzQ1ZZmsoiiKoiiKoijKgKOBBcUd44xOktsR4OYwCnlw0tSOl9mkiZjM6PzGs/DmjfDsH2HDCpnJ/eyf4QtnSwHkUmQw+Cpgs73lAdKWFW9JkOGzF6XIbsc6kYRY+pL1uyk7S9bDzIOlZkV/WPoy3HmGHO+tj5OCvl4lOrxkI3iZre+Ue8nmhHcLVOQKXvTHsT/UCIRh9BQPxzyV2VM/CSZuI585azLY6emWmiTv3Cb9pZDgQn+oDMBG29M9djvOf2EbKpLd/O+kUVSteBmWvCRBj9Bo2P170o/7Uxi9eSHc/yP47DlxqB5+mWQ/+JDMhCQpZ/8ouT4lkcCC8TebAJYp5BsI9w0eODOxMhWaLbQmjZKOlwBnMCxBBX8gXV6nz7piubdnzrfB2NSsI6FuEtz7XVj3GfzjoOIVUa+olOyFrY6RGgwvXA6r3pX6C2/8CzaaK/JgRi4wHoFERIJorvhg6i5i51sdK/29FHR1SJHmJ38LJGHyTnDEZRB2OHGDoez1E5wEw1BVK8GOYEiCrIXa0WDL6SkDTnNzM9FolJtuuolZs2bR1NTE1KlTB7tZiqIoiqIoiqLY0MCC4o5xRtfWZ9dLjjSLxrmZ7RkIe3Nkm2W64pZGc02jaFPPPFRmfb54pQQYHvwJPPfnlERSiQIMhkAINt5VHjt9TfTdWz6WAMPy12XG5bYnFK5z72T1+/DvL8mM9BkHwJF/yU/324uzzouEVT5yL27nVwtypuOpAHRKozweFWdqzRixgUzHsKJSpFsgPbgw48Ditt0jPb5KkhNmw9S5sMs3ZTZ/f2f8RtbA05eKpEyyW47hCTeJNFmyWxyUPp/01a64JTMVCEEinC7J4rQN+2x4krK+YC2MnprZaan9unh4OZaBsGQqZJPXAble5sKc/442CYpFW2FUat0NU+HYf8DTF8PHj8M934Flr8BBFxVnfPFViEzRjAMl8+2Fy2HZa7DkxRy/q5TjM3oTmHWESJ7VTZDvSuFM7+qAN2+S8XXDSvlszqlwwIXQ3W2TO4paAYWaRsnIWrcCwqPlfSYCYTnWxWCw5fSUQWPWrFnMnTt3sJuhKIqiKIqiKIoLGlhQCiceFZmDZJfIktSFvc8qDITTi6qCOCvMDOFtT4Adz0xlMPxJnB6lCDAkYuLcD9bA2C36OkZ9FdA0Qx6zT+r/9uy0LoZb5om2/aS5omWdSzbGeXyL5fjMZz1uTvN8a3coloxIpBV6OlPBBRcnXTwqtTySyPdHXSkOtvf+I8GF/tZcKBb9CSokYhJIfO7PIsMCMPMQ2P+X4gyOtEqGQngMkJKIqqnrG9yy4+zT9tnwHeslE8I0OZPTUvt18fB6LO3yOpnwe5gxb85/eIwEFSoDVsAimrK1o/8qRcyfvEgyCla9K8G6UZOzr7urA9pWQNtKCX7XTYKNd3MZP3ySDbfpXrDiTcmQCNakrt2pZ3+1dT2vDA6MHE9XB7x9a3pAoXa8SPBtfZy0o9ouUZWSQIrHpJ3RtXLNiq7NHlgoJhrkUxRFURRFURRFKTs0sKC441W2oqpWZv3WpiQOIs35zSrsda62yO98WLOQ/VWw41cli+Gtmy0nyIM/gTduhLOeKNwJk4iK9MPzl4sUBYh+9VFXZC84XSxWvCFO4fbPYewsOPmO7PUKDM7z4uasK0Qywji6vKCSFMWlZoyVseBGImY52xMpeznmarGTd26TmguH/xm2mTdwbS4my14Viad1S+T9uC0loDA9VTA20iLBRl+l9Ddj85EWCbiEM2R5OG0jEIbRk6XvVtXJZ/agQzGclmobpSce9Zax0Hv+k1YA28ghjbJlRez5I5g0B+46S5z/f99PgnXT9klfX2wdLHgA5t8LnzzVt6bP5ofAcde7B4d9PpFB2shl1nWm2kClIJmEBffDI7+AtmXyWd1E+MI5MOeU1EQBWwDB4JRACo+WoEJ4tLVMIX0/12+c36tNKYqiKIqiKIqilBUaWMhCMpnEN1KL+XmWrXDIHATD0N4Mvrg4BbxI8JiMhQp/eqHVSIs4XMMNUtB4u5NlVvNTF8Hq90SmKN/CxsmkzPR+7EJoWy6fVY8Sh8pHj8LVe4rTdtM98ltvPtt/9e/w6AXQk4BRU+DIK2SGaNsKSzu+MihBGpOVELA5QHMd31JLRqgkRfEwGvAmqOBmc4GQBO+SWPIwFZVwyO+loPL7d8G935P+s9v3hk4B0p4uCRY+92ex5ZpxsMOZMOswqLEVuXXTdU/EpKYCWDbihUzOSfvn/QkOqG3kT67jbR8jQMaEeDy/bZgAdjwq40oglD7Tfvp+cPr9cNfXZGy55QQpPr7DV6T48vx74JOn04MAgZBkKlTVy28WPCjFxo/5a35ydgNFy8fw8HnwyZPy3h5QMNl/yW4rO8g+vjjtpqaxb6ZCIX0/12/UnhRFURRFURRFUcoaDSykWLx4Mffddx/r169nq6224phjjikoqNDZ2Ulnp1WIsa2trZjNLC3FmB1onHxenQGmgG2F39JuNjUXjERMdJ3IWfirpGgySFZBnsVhN09+RPCWP8KK1+WDukmw+9kiI9P6Cdz/A2hZBDceI7NYd/lWeqCjv3Ssh3u+JzNGATbbF3b+JgTrZH87U47SYK1s19SfiDscPLmOb6klIwZAkmJI21E+mP4fa5OC59GW9JnVxqnqNiu/Ow4H/gZCY+C1a+Hp30mw7KCLittvS8G6z+B/35baJQCbHyZF2js7wBdMDyK4Sm+FIFArDtBsWvyF0B9nZpnJtQwJO8p1vJ020tUBFOi4N+tyKwzdNAPOeBAe/rnIIj39O3nYGTMNNt4dNj8YJu0AtY0yTpk6De/dCaEGONjxu8EkHoHn/x+8dJVcMyqDsNPXYe+fZpC0s8kexWNWZkIuyaNC+n6u35SZPSmKoiiKoiiKoijplLn3aWB49913OfDAA9l+++1ZsGABY8eOpaKigqOOOirvdV188cVceOGFJWjlAODFoeZ1Nm+sDQLVQHP2ZZ01FsCSQjISMeGG1LZjomcNUDPW+35tWMmPe65i/+RzsAJpy+7fh12/LRkE0bVSwPW0++CxC+Cdf8Mzv5cZqkdeAfUTvW8rEyvegru/JXIvFQE48Ncw4xCRYQpUyzI9CaistmSlglF3p0omZ4v93JRSzmkAJCnK0o5KIXNj+r/JWLAXMwdYt1xqAkB6oMHUJwHY52cwZjN45OdSk2TDKjj6b+XnjOtOwJoF8NnzYl/xdpEk2ud8KXLblYBwkwTWch1fs2/mODnrUPRn3/vjzCwzuZaytCMnuY6300ZGTYJEN7DE+zacmXGZglH+ajjsj7DR9vDgTyWIMWYzmLwzTNsPpuwo1+yOdvku0iq/m7YfHPZnuPe78Oq1Egjc9dve21cKkj3w7p3w5G+tcXPavhJ4HDMtc2DeniHU/AnE22RfcwUWsvX9TNfOXPZSZvakKIqiKIqiKIqipDPiAwsLFy7k4IMP5swzz+TXv/41a9asYf/992fVqlVpy/X09FBRkXuW5Hnnncc555zT+76trY0pU6YUvd0lwYtDLVPwIeFwgofqJbjgD+au02CvsWAyFww1qUyFRAzWr4T1KQdJ7bjc+5OIwkt/o+rFv7B/UpxK3VseS+VBvxIZiN7lOlL1HSrggF/DRjvA47+EZa/A9QfBYX+y9N7zJZmE166DJ36bkj6aLE7fqbvIPsV84gzt6hApmIrKzPIThkyf28+NeT9Etd7L0o68zmT3Ku1ishLs9mYPtK1bDnRBF1Abkt/ZAw3GgZ7oEMmWugkSvProUbjpaOlnYzYr0s7nSU+3ZAGtfFsK4q58S4qkd3VYy0zeCQ68SAIJ/mqoHesieRS1PjPH0hw/U+i9N7jQLseiq0M09L3WDHGSyb6GYP2EsrQjJ27HO5uNAMQddQlyavU7MuPskkjme3/Qsr8ZB0PjFuDrAX9Y6ib4KuVa3Z2Q4G+iQz6v8Ms4NedLEnR46Fx4+hLpf9ufXqyjlB+fPS9B8pVvy/v6yXDQb6UgujMT02ljvXYWA5IS8KuIyfHqiqWCd2O82YA5L4loZnk/RVEURVEURVEUZcgyogMLnZ2d/O1vf+Oggw7iggsuAGDcuHFsu+22vPPOO5xzzjlMmjSJH/3oR1RUVHiquVBVVUVVVdVANL/4eJkdmCn4YHe6mmXMDFMvM3/txTUN0RZxFhrHo98vxZshe8ZCMgkf/A+e+A20LccHvM9M/lZxKr/f81AqTVAhHhXnEKRmsaYyB7Y8SrIUHr8QmhfCnV8R7fd9fibOEa/E1sEDP4SFD8v7zfaFgy4WWYlESmKiY61kMHR3yT4Gqr3VpnDDfm6GuDZ1WdqR15nsuYJvdoe4WzaKCbT5AxJUaNjI8VlCAg1ONtsbvvgPuOfb4sy/bn/Y/1dSm2Qg6i4sfRkWPWIFE+KRvssEwjBxO5h5EGz3JWhvEbs23/VxMMf6FpM1TmJ7oXeQ60RXQpy9iVjhgQWD01k9BG2qLO3IC9kki9ww5yaT49o5vtjXD6nz2i3fmz5XP0Guyb1t6hD7841OBTwQR3t3wnLM73QWxNZKYOHR/4PqBtjq6CIdFA+0fCTj3sKH5H2wViT9dv2Oe5ZGIgrrVljBSntQIdkNodHgD8n30bXIBQmIp4IQkRZLKqnWZUw25yVJZnm/fBiCwT1FURRFURRFUZThzIgOLPj9fo4//niqq6sJBOTG+re//S233norZ555JqtXr+bBBx/k5Zdf5o477hi5hZztZAo+2J2uyWRq2VAO557teAZr+i6bNI+k5fRP9sizW2DBXwXLX4eHzoNlr6aWG0d8z/M45+Fx4lztbEs5SID1y8V5Em6C0bZZvFW1Usvhi/+QbIPXr5fn5a/Dob+H+kmio+0PyTrN/tpZ/gb85wxL+mjv82DOqbJ8IATRVmhbltpBP9SNE6dorgyPbDjPjTkfXvut2364MdLswOyvWx+1Y45fruCbcYgHw6TZgB3z21pbrYV4VDJaGsb1zXIAceRvNBdOvVtkkT59Fh78sRRrPeJyqK73tr/JXOfXbrdhCFTCi1eII9WOvxomzoYJ20iR8tHTYOpOVrZRpBkCVdLv6+rdC95W1aSKlSOZCMZpHI9a+2OOdcNUkQDLV8YoU39OC5bWpJ/XkWYDA4mvwnGsXfqF/TOfz1re7rg2ttrTY0mHJaLSnxIxCRSER8sysTYJhFcE5PqfiEH1KGsd8Qh0dcq6w6mAeSI1e98Essxn258JLZ/Ae3fA/edIJtqMA7Lsr9e+lOX6HGmGZy6F126QMc1XCbOOgL3Og4bJma9biQ4J7HXFoa7GOq5VNXIMa+tlzI3HwBeToEmg2soqiq5N1UFa6x5YMOeltj67vJ9XhmBwT1EURVEURVEUZTgzogMLlZWV7LDDDvhTM2YXLVrEVVddxd13383hhx8OwN///ncuueQSFi5cyMyZMwezueWN3akdabbNNu3HrOHaJoiHxdlu6EgFBZyBhbaV8ORv4J3brPbMORW2P52e4Bh4JFWwOYm0raNNHDAd68VZG3fostc0yuPwP8HMA+F/3xI5l+tsDqLKoDifqhvkOZR6rgyKtnVPQpydx10Pk+akO8MireJ49VWKbAuAmVhcDG181aYePHIF36rrc5+bQDh9hrGRaukNSDiIR8RpmgQap8GX74YXr4THfwULHpCg2BGXicZ6MenphgfPE115kPVP3V2kviZsnXL+Z3Ccmv2rzRKAdBYrh/QZy+ZaYxyNxez3zgBRrsCSUjzyPdZm+Xgku+M6HoNklzjUQ3XW5/bXbttOs7+QXL+dWTMmC6JjgxRG7myDRQ9Lxtsp/5FgdbHp6oCXr4Hn/gSdG+SzzfaBnb4BozeB0Kjs47A5TnXODA/b+2SPlZ3gD4DPL+8TUSApxzsUdM+0c9pjf+1TizkriqIoiqIoiqKUFSM6sAD0BhUAZsyYwdtvv01TU1NvTYWmpiaCwSCjRo0axFYOMdxkjSLNkiEQqJY6A16cRsYJ0dMlM/x7uiSAAFA7Xp4TUXjxKnjh8pSjA9j8MJEtGr1JSk4pZq1z1CQJJITHSFt8lVBVb0lu2It8mn2ZeTCc8Qg8+BOReelYL0GJ7jhE1sjDjWn7wSGXwphN+35XMyalaZ0rq0MZFuQj4WGWNfZj+nAwJMWOXX8Tk4BWhd9ysM4+CabsBPd+H9Z8CLeeCDt+Ffb9RebitXlQlewgcNfpsCglu7Lf/8F2p7pr4kMq+BGz+rxX53E2ia9SOho1kFA6SiVpk+ucmcLEJlPBzLyPxzLbhD1oV5OyPzPGVdU5aoLY1n30X+G/X4OPHoN/nwRfvhfGb5W9/Z0bYP0yGWO6OmWMcXt0xUUm8M2bYP1S+e34rWHPn8D0/axrgBnLIs3uY00+jv5oK6xdKtl9NY1yzEKpwGF13cBkEWjAXFEURVEURVEUpawY8YEFg6mf0NgohYNNoeYXXniBzTbbjJoadTB5xs25E2mVGZyJCIRTxZmNM79XO90hk2BeVwZTtQc6xMkKInny3l1SB6FtuXy20Q6w/4UwdnOr6GciJlINhvAYCJpu3yhtcdPe7miT2damjaHR4iiq8IvkTftqCXL4gO5OKSrduQ46U86cxmmw6d5QN97bMXM6XcsN+7kpx/aVO/lIeJhl7UWJwZYR5Cg62yvzYuvHkVR9ktqJcNaTUsj1lWsks2Dxs3D0VSJRVCANyfX8quf3VC76BCqr4MjLYdvjs/8o2gKd7SI1k08fyiTx5fadnUizHIeaRrleKOXDYEnaBBzjTbTVKkbs7JPmmmxqolSkxo1Iq9iZqSFkCIbSgwxJJFvt5uOk/sgt8+D4GyXLZ/1SCSC0LZOAe9syK6CQLzXjYOdvSgA81GBlKJhHpgzCfIM7HeshEJDnRCoA78MWpFGHv6IoiqIoiqIoykhjxAQWurq6SCaTvbUUgN6sBKC3foJ5bm1t5Q9/+APXX389Tz75JLW1tQPf6IEkXydDvsvXjJFCl4HqdNkIu2PJOJvam61CmSAyC8YhFEtJId1ic2LWTYI9fgizjhS9anvRz0AIEt2Z2+WcXW3aZnS07bNYO9pS8kVIlsO4egl6dLTBuK1gwxqoGysZEcbZC+JQDYSkkGbv8YulO3sirZDYAIG6zM4fc4wGo3ClU29e8U4ias14rvVQ58DMwrcXJU6SbjfRFojbbKSmKf28dMWgY53VFw+5FKbuJsXEmxfAPw6GI/8CWx+b9+74Vr/HZT3/xwTWkKweje+oKyUzIhdGIj4eyzyDOtd1JZ8Zy5EW6O5IBRc0sFBWDKSkTSKanrUWTBUejsesoF3ccX2GvkXCAdYtt4qNm2UCjoCCnUAYTrgF/nmYZA3948Dc7a0eJQHvioDI51UGZJzxVcprfzAlR1QNDZtKhkJ4NPTE04uZ97bBJYMQ8g/u1E2ADavkOR6zZJFMFoiiKIqiKIqiKIoy4hgRgYUPPviACy+8kBUrVjB9+nQOPPBATjrpJCoqKuju7qaysjJt+UcffZQ777yTRx99lMcee4xttil8Zu+QIV8nQ77L1zT1de4Z57/BOJt8cXFadCVE+9nO2JnwWbO8DtTArt+CHc9KFeNMrc/uXAmGAVuNhngMghnkZMzymZxd1fVWJoNdV9vM2DRFP40TOBAWB3BPd6ptNseV09mTiEF0HYQdJmk/zjB4hStV27pw4lFLpsjLeet1ntuKQdtJxEQKxdhIrYtTMxCS2h9Jn+XEn7QdHHmFyIYteRH+901oWQRbHAZjZ0kQIhdv/5vgQ+cygU5WMI7Gk26nqnGyrYB01OZsdbS7JlXHJBF1n0Ftfu+lj3sJbNY0WhkLSnkxkJI2pq7ChjUSFEjUQkNYHOJdqaCdW2AgTe4oNfPf2FxNyBEcziItFmqAk/8DNx4NaxfLOFg3CeoniSzg6E1gzGbyefVoKYJsz05KdokEUTAEPUkJbvv90NUlEkQdqdoK4dESwPdVpmfAJWKpLItqhxRZntf0hsnyACtYY4IKSS2orCiKoiiKoiiKMhIZ9oGFhQsXsttuu3HEEUdwwAEH8Pjjj/P73/+eRx55hOuvv57Kykri8TjBoOV83mqrrVi9ejXnnXcem2yyyeA1fiCxOxm8OO0KcTRHmsXBUTOm7wxrO2abpqBkZ5tkMASq4ai/wbN/gNg62OlrEmgIVEN0rVXkOZsjsSsG8crMzs9MuGUymCBEMmktZw8kmAK8brNFnXJRgRCEG1yWcxznwXLuq7Z1/hg7Aqvocn+15U2f63V6Ykkm2ftTuDE1K9vmxE8itUkO/C288U95PPtHeVTVw+QdpcDs5B2k2Li/2lpfVwc8cj68dTM+4GXmcGnFN7m5fmK6HaU5Wx37Zy+w62YTZv+89HEvAQi3YKYy8jDOb3810GXVEg+EYVSWfuZ2jQaoqZZ1RlutGfyGeMwhT5YKtFXXwzdflELI3Z22ZcKSZQcp+bINsG4FNExK1RBJtb1ugoyBtaMt2zd/WUxgO5BatqvDkm8yQYWeDmhbC2M2tgJ6/bmm95Enc7F3RVEURVEURVEUZdgzrAMLyWSSf/3rXxxwwAHceOONAPzoRz/i+uuv5+qrr+aEE07gtttu6w0qXH/99ey7775svPHGnHzyyb2ySCMCu6PAaDJnc9oV4pSItEq9g0iru8PPOAsr/OnfJzpSzsoOcb7ve76tHdWWbFLHBpl1Hc8SMPA7Z5pmWM458zpbJoOdQMrh1AUEbMcvEQN8mYMpNWMgEerrbHUeZ7d6FPbvS1UUVckft/7sxba8YPpjpMWSRnIrjBywOfErAylnZrVIIzXOgA/+B6vfk+Ddx4/LAyTDYuJsmLyTPL94Bax6B/CR2P1HXPDibJK+ir52ZJyeYNWCcPb5bAV2nRr4mfpyrgCE2oFisPep6FoZAwrB9FkTLEx0iOO/Yy1EbHVOjE30vrcFmrscQYW09YdS7fPLGOJPZQT0BsqT6csaIq3pNVmS3ZZ8k6kFEWmF+gZ3qSSv2LMUnGNSICyyTYoyWKxbatXgyoCvq5uxyWbW+DTgrCiKoiiKoijFYlgHFnw+H8uXL2fVqlW9n4XDYc444wyqq6u58sorOe+887j44ot54YUXuOiii3j88ce54YYb+sgjjShKJXtjHBzOopeZtuuc8R2ozhzQSMTAl7TJDmXKtAgBtowFgzOQ4Aw+ZJN4sRMIQ8DhTLI7lzI5VLM5W93INGN7sIqiKn1xs6N8M4NyYZyXXXF3eSF7v+qOp/f5uafCrMOloPL6pbBmAax4A5a8BJHPYdmr8jCERsPBl9C98T4kX0p93p2AQEP6/tkDHq5yRx4LlWfry7kCm2oHQ4uBKg4fyiKD5wX7uBAeLYEAkpJpEF0rn9md926Sd/axwU4gLJkKJush2SWvc/Vf5za6Oiz5JpDnYmTuxPNokx0NgiulZt1SuHIn6VNZqAKupYqvVvx+YNqlKIqiKIqiKCOAYRtYSCaT+Hw+5s6dy4IFC/jwww/ZYostAAiFQsybN4+FCxfy5JNPsnbtWnbbbTd+8pOfsP/+++P3D9vD4o1Syd7YpUmMc9E4FRJRmc2dJF32p6dLZkIaCaJE1JJFMm0MhCHQITITmTTn7dizDyItMjuUpBTNTCv6bHPWRFog2izFKkdNSm03ZDmI7bNQ3eSP2ldDZXVuZ6pXMgV/tBZC+RBw9G3T1/PJDHLDBLl6txNy73O9y6dszWQs2PGHJGAwdqYUgU3EJNAQWQMr34YlL8Dy10UPft9fwJhpEItYvzeTqHuzE9wyF5rTHat2mRa7NJL9WuCUkMoXtYOhRamLwyeiIoOXBGrqrM/MDHxIjSu267NbACwQEuk7U7C5ZoysY/0Kq6izCZwnsew6tlYCD4Fqq6C6aYPJfEjLAjA1gpwFl21SS0HHMtFWyVQIN5bmGBpZJrd6Er374fLfQYPgSj+YUu8jtG4hrMiSEdO8UPrgsX+HppkZF4uvmk/1Pd9g6+SH+Fa9TWjdIuZMqHBff7gRGqYUaS8URVEURVEUZfgybD3oRsbo0EMP5Ve/+hWXXnopl112GXV14lSor6/n7LPP5g9/+ANPPPEEX/ziFznrrLMGs8mDR7Eln+w1BzJhZn4ap0I8Kg5NgHjKOWF3DlakumpXPBVAiIsuvKGqVgIQtSEXHfcqa7l4DBJxywlq5JmSPVCRkpwwTlL7LE8fKcmlKli3LCU3UQnjZqakmrpTjpVa62H/cYVfZntmy1pIOz45ZnMGMszsdct88HI+oPj9YLgQj/RvZq3TgWaOs71/ux37TKfN2E5sPYRSwbBsNUvM8iDBBbPNjvVic1W1ElQDaFsF8XYIjYHtT5NH73qiViFqgw+xl0Q7BGotR75b5gKkAoWkBwzcrgVukmj5oDVBhhZ2W/ByvbIvk0xm/o3psyaYVeG3rs2JDrmOR1qlD/oDqbak7Cgta802+99pZ1W1MHqyFQyLrk0PjidsY1swnN6nuzqlDWbsMG2y932zD4GQZCMku1NZCbZ2dHWI3ULmscGJ5+t9yuHaZ1yzYeQK7UGCXAFCDf4pOQhEVzP/27XUPPN1eCbXwmGYumvWYEBPoIEOqjg3eRX84ypmAW98vRbc1h8Iw7df0eCCoiiKoiiKouRg2AYWDNOmTeP222/nkEMOIRwO88tf/pKmJrlhDwaDzJkzh8bGLMV+ldJgnAogM5pBHDT2jAU352A2KZk0mQW71rUtsNAVg8qkNUPaLs9U05hZwsU4eZKpdURboLLK2n42B0kwLNIUZt+8SEDobM7yob/nImN2SZ7yV871Ge11t36XJi0TTu+nZl+ML9buk/XZnp391PwWm0MyNAa61qX/1k5voVmbo7W6Pv04Oo/PQDocB0qCR8lOqQJBvVlv9HVum37mi0tQoSsBdVn6ZTZM++1ZSCCvk1hjG6RnLwVTv+mKQzDDWGIvwJ4pMykQEqe/j4F31CdSwZMkUGsL9ucKEGrwT8nCkiVLWLrgLbYJ+lg892dsusNB2X/gJcNg1GS+WvF7RrGBP52+K598tIiTTz6Zm2++mVmpjGZAMiDuOkv+52lgQVEURVEURVGyMuwDCwD77LMPd9xxB/PmzWPFihXMmzePbbfdlhtvvJFly5Yxbdq0wW7iyMPpiKnwQ8NU77+D7FIymRww/pA4kgIhy/nTsFFfCRe3IsqmfYnU7FETKMjlILH/Nle7DTqbs3zo77kotgPNy/rsAYSapr4SJL0Bh3D6fpllnUEI+2cVtkBdMATBSksCzInTYZ9JGsqtGOxAUGoJHmVwMX3WGcyCdKmyeFSCCv3th85rRTwqzvZMY5Z5ZLJVQ6xNgt/BsPt1KO3zAc48M1lMFf7sAUNF8ciSJUuYNWsWm9d3cOjXa6mePBsmbVeUda/xNbGGJpITZhNr9vHmqh5iDTOLtn5FURRFURRFGWmMiMACwBFHHMELL7zAOeecw7nnnovf7ycQCPDggw8yZYrOSBo0+uN86OPEcdHETsREOsL+m2BKYzstOyGcX4Fme6Ag3yKUXvbZ7tTSIpeDy1CcWZupj7k58TPVgID0dZjv4l19t2W256y14Ibdme/cRj79vBh2oc7P4Y0X2822TL59zM2+7OQq6J6JUL375/YxC9JrlRSLXMfA67Wmv9tRRgzNzc1Eo1F+c/lFsPR3TJwwYbCbpCiKoiiKoihKBkZMYAFg7ty53HPPPbS2ttLe3s6ECRN6ZZGUQaI/Ttts8kfBGut9d3eG34f6OmXsgQYvJKKwdqmlz+3cFzdnSb77rLJISr7k08dM/2pvtoIEbpkEufBqP5mkmcBbPzc2lUjNlO6PXXjVo1dGJv259nq99ueyM2MnbhlBxuaiLRDvyDwO9Ydcx6BYgVcd50YW65ZKv3UhtG4hcyZUMGtsBSwd4HYpiqIoiqIoipIXIyqwAFK0ub4+w+w/ZWBxc7z0Z9aiM1Bg3vuC7ss7ZSUCIZlx7YtDPJTZ4WhvYzzqrs9tKIazpBizqnU26MgiEZVAgY/M8ioGu9Z8f/pqICSOoq549qwFuwSN0WYP+t112t0wNpXEvSisMvwoxvWrkHX059pr+mmk2ZISK8iuzO9cClSbMa4rnn0cMhRSU2Sgxh/NHho5rFsKV+4k/cKF3qLKb1wk/SWsddAURVEURVEUpVwZcYEFpcTEI96dN25O92LOWjTFcZ3SLRmXD/fNesjVbuMEcepz29fZX2dJMWaE6mzQkUU8CvF26cfxDhg9OfN5d2rN2/tqPs7YPvbjwf6NNju467Rn2o5Tu14Z3hTj+lXIOgq99hq78SHxgGzb7U/QpDfDKBVgqA1lX0chNUUGavwZipJzSmFEW6TfH/t3aJrZ5+v5H35oFVWeu/vgFVBuXph7GS9FoxVFURRFURRlGKOBBaW45OO8KURvOpsTJtIiztRgbeHyJpmKN2dqdy5nSLk4S3Q26MgiGBY7MDOZvdijW1+NNENnO1TVeiyu7sF+7G10q6+QcxtFsqlCZm8r/WegMweKuQ6vxKPgD1oZNdm2W6ysNi/7NRDHwO386vijuNE007VocmxVj1VUeTCc9uFG6bt3nZV72UAYvv2KBhcURVEURVGUEYsGFpTiko8DoRC96UxOmEQUOtZCT7c4QQvFi4OmXIIF+TAU26wUTiAMo6dCbVP/HHpJx7OTaCtQa63fq4PTtDFbodtSU8jsbaX/DGTmQLHX4ZV8gs8D6XQfiGPgdn7z2a7K9imDTcMUCRZkqAHRS/NCCT5EWzSwoCiKoiiKooxYNLCgFJdgTf+dAdkcC5mcMPEoVNWLxnS4USSZemdOV7lvJx61ljHrTcTSt1VMx4Y6TJSBphBHor2f1jZBPPX7SKq4M7aaJc0fQcAPTdOgZojpYOss6sFhJBz3fOzOLkVmbMyLjKB97CoEu2xhfwJrbuNarA1qxhTYrqh7MXlFKRHz588HoKmpialTU5l5DVM0WKAoiqIoiqIoHtDAwnAmmWmasQOfr7jb9bq+TO1zzni0r8/UTXDirHUQaba03gPOwEJqfc56CuZ9bD2ERvVPmsLN2TJYdQ6KfX5HGv3tz4UuN1jY+6kp/GzsKR6FgC2wsG4ZjNtUZMhqmga2nf0N1Nmdv17OidpR/zDHL9M13DCQ9lFOwd6c44Ot/3mpBdTv7ZnN5uj3bpk/oXpvv3XDrZi8ZhQpJaCpqYlwOMwpp5wCQDgcZv78+VZwQVEURVEURVGUnFQMdgMUpQ/BsKVN7fk3NZYT1DiLuuN912GKBrptx7yvacx/+07szpb+7JcyNIhHxPmeiOZettxx66eZ+m7DFNGSH4xsBTcbU0Y2Zta/VzsczD7kbGs+40MxxpJijUeZxtFC1xusgdqxMp7reKmUkKlTpzJ//nxef/11brrpJqLRKM3NzYPdLEVRFEVRFEUZUmjGglJ+9FcH2l44MxCGeJf1nX2Gpj2ToBjbdWLkIOyzYgd6VrcyMAxWNoqhmDOv87GDMRtDVZX064Ge/T0SJHWU/Mhlh84+Oph9yNnWYo4/XmyxWNtzZqDkykgpdL2KUgKmTp2qGQqKoiiKoiiK0g80Y0EZfmSbMen83O7cyXe2ayYSUYi0gj/QdxvK8GQgslGy9c9S9zG77rm9oKV9nwe6nwfCVpaSokBfO3TajPN6P5gySP25ZuSyNR1zFEVRFEVRFEVRlAFAMxZGIoPtUMkHe1u9zl7MNhMz3CjFZg32GavFmnUej0pQoSshNR/MZzqzevhSjKLlucjWP03/Be8FYPPBqXtusNtTMWZ/D6Vrk1J+OK/9TpspxfW+WG3Nl9j6zBJk2WxRbUwpJeuWpgef3WheODBtURRFURRFURSl5GhgYSQy2A6VfHArDFlM3BxRhTpGjcMGoKrOKiRttpPvetTxo9jJ5iw0/TityHIR+o5TxisRhcgG92X74yg12zEyZkPh2qSUP06bKeb13k6prtnZ1hsalfl32WxxKI3/ytBi3VK4cidvWZ+BsASmhwNeAiXhRqlJpCiKoiiKoijDDA0sjESGkjb5QLa1GLUderpSBaBttRS8OJ3syzgdPxpoGJ7ke1699M9C7CVbO9x04MNB7+v2sg37dnxowValeGSzGS/25NVGsznr+3P9zrTe/oyLbr/VMUYpBtEW6UvH/h2aZmZfdjg42sONYi93nZV72UAYvv3K0N9nRVEURVEURXGggYWRSLGLFJeSQB4SSKXCq9Mlk7PHywzRtMwMx3p0hunwpBTntRDb9iKx1F9Hf659Nduprh+8Pq7O1fJlsM6NVxvNZif9sfNM6+3PGO72Wx1jlGLSNBMmbTfYrSg9DVMkWOBF+umus2Q5DSwoiqIoiqIowwwNLCjlQ7k69rw6XTI5e7w4Z+3LONczlDJMFO+Uy3n1IrFUym0UczvZ8Jo1oc7V8mOwzk2mfuvsS9n6b3/sfKAmAZTLtUhRhhoNUzRYoCiKoiiKooxoNLCglA/l6tjrr9PFi3PIi2RHIlqawrzK4FAumUOlbke5BAy9Zk2oc7X8GKxzk8k28hmrBtLOC7W1crkWKeWLFmVWFEVRFEVRFMUFDSwMZ3y+wdluMlnY7zI5j7yuL9P+2j8v5JjkcroU+zhn2t9yDbwowlCzt4HCa7/1evwKvR7Yry9u2wrWDL7smuLt3Div6QNte7n6EgyOXeYzRgzW9UoZeozUosyKoiiKoiiKouREAwtK+VBOsybtMz+hPGZc64xqpZQUOts51+/Kpd9q4EApFoPVl/K1tXLJFlKGNiOtKLOiKIqiKIqiKJ7RwIKiuGGf+QnlkSlQToEXZfhRaEZMrt9pv1WU4pCvrWmWm1JMRkpRZkVRFEVRFEVRPFMx2A1QlLIkGIYKvzzbXyvKcKXQfq72oSgDQ762prapKIqiKIqiKIqilBDNWFDKm8GScnDO/NTZnspwp9Ai4ZqRoCi5KcZYlq+tqW0qiqIoiqIoiqIoJUQzFpTyxilJBJbj00shQUUZ6eRrL242pyhK/xgsu9LxUlEURVEURVEURSkRmrGglDduhV9VN1pRvJOvvZRLsWVFGU4Mll3peKkonpk/fz4ATU1NTJ06tbgrb16Yexktfq0oiqIoiqIMMTSwoJQ3blIO6vhUFO/kay8qn6IoxWew7ErHS0XJSVNTE+FwmFNOOQWAcDjM/PnzixNcCDeK7d91Vu5lA2H49isaXFAURVEURVGGDBpYUAaH/uhNq+NTUbwzXO1lsOqvKMpA0t9+PlztX1GKyNSpU5k/fz7Nzc3Mnz+fU045hebm5uIEFhqmSLAg2pJ9ueaFEnyItmhgQVEURVEURRkyaGAhCz09PVRUaBmKkqDyDIqi9Ae9higjAe3nSilZt9Sbw3sAWLJkSa9jfzCYOnVqWiBh/vz5xZNEapiiwQJFURRFURRlWKKBhRSLFy/m8ccfp729nS233JIDDzyQiooKkskkPp/P83o6Ozvp7Ozsfd/W1laK5g597PIMeRzfrCSTuT9PJou3vVzbdeJ1u8Vu3xBE7SgPBqs/DxZmf0txDRlmqB0NAXL13XyljMp9fFPKh3VL4cqdvBX2DoRF0qdELFmyhFmzZhGNSlvC4TBNTU0l21427LJIRZVE8orWYlAURVEURVGGEBpYAN577z322msv5syZw/z582loaGD8+PHce++91NTU5BVcuPjii7nwwgtL3OJhQCAMwZrBboVSpqgdKTkJ1ug1JAdqR8MA08/LPeCnDD2iLRJUOPbv0DQz+7IldmQ3NzcTjUa56aabmDVrVmmKJ3vEyCI9++yzxZVEyoXWYlAURVEURVGGICM+sBCNRvnGN77BCSecwFVXXcW6det46aWX+PGPf8zOO+/M448/zvjx4z3LIp133nmcc845ve/b2tqYMkX/+CtKPqgdKUr/UTtSFCUnTTNh0naDsmmn/NGsWbOYO3fuoLTFztSpU5k1a9bAblRrMSiKoiiKoihDkBEfWOjs7KStrY0DDjgAgIaGBg466CCmTZvGiSeeyMEHH8ybb77pWRapqqqKqqqqgWh6eaOFVZV+oHY0iKjtDhvUjgaJeERtSFFyUE7yR2WD1mJQFEVRFEVRhhgjPrBQX19PT08PTz75JMcccwwAPp+PGTNmcP311zNv3jy+853vcMUVV+RVa2HEowUnFWVoorarKP1DbUgZbMqoKHPGzZeR/NGQRGsxKIqiKIqiKGXAiA4sJJNJKisrmTdvHg8//DAPPPAAhx56aO/322yzDSeddBJPPPEE0WiUcFgdBJ7Jt+CkoijlgdquovQPtSFlMCmjosxeKBf5oyGD1mJQFEVRFEVRyogRHVgwGQinnnoqDz30EFdeeSXhcJi999679/stt9ySm266iUgkooGFfAiUqQREIgaJdeLw0cKvitKXYtuuSispI41gTen6utqTkosyKsqciSVLlvTWVVDyRGsxKIqiKIqiKGXEiA4sgGQtbLbZZlxzzTV86Utf4tJLL+XTTz/l9NNPp7Ozk1deeYVJkyYRCoUGu6lKMUhEoTKZcsxoYEFRSo7KwihK8VB7GtnkI3E0iEWZs2GvraB1FQokn1oMKpmkKIqiKIqilJARE1jo6uoimUwSCAR6P+vp6aGiooKenh622WYbbrvtNs4//3x++9vfcv755zN9+nTeeecdnnjiCWprawex9UrRCISBTpWoUJSBQmVhFKV4qD0NT7wEDKLNcNupQ0LiaMmSJTQ3N6fVTTCfzZ8/v7e2wh577FH2dRVMZsWQqwGRr2TSCTdCOEeQRwMQiqIoiqIoioMREVj44IMPuPDCC1mxYgXTp0/nwAMP5KSTTqKiooLu7m4qKyvp6elhyy235JprruHTTz/lwQcfZPLkyeyxxx5Mnz694G0nk0kA2trairU75U9qn3NS7GLYGbbbEe+iq0NuxNtiCeJVVdDRDR1FOifO7SaiEI9BMJQ+o1SLf/fB2EUyR58ZkXY0WOQ4F2n2tOpT4jW1HmZOByHWBbEs50/to2BGmh2l9cG2NuLBMvwrU+xxMG19WeypFONqpjGtlNsdBPK2o0UvQm0RMh+jLXDX16ArlntZfwiO/VfuoEFoDFSMgkGw9aVLl7LjjjsSi8UIhULcdNNNAJxyyinEYrKPoVCI7bbbjoaGhgG7HuV73aiqqiIUCnHKKacA0uZXX32VKVOGiGO9YhSc+jjEWrMvZ/rfdcfmXqc/BMdek7X/tbVHgNx2pCiKoiiKogwPfMlh/s9v4cKF7LTTThxxxBHMmDGDxx9/nA0bNjB79myuv/56AOLxOMFgsCTbX7Zs2dC5CVGUQWLp0qVMnjw54/dqR4qSG7UjRek/akeK0n9y2ZGiKIqiKIoyPBjWgYVkMskvfvELFixYwB133AFANBrl+uuv5+qrr2bWrFncdtttvctff/317L///kW9Yezp6WHFihXU1dX1FoseKNra2pgyZQpLly6lvr5+QLc9EAzn/RvO+wbW/i1ZsgSfz8ekSZOoqKjIuPxg2NFwPwcwMvYRhv9+JpNJNmzYUHZ2NJSOu7a1NAyVtpp2fvDBB2y++eb9tqOhst+GodTeodRWGHnt9ToeKYqiKIqiKMODMtQPKB4+n4/ly5ezatWq3s/C4TBnnHEG1dXVXHnllZx33nlcfPHFvPDCC1x00UU88cQT3HDDDVRWVhalDRUVFYM+Y6e+vn5I3MwUynDev+G8bwCjRo3ytH+DaUfD/RzAyNhHGN77OWrUqJzLDJYdDaXjrm0tDUOlrRtttFFOZ2g+djRU9tswlNo7lNoKI6u9XsYjRVEURVEUZXgwbAMLyWQSn8/H3LlzWbBgAR9++CFbbLEFIDqp8+bNY+HChTz55JOsXbuW3XbbjZ/85Cfsv//+RQsqKIqiKIqiKIqiKIqiKIqiKMpwY9jmqJr09EMPPZRFixZx6aWXsmHDht7v6+vrOfvss3n11Vd54oknADjrrLPYdNNNB6W9iqIoiqIoiqIoiqIoiqIoijIUGLaBBcO0adO4/fbbueWWWzjvvPNobm7u/S4YDDJnzhwaGxsHsYWlo6qqigsuuICqqqrBbkpJGM77N5z3DYbG/g2FNvaXkbCPMHL2s9wYSsdd21oahkpbi93OobLfhqHU3qHUVtD2KoqiKIqiKMObYV282c69997LvHnzOPTQQ5k3bx7bbrstN954IzfccAOvvvpqUQs2K4qiKIqiKIqiKIqiKIqiKMpwZcQEFgDeeOMNzjnnHBYvXozf7ycQCHDrrbcyZ86cwW6aoiiKoiiKoiiKoiiKoiiKogwJRlRgAaCtrY3W1lba29uZMGECTU1Ng90kRVEURVEURVEURVEURVEURRkyjLjAwkDT09PDihUrqKur6y0orSiKkEwm2bBhA5MmTaKiInPJF7UjRcmM2pGi9B+1I0XpP2pHitJ/vNqRoiiKopQD/sFuwHBnxYoVWr9BUXKwdOlSJk+enPF7tSNFyY3akaL0H7UjRek/akeK0n9y2ZGiKIqilAMaWCgxdXV1gPwxqK+vH+TWDBBek2AGaIZSR7yLk/78OAC3/mA/qoOD1O1zHZdEFOIxCIYgWDMwbRpk2tramDJlSq+dZGJE2lGZkrc9ebke5NP3y+z6Ug6MNDsqyTXd2a/sfTIQtj4fQf0qL4aBXY40OxpUBqG/lOS6EY+4XyeclHG/LzZqR0OXsrlfUjzbkaIoiqKUA/qPocSY9N76+vqR88e5zBwMwXgX/mq54auvry/fwAKp/jGCbkANudLgR6QdlSl525On60G9935fZteXcmKk2FFJrul9+lWG4zMC+5UnhpFdjhQ7GlQGob+U5rrh0ek3BPp9sVE7GnqUzf2S0ovKhCmKoihDARXtUxRFURRFURRFURRFURRFURTFMxpYUBRFURRFURRFURRFURRFURTFMxpYUAaWRBQizfKsKIpSKHotUZTyQe1RKSamP8Ujg90SRVEURVEURVGyoIEFZWCJR6GnS54VRVEKRa8lilI+qD0qxUT7k6IoiqIoiqIMCTSwoAwswTBU+OVZURSlUPRaoijlg9qjUky0PymKoiiKoijKkMA/2A1QRhiBsDwURVH6g15LFKV8UHtUionpTz7fYLdEURRFURRFUZQsaMaCoiiKoiiKoiiKoiiKoiiKoiie0YwFBZJJb8t5nTlW7jPMvO6vV4p9XIp9PpT+MdLOR679tX+fTOZevtjHZbgcZ2VgKLb9Dtb1YLDGrcFa30hjpI0z5W5vXhksOx8u/UBRFEVRFEUZ8mjGgqIoiqIoiqIoiqIoiqIoiqIontHAgqIoiqIoiqIoiqIoiqIoiqIonlEpJEUxJKIQj0JQi1AqiiuJKEQ3DHYrFKX/6PVeKXe0jyqKoiiKoiiKUuZoxoKSmUQUIs3yPBKIR6GnS54VRRHs1wFjI4oy1BkO1/uRNkaPNIZDH1X6h9q4oiiKoiiKUuZoYEHJzEi7qQ2GocIvz4qiCPbrgLERRRnqDIfr/Ugbo0caw6GPKv1DbVxRFEVRFEUpc9RDpGQmGLaciSOBgMoNKEof7NeBQBjCwcFukaL0n+FwvR9pY/RIYzj0UaV/qI0riqIoiqIoZY4GFpTM6E2tMJg6x6qxXN7Yz0+wZrBbUxryvQ5on1VGGoPV5/OxTbVLZSjj1n91/FWUvFiyZAnNzc2975uampg6deogtkhRFEVRlOGABhYUJRf2VPSBvsEbzG0ruUmTCRqmjo180T6rjDSGQp8fCm1UlEy49V8dfxXFM0uWLGHWrFlEo5asVjgcZv78+RpcUBRFURSlX2iNBUXJxWDqHKvGcnmj56cvekyUkcZQ6PNDoY2Kkgm3/qt9WlE809zcTDQa5aabbuL111/npptuIhqNpmUwKIqiKIqiFIJmLAxnkklvy/l8pW1HJry2zyul2o9MqegDIS2RLQ3e7fi5tWmwzu9IoJQyBcW2j1KQiEGiM72/OY+J2Y9i2Yv2ZyUfvPaX/tibfQa1eV8q+y3UjjLZZbEotl2W+/+XYlPu/8MGwo6y4TbW2j/zsl37MsmkPPKxp4H4zzdc+rNStsyaNYu5c+cOdjMURVEURRlGaMaCUn4kohBpludy3p49Db9U28iXfNqkKIWQiNlee+xviSisXQadG6xlB9rOFSUb/e2PA3XttW9npNjQSNlPxTvF6hPxKHS2wdqlfdfl3Ib+v1IURVEURVGUPmhgYSQxFG7OE1G5wetsG7ibt0JvFvNJwx+oG1KVBlBKjf36EfDY3+JRSHbBhtXpn5VbYE4ZufT3Gp3r2htphs8XyHN/sG9npDg6R8p+KpkplZM/GIauBPgDfdfl3EYuG9dxSlEURVEURRmBaGBhJDEUbs7jUbnB60oMnHO8UGd8IAw1TfI6183kQDn8TZu0OKdSChLR9IyFQMhbfwuGweeHuvHpn5VbYE4ZufT3Gp3r2htpge4Oee4P9u2UelwpF0epBsxLT7mc60zk6+T3SiAMo6dAVX3fdTm3kcvGdZxSFEVRFEVRRiBaY2EkYWY4lvPNuWlbXRYN22Lr3PZXJ99+M5lpPW4a3Ioy1IhHoTKQ/+8CYagZA5FWqLJ95tXGh8K1SxnalLJeCkBNowQVahqLt85822y3K8g9jnoZ2waCUp8bZWDOdX/+uznHgGL2Cee67O00k0cKaaOiKIqiKIqijAA0sOBCMpnENxwLqA2Fm3MvbSz1DXC+N79ebya9tnsgCgQqxcN+voI1g92a/Cikrye6C99eqN7bck5bGQrXLmVk4tWGapryc1KWAueM6mzjkdkvH1Dt0W6VoctAOMX789+t2GNAIgaJTne7LbSdhbZxKP+HUBRFURRFUUY8KoVkY/Vq0f8elkGF4USpZRHyTWf3Kj/ktd2aTj+0GMrnq5C+Hi5wxnU+dqvSJ8pQYSjZv92uctlYPAr+oAb1RgoDIaNYTtf1RBa7Heh2DqVriKIoiqIoiqI40IyFFG+//TYHH3wwN998M/vuu2/B6+ns7KSzs7P3fVtbWzGap9jpj6xQPApxxyy1gZJd8eqgyXf7wzDDYUjZ0WDIHzjPeaF9IBiG9mbwxWUdmWyiGOTjoFRnZlEYUnY0FHCzi/7a/0Bev512lW17zv0ajHGmTMY2taMikc91vZBzn89vAmGgc3CCHCr1pyiKoiiKogwjNGMBCSrssssufPnLX+4TVEgmk3mt6+KLL2bUqFG9jylTphSzqYqh0BlebrPUnOsa7ALI+W5/GM52G1J2ZM7XQEoYOM95oX3AODUqg9ltQhmSDCk7Ggq42UV/x4tytTXnfg1GO8vk2KgdDQKFnPt8fhMIZbbbUve7cvvPqSiKoiiKoij9YMQHFj744AN22WUXzj33XC655BKSySRLlizh1VdfJZFI5L2+8847j/Xr1/c+li5dWoJWD2HiEWhfI8/ZSEQh0izPbhSaqh5w+d1ApL3n2p/+UE7yAkVC7SgHznPenz5gfhuPwucLpJ9mW18i1r+2KwOG2lGRKcTOnNd+5/ustlbCcSNfBmOcKZOxTe1oEHA795Fma4zy+htDIgrRlsK3XUzKpF8riqIoiqIoSjEY0VJI69ev56yzzmLs2LFccMEFAJx44ol88MEHfPTRR0yZMoWf/vSnHHfccYwaNcrTOquqqqiqqipls73jtVaE16yMYqzPa1G8XMu5pdRn2q7980AIgrXmC+uzQCi13Yg4TgMh66YvHu37WRoejks+xQDzPc7DUDZmWNuRk0IkH9wkTQrtA+a3kYXQ0wmR1uyzJwfCyZntmBR6nDMxjGvqlJUdlYpksrA+UQy7y94weUq79of6vs+2Tuey2TDjVKlkg3Lte7H/R/h8kgVWBsVsh7UdlXp8K5Te/pak15YirdATT41Rzlo/Pm+2lIuBkN9ytrOU2xzG45uiKIqiKIpSHozojIVRo0Zx1FFHMWPGDE477TR22GEHotEov/rVr3j77bfZbbfd+N3vfsejjz4K5C+LpLjgdabWYM3oSsTk5tM+K9vtsz6/K1GGhTL8KRO5D2rGQEW1PGfDn8XBWawZ1uVyTJThy0D1sUBIrv0mMOB8n418xo1oC0Q+zzybW1GGOjVjoKIq9xjlhrG7XLhdF0qdOaTjnaIoiqIoijKEGZEZCytXrqS5uZltttmGn/zkJ1RVVXHNNdcwdepUrrnmGiZOnAjADTfcwMEHH8xll13Gcccdh09n/vQfrzM+SzmjK1sGQiAEkRYpZhtPfR8IWctnW2e+GRZ27PtXBjM0lQFkoAs3pmXl1KS/Hzezn+vOYgfO7WZDi1kqpWag+phZf7RFxpaaRpfZ1hlIGzdsGRBuWXXRtZDshkCt66oUZdDoz/83e3/Px3bS1pEae7IFxQ1u14V8Mk4LoVTXIv1fqSiKoiiKogwAIy6wsHz5cmbPns2ee+7JT3/6U3beeWe+//3v09DQQFNTExMmTACgq6sLv9/PnDlzeO655wa51UrRbuwSMYisBH9A3jtv5ILh9AyFYNh6ZKO/N4b2/dMbwJHFQEtZpfXvmr7vc9GVJXMnmx2Y7URbcgcYhqG8l1JmDGQfS8Qg3p567WE8yeaIdY5P5rPqeuhOQG1T8duvKP2hP//f3Pp7vph1dHfnXtbtupDr/11/J76U6lqk/ysVRVEURVGUAWDEBRYWLlzYW4DvqquuwufzsdNOO3HaaafR0dHRm5Xg98uhWb58OVtttRU9PT34fD7NWhgInDdp5r0PcZ70d93+AHQloDbD7DUvGQp9fpNHRoLbcjpDWxkonP073/6ebdZnNjsw2+mKuwcYiq0zPRBa2Ur5Ug7n38y2Bqntk8SbnWVzxLrZq92W89nXcjhGyvDHNQvAYwZbIf/H7MQj0s+TQKChsHXk+n9X6owGJ17tVv9XKoqiKIqiKAPAiKuxMHv2bA499FBOOOEE3nvvPS6//HLee+89AILBYO9yHR0dnH/++Tz00EP84Ac/oKKiQoMKA4VTbzYeBX+wOLO6AmGoqoOGjTLfbAXDkm5vbsoiLeltsb/3Si4N3UA4e8FcZehRal3mfNsRj8j7YI30NePMcb7PRaFOCrOdmkbRuk6SXruk2DrTqls9shmM8++0eVP3IBGFhikweoo3+8lWW8E+PmX7zAtqI8pA4Pb/xkvtKvDWt+OOMc5OIgaVQW+Zp4VSihpa2f4/eLXbQBhqx2q2gqIoiqIoilJSRlRgobu7m+7ubj788EMOO+wwzj//fBYuXMjll1/O7rvvzvHHHw/Afffdx+GHH84NN9zAww8/zOabbz7ILR9EBss5GmuzXhfzps3o9Nq1qbMFCpw3v873cY/Hx74PpTym5eLMVsrHaWfa4ebAiUekv5iH0zFjvndz2BSKPcDQFRfn67ol8l2xnTOx9cVblzK0KIWzLxd9guIx6YPxHM5TO7lmI0daYM0iebZvt5CAd7ZjpGOJUkoiLbDinVS/7cc4E4/CuuXQucF9jMunWHo5ke3/w2Bc2xRFURRFURQlAyNKCqmiooKxY8ey44478t5773HMMcdQVVXFaaedRmdnJ2eddRYA++67L2+99RZXXnnlyA4qwOBptIZskkel1MJ26vc6C2Pmko0xv3emwDudQ/Z9iDSXLm1+oFPylcwEw9DeLIXAE4N4Pky/dnOsmP4baxObs9dZiEfEYdNbj6TI9m/qO8TbobPdmtVaTEKjirs+ZegwGHU6nNIjwRAwKvXskXhUnKSRVhg9ue8+RFuhu1OeTSHbfOukGLIdIy9jiUopjSyKeb5j6yQTNbZO+nEh/RdSRZmzyFsGa2xjWleOdRW4f6X435VNxkhrEClFZP78+QA0NTUxbsKkQW6NoiiKoihDkRGVsWCkjCorK3nqqacAuOuuu+ju7mbKlCk8++yzvPjii4TDYc4//3wNKkDhM6P6M9vRbBNKP2MyEILuuNzAmaCCfXa3PbhgbvLsMknxqPzeeXwGa7aZzmQrHwIp6YXK4OBkLRgbBHepI6M93RWHmjF9Z3XaHTaFzvaMNMPnC612OAmERHu+qrb42TxqC8pA45R8CTdCzTh59kowLDbnD/S9bpj3nbH09/nMyvZqY17sx22cc1u/Zj8MD4qZhVc/Ser11E9y77+9WQy2bWXKzOlKyBhmD4rnmwGRiMLapdDZVtzMn0JReUylxDQ1NREOhznllFPYfvvtmTVrFkuXLhvsZimKoiiKMgQZURkLyWQSn8/HvvvuyyeffMK3vvUtHnjgAV5//XXeeustfvzjHxMMBpkzZw5VVVVaUwG8zYxqXyM3ezWNoucK7nUSvM4CM9ssdGa/mXXWS5XtuxgkOq2MhGA4PZjgVijQfJ9WbDb1u2Q3JBLgnGQ3WLPNdCZbeZGtHxQ6O9Lr73LNojTa0xX+vpkCJujgq4SGcfJZpDllF1Xpy0aaLft3rifSIrOrI63Wd86infaAR742n+1YqC0oheLWrwqxVzPGGIeoGTsMJphtl+YLhiVTwe26kYhBdSqbr7o+fUyq8Ri8cF4XnOOlW5Zdtv3rU5TX5bozWJmPSnEpZjHg0amaI73rdvSLSCskNkCg1tqe/b9aIibLQHqGq1lu7RLJGBy/BYyemrs98agVSK8r43FDs4SUIjF16lTmz59Pc3Mz8+fP55RTTqGlJcMkEEVRFEVRlCyMqMCCCRRsuummfOUrX2H8+PHcd999bLrppmy66ab4fD5mz55NdXX1ILc0B8mkt+WKHRhJ9rh/HmmFnnjKedgI+NJvQDM6OHPsR6+Tvzrztt3ojECyC2IbIFQHXbb093gEKpOyPn+1tV+xNgg3yGfm83jE0sb2VVrFZo2sTKBa9tnvl236bf3GrCcRlcBLMDUz2wvm/DodsMrg4NXe3PAiNRJptrIbvNhHmj2FMptRIJSSYAql9sGxYKBa+rfTvnq6RZqowi/9/vP54hSdsLX0yWTA1sSedPsPj0nfRngMRNdCzWjrOCaisg2nPJQPy+bBCmT0cWL5rPWsXWpJNTmPc9Gvf/3oB24MZuA6mcy9P+V8/PJaVwHbjTSLRFeiVoouQ/5yJz3d1ut4RN4ne8BfZTlGu2JQWWU59s36axptwe1U+5NJy2ZDo62vOtvE9hpSEhaJjuxOxzRptKS1Xx1tEqzoI5uWpR/Yr2+mv9jHfrfPBuv/y3Ch2McvH1sqZrDWjDmJqPTpYMgxHqTa5cOyJX8VJFI2tH4l9HRCTxK6qyXzzr9B+pi/SqTCKoENq6Bho9Q2bTbZ2Q6RNll/aLT8JlkHNdXyOh8GUoIy3yCd2puShalTpzJ1qofAm6IoiqIoShZGVGDBsOuuu3Lttdeyww47sO222/ZmMhx99NGD3bShSc2YVFDB5lR03oAWMsvNzPa0OyTdbkD7/C4ky4VTzpeELR0+EAI6+0pG+P0QXZcKGJhZlqmMBF+lOHrs2zf72DDJCj5EWvq2LR6TIEc8BvjyCxQUqputDA2Ms60r7t0pEY9KP0wCNXXW54mo5ag368jlBMr2fSAEnzwFL14By16Rz8ZMg63nwRZHpS8bHi3BA2NvdtyyGOIxaFsF9RMg7Gi7sflIS3rtk0zHYijMMFWGFvGojAXJLpktbbBns9mDvpD7up5Mwj3fkT590MViEz3dYsd2CRhntpwT+9gUDMlj3QoZv8w4lOzOfi3ptfuktV/RFnnfHYeqOvffecWZheT8rNgBOqW8yHdChP0/kr3P+kMQ70ifsBEIWfYRbhA7rW1Iraddgg2jJsqYMXamBBXqJqS+j0LU9l+wq0N+Y7YV6MeEIrdMVyfFyjQoZtaIoiiKoiiKohSBERlYCAQCnH766VRUSImJYSV5ZL95GShndE1jugxDpsLFRmfZy42VkY7wIbOeA2HL0e+8AbXjFnxY/Un6Mk6960BIblD9/tTNYep3JkBhDyT0KdAcs5az3xyb7wB8flkm30CBl5tVZehi+lMw6t1RYJcvCjr6oj0LwC3QkIjKLM4kVp+y24npsyvegOcvgyUvyOdme60fwzO/o+rFy/luz67c4zswVUC2NrsMi7MtiQ6oCknRTmM7/qCjgLpL8ATSpWPM/tepJITighmHTNaL6Tum70dbUn3MVgDZXHOr66A7YQW57NJ5+CzJLpNdk+263tMN930fPn5c3l9/EOz3S9h4D3GO2m3HTSapj3ySbaypabSC22acMhkLXh2ZRtbP7bpSKlTOpTwx/9GSWP0gb6k+x/+cTIEGt/9IzvXQJf05EZOC5ivehIUPQcd6GLuFZNF1byLBsI52qK61+n/DRlamQjwqQYekraxcogMqKq3s00RHqt0dBUyCcQmmOSlWVoMZR4fTfYuiKIqiKIoypBmRgQWgN6gw7CillnEmR0e2NtidlmuXWbIlYN3AmmLIdhIxSKRmkyWBgE2SqNeB4hJEyDT7zdDyCXQ1Suq7fWb3qIl9nfjZAgnOQAeI9JKZtW3a4fPbHEe+vtvIhpebVWXw6a+TLB95iTSpoBYrw8YEE+z25pQbisdS8i4d0N1l1UMx33/8FLxwGSx7Vd5XBmHOKbDb98Vx885t8Pr1+JoXcjiPc3jycXruvB3mnArbnSjLm22bAEbNmJSjydaWmtEQWQsVyOc+LAcPwLrl0LY8tawjYGGcVvGoe2HLwQisKuWJGYdMIMru8ARrtnIi1YfsdXbAsrU+9XVq+gZ9M13Xk0l4+GfiDK2sgnGzYOVb8MAPYcZBsMdPU9d5Y6O2MTbNQevo57EN4gw1WXJpwYlUloWXeiVme+C9+HN/iEeswKEpaq+BhfIhHhWJIJBxIlSf/zlyZvasW27977MXVzaZNsE698C0D+m/S16UoNxHj0JsrfX9/Hus15VVMGZTaJwhNjZxGxi1MVTVSztia8WGuyqoSnbIb9YvhXCdZEQYmbFEhzzHo9DVSZ9gSNqxyjMzw55poIE1RVEURVEUZRgxYgMLw5ZSpEmbmyDjDMgmT5KpDU7Zkng03bHjtr6ODdDdARUboG6cOEzsN6CRVgk+JGqhIUOWAcCYjYEWeZ3slu36qyX9PdYKaxcDPhizWfabPGfGhH1b8ZjUc+g9Bi7tKEagQOsulB/F1ld2zrS24yYVZH7jlEFy1jAIhqCrVmywulq02X2V8Mkz8Myl6RkKJqBQP8n6/Y5fhR3OJP7RM7x826XsxmtUrngdVrwOT18MO38Dtj9dghbGtuMhy5Fi2hJukofJZKhqTM3ATG2nq8OSL3Nea4zTKps8khaJzU0iCtTnXGxIEwyLc70rbkmo2AMAwdr07B234ID5jZErM7OwndfyTH3trZvhtesAHxz9V9jiUHj2T/DsH2DRw7D0JZi2H2x9LEzbx5qZHU3VK3E6+xNRkR3z+8UJ6g+kB9ETUWvGtZf/AiZ4UeH3Xvy5Pxj7NBJQKudSXgTDUFXbN2PBC/Zxy8jfRZqt/3219n4cS9Wm2iCTL5xjFcDnH8D9P4K2ZdZn4UbY4jAYNQWaF8KaD6F5kYwZaz6Ux4f3ZmxiNdAbjrjF9kX9ZDj0DzDzACu7wRkM6bO/HjNQzX+2YDj9uAxUTQZFURRFURRFKTEaWBhuFLO4nsHpDMg1q7F3hnTUeu8mWxJNOUfs27E7d6rrINaTfmNqzxowjshER3p9A/v+J3sgEWV28n0mJj/H/0YE2pdDZI3MWOvckN720Gho2Fj05MfOlGDDqMlQO0EcUb5KWS7Skv47t0CCF/INFGjdhfKj2ME850xr85k9W8juJDXZCZEWkVWyy48Zos3ikAyNhqYx0lebF8Ezv4cP75NlKoMw98uw63fTAwp2fD56Nv4Cv6mM05hs5V+7Lsb/9k3QvhoevxBeuBz2+Alsti+9GvAg20vEpKaCWw2IhG3/RqW27a9Ov9bYZZByFaZVh2V2TJZVueE2k9fL7F63ZeJRmRUdrpfgtb0v2aW07J9BetDOZNNlqq+Q7RqciMJTF8nrfX4GWx4pr/f6CWy2N9z9LVj7Kbx/lzz8Idhkd5i6m8i8tFZAZaXsx4bV4oxMRKG7U9qQ7JZxasczrW32Br8zZPS40dHWt+h67/pcbM4ul1PrcRsGY5+19epQLQbFnvkeCEODrZCrWb/5L5dtO2njVsoujM3VOmwlEJIsAZ/fCo6B1X+fvgRev14+C42BWYfDlkfDxrvJf1A7Pd2w7jMr0LDmQ1izUN53deCJtmXw7xMlML7b9yXoYQ+GRJqtOmImOOBVqtKeZWc/drG29LpkfX5XhHNrMoQ0M0JRFEVRFEUpIRpYUHJjnAE1dd4dds5Z3E5HZyAszoyeLuszu9M8ELIc+UkgmCqsZ88aCI8RZ0y0BZoXSLAgskZuKtcvlUyEtZ9S3R3nUrONd13aWjcRSEqhv9haeax8q+9yoTGw8e6w93my7fbVUBmQWeCjJqfvXzwG8Q3izG2YlMUh5hIocHNcmc8gP8kKlYYpPcUO5jlnWoNDTsLmFO3tE5Up6YhuKxMgslZkhwJhWP6m9KG6CfLda9eJPEuyR36/zfHi/GyYKuvwQItvDF17HI9/7x/De/+RugzNC+GR8ySwcNRfZNvRFkvWzEg39am7YKSbUs5c47QxD7s0jKfCtEpW8g2ADhRu2T9eMoLclom0QkUFNH8C7c0QGgW14y1HeSZpv1wOQ5NVEGkVDXfnddVcq1+5Bto/F5va9dvpy0zZCb71Eix5Sezww/tlzProMXnkw9u3wr6/gJkHynmNtIIv7j4L3HnMoq0yhmXCzebscjkRrIkDnuRgatQ+i0mxs+UyrT/WJs72SCuMnmxds+1Oa2NTAOuWWlJ4xhFvx8iJRVrkP1J4tPxn+uxZeOQXIoUHsMMZ0rezFRSvqJQJII3TYPNDrM97uvsEFjriXRz//54C4Paz96Y66JdlnroYXrseXr8BFj0G+10AU3exxp/1K6DClwouNFn7ANYy4B5szJRlF8qSMZaIwtql1phfcGChxP1DURRFURRFUdDAguKFXmdd0vtvvMwcdjpw7O/tztP2ZiuYEAzBx0/CZy/AhpWpmWqLLOkVF5IVAZb3NLKS8cyZuwP+ps1g9CbyaNjY2n48Aq2LofUTaP0o9Zx6RNaIbNKH90qK/jHXpLSsu+WwOOsvBEOWZIVdqsIeIDD0kbtwCTaYz7rj+d0gqjTM0MPYm13qKJOcRE+XOFbs0kKBMDR/DPH14jQZNVFkxT56BD57Pl1aYtq+4riZOLvw9lYGYfZJsPVx8Pz/g2f+AJ88AX/dDQ78rcw0DdRK4MM+67mzXYIfDRulHFUOzXrj0ArVpwcXyjkbYahoZ5dr29zGDS9jidsyZjZwbD2QlGLh9Rv17WPOPuUM2pn6DHaJoq6E2KRbQDgRlaDgy3+Tz/f8sVV/xE6FHzb5Amy2Fxx0Eax+TwIMCx6U8cY44Y3TPhCGQI31ujIAb90iAfT/nAEzD4ZDfy/Lm2s+ZO6PiZisozthGwNdgi3OmdV2uZwkOr4MJqXO0OqdVDJGnOp+v+WkzjR5JNIskyoAEi6O9t6JE6nJIqE6yV547g8SjAOROjryL7DpnlbwO18qKl36ZBedvtR2gzUQ9MvzoX+ALY6Ae78vAb7/ngXbngg7fl3GT3/qN84MA7dxyq1gtbMdwbD8r80UAHRKhxY6rmgGn6IoiqIoijIAaGBByQ97scdENL34slM2IdcNkFOOwk2ewqzTh2QnvHKtSK70CXL4ZGZo4zRonC4SEY3TYcxmdIYmcOYfnwTg7gP3xx+ozNCeGpiwtTwAfD7ru442WP463PMdaP0YbpkHx14DE2ZbMkjODIWGSX3lkZw3ot1xKzBh2uAmuwHiiHJqfedCbyyHJua82QNOtSHr80gLvYUmjTa63eb81dJ31i+Fl6+E+ffa+lgtbPclmQ3aNLN4ba4MiBN188Pg3u/CijfFXt7/Lxz+/ySrJxEVWSawOWejEhhxmzVuHDlpwUafc8uDQyb5HZ0hWjhu44aXscRtmZqmlBxQNbStgvoJYivGfqBvUNeMN856QoFQ+uz+ho36ZjWYa3sSePNfUsOkcTpsMy/3fvt8MGEbeex9rvsySZfA/u7fg6d+B6/8XTIfFj8Lu30X5p5mXSuc/dEub9OdkECJWXb9cmsfjT06Z1bb5XLsNqAMPKXO0LKv3/lfItN/i0AIgnXp9Uvs9GbB2OpTLX7SCirscIZkDGTLUigFm+0F33gWHvulZC6882/49Fk4+HcSgDdtj0fS/3ttWC3PXdWS1WuWy/Y/zQQMMwUAndKhhdZk0AwhRVEURVEUZQDQwIKSH3bHeDIlY2Qcfl6kSgrZnj8IXZ2iu/vatfL5jIMkVb1xmgQRxmxqzSpzEu9y/zwfquuluOaZj8Ltp4rT9NaT4LA/wJxTZRmToRBthfgKmS0eaki1IWYFKir8lsO0K25lWwTC1uw2czNqbihNpoK54XTesGea0WbWqQw++cw6DITTz7HdeZOIWX3GbV3dcVjxGrz2D1j+mvX52C2kAPM280rrtBm/JZzxMLx4pTg9P35cshcO+JU4aBIRCW40bJRdrsUeuARxBmfTtR/obAE3p60G8sqP0VPkYXAWLDaBBhPM6twggeTQaMtRGAzDKFswwTkL2WiZ+5Dr/Gspffi9zu2rCV9Mquol22H2l+CBH8GyV+Dp36WCeX+CSXP69kfTb7s6ZFyzH5d4O7S3wLjN0yXJMvVnlR4bGbhdWzOde7cZ+nZ6J05Uy++TSXj8V/LdF86Bfc8vfvu9UlUHh/0RZh1pZS/cfipsf4YE8fzVfYMF9kCcyVYw14IKv/yHcxu37GNFLunQ/owrQyWLTlEURVEURRmyaGChnHCbkeiGz+OMXa/r84wvfSaxcfwFQunfedH/7y0qF8p+sxOolhT8J34N790pn+3xQ7kBdR6HTHJIcZtmfDwCyYrc7QORX3ISDMMJN8EDP4EF98vN56p34cCLJGU+EZOZ5G0roCsKHeuhabpI0YTqU84sm+ZwICLPPtIlmSItlnSMPVMhzRnWbN0sZpspnasf5FuHodj9NB+SydzbL7Z9FGt9+c5md67OSB2BOOZ9qYUia6TvBEKwfhnc9EXJqgGpUbLF4bDjGTB5J2tfuuOZt5urxkK37fuuOFRkWH7nb8C0/eD+cyTAcf8PYKMdYMezoHaS7F94tDhrnHIX8ahlz/GUXfR0WcfYTRs/7fiG+h6/TEV3C+2nbs6eUgTyvPTTfK/1Pl/u/S62fQzWuNVpP+8hyznor5bv1q+QgHAymdJ9b4XqOrGveFQ+D4ZkLEom0yWSDCYAXuGH5/4k2WvjthLN9+5E9vZ5LTDrJqdkGLcFnHYPvP1vGSubF8ANh0ntlP1/CZUNVj0jfxASPRI4ia6V7Zt97+4Sm0x0iE0Gqm37mTov8ajUTbFnK9q+zko+Ts7BHGfKmWLbUaZzYv88HoWehNiLv7qv9KP9N8bW+khvRWXSham9YK77z/5Jxq1Rk+ELZ/cdC7xKIXV7mEDSZRururugO8Mx2ng3+Pozkh37+g3w+j9g0SOw98/kO3/KFuMRGWN7rw89loyRL3VNiZt6LJPSj4m/2nYsU4GIqlpcDcmM72B97/Uy6fV/h9qboiiKoiiKUiAaWFDyw202WjxizcoyTvNMTjxDIiYZD/b6A73fRVMFKAEq4IEfwkePAj44+GKY++US7FgeBEJw5OXwwnQpWPvqtVKH4ZA/QO1Y+X6DkaSpgsjn8tqeKm9wO572GemBsDVzNNIimrxxl0K2/ZnRpnUYBoZ8zlEiKjZkn7lo6hJ0Jay6BNFm6SvRdUCPSHStXwo1Y2H708VW6ibK73s8OF6KTdMMOP0Bkbl48rcSYPh8vswInbE/TN3V3dlhirfb5TRireKk7Yqly9TYf2MPbDqvQbnkKfIh0iz2WNOos0DLCbdxJ+28h6wHyDgTa4b1q2HCljB2OoyaZBVktf/OrCvZnd73jKO9q0Oclb3ZCj8Fn8cgdjHwVYjE2RaHwRO/gTf+Be/eLhJJc78MG+8uWX4mWym2DtpXp2Se1sLYMZL5Z4rpZiIRSxWX75T3bjKImVCpsPIj0zlJ+18QlqCCsYO44/+bKcIM4lSPrhU7Sgs62P7XJFIBvpaP4KUr5bMDf1tefaKqVmqWzDoC7j1bxtV7viWZf9t/BTY/VLIVzH80g5F3MseqbYVcM6KtMMo2ltuloPxBCVCAFG32AeHUOk0g0wQfwo35/c/TLDpFURRFURSlxGhgQek/2YoNuxW3NLOv4sn0+gOGeAwS7eJEfeg8WPG6OBKPvAJmHT5w+5UNnw92/z40zoAHfgwfPyFO3WOuFvmJ8bNkX7s60mVrnPIZ9kLOxhlmnKr2LAa71JRbIdv+SFLojefA4OUcmdmLvRrvNmdPICzFjk1dArO+9Stgwwrph23LpCj5qXeLdEs5UFEJu3wTZhwI930flrwI79wqj6o6CS5svDtssrtozFf4U85fR/sToZQsWKKvNj7YajCY5R3XoHwyqnIRaYHujlRwoSn38kppsRdOrgyKo99kfflD7v0F5LPOKFTXSHYZWIGHeMy6Pkda5dnU+7FLiZlgQ2UAXrxCAl+Td4Tp+5dyjzMTGi1yLtudLPJIq96Rdr14BQRqYKPtYfIOUksoPFZmWZtAQs2YvgVqnQRCYtOVVVa5E68yiDrWlB/mnEB6FqT9XAXC6VKTTud5dC30dEJPUvpEZaqwecDhSPf5ZT2BkMyQf+g8yZ6btp846suRTfeU7IWnfwev/wvWfAgP/RSe+yPMPllqQtgDBXYCYbHHRHt6hkE8dc2wBxd6rzm2SSVgSY/SJZlE8Q6ZWKCTQBRFURRFUZQyQQMLijeMwzNTBkKsLd0h4ebEszv6apoc39luzIIhWNcB935PbuKCtXDc9eJ4LDe2OFRmsN1+Sqqo8/Ew75+SLh8Ii4MruhbwpY6frfCfs5CzcYC6FbGG9GPqVbbIC8ZBrSnuxcVZ2NSLBIiZJZpEnHdOmYmuGPiS6cGGrphk9bStKL+ggp3GafDle+DtW+HD+2HJC6Jnv+gReYBLoGFbOQ5g9f/qem+OyUAoNZM8btmdW2CvEFuqabQyFpTBJR6VTC5TEJYOIGlJ2flDfZ3lJmgQCMHYmbBhFdRNSF8mmRSne3cnVAREzq66Tpym9ln6AIFaCe69/z95v+/5g3893Wiu1AR6598pe3tR7O3TZ+QB0u+n7CLOU6e9ZSIYlqLU9vE9Vy0GUK33ciBbrQRngeBsgXDnd4Fq2LAOqkelJIHo+9/PH5T/dmYm/gf3wCdPSiDwoIsG316yUVULB/5GZDhf/6dkqbavhuf/DC//DbY6BuaeAmNmyPL2bI6aMZJlag862IMJzmOZcEwqMdKj8ahkK/oD+WXdmf8UkWYrYKT2pyiKoiiKohQRDSwo3jA3J5luaEL16e/dJH6yzRiOtMpMrUStpNDflwoq1IyDE26UmczlyqQ5cEaqqPPKt+CmY2DX78KeP5bva8eJU8ofTD9+9noV5n02MgUclPLELiUB+c3ora0Xh6idyFqoqICkz1rH5/PhrrPKP6hg8FXITOrtTpZaDqvfhU+fh8+edw80jJ0Fp98nRdBN0NHIyxjHrrPWgp14R2ZHjH2WtVcnjd0xp5kK5UG0FRrGWpJFlUGZBZ3EmlEfaU131HXFJFiQiMns3/CYlMRPKjMh0gy3fQnaV0mthElzYOJsmDAbGjez1mPq3tSNgwd/JDr0m+4pj4TH2gmlpKIyi72lAg0fPy4PEHs7/kYJsrhlExqcY5GX4JzKIA0+2c5Bf7JJAiEpkB7bIPbnDIrb//u1rZC6Ba9eK9/t+h0JOg8FQqOlDsSu35Ig4kt/hdXvwdu3yGPj3WGrY2GzvaFuvPwmV6ais17FaJcizyBB7JrG/LPuzHk1dbrM/xEN8imKoiiKoihFQgMLijfMzYnzhsYUYXbKQ7iuIxVsMDUZTLG4YMhyAPmQ71a/J2++8iDUTyzuvpSC+klw2r1SzPn9u2Qm26KH4bA/i251uEEcTb647L85FprOPnxxOmq8OG2MEyIRFU1nUyA1EIaa0bB+JVQg33/6HPznq1IccvSmcOr/yjuo4KSiEiZuJ49dvy0zzFe/Zzk+P30W1syH/30TTry5r169PQPKOIVrxlhZBImYBBW6ElCbQQYn1yxrJ+ocLT98pI8tiZiMReba2r7G6idgywjypwcberokAFxRAXd8GdYulu+WvyYPQ90kmLy9zO4ftyWM3xr++zWRw6sMwn4XDNSe50cfe+txt7f7z4Zjr8seWLBjr69g3rs5LFUGafCxnwNn9kI2B3giatVYCITFzm47BVo+hjGbQMPGUL8RNEyF0RtD0+bpv/eHYNlr8Np18OEDVjbRuK3EUT/UqAzCtsfDNvNgyUvw0lVSy+SzlC2N3QK++ljm39sn0gRClixSsccU+zm2n3sdx0YUS5Ysobm5mfnz5w92UxRFURRFGaZoYEHxRqabTpPiXuHPY9ZvTGZKtq+B2tSs3/AYufkMhqD109RnjeKU7yqDmZ9eCIThmGtgy6Pg/h/C5x/APw+Hvc+VDAZfW/a6E5mOn5eZ2ZCf1ER/ZClU0sIbfeQi8jhWkWZYtxwCVZYzJ5yyle4uePFK0XxO9ojs1nHXWxITQ5WKSpkVPnG2zAhd+Q5cf4hkLzz7J9jzR+J86eqw6rQYu1i3XDS+I61WYME4jWsz2JZxRucjwTGSnKNDxc5DNpkjL5lyvYEHWyHarpg8d3fBfT+ElkVib8deDeuXwfLX5fH5fJE8mr8C5t/r2E4NnHiTSBANBTLZ26fPyWzyfc51/51zPLJn/kBmh2V/6gApxcF+DpzSRwY3u49HRd4n2gqVUXjgHFj8tHzXtgx4ru+2asdLwHv0JrDiDWheaH03dTepTbDFYSItNlTx+WCTL8hj7afwxo3w+j8k2/b5y2Dv8/r+JhGFjrXQ3S0yn8GQjFu+1He9/w1d/ve51S7Lhj2AUNOUfp5Hyjg2wlmyZAmzZs0iGpXrczgcpqlJsy0VRVEURSkuGlhQcpOtvkKugqhOx7nJcOhog+pa6OoSx599pnbLx/LboSg14vPBFofDlJ3h/nNgwQPwxK9h4cNw+J/lZjtT3Qm3G8V4VJym/tTNd7YbwXxmofVnxtpwm+1Wbg7URFQcDZ3rIdolDk7TrAo/PPwzePcOeT/ny3DI72QGZalY86E4XCdsXbptuDFxWzj0Urjne/DU76To7ITZMrsz0pI6XymnS80YK2MB5HvzvphZQeXmHO0t9t1V/HUPlp1ns0fzHVXWZ7mcY0ZCC1I1GJzbS8kiJaPw9EWw9CUJEnzpNpi0nSwz55TU7yNSDHlZKtCw/DWRdgmNluUn71jIHltE1sC9Z0vgfZt5EqSurs/5s6Jgt7dn/wBTdoLp+6bXkgBbYfmYZYNuGQuF4Hbuy+36PFxwC5ImorB2mfV/wxzvYFgyFpIJeOkK+PA+sZkjL5fgdutiyfAxz7G1UoOgfbXYE4gTfdvjJaAwbkv53XBi9Caw3y9g4jZw5xnw/OUw+0uSwWEn2iqyZD0Jq6BzIATxdli/QrIO7QE7u23l+r/tJFNh7kLHsbQMCM22HQo0NzcTjUa56aabmDVrFk1NTUydOnWwm6UoiqIoyjBDAwtDjWL+sfd6w+5WX8EeMMgWAHA6zk2GQ3i0laEAKUdhqqBddI18VjO2f/vnhWQSWj6SY1BfRBmZmrEw719SOPOhc2HZK3DdgVIAcPvTZZlsMlLGmZOIZpdzsZPJUeB2jvsz83owZ20nohCJF9fJVC6Bkl4ncRRCoySjp67J0mqPtsDtX5ZaBL4KOOA3sPM3gBI6aD64W4qo93TB9ANgr59Cw8zSbc/JdieLhMYb/5JaEqc/KNebRJtISeCX4EEgBONmWL+LtEJPRyq4MAQDlF7p7bsuDvP+Mlh2nskeE1FYu1SuhxUFjH3xmDju/Km/PWbsCYRkW69eDQvul+Dd8f+0ggp2gjWio77x7tZnG1bJOqpH5d8mOy0fS52edUvk/Yo34IlfwRZHwHZfkqLmpS5wa7e3/34NznpSHMKdG2DD51JLwleZLiPVW28h1bZcs9+z4Xbuy+X6PNTxIn0Ut/3fqHNk2/mr4f3/wguXy2eH/h62PcF9W7F1qUDDJzKTP9wIWx8LVQMUJBtMZh0Fm+wh0mKP/gKO/5f1XSIK0XXy2l8t/4VNfYXYWsnecAbs7EGEfOtsZSrMXSh2W9TAwpBi1qxZzJ2bO5vuwwULgIaSt0dRFEVRlOGFBhaGGsX8Y+/1ht2tvoIzYJBJ0sd5c2TeV9UBSbmpMlro9hssKJ1DsKcLlr0Kix4VmZX1SwGf3PjufrboBBcDnw9mnwQbfwHu/Y5ITNz/A3FeHfmX1CzZbkgkrBnpkJ6l4KuUY1WbQwYJMjsK3M5xf2ZeD+asbdNHiulkGmx5m2QPrPsMVrwDHeskgBBbCxtWitOyY504BiKfy7LBOvjidTDjgNTvS9Sut26BB39ibeCjR+GjxwhseQzjk3uy2jeuRBt2cPDFsPJtefz363DmQ6kATLvIIjlndUJ6BoMXubGhSm/fzaOYp1cGy84z2aPd6Vnj/C4iwemu1HkON6ZnyJlxx++XLLkau7MuBC//DV6/Xt4fdQVM28d7e+smFLafdpa+IrOcO9aJXv3sk+C9/4gk07u3y6Npc5hzMmxzvEgHlgq7vd15Opz8HznmoTp5bhjn/VqZb1AgGIb2ZqlFlLD9JrbekjhTCsPLuTDntc6WQWps8fMPpIYUwI5nwdwvZ95WqAFCc6To+UjD5xMbunovyexY+BBstKM1caa6DroTkuUEltThqEmSzdCbHZxnEMEQaZb/tP4QjJ4q6y7Wf5zB/q+klIympibC4TBfPfNM9vvFfwBYunQZM6ZtMrgNUxRFURRlSKCBhXLCy2xE+x/7ZD89il5vEtwcTM7fuqVtm+V63yfT37c3i26vD3FY+BLy+YbV8mwyFno8ynxE1rh/nuihKtnBDrxD4L6b4bNnZAamoTIgN3rv/UdmaG9+qDhwxs7ytl0TCMnG4X+GBQ/BE7+Bjx6Dq3aFA38N47eVm/euGNSNl2W745YDrWFc/5yh+dwIGidcrtmlXmfNeumf+fbhYChVzyPc/9m75ve5imj3187sJFIyYIFqOcbtn8OtJ8Dq9739vnE6HHcDjNvCKoDp1T68Ltf+Obx1Mzz7R3m/9XHi6Hz5b/DRo1R+cBfXcTf3+/aH9ZtAw/js6/N8njIs5/NLIOW6A2DV2/DguXDQbyFucw4HqtPPU3iMVXNi/VKRmQjWDs0Zz9mOn+m7PW0Du107xbQPyBzQsDs9kzbpr2S32FWiHTrWQ3KUONUC1ZY2fCJmBV+M9J7hndvgyd/I6/0uEPmh7njm9nndX6/29va/4ZHzZZvjt4Ej/p/0322PF+f++/+VAHjzAnj0/0Rab/oBIpU0Zee+Rc2Nw7JQ7Pa24i14/Fcpe0sdw0DI/Ri49Rcv449zJn0w3NcBHupnNshQwGu/KnTcyySjY5ck8lfLw3wej4hsz/plcPtpch3d5Asi+dPd6b4dr/thl9fKhr8q9zIg/SjnMt3W6+4EdGfJ9utY7227zmxTgDGbSWbqa9fBwz+Hk++U81aVqunjWty8VrIT3aQx8wmOR1rl/20iZtVV8BIk9nT/UWOtJ9t5LvaYoJScqVOnMn/+fFas+pwLHpZ7sJaWZg0sKIqiKIriCQ0sDDXsf+z7SzFnrWdzILgVoYunnOlJUrOKY6nigGshkgoshPuZsRBbB588SeDjp7iz52WCJGBh6ruqepi6ixS+3Wh7kZ947R+imz3/HqmJsN2XYPuvyOy7/uKrgJ2/DpvtDXd/W3S67/kuzDwEdv4m+LulvVV1KVkTX2H68F7kDjIxFCQngjVQO4TlFOJRcdQkOuTm+7ZTJKjgq4DacVKDo3aCBJlqJ8hs6LoJ8nndBAm2OR2JxSSZhFeukSACwJxTJYvH54NDLoHPT6P7+SsILHuJo5MPk7zhWdHM3vGr7g6WYjFqChz9N7j1RHjjnxL0m2t072PWIxjq23eTjudMqJZ7eWOXxqHb8V0IArWS4WUKe5vPjQPTrX989Lhch0Guz7t8o6S7kIaxtSd/K+832xsOushqu88nckyTtpPC5R89IZkLn38gtXsWPCBa9Uf/Va4PxWTUFDjqr/Dvk8TeJu8gMkmJqGSGGNzszY6X8cc57jj/S+gs6eLgDKD3Oqur3c9RIvW/rSsB950Nbcslm+aYq4d2weWBYs8fSVBw7WJ482bY60e5f+OWHQzeijb31kKrtiSnEtH0zB9FycLUqVMZN2ESPPzwYDdFURRFUZQhhgYWlOKQ5kBwePDcshmiLX1nEcdjUnuhI5VN0B8ppDUfwv++BR3rqQQqgRWMY9y2++OfsgOM3woqKq3lx24ujtMVb8Fr18Pn74s0xrt3yMyz7U725uTv6pAZ3zVj3Qvsjd0cvvKgzAZ//jJY+KDc+O3zC5kpWFEpzhpTjDdfGZf+BAfUgVMYXh3S5ia/pwcCVSLrs/ItCI2B0++Hxmnpy5cygOBGMikzt1++Wt7v8i3Y4cz0mYzjtiRx+BWcd81/ObPnVjZPfAIvXiEZDjt/U4rcep1hmi+b7Q17/gSeuQQe/yWM2RRGb2plHFUGJHto1CRH0DNkq1PRnNnZORQCa8MRu/1Adlsy56jbEVgIhiDoUiMnmApmR1okcB2PWetd/gbccbqsb+vjYL//K+puZaWnGx67EN64Qd7PPhH2+FH6mGSnqk6WmX2iBCLfuxPm3ytBhttOgeOuh1GTi9vGaftY9vbAj6FxBoyZJhkiGz4XWalELTTYzlMhwTnnuOO0z3IrmD5YFLtwrv1/mWtgISb/Q575PXz2gmxz3g2lleEqJmbWfLHqkkSaZV1hj5Jc1aNgn/PEdl69Bnb5ugQ+s40xmfq6l6LN5toYDIsEUrHqKiiKoiiKoihKDjSwoAilnK1rnzUaabHed6yXGy1Iv6GKt8tzocWb13wI//0mdLZBw8YkZhzCt1/flM+YzN27zcTflSXFfdJ2IkWx9GV440aRnzCO0x2/CtP2E8klo3+/YRVsWCHP7astWaSqOjj4d5IV4aQyAHufC1N2EnmBxU+LY3T/C2HsDPmtuYn0MlPNTn+CA+rAKYx4VPpapAVGT8l8DHuLoHeKs27RIxJMOuHGvkGFgaanGx75Obx5k7zf44cSTMvA276t+F7Fr7n30FaCL/w/aP0YnrpIipWfeGvp6qN84WxY+aYcu/vPgRNukc9Do63il8Z5bAI5iRiE6iHWJsUyM83g1MBa/ylkHLEHdCC7M8ycowpb8CreAYl4KviawfFm9M3N9y0fS/ZLIiIBq6OuoHTFShwkYnD3d6RmCcAXzpGAnFcH6Pit5LHDmXDnV0Tq699fguP+IVJpxcRub3eeAV++R5zNiQ5I+mVigB3nuXTrC/3JqhvJFFpfyz45Aaz/YgmTMVrr/rtACF6/Ad68Ud4feYVI8A0FPp8vWRbJpMh4Td6x8HW1fASvXiuBvAo/7P59mHta5iCgndknyZi68m14/EI49A+FjTG55BpBM30URVEURVGUQUMDCyMV5yzRtUtF1x/6Fu3r702/qasQabGc5Aa7LycRhcXPS8FKyN85meyB9/8nmQDxdpiwDRz5F7oravjsjUXe1+PzSUBgi8PFofLilVJc95nfyyMXFZWicXvP98TZM2Fr9+Wm7QvH/1OCC0tekBvPY66GURul30RGWqSYZTyS++ZSnTQDTzAsusb+gLtD1NgSiKzEoofg7VsBHxzzt/45PYpBx3px0i98WNq07y9gq6Nz/87no2f6QbD5gSL58OyfoPUTuOEQCcBttg9ssntxCyb7KkQS6e/7iE3e+105hjWN4jSOtsr1xQQUOtulpkVoNNSktOcz2Yeb7ag8Un4UkvXhdIBlc4aZcxS31S9oWwmhVIaXCSDYA7PRtZIJZ4r/vvFPePJiyV6ZOBvm/VOc5Zk044tBogM+flyklxY/LcHpyioJYrsFn70wajKccBP856syZt5xGnzlof7XWLDjtLcnfi3O0VAtxNqlloUd+7nM1Bc0M6gwCnUU2ycnJGIQ3yATGWrHi6M80zloWylZNQB7/ww2P7h/7c9FPApty0QCM9TgPWMvEZNAwvLXJJtn9XvQ/JFVg+jfp8h/wU33wDd5dyqS3fT4cgQF1i6WQMKiRyWr0NDTBU9fAp89L3aRSxLKVwEH/gb+eQS8dYtIX846wtt+uZEtg1UzfRRFURRFUZRBQgMLIxXnzEJTLLgu3Pd7c3OSiEp6tZn5aQrDecWezh0ISZFNM4N0xZsSEJh/j7yvGQdNm3tf96p34cGfyk0liMPoiMtSs/+zFOjLhq8CZh4M0/eHD+4RPez21Zbefd0EqJsox6FugqWJH6iWG8lIc+aC0obe4MKX4bPnZNb3kVekFxbON2vBK+o0zY2XgtaBMIyenL3GSE+XOHFGTxG5LIBJc6RQ+GCy4i24+1tSY6QikHJ07prfOir8Ukh28k5w+ynQtkIkxN69Qxy2G+8mNjTjANHo7i+hBnEG//NwqVVy3YFw6O9h2xPAHxOHUjwluxZZC9X1cp3JVrMlky3kcoKqDQn24Jkpru4VN4dYrm1FN1jvYy3Q2WPNprZfL6NroacTomuJ+kIkn/szNS+lipI3zYCTbitdbZCeLvj0efjgfxK0M5l4IH3x2KslqBhtybiKnNSOh+P/BTcdK1l0y1+Dhqn9bnoaoQYZS288WgLgwRBE/VDnklHoPJdu10SdSV0Y5tjmK+1j/98VT03qqKxOBRVMFkPU9t8sdV6WvAg9CRmn9vgh9MSLty9OVr4Dd55uFUyu8IvkUE2T/BesGQu1YyGceo6tk2v/qndgzUIriGBn071kHe/f1btsFVdyO2He9G1D5XvLYMbe8h8umZRM14UPwYIHYc1824p8Mn7tdBY0L5KaKJ8+B0/9TopY52Kj7aVW0Zs3ivTa0VfJWGXH/LdOxMAfzlxfq1T/BRVFURRFURSlH2hgYaTidnNfZ3MKuH0fj6ZmAK+DZEP+M6JM5oKhqwPevxvev1NSxQ1zToH9LvBWNLmjDZ79A7zxL8lYCNRIAc5tj5eb02JQ4Yetj4WtjpFtOFPgexLp7zs3WAUuJ2yTe/3T9pUCnP/5qkgujZoiUkl2Ym1ys5mNfJ2cOnM0N16PUTZbsNtSICxOhacvkWDa+uWSoTLQrP1Msgyev0z6b8NU6YMTZ0uNkEIYvTF89XFY9ip8/KTM0F63BD55Sh6PnA9NMyXAsNWxIudSKBO3ha8/K0GRJS/C/74J1Q2w6R7pkjfBasmKcstEMJJIwZrM5zmTE9TYWiIqwZORbkP24FmpZLCc2+rFB1U2J5vdkRqmN2Oh54UrqDVBhT1/LBJExa4HkkzCijfEtj64R7IiDPWTYYtDRXpp8o7F23ZotGQ9vP9fcdBudWxx1mtn0nbyHFkD3V3QMCndzpxkG4t0JvXA4pTRSYSsGe/xSKreVSwlE2ertxBJjQMNGxevToEbK9+BO74s/5v81fK/sKdLJnG0rwbez72OcBOM3xLGby0ZouO3lkkeIHJenz4Hnz5L8tMXqOtcz57Jl+GRl+ERpO5VVyes/dRan68SpuwsY9X0/azi6BNny//Su78Nb90kv93xzNztO+i3sk9v3wr//YYc9x3OsL63/7cOdcs5cgsceKm1oCiKoiiKoigDjAYWRiq5Zom63fwHw1BVKzddpihmNuIyCy7pr06XuWhegO/dO+Dtf8uNFIhzbsujYeevywy5XCSTMhP0id9YWQEzDoIv/EBmtJUCn8+qCZGNVe8CSajfyLuTbdYRcMjvJOvi6d9B7bj0G89Qfe515Bso0JmjuSnGMbLbknFmT9kJlr4CH/wXdv1OcdqajWSPFKv96FFY+IjUDjFsfqjM+K8e1f/tVAZh493lsc/PRVLi02dFUmLpK9C8UB4v/Q32PR92/kbhTqvRG4vm+31nS0Du3u/DN56zbG79sr4F4g2JqNSVSNj0yt2Cd7kKPSfJf4b+cGQgryXBMCRsM5RHTQJ/heVsC9pqLQRDIoH05k3UvvA7+WyPH8He52XfRjIpwbDWxTLmBWut50CN9TpYI4HmNQtTwYT/SjDNEBoDsw6HLY+SmculKsg+YbZsf9XbuZcthKp6ca62rxbN+Y3mWpKJkZbUMbdp9bc3W7Y3usgZFErhmCBDPGLNkK8MgA/px3aHdWcqw6aY0lpO7EGFjXYQ6cjKgEjaRdZIYC62Tl7bH4EwjN9GAswTtpGsg66Y+zbqJsA2x8E2x9HZ2cm5V/6H7ZPvcPL4T6hY9TasSY2F/irYZE/Y/BDJUMgU+Ju+v9RZeP4yePxXEsiYsnP2/azww1FXij28+neRHuzcIOsB6791RaVkLLgFDuKRlNRfVJbx+bLXLvFCsQuCK4qiKIqiKCMSDSwMJ0otyxEIp+SPbNvItk2Ttt3VITdpix7lg+u/x1Zh2yzOUVNg+69IloJXJ3zzIpn9vORFeT9mGhz4a5k9Vg6sfEeeJ87O73fbfwXa10gGxv0/lDT+LY/KPUvNKUMC4jTI1Q+cTlOVdelLsKa4xyIeFYfbxnuIo/29u0oXWEjEYPGzsOhhqRVil+XyVcos563F4VKSGak+H4zZTBw/u3xLHESfPAXv/UcCHI9fKFkbh/+5cKdGRSUccolIwKxZAPd+D064WbZt6rdkqskbaxPZMprlvHgJ3hmMI722Xm0FBm4WurlG2bflr4Zwbd/6Cia48N5/JOgEsPM3cwcVlr4Cj/9a+pQXzCxrQyAszslZR8ImX8itw14MTGbcqvckiFiKAEbj9PTAAsjx7pUeswUWfI5nL+j4M3CY/2ZJ5BpaNabvMY9H5DmUI1OyUNyCCmYcMFKTUNysogo/830zme+bybwv7UZ1d5vUS/BVwqZ7OjI7opnXs/M3ZbxZ+JBkmn7lQal5kg1fBRxyqQTpnvsjPHaBZIvse74c+1wSZtFWWLdUrjX1EyAeSj9nhWSgFloQXG1VURRFURRFsaGBheHEQEjbOLcRj6akf1pFZz4tCyIks97euhlevRbf+qVsZb6evh/s8FWZ/eWUFsq27Rcuh1f+LvIt/irY7Xuw09fkda56BgPFqgIDCyASHdEWeP16uOssOYaT5roX6zOYc9IVtxyefoc8i5cbwVL1n+FyE1qM/QiGJeizyRekL69+TxwUxQqKta2ET56UQMInT6fP4qyqk4LKMw6QZy9SY8Uk1CBFobc8Cl77hzhW5t8jetbHXQ+NMwpbbyAMx14L1+4vjp6XroJtT7RmrjuDZ0ZPPFQvwQV/MDVjN4/MA5VzGRzMNarDVq+gV3M85NAgD4le+v++CSRh+9OlkGqmIJrRT1/4sLz3V8Nme4kjrzMiAcF4uzhcOzdYckxdHVKfZNo+Ipc34wDpG2lyTSWmaaYUg+5skwLqjdOLv43GaeKEbfnI+swEc5ySSIEwxDvcxx/QeiYDiVvBXzNZoaYu9TqaXusjELKkkEoxTqx4K3NQYSAJjYYtDs//dz4fHHyxSAqumQ93fgVOvTv3+OHzSV2Gqjp4/JfyH2DBAyL9OX2/7P06iQTCKyogkKoLY59AUkjWWKGZZiqjqSiKoiiKotjQwEIOkskkvlLqyxaTUstRJHvkxiYek2fzPtIKfr/IHwRCUJkqChhZA/d8B9+nz8nvQ6Nh9okw9zQYvYncyJqb12ysXy7ZCS9eaS0/dReZBV030dLGzTQz1F68uXMDfO5RLqIy6G25aftar3u6U1JIpHS0q9O37YWDLpZj9+F9cOcZMO8GcRR1tsvxNjdyplv6gxDvBpLQuV6Wq2qAmrAEYCoCcgPa2S7p9plmxhW7/xi7yTYrbjBtK5lpKruDXHr6vbOoQ9Yx7HXkOI5lMimf1U2SosaLnxYJk31/3ne7Xoq6didg6asiN/Tpc+kSRyD2sdk+ouveNMOykY51lgyZk2SOYud2e9qwCgI5ZkdHW/t+NmEbOPC3UmuieRFcd4BkLsw8OPu6wL1QZ+M0mfn56C9EHm3sLNGFd2ZBJWJio0bCyEgfVWfJPMjXoem1X3mlFDaSTOZuZzmOe8a+7E3v6YJgA+BLd3R//JRcP3u6JJi1988gtrbvOts/Fwffu3dI3/JViLNxxzOlaKyTQFiOXXc85bSNioyYKQLd2S6P9+5M/13rYmlL47T0jAKvxdLrc9RiGTcLVr4lmRaNm+VeX4+LHblhrhkmWLH6A0vSLVuALVRvK0pru3aCY3JCyvEN6QWFnfTXmenFLottu6Ug3za6Ffy1112IR2DdCvAHoCuROm8d1nU73CjXgkTMff35ts+eqTBxOzj0j1LjoKvTffkVb3jbbtPM3MvYx67mhRDIco0zGROZqPBLUfN/nwir34d7vwtHXJ75umk/LjudJXKXj/6fBOpuP1WuOfucL8fbGRAHqBkt///Md9HWdHsoJNhdyG98vvT/im77W45jh6IoiqIoilIyNLCQYsGCBVx99dWsWLGC7bbbjgMPPJC5c+fi8/nyCi50dnbS2WndILW1tZWqyX0ZjFm0gbBVyDG6FhLt4A+Jo/PesyHWKo6CfX8Bs0/Kv+jc+mXw6AWw9CV5XzteAgob71b0XSkK65elnChVhc8araiUQrq3rpUZov/7JnzxH1A/SeRk6ie4n2d/tXxflZKkiKccAVWB3LIwULr+U0DAYsDtKJvzOJeevvk+EUvpv6ccOeuXQdInzuuaxtR2YhLoCYdE/mvx0yLVss/PvN+Mt68WiaPFz0j/SAtY+cRpv8keMoO6aXNrvZkCCYPFuFkSTHj6Evj8Aylqucs3YY8fFlZ4fYcz5Hh+9Bg89FM44+G+y9hn6nqdIWt3aJr3Q2TW9KCOR6Wgt7CsLWPBbwu2mmvYZy/CbaeI83/GQXDwJX3lgeLt8Oq18Op1VmbPJl8QmZMxm2Zvh88nWXL+KiCHVEx3QmqMGAdpdQNM2VGcqsWUeZmwjQQWVrwF2x5fvPUaxqTGs9aPU5MLsvR/c83vive9diaT6dJ+kRZv9RgGsSbQkLYjp5SiM4MhEbOCCjVjZCzsist/CYBwEWssOIMKh182tOvT1E+Eo66C206V7Kixf4Vdv+Xtt1seJQH/py+BN/4lE0kWPwO7fw9mn2KTGo1ZwQS7zdntYaCzeZwFwRVFURRFUZQRjQYWgA8++IDddtuNPfbYg4aGBi677DIeeOABjj76aM4555y8ggsXX3wxF1544QC0ugR4ksuJQbIr3bFgbngSMehohef/Au/cKt+N3xqO+Vv+TvauOLz+D3j5GujuFKfENvNguy+lZwGUGy2L5LlxuneJJzf81XD8jfCvI0Uu58ajITwGaidIgGH0JjKbNtwomSCjNpLvRk2Uc9PVYWlfV9VDbRPEw4NzE1/ATeiA21G22bC59PTN9yBOMpD+mugQ2YJIqxVYCITEsRYIweYHSyHYdZ/JLOPJO2ZuXzIJb94ks6A/n5/+XWi0BNo22UOKJpey2GaxCY0WeZrX/wnz74aX/irOpyMvl76dDz4fHPZnuHY/cX4+eREc/qe+jrR8HSJ2B84Qk4Ao6/Go0GKja5dBPG59ZqRcjANuxVtw64kSLJi+vwSv7IGq7gS8cxu8+BcrK2jibNjp65LlUkwizVJHxWTa+aslwLfoUZEqm7SdXMvrJvZ/W+O3lmevM7zzpSk1hq/7DAI5AiLmP0Ew6n7ttNug13oMgyg/NqB2VGwnsbNgczwVSDAZDCbgUJvKsIuQkhtbJ58Xazxx1lQ49I/5/x9p/1ykynriMGUXCU6XqiC6VybvAPtfIHW/nvuTZAbOOMDbb6tHwUEXwTbHw8PniYzmE7+BD+6Bw/4EDRv3/b9tsNvDuiW5M1IVRVEURVEUpUSM+MBCIpHgkksu4bjjjuPaa68FYMmSJVx88cXcfPPNxGIxfv7zn3sOLpx33nmcc845ve/b2tqYMmVKSfehaDidZm43uJk0lUGCCnd9A5o/lPc7fQ32+Xn+szI/e0FurtZ9Ju8nbge7fbd0N0zJJJAszg1qcyqw0FRgtoKdqjo46d9wywnw+fsijxRZA6vfzfybjXeDY6+RWYb28zTENOEH3I6yzYbNdezMd2uXicOmKqVb7Q9JgKfONqM5GE4VDEbOz/T9xaH+7p3ZAwuv/UNmNgK9WQmb7ika8I0z+xfEGmwq/CI7M30/yTT47Hm44Qg45q/51ympaYQjL4NbT5LA5LR9RGrGKQXiJJszz3n+vcyaLhM9+LIejwotNuoPQJtNXisQgsgqyZZbuQLu+mqqQPoXYN4/0yVcIi1w52mwJjVGjd4E9viRZDVEi1yjZ+XbsOAhkaML1MCWR8oYtupdKRAdbZbnZa/BlJ1hy6Nh/FaFy4hMSAUWVn8g151iB+AbNhZb7eqAjvXpxZoz4WXcCTemlsszm3EAGVA7Klmto1Qmnaknk+l4mwyHjvXyvhjFm90KNWeSPnKjsz01o/9pS6pv6SvSdzb5ggTUB5PZJ0qtpDdvhPt/BCffAWM9SDMZJm0Hp90nv3/6EgkwXHcAzDlV6ohVj5Jrl5tEEnjLSHVSJmOUoiiKoiiKMvQZ8YGFQCDAypUre28Sk8kkU6dO5f/+7/+49NJLue+++9hkk004+eSTPWUsVFVVUVVVRHmDUuK8sXA6V91ucJ2OAjNTNNoM1x8GiYjMrD/8Mu+ztuy8ewc89kt5HW6CvX4igYVSabbG2+HFq8RhX1Uns/urR8kjPCb1ukGeQw25nTUtH8tzZ7sELPrb7trxcNYTMlOvbQVsWAEbVkqR3g0rUp+tlOfuuARlbjoOTvkvVNX031kzSDefA25H/Q28GIdnxwZx8idS7yHzOUjEJEAw/26ZoXjIJe7LrXwbnr5UXu/yLZj7Zembhq64+++GGlseKUWs//sNWLsYbp4Hpz+Qf5Bu073+P3tnHd/E/f/x58XaJHWllOLuLsMZgzE2GBvbGFO2MXc35vadu7ExY78xmKBjuLu7QwVoS12StrH7/fHJNWlJ26QtY3JPHuUi57nPfe7zltdbSCpt/Azm3ge3LRPtt7q24E8NEvD/OvmbZDb8rfujQKVtlMLbkhZimgFu54K9RBhLC07CnHtFpHViT5jwo8dIqvDn48KpYIyECx6AztdUXZunLuz+GQ7ME68jmwrZE6UGQ2J3aNhNFFlO2ySmqRvEX7PBbimwWjgKQxsKI3BJLuyeKe4T9YlWL44l5yhk7K1Y88FuFRlatekn6iKr4t0/nUNplr+0HdWH5JN33R+oWMMiqJIMXIUaDO7nQJddFAKHumUsOMpEceKlL4hnLe9Czf46FnKPw/qPxDGByMwxx4i2Y82B/XPg4AK46CX/65WcC4Y+LTJWUzfC7Dth0sLAgmo0WlFgvuMVQv5zz0zY8T2cWAk3/QFabdUSZL4yUmt6dvub9FEqKioqKioqKir/fP7zjgWbzUajRo3Izc2ltLSUoKAgXC4XCQkJPPTQQ9x5553MnDmT66677nzvav1TeWBRnYZrletwSyMVnBJOBa0Bbltec+G7qsg+LKaN+wkJi6BQYTQ/F7gcQoKlOFO8Ly0QfwVpVS8T0Rh63Vb1YDvcbWw5tgxm3Sz0chN71G0/JY04n6ENgO5en3vNI8vi3E0dJgxnmfuE0bpcJqSWzgF18OkfShvRaEUbcNiEZrUiOQEeOR59sDinGz+F9R+I70Liql63y4EIRZREgUdTPUSQ/l2JbQM3zRGa1em74Njy2mX/DH4Cji4Xxaz3z4GBnmjjs6SRoHYRn9VxHvXg64XaGGy9l4Ga7zmBOvNsVk/bqrBddx+04BEhORTfESbO9BjyvVEyFS55WxjxzxVKnxLeSMj3Vc6GkyRRxDm6hTDQ758jaoOcWCXOd9+7A3dKS5KQV9v5f7DwCZE9d+Fz9es4aTpQOBaWvSgixcsLAJe4pfeq6Ceq6oN8tcVA8O6f/i2a7/WRXehd9wfEa43u7GL2NouQ6nOUQnhD8ZksCwcdCEnHQPsbR5nIOju4QFzTNnc9lEa94cqvAvudMvbAug/E/oU1gk7jhfwRQIcr4dQ2YXjPSxbSd1dMrf2zZ13R6mHMR/DtpUKaaM8sUUcpUELihXxoq4vgt8ni2brgpMhCDU/0vYyva6amZ7d/eh+loqKioqKioqLyt+E8i5OeH3Jzczl48CBHjhzBYDBw++23M2/ePL788kskSUKj0eByuWjcuDEvvvgi8+bNY+fOned7t+sfg+nsYrR2q4jetbsHI+aYGoo0GkHSQcMuIpLUWcfoaZN74Bua4NswVF/IMuz5VUTD6YKh373Q/0HoMQk6XAEtLhQD4ZjWYqCnZCrkp8Kad6t2dlxwv3A8aA1CN3/mjfD7HcLQfy6RJGGUjXQXHc0+7JFBqlx8Fir+ztXh6xpRqYhyLpUBvEYnJHkiEoWjwWYVMgaKoSc/VUj9rHtPyDp0ugpunlf1+hN7iOsRGZa/7Jbu+hcTFAYthonX2Ydqtw6tQRRzBlGXwvuceUfoKoTECOdOSCXDW1XU1H78uXf+nfF1zwhkmdosXxPKvUjC7Wxz47KL+2xBmoiov26WyC7zhZKNUnqOi+82vkBMlRoO1RHRWEj9DXoMkESE984fa7fdAY9A/wfE6y1fCRm94nqUeBr6NJjjhIPmt9uh2N0GDMbq+wlf14PNAvmnhDyOd1sMBLV/8o1yXvRG8VeV9JG9BHCAzh1jZLMKKZ6D80GjF7KK/khEOm1wfCX88Rh82kcYxPfPFk6FkAbiuejq7wJ3Ksy7TzgVYlqL7FXFqQCgM0CTfqLdRDYT21r+kqihcr4wRkKfO8XrjZ8FJvdUGZtFTKNbiuxTWfJIlFpyPBlcVfVDNbWNf3ofpaKioqKioqKi8rfhP5exsHfvXm688UYcDgcHDx7kmWee4fnnn+eNN97goYcewmg0MnnyZDQaMZgKCQmhffv2mEz/wofv2kQ5+VoHiIjFqGYimjF9d+2jxpSCrdbs2i3vLydWw8nNgCSiyqLcBnm8dJO1horLWLJh0xdQnAFr34fek0WhPm80WhjwkNDc3fQF7PsdkteKv1YjYcCDYpB8rohuIYyxNovHkOArMs3f3/kfVpvhvGCzChkdCXGOlULN4DFiO21ikH9oISx+WhjTgkJF5HSn8TVvY+hTkLxGyKWcWAXNh5yroxFYsuDUDlEINn2XaJcDHhLX119BTBsxVTKYakPnq2HJc3BmvzgGpTCvIo/jbWjzvs79KmL/L8/kqU00qy8pvfo0+Cq/kd0KliLxkWxDP/dOUeDeHAfX/SocwVURngQntwjn3rkkoYuQQbGXCCd0eKOal2k6wC3h9Sns+kk4HbvdEFjmgkYLQ56EBp1h3gPifjFtpIgUT+xe8/I1YYqGq76F78fC4YWwqTV0nghIntoxcHab8HU92d1FhB12UTi4NujrWQKpJkf7+cbf7MOzsk99nCObRTy3oRO/nd4oioqveUd8P+IVIdlVFS4HpGwQmQlHFnlqMoBoi21GQZtLxHUXaP0qxalgs4jnpX73Vi0rpNGJZ7EVr8GZA7Blqsj4OV90vho2fS6ylmqbtQCinweReaoJEhkL4MkSVpx0VfVD6rObioqKioqKiorKX8R/KmNh//79DBkyhAsvvJAZM2bw+uuv8+KLL5KWlsaDDz7Ic889xx133MHTTz/Ntm3byM7O5vvvv6ekpITw8PDzvfv+4280ui+qinLyjpJSsORA1lGRqi07IK69+Dxjd+33XUnVt/gR6Vlbzhzw6F+3u6xiFFx1mGOEYyCqOThKhAHo9A7f84YmwPAX4KZ50PYyQBKD728ugfkPi9T9c4Fi+M1LFhIH9pKKkWnKtQFqpGd9YTAJbX59yNlRoUq0qEYPi54SxpKyIlGs9Y7V/jkVQEQ1d7tBvF79Dric9XsMJflwbAWsfht+vh6mXwkrXhHR04WnRJv+bbKIpK7vbfsi1suxUNuod2OkaN8AW7/2fG4wi/ZQlUHSn2j7f1ukdOU+Q2+CkNjaG23PZTSs3gSmaDSyiyddn6BNXScKCU+c6eUgrgIlY6E6ubv6QKuHKPe9OPuI/8u1HS2y5kDUadg8tXYZSm0vgUl/iP6gKB2+GwPLXqqfDJLGfeGSN8XrdR/AsaXgKoOC01W3m6quB4cdzFFekkoWd/aXpe77WRtstcyc+KuwZAuDtaUOgRfKObbkCseOOQoikyD3mKhJ43KIfqn35KrX4SiDH66AWTeJWgClBeL37XYDTPgJ7lwrZLga9aybU6Fh9+qdCgqmaOFQA2HMT14b2DbrE11Q3bMWZJcIfgFoORwi3DJVSnaQpPPUw/g39UMqKioqKioqKir/SP4zjoXs7Gzuuusurr/+et566y3at2/Pww8/zIgRIzh58iT79u1j0qRJzJkzh2+//ZZLL72UgQMH8sMPP/DLL78QH19NFOTfjbrIUCgGAKhoaLJZ3VFSXgPvwtNgPSOMkpLOU0ugLo4FRQrpHGUsSHknYMcPgCyMu80GBbYCgxn63SMiQl0O2PoN7KhGtiKiMYx6A26cDa0vFts9MAe+HgGLnhZGn/pEcSzkHHFrXlcylCjXBqhp8PWF3iR+58gk3wP8U9th2ghh8JC0MPhJuGlu9UWCfdHnDiETpNQNqCtnDoiimLNuhu8uhSVThHxFfiogQWxb6HItjHwdmvQX182mLzAsfJB4+Uzdt18dEY1FlLejTBgva4vijNn3u/+OVn+MNfVlOK+LE7g+qW2foRgplUjq+pY/qgpZ5l75GwawBVlrgGt+hITONS+ntLn8lHO7fyAkTEBk8QVCp/HQ5y7x+sAcWP9h7Zx5Ma1EAdn2l4u+YONn8OVgOLos8HVVpvtN0MtteF75OuSdFBr9gRo5jWFiWm7szjlbpuyvxFDLzIm/ivqoBaNk0UmI3wsgdTNMHw+2IpE5M+bj6jNldv8ssoQMIaKPuOZHuGsDXPQiJPWuXfFxONupcOn7/hdAbtJfyAqCkHMqyqhyVkl2IRWkiQyNDZ+I/qE+6Xy1yJxSshYCJXOfkFHTm6DpIOEEsmaJqd6dFalkJKjPcSoqKioqKioqKueZ/4wUkiRJXHzxxYwf74kQfuWVV1i8eDEZGRnk5ubSrl07PvvsM7Zt28aRI0coKyujffv2JCZWUTDtfFGTNEIgMhaKQUhvrFoqR5bFVAJMoe5lSsR7SSv0rM3R0KiXWDZjj39Rar40f5XidNYcMaCUNP5HfFZV38EBEEeYXIh+0TPCWBnRROjWe6fvV6a6ughRLUTked4JWPkapG2ANqOr/20uetEjkZS6QQzODy+CCdPBHOuZz9+BtMZHUc5It2Oh4KQ4d/pK6/orC/b5E2kbaDSuLNe8TKBFT6ujKukJX5+7nMJoU5IrDD/BYcLAsflLEYEY0UQUZWzYTRxDTVrQQWFnv+//gKizsP4jcS3pgqHEz+jrU9s9r7MOwabPxH4phCYI2QmNVuhiK9dh9mGIdkt+pW1Ck7mHz3mSz6UboPBC0NfQ1jV+djOV2++wKaI+yZavRAS2klkk+Wm0kp3Q9AJx3vNThPGoywTxna3EI4cUFFJxub9KQkKSzl/xWUmq2E687wvK5/60zQr7X8t7y1kFfH1s12b1mseEbu2bjJaX4ULCcfHbGBI6QWm+7/V7Gzkjm4ppftrZxk9f/ZEvSvL8m6/1KJEZV5wJ5viqi+Ce2nb2Z2EJ0GEc7JsNRxYLJ/5FL/nXlhylFd8PeVIUXV7zlugXfr5e9H0jXoFQPwImqtrmhW6ZsZR1sPgJmLxC3I+UZ4aqrgPlnqMLdsshBXuuI+WZQhfse1mf6/OzD/GnXzgXbbA+a+KExIDNVLf+W5GCCwoVx5u5D2bfIQqfx7SBcV+427Sj4nJK0XRHmXBSAQx4WBQnB9H/uZxCRs8fzuyv+D73uKdQc0xr6HEzZB3wP+Oh8JR4Bju1XWRfLH5W9CFanWizucfRZR3jdedxWnOcoDmVHKCSRkiYKQRH+LfdqvrxHjeL/n/DpyKoxN9AAknyyCA16iVqSdjdv4WEp9+wWb3qaJWI1776LX/PX322IxUVFRUVFRUVlf8U/5mMhejoaO69915atRIGshkzZvD888/z008/sXz5cn744Qdyc3P57rvvSEhIYNCgQVx00UV/P6eCPxjMQsbCH+OYMqCvHCGoN4qBpCKBpDMIe4+tRERNyU4hNRKWCHojst2KHN8BkEQUfnEtI5qVGgsuR/VG/wDRyQ6muN5HU5IDwZHQcXzto+pADK4Sunrkn46tELrYNUWWxrWDy94XRREjmwlj2Mo36s/4ENVcTItOC+OMrrI0TxURbn+XyOm/G1VFYVf1ub0Eyizi2p0xUWgtKwWab1/pcb7Vll63ijZXeAq2TqvdOooyxLKySxiSut8sjIxDnoKOVwpDfGXnliQJY0/7y3GZ4zFRysPyVPTr3q7XdlqBFkOFQUZ2iloJtYnaljTQ7Trxeus3ngweXwWcvbFZIC9VZG+cS1mWv4uUhdJnBGpY9d7/2kbP1vRbVJ5ny9fo1r4FwMfSJFytR/m/LcWxUJwh6qKcS4LDPPfj9J2BL9+wm4h8lrQiOnzlG1U7z2uiaX8hUdP1OrG+Y8vg64tE9l5tpc20erhiqjCY5qfCzBtEUexq25VVPD+Uy/S5+ydHiTDQGqPc0kh/88yB80Vt+29viSlvKThrrpA/yksWEfbX/ADBNch+7v1FOMtC4sVzVH1weqeoW6U4FfyRP/KFVicKoetNwrmw7EVRa2TufbD2PXSH5tKdvYRgRdboRVaRUs9n1091K7ZcmfaXi1oTljPCQRgIx92OhaTenvoJ5jjP87G9xJNBbCs5O5tYRUVFRUVFRUVF5S/kP+NYAAgNDS1/3a9fP7Zu3co111xDVFQUgwcPJiEhgR07qtDM/7eiGIYqR2sq+q1agydlXkIY+ZSoQlOUWE5rcEdMhSAr8g8Ze2q3P7ogT6SYv5FvNSHL3CtPozMHkbVBwlhTH4Y8yS0X0/kaYcA8tU1EV1eOGPVFQhcY+arIOkheKwph1gemaI9hIPe4/8v9lTIm/yR8GX6VbAWn7ezrSG+EIDMcmCuyUgxmuPxzuPwzESFaV3TBMOgx8Xrdh0KGLBDKimDzF8KQF9kcet8uimtWzo6oiqBQbC0v4SvpWmzo0J7eCgseEQVxzwXDnhHnMH0X7JpRu3V0udbdPreKYqO2Ek/tC+/7nrfxzV4CtmJhfD6Xsiy1Nej/XaitM6Gyln5JYc3LlBaKmh9/iOv/e+lKFmiGB7ZdY6Qo4Ay+MwXqG6X4bW0cCwDxHcT1q9HByc2w7OXaX496ozC6XvWtcIjbimHJ8/DjVUIWrTaYouCq78T1m7JeZO/5ep5QUBxE1jz3NNdTm0FvVB0KgTj4veet3H8r3ynty5fzTnbBvPvh9HYhaXT1DxDWsPptOspEBh5A7ztEwEldkGVR/HnTZ+Asg9h2tXcqKJhjhGwgiIxSaw4gQXgjHE0H8750K3dpXqPskg9h8BOiTZiixXwH59XteLzRBUFPd72UrdP8d1o4SkVbAmg21HOOzdGe5w29UmfB6FVz4T/edlRUVFRUVFRUVM4b/ynHgjdNmjShe/fuAMiyTFlZGSEhIfTt2/c879lfSFUySAqK8c0ULQY1piiPQ0HReDUYxWfuQU2mpoFYtk4FnN2yQPXkWNCmrGKUvBInEvauN0FIXL2st5yk3tDzFuFgyT4MGz4TBtyaiG4BvW4Tr9e8Wz/HK0meoqEZu4UEgCW74p8vo8XfJXL674Yvw6nNKgb7viRz9EaRJbLlK/H+wuf9L9DsL52uEpkvpflCf91fnHaxX9Yc0aZ73SqijgNF0jBLcxn3a17BFd4Yygph9VtCHqO+M15C4mHgI+L1mndEpGyghDUUBTABDs0XxkzFwGYv8W180xuFsU2RSVKzearH28jpj3G0sqHTGOZlDBXLZWVlc2jvTrJTD4vvzuyHPx4FZBzdbuZH6Yra7Wtjdx+ftrF2ywdCQlcxzdxbs/RZVcS2FrVCdEbI2AVLnxdOgdoS00pkGgx/QVzj6TtFcecVr9fOsRzXDsZ8Il7v+AEOLRCvLTlnr6/coRcMxVnuGkMOcDgqOflKArue/i0E4uCvLEPm3X9XzkT15Uhd+iIcnC8+v2IqxLeveZv1ma3gKIMtU4UTHqD5UGHkr4tTQSGxB1xwv3DKDX1GZIhe/AaOHpNZqLmQ41JTj8SXLkjMB3BkqZALqy+8sxZ2/eTfMmlbhOPfHCfqxlQV+FOhzkK0WmdBRUVFRUVFRUXlvPGfdSx4I0kSr776KuvWreOqq64637vz16EMPi05Ff+UQa0yeAHISxMGOSUqypIjBvruQY2sDUaWZY5Z3JG3tc1YABFVCsKYUFtkGY6vhLXvojsoCt1Ola7DFevH4Lk2xLWDvneJyM3Ck6IgoD+GpO7Xi2XLimD12/WzL0oB54w9woicn+b5nasyWqhFAP2nJifMpi+E0T+uA3S/sf63r9HCoMfF6y1f+y9FtGemiODUGaH3nXXOoDghNcY2/DVoNwaQ4PgK+G0yLHxcODz2/SYyGYrSay+3AsLo06CzMKauerN261DkkA7Mg9KiilHTvoxvBjNENvboYldn7PsvGT6rwtvIabMKZ1PeyarPife5Vl7LlP8esixz5OgRThzeR/LxI8j5aULOxGmD9mNxjHij9lrfSX3ENG1z7ZYPBFOUyEpzlAmnc22JaiZqLBjMkHVQZBrURbZFoxX3pluXQJtRIhNxy1T4foz/NSS8aXMxDHlavF7wqMjW8iWJZDC5Nf5LhXyLVg/oROFn74hrxfGkXE9VtT9LNpw5VLdnhb8TgTj4q5Mhq5yJ6i1/BKLezPoPxOtL3oZmA2venssJm6eK1/WRrbD5S5E1JGmF46zLhLrJU1YmqTe0HS2er3xk0Py4YC3LNrmfUxO6uGsfOUVGX35q/eyDd9bC+o8q1jSqihOrPfsfZK6YqVAdimzpf7kfUlFRUVFRUVFROS/85x0Lv/zyC/feey+ffvops2fPLq/B8J9AGXxKeGQJfBkD7CVgLxaGvXJNV2cFTVdJkpAkidYGd0SxogXrB7Iss2fvftLTM5CLMkVUJtSclg84HE5KSivpTssu2DsL9s+G/FQkZH6XRvK7FIAWd22IaCwi7oJCRfZBqh8RsRqdKDAoaYQjJKsOxicFxWCsGHMNbsOdOfr8ZCX82wyvlY04yvFZc8VfmVvWJaq5/4WLA8FRCtu+ce+Ln0VOjy6FtE2AJLJr/Cja6nLJpGYVsnLPSb5evJcfVx4ku7DSvUGrh27Xw/DnRRSr0y70upPXCumi1W/BnHvg5+uEZNLa92Hvr4FFhWq0ovA5CNmMvGT/l1VoNVLsX0kupKxxZ2JFVm98U1AM31W1G1VGrKKR02ASEeg6XdXnxPtcK68BclMqLOPQGJAlrcgusBUJCZ9xn9fNAFnqbp+1ydYJhPRdsOhpcNnFuamrFFpsGxj5mpAtyzkCa9/zz1BZHaHxMPYTuPIr0T5yj8Oce2uXXTHoUWg1Qhzv1mmetmWzVgxYsJeIa0PSit/d26lgK4H8U8Lp5/CSmiupwnlqyQFnqZj+GwjEwV/dvMp33vcyb/mxLW4HwQUP+J9RV3hK1CbRGuqntoLynNmkPzQdUPf1+cH/zV9Z/vqOl7/kojteZfmmveKDzhNEGy3KgBWvueWZalnTxJv2l4u2UJTuztCpgRB3xu7hP+HAfN/3UJsPJ4Jaa0FFRUVFRUVFReU8cQ6sXv8s2rVrx6xZs1i9ejXt25+jaPa/E4r8kRLlpjd5NMVNUWIexRigSILojaAPEQ4IbwNApQjDeZ8+zZjCHcJg0Pcuv3bH5XJx/6NP8ckXXwPw2dhw7uwqk+yMIySoGTFVLFdaZuPTWUt59eu5FBRb6dW+OUN7tOHCHq0ZatiJ5vQ2QIK2l1Ia353P17ap1ekKGHOsMK7s/VUUyGzcRwzEqyO6BbS8CI4sgm3TRNHauqAMREPj3TUXws5vJoK34fXfmBGhHF9JIQSHigj+LVOFHnxhOoQl1N+2nDb4dbKIatSb4Jofay62WZwJK18Xr1tdJAyUNZCaVciI52Zz6FTF6GWNRqJf+8aYr76w4gJx7eHSD4TkQ8FJKEhz/50SBimnTWRL5J0Q8++ZBZe+D6EN/Dvu+A7QbJA47i1TYcSr/i2noNVDj0mw6g3hdOx2vZfkUQ31DRTjd5Xfmzz3VLsVirPFvfK/lAFUWRYsslHFc1IuuVfNebSXQpCxvEZNq5atyImMJDo6Bpb9IOZpf7moM2Jz1Go3ZVmmbPfvBAObC2NZ88EnZGVnk5Wdw5nMdLKycwkODmJg354M6d+Hfr26YzJVrV0uyzKn0s+w7/AxMrNzKSgsxlKUzwB5MwPM4lpPKTbwv33xpC7/Bq1Gi1arQavRoNVqCA7SM6htHJf170hsZEjNBxDZTGQGLHkWUtfD9h9E5kFtszcUWgyDq76B6eNFtsGK14SzMBAkCYY+DUcWw+FFwslqihK/v8sp3ocnehx55rizdeHtJWDNFnr7+kT384kVjFXc48zRwsBq9j+Q4bxS+fnrXGHJFgWyzVEep529RGRGZh5wa/hL0Huy/+vMdd+7I5vWPVsBoPVI2PgpnNwE7cd6ZOfOAS6Xi2fe/4G3vpvPhVOGlX8uyzKPvPMD22a8jsYUBRe+ALv+T2RSbJ0Gx1bAsOegQcfab1wXJPq5gpOQlwphidXP3+s2EZSy73eYey9cO1Nsv7y/Mrkl/IqEAy6ioedaKikSDvOa+KuuQxUVFRUVFRUVlf8E/3nHQocOHZg+fTp6/TmOXvy74MvIq0SZKs4EqKiBraRiy3L5amQoz17Yu28faSeO0PTUXAhFFEeOal7jrrhcLu6472G++nY6AA3DtNzUwQVI3PbjCbZ93IeXpzzFnQMT0OlEhKrN7mDGog1M+fQXUjM8UYob9xxl276jdCtejqaDHhcSUtfrkRr1gNrZoGpPUm8xIC3JheR1/jkKet4sDDLHVgipi9i2td++or8dHCEi2hVHw/kaQHobXuuK3Qr4WWj4r6SkEPRBIpK6YVeh4566EbZ/B0OerJ9tuBwi+v/oEmFcveYHaNRTSF1VheyCZS+KLIrwxtC65qyd3KJSLn5hDodO5aHXaWgaF0bz+HAy863sPJHFxkMZKG6F6x99k7uuGcGwvl2RNBphQAltIParHEk4HPLdzobktZCfAtu/h8GP+3/8vW4TjoXdM2HAwwFlRQHQ4yZRp+HUNrGeht3E/a2yQUtxtPoyhPsyyHgb1S3ZwuBT+fP/Gu5jX7Z8OYd2rqdT+7YMGDikwvmQZRlJMYjbrIAELiA0ClmWiY6OIjo6Slz3KevEfAE6XfPzC9iybQebtm5j89YdFB7fysprbLhkmXHP/8TpItnncqvWbeKVdz7BYDDQp0cXhvTvw5D+fQgODmLPrp3sOXCUPQfFX16Bp/B0l3gNP15hpEOc6K8+3FTGE0sLKXVULdXzHcJhN6Bzc8YN6sTlAzvRNKGaazu+vShwu+592PcrlOZB37trdmDXRGxbuPRd+P1Ocd+KbQtdrglsHQldPA7ATZ+L9i0jMiC0ene2QjVZVnp3zSZtkHDOQfX9hznGYzj/J3AunOyV70l2q6emh7PEc370RuFsOLZUvG9yAYQ38r9eR95xMfXj2c4vGnQWhdQL0kSf1mFcnVcpyzJ2uwODwfM8X1hs5c4XP+WnBavR6j31G1IWfUr7Mfey81AyPy/awLWj+osgjD53ij5it1s68LdboctEURC6umu3OsIaCcdCfgo06Vf9vJJGZBEVnBRSgr9PhomzRACBvcQjJ2bJdWeFlXiuJZ1OOBsUDEaxvsp9VuUsO9XJoKKioqKioqKiUgf+844F4L/jVIDqB+mVi5cq07Pms0L+adDpwWEn+fhRzHn76RyaL1K+Bzzk167c89DjfPXtdDQaDd9+8THXRu9Ft2s6mfom5ITK5J/Yy32PPMnHTRMY3L0tKenZrNt1hGKriGhNjIvkpTvHM7RXO9Zu3Uen/D/pGlFEmUPmml+sFC5Yxu9vtSMo+C8eLGl0IjJ8989Cd75Jv5oHpFHNRdTosWWw7kO4/NPab18xFOgMUJjhiS48X4PG+jSw/lVp/oFG9BnDPJrn9hLodI1wLOz4HgY9VnftaLtVaJcfmCc028dPExISNbFrhjBO6IJFZHMN+yHLMle8Pp8DabkkRoew4c2rSYr1SLikZhXy+5aT/OF+P3vpen5duIJrLx3C249PpmG8D4OoRguhCeIvqbdwOix4RMjbZOz1Pxo0qQ/EdxRGs23fwcCH/VtOISQOOlwusiV2/R806lWpYKzboaBEWFtyKvcdPAABAABJREFUISKxkpxINYZB5ZrRaN2F7VUjzc6dOygpLGHP/oMMGFqNU8tRAsZQ0ESKKHdrLpIS8Z57DKm0QBjWGnbza7u/zp7HMy++yqHDRyt8PnO8EdCz5KSJ9j27MyQ2ltiYaGJjo4mLMBMbHUV2bh6r1m1mxdqNnErPYM2GLazZsIWX3/7Y57a0Wi1tmifxYB8dk5plodPIFDqDmG/tCt2a8tlAExqNBofDidPlwul0uadOsvMLmb9sHTsOn2T1zmOs3nmMhz6cTbfWjfjisavp1a6x7wNsMUxca1u/gmPLhRFyyFOBO9sq02qE6L/XvgdLnoPo5tBscGDr6HevcCzsmQldJwqNe/A8T3gXFq6csWAwigw+e4nQl4d/l4OuPp3sCpXvSTar6CNK8sFWKu5rStZVRKIIYADoFGA9sfKMhWb1s9+SBO0uE1kLx1eIrM06ZC1YS8q46qH/sWT9Tq6+uD+XDOrJwRMn+fjHBeQVFqPTafn8hbuZ6VaIjA4P4fGbx/Dsxz/z7Mc/M354H/R695AosQd0vBLWvAuHF8LO6eKaHvYMNOwe+M6FJ0Ia/tdu0Bthwv/B1xcJ6b9fb4PRb0OUu36WwSQyFSpnDhecFM+fzhLR39lKxHn2FUykXIf/9oxSFRUVFRUVFRWVc47fjoXmzWsXpSRJEseOHavVsirngMqDdG+ZCm9ngqEaw5itBHR6Thw7QkpmAfqgYDpa3BGlXSaIVHk/+L+ZvwLw6vPPcEPvaJj9MwDx415m6/39mPrN9zzz4mscSk7nULJHmzY+OpyHrxvFfRNGYAw2gKOMZrF7gCJkjY7/y23Lnyc2U2Y7yLLNB7hkUI9Az1LdSewhnASWbBGh3XJ4zcv0nCSWOTBPGHdialnvw2YRUxmwW4TEiL+SM393Khui6kpVDoRABtvK4FwqEwbp0iJh+AsKheIzomZIbYwRCqd3CN3z3GMimnfcF2L9NZFzFDa4jaH9HxKGhho4cSqLVXtPodNqWPj82ApOBYC4cBMr9pwEd/mT264axdQZc/lp/kpmL93AI5Ou4Kk7rsFkrMaRFtFEON4Ou6W/Rr3ln+NFkkTWwvwHYfu3Qm7Nl+OzOnrfLhwLRxYLPWpfBWNlwGEXjlN7SUXHQnWGQZtVOPEMpn9WFPU5pGvXbuzcuYMmbduRXWhl4Z+/snPnTvr07sNVV1UybJYUgdkt42HN48TxQ5xKz6atcx+xAM2H+O2g+3La9+VOhRbNm9G7R3dGdU/iqtJpAIx87ndGVpYEK80vf3nbDdcgyzLHk1NZuW4TK9duYtX6TTidLjq3bUGnti3FX7uWtEswE7T+XUjfIRZu0p+wgY8y0c+aMi9d14/k9BzmrNnL76t3s2b3cXYcPsn1L/3Avh+eLM/WO4t2l4qI89VvisLQCx4R2VF+tPNq6XcvZB0SUm6z74ZbFont+EvL4cKZcOYA7J8Djdz9r9JmZPnsoAVbydm1nc53pt254Fw4SSrfkwwmiEgCSSfuYZZccQ+zWUTdj6wDwvHQfmxg28mt54wFqLesBafTxcTH3uWP1VsB+HH+Kn6cv6r8+zbNEvnsubvo16MzM2d7lnvwukt4Y9ocjp/M5GDyaTq18nLkBUeIgumtRggpwYJU+P0OaHMJ9LsvsHu8In8USFFocwxM/Bm+HgGZe2DpC3DlNM/35VlyuSDlin5LHwKuMtAGi9+/csaC97KVn3dAPK+qmQsqKioqKioqKioB4rdjweVyeWQL3NhsNtLThcFXp9MRHR1NTk4ODofQnklISMBgqAct1n8DslxBSsgn/uok17SeQPCOHvRVuLTCdt2FIvXBgExyTinFTh0NXKeJsx52Zys84ndq/YTLLuLLH3/DeXA+zP5E7EeLCyE8CW3RKe4cfyFXDevBe+++jbXURsukOGx2B6kZuSTFhlBiKcQoa2HLVyJlXdIgxbRmUqNQZq6J4M+92RQcXAVRyYC75sPeX8Hi5+CuQRf/5ju8yPfnIQlioHZkiTDu12RcDkuEpgMheY2IlLvkzernr2pgqzgWtHqhbW+MEhHrNRX6lPys5W6z+BfNfy50fA3mmttJde2j8j5V5UAIJLK0vFaJUaxfMY426S8KMJ5YA4m9PPM7LDWvE0Shx63fiOtbdor6HRc+DwmdKxY/zj589rJOGyyZIgqpNuwmahSs/6DGTUpZwrin12ro1CRSbFfZbaeLCW8tZP7201w4Unz29t2XcvPwDjzy/s+s332UVz77ibWbdzD/vQcwG92yE76uq6aD4fhqEY2591chy6HUeKmOBh09hqg9M0UWRlX4ug4adoPEnnBqK2z8HAY9IhxANitYc0Q7DU8U8m/lxk9lPVL1hsFAo5Hr8z4e6Lr86Y/qgWFDhzJs6FCysrNxOh1s2bwZm83G1q1bGT/+SkDi7bff5sC2dfTq0YM777kHXE5cweFk5RRRWmpDn+aWbmk22FOQ3uW5LtEYQFvR+D78wmEsXraCfn17s37JXPHh3PvhMEIOLLq5aBveZFVsRxLQ1OikQ3wQKbFGDkeHUWSx4igpJOv0CSxSGsacWeg0JwEnskaP3OlqNE0HiLomJ1b6d5KiW9I0LpQHruzHA1f2Iz2nkM6T3uNwWhYvf7OQF28ZIebLPnT2sgYj9LsHtn0rtrnoKeh9h3+SUdUVaO7/IGQfEUWiZ94E1/9W83XtXai+790w9z7YPUM4KrxrIASFnB2Z7igV95qSQpH9pUzrM4ran+v9XLSJc/1c5+uepDeBKUK0E0kWtRUK0mHvL+L7lhcK2R/ZKZwM/qDUxwmJr/4ZLz/Fv/WFxItptxtg5WtwfKWQHAquJHV4aGG1q5Flmfs+Xcqc5TsJ0mt5+foLOFNgZfmuNCLMQVwzqA35xWUk2o7BiXxgCABzfv6OKKNEWLCGYis4UjaB1isIyvs4etwIR5fD6e3C4XZ0qZD8atRLZNLVhM7dFxakVmwnvlAyH0E44a/+Af7vGlH75M8nYdxnok/VBYv+yl4MJXngcIAxUjwnmKMqPstX14b0bpnT/FPCEaV8ptZhUFFRUVFRUVFR8RO/HQvJyckV3ufn5zN8+HBatWrFq6++Sr9+/dBoNLhcLtavX8+zzz6LxWJh6dKl9b3PKoGgDA4UKg8SFGMYCCO4P8VM9SYkvYlGzVqRnJxCh/R54vMuEyGiMZQV+LVrD9w2kVOb5/JYi6PgkkRE6tCnWLN5B6s3bqdzu1a0aJrEo9eP5Nfl23j7x8UcTM4oXz7aJLHmtkjaRTpwaYPQxLQSRkIgzCgu7aLSv7rAghehDYQusc3i/2C72/XCsXBoAfS7q3ayA8qg3xgJQeGBR3XXuH4/o/n9mc/PqN56o/I+VWUMDiSy1G4VbUdGGNCU5ZoPdTsWVouaAIGQe0IUbszcK963vEhEI9dUqFlh90zhfAgKg16T/TZuBeuFE6DM4azwucslc8uHy5iz6QRGk+e8fDhjKU/fNIK1Xz3Fbyu2MemlaazcdpBLH/qgonOhMkEh0Ppi2P87HFzgt8QNGp3IOlgyBTZ/CV2vC1xmqvdk+H2rkEPqdgM4bOIakJ0ew0p1GVtV8U+UbDnHxiMlGMGslygpOsOQri3ZtO8o3Xt0R6MR19qaNWtwlBSyfuNG7nrgUQA0pkiiWnbHtOYjIkrcjuDmQ3xu4/Gnp9CyWRIh5hCMxmCCg4MpKxPGuX37D+JwONDlHRNtEYQhvhqcTiezl27g96Xr+XPNNnLyPTUUTHroH57B3Q0MdIvzXHdrUx1MmlNMatFUGsb+QqP4KBqZHSRGmWkcG8I1/ZsTH+Hf+U2IDuOtu0Yz6Y2ZvPTdUhrHR3Dr6N5VL2COgQvuFbJnmfuEtExesl/SZ1WiN8LI1+C3yXBmH/zxCIz91H8jeYcrYNWbwgG45m24+PWalykpFEELGp0wjIIqJ1YblD5ObwSdUZxTa56o/XLQLWLXaXxg6ywtEI5XgMgmge+P7Kpa5qhRL5EFkXscDswR9+QA+PLPXXz2x04kCX58dBRX9m8NCIfDt0v38cjXq8grLuO1WZuZ+fQV5ctd994ynPYyEqPENeaqzrGjC4a2l4j6SYcXQeEp4Vw4vVN8l1BDEIriRAkkY0EhqTdcORVm3SzOjzEcBj0ppnoj6EOhKEs4GXXBEJlUcfnqagYp2EvKpU0J9VGH4Z/Wr6moqKioqKioqPyl1LrGwhNPPEFpaSmbNm1C6xUtqNFoGDBgAEuXLqVLly488cQTfP755/Wysyp+UFVEdlURgIoxzJLtpXvsY/Bhs4g/vbF8+datWtPakA0bt4qotwCNp1EF+/jtGiMGrcQhuRlthj1LRnY+l970IIVFviPiwkOMXD64K8nJyXw4sJB2kQ6yrS7eOBjL25d7ZFsiTeLSXnskj9uGnPvIXJ9IktDEzdgtHAuKTnh1xLQWBrTjK2HTl/4ZZCpT5j53YQlCczvI7L4u3Hq8dR0k+huZ7c98f1XNBG9KCjwRtHU1BtutkHdSGG0MRrB7nV/FEJq6sep6JZWRZWHwXv6yuy2GwOAnofVI/416GXuFLjQII7y/zgigzCGyWlwuGZdLRqORKLU5uOn9pcxcdxStRmL6QxfxhXv+l6fNY1TfNnRr04Qrh/UkMTaSEfe9w8ptB3nqk1/48NHrqt5Ys4GiKK/ljJDBaOxH5CeI4vBr3xVGmsMLoe2lfh8fIHS9lzwnIryPLYX2l4vwdEkrIkDryvmI9Kytg+4vMh6Z9WAO0XPlZSO4csL1YI4mJSWV06dP07FjR/bu3UuHXheINuTORghJXU6rUzOEUbLrdcJp7cbbBvjpF1Nx2ssqbxKAwsJCUtNO0XzPJ+KD1qMgtrXPeWVZ5pdFa3nuwx84eNxTED081MwtwzswuZuGVq5j6GSxLZtLYs2ZEL7fK7HoYCFn8mRk2UHy6SyST2dVWPeewylMvdQgznV0C+Ew1lYdKX7zqJ4cOZnNa9OXc+c7v9G2cRz9e1VjvFRqqBxZKtrSoT+EUX/AQ+XO9oAJbQAjXhXSYwfnC3mjC+73b1ldEFz8Bvx8HWydJhzm8R3Ed1UZOo1hbqeCKiNWJ8r7XbOn7y3JE9J4xRni89YjA1tnjrtWiTm25sATb6w54l5bViTq4zS5QGSM6b2k8iQJOk8QWQsHF0DH8X4HQ+QWlfD4NCF59MZNA8udCvnFpdzywWJ+3yD2O8Sop8BSxo3vLqTLAxX7JOVWYnfUkNEJENYQetwsJKWOLQdrNix9XhxXj0ni/PgixC1FWXxG3KsDvde2HA6XfQhz7oHt34MhVLRtJcvY4C7mbPaR9eddO62q304536Fefda5qAeioqKioqKioqLyr6TWjoU5c+Zw8803V3AqVFixTsell17K999/rzoW/kqqisiuKQKwumLN4B6cON3zeK1j1f/EtNt1QtfXTw4s+IwWu9/BoJWYd0xLhztfAI2Ox1/5oNyp0KV9a06knaawqJik+Cjuv2YYt18+iDBtGWz6HCwWihx6Bn+bx+HcQzw+LI64MBEhfdMFiXy/q4w/T4XQ+5PTJLoD9I7ZYzA4RRZDuGQhTuNfdkWtCYkXg0BbkYgi7z255mX63CUcCwfmCR15L4OaXyhSSKZo8bs7yjzFtsHz+1XnbKjOOOqvMd6f+eq7ZoI/GKsxtAdqFLZZ3Vr8WqFv7H1ujZHCoFCcAWmboXkNRVCLz8DCx0UhSxCRnBc+H1h9jOIzsOkz8brFcP8zAdz8vkMYRPu1aYBGI5FdWMLYVxew/mAGIVFxvHHbCNq0bwpuxYjg6CRuench01++nQahOvp2asGs1+/m4vvf5dNfVnD3+GG0bZboe2ManSimvPlLccw9J3m0qKtDbxRG1HUfwKYvoM1o/50uAFqDMA6t+p+ot9DmEmFdkiX3b2kF6lAEN1BjfX04ImrroKtn45HFasVisWA2mzGbTJ73egmz23FjsVqxWmWOHz9GQUEh3bp14+abbwbgo48+4tiRwwxraGGsfZ7IIul0NYx+F4AzBSUUlNix2T0ZNaENmjFs8ABKS0spKy6gKPs0yampFBUV07ZNa3IObaB5DdkK6zZs5pHHHmPTLiE3FBkewh3jR3BjzzDaOg8gZR0AZZPmWGg6CEOTflxoCOFC98d2u4P07HxOZuZyKiuXkwc2cyKziH0HDvJG30Kwuq/RU9shfTdENkOObklVV+4rt43k2Okcfl6+i6tfmM7275sRHx1WxdwIeZTWI0T09IaPIGMP/PkUDH488D5EIaEzjHgF/nwCVr8FMW38N0q3HgntxsCBubDgYbj5D5FB4cvQWdXzR+W2ocqz+KbyedGbKsjYYYwUmZAAbUcHfu4Ux4Kf9bMA8by48VMRUAEiwCJjN2iDRA2qlsMgoavoBxr1gtCGUHRaOOL9kfIC3vltK4VWG52bxfLoFT0B2H40k/Gvz+dEZgF6nYZXb+jP+Iv6MOi5BRSXeTySoQ2a4XTYSUoMJ9eZSma+n85ZSRKZC7FtRDbiqW2Qsh5ObhOZIO0vP9tpGBQisgfLCoVDPLatf9vypuMVwkG0+BnY+Ilwcij3M3NM1Q65mp7tFUdf5TZVVT02gykw55KKioqKioqKisq/nlo7FgoLCykoqN4oW1BQUOM8KvVMZUORv0Zgg7n6wYLeKCJHvQcnaZshZa0w1PX3P1vhyPoFtNj9JgatxJKTwfR44FsaNmzA6o3b+OHXBUiSxKb539OrawdkWabg0FrCzMFCOsNRBms/ExkWwRGE9r2TkNlTcWSdYPqGdB4e2RSAFk0bMfjBJ3FV0g9+ONtTMFSPnWkh75xb54IkiQjV9J2w7zdR3LqmCNKEzp5aC9u+EcZlf3HawemO3nXYxYDRXuZJczcAlhxh0LeVCOODreTsa+SvSoP/q41DNRlSAz1uZT2h8UJ2wm4VUYy2ElHIN7EnHJov2kl1jgV7CfxwuZBY0AbB4CdEcVZ/614orP9AFKENawRdJ1Y9nywLzXZZFgYS93ambxRSY9cPacOR0/lc8tI8jqYXENcgkR53f8JcdMz1kqHuPfltAB7bBnqNzLRBOYzs15HLBnZl3pqdPPjOTyz86JGz6vOUE9dBGCuzD8HWb2HYM/4dZ4+bhXMxfZfQnm5ygX/LKXS/SdQxObVNyE7FtoGSfNDpPCGs/uDL0Bmosb4+2lptHXTVGY9qsS8WiwWHwyGcCSaT5z06TKZocDkoySvEadATHRPDqVOn0Wg07D9wgMZJSezYsYO2oRbG2pd7nApjPgKNljMFJdzy+TrszoqRxb0nv42S36aTXRz/8gGyzwgH2Y6duzg56yl6tdOzsywJW0oxvWLk8uvxyNHjPPXCq/w6ZwEAZlMwj90ynoduvJSw9a9DhltXXpJEW245QtTgcLcXh8PJ4ZR0dh5OoV2zRLq1bUrjBLeBr2UpFGXgOJqGTgPZDhMxjdsII21ZEeQcQco5wq6NKwhu1pc23S+o0N4lSeKrx8az+1g6B1LOMOHZqSz56MGqizkrNO4jnJGr33TXXXgGRr9T+6LOXSeKQszbv4X5D8Ada6qOzK7MyFdFZPepbbBjOvS4SXxeUlgxurqq54/KbUOVZ/FNTedFb/RIgbW+OPD118axcGSJKAKuC3bX7DgsMtSKMyF1vfjTG4WRPa69kFgqOi2ee/xwLGQVWHl/zjYAXryuPxqNxHfL9nHHx0spsztpGh/GrCcvpXFSIlP2t+D6G24gXs4m1jWTeLKJuyWMOLKJ5TgpckPmZslsOXIGvU5D12Z+ZM3ojcJ51vU64Rw/sx92/ijqMIz0kWka2UQ4+/KSa+dYAOh1q3AurHkbFj8rZJIa9ap+mZqe7S05Qj7TEAKR1Tggva8x1bGgoqKioqKioqLiRa0dCx06dGDGjBk8+uijtGjR4qzvjxw5wowZM+jYsWOddlAlQOoq7eJLpsD7M2Xd1hxPUb3WFwtjix9s3rqdQ1MfolU7ic3ZJi54fCbmkBAcDgf3PiuyH2679nIMej3vfjGdpWs3sWbjViJDzQzo0pKnepXSSZeNKygcTb97wBTFLZf1Z/O+E7y16AQdE0MY0TGGApfxLKdCZezoKZDNxHGOnV/mWE+0ZfouaDqg5mU6XC4G2NlHAtuW3StyWWcQBm5JI5wKJndRYVux0Fw2RQr5F8UoWSEi7V+aBl9T+/B13P5mb8iymNfldEvraETxU6jZmZR9WDgVgsLgul+EoduSVf0ylZFdnqLOfe70FIz0hdMmjJsApYVgjODoGSvbU4vQaTVc1qspfR//hdO5FprGhfLFk5fzTmH13YXdJfHCN0t48oquvPPgNSzauJdFG/fy7by1TBoz0PdCkiQkkbIPCYOLv5iihXzG9u9E5kKgjoWQOGjaX2QGpe8ShdaNEe7fOAAjvS+DXqDG+vpoa/VlZK1jtoXZbC7PWAAwmUxYrVZMJhPoZHCUEmwMprSkiAYxEezXaUlPzyAhoQEZGRlERkZygW4XyE7kViP4v+J+fDRgMLIs07B1F+xtLq92d2RJQ5lLQ9cunbn3ztsp2jmbcQ0243DJXPf1Afa/cQlJjRLp0rE9e/YfICVVtBeNRsOtV47gxftuICEuSlwXeSfEOWg9Crn5UPaeKmbHpmMcPLyOQ8npHEw+zdG0TGx2Tx2fQd3bcv+1FzN2SA90sgzpu9BpYNY+O4+uKOC6wQXcNOQCnK4MDu/Zypg2OrpElULBSqwrN2Nq3ldEQ7vPfYgpiN9evpFed3zIyu2HaTV+CqP7d+KygZ25sGfbqp0MkU2EFNGyl0S7Sl4HHcfV/HtWxYXPCaNwzhFI2+S//FhogigmvfYdSF7tcSwYvTIvqtOAr9w2/q39Ul3x57yYooTTe9lLwknm5zMb4KmvEIhMlVJsvN0YaNBR/HUYJ2oppKyD1E2iHtfpHeKv/FhqNlrnFFgZ+eQPNAtzMqB1DGNayixcMJf0w2l8fomeTokRdGkUgq54KewpLZfuq4rm0klCsrLp/dkZAJa9eBnDhjT37zgjmwrJsAPzYNs0yE/zPV98R+FYOLGmds4dhYGPiDaYvEZkd0Q2q/p53R8HgFRpWhVq21NRUVFRUVFRUamCWjsWnn32WcaNG0e3bt249dZbGTBgAHFxcZw5c4Y1a9Ywbdo0LBYLzz77bH3u7z+WUksRhuAaHsj9lfOorshcXbEWu2UKnEBQxc9sdjAaxGcFuejyUtABjojmOGxeRZK9ZCo8uyzz+Vff8sJLr5B8lwRINBv7BNogE6V2F1N/nMP+o2lER8eSkp5Nj9E3VVi+JNfC6aO76dRPbP/ib7LY9vYbJMZG0Lt9M1o0aUjy6Rwu+Xgvdw9NYvKYeL8O1ybrKJWrcEC4/Cx86aq5GemCo9HZrTjS9+FIrMEIanei0YViAFylhRVkPypg8/G51UIwioFNDxjcGQtmz++SewaM7vemKBGhbSmCArdcUpBTGG71BvGd929bz5QGuO5SmwNDTcvUqX0Yzj5ua5GnTZgMnlntJR69ZL3R7VhwgiUfzBFoUrdhyD6EbDBT1uFaz/p8/G6aolzxe4clYgtvKeax+6H5DFB+OjQYzPFoik5hsxbhqqya4nWdSnaL0rpxWnKwB8WQW6pBqw8iMjSYlFwbmUUOYqLCWPW/aygyREIhNfLT0m1M/3UeU269jMcnjeH1bxZw55s/kdAgliHdfUdpalxacexI2Pw5ZuX89bidoF0/IaVuwHZsHa6kvhXnk6u/TnSmeHSAPT8dp84Mkg70bpksn9eYr/tzEDidoAmqup1Uvn4qXze+rrkAqb92VPPxWEpKPHJHsrXCsWl1BsLCDeXb0OoMhIYZSElL48+Ff5CRkYFJKqPUaqFBwyRyrE5csovwqGg2bV3FieRkunQ4BcDt3+7mm1Xzyrd7OKOI3jU4FgBeeuE5br/mUjTOUoIsn0ARHIseTuehOtIWL+V0ZjanM1cDoNUHcdGFg3llypN0CBf1NUrtLgwH5qEBduu78+EvWSxa9wTpZ3J9bE1LSKiJpg1jOJSSzro9J1i35zMS46N4a3QMVzfIwyVpeXWLllOFVt6cd4A35x2gY+NIjqRLNFhm487uWm7poiXaZIVjy5FPrMaZ0ANHi+EgaWjaKJ5pT1/HLW/+Qlp2MZ/P2cDnczYQFxXGhOE9mTiyNx1beBmJHe77nzYEbfOL0G+biittC7a2lc6dv/cXmxPQoEvogS7nCI70/Tiajzp7viramya2g2jfOcex2RwgG8Q1JhnENebrmaOcym3D/d5WApZMz2z6AB2CvrCXUJp/JqBF/OqP/MVXv3XWvaIqvM6TpUgsow2qmMl01U8YfroCTV4yru8uwzbxdyE956zi+cILva0ULWCXDDhrum7cp8NQUoAGsJka4Co/RRKEt4DOLaD77UgFqWiy9qM5sx9N9kFkUwy2Hnd4rmEAp1fWntOO7vhiIvJT2T4JIASwwYkVjIqDUXHK9WOHsrzyxawEc4YYMonhjBTDGdx/UgyR5POc631u61DKzzuDWZEiE2w0Uur083ncva8aU5y4zkPisTnO/i01LS7GsOsn5IMLKBvyYtXP+3LN7VIfHCl+D1sZzrIysFpAXyyyJh0l1bQnH+gixHx6Uw39j/saQ6qxnwq0P1JRUVFRUVFRUflnI8ly7a1w33//Pffddx9FRUUVpC5kWSYsLIwPP/yQG2+8sV529J9KYWEh4eHhDHt6JrqaHAv/MF51vkFPdvOOdDuLNUP8WmaQayPPyB+SSQw3ad5H9lPqJUgu4zPXkySSyR/SUD7Q+FGr4G/ECNdKHpG/ZDdteUz7XI3zt5GP8qHrOTKI4Sbth35vJ14+w/euBykliLHab+qyy38JjlIry1+7moKCAsLCqtYP/6e1o3C5kJddb9KG4/wijWaqppoixsAQ13qekj9mJ+15Qlt7Z+wU53sMYAufSDcxV1O1FvpFrlU8Kos4TjtaJmo+oVCqRr/9HNJH3s5Lrrc5RHPu174S0LL3uqZxmbxUtCvNlIBqLUxyzWCCPJffpYv5XPPP7qf+Le2om7yHN1yvk08o12o+xSX56dz1wW2uH7lKXkAGMdyueZMyKbjmhYCe8i5edf0PC0au13yEVarFeZJlPnRNoQ3HmSldxteaa6ud3SDbGCKvZ6y8iJakALBAGsaH0q2B1Q+pRJScx08uocN+hWYqFqn2EiZjXIu4R/6ODXTnBe2jfi+XJJ/iK9djlBDEOM3Xfvf554N/Szuqilg5mzddr9CQM5wmjsc1U8iSaq4n84zzfQaxmY+kSczXXOTXtr5xPkRDMnlE8xx7pVpK/3ghyS6edX3AALaUf1ZICHmEiz8pnHzltft9DpGcIYZizNW2I6UfySCGOzX/o0QK3El1pWsBt8s/skrqy2uas4uc62Ubs1x3YKSMezWvcETyMyPCB0+5PmSIvLHGfv58EWg7qmk+ldqzfft2evTowbZt2+jevXuN85faHIz93yIAXhwZT9/ePc/1LqpUgdo+VFRUVFT+SdQ6YwHgxhtvZNy4ccyePZtdu3ZRUFBAeHg4Xbp0YezYsWpH+C+nASK6L0PyX7t5uCwiRZdJAwIyMNwg/0IimWQRxVSpeiNtIJhkK5PknwmmjMXSYPbQtk6GnKo4ILUCGVpzHK3swClV3/SsiIGtGT8LCroxYAegjOploFTODXrZzlh5EdfKswnBSikGfpUuqXG5EETB7SJC6rT9U1IDkCGJ09XOF49HZkmPkyHyBuZK58tAIbv/D7zd/SyNZaS8ks4c5Gp5HjOlMX4vm4/ITogkP+DtqpwbBskbAVgn9aqTU6G5nMwVspDq+1gzyW+nAsB413wA/pSG1s6pAPRmJ204TilB/CKNrnF+m2RgsTSExfJghsrreUz+lNHycooI4RtpQq32ASBXiiSLKGLJpQkn2U+bWq/ruNQYZGhGakDLnSYeO1qMlBFLDmfwsz6DSr2TJcXwuObZcufCm66X/XIuKM8VtgCeK5T7aq77PltXbpB/ZQBbsKHjOc1j7KEdjhqeo/zla+laesk7aUA2t8o/8bF0S8DrSEBk0KTj+3nYLhnYInVlkLyJAfLmOjkWVFRUVFRUVFRUVP5OBJSx8PbbbzN06FC6d+9edTFOlQooEQeZZ7JrdrT8lVJI1hyRLl1S5CnsG97wbP1Um1VI5MgOt1RIMGh1yPYSgqf2Q3I5KL1ru0ipL1/Go5ly6RUTWblmLX379GLqG0/Rdul1SLKLdl/Y6D14FMbgYBxOB8eS01izeSfIMk/cM4kpD95Wvg5p/xwMmz5EQsbW/TZcse0r7GJ6dj5drn8Ja0kZb4xvTYeGIdz4awHdb3mz2lPQXj7M/+TXMchl5Z+5NHqchjCchlBI6ObfuXSU1TyPLBN0ci2SrYiySz9FjqnGwBMaD5YsgqcNFZJG9+zyfW2YztY7ljJ2E/TdCGRzHGXXzgFkMIaLWgqmqLPXoVB4GsqKISgEwhvVfDz1RGFhIfFxMX5HtmVm5dTcjrzbh3Kda3RC3qm21CRJYbOiOTgH3dq30BQIw5srvhP2Ef9DTqxUXFGpbeCFdtPH6Ne/i6PjBBwXvebe92z/9s2rDoc2eRX6bV/ijOuIfeBTFefb8HH5S33eUbQlWchaA5LThktvxhbbmZHv72Td0XxG9WzCwq0p9GoVx/JXxtHjxfUkXflCjbsSsnMac+YtoHmjWAw6HQeT07l0YFey84vZuOcooWYj66c9Q7OGHuOiJnM3hu1f4Yptj+3Sj6tZu5vIZhXeanf/H/qlzyAjYR/3Da5m7iLZNUijaPbPxjDvTlyJvbGN/8H3TDqjl5yIFIA0yV9LwO2oiv5IlmUO797EyZQTNGrclNZdPfJSUmXHj/tcyHqTKNDqxe//9zW24lzCQowMvnQiqRnZbN+2lby8PLLS0+iQFEX7Ni149Z2P2XH4JHmFFkotxZx6wECMSSLjoi+I6D62wjqPZRbx8A9bqIl3J3Sk3bIb0WTsxNl6NPZRb5d/9/iUl/n0S08ml06vx2Q0YjQGYzJo6B6v4ecRObhkiSNdp9Cktehrvv1tCfe+/CkAt185jHcfuaHqHZBlDGvfQFOQQoqmCY8vszNnSwoOh5A4uXV4G16a0Itws4ETmYXsyNKx8+hpdh1NZ+eR0+QUWri1q4YvLhFGXHvzC3EmXQBBvg20OYXFvPt/S/lgxjIAzGYjqSt/IMgglteveg1txk7sPW7D2XKEZ0Gzf3KBRDQR09ICgj/tIl7evQuCK+2PvmrnjeGrQWhyDmMb9y0uX/UZbFYh4aIznlcN93PSH/mL0m/Vpc/yvj/pDGd/bysBRylYczD8MhFNfgqu8CbYJvxS8RmuEvqZ16BNWYNt2Eu4WtVQHyD7sKilMkc8w5WO+bKK2jJ+Zs8cXowm9yiGE0sAuGWene/3uGjZMJK1b13LgdQcxr4ym0JLGS0bRvLVfcPp2apB+eJ7C4w8k9ynxs0Ezb+PuaNELQlb8+G4kvr5t38NRRS4fsWLop31vgdni+Fnz5fUF83+3zHMvxtXVEtst63xvT5/pJDm3YX24Fzs/R7G2eU68dymyCBV14YqX1u+xgFmdy0u5Ter3N/5MU4pLCwkPjZazVj4G6BmLPxzUduHioqKiso/iYDCfR5//HEkSSIsLIxBgwYxdOhQhg4dSpcuXc7V/v1rCA7SExxUQ7TXuaydUBkpVAzmg9warPqqBiNaMJmgNA85yCgGFTo9ctpaJJcDTNEERyeKQrUKNlv5y1ZNE1i2vIyBvbrQrmw7yC42pDlIateL716+i5RTmbz62f+xat0mZFnmromX8spd45BsQs9adthwbp2KhAwhDTAUnICCExX2cO+OdIoKCzEbJG5qXUxsSAmtIqu+tDWyk4ny70yUf0dLxXOucdnRlOagL82BwhT3IEqqfjBVydBZJdEtIH0nQac3Q2g1BoOoRDBHACL9Pxgb6H0Mwg0+InolEVko6QwEu4rFQNMUItZnqOL6s1nBXgCSA3RhYKjhtlCPTkVbTW2iEsEGHcE17Z93O1Kuc4MJ9LWMbnQ5hUFG4wK5BHTuQtxKgcTso7DkWVGQEkRh4CHPoOl8NUEaLVS6xpB9ZOrYRAFxnTkcncH9fZmf94NgLx3lqMYAaC2ZaIMr6SuXeGUx2IXzTzKYocSGxm4huCiZnvFOVh8oIypIRoeDjfvTmL5kB1f0bEhNJt0GciaPtTnA3NllHDlxkjkTjIw7Wsac5Zv446PHePXrOazbeZhJz3/Omq+fQ6/8Hu4CtBoJgrV+6L67LBXfdxgDGduR9v6K4Y/74doZENEYND4Ma96426DGmkWwXOYpWl5d0WJ7GWhloAwMNRTkrom/YTuSkUk7mU5ZiZW0Uxl07i3mkWXP7lqtosZCbtoh8nOzSUhsTFLbbqSkpHDy5EkaNWpEm/YdOXZgD807dSM0IooWwSaWL17Ils2bCA/SsOjEUZ587UPSMz2ZM3eNaEOMKR1M0TToPQY0Fe9vBr1/GW6xR2egydgJhhC0Fz6L1uXJ+ppy38189/10CouKefqhu3j1mYc9Cx5cAHt+gYwcNAmdaBOng/zDANw+JAlt8eWcysrnyRtHEmz36Lev2nGEJz6djd3hpHf7JlzR3shFuhRkWaaJK4Wfh8KZ3lqeXubg6x12vly4m/lr9/DxqGDGtdPTLrIZE3sCPbXIciMenZPOuyuzGN0mmDEtnOiPL0OfsQv6ny2vAnDg4BG+m7sKp72M2IgQZr73COF6J8hu7fzwhpCxE31BMnq51LNgiJ+R5Dp3mwwJhbCGUHia4LwDkNS70nzVXM+xbSDnMIaiFN/9iyEMqKXh5Hy2I8oI1geYWVNTMfdA+qzK67KXgcsKlgKISDz7mS7IAIRDZDzcPA++vQxNfgrBM6+CG+dWXdDZJZ4rDBrX2fffyuiAUtGfoTUQHGz0XZ7m1Prq16Nw6DfkYpEN8Pb6MuYfduC0O7mipYO8HfO44sMT5FmctIiUyMvOZNCj05k2Npibu4r7fzhNQVuzY2FlmoYNGQb6NbBhSFkNMc1AW0MfAuL5CsAqMnj1Mc3Qm3xkHspWaH4BaPRoco8SnL0boluePZ8/DheNOKH6kEj0IeHiOcReIvomyeZuTz6ofG1VHgcoBZpdDqDMXaw78H7OFmibUFFRUVFRUVFR+UcTkNjtiy++yNChQ7HZbMybN49HHnmE7t27ExMTw/jx4/nkk0/Yv3//udpXlfpEbxKDBnMMmKOrjnCyl4jIN10wOBxiaopESl4lvm87uqJToRId24nI/L37DyHvnwPAd7vsXDnmEu6Y8j6tRkxi6syFyLLMfTeM5ZPn7+N4WjqPvP4Fw296gncenojOaSWnBApDzjbgy7LMC78fBODe/uHEhogBTbNI3waCePkMb7te5gb5N7TIFFLdIE4W0WOy0z2to+MnprWYZh+ueV5dsMgyAJFJ4C+OUs/yJQVgcA9w7SVgyRF/tkryStYccYySFkLOzoL4R6Nc59UZi2vCbgV7ablxBWsOWPMg7wT8djt8NUw4FXTBMOBhuHsjdL32LMNotZTmi2lwRO33EyAsQUwt2eC0Vz2f011cURfkiUS0FdOrsXh94GQ+r04UmRYPf7ORgR0SqlxVlJzHw64v+Mb1MG10p7i9hzCGJee7uLeXMMzc/+b3TJ1yK+EhJjbtOcYLX/zmtQalXdXSQChJMOQZaNAFygph3gNnX+O+CHFLVlhzxKZdjpqX0xtFtOffKFuhPpGQaNamA7rwBJq16YCk/PP6aSwWCw6Hg6Mp6ZSU2fllzgKef/55fpvxA87CDE6nHKV7n/5cdfOddOjSE0mSOHToEDNmzGDhn4uZOn0W//frPNIzswgPD+eWSZNYsngRH9wxVGyg7WhxjmtBlJxH9PYPxJvBj4nsLy9iY6L56n2REfTptB8pLPLKHirJR87YI1436V9hOY1Gw+Qx/Xjh1lHlAQKyLPPM53MZeu8HbNqXzPZDaXz++1rCM4XB9INNNoZ+Z+HJpaXIMnw1xsjyG020jNJwukjmipklXPGzlXyrp3iuJEno3N3pqpM6T5aCNRsy9511vB/MXMXIRz4np8BCz7ZJbPv6EYb07lRxJiUDreCkX+ewWmLbiWnWwcCWi2klpqd3ivvpvwVbSS2WsVZ/rwmkz6q8LoNJRJ3r9KLPr47wJOFciGgMecnw/RgoOOV7Xqf7ucIfQzt4HAvB4XVz/JQVI1uykIA/jtj5YoeLaJPoV9vGGRj1ZSrZFifBOoljeTJnLDIycMf8UjakBV5A+M80ozhGpw1SNvi/oMsJRe5i4qFV95UEhUKTC8TrI4sD3r+zcNrdQUFm//qmytdWhXGA+3ODSaznPGYOqaioqKioqKio/LMIyLEwZcoUli5dSn5+PqtXr+aFF15g8ODBlJSU8Ntvv3H//ffTqVMnGjRowIQJE/jiiy84fNgPI6rKX4fdKoyOvgb3NqvH+KwYoPVGcNiEwVonjD1HDx/Cvk/oUNOuak3zn36ZzZsffA6AsegEUvZhSh0yc49pyc7O5cuf/8BudzD8gm6s/ek9PpxyD5IkcfcLH/HuN7+Sc2IXD/YSRsfb51np/dI69p0srLCNIxnFbE/OR6+VeGRQZPnnbcNLcdptFeYd6lrLZ66n6MBhLBh51XUnS1OrM2B5DYgVB4OrDk4GxbGQc6T6+UAMxoPcTgHb2dI5VWJXDABBIuJOb/YYTa25YlrZ4CAjZCyMURWNGdVdK/8l7CWg1XvkXmwW2PIl/HAFHF4IyNBxPNy1HoY86XHmBEK5ISaibvsaFOp29Mlgq8IhJcueaGaNzrO/Ngt9mgijxPbj2fRvG0//tvEUl9r5Y/1+NK6KhpoguZTrXb/wjethRsqr0CCj18Cbw410a6Dhg002HrnAQEJMBEfTMnnw7el88eytALw+bS7/t3CdZ3+gbgYonQEufU/Ig+UcERkkNbVRs1uOqaxQtDV/jCkGszDA+Cvj8Q+kQ/v2jB0zhg7t2/v83mw2o9PpaNamA9qwBqSkZ5Ofn092ehrBQXoaxVWUXNuzZw833HADW7dtp6ioCJ1Ox6WXXsr3333H8WNH+eijD7mgb290R0RNhKr6lPm//3LWPb0y98jfo7VbkBO6sM/QnYWLlvLVDzN58c2PuOPhZ7n02sm88q6QNMovKGTVus3ly6Zu+QMJmeUnnGxMrVnebu/x07z2/SJkWebyQV2Y+cqtfD25J70TtVhsMq+tsbEy2cn/1tmYskKsb2gzHWsnmWgSLq713w86+Hx9RckzjbsdZBTZwRjpyYzZ8wvkHC2fr9haxqOfzMHlkmkcH8nyD+8hKT6Ssyh3LKTV3Tke5y7Ce6aWjoXcY9U77/5pfY6hFg7GuhhuK5+fyuvSmyCykegHKhuYlec77/MfngQ3zYPIptU7FxS5x9o4FmqLywH7ZyPJLg5kOblrQRk/TGzEoSxxD1h1zMqxHBuhQRpKHTI6Dbw3MohxbXXYnPDYErHP4RShk6u/b+C0YbcWir5Tkf7K3Ou/M85yRvSpWr07yr8aWrnlyA4v8m/d1SE7xXOdxX0P8dU3+WpTVbWzmrJpVFRUVFRUVFRUVHwQkGNBQa/XM2DAAKZMmcLy5cvJz89n1apVPPfccwwaNIjCwkJmzZrF3XffTfsqjBMq54nqouXsJWcboBV5kKAwkbFgMFK0ZyEGR5HQaG3a/+z1ANN//o2Jt91H6slTJDZswBvXiOtg7iEH48ZfTeeOIvIxMT6Gxd+8Qf8eHcqX7d+9AzoNfHu5GZ1GIlsOZ3OmnkPpxfR+YSU/bUgrnzcqRAx07U4Zk8FjmLyjs51j39zNhs8eIH7NMzzh+pgn5U8xU4JFDmLSYjOvfPgNV3+bxmdbqhh0arQiir9CRkYdshiiWwrjqSVLnOOaUAy+tclYkCRAB+EJ4nfS6IRhvLSiYwabVTge9CFnZyt4Xyv/NINPZbz3P9Bj0RvFtaA3igjBH8eLegV2CyT2hEl/wrgv6laboiRfTI0RtV8HiGtVMQjYqpCsKHcQSO75jWIqu2gW6uSqC5rjdMnc+OFKRvcQ0krZmenc7JjOhs8eoOCPlxnhWsk3roe5Qf6NYMoodBp4Y2swK5MdmA0Si28wodNITPilhC+evQVjsIHFG/aQmZPPfRNGIMsyN075nDkrtlKesVBXSZOQOOFc0OhENOjGT6qfPyjMYygrK657ZguIc/5Pbic1oMggmc1m2rdvx8CBAxg+fDgREREMGDqCPn3707hl2/L5X375ZQYOHMihQ4cICgri9ddeIzUlmd9+/YXLLx9LcLBw1mlS1yOV5PnsUxwOB/c98CAP33cX6z68g/DjC3j9ak9U/rsT2vPx9Z34ZnAuA+RNyJKGG2bm0bH3YC65YgKTH3qGF978kC+//5kFS1aye58wil899hKGD+6PLMt8OXUqkYUHAPjfulKuffF78ouq/w3bNmlAnw5NAdh55CQnz+TRJ/g4AJ9ssZFlldFKMKKFlof7GbA5ZT7cVEaHTy2kFIhrfmBjLdf3rOgMGNNRyJjM2lnA/P1FOIOjhINYdsKuGZAv+r8QUxCPTBBZHqmZeYx8+HNSM/I4i9CGom3ZLB6Db20pz1g4ENhySk2hvOTqI6priub/u1Gb+0VdsuiU82PJrmhM9l6Xsn6DSTgSzhwR0/Lnu5yKASTGKLhxTvXOhUAdC0p/VlvHgiwLw3tROrklMpf9ZOXzqxtxPMeGLEP7eANz9omAi/5NxfX0RH8DD/YN4t2R4p6y8aSTojKZOHL4yvEwaT8+yOapj5ZvYvPUR+mw+w2e4EvWfHAHpQVZXN41RjhllPpVx5aL7IWaKEwX05AG1WbwAtByOCAJx0Xh6ernrQlJK7pPlwMsbgdD5X7fV5uqqp3909qfioqKioqKiorK34JaORYqo9frGThwIM8//zyzZs1i6tSpdOjQAVmWCaA2tIov6tugWznCzW6tmJ2g0Ykiv94p1XqjGGyFJ4AumBY2t9xVFZIV6RmZ3P/EcwDcO/lmDm9ZRaOiHQBM3+vk8fvvYtig/gQZ9JzKzGbfkeQKyz948zgeHRhKl3iJMoKIadqJ7S8NZXiHWKw2JxM/28pbC0QmTExoEDGhYrB76IxnABgXouP/xmqxZR3j8VbHGCavx4mEXR+GWSrj+2FZjG+Sj1OGu/8o5f6FpThcPq5VyW181ejc0kQ+shiqk5zxRm+EcGGo9StrIcgdqeqj2G+VlEshBYksBG8jjgQEV9LetZcIY4GvCDWDSWSr2K1QnP3PHnB6D5gDHTzrTcLgqTfBmrdF1C3AuC+FU6FRr+qX94f6iPBU8JI28oniWNBo3cZ8GTRu6TCbhS/uHEijaDNH0gtYtFMYMfMsZQQ7CilKP8brHY7wiPwl0eSTUiBz1SwrLd/N4aet2Yz5ycrBbCcxJg2Lrjex9bSTh975kcduHA3AEx/O4I7xw7jx0oE4nS6ufuIjdh9Ode9YPWilN+wGQ54Wr1e+AYq0jS8kyZO1UJRe871WcRpU5bABj/HuH9pOZPe/E8nJrF6zhhPJyeITWTgVkpOTKSwsxGKxiMQXGUaPHi2yFy8aRZZVxmKT2bZtO9deO5HXX38dq9VK8+bNWbzoT26/fTJBQUEUFRVRWFiIzWbDZrMhHVwgdqDtpRX6lD179nLxJZfy8SefAfDcY/fz89T3aN/YU/y7RZyZVnEm4re8AcDb60r5cflejEYjXTp15JLhg5l8wzU8/9h9fPnuKyz4aSpHNi/l568/QKvVcOcjU9j7+/uEBkmkWQwcLQknOT2Xyf/7udrnF71Oy7w376RFYgzJ6TnMnTuHDlEOSh0yG4ob8fnoYNIfCWH+tSZ2Zbho90kxD/xZRk6JTLsYDXMnGFl1s4lGERWNtf2amRnaKgS7U+ayqSdo8tJBHlxUhsXcWBg5d0wvdxC/cddl/PLKJMJDgtmwN5muk97i85//ZOGabazfcZATJzNFNk+Iu5htQWrlwwiMWLfTKOuQX0Vmy4lqDkgiOyg/reo2psqwVI9yfhRjck33GUsuuMqg8JSY12mraIh2OUSWY3gjd42FRsK58PN1FYMmHAFKIZW5AxiCalk348x+OLMfhwuummVlRLsILm4bwk87RD/ZNMpAjsVJYriOTg2FI6HY/fjXNEJD0wgJpwxrU0Vfl6DJ5bYmaRRleOpzFWWc4NDB/SzbsJOS/Cwu6RhFt8buZ66wRPH8VVYEp7bVvL9FbsdCWMOa5zXHQCN3Qdy6yiFJGjC7n9e9M1O9+ylfbcpgEteCEjTi/bna/lRUVFRUVFRUVAKkzo6F3Nxcfv/9d+6//346d+5MfHw8N954I0ePHmXIkCE899xz9bGf/13qO4KocrScsn4lO8Ec7flTCrm5i9RKeiOSJBFe6k4PbzbY5yZeeOM98vIL6NqpA++9/jwmUzCS2xBSqI+nSeNGmM0mhvXtCsBDr31O+pmc8uXDQszcOEAY4P+3xsrL809QWGJn7kP9eGK0kFR4/Od9bD4mov7bJojB4Lpkr8KUQL+mRn66JpKOsRoKCeFRzfM43UXtgnUS318ezKP9xED5o802XltTQ2SaJPnOYvDXwCLLnkGcPxriYe4I+ECiQ03uotBFmR6ZBsXYKXO2Bm91uryK3q7WIAat/+QBp/eAuS6DZ28nkjXHUxuhrriLU5ZHStYWmwVK3FHLVRl1lGtPiV4tOAXOsvLvIkOC+P5+EQm9en8GAMcyCimzO+mdqGVoIwcOtHwpXcfBXC1bTzvJssrsznRRZIOJvwqpraYRGka11HIsLZNv5q5mRL9OlJbZue9/3/P185O5YlgvbHYHT3/pllWz5lAvNO7rkYOqJN90FvHuTKn9c6u+1yoOB2vO2VJilZ0NSnv6p7YTN2lpaZSUlJCW5skOs1gsBAUFUVZWhtlsJjs7mwMHDpCTk8POnTuZPn063377Le+88w7PPfccP//8Mw6Hg5YtW7Js2TK6dOmCVqst/wsyGAgKCiIoKAit5DZiesmIbdu2nW49e7Ns+Qp0Oh2zf5vFU08+juQjs0WWZTIyxLVa5pC59qorOLpnMzs3rmTBjK/48r1XeOGJ+5l84zVcctEQWjYXcidTXn+fL7//mRiTWGejlh2Y8eLN6LQaflm5i4Ubq7/3xkaGsvDde+jUoiGtGgtt9WCdxC+PDqdFlIZHFpcR9WYRE34t4XieTIMQiS8uDWb3XWYua6P3eSwul8xtfT1yUqcK7HywJpdGLxygLDgOHCVwdGn591cO6cL2rx+lV7vG5BVZueulz7nkzpfpf/2TNB95Bz/OXwXRLcTM6dU42vxBkVCrKSq7MnqjCFgAca+rj/oC/yWUexCI8xMS4999xhwFLhfYSsVvp3c/42l0HoO03i3xd2a/J9Og8vONsm1/HQWKpF/2odrJb7mfqax2mTKnlrcua8DCA8XM31+MRoLkXNEP3zcgiliz6M/mHLIz/7CdtAIXRnch8XVpnvol49qeXXdre2oxv+8Ux3ZdH696LBotJHQRr60+soAqY3EXoTfH+Xd8zYeIqT9OC1/EufutDR+La8Mc4wkIUhxHSj/lq03p3YEkOkPFtqi2v38NqampbN++nQMHAswuU1FRUVFRUVGpBQE7FvLz85kzZw4PPfQQXbt2JS4ujiuvvJJp06YRHx/PSy+9xKpVq8jPz2f58uU8//zz52K//zuc6wgiZf1VyRMoRmllkGIvgXx31GNEY5+LNGoooiNPpWeQm5cPkoYMmxi8RlCAwyGMfQ9NugKDXs/S9TvoMPp2/ly9pXwdrd3OgkNZZTz32wFaPrYE8+S5fLdWbFunlcplkC7vIQw6UxblkpZfMXtgcJKY/iENY7/UuvxzWZb5bpedaTvF/BoJWkX52RwqG4N0Qf4tV5AmBqBaPcR3rHn+xn3ENHWjf+sHSOotHB+FJz2G2uqMnYozyfs7xYihRG87bBWL+/0T8R4w13bwbLdC1xs8UYmLnoL3OogCzidWBxbB601ZkSfC05+Ix+pIWS/aa1ijqotIavVe2TDFYr81ehG975ZiGtqpIV2aRiPLEKzXcvh0AZuPnOHpQaIdL5f686tmNIOb6Tl8bwjfXx5M2xjRfjrFe4pWD20mjD5xkWF89vQtAKzadgBraRn/9/o99OnUgq1pbqdG4WmP5EZdWP+ROKbmQ0UGQ3V0vV5Md/5YtfPM2/laUklKzPv+aLN4HLT/1HbiJilJ3DiNRiNWq7j3m81mwsLCaNq0KVmnUli54BdSjx4gOzubgwcP4nA42LZtG6WlpZhMJoxG0accPXqUwYMH88WXX1Jc7DuLxtXYXdD0xKryz6KiIsvXcUG/fowdU3U9n7UbNnHffPHbPD3YzP+9+xQNE6opoqps1yXarL6huB9LxRn0ateYUX2F5E9KRs2Sda2S4tj9wzN8+cZTZEV0B8C67SfuWlDKD7vtFNsgyijx4pAgjtwXwu09DOg0ZzsUTubbeHlRJs1fPsB1P5ydWdCsUQKlzUeKN+k7K8jVNE+MYe2n9/P8pJEM7tWBxPjo8u9iIsIgsYd4c2pr3eosZO4V0/j2gTsXdO5nDJfTd3/jjwb8f4XKx1/Z6elvH2aOhvBECI0TRZ31xrMDSPRG2PApzJgostya9IfrZnmec4oyRHS7pPEUvK+Jxv3Ec1HhaTgTuGHTGt6KLaddhAVJ/H5tKGaDxIIDInPz1j4RHM4S/cSEbuGMbBtCpFFLcr7MZT+V0OyDYg5ku9BpoFdD0RelF7kYM+Psa6lZTDAH0q0Y9Rou6VixNgwut1PCnywNxZlv8lHjxBfxbim3jL3+zV+ZPndAXHtR1H3eA6JNK/V/yh1G1UiOKbUUnLa6jS3+6+30b0pqairt2rWjR48eXH/99ZhMJmJi6hi0oqKioqKioqJSDQGNDHv06EFMTAxXXHEFX3/9NQkJCbzyyiusW7eO/Px8lixZwjPPPMOAAQMwGPxMmVapnvMdQVQ5or2kwBOdFZ7oc5HHH7iLzh3akZWdwwUjLufVtz8kLEnUWIg3lPDFN9MBuKh/D7b9/jHdO7Qkr6CIcfe8yKrNuwHQumVcJt8wgZ7NIgjWa5BlyCgQA8pnLmtDy3gR3frAiBb0aRFJQamLW2ee8chXuJxEBYnB4R/SMADyS53lOteT5pSSWyLTrYGGzbeZubbT2RFtPpFljxE5EOOKEp0W38k/Z0Tjfp7lHH7o/IIwGCuRdinrxVQxJICXEdRHIUeFch3n3Kplkv6L2EvAGArjp8GwKcI55CyDfb/C9HHwSW9Y827gusmKPnNwuKdgd205tlxMWw6rvmaBMUL8thqdyHIJSxC/s9cyEweKKOcmccIJMXvNXi5rJQw1v0hC2mjZcQd6rcQNXQzsvtPMrjvNfDM2uHwdwToJY7CB71++k+aN4miRFI/LJbN2x2GCDHpeuftqMi0yWVYZkCE/pW7Hf2a/u6A2opB2TTQfIop1lubDoYW+77Xe8iNypYwG7/vjP1wGyZumTZvQrVs3EhMTsVhENobJZCQ2NgaTyUhG2jGCDTr279rG+vXr0Wq1xMTEMHz4cOLi4rjlllu4+eab6devHwaDgdTUVJ544klatGzFZWPG8uZbb7Fu/QasVisOhwNbI/e9LnNvef/SrFkzZs34PwA2bNxYnpHgi6+/+5HfDzrYY41FIztg2Yt+GdAvv+QiAH5cJaT1KD4DLgc2u+g3zME1P8ekZebx7k/L6HbT6yQ8vJLVKQ5CDfD7NUbu761n/S0msh4L4bnBQYQYKrZJu1Pm990FjP7yOE1ePMBzCzNIybMTYdRyW98o3hyTwBdXN+LbiUncPKoXr805wNos0R7T1v7E4k0HyM4XfaVBr+OFW0ex8PPnCDGJNjhx9CBGDujm6XOsOZB3glqjSIsphtFAUPo8fVDFNhaIBvw/kdoYXysfv68Ak+rWW1niMigUIhLPNiI7bTDnHlgyRTzTdLsBrv/Fk/kIkOe+J4fEi0h+fzCYoMkA8froEv+W8WLexiPcPNuKzQmxwXawW1l7XBxnpwbBOFxgMkgkRejp3DCYY8+04vELDATrwCnDBUladtxhZmxbPcn5LgZ8Y2HvGRfxIZ72lxgRRHyYaN/X9YknwlTp+U/JTtT68VyoOBaMfjoWGrgDSwpSPYE6gaALEnWdNHo49AfsnO75TnEwVC7i7I3NKrIV9HV8tvs3tdN/EdnZ2VitVqZPn862bds4cOAAjRv7DgRTUVFRUVFRUakP/NBj8bBjxw40Gg1XXHEFjzzyCL1790ajqZcyDSp1QYk+qo0BuLIUUmXc0jFZWdnk56YSQw6RyKIQcBWyLUFBQfzwxQcMufQqjp1I4dlX3sI0MoiH+gbRMkrDc6+9w4QrxxINdGzdjI0zP2T8/S8zd9kGLrvjOdbNeI9O7gjuIYMGsqWBBVmWySqykZJtxVLmYHBbz7Z1Wg3fTu5Bx6eXsuRICd9tLeLmXmGUWC0YgcXHXWS2EpF2rd5IodgqnBMhBpgyKIiH+/mOIK0ab4NVAMud2iqmSvRoTUS1EFHklixI3wFJffxbrkl/OL0dUtZB56s9nyvGT28jqK/fXZHAMkd53qsIyopAloQB5oIHIHk1bJ8ORxcLA8GqN2D1m9DiQug6EVqNqNkwUeiOPK5rtkJBmqjdIWmg6aDq55U0ENqgWufDtQNb8uT0zRw6lc/k4W3pakhGI8GaUxpSGouI9st/tvLRRRJ39jSg10p0jtficMmsOOHgwuY6uidoee+RibRvIWS9hvRox7G0TFZs3c8lA7tyYZ8O9O3Ukr2Zp0V2Q24yxLSucp9qZN0HYtrmEv+ygjRa6HkLLH0etnwlMhgqnxPF+GK3igwP768N5ooGnKruo/8E7FYkr37EbDaXF2rWVDonDZJaIMsyJ05n43A4cDgcXHfdxPLvly5dxpEjR3A6nTRr1oz09HRKrFbKyspYs2YNa9asAcBkMvHE44/z5JNP4IrrgObMPjixFjqOA+Dii0fSr29fNmzcyNSvpjHl2afP2u3iYguzfp8LwAJ7PzpqFiKdWC30y1uPrPaQ+/XqRnxcDPtOZVNoiyDM4OTnOYvYc1w4+0w+HAvWUhvr9xxn+bZDLNt6iM37Pc4wvU7Ltyeb0bvJGTrGlfHBKN9Rw8U2mY8323h/o41Mi6eGzpCWZvo0NrE51crXm3Ir+UaELNX0UInD94aQZCjk0WlfM3Kfg8bxkQzs0pxh3VuxcHsqh06cIiE2ko+eniwW1RmEwzltM5zc4q55UAsUx0KD2jgW3A5H76wku1vjXQZCvGR2lD7on9qWvPE2vvr7fFb5+H0ZgKtbr/dzXeWMRAVrDsy8UQQgSBq46GURCV/5/qc4e0Mb+LfvCi2Hw7FlIjDCmuuRwvKDn5bvZn+Wi9X5DRgenYGrJJ+MQhFcEW4UY47WsUFo3M9thaVOXh4WxP19DBzIdjGsmRaNJLE/y8klP1pJKZBpFiHRt7EWRXDvw2tactVnovbXXYN99L0uxbEQQMaC0c9jDA4XjpeUtbB7Jgx6tOZlKtOgEwx7VvRdfz4FTQeKAtz+UF/t69/UTv+FtGvXju7du5/v3VBRUVFRUVH5DxCQV2Dy5Mm0bNmSX3/9lf79+xMVFcXo0aN588032bx5c7msgMpfTF2ihmqSQnKTk5ONzWbDkpksPghLrNYo2bljO07sWs+0j9/mwsEDOJorro2ODYLJzcvnyRdeB4QUxdzlGwgxBtOjYyuKLFYmPPgKsiIN4y5mK0kScWFB9GoeyZB2sRW0qbccz2PS1G043ZffiVw7LqcLp03UXFiU7Jm3xC7TJFzik0uCOfVwKI/3DwrQqUDFbIXqosK9cTkgx130t6GfD/qS5HEmBCKH1NQtK6JkLCjZCeBxKkD1tRUU6aN/svxRbakuEjQoFILdMkKSBKGNYOBDcOMfMOw5YbyTXSJK85dJ8M2omuV9itwZDmG+M4D85tgKMU3sUS5pVC01XLtJMSGM6CIcAlsPneT2niLi+IUVnlomsgx3LSil19RiXlldxv/tsdPlcwt3zBfXWNcGGm4f56nF0qeTyILYd+ykexckbhs3lD1n3LITdYmmTtssnGkaHfS71//lul0P2iBI3yWW94XdCrYSYWyqqj0okaL/1PZSqR8xm0zExcZiNp19PE1btaPfhZdxwZCLcLlcJCcn8+abbzF//gIOHDjI3r17adOmDSaTieHDh/PwQw/x8ccf8dijj3DZqBHodCLy2Wq1smzZMgBkxRnmJYcE0K+vuAcmp/jOZikr82RzPfX+dF5fJSL4C2Y/zsZ1aygpKfW5HIBGo2HiFZcBsDFNrGfJ8pWczi5AkiRaNorB6XSxeX8KL33zJ4Pv/YjIkY9x0QMf8fr3i9m8PwVJkhjYpQWfPHIN6fNeY9pLdxPc83qf2yu2yfxvbRlN3y/mqWVlZFpk4kN1PDY0lnfGJpBf4uR/y7NYcVQUxzZoJZpGGbigmYmrhnblgasG8cD1l7Ld1hSAdy82YdJDamYePy7exq1vzOCXxeuRJImvX76XqIhQz8aVIvMnaymH5HKKjCDwRFwHgpKxUHzG41DISxPXXOWgiPOdqVlbfPUdtZGzrOn4lfPnqEbKpjiz6qzEMwdg6oXiGSEoFCb8BH3v9N0nKBH1VUnrVUVEEsS2Ef3h8RUBLXrklHhecSX2Bo0eDS4+uDgYjUS5k7Oo1IUsy7y6JIumrxyh8XvFfLrFRpRRYk2Kk0+32OjzlYWUApnmkRLNIjXM3O+pufPGojTsTpkBLcPp3jj07J1wuu8r/mQsWN2Saf5mLAB0uVZM98yqWLspEPrdKzJbbcXw22RRW8u75k9V1Ff7+qe2UxUVFRUVFRUVlXoloIyFL774AoCMjAxWrFjBihUrWLVqFQsXLkSSJMxmM/3792fw4MEMGTKEXr16odX6mTqt4r+RujLeUUPe6/DHeKA3Ve9UcBdvjg43kV8oEyG5oyvDkyoG7nvjjkwMjw5m0s03Menmm1g09QXI/4HmEWL/vvr+J5qES8xYuIZ9R0Uk5sUDupEQG0nG6ZNIshjo7Tt2koh8GwUldlKzraTmWDmZW0KuxUaexUZGfikrDmQhy2A2SNzV24zTYWfIZ6msvtlEqUOmdZwRbyXbjvE67u7jx0Ao2EehQqfDo4cfHCacC61H1LyuM/uF0TS6JYTXEJnubZRI7A4H50Pqeug9ueJ8rgjfyyf2FHUW8pLh9G4IiRVRd4pDweVwF2+M9jgd9MbqU+eV/aptZkxVBGrgkuW6aYT7cwyVI0EdpeLcSRpRXFZGnCuNVmR1WHIhNAq63whtLoWyAjg0H7ZOg4zdsPdX6HGTZ/1llRywilZ6aENRaFOhBmdfOfkpwuinyCA16OhbUqjnrf6tb9/s8pffTkxicHoOY1vY0UkajudL5DiNKGUur+1sZPq2MraedrH1tMeBEm2UKHNAkE4S0kRug0ucXRxrzpl0SF4LgC3zIHvPuI87Pw0MPow83vj63WQZ1ruzFTpPgNi2nkKzNWGMhA7jYPcM2PI1NLng7HnKLEIGSSl8Xd292vv6rI82o6yvunUF2iYk6exjMJiQvaJPs7KyyMrKKv86NjaW2NjYCov07NmTkJAQZsyYQXZ2NgUFBWRnZ5OSkkJGRgZJSUk4nU4GDR5Mu3bt2L59OzNn/YLDIX6bcePG8fbbb2N3OHE1HoB282dwfJVoB+79W7hoEQDDhw31HKfX8UYnNGbnti3M+Hkmc+bN49U127muk54mEUUsfX0CA1Y76NiuNb26daZXt8707t6FDm1bodcLg+GbLz7FxcOHYN74DpDM2K6xxHfrhdkYxFsz17Now25y8ivWhmgUE8qwLk0Y2qUxI7o3pWG0cs3mQkGuyBBI6gNpm0DSYm1zOR8vTeatXzaS7Zbza5UYxePj+2JN3sL7a/I54S5IazZITO4Tzn0DImgW5VXguZGXMd/VEY6fITGkhNw3urAuL5YV+zJYsT8Tc3RDptx+JQO6t6tosIxrL6RTijNFX+SvXr7ZnR2Yd9id8WaCmDZny+LUlL2qFAkuOAVZR4XzU2cQ2v8hRs5+oPDzecjfa7+2z1eB4CuLoK5yM1VtR5Gyq7xuu1X0SU4naJzCyKw4dewlQjpnwSPCGB3ZFK78SmSJVWWMVgIiopr5ZzgvLfC8bnsZZB2C4yuhy8SKRvoqanQBxMVEsz8li2xnCLS8EA4vYkJHPT/ttWOLbEmwIYNjOTbuWQKf/XkGgEyLzGtrbby2tqJsZL/mYeRa7Cw/UYLZ5Mk+2JJcSIRJx7e3dfFcm94oz3k1ORa0QUJKD0RWh87HuuBs50GzQSLr15otsqtauZ8jXY6zl/WFklEx5iP4crDIRFr/EfS7W/RX+mIwGP0vuK2ioqKioqKioqJSSwJyLCg0aNCAa6+9lmuvFRE36enpFRwNixYtQpIkTCYT/fv3588//6zXnVapRGU5jqoIxMjldigoWqyxwRKxIdFwsvr6ClXRf9Q18NMPNA51Mn7saH6Zs4ApHwn9bL1Oh93h4FDyaX7830Pc88SLAOSVyHS80r8U8at6J1JSkMPba4UBaFRLcWnnlcJ1Xcz85jXv2lQHTpeMNtBMBRBGZhCD+kDqK+Qmi6kSNeovjXqLacZeIcMTVIPRFdx1FjrD6R1wcpMwdntnJ1hyQLKBrbIkUg3XUG0kHf5u+HMMldP7lXOk0Z1tDNEbhXPBuygmQFJPoUm96GlY9z50u85jlK5MQT1IIZ05IAxFQaEQ267266lEg/Aglj/YCWOeKMD5xBILe09pyx0Li4+WsWZyNAezHMw9WMq+Mw6u6mjkyUEhBOnKhHHfmltukIoOFUaXnCJPFHlecRl7FMdC7rHa7eiRxSLjQG+EfvcFvnyvW4Vj4dAfQiLEW2MchIHGHipsnYFEHtdnmznX7c9grrDerKwsysrKSEtLIykpiaysLFJSUjhw4ADt2rWjZ8+eJCcnc+LECUwmE2VlZTRu3JgjR44QGRnJ1q1badGiBSUlJezYsoFrrhpPVo6nGPJzzz3HDTdcT0iIGY1GQtusv7ivFp4Uhu+o5hw5cpQDBw6i0WgYdXHVskatWrViyrPP8OwzT/PRx5/wxDfPMGOchsf6B/HdLju79h5g194DfPXDz4DIlAkxmwkLDSE0REwvbVRE/27Q1FzKmI/nVFh/WIiRi/p04qK+nbiwuZYWCREVsuZ8ktgTa3YqppJ00jf8wis/FFFkg5YNI7lvTE/yLWU8/e1KsgqEIznGrOX+ARHc0z+CKFMNARkarahzcHIzQYXJDGvVhGEdu4rv2o/1vYwuGOI7iMLPp7b5L62nkC7qHxHf0X+t/crbB2HAthWDJENwJETE/XukVAKVhqmt47G67disoNOBUysc4Uq/L8uw9gNY+w4gCwfq+G9qdmAXiMCPWmXUJfUR9/6SPEheAy2G+bVYQkwEAOnZ+dAhCuLawZn9fDY6mGe3pzK6RxN+3XCcz/4UGTRPXtGNXrE2Pl99mi0pRcSG6EkIN9A1KYTftmdxMt9GwwgD393agbfc2wg16lh4XzdaxFVx3sszFmqQQrIVe+b1VwoJhMOi4xWw+UvY/bPHsRAokU1g5Ksw70HY/DnEtBK1g2SnyLI7146FcxFwoqKioqKioqKi8o+iVo6FyiQkJDBx4kQmTpyI0+lk9uzZvPjii+zdu5clSwIv3KZyjgjEMGXNcQ/+3Sn8kk1E7Cpp8eFJAW06pGErHLKEUQ9xRhctmjclJzuLh264jOtGD6LlJXdz4mQmsZFhvP/geLAtJN+mISYyjNz8QsKMehrHmGgcbaJRlJGYEAORZgNRIQa6Nong7QWHmXVIGCsvahnEK8ONgIuEMD2lWgm8gpcLSmUyimUSw2ohgaQMIKuKSvOF0+EZnCuOAn8Jayj0sHOPi4F5m0v8W67JBcKxkOZ2LCiGb6joTPCuu1ATf3c9XX8GuP4cQ+UIU1/nyGYRn9mtnmwQZZ2KU67jVbDmHZE5sve3ivUuvCmXQqqDY+HkZjFN7FE7o181JAZZwChhcepoEBdLXKYnejvH6uLhPwrZcGcMt/Wq5JhyaIRxQ9GfxuNQKLV7GuTR9EL2KVJIliwR8eqWQPMLlwPWvC1e97hFZOgESsPukNBVGF13/Aj976/4vd4EUX449SpTn23mL25/sbGxZGVl0bBhQ4qLi4mMjGTbtm0UFxdz4MABevbsSVpaGsHBwfTs2ZOEhARKSkpISkpi+/bthIeHU1BQQLdu3fj2u+8qOBUAXnrpJV566aXy9xMmTGD6RT3Rpq4XckhRzVm/YQMgJPNCQmoubF5YWMgDDz0MwM2dJC5uqWP3K4NZaBzPlp172LJjN1t37qGgsIii4mKKir2u5RMSU7qF0jLMjlaCLm2bcvEFXbj4gi707dQSvd79uJSxq8rtu1wyWw6nM3fjUeZuOkp6ZjY77jDTIlLDz9eE8WdhK46lF/Dwl0txukSkfdNIHY8OiWJSrzBMhgCc1aENIKQBFGcIo3+T/jVH5Sf28DgWAkWpr5DQOfBlwdNnBrkDIYLCyms4laPcO/3JoPs7Emh2gvJMZskWy/lrnK1uO8r5NMdWdCosfAy2fSved7sBRv3P3XfVIKFZ7lhoVPN+VUarF1kLO76H/bOh+VC/MkfiooQxPCuvCIiABh2xZJ6gYWgJF8dlo2nSl183HAfgtuFtee363khZh7iiu+fevzOtiJEf7OZMkZ22DUy8dnkz7ptxlMZ3iO/n3Nedvi2qucbKizfX4FhQ+jeD2ZMZ4i8drxKOhZR1UHASwmtxjkFkg5xYC3t/gUVPwcSfIbq1cIifa/4NAScqKioqKioqKip1os6OBZfLxbZt21ixYgUrV65k7dq1WCyi2C5ATIzvAr8q54FADFOKuoAu2C2ZYxSFS4syxOeBRq9pdNhNDdCVpLN/42K++eJ3+sXbyrW2r7yoH78u2cCUj37i98cvhA3QrHlLstY8i7xjerXRoSdzrPy8SQx+l98aw9AWwW7juctnVkHraA0NQ2uTrVBWfixoA2g6hSfFwMsULeQEAqX5UOFYOLbCf8dC4wtgwydwcptItS/NEzJMym9fUigi7SsbdqrjXEg61Cf+DHBrcwy+MoIU54zM2bUqvDMc+twJK16Fte9Bp/G+s1wK3Y6F0Fo6FkoLRcYCBO64qglZFtIpgDkqgY+ujeXx0TK3uVW1TAaJLafsvLO2mMcHVTK8K8dakutelczLs4RBc8KAlmLXbQ5+23icIhuU6qMItueKa71hN//3cd9vItPBGHm2XJi/SJIo4jzvftj2DfS7RzholNoKBqN/2UKVqc828xe3P0X6KCsrC4fDgU6no127duUZCwBJSUls2rSJ0tJSgoODadasGSkpKZw+fZrY2FgaNmyIwWCgb+/eZJ7JJje/EJ1Oh9PpRCNJOF3OclmkGTNmcGPTYYwKAk6shh6TuOzS0URHR5OTk8PnX0zl3nvuqnafw8PDmfrF50y+407uW1jKwfsjMGZu44rR13HFmMcB8cySlZ1DUbGFwqLi8mnhie2U2X7GqHeQ8ftzxDRp69d5crlkFm07zm/rDzNv0zEy8zySMlqNxAubzXxxYQmjmsOff+5hwWbhnO7XLpG7Rnfn2tiD6LS1lOlp0BGOZYk2VpBWrbwMIJxnklbccwI1ZGa4MxZqU7gZPEZXvQliWnocCN7OhEAy6P4NKM9kDlv9GWeV+4S3pM7BBcKpIGngopegt48izb5wlEGhKGQeaJZqOa1HwJ6ZIijl9A4h71gDyvhBKc6MRsevp2K5PjGFq9tJOJsGc//ojpiC9Lw8sddZz4frjxVwyUe7KShx0inRTN9moVz5xT40uiCUFtK7WThQjeyQvzUWrO76VYFkKyhEJAmHYMo6cY4GPBz4OkD8lmM+EI75E6tg1iSYtEA8451r/u4BJyoqKioqKioqKuecgB0Lsiyzfft2Vq5cyYoVK1i7di1FRUXlA4HIyEjGjBnD0KFDGTp0KJ061XIQeh44dOgQ2dnZ9O/fv9brKCsro6zMozVeWFhYH7tWPwRimDJHg92r/oLBJCK3ityDzJyjHuOpnxgbtIYT6bSO1vDoMy+wYdoz5d+9fO+1/L5sE7OXbyJ5fGOaKtuEGiUnPl5yDIdTZkizIOFUAE+BZacNnVzM1fJccojE1UTi6nZBVas3l+s1y2AvFRHXLpeYKusMJCpNlisafWuj89x8KGz9Wgw+nXb/igkm9XYbkE4KA1JYo4pR9ca/WHc3wHT5WrWj+hjgVt5P5b2vCFrFOaNokCveOO8C2R2uhPUfQtZBOLIEWleSc3E5Pc46fzXPK5O+U1ybEU0gNL7G2QOirNBjYNHowG4l1mwGqwySRLtYHZst8PSSIgY2DaJfY4O7DoYLp9OBFkREpywze9MJth3Lwhys44lxwnEwb0sKBVYbjWNDCEpoK2qJ5B7z37HgKIN17toKfe6qm+xDh3Gw8HFRn+LAfGh9kXAqyA63pEQtHAvnmfroj8xmMxaLBbPZTM+ePenZsydWq5WsrCzi4uKw2+2cOXMGh8NBq1atOHbsGEajEYvFgh4ntvxMDIYgLhs7Do1Gw/bt23E6nXRs15qmDePIKy5h49adbNu2jRd+WMWo28yi/oajlKioKF558QXuuvc+przwIhOuuarGYIXbbr2F2269RbxZ/iqse09kDrmjpTUaDfFxscTHeaKbZVlm+6JMUncaaWUqYtOapQRnOOjftTXBQb4jlvOLS/l+2V4+nLONY+n55Z+HGg0M6NAIc7CB/anZTFufSYjTwAcXB/PeyCCu6xNPZNtBtGreRCyw91DAv0k5epNwGGcfEnV8anIU6AziHlF4GlI3QKer/NuOywGZ+8TrBrXMWFD6LUdJRYe2Jad2GXR/IefsuU55JjNYq+67/Ok7q62/4oKlz4nX/R8Uzm5/KUoHZOGQqK3DwxAiZH4OzIW9s8S9vYbnILvb2ajXebLvpm3MoaCxnft6G9Ce3MgH47qIbM5KzvqlB3IZ++lerDYXCeEGjmRa2XNKOPuu7xtPek3763KKAuOlSo2FGjIWlGfi2jgWADpdLZ7t9v1ee8cCiP286lv4fqxwAs64Dm6cD8Gh4tnFki1qb1R4ZqkH/u4BJyoqKioqKioqKuecgBwLY8eOZfXq1eWDKlmWCQ0NZdSoUQwdOpRhw4bRtWvXmrWH/4bs3LmT/v3788Ybb9TJsfD666/z4osv1uOenSd8SRSUFYsif7nHRKHUo0vg4v9B477+rTO+A5xYxSWtg/nyp+1c/cjbXDG8L707taJt80bcOGYI385ezhsz1vP5UCBzvxjg+cDlkrGUOdh/qpBPlwpd9ocHeEllaLSieCGgc5VyKzMAePw69yBRdnrVipTwWYnal0SApK15oOlN2kYRgY0ELYb6v5w3xggxdTmoumJ2JYJCRXHpkjwxsA+J8RhrvA3f5YWbAxgY1kZTN8B0+Vq1o/oY4FbeT+W9rwjaqpwzStux5Ihp86HCqJJ18GzHgqQR2T8FqbWPWFQiU89FhK/3vTzvBADBwGxuIYtoDg8Ca18TOzKczNxVSLTBSMMQmRADKCaho3nwfzO38dEfQkrlwUs7ExtuRJZlPlwgoqCvG9QKyduB4S/7ZwvDTki8kPeoLbILlkxx11CRQB8kjDCIt5j+eU4FCLwd+eq7zWYzZnPFa8tiseBwOLBYhMGutLSUsrIysrKyaNq0KS6Xi4svvpiMY3s5eTKF0ymHCU9owY4dOygrK6OwsIDcgoZo9MG4XC4MBj2NGjVi26mTpBa4aEwBu6Y9TLub32fybbfw+ZdT2bV7N+PGX82vM2cQFhF91n76pN/dwrFQeEr8tpUM1plnsvjxlzl8+9Ov7Nl/iCmDDLw0NJgGhbvoeed6Qs1GRg/oyhUX9mJU/67YHQ7mLNnDrDUHWbIjGbtDOJsjQoK4dnB7EqPNrNpzkoVbj5dvQ6uROE4Sx+RgWkhp9I4sgDN/gKazX9Hb1VKSL6TWQLSb6goZW7Jh8xeeDKlADKGpG8V93xgpjLmB4rSJotwgHKDeeDsTvJ87/kba7ef8ua66vsufvrOqeewlooaPImHZ/4HA9iukgZClKy0QUkqj3/MvsKEy7S6Dw3+KIIujS6HVRdXO7lCe3bSiF7E7nKw/lMnWwy5u7hVBqMMKaZvJOLyN5VkxnHZFUZqXSWpuGd+sz8DhktFIkF4g+pRuSSG8Pq45g9vHM9b3I6UIJClKF8+csluaT2/yPH/5wmmDrd+I1/Ed/D0bFVEyQRyl/hcir4qgEBj6NPw0QRxH3nHQm0WGkCUXXKVu54KXY0GRdfwbtDMVFRUVFRUVFZV/JgE5FubNm4fZbOaiiy4qz0jo2bMnGk0AusB/Q3bt2kX//v256667uO++WhT+9OKpp57i4Yc9xsHCwkKSkgKrR3De8S7c7CgFk9sAITvgkrdFYbiVr4sIyelXwM1/QMOuNa+39cWw8VNGt9Zj1sOvSzbw6xKhoR0dEcpTt11BXFQ4X6w+xfWtwxmQaGftN8/x7ConJXYnhSUOikocFJXaKSp1VBiDDWgdzeg2nroH2zMlvtpchgYXSRF6uvcfSoycS6OS/cQaKw/eqhjMKQWaNRrhUJA07j8/HWfpu+DUdvG6+RCIbePfcpU5IwoUEtPKf6eGy+HR/k3oKPSWFbwN3+VG81roQldn6KhsFAowm+C8taPK+6m81xs9A3C90b/IWmUepV6A4szxRpJgyJMw526htdxhHEQGKJcV0xpYILKInI7AZLpqIigMwhsLw5LTBi4buJwYKaMxp2ncTANoGNNG2aZoS/mlMr8esDNjr50VJ5w4ZWGk79I0mkcv7wrAst2nWHsgA6NBx+0XtYXM5WIV8X5mubmc4pwB9Lw1cH1rBdkFfzzq1h+X4NL3ILGXiKzW6kWdmboaXM6TkTSQdmSxWMozEyo7EirjncUwYMAAmjZtSklJCTabMOQ1bNiQqKgokhKGEH/0IMbwOFJOn6Fv375otVp69OhBQkICs2bNQqfTER/fgNDQMGIiI3hh5SGmjTXSKHkm7VrP5coJN/LKSy8w8YabWLtuPT37XsDPP/1c5b45nU62bNnKtu3bMelgkvvzZavXERwSgdlk4nhyKt/O+JU/lqzE6TZiBhn0ZIR2wSYfpUdDuK5HBD9uy2fGog3MWLSBIIMep8tVLt0E0KFJDOMHtMFo0PHNkj0cOimuc0mCi7o14+pB7bj8gtZEh7l/86IMkZVTeBrSd8CZfeKebjD5lkmr8iDtntoKslM4kpP6Vl1f5eQW2P6d557V42ZoeaH/2zv4h5i2vrh2NVz2zRaSaiHx0O5Sz+cVaipUahd/I+32attRXdp2fdUFqmoee4knot4QErjzWR8M46eJ6PfktbD0eRjxSmDXKojnjy4TYfu3QmousUe1s4eHiOPILSwG4tBpNfRrHc/q/enEvprBXb0MPD3AQAMzTGycyfb00zyzv4w/jwonu1YDThdc0CKMl8c0Y2gbUWy9tPKjnssp+rbiM+WSfYCQAE3qLZ7ZqnvmSlkv2mFoAvS4KbBzonByq5g27F67jNbKJK8V08QeUFosjsVeIjIVlIwFOLtOlM0dSPM3ceapqKioqKioqKj8cwjIArVmzRr69OmDTlePhqvzzJEjR+jTpw+PPvoor7zyCna7nfnz53Pq1CliY2MZOnQocXH+S5QEBQURFFRLA9ffBUXnuDADgoxgzRVRVS4nGIKFFnnrkTD3fkheDb/dBrctq7ngalx7iGiMLj+VjV8/ydRFe9i89wg7DpwgJ7+Ix975nncevYk3vv6d22cXsetOMwMalBBst7DqmNPnKrUaiSHtYpl1f180OdvJtjh5ZnEhU7dakGUI0sHItiaWa4Q295zw+8GRX1HyqByvQZ0kieiv2pJ1yDPAS+oD8e1rv67MvWIaF0BEnFUpmCuBS/ZtdPBXdqI2ToLKRqEAswnOWzs6q3Cz13tLtscRY46p3kjjbTBT5Hl8ORYAWo2EpoNEW1r2Elw5LTADQ1iiMCyWFYkIxZjW/i/rD+aYChGOpS4Nd525llhyGXT0DbakWmgYqqFxmES2VWZ7hkzz6CBGtw2jZZyTgcXN2X48i35tGvDQZZ0x6IVh8o3fhNNt8kXtaBrqgvQSYfzytw7JkcUiiyI4HLpMqN2x+XIqtBktaioYjJ76CnXlPBlJA2lH3lkIlR0LcqVIWpPJhMkkjqNx48Y0adKE7OxssrKyyM7ORpIkDh48yNVXX02rdp25EMjJyeH06dMYjUaWL1/Ob7/9hsvlwul00rlzZ6Kjo7FarThLizlt+4aGpmImtS5iyjvv8tW0b3j15Rf5+NPPOHz4CMNHXcKAx34s35+srCwWLV7MHwv/ZPGSpeTkCN1zkx4mPS3a35jrbsdqP/u4+/Toys3XXsk1veKJDAsRBVCPLuWHG5py3/3j+HX5Fn5dtpnjJ0Woc5tGUbRtFIXTJbPtaCYv/riufF1hJgO3juzMPZd2p0WiD7mR0AbQfpyIIE/dIOrfOG3iHmsIEfcLX21fdgkDsTVH/JUWeL4zx0JiT9+R5I4y2P2z0F0HiGoBvW8PTArF5YTDC8Vrf2v8VNh3GTZ+Jl53vb6ioda7poLy3jtzwaex/K930lXbjurStuurLlBV8+iNnmeB6iLvq6NRLxj3Ofx6Gxz6Q9xvBz0euBG83WVC8ifnCGz6HLpdX+U6kuKF8TstMxdojiRJzHn6YoZOmcvOEzlM36+hLDSBa9o46BORS/cELQuvM7E/W+LeBRZWJDsY3i6Sefd0JFjv5QiTXXSSD9BV3ochcyfYiqjwDBgcAWEJYlpTLZGCNI882OAnan8tKo6FRr1qt3xlDi8S06aDILKJJxDCYK7Y7ivXiVLam7/X8t8oo0hFRUVFRUVFReX8EpCHoC4SQX9HHA4HH3/8MSEhIXTt2hUQck+nT5/GYrGQkpLCxRdfzMMPP8yQIUPO676eM7w15MEzwNfoIKyBJ2PBYHIbAErF9zojjPof/DheaJLPfwCu/Kb6waYkQetRsPkLOuqS+eCp2wCw2e08+MY0Pvv5T554bzqfPns7YSEmjpeup419LzOvjWS1tSUZBTae+3Uf6fllhBl1vHVtZyYPbYYkSciyzLeLLTz8Rz55JWKgOLGLkf9dHE5MmImxlf0S5ft5DmS78lLgmDv6ukHnGqPzakQZvAaSam/NFlNjBKJehI+sBH8LN9fGSfBvLOjn7Yjxzl7w5WBQBu1KYUflM19IEgx/Hr4ZJQyAR5cITWp/kSSIbSuiks8crH/Hwlnb03JaSuA0CbzUJpxW0XrunJPPyhO28lkahtopssnc3svE4NE9z1rFxkMZLNt9Cq1G4uExXcDilmdp0Mm/aFhZhs2fi9fdbhRG2UCRXbDoGdj5IyDBkKcg6QK3sYn6cSgo/APag3cWQiBIkiQuwdgYYmNjWL9+PcuWLaN9+/bk5eURExPDrFmzWLHi/9k77/C2qvOPfyVLsiV529mxs4dDFgkEMtiEvSmEEUaZXfyglFLoAkoLLbS0lLJLWWGWUfYmrISVRRLibBI7i0TelmRr/v547/E9ur6SrpYl2+/nefRo3XHuvee95553LsbECRNw8MEH46OPFqOz0wdvawMmTxiD7+u3YcmSJWhubsbUSROw9+gLMXTrfbjhsCJ81jkR7yz9Bv93zbW4cOH5GDliBD746NOu/R91zHH4fMmnEcaPkpISHDJvLuyWMABS/E+pGQ9XWyc8Hi8KCvJx1inH46JzzsSkieNopbov6H3sfGDrRzA1bcVBk0KYdPnpOPnQ/fHaxyvxwgdfYsOOfV2RCQCQb83D3EnDccbc8bjo6MkotMeJKjOZSOFXWg24NtJYEQ5SPROfmwzaeTaKSgj6lEihQPe0gFYHGRUHTIhSFH4nKXBbdwEwAROOByadmliqMYDuK+59pFAemcQz4PYlZBy3Orp7dcv31IjCzTrjjHhW8XmoVkQORDIASE22ja6brBLXageEI1BBaeLtE4w5koo+v/Nr4JtnaFsHXZnYNsx5wOyfAW/+AtjxFTlbRHk2EoaFTXXfIxwOw2QyodSZjyW3n4aNu1owpboceXlKnw90oHnrKthbt2BSJfDhRQ58sROYtt8YFFjMJFOdbYCvDfmdbvwVX9N6YrjKywccZWT0M3pugz5gy2L6POm05J/xwiFgp9KedBgWGreS4cZsoftYyZDodYesdvX5xGpXj91oX86hiCImM6zfsAE2C8lZZWUlqqur46zBMAzDMEx/pe+EHiSBxWLBz372M3R0dOBvf/sbrr32WkydOhXPP/88xowZg9raWpxzzjn417/+1XcNC3IOeUAtyOysoJeMv4PSIfk7KEQe5cBJ/wCePQ9Y/waw7N/AgZfH3t8EMixg62KakFnyYbNacc+vL0NDcxuef2cJLr/5Ply98CQcd+UlwKe3oLizBbMHuDH5kU3Y00IFFFu9AVz5nxXwBUI4/YBhuOKR5XjzG/LMmzbEintOKsUho8jDsFv4e6YIBYGdy+kVDlHqopHzUgtvDwXUVEiDJhtfT0wY7eVqkWEtsdJQyIqMZBQnuVTQL12edTanakSQoxe0hgWfh1IOBDooV79FUTRGMywAlP7owMuAL+4DPvwDMPKQxNomDAv71gM4JbF1U2TCAAs+vLQCT67y4u9L2rHm+wB2tYXwm/fa8Lv323D45Fdx5uzROOXAkRheWQhPpx8/vIeUMgsPG48RA4uAbftoY/G8RAV1S4E9ayjNw4wLE2+01qhw5E3AxOPp/tbeDJQXqYWb3Y2A1QvkO3WutVuSkxgK+VyShygYSYG0bt06bN68GWPHjsWkSfpRWD6fD5WVldi3bx927NiBxYsX469//SsAYMOGDdjncmHgwEFoa2vDjIkjkG/NQ3OrG16vB2azGR0dHQjXnIKm799BmXsL3rj+UNz46VG482934YlFT2HgwIE46aQTIaTpyy+/RDgcxvTp03D8scfihOOPx8EHK5GVPjfwF8rp/8W7L8eNzmpuc2PZt3Wo8A7F/vl1WPHy3Th5USt2tYW6lrHkmTFrwhAcOa0aR04bgdk1w1BgS+JRymQio8Ce1co9yk0GBjkaQcZWCDgq1Fe0YwmHge8+IQVwyE8GgQMuSz5qboOSBmns/MTqCwlEtMK0BeQNLsYdgTz+xIqgE88qJqge1kaIGMsyUIcmFdk2uq5RJa58rHmacSdeRGk8JpxABY0//jPw5f3JRYqVjQAmn0lRNGteICN4fvf6NZPHUhHy1Zvq8cN7FuO+Kw9BU3sn/vzSKqyta8QZB4/CxUdOgM2Sh7dX7Ma1j25Fp6cdtx5ZgAunWXHwMADNG4EWM93rFUwAGlGCb0z7YV7pPljtRcqzbIJsX0rGivwi4OAfJ76+wLWJ5N3qoIjeVNn4Lr0P2Z+ijX3e6IYFm1NjzHNG9sd4z029wFjOpMZll16KoJ/mXA6HA7W1tWxcYBiGYRhGl35pWAgGg8hTisKNGzcO119/PW655RZUVlbirrvuwrhx5ME4efJk3H333Zg/fz7WrFmDKVMMKr0yTaoF3mS0k4Ouz6buE4uCosjveVagZAQw7xrgkzuB924CqmcDAydG31/VLKCkisLIW3YAo0iBmgfgqfvvwKg7H8Rf7n8Cdy96HU+89gke/dFBOLXgS+S3boc51ImpY4fi/X/8FH9e9B7uevYjXPXEKtzw33Vwe32wWS34w2Un4hfnHgWLRQp/D5oAxbkMh14HNG0wdm4qDBapHFBDBTQ//5daSLN6DjDnqsj0FNEmeFrkXPHbl9Okz15GSig5v3Usz25Po7pPi9IGrSFBTCrdDd2972VFhrOS+pzPQ++ppIjSkqjRxWRKfB35WGTFklaOEjFAxJpU+70AAuQpapE8AQOKgscSRTk39xpg3SvkafzVQ1R41giFg4ER84BViyiPucmin+qkfY+x7Y2YHfv/oBkQztMX/g+wmmECcKHy8no78NKbH+DvDz2J5avX4cM1O/Hhmp346UOfYvKY4SgvcWL9zmYMqSzF335zFVBaqCovB00mZX4s8ouAr/9Nn/dfCJSN1F8uWi54kf5IGBVOu58UZH4P0LQDKBxAfUxcY38b4GunHNyOisj+oafwM9o/jd7HjWwvHbm5tUjtE9EAmzdvhsfjwebNm1FTUwMAWLx4Mb5ZtQrTpk/HEYcfjpEjR2LbpnUYOWwgnAUWvPfmqyi0BNAZBEpLS5BnNmO//SbhzDPOREd7M9as+Aotnk4UlA/F9u3bMH7sWBSVVuD7KT9G2RfXIe+bp3DHDV/ipJNOwpU//gnWr1+P119/A0ftfwkA4Obf/QazZkxDU3MzatdvwD3/+hd+etVV2L1nD6bXjMO7R9Ax1G6pw/ia/brG/nA4jC1bt2HJl19jyRfLsPTzpfh2IxUoH1FiwoafFWLGwBC+u9qJlzZZ8KlnDCbOnIeLTpqH4kIDCmr33vjLAMCJd9G730tysOFNMkqWVNHYMnAiGQ7tZfG35XMDK59UUx8NP5AicfTWdRgogB0OARuUNEg1p8SOdtAbj1ybKGUZTMBBP6JlxLjjbQXsxapS06ZjuJMR8lhQnJgiP9r9Px0kMx5FI9b9wKgSVz5WETkjDFXR+o/RcxIOkxI90EkF0T/+CxmKJp0WuVy8GhyH/YqcLxo2A7WvUb/QMG5cMf72y4vxy789gccXb8QnGxqwy9WCTh+NDR+t3YXfPrMcZrMJzW00ro4eUo7jFl6OPHsA2P4ZFYoOhygiobQaKK1GZ/EonPvNEYDJhFcO64A11gxIx+ABgAzaIop03s+B4qGxj1egV4tu13J6H7o/OSEAZCw3gl6/26SkQRp9KBAIAs4UnmPiGbN6gbGcSY3PPvsMNosZtbW1WLhwIVwuFxsWGIZhGIbRpd8ZFjZu3IjXXnsN5513HoYMGQIAGDNmDP74xz+itrYWI0eOBKAqUjo6OjB+/HgMGjQoW03OLHo55QXxUuD4PKS0nvQDKlS86V3gvxcDl74T3TvOZKJcu1/cRznlR6me2RaLBX++8aeYd+A0XH/bPajdvA2n/+U9LLnEgdlVFtx7cjEOWvAjDCgrxF9/dhrs+Tb86fF34fb6MGvSCDz6mwswadSQ9J6feISCwOrngbUvkreprZA8z0fMTY/CQeTLHXt0YkUzRSqkgiJKsVE4UCfVhJJ+wuTrnucaICWSnCJLLJNOw0JPkIxSJtmc1oBioClUz2O8GgtyO4++CXjpCvIInXhCdKW5lvxCoHwspUHYs5pSV2SDcBh2ewHOP/NEnH/midi6fQdeeuZxvLR4Ob5cuwVrt+zoWvT+Gy7E3c++C39bA26f2ERKx0E18fexaxUpTk15wEEGjS9d7dPUVJj/R9Xr1uoAyoZHGpesSt/xtZP3Z4Gmf/QTr01xKxs7diy++uwjmDsaUbd5PUaMm4hVq1aipaUVK1euwJFHHIFRo0Zh0BknY/u277D522/Q2rAH8HdgUHEhZk8dD0dJIQ466GC89/77+OKLLzBr1iwcd/wpKPn6a7jd7XDkm7F22RIs+XIVFqAUB5Q2Ax/dhkPPeBirVizHX+64A7ffeVdX227+420I+jp0272k2QUcQfJ3wOHHA1Y7pk/ZDxXlZfhy2Urs3efqts7o6qGYOWUiXgiW4ATnRpR11uOciUGcg41AVQXgHQkUTkj3Kab7xuQzgYknU6RBokpw1ybg83sobZEpD5h1OTDlrMQL7crsWUO1HWyFpKxMlK8epPfxxwIVY+mzkBkRRRdLdrTG3mQUmX1BRsWx+z0ULZeIF7m3md5TjVgQzL2ajKwrHgde/zm154BLjT/v5FmB+bdSpGvd51R0fOj0botde9GpmFEzBudcdwe+20URmPOmjsZJc/fDo298iQ11ZLgbNqAEC46agV+cMQtDKpSxtuYUivoLdNKzjyID4aA5tecyv1eNwBl3jPEIu2jUK2mQqmalth2ADEgindv44ykNUrw+H0um+oLcMCkxffr05KLxGIZhGIbpd/SrJ4bNmzdj9uzZaGpqQkNDA6699lpUVpJnb3V1NaqqqmBSJh3i/ZNPPsHw4cN7f0HmZIg3sRC/FzmAMx4CHjxUqbdwLXDmv6NP4CaeRIaFui9o4meJPLcnHT0Pxx8xGy+88SH+cPcj+Nlb2/H15U6cNg5AXhOAEphMJvzxihMxaeQgeDr8uPiEWbBYe/gate0G1r4EtCme4FWzgAOvSL5IopZQANjyAX0ef1xi67oVhZmtiIrzuRvIC9ZSADgVT7yuNEc6ea7NGq93o4Wec5F4nrBdy6VxIm110HkPByl9BBDfsACQQmDUYaQ4//CPwBkPG1eEDJlGhoXd3/SsYSEcIgPY1w/T+RtzBBWkHjIVo0cMx3UXHI/rLjgeDc3teP+rb/Hh17WYWTMSJpMJk8cMxzsvLgYmmkjxaERx+Pk/6X3ymUBpVWLtlI0KR/ya0rvI6ClaCisBn9I3tGnF+pnX5qRJNWjdvQWdXg92121G2GqH1WpDKBTC9On7AwEvCk2daAsG4fMFYCrIw4T9pmG/Sfth/OgqHDX/OORZbXC1evDRmy/B7QvixRfrsGLFCrS0NGPYsOFo2rsLk8aOQt2WDXgkbxgOmN5MhtvJP0D++GPx+9/9Dqed8QP88n/bqVHhMEpLS1EzcYL0mohBgwZiw5pVwM7fAACcTgf2NXuw9MtlXcdjs9lwwP5TMfegAzF38gjMnjEZAys1nt3ff0v7r/tcfVVOIOXlsBmpKe71sNgAJJByKBwC1r9OBu5wECgaAhz5O2CgASNdPDa/R+/j5hv3pBZ4GoFVz9LnmZcoKcXsqmHaSHRYOvK4CxnNRFRPT6N3PvSML34PnX9rAdDRTMul67nEZAKOvpnqDHzzDPDhrWTUOuZW46myBk+mZ5qNbwErHgMG3KZ7fQ+fNRkrH70e9730GQ6dPgZHHzgBJpMJvzzvKCxZ/R1MJmD25FFUb6GzLXJlIxE+ibLySTLcOQdQtFwqhMNUawIAhnevQ5QwWz6kvlE5Hhi2v/p70vU5+tfYxjAMwzAMwyRPvzEsuN1u3H777TjllFNwwAEH4KqrrkIgEMD111/fZVyQWbt2LZ599lk88MAD+Oyzz1BSkiZvr95EvImF/L/VAfzgMeA/x1Iqh2X/AQ68VH+9odOp6GTrTmDHMt2CkHl5eVhwynycddJR+OjVRfBgFQob1lAth4N/3KXMOe+YNEzIEiUUJMXv1o9JqZPuKAVB/deAt4kmyIlOPEWNhcKBlFjY307f9Qo2d/2mtF3PgGBUOd+bSddEWhhnTAD8fjUdVsCAYcFkIgXNv48Gtn0KbP4AGHe0sf0OmQasfYEKpQYDQF7mb++mvd8CX/wT2Fer/lj7Gr0KB5FXZ8lwoGgIKkoLseCYg7DgmIMAAIFAEHc99Q6uOLwaQD0pm+LRXAfUvk6fZ//MWCNDATJiLnuEUk2JmgpjjqSinfEQfcLdqBZC7ccMqR6L3XWbMaR6LOrq6zFp0iTMnDEDc+bMATwNcBRYMWLECASsJWhuacHpCxaS0T7ghcnvhb24AvWrvkF11TB89902BKz5aGlphtfbAafTgeox1XB7O1BcPgjb9zZgGabiAKwGXv0ZcOUnQNEQjB83DgAZFn59w/W45be/6nIGkDlgykTgTjIs7N6wApvqvsfyVavR0NiEA/afipnTp6pOAyKNnZZB+9GruZ4MDFveB1wbgE/vpHGs5mRKRSanvespOpqBz+8Dvl9D36tnk8EsmWLmWsJhYNP79HniSYmvv/wxuucNnAQMma4Us1dqzxgtwGzE2JuuGjq5Srx6R3rGhq7aWR2qk0EqxZu1mMzAsbeTMXjxn4DVzwJN3wGnPWB83NnvdGDXCkrf982zwAGX6C42pLIEt15xYsRvZrMZh0wfk+pRJMaeNcAmxdB28I9Td7Jo+o6e0/JswOBpqbdv49v0Pv7YyN+zUWTZ7+mZ/TAMwzAMwzA5Qb/RkpjNZsycORMVFRVYsGABBgwYgHPOoRQYwrggFBPbtm3DL3/5S2zcuBEff/xx7tRWyHWGzSCl6Ns3AO/fQvmdh0ztvpzJBNScBHz5IHmsjZgTVSFvNptx5MzxgG8Y8Nlmig7YsSw9oePJ4NoEbHhbzZ89sAaY94v0eQMKOlqBrx+iz2OPjp3bWg8RRVEynJRfPg8puuNNhvuDASHTiOiO/CLAAcrZD9A1MEL5aOCgK4Gl9wAf3QaMPsyY0rJsJKVd6mylXMvjj0283yTAnPDXyH/t7/TF6gBmXER1QDa/B2z9iBRGK5+k/6sPBqYsiEjnZbHk4frzjwI+WQG4AQzWuVdoWf08gDBFRBjxyA50Ao+dSAosAF1GhekLlFoUSp75eMpJn4eMCoEARWj1Y0aMm4gR46iOTti6Hbt27sSwYcMofaDNgYbmFmyt24MR42pw0EEHwWw2kzLZbwKsFYDFDm8gDGdhEc485wIEzTYsWbIEo8eMxrRp09HU2IA1a9Zg6IjRGDisGv5D5yFceytM+2qB934PnPFwV6pCALjtz3dg+JCBuOIyfcWkIC/gxcTxYzFx/NjkDry0iuoJTTqNxq3N75Fx/MsHyAB49B/086inStCn1sfxu5W0XG4yOq9/g+Q9zwbMuBgYfXh6jAoAsHMZ0LaL7mdjjkhsXV+7Wgdl5iVAsIMiuExIrgBzzH1lQXHak2jrHWmPUc/YYHMA7W7qG2276bd01uYC6JntwMtovHr1KqD+S+CxE6iO1dj58Z0sLPlkTPjodnLUGHWomi4r13C7gM/vpc/pSIEUDgGrnqbPQ6ZHr7tkFE+jagTURrdmwzjnM+BEwTAMwzAMw/QZ+o1hwW6346KLLoLTSUrTs88+G+FwGOeeey7C4TBuuOEGVFRUIBgMwul04v7774fZbO6/haoSmWjIy866kpSKG9+myeal7+inUJi6APjqYZqMrvsfea/FwuYExh5JipTNH5LBItHUDKkQ6ADWvAjsW0/frXby4hw8Jf1GhT1rgDeuA1p3kEJ5ytmJre/aBGxWJpnDZtC7syL6xDKiqHMUo4LPrS7T22osZJIIOVGMNtqoEKGEaN5uXLkz+ypSPLTupBQHWi9EPUxmqlmy/g3gm6eB2leAoTPIwDco/cbRorASBWO2AguepAgFgKJr5l0LbF9CdVe2LVHTnu1/oWpcCHRSLQn3Xjp3RqJy9iqREaIuQjzWPE9GBaty/xh/IjD2KPrPJhnZ4ikn5bRvev9HeBX3PcOcCfpKwlEjR2LkiBHqDxY79rlDsDiK0djYALOZUpfA71FrtFgdaOsIomjQCLjd7TjrtJNw8nFHAVYHXC4XXl/3LcxmM9auXYuxI4dh7epvcPC8K4HXr+mKKqhdvz6iHT/+2dU45aQTMHjw4MgGWu2k+GzcCrxzI3D6Q4nVqtHDUQ5MPx+YdDpFL6z5L6Uga95G+0qFcIi8v3etUu65biDoj71OSRUw5//IiJwuOluB935HnyednriycfHtZFgsqQKqZtO1txXR9Qh0qAWY49UMMGI06Ou54OMdn16knVUZj3xuUtZv+xT49G9k4B0xJ73tG3MksPBl4KXLaIx74xdA1UHA4TfENxQMmEjL1n8J7FyRm4YFtwt4/2aKLiganHoKpL21tL1dK+l7TRLRQDJBP/DCDyl6qWxU93HUSCRmuo1zthSjORiGYRiGYZheRQbc63IXYVQIBoMIh8NYsGABnn76afztb3/DX/7yF+zatQu//OUvccUVV2Dw4MF9z6ggJvEiTFn7XUaeaMRDXtZkAk64kzzrXBuBj/6iv87AGjJCABS5sGdN/P0MPxBwVJCy5bvP4i+fLjpaga/+TUYFUx5NzOddQ8aNdKY+Cocp1cZzC8moUDwcOHsRMGhSYtv54A+Ua3v8cUDpKFLctuygOgt611MuzOxzU5/wuaMv01eJJQ/Rlm+qJyWcOK8+T/fzPGACKd87WoCWemPbtjmohgCgeOkbZMo5lPs9v5iu4bZPgc/uAl75EbDiCVJm+PUL3SbKR6Y5CBeUUaHZHcsj/7Tkk8LpuD+TV6opj/a97BFShAijQuNWwGIHDv6JsZzY7n30XmKgtkIoSFEfAHDItcD8PwEjoyjVbI7YHtRWh763sCCR+6WWRPtdjjN82HDY7QUYPkxSdIvzqxjfJk6cCKezEBPGVAOhADatW40333oLjTs347ApwzFz4iicdepJmFxVhinjRwH7NtB2BtK9sKoq8vqffuopqKio6N4Ykwk48S7qY9uXAp/9PX0HanOQrA1SUnh9/23q29z4NhkGW3eSorDLqGAig5VzICkPB00mhey084Bj/pReo0I4TBGHrbso2u3omxNbf+cK4Csl2m7edUCeifLfexvJs1o2IsSTm3hyCcSXzd5OrOOLdu/wK84CQT8w/QJg1OFAsBN4/gI1giGdDBgPXPIOMOdqip6p/xJY9AN6/hM1hqIhItX2rY+9XDYQRoX278lwftTvk0+B5GsHFt8GPHkGjYVWJ21v6oLU2vjub4Btn9H9YcGi5KIUjciZTLwxq6/KIsMwDMMwDKNLv4lYkMnLy0M4HEYoFMI555wDk8mECy64AK+++iq2bNmCr776CgUFPegN31NovZJieSkl4gWoXdbmBI66BXj1p2Q0GDdf30tuv9MpN/vWj6gA4Kn3RRYM1mLOo2198ywpTO2l6Sl6F4u2PcCKJ0l5bCsEZiwkZUu66WwHPrmDjgugVALz/0CenYmw7TNKg2PKo0mrsHsEOlTDgPaayoWZZQOCzalGKgARisE+SaJeez4PYLECAb+aHifi/DnUaJDy0ZSXfc9aSm1khClnk4Ju+2dkkDCiTDebSVEx+Sza345lwM6vydty9zf0MudRgcfBUyiSIUlP305TPgJTzoH16/uBlU8oqZd0vMGHTAMOvJyMCt+vpWMK+VWjwuyfAKUjuq+nJajkaAeA4qHxl9/wJtCwGSgooZQdHS2k3PE2Ue0RnzeyRkwqypBUvKb7WCqXESNGYIQSxRAOhyltUV4BYFfG1HAY+0+fjunTpsEc7AD8Xmyt34NOrwcNGzdj9uw5WPfteqz5Zh0OnLYfZs2cAbz3Iq2rKPGLCtWoqeZ9u1HoyI/eoAETgGP/BLxxLfXBQfsBE45P3wEPnERRMXvXUb2FZGmuB1Y/R58n/4BSpIjUdFZ7RtOaRbD2BUrzZLYAx9+R2BgU9AOv/5wiLyaeDIw+hNKHFRRSnR9/OxVCF/08GW98RiXavcPnoWhHSwFQUAQcfQvwyk+Avd8Cb/0KOOvx9BezttrJgDvhOOCTOynSbtUiug8ffiP9rscASquGpu/06ztlC61R4eibqGhzooTDFEH68V9oWwA5fRzxa4qASIXljwNfP0KfT38AKK2mWkAAnUsT1GfqWBHIicpZHxuzGIZhGIZhmNToVxELMiaTCSaTqSty4ZBDDsG+ffuwYsUK7L///tluXmbQeiUl6qUUDa1Hnb+D8uVOPhNAGHjtGvJY1GIyUcqUspGk7Pvw1vhpHwZOokiBcIgKsda+Tp7JmaBhK+WJ7myl4zvoiswYFfatB16+gowKZgtNOE/6e+JGhXCIJsIAKaaKh5LxxTmQ2h3NMGBzKKmSJAWWWE4oygE6B30lzYvPTYWAm+pUr7tE5cHmoMiAsipJQR3l/A2YQN/3rDbextIqKggOAKv/a3w9gAwMA2uAGRcAJ90NzL8VGHMUKUZCQUrHsPp5YPEfge8+SVqGghNPpXPQsoMUSdEYNInqRuTZyOCRqFEBADwuAGGK/nDoeKfLhMPAkrvp8wGXUb0LkYUqr4DqK8RK15BoFEEqXtPpug9nCTGWxnrV1dXh888/R119fddvZrMZJpsTJmclRo4aifI8DwYNHQZTKIQlK9diX1M7vlq1FqbSoWpx8EH7ddu/xUhB7QnHAwdcSp/f+Y0aAZEOlCgK7KsFQqHkthH0A1/eR/eKIdOpjkP5KDKA2ZyU5qwncG0EPr6DPs+9OvFc8l/cR8ZDexlwxG8o/VHJUEofZcojI6xMX482yDTR7h3id0cZvRcPAY67nT5veBOofS1zbSoZDpx8N3D6gxRd420E3rqe7vl6OCtpXAqHKKVYLuBpTI9RoaWeDDpvXKumBjvjYeCUf6ZuVNj+OZ1XAJj7c2DCCfTsHQoAniYyone2k/I/lYg6PXr5mMUwDMMwDMOkl35rWABIIRIKhXDttddi8eLFWLx4ce8v1BxLIaadxMea1MsTkYSVbAXkuXzU72ki1VIPvHdzlGXtwFE3kfJk7zrgqwdjb9tkIqW5yJNe/yV5baVrwiRo2EKpYwKdpPicdbmxVC2JIFIfvXoVpScoGgKc8i/K352MN+HaF0lxbSskhbK/Q821DCg1FOJMBG3OSAOCVlHeV/B5lEl3u9p3ElVy6S3fZaTRGBqGzaTvRlJ+yYg0CWtfjG90i4bJRBETE0+gvNeHXg+MPx4oHEz9e90rpIRv2p74tm0OYKpSA2TFE6QcikbleEp5ZLXTOUvEqADQPQggOYmnaN2+hLzILQVkEASUPmwhJaezIvZ1Fvc/t6v7vc/I/dDnBtr3dU8ppkc/UK7u2LkDHZ0d2Lljh+7/E0dV4fAjjsaY8VOAIZOw3wGHoKCoDJNmzgMCPphalPV0DAuGmfdzMtQFvMCrP1OjX1KlbKQa7dW8LbltrH2RDJ35RRTdk25vciP4PaSoDHYCI+YB+1+Q2PqNWyWjxDVk/HOWkwHPZgfs5WQo0e6zD6UB63Gi3TusDrrPya8Rc4CDf0r/v30DOXNkkhFzgIUvKsbxsOpZr4eIWtibA+mQPI1qdEGyRoWAj6J1nzidokjNFhr7Ln7DeMRiLJrrgf9eTGPUmKOBg35Mv1sLVIOSrZDqYYmaT+k0BPSDMYthGIZhGIYxTr9MhaRlv/32w4oVKzB16tRsN8UYsZQO6QpRllMUJLrNvHzy3CwoAU67H3j8ZComO+VMyrsuqByvvp98D/DiJaTknHBiZLFaET4uUz6a0rh8+QCF0H/9byqqp+cFFpLOl8kMDJ4cve3hMHleb/uEvo85Ejjyt5QzPhp1X0T/T2bItMj9vHkdUPsqfR93DHDs7RSlYLQYtFCuhsPA+teB926i79POA0qqaWJpzqMcx9HSIAFquh45TF4uRhsrPVVvxeagSXdY+RxLpuIVXBbnSq/4tUhlIhsWjKY0MVuBcccCjkry1t/6sX4Kl6oDjW2vs139PO0cMgJ8+zLVIWjdSe+TzwAmnkh9JxqBMLBciXBo2Ewe1hY7yeHq59RjFQyfGfl54gn0WXuu4t1bOlrovXhI7OUAYOk/6X36QrWotMkE2IvpPZ5hQiiKA77u975498Nw2Ng9MxvK40Qw2j4DBcmHDRuO+vp67Ny1C/fedx+mTp2KQw6Zpy4gF8e25OP8s07H+acdR9dBFDktqVKiuMJQw09A8hRLpvKL1M+nPwA8dhIVmX3tauC8Z8n4BBivUxDY0v23gfsBO5dRNM7AGmPbEXQ00/0bAA7/NTAsSsSk0fuG0ft1nk393LgV+OjP9F44CDjtXjUqyEix63AYeOM6SrlXdRAw9jjlvpqnptMzmSg9j2ykTsfzShr7qaFlchF5vBbnUdtf/B5g1hXU1xq3AO/fROknAwbrJgU7jS2nVcIf+Vvg0eOpdsgRvwHKFGNyQYm6zNAZFLG5dx1dA/kZSF4uFnnW+Mv4w8DnSs2H/ELAouk7bhelcXLvoxpXZzxIhuxYyPcXgJxd3r5RjdAYMYciBodON3QYcfugz021MjwuoHwMcMIdFKFoyqO2yO3xe4B2l5oSKZaM6fUhPYzIW66PbX2Uuro6uFwu1NbWZrspDMMwDMP0M/p1xAJA9RYuueQSTJ8+PdtNSQ+ZSm/kjVOAT0bOMz9yLk1mAUqJ5GvXX2fsUWox57d/BbTpGBO0DD+Aoh2cA2gi+Pm9qRXQDAXJc3TDm/R92rnA/FtiGxWSpW4pGRXMVuDI31GkQqKpjwBS7D59NnmveVzkAT77KvJQ9HuVPPIxog58HqB5J6WqkqM+0h06n2vYnKTgKB9hLL2TkULn7gb9wtcAGcIAit5JxFM0zwpM+QF9Xv2s8fWMYDJTurKFL1E+dCgRNK9dQ3VPjCrZbA41gmjdK/EjK4SxJVGEgTGeomfPamDrYjq+OT9Tf7fayVDg98SOJBCKUKudIhu0smPkHmtzqPvqx97YIu3RqJEjceghh+D7779HS0sLvvnmG5ggKZ80443J74UpFIDJ0whT/Ve0TCrRCgJ7GXD246Ss3LkMeP0XsaNsjCIKOO9Zm9h6fi+lAESYDHrp8GY2insfeZE/diLw4KHKuGeiNC3xUo1pWf0s8N3HZGA89jagbDgd296NlCYtWjo9vbHJ5+YohljojUVGxmufh4xEh90IwASsejp2+rp0MXR/YPQRQDgIfP4v/WWEs0fTd8ALFwMvXU7RL9++RMb4nngO0dZUMGJU0LJ7NfDsQjIqOCspJdSCp4CKMelpYzgMvPp/lG7MOQA44S5KRRhtLPJ5AF9b9+c7gdyX+vozXx+nrq4ONTU1mDlzJhYuXAiHw4HKyj7oFMQwDMMwTE7CEQsg5UefQVbapdP7zl6sTDhc0T3b5TzzchG+o35LXnIt9cCHf6Jcv3oc8gsqVPv9t+TNf/bj8T2LS6uoyPHSe8jbbcUT5OU95ojEvKYCncDKRbQNmIBJp0YqJdPN1/+m92nnADMuTHx9n5vS13x+LxD0kffp5B9QtILfC/gLVONOYaUaeeJuiEyJ5Pd2L0AMpFaMti9ipNC5yRdZ+LprXTfQ0U51Llp3Uv8eOQ+GmXoOReZs+5RSIJQaKOKcCI5yMqBNOgX46HZSinxxHynnD7jM2P7GzQc2f0BKxC8foLQPRjydE0EYFuIVbl6qKK/2O4PS1MiGAptD/xrJyIZRvboiRgpdWh3qvrjAZRfTpk3DN998g2nTpsVesKuQvJ+UaEB6DAsAUDEWOOMh4NnzgdpXqI8c9svUtikUo3vXkYHaaN9f+yLQtocUmHOvSa0NRvC5gU3vAev+B2xbQspegLydRx1CdShEXRejuPep0XJzrqK0NjYnGayDHWS4cVREqe8jPa8IOfV7aDxjudEn2ljkbaXUU9EQ49SYwynN1congNevAS7/MHFDb9AHPHMuABNw7jPxowXmXUPjyTfP0mdtrSrnAHp22fYJ0LKT+pR7HzlgALSfkmFAxTiSX3uZarQV6ToDHWof8rnpN6ud5Lt8FFA2GiiKknpPr1BzokaFjhbglZ/SPWv0EcDJ/zAebWGUz+6ie5bZSqndqg+MLSM2B9U5MSF6tKroS/zM16txuVzweDxYtGgRampqUFlZierq6mw3i2EYhmGYfgIbFpj4aBWn8dKCiJyuXesXAsffCTx3HuWd3e90oGpW9/1Y8qnQ7OMn0gRz2aPAgZfGb19+EXDY9cBXDwHblwKb3qGaBVPOAiy22OuGw+TNtew/ZPgwWyilUqJFKxNhby3l3TWZgZk/TGzdcJhSCrz7W1JSA1SU96ib6Pz5OyjPrt9Lk8mIsHhvZEokMSE35QGlAyMnqEaUp/2JWJNuca5kBbbA5yYFm78dKB2ZnGGhtJpynm//jDyDD01RCRqNYTOBc54Blt4NrHmR+ulb1wM1J1Fkg0gZo0d+ERniPvs7pa5Z9h+S3XQWnW3fS++xFD5N20jxAgBz/4/e5X6vNXpGQyjpIowSCSrfWFHTjUMPOQSHHnJI/AVFYe2AF9irRKGly7AAkPL8+DuoqOrSuyl6adz85LdXNoruAX4PeV1XjI2/zq5VlDYFJopaSyaKxwhBP403614BNr9H/VkwdH8aj2tOST7l3Tu/pSis8jE05gqjnbMccDfSu9h2LHkSchpG/Igg2aEhU+ctV4l2X7HHiXiUx/TjbgO2fEB1PT76M3DMrYm1ofZ1tV7QpvfU9HbRqDqIUgJtXwp8fh9w7J+6LzP1bHr5PJSqqWET4NpM7+59ZLRu2UEGikRwbez6WADgCVTiO1TBsmYUUD6SDOtL70mtpkI4DLz1K3qGLKkyblQIh407wKx/kwz/AHDIL4EpZxszcJfFUC7LfYmf+foENTU1mDFjRrabwTAMwzBMP4MNC0x8xIRDnswLjCrPJh5PqYW+eQZ45zfAZe/pL1c5jpQs7/4W+PjPpPgwgtlCUQZFg4FvX6F0KM3bgbIRsAYC+HPQhHx0wva5Gwj5yOMu6Kd3kQrD6iBlaNlIY/tMlmVKEcPxxyXuff7p36iwIEAK1iN+B0w7G/A0kVLGrngshgKKcsauRioIo4NTMTb4veQZms6ifn0VI5NuvRQ/IiLE6weGTAXqlgDfJ1jAGSDZ2f4ZsOJxUuJNOB6onm0877pR8qzApNNI8br8UWDHMlJIbnibDBzlo5BXMhJjw9XYDk3fHVgDHPxjUtLUfa4oa49JT7vCIVLYArENC8v+Q8tWzwYGKzVzZGOC0TRMQkkXYYxLUIHZnxQ1RvNzJ7RNL2CyqEXFv/4PKRZHzAXKE6xjoMfUs6lPLb2HlIKWfGDUoclty5wHDJxE6ZVWLgJmXR57+bY9amqz/Rcaz7+eKOEQ8OTpSiSeQukIYL/TyFgoUrQly7cvU7oak5ny54fCqtHOWdndWCHLk/gu5FLIqbMovqz5PEBnKxkuyob3L+OC3n0lUSOmrRA4+Z/AU2dSOqxJp1JqSaOsXKR+XvPf+IYFAJj7czIsrHoKOOLXMdrmIMcO2bnD20xpHxs20btWGW5z0DHZnJG/dbYCjd+RnDd+B7j3YRBcGAQXsG5l5H6TNSoAwPLHgI1vUyTBqffGNyqEQ8Djp5CTQfVsShk6Yi4ds54x3rUJeEUp0HzgZcCh16Zn7O9PYxTDMAzDMAyTMdiwwKjEUw7pTUISmZjUnESGBY8r9nLTFwLffQJsehd44YfAETd2D52PRtVBgHMgTV47WoDdq5EHoMs8EaXEAwoHUfRAYRKTykRo3U0RBwClnUiEUAD46mH6POsKYOalZDjwd5BSpmUXpQOwl6rKHXejkhpAOXA5msSo9zZDJKI8FZ65gFpQccAE+t6yM/F9jz2aiiTvXkUKydXPkhFp3DFU6Lz6oPQaGZwDgEOvJ8PC8kfJY7RhE9CwCVYA9wIIIA/mD4eSR2TZCKBoKKVDEqQzWmHZo6RcybN1Lw4tI4pO139FBpFJp+qnW4kVgaCVC5aR+Gjzc6fDyCDO+cAa6vfbP6MXgPz8ItwSHIvVpkkw7akAhk9PLvXWob8kr+11r1BamJP+kbxxYdwxZFjYvQp49SqKyht/PHlEy7TtoeLiPjcZ6w68LLn9GaFtNxkVTHnAjAtIHgZPVQopx4nmi8d3nwKvKOkCZ11B5y1eZI8sW6kY7WwOGtssFqWv9WHDgpFxR/scZmSdsUdRKsZvngXe+AVw6bvG60nJkZD5BmtDCTkIBROva2IvJcNHLONHtHRMI9UIqQ53G37z4jqMDm/HlaN2wNKyneTfWUlFppMxKuz+Blh8G30+8jfkQBCPpu1kfAcownbTO/Q5v4gMDSPmkrFh0BRKrfTS5XS/qJ4NHH4j4Gmk4tNahx82EjAMwzAMwzBZgA0LjEqsPPIyyU5khNJxzJGxlzOZKCXSs+eSkubjOyjVj1ZBE43yUcBhv6JULh0t8Jvy8bf1g9Bhysevp7fBll9AShWLjd7zbJTmpSdqbax4nM7x8FnGJqAy2z4DvI2Ur3r+LZS3vysXvHJuzCYyNJQOI8VLKKDk1y1EV61Uuc4CRyoYx6h8AKrSzGxRvXbLRtG7tzHxfedZgfOeB+q+ADa8RYoIb6NkZCijVC7jj0+vkWH4AcDQGaSgbCLPz2DDd3Dv3YZitAOt9fTavkRqqw2Yfn5i6Z5iUf811XwASK5Lhkdf9pBfUKTSmueBFy4BfvAfUqYKjCgztVENNifl4G7eQcWck00Z05eRPaYTkZOY27TT64JXgF0rgC0fAbtIcW/qbMPBWImDwyuBx59SFHIHk1F64onG92EykzEh6KfixakYF6pmASf+HfjmaWDH1ySrO5aRknDcMUBBsWpU6GwjY/lBP46fnz4VmurovbQaOOr36dvu7tXA8xdSxF/NycDRN6up0mIZ77SypTXgGTU0WB0UqZBoqrHeqIRNRp6MrnPMbcDm9yld0JJ/Gq81ctq9wEdK5GSs6AOZlU/S+4TjIg0TPYmtEGtNE7HWNBGXHmiBxWJSjBym5J7/OtvUugrjjwNmXGRsPdcmei8dQenDdnxNKQQ7W8mhZtO79H9+EVA8HNhXS899J98NtLsoCtJkVlIwpul+yzAMwzAMwzBJwoaF/ki0ybVeOL3esol6p/qUbWx8m74bSY9icwA/eJRC9Ru3Ap/ckVge6jxrl+I+GDBh8UZSRoYqdgC2NBeVNUpnm5r+wkjtCC3rXqX3iSeS4ljrWe0oo5RI1gIyKgC0XEGxek3dDZF1FhjjJJJuwmqnc23ykaLN5lQNY54kDAsAXcuR8+g1/xbJyPA2pUda/Ty97GWUzmjuVaoHfyqYzVQ4s2QYMHIe/IEwznohgAFowH8O3ARbq+L12VJPyo8ZF8YvsGyU9r3A2zeQ8qfmFMoHH7OteZTiA1CNC6fdT8ZMqz35KB13IxWidTewYUEPrcd0Kgpfrdd00EcFgcvHANafAXk2dO7diMcefwxTw7U42LYRps42yvW+6T3g4jcocs0oeUr6kpeuoBoEqRgXykdRSqB9GyjlnWsj8N3H5J08Yi5FNAijwuyfkddxJmmRDAvponEr8Mw5FAU3ch7JlxwtEivdkYzWyKCVTbere40GGdHnElEI90YlrDzuaJ/HEnmW08NRDhx7G/X9pf+kqNKBBtKM2QoTq8vgc1OhcgDY/0Lj6/UEyUbWhcNU8LllB9VVOP4vxvtig2JYGLgfMPdquk6hIBWq/+5Titit/5LuFftqadlT7gHy8oHOBiBgobSfANfyYRiGYRiGYbIOGxb6I9Em13ItBbcruvdpot6pfi9Q/wXQuguw2I0rbBzlwNlPAI+dRJO3z+4CDv1V/ILMucrq52mCXT4GGH14YuuGAmoKpVFHqF6dNklB6ixXC2Z2ecuXR06cOf1R8iSS9svm7O6B66ig/zyNiRVt1EM2Mhz9O1JCbHibPB29TZS+aNO7VKSzenby+4mGyYR9qERoSCFQZbAOSqIE/WRU8DZS7ZXDbzB2zoRxwWQCVj8H/O/HwIl3kUHOWZlc2hRnuWJUqEh83f5GMnm75XFEa1gQ96z8oq77XXjwVLxkPhEv4US8cvVhKGhaD3x6F7DhDeDNXwKXfZBYJECelRSDbyF14wJAac/mXEUGhvWvU1FxUXS2p4wKANBcT++J1vKJRsMW4OmzKTXa4Ck0Plvy6foEWrob7xKJQtAaGrqMeY3pM+b1RiWsLE9uV+TzVrxnOSNMPInS6W18B3j9WuDi15NLKxaLda+QkrxsJKX46QusfpZk2mhdBRlRULp0OBnqCsrIMWTINEpVNu1cINBJBojvv6UovXHHUBpFS4FaS4JhGIZhGIZhcoA0JsFmchphLPArk+pYBXvlyareslYHTfRFgbyAj7br9+hvz2oHNiqh3aMOSUypXVIFHHY97WvfBuCLe8mzq7cRCgIrHqPPB16auJecSINkLwOGzwR83ujLWu1qRIOMzyN5j/KkNONor4NIFRIOUsqDdGG2kDf0MbcCP14CnP4ApU9o3Qk8fxHw3k1qjY3eQjgMLPkHpYewFQIn/DWx+4Y5Dzj1PmDqAjrfb1xLEVNuFxn3EsVZCQycwNEKmSLWmGSzk2HHFuX6m/NIIXfS36nuyN51wFcPJt4GYVwYO5+MWq9fQ57DqTBgAjDvWqpBUDoCqBjXc0YFgCKJAKAkDRELu1aRkb+5jowj5z6rprTxeUlx3KzUjxEGvGhjkRGc5UBegZrmLx3Izy69Ea2cxHuWM4LJBBz3Z6qVsHsV8PXDaWlqBKLY8/Tz01t7J1t8/y3w2d/ps9G6CjIiFVJxNRAMUt2xlt1qFLC1gAx2ww8ADv4xpRsDyPjgrKR3gTaCmGEYhmEYhmF6GI5Y6MvI3r3y5KNwQKRnYDgcuZ7s1Rfh+aZZDlCV1F1ec3ZSMPg7aHIE0Ofdq+jz2KNVw4DRPPBTF5Cn238vBnYup/Qvx/yxu/eye6/++v4QgO30eeRcwGZwv51txpYzEn2w4U3Kr+2oVCaJOueyCx2vbJEGadwxpMRxFNB59UsGBnEtTCbpZVa3F8t7NJHc09r+EvUweqBmhR5G25f+HUd+jahhEaZ0PiIiyNtERqJYGFUWhQKR3yeeBIw6nApKrnyCCqZv+xQ49s/AiDnxtzdov9j/+4MA1tLnIdMBaxxFkdGCoAWl9N7RArz+c2DjW/T95LupJokgkcKfJ91N/WHN88BrVwNH30I5reXCtXlW4/2/N+ZoT5aelKNYHtZ659wktc1soVfhQGD+H4BXfwZ8fCcw+UwyTJsNRi4IeTzjIcqbvuFN8uBe8AQZ7gTlo41tr3Cg+nn4AcDMi/WXM6p018p5NGTFbYsSsVBW3V2hKwyd8TBbqD7S8xcCfjdQORE46zEyLgjyCwFvC+V+l8cXbRSCEeTr7ayMjKDU6yPpHI+yNWYZRSsnRiITot2zxO/WAjJ6zf8DGdM+ugOoOZWeuWTyDRoEvE2R3/etpxopZisw4QTA20y/D5pkbHsWg/LRuDX+MqYQAMWoX1IVe+wqiFKUuqMVeOdGksdxxwL7X2BwTFL6VjisRixUzwIKKymFpcUKBDrIWJdfrF8UW/zuc5NMAHQNTUi9bkWu930m69TWUlquyspKVFenMb0ewzAMwzC9nj7gOsQYIhHPNj2vPr+HUoHIXlE+D6Va8DSQMlDUUvB3KArsDnq5XcDeb2kdI/UV9Kg6iApjwkQh6B/dHqlUz2XCYWCF4rE34wLjilZBKEBKLgAYMY88sP1e1VDQspOMKu4GWkab41oQqw+k6vUmR8T0J7TH7dORE4HVrqZL8DRktl35hZQG6dznKI1Cyw7g+YXAu7/N7eiFXauA/xxDRgWzlYwhE05IfnsiLdKUs0luPrgF2LG8+3JG+3+05fpr/+8JErk3TToVGLo/KcDfviG5/YmaC+OPBYKdVKdj18rktpVtulIhpaAEWv0c8MwCOqejDwcuew8YOFH9XxRrdpaTclPPUCIUoUaihXweiuhqqleV3+yRbQy9+1C08yd+93tp+QknAFUHAwEv8MrPkovs0mP18/Q+9ig1HWAqZM1xQNn32zeodRWOuz1xhbynQTG+mICiIZTys3IMjdmy7MSSGfGM526k1KBWR3Ip/hjGAJWVlXA4HFi4cCFmzpyJmpoa1NXVZbtZDMMwDMPkEGxY6C/YnN0jFRJBnoQK/F5SUvrcgKdFVXhbC5T0B4pH5Kb3yKNr4CRScibLhOPI4xigwpgPHgosvae7h1yuseNrwLWBPO+mnZP4+tuW0GS0oITqMwQ6VK8/+TyL+W209BOx0kAIowOQnIK0vyp/tMcdzagj0lA5B9D3ZAs4J8rIucCl76sFM795Gnj0eGD70p7Zv1HCYeDrfwNPnEKpVkqrgYteBWZelPq2hXFh/PFAyA+8dR0ZQv1eug5G0sMJoi3XX/t/IiSiXAZUJSlg3Cge6KTUQ2YL1aTZ8FZybRXGhZHzqL3PXUCp+HoTnW2UPg9ILhVSOAx8/i/g5Supb085Czjv+e6e0eKep9f3xTV3N+jfF/WwOYBAgDy4o6VjZPTRuw9FO3/id1ELIxwCDlXSTtYtBR47gRToqeDaCKz7H32ecnZy2/B56Bnos38Az50P/H0S8O+jsmPsW/EE1S4yW4FT/hk9qiEWIg1SyTAlWs5L59xRoXHm0TxLyPdP8YznLO/+rJfofZZh4lBdXY3a2losX74cixYtgsfjgcvlynazGIZhGIbJIdiwwBhDnoQCanSCyUIveyHlpbbalUmSkhfZ0wTUf06fx85PvR37nw8cfycZKLyNlIf9wUOAD2+lVEO5yIon6X3KmfHT3+ghJuYjD6HisVYnUKAod5wVdC6cA+m8i6gFZ0ViihhhdACSU5D2VeVPPE907XFHM+oIJYG4/j1lWADU6IWzF1H6ktaduRW90NEKvPZ/wHu/I8X/hBOBS96lNEvpwpwHnHIPKVjbdlHKD5+HjKGi8KmR3OuxlvO2pK+9fRFZUdalcHZFV4IJJSmgnvMueZQU1J4GdTsAMHgapScBgLeuT17BZikAznyEIiA6moFnz1NrFvQGRFsdFYnXdAiHSB7fv5m+z7oCOOZPNMYD3ZWcQR8Z+DvbujsfhAJk9NbeF6PdW60OoGw4pXwR6XtSqYsg9tMfFK2xamIBkedbPq9Wu1KrZAr1eUclsGcN8PCRQN0XybWluR548VLa39AZQPXBxtZz76NC0otvAxadSYaEZ88BPvsb1TzxtZPBYtEZwBf3J5YaLxV2rwY++jN9PuJGKl6eDC7FQFkxjs55rFRoXqkWkzaVpbNSfckOQ9GcGxgmBaqrqzFjxgzU1NRkuykMwzAMw+QgbFhgiHgKVKsjUlnt91IItgjjdg4kDyx5QuvvIK9D4R1dMqz7dpNh8hnAZR8AJ/2DoiD8XmD5Y8BTPwCWPZobxZ19bvKWfeMX5P1nMkfPsR2L3auBWlFf4VigeAhQMoQK2ooJqU1RDHgaVcVOrJQ8sUjWQNDbi2JGI5Ynul7uapuju1FHGOGCPjViYe+6zLddy4g5wA/fogKaAEUvPHQY8M6vqQaD0Rzu6SIcphRfT54GbH6fvECP+RNwxsNqyqh0UlACnPlv2s/614Et7wOmvOh9PdH0RvYMtLkvoI08EB7SIpVHNCWY3r2oK3JOuibydgCqJ3DMH5UUYPXA4j8m33abEzj7CSrC3P498NRZlK4r1+looTERoJQtiRAKAq9eBXz5AH0/8nfAzMvUlEdAdyWn1UHe2wHF8CAbHQI++s1qj1SAipRHezeSEUS+pukcT/pSNJGh57Qo583tAtr3qrKoXc9RQddo+AHAxW+Q4tzjAp44FVjz38Tb+vrVZCQoGgKcel/8os3hMPDJX4H751L/W/4YGTfCQdpGzSnA/FuBC1+lOkKhAPDRbcDLP6KxNVMEOqn49EuXk+Fb1FVIhnAY2PoRfa4YqxOl4JEMro30/CwwWgg9lYLpDMMwDMMwDJMEXLyZIeTJt5HJvFAOiYLBeso5kaKneBiwr5W8R/fWAkffRIrxVDBbqAjyxJOAbZ8BXz1AnnVfPUSph46+ObJ4ZqYJh4Gm74D6L6kd9V9FTnanLkg8z/XKRcBbv6I83+VjKEexuDZWB3m7CfxeCqsXUSOxCjXHwkgxyP6EXMhci1ZhJYqXi2XdDaQcMIVJqW22AGOOBNa+AHz1IPWHWZf33LEAJHfzb6W0QO/cSIrX1c/Sy15ONVDGHg1UHWi8uHoyfP8t1UnZqdQ7KKmiornpjFLQo7mOlEMA1TpxlJPc6JHIPTFWP9EiG6T6Yl5srcFNnEezRfWcBtS8/IC+Eky+F4ltAkqxZqlOjUgJot3OkTcBL18OLPsPMKAGmHFhcsdjLwPOeRpY9AO6x7/wQ/Lgn3V5ZmUkGYJ+4OtHgKX/JOMCQGOkUYRRYc3zZHQ78W+0fmcbGQ0KlfMrj//iO0D/exqAznaKkiitjj4W2Rx0fwwHaflMjT2JyGauEK3gsvaelEgxeVGawO+NXgzb76U+4CgHLn4T+N+PyQj78pVA627g4B8ba384rBZNb9sNvHCx+sxittJ7nvIuiq97m8nADZAhb9hMelXP7e6Ucup9FMH53u+pHs8rPwUOuS76vTwZAp1kUPnifjIqAkDFmOTqKgB0Xt/4ueooMuqQ7suI8+9tVYo5SzKnLYQuDH1ag10yBdMZhmEYhmEYJgVybFbMZA0jk2+RJz6WMUFGKAp++CYVTV3+GLD8UWCLEm1QdVDq7TaZaII2ch6w4jHgk79R7t3nFgJH/JqKTSrYw16YWuoBfzMpfT0N5JHnaaDJbtlIUoSUjQSKBsfft6cR2LkC+H4NGRLc+yL/Lx1BStpx88k7zSh+LxUIXPUUfR99JHDsn2IrsWQFjxxVIn43ooBIREnRW0j1mGIpu2SZkWuQdBkWGoFQJxAKqd6g086hNA5L/gG8+xtarqeNCwBFL1z2ARnBNrwFbHqHUot1GRnKgDFHAeOPS5+RoaMV2P4ZRSdseBtAmNLNzLocmHmJMZlLhbrPSQEFAAdeBtScGnv5RBSSiShFZeVgb1MA6clTNEOCUH6K8ygr/RNVfmmNEz5NdI1Wueb30rgw+2dUJ+DtG4CyEcCow5I77sJB5MX97m+Bb18CvryfZOe428hwnm3CYWDLYuDze9S8+JXjaQw0esxao8JxtwNVs+m//CJScIpzrL1+8neRjk8osrVGCIFIedTuolRJmVL8C9lMRhmcLaIZNbX3pGjL6clpYSXg05FPGflaWR3AWY+R8v6L+4APbgba9wBH3RQ/+sBkAs56FPj8Xnru27fe+LEffQsw/Vz1u0XH6GgyAdPPowjOFy8HNr5NivajbkrduBD0AetepXoKwqBQOIiMKlPOIoN0wtv0Ay9fAXz7Mp274/5MTgZarHaK9HWWAz4vYIsx7vq9ZPBzNwKlwxK7n/bFZz2GYRiGYRgma7BhgSGiKcbkCUiE52ECk5H8IuCEvwKDpgEf305ew4vOoIKyR/42Pco1kwmYeCIweCrw3k3Avlrg7RuBARNg62zH/4Iu2NEJPG9we3k2oHgoGRpKquhVOpyUozuX06tpW/d1hu4PVM0CqucAleMSV2Y01wGv/ZyMFSYzMPcaCrs3mdUIEICuS8AXaeSxaRQQeilEYnlfJxq10huIdUzpNDr4PORlKDynAfrsbgSKyik9kuDwG+k928YFs4UMciPnAfNvkYwMb1O+9LUv0MteBoyYBwyqodRjpeOMbT8cJhmpWwps/ZhkJiylKZt4EnDItZTmIhOEwyRHm96jgpu7VtDv448H5v8xvmyyB3V39OQpmiGhq+5IIkYXtzq+xFKoyuh5wwsF6WE3kHJwzX+BFy8j40Dl+OSOvaCYCrYOPxBY/Cdg90pKjXTEb2jsyRZ71lBh2z2r6btzAHDIL4ApPzBuEGzdRUaT2lfJqHDqv4AhM9RULHKkSTxEKjhrFE9rGauDUlcxkUTr71pZiracnpyKdW2e6LLUZSz0qt+P+SMZfd/7PaXHav8eOPmf9LwTC6sDOPSXFK3ZsJnaEwoq7wEaC0JBiiATvw+ZRs9PRhl9BHDmw2Rc2PYpObAka1wQBoXlj6lOIqkaFACKfHjlZ+RQY7ZSe2tO0V/W6lCjeX31gK+NDHR68mO1q+mSxP0vWhSDlr74rMcwDMMwDMNkDTYsMISh0PsonofysqL2gt5kpeZEmjguexj45hlg5RPA1sVkdBg5Lz3HUVoFnPEgpURauQjYtwFmAKLFYasdJkcFFSd0VKivYAfQVAc0byflftBHSlGt8SACE0UijJhD0RdDp5EHdrJs+RB485fkheaopNQwgyarnroRHokdVLRQa+TxeSgCI4zIXP9GlJm9WeEZDaOpjNIxubYXR353VkQaFAQmU3fjgs8NHPyj1PpPKshGhiNuAOq/piiGze+TkWH9a/QCUADgUQzEZoxE3vIDgcE1wMAakqOAD9i1nIpsbvuMUi3JlI8hD+oJxwODJ6f/OPwe2u+m94DN71EaDpkxR1G0VNN2INBBCrOiQelvRyx6owe1QE+ekjEkRFOACeO1XqqXaMptvXzisjL7hL8Bjd8BO5dRJNsP36K+miwTlXHsnV8Du1dRSrF1/6N7dflo6uPlI5PfvlFadwJL/0UyCpDic/8LgHk/N26sb9tDaZOWP04p90x5VONk0il07v0ddG7l+gpAbMUlp2JJHdloJ3/XW07vv1jjXjz5FOl4/F51udk/I5l57Wryuvc0AGc+aqwoeGm1fhpIc5pKvHUZFy5LzrigZ1BwDgBm/zQ1gwJAcvPylVRnzFIAnHAXMGIunT+BiA7RYtK8a7E5KVIhIjLVYArMvvisxzAMwzAMw2QNNiwwhJHQeznNjh5dodk+wFFGv1kL1O05yul1yj00YXvt/0jx+MyC9EYv5FlpUjjuGKC5Dp355fjRGx1oRCmeu3gCCmKFlwM0qW7/nupBtNQDzfVkbGjZQZPMofsDw2bQe0EJeXSnQigALLkb+PJB+j5sJnDa/UBBKX03WyKjFQD6LiIWZPxewNeufHYkpuzri/UVjKYySgfaiIVYaI0LH91GxrAZFwIzf9jzym4ZswUYMZteR/4W2LGM0ovtraVIoNZdGIq9GIq9wFdfqes5BygKSI+0LSt5oI46DBh9WOJ1RozQvpdSYWx6h4wKgQ71P6sdGHYgKXNGzAOGTCEZ8TbSu78TKCjqe/0+U+jJUzL3jWhpPKx2SqVj8qlGhXjGP0dF9JQhoj+e8SDw5BlkOH7hh8B5/01NYVgyHPjBf4CvHqZ6KfVf0kumaAil1SsbRYaGslFkdNDeyxPF30EpBVcuUur4mICak4CDfkR1hYyMoW4X8PFfgGWPqvIyfBbVPxo8BWjZSb85ymh7bhddB28rGVATrd3DJE6ihm+tc0iy9zTZgcQvpb+c/ANyeHjhh2Q4XnQ6sOCpnq1lFY3RR1Bkxbu/jWtccIQ9qMEmWJa9D+xdC3y/Vh2znAOAmReTYS3VSLqOVuCFSyhSzuoETrgDGDod8DRR9FNHK73LBhy/h/4PA7DZFaNDjCLMWiNePOefruX64LMewzAMwzAMkzXYsNCXCYfjLwOQklNWssqetPLEJdr25MKaAT9FLHibadLkaQZsUsoeEdVQdRDwoyXAm9dRmoqVTwDffQScfE/3onZGPdvyhkd+L6bvYV8Qu0xL6beiYYDdgEKpfBRQPdvYfuUiyjGX0xE39z7g5R/RRB0gA8thv6I0AR4XhcU7lJQ6pmb6LMLl88107pvqyavNWamkrCpUJqYORHd3Q/KpgHLd09po+9I9ue6KWFD2H+38ysqOo35PhSk/+wd5IH92F7D0HmDy6cCsK8l4FY88gwpSvVzVeoQ1Xqg1J9NLoaNlH2669ymMDW/DJRPcyNv3LdCwRfL2HEi1RcYeDYw6lPqsEUKB+MsAkedv4zuUBsPXpv5WMpxqQ4w/jor2BjuB1r1A8UBSxJrzgLCJ7lVFhemJWOlPOavTcaw2BxkQ5DQeAL3LUQs2Bym1Az5K4aK3P08D4M9Ttysv424A/O2AtRA47zngkWPIAPDCxcDkMymtUcUYSjUXNujhXCSlgJmv5IPftgRwbQD2baQaKh4XRcu07abaHoL8YqrvceDlqlx0tsEQBcVA7WvA+zepdRRGHUo56eXon1jpjzwNdH/56mFVmTp8FqVzGnUo3TvdLjLIBDrI8FaapyosYxXbjkemZCTXx6NkSdTwnWwEnrZegq1QTcfjdinRCx2A0wmMPwa4+HXgqbMp9dYDc4ExR5Bif8wRZDg2amjwuY0tl2dwmjLtXIpAE2mRPv0rcOq9NK7uoPSVth3L8GJoA8wIAyukdYuGAnP+j+o2CIOjJU6qp1i4XcDzF1CasoJS4OwnqcaLz0PP0QGfKv82h3oN/B3qWGazJ5aCDOBoIYZhGIZhGCYrsGGhP6I3wTc6IdFbVy6sWTZcNTIA5HkaCijKHy+tn2ejz45y4KS/AxNOAt65Qam9cDow/w/AQT/uuwoDgM7Jd59Q7t223YpH252UiiYUBAJK2gm/F2jepSjHCkg5rE1VJSIUrEq6EKNe4ZxnN33oKYGMnF+TiRSNMy8GVj1D6Rh2rQBWP0+v4bOAg64kxX46CiinA3s5VpkmY5VpMi446VDk2fJISbS3lpQyg/aLX9wzVcJhKij67u8AhIGKceS1PeZoirQwmQCY1PvVAMXoI65TxUgyMoiaAKnSn2QpHcdqdQBlVfqK04goOeUVa3+hAOBuIcOedhk5nciACVSM9qmzKO3clg/pv4JSYPgBwLADyNAwbCYp8Y0yYCK9ZNwuMjDs20gGB9dGivZxu8h4+OUDwIyLaJwz0v9cm6g+kTBAlwwH5t9KaZmMjJPeJiqk++WD6ngxZDpFJI05KnIbVjuluAn6VcOPszJ1hWV/kpFskIn0NmKbABnprHYydl/6DvD0OUDDJmDdK/QC6D485ghg9JHAyDmqgaKnkGsubHwb+MfkiBReYlTahYEYNOlQ5FXPItkfMNG4g0g0wmHq3227yfDi2kAREKfeD4yaB8CkRv6IIvRabA7AX0SOIYka7/qTcZthGIZhGIbJKXJEU8X0KKlM8LXrismMCaSMsToiJ0Q+xdMx4CPPzI42wFFKEyt3A3llTTqZCmouvhXY8CaFs+9bT7UX4hUI7E00baeaElsWA999DHS00O+VE4CzHyfFl7tB9dwWXqLhIBCwUP7rgGKc6TIIKdELJiSuUOA8u+lDL/ohQinjij3hN1uACScAww8G2nYBq58B1r4E7PiKXsVDyct51KGkJPQ2kbHO00hpfTwNlELBq/xWUKym/xkxN3HPx0SxOUlB0xMEfcDrvwBWLaLv+19InuMdbeTx2bxDqS/ijB6V4vOo96t00J9kKV3HGu3aGC1QKzBbVE967TLOysgxacwRwHnP0zizZzV5FHc0U50CUasAJroXDz8AGHcsyWWiRm6nUsNHjnoLh2i/n/2Diop/eT+w7D8UOTHrCjIWaOlsAz7/F7DicRoX8vKBOVcBc68y1ncbtgCrnga+fliNjBg4ibYx5migcID+elYHUCJHfrjiF4SNR3+SkXSQ6HNaJtLbiG0Khbio6VQ+GvjJ58DWj4CtHwN1S4Fdq8jQ0LCJ0vqZrRSZOuZIMvpWjE1v26IhGxf8XnqGHDwVGDYTvkH748I3QmgyleKVEw8no3g8wmEqvPzlA2TgCwaUgtOByM/aiDvnAKWmgnQPiCcDVgdQmuQ1ZMMdwzAMwzAMkyXYsNAfSWWCr13X56GQcW1xYXl5UZ+hZWdkPvNwEPB5Ve/VE/9BHqMf3kr5oxu2ksLdSIHAXKSzjXK+b11ME/DG7yL/LygB9jsdOObWSM8+byvltnZWkKHB0wQUK/l+5XMGKOcuybz1nGc3s2iVMvEm/H4PEA4AFaOB0x8AZv8f8M1TwDfPAq27KG+0UVp3UgTB1/+m7wMmSoaGOZk3NEQjFCR58LWTh7ieMjUWngbgxUupGKbJTHm1D/oRKX5DQYrs8bcr9UWiKEFj9XvZ6xMw7gEatyBqH/ImTcd9I5HzYWR/8vUS63Stq/H8rT6Yii8D5JXf9B2wcwWlSNqzmuow7FtPr5WLKGro2Nuork4qmMzAxJOACSdStMSSf5DR8JungTXPAzWnUl8uH0XKzHX/Az65Q00xNv44GivKRsbej7eZCuyufhao/0r9fdB+VNdl1OGU5kh7XkSBZnlMd1ZGKpUB40WctaTab/qSDBkh3YYYvwdod6lpExOp2wB0L5JuziPDWcV4YNblpGSv/wLY9gnw3WdA6w5g+2f0Wvwn4OAfU5rHnkjVM/oI4NL3yOg+aD8qnAwg5AuiSaTFjEegE1j7Ihn29tYmtv8BNVQnq3Jc5PXL5DMXG+4YhmEYhmGYLMGGhf5ISoX9EvQmjVi3IDLE2+ehiAV5u3OvptoIb/ycvOAemU/pKwZMSK692WLXSmDRmZH5s80WYNBkYNx8YPyxlIpCL/zeXqz/3WYno4JNFFXs6D9Klt6MURkJa97LRwBzfw4cci3VEvj6EUqz4CinXO0FJYC9nKIZHBVURNxRQcrS79cBe78lj+zGzaqidNkj1A9PfwiYdGomj7o79V8Cr18D7Nug/lZ1MOW2Hn9M/PV3r6ZimC11QH4RcOp9pNgSXrRWOxno5HtMospI2esTSJ8HKHuTRpLO85Ho9RLGbncDGaQqx5NXcfgn9NuetSQzro3AqqdI+f/I0cD+C4Gjbk4sTZIeJhMw9ijy5K77nHLBb18CfPsi8O1LVDi2dRew42tavmwkcMTvgP1Oib/tfRuAx05Uo+FMZpKRmRcDk89QU5TlO9Gt/o6obWGCmnbN7aJ3oVQWy3hbKU2Stvh2JulvMpRuJbQ2bWIi90OzhRwdtNgcZOz1tVPNmjFH0vONvZwMdls+pCidrR+Rgn7Dm8D5L1K9gUxTPgrAqOTWbdkBPLMAaNhM322FwJSzSTbtpWRE6Wyn+g+OSnKYybPSeTJblChSSb5EbbFUnteE4S+aMY8dRRiGYRiGYZgswYYFJjWMTmZESLrZEpkiput/DynNAaD6IOCsJ4A3rgGatgGPnUQe3GOPSnfrM8f7N5NRoXgYebwOP5AMCcVDSCmqN0kHaNIoG1xkY4J8rpt30GTeVph8xAITnXR5x8bajlA2iMLmzgrV+NBcTwpyp1Kse9q59IrYrugXGiWD30PFXMOg/11bSYG5dy2wczkpfN79DXlAi0KVmcTXDnz4RyoYizApRZyDgOZt5OH63Bek3D34p6T81LYpHAZWPgm88xsqxFw2Ejj3GcAxgGRMKDcB1UNd9mBPRBmpF5GVDg9Q9iaNJNnz0eVBLfURMaYAiW1TKMrFPdfnAVp3A4WVdN+efi6l2Vp6N7D2BYpeWP8mcNRNwLRzUq8BZDJR9NDgx4Hd31DNkC0fqPnqLXZg9k+BmT80LqdL/klGhZIqMiaMP54MkWaLft0TWVkpzkd+EclotHzw7gZ672glI4tcfDuTUQX9RYYydQ6TSZtocyhRDj5Ka6mtIeT3qs9t1gLFAFVAfbtoMEVkTj+PIhjevBZo3Ao8dgKw8EXqo7lIyw5g0RkUueQcCMz+CRkV8mzq2OJuoLEn4FcMazpju6dBGcMrIgvSG4ls0zMeiG3I8maU/hbtw2Sc2lqK4qmsrER1Nc9BGIZhGKa/w4YFJnkSSmchKXEAtXaASOvj85ICsm0fUDQAGDwFuOwD4LmF5On8/IXAUb+nXNS5XtR52xJK1ZJnAxY8BRSUkXdnKKCfmkPGpvk/muHGpHkH0q8Mj2hTP5uMJqqQjnbuY21HKArcDapsiPRXne10bX12nfVko4LOf34PRS6I/4Y4gJIhQPgMWueBeRT5sGoRcMClCZ+ahNi6GHjrV0BLPX0fOx+YdSWlogn5gC8fApb/h7zDX7+aCtTOuoIK2+YX0bG8eT2ligHIGHLa/eQ16vOQUUEUmAUi84ADkcpII/Khlbd09Xv2Jo0k2fMh5CkYVH9zVABWi7pdo4jIBZ+HPJODQYogMxdQKjp3I5CXBxz5e+CAS4A3f0EpUV6/mtIXHX8HMLAm8WPQY8g04PQHKVriy/uons5hv0osVVj795QCCQCO+wsw8fhI46VA/s3vjTTOyQYE7ZgNkELT76VUSYGC7uNVJqMK+roMifuT30PPDsmew2j3uWTSJori9qEAKcrdDRQpaS2g8SnPJjk9KEr3sBJy5/cq6em8VLz49H8Dr10FNG4hZ5Gzn1BTkuUKslGheDhwyVskg6L2lRwdJ489WsOC36tGh/gdqizpGXTk6yXkR894YLVT/aSAH7C6EzMu9LdoHyZjVFZWwuFwYOHChQAAh8OB2tpaNi4wDMMwTD9Hx4WtfxMIBOD3+7PdjN6BNm2I3v/uBnXSJHtkW+2kPJE98wN+wGIh4wJACqMLXwGmnUeFL9+/GXjjOiremk6atgN716sT4mQJh8kj/L3f0/fJPwAKB9IE3JRHxyOfA4F8noziKKdty4qgeNfDKGI7YjKd6vZ6IzaH6gnt95D3rj/GeYh27uXtaLHaFU9iROYwB6ggJCT5AJR2KMWZwwHVU1TG71GUOVI7rA7yDi0ZRrmmhTHhs79THulY+L3kZdqyMzH58DYBr10NPHseGRWKhgKnPQCc8DdgxMEkB0VDgKNvAn7yJXDo9UDhIKBtD/DBH4B/Tid5f/R4MiqYzMCRv6W0aPZS2ofNQcrQ/CLV41qbB9zqUPOJp0s+AGN9oj+TjvOjtw0hT+lUjnkaSEnY2ULpxAaMJbnraAJ8HSSf1QcDl38EHH0L7bv+S+DfR1Ff9bnT15bBkynF1yn3JF5/ZMWTdN8YtB+l3AO6j7tApOezVYy71sj7T6y0K0LOnBUkWzYnLS+nTerrUQWZQNyfwkjtHKbzPgeoMhcG1a/xNNC7aGe05xqrnQx1QqlePISMwoMmU+2DZ86hSLpcQTYqFA0BTr2fooZEBIE8tmjHHoF4lgMoOsRaKEUkRqlrIV+vrvubjvOJzUm/a2XVCLGeQxgmAaqrq1FbW4vly5dj0aJF8Hg8cLlc2W4WwzAMwzBZhiMWJNatW4dbbrkFu3btwtixY3HMMcfg3HPPjb+iRGdnJzo7VWVda2trupuZO8RLTRARuu3onvpFqwAsHQo07wLsVvX3PBtw4l+BAeNJifPN00DTVuDMf9OENlXWvQq8+n+UYqViDFBzCuWeT6SmQ/teYM1/gVXPAC4lf7zFrkRX5AGOQnViqj0HgOIF2E6TUCMTP+Gxnu9Mvt5FLMR2RLqmLExGsy5HsneskeLL0c59LC/bLo9pHc/gwkHUd8S6fg/JhsUCmJQXQH1H9ky1KoaQqMWJvUDNyVTUuW038OX9VNS5ZQcVfG7ZQUU3W3ZSnnePNGF0VAJDpsEycCoODpuxEaO7bz8cBta/Drzza2VdExWlnXs1pWyy6kRZFA0GDr8BmHMVsPYl4PN7yIP8i/vof3s5yfvIefrnUByXiPgA9HNapzOVilAGtbvU65iDnqBZk6N0eMjqbUPIky+QvraGAdhLSKac5cq+vVTHJOAnI67fQwa9SacD444G3r8F2PQu5Y3/9n/AcbdRNE22CPqA5Y/S5wMui0y1pzfuykaD0mHd7z/y2C2+i+XFS0Ysr02bFItelJ6lR+RI3J8Ki1M7H4lGacVDyJzVDbgBOJR0R3rGBL31BD4v3esXPAm8/GNKg/f8BcBpD2Y/zaU2UuHUe8lxQzbAyZGc4p4vp2Dze9VoE7MFKDWY6km+Xkaicryt6n3KKH092ofpUaqrqzlCgWEYhmGYCNiwoLBx40bMmTMHJ598MubPn48PPvgAd955J9599108+uijhrdz++2345ZbbslgS3OIeJMVvfRHEalfCiIVpz4vpaAAIj21Ax2U47agHHj310DdF8CjJ1AofbJFncNh4MsHyFgBADABDVvIi/uzv9N2a04lI0PFmO7rB/3A5g+Ab54BNr9PaZ0A8ggfdThw4GXk9SYmgH4vEPDRBDIcJCVuQRlNzvXSGsXCJ9JIaZR26Zo85sAkNKfkyIhCOt45c7vIK9pZ3r2+hlZB4fNQX3BIygOfl4wKgQBQOpD25W6gyAW/juI1ajvtpISceg7w+T+BD2+Neehd2wz6yFCw5QNYtnwAcWXCD/yBaocMmQoM3A9Y/Syw8W36s2wUGQsGTKT+XjiYfo9WX8SSD+x3GtUkqf+CZMvmpLQu5SP11/F5gOad5MUJRBoaoiml04HoEyZfTqeYyJocpcOI01M59YWCVB6PxPhTaFdlTaQ2sVcAZzxE9RYW/4kMcc9fSIaFY29LPNIgHdS+TgbuwoHA/ueRclMgG66B7pEIsqFARCoA3Qs2x8rtHivVSzR6UXqWHpGjTIzfRoziRpHHqWTaZFNSI5nzgAteIpnZ/D7w0mXASX8HJp2WWvuSRTYqlAwHTrmXnvnCoUgZkFMbaR1lhIyIKA5Rt0XrRKJHtOuuFzXk9wLQRDcyDMMwDMMwTJZhwwKAcDiMJ554AvPnz8eTTz4JALjuuuvw6KOP4sEHH8SCBQvw3HPPGdrWjTfeiGuvvbbre2trK6qqslSkzmgtglRTAHXfMb1pPRu1yjh/hzRh6iBluUixIPB5yCs4z0rpKM55Bvjfj4DmOuCxk4Ef/BsYd4xYWL85eVI+7jwbYLYBb98AfP0w/XbAJcDBPwPqlpC39eYPgX0bgH13AJ/cQfUeJp1GSk9/B7DqaUrP4t6nbnfo/uTNWj2Pin+K1CyiYKa/kyamHa10eoJB+m5zqPnwhQFGr8imTL4zMYVb1vpB8vSIHBk9L7EUPm4XKe5EWpBouBuAYIeybGV0T1KRv9xsoVQKgnynUhBTWl70A2sBSKMRB5OJ5K2gDJh8OrDhDSqO7qykVEllI0mxUlKlpLeoJONA8VCK6Pn+W2DXSgS+W4r62q9RjR3Ia/8e2PQOvQRmCzD7KopCaP+ejAo2JylqhOFQjzwbyYe1AKieC0w9O7oiUyhdfB4yKgT8pAQW955kFJ3xkPuLuLf53Op1zMHaLynJUSrHo+fVnuj9JZbcJaRYM+kr6eTfnJXUP6Pt22YHvHl0/zdbgGAAGHMkMGIe1Qj5/F9kUPvuE+CwG4CDf0z1GYwQzdCmRW6flq+UsWzquUCeptCzCXR7MCG+kUAv8sBkij/e2JxAfmH0/3XXceS07Mjk1HhklHA4dvSC/N1Ivn5fjPVlWRHHof3f5oz8fs7TwCs/pWjPV/+PnDUO+GH3/YYCFC3kcSnjrfI8WDYSKBtBkUUAkGfg/hLqxIjwDowLb4Vl8WLg+9XAnjXU1uJhwIKnabwDuhsEbIUkR1pHGZ+H7g8+LzkOdBl1FMO/L6w8C8a4vnrnUk9Ww2H1xTAMwzAMwzA5AhsWAJhMJuzcuRN79uzp+s3hcOCSSy5BQUEB7r33Xtx44424/fbb424rPz8f+fn5cZfrl1g1E1JAzUfr99CkzVlE34W3l89Dk8igkpLCUU4T0jd+AexcBjxzLjD/VlLkGMHnAV69FNjwFgATcMwfgYN/QpO+itHA/hdQCph1rwLrX6Nc2nvW0Evr3e0cSMrP6eeSV7a7UVXKCMUmQJNOqx3wNAEFxZTiRih7xOQ1EQVoDkQUZJpeI0dag0E0RFFmOVWP7Ekqy4ReLmTtNfcrBjcTFMOCgXZ6mkixb7UDfidw5iMkV3n5QOVotR3+DkVhrxg4TCaKxBk2Exg2E4Gas/GjjZ8hP9yB/54/CPl7VwO7VwI7lgNFg4DDfwOMnEv7dVSoSk0RgSEilvwd1B5ZsSqUNoU6ud1lhNLFBMBW1H15PcV2Juip/SRJzsmRrEADkk/TkmjtBj0lnRFPfIHVQSm5ChQjtbi/O4uAo28Gpi4A3riWcsa//3uK3Dnhr0D1QYm1E1CVhkYVzTtX0FiYZ6NIJC1aw7U27ZFMNEW00fRGiZDjsiOTc3JklFjRCxG5/Q0aFqKtH692QFc6JWm5PCtw+gNUp2DZf0h+vvuEHEzcLqX2yT7A24yYhnNHBRkZSkeoxobSkUD5KHLe2LUK2L0K2P0N8veswUMh5d6xTNpGxVh6rqwcp78PbVSheG41W9RIJ+05EMYGm10dV6Pd6/TOpV7EVmEl4EshcgToVSnImDTSXE8yFQ9racabwjAMwzBM36PfGxbC4TBMJhNmzJiBDRs2YP369Zg4cSIAwG6346yzzsLGjRuxePFi7N27FwMHDsxyi/sAYhLmdgGdbVSsuWgATTC1qUyE4lD2HrPaKQ3Sh7dSupR3fwPsW09pKOQUEBpKwy2wPfcDYM8qUqae8RClOgIiJ1t5NopOGH0k0NEAbP2IXju+pmiCUYcBk88CJp9Gk2OZjjZSlkYorez00uayTkc4O08Ss4vWYBB1ucpI5ZxWaSAUC0ZzlPs8amoGi6LA8DZR8Vm9tnibgFCnalywFwGBAkWupLoHnkags53yzWvroMhtB9BpKkB4+EHAaMWIIHuAy8j7EF6cbXvoN09TZHvlSAC3K9LDXLtNv1e5ZxhUThqRFZanzKItLJtsmpaEl9epY9ItVZ9HVQRqU/SJe7hPU2tAMLAGuPhNqgH07u+AveuAx04A9l8IHHVTZFozLYFOYNcKYPvnQN1SoP4r+r3qIKB6NjBiNjB0RvexRiAi78bOp3uHNjqjW+RgDHnJVBodJvtox5xEU40lun6s/8V91monA1yejVJTrvtflJ2bAHspUKC8wiGgpY7GNU8DvXYuj3sIJgBe5GMLRmLijHmwDK4Bhh1ARdPNBiOMIqJ6KsgQqHfviJClBjV9JdB9jNE7V3rGinQ4lfSiFGSMARSDgb15I/YfbIa9eSOwSxP17HEBz11gyCCfb3VgQPjP2GfKgDGZYRiGYZg+S783LJgUr8ATTjgBf/jDH3DHHXfg7rvvRlERec4XFxfjmmuuwV//+lcsXboUp512WhZb28ew2kmRaS8kz2k9pY9sbJAJBijlROV4MjCsfJIKvp75iG5R5+HhXfhj6C8w79lHnqfnPE2plQQR3nvKJM9RRt5o08+n1C7BDkpplGej9glFj8+r1FBQ8uAL5W3IT8fVpZiSPM2a6pVUSAYLNgu0ik+eJGYXrcHAKN1SrSSg5BF9wJynKu1bdlEaofY9gH9k95QM3ib6XD6Ylnc3KkY7TTFlvxfoaFZTISWCVoHpcyv1DyzqMQvlbNFgNWJB9xjjeJPH8nb2uemYTaBjEMdnRFZYnjKLnkEtGe/baB73sYgovqqjcO+qXeNVo3ead6n1O5yK53+0VHUmE40V448H3r8ZWPkEsHIR1WKYfzMw7TxaprMN2LGMohu2f04K0WBn9+1tfp9eABnCh80kI0P1bGD4ATQ2tn8PrH2Zlpl+Po1BniYy3uUXxk8lFsuA1lM1LpieQTvmiO/JpgSMW88nxv/iPiv64CHXAWWjyVhQWgU4BwBmK1BQQv28aAgp8t2NJI/5irPJvvVA4zaSH48LaNoONG4BGrdS5KnZCgzajwwHQ/dHZ8V+OOOJPQiZzHjl4EmwdDbS8QcU+TNUE0FjkHQ3AI3fAQWFAAYox6cxMtjsasRCrKL0PQHLdd+huR64dxbg96AGwIorC4FPrgQ+0VnW6gAWvgg4YjzXuTbC9NLlKDG3YR/YsMAwDMMwjHH6vWFBMGbMGDz//PM4/vjj4XA4cPPNN6Oykh6sbDYb9t9/f5SWlma3kT1BT3jsyt5qjnIyLlgKpNRBDvUlws7lyZ7fS8UoAUpdNGg/4IVLSVHz2AnAwpcoX66CqbkOd4VuRgnaESqugvncp6lugow82RKTPFGQuQs7oKfPkgv3BQIAAqTcsRWQ8UFELcgkWrBZoJ2UpnuSyB7b2SGaYkHveog0RSJFSThEkQreZqrd0baTlnOCFBytu2hZc74aHWD1KvmfvZH7tdjJI9Si6a8R0QhSShBPA4AoCky/V61/YAPJsfD8BiKNH3p4W9Xi50aQ6y742gGEI8+rnqx0ywPOSpeMoqeczDTCwOVvp3EmWk55m2LoDkP1QI6o3wE1pUm0SBqAipAfch0VNf/8HqDpO8ohv/5NYOQhZAgPdESu46igqITqg6lug7WAxrO6z4HtSyklTN1SegFkaDj0OlKshvzkdT38QMDXBjR/B5isFCGndy66apPY9A1o0VIg8djACFLtC+I+Cyip8TzApFMia2zJ6TAFctSnuwEI+CjlUWl1ZFSQ30N93WqHXKso7AsgZNqrbN9LBglTvvrsKRs7ohVf1qau9DSRcaKjndrh0xlbhUFSL91hrHMZ7zwn838/SKXZb/AosnPGw6h1hXD++efjqaeeQo0SdR+Bo4KMdgzDMAzDMBmADQsSRxxxBP773//irLPOwq5du3DWWWdh6tSpePLJJ7Fjxw6MGTMm203MPD3hsevzAJ2tpMSxFlDdgY5WUnRoC65GeC6LiZEdsBYq3pkNVN/goleB5y+kYrRPng5c8DIZF0IBWN/4KfLRjk0YiaqFr6JgQHX3NhmZbInIhK51RIoXKboCIO9xi4UUVKLegs9Lx2sCPeDLea+jTWD10Co+0z1JZI/t3MJo7mVnBfXFhi1AKEj9THhgWwsURaaSssHqoP7WtA2wl0R6VjrL9VMgyXJolQwLsaIKuuolFJCnqb8d8BfS70LxAkgRPVLxV59HWcZDBhLdc6NJ+RKRPq1QeY/jYRsvDzjTu4hWBNViBYJm6hfRoh2sDsAiRS0IA1ihJB9CpsQ4oC0ILX7ztVN6pFPuBb77CFj6TyruvPFtWqakChgxh6IPhs4gj2ytwnLIVOCgKynVyp61wHefAvVfUD2Ftt3A4j8pC5ooGsLvJcO2rVCpi6JznLKM6NVyAbqnq5Kj+HhsYADjfSGa4ls8+7gbVKeMrmcl6XnIWREZISDLiKeBjHgmJXLPL61n5D5uAj0jmqDeE7SpKrXPnnrnASBDX/EQJYrUC3jb1Gg8Ud8IAOzF3dMdxjqXidaxSPR/pleze88eDAFQ6wphxe4gVu4JwVs6Hhg6PdtNYxiGYRimn8GGBQ0nn3wyli5dimuvvRY33HADLBYLrFYr3nrrLVRV9QNvj57w2LU5aLJlsakTSuFtppefXZsbW0wu3Q2Aey8pcRwVwFmPAy9cDDRvV40Lq56BeddyuGHHreaf46FUilB6FOVowA8UDoysnyBHJJQMVY0IwvjgbkRXTnyrQ1EEK+dYTK6bdwAwkXJXr5094THKHtvZxYgHfTSlidUBFA2ltEcWKSd8ybDuXpT+DsBspn6aZwdKh6rbtRUiosYBQG0wQTWeCQJ+oLBU/a6X3z0cAkyN9L9IvyQUt3K7ZMOCXkRPNEOCMGwkU3eB+3vfQjfNiDAQDFT7hbYvCbRpwnTrlSiRNNHSdQkv6ZCf+uKBlwNVs4DnFpLR75hbgQMvU1PQREut5G6gtjjLgSFTgMH7AVPPpvR6G94AFv+RlKpzrgaqDlRTiwW9QF6BftuNyIgsE8IJQLQjmjGC6V8YvW8KeXS7IscsYbyWi6CLbTVLaSIBNa2d9tlQds6wOZSaIIrRz8jzkb8DqKzuHo0g0Hv21NKyA+hopPSasrzZpXHSo9Q3CoUAc3n3cxbrXKZSx8LI/0yvpa6uDueeeSaWXGTB+eefj5V7QnA4HF2R9qlQFaaoV9OebwBLlNojOilnGYZhGIbpv7BhQYcZM2bg1VdfRWNjI9rb2zF48OC0PKz1ClLx2DWq+LY6gLIqNR1SrEmP1oszYjtK5IIJildqPnDaA8D/fkzGhcdPJs9OAPeYLsH3pgHJHZdAKDmtBZGRCF0KKmUCarMDfntk8WahbNKbIIsJbLCDlEzuBn3DQk94n7HHdnYx4kEfT84Kiuldu67shS0UkP5Oiq7RpkSSlaaA4qXtB7S782tSukRTtjrKVWNHrHZ1LS8pjaJtW6v4iVV3IRrc3/sWeoo0vX4R1SjgAKUJC5Iy3SpFqIk+ahfyFUXxKPbXWabKx+BpwBUf07IlOimK9HA3kkLS3SilMCug92nnAKMOo0LreXmU5kx4SBcOUgwACdYmiTgH0vlzN6p1UlIxzDN9B6P3TSGPAR/Jm7eV5Ed+9tM+34WldzntpVWzrHZdI4YAmYLi2NEIRvB3KMYMaRyUDecAyWXrbmX80zlvsc6l9j/t2J9KnQumV+NyueDt6ABQiKeeegre0vGorKxEdbVORLZRHBUIWx24wX8fyd9/YixrdcB6WKwFGIZhGIbpT7BhIQrFxcUoLi7OdjN6F4kovrVKw2SQJ5bN9VQUs2gI1VhYdAYZFwAEx52AxVvnxt+ebj57yXBgL++eXsLbqHrX2TQKow4pHN5mB/KjRLzIxyE8Q6Mtx95nfRsj1ziWnMlKDZEnXk+Z76ygl7yMTLcClY0UWdC8E3AMVpezWCOVs9GUO7GiLKwOaoeIkJCVn111VzSGhGge50z/JZGILr1+KmQBoEgAE8jA0KUMFXLVEdlP5egevb4Y8FIRWXt5YjVDnOWKcaNAifDLjxwriocobSlQf/N5qBBtqmOrwOoAyobzuMMkR1cUnCKbov/H6kvOCsAvPR9aozhkRNuXFjlFEmzq7/lSRISeg4vfS8+U7kaq7aDX5pJhqow271BSXWqiF8TncDB1pxBObcToUDNxYnrSH5VWofOKz/GL+18HANx18Wzk60UsuDYCL10Oi68l9X0yDMMwDNMnYMMCkz5SVXwnUmtAu7yjAsiz0QTPYifjwn8vBsxm+I+8Cdi6hdbpaAKsUJWZcmFAvYKWEbnlpdy7oihzGKTcCQRIcSQraAs0aWPiHadQ9kar6MzeZ30fI9dYK2fRDAjuBlJmeBopd7xcS8HdALTtopQppcN0DBQaz+bSYWRUsFhJUSrIl3LWx1P2y4pbILI9cu562agge5XLbXK7Ytd36NpfhlOHMblDIko3Pc990QdNeZFGN9k4LFKFyXRTQIr+2wH42oD2fVQ0unhoZFuFUSC/MHJMENu02oGB49RUeV5PpCFBz9vb5uieriziGJMwyMn3FJYpxghGPOsj+qIjUgZkw19ZiilI/V6KKnA3AibJsOAoB/wt+nUUfEr7O1rpnrD7W6BydPfC0lY7MGCsUkdhH/1nseuMp4pBMlXjHDuXMJmmZDg2m0YBAMKDpwE2VhMwDMMwDBMffmJg1FzP8QiHY/+fsOJbs99o6SmiIS/vrFQnXZ1tQNFg4MqPacLn86nreJsAcxAorVIVUR2tFBYvClpa7aBCt0q0gglkJBD54ANeNZ81ALTtBQoHUIFc4QWX71QngCbF48fnpvZ0NAH5SjSM7GkqJqr5GsVVNOJdj0SXM9oPmMxhRHFnlfoMQH0xrKRjkJWeNodS0NUn/a/IlaeJ+r1ZpKTogL7XptSesuFAu0uNIgDIoCcmntHkV+SQF+30tlDRaLm9srzI7df+5vdQGwKKrJgtZGSQ15HPTzq9O1mO0k86FdWpKt0i7tlKoWeTWad9Sj8Q92yAao10Re841PZ4msgInacY5DxN1G8DnYosNNFnv0dVfloLyMAtti3qm4RB6wQ6yXiQzLlLdIzVEkumhHzEaxfLR8+Qjue6ZOXTyL1XWxzZ06BGf1od3R064qE1sAusdjKue5uAPM2zlTZyyeehuglt39MzpaMMaNlN9YjcjZIBxEOOLH4vPa/lO9VnxXwnYNZ4eecXdTdI6rZfOddR658kke7P6LjFMAzDMAzDMEnChgUmd0hUMaSbzkIzWbU5gEBI+r8D8ASVHO7K+qJwdH5R5L59XlIWBf1SigzF8JBnVbfnKCfFkl6BXZHiRSh5fe2kQAr4gcIo7TZqWGByl0wqZLotFyfXu9Xd/X9nuVrk1QR9r03tfoTxLtyp3ybRDkA/NYyQb+H1Ga8gta6XqwcRRdCB7rm7xXIAF5vNddJp/Ek2okuWVW0NgVjtE/dss4UiFbQyZnPS754GxSiASGWpMPqFAvSfME7IBm6/l4wMQcU4HvSpNVSSOXeJjrFGislr4XQtfYdkr2W0fhLRnzTjllxbwUi9BDnFkdWhRhxp6wVZHRSxVxAEOjRjlzbqx+8lI0TQR6ksy0fS+iJFpTgfYUSOLTYnUJ5iSj75XPd0ej8jRg2mZ2mup7EjCvbmjagZYO7BBjEMwzAMw0SHDQtM7mBUMSSH0GsVQd0KujoQkVfXVggU5CtRDoqCU5uWSPZENVmAsJ8iFUyWKHnpw/S7Xtu1CmBbIRkOHBWR4f8iNUYiObiZ3CXdCplYy1ljKAN8blWxCUhyU9E9rQNAETWyMUTbHpsD8AejtEkxZIg0Re4G1VhhpNCkEWwOdBVBl+VVzt0tzr3ZwsVmc510pPbwewF/Z3wjXjRjn1ZWI5RsMdonjzV6aYnEOOWoQFctBjkNkWz0cxapx6I1yAkDhMWmGByiyKYREpVBt4siAPOLgNLq5FK1Mb2XZK9ltH4SYaiuiNyuXFtBlqdwuLsRAVBTHImxy9tIz1ByyrGu47BTxJClQP3N0wigUGPgtpOjiNVB9RPEcYhxRNwbCovTbzTLptxk06jBdKe5Hrh3FvW3KNQAeOoMB4J5BchzVERdjmEYhmEYpidgwwKTWRLx3DayrM+t5noHYk+ChMJUVoQWDwVMivenuwFddRVkb22RMzvgB0qHoqsgrljHZleVslYHpUGKhpgsiu1qJ9NdkQod5HHN9E6S8ezVw2g+c6MKQr8X6FQ8/EUf04tMAGhfYSUdS9lwfWOA1QE4bDrrSgYMm4MUoCZf4saVWMfcpdSp7N4mvWNJRkFjZP+cXz55jOReT2abeeHo/UzsU6+GjsDbqhqntFE60donjxfy965xR0mXIgxsWkO4Xr0D7Xgmvvs8kdEKQOLnLpn+G9a8G0GvXewR3TtJd12naOOiu0GNCtC7b4txzNNExoFAB73blHoMLTuBxm3R61qJqIWQT/1NG6Un5LZkuPKbNlVnhu//4lynM1WYz22szWwMzC08DdTfzngYqByvu0jt+vU4//zz8fh/n8WU0hTrkCRJQft27D/YDHvzRmBXlOgJRwWlnmUYhmEYpk/DhgUmsyTiuR1tWVkB41fqHLQ16ReplFMKAfTZ06z+b7MDtiK1IGagQ52kAugqHOhpBCwWMiiIaAR3A+1bG2ofDXkiKo5Nq9QVxySUWkbzCTO5hbbvpkMhk66UIiEfkGfX72M+j2qoC/oATwtQUNh9n3JfliOAuv6XDBgipYyQ20SUFbGOWfzndqnGG73zksq5N7J/TvGSPJk4h1YHgM7o/UzsU6QYsjk0/RmRRt1ElGzdCjc71DFIpEsRBjZtXQO9egd6xgaRDkmOVkiGeOdepO0LQzXeFVYCPkfqCkf2iGYAzb1Zsla5G4FQp2Jc0PG+ttrVeiWte4B8ZQwrHU5K2N3fAgE3ALMaSaqtuWCzRzqZeNuA/Hz1uzaNppbeeP832uZYUY9M9qgcDwydrvuXd08IK/eE4HcM6tk2AUoqWQdGrbgNK64sBD65EvgkyrJWB/DTr9i4wDAMwzB9HDYsMJklESWNvKys+JEnfFY7pSQqGqi/DW0qJL9XLbKst5xFKZTZ0apGLjgrKAze55HSHUGNXLAZVP5HKFMcajok7TGzl1jvJxMef+naZuFgJS2QjsLGr9QRCfipXxfZutcLATQKCh3Dgig6LvJjywrSdKWCEv+JvPSZUPAY2T/La/Jk4hxaFWNxvH0WSOlLRLou+d4s2pSIYcpqJ2WoXLi5y1hc1D0FEqB+B9RaCgI9Y4PYXqrnLN6593lU46AvjRElRvbN9E7S5cXvLFcjFvSwOoCSoSQHpjxyBhHPdZ4mwJZP0Xbl1Wo7tDUXtNF2ds09I15dh97Yh3tjm5ncp7QK+OlXqF2xBOeffz6eeuop1Eyc2H0510bgpcvJ+MeGBYZhGIbp07BhgcksCSlpHPqKn4hc1k61UKZYTvwuQtnlegk2B+ALdN+XUOjLBoaOVrWQs/hPi99LuXzlXLzR0ObBz1Y0AqdwyTzJKODiXZd0KfXkNC/d9qH0yULJEFeks1+5L+ulRRE54wVCfrVe2oJoxx7rmMV/No9xZYnfAzTVU37tkuHxay7ES+PCNRtSI92pVZLdZ7d7c5JtsjlUpajJE2UZjWzIRZ/j1QjSW98oiaadsjlU46BeVEcqKQ2zcd2ZzCMbnMX3ZJ4zrEpEXaxnpC7jgOZ3RxngrwKsBWR8cDcAXiVlktWuRCoo0QtyxIJs1NN7doy2/96Ezdn72sz0Dkqr4C0dj5V7QvCWRo+sYBiGYRimf8CGBSZ5Mqmw1ip+ZMWKtkisUF7GC2WPth+AUh/lWWMv6/MC/nag7Xs1dVJJjP3kykS0N4bw9wfScV2EDGoLvsrYi1XFj1Zxoo2Y0cstDUT2ZT1DXbfltZFDmntFKseeiFz5PIBHuU9YkjQMsPzkBvHScSWCkT6UyPhmLyYDnsVG7121THRkUs94IEc1pMt4lWi/tTqoQLNANu4Dqac0ZPoe8nNaKtdd++wmK/rjOWQ4KpQoOVHEuQkIdtLn0uH07m6g6AVvs7ReOWCz6O+/q13slMGkmeZ68uCPhWtjz7SFYRiGYRgmTbBhgUmedHmr6WFE8aNV0IjvAE0kY3mfyfi9ZFQI+iM92EQqJNEOmx3wFwLWNlo+kYKWmcDopJfD4XOTdFyXiNodMZSYEXneHZHrx/PUjIWnAUBh933LXtYiakAUXBf1EXqiT9ocgKOSIha0URssP72LeOm40kW0Ys8RRjw5ykZTJydevRy9CAS9FEjx2if3W73fUu232vWTSWnI9G20z2nJXHefh/pvGJQ+DKBxxdcO2Aop0iwefintkb0MaNsFIEzbFfUVfF7AXhrlOKKkQUqnkYyNFExzPXDvLOoL8bA6yGjWFzBiKOEizwzDMAzTq2HDApM86fJWS3r/GgWN8L4WhZm7vN+8sbcjGybEpFgUiZYLNVsdQKmS+iKRWguZIpHCfDyRzT0SvS6xlIfxlJjaPO9d20wiykfGiDLU51HrOBT1cGoUqwMYOCF6u1h+eg/x0nGlC71iz/LvWlmJWidHJ/InGvHyu+u1T+63er8l0m+NpC9KJqUh039I9rr7vUCeLVLWhHwblXMRsSA7gsj1FeTl9Igmw+k0knEkD+NpoHvtGQ9TYeZYRFG019XVweVyoba2NkONTCNKkWe8dHn8ZbnIM8MwDMP0atiwwBjHpFGUaBX7WfdSVNoXMRk0kbdyxDKa4xDHZTLpb8Nkpt9k5UvhgO7rx8Ono7zRI2xwNh3RxhhtMLo9JjOky1MxFeVhtDztog8BZJBLtI2yMigWgQAVj+5JhUo8uTQqP0x6MHqOo92voqXjMpmSu/9Fk0u9Ys/y79HShRkh6j4TqKOgp+yMpwCNdw+KpfRM9box6cXIeZavdzL1OfRI9z1SHIaeXBVWAj5H5PNXLGyF9BLkOyOf3/wdZGgIdkgr6TwLajEyvsa7HuJaAPrjpVY2jcqR0evBY1vuUTk+qZoEdXV1qKmpgcdD/cnhcKCyMofrPilFng2lfuIizwzDMAzTq2HDApMeZMVIuhQMRhSy6fC0FEqVdpfquaY3oUzV40xv/VSUzkaVURyCn11Syj0tK4hkI4ArPddT9POIYukJbNNRAVgNDCPhALBvM33WyyGfjT6abFFcpm8QTS619/50Fe/WSwkW0R63msoPQMy6KVriKUDj3YM4fVHfQr7eRvuQrAAHoqfaSvc9U6/vphr1ol1f9G9zfuRyqYw7RtcV10KvWLv8P0cyMHFwuVzweDxYtGgRampqUFlZierq6vgrZpPSKjYWMAzDMEw/wIArEMNkCW0NBy1CUdPZGn0ZIH56CZuDJn0mxN6fWE5b3K99HymF4qG3frxjTAc9sQ8mOnrX3ShapYNQTKT7eqbSRoHfQwYKbf5gm4MK2oZ8ZFzQyy/MfZTpSYRSMOiL3+fT1TfllGB6+/R7gc42wLWF3v1RUvgl05548i3uLazY7Bskcz8X/crd2L1/5dL9Odo4E4uu/h2jhkKi+zS6brxrkY6xl+lX1NTUYMaMGblvVGAYhmEYpt/AEQtM7hLPi1Ivd3syCO822QMt1nLaNhj1DNRbvyc8RdkbNbuk4n2ZTNqTZEhHXvRYHuADxpJRwV6s75nJfZTpSXweKsxstsTv9+nqm2L9oiiyZrWTUregiMa0whj54BNtD9c96F9Yk4gsEP1KFB/P9JiTLOn08Dd6XHr7NLpuPNlj2ewbNNcbS/nDMAzDMAzTB2HDAtMzJBNyHm/CFU9Rkyjx9hereG6yE+5UCvimK00Gk7ukI01ET6UZsjkonZjJR/uU9+WsjC0ruXpMTN8kkft2uu6fccczJ1A6TC3irC26nkwKGpYTxihy/5TTIonfcyVtXDqNHEZkW5wLE6juSjLrsvz1bZrrgXtnGYuisToohWQfQi4k3SvSMzEMwzAMk3bYsMD0DNG8zFKZePW0wjxa8dxEJtypTjSTyZ3M9E9EX/N7gDxbemVPD6uDthXNmzSd8sp5qZlUSGdfTIccyQYEOQ+730v93O9V7/eJ9H2WEyYZcrXfZENRn0h0k966qZ5HNk7kPp4Guk5nPEyFmWPhqOgzNQcqKyvhcDiwcOHCrt8cDgdqa2vZuMAwDMMw/Qw2LDA9QzQvs56ewPq9gK0ogeXlCIE0eMpp8/ImOmHMpZQETG5P+kVfC0M/h7NR2UvkGDPVP7VtYDno30SrP5ANunLTu9S+mXAhWMmAIL5b7fQSnwWJ9H2WEyYZeqrfJDp+6o1ZmRyD/YphPgygsDju4t1I9zNjrj1jMJFUjgeGTs92K3qM6upq1NbWwuVyAaDIhYULF8LlciVnWDCSKqoPGWYYhmEYpi/BhgWmZ4jmIdrTig+/B0Acw4I8UZUndekobikfbzITRk5rlFtkc9IfT6Ei+lhhcWqyl8gxZqp/atvActC/SaRwa6YRchTwJX8vkA0IspHBWdk9Mi2Rvp9tOcllwysTnZ7qNz4P0NkKuBuAsqrkDNeZHIN9SrRfMtEKQHrOIxsHmRymuro69egERwXJyUuXx1/W6gB++hUbFxiGYRgmx2DDApNdelrxoS3SrLfviHRDaZ7UaY+XJ4y9m3T2j3R4b8qkq2hkLig2cqENTO6QS0rqrhz0nuT7qM0ZaUDQRimkSrYU/OxtzcTC5iCjgsWamuHa26oWnU53+7I97mTbOMgwmaa0iowFRopfv3Q5LceGBYZhGIbJKdiwwPRt/B7A06Z+t9oBX3NsZYc8mczkpI4njL2fnqwbkK10QLnQT3OhDUxm8bmNK7/TqXRPF+nqo1ojQzrIloI/FxSzTO5idVCkgpE+Ess4Zk8iTZHR9vG4wzCZp7SKjQUMwzAM04thwwKTPUym9G4vHO7+m1CoyMjKDr02CMWO3vaM7jeXSPd57m/01PnT9kttv4qWDqgn5CgaJlP8/ee6fDA9Q7x+kEhh+kzIpNFtGu3P2ZRLLXoK/nS3L9ZYyqSPnrhuPYHYb7w+Ivp9NONYvOc5vX2mE36+YjJMXV0dXC4Xamtrs90UhmEYhmEYXdiwwPRtbA7AH9T8xsoOJgeJ1y/Z+5fpy3D/zhzsec30dqLdHzJlYGcYAGiuN5aiJ0PU1dWhpqYGHg/VFXI4HKisrMzY/noFXOSZYRiGYXIONiwwfRurA3DYst2KxOGil4yWbCsHRZ9EfvbawPRdWEGYHnjsYBiGSZ3meuDeWXRPjYfVQcrsNONyueDxeLBo0SLU1NSgsrIy9WLJvRUu8swwDMMwOQsbFhgmkySr5OGil0yuIfpkMBh/2UzAClMmF8j1fshjB9MXyVS/znV5ZrKHp4H6xxkPA5XjYy+bYQ/5mpoazJgxI2Pb7xVwkWeGYRiGyVnYsMBklv4+aUt2MsxpQZhsoie3ok+asxSxwApTJhfI9X4Yb+yQZZtTAjK9hUw9EyUrzyxH/YfK8cDQ6dluBQMkVuSZUyYxDMMwTI/BhgUms+S6EibTJDsZznbaG6Z/oye3ok/6ArHXzRRsbGNygVzvh/HGjkSKZDNMrpCpZ6Jk5ZnlqHeT5doJfRlRZDpraZs4ZRLDMAzD9DhsWGAyS64rYTINGwiY3kguyi3LEpML9PZ+mIuyzTDZIll5ZjnKTYwYDDwu4LkLslo7IRZ1dXVwuVwAVCV9b6CyshIOhwMLFy4EQIWma2tre964wCmTGIZhGKbHYcMCk1l6uxKmJ+jv6aKY3CMTcsv9nGGSJ13yw0WyGSZxtPLHcpR7JFpseeGLgKMy9nI9nCqnrq4ONTU18HjUY3A4HKisjNPOHKC6uhq1tbVwuVyora3FwoUL4XK54hoWZENK2qIcOGUSwzAMw/QobFhgmGzT39NFMf0D7ucMkzwsPwyTPVj+sovR1EU5Umw5WVwuFzweDxYtWoSamhoAWUwplATV1dURbY0WcSGOSWtI6dEoh0RTJi14MucMUQzDMAyTK7BhIcOEw2EAQGtra5Zb0oMoxxyXdHt6Rdlvhy+AQAc9tLa2tsKXb018e34P4PMCNnsGPLkD6raDCfSTPuApJ+QiHKfPsBzFoIfkSNBNnmxxhhGxvWT7uVG0MtoH5MMovUKO0tifE+qDRu/jRvtLtuTSl2b56UfyYZReIUf9jWzdN7SI8QsAWtv65ThjlITlaNPnQGGMOhWeBuClK4CAN/7OLXagdDJQONxIQ+Mv08O0t7cDAKqqqjB27Niu33vqXpOSjEjk5+fDbrd3pUXSYrfbsWjRIjQ0NMDj8eChhx4CAFxxxRV45513MGHCBADA4MGDMXjw4KTaEBdzCXDBB4C3MfZyov89ckb8bVrswBkPpSV9Vmu7G0B8OWIYhmGYXMAU5hEro+zYsQNVVey9wDCxqK+vx/Dh0SeCLEcMEx+WI4ZJHZYjhkkdliOGSZ14csQwDMMwuQAbFjJMKBTCrl27UFRUBFMPeza1traiqqoK9fX1KC4u7tF99wR9+fj68rEB6vHV1dXBZDJh6NChMJvNUZfPhhz19WsA9I9jBPr+cYbDYbS1teWcHPWm885tzQy9pa2inevWrcOECRNSlqPectyC3tTe3tRWoP+1N1fHo2Tob9euJ+lNbQV6vr1G5YhhGIZhcgFOhZRhzGZz1j0NiouLe8VDW7L05ePry8cGACUlJYaOL5ty1NevAdA/jhHo28dZUlISd5lsyVFvOu/c1szQW9o6bNiwuEqcROSotxy3oDe1tze1Fehf7c3l8SgZ+tO162l6U1uBnm2vETliGIZhmFyATeAMwzAMwzAMwzAMwzAMwzAMwxiGDQsMwzAMwzAMwzAMwzAMwzAMwxiGDQt9mPz8fNx0003Iz8/PdlMyQl8+vr58bEDvOL7e0MZU6Q/HCPSf48w1etN557Zmht7S1nS3s7cct6A3tbc3tRXg9vZmetu56E3t7U1tBXpfexmGYRimJ+HizQzDMAzDMAzDMAzDMAzDMAzDGIYjFhiGYRiGYRiGYRiGYRiGYRiGMQwbFhiGYRiGYRiGYRiGYRiGYRiGMYwl2w3o64RCIezatQtFRUUwmUzZbg7D5BThcBhtbW0YOnQozObodk6WI4aJDssRw6QOyxHDpA7LEcOkDssRw6SOUTliGCZ12LCQYXbt2oWqqqpsN4Nhcpr6+noMHz486v8sRwwTH5YjhkkdliOGSR2WI4ZJHZYjhkmdeHLEMEzqsGEhwxQVFQGgG1pxcXGWW9PH0atD7vegw92Ocx9aBQB45pojUZBvTX57erCHSNK0traiqqqqS06iwXIUg3T3U7E9vwfweQGbHbA6uv7u8AVw7j8+BAA88/OjUGDjYSTb9Ck5MtCf+2Uf1J6XKPLJ41Hy9Ck5ynXk/hytLwOJj1sx6Jf3jSzQp+QoVr+S+63Nmfr2ZLJ0H+/wBXDu3z8AwDKSbfqUHPUzWI5yB6NyxDBM6vCdLsOIsMTi4mIe8DON7gN7MWxFAVgKNtK34mI2LOQg8cJ3WY5ikCnDAvTPs80XgKWAlD/FxcX8wJxD9Ak5MtCf+2Uf7HZeolw/Ho9Spk/IUa4T0Z9jnMM0Ghb65X0ji/QJOYrZr6Q2p7GfJrS9NMMyknv0CTnqZ7Ac5R6cJoxhMg8nG2MYhmEYhmEYhmEYhmEYhmEYxjBsWGAYhmEYhmEYhmEYhmEYhmEYxjBsWIhC2Gi4KsMwDMMwDMMwDMMwDMMwDMP0I9iwIBEMBrs+m0wmhEKhLLaGyVn8HsDtoneGyWW4rzJ9Db8H8DRkuxUMw/Q2/N5st4BhIuFnNIZhGIZh+gBcTUZh48aNuPPOO9HW1oaKigrce++9MJsTt7t0dnais7Oz63tra2s6m8nkAj4PEArQu9WR7db0SViO0oTcV23ObLeG6WH6pByJPs0wPUSflKP+CCtvswrLkQ48n2AYhmEYpg/AEQsA1q5dizlz5qCjowP5+fn46KOPcOONN3b9n0hapNtvvx0lJSVdr6qqqkw0mckmNgdgttA7kxFYjtIE99V+TZ+UI9GnGaaH6JNy1B9hxW1WYTnSgZ/RGIZhGIbpA/R7w0JLSwsuvfRSXHTRRXjyySfx4IMP4vDDD0dBQUHXMiaTyfD2brzxRrS0tHS96uvrM9FsJptYHYCzkiepGYTlKE1wX+3X9Ek5sjoAR0W2W8H0I/qkHPVHrPZst6Bfw3KkAz+jMQzDMAzTB+j3bn/79u1DW1sbzj//fABAQUEBgsEg3n33XXzxxRew2Wy4//77MXToUITD4bhGhvz8fOTn5/dE05lkMRqBYtSglO5C3wkYsvoqOSVH2eov6e4H6dov989eQ07JkVGM9K/e0Ad7u5xnanu9kF4pR9kil/ufvEw4nJ5ntz7c79NNTslRf7uvpXue0lfGN4ZhGIZh0kK/j1goKSlBR0cH7rvvPjQ0NOCmm27CY489huOOOw7HHHMMvv/+exx99NHw+/0JRS4wTDe4SBuTy4j+6XNnuyUM03fg+z7D5B6eBpZJhskEPOYxDMMwTL+j30cslJaW4vrrr8dtt92GHTt24JNPPsHjjz+OBQsWAABOO+00zJgxAy+//DLOPvvsLLeW6dVwkTYml+FCzwyTfvi+zzC5B8skw2QGfpZkGIZhmH5Hv49YsFqtuOyyy/DNN9/grrvuwujRozFnzhwAVLTZ7/djyJAhGDhwYJZbyvR6uEgbk8tw/2SY9MNyxTC5B8skw2QGHvMYhmEYpt/RLw0LYU2ORovFgrKyMgwZMgQ2mw0ff/wxACra/Mwzz8BkMmH8+PHZaCrTl+AibUwuI/one5gxTPrg+z7D5B6OCpZJhskEPOYxDMMwTL+j36RC2r17N5qamjBp0qSotRLy8vIwduxY3HvvvXjooYcwbNgwvPfee3j//fcxdOjQHm4xwzAMwzAMwzAMwzAMwzAMw+Qe/SJiYefOnZgyZQp++9vfYtmyZbrLhMNhFBcX484778SZZ56JIUOGYMSIEViyZAmmT5/esw1mGIZhGIZhGIZhGIZhGIZhmBylX0QsbNy4ES0tLWhpacE999yDq6++GjNmzAAAhEIhBINBWK1WhMNhjBgxAtdccw0sFgtCoRDM5n5he2EYhmEYhmEYhmEYhmFSZNWqVbBZSJdUWVmJ6urqLLeIYRgmM/QLrfm0adNwwgknYMGCBVi7di3uuusufPvtt13/W61WAMBjjz2Guro6WCxkb4mWMonpRfg9gKehZ/bldgF7N9A70z/we+h6+z3Z3U662sEwTO9AyLx4ZUr2+d7C5BqZ7pM9JVtM7iL6gM+d2e1z30ocPndML2LevHmYOXMmZs6ciZqaGtTV1WW7SQzDMBmhzxsWgsEggsEg1q9fjxNPPBG//e1vsXHjRtx9992YO3cuzj77bADAp59+ittvvx2/+c1vEAwGAbBhIW343ED7vsw9oMfctwcIBYwtm+rDqrsBCHbQO9M/EP3Ll+IEJ9XtGFlf7t88MWOY+GRz7IqHkHl3g7F7R7Iyn657HNP/SHWc8bn11890n0xUtpi+R32GvBcAAQAASURBVE/1sWz3Lb8HaKoDmut6z/Ngrpw7hjHAvx95BMuXL8eiRYvg8XjgcrHzIcMwfZM+nwrJbDZjwIABOPDAA7F27VqcfvrpyM/Px0UXXYTOzk5cfvnlAIBDDjkE1113HebPn4+8vLwst7qXEw5HfpcfAq2Onm2LzQH4g9H/93uoXTZH93ZqjyMezgqaiDor9P9Pt6HKaPvYQJYasc6f6De2FPt1qtsxsr52MhZNJuP1K/n/cDhxOckksjzbnNluDdMTROuDcl9IdtxJZewyet9N9j4uZF6MNzYHLRNte8mOb/K9hccSJh5yH5H7nPZ+bKT/RZM/vfEu2vbk+0DYZuwY9GQrVfh5LbeId57T9WwXbb/x7qva/pKO8UwPnwfwtdNnqwOwSjLSk893iewnU9eGYTLAxAkTutJvMwzD9GX6vGFBRB3k5eXho48+wrHHHouXXnoJwWAQVVVV+PTTTzF+/HjMmTMHV1xxRZZb20fJ5kOg1QE4YkwmIya+KbbTWUkvpv9gc6ZHgW1NcbJoZH1t/+6LE7NYiiymf5EOg3YuKzASvfckeyzpuscx/Y9MGcwTGS8j7gMGDQupjsdM7yfT971Et58pBy2bA7AVAiblcw75iUSF5ZNhGIZhco4+b1gIh8MwmUw48sgjsXXrVvzkJz/Bm2++ieXLl2PVqlX45S9/CZvNhhkzZiA/P5/TH2WCbD8E+r3R/5MnrtluJ9O/yJQHWjS0/bsv9vVcVgQzPUsifSGaLPalMaEvHQvTO0hVOZuOPivfB2Slqd8L+Dt7bvxlmFTI1LON1QGUScVkfQZTxwp6+jmWYRiGYZicpM8bFoShYNSoUfjhD3+IQYMG4fXXX8eoUaMwatQomEwmTJs2DQUFBVluKROVVB9cY+UNZWULky3S7YHGEzyWZ0Ylaa/mPt5/+D7B9Cfk+4CsNPV7gLywMZlnmWGyTa4+26Rr7GQZYxiGYZheTZ83LAhmz56Nf//73zjggAMwderUrkiG0047LdtNY+KR6oNrOh9S+eGXSRfp9kDLhnLU7wVsRT2zL4bJFLkY6ZLJnNr9xYjCMNGwOgAoEQvxZI1lhslVsj0nSdfYyTLGMAzDML2afmNYsFqtuPjii2E2mwGAUx71JlJ9cLXa09cWvYffbD/YM72TdHugZUM56vcAKGIZYLJHOoxbuegNmsmc2rlmRGGYnsZqV+8bbldsWUu3zPB4yaSLbCvk0zV2JitjLEsMwzAMkxP0G8MCgC6jAtPLyLbSR35w1Xv4zfaDfTQi2s3FN/s8PSEnfg/gaYvcJ5B5GeDJIxONvmrcymRObavipe129Z3zxfQ+ckVm9WRN2zaOGmJyEbnvZlOeUt13sjLGssQwDMMwOQFr2hlGRihb5LoM2gdXZ2XkA6zNAZgtuecBKreb6dvo9dtMIPqUQEQDZVoGuC8z0dAzbmWanpA3vbEmnbBMMdkmlT6YThnUk7VMykeuPjMyvQ+576a7z/q9xmUsW+MJyxLDMAzD5ARsWGByi55SkEZD7+E43oNrNAVQto+FH7j7Dz01qRN9SkumlKBChgB1v9mUKSb36CnjlkxPyVsyY4jRdXh8YLJNKn0wERkUMuFp6Jm2xSPTRkOmbxLv3m6kzyYypvgTkLFsjScsSwzDMAyTE/SrVEhMLyBeWGumQ331QuITCdGV25ftEF3Rbq4n0vcxmjYlHeHqDltybUymTUKGzBaaPMbLhc30XzKZCkzbRzNZpyDaGGI0nZ3RcSfbKQYZRo42kr8bIREZFDLhbkq8jQyTK8S7txu5p3fJgksdy6KtIxc4ZxiGYRiGiQEbFhggHDa2XE8oqHUni1L75AfrcJhCda12ZXmj7YtxvFZ78sWe/R6gaQdgUcRKeyzpPs9sMNAnl/pzKiRyHDZnfMVjOESTSV874C8ESqvod58nUo7i7TaiXWHEXyHOeY41WdbKEBee7b0Y7c89va1oRDUS2zXjRJS2JNvECGOC1N/DIePb8LYCzvIkG6Chr9xP+xs9ISPpIFkHjEQMY0KOnOUAvovTHjeNhz4PEA4C7kagbHj0faX7PKd7e/1NLrN1v+oJeYs3P4qJKXIbAZ++3MnjjCVffa4Uv/uV50V5e9o0TBHb4/GDYRiGYfoDbFhgcot4k0WrXVWC+r30IOv35oai0ecBwgGgtREYUMweoUzuEda8A+mTI62BwiixjAVaGWKZYnqKaAr+TCPvK6K/h9V2xZMze3Hm28kw6aAnZEvIkU+qD+TzAH6fIkeSUV6MhyYAfj9gsXKEHJMbpOP5R2zD5klO7vxeIBQE2vYAeTYgvxAorWanD4ZhGIbp57BhgUkvPnfmUxXJD65CwZIqySpFtW0zWYDigVL7Mpy6iek7ZLqviHQTtkLAUaH+LhvrUiFZA4XeZJnlhkmUdPeZeAp+LekYQ4D4yqNocib2D3DtBCZ3iCeX2TIWB7xAnhL1KhsWxHhYUAw4EV1ZavR+w2MZk0lijTsR/2kiWpORO78H8HnJ6GaxU0SPGA7Z6YNhGIZh+jVcvJlJLz1V1BKgh2inoiB1N5BRo6sdbiXti1t/XYDa6G5QH76FsiYZxOTRWQ7kF6sP+D15PpjehbaIXqb7it8LWGxqXl2BVo48LnoZKe7nk+TFaieFZroMfSw3TCLE6jPJFEFOtChkqmOIEXweOoaA4mmtN4YBCbY7iXPDMEbJ1Xu5RTNeiWdGQJWfWPcAo8elXS5ZeUu06C7LdP8g1rjj9wKdbUDLTrUvJNI3GrZGFjzveoa0A2VVQOFAoLAyPcfBMAzDMEyvhiMWmPSSznBYoayP5gEqlCl+D4Xkyp5n8sO2NT/K9pWHbk8j4CiPrRQVeXf1PH9EW+Qis4JkiuoaLdLJ9G60RfSAzHoax4tMEDLjbaVUKvJEVChZ/B7A26auE/ACKEreWzuaNyeH1TOJEqvPJJvHPRp6/T1dkT8CPdnwe2msMyuPbs07KVWLvP9YMiO2KehWP4LljUkz6bqXy33X7yFP6cIEDGh67UKeqpAV45+7UZWjWNs2elza5ZKVt0TWS6boe38hU8/a2vu1/B2IHbWSSlRLrHHHaqf5TZ6UziuRfhTsBDxNaoSrvC+OUGAYhmEYRoINC0x6sTnT97ApHoA9DZEPzno1FvwdZByQiVfAUn7oBlSvbT2EEcLdCJQO6z4hiTbJNPrwzRPB/oe2iJ7WKJWJ/cVSggiZcpYp35XJcShICsygF/B1AAVSG31KkUtPAxWFthUmpkCKNsnlSSujJUJRY+v+f6w+k25DlRh75LEpnnzFUjwZ8YgW78IA7veSUSHgBwrl/ccogim2KYyHPV0/gsltMpG2J+mUK5p2yH03rETm+AxsO9Z9I8IBRZEpk9+Y4jXWcWnbH8tobvScJyKnLNPRydSztvZZRnv/Fk4kYdAtWo6EScW4G2vcsTmAkmGqoUz0NRMo1Vc88vIBR5n6XTZwm8yJyR4/zzEMAKC2trbrc2VlJaqrq7PYGoZhmPTBhgWmZ0hUqQJ0V7wKz7JQgNI/mEAP6VY7eXFqEQUsY4WqWwqAQEf3yAg5X7XPCwQ8ZLwoKO6ekxdIXRHKE8HMkMsTG70iekbam+5jcjeoUTvOCjVnrpxPN9AB+FqBYJAUmQKLleRBLgot0rOYQJ5uNidHJjCRJNOHI5QvOvf7WKRyf9Zrq1BCymOTduzQHpue4qmzlYzVZcP12+dtBawFtIzFCuQXdTeAFyoG96b67gorLULehMFdT/GZyHlgeh+xrmMsBWemagrEMiLI7ZD7rohYMFL7oEvOGgBbaeSyet7e4nNELa8EjynWedTKm1GlciL3MDbMRydTzxza7epFqgR85IABRPZ1wHi0qttF44GzPLojijx/AdQIA7eLUhmZLTGeL6X1iocAjqLu/4eC3furSLEkRxJxNBzDdFFZWQmHw4GFCxd2/eZwOFBbW8vGBYZh+gRsWGDik47Q4WjePCINjN6ETUyOrG50i1gw+SJTQngayUgAl/IQLU0YPe36bRL55DvbgdKqSOWQnBYGineco1zddrrhiWBm6A0TG/nau13x25vuY/I0KiHvjZFKS79HmYTmAXYAnc2AvQxwlKrLyOnD/B2KccQL+KXJs81pPDIhkfQBeuvk6jVmIkmmD8uKmij1k9OO3wM07QAsyjgjKzltDn3FZFdKFc3Ypqd4EgYDvfPg85BntqcRsJeokQm67dTIXLRzKqc0i2Vw16PdBfjaAFsRUMaT4F6BUaW9IJY3vRGZ9XvIwNWVnitBJbz4DnRXtCYT/Snkzt1AbXI3ao7XqT7TirFXL3Kw3aVG5BVWGneK4eiC3EP0I1OMyK5Utqv3XaSVFNfYhEiZMhKtKmSxeQdgNivGBTl61NM9mrujNdIZKlZfE9uX50veJsDfojiJlCvHFCXlns9DcylAjSTivs0wXVRXV6O2thYuF9Xyqa2txcKFC+FyudiwwDBMn4ANC0x80hE6HM2bR3h8xpqs6oX6+jxA0EcenH4vPTx7W0kR6vfSA7fNia7aCAJPAwAlXYsJQKATMFuBoL+715rfS15B7gYg2BFpsBAYycXLZI9cntjoKX2MtDfVY9JGKDjKVcOcuwER+XP9klxWjicjgz+obstRDtgsJAciQshqB6yFJF+y96dQGLldsdO/CC9uawHJczzlc28wHjGRJNOHZUWNL5CZdmkRynS/BSgarOzbQ+NIGCQ/2jFBpJoII7Jf6imeyoZ3Pw/ivuDvoO82O41zhXbNcpo0LkLmjJzTZGTGpHlncp9Ynv96/SSaN327S+3ThTFSqPg8anquojj9SjZuCSNCPEVrIpGu4visDio06/MA5iCA7/TXi5WrXu772nOqG9GUxDOhjw3kfRa5X2uNsvEU/XLkTShA40HY1D3Nq3Y8EGn6Al6geBgtE8uRQ2w/0KH+H4ZksLZHjmMmc+T+bQ4gvzAykkh+joz13Mcw/YTq6mo2IjAM02dhwwITn3QoZ6N588hpYIzi96rhvHKEgXjQ1nqPihoKQGTaCqsDsDpJgVkyLLIN2uiMUEDdnjYtU6YVmj536hEj/ZVcjgTRU/oYaW+yxyQ82lp2ksebiFAQL3eD0rejKELF72HJsOBpBFAYqZTRMwSKbcWLyOjy4raQEsdIeoBcNh4x+uSyXMp0KdGlEAm/V/XMFH1OHhPksSlev9Q7D+K+YC2QIiMc6BamEU3m/N74SpxkZEakWGI56z3oXedEZE+sL0eIxlpX7KfIwD6iGRFi9UvZ0BEhGxJ6xyd+i2WQlKMXBELx2vW8Kgybmqi6VJ4Dxfpy3ZPecG9kjBPtfhtLFvUib3weiq7WW0c2cIv0lBZr9+Wi7UNs31Kg/u8oA/xm1UnEL0VF2Aq7H0tpFIUpO38wDMMwTJ+HDQu5RNhgfgejIbzp2p6YcIXDxrdplEQVTMKrywTy4gT0FZlCCWO1R3pYmy00Qe5oI0VqvpMekPNsQFAz6RSnxWIDfEHKKxroUDxVxaQySAqgcEjNSW+z6x+T1sMnGtpzHO2hvKf7Qaa211dIVDbSpRAPhyLD4MV25e8AGahCor+aAHspEApFbsfbSqmOwqHIfVgK1AlnSJKToJ+26ygHLPnK/8HIdU156mcxObXau58vMWmVDYRd50ZeVtOvot1DstVPWT56F9qoNllZ6awEfB1k6OpSMBaonpnWAlq3o5WUMF3K/oJImdHKk0w3WbMB/hDJoWhHKEDjh3aMEUZ0uc8ZUeIkY9iJtw6PMz1DIuNMrGtmxPtfmzor2lgl/6+NNPBJqSxlxb21gPqyeH4C9GVGHm/yrMr4EqJo01BQTYdpjqFE9XuUugz50ZfREg4CnW7J+CF5iIuxLhyMHelgBDFey3VPmMyT7rmMmAN0RZBJ11Hu10aJ6FdhRKZhldou5i15Nnp5GhXnjzBgcdLjUp5NfwySZVC0MWSJ/N9qpui5cJhSI3W20/in5+Sk99wJk7Fn3XRfD6P0t/GDYRiGYTIEGxYYY8he89HCv5Mh3na6PMaUB1W9aIWIdmoebG0OADb1f0c5kAd6+M6zUJoLXxvQthsoGkL/axEP9O5Gmtia8tQHfKudvvs9QPOuxHILGz0f7JHde4nVv9PptS1H0gg50RaVFRNVexkZyDxN9G4vU9thsQCe5u4TY4GnAWiR8lR3tAP5OjLj9+p7tulFQYhICNFms6V7gVqGiYbPA9hipWfRqdEjKznlejpaj2G9dEVWB1Ai92ElKs7TBJTYqWC536MUi9XIkbuBlDP2suh9vCsvd4f63e8B/J2U1iLPpiiDoimDU1R0pgLXO+k9JOJFHG+sirWtiLFIkTmfO9JApueUIX6z2EgW2naTorNoiGLQ66D3rv1IY0m3NnjICBH0GDs3Xcdtp2fFkF+tz2C1Uzt9XnV8jZcfP+Y+WFZ6nEzdp0RhY3+M+3Mq6CruNXQ95xXGHgP8HurTJlB/Fr/JqZAAkjNfG41vwqARzQYgZN3ToKYLFIWcM9nHedxhGIZhmKxj0IWa6ffoFdiTv6dru9H+Fx6lVntkwVgt2lRF0RAKz/wymiD62gFvc+R2mncBLbvo4VtMKoN+etDWbt/nJaNCRyspf/xJnhc51N/tUifKIg0F07tIl5xoETlrRT+z2qleiWyI08qJ1UFKT4D6e0cjvcuyFQiQcSGa/HiagVCn1I52/WXlCXa84wgF1SgGuc0+RTmb6LnTnhumbxOI18ekMUFvfBD9zlmub7COd/+12mlcyLNqUlEEaVyQad0NuPfSe0QbPaTAFH3W00R9uGU3pS5r2EayGgYZsm06458wZgBqjaGeJlP3Oyb92BzGUs0lsi2A+q3Prf6nNxZp5cOnIy/iN38HPZt5GoB9m4Ev7gdWPkkyJyOPJeK7R3qGCvoo+iih41KcSsyK4VC+dxh91kwGHsMyS6buU1Y71aEClBoHCWxfe831+le0Puf3KuOHF9i1AtizOr5h2eel5zdfe6Qc+tojl7MWqM+FNjvgHEDRedHoaKV2+NqV7Sd5jhORAR53GIZhGCbrcMQCYww9r3lva/cCYunYrt7/chHYmDmrDXhryt7UVjsQ8AAte4COZjIkWAvIq7SjCTDnk4KmoIgUOpYCdQIs70Moekx58T1KYyHnNOacpL2fdEebCMOBzyMVNpaiecSk01kRvSBgoIP6aUG52m89StHmkiGx5cdRSmlaBAGffjFXrRxG8yYV3qoih7BecVp3Q3wvPZl2F01qbYXdCyUyfQ9PI+BQomJ0U65o+6LyWY5kSNXjuGRo5D6sdtUDO2LZAsDvjvS0Bkh52lwHbHgD2PQepXkZMQcYMx+oGA2EA6RILRkQfTzoUsR6I48/WiqaTMDRdb2HdHoRa2voyH1Qr3aB1a70E0kmW/cAxUqBdL+HDIZhAPYSIFQEbP0Y+OZpMhYAwPLHgaNvAcYdrT7TiYLqYhvC0OCoBKweIOSLfyxCXiwFqmHB71WVqbKMZyoyKF40CXtop0am7lNCDjwNxiIX9Iond6Xck2omuBvU+Ypen/M00biyaxXw6k8BhIHJPwCO+wtQECWaz2YH/IVqxIKQuQ6NYcHmUJ4LlQgh7TmToygA2l9QkTO5kHOiJPIcx+MOwzAMw2QdNiwwxrA5uz8g22OknzBKvMmtnEdaRi+nvAi9jaZUFQhvub21wIbXgdXP0YO7o4ImoGXVQH4xfS8aDFROpPD7siryRtJVGCn7C3hJ2SoMLiKcH6BcnvEmgkZzGjPGyeYkPB3KG73Jp15hY6NGNbMVsBeo0QvyJFj81hXFoPXetgOOEvV7yRDAHiN9mHwMoaBiwJAMDLHOjzgeYWST0zrFQhg6jBSxZXIXo3IrR8ZolZpAd8Wm+KynBE2mjSKdhKNcvXf7NWldBCVDKQ2SzU77r1sKbPsM2PYpsG9D5LINm4AVjwMlw4HBU4GqWUDVQfRZT8ZFehbtf3qpaBI9RqP3T07r0jdIdszUOoJEXc6pGR86gHw7utJ/+ZSUXx2twLIXSQ6attF/RUPJON6wCXjuPKDmZGD/i0j+TFIaPdlo3fVdU/9H99hFarRGwG/vrtDVixZKN/EUpVwMNzXS/Vym95wk+ku0ugtA5HWUr7m8TiyHEZ+Hah607ADWPAd8+xK68hStfQHYuhiYdBoZGapmRdYTsDqAUmlb7gaKunOUAtgV2c5YDl1y+0R7Rf27VKJ5TJr3WPC4wzAMwzBZhw0LTHIY9RDRFsZMl9ekXk55EcLrj/MQvPEtYNXTwI6vIv9z76XXvnX665rygEGTgGnnAlN+0H3yLCbDolit8LS22CLzdwPdJyRikiJINW8vo9LbJ+F6k8+CYlVxIrzZ4kXzAJET3nAY6GihNBPeJiru59oEtO+hyWrQpxaMzbMCzoGAJR8maykcYQ88sAMFZd1D9bVGBUBtawC0bXcTUDos9vUQx+MGKW+Fl3c8ZZdIW5OI12c20sYwsTEqtzYpl3QiHsTp8Dj2K+kkxPa6aoWIqDYHyZl7L6U0atwC7FgGbP+MDNtaRswFpp5Nn1c/D2xfQkqjlh3Ahjfpd7MFGDgJGDYDmHACMPZodf2At7s8inWiHafbRfLlLNcfc3r7/ZNJnExdczl6Ru6PjjLyunaUkbzsWwcsexTY8BYQVFLvFZQC864BDriE2vXhrcCqp4Da1+hVdTAw4yIydusZra0OwG6L30ZxXwhIBm2gexqkgGKk1xrstPIkjjkRI008RSl7aGefWDIiOwi5tpAjk7MysjYPEP06yilgY41TdV8Ayx4BNr+vRglUHQQcdgPw+s+B5m30/7JHgLJRNG+ZchZQMbb7toRhuoCeDUvQCtPulYBnNz3njZitpjuLOFbZ6CY9g7obEr+HaIvAWx3cxxmGYRiml8CGhf5Gury3jXqIaAtjpuIdCqiRCgA9SAd80iTVQp5s2jybYRtGh7fh+PBi5N/zI6CzlX43mYExRwH7LwSGTKfigK27gNadyuedyvddQNsemhzsWUOv928BJhwHTDodGHskKbdsdqrLEOigMHp7MXngiRBi4WHudpFyNb8QKK1WjytaAVEmNXrbJNztokmZ8E7zechrSxgTugwKLvovHKQUXo5SijiImSpMWd+1EfjvRfSeIPkAXgbQARtsD1cChQMo0sc5gCaDhQOB0pFA+SigfHT3fty2jwoL+g30cZ/iEW6xkhx1pX/SrKe9r1kdgC1O1E+EwSaDhgVOW6FPvPNiVG5LhwM25VFGex1jpQHSS9ESD7eLUi+JNClBH7B7LSlwAl6gs43qJ7R/T+NMRwsZ7YTSR8vAGjImjJgLVM+OVOxPP5/W3bWK8mbvWgnsXEFGij2r6bX8MWDuz4FDfk6pZESaGBPonHYVQ5e2q1V0uhuBYIeiDNUxLPS2+yeTOolec22KPlkBr1coXfbm7iranA+seQFY/ig9YwkGTwFm/hDY73R1O5YC4KS/A7MuBz69C6h9Faj/gl4TTwIOvxEoG6mOMQlFXSj3BUu7fgo1T6NiTMwDHDpGdHcj1SFq3al+RwDwmGmcTMc4wB7ayWF0LDayXDwZ8XvouczvBmDSL3gsX0cRQSc7kOg5jITDwNaPgM/vBbZ8oP4+fBZw8E+A8cdRZPWPlwLffQysfZGM0k3fAZ/cSa9Bk4FJp9JzWruSBrZtD9CyA7bmerwaqkc+/MDjUlsdFSRbk04BRs4jJ6pYCIODiMDQOk7pnVf5mYzryjEMwzBMr4INC7lOupVS6fZEi9c+8XApUgN1FWZNwosLUCemZouqOOkKES4AEKDaCBYb0LwD2P4ZbGv+i/tD39L6nQBKqoHp51HkQfFQddvFQ4FhM9XvcghuKEgP3hvfAlYuAr7/Flj3Cr2Kh5ESaOpZ5P0d8gHeFmqPtYDaYspTlTZigiFPNMREQpynaPnxc0FBmSvtMEpvm4S7G1RFH0D9R/R3gZwSKeCnHOy+dikCRlOTwN1A23OUAvvWA89fQEpPQN22zQFYnarntaykD/qA9r2Aex/C7d/D5GtHAXxA267/Z+8sw9u4ti78jsiWzBh0yGFuoIE2aaBpm7Rp0zZlZsbb3tItf2VmZoa0gaZN2oYbZubEsUNOzLYkW/j92DOWLEu2DMFqPY8sS5oZjWbmzDlnr73XkkdIKEI4xDWRdhKVIERESkfodk7tx8JpF1LB5ay5bQS7rx0tWZ+RjO/gqO24BJ6/KvJwYWQeQ3gyQMH6olD3OGuB9C8758H+VRK4qSgNb1+MFkhqDa1PhjYnQavB0id4PaHXMSdB5nB5KDoJKpXsEaJh29/SF81/TUiGUU+D2yWEtZfQma7aMdGOe0wyFO0BPcHJvvreP4+1fiICHwIJ7NrOocOmEmklYE6BmLiqbQ+qV884bZKIYTBKO/rzESHkQIiDbucKodCsV1UJF3+kd4XzP4YDG+Cf12HDRNj0mzw6jpYxXlonSO1Y+28OJCFNZhnL7V2uJpSskUBs70uF5NbpqxOWDivglTatj/ZJKqG28ejE8PqBmtpOpF3VH+H2xeEsV9t90WlXvXHcMv7x96MLdg79xyPBJGDdDlg7ARa9I/MPkD6h81lCKPjPXUCqTNufKg9HGWz9U6rgdsyG3HXyCAIdkjziQUGJbYKS0AIKdoqM5Yov5KGRDN3GQVoX3+/1H0tVEiKKjzQJljhVpXK0kcZkkTYSQQQRRBBBBIcdEWLhaEdjB6UaO5gWbP+CZYkGe11R6isZ1/bNP3unspw8xfd9wYw4AQ5uE9mIgm2Qvx3yNkPBDkAGyk70LFD6M+ii+zBlDpEBeV2g00NCC+h/PfS7TiaZK7+WbKCSPTD3RZj3MrQaCBknQdexYDD7yov9dXljU8ERkIUUTvCmsa6Fhg66I4HSQ4uYFLViITl0e/WXRPJ6ZXkFX/sIND22qVmUq76HWU+Dxwkt+sGFX0mFQR1Q4XBx4Uu/k0gxH13anqiKArDmCvFQus8n3VK8R7K4NYkx/yxUgJlPQqczRSO77VBfNYI/KVJp8qn3vYdS/RrWjgf4AmFQC+mpvh8qaNVYiGR8B0c4xyWkuWUAsRCqMqEmGQltHS3LukofpgZKrQWQ1FL6qs3TYP2v4ovgX4EQky761TFpovNuSQnySG6ce6WiiOdCQkvocraQE1PukszVkj0w9i1fFVxNhs32koB+1wwGQ/3u6aH6E//zpb1uiOxYJFh0+BG2HJlF2kp0vIx1Asd9/gkhWoJF2UHADbNegnU/yXuJraH/ddDrUmkzIOvVhvSuMP4zyL1PxmEbJkoSyJY/5HNzEiS3x5jUjos8sEdphpIdB827+nyF9q2GXQuk77IdlOCt5uvgj+Ld0PMSiE1R9eRjfZ857WI2rUvx/W5LklQVoqvuixQKodpOOBJ/EYRGuH1xvSp2rL7XWhW1YpCKuqjY0PfGcM7h9pmqtFG2uv0YqbQeeIskbNQGU6xIIPW4QMZp638VPwZ7kcxrEjIq+xWHpRk3/LCLPFKYcPvpRJsMsq9Z/0gi1cbfqpIM5iSp/G5/GnQcBebEIN9vCZ04VZYHJbvB6YRm3eT+EC6hGQqRNhJBBBFEEEEEhx0RYuFoR2MHpRo7ezvY/tnyfVI/ppjgWaNGs0/ixFpQPYulijxDStXvM0QJcbBnJexZDruXivGlx1l9/9I64+x5GZfOSqNEiWdS21PCMwOrCYoiWXTNesGoJ2HjVCEZshfIxHTXAljxqWTc9b5cSvkDTdPqcw7qei04rLUHfAL3w3+dUAGgf2OgNJzj0liISa0qSRIsc7TKNeStfi4CTY/NSTD7eVj+iXzeeSyMey94wDUMVChR5JKOt0U/nwxNILxeuReU7JOJY1GOSjhkCwloy4eVX8ojOkFK+DMGQ/OekvWqZbAF+qlA9WtYe/jLCcDRMbk81ipmDhfqSqb633cCZSVCVSbUJHekrRPMCN1kgX1rIWs27JgjQUf/L03OhM5nisdBy351J6obC70uFsmXH69QK5Euhwu+gOhk6Vsh+O83x/v+d9iEVHC5IK4Rgzj+56sxZMciwaLwUB8CJpRUSai+Ppj0XFJLn3wLVG97gQTfgQ3w290i0QJw4o0w8vF690kANOnmIxjmvy7SSMW7RVJsz1L0e5ZyLUhT/uZ1QBEizu0QUjwYEjJkDBfXRHwfVn8LUfHQ99rq+1pFb179/dp7dUGotlPTOYmgdoTbFwdbrqZ25bBJVXN5iZBrlT4i0aoPj71qNViwcxjs/la8B/56HNZPkNexTWHAjVLJowXw3WEQb/6ITYcBN8kjCDwOJ/uV8qpv6gzQbpg8xrykkgyTpTLIli9G0et+lmUNZjFvjooTQsNkkfGdORFMcdJ2NH8gRZH+11YMeoNPjq+h9/pIG4kggggiiCCCw44IsXA0IVjmbH10oOsKbzDxzzARbAAeKPUTLGvUFAPxTdUJVzmU5kr5u94ky5kTwO4VEqF4rwzQyw6IWd/q731a0v6wJEPTntC0FzTrIf9bUnA73ZTMXibL2AshOjq83xZOsEjRSzlwt3FSKbHmeyk3th6EpR/LI60zdD9fMrOjE+W3BJOn0LwYTHEBn/llcZuT5D2PW6ooaoI2OC/L8wVpa5qYer3hDegPxzXZEDR2Bnq4x6Ux4J95rfO7/uxFcs7dDvHw0K4Vo1kMJP1hiFIfJllOUeCvxyQgAhLAGfagKp8URMbFHYSg84fTXXVZdw1SLtHxsp8pbat/R85iMefcOl0IgTU/yMMQ7TOxbX+qXOdupzy7KuQe4fVK1rUlqaqUjDFaKoSM0dJ+w5lcNuT+FwyHugLiaENjHz9/VJOH0IglV+jlAlFRWjWwp2WTGqLA6ZF7qtEsxLTTCttmis779plVt9P8BCG/Opwm5pfaeXYFBGE0hHtcwr1eQrXL9C5w+S8w4TrI3wZfnwenPgltToGYqOoZ34YosNmACrmnOMulH0tIlWVLcyXrXOuj/O8vwSpD/LW0/RE4NqgkhQKOS6iAXeBx8T/Hx2Mba6x2VJ++qiwfnKUquZRenbB1WGX8pcnkVZTJtVNRBvoo2YY+CswiokJFia9S02iWvsigVhm5K2DhuzDrWWlzMWkw5hVod4rsd6C0WDgVC1BV8z2ptXgwgFybBTuhcAfOA9uYs3AxGd69dDQdRHGUQtEudSUFUjKFnGjaA5r0lP+1ygmA+AyY+RQseR/SOorUktb/VPGLMPv1S145t067HIMKq/RxgdDWj4oJ3XbgyBPV4Vynh7JPqC/qW/GknUeHVa55R5DzpxEIFnV8rt0T9eoYTG9S75sWX39kNMv7/v2TopP7s8cFa3+CP/8ngXsU6HsVDL3fd9/VpCzDhVLLfEGDw29857AjGnkBaHmiVMud9n+SSLVxivg42AukSlWrVK0J7U+FM16QuV5Sa/nNxmi1kkndX2N0danAwHlZsPNalzYSGf9FEEEEEUQQQaMgQiz8G1HbALuhkgOa6WyozDUNWoCnZK98p9ftG3BbkuVRmgtbpskgO2eRb11TjBAHzXuL8XKz3lLSfiQHdSmZMPwROOUByXJd+xNsmS6ZpLOekYl0q0HQdRz0HF9VLqAgSyYtphiwOHwTeO1zj9s3MQkX2uRGcaiyHvmQlFHzoDuS6RMch+u4+EuExalVC/YiuT7+elQCnx1OF/3otI7VCSpbAdgKZUIGsq3pD0qGmaKTgGOfKw7tbwgHeqMYALY5GUY9JZVHW/+SyWnJHpF22T5D2rQWdLIVgVIkHg0A5rjq2/W/thVd1es8IqVy5BDOsQ8VIAB5X8uoDvRYsOWDsYagiXb/LC+F6Dghl/37GZD3Vn4tZsj+gcY2J0tlQofTIL6ZvO1xB/uWI4vEVnD5BJh0O2TNgz/uh5P/AyfdJfcEo7nqvcJZLlUKZfuFOFD0EkRylUvbdPglAviTCcEqQ8Ihmmvqc8KW2znKCe3GRn3vV7X1VcG2qw2bDNE+D4Qq6wSMQfyTRfwTHyrbq13Gcw6777VJHetNvhN2L5H3O5wOZzxfNXjf2DCaoUlXaNIVdzs3Ly0WLfpJtw8m2lUokpmKXgg6/+srWCB2wM3SZpZ8CH/8F+KaQcfT/X6zS207/qSA+r6ibtMUeGxVQsGlBqJrageRPqz+aGhySLAEKf9rX5PU8kcg2QByP3ZY5VpLaOFrWzq9tIOyXJh4K2yaIssnZ8LoF6Fl3+rbP9LQGUTGsu1QGP2CkB0VZZKwUlEq/5cXq6/L1LHtQalu2PY3fDwChv9PCHtLkjp+PSiVDgktw9uHhp7XSJuKIIIIIogggkZBhFj4N6K2gViDy1DrEABw2iVwilcNBKqD78IsWPkVrP5OBqIAKBJg7H05dBglAZDAbR0N0Bmg/Uh5lBdLufDanyVDO3uBPGY8AZ3OgMxRkNpB1exWwGWQSUbxXnltSaxaSm/LrzqBrwnaebDmiQeFOa72c3qks+GOVoR7XEJJSvh/Fkr3HKgiEeZUM6H3roY/7lMz14AlH8gjvQt0Hy+PBFVn11YoXgpFufL/jMelLRlj4Jy3IHNEvX7+IYVOLxr1bYcKybB3pRAMGyZBcQ78fDV0OQdOuEKyy02xBPUugapZo6bYGjT6I9f4YUU4xz7UMtr7VYwf/YgFjwusxdXl9DRUap0nymu30xckzV0vbWnzNAnsgcg29LoY+lwFyQGVNkczouJh/Kcw5wWplPvnFSjcASOekM/9fYkMBjFEdzmhcKvI0djzIa4l9Di/arvyJxP8+yJrXs33snADNhEyOzjqe7+qra8K3K7DKtWlpjgJbIZKAvF6fNeQ/3fY8oMnPpSXivyJRjKsnSDjnvJiWW7kY9Dz4iOXDKIoUi0Rk1a3dUY+LlnVG36VKqGrpohBtMsuxzEmgPDW+ipLXMBYwO77zOuWdRV99XYQ6LcQ6cPqh4beZwLbldMm43RtHhL4WSDZpkEJeNbuqV6v3LdnPw/lRTKPGHAzDL49eIXL0QZFJ+MzrapaQ2DFAYiPym/3wv7VQoJvnAKnPyt9GFSVOqxSCRTk3DX0vEbGhRFEEEEEEUTQKIgQC/9G1DYQa4yJfhXz5dTqnzusksGiZUg6DWCMlSz/wOqEmHQJ9PS+1GdMeawgOgF6XyaP4t1i9rzmRwnkrPtFHtEJ0GYIdDoL2p6sSr+Uy0DdVgSpKTLgDTWB90coE9P4dAkiRYI3hxZBg6DqMbfmqd4jcTUTb0azasQcLdnHU+4AR5kELwbcIvJB22fCgY0w82l5tBokcltthoIuCkr2w/QHJBM7tglc/K1U1BztUBTR323RR8r+57wAi96DjZOEmBv2EKR3Ch08888aNcVWlQNTkAlrbHz19SI4tAinT6lpGXuJtAfNC8E/8KAzBDeF1BCYrV9eLETv6u9h30rf++ndoN810P3cYzfAoDNIBnhKB5j+sJh0FuXAiEel/ynMErIuf5v8H0xSMGs2nPVqVVmXQN14zcsk0NPCHw5b9Uq5YIiQ2cFxqAiXwO067UJk6wxVz2XgWKKm4GZ5qRB3TptkHduLIVo1NfY4Yfojcg8HkRQb955k+x+LUHQw9nUZj2XNhW8vgou/h8QWYtbrTx7YClSyQTVvr1ad4EcuaMtoUi/+SQr+HjAREq5+aOz7jNMucxe3s/YKH38YzDKud5b72pc1D6bcKeM9kGrsM54TKa7jEWmd4arJMrb751VpR1+cKRW1HcdAVJCKn8BKIA0NPa8RYjuCCCKIIIIIGgURYuHfiNoGYsEyc2rLtA5EFfPlIMSCMzBLywzfXwwF29QFFDEK63OlZFkHVicci0hqDUPuhZPvgT3LYM1PPvOzTb/JI6kNnP2OGAY6y31ZthC8FDsQWnaptcAvKKCey7hIAOeQQ5ukBAt0BnqPBIN/kGfdLzDtQTmfrQdLNnJ0AvS6SAIWm6ZK4DB7oe+h6IVAKMySKpi0LnDJd1JW7ig7RD/6EMEQJVmtHUaJfEZxjph9RsVBx9OqX8tOW/WsUe18KA4J5OgMkTZwJBDO5N9/Gf9sdxCSTmfw9SX+HguWFEIaiIPPPNNolnvt1+dDwXb5TGcQ75t+1wmZdbzoI/e/TqotJlwnfc1X54ReNraJeEYktID1k0Si4usLxLfBYRfT2sB+P5y+yGQRUsFgjGSD1gcNCZjVVC0SbLv2El+fpREKWuC0JvII1Mo6l6/CrmSvVJ3lbYX8zWJ87rBKwPzke2DIf1S5LVvobR7t0Jvg/E/gm/Ng/1oZu/a9WohJDQ67BIzdFfI60RKkOsFcA0mukuL+9z2ItKP6oDHlbrRqBJAkoGCSWbXdH/VGH/FQsAM+P1PGZ/ookVIddGto757jBToDDL5Dxnda9cJvd8PwPJkn+cNe6pOUamxEiO0IIogggggiaBREiIUIaoc2waltgumPmGRfxUIwGM0ysLbEynb//J+QCuYkkaDofbkE4kEy3o4nKAq07C+PM56FrPlSCrxpqgSEv7sIznxVMtD94e+5ABJgDYQmpVNeAF41MzsmtW4yPhGt0fqjpklKbCo4LDUH44xmOQdLPoS5L8p73c4VI0pDlG85S7J4JfS5AkoPwHq1+iV3LeRtkWXaDZfgR/QxnqHfahDcMBMm3QZb/5SqnzZD5DP/EnlbgUqeGOR9zWOhMlM0kpV2zMBfniBYRmFdZO+07NH87SKrVZgl8id9rxHiOq6pLHe89TOZI+CaafDLjVKhkNxOZPdS2ssjtb3od/vfH5r1kuzy8kI1SzrEvSpcX4WkjEi7OxIoyxNdc1McJIVR5Wn2uwa05AQvVf0W/AOqIO/ro6S/2b1EvKRy10mgNBBJbeCctyFjQEN+1dGFqFi48Bv49nwhUea9DIvfF8m+gbdIH+12gaPCR7oEVidAaKmXcDKpj+SY7VgaLzaG3I12/WumzDq9bx7jX5ng307824vTLlU/1oOQs1RIt4IsaTuOMmjeB855R+7R/yZo1QtzX4aFb8H6CdWJBXOcJI0U71arTlMJmoRwtF+HEUQQQQQRRHAcI0Is/NtQn0GYNsGpKSCqwb98Pr1j6M9BMnKc5ZCzENb9JO+d+5H4KBxOuB2ib+ofuD1c0Bnk97Y7BYY/BD9fJ5nnE2+GsgOisaooall9oQR8NEIhGLFgilGrQeJF+ig2jHOmIaI1emihBbkdVslkrHzfrxLIECWBvRWfy+tBt8t1ockjBENCC8n8GnyHyJ7sWiDZXe1HNSwDu7xEJnlrJ8h10flM6Ho2xIRpqteYiIqDftcKsbB3hZ82tV+JvBe5n5RbAZe0l6SWoa/lQ21iH0H9ofU5EPwcOP2ynZ12cFYEP09Om1wTBVkw+VYo2S1Bzism+XxJDheKssWY05wsBHp0ggSnDiXSOsFNc0Tnuto9JEjp1Na/5LnXJdWTAhxWqUBQUKtEwkgyqIlojbSv4GiM4xKo414TArOrtdcxAZJ9GkFXlA0eByx6H3bOlusiECntoWU/SZ5o0U+uw0N9rR8JxKbBTfOE7F74tsgTLn5P/MHOfR+a9ARnmci4+cNh95EJGiHuioUEv/MdTib1kRyzHUvjRZNFlUN0SPsKd3+dNrm+K43r1WoT7Vp2qhWSJrPP/0w7nxVl4h+XvwUObIKDG+Hg5uCVowkZcPE3dfP7aAg8Lp9HTnTC4fnOmqAzwIAbhVg4uEXmhpr0WuVYzyltyYuaoKOew0qJ0dhDL5Ub6bMiiCCCCCKIICQixEIQeL1elONFEiEQ9ZkMBJvghNLy9zd61F77L6N9bi+RoKCrAmY9I5/1vuzwkQpeD2QvEj+Hzb8LsdD+VOhyNmQOOzJmaZYUuOxHmPawTEz/+p9kAY56EsryZVAN4HJBjLkqSQO+46wFCGLrIF0FEa3RwwX/NmCO91UCOazw87WwdTqgwOnPVJVWCAeJGZB4UcP278BGWPUNbJjsM7QFWPAmLHgTU7M+jPGcwFzlMGeftugnwdHSfeIdYU6iioFzTLIQbwa9TDYTMvwMSoPc9xpiYh+ZYDYMtR0/rc/RtPwDz4H//7Z8iI4Ofp4cNskQnXwLlOw5/KSC1wM7ZsPyz+S5ChQxtzUnS3azZnxpSYaEVtCyL6Q2UkC2JmJSQ2GWbx9PuEKenXZwFfsCa1pQzGhpuGnzsRSYPJyw5kFFqZCp9Q2UaVWK4fTl/mMz7XUoA2enXciKxR/A5qnq8rGqL45ahdmyT3UD18bE1j+lMiIq3veIjpfxU3S8BEpNcYePyNCbhIjreTFsnwFzXhT5sR8uF5+gXpfLMdMqE7xuPw8mu4/fc9iFuIuKqXvSz5EYsx1L40WtLYR7v9HuYQ4bGExSBax5NGnVJrZ8X+UC+CoXnA5Y/QMs/xwqiqtvW2cUoq1JN/XRHVr0rdtYvcZ9V+WVyg4IkV358HttzfOZKqd2hJYn+qqozUfI+ySuufSF9gKRUmvWy3fcLckqeYNK5ARUL5YX1a2913f8FumzIogggggiiCAkIsSCH2w2GxaLBUVRjl9yobEmA5Va/vlVg9sONUM0Jjk4yQA+s02HFZZ8JNrpsU3EuOsQQynKhi1TJMOsZHfVDzWfA1MsdDwdup4jkiuH099Bb4IzX5Py4L8ehVVfQ95mMeRUjOK5oE3ai/aIfrXLWTVAHY5MRTBEtEaDozGCyFW2oWWEqhnBRrNM+r67SCZUhmg4/2NoP7LxfkNtcDvEFHrFVxIU0ZDaUQg/UwxsmAi7FqDbt4K7WMEt3i/QTxoFvS5QfVBMh3Yfo2JlEr5/DeycC62HyKRTIxaMFohOUturXjXJVs9XsPteQ0zsIxPMhiHc4xfqHPhXz2mSLUFNnwtE/uhwkwrlJbDmR6k8KsxS31TE66S8WEyN8QpBZi/0eT4EIipOJDJa9BXT22a9pR0cCqz4Sp7bDpXArFPNqnbafLKGpljVWN7v+GsEt3Z/bOi5/bcjHC+emhBuf+XvneU/Vgs1dtDGB2t+kHESSIVp13MCgnqeeu54LfB6xeh10bvhLR8VJwbRaZ1kPJXWBSWxg2znUIztFUWSU9qeItKeSz+CuS/B/vVw+tPShkANlKpjOJNZzcg2q/5Abl+7Cec8Hskx27E2XqzL/Ua7hymoPgr4yR+p6/tX+jjtUp2w6x+Y/7pI9oCQXU17yLhFe6RkHpo5hdcDq78XYqu8qPblFZ2sk7dFHqu+BiAqtikPedqwnk4oBxKgebfDQ9IpihyrnXNgz0pI6ehLpjKYISZFKnoCSXKDGaIT5TkYnDa1WgUf4Vrf8Vukz4oggggiiCCCkIgQCyrWr1/PpZdeymOPPcb5559fb3KhoqKCioqKytclJSWNvasNQ2NMBhxWGax5kcFalezrcp9eb+DAu6JUMniik2WQeHATrPxSlh390qEryXWUcZpnNqd55xL1+Sbf+1Fx0Pks6HGBDPQ3/gabpoj54LoJ8ohO9EnAZAw8fAPsATeLnMCE62D3UphwPVz9u3x/8T5ZTiMV/APUjYUjnJF9VLWjxggia9uw5qltUNOttov2+09XSgDSnAyXfA8ZJ1atFjhUKNkHq76FNd/55Jl0BuhwmhAKLfv7gjBdz4GyXJzrJpHzzw+0Ixu2/iEPc5JU+2ScKIEbj0t9uMW8Uvtfe27aXczZ64qMAUIsZC2QQCvIhFI7LzHJEqQxmSUIqiHYfS9cE3unTY6Nf1sIqvvv12YaK/uwgTiq2pE/wp2ghzpH/mR2KB+A4hz49kJ5PlykQv42WPYZrPvZJxETFQ89L4K+V0Gi6hvkdkrwx1YgVTa2Ah/JYMsXyYy9K6TP3DlHHiBBlbTOaoZ4PyG+LSF8jOoCjwtWfyf/dxgNTnXfTWawF0tfA9X1+h1WH8ENvszghpzbwO0fBW3qsLYjzYunLsEr/3tPuP2Vv3dWOGbcIDKNM56S/4c9DN3PC38fGwKvB2b+H6z4Ql53PktMcytKfI9y9Vm7N1SUyiNvi3hYAVHAL5jJIgPDX/2haRdI7wLpXYNLS9YHeiOMfgGadIXf/wtbfofCnXDW6+Ibpuhl/OuPSiLB7jvvh1Pi5TDhiPZHdZn7aO0oOl4SPTTfBP/2oW3P65Xqzn9eg/yt8llcMzFh7n2pjKf84T0ExNv+dUJm7Vslr6MTpa+LbaI+0mWfKl83EdLDXijzC+2Ruw6lbD/D2M8wFsHXX0i7yBwJwx6C+OaNv+/+aNpT+rr8rdL3OGOrJo8EQ6j7pX/ViX+lXV36qEAca2RaBBFEEEEEERxGRIgFFV988QXbtm3j6aefxu12c+GFF9aLXHjuued48slDn3l/RFFpXmbwDdC04LZ/kNsUMNizFYDHI1ko5Qb47R7J0Op8JrQZHLxsGKQqoiZ4vRKEddpkIqnpm1aUQPYiorbP5D9eMc/zoqCkd5YAZbOe8jtK98p2mvWApt2gYCfsWQ7718rAe9U38rCkQHo3CbQqCjLiVa8NRf2jvZ/SHnqMr5rFHe6gXAuIthsmZMJ3F8vEdOZT0P9m0CFJgZYkkTvyH+gGm7SEI4MRiCOckd2gduStb6pnCDRGlpIWuHE5ZFsudXKdtxV+uU6CiYmt4cKvJKPNYZXjHw4q8mpfBny69G6XBIg2/QY750kbBLCkilF0896+qhj/6gUV7qYncIv+BNp5d/FW5xUYsmbK/q/4whf4CQc9L4JBt/nIutimta/TrLc8710BRm3SaaGyHRpj5AFq0EytoDJGh76OAyf+gQjWFoLKw9WxzRyGiriQ7cjrrb2dHMr9q3GCHkb79fdY8HrA7ZF7vna/Ld4NX40Tsi6xNVw+AeKa1Nymyg6Et++Bx83rgV3zYdV3kL3A9358C6l8az1Err+iHHkEIjpeMjETArxLPG7Z/wMbffrcpfvgwAZ5rPxaKnQu/FIk0DTUdj1r8A/U71spklGmOGg/QuT2YlVJlsQWfkG1gN/utAup4Hb6PteOj9frW97hF5gLlyDweg9/PxSiTdTYjvzJj2D7WNd2VJ/gVTCz89pIgkoyIVr+15b3eoIbChdsh5+uEpPzLmPl3u2uqL5dV5D3gkHrd2pD/g6pVNgyTV4PvlNI7mrfqxoku53qWLBM2kthVuXDW5xDjMdON7bAmi2wRl1X0YnsWPMT1MqgXuKfEA5CnatOYyAmHSbfIe33h8tg7BvQdoiMUSuPr3rcDVHy0BmQdoRPfifoPTHM6yrc8VC412k4y4VY5qga19XUz/i3B7dLTMr1qgebx++6zV4Es/4PchbLa1McDLxZ/KCM5qr9lAZdmNUKFUG8GKotUwpznhfizOuRa7HPlZLkEZgEVbBT2mZRtjz80aKvPFwVOFxuvpu+gG7ezfQ1bEOpKJVq1a3Toe+1QibqDEJOhINAf5GQiJY5GEj/ZjRL31MJrV9xq5V0Wn9i9vnj+d9T/KtOTP5jRQ4tQdDY7S2CCCKIIIIIjhFEiAUVFouFE044gT59+vDEE0/g9Xq56KKLUBQFt9uNXh9epvpDDz3EvffeW/m6pKSEjIyMGtY4BuEfaA06QAsysDJZJIOmeLcE+pZ8KFkp5iQY+Vj43112AJZ+DHmbVPKgVCb2NUxSFSCb5vylDOWySy8luiw75LIoOgnspmTCqKdh7yrY9reYFNryIWtuePu57S/RAh7xPyEZ6ou0TnD2m/DNeMkobXWSmCLGJkrWm9MmxIvJ3DgDZS3LB0LLixwGHFXtqDEmIZo8ldEqJfPOcpG4mnKnXFdNusNFXx9a8768rbDpd9jyhxBmGpr3ERKs7SmgN0gFRRjYobTG1b8/hoE3SqB/+wwozZXrRqdXJQT0olGs6H3vOe2wfaZIahRli4dIuMHGlv3k+eAmyaQzmHyT96CZ7eUqwVBe/3MYLrF0FJbJH1XtqDERKHtQdlAyS41mKN4D317gq1S4fIIE+esKV7kEY2wFIqlkD6ws0P73lwNUpB31vkSCTA0JHuj0vr6oy1nyG8pyYd9qeeyYI3J+U++BC75s2HWnVUQ07y3HUKuCsObLdgMzrDX4G/5q319FVifYezGhPZoCcZS0qRrb0dEgi1brmCzYOupxdwS5fzrs4oHlsKvSIVb4+RpfX3Xma4cnMOZ2wuxnxftD0cGQ+4Ssqwl6I+gTpAI2oYWvzwAqKpzc+cMW2nqzub9nEYbCHUKYlOWq5N1GWP2t9FfpXWRdTYasPhUzLfvJ/WfirbLtn66WaoZOZ0pVkL0IEpoFJ4FMFum3DsW1f4QqUo+p/kgjQ/WmqufHaReyd8GbPp8RvUkC+oNuO7T+Ihq8XvnuuS9JmwRoO0wMkC0h7tXhwBCFJ60T3+okyWPSZelEF22GRe+Jr8mid4RgGHJf+MRCXdCkuzznrhcCJ1SFeJX+JASB6l910tBrPOKpFUEEEUQQQQS1IkIsqBg+fDiFhYXcdtttFBUV8dRTT5GcnMySJUsYPnw4gwYNCqtyISoqiqioqMOwx0cQ/uan/q9rg8kig94DG2HhO/LeiEfDGwi7HaIfuuzT0BIxOr1kpkTFqc+xkNSGiszR3DA5GhSFy2KbQE3EQpXtGWRi2LIfDPmPZG+X7pfPKrMxvZIppGWVeb0SkFr7o0xYf7kB+l4jJdH1RZsh0Odq0eue8xxcOdlnLq2ZAWoBgPrAn0ywFkgGalSc6JEeIRyydnSoJwi1BcxMMXJ95CyG6Q+BLU98DC7+rnEkTQJhLxQyYcMkCWxoMCdBp9HQeSyktGvYd+j0PuO/YDAGOY/bh4u0RfZC+OVGGPNieBULMalC1OVvE/Ku1UCZ1FvzwWSrHlQzRktwBiQQrGXP1VbFUGX/w7xWjsIy+eOiP6qS7a4GCwL7AL1BAqH52+HHK6rKH8XVIwBSsFPu3daD4S1vioVu50HPC32VBwc21rxOfRDbRGTKOpwGfa6C7y+VtvD3YyInWN9g7w6VWMgYIH2ZlhHqdck9JKFF8ABnYFUiBJfVCXwvHE1/OGraVI3t6GggP8I9ToH9k3aOA8cPJrMvo97rhcm3S7DPkgrjPz08v9VVIdn+O2bLWGz4w0LaNQQ6A7uUluxSWnJPvwwMRrWasyxXkkj2rpBHyV4JpOauExNeRS9ySa0HQ+cxdZMmim8Ol3wLfz0OGyfD1HthzwoZFyoK2AohIURwVJMVrS9CjXeOEBl2VPdH/v0MCEGtN1aVrvR6YMaTUpnpcQGKSKme8qCvWvtQo2C7jJ12L5XX8S2F0GjRp/G/S6eXYP/Zb8Hm32Hx+9LfTLwFel0MJ90jgfvGQkp7nyxYwQ5I7RB8uXCk28K5J4Y7H9DaS1mer887CvqlCI4+ZGdnk5eXh8N1iLyGIoggggiOYkSIBRVGo5G//vqLF154gQceeID33nuPiy66iKKiInJzc49vQ2cNdQm61jYxCQwGadCb4M+HpZw+c7iU1NeGXQukFL5YlZFo0gNOuEICsaYYH5FgsgQNrHidHlDCy8IOCb0RWg0K/lkw+aEuYyWbKGuemPhl/SNl8CmZ9fv+EY9KRnhxjkwqRj4mA3r/AEB9oZ1Le4nPtyHuOB00H4oJdTgmmP4BnZJ98PcTEsxIbN34pILbKdfbhkmSiazJv+gMIsPQ+SzxC9Efwdt/5gjR/J32oMhUTLgBxr0vHg21IWOgTG6z5kJqZzE0V5AKJmuhlM9rk1ONQNAqF2yF8r+/JnwERy8ctqoa/iaLr41pMJgBJ97SffDrDSiBngrhSoppKN4Nv94opEJUHMQ1FyLOkizP5kTxQjEn+d6PbSbVM7WhMY1jY9NhzEtCgGz7WwKg/a6p+3YcVp+UR8uBqvyKKiHhdMmx968+CLqNgP6+Uic+32f87F/1EK6m/7GAw0V+BBuf1ZUoD+yfjGZweKuPHyqTR+ww/w3pS3RGOP+j6pJdhwIOK/x6i0iL6U1w6hNCeh0qxDaRSgitGqJ0v8ix7FkGu5eJ+XvuWnks+UCkkrqMFYIvXNL5/I9Fh3/2c2KUe3CTVMW67NJGtHNgK1IN0i3SZ1cxSg9DUixcvw17yeELhh8p1NY+/I+nLV8kqkyxsqzeKHKq6HzLzH4eln0i67Y/FYb/D5p0U7/Leuh/y+IPfKSGPgoG3AQdRlWVXD0UUHQybmx9kpinb/1TKqi3/gXDHpQKnMbo13QqgbdnGexaCGb/PsMvKcQfDrskjShIvxxqLhTsWnDY5BxbCyCpZei2rLUlxXHkq9MiOGqRnZ1Nly5dsNls6I1RjHx0AgApKUcuSS+CCCKI4HAiQiyo6Nq1K0lJSRiNRrp160ZWVhYOh4M2bdqwYMECzjnnnOObVIC6BV1rytJz2HzZPv7LOu0if7J/rQRsRj1d+2B00Xsw7xX535wMg+6ATmcE9w04ms6POQlOe0YG4PNfl2zxL8eKMW/TnnXfXlQsnPWaSCJt+BXaDIVeFzSSTI+lqk9GXAMCF0c7DkV2aU0mmBqh4LCpsj12CaYXZ0NcU7ke4sLI1K/Lvvx4ucgeaUjvKprUmcMPnUF6fZDeBc77WI7HwU3w45Vw2U/QtEfN67UaJIGZHXNhwK2qHrLFF4B2qvevKjJIKrngdsoyZQfBoGoYx6aHv8/HW3s4nAh17Go6ppqGv8spfjKgtjE/6TtjNJjNuL8ch6Eou2FGzU67BDTLDkByO8nODpS2qI/Wt8cDM54QP5/0btIHNO0Zvo57KDQ/QUxCZz0j0hwpmeKTUhfkLBGiX2cAR5H8Xmc5WOLAgtp+1GNvzZcgjiWAKAgmfwQSsKkokqoH/yQDTRouGLR7ZqSNVUWwIFhdifLA/kkjF4J+n12SGea+JK/PePbQBvc1uCpgwvWSkW2MgVFPiUTX4URcU6nk63KWvC7ZKwTD1umiq6/Jkc17Fca9J5VztUFRYMi90u9NvEWCp7/eBOM/E4N3a6FUMzqtvmq6QAkya754lBlja2g/ftdETeOdhlZDHAuorX047SKnaivAp+GPr00oeknAcNqlkmX+a/L+ma/BCZcfjl8gyFkCfz0qBBeI/9opDwrJp713OGBOguGPSLXr/DfF++33+6Sa4fTnGmd82bS7tI09K6DjGTJW0xtUwscMjlIo3APRMVJBZTRLmwBJMghFLAS7FkwWtUrbUPM9VJtn+Y9VIoggAHl5edhsNr7++msyO3Ti8em5AGRkHAYyPoIIIojgKEA9XF2PTyQmJhIVFcXSpUu5+uqrWblyJR9//DGnn346N910E5MmTTrSu3joYbIE19V32sCaV9WIzGgRWZJQg3W9v6EjvuDqgjfl9YhHaw+olu6HhW/L/z0ulKBj5zH1MyMOBbdDsoAWvit6t40JRZEMuAu+ENNZV4WUwwercAgHbYbIcQDYNBmK9vrOiea1EOp1TdDOpfYIVTJ/PKCm67a+0NqNlkUYk+qb9GsBNwVZRtH5DF4v+LJukgrhYMFbQipExYnm72U/w6U/iBTX0UQqaIhNg3PeERkljxPW/lz7Ou1Pld9XnA2/3a0GAixSqRAV61etYIfyUp/+vSVZDM9NsSIl5q6Agqzw2oiG4609HE6EOnY1HVOjWZVlS/b1ISZL1QofeyHsXoqhaIec2/qSCgDLPpPrKrYJnPtB4+llF2wTTyGHFXYvgWUfw293ij/CondFEqy+11T38SLDhBemPSDEfV0Q10TajMclAd1vL5TKOC2YogU3rfkSxHJXqIE4PxjN1bOrQc6bxwvRcX4+FLVAu2dG2lhVmCxCsBmMvmMTasymwWGVsZtDzabWiASnXTWdtgYfJzhtEtj/8xF53f966H3Zofld/vB64c//yXebYuHCLw4/qRAM8c2h69nSV107DU6+R4hHp03kmsL0JQIkKHvNH7LN4mxY8IYEsBXk3Cp+QdRAKAHPgXDa5OFy+Ii5YOOdwOvGaZMAruMQZ903JoLNSwJRW/swmmWeojfK/zHpcr/TfGViUlQz8HKRAgPJ2j9cpIKrHOa8ABOulXtvXDMY+xac/fbhqRwKheZ9pJ8dfJccu+0z4ZvzhXxrqMl2eld5Lt3rMzIvL/YliLhcYDTIfEpBTSyJDd1m/GEvqf6eMTp8P7lDMX+I4LhDly5d6N2795HejQgiiCCCw45/ZcVCoKSRx+NBp9ORmprK6NGjSUxMZOrUqfTu3ZuOHTtiNBrp3r37Edzjw4RQ2e/1yYrTnk0WvF6v/L/me5SyXJGW6HOllB3XhAVvyuCxWW84+d5DU5Gw5kdfIGbuyzDw5sYfsMemSyn/D5fD/jWwboLostYHfa4U/4acxSLV4bIDigy649TsV6OlqveCohNtUG1gHhswMK4pY/ho0I8+2lFT1YgWxImKk6DOwc1CLJlifROoxsK+NbDqG/l/9IvQ5uTG3f6hgjFatOl3LxXfhFMfr5k8jE2HyyaoE9kleH++Gs7/XF1FEYKwMEukDUr3C2FhK5C20rwPdBsn2zmwSTLVCnN8wYSGVGpFUDNCHbsg73v9JSosKXIuK6uCAtb3uGHnPPm/9eD6kwrFu2H5Z/L/0PvrVslSG/aulOcm3SGti/QD+Vvl+tw0VR6KTj5r3ltI5MQwTU0VBYY9JIGnnMXw89VwxeTwj0N6V7hjOSz5SCoEsxfCxyOg58Uw9D8QneSruPIiRtbmxKrnLJjXAki7qpQZ8U9M8Es4CJR10e6ZkTZWFUYLJGXU7f4TTJrP/z0I7rFQXgaznpXz1rSHVJfSwIBhOFj8Pqz/VQLtZ78lbaFw16H/3rogJk3GYT0vkoqDfatFOu3Sn8KXNEzvIsTll+eI70K3c6H9SJHqMyfKPS/YObakUEXzPxAOm8ji6Aw192WBY5YqVQ71MKk+EghnXlJbRa/JIvfJYLKt2udlSBWJJssTru9OQ5G7DqY9JFUBAN3Ph6H/bZzzU5gl1dR6oyQr1WebBhMMvEXkNX+7W/rPHy+XKoLWJ6mPQeH3YxqSVc+v4hxfQoHeKONEkwUSmiNkQ5F8ZkaSSkDuY0V7hHAIRgCY49V+KM837jCE0V4iiCCCCCKIIIJa8a8hFvbt20dhYSFdu3atJmmk00kQ65ZbbmHXrl288847lWxznz596Nat29FrOHYo4W/qG25GBwQPMuiNsPRj+X/wHWCIqplYyN/my14edPuhIRV2LZCydhSZENrypbS93zW1y7HUFZYUGHwnzH4W5r4IHU6vn+lZi34i9VGYBXsWQ7P+oFcki0eTC7Hmi46/IRoSm8s5dJRJwNWcCI4aJpXBJJCOoInzMY9AyY8CNbMxuW3jXtNup0it4BUt3MYgFTwuyF6sTkBN0i7imzd8u8HQsp+QLWW5QpDUlqXasn8luaDsmo/37ROk+sjtqHk9RQfNe0FSW0hqrcqulFe9/msi2hpDesx/+0dbEKeu++aw1i4NVdu9JNgx9Q9+aoE0W75k4hrNgMm3rE4v0gkgwYz6Yt6rcv207C9VMY2Jfavluc0QaDsUup8nxyV3A+Rt9hnGHlgvjzU/CLkRbjvWG2HMy/DT1XKP+fkquOyX8PuY2CYw4n/Sxmc8LeT1mu8l6NnvWvE0Mlmk4kfzuwg3+O/vi2EtkOCOFtQO5kdTk0xSQ3GsS5nVFBAO9nvCMdIO5rGw4nM4sE62ed7HMl5zBWibNwa8XhmblB0QuRdN9nLkoxKwPJphiIIzX5U2V5wDk26V6lRDmHOFVgNlLDz/DZj6H7hpjozZ8PralkawajCaq8sj+aO+xPexSJjXtM918SPR5isOtcpXg9Y+ygtlXbNa8VmYJWS2Tn9IfhZup1wTC96U5CBLKox6suHG5SCGyJun+qovQKptTryx/tWzTbrLWGzWszJWtOXBxknyACHR2gyV9tyyn3qN1wCNWNCOsyXJdy400sBoBtxyfJx+HnNOu08WKfBeGcwn4Vi87iOIIIIIIojgKMW/gljYs2cPvXr1YujQoTz88MP069ev2jIej4fhw4cza9YsLBYZZGiVDccFqVCfCbU2adUZqgaE6rOt9RNRCrMkwN7nitqXn/uKZHZ3OK3xg/wARTlSrQCio9tmiBAfeVtg8YcS+Gnau3GDv32ukIBRwXaZNIz4X923oSjQ/QKY9xJsmwHdxgthYFFJBID8naBTZABvtEgw1RQrJfZa1o8/gg2uD4XJ8bGCulzftZoDWqsGcfatkeekto27z8s/EwkkcxKc8t+GbcthldL2LdMlO1nD9Ieh1yXQdhSNrqKnN0G7UyRze9tf4clfVJIL41Eq/ErcFb0QaNGJqtFukshA5SyWrLrNf0Dfq2VZUwzEqkFM7fo/1Nf+0ZwdWtd9C+dYhbNMlXZkrhb8XLhsNdvXLqZzxw70690TFL8+OSpe5IUA2tSTWNg5V/TkFb14FjTmfd9e5Ms6bebnr2O0SKCl/Qh5XbpfKht2zBGT2NnPw8BbRf4vHETFwTlvw49XSWXUxJsl0Kl5HYWD+BZw7vtw4g0iSZOzWOQI1/4EQ+4Trxanve5BZu18aj4+/hULIJIm/pULh8pnoaZrUZMPPJZQW2AskKSx5vnMtLX3A7Pfdy/1+SqMfgFSOzRsH/O3yzatByTbu+ygPGuvXRVVl+9zZWipGS3oWpwjFUUx6SKnF5Mu9/qYNHWsc5j8tizJUnnw3cXSdqc9CGe+Er5c5yn/he2zpIJpyl3it+AvIap5KrhcEJdeO5lXX+LbeBSS3LWhpt8arJ0HSu45bFWrFDTys7xECFnt3hQVB04HJGfKXMjtEBK4rpn44eDgZvjtLl8VdcczxCDanNiw7e5fC0s/Ea83kOuzRT8hGmx50t57XSIVf/VBdILcK0Y9LST5rvnyOLABDmyUx5IPhHTLGAC9LhWvvGBIaCnjwcDjnL8T7PnyXTGp0s5Lc2W+Zk6Q+ZTRDOjBHaR/CuaT0BiJIsFwrBPYEUQQQQQRRFAP/CuIhS1btlBcXExxcTFvvfUWd911F3369AGEUHC73RiNMvm2WCyV0kjHlVlzpfFfvpTTa+/VNPAJNWn1H6BrWT4xKaEz270eXybagJtrn8DsWSHBRUUnZneNDYdNSASPS4zCOoyS7xp0mwT+dy0QuSKPB06+W9X5bAToTTDyMfjpKljxpci/pHas+3Z6jBdiYdcC0OmgmZ9MlzUfzLFgL5NMH1AlFGrIRgo2uP43Z/LUJbAcrjlg8W55na+aKjcmsVCwQyQkQAIV9dWFL94jWcobJvmCPdEJkr19cLOU5q/4AuPu5aR5b+KgUkPmZH3QfpQQC1v/lGztcNCyP9y9VrwSzInyMMVJYMnrrrrsP6+Jye2O2SLzojcGJ02dNlH9iA3I9m6syeLR3Lbqum/hLB/OMlXakbnaPWnTupV4SovYtnkD/U7oKcuqUA6skzYWFQdN6kFCu50SRAf1ntzAQGog9qvVCklthewKhbimor/e4TSRJNryByx6Rzwkel8a3nfFNYMLPodvxkPWPCEDR79Y90Bri75w9e+wYSLMeBKKsuGP+6XfGv5IcOLPX76qJk1z8C0XkyrB7lByPbXdg615tY8//FHTtahdg8cS/INl1jzfvcmfQNCOi8MKedtlzAC+9502kRAxmaV6a8L1cu/sfr4EABuCzb/DlLtFjq4mRMUJOdB2CAx7MPgyXo8EQLfPkNe5IbZliFb9otKFuOty9qElGlIyRbZpwnXyexNbiQdDONCbxPz545FC5q/4EgbfLp85bJIt73GLhnwwDxMN/tXFEAloBmvn/u9pbd2fqNHIT0O0kAuWZHnP44bkWFkmvgUU7ZIxV2MSCx43LP0I5rwoHjbRiT6T5PrC65W+Z+U3QlyBzHNaDRLCIiZN7gnLP5Ox3covhQAfUo+EJw0Gk1TitBoIQ/4jVYZ7lolUYdY8qUjdOVcel/0k47dA6PRSTZq3VZKwEjPkvuR1gVcBt0ter/1R/Ik0jw2jBYbeJ+etpvv4oSIT/PFvTsyKIIIIIojgX4t/BbHQq1cvxowZw5lnnskHH3zAq6++ykMPPUS3bt0AKkmFzz77jFNPPZWMjEOQiRIOGmp6VRNMFpmA+xv/1VWfVNs/o1kGc0azlKZ6HHitBZX6sl5XhY+UcZbj3TQVXd5m1VD2KpGzgOBmjl6vZGqC6M7Gt4Cdc8L7jZa04O+7/I5r/naY/ZwEawxRMmHTKhcAUHxSQxt+FTmA3peFntCBeECEg4oSyVhtNxx2zBIj53Pfrz7pra1UOKEltDxRsnTX/izl9JpZLUjpdEKGnDuvN7TRX01ojMF3ONfzobjmww0ihPruugRX/ZcNtj2jWQI8mmG3phed1IZaNavDMfn2eiR46HZKMLBJT6nGCYZ9K4O/X7hLsstyN/j2KSZNrrEm3SSgkdJRZJC2z0R/YB3v8wDvKFdDfk8wNlLQpu1QCfYX7JDKoZTM4Mv5V1FoSFR9UTwuCcaAZLT5o/0oIRay5svxcjuACplcV2ZK20JrVIc7Wazt+juUUi8NhX+7D9U+QmT8WW02rFYrMTExxFj8jk8495LAdhTw3T07Z7Jzs50O7VrjNZjxOn2kkW7XAvmn1aDg8hT+1SzBsPwLud6iE6BvGN4/YZsQq/3snuXy3KRbcKNRLYvUHy37ia73zrmw+lvZv2EPhSe/kZIpZMKUO4UojE2XCoRAlO6tfVtNu8PN82HxBzD/damk+P5iCUyd8RJE+wVwquj5B1YDBOj6+xMJtQUBa4I1X7JTrfm1EwuKUnPbM1lAV1rzNoJt82hIQAm8NxXvBkcpuO1SJQqqnEucJB3EJPnaWEWZrGuvgEm3STVAYms4/fmqAbpwr/vS/fK8aSrMeV76qPSukvFtSZbxiSUZzMnq65Sq8kFlARr221QiYfsMqaBRdDKG8nqlbVeUSCDYUSYPV7n8/uLdkj1dug86ni7bcAGoVTMOqwQqQ0GrMqoNTbpDs14w4lH4+3Eh+eOaSXWPP9whyJXktpJt/ef/pH9qPxLSOsm5jIqTaoWE5j65F21c4F8VoZ1/e4lPR75yzHoUXJ+1Icg9v0EI1ucEkxEzmqk8Ptp9wVrgk3szxVS9NhNbC7FQtBOUYfXbt5LdVV8X74EZT8G+VfK69WAhFSpKJeBfGw5urvra65Ux1M7ZQgiDVOI16yVSgeZEtRpgj3zWdZy0wZ1zIGsepsIbSPf+hwNKmnx/qChBuElRTXvKY+CtMq9a/pmQDFPvg/M+8lXU+VemJ7VViYUdIgFljPJVX++cC4vf9d1nUjtK/zj7ebnHtDlZvSd7pSJKS1QIBf921FjVykdz8kgEEUQQQQQRHCIc98SC2+3G7XazadMm3n33XdLS0njuued44403WL9+Pc2aNePnn39m3rx5PPfcc8ycOZPPP/8cvf4Q6WceKQQz/qvvwMd/gB6TBNZCeQZfhrYhWmR3yotRFr0jn/W9RoI3NWHnHJkM6qPEGKyRod80WUgFFDHK1Ac0AUWRwL3BDAXbZHC76F3Z93CN+WrDkP9ItcHuJTJZro+ed4/xsv6a78WDwmmXrCe3U457fRE4WP43lvTWhVSpLRBrtIixnC1fYvZaMC+5kSoWVn8vermG6Lp5kXi9EtDcMVcCSRpSO0Bz1cfDf1uKovp7tMWzcQqxpXt5wPsu7uV94IRLJQDSUETFSnB451ypWApFLNQXaZ19gYGcxTKB9w9wOqySuasQ/PdEJouCEASL1WrF5XIJuWCp4zGq0o481aoF+w08mX7tm4PXhddpB3OTys90OSqxUB9/BWu+yNIBDLhJZJUaEx63T8+6LpJ+igLthsl1ufkPyfqc94pkQocjbdTuFMn8nvWs/D6PS4JHrgp5uMvleq987ZCAbFoXkaHx7xcN0XDSXSKVMecFWPU1bJkm65/9rshQaPJV/j4Y/u3EX9pKUWpvR+Heg2NSfBULDYUpBmKPUT+hwHuTIVo1PfUbCxgtQrYaY6sf24oyyZjeOUfO0fjP6ucBpWHNj7DgDfm/y9kioxVIioVDnGvIWSL3bIBOZwZvSwnN5Tq2F8kYL2+LyPltnCJjt2DZ0Y2JrudIX7r0Y2l37YbVPt7V0Pca2Pa3VNNNvAWuneYjBmLM1T0wHKocmdbOQkmNRRAc/vcXf7lKp11IhfISCcYbrVWJhbSOkDVXAt6NgR1zpCLMYZX9OekuuY4UReZRdYU1T3xxitQEFkUvCSdtTg5NqCqKJHXEt4D1v6IrzuYdHuE53e1Ai3r/tKDfk9xW7gX718o+rvkhuOyZ5rNwcIsQLyC+e/Ne9hEw8S3Fi6XLOfD7fdIv/XE/XPazkH0VJdL/aj5N4EvACkU2NFa18uGoiogggggiiCCCowzHPbGg0+lIS0ujf//+rFu3jnPPPZeoqCiuuuoqKioquOEGyeQbMmQI9913H6NGjTr+SAUNgYOdxhj4WFLloWU6O9XBlqsc3A4Ofnge6eXb5btOvLHmbXnc8M/r8v8Jl4uhZCOit3cdhnU/yIuUTAlkhkJMikgkLf9cjAUXvi3VFkmtG74jCS2g71Ww5EMJFrU+qe4Twc5nwZ+PwsFNMkhPba+SC87qg+lQCEYaBA6WG6uk91ggKOq7j9p6oSYrRgskWOSclDQisVCa66vuOeHK8NtLRQlsmCL6tyCTz+a9RZ8+tglUWEOva0nB0esqvp+/ncu9EzDsWyEE3AmXS0ZcQ9H+VCEWtv4lsmmNCUWRTOslH8Cm36D5CfK+2Y8UNajySMEm4ZHJoiAEwRITE1NZsRAU4bQvp02uP5O5el9lSZSMZD/OQef1oMtZJC/q46/wz6sSwEnvKvfUxkbBDrW6z+ILltQFLfuDMQbW/wrZC2BGqVQuhENu9bpEsrZXfCnkeDjYMVuI/dOfrd4/xqaLfnyXs+HHyyXrdMrtMPZtX4AzVNWCZpAKgFI9c7i+fUxMangSSMc7Au9NSa1kDBPYhryqZr8VSPT7LGseLPtE/j/rDamuqQ+8Xlj2qW9bvS6Bgbc1rKojdz1s/1v+bzusZoJOb5LrNDZdsv7dTpEYWvkNRCdBYvv670c4GHirBIvztwo53n18eOspihhBfzxSjN7nvChVDBqh4LD7yYyZoXivkHgmi4wnazN1PhbRWGPG2rYTWE3lUpNzDCYhLY1qkpTR4svSz28gseBxw5KPJHsfpJL51CelKrQ+8Hoge5EkKmm+eC36ydxCIwhrk3lLyYT+1+PZMIn44mye8byAe+sY6Hxa+J4h4SA6HgbdKuTbyq+k+ighgMDQ+sqCHSJzueQ9IbNBrvXBd8KAW3zzptOfkXnQ/tXw2z1w1ZSqZLYGLQEr1PyovtXKEUQQQQQRRBBBYztwHn3QMh/1ej2zZ88G4JdffsHtdpORkcG8efNYsEAyHm+88Ubatm1kU9XGhqalG0xS4VB/r63m7120aBFffPsT69ZtkIyfr1VSwRQLF34l8io1YeNk0dSMiod+1zbq7qd4C3jI8zYKXpl0xjWtfaWEFqJ3G99cMoqWfCgGfY2BvlfLPpTuF/KirohO8OmvrvhCDSyYhd/xOAmLqAg0swNVDkLlG6158qwzNHzwHOy7jjbUdx8r9XoD1vNvM04bbFclvaLiRQaiofj7cZG7SO0IXcbWvrzXC3tWwj9vCqmg6CRT7ZT/ill5uMSEouM73Tju0j2FJ7aZEBWL3pUAZkWpLwu6pkco2YP2pwKKTBK1UvfGREfVMHDb36Jl7G8YazSH1rF2WH333SN1Dz7KEWOxkJ6WJtUKwY6Rw4bNWsrBfTlYbSGOncMm+u6OILIrBrMY0Bt856cdWSiOevor7F8rUnIgmY/hyAzVFbmqCWeTbvUPzjTpKh4LRrNs789H1Kq7MDDkP+Id1PokyBwhfUbXcdDzItlmv2uEwDvpLqkQNERLZvgvN/hI0EC0OwUu+kaW3TkHpt7l82QJbEOaB1NN91Stz4kEaBoPRoskfFQzqC4HW7E8g7TPvavg78fk9aDbq0v4hAuvV4KFGqnQ/4aGkwp7lsOmKfJ/i35S0VYXdBsnhLfHBUs+RCkLZcwQBsKR61F0PrP1zX/UbftxTUXCDMSgOlut0HDYhUhwlPoFv1XNeXtx1aB4MGh9lyNIwkBNnx1p1Hc8Ftj31LadwHuWOd73noKsaysEW4Ev8B+uTFYwlBfD1P/4SIWeF8E579WfVLDmCZm3dbrsa3KmyKN2Gl33qiNzIo6BdzNVGYEOL8atU2Xe09jj9sxTpZLC7YD5r1VvVxqxsHsJ/HCJj1ToeTHcsghOvrfqOM0QDeM/kSSR/Wvgt3vlfAUm+xjN0s+Hmh8ZLUJUh0Nk1WXZCCKIIIIIIvgX4LivWPB6vSiKwogRI9ixYwe33norv//+O8uXL2fVqlXcf//9mEwm+vTpQ1RU1NFv2FyrWWwDs65DreewqZkeobMK169fT5m1gi07dtBjxYMoBTuETLj4u9plICpKpSoApLKhIWX4gXDaeczzGomU4ElojS6hDgP46AQJvKz+XoKxq7+HA5tk0G5OrP8+Gc0yOP7jv0IsdBsnurx1Qc+LxFxz/S/Q50oZ5DrLAAMY1IlmTddAsIwbLfNRM9QMNLetL46F7J767qO2XuBkxWkTiQlrIZiixa8DRD+2ofeZLdNlIqkzwOC7wguKbv1TqgFAJrHdzoP4Ol5zftimtMUx9BGit0ySQP2u+fIIB4mt4JQHq+93TCq0OEEM3DdOCa4N3xBknCiTT3sh7FkFmcPkWtcIBv9KhUCJBP/gxPFizFef/iKcDPNgy5gsWPPzcSvG0HJJJouvYiEY9Ea89kK8BvFY6O9VjZFD+SvUhLkvAV7JwG/RV/SYGwul+8UEfYdKJjbt2bDtJbeFUf8HM5+SoNafj8LY130kcCgoutCVP8GIsVYDRfu6YAf8ciNc+n3wddsOFXLhh8skI3zqvXDWa9XNmwOzgbVKhsBM+mO9HR1phNuOjdFgSfDJJTrKYPpDcl7aDYNhD9fv+71euTZXfCmvT7obelxQv21p2L9G/IO8HpGxa39q3ftNRSeVpgvehMIsTAte4WbPUP5WhoA3iRr9B8pLRH5FexTsELJmxP9qrnbtOFqIgT3LRe4lsQ5Vrp3PhF4XyzhzwnVw8TcQnwEGg3gtxJiFaNB8uMyJvqB4KPN0TZ60ZA9EJ4tcUqBJutNe8286EqjveCyw76ltO4H9vtMuRLUmj2jNE3ktf0+Owiy5LutKFh/cAj9fI+fCECXtrdMZdduGBkcZbJgshuEel8jHdjwNmvdt2PhSb+RN3fVs8rTnXuUzlNz10lcOuq3xqsMURe4RE66VdrJ1ulRtaEhSE/w0OaiWJ8Lp/wfN+8g8NBgSMoSg+f4SWD8BMvr5Kob85Y8ac94cQQQRRBBBBBFU4l9TsdC2bVuefvppfv31V6ZMmULbtm0599xzefnll/nvf/9LdHT00U8qQO3ZfQ3Nug61nsmiZnoE/14FhW7duhEbG8uAqCwfqXDVb9VIhYKCAk4ZOYq+w85k8u9/yZuznhHJofgWMrFqLLjKMf3zAp3ZTikxOAffU/cAlCEK+lwhJbsoovE592XY+rdqAFtPtPfL2ln2ad3XbzdcJtwVJfDZaMm+9Xolm81RBsX7as6qrinjprGzSI+F7B7/SWhdstFD/TajBcpLwZ4Pxfth1z/yfvPeDdtPp12COCAkXDiyShWl4usBkDlSgo0NIBUqoTeK38eQeyEmPfz1irJFAzsYup0rzwvehoIGZAYGg87gux9ppr6hMj79gy5aBqMm6XK8ZFjXp7/w//1adqg1Dwqz5bw6bcGPkdGCJTUDXXScTy7JP7u0cnKvkgrW/Krt0GQGtxNFb0SxF5HiLeAC72/yWV1ljLxeydQG8VZoDLjKpU/4/X744XKpwHOUSbtoDJmwlEw443mpeCrZDbuXNnybgUjrDOM/FZLbetBHRAZD26FwgRpIXvezBM0C25LRLJ4LtgLI2y73oaO5au1YhdaOy/KqtqfAKtOYFBmXabI59kJf9vU579W/amfZJyqpoEiwtKGkQvZiIaucNiGhO59d/4ofg0naeGxTFKeNc73TeMfzCKYpN4nGu/WgHLu8LUIGznkBfroaJt0qUmkbJ0tSiatc2t2id8BTgz9EXFOf38vs5+tuSnzGc5DSXkynPx0tiSPGWPGQcNohdwOgGjonZci5DJQh84fRLPI+Hjc4S6u3z1BVekca/uOqmqoEAz8L7HvqMvY0xciyGtGgPXvd0h9pklzxzet+PW6fBV+fJ6RCfHM4/+P6kQpuhyRdTLlLrk2tSmHQrVLV00jz2D91w3AMukf8SWx5MP91uSYbCwktRcIThPjzH+slZkCz3kLKnfcRXD1VSIXakDnc159v+dMvKcRdS1VPI1dUR6paI4gggggi+BfiuK9Y0DBo0CA+/vhj+vXrR8+ePSsrGcaNG3ekd61uqC27r6FZ16HWM1qqSFAA6sRVNaWNSWHQwEEM6tMD7/sny+cDbxUT2AC88NIrzJ0nQdZxl9/A1m/+S+bmqaL1fsbzVc3SALfbg15fj0mlywFzX0KXtwkrZh7UPcQrsWFIIAWDopNJQNMeMpgvzBIN3d1L5He2PaUe2XSKyE9MuB7WT4R+14Un0aRBb4SrpsKk22DrNAk2H9wEo56WEnmDwZd9VRsCM3b8PRfg6CYEGhON5SkBPl34Iis4CiFLJRb6XNGw7S56R2RK4puLdEVhVu3rbP1TfldcU5l8NTaJmtoRRj0VHtG25gepbNizHNK7VP+8xwWwaapoBk++E0a/IHIwjQWdSZ61SZ+9xGd66Q9/jd7ArMZqEiN+7SeUSeLRiPr0F/73B62yyV4s0hza5yECOTEWS9VKBYdNgs3WAp+utSaD5HXL+0qB2sckSzDNYQfFzK2eL4jBjqd5P3R1JaMrSiVQCJLpWF+4HBJ03D5T/AkqAwmKXNutTxIvj4A+TYPH46lbdkdcM2g/SjIyt0yvuzRMOIhNl8zppR/Dtpkw8PbQy2YOl0z3HbNFkm/grRKI0qAFPJ1lcn24neFda1p78t/Ov6UPCkQ42bRaO1YcfgEyr6/KVNuOJpGkoVwlV02xVc9bXbD5d5j9nPw//GHoNKZ+29GwfZaMZTwuyBgAbYZWNROvI5xOFxPnbqRts4vo3qmcRStWM9i7HFNxtuoH8ZmMpYL1XfEtJMif0l6qVxe+o0qo/VhzAswp/4VvLoDshXJ8Op8Z/g5HxcO102Vct2UaTHtAqjfOelUkkRQFysuqV0IE05TXqhhiksGpSmX6fx7Yrx2tqGlcFvjZoaiAMkRLJd0a1aOtLpU9Xi8s/QRmPytVDs37CHlU14pnj0eMo9f+JPMukL6rzRAZfx2CxDhvQoZUVi98R0iF+W/IPT6xVeN8Qa9LxJg9dy1MvFkS0fRGmW9dpyad1fV3db8AFr8v40eU4O0iEOGOg8KtbGjMeUQEEUQQQQQRHCP41xALRqORq6++Gp1OpvHHRHVCuAgVFK4LtPW0TItwJvLWfF9Jr2a2uWkqStEumRydEDyA+uffMyr/b50ATde9D0ZgwE2UJ3fm+edf47fpM8jLLyS/sJCyMisn9e7Aew9dTY8OYQSBvF7IXadmUW7Ca4jmYc+DbFPqYZ4ZiIQWku29fw1s+h3Ki2RSvWGykASpHeq2vRZ9JctozzKZ5A6voxSBOREu+koyfmY9IxPeVoMki7y2wbQ/gg2E/y2D4ypB4YAJRrgTCadNSuUD259FzQxdOFECpa0GS1ZwfVGwU0z/AEY+Ht759bjFrBhE6uQQ3ftKbeX8+OcituXsJ2vvQYpKbdxywamcPaxfleWsKT2I2TVf/Ep6XVI9S1bRwRkvwJfnQN5m+OpcqWI4+e66EW+hoH2fFlg2+8mu+csfaUEXTQ6hpmvAmieyV1Gxx0agRkNDgzBae4lJUQOb1I2kMFmEPDAYZV2dAZvTi81uw2JQsBiRrH9nuZwvcxI47ei2/M3JLMWFHvcZLxHllz3q9XqZP38Ba9et48wxo2mVFkTio+yAPEf7ZGE8Hg9/zl5A9p59dOvUnp5dOxIXG3AuneUi07V/jZisHtgknjYa4ppBx9Oh/Sgc9lLWbMlm5cR57DlQwP78InLzi8jNL1YfRQA8e8MZ3Dl+SPjHrINKLOxbJQbucWF6o9QFmSOEWMheJCRMTeT0gFuFWFj3swSdAmE0S+DaGOszFA52X9XGHl7kWtCbhLAyJxz/fVBNqEs/7Cc7htcrYzQFuafpTdWlLDVvjOjE+u3b7mWiFw8iOdT3GmiIj8Gm30R2xeuBdiNEdmjb3/XenMfj4crHPuT76WLwnpqSTJ+7vsTitZE65Squ7mXgpJYIqWCKFTIwvYv00ZaU6vfyE6+XIOum3yRpptXA4F+c2FqqCRe+LdWtrU8Swi5caOO6+eq4btU3cu5Oe1Y+tyT5VVcGVCAEyiBpkpaJDSBQjzRqCvwG+yzw/lJfqRvNe8IUA/+8IttpeaKvqrI2uB0w/X8yLgfxCBh8uwTP6wJXOcx8RkzBQa7NHhcKqaC9VwO2ZB/g7jd/JT0phhvOGsDg7m3CnwNHJ4gHz6L3RNprwVtybWtG1g2BTi9znl+ul0STuS/55kD1Hac26SaEYMke2PoXtFGrh/zbib80EoQ/Dgr3XnwsSL9GEEEEEUQQQSPjX0MsAJWkwnGHxgwAh7MtrczeWQ6GKDZt28aWnMV0aN2czhs/ENXavlcFDUbk5eWxarXoYq+YNZmKby4jxujlgKkVm929uWHoGDZv3V5tvfmrttLnssd44Koz+d/1Z1PhcDFv5WbmrthMrCWaG88bRtNmcZLRs2W6lKwD6KNwnPwAm+bVMeBfExRFpC3Su4p55c65cGA9TL4DOpwmxsx1yf4bcBP8ssxXtVAXSRmQQOxJd4POKCaMf/1PKiiS/DLaaptYBRsI/1sGx/7XfGCmdbhty2Hz+Skktqg6YYk1iBcGQP/r67+fXi/MeEImq21PkczlcLBnmQR7DObGkWQJgu05uYy96yU27thT5f0/F67hm2dv5+IzBuP1evlwwgzuf+Vrdt4RRQplOPdvxNi8e/UNxjeDKyfCvFek7H/9L2KG2f86OPGmhl2TlZN6RTIRPS5Vo9oKRXskyA3Vdahruga8Ac/HGbyh5DwMZjCYJUgRhE8JuZ76mWIwQ1JL333GYMaWdxCXYsKGHrNW3eByynmzF+KpKEE/+/8A+FEZy3lpUvWyY8cOvvr6G778+ht27Nghu2cwcPlF5/PAPbfTuZNfH6AFP2PSKS4u4fNvfuCt9z5ke1ZOlX3sntmC8f2bMqKtia5xJSQ59qLzVtV49piToXlfsmN6MifLxZKfN7J09QOs3rAFh9MV8vdruOvNSSTGmrnyjH61LgsIudaslxAb2/6CEy4Pb726ILmdBE4Ls6Taqfv5oZdtN0z6wgMbYPW30PdaH+GpBXACg5qhiOyKMvnfFKv6+6jEbEPa+7FaTaQhnH5YO57+nkheL5hsQiy7HMGlLDVyNTqh7vtVsAN+vUn6o/ajYPgj9Q8Ger2w5ntY9K687jxWjMcbaKj+4Js/8v30RRgMeizRJgpLJFBsUyx8uV7h42WljDmxI7++9ySmlNZV9z+Y50qrQdImNk0Vgj++OTQJ0n+BEC1bpok/wz+vwrnv123nFZ2Q6Wkd4adrYf2vQrSNehpcdh+p4HFJ1Z05vqqXidEcOltbI9A1GM1Hn8eCP2oK/Aarrg28v9RY8RCQTOAPp136ndz1sG6CvHf6/4V3ndsKJAs/Z4mcy+GPQL9rwXog/N+tYfnnQiAYLeKN1fE0IQrDwK9z13D1s99RYpW2/sW05XRpnc7ZJ3XDZNCjKBATbeLC4b1o0yzEvMUUI4TIkg8hb6uQDDGpUlHUUMQ1hZP/I1VK/7wG7U7xSYnVB4oCHU6H5Z/KuDuto1TKxTaRc+Isr0rsOMvDJ5xC3YuDJff9W4nwfxmys7PJy8sDYOPGjUd4byKIIIIIjiz+VcTCcYvGDACHsy3NlNZVDjGprN+7DsVWQsmmzSj7VsqAt19w09VZs8XMsnu3bpxgnw8tFIrLvZz4+np2FUtpedMmaTz76H/p0rE9KclJeHMW88CbPzJx1nKe+WQy70+YSWGJFY9HglbtkhQSdk3jhr5RWPRq0McQJcHXTmPwmpsCNWjiasGvuk6K9UbxSehzlVQbbJ8pJmRZ84Rc6HpOeNtp2U8qF/Ysh+WfwZmv1m0/NAy4Gbb8IeX3k2+HKyf5dGD9NZi1zPzaDDSPRzkkh7W6xEZds+ECoRFt5aUQHVc9K3TTbxLIjG0ikgj+Gc51gWa+rDdJtUK41+vGKfLcsm/Yk9G64M8Fa7jkobcoKC6jeVoS543sT5vmaSzfsJPvpi3gsoffZuWmLNZty+H3f1YBMGGDwo19TUz44j3SRtzCyAHByIXmcOYrYkw+6znYu0IyQNf8KEGnbufWL/CkGd7qjRJM0GRqrHlCKricEOsXiNGCMzVdA7Gp4LAc/yRcI2BX9i727NlLixbNad2qdSU5sWLlCrZtWENmq2a06dAFi9GiGpWa2Vu0j9wD2aQ3yyBl5buYywvYQxO+U8bRduVqHnjgfub980/ld8TGxtK5cyeWLVvO59/8wBff/sh5Z4/h2ccfpmOHzEpiYdO+Evp3PoGyMgk4JibE0b93dzZv3cYzA0q5uHsJBp1qIKkmd+cUe5izy8WcXW5mZ7nZVlACZAETqv3WpPgY+ndvT9sW6TRJTqBJSiJNUhJokpJA09RE3v/xL175cgrXvvAj6UmxnDEgzGqmDqcLsbBhklT1pHaSDNLGyCIFubdkDheZmI2TayYWFEX6nil3wurvJHimBS01zffAdhGKyI6KFXIuthH9ePyDiscisRBOkCpUP2W0+KoW/KtStT6qvEiWq6ssi8Mq5sLlRaKFftZr9ScBXBUSUNw8VV73ugQG3NKgyjqv18vr30znpS9/B+DTx67nkjMG8s/aLJ5Tue91f37DgLOu5PclW3jovcm88uid4W28x0VQuEuqYv95TYKgwYgZvRFGPCp+DRsnCwHY5uS6/5hOY+CCT4Vc2DET/nTBaf+nnk+zyOIoXiGPYuKqei3EBKm6gOCExNFMLNSG2gybaxrH+R+vwGNlNAsxN0utFOl5UXha/xWl8M14Id9MsXD2W3I/rQ92zpOKMEWRcU+TbmGt5vV6efTjP3jmS5EUOrlHWzpmpPL9zFVs3HWAjbuqEhwPfzyNC07pydBB/SBqXPUNGqKlXS77VK79v5+EoffX/3f5I3O4EHCrv4WJt8CNc6Q6sb7oqBILO+fC0Ptk33V6cCGSfKVFcr1r/gvhJuWFuhf/W6q7I6iC7OxsunTpgs3mm1NaLBZSUxvJ5DyCCCKI4BhDhFg4mlDfiVQondRwTeP8l1ODPCJLcDBgIOVVMzPsYnwaHQcGMx06tGfPpiK6Fq2UxbqOE2kkzRzVD9OnyUTvupEdYMkHADy+KJpdxRK8ue6is3jp4dtIShB5kq07c3jx00kM6dGGS0aewN2v/8S+vGIU4JqBKdw9MJru8aXoFAA3O4o8ENeSdm0yJYC7cRJ4DMA1sgPLPvFp3dcGj7v2ZUD0d+NbQMczxFDTli+Zd3uWVw30DLg59Db6XCXLr/tF5CTCkXzxBtm/MS/Cp2dA9gLJ9h50q1SOaMFRfw3majI6Qa6/YAPmupoRHm7UtH/a7/GX2KjJ2E+bvMuGg2+veI8EEcwJsqzXq7adaFl/qSpddMIVMrmxF4T3O7T24/VKZczs5+V178sgKsaX+VYTUVG8WwLyKOK/kb+t9u8t3V/LAlGg/wyAsVfdxd/rZT/6t45l4s2ZNE+0AlY8mRBdnM5nCw/w4udCbkSZDDx367k0iy4CFjMyw0G7u15k6y/P0DQuRLaP3gQjH5NrevkXEhSe9oC05SH/CZ01F0q+RctWUxR5eFXS0RgtxzpWzfSsfN8MeGsm2Pzvk0eifdT1O7XfHu42a1rUS1UZm1BBYfV4Ll2yhOzsbFq3bk3rDMlkz8/PZ/4//2D22thn8OB0ONi4cSNdOnekV+tU9m5ajcMQQ3H5QVpu/hWAN3TX41BMXHnN1WzbshlFURg1chhXXnox5559JhaLhcVLlvHcy68x6bc/mDBpKlP++IsH7rmDy9ocoBOwcH0OZWXldOnUkTvH9uKKM/oTY46SPmLLdABK3NGsLYzi7+0V/LWtgi0H3dgr3JQ73bjcPsLaEmWgb2Ya/dun079DE/q3jqVdk7gAyQkXkC8PG7w4JpkD2Z34avZmHn5vImd0uCj0cfbXVE/JFPPL4t2i+b5/re8zS4osm9QGEtuIfJ8uyFCvaS0BqoxBQixsmyH3s5oCj51Gw6wm0jY3/gZ9VVNOh12uo6Icn0+GKcaXTQ1U3lc1aQprQd1IgNqu/WOl8i7c8V+w3xss4KXJkmmBU1s+GNVMd4NJ3teIheiE4OMJf1jzfP//85oYtcc2hdOfUwl7VTYmyLgvKLbPlASVDRNVU1hFspXjW8CmKb7lwjVA3SmVrlv2FnHXpwuZtlKqVp+5tB9XdPNAzgIGxutBJRYytn/NJ1d15rw3l/L25z/w0slWdDq/c5A5IvR3dR0rUivWg0KoDXsoOLFiskh2+ZbpYup+9e+V0mshEWzc2XYYjHtPgq4750pQd8xLEjA1mKVaVWeQbTtsQhhYkuSeG8xkOBghEW4fciikFOvaHwWiShv3Vr+/BLvfeD1yf3La5C1LbPU24PVKYsi+lbL+sIdDzwuKd/v+n/WskAox6XDmy1IBpn2uyY/VhvW/igfKNtVrIL2rGIznbam63I5ZQVf/Znkpz3wvBPq9QxN5/ppeGA06XhvXlO8W5rBudwler/oT95Uyc8NBvp+5ip/mbWTko+MA2LdmNm1Tq16ve03tcLn300qfh3fO8ygF22uuMAhXHnbQ7bDrH7mv/HozjHk5+DURE0bQNqO/EDr2AijIkqo6kxkMdigo9PnPmZMlQU4b49WIGq5P/+uvIffx+iwTwRFDXl4eNpuNr7/+mi5dpHI2NTWVVq1aUe6ovVo1gggiiOB4Q4RY+LfDXxtee61ltWnGf1WkYeyS1RudpJYOm+nZuQM9Uj0oXzwGKCJXEgRut5vJv08nPgpuarIaHB7IHMGtp1xE7C/TOPWkfgwbJNlAJaVW/u/tz3n90x9xqnISvTq05JsnryHNto1OznUYKwoACarmm1ry8KRsPlpSRlLMdlY8nUHr1MN8ecekQcfRor+9f42UQJtiJfO6NjTvI5l/+1ZJif3IR+u3D4mtJUtu2oMy+e9wqlRDaKiU6AnTeyEc/dpjCf6a8NrrhsBp92VApbQRCSxbgZoBVy6TmuxFYkze56q6b78oWwiibNGIJqmtVMOEi81C5NGyHxTn1LxsGPB6vdz3VzmMltezthQDcOvQprx8fhvMJl9wRadT+Pjy9vQeNJzv/lxCm2apPHLNaLpntgCPG+/fa0mLsTGgmYd3fprN0//rH/qLFUUmry1PhF0L1JL8LSLF0WaoEAz+0l81QacSC56AgX9NmcEOuwQd/uUZacuWLZeAf5cu9OvXl2XLlrNp0ya6t23KCe2byUKOmu8Lq1atYuOGDRQWFnL+2aPBaSf/wB6aN2/OgT1ZtG3XjiWLl1JeVsSWjRvo1PRE4uNjKSyx03brB4AXV4+LWb1BAuM7d2YRFRXFljVLaZXRssp3DTixHxO//5L1GzZx//+e4I8/Z/D0C6+QPjqaTieasBvimTbxC04bORxlzXeykq0A77YZKMAaUz/+3h/Plt0H2HLgIF6zi36ZbuItJhIsJuLMJixRBiwmA6ed0Io+mWm+L9cCrTVAp1N44cpBfDV7M6uz8imxOYi3hFFVpDNI1VLJXijYLkGs/B1QulcChrZ8lVBUl03rDF3OlqqpcJHc1qdVvX0mdD079LKGKJF5m/UMrPxK5P0UxZcx71AljhxB5Eb8UbJHgmluO8SmhV6uLtDa9fHkq1UXaEkFLjWpQPUywWgGe5EsUxcppNwNPs34YQ/W3/S5ZI9U3DisEiDvfJZccw3Au9M2cPdnC3G6PBgNOh4dfwIPndcbl9vD7yty+Hj2ThhzVuXyw7pIkNLh8uD2eKsSCzXBaIHel8LiD6VyaPV3oSXJel8KOUtFn37R2zDkvvr9uI6n+8iF7TNg+iNS3RoVV13uKFol1R12X+A0sDpI893QGY5+0i0Y/MehtUGTjdLagrVAiBfwkTKmIGNiWyHMe0n+H3xneAk/O+ep4y4FTn1cSIX6wOOSZAqPSwiK9K5hr7ogy871P0vCx6OnJvHU6SlgEIIp3mxkfP8WtG8Si8vtxe3xMrZPU+48LZN/NucxZ2d55Xa63/0DwzqnUu5wU2p3srfQyp58Kwrw9phobu1vEjNpZzm0H1m/36nBZIEznocfr5Tre/2v0P28+m1Lb5Jq8g0TRbYsY4CcX5MZ9NFg2wtulxAL2lzAHw6br9LLklL7NRaRPvpXo0uXLvTpE0YlUwQRRBDBcY4IsfBvhzVPJv2mWF/Zrz+5EDhYMpnBYccbI9UKc+bOYdOaFZxnnEs6iNRLiIH0wsXLOJiXzw8XxWN25Eu228Bb6WiK4f/uuxGAvbkH+X7KDF58/xty8ySze3jfjqzeuofVW3dz4X/fIPc/cVKhoI+SgGnrQaTEpPF6k6msOPgPy3YWMf6tpcx75GSiTUGyyA4lFAWa9pRMvMId4vnQcXTtE3dFEQmJKXfC2h/EHK2+ppy9LpEMuR2zYMrdcMPMqiZ+mtGqNT+I2V8YWqHHctlvuBOAKsehBhLGaAbFAHF+QTBjtEy0ABa/J8+dxohvQLhw2kTHduU3UpGgM0Kfy6HP1bVnPPpvY/tM+b/zmbA4hMaz1ytBc7erVpmmbQUeSuweLF4bNsXCk2NbcVGvONqnVz9GBVYnZqOOOy8awZ0XBWR/6vQozXpAzmIu6Gbk4QlzeOg/d2Ax1/Lb9EaRRuoyVsiFtT9JG9u/Bq6aUrPJbOU21G7PHaYkldMmmtZeIDa+1sWPR3i9YLfbWbp0KS6Xi82bN9O3b182b96M3W5n0/Zd9O7WUY6RZhwLeLyeaiaRbpeLuPh4oqOj8VTYmDVzJitWrSStVScuuPQqzNHRFBSVsGvndjp3aI8xoSnxTg9Ni37HUpYFlhRcI56ADSsqtznilCHVSAWPx1Ppq9Sta2emTviOXyb9xl3/fYQWcUUAXHvrvUQPlGuzwuHi0Y9+49yYFQxq7mXGDhenfjUz7GP00NeLGDegLY9d1J8T2oUfFG+WHEPbJvHszC1h0eb9nHZCq/BWVHRStZDQUmT/QO5ZBzZIELMwSyRbnFaRrjiwQTKfO54ugdxat69A26ESNN08tWZiAcS4d96rcHCjGO427+ML5rhUiSP/4J1/sE/rg/TRoLPKcwQNg//xjUnxBVWj4nzHu1yI4bCJBbcLZj8j2d4dThfPgfpgyzRY/b1sx5IK3cY1TPoEmLV2L3d8sgCPx8voEzJ4/dqBdGyeyKItuYx/aQZ7CqzojVGMHCPLfzwniysH+sZYLo+XOlnqxjWF7ueKNN+GSUL6twmSuW20SLLN3JckaaTzWEjrVL8f6U8ubPlD7gFjXvb1e1a1GlIjjpwqIR5Mjkz7HGQseKwliviPQ6GGSlyqyh0V74WKYiFcUtr52ojDXpWgcdph+SdSwRnfQmSAaoO9EOa8IP/3uqRhnlb7Vkn71EeJSXiwypMg2JHv4Lwv9lHh8nJOtxgeH+Uj/rxeL98uyOG2L1dTbKs+/ok3G+jRzpcIVeFw8/vy7CrL6HQK3Vsl88RCB0XlFTw8JEoqjFx26HRmwwjc9K5SuTD/dZj7IjQ/of5kY6czhFjIWSgEvDaG07y19GrVQlRMdSLBafeR4Zq0VgQRRBBBBBFEUCMixMK/Hf6mo6HIBH9ogVk1cLRm+RIo3El61EL5fPAdIVf95scJXNrDwIWdkQzuU/5bmb04b8kqnnj9U2YtXFFp+NmhbQavPXonZ3aN5WBhKfe8/jOFO1agUyCrGLa3OZ+RXX0Dd7NJz8939KfvY3NYtrOIaz5eyUfX9sZgOsyXuaLIRMBRJnI122eKVERtaN5HSIn9a0Q+Z8T/6v/9o1+AT0ZJQGn285LR7T+J9JdD8B80h0MaHCvSErUhmHyLRig4bZL1FGqi6g9jtNp+1GCYdtwObIUNk+X//teGt09er5S+z35elYdAgjdD7oXEMAOOGrbPkvMb37z6BNerypppE+4w0SFFz5fn6HF4bmE5Pel7UjSmaMmwzi9zsn6fjcU7S5mxuZjpG4oAaJqygXYt0njwytMZO8RvP5r2hJzFjO9q4rapJXw+YRq3Xj4uvB0xJ8EpD4jm8eQ7pBpj01TodXHt6wZWLGjybiZz9Wvemg/5O8EcK1mDRzLwcgQrhRQFrFYrbdu2ZePGjaSnp2O32+ncuTObN2+mfceOkJARZD0Fu70cq9VKrMWM2Wxm2PDhrFy5kv79+4PBzLqNGym2OVg97TdmTP0VryEag8nEmtWr2Z97gNIyKz1bWJh1kQv08Mbmpiy7+2FoP77ye84afToggZOly1bw1vsfMWHiFEYOG0q3Lh3JbNuWdm1a06d3TzYun4/xh4uhcBPbD1hZ8NlXbN66jb9/n0TfuAMMOtuMzenlrr/c9O7Qgo4Z6XTISKNjRhqx5iiK92dRbHVQYndQbK2g2OZgT4GV6Suzmbh4JxMX7+TsE9vw0NldGdgxPazje1LnpuzMLeGfjfvCJxaCwWSR6oQ01avB65X7yOap0hfsmClm7l3PgSZdaw8CacTC9lm13/MtyZKdvewT8UI57yNpVzEpkFCbtrn6eWJLXxA8gvrDaQswordU9RPSkgo0eaPoxPC2u/obkdOLioeT7q77frmdQghv+k1ep3aUsVEDvX9W78jlktdn4vF4uXp4Rz69bSiKorB1bzFnPTud/NIK0uKjuWJEN9ap69z99Tp27ivy7ZqnHrIjTXtIEsHGyZIIkNAyeOVcxonQ4TTxSZr+CFz2Y9iB4mrwJxc2TxVy5sxXhUyoTB7xqyKplHoJgHY9WPOPzUSRwHFoTfcnfxNrQ7SvSkYjPkEkLa15MjcxJ4mMzpIP5bMRj9Z+T/J6hVQoL4LkTDjx+vr/th1zIF+kvWg1ILz7oddLud1GkqeMrbfH8NdOD6O7J6NXb/EHisu546vV/LhYtMAyUsykxJrQ6xQqnB427yulxO5i0ZZctNqDaY+dxfY9B4kzG4kzm0iOjaJXm1RizUYmbFEY/8C7lDkVnh1hEjLZaRc/nvpe2yCJI9kLIWcxTP0PnP4spIfpPeSP9qPkXBZmSSWfdi80xoKphW/uq82H/IkEo1mS7RRCH3ttPKbhWCPmIogggggiiKCRESEW/u2ITRV5gsDsdFueVC9Y88GkTTi8vgCcQQZbHdu1pOm63yXTudUgaNlfZBgC8PQLr/Lll1+w917JrLKfcB1Ocyvigb/mLeG0K+6pXPakfj25fNxpXHvhWZhMRti/hrSkOL5+8hp2zNRDxXpm7XBw/Zsf8Mqd53PXRSMqs2Jbp1r47ta+nP7SQr5ftIf5Wwp4fHwPaFltl2pHYHl5XaDTi17w5j9kwLprQe0TcUWBftfBb3fBmh/Ea6G+MgNxTeG0Z8TEef4bEvBJyZTzWVEqchOWpOoZ3uGQBsdL2a/DJpUl4JNv0YgVLzVLBDhsquRIkcgORMX5GWOWy7Wzc5ZkC6d2hNZhmjYu+UDOF0hFz5B7JbhX1ywwr8cng9TpzOoTPbdDroNKKPJ7tSyuILjgRxs9mui5oa+JZrFOBrEcSqDkoJdTvixn1d7gFQD780vYn1/CRY98xIbvn6BNc1UjNyUTjBZSsDEq08DydVuCrl8jktrItT3nBQnuhEMsVFYsOORZkzmyFYgGrz/BYCsEnQL2MvmuI4kjXCkUExND586dcTqdFBQUMH/+fFq0aMGoUaNIq8Gszmq14nK5sNlsmM1mTj/tNE4/7TTcHg8oCnpLMl++8yl79u6tJJUD8fiJClF6A9O3ubj7m4XojSsY+agQCzq9nq5dOvHE/z3PNz/8zLbtOyrX++2P6fz2x/Qq29Lr9ey6y0KLOIVr7nuGpXvFJyFKD7Pvk/uhs/Uw1v48slq1BQAHg/cJG3MKePrHZXz/z1YmL8li8pIsTunahAfO6cEZvVsE35aK4T1a8PWcLbw/fT13ndWLlPhGythXFCEW+98Aueth/S/St6/8Sq7/E2+oef2U9kJoFmWLgWjnMTUvP+BmMffMmgdFu6FJ59DEnX+wT4MW7IygYXDYABeUFlbv4/0JHW2sFk7FgvUgLP1E/j/p7vqNTRa/75OJaXMSZAxssETVxAVbuOCZX3G5PfRolcw7N5yEoijklZQz5plp5JdW0C8zldlPnYXeFM05qpVP20RIde5m9z2x7Cr2sOuglW4ZdZCE0tD7Ugle7l8j8pNnvRb8N418XMaB+1aKl1aP8dWXCRcdT/cZOm/5Q8Z7o54O0p7MkpFdE7R2eKy1u8BxqL8XXCD87yuJLYR4Cazactqh7KCM5yxJQio4bTKn6Tqu9v3JmifePDqjSJnWlyyz5on8JUBaF4gLs9K1vIRoTwXRZrn2zuusB1cx6GJYedDAqI//Jr/MgV6n8Pi5nXlobCcMet+40OkScuHlmQdRU1ro1z6NU7sHJ8fPG96Xkf278Ny8jQw8oRtnJ22DXfNl7NmzBq+g2qDo5Fr+7mKp+v7hUhj3vpBzdYE5EVoPknOye5n0g/pouW9pZJK1wCcPpxEJ4Gd8XkObqPRrUw3QjzViLoIIIogggggaGRFiIYLg0IKkCj55JK081BUrpcHA0OGnE7XjGSgjZJDir5lzePyZF2kVr5AQreBFR7vrPsFo+ortc37km4l/AjBm+CDeffo+CotLWLVha/UN2Yto55Lgoy2+HR7PBu55/WcWrN3B7eOHcbJZNHJHdU9n2n2DuPnz1ew8aOOmz1ZXWhaEClwdEhiixTRs029SiltRVrMBJogfQnI70czev0bWry9SMuXZ65YAaZyafW8tgOj44CW+xwtpEA5MFjkfmnyL9p7DJpI3NU1UtbbgdUkWZmX5fLlMDK15Po31+ObhB08Kd8lz21Ng1FPhyx4FYtdCMQs0xkDm8Oqfa9n6il4m0Yret49BiIWV+9z8vNHF5C0uzulm5vH45xjqXczF7gnERylY9BKcbZlkon/rWAa1jWNsz2TSYo3sTBvJva//xLxV27j7tR+Z+NKtslGdHlr0gax/eHSoieUtM+v3W/PUe4UhTBJQ05kv3CnPJrOQCrYiiFaNGbX7H16p7IlrXg8JrUZuR0e4UshiMbN7927mz59PVFQUiYmJxMbGsnjxYg4cOECfPn0YdeqpACxbvpwZM2YQFRXFySefTOvWrbFY1PPjsrN80T+s3biNRSvW8NNPP1NYVARAfHw8PXr0oHv3bvTs0YPMzEwyo4toP/tmPOgpHfIwbw+0UFJmY7bKY7Vv15bhZ/hkesxmM+PGjqF71y6YzdHs2LGTHVm72LFzFzt3ZWPwVNAiTq51T1wLzhjVgU4d2nNCzH4So2cDkNDllDoHPLtkJPPtf07j0Qv78eKvK/l6zmbmbMhlzoZcOjaL5/ZRmVw6sDkpKSnViL7LTunEq5NXsz67gHs+/Ycv7z61jmcnDDTpJiTn3Belkq4KsRgCmrRfUbavgqompGRKJUTueigvqOqxYC+EhOY+j4WaSARNxsdkCd/EOQIfTBawGiAuRMWMZu67f428DsefJnsRuCtExqdTLQRTKGgm44PvEF+OBmJ91kEuf3EyLreH03u3pH/7VM578S+sFU6yDpSxO99Km/RYfnv4dGKijZS7PZzsXcIYzwz63ur7/hbxOr7esotuGT3rvhMaSQM13zPimsoY+Z/XYOv0hhELIOfgxBth0TvSPu0FauVkHZJhtAQJ/zFQTfDv346ldhkou2aySADcHwaz+LooBtHeL90r7/e6JLy+oDBLntudIoRsfbHiS0lIMSdD0+5hr+Z0uzEC07a5MEWbGdFS9Z+zujjto1zyrR56ZiTw6Q196NvWJzu2u8DGrA15jOvbjO4ZCbxxfUcuVHM8Pp2xiXvP7BL0+xRF4cJT+zNj6UZem2/l7MeugBVfSbVByxMb5pcSmw6XfA9/PQY5i4QQryuxACKzBnLf0hurVqiAXA+u8qrycFoFT21kW6VfW7LvdWMjXOP6CCKIIIIIIjgKECEW/u0oywNnmZSHxuCTQtIeTlvle16HOnnyin61oihEV+SiK9sn2c6ZI6ptft/+XC677ha8Xi+jz7sMr+4PFI8Lo6OUnDwvO7L3MGuRaGXfdc0FbM3KYex1/6W8wsErH3/Ppy8+TH9NBnfzH+B2Yjc345ZbbsWZOpv/vDmBn2as4KcZK8hINnPJoBbcOKwNp/VIZ/1zI3j7rx28MN2nEXr+W0v5dbSXKEMYE4XGkGMwJ4EpDhylkLu2dk1iRZEspYIdYk7bEGJhrmo613E0JGb4JlbG6JpLfI9nBAZ+A+WFajTw9ZucaqXSxlif+ZtN1TeuKJNAfYK67V0La5cY05DeRXRhdYb6kwpeD6z5Xv7vMjZEAEC9/vUG+a5a8MlKye4/p5OeqyZW0OSmDCaSyOW6XwD47+h2/La+mFlbSigtd5NndbF6t5XTuybRr0sb3n/gMnpd/jST5q5m6j9rOfPkHgC4Wg/FsXUegzMMNO1QJ4VrQWmuHC+AQbeFt06LfvK8e5nIFxgtUqkQ7QaXE2LVduGwgzkBlBAGf8FwKKsKjgLSb//+/cTHx1NaWkqXLl1wu93s37+fnTt3snr1apxOJ23btmXlypXk5uYSHR1Nbm4uffv2Aa9XKDpbAbu3rkbn1jP9zz8pLCoiPj6eKZMn0bdvX3SKQnl5OSaTZHxGTRJJCV2vCxl/zn0sW7aMt977ENpJ0GXL1m3o9XpGjRjGZRdfwLixY4iN9SNwPW7fvx4PuxZPgX/uxabEcv4lV7Jvfy579u5j2Y61XDQWog3w++xFnDH8pEqPhrqgS0Yyn905kqcv6MFrUzfw4d+b2ZNXwvjUraTkbse5D8oVMzEJyeiiEyAmjajoRD65bRiDHvyFr2Zv5uKT2zOmX5v6nqbQKM4WUkHRQc8Lw1tHO37hZuBWSo2pgTuTWUgFvVHaFEpV8lIL9gUarGrtqKYApsN6xOTBjihqIzCNFsnMDlV1aY6HvM1QlisJEK0G1v6de1fKcyNUGZDQUiogGoCisnLOfXoC1nInLVLjmLdxP9NX7a6yTFJsFL8/cgZNzB7Yt4aowp086hH/I68Xpm93kRJjoH8zKC/MZU+BnRbJdRgXeT2w4C3I3yrX6dD7aj42bU8RYiFnibQrXQM9wDRyvEl3n5SLMyB4WhP8teQdYbQh//7tWCIWAmXXHDafzKV2rCzJVf0VolQ/Je341AbteNRBWrIaCndJBQpA8951khR6d6mTu/orDG2tJzpKAQ84vTpO+rCAPKuHvm0TmfHgEBIscn+2Vbh4aepWXpi6BbvDTfeW8Uy+ZxDN2viuyZcnrebmU9ujUxTemrqWGWv30KddKqP7tGJgUxdD+4hXyKJ126lIvYeojAFCBKz7WeRXGyKJFJsOA26S7e1a4JP5qgs04rSJjDfxUtVLI1hFT7BKOg3BPOgOJRz22peJIIIIIogggqMEEWLheEdtE1AFybLWjEwNptBB0JhksMo6iqcCxWDGuX4qJoCMAb6BuB+uu+0eDubl07N7V1594Rn2vzaTZiYX7ZN15JS4+XPeErL35GIw6IkymTjjqnspr3Cg1+tZt3kHA8+9kfsuPZXTOkYx0r0Kj9fLSa9vZdDSH3n7vosZ3COT93+dy4RZK8kpsPPi1G28/Ps27jkjk5cu7sb9Z3bgilPac5UqJfzn2gNcaHUz8SJzjdIUjYrYdCgohb2rwjM7TO0AmxEt4/oiZ4l4Oyh6GP6Ib0Cu6S6b4g5Nhs3RjoYEfv0np4Fl0lqWk84AyW2gIEuy3GPSJICSNR86jKr9O9K7yvOBDXXbN3/sWigZjMYY6Do2+DLatR9GBc/8bBcfLpf7Q+sEPb9s9dAEyESqK/aUwrgPfRVG2w+W8/cmMQWNidLx3TN9GTukF/dcciovff0nd7zyPaee2Jkok5FV2cXMWOLggZOiaHvwb/CeVbfJ6KbfJLjTvK9UP4SDZj3lPJXlQskekThy2qH0IMQ3lWWsqkSIovcFHsKpRginquAIeiXUF4pKRHXt2hWTyUTz5s1p3bo1MTExOBwO1qxZQ3JyMsuXL6dFixakpqbSsmVLzGYz7dq1Q0Fhy9Yt7Nq1C2f+LpavXMvUOcvYtSsbg8HAd99+w4kn+jIS9QY9eoMBJXcthm3TAYWSHtdw7qhRzJw5S0xYHz0PgJeee4rLxo8jPb1mw+QNGzfz1vsfo1v/E++cruefbUU8/PUzVZbZflIM3dL1vPb5rzzw+XzuGD+Uy07rS4y5ena1x+Nl1c48pq3YxbyN++jaMomHxvclNV6ul5YpMbxyZX+euKA3K1auoFmcaFsbdWDELtdeyZ7K7Q1QdOTcl8rsbVZmzp7DsO7NsERX/d4VG3bw2te/sSe3gE+fupU2LcLzcACkrW+aKv9nDJTgbjjQDN31YRJ/WvstL1KlFM1SqaDJIWn3UU1CQgv2+d9fw5VnOcLyYEcMDpvcv+ylkNYeYoJIkYWqCNGObbbqi9X6pPDMvPepxELzMO+zNaLhlaPXvDqVrXsKMUcZ2JMn1Tc9Wydzw6mdaZZkwWJSGNzMRemeBVAgwWEFyCeRP5VT6GbIYvQ38xjbycjki82c2V7HLV+sZuI9YZAsGrb8KVrwOgMM/W9lJW9IpHeVhARHmfTxTXvU89erqCR7BsgYXh/tC4hqAdTa5MW09UAqLRvavx2N8DeqLsqRCt5oVSJM69+1bHZNHsekfm4vCu87tOXDqQQLhWUfy3im9WAZO4aJPzZZufv3UgY3j6F/Cz14HHi9cOGPNjbnuenWxMT0+0+qJBUmLtvLnV+vJidfjonJoGPd7hL6Pz6LHx/0SacdKLLR8+4fKXe62ZMvFbjTV+bw3ISVxMf8yXsPXkFaUhwHC0tZtjGLkzqfBftXS7+2awG0CVMCNBSa9pBqgooS8Qhq1jv8dctLJEELZN6lJQRVIZn8yINAs/tgONz9TbgEYQQRRBBBBBEcBYgQC8c7ahsIxaSCo1yCzQqSQeW/nNPmk0Iyqxk9XpdMWgxmyjf/LcRC++DSDes3bgagf5/emM1mVhR5aZYOmck6ZmW5ee7drwAYMagv7339K+UVDkYPG8jHLzzI/c++w7eT/uLlb/7kkhtjoKmej1Y4Wbnfw8oJc2mRlsjDV4/mxG5teOe+i5n689d8MncX09Yc4JU/ttMkPor7z+xAosUXEIky6pi8uYKXFzi4/6SGl+KHhdgmULDdNzGvDakd5Dlva83LhYLXC3NelP97jJcSfG1AbTBWzco+HDiaAqkNmRj7ZzJpkxB/aFUGRos852dJwHvrNNg+I0xiQS07L90nWb7mpJqXD4SrAlZ/K/93GStBjKAIj1iwOb1cNdGO0wP9mut4Y7ED9NJuMr1CLCzMcaLXwbheKVw5II0DpU5W5Fj5cXke+VYXj304hbFDevHYdWfy5e+L2Lk3jz8Xb2DskF7Yy528ON/BLf1MxBftEj3ctkPD+61eL2ya4vut4cJoEVmYfatl8pvURsjVKLM8a54Lir7qBDOcSWU4WWzHSjA0SLvt1rUr3bp2rbLY8OHDiIqKYv369bRs2bKy0gCgc+dOdOksxotZWVksXTyfr7/8is07fFVkb77xBiNGVK92AzDMeQ4AV5dxnHXtfcyb9w9Go5HxF1yA5uRzy/XXEm0KnvnrdruZ+vs03nr/Y/6eNUe+b3Q0oKckqjlXXdaXZk2b0KxJE5pVbKWpbgk4dtOtSRR/L9zHTS/+wP3vTOLqMSdyy7knkxIfw19ztjBtZTbTV2ZzoNh3D5i2IptP/t7I/y7sxx1n9kTrXeLMRk5pVgE22G9qywdLbGzckUPreA/d0nT0bmakW7oevddDC4uDy3oauQwoWDsFS+cheGLS+WPFLl555glmLV3vO+7XPcHcz58io2lof4sqOLhR+iGdATqcHt464Es6CDdbVMvCztsuJB5pqiGzdq2rFQuahIQWCPW/v2oydbXBZJGqS8URflXY8QCTRUgFnU7Im2DEgoZgMjAmC+yU9hBWVWTJHpFzVPQND4Y3Auav383EBVvQ6xTsFS70OoUJ95/K2f1boygKxSWlsGMWCXl2EqLA4/UyY6eHricM4IbSO3ErBia2/JQWSdFM21pOhSeGZnGQn59Hqd1JnDkMEi17sWjKg/hhNela8/IgbSPjREn6yFncsGNZul/GCYpO+jO9SfWF8su6Dybp4n89gIxPXQ65jioNbmvo346lSoVAOGxSoe11g8sFMUHGwUZVGlHLZA+XWNCW1yQw64r962Q8ouig3/UilxUG5my3c/6X+wFYmqunv8ptvbfcxcRNDjJTjPx1Y3NS4qLwer08PXETj/8iRiOtUy28eHF3BndIZtzri1i+s4gzn5nK0Ieurtz+9v0lADRPjuH2Md1Zl13A78t3UWS1M3nuKob17cRPfy/jr8XrOalXB/H0WvezGIvXhQgIBp1BSIGtf0pyTl22l6vatCe0lOotfwSrSAjVXvxR0/zhUMiE/Vv6swgiiCCCCI4LNKBOMYJjAiZLzSa0RgvEJEmw2WgWTcpAQzR/ssFkZvuOLGbOW8jWTWuJL1AHb+2DB00/eEPkeD758lt+njiFfsNFC/vikSfQLD2FfQfyyWzdgnf/7z9MmSGTtCfvuZ7mTdL45o0nmPTR8zx5ehq9m+qxufV0GHEFr90t2rSPvD+Zr/9YDIA52sT4E5vzx32DeONykch44McNTF5RVRf69cvkswdnVLA5z81hgabpfnBTSGPcKkhRiYWC7VVkPMLGjtmwe4kEgHtfKdIXWga2yykBnYZknDltktkWrv6nfyD1SMNokSBMXQbs1nw4uLVqpYI2CbEV+ErfLcm+7RotIqPT7hR5vX1GeN9livGZBB/cHP4+guzHnBfEW8EUF7paAfzkGmomFh6fVcH2Qi+pFlib68Hpgb7NpNvIJAsAly6KbU/15caTm/DVkoP0aRXLu5dksv6xEwBYtSWH3PwSYi3RXDxKZIh+miHyZ4N7ZhITn8hLCyrkC1d9G76UQO460TU2RIckNkOiUg5pqTwbo6HCLs8mc9VKBQ3+99K6toFQ24GGbetQooZ2uzMri7nz5rEzKwuAwYMHccMN1xMdHc0HH3zAO2+/zaJFi/joo4956eWX+fiTT/jvAw/w6BPPsHlHNoqicPbZY5k1aybXXHN10K/XZS9Av3MWXp2BO37Zx7x5/xAfH8/SxYv49JOPa9z1vLx8Xn3zHTr06Mc5F13B37PmoNPpOHfsmVwxUnTUx99wH59/8DbPPfkod956IxeMOIGUppLF//xVJ/PqHeNo3zKVEms5b/40ly6XPkuTsf/jstf+4qvZmzlQbCc22si4AW15+erB9G6bSrHNwf2fL6DL7d/y08Is8fSpKBPDZKBpm048ftlJfP7AePoPGMzzS6Po9V4plmdK+HxfJ7xtT+GfwlQK7F6SDXbY9id//PINN7/5O7OWrkev13HpmJNp36opWXsPMvy6J9iTmx/yOFTC65HqHoA2Q8TYMlzUt2JB8UK5KiNizfdd3yaL3Ee1h7+/TW2GmRocVjFa1dbTm46O/uVwwWiRSoXohNpl2vwDZhoqSsUzAYJKWFZDtoyzSOt0VASWH/9qHgCdM+S3nz2wA+ec2IbJS3fR77+/MOOPSSTo7OTZPLyyyMVpP+g47Ssr13y9E7ciBJmiKAzITMLpgW2lkrF/fhcDy7OKa9+Bg5t91T+9Loa2Q8Lf+YwB8pyzOPx1gkGrVkjrBJYUNbEhQD9ee89hU71ObNUrg3QGyTPQkk6OtWqEcKD9ZgXAID4KxmhVCipgTG5SM9u1pI7ywvC+Q0viqAhTOskfXi8s+UD+7zg6PM8TYHd+GWd9the708uYzhauG5SK12Dmz51ebp9qI9Gs44/rmtEs3kCF082VHyyrJBXuPr09G18YxYUDWpISG8XcR4Yyrm8znC6f98Rndwzn+SsG8vv/xrD13Ut46Pw+fHPPqYzuIzKfPdq3YMxg6U9/+2e1rNR6sFTuOO1CLjQUWtWDRuKFi32qDFLTAN8Uk1mdAwWM7/zbSyAc6hgNQs8fjqZ5TgSHFNnZ2axYsYKNGzce6V2JIIIIIjiqEKlYON4Rlg6kIpIEKNX1YU0xvomkqwJ0RnbvO4hiK8C1eim47BDXTLLstYBgtE8S6Yyx43jg/v/wwkuvcN1t97Lzm/9IJmdRNvsO5NMiPZm/332AJYsWYLOX07ZFOv1axUBRDuUVDnqnweiBXvDCFl0HcvYdoGWckXvOH8BrExZz7TNfYvZa6duhGQlZ64iL0nFHL9i4PYH3FxZzwVtLGZS5hajLrwHgvNZWFg1M4dNF+Qz/qoJd9yRgRA2cKHpIbO3LuAw3sBuo0x8IvdHnV7F9Zu1Zas1PkGCpq9wn1RIMwcxqvR6ft0L/6yCxpZjzuZ1yrpxWKLaLcWLgdRGu3m9dM64bs3ze6w2dZX+oKiOsBeCpkGeLlmUbrWrwJ/leB0OLfqI5XrBTyrKT29VehdCstwTM96zwkUw1YccsOSZbpsk1qzNA59G+oLmGKteLEuJ9KjOTl+5x8eoi8VawOqDCDX2a6Vm+z8NIfBULF53cgTfnl3LvD5vweGHutlKWPDKQ1qnJnNAqjpXZpfz1+0QuH9KOC7sZeQOYMHMpL45rSdNEM9cOyeCVyWv4z0kWEkv3wabfa86i1Y6fltHX8QzxEAmE2xF6G816yfPeVXLPM1kguZUa8I8JHjzzv5da8+pfdRB4T66tPYUj2VZXWbea2pEGtd1anWA9eJCYmBgsFtm/nJwc7HY7OTk5tGqVgYJCdk4Of/zxBzt37kRvMFBWVkbr1q35/PPPKydgZrOZyy+/nNtvv40m6U2Iio6mvKLqedJ5nJQUF2Oe8SQAs4pb8f6PfxIVFcXkX36mV/eulDv8yCdFD4oeq9XKpCm/8+2PPzH9rxm4XLJMUmIC119xMbdefwVtMlrA+2oQMKkNXoeVAwfz2Lo9i61LN5Kan8fYJLCWFHLXtddw17UX8feitbz7459MmbMcj8dLry7tOeOUAYw+ZQCD+nTHYNCTs/cAN98fz49TZ/HIyx+xMzefC1+bzeAMPT+MN9MyXofL4yV/xe/YnFIJ1MoJH4zy8tYKCz+tsXHNh0uZtjiGZ85IouvbZTw+LIqb+ho5MxM23RbL3NwYunXtQqvUGHJGduOU50vYnpPLiCv+w+wHB9EsUb0HDQziNZK9UPoSgxl6XyqyheF6JvhXLAQangaDovYjbo9Uy4FkCDvscn0HZtCHgnZ9BruvV9F6P8rlWcKQm6sXYlJrrlTQvlfrq4zRvvd2zJHjl9xOzlFtCQ9ZEsinWa/aid+apOwq71OKjCfDgbvq981Zm8OMVVkY9ArZBySb+ubRPZkz4y/Gv5/Fzf2MnNfFjMPt5bvNJq4dks7YE1z0ermEmWv3MnKcuqGdc+kXX8IvwNR1hXQ7KYrzuxj5bukyhpmioP+NwfenYAes+QnwQtth0DNMc1/tGGtZ1zlLJAgdOO4K19R67yp5btpTxoqBkkdRMbJfTru0Ib2pqseA1p5MMb42FhfG2Cmc67mu13w4/VFNcFhrvqdo1VBRcWD0k2LTG9VKp4DxmzFalgWpHA1HnlFb3lFW8/Wwb1X19/avFWksnRFa9pVlwpCqe/XbaZRVeOnfNp4Jd59IlFHPm3/v4q7vctEp8MPNJ9ChUyqldhdjnvyDf3Y50Ovg8/MSuLxHASXb5zL+ZxvTtlbwyLA4fhoXx9Od+qFSjjzxw3K+vnMogzo3q/K9y7dLkL1fip0T2sSgKLB84y42L/yDTi0Shewq2SP9zv414ZlZ20IQ5GlqFe+BDVLFrfUptUHzV0jvSpXxbjWon4Ua90FVz5/Gkgk7FOO6CA45srOz6dKlCzabEEgWi4XU1DCrRiOIIIIIjnNEKhb+zXD6ZWGEzNSwyjIOK4qioCgKrZqnEWP00tKhSvVkjqxxAPT0k4/TtWsXSkpKmL1WJDBSdaWkJcXz9weP0KZFOj//LdlbF542EEVReP3r3zEPuJLfPnwCo9fBmlw3/Z5ewtUvTeKCp3+mwuHmomHdcLo8jH/qJ9pe8SbJj23H8vBWPl9awpvj0jmrSwwOt5d/dvomzUPfzeH1czPo2dzMvhIXt031yy6JSWu4mV4wKIpPL/VAGBkOOj2kZMr/eVvq9l0bJ0smtykWBt8pQVhjrEx6nOXgrpAgT2AgIVjWtP97/v/XVgUTiPpUCdQHhypjyJIEuih5dtp81R+VGbdq6XzxHt9xtRVICX10PLTsL+9tC7NqQSOe8reHt7zXK1UqBzfLBLjzmRDfvJaVapZCcrq9XDvRiscLSdEKdhf0bqpn1X6poDF5HWSwF4CPFhZy9/dCKiRaDBwocXDh+6vxer2c3l0G3FOWi6nmoI5pDGifiq3CzbO/rgXg2uHtsTrhyVnqeVv/a82kAEggZaMqg9R9fC2/NQha9JXngxslwFVTtlow1LR8XSsQ6tqeDhdMMRCbhtXpxeVyYbX6JB4yMjIwm81kZGSQn1/Aps2bWbduHenp6ZhMRrp160a/fv347LPP2LhxIzqdjmuvvZZ169bx2muvkpmZicFoxGSq/jAajbDlD4wH1mBzwqUfrEZRFL798nNOGRo8M/jHn3+hebvOXHbN9Uz9Yzoul4s+J/Tiw3feYPf6xbz41MO0aZUBGyZBRQl2t56TLr2PxNY9aNqpH0PGjOfax9/nw2kSjMjauoHh1z+FTqfjtMG9mPj6/eyf8SH7ZrzPrx88Q59uHZk6ayFnXH0fib1G02bIBfQcfQ0XjBnO1lnf8cTd12IxwqLd7somdtkvdpq+Uka7N8vo/p6VAR9bGfq5jcRoPa+fnYJBBz+stnL+lwcYlmnh1qnlnPldObtLIcakMDrDRiv7erDmk5Eczcz/DqRVipkt+62MeXUJHk+IwJzHDWt+kP+7nBXUC6lG1FUKSQvCxaWrHk52ac/BJFr84Z9VHfh+4H3dv80crv7lWIXREiBFha+CLnNkeNvQSOqGSps0Ap78dgEAQ7plUGp30K5pAt1bp3He5zn0aqLjtdPlOnttsZs/tzlINOvomB7FU2dU9yPp30LGe5+vclDh8pKRoKOwvIYAtzVPEjfcFWKY3P+6ugf/0jr7fBYObqrbuv7QKhYSW0sFSjByqDIgaoeSXEmOgOrtJVQbOlqr6QIR6p4SDFrfbUlUq7H9+nCn6n1jK/DdJ8OWQlIrFhxldSNJPG5f9Uu7U6QKKQzs3FfIh1OXA/D0uA5EG/Wsyi7h3h8kIeqlCzpxmjr+uv6L9fyzy0FCtMKiG5O5rBvgcRFvdNMjzYvHC0/PKuWleWU8NL5f5XfsOlDC4Acm8MVM37yl2FrBlr1FAPTNTCM9wcyZagXDx3+ryVgxab6EqKUfh0dIh4Il2ZdgE5gsUxP2qRUU2rra2L0xqkyDQWtDR0FFVwSHDnl5edhsNr7++muWL1/Oxo0badWqluTCCCKIIIJ/CepELGRnZ9f7EcFRCG3CDqEHROqAPW//brZtXk9B9nraNU1iwIBBxBWpg832NZfS79mzl927xaSywiJal5nJOqa/+yCd28rrwhIJWnVoJdkoBwqK6dVEx019RX7hzj/KGdClJXqdTOKWbd3L5/efwxWn9qRJUgzRJgl6ON3w+yYrRr3C5Gubs/Y/rXnnXN+EcvNBB2v32Zl0QyYZSUY+Wmbni7XgiU4OrUfv9Uogs7wIyovrl1mlEQsHwyydTOkoz3UhFjwumP28/H/ijVIebzRDQjP5bfHNIDpFpC1shZIhZFMH2v4ZORr8AzpleVB2QJ6P1kBOQwK0NU2gY1JUg8wUVX/fVbV83mGXyaSWNQdgK5KAXGmuaCpD+HJIWul2QZjm3TmLfZOojqdBctva16nMwKt+LZc7vVzwYxnrDrixGKGw3IvFCIMzDHi8MKaDkTbkoMeDV2fktVkiN/bo2HYs/Z8YXy7ZWUyFy8P5fUUG7KdFu1i2PR9FUbj/bNGi/meTSJl4vV4UFN5b6sBlSgB7gVT21IRtM6QtxjaV0vu6IrGVtA+3QzLb6iLD4g+nvZJ4rURdCa6jtT2piImJwWAwEBPj6x/atGnDkCFDaNOmDXl5eTgcDqKiojh5QB9eefp/vPr0w3gdNhwOBz179mTBggW8+eYbNGlSPbjnj9Wr13DrbbdROuVhAF5ZWIHbnMIXn3zMeeeOC7rOY08/w0VXXENJSQlt27Tmfw/ez8ZVS1m+YC43XHs1FosEjuwF+ymb9n8APDrDyoLl6ygpLUVRFFpntCQxLoYdhRIAaZuko6jUd04P5Bdzz0tf0O28+2g39CIuuuNxvvzme7q41jJhHHx6djQH8iRoF2Mx8/hd17D1jlgePMkkwUq7l0mbgmd6l1R4uOvkBGbf3Jz0WD2r9zmIjVJYeFtzJl/bkpZNUiRopTdJP3RgPeSuo00CzHpgIFEGHauyS9hxMMT1tnO2aLFHxYn+dV2hjRHClULSyHm9Uc2WVqVBtKo9W77cFwMRKjh4tBJvxyKcal++9S95HY6EXNlB1QRVUT0zGgP1y07fsa+IWWuy0ekUnG4hua8d1YOnvluA2+1m4sUxGHQwfbubB/+y8duGMnYWCDF2zykpNE+oSo5VuGQ/nG6YuVOu85FtQiSXOGww9wUZByZkwEn3hE+2+UOn9xHbdQmU+sPrhb0iJ0jTnj7yL5CYM5qlj3Oq4xZvHfolpw0Kc8Q492iXd6ktMSBQPz8mRQLWlmRfNYOtQB4VVunPtQB/2ObN6vzB46o9McIfOUvAelDmX+2Gh7VKYamdMY98jbXcwcB2CZzWTSTB/tqQj9vjZVTXFO45TeSUdhy08ePS/SjA6lsT6dvEhYKXPSXS1z05LIqOKTIeLLAHJwA042aA5dtl3NY6LZbUeKn0GNBR5je5xX7XSdOeck7yt8P2WWEejBDQxtC7l4S3vNPmmzs16SbtwloAtoOwf4MvOSiCCOqJLl260KdPn0YhFTZu3MiKFStYsWJFJF4WQQQRHNOo06i4TZs2KPUozVMUpVKWIIKjCFrppv9gvEpJcUzloDuvxIZSUUqpzUqypRUc2IhStEt0/NueEvIrXC4Xl15xFSUlJQwaOIDBoy/E/fVrxJoUerX2ScJ0y2zJ34vXsm5bDgD/d9uF3N1qPXrvAX5Y52TOLjfDeul56JKT+b9v5tE0KZZduUWkxJu5cUwfHr/iFN557wPumnQQlXvgoDeJqCYxnJxu5Be16j6uaVt+3Z3Aja3S+Oz6WM58bTFX/1LC7opYHjk94Nr2eiUzzWmnykTYVR5+ZrOGWDWglr9NJh21yVBUGjiHGVwGWP2d+DJEJ0Dvy3zvV5PDcgFuKNknurqmWKlscFVUDd74l/ZqAfejuTI3LNmvEAhX3slkFiLBX5/VZAZXrFwv2nVhSZQAhN4gBs4g5nOu8tqDEVrFQul+yUTUSuyDYeMUn1Z2u+GSDRkOtPt4QCZZabmbc74pZdZOF1EGIRF+3uBkTAcjWc5k4ppZ6N8jjjhVBqmQBPaQSHxzuGJkd9pYfBNLa4Wbfm0SuHxIW76et5NbP1nMov8bTcdmkgmYrU5W35m+GY/Xy8n9e2LoORKWfSKVN21PCd3O1v0sz93Pq1+VkaJIcGfrn5Cz1FdVUhu0+6PDBgaTyCmY49WAhRp4N1mEbHA5wHRsGcp6/e9z6r8WiwWzWc6DN4BUzcvLY+3aNaxatZq4uDjGjhiEgodVC2exZatUtJ111lm0b9+e8vKq0icFBQWYzdF4vV6mTZvGxx9/wpIlS7imt5Eu55gprNDR9uIXyJ54ZeX3Hygup9juwOH0Xbcf/TCVuGaZXHnZxTx8z200T65OkK9Zt5FtH17Fee0crM11U95lPL/eNoyOmW1p16YVG7dsY8RZF7JTJRaSzQqLPn0EgD/+WcnVj77HgYJimsQo3DEwmqv7xtI7xVHZ1wC06jOE2BjfuW4ep+Pq3hKM/2uHk8XXx+DyiAxSmcNLqQP0CozuJUGZk9pE8+0l6Yz6eB+fLC3jrC4xGPXqFxiioWkvKMoWDxV7IexZTrvEDLq3jGV5Vglrckpo3yTgt3vcsG6C/N/13Lr3W+BXsRCux4KftITBrJqlqp9pxuiaSazDJr/HVQ7RSWoFQqD2dZD7+rFigF4bDpV8X5Xtq/2V0SL/52+VrGx9FLQ5qXZJoj1q8Dsls+7VLo2Mr2dtAODkri34Z4Mkqwzo1IzHv5nPD+ebaRmvkFPi5aKffIHQeTtsxCalU4yF9h18MkPbac3kvDLimjlJjivloxUFjO5gZFjbIP2z1wsL35RrNToRhv63YURXy/5inr17KfS9uu7rF2XLPUBnFOlMc2Jw81nND8rslr4qKjb8/XbYfL4LcYexjdWnTVSRsQlCWvkbwwf9TrvcK+1FkrBgTpBKEJBEh3BgNCMDZK+M28KRtCov8Uk6th8VWlLTDxUOF+c98T2bsvNomRbPz7f2rpyXbz8g468B7RIq3/twzm4So+GPy2NoHSdk3GcrHdw9vZx1t8WTEafw8dhobp0Tx/lD2vDgpGxQC6bjmrbF7XJyxoiTOOBQSDeVs3iLGEUP6OBLEtiQUwRAtww/mU+jWap69q2CVd8IOVDTWLYmtDxRtrFnuVzjtY2hD2yUsW1Mujy8qr9GeZkk1dgKa/em8cfx0t9EcFQhNTUVi8XC5ZdfXvmexWKJVEFEEEEExyzqRCxceeWV1YiFHTt2MG/ePBITE+nduzdNmjQhNzeXVatWUVRUxJAhQ2jXrl2j7nQEjYRgE/Yqk5OYykdKEy/FB3cTZ44DYwwseleW739tjYPFJ59+hoWLFhMfH8+3X31BcUkJlHhpnaigs+WJvAzQo4NopK9ViQXdwQ2kew/g1RtR2g4kJnoWs1fvYvZqCWhOXriFyQt92fwFpeV0UCcUiqJwwJPIteUP4aRqMOTEG15mDXB7GRjjnLx0yZPc+dUqHv19L/1bxXBaF3Xi7PVIppZXM09WJAPT7RCvAkN03UrgTbEyIS0vEnIhvWvNy1cSC3Uw8J3/hjx3Gy/mdDZ1QqQoMsg3qkEbU6zMvRQ1yONFPgs8j/7Xh5ZRfbxmjYarjxqszRgtYLDLZEWbvGqZcPYCiGsuFSvWg5KdVluGvTlRfEtK94k3Q6gs0dx1sPg9+b/VQGjeK6yfKvC7dl0VYIjCWuFm5LvbWZrtItYEky6J5VZVKuy0Xs34scPrDDKY+Ae41fM5APO9vRl0y7UA3FPi4lPzV0QbdZQ7PZSVu0mJhZcu78vkZbtZuj2fT2Zt48JBMmHPL63gQLGdj2YKeXbX5WOhTR+RBSjbL94RncZU33V7oWiEA3Q9pw6/OQDN+wixsGdZ+Ov4m0DqDGICCAGmmeo1coxNRK02G1arVfVSqB6ACZZUcPDgQfLzCzhw4ADl5eWs2biN9GS5j2TnSOCvVatWKjFQNeATHR3Ftm3beeCBB1iyRDIRDQYD/3dGMmAnccxjXD7wpsrlDxSXc+2HC3G6q5JhJ97wMgBbgRs/X8mn1/cjXc2k9Hq9vPXBZ3z77vMsukbIXPvg+3l77DWV669eu4FTx11GUamVwb074jFZ0TlK0dnzuPOdX3nru2kAXD24GZ+MsqPDA0hG6vpCExv2Wrmgm5ER0eslOOVHdLVNkkzQJXs8XNgtBJls8hWOjuxg5r6hCbw0p5jrfz7IQaubs7pYaBZvkO3+P3tnHd/k2b3x7xNtUhcKtJTi7jpgyGDIgG1szN1d3gmz39zlnbsyd2djwDYGw93dKVrXpI09vz9OniZtkzQpZWN7c/HpJyF5PLec+1znXCeltWhMF+yQsaV4L9cPsHDZ7lLW5JRyer+aWtgU7pQMAWMstB8d+Pz1obp4c7hSSN77V93SL/yJ+GoS1rttyX4oPSDHNlggOUCtlEA41usqhIK/4/RoO6w0IkfLsHPaZVwFmYeM1vqJhX3e8bExZZAakLDw26rdPP6lkOitmyby5/p99O/QjE/mbOLsrnomdzHidKuc9nkFsWYD4zpb+WJ1KbP3x/BV59txYsR4ku94t+ofhKEwaCi4nQ7mvHYVLk8VBl0Au678sC8rcNgdoWtbhAMtY2H/SiEtIg3YOiQygjTtAokZ3rolNnmusQHscZcTkjIju26tb4VTd6ExEapP+Ac+Qc0gqFCoXX+iNjTiAcUnfWnxrgWqSsNzZis6b5/2ZjyE86zXfi4kRFxTyB5U7+azV+3k+pd/ZvPefOKtZn5+7Hwy9Turv9/uJRbapcu9Olwelm09wIqr4miTrEMFHpxTxcNzq7h9aBz7Kowkmx0MzTZw48WTeEB3cjWpAL659e59YFTcvNdpHku2SrbZwPZNqrdbv1cKXHdrmVLzgtPay/xTkiNBML3Oq/+ZBEJ6Z/mNq8qkKHNmn9Db+/cPexG4K8UOT2ktdrq1njpntfFPnm+iOGbRsmVLNm3aRH6+SFJv2rSJCy64gPz8/CixEEUUUfwjEZEU0vvvv8/UqVOr/26//XbWrFnDPffcQ05ODrNnz+azzz5j9uzZ5OTkcNddd7F27VqmTJlytK4/isZGkJTiJk2a0K5jV1JadpWFTFWZfNFiQNBDrVu3nseeeAqAt15/hVatsrHvW0tWoncR5acl2r2dTKJrt+6VqFjv8ZWELM4aexyrXr+Kfh3q6sYP7S77vfrjMmZvl8WzApQQW4dUqA0nRsb1bsGlA1NRVbjw41043d4Vr73QSyoosriJSRLnjIZINUMVxVfArDiMVMfqbfeIs6o+qKqQFgCZveW96pao94IdsH+118FkhYRMSMwUHX5rWl0jO5As0JHItRxrOr1H4/4Kd0FFLhTu9kl5GC3yrBVFouDAp8MbCltmCKmg6EJHVdllMUdMEmQNjOyaFZ0va6bsIFSV8faiQpbttZMYo/DHJQk0i9OzJd+DSQ/ds1LQGXyO0X2IA3OMOpeOqhADTgxsK/ZNKeVV0m6bJVm4b7JkYdzz2SqMegWTQbZ767dtFFc4aNs0ngnD+8nYoxVW1u4v0LVrjoS1X0Z23/5weCVaaku8BNV6r5Df2uUQGSWteKq/jJxWkwbCk285hvpGRUVFnVoKgWCz2cjLy8Nms9GkSROys7Pp0KEDWVlZNGvZhh0Hi3nv8x/YuUdI4oyMuuM2iLTiSSedVE0qZGRkMP3nn2maJs4JpZbWdIndUYdUqA2nW6XE7suOfPm1N7n5rgcZ3Ur2K2kygAFeUmH/gUPcdu8jDDlpMoVFxQzs3o4Zz12Pztsu7n79x2pS4ZQR/Xjj3ivQ+TkAK5wKv20tY4u3zStq3XHaoFPwqCrbCuted6VL5bN1Tgoqau736NgU+mSaKLB5uOqbfNo+lcP2fKdvA6MFmnWrno8Mqny3fl9Z3QdS4p1rUtuFX6y5NrT5RwkzM0grcF+wU/qwf/8yWqXQukYg6I1gsEokvLaf1v9C9QltvIZjpv+EjdqFp0ONE9r4oP2Fc5816iH5SeHYCiXLavd82S4cGSTwzYllB8PbPhjsRRLxD+JIjQC5xRVMevR7qpxuJg1qx25v0eaTB7TlkzkbGdpSnL4vLXWwPk/lt2tbcWZPGT/WFBjrtQX1RhP92ySjD+bf15uoJuM1O+tIoJE71pSGFWjVbLb8bRKw4LTLNQZzoFsakGkSyiY6mvNWqD7hH/hUX12FigLI3eaby/3ndIdN+oN2HFuhBAxZEr31tJJ896YzElaqbtEemf8VvQSH1AfV48tI7nV+vcTFvHV7GDXlAzbvzSc9KZbvHzqHHm1qFjLecsiPWFBVNm7dyc/nmLykgsK8/QYenltFUozCXcPjufbHUu74tRKAS9Uvaa/urHNeDU5Vz/4ymL9RxoGBHSRjwV7lYou35kK3rFprCUXns+eqSut9JEFRtNv328WE0Za1bBF7EeD2zUEmi/QdU93AiZA4xuUqo/jnomXLlvTp04c+ffrQuXPnv/tyoogiiiiOCA0QCPXhjjvuYMCAATz66KN1vouNjeXxxx9n+fLl3HnnnUybNu1ITvWPR6XDhcnxF8tBhaoF4LSLoa0AlhQ/I94MRq9Rpl2vwyZGt85YTTgYWgzEULAN144/cbUZV/vEAHw7bTo6g4kxY0Zz6qTTqXS46Zg/A52i8P0WD/2GWkjzZv62b90Sa1wcheVVrNq2n65N22EG1JK9VDncZDVvwu/PXs6AG99h+35favKm/aXovdf78zYXeqOZER2ScKjhyTYcqoCFOU70RjPNky04MeJxOTDZi1EAhzERj96XnmxGQUGlSjWiqt7u4wnP4WKIa44BcJUcwOUK9du4ISYds96I4nZSVbgPNbFF3e10NR1SxqzB6Lf9gjNnJe6ULlBWAi43lJdIRGhJIRj8nXUmcTSoyG+t816Trcy7YHODtYHOKH+EOF5lhH2iUfpRpPenkUjaItRo8UW42YuknoJHB3Y7JCSBrRwsvvZnmPc8BrcDd8vBONN6gCMEUWQrxDz9dhTA1fk0XJYMcAZpK8mdiAHUyhKqnO76HYe1+0RsFkbbIfSuCrDlc3xzE9YYM6M7mOiWaeX5hZXojWZOaGvEElPz2D8po+mnrmUgq3jQ8yw36R4hT0njnHc24cRIq6YxZKUnYHcrbNhTxk9r8tAbzTRLTeTOzzfgVoykp5jZeMiO3mjmnGEdcHh04AFjRQF6wGlpgjvQT62LQzf2GUw/Xg3L38XRtDeeDgEyG+qhzU3bZ6MDHM374ykv8y02beW+9oHffdvKpa/rDIDZNz76Q9tXZxDyQetbwRBOWwzD8dQY/UhviqHSWcGuHbv5c8EikpKSSElJIS0tjbTU1OqMhYLiUtwuF5VONzabDWt8IpNOP5OsFpnYKiuZt3AxtopSKh0yruqMZiqdbmqHKeuNZpplZpHj1ZQ9nFfASRNP4cmJzbi9B5T//jSuNicTE+ONvnSGR+Y6nG4qvX2sWUYmZmscQ7zBXw98uohN319G0/QmfPn9T7ic4pQ/fshgvnrsCmJyFwAqnuS2WNNboTeuBuDnBes461kjLRO6kF62lou6QXYi3DzQJ3fh7HQabrcONHIaE0aPA71OoWmimUpqSmNc+Yudz9Z5yJqXzxfnp9Ojufd7PUy7Mpu3l5Tx/LxiyqtUthXraOHxmWuqqwqlqpIYHUxdaUNvNDOgfTqVHgP4zS2G0lyZc2LT6845YT5Pk8eDDqhygxpq7FKkPemT22ME3IfW4+x0GlQWQYpF+oHTm9ml4A1isEJqZ1/fc7hq9r/6xudIxvK/qB/VQR07zAxutzgwVRMYTcHHCe3+7GVgiY/smThc4rhWTRJkYCuFij2Y9y9HAapan4jq0Ma54FA6TcK85HXUvYuoKjpYPykQZL7Sb5uDUfXgSe2Iw9IM3GHGNbl1zNl4mEq3jo7ZzXjqitF0ufY99EYznVo1x6MYaZNmBlS2F+tISbCyPk/l2Xll6I1mWqRacdZ7ErioTywuxYARN250OP37iykZQ7txGLb/grrkTarGPOWThdKFsOX84e1vSvEeTMunin056BY8tfuhPoxAkmYDMTXrhe7QalzzXsJ1/B3SphRTgHbk194aaw2itTFbec1sWC+OrB+F6BOqyXef4HtfXurNJLb4xpLifPBUgTMfYpNrzum2cpF409p+hZeUjU2FBGnfuv1rMQGexJbeywj9uxg2z8AAuFsMwKmPDz6+urzjUFUFMaobFYUqS3Pf5xpq9Q+LxYopxoLb7WHCkG4M6t6WSrcCfvNCrh3vWiYWd8FOesXlAQrz9+vp1yqRYlcVeqMZk1nH91tU1ufr2FOm8Mj4BFKVUv7P8yLX6x6nQgmcAfLQV6sprlRpnZFGt9bNqPTo+WTBLtyKkdYZcaSnJlLpqXkfpsMbxM5K64on5Lon+HfGZe+iR8WdPQxnfOvQNjRA1jCxjQ+upcpe6SWtTVBRLrJI/uOoElF8Zf1oCFEYBJH2oyiiiCKKKKL4O6GotUWTI0BSUhI33HBDQGJBw//93//x6quvUlxc3NDT/KNRWlpKYmIiI+/5EkPMvyfaYZC6nAc9z7GPZlyufy6sfTLUg7zjuR09KtfrHmO7EqLIrKryiecG0ihiiu5e1ir1SAc1FlSVxzxP0Y+1LKMn9+ruqGEofuG+miTKuEr3NHuUAM7+EBjjmcNt6luspBt36++pd/u33FPIZj936+5ipVJ/0cSJnl+5UZ3KGrpwh/7eiK7t74Kr0sbsx8+ipKSEhITgkUj/1H7URC3gPc8tmHCF1Y7v8bzEcHUxe8jket1jOJXQTqQP3TfRlHzu1N3DaqVbxNenqB7OUX/gIvVrdKhsoQ2P6m4mV2lS774W1c5zngdpQw47acmtugewKw3QcK+FV91304493K+7nSVK8JT3yzyfcbY6DRsx3Kh7lH1K4Mj4QEhVC/nUcwMeFM7WvU6p8vdqhx8p/k39yKra+MhzE3HYeEh3CwuVMOtfBIGievjKcxXx2Lhe9yjbleDSjFrbe1m5lJ90waWDdKqHPqxjnOcPBrGCQpK4WvcUNqXmM9X65826h9istD+i+9AwQF3FrZ43SaaUIhK4SPcSjiDjxF2eVzhBXcjbyrl8rTu5Qef7wH0TzcjnJt3DbFHa1bu9ZhtsoxU36B9v0Dn/Lvyb+lEgDPcs4h71ZfaQyVX6Z8Le70n3Y/RmA58op/Gh7swGnfsl9710ZCevKhfzo25sg44RDC+676MTO3hAdxuLlb4NPk5XdTPPeR6mkETO1b1Ww/Yzqg5e8dxLK/axkL48pLs1cidiPfZlJBigruIRzzNUYuYi3QuUKIn17/QX4d/Qj07yzOY/6jsspSf36e8Mua2ienjf8x+akc/jyo3M1dUva9RB3cHLnvvIJ5nz9a821mWTqR7kXs8LtCEHNwrvK2fzlTIRNYQDPVat4DXPPTQjj/n05xHdfxrFQR6vlvOl52p0qJyre5VCJUIJIqCbuolnPY/gRseVumfYrzSvfyfgFfc9tGc3TyvX8rtuaMTnPRYQaT+qb7sojhwrV66kb9++rFixgj59gq9PKh0uTn1K6qf8cOdYYkz1x/GGe+woIkO0f0QRxV+HI6LqPR4P27eHLi67bdu2OgUfo/jnYw3iIG3BIeLU8rD2OVf9AT0qS+gdmlQAUBTWKVKItru6+YiuNRIMZjn9WIsDA6/pLqpjXKvelGiFCKWQoNrx2YLwJAUOIGnOmeqhsLZf5XUsd2YrZrUy4uuLovFxtvoDJlysoUu9pMIwz2KGq4txo+Np3bX1kgoAG5UOAHRVt9azZWCoio7PdKdxr+4OSokTx4/n/+ijrq13X7ti4X7dFApJpA17udvzCrpIJcICoBl5ABwiPeR27ytnsYYuWKnkPs8LEbX5/qroZW+m7T+eVPi3waZYmaaIU/9sz4+hM+/CQAsOEo+NSkzsIrhubbaaQzv24ETPXOW4kMf0KDqWKz15VP8fztK9wVW6p+uQCgD5iLxPEwqO6B4AzGoVN3je4xHPMyRTyi6yuEt3T1BSAaCpmgvAISV0XwoFnTfTxBOmubiHTABasr9RxoMoGg8DWQkQkrANhOnKKADGqX+gVyOPos1QD9KRnbjR1du3GoIUigEo4sic61tpgwMDKZTQnNwa3zkVE0/prseBgcGsYKw6J+Lj12dfRoKl9GILbYihijPUnxt8nCgCozlSS+CgUr9sVze20Ix8KrCwKExiKw3JvM4jgiLC9cCoOnjG8whtyKGQRO7S/R9f6k4JSSoAVCixPKa7CSd6jmcZp6izGuV6urMJHSp7yGwQqYCqcrnnMwB+UU4Im1QAWKb0AmAAqyI/bxRRRBFFFFFEETGOKGNh4sSJzJw5k48++ohzzjmnzvefffYZF154ISeddNL/rBSSxpQeziv465lS/5/WaRfNUP+UZe0zg8VXnEpLJ3bZRbsVpPCbxy2pxPHp3noDFswvdUGpLKLq0tmoTfy1AVXmL1zIuPESIXkgZxeJ7mJMbw9BUd3kjH2P1sPPB+Db525lzCDR4Ny8+wD9zr0bk8nIod/ewLJ/PsZ1n+JObImzyxkBb7HHVW+w82ARo/q04atJOkwGhT932jj7J1N14bFQ2PDhnXx7up4emVZQPZhLdqB4nLhi0nAFUAozV+ai4KHKlIqq80rLtBtZ73kAaD2cmGlSjLRy0ntSADoQvIXJDPOewrByKq5eF+EaHiDDwZxU8/+qivmNfihl+3Gc8haetqPltw60eHXafb+1JuvjrqqT0n60UVpaStP0tLAjcg7vzyEhNTJ95iOC0y66uZr8Ue3vCnaKzIQ1DRJq6t1SuBPzu8NRPE4c536Dp+UQ+TxQzYyKPMxTT0CxF+Ea9B9cx0+BA6vrvTz9lp8wLn8dd2I2zi6TQ2+86aeQXx8stpF/YC/9M3SoKjz4p4u3V3vYeUsSO2jJrcr9AffrqG7nGc8jmHGyz9iajo9vpcrpoVuLeB46pS3D+rTHbNAz5IGZrNtTxPAuTflhygg+W7Cba99ZQresZBY/Ng66nAaOCmJ+ugaAylPe8Wnl+iN7iO99RR7mT05GqcjF1fUMXGOe9n2nCy5RZvzhKvTbZ+I87ibcA6/3/s7lYC8VSSmdXrR4LSkireDw6y+1tZ/9x03tu9rjra2gpkRSJAjD+VRaWkrTJqnh96Pc/LrbOe2o1dccg6YrnZefT35+PmlpaaQ3qZvJsmjxYiorK6mqrCK7VTapqak0SU2lRVZLSkqKueaaa3n4kYdrqFQ7nA4efPAh3n7rrTrH0xsMbFg4k7bTTkNxV/GuezJ3vDEdjyU5rDF93ScP8MN7L9C9W1c53qqpGP94CE9GXxynvRd0P8PMOzBsn4m7WS+cA64PfoL4+p0bBcWlvH3XefRKdzOpo56ZO2F4G2nLy/a7OOEDG3odrLgyltaZTbh/VhEvzpc6LP2yzLw6KQ0FGPTqftwe2H57U1paHehcojP9/nqFnr360jkzwG894Krqt+Yfr0apKqHqxMdRk2tlasTXGq+CwPzlOSjlh6g67wfUpiGyoszeorEeN+bnWqO4Kqm6erGc119Grr66I1pf85+LjqT/aDga/Sgcu64hJratQApbGyyQ1KKuzRbOPF2b1Kkqw/xaH2kP5/+ImuV18IdTM8DtwPz2UJTKIhyjHsPTaljwbR11a7QY1nyEYe0nuDP64xz1iHy4dUb95wWqKivocs1UDhdV8NmdJ3PeMz+helQ2vnEZr09fzcs/rqTyLjMGHditWZQ49SRZdHg8KuPe3ss6e9Owxo3n3A/Slj2YcKBDxdH/WjzZdSOd9VumYVz3GarejGP0k6gpwTOgaiCuGeZPJ6GUH8TV90pcx90YeLuYMMkRkxXd9lmYvjof1Wil6or5UuvHYPHWDygHY5zI+wSz/Y+SvRexXRdoPooE2hzstIuevtsp96VJI9kKfeOHwQKFO3w1TpK9QU6VRSK/ZEkGlx3jzzej3zEL58iHcfe7KuTpDb/cimHdp7g6TMA17K7Q15qzDAD9nj8xbv4ed9OeOHtdXHe7EDVNZi7bxqX//YHSikpGdU7hhxv7sK+oklveW8i0s42oOiNVTXuj6kw0vXUOtio3y65Lp3O6kT3FLrq+eBhUeHJcIjccF8cOtQW3eu7gVM8MrlM/xImeW3QPsa1Wdl/Bz48yd0p/9DoduKu49JW5fLVwJ+ce35a3r6s7JhgOLMNQuA1Xu3G4+l4W+rnEpNT5SLd3AaY/HkA1xFB12gcy9qeHp0OvHFqN+aMJqKY4qs74EtK896K6QDH4avoEI10i6SP+89ORFnb3Q6TzUTQi++gjmrHwz0O0f0QRxV+HI6qx8PTTTzNv3jzOP/98nnrqKY4//njS09PJzc1l/vz5rF27lvj4eJ566qnGut5/LGJMhrAmlrDQkIWqKR6ID/2Z0wF6FRQHWONAdfi0kCu8CxW1EnQuMBulAHBlEWb7YTD7SfUU76VzMyvxVjPFJaVMOnkCf/ynixS3bHkcWR16cfYpY/n0mx856/bn+PHTdxkzchg926jEmO6loqKcg/pMOvY6C9Z9ir50H/rc1QENwAR9JW5nFef2sJLQqiMARTl7cLvCi/Lv11xhQHolOCulYLTHCYoOg0GPwe0IsIc8e7PiBMX7O4QbKW1QZOHnqCCmZCckBYme1WonJMv3hpLdGHQBnNF1ykgo0GYYrPkMU+4q6DQanEVS7MxUSzM1xgwk+f7vLgN7CRj13nZxhHDafAu3EAXPHBH2iRgc9fejcKMAw+lHpniIDfI8XKUQnyjEW3I66Pzap9MOC5+V9pQ9BFNbPwdFUU7d6/hlitRrSOuAoedZGGwHIDaMQs8t+8Jy0JcfQh+XGFovtnXoAs8tXG66Pf4mz401c3VfEw8NN9C/uZPdzlRMTTKgJPB+W5R2/Fe5lv9TX6KFcxdDmjlYl6uy6GIjFmMOxHTgx+V7WL39EPEWI59dP4A4o8rMlbtxO6uY1CedGJ1b7rdSogSJSSImMYgDsahWBtPQ22Dm3Rg2fI0huaWvKGmLfoH3dztgrxQwNbYdhlGvgqNK+p01VggFFak/ojikDZjigSAGqf+4afJu46ySz6iSfZV4v/7QSPOAHxzGMAvrehFwPjLFo6p+bc7bjcqKC8HtpKy4kJYZfs5obx9v3TyV/bmFZHZoR3bLluTl57Np43qOG9CX6dOn8+rLL2AxG3jooQdRFIWcnBwuvPCi6qLNXTp1pHvPnmzduo01q1fjcFZR7onB3eMcDKs+4PIOxUzesp7x51we1r2VlxZz2llns3ju77RokQmHJEpb17QrMWqQQp8eN+xdAIA+JRt9cYgMoLw1Qb/afaiY579byjsz1mCrcvLMaDOgp1+7NGKyJLvotV9W43YWceGQTLr16Q7mBJ69Avp12cs1761gyc5SBr1YToLFgMvh4JVTksk2laC4VA5XqFzwrY27L5lI7+5BpPgs3vHWVQVV0mnNqdlgrjUOm8OrQ6Q5qM1GAxhDjC/V3+kgtT0cXoe5aBskZ4LtMBgM8p2pVj9y2MQxoyJOUMXbn5xFSP+xyhh8pP0njHkh4vkoHLuuIfaaUw8pGV5Hld/8E8iOA29heXtNx7HeVNMhtn+9tAdLMubs/qDzPg9rmPN910mwYiqmbT9B1wA1bTSU7ar5f1WFnb8CoM/qi77KmwkQH14E8wNvfMuB3EKaJ1toaizHVVVJZoqVVIp4d/pyEg0uDDoh7SyxcVi8v/Ob8w4zb2sR6S3DI6JMOjcxuNGSUU17/wRDgPYemwQJGSilBzDPfwrOfD8kiV2NDZ9D+UFIaIHhxHsxBLOLXGHak3qgw2ho3gvl4Gpilr0qc6FqB6MCqk5eqTUXQd35qZERcT8yG4mpbzwK1Y9MCUCCz+40JtUiMON8/cNph7gkcMVCUqZsV1EAMRZvf0sEhxHKpNC4MbE5RjVEkWpnJWz5EQBDuxMw1LseqJKXSsli08fEodc+80fzTkGPcOopnbgjz8XdL36KuTKPmH3z+HWZg/Ft5XvF4yTmoMyvvVOr+HOPmxU5Nno3j6djqo5HTrCwKdfJDQNiiNF7MHk84IEflLH0UDdxPMsC1lu4pIeB2ANiO60z9+eLPzehqnDLGYOJSQwgn7lD7tGQPRBDXD39vXYdOY8Lpn0o99PnYmKyvEWgw6lBApDdHywpKPZCYqoOgrG9BEw4K+XV5O2zSpC+G2ysDQR/+y7cth/GvBCpXRdFFFFEEUUUfyeOSAqpS5cuLFiwgKFDh7JmzRpeffVVHnjgAV599VXWrFnD0KFDWbBgAV26/EX6+FE0DI4KqMiX9zqDN6owFpKzIClLIjCSMiVaxBzrW6wmeDXNyw7UOWRm82b8/u2HJCclsm/LanSbvRkr/a8EYOrLT3Lq+DFUVVVx6vmX8+sff6IoCu1atwJgx649kNJGsiNUD1XlxQEvfXxPcXT9stZHJFgiMMbWH/KSBx6XL9LOnNCoBbhqIM7rmCsPg/hIzpbXoj3hH7+1N2po1zwxoFW3LKTqQ0WhOB3yd0hbqMgPGHkYNhw27zMNsSBrCEyNH10XEE6bPANniOs3WaWtJGfVJU9shaC1+aG3hz7X1l9g11zpe6MelIi7cJHSBvRmyTYpPxz+fgFgNOjJSEvgmp8q2WRLosoNEzsYSarMwewqC7nvn7rj+F4R3ey3TraQGa/DYpQ+pKoqj367DoDrx3QgPdGC0+Xh17USkXdSL7/aCNo9xEUg3dKsO/S6QN4vfhWK94befu8SadvWVEjv4i3GrHgLQSKfx6aCy+FzVEDwNmGyClnhsPm+M1nluJpzw2iVcTQEyXbMwGUHWwG24gLy8vKxWq2YzWaa1M5W8Pbxls3SGHTccbTMykJVVRYuXMgv077jwsnjOe+cswD473//y91338Mvv/zCcccNYunSpSQmJnLu5FOYeMopdOzQkSuvvKK6vLPBaMDW6zIhynb8TlLlPjKah1dDo3WrbPbvP8D4SWeQk7MPDq2XL5qFiLbfv0IyVgwx0qcixNqduZz/1A+0u+x1XvphObYqJ71axjOyq4z3qTFyZ/uLKvl6hbTxy4Zm8sKs3ezMFSnBcwe3ZOPTYzm1bwZOtwerzsmiKxK4tpcbBRV3fAu6vlbObzvddM8Ow1mq9SVjLJjCICmDwutpjWRObCIkCgdWCWGquqA83/e9wybOvIoCKN7vnW/Kfc4/nUGIBm0O+Sf1n8ZA7fGjPjjt3uK0dpl7KnLluftjy3R5bXuid8yLEN1OBxTYuwhK9oW/X+FOKM+V7LPMyOof/Dh/PU//KP33lcuO41CR2DKtmsTx32kbKLM7GdHBG+Gv6Kvb6LZcO3d8L/NA7xaBC9EGhdbOy4LYaIpOyGu9Sey4NZ/Vf8ySfTI3AYx9rPHasaLAsCnyfs1ncs3OShnHrKkSfR+oLQVrX+HYPZFs91fDaJW5u/Z9maw+UgEku0ojFcA35mhrG6MFSrwBIMECgDTs+F3Grth0sUXCRaU3UiOcDJXCnbDgBVj+XrVDetn6HQAMyZL1zmfrnZzcoW6/Hp4t38/Z6SM87j4hiQ/PbkJMbaJYUXhOdxWHaEJz8rjV81YNB/iQNr555L7356CqcOawzvRpHyCLr6oc7IWAAs171n+PtbHxB8ksiUmE/ldEvr9O78sm37PQ99vHpvgy9CsKG6cNH+n8dKz2pyiiiCKKKKKIAEdELAB069aNOXPmsGfPHn788Uc++ugjfvzxR/bs2cOcOXPo2rVrY1xnFOFAM060v3CNFG1RCmIc1Y5uB/ksMRMSMn3Gt+b8K6lLLAD06dmN37/9kPtHxmPUwYr8GErjpfijyWTiy6mvccpJo6msrOKU8y5nzvxFtGsjzvTtu3azZv1mFh+SJvrC98tZn1M3ZFojFmauy8XlFgeIxaTHaStFdQXKOPDB7XSwP7eInGIHVJbKh3pTYPkVDUdKOGjyE2VhOIGTvMRCyT5J7Q4HrY6X18PrxcGg6MNLdY9NAY8HYuLF2NacFA1FpI6RcPFXOZZqEyOBDH9tMQHyna1I/px2WRC5HfJ7txpS9/gaCrbDn175nv5XQVqEBV51epHKACiqx6EeBto3l0Xu/P16Duky2FnkoVksZJYsZ4z795D7fqycToVLR6skHbcOEt13t0flto9WsGxHARaTnlsmSBr7oq15lNqdpMWb6dfWz0laTSxEKHfV4yzI6C1R2nMeF+dKMOz4TV6zjxcnUWyqRLC5qyRy3Wn3Rp5ZZTzQ+kEwsszozcoxmHzf/ZMdod77tJXk43K5iI2NpUuXznVlkLx9fMbsP3n4kYf5efp0FEXh4MGD4KigMP8wg3p3oU/v3gC89NJLTJ58BkVFRaQ3SePNF5+h/4AB2CpsNElvwoknjq6ux5SUmISpSTvcHb0Fhxe+hBEnbmfoMd2oV5j66nM0a9aUdes30LdPTyjyRlCHcvposixNOkbkdHW5PTz++QJ63/Aun/6xAbdH5cTerZj1+LmsfGAwfdp6n5k3++212XtxuVWGdUjmjTk53PL5ZtreMp3Xf5NaVZkpVr67ZQhLpnRh840JDMhAxvCm3dig70aBTSU5zkxaQhAZPX/4k3RHMm9pjqV6dLproIk32jZ/mxAEigHi/CQiNJujohAMRhnHTHE+qaTYVNn+aMwh/wREOn74O0Y1P6B/QKyqwjaRZaDDmIZdU2ILaOktSrv+m/D327NQXjP6hratamH3wUIufuxTAG4e35nTB2azJ1+CHTKSrbz8yyYAbhvnLSju7bdllW5OfXMrpZVu+rWMZeGmA/WPG6qDRLRaYd6+YiuQ+SQQzPG+II5VH0HeluAHV1VY9KqMAW1HQoeTQt94pGgnWQs4bbD6E+lPIFIvRkvgtlT7M82+Kc8PLyDkaAWOhIuGOGJrrHNS6xIt/p/ZCyWDGSAxK/RxN3wrr+1GRTZGVhMLScG3sRfBsnfgj8fg0DrYswCKdqGqKgtWS+bmkJZ6cko8lDtUWiTo8NSKhB/RSvrFnJ2VQesdJioVGJE1RrB6C6rbQaalEofLwz3TDvDDoq3odAoPXzQi8LVr5GNaO59MXrgoPwwLXpT3A66OfH8N7aRWE7vmCrntbxc6K8Nrw4HaWmMTAX93f4oiiiiiiCKKRsAREwsasrKymDhxIueffz4TJ04kK0uMsV27dnHJJZc01mmiCAXNOKkoiMxIqR2tA74sBi1qvSIf8neKs1pDrNdpEiBjQUPvNAeX9ZKImSk/FzD1U9+C1GQy8dX7r3PqiYPpkuzkt7fuY3g7kUm4+a4H6T38JD5fLMfulurm+g/qSlD0zk7EoFcosTnZckDIAYNeR2VJHgc+v41Xsn7huRa+QmTPtZjFKzHP8krMs+z76HoqS/LIK7JVO36IOYrZCuBzmIYTXR6XLpFnqhtKgz/jGohtAuleMi9nkbxqEaGBoP3ORgs07ybnjE3xOdfCzVyobWgfLcfqXxXZU5sYCWX4a9/Zi72vRbDfWzCuWYhIrfLD8NPN8nyb94Y+FzbsWrWIuvoi9cNA82QhFfcWOshumsTTy838tNWJXlG5jXc5Z/1l9Nvkk7Z7TnmSV3SP8oruUV7TP8asHULundNNDx43z8wr5/mfxQH0+Dm9SU+UMeaLRbsBGNszQ/R6NZR7ZTIiJRYUHQydIjURivfCkteDb7vdS5BkDxbZCYdNnAoJmd426xe16D8uhiLLjhaRVh8a2h/qy8TRGbAmpmEwGIiNDRLx6+3jS1etpbi4hBUrlgMwYMAA2nXqxpDjh9Gj70CyW7WiVatW1bu1zMqiTZu2LF62go5tWjJy6CAmT57M8mWiPa0oSvU5XQOvk502fEdHSxELXrqaXd8+zultfUTrc+f15JWLevPKRb1578r+9OnSht+m/8jwocfTJ13a47YCN2MunsK0mX/gdteSUnDaYccf8j49/ECImct30uu6d/i/9+fi8aicPqQjK16+jF+fOI/RfVqjKIrPkep1UH69XKKgB7dL4oulvojo66auZOu+fCjZj3JgJQOs+7AaVInWzB4MiS3YVyDjcILFFJ66jjbHxB9hTRpNqz8iYkFkCSncIdJiic19xAH4+lZsijiNUttJ5pcphPMziuAwxfqCQmJTJHra6pUecdph7ZdQtFuy29qEWRMqELp7a11t/CG8YAe3C3IWy/vswRGd6tnP/6C43M7A9mk8fYHI2i3dLnW/7A4XFVUuOjRPYFAbr9NRZ8DjUbnow+1sOmQnI9FI03gjZUV56KffzvOxb7J66h3Vx39OfZhX1Pt4Rb2P97iTdK3Aur/9FyxrASCtg7Rb1QNznwweiLFnAexfLiT12Mcb376snbVQcrCmJFY484NmwyiEN4/9XfOdhvrsMS0bqqLAj+wPsM4JhkIvGR2f4a03FAQV+bDrT3mvSTCGC622SaCMBbcTNk2DmfdIhpD/dvtXUFxWweECISaaxemYsd3FKR2FUNLVal+DWugx6WF/qZtVBwITbOlKEe8ZH2bctgdY+vbtbFXa8rYidfCucn9A5VfXceLWB0jXlTB1SSFP/Cpzy42n9qdTyyA1BbSMj+a9w3gYfrAXwTeXS9ZVUjb0Oj+y/f3RdqTMWwXbJRvbZfdrDzHhteFAba2xiYC/uz9FEUUUUUQRRSOg0YiF2ti7dy9XXnklnTp14qOPPjpap4nCH5pxEpsavpHitPkVVfRzIPmn1oM3ir0KbMW+bRK9Ds3S/UGObYfpt6NT3SwpTuOP3W6JHMvbCuu+hpn3YPr0NL4fsp4VV8XxaJ9DXJ/4G03jhYhQVRVTaykweHxLA8M61NXo/GbZAVxulSbxZto0lTTdrQeFYMiyVNI+poi2Zp8kQFtzEe11+/Hk72LL7oPoFOiRqhnbimQuVJZIGq+rSgx8j1uizrS/I4HFWzAsHGJB0YmzEyJzGrf26vnvWy51E9yV8vsFgv/vrDkntD+o2QY0EiLQIvWvirhx2P+a89R2aoXjVDaYvenfxXBAdN1pGsJROev/xJGe3ArGP9MweQrwZbYU7Q5cGDpMqKrK3A3Sl3tmWnG5VX7dWs4pn9lZeDgGVYVLO1dyY8ZqrvO8T091A23Job2yl/bKXnS2PK74oYxvNznRKQr2ykoe+F2i/l6/YiD/8WYrHCq28+4fEqF96Yi2NS9Cc+RESiwAWJJg+J3Sb7b/Ctt+rbtNcQ7kb5Uo8DYjQGf0ZSho0m8mv9/cP4rxWCTLqvtdhNlFobY3WNidV86KdZuoqKjAag3tiOnbtx9JSYn07SvOvz7dOnHWaSfTo+8gBg0byZVXXsm4ceM4e/IkHrn3Drp2bItOpyPvYA5Wi5l2rVqg1+l58MEHAZgwfjxmszjk1abdcHecAKqH2zsfJCPZwrbVC7n+knOqz982PY72zeJp3yyedG8kf9cunZnz63Te+r9LAVi0z8OvcxdyykXX027gOF586yM8Hq/DfM8CcTjozWE54TfuyWP8fV8w7t7P2bAnn+S4GN69ZQLf3DeZPu1rFUTWS+YObgeoKhcMEjmnZ2bsZnhH33z2wbkZtLcth8ProEKcp6S0hayB1fPygA5NibcY2ZNXxtcLt9d7nQ3O/vGHqvqifCMhFtL8iIUqbyS4FkENvr6l/UUdKsER6figzePas3bYxPENcNx1EjzRULQeKsEL9iLYOaf+7fcv90V+h5oLA8DhkrlsfO8WmAx65m06zNeL96AosDNXjnnpCe2qSbsDxXYmvbGJ79cUYTIoPDs5m+kbiwF4dlwcjrzdFOzbUX38tuylPXtozx4fqQA1bbxQkpWKAm2GgzVNorPXfF53G1WFpW/J+0E3SJ8+Gmg3Wn4Xpw3WfFKTWAjHXqpeO6SFN8f93aRfKHtMu+eS/WJf2Qp8+wQbazQywuGVPtTk81Jahb6OrTMk8CexZf2ZDf5QPb5+UVumLncjzH8ONn4v80ZqOzjhXuh5rny/fwVJcVYG9RS5uRt/saMoKuPaBZaAtRgVTu8stuV9s4pxugOvYdKVIn5bupGyQ0KqTFdGUuTQY9TB60MLucJbRq9Tui/r6JGLRwS+P1elT8I1o1fQxxAQv9wpREBsOkx+N6IspzqwpkCmt9ZW7nqvvefNWjBZhYStrw1HIiXWUPzd/SmKKKKIIoooGgENIhbmz5/PCSecQEJCAikpKZx66qls2SKpwDabjVtvvZUOHTrw7rvv0qRJE1566aVGvegogkAzTsJdHIDPMRUo2spe6nsfmwI6M1iTAHFCqtUGexD9ZkWpdkqobge/XWjlRvU9+PwckSvZ9CMUi/GZVyFOHp3HyauPTOG8Myax9Pdp9BpxGntLPCTGKNwzvOb97Cu08cgPkg5805i2WLxFs9buLQagR8ukoLf9wjwhGyZ0isWg1wxyVQx5p92r91wBjjKpPVBZ5I0wUgElMieLBqfdp7sfjrMnd5Noq0LDo04tiaCPkd8vEEJFcdX+LtQi9a+KuDFZ/p7InlCGf/V3FjB7+4KWzbNlui/itza059hhfHg6u8GQ5K3xUFXqi25rAJZuO8yOQ6XEGBXGdUniy5UF7MyvIjXOQM8O2TjiWpBvU2kWp3CqOounPY9hchVzoLCC5+cV0/mFXC7oYazW+d2U58LhlhoKV5/ok3h67qeNVDk9HNc+jZHd/ByxbgfkeQsz17egDwZLsq8YnxqAZMn3SlaktpM+paslFebvYIgEgYi1cB2CR0LKVfe7CGuP1LN9Tk4OdrudnByJOlRVUIP8Gz/+JO6/734mjB/vnRfyUctzUW35eDwqo0aN4oEHHuA/11/FiOMHMbBvL1JSUujSoz8tWrYGo4V333uPrdu2odPpePSRhykrL6O8vILy8gpKBtwOpljiijaw6fWLuGPK7egNPhLu7anvB5V4aJklxOxpE0Yz5frLSE5KYHfOfv5z3xM8/+YHslFMIlJjowrWfuFzhNdCXnEF1784jR7XvsMvy3Zg0Ou45bQBbJ96LZeNDZKZpDf55gqnnXtPbsuFgzJwe1SW7izhvUu7Uf7aKC7qUCECLOZ4cT5mDxFZNL95Ji3Bwu2TJPrz3k+X4HTVQyJqcntxzUJvFwr528QBpjdFVvckuZU4uF1VIhPTUFm9/xXt6VD3eaSkvdESfA6KFDqDLzL7YPAi5tXQiDUAW5CsySBITRBCraCsCqfLw3XvyNx2ar8sNu4rwWzUccXIDszeXoFHVcmI9fD2OA+TOxt445xWzNhQjKrCpJ7JdMuwsjInjMxLVa05b5jrmZedlb5iywEzEVQfUag5ho8GKvJ8NTW0Gk1Ou1yf21G/vfRPc2yGtMc0u9WbaVB7agg0xzvtMs4V7/cWkg8zQMPqtatL9sLcp3yZz/VCEVsFhNgGCUhZ9ZH8VRbLsQdcDcPvgpTWIuWnM0BFHkr5Yd57+DrMJiMztrtZc8hDgS140NNdQ8zodTB9i52J7x+mtLLueLC/xMWMrXbMejjZM4upnltJNslzSLIaSLGKXTWsXRwdvOTCF3M31j2Z2wkbf5T1kykusroTqurLcDrl5boFnRuCWK/UpqLzy8QujCCjPwwpsSiiiCKKKKKIInJiYcWKFZx44onMnTuX8vJyiouLmTZtGieccALbt29nwIABvPDCC6SlpfHiiy+yY8cOrr/++qNx7VE0BjTHVCDHssUvsi02DdLa+AxpEN1KgFZDAx/bECPyJMBxqaWMamPAiAOMVnJj2vLIn1WM/8RG6tNlnP+tVlQtgckXXsUnb79Ev949ePKlN7nvD4lIs1TkgNvB4ZJKXpy5nW53/87mA2WkxJm47kQpuLk7r5z5W2QhF4xY+HVrBW8skjTi/wxLlnuKbSLZBDGJPskGnaEWgeA13E1xkRMLqgor35coUkuyaMLXt/3cp+ScHU6StPtwsWuevDbrKXII6R3kfmrLGjkqAmeraPCXVwDfMwm0SP2rDO1j2aA3xohT0umA7mdKO8nb7EuVr42e3qjr9V+FX0MjEPQmn2729tmyQI0Qqqoy5X3Rwj6zdypWk44nZkn2wn9OaE6sWY85NoGPdyQx6UsnM5QRlBCHDpWMOJVbBhrYd0scL46LwahX2FEEw6ZWkGBWeOuq40QWBsgvreS1WVsBuPf07tWfA+KoclVK0cmGRHaqHlj4MnicoufdfmzdbTTd34QMaUPaeFacA0U54lSIpL6I5hCEun0jXIfgkZByDe0PQbZXFAVFUcjKysJisZCVlYWCElK9Q76XDJX8ggLsNhsKKiuWL+P555/ntddeY9WqVeQczOXQ4VxSmzYnMzMTQ4yFnQcK2bJjD++++y4Al156KV27dsVkNGI0yZ8+tRW2kY8DYFr8Mk9dOYYF8+ZWn/+W2+9i4mlnsnt3gCL3zXsBEF+xm6fvv519q/7ggdtFXum+p17mz0XLUTP7wYRnJTKy9ACs+rBGcdricjuvfL+YDhe/wGs/LsXtUZk0uAMb37qK564+kZT4ECSNovjGT0c5iqLwzqXdGNU5lfIqN0/9vA1z3jpAFbK55WAhFIJoSt9ySk/iLUa2HSjhwc+XBT8vQJkUR6+u69MQaAV/242OTOdap4eMPvL+0Nrw5Ec0OGze/rg3fM33fzpCjRV1ZPn8ZCprS1ZWH69CZCu1bKzBN8nnC1+SgI4jQap3bC7aXf+2mX18jsUtMyI7TaLcb0FZFS9O38j6nGLS4s2YDOLgPHtQa9ISYnhhbgFD3rOxuwSaxun4+iwro5uX8fsmCXy5e4yQi6v2hSAWVNWbmernUO40EdI7Bd/H7YAtv0gQSnoX6HVe3W0UnUReQ/hylpFC9cCP10v7SWkDfS+Tz512qbeg1QD6X4GWmZDYwivtWavQfe1sbJDxyeWU56UixChA4e7Q5+o4HsY9Kf1zx+8iXaRlIoSCokDnU+T93kUie7TgOclWUHTQejiMfhSyBvgIK0OMbx1waC2dWmfy0HWyjvhknZP/m12F2xOYXOjZTM/3F6ZjNSrM2lbJ8W8cZGlOFR6/7acuK+WafkZ23WjmBvV9mlDIvlKVO393kNqsZfV1KIrC5cfJM/2yNrHgccPmn2Xu0Zuhy6ly3eHCUe4jZyJZ84TCYe81JnhJitKDItNkKwq+TxRRRBFFFFFEETEiJhaefvppHA4HTzzxBLm5ueTm5vLwww9z6NAhhg4dyubNm7n33nvZvn07N954Y7WkQRTHKDTHVG3Hcu1odf+FKoC9GGWfaGoHJRYAOk2A467jy61Grv7JzgfKWXiu+IPWj2zm/j+q+GW7i0K7yhV9JLKtsOmQ6qiSAwcPs27jZj5e62RDngc8Ll7+4nea3TCd/3y8lhKbkwFtkllw33BS4ky8M3s7bW+eVp2x0LtV4Cj9B2bKgvO6wYmMbG8Vg1mnl+KrWtR5TCKYE6SwWkyyRK6Z4uVViwiLBAXb4MAqiaYecLUcOxR2zIZ9y8RpPPTW8M9TkQe5G+R9ywG+z/0jsjQnRKAFVjD4kxD/S4vUSFAt8xEj2T3awnH1J4G37zBOCK2KPF/x2IYio7dIInmcPmdgBCgqr2LeRnFE3jM2k5wiB+sPSLvon+0bG64Y0oyFB3U8r1zJObrXGfWxg7dXOCi0q5gNCirgwMgJH1RQ4YQHR8XTIlX2L7E5OOWZOVRUuejRMpnxvTNrXsTeJfKaNbBhOtTbZomUjMEsshOBjqE5d2LTveOZzS9DqVycCuHqMIPPIQh1HfzhEgaNQZY1ckR361atGDZ0KK39aiPUxu7de5g3bz579opMW25uLocPHyKvQpzkq7ftZ9q0abzyyiu8+eabNMnIJqFpNhu27GT//v3s2bMHk9lMXn4eO3aIRMn+/fvZv7+utJ6z0ylUdT8PUOG7a+jW0ucsMpnNTJ8xi449+vKf2+8kL88vMlqTYSjaA1XlWK0WHrj9ekYMHoDdXsnwSRfRffipvDBjO4XtzhBZE0cF6tovWL9gBmc/8jnNzniaG1/+meLySnq2bcbsp87ju/vPoH1mkCyw2tAy+hwVeDwqs9bnU+kUB+Zjw3UYPJXS3pp2C9nuHU43n8zdSpldSMj3ft8U/Jyq6pNxiW8e3nXWhtspfQqEKI0ULfrLa96mWprv9WQEVRQIsVORF77meyho5F84tYL+LoQaK+oU2vWbt4PN4U67OMm1z7tMgo4T5LNvrzoyckFzuoZDLIDYgAC7/xSpyTBRVCbXXul088Fckf66ZUJX/twkmTjZTeJ4f842fl61j8X73JRbs3HFpOL2QAurg3XXxvHLxckMaGKnOP8Q6foSbhuo53TPz5zqmYFedYpTXvV4CQXNyaqInZacHfziVNVL4hdKQMrI+2pmZ/hDI/YaoQZSQCx6VWSpDBYYdofIumm10LTsvf+FrJ/aCCZ9FChL12SFpEwhT2NTffNG2YGaBX8DoftZcPq70j8ProGf/hO6NoeGtA4SAIEKexfKeJvcSkjADuMCSwA18+oRHRapplsvnEhyDBRVwprDHl5fHjxjYmInC39e3Yxm8XrWHXIy8NWDNHssh4u/yOODJflc0t3Dq+MtpFshjxReVi6lw+sOXMZ4zCZpR/uKHDwx6xCPzJT7O1DgR6KoHpkvivfI8+1yqk9SNVxoWfBGa2RkdDBUlVZnxZOQIaSCvUCy8Y9iKb0ooogiiiii+F9ExMTCggULGDlyJHfeeSdpaWmkpaVx7733Mnz4cHJzc3n66ad5+OGHiYmJIEohimMPWrQ6yKKkolCiUbSF6oLnZQHTpLOvUGMgKAr0v4IVaZN5a4WTaSty0BmMfPjqM2RlZtC/T08uOHkEkzqJs378Iz/x7bRfAMjMaMZd/7kOjwq3zZTzXtXHQHaiQv82ybx8UU8W3D+cThnxzFp3mGveXYZHVRncIY1XL+1HlxZ109jzyqpYvFcWCnePDNMxpBEPeqO8Rory3OqFAD3PkaiyUHA7YN5/5X2fi8UgDhe758trk85SeM5WJA4V/4gs7TeMpJhdJCTE/xI0p1VFvjcCSgVHpWT79Dhbttk83bdg8ofeBD288gjL3xXZkYZC0UHnk+U1dxPkbo5o96RYM+0zpL/M31FGZpKJId6imJPf3srsLZLhExej5+sr2oOi4EHHa6elcsVxyaQkxIHBgmK08sjcKnJK3GQn6bm6vy/qdNQjv7Joax7JsSbeu3ZQzWwFVRUiDYRYiBS2Qlj+nrzvfVFw6TAtEt2SJL+Jvdjb/g3gcoXWYQ6ESByCRxOR1lhoBGhySbWJANVoAWsqnXv0paxUHIkHDhxg6PHHM2rUKNLS0khKSiIlJYU9e/aQ3iSdU8ePwWAwMGPGDHr06s1770311UDwonL4fbjTOoMtH9OP16LzRhfPnz2LE0eegMPh4MVXXqdtl5488vhTlJeXS/ZLQgagSjQoEnH5+Zv/5eKzJ2GxxLBhy3Zuuf9Jml/0FhfPjGFVSQKK6qGbex0nJe7AgIuurdJ56YYJLH/9Gk7o2SqyB+Ul7Q/mFtD5/+Zx8ksrWbC9mJsGmpjcxYiKIpkVQQhrt8fDx/P30PmGT7n2DcnUaJEax+tXDw9+TnuRyBApusgkjPyxZ4HUG4prCq2Oj3z/Fl5t631+mRXhzCMKEuWq6L1BD1YhIhrqGP2r6v8cCSIZK/znbaNFHJIOe13ipNLP6RebKnrl3c86cnIhubW8lh7wyQCFQpPOso/bCdt/C+sUJeV2XvtOJGLOOC6bcb2EhP5t3QHuOKUbAI9+u4bLXl+AqsLN4zuTaDUw6PVcer1ZztL9bpJiFMa1ckNFHkmeQu4bauKpUQauVj/hOvVDjP7EggZFJzZefcT2gZVSP0TRwaj7QztQq4mFABlVR4p9y0VWFGDIf7yOZ0WI8uq5jcZp/8eKLFlFPuRu8WUK1ofa0kfB5nj/zy0pvgwtrQhxKLQeChOfl0CR4r3w440iAVcfOo6XOcoYC93OgP5XhZZJ1bJ/8raAqxKj0cAJrSUQq0Oqjv+bXcWuoiCyZ5XF9G1SxZabknl5Qhz9MvSc2UXPYyMULu6ho0WCjqJKlSpLOpfqnucn3WjiYwxMGdWUPYUOLvhwN9kPbuCenw5SXuXBajYy5cxBcmxVFXIrf6v0iU4TIaEBhLZmJ1tTQ28XLjQ7OC5d6tUZYiRoLDZZMscd9bTpY6XNRxFFFFFEEcU/ABETC7m5ufTt27fO5/37S3TaxRdffORXFcWxA80RoOBzqh/eiKI58UbeG1Z08ekTRarl9z8X4XK5mHzyOPauX8zS36fx0c0jMelhU4mFJbsrmHzR1dxx/2MUFBbxxAN3se7xUdxx5nGUEo/ZoLDlrrYsfegEbhjdFoNex/qcEs54aQluj8qFQ1sx/8HRXDcmcBrtb+sOoarQM8NMi6QGZB5ECqfN51hpOQhaDat/n9WfyuLEmgoDrozsfJrsTtsR8qq6xVh32qXOgjneL7I+NnC2SiBEQkL82xBsceG0iXxOVaksXD0uQJHIN0uyRL017SZZBOu+CnzsrqfJIrZ0P3x5gchfVRY37Drjm0L2YHm/+afqopbhQKdTuHqMFNecujgXg15hxvWdGNUxgfIqD+Nf28xHS/Ior3QzoJV3wa0oZCcahCDwkm87Cj08PU806p8fn4DFqPD7uoMMf3AmK3YW0iTBzB/3j6Zvm1oLR1uBPEdTHDTtEvm9L3lDnCmp7X2ZIoHgn7EAEqSqFfGLb4AD9liR5oq0xkIjQJNLyswUp196ejpNmzYjPV2e45DBgzn5lFNo2bIlQ4cOpaCgAJvdxsSJExk9ZjS9evUiISEBe6WdEf26MHlkP1IT4ygtLeX2O+7kpJMmsGHDRtwut/xhpGzsS2CKRZezkAvUbwDo0qkjv07/gVk/fU+f3r0oKyvj/ocfo3Wn7px+9vmsK/Rmw21ZVF2LoWl6Gu+/9DgH187ltafup0+PLjicbj6cvZE+L+xjyq+VuD0ql/QykX9fJuuem8y1p/SnqKyS7QcKWbntEH+s2c0Pi7by0W/rePXH5Tz/7VKe/WYJz3y1mKe+XMQTP+/gsWk7ePK3XAAS9FVsz7WRaDHw4uQsXhgnv5nSpFPAGiuqqvL98v30vHsWF76+hJ2HS2maZOHlK4ey/Y0LmHRcTYK6oLSSG9/6k8vvepqyQ94itbFNGl4UfrM386nraQ0j1LWimQXbffrvRgu4HDJ2aoVSa2cwWFMhqaVXws965MTAX1X/56+C/7xtipVn6h8woCGmlnSVTg8nvwRdTz8ycsGS7G2vqq9Aaygoii9rYfuvYc1L//38D4rKbHTObsqZg1px00ld0OsU/thwiOFdmnLN6I5SDkGFq0/swKn9suj75DqW763gYIWOfGMmuaQxZ5+et1c6eWuFg4/XuShREvhdGcIfyiDc6BHD1vun6MOTuCzaA3u9OvCth9ZflPpoZSxUlsB3V0vf6HASdDlF7iEmSbJTnRXS7xqr/R8rBF1FgdTDqQgQrBEIDQmKURRfMeZwf7eUNtK/UtqIDTf9dtizMPQ+JqsQQifcA5l9619LxTUV20V1SwAJMDxbxubmcWDUKXR+tZzj36vg7t8qWZTjwlUtd6SCx0WCwcEN/XQsuzKWV8dbaJGgo9Cusq3ESHJSCrNzTDgVWRv9d1ImL8zJpeOjG/lkeREeFYa1jeO981py6ItbuHiMt7ZQ7gY4tE7etx8bOtsnFDSyqLGIhcPe7O1mPcQuT2wuv2tKG3n2zsrQbfpYafNRRBFFFFFE8Q9AxCtOl8tFbGxdR6QNO85wAAEAAElEQVT2WWpqIxkExwA8Hg86XYPqWx9dhCsTEqSgZYANg39ltIgBrwB6gxhi856VSLWsgdDmhLr68AEibvodfyJJSUkUFxezdFMOgwcdJ6n0qlrtdO0w4Tpute/guTc/5JmX3+SFN97ljImjeeOuy+kWZ5Xtf70fc2UuS8ub0+u4ERSXVTDhjimUVbro2SKWeRsPMmXqPJ6Z3MYXEa36CISflkpK/YTje0KneqIwtaJ79UFz5taG2wVLXpNFUEIGjH+6fr1RezFMv03eD72tZk2L2lBqOXtU1UcstB4hTgd7EdiKweIS+aVQkXWh2pU5zleYuDERqeSN5sT+K8/tqJBsHUeFyA34f24wSSaI0eLLDDGY5dVph+5nSLbKqk988jz+v6k1BS76AeY8IRJG67+WqM7jbxFHQThOwSadfe+TW0s0W0UeHFgNfS/xfVe8r/aeNTBxUGduf38hq/fZ8cQ1Jy5B4ec7Mzj3tWV8t/wAF324A52yg26tmtDsUu9O3U4HvUSOq6rKLY/9hMMNo3tl0XHwMAa++BvLtkmUakZaIr+9dAOdWwXQfN/8s7y26B9cUqL6fmtlSG37FfbMl/4w8XlI7xx4P4BS7zNIzAJFI8oUX1S0yUrIHHlNEkxDsPok4aCx2jE0/BrChBLgmbRu1Yr09HQqKiqw2e3EWq3EWjW5FnEaP3r/PWC08PY773DnXXcxYMAArrn6agYMGMCevXvZsGED8fHN0dvbUlbyMx3bZFKlWNmydRtLli5lxAkjuemmm/jPzTfRtGlTSOhJ6fBHSPj1Vs5Vf2C92gkMI8FgYPS48YwaM46vvv6ae+9/kO3bt/PdD9PIPmzi+bExzPvxQy68+mN6dOnIGSeP45pLziUxKZlrL7uAay+7gJUbtvP+p19RUlrG8EkTUDtaUX+7j5jyQ7hXf8KTCz08+Hs57nCnVS90CtzQNZ44k8IHl3Ti1IGtic9bCS5VHP8dxtVoC2W2KqYt3sKL3y1h6WbJBkmKi+HOi8Zx45kjiLXUlcj4c9U2hl/7qvd/60gvWsETQwhdX8EUYjyvKPA5T3ucU3+fBOrYEdZkceAU7oTtf0D306QOjcla09GnvdccnyZrzX5Yo28GQH39SHPAa57okLcQ4Y8bzjEbw17TiBhTAL38QM/HZIUqVQhHf1JI5x0jVQ9s/F7IhdPfCk3GVu/rF4iR3BoOrhana9NuNbdLC5DBmtIONnwv42/uJsnmC1J7KLfYxvNfzAHg0fMHoE/KJCsJzhrWmc/mbOS5mbt4//ZJJCX/SbzVRPOUWEY/+gtuj0qvNul8d+8kflq6g0mP/YHTJdHbvdum8/p1ozG3b8HTq0W6c9C4QvShptf4AJmiZQdhxfvyvt1oOO7a+knlJK+TtWinkN/1IZzgDVWF6TdK0eCkljD2cW9WralWAWEleI2FUG0qEOrrh0eCcPqRdr3a86ldO6Eatfpb0Lm9nvOltJYst7IDvkLQodCko/xd/BP8cJ1E8M9+BM7/SkgDDeEGjniCFJDO6A3bZkr9rlbHM+KU82DGVJYf1rPouQt4ZdpKvlmwlQUL7Dy5wMH4/m346YHTUPbMr36GjsoK9C47OoMRJb4pKZlppCg65m4p4vIvdtPdW5LlsdlFbNkr66ATujXjmQv707etdw3R61R5LdwJi1+X930u9tUO0xAoWzcQUttJcAlIhkEgKSgIv2aDqvqIhfQu8n8ty0v73hgjRGewNn0023w480Jj2ohRRBFFFFFEcZTRwFC2fx927drF77//Tnl5OV26dGHMmDHodDpUVa0p2VEPqqqqqKryRWSVloavKfu3w2HzK+brt8i3FciCyOMCWz5snibfnRBetgKAXq9n3OgT+fyrr7nu5luZP3sWcSBRLsV7wBCDvsNYnn0wlsH9evH4S2+zct0mPvvuF84Y3oPTRw+izNSUOTsNnNzGRdnCqTS5/T2ap6ew92AeHVpl0Ca5iu9WFfDsr/u4f0I2CZa6zfuH1WLknjqwAcVhI8WmH2ThbbSIwR2OQbz0TYk2S+8M3SZHdr7CnRL5rjdBy+N8zm1LvDi/4/85EZvHVD8yWmVBVnvxrf3fDFQUSdSolk4P8uxbDZPt8rfAvqWBZX4SMuCUl2Hv+fD7w7Ltbw/A6o9h+N2Q1T/8azXEwICr4I/HhKjIHiLFYMNA2+ZJWM1GbFVOZq0/zLgezTAb9Xx5wwDu+XIDny3ex75COxv2laK5K29990/OHpzNut0F/LBkJ7+tycGg1/HSVcN59vtVLNt2GIvZyBUnD+auC0eT0aRuZDaqWh19R8vjwr9XkAyEX++X9wOuDE0qqB7R2AVIyqpJlIVb4FKLfrSXyu9dUSiRcEfZsd9QHO1+VFFRgdvloqI4j1g11uek0iL9vFk+O9YtxVFRwurVq7HZ7VRU+GRb9HodPYeMZH9JJfPmzWPE8GEkJiby7HPPsXHjJp599lnefvttHnzgAa655mqq2p9Mxf6lxG78nDs9r0HZOZAqhRl1Oh1nn3UWp592GvPnL2D1mjVUrJ8OrGBgCwNl5WUsWLqSBUtXcs/jzzF0YD9OHD6YE4cNplfv3rzUS6Qmdu3ey73vf8I3X+Xz8EAn53Y3cu8QHSNbWrlmhodCl5WEOAsJsRYS46wkxFowmwzodDp03gLYuuLd6HQKBp1Cpc5GHHYu6JcMpVtFRtBgEYeHolBur+KnxVv5cu4Gpi/dRpW3BoM1xsgtpx/H7WcOJql5q6C/w9s/zK/xf6u7GDA3vL7Clp8kKrZZ97DHj4Bo0U/mpZxFQiyAb17yr7sAQmb42x4atL6pZY6F6whtRITdjyJ11oYL/8jZQPNQoM+C2RsuB4x5TN5XkwuERy5oSGkjxELhrvC21+mh1/nw51OSkdk1uG2zYON+KiqdtM9I4rRB7ao/v23yAD6bs5HP5m7kqvG9eOKyEazblUu/m97H7VE5b0Rn3r5xLEu2HOTGN34HYEyfVtx95kCGd89CURQqg/hqw4LTDnOeFHI5rSP0vyK8/bQ+WA+xHxFWfyK/nc4AZ0wVJ7hGerscklHicootEqxNhmpTgRBJEegg0jFHNB9p12uyQnLL0Of2v9+GFq9O9ba9cGuJaDDHiezYDzfA1l/g++vg0l9CBwlFgoxeQiwcWAWqSrfsJqQlWMgvtbO/oJw3bxrHK9eN5pv5W7jgmZ+YvmwnT369jLuHCGG74GAxJ7+8hyKbi3bpFs4bUEHPLIUXf8/hz60l6I0+h/72g6Wkxpt5//qhTOjbou5a2FEBfzwuZFZmP+hx1pHdW3XGQoS1GYLBK39IajuRy9SIBa0+jdESOtjqf63weRRRRBFFFFEcARpELHz88ccsXry4xmfbt0sk+Pjx4+tsrygKP//8c0NO9Zdg/fr1DB8+nN69e7Np0yaSkpJo2rQp06ZNIzY2NiJy4YknnuChhx46yld8lOCfMuy/uPfLpOXP/4qDrsNJPg3lMPHkow8xe+5c1qxdx7kXXcr3bz2JXiMp2o6qds5NnjiayRNHM+Ckc1m2ej0GvR5VVbn8vpdZuriIMTfGM6qNgSkDqrjvD4nofPfhG3j4iWeqzxUf44vS83hqRiY9ftHxDOjYQIdLuNi3DPYuAhToeV54qb2FO2H9d/L+hHsil5/YJfrbZPSmOjLL6I1YjA9hIPsvxI4RB+kx1Y/8FxdOm49k0P5s+eJkdjvrRhsmZEhf2fANrPwodP2AlsfBxT/Cms9h/vNSc+Gby6D9GMleCbfWRkZvKai+ex4seR1OejqszAeDXsfVJ/Xg+e9X8OC3mxjbvSmKomDQ63j63O48fW53DhTZ+W51PpqAxlsz1/P6TytqHOeBcwbQqUUKa3bJIvH9ey/grFF9gp+47KBk1uhN3rYbJmyF8NXFUJErEkiDbgy9fXmeyFIpOmjSQTTIPc7ApFEwaIvS2BQhFTQJkmOk39TGUetH3jEj1qhQgQHFXkp+fjkWazyxTVr6Iv28DuGsFs3ZtWsnLXv2paKiApfLxf79+7FaLRw8eAij0cRFF13Ebbfeytw/57Jp4yYmnXoqo0eP5uuvv2b//gPcetttTH3/fR577DH6Dr6HQxsX0ZY9eKZdCxd9V6ONG41GTjhhBCecMALyxsJbw2kW52bTzKl8MnMZ737yNQcP5zJrznxmzRGnfGpKMqOGD6GsvIIZv82plk2asrgZ5k4DODVmCYOz7Ky91iwR1y0HhybW/eXP8raIVnfhDnBVoqKwVW3FqqWH+Gbdl/y8dCv2Klf15u0zUzhnRDeuP3UATZPrzxR7+obT8XhUPp0lsnsT+7UCDjaMWFBV2Ojt4V1OjXx/f7ToD2u/lACC2kEL1Y6dVJ+UXG3bwx+ROkIbEWH3o6N1jY0VOeu0CamlAie/KFHBa7+InFxI8dZZKAqTWADoNB6WvSVFxXf8HnSzpskyllY53TXs7r7tm3PWsM58+ecmxt/3Jd/cezp3vvcHDqebkwe24+PbJ1Bqc3Dx8yLhddno7rxz89iIAoOComgPrPxA+nBMEgybErQmSh1o83b5YYmODhaJHS7yNsOse+X9oBt90fDV0lhegiHOm01XvBeqysXhneTnkD+a0dhBav4c0XwU7vWG2we1QCoN/mOTwybZZNAwCSu9ESb8V4JECnfCtJvgzA8aJilXG+ld5fg2KXKv0ymcM7wzr0xbyXuz1jKuXxuMBj3njOhCUXkV1706i3ve/5MOMV3RKQrnvbORSqdk8mzPtfPwT7urD20yKFwyqgO7/U53z+k9mNgvq+51qCosfEmCmWKbSJ8IR0osFGyNKIXkn7FgSpD6WtZUSMz0rnW9NQO1WhoaIiGHjxaRHEUUUUQRRRT/QDSIWNi+fXs1kVAbM2bMqPNZoxj2Rwk2m41rrrmGs88+m9dee43i4mIWL17MlClTGDhwIL///jtNmzYNWxbp7rvv5tZbb63+f2lpKVlZAYyyYxG1Iwk1xKaC0wo5S2DbLDEeR9wd8eGzs1vy49dfMGLMeH6aPoNLr6vi3d5rMQKVrcdQO76uyiEp3ZYYEy99/BNfzVyIwaAnJ2Mi7Q7/xL3DzHTv3Z/8pJ4c37cL5VW+cDStzbk9Kld/shXGyudvnN+BK84YEPG1R4SS/bBe9L9pPzp0FLU/5r8gUaLtTpR6DJFCkxbI7CeR2QnN5fe0F8vnwQxf/4XYMeIgPWb7kdPmXZD4LVr9X/0XvVp/6nOhEAsbvoNxj4c+vs4AvS8QTeo/nxHn5LZZsHMu9L9cpI3CkUroe4lPqmLjD2Fnv9x5xkDemL6aJTuKmLH2MCf1rCmlkpFs4fLhrfnRK609tk82yzbn0Kt1GsO7tWBkjxYM6tQct9vDhr2SHdSzXWbok2pRZZl9wne6OMrhm8tl0R7fHM54r365glJvkeG4piJTpiDyHoEcEP4LRvBJMGjOGwg+Xh5DOGr9yDtmxBoNWBPTyDtow1NVToVTxaqqEo1vsAgpD2RktmTsxHRi4lOIjY2loqKCzMxMbDYbbrcHp9NBTk4OaWmp5ObsJsWqw9iiOa07dOaqK6/kjTfe5JNPP2XdunWccsopnHXO+cR2volXPP+HNWcRzH0GTggyJxlihHjK20ynBDuP3P0fHr7rZjZt3cGvcxbw258LmbNgKQWFRXz53U/Vu40+YSjXXX4RE8ediMFgkOyYGXfD/uWw8kPcB9byW1VPPvltNb8sWM2E43sz9eFratg7e/NtPPnTFlqZS7mjP9XFbm/6xcYrS5fUuMy2GcmcPbwbZw3vSo82TSOym5qnJfLJw5fx7M2TcSa0IWvVU1BAaCmkYMjdJHUR9CboMDby/f2h1VnI3QiV5TWzFPyJhHD60tF0hNaDsPvR0brGxoqcddjld3U55G/UQyJvuemHyMiFFG99j8Kd4Z/bECPFo5e+Cas+gtbDAhJzrZsmALCvoByny43Rb5Uy9dYJFJdXMmvlLsbd+wUAqQkW3rr5JDbuLeCaV2eRk1dGm2aJvHj1yCNbe7idYvNuneGbo3QGGH5HZNHnMUkyHrrs4txMPYJsWadN6ipoUqTHXVt3G/85CmoGBvmjsdpUIOdqkJo/YfejQMcM93rD7YP+2YeWhJqkptMOCZIFF3HGggZzPEx6Az48RWzzhS+JxOWRwmAScuHgaslasCRy+dgevDJtJd8v2kZ+iY20RLmPayf2ZlNOAS//uILz39mEw+1BVeGUnmm8c3FHft1YxCdLDrF2XwWn92nClDFZpLXuyqnemscmo56LR7QLfB2bf5b7UvSyHoxJOPJ702STQmURhIuSHLETdQYh1eylvmziUPNNJOTw30h2RxFFFFFEEcWxhoiJhV27IohQ+gegqqqK0tJSRo8eDUBSUhJjx46lbdu2nHPOOYwbN45Vq1aFLYtkNpsxm48wIumvQm3N0toRhRo0zeNFr8j/u53RYHmEgQP68+G7b3HW+Reh2zMfY28LG/Pc9Dj+Cp6452amXHdp9bY2uzhhXv1sOtPmLAfg2SmX0m74RFing00/cmriBhh2MgAVDh+x8M3KPEZ2TOKGz7fzxaoSRnn9IxccV7f+Q6OiZB+smCrGZpNOQhKEg51zJcNBZ4ARd0V+3pylsGuOvM/o662H4SUV3JUSERrMWP8bHTbBcEz2I6dNotTdlTWzB7QFb+2hQes3rYeJznLxHtGZ7jSx/nNZkqUwevczRX5h/3JY/JrUXzj/6/olyGISoe+lsphd97VoYoeBpsmxXDeqDc/+so0Hv93EuB6hHZzf3DWBGH1dfYn5mw5gq3IRY9LTrkWT4Cd0VMCBNfI+VDaHPzwukRk4tFae05kfhJfNoREL8c3kGCrBi1rWLtpX7QT1c9ho77Wox2OElPPHUetHtcaM2KQmVFRYpdaSy179nWKwoJisZHfuTeW6VXTOTifWCLFNmlRnBKiqyt69e9HrK7DbK+napik5O7fRrVcHuhw3EoD77ruP884+jaeffIrvp//KN998zaj7zuVF5QruVl+B+c9Bp5Ogea/A19u0q0T6HloP7U5EURS6dGxHl47tuPnqi3E6nSxdu4Xf5szH7XZz4TmTad+2Vp9JyBAC69cH8Gz8Hv2h1XQuWcnceRXkl6h8MO1Pzh47iJOO74Xb7eG9P3Zxx+frKbY56Zym447+knnwzUYnry1z0jTRTEZSDGOOEzKhd7vmRxyE0Sw1EYyVMg9BwzIWVn8sr21HSl2eI0F6Z+kXjgoozYF471igOXbAJ4EUTDPd38nYGA6nBiDsfnQsS2f4ZysoSBBDZSmMeVSkTLb+IuTCxAroeW7oY2nzSdFu+UtuFd41dJsMKz+Egm3SnwLYkc2SY4kx6al0uNmbV0bbLN/ztMYY+eHBMzjrse+YtkSCm165bgwvfr+cZ75ejNujEmMy8NFtE4izhFMXJAhKD8LsxySbDiSYJmsgdJkUue2rKDLnFO06cmLhjyck+8maCmOfDG/OiUsDR62gh8aMtA7kXA1yzLD7UX0O21DXH0g6TTtmDaLCL/tQ+3/1MSy+Nl68V/6SQsgvBUN6Jxj3BPx0iwQOpbRpGNlbGxm9fMRC2xH0atuUPu2asnL7YT75YyM3T/Jlkz931Ui2HShkxnJZu18zPIOXz22PQa/jvIFNObNvEzYcqKBFspm0eBMVbk/1vqf1b0lqfICAjfLDsOEHed//8vCDp0LB7YCCHfK+Mcb5fbJmJLm1BAMpCMHnL4MUiFiIZD10DK6doogiiiiiiOLvQsTEQnZ29tG4jr8NCQkJeDwe/vjjD047TTSAFUWhffv2TJ06lTPPPJMbbriBV1555ZjOvGgQqnWwgxRRrL2tVix45xxJDU9uWFs4c/JpzEz4ngMzngXWkGBW0OPmjkeew+PxcOcNlwPQJDWZ7bv28sPspQCcfdLx3Hj+BDlIt9MlpT5nKSx6FecJD7B2n0+3+4w3N1a/N8eEWezrSKCqsHchbPpRjNjYJtDrvPBSg8vzpMgbyD7hLtJBfrN5z8H8Z0WiKq0jtD1BjHTNaLYXhyh0h59j/F/WvhsbThs4K6CyRJwzkejytx4Oqz4Ux2Y4xIKGJh3FmbnlF5hxJ+RvFedQOOdtNVTIqn3LYO6T4hhp2r3e3/mOCe15adZ2lu4sYneejdbp4TvM80vtPPLFUl6bvg6AgR2aodcH6QOVpbB8KtgLpZBsVhiZRKoqdSh2z5P2Pfm98B01mqRBYpYQCqHkoWovGDUCVtOx1rIXakRex/q+/7enxvu3fVXFarFgtch48+fM79i4fi1duvVg2FiZU/v26UvfjtkBnUWtWrUCwO12s3v3blq1bkvndq1Q/JxmGzasZ926dYwYMYIRw4fy3GtTAVii9EbVW1Bcdom8DobMvpJFtmsODLm5Th8wGo0MOa4/Q46rp56JTg8dx3HHxyu5KnsnHVL1zLzAyvHv2Siwq2zPOcRvi9dx67MfsW5bDgAD2iRz3ajWFLkPYNbD0KE9cEyMRa/zXkOzHqHPGQkOrJbMKFclJGTKXyRY+6W3kLoick9HCp1eisvvXy5jX2wzcXRqpKsmgVSyD1RFnHy156poVGhdNMQx7PDKf7icUlgb5FX1wPhnJVts4/ci21J6QOT3giGxhTjY87fBF+dLjaCMEHJ3GmISpbjriqkS7awz+GSVvFAUhS5ZqazckcuMFbu5PqtmMEiMycDX957OE18sJDkuhsWb9/Pi9+JEnDSoHc9efgJtmieF90wC4dB6KdDsqpTrbT9WMk8bKs/iqJACwCBEeENRuEueG8DYJyAzTNnAQHZKoD6ltSkNf2dR5/qOGc6YECg4wH/76iLxQc7fvJuMXXmb4MNT4dzPxR6LFN0mw/6VkqXz401SC6r96MiP44/MfrDiA7m2zD4Qk8DFJ3Zj5fbDTFuyvQaxYNDr+PyuU7nzpS/pmRXHNcMzaqxlH/5pN4/+LCmoGUkmkpI20OKy0wG4ekyA+y09CHsXy7iRPUTItiOFxyXPpmCbZDYFCxAIF1XlvjVVZj8Z27SMCqddMhlsxZDYvK4UUiTk8LFMJEcRRRRRRBHFX4z/6eLNqqqi1+s588wzmTlzJtOnT69RI6J79+6ce+65zJ49G5vNhtX6LzMgqnWwa2UsBILTDic+BN9dJTrRn50NF/0IcekNOvWY0aOgdxZ8ciYtyOfTm0dwxnNzuOuxFygoKuGpe2/h+6kv8sJbH/Pep18zpHcn3nnoep5651t+nLOU/95+KYP7XSGyQ6X72f/jI+gVcKtwZt8mrNtfweZDsqB49dz2fNmgqwwTrkqJCj+4Wv7ftJs4ZcKRSPG4pfhsZQmkdYCBV4d/3qI98MO14jgG6DhB9PS1orQaYZSc5YvgiuqBNhxGKygGIRXUWnJITlvwjB+n3UfCaRGQkUBRoO2Ihu13/K2w7B3RtN67SGoZZB8fUus3PTGGfq2TWbS9kD+35IdFLOw+XMqbM9bx+ox1lFSIhNmEfq145eog120r9JEK5gTod5mQC/Vh889SuBIFJjwPzSNwyhZ79ZtS2opDzVYUfkFUo1UcRMX7pa4CePWsAxSi/V92grrsbFm3CltZOavXb2GYv5JObWeRy46tOJ8Kp0qTJk3Iy8vDbDZjw4DFKI6PnJ1bOZBXxJ9/zkOv11FycCetWrXixOGDyAFGqAuFVEhpW53xsnPnTmbMnMWq1atJiE8gLVZHs5RYLlSMGEr2sXPZLFypHdiTc4DdOfvYvXc/u/buY/e+g+zem0OMOYbJp5zEeWdMolePrgEDCh6+5za+/+VXmnl+o1OanaXXp/N5cW9mLFzLTU99AEByrJEHTuvMdaPaYDTogFZCwhwNAtfjkr6xZ6H8v1kPGHp7+DrwICT9nCfl/eAbxWHVGEjIgP0IsWcvEJ35pMyaEkjOStDpJCMsEAluL/VFFkdRv2O1Il+epTXZ9zxNFiEMVDfYVJHzMVmgqkIKC/e/BuKawdI3hIjucY7okQeCooPT3oYfb4DD6+GbK8TZHY501oCrJOJ5y3TY+Yf87kk1g1QuPbErK3fk8sIPK7lgdE8SY2sGh5iMeh64YCif/rGBm9/4DYAPbxvPhSO71n/+YFBV2DFbsgpRRW5m2JQjl3jZMVvafEobKYbeUPz5tPzmWQOgqd+8V5vsDgeBHPdam7KXgCXx6BR1Dhf1HTMcMsN/G4ct9BjisNWdx40WuPBb+Og0yXb7+HQ4++PI6kBpGON1cq/6CJa+JefregT1a2LToFk3qV2TtxmyBjCyp/ShxZsP8MJ3yygqr6TS4eaEni0Z1SubNy6sSxKoqsrHiw9X//9AsYPDFSV4RaAY0L4J4JeRWrJf5MFUVeRah99x5AFJHg8sek0Cs/QmOO3N8OuJBcPvD4kUUkILGHS9nMOa6Pt9bcVgMASusRBFFFFEEUUUUTQI/9PEguYwuPDCC5kxYwavvvoqVquVESNGVH/fpUsXPv74YyoqKv59xEK18e4VX61tpPsb20aLaPaf8wl8erY46T4/Fy74VqK6GgK9SVLuF73M5MzDPPvArdz20HM889pU9h08xMVnnsqtV1/E49dMZOP2HEZedj/L1m8D4OTrH2PRp0/SYfCNuGfdTytjIY+MNJPdqjXnDZAItz0FlZRVummXkcSXuQ18RvWhshQWvAgVebLY7jghqHZwQKz8UKI5DTEw9jF5JuFg4w/w24NQVSaG8cgHoO/FNbfRInPsxUIuRCM/jwxGK6S1BVuSL2NBQ3XthQAZP0aLT5Kk7NBfdbUCvREGXiMRpis/lEVoZQm0Gx2S+BraMY1F2wuZtyWfi4fWdPpoEjYAr89Yxx+rdvDTsl1oH/dsncazlw1lVM8gWv7lubD8PWm7lhTof1l4kZz7V8Lyd+X9sCmRR/0VeYmFhOZCKoAUb3a4wRRGn3DahVRwOaUwJtTVs9Ycpf+rqfEOG5269WTdho107FUr+r+Ws0h12LBXlLI35yAHS6qorKwkLy+PPr17kdK9PXhc5B3cTJXbjMVqobCgAMUcS1KTdIwxB0BVmaBKEdhN1oG8fsutzJg5k23bAtd/sky2cE43I9++cDtTfq0KeRv/fflN/vvym3Tq0I7zzjiVc884lXZtfJHVZpORQQMHsG5HHH3zv6FNrJ0L3fP5epsNg0HP9WeN5v6hBlLiao3nR4NUsBcL2aZl5HQ/E3qeF1mh0OIcmH67OJ07jheir7GgOaftRZL1WF3w3FozariisK7jT5OfMwQgSPyJ8mNQhuyooj7HakUBeBwyzlXriluFaHCUi5yf6pYsBnsx2PMBReTzDqyEfUth28zQ7SA2TbLpfrlTCILptwlx3u2M0O1c0cEJ94qkT+EO2P67jOWJvvniolFdeOSLJWw/WMxJ937JzMfOJt5aU0Jn7c5crnhhOgD/d87gIyMVPC5Y84WQ7wDZg2HwzZERc8GwRa6R7mc2vP8fWieZSAC9LqlZi6h21lww1A4sqT3faW3Kn9jTpISONXsxHDLDfxuHTcaQisKa96OtcRw26Q8VhWCKETvcaRfZogu+gS8ulH7x6VlwxlRodXxk16voRHIsJgEWvSpyc06v5FhD20SbE3zEQot+dGmZRnJcDEXlldzy1uzqzZ7+egmpCRbO6JXMzSe2oHNzv0zAAxXsLqjEbNCx56lB7Myzs6k8iS8Cna84B3KWAarYkyfcEzrrMxyoHqm5snehHOvUV2X9dCTY9acUWgcY/18Jfqste5TY3Le2bWimThRRRBFFFFFEUQP/k8SCf60EVVVp06YNb731Fueddx5PP/00u3fv5pJLLqGqqoqlS5eSkZGBxXLsFug8arAVyCLUFOdLA49Lh3O/kIJkuRvhy4vgvC/DL7paG11OFYmY0v3cOqoFSYkPc+XtD/LZd7/w2Xe/1Nk8KSGWjCYpbNyRw6jL7+fuKyazfYGe54bB3cebUZN915GdKlFulbWL1tWGs1IWZuYwIqb9UbwXDq6VBUlMIvS+MDIZo4NrYcmb8n7YlPD2rSqDXx8QySWQNN9xTwXW/TVaxGlgMNaM3PpfdXo2BoxWSAzw/IzW4Bk/Jis06SDvG5KxcKRQFOh8sjj0t/8m17Dxe+gwLqhDf1inVJ7+GaavOcyWg2V0bC5RXct3FnHJe+vIvFxIrCnvzcPtFCftiT2zuG58D04Z0Dqw/JGqilTL5p8kyycuHfpdGp6Oe/FeKWatesRxNeCqyJ+DVoQxrrnXueYCo1mKIdYm2wIWj/T+tnEhIkNrEw3/FBxBNlONiH6TlWHDRjDsxPH1HkcxWbHEJpBbuAX0ZtatW0fz5s3Zu3cvA3r3YNG835m/eAWJac3o2KEDyXFm1q9ejs3uJsYaRwd20p7dVLpUjr/pTQrtMtAbDAaGDB7M0OOHUFVVRf6BPRQUFbO6KodzOMS53c08vNBAVovmtMrKpHXLFrRq2YJWrVvTqmULcvYd4NOvf2DajN/YvHU79z/+LPc//iwXnj2ZV//7KDc/8AafTF+Aw+kCoH2Kjh/PtdApTc+iK+IpaDuZjN6jpfD60Ub+Nlj9mTipDBbocVbYhdqrUVUu8jeVJVKL4sQHGpcAifdGn1aVQmprKRpstNQMXIhNDZypoDkEXU6IDyHn0lh9zmmrf5tjAfU5VmNTfRkL/rCmSDvRYLKAmgQWr6a5JUnmhX1LpWhxfQST0QoTX5AMhzWfwbz/StDJkFtCE1s6PbQZLrZT0W7Y9ht0GFMt3ZVgNTPz4dMZec9XLNq0n7Me/55fHj2bgwXlvPD9MpZsPsDcdUKkje3bmocuHAp4gp8vFKrKJauvYDugiMxmmxGNQyqU7JNaQIruyCRj/nhcXjtNhLbDfLKkELoQrT/qCyyp3aYq8v9ZgSih5jCT1UdQ1pB/8pIyCuB0yvda7SXteVqS4cz3pf5IzmIhGU57XfpJJFAUGH6njwje8J1km/S/PDzJ1Npo0V/WZo5yKM5Bl5zNS9eeyKd/bCTBaiI5Lgan28O0JdvJLbbx5p92vlyey9wpveneQtY6Xy6XiKtRnZNommCiaYKJ3olt+GJzrXMV7fHVLEhqCS36NgKpoErW6q65cv8nvxR+TbpgqCqXehYg67H2QY7nTzTYi2sW8f6ntPcooogiiiiiOMbwP0MsHDx4kKKiIrp06VLDEaIoCh6Ph+7du/PFF19w77338thjj3HvvffSrl071q5dy+zZs4mLi9Dp/HfBUXHkcjfagl+T0lHxGuBuccInZ8OZU+Gzc2UBOuteGP9Mw85ltED3s2DZ27DqQy475wNaZjbj3c++Y8XajWzbuad607FDevPuIzdg0OsZcsFd7Mg5xPWPvgVAp4QEruoFSvFeOWY4RIejQhyd+VvEYWlOkEicxBahi156XBIppEWIpnWU2giRODc8LpFAUt3Qfow4fuvD/pXw862yWFV0cNz1cPwtwVN5tSwTtyN4lFoURxdaXzJ7s3rKD0tba8hC8kiR1FKcG9tmiJNvw3cSHZbcqs4icVjHNJolmjlYXEnP//udh07vjF5RuOerDXh0JjSBjIkDWtM9M54LRnSiY4sQWQeVpUJm5G3xXUvvC8MjuSpLYPaj4jhI7yKyApE6PjUdd4C0drIAVd2AKovzQNladTSZ/6GkQThorGymSMYYgwVrWhade3rYt28fx/XpQUVxHklxMSxbvY7Zi1YTo9eh2gpoldGLsuI8hg0ZjMMDhwrL6OeSbIWvN3mIa5LFmePGMm7sGEaecAIJCX5klUYouR3w7hgy48spXfheXUkLr6OhX++enHbySZSWlvH9zzP59Ovv+fWPeXz0xTfMnD2X3Lx8QLIW2rZIp13LZnxUnsqtmQdJrdpDxu6vwWwTx8nRyFBQPSJpc3A17JoPqCId0fuCyHXgPW6YeTcU7pS6QBNfkOy5xkSCdy4t3S/PWJuvtPoKoTJ8tM/jQ0RYNyZR7rA33rGOBsIlAGPThESos69dyAT/ffXmmtu2GQGzH4Y9C2ScrC/gQqeHEfcIKTDvv0KolR+GEx8BY4i2pOgk6nrH72JLbftVbCGvDEqvNum8ft2JnPP0z6zZmYvb7WH0PZ+xYU9+9SG6ZqfxyZ2nCJHtbgCxUFkiRXUr8qTd97tUyLXGgpat0GJAw4v27lnglYwyiLyZ2wmqU+zXYPNRIHmkSPvLPy0QJdQcZrRCcou696ORMuZ4sBJczrKqHIbfDQueE0f4d9fAVXMiCyTS0HWS/CZL34Zts+Scg66L3FGvN0odra2/SNZCcjYXjOzKBbUyd1xuD3PW7uX2135mzb5yRj67mt9v60WxzcUTv8ga5pz+TQOdQeawgh2yTgK538w+Rz6vqaoElG3/FVDguOug40lHdkzwk0DKhBP+TyQ3a2crOO0iwanilYPztnNjTFRyL4oooogiiiiOAP8TxML+/fvp2bMnw4YN45577qFfv341vtfpdHg8Hrp06cJbb73F7t27+eWXX2jRogVDhw6lXbt2R34RqgpqPaHz4RproY7TIAdRrfNqUTxG7wJUM74ddohNlgVYWgcp+PfdVZLWm9kX+l7i3b+izhkCQlvM9r8C1nwqzo1Dazlx3AROHCdFmmf9Ppdxk8+nQ6sMvnv5HiwxQhis+vYF3vn6V176eBoxZhMnXHkXbH9LnEj2YtGI1iLOXAr87j1n97MhMQ02fCsFcd0O7yPQibM1d6P86QyQ2k4Wmc26iVanooiUzeLXxUmCIhkXncaH5yg2+REAB9fIMczxMOaxmuSApZZh63HBn/+VRbvqET3icU9DRk9xjgZakDhtvhoAOguU58vPbE399zpHNdTXzyJFOP2yhhyBte7npjhAkfeVpeL4aSyEE/EP0FUK6dL9DHHUH14nTh29UYo6Z/aVv9bDiFcUFn9zGlc98DKzFqziri82VB/m9NHHUe59//kL9xETahZRVSnIt/QtcXboDELCdT29bkRraoBx1uWAby4TR1ViFkx+J3zpNf8+eWCVyB7FJEmx59KDcj1GS+DfItwo0H8qFKVmu/Z3ImmfN2Y/0hyiNZw2cvxW2S2pqrTjKDpAhepm3uxZuEyJFBYW0CzRROvMziTGmWme2Yu0GNixN4f0mCpGlEk9gYHXvsruYWfUzJzwOH3v/TXS24+RsX/nHxIx7Q9/OQQgITaGi846lYvOOpUnnn+Nex79L7l5+WQ2b8ZHbzzHsMED0Ov92rDHLbJ4Kz8Qh2JmPxh4bWjnKoQ3HleVQ/5mqYOQsxQqi33fdTgJBt/gI9Njkuo/Hsg8M+cJkY7Qm0XWpkmnutuFm42oBnHsahkLpQe8bcr7OxktkhWpZTBAXWdoKKJK+y5cuymc7UxHob83Zj+qbd+FIhpq2yROr/yRs7JmPRtdrediSZXgipJ9sPtP6HyKfF5fOxh4tRDG02+XNjXtBpE2CUZ2adkQfS+GX+6SaPAt00W7vdtkaHkcOxeK9N3gfj34cqOLDXvySUqI5dkpl9GvWzu6tG2JweDtg7bC0NcH4PK/z2T47RkhFeLSYeT9cv0awtVeDzZHqB7YOlPedzk1/IxY7XdzO0UmavbD8v++F0Pz7hJ57yiTej+JGT4bQ1V9Y43WTlS1/r4UrA0F2z6cfnQ0CNX6UB8REkz+yX/7QPsaLZLd6HHCcf+RPrR7PvzxmNRc0FB2uO6+gdBykPw16wE//Qd2z5NzTHqtJqmbs6T+Y7UfLcRC0R6wpgVsYwbgxJFtmNO3H6Nvfpnlm/cy8oWN6HU6XG6Vs0f15YLLL/X9Zum9YXMhndRtmPI2QN5G+bzTyUKARBoU02JAzf+rqqxltngz0sc9IcFl4Y6Twc7vL4E0/B6ZVwxG73jnN8c6K8X2A3BaIa6Jt13kS/ZqFFFEEUUUUUTRIPxPEAtbt26lpKSEkpISXn75ZW6++Wb69JHChB6PB7fbjdEoTui0tDTS0tLqkA//GEQaZVTD4aMtQPyieLTPnHZJE9VgtELLgdD/Slj2FvxyB6R3ri6gGRFiEkQTetnbIg3U5oRqI3fMqOGs/f4lmqUlV5MKAPGxVm65+FRuufhUn7RV/IUw/zkoOyDR2D3OqnGaWLUCw/ZfYO98kWIBcaT0Ol8K6x1aJw7IA6ugIleigPI2w/pvxJnZpKPIF7kq5dkMuEruuSHQtHyzjgu9gHVUwGfnSNQaSPr1aW+Ig9ZpD+50qdb890Yplu4DfYxs/28nFv4O1C6ErkFznqmIA7siT5zkjUksRIqYRBj7uBQS3DEbbPmiH3xgpfRBSwo060528x7MeGUKH/yylFuefJsqh4sX776SC04by6TvwziPvRhWfyoEBghxMOQ/vkLW9UFV4bcHYP8KcYRNei28WgyBsN3LLGYPkesC6Qe1pUI0hJud8G8piH60szEq8n2yet65SVVVGUuddnJ2bsVW5WbFqjXoY+LYvXsX/fv3JzXRSv+BA6hy60hLTEVV7SRaDQx0ryAGB7vIIuu40wIWWA6IThOEWNj8M/Q8J7AjPQBuu/4KNm7ZjqIoPPvo/9EkLYCzVKeHobdKO5/9sNTO+f1BKaAelx7mg/JCVaFol2SpHVghmT7+jnujBTL6QLtRDdekXv8tLH5N3o9/Bpr3athx6oNWiLPskBDclkRfe/MnZCE8rfijiWN9bqxt30USSBKubahTREN+zefi/NOIhXDQ8SSRU/rxRrGnPj8fJr0OKa2D76M3iXPxj8dEqm/vIvlLyCAtRyU5Bob07sxDr30OwO2XnMZlkyOsr1MLZrUK05ynRLbJkgyjH214RkEw5CyD8kNi37UZEf5+hzfIs1/3ldgLIHP20NvlvdEitTO04rOBSPBIiPFjofaW0wYVjiObRxs7I9dfqk0jcGLi4fjbYM8imUN2zq1LUIeLrpNkPvz+aslc+PpyCZyIJJghOVsCLkpyxH4LMRckxVv59cUbGfOfV1i2STLBe7bP5N17zq+ZxV9+iLs9bzBCXQx5CKHY8zzocXbjZCosfBGWvC7/H/WgkApHiqoymHazvO80QdZlzkr502w8bS0E8txVahLJ//ZgkiiiiCKKKKI4yvifIBZ69uzJ+PHjmTBhAm+++SbPPfccd999N127SsqoRipMnTqVE088kaysIEVH/wkIx7j2d4ZpiwptMR8ohRp8Ra6q9catYLRJYdiC7bBzNnx1MVz5R80I0XDR92IpLntorUg8+MlUdGsf2hFZbRTHJEKvCyQ6et9SMbqzBoKrirM9P3Cm+hOGnd5IlZQ2Qihk+KX1tjxO/lRVyInd82SRl7dFUuZzlsp2aR2EVLAkRX6fGvZItC3Zg4Nv43GLruueBWII97sc2o4KL2XaaPVGgyLGtSEGdLqo0RwKkTiJAxVC1J6twyYyH1qGiNEqfSy2iY9YaEy5hYZAb5SI0b6XQslecd7vXyHOIHuhpPvvmouCwiUpbTj3lQk4YjOJb9GJSvyijgNBVSXabt2XMpaEylIIhWXviHySooOJzwfOaAgX23+T12bdofQQxKV5dZTr+Z2DjYfV3x8DTpl/AtRar3jHba9juVXTRPYeqKJH74HklpTRpmNX4mJjycpqiTU1C2w2cvbuJdWqkOouJd4jklrTlZFcHomzI3sQpLaXLJpPzhaHZqfx9e5mMpn46I3ntAsPvXGXU0Qy4scbxeHz2/1SCDYUCe12QOFuua6CbUJg22tFYCdlQ9YA+Wva7cg04A+vl2AAEEk9LZvpaCCuqWjCq24o2CrXXjuIoXbGQhSBUdu+C0UW1LbztOLY9Y1T1lTR8l/zuTg8Pa7IZFoy+8LZn4hcTEkOfHE+nPKyfB4MBjOMfljsqg3fwqafofQAV7aB82+NZ2Hhb8TYDpKSGM+NF0wM/1oCQK+6uNfzArr8zdIOT3yo8UkFgM3eOlgdxtWf7WErkACWNZ/LHKzBmioO3X6X+shJk5+j22iR/2sOUofdr25JmJIuJqsQvy4HmP6meay8AEypR38erWG3+dlrGrEJvqw6f9IzNtU3VpnipOjy6o9FRu7qPxteb6D9iXDWh/DVJWJzfXmR1HOIhOBs0V/6Wc4ykUYKMT8lxVuZ9cINnHXvu+w+VMh3T1xFrMXbNp2VsPMPTHsXMUJ14kHB03Y0hn4XN04gTGWJFHrfPkv+P+Ie6HPRkR8X/CSQMmDgdfK7uSqFfLMVSf9w2EF1gWKQjCwN/jae/33WZ/tFEUUUUUQRRRQ18K8nFtxuN263m82bN/Paa6/RpEkTnnjiCV588UU2bNhA8+bN+frrr5k3bx5PPPEEs2fP5v33368pcfBvQ42ih1afBERFvrdYoikw0WBNE8Pcll9zgXvaG6gfnYqSuwm+vBjO+zzyYs7WVF806apP6upfh4u09rKQ2/qLZC3YizDvXcxlqoi3eGKbout3iWQKBDPAFUU0OtudKH9up5AnuZskuq31sMgcpLXhtElWBEhKdCCoqixatv4iMhWnvwMxKWCJ8y0eneVgjIOkQOnbXuLH45b/x6aEcI5W+CR8/m0GdCRkQSRO4mCSFCAOHGe5yBL4S4nFNxeZrXBT5v8KKIo4LJOyxfHvqpJo0UNrxcFRkgOFOzAX7sAMsBbMejPPu7PYqWSj39NUtIsTMmXcqJ2lkJTtLUweZpaChhXvS/YRyAK01fENv8fyw3I/AMltANXnCLAVho7Wr/ArYB9om3+aDvXRQDh9LC4NHNa6TmNv32jXtg3tOnSS38Wa4stCA3Da2XZgO063jqIqD6nkE1N5mErM/KYM5fJIrlVngHM+kVo1u+eLFMXhDZJp0Jho3kMcpfOfl8yDOU9An4slw8DjERm8wp3yV7RLIqc9rprH0JvlOJl9hQBPbdM411aeCz/fDu4qmd+G39E4xw0GnV7IhbIDkLcD4jKkvcSm1u17/0tZQo2BUIEk/nNURSG4K73kQj1OQqMV2o8VSS17oQRUhAqACISU1nDup/D9dUJifXsVnDFV2nMoJLaAwTdJJuy2WWz94Vk6JLk4sWkRq6+JY787lYTCNWDpD/oGLF9UD7erbzCANah6E8rI+xumk18fqspgxx/yvlOQ+lma1FE1geOVb9MZJSCmy2lSSFpv9EmRagSCP5kAfjah3bd9uLJeWhv6OwlyBRmbG3MeDTRO1LDb/MjMqjIoyxP7WjFAYmZd0lOTTTJaJPNyy8+yJljxvsi5NhTZQ4SI+/Iisb0+P1/IhnDRvCdsniZZ1sV767W1kuKtzHrxRt8c63FLINb238FZgQKsoitv6c7n+cF9MBgbQdbq4BqYdqPIq+mMMPJeqbHVGNj1p/wGIBkQ1jRAFXu0PF9sD5u3poICWGtliNeQMY2t//MooogiiiiiiCIg/vXEgk6no0mTJvTv35/169dz2mmnYTabufjii6mqquLKK68EYOjQodx+++2MHj36300qQE1nmLaoqMgXI0oz8P2Nbs240hyomsSONc1nsJ/1MbwzEvYvg5n3wPj/Rp422/t8IRa2zYS9Z4rUUkPQ9gQo3i1G//bfUIADpPORcgY3D25NTLP2kR1Pb5Ro04bKHtXGll9kEZmQIY7XQNjwrURso4j0UYcxNYsvurwRVvU9Yq0YWShngvYbO2z/PgP6aEhFBNpWO4+9VHRdXQZxRmvRbyarL0oqf8uR3dPu+dBu9NHRMTZ4nZmaA8hWKE75wh2i41ucg+Kuogvb6aJuBy24UtFJ1GdFgTgsdQYhCtuNjpxUWP8NzH1K3ve/UsaFhsJWCL8+IO+TsqVwsyVJ6rvYCutfOCq1XmsjWhC9/j4WsL6CF1phRWctJ45XIklz7qTGmSguyCchLRtlmeiuz1f6Y1Ma8OwtSXD62zDvOZH+Wva2OD5G3V8zkvFIYU0V3fZlb4nDaMV7ksXjcQqBVxvmRGmfqe2gSWdo2kVkYhoTRbslU8GWL5l3J7989AvJV5b4iHiPQ6JGHeUNJ7L/TVlC4ZAkobYJ9V3tOUrLWAgHOoPUI1n3pQQ3REosgLT/M9+HaTdJhuYP18G5X4jTtj4YLdDlVNIzRnD7bVfQL2Y3Z3QxkqkvgEWvyvdpHUSeMq1TaKklEBmxwxswbZ/NSHUHLvR4ht6FqbFsutpY/amMYcmtA2cnluyDT86UgBUNzXtKbYm0LjJGmRNEfrTCf54KQBY47FByAHBBZblkpyY095EN5tjwbJ/yfFAcNTOT/yrEpja+PGSgcSKQjWe0iC1giQN7OcQ38WUpBLIFTVZIawsj7pax9I/HJYPhSJA1AM79DL64QCT0vr8WhtwU3r7GGKnXsH8FrP8a2oyUunD1ZLQpiiJBF2s+F8kugNgmOAbcwF1z2zWOfelxi9zeghdl3kvMkuylZvUQjOHi4Fr44Xp53+McaNZT5KrcTvnNU7wkgtMudrkSIEtVI5BA1sFaAFZUGimKKKKIIoooIsK/nljQoh71ej1z5sxh7NixfPvtt7jdbrKyspg3bx4dOnRg8ODBXHXVVX/z1f5FCOQMC1RXwf9zzbjSyAX//Z02lJgEmPAcfHslrP1CnHjhGsYa0rtA6+GSEvztFTDyvjp1EsKCohNDf/Eb4LLjbD2KKzafglsxcLNyMPLjNSZ2zoHfHpT3nU8Jbrzbi+S1eQ8p/Ac1fzcrVBfXDgSnDSqKxJgOBi1TARo/WuxYQSRkQSRO4kCSFBX54LYL6ZOYKQtTf7Q6XorLrXhfotTaR6ATbbBINk7+Nvj5NuknI+5qXEdoIFhTRB9a04j2eKgqOcSzs/bQhj2cmbYdfek+KXxeekC2ScqWFHdNWz0SVJZKoXKQYqCDb27YdXtcsPIjiRTXCt12P9v3vLRCnxqJGiztXSs8qiJ9Chrm5Ps3o74+VkNuz7dNjboItYpoKjUIbQup8fGkJqeAOR7V268GqivJUvc37Jp1ehg+RZx+M++RiM1Pz5T21uOsxnO2G0wiNZSYJU5ah7fsuSFGnI6pbWTeS20HselHt+jp5p9h7pPyTK2pUqw53IKyDcWBVfDNlZL5pDdBRk85p0rDHTb/piyhcEiSUNuE+s5/jjJaAztunTZvEfsAY1aHsdJmd8yG0Y807P6MFpj4gki95G6UqOWzPwn7t09KSuSpJx9n0eotuNqmYtg3X66nskTIwINrZEO9Uead1HaQ0layEAxmkffZt1TsropcdIATPc8o13JrRghppoaiqkxIhaVvyv97nVe3T5fsg49OE5IvJhl6nCmynE27CIlQul9ezfHyCjWDfWrDaRfJl/JiyeJQXSL/YvRmL4RDwBm94+/fRdgdjfMFJBH8sxf8s7G9gQYJzWrKJIVCv0th4csytu2cG1rqKxxk9Bbi7f3xsgbqeU74tXlaD5UM0/JcWPs5rEXajCFG+oHBLBlwhhiZkwwxMsftWy4Of6NVstdaDMDTrB8oYRRCrw8lOWLL5W2W/7cfC+OeaphUbiCs/hSmT5FAlqRsGH6nz3Yzx1GjQH1FgfSJQDW1tKw5LbhOCzQ52nWnoogiiiiiiOJfhn89saCle44cOZKdO3dy3XXXMX36dFasWMHq1auZMmUKJpOJPn36YDabwy8C+W+DvxFV28mmfa6qgRegFQUi/ZLSHobdCXOfgD+fhqSsyLWbJ74As+6VNOPfHhCpiLajpD5AJDBa4fhbQFFwuxTcW46Bpr5ngUTveZzQcTwMujH4th1Pkmiog2vEYVvbSWu0AorP2VmL6KF4P+CSGgtxIRakmn5ybNrRdWr9XfirIsq182iOw0DoNlnawIr3xcFy/teiNx4OFAXO/hiWvi3775oLexfDwKtkwdbYkc3BoNOhxmcwV5fBXAYxaWCJKFLYCoT0MFolWq6hjtklbwoRkNIWBt3QsDa5ewH8ej/kbZL/N+kMJ9wjRRaNVl+mgld2B52h7qJSg3+BWU3qyuPyRrZZa5II/6ZI6khQXx8LVtg85DH9CG2TFZIyff8f9QDufSuI37+chz3PgG0MmMJ0wNRGp/HSXmd4yYW5T0o9jhMfbDzSTlGEHE5tJ4RxSmuIa+6b046288Jhk/l480/y/8x+4igOli3XGFBVWP6e9EMtUnXyu5DRS6JJ/TXNI8WxlCXktAFH4CgLhyQJtU04+9cmPGvXXqgqlyCEpEzf904btBgg++dulMjmhso/mmLhlJfg07OlXtWv98FJz4S9u16v5/i+XeQ/SZNFIqhkrzgs87bIX1WpRP9rGQCKTtpcRT44vXW1DBZcWYO5ZM8k8pVUGk38zOOCvUtEjmbnXHF0gsjjdD295rb+pEJyK7jwewlCcNp9JIIxDtKSwOUCR5m8JmYElj4CCWRQDDKuuOxgK/YWdvYWr42k1sK/hbCD0OOE0wYl+2tG9cckeG3h1MD71IbOILKry94WKasjJRZA5qKsAWLb7VsmWZ/hIL65ONZzFsu+VWVeW6Q8tE0KMi91P0uIrMaA6oEN38OKqVI7yBwvmXtdT2+cNYarEmbcDas+kv9nD4GxT8p602mTNh8IljDuT8vw9oe/VOyxMu9EEUUUUUQRxTGIY8DbenShEQWtW7fm0ksvpWnTpvz000+0bt2a1q1boygKPXv2JCYm5m++0mMIkWpLaraiIUYWfcV7YM2nElkd31wKIocLYwyMf0YiORe+LBHeB1fDoOsjN+qOJUd53ha5H7dD5GHGPRV6oZ6QKTq7OUtg0zToc6FPBkl7Dv6yVJpDoKIAKou8CyaDOAuC/Yb/S6m+jR1NHuh4Ros4BRQCP1OnHfpeBQfXwYEV8PXlcNEP4ReONFphyM3Q+WSY/Zg4Qhe+DOu/Eyd8Zp8jv6+GwpoKLcNckAdD8V7fYnH4HZEXRCzZB78/7HOgWpJFrqDPRTWPZYyRxacxRn5Hl0M+DxYVWl200Y9AcDmCyyyAOLSiC1FBtYNHrfudVjiztkxSrQyGGv9XVRynvE3R62PJIBfPd5fDhV/J/NMQJLWEsz+E5e/DghdEiuJoZC/81QXb3S7YMh2WvytR0IpOpMX6XXZkNYLqg8ctwQHLRbKKtqPE8ZOSLb916WFfJt0/PSLUcQQECYRHkoTaJtB3teem2oRn7RpbFYXye/jbER63jI9Nu0mNhF1zoe3Iht9nfHOY8Dx8c5lIQTbpDN3PaNixdDpxyie3EseuqkLZQZGCKdghf5VFYocCWLxZdy2Pw0UM+XuPcJ7SULBdHMo7ZguxriGljWTM1nak+pMKSS19pAJ4C8u6pci5VpjZhERZGwx1ZZCcdiEdNA15U7zPIWpJke9dhYDbW88kjPs5lgi7hiDSelp6o1cy5wgKx3cY4yUWfoXhdzXOmqP9OCEHcpaGTyyAROm3O1H6qatS5PaqX6u8baKq5nfxzaR+T2PNcaUHYf6zvgLkmX3h5Jek/zcGSvbDtBu8mUoKHHedEHgaGeSs9K5dK30ZC06bEG4qEFu7voKXiNB+d0sAktg/sOSf3D+iiCKKKKKI4ijjX08saBg0aBDvvPMO/fr1o0ePHtWZDJMmTfq7L+3YgH+WQiQOZ6cNVFAxyELUZIERd6HYCqRWwjeXw0U/Qmrb8K9F8RqMya0lMuXgGnEYDr0NYps0/B7/LhTsgIUviTHfejhMeLZe/VNAolxzlojmfMcJksLssNeUN/CXpdIKa9tLITYZUrOjhrCGxo4mD1S8OZQuL8j3tkMi8fPHo+JI/+YyOO/ryKIEU9rA5HfEafjnM1C6D2beJW1r4DU++Z5/GuY9K9HN2UOg1dDw93PaYNFrouXrqpRFcrczpEBgQoZ8X1mKr5i2n+PBVigRdlrWjqOips4u1E2JN1rBZKsb3Vm7Xs2/cSHaWARdRYEvQteSUEcmSVUDkBBerFq9mu3rVzJLN4XnPQ8Qf2A5TPsPTHqt4Q4SRSfSE9lD4PcHxUl5NLIX/gq4XUKurZgqhAKIzNKYRxonqjYUnDb47hrYOgNQYMBVon0dkyBOUpdX69rlBDN1+1owSbJjFeEWyP0rUXtuqh2JXrvGVlJmTTvC365oO1KIhZ1zjoxYAGjRF0bcA7O9Rc0TW0QWdBIMiiLjvCFG+i/IuF64Q9pRk84+Is0V/DBhwVYgRW63zZRsWg0xSZJl2mmCnK+2g7nsoGjB185U0GCy+AJHtD+HXeSMAgUqGC3Sn2LiJKMh1lLzWFodLkd5/XW4/i2ItJ4W1CS0I7HBNEI8o4+cq+yAZNA0Rs2ODmNkDsrdKJkHkWYSKLrAJJHHc+TXFgwet8w5y98TG8wQI2N/x/GNRyrs+hN++o9ktFpSYNQDIieq86uboAWNgBB5WsFmfZD6Chqh51fPKWBfq2WfBIS/bfRPmLuiiCKKKKKIopFxlKv2HTswGo1ccskl9OghRaP+cskjTbLmrzhPRX7k56udpRCbFp5x5LSJwxt8r5ZkOPUVPM16ihbulxfJNUWKjifB2R/Joq1knxRhzdsa+XH+ThTthvkvCKnQcpBE74QrW9P5ZHndvxwqDkuUtMvukyrQfmPtvdEqxrMlQbR761tc+f/m/3aYrI1fR8Je6nvvryMfDEYLGKxS9Hz0Y0IAHN4AP90sC7NIoCjixLh4mhBQik6iSr+5XAp/R3q8vxuH1kv0p6KTbIVwx+fyw/DuGJj/nCxoswYKUTPuCZ98mH8UW20YY4IXq68N/7FV0ywP1MeORls7VuDvvKkPweYihw3yd0BVifxmQTJFFi1azLvvvsuiRYtrfL5z83qqbMXkKJk8orsFVWeAjT/A3KeP5M4ESVlS2Hn4XeIc0bIX1nwuBNSxDLdTnDsfnybEZel+ccAMvhku+ObokwoVefDR6UIq6M1w0tOSLWTx6lp7XOLoMceLM1v7zL+v+fc/rf1of3+VDRUJ/mriMBz7rvb4419fQbPDAo1dWmACyBxltEKbE+T/O+dIZsCRosdZQvqiij1Xsu/IjxkI1hRo0V8yLhojO+fwBpj1f/DpWbDkdSEVdEZoPQwmPg+XzYRhU6ReSiBS4durg5MKteGwi5RlwQ6pl2Cw1CWwTBbJbLA2qSuTpMGSIt83dlHkYxWRzrtahm+guczh950jwHbaOKWqPjJr19wjvweQbJb0LjLf7F/ROMc8WlBV2LsIvrvaF9jRrDtMekPs08ZYZ6seycz9+lIhFdK7Sp2W5r0kY0eDvwxS2UHI3ynjmdMO9jLfNsX7ZNxx2qTfaPZHsHWv9nk4WTDh2kZRRBFFFFFE8S/E/0zGAoAuUp3+xoTD/tdI8zQ0MjscfdVA12+K9aZap/iOozeDKZaicW+Q+M2ZGIr3SPG+cz6pGb2ihLHgazUULvlJFma5GySKdOzjgWs3+EeQ+cOpAl4DtFl3SGtZ/3lBjORwYDAH/jxvi8hBuezi1Dnzg/AWPR6nvMali87xvqWSat31dCnOV+WnmWovlQhQTSM5ra0v6qa+5na0NXXDcUQ0hrOiNoK109oLhnDPHSyK1j9tukZUk9/5tSgmDWnt5LwuO5zyMnx1qTjU5z4JYx6r6QTRiLpQiE2TuiT9rxT5kYOrYckbsO4rXxHL5GzRU09sAcktaxa1CwRbYujvnR7AKzOR0QuMRziuqh6RPAMpdpnZL/T2muSNvRg+P1/6fXxzGRdaDgE8Ep2njS+mWD/irdaYo/1fUXwEnQrEBUiJD3ds9Y8W/CcXdA7Yj/zGDO37YP2ozvPybu+0S6StvVR0wYM4vtatX0dZaRnr1q9jUL+eEi2sQscWaWzcIX1qjdIV14lPYJw5BRa8CKntpQ35I8jwXAc6vyyygVf76tzkLJH+uXMOnPRU+I665j3DPG+Yjk9dkCw3V5VktS15QyJnQTL7Bl0vjv1g7c4Tbvh2GONk/nb47ByRn7GkwDmfQvMeNecXh02KZ2rXoyh15x//9qW1H3sJWBID1zX5u6Eo9dt1kcxx9Y0X9Y1BNfa3AKovutppk6CG2vVOnHYhossPy6uil3nKFCu/oSFGHHWl+yGtQ/33EMwe0jDuCSjaJU7TmfdI7aBQQSz1zQcawrHXnB7AW0w2uXXoucscD3vmw8JXxHlafT19odvp0OlksCSFzuwt2SeZCqX7vPJHP/pIBS3LEXx1ERRFyHVHudfuqIS0hMC2sjkudPH1+r4/ltAY/SgSKSettggEjjDXiANbgfwG/hnGTrtXDrFSCKys42D7r1I/a8TdYZy7ov5t2p0oGQuHN4h0XSikhJkNHu56RrEC3mzChIzgfaQ4R7KPtL5hSRFyre8lNTMH3Y7wzhtoDLAXwffXyvMFyX4b+7jYjOW53uvVyRzqcsjn9lLvOKZKoJXBIra0onjrjnh/d6NVMozDzQipr/35z13hjPnHklRvFFFEEUUUUTQC/qeIhb8Vf1XKfEOdxQ3VV9X2U1Vef+lZViyez5DhI7ns6huwpGVRNvEdkr8/Vxyeb42A09+B1hHInIA4Dc/9HKbfLino02+H/K1SnPmvKlobKQp2wNeXScZGsx5w2psNc+B3OVmIhS2/QIexYHdBvMEXaR2bAiUHJLKtogCSs8I/zz9dU/evQrCaI/6F3gIRF+BdwJZBWS7Ep8siJjZVnAqZ/UUW68cbYOlbsG+5ZLQ07RL5NTbtKlHJa7+QyG1bgfztW1p3W2uaEAxJ2UJcdZ10dDXX68OWGSIjYIqDoVPC28dpE0dm7kaRebnkZyFRnDafpISG+oo4etw+8kdvqpla74+GjK3/toLOwdo51HWKBnteJivENRVSIcQz6da1G+s3rKdb127S97yOoG7dutG+e1/ee0WiOd29L8ZYcVCyVqbdLM60zqcc+b0mtRQH+aqPYO5TUhhz6kky7/Q8p/F0qRsKVxX/z955xzlS1///NWm7SbbvXi8c7Y6l39F7k96kSD1FUER+WBH9flEUOypY+Co2VBAPRKmKKF167+UOjjs49jqX7ZvJbtr8/njPZ+eTyUwySSZt834+HnnsJplM/bw/5V3xxt+B538HjG6iz8LTgf0/Dyw+t3Ltre9ZikqMDZIMnvEXw4FANsKYz0fIpfDCF+1G3i6uGvmzreqaTDWc9BexYfsCs2MRyr0faKW5ACB5VyM7OkgYHTQA3mYg3k+GBDHWaRrV7vngaeD9J5wZFvLhawJO+S1ww3FUp+D+bwAn/Kz68iTQ0mREfPFPNG8FyKi382nAPp+hYrdOkGsqtM4GTvkDGdYEwqAzPkpGBZHSSPHQWJiK03gUHShvarB6Nn4XSyBE44Sm/283diXjmbUYhCwlxym9GwAsOJD+rn+JUnCFHBbLzsV2R1H61A+err06aEN9ZMR/9356L9Ie7fd54564wcbXgdvOI2O1rxk47hpyGhAGafH8xL0RzyfcBSSaaZ4b7tZTkOrPJV8dtFLg9RTDMAzT4LBhoVJUKudiFSc3Lz37JNSxEbz24rPARZ9DKBRCaPu9oZ1/PxK3nI3A0GpK03DYFcABXyhs54EQcPKvSHn07G9IEbvmKSr0PG1R8Set9pPSaGQ9GQBmL6ZXKbUcBj+gsN3YAOVcPfX64p//DicCD3wL2PwGsP5lUgQL76nJgmVqY+XSrTR2uVeDbYZSzG7hL4pjNrdSXvFWKT2FP0QLpXQSePBbwIaXgesPBQ74EtUTKfR5Kh4qGrnjR8nwNvgBMLSG/g6uoVdsgMLD1Qi1p7fuIsXpR66kdl9pEjEKoQeA/b/gzBs8laAIqHXPA83tVBS0ZTp9Jysr1Uj+/tAfyi7MbGc4KKZvLXdUUC1hVora3S+H93H//ffH/vvvT28ShiJBC3dD0wyD8nMvvICDD70cGFkP5fW/UVH00//ojnFB8QBLzgO2PhS4738oeuG/P6AooyO/R6mTKkE6BQy8Tx6sm9/UX8sp8gkgQ83eFwG7nEHFXCvF8n8Ad18CpCYoQuPc2wEohRkA7JTp5nZiVddkquGkvwjmiChTTH8BSeHWmr3fRIzmE8JJIRDKVtZtdRApONc8Duz1qSIuyoKWGRRpd/sngdUP03xun8/m/52m0ZzN4zVSbLlFOklpvF74Axk8AFJo7nY2RTCJ1HpOkI0KbXOA435KUVoJuUaW/lxCHfQ+HKTvPF49/Uo3pUTy+bOdGtxAKNMzIlnqQLbcMIT4Q2Q4FpjrIomX6HPkWgyJmGE88AeBmTsDPYuAyDvAe4/oqb5KZHovGWdHN5LhdtvDSt9nqcQGged+B7x+qx7tpgC7nkmpK9typPYqhldvBu69jMaV9nlUU2zuXsb3gZC1w8LkZ5LhNREzDB5Wv2MYhmEYxhXYsMDY43QCn1ChxFXstddeePa5Z7HLkn0yPIeVnu0QuPgx4J+fJ0XmI98lpeDxP6dQcqcoHuCgyyj/6APfpNRIN50MHPBFYO8LC7++9S9TMbCoHlK7/iUqeAnQZHbmrqQsmbUbeanJXt0TY7R4HO4jb9GhPmB4Lf0d3QRAo7Qcp/2xNC+etlnA3p8Gnr+e0nGcdSt5wMv3LdStL4RqyKsJmDqecFZe2kIpILxo7Rb+/hDQOTfzPphzte9yOqV7ePBbtDB94hpgxT8pmmGuwzQQ5nMT7VYmnaC2M9RHxobIu2RU+HA5cMuZ5JF50GWVNVC9cjPlZm+d5UxppaUptcSqhyjE/cgfUoSHXNQcoPfxMUoRFtYVUFYKbX8o87kV2k7ztXE7r+ypiItGlKwaSLIMahoQN9L4vPP22zh4/32BE39JXvzL73bXuABQOjERvfDoj4F1L5CR/MBL3Y9eSKcoVYwwHmx+C/hwhWFEkGmdaRgU8qWgcRNNI4PgQ9+m99scBpx2PXmJJgo0ADhtN1PBI9Rpf2G3fb57JXKBm9NL2RpLJaO51TgXCAM7HAc8/mNKeZJKZKaFKYVZuwKHf5PGvWeuI+WsUKBOjlNrKOXK4BrdSL7GSCUTnkaFkqctIkVs59akLC40+i4ZB1b8A3jxj0bNh0ALsMd5wJ6fKrxGgWxU6FxA0ba+IADFeo4m1/cBjNQsgbAekbqOohfciFqQ25Mw6IlIlnpRuJYjCtBOrvRo7MlnYydLi44lw8Kqh9wxLCgKycKrt+iF06toWEiO0zzthT9QNBRAdSWO/B5Fyrp9rPv+F3j5Jv04BwJHXAG0zJLWlAUaB/xBiuZW4kA8mPlbEbFVasHlXP16QqVIMgXOajUwNUdfXx8iEUqnvGLFirIfTz5GT08P5s93mL6ZYRimyrBhoZEoVNHrdAKvb/fZiy7CZy/9Bin/ov2Unkco/Pwh4OgfAz29wJM/Jc+wzW8BJ1+X6YnihEXHURqZB75B3m5PXEP72+ciYNoO+X8/1EeK+uV30fV1bUteqVtWkLEhspKMBMNrgXfupd8EWug8/c1UaHZ4be5jzNiJCpi54VV3+DeB9x6j83rq58CxVxvfiYmxP1jcwlBuE257xE21NDAyQgnjl+ov2JFPIRaP0YLjqKvIsPDkNfSs/3wSpV05+CvuKS6bWqltigXh4qUkP2/eQa+V9wELj6Ec0l3buHNMOza8SopaANjvc0bthFw8fg3w5u2kCPnYjcCCA7JTHwH0Xh0EkAQi7wOtegSSUPKLmgultssC+8gpKQuCYu5n3pzy0czivv5g1naLdtD7fI8XOPFaus9v/4uMC8ddDex+doEXYoOIXpi3DylD171A0Quv/ZXSYYR6yJNV/A3qL6taKcIwPbIWGNmgG6XX0d+RDUadHRl/iIzqM3emorQzdiZlajXSmD3xU4r0A4DdPw4cf7Uhv4W2g6lgMHBKof2A0yggQcb3Wv75gRj341HryLt4lIy+oW6KFFh5H9B7YkGXnJOdTiGj2Wt/Be69lOZvoxvpWLYodG3RLfRa87jxVVMryef8/YGt9ifjgxoBRjcDY5vhHd6Ez6RXoAcDCNwRA6KbgbEtgJai3wc7aUzc9WygY27h15OIActOsynU7MneNp3SHRTGyRAeaMnO+e4NGNtZzdEKUVzK7Uko01va6kv+CjVgO1n35EyXKKfCtNlm4VHAU78gw8LG18loVirb6IaFdx8gudzheOrzK5CbP6Sp2AOvw//QLcAHT1BKV4Dk88BLDdlyk3SSHFzWPAFAoXoVu55Bz08BzfM0UfeigDVPIGT/DMXncbX49U9CBQbXUmQRkN2O4qphkGmksW6K0NfXh97eXqiqOvlZKBRCT4/7kaE9PT0IhUJYunRpxrFWrFjBxgWGYeoCNiw0EsUot+Q88nZYTfQDwWyFn6IAe3wc2uxdgX9fBmV4LXl2HfhlijrwFNAcW6ZR3YK37gQe+R55d/7zC+Q5tOcFlCLFxDxtPfxP/gl4/7/GQnLRceR5I08qJ8aATa8Ba58HNr4GbHqDFn3v/Tdzh8FOimzo3Apon0/ech3zKHd9sNOdBUA6SYVt+1fTe8VDXoNN+vnKE2bx3jzhzrWwylhoumxYaIQ0MAHpOShK8YuG2AjpHXY+hQr3PfUzUrY8+TPK83zyr9xP/QBQuoVjrqIF3EPfoegFYWSYvZgMDFsf4p6XqmDVw+TtnIqTwW67I/L/ZsvbwLPX0f8n/RLY/khq21b4Q1TMfGg9EGyhNFQt+rMRdRUSUj9YbHSN0zbeCLKQD6t7nLcYrd6/xUb01GMxI32Vzt47b0spvgDq+06/AbjrMxQdd++lFIl29A/c8+jvmA+c/ifgtVtJPgfeo5cdTW26waGbvKOH1wLjQ7mP4Q+RF/aMnYDpuiGwe/vq1kIRrLzfMCoc/DVgjwso739zunSlyVSJcrOj0H6g1H7DTqGWYXAI29cRSsTIUaT3ROClGynCs2U6Ke/d4uCvUgRd39M0jxOEemhu1bkNKek7t6K/7fPI8BZZCWx5hwwTW94hj/GJUVLurnqI9qF4jbkeAD+A08SbTdI5tMwAlnwS2OW00trdc7+jvqBlhsmoAKNYs2wcHR+lVEii1qsGw5jqD9LLnEte3l9cza24zBXxUq9KzkLPu1Sjvl0qTJm5e5GD0sBq4M8n0Hiz+9LS1gCzd6eo042vUe2s1/9m1IDy+GgsmPzf9FmwC+jZnmqidG9HBuh8jG4C1jwJ/5qn8ff0c/AjBbyjf9c6i2r37HBC+WqhPPFTMioEWoCjfgjsciqtIRNxivgRa0otkd/QY8X4SGb9CyE7CkqLKo+rZFSQU53KBEJAoJWO08jzvzolEolAVVUsW7YMvb29AMoXRTB//nysWLEiIzpi6dKliEQibFhgGKYuYMNCI5FvkWq1qA86mHDJSiIgy/NY0/RVkz4xTC84EMqFj2P1Lz+K7SZeJ4/p9x8DTvpVZt7TfCgKpW9ZcDCF6r91F/DOv2lyuucFwMJjAY8XyuB7+Eb6BhyoPQ/Pe/q5LDgI2OdiKkxopqmFQn3n7EHv0ymKZlj7AnnMCEWPMF6UIwVFOkXX88RPDaXVjicDh3+boibMBcvE34lRyunfoS9oE7HcOXQDId3bLU4LWjeNC/W6cC0U2eup2Ov1+Wnh4wsC7bP0SJ49qbDl6keAPx1Dyky3Q88FsxcDH7+L0l28dCMV6tzwCr1C3YYsaGn4Uyl8MzUGD9Lw39cMIE3KJyHnYnHrNS969VdCBd7WI4G2PpgMe/kW4FoauO9yus+LjqfcvoC+0Exlp0ICDONCtB9IjJNHeEBX1ni8ptRJRSofnLbxRpEFM1apN+R7nG9MkgsyivdAZlqgdApQR0g5oOqFTo/5MSl6nvgp5Wve8g6l6mmd6c51KR6qj9J7Iikx+1cbBdPVfjqP2ABd78QIvQbXZO5DGKbb55F3tPi/fS4pJs1GhGoaFTSNFL/PXw+88x/6bPelwP6f05U/USA2RAWDS4lameqRPTk9oy3mX6X2G0J+AOoHhdOB2ZBgpzwVnx9xJdX4eP8xKqh6zm3AzF2KPy8Zrx845TfkyKEOkAGhYyuahwFUODmLJmD2EnoJ4lGKgu17mmpCbH6TxgbFS8aQlhlIhafjrtV+bEEXPnX07gi0z6I+IdxTusI0uoWK2gLA/l+ksTw6YIw5coSCeKbNenRCqJMKzsoFghN6JKPdnEzIigJ7xWWhES9TkVKNc+J3aj/JULg7e18eH6XKu/crwAdPAv++jCLajvlR8ffb46P6bGufoz539SMU2ZKKO/t939OZ++rYCujelgwN4qUO0HppzRNkqAPg1V/rMBMzdz8avu0PJwNHIY5fhbLuReBxPRL74P8Btj5QH1diAEQ/pfdN4t5bFaHPFcVgNh4kYhRN6PGVtu4Rx2u1kS1/COhkpXC909vbiyVLLPQFLjN//nw2IjAMU7ewYaGRyJuSRVqEiPdJobQuINWHr5kWVGoEUHxAzzZ6jllCAaD4A9j2/92K9Lv3wyPSSvzxI8BRP6AcpYV4+rRMA467hgwMz/ySFPFPXUuT8VA3mvqewcH6pql5+8F70KWFLYo9XiP1RLnR0sCKe4DHriYPPIAUUPteQjnokxNkWBCY841GB4xif0D+HLrCi61cUQv5sPM4r0VkT8KMvPxBWnQm40DAgUJMqj9C919P29PclunNuNMpQLAHeOBySt91o+4J53ZOd4GiUIj7tEXA2IdUmHX5P+ja3n1gcjMvgAPFm74SjrfLxyhayYnC9I3bqC6LP0he0uIejmwgeZA9Q2VEAcbEGHlVx5vII65jTuZzKsboyuTHKvWGfI/zjUkWed8VAIo8noyPQPF7SOGSiBkpRQ77OjBvb+DOC4H1LwJ/PBo4/Q+Fp97LRVMryakV6RQZetUIKXBE0dn2eUDbXElxWgNRCHYkYiR7z/+BahoJtj8aOPgyox+LDZHRfXCttXHBcdTcFIzscdp3lCt3fCBEClHZyzcj73g0x+8l+Tvup8AdFwCbXgduPQdYeid5RbuB4gHm71vaPjxeSkEza1cqBD0xqhfa7Z6UsUQijevffxsAcP62OwN+F8fRx6+mvmfaDsCOJ5FMNLfqRm/duBAbpIhTtZ/G/NQ4eYPL/aDiye8hDxiy0pwjlVE50gbVGoXWLSlmf2JcAYBEyPp+di4Azr0NeOZXwKNXUYTBuhcpGnunU4uL+vT6Kc3eggPJqKDqxup0KvOvlgJS0t+xTVRDK/Iu0L+SZGFgNb2kuVwGigeYuQsSCw7HZ5+bg3XKbPzjgJ3hc1NGrBgfAe75gh4ZdTI5UCmgcUU4EMipkBQ/GXcEcdUocg7YrHNsDKfmKIZiaERjHcMwDMNYwIaFRiLfBFxehMRV8uZIjNt7u5t/KzzfE800IRzbYiysfMHJieFjD96HN954HXvtvgv22f9oaLOXIPrXT6FldBVNMJf/gzx92gvMcTtzZ+DkX1Ph25dunPTA0aDgMWUf3Kp8FL84bAm8PTXoDaBpwKoHKYf8h8vps+Z2YPHHgT0+6ayAYED30JYn0IkY5dAFDIORVdRCtZQ58Vj+bcpFoYtou3QRcioJJ0ohs5e9PwR0zM5OHZYYp8LEp/4JeOwq8ha99yvA878npd6i48oXlt4ynQqi73E+eeANrwc8HkDxIpFW8JtnhpCGgksOmg6/zzf5HbS0vuCVXil5Iay/pvcC2x7uzICoDlC6MwDY41NA6wy6V+ogHTcxbrQjObVRQrq/gRYAXlLk+PyFp0Ga6p7U5aJcqTcy+iqF+kqPl555bJjaIkBpxc6+lQp+D7wH/OU0Ms4t+bg755ELxUPn1dxO0RP1xMgGSsH3ys1G2iZ/iIph7/UpMj5OGkf1KKvhjSRbVjKSS36mQnqWXDjtO8R9ANwv9G5WrJmjFgDrsU0m1Ekp6O6+mOYofz2LotwKiTKtJE2t2fUKysWWlcBLesHZAy+jKItgB70XY7pI4ZZOAeoQgJShbJbTJDW1OnPwcCIrlU4bVA3cPmcrByuA5hAiAthcBFigeID9v0CRNHd/lhT593yBUsftezGw2znFn5evGWibbfFFvmhPDRjbTNE8/auM11Afre3m70sR3FvtDwQ7kFJCWPf8m7n36SYPXkHpATu2osgon58c0vwhIAQjDRJgGOnkCIVEzEhF1GJjjBMG1rhqRG4BxadAqkcDHMMwDMOUGTYsNBL5JuDmRUhcNVJQ5FM6Z3i+6xO+lmmk4JkMYQ3iL3/8PW6+7S60tbWiJRjAPoccAfRsj/Alj0B7/Booz/2WCjJffyhw6NdJqV4IHi95kG59CPDKMkBLIb7DqbjqXzU6+dM0Uhg/fjXlUgVoAbPTKcAuZwCzdjEmzwNrSCEd6rb3ZjNHMAgFwuA6wKeLu1XKGH+oIkXhsjAX3a0khS5IrbyeRBRDXCUFt1yPxG7xYVV/xPJ4emRKuBs462bgud8CT/+S0rrccSFF0Bx8GUXqlOvZeX3ANodmfJRKpHHvcx8AAD67w9bwl9uj7dEfkqdn17bAXp+myBAFdH8SALxadjokYbxJqJSru102OKjZ/Vy+djAVPakrgVPFlmOvbl3etIDxWahDT22lK7mD7ZkyOm0RcPpNwCPfprRF//kapfza73NkuGMITaOooBf/BLxzn5GbvnUWsPPHgN4TyNivSPca0Pu/mOFFalck2E5+pqIxQcZp3yHuQzRSuqJUyJNIDWKeFwDZ45nd2CYi9HzNlD7l7L8BN59Gjht/OprGh20OA7Y9zP2CrvXCw98ledn6EGDrg4wxHpCM3lLKqVAHzRfkl9dP41xyIjsqslLU4zhXarRhrjoUYm7g8VH9NHPkT9a+YhRZMGcP4OJnaL726jJgZD3wwBXAEz8DlnwCWPwJw/BUbhSF0n0FO4AFBxifp+IAPDTHqxZv3UUvxQuc8lugdboxN06o5FSSiAGJIM2tw910PfJzEH1WS440SALZmCpksZi2Xo8GOIZhGIYpM2xYqEeKVSLKE2Z5HyI3uoy82BcTb/F5vv37g3oh2xaaDPr1BZI/jEeeeg4+LYENGzZi5vZLgKZ22jYRA/b8NNJz9sS7f7oIi1qjwAPfAFb8Azj+51SELB+zds98v+3hdHnxFPCvR+izmbsCynj+fQHOJ/7COzYfHkkBm04Cqx+l4p9rn6PP/CHdKHIY0D4bCHYDzfo5jI+SN3hyArQYsKnrYFcg1a64WDGeN07bn5PtqrF4njx2gYtoi7QsGQsVX4BSUQmlgN3iI9Cie9DL+xnXFeHjxnfBTkC2PRz0FVKsP34N8NKfKYf0bZ+kdn/o/wLbHpH7nqcTzq6zOU+R6HgKABkW0LEACORp/1ra2XGtcviufY6KWAPASf9HuehjQ8Ziv3N+ZhsWERxN4cy+SCAX2xbv7TyFzbLhtnxUE02z7vdl3JRzcUw7nC7UhbyljIKsCPUAAb3tKB5DOSTaQrCTXqffCDz1c1LuCIXG3L2oHs9OH3XuvdjUkn8bgAxgTnCau9rj0IBnHo+0NOV/H9sCRD+kNh79kD4T/49tIa/Wsc3G77Y6AFi8FOheSEpPLU0erv5gZt775DAmq8/aRdaZ6zAVEi1U71iNGzm3t5mnCcxylKsoutovpT8y3V+xb0XRZSacuT9Rm0lEMYhxMhACPnE3cOOJ5JG94p/0AigX+7ZHUKTQ3D1yt23zGGhHcsLZdmjPv0k8BYBSIaFlutFvWJFO2X8ns+Zp4N37Se4OuVwfe2IANKno/AQVcTdHUUQjlKYmNkxzZQ35I0cKpZDxqNC2WgsUkuLVajurCAWzLAVCABTTnNF0X31N9CwB2h9AxrZtDqX0Qyv+QZFgT/2CatXscR5FMbTZpHF0uv5IOlzPOI1uTUjztXBPjvmdw/3ZOUENfgDc/3X6/6CvGKnQRPuL9lP6qdgw3dvkOKW8lOdsk8Ygh23W7nf55kKAaR6Zp49mGIZhmAaEDQuNRDGLhoRKeZNF/spcE/gMY0RssvCzIk28DtxrCV7EBE7Zaz8cd9yx0nHIw1gJz8C/PcfgoXeewiW7qFTQ7/rDgAO+DBzwBVro1ivpJBXFXfFPKl6r9tPn3ibyYtrjAlqcJvUFvezR7g+SAk0BRSzYYVcgFbAuLtbInjdOlMVO04eFuzPrW+QqiGmFEyNHXKW0Qgd8CVhyHqUqefEGYOOrlJZizp5kYNj6kKmx2EklgHsvo/93OwuYtw/9b75XVs8xZ5FUc+FSG0/hRpYNud1XQtHk1MgntvNIhtVEDAi05s/jP7yBCg7P24eMVSvuodo+614gBcdu55Cyp7vO0hbZkRynqL2nfkEKLSf4gsBuZ1IatOk70n2LvAuMbATaZth7UsdGMqO1rLCSp0aWMTtyzdPiUXsjgnnMj6tk3JoYpbGpc27+SK2Eqkc3+mkuYlebqakdOOd24MM3KY/86ofJ0L3xNXo9+TNyitjmUGC7I8iDO9hBn/lsnCLqES0NPPQt+n/P84H5exvfxWOUPioZI4OBVfo9gBw+gu3Z3vLF0gjGukLId0+tIhSETJjnEfnmjPKcb2g9OVWl08A+FwO7fxxY/wLw/O8oldizvyYDw65nALueRYaucA+lzitXistaIZ2kVFHxMRqPD7o0ext/kIyPipcMc14/MLwO0BQ9esFBetisfbokE/VogGMYhmGYMsOGBSY3ubzdc2GjVP30xZ/Dpz/9KWtl6+iHANL48mVfBcJX04Ls3q+Qt8/jPzaiF+buWdo1VZJ0EljzJBkT3vm3YUwAyDN8h2OBXc7U84jqymhFV9DI90hMZEV6AvGZmUILpNZj6HslKSR9mGjzACmpLfcXtfYglZXbg2vJUBE2GZASMVISJRNUS+Oo71FhwKd+AbzwJypQe/Pp5Pl18Ncob249Gxie+y2wZQUZ0j7yXePzYhaH8SiF1Wsgg53Hl90HmWWhkWVDbveVWEA7faZiu3jS+CyhAmg1zjkaMZR0sqFbjGNbHQBsfyR557+yjKJ/htcCz15Hr60PJiXhwmOLK7hZbYRB4cmfA6Mb9Q8VUsSEuki529xBiqz2ueQx62smxW/XtkDXAmNfiRgZuZtbAU/A3pM6KEV72KaAM8mTSEumwagDxOQmlxHBaswPSIYCs0e21fMYXEcFUpMAOmdkGyIyUogEgfn7UYqsI78NjH0IrH6E5murH6HaHMvvppeMT09XJtqhMDgE24GeRVS8NZgnaq5WePNOMqQEWoD9P09e1oGgNJ73A8ObgGALELcwBnl8ZPApJjLOTs7YWJefXNGIhY75GWnHpHk6QH1n1xxDCT5zR2DnU4GVDwAvXg/0PQu8ejO9BIoHCHZRXx3S++xQN/0/fQdgh+Opv65nnvgpGfSbWqmuwuhm4x5Npl8LGc9B1EYY2wT49M/MhoViDWpsiGMYhmEYV2DDApObXN7uOX9n8ugQCtVoP6UyaZudPXlvnU4pfwItmMzhfNJ1wMr7gYe/DWx5G7jxOPKmPPArzjzfqjFRzGVMCHZSAcwdTwIWHEiKrs3LSQE8uglo6QGSSVIcA7qSTPIStSsgLMjpqW0xgZ7q+a1LpRDlsmjzwvN9Mg1CLPv52S36o/1UYDjan21YAMj4FmzNNE7s/0WKdnn216RQ7HsWWHYqFRA84IvAomNL94DTtMoZKeJjwGM/AZ77Hb0/6Ku0uAaoDSfjRSweY0BcT1MQCFp7uxXqnTiVqSejipWXtlnGrPIwB1qBJZ8E9voM8N5/gZduBN57FHj/cXq1zKB+esbOVGx82g617aWYHKdiy09daxgUWmcC+30e6D2Z8rrHY4C6BRgfJq/zlunUzwyupagEcxolf5BSP3m8pBC2cggw56q2U2xaKfC8Ad3IZ9HOWOGTTaGOA/5QpuJafjbhnuzn4fPrRoW52fu0yk8ut4eW6RRZtusZNE69cQfw4RsUUTe8weh/kzFgNEbzHSvu+19g4THAbmdPprMsG9EIGUFSEzReTtuB2roTEjGq/wMAB15KCk+51k9CBfrfB7Q4EBsDOhcYvzWnZCmmfdumWqyjvrsSmO/TZFSORc2xYp7FWITadqA1c54XbAM8Fp71iXFgwf5kwB5YTQbgD1cAsX5aJ2lpQI3QCyuzj9fcQTK2+BP1WSNo7XNkWACojl5zB123uHdWNSxErbjwNCA2ah0dV6hBzZzyjQ1xDMMwDFMSbFhgcuN0op23QJq+KB38gHLRj2ygyaFYnE4qfqYbE8poPy3Utj+SXg9+E3jj78Dzv6eXE1pnw7vP5+DXZiOhBJz9plg0jfJ2P/I9YGSd8XlzJzBvb2Cbw8mLfMYi+jweo+tvnUmLDX8z/fX56drF/4Ax6S4kvY4Z9mQrnGIWmuIZhS0iT/IVjAt3G0YF2UN00sA3nYxRcsHNdIoK8B3yP8A+F5FC/tWbgQ0vA7edR4rRE34GzNylsOsYH6Z0Sy/8EZgYIcXL3D3hmbEErVoUo0pr/n0UwpaVwGs3A6//nfK/A8Ci44Hdz9avVQWGN1L/ART2XPxBWvhryC87rNBEQXmLq414nrKXtlmxJntoD62ldqDASK2340nkeb3xDUqT9OYdFNHw/PXGPjx6IfPeE4FFx1Wu+GY+tDTwxu3Af39IRUIBIDwd2PNTwO7nkgFeKDwDQSCpp5fQFMPTNjEONIXor4yTVFhmJ4JC01rZbcfjVTYidVshOPXIzudEUsjcw+MDtj+c5j3N7VS/RB0CPAoZsJJReq+laWxJqvT5mieB/neNug3d2wFn/CVTKe8Cc7SN8P/rc8DyOzNrAIWnkdJ2t3Nzp0SbGAX+fRnJW9scGnehGTIG0P/BFmC0H2jtyPy9m2kYzc+ykQ3iVpjv06QBLV5YFLYdiukvkFtWRGHvQJDk4/Q/AkMbgCF9bdTUQuOS2k8G4pFNVAdHjZDhO7rFWAMt/jhw9A+c1+mpJOkUMLSGirxveYccw7asBCLvkMzt8jFg8bmAOkjb2xWRF/iDNK51LihMHuwQ44sG+5RvDMMwDMM4pgZnI0xdkjdljD7R7tzKiFgQxga1X18MBTMnd+I3omDkydcBO5xIRZ2H+5yd1+gG+B/6Om5AF25VTgaSBwDlyG6x/mXgwSsovBegyITtjiKF1baHA+MjFMbr8RqLCnH9CigXr5hMqwPA+AClnkiCvGwFpeT2ZE+2wilGyWwVrSNHnuR6fuEew8NNRD5MRicEKVd2cjzzMy0NTIwDE1EqHHnsj4GDLyOl6At/oNzXfzqGCj8f8rX87WdoLeUBfnWZEdIPAGseB9Y8jgCA2wGsxSz4/30QMG8vSk9WiLenYGIMWP4PUuauf9H4vHUW8JHvAIuOkdLZ6Ia22AgdJ+FQ4SiipUJdzmQnrlrnJWeDg7uUkrpAHc2/XVxOUSGeYYzaHKB7549nej92b0fFnHf+GLDpdTLO9b8L9K8mxc6qh+h172XANgdT9Fk1jQxrngQevJLOFSC5OfBSSreRThtKrPERGpP8IaBdvxfqgNG/hLuoveerk+AEOd2L/N5qu1zPncer4rGTrXzRDfmeh+z0YfYsFoZwXzPJXGga0D5fP58YRWMCRo0okTJIPufoALDxdeCde4GV/wH6VwE3nQSceXPhhnELlIH38NX0r3GY9hS8b+kFW6fvSF7TG18lpe0z19Frzp7A7udQtI9csL3vGeCfn6f0aVCAI76lz1VVisZIxICwfn2YRhG4Zo9oJ32flae9OcqBxyEDp22+2ChsO0Tkj1XqUiusIiMBighNjAOdWwMdczN/k1DJ+LD/F4B1LwOr7gdW3ge88hcygH/0N8U5G7lFPEqRCBtf0w0Jb5Ps2hWWntYL7P1ZMiqE9HFJzB2t+nvZycbcZ1jVnAFyP1vxOwXUL7EcMQzDMEzJsGGBsaYYpU9s2Dp9C2BMtOWwYKHwE6krrMJfAyEqWJvQF2zbHAJ87kXyFFMHSGECkEdcqMvIzZsYp5Qqb94J7cU/YFr0Q3xeuwHa7+8D9vt/5JXmRhHBkY3Ao1dRJAVA92qP8ym9hlwAMdRF6WgmrzNoGE5SCd3AMkCfKaA0FSKXfrGGhFwLUfk7gBWmdrjhNZsvfZUdZq838aw8iq4E7KbPfE16qp8oeV8B5Hl52NcpbdgDV5AH9vO/p9Rcx/7YOsXExteprsHyf5KHM0CL3L0volQwH74FbHwN6XUvwTOwCvOwEXjz7/QCSIHSs5COHe6hnMDhbiM/sPgs1EUK21dvIa9UUZdC8VJEz65nAAuPJk/XjPuh5xVOJUg5rAHonJ//Ptrdf7t6F4GQUYibC82Wj2Lvp/hdvu8zUpHp+xepfTSQEnAyLYyk7ExMUDqyOXsCe56n7zMGbH6LjArv3EvFN1c9TK97L6MCtftcRPUbyp0yLBohpetbd1PKJoBkb79LgF3PAVq6TR7qMRofzcj9SyBkRElF+7ON/LmwkiM3ZIUVp8VT6v3PN//zB6mdKHEgHjRSlciGqoCsaLVSeirSsaQ5Uc82QMsngMXnAP/+Kikpl50KnH4jsOCAwq8FIMPgU79A4K078RE9QiG1zRHw7vf/yGs8EQNig2Tkfu9RUpKuf5FeD1xBBsRdzyT5f/bXADSKVDj6h8D8/ekY8RjNOQG6J+FuySBgmtvmMxoA1p72PP7YI+7PWMRYO1i2XZf7lVL2J9qGv5nmTf5ma+OuPwR0zKZtdz0N2OPjwDv/AW6/gGqa3HoO8LEbs+dM5SIVB9a/Cqx5gsag9S8B6UT2dt4AGeunLaK55IwdgfatSM7jozR2mI0FVljN4eRC8wDtQ5YRwL4Pi6sUHWKXho9hGIZhmIJhwwJjTTGLmGCBk9rJyb9F2LDsoeIN0P9aKtNrxTMMhDsBb5C85GSv/0CY9r3bmZhYeDKu/8NvcZb2D0wb20gplZ65TlfEFGlgSKjAs78FnvmloRhddBwpYVtnkNJqYhBomWX8Rr5OkQbJLxkY0gkjNLepVc8HbqEI9QedKahzPUPzBDzXs25kT203vGadppAw32fZQ1Rg51kc6jLaUsb204BTfkdh5/++DBheB9x6LrDTKcCR3yWl/+pHyKCw5knjd7N2BxYeB8zdi6KL2mYBsxcDO52GuBbA0msfwA5YhW/vugW+LW+SojU+RgaDQuncmhQ32x0JdMwzPNjMiAV8cpwMC4lxUrLmM47Z3X+7ehfmvOTiuQAcMu8mhcqW+Tnk269VKjJZpobWUjsy2wF8zUAimlkgMxEDWqZRJMNen6ac2O8+ALz3CCk+V95Hrxk7A/teDOz0UWfX5JSRjcC7/wFW/Is8pkX6FsUL7HEecPBXAXhojFQHAF8s8/eKN1O5m1D19Hv6Z8KYkKHAcfpcLORIfrbycxPfNdo4UmlKHbfsFN9yUVVzWxHtx1xYVp7rWBkY4jFSMgrv5UALAL29nngdcN9lwIZXgL+dQzW3ek9wfh0D7wFP/YIM61oaCoBnsRjLPKfhmo99Gt6AqR/Z45P0mhghI8MrfwEG1wCv30ovwc6nA0d8m1IQimsSacY0/X/ZYBLuzqxz5MRoYOVpzxE89oj7o+iOStGIMY+q1f4mHqNi6f6gEaWQ0I27ArkYuHwdi44Flt4B3Ho2GcKWnQacdQulk3UbLU2G9fefoHli3zN0njLt84C5e1OB6bY5ZMzu2BronEeyLeoohDrpvcenz1kdFKK2WyP6/OSA1Wox7uRa/4jvAWMOWatthGEYhmHqBDYsMNYUuogpOL+lrCS3UKDKi1aRCsmqWGAqYYTey98lYqSM8fqA5lb8y3Mk7tcOxV37vgH/a3+mtEQZBoaPZS+IrdA0YPndwCPfN/JZz90LOOoHlAomESPFZzxKqYwy7pG0sI4OZHv3iQV4c5u14aBQz/dcz8RqYcu5rrNxw7tNROuIlEh2ixir+2yusxDuto4KsjIqyGz3EeAzj1JR5Bf+QLVA3nuUZGjLO7SN4gUWHgUsPg/oWqB7Lw+QknVkI22jpYCkglGlFS9gMZI7dcHn14CmNkBLUA2VqF54cHgd/R8bpBQTsUFgfIgWqf4QsMPxlCN47l7k5T0+orfv8dz3PNxDyht1AJiQ8prZLiKlgory+1z1LuTnLlJSeXzWRZ+Z4ihUtoR8eHxGOhVH+9WstwvpHsVmuWmfnWmkFoxFgOYWSuU3bSFF8Rz1HaDveVJALv8HpR37xyXAw9+lyLXFS40oukIZ+gB4+17g7X+RR6jM9J0oSmKHE4E5u9Nn0QFgfJQMJekUMLaFjCGBluw+Iy4Z6oHcRXnzYSVHVvIjIkhKiv5qYCN3PqwiFAv9jcBO8W2O/jFH1AVCmTULAD2aTjcctM/ONi4EgvSdKKbbbkoDc+w1VCR59cPAXZ8B1KvImCZIJWg+N7ye5mQj6+n/oQ/Io1qcz4KDMLHnxbjyLov7YB4/Q13Afp8j4/raZ8k7/IMn6foO+hqluBRy7ZU8ptuleyhqhIlizrnuuZP5s9UzZXkwEPdH3BMRCV2JeWuG4c1mbj655mmWnrtUb2FyO93YEBsFgq3Ur/tFRI/pOrbaHzjrr8DfP0HOHTedDJz9V/uaJOMjwFAfvYb7KMo8NUERCKk4kIzDn5jAN1Lr4UcS/r//jhyetrwNxAYy9xXqBhYcCCw4mCJNOxdYR+spCoBBWhelEjS2ts9xcFMlrNaIVimtzDJiJ1NiOzE2NeLahmEYhmFchg0LjDXlTkOQzzPSvGg1L/zE94kRPZw2DLRL36uDNBFOJoFOKsKXUPxIbX8M/NsfTovF535jGBge/CZFCTR3UL7s5g6aOAc7qPhysIO+f/UWIxd8eDqlv9jptEyP8UTMKA5qp6CxUuAIw4NiylMvFiSA4eXjhELyKXOua/cxR5jYecgLrO5zMR7EMiKFmDiHI79D0Qr3XkapjWKD9PmOpwC7nQ3M6AUCrUZqiKQe3p4cpxQyw5sBRTqPYBvg02gfbbMpX/XksXWvaF8T/Y0NkxJmeC3gbaKi5e2z9HMcpxy7Hp/hwTbpVd2c3VYDId3IIXmr5WqjZqOc/Gzy9XPc/iuDk2Kl0QgpjFBElJlI86OA+nYrZQWQaQCWaemh8URE5oltZu0CdH8HOOxyKjz+wh8o7/VjPyJv6V3OoCgHu2KwE6MkE8Pr9Nda8gzd/EbmdrN2J9nd4XiS0diQUdshOkBGvaYWwN9C8trcQoocq2sJBLMjFpQ4vbdLZ2iHnE88l9JURJCUIkeNbOTORzH3xu43dt7y5ugfQDLY2s01JMNBbABIBA1DuTiW8GIOINPTP9RFY8IpvwUe/h7wyk3A/f8LvHsfRRuNrCdZMxszZBYcBOx7CdCzEFoiDWCls3sD0HnN34+8w/1BkjmndYSE0hgg+WrSC287iU4Q5OsT8z1z+ffFptSsN8S9DKiVG7czDG829zkRM2o3dcy2jkIAjHYT0g1XSoIMDWYDlaB1FnDCL4D7vkbGtJtOBj7ybWB8WDcirCUjwtBacuzIgxfAweLNGukLXxPQswMwbx9g2yOAWbvStTpZj4Q6MVkjy85xxOxEkw/ZkGTlsONkDZtrbsdGO4ZhGIYpCDYsMM5zQms2np9A4YvajAmdxfGFsiKhkrd0MgZoCikZQ120SGsKk7dNfIzyzqcmjAWpR99nczgzBB2gkOMFl1LO3Jf+DLx6EzC6iSb9QsmTC38YOOCLwI4fBWL95DkdCBsF/ppaMov9CeTzsNvGCqEULdZjutSc36UUjK5l3Gj3uTArs/MpqLMWQorJAGVzvrnSwiQnSOkSG6KInECQimCecxuwXHfd3OYQ8nT2NQGpFEX5eFvJg61VjwoK6UrBdBKIS7l0w11AfISuz2Oqit7UTp+JKJy2maRgmRjW89jrtRISKkUlKZ7M9p2M07kn4xQRISN7qwH5F4Dme28X/WO1mBTPpdy58yuJotTe9eQbQ8RzSCcz0zCo/YDSmmPcEbncpRzofgtFW2Kc2mdSl7dQt7FNQH/+LRZKj6ZWMgYnvMC+/w844AvAm3dSLvZNb5Ay9JWbqG7IVgcYxoOhtfR3fNjmtD2kxNn6EFKOzt7dOPbgWt2wNkHyHxvWo35GKdpI3E9bI00LveQiliLlYCl9fSFK03xYtU9Zjmut/VYKu+su5t44NZqKZxiPSjU4wtb9qNkxoqnFSC0XV/V2O05tTvbWDup9vIimiceMOgUAcMLPyRj9+E8o2k7G6wda55ACM9hJUQ9z9qD0fV3bGsaP8YjxG8VrnGtCpZfcVn0+Ol7rTHofjZCc+Zqp9pVVCs0MRb4uY2av6EKigvL1ifmen/z7ep/DFSrv+eatTud1To7rRI4CIT3FUQoY3kDRO7nGObFekNuUeS0TjVBR5/A04KRfA/dfDkTeoag5O0LdlLaoZQatZZr0+9TcAfgCSIwN4XfPjyAJH/7fYVsh0NoNBLtpbpZOUhRcMkn3JTWRfx2jeGj+1ukzrsNqzpoY0mvN9Uvp1RyMG3Yy4ui5he2jgMS8lI3YDMMwDOMINiww7lCoV69TZUNcBRJjpHzRAKCdPN4mF6NdNAlVBzFZh2FgTPeGnkO/yYh0aDGUl6FOYJ/PAAd+gRQ0sUFgZAMQWaUvBhP6JHOM3o8PAR1bUVHc1lnkLRdvIg82y+KEoN+rA3ru4SB5vRY6SXV6b9nDprYwP7diUhnIaXyEckTgpNaGUGIkE4ayBgA8HvKkDncDQ+tIITnWT/Ihe3ILo4LwYvYHAXUMQJ9xjKBJ6W++vokx3Utvjq6w7SGlkgajpohYaEYjxnXlUsBYpVrJtQB0kq86oZLCVi4GyFQOp8qZuAp4JKWeU4O2P0iKPqFvkNsaYBgexodIySKMD1m1bSwUUhkK1m5gt7P0Yq8PU2Tc6v8CK++nlxXN7ZSXumtrUvrM2Im8pH2SDMj3RVxDYpzabHKclCBdczIV+hnnaOpr5Pau+NypH1LusWqqGrndoJh7k0uxZvVszIYEp0pyKy/yiSjJm6itIOqAxGOUNkt4bE+eUwzY60KgfT4w+D5FyHUuALq3IZnxeElxK2oQyZE3Qqnrk4zfsX4gMMPYfzplGBeAbLmPDhgOK7bpbiyUnIEQFZlNjtP7cI/z51SwM0KBv2fcQZYjO/nxh6jewNA6MoSJ+Zw6QENKuCu3ocGK6ADJTDpNkXNn3QL89/tAZCXJSed8WrN0bAV0bgWEppGcqAOZ0XvtcybbSOrDD3DPi8sBAJ/dYUcgGMZkGiaxnkGCHE+aLApNi3sQHaD9h3vsozMy7mGouBRWbrdxIcNiXsqywzAMwzCOYMMC4w7lSp0UCAHxFlp0iogFc/ogTSFFaWKcDATpOEUgzNxR97JLSttLdRTEBDI6QMdpmw10b0fpXNJJmuDKx5MVuwmVPON8zcbEM9qfOQEXNROEYcSje4R2zst9r6xyJcvb2y1cOE1EeSlUGeZEJpw8M6HMETnKYyOkIBHK+lxKikllU4S2D3UiK6+vPwjAS6lTEmNAZDUQ6qCFVbOeE11sFwgB8ZSxf18IUCZyK/Sjg3oIvO6BKuftTsSAcKuh+MmI8JAUZbkKlxezsPRL5yDex9XsYoCM++RSvOQ1Doi+dtT4LNfiP6FSbYSkSTkfVwGfyUNfGB48XmSk3nNS20ZWsIp2DZDH9Bl/ATYvB15dRt6YHVvRfoIdQMd8StXXMi3beCAImPr4REzyINcN314f1UvJlcbI3NfI7b1zpjtjRiEOAzxW1Sa5nk1WXQWLPjrX+Ci3Dy2tp0jSlf1iXErGso3Vcd3oN7SWDAkzdwF6tjXmWsMbDCXp9O0zr2Uy5V0QaJLGrugQ0D7DOC+haBXGhYzUNXNI8SuMFnZYjUViX/ERYBiFRZ2WOq+2isxiykveyLtmw+EpOkAOSr4mZNRQEGkgzbIk0v5oICelcBe1WVEfrnUGcNofrc8rEaPaI1oSGI2Q3PnDGUaFyfObvJYYoKlAogXo0M/FFyPDiMeXe86akKID8xld5O0KTWHl9tpTyHBLG49NDMMwDFMAbFhgaht/iBZ1gKGol4nHAEUjj5222fT9hyuBlpB1TlKvz5jwiwmkYvKQkT+PjwHqEOWCD3WTYiitF70UBUTFYjidpIVyx2xMFmBToHvJeukznz+/MiXfwsTue/ZOKy/lUIY5KtqoK3OEQkMoOISy3onyPREDkKR2KqeXELRO0wu/avo1julKVp8hH0JplJRk0B8E1WRQqWCzvIAUC76OOdlKV6ui7Vber+KaEjHDy898bcUuLM3P06oYIOM+xcqRUErEVUCT0q2EugG/zVRGKN5FFEJ8nJSWCrLr1dh5fPuD1O8n44A/aq/8lw3M6STlfvf6SY66tqY87yKl2MQoMDFC9XuEMcAuV70sMxlp8bqN889Vz0c+R7mvqWZ757Gqdsn1bHJFReSrIWTGHzLmSgCldEFST8vXrM/nVOP7ZILmb1D04urCSGhSYopzkeVFGLURMI4f7sg8l4ApakEofieN4j32RgFZYWq1jT8IJKKGApipbUqpTZFLfqIRY27lDwHJ9Xokiyez/1YHKNKzqYWMz4K4HgEKAHG9rYW6MtcluZT9Xj8wOgS09lCUmtmoAFg4bqmZWTiFATDfeJNMkJHCbBgvJLq0GlHY5XKSYxiGYZgpDhsWGPdxezIoDArJmJGzXXhbJ2KUvzOoh75H+4Fp21AOUKv0RIrk3SomkMILKBmnxaX4fOxDYMNrANKkcO3eLlv5KdIvaSBlUSIKbBokb1S/XnxQ3IPkuDNlSj6li933PCEuL4Uqw5zIQSHPTBgM4lH636xMzOVZrZn+ygg5aZlGf0UIuyhwGze1eZ90zFg/kPTqi9YAJnPfT4xRpELHHGulq1UxarPSKh4FhtZnpmoBrAv1yTjtf5ykqmLcp1ilslBKKKD2YEeGUihkRCFoev6tVDyzfsLk/m0Mc1m55PMYhUXNAl+zMTYApNRRB/QaQa0UYeBELoTn9PB6TEbQeXxGrvvOec7un7l9V6O951PAMtXHrl3kMlwDxtyoGGNRQne6GB2ivyKKQR0wFLEds4GA7u0dkqIGAkHyqBbjoSyruVI1+UIUASHGOnPUgti3OZ2mFfkUpp1z9VQ3DuoqTN6TAubRnAbTHazy6xdqWMjVr5rnYf4gRRkIQ4PddvK5Kb5shb2TlGTiu6ZW472VrMr7CHYCCFuvpcQ5RQdobeNrNtI5CScqXzDzugIhiiBU4plpx+yodGQbyxHDMAzDFA0bFhj3cXsyKBaKIudlRs0Ec2i+UJIGrY8d6gL8gczPxELA6py9fjJoxIbIK0gU9ZSJjRr5gBO6d2lza+ak2i602Yp8Ch9WgFaHQu+7W3JgNhgIJYzHl7nozbW4DHcB8WbJIKdmpkOa3EcI6LRINSQvQOXfRIeAtg5dNr3GdU6mPzKnhcizAJaVV+I6kwmgYzpdq5N6Ck7vO8tRdSj2vguDRHMboAXst5Off7iH8kwDRtsxy40gl2HOMprGFH0j9uEL0DFEhJtQDqUSNJ4A2SmLctYTCep5uFPklSrunRNDx+S11YjChFMg1S9W8mE2NjhVwiZUqrGQ1A3SCgB/C9DdQp9p0A0GerSCBmov7VaK0BClaZGLtdpFxckkVSnSQa/9I0ctQDFSvuS7Lie1EDRNikpycJ8KkRWWK3cod379lh5y1BD9fEg3Npn7/XBXdtsV6fusjLKyk5RYp2SsPfRIhlyp8qwQEakyIhpbRJKOrKe1TdsMIKEfV4iiuX6yiAx12lYrHdnGcsQwDMMwRcOGBcZ97CaDxSo3hGJF9tCODuiT3mCmojOf0ioRA5Ij2ecgzhmQPKKDVKQ5pXvj2IUa+3xGAcK2OYbCVj6vuB7ZII5RC0oepry4tSgyKx3tlJCJmJEDWijhJwtZ9piUoqI9CsVNyjp12OT2khLVnE7C481Or9Qxh7w/EzH6K847l6JHXIPsbQqQkVDOg59PmcppVqYmct8u180xYxvRlceolet7q1zyGXUapGPFRgzFkGjPAKWdsNp/hmzBiESQUxa1zzG8qeVoOace0HGVUi9FB8h7upRUE6UYKVg2aw+nz9NKPpzUH7EirhrRPIo3M7JTJgxSxNp5TJv3KQx5VrV8zGOXLwRocV2m9G2Fcla8Vwf0lC7R7Gg62aDixFgaHQASo4C/1dm9KkRWWK7codz59f0hZ+mw/CGKYhAk9CgKDXRudiRiFC2qDgLts+mz4Q26QVtxp33IqZDiMaoPoXjIMGg2mADGegow1j9OjTaFOCG4YTxnOWIYhmGYomHDAuM+tqH0RXqDBILkCSMWsMmYER4fmFPYuQ1vBIJNxnmaz1n2iA52Aj3b0fdqP9VaCHXQe+EFBFDaJZ8uSu1zc1zDuDFxLeQ+1Iq3KZMfq8LbpSKUELK3o5ViIjoApCd0Y0JP9vuMfQYzIxasohcyrktXIEX7gUTa+NwXAkKt2dvLOaujA5TX3ol3tay8srpOJ16xHInQ2Jifv6wEzJV+x6nHtZAFqzoNALV1oUCBtI2dUU1WzgLWkQhWv7Xal1CiWhnOowM0TsnjTjFj0eBaI1WN2IfTsYlls/Zw2gas5MNJChbLfYUoYiFsY1CY3L+pvciRdubPhzZQBIK/GUhI8pJhrJYMC+oA0DHN5NmtGsdUFHvDSTEGFTsvbqfX7ta2jD2Vvo+JmL3DkjyXjOupmXIVTAZ0J6xBox6VMDR4vZQCyWy0zoc6ACT0ekZC5uR7FBafm+RRbKP2G30LINUHKkMaPDeiDViOGIZhGKZo2LDAFEcxym4n3iB2+5UXsHJ4vKNzjRn/+3zkgdZqcw65zrFZUqCKBYHHS5EK6mCGM1wWZg+kQrxiODy3fijXs3KiyBBFnc1FnsNdmdtZKWfypufS5U6JG+kjAD2dhDfTy1NWziRU4/i5lE+yVynnXmfcpFivajtEMWeRe90q1ZcoeC6KLOfbX7SffuMPAeMjZIQGCk9dYVdA1x+iSAXzuFOoh2ZcNdKTtRZhJGdqj1K8dAtJfyRj9ty2MxiYkSPtMoyHetq8WDy7/opthN8YkAhnjlty8eZcvy3GoCLqQmggY2euCAim/ihmTZSrHcl9q1MZ9YcoUkEdIJlIxoBAM0UTAJlGa6tUfma0JKCOAMFW64jWvGlbJYcqcU2lRgPY3WeONmBcoq+vD5FIBACwYsWKKp8NwzBM/cCGBaY4ilEoOPEGsdqvKN4sJuGxIVqUhrpy7goATUKHNxrvAy25w5zlc0ynpM9zpKNJjNPE2ymFesXwhLl+KNezcqLICPdkKuVF+qNEDJMFnwF75Yyj8wgBflPEgqyQAYz/Qz2GcUE27llh9tpmJQtTDFZKB7PsuKHEi4/rNURsIgvMBc9zYU6ZBAAehZRDxeTEtosMshp3ihmLAMMwLwpVN+dIz8HUNoW0gXIpwO3GJLPBwRxpJwgEKcLA4yXP7ozvpOgFOYWa31Qw15wGCbA3nDgxqIi+aHL/ume3WxEQTG3h9ppInksWHL2iOz4poDY1PmjsU06ll69Oj+Iz6sc5SUdmdS6yQ5Ubxmdxn6MRff+m+yNkjuWIKYK+vj709vZCVY2+OxQKoadHX1sNrSXHkjwoyRS2096n/ze9Bvi81huGuoGOeSWfN8MwTC3AhgXGOXJxPHnSqziN7TahWYQcWClmk+O06EyOU2SAOFxTS/bvzSTGM9M2hHsAv8Nm75EmAk2t9D6u0t+mVnqJ7SbvhcfZvnNhvp/FegUKrO6zk+MyhNP7omnOFoCF7E9QiCJDVqpaKSyEItMfdN5exX48PqBjLoDlxr4UX6bMmvsFJ0oTWe7FwrFSShZu95WhmHZfKFbKHbPslKrES8T0yLe4rmC3uK5C+2zzuBcd0A3nDu6ZLPeljhX5kPu3aMQoVM3RCvVLIXJpJTvFpmqUx56msPUcKqHP/RLjpKAULzPic/lcLGVH+qxjLhCQ5oJuy47oi2LDQLA901PcKq1ZqfNppro4dSpxOudyakyw2l9Al6fmNkpdB4VkqHO+zflKbU7eX7gnU0bKjZO+RJx3Mm7hhCZHeThNUcbyxhhEIhGoqoply5aht7cXANDT04P58+eTUeG6vQ0nqhw0AbhOvPlTjg39IeCS59m4wDDMlIANC0xxlEuBYelVKXl/2qV3MReqlX/blIIrmJVWdsdkmGpgqVQNAWMRSrMi0i9YFaLN54GaK2JCllmrCbeTBXdWXvwyRH1wrZKpj5O2FggBg31kqAYK77tlr3232pGsGAmECjunUtIRcSFmphCsnrnc/sR7u/Zkm+rS5G0sj1+FtLFy50gvRF7EuYuoo1ye55zbvXq4NS+opWeYUQehm1LtmddMTs5X7QeU1spdl5OxTJx3QHpucnRQMp4532WYIujt7cWSJUsyP1T7qa2dej3QszDn7yeSKVx64zMAgJ99cj80WUUsRFYCd14I9D1jGQURHFqJxTM9CA6tBIamsfGBYZiahw0LJlKpFLxem5A1pjrIxWv9QWC6xYAeHQBS49mFagNhkO+AG+dh4VWaGtcn7WxYYKqMlRJGhIrbeWg79d7OMEYkM78zFxk0LwwLXXCXa4HO+eCnPk7ajl/30FSU4vput9unkJ+ESmlcCm2fpSj4S5GJWlKkMZXB6plbRZvZtadc37sxdriNWelciLxU+9wZZ9TbvKBQQ4g5RWYhVPq+FDKWmaPnREStmO8WErXAMIXQsxCYvXvOTbR4EquUTfT/zN2sI39C3dSG77zQch+9AF6+qAV4/CLgGY5sYBim9mHDgsSqVavw4IMP4qSTTsKcOXOK2sfExAQmJiYm34+MjLh1elOPjLB15PF0y6MAtYtkKOXY5gm8eaFY6DEZx0wZOaqkl7ydIkMs1iyjDaRi6NGIdeSCiGoQaAHT93L4eYFKzkrenwb0sJ4yciSY9Ews0Vg86cVZYA0DJxTapoX8aDAUI4VQigJTyARA8l+IHJqvcwpHBE05OXKTQqLN7PrghG5Y00A1sEppS7naJQJ5f56BWelcrjHEnM5silKTclRP84KECgyuo1R8QLZsFCo3+bb36McpdGxwgmU9pCKPYX6G9fI8mcamYx4ZC2xqNqx4+22ce+65uON3P8TWL/+QtmPDAsMwNYwLCeGnBq+//jr22WcfvP/++4jFSImWTlORUq2AnM9XXXUV2tvbJ1/z5vEgYIu8aDOH05vxB/VczjYFxMI9RiTDhytpIuzk2NEITdQnRrKPne+cAiEyKuSawCZUOoZIEWN+XwmqccwSmTJylK8NuY3Vs/aH9Fy5UvqjaMQIFRfebHLx5Ix9xoCJUSCymv4mY5nfBUKGQlQcSyh08rW7Uu6P2L945Wvf8rk1CFNGjgST9TdMz7rQPi7cA0xflN+Ts5i+06pN59qPkJ+WHmey42Z/LmQCKEwOEyrl7pbHzbhK7wfX1tVY44QpJ0flwq6PFW0WsP4+rkfriDFkLAKMfUh/Eyow1Efpy5y0K6vUTFZtOxGzliX5M3lsy3V9pVLpeUKVqEk5cvOZutVv220bV/X6PknrdUch7UgYKazWPubtCtmnOO981+tmm5efoXm+yzC1TMc8in6weMU6FuKVTWms2EK6qI2bNlXvPBmGYRzAhgUAGzduxOmnn44LLrgAP/nJT7DddtsBAFSVJjxKAcWdLr/8cgwPD0++1q5dW5ZznhLIizbzAi5r27C9clRGTokkthteZ39sDfYT9Xzn5GRi7HSRW07qcNE6ZeQoXxsqFjuFyOA6Uv7nXCjGso0IuQx3/iCQTADNrfTXJ22TUO0X5k7aXb77k2txOmkc7K+79l0ppowcCUR7KaatFUOhihqhPDW36Vz7sZIf8/ayHJTjWgvtp+Iq4PNTfyB+Ewjp/YO/MANFHRi9p5wcVRonThpy+xNTbkX/7cQYEB9z1q7M+xLvgUzPUDtZMkcp2CmdS2m75t+Wa55QY0x5OcrVzgvpt+22DYSApjagc659dKpVO7Jqq/mMFICzSDrz2DQxQvNQkZ7IqcwzDJNBT08PQqEQrrjiCgDA6aedhr6+viqfFcMwjD2cCgnA8uXL0d3djR/96EdIpVK49NJL8fbbbyMWi+FjH/sYPv/5zwOgyIV8RoampiY0NbmU03+qYw57LcRjyC41kjk9USJGi1K7Y4sCYFaFOPOF5TotFCpvU42w63oK9daZMnJUyXoBsrKvNccxrQox5yrGHggDHXOk30jPpVT5yHd/cuU/tiqOyWQwZeRIINqLuc5Hufq4QvYr2qrHlx0JUej5WaV2KDbdmBMK7afEseVx0x8COucVdm655LuGmHJyVGnytdmsNJM9RuohAGhqIQVnobnX5fdC0Sl/HvBmn5dT+Sql7Zp/2yD1GKa8HOVqO4X023bb5msndt9btVWrPtyMxweEO53P0QIhWn/5fPkNEg3S5pk6YWgtoPZnFkzeYPK9jays6CnNnz8fK1asQHTV08DjFyE2Po5IJIL58+dX9DwYhmGcwoYFAGvXroXX64XX68Vhhx2GYDCIvffeG7FYDF/60pfwwQcf4JprrikocoEpI/EoTWIVAE2tmd+ZC5X5g7QoFaj9gNLqTnFAp4VCrRa5lYQn8FMPq4Xn5GdlKD5vV7zZLjUZ4E67y7UY53bNCMrRFgrNV+20rTrZr/l65H3XQru3O4diDBR1ZvRmiqDQdiG2F7KSK2rAqYwGQkAiJR0jCPgtop+cnmspbZfbfW1SzjoxhciA2328VXtzcoxQN8mI0337QxRNUa57yDDlYGgtcN3eQELNLJj8uMW2/hDJRYWYP38+4BuwPheGYZgagw0LABYtWoS33noLP/3pTxEKhfD73/9+snjzAQccgNNPPx2HHXYYjj/++CqfKQOAPKd9Ad0bJk8ezUAYaG8CsJzem9MSlWPyO4WLWDI1gtWiUHh45vOiNKdCEpEITnPSVjLlUC0oUZnGxIlHsrmvd9JWi/F0dkMOanFcYvlmcpFPVkqNeClFJsrtlMJUnlLbk1sRWG731XJUq/zeDWrBeYphSkHtJ5k79XqsiKRx7rnn4uabb0bvDjtkbxvq5gLKDMMwNjS8YUHTNPT29uKkk07CzTffjFQqNWlU0DQNRx55JHbbbTe8//77VT7TBsDpZNoqlYtTRGhuOVMw1El6B2YK4ij9kCQ/xRgZkhYFnhlmquFElorp6516K7utXOJxiSk3brfZfLJSTKoyq89YJhig9EgStyJRcrXLYmWM2zrD5KZnIWLJNF7ZlEasYyEVUWYYhmEc0/CGBUVR0NHRgRNPPBHPPPMMVq1ahQceeABHHXUUFEVBS0sLOjs70dzcXO1TnXqYU0tl5OqUFJualrmdXT54u1RV8ufhHiDgM44XCNn/znxcO8y/lxcX5UyfVez5MeXB7ftczP5y1UoQ7UXeRlEy87YLI4OcPsyMvChVlPznWa126vS4TG3hpB0U0laKbVd2siS3q1yKJLvj5pJRGbvxsFgqNS4xjYvrbTaPrMjf5+vvzamQFIVlopGxet5O+2Y73PLWz9Uui5Uxp0YP+XhO5ncMwzAMwzBgw8JkQebTTz8d6XQa3/3ud/GpT30K3/ve97DNNtvgP//5D1asWIEjjjii2qc69alk3tlSFxDV2jfDuIl5IexE/jgvNMMQ5Uz74PZ4yOMSU25quXaAPwSEApmfsUwwtYg/ZN8ui5UxTlHEMHVN7zSbotIynKqJYZgq0jCGhYGBAXz44Yfwer3YaqutEAjQAkNRFKTTaXg8Hpxxxhno6enB3//+d1x88cXYfvvtoSgK7r33Xmy99dZVvoIGgBd5DFM9xMKTPdQYpvrweMjUG7kUogzDlA6PCwzTWIS6kfI24+ZTYV9UWuAPAZc8z8YFhmGqQkMYFt5880184hOfQDKZxMqVK3HFFVfg8ssvh9frBQB4PB4kk0n4fD4cfvjhOPzww/Gtb30Lfr8fPp8PnZ2dVb4ChmEYhmEYhmEYhmEYJidDa6k4cy4iKytzLsXSMQ/LD7sR533sBPui0gBdx50X0vWyYYFhmCow5Q0Ly5cvx6GHHorzzz8f559/Pv7zn//gq1/9Ks477zzMm0cdr6Zp8Pkyb8XMmTPh8eQIN2OYWsLtoonM1ITbCcOUH1nO2LuUYaoDj3dMvcFjB8O4w9Ba4Lq9Saby4Q9RGiFsKftpFUMiNIOLSjMMU/NMacNCJBLBxRdfjKVLl+Lqq68GAPT29uKhhx7CunXr0N/fj56eHsydOxcA8OMf/xjxeBzf/OY32ajQ6MSj9bUglQu61cP5MtWhWu2EFTxMIyDaeVwFfAH3itgyTLWpxz6c50VMtShWXtwugM4wjYraT3J46vVAz8Lc207WJqhNwwLDMEw9MKUNC4qi4JhjjsHpp58++dn3v/993H///di0aRMikQh22mknXHHFFVi8eDFeeeUV9PX14ZJLLkFXV1cVz5ypOvW2IK3loolM7VCtdlJv8sQwxSDauQLA4+P+mJk61GMfzvMiploUKy/cZhnGXXpye/n39fUh8t4WAFuwYsWKip0WwzDMVGNKGxa6u7vxuc99Dq2trQCAW2+9FVdeeSX++te/4sgjj8Sbb76Jr371q3jooYdw4IEH4qqrrkJzczMbFZj6m9z768iLkKke1Won9SZPDFMMop03t7G3KTO1qMc+nOdFTLUoVl5Em1WU8pwXwzCT9PX1obe3F6pqpEsKhULo6emp4lkxDMPUJ1PasABg0qgAAPvttx9efPFFLFmyBABw8MEHY8aMGXjppZegaRq23nrrap0mUyjlDssPhHlByjBuUQsKnnpM5cEUTzVyVddCO2eYclDLbbveUlcyU59alhcrxHiJpmqfCcNUjEgkAlVVsWzZMvT29gIAenp6MH/+/CqfGcMwTP0x5Q0LMltttRW22morAFSwOR6Po6WlBTvvvDMU9g6pL+oxLJ9hmOrBfUZjwbmqGaYx4L6dYUpDyFAqVe0zYZiK09vbO+l0WvdEVubfZrKmBMMwjHs0lGFBRlEU/OAHP8BTTz2F73znO9U+ncZE04r/rVWYsd3+5M81zflxa93Y5Pb5TZX7Ui2qdf9KkaNi9uf28cqF+T7LfQa34amDolg/z0JTUbgtv9WSE27bTDVxu907ac/lSNNU6+M5y3ltUevzunwIGfJIEQu51kvc7hmmtgh1k2H9zgvzb+sPAZc8z8YFhmFcpSENC7fffjseffRR3HrrrXjwwQex/fbbV/uUmFxYpTCptzBjhqklGjEtUCDMnuuNRL0870aURaYxKVdb59SVDFMaYk0VHa32mTAMUwwd88hYoPbn3i6ykowPaj8bFhiGcZWGNCz09vbitttuw+OPP44dd9yx2qfD5CNfmHshi9VEDAi05t6GYaY6QqbGInoO+gorNVmZytQjhdRtcNrGOY0LMxVw0t6nQlvnsYupBuVud2L/0TH3980wTGXomMfGAoZhqkZDGhZ22mknLFu2DH6/v9qnwjghX5h7IYvVhAqADQtMgyNkSolXR9EzFRRMTONRSN0Gp228HGlcGKbSOGnvU6Gt89jFVINytzuxf840xNQDQ2udeeYzDMMwFaMhDQsA2KhQT+RLe1TIYpUXggxjyJTsBVdJpoKCiWk8Cmm3TrfltH7MVMBJe58KbZ3HLqYalLvdif2Husuzf4Zxi6G1wHV7646CefCHstp0X18fIpEIAGDFihXlOEOGYZiGpGENC8wUopDFqj9Y3nNhmHqiWoqeqaBgYhoPv4MUSPK23MaZRqFR2nujXCdTW5S73Yn9x5PlOwbDuIHaT0aFU68Hehbm3jbUnZEaqK+vD729vVBVwygRCoXQ09NTrrNlGIZpGNiwwDQ2nC+XYcoLyxjD5IZlhGEYO7h/YBqdQuobMY1Bz0Jg9u4F/SQSiUBVVSxbtgy9vb20m54ezJ8/vwwnyDAM01iwYYGpH8qxuOJ8uQyTidtyxjLGMLmRZUS8ZyUi0wiw0jw/PIYyhTLV5KqQ+kYMk4fe3l4sWbKk2qfBMAwzpWDDAlM/lGNxxflyGSYTt+WMZYxhciPLCCsRmUaC23t+eAxlCmWqyRXLAMNk1IQoOdLCSXFrUyophmGYXLBhgakd8nnYlGNiyflyDaaah1OtUO776vb+3ZYzljGGMbCSV7OM5JI/7qeZesFJW62EwlCcB5rKd4xywmMoUyhuyFUiBiQmqjPWmPsO8VKUyp4Hw9QAPT09CIVCWLp06eRnoVAIK1asKNy4EOomWbrzwvzb+kPAJc+zcYFhGEewYYGpHuYJYr5Q10C4uBBY+TiKUvsTU01ztp3b18GhxqVh9zzKfV/d3r/bSoxalzeGAdxvp8X2B/nGuXy/r9b4wUxtimkvudqqaKdujTe5zk+cRyrlzv7KCcslUwh27cWN9VJCBbxaZdYEha4HGaaBmD9/PlasWIFIJAKAIheWLl2KSCRSuGGhYx4ZC9T+3NtFVpLxQe1nwwLDMI5gwwJTO3Coa3Xh+18eyn1f+bkxTP1QqryyvDP1Qq20VXEenjqNWGCYauAPAZiojvzWSt/BVJahtc4U3g3I/Pnz3Ssy3TGPjQUMw7gOGxaY2qFYDxvGHfj+l4dy31d+bgxTP5QqryzvTL1QK21VnEc8We0zYZj6IRACAm1VOnaN9B1M5RhaC1y3N0XK5MMfopQ+Dujr68vw9GcYhmHKAxsWGIZhGIZhGIZhGIZhmMqi9pNR4dTrgZ6FubfNUVRYNiRs2bIFp556KlTVMFaEQiH09PS4dtoMwzAMwYYFhmEYhmEYhmEYhmEYpjr0LARm717UT/v6+tDb25tlSLjvvvswbdo02n1Pj3sphaqMHIFRtutyknoqh6GHYZjGgQ0LDMMwDMMwDMMwDMMwjHtUqHZCJBKBqqpYtmwZent7AUwtQ4Kgp6cHoVAIS5cunfwsFAphxYoV7l1rqJtSTt15Yf5t/SEqCM3GBYZpaNiwwDAMwzAMwzAMwzAMw7hDGWonyOmOZIQHf29vL5YsWVLwqdYL8+fPx4oVKzJqRyxduhSRSMTdAs+XPO/MIHTnhbQdGxYYpqFhwwLDMAzDMAzDMAzDMAyTH6eRCC7UThBYpTvK2EWD1FCYP39++SMxOuY5NxZwyiSGaXjYsMAwDMMwDMMwDMMwDMPkptBIhPn7uaJUtkp3JDMVUx85pSI1F8wUmjLpzL8AoTyGHzZAMExdwoaFMqNpGgBgZGSkymfSuIzHk0iO08RnZGQE8UCNN3tNo4laPAYEgjQQW6EolT2vMiDkQsiJHSxHFSQezdn26k6eGoBGkyNugzmQ20CucWQKjB9u02hyVFXM99iurbrYTrnfqAwsRy5QBfkAWEZqiYLl6N1ngJZw2c9rkv5VwFgUOPH/gO7tcm8b7AI87YALsj42NgYAmDdvHrbbzvq41e5TKi1HTU1NCAaDGTUXgsEgli1bNhm9MXPmTMycOdP9g3vagY8/DMQGcm+n9gN3fgb446n59+kLAqf+3lFarHyMjEUB5JcjhmFKR9FY0srKunXrMG8eW10ZJhdr167F3Llzbb9nOWKY/LAcMUzpsBwxTOmwHDFM6bAcMUzp5JMjhmFKhw0LZSadTmPDhg1obW2FUmEPwZGREcybNw9r165FW1tbRY9dCaby9U3lawOM6+vr64OiKJg9ezY8Ho/t9tWQo6n+DIDGuEZg6l+npmkYHR2tOTmqp/vO51oe6uVcxXkuX74cixYtKlmO6uW6BfV0vvV0rkDjnW+tjkfF0GjPrpLU07kClT/fepWjenuu+eDrqW3yXY9TOWIYpnQ4xrHMeDyeqltI29rapsTgYcdUvr6pfG0A0N7e7uj6qilHU/0ZAI1xjcDUvs729va821RLjurpvvO5lod6Odc5c+bkXXwWIkf1ct2CejrfejpXoLHOt5bHo2JopGdXaerpXIHKnm89y1G9Pdd88PXUNrmux4kcMQxTOmy6YxiGYRiGYRiGYRiGYRiGYRjGMWxYYBiGYRiGYRiGYRiGYRiGYRjGMWxYmMI0NTXhyiuvRFNTU7VPpSxM5eubytcG1Mf11cM5lkojXCPQONdZa9TTfedzLQ/1cq5un2e9XLegns63ns4V4POtZ+rtXtTT+dbTuQL1d77VYqrdJ76e2maqXQ/D1DNcvJlhGIZhGIZhGIZhGIZhGIZhGMdwxALDMAzDMAzDMAzDMAzDMAzDMI5hwwLDMAzDMAzDMAzDMAzDMAzDMI7xVfsEpjrpdBobNmxAa2srFEWp9ukwTE2haRpGR0cxe/ZseDz2dk6WI4axh+WIYUqH5YhhSofliGFKh+WIYUqH5YhhSsepHLFhocxs2LAB8+bNq/ZpMExNs3btWsydO9f2e5YjhskPyxHDlA7LEcOUDssRw5QOyxHDlA7LEcOUTj45YsNCmWltbQVAD6Ktra3KZ1MimgYkVCAeAwJBwB+y3q7GLL3j8STO/vnDAIC/fvkINPu9mRtE+4F0EvD4gHB34QeosevNIl99dvmZBsKVOSedkZERzJs3b1JO7KgLORqLOGtHtd5e8pAhT186HM0BaRix6h+cXm++dmomX19U5/e5EOpCjpw+XwfPLatPD/BUZhJxnyspH/Fo9rHsxtUalsu6kCO3qdN5XRZy/2JzPePxJM7+xSMAHPQbVv2VVZuu9ftSBRpSjpySaxyU21dLT+WOK8nLuBYwZMQ8v5Nxu907kN+yHLeGYTlyAat272S8s9vOYftzPEd1Oi92qqdoIPlwCstR5eE12tTDqRzxky4zIpyqra2t/jsqTQOicRpkPT4gbHM9NTawBeJJ+JppUtDW1pZtWAj6gLgKBEK5Jxl21Nj1ZpF34qI/xypeR76ww7qQo2avs3ZU6+0lD1nylDFhsHg25TIs5OuL6vw+F0NNy5GLhoXcbbDBEfe5ovLRlv187cbVOpDLmpYjt6nTeV0WGe3P+hoK6jes+iurNl3r96WKNJQcOSXXOCi3L7edfHKOv8a9dywj5TQs5OqPGlDeWI5KwLLdO7xHVu3QYftzLEdO58VO9RQNKB9OYTmqHLxGm7rkkyN+0kxhBELG4DZV8BdpUGAYGW5HlWUq9kUM4xbVlg/uD+uHareVeoHbNFNOuH0R3B8xtUAttUPuGxiGqQPYsMAUBg9uDMPUAtwXMYw9LB+MU7itMAxTK3B/xNQC3A4ZhmEKwr6sM8MwDMMwDMMwDMMwDMMwDMMwjAk2LDAMwzAMwzAMwzAMwzAMwzAM4xg2LDBMsSRUIBoB4tFqnwnD1D9CnhJqtc+EqQT8vBmGqSe4z2KmOolYtc+AYRoLHlcYhpkisGGBYYolrgLpJP1lGKY0WJ4aC37eDMPUE9xnMVMdVm4yTGXhcYVhmCkCGxYYplgCIcDjo78Mw5QGy1Njwc+bYZh6gvssZqrDxWoZprLwuMIwzBTBV+0TYOoIRan2GeRG0/J/brdNMfhDxiTcyX6rdf9q/blNFdy+z07baq0/X6fXEQjTi5mamNupW89b03K3sUaTy1o/bq3fv0ajWvLhNk6uo9Rrled8DFMMtS5vsnJTUUo/32r1B8zUxu15hNP9ud2eFcXdtQ/PrxiGqSIcscAwbsA5EplGhds+UytwW2SYxoBlnWFKg2WIYaYuLN8Mw1QYNiwwjBtwjkSmUeG2z9QK3BYZpjFgWWeY0mAZYpipC8s3wzAVhg0LDOMGnCORaVS47TO1ArdFhmkMWNYZpjRYhhhm6sLyzTBMheEaCwxTKAmVPAACUr5dzr3LNCqi3QuvGJYDplpUux+WxwauF8I0GvFo9tyoXFRb1hmm3qmUDFmtmRimlpkKbZbHSIZhKgxHLDBTi0rkFOTwQqZS1EuOTJYJppGwk0uWA6aRaZT2Xy/jMtM41HKbbJR+gZk6lNJmhSwyDMM0GGxYYKYWlZjAcnghUynqZUHGMsE0EnZyyXLANDKN0v7rZVxmGodabpON0i8wU4dS2qyQRYZhmAaDUyExU4tAyAhfdEqhIY8cXshUimLaczXIJxNTIayYYQR2csljQ+Fw3zB1CITdfYa12jbqZVxmGodabpNujIucZpCxolxjRCltNhACEin3zoVh6oS+vj5EIhHEk+lqnwpTJdiwwEwtipkMyJ4+tbR4ZZipoqhkGWOmElNFLmsB7hsYO2q1bbD8M7XGVG+Tcl/AhgVGUItjhD8EhJuqfRYMU1H6+vrQ29sLVVXh9TfhiG/eUe1TYqoAGxYYppY9fRhmKsAyxjCMFdw3MHZw22AYBuC+gLGG2wXD1ASRSASqqmLZsmVIpIG/rqn2GTHVgA0LjPtomrPtFMXd/RVLpTx9yn0ddji9z0xlqDf5cON4TmTM7fvC2KNp+e93te6zk3ZQSBt0u13VqlyWC7fbgXl/gTB7oALV6//cbqduykchc7NC+418fWC15JzHt8pQ6/1zLYy/TuYJbpHvenmcYKzIN0ZUS86rJUdO4fUWUyZ6e3spFdKazdU+FaYKcPFmpvFIqEA0Qn8r+VuGqRa12G5r8ZyY+qWR2lMjXStT+0yV9jhVroNhyo0bssLyxpTCVGs/U+16GAbA2rXrqn0KTAVhwwJTHRIqMLYFiEcrf2yRk3EsUvggLudzrHXEJKUa95ipLcrVbhMxZ5Nhq23qSZaY2qdW25Obi0Wxr7GI9bXywpRxm4QKDPUBg3327arcslepdl2rfQhTG1SqHVZzfeSUsQgwtpn+FgvLG1MK9d5+zP1Jvuup9PyuHvohpibp7u6Z/H/JHkvQ19dXxbNhKgkbFpjqUM0JQSAEeHyAgsLPQfy2HvI51vuki3GPcrXbhOqsnVltU0+yxNQ+tdqe3OyHxb4UWF8r9/mM28RVYGIUiI/at6tyy16l2nWt9iFMbVCpdlgP/bhi+lsMLG9MKdR7+zHLeb7rqXS/UA/9EFOTzJs3d/L/mKoiEinBAM3UFVxjgakO5S64JBSegRCAQOZ3IidjxjYOqVQ9BjfgolZMufGHgIA3fzuzaov1JEuNhNwv1lNO41ptT272w2JfzW3W18p9PuM2gRDQ1AposG9X5Za9SrVrN65D7j9rsT9iiqdS7bCa/Xgi5my7cI8+/yvhHGt1zGbqg1prP7n0DlaY5Tzf9VS6X+D5JMMwBcKGBZeZmJjAxMTE5PuRkZEqnk0N4y+z0kq2tPttBvhqTkoqsfgU11eHxZdYjlwmQx6KaG92E2Z/EPD78u+z1hYADUJRciS3lVowLNS7os7Ntp9vXyxnZaGhxyN/COiYX/1zcLtdq/2A0ur+fksda6cwdS9HpbTDQsaxcq+PcuE0zQqPNVWj7uWo3rGTZSd6B5lCZajSMlfNfohhmLqEUyHprFq1Ct///vdx9tln44YbbsC7775b1H6uuuoqtLe3T77mzZvn8pkyjqhkiGQxOeY5xDAnLEcuU6o8lNpei8kNyvniS6YoOaq18PJC2l6jtplGve4KweNRHSBkQLzyyUK55l+11n/WEDUrR5XoP2t5zi9fPxsLap6alaN6oVR5t5PlWur7eU7IMEwVYMMCgDfffBMHHnggXn75ZXz44Yf4wQ9+gF//+teYmJiApmkF7evyyy/H8PDw5Gvt2rVlOusGpJCB0h8yQnXLTTE55mtpAlKDsBy5TKnyUA3DRFwFJkaAwbU8OS6SouRItJVa8VQqpO3VsvKmnJivmxeVrsLjUR0gZCDa76wP8OgB227LSSXnnnVGzcpRseNGIf1sLc/5Mzytg9U+GyYPNStH9UKpzip2slxLfX+jzoUZhqkqDZ8Kad26dTjzzDNx/vnn46qrrgIA3Hjjjbj00kvxxS9+EQsWLChof01NTWhqairDmTJ5Q8yrlTLDSR7CQnMpytR7KpAimPJyVEvP1Mm5yO01niz8GMXk6gyESEnk83NaiSKZEnJUSF9ZTDur15oSMubrLjQdSy31RzVIReWIn0VxCBkIdxvvcxHqBhJD1U9b1EDPu2bHo2JziRfSz9Zy6iD5+gvxpSul7TZQu3ebmpWjeqEQebeS8XLKslty4eQaWQYZhnGZho5Y0DQNjzzyCHp7e3HRRRchnU4DAM455xzMmTMHH3zwQZXPsMGIR4GxLfTXCuElAFh7CZXDQu/EI8mJl0IpngzseTD1qIVnKtr2WCT3ubjh/Vxs+w8EAaVGvfyY6mFXYLKYdlZOWSxFdkqJ0CvUO7YW+iOGcPtZ5JtXVRu3omuEDIiXkz4gn5xU4t6x7BVGOZ5J0fOTGohCcCPNZLHXX0rb5XbPFIpbsl9IezfLuFl23I4OdUsunFwjyyDDMC7T0BELiqJg5syZOPDAAzMiEzRNw9jYGDZu3Fi9k3MDp2mc3C7u63R/5vPL5/0jvASiEevt/EFSOOUN5XXqkqPURiG+Yr2pBNVqB4w9Tp5pgWnY8mMjbwpo4uwP6tso1tsVLQMFyJv5uN6Afm7Scd2+L43Y7hWlvq/bzdQlGd6abrYtzWGKCZvnUIrcFepRl6s/YnmrDOK+yM+ilHslnlul5zBO24tGjjyIR4F0iv76mrO3U8ro/5RLTjSz/Jbp3pllj+XNmmq151z3LxA2otzcfm5O9+f4fkj7cyv1USlrk3K3e6dMFfmoFm6vL3PtT263TqNLS21X5jHCLDsly5Lp/DL0GPJ3ZWinbq5DWY4YhkGDGxYA4KijjsJRRx0FgAwKiqIgEAigs7MTfr9/cru//vWv2H777bHnnntW61SLo55C3ZxOUu22kyf5+Yj2A9EBINxlhM4Xc07i/vqD5UujUcsh1Exx1MIzFRPYptbcHpsJlea3AR8w1AfE0zbbxdyVg1INaszUpdqy4xSzsTuuSnJS5DgH1Ne4zhRGIfMYR/ur0X40oRqRRx5vplImoQLqAI074W7jfpRjnMlFJe5dLcwF6olabc+VwKrfL+Z+OHbCMiHkTxDQvaKLwY12z+NgbVKu51Kq7LtxXmbZKVaWZOJqplw5mR+6AY89DMO4TMMbFmQU3eKqKArC4TCam8l76vLLL8dvfvMbvPTSS9U8veKoBY97pzgd5Oy2kxedgPS/RS7K6ACQngCGN+j7tBnI852TuL+JWOZCt5AFsDzZEfvkiTLjFvEoGdIUUF7pgLQgFRP1aL+1DCRiRtQAAEyMAQkLw0IiZi0HGedho1QVn5vbfD7Z40Vl4+JmgclcY2SpbUzImCDaDyTGAH+Lvn+Ldi/I1f7dqjcktourgC+QvT+WsfrH6byq0DZjt534XmC7XYwiFTxeGpfM38XH9P9DxpjiZJxxE7cUL8XIEcueNfWgDCvX83ZrPWcel/Ih1jPRAZLLiVGgcx59V81nUU/r20aiXM+lVNnPd15W63bzZ4XKjhWyrGsaMLSeasklE0CwzZgXFrIfbv8Mw9QADV1jwY5EIoGBgQHE43F8//vfx7XXXouHHnoI2267bbVPrXBqIQdoPorNUZiV6zBGE96h9aTAEQtQK8JdgKeJQu9zbZfv/MT9NSu65AVwPuTJDuc8ZNwm2g+MrKNaClbtMVdb9QcNo0Jc1esdtNhvl0vha3cc8XmhbV7Iylik9BzDTH1TyvPMNUa61R8L411inN4rKL7dAw5yw9ucd0KlqKPBPmNRKqdDM++Px6PGwfys7WQqX5sQ34s5mN12/mBmpEJCBdR++usP0jgjDHDRCCl4nIwztYjVPcvXZ7HslY9yj//FPDsnv7Hq950eS4xBYjvz+1yIsSo5DowPAYkoEBup/rqyHta3jYaYV6Ti7j4XN2Q2X3uxWqOYPzPLTSFrfYEss4kYGRUmRgBFA5Jx5+MbjxEMw9QYDROxkEql4PV6HW2rKAo6Ojrw9a9/HR988AEef/zx+kuBJKgH755ivRviKhkSogNA51wajKMDNEhn5I2XUPuBhL6Ynb59phe1ed/CayDX+fl1jwMxqRBeDoWER5rDOysd5i17PVTCC5BxjiMvtjzRMQrIgGZONyEQbRWQIhf0/Yi0HNEIeTQHQoC/A8DyzH3IHqXy+8lzVI2USuFW6+MX2uaF3Chxw8AgvIny9SPF5Gplape4SguzaD95UhYyjuQaIwMhavvJOBDIMT5ZRZ3JkTli8elv1tunFFVXTF+fb1y3SxkQVynqCADiUsSSx2YqWEjqAfaeqy+snldshJwuAPt5T742Ib4XKSbttjO3YRHBkIhRBEN7SDeEbaA5HUBpV6z6azEGWrW9DNkM5LwlrmG+t1b3LN+8t5FT/hRKoX2PkzVHKfPiYp9dbITGCESsr8Wq33d6rIxon1D2+1yIOVr7bHqvJYFQF51LOfp9p/ush/VtoyGiH8210dzYb6lREPnai926XR4XzXLjD5JeIRnP3I+cKUHtB5RW49iyzIoaBorXuG+55DGjX6rSGMFzPYZhbGgIw8LKlStxzz334JxzzsGsWbMstxH1FQCKWFAUBZFIBM8++yx23XXXSp5u41Hs4BgIGYaEuEqLzo45FqGMSeM3IxuApibyvA530XbmGgtx1QhNdHJ+0X5AjdDEoGc7QxnrdDEiBmZxjGJzlhYLK1lrC3nS5mgBHDM8RDNSHunPMtStT6iDxj7llETiJUf5mNuBE0OZOU2FbPCQUyqZ5WgytFjJvn4ni0qxvTAwOFl4sNJmaiHarxgLXF3Qjuffr9lzzEphIxan4e5MGSxHui+7BXQgBDS16DVTpG0G1xnjXbH3jtNS1BdWzyvYZnxv10fmVc6YDQa6p2ne/lwaY0T9BeHNmUwALaJOiYUhXY7+MR9DjmxTLNJiOqFUxXUxCuFClaaNrOwp2FDgYPwvZV5crMI72EbjhEhLJ85DPFOrZ+w0ZSRgGJCj/cZ7R85P0nrG7AjiZr+fLzUfU/uUa25dzTm7PC76g/o6Kw5E9c/i4wCSQGwQaJ2hj0/SWGOWjwyZ1QwDhRNnxMmIwIhhtK50ylie6zEMY8OUNyysWrUK++23HwYHB9Hf349LL70UPT2ZilvZqAAAwWAQn/nMZ7Dvvvti4cKFlT7lxqPYSbg/RJEK8mQjn0Lf2wwkY0BsLNNwICMvZlulc5PDDeWBWgGFCPuarZWyTihloHYjDzgrWWuHjAWtg2cjJrrjg+Tx6WvWJ5ymqAPonjF2nmq5JrayXMmGOvN5TEY+RIzFoWxcyDdpTqi6klMfmpzkezcbGJy0Y/Z0qx+c9G/+EEUquN2PxdXMscAOq6gzc1uXF6dOc8WbDRZ296EQY1zHfOfXaDUu2R2Lx5H6wvy8zO/d6iOdzm3k46n9NJZpAJpayagg5CTaD8THgECLvbLT6jqF4TkfVu07GqFIn6aWbPmx+i2Q3/PU7TGokZU9hRoKwj2153wgouNEOpSWtuxnWswzFr/x+MioLRxIxPt8v03EM414Yi4oDIaAe+mIxLnapeYrlkY2ulWacs2tKzFnt5qXmdcucrRPdIDmdclxWrP4m62NdU7asvg+2k/jn1wPTziiyEbRZNxZna1yGOl4rscwjA1T2rAQjUZx1VVX4aSTTsKee+6Jz3/+80gmk/ja176WYVwQRoWrr74aqqriyiuvxCc+8YlqnXbj4qQoYDRCi80W/fmZt7csviQZBNrnAOomUr7KXnAyYlJgNiqYPVLl/Qa7gUDQmfePFaUM1KUuKMWETTKuMVVEbgtOJtOBMLV5LQWMbabImVxYKfllD2pA94YxpVYSsqUFsvdpjk6QF4dyZERctS8ULc7D5wOSSWdKTmbqU4xiMh9WqYvM/wtvMICi2kV/b3UM87H9IUwa8gRyOL1TQ5vcF+S6D6XIRq5rtBqX7JSsbKyrLyzbLHK382LIN7dJSGOPMBAnYnravC5k1fRRTH+B3A4lsuE5Omp/DnZyllAp0jWuAp45ua81Q4nrYuSpE8VoIyt7HM2TCrw/pc6LC1Vmi+OlU5isxWNn/ANyRwFZRWeIsaaQNK3JGODVrA3gpbT1aITmgeHuzN+Kc21uK67/sbvnPHdknCCnNfLr4QhWaWaFDIn5nEgRZkeoG/BL6raMdirJodoPjKwHfE2Z8085Ik8YRQN5HKlEmxeRf/mMiFbkc+ZiGIYxMaUNCx6PB3vssQe6u7tx5plnYtq0aTjrrLMAIMu4MDAwgJdeeglr1qzB5z73OXR3F9EJM6WRb/IXVzPzQwOmGguSJ4E8EU5KRZUCIUDpot+Eu7I9AmQlqLxytfJInVyEpmhbOf1MoeRb1OdapDTygnIqUsykTUxORZ7OXARCmW0lrlLqLy2pF2duprRF5sWkkK1UKnufstyJybkmndfgWhInDUYUg/idbGQQf1uLaOe8eJyalKN/y2UotkphEo048w6z6p/jKi0WUymSLXRny2CufZkVJJOLTQvlUSBUvELL6hqt+iLN9JeZOpSjD7VqQ7KTSFI3ivtbgI6QlDZPN5ALr2iAxgo5tV+h5xGyGRvl67aa63n85I3qK8AQ6CZOnot8n7luVjaVVoaJZ1ZI7adAKDO9q7kdOR2PzMZff4icP4bW6gY7C29oK2cPX5AifSyjWEto69F+IDWuGxckw0Kpz8hOTniNVH9UMspEHEsYt+VizFaRpXbzNzmdrJwKKREDEhPGtYh2OriOvhcpMjWQUUEx1cOzisjLJyuyQTHfmtDufpQj2oFhmCnNlDYsBINBnHfeeQiHaUA444wzoGkazj77bGiahv/93/9Fd3c3UqkUPB4Pfv3rX2NiYoKNCtUi3+QvEMrMDw1kTsLFYlNMkuNRPaxQNfYRV0nBKaelAOzTwwjM6VbEvgBg9EMgEQWgAdMXZf82V2HBjO2K9Ehl7wFGeGz6o0b+z3jU2svMvIgUqb9GB4HW6SRfVuG8QrYUi0mqLHcigmJilAwWigaoAzRhDvcYeX7NdUwA+7ZstciQZVHgZvg8Uz1yKdcTKqDaeB47xc5QbP7fbnvzeSZUUoaa++exD4G3/gGs/A+w7gWgZQZw/r+Blun21z241rreQYbndSTzmHJqD1npFFcNI3o+r1KnypeWHkwWfnYKKzrrg0op4OIqENedRFIJwOs3/Dgyai3ESEE6+iGNTYB9AWcrohFn7T9XlGAgBLRMy4yUlTGPQ1ZjlBPPcidKonzPxUohxPJWPWLDNP9xqpzzhzLTuxarKLcy/iZihswNxygqwt9McjbpSGIx7gVMayUZ0d5a8qSWMrdzkZJJeFG7pUS2uy+8Rqo/4iowMZLpOOgm5ig14aQY7spc/8jRPRkZEaz0BDbRQNF+INicqTtQ9H17Pfpxuw2Dn1U9PHn8cpoe1ElkgxWi33E7JRnDMFOeKW1YADBpVBDGgzPPPBOapuGcc86Boij40pe+hKuvvhpr1qzBrbfeiq6uriqfsYu4ndpGc9lFUUtnvvc163UKVGBsCyi1UAiTK05No4myov/vD1Gx5mi/PtCOZXqyRfuBxBgA6TgJ1chdKkclZExI9c+s8vFOjNFxxiI0mQ60kBeqliAPHM3Cm9upF2BGyLLpXmdMWMR3Dp8vpzgqDTfbvewZU44Fv1DqW3nZaGmjLWoaLSoBkjlNA7pbdO9RGAtOWUb9eqovucaClgI0Rd++2fjM16wb/XzA+CjgbSIP1FAXyYCqF9pNJeh3mpa7OWfIUDDzs9gIGQozcgaLjgKZiwEg0wDi1OgHsByVSiFy5MTIKlD7AbQUtvgRbVl+n/W/Zr29fGwxHoyPAcF2oDkAfPAUsOphYNVDwKbXM487MAbcciZw1l8BxUP7bG7NvDZfABgfofYcjxrXJU4nHjXyz3t0zzbNdK7C2y6yGvB46P98ofAZ90R+VqZ2X4ySphhP+Kkib07bvdPrdXseJmPn9e62UicQAhK6k0hYGJWDJBOBFhjpjxQgOkhjxdgW6rPt6iRY3Zfh9UB8lMa15vbMaDstbYxvYu4pPpfxNQPtczN/JzMxRvI4PkqyLN4nYpR72+Onz2yjcB0oz5zKXL0qhDTNvXZdS+ueYDuQipscNaT9WTl6iH5Y0/Q5W0yfI0ntTm6v6UTmMRMxOoY/DIQ6jO99AZKvxASQHKXPkyrgm02f+wL6uCIdR0vT+BaPSesx6dzlCHK79qmlgIkotcuJKDmYhDrpJX+vpYrzjLZzQpgq40etU65xKxCiNbzsOFjM/tJJPb2eMKTp+5kY09tkmj6PxulYWprWKQJfk7GfybmXtH6SEWuZuAokJOcXBXo0eTO1da+f+oT2IKAOGimVzJEQdg6PVushO0RfElfpr3lMsOuDEjGqb9TUkr1PK9ye5zBTihUrVgAAenp6MH9+jjpVTN0z5Q0LAq/XC03TkE6ncdZZZ0FRFHz84x/HP//5T6xevRrPP/88mpqa8u+IcY5ZoSfSowgFR1zNnqwCNImNj9GA2zGbJsiAPjnQJ7IiZFFY5NMpfQJu2lcyCUDysE6OA2grPCdoQqXzSY7TBKWphWo0hJuB1tmAd9CYKItrE3lShbI22J77GJOTYosBOlfqDKZ+EBNCu6KtIspGgXVqLasaImbyebONj+oT6QF9P/orHqM2jiQwPE55Qy29LGPZn2WdQ5B+LyangCGz4n/zZ7mw8gQy5zm1qxmh9pMh0OsBmruMVEyyESbfgpY9ritLvjYcGzH+zxVpBlgvnHKlf8j3Wxl/M9D/PrDuWaDvWaDvGWB8KHObWbsB2x4BzNoduPfLwMZXgTsvBE6+jr6XDQtySjM7L1Jx/fLCNqFHTch5eUVEUFI33ol0ZHJRwErBqShqB6cGAztjkBiDBMUayYUTSL4xrn0WMLwRCOrLFZEzWj6+P5itPBrbrCvZvYYS1oy5voP5O6FQBayVq+L4iRgpceX3ZuOf1bHjqmEYdyPdhJCzYnPUM+4QjxpeySHhla+3WXkMGl5PSkb5c5l8BqWESopKQSBIhrhElAzKKoDEBgC684cvCDS1kTErMQH4dSW/3THUASAxQg4i4nwmzy1oRJA7UW7mquvgD9LaqpgadeVI38aUF6ce953zcs8bnI5liXFDp9A+i96PbDKMXIlxY/1uZTCYPKdmXW7ktUZMGq/0dh4fBQa3GNs0dwJ+r9EHTNaeC2bWi7RT8MvOVOZ9OCFXRgar70rRN3ChdMZEMBTC0qVLAQChUAgrVqxg48IUpmEMC4BRpFnTNJx55pn4/e9/j1dffRUvv/wydtlllyqf3RREHrAAw7tl0gPTZAwQCzmAlJ9akpSfHfrC0x8C/C00WTcPWLGRTMW+oHUakJQs5F5fbi9Y8V1C98YRi9S4Cjx1LTDUB3QuAGbsDMxZTJ7YUPTJuazoGafJxdA68r6zCxV2exDmQb06FJrSwG5CKIer+y2U2HbRCObzAIy/4nxkw8HoJmNCK4wKwxvou/ExSv1gZagT5+AEoZBJWihurNLbJMZzK3rlaxMTX9ttpfukgaKJlObMgtKAMXHPN4mW+wc2LJSffAoVOZVdrgVWXM2sH9IxR/eWzpP6TpBrO7UfeObXwAvXU9sUNHcA2x5GxoRtDstMe9QyHfjLKcAHTwIPfxc4/meZ+5zMxS1FHch5scU9CbbRmOcLGMdOp+h/cX0+P4AWoKOLZFuN0Ln5c8hNIRSa5oXHo9qg0AhKO0WEUIjnG4us2odsYBf7lNPopZN6xGmMPEgDzYYCUyjtRYRAIkZzyfeeADa+Amx6kyKFxjaRQWHXM4H9LqHjxAYsrkWPLrBycBFzVCB7viqYdJwZ1Oem+vvxUTI2hGyioEV0UrjLPZlkOasO5kjUaD/N4wIt+vtI9jiSiJFRIZXIYXiyMGYlVFL4i/ok6RTto2UaGRUmhugzxQuk08DEMG2rtdO5eHxAm53TiJqZOlYdAoIBctBqMZ1jroLpZsRccNK4Yt5X0N4zOp8zDRut6w+nY1C+/sxq3W6VMjURk8aLcWB0I63PFd2pQxQht+qrhVMhoMupyeM+Y46oG7nVQaA5DKCftgk0A7HNRp/QPsfiOA4U/GIbMee1MlZaOcLkMuzZGS/yOd3YwYY+xsTLL72M0eEBrFixAkuXLkUkEmHDwhSmoQwLABkXUqkUvvrVr+K///0vXn31VTYqlAvzgGX2bhERCwKxkFO8tCCLj2WnRxGTbL9psEUys0iz2DYeI+8dgWITHm6VczudpEmILwg8+iPg5Ruzf+dtAjq3Bnq2A3oWAtN3BDq2AkI9eh7sGJ1XU9h60uP2IMyDenVwa6LsD9LEU1ZQmL+3yvkp2pQ5PZBQxI9FgJieUmJ8DGhuocViWF7w6UaF1pmGNw2Q7bkpInFs70WMFr7mYs05PYr0BbLabz2plQ0uCQdKGHnSrQAIdtP5m6NAnC6OefFaOwRCQEJKaRLqAhAnZY45N21CzawfIi/aZK9/q0VUXI8C0AAEfMb+vQHgrTuBB68k5SVA/f7CY4HtjgDmLKGFn1Vo+Jw9gFOvB277BPDWHUDX1sDh37C+RpEKYLLdS2NfQgXCwsNOWkCbI4JadDnQkpSyzGvjPV3MYjJfn8djUW3itC+zG6tyRYrJ5Hr+4hwAU60dvS8WEUm+gG5A8+nRpyD5W/sUsP4FYOB9IPIOEFmZnaIIIC/ol/8MvP43YMl5wHYnWF+L1TWI+aMY96L6mJYwXU8iRhEViTEyZHibKN2DHIlkRSHRBewwUtvIOdo75hjrFqu6IZA+i6vkySzvZ7JGXMzamBWX5kLJhBHxMD5KBrXX/kqK03APEOyk+WRzO71apgMd8yjKOtRF8yHFY+w7MU5jhSDUQefXEjTGHWHUCJvmUnYGAOHRLQwpCUmmnJDPmYaNafWHW/Npu3W7POYkxqnd+Zv16E0NSGvkOJhKkVwAJAfxaOb+fU26k2DU2FdzW2YbNst2IEjHGh3M3JdV3ROBPNcMm1JjyhHs8rGsDBGqmC/6dIO1g/mc0/RLTuG1EmNi3ry5aN52QbVPg6kQDWdYEOy00054+eWXseuuu1b7VOoDEdpbyMJGKO3EhFMOCfYHs3M+i4Wc2CaZAELSBFREEUQHafIue2LHhgF4je3EgjDcDQz3G/vwSxNkszelfF2BEKCOA6sfAl65mfJmQwH2vpAm1pF3gMi7tHCNvE0vmdbZwCH/Q0aHphYyToxFDI+FzvnGOSigyUouzBMMq0E7IU1OWvLsj3GXXJMpua0BmZ5tAjm9xGTxLivvLEmmzAVchddjXM3M2RlXqd1pKQBBUmYCmcYDfxCAT4+sCWbKotlzUyiBAPLMCUyTriMGDKzWPXb0lGMiFYRd2gkhr8IQYTepFSldnIT/ipRF0Qjdn3CIzkXcN6v7a+4TzO85UqE28IcAv6mWjVgMDa3DpDYn2Ebtqak1Mx2XIMPr3yZE3BvQax2o5OG2/hXgxT9QOiOAcq8fcSWw40ed545deDRw7NXAv78CPHENsPlNYM8LgG0PJ1nJuFbd0JiI6QomNdO4IEdKiG2A7MViqIfavzx2RPuNYoWAwwgOSSbyLSB5gVlbyM9OpIIsRWEt16kZ6stWNuZ6/qINRyNGuq4Wk2yODxvGv8Q4Ke6f/Bnw6i2U5shM62wy6s3ZA5i9hFKQrX0eeOJqKpz+/O/Q9NKNuCy9N/6lfATQjsh93fL8UniimhW90QjVUtm8HBh8DxheS/PCnu2Bs24F/BZe2MU8h2KMdJy+r3IEQnpNKb+x1hGpvnL9xqzEE3Xh/C30WzkSW47oDuhOWqEgsPktYMU/gTWPAf2rjf1vyTpiNu3zaJ2y3ZGGQjQhGehCXYASz5wLZjh4SO3KHKEuK0Djo1QjxddMxg45DaeMlXFCpLNMxgFEjHvHxoT6xS1jkNW63Tzm+JtpPRIbpqnhbR8nQ7TjY4RpLdPcDgQ7KOoz1E3vvQHAF6LPw9P0SFoPMLwBitKE6VoUEwhQu25uR2YdKwkx10zFqa2LwubRfmBkPRmr/SGjuLP8O8BweknouhDFI0UTWvQzMmanknxpy/LeL5ZNhmlkGtKw4PV6ccEFF0ymRmIcUIr3oXnCKf43D1yTi81+vQCsrsCUFSjJhD55l89D0b0A9OcZ7QdW/ht46x9AcgK+aTvhQK0by7FQP4f23Ncz9AHw0k3AK38Boh/qh/AAx/yIFECCdIoW1JF3gC1vA1veoVdkJTC6AfjXF4HtjgL2/6JRpCk2RFET4p76dMVVhkeShfdoVoocm8Wn12J/TPnJNZmKq0aBRn9zZo5/gfBMTiUlz+ocygAhUxoyizTanUeghQxcwS5jMaelqUhsaoIWbek4MBoBPFvo8+S4HlKv6PVFVCA2BN/oFlyafg+t2hgCf0tQ4fLYEL0CIaB7e0oXNmsxsM0hhpwnYmQYVAcz6zckYpIcSJNaWQ4AmtwnE4b32+S9z+GVY54k5/J+M/cJ7HFdu8gKdcB4zqlx6qvTGuDpIu8vS8WmA69rodBITACrHwZe+D318wAtNg/4ArDv/ytuAbbkE0B0C/DYj4CV99GrfR6lbVn8cTI8i3MIdQKRQVJarh+hopvqADC8DmiZAex4Ml3jWIRkGci8ZruUYdEBID1BaZJCHdneclbIMhG2Se8n4AVmbWHVnxWlsDb1oaJfB3SPfimCLt8+5cgaWZGYiJEzhi8ADH4AvLoMeON2Iyo1EAZmLyYDwpw9yKDQMjN7/9seBmxzKPD+Y8DjP4Gy7gUciSdwpPYE0jfeDux1AbDoeBrrNBhpiQQTUV0p+iH1OR8uJzkcWA1seA0YfB+WLqib3iBjRu8J2d8V8xycGOnMxol6Tt9XbxEa/hA5O8lKcTule64UJXKkQ9IUiS1HdCdUkocV/8xUknoDwK5nkJF6fJjGidgAjWPqoPF/bJBew2uBf36O5mqHf4NkJWTKMR8dIGNHooXkI2mOPJecYjz62kaOQhKpYbx+PWJ2kPYXaAECppQwVvMzObVUbBBoncFzMiYTK2OtwB8C/OOUBnnVw4UZFQAgEaXX6MaCftYE4C/ijch4GWihNGTi1Tqb0iIFu8mIF2ijqFJFIcOdAoqaEM5ZZt2AMEYKmfEFaftkgtZ0YcmhxmyEkHULcrRVrhSzDMMweWhIwwIANioUSqHeh7LniZVyb/J/KbpATBQDQZq8xmM0qU4Kz1EvDXxqv8l7s5ms85F3gOd+Bbx5p6GEB+Db+Aq+qf+v3TgXmL8PFdKcsQvVSQBIgfruA8BLNwDvPojJxWLLdGD3jwOLl1IIsYzHS97f3dsAi47NvPbHrgae/TWw6gFg7TPA3hcDO32UPBtE+o18OYzlRYjwXE3G9Htm4XHNHqK1yaQ3my8zx78sI6I78jXnL8oVj0phsxYFns34Q6SoTCeAD98G1jwBvP848MHTZPAoEB+Ao8Ubs+NoMkbyufZZ4PVb6bPWWcD0XmDmrkDLbGDuYiAhFQyU+wd5UitPmP1BwyMwOmB4m8teOVaYF/g5U1+Y5IflqXaxSq0y2W4GgNauzMWU+RnmWjyJxZuvGeh7Dnj6WooqEMfd8wLK2R6eZv17pxz0FaD3JDJgv3YLKXmeuIZq+XRtQ7mx1UHDWGDHkz8Ddjkd2OZwSmPmdGoT7qLiockYkNajOuQ0UlYGO9sxq84UgY2I1bMrpo8z96H+oJHmUkScOVX8WaWiC4TptxteBp79DfDef43vZu4C7KPPpbyBzN9ZpR4DSEmzzaHA1odg4oMX8fjNV+EQ7VkENr8B/OvLwIPfovEpMU4eo8kJPUJXVyjlo2UGndeMnen1wZPASzcCL/3J2rCQ7zlYyZITI43ZOFHP41ehBq9aiM7IlVbRbt5hHof8IWqHwjAEGHar6Gbg9duAd+8jByaBx08OHDueROn4gh02J2jODa+SfD11LdUmufl0Mmwf9HXrn4nadu0hI/oUMNYrHh8pdc1RSP5mciQR6THjMQB6YXO58G1Ti/19mpwfBzMdaZjGI1dK4bGIIVNyv+FvpiiD1Q/T+/0+Dxx8Wf5jJcfJmDU+bBjjxofJiWp80HCoio9hMu1xYhxIxqDFY0hMqAggYewvPkaGjVzGDW8TMHcv4MRr9SgH3aBnNiJMztVUwynEH6TjB/2GkR+wNkLIugU52qpY2eI5YEPT19eHFStWVPs0mBqgYQ0LTIGIxZ4T4tFMj5VwT+aEW/yvpWGZR1RMXoWXiiiC1yTCi1WjUOXEKPDG30kxM/CecYzOBcDu5wLt85Dsew5rXn4EW6MP3pF1wJvrgDfvMI41ezF5no1sMH6/zaGUk3fhMUYO00Lu1ZHfJmXPvZcC618CnvgJsPI/wNE/BLoWGMfOSgmjLybMymXLiUE483dW3hpM9fGHgM652ZMuuaCfHDovpzqyTNkjpWgR+7GazGkatev3HzdeasT6HD1+8g71BmhiO/m//gqEKYS9uR3JQDtueqEfYwjjsyfti0BrN4UHBzvIC3vDK/Ra/zLQv4o8fUY3Aqsf0Q+mAAsOoMK1bbOtz2cyBLgZ6JhL1yeMiojrObg1UgSJNDeCDMWohdLKaaFR9riuXeS+UR0A0KL3f91Gij2rRZQVZkV6IgYMrgHu+x/quwFqB3t9Ctj/8xT14xY92wPH/BA44grgzbvIsL3+JTKSy3gDlM5I5MUOdgHBduC9x0jGX/gD8PJNQO+JFEVhNoJbIe7TxKihBIqrppz3pvtmJxMc3eOcai3ArZ5dIX2cbAiX5xlynyrX/DHj5LpTcXIMefY68voHACiUPmyfzwJbHeA85ZgZRYE2ewmu8VyM32lL8ddDNsL/6p9JftY+n+e3HnLsaJ1BDinCkDBzl+w51+zdybDw/uMUbdG5Veb3+Z6DmBcUKktmQ4LYZz06URXsyFTF6Axz4WYrMuYdNgYwgPajiYiwLnIgGt0A3PV94M3bjToiHj+tUXY8mWTD1piQA3+IjNu7nwM88gNyBHn9b2hacQ/OSR+H2xXdKBbqIoW+VT08Od2RbGgEjCgkLWV87g8CQRhGBnWA1lexAVLimvsWgXl+zDQuVnMN0V8oceu+0x8C0h+SwxMA7PFJZ+0oEDZSOAsc9qcT8SROvvphKFoad39pfzR7krR+GdlIMj2iv0Y36v9vpPVZaoKM0zccC5zwC4rGm7wOCydNsRYUfaWInBL3yc4IMXmNocxoq2LhOWDD0tfXh97eXqiqilAohJ4e1kM1MmxYYNxHFBBKecnjPx8ij2hWkdgYpWRpbkNGbYTxEeD9J4GV91Joo5i4+oI00d79XGCr/SaLkiV3OBWXvPYQgloMfz+jHYFNLwPrnqdQ9fFhvX4CSFmz+7k06ejelgbJUpi5M3D+f2iR+cj3gM1vAH/5KCl+Dv3f7ImNGJjllDCAMSmI9uveTM3ZBZ54QC8fbiiCLJUJwUwFuDl0PiM81cbrXniLyc/+3QepuOz7TwAj67LPY/6+wIKDgK0PAqbtQKGzcgG/PC7PyXgSf3vpIQDAZ3qPAALSMNK5gLxtBOMjwMbXdGPDy/R3eB2w5kng1nOBj91AHp/plN6+pegExUPnIkcQRPsBpEgR2twGxMcB8yPJV+zPCpah6lGqfFnldXaSK1YYFERKOrGPFfcCD3+LxgbZoCAiFNIp6/2Vgj8ELD6XXpvfosXmpCGhC/CHYSmX6RQZrJ/5FbD2OTKYv3kHsO0RFFWxzaG5F8IZSiBdvqxy3uejnr2jK025+5pyGS6c9Ku5vLZzXffG10lx+vrfjPoJ/hCw2znA3p8Gurdz7zoAjCqtSO1zCvwHfo7GouF1usd0mP4GWvRr0f/6mu3lyFw0unMBsM1hFGnxyl+Aw68o7OSKlSW59oqds0G9UKhRv5r9j5zq0jxXy/Ubq6gwOTqgfzXwxM+At+8x2tg2hwE7nwYsOs4wJmgljkets4CTf0Vpwe6/Asq653Eebsex2n/hWT4B7Ha6RYSg7hkNZDtxmOuA+ZqNviM2QOu0xDiAJAB9rZNKWPctZmOm2Ke4Z+wh3VjY1SWU+z67fuBlPTHRNodlG3vLiKZ4dJnwkZGiZ2HmBvLaKzkObFkJ3H0xpd37+8eBQy8nozpgXFciRnO12KAeETTX2MdkxEYOIwQADK2lzzSQPNvVbnQKzwEblkgkAlVVsWzZMhx00EGYP38+xuMl6s+YuoUNC4z7aKDBTizK8hHUJwhZRWIDZHCQi732rwJu+6Se21Zn7l7A7kuBnU4GmuyLFseUINILDgYWfUQ/zzSFJK59nryeFx1Lk2A38XhJMbXDccD9VwDL7wae+SX9Pf6nwPZHGduKgVlMCIRi2d9M3gxIkWe4OXyaB/TyUi5FUL7Q+egAea8Nrc9csFoZIQIhWpw9+E3gud8a33kDJB9bHwwsOJC8X8wpJMpJcxsde+uDjc82vwXc/DGg/10yLpz9V1LaKjAWl+GuzMKycZUMlqMbyVuvKUyL+VSKPje3/diI8VsnsAxVj1LlSzbEysa4fIiIOI+XnrvHCzxwBUUNAMCcPYHT/wh0zC/8nEphxk70MmPl6OrxAjucQK91LwDPXEeKqNUP02vGTsB+nwN2PtVa7uWxRHi0KV6gY3phslCIIrDRQ+bL3deUa7wqtagjkNkvD64B3robeOsOKToBpOjc+zPk4BHsLN3BIxeKJ3Nscosln9ANC8uA/b9gKMGctP1SI+VKef7xqPOUQoVsW26qHV04spkiyJw6M4ixSh0gwzFAchXqBkY3AY9fQ2sEYVBYeCxwyNeoIHm5mL0E+OS9iL9xFwb/8XXMQAT450XAS9cDu51F5+fxG+levH5ShKYSABT6vntb3ZjtyTRETtZA0g0IyXFKDepv1iMzYkbEgvk+meu5iLYNsDNIo2GuS2juT+36gVScshoA1DfXKr5mYNauwKceAO75IjmJ/Pf7QORtil6QZWBkI9AUAjTFei6RlWbN5JA2MQaMD9F3iWZy0hI1FvJh1fdXuw9mqk5vby/mz6/weompOdiwMJWxyzlbbsLdhsXcrA2RPXVEHlhRiDMe0/N4Bo3/Q92GQmRwDVnwh/ro893OppfwAEiO04BnJi559MRVIDUqnes0YIfj9e+imb93amRIxfNv4w8Dp/4e2OVjwH3/S/m0bzkD2P5oKprWsRVdd3ObkXpJ5D0c2Qh4PEB8wshDmrHvPAO62+3AaWi9k+OWo426vU+3FUFOFCW+JprkibQksje/2aikpYCB94F7vmCkblm8lNJ4zd3LaC8eP4ljMk97leqTWJKQ5Gl8mCKT8l2LTNfWwNI7gFvPoULpfzmFjAs9C/WUaM3UnsWCW9Po/sfHSDb8LUDbLMo/nxjT83qnjby/yXGg2ZweKUr3UOQJBjK97NycFDttf7UuR04p9Xpl+VKUwq8l1GVEzci5YgFJ8SD1mSIyLjEujTdjwO3nU0QNAOx9EXDY5TT2yIXCAVN0Tw6sxiIrPHnkxynTFgInXUse0s//Hnj1ZjLi3X0x8OiPgJN+RdFKk8c1Tf8SqlHLyB8yhm7F6fNw2J6dKj6rNW65jfm4uQzKbuDmeCUUN2LeFuwgxc7EiBFdap6P2D22dApIjAIv3AW8ez9FsAk8Poqi2+lUqksg5nzxKNUGcgt57IpHAbgge1bzxO2PorlldAvw9r9IMQvN1PbtDDQltlPz8y9EjgoxSuTath7GIzdpm0nzKl8g//xOS+tK+TgVlI3207w+8i7w4h8p2lQYFLb7CHDAlyj6GbCuiWWOmLHFWbtKLzoRn/YEcJp2L87z/QvK+heB9S86PAaoPtDiT9C5+0NAS48+p2sGEk007rbN1MdVjeTQHyJnEbogY1+yMlQoMxXQ/QKM+aLlPXA4TrtNPaYeqxcy+jaH/amWBt75D/XF4WnUN1u1l5TDcSa6xdl2HqlPzLVOstMfHPk9WhM9fjUVat+8HPjYjVRHK5GmsXh8GGhty4yitWt/cZXWTMJZs6mF5noadEOfTY0Fq/60EhHebq+jGIapCGxYYNwnV2FMkSYp0EJ1FATxmO6JoA++WgpIJIw0J8PrSAE51Ad0LAA+fjfQ7sArtdbY/khgq/2pSOezv6UF9qbXgRP/jwqwAYZ3NjS6H22zKOSxrc0IVxQL/Ub1+qwkbimdhZLGFzC8bUQ4OWAo1MW2ybjuzaVSoTAtZR1Cv/5l4M7PANEPSa5O+Dnl3a1lOrfSjQvnUj75ZacBJ/0a2OYg63stCrr7W/SJcYj6hkRzZqhvWi8K6PGalMkxw2ASH5eKPnO+3qrjRNEqp0SwTcMSMiJdFN1YrcAwUE3uK0aRQH697ax5nGrhjA9TRFg9yE8uOhdQLZ+Dvwa8/Gfghet1A97JVLRw/88DE1HAoxi5qwWxESDcmf8YuQo858IulYHVNjy2FYc8XpV6L4UCYeA9UoKmxg0P43QSGN0C+P3AeJQ8kL0BIJWk77Q0eUXGo8Dm14EV91BUjUDxAPP3owLmi47LltN6xuunNE5PX0sGvh1P1o3iOaI+3JrTlTJfKcQoxVF+hD+oR3ppuuIOmfdfzPPk+Z0/qNek6geG1lB9g7f/JUUoHEORZsKgUGHiSgB/VU7BWZ/+Opqfv5aKRSteUuJ5vEaaSo/+mVDif/AU9RUPfxt48meUtmn/LwAdoez7oA7QnGx4I9A+i6LGzeOKnPolrmauC63aeULVx39Q6iQeP6YOcg3CuEqKZ6dRdC/fRH93O6fwmonVQlEoumL6jsC/vkypkf7wEeDEX9CYmYhZp0GTC6LLdVHUQSA9QX+ndQFN8wx5E/iD1CeJaPFwt/Xc243oRYZhpiRsWGDKi3miKIzQ4m9CJWWgAsNTEgCig7oFXQXGPtSNCmvq26ggCISBI66kycGdF5Kx5NZzKHJhn4sNJWhiHIBihCfKhZjMIcHyAo+VMvZUU2k1WUwrrRsWxun9+Ch52CfGJYXQOC0yRVEuTa8rEPBm5pR/8Qbgke+S10v3dhQV43I+6rLROhM493aKQtr4KnDXhcCx1wDbHUHfB6QUaKKgO2B4svilRSdgTHabWug7YaQUnm7C2CAv7gX1qswU552ocj7Lct8/OSUCAKg5omqCbaQgD7YZIfMyAT0irrkJeOxq4Lnf0OezlwCn/DYzX209E+wADvgisOcFwP1fJ+XV09cCK+8D9roImN6bKQ+AkZbQCnksNz8PpwpRcyoDu204xYU7lHovhfI42EEpULx69FkyBvxNrwdSKPP2AXb8KClPndTgqlcWn0vytvY5YOObwNb7595eyNRYRMqTXeH2X4hRolypLyoxFrt5jECYHIHUQcCnZvepYp43soHGpcH3gS1vA33PkFORiNgGSCYOuozSocifV4vWmcCxP7H+zqrWUDwKvP534MU/kIHhpRvIuL39UcCuZ1Gxc3WQDAkAtfWmFrpHTa2GDKj92WONApoD+3xklPDFMueIgK5U1ecGudpnvc73GhkxlsWGjbRjYb2wcrSf2oxVnYDBNcD7j9H/i5dW9JRdYe6e5IT178vIMH/7BcD+XyRjtYZsR5uM9GHSGifUSbLnbybDgaxH8PiMezm0HpgYBmJD2XM9uzoqXFSdYRgdNiww5UUMSiKVi1xYCDA8t5tMnpPhTjIujL0H3PlpSh00FYwKMrMXA59+GPjXl4C37wUe+jZNHD7yPVI2x4aBzubMCfbkfQsa91NWHgCslMlFNZRWsqeNx0eKNUAPDR/XC5fr+WcT+nn5myliQVZ+i2KqiRh5jP3ry8Abf6fPFh5LNTtEiHi9EOoEzr4VuOMC4IOngXu/BBz1Q6pJEo/lf0YiSkFMmM2LerGNL6B7tPdY76delZmT5x3Lv21FzqNM908uZj+0HtBMYeWy55XHZ+RxF96kcZMSYngdcO+XyaAFAPteAhzy1crWH6kUTa3ASb8k5c6/v0IRQg9+ndJVHPEtYzsxFtsqYyxyZtsVkLfDiZcze0K7R6n3UlbORfvJwJCKU4RcllFBIdnz+Ch1o/hf8VCqx96T6CXmb05SSNYznQuArQ8hpdbyO8iwkKGkkRxB5L5LidfnWOQWlRiL3T6GBkr5qOh1AwCqobDpDWDDq8DGV4C1LwAj67J/G2ihaOUDvkwGhXomEAb2PB/Y4zxg9SPA89dTRODK++g1rZcMbjt+lMbalh4yFoh7JsaTZDx7rGnS01sKedGS2XPEQBBQvRRZlQunz1+euwNsiKgmYiwTCnCxNlL7gZH1JH8ivbLMK8vo7zaHVrRos6u0TAc+8Q/ggW9SurSnryVdwRHfpvugDhiRQHbRBOEuI6LXah4n8DcDgx8ALd322wisjA4MwzQ0bFhgCkf29gCsPT/Mi6XECHmSBFqAjnn0uYZsr5KEislc6f4m4JYpalQQNLcDp/2JJgsPXkkGhg2vAof8DzB9ZwC+7LBgILtgntXzELB3jkG5lVZW91osYjw+UmyLHLz+EIWX//kEqqOxy+kUqtsxlxTlimL97H0BYNnpuheOQgrRfS+p31yTTS3AGTcB//gcLT7v+xrJxSIH6WgmFZsJMjDEBvV7B917KewsbLca7cINJs+7yiHJ5bh/5hDsQJi8o3x+YGwwc1srzysxBiV0+VMHgY7ZwPtPAnd/lgrXNXcAJ18HLDqW8syWkw2vkBdnywx6tc6k8bBS9J5INVfu+QIVln3h95Q7+7BvANsclt8DWZYjc59klZvXch8O2j8XAXQPN++lqFvz6I+Adc+Tou+8eygP9GR6FNjXWGhElnyCxum37gb2+X9kmBHF5gWikG8qQfPbRjesVeL6izlGrnR84W5M1hHwhyja9MYTgA8tInq6twPm7EmeyHP3BHoWuVdnp1ZQPFRjYbuPAP2rgOd/B7x+G7BlBfDAFcBLNwJn3kLRpyE99V60n+5tuDv3WGN2FpDxh/SIxFTuiA8nzz+hAoPrKEIimaRovmjEUF7zGOUu+ebIWWOZZvzxNdFaCjDaUSBECndRtHnxx90/51QCuONTdJw9LwB2PCm7dpVbeAPAsT8G5uxBqTv7ngZuOhHomA90bg10bwPM2AWYtj3Qvb0hG+bUSFbroYS0jQKSQRHhbZWqVPSFQPZ4xjBMQ8OGBaZwnHjImxU9cZUMC/EYDfxiP0IBCNDnsUHKvax4ydNgeC0pYdw2KkQjFIa88XVg8xtA21zgiG+Wb1KQC0UB9vo0TRhEaqR7vgDseCpw8Ffz/9484TJPyurVG7sclENpJU+Ire61eREj55p9806jYOwzv6KiqwsOIiXgvL2tPXAe+wkpKwItVMxr3t7uXk818DUDH/szFZp9607g35cCnXcA03eg780e51a/B/SoDykUXkyK83nTlFuZWS4ZFOedsijqWEnKIlcW3lBiAZNUAGySjm+zWEon9eJ0SQBJYPXjlHIrEaXUR6ffYBi6y0VyAnjsR0aeXxl/EGiZCbTqxgbxf9ts8nju2MrdRVvrTODsv5Eh++HvUgHdm08jg8MBXwZm7ARA0ZU7Jo9qv7QoBYx+aVLxY2HYtFIWsKG7tsj1PGSPXcVLY9Ybt9H7436qt5caJJ0iT9ZyF8rOx8JjSI4H1wD/+iI5kbSa0j8Jj1OvXjyzlNzwTpx+ap1KpLApZrwyj0dmQ4Ovydh2eB0ZFRQPzedkQ0Jze/HnXY9M7wVO+AVw2BU0Bj7/ezI2/OuLwDE/AWIDgKoASFHEhzCuAdljjSDX8zOn27XCyfOPq4ZRwd9MEeSKRgpeXku5T745sp3sC0cSBUaqRRGlfMenaa3fuYD6Yrd5/zHSIwCUkvblPwP7/j+qpVgudj2DZOqOT5GjSv+79Fpl2i48jYz+7XOBrQ8lI5/ZECf6NJE6NBHT0ys1A/4We8Nbhn7HJgqcYZiGhA0LjUyxk3SzotTK88Os6Al3A4mQ4T0aGwGQNLYFSCEocsm3tNEgDQAHXlqaUWFiFLtpb2GRthr+e/4CbH6N8p2a8Xio9kGpfLicFhTTdijsd7MXAxc+CjzyPcpNuvxOYO0zwEFfA7Y/wjp/pBmrZ9roHnDlRp4QW93rrKiccSOX8lPX0mc7n0bhp+tfBFY/TK+ZuwJ7XwTserqRouX9J4DHr6H/T/g51SOYGK3MdZYbr5+8x4f66D7cfTFwzm20aNdSRrqfuIrJlEciFVIqYXgMArTIqCUvGpbBwpGV2HIe10AY0Ewpi8xejYLYCHlEhruATcuB+75KRoUFBwFn/7X8yoHB94F/ftHwXJ2zJ+WvHd0MTIzQ9Q2+Ty87WmbQwrhzAYXyd4i/WxWX+kwYsnf8KPD0/9FYs+4F4G/nkPfsomOBXc80xq9oP43NYqFpTuWSCytlARu6a4tczyMj2q4L2PQmMLqJttvh2OqcrzpAismxD4HoFnpN/q//VQf0GkV+YP6+lAZsu48AzdPz799NvH4yXt54PBW2ffpa4OgfZG4TCNH8ttRimJMe1n7dGDhO/wNTR86q2XeY1zQi0iQ6QHXQZMPCwHv0t3s7yo8uIwo0lwO1H7j3KxT17PWTMdDjlf73URF2xUefz9oNOPhrlZmXhHuAgy4FFh4N3HAs1Zh4/rfAXp+haKjRYaB1mjG2WKUNA6xTG2YcpwtQQQrSXKn98iGO2RoyFNbJuFH3jHGXQIjWRErc+rnZyb7cVlJxw4P+4e9SZKY/RH1wOYo2v3E7/Z2zB9D/HjD0AXDf/wAv3QDP/l8BtFB5Isln7gJc/Aw5XvavAiLv0l/xGttsjI0A8PrfgBN/CSw+xzqlpZw61B8kXY08FpmNqE6LN7MTCcM0HGxYaGSKnaQLRanszSb+ysrsrNQ9ISAuDWQiYmGymGoLeWGHuoFXb6ZFYutsYPdzC7+2wfepsO2aJ9DUvxo/Ee4r74oNFKB7Wxqgw9MpVPflm4DObYAlJYRMrnoIuOuzNIm58FHyPi2EphbghJ9RYaZ/fp4mDv/+MqXJOfIHzkN3Aem+1sCgPpUnGIEQKT6TceTM4y8QtRXe+y+10+Z24LhrKLXEhpeB5/8AvHUXecL88xLyhNnzAqD3BMptDY3Cenc5vfRzFxNM8XySMb1wnkgjo7+6twPmLCn9ePnwNQFn/Bm4/nDywrn1LPLeTqdoIZxO0UvTAL++kE+naIG8z8W0jTBCery50xfIlLt91oIM1hty+qOs4nEO76XPrxfV9AMPX0m5eDsX0EKz3M9juZ4TNxEFgp3AsVcD2x5mfJ+I0QJQjZCydnQzvR/bRB6vgx9QuqYx/fO1z2UfY86ewEd/XVwR3NaZwNE/BPb/gmFgiLxDr6d/CWx9MLDdkcD0HSmKMNBCchTtp8V/PJjpXGBXwDk2YixcAXeNbFN5XKkUuZ6H/F10gAqzAmSYE1FilUDTSBH56s3AyvuNdII5UShF3pon6PXgNxGYvjPOSe+Ap5U9AW3fsp82AIrqOOEXwF2fAZ79NSmhdj7V+F6OCCpFJuIq9XPJBBDwGv+3TiG5qLaBPq4aKXb8QZIJnx5pYmVY6Ny6cuc2uhn4+8dJseiUja+SUfmU35FncyWYsRNw4rUUnf3qzTSG7XA80NNG35vryJmVl3Gb+goCf4gKO2up0gxQ5jlbXCWHNx5nyoOIzrbTSeSSfXMdjjduozkMQG2tHJF1w+uAtc/S/x/5LqW5e2UZ6RG2vI3APy7ENdgBf/KcCWBP94/v8RoOJ9t9xPhcUYDxEd3I8C7w7oO0nvz3V4CuBcCsxfZpxgTmz8zRWk4jAdmJhGEaDjYsNDJmDwEg/yLdKu2LCKOz83gze/mIAU3kygTodx36b5PjwJO/oP8P/HLmhD0fG14Bnvst8M5/IGJhKWlGD1ZiG+x30OHwz96FJhpiEgKQ4uTxqylaoHMBsPVBzo8p6HsW+McletRFCnjpT8Chlxe+H4CKuV38FNVdeOkG8ozQNFoA2OVjlUN3S11Muq2wqfUJRinXKxYgTq/PHwJ8QSMiZ89PGW1x9hJSFH7kSpqkvngDKRofvYpeAHkVH/ujws4xFQe2rCTP6c3LgQ9X0P9qv/N99J4IHPoNINBR2LELpXUWpXj680nAlrfplY/3HyMl6OzdMz+XJ8TivZWRwZzejZWVtYNZwRCPAupY7t8IBdDoFuoT//1TUkz6w8CZy4BQV+7fl0I8Ctz/DeD1W+n9vH2A439GinwZf5DGmu5t7fcVG6I0KkMf0N/BD4z3aj9F9tx8Ol1Tx/zizlcYGA78MqVme+M2YMNLZPgUHn8LDgJ2OQNYcAANqN5ApkwlVPsUEWJugIjxWaOMK9Wg0LFMVqCZfyt/N7iWvO4BipSrBLFBkqNXbzGUtQC19ZaZlO6hZRr9DU8jA5v4P9RNsrLqQVKurH8Zng/fxHl4E+dptyP9p+sokmH7o8jBRNSIyIU/WJwH6k4fpZSbT/+SHEamLQRm7Ezf2Xlmy9g9U/lz2cMaoM/F/9FI/vZQD0a6Yg30Tq4tX6HeRAyIS2kWwz0UqZCVgk+lqGWA8p5XgqG1ZFQY6qP504m/IIeVVFJPB5jS/0+RUj6VpBREj15F5/qXjwIf/Q2lxCsGYfjz+p3tY6dTgI2vUfrPB75BY6B5zSW3afM6MjZKkYh20QuBIDnvZClIi2zj7BhSGXIaD3I8A7mtvP8kcJ++7t7/C+SkVw7evJP+zt/PcGba5yJKVfTiDdBevxW7pN7Gz9PfQeruR4GDLwNm7FieczHT3EaOYHOWALt8jPqAFfcAf/s4cMF9QM/2zsY7gdMIBTOlGILrYTxiGCYLNiw0MmYPASD/Ij2uGuG/4S7y0gbob0ub9fav/42MBTudaoQtBkJ6WqRUdtjjK38BRjdQtIKTgktamiIFnv6/TK/ObQ8HdjsH49N3x3nXrwQA/GOv/eH3prL3sfdFZOF/6y7gn58Dzr2dFptO2fga5XNMxUnxG3kHeOVmyrdYbE7VplaKXtj6IOCOC4E376Awz5Ovo7zdZg9ReWFZ6kDstsKmmp5mTiYopV5vvjBe+VwmxigyYdPr5PW594XZ27XMAA75GnDgl4Dl/6S8tOteIIPE6X/MfY7xKLD+Jd14oBsR+lfl8fJUjPvja9In8UE6nsdDRrMV9wDvPwHPQf8DaPPLWyx63j5kWFv7vMWXpuS5r95Ci9q37wGmLZLy8kohuwAQWU2L6lBPtmFBfn4i7F20hQzlTRXzdTcqZu8ooYjLRSJGiu5AE/Du/cAbf6PPT/kNeeCXiw9XkGdy5F1auO33OXoVW5wz2AEEd882mAHAwPvAbeeRMmnZaVQAfXpv8ecenkYL430uAvpXk4HhzdtIofvu/fQKdgHbH01RfbN2M9IkwQuELbzfRL+vxA0nBJ+P5g+dc7P7sYSqyyGc55qPDRt5lpnSxrJcv03Ggc16Sq9yGhY0jcavV/4CvP0vo6h6IEzpuxaf61yGu7el1z6fBaJbkHj7Qbz00G1YgjcRGF5LtUZe/KPzc5uxM/CxG2h8LpQjrqRUUu/9F7j1XODcO4G2WRZRQHJfp4895jFJID8vs7yI/0XEV772MJWNdE6uLRrRi2jHSTkvOxmIFCGBlsw0i/LYJMakxDgZgIHKRCz0ryaF4dgmMriducwm+sBivjZ/X4qC/XA5tckjvwPsdn5hx9/yDvDQleTcAQU49ifA4qX5f3f4N4HNbwLvPUpR3p96gObDVpE7ZgcRn48iERMxPfWXHr0Q7afP/c3Wa42p3ManAoUacMzRXuoARXknY7T+P+Jb5Uk9lkoAy++m/3c+LfO7YCdw0KWYWPJpPPynb+MY7VF41zwGrHmMjG6ts8kALozgoS7DGF6O9YXiIaPhyAYaV285k+psdcwz5md2zp9AZtQ3AAz2GbUxy1m7jmWVYeoSNixMZZwo/sTAAhipiZotDASAPsCoFGYntgmEaMEj8hpCo0EXIKPBw9+mcFcAeOrnwMLjgN2XAnN2p0mkOqgXXRqjfSXHgSd/Rtsf+CWaNI5utj6fZBx451/Ai38yvNk8PvJA2/0coEv3FkqMG78ZWQc02eRaPOhS2s/G14A7LgDOu8coLJ2LdS8Cd36aUl7M3RM48f+Av3+ClLnPXw/s9SnaTo6QyIWYPAsWHkMTg7svJiPNxBjdm5CeckcOHZ70KJCVr0pu5bqV4lQ2BBSrQJZ/Zxc6Wei+NY1ehWA3Qck4vxzXKx/P7j76Q9SOJ3SPNquCsHEVGFoPeBTg6V/RZ7udRcrDdCJ7eyFHO5xArw9XkMx0bZ3Zpsc2Z/5/2wWURsxMIKwXhF1Af7sW0OTW10y5qMV1Wy1KN78F/PcHQORdBB68HD/CTrjW82kycCl5lKaahSHPCvN+2ufRy4y5wHpzBxkW3rwD2PcS8nL1BqgvEZPnaD8ZFRIT+vraJB+ykVXkaZW95ao5wXUiI+WQI7cNR4XKrR2BEJDI0aaEIk4B5V4XNUkO/Aqw7RHZ/evk+TlcgMYtCmVrGhkv/nsVkJqg9HpHfJM8xtQtufdndz5mzGNRsAM47Q/A3ZdQyPstZ9DYs82hzvaXKxKwfTZw4BeBA75Ayp83biejuxoBXv8rsPwu4Pz/kKFBFPubVO5Lz1mMSXIKxGi/kQfeKsIxrteMcbooDeqG+3IaOusJMZb5mzPbdEJSIJjHQaFcADLncjIbXqS+vGcRjRF28pJ22N+PD2e+j0fJeP3G30hZKehZSGn/Fh5jzCGsIu0c1BpKzdsXV3oXoEkbx+1HDyGw5lFSiJrPxY7NbwK3nkOp1ITDSLPDdudvBk79HfCHIyni6J7PAcf+jAxsmkbXn9aATinF1ESU5GFiFGjuBEItxniqeExGiSh9blYMOXXqcGPOJyj094qS/zeljB+W98C0P00/D3/IkAHhSKUOkFdy5zz734v3mkZGX0Bfg5i2cxolKupq5WLzWxSpMD5Mc7rjriG5HOrL3tZOLo/9CUVrv/8YcP/X4dv0Frza0UgpPmBiCEjbzO+2vEtR2W/drbdJBYAG/OerlCZGpOrMFZF38nVUb2Goj4rRnvpHY44tGwd8TUBCo7+Kx0hvqIDmriKSSB2kGkaDHwDTtjOcfMR83dwOCvGKdtqmnbbTWh+v3JqvFYrsNJJQaa3jb85+PppG6y1NT4+qeIDbP0VtqWMB8NHf0jbjQ86O6/R6U3Fg9SMU8RPsAubvT59lXUcK/+f5NG7XjscfFtwL73uPkHNYLvxhmkctOAjY//OZDinmdY/tPmyiCk77I3DTSTT23HkhcOYtRh8n0oYB9L/ar8uFHvkjG/XkqK1iDCFO77Ob4xHDMBWDDQsMkVAlA4Gdt7XuBRrslFIZxbJzKAOk1LvzM8DK+wAopAwdeI88IN+6k3ICHvAlyt2eThphq68so3zTrbPsvV4mRinX7ys3GcWJhDfbLmdQaHwxeAM0yb79fLLu3/VZ8v7JpYAZ6gP+cTFN7GfsDBz/c1LU7nE+hfi+dgt52JWaj7j3BPp798XAO/fSfT/yB0Zu7Xx5enMpR+XvJg0LDnMo1gNOFtZu5IzUTH/NCO+qdS8AHzxJE+F9PuvkCoh83sipBPCfy8moEOqiXJo92+uvhfR9sRO0GTsBH7sJePVmaM9fj8Wpt/C79NfgeekSYK/zy1MYzSnbHkFGNjVCBobZuwPpdOZz8AdpG+FpkyEvJmNasymPrmx8tUspwWG7hVHo/TKnqciZ0iNGY9nQOkpNl4oDC48lY2w5GB8BHvqWPtYB2PoQ4OirAKUCC/PwNDIu3PNFypd998VkhHZqXMiHolBO+Dl7AEd+l5RPT/6cIgNv+yTwyXsM+cnVx8qpCvLl9A+0kpw6iW6rds71WkQYZMyK/0SMFDEjG0hJHe6SUiDFpCLNNs4UHzxJf7c73P1zHlpL0Tdjm+i9t8koIt6zveuKhQmlGeltjgAWHUn3KTme/0ejm0hxFXmX0hmd8rvCU0MEO6mG0A3HURTgM9cCh15hOJMrIO/rZADK5AABAABJREFUSQNQkJSlTa36WGVxvOQ4jb9C8WNOq+TUQDeV5nzFEO4GojAiEsT9G95ATgnRfmf9TDoFjK6n/4VzUzlY/zI5QE2M0vzuuJ+Qk0Wh+IMUPfDqtsBLf4LvtZvxQ7yC73u+aL19Ogm8diulq53QjewLDqLo7OX/oNRlT19LBvZ89fGCncDpfwL+fCKNKQ9/FzjoK2QskFMZTdboUw0DtTh3+ZmEu8ixpKWb6ov4vZnzdau6CewV7YxKzHFFRLcwJAiltjoI+C0MDP4gtf/+lbTWfv9R+v5jN1LbKhdv3UV/e0+iYug52KDMQuKQb8K75yfJYK7265E1/UBMj7BRt+gpJaPAUJScMYMdwB6fdO+cwz0U1XrTyZSW7/6v0RiWjNFaSciUGH/iY0CihfpFudBzKmlEFlnhtK5dPhp9PGKYOoUNC42OmFhpyPTStUIMLOFWyeMjRjmUZcZHaJH4wVOkrP/ob8jj+r3/As9cR4X0RGqFrQ4kJfz2R5JX0BMiWsGmtsLIBuBv5xpe2uHplJZhlzOce0bnItgBHP9TSmu07gXg/q+TF5DVwnZ0M/C3paRs7N4OOOmXxkC4/ZHAs9fR+S7/J+VdLBXZuPDeI8BjPwA+8j1dYayRB51dnl6nBRqnIm7mR811r8LdhsFNICuwxedv3kF/dzwZ6NzKnfMCgKeupQljUyt5p5gjD4bXlbZ/rw/Y4zzEtzoMy2/9FhbjLeCZXwCr/kPtcObOpe2/6PPyk3fcc7+lhe2i4/RCbi2Z24lnIyIYzAWB7dqJ+DxXSgleoBZGoffLXM8nlaOv9wepNsG9XyIj27QdqHhqITllndL3LPDA16mf9/gp6m3JeXSsWAH1S0qhuY3qsvz7qzTm3nkhcNxPgR1Pcvc4Xj85BMzZA/jDR8jz7d6vACf+kpSzuXLEy+Tqj/0hoFOvFZFQ8+eGL9ZrrhERSup41DDSibpW+XIoa2ng/cfp/21dToM0toUiPsc2AW1zgMWfoLYrIgKSDiN6ikXxOOuDurYBTvktcNv5VMvr3q9QYdBCmbET5cC/8zMUgbr6EVLALjqejN5y2pdwF0UPmZ9NPEbz5fFBkssUslNZMAZOx5vkuB7ZOE4RCoEQEOogJZsCawce8ZkvQJ+PbqQ5uTcAtM3Of26pBADNWYSC4IOnyPEpoVLK1mOuojRNxaIo5ADVtQDaoz/C7onl+GX6CiiRPwCzJIeWD54CHvkhRcgBJBP7fZ4itQEyLviagZdvpPlYYhw4+ge5DYPTd6QaRHdfDLz5d0qxt92RVEPBTGKc1nnCABpXaS4nnke42+jL5OeTy+A9ldc+buLWHDeXgWIsosuaV6+hEaNnnhwnRbzipaih/tXAmqeoPa59NjNarVzFmgXD642UyzsVUL+hYyt6mZFTDkUjNM4+/X/As7+luVYhKZnz0b0drQ1vPYfqUD74HeCQr5LzjahVEu6mMVf0ebKCPxEDWqfruiKbeZe50DPDMA1FGVbaTF0R0MN+W3ry5zQWE7eMCbVKKYlESN2Hb1O43QdP0UT37Fup6KuiUM7DpXcAn3qI6i0oXvKCu/NTwA1Hk2JkbLN9tMLEGE0+xzYDbXOBo35AeTnl4rdu0LUNFbNUPKQEfu432dvEBo1iaW1zKaRXrqXg8dECGaDIinw5wZ3SewIZahQv5R/+96VUj0IdklIY6IhJtwgHtnu+4jueBOTGakIcjQAfrjQUYLJ8ANmFGSdGqJgkQIswt1h5PykpAOAj37bJsesOWvtc/K/n67hGuQhaUzt54dx6FvDYj410DJVm17Po76qH6F6HuuyfA0ByIkKLoxFMFpHPhegr7Yxz+QyzjEGh90tsH+7KHRIu0iA9/G1KWxLsBE77U7aRqVTiY8BD3wZu/yQZFdrnAWfdQkbychgw8uEPAif8nLy800ngX18CXr6pPMcKdlIqGF8zFcV94frssScfwmhgJ3cJlYoFT4xkRqowxSHSIIU6aZz3NWWmXLcau2Q2vk7RoYEwMH8f985rfIiMCsNrSYbOvIUcRYqtS1Vupi0CPnodtf01TwAPfrO4HN47nQKc9Cua60a3AE/9Arj1bPJUVTwkT4kYsGW1YWCQoxUSMaptkk4Bis9Qgud7jo1MzCbdlZgnR/vJSBMby4wACXWTA5PZ6CN+O7yeFJtx/bMhUV9hQf7aOsPrKRXQr/Yig9XzvydZy7VeWPUwOT4lVIoUOPYnpRkVZLY6APEz/ooNmI5Z2ILA38+mOdVQH629bjufjArNHcCBl5KSUhgVAFrn7fUpqlkHkIHhv9/Pn/5kx5PJQAEAj/6A1jRW+JszxxrxPIQXuJifh7sNA3audW2+74sl3/hWj7g1x5UNFADdo6E+yt0vUrymxo1MBh4PsP5Fms/c9z/AL3YF/ngkzfFWPUiy19RKKZBPvZ4yF5QTUVth3j5kCHeLQJgczRYvpWvRUsADVxjpdd1i/r7kLAkAL/2RUkknYno6JNHndQEhvf6DjFg3Wc31hGEE0A0VavXWgwzDVA2OWGh0AuHiJ1UiNZKYbIxFyIN/YDWlaDj7Vmtr+6xdyfPrI1eSVf6Vm/RCsyvoe6toBS0N/OcymtSGp1E4eeus4s7bCfP3JQXtg98CHvsJeajt8jGawK+8H/+fveuOc6Lc2s+kbcr2xsKy7NJ7R0C6FEURG1bs9eq193at14561e+q194bdlCKKIL03lk6yy7be0nZtPn+OPPuTLKTZCbJAot5+PGbbDKZTCbzvu855znnOdi3kPS74ztQoN8iI7/U7xxg/TsUeNr6BZUbRwM+lQt/ki7jhAd8JQyYnr9OkKiJZVFHDrmMHWsNGcHWGnkJCWnzYGs1sOoNupe7nRa9DH9bDfU/ACiw2XVCdI4bDByHJdxE3Hb5ZTCungPs+RXY/An915uAuEQy9uMSKaOa/c0ep/UA8saF39TWHx3601xTtgNY+19g8uOt95FKtrEgDKtckMvC8ieSQmVax8aYcqi9Xv771wXou+Oyk+O341siXy/8KHpVQTxPckPbvwH2LiByGQAGzyb5huNNzGr1wOnP0Fq0+VNqqNlQAky4P3rjjKHjIApozb+Dqgx7nQFk9vfNHg2GUNmPThutXW4XkBAbV6og1Sj3kTryUBKIKYUqVP2DBnJw2sjOWfY8/d11grrM6lDn+dMtok0364PwZSyPJToNparW+XfSuqe/D5j+ono5wMGXAP3PI9tw5WuU6b70aZIKvWwuVSMwPXl/qVG9CdDHkz2qN4s2RoxQCAxTALLKVi1k5+poTHBaX2ksqQwP693DEplcdqpwaKwDUnPJtjv0J70WqnGzvQ747jqgQZBNKlpL/wGqfkvqTGtXci41ZU7KoWzmbV9RELDn6VSJJ9dPKwLw6b1wh+bfeNT7Boa6dgE/SRJgOC1VNpx6G/XXCoShVxD5tvp1YO3bZPONDSCtxDDlMaq4PbQM+OkfNKb6zRRfd9pozeUhBjaZfe12tpYAO544GStYldpsoSST/KtEnDYxeG6Ip3Wr5TNNlLRUsdv3GHGJQJdTgdyxQO4YkiGOto3jD1s1SYDt+I7+7n9+23wOxwGTHgbKdooKDd2nUIJmx8HRSVwZcAFJ+y17DljxMs0xnUcI40kiG8YIMga9iYg4OUjlFPVm9VULMTnZGGI4KRAjFmIIjlba1n5BA2mwTm+k5sgAOYmhSviSOgNnPEOleJs+ATZ+QA6mXLXCmjfJqNYZgXPfaltSgWHYVaT9u+E9yszcv8T39fgO1IMhUINnnZGqKVa8TDI1CZ3ERs6Rou/ZlMnx/Q3Agd+oyaYUTM/f7QLiEFpSIobQkCubtqQSqaA3ygfV2OO6YnJAmQzSaBW9FUKhYjf93kldgFH/iN5xlcCcBpw5B+gzk8iN+iIhm9Lu21RaDgkdSUN74IVir5BIMPJmYN6twOr/I532iff7vm5KFOcy9jv5l81LEalz2B4NZblG7sfjs1sCogGuYUCCx0TyRAAw8iag28TIM95rDpGm7q4fxWxUgNavac8QCX2igNMAU54ETGnAqv8QsV2xm5o6m5Kj+1lDhHL6fQuBPQsAQzLNcZwOSM4OHuAJJUHBnk9oR2PnRIHTRpUethqS0WHXr7GcAqbxmWIFj60aLU1N5XBoGbDwASH4yQXue6UW7mZg3h1A6TYKEl3wfptW2UUdXSdQxezih4nEbCyjZqHGxNDvlUIXB4y4jqSQtn4BLH2WKq0O/g5kDRakJ2QC4gYTEJcjZsxLSY1gvbZOZgRbb4PNNyyZXidpQK+TIc+Y3JE0a1tvovkuIYP6rP34D9J5B4A+ZwY+V6+HKrTrCynr+cyXgMp84Mga4Oh6ysKuPUz/5dD/fGD6C8obuqpEI5eARzUPYt6gJdBt/YyezBtPAc/0HsJOIey7gRfSerTqP+T/DLwweIa3Rkv9gj6cDlQfoGrAAbNINozp7TcL8iwus0j4SO04VjnPbDoWHD3WdtjfWWKpqYoazhsSRFlDKfwJCoOZ1iMepJwgJa5X/ofsF72Z7r+8sUQmdBhw7CpDK/IpUWPPL2KT5ow+QF4bJnDFxZOE2LzbiVzY8hn9t2QAPaaQVFiX0ZGR/OPvBSr3EJG99Qug8yl0PKdd/H2cQiUDkyD1Jwqk/RT85RTVSvKdjGRcDDH8DREjFmIIjhZt63rK+LFW+y4YrL+C00bOYmo3Wogddco/w5hEgXH/4DjDoWWiHNHUJ9tWP9Efkx+l/gg7vqVMWI+b+if0mk6ZEro4cuADYfBllFHEyjiB6JELA2YBGz8i2amtX9J18dfzjzeJmQTSBbs9Bj2PN+QydiyChJi1ipxBa03roBojeXb+QgZ3ci5l60cLDULZeFq3ts/aCYSuE+g7ORooqNXcJGwbqSFZcwPgaBS2dSQj0VhKEhBr/ksZOSOuo2OE6zAMupiIzWXPUyaORkPGMyAavZxfZluwALq/c6h2zLRHQ1mukfvx+OwWx0bmOZctsMSAwUxNvIHQzc5DYdePRHaXbhOf05uA7lOpaV/uqW0W2IkIHEdraWo3YNEDNNY+O5ckodK6R/ezuk0iYqF4E/WWaKwlDV5btbyTqbShbKwCKHywSiydQbjuwnXU6SlI4HGJ86HXI8qIsMb2BjMREH88A6x9CwBPGdMz36B7PlJ4PUQqFK6m8zj/HWrQ3N7Q5yyaIxfeT2PsiwuACz8hWSK1YARD3VFgzf9RAkK3SZS5LjfHOO30G7lsQo8F6W+qInP7eBLJ0Uaw9TbYfGJJo0C1fxa8f1BM7nmDmX7voxuBebdRYoXOCJw1Bxh8aeBzXfNfkoHVGYFz/0uByuxhRDB5PdRvpKGUiOy6QqBW2MZnEmF+DMhsD6eDe+Ij0I24mq5rOI2o+59P47xoHbDsReCcN4Lvb0oBblwKLJ9Dc8/O74Gaw8BlX1JlNgtA+/82zJYDSELPVgVAA2T2Oj522N95/eL8tkBw21lvpvWFgcmA2esooRAAznyRfGkpQslrKQXP07i215Fv4qijx/YaYO8iIvoYsgaSckH3KSGbNkeMrAHANb8AhWuAg8vIz7dWUtXEtq+pumPABcDEh9RXywFkJ572KMU1ClcDtQVAZh8aX6xqwWAiQk/aLF0Kn35AfnLKgQgIpf5WDDHE0C5xAnrFMZxQYJM9y+SRBuakMi91xQDcQHwWEQuVeyn4HilqDokB+SGzKaBzrJHeEzjtEfqvFhwHjBFKgNuCXJj0EPDJTGDbl3RMS4awyEt0djmu9YLNshqtNUBK5/ZjBLtsAFRmBR4LGMx0LXX61k49M8b2L6LtkNnRzbZpLKNtQlb0jhkOOA1lRftnRssZ4O5mkhTb9hUFJVkz95SuwNAriSQIVAkUDOPuoe2y54Glz9DjUbf4Em62aiJKXTYhkBbA0PV3DtU6qO3RUG7Lc1ZbIh/oOfY7tPxtB1xOMXDNpCESI6hq2/ABafgCJP/QdQIFSXqeATHFNULwPBGNtYVU3dNUQf+tFfRdOg2jYFO4evN9zyYi4cd/UFDqi1kUxM2JokZ+9jDalu2g3yCxo/ibed1CIoJDmBf9MkljaBvozdTg0mn1DZYa4kk+x5LqK5HkBun1MxxeAfz2KElaAtQr6oxnWstThgOeBxY9BOyZTwHzmf9H8g7tFd0mApd/T9nVlXuBz84BLvw4/IabQy8nYuHwXxRQNSaLDYCddl+7m/fQVBSX4EvaSaUXgwVyWB8TJpfZ3omFcNcuaVA6EOSaNjPs+hFYcB8RPSl5wIUfBv/9D/xBjY0BYOpTRCpIodFSZn9KV0peOt5Ilsk6VwqOo2Swj84Edn5HPkqo8W6wANOeBHpPJ2ndks3AB2cAs78hXyyQ7cx+I5eD7EutQbwf5O4Ll42y6zm0TZ+FvyvYtZSz2dSQO6vfoCB/Rh9g4MXROTfeS/LLR1aLBIKjTqxEkAOnJanHYVcBHYeQ33ysYLAAPabSf70ZKFxHfSUO/E4kw+ZPqXLo7P+ERy6kdqX+Jrt+JEnq058jW8AKIFmw04L1b/EnW51W8q94CDEISdPnUNJIf2cyLoYYTiLEiIUYgsNnsucBp4RMkDo5Oj3pjKb3Io3Ryj2Rf7bTCsy9mrKeOw6lPgLtEYxciEukTKVokgt546g09MgqCoaNv8cvaGqWX7BbAuG6dpZRbVe3v38ws60y9PRmqlTwMbIkzqi9mjJfOC0FzaOJxlLaHgt5sGhBF0c9SPqdA1TuA7Z/Dez+mUr/lz4NLH8B6HM2STtlDVJ3bH9ywWmjLD9GuLnsVGFiryEDOFjgRXrvqA1ctEdDuS3POZRzKffZgeYul0f8220HnNXUdDO9m0i0sYCcWuz4ViQVTrmRmqxLdWXDaUjn9ZCUXtl2cgSbyohMcAWZz/YuBMBRMCV7BND9NArKqHEgM/sCV/wA/HAj9YeYexXJbvQ7V/13kEOH/hTAcdQBznogPk1onCmpEOLdVMlgShaDPe1tXLQ36M0URGlpVm8GkgKNrRoKsOiNwKHlFCT1NFPD2nNeFxNEggVflGLZc2KD4jPnnBiB00iRNRC4ch7w3dVELnxxITVm7jlN/bHSupNNV7CSerkMu5LmN6B142BHA/UEkPZ28u8dFCiQw0gF3k3E0snQxyRaa5dc1Yfcc24HsPAh6isFUM+Dc98MLjlXdUC0/4deSfbPyY6Og4H+F5Dkyu9PAVd8Tz5RKHQZDVy3CPjyEsqm/uhMkp5lc4Y/2cN+I/BU3aAzBvZ/2PudTcL+7dBWO1ERyGYLZjtLbW2tgaqw179Lr01+LDqV2DwP/PkcBePloNERkWtMojFsTAYyegGDLj3+SVsAXZeu4+n/1CcpMWvBvZSQ9cvd4ZMLY+4kYmHvArJ1Tcm+1SZykFYgSG1jl53IOo/Qo4atPYGqwGKIIYaTDjFiIQZ1kHNc2GIRlwB0GkKPq/ZF9jk8D/xyD+krmtOERTMCPcHjDY4DpjxBj6NNLvhXLWi0ZDAH007Wm6lSod1lVKs0TPyDmW0p9eKf+SZ1RjcLOrW9To++kdpSsdCOiAUpMnoBUx4HpjxFZblbPiX5mV0/APnzyZlU25B63D0UvPrzWWDlq/ScVBaJ0xK5EcyA9r93Ys6ncshVJ8g5l+FIsunNgFmyFuhMQE0VBT6rD4lNlRPCIBb2LSLta4D640x+TFkQJBhKtpLkV9V++deNySRxwf5bBCmhoxuJaKvaR/+3fUn3bvYICrp0OZUyZEOdnyUduPQr4Ne76fv9chdJdoy7J/LvpjVQYLV4E2nDM5nCloanJsDpIHkkjdZXnzyGyBFo/LhsQH2JGGhgpHpL5ZZfNqlOBxxcCiz5F815PacB570dXtVYIKx5UyJt8RJlgZ4sSMoGLv8B+OlmkkX6/jrqRzHpUbGfhVIMu4qIhf2/kfyHrQ4wpfoGZ1z24P0cQgVyWpqjg6pbwl3XnFb5RI1wyNdIoXQtaWlubhLXJGmAOtC1czRQsBqgxISfbiayFhxVM4+9I3glanMT8O01dG2yhwMT7g+878mGSQ9R4LJoLa1BvYP0n5AirQeRC1/NpsqFzy4Azv8fNT33J3ta+mWZSLaXNZEFWvcKbJHBjCcbMLYmtS1C2c5SW9tkAJa/SMRdl9FE2EUD6/4nkgrj7yNbxZQsEgk6c+T20LECp6ExpDcBP//Tl1xQG7zvOAjodholhG7/BjjtX6H97EAVCHoToNUCnNHXtzJY2n9FXAwxxKAIMWKhPSJa2oKBEMhAl36s3iTo8Jl8jYbsU2hbtZ/OM1imAQsAyWHzp1Q6y2mpUsFlDdzIjKG5Uf55t+TE64sou1UJ3M3K9uswQNl+ADD8WiqlZLJI9trWGewpecqOxeRAuoymLJ4jq6lJ2ik3kmGtM9A+GkkWg7/Woc/v28b3lRzUfqYSB1hqHEqDmRzn+3e0v6/X6xu80cUBLi997ravaJ8hVyB0OkjLAZXtxnosmNMBd5Cs0pJtvn+7bNRwkOk4a3X02LUs+Lj1aAAIEihH1oReRaoDBFT90WMaBSnPnEOB1M2fAEc3AN9eTc9l9Kb9lEpnjL2LsnaXPU/kgkZHzrzWQCXAoTJo1FYosLEVk3qRr06Qcy7l9uMV3PfSffRGIKEDVaBYq8TPiktUN8a3fQks/hdJjPQ8neblqr2t93PUKzve4ZVUtl6xi/7WGSmgZE4jZ9aYBMQlUS8Qf1gySAKguZHkAGsOUdams4kClwUraL/EbGD41b5ySd0my5/P1Kfos7d+Aax4heSRpv07dJZbqD4SnYYJxMIuMZuajRmDXyWXwQzl858fAtolUZzH1R6L59t23ZT9zpLP8xk/Jt/nW7T3hbXP5aDKGZdDdPKdNtIj3/kdsPZtOnb/C4AZr9L7pcE4p0QuKRjkxu/2uUTyAjQH95kBFG9Wdjyln6ukosINAAJZUrAq+NrFZL5CwSupnprxKo2t7V8DWz4n2ZupTwE5I2k+UoI+M0hr3lZFGe7dJwrVdqm+AR97jbjeO22+PTJCyftE0hydD3T/SckqlZWl0YBSuRV/GVBpkIzjWq/hHie9brDQfFy0VrTdTalEwHU/LXhfOZ4H5t9J64klHTjjOcDrov+BcGi5su+tVyhR5pL4MzxP18DdTOunziSuA4VbAAikfP6vgC7A/Ka0ktReS9du2FWUhf7HUzS2/BPFAv1m2jhKLpl/J62n311La9fwa2iu0RloDPIe4W+B/NHFiT5ScxPt42gEjAn0tzmVmtuz9c1aRfeEJbV1hWKkdt2x6mkXzfVIaZBd8ef57Scl9KRkXsUu0V867VGqqpL7CKXkZfUhqv5c/Tr9PepmkhZicDuBxgqq0lMCpTK2ZfsBCElkJVsCjyO3Q9nxzBnyz4+8mXpQ7l9M0mGXfK6sckE6/sbcTsTCtq+AvjOJ0HM5aG7wJwT0JnreZactW+85De2b3jM6CYvH066LIYYYwkaMWIiBIDV8lBjoLEjksonNMgHKuNQZabGsOxJew6+jG6lkEaBMlywVgfsTHf49F5a/QEGhSLP3JjwAfHYeZXx3GgbkBmgO7F9O799g82QLivpnSkj/VmpsKGk85bQK+znIqHPZycnXm4H8eZSBHN9BMGijaOS4HRRgANRVQjQ3AeveQsAmuODI4WKEgzEF6NAPSOsJIEKtba+bjNBgBnp6L6rwWfIYGeVL/kVBm6QcdZ8llUX66yUypsfe6XvPa3Xy97zaCgW5Jul/V4TKmJVmEEaaxW6roQCPKRWoFwLuCR3VZZ8VbwaWPEGBnrxxYsVLOHA30zy860chsMERodDtNPn5g/e0fo4hLoGItI6D6Ro1lhFpX7WPiIaGYmDNW1SpFp8Z/Lw4DZFtidnAipdJ8qmhlJqHxiWE910BoNNQ2pZslm9gHyjIKZdFqjSr8e8yvlqCoNWBM8uZJI4ULPGD0/o956e/77IDu74XmjSDGnCf/kzkPYB4L615TRVUsbNMsOdOuZGaFJ+s0OrJZu1+GvD7kyRT+ONN1PBz8mPB9aoZdEZg0CWUYbt/EfVKadWs1gTYQLZ3TRNgjKcgj5y2uZxdF63qu0Dku9rK0miAnQtAQeJgvXxYPyx/DX7/OcZlo/EFULJFQzE1afY4SW991gdAsgKbZMMHlKmv0VOShDRw3dbwOCn5pPow0HAUqC+mv51+iVgaHaAzwqCNw5ueeFhhhn4LR8RFYifqzROJlMkpN1Az5rpCYJsg86UUehMROEufJr/p9ycoSez0Z8UkGJdDSKTS0XzospNtIA1cm5PF4/nDWkMSLtaa1vIuodadUMTB33HtCgVrNc1fnA5I7y7+RkufpfWj95lA5xGRf07BSupbA5CsUb/zIj9mOHA20XrocdG94HXTY5dwb3jcAtkokJgpeWTHhpKByhpIfeTWvU02WDiySLljgd5nUVXRDzcC575FlbR8IhEvxkSaB42Jom8L+EotAr42HdvG7vcYYvhbIUYsxEDwkYjxcxakpcP+i4TLRpkg9gbAlAigGUjtTlkHlXvVEwtNFcC82+lc+pxNWSmRyiqFgsdJARHeK/znKdjjagbgpUx03guAp0wyU0pkn8fIBY+LMgSWPEbHzBkpv3/hWnJQe04L7JjmjSWDafdPlJ2d2pUIC72dSvHltA79SYaY4SsPJY2nXHYaBxzIEJQ6Lls+p+3g2eT0BMtSU4v6YtrqTMozIgEKWLhsQrWCVjBopQFOXsyoc4PGR30hoF0KXXpf9OKTsA8KxzbPU9ZazSFqCFp/lAL8eeMoYBooiKU1ELmw8AGaAxY9DJz9mvLvyCAlF/58hsZRZj+0NMBUc88HI5laSvFj48enaZs0i51dZ7beaHTqgywuG2CTZDE7rYDbQ9mHDqEKTk1/hco9wNwriaTrNAyY9HB4mr48T1VjWz4TyfbkXKDXmdGRP+M09L0SO1HTWHstsOF9CqKtfZsCtkqCXAMvovP57V/AkZXAlxdTgCzcnhQss7t8F9BsB+IUjgN2DzDbIdQ4bI/N0ENBSUNza7UYBJXbx5hIx7FCrAqRao6z38JfxtJpoyxOJk805nZgwoPKCbm6QpKsayyTNB8vp//WSt8G6wA14Bx3t6rLExGYLRcNfW61yBkFXP4dSaDt+Jb+H1kNTH9RWV+JYVcSsXDgd8DrBAyprffhQDaqTg+43YBGxq5oa7I7EEFxLGxI/7HD/lurQvfykcqA+n8H6RzDdPg9bpJz+/MZ8he6TQIu/lTMjg+GI6uJyAWAyY+S9Eg4qNpHthM4cYxyGkqM4Djf5+11tG/9UUEqUy6ZhaNsf1aZ7XUDziZo0IQeEKq6K4VdS7ZQ9U3eOCBvfHhzsMECnHobVSyseo2u64hrlV1DgMbxlCfJv/z9CVr7ao8AF34g/IZGMcsaEG1yl52IhlCkiCVVrFiQQoldF4o4OBnXrkjB5i89RBvx6HqSgOM0RNBGisK1JKvEe6lX0LCrIz+mWvA8tEWrgb3z1Pcp0sURwZDSlWzTpBz59UxKLoTTc4HjgPPeIqmxks3UZ+n893wT8cxC3EOalMXGl79dr9SmiyGGGE46xIiFvyv8swUBMXNUztD2ugXpI5lFwt5AxpxGS6+ndhOJBaVamgAF2ufdQU5pek/gjGfbTvPQaSNN6JKtQEW+imAvB2T2IYY/o3f4mX0cR5rv1kpyHhfcB8x6nzK1pWgoBj49l85Pb6asgoEXkWPjL6Ex8zWg+gB9ryWPk2GARGrmnJwtGgnSgKhcxYIcpE4coE7Ltr1UQQQ6X6WNpxyNlBEl1aWuP0ra1QAw5PKonzIajtI2oYPysVK1j+4RcCTNxQKKvFcgCWtoy7JqvC5y4Mp3Ac310JVvw/9hGw4hB9pDpwK5o1pnPHtcwufsoGxwf5kAt4Pu+9KtQPcpQHIX+XPVm4FpzwC/3kPfdfHDQPZi9eTeuHuAsh3Anl+IYDj/3fCIAFs1VXtIyTqGmI6oL1hQS87JMJipyRvnDLyuBILT7pvl31QFJCTQ82r7jdQeAb6eTfdnRl9qihdOL5+aQ8DGj4DKfPrbnE4VCpn92m4NM6WQM7npI5pn1r9DDUEDSSFJkTceuOwr4PsbaZx+PguY9Z46WT+GlK6U3eaoAxoK6Tv7z5U+OubCGGHBFhbIUTIOnTbf+6W9rC2BoKSheUqOuC7568MDQkY1T/ettVpeXoJdf4CyeJ02YMO7JP8FkOTE6H8qO2evG1j3DlU5+JMHUnAaWgvjs4C8McCpt0dnLPBeIrrtdSRL5hC29lrhb+F/cyMAngKXQlKMXmfGY55kNHEW6HZrgTiBbEnpGngNChcGC13XHlOpeqGhGJh7BSUYTHooePVCRh+g80gKtK1+kwgZSyrNcew3lWaNuh3yiQUnM9kdaOwESoySzhXBCBFWqcBk9TxuCt5v/IgC7AYLMOM/ygLi9cXU04b3ksTY4MuUS3sxuOxETBWuVvc+KQzxVKmWlA0kdqZtQkeaM3gvkQvCfdTcVIOnN1pg4W24v28p9B4r2XBN5WSzHV4B5J4KJHUJ3qhaDgMuAA7+IWSR/5ck2MbfS+S7EnAccOqtQFJn4Kd/kjTSR2cRyZPcRd5ud9mBqkOCbS6sNS7JOGK2qyVdPslBiV0XijiI9eciSNchHkJVtzA/8zywQuiHNvjS1r6wWpTvAn78B/kvXaK4/qhACl+Hu73vQr97Kz1hTKbvqmXys3paJzWCDK1WRxUc9mqqSHU3Uxylci9VPOmMVDWe0ZuuT3IXMQbByIX1/wuPXNCbgUs+oybpdYVUJX7lD+K64pL8doC8XxyOTRdDDDGcVIgRCwHA8zy49tLIRwn8jWt/ZjlY5ihbLFoC0H7OvSmRSAWz8P6MXsAeyOtTB8PK/wDFG8kIPu/tqAfp9LwTmqNbgcNLyeiQBqc0OpIN4DRkfGi0aMkA4rRiRpCtioiIinzKRh1+TfgnxGlI49pWTQ7L/LuAK3/03Wfn92QYcVq65ju/o/+dTwGuXeC7r8FChsH700jXfv07ZGg4GwG3nZwJwJdI8An0BLne1ioxoKo3K9eybU9VEAEdVYUBY6PgoEj7LGz+BABPgbzUrtE9X54H9v9Oj5UGUnkvlbsC1JtDmqXMaQCtRp5ASehIWZj1RfCU7YK76gC6oQjYVQTs/p7kUPLG0TgqXEOa61LtUE5D2Tap3eg61BWSc2mtooZhfWZQjwU5mJKB6c+Tg153BPj5NuDSL5R9Xykm3E/Ewr5FRKx0PkU08uUgF5BgiX8xyc7QYI6HnJPBJDvUzA8uGwVFXXb4yHHFpwOch+Q36groOSXjweOiQF9TOQXyzngmPKmHwrVUJcZ7KVDT/3yg7zmBmzVHE3HxwMibqEqiaj+w6WOg+1Qi5kOhwwDgiu+B768ncuGry4AL3qN5QQ04jsb/oT8pg73ziNYOpcsuyiSldG4dCFTy+7PsYQBwOk6cjLhICHQlmazSoBTLxpYGi42JlAmp0RFRx163pIn7sCoFRwNpVm/9TCAVOGD6C9RoWCkWPUzyfgDprKfkkcxffAciuC0Z9NiSHro/hxrYaymoWbCC5KGUwu0QJANroQUwDqD526dlFwcMmAV0V0DKqQWrXljzJl3zbV9SVug1C4K/b9iVRCzs+p56M1lSfatQ4tPFCpTmRqGfhr9kkvnkJbsDjZ1AiVGqKhOF97idFMyzVdEcDwCT/yXa0sFw4A/qK2Kvo0axU59UH9jkvfS59UUAOAoeavWCjCdP9zHH0WPwosZ+XDwF35NyqIotLjFw/y1OIxKRAHhdIjZynQAOuKdzCfQ6nhKZynYSsdBYChxaRpK1576prhpPowPO+x+wbyH1ImksAxbcT8ea/oLy4/Q7l+aYuVeSLffNlcBNy3yvL/tOVYcAbzM1QZcSCyzbOhIZwJbPOkGIA5cNgIrK5WMN/2QTg5nWKYD8geKNNN7G3xfZ5zgagO9voGrWrIHAxIeObeWaxwVtwXK86/0DiWgCr9GB6zODfCT/ZMRAPRZ4L0lV1h4WemwdoX3Ld9B/gNbeiQ+L933WQJIxYg2dlz0PTHlc+XlbMoDLvgY+nkFr1K/3Axe8Q6/5Vyj4yGFXo6Vn44kwDvwRUPI3hkhQWFiIqqoq5OfnH+9TieEEQoxYkMDj8UCrpcWH4zh4vV5o5Bortkf4G9dKmWWp06yTEAvNTYC1Viw/tQgZxLwX2L+EHserMDhrC4CNH9LjM19S3sA4FHgvNBX5uMu7AhP4dTCskTDuCR2BTkNIKzWxU2ujX655c1MlZQ4VraMg56rXyMBN6x7e+eniKPvpi1lAUxkRDKxJbThI6gxMewr4+VagfLvQQLiJAjJVB6mcmyGUvI8U0oCq0rLe9lb+K3e+PhmiMteJSeMAouFaXwrodOQ0rfsfPRdtXWlHA2Wk7FtIf+eOVfY+Ww1leGp0lFGtBhwHJHeBKyEPs2t6YxK/Brcl/gFN/RFyCIo3+u5vTKbgpSWdSDidJBPcnEbB3P2LBc34EEHY+A5UufDzLcChpaLepxpk9iMH+dAycmI6nxJ8f7mABAvWqQlAt7fKnWghFCEXaLw1S5ryGSTye7YaygDVxcGnYaXBAljigUN/UWYnQNJwobD/N3LYzGnApV+Sc6QW1kpat3gvBdRHXE/O2bGELo4I7vXvkxNatE4ZsQDQujd7LmV/Fq4GfrgJuHqe+vU3ezgRCyWbAf1trV/Xm3x1zaXJDUoDfgYzJR1w8K1YON6IhEBX64j7J3kw8i4uQXgtQHVdi8Z4qqjpDBAhpIZUcDmoESYAnPE8kWj+dpOS5utKwfMkVXZoGZFWLcfmhAboibTOGJOBOIvYEJ29xhIyBLLf6bDhnW0cEmDFFXnV0HlsJOFUc5ASNpxNQJ+Z0c9sNViod0X2cGDBvUSs83zwz+l/HlU6NJUDB34D4jOETGuHKEsB+N4LJ8J4OFZQM3bsDa0lboKBVdTZayhI31hKtp4xmao8Q6FqP9ngvJd635zzf6JEjxrUHSFSQRcHjL5Nfl5X2rw5EnAaknDKGkhJVfnziWw5uBQYMlvlsTiqvO4+mdbONW8CO74jKbZEBYQNQ5fRwFXzgHfGU4V8Q7FIHNgESUS9CeB4krONTxbf659traSPWntAJE3T28JOtVYR8WlJo//+ySbSdcpeR9vkLkCiwkSpQNjyGdlmKV1JPkvqe7QleB44sgrY9An0TWXQAziAXOSMvhhxKSrlMDkNEZhJ2URImNJoLqjcR/d7xW6KmxC7KL6v2ySKKcy7Ddj5AyVUqfFX0nqQNObnF5C08vTn6P22Glp7kjr57s8IB6n9E417KZr3YyTjIgZZFBYWom/fvrDZiLQxm81ITz+GvYNiOGERIxYE7Nu3D3PmzEFjYyPS0tLw5ptvhkUqNDc3o7lZDEg3NKjIrIoGAk3G/kEcKdvsL4kkhdRpZsSC3gzUl1DGv9vhG6zeMRco204BgFNvVX7eq16nz+k6Aeh1uvL3BTxvK2VmH/oTBlsNWKEtb04Hlz2MgorhGC/xGZQtkzuWGrJZK0imZeKDyrRz5WBMpPfmz6ds78GXiq8NmEXNrJgUUp8ZwIALyXgIBGZce9yU/ZHYmbTHNXrA7QLi/SoW/CF3D8WnA06zvFRWIESQvXBcxpHc+bbIgAUgYFgGjkZHAUpbNZEKbjew8hW6lp1HUrAiWqjcS1nGNYeEZsR3UYa0EjQJUjHxHcKTfBFg5Sz4lZuKmyaMhrGpiLJIi9bSi9kjgC6nEtnGaah6Rg56E5DZn5zw5kb5faRI605kYGMpVUR0V0mMAFQSfWgZvT8UDGZyjNxOwMAI2TDkjo5j5c5xX4+kCKSJLX299igFnz0umheddklWVB2RvR43wEnmLXMqUHcQ+Olm+vuUG4Um6SHAep8MmU3jQS2xYK2kwJ+9hu7LsXdTAOh4QKOjSqDaw4IOtwrEJZAM37dXA0c3UGXQ7Lnq5ofcMcAKAGXb5NcUg5nk+KSZ9tJmq3WF5B/HpwceI3ozkBJluRp/BMhsCzqOok2gB3Oo9RJS00deSnJN/c/DWk1BAXOqkB2aBky4j/o7lWwmDXiltkvZNrJF4jPlSYVowWUj8vfAEmo0y5DeC+g6kRJC/KshAulXx4mSQ1438MsOypC9tF8ddDoIlX+LqQpj3yIiFwZdKn+sSMELGRpKJNL0ZpJA+u1fJDvVfTKgNZJ9Yav17ZvRTgiF47YemVQmIbDkK95Daw6TXtRolcmfrvwPkQp544FzXg8uexUMlULVd0Yf5WRxW4LjgA79KDll1480f6glFhh0RpJfO7oBKFpP6/HEB9UdQypf5nVT4BMg/w8gDX9jIv1+0gb30qptTuNbCcSeP4FJhoDjKJKm6W1hp1qrhYbY1WJSTqC5KvdUABxVTzZV0BoTDpw2qtwEgLF3HLvfsGI3EWXCmOUNCXjddQkWcxPxY0IlIi5z5jSUoJWcSxVQfzxJv5PcfNTzdPL7G46Sv6NGkhogIiNrIMnHbvsK6DldHFO2Wvj025ST25O7l5i8XCg7L9gxwkUk4yIGWVRVVcFms+Hzzz9H3759kZ6eji5d2tg+j6Fd4CRJx48MO3fuxJgxY+BwOBAXF4dly5bh4Ycfbnmd55UvCM8//zySkpJa/ufkKGimGE1IJ2Mp9GbKHPafoJuqhKZ7VfLHM5jF3guAmP2lM1EGjs5IgTeXnQIzfzxF+427W3lTzvJdFFQHIi+BdDuA3T9Tr4ad3wO2GvB6MxZyp+E+zWNoPut1oN85kWdEWNLJaEnvRZ/5x9PA9rmi46gWXU6lbdE63+cTs4GrfgYu/BC4dw9w/jvUfDaYbiILCPFeqiRJ6UJZCPGZvr0WLOkBsvBl7qFA908bIaxxxAwXpzX0vkrB7v9AGR96U+vX3W5quLhbkIuIZq+QXT8BH59FpEJiJ5LO6neu8uMzDXo11UShkJxDzuXZr1GmzLCryAlW4oCzMnSl0hYd+tPWf5woRc4o2pZsDk6oAmLgW2dova+1CqjYB9QWhr7n/OfQY4iA4yjapcFOq+918P8bCLw2SV/n3VQVBl7Qjmev2QXCzgXEp/mON0cD8MONdA9ljwBO/3fo8609AhT8BYAjzXO1YKRCUzmRElMeP36kAgPTXG9QSSwAQuXcq5TpXbaDAmNqkD2MiOvGMsqic9oomBBsjLE1BaAKSGdT6DHZ1giQ2RZ0PYr22hhqnDBYqymxwSpDiEmvv60G8DTTliGpM/XjAESJFyU4KlSlZY9oG1KhroiCM/NuIxnBhhK6N7tOpDE2/l6qDIqmxBLHUWPPwbMBcERobPxAfaNNJSjfSdsshb1MRlxLzWqtFUScaoWkBZ3OV+9aCZh9dBxlIdrMPwr23cJdfw1msk8Ss8SgdLCeIgwlW0kyiNMAkx4On1QAqFoHIGLhRALTvy/fHfn9xOahbV+rv6elaKoCagqAmsNC8oFWqFZwisFPW43v/xZpF4kd708ynIAIOI4iWYPawk61pBEZakkT1yT23399M6cRaQVQolK42P41yeYld1EfUJei/ihJ7x1ZBRxZAxSuIwLs6AZKTCreTGO9eDPw53PAwgeJVNDFAYNno3n8I1iomQwv1wYSTMyuDjS3cBzQ5yx6vOfX8D6DkevbvxF6QmhpTGn1fr0WzEKvDL9EVv97ySkoXTgbldl50bwf/06V4scYffv2xbBhw2KkQgwt+NsTC/X19bj++utx9dVX47PPPsM777yDSZMmwWgUy1bV9Fp4+OGHUV9f3/K/qKioLU47OOz1gV/zN8DZVwv0FaWySbYqoK6YFge9kSQfkrOJDdYagHVvU2AhMZt0n5VixSu07XuOaFiohccF7FtMfQq2fQW4rOQ8j7kDzTPfxmuaG7GD6xt+s2U56E3AKTcI2eg8OaMrXwnPIe08krYsW0OKLqOBfucpd1BanG5eDMAxIgE4oQOhDGGNI6UBGTVgQaNAWS/S62qrJpLJmEAZkOBJ+qDTsMjPg/cSaffzP8moyxsHXLuYpCzUoKmctgkdIj8nf3Aa9TqmjFhwWpU57ay57NEwiYVOQykAaq1UpoEfaCxYaygTq6E0tBN6jEk5KQKOo2iXBvs747ZqmsekVQCh5hWDmRrXxWeApE4kWaYGE72Wkk1bSfNu3YoXKWBnTKLMeyWZ9qxpbdeJ6pu2+pMKU5889vJHcmDEQn2YNkdiJ5K3AYD17wIFq5S/V28mcgGgDLm6YqpCko4Ldo/4z88Gs9AMPb61LNaxDoQGyGw7pnad0vU3mO0mHY/mVEAb55uxCwDj7qKxUriGqhaUoHgzbbOHK9tfKXgvNXNd/BA1d3U3kx057Gpg+otEXKuRSQkHeeOAU66na1+yhSpRo5mkAIja2B0GKdtfZwRmf0PzS8VuWv8d9UQuSCtXQpF4bD+58dcWCRkBEJVxJDcvBLP9/NdfpfMKe5/LQRXaQGgbhedFf6bfeUB6D0VfSRYeF1B9kB6faMSCJZ2q9HgPULo9smN1nShUVdeR9Eq44D1ETDqbKLhrTqHeEjqTSBg4m4h8cDZRNYNDqJQ1WMR9gODJRCcA2mQ9ags71ZIOZPYWxpGwJllraGuTIRi6TqLt4TCJBXczKQkAwKh/hEdA8zxV48y7HVjxMrD8JWD5C8Cy56hnyh9Pk/33+xPAksdoW7iG/J+eZwDnvwsMuaxtE01Yr6m4IDGBPjNoe3gZVDeMB6jRukZPiZ8NR8k+NKcQuRBqbMjdSy12nuDzhZqDj6PfFEMMMYSPv70UUmVlJRobG3H55ZcDAIxGIzweD3777TesXbsWBoMBb7/9Njp16qSooXNcXBzi4o5z5qIpKfBr/uVlbOIO5sQ2VVEwpdkKJKQDbgDJmb4Tfl0RsO5denzao8qNssK1wOG/yAAYe6ey90jh9ZC289YvxaCpJRMYeCGQOw7QaAC30NisLaDRAmNuo6ztdf+j/hINpZRdZwzyO/jDnErOQ+Ue4PByYOBF4Z8Tq2bwd4KcVgr46ITXAwXLT4AGTGGNo2PZ08Ffk5U5LU2VFAw48Dvt1yuCjBkGngd+ewzY9BH9PeZ2YMID4TUja2qDioVIoDeTocp7yNGID0F4MGKheAs53sEqd2Q/zwR0HEz9IMp3AJ0Gt95HTrLHH5ZUcpASk09oJzTgOIp2abC/ZjGbbp12ciDYOAk2r+jN1NiX9Vhw2Slo6hLWqqROdDyDCXB6AADD+B3QbXqP9p/5ujKSwOOk7EgAGHq5uu/ZVHFikgqASCw0loU3NgCg1xnA4MuInF9wL3DNr8qbW+aOoUqigpXUv4XJ7jltNLZddgryxPvJkujN8r9btErh1Wj1Bnj9mNp1StdfliUoN/dIx6O0QSYDk7YcfBlVBqx8NbQcktdNlV4AVSxEE2U7xeBM9giqyszoS5mX4QRFwkWnYXRN171D1RnzbqdKHlNy5Mf2eogcAJRXLAAkcTZ7LvDJTJIbXPYMMPkJX9kW/4becghkH0nHmcFCtg3bL8oyIlEZR3LzghrbT+28Yq8Te3t4Q/QPObKK5kCtnuy0SFBzkGTHjEknjr0mRfZwYM8vlL3dZXT4x9FoKRD71xxg0yeUKR1ONRSno3mO01IAlOnCO5rFudDtpuCm2y1UM3jE4KZU1lRptf1xQputR9K1MtoSQnqTWF3HGon7z1s9pwJr3yRiIVQPGjns+lG0zfqdp/4cnTZg9Ru0FgFULaaLo/HP8wCEbcvfwj2UnEMVbym56j8zHDQLa2KwZMOMvkBqN6puP/AHVbargTmNZKn3/Ep9lTL6UCKCxymuPWrsMqmdZ606bvKwMcQQQ9vib08sJCUlweFw4K233sKLL76IN954Ax9//DEeffRRxMfH45tvvsHUqVOxbds26PVhOOoMPB9aJicapeXBDGwmY8RDdO6lTmygBlYchCwpJwUsUrtQxQIEI1tvJA1YZyMF7fqfT4ttKDRVAsuEDMl+59FnWmUkmVjWjhQ8T70c9vwiEgp6M/VOyOxHDmqhkIXn0QAQDN8ja4B4hQF/WwB5KH+47MTmD72SyjDLdwI/3QKMutnX6Q+l+915BBELB/4A+irQ5A+UjaER7lO3k64TMxadNkFOxAkkhFjMgwVjoimBoPZYHBf4PUziKdRYi0pjKb8MbaeNJFm0eiq9Zhr+vU6noLkUSuWySrfTvhveB3Z9D4AjibGep1MWScvxFDbLtFWKvQziEqiqRw5lITLQvDoAQnbyqlcBzhV8/+5Tgr9uMNN5NVWEDtImZlO2ur0WKN5A800g6AM4Rp1PIWLh6PrW+sD+5Fug+8OSHr7z2ZbOm1IYLNEdx/69J1hPFtYoljmPcrrwUuhN4pxprRZ1k9nx2WfYKpDM1+N+71v097CrSM5ErlrMv3/HvsU0t5vTgZzR4uuOIJV+gG+lgjmdegjxHpGs88fuH4Mfj6F0m7L9zns7+OuGBJp/PC4KYCaFmeE96p9E+NcepqztS75Qdq/kjiUJpeKNNL/EC7+xtVrIEHUAvIp7jgUiOCeNy0BjJdS5tWWPk2DrkVoollEUPi9Yv5dQ58TWrxHXE4lUuIYkHvLGBX5P0QYaz4Z4mvvstfL7KV2P6grEx2ysdBktZlrWH6FtbaGy41UfCL2PVwfgauEzfwY0ATLQswbRGKrYTb1HRt0MmAI0/+2osPrAUS/MfWaS9AuUGOCWmcMy+gAXfgR8czklnqx6DZj0II0zc6rQi8Yofw+xeyEQYSX1GXg+9HhRcr+3Ve8NILwEEp81V3i/3oQWBjzYumRKEauIg1Us1B4Blr1Aj/ueQ+OgTiaT3O1Qds4V+bRN703nGWh+2PaNsuMp7pkTB+B8eli0DtAE8OU6DhGJhWDXhZFpwdChP91rVXuJPAunX11qLvl9eqOQsMLRmuOyAi63INmSQhrx5hShEXqTmAQRrcSktrz3lXx2qM8Pts74k4zRhMEsJBcYfGWn9CZx/HUYSNV1jSUkqZgWpOLH317zuoG1go009AoaZ26Hcj9+zy/A3kVUOcNpqD9Kh/6tr2cgcrF8l69fVnEAgNDofd/CwGtNzqnKzk9KLroFMiwuofU6Il2Xu00mYmH3T9S/Ugol63Sfs4lY2P4N2QpeN/U60+nJBkgO8x6JZhLg8V6PYoghBh/87aWQkpOT8cADD+C3337D5Zdfjjlz5uCTTz7BY489hrvvvhtfffUVSktL8eOPCoMExxvBysecNjIuAwVUWwVLBZ1spqGXkAkYU1pnu1buBbZ+QY+nPa1cbujwclqIdUbSklWK6oNUbrzxAwry6M1A33MpsJ81MLxM7mggvScw8h+UYWSrJsdVTc8Fpv9+eHn4vRoAkXDwCgFfq9BHw2Wn0uCUHHWNk042ROO7+Wuy6gyAMZmc/JJtFOBMyROcwgiw+ROBVABlwPU8PfxjNVXS1phM53uigGXdWCtD78txogzH0Q3hfV6OIDtWtL71ay47Gc1uV9tVIZzMY4uBrUOWdL8ePSr0i6VjzF/uQxuH+71vIRX18Kb3AaY+pfzcdgiBmAEXKM/q9ycVxt7RWlrmeIPjRGKusTT84+iNwOnPEEFdsJLmICXIGUnZonWFgFuShag30RjndDS2lN73BgsdQ2uITO9aqbSQyybfr6A9gs0xga4bG1tp3SkIA1DGcDCUbqVt1qDo2ljWKpKABEdE34kAYyJV0BqTacyvel3sTxQuGIEYro2aNw44500AHLBnHvWi4CHMtWmtbTp2PyuV/JFm/x9nKcygkPNxlPTv8a/U9pFdC7Iu6Y3KeiwcXkH3sd4UXt8ef1Sxxs0R2pBthY6DyNdrKAYayyM7lsECDJhFj1llrlroTfQ7Se+LlrVHKxAJdpIqBWhfcwYlQQAx6RUgOmM/mNSY1KZjlXSMcGhupCrgzkI13OHl6j53/xK6F43JlNyoBoVrgR3fEalgiKf3Zw04cQPSLBkmlDxyTyGZsWAVqTqojSvkjSeb0lZNfS9sdWJD+0hEIGJjLYYYTlr87YkFvV6PG264Adu2bcOrr76Kbt26YcwYypbgeR4ulwsdO3ZEZmbmcT7TKCCU0eDfiJYZ2wBphSbl+AZTnHYyBJY8QYtNr+nBM96k8LpJOgigcnwm4xAKjeWkxVtfSAGHnmcAU54AekwJT/oh2ojPFEp5NVS5ULxR+XuzBlG2RlO54GiHCZaZxH47ZgDoTcoX8xPduVQLqbEbje/m3/za3kDXN7GTqP/fa3pkhunWL6kCBqAs4t5nhX8sgBpAAoKG/QkEdg3lqpXkwGQ4jqoYW1KwfiY1B0nmQAq9ibKAWJNzBkayRkPv/WQbW3Jg4w3wnXP815hg+uAGs0jctVQvUOBHu+VDjMAOOGCAa+bbykmgPb8KevIcMPBiZe/x76kQDVKB58k5lMtojQTRIBYAas455g56vPRZMXs2GOISxAoif81+JmUVl6Duvve/X8KBwUJznlIy/WSBT/Nzv3EmHVsjbyKb4cgqIpICgRELwarEwkHhWtpm9Got2XQ8Ed8BGHsXbR11JJFRdyT847FKwCyFFQ5y6Hu22Adl4wfAXr/GnFIywWknu1xubvUP/kn/bo9BHyX9e5T4PkDr9cglrTDg5TN9vW5g04f0eMBFkUtnOa1UAQGcuMSCwSL2fijdEvnxhguVRPt/J3JaLfxJIadAJJhS6b9WT8VeLYFtE0laSu/zQEFxtc+3V0Rj7Acj+aRkgnRN0psomUenF8nlw38p/0yeFwmpIbOV2wteN7D5M4opeN3Ul3HQxUDCCSg9JoWSHgsASSENvAgAT1Vuy56jilal0OpFO3nXz4ApgcZ9UrakGvUkufdjiCGGqOBvTywAgE6nQ0pKCjp27AiDwYDly4kp5zgOX331FTiOQ69evSL7kBPB8AhlNLjsxPjXHRWaudko85pJI1lSfasVXHZyRg8soYyQqU8qP5ftc6nU0ZgEDFGoc83zwM5vyVlK70WEQp8ZJ56+eXIO0GMaPd7zqyjVFAq6OLEZr9psDSmYg8RkQeLTifBgmTlK0B6dy2Bgxi67r9XKILHAcqAGhyZBWszrjk5/hbVvAVs+pcen3Aj0Oyf8YzGwigVLlElS3ktzgb2WypOVSmEwtBALCioWADGjqXhTeJU9lnTSTgWoP4v0N/UnjABRHqm5QVmQJhRCNQQ/GRDIuZQGNFn5u7+kmNRZaXndQeQdABzdCN3y5wAAb3NXg09XuDZX7gF+e5Qen3IDOZGhINeoOVxSQUomVOyiEnV7TXjHCgRGLDSURH6sQZdQnyJPMzDvNmVVA0zC4uDS1r8hIJ9ZHQzSpppt3VyWBR/bK/znIWOiGGi2VbfOyLZVE9msM4WuWuB5MeNeri9NuHA3iw2huyiUhDiWMKUQwZbUhSRV1vxX7DOhFqzJrVLppEAYfjUw7l56vPgRqoxt+Z1rBDJB6EXDCZURoZodt/cqulD2aqjX2bpkrfFtOu+0kV0jlReRk3nd9jVQf5QqggdeGNl3AYCyHQB4stUCSXCdCGD+SnGYY0KKtB6CXAsPbP5U/fsbS+n+9++ZwOR2NDq6lq38WMm8GWgcqH3+7wwpiReo0bp0TbIK/ZcsqZR40EmQWS1YpZzoL1pHSgZ6CxEDSmCvBf58Dti/mP7OHkYSxCdaPEEOSnosMIy/jwhyTkNrxbzbWidUBcOQS2l7ZCWREqYUMRHU36aIFtF2shF2McTwN8Lfhlhwu91wuXyZWq+fVp5Wq0WPHj3w5ptvYsKECbjsssvwf//3f/jiiy/QqVOnyE7AGUEp/7GCtYYCg/ZqeqwzkCEuFwBj2SCrXqe/R1xDUkBK4HUDK16mx8OuDs26M5TtoEx+jZ6qHJQ2lTweyBsLpPWk77rje+XvyzmFtnsXhS+HxCo3WGbCyUYShANm7PIIzxEIWirPsmqNFOy211I5Lvst1WLfImDpv+nxsKvFEvFI4KgH6oXs6PjoEAuJfAN0tgqgpoACmbYaMgbrjqq7d9VIIQGke6qLI8dESSa1HFrkkNaFDpgyeSR7o9inRoqYc9ka/hmiLPDlTyYEqpJraQ4nGVs6PWX9zr0anNeNZdxoLOImKTsfdzMw7w7S3M0dS45WKNhro9eo2eMkyUBGJng9JIcSbTkldn7hZHz6g+OAKY/TMav2U0PbUGDEwpFVvr0tGCnkDCPzU418ViRgkjLtFT762H7rHY/WlR88BMKujog2gH43uSBh9QEaD1oD9bCKFo5uIOLKkhFcT1sNnDY634KV9F0ikZUEaH069VbKzvY4SRpMrQwf76UKViCyigWG8fcCw68BwAM//gOoOkiEAg8iEwwmwXaXBMul65P//HwyVtGpDU7JySC6hKoPae8er1/GL88DK16lx0Muj07CQIlQAXCiViswsCBw6Va/yo4wMVyQxN3+jRg8VYqaI2IvH8C3CqWlf4ZM0Fhu3vQPigcaH+153LRV8Fbqb8rZxmw9Z2sSB5FA0JsAYyrNuc0NIhkbCju+o23fs5XFBdzNwO9PidJl4+4mYlupjPPxBqtY0Clo4M1xVMVx1itEvJRsAX7+p/IEsA4DqErR66L+jzpDANvdBtQeFdeaSO6vmE8VQwztFu1kFo0Mu3fvxuWXX47Jkyfj2muvxVdffQUA0Gg08Hgo+4TneSQmJmLOnDmYNWsWOnbsiNzcXKxatQpDhgyJ/CTkDJoTDZZUqiAwpdHjYBIELjsFsFkDvqFXKv+cwjWCFmKSuqApKyXPG6tcOika4Hmgvpiafh78U1ljak5DGt4ANaJSanR3nUTOe9FaMq7DATM2PE4K8ipZ2E/WDAF/SZb4dGWOgNz1aCyjYLZ/5izLcmcyOgAZxTWHwjvn3fNo2+tMItAiRWM5sOB+Oie9CUhUkKkdDB4nrvV+jU+9d0LnqAHAUzCDzRVeF1QJcOqMtFWakayLA7pOpMdL/62+QgIAuk+m7e6fQu/LfldLCo1NuSz89upcRgNyY8WfzJRqvgfS2QVaOyssk5QDVY38ei/QWAJvSle8zt2gXGps53ckn2fJJAcrlMa510ONOJvKiYiLlFSoPkgBVE4gE1K7AZn9SV4wmmCVOCWbiciIFKYUsZmuksq7vLG0rtcfpabALccRKrpYUEHqeFqrBIdUpiLIaaX93M7oZBKerOsc4DsPMZLEkkbPWdJ8K4UAYdzF0/7LX6TnOK28pOQeQXKn4yAVTWBDwF5LgQqA7ptIZAO9blqfizcBRWtIssjTDDhqlTfLDQadETjlJiB3PP29d4EyO1AKFrSKhtwWxwFnzqH5w+MkWT9OS3a7tCrIKQmWy61PTj/76GRKPgkUnHLZiHitLfJ9TSqDCIj9VlwOYOGD9DizL1X4SOF2AA1H6XEkPbCk531wKT3OGhj58doS6T2JdHdaxT57kaDbRFobmxuBrZ+H3l9vpup1AFj1KtBQRs2Z64vpOYtA3DsbgfqS1gl+TrtYmd8ybwqV3dIgqfR56fohtXPY2tLWlXXRwrEI3srZxszGY+uTOY2uv9NG/pU5kWwIQPm1ZNLBTCkgFKoPUlPnuARg2r/Fvm3tBQkdaatmHcobC1z4Aa3f1QfUyXD2F2IZBSvEJBF/291p811rIrm//u4+VQwxtGOc9MTCvn37MGbMGBgMBkybNg2HDh3CnDlzcO21lBmh1WrhdDrBcRx4nkdubi7uuusufPPNN3juuefQu3eUMkba0mBX6iyH2s+STsx0Zm+x8aaPJIjQU8EpBIc8Lomevwona88C2uZNUMa4M9QcpC3T9Wxr8F5agHd+D+TPo0Bx5R7K6lOCuATxd3fUKXtPUjYw4X56vOSx8DJPpQGYpjKgYj8dRzYbVLgnmqpOzgwBf+NGafWGnFGkNdB9HixzNrMf9VbgvVRmGw5YjwYWPI8E1QeBBfeQ4xuXSESF3hjesTxOoOoA4gqX41J+HkxohlcbR3qkKbmi48Vp1GX+sCCvNCswFCb/i+7zonUkq6YWvc+ioIy9lsqDmdQV+y8nj+TfiJjh714RpMSBYI4CIxP0Jgrc1PkFd+SclbpiwNEILHkYqD0MxGfBdem3sHEKr7e7GVj/Lj0edbMy/esDS2i9McQDkx+LAqngpPkjoxfdd3EJ6gOpSqpzkrKB7lPo8fp3I8/WBoBCYT5SIlUTlwhMe5oe/zWH1h0pWcQeSx1Paw2g0wFud+ux5bILc24UgsPAyZ0JJzcPyTXIrC8Ws3ONScCSx2kO5LTArPflg5m7fqSt0sBNKPA8HdPjBFLywg/s2KrJHtvyOcmLMTvLnCbaptGqdNFoSZLQEE9VR2okkTiNKOFXtC5658PWTJMg7+IU+tGwPgsGIVie0lm+2bG1pn2OByU+T6DglNNG2fCuJl/Jo5asdrNIgDrqgUUPATUHaGxd+HHredvHh4nCfLt/MX2v+A7RrQ5qC2i0tKYClKRRfTCy43Eaqg4CgPXvhx67HAfM+oBstLLtwMb3BCkwq2/Vo9tNa0x9CVB5kO57QKhSESrz/ceHHCEXbP1ob2vLsQjehlqT2N96M/0OPGguY9XLyV1CfwbPi/sr7Y3AEiLTe5/4/RTkMGAW3fP1R4Gj65W/L7UbrbcAxTaUousE2h7dAMQFqMgymH3Xmkjur5Cy3SdxgkgMMbRznNTEAs/z+PTTTzFt2jR89tlnePzxx7Fw4UJcf/312LRpEy655BIAgMFADsjHH3+MwsJC6HRUPslFkkF1LKHUoInU8JFKEhiELFKW3eZuVnYM3is2nOt+mvLPtteSEwkOSOmq4HN4au56cCm0lbvRga9QHmTxOGkB3folsH8JGS2cVswGLd8FlO1UdiwWxJJqtIbCqJuBnFFkHM+/U31mnDSjqqmGHKjmpuDGMGtqdrJlCIRr3Pi/T28iyS5DfPDMWZedeiJwGsomUSuZUF9EskIaXeQEWulWYNEDdO+l5FE5bDiVPgKhgIJVQF0BON6D/cjD45p74UzMIwOX48RMzFDZ4P7gwiAWkjoD4+6hx8uep6oMNdDoRId4zf/R+JAGWmQlr/7mBEIgKBljej9n0mWnecnZFDx44LID8AK/3EVSeKYU4MofwCfnKj+/nd+JckYDFOhfO60iWTX4UjE7TC38SYW07pFle69/T1lT5uHXULCrYndkvXoAWnMrBUIjb6yy9wy9giSRXDZg/l00N7Df3iAZQ+y+saQSIeEf/AR8mzpGI0B8smbCKXG0W5JB9CJhs+hBYN9CkVToO7P1+yr3UtBeowO6TYrO+e75hcaGRgf0P18dEe1xEcm260ca2+U7qTpBZyTbMHcs0HEI3VNAdIMPWoN4DQ4sUVct11mQRixSEQgKBt4rVhskZ5MUoa2SKmRZn4VAa5Z07LFsYUaqt4dgjRJfJth3j4sH9BJbTk6Cj9MAv/0LKN5Ax7j0KyBVxvfgNK37moULr5tIPgDoMbV9SLPkjATyxtH9uPI/QFNFZMfrew7Zd7Yq6l0RCpl9gfPepse7fiQpUdabByBfNakTYEig6pLmBqDmsJggF0jiSI6QC7Z+tLe15XjZs/59tADfKgavm8YRpwESO4U+XnODOO6UShnWCgl7KSrsyBMJxiSg5xn0OH++uhgBi5+oIRayBtJ4cDaRLKacD8xsOlaN2pbkQHsj8WKI4W+EdmC1hA+O41BcXIyysrKW58xmM6677jrceeed2L9/Px5++GEAwOrVq/Hcc8/h0UcfbZFHajfEglKDJlLDx1+mggegFbJ1lJabF2+iII8hXszgUgImK5PUWZkkQvUBkhOq2A394d/xqfcufOa9A/qDi0lj0FbdmmhwWoFDy4DVb5Bx2txIzmr2CGDYlUCv04Gc0bRvwUrKFggFYwpt1TRL0miBma+TcVy0DlivQNva//3sd7EkkwMVFx/cGGYZ2Sdb0DRc49n/fQYLZc+kdAmuoWurpff0nE5///FvdZ/LshmzBoZfWQAAh5ZTJqrLDnQYCEx/SX1PEp6njPIjqynDh/cAcQlwdhiG2zTPYh033Dd7jxm3ahugtlQsuILv54/h15BedXMjVfeoJeAGX0aB6toCauLMAi3BJOBiaA01VUDMoWRBzqbK4M6B1gD8/jgFdwzxwOXfUiBBKdwOsVph5D8oKy4Udv5Azmpi5/AztG010SUVAMBtB9a8FVp72pIODLyYHm/8UDnpL4ejG2mb2V85KclpgLP/Q9/30J/Ae1OA0h2t92P3TbC1x2ChMeloaC1Dx6qM1EhPtEdyUIkDrrRqKCmb1gGtAfj5VsoyDkYqAMCuH2ibM0qUqIgETZXA6v+jxz2mipVuSmCrBrZ/DRT8RY2nOQ2Q0g3odRbQZQxlZDJpPWnQOJrIHUfJG03lYt8EJcgZRdtoEQuOelqTAZqrmDmrM9K847IHvmekY49lC1ur20+wJlxfhjXotaQDKTmBJfj0JmDVa0S6aXTAhR9RNXcgsLldrQ3jj8MrKJHJmAx0HhnZsY4lRv6D5pXawzSv7F8SWY+40bfQ43X/U+Y79T4LmES+PJY9Twk6cvLDpmQiQIzxweeFQOtEoOfZfWUwR6fHxvHAscoCl+uZJK1iqDtCzyVmy8vy+YNVKxiTldtYrGKBZe+3R3SfTPdaU7n6qgUAqN6v/D0ardg/q3yHSCD4E0RSOyTU/RSTSoohhpMSJy2xwAtGzbBhw+DxeLBnz56W10wmEy666CJMmzYNf/75J2prazFmzBg88MADePrpp6HVqsy4Pd5Q6ixH6lQbTOTks5JrDqIhrjR4sVeQQeo5TV2ghbHrad1D7+tuJi1AAEjuAm98FtzQIhPV0FbvpWy5tW+R47Dzewqe7F1AhELBCjJ4jClA3njKvsw5RfyenYYImp48sP83cu6CgVUsOFRULAjn3SIpsfwlyj5VA7bgchogsycdT+53D6Qd+neFnDEUKoDFXncJY0IXR0FvjZ7ILab/qQQs6MCCEOFg90/AXy+S0ZY7jjRElTZIZ3DUk7FatZeOY4gnx7rzSHgtmfIyLuFWLISb7afRAtOfp/cf+B346Z/qgkgGCzD8Onq87n9CSXWN+JoSxEpyWyPQNfGpeDMDWhP1Gwgkc8PzRI7t/42I0ku/UC+ZsvVLddUKjeViRd2wq9TfywCRCqveiC6pAADmdMriXP+/0AGsAReQfJO1koiScMGIzrxx6t6X3guY/Q2dc2U+8PFZwMaPww9aavWtZeik/RraK5xWgVwT1hbZ9UeBs64mucSUDCy8n3o4hSIVmGQRQDZbpOB5kshyNlGSiNIqGIDGcf58QeIngZI8hlxB55Wc03pNYvZO1JuTmsTxoCaA2mkoXe/GEmVJKaHAAmpxiWRzWFIBcwaRRzoTkQX+mvJyaEkuSWs/wRo5bXslv3OLBFSVb1DMX55l5X/IRwCAmW+Erq5u6WsWAbHA8yKJ13emsqBqJJ/l9URHKg+gdXzGK1Rl67KRb7X037QWhoMBFwLJuTTmlVZtj7sH6Hsu9fj69hqgdKd4/7O1Qm8COvSjccJ6zkRjDWmrDOpj2a/hWGWB+5N4/mDyv0r7T7F5UClB7XZSVTigTGrpRIXeFF7VQguxoFK2LFdY846spG0ggshf6jLQ/dSWUkkxxBDDcYPK1NL2A1ZtcNZZZ+Hpp5/GSy+9hNdffx0JCZS1m5iYiLvuugsvv/wyli5dilmzZuHGG29syxOKrDmd/7GUQLHRqHQ/joxGWw1gqwOMCWJ2mKeZXgcoszLQ+eTPp8c9T6dMYyVobqDyO4BKI5sb5Per2EXbyr1CKZ4JSO0KJ2/AxbbL0A/78Uzi19A115EWr7OJAvbSoH1cEpU7x3cgrVNGUMjB3UyBqwkPBO4VwbLEbdXKDTab0DSuxzQquz+0jIKml37lm3EbH0QbUmcCUEsBLf/Fl+mP6k1iAFVqBIRarKPljIRzLJ4P/Z5Ixof/dXDZSONdp6P9WRWB0y5eQ5sgN6WPF4wdC2mp544hKZK9C321cgPdvwA1NgeCZ8f5gwVCAaB0G1XTAFT10HEgcHAJ/X1IgSyK1yNKn0jhbKJjAwDiAO1V9FBnAjhhGeEF8kxr9JXj0oWovGAOhqcZcClwpKSl9uY0YOpTwB9PkTTFFxcBZ71Mjq4SR2PwxcDaN0k26sASIK0XObOpuXQM6VhgsgTS7DQ148YfJ/o4CheBrglz5PUmABwFwqw1QoNFyZhl1W9r3wY2f0yvnftfItsYge2WOFFeDyCnSOJ2EFkMUAa/NYRclrUS2PgBnXtmXwp8MqdVivXvBT6GVP5IoyMZJY8zOGmW0Sv4eTHY6wFwdPxFD1G1jdxcN11oxDvoEmDNfymA3PkUup+liO8Q/PN4XpRy635a6HHsn1zQ5VTght+Bn26hee3Xu2luOucNZRVBbLwx6RIevk4oG38Gs7J7Wcm60BZVqsHOzX+syI0d6fcMOLbMrecfuUCD1wPMux3YMVckFbqfRvO7HMp2ULWozijqLIdCsF4gResoMMFpqRK0+lDo4236qPVzzkYi7YvWis/5nx+zlVxWCjYCgFfyW1jSAE2QYMyBJcHPi9NQQ/ijG4DsYcH3BYikzBpA6+iRVUC/c+X3U0pC2gQZJEsG3bcGi4QQ58S5lveSTWmrBcwprSuPdEb6r1R2R8lYO5brkf+Y4P1+U6mtpjPSYx40J3s9ravYtn9LQXGAbIt+54ROetAIJIA+DjAmBt+3ukr++bLtNNa0cUDXSWKvrVAo3+X7d3MDzcU8D4CXbL3iYwaOE39/RqLHS4KtNQcBLgBZwmxVKQZcABSuJVuzaB19p1NuVJYo47/WTn8O+O46sqGXPSdKVwariD1rDvXDKN8F/HgTcN67QHo3sttdDtoaTJJqBp6uVaRkmtq1SCmUEIPRgvQ7AG1nHzJJxECoF5oKhwr6MxKvQVCkMKfLE3v+fndtAY0FQzz5Kux1pcl7B/9Utp82EQD18kThOoALMIe0+FUhMP7e1s9lDaCqqqZyWq86DQEaQ/g9LMms5iDNW6GSZ5gd0UVQaziymsgZnQFweWnr9dA4kvasASQEkvReEmwsOZslhhhiaPc4aSsWGLp37465c+fiyy+/xMMPP4yqKtGoMxgMGDp0KNLSwtAdP5khLXHzL3dz2skJ5d2kfcwWBiUVCxW7yWjQxalrTOu0Utk7QFksweCoF7MRMnq3OEvNnBFbuIFwp/QgI7f7VAq2pPUgRyu+A/3dZTQ1c1ITYNj1Q2CtXSYdYA9R2SAHjgOmPknNrKr2UZBIKVjgprG8ddYLyzSoPwpU7KPsrUBaoycz5DLd/LMomqqINHA0+QbDXHYKbtQcJN1zl0Oo4BEy3/RmoM8M2nePJPAfDPZasTInnGaWZTtFUiF7BFXcqAkW2GuBahXVFf5gwRu1mXYtPRbCzPbrMYWClXGJNMf8cCNQe0TZe81pwJDL6fG2r4UghJXGRn0J3Rsum9gME2idiWMPQhS1J6jJ/Ay2b6BMJNYEGxDnnMxe8gRQ/jwiiwBg6hOBM6qDYdvXQGMZBd56Tw+9f/VBoSErB/SfpT7I7N9TITEb0EYxd0OrFzWEXbbQxHzOaCCtJxF2279R/3l1hUBTGX0X5lSqRUIWyVeNvRsAB+z6HvjwjND6vtL7S28WZeikGcpA+89a8x8rcmNHmp0nbYIeDE6rQHjbxGSQ5kYieaSkQqhxxRJBuk+J/Do7GigRA6DPNaVEdrxQYOS2yxH9IJkuTgx8bftK+fvYuq6295IcrEICipyuuH8Gvq2WbOOqw4Hnd/85PdgcfyJV6gVs0mwn4tou6ZtkMEkSGVyt5XL2LgLm30GPR98CnPpPZefAyIlIKhbyf6Ft99PUV5gyuBz0O7sdNO97nGSXed2Cj+I3Dnierou9lnyUFkIiTHAaSqg55XryqVx2IvfXvBlaws8f6b2A0x6hxxs+UNYvyGAGZn1Idl3VXmDZM62D804b3RcsiB6NNaStMqjl5JzaCtH+DuHMEU6bmESY3EYVC6wiQq7KLYrQeptxpfc73Oz9BHqvXUgwkYzFaKxJujjy8wAiPJT0/InvQDadu1kkcZSA9VlobiQ5JL3ZN/mKxRVYnzpATCZSUwVzIq0tMcQQg2qc9MQCAJx22mn49ttv8f777+Omm27CV199hV27dmHOnDk4evQoundXIK/zd4K0xM2/3M1gIqbfnE7ZH2wBUdJjYd9i2nadqC6AzYKElszgEiW8l6oVAApoBHNcNVoyPtN6EKHQaSj9HY6hUX0AOLhU/jVjMm0ddeqPCwgZ2U/Q400fU48KJWjRF7a2lodhJILLAXgdZAiwoF8wo/JkW/DlSjX9jWsOdJ+bk0UJMCaX43YL5eQewOP2zdIHKCOR01A2fJ0CA479tmndW2cXh0JFvuh4dRpGDfWU3stuB2njNhSr71MghYdJIakkFqLR+LDjEOCC96iiqaGYyIWjCsfK6H/S71TwF+BtpnnG66ZArtNO/3mPr2yCNJBhCpGheCwQjTGpphRebl+lAV+5EuqW41qB/b8DP99Of4+4nvSb1cLtoKbcAPXSCJUFzHupESxA8ixJ2eo+T7ZRcxsUhOqMorxec0Pw34rjgKFX0uMjq+SrL4KBySB1HhlZsEGjAyY9CFz2Fa1n5TuB9yYD694F6o4ClQfEICmDM4hERXtr3Bds3fRfb0IFd9jroaTabNX0mfWl9L+5Efj1XkqCUEoq8F6RWAiH2PPHti8FCaQcoPeZyt6jRkbQH7o40ALOR9ZnJBBSu9PxS7cGr9KQgjVwZr1LIkFLQC1DXu9aCnMKVWuYgmjL+4+rYOPsRBqD/mOG2Wg2IcDFA3A0Ag2l9LzLTmu7zuhL0BWuBX78B71nwCxK6lGKlh4LYdowtUeAsm00Z/eeEd4xeF70M/QmSkgyp5GvZsmgJCdTMvlFplSyMeMSxEQQrwtobkRc1Q5c6/0aWXyICr9giM8ERlxHkmGcBihcTY3iS7eqO07vs6jyDgCWPKEsYSQpm2xBjZ6yuNe8QXOgs5F8HpdDsD8U9gWUQyhfKFq+UnslzV02oPZoaBvFaSPfqLaI5q+6YrHHglKZIpvE5lQCFkxPalsZJD3fjCv4H3A+vxha3iWQCR6xOTUj/lx2IhzCJRq6jBYq56uA0u2h99doKekFEEkcJdDoxASTg8toy5IWmEKEf586WzVVmNuqAx62FU6ktSWGGGJQDcWe79NPPx3WB3Ach8ceeyys90YTM2fOxOrVq3HPPffgoYcegk6ng16vx8KFC5GTo5AZ/7vAR7IC4mOXjYx2xlJXHpDIgygw0vYupK1Sp5KhtoC2oRot1RVRYEqjV9aLIZooXEPGu7+EDatYcDvIqTaEkYnUfTLQ7zzSzl/8KHDF96EDC+y3c/pl2gO+JfPWGgqcW6vEQCnL5GkloRSB7EsgHE+Swr/0Vw6WdCIMpGPB6ybDKakTZbU3W4H4ZJn3ZlDWcOFqkitipdyBwIIN2SPUfY+qfSKxlTWIjD8lpALvFYw+VsXFkUPYFKZD2VKxEG7zZicZ1+FmEaXkAhe8Dyy4jyoX5l4JzHiZnNNgSO0K9D2Hxte2L0UpGUDMGHPaJY0e/cZGqHsoFKTSSuGOq2iUzCsZD8H2VTo/+K8vAKw2K2z11bBUbYV54Z3kdPWaTn1mwrkfWLVCQkeg1xmh9z+0jNYZXRzQR2UQVZZUMERGlAWDIZ5IPGcTZeNqtIGl+NK6U+Plil3A4b8oYKYUjFhQKoETCt0mATf8Qc09j6wCFj9EUoPj7qbXpZnXBhPZFHL3opr79ESAknER7hwgJ2sIiInJ7mZqVLrrZ3WkAkBEd2Mp3W/dJylrohrwWJspS5/TAMOvDS5nwlC2AyiOIADPcYIEip3kOZmMYbSgN5FcWn0RzTfTngr9HlaxULmXMssjaYbNgjWGBArK6Qxi/xp/mNOAjq3nXR/4j6tg4+xYj0E144PZaG47zSHmFNpqOKrcSOokXAdhzqw+SBn1O76j93SbRBWQSqs9gcibN+8RqhVyRpMNFg5cNsEG46hHXCuJE5nApS6O/ns95KO4HeC8blyKebiUnwdPbQJdv7hE9euwRkvXssfp1MOqsYT6q3Q7japElcjhAcDYu8jGLdlCvWGuWRi6oiNnJHDWS8Avd1Old3wHIG8i2eSAKIsULkLN6W3hKx1PqF2fnDaSj3W7gYRgyWqCAoLLATS4ifisL6bXlAb+rSqJBZbkpbQiIkx4OB0WYBKsMGMWFkPPCT1NpJVDvNeX6NXo6L/OoGyNBMSqhf2/UdXC4MtCyxsl51AyWdU+db2TcsdSX6Ejq4Bxd/mSdPEZrf0BWx2pW6iJe7C1BRDjEifDGIohhr8JFEeAnnzyyVbPcRJDg5ewrex5nudPGGIBoEbO8+bNQ01NDZqampCVlYX0dIWL0d8BTpvoeFjSfP82mEkWxtlExnlyJzI4WUAjUF8FhtojQPV+Wiy7T1Z3XnUFtA1GLDitIgERrWaZSpE7lhbaPb/SOUqdRV0cZUa5HSRLlBZmifPEB8kxbygmJ2jiA8H3Zwuxx00BB7kAhCWd/lurfDMEAhnEbeFMHksNUX8o0XjUm32DdtKgqMFEYwBuGhucVii1lxyzzwyBWFgYmlhgjZs7qyAWag5ThjcAdOgvZIgpdABrDomVRnEJFITVGsIjFnhe0rw5zIoFgIItLCM7HJhTgXPfAn5/nAKp8+4ALkkhvfdgGHMHEQu7fwbG3yfKrjDozfKBBnYPsQy1cIzgaDih0SiZDzIeeP9sKladI8wZHJNp8ZsfWr1P8jk8z4MTXrdZbfDaG2D44zGSZeg0FDjvrfCaJ/NeUTZuzO3K1oJNH9O21/TQGtk+n8XTGGQkQnLusVl7jElC8MxBAcaErMCBsK4TiFg4sko5scDzYlA3XBkkOSRkAVf+CCx/EVjxKhGujgbgrFdE2aNQkN6n0SDl2hpK1k015IN0DbdVk8RIXLwvsWAw0zplstD9uPp1en7Sw8qrD/YsoG2v00P31wgGnifCFqDxlRJCzhKgTMpISAUGnUmsvG0L6aXU7iSbV7iaSJiEjsH3j88kG7G2gMiWUE2Bg4FVLJhSqDCDZYn62+0uW+AqBSn85/9g9tGx1sdWs0ZKbTSvW5BGFSpX4lNEjX3eS/f4t9egJdCXOwa48CP1c7hWsBHDIZObG2luBoA+Z6t/PyBUKwhyq8ZE9eumRkvzh94Mpz4R2+vjMQI7oHU2Uqa/3hx+slZad+D0Z0mCbd8i4NCfZHue8Zyy92t1tO/cq2itXfGysmqSYVdRr4UN7wPLX6CkG5cwPvVGcT4OZw0JNadLX28Pa1QoBBp/gb4buy4JIb6zXlBAcLsBkxHwchLZY6XEgjAPmjNC78t7gYaj9Fhpc+gw4dKY8V9cBwA4D8ugl/ZYkPY94Tih2lvwoZhdZ0xSPo67jKYkDVsV+ZG5Ifwddm3VVgTmjqFt8Uax52Agks5lpz6cbpe8XF8gsLVFGpdor+Mmhhj+hlCckvHnn3+2+j9jxgzo9Xpcd911+Pjjj7Fw4UJ8/PHHuPbaa6HX6zFz5kwsXRpAIuY4ITExEXl5eRgwYMDfl1TwL9NkZdS2al+JCjkZJLcL0AkSIZY08bVQmVdM+4/TKGfiW85XCH4GC/hIm7+xhsnHCqzMXi6ea60SgrdcZNlpcfFitpsSJ5Hpb7PPdNnpuaqDpDEp7bvAShgBuhc8TnmDuS10RI+lhqgc1JYsG0xU6slkkVgZa1y8IJfj99swAy6UHnr5bmp0x2lF400tDPHqssoYEWDJjDwgyqoVwKkf31qDGPRZ8UpkOsUAGbkjbxL/VnI85pxotDRXqSW8IinfDaQRrQbHw/D2/85K5geXjdYZv/Fm1nPQ8k5oWIAnoWNraTGlaCilIJ/WAAy6NPT+rL8IAHQYGMYHSsZc9QFhfm3jSixOsp6E0tVN7UZbFnhSenyLkDm7+RP15xcMGh3Q/3zx/LV6wJTgO+aCSSFJ0R7K5pWMC7k5QM5O85cQ4/220ve6rFRlwHHiet9LQa8RBkY6h2ryHQq8R1z/QhG8DC7hfBM6RfbZbQ2tQQz+KJUR7NCfttUHI/tsaaauOU3sqSC12502oapSSAjyegSZoNZz8AkNNWsks9FMqRSw5D2UPZ3YiZ6XomovAJ7myKt+Aq78Kbz+BmbBfmmqUP9ej0toOM2FJqaCgTWtjsQW4Dh4jSl4VPswrtb8B16t0ffY4UJnAIZeAQy8iP5uVtmXypIu9sJiCWRKcPozQEpXmv/qC4Ux4CeDFM4aolSyTm8+sdYopzU8iaaAfUwCfDelvqLBTNnz6d3J3ohPF/0Sk0J/mdk1ihKSODHxSe09GE1wnBgLiUugczcm+V4vJf0SGHRx4tyh5Hup6Y0pBasm0ZuD+5pOG91jnBZIzg7Pt4mGXxRDDDEccygmFiZOnOjzf//+/Vi2bBk2bdqE9957D1dddRXOOOMMXHXVVXj//fexYcMGLF26FAcOHGjL848hHEiNAZeNdA2bG8k5lTYG1JsoyMyaOOvNVKlgiBcyfnigUtCWzRoU/DNT8ijI6nGKDWaVQtocKBDi4sVSSNa8+ViBZdb1O681ecB089N7Ki/VlIPTSnqhANDvnND7M53KjF601QukEO8mJ1N6LaVNVXUGug/YvdHWON6ZCJEY/Uyr15giGNHxrYmSGiF4ECrba/OntO09XV0gJ7Ur0FVo3lW0DqhUkYESx2S6oqA/zYL3Wr36knmOI7kivYkkjNa/F1ljM94LLBPkjLqfJjY3CwSvG/hd6GMy9Eq6/moJL2YEA+oct/aczWYwo/BoCVZt2IrDBQVBdy04cgSrV6/Grz9/h88/+xjrV/s2YjTrgbTMTuCmPk2O394FwMYPwjsvVuGW1DmwRJAUHEdNjgF1zezYe9N70NqmNwNgTdD3UyZzc2Poe5nnafw0NwJNlVSqX1dEFW62Wpr7Pe7Wx2HjVmsILtvRksmarO67Tf4XOYY7vwd2fKvuvcFQsRv49FzSA+84WJAd0fmOOYMJcDvR0nw4EAxmZfud6JALxPivTdLvyogCSxplwftnBDrtwjxkpXuj20R6nkmuKAGTdSzZGtZXaoFGJ1ab1hxS9h4mWRJp8IdV0iqVXVGLhmL6jdJ60nyjBCxTlmXOhgtGhqfk+TX7Nol2vMtONl9jJVWdaLTEg3o9yhJU/HG8+mwFC1QGOieDiWSPzOnks8jdA4x0NaVS5XG4Moxs/VAT9GYwpwpBQZ7mxnDAceoJrhDogCpoPEIAPloEX9kO2nadqP69bLyk91L+Hq1EFtfRSASQRtc6w9peLyTYtcG9fSIFSMP1dwKNPzXfLVAfGKeQbNLqnBSORUZaxymoNOU4oKMQq4h0XYsmOE6oXGC+mMoELd5LaxEgzkXBwGxCs4pKAkBMMhl8GW0D9Stx2ckuNZjDv+/bqiF6DDHE0KYIu3nz66+/jksvvRT9+/eXfX3gwIG49NJL8dprr4X7ETG0FaTGgNNGFQisXI1lPbFyah6idisgTPZptG0opiAKpwUy+wb/TI4TJZAO/qn+fIHQBh9rSNRYJmY9HCv0mAZk9vN9zu0ESrfRY7W6+f7Yt5h+g5Q8alQbDM2Nov5usiA7YLBQ5oA5nUgYOSeL3RccghufJ1MT50iMfubAm4XsOLlryrISU4MQC9ZqIH8ePR52tfrzyBooBoEO/qGcWJM2gY3UGWUSAKwRoFqY00hrndPQd1ATAPPHzu+B8h10z099KnSwYOuXQOUeCryOukVSjSIEK60y2Z3+Y4AZwQBdz9qjysbHiZTNphY6E45UWWFz8Sgqkg/I88K/oqIi2B0OrNu4DQ2NNuzcSwFGnufB8zwKS6uwftNmFOlycTBHyGr8/anwnL+6QtqyuU8JWLCCEbJqwGmo4ia9Jzl1phQAHAX+mypIBpA1EgWE39tKzzWUAtWHSOKhoZTWUybd4qin4GF9MQVkG0qEnig1NMez+yuUTE1LRp/KirmOg4FRQuPshQ/SOUaKinwiFWzVZDNc8SNlEhtM9L0qBUIGoDlZawg+NpgEV6j92iP81ybpd22pIpUkBVirRMLBYBKccgsF0fqdS8+zdUYJOg2hbdn2yNcHNr6USi8wYsHZFP5n8rwY8Ai3+ikU2L3a83Tl72EERH2kxAKrWPBr3mwwi6QCQKRdQoYg3ZhG9opGGx7ZciKuV8HOyWAiuzdJ8A2sNeJ/l120y6oPRJbMkM6IhTDnSJaYxQLv4YATApFR8H1MvB33eN8R/kgNr4rDH/VHKRFN6guqAbOlM3qrex/L5LZVU8UKk2+R3i+mJLHSJ9r39okUII02yaHmu/krIEifdzYBrqbWr4UC7xXXCKVKBcx/Lt0a2ZiPJrwekoT0CpVLcSqrz61VZG9q9MqkBh0CYW9ODb6fFLUF1IsMoAQsgMaSP1HHElE9zrYj9GNo18jPz0dhYeHxPo0Y2ghhEwsHDhxAWlpwtjMtLQ0HD0ZY7htD9CE1BgxmWpD9y9WYESDVbvUHM4IzeinT4O0m6Mke+lPdgt7SiDiEwWdKpu/Ee4hcOFbofAqQM6r18+U7KAPBlCpmRoWLXT/Stv/5oQ0OljVlTqPfjgUcDBbSjk/uAtnmz+y+sKQHNz6VOJdtRT5E+7hqjX6n3dcxZb0WXHZfKSQWkGaBlLQegY+57SsywrIGkbZ8OMgdS/cY0w1m0i7BoDMK2sB85JmhrGJBE4GcUvZw0sUFqIKjeLP6YzSWAWvfpscT7qegZTA4bcCyF+jx8Guo4sgpODr1JRTslJO4CjYGGipIl1gJuXAiZbMFAcdxsv9zcnJgNBqRkyOvV8sJ/3JycmDRA6OGD0JcQgr6DBjqc5yj5dVo9MShqNoGnHI98j1dSF7rx5tCSvh4/IOejBxQqtELiJVddREauwYzfW5mX0H7XEv3j72WCIbaAto2lgkkgk2UmdDF0f0X34F6EZhTaZ5uIet4midcNromjMwL1YTSUUdbtRULADXa7XIqjYefbolMpqwiH/hiFgV4MvoCs78VyU025hw1tGXN0pWMjXYyhlRDbm1i31VqjzmtYtUpC8yY0yiAndiRgmjdJhIhUbEbKFE4r6b1FPszVe+P7LuwLMoqhcfRGtAICmb+ftCFH/JdsLlUBoHcDlBmDKesckktHA1Ac73QN0xFr4SoEQuC7I5BaHgq/f1bgng2sVKhpRJZIB5sNUDdUVGermKfSFYEwok41pSeE7smDaWArRKw1gJpTCauDrDXhH8O6RFULACUHAJERixookcs3MB/iSxUwasx0FoUDRz8g7adhqnPlOZ5CbEQIonNH4xYYBUPDSVAzQExAYfdP5a0yO7t9pBwxYjo40FySCupGKSSOfoACW/B4LKLkkFKya/MfmRT2aojrxqLBjwuWkt4LyWpGBPVJ2ixtSSxk7K+DM1hEAubP6Ntt9NE8kJvpmMwyS9rNf3XGcT4UgwxCEhPT4fZbMYVV1yBvn37xsiFkxRhEwsZGRlYuHChfHNGAF6vFwsXLvz79jFoL2AVCP4LQEs2tmAA1hXTgsHgsgEFQsOxUDJIDF1G0XGbyqmZpOJztIifGQR2lxcHHEJWZn3xsctG6Hl662A/z1OzZYCa8YZbYg1QtmrpVjK++qqQQUrJE3sr1BX79lUIBmn2tWyJuQJHrq0y25Rqb7cVmHPKtFptEpLBIQnOOwWigWX5BiKWPC7KmAeA4VeHf59wHNBjKgUlPc1A/i+hg4AcJ2Yx2+vC+1yGSCsWGPqcDXSfQkb2ylfVBXp5Hlj+Et2vWYOAIbNDv2fjB0BTGVU7DadGazCY6Npp9UJcSttaGsl/DEidysRMoReNLvR9eiJls4WBrnl5GD9uHPJyc1uqDw4XFGDFypU4XFAAXhB/z8vNxejhgzHjzOm4/srLMGbMGB/bIbtzZ5QUF2Prtm0oLy7Ega5XoYFLpN//13t85nKv14sFixa1/J2V2wPjJ5+Ou+9/CF989Q0aCoW1RQ2x0FKxUBQdKQmtnhyulFySqmGBTXZsrZ4IfUu6oDHcg/ZN6EBj0phIryVlk9xZeg8a2+ZUKvnXmyg7TW8O3Sw9EmJBo6Vm6MYkCkj/NUf9MQAJqVBDjv3Fn/mSfgahiaMxVZRaVDo22vkYUgX2XaWJAS67WHXKAjMGixg08LoBrRHofSb9vf59ZZ+l0Yq2XaSyEWk9AAiNORX0+ti4vxxfbqRA75ZyL2bNtePUD6yotKrQnWY9IvTGyOyvQGDBnC6j1fXPkhIL4dqoHpeYPOBxExnXWCm+zux3VnGsN/k1XfXLErbVAh4H2TLB0FZjTUlQNtA+gc6JJYFIkwIckl5XnPBeVukcSc8LljjSWBaebZrZj+7RxpLQ5E4gREkKSdPcgLN5IgHcSbnqG0HLweWg5rIA2alqYa2iYCinVd9EOlEgFpoq6H6w1wHNNqCxQpT4ZQlVwfyeUDgRq3mOB9QQLEwyx5wGpOSolyBlAXKtQVlyI0C2GFMXON5ySF7Wf4incRZO43VAlPBUKsfXUsWqkODzOIFtgp864AKy41hFd30x9W6sPkDfJVgyagx/a3Tp0gX5+fn4/PPPYbPZUFUV5loXwwkNFSJuvpg9ezZeeuklzJw5E88++ywGDx7c8trWrVvx6KOPYufOnXjggQeicqIxHGNItfHqioHmOgpQsOzI+lKgTJD56TDAt9FQsIZWXScC+xYBh1eQrrrScwHICAniIE54YT32FVWg5J4EWGAjYyMhC/BIFurEzsB2hc0ox97Z+jmnFdg+lwya+A7AgFmifrAUlXtJxkJrAHrPEL6DQqfYv5pgz6+07X6ab5ljoGvRkrGbS5/bVAZ4PJShEcwh9D+e1FCWvk9vVtaUi5XlRxMGkxjQbYtggRw4yf3DmiOyJoBeofGeywEYEwAITcT1Rvr9WVZhajcxiCAlII6spn2MyUDuON/XlGaTSB21LqcCC+4HbFXk5I64VnxNrgJAayCHy2UVjPO40AFI3gCwpDiNFuC8YpYcy46UQmmW81GhH0n2CKr0qC8C/ngaOOVGX73RoQEy1vb8ChSupqDtGc+F/h5N5dTPAQAmPEC/ocFMgc3kzsF7H/iPATZWeFDgN0PQew12/0fz/o30WFHs9bBz505UVFSgrq4OuV264NeFC7Bp40b07pqDHl2zkZmdh+qGIhw6eAg9crMxqG8PWDgHnHWliAOHbVs2ITsnB/MN5+Jy19f0u275tKUh93333Is33nwbUx77HgBgt9mwcvUarFy9BgCw9noLRnXW4vl3v0OXA/E4b+pYWCwhvpMphe5dt4MaPwdz0MbcruxCbPrY92+nle4Rg8X3fjYozLRT6nD6k3tMg9ic6vtaRb6y42UPJ0mxX+4CVr1OVVVyFXrxmfLvr9gNfHEhOaNZA4FZH1Egtv4ojReLkPFmBqCzi6SCUhyrdeBEBZtjEoSttYqe08XRdWSVdUOvAnb/DOz+CZj2lPh7BQsAdB4BFK4hOaQuo5Wdj1w2sjmNbJfaAhpfqd2CNoR99LNVyOI9+McI4KxecXhpjQfby90Y+ZEL/5mVh3MHp4Lz/939CTY3q+ixSF6TjDt7HaAJkt0drNG11yPKQnSfLBLrwcDWyHghA9zZRDaZf9NRJQEZFnzmNJQY1FRNckct9odJ+G8U1zVpHxaDRZQ6NVhApE916+bGxwpOYdz725o++wSwR/3B7DW3g+4xt0OUFjElAg4e4Dn67tYaIm4biikwljNS5ngK8u/MafTfVk2Z8KxBtxzkMqvj4oG0XtRMuno/kJqnPEjIAqp6J9DcAK/XC41ckFVh/yB9HNlr87mpmDZgJKANQH4pJdNMyUDRIrrfEjoCeePkr2mw35Sde0qukPChwJdi9jbrWdZUTvePMRktcjMuO62rUttH6X3mD6nPE601qS3Wtmgf058cDXT9nDbq9+IU5idmc3Kg34Ln/Y7FIWifBY9LTIgyxAf2M+TGW85okiku2w4MEfoF5I4L/j0ZmN1kq6UkLoNFXoaJNwCM0zQlA5xkjeB5+v6M/DYmAcldAU2QuSZYD4mGUtoq7T/CCJn4jNDJYBotsGcJ+bOWDCBrOI0/Wx2tLa4mkmHSxVFyQ3KmWOlorRaq+mUUEqIFJeT8iSJ5FQO6dOmCvn1VVp3F0K4QdsXCk08+iSlTpmDBggUYNmwYEhIS0L17dyQkJGD48OFYuHAhpkyZgieeeCKa5xvD8YAllRYQJungslM2LsvwYWW8StBjGm0P/K78PS3Nm4NnQCSZDWhoBn4+IBgjlXuVf4YSeFxA/nxalI1JVD0QaFE+JPSRyBkdWXDd4wJ2/UCPB16s7D21ArGQlC1kpjkoeG0LIo/DskykVQ1ypatKIc0ii2aJsMFCxlBbGiqB4LSKQRqW3cTkpix+usV6s2j0WjICO2H7F9O257TIs/0BMmBH30yP9/wSOgtPFycarOFmygHwuKjp2G3fFuLDVWXweiMw5DRaoP8schbstUC5guomey2w7Dl6POoWZdJjrLqh42AiOU0Sw11tZiarYIhP981+ay9Z1HLZdmGO2z179uC3xYuxZ88eAMCmjRtRV1+PlRs2o8ljQHF5Dfbv3w+bzYYNq5dj8aKF2LL8V+jdDTi8YzWOlhIZN+GCG8BPfowO+ttjLcEFk8l3Ptq4Yik+fe8t3HHLTRgzeiS6p5JZ89WSDbji+luQ1e9UXH3r/fh9+Sp4PAGCmZxGrHBg82e0YbDQPKCmKV80wOYhU0r4x+g1HRhwEQAeWPiAMqk1QGzUbKumcXblz6L8CMuYZhnFrMrLX3bsZEJbyGVI5yqnTezxwoK1llTaZg0iW83jJKk5JcgeTttwZOn8wbJEy3eH3NUUp8PqIhqr/dI5rLx3AHJT41BQ3Yzz392LC97di9L6EMF8af+baKNyD92/hnjxGimF3ki9roDwpThY42ZjMtBsBRKz5HtnBVrH9Gaa71K6iPtk9hYzto81pAkjAfdRKcPkb79K/zYlisRDkjDvR1KxAIg2h9IG5f5gPU1Kt4b19vwKIq6OVFvx4ZqqgGoCocA116MMGXifU1DxqQQ8LyZH9T5LGVHjj+oDtFXSmNYfTAqpsYzmvqROQIe+wrgwtbZ9lNxnLhtQW0gVlf59to6Hb3IiIdD1M5ioDwirSnAKlXY6lYkEUrQ0blbZAyR7KBEsdUeApsrQ+8uBJVm6HOoC1zxP583O3ZIBpHQLTioEg8cpNm6WS3KUQ0uPBYUVCyxJpvcMwBgv9mJ0NgmfrRGqb7PF+z8ctYQYYoih3SNsYsFoNOK3337Dhx9+iIkTJyIuLg6FhYWIi4vDpEmT8OGHH2Lx4sUwGhWWp8VwYkGqlwdQ1odRaHDlchBr31QGgFNJLAjZ1cWbQ8qvuFwuvPnxN7jzrQUAgP2HjuDXVTthbyaHkud5uNyeFgN60ZPn4K/nLsC5ZwmZZnWFrcpSb3rrz/AMbq8H2LuQsl50QjPEQIanvRYo2UKP1WjvyuHA7xSIsGSQTrISsIqF+I503t5mIM4SNPkDLlvrxlpMjzNSQ/lkKRGWaz7GrhEjGaQkGJPCCiiD5BQbmfc8I3rnmT2cssJ4L7D2rdCl8S3l35WqMzsKqx248bO98ArZoT/vasT1n+3HqS9tQ0GVI5yzJxjMQGche7BwTejzWv4ijbu0nsCI60Ifv3IvsPULejz1SRofinSaVcoxtBfIOYMKxq3VZkNlVRVsdnuLFFJ9fT3MFgvq6+vh8Xow+tRTcejQIezYvgNvvvkW1q1fB5MG6JhmgSUhAQ6nGzaPBpb4RGiNiahtaEST1YZOWR1Q3Xk6CrlsGivLSYbn6aefwvnnn99yDv95821cdtEFeH3Oc1j169dIN9NEd/G1t6Jb1zw0Wa349JsfMW3W1egyeAJufeAJvP/ZNygqLvH9MqzZczgNnE9kMBIgHCkkKU57GEjpSmvgksdDj0kpqZA1kBo1s+xsFmRwSzLGDSbKNnbZgaoDERGdJyyUroXhEhAGM11Tna51I0y9CRgmVLBt/FBZlj0LmlfujTw4wIiFitDEwlOXjcLBWi8qrV5w4JGodWLXY0PwyBnZ0Gk4/LStBv2e3oLH5hfi641V2FLU1NquY9+/LSQZitbTNnt4eEQhayZcXxze57OxYUqh39pgEhs2y90zJ7r+u5L1U8k+0gQZqf0qTQphySA6I0kjsWBcpMRCSlfahk0sCP21SraqssNqrG7c99NRnPFOAQCgcwKHm74+gks/PozKxvB64ryquQkOLkq+e+VeuiYafXgySIDYqyw9SK+yQGDEgr0GcDTRY71J0IY30ZzpcYp6/0ruM6eN+mg1N7Z/vyYakM4vTFufXU8GJrvMrqs/0RAOWHDeoLBxM0NcIpDehx4Xb1T11vJGN/61sArnflYNlxdETnoVjjOeJ+UHdl3iEkhFIZIqkvqj5OsZEpQlj/BeSY8FBcRCbYGQKMkBfc+m5yxChZbHTRV4ppTWvRv1JkESVq++KXcMMcTQbhFR6hzHcbjmmmtwzTXXROl0YjhhwIKo9gbK7mGLv62OjPK/Xqa/B16kTl82sSNJJ5XvBIrWBiw3X7h0Je556lXsOXAYk7tqAVjQbGvA2fe/A42GFmGWFZ2blYrHrp2Oq09Jxvj+negAVZkk8VK1D+ggZpR9uXwvnh0Yh5wkFQu5100NcWsPC30OZgZfwA//RYt3Wk/l5cyBsO0r2g68SHlGO2sgl9aDsr+T84gMsgQ5Z72ZSCR3PRk95rToZd60lSzSsQZz3P0bZ7LnpOXnLrvY8DI1gCbskdWU8RHfQcxWixZGXE8Oas0hqrLpf17gfc1pdG+77SSJFAIeSTVC/6c3IcvohH5qAtxeHlec2glvLi/D+oJGvLuyDM+dlxf+d+g0FDiyihzCqn1ARm/5/QpWAPnzAHDA6f8mSadQWPpvGqNdJwIdBgaX92Il2wBJJ+iEcdheSQQ5yH1/BePWarXC7XbDarXCarWiqrISeXl5cLlcyMvLg8PRjLq6WuTn5yMuzoCmpiYMHjIYnNeBwf1PQT5cKK2sRXlFPVauXIXC4nIkJMYjJdGCG665EtsPlmBERw3eORXwbP4c57+0FEu3FcLhdGPKgCsAAF98/S3+ed2VGHXKcGpGCgDmNPzr/ifw6L8ex+q/luLzb3/GNz/9ipKycrz14Rct5z94QF/MPGMyzj79NJyS3IUyLSJt4HyigRELjjoivO11gKOWpInsdaS36xC2idnApIflg7F6MzDjFeDLS4ADS4Ad3wCDLpX/TLcD+OIioVFzH5I/kkq+6M20hho9vs/pzUQqeJoFaZaTrEeX0rUwXDkOvRlIEWTc/OVQDCZg6GXAXy8SOZQ/n6QcgyE+kwIfDUcpQJg9TPm5+IMRC7UFIUmKwV3T8e0D07G+aAVm9AS2F1ThjBHJePbcXFw6Ih3XfXYAGwuteGahmPF/1uByfHvbSJjjBLemrSoWmpvEHmGdTwnvGEmdSYoj3AbONoFYsGSITU9ddkoicNl9ExxcDuF+MKi/n05EBJPtY+PGZfe1X63VYoVJShfxOZ2O7m8AqDnOFQsZfaiC1FGniNx2uT1484cVePK9nai3e8ABcHsBvZZDThKHuVtqsWRvA2b0S8LoPAtGpXgwJEsDnSa47+PuOAzbKoJIOanFXkoMQ9cJpCEfDqqEigWlUi9SmNPIJvQ4AWsZSYZJ1ze27qiZbw1mCuRyaP9+TTTgv14pWb+USOqG/FyBKFJbsQCQzF9lPlC8Sew/JIHb7YHL44WG46DRcKisa8LLXy/H/346DLuLfKCvexlx5WADmpqsiE/0C6fxXsTxlFxVb3OhyduMdE2TSEIYk6PT/4f5+ym5yo7ltIpSYkqIiE2CdHTuqdQXi32EwQykdyOfSE5Cz2ChCgZbtXAfCGSvEtnVcKRZoyjnGkMMMYSPqNTkezweVFVVobm5Wfb1Ll1UNFGM4cQAc1TYghGXQAuSMR44tAIo3UKTN5OqUIMe04hYKFwD9JqOZas3Ys7bn6C0ogr1jU2ob2hCdW0dACA9NRlXnzMcwAbkpMShc6YeRyvqfA53pKwGNzz/JV7qlIynZ4/C0G7pMHOd0RkV8FTsAZcg9iW48fT+6JyowoHwOKmMt66QgvR9zvZtOukPr4f6RwCRVytU7gEKVgLggEGXKHuP00oNSAGxH4M0S4Q1XJL+zQw8g50cVlalInXMpAF0OcIh2KIeDQPyWCHY9zBYWl+TumIx0CwN5OhNQEMZPQ5UsXBwKW17TAmvPDwYTMnUDHrNm0ROdZ8ceF+NDjClkgFYVyg0LOaweJ8dHIApPYzQajjwPI+Fex14YEkNsgW1pQQD8MYMyhbS6ePw/PndUG/34u2/SmHQkgVaXNWIm/+7GPXWZiSYDUg0xyEl3oj0RBPSEkwY1qMDxg/IaX1eujig4yCq/CjeIE8sNJQAvwtye0OvVNZI/uhGYP9vRBKecqMYjA5kkDInyd5AGrGNNfKaqicbJOOWNWH2h8VigdVKQcL9+/dDq9Vi6NChGDNmDHbt3Im3334bWzauRW5mEly8BqkdOiErKwupWdlY9Puf2LV1Izw8UFFZjeIaK/TmRGjhwe6DxVi9bguqauqweYcXM9NMOLuXHjPTDmO+1QFdnBgYeO2lZzFyhBDwZFrMplSA58FxHMaOGo5RwwfjsgvOxqdzf8Sa9VtQWl6B2voGbNuZj2078/HMK29iRF4iNlwNeOqKsOSvDUhJSUFqYjxMRj0Meh0Meh20Gg2gdYPjuBb/ihMczziDvrXu+/FG/VExO23tW6H3rzkI7PgWGHaV/OuZ/YDx91CF0J/PA91OEzWspdi/hLT0LZnABe+TVIs/DCZRrkcKUwqRIUp7zLQnKF0L1ZLx/uuW3izKStlqKBhgEiSRhlwBrHwF2PBBaGIBIDKh4Sg1746EWDCnUs+rxjJFVQtTB+fglbUezOipxcRsN2Cvg9eQgDidBnMuyMPcTdUobXCiqsmFXSVNqK6qwts/rsDtEzvA4LFKiIUoVywUb6LATGLn4LZgMCQI72MSFmrBpJASsqgfEIN/4gMjG1hDTSUVeSd6cCZY0JKNG//fnPPbMjlXR5N4TWoOATWHqedCOGB2HpPtUQutnpKuijdR/44gleC/b9iLO17/AfkF5QCAQZ1MeG5mNnS6WsDrwqKbcnHJF+XYVmzH5xtr8LnQCD3VxGFmLx3O76PDtO46mPWt1yt318lARXhfoRUaSinRCgD6nBXmMUoik0LiOCJI64+SfJHcdWX3DSD2qAlVPROfHqtWYPBfr5SsXy4brU1Ou9BrgFNPPDULxEI4SXDZw4EtnxG5IFSA8TyP5VsP4cMF6/Hd8h2wN8tXIozMMWJgRwPm7rbhysEGxGuaKZFRAiOAefCrnvYCACdUmilIgAoFRz35M4AKGSShcXNcAvlYwcDzYnLj4MvJnpPOrZY0+h8IrJePlOz1n7/l1pxwEivCTcaIIYYYooqIiIVNmzbhkUcewV9//QWnU76smuM4uKXl7jGceHDaJEFjyYTssgnNFdPoecZyxwmLeFx88EUlELpNAlb9Byjbgc++nY+r7nq81S5arQaTx47E6GGDsK9yD5AMJOndWPDc1XBpTDhcWoX9RZXIP1KOytomrNtdgH0ldbj0ZdKs12uALf+woH+mE96983G2Nh2/cFPxn+vHg9uuMKPIZQd2zyPJJ42OKhWSQ5BkdQVAcz0tbKy0ORy4m4Ff7qbHPacByTKBVzmsfI0yIhI7UyWJs4mqTJKzxUXcKzRydjp8s6/1ghSF3ohWcUR/48AfJ8uizr6HtUos6Q2YVSFohLpdQLyMtnFCJj0O1DSPGdGF64jAUpJprwbdpwDbviGyqKEk+L4JHcnId9QDnAZ/HNFg+kfkjGbGa3B+PzP2V7uw9GAztPo45PFOnMMvwa/3mqGDkHUsBNsbm+nvH7ZWYfHuWqxlRFsQfP3gObhk+hjfJxvLgLKd9FgrYwA3lADfXUv7JecCY+8I+TkAxKbzXSdQVQ/HBb93mZNkSaXsnASZQOrfCAUFR1BUVIScnBzk5eXCZDSiqqwIJt6GiopGWF08iouLceDAAXi9XnAuGxL0XnTKSsegsRMwftw4lJSUYP7iZWhuqoW1vhpcnAW1NTXweHkUFBT42BNDhw4B19EIYDdmTJ2AvXNeR0ZWJ1z6Bt1X3bp2hdvthl6vp6AQp6FqoU0fASOuQ3FpGWbOvglbdsgHM03GOLjcbmwsaMCh2nh0SwF++ORNvLdZnYxEx4wUjB/WB+OH9cX4YX0w0Mu3VNcdF5RtB1a8qv59oWQ4uk8hYsHTHHjfkq20zR0rEg+MsAbEBs0tPXiqxeeYsxptsvVkRqD112WnPhYAaVkbTCS7t/IVImyd1tDBhV5nUEXY9rlAz9ND20DB0GkYZTDv/w3IDN7A7z/ztuK7XU48NFYPs94NNBxFvQP4ZLUDm0u9GNxBgwk9tJjWIw6pcQlCsqYXsJW2HMMGM8xyjWzDhccFHF5Gj5U2s/YHz1NSDUAVB+GAVXz4kwi2WmqCzu4BvYkqFoyJfvdFAAKhPdhxwYKWerPQGFWQ3mC2KpOplPZb8Hro9zQkUp+F+kLg03OAm5Yp1x6XIrMv+Qn1RVRhGU52fbfTiFjY8S35Wx0Ht9pl0dp8nHnfOwCA9GQLnp+ejmtHp0Gr4YAmO9DsQm9LIzb/Mx35VV6sLXLhlz12/LGvETV2Hp9sc+GTbS4kG4HPzifC3gfRskMbSoD175I/kjUQSA9QcRrqGN9dR2tNavfwKsAr9wqVQRzZ5LY6tDQ3Z2BrkbVK+f3fHsbKsYI/Ye7/t8tGvWDYGg+QLd1YTPOT20lxBa8kVqSoabqQfFB9kMa9msSO+EyqEqrcA6x/B+h3Pp77fCn+9f6igG8ZOzAPj492YVovMziOQ365A/lVNeibrsxW2VnhQZMmEaO7RmGMFW+iNdllI5kxmblCFkxWTEkfOvCi3JQ5o3WMSIpAyYf+lf7+87fcOApH5eBkUUaIIYZ2jrCJha1bt2L8+PHQ6XQ4/fTTMX/+fAwePBhZWVnYvHkzKisrMWnSJOTm5oY+WAzHF/7a8UynlZUZuliAVTDG+pxFi3JThbJyen90HEQBbFs1nnn1eQDAVReejZnTJuDXP1bim3mLYXc0Y8lfa7Hkr7UAgMtusaB/phb/mvM25u1tTVRdOnUYeqVp8e5vu2B3uqHTaHDe917MOc2L8/rocTv/EQYiH/AEkKXxB88DO74jGRbWUyFBJuvSH+X5tM3oE1mTzmXPk0FsTiN5FyWoPgCsfZMeT3qYjLWmSsqEslYDFtBvy2JBLCgeBwo+682k/Wutab04y8kASXGyLOrse7idCkp5hWsRLxhSXo9QESKMo9zxpGW9dwFw5hyqeJFixPXUt6PmIGWPjr4lut+F4+j72BBaTzsuAejQH6jaD3iaMSnHi/vHGPDyaicqmrx4Zz3NBSYd8PKZRlzkvQcZIOJhV4UHTy53YlVxMTokVmBQJws4ADuKxWyu7LR43Hr2MHRIsaDB1oyKOhuen0tjW6fVID3J775qKAG2f02ZTInZROr5v/7dteTEJ+UAF36o3LmT9o1JzCJHOti9K3WSQt3n7SHjM0IUFRXBbrejqKgIeXm5OFJYiKK9W8DxHvTu3hU/LFoOnudhNpuxbds2lBUVYGiPDhgzbiI8Wg5Wmw3btm9HekY6iux2JHbIhdvtxtRJfZGfvxv79u1Dbm4ubrn5ZsyceTa6dOkC06fTgUqgMmkI3nz5FcxfsAiDbv4fAOCci2YjMd6EmWeegQvOmYEzx94Hw8qXgGXP4XCjFhP+MQdHS8qQmBCP8aNPwchhg2A2mfDTwiVYs2EL7A6x0vKNdU68Nt2Iu0cb8P5mV4A6DXmUVtZi7uI1mLuYgoZJJh3G9kzBhF6pmDkkE/2yj2GVy4HfgQ3vU3AqvTdwyvUURLNVE4Foq6Igiq2a1jh7Le1rSgEGXBD82Du/o23u2MBrYu1h2loyxMoE3g3YG0la0SmRa5E2bZYbM3+DMdUKgQjuQNci0LykN5FUjstB65LTTnOeOY1++9JtQM7I4OcyYBYFMA4vB5a9AJzzRvi2TZ8ZtB4e3UjzeoAM1YOl9fj33I3wennMK8nApf01cDZWI8XowbOT/YkCSnhxQYcVBU6sO+rC1jIPtpZ5cai2Ac9cuB/3n9UzOiRf0Toi341JYg8g1cdYSxW7ujhg0MXhHYMF4KSkia2WArC2WjEwrjeT/I8/AgVFg61vJ8o4DFX1I5cE419tysBzgDkZmP4i8NvDJCvy631kT6itPjMmkbTiwT+IiBt/n7r3A1TlXHMQ2PUj/TdYKPlBggSzSAS+fOu5uLrDXgBAUa0T93xXj3fP5JBickHjrEf/RKB/f+D6/hxKG+Oxp8qLkkYvtpZ5sLuKR89UCojyQnVf1MBIBaeVqgxOe1T99WSkArPxLnintQ2tBKv/j7bdT6PgKOs/I+fLqPFjThafJ9oIlIHOu2n9AYQqBbuQMKShajpwvveIEunfnNEUVK87QhVHaQr9ewBNVjvQ/wrEr3gaKN+FZlNHzPl6GQDgytOH4Z/njcGArlnweL3w8jw4cEhOMMG++h0crHahzu7FgCwDdGlZeGVlLV5fUYtqm1dy+nGY9CDJbl5XeC++3liFb7ZZ8eBpBozuGoEt6LQCO+ZSn0qAxsawK5XFJwAiJAAiMUOB05BfeHQDUHsI6DwsiO8jzLu26uDqBv7zt9w4CkfloD0pI8QQw0mMsCOf//43BTvXrVuHvn37QqPR4Pzzz8fjjz8Ou92Oe++9F9999x0+/PDDqJ1sDFGAdNEHxFJOjU6i0+oWgs86CuyxfXRxtI/WAAy/lrIW17+nnlgwWODN6ANNxS4MTHWhU7cRuOCsKbjpgX+jooqClf16dUOPvBykpSQjVdOISuwHUI+pPUyYt7cRXTulYWC3TuicmYx3fl6Fr3/fjNkTeqHko2tbDOSqBjvmrT+Ef6/ZiodPBSbxa1G+cRMMcV5oNEEyDHgeAE8BF0M86dMrzWBi2rsdItAoPfAHsPlTenzWy8qz2hY/SgHk7lOoSRrvpeoDrZ6MOCbbExcvBiniJVUMLCBuknH2AzlmDCfLot4iC2UL7TTIXROXICdVV0JGblwiyRYUraVAnBSmFGDig8Cih4iA6HJq9HstsOwzJY064xKI9CvZCq3XhZemGXF2Lz28WhO+2enAgHQe5/TUICeJB1CDCqThofll+GSLHaztQmm9E1uLrOiZYcSMgakYnpuA0WMnonvH5JZxyfM8Zr80HwBg0Gnx02PnY8qQPPE86grJcPY4Kfg06BLfAIo/qXDRx2KDPiWw0xxDzegdgtap3+8s7asA+EqMhGrqF6rM9wRGIMkjaTJYTk5OS8UCAGzcsAElRYeQkWxBRuee6N+/P0pLSzF27FiUlJSgubkZ5Q4OHbv2hDE+GW6XCxazGRPGjwcA1NfXw9HcjPqyI9h3gKrJLp89G1deST0USvdsQM/KXfB4eUy5ZQ6q7Ty0ejG4kp6WhvKyEnz65Tf49MtvYDabMe+6zpiSVobUVU8iwWlFn57dseDr99E1V6z8uu+2G9DUZMWmbTuxbtM2rFv5Jxbt3Y96hwd9M7Q4o4cOiw4oq7bMTE1Er9xOOGVAd+w6eBSrt+5Fvc2BBdsrsWB7JR76bi8G5STg2nGdcd34zkg0KeyXoxY8T2vHnl/o77xxwKhbJE66RErCI6nI8HqFSjtTa21+KdxOYOcP9DiYPB/T/e001JdAMAuavkz+yGWjtYmHvE4v8PfMDA1EcAe6FoHmJYMJMAjJAizYakoFOgwCDv9JQYZQxALHAWf/B/jfeJIw2v4NMOTy8L5XYjb1JTi6AajIB7qMkt3tncU74fXymNC/Ey4dSQGTcz6sQKrWhicnW9AxQYuFe+3YXu7FhhI3tpV50atzKvpnk63Uv1ccGrW12Fddjofm7sKaAzWYe9tIIJIiGI+LgsYA0H0qoA3TfVr/Pm0HXBheZjwg6nRLx6o5hUgFnZEytF12qlKJl2lEG5CICrJOnWjjMNDaGioJBhASbDx0rUzJgCkNmPwE8OONNHfu/B4YeKH6c+p3Dt0je34FxtypvC+aFCOuI/L38HJg29fka7Fm3wDGDuqGey89Da98/SfufP0HjLu7B2psbpz5v/2otnqwuoDD9B469MvQoF+6Fv0yNMhN1qBjAv0HgMslipEFdV48/IcDz002omtKFKrEpKRCUmdKjFIrHem0At9fL7HxPlJn4zHUHxWJ8FG3AKl59DjQvaHGjzlZfJ5oI1AGOqtYYEkGepMoz8f2q9wnHodTQCLFxQM5o4AjK6nBsAJiwdHsxB3PvoP3viV1gw+v7otr84qhPbwUHeKcSEtMxbv3zcITHy3B818shdXhhNXuRKO9GaXVjahpEP0Ck57DxG4mjMgx4rVzO2B0rhGHa9zYX+VEk0eP+UID9Ol9ElBaa8c326zYeLQ5fCKvIh/Y+kVLZTl6nkEVhUoJN6+H+mwByqWaOwwQiYVgcyqbd5nNwojdUGoHsXEUQwwnFcImFlauXIlzzjkHffuK5cy8UBZvMpnw3//+F6tXr8YjjzyCL7/8MvIzjSE6kC76AD3W6HwljVx2wJLg28BZZwDsEsmkYVcDf80BijeSlrJKo297tR5DAEzsbsYFTz6LS255EBVVNeiW2xlz/nUXzj9zsrjwHllJ7PzO73H71Dzc8uD10OnEhXTy8F649PGP8OVf+zBxQCdcPrE3XvlpC176cQtszS5889A5uE8zCY9630AHI8lttEg4+C/ujFQAKODY/3zluo8uu9i4LUSZf0BYq4CFD9Dj4dcC3SYqe1/VfnJoNDrgjOfIkHPZAWMKBU95SGR7ZAKkLptoNARrUByths4nOpQaO3LNm+tKAA1H173HFMo82/NLa2IBoH4jPf8E9i8mguGyr5Q11FKKFmJBoayLRge3xoQPNzlw5QANJuRqAbgwIE2LdBONi2o7j+/MV2A+Nw2PTX8Bc2Zr0OjwoNbmxl/76/HvBYXYX+nAD1ur8diMLkjt5Pt9ahod+Ho5VfZ8cu9ZOPMUiTNQc4gcQa+b5I0GXOSrReqoj4xUAMhpBwR5hABBVGlfBVOifDDFZaPxykMM3igp820nsNnsLU2ZbTYbMjIyUFlZiQMHDqBHjx7Iy6NqRJvdDpuTR42dQ2JaJvQV1Th69Ch++OEH1NTUoL6+Dmlp6Xj2lbdgsZhx6HABmhobkZ3dCSNHjkRcnBHFJcVYvHAhKqqommTixIkwGum3KV7/DQBgdZEHusRM3HL1+Zhxzrl4YyNJbh3cuRGbN23CD/N+wY/zF+BIYRHOfGsfllxpxsQ8HZZcmwLL1e8hOau1nFx8vAUTx47CxLGjgPOplNy7/Vvg0FL8+M+BKMibjSabA012BxqtDpRW1eFQSRUOHS3HoaMVOHS0HLUNVlTUNKCipgGVtQ1Y98VzsJjisPWn/8OKfbX4I78Kv+2swvaiRtz9VT4e/3E/rhvfGbdPzUX3zCjOp143SRA1ke42Bl5MpL8SB1ajUTbv7PyOiNP4rOAZb6xioeNAIQBo9w0gMDjtoiQJ6wfASAaWaf13zAwNRHCHey2kwVaDiRoxMmJBCZKygTG3UTLJxo+JBFckpSCDvudQoKL6ABHpMlJM6/fTPVzbRNVEbg+PZfsb0ezm0bNLAtYcasSSPZQIMa57AsqtjSjfW40Ve2n+yE4x4qVLBuC8YVm47bPt+HlzKT786wiumRSGRjuDtFohR54QCYnKvRQw5jQUQA4XXkF+UBq4NqeJlSjWSsBeD5iSAKeMLaPEvvEP3Ae6944XeR6w6iJEEgwgSiFZJI2vE7PJ3tj+FbDwQSB3jPoeGrnjaB61VQNHViu336XgNMC4u8nGqTkEbPkcGHmDDwn1/M1nY/XOw1izswAz3z2AMV0tqLZ6wHHAV9f2RHaSAXV2N5qavbCadag36ZBgO4z91V4cqqWs6p5pWuyr9uC2BQ4cruMxb28Tnp8ShxvGqqnT84M/qTDyxvD6Ua14hRJMErLCJxUAYO3bdI/kjlUeSG1nySAnBKTXLNQaxcgFc4J4fV02oL5Y9J85rfIKl26TBGJhGVWBh3jfrgOFLaQCAFz/ST7OfqY/MlxF+PQ8E/7UjMSB4hq89NWygMcw6zmY9ByqbV4s2mvDor0UTzk114hPLs3C2K5JcPAGzLeL7xnZhezZP/bbcMEnJXjvoiykW5QSAl6qGiwQZGUtmdQHi/VRVIqqfTQ2DfEkS6gEHQUWsvpA69/UR0ZbmHf1Vt8YghKiN4YYYjhpEHZ6Qn19Pbp1Ex0LvV6PpqYm8cAaDSZNmoQ//vgjsjOMQT2cVpLAYc3rpDCYxSZu7LF0wjeYxZ4KepNAOqTSloeY2R6fCWQIwXNWkqcQVVVV+N+v9J6LR2Yju2Mmhg3sAwA4Y+KpuOCsKa3Z/GRhAW0ohk7ja/jOOm0IXrr1XADAfR+tQs+bP8MTX62H1eECzwPPfrsB+Vwv/FPzHBYe8JAWKQQCQaoRLSUVAGDQReqaSVXupSqB+MzwtHN5L7D8JZKlyOwHTHxA+Xt3/0zb3LGUtaE3SZpfugHwlN3Bei1IoTcD5nTRMLCk+zpm/lJZJwOcVmrkVlcoP06UQu7aJHcCDAmUHTVAyHrb84vYo0QKjgMm/wtIzgOsFcBvj8rvFy5Y4MHTHHw/AS63F5d9U41/zLPi1A+sqG8GAB7pJh5WJ4/3N7tQ4EjGD5oZcHEGDM6JR1q8HnnpRgztEo87p2Rj39Mj0CPDiMKaZlz18T54PL7fJy3RhMHdMgEADTZJJUXlXtIW9rpJT3fgxa1Jha1fREYqAOT0A8EDqWxuZHOfnJPktFHzOGeTSNTqzTR+pJlaTDbEWiU2T7dWiTrZJwisNhsqK6tgs9lRUHAEf/zxBw4dOoSioiI0Nze3kApWqxUHDhwAL0yfI0eOxJAhQzB27FjodDqUlpaisrgQ9WWH0bNrLrp1647a6gr8sXQp5s3/BTt37kTBkSNYtXoN/vPa63jhxRfx2Wefo6KqGgaDAS+++AJ69+6N5uZmNDc3Y4C+EAAwb58bXbt2xeuvv4Ypk8Vm5FqtFuPHnor/vPgsDu/ajE0r/8Dsyy7FLX9aUONNQLbZheRVTwck1+x2B9Zu3IKvF63Bix/Nx48FCeDBwVh/EH1SvRjRvxsmjeiHpHgTvF4vnrj5Isx9+R5s/PoF1Kz8CDUrP8SyD59EdmYq9haUYPZDr4PjOIzomoy7z+iKX+46BWWvTcFbV/ZH307xaHS48fqSAvR8aDnOfX0jFm8vg8cb4Zh3OYAja4hU0OgpW3bgherlJ4LB7SQtYgAY9Y/A2bj2WrFBYHwHMUPRKbN+GEz0u/BuapzaVEU9AaT7+o+pvxOi9d0NJoGsEWw9VimglFgAgF7TiVDwuqhxt1QPWw06DABSulLGONN79sPTs0dBp9Vgx5FqLNhZC52Ww4vnkQ349IKjGCWRknhlVh72PjEUb18zBA+d3QtdM8wornXg8v9txC/byvHsRf0AAA9+sxMHK5pkPy8kyncT+Q9EVq2wQahW6HWG+qCQFGwuk5Ok0psocGQwUyJJuPBPQpLei2wNYwFF6X7HClJfRvV7LTQepMGvlFwK4Gf2o4b38+5Qb4tp9UCfs+lx/s/qz0t6nMGXkX3jslIVWrN47+p1Wnz3zLXIzkhCfrkDu8oc6JCgA88DD84rRka8DsO7WDCxZwL6dTQhyayH1QmkmTmc2VOPUZ11uH2hHTO+tONwHY8uiRxsLuDORc2Ydl+YKgNypEI481bhWqqKAihJKlxSwVZNzXkBImoYXAKBHcifOV73c3uGP8nnv2ZJpZBYHyWf1+1USex20N9qKn1yx/rKIYXAsH7d8d7Tt7ckJ7784PVIO+M+1DfzGNVZi9k9bejftQPuumh8y3uG9+6M316+ETs+uhc1T3dH03M9UPlUd+y4NxevnZuB60cmItGowZojDgx59Qj+u7IWTrdvnGJ4ZyNePScDei3w004rhv3nCHaWKvDLnFZqMM1Iha4TqNI9nPWDrfedhiqvcmDNzku3t+6pJef/+scQ5GIKMcQQw0mLsCsWMjMzUVtb2/J3VlYW9u/f77OPw+GAzRZbnBUjVNNEQFk2RbAsWbkmS7LHsJIWOQfKlDFYAH2TmHnIaYDsYST9U7zZVwM9iOzKH0v/xAOPPAZ7kQ1APDK5GhRW2VFS1QAA+GvDdp+gfNHREvwyfyP2HSnFk7laJBncmH3PC4jr0AtTR/XHlJH9kJWejDuuPBffrtiLNVt2o9HuQtecjnjs1itw1zNvYeeRGnQA0MAl4py5bjxwqgf/nmSAhgMF3/udR1mY+b+Qs5ucS5UKSjULWcZd5R7aZg2Sb4iYGKLx2Ib3gZLN5ORc8K6EGAgAaXMr5sT0mErGGftdGYcSZ5InOwJVI6jJQAl4fgqCWtEMfKmB0wY4haZUkZRiSq8N62nAZVCDS72ZsqQM8eR0lW4FsofL31cXfgh8fJboVI27mwJtSsCaa8mB3SPNjTReQ+DO/y7CdzvtMOg0ePDCkZjx/R6clWOHQctBk5aHOy4aADdnAIRTK+50NkrKK5GdkYycrFTodTqkAvgmswBjb3gOv+6owdA7P8ddF03A5dOGI85AS87s00di2/9+wTerDuGmi84AynYAu3+i8dfzdODMl3ybCDL5I0cdXdvLvlafTcjAiAVjEmCvAzxuGTkFBfeEwUxkHY/Q/RmkTQEB8fEJZGxbrVa43W5YrVYUFRWhtrYWhYWFGDRoEJqampCSkoIePXq0VCwcOXIE27dvx759+2CzWjF23DgMGTwYffr0QcmBHdgbp0dtZTEKy+uxK58CiBMnToTJaERtXR1VM9TVobauDi6XC4MHD8a777yDQQP6wdHsgMFggObgHzCWrgcAzNvrxr7qtfj4o49w5VVXiyduTASE+4oDMOzUCfj41Alobm6Goe4Q8NEZNK+ueAU4/dmWOWfvvgP434ef4OMvvkZdXb3PtfhpdhLO7QlUbpqPtLOfwM4DhZh4wzMAgF/X7Mb8/z3Vsm9KRiImZnTCz2+nYdzse7FgxRZ0mnozzhyQhrOHd8a0QR2R2sGAW2Z2ws1nD8OS7aV4bUE+Fm4pxrytFZi3tQJZaYm4ZPIQXDZ1GEb2y5Uvk+98ivwPV30A+P1JCoYZk2jsZA0I/YNzCs0/do/u+JaIi4SOwNArZdY44ZxrCmhrSQestYAlhT5Lbxb3YdBbKBu+rhgwxlPAVB/vO55C2TxK7Cbg+K01Sj+3ldMeQKtaaQWUv5SEdK3PHk5rQ0MJZYoqsXVSuwIzXwc+OJ2ao+fP9w3YMbj3hj7WwAup4rX6IAVQ/QLkEzoOwV27bXj588V4eEkTzrr+Idw5CthoewefL1iNQ3xn3HlZP6QkmjHykvMBADnFu/HsVyvRJcuBqSPS8OHirZi/pQwVdg36dUnH7sIqjH56BcY8cCt9SJ+zg3tAcQlEkm35jCosAAqY9pnhG/hK6Rr6+wKU7JNPEoAYdXPgPhVK7mdG6vA8BUl9mmpy4r0RSSPeYHaf9D6MRkURx4UeJ/7XJeAaHeD6+WTXmikYKUVcPNn+570NfDidKks2fQoMu0LZd2DVj4Muonvm0HKSefNPYFC65nc+hfoTLHqQ5t2d39H6JZAhnbKA+e9nYfwlt2FtgRVXT+mLb1fux9oCK+5Y3IyP75rWcqj3f9uJW9+xw+lyIy3Jgr55WRg9sit6DnHh/75bjsIGHtkZSaiut2JdfiGmCO+zlh+G0Rwg/zBvnPjYaQWWPiv2VJDKHyn1o+ISiDxZ8gT9Pewq8mf8ofSeXvMmzaEZvemc3EIQt6GUxi+nod/cH3/HCrlIEbJKQXhdb5If5wYzySLZhJiSRhua1GP+sTmV7sVDf5LkbI6fneRHgHMAbrjuGtxw3TUtz1VU1eCeXx34/AITcmzbweFsvPrIP9GxUw4efP1LbNp7FBsKGvDI1CkAJ65vAzKAAULc/fFqO659fyuW5lfj9p8qcdevDZjyGL3W6dki9M1Owv/uvhTrZnhxyb+/xv6j1Rj2+lFcfGY33H7FTIwa3Kf1ebNeK7yX4jATHgA6jwh+XYIlQ5btoG2PKcrkcQFKIOU0FCPxV6fQG4XEEZ58HCVVPsfDDjtetl8MQZGfT8oF6enp6NKly3E+mxiihbCJhX79+mHvXnGCHTt2LH766SesXbsWo0ePRn5+PubOnYs+ffoEOUoMqqHEsYyGYWStBhqOkryL3iwQC5JFw2UD0oXfVkHW29Zt2/HgI4/ht9+pgiXeYkEzDIhz23He9AnYUkqL/6Rxo1FcUorP5/6AH+YvxPpNW1uOMeFiE87vq0cnbS1emb8CH88nBv+0EX3x5XO34PNXHsH9L76DM4Z1xXXD4uA68COGXh2Hf/4lGrZnzDgH/7duMzY3OfH56VakoRrY/IlQWs4D6b2IJAmnOWH5Ttp2UBDU8UfZDmDVa/T49GeAdBUl+1X7SHtRowd6TvNtgqkzkbHmsgslkBbfAEMg/UPpfXYyZosazFRVwCGycSIdE7xXMj7s4uvdJ1Mzv/z5FNCRQ2YfYPoLwC93AX+9DGSPoCBGpGipWHCGLEWdt2Y/3v6F9Dc/ufkUvLpgHzYcqsPesjh8d+do9O3RFYfdcVi+t44agQMYcdu78AhZkW5HIzqYvJh9xmjcdvEUfPbUjbj6yfex41Aprn/xG7z45VJ88shlGN0/D+eM7Y8H//cLVu88DHfhBuj2/0oH7HsuOaXS8effUyESUgEQeyyY04UqrCDzabCgpt5MJIcSyEkknWCOq8VigdVqhcViQU5ODgoKCpCXlwcA6NGjB3Q6HfLyctGvH1WqrVixEuXl5di8eTNSUlKwZcsW1NfXY926dRg+sA8uy8zA7v2FMKdWYs+ePWhubsZtt96Ks8+mjE6nsxl6vQE8z8PhcMBoNFJAnSeZD83BP2D4+SaA9+DLHS7sq/YiKbMzEjt2x8FykUw7WN4Ag04HnveiYP8e/PX7AsybPx87duyEXq/HRUMS8el0QLtjLj74dT1WufqjoLAIf/61suUYmRnp6J3XCQkWM1Zt2oHnlzfh3J4WZDRsR/UHs1Df3BEXDU3GD1vrMLy/bzNNhuEDeuKLlx/A9Y++horqOnyyvA6fLD8InZbDgJxkDM5NxaDcFAzOTcGnt45FVWMz3lq8F5+vKkRZdQNe//YvvP7tX+jWKQ2XTR2GS6cOQ/+uWcG1eAvXAstfoKBJchdg6lNARq9IbgN5uB3A2jfp8am3yhPnDHUFtE3IJvk9gMaay0bOKRtH1moKvOlNRD4A8sHCdiwnFhECaVX7zx1KpTuka70lHcjoQz0TSrYAvc9Udk7xmcC0p4H5d1DgrsdUMaNRDbpOBNa9Q2RYyVbZYMl9l5+Olz9fjO37i2B3OGEyGjC8bx4+X7AaVrsTh4oPoqKmAY1WB4b3zcMTb83F/mKa21fsLMSs8X3x0+q9WLenBMakDGTm9obTK46l+VvLMKQnadcnGbzINEmrV73A/iXU68ftoMBKr+mUcBKObj4AbPqIrn/OKKDj4PCOwcCkkBwNYmKBQWJ7sD5p0mo5tVKWwch16X3YHjSynYLUCvvtZJtTC9ctMRuYcD+w9GlgyeMkG6aiKSwy+lDVQ8VuSlYadmX4521KBqY8ASx6mLKxl78ITHm8JWFkaP+eePSiEXjkszUoq7HiknG98NEfu9HsovvD6+Xx0CerMOdHsaq8ut6KldsOYuW2g+iQmoBbZ03AZ4vWo9ppgD4tHclm0U485dl1uGlKT5w/sitSDC5kGhzy57nrB0r6SOwUXk8FhmXPkd+ZlANMeji8YwDk46x/lx73u4CqPlwWYa5sosB1fKb8e9vD/XwiQcn6ozcH9z8MZrJbmK2j1v/udQYRC/sWAaP/qbrJtzHOgC92uHBeHx0u7KcHNn4I7rRH8cC158BiisNtL3yEFz6ah5tmTUF6gGNkpxjx0fWD8dKyOny3oxHNXvEc+ISO2FHjwuSnF+OhWcOx+o1/YPazc7Fk0wF8Mf9PfDH/T4wf0R/P3X0Nxg3vDzQU0/rKKjC6jKE5SY2Cgj+sVWLyY5fRyt+nN1E8onIvULZTqKKSyFta0siW+zvaaDGEhfT0dJjNZlxxBZH2ZrMZ+fn5MXLhJEHYxMKMGTNw9913o7S0FB07dsSDDz6IH3/8EWPHjkVqaipqa2vh9XrxyCOPRPN8/35QqnMqRTQMIw6A1kgLtN5EhprTJuok22qAFGESKN1Kjo7MYs7zPO6853789+13wPM89Ho9zj9nJjZv3YoVh8owtZsOp3TikNxjDB6593aUlJaj14gJsNnE0jqjQQ+LKQ6l3iQAjbhvRm9oe3XB7+t2YcveI/hzYz4mXPskVr56Db4/nwNKfwZ28tABGJIO/HlBHd72/oGF3GS4hl2NU4ddDS+Af7gq8YLjKfQwCoHGjoMpW5oLkKETDE0VlFXEadX3V3A2Ab/eSwtzzzPUN0ZkMkhdx1MTOoAWeiZ7oNXT71dXTFJI0gBDIP1Ddp8ByjMR2hMMFiAlit/HZaNrzK5ncxMROkmdqJl2/jySQ5ryROBjDLqYMm62fQ38fCsw6/3wJLWkYFl5IXosFJTV4aqXKZvyruk98fFfR7DhUA3S4g1Y+shEdOiYjesKz4ULuhZSAQBG3vhyy2OPy4lVb/wDz330C+Z8thA3nDsBhfNfxoc//IZXv1mOfUWVGHvr/2HOLTNx98UTkZpoxhV93SKpMOhSkoWSjj+5Rs2RkAoswxMgqSpzCsm2uJ2kZ95WQU25SrETLIvGYjbDbKJ5IC83FxaLBZWVlTCbzdDpdLBYLJQ06raj6MAeVBQXACAj8ciRI+jWrRu2bdsGp9OJjdvzkZ2djd4DBqPPQA5NTU345ZdfcNHFFwMAxo0bh48//giZGXR/6/U6eDwsC9eLhk3fw7LyYWg4L77b7cLVP9lx+bU3obb7ufhwmxPYtqHlvO/59P/ZO+swqervj7/u5M5sJ93d3YiUQauIImKL3T+742t3INgBgogKKiEtIN3d3WzXzO7U/f1x5u7Mzs7uzi4LIu77eeaZunPnxifO57zPeR/fa7fTwbKxX5KXmQyA0+lk0ppUquhNvHdZGDfXPMDPk7ezaK8LnU7HoMsu4e7bb+ay/n04tGERD//vE1o1rk/jejWZcGgfAxJPkGBVuMhygouGQuolUazNWMq3n54mom4HWjZpQMM61QvS6q+6tCdD+nTl73XbmDn1O2asP8qu41lsPJjOxoO+DE+A6rEWOtSPZ8nY+zlwPJXJ89fz299b2X88lVe/n8er38+jTtVYBnRtxtAeLek7tA1mszda0+OSAqPrvgNUSW3v88zZy4DZ9CNkn5To09YjS95Wy7SKry8Rof7BCB63T3rOmePTgTdaipIPBan0/9EI0mDnfSbES+BcX6Nj2YkFkMCL3XNg10yY8QjcMC145G9J0BslynTXLIkMr9GhyHiYFBdFdISFzBw7+46epmXDmhw6kQJAvtPJyi37AHh34p8Fv1EUGeI9KkxdsoM29avQsEF9Mro+ht5YONL5y5NN4aT30uhUvu6TJeRC5hHYONlHkMU1gI63+OQ4y4P8bNg4SV53uav8+9FQIIWkCLmg04PD4pMw1eqkgdh9GsFX3PigBZuEaued787XwOwEW6rY2S6nBFk4bb5MbA3adQNocRXsmSv22O8PwE2/lc3Z2fIqWLhdHO5nQiyA2Dv9noM5z8haa888caR60bBaDADZdifJ3sKyXZtURVVVRr37J1OWipLAi7cN5NFR/dlz5DSf/LKY6Ys3cyotm7G/LKF/ry7o+z6FGnCOjUb+j0XAogNgwM03Tf4qSi7Y02HbdHnd4ZbykwoH/5Z6EgAD3z6zuWzjD3Jc4UlQtY2sy5xamwjzZcVp7STUdl9Zf6EoKpL417ILykos1O8j/Tf9oGTC9X6yTD+PioygQa0q3D3zNIOaR2LJPi7r6lZXc/c1l/DltEVs3HWQdyfM5PVesOdkDk//vIvjGXmk5TpJz3WSmuvAEJFAjwc+o03nwnON/zppttPBXx+/xUf3DybHns/Hf+7mx1mLWbp2G5fc9BjjRjXipgZpKB6nZHR2uk3qvZwJqQBweIU8JzYrVK8lJFRtLcTCnnm+2gyqW9ZSBu+YWV5Zukr851C7dm127NhBSkoKO3bsYPTo0aSkpFQSCxcIyl1j4a677uLYsWPEx8sA1aZNGxYsWMDll19OQkIC/fv3548//uDKK6+ssIP9T6IkndOzCWu8EAfx3ujMjGMiHaNpH6tAbF05DkcOpARPf8/KyuLjT8ejqirDhgxmx6Z17Ny9m7379rP+lCwk37xrMAv/+ImWzZpw58NPYLPZ6dKxHc8//jB6vZ48h5PUzBwmrpRVYLTjJK/eM5x1k17mwMSH+P6aOFZe7yRp+5dieKNii2vJu8odrKU1Zpw8pH7FM+pHhKs+XfNsYyJvHmotZEKjy+RRHlIBfNkK8Q1LjQwvgoX/g8zDEFldogHL6nDcPl2eW1zlK8Kt6VmavHq7Or0sLrXFlma42VJ9xrWmmQu+dgaVeqOhwKE5zbzX1+0U54nTDk0ul8yftP3iyCkJl74q0W62FJE3Ka+OtYYQizf/sGgbmbn5dG5SjYcHNGbOZulrvz3Sk1a1YziaqxNSoaS/Mpr44Inb6NGmEU6Xm3G/LGLfsWQeu64v2yc8wehLO+DxqDw+fga2PAcfDonnw8u98gG1u0Pf50onFcqrt6vBkeNLAdaiqIxWqeUQrI376zj760pfoFAUpeCRlJhIi+bNqVe3LomJCVitFlGscNg4ceww8ZFhNG3alMTERKKioli+fDlWqxWLxUJ8fDxHjx5l//79REREcPHFhYtY/v333+zffwCz2VzkEXZkKbVWPIvRSypc94udL7/8khdeeQ2Xp2SZEL3RRLtOXZn4/XecOHaEwwf3s2HZAgY/M4n9kV3Q6xSmj4rmq5fv5cDWtfz+0wQGXNqPZStW0/mqu/ht/jL+XreFr3+ezY3f7mbwnGq8faA5f56IJdmmEm+By6plcHPMKi4+9glLPr2foVcOp/Pwe3n4tc9YsmYLOp1Cn65teOfGjuz84AoOjr2KaY/25sURbbiqc20aVBHHy/F0O3+sO8rslTsY0rMlk168kdN/vMLkF29kaM+WmIx6Dp1MZ/z05Qx87HMS2g/k6ruf5q8fP8b98xhY9y2gQpOBMm+cLVKhULbCfSVnK4As7sEnB6fVFTFavYEKXtvF5ZKFs6kE8gHOnc3zTyNwfCnpvP23LU5r3r+OkJatqDlPHbm+LIHjG8p2nIoiUcnhiSKJNOMhXwR9WVC7mxDfWccgbV+Qv1Fo1UCy9j6YJPUN0jLFfsuxiXOzTePajLysC/VqJNK8dkIRtZxN+0+xYHtyEVIhEE6PQpbdKY7gxW8KqWC0QPuboO/zZ0YqgBTedORIRmz93me2LxD7DkT6zBIr1z/zmM/pqdVJc9rF7nM5i9qljlxfrR8t2OTfZOeVNB877ULmaNdExetQtohDzJHjIxG06wA+m9cYJpJy5iiR0Vv+SdmOrelgaduntvmihM8E8Q2hnTfgaMP3IuHoRZ0kmU+W7zzB+n1CqM9ed5CUTHsBqfDctZ154bZBhFvM6PU6vpm5ktSsXLo0r4vJaGDVnpQipEIgXOhZdzRIXYLNU2SOSGgsfbo8cOTCrMfldfsbxZFaXrgdsHK8vG45HOLryXrW4/ZmH+klcE5b95TW7s+HeiLnMwLnn5L6pcMmQW8OW+HX2neZx+R1WYkFcwRcIlKVbJgAm6aU+TR6d2xOik3lmskSeKTunQspu9HpdDxw3eUALF0vfXna+pP8vPYEy/ems/NEDqey8nG5VcIiokuda/RGE4t3JtNmzMcs2XyQb15/mAN/juWXu1tx8MEIbq53SkiFqq2FYDuTvuCPQ8vluU45+qiWlZi8Qwg7k0X6kUpBhnHB2HmBr5EqUTGoXbs27du3p1mzMgbiVuK8R7kzFoxGI1WqVCn0Wffu3Zk5c+YZH9SFiDyHC5OjFCdhUG1VM7jdoDNDab8vCU67b3EfkuPbDEavA8GWCg4HZKdDnBUcLlRjNGDClNgc/fG1OA+uwh3jlWBw+RaZZksE3Xr0ZPXqNXTp0o3Dx0+ybecewsIjueHhl2HlC0RnbCMvK5U3P/oCpxu6du3C/Ok/MnTkLaAz0Kt9c+4e0Y93v/udPFcyFkM+37/zKL3rh1EnLIcbmgEoHM2G6HZXYGp2GVszo5m7DOapvRiuzuQW9Sd6qatopO7nFd3D7FPqAtC7Y1PyqnhlGAIlHd0hOPhd+eh3L0S/ewY6wJnYAndxt8lZdPGtO7gU0/bpqIoOxyVvoOojwBHiIl2noDu4BNPpHag6I/m1ekHGae+XChhNsi/FDBavHJRqouDe2lIhR2pbYLOBJVKO0epvGJ1B+wuBIMkr4z5D6kehIlRt7pBgFq1+xSTX2FJFZD5UExgtGOv1Rr/nT1xbp+Pq9lAJ+zGhDB6HaeIglBMbca36AlfHO0v+6xIuh0ExYgDc6YdxWqsVS5ztO21DbzQzoEszEmOjSIiNJD3HgWIwcSrHw+1fbyJxWDEksarSgzXc7plMojuVMTfVYPa2GszcksbBnZtoXbMHFms4Xzw1mr+2HOFESibHN8xjdEPRtX9/nZE7evZH7/LrgKoH07S70GUewRNVE8cVX0NYkrcPhdg/1KLbKWnHMAOqIYx8p8fb10pq4ybpRyrSXzwuOQaju4zjaRBUYMZCRfUjVVXZsWsXB/YfoF79ejRr2iTIr81YouI5ceQkdWrFUr9RExYtXorRaMSe7+SygYOZ+tNU8vLziIyA32fMYtas2eiNZiIiI2natCk3jB5N/QaNOJVSOIrfkHmIqtNuQ/E42R/WmjsXbkfVe7jtznvp3GcmkT1vK/Xc9h44TGpmFtGx8SiKQmKU9/507YRn2q2Yj63h5piVOKo8Q57TzYTJU7n/sadxOZ20a92CEZdfzLxla1m6dgtrdxxi7Y5DAHRp05iBTay0tZ6ge3wWieFwRwcTd3SAXamnGDJlFh9PmkVCbDSDendmWAMnfVtWpUp8NJfHR3N5R9Fid7k9DHlzIUt3nKZeUiSjB3QjzzvX6E1hXNGnA1f06UCuPZ+lm/Yze9UOZi7fQXpGJtdHr6W3XbIjclUzdLwVfdPBMle5veOZPsSCo0oI26kqhjXvYcg+iRpRlfymI0qYn1zgtGE6uhYd4IhugMeWLQ4dW6446wxWGROd2RAWL0SDJV76l8MFqhny0rwy6WGF+1aZbZjA8z3P56PcbN/4Yi3BOeG0+6LQzW5xmmljlP+x2HIg1zu/Y5aHLafgP5SktjIWHt9Ifk526dGGbr/7bohGGTIO09RRKHvn41r4Oq5eXukSZ4jzqi4CQ43OGI4sw7PlF1zNr8YTV1hm7IW7hnP5gx/w7axVDOjVgRrVqqA3momNiUFvNLPzSAov3XMN37x8DzNm/cnI134FoHHNOHYfTRMHYilOqjrqUQap86m7coW0S8BdrT3Otjd7nfYUtQ39EcSuKwSPC/OGCSiAs/1tuJ2l9LvSSBpVxZh1Gj3gNMfiNsYICa83yv3Fr+2oJtBZwWoBzEXbh9beDJaKWWd4cVb6UaC9Ziuuv6hy3nn5vmtijBE72IQE3CjINg5X4euAWT53uyGyLrpL38D0xz2oS9/FUb0Las3OxR+ffzswRmOsdzH6ffNxr/wC52Vv+saf0u6/hoDirzQYiGnfX+jS9+NeMRZnzydAp6dV/eo8eW133v51HaeyXRjNYczfeooHvl7JLZe14fuFO/l51WH+z+7CZDTwyNgZKHoTej2s3XOCF24bwqK9ucGPIQB3fb6C14fU4Mqu9VCcKrqTmzHumi1++jY3e+NgAmvFlH6+hhXjMWQdFVuv++Mlr4H0JfcP/abJGLOPo4Ynkd/xHiHfVLztIQKcTtDr5b6H0u7925nRWvr256Fdd1ahmgrPPyX1y4xkyVQ0RohzuqDfmcCWg5KbKXOS20G+3V5yPY3Acbf+Jei73Idx1Seoi17FlZOCu8OtIfe3/z0wGp3BzLd/LOarjW5ua6sn869PCOv7OB6dAb3RTHhkJHkeAyO71+ONP4+QZXdxffca3NevHnHhBnItNXgspfT/iouO5GiKgce/XMi+Q0f5qHsqVyXlADoOZqjoWo8gqfNV0pa0cSDUeTWY/ZeXifnwKhQgv0Z31IK1TwhQXOjim2ECPGkHcBiifPcckzeYzlT43ttyfEFbgbbaP5CpXdZ+VIlKVKL8UFS1Qr1rlQhAVlYW0dHR9H36JwxhF17E3fWeX7hR/YU1tOFZ/RNl+q1VtfG15xFiyeIgNXlK9xRpSmyJv3nG/QG9WF3w3oGBFUpH/lR6s5GWeIpxnDZR9/K052Oqkkw+Rj5SbmO+rleZjtcf9dVDDFLn01ddhhWJnssigvt1r3BSqVLKr3240zOBq9TZzFL68KFuTJmOoaW6g1c9bxFGPvOVnrytu6dMvz8f4MqzsfC1a8jMzCQqqvhUz397P+rnWcrj6jgOU50xurdLNa56eVbyjPoRHhSe1D3NJqVFuf63i7qOlz3vArCOVryuu59spYyyFSWghnqCezzf0ZHNxW7jQeEYVdmn1GEfdbETxt3qd+hR+VK5jqm6IUV+E6emM9lzL24UbtJ9RLJSxtTdYvCg5wsGqovYTFMe0z9fIfs8H3Ch9KPq6gm+9DyGHg9vKXezQHdRhe//G8//4UFhkG5CsfNFadCpbtqwnYvUVVykriaKHNKI5hndE+z3ktYVCbOazwue9+jAFhwY+VkZxFRlMDblLN5DVeU2dTLXqDMAeEe5k3m6i4vd3KraeNnzDq3YSR5mbtO9Q0oF9dtzhQulH4UCnerhG89DVCWFH5WhfKMrReIqCPp4lvGkKtks7yljmKPrU6bfV1VP8YnnWSIRx+ZxqqACejzocaPzPstDXhtws5WmvKx7iJwznMsaqAd53/MCZiSj7ySJfKK7mTVKuzParz/aqNt4y/MqmUQwSvcprlCLphcDzeb2oPCw7kV2KmWox3WOcMH0I1XlafVjLlZXkkUED+le4pgSWtZka3U7b3peRYfKZGUY3+quPePDaaTu5z3Pi5hwMVvpzQfKmH9MUvFiz3IeU8dhxM0yOvKy/pFy7cegupjsuYcocnhe9yirlPblPqZoNZOvPI8SSS7jldFM0w0s977OB1ww/ShEhKu5TPA8QDj28rVvVeVh9QsuV/8C4AjV+Fh3a5nXT1bVxkee56jFCeyYeVN3DyuUTqX/sIxopO7ndc9rRGLjCNWYrFzBX0o33Gc4R/hDp7r5n+ctOrCFo1RljO6dMtu9wzx/co/6Pbupx/36Vyvs2M4VytqPStuuErB+/Xo6dOjAunXraN++6Jid53Ax7E3JNP3ticsIMwVv06XtpxLnD0LtH+WWQqpEJQAWKZKm154tRKuZZfqtTbHyuO5ZUoilLkd51/MSVdTTJf7mQ93t7KI+x0niK2Uko3Wf8JruAdYrrUucLHcpDblX9yqraIsZJ4+p47nf8xVGtWSJGH+Y1Xz6e5bwvvsFxnmeYrC6ACt5HKEa45UbuEX3XplIBYBa6nEAdlOG4nAUJhXW0ooPldvL9PtKnFusUDrgwEhtjlOfw6Vuv0TXldlKb3SoPOYZR6SaXepvgmGV0oHXlPvJw0wHtvCx5xnqqaX/f2kwq3nc7JnCeM8TdGQzDgxMUq7gDt2bvKbcz4/KUNbQhlRi0KFSixP0Vldym/oj96nfokflT6V3UFIBIA6JZE8npsJIhXrqYS7zLjjK40SrxNnHcaUaPyiSGXOv+m2p80FZYfI6ELMJLzepAOBR9GxQWvGR7nbu1L3JPuoQRybveF6hlbqjog4XkEXuq5436cAW7Jh5Vvc43+muOaukgqJ6uE/9poBUGK/cUCKpEKVm8abnVVqxkxysPKV76l9HKvzX4FF0jNfdCMBwdSa11GNl3sciXY+C/vqA+nWZ2/5JpQq3697hd+USXOipzilqcIqqJJNIGvFkEEM2kdiwkocZJ3o8tGE7z3k+wKCWPxIxQs3hOc/7mHGylcY8o3ucW3XvViipANBDlRowK5SOZ0wqDPXM4Ub1FwDGKjefl6TCBQVF4V3lTnbSgChy+J/nzZDXOZuV5nys3ArAdepvjPD8ccaHs0epzxu6+3CjMED9izHqpArOvA0Bqspwz0yeVj/BiJvFSlde191f7t21Z0sBMb+Gtmd0aHerE4gkl33U4Xfl0jPaVyXOPXKVcF73a99XqrPLtgNF4X1lDK8r95FGNLU4wVueV3nM82mZ/BM2xcrDuhfZSHMs5POi532u9/yKooaYbRQC/EmFbTTmft3/WKC7qEJJBYBb1J/owBbyMPOK7qGy272qyiB1AQBzleJtwEpUohKVgMqMhbMOjeE5lZxaOgP6T98Kh03kWwwWX1q832dqEG3ldauX0Xr1/xGVewBn/9dwd7wdXPmFtnnsyWcY9/kXXHzRRSxeupSmTZqwZvkSlHyZ6JWso2R/M4IEfQ6pLgvtPrdzPCOfxx68h6ED+jNjytdk5djR6xT0ej3WMBOdW9SnW5tGRFjkmMb9vIDH3v+Rof17MOn9Z9iX7uGReflFjldRPYxSpzFa/RUdKmuTjSx3t+WOq/v7NlI9KHnpKE47Ss5JdLknUXJOodhSCgwLVdHjSWqBu2ZXPLV7hBZVUaNDkY9M312KLusY+Vd9j6p9byk5a0M5shLTz9ejOO24a3XDOWScaPiDpB2m7RedQ4MJqrWteO1tTRJGZyi5CFQI1yQrK4sqifEhRxKE1I9CRaj9Ldj5Bn7mtIMzV/qOlvqZeRwyD4EpCuLrY/zjHvS7Z+LqfC+uXiEUFzu9A9Nvt6HLPIK7zkU4+70a/JqmHyh1V0rmYYx/v4UuPwtVZ8BZrx+e+MaFtvl27mbu+3QuKPDe9W15ZOJGGlWNZOzN7Rj+7REpQOaVPbrLM4EkUgFYQxs+1d3IcaUaq794lPy0Ixyb+T72fAfPjZ/Gn4v+pk2SwsCWsdSx5tEg2klitdpEdr2ZrYdS6HrXh5hMBg5uXk1UlESg6g4sxjTzPjyJzXFcG6CXGqrWuv92rjyMU69Hf2Q57saDcF72thSjdeaCqkBio+Lbcqjt3R+hyLZUYKRhmfvR6RTZLuDcCpkDfoenqnK4P/44hRMnTmCxWrn44ovZuXMnGRkZtG3TFp07j0M7NxIXF4caFsOJ1ExOnjiBwWhk/bp1LFq0iNOnhSho1Kgx/fr1o2PHDrRt24aoSN8x6zxOEmbcSET6NpYf8dBnohO3Cp37DiKyx62lXotXr2nFZT07k5mZwYMP3M/j991BdLToUOuOrMD068144hrguGEWAG63mwV/LeWLz8fz55LVqB7f4tFoMpIYG01SfCxJ8bEkxkeTFBtFUnw0SXEx3udYqkQbqbb1M/QpIkvn7PYg9lN7+WXlYd6ZsZ3dx2Wu694kkd8f78uLUzfyyZ9Sl+i2IV1RVcix5ZNlyyM5PYc9x5JRUPjsoSFcFbEOXdZRVKMVR9+XURObe++Jyo59B5n391rmLV3N32s343K6Co77iXtv5cn7S5COKm4B63FhXPIa+j2zUVFw9X8Nd+vrit9PzilMv4xGl7oH1RKP44ovUBOaeOv6WMFlk2dN39/mlaixxIE9TfTOTREQVUO+17bXiq4G63ta/yq4USHII10o8xEUM//4jTfae39brpj/NP50Hfr988WWuGZK8ddJq01TZB8ejDMfRL9nFmpYDI7L3kONql76OZwOICHyMlBsKV4NdB3odKDoyXWq9LhN6qusmvAyk6fN4sbY9USaFXa4a9PqzT00qJXEtGeuoPVdnwNQv1os+08IOf3MXdeyMvGaQn+lqB5e8rxDFzZygkTu073Kwi9fxGhPZtX3L1EtISb0IrTV2xb/nerB/O0lKLmncQz7Ak/9vqXvT7PlAqDbPg3TzPsAcLa7GXfHuyDBG5BiS4Nc0dcnPBGscb4fOuw+u95lL9tcVk75saysLKokJVRsPyqpfxQ6zuDXrwhsaaFdi7x0yDyGaep16LJP4KnWFse1U4PUrAge/KFf+yXGZZI16uz7Eu46IWbh5RXvCNXvm49xtWQKOat1xF2lDQBuj4e2D07mwKlM2jVIZMO+ZJrVimXHEekL6755kmWb9/HA+1PR6XU8cm1fsmx5TF55rFCB2eLwXr1l1Do5h6icvQB8sNpN59vfp32rpsX/KLLkYCvjgufR75mNq+1NuPq+WOoxFCePo9u/ENMvN4is7OgZqDVDiDDX+saZSFoG4p+06ypyPgoVDr8aSk5vDQqXU6SOCl3XIP0345jUk1MMEF/fu79s9Jt+wLjkNVRFh/Oq74OPm/ZSNIfyszCs/Bj9lp9QUFFNkbg6jsHdaEBwSdjUwnV+VFVl8qylONdP5M628tnvexVumJaH2WzkrWuaMbxDNTYdzeKd2fuYsfE0kVXrhdSPYhc/w/hOB4gxwx5bJAN/dHHgZAYA9WpVJSYqgg3bpI9VS4pjyntP0r5TiLURwnzzlnJyM+bfRAnB0f9VPA38/BzWhJB2pyRvxzxxCKrRSv6o3yFa6h6J1JFFxlHVXfo46j9Gn+Miz2XtR5UZC6WjMmPhv4dQ+0fFUqOVKBZhJkOxHasA54pY0IpQmayFnW+mKCCgsXg/S05OJi3tGPFx8QUFuxVFoW6VODKq9SRq7wGM23/G2P0u0PmiyDIyMvhxymTcznysYQbcznw6tmuFxWwAj2hF70pzMejzDGZdo9A43s6n/Z0MmZzPoYP76dahDd1ih5V4OqfTsvhi6jzcznwsRoUwg4JJH9y4UxUdPyjD2aU24EnPWDom5tIwfy1hR0yQlyEOeW3RHgyWWKjZGaVmR/TmSPQAxhANSaO+8HunXbRxAXNSQ9/3poDt/HFoBfx8vfy2Zif0vZ9GH2aWRb/BAjgAJ5gMEFkVwiPLX5AagrcVJdLvsxLadAgGtqO0PhGAkPpRqAi1vwU738DPnPmgBxQHmLyGneKAyDjQm+U+tB4Ou2di2PU7hn5Pl359rOHQ/yWYdgf6Q0vR7/kdWgSpcxDK5YivDa1GwJ65KJlHMO2bA/bTULtrQfu4a0BLZqzYzszV+zienInO42TnkRS+XLCTWEtEEdmjUyQwTncDK+hYcC5ulxN7bi64HVSPC+erp0czOiedH+atZ87ek3i8xXeTfx9JmMnAsZMpuJ352J35pKUmkxQfLcebJ4sGXWQVwgL7TUn9wx/a7zKOwC+3wolNoDejv+RF9NEJ8n32SXHkhEcW35ZDbe+FjjESKMUxVYEL0HL3o+LOLaDfq95FYasWzXA786lduzYeZz779+zC7XKxzxrGVVddRbVYK4rqYsnfK7B5zBw9fBC73U6fiy/i+quH8OnYT1i1YRs7t29h5/Yt3sug0LxZM9p36ECbNq1p27oVrq7PkzT9WrrX0vFEV5VXljg4sG8vrXuUfm7RERHcefvNvP7Gm7z37juMH/cp1119JXfffjMdLOKs0VnjfO3KqGfo5f0Y2r4aR0+c5uCxk14iIYboyAiUwPvkygv+x1WegWUfohxdg2n5u5iqteHWi+syukcNLv3ffBZvP8XSrUc5cCKVN0e2YsnWo2w4kMbnvy4OurtEq0KL5N/QeQCjBeXyNzAn+EcoK7RvVp/2zerzxJhryMm1MWfJKkY//Ap5uTl88f2PvPhICfJ6weYFtxMWvgD7FoKiR+n3AsaOozEWt4+Mw/DTdfIcWRXlht8wR9f0c/JZKdQPXPmAt5iqEg7RieAM925rKNxvFKX49hlK/ypyvhfIfARFr0vg9SjL9bn8f/D53+iPrEC/5zcpeBoM7uLGXT0MeRcmHRVHxl8vwOAPpKBmSTAEnG9EtDwCYNIZSHUYSU7P5oEPp/PJ4zcw5uENTByi0kx/mBd76XluwREeGTcTt1OCSfYcPolBr+PWy9pw/cVNWbm98D6vU6fThY3kY+QV3cPkKBFUi4tgx6adLFu3ldGDeoa+Ogqcn/xxchvkngajFVPDi8AQwtwVbJu982H2Q/K69UiMne/AGJkAOLwa13oIj5J+ZY0Q+0+Dv13v0Hu3txTepjg480GvAvk+uyYEnJV+VCKx4H+cxbQ7h01sexUpbm2NCH4ttGLWRosE5eQ5ITIeLnsDZj6E7sRGwmbeC1d9XriQvVrMve12J7hyYNVnGBe+iLHvs9CwX8nnCuAqYbxqcgm4bbDuG4wn1mI0GiCxKejh/4a04O5xi9iw+xgmg56t+08SZtST53TT6843eeueK7i2TysmzV3Lm9/NJMJqJqZ66ZkvRtVB4uEZRDmk5tDEY7V5ePZWeiZ/wpKfPik6Txb8sIT1h9MOB2X+M7S6AkMotp0+yDaOXJgnwTpKpzGYqzUDZ6b3HpbgxHQ6im/fxa2TS8P5YNedSxj95hqnXq5ZZGyQa+bXf7XC2dp61aCT9RLI/ehwA2QeRNk0CdOMu+GmmZAYUO/LVUpbMcZC/+ehfi/4+32U1L0Yl7+Hcd8c6PEwxAeoBBS5bAq3DuvFvvaNee3zt3m0TRZDG8LSGw0MnZzLLZ+t4bFIE9d2rsYTl9XmpSF1eXFxPqWVLW6k7ueVTgeJMcOywy6GTT3N6mnjmfj7It795lf27j/ENZdfxBM3/x+Pvf0VB4+d4Ol3vuSvX0Ms4qz1N48blr0tr5sNwdQ0IIMn1HXU5olyNer3Jsyog7xTEFEF8K51lQgh6MzhJa+PNJvkH5BuK2s/qkQlKlF+VPa2/yIc3qgCh803+Qca0wFISU3B5XCQmpZaQCyoqkqNeg0h5h7YNwmOrxfWP7pGwe9efeNtUlJSada0CffedSczZv3JjFmzcTqdGIGcnFyuumEM+07beGtve75IOszgxvD3a5fS+oY3Sz2V1Ixs+t/1JjsOHKdm1UReeegWAJzOklPk1yptuVf3Ks9kPEmTqDw4tKzwBjoDRFSVaJuIKt7XVSWKraImxvSDgAphMYUjzIrDoRXw43Vyn+r0gEtfB0uMRHuoTlBdYM+GiARwxUBMCFGDpSFYWzGW0dD+tyPY+QZ+ZrJKHzJaZEHitPsiD62x8lmNjmAMh8wjcHwD1AiBnU9sAl3uhhUfw/KPJAMlrl45zyMMmg2Gwyvl/49vkOwWc5Qcq9HCk92N1PIYSdSlM/v+FjwyeTtLthzltWG1Gel5AhMuHBiYqgxmijKMfKVoFtPdw/sQGxWO2+3h0Q+n8MO89QD0btuAhev30rVFHRJiIvh18WZG/+8HAO67qidNG/sV7sz1SuCEJ5bvXDXsWwjT7wZ7upCCV34GsXXkO2usPEoqEAcXdnsv7twC+r2qgt1uJz4+nn79+pGUlERubi5NmjQhJSWFpk2bYrGEUathU3DY0K/dwpZV64mMjKR58+Y4HA4yTh+nVZMG5GZmcCgiAoPRQHJyMhkZmWzbvp1t27czYYL8vU6n4/6Lk/igl43nLw5jVbKVFRmhFZgEePmlF6lZswafjvuMbdu28dX3P/DV9z/w1vD6PNYS7Eo4JrcbfYCToma1JGpWSyrftdSboOcjsOYLaXfHN6K68nn9LzuLt58C4LGhLWhbNw5FUZj+WG/em7EDQ1RVIq1mIq1mosLDiI200iDBRNiWH2gaDw4lDFPHWyEhuPMn12ZnzpJVbNt9gL9WbiAvLx+j0cCX775YtuN35cGfT8Hh5aAzwqWvQv0SUt9T9sh8lHMKYmrDjX/IM/iiF20phduY0SqFGxV8n5fUtyqi7/k7iCo6e++fQlmvi799B4VtvZja0OMhWPwGzH8JGvaXgqdlOh4LDP8Svhsq89uiV+HS/0nWyhlCURS+fXEMwx75kB9mryA2Kpz77rufh794j48vN/JsTwN7U818t3Y/Leok4HB6uGdIB266pDWxkRb2BAwbHdRN3OCVE/pYuZV93pooBoMsh6omxJzxMRdg73x5rter2EyEUnFkNfwyRsbj5sOg12OAzpeZokXdx9QqfV+m8LL1AZPV13fOZ4RynE67ZEcBOK0QnhD8WmjX1GmX741h4MyDWp1gwDvw2z2wZy5MvQmGfx3aten5CORlw6ZJsOg1+U3tECOQi0PzYXI+W6aKTac3QVx9xlzagmU7jjPxr104XG5iI8yk5+SjUxSycvO46+0fuahNAz56eARfzVjOpj3HUHLtJf5VhJrDC573SHIcwoOCrk53el92O5aJo/h77WZ+m7eUKy4tR826Q8tkfI6sBtXPIFp18ZuQdUyy3i5+XO6XonjvYUnzi6X4bYKtfSpRMkKdl7Q+ZgyDmBrCOWj3Ij9H1rUD3pRs7MMrYNI1cNnr0GRA2dffSc3hivGw7VdY+zWc2ga/jpExud1oiG9Y4s8b1KrK4y+8xe+/TuGi/L9oXUXPmjHhXPOznb8OOhi74BBjFxyiYRUrj1zbh+kl7KtA/sissuywi1G/qaTmOJk04y+ev3cUV/bvRuth9zJ1zt+8cN/1LJn4FnX63sziNVs4cPgY9WrXKGHvAdj6C6TsFp9F93JKldkzYJv3jNqMkvul6OVh8toS2j0/kwDGSlSiEhcMKomF8wmhTpjFRe6EGmERzAgPNKYDEB+fQGpqCnFxCezcvZv9+/dTv359wskn5fBO6kY1Jy5zC2z9WYxoID8/n4/GjgNg0MAB9O/fnypVqnDq1Cl++HEqN99wPR9//CXbd+4G4K7nP0RRtsCfT9LDuRRcKWCpBbWDM/VrN2zh1gdfZcveI1RNSmThlE+pX682GZnZ3PfcW+h63IfeWLzTMFlJIOKmSXDgF8kciK0DsfUgtq6QCKU5HDWUIl1UgMBFtiZhE9+g8He6IPGhh5bDj6O8pEJPGDWlcOqu0yZRA1bvsURYiraB8kTgBGsrZW2nJf3vPy3/VRqcNsliURHCRjv+wHPyT/nNTZVoEZMVYmv5PtObxJjdPRt2/gG1Opf831HeIoE9H4QTG+HgUpj3LFz2mmQaaAhVskHr1w37w8FlsGKspNv7pdz3jIaegyyAHTjEpru0sUBS6f1ljwLhdjoY0KUJ7z9zI5iMvP7Zz3wweS4ArzzxAPOXrADgiiuHcyyqHde8+Bhut5vBl/TmvY8+LNyucr1pzhFJRdtbKI4R1QN/fwB/vQ6oUKWVOL4SGwfbWJ60KKpio9xCbPf/UDHFMkFRSj7OgH6vKJCbm0t2djY2mw2bzUbdunW5+urhqB7VF61osIDBgktnplWrVqQkJ6Nz55EYE05YWASJSVWxRsUSYffQq1cvRo4cycaNG1mzZg3LF8wgKzuH7HwVe76TDxedpGNMGKNbm/i0v4u+M/WobieKvtj4eYx6HdFmMODhnjG3cfftt7Js8QLGffUdP0+fgT31GGDmm1/ncv8dNUiIj6NqlSSqJCVSNSGWqlUS6dOzKwP69y7+2gQbn/0x+ENY/iGs+RLl9A4iMvNRgFceuZWn776+4FrVBj64lKISDNkncfzxf5gSdBzO9DDB3plnmg0tNs18xG23M3vBEt/h6XRM+vJTBgweXPJx+keUH98I81+AY+vEATr8S6jfW74L1t9ObIJJIyQCOLEp3PArmKPFqez0yq4oyJjnDHDMmKzFBjCUC6X1N38HUUUTC6pa+hz2T48HjlyRnDD4tVvN1gOZm1qNENstdS8seRsGvl10P8VlcWqIrApXfw0Th0uQycYfoP+LxW8filwSQG4KA4e35DtdHKMfeI5Ppswnpmodrnj4Pd775v94pKuBL4eEcTjTzaIDKdx/TR8euvXqgp9Hm/UYFA8uVUcVNZknPWPRoTJT6VtQN0RR3Rw8JJHYDVp2gLjqPpKsvFBVH7HQsH/xkfSB0GzBzKMyh22YIBmptbrBRU9A9mlv39L7ZLCMFkKen/zhtEFOivw0mKO9rESEhrPR5kucr/yOs7j+aLTIPShwYhaXuR1g81piQRuiW10lNvaU0bB/MUweCaN+Ekdoadd/0DtC3m77Fea/CFd9WbINGIpdd/ETkJ8Fu+eITVenO/oaHfh23EDcj73F5Bl/kZ6TT7MGtdix74hcBoOepZv2sXrHYe4Y3o/7Rg1mw8F0Dnr7SCAS1VRe9bxBHY6RmQ9X/2zn+x8foGad+jx81y289sF4Hnvjcy4bMBiLJQh5VhKhtmeePDcZKNKtoSBw/j+2HtZ8Ka8Hvy9zTk6q9IuYGgS9L9q9LwmB7aCi23Qoa5+zsT76x9ZcftdPu7YRUb4gBE1SyRIjY6ApHK75Hr4ZCKl74JdboEE/uPwNWTNHhBgAotlXvR6FtqOE2Ns1Cw4slkfD/tDtvsJrqgAYgKse7UFeyiFOT7yJpPA05o628sCfeXy50YNOUdh7ysYj363mooduL2KjGlQXzdnN8573iMRGelhtLv9hKzneJI2xk2bw6K3DadWkHsMv7cEvc5dx///G8ecXr9CvWxvmL9/Is2+PY+JHrxSfGaTBEitz+qrx8v6i/4O4+kFOqmhQWBHs+B3c+ZDYDGp1kT5Q1gyeQISsFPAvWEdVohKVKIJKYuFCQqgRFsGiCkqJ+ElKTCQxQTT5Vq9ZjS3Xxv79+6lmyMaZl8upyFZCLGyZKmmGioLRaKRvn978OWcu77z3AcePn+CeO+/ghZdf4aH/e4z+fXrTo1s3rFYrNpuN4SNHsWDWDBo2HQw7Z8D0u+DWeUWOJTUtnWdefY/Pv/8RVVVJiI9lwbTvaVQrjsPHTjLwpofZtns/cdv3cMv1I3B5FHbE9pFj/+JRnrrnBob0v4j4CCNJEXqIv6U8V/vMkbZfnuNKKdx8aLlEbDhtQiqM+KaoM0q7pxrBEAzlicCpiIjRf3Pkj8MmETQADr9roZ1TbopPM1K7J1rkjf890j5rfY0QC9t/E5mjUKI8FB0MfAe+GyJZLj+OEgO795NF03lDRd0eUKU5pB2QhWleFuRn48hJZdbcBSRYoHPTmpjcuZCfzb40DzPyO7LJVZ/p894t0BHdMvFZcrKzCbeYuXFAJ15/+RZ0Oh05NjvvfSfFCse//QLtWjbjuTc/wmAwMPKKAcRGRxEXE01yahp9enbGaAxYLJ5JxoI9wxtV6B072lwn0dca6VYcCpGr/7J2WtEwhRfpq+Hh4URGRpKfn4/ZbCY3NxerNYgusctOq/pV2bH3EJ0GDqRZ7URSk0+h6gycyHRQp1E6vfrX4dJLL+W336azd+8+qlWrRvvO3Tl5ZD89+1zK0KuuYdPGTaxat5zL82bQIA66hO3njw/uwGiNwmwNp/1NrwEyprtdUpS5bvUkpkVfx+hRIwkPD0dRFHp270LP7l344I2XOfLdHcBWUmwqHo+H08kpnE4urNX79sdfMH3CeIYNvKR8105RJALc44F1X/N/3cz0bFGbLneNLLpYUlWR4zq9A5J3op7egSdlDyY87EvzMOgnF+++3rvEvzt2UrIhLu97EX16duWS/v1p16ZVaMeavEscybv/lPemCBjxbYmLbA6vlPkoP1syqEb/LA7O3BSJoLVngiVaMhN0+sLtyJYq46lGavhHzpeSNVlunMuo6/LKZ5yNY9Cuo9MupILLKQEH4LvOTrtklbjzodcTMG0MrP1GHDDVy1HEuGpLGPQu/HavEAtxDaD9DRVyWqOuHEBGVjb3PvMm//vwK8LMZmpc+ihTV7zNiBZGZt8YQ+tP0vj4p0WkZeXy4SPXEh8dQZLFTeTqj1iwYT/LR+YRFZ7DLupT79J78LzyMas2bqd+1ViyU07QsXVT6tYsSpqXC2n7ZL7WG6FuGaK5AwkFgDrdoe+LEiVqS5H+o1J+x78Gh80XxW+8gDJ6giHwWuWmBLdL/W3eQn3J+1mDPnDDNJh0LRxdA98OgtG/lB5gpOhgyIeSPbl/kaxvRnwHVUMcq4PuU4GOt8rYefBvWPou9H0OfVIzJrz9OFUT4nj/21/Zse8Iw/t34Zf5q3C53bRpXIdNuw/x8eQ/0ekUhvfvyphum2netAnO8Oo8MiuNRhxgSNqX9E84jd5jI98US89xR9h62sPmHXuoVqc+Tzwwhm9//JW9Bw7xwlsf8dYLj4d+7Pk5cMBLiDcZUL7zd+TCHw9KIEmTgZIF4syT7G1DMQEAThsk75bgH51eCNFga5MLOVP1n5yngv23tp5S8doMfmup0b/AqnGw5ivYtwDG94Bu90PPB8p+7FHVYdgnkLwTVnwKO2cK+bt3vqgAdL6zxJo5YQl1CBv5Ea5lYzEeXcG4QRbaVHHw4J95NK0eSZIpkxqzb6NBgommSUYa1alONU6ToKai85p+q07q+CGzGjmOrYRbwoiKtHLidBoTflvImGsu55UHb2D20rUsXLmJe14ey9N3XMuiVZuZNH0OzRvV55kHSq8zxpK3xT5Lai7rn/JAVWUOAgk8UBQhnytRiUpUogRUEgsXEs5kAR3MiCrG+Khfv36RjIXIjiPg1HRxlntlXnQ6HTOm/8rrb77Ncy++xKQfpzBq5LV06dyJVavXcO3oG/n804/ZtGYlg64Yzu49e7io/6XM/WUCrU5sEt3mWf/Hqdb3s3HbDrZs382WHbuYMXcRaekZAIwaPpS3X3yC2Jhovpo8mefe+YwTp1OomhiP1eTm3XffQ2800+85IRZ6NqvO46PL6TCqaGjFooJFE2jIz4Yp18u9qN9HdF1VfIUrHXZfkSztveqW58DFEUjKfHHt42wZm/+WdPpgMFn9FvFBotpcDr/FqcX3nfZ9bqpvUWqyygLKHCXOxMOroE6I6fARiXDzDJFD2jhZDOz9f0Hb66DjbaEXFfaHJRZqFF4Mm4CPvzzOwuXruPGq+rz55N18PeV3nvn4K4b2d3HriEZ8P+GHgu1PH9iB25lPeEIMHesnoNPpcLvdPP3BJNKzcmhctzrXXzWYK26WVNzrhw/m9Y++YNfegySnpgHw4ttjGTHkMmo18JPfyPESC6FGJWk4sRl+vhUyDkmkXJ9nxChWPaX/NhghVIkCWK0W6tatQ1JMBLbMFKzF1ZZx2GjTqiVt2rRFtcSBO4+aVmn/G8Z+TU5ONnv37GHo0KEcPnSY/fv3s2nTJiIiIkiq3pD0bDt169aladOmXDvyWgxLa8C6Txl/a3sS93XgjxkzOH74aMHf5acfp17tGhw8eIgtJ/Zx17oVPPXcCwwZNICsrGwOHTpIWno66RmZfHWZi/bNjZzK9dC2TUtGXzOcFs2acOp0MqdOHGPpyrXMmLOQ2x96mp9//5Oa1asWelSrkkRSlaoFsinBcPLUadZu2MyaZWmcWO1h7KUKXaJOSfZMt/slqj95l6Spp+wqlDGkIKVa1h1389behsz59QXqlOLoDDNL5Nndt4xi6OX9QouMzjgCq8fD1l8BVZxeLYdLtmFJkir7Fkm0rtMGNTsJqWD2q8vkcorcmzFCdMyLZKj5PTvtMr9lHhUpQBWJWi0ma7LcOFPna1lwPpDo2jEUSLl4x7NAUkG7Jm4nOPKgahtodTVs+Rlm/h/cOqdodHAoaHSJREkufQcW/U8yQOuFWLC2FNxz0zXY7Hk89r8PefatT3nv+Ud4coGemlEuutWCVXcn0uSDZH74czVzV+2gd/vGZNvymLNyO+MHmWkUbiKLCP6ne5AvEq0c3b2Z7BOH2HQCzCYT3737bOkRoaFCy1ao3a30ehMAmcdg2QdCyGiEQq0uMmZUbS3R7m6HyHMaLb45/0wIOZNVxguFf6d9FgyhXo9Q7FKNLDVFFN6uVme4dhL8fBOc3g7fDIDrpvhkFouD3ijkwq9j4Mgq+OV2GPlDqXIsJULRQbd75ZyPrZN5pt8L6OMb8O5Td2DPz2f85Jn8tmgNAy9qz6yl6zl6OpUPn7iFWUvXM2f5JqbOXcHUuStoXS+BF4Y1YVx0JvU5DDGAC4hviPmSV6j/15tsnbeEvQePcBkQFRnB+HdeYujou3n7k6+oWa0qD9xxY2jHvW+BtOe4+pL1VlZ43PDrHXL9rfHQ+2khFYxhwW12DQ6b/NadD6b4ktdEFyr+yXkq2H/7ZzD4Z7g47ZKB0v4WaDYM5j4jbfzvd2HLFJHbazKw7NHtiU1h6EcSALLyUwn0OrRMHjU7Q5c7Rbo22H4NZgy9Hobt9VE3TuKujiZub2/CoAMIQzqMlt3nte0UsLng7+MGhv+QRo5Dgp4evHEYer2OVz6dzHMfTWD4pT1o1qA2P777JFfc9wpfTp1D68b1+PjZu7nnpbE8+/Y4mjeqx5UD+hR/bsfWS/YhSMZgeeUIj64WuUujVWr7/df6SCUqUYlyoZJYuJDgz/77vy8OpTmSAwwAbcHVrGkzmjVtVrBZ7aZtUXNTUBv0Rdk5QyY1r368Xq/nmaeeYPrvf7Bu/XqW/P0382fPon2XbixfsZKW7Tpx1RXD+OSDd3nk8SfZum07XS+5grFP3sBo9UcMO2fwwjtT+Wyds9ChtWrehE/eeIHaNavz0Rff8cWEnwrIhhaN6zN8QG9e/vBrrJYwhg++jFPe300Z+78yXdKzCi1joaSo850zxPEUVcNHKqguX1aCP4ngtIE9TYxrf5mB3BRflGhJ6f1ny9j8N0f+GK3Br1nBOaVAbhqEB9TIcNggZZ/cK2O418nmJRiaDoJNk2H7tNCJBZBokUtehvY3iabs3vmwYSJsmybkQrvR5ddx9sP1wy5h4fJ1fP/rn8z6ayUP3zoCgN/n/01evoPwcJ/j3WoxY7AYOJmSwcjH3mfv4ZP8tmg1qzbvAeCSrq1p1fsKDh45hsFg4N5brqPLgJGofumw2Tm57Nx7gFoN/BaXucnecy5DxsLGSTD7CXDl4Ymoim7AG1CtvSwcNedaYAFHk9+YWaIM0n8bil8ae7gRwuNiQOf9Rhew+PJ32ChKgTwSQNeuXVmxYgUXdWlPoxrxXNyzC6tWr0av1+N0OomJiaZTx47Ex8cxderPrFm+hG5NqzJC0ROXvZOxz3/JJx9/xLoNm3hm9kkAHPn5bN++A4BmTZuQkZnJiRMn+X7ipCLnkRQu9zY5V2Xj9q1s3LSVzh3b8fqLz3DTiMHcP+Ym2vcZys49+5g4dXrwa6EoxMfFUiUxgapVEqmSmEhiQhyHjhxjzYZNHDt+stD2ue4YJg4zoBxbBz/fXHSHOgPENeC0vioPfjqb1cdVbr/9diZ9dUORGhDB4PGEQJppyDkt0X9bpvqkbZoMFJmAhGAyYX7YMQN+uU2cQXV6SLStP6kA4vTU6cFaTGSb1ucKZOPShPTT5ietr2rOwX8y8r88OFskellIf+0YCohuP2JFi9LWSAdTuOibO3MAFXo8IpleJzbBX29Av+fKd7yd75CI/W3T4I8H4PqpZ+Y89cOjd92IPS+f598Zz7Nvf8r1Vw5g2I/TWXl7OPVj7ay6pwqXT8pn19E0pi5YB8DNbY3c0cGEisLruvs4rSSyauN2du47VLDfkUP60bxROesXBYNGLDToX/J2GqGwYSJ4vHZu7W7Q9V6o2VH6BAjplpcFYVFeZ6j3nmoEXW6aV/qFshENWtDDhZKtEHg9ijuvUOxSNeDZ306o3kbIhJ9vkcyU74fCdT9CUrNiduaFwQxXfApTb4aTW+T3IydBdAg1MoqDzgA9H5baJqd3wJ9PQmQ1lITGjB3VGHPucT7+YwNJcVG0a1qPDTsP8OCb33BJt9aMe/Z27Ec3U9O+nSEN8wkzbJFTxUhuYntyavZi1QkDm8b9wrylqwCwhPnszH4X+WzYGfP+Cp1Y2DVbnhuXQzdfVWHOU5JppzfDVV9ILTxjmK89KyXMnTq9kAqxtXxtINfPlr9QI7MduaEFmZ1NBJsj/fuifxCQFuyj1UMbORn2zhM5o8yj0oca9JH6C+XJ3o6vLxJl3e+H5R+L9M/R1fKo3k7G4GByZYoCLa5AiakFyz7E4LSjAsl5BnacymdfmpuDWTqsvR/khJLELx88zbH0wkoCJqOBb36dy4lkkZk9lZLOrgNH6dauGUP6duGl+6/nuQ8nMGX2Ev6e9A47Dqfw8TdTGDfhl+KJBY9bJC1BggRCqeNXHNZ7sxWaDipfXb/zIXuzEpWoxDlHJbFwoSFU57DTBulHCqeLBk4CJSySVe/CPyXLxvQZczhxeB9DGtenHchistu9EFUDh8PBmLvuYd16KeD6vxdfpEmTxqz6ewkvvvI/fpk2nV+n/8av03/jqccfpVrVqsxbsJBbnv+MLd1MvHtpGB9cHsbmrGhMifXp2aUDzZs05OTpVJ54+S1Wrt1YcEx1a1Xj3huv5s7rr6TfdfcB8MaT9zJm9AiG/SByFzrdeVBgyJUvUYEFUkglZCxs/VWemw/zRuBYfKRCIIlgS5NaESqFZV8CF0clwZ4pzp//MspqEBmMsiDxd0o77d5i2hmyyNX0Y01WuZebJsOOP6Regq6Mw3B8AyGZDq8UA/vUVslk2PwT9HjAG8FT/nZ+y4hBWC1h/O+T79i2+wAfffsLo4Zdwo9/LGDu0tXojT5tTps9H7czn7ZN67Jx50Ge/lCyGSKsYdRIimPsjyKxUrN6Vca/9QKd2rXixmuG8d2U6cTHxfDUA2OoV7sml1zcXXaYlwWbpxSusRAKNv4AfzwEgFr3InQXPwHRtYuOXYEFHAs+swlJV+CMOMdZPf8mlOY8LbRILDzoXD9qFNePGgW2VNxuF6NHXMXx0+msWLGCbt268fhjj4HqYdXqVfw4eTIxYSqb9G7axdejoboXVo5DGfoxLVu2BC+xMHfWH3zyySdM//0PduzcBUD9enVp2KA+LVu0pFXT+jSoX5eqSUnUW3QnZB7i26eupdnWBN795AtWr91Av8FX0//iHjx2/xi+/vgNZs5dxJFjJzh5KpnTqWmkpqWTnplFbq4NVVVJSU0jJTWNbd76QP5QFIVmTRrSvG51rBYzYWYTE3ONXGtZhknNE7IsoTEkNJGaH0ktwGDixWfe5setLq4d0p+n7r05pFuRmpbOkWNyHWpUq1Lyxqe2wU83+LLd6l0shS6rtSn9jw6vkEW86pbxZcQ3RWsQaeQ2FC3a7L+Nv6MvpoZkdSlI1GmgA/zfJp93tkj0spD+JR1DsKwsaxw4LeCyS/2Qvs/BrEdh2YdSvLteOYqyKgpc8opk5xxdK/J9za+ElldBYpOy7y8Azz54Ox9+NZnU9EyGD+xHrs3OFT8t4K8bw6hryeXby1w8PEePUxfG4xeFc2X9fEDF1eBS1h9sDcD9L7wHQLsWjdmwbTeWsBA0p0PFqe0SSa3oxPEVDB6XOLOWvO3LUKjeHrrcLb8JvFdOu9wr8CPKvY7C/EypcaLVzSihXlohnM36I/8UjBaZxw3Gsmc/Bc7vEQleCUyLfO5fqyQ8XtryyMlCuCbvkPoid/3tu0/FwRQhzvApN4h+/MSrodkQsQ2rtCyfvrjBLPKYS96Fk5sh+wRkn0B3YDEftIOXmkWy5NAqrhvYki8i85i27iSO49volryPNnX0eCMF2JFuYGHc9SxUejDz8dvItxWWox3YtwfXX3l5wfuPvxQHZPWqSXz65guhHeuhZTKnQNllkFRV7N41XwEKXDlexikNDpusi8xF5RwLEFnVS2L7fZ+bBu48L7lwoRILNl+x93/qHAPnp5Js6mBzWfNhUPciWPMFrPpMsig/7w23zy//3BJbR6L7O98J676WOijHN8Cvt8OQj3z1pgJRo4OsxezpKNYEkvRGwm15HJ77NxM+mUzjvj0AOJkjZEmY2URevoz1DqergFSoXT2RO68ZSNe2vuCqhrVlXW8yyvrwxuED+fibKWzYtgtVVYtm1jlssHKsEIvmKOj1WPmuBcDpnRJIAtDh5vLt43zI3qxEJSpxzlFJLFxoCDVizmHz6e6agfSjoMk7aJNASQtUrx55+qljbN68GZy5LDYnUZtY4u1pMOFKuGEan0/8ne8nirOxY4f2KIrCL79OIyIigg/ffZuXnn+GV157kylTf+b1t97h0v79uOP2W9m5cxer3C4WHtxG37o6bm2aw5g/VrNkxZpC0c7gdeQ0asC1g/vQqF4tRtz9NGs2bUev13PtkFKixc4lNEJh1TjI8eZQJDSB6JrF/0Zz1MTW80keGa2Soph2UBzWBot8pwIooKiFSQRtcRRKdIoluvRtLnSUxSAyWQMWsVrfsUjUrk4v6e95WRJBZbSIUWyJlcj5o2tL1jMvCbW7wo3ThVBY9hHknIQ5T4suZo+HfcW2yghFURg5pD+XXtSZ3iPvZ8uufcxcuILH7xzF1t37+fPvDQXbGo0G3M58Nu48SM0q8Rw9lUrdGkkcPpHMroPHMRkNPHbvbTz1wBjCvdHi995yHd9NmU5qWga9u3emQ5sWsghe6Y2k1tp8QpPQJZ52eqPf2t2A0vtpWVSaI72FtP0KlTpsgEEi2zTHjcclC1F7OoRFllxjoaS24b9AulCcNMFQBudpsbIiJisG77V66sknC3+nKmxau5LqMWFkZyTTpW1zssLqw643JSul3Wio0qFg8+5du9K3Vw/27t3H+x99wjffT2D/gYPsP3CQufMXFmwXExPNxGEmBtUF694/uMcYRZtHBvDt6gxmL1jM/MXLmL94WUjnZTAYaNW8Cc2aNKJG1SqoQEJ8LGaTmYOHjrBw6XJ+/nNxwfafA/ebITbCTLfudbjhil5c0rgjBoOePUdO8fKHXzPpt7kA3D5yKPOWrmbGgmXY8/JxuVw4XW6cqg6n04XT5SItPYNd+w6Qkppe8B81q1Ut/oDdTpERcNqgSgvR02/YN6RzBeDv94VUaDYUrv7KR4b6R/Bq7cKWIpFzWj/WijcHazPFyRRpfbMye0hQUZkQwa63yeILWHDaofVIcUyu/170y+9aGpq8ViAMZhg6VkiFtH3isFn3tbS/FleJZFJpuvTFQFEUundswx/zlvDoK+/z8SuP0+qeS1g4dzaDXGvoWtPAitsMeFQVnZIHwM/bnYz/cwf6QbKP7XsOEBMVQVREeME+KwQ5p+D3e+V1g77B5zCnHX64WuRwQGoo9HpcIkxdDt82/sEKgffevyh3WFzhTKBQJf3+zTKVxcEULoRleWQNA+d3o392Vapc63w/W04je66dKPcz/YDUT2g5vPT/ssTKWDr1Zgky2jBBHnH1xXnasJ9kE5UFRqtkGeVnyxohZTek7MZ1aifRYU6GNDECu7h0IGT3iyDSLG0+M09l0lYnX653sCnFSL/nLgPA5XRhtYTRonF9WjVtSOe2Lbh5xGDMZiGVN23dyf/eGwfAG8/9Hw3rlyIFZc+AtV9JHRdUqNuzbNHQbqfItG30ZiP2fkqK7/rDmQeObLClQ6x3beXvuC6uzYfHBc8+vpBQlv5+roJocvzkxmJLyKgvOC6vPFLX+6Dt9SIndmqrZMCcKWkdVU3kUzuNga+87cqWWvJvDGGF+mm4NYwbrujP0P49uWZG4U01UkGv19GxRSMu6tiCwRd3plu7ZiiKwt5Dx9l35AQbtu9j/JRZsj9vQfSWTRqg1+tJScvg5OlUqlXxI4aOrRfpQc2v0Ofp8snjgpAKPwwXqbAaHaSOVlkQqvRyJSpRiQsSlcRCEARlg/8tCNXpow32kV5Dw2AAl0tIhtyUUo0J1WiB3FTioixUjY/i6MHTxMTGsaPqEzTb/CrxGYdgwpX0af8qtWvX4vDhI6xdt56bbrvdd6hGI//30AN8OX4szZs15ZXX3mDu/AUAREdHk5mZyTNH9Ky4LZyb2pr5ak8sK3eekN8aDDhdIuWgqirbd+/lhff2FuzbYNDzv0fvIikhjjxnKKH6ZxEuh8jerP3aN/FHVJHItFZXlxxdXq21RPak7Q2I8sgTp7UjRxY7DrsYxApCKnjvjzgNIkJvExfaIrM8KMt1MFpl8eIvPaHtw2QFR7wYwrlpIjdhA8KipQj3zj9gz5zyEwsgbafpYFlcbfgB1n4pESvT7pCigB1vl2iucmQwxMVEMW/C+wwd8wSrN+3gjXETAQgL9zmZDs0dz69zlvLQm99w9JQY4AePnQZg4EXt+eip22jQQSI2Dxw6ytQ/5jD+uykA1KtdkyYxDpj3POxdII5LgPhGUpCwaRkyL7Tsn+bDhEhz2qX9g09exWn3/Ye/DJLTLkSDIcmrEV+CM6KktnEhRn+eLQQrkOk357Ru3hgzTlo2qk2nnv1A0aOGHUbZNBlmPAw3zy+yy4YNGzD2o/d5+YVnGf/FV0z//Q9OnDzJ6dPJOJ1OMjIyGfY9PNTVxFM9TVSxZnEV82hS3435CPyyHVAUdDodlrAwoiLDiY6KIiEulqTEeOLjYknPyGTdpq3sP3iYDZu3sWHzNgDq1KpJano6OTm5BcejKAodWzWmU6umZGTnsHrTTvYeOsbBPxYy+Y+FJMXH0rl1E2YvWYPbLe3ysou78Py7n7Ni/daQL2XtmtW5cuAlVEkqIQJx3bdSsDAsGq78vGyLztR93kLoCmq/50HR+4Sx/Aue+wck2FJFZthh99ZNKGPUmuYAd9pCskcuKARz6JxJJkTImvPecc+eBp3vhj3zpc7V/Bdh4Dvl+29rHNz0BxxcItmX+xZJ5sypbaIFX7+3jNl1epS5nsPT993KsjWb2LprH32uuZOWDapzcbvGnK7eg0b2DfSrloNOUdiQZuWnfVbennMQdHvo5yUWrhnclyNHj7N41QZMJiPXX3Fp+c7RH1nHYPo9YufF1YdLipHenPuskArmKLj8DV9xzIKMn1SZqwK1/f3hX5Q7JqnwvQ11/vk3y1SeDZQ0v2t2gaL31YLR7IrIqtDoUlj9GRxYGhqxALIOuPF3ieDf/pvUHUjbL0Tu3++LY6/pICEZykLumSOFpPJKobjz83jmueepa0qjSzUPzSJtRJrduD0q49Y6eWulSvWatWjUOonuNeuh5eFZLGEoHieD+/fkoduuIyrSz/Y7cowBI28nJ9dG7x6dGTV8SPHHk3EE1n8n2ewuIfpodY1kWIQKRy78MkaIG0UP/V+WDChbuq+2gskqz7Z077rI25+KkEVB7m94woWbqaDBVEIWRyAqKuK8NIJCCXgubh+2NF/AnD1DiOvo6jJ/nNoqJFqFQyk+W6EUmE0GtAN+8MYr+HTitAJiwe32sGrzLlZt3sU7X/+KyWjA5fYUkbVMiI3ijmskoycszIzVEkZ2Ti65Nr9AqdWfy1oSIKIqDHy7bBK7/tBIBVuaFH4e/KGMb4oSOslUUlZMYFuozACvRCUuOFQSC36w2WxYrVJL4F9NLoSCYMaVRjKEYEwoRiuY7MQnmogMM2IOjyY7x06PIfeyNRSSlusAAKyKSURBVLE6LLiX+IxDtFj/DHtXzePH2cuYMWsWWdnZ5OTkkJKSys5du3jj7XeZMGkyjz70IFMnTWTCpEn8Ov13MjMzadSwAbf938Pk5E8kIn07T15k5doDJvLzHThdLmrXrM7LTz5Ej87tWbBkBXMXLGD91l307tqe5x64jfp1apzli1gKNEJhzVeQK87WQoSCIYTUey1a4NiGwp9HVZdMBS3yWstmiPbes9xUIR20qJ1QJu3KRaagrNehYHs/Ass/kjc83vs+x1u0NE9kSHb+AbvnQr8Q08dLgiEMOt0GLa6A1V9InZOTW2DGgxDXADreAgmNyiy7VCUxjmU/j2PcxOlMn7eUtVt2kpvnq3fSdOgD3HHlxbz/xM18O30Rq7fspWHtqlRLjGH7/qP0ve0FzJa3UFWVvQcOF/xudOdEPh9dG8vMu31/Vrur1Iqo06NsmRYetxRrBp+smMMOqF7j1s+JGphdoj00B0FECTUWSjOCK4m58iHInNOjV196dPVbHJksIq2yZy4k70S/aizQKuju4uPjeebJx3nmyccBUPOzSE/PkALNycmcOp3Mj8cPUy9tMb3MO2iRBFNHWNl8ys2Lf+UzfaeLnNxccnJzOX7ydMF+I8LDadSgLs0aN6R9m5ZkZmZz5Nhx9h44xKEjUkw6LjaGnl070atbZy5qUZ2E2GgMBj3xMVFYLWGs3bKLCdPn8eOMRZxOTWfGopUAtG3eCI9HZc5iiWA2m03cNHwANasmYTQaMBoMGK3RBa8jIqw0aVCfxg3qFmQCFYv0Q7DiE3l98ZNlj2Rb/YVcxwZ9ISxG+pZZc3gHkdYxWsFo8xbIdAgBXm6n+H8wnf5Mz1kbpzQiwZ/8CXQ4O3J9UlSWOJ9UnAL0fwmmjZHo4mZDxclZHuiN0KCfPGxpUjdq269CLuydLw9rHDQZJA7ZELWyu3Zoxe6lv/L8O+MZP+EXtu47ztZ9xwu+rxmloFfgUGYWPVo3YNOE5/hq5mq2eb/ff/g4q9ZtwmoJY/rnr9OjY+vynZ+GQ8tFQiovQ/rYFeOlHkIgtv4iTlYUIR5aX+P7zpknGuPOPJmnSoqJ8S/KXRyR8G+tVXKmKKnNl4TibL9CmVl+Y55mP4AUs1/9GRxcKnI9odoweqM4L+v3lkyD3XNgx29wZLUUqj22Dv56UwJEWl8j2u9lhNkcxpsvP+v7QPWgZhxh3tq9jN35B0fSj3EkfS+rtuxFb1xHv+euA8Buz8PtzOeFdz/nw6+m8H93XE+dmlXZtms/k36fx4lTybRs1php340NXg/o1DbY6NXF17Tzk5pDl7uELAkVOckwZbRkUhksUqOiYX/pJx6nL+tUux/R1SRD3L+GVqW8ZdlQUfZsafOZ0QqOvJKvvb+EqWKQQEitvmCsN+MleeeZHac/johdRpUW5Y/898OrD9/IwzcM4oWPJ/L1L3MLPtfpFHSKDodTgiQtYWYa1KpKwzrVGdy7M6MG98YSZkZVVf5etQGHU9ZeKqpINS152xes2Gyo1DZKKkchdChMKiQ2laLyerOvHZQliz+U4CtjGfdbiUpU4l8BRQ3UlfmPYtu2bYwaNYrnn3+e4cMl2qQ85EJ+fj75+fkF77OysqhVqxaZmZlERQVZZJQHZ/OWOW2SmqggbHMxg72qquzatpGj+3ezdOnf5OfnkVSjDl179WXbpvXEGez0PPAeVUx2iKkDN0yTAsR+v//jjxk89OjjHDh4sNC+DQYDYWFh5Obmoqoq/erpmX9jODanSt0PcjDHVOHRe2/nrpuvw2z2c84Xk7KY51QLaiz8dn0CYaYQo6BLKv7lj8B0/mCEQngSdL0nNELB35BJ3gnjussi5t51YPG2IYfdRyYEg9MGGcdlcWqOLDkSpzjDurjPQ+0TIbTTrKwsomNiivSPc9qPKmxh4Xe+mgSP5tjOTfWlWeuNkH0axneTbe5ZGbzOhmZIl4b8INvlpsLGiVKvQNtPeCI0HyoOnpLaoKH4iH2Px8O2fUd5dKXcgwWvDMftzC92e3/odDqeHNqMh9vlkeDxFmdW9LJAbDsqeJG0YAhsyxmH4eMOcl3v3ySOTPA6NINIQwRKTIRauLnQPS2hP/0DhHRWVlZBlleF9aOyzjNl6Uf+20Lh3zlyih/fNkyEPx5A1Zu5TX2NY0o1fnu4F2GmEsZqR3bx3+VliZNv7TcF/SQrrAZLPR2Ze0hh976D7N53kIOHj5atSHIQRIRbqJoQR9XEOJLionE4XZxMTmP3oWNkZUumg9ls4o7rhvHkPTdQvUpA4fJQF7j+ka1p+6XI5YlNULs7DP/K1z7NIUTA5mfDJ53Bkc2xHq/x57YM8m05dOp+EZ269SrcXxw2X8S1w+6rmxB4D8vSP0JpUxXY38rcjzIySu9HZZ0vzzSqT6tPoY1TgRkL/u+ddhk/3fkQWUMc/HZvZKg1DmY/DpsmQUxtuHVOaE5aV2jzASc2SbHMnTPEmQGAIplqXe+FmFq+8ykFyanpLJk1lcUbdnPsdAbdWtXn4vaN+XPFNl7+agYut4eYSCtX9uvMsfaPAjJ3hYcZmPn12/TsFKTOSEwIshwg12rt17DsfXGeVmkJgz/w1b7SEJEEqXvhy35yD9qMgouf8Dqrw3z3WpNCgqJzUqG5KoR7EdgWSsI/2Y8q2q4rKUunrGSLv+SUObL4GmSZx+GjtuLovmclxNYNvl1eZmjnkbpH5F12zhKJJZAMzsvfKOyU17I1S0NeVtCPXS43S9fvYNGarfy1Zjtrdh2h1xM/AvBcqxSOnzjOC+99zs69B4v8tka1KqyYPYVaNfwkm1SPkGzrJ8Dx9b7P6/aEDrcUL9FZXF2K1H0ip5ZxWLYZORli60vQlDVW+o5/xoKGUNdvofaRirbr/O2rYsb4s7I+Otcun9Lmr8Drrwaxs7SMBU3SFCSYyhoLxzbBhCHy/omDPvtfQ34J9l+h7fzWUXOelnmp0+3Q/YHC26XsCml3eQ4Xw36Va/3bVQphBmk/W3Yd4PmPJ7JgxUayc+1Ffme1mLGYzVgtZqxhZsItYWTn2thzSEhzk8lI2pQHCN/0lVyriKrQ61Ef4RhbihyZBm1cdNphzZcip+vIEQnaAW+LLGxEFZnHQvQLlYqy2DbnYD4q73b/dRw+fJilS5cyevRo1q1bR/v2RYuE5zlcDHtzDgC/PXEZYabgQY3r16+nQ4cOxe6nEucPQu0flRkLXnz33Xfs3buXV155BbfbzTXXXFOuzIXXX3+dl1566Swe6VmGpkGZnyV1F7Ro98AoOGD/kRPYHHpq16pJUpUqTP35Zz77ZgK9Ordj8GV9WVbrXnodG0dCxiGYeBXcPKvAOaIoCkOHDOLSS/rx3YQfmDBpMvsPHODkyVO4XC5ycnyT/JoUCzsyw2gWncfWT0aTOOT58y+bRFXF4NjxhywG7N6FcniSRJI3v7JwQeVQEd9ItPptKRLFVLsHWGPEieqwFz/BG60QU93roAsxdTEwauAfjCY4p/3obJxnsEhejRQyWiCuDtTqCof+FpmRLndWzP9qCI+HHg+KpNDmKeKQzU0WsmvzVGg2GBpfXmbJHp1OR6O6tWClLI6//t+9TJ21mJSMbNIyc7DZpZBzrw7N6dqmMWaTEUd4DaxpO2iZtQBT6g7wINe5+TBofa3ICJwJtIV1dC1ZRIRFFtZAzk0DXOJwjalVtD847fK7zGNCEvrLJGnQnKYqEPHvMTj/kX6Um+KbR4rrT/59LnCh4rD7otG09xrJ0Ohy1NrdUQ4v50G+5HHds8H3HyrCoqD7/dD+RikEuHESUXnHGMQxBrVpBiMkDd3lzCctNZX09DRsNhv23Bzstlzy7Lnk223sTs5n0nY4nePB7XbLw+XC7XHjcLpwOl3k5NrZm3uMvYeOFTmMWtWrcPvIIdw+cmhRQqE8SN4l0bO7ZgOqkIX9Xyz7Ym3zT+DIRo1rwFuTF7Brxx6iY6KJi4umU7MGhQudO22yOM9OhsjE0CX4/BHoEDxPsujOaT8KPOeyzk9axKA29/jXVfB3koJso+glMlHBK53ol+nZ93k4sFicen+9DpcWI+1THiQ2gcTHoMdDIgWz9RfY/xfsnClR2y2uknkxBDm8xPhYhvdtz/C+hRemnZrXpVaVWG555Tsysm18P3MF/byb3Dh8AM/dez31alUPsscQ4ciFOc/CXm8Uaosr5ZoFI+6ddtEDd+RCjY5SJNvt8Ep9hUu2qdEqzuviUFr2SaAz/TyrVXLO+pG/00xzRgZm8ITan/wlpyJKkEkMj5esniMrRQ6pOGIhVERWE/utwy0SYLT2G5FKmvM0GN4VR30FwGDQ06dzS/p0bgmAPbw2V/wggR8d2zQnrGMLhg/sy8sffMmEX2dRs2oVWjSuT8uWLbhq0CVUq5okO3I7YNefEtCS5iVCdHrJROp4CyQ0LvvBHVsnBa7t6RKgdvXXEF0bsk6AThFyIbGBEAuZJ3wZ3Mawwv2oJAfm+ZBpWsYx/l/lZyhtDi/p+jv9iNTomhI86HFLu7LEyDbRNWQ97MqTzOVgQVplgarCYW/GQu1ySgqVgFZN6jHtk+fweDzsPniM76cvYNyPs8jIEp+HzZ6PzZ5Pakbh31ktYVx/xaW81ttA+EbJIqXRpUJ8lLWWDAgpsW26FELP8tqk1doJcam6xZbTh8l11iTF9CZfG9VkKlVEfrY8qgjniX1XidBx+PBhmjVrVqDwkpBwgcvHVaLMqMxY8OLFF19k/vz5tG/fnvnz5/PCCy9w7bXXAuB2u4OneQbBOYnIqWgENgGnDdKPeCN0osTxEySqY/uO7ezbt4+GdWrQtF5tWnfqxun0bOpXi+bj99+lQ6euTJ7wDZcde594g00m6Rum+xZd/tEHXjgcDk6cOEl2TjYJ8fHExcVhwiHp8tPvFmfFHYuDp5gXI/OS53Qz7KPVAPz2QGfC9CFGnoYiG5NzWhbCW6YWTsWMrArd7oc2I33nG6qGcOBC+s8nxSFcp6cUZYqsIYZzWGTFTMpnK2MhBPzjkW0QQkSod7viItu1z0typPr/h94kn60cB/Oek2LON0wL/ptQoAuhXTntsGkyrBoPmUfkM3Ok1GDo8YDvmECiKktAntPDsO+l1slv97YlzFjC2HhqKyz7GA78Je8NYRIF1OWuopk+BlORnwdHQPtb+7VE1jboB4Pek0WmNVb6kccl2SEGAxgjILZW0d3lpkLyXpGqMlqEfAiMVi1L5GeoON8zf8qbseCwyb0s6VqV1OdyU3zZPQ4bhQr7OXLh8GrUKaNQXHbeVe7g3sdfLjYapkzn4fIW8F71Gaz7JvT+p0FvEj3sdjdK9Ji3noeqquTk5HLy1ClOnjpd6JGVnc3l/fty+SV9S7cxQmkvp7bCyk/FMauh0SXQ82GRoPBHaZrdqgc+7QJpB1AveoLBL/1CelY2To+Bz999gXbtO/kieB02WfTbMqSvYShMOviPnSVlSuQk+/pZRAUQLGXEeTEfBaLcGXVB9pd+RIIUFAMkNPA5dWypsnl4fFGH9e45MFlsYUb/CvUuKvlvg2XQBUMw5/vJzSL7sn+Rd5sw6U9d7iy90LNWPyfwY1Vl3YZN7Ni1h72HjrLSLA7Z3+5oSpixBNKiNNI9bb/UU0jbJ3PwZa8JQVlcP539hIwr4Ykw/Duo0Uaue36O9AltzgkWsashN1XGKEts0f5xpnPU+Z75Eyq089DGEnsmWKJ9Y4ojt2z9yZ+wgcLrFn9b0OOCxW/Dkreg+RUw/Ivg+3O7ynYeGjxu+O1e2D5diMCRPwi5oNlzpSFEGcw8zAwbuxEoxb7T+m/GYdj0I2z5yZddZIqQLNQOt0BCw9COz3/do6oSpDX9HnDZoWobkRYzh8s8m31K7LyoamIXnN4NnjzIt0vQTmAfKK5vnA2psPL0I/826Tfu/KPzUUWjLPakdl+cNrnfwbLvVLcQS648mHQtZByEayZAkwGF9+VxBv2LItDIsNR98NMNMvfc+mfhtRFInaoQkOfRMewTkTD+7b52xfejnGTcbjc5uTbsefnY8/Kw2fOw2/Ox2e3Y7Hm43G569r2cmCXPwq5Z8ruLnxRSIbC9BR5vMBxeIbXttIyiqOpSCL3RZdIPc1Ol30V7i597XEIc+gcM5aaI/wMkG6+i65NUZiycl9AyDCZOnMhFF11E7drBMzsrMxYuPFRmLJQRffr0IT09nXvvvZeMjAxefvll4uLiWL16NX369KFbt24hRcmbzebC8jz/Rhit4oDzjyIIiCpQVZVmTZtx9Ogx/vhzAcc7dKB161bs3b6Ftm3b0aFTVzBamLtqO7t0rXmp0XaZzGY8BMM+LXbSMJlM1KkTMFA5HNCgr0Tvp+6RiJiu95zFC1AKnHlCdGz7RSKTtIWg3gyNL4WWV4seahn17ItFy6uFWDi+XtLkw2PFsLJnSlZJeNyZTerFRQ38g9EE57QfhXqehaIF/RxmGcdAdUnkZ2ytkq+lltJrDIPGlwmxcHiFpKkHI8sqCkYLdLgZ2l4v8hMrxkqGzbL3Yd9CGPbJmUf6+CN1Hyz/0Ofg1Bnkv3s8KOm1FQktYyGxsZyn3ltDAUU4iGhvRKrmGAhGEEUlQXqeLCaCrX+Ki6o6z/V5/5F+ZLKFdq1Kul5adk9gYT9TONTujKvTXRhXvM8d6g+Qez+YqgXbS9lhiZWCkp3HCGGVtl/ak6KXZ51eXusM8tAb5OAOLBGn6LZp8qjSEtqNhqZDUIxhREZGEBkZQaOGQfTjKyK24/gG6dOaQxYFmgyE7vcWJRRCxd75QiqYIlHbXU/3rkfYuHYF4TGJ5LhNQir4O9v0JsmmM1qLkq+2VB9BVBKxcD5EjwbBP2rXGf3mGv/35YGCjHFmv6LApdVhqNEB2lwnxPSMh+DOxaWTUuVF1dbiMD28UjIkjq6BNZ+LHFOnMRL5XMb/VhSFju3b0rF9Wwky+WR96T8qDXvmwezHxNEVWRWGfw01Oxa//dZfhVTQ6irUaOOXVWANHnHqTyJo8jtOu9gaQYJy/g1z1DntR9r10K6df3s3hcu4G8q10XT7HTbJatQbJaNbb6RIce16PYVYOPi3rAtCyLYJGTo9DP1YHKm7/4SfboRRU84847M8cDvFbtw4SWpKaIioIlkWba+ToLQy79ch8+fKcVIjDKB+Hxj0vhAZbqfMu5ZYiDT51ljhcRKMEBXj+yz9sJ8cn18GcaAU3Pmg8e6fVRYCLgg/Q0nQ7ouK3M/A+2YKF6e2QyQkSWwqxELyrqLEQllxVIIQqdY2NCd9cXA7qKaeIokU9NsPQu5J6avNhhQh1fV6PdFRkURHFZOtZk+HmbeLD0BvEqm9FleW/ZhS98GCl2DXTHlvipSgk653e/uDdzzUArA0m0NnkPWpfx8xWcWOUDnv7LVKnH00a9asWFKhEv9tVBILXhiNRubNm8ebb77JE088wbhx47j22mvJyMjg1KlT/42Czv7wd4TmpsjEEcR5vXHjRjIzM1m3bh0/fP15EW3fPl1asWJJChMz2zPaslQWpwlNoOdDZTseRSdRa7MehXXfQvubg09mrnxJh0w7ILqkOgO62MZEq3YylXI6blVVjJjkneIo3TWzsG5jjY5SO6HpYF96ZkWiRgdJq04/CKe3Q70e8nluGrjzvNG9leloZx3B5I20NPnsdJH/KG2BkpPidbCFi5EZV1+cl/sWlM9QLCv0RimQ2eJKiQib8zSc3ARfXwaXvgqtRpzZ/rOOS6HYbdO8hJsi/3XRo6Frf5YVWqRRdM0ADVYt0ilAEzmQINLGkaoiBRB0XCmpqOP5sDA9n3Cm18q/nxktRR1vpnDcvZ7g0Ipfacgh3Aueh6uLiQ4tL6zx0Oux4N8Fiyju9Rgc3wgbvocdMyRz4M8nxTna8moh1c5G+z+yWvrboWXyXtFJEb9u90qx9jOBt2gz7W9EianJ08+/zA+ff0BOro3t27dx0WXDfNtq98zl8GWbgF90oXe70jiUMjpY/jMoi8xYSftQkWwFlcJO6GBzmz863gH7Fkl08oKXYcBbZ3I2paN2V8lu3bdQpBqSdwgJvv47cYK0HV16raqzAY9bCPOV4+R9zU5w9TcSsVkcUvfBrP+T113uFn18rY2X1N6zj4ud6bL75rBAotUf/+Y5ymkDKjiwIpSxpLRr4y8B67SL/eT2RkDbM4vq+Cc1F9k5W4oUQ61STlK3OOiNcOVnMPUmkQ37cRQMGwtJzSr2f4pDxhHJTNj6q5wjAIpkMbUZJW071Mxsf9jSYP33ovWuFaM1WqHjbdD3GcnycNqFzDZHgDHXZ+vlpsj9SfKTWspN8dUWM3rXrlpb0LIX/MmFSsfo+QXtvoRHBr9vpnAJztK+q9IM9vxZMQWcj6yR51qdSt9WVSWg5NQ2Wftkn5RxO+sE5txkvtUMnnl+v1n2oWRstxoRWpZ2+iHxe2Qfh7AYmW9qdy3bOdnTpdDz2q8lg0PRiQ+l95OF5y7/8RBKzoAzWkOvQ1SJSlTiP4NKYsGL5s2bExsbi9FopEWLFhw8eBCHw0HdunVZvnw5w4YN+++QCv5w2CQ6Jzc1aDR227Zt2bhxI23bti2q7eu0c9P1o2jRqD42p8pfG4z0dsyDBS9CfH1oeEnZjqXpIJmUM4/Ami+genshD9IP+p4zjxHovTABPwEpxGKc1hqqNJUIh8Sm4rD3L/aUlwUpu+WRulciIFJ2Fy24FlVDHKYtrhSt4LMJRRHn1NJ3YPdscQybvDqitjSIjjmvotIuWPg7oTVobV3Rexc+pezDfwhx5kG93kIs7Jl7boiFguPQSY2Dmp3gjwcka2Lmw6Kn3XlM2SNSs0/KonDzj76Fd4N+kqFQo0PFH78/CooX6iQ92hQhfcPlCO4oC3SinUlmjjbmgY+Arex/wRFKNLq/pq6/8y0QOgPv68bwkec59Dumwd5rpQj4P4nqbeXR51lxvmyYAJlHYe1XsqCr10v6hMkqziejWZ4NYfIwep8NFonctKWBPVWebalSt8eW5n1OFbI745D8t84g40eXOyE+ROmJkpC8W7IfFB20u6GguG79Zq3ZuWMnDVq1K7y9NjbmpoEn30cuaI6A8HhwFhOZXYnSofUdl6P8TmKnXRwZzjzvs59DrTQnrDUGej0Bsx4WrfemQ0qXRDpTKIo4Kmt3E/mHv98TG2/Rq0LYWRPEKRKRBOFVxPlR8D7JJ89QUVHj9gyY+YgvQrvDzdDr8ZKDOpx2+NVbV6F2N5kPi+sDBRG5Yb57m58rMku5qWLzWeNkfDCVoR+dp1lAhaDV0wkVFWXvlnZtNEdbIXvBIvdDb5R7kesdo8OipW9Vaw1HVsHBJRVPLIAQald/LaTC4ZXw2/1w1fiKGfeDQctO2DzFR2CDSHq1vgZaj/QVWi8rUveJ9OCmH4VAA+m77W6U+ltR1eQ6642F27w2XuWmCPmWm+aV3vOrLWKKEHs7MNrd3/6rJLLPTwS7L8Hsdisih2TxjsEhFlYuFm4HnBD5Imp2Ln47W5pkfm/9pdji6QqQj5HTJFC9dj30UdUkkynnlGQNrBovBEP93sVnRhzfCHOelDYeUweunVi2fu7IkUDMv9/z+TAa9hcZJa0GjP+6xX88dNjAnuULEgkFlX6ISlTiP49KYsGLmJgYzGYza9asYfz48WzYsIEvv/ySxYsXc+eddwIwbNiwUvZyAcJkFcPZYAy6mL2kf38u6e916ChK4e+9hkBinaYcPZ2Ks/NdHNytUPf0XPj1TrhxuqS+hwqdATrfIfIxKz4p4ZgjIa6eTJweJ55T29FlHCKBdDi4WB4azFFQp7s4dE5slIVrMCg6iK0HNdqLA6dW54pNcy4NjS8VYuHQcnE24S0wG19Xrsu/ISrtQkGglI62KA0l+iQ8wedEBHGcrPtaHCebJkOrawoTXWcbUdXhuinSn5a+K/q9R1ZB/5dCIsyU5B2weaJEaWtaprW6QM9HxMl6JnDlQcoeKTqdkyzPucniUM1NLvwACIuXAovhXseMOVLuVW5qYckWo6VoFkN5oZESWjTV2ex/54PRfibHUByB479Pf0dOKQv+vUp9pisDGK7OEomWa3+Aam3KdkxnA9Y4WTB2uEWIug0TRCrpwGJ5VCT0JiGdu9zp08M9U2SfEJkXQG3QV+5Zfja4nHTrO4hul11dOMjCfzzUJCnC4wIcOEFI2UqEjtJkxkKFPUvmHk1eIhDFFQDOPAbV28j8tOUn6W93/FVyoeGKgqKTbNDGl4sjZ/lH0kZzT8vjVAm/jawKne/0RoeWM8PBlQ9bfoZV48QpZAiDy16VzKDSsOg1iWYNT5BI08gSZACddulntjSR7wuL9RYldfqK2YfHV9y4ez6hLEQJVJy9G2ph2WBjmEaUZh4Dd74QT8YwqQdwZBXsmi1t72wEpBmtcM1EmDRCZPCm3wsD3jxzm8sLq2qjA5sxzpkMh5YUDqyq0xPaXCv9sTzZCSCZPwtf9a7jvIFgiU1lzmw62FskNhsyj0tfMFmk/TvtvuupkQS5abI+9bcZAh3T/tHu/tkLlTi3OBP7MRjZ4MyTOUuLnD+9U2SD210v43RZcWqbjPd6U2GJMdUja5Ejq+DoWvEVeLy1UgwWqN0FomoKERZVHSKrkRdRk2FfHQJF4bcr26E36iUwYMtUIRU0gmHFWKnF2Gxo4fPbM1fmD48TqrSAkT+WTZlg1ywhwrX1UVILuOQlkRazpXrrz2SJ7Kg2jvqPhw6bT5I0GILdy1DG5fNhHVOJSlTirKGSWAA8Hg86nY6EhAQGDBhATEwMM2fOpG3btjRu3Bij0UjLli3/6cP8ZxCs3gKUnL3hvzgNT6BOwwTqaCR7n4ul0NK+BfDTTXDLLIgsgz52iyvFAZu6Vxj8uLri8I+tK0x+bF2JZPM7PofTzcgPF1OPI7zVW8GYsl1SJpN3SzbG7j8L/0dkNZGRSGwqztWEJhDf4J9JvQeJBv/9AXltiQGdSQxtjVDw1/uvdN6cPWhO6rx0iSJU/AqUhppSbbR6Fzh5sght2A+qthI92d/vF4mFvs+d2+hrnV4iKev0gN/vk4yg3+6VwmDNhhRdGKseuqrruMozG/Pk7b7Pa3aS2ie1u535Yjr7JHw72BeRXRriG0H1VhBdrbCx6q/tXnDtz0Lq+7mICj0fyMOzcQz++wzMeisF3ytXc2XMDnTpB+CbgeLwa3/T2XHmlBU6vdQGatBXCOvNUyS6zZkn0ZmuPFnEOr2vnXnyrLoBRcZ6S5wQFdZ4eVi0197n+IYVJ4OnqrD5J5j7tDiS9CaUTndI6J3TCbiknox/UWYoLC0WHl+YtCtr8eZKlIwzdRJbooLLw2kIVmvBFC6a5o4c6P6QOFcyDomM3tCPy38sZYXOIFHMrUbIPJx7SkjmnNPipCl4n+wlHZJlHimIDr0bml4V+v8FEgogDqxhY8U2LA2Zx7x1FYAB73jttdzinZr+TlKH3Vu8PmAc1DIXLjSHTJmdjBU435bk6Cqu/oU/yWCN82UsmCySib3uGwkCWv6RyNJVVL01f5gjYORkmDBMMqun3yUBHa1GlG/+yz4B+5dgPLCUnzwrMeIGLQDcmiCZ0q1HQLQ3O6G8pII9HX69Q6ScQLL4ut8P1TvI/Ac+ks0c6R2L/Ooh5GXLOKaRBDE1gtdP8O9npUm9VeLcIFBqpzQHc3H30x9up6zPE5vKuv7PJ2DZB1I7oO31oCtDAGBYjKzt3A5po22vg2MbZM6zpxXetkoLCepoMjC4TePRgXK48GcGk5AerUYUJhhWfALrvoOWV8l323+X2kIgGQ19nw/dzsvPgjnPSF0iELndrvcWPk6jReY3LRsh2DhaWjZ2sLVAKOPy+bCOqUQlKnHW8J8hFlwuF6qqYjT6jCGNUNB5J567776bQ4cOMXbsWJH2Adq3b0+LFi0u7EJJpSHk4rZeA91h80u1Dy9qHFz9tWi6J++EqTfDDdNCn2AMZtHeRS2aMVCC8W5XLGynMe42nTHqvRrZHrc4dA8tEw3P6m0k4tUSW+r+zjryMmHvQola2DtP3ocnwshJEFdHrmegUVY5SZ9dOO3iXHG7wZEHkUmFdfqLRNMUs2B15vmRC1a4ZbbICP39gdTQ+PE6yaK5+MkKi0ALCTU7wi1/wrQ7pE/8/a7oh170fxQU9tr1J6YtP/OS5xgAqqJHaXy5yEJUK0P2UUlwO+DnW8V5ZYqQSGxrvBj91jgwR8siXmcASzxUbQEJDYrKNzlsYMuQYpfGiLO7uDwXUaHng6TF2TgG/30GXsdSFpZ5ShiOwZ8R9vf/JCtg1qNSO2TQu75U7/MBsXXh4ieCfxdYvNntkLktcP45m2RJ8m6Y/7wUbAaJbhvwJiQ0lutuRUiFgshQv3sUSr/yd1hXEgv/DIwWIVr9JeKCZScEu5fh8b7Aisteg59uEPmSRpdBs8Hn7hxA+kZEojz8EwBUd+HtXPmw9Wdx3mSfhAUvYl41jsGegcxRehe/f5cDtk8T+TKNUIioIsREq6tDDzBZ/pH05ZqdRRM7kLDxH9vA6yiNk/FAi+B32SWgOzxOyAYtc6Gkuea/EBFakfNtMEdXoWtYir2gkan52XJvqrUWiay/XoWF/5NgkSYDRXqybo+KOWYNlhi46gtY+IoUFF/yttiQvZ8sPWJbVaV2yf7F8vDKyOi9j6NUpWr7ARga9Rc7tCLWQ0fXwrQ7pVaL0SpBNPX7SkCIyQpmq5BreiPow8DlEi1b8I1NmjNUuy/+keyBOvwVjf9C3zqbCJTaCeZgDlZcW6unEcwWjEiUtnn7Alj9uWQAZJ+A2Y/D3+9LgFTb60Ibt+PqCXE852mRV170mu87gwVqdpCI/zo9yi//BYUJho0/yCPjsNQQ2jDRN5e1uU6CtUJVRzi8QrIJMw4DimTO9n1O1q2OHCHltOCr0rINS8rGdtrkoQIRUUV/UxLOh3VMJSpRibOG/wSxsH37dl566SWOHz9Ow4YNufTSS7nuuuvQ6XS43W70ej0ej4c+ffqwaNEirFYZ8LRizf9pUiEUaMaW0yYphAqFU+0Do+DCouG6H+GLvuK4/P0BuOrz0CdPRSF49boyQqf36WKfD0g7AHvmyALh8EpfqiVIVsaQj8DkjdTJTQdnrjhTY0MsoKTdJw2VxnHZoOm2miP8yJwSFp0lRWbkZYPVS2AZwqDbfRKt8tdbEslyaDl8P1QWpBc/IQbvuYAlRoo4b/5RirfunQepe8Q5smsWOHLQAdlYma30Y+jNDxEWV0ESLBrmPgdH14hM2e3zwBwjhnaet2C6NdZL8nijP6NrBN+P0w5hkV55pGIidLVI6orsC2dr8Xk+SFoEHkNFnGtJ5xUsgjoQJitc/LRkyiz7UOSGPusFvZ8S6bxzKVlXEShOb/dsIOcULH7Lt5jVm6DDrdB2lEgBWON8WRX+WruavFgBqWotLDumvQ+ma12Js4eSHKIma1FHTTCnTbDISFO4tI/ME5DUFDqNgdWfwbS74OAomb/Ot0KOBrNErLa8uiDzQMk5xf18w0j1N/Rb74BWV/kkDDVCYc1XkvEA5SMUQLIVNv4gry96RK6rVntIKzYb7F74Z5Pkpsq27nx5r5ELxckGBQb2VEaEFg9Hrq+fBHN0FbLdSrHxCqLlvcSPooeeD8p9W/eNkHkbJsjDGi8SQs2GSvBIRTjrjRax2RKbSeTzzpmwZ76sb1QPoAqJoKp+r72f+0PRQbU2OOv15a4V1TiqVOe3nm0xGCtAmlP1wLKP4K835BpF14LhX4ptZzB423UAuWmySPS4BpNFHoEFswOvRbB5RsuACKzFUFZURlufGYoEjgRxMPuPi/73M5gtaAzzZX8bzJL50m602DOrxgvBMOcpIXlDJRiqtoSrvxJSMC/DRwxXbS2EV1h0xV0Pg0mkv5oMlNo9GyYKMajooMfDsiYMBa58WPymnDOqqC70fBSaD5HzVd0SZGUwSMaQFuARShsubnzUm7x+nsD7V8qa4HxYx1SiEpU4a7jgiYXdu3fTvXt3hgwZwiWXXMKCBQt4++23mTt3Lt988w16vZ78/PwC8sBqtRZkMvwnizWHimC62Coy0ZgjS09DDU+EIR/CL7fBrpkyKfZ+6pyfxj8KjwuOrJGshD1eB64/YutKcd9Gl0C1dmIYa2nyWtMsSxPV7pM9EyzRpRvHldE5hVFWnfCSIjPCvCnetjQKijVGVofLXxMd67VfSN2CXbOkfbQdJXJF4YkVdz7FQVEkUiapOcx/0Vsc/aB8F10TZ7OrGL26LXlKGEPLImMWCjZNkUhRgAFviYHssAupoKhCNmiOGFO4j5wJBm28ifA6OjOO+GSRtHuiLVZC6Qs5KdLfwhNK3va/tPg8F+fqX0BOi2ZT/ZzvikGyhzreBk0Hia7s0bVSi2fbNBj8ASQ1OzvH9m+FwyaRtMs/EYIavJIUD4i8oErRwADN6ZmbGlxSrNDCP8CJHR5fGaF2LlCSQ1RzOiv4ohVLctoU2bddHBMuF1z8GKTthb0LpJjzuu+h1XBpP1HFEL3/FAxmb3To1Tg3/kTGX5+QSBosfQPWfw2dbpPt/AmF8CSJFC0roaBBy1ao00MIT1u6SHKo+LJ5A51mgYUyTRavc9jsLUJbih2m3XstsOff3t/Opv3p30+CzeehRtUW6jcWH/GjKND7CakZsG+hyP7sXygkgxahbImDJgMqhmRQFGh/g5B+c54R56G79J9htEDt7lD/YqjbEyyxuDFzdOXG8h9LILJPirTmgSXyvskgqeGl92a/KYbCZJlGIGg1FUCy5RTkmpWU8VZcMebAWgxQusRO0P1XRltXGIobz0oqrl0ow8vmIxXAt5bSCOUmg2Hn75LFUFaCQfNPnCsoOqh3MdTtBae3idM+oXFovz21TWR0k3fI++ZXSvFzc4SQCVZvXZ7oanL9nHmi1hCqzR7sPpXUD/5L659KVKISRXBBEwuqqvL9999zySWXMGHCBAAeffRRvvnmGz777DOuvfZapkyZUkAqfPPNN/Tv359atc4gxe1CRGlFerRJJiIq+EQStOiSHaq1FQNTm/DjG0pq4H8BR9aIse2vIa8zSGRE48sgoTlEJorkTkxNidKJruZbuJg0oyvEids/dVGLiCvtt/81A6GiF7LFGs7eKBu3s7AkkobYOtDnWXHur/pMIrDXfy9Rlx1ughZXhVRY+YxRrY1Elf39vkTEtLgCanfD7YK8NScq/v9ObBYpGxBN0Hq9pL2DL/NA0QNOWZQGRsv4LzSMfpHUGtSAZ/CLjguhLzi8GROhFnz8Lyw+z8W5+heQ0xw5bj+vSVRVUBxyLyOqwtXfwbZfYclbcHw9fNlPSLkeD/1zdXLOF3hcsHkq/P2er6hftbbQ91mJyNOyC/xhtAiZoDhE8724qNDAzyuzFM49Cuki+2WPgNwLg6mw09lkpSA6obR7pTn/wr1tYORk2DUHVo8X6bzNP8mj0WXilK8oabyKgsGMu80oblnSgMvUv7jPOhMl9zT89bpvm/AkIRqaX1kyaV0SCmUrPOp15uQCijh7tGxef7vYaS9aKNNoFe3wkrIU/KHd+7Bi7PB/G86m/VnavFVojleDbwOFxziDqTAZ67BLxkn1NhL1fMUnQjJsmy6EnD3NRzJEVoNu93sdnuUoOquhZie46Q/JRFN0vuxuTVpPy97TvjNHlb9WQijYt0hsOluqXM/LXxe71pYun4Gcb2kyes4c77aW8knpmcIL12IIhUgNhspo67OP4sihQMmrUztArxci22jxraVAXhtM0O4GCcpa9x2s/cpHMKz4RGye5sPOj3pcGhQFqoRYz9Pjlvo/i9+SAs/WeOj/IjS/whu0lgHWGN/2Wtt12kJb85SEkvrBf2n9U4lKVKIILmhiQVEUjh07xsmTJws+s1qt3HrrrYSFhTF27FieeuopXn/9dZYvX85rr73GwoUL+fbbb9HrKyD9859GoHZzeVFakZ7yGFvapNP+RokS+/t9MUCjqkGtzmCK9E34xhANbVd+8M/9tXcNFjCHaEjrQmwDqifE/RnkOi55R7RQVY/oxje+VHQba3WFiCQxnnJTxDEQGSPRC9p1NvstPsviI/NPXQy1CNSFbiAEGpSFyDI/w7aCulEBzJHy0NLoAewZYhy7HOL8dOZD9fYw/CuJRJn/IhxbJ1HGK8dJNkHLqyVVNjpEIjRQg7o4JDUv/L7uRYXfO9yAl1gIiwVTBYyV9nSpq+DKk+KHvZ+U/qwtAnMzJZozPMHbN9LkvX+Un8shfcrl8GY2BBBFEQngsBZ2phWJiApCLmmf6fQ+wqIkFLcwKi9CWficT4uj4hDqMfrPW8HGIHsWmPzS0XV6QCfP5gjZvtNtMp4ufFlSzJe+Azv/gMEfyvwSDKGSDiFLK4V4vv6SdyVBk2wpD1RVMp/mvyi1jUDGjT5PQ+uRJd8bk16cQPle505MreB9QNuHonidQcVIjGn3tzQi99/QpgskRkpAqOdREeerjT05yUGKMPv3JSX470qCNm/5o2FfqNNNAiXWfS3SeXvmyKNBXykmW6d78HPzhDgfVaQ0mN6FUzEyQ7mEMbc/RdiOqRLRCiKb1makbxwIZQx35YMtRWpg5WVKNuimSZKtUKsLxDWA7FOynSVGnD8FfUf12QAOm8x9mlNZ6xOmCIrUDtIQeE0ret45l1CUIOfj114VpeLWMyDXKeQ1S0ljo981918HOPMBVdYuqiIkld4MNTpLkeJLXhG7btt02D5dHJ5znxaHZ8+HJPsg1AyG2CAymcGKi4e6TnH6bWeJK8G+K+G6uPKl7sOq8fI+oQlc850vCtscLlJRKjKf2jLkM/974srz6sJnyrrNZJFtygv/e6UoF/ba5lwiWL8sT5BWWbKCc9Ok/TjcEK34MiTBl9Ef7o3UVxSvRNINQuKt+QKyjsH0u0Wq7LLXoUZ7SGgU4gmHaP/l2X2vTZHF96OwmBD/1m88SD8kx39kpbyv2wuGfiRyhIqXwDaFyzXxL4hu9BJz5ggqRE7aH9r4/W+ehypRiUqcMS5YYkGrj9C+fXt27drFzp07adpUjC2LxcKIESPYvXs3ixYtIj09ne7du/P444/Tv3//C4NUqEgEc+6caeSG0SoGidMui89jG+HAIvjBm7GgN8kizBrnfQ54VG8r0Tn/JqQfksK4R1bL+9bXQP+XxWAILHgdnlCYAHDaxKEaiqEWrOBpeUiC/1p0zrkmUrSIen9pkcACdSarOPZvmy+SYRsmSrTb6e3iNF34MtToKARD8ytEE/rfBo9bjOSMQxBTR+qt+DuxnHZJYc9N80W2WaJ8fUJr54ER0jkpPumj2NqhtWeHzafFG1tTttf6pskaOin3X8HZzmoKds8sUYVlHjKOgsXrDPRfkFZtAcO/hn0LRBYpeRd8MwA6j5FoteIcdv8WnNgEKV75vILIVL/6Q9prjwvWfSsEC4AlFjreLrJRlrjQHNqB2T7+2uLaeOnfFqD0dvFfy4g7lyjNZjvT7Dz/+x8eD7U6SXR9z0ckMnTbNInO3rdQ7LTOd4jUSmTVijm/ioDBLBmAHW4qfdv8LPjrTTi2VsiDvEzR39acNsHQ7maJtHbaRHrSGlfUttAip115kmmQl1VZH0HDuXRQVXS2qiblY4nzvdeenXnSb+r3lkenMVK0dds0yD7uLTr7gWTZtbv+zDIY/gmk7oVf75D6eQDNhsFF/wcGK2QelX5gtEK09zrnpoLqN2/4177ITRNNe3Nk4WysstyjYPe2Itc2lZKxRVGeud1hE3sdSr8/4XFS2N4YJu1Jgy3NV+fEXzJVa0/NrhDCe8tUqXlyZLVktLYZCb2flsDG8xmqChsnityZtrbp9Rh0vDW4KkSwekqVZFolKlGJs4gLlljQ6iMMHDiQl19+mbfeeosPP/yQyEhxVkVFRfHQQw/xzjvvsHDhQoYPH86YMWP+yUM+f3G2jLCCRRWiZ/j7fXB0tSyy3A6J4skuQXKlYT/o+/z5l3IfDFt+lgVDfrYYyYPeFdknzalcpOB1gLFaFkMtaJGrSqO3VPxTkRaFNEX9I+L9HH6KIkW+mg6W6P6tv8DWXyVi5dhaecx9VjSdWw6HpkMkQvLfgCVviwPKEAbXThDHpz8C9XG16+VyFG7ngfevpDokxS0GtcWswejra8GcdJWLScE/QcY5bKDzyy4wGEUmKzLgGLQxr/U1ULcHzHtBJJJWfw77F8Gt88SZ92/DkVXi5Ny/qGy/05uhyx3i/M3PlgyE0jgFjaTWxqXAugv+C9XAtlBau7jQM+L+SZQWkR2KPVHSGKfdf1uq95EhcnUJjeDyN6DLXRINuuVnOLpGHiDR1XW6Sd2Bmp0hrv75n5lyaBlMvwcyDhezgSIOHmusRJ+aIoRMadRf5G4UnTi6/OVe/LMVdQaZ+/Ky5PlCqI/wb4LTBulHZB6B8s/nTptPtkqbe3JTxdHpsPs+C7Qx4+oJudDpdtg126sJfxz+fAKWfSASfv8GgkFVRQpt9uMi/WWJg34vQIM+8n1uii+rPNrvGhfUpghY54QnSHBHYC2/spJuZ5vAriTIfdDmDPBF2IcaEGeyytipUPr4F54QQCikSoCSM8+7TvDWEQiUutICtno9Bj0ekKyaTT/KY/vvUn+h2z3np3xjzmmY8RDs/lPe1+goWQrBspNA7kP6QZmToqsX9i9UohKVqMRZwgVLLGho0KABP/30EwMGDMBqtfLiiy+SkCBRpyaTiXbt2hEfH/8PH+V/CIHFBbXFFcCwT7wagF4ZhezjYpTkZQo7n3NaIsdsKVLseO8CebQcDn2egajqZ/fYVRVQyyCFgSwWZz8BW3+W9zU6wNCxkOTVyNeugRaRoyHQWC2rEyb7FAWp9hGlpJVW4p9FqEWh/VOFG17qIxn2LxKS4dhaiUo+uFRIhh4PiYPnfDYmd88RvXeQYs1VA0hCzbHpX9RSIxf8CZlgWTpa9HpZCowZrYUXs9pngf2ncjEpCLw2Z5tw0f7P4ScfZI6E8MiS/08fBpe9Kn1mzlMS6T/7cbhyfMUf49lCIKGgM4gDU9HJIlpRfK9VN6BIHRfVBfGNoP8LkioPkhFotJY+NjjtQkK4nKJRXdAngtRPCGwLpd3/SrL7n0Mo9kRgBopms2kEk0YoqN6+6Hb62kNsXamf1e0+kQba/xec3ArpB+SxcZJsF54kdaVqdZHn+AaEJNFgMJ9ZsdtQ4MqHRa9KgXNU6Tt9nobI6hJFbYmBPC9BF1Vd+kcwmKOKkgX+BdGNFom0PZta9/8F+M89ZQkQcdiKJ6dD/T+jNyDBmQPOCIjxkgrZx2XuKa5tgPw+2qv/33kMdL1LoqmXvieBVf4EQ4srpJ+58sR56rJLO3Xl+WRPXHlgDJc+GFevqHxZRcDjhqzjkLbf9zi1FQ7+Ld/X6gJDP/YShzq5VrYM8TgEKudo84C2rirJ9ioPEX22CWyT1UuaOMBk+2/LwGhzhia5m5sSup1stEpmMZSeoe+0ic1vtPjsGKddHOiF9mnxHZdmryT5SR5dMU5IvTlPSfbC4jek7/V7QfpaIOntcYv/wZYG9lTp4/ZUUVGo3+fs9DWAXbNg5qPy33qTZFd0u7d4uWaHDbJOSoCmM1c+Cz9DP5c/aQSVQVWVqEQlguKCJxYA+vTpw9SpUxkxYgTHjx9nxIgRtG7dmgkTJnD06FEaNGjwTx/iucH5EGVbqDaDxScFoxXnMlqlWDH4jO1AuQWnXWRT/noT9s6V6O3tv8Pg96HV1RV/zHlZkqq8+nMpOpbYWHTok5pDUjN5RCQV/o2qwo4/YN7zoueo6GWR3fVun/SR5lAOZvAGGsNldcLojWJYOL2GgGawVaLiUFx/Olv9zD9VWDHIwjI8ETrfKY8TG2HHDNGST90Li/4HK8dKMc2mg6DeReeXIXhsHfx2j7xue70QhIHITS0sZ6QtVJx2Wbj4F3PzT/vVIqmLky4qabHpX+SsuMVNZbR1cPwThIs1HoxBTBmtHxrDfFGRjS8Vp8uUUbDlJ1l49XwYqrY6N8daHrid4lzSCsLqDFLAvefDkOSNVvNfOPs7LZ02X/+J8avFUprzTSPqQBxuWraQf3ZCqGToP21zVKIoyjrGaf3aP3vFaYcwtwR7hMWK48K/feSmSvZZ9wfh4ich7aBkLpzaAie3yHyVexp2/C6PMkGRfh+eKLZXeCJEJMpzeBXf67j65XP02VJh6s1wfIO8b3eDEJP+tZGMFhlLrE4fyeGw+9msIRY6d9rFXnM7waiX65yb4iPFK/tNaCiuRlZp0NpsZBmudbAsh8AMSVu611mu+Pqawx587Az8rNPt0GaUjPl/+xEMfz4R+nlpB9NsiBQRTyomsrkkqCqc3imye6l7IXUPpO6DtAOicV/k7/Syxrno0cJFlo1WSKjvy+jwz+4AeV1a/YTyEtHl/V1Z5i6H3Zfl+l8mFgLt4vLaycXZkdo9cdrEwe60F76/BeNywP8Fy7DUUKM93PInrP0Wlr4l6/Vpd4jkULf7pN2f3g6ntklfcNkJCmO4ZEJ0uaviSOLkXfDX60IsgNTsufxNqW1UEpx2sERAfgYh1YQIpa1r98SeKdJ+//WgqkpUohJB8Z8gFgCGDBnC8uXLeeSRR3jyyScxGAwYjUZmz55NrVohFj/9t+NcOH1Km6AKGXne0BWjBdCD20+vNpiGM/gMhJg6MOIbOLoWlr4LB5fA7/fLNhVFLmSfgFWfiT51frbv8xOb5OEPa4KPZEhsIkXZNE3rqBrQ7yWo2UEKj1qiChs4wc71TKI5jRZxJJnCxdhVqHTwnA0U159C7We5qb4ixKFEk/inCqsULeaa0FgWdV3uFFJr2fsSVbb5R3kYLNCgNzQeAI0uLZxKfK5xYAn8dKO0y2rtJGrIllp0URa4WA/VUVPa9S+tfzltkH60eHmEymjr4DifCJeCfmj3FfIDWUj2fEjmje3T5dGgrywi6/SoOGkWpx1Sdsmi9PQOKZpsioBmQ6X/heKAyMuCX2+T/qLopNByyxEQV7dwdJz/wtm/L/hH9JUFWrFmc4RE2+ameucQS+n31n+uudAze5w24F8op6WhpPsTLFq4UIaK93VEku9e56YWzmrQyKnMY+KIrN0Zmg2W/ujIFcf94ZWSjXNkVWE7q0So3sjRFCmCWxxMEeKk7Xq3EBGhIPskTL5OnKiWOCEUmg31tfvAvqaqvmtRyIFl8T2KHFeAI9lhE1JBu96azN+F2m/OBso795RnLg/McnDaxCYzRYidlZsqhLYTec5NFYek5gwN5RgNZtFObzwQtkyBNV96pWEV+c5gFnk7Y5i3uHG473V+ljj/bSk+4q7ZEKl1kNS85P915dFB3URXdT3m8Y9D1tHg2+mNEF1bsiISGonMWZWW8ux2+DLPtTWH/3UuqKvgHR/8ayycL+0+1LmrvBkvFyKCZS0WOP3LsAYtri9r90RFovX95yOn3Sd/VGQu8/ZJZ5ZXZiu+8L4VBVpfDQ36wbqvpcDzgSXyCIawGJlPwqKlz6fvl/ohC16EzVNE6jjxDCSaM46IROyWn6TouqKDjrdJ3RVN4tZpK7wW8s/YNlokG9AYUXSdGAyhtHXtnmhr1fPBxq9EJSpx3uE/QywAtG/fnt9//520tDRycnKoWrVqgSzSfwIV7fQJZigEm6BKMyhMVpmsPH7yFsVFGATq0dfvBfV6woxHJKugIsiFlD2w8lMp8OR2yGfxjWRir9paHETpB+H0NkjZLQaFLcUnQ6PBEAYtr4bGl0uqvMsphr89q6i0S0UWVtK05sPjffu80B08/wSK60+l9TONSMo8DjrFSy6E4PQITBUO/A9NRiz9sGjKNx0kbXnH76Ldm31cnnfNFkO1djdJWQ9P9EZ/JniLo3v1SytCasLjAnuGr9hlXqZEAC14WfpWnZ4S3WZLD+78tMYXdowWVwcj8HP/vlQeUq1ysVg+nE+Ei9YPVVUWlf7ofBfUuUgWkLtn+wrNVm8P3e+DJgNDl7zzuEXe5fQOL4mwU57TD8iiMBA7fpdr1OgyaHEl1L84uH525lHJrEjeJdtf/RXU6OSTJooIcPIGktOBkmHaNQlEMBkx/2LNJquPaChuH4X25x85fB4RTWcDmmPs34pQ708wcirQOa5lnhojAoJBbOKEVAzihDFavNl3NqjWVuYhkL5iSxcHrMEiz7ZMMPo5T41hiMRjLuQki9Mz67hE+GeflAyI3BSZa3KTZb5Z9oFkm3a4GTrcVfJ5ZhwWUiHjkEgeXf0NxNYpbEflponcTHR175zi13eLI75Lgpb9odm/4QlgCjK/V6JkFEjqnIOaHYFZDrkp4sBTvNIkqlvaQExNX9alVkPDZCmdoHXYvFIvYRKI1O4GIch0Bm9dunyp3+GwSb+Krxe8zR3fIJJKu2dLsMmOP4ITDDmnRFZ2zxzM+xfzmsfr5M9CyIvEpkIeVGkuUdPWBIisJplBgc7dQgEebukvRi/RptkGJot8rjilXyt+UmHFtfvyBkeV93ehjo3lyXj5L6Isa9Di7EjtnkREFbWZtFpsCmKvaJ9pxZuddpmfbCmS7e0v7ahtG2OBXv8ngSaLXpX5JaGJtP+aHSC+oUjbKQb5H48L8nIkgn/XbFjylhDd3w7E0GokkWofspUQ5ZFceXBouWSda9m0AI0vgz7PQpUWhbf3J1LA77VSeA7SgtdKgz2z5HXo+WTbV6ISlThv8Z8iFkCKNkdF/YsjzM4EFT0xBDMUghljgdsVSFT4R+gHWZDlnBJ9Uv/tgqURKzoY/J4sTDdMKD+5cGQ1rPjEVxwJpEBSh1ulULTJ6jVIaoLOKPq6YZFi5GcdgRNbxKGUulccol3vlUWOPUMm9xpep7DB5JUgoLDjp7jCzaUhmGMIijpbtYigUItpVaJkFNefSo2G9zoRDGHgtlNQC6MsTgT///C4fZ/bMqQ/5OVAdC2Jzk5qBt0ekAjM/YvgwF+S1ntomTyCQhEZC41w8FuwGz0qL7vFcDf+/JWQIyAOXFeeOHXsXiJBk24KhqaD4NLXxdB35csCE4q251AlWyD4b8pDqlUuFv9ZBBJnga8xl74PrY/kJEtEpD0bLJFeJ4ZFFmpXfSa1e/7+QBZzx9fDz7fKArLrvVJ4MjdZnJY5p3zP/q9zk4MTCCCRbQkNIbYB1GgntW+2TxfSYfs0eZgjhXxufgXU6yVRrSc2w5TrxVFqTYAR3wpZqI3hEQGOqcB50Z+shpKJ68BtgxVr9icaAqERpdqc4m8DXOiL0WDR6P8mVOT9UQBHnkj6OOJ97UpF2riW2QDibC2ILvVeQ0UnWQ0Om7w2WiHSLJGpgdl1il5sMK2uljMP9AZvzYIwea96xFm6apzov6/8FPPar7nbczFTlcFFjz9lD0weKX06qgbcMkv6XmBUqOqS//KHvwRSISKvlPah9R0oXFwz2H2pzDo9fxB4f0xWyM+lkLQP+AhtlxPCouS5uKyFQDk7R44QbdHVAtq/Wewbpx08Hq8spt3XjvzbamJTuHYCnNoOS9/xZi/4EQyJzWDvPJ/kF9KNU4lhldKO/hdfjKlmO1nnGMK89mCct55ELmSekOMraLeWIFHkTl92gnbNjFYhGxzZco4x1Qt/FwzlCVor7nehINSx8UKf4yoKFRFk4H+tA20uoxVMXme7LV36m3/xZi2TPy8byPFmSPvZlPk5FEhmxtSCAW8LqW2w+EgMk4WCwtBuJ7hcEOYly1teBbU6w7IPYcdvGLb8yFfM4EtlFKg9gSD1EHJTYN8i2DNHnjXpYoBaXUVGsEY7mdNsqYX7NhTO2gjM2Na2sYTo77JEh7ZdJSpRiUqUgP8csVCJCkQwQyGYkRW4XaBer7ZNoMGhNwJun9FckmyMooMBb8rr0sgFVZVoH80xlHkUNv8ER1f7tmnQXyIXqrQUQ8IYVjgS1OMEa6y8D/emHsY1kEgHFJ8hkpcBbpfvmLWJX0t1d9qLpmU6bJLKnJsKsbVKNloduZBxzCfZUpwTVrsvZSmmVYmzA60NxNQ482wVp9cg1iRPrDHyufaceQIMBjGCo2tC9/uliGv6ITFmT2ySiE+tQHpephBhePuIPU0ICT/ogS7am/2hnrNViIqwKDBFQp1ucPETEpXjsvmiw3NTvNkCpsKLgmLP33v9CkmMhfuujeaIDSyeGcrxVvaPfw7+zgAo+trtLv63gXDaIe0QGE0yjodHyuJRdcmcYoqEy1+DHvfD6i9FNix1L8x8OPT/MISJE0eruxNfHyKqgcEKnnxxrJoixDHT82HYuxD2L4C980XeYstUeYTFCIm9a7a039h6MPIHmVsg+Dzpf838naBaZlxpUdT+jlBtLjFH+tUnUX1zVLB9BEqP/Zf6zoVwniU55wp9V4qT3GgVW0dBpI+0rLfwyKJt1mjxOYYyj8tvDGHiEFLdQhyoyOf+Wu0Fx+V1IOVly/yWny19xxzha39OGzS6RKSX9i+CJe+gnNrKFcxhoLoA3byV0OM+cSKd3Ao/jpL5LqYOXDFeijU7bIX/12iR/1ApfD1s3sK96OWgDd6lVWnEgn89lNKyFiuzTs9fGK2FI6iNVq/cj7ctx1SXOceEBGiUNI5qY3FOirQ1WzoYvWsQ//uurT/sGeAwSDCJ3kCBFIrHLe3SaBG5ouFfSuDTX29I8JRGMGio1hbq9ya/Zk9GTc0HRaFv/eqg965n8jJ9GRnOvP9v787Dm6ry/4G/b9t0SVdoEQQBBUFZBUYQiqAgm6iMG26AO+PuiOOOC4iOjujvq+My4zLiNorKoOK4jCKbioqiIGBZZbWotOxNS9Lm8/vj9qY3aZabNsm9N3m/nscHm9wk5ybn3HPu+ZxFLXNZ+aHrFl+HZ40a1Hdkq2XSFxSoBnb9DOS1rP9ugpRzvcD7yGD7XBh5HZlDf13WD24LrH+iCaAGLgfk2q3mt5wWjZdK0tpOgvpl9Pao7THfbIYqtSzlFKkBQKmrn/Gq1C8964BvjxRPdUO95BuQUaO2mf74FHDCVfDOuxGFuzfiL/IcvG+sAMb+TV0muWI9sOFTYMMn6lLO+tEaea2BTierG0d3GNTQ9+Cp8f8sb119wL244Xvwfc+BAxUNzKBjGSGTlZWVoaSkBB06cD9Qu2NggZquqSM6tEosXGWnjS7QbuD2/qJ20IRbNkYLLtQcAMreVYMLv/6IDI8H99StRkvsQdaz1eoIVa+n8evTM4Ejh6jBiMP7Aa2ObkivpnqP2gGblad22mhT+gG10e3IUQMi2myG/DbqNGW3bpkK36i9EFMUM+tvSrTNwPTfXaNGWHXDki15ERoP2ntH04DgKLnmCfb9aXlAyzu19XnDyPrlgdwu/+mwQP0IMqc6wiUjQx1Vk5nTcFMIqMs7DPiTGlRw7VZH2xUerpa57EI1n1dVqMuwVKwDPIeANHUUqae2Dk8s3QcA+PPITnB4a9TyVOdRpwnnHabOlsgpUvO9u0o9L210qdYoTqsfYZpdBGTWqWnIyFQ7k/SjN8PRGtFaOdK/RuuIScsIvYkzWVOwYLT+/9MMzFjQeGrUzhHxNgTgADVvKrrRlEUdgVEzgAGTgZVvqkvruSrUpcLyD1fLhSNXXf6h+GiguLP6WHaRuhZ7mtbpUl8WFUUdVV1XvwSeljdra4C2vdUgxKgHgC1fAuv+C6z/n1pmV/9HPa5tP+C8l9TNaA2dZ33HVFWles6+YHO4YIRudlC4uiTce2iv5U2pPYXrsPZ7zsD1OL8VcGAXkFOf90K11TKd6hrxrt0Ns9rcNfUzQGuBzGy17GidQ/olVvSzApxF6qbQblf97FZ9W6mmftkYAMeeDnQaBveP72LtR/9Ab6wFfvw3sPpN9blNC9TBHMVdgNMeV5d9ARoH/oOVA3c1ULOnoV7Lqj+HXIOzWWr2G9vviJ0/9qKNftaWANLyZqilmgL3icorUa/FQH0erPHP3w4ngPpAXM0BdWS11Af2fCOX0dA+zMhS65xTpgG9zwe+f03tTO04GOg+Tg2IAxCPF1AWqJ+RlgXkt6yfiVo/SwFQy6lS1HiGAuBfVl31r6mtVWcL6mcteGrU8ltXa2zmV+B9pNHlKlMp0G0HgfVNpL/DCVwOSOrUPJGZE3pPndzihvaRq7LhtbWehjZT4eFA1R5182Ntn0IlvXFZBhrutdK1+soJtD8B7onz8OqTMzBJ5iL7l2XAv0aq90B7t/mnp2UndUnYY8ao+82Jt+F9tM9x7QUO/A4UtFHvdVy71XrNoa0Cofsecksa6gr9LFQgTBuOZYTMUVJSAqfTiYkTJ8LpdKKsrIzBBZtjYCGV6Ts9jWwkKUHWQWhKx7ORSixwORNHNrBvN1BYiIadXANk1Hc2jZimTqlf/xGw7DlkADhRO2a/7vicFuoGR/lt1GUxjr9C7SjSOvyDrbEtUBvZdR614VJ7SH1Q67zUvg/9BkcOp9rhGsg3RTHgfBxOdaZCqM2r9LMZ9Eu2hPoN9b9buO8+2A2P33rZBvJIMjK6Zm+w8hGskazlK091w8h8bXq8fnSmSOTRpNqmgdq0X22d6sxD6udkFTR0EmqdI/r1z/MOazxS7NBB9f3y26jBgeLOakM3uwVQW4O6jAJ8+vX3AIDr/zASjswMNT8eOqB2kuS0aMiXTvinUftOMp3qOaP+cberofxm5RvPa+GWSjLaEZOINZmDCZZfgjErfWZ9LhD85k3//27dfjyuSkDJD31dy23Z0NGRlauWi8w89T99+dLyY0FbdQP0E29SR2r6AgYudVM9Tw1Q2M4/WKXNBDv4mxogc2Sry6ikO+pn6QQsUaek1S9nlKvusdB+AHDircAv36rLVeS0AE6+Cyg4PPJ3pV8OLC0DUNz1AUWtwyXM76jvOPVtxpsTUKaCvD6w7RBYBvWzhQD/65eZ+SrWFMW652M0XeGuk37PGXi/Wo/a+eHrgA/zmrQMtb7z1NR3hmqfleEfhE9LV9tZ4lX/VdLUf7W1s/f/qg468dT47wukLQmYWz9zIrsQ3h5n49ZPWqGnlOGRDkuQvmWxujQZALTtC4x7CmhxpP/yGb6yEax9VKXOzkjLUAMbWrsvmiX0tHrRUx28rteXtVQOkDenHZYIgfcLWh1j+PVKw79aWczLUdtWe7ardUGjfa+U+qB1XsOeatoAJiWt4V4l3aEuT6l1uLbqAQy9TR0s4pX6Nl79e6fplphp1UUtj3u2AWmZANIa8rhWX2qDRDR+ZVUb7V0fKNTS5XEBEHWGReER0X1PmlgtV2nV67ddRFsuA+ubSH+H/Nw09TpdVaF2smc6GwYjam2sYDJzgRZHNAzs0gYfFR2hKz+56r2Tu8T/MXeVOuhKvzyz26WWM+0eJ63+c3NbYU7aGVgsg/By+zlI37pEDSqkZwJH9Ac6DAaOHqHObtXOW3s/fXsUUMtSVv3Mhcy8hqC59rcWXNDXU1rbbv+v6n1mVl587+Fjfd1luUwJHTp0QFlZGT7//HNMnDgRFRUVDCzYHAMLqSwWncbae1RVwLe+spFGXlWFbmkjAzdLmU6g+MjQG8r6LXuSBox+COhYCuxai1pnK/zzq72oVFrgjomjkZXtVDtMHU61kVxVWT+yza2+PnBTJ+08tY5ZT546ikE/ukg73mjkP1LjKdT7BM5myGsV38YCR8k1j5FOG30QKlCk0aTpmf7L/Hiqgdp96khrJQMo6dzwOcHeU9s/QSs/nvr31EaWOVs27H0A1Of3IMvQaJ2Saenq66t2N4wma3FE6E5i7e94jJbhKJzk4rfvgu6mK9LottySxnVMuM66cOubA2onjX7qubtKfU5B/ajpOrXs5RY3XJvD7Rui/e3IUZfSO/a06K7pfsup6ILbRjpc/DZ9DhIg0NIdWK9HGlWoPV+9T127l8u3WFe462S019CcgoZ2lNHPbqG/iazw38QY8C9f2tIr+iVjtM2TC9sGT4/f56n11GqlGzznTEb67z8AXz+jdgid/njkchdYjn2zfBB62cpwgwP07YNQZYpLIMVfc2fm+u0bl9s4nxgRrF0GqLO1tbXdA+UWAx5nQ0envnOycqO6ZGBefTmSOrVdl1vccN/j2qMuqaTfs8BV1fhz8koa3l87NtSyqvo8rR0frP7IKQTSipseLDN6beKsa2sJNmgk3N9G3kurM4qCdEgG+/2112UGPKeV3aqK4G2iYEvXagPDApdbrd9nZZdSAs+JdyC970Xq452GNczECxZ8D3buucX+KxwELncUrO2W6awPulSrZT8weBftklMsQxQnHTp0QLdu3YI/uXd7w2bs4TiL1WUtyXQMLKSyWHUaV+8DFKnvkDR481NVqc4qqNodvtNHP3JN69gJtvmwryOjfq11RwZQej0AoPbgAbz/zRcAAGlxFOCoH4Gq33DMUw149qvT8rW1C7WKv6oSqPi5fv3SPP/KXT/bI5rKN1LjKdR7hZvNEElTGgeRNs+l8ML9zka+WyOBCV/jsv4GzuNSy5UD9cui1I+EzMj078TIDFJ+BOq+BwL41sN11JcB90G1kvfqllTa9wtQ2Krhs6tQ/9nZDdONowk66m/IgcY356E6Ou2MjXZj/DrYdIGFaPfPaPReBjoDffXLbuBQNZDlrF+fV+tcrL+xdBYH71DyVKszeqp2q4Fr7TH9cb56pNr/70BVFcD+HUB6jjrKLvAm02jdotFep7+Z1qc7UudRsPfXZimFC5qS/RjpJFfc/nlGW1NboHZQhsqb+nyTpwsI6MuXvjPHkdNQLynpjfNYpPbtvnLgiOOBi970n/Xj61yqVJc40mab+jbM1TqWchvKTrgg3sEKwH1AF2wMcWyo9HJwR9NEU682N3ijvV7LF4H5xHdcmPZL4O/srlI7VKp3A3U1QItOjT9Xm7WjpcFV2bA3ibdOXcolLQModDYshVlVqQYqtAADUP9d1S9hJLr2nX42YKT0asLNNoz02nh0djIwZz4tOByPNq4+LwXLE1UV6izsrLzGgYegg0jClF19gFtP289KG4DoyFE79H1pzAGc3dSZroB/YDzwehDsHAIHx+jvHbXrhNbe8s22q399fht1gJcWaAhs0xopF/EoQ7zvoUj2bgeeHuA/kCsUhxO4bhmDCxbAwEIq0yqe5k45yylUR6lpswmCdfwHyi1WR+Kk1x8PhK/wfB2culEygP/ImIP171PrVjcM1FTvbvh/by2AdP+1f32dopXqZstIU5dE0ir8qt1AmlLfIM9Wb0i1zXH1jYJYVr7h3qupvxsb2PZjaDRpwBRUrXPTU6M2bvX7Fmh5NbARC+35DHX9znQH/NbDzcxRpwCnZ6iNaE1VBeDM879BzClo2IxSC2roy2y4TiatUe+7ofbWj5arbyy7Khs2DcwtSY6GKculMfobSH2WdxYDcKvTzIPlq3CB6lCddYG/iXZ8dktAKhuWLtM6F/Ud+9rMH0B3k5fTMIvHtwFfkJvXSB1S2vvU7AfSXPWdQyVoFITwuNT6UIH/6Ff9uVXvV9Oz7xcAotZ5+jRr6Q62f0K465J+JlUqL92SjIy0S/xmFkG93u/doS51lxnkGO19tHxT5/Zv3+0rVwPVWqeMngJ1mYiMrMZp0r+v/m+NVhb1HcH6QLz7oNo5q99zxMhI0WBpBNT6TOr8O7hCjVLXsPOl6aKpV5sTvNECZ3WH1OUiUX8fEmyfqFCBWqDxNdVTrXaIwqsu2RopbZ5q+PYrceSp+alW20PIpQah9+4APAcBV7r/vh6uPVCn3WQARmcDRjubyYh4dHYyMGe+eLZx9fkw2Cwara0YbqUe/YwjtwvYv1Ndekx/aQ8McGtBBI+rYWZc4Gw6TUFbIL0+AYF7qQSmN/B+yW+AS33AW4H/wJZD9eVeP9BR+xtQA9+h2rQRryshAv5GharDeN9Dkbgq1fxz9vNASdfQx1WsB+ZOVo9nYMF0DCxQ82iVU15B447/sIGF+g4Hb63aUZJTYKzCCzV1XNuwKHBkG+DfoNAa+/qRBdqxmTmAFKkjy/Q3BdoMhbzWamet1KgNeHeN8XQHCrz5jrbjqynYwE4NmU610emtVTtp0jJC71uglSGtE7CqQg0q1Hngt6Gew6kuNZGRDTiqAGxWH0/TjYLTb6qpn5ofWGa1RrA7yI2p9vpaN+D1qiP19OVXf5MQrgEeyModNCyXxuhvIPV7LAD1+epA/f8buIGJ1CkSbIacVsc4cho2yAT8OxerKnSdO7qbvMxcdaZC4Gwc7TXaTIHAjkuN/oY1tyVQ51JnLITaUFfrGA12rtq55bZUZz5oZTfDGWTT5ibMWGN+Ti5++2kY+G0D85tA7fhXdO2yYGVSe+9ad8Nz2qAO7XnAvyw4ixtGaAdLU7jOCyW9ofxo5U6bbaEAyMxTgwDOYv9ybKQ8BC615nCqday3zr8+izbAScZFcx1qTie526UGjNIc9bM064NjQTvjQwRqgy7XkqPmP9+msRE2OHbkwLfGvDYzBlDrAaX+M6rrN3tOS1f/1WZ419ao+/I4sgElq+E9mzIb0IhQ+Tqa38zosfEIgFB0EtUmCPY5eSVqmzDcZ2v5URuQFWzpscC2mTYLteaAOtBQm8Xg27h8V8NrM3LUuiVwyTLt+MwQZSCwnLgq1TZbRnZD+1K7TggaXyMC877+uzFaLvQDRZozm6s5ZZ2ST8ASRzl716NvmzTk7F0PlNfvU1KxXv23pCvQtk/i00hNwsACNU+wTouDFWol6olwM6Tv4ND+DvaeQOMbNY1fRZmj66ypbKjE9SNznC3VUdnavgr6St1ZXP/ZOf6VnX7KsNvVMGJAf0McbcdlYKdosA7SWI/2ZAM7dWhlIdSeJJrAxl2ms2ETLre2hrWuXBY5AWctfIGFlp0B917/PR30s4G01+lHqSr1N7BBA4faevNVahnTL6cCNNwwBwbkInXAWLmDhuWy+TKd6o2doHG+ijRVPphgM+S0x1p0CPO6+s4dfeAhaHrr83lVhf8SSaE6LgP3QvCrA4Os553pbEhHuNkGbpcawFPSGj4/WoHfKfNzcgk1qt5oWQq2PnuwTgUt3+jXvQbUGXQZ2eGD1wCCbq4cdpBKsGXI6gMb+jZl0IB8hDX0g31n4c45FHa+NF2irkOZTiAz3/+eQAuOBc48C3V9DxpoizKoqw+8afT3NG6XupdIrUfdV6G2GoCoQZCCw+vfI8d/j4VYfYeB14pQ+Tqaz2M9Yx+ZudH/Vk0ZDNTUPKHlR0eO2h+h38/Ad4xWHnUzD6p2A9n5DXlaey8gIICco14jgn1uYBkPFwzQNkLXguJaPeTUljSrVlcyiPUMI22pp6aIRVmn5BJkiaNuAL6/Kg9YchWwRHesw9mQv8kWGFig2NIqWCOdeI2m/rpCL6NkZNSpdpMZGDTIDNHBE1hZBo4kCKTNctCPBgIAKMZnaug/K9iMBSt3gJL9uF3qCLrAG1wgxCg5Z0MnjrbZX9iOjxygdq86useRHXw0XmBagMgdJaFuqgMfD9UAb/Q6dtAkNYcz+MZ92nPhpsqHE22+CdcZFDhNXvu31uO/LAvQuONS+y9wY8HA99WvrxsuAKLxrfkexSajgVhnJbdQZUCbJVS1G2hxROjfPlgHQrhOBUdAfaRtNOubsRPY/gpDH9Tesw2o9TY8lxFkVpA2MhMI3jGsPzbc800JIoRLP8VWLGcw6q+1+j0UgPDBZb1YtU8CN5f1u6ep7+nMy6kPmtcv6acELA0LXWDB4wIQpEM0WoF1RHPztZVnoFJsxKpdYeR99PkxcOBGKJnOxrNQ9ZxRdsSH22RaE9he09qz+uU1I31fTSk7OWGWQIr0fqzDKFCQJY7K1q7FhAkT8O9//xvdjj224Vhuymw7DCxQ7DW1kRyuARDVtOYQy0kAakepx63eDEttfcPZYDS0qlJdn9SR1zgd0Z5zYGVrtIOUrMtKNzvaDaa2t0LQshCivHnqA2gKjDWOtdEEwabi6mllJHBzT6PCbXwYqfHKxm1qa7SXSBOv083hyFEb1LVuNT1aJ2awm9NQHZdBgwhh6rtIggVCIo3GbvQeDNoltVBlINPZsG9ILINKoZaFCZfHtUEfoepebWkwjy6w0GgEZZClLkJ9nrZxdKiZuaxvrC1ewVDt+hzt/jLh8ks01+Nw5aTRQKwc9X4ocOBVqPuS5ghWRzSnvaz9fgcrGoInLG/JJVbtili8j18Z1Jeh+v/3VDd07vtm0kXZHjNyTWo0sCpInRXpPKO99kX6/jiwhJpKt8RR9a9e/PCrF9VFXbnskc0xsECx19zpiMEqsGjeM9zMg9pqdROl2hp1I9pwGzoFUgL+bWr6wuENqX1ZqYGlNTiz8qMfxe/WNnxON97wNBTwczaMHm1KQz/cxodE4Whl08wNhfWbxNa6GwJ+wTr3Q3UQBXu8KfsghBNpNHYg1lmpyeFUZyrEOqgUdFmYCHVMpLpBWxoszdv4Od8xAeUoXN7Xl2XWR/YTr2Boc4K8oURzPTbaFgNCX7f1aY/VeQT7rOa0l5s7SIWsz0r31IEzgYI9p+1XYqRzP5imXJOiqbOa+jmRvj8OLCGr0PZkCIczIOKOgQWyhsDRK6FGszR3VLi2iVJhW/XvaBrO2nqlgP8eDkRAbBtY7qqm5XNt5KYjp/FeB4FCjkQNMZINUMuf62Doz4wmwBCtUBsfEkVi1s1P4GhTLQ/nhtpMXXe8fs+gaDePDRRNvRmPzjFKTvpgcahlLKMVrqyGqmsi1Q3acjXuWgA/NS99Rj+zucKVWb8NtWMYVEwV8QqGxjrICzT9ehyqrHhcDe07Mzvjm1Mna+l2u9Q9IrLrl2qx0qxhspdwM4P0ZTCwXPnadC0bjm303vUrJYS6R0pkvo31tY8DS8hsWt/c3MmRj3U4geuWMbgQRwwsJDMl2NB6iwocvRJqNIv2eFWF+rhfRRzkfD0uwHWg4e9MJ5BZ0PgYbZkM7ZhgwQ39hpvRjOiMFzE43cJO+cDOjN5UGvndwo3mChzx7xeQi3K0cTCZeep/wT7PU6PuvaBx7QbkUOh9HIwy0rDWvt9Y52ezylGqlctYfs/6YzzVgGuPOvssryR4/kn0zY+WnwP3ONHyr9vVcA6hyi8Qu3ommtGhTe0cS7X8TA0i5a+oAluBx+jyVVWluqRRZl7jkZr6DZjj2Umjf//cktjne21QgXbtCPad6r9vBhb8mXUdinU7Qnu/iNfjEO8X2BZUFDXv7i3X7elT07icuAMHjkS5NF6j5IVIX+B5Gfn+9GVPKx9pGQ3vw3JhXWaXy0j1Qrh7J31eDbz/D8zH7iq1nkJWw2PaSgn699bSowUmQtWf4ZaADSWWdSDbdWR1Re3VYIGrMvxxFevV4IOrkoGFOGJggawhcPSK9jfgPxJOe7zW4BTYgxVA1b7wn601Rqv3ATmFkYMboUbaNLcy52gb0kQatanlS8A/j2Y61Twfau3npqiqAA4dBLLy1I4Ujy6w4K0F0hB6Hwej9GvmKgjfSUzJIxbXPI9L3UQWANwmXDuDnYOWn7U9TvTlOFL5DRY0jIXqffVlNEYjy4k0TV2HOdryr1+OMtRrjQbRXJXA3n3qSNNolkeL95KH4a4dGi4/kVqC5fVIZSdYHnG71KBCrQfITA+ej2urAz5b1+HqqVb3VYm2zMSKX+AgyPmxXFAoka7bRvNOpBlEWnmp090nOZwADgVvB2rvpX9Pd5VaPwnUeiA9IMAcaYUHKy3LS5QIRe0ZLLAIBhYotmLVOa6NWtNGB2gVpPZfpstYI8BIsF1rUGhLxwQGNwI/Qz+iLnAETXMqczYGSBM4atNv6YMwnY9a52Qs8pFv1HX9jabUv78zs+GYtAzAWdT80WH6NXNDdRJz+YfkE4trnsMJIF/Nn7HqUDC6DEmomzgtP2cXNH59pPKrPz7Ud9KUejanUA0uhBoFTamrue02fUBN/7cm5H4+UZb/3BL/AFykgR/hzqtqD5Dmru8ojaKTNN6dl+GuHRptBi2lhmB5/WBFw+ydFh0avyZYmdTybH6YwHVGkA7T6v1qMKFqN1BXE32ZiRV92Qs2kyMeS1FRcoh03Ta6rF+kPObIUWcs1Hr9H8vMD56eYPtsearVwVyAWr7DDU4J1gY1UkdxICMRxQEDCxRbTe0oinZ2gNGlLXJLoE5J3B76mFDvZeQzIo2giUaoWRqB2CBIPfp8lhswkt9oJ46ekTykfaa2Fm+w93MWAzhUvzRZE6fKa+egNeqB4J3EnOaefGLRSefIUfcsiKXA+ihcADnYOYSrO4wGD6JJXyShgufBsH5JPVp+CrrEpE64vBEuT4YqD9GW/8D3idQ2DByYopfbAnDva1gb26h4L6uW6GXbyPqClRMl4F89rZx6XP6jnYPlrcBgYLCymFO/fKwWXIi2zMQKA2rUVEavq80d7JKZq842OHQg9DGR2liOHHWGuEBtszUKoAVcDwL/jrbvgvUNxcre7YCrEkptHY6WzQAA5deVQEZ6wzFGNlkm22JggWKrqR1FzQ0gBONbwzCOlaY+3c29IQw1SyMQGwSpJ5pyFatGpZGRk0DwtUmbui6vwwkUBRl9p08Pp7knD6t2ogXmtYMVgPuAOuosryT6m7h4py+SaNLI+iX1GF1iMlzeaMr1OZp8GdgZY+S14dLkLAaKWhtPK5FZguV1/ewdTeDePoLQy2kBxq71+mVaMnPNmalAlChGZ7yFE2m7kEjlLuKsiCCDU6Jtq/F+imJt73bg6QGAx4UsAE9rj78Y5FiHs35gIiUbBhYotoxWcE25SYyWVnnr1zpsrkSkO1KFzwZB6ol1PjOSh4x+ZrA1R4MFG8JtOm2Elh5uJkbNFXHEWMDj+tGhsQh2x2qpwHhg/ZJ6tPwUaYnJcHkjUp5sbt5vSsCrKeWkKZtlEiVaqNkH+v058iIMCjFyrQ/XyZmI2W2cQUfNEW3+MTrjLZzcYkAJs1JCotpY4c7dqoN6yL5clWqeO/t5HCrqjJtf+goA8P8uHYQs/YwFoH5gB/dESEYMLJA5EjEqUqu807Ji956JSHekCp8NAmquWOahYDeewYIN+rIDcFQ0mSfa63iw0aGJ+FwzsH5JXfFsezR7iYlEdcZUW7+MEgVjdJapprnX+kTUZ3aoM8m6mpN/mrwCQy7UJZhDSFQbi2WHzFDSFVLSExuVXwEA0uY4INNC3c1GlmJi4KPJLPRLU0ppSoXd1JEH7trYvaeVRnNyJA9FEu884nYBmQWNHw+6sV5A2bFKOQJYllJNPJcSaurnGs2DZuVVlhFqjua2nUKVQSP5UjsmXGePnrZZLZGdNKWeiva6rp/Rk+lUR3XXutXZTvGoF6x0z0X205z8E6k8NXXJ16a+n537K4jM5ixWy83cyZGPdTiB65YxuNAEDCyQObRKMXDjsHDiEX2P9j2tNJqToxEoEqN5pKmdhrXVAIIEFoIJti6oVbAspRazruPhPtdoHtSOi7TRbqyxjFBzxKvMGcmX0SyL6XEBUqv+S5Tsor2uazN6tPpHoO7nEK96wUr3XGQ/8cw/wZZ8jef7BSurXO6IyJii9mqwwFUZ/riK9WrwwVXJwEITMLBA5om20xMIvxFZqNe6DoR+Pt4R/XiO8uRoBPuL9yhgo3mkqZ2GGfqljmI8egdI3ChpliVqrqoKoGq3OtK5KRtcGs2D2ijRqj1ATv1svETcPLKMUDSsdO0OtiymqxJAXuO6SgL+DUV/frGq78j+4p3vm/L+4V4T9ey9+mUutY3etf0cWC+Quyq1romBS77q74GMzo4LFG62XLCyygEfRMYVtWewIM4YWCDjYr1pqr6SDPfeWsWZlhF9h432Wj39Z4XbmEwi3VkGeb9Qn+92xb6hFS7tZF36/BKL/BEun+pHrITLp0bLYuD76Bu4sR69AySm0awoLEuJEK9NtxUlsRt6hypvVZVAXY36b1MCC5FGl2nnmJmrloecWqDWA+QHlNlY1FvBsIwkp3iVnUh1W6zyqZF8qR2jXxYzVF2VVwK4ndEF42NZLhJ5LUtlsb5OasfFs80f+P4OA+21YK/Ri3ZUs1aWtI3eswvCn6fR75nsSf/7hstnyXJd059HVp76n8bvHijb/zVGzz+noPHnaCItMWuH7zhe7VOKu23btqGsrMzsZJDFMbBA5jHaUWFkRE2oETmZTsBjYPp7vHCUJ4VjlfwRi07Dpp5LLEfTEZklt7g+qFAc+phYjWbVykN+iowMJPsxeu02a++OUKOsjXa0sm6iYOKdL7T3B9SZa0ZGh8cjTQw0UyArXxMTUc809/yb8nqWQ0qAbdu2oVu3bnC5XHA6nSgpacLgKUoJDCyQ9Rm50Qs1UsLhBJyZ8U1fOKz0KZxkyh9NXc8zlqPpiMySWxJ5pkKsZuAk03WDkpPRPGrWUg7OYsDRjFsgrW7iyErSi/e1Wct3VRXGZ0Zk5rIdRfFn5fZ6IuoZfdl314Y/NtLriSykoqICLpcLr732GoYMGYIOHTrE5XO0GRElJSVx+wyKLwYWKDnEeqSEfq1IqzaUiKykqSOCrDzKiSiWtP0Rat3qUhKsWyjVhbv+cx8DouDs3G4ya5YSpa7mlBfWQ5TiHK7f0LdNGvodno4OGbuB8t2ND6pY3+T3LykpgdPpxMSJEwEATqcTZWVlDC7YEAMLlBxiPVKCGyIRRaepZcbKo5yIYknL66xbiFThrv/xXq+eyK7sPGOG91eUaM25z2A9RKls73Z0X3gpvr8qD1hyFbAkzLEOpzobNEodOnRAWVkZKioqUFZWhokTJ6KiooKBBRtiYIEoGP06pnu3AQJ1Uz82gomCMzry1GgZ4qg2SkbRjpyLZrQcZ9pRMon3qOxgdQzrndTA3zk4T3X8P8POsy3IvjwudcZotPfzzK+UylyVSK+rwYS5Ltz9+KvoduyxoY91FgNF7Zu0FFiHDh0YSEgCDCwQBaOtSVpVARw6oD7m5g0IUUhGR54aLUMc1UbJKNqRc9GMlmOZoWTiiPPSE8HKC8tQauDvHJzHFf/P4CxVMoPb1bT7eeZXIpTt8qK6qCvQto/ZSSELSzM7AUSWlukEsvKBzHyOViBqqkwnkJYRXRlqymuIkk005YBlhsi4YOWFZSg18HcOjh2olKx4P09EFFecsUDWZ+aUZYcTKOLULLIBK0/tb8qIH44SIopuLW1tpl043IiQSBWsjgn2mJXrVmoati+Cc+SY87ksYxRvvJ+3JpZ9siIjm1FrSz+RDwMLYXi9XqSlcVKH6ThlmSgylhMiioQbERJFh3UrUXyxjBGlJpZ9shJnsZoP506OfKzDCVy3jMEFHQYW6m3evBmfffYZDh48iO7du2PUqFFIS0uDiEAxMlKw3qFDh3Do0CHf3/v3749HcpODiLHj9BsnRfFb+OhfoyjGP9eocO/H0aFNwnIUBS1/hysnsdzUVZ/fFSVymTRa3ppStikslqM4MJpPY53vRWIzsiteGxEmcTlnOULsf1+z84GRuksTrm61evvPQuXSUuXI7PxnJfp8iszYvncsyhj5YTmKA7POI9bXZ6P3emadb7DPZdknKylqrwYLXJXhj6tYrwYfXJUMLOgwsABg9erVOOmkk9C3b1+UlZWhqKgIrVu3xvvvv4/c3NyoggsPPfQQpk+fHucUp5jMXPt2ynN0aJOwHDVBuHLCESEpieUoycSiHEeztBIBYDlKeU1tg7L954flyKL86pUYBxaMsvN9XoKxHFFIdrzXY9mnIMrKylBSUoIOHUxYvqyoPYMFTZTy6/y4XC5cffXVOP/88zF//nysWbMGjz32GHbt2oUTTjgBv/32GxRFgdfrNfR+d955J/bt2+f7b/v27XE+A7I0bhDXJCxHMcZ8mJJYjpIMy7EpWI6oSVhe/bAcWRTzqa2wHFFILMsUjb3bgfIV4f8zstdADJWUlMDpdGLixIno1q0btm3bltDPp+ZJ+RkLhw4dwv79+zFy5EgAQFFREUaPHo3OnTvjggsuwJgxY/DDDz8YXhYpKysLWVlZiUh68kjmjXu4QVyTsBzFWLBNXZO53BEAlqOkE219wjIeEyxHFFK4Msb2nx+WI4vS51N3bcPjrkpAyWcethiWo2ZK5nYR6xwyau924OkBanmIoC49GxWuAwlIFNChQweUlZXh888/x8SJE1FRUWHOrAVqkpQPLBQUFMDr9WLhwoU466yzAACKoqBLly6YNWsWxo8fj+uvvx5PPfVUVHstUBSsPnUvmRshlLqaUu48LiBBjQsiaiYr1K2sPymZWaGMNYcV9oEga/LWAgcr6vMGr9+UJPTXbO1vXv8o1bgq1fr/7OeBkq5hD/3p553Yfu/YBCVMDS5069YtYZ9HsZPSgQURQXp6OsaPH4///e9/+PDDDzF2bEPB6dWrFy688EIsWLAALpcLTicbVXERr80kQ4m2o8PuN45EwTSl3GlloanYyUipyoy8n+i6NRjWn8mF13B/VihjzcF9IKzPrDKXlgGgjtdvSi76a7ZVr3+sZylRSroCbfuEPcTzq7Hl4FOSkaWinMUps2dDSgcWtBkIkyZNwscff4ynn34aTqcTJ598su/57t2747XXXkNVVRUDC/GS6Kl70XZ02P3GkSiYppS7TCfgqWv6Z7KTkVKVGXnfCtPiWX8mF17D/VmhjDUHy6f1mVXmnMWA4mb+oOQSeM22Yv5mPUtkbc5itWzOnRz5WIcTuG5ZSgQXUjqwAKizFjp16oTnnnsOF110ER555BFs2bIFl156KQ4dOoRly5ahbdu2yMnJMTupFCvR3kjZ/caRKFYcTsCZ2fTXsxODUlWq5n3Wn8klVfNxstLKJ5d6tS4zyxyv35TMrHr9Yz1LZG1F7dVggasy/HEV69Xgg6uSgYVkUltbCxGBw+HwPeb1epGWlgav14tevXrhzTffxN13340HH3wQd999N44++mj8+OOPWLBgAfLy8kxMPcUUG8pE5mDZo1TFvE/JgPmYKLFY5ohSC8s8kfUVtU+JYEE0UiKw8NNPP2H69OkoLy/H0UcfjVGjRuHCCy9EWloa6urqkJ6eDq/Xi+7du+O5557Dli1b8NFHH+GII47AkCFDcPTRR5t9CkRERERERERERERxsW3bNlRUVKCsrMzspJBNJH1gYf369SgtLcUZZ5yBkSNH4rPPPsPMmTPxySefYNasWUhPT4fb7UZmprq8R0lJCUpKSnD88cebnHIbEzF2nFlTD2P9uUbPlygeEl3e9O8jEvnzrTbFmCgRjOb7WNcfyVKvkrWkWn42iukjIPbtsFj/bk35XEUJ/Tqr3+cRAebd7+uPC3efZFY5J4pg27Zt6NatG1wuFwDA6XSipKTE5FSR1SV1YEFE8Morr2DkyJF49dVXAQC33HILZs2ahWeffRbnn38+3nzzTV9QYdasWRgxYgTat+e0FiIiIiIiIiIiIrK4vduNrf0f7umKCrhcLrz22mvo1q0bSkpK0KFDhxgm0hhttoRZn0/RSerAgqIo+OWXX/Drr7/6HnM6nbj88suRnZ2Np59+GnfeeSceeughLF26FH/961+xYMECvPTSS0hPTzcx5URERERERERERERh7N0OPD0A8LgiH+twAs7isId069YN/fr1i1HijCspKYHT6cTEiRMBqP23ZWVlDC5YXNIGFkQEiqKgX79+WLduHdauXYtjjz0WAJCTk4Px48dj/fr1WLhwIfbs2YPS0lLcdtttGDFiBIMKFHseF+B2AZlOIDPX7NQQxZY+f3PDMaLYYvkiu2BeJQqO9wFEqYt1IyWCq1LNa2c/D5R0DX+ss9iymw936NABZWVlvj0eJk6ciIqKCvsGFiLMEAFg6d/DqKQNLCj168yNHTsW999/Px555BE88cQTyM/PBwAUFBTgpptuwqOPPooFCxbgnHPOweTJk81MMiUztwvw1tY3KnhDQUlGn7/ZYCaKLZYvsgvmVaLgeB9AlLpYN1IilXQF2vYxOxXN0qFDB79AQllZmf2WRHIWq+V9roE+ZocTuG6ZrYMLSRtY0HTu3BlvvfUWTj31VDidTkybNs23+UhmZib69u2L4uLw04CImi3T2TBSgSjZMH8TxQ/LF9kF8ypRcCwbRKmL5Z+oSfTLItluSaSi9mqwwMieF3Mnq8cxsGBtw4YNw9tvv43x48ejvLwc48ePR+/evfHqq69ix44d6Ny5s9lJpGTn4NRnSmIOTu0lihuWL7IL5lWi4HgfQJS6WDdSc8VgU2Y70pZF+vzzzzFx4kR8/vnnpm4oHbWi9saDBTZfMiklAgsAcMYZZ2Dp0qW4+eabcccddyAjIwMOhwMfffQR2re35o9DREREREREREREScRIwMBVAbw5KWabMoezbds2lJWVNfn18dChQwcMGTIkeTd0TpIlk1ImsAAA/fr1w7x587B7924cPHgQbdq08S2LRERERERERERERBQ3e7cDTw8wHjCY+B/AGaHvshkj2rdt24Zu3brB5XLB6XRaqp802IbO2uyFQLaZzaCJdsmkbV9FPtaEmQ0pFVgA1E2bCwoKEvZ5IgIA2L9/f8I+03T159yIxwW4q4HMHPXiWL/BdrzVuGtRW6NesPfv3w93ZoyzfajzDZSg87UTrVxIhO8wJcuREe4q/zIVTozyX9Tlifk+7lKtHMX9mp5IRuuPwPozFJa3Jku1chQXRvNzKHFsJybVdcPCUrIcJcl9gOEyYrTtafHztbKULEdWp/8twrTJDJcjlo+4i7ocbfgKyEvgknWVG4GDVcAZfweKjw5/bE5LoOgIY+/bxOvBli1b4HK58Nxzz6G0tBRFRUVRX1vi2dYqKipCUVERsrKykJOT45u9ECgnJwfffvutvValSSsE8grDH1ObCdRlA29cGfn9MnKAs59r1uwVzf6DVQAilyNFIh1BzbJjxw57ZWoiE2zfvh1HHBG6smQ5IoqM5Yio+ViOiJqP5Yio+ViOiJqP5Yio+SKVIwYW4szr9aK8vBz5+flQEhyZ3r9/P9q3b4/t27cndJZGoiTz+SXzuQEN57dt2zYoioK2bdsiLS0t5PFmlKNk/w2A1DhHIPnPU0Rw4MABy5UjO33vTGt82CWtWjp/+uknHHPMMc0uR3Y5b42d0muntAKpl16r1kdNkWq/XSLZKa1A4tNr13Jkt981Ep6PtUU6HzPKUap9x3aTTOeTqHMxWo44DzjO0tLSwkZ2EiHRyz8lWjKfXzKfGwAUFhYaOj8zy1Gy/wZAapwjkNznWVgYYfokzCtHdvremdb4sEta27VrF7bRDERXjuxy3ho7pddOaQVSK71Wro+aIpV+u0SzU1qBxKbXzuXIbr9rJDwfawt3PmaVo1T6ju0omc4nEediqBzFNQVERERERERERERERJRUGFggIiIiIiIiIiIiIiLDGFhIYllZWbjvvvuQlZVldlLiIpnPL5nPDbDH+dkhjc2VCucIpM55Wo2dvnemNT7sktZYp9Mu562xU3rtlFaA6bUzu30XdkqvndIK2C+9Zkm274nnY21WPB8rpqk5eD7WZbVz4ebNRERERERERERERERkGGcsEBERERERERERERGRYQwsEBERERERERERERGRYQwsEBERERERERERERGRYQwsEBERERERERERERGRYQwsEBERERERERERERGRYQwskO2JiNlJICIioiTCtgUREemxXqBkkoz5ORnPyUqS7ftNtvMxEwMLZFu//fYbAEBRFJNTQqmirq7O7CTERG1tLTwej9nJoBSRLOWGmua3336zzfVGn1cVRYHX643p+8f6/eLNyjdcO3fuxLJly8xORpPZLS+kCraPKBjec0Yn2dt9dr9+u1wuAGp+tnI9b1S8226xYMU0RSOZ8owd8osdMbCQYux+IdCsXLkSffr0wYIFC8xOSlxs27YNH3zwAV544QXs3LkTVVVVZicpptatW4cvv/zS7GRE5aeffsKzzz6L6upqs5PSLD/99BMmTJiA4cOH47LLLsMbb7xhdpLizo75LVls3LgRzz33HH755RezkxJRsBthq9aZ5eXl+OyzzzB79mxs2bLF7OSE9MMPP+Dwww/HF198YXZSIlq/fj2uvvpqXHDBBbjuuusAAGlpTW8mb968GS+88AIef/xxfPLJJ773s2qe2rx5M5588kk88MADeOeddwBYtxPtxx9/xNChQ7F48WJbXFu2bNmCf//733j66ad97VYr54VUZff2kd3bOlYtD8l+zxlrdmr3GWG3ujySNWvWYNCgQfjPf/4DwP4dxbFuu8UC84x1WTG/JAt+i0lq3bp1uPnmm3HBBRfg4Ycfxvfffw/A3hcCzcqVKzFw4EBcfPHFGD58uN9zdj83QL1hHjBgAO655x7ceuutOOGEEzBt2jRs3rzZ7KTFxIoVK9CvXz9fnrSDlStXomfPnti/fz9ycnIA2DOvrV+/HqWlpcjMzMTIkSPx888/Y+bMmbjsssvMTlrc2DG/JYsff/wRJ5xwAjZv3uwLyGmjQqxWfsrKynDjjTfi1FNPxV133YV58+YBsGbH6qpVqzBkyBDcc889mDRpEi6//HJ88MEHZierkZUrV+Kkk07ClClTMGzYsEbPWykPrF69GqWlpaipqUFWVhYWLVqEO++80/d8tGldvXo1jj/+eMyePRszZ87ElClTMHz4cFRVVVmyHbZq1SqUlpbif//7H15++WXMnDkT7733ntnJCmrTpk0YMWIEzjjjDNx8881o166d3/NWG3m2atUqDBgwAG+99Rb+7//+DzfffDNGjRpl2bywceNGPPDAA7jwwgsxa9YsbNiwwewkJYTd20d2auvY6R412e85Y81O7T4j7FaXG/Hyyy9j48aNmDFjBt566y0A1ix7RsS67RarNDHPWJMV80tzWarNJpR01qxZI4WFhXL66afLxIkTpU2bNjJkyBB57LHHfMd4vV4TU9h0a9askezsbJk2bZqIqOexdetWWbZsmbjdbtuel2bPnj3yhz/8QW699VbZvXu3iIhMnz5dhgwZIuPGjZMNGzaYnMLmWbFihTidTvnLX/4S8hir/YYrV66UnJwcuf322/0er6urExHrpTcUr9crU6dOlXPPPdf3WFVVlTz11FPSq1cvOe+880xMXXwYyW8UH+Xl5dKlSxe55ZZb/B4/cOCASSkKbc2aNdKiRQu55ppr5MYbb5QLLrhAsrOz5fHHH/cdY5VyvnHjRmnfvr1MnTpVKioqZOvWrVJaWiqTJk0yO2l+Vq1aJU6nU+6++24RUb+/srIymT9/vmzatMl3nHYdNdPevXtlwIABcvPNN4uISHV1tVx77bW+dka0qqqqZPDgwXLNNdeIiFqvf/TRR9KzZ0/p0aOH/PrrryJijXMXEVm3bp20bdtWpk6dKl6vV3777Tfp1auX/POf//Q7zirpnTFjhpxzzjkioqbpmWeekenTp8uDDz4otbW1JqfOX0VFhRx33HG+9sPevXtl1qxZoiiKDB06VH777TcRsc53u2rVKmndurWcddZZMnz4cOncubPcdNNNUlNTY5lrYDzYvX1kp7aOne5Rk/2eM9bs1O4zwm51uVH33XefDB48WG644Qbp1q2bzJ492/ec1erQcGLddosF5hnrsmJ+aS6rtdkYWEgybrdbLr74Yrniiit8j23dulWuvvpq6devnzzwwAO+x+3WINq7d6+UlpZK+/btfY+dd9550rNnT8nOzpYuXbrICy+8IHv37jUxlc2zdetW6dixo/zvf//ze/zll1+WoUOHykUXXSTl5eUmpa551q1bJ1lZWTJ16lQRUfPq3Llz5cknn5TZs2f7brCtZO3ataIoilx//fW+x5544gmZPHmyXHPNNfLRRx+ZmLroXXrppXLiiSf6PeZyueSFF16Qvn37yh133GFSymJv/fr1tstvyWT+/PkycOBAqa2tldraWrnxxhtl1KhRMmTIEPn73//uO87seqi6ulrOP/98uemmm3yP/fzzz9K1a1dRFEXuv/9+3+Nmp7WmpkZuueUWmTBhglRVVfka8/PmzZN27dpJRUWFqenT1NTUyOmnny5paWm+x8aOHSt/+MMfRFEUOe644/zaKGZ/rxs2bJBu3brJ8uXLfY9dddVVUlpaKmPGjJFx48bJL7/8IiLG0rp7927p1auXzJ071/eY1+uV9evXS79+/aRPnz5+j5uppqZGpkyZIpdddplfR9mECRPk2muvlSlTpsjMmTN9x5udXhGRP/3pT766asCAATJ06FA54YQTpGPHjtKlSxfZsmWLiFjjxn3lypXSs2dP2bhxo++xHTt2SLdu3aR169bSv39/E1Pnb/v27dK9e3e/dsCsWbOkRYsWsnnzZvMSliB2bR/Zqa1jp3vUVLjnjDW7tPuMslNdHo1FixbJjTfeKOvWrZNJkyZJ9+7d5ZNPPpEHHnhAvvzyS9ucS6zbbrHAPGNdVswvzWHFNhuXQkoyDocDO3fu9E3lERF06NAB9957L4YOHYr//ve/+Pe//w3Amks8hFNYWIg//vGP6NKlCy655BIcf/zxcLlcuP/++7Fy5UqUlpbi4YcfxqeffgrAntOZ0tLSkJOTg/LycgDqJnIAcPHFF2PChAlYvXq1Lc9PRPDMM8/A6XSiT58+AIA//vGPmD59Op544glMmjQJV155JRYtWmRqOgP9+uuvAICSkhLs3LkTQ4YMwZw5c7B582Zs2bIFY8eOxdNPP21yKiPT8kq/fv1QV1eHtWvX+p7LycnB+PHjMXLkSCxcuBC///67WcmMmdraWjz11FPIy8uzVX5LJtu3b0d6ejrS09MxYsQIbNiwAQMGDMCAAQNw00034ZZbbgFgfj2kKAo2bNiA9u3bA1D3WTjqqKMwYsQInHPOOZg+fTpefvll37FmEhE4HA4MHz4cTqcT6enpANTrU3V1Ndxut6np0zgcDtx1113o0qULBg8ejFGjRiEtLQ2PPfYYVq9ejUsuuQRff/01brvtNgDmf6+FhYWoqanBM888g8rKStx333146aWXMGbMGIwaNQq//fYbRowYAY/HYyitBQUF8Hq9WLhwoe8xRVHQpUsXzJo1Cy6XC9dff73vcTNlZGTgvPPOw4033giHwwFFUfDggw/ijTfegMfjwbZt2/Cvf/0L48ePt0R6AbUcrFy5Em+++SZatmyJ999/HwsWLMA333yDVq1a4ZxzzgFgnTVz9+/fj1WrVvn+PnjwIDIzM/H4449j165dePTRR01MnUpEsGDBAnTr1g1XXXWVb+mSiy66CO3atcPWrVtNTmH82Ll9ZLe2jp3uUVPhnjPW7NLuM8pOdXk0HA4HPv30U3To0AG33347hg0bhvPPPx/33HMPunTpYpslbmLddosF5hnrsmJ+aSrLttkSH8ugeDp06JBcdtllcuaZZ0p1dbV4vV7fqK2tW7fKqaeeKuPGjTM5ldEpLy+XH3/80ff3448/Lt27d5cxY8Y0Gr0/evToRiOOrK6qqkrcbrfv73HjxkmfPn1kz549IiLi8Xh8z5177rkyaNCgRCexWbZv3y4bN26Ubdu2yZ/+9CcZOHCgtG/fXk477TRZt26d1NbWyqpVq6RHjx6+5Q2sQItWv/fee6IoirRo0ULGjx8v27dvFxF1pOfDDz8smZmZ8u2335qZVMM2btwoJSUlctlll8n+/fv9nisvL5e0tDR55513zElcjK1fv95W+S3ZLF26VIqKiuTRRx+VsWPHyo4dO3zPzZ07V9LS0uS///2viSlUHTx4UMaNGyc33nij/P777yKizlho1aqVzJ49W6688koZPXq0rz41m5ZGEfGr24899lhfnSEismzZskQnrZHvvvtOunfvLn/4wx98o4BEGqYfDx482BJLJLjdbvnHP/4h7du3l9GjR0tOTo7fNO+ff/5ZioqK5M0334z4XloemTZtmgwaNEg++OCDRs/fd999MmTIEKmqqortiTSRvo2xfv16adu2rbz//vu+x5577jnp3LmzrFu3zozk+Wjf7eLFi6W0tFQGDRokkydPFpGGsvDNN99I+/btLVMn79q1S4YNGyZnnXWWPPLII/LBBx9IUVGRTJkyRUTUNp1+9LaZ/ve//8n//d//+T1WU1MjRx55pLzxxhvmJCqB7No+slNbxw73qMl+zxlPdmn3GWHHutyoPXv2SGlpqW/W62mnnSa5ubly1FFHybvvvmty6oyLZdstFphnrM1q+aW5rNhmY2AhCVRWVkpZWZmsX79eRES++uorSU9PlyeeeMJ3jNZwW7ZsmSiKIj/88IMZSY3ajh07pLi4WM466yz5+uuvfY+/9NJL8t///td3EddujO+44w5bNfJWrVol48aNkyVLlsjBgwdFRL0RPeqoo2TkyJFy6NAhv+Off/55GThwYKPHrWr16tVyxBFH+JYZKSsrk0mTJsnpp5/uy6+a+fPni6Iofg16s9TW1orX6/Xlrw8++EB69eolS5Ys8Ttu48aN0qpVK1vddC9YsECysrLkuuuuk127dvker6iokD/84Q+ycOFC8xLXTIHrPG7cuNEW+S3ZeL1e2bNnj1x88cXSt29f6d27t99zBw4ckL59+8qTTz5pYiobPPXUU9K1a1cZNWqU3HjjjeJ0On3ro86ZM0datWrlV1asQB/k2LBhg7Rp08bX6TF16lTp06eP6Wn2er3yww8/yMcff+yro7W2yN/+9jfp1auXZW6uPB6P7N69W9asWSM9evSQbdu2iYh6DuvWrZNu3bpFdW3ctGmTDBw4UMaOHdvodW+++aZ07tzZL0hkJVq+0X6ruXPnSrdu3XxrA5tt165dcskll4jD4ZBRo0b5Pffjjz9Kt27dZM2aNSalroFWRletWiVnnXWWdO3aVbp06eJbskZE5Nprr5UxY8aYlcSQtLR7vV7p27evzJkzx/fc66+/bpnATazZpX1kp7aOne5Rk/2eM57s1u4zys51eTjDhg2Tr776Si655BJp27atvPHGG3L11VdL69atbdNRLBL7tlssMM9YlxXzSyxYpc2WYc48CYqV1atX4+KLL0ZtbS3Wrl2LqVOn4r777sPDDz+MKVOmICcnB5MnT/ZNCc/Ly0P37t3hdDpNTrkx69evx759+7Bv3z4888wzUBQFAwYMwCWXXIKamhrfVKWMDDUr//LLL+jRowe8Xi8URbH0VKY1a9Zg6NChuPDCC9GpUyfk5uYCUJe1eP3113HOOedg1KhRePbZZ9GxY0dkZ2dj2bJlyM/Pt/x0MwC+qcKtW7fGG2+8gdtvvx3HHnssZsyYgbVr1+LII48E0DB9uKamBl27dkXr1q1NS/Nvv/2G1q1bIz09HXV1dUhPT4fX68XYsWPRs2dPtGrVypdmRVGQlpaGtm3bok2bNqalOVrDhg3D22+/jfHjx6O8vBzjx49H79698eqrr2LHjh3o3Lmz2UlskvXr1+P999/HRRddhMMPPxwA0LlzZzzwwAMoKyuzZH5LVoqioKioCGeccQa++uorbNy4EZ988glGjRoFRVGQl5eHFi1aIDs729R0auX4uuuuQ0FBAZYsWYLy8nI8/PDDuOGGGwAA6enpaNeuHXJyckxPp57+7+rqauzfvx8OhwP3338/HnnkESxduhQlJSWmplNRFPTu3RtAw7I02r8bNmzAcccdB4fDkdA0agLTmpGRgRYtWgAAMjMzsXjxYkycOBGKouCNN96Aoijo2rWr4ffu1KkTnnvuOVx00UV45JFHsGXLFlx66aU4dOgQli1bhrZt25qap4LRvpPi4mIADb/V0qVL/dooZhIRlJSUYPr06di/fz8++ugjXHPNNfjHP/6B3bt3491330V2dravrjaToijwer3o2bMnXnrpJYgI9u7di44dOwJQz+XXX3/1lREr0cqGoijIzc31XavvvPNO/OMf/8Dy5cvNTF7c2KF9ZKe2jt3uUZP5njPe7NLui0TfNrBrXa4X2Nbxer1IS0tDSUkJTj31VBQVFeGDDz5Anz590LVrVzgcDvTs2dPEFIcXz7ZbrNJn9zwTyO55Rs9q+SVWLNNmS0j4guJizZo1UlxcLLfccousWbNGHn30UVEURbZt2yYej0emTZsmiqLInXfeKd99953s2rVL7rjjDunUqZNlRp5FUllZKePGjZNnn31W+vXrJxMmTJBVq1aJiP/GfNXV1TJ16lRp1aqVrF271qzkGnbw4EEZNWqUb1SsiDqa/4cffvBNHV29erV0795dOnfuLMcff7ycccYZkp+fLytWrDAr2YatWLFCcnJy5K677pJdu3ZJjx49ZMaMGb5RVsGWFLntttvklFNOMW0jtLKyMnE4HHLGGWf4HgscFRbozjvvlJ49e8rOnTvjnbyYW758uZx00knSoUMH6dSpkxxzzDHy/fffm52sJtmwYYO0bNnSd70LHKltxfyWzPTf95tvvik9evSQI444QmbNmiWLFy+WO+64Qw4//HD5+eefTUylKnCD18Ayf+2118qIESN8M8oSpby83PCo602bNknfvn1l8uTJkpWVJd99912cU9cgmnSKqHX6nXfeKa1atUr4qHIjad23b5+MHz9eBg4cKEOGDJELLrhAiouLg46g9Xg8fssYijTkJ+3fNWvWyFlnnSVHH320tGvXTk466SRp0aKFKSNyw6U3GO23Ki4uTvhoZyPf7fbt2+XWW2+Vww8/XIqKiqRfv37SunVrU+qxaL/bDRs2yF133SUtWrSQsrKyeCevydxut3Tv3l3mzp0rM2bMkJycnKSdraBn1faRndo6drxHTdZ7zkSwU7svULi2gRXr8kiMtHUWLFggAwYMaHQ9r6mpiWfSmiTWbbdYsFv7LxIjbRi75Bkj55Lo/JIoZrfZGFiwqV27dsnQoUPlz3/+s+8xr9cro0ePlqVLl8qKFStk69atMm/ePDn88MOlTZs2cuyxx0q7du0s0Tg2ora2Vn7//Xfp2rWr7NixQ+bOnSv9+/eXyZMnS2lpqW/N0Pfff19OOeUUW51bTU2NnHjiifL9999LbW2tjB49Wvr37y/5+flywgknyAsvvOA79sknn5Q77rhDpk+fbosG7MqVKyUrK0vuuusuEVEv5ueee67079/fd4y+Abp69WqZOnWqFBQUmDZVu7y8XEpLS2XgwIHSqVMnOfvss33PBQsufPPNN3LNNddYtoFg1L59+2Tz5s2yatUq05dNaaqDBw/K5ZdfLpdeeqk89dRToiiK3HrrrX7no89vq1atMj2/JQv9EgeBy7PpG3GfffaZXHXVVZKdnS29evWS3r17J/xaHS6twSxfvlyuvvpqKSwslJUrVyYghQ30yzEYaRCuXbtWFEWRwsLChH6v0abzo48+kosvvtiUutpIWrXrxJYtW2TmzJly3nnnye233x603l2zZo2cd955cuKJJ8qll14qr7/+uu85rc7QysCuXbvk22+/lfvvv19efPFF2bBhQ6xPLyIj6dX75JNP5E9/+pMcddRRCa/jovluq6qqpLy8XF544QX58MMPZcuWLQlNq9H06v32228ybdo0ad++vSlt1kgDJvQ8Ho+UlpbKsccemzJBBY3V2kd2auvY8R41me85Y8lO7T4jjLQNrFSXRxLN+eiXorTCHmLBxLrtFgt2a/9FEm2bS2PFPGPkXBKdX5rLTm02BhZsqqKiQv7617/6raV5//33i6Ioctxxx0n79u1l1KhRsmnTJikvL5fFixfLJ5984reRktVpBX/ChAny8ccfi4i61n1JSYnk5+fLrFmzRES9yM2YMcOyF4Rgfv31V2nVqpV88sknMmXKFBk9erSsWLFCPvroI7n11lulTZs2fhdDO1m2bJncc889ItJQEa1du1YKCwvlmWee8Tt28+bNMnr0aDn66KNN7aB//fXX5eyzz5ZFixbJnDlz5Mgjj/QLLug3t9y6das89NBDUlpamvAOR2rM5XLJ008/7duA6c033wx6wy2i5rcxY8ZIp06dbB0QsoJVq1ZJ3759pVevXpKVleU3I0mjLzciIr/88ov8/vvvsnv37kQm1VBa9Q4ePCgffvihnHLKKabMEFuwYIFkZGTI8OHD5eKLL5bly5f7nqurq2s0Emfnzp1y9tlnJ3zkc7Tp3L59uzz//POyadOmhKZTxHhaA9fQDjbqfN26dVJYWCgTJ06U6dOny9ChQ6Vv375y6aWX+o6x0j5ITUnvL7/8Iq+++qps3rzZ8mk1U1PSe+jQIdm6davfhuaJsm7dOnn00UcbbUKrp+8scLlcMnjwYCkpKWF7x2R2auvY8R41me85Y8VO7T6jom3HWF205xNuZp0VxLLtFgt2a6NEYuR8AmckWDXPRPPbJCq/NJfd2mwMLNjY/v37ff//xhtviKIoMnv2bKmsrJRFixbJ8ccfL/fee6+JKYyNiy++WO644w4REbniiiukRYsW0r17d7n88stl6dKlJqeuabxer1xwwQVy/fXXy+mnn+5rxIqonS8TJ06Uq6++Wjwej+9iZ8XIsBFer1f27t0rZ555ppx33nm+jZE1K1eulK1bt5qYQvVG4b333hMRtZJ56623GgUX9I3nnTt3SmVlZcLTScEFLlMze/ZsURRFbrnlFqmoqBCRhtFomzdvNj2/2V24JQ40wa5XZjTcmprWmpoaOXDgQCKT6hNsOYbVq1eLiP93+OKLL/o6fs24kYkmndpIcrMa79GkVX99CMwbXq9Xpk6dKueee67vsaqqKnnqqaekV69ect555/kd/+KLL/rltURrSnq13yrRbY5U+G7NrHsiLaMjEvw3f/nll2XdunWJSCJFYKe2jl3vUZPxnjMW7NTui0Y0bQMz6xujUvl8wrXdYsFubZRIkul8mtses2Ifmx3bbAwsJIktW7b4RXFFRM444wy/9eLtRissL730ktx7771yzTXX+NZnnDt3rnTu3Fmuvvpqqa6utuQFIZJvv/1WcnNzRVEUmTdvnt9zf/nLX2To0KG2PK9Q/vOf/4iiKPLFF1+YnRQ/wRq91dXV8vbbbzcKLvzzn/+UjRs3JjJ5FAV90Eq7kb311lvll19+kSlTpsiZZ54p1dXVJqfS3kItcTBmzBhZunSp/PDDD7J9+3bfcw8//LDcf//9JqS0aWmdPn26CSltYHQ5hiVLlkiXLl1kwoQJ4vF4El5X2CWdTUnrxIkTw85oufTSS+XEE0/0e8zlcskLL7wgffv29XVKffnll3L00UdHfL94iza9Zv5Wyf7dmpVeI8vo6D3yyCMybdq0BKeSjLJbW8cO96jJfs/ZHHZq90Uj1m0Ds/F84n8+dqnzjUqm80mmc7Frm42BhSTk9XqlpqZGLrzwQnnwwQfNTk6zLV68WBRFkTZt2vhtSvnOO+9YchOoaCxZskQURZHTTz/dF4EXEbnxxhvlyiuvtN0UzHAOHToko0aNkgkTJojL5TI7ORG5XC7fskjnnHOO/PnPfxZFUWyf55Kd1+v1BYtmz54tDodDjjnmGMnIyLDk+q52E26Jgz59+sgRRxwho0ePls8//1wOHjwo559/vgwaNMiUGT52SqvG6HIMIiLPPvusadcju6RTJHZp1d7n73//uwwaNKjR0lP79u2T2267TU444QTfsg/PPfec6b+RHdJrp7SK2C+90SyjU1lZKeeff76ccMIJvlHwZD12betY/R41me85m8qObSkj7NSOMYLnE7/zsVudH0kynU8ynYvGrm02BhaS1D333CMdOnTwawTYldvtln/961++tcKSbaTI4sWLpW3btjJgwAC54oorZNKkSVJYWCirVq0yO2kx99BDD0lBQYHs3LnT7KT4CVwTVFNdXe2bat6yZctGI67Imrxer+86MXz4cGnZsiU3ao6hcEscLF68WAYMGCD33XefiIj8/PPPYdeGjDc7pVUv3HIMX375pcmpa2CXdIrELq0bN26UkpISueyyy/zyl4hIeXm5pKWlyZw5c2Ka9uawU3rtlFYRe6XX6DI6e/bskcrKSstcCyk0u7Z1rHyPmuz3nE1l17aUEXZqxxjB84kfO9X5RiTT+STTuYjYs82WAUoqc+bMwaJFizB79mx8+umn6NKli9lJajaHw4FLL70UaWlpAABFUUxOUWwNHToUCxYswGuvvYavv/4aXbp0wRdffIGePXuanbSYEREoioKrrroKc+bMQU1NjdlJ8qmrq0NGRga2bNmCjz76CFdeeSUcDgcAIDs7G/Pnz4fT6cTnn3+O7t27m5xaMkJRFNTV1eHWW2/FwoULsWLFCvTq1cvsZCWN/Px83/8PGjQI3333Hfr16wdAvZ61bt0ay5cvh4jgqKOOMiuZAOyVVqDhWjl8+HD8/PPPuPbaa/Hhhx9i+fLlWLFiBW699VZkZmaiX79+yMrKMq0+tEs645HWzp0746233sKpp54Kp9OJadOmoaSkBACQmZmJvn37ori4OBGnZoid0muntAL2Sm9ubi4Atc2TlpaG888/HyKCiy66CIqi4KabbsLMmTOxZcsWzJ49Gy1btjQ5xRSJ3do6drhHTfZ7zqayW1vKCDu1Y4zg+cT/fOxU5xuRTOeTTOcC2LPNxsBCkunWrRvefvttLFmyJKk6QbUGXrI65phjMGPGDHi9XgDJd75aZV9UVITFixf7LpZmq62t9QUVjjnmGFx44YW4+uqrfc9/+OGHWLx4MRYvXpxU5SlV9OjRA99//z169+5tdlKSVseOHdGxY0cA6k2A2+1GXl4eevbsabmbFjukVUvHUUcdhcsuuwytW7fGf//7Xxx11FE46qijoCgKjjvuOGRnZzOdBsUjrcOGDcPbb7+N8ePHo7y8HOPHj0fv3r3x6quvYseOHejcuXO8TqdJ7JReO6UVsF9609PTISLwer244IILoCgKJk2ahHnz5mHTpk1YtmwZsrKyzE4mRcEubR273KMm2z1YrNmhLWWEndoxRvB8EsNudX4kyXQ+yXQuGju12RQREbMTQbHl8Xh8I66JKDh9UKFfv34466yz8OyzzyIjoyHeWl1djX379qFNmzYmppSaShvtQolz77334uWXX8b8+fMtORpRz8pp9Xg8ePXVV3H88cejd+/els3LdkknEJ+0fv/997j55puxefNmZGRkwOFw4I033kDfvn1jlOrYslN67ZRWwH7p1W7/FEXBKaecghUrVmDRokWWHvFOwVn5uhuI96jJx8ptKSPs1I4xgueTGHar8yNJpvNJpnPR2KHNxsACEaWcwKDCuHHj8MILL/gFFbxeL0ctERkUuMSBlRtvdkmrXa5BdkknEJ+07t+/H7t378bBgwfRpk0b39Rrq7JTeu2UVsB+6dWW0Xn88cexYsUKy494JyLrsEtbygg7tWOM4Pkkht3q/EiS6XyS6Vw0Vm+zcSkkIkop+j0VQgUVAE6FJoqGXZY4AOyTVrtcg+ySTiA+aS0oKEBBQUHM3zde7JReO6UVsF96Afsso0NE1mKXtpQRdmrHGMHzSQw71vnhJNP5JNO56Fm5zcYZC0SUcrZu3Yru3bvj/PPPx/PPP4/09HSzk0Rke3Za4sBOaSUiiherLCtBRPbDthQRUeJYuc3GwAIRpZS6ujrccMMNcLvd+Oc//9lopgIRERERERERERGFx8ACEaWcvXv3oqCgwLJTK4mIiIiIiIiIiKyMgQUiIiIiIiIiIiIiIjKMw3WJiIiIiIiIiIiIiMgwBhaIiIiIiIiIiIiIiMgwBhaIiIiIiIiIiIiIiMgwBhaIiIiIiIiIiIiIiMgwBhaIiIiIiIiIiIiIiMgwBhaIiIiIiIiIiIiIiMgwBhaIiIiIiIiIiIiIiMgwBhaIiIiIiIiIiIiIiMgwBhaIiIiIiIiIiIiIiMgwBhaIiIiIiIiIiIiIiMgwBhaIiIiIiIiIiIiIiMgwBhaIiIiIiIiIiIiIiMgwBhaIiIiIiIiIiIiIiMgwBhaIiIiIiIiIiIiIiMgwBhaIiIiIiIiIiIiIiMgwBhaIiIiIiIiIiIiIiMgwBhaIiIiIiIiIiIiIiMgwBhaIiIiIiIiIiIiIiMgwBhaIiIiIiIiIiIiIiMgwBhaIiIiIiIiIiIiIiMgwBhaIiIiIiIiIiIiIiMgwBhaIiIiIiIiIiIiIiMgwBhaIiIiIiIiIiIiIiMgwBhaIiIiIiIiIyJAjjzwSRx55pNnJILKdSy+9FIqiYMuWLWYnhch2Fi1aBEVRMG3aNLOTQjoMLJDtXXjhhVAUBbNnzw57XGVlJbKyslBSUgK3252g1BFZ1xdffAFFUXDGGWcEff6qq66Coijo27dv0OdnzJgBRVHwyCOPxDOZRLayZcsWKIri95/D4UC7du1w3nnn4bvvvjM7iURElITYriOKPbbriIjCyzA7AUTNdcUVV2D27NmYNWsWLrjggpDHvfbaa3C73Zg0aRIyMzMTmEIiazrhhBOQm5uLJUuWoK6uDunp6X7PayMCVq5cid27d6Nly5aNngeAYcOGJSrJRLbRuXNnTJw4EQBQVVWF5cuX4+2338a7776L+fPnY+jQoSankIiIkgnbdUTxw3YdEVFwnLFAtnfKKafgyCOPxPz587F9+/aQx82aNQuAGoggIsDhcGDw4MHYv38/vv/+e7/ndu7cifXr1+Oss86CiGDx4sV+z7vdbnz11VcoKChAv379EplsIls4+uijMW3aNEybNg0zZ87EggUL8NBDD8Hj8eCee+4xO3lERJRk2K4jih+264iIgmNggWxPURRcdtll8Hq9ePnll4Mes3z5cqxcuRIDBgxAp06dkJ+fj6OPPjrke3bt2hX5+flwuVzxSjaRJWij0rRRahrt77/85S/Iy8tr9Pw333yD6upqDB06FIcOHWKZIjJAC2wvX77c99jw4cORlpaGbdu2BX3N5MmToSgKPv/884SkkcgK3G43nnzySYwePRrt27dHVlYWDjvsMJx99tn44YcffMe98sorUBQFM2bMCPo+X375JRRF4aASShmxaNfpZzq899576N+/P3JyctC6dWtMnjwZe/bsiecpENlGsHadZs2aNTj99NORn5+PwsJCjB07FqtXr050EokswWi7TlNdXY077rgD7du3R3Z2Nnr27Innn3/ehJSTEQwsUFK47LLLkJaWhpdeegki0uh5/WwFp9OJs88+G5s2bcJXX33V6NhvvvkGGzZswDnnnAOn0xn3tBOZSbsBXbhwod/jCxcuRH5+PgYMGIDBgwcHfV57PcsUUXQyMhpWopw0aRJEBP/+978bHXfo0CHMmTMHRx55JE488cREJpHIVLt378ZNN92EQ4cOYezYsZgyZQpOPvlkfPjhhygtLcW3334LADj77LPhdDqDlh9AXQYTUMsZUSqIRbtO88orr+DMM8/E+vXrMWnSJFxyySX48ssvMWLECO5XR6Sjb9cBwOrVq1FaWoqPPvoIY8aMwXXXXQe3243Bgwfj559/NimVROYx2q4DAK/Xi3HjxuFvf/sbWrRogT//+c8YOHAgpkyZgscee8zEs6CQhChJjB49WgDIokWL/B6vqamRFi1aiNPplH379omIyKeffioA5Nprr230Ptdff70AkPnz5yck3URmqq2tlfz8fMnPzxePx+N7vEuXLjJmzBgREfnrX/8qiqLIrl27fM8PGzZMAMj3338vIixTRJrNmzcLABk9enSj52bMmCEA5LTTTvM9tn//fsnJyZHu3bs3On7OnDkCQO6+++64ppnIampqamTHjh2NHl+9erXk5eXJiBEjfI9NmDBBAMiyZcv8jnW73VJcXCzt27cXr9cb9zQTWUGs2nX79u2TgoICyc3NlXXr1vmOc7vdMnToUAEgHTt2TMxJEZko2nadiMhJJ50kAOS1117ze/zOO+8UAAJANm/eHM9kE1lKNO26WbNmCQAZM2aM1NbW+h7/8ccfJTMzUwDIfffdl4hkk0GcsUBJ4/LLLwcAvPjii36Pv/POO9izZw/Gjx+PgoICAOrSE23btsVbb70Fj8fjO7a2thZvvvkm2rVrx43LKCWkp6djyJAhOHDggG8ab3l5OTZs2ICTTjoJAHDSSSf5rcfrdrvx9ddfo0WLFjjuuOMAsEwRBdq4caNvLd5bb70VJ598Mu655x4cdthhmDlzpu+4/Px8jBs3Dj/99FOjqcDaaGtts0CiVJGVlYV27do1erxHjx4YNmwYlixZ4qtrtPKhlRfNhx9+iMrKSkyYMAGKosQ/0UQWEKt23bvvvov9+/fj8ssvR9euXX3v73A48OCDDyb4rIjMZ7Rdt23bNixevBi9e/fGhAkT/N7jrrvuQlFRUYJTTmS+aNp1r7zyCgDgwQcf9Fuar1evXpyBalEMLFDSOPPMM1FcXIw5c+bgwIEDvse1QIMWeACAtLQ0XHTRRaioqMDHH3/se/zjjz/Grl27cNFFFyEtjcWDUkPgtHlt3d2TTz4ZANC/f384nU7f819//TWqq6tx8skn+8oJyxSRv02bNmH69OmYPn06Hn30USxevBiHHXYYPv/8c3Tr1s3vWK2RrO8Y3b17Nz788EP0798fxxxzTELTTmQFK1aswEUXXYQOHTogMzMTiqJAURS8//77cLvdqKioAACMHDkSbdq0wezZs1FXV+d7/auvvgqAyyBR6olFu27lypUAgCFDhjR6/0GDBjVa+oUo2Rlt12llJ9gSlnl5eejTp0+ikkxkKUbbdStXroTT6US/fv0avUewOonMx14eShqZmZmYOHEiXC4X3nrrLQDA9u3b8dlnn6FLly4YOnSo3/HajaZ+XV6uxUupaPjw4QAabjwXLlyI3NxcHH/88QDU0WmDBg3yex5AoxkILFNEDUaPHg0RgYjg999/x8yZM1FRUYEzzzwTBw8ebHTsYYcdhjfeeANerxcA8NZbb8HtdrPsUEpaunQpBg4ciLlz56JPnz644YYbcO+99+K+++7zjag+dOgQAHWE9oUXXojff/8dn376KQBg3759+OCDD9CvXz90797dtPMgMkMs2nX79u0DABx22GGN3j89PR3FxcXxSj6RJRlt14UrOwDQunXrhKSXyEqiadft27eP5cdmGFigpHLFFVcAaJil8NJLL8Hr9frNVtD07t0bvXv3xrx583DgwAEcOHAA8+bNw3HHHYdevXolNN1EZurTpw9atGiBL774ArW1tVi0aBEGDx7sNxrt5JNPxpo1a/D777/7bkQDAwssU0TBtWrVCrfccgvuuusulJWV4e677/Z7PiMjAxdccAF27tyJBQsWAFCDctrjRKnmwQcfxKFDh/DZZ59h3rx5eOyxxzB9+nRMmzYNbdq0aXR84Kyft99+GzU1NQzMUUqKRbuusLAQAPD77783ev+6ujpUVlbG9ySILCxcuy5c2QGA3377LSFpJLKSaNp1hYWFLD82w8ACJZVevXqhf//+WLp0KdauXYuXXnoJ6enpuOSSS4IeP3HiRFRXV+M///kP/vOf/6C6upprWVPKSUtLw9ChQ1FVVYV3330XGzdu9K3Dq9H+/uSTT/D111+jVatW6NGjR6P3YpkiCu2uu+5C27Zt8cwzz2DLli1+z+nXid+8eTOWLl2K0aNHo1WrViaklMhcmzZtQsuWLTF48GC/x10uF77//vtGx/ft2xfdu3fHu+++i6qqKrz22mu+mQxEqSYW7TptBOnnn3/e6P2/+uor1NbWxvEMiOwhWLtOKztffPFFo+MPHjyIFStWJDCFRNYQTbvuuOOOC9neC1YnkfkYWKCko81auPLKK/Hzzz9j7NixOPzww4MeO2HCBKSlpeG1117Dq6++6lsnnijVaKPUpk+fDqBhHV7NgAEDkJ2djb/97W+oqanBySefHHQzTJYpotBycnJw++23w+PxYMaMGX7PaXspzJ07F88//zxEhKOtKWV17NgRe/bswZo1a3yP1dXV4ZZbbsGuXbuCvmbSpEmoqqrCE088gSVLlmDkyJGcMk8pq7ntuj/+8Y8oKCjAiy++iPXr1/se93g8jWbdEaWqYO26Dh06YOjQofjxxx/9locFgL/+9a/Yu3evCSklMlc07Trt/mfq1Kl+e2etWrXKt38WWQsDC5R0LrzwQjidTnz55ZcAGgINwbRt2xbDhw/HwoULsWjRIpxyyilo27ZtopJKZBnaDejq1avhdDrRv39/v+ezsrIwcOBArF692u/4QCxTROH96U9/Qtu2bfHKK69g06ZNfs9NmjQJBw4cwKOPPoqCggKMGzfOpFQSmeuGG26AiODEE0/EVVddhT//+c/o168f3nrrrUYdpJoJEyZAURRMmzaNgTlKec1t1xUWFuLvf/87qqqq0L9/f1x11VW47bbbcNxxx+HAgQMhB20RpZpg7bqnn34aBQUFuPjiizF+/HjcddddGDlyJJ5++mluPkspKZp23SWXXIIRI0bg448/Rt++fXH77bdj8uTJGDRoEEaNGmXOCVBYDCxQ0ikoKMC5554LQN3c5bTTTgt7/KRJk+D1euH1erlkC6WsXr16oaSkBABQWloKh8PR6Bj9NPpQgQWAZYoonOzsbNx5552ora31jSTVTJw4EYqiwOPx4JxzzkFOTo5JqSQy1+mnn445c+agU6dOeO211/D666/j2GOPxbJly9CxY8egr2nfvj1OPvlkeDwe5OXl4cwzz0xsooksJBbtuksuuQTvvPMOunTpgpdffhkvv/wyBg8ejPnz5yMzMzN+iSeykWDtup49e+LLL7/EmDFj8PHHH+Opp56Cw+HAl19+iU6dOpmcYqLEi6Zdl5aWhvfeew+33XYbdu/ejSeeeAJLly7F//t//w9/+ctfTDoDCkcRETE7EUREREREREREREREZA+csUBERERERERERERERIYxsEBERERERERERERERIYxsEBERERERERERERERIYxsEBERERERERERERERIYxsEBERERERERERERERIYxsEBERERERERERERERIYxsEBERERERERERERERIYxsEBERERERERERERERIYxsEBERERERERERERERIYxsEBERERERERERERERIYxsEBERERERERERERERIYxsEBERERERERERERERIb9f2mhKBRohT6vAAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig = corner.corner(\n", - " samples,\n", - " labels=[p.name for p in omp.params],\n", - " truths=true_params,\n", - " label_kwargs={\"fontsize\": 14},\n", - ")\n", - "_ = corner.corner(prior.rvs(5000), fig=fig, color=\"tab:orange\")" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "visualize-results", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig, ax = plt.subplots(1, 1, figsize=(8, 4))\n", - "\n", - "angles_plot = np.rad2deg(obs.visualization_workspace.angles)\n", - "ax.errorbar(np.rad2deg(obs.x), obs.y, yerr=obs.y_stat_err, fmt=\"o\", label=\"Mock data\")\n", - "ax.plot(angles_plot, y_true, label=\"Truth\", linewidth=2, alpha=0.8)\n", - "ax.fill_between(\n", - " angles_plot, y_low, y_high, alpha=0.4, label=\"90% predictive posterior band\"\n", - ")\n", - "ax.set_xlabel(\"Angle (deg)\")\n", - "ax.set_ylabel(\"d$\\\\sigma$/d$\\\\Omega$ (b/sr)\")\n", - "ax.legend()\n", - "ax.set_yscale(\"log\")\n", - "fig.tight_layout()" - ] - }, - { - "cell_type": "markdown", - "id": "af2b08c0-ab30-4be7-9111-ef051d822066", - "metadata": {}, - "source": [ - "Note that the predictive posterior has excellent coverage of the training data, even though the parameter inference was not perfect. One must be wary of infering parameters from optical potentials, as multiple different sets of parameter values can produce the same cross section! " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "d3325c9b-5ce5-4dd8-899a-be008fd5b86b", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.13.5" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} \ No newline at end of file diff --git a/examples/alpha_ca_error_model_comparison.ipynb b/examples/alpha_ca_error_model_comparison.ipynb new file mode 100644 index 0000000..8857307 --- /dev/null +++ b/examples/alpha_ca_error_model_comparison.ipynb @@ -0,0 +1,1252 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "6999ba52", + "metadata": {}, + "source": [ + "# A Gaussian-process discrepancy for $\\alpha + {}^{44}$Ca elastic scattering\n", + "\n", + "This notebook takes one real measurement, one optical potential and one piece of prior knowledge about where that potential goes wrong, and asks whether the data agree with it.\n", + "\n", + "The data are differential elastic cross sections, as a ratio to the [Rutherford](https://en.wikipedia.org/wiki/Rutherford_scattering) cross section, for $^{44}$Ca($\\alpha,\\alpha$) at 29 MeV. They come from [EXFOR F0567](https://www-nds.iaea.org/exfor/servlet/X4sSearch5?EntryID=150567), measured by [Oeschler *et al.*, Phys. Rev. Lett. **28**, 694 (1972)](https://journals.aps.org/prl/abstract/10.1103/PhysRevLett.28.694), who report no uncertainties at all. A four-parameter Woods–Saxon potential describes the forward angles well and the backward angles much less well, and that disagreement is what we want to model.\n", + "\n", + "We'll model it in two layers. The first is an error model after the `jitr` [$\\alpha$ + Ca Bayesian calibration](https://github.com/beykyle/jitr/blob/main/examples/notebooks/alpha_ca_calibration.ipynb), the same one `local_optical_model_calibration` uses: an inferred relative error uncorrelated from point to point, of log-space size $\\sigma_A$, and one common to all points, $\\sigma_B$. The second is a mean-zero [Gaussian process](https://en.wikipedia.org/wiki/Gaussian_process) discrepancy in the style of [Kennedy & O'Hagan (2001)](https://doi.org/10.1111/1467-9868.00294), which describes the correlated part of the misfit: the part neighbouring angles share. We'll compare just two versions of that discrepancy:\n", + "\n", + "1. one whose size is the **same at every angle**;\n", + "2. one whose size **grows as a power of the momentum transfer** $q$, with the power inferred from the data.\n", + "\n", + "The second encodes a physical expectation: large momentum transfer is sensitive to shorter distances, where a simple Woods–Saxon shape is least constrained, so we trust the potential forward and are suspicious of it backward. We'll ask the data which version they prefer by [Bayesian evidence](https://en.wikipedia.org/wiki/Marginal_likelihood), then look at what each one predicts on a fine angular grid, and how well calibrated those predictions are.\n", + "\n", + "It's worth looking at the [`jitr` quickstart tutorials](https://beykyle.github.io/jitr/getting-started.html) alongside this one, since we reuse their potential and priors.\n", + "\n", + "Recipes: 7, 10, 11, 13, 17, 18, 40 (see [the recipes](/recipes.md))" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "fe61dfe1", + "metadata": {}, + "outputs": [], + "source": [ + "import time\n", + "\n", + "import corner\n", + "import jax.numpy as jnp\n", + "import jitr\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "import plotstyle\n", + "import pocomc\n", + "import tinygp\n", + "from budget import budget # sampler budgets, cut in CI's quick run\n", + "from jitr.optical_potentials.potential_forms import (\n", + " coulomb_charged_sphere,\n", + " woods_saxon_safe,\n", + ")\n", + "from scipy import stats\n", + "\n", + "import rxmc as rx\n", + "from rxmc import terms as T\n", + "from rxmc import transforms as tf\n", + "\n", + "plotstyle.use()" + ] + }, + { + "cell_type": "markdown", + "id": "c0cf56ce", + "metadata": {}, + "source": [ + "## The data\n", + "\n", + "We'll take every fourth angle of the $^{44}$Ca set. That leaves 73 points between 15 and 174 degrees, which is plenty to pin down the diffraction pattern, and it keeps the whole notebook to about half an hour. A ratio to Rutherford is dimensionless, so there are no units to convert, and the kinematics the model needs go in `meta`. There are no reported errors, so the error column is zeros, and every uncertainty below is inferred.\n", + "\n", + "We'll also need the momentum transfer $q = 2k\\sin(\\theta/2)$, so we compute the wavenumber $k$ from the reaction's kinematics now." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "92ec14d2", + "metadata": {}, + "outputs": [], + "source": [ + "df = pd.read_csv(\"data/alpha_ca_ratio_ruth.csv\")\n", + "df = df[df[\"target\"] == \"Ca44\"].iloc[::4]\n", + "reaction = jitr.reactions.ElasticReaction(target=(44, 20), projectile=(4, 2))\n", + "E_lab = 29.0\n", + "k = reaction.kinematics(E_lab).k\n", + "meta = {\"reaction\": reaction, \"Elab\": E_lab, \"quantity\": \"dXS/dRuth\"}\n", + "angles = np.deg2rad(df[\"angle_cm_deg\"].to_numpy())\n", + "ratio = df[\"ratio_to_rutherford\"].to_numpy()\n", + "data = rx.Dataset(\n", + " angles, ratio, np.zeros(ratio.size), label=\"44Ca(a,a) 29 MeV\", meta=meta\n", + ")\n", + "x_fine = np.deg2rad(np.linspace(10.0, 178.0, 220))" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "5a03da60", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "73 points between 15 and 174 degrees, q from 0.56 to 4.32 fm^-1\n" + ] + } + ], + "source": [ + "q_data = rx.reactions.momentum_transfer(angles, k)\n", + "print(\n", + " f\"{data.n} points between {np.rad2deg(angles.min()):.0f} and \"\n", + " f\"{np.rad2deg(angles.max()):.0f} degrees, \"\n", + " f\"q from {q_data.min():.2f} to {q_data.max():.2f} fm^-1\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "b2e6b303", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "ax.plot(np.rad2deg(angles), ratio, \"o\", ms=3, color=\"k\")\n", + "ax.set(\n", + " xlabel=r\"$\\theta_{cm}$ [deg]\",\n", + " ylabel=r\"$\\left(\\frac{d\\sigma}{d\\Omega}\\right) / \\left(\\frac{d\\sigma}{d\\Omega}\\right)_{\\mathrm{Rutherford}}$ [dimensionless]\",\n", + " yscale=\"log\",\n", + " title=r\"$^{44}$Ca($\\alpha,\\alpha$) at 29 MeV, Oeschler et al. (1972)\",\n", + ")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "f4bbc9b2", + "metadata": {}, + "source": [ + "## The optical model\n", + "\n", + "We use the same model as the `jitr` quickstart: a [Woods–Saxon](https://en.wikipedia.org/wiki/Woods%E2%80%93Saxon_potential) potential, plus the Coulomb potential of a uniformly charged sphere of radius $1.3\\,A^{1/3}$ fm, with radii measured in units of $A^{1/3}$ fm. The real and imaginary volume terms share one geometry, which leaves four free parameters: $V$, $W$, $r$ and $a$. For priors we take the quickstart's typical $\\alpha$-nucleus values, truncated at zero so the depths stay physical, and we bound the geometry to $0.8 \\le r \\le 2$ and $0.2 \\le a \\le 1$ fm (recipe 13).\n", + "\n", + "`ElasticXS` solves on a radial basis whose size is set by `wavelengths_beyond_range` and `zeros_per_node`, with partial waves up to `lmax`. We keep the basis at its defaults and use `lmax=30`, and the cell after the model checks that this is accurate enough: against a solution converged in all three settings, it is off by about 0.2 % at a typical angle and by at most 7 %, at the deepest diffraction minimum. That is far smaller than any of the errors we're about to infer, and each evaluation is tens of times faster (the exact factor varies with the machine's load)." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "91f59c49", + "metadata": {}, + "outputs": [], + "source": [ + "A13 = 44 ** (1 / 3)\n", + "\n", + "\n", + "def central(r, V, W, R, a):\n", + " return -(V + 1j * W) * woods_saxon_safe(r, R * A13, a)\n", + "\n", + "\n", + "def coulomb(r):\n", + " return coulomb_charged_sphere(\n", + " r, reaction.target.Z * reaction.projectile.Z, 1.3 * A13\n", + " )\n", + "\n", + "\n", + "params = [\n", + " rx.Parameter(\"V\", prior=stats.norm(150.0, 20.0), bounds=(0.0, np.inf), latex=\"V\"),\n", + " rx.Parameter(\"W\", prior=stats.norm(20.0, 10.0), bounds=(0.0, np.inf), latex=\"W\"),\n", + " rx.Parameter(\"r\", prior=stats.norm(1.4, 0.3), bounds=(0.8, 2.0), latex=\"r\"),\n", + " rx.Parameter(\"a\", prior=stats.norm(0.5, 0.2), bounds=(0.2, 1.0), latex=\"a\"),\n", + "]\n", + "omp = rx.reactions.ElasticXS(\n", + " \"dXS/dRuth\",\n", + " central,\n", + " None, # an alpha has no spin-orbit interaction\n", + " lambda ws, *x: (tuple(x), (), ()),\n", + " params,\n", + " coulomb=coulomb,\n", + " lmax=30,\n", + ")\n", + "alpha_0 = np.array([150.0, 20.0, 1.4, 0.5])" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "d95b3b0e", + "metadata": {}, + "outputs": [], + "source": [ + "# we always draw the model on a fine grid: evaluated only at the (downsampled)\n", + "# data angles, the diffraction pattern aliases and the curve looks ragged\n", + "on_fine = omp.bind(x_fine, meta)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "3a14a8ef", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "log error of the default solver: median 0.0016, max 0.069; 38 times faster per evaluation\n" + ] + } + ], + "source": [ + "# the solver's accuracy at alpha_0, against a solution converged in lmax and in\n", + "# both basis settings\n", + "converged = rx.reactions.ElasticXS(\n", + " \"dXS/dRuth\",\n", + " central,\n", + " None,\n", + " lambda ws, *x: (tuple(x), (), ()),\n", + " params,\n", + " coulomb=coulomb,\n", + " lmax=60,\n", + " zeros_per_node=12,\n", + " wavelengths_beyond_range=4.0,\n", + ")\n", + "on_converged = converged.bind(x_fine, meta)\n", + "on_fine(*alpha_0), on_converged(*alpha_0) # compile both before timing\n", + "\n", + "\n", + "def seconds(f, n=5):\n", + " # np.asarray waits for JAX's asynchronous result, so the clock sees the solve\n", + " t0 = time.perf_counter()\n", + " for _ in range(n):\n", + " y = np.asarray(f(*alpha_0))\n", + " return y, (time.perf_counter() - t0) / n\n", + "\n", + "\n", + "y_default, t_default = seconds(on_fine)\n", + "y_converged, t_converged = seconds(on_converged)\n", + "error = np.abs(np.log(y_default / y_converged))\n", + "print(\n", + " f\"log error of the default solver: median {np.median(error):.4f}, max {error.max():.3f}; \"\n", + " f\"{t_converged / t_default:.0f} times faster per evaluation\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "5fe1f329", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "ax.plot(np.rad2deg(angles), ratio, \"o\", ms=3, color=\"k\", label=\"data\")\n", + "ax.plot(\n", + " np.rad2deg(x_fine),\n", + " on_fine(*alpha_0),\n", + " color=plotstyle.COLOURS[0],\n", + " label=r\"the potential at $\\alpha_0$\",\n", + ")\n", + "ax.set(\n", + " xlabel=r\"$\\theta_{cm}$ [deg]\",\n", + " ylabel=r\"$\\left(\\frac{d\\sigma}{d\\Omega}\\right) / \\left(\\frac{d\\sigma}{d\\Omega}\\right)_{\\mathrm{Rutherford}}$ [dimensionless]\",\n", + " yscale=\"log\",\n", + " title=\"Before fitting anything\",\n", + ")\n", + "ax.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "f58bf0a9", + "metadata": {}, + "source": [ + "## The error model\n", + "\n", + "The data span three decades, and the disagreement between a local potential and real data is naturally *relative*: a fraction of the cross section, whatever its size. Relative errors become additive in log space, so that's where we'll compare (recipe 10). `space=tf.log` transforms the data once and every prediction along with it.\n", + "\n", + "### The inferred errors, $\\sigma_A$ and $\\sigma_B$\n", + "\n", + "After `jitr`, we think of each measured point as the prediction multiplied by two independent [log-normal](https://en.wikipedia.org/wiki/Log-normal_distribution) factors of median one, $y_i = y_{m,i}\\,F_i\\,G$, with $\\log F_i \\sim \\mathcal{N}(0, \\sigma_A^2)$ uncorrelated from point to point and $\\log G \\sim \\mathcal{N}(0, \\sigma_B^2)$ common to all points, like an unknown normalisation. In log space that is\n", + "\n", + "$$\\Sigma^{\\log}_{ij} = \\sigma_A^2\\,\\delta_{ij} + \\sigma_B^2,$$\n", + "\n", + "exactly `T.noise` plus `T.offset`; `local_optical_model_calibration` derives it, and explains why median one. $\\sigma_A$ and $\\sigma_B$ are log-space standard deviations, a factor $e^{\\pm\\sigma}$ at one standard deviation, and each gets a log-uniform prior between 0.05 and 2.\n", + "\n", + "We need $\\sigma_A$ for more than bookkeeping. These data were digitised from a figure with deep diffraction minima, and their log residuals scatter from one angle to the next by tens of per cent. An uncorrelated term is the natural home for that scatter; without one, the discrepancy would have to become rough enough to chase every point.\n", + "\n", + "### The discrepancy\n", + "\n", + "On top of $\\sigma_A$ and $\\sigma_B$ we add a Matérn(5/2) [kernel](https://en.wikipedia.org/wiki/Mat%C3%A9rn_covariance_function) (recipe 7), evaluated in the scaled angle $u = \\theta/\\pi$. It's tempting to evaluate it in $q$ itself, but $q \\propto \\sin(\\theta/2)$ flattens out at backward angles: there, neighbouring measured angles are almost on top of each other in $q$, and a kernel would insist they agree exactly. In $u$ the measured angles are much more evenly spread, though not perfectly: the digitised angles are spaced anywhere from 0.06 to 6.7 degrees apart.\n", + "\n", + "The correlation length $\\ell$ gets a log-uniform prior between the two natural extremes of this dataset: the median spacing between neighbouring measured angles, and the full angular range they cover.\n", + "\n", + "The two versions differ only in the amplitude $\\sigma_\\delta$ that scales the kernel, and that's where $q$ comes in:\n", + "\n", + "| label | discrepancy amplitude |\n", + "|---|---|\n", + "| `constant` | $\\sigma_\\delta = A$ at every angle |\n", + "| `power of q` | $\\sigma_\\delta = A\\,(q/2k)^{p} = A \\sin^{p}(\\theta/2)$, with $p$ inferred |\n", + "\n", + "In the second, $A$ is the size of the discrepancy at 180 degrees and $p$ says how quickly it grows towards there; $p$ near zero would mean the data see no growth at all. $A$, also a log-space standard deviation, is log-uniform between 0.05 and 2, and $p$ is uniform between 0 and 16 (recipe 13), which allows anything from no growth to growth confined to the last few tens of degrees; we'll check whether the data press against that bound." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "6a54d545", + "metadata": {}, + "outputs": [], + "source": [ + "comp = rx.Comparison(data, omp, space=tf.log)\n", + "\n", + "\n", + "def log_uniform(lo, hi):\n", + " return stats.uniform(np.log(lo), np.log(hi) - np.log(lo))\n", + "\n", + "\n", + "# point-to-point and common relative errors, as log-space standard deviations\n", + "log_sigma_A = rx.Parameter(\n", + " \"log_sigma_A\", prior=log_uniform(0.05, 2.0), latex=r\"\\log\\sigma_A\"\n", + ")\n", + "log_sigma_B = rx.Parameter(\n", + " \"log_sigma_B\", prior=log_uniform(0.05, 2.0), latex=r\"\\log\\sigma_B\"\n", + ")\n", + "error_terms = [T.noise(log_sigma_A), T.offset(log_sigma_B)]" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "7cab4bee", + "metadata": {}, + "outputs": [], + "source": [ + "def by_angle(x):\n", + " return np.asarray(x, dtype=float) / np.pi\n", + "\n", + "\n", + "u_data = np.sort(by_angle(angles))\n", + "shortest, longest = np.median(np.diff(u_data)), u_data[-1] - u_data[0]\n", + "log_ell = rx.Parameter(\n", + " \"log_ell\", prior=log_uniform(shortest, longest), latex=r\"\\log\\ell\"\n", + ")\n", + "log_A = rx.Parameter(\"log_A\", prior=log_uniform(0.05, 2.0), latex=r\"\\log A\")\n", + "log_A_q = rx.Parameter(\"log_A_q\", prior=log_uniform(0.05, 2.0), latex=r\"\\log A\")\n", + "power = rx.Parameter(\"p\", prior=stats.uniform(0.0, 16.0), latex=\"p\")\n", + "\n", + "\n", + "def power_of_q(c, log_amplitude, p):\n", + " # c.x is u = theta / pi, so q / 2k = sin(theta / 2) = sin(pi u / 2)\n", + " return jnp.exp(log_amplitude) * jnp.sin(0.5 * jnp.pi * c.x) ** p\n", + "\n", + "\n", + "def matern(log_ell):\n", + " return tinygp.kernels.Matern52(scale=jnp.exp(log_ell))\n", + "\n", + "\n", + "gp_constant = T.kernel(\n", + " matern,\n", + " coords=by_angle,\n", + " amplitude=T.constant_amplitude,\n", + " amplitude_params=(log_A,),\n", + " params=[log_ell],\n", + ")\n", + "gp_power = T.kernel(\n", + " matern,\n", + " coords=by_angle,\n", + " amplitude=power_of_q,\n", + " amplitude_params=(log_A_q, power),\n", + " params=[log_ell],\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "0fce2c51", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "length-scale prior on u: 0.0099 (the median spacing) to 0.883 (the full range)\n" + ] + } + ], + "source": [ + "print(\n", + " f\"length-scale prior on u: {shortest:.4f} (the median spacing) to \"\n", + " f\"{longest:.3f} (the full range)\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "f5f42a8b", + "metadata": {}, + "outputs": [], + "source": [ + "gps = {\"constant\": gp_constant, \"power of q\": gp_power}\n", + "problems = {\n", + " name: rx.Problem(\n", + " [rx.Constraint([comp], terms=[*error_terms, gp], statistical=False)]\n", + " )\n", + " for name, gp in gps.items()\n", + "}\n", + "colours = {\"constant\": plotstyle.COLOURS[1], \"power of q\": plotstyle.COLOURS[0]}\n", + "label = {\"constant\": \"constant\", \"power of q\": r\"power of $q$\"} # for plots" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "c707911e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "constant columns: ['V', 'W', 'r', 'a', 'log_sigma_A', 'log_sigma_B', 'log_ell', 'log_A']\n", + "power of q columns: ['V', 'W', 'r', 'a', 'log_sigma_A', 'log_sigma_B', 'log_ell', 'log_A_q', 'p']\n" + ] + } + ], + "source": [ + "for name, p in problems.items():\n", + " print(f\"{name:10s} columns: {p.names}\")" + ] + }, + { + "cell_type": "markdown", + "id": "2f17a91f", + "metadata": {}, + "source": [ + "## Running the calibration\n", + "\n", + "Optical-model posteriors are strongly correlated and, for $\\alpha$ particles, multimodal (as we'll see), so we'll use [preconditioned Monte Carlo](https://pocomc.readthedocs.io/en/latest/background.html) through [pocomc](https://pocomc.readthedocs.io/) ([Karamanis et al. 2022](https://doi.org/10.1093/mnras/stac2272)). It moves a population of particles from the prior to the posterior through a sequence of tempered distributions, learning a [normalizing flow](https://en.wikipedia.org/wiki/Flow-based_generative_model) that undoes the correlations as it goes, and it computes the evidence we're about to compare as a by-product. On `alpha_gp`, the benchmark's copy of the power-of-$q$ model, it is the only sampler that agrees with the reference, at eight times its default resolution; below that, its weight on the posterior's deeper family swings from 0.66 to 0.96 between seeds. The reference is itself pooled pocomc, and an independent check by dynesty puts 0.79 rather than 0.74 in that family, so the agreement is partly pocomc's with itself ([benchmarks](/benchmarks.md)). `n_seeds` below sets how many runs each model gets; we use one." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "f3d12040", + "metadata": {}, + "outputs": [], + "source": [ + "def smc(problem, seed, n_effective=budget(4096), n_active=budget(2048)):\n", + " \"\"\"pocomc on the unit cube: ``prior_transform`` maps it onto the prior, so\n", + " the evidence is the problem's own. Eight times pocomc's default\n", + " resolution: at lower settings its split between the separated modes of an\n", + " optical-model posterior swings from seed to seed (docs/benchmarks.md).\"\"\"\n", + "\n", + " def log_likelihood(u): # every particle in one vmapped call\n", + " return problem.log_likelihood_batch(problem.prior_transform_batch(u))\n", + "\n", + " sampler = pocomc.Sampler(\n", + " pocomc.Prior([stats.uniform(0.0, 1.0)] * problem.ndim),\n", + " log_likelihood,\n", + " n_effective=n_effective,\n", + " n_active=n_active,\n", + " vectorize=True,\n", + " random_state=seed,\n", + " )\n", + " sampler.run(n_total=budget(4096), n_evidence=budget(4096), progress=False)\n", + " u, _, _ = sampler.posterior(resample=True) # equal-weight draws\n", + " logz, logz_err = sampler.evidence()\n", + " return {\n", + " \"samples\": problem.prior_transform_batch(u),\n", + " \"logz\": logz,\n", + " \"logz_err\": logz_err,\n", + " \"calls\": sampler.calls,\n", + " }" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "4cadad4e", + "metadata": {}, + "outputs": [], + "source": [ + "n_seeds = 1 # runs per model; runtime scales with it; raise it to see the spread\n", + "runs = {\n", + " name: [smc(p, seed=10 * i + s) for s in range(n_seeds)]\n", + " for i, (name, p) in enumerate(problems.items())\n", + "}\n", + "# the runs pooled: each is an equal-weight sample\n", + "samples = {name: np.vstack([r[\"samples\"] for r in rs]) for name, rs in runs.items()}" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "c213d49e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "constant log Z per run: -91.44 +/- 0.03 (270336 calls in all)\n", + "power of q log Z per run: -84.48 +/- 0.04 (356352 calls in all)\n" + ] + } + ], + "source": [ + "for name, rs in runs.items():\n", + " print(\n", + " f\"{name:10s} log Z per run: \"\n", + " + \", \".join(f\"{r['logz']:.2f} +/- {r['logz_err']:.2f}\" for r in rs)\n", + " + f\" ({sum(r['calls'] for r in rs)} calls in all)\"\n", + " )" + ] + }, + { + "cell_type": "markdown", + "id": "b07bf0f2", + "metadata": {}, + "source": [ + "## Evidence, and what a Bayes factor is\n", + "\n", + "The [marginal likelihood](https://en.wikipedia.org/wiki/Marginal_likelihood), or evidence, is the probability a model assigned to the data before we asked which parameters fit best. We get it by averaging the likelihood over the prior:\n", + "\n", + "$$Z = \\int p(\\mathbf{y} \\mid \\alpha)\\, p(\\alpha)\\, \\mathrm{d}\\alpha .$$\n", + "\n", + "Because it's an average, it rewards models that put their probability where the data actually landed, and it penalises models that spread probability thinly over parameter space they turned out not to need. It's an automatic [Occam's razor](https://en.wikipedia.org/wiki/Occam%27s_razor): the power-of-$q$ amplitude has one more parameter than the constant one, and it only wins if that parameter earns its keep. The ratio of two evidences is the [Bayes factor](https://en.wikipedia.org/wiki/Bayes_factor), and it tells us how much the data should shift our relative belief in one model over the other.\n", + "\n", + "Two practical notes. A Bayes factor depends on the priors, not just on how good the best fit is, so the prior ranges we stated above are part of the claim. And since we fitted in log space, we add `problem.log_jacobian()` so that $\\log Z$ is a density for the measured ratios themselves (recipe 18). Both models share the same Jacobian, so it cancels in their Bayes factor. `logz_summary` takes the error on each $\\log Z$ as the larger of the half-spread between the runs, if there are several, and the runs' mean quoted error, and `compare_logz` calls the result a tie unless the difference is more than twice the combined error." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "efffbe81", + "metadata": {}, + "outputs": [], + "source": [ + "logz = {\n", + " name: rx.diagnostics.logz_summary(\n", + " [r[\"logz\"] + problems[name].log_jacobian() for r in runs[name]],\n", + " [r[\"logz_err\"] for r in runs[name]],\n", + " )\n", + " for name in problems\n", + "}\n", + "verdict = rx.diagnostics.compare_logz(logz[\"power of q\"], logz[\"constant\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "578ce107", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "constant log Z = 223.04 +/- 0.03 (density of the ratios, 1 run)\n", + "power of q log Z = 229.99 +/- 0.04 (density of the ratios, 1 run)\n", + "\n", + "power of q vs constant: dlogZ = 6.96 +/- 0.05 -> power of q favoured\n" + ] + } + ], + "source": [ + "for name, (mean, err, _) in logz.items():\n", + " print(\n", + " f\"{name:10s} log Z = {mean:8.2f} +/- {err:.2f} (density of the ratios, \"\n", + " f\"{len(runs[name])} run{'s' if len(runs[name]) > 1 else ''})\"\n", + " )\n", + "words = {\"a\": \"power of q favoured\", \"b\": \"constant favoured\", \"tie\": \"a tie\"}\n", + "print(\n", + " f\"\\npower of q vs constant: dlogZ = {verdict['dlogZ']:.2f} +/- {verdict['err']:.2f}\"\n", + " f\" -> {words[verdict['verdict']]}\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "a6773971", + "metadata": {}, + "source": [ + "The data prefer the growing amplitude: $\\log Z$ is 230.0 against 223.0, a difference of $6.96 \\pm 0.05$, far past the two-sigma bar `compare_logz` insists on. A log Bayes factor of 7.0 means the data raise the odds of the power-of-$q$ model over the constant one by a factor of roughly $e^{7.0} \\approx 1100$, even after it pays for its extra parameter. How much it pays depends on the prior range of $p$: a flat prior over $[0, 16]$ costs the growing model more than one over $[0, 8]$ would, so that range is part of the claim.\n", + "\n", + "The errors above are pocomc's own, from one run per model, and a single run's quoted error is often an underestimate, since the spread between runs can exceed it; raising `n_seeds` runs each model more than once and lets `logz_summary` take that spread into account, at a cost that grows in proportion. On `alpha_gp`, the benchmark's copy of the power-of-$q$ model, three runs at this setting give $\\log Z$ of $-84.50$, $-84.52$ and $-84.55$ (this notebook's run: $-84.48$), a spread of a few hundredths, far below the difference of 7." + ] + }, + { + "cell_type": "markdown", + "id": "37c0afce", + "metadata": {}, + "source": [ + "### The potential under each discrepancy\n", + "\n", + "The discrepancy model changes what the data can say about the potential, so let's overlay the two posteriors for $V$, $W$, $r$ and $a$." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "360da7f8", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "labels = [f\"${q.latex}$\" for q in params]\n", + "fig = None\n", + "for name, p in problems.items():\n", + " fig = corner.corner(\n", + " samples[name][:, p.columns(params)],\n", + " fig=fig,\n", + " labels=labels,\n", + " **plotstyle.corner_kwargs(\n", + " color=colours[name],\n", + " fill_contours=False,\n", + " plot_density=False,\n", + " show_titles=False,\n", + " levels=(0.68, 0.95),\n", + " ),\n", + " )\n", + "fig.legend(\n", + " handles=[plt.Line2D([], [], color=c, label=label[n]) for n, c in colours.items()],\n", + " loc=\"upper right\",\n", + " bbox_to_anchor=(0.95, 0.95),\n", + " fontsize=9,\n", + ")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "eb4d7105", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "constant fraction of draws in the deeper family (V > 145 MeV): 0.45 pooled over 1 run(s); per run 0.45\n", + "power of q fraction of draws in the deeper family (V > 145 MeV): 0.73 pooled over 1 run(s); per run 0.73\n" + ] + } + ], + "source": [ + "for name, p in problems.items():\n", + " col = p.columns(params[0])\n", + " per_run = [np.mean(r[\"samples\"][:, col] > 145) for r in runs[name]]\n", + " print(\n", + " f\"{name:10s} fraction of draws in the deeper family (V > 145 MeV): \"\n", + " f\"{np.mean(samples[name][:, col] > 145):.2f} pooled over {len(per_run)} run(s); \"\n", + " \"per run \" + \", \".join(f\"{f:.2f}\" for f in per_run)\n", + " )" + ] + }, + { + "cell_type": "markdown", + "id": "a7f0240b", + "metadata": {}, + "source": [ + "The two posteriors for the potential don't agree on which family of potentials to use. The posterior for $V$ splits between a shallow family near 125 MeV and a deeper one near 165 MeV. That's the well-known discrete ambiguity of $\\alpha$-nucleus potentials: depths with different numbers of interior nodes in the scattering wavefunction give nearly the same cross section. With the constant amplitude, 45 % of the draws are in the deeper family; with the power-of-$q$ amplitude, 73 % are, and $r$ and $a$ tighten with it. The weight of well-separated modes is the hardest thing for a sampler to pin down, so it is worth checking: the [benchmark](/benchmarks.md)'s three runs of the power-of-$q$ model at this setting put 71 to 74 % in the deeper family (its reference 74 %, the independent dynesty check 79 %), and at a quarter of the resolution 66 to 96 %, depending on the seed. So the growing amplitude shifts the weight towards the deeper family by far more than a run's scatter, without removing the shallow one." + ] + }, + { + "cell_type": "markdown", + "id": "6eb7d309", + "metadata": {}, + "source": [ + "### The inferred errors and the discrepancy's hyperparameters\n", + "\n", + "Next, the error model itself: how large $\\sigma_A$, $\\sigma_B$ and the discrepancy came out, over what correlation length, and whether the data can tell the uncorrelated error and the discrepancy apart." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "c9b6b639", + "metadata": {}, + "outputs": [], + "source": [ + "hyper, corr = {}, {}\n", + "for name, p in problems.items():\n", + " s = samples[name]\n", + " amp = log_A if name == \"constant\" else log_A_q\n", + " pars = (\n", + " (\"sigma_A\", log_sigma_A),\n", + " (\"sigma_B\", log_sigma_B),\n", + " (\"ell\", log_ell),\n", + " (\"A\", amp),\n", + " )\n", + " # every one a log-space standard deviation (ell aside): directly comparable\n", + " hyper[name] = {\n", + " lab: np.percentile(np.exp(s[:, p.columns(par)].ravel()), [16, 50, 84])\n", + " for lab, par in pars\n", + " }\n", + " # are the uncorrelated error and the discrepancy told apart?\n", + " cols = [p.columns(par).item() for par in (log_sigma_A, amp, log_ell)]\n", + " corr[name] = np.corrcoef(s[:, cols].T)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "6c91234f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "constant\n", + " sigma_A = 0.535 (68 % interval 0.463 to 0.622)\n", + " sigma_B = 0.281 (68 % interval 0.096 to 0.804)\n", + " ell = 0.022 (68 % interval 0.015 to 0.056)\n", + " A = 0.633 (68 % interval 0.502 to 0.799)\n", + " posterior correlations: log sigma_A with log A -0.10, with log ell +0.53; log A with log ell +0.32\n", + "power of q\n", + " sigma_A = 0.488 (68 % interval 0.441 to 0.542)\n", + " sigma_B = 0.394 (68 % interval 0.189 to 0.919)\n", + " ell = 0.025 (68 % interval 0.019 to 0.032)\n", + " A = 1.492 (68 % interval 1.132 to 1.811)\n", + " posterior correlations: log sigma_A with log A -0.14, with log ell +0.06; log A with log ell +0.33\n" + ] + } + ], + "source": [ + "for name, rows in hyper.items():\n", + " print(name)\n", + " for lab, (lo, med, hi) in rows.items():\n", + " print(f\" {lab:7s} = {med:.3f} (68 % interval {lo:.3f} to {hi:.3f})\")\n", + " r = corr[name]\n", + " print(\n", + " \" posterior correlations: log sigma_A with log A \"\n", + " f\"{r[0, 1]:+.2f}, with log ell {r[0, 2]:+.2f}; log A with log ell {r[1, 2]:+.2f}\"\n", + " )" + ] + }, + { + "cell_type": "markdown", + "id": "7ce3ca63", + "metadata": {}, + "source": [ + "Both models agree that the data scatter a lot from one angle to the next: $\\sigma_A$ comes out at 0.54 (constant) and 0.49 (power of $q$), a factor of about 1.6 to 1.7 either way, which is the digitisation scatter we expected. Some of it may be error in angle rather than in the ratio: the curve was traced from a figure with near-vertical stretches around the diffraction minima, where a small error in angle is a large error in the ratio, and a $\\sigma_A$ that is the same at every angle can only average over that. The common error $\\sigma_B$ is poorly constrained in both, between roughly 0.1 and 0.9; a single measurement can't tell a common shift of all its points apart from the potential moving.\n", + "\n", + "All three amplitudes are log-space standard deviations, so they compare directly. The constant model's discrepancy, $A = 0.63$, is a little *larger* than its uncorrelated error, at every angle. The growing one is negligible forward and reaches $A = 1.49$ at 180 degrees, about three times $\\sigma_A$. Can the data tell the uncorrelated error and the discrepancy apart? Mostly yes: $\\log\\sigma_A$ and $\\log A$ are only weakly correlated in either posterior ($-0.10$ and $-0.14$). In the constant model $\\sigma_A$ does trade against the correlation length ($+0.53$): a longer correlation length leaves more of the point-to-point scatter to $\\sigma_A$.\n", + "\n", + "The correlation length comes out short in both, $\\ell \\approx 0.02$ in $u$: two to three median point spacings, near the bottom of its prior. So the discrepancy is not a slow drift. It describes departures that change on the scale of the diffraction pattern." + ] + }, + { + "cell_type": "markdown", + "id": "1426eb12", + "metadata": {}, + "source": [ + "### How fast does the discrepancy grow?\n", + "\n", + "The power $p$ is the one parameter that says whether the growth with $q$ is real. Its prior is flat between 0 and 16." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "571262cb", + "metadata": {}, + "outputs": [], + "source": [ + "p_q = problems[\"power of q\"]\n", + "power_draws = samples[\"power of q\"][:, p_q.columns(power)].ravel()\n", + "power_lo, power_med, power_hi = np.percentile(power_draws, [16, 50, 84])" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "94d95f16", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "p = 7.50 (68 % interval 4.41 to 11.52)\n" + ] + } + ], + "source": [ + "print(f\"p = {power_med:.2f} (68 % interval {power_lo:.2f} to {power_hi:.2f})\")" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "828bd51e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(5.2, 3.2))\n", + "ax.hist(\n", + " power_draws,\n", + " bins=40,\n", + " range=(0, 16),\n", + " density=True,\n", + " color=colours[\"power of q\"],\n", + " alpha=0.7,\n", + " label=\"posterior\",\n", + ")\n", + "ax.axhline(1 / 16, color=\"0.4\", ls=\"--\", label=\"prior\")\n", + "ax.set(xlabel=\"$p$\", ylabel=\"density\", title=\"The power of $q$ in the amplitude\")\n", + "ax.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "07372261", + "metadata": {}, + "source": [ + "The data want real growth: $p = 7.5$, with a 68 % interval from 4.4 to 11.5, and the posterior falls to zero well above $p = 0$. How *steep* the growth is, they don't settle: the posterior is broad, peaks near 6 and has a long upper tail, though it falls to about a sixth of the prior's height by the bound at 16, so the bound does not set the interval. Whatever the exact power, the discrepancy at 20 degrees is tiny: with $p \\approx 7.5$, $\\sin^{7.5}(10^\\circ) \\approx 2 \\times 10^{-6}$ of its size at 180 degrees, so in effect the data say the potential is almost exact forward and increasingly wrong backward." + ] + }, + { + "cell_type": "markdown", + "id": "6bf38e5d", + "metadata": {}, + "source": [ + "## What each model predicts (recipes 17 and 40)\n", + "\n", + "Now we'll draw the posterior predictive on a fine angular grid with `rx.predictive.grid_draws`, which re-evaluates every covariance term at the new angles from its own definition. For each model there are two different things we might draw:\n", + "\n", + "1. **The model only**: the potential, $y_m(\\theta;\\alpha)$ with the parameters drawn from the posterior. This is our uncertainty about the *cross section the potential predicts*.\n", + "2. **The full predictive**: the potential plus the discrepancy and the inferred errors $\\sigma_A$ and $\\sigma_B$, all drawn together as one correlated curve. This is our uncertainty about *what a measurement would read*, and it's the one to lay over the data.\n", + "\n", + "Every term here has a value at any angle. $\\sigma_A$ and $\\sigma_B$ are the same at every angle in log space, and the kernel and its amplitude are functions of the angle. That's exactly why the full predictive can go on the fine grid at all. `physical=True` maps the log-space draws back to ratios, so the bands are in the units of the data." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "86779a36", + "metadata": {}, + "outputs": [], + "source": [ + "bands = {}\n", + "for i, (name, p) in enumerate(problems.items()):\n", + " rows = samples[name][::5]\n", + " bands[name] = {\n", + " \"model only\": rx.predictive.grid_draws(\n", + " p, on_fine, x_fine, rows, model_only=True, physical=True, levels=(16, 84)\n", + " ),\n", + " \"full predictive\": rx.predictive.grid_draws(\n", + " p, on_fine, x_fine, rows, n_rep=2, physical=True, levels=(16, 84), rng=i\n", + " ),\n", + " }" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "58f077e7", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(1, 2, figsize=(10.0, 4.0), sharey=True)\n", + "for ax, (name, pair) in zip(axes, bands.items()):\n", + " lo, hi = pair[\"full predictive\"]\n", + " plotstyle.band(\n", + " ax, np.rad2deg(x_fine), lo, hi, color=colours[name], label=\"full predictive\"\n", + " )\n", + " lo, hi = pair[\"model only\"]\n", + " plotstyle.band(\n", + " ax,\n", + " np.rad2deg(x_fine),\n", + " lo,\n", + " hi,\n", + " color=\"k\",\n", + " hatch=plotstyle.HATCHES[0],\n", + " label=\"model only\",\n", + " )\n", + " ax.plot(np.rad2deg(angles), ratio, \"o\", ms=2.5, color=\"k\", label=\"data\")\n", + " ax.set(\n", + " xlabel=r\"$\\theta_{cm}$ [deg]\",\n", + " yscale=\"log\",\n", + " title=f\"{label[name]}: 68 % bands\",\n", + " )\n", + "axes[0].set_ylabel(\n", + " r\"$\\left(\\frac{d\\sigma}{d\\Omega}\\right) / \\left(\\frac{d\\sigma}{d\\Omega}\\right)_{\\mathrm{Rutherford}}$ [dimensionless]\"\n", + ")\n", + "axes[0].legend(fontsize=8, loc=\"lower left\")\n", + "fig.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "ddb882ac", + "metadata": {}, + "source": [ + "The two full predictives differ most at forward angles. There the constant model's discrepancy, a little larger than its uncorrelated error, roughly doubles the log-space variance, and its band is visibly wider than the power-of-$q$ model's, whose discrepancy is negligible there. Towards the backward angles the order reverses, and the power-of-$q$ band opens up. In both panels the model only is a narrow band that misses many of the points, which is what the next check quantifies." + ] + }, + { + "cell_type": "markdown", + "id": "a7594448", + "metadata": {}, + "source": [ + "## Are the predictions calibrated?\n", + "\n", + "A band is only as good as its [coverage](https://en.wikipedia.org/wiki/Coverage_probability): if a predictive distribution is calibrated, its central 68 % interval should contain about 68 % of the measured points, and likewise at every level. We check this at the measured angles with `rx.diagnostics.predictive_draws`, for the model only and for the full predictive.\n", + "\n", + "We expect the model only to undercover badly. It isn't *wrong*, it answers a different question: it describes where the potential's curve is, and the data don't sit on that curve. The full predictive is the one that should follow the diagonal.\n", + "\n", + "Two cautions go with the check. First, with 73 points the coverage at any one level is uncertain by about $\\pm 0.05$ (one binomial standard deviation), so we draw that band around the diagonal; it applies to the 73 fitted points, not to the curve for the unused angles below. Second, these are the points we fitted, so this is an in-sample check, mildly optimistic. We kept only every fourth angle, so we also have 216 angles the fit never saw; we score the full predictive there too (recipe 11). They come from the same digitised figure, many of them within a fraction of a degree of a fitted angle, and we draw them from the same marginal predictive rather than conditioning on the fitted points (recipe 11's `given=`), so they test the predictive at more angles of the same curve rather than on independent data. Because the discrepancy's correlation length came out at about two point spacings, coverage counted point by point does carry information here, unlike in `gp_discrepancy`, where the correlation length is comparable to the whole range." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "7de4ceb1", + "metadata": {}, + "outputs": [], + "source": [ + "levels = np.linspace(0.05, 0.95, 19)\n", + "y_obs = comp.y\n", + "held = pd.read_csv(\"data/alpha_ca_ratio_ruth.csv\")\n", + "held = held[held[\"target\"] == \"Ca44\"].drop(index=df.index) # every angle not fitted\n", + "data_held = rx.Dataset(\n", + " np.deg2rad(held[\"angle_cm_deg\"].to_numpy()),\n", + " held[\"ratio_to_rutherford\"].to_numpy(),\n", + " np.zeros(len(held)),\n", + " label=\"44Ca(a,a), unused angles\",\n", + " meta=meta,\n", + ")\n", + "comp_held = rx.Comparison(data_held, omp, space=tf.log)\n", + "coverage, cov68, width68 = {}, {}, {}\n", + "for i, (name, p) in enumerate(problems.items()):\n", + " rows = samples[name][::5]\n", + " p_held = rx.Problem(\n", + " [rx.Constraint([comp_held], terms=[*error_terms, gps[name]], statistical=False)]\n", + " )\n", + " assert p_held.names == p.names # the same parameters, in the same columns\n", + " full = rx.diagnostics.predictive_draws(p, rows, n_rep=2, rng=i, return_draws=True)\n", + " alone = rx.diagnostics.predictive_draws(p, rows, model_only=True, return_draws=True)\n", + " unseen = rx.diagnostics.predictive_draws(\n", + " p_held, rows, n_rep=2, rng=10 + i, return_draws=True\n", + " )\n", + " coverage[name] = {\n", + " \"full predictive\": rx.diagnostics.coverage_curve(full, y_obs, levels),\n", + " \"model only\": rx.diagnostics.coverage_curve(alone, y_obs, levels),\n", + " \"unused angles\": rx.diagnostics.coverage_curve(unseen, comp_held.y, levels),\n", + " }\n", + " cov68[name] = {\n", + " k: rx.diagnostics.coverage_curve(d, y, [0.68])[0]\n", + " for k, d, y in (\n", + " (\"full predictive\", full, y_obs),\n", + " (\"model only\", alone, y_obs),\n", + " (\"unused angles\", unseen, comp_held.y),\n", + " )\n", + " }\n", + " width68[name] = rx.diagnostics.sharpness(full).mean() # in log space: relative" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "d23a080a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "constant coverage at 0.68: full 0.86 (unused angles 0.81), model only 0.25; mean 68 % width of the full predictive 2.08 in log, a factor of 8.0\n", + "power of q coverage at 0.68: full 0.77 (unused angles 0.75), model only 0.21; mean 68 % width of the full predictive 1.97 in log, a factor of 7.2\n" + ] + } + ], + "source": [ + "for name, c68 in cov68.items():\n", + " print(\n", + " f\"{name:10s} coverage at 0.68: full {c68['full predictive']:.2f} \"\n", + " f\"(unused angles {c68['unused angles']:.2f}), model only \"\n", + " f\"{c68['model only']:.2f}; mean 68 % width of the full predictive \"\n", + " f\"{width68[name]:.2f} in log, a factor of {np.exp(width68[name]):.1f}\"\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "65192f70", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(4.8, 4.6))\n", + "ax.plot([0, 1], [0, 1], \"--\", color=\"0.5\", label=\"nominal\")\n", + "binomial = np.sqrt(levels * (1 - levels) / y_obs.size)\n", + "ax.fill_between(\n", + " levels,\n", + " levels - binomial,\n", + " levels + binomial,\n", + " color=\"0.85\",\n", + " label=r\"$\\pm 1$ binomial sd\",\n", + ")\n", + "for name, curves in coverage.items():\n", + " ax.plot(\n", + " levels,\n", + " curves[\"full predictive\"],\n", + " \"o-\",\n", + " color=colours[name],\n", + " label=f\"{label[name]}: full predictive\",\n", + " )\n", + " ax.plot(\n", + " levels,\n", + " curves[\"unused angles\"],\n", + " \"^--\",\n", + " color=colours[name],\n", + " label=f\"{label[name]}: unused angles\",\n", + " )\n", + " ax.plot(\n", + " levels,\n", + " curves[\"model only\"],\n", + " \"s:\",\n", + " color=colours[name],\n", + " label=f\"{label[name]}: model only\",\n", + " )\n", + "ax.set(\n", + " xlabel=\"nominal coverage\",\n", + " ylabel=\"empirical coverage\",\n", + " xlim=(0, 1),\n", + " ylim=(0, 1),\n", + " title=\"Coverage (band: the 73 fitted points)\",\n", + ")\n", + "ax.legend(fontsize=7)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "61e636ec", + "metadata": {}, + "source": [ + "At a nominal 68 %, the constant model's full predictive covers 86 % of the measured points and the power-of-$q$ model's 77 %, and the power-of-$q$ predictive is also sharper (its mean 68 % interval spans a factor of 7.2, against 8.0). The 216 unused angles give nearly the same numbers, 81 % and 75 %, which is what we should expect from points so close to the fitted ones; they confirm the in-sample result rather than independently test it. Both models over-cover. With 73 points, the power-of-$q$ model sits about one and a half binomial standard deviations above the diagonal at 68 %, the constant model about three. The constant amplitude over-covers because it has to be as generous forward as it is backward. The model only covers just 21 to 25 %, as expected for a band that leaves out every error term." + ] + }, + { + "cell_type": "markdown", + "id": "1f01181e", + "metadata": {}, + "source": [ + "## Where the potential fails, not just how badly\n", + "\n", + "Finally, the question the growing amplitude was built to answer. We can ask each model for the discrepancy alone, a mean-zero correlated draw from the kernel about the fitted potential, with `grid_draws(..., terms=[gp])`, and subtract from each draw its own potential curve, drawn from the same posterior row with `model_only=True`. What is left is the discrepancy on its own, in log space: the correlated fractional departures from the potential that the model considers plausible at each angle. (Subtracting one median potential instead would mix in the potential's own spread, and with the constant amplitude's two families of potentials, a median would sit between them.)\n", + "\n", + "These envelopes are statements about the model, not predictions of a measurement: they leave out $\\sigma_A$ and $\\sigma_B$, so they don't belong next to the data. The `gp_discrepancy` notebook writes out the equations for each of these objects." + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "f59ee077", + "metadata": {}, + "outputs": [], + "source": [ + "envelopes = {}\n", + "for i, (name, p) in enumerate(problems.items()):\n", + " rows = samples[name][::5]\n", + " with_gp = rx.predictive.grid_draws(\n", + " p, on_fine, x_fine, rows, terms=[gps[name]], rng=3, return_draws=True\n", + " )\n", + " potential = rx.predictive.grid_draws(\n", + " p, on_fine, x_fine, rows, model_only=True, return_draws=True\n", + " )\n", + " envelopes[name] = np.percentile(with_gp - potential, [16, 84], axis=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "d946253c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "constant 68 % envelope width at 20, 90, 170 deg: 1.200 1.304 1.251 back/front = 1.0\n", + "power of q 68 % envelope width at 20, 90, 170 deg: 0.000 0.230 2.820 back/front = 75816.0\n" + ] + } + ], + "source": [ + "for name, (lo, hi) in envelopes.items():\n", + " at = [np.interp(np.deg2rad(a), x_fine, hi - lo) for a in (20, 90, 170)]\n", + " print(\n", + " f\"{name:10s} 68 % envelope width at 20, 90, 170 deg: \"\n", + " + \" \".join(f\"{v:.3f}\" for v in at)\n", + " + f\" back/front = {at[2] / at[0]:.1f}\"\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "9c8629e8", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "for (name, (lo, hi)), hatch in zip(envelopes.items(), plotstyle.HATCHES):\n", + " plotstyle.band(\n", + " ax,\n", + " np.rad2deg(x_fine),\n", + " lo,\n", + " hi,\n", + " color=colours[name],\n", + " hatch=hatch,\n", + " label=f\"{label[name]} (68 %)\",\n", + " )\n", + "ax.axhline(0.0, color=\"k\", lw=0.8)\n", + "ax.set(\n", + " xlabel=r\"$\\theta_{cm}$ [deg]\",\n", + " ylabel=\"log departure from the fitted potential\",\n", + " title=\"The discrepancy each model allows, by angle\",\n", + ")\n", + "ax.legend(fontsize=8)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "26a0c48a", + "metadata": {}, + "source": [ + "This is the clearest difference. The constant amplitude's envelope is, by construction, about the same width at every angle: 1.20 at 20 degrees, 1.30 at 90 and 1.25 at 170. The power-of-$q$ envelope is narrower than 0.001 at 20 degrees, 0.23 at 90 and 2.82 at 170. Because each draw has its own potential subtracted, the envelope is the discrepancy alone: it passes smoothly through the diffraction minima instead of spiking where the potential's own curve is uncertain." + ] + }, + { + "cell_type": "markdown", + "id": "3a3a89e7", + "metadata": {}, + "source": [ + "## Takeaways\n", + "\n", + "- A correlated discrepancy and an uncorrelated error do different jobs. Scatter from one point to the next, a factor of about 1.6 to 1.7 here, belongs in an uncorrelated term; the discrepancy describes how the potential goes wrong coherently across angles.\n", + "- Compare error terms in the same space. Here $\\sigma_A$, $\\sigma_B$ and the amplitude $A$ are all log-space standard deviations, so they compare directly, and their posterior correlations say whether the data can tell them apart.\n", + "- Evaluate a kernel in a coordinate where the data are spread out. Momentum transfer bunches the backward angles together, so we evaluated the kernel in angle and used $q$ only for the amplitude.\n", + "- *Where* a model fails is prior knowledge worth stating. An amplitude growing as $\\sin^p(\\theta/2)$, with $p$ broad but well away from zero (4.4 to 11.5), is preferred by $\\Delta\\log Z \\approx 7$ and over-covers less (77 % against 86 % at a nominal 68 %, and much the same at the unused angles, which lie close to the fitted ones). It shifts the weight towards the deeper family of potentials, but it does not resolve the discrete ambiguity.\n", + "- Say how many points a coverage check rests on, and what it can and cannot test. Unused angles from the same figure only repeat the in-sample check; an independent test needs independent data, or a predictive conditioned on the fitted points (recipe 11).\n", + "- Terms written as functions of the angle, like $\\sigma_A$, $\\sigma_B$ and the kernel, let us draw the *full* predictive on a fine grid." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/budget.py b/examples/budget.py new file mode 100644 index 0000000..acac820 --- /dev/null +++ b/examples/budget.py @@ -0,0 +1,33 @@ +"""Sampler budgets for the example notebooks. + +The committed notebooks are full runs, made with ``python examples/run.py``, +and the documentation shows them as committed. CI only checks that every +cell still runs: it sets ``RXMC_EXAMPLES_QUICK=1``, which cuts every budget +wrapped in :func:`budget` tenfold and caps NUTS's trees +(:data:`QUICK_NUTS`), so its numbers mean nothing. + +``import budget`` works because a notebook runs with ``examples/`` as its +working directory, under Jupyter and under ``pytest --nbmake`` alike. +""" + +from __future__ import annotations + +import os + +__all__ = ["QUICK", "BANNER", "QUICK_NUTS", "budget"] + +QUICK = os.environ.get("RXMC_EXAMPLES_QUICK") == "1" +#: NUTS's extra keyword arguments in a quick run, empty otherwise: trees of at +#: most 2**5 leapfrog steps, since a step size adapted in a few dozen steps is +#: small and its trees grow deep (on a reaction model, five times the time) +QUICK_NUTS = dict(max_num_doublings=5) if QUICK else {} +#: printed at import in a quick run; test_notebooks_index refuses a committed +#: notebook whose outputs contain it +BANNER = "quick run: sampler budgets cut tenfold, results not meaningful" +if QUICK: + print(BANNER) + + +def budget(n: int, floor: int = 50) -> int: + """``n``, or ``n // 10`` (at least ``floor``) in a quick run.""" + return max(n // 10, min(floor, n)) if QUICK else n diff --git a/examples/calibration_config_emcee_dynesty.ipynb b/examples/calibration_config_emcee_dynesty.ipynb deleted file mode 100644 index c0e6d15..0000000 --- a/examples/calibration_config_emcee_dynesty.ipynb +++ /dev/null @@ -1,661 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "59aaecd72125b689", - "metadata": {}, - "source": [ - "# Calibrating an optical potential with `CalibrationConfig`: emcee vs dynesty\n", - "\n", - "This notebook shows how `CalibrationConfig` acts as a **uniform interface** to\n", - "external inference libraries. We calibrate a nuclear optical-model potential\n", - "to mock $n + {}^{40}$Ca elastic differential cross-section data using both\n", - "[emcee](https://emcee.readthedocs.io/) (MCMC using ensemble sampling) and\n", - "[dynesty](https://dynesty.readthedocs.io/) (nested sampling), then compare the\n", - "resulting posteriors and predictive posterior bands.\n", - "\n", - "The key interface points provided by `CalibrationConfig`:\n", - "\n", - "| sampler | method used |\n", - "|---------|-------------|\n", - "| emcee | `config.log_posterior`, `config.starting_location` |\n", - "| dynesty | `config.log_likelihood`, `config.prior_transform`, `config.ndim` |" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "a4e74c882f17c512", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Using database version X4-2025-12-31 located in: /mnt/home/beyerkyl/x4db/unpack_exfor-2025/X4-2025-12-31\n" - ] - } - ], - "source": [ - "import corner\n", - "import dynesty\n", - "import emcee\n", - "import jitr\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "from jitr.optical_potentials.potential_forms import (\n", - " thomas_safe,\n", - " woods_saxon_prime_safe,\n", - " woods_saxon_safe,\n", - ")\n", - "\n", - "import rxmc\n", - "from rxmc.config import CalibrationConfig, ParameterConfig\n", - "from rxmc.params import Parameter\n", - "from rxmc.priors import TruncatedNormalPrior" - ] - }, - { - "cell_type": "markdown", - "id": "e5ea9b3edf23cefa", - "metadata": {}, - "source": [ - "## Reaction, optical-model, and mock data\n", - "\n", - "We use the same minimal optical-model potential setup as in\n", - "`30s_optical_potential_calibration.ipynb`." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "e86da6406a1b5c37", - "metadata": {}, - "outputs": [], - "source": [ - "Ca40 = (40, 20)\n", - "neutron = (1, 0)\n", - "E_lab = 14.1\n", - "\n", - "rxn = jitr.reactions.ElasticReaction(target=Ca40, projectile=neutron)\n", - "\n", - "mso = 1.0 / jitr.utils.constants.WAVENUMBER_PION\n", - "\n", - "\n", - "def central_potential(r, Vv, Wv, Rv, av, Wd, Rd, ad):\n", - " return -(Vv + 1j * Wv) * woods_saxon_safe(r, Rv, av) + (\n", - " 4j * ad * Wd\n", - " ) * woods_saxon_prime_safe(r, Rd, ad)\n", - "\n", - "\n", - "def spin_orbit_potential(r, Vso, Wso, Rso, aso):\n", - " return (Vso + 1j * Wso) * mso**2 * thomas_safe(r, Rso, aso)\n", - "\n", - "\n", - "R = 1.2 * 40 ** (1 / 3)\n", - "fixed_spin_orbit = (6.0, -3, R, 0.45)\n", - "\n", - "\n", - "def extract_params(ws, *x):\n", - " Vv, Wv, Rv, av, Wd, Rd, ad = x\n", - " return (Vv, Wv, Rv, av, Wd, Rd, ad), fixed_spin_orbit\n", - "\n", - "\n", - "params = [\n", - " Parameter(\"Vv\", unit=\"MeV\"),\n", - " Parameter(\"Wv\", unit=\"MeV\"),\n", - " Parameter(\"Rv\", unit=\"fm\"),\n", - " Parameter(\"av\", unit=\"fm\"),\n", - " Parameter(\"Wd\", unit=\"MeV\"),\n", - " Parameter(\"Rd\", unit=\"fm\"),\n", - " Parameter(\"ad\", unit=\"fm\"),\n", - "]\n", - "\n", - "omp = rxmc.elastic_diffxs_model.ElasticDifferentialXSModel(\n", - " \"dXS/dA\",\n", - " interaction_central=central_potential,\n", - " interaction_spin_orbit=spin_orbit_potential,\n", - " calculate_interaction_from_params=extract_params,\n", - " params=params,\n", - " model_name=\"minimal_elastic_demo\",\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "62252d74eb52a9d4", - "metadata": {}, - "outputs": [], - "source": [ - "angles_deg = np.linspace(2.0, 160.0, 28)\n", - "true_params = np.array(\n", - " [48.0, 3.5, 1.1 * 40 ** (1 / 3), 0.7, 21, 1.2 * 40 ** (1 / 3), 0.5]\n", - ")\n", - "\n", - "template_obs = rxmc.elastic_diffxs_observation.ElasticDifferentialXSObservation(\n", - " x=angles_deg,\n", - " y=np.ones_like(angles_deg, dtype=float),\n", - " Elab=E_lab,\n", - " reaction=rxn,\n", - " quantity=\"dXS/dA\",\n", - " measurement_quantity=\"dXS/dA\",\n", - " y_units=\"barn / steradian\",\n", - " dataset_label=\"template\",\n", - ")\n", - "\n", - "y_true = omp.evaluate(template_obs, *true_params)\n", - "\n", - "rng = np.random.default_rng(42)\n", - "y_stat_err = 0.2 * np.maximum(y_true, 1e-4)\n", - "y_mock = np.clip(y_true + rng.normal(scale=y_stat_err * 1.3), 1e-6, None)\n", - "\n", - "obs = rxmc.elastic_diffxs_observation.ElasticDifferentialXSObservation(\n", - " x=angles_deg,\n", - " y=y_mock,\n", - " Elab=E_lab,\n", - " reaction=rxn,\n", - " quantity=\"dXS/dA\",\n", - " measurement_quantity=\"dXS/dA\",\n", - " y_units=\"barn / steradian\",\n", - " y_stat_err=y_stat_err,\n", - " dataset_label=\"mock elastic dataset\",\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "7ae38c666c0d856d", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 1.0, 'Mock $n + {}^{40}$Ca differential cross-section data')" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.errorbar(np.rad2deg(obs.x), obs.y, obs.y_stat_err, linestyle=\"none\", marker=\".\")\n", - "plt.xlabel(r\"$\\theta$ [deg]\")\n", - "plt.ylabel(r\"$d\\sigma/d\\Omega$ [b/Sr]\")\n", - "plt.yscale(\"log\")\n", - "plt.title(r\"Mock $n + {}^{40}$Ca differential cross-section data\")" - ] - }, - { - "cell_type": "markdown", - "id": "9758436cf4777841", - "metadata": {}, - "source": [ - "## Build `CalibrationConfig`\n", - "\n", - "We use `TruncatedNormalPrior` here to enforce physical constraints." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "82a298155fe56dd4", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ndim: 7\n", - "parameters: ['Vv', 'Wv', 'Rv', 'av', 'Wd', 'Rd', 'ad']\n", - "prior objects: ['TruncatedNormalPrior']\n" - ] - } - ], - "source": [ - "prior_mean = np.array(\n", - " [50.0, 3.0, 1.2 * 40 ** (1 / 3), 0.65, 18.0, 1.2 * 40 ** (1 / 3), 0.65]\n", - ")\n", - "prior_std = np.array([7.0, 7.0, 0.5, 0.20, 10.0, 0.5, 0.20])\n", - "lower = np.zeros_like(prior_mean)\n", - "upper = prior_mean + 10 * prior_std\n", - "\n", - "prior = TruncatedNormalPrior(\n", - " mu=prior_mean,\n", - " sigma=prior_std,\n", - " lower=lower,\n", - " upper=upper,\n", - " seed=0,\n", - ")\n", - "\n", - "model_config = ParameterConfig(\n", - " params=omp.params,\n", - " prior=prior,\n", - " initial_proposal_distribution=prior,\n", - ")\n", - "\n", - "constraint = rxmc.constraint.Constraint(\n", - " observations=[obs],\n", - " physical_model=omp,\n", - " likelihood=rxmc.likelihood_model.GaussianLikelihood(),\n", - ")\n", - "evidence = rxmc.evidence.Evidence(constraints=[constraint])\n", - "\n", - "config = CalibrationConfig(evidence=evidence, model_config=model_config)\n", - "\n", - "print(\"ndim:\", config.ndim)\n", - "print(\"parameters:\", config.parameter_names)\n", - "print(\"prior objects:\", [type(p).__name__ for p in config.prior])" - ] - }, - { - "cell_type": "markdown", - "id": "c95fbc706233ff5d", - "metadata": {}, - "source": [ - "## emcee: ensemble MCMC\n", - "\n", - "`CalibrationConfig.log_posterior` is passed directly as the log-probability\n", - "function; `CalibrationConfig.starting_location` generates the initial walker\n", - "positions by drawing from the proposal distribution." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "b11457245e87a591", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 5000/5000 [05:03<00:00, 16.47it/s]\n" - ] - } - ], - "source": [ - "nwalkers = 32\n", - "nsteps = 5000\n", - "\n", - "p0 = config.starting_location(nwalkers)\n", - "\n", - "sampler_emcee = emcee.EnsembleSampler(\n", - " nwalkers,\n", - " config.ndim,\n", - " config.log_posterior,\n", - ")\n", - "state = sampler_emcee.run_mcmc(p0, nsteps, progress=True)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "f7d84c28fb8ddc5d", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "The chain is shorter than 50 times the integrated autocorrelation time for 7 parameter(s). Use this estimate with caution and run a longer chain!\n", - "N/50 = 100;\n", - "tau: [200.51739056 200.00513277 183.65262029 143.22836146 211.13930814\n", - " 166.72607996 197.35966807]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Autocorrelation times: [200.5 200. 183.7 143.2 211.1 166.7 197.4]\n", - "Burn-in: 422 thin: 71\n", - "Posterior samples: 2048\n", - "Mean acceptance fraction: 0.320\n" - ] - } - ], - "source": [ - "tau = sampler_emcee.get_autocorr_time(quiet=True)\n", - "burnin = int(2 * np.max(tau))\n", - "thin = max(1, int(0.5 * np.min(tau)))\n", - "flat_emcee = sampler_emcee.get_chain(discard=burnin, thin=thin, flat=True)\n", - "\n", - "print(f\"Autocorrelation times: {np.round(tau, 1)}\")\n", - "print(f\"Burn-in: {burnin} thin: {thin}\")\n", - "print(f\"Posterior samples: {len(flat_emcee)}\")\n", - "print(f\"Mean acceptance fraction: {sampler_emcee.acceptance_fraction.mean():.3f}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "73d1640d733a5e7d", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "chain = sampler_emcee.get_chain()\n", - "logp_chain = sampler_emcee.get_log_prob()\n", - "\n", - "fig, axes = plt.subplots(config.ndim + 1, 1, figsize=(10, 9), sharex=True)\n", - "for i, (ax, name) in enumerate(zip(axes[:-1], config.parameter_names)):\n", - " ax.plot(chain[:, :, i], alpha=0.3, lw=0.6, color=\"tab:blue\")\n", - " ax.axhline(true_params[i], color=\"r\", lw=1.5, linestyle=\"--\")\n", - " ax.set_ylabel(name)\n", - "axes[-1].plot(logp_chain, alpha=0.3, lw=0.6, color=\"tab:gray\")\n", - "axes[-1].set_ylabel(r\"$\\log p$\")\n", - "axes[-1].set_xlabel(\"step\")\n", - "fig.suptitle(\"emcee chains (red dashes = truth)\")\n", - "fig.tight_layout()" - ] - }, - { - "cell_type": "markdown", - "id": "3d504061cb491b17", - "metadata": {}, - "source": [ - "## dynesty: nested sampling\n", - "\n", - "`CalibrationConfig.log_likelihood` and `CalibrationConfig.prior_transform`\n", - "provide the two functions dynesty needs. " - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "af9341b781df8d82", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2813it [03:14, 14.46it/s, +200 | bound: 12 | nc: 1 | ncall: 64251 | eff(%): 4.704 | loglstar: -inf < 132.820 < inf | logz: 119.434 +/- 0.254 | dlogz: 0.003 > 0.500]\n" - ] - } - ], - "source": [ - "sampler_dyn = dynesty.NestedSampler(\n", - " config.log_likelihood,\n", - " config.prior_transform,\n", - " config.ndim,\n", - " nlive=200,\n", - " sample=\"rwalk\",\n", - ")\n", - "sampler_dyn.run_nested(dlogz=0.5, print_progress=True)" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "b3ba5da881a8bd00", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Posterior samples: 3013\n", - "log Z = 119.43 \u00b1 0.38\n", - "Efficiency: 4.70 %\n" - ] - } - ], - "source": [ - "results_dyn = sampler_dyn.results\n", - "flat_dynesty = results_dyn.samples_equal()\n", - "\n", - "print(f\"Posterior samples: {len(flat_dynesty)}\")\n", - "print(f\"log Z = {results_dyn.logz[-1]:.2f} \u00b1 {results_dyn.logzerr[-1]:.2f}\")\n", - "print(f\"Efficiency: {results_dyn.eff:.2f} %\")" - ] - }, - { - "cell_type": "markdown", - "id": "dcf890213bea8821", - "metadata": {}, - "source": [ - "## Comparing posteriors\n", - "\n", - "Corner plot overlaying the prior (orange), emcee posterior (blue), and dynesty\n", - "posterior (green). Red dashed lines mark the true parameter values used to\n", - "generate the mock data." - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "e05d6c94f3dc1ed0", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 1.01, 'Posterior comparison: n + $^{40}$Ca OMP calibration')" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "n_corner = 2000\n", - "rng_plot = np.random.default_rng(1)\n", - "prior_samples = prior.rvs(n_corner)\n", - "idx_e = rng_plot.choice(len(flat_emcee), min(n_corner, len(flat_emcee)), replace=False)\n", - "idx_d = rng_plot.choice(\n", - " len(flat_dynesty), min(n_corner, len(flat_dynesty)), replace=False\n", - ")\n", - "\n", - "fig = plt.figure(figsize=(8, 8))\n", - "\n", - "\n", - "def corner_kwargs(color, alpha=0.4):\n", - " return dict(\n", - " labels=config.parameter_names,\n", - " truths=true_params,\n", - " truth_color=\"red\",\n", - " label_kwargs={\"fontsize\": 11},\n", - " show_titles=True,\n", - " plot_datapoints=False,\n", - " plot_density=False,\n", - " plot_contours=True,\n", - " fill_contours=True,\n", - " no_fill_contours=False,\n", - " contour_kwargs={\n", - " \"colors\": color,\n", - " \"linewidths\": 1.5,\n", - " \"alpha\": alpha,\n", - " },\n", - " hist_kwargs={\n", - " \"density\": True,\n", - " \"histtype\": \"stepfilled\",\n", - " \"alpha\": alpha,\n", - " \"color\": color,\n", - " \"edgecolor\": \"k\",\n", - " },\n", - " labelpad=0.4,\n", - " )\n", - "\n", - "\n", - "corner.corner(\n", - " flat_emcee[idx_e],\n", - " fig=fig,\n", - " **corner_kwargs(\"tab:green\"),\n", - ")\n", - "corner.corner(\n", - " flat_dynesty[idx_d],\n", - " fig=fig,\n", - " **corner_kwargs(\"tab:orange\"),\n", - ")\n", - "corner.corner(\n", - " prior_samples,\n", - " fig=fig,\n", - " **corner_kwargs(\"tab:blue\", alpha=0.2),\n", - ")\n", - "\n", - "# Legend\n", - "from matplotlib.lines import Line2D\n", - "\n", - "handles = [\n", - " Line2D([0], [0], color=\"tab:green\", label=\"emcee\"),\n", - " Line2D([0], [0], color=\"tab:orange\", label=\"dynesty\"),\n", - " Line2D([0], [0], color=\"tab:blue\", label=\"prior\"),\n", - "]\n", - "fig.legend(handles=handles, loc=\"upper right\", fontsize=12)\n", - "fig.suptitle(r\"Posterior comparison: n + $^{40}$Ca OMP calibration\", y=1.01)" - ] - }, - { - "cell_type": "markdown", - "id": "3f2e6d58-11bc-4837-9b1a-51a5bf53c49a", - "metadata": {}, - "source": [ - "While Markov-chain based samplers like the one in emcee are typically great, nested sampling is often better suited when the posterior has multi-modality. Here, we can see in the emcee posterior, that different modes appear, which indicates that convergence was poor." - ] - }, - { - "cell_type": "markdown", - "id": "0c456000a3c13726", - "metadata": {}, - "source": [ - "## Comparing predictive posteriors\n", - "\n", - "We propagate 200 posterior samples from each method through the model and show\n", - "the 5th\u201395th percentile predictive band." - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "696cddd8e740f83c", - "metadata": {}, - "outputs": [], - "source": [ - "n_pred = 200\n", - "rng_pred = np.random.default_rng(2)\n", - "\n", - "idx_e_pred = rng_pred.choice(len(flat_emcee), n_pred, replace=False)\n", - "idx_d_pred = rng_pred.choice(len(flat_dynesty), n_pred, replace=False)\n", - "\n", - "y_pred_emcee = np.array(\n", - " [omp.visualizable_model_prediction(obs, *s) for s in flat_emcee[idx_e_pred]]\n", - ")\n", - "y_pred_dynesty = np.array(\n", - " [omp.visualizable_model_prediction(obs, *s) for s in flat_dynesty[idx_d_pred]]\n", - ")\n", - "y_true_vis = omp.visualizable_model_prediction(obs, *true_params)\n", - "\n", - "angles_plot = np.rad2deg(obs.visualization_workspace.angles)" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "f489936f103b25a8", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig, ax = plt.subplots(figsize=(8, 4))\n", - "\n", - "ax.errorbar(\n", - " np.rad2deg(obs.x),\n", - " obs.y,\n", - " yerr=obs.y_stat_err,\n", - " fmt=\"ko\",\n", - " label=\"Mock data\",\n", - " zorder=5,\n", - ")\n", - "ax.plot(angles_plot, y_true_vis, \"k--\", lw=2, label=\"Truth\")\n", - "\n", - "for y_pred, label, color in [\n", - " (y_pred_emcee, \"emcee 90%\", \"tab:green\"),\n", - " (y_pred_dynesty, \"dynesty 90%\", \"tab:orange\"),\n", - "]:\n", - " lo, hi = np.percentile(y_pred, [5, 95], axis=0)\n", - " ax.fill_between(angles_plot, lo, hi, alpha=0.4, color=color, label=label)\n", - "\n", - "ax.set_yscale(\"log\")\n", - "ax.set_xlabel(r\"$\\theta$ (deg)\")\n", - "ax.set_ylabel(r\"$d\\sigma/d\\Omega$ (b/sr)\")\n", - "ax.legend()\n", - "ax.set_title(r\"Predictive posterior: $n + {}^{40}$Ca\")\n", - "fig.tight_layout()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "7bce006a-eef3-4749-aaf3-271026e4bbad", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.13.11" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} \ No newline at end of file diff --git a/examples/correlated_observations.ipynb b/examples/correlated_observations.ipynb deleted file mode 100644 index 193b69e..0000000 --- a/examples/correlated_observations.ipynb +++ /dev/null @@ -1,785 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "c00", - "metadata": {}, - "source": [ - "# Correlated observations\n", - "\n", - "Two datasets that are *individually* independent can still be **coupled** by a\n", - "shared systematic — e.g. a common detector calibration, flux normalisation, or\n", - "energy scale applied to both. The classic D'Agostini / Barlow point is that\n", - "treating such datasets independently is **overconfident**: the shared systematic\n", - "cannot average down the way independent errors do.\n", - "\n", - "The covariance API expresses this directly. A `Constraint` owns one multivariate\n", - "distribution over the *stacked* vector $y = [y_1; y_2]$, and a covariance `Term`\n", - "whose `support` spans **both** blocks writes off-diagonal blocks that couple the\n", - "data. This is \"case A\" of the refactor:\n", - "\n", - "- **case A — coupling the data**: a cross-block `Term` (off-diagonal $\\Sigma$).\n", - "- **case B — coupling the parameters**: the *same* `Parameter` object shared by two\n", - " block-local terms (one sampled value feeds both; $\\Sigma$ stays block-diagonal).\n", - "\n", - "We demonstrate both." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "c01", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:18:30.768095Z", - "iopub.status.busy": "2026-08-11T03:18:30.767914Z", - "iopub.status.idle": "2026-08-11T03:18:32.802335Z", - "shell.execute_reply": "2026-08-11T03:18:32.801332Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Using database version X4-2024-12-31 located in: /home/kyle/db/exfor/unpack_exfor-2024/X4-2024-12-31\n" - ] - } - ], - "source": [ - "import corner\n", - "import numpy as np\n", - "from matplotlib import pyplot as plt\n", - "from scipy import stats\n", - "\n", - "import rxmc\n", - "\n", - "rng = np.random.default_rng(3)" - ] - }, - { - "cell_type": "markdown", - "id": "c02", - "metadata": {}, - "source": [ - "## Two datasets with a shared calibration\n", - "\n", - "A straight-line signal is measured by two instruments over different $x$ ranges.\n", - "Both share **one** unknown multiplicative calibration factor $c \\sim\n", - "\\mathcal N(1, \\sigma_c)$ drawn once — so both datasets are biased by the *same*\n", - "amount. The reported statistical errors are small and independent." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "c03", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:18:32.803854Z", - "iopub.status.busy": "2026-08-11T03:18:32.803610Z", - "iopub.status.idle": "2026-08-11T03:18:32.992778Z", - "shell.execute_reply": "2026-08-11T03:18:32.991831Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "class LinearModel(rxmc.physical_model.PhysicalModel):\n", - " def __init__(self):\n", - " super().__init__(\n", - " [rxmc.params.Parameter(\"m\", float), rxmc.params.Parameter(\"b\", float)]\n", - " )\n", - "\n", - " def evaluate(self, observation, m, b):\n", - " return self.y(observation.x, m, b)\n", - "\n", - " def y(self, x, m, b):\n", - " return m * x + b\n", - "\n", - "\n", - "model = LinearModel()\n", - "m_true, b_true = 1.0, 0.5\n", - "sigma_c = 0.10 # shared calibration uncertainty\n", - "noise = 0.02 # independent statistical error\n", - "\n", - "c = rng.normal(1.0, sigma_c) # ONE common factor, applied to both datasets\n", - "x1 = np.linspace(0.0, 2.0, 8)\n", - "x2 = np.linspace(3.0, 5.0, 8)\n", - "y1 = c * model.y(x1, m_true, b_true) + rng.normal(0.0, noise, x1.size)\n", - "y2 = c * model.y(x2, m_true, b_true) + rng.normal(0.0, noise, x2.size)\n", - "\n", - "obs1 = rxmc.observation.Observation(x=x1, y=y1, y_stat_err=noise * np.ones_like(y1))\n", - "obs2 = rxmc.observation.Observation(x=x2, y=y2, y_stat_err=noise * np.ones_like(y2))\n", - "\n", - "xg = np.linspace(0, 5, 100)\n", - "plt.plot(xg, model.y(xg, m_true, b_true), \"k:\", label=\"true signal\")\n", - "plt.errorbar(x1, y1, noise, ls=\"none\", marker=\".\", label=\"dataset 1\")\n", - "plt.errorbar(x2, y2, noise, ls=\"none\", marker=\".\", label=\"dataset 2\")\n", - "plt.xlabel(\"x\")\n", - "plt.ylabel(\"y\")\n", - "plt.legend()\n", - "plt.title(f\"both datasets share one calibration c = {c:.3f}\");" - ] - }, - { - "cell_type": "markdown", - "id": "c04", - "metadata": {}, - "source": [ - "## The covariance structure\n", - "\n", - "We build the **same** shared-systematic two ways and compare the assembled\n", - "$\\Sigma$ (via `Constraint.covariance_matrix`):\n", - "\n", - "- **correlated (case A)**: one `normalization_term` over the *full* stacked\n", - " support — its rank-one mode spans both blocks.\n", - "- **independent**: a `normalization_term` per dataset (block-local) — no coupling." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "c05", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:18:32.994269Z", - "iopub.status.busy": "2026-08-11T03:18:32.994136Z", - "iopub.status.idle": "2026-08-11T03:18:33.810366Z", - "shell.execute_reply": "2026-08-11T03:18:33.809598Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "correlated block_diagonal = False\n", - "independent block_diagonal = True\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "s1, s2 = rxmc.covariance.stacked_supports([obs1, obs2])\n", - "full = np.concatenate([s1, s2])\n", - "N1 = len(s1)\n", - "\n", - "constraint_corr = rxmc.constraint.Constraint(\n", - " [obs1, obs2],\n", - " model,\n", - " extra_terms=[rxmc.covariance.normalization_term(magnitude=sigma_c, support=full)],\n", - ")\n", - "constraint_indep = rxmc.constraint.Constraint(\n", - " [obs1, obs2],\n", - " model,\n", - " extra_terms=[\n", - " rxmc.covariance.normalization_term(magnitude=sigma_c, support=s1),\n", - " rxmc.covariance.normalization_term(magnitude=sigma_c, support=s2),\n", - " ],\n", - ")\n", - "\n", - "mp = (m_true, b_true)\n", - "S_corr = constraint_corr.covariance_matrix(mp)\n", - "S_indep = constraint_indep.covariance_matrix(mp)\n", - "\n", - "print(\"correlated block_diagonal =\", constraint_corr.covariance.block_diagonal)\n", - "print(\"independent block_diagonal =\", constraint_indep.covariance.block_diagonal)\n", - "\n", - "fig, axes = plt.subplots(1, 2, figsize=(9, 4))\n", - "for ax, S, t in [\n", - " (axes[0], S_corr, \"correlated (case A)\"),\n", - " (axes[1], S_indep, \"independent\"),\n", - "]:\n", - " im = ax.imshow(S, cmap=\"viridis\")\n", - " ax.axhline(N1 - 0.5, color=\"w\", lw=0.8)\n", - " ax.axvline(N1 - 0.5, color=\"w\", lw=0.8)\n", - " ax.set_title(t)\n", - " fig.colorbar(im, ax=ax, fraction=0.046)\n", - "fig.suptitle(r\"stacked covariance $\\Sigma$ — off-diagonal blocks couple the data\");" - ] - }, - { - "cell_type": "markdown", - "id": "c06", - "metadata": {}, - "source": [ - "The correlated $\\Sigma$ has **non-zero off-diagonal blocks** (top-right /\n", - "bottom-left): every point in dataset 1 is correlated with every point in dataset 2\n", - "through the shared calibration. The independent $\\Sigma$ is block-diagonal." - ] - }, - { - "cell_type": "markdown", - "id": "c07", - "metadata": {}, - "source": [ - "## Effect on inference\n", - "\n", - "Fitting the line under each treatment: the correlated model is appropriately\n", - "**less certain** (the shared systematic is a common mode that cannot average\n", - "down), while the independent model is **overconfident**." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "c08", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:18:33.812158Z", - "iopub.status.busy": "2026-08-11T03:18:33.811974Z", - "iopub.status.idle": "2026-08-11T03:18:39.649142Z", - "shell.execute_reply": "2026-08-11T03:18:39.648248Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "correlated m = 1.201 ± 0.105 b = 0.582 ± 0.051\n", - "independent m = 1.196 ± 0.079 b = 0.590 ± 0.041\n" - ] - } - ], - "source": [ - "def fit(constraint, seed):\n", - " evidence = rxmc.evidence.Evidence([constraint])\n", - " prior = stats.multivariate_normal(mean=[1.0, 0.5], cov=np.diag([0.3, 0.3]) ** 2)\n", - " sampler = rxmc.param_sampling.BatchedAdaptiveMetropolisSampler(\n", - " params=model.params,\n", - " starting_location=prior.mean,\n", - " prior=prior,\n", - " initial_proposal_cov=prior.cov / 100,\n", - " )\n", - " walker = rxmc.walker.Walker(sampler, evidence, rng=np.random.default_rng(seed))\n", - " walker.walk(n_steps=6000, burnin=2000, batch_size=1000, verbose=False)\n", - " return walker.model_sampler.chain\n", - "\n", - "\n", - "chain_corr = fit(constraint_corr, 5)\n", - "chain_indep = fit(constraint_indep, 5)\n", - "\n", - "for name, ch in [(\"correlated\", chain_corr), (\"independent\", chain_indep)]:\n", - " print(\n", - " f\"{name:12s} m = {ch[:,0].mean():.3f} ± {ch[:,0].std():.3f} \"\n", - " f\"b = {ch[:,1].mean():.3f} ± {ch[:,1].std():.3f}\"\n", - " )" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "c09", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:18:39.650554Z", - "iopub.status.busy": "2026-08-11T03:18:39.650423Z", - "iopub.status.idle": "2026-08-11T03:18:39.814309Z", - "shell.execute_reply": "2026-08-11T03:18:39.813633Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig = corner.corner(\n", - " chain_corr,\n", - " labels=[\"m\", \"b\"],\n", - " color=\"tab:blue\",\n", - " truths=[m_true, b_true],\n", - " truth_color=\"k\",\n", - ")\n", - "corner.corner(chain_indep, fig=fig, color=\"tab:red\")\n", - "plt.plot([], [], color=\"tab:blue\", label=\"correlated (case A)\")\n", - "plt.plot([], [], color=\"tab:red\", label=\"independent (overconfident)\")\n", - "fig.legend(loc=\"upper right\");" - ] - }, - { - "cell_type": "markdown", - "id": "c10", - "metadata": {}, - "source": [ - "## Case A vs case B with a *free* shared nuisance\n", - "\n", - "If the calibration magnitude is itself unknown, it becomes a sampled `Parameter`.\n", - "The same `Parameter` object can be wired two ways:\n", - "\n", - "- **case A** — one cross-block term: $\\Sigma$ couples the data (off-diagonal).\n", - "- **case B** — two block-local terms sharing the *same* `Parameter`: one sampled\n", - " value feeds both, but $\\Sigma$ stays **block-diagonal** (the datasets remain\n", - " independent; they only share the uncertainty *magnitude*).\n", - "\n", - "Both have exactly **one** free parameter (gather-by-identity)." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "c11", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:18:39.815796Z", - "iopub.status.busy": "2026-08-11T03:18:39.815612Z", - "iopub.status.idle": "2026-08-11T03:18:39.820536Z", - "shell.execute_reply": "2026-08-11T03:18:39.819858Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "case A (cross-block) n_params=1 block_diagonal=False\n", - "case B (shared param) n_params=1 block_diagonal=True\n", - "case A cross-block max |Sigma[s1,s2]| = 0.1375\n", - "case B cross-block max |Sigma[s1,s2]| = 0.0\n" - ] - } - ], - "source": [ - "eta = rxmc.params.Parameter(\"log eta\", float, latex_name=r\"\\log{\\eta}\")\n", - "\n", - "case_A = rxmc.constraint.Constraint(\n", - " [obs1, obs2],\n", - " model,\n", - " extra_terms=[rxmc.covariance.normalization_term(parameter=eta, support=full)],\n", - ")\n", - "case_B = rxmc.constraint.Constraint(\n", - " [obs1, obs2],\n", - " model,\n", - " extra_terms=[\n", - " rxmc.covariance.normalization_term(parameter=eta, support=s1),\n", - " rxmc.covariance.normalization_term(parameter=eta, support=s2),\n", - " ],\n", - ")\n", - "\n", - "for name, c in [(\"case A (cross-block)\", case_A), (\"case B (shared param)\", case_B)]:\n", - " print(\n", - " f\"{name:24s} n_params={c.n_params} \"\n", - " f\"block_diagonal={c.covariance.block_diagonal}\"\n", - " )\n", - "\n", - "# same single sampled value, different Sigma structure\n", - "val = (np.log(sigma_c),)\n", - "SA = case_A.covariance_matrix(mp, val)\n", - "SB = case_B.covariance_matrix(mp, val)\n", - "print(\"case A cross-block max |Sigma[s1,s2]| =\", np.abs(SA[:N1, N1:]).max().round(4))\n", - "print(\"case B cross-block max |Sigma[s1,s2]| =\", np.abs(SB[:N1, N1:]).max().round(4))" - ] - }, - { - "cell_type": "markdown", - "id": "c12", - "metadata": {}, - "source": [ - "## Takeaways\n", - "\n", - "- **Correlated observations are just a covariance `Term` whose `support` spans\n", - " blocks.** No special machinery — a cross-block `normalization_term` (or any\n", - " a mode or kernel `Term`) writes the off-diagonal $\\Sigma$ blocks.\n", - "- Treating shared-systematic datasets **independently is overconfident**: the\n", - " common mode cannot average down.\n", - "- **A couples the data** (cross-block, off-diagonal $\\Sigma$); **B couples the\n", - " parameters** (same `Parameter` shared by block-local terms, $\\Sigma$\n", - " block-diagonal). Both are expressed by *where* you put the support and *which*\n", - " `Parameter` object you reuse." - ] - }, - { - "cell_type": "markdown", - "id": "2e389f4a", - "metadata": {}, - "source": [ - "# Shared systematics between cross-section datasets\n", - "\n", - "The toy example above carries over to real reaction data unchanged. Here two\n", - "mock *experiments* measure the same $n + {}^{40}$Ca elastic differential cross\n", - "section — one at forward angles, one at backward angles — and both were\n", - "normalized against the **same uncertain flux measurement**. That is case A:\n", - "the shared normalization couples the two datasets, so they belong in **one**\n", - "`Constraint` with a normalization mode spanning both blocks.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "7cd8e173", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:18:39.821956Z", - "iopub.status.busy": "2026-08-11T03:18:39.821803Z", - "iopub.status.idle": "2026-08-11T03:18:39.920680Z", - "shell.execute_reply": "2026-08-11T03:18:39.920050Z" - } - }, - "outputs": [], - "source": [ - "import jitr\n", - "from jitr.optical_potentials.potential_forms import (\n", - " thomas_safe,\n", - " woods_saxon_prime_safe,\n", - " woods_saxon_safe,\n", - ")\n", - "\n", - "from rxmc.params import Parameter\n", - "\n", - "Ca40 = (40, 20)\n", - "neutron = (1, 0)\n", - "E_lab = 14.1\n", - "rxn = jitr.reactions.ElasticReaction(target=Ca40, projectile=neutron)\n", - "mso = 1.0 / jitr.utils.constants.WAVENUMBER_PION\n", - "\n", - "\n", - "def central_potential(r, Vv, Wv, Rv, av, Wd, Rd, ad):\n", - " return -(Vv + 1j * Wv) * woods_saxon_safe(r, Rv, av) + (\n", - " 4j * ad * Wd\n", - " ) * woods_saxon_prime_safe(r, Rd, ad)\n", - "\n", - "\n", - "def spin_orbit_potential(r, Vso, Wso, Rso, aso):\n", - " return (Vso + 1j * Wso) * mso**2 * thomas_safe(r, Rso, aso)\n", - "\n", - "\n", - "R40 = 1.2 * 40 ** (1 / 3)\n", - "fixed_spin_orbit = (6.0, -3, R40, 0.45)\n", - "\n", - "\n", - "def extract_params(ws, *x):\n", - " return tuple(x), fixed_spin_orbit\n", - "\n", - "\n", - "omp = rxmc.elastic_diffxs_model.ElasticDifferentialXSModel(\n", - " \"dXS/dA\",\n", - " interaction_central=central_potential,\n", - " interaction_spin_orbit=spin_orbit_potential,\n", - " calculate_interaction_from_params=extract_params,\n", - " params=[\n", - " Parameter(\"Vv\", unit=\"MeV\"),\n", - " Parameter(\"Wv\", unit=\"MeV\"),\n", - " Parameter(\"Rv\", unit=\"fm\"),\n", - " Parameter(\"av\", unit=\"fm\"),\n", - " Parameter(\"Wd\", unit=\"MeV\"),\n", - " Parameter(\"Rd\", unit=\"fm\"),\n", - " Parameter(\"ad\", unit=\"fm\"),\n", - " ],\n", - " model_name=\"shared_flux_demo\",\n", - ")\n", - "omp_true_params = np.array(\n", - " [48.0, 3.5, 1.1 * 40 ** (1 / 3), 0.7, 21, 1.2 * 40 ** (1 / 3), 0.5]\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "d5480648", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:18:39.922385Z", - "iopub.status.busy": "2026-08-11T03:18:39.922240Z", - "iopub.status.idle": "2026-08-11T03:18:51.337995Z", - "shell.execute_reply": "2026-08-11T03:18:51.337238Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "def make_xs_observation(angles_deg, label):\n", - " return rxmc.elastic_diffxs_observation.ElasticDifferentialXSObservation(\n", - " x=angles_deg,\n", - " y=np.ones_like(angles_deg, dtype=float),\n", - " Elab=E_lab,\n", - " reaction=rxn,\n", - " quantity=\"dXS/dA\",\n", - " measurement_quantity=\"dXS/dA\",\n", - " y_units=\"barn / steradian\",\n", - " dataset_label=label,\n", - " )\n", - "\n", - "\n", - "sigma_flux = 0.05 # one flux calibration, shared by both experiments\n", - "flux = rng.normal(1.0, sigma_flux)\n", - "\n", - "angles_fwd = np.linspace(5.0, 90.0, 12)\n", - "angles_bwd = np.linspace(60.0, 160.0, 12)\n", - "\n", - "obs_fwd = make_xs_observation(angles_fwd, \"forward experiment\")\n", - "obs_bwd = make_xs_observation(angles_bwd, \"backward experiment\")\n", - "\n", - "for o in (obs_fwd, obs_bwd):\n", - " y_true = omp.evaluate(o, *omp_true_params)\n", - " stat = 0.05 * np.maximum(y_true, 1e-4)\n", - " o.y = np.clip(flux * y_true + rng.normal(scale=stat), 1e-6, None)\n", - " o.y_stat_err = stat\n", - "\n", - "for o in (obs_fwd, obs_bwd):\n", - " plt.errorbar(\n", - " np.rad2deg(o.x), o.y, o.y_stat_err, ls=\"none\", marker=\".\", label=o.subentry\n", - " )\n", - "plt.xlabel(r\"$\\theta$ [deg]\")\n", - "plt.ylabel(r\"$d\\sigma/d\\Omega$ [b/sr]\")\n", - "plt.yscale(\"log\")\n", - "plt.legend()\n", - "plt.title(f\"both experiments share one flux calibration = {flux:.3f}\");" - ] - }, - { - "cell_type": "markdown", - "id": "f248a5cc", - "metadata": {}, - "source": [ - "## One constraint, one cross-block normalization mode\n", - "\n", - "Exactly as in the toy: the coupled covariance gets a single\n", - "`normalization_term` whose support spans **both** blocks; the independent\n", - "alternative gives each experiment its own block-local mode.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "cd5da3bc", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:18:51.339630Z", - "iopub.status.busy": "2026-08-11T03:18:51.339493Z", - "iopub.status.idle": "2026-08-11T03:18:51.622477Z", - "shell.execute_reply": "2026-08-11T03:18:51.621873Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "coupled block-diagonal? False\n", - "independent block-diagonal? True\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "s_fwd, s_bwd = rxmc.covariance.stacked_supports([obs_fwd, obs_bwd])\n", - "s_all = np.concatenate([s_fwd, s_bwd])\n", - "\n", - "xs_coupled = rxmc.constraint.Constraint(\n", - " [obs_fwd, obs_bwd],\n", - " omp,\n", - " extra_terms=[\n", - " rxmc.covariance.normalization_term(magnitude=sigma_flux, support=s_all)\n", - " ],\n", - ")\n", - "xs_indep = rxmc.constraint.Constraint(\n", - " [obs_fwd, obs_bwd],\n", - " omp,\n", - " extra_terms=[\n", - " rxmc.covariance.normalization_term(magnitude=sigma_flux, support=s_fwd),\n", - " rxmc.covariance.normalization_term(magnitude=sigma_flux, support=s_bwd),\n", - " ],\n", - ")\n", - "print(\"coupled block-diagonal?\", xs_coupled.covariance.block_diagonal)\n", - "print(\"independent block-diagonal?\", xs_indep.covariance.block_diagonal)\n", - "\n", - "fig, axes = plt.subplots(1, 2, figsize=(9, 4))\n", - "for a, (c, title) in zip(\n", - " axes,\n", - " [(xs_coupled, \"coupled (case A)\"), (xs_indep, \"independent\")],\n", - "):\n", - " im = a.imshow(c.covariance_matrix(omp_true_params), cmap=\"viridis\")\n", - " a.set_title(title)\n", - " fig.colorbar(im, ax=a, fraction=0.046)\n", - "fig.tight_layout()" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "a5cda1bf", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:18:51.624199Z", - "iopub.status.busy": "2026-08-11T03:18:51.624047Z", - "iopub.status.idle": "2026-08-11T03:19:37.355527Z", - "shell.execute_reply": "2026-08-11T03:19:37.354746Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CPU times: user 45.8 s, sys: 2.09 ms, total: 45.8 s\n", - "Wall time: 45.7 s\n" - ] - } - ], - "source": [ - "%%time\n", - "xs_prior = stats.multivariate_normal(\n", - " mean=np.array([50.0, 3, 1.2 * 40 ** (1 / 3), 0.65, 18, 1.2 * 40 ** (1 / 3), 0.65]),\n", - " cov=np.diag([7, 7, 0.2, 0.2, 10, 0.2, 0.2]) ** 2,\n", - ")\n", - "\n", - "\n", - "def fit_xs(constraint, seed):\n", - " walker = rxmc.walker.Walker(\n", - " rxmc.param_sampling.BatchedAdaptiveMetropolisSampler(\n", - " params=omp.params,\n", - " starting_location=xs_prior.mean,\n", - " prior=xs_prior,\n", - " initial_proposal_cov=xs_prior.cov / 100,\n", - " ),\n", - " rxmc.evidence.Evidence([constraint]),\n", - " rng=np.random.default_rng(seed),\n", - " )\n", - " walker.walk(n_steps=6000, burnin=1500, batch_size=1000, verbose=False)\n", - " return walker.model_sampler.chain\n", - "\n", - "\n", - "xs_chain_coupled = fit_xs(xs_coupled, 8)\n", - "xs_chain_indep = fit_xs(xs_indep, 8)" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "8d155f69", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:19:37.357572Z", - "iopub.status.busy": "2026-08-11T03:19:37.357306Z", - "iopub.status.idle": "2026-08-11T03:19:39.348068Z", - "shell.execute_reply": "2026-08-11T03:19:39.347258Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "coupled Vv=45.63±2.31 Wv=4.19±0.82 Rv=3.90±0.14 av=0.67±0.02 Wd=20.38±1.44 Rd=4.09±0.03 ad=0.50±0.02\n", - "independent Vv=46.78±1.82 Wv=4.16±0.87 Rv=3.84±0.11 av=0.68±0.02 Wd=20.40±1.40 Rd=4.11±0.03 ad=0.50±0.02\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "for name, ch in [(\"coupled\", xs_chain_coupled), (\"independent\", xs_chain_indep)]:\n", - " print(\n", - " f\"{name:12s} \"\n", - " + \" \".join(\n", - " f\"{p.name}={ch[:, i].mean():.2f}±{ch[:, i].std():.2f}\"\n", - " for i, p in enumerate(omp.params)\n", - " )\n", - " )\n", - "\n", - "fig = corner.corner(\n", - " xs_chain_coupled,\n", - " labels=[p.name for p in omp.params],\n", - " truths=omp_true_params,\n", - " truth_color=\"k\",\n", - " color=\"tab:blue\",\n", - ")\n", - "corner.corner(xs_chain_indep, fig=fig, color=\"tab:red\")\n", - "plt.plot([], [], color=\"tab:blue\", label=\"coupled (case A)\")\n", - "plt.plot([], [], color=\"tab:red\", label=\"independent\")\n", - "fig.legend(loc=\"upper right\");" - ] - }, - { - "cell_type": "markdown", - "id": "d8d2706f", - "metadata": {}, - "source": [ - "## Takeaways, continued\n", - "\n", - "- **Real reaction data changes nothing structurally**: the shared-flux coupling\n", - " is the same three lines as the toy — put both experiments in one `Constraint`\n", - " and give the `normalization_term` a support spanning both blocks.\n", - "- The independent spelling silently claims the two flux calibrations could\n", - " fluctuate separately — a stronger (and here wrong) assumption, visible as the\n", - " covariance heatmap's missing off-diagonal blocks.\n" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.12.3" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/examples/data/alpha_ca_ratio_ruth.csv b/examples/data/alpha_ca_ratio_ruth.csv new file mode 100644 index 0000000..4c1d737 --- /dev/null +++ b/examples/data/alpha_ca_ratio_ruth.csv @@ -0,0 +1,1008 @@ +target,angle_cm_deg,ratio_to_rutherford +Ca40,14.916,0.5496 +Ca40,15.846,0.48195 +Ca40,15.855,0.40447 +Ca40,16.786,0.347 +Ca40,17.716,0.31103 +Ca40,20.024,0.30437 +Ca40,21.858,0.38739 +Ca40,21.865,0.33967 +Ca40,23.233,0.44188 +Ca40,25.534,0.45178 +Ca40,26.919,0.41394 +Ca40,27.383,0.37101 +Ca40,27.85,0.31828 +Ca40,28.778,0.26714 +Ca40,29.243,0.23424 +Ca40,29.709,0.2054 +Ca40,30.177,0.16865 +Ca40,31.102,0.14469 +Ca40,31.105,0.13549 +Ca40,32.48,0.13551 +Ca40,33.387,0.16148 +Ca40,33.836,0.19242 +Ca40,34.286,0.22433 +Ca40,35.195,0.25032 +Ca40,36.563,0.26158 +Ca40,38.844,0.26164 +Ca40,40.216,0.23453 +Ca40,40.679,0.19684 +Ca40,40.688,0.16519 +Ca40,41.149,0.14485 +Ca40,41.613,0.11894 +Ca40,42.075,0.10203 +Ca40,42.536,0.08947 +Ca40,42.999,0.07509 +Ca40,43.036,0.034879 +Ca40,43.043,0.02992 +Ca40,43.056,0.023003 +Ca40,43.06,0.021073 +Ca40,43.459,0.065844 +Ca40,43.465,0.057734 +Ca40,43.474,0.048452 +Ca40,43.481,0.041563 +Ca40,43.503,0.026817 +Ca40,43.52,0.018888 +Ca40,43.524,0.017303 +Ca40,43.984,0.015173 +Ca40,44.893,0.014209 +Ca40,46.242,0.017309 +Ca40,46.248,0.015513 +Ca40,46.675,0.026246 +Ca40,46.684,0.022026 +Ca40,46.689,0.019741 +Ca40,47.111,0.036459 +Ca40,47.12,0.030597 +Ca40,47.54,0.05904 +Ca40,47.547,0.050646 +Ca40,47.555,0.042504 +Ca40,47.975,0.08383 +Ca40,47.982,0.071911 +Ca40,48.403,0.13281 +Ca40,48.411,0.11393 +Ca40,48.418,0.097729 +Ca40,49.285,0.20586 +Ca40,49.291,0.1805 +Ca40,49.299,0.15484 +Ca40,50.632,0.22972 +Ca40,52.43,0.24006 +Ca40,54.228,0.22982 +Ca40,55.128,0.21522 +Ca40,56.03,0.18873 +Ca40,56.034,0.1729 +Ca40,56.937,0.14833 +Ca40,56.944,0.12724 +Ca40,57.397,0.11157 +Ca40,57.406,0.093636 +Ca40,57.859,0.080327 +Ca40,58.312,0.070437 +Ca40,58.318,0.061761 +Ca40,58.327,0.051832 +Ca40,58.333,0.045447 +Ca40,58.788,0.038143 +Ca40,59.24,0.034187 +Ca40,59.247,0.029326 +Ca40,59.255,0.024612 +Ca40,59.262,0.021113 +Ca40,59.716,0.018112 +Ca40,60.169,0.015201 +Ca40,60.176,0.013328 +Ca40,60.181,0.011946 +Ca40,60.631,0.010707 +Ca40,60.637,0.0093879 +Ca40,60.645,0.0080531 +Ca40,61.096,0.0070616 +Ca40,61.547,0.0060579 +Ca40,61.555,0.0051966 +Ca40,61.562,0.0044578 +Ca40,62.897,0.0042673 +Ca40,63.75,0.0086033 +Ca40,63.757,0.0075436 +Ca40,63.764,0.0064711 +Ca40,63.771,0.005551 +Ca40,63.779,0.0047618 +Ca40,64.144,0.024626 +Ca40,64.153,0.019781 +Ca40,64.162,0.016601 +Ca40,64.17,0.013932 +Ca40,64.176,0.012216 +Ca40,64.186,0.01003 +Ca40,64.561,0.041664 +Ca40,64.57,0.034966 +Ca40,64.577,0.029995 +Ca40,64.995,0.049648 +Ca40,65.432,0.056625 +Ca40,66.308,0.066017 +Ca40,67.186,0.073667 +Ca40,68.503,0.082208 +Ca40,70.26,0.084047 +Ca40,71.581,0.077007 +Ca40,72.025,0.067525 +Ca40,72.032,0.057924 +Ca40,72.476,0.050792 +Ca40,72.481,0.045522 +Ca40,72.486,0.040799 +Ca40,72.932,0.034242 +Ca40,72.938,0.030024 +Ca40,72.944,0.026326 +Ca40,73.389,0.022584 +Ca40,73.396,0.019373 +Ca40,73.403,0.016619 +Ca40,73.851,0.01335 +Ca40,73.856,0.011705 +Ca40,74.302,0.0098241 +Ca40,74.745,0.0084277 +Ca40,74.755,0.0069196 +Ca40,74.763,0.0058071 +Ca40,74.77,0.0049815 +Ca40,74.777,0.0043679 +Ca40,74.784,0.0037469 +Ca40,74.791,0.0032142 +Ca40,75.234,0.0027573 +Ca40,75.245,0.0021668 +Ca40,75.676,0.0024178 +Ca40,75.687,0.0019 +Ca40,77.842,0.0028193 +Ca40,77.849,0.002472 +Ca40,77.861,0.0019005 +Ca40,78.25,0.0049836 +Ca40,78.264,0.0037484 +Ca40,78.271,0.0032155 +Ca40,78.29,0.0021207 +Ca40,78.638,0.013357 +Ca40,78.646,0.011458 +Ca40,78.653,0.0096161 +Ca40,78.661,0.0080702 +Ca40,78.669,0.0067728 +Ca40,78.674,0.0060701 +Ca40,78.69,0.0043699 +Ca40,79.042,0.025215 +Ca40,79.05,0.021162 +Ca40,79.056,0.018555 +Ca40,79.061,0.01663 +Ca40,79.454,0.039948 +Ca40,79.46,0.035027 +Ca40,79.465,0.030713 +Ca40,80.311,0.047605 +Ca40,81.168,0.055501 +Ca40,81.593,0.063301 +Ca40,82.449,0.0738 +Ca40,84.596,0.078834 +Ca40,85.885,0.077138 +Ca40,87.599,0.072246 +Ca40,88.457,0.066191 +Ca40,88.889,0.059327 +Ca40,89.319,0.053174 +Ca40,89.75,0.047659 +Ca40,90.182,0.041791 +Ca40,90.612,0.037457 +Ca40,91.467,0.032847 +Ca40,92.738,0.033579 +Ca40,93.581,0.036658 +Ca40,93.997,0.042736 +Ca40,94.411,0.050926 +Ca40,94.826,0.060684 +Ca40,95.241,0.069213 +Ca40,96.077,0.080693 +Ca40,96.492,0.092033 +Ca40,96.906,0.10497 +Ca40,97.741,0.11973 +Ca40,98.576,0.1307 +Ca40,100.66,0.1491 +Ca40,102.33,0.14274 +Ca40,103.58,0.13368 +Ca40,104.42,0.11982 +Ca40,105.25,0.1074 +Ca40,106.08,0.094183 +Ca40,106.09,0.082582 +Ca40,106.51,0.070845 +Ca40,106.93,0.062121 +Ca40,106.94,0.053289 +Ca40,108.18,0.047768 +Ca40,109.01,0.043764 +Ca40,110.64,0.054495 +Ca40,110.65,0.046747 +Ca40,111.46,0.063533 +Ca40,111.86,0.072462 +Ca40,112.26,0.082646 +Ca40,113.49,0.094271 +Ca40,113.88,0.10519 +Ca40,115.1,0.11484 +Ca40,117.14,0.11238 +Ca40,118.36,0.10525 +Ca40,119.16,0.096428 +Ca40,119.58,0.084555 +Ca40,119.99,0.074144 +Ca40,120.8,0.063609 +Ca40,121.2,0.057012 +Ca40,121.61,0.049992 +Ca40,122.43,0.04481 +Ca40,122.83,0.039292 +Ca40,123.24,0.03761 +Ca40,124.83,0.038451 +Ca40,125.23,0.044826 +Ca40,126.42,0.051131 +Ca40,127.21,0.057056 +Ca40,127.61,0.066516 +Ca40,128.8,0.074228 +Ca40,130.38,0.075888 +Ca40,131.58,0.071071 +Ca40,131.58,0.063697 +Ca40,131.98,0.057091 +Ca40,132.38,0.051171 +Ca40,132.78,0.04487 +Ca40,133.18,0.038492 +Ca40,133.19,0.03302 +Ca40,133.99,0.027714 +Ca40,134.38,0.024302 +Ca40,134.4,0.017883 +Ca40,134.78,0.020848 +Ca40,135.2,0.016029 +Ca40,135.2,0.014366 +Ca40,135.6,0.012876 +Ca40,135.99,0.011291 +Ca40,136,0.0096853 +Ca40,136.01,0.0084923 +Ca40,136.02,0.0063876 +Ca40,136.4,0.0074466 +Ca40,136.42,0.0054797 +Ca40,136.81,0.0050202 +Ca40,136.82,0.0038596 +Ca40,137.21,0.0043067 +Ca40,137.22,0.0032393 +Ca40,137.23,0.0028403 +Ca40,137.24,0.0024365 +Ca40,137.24,0.0022815 +Ca40,138.41,0.0022324 +Ca40,138.76,0.0058537 +Ca40,138.79,0.0033117 +Ca40,138.8,0.0027793 +Ca40,138.8,0.0025461 +Ca40,139.16,0.0046004 +Ca40,139.17,0.0039463 +Ca40,139.53,0.008132 +Ca40,139.54,0.0068247 +Ca40,139.9,0.015019 +Ca40,139.9,0.017508 +Ca40,139.91,0.012604 +Ca40,139.92,0.010578 +Ca40,139.92,0.0092749 +Ca40,140.27,0.023278 +Ca40,140.28,0.020411 +Ca40,140.64,0.041148 +Ca40,140.65,0.030279 +Ca40,140.65,0.034532 +Ca40,140.66,0.027137 +Ca40,141.03,0.045913 +Ca40,141.41,0.052366 +Ca40,141.41,0.057162 +Ca40,142.18,0.065199 +Ca40,142.56,0.074362 +Ca40,143.34,0.082979 +Ca40,144.5,0.090593 +Ca40,146.05,0.09467 +Ca40,147.99,0.092642 +Ca40,149.16,0.084883 +Ca40,149.93,0.077769 +Ca40,150.32,0.069704 +Ca40,150.32,0.061118 +Ca40,150.71,0.053592 +Ca40,151.11,0.045975 +Ca40,151.5,0.040314 +Ca40,151.51,0.033833 +Ca40,151.89,0.028395 +Ca40,151.9,0.024358 +Ca40,152.3,0.022316 +Ca40,152.3,0.017157 +Ca40,152.3,0.015377 +Ca40,152.68,0.019568 +Ca40,152.7,0.013483 +Ca40,152.77,0.0021882 +Ca40,152.78,0.0017577 +Ca40,152.79,0.0013813 +Ca40,153.09,0.011823 +Ca40,153.09,0.010596 +Ca40,153.11,0.0073014 +Ca40,153.13,0.0048154 +Ca40,153.14,0.003868 +Ca40,153.14,0.0034667 +Ca40,153.14,0.0030397 +Ca40,153.15,0.0024416 +Ca40,153.16,0.0019612 +Ca40,153.17,0.0015754 +Ca40,153.18,0.0012935 +Ca40,153.48,0.0092916 +Ca40,153.49,0.0081471 +Ca40,153.5,0.0061279 +Ca40,153.5,0.0053731 +Ca40,153.51,0.004316 +Ca40,153.54,0.0027244 +Ca40,153.95,0.0013815 +Ca40,154.31,0.0020948 +Ca40,154.32,0.0015081 +Ca40,154.66,0.0051436 +Ca40,154.67,0.0038688 +Ca40,154.67,0.0043167 +Ca40,154.68,0.0032468 +Ca40,154.69,0.0024421 +Ca40,154.69,0.0027852 +Ca40,154.7,0.0017971 +Ca40,155,0.011826 +Ca40,155.01,0.0099249 +Ca40,155.02,0.0081488 +Ca40,155.03,0.0068387 +Ca40,155.04,0.0057393 +Ca40,155.36,0.024369 +Ca40,155.37,0.021841 +Ca40,155.38,0.01833 +Ca40,155.38,0.015724 +Ca40,155.39,0.013787 +Ca40,155.73,0.031699 +Ca40,155.74,0.027192 +Ca40,156.12,0.036954 +Ca40,156.48,0.049134 +Ca40,156.49,0.041235 +Ca40,156.85,0.063911 +Ca40,156.86,0.056039 +Ca40,157.23,0.084975 +Ca40,157.24,0.076158 +Ca40,157.6,0.11298 +Ca40,157.61,0.10126 +Ca40,157.96,0.1676 +Ca40,157.98,0.12886 +Ca40,158.34,0.19116 +Ca40,158.35,0.14697 +Ca40,159.11,0.21331 +Ca40,159.48,0.23802 +Ca40,160.24,0.25984 +Ca40,161.77,0.27154 +Ca40,162.91,0.25994 +Ca40,163.3,0.23814 +Ca40,163.69,0.19553 +Ca40,164.06,0.21345 +Ca40,164.45,0.17527 +Ca40,164.46,0.15708 +Ca40,164.85,0.13774 +Ca40,165.23,0.12078 +Ca40,165.24,0.1059 +Ca40,165.63,0.094919 +Ca40,165.63,0.086955 +Ca40,165.63,0.077933 +Ca40,165.64,0.068334 +Ca40,166.02,0.061247 +Ca40,166.03,0.048131 +Ca40,166.03,0.045069 +Ca40,166.04,0.038661 +Ca40,166.05,0.031743 +Ca40,166.05,0.028449 +Ca40,166.06,0.025498 +Ca40,166.07,0.018356 +Ca40,166.4,0.054895 +Ca40,166.42,0.03542 +Ca40,166.44,0.022358 +Ca40,166.45,0.020038 +Ca40,166.46,0.017189 +Ca40,166.84,0.015748 +Ca40,166.85,0.014114 +Ca40,167.97,0.021878 +Ca40,167.98,0.017574 +Ca40,167.98,0.014749 +Ca40,168.31,0.052555 +Ca40,168.32,0.045083 +Ca40,168.34,0.028458 +Ca40,168.35,0.024953 +Ca40,168.71,0.033177 +Ca40,168.71,0.038675 +Ca40,169.05,0.083266 +Ca40,169.06,0.07301 +Ca40,169.07,0.062629 +Ca40,169.41,0.13484 +Ca40,169.42,0.11567 +Ca40,169.43,0.10142 +Ca40,169.77,0.23835 +Ca40,169.78,0.20446 +Ca40,169.79,0.15379 +Ca40,170.13,0.33843 +Ca40,170.14,0.29031 +Ca40,170.16,0.17929 +Ca40,170.5,0.45994 +Ca40,170.51,0.39454 +Ca40,170.88,0.52457 +Ca40,171.63,0.58536 +Ca40,171.63,0.66759 +Ca40,172.01,0.72877 +Ca44,14.86,0.6024 +Ca44,15.785,0.4932 +Ca44,17.166,0.4317 +Ca44,18.536,0.4223 +Ca44,19.895,0.4827 +Ca44,21.72,0.5395 +Ca44,23.543,0.5397 +Ca44,24.931,0.4322 +Ca44,25.397,0.3699 +Ca44,26.318,0.3029 +Ca44,27.238,0.2269 +Ca44,27.703,0.1858 +Ca44,29.088,0.1521 +Ca44,29.099,0.1274 +Ca44,30.007,0.109 +Ca44,31.379,0.1066 +Ca44,32.275,0.1192 +Ca44,33.623,0.1664 +Ca44,34.518,0.2033 +Ca44,36.316,0.2483 +Ca44,39.014,0.2968 +Ca44,39.487,0.243 +Ca44,40.399,0.1946 +Ca44,41.31,0.1666 +Ca44,41.321,0.1364 +Ca44,41.332,0.1167 +Ca44,41.342,0.09771 +Ca44,41.375,0.04589 +Ca44,41.803,0.08 +Ca44,41.814,0.06697 +Ca44,41.825,0.05362 +Ca44,42.307,0.02943 +Ca44,42.746,0.03675 +Ca44,43.216,0.02305 +Ca44,43.676,0.01846 +Ca44,45.034,0.01766 +Ca44,45.888,0.0393 +Ca44,45.92,0.02205 +Ca44,46.358,0.02754 +Ca44,46.752,0.06554 +Ca44,46.774,0.0502 +Ca44,47.19,0.08186 +Ca44,48.074,0.1022 +Ca44,49.405,0.1277 +Ca44,50.287,0.1492 +Ca44,51.636,0.1428 +Ca44,54.317,0.1278 +Ca44,55.66,0.1001 +Ca44,55.671,0.08568 +Ca44,56.125,0.07498 +Ca44,56.579,0.06277 +Ca44,56.601,0.0385 +Ca44,57.476,0.04808 +Ca44,57.508,0.03015 +Ca44,57.54,0.01692 +Ca44,57.961,0.02414 +Ca44,57.972,0.02021 +Ca44,57.993,0.01448 +Ca44,57.993,0.01239 +Ca44,58.003,0.01085 +Ca44,58.035,0.005694 +Ca44,58.098,0.002141 +Ca44,58.098,0.001874 +Ca44,58.456,0.008686 +Ca44,58.467,0.007111 +Ca44,58.488,0.004983 +Ca44,58.52,0.003125 +Ca44,58.52,0.002735 +Ca44,58.941,0.004172 +Ca44,58.951,0.003571 +Ca44,59.436,0.001754 +Ca44,60.697,0.005824 +Ca44,60.739,0.002503 +Ca44,60.739,0.002735 +Ca44,61.065,0.0221 +Ca44,61.075,0.0185 +Ca44,61.086,0.01549 +Ca44,61.096,0.01213 +Ca44,61.107,0.01015 +Ca44,61.149,0.004664 +Ca44,61.159,0.003904 +Ca44,61.17,0.003417 +Ca44,61.201,0.001917 +Ca44,61.485,0.03017 +Ca44,61.495,0.02525 +Ca44,61.558,0.008312 +Ca44,61.569,0.006958 +Ca44,61.926,0.03525 +Ca44,62.345,0.04501 +Ca44,62.345,0.05143 +Ca44,63.215,0.06424 +Ca44,64.084,0.07342 +Ca44,65.401,0.08391 +Ca44,67.143,0.09379 +Ca44,68.902,0.08583 +Ca44,69.786,0.07348 +Ca44,70.232,0.06151 +Ca44,70.678,0.05149 +Ca44,70.678,0.04507 +Ca44,70.689,0.03857 +Ca44,70.699,0.03301 +Ca44,71.145,0.02764 +Ca44,71.591,0.02314 +Ca44,71.601,0.01853 +Ca44,71.611,0.01621 +Ca44,72.057,0.01215 +Ca44,72.067,0.01063 +Ca44,72.512,0.008703 +Ca44,72.522,0.007449 +Ca44,72.967,0.006099 +Ca44,72.978,0.005338 +Ca44,73.412,0.004777 +Ca44,73.432,0.003911 +Ca44,73.877,0.003202 +Ca44,73.877,0.002741 +Ca44,74.764,0.002244 +Ca44,75.208,0.001681 +Ca44,76.001,0.007129 +Ca44,76.011,0.005836 +Ca44,76.063,0.0021 +Ca44,76.073,0.001837 +Ca44,76.361,0.02587 +Ca44,76.371,0.01982 +Ca44,76.402,0.01299 +Ca44,76.413,0.01064 +Ca44,76.423,0.009104 +Ca44,76.454,0.004779 +Ca44,76.464,0.004182 +Ca44,76.485,0.002681 +Ca44,76.495,0.002347 +Ca44,76.824,0.01485 +Ca44,76.906,0.003275 +Ca44,77.215,0.03091 +Ca44,78.067,0.03861 +Ca44,79.78,0.04823 +Ca44,81.498,0.05893 +Ca44,83.64,0.05393 +Ca44,84.505,0.04416 +Ca44,85.389,0.02895 +Ca44,85.399,0.02424 +Ca44,85.795,0.03865 +Ca44,85.805,0.03236 +Ca44,86.261,0.02029 +Ca44,86.697,0.01737 +Ca44,86.707,0.01422 +Ca44,87.143,0.01217 +Ca44,87.143,0.01042 +Ca44,87.163,0.007804 +Ca44,87.174,0.00668 +Ca44,87.578,0.009118 +Ca44,90.134,0.007636 +Ca44,90.154,0.006114 +Ca44,90.547,0.01019 +Ca44,90.95,0.0159 +Ca44,90.96,0.01302 +Ca44,91.785,0.01942 +Ca44,92.619,0.02373 +Ca44,93.452,0.02899 +Ca44,93.863,0.03463 +Ca44,95.114,0.04326 +Ca44,96.783,0.05169 +Ca44,98.456,0.05286 +Ca44,99.718,0.04731 +Ca44,100.15,0.04234 +Ca44,100.99,0.03624 +Ca44,102.24,0.03172 +Ca44,102.24,0.02715 +Ca44,103.08,0.02377 +Ca44,103.51,0.0199 +Ca44,104.35,0.01741 +Ca44,105.64,0.01524 +Ca44,106.82,0.01364 +Ca44,108.87,0.01491 +Ca44,109.75,0.01743 +Ca44,110.92,0.01992 +Ca44,111.7,0.0238 +Ca44,112.58,0.0266 +Ca44,113.36,0.03039 +Ca44,115.01,0.03474 +Ca44,117.81,0.03475 +Ca44,118.68,0.02975 +Ca44,119.06,0.02604 +Ca44,119.93,0.01994 +Ca44,120.31,0.01746 +Ca44,121.08,0.01461 +Ca44,121.17,0.01223 +Ca44,122.32,0.01002 +Ca44,122.8,0.008202 +Ca44,123.95,0.006867 +Ca44,123.95,0.005878 +Ca44,124.43,0.005031 +Ca44,126.43,0.004503 +Ca44,127.19,0.005146 +Ca44,127.19,0.006148 +Ca44,127.57,0.007183 +Ca44,127.57,0.009172 +Ca44,128.33,0.01072 +Ca44,128.33,0.01252 +Ca44,128.71,0.01463 +Ca44,131.17,0.01636 +Ca44,133.15,0.016 +Ca44,134.66,0.01432 +Ca44,135.5,0.01199 +Ca44,136.35,0.007193 +Ca44,136.72,0.008404 +Ca44,136.72,0.01004 +Ca44,137.47,0.00576 +Ca44,138.69,0.005155 +Ca44,141.87,0.004719 +Ca44,142.61,0.00404 +Ca44,142.98,0.003615 +Ca44,143.82,0.003164 +Ca44,143.82,0.002534 +Ca44,145.03,0.001776 +Ca44,145.03,0.001019 +Ca44,145.4,0.001422 +Ca44,145.4,0.001272 +Ca44,145.4,0.002169 +Ca44,145.86,0.0008917 +Ca44,145.86,0.0006389 +Ca44,146.23,0.000714 +Ca44,146.23,0.0005717 +Ca44,146.6,0.0005004 +Ca44,147.07,0.0004478 +Ca44,147.81,0.0005117 +Ca44,148.55,0.0006114 +Ca44,148.55,0.001114 +Ca44,148.92,0.000975 +Ca44,148.92,0.0006986 +Ca44,149.29,0.001331 +Ca44,149.29,0.001626 +Ca44,149.29,0.001817 +Ca44,149.29,0.002269 +Ca44,149.29,0.002771 +Ca44,149.38,0.0008534 +Ca44,149.66,0.003167 +Ca44,150.4,0.003619 +Ca44,150.86,0.004324 +Ca44,151.23,0.005052 +Ca44,151.96,0.006171 +Ca44,152.33,0.006897 +Ca44,153.53,0.007883 +Ca44,155,0.007884 +Ca44,156.2,0.00675 +Ca44,157.02,0.003171 +Ca44,157.39,0.005406 +Ca44,157.39,0.004627 +Ca44,157.39,0.003705 +Ca44,157.39,0.006041 +Ca44,157.39,0.002654 +Ca44,157.39,0.002222 +Ca44,157.85,0.001945 +Ca44,158.95,0.001741 +Ca44,160.14,0.001945 +Ca44,160.5,0.002376 +Ca44,160.87,0.002597 +Ca44,161.24,0.003244 +Ca44,161.6,0.003626 +Ca44,161.97,0.004429 +Ca44,162.42,0.005175 +Ca44,163.52,0.006464 +Ca44,165.44,0.007226 +Ca44,166.26,0.006612 +Ca44,166.62,0.005917 +Ca44,166.62,0.005294 +Ca44,167.35,0.004634 +Ca44,167.81,0.003879 +Ca44,167.81,0.002719 +Ca44,168.17,0.003395 +Ca44,168.17,0.002433 +Ca44,168.17,0.001905 +Ca44,169.36,0.001705 +Ca44,170.09,0.001949 +Ca44,170.09,0.002328 +Ca44,170.09,0.003177 +Ca44,170.45,0.00266 +Ca44,170.81,0.003713 +Ca44,171.18,0.004535 +Ca44,171.54,0.006472 +Ca44,171.54,0.007561 +Ca44,171.63,0.00554 +Ca44,172.36,0.009034 +Ca44,172.36,0.01079 +Ca44,172.73,0.01289 +Ca44,172.73,0.01473 +Ca44,173.09,0.0184 +Ca44,173.09,0.02056 +Ca44,173.45,0.02568 +Ca44,173.82,0.0287 +Ca48,15.933,0.57851 +Ca48,16.845,0.50721 +Ca48,17.302,0.46463 +Ca48,17.759,0.41639 +Ca48,19.573,0.46469 +Ca48,20.479,0.49631 +Ca48,21.84,0.5301 +Ca48,23.2,0.51864 +Ca48,24.563,0.45473 +Ca48,25.02,0.39868 +Ca48,25.022,0.3652 +Ca48,25.477,0.32018 +Ca48,26.839,0.28073 +Ca48,26.841,0.25715 +Ca48,27.296,0.23045 +Ca48,27.298,0.2111 +Ca48,27.305,0.15529 +Ca48,27.754,0.18106 +Ca48,28.664,0.13918 +Ca48,29.12,0.11938 +Ca48,30.027,0.10936 +Ca48,31.83,0.11939 +Ca48,32.278,0.13619 +Ca48,33.178,0.15535 +Ca48,33.623,0.18514 +Ca48,34.071,0.21118 +Ca48,34.52,0.23566 +Ca48,35.418,0.25728 +Ca48,38.565,0.26303 +Ca48,39.017,0.23572 +Ca48,39.027,0.15884 +Ca48,39.47,0.20666 +Ca48,39.471,0.1935 +Ca48,39.473,0.17725 +Ca48,39.937,0.093846 +Ca48,40.376,0.13927 +Ca48,40.379,0.11945 +Ca48,40.382,0.10942 +Ca48,40.389,0.082278 +Ca48,40.392,0.07057 +Ca48,41.293,0.06053 +Ca48,41.296,0.053068 +Ca48,41.747,0.046526 +Ca48,41.75,0.041695 +Ca48,42.202,0.034986 +Ca48,42.206,0.029357 +Ca48,42.657,0.02518 +Ca48,43.107,0.023066 +Ca48,43.989,0.039045 +Ca48,44.433,0.044537 +Ca48,44.442,0.032052 +Ca48,44.444,0.028101 +Ca48,44.447,0.024636 +Ca48,45.315,0.075389 +Ca48,45.318,0.064661 +Ca48,45.323,0.054257 +Ca48,46.201,0.10476 +Ca48,46.205,0.085995 +Ca48,46.643,0.12214 +Ca48,47.085,0.14557 +Ca48,48.421,0.16245 +Ca48,49.754,0.17351 +Ca48,51.535,0.15551 +Ca48,51.538,0.13633 +Ca48,52.873,0.12219 +Ca48,52.875,0.1095 +Ca48,53.321,0.1003 +Ca48,53.324,0.087937 +Ca48,54.215,0.075427 +Ca48,54.217,0.066128 +Ca48,54.668,0.048648 +Ca48,55.106,0.057978 +Ca48,55.112,0.044564 +Ca48,55.116,0.038222 +Ca48,55.137,0.015554 +Ca48,55.561,0.033511 +Ca48,55.568,0.024652 +Ca48,55.577,0.017742 +Ca48,55.583,0.013051 +Ca48,55.587,0.010951 +Ca48,55.59,0.0096012 +Ca48,56.008,0.028119 +Ca48,56.014,0.021144 +Ca48,56.919,0.0087955 +Ca48,58.241,0.0096026 +Ca48,58.679,0.010953 +Ca48,59.108,0.018541 +Ca48,59.116,0.013054 +Ca48,59.552,0.015903 +Ca48,59.983,0.024123 +Ca48,59.986,0.021149 +Ca48,60.414,0.036593 +Ca48,60.417,0.032081 +Ca48,60.42,0.027516 +Ca48,60.841,0.061941 +Ca48,60.846,0.050847 +Ca48,61.277,0.073821 +Ca48,61.289,0.043612 +Ca48,61.713,0.086071 +Ca48,62.15,0.098178 +Ca48,63.464,0.10956 +Ca48,64.777,0.11962 +Ca48,66.53,0.10721 +Ca48,67.406,0.093993 +Ca48,67.852,0.060622 +Ca48,67.858,0.047629 +Ca48,68.284,0.077162 +Ca48,68.287,0.067649 +Ca48,68.291,0.055532 +Ca48,68.298,0.039966 +Ca48,68.302,0.033535 +Ca48,68.305,0.028763 +Ca48,69.181,0.025218 +Ca48,69.184,0.021629 +Ca48,69.19,0.016625 +Ca48,69.193,0.014575 +Ca48,69.623,0.018552 +Ca48,70.069,0.011965 +Ca48,70.078,0.007717 +Ca48,70.086,0.0056769 +Ca48,70.505,0.010961 +Ca48,70.51,0.009401 +Ca48,70.517,0.0067657 +Ca48,70.958,0.0050876 +Ca48,70.961,0.0044604 +Ca48,72.267,0.0039108 +Ca48,73.123,0.0063359 +Ca48,73.56,0.0054344 +Ca48,73.564,0.00456 +Ca48,73.985,0.0078899 +Ca48,74.406,0.013355 +Ca48,74.41,0.011206 +Ca48,74.415,0.0089996 +Ca48,74.834,0.01627 +Ca48,75.253,0.028775 +Ca48,75.257,0.024144 +Ca48,75.262,0.01939 +Ca48,75.677,0.041776 +Ca48,75.683,0.033549 +Ca48,76.106,0.049788 +Ca48,76.532,0.059337 +Ca48,77.393,0.067685 +Ca48,79.113,0.072295 +Ca48,81.26,0.072304 +Ca48,81.691,0.067702 +Ca48,82.122,0.059357 +Ca48,82.124,0.054372 +Ca48,82.127,0.047668 +Ca48,82.129,0.042718 +Ca48,82.564,0.032123 +Ca48,82.99,0.035846 +Ca48,83.423,0.027553 +Ca48,83.426,0.024156 +Ca48,83.857,0.020719 +Ca48,84.288,0.017771 +Ca48,84.292,0.014912 +Ca48,84.722,0.013074 +Ca48,85.151,0.011462 +Ca48,85.155,0.0096177 +Ca48,85.584,0.0088102 +Ca48,85.587,0.007724 +Ca48,85.59,0.0067717 +Ca48,85.592,0.0059369 +Ca48,86.033,0.0032129 +Ca48,86.036,0.0028168 +Ca48,86.447,0.0053206 +Ca48,86.455,0.0036648 +Ca48,86.875,0.0047682 +Ca48,86.879,0.0040896 +Ca48,88.163,0.0026963 +Ca48,89.01,0.0030089 +Ca48,89.417,0.006342 +Ca48,89.43,0.0035082 +Ca48,89.826,0.012516 +Ca48,89.834,0.0086213 +Ca48,89.837,0.0075584 +Ca48,89.847,0.0048747 +Ca48,89.849,0.0042738 +Ca48,90.242,0.017777 +Ca48,90.253,0.010503 +Ca48,90.67,0.014594 +Ca48,91.081,0.024167 +Ca48,91.084,0.021188 +Ca48,92.768,0.02818 +Ca48,93.187,0.031446 +Ca48,94.028,0.033586 +Ca48,95.291,0.033588 +Ca48,96.969,0.033592 +Ca48,97.392,0.030104 +Ca48,97.394,0.026978 +Ca48,97.4,0.020736 +Ca48,97.815,0.024713 +Ca48,97.821,0.01818 +Ca48,98.661,0.016293 +Ca48,99.081,0.014601 +Ca48,99.083,0.013375 +Ca48,99.088,0.010741 +Ca48,99.503,0.012252 +Ca48,99.509,0.0092129 +Ca48,99.929,0.0082563 +Ca48,99.932,0.0072384 +Ca48,99.934,0.0066305 +Ca48,100.36,0.0055638 +Ca48,100.36,0.004986 +Ca48,100.78,0.0046686 +Ca48,100.78,0.004093 +Ca48,100.78,0.003668 +Ca48,101.62,0.0032872 +Ca48,103.28,0.0032876 +Ca48,103.69,0.0036686 +Ca48,104.51,0.0060754 +Ca48,104.52,0.0053264 +Ca48,104.52,0.0046697 +Ca48,104.52,0.004094 +Ca48,104.92,0.0067796 +Ca48,104.92,0.0079044 +Ca48,105.34,0.0094205 +Ca48,105.74,0.011227 +Ca48,106.15,0.012529 +Ca48,106.15,0.014607 +Ca48,106.98,0.016662 +Ca48,107.79,0.020299 +Ca48,108.62,0.023155 +Ca48,110.26,0.02528 +Ca48,112.32,0.025844 +Ca48,113.55,0.0242 +Ca48,113.95,0.020757 +Ca48,114.37,0.018602 +Ca48,114.37,0.016308 +Ca48,115.19,0.015271 +Ca48,115.6,0.013388 +Ca48,116.83,0.011739 +Ca48,118.87,0.011236 +Ca48,120.88,0.01369 +Ca48,121.29,0.012002 +Ca48,122.5,0.015278 +Ca48,122.9,0.017427 +Ca48,123.7,0.019447 +Ca48,124.11,0.021701 +Ca48,124.91,0.024217 +Ca48,125.71,0.027025 +Ca48,127.72,0.03016 +Ca48,129.32,0.032215 +Ca48,131.32,0.03152 +Ca48,132.52,0.029515 +Ca48,133.32,0.027038 +Ca48,133.71,0.024768 +Ca48,134.91,0.02269 +Ca48,135.71,0.021246 +Ca48,136.9,0.019895 +Ca48,137.3,0.017442 +Ca48,138.88,0.015633 +Ca48,140.86,0.014964 +Ca48,142.05,0.016337 +Ca48,142.43,0.01823 +Ca48,143.22,0.019903 +Ca48,143.61,0.02221 +Ca48,145.18,0.025336 +Ca48,145.96,0.0289 +Ca48,146.75,0.03225 +Ca48,148.7,0.033701 +Ca48,150.27,0.030204 +Ca48,151.84,0.025908 +Ca48,152.23,0.023733 +Ca48,152.62,0.020808 +Ca48,153.4,0.019061 +Ca48,153.8,0.017082 +Ca48,154.97,0.015996 +Ca48,155.75,0.01565 +Ca48,157.3,0.015998 +Ca48,158.46,0.017853 +Ca48,158.85,0.020365 +Ca48,159.24,0.022232 +Ca48,161.18,0.024273 +Ca48,162.72,0.025927 +Ca48,163.12,0.022731 +Ca48,163.51,0.019929 +Ca48,163.89,0.017093 +Ca48,164.67,0.014987 +Ca48,164.67,0.013139 +Ca48,164.68,0.010099 +Ca48,165.06,0.011775 +Ca48,166.23,0.0090511 +Ca48,166.61,0.008663 +Ca48,167.77,0.0098819 +Ca48,168.15,0.01499 +Ca48,168.15,0.016727 +Ca48,168.54,0.019503 +Ca48,168.54,0.012578 +Ca48,168.54,0.011028 +Ca48,168.92,0.022739 +Ca48,169.68,0.025939 +Ca48,170.07,0.028945 +Ca48,170.07,0.032299 +Ca48,170.44,0.044881 +Ca48,170.45,0.038494 +Ca48,170.83,0.053489 +Ca48,171.6,0.062367 +Ca48,171.99,0.072716 +Ca48,172.75,0.082946 +Ca48,172.75,0.096708 +Ca48,173.13,0.11276 +Ca48,173.9,0.1231 +Ca48,174.28,0.14353 +Ca48,174.28,0.16016 +Ca48,174.66,0.17105 diff --git a/examples/data/p40ca_elastic_35p8mev_gross1967.csv b/examples/data/p40ca_elastic_35p8mev_gross1967.csv new file mode 100644 index 0000000..c3e3d4a --- /dev/null +++ b/examples/data/p40ca_elastic_35p8mev_gross1967.csv @@ -0,0 +1,50 @@ +# EXFOR C0076002: p + 40Ca elastic, Elab = 35.8 MeV, measured dXS/dA (CM) +# E. E. Gross et al., Nucl. Phys. A 102, 673 (1967); statistical errors (ERR-S) only +angle_cm_deg,dxs_mb_sr,stat_err_mb_sr +10.24,5562.,177.984 +12.80,3426.,106.206 +15.36,2354.,61.204 +17.92,1525.,38.125 +20.48,959.1,23.018 +23.03,525.5,13.663 +25.59,267.4,6.685 +28.14,106.6,3.198 +30.70,47.86,1.197 +33.25,38.42,0.961 +35.80,58.79,1.411 +38.35,77.85,1.946 +40.90,94.19,2.261 +43.44,99.49,2.487 +45.99,99.59,2.390 +48.53,81.66,2.205 +51.07,67.73,1.626 +53.61,47.41,1.328 +56.14,35.11,0.948 +58.68,22.01,0.682 +61.21,15.05,0.391 +63.74,9.683,0.2905 +66.26,8.718,0.2441 +68.79,8.500,0.2210 +71.31,8.606,0.2151 +73.83,8.355,0.2506 +76.35,8.252,0.2311 +78.86,8.004,0.2321 +81.37,7.681,0.1920 +86.39,5.608,0.1795 +91.39,3.286,0.1084 +96.39,2.015,0.0564 +101.37,1.250,0.0300 +106.35,1.128,0.0338 +111.31,1.119,0.0280 +116.26,1.109,0.0455 +121.21,0.864,0.0259 +126.14,0.521,0.0287 +131.07,0.305,0.0088 +135.98,0.169,0.0052 +140.89,0.183,0.0046 +145.80,0.398,0.0115 +150.70,0.564,0.0141 +155.59,0.683,0.0219 +160.48,0.706,0.0191 +165.36,0.666,0.0246 +170.24,0.402,0.0177 diff --git a/examples/gp_discrepancy.ipynb b/examples/gp_discrepancy.ipynb index 236a733..1713416 100644 --- a/examples/gp_discrepancy.ipynb +++ b/examples/gp_discrepancy.ipynb @@ -2,370 +2,407 @@ "cells": [ { "cell_type": "markdown", - "id": "c00", + "id": "75c9df24", "metadata": {}, "source": [ - "# Model discrepancy with a Gaussian-process term\n", + "# Model discrepancy with a Gaussian process\n", "\n", - "A linear model is fit to data drawn from a *mildly non-linear* truth. The model\n", - "is structurally wrong, so a plain fit leaves **correlated** residuals. We absorb\n", - "that structure with a Gaussian-process (GP) **discrepancy** term added to the\n", - "constraint covariance — a `rxmc.covariance.kernel_term` built from a scikit-learn\n", - "kernel — and then **propagate the total uncertainty** (model parameters + GP\n", - "discrepancy + observation noise) to a fine prediction grid using\n", - "`rxmc.predictive.total_predictive_band`.\n", + "Every physics model we calibrate is wrong somewhere. Often it's wrong in a *structured* way: it drifts away from reality smoothly as a function of $x$, rather than missing randomly point by point. When that happens, the residuals it leaves behind are correlated with each other. If our covariance assumes the points are independent, the likelihood reads those correlated residuals as a series of independent confirmations, and the posterior ends up far more confident than it has any right to be.\n", "\n", - "This is the Kennedy & O'Hagan picture: the discrepancy is a latent correlated\n", - "function, marginalised over its GP prior. The kernel term only inflates the\n", - "covariance **at the data points**; predicting the discrepancy at *new* points is\n", - "the GP posterior-predictive provided by `rxmc.predictive.gp_posterior_predictive`." + "The standard way to handle this is from [Kennedy & O'Hagan (2001)](https://doi.org/10.1111/1467-9868.00294), who add a *discrepancy* term $\\delta(x)$ to the model, so that reality is $y_m(x;\\alpha) + \\delta(x)$. Usually $\\delta$ gets a [Gaussian process](https://en.wikipedia.org/wiki/Gaussian_process) prior. People mean two rather different things when they say this, and it's worth separating them before we start:\n", + "\n", + "- A **mean-zero discrepancy** only learns the *covariance* of the mismatch. We tell the likelihood that the truth departs smoothly from our model, roughly how far and how smoothly, and then integrate over every departure consistent with that. We never try to say what $\\delta(x)$ actually *is*.\n", + "- A **non-zero-mean discrepancy** goes further. It gives the mismatch parameters of its own and builds a posterior for the discrepancy function itself (recipes 8 and 36).\n", + "\n", + "In this notebook we'll only do the first. We'll also let the size of the discrepancy **grow with $x$**. That's genuine prior knowledge in this problem: the data look like a straight line at small $x$ and stop looking like one further out, so we trust our model more on the left than on the right.\n", + "\n", + "Recipes: 2, 7, 10, 16, 17, 18, 33, 40 (see [the recipes](/recipes.md))" ] }, { "cell_type": "code", "execution_count": 1, - "id": "c01", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:07:51.145746Z", - "iopub.status.busy": "2026-08-11T03:07:51.145608Z", - "iopub.status.idle": "2026-08-11T03:07:53.817459Z", - "shell.execute_reply": "2026-08-11T03:07:53.816779Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Using database version X4-2024-12-31 located in: /home/kyle/db/exfor/unpack_exfor-2024/X4-2024-12-31\n" - ] - } - ], + "id": "506a99dd", + "metadata": {}, + "outputs": [], "source": [ + "import logging\n", + "\n", + "import blackjax\n", "import corner\n", + "import emcee\n", + "import jax.numpy as jnp\n", + "import jitr\n", + "import matplotlib.pyplot as plt\n", "import numpy as np\n", - "from matplotlib import pyplot as plt\n", + "import plotstyle\n", + "import pocomc\n", + "import tinygp\n", + "from budget import budget # sampler budgets, cut in CI's quick run\n", + "from jitr.optical_potentials.potential_forms import (\n", + " thomas_safe,\n", + " woods_saxon_prime_safe,\n", + " woods_saxon_safe,\n", + ")\n", "from scipy import stats\n", - "from sklearn.gaussian_process.kernels import ConstantKernel, Matern, WhiteKernel\n", "\n", - "import rxmc\n", + "import rxmc as rx\n", + "from rxmc import terms as T\n", + "from rxmc import transforms as tf\n", "\n", - "rng = np.random.default_rng(7)" + "plotstyle.use()\n", + "logging.getLogger(\"emcee\").setLevel(logging.ERROR) # fit() reports tau itself" ] }, { "cell_type": "markdown", - "id": "c02", + "id": "c44ee40c", "metadata": {}, "source": [ - "## A linear model and a non-linear truth\n", + "## A line, and a truth that leaves it\n", "\n", - "The model is a straight line $y_m(x; m, b) = m x + b$. We give it the usual\n", - "`.y(x, *params)` helper so the same model can be evaluated on a raw grid for\n", - "plotting." + "We'll make synthetic data from a truth that is a straight line plus a small quadratic departure, $0.03\\,x^2$. At the left edge of the data that departure is 0.001, far below the measurement noise of 0.02, so we couldn't see it even if we tried. By $x = 5$ it has grown to 0.75, thirty-seven times the size of an error bar. A straight-line model is therefore an excellent description at small $x$ and a hopeless one at large $x$, which is exactly the situation a growing discrepancy amplitude is meant to describe." ] }, { "cell_type": "code", "execution_count": 2, - "id": "c03", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:07:53.819066Z", - "iopub.status.busy": "2026-08-11T03:07:53.818832Z", - "iopub.status.idle": "2026-08-11T03:07:53.822492Z", - "shell.execute_reply": "2026-08-11T03:07:53.821615Z" - } - }, + "id": "b77965a8", + "metadata": {}, "outputs": [], "source": [ - "class LinearModel(rxmc.physical_model.PhysicalModel):\n", - " def __init__(self):\n", - " super().__init__(\n", - " [rxmc.params.Parameter(\"m\", float), rxmc.params.Parameter(\"b\", float)]\n", - " )\n", - "\n", - " def evaluate(self, observation, m, b):\n", - " return self.y(observation.x, m, b)\n", + "M_TRUE, B_TRUE = 0.8, 1.0\n", "\n", - " def y(self, x, m, b):\n", - " return m * x + b\n", "\n", - "\n", - "model = LinearModel()" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "c04", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:07:53.823735Z", - "iopub.status.busy": "2026-08-11T03:07:53.823595Z", - "iopub.status.idle": "2026-08-11T03:07:54.037874Z", - "shell.execute_reply": "2026-08-11T03:07:54.037056Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAHFCAYAAAAOmtghAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlcelbwAAAAlwSFlzAAAPYQAAD2EBqD+naQAATOpJREFUeJzt3Xd0VNXaBvDnzEwy6YNAQkISiKEE6YiRLlWEoFQhCKgICChcEEQEvUhRAQuaq6KCV7yAcEGJCIpXpAoCUqX3kpDegElPppzvD74cGdImycycKc9vrayV2TnlzVDyZO999hZEURRBRERE5CQUchdAREREZEkMN0RERORUGG6IiIjIqTDcEBERkVNhuCEiIiKnwnBDREREToXhhoiIiJwKww0RERE5FYYbojJ88sknUKlUSEtLk7sUE7///js6duwIPz8/qFQqXLp0Se6SXE5ISAgmTZpUaRuZz8fHB6+++qrcZZATYbghKoPRaITBYEB1FvCePn06atWqZfGacnJyMHToULRs2RJJSUkoLCxERESExe9DFdPr9TAYDJW2OZK6detiypQpst3D0d8/sj8quQsgcjYGgwF6vd7i1z1z5gxu3bqFESNGwNfX1+LXp+pLSkqCIAhyl1FttggXDDBkSww3RA4iIyMDAODl5SVzJXQ/pVIpdwlEdA8OS5HL27x5M9q1awcfHx+0atUKmzdvLvO4jz76CCqVCiqVCm5ubqhTpw769OmDXbt2SccMGjQIn3/+OfLy8qRjVSoVkpKSzL5GWXr06IGhQ4dKn6tUKvTu3RsAMGnSJAQGBkKr1WLcuHEICAhA27ZtAdz9bXnp0qVo0aIFvL29ERQUhOeeew7x8fEm1y+Z87B//3506NABfn5+6NSpE06ePAng7lyfTp06wdfXF61atcLu3bvNem8feeQR6fv18PBAw4YNMWHCBLPmMpXUdPToUXTt2hU+Pj5o2rQpvvnmm1LHVvX7NOeaVVHWnJuq3uvbb79Fp06d4OfnhwceeABRUVE4ceKEyTHmvp8l9z5w4IB07/fff7/UPbVaLVQqFbRaLVauXCldu+TvVkXXysrKgkqlwkcffVTquo888ggGDBhg9j1KWPrPhVyYSOTCNm3aJAqCIE6dOlW8efOmeO3aNfHZZ58VhwwZIgIQU1JSpGONRqOo0+lEnU4nFhUViVevXhUnT54sqtVq8fTp06IoiqLBYBBffvll0dvbWzpWp9NV6Rpl0ev1YmxsrAhA3Lt3r6jT6US9Xi+KoiiOHz9erFOnjjhixAhxy5YtYnp6uvjVV1+JoiiKI0eOFD09PcVVq1aJmZmZ4pEjR8Q2bdqI9erVExMTE6Xrq9VqccCAAWJ0dLR4+fJlMSkpSYyKihIDAwPFgwcPikOHDhUvXrwoJicni0899ZTo5+cn3rlzp9L3V6/XS99vdna2uG/fPrF169Zix44dpfrLo1arxaeeekocPny4eO7cOTEtLU2cNm2aCED8888/TY6tyvdp7jXLU69ePXH8+PGVtlXlXq+//rro7u4uLlu2TExMTBTj4+PFiRMnil5eXuLJkyer/H6q1WoxKipKHDhwoHj27Fnx2rVr4pYtW8r8fnQ6najRaMSJEydK1zbnWhkZGSIA8YMPPih1zTZt2ohPPPFEle5R0z8Xonsx3JBLCw8PFyMjI03a9Hq9GB4eXirclCc4OFicMWOG9HrKlCmit7d3leq4/xpl2bx5swhA3L9/v0n7+PHjRQDi2rVrTdoPHTokAhDfeecdk/Zr166JKpVKfOmll6Q2tVot+vv7i3l5eVLbuXPnRABiWFiYmJOTI7VfvHhRBCCuXLmySt9jiT179ogAxOPHj1d4nFqtFuvWrWty76KiIrF27driuHHjqv19mnPNilQl3Jhzr3PnzomCIIjz5s0zOd9gMIitWrUSn3rqqQrrKev9VKvVoq+vr6jVas36njQajThp0qQyv1betaoSbsy5R03/XIjuxWEpcllxcXG4fv06Bg8ebNKuVCoxcODAUsfn5eVh3rx5aNmyJXx8fODm5iYNOV29etWse1riGuUZNGiQyeudO3cCAIYNG2bSHh4ejvbt20tfL9GjRw+T+TwRERFQKBTSkF2Jpk2bQqVS4dq1a5XWdPbsWURHRyMkJAQeHh5QqVTo06cPAJj1/fbs2dPk3u7u7oiIiMD169er/X2ac81hw4aZDCt27dq10lqrW/9PP/0EURQxYsQIk3MVCgV69eqFPXv2SG1VeT979eoFPz+/atV9P0teqzzmvFdE5mK4IZeVmZkJAKhXr16prwUGBpZqGzVqFJYvX45Fixbh+vXryMvLkx7HLi4uNuuelrhGWfz8/Eo9QZWVlQUACAoKKnV8YGCgNEG5xP3HKZVKeHp6lmoXBAHe3t7QarUV1pSYmIguXbogKysLW7ZsQUZGBgoLC3Hw4EEAMOv7Lat2Pz8/3LlzR3pd0++zrGsaDAaTj+o+/WbOvVJTUwHcnafi4eEBtVoNd3d3uLu749NPP0Vubi6Ki4ur/H4GBwdXq+ayVPVaYjWWUDDnvSIyF5+WIpdVu3ZtAEB6enqpr90/QfPWrVvYunUrFixYIE3sBe7+J56QkICwsLBK72eJa5THzc2tVFvJ95eWlgaNRmPytbS0NNSpU8ekrbxHmctrr+wH2ObNm5GdnY0VK1agUaNGUntCQkKF51X13pb6Pu+95g8//ACj0VjpOZUx514l9Z0/fx4NGjQo83iVSlXl97OsvxPVVda1/Pz8IAgCcnNzS30tOTm5zLBSker+PSMqC3tuyGWFh4ejYcOG+Pnnn03ajUYjtm3bVuY5np6eJq9jY2ORn59v0ubt7V1hr4Q517CEnj17AgC2bNli0n7z5k0cP34cvXr1svg971XyQ+n+73ft2rUWvY81vk+FQmEyLGXNR71LniravHmzyT3v/QCs+35W9ne2LO7u7ggODsbZs2dN2o8cOSL1itb0HkTVxXBDLu3dd9/FwYMHMWfOHGRkZCAlJQWTJ09G06ZNTY6rXbs2OnXqhM8//xx//fUXCgoKsG3bNnzyySdo1qyZybEtWrSATqfDjh07SvUwmHsNS+jatSsGDRqEt99+G9999x3y8vJw9uxZDB8+HL6+vnjzzTctfs979e3bF+7u7pg9ezaysrKQnp6ON998EwqFZf/bkfv7rKl27dphxowZ+Oc//4mPP/4YycnJKC4uxqVLlxATE4Pp06cDsO772aJFCxw+fLjUEF5lJkyYgK1bt2Lz5s0oKCjAoUOH8N5775X597m69yCqDoYbcmmjR4/Gt99+ix9//BFBQUHo2rUrHnvssTLX4Ni4cSPatm2LHj16ICAgACtXrsT69euhVqtNjhs1ahSeffZZDB8+vNQ6N+Zew1K+++47vPLKK3j99dfh5+eHrl27IjQ0FH/++ScaNmxolXuWaNasGTZt2oTTp08jKCgI7dq1g1qtxoIFCyx+Lzm/T0v46KOP8O9//xubNm1C48aN4efnh8GDByMpKQmzZs0CYN3388MPP4S3tzeCg4PLXYOmLHPmzMH48ePxwgsvoHbt2nj33Xfx6aeflvn3ubr3IKoOQeSAJlEpoijCYDBIQwIVMRgMEAShzN+gjUYjjEZjpdep6BqV1WQ0GiGKYo2GTsq7f1XbzaXX66FUKiucy1LePWry/VrimmVdw9y2mtZfnvvfz5r8+ZRskVBSX3WuVdk55t7DGu8VuQaGGyIiInIqHJYiIiIip8JwQ0RERE6F4YaIiIicCsMNERERORWGGyIiInIqLrf9gtFoRHJyMnx9fau9pDoRERHZliiKyMnJQf369StdmsDlwk1ycjJCQ0PlLoOIiIiqISEhASEhIRUe43LhpmTn5ISEBPj5+clcDREREZkjOzsboaGh0s/xirhcuCkZivLz82O4ISIicjDmTCnhhGIiIiJyKgw3RERE5FQYboiIiMipuNycG3MZDAbodDq5y3BYbm5u3MmXiIhkwXBzH1EUkZqaijt37shdisOrVasWAgMDuZ4QERHZFMPNfUqCTUBAALy8vPiDuRpEUUR+fj7S09MBAEFBQTJXREREroTh5h4Gg0EKNnXq1JG7HIfm6ekJAEhPT0dAQACHqIiIyGY4ofgeJXNsvLy8ZK7EOZS8j5y7REREtsRwUwYORVkG30ciIpIDww2Zpbi4GBcvXoTBYJC7FCIiogox3DgBnU6HixcvWmz4p6zrXb58GQ899BAyMjIscg8iIiJrYbhxAvHx8XjooYeQlJRkl9cjIiKyJYYbB2c0GnH9+nUAwLVr13Dx4kUkJiaaDCMVFhbi2rVryM3NRX5+Pi5evGhyDYPBgIsXL6K4uLjc691/z8TERE4UJiIiu8Rw4+Dy8vLw0ksvAQAmTpyIwYMHY+HChdIw0ptvvomgoCD0798fhw8fxpEjR/DQQw9Br9dL18jIyMBDDz2Ey5cvl3u9Ep988gnq1auHDh06oFatWlizZo1tv2EiIqJKcJ0bM+Xl5QGAycJ+xcXF0Ol0UKlUUKvVpY719PSEQnE3P+p0OhQXF0OpVMLDw6PCY6vC19cX27dvR5MmTbBr1y6EhYUBAM6ePQsAOHr0KG7evAlfX18AwN69e2t0vdOnTyMuLg7e3t747LPP8PLLL2PIkCHS9YmIyDryi/Vo/tZ2AMD5RU/Ay50/wsvDnhsz+fj4wMfHB5mZmVLbBx98AB8fH0ydOtXk2ICAAPj4+ODmzZtS2/Lly+Hj44Px48ebHBsWFgYfHx9cuHDBKnUvWLDAosFj4cKF8Pb2BgCMGTMGeXl5uHz5ssWuT0REVFMMN04uPDzcotcLDg6WPvfx8QEA5OTkWPQeRERENcE+LTPl5uYCMF29+LXXXsMrr7wClcr0bSzZU6lkCwIAmDJlCl588cVS2xDExcWVOtaS7r9fWQvr3Tv/hoiIyNEx3JipZCjmXu7u7nB3dzfrWDc3N7i5uZl1bFWVzOEx5+klf39/AEBKSgpCQ0MBACdPnqz29YiIiOwNh6WcQGBgIDQaDf773//i/PnzpR7dvlfTpk3RuHFjzJgxA8eOHUNsbCxeeeWVal+PiIjI3jDcOAGVSoX169dj3759GD58OBYuXAi1Wo2IiIhSQ2YqlQo///wzBEHApEmTEBsbi1WrViEiIkJ64svc6wmCgIiICG40SkRUBfnFeoTN2YawOduQX8xpAdbAYSknERUVhaioKJO2+xfrKxEREYHvv/++wmPNuZ5SqSz3HkRE5Bpyc3Nx8uRJhIeHo379+nKXA4A9N0RERGSm7OxsHD9+3KQtOjoa3bp1w+bNm2WqqjSGGyIiIiolJyfHZLPk+Ph4aDQadOnSxeSBk4cffhj169eHwWCQo8wyMdwQERG5uIKCAoiiKL1+++23odFosGTJEqmtQYMG0Gg0qFevnsnGyvPnz0dSUhKmTZtm05orwnBDRETkooxGIx599FH4+voiPj5eam/QoAFEUTRpEwQBN2/eRHx8vLQ1D4BSD67YA4YbIiIiB5OqLazyOfv27UPXrl3xzDPPSG0KhQIGgwEGgwF//fWX1D5kyBCkpqYiNjbW5Bp+fn7VL9qGGG6IiIgcQOzxv9cc6/PR79h49Ga5x37++ed48sknceDAAalNpVLhwIED2LNnj8kQ1Ndff42bN29i8ODBUpufnx/q1atn2W/AhhhuiIiI7FyKtgDzt56TXhtF4I0fzuLSzTR8+eWXePPNN02O//3337Ft2zbs27dPamvXrh1Wr16NvXv3mhzbtm1bhIaGlrk9j6Oyv4EyIiIiMnEjMw9G0bTNIIq4mqbFSy+9BEEQMGfOHPj6+gIAxo4diy5duqBv377S8Z6ennjuuedsWbZsGG6sJL9Yj+ZvbQcAnF/0BLzc+VYTETkTa/4/bzAYcO7cObRo0QJKpRIP1vUGRBG4p3dFKQh4uGkoRo0ahUaNGqG4uFj6Wv/+/dG/f3+L1eNoOCzlpG7fvo2wsDBcvnxZ7lKIiKrFlbYpMBqN0ueiKKJBgwZo06YNLly4AAAI0nhiRLgRovHuWjIKAVg8tCWCNJ5Yt24dFi1ahDp16shSuz1iuHFSBoMB8fHxJkm+MiWP93GjTCJyVI4WiLbt3o+HH37YpJdFEAQ89NBD8PHxwY0bN6T2BS9EQVAoAQA7Z3ZHdGQDm9frKDhWQhKdTof4+Hjo9fb/HwIROQ4O09+1adMm/Pjjj2jYe4zUNntvPjINdXH5wAHo9XppzZj169ejTp06UCqVZV4rUONhk5odFXtubKA66xFU1ZUrVzB48GA0b94cgwYNwpEjR0y+XlRUhLCwMISFhaFx48bo06cP1q1bJ309OzsbPXr0AAB07doVYWFheP755ys9j4iITBkMBhw9ehQrVqwwaf/111+xYeuvWHfx718gRQB1+0/D/uNnTBbDCwgIKDfYUOVcMz7bwP3rESwZ2spqXYgFBQXo3bs3OnXqhLVr1yI+Ph7jxo0zOcbd3V16/E+n0+HYsWOYOnUqVCoVoqOj4ePjg3Xr1qFHjx7YsGEDQkJC4OnpWel5RESuTtQXIzU1FeENQgDc3SW7Q4cOEEURTz31lLRT9ogRI6AIaobfdKaPXIsQUKhyjMXxHAXDjRWUtx7BY039EaTxtPj91qxZg8LCQqxevRoeHh5o3749srKyMHHiROkYQRBMlstu0qQJrl+/jlWrViE6OhoKhQLBwcEAgJCQEJNjKzqPiMiV5Z7ZiaztyzE7fjA2ff8dAECj0aBXr17w8vJCTk6OdGzfvn3RqkM37Fy62+SxbqUgIKyul61Ld2oMN1ZQ3noEcZn5Vgk3J0+eRGRkJDw8/h6Dfeyxx0od99NPP+HLL79EXFwc8vLykJuba9bs+uqeR0TkTD788ENs3boVy5YtQ2RkJABAVSsQMOhw+fIlk2N37txZ5jWCNJ5YOLAF5m25+wvwvU89keVwzo0VPFjXG4r7Fnq0ZjIvKiqCu7u7Sdu9QQcAdu3ahejoaERFRWH9+vXYs2cPpk+fjqKiogqvXd3ziIgcVXFxMX7//Xd89dVXJu0HDhzA/v37sXv3bqlNXT8C9Sd8iUNHjpl9/WHtQ6TP+dSTdbDnxgpsncybNGmCb775xqTt9OnTJq+3b9+Onj17YsqUKVJbcnKyyTElk9fu3XPEnPOIiByZXq9Hbm4uatWqBeDu/3E9evSASqXCM888Ax8fHwDA5MmTMWDAAJNVfwWlG9zqhFR76wI+9WQd7LmxElsm8+effx4JCQmIiYmBKIrIyMjAW2+9ZXJMcHAwTp8+jbS0NADAjh078J///MfkmMDAQCgUCly5cqVK5xEROaoVK1agdu3aJnszhYWFoVOnTnj66aeh1Wql9ieeeAITJkxAgwbsabF3DDc2YO1kXr9+faxduxbvvPMOatWqhWbNmuHJJ580OWbixIlo3bo1GjRogDp16mDy5MkYPny4yTGenp54/fXXMXDgQDRo0ADPP/+8WecRETmCdevWYfTo0SYL49WrVw85OTk4fvy4ybEHDx7Ef//7X+lBC3IsHJZyEk8//TQGDx6MrKws1KtXD0ajEePHj5f+YXp6emLbtm3IyclBQUEBAgICkJubizt37phcZ/HixZg/fz7S09Ph7u5u9nlERPbEWJSPY0eP4LEunaW2FStWYP/+/ejevbv0NGmfPn1w7NgxtG3btkb3S9UWItzfp0bXIMthuHEiKpUK9erVAwAoFAqTR7hL+Pr6SrvG+vj4SGPJ91Kr1QgNDa3yeURE1lKV8FCceRMpq6biqVU+yMrKkhbHGzduHLp3747Onf8OPD4+Pmjfvn21arLlemZUNQw3VuLlrkLc0gFyl0FE5LDMCQ+7d+/GF198gY4dO+LVV18FALjVDoZno0dQ18OAxMRE6Re9sWPHWqw2W69nBvDnSlVwzg0REdmMudvRlBUe5v5wBht/+g3Z2dlS+40bN7Bp0yZs2rQJwN1AJCiUCBj2FsQnF+JwhnV+zFW0nhnJj+GGiIis6v4emI1Hb1Z6TlnhwSgCz0+ZhR07dkht/fv3x4IFCxATE1Nub0qKtqDm38R9bL2eGVWNrOHGYDDgxx9/xDPPPINZs2ZV6Vyj0YiXXnpJmkRLRET2pzqBIyMjA2s++xAQjSbtgiiijtpgsqVB/fr1MX/+fHTo0MGmvSkl65mV4ErD9kW2cKPT6dCoUSOsWrUK6enp0uaM5nr77bexfft2bNmyBQUFlk3l9y5iR9XH95GIzAkcSUlJuHDhgvTay8sL33z+MbJ+/VT6f0QhAIsGNkPi5bPlzp2xdW8KVxq2X7KFG6VSiT/++ANbt25Fq1atqnTu/v37sXr1arz//vsWrcnNzQ0AkJ/PMVNLKHkfS95XIrIf+cV6hM3ZhrA525BfrLfafSoLHCtXrkRISAhmz54tfd3b2xuLFy/GyjdfhKi7u9XLzpnd8WyXxhWuBCxnb0pV1jMrmRgct3QAvNz5XI81yPauKhQKhISEVH7gfW7duoUxY8Zg9erV0Ost+w9SqVSiVq1aSE9PB3D3t4fqLqntykRRRH5+PtLT01GrVi1pWwcicj33b0cD0YgXH/aTAkfHjh0hCAIKCgogiqL0f+6rr76K/GI95p7YDsD88DCsfYh0r50zu3PtGRflcJHxhRdewDPPPIMePXqUu+vqvYqKikw2ebx3ln1ZAgMDAUAKOFR9tWrVkt5PInI9WVlZqFOnjhQ47hzcgNyT/8OdlycAI7oDAFq1aoW0tDT4+/tb/P7ct8l1OVS4+eSTT5CYmCg98meOJUuWYOHChWYfLwgCgoKCEBAQAJ1OV50yCXeHothjQ+Sa8vPz0aNHD5w4cQIpKSnw1jwAAFDXa4zRz4/C4MGDpWMFQbBKsCHX5lDhJiYmBrVr15b2NsrIyAAATJgwAcOHD8f48eNLnTN37lzMnDlTep2dnV1q9d2yKJVK/nAmIqqEwWDAwYMHkZaWhqeffhrA3SF9nU4Ho9GIQ4cOoU+/KACAZ6NH8MGiJzjPhKzOof6GffnllyaTfU+fPo2DBw9i+PDhePTRR8s8R61WQ61W26pEIiKXsnPnTvTr1w+BgYEYOnQoFIq7z6l8/fXXCA4ORr169aw6YZmoLHYdbvLy8jB69GhMmzYNvXr1Qt++fU2+XrK/0RNPPFGtyclERGS+vXv3YuXKlejVqxcmTJgAAOjZsyfCwsLQrVs3ZGdno1atWgCAhx9+WMZKydXJGm6mT5+O+Ph4nDlzBrdu3ZLGYTds2AAPDw/odDps2bLFZHyWiIhsQ6vVwtvbW9p48q+//sJ///tfJCcnS+HG3d0d169f55OlZFdkDTeDBg0q8+mlknVRvL29sXnz5nJ/A2jTpg02b96MunXrWrVOIiJXM27cOKxbtw4//fST1Gs+bNgwJCcnS3NrSjDYkL2RNdz06tWrwq+7ublV2Gvj7+/PXh0iohq6c+cOdv55EAMHDpTa3N3dUVxcjH379knhpkGDBvjggw/kKpPIbHY954aIiKzLWJSHRg1DUVhYiLi4ODRs2BAAMGvWLEybNg3NmzeXuUKiqmO4ISJyEfn5+fj555+Rnp6OcRMnAwAUam882qEDsjIzkZycLIWbxo0bl32NYj2av3V31eDzVn6su2SbAntl7/W5MoYbIiIXcfz4cURHR8PPzw+jnhsrtX+2eiNaNawnX2FEFibbxplERGQ9J06cwMSJE7F8+XKprUuXLujWrRumTp2K74/elNoHfXkMG+957ci4KSUB7LkhInIKoihCFEVpEb0TJ07gq6++QuvWrTFlyhQAdzcs3rdvH1K0BeiydLd0rlEE3vjhLB5r6m+VHbQdYfjGlsNtZH3suSEicnArV65Ey5YtsWXLFqlt2LBhmDBhAmJiYiCKosnxNzLzYDRtgkEUEZeZDyJnwHBDRORgcnNzTV5fuXIF58+fx4YNG6S2Bx54AF999RV69uxZah2aB+t6Q3Hf0jRKQUBYXS+r1UxkSww3REQOQhRFjB07FgEBATh37pzUPmHCBPz73//GihUrzLpOkMYTCwe2kF4rBGDx0JZWGZIikgPDDRGRHUtNTZU+FwQBt2/fRkFBAX7++WepPSIiAuPHj5f2dTLHsPZ/78e3c2Z3REc2sEi9RPaA4YaIyA5lZWWhQ4cOCA8Ph1arldoXLFiAI0eOYPbs2Ra7V6DGw2LXIrIHDDdE5HDyi/UIm7MNYXO2Ib9YL3c5FmE0GhEfHy+9rl27NnJycqDT6fDnn39K7e3atUNkZCT3cyKqAJ91IyKS2ZkzZ/DUU09BoVDg6tWrUCgUEAQBa9asQYMGDRAQECB3iUQOhT03REQ2ptPpkJycLL1u1KgRbt++jVu3buHatWtS+yOPPMJgQ1QNDDdERDa0fft2hISE4IUXXpDavLy8sGPHDqSkpKBJkyYyVlc1qdpCuUsgKhPDDRFRBWo6v6e4uBi3b9+WXjdu3Bjp6ek4e/asyXo1jz76KDw97f9R7NjjidLnfT763Wm2bSDnwnBDRGQl69evR0hICN566y2prVGjRti3bx/i4uLg4+MjY3VVl6ItwPytf6+vU7JtQ4q2QMaqiEpjuCEishCDwYCioiLptb+/PzIyMrBr1y6TLRC6desGNze3Uufb+1NgrrJtA4fbHB/DDRGRBXzzzTcIDw/HypUrpbbevXvjp59+wqlTp5zi0W1n3raBw23OheGGiKgaSnbhLpGfn4+bN2/iu+++k9oUCgWefPLJMntpHJGzbtvA4Tbnw3BDRFRFGzduRGRkJHbs2CG1Pfvss/jPf/5j0mYrthzOcsZtG1xluM2VcBE/IqIqOnjwII4fP44vvvgCffv2BQD4+fnh+eefl7ky83m5qxC3dECNruEs2zaUDLfdG3CcZbjNVbHnhoioAof/PISMLe9Bd+fvDSynTp2KJUuW4KuvvpKxMrIUZx1uc2UMN0Tk0Kz9ZMu7b7+N/Iv7kXPi7124mzRpgjlz5qBu3bpWvTfZjjMOt7kyhhsicjjWerLl9u3bWLZsGfLz/55rMe2VGfBu1Qc+LXtZ5B5k/5xluM2Vcc4NETmU8p5seaypf42GEURRRPfu3XHmzBn4+Phg0qRJAIA+jz+OuvuNNa6biGyHPTdE5FAs+WTLqVOnpMe5BUHA+PHj0apVKwQGBlqiVCKSCcMNETkUSywkJ4oi+vXrh7Zt2+L333+X2l9++WWcOnUKgwYNKvM8rlxL5BgYbohINtVZn6W6T7YYjX8PLQmCgPDwcLi5ueHUqVNSu5ubW6mVhLlyLZHjYbghIodTlSdbjEYjPv74YzRp0gQJCQlS+7x583Djxg1Mnz693HPlXLmWvURE1cdwQ0QOrbInWxQKBbZu3Yrr16/jyy+/lNqDgoIQHBxc4bm2XrmWvURElsFwQ0ROJTU1FfPnz0dh4d89H2+//TZWrFiBefPmVela1Z3fU53hNu5vRGQ5fBSciJyGKIro1q0brl69ivr160uPc3ft2hVdu3at8vVK5vfM23I3dFhz5dqKeomqcr9UbSHC/X0sXN3fLLFtA5G1seeGiBxaSnKy9LkgCPjHP/6BTp06oWnTpha5vq1Wrq3JU2AcziIyxXBDRA5JFEVkbf8MEY3DsX//fql9ypQpOHDgAHr27Gnxe1pz5drqPgXG4Syi0hhuiMghCYIAiIDBYMD27duldqVSWepxbqB682BsrTq9RLae9OysSobb4pYOgJc7Z2w4OoYbInII165dw4QJE5CSkiK1aTpHY+/+P/DOO+/IWJl1mNtLZIlFDYmcDcMNETmEF154AV9//TXee+89qU3l54/IRzvIWJX8qjucReTMGG6IyC4lJydDp9NJr+fPn49+/fph1KhRMlZln2w16ZnIUTDcEJHdeffdd9GoUSOsWbNGauvduzf+97//4dFHH5WxMvtnzUnPRI6C4YaI7MK92w14eXmhsLAQu3btkrEiInJUnBJORLKJPZ4IURQhCAJ6L/sdS4e1QnRkA7z00kto0aIFHn/88TLP40JyRFQR9twQkQlbPTJdsj5LyWPbIv5en8XDwwN9+/Yt85FuIqLKMNwQkU2JogidTucy67Nwd28i22O4ISKbOXnyJHr16oV58+Y59fos3A6BSF4MN0RkM0lJSdi7dy9WrFgBX6XBIdZnqerKtdwOgUh+DDdEZDVarRanTp2SXkdFRWHx4sU4deoUfHx8ZFufxZpDRTUZbuMWAESWwXBD5KTk3kvp8OHDaNy4MYYNG4bi4mIAd/eDmjt3Lho0KB1irL0+i62Gipx5uI3IUTDcEJFVtGjRAiqVCm5ubkhISJC1FlsOFXE7BCL5MdwQkUWcOnseD/R8Qeop8vHxwe7du3HmzBk0atRI1tps/WQWt0MgkhcHdYmoxtLT09Exsj0KCwuhrt8MwBMAgIceekjewv5fyVDRvQHHVkNFttgOgYsaEplizw0R1VhAQADGPPscPBtFQulTW+5ySuFQEZFrYbghoio7evQo+vXrh4yMDKntw49jEPD0fLg9UF/GysrHoSIi18FwQ0RVIooiXnrpJWzfvh3z58+X2t3c3GSsqmq4czaRc2O4IaJylawHYzQaIYp3J6wIgoBPPvkEY8aMwbx58+Qsj4ioTAw3RA7AlmvW3L8ezPub/kCnTp2wZs0aqb1z585Yu3YtgoKCrFoLEVF1MNwQkaSs9WC+OHYHxy9cwzvvvAODwSBjdURE5mG4ISJJWevBiBAwetIM7Nu3D0qlUp7CiIiqgOvcEJHEvUgLiEZA+Pv3HqUgYOk/Z1rlsWmuz0JE1sCeGyIXYO5GkbXcRWh3fQnReHf4ievBEJEjYrghclLmbhSZlZUlfd64cWPEvDIKem06AK4HQ0SOieGGyAmZs1GkTqfD66+/jrCwMFy7dk1qHz4iGm4P3H0KqrrrwZjbU+SsSobb4pYOgJc7R/+JbI3hhsgJmbNRpEqlwtGjR5Gbm4tNmzbV+J7m9hQREVmbXfxKER8fDwBo2LChWceLooikpCTUqlULPj4+1iyNyCGVt1FkXQ8RBoMBSqUSgiDgq6++wrlz5zBw4MAa3a+8nqLHmvpzvg4R2ZxsPTeiKGL16tXo2LEjIiIiMGzYsErPKSgowPz58xEQEIAuXbrA398f3bt3x5UrV2xQMZHjKGujyGcfUqFP5/b4+OOPpfZGjRrVONgA5vUUyY1DRUSuQ7Zwo9PpsHv3bnz00UeYPHmyWeckJiZCo9Hg2rVriI+PR3p6Otzd3TFmzBgrV0vkeO7fKLKBPhE3b97EqlWroNPpLHqvkp6ieykFAWF1vSx6HyIic8gWbtzd3bF69Wp07tzZ7HOaNGmCmTNnws/PDwDg6+uL/v374+rVq9Yqk8ihifpiAHcnBr/wwgv47LPPcOTIEYtvcllWTxEfISciuTjkhOKEhAScP38eP/74Iz799FPMmjVL7pKIbMacJ5Hy8vIwc/o0pK57HaLh7l5UgiBgypQpVpundn9PER8hJyK5OGS4mT9/Pp566ilER0cjIiIC48aNK/fYoqIiZGdnm3wQOZqqPomUnZ2N7zZuQHHqFRTcOGHt8kqp7iPkRESW4JDhZtWqVbh27RrS0tLg5uaG3r17l7uh35IlS6DRaKSP0NBQG1dLVDPmrFkD3J2kXyIoKAhfrvw3AkYsglfjR21WKxGRPXDIcFOiVq1aeOONN3Du3DlcvHixzGPmzp0LrVYrfSQkJNi4SqKaMedJpAsXLqBTp044fvy41PbkwIHwfPBhW5VJRGQ37DrcGI1GXLx4EVqtFgDKfMIjOTkZAKRJxvdTq9Xw8/Mz+SByJOY8ifTOO+/g8OHDeOWVV2xbHBGRHZJ1sYcbN26gqKgIt2/fRmFhodT7EhERAUEQkJ2djYceegjffPMNxo4di5iYGCQmJmLAgAGoW7cuTp48iX/+85+Ijo7mcBM5rZInkeZtuTs0VdaTSJ988glUKhWWLFlS4/txp24icnSyhpvp06fj8uXL0uvBgwcDAE6cOAEvLy8olUpERERAo9EAAGbOnInVq1fjX//6F1JTUxESEoIlS5Zg9OjRcpRPZDPD2odI4WbnzO64eHQf3nvvv3j99dcBAHXq1MHq1avlLJGIyG7IGm62bt1a4dd9fX1N5tIolUqMGzeuwqejiJxdevwlDBgwAIIgoGvXrujSpYvcJRER2RWuQU7kYFq3boOJEyfCw8MD7du3l7scIiK7w3BDLi+/WI/mb20HAJxf9ITd7TskiiJiN30PY7E7FO5314/54osvoFDY9fMARESysa//xYmolNdeew3Lli2DT+u+qNN/GgCYFWw4MZiIXBV/9SOyc1FRUXBzc4NKU89koT4iIiobe26I7IwoisjIyEBAQAAAoFevXjh74RL6fnVe5soqxp4iIrIX7LkhsiP5+fl44YUX0L59e2RmZkrtIVzHiYjIbAw3RHZEr9fj4MGDSE5Oxp49e+Quh4jIIXFYisiGKnsyy8/PD7GxscjKykKPHj1kqJCIyPGx54ZIRnq9HrNnzzZZ0LJVq1YMNkRENcBwQySjL774Ah988AGee+453Lp1S+5yiIicAoeliGQ0adIk/PLLLxg/fjxq165d7nF8EomIyHwMN0Q2Vph4Durg5gAAd3d3/PLLLxAEQeaqiIicB4eliGzo9ddmIW3d68j9a5vUxmBDRGRZDDdE90jVFlr1+kFB9QEAhsJcq96HiMiVMdyQy4s9nih93uej37Hx6E2r3Wv6jBkIfHYZanUeabV7EBG5OoYbcmkp2gLM33pOem0UgTd+OIsUbYFFrr9lyxYMHToUer0ewN0hKHX9CItcm4iIysZwQy7tRmYejPftRWkQRcRl5ld6bn6xHmFztiFszjbkF+tLfT0zMxNjxozB5s2bsWLFCkuVTEREleDTUuTSHqzrDYUAk4CjFASE1fWq8bXr1q2L1atXY/fu3Zg4cWKNr0dEROZhzw25tCCNJxYObCG9VgjA4qEtEaTxrNb1MjMzER8fL70eOnQoPvvsM7i5udW4ViIiMg/DDbm8Ye1DpM93zuyO6MgG1brO5cuX0aFDB0RFRUGr1VZ6vLWfzCIiclUMN0T3CNR4VPtcLy8vFBYWoqCgABkZGWUeY8sns4iIXBXn3BBZSEhICH777TcEBATA39+/1NfLezLrsab+1R4GIyKi0thzQ1RNoihCe+g7FCVdkNpatGhRZrABavZkFhERmY/hhqiaVn75Be7sW4P02LfN2tG75Mmse1nqySwiIvobww1RNY1+9jm4B0WgVrcxFe7oXcLST2YREVHZGG6IqqCoqEj63MfHB4Fj3odvuyizz7fUk1lERFQ+hhsiM12/fh2tWrXC+vXrpTZBoaz29WryZBYREZWP4YbITN988w2uXLmChQsXori4WO5yiIioHHwUnMhMCxcuhCiKmDJlCtzd3aG/Zz+pVG0hwv19ZKyOiIhKsOeGqAJ//fUXRPHu89sKhQLvvPMOgoKCAHBBPiIie8VwQ1SOtWvXIjIyEv/85z9Lfa28BflStAW2LJGIiMrAYSlyeV7uKsQtHVCqPT8/HwaDAUlJSTAajVAo/v5doKIF+fhoNxGRvBhuiMoxadIkNG7cGD179jQJNsDfC/LdG3C4IB8RkX3gsBTR/xNFEV9//TUKC//erbt3796lgg3ABfmIiOwZww05lfxiPcLmbEPYnG3Iv+dpJnPMmTMHEyZMQHR0tDSJuCJckI+IyD4x3BD9v379+sHLywtRUVEQBKHyE+7BBfmIiOwH59wQ/b+ePXvi2rVrCAwMlLsUIiKqAfbckMvS6/V4/fXXkZqaKrVZO9iUPJkVt3QAvNz5uwURkTUw3JDLmjlzJt5//33069cPBoNB7nKIiMhCGG7IZU2bNg0PPvggFi1aBKWy+htgEhGRfWG/OLmsxo0b4+LFi3B3d5e7FCIisiD23JDL0Ov1mDhxIv766y+pjcGGiMj5MNyQy3j33Xfx1VdfISoqCvn5+XKXQ0REVsJwQy7jlVdeQffu3bFy5Up4eXGbBCIiZ8U5N+QyNBoN9uzZU+UF+oiIyLFUuefml19+wZo1a9itT3ZPFEXMmDEDmzdvltoYbIiInF+Vw01xcTGmTZuGoKAgTJo0CYcPH7ZGXUQ19u9vNyImJgbR0dGIj4+3+PW5IB8RkX2qcrgZPHgwUlJSsHz5cly5cgWdOnVCixYtsGzZMqSnp1ujRiKzxR5PlD7/19UH8MRLC7F8+XI0bNhQxqqIiMiWqjWh2NPTE2PGjMHu3btx7do1PP300/j0008REhKCoUOHYvv27Zauk6hSKdoCzN96TnptFIErmvZ4csQYGasiIiJbq/HTUoIgSPMYPDw8kJeXh0GDBqFLly64detWjQskMteNzDwYRdM2gwjEZXJ+GBGRK6lWuCkoKMC6devQu3dvhIeHY/v27Zg3bx5SUlKwfft2JCQkQKFQYNWqVZaul6hchjupEI1GkzalICCsLh/7JiJyJVUONz/++COCgoIwffp0tGrVCmfOnMGhQ4cwfvx4eHt7AwD8/f0xcOBApKWlWbxgovJ0a98SPf3SIIp3A45CABYPbYkgjafMlRERkS0JoiiKlR/2t//973+4c+cOhg4dCrVaXe5xBoMBoihCpbKvp0iys7Oh0Wig1Wrh5+cndzlkYfnFejw071cIgoDdr3ZHuL+P3CUREZEFVOXnd5V7bvr3749nnnmmwmADAEql0u6CDTmfq1evYurUqSguLpbaSuaABWo85CqLiIhkxPRBDkun0+HJJ5/EpUuXoFKpEBMTI3dJRERkB7i3FDksNzc3xMTEoHXr1pg7d67c5RARkZ1gzw05tH79+uHxxx+HUqmUuxQiIrIT7LkhhyKKIpYuXYrMzEypjcGGiIjuxXBDDmXx4sWYO3cuunfvbjKJmIiIqATDDTmUIUOGoGHDhpgxYwbc3d3lLoeIiOwQ59yQQ2nevDnOnj0LHx+uX0NERGVjzw3ZvbNnz+LSpUvSawYbIiKqCMMN2bXU1FRERUWhY8eOOHLkiNzlEBGRA5B1WEoURezatQsbN25EUFAQFi1aVOk5cXFx2LhxI65fv47Q0FA899xzaNCggQ2qJTkoFAqEhIQgKysLjRs3lrscIiJyAFXeW8pSdDodWrZsieDgYOj1euTn5+PYsWMVnrN+/XosXLgQQ4YMwYMPPoj9+/dj06ZN2LFjB7p162bWfbm3lOMpLCxERkYGQkND5S6FiIhkUpWf37KFG6PRiKtXr6Jp06Z45ZVX8Mcff1QabhISEhAUFGSyZ9WgQYOQk5OD3bt3m3VfhhvHcOHyVfRfdXeezflFT8DLnXPfiYhcmVU3zrQUhUKBpk2bVumc0NDQUptxhoeHmyzoRo5v48aNaNOyOXJO/SZ3KURE5IAc+tfh27dvY8OGDRg1alS5xxQVFaGoqEh6nZ2dbYvSqAZ+/fVX6HQ66G8lyl0KERE5IId9Wqq4uBgjRoyARqPB/Pnzyz1uyZIl0Gg00gfnbdi/VatW4Zs1a1Gr+/Nyl0JERA7IIcONTqfDiBEjcP36dezYsaPCsbe5c+dCq9VKHwkJCTaslMxlNBqlzwVBwIjokRAU3DOKiIiqzuGGpfR6PaKjo3H69Gns3bu30p4YtVoNtVpto+qoOkRRxIQJE+Dv74/FixdzI0wiIqoRu+65yc/Px5gxY7B//34Ad4PNyJEjcfLkSezdu5fr2ziJP//8E9988w0+/PBDnDhxQu5yiIjIwcnaczN37lwkJCTg+PHjSE9Px5gxYwAAX3/9NdRqNYqLi7Fu3Tr06dMH3bp1w4cffojY2Fh0794db7zxhnQdb29vrFixQq5vg2qoU6dO2LBhA9LS0hAZGSl3OURE5OBkDTddunTBnTt30K9fP5P2kmEJb29vrF27Fp07dwYA9OvXDyEhIaWuw92hHV90dLTcJRARkZOQNdw8+eSTFX7dzc1N6s0BgLZt26Jt27ZWroosKb9Yj+ZvbQdguhhfUVERFi9ejNdee40bYRIRkUXZ9Zwbcl4zZ87EokWLMGDAAMi0SDYRETkphhuSxciRIxEcHIy5c+dCEAS5yyEiIificI+Ck3Po1q0brly5Ak9Pz0qPTdUWItyfQ1dERGQe9tyQzWi1WqSlpUmvKwo2scf/3nqhz0e/Y+PRm1atjYiInAfDDdmEKIqY/OIEtGvXDocOHarw2BRtAeZvPSe9NorAGz+cRYq2wNplEhGRE2C4IZswFmTj8qVLyMrKKrWz+/1uZObBeN8cY4MoIi4z34oVEhGRs+CcG7IJpZcG+w4ewukTxypdqO/But5QCDAJOEpBQFhdLytXSUREzoA9N2Qz3t7e6N27d6XHBWk8sXBgC+m1QgAWD22JIE3lk4+JiIgYbshqRFHEpBfHI+/iH1U+d1j7v1ei3jmzO6IjuY8YERGZh8NSZDUbN27Et2vWAEoV1PUjqn2dQI2HBasiIiJnx3BDVjNs2DC8+tpsrPpLC5Wfv9zlEBGRi+CwFFmNm5sbFr3zLvzaPwXg7mJ8RERE1sZwQxa3Z88eab8oLsZHRES2xnBDFrVx40b06tULw4cPR9LtPC7GR0RENsdwQxZ1+/ZtuLm5oVmzZoi/VcDF+IiIyOY4oZgsavLkyejatSsiIiKQma/nYnxERGRz7Lkhi2vZsiXc3Ny4GB8REcmC4YZq7NixY+jbty9u3iw9WZiL8RERka0x3FCNiKKIyZMnY8eOHZg/f36Fx3IxPiIisgWGG6oRQRCwYcMGDBkyBMuWLZO7HCIiIk4opppr3LgxfvjhB4te08tdhbilAyx6TSIicg3suaFquX37Nq5cuSJ3GURERKUw3FC1/OMf/0CbNm2wbt06uUshIiIywXBDVVZYWIi0tDQUFRWhcePGcpdDRERkgnNuqMo8PDzw22+/4ciRI+jQoYPc5RAREZlgzw2ZLb9Yj7A52xA2ZxsKdAYGGyIisksMN2S2H2I3QXvoO4hGg9ylEBERlYvDUmSW27dvY8a0f+BOZiYUnr4AouQuiYiIqEzsuSGz1KpVC+8ufQ/q0JbwadVH7nKIiIjKxZ4bMosgCBjz7HN493IABEEw+zwuxkdERLbGnhuqUG5uLnQ6nfS6KsGGiIhIDgw3VKHp06cjMjISp06dkrsUIiIis3BYisqVnp6OH3/8Ebdv30Zubq7c5RAREZmF4YbKFRAQgAsXLmD79u3o0qUL8ov1cpdERERUKQ5LUYUCAgLw7LPPyl0GERGR2RhuqJTz58/j2LFjcpdBRERULQw3ZMJgMGDcuHHo0KED1qxZI3c5REREVcZwQyYKCgrQqFEjeHt7o3fv3uUel6ottGFVRERE5mO4cUH3boB5/yRhHx8frFu3DhcuXEBwcLDJ12KPJ0qf9/nod2w8etMm9RIREVUFww2V6f5gk6ItwPyt56TXRhF444ezSNEW2Lo0IiKiCjHcEABg165dmDVrFnJycsr8+o3MPBhF0zaDKCIuM98G1REREZmP69wQ9Ho9Xn75ZVy+fBlqtRrvvvtuqWMerOsNhQCTgKMUBITV9bJhpURERJVjzw1BpVLh448/RpcuXTB79uwyjwnSeGLhwBbSa4UALB7aEkEaT1uVSUREZBaGGwIAREVF4Y8//oBGoyn3mGHtQ6TPd87sjujIBrYojYiIqEoYblxccXFxtc4L1HhYuBIiIiLLYLhxYQXXjqJdq5bYunWr3KUQERFZDMONC9Me2Yy4uBvYv3+/3KUQERFZDJ+WcmEBw+ZhrN85zJo5Q+5SiIiILIbhxoUp3D0x54034eXOvwZEROQ8OCzlgi5cOC99zj2iiIjI2TDcuJiDBw+ix3OzIIpGANwjioiInA/DjYvZceAYaj/xDwjC3T967hFFRETOhuHGxTw+dBQEhekfO/eIIiIiZ8Jw42JK9oi6F/eIIiIiZ8Jw4+Dyi/UIm7MNYXO2Ib9YX+5xP//8M9LS0rhHFBEROT0+A+wCkpKSMGLECKhUKhw7dgzD2odj3pZzAO7uERXu72PWdbzcVYhbOsCapRIREdUYw40LuHPnDlq0aAG1Wo0mTZqgQGeQvsY9ooiIyNkw3LiAFi1a4PDhw8jKyoIgCJWfQERE5MA458ZFKBQK+Pv7y10GERGR1THcOLFdu3Zh1apVMBgMlR9MRETkJDgs5aQMBgOmT5+Oc+fOITMzE7Nnz5a7JCIiIptgz42TMhqNGDduHBo1aoQXX3xR7nKIiIhsxi7CTWZmJtLT061+jitxc3PDzJkzcenSJTzwwANyl0NERGQzsoab2NhY9OnTB0FBQYiKirLaOa5MqVTKXQIREZFNyRZuioqKsH79esyePRsvv/yy1c5xNZmZmRgyZAj++usvuUshIiKShWwTitVqNWJjYwEAv/zyi9XOcTXvvfcefvzxR9y8eRPHjh3jujZERORy+LSUE0nVFmLy5MlITU3F6NGjGWyIiMglOX24KSoqQlFRkfQ6OztbxmosL/Z4ovR5n49+x5KhrbB27doKz+EeUURE5Mzs4mkpa1qyZAk0Go30ERoaKndJFpOiLcD8reek10YReOOHs0jRFshYFRERkbycPtzMnTsXWq1W+khISJC7JIu5kZkHo2jaZhBFxGXmy1MQERGRHbDrYSlRFJGUlITatWvDy8urWtdQq9VQq9UWrsw+PFjXGwoBJgFHIQBhdav3XhERETkDWXtu0tLSkJiYiNzcXOh0OiQmJiIxMRGiePentVarRWhoKL777juzz3ElQRpPLBzYQvreBYhYMrQVgjSeMldGREQkH1l7bkaPHo2LFy9Krzt27AgAuHz5Mry8vKBQKBAcHAxvb2+zz3E1w9qHYN6Wu/Nudr3aA+H+PjJXREREJC9Zw83OnTsr/Lqfnx8SExNN2io7x9UYjUbp80CNh4yVEBER2Qenn1DszA4dOoSHW7dC3vnf5S6FiIjIbjDcOLCPP/4YV65cRkHcSblLISIisht2/bQUVezrr79Gi1atsTIpSO5SiIiI7AZ7bhyYr68vXnt9DtxqBcpdChERkd1guHFA924nQURERKYYbhzQgAEDMHjwYFy/fl3uUoiIiOwOw42DuXz5Mnbv3o1ffvkFKhWnTBEREd2PPx0dTNOmTXH+/HkcOnQIDRo0QH6xXu6SiIiI7ArDjQNq1qwZmjVrJncZREREdonDUg4kP5+7fRMREVWG4cZBnD17FvXr18e8efNMNgn1clchbukAxC0dAC93dsQREREx3DiINWvWQKvV4tKlSxAEQe5yiIiI7BZ/1XcQS5cuRefOndGkSRO5SyEiIrJrDDd2Ir9Yj+ZvbQcAnF/0RKkhJoVCgcGDB8tQGRERkWPhsJSdKygogNFolLsMIiIih8FwY+fmzZuH1q1bY/v27XKXQkRE5BA4LGXHdDodNmzYgKSkJPbeEBERmYnhxo65ubnh3Llz2LBhA/r16yd3OURERA6B4cbOaTQaTJo0Se4yiIiIHAbn3NgprkZMRERUPQw3dkiv16NNmzYYNmwYkpOT5S6HiIjIoXBYyg4dPHAAV69exe3bt6HRaOQuh4iIyKEw3Nihx7p3x7lz53Dt2jV4e3vLXQ4REZFDYbixU82bN0fz5s3lLoOIiMjhcM6NnRENeqRqC+Uug4iIyGEx3NiJ2OOJEEURglKFXh/uxX+PxMtdEhERkUNiuLEDKdoCzN96DoIg3G0QBPxz8zmkaAvkLYyIiMgBMdzYgRuZeTCKpm0GUURcJte6ISIiqiqGGzvwYF1vKATTNqUgIKyulzwFEREROTCGGztQz1eNBU/9/WSUQgAWD22JII2njFURERE5JoYbO7Bx40Z8MHkQ8q8cBgDsnNkd0ZENZK6KiIjIMTHc2IGVK1fi7JkzKE6/DgAI1HjIXBEREZHj4iJ+diA2NhZfrPgKXyYFy10KERGRw2PPjR2oXbs2Zrz6KpQ+D8hdChERkcNjuCEiIiKnwnAjo8WLF2PEiBE4ceKE3KUQERE5DYYbmej1enz22Wf4/vvvcenSJbnLISIichqcUCwTlUqFX3/9FatWrcKwYcOgl7sgIiIiJ8FwI6PWrVsjJiYGAKAvZrwhIiKyBA5LERERkVNhz40M3nzzTQiCgJdffhn169eXuxwiIiKnwnBjY1qtFjExMcjPz0ffvn0ZboiIiCyM4cbGvLy8sHr1avz666/o1q3b3+3uKsQtHSBjZURERM5BEEVRlLsIW8rOzoZGo4FWq4Wfn5/c5RAREZEZqvLzmxOKiYiIyKkw3NjQokWLsGbNGhQWFspdChERkdPinBsbSUtLwzvvvAOdTodWrVqhXbt2cpdERETklBhubMTd3R0LFizAyZMnGWyIiIisiBOKiYiIyO5xQjERERG5LIYbG/jyyy9x6NAhuFgnGRERkSw458bKMjMzMW3aNOh0Opw5cwYtW7aUuyQiIiKnxnBjZQUFBRg1ahSuX7/OYENERGQDnFBsI6IoQhAEm92PiIjImXBCsR1isCEiIrINhhsr2rZtG1JSUuQug4iIyKUw3FiJVqvF8OHDERoaiosXL8pdDhERkcvghGIrSU1NRbt27aDVahERESF3OURERC6D4cZKIiIicODAAWRnZ3O+DRERkQ1xWMrKuMUDERGRbTHcWMGFCxeg0+nkLoOIiMglMdxYmF6vR+/evREcHIwzZ87IXQ4REZHLYbixsOvXr8NoNEIURU4kJiIikoHsE4qPHTuGjRs3IiAgAK+99ppZ5/z222/YtWsXPDw8MGzYMLRu3drKVZqvadOmSExMxOXLl+Hu7i53OURERC5Htp4bvV6PyMhITJo0Cfv27cPGjRvNOm/u3LmIjo6GIAhITU3FI488gh9++MHK1VaNSqVC8+bN5S6DiIjIJcnWcyMIAj7//HNERkbilVdewR9//FHpOZcvX8b777+PzZs3Y+DAgQAAjUaDqVOnYuDAgVCp5O2Iys3NhY+Pj6w1EBERuTrZem6USiUiIyOrdM7PP/8MPz8/DBgwQGp79tlnkZKSgqNHj1q6xCrr3bs3Hn30UZw6dUruUoiIiFyW7HNuquLKlSto0KABlEql1BYeHi59rVOnTqXOKSoqQlFRkfQ6OzvbKrUlJSXhxIkTAICgoCCr3IOIiIgq51BPSxUUFMDX19ekzdvbG0qlEvn5+WWes2TJEmg0GukjNDTUKrUFBwcjKSkJ33//PQICAqxyDyIiIqqcQ4UbHx8f3Llzx6QtOzsbBoOh3JWA586dC61WK30kJCRYrb6AgAAMHjzYatcnIiKiyjlUuGnRogXi4uJQWFgotV24cAEAyn06Sa1Ww8/Pz+SDiIiInJddh5uCggJMnToVhw8fBgAMGjQIer0eq1evlo5Zvnw5IiIi0KZNG7nKJCIiIjsi64TixYsXIzk5GX/88QeSk5MxdepUAMBHH30Ed3d3FBUVYfny5XjkkUfQoUMH1K9fH59++immT5+OX3/9Fbdu3cLp06fxyy+/cOdtIiIiAiBzuHnwwQfh5+eHZs2ambSXBBUvLy98+umn6Nixo/S1F198Eb169cK+ffugVqvxxBNPoE6dOjatm4iIiOyXIIqiKHcRtpSdnQ2NRgOtVsv5N0RERA6iKj+/7XrODREREVFVMdwQERGRU2G4ISIiIqfCcENEREROheGGiIiInArDDRERETkVhhsiIiJyKgw3RERE5FQYboiIiMipyLr9ghxKFmTOzs6WuRIiIiIyV8nPbXM2VnC5cJOTkwMACA0NlbkSIiIiqqqcnBxoNJoKj3G5vaWMRiOSk5Ph6+tr8Z3Es7OzERoaioSEBO5bVQN8Hy2D76Nl8H20DL6PluHK76MoisjJyUH9+vWhUFQ8q8blem4UCgVCQkKseg8/Pz+X+0tnDXwfLYPvo2XwfbQMvo+W4arvY2U9NiU4oZiIiIicCsMNERERORWGGwtSq9WYP38+1Gq13KU4NL6PlsH30TL4PloG30fL4PtoHpebUExERETOjT03RERE5FQYboiIiMipMNwQERGRU2G4sYDU1FRMmzYNPXr0wIgRI7B37165S3JISUlJWLBgATp37oyYmBi5y3FIer0eq1evxsiRI9G3b1/MmDEDN2/elLssh/Tbb79h7Nix6NWrF8aOHYt9+/bJXZJDO3/+PDp37oznnntO7lIczvbt29GxY8dSH7m5uXKXZrdcbhE/S8vNzUXXrl3RqFEjvPbaazh8+DAef/xx/Prrr+jdu7fc5TmMP//8EyNHjsTzzz+PrKwsxMXFyV2SQxo1ahR8fHwwePBg1K5dGytXrkTbtm1x7NgxhIeHy12ew1i+fDl2796NIUOGoH79+tizZw969eqF2NhYDBo0SO7yHE5BQQFGjhwJo9GI06dPy12Ow8nIyMCVK1ewbds2k3ZPT0+ZKrJ/fFqqhj7++GPMnz8fqamp8PLyAgCMHDkS8fHxOHTokMzVOY68vDx4eHhAqVTikUceQdeuXdl7Uw25ubnw8fGRXhsMBoSFheGFF17AokWLZKzMseTn50v/nkv07t0bQUFB+Pbbb2WqynFNmjQJKpUKbm5u2Lt3L06ePCl3SQ7l22+/xaxZs5Camip3KQ6Dw1I1tGvXLvTu3dvkP8JBgwbh8OHD0iadVDlvb28olUq5y3B49wYbAFAqlfD09ERxcbFMFTmm+4NNWloaLl26hDZt2shUkePatGkT9u/fjw8//FDuUhxadnY2+vfvj/79+2POnDnIyMiQuyS7xnBTQ/Hx8ahfv75JW/369SGKIhISEmSqiuiu77//HlevXsXAgQPlLsXhGAwGdOzYEe3atUOjRo0wbtw4zJo1S+6yHEpcXBymTJmCdevWcQilBgRBwPDhw/HSSy/hxRdfxOHDh9GiRQskJyfLXZrd4pybGtLpdKVWiiz5R6zT6eQoiQgAcPz4cYwfPx5z585F586d5S7H4SiVSsTExCAvLw+7du3CsmXL0KFDBwwYMEDu0hyCXq/HqFGjMGvWLLRr107uchza008/jdGjR0uvBwwYgObNm2Px4sX47LPPZKzMfjHc1FDt2rVx69Ytk7asrCwAQJ06deQoiQgnT55E3759MXbsWLz77rtyl+OwOnbsCODufJuMjAy88cYbDDdmunTpEg4dOgS9Xo/Y2FgAd3u6s7Oz0bFjR3z66aeIjIyUuUrHcP8v0Gq1Gt26dcOpU6dkqsj+MdzU0MMPP4w9e/aYtB0+fBj+/v4IDg6WqSpyZadPn0afPn3wzDPP4JNPPpG7HKcRFBSEzMxMuctwGOHh4aUeqoiJicGJEycQExODiIgImSpzDqmpqfD29pa7DLvFOTc1NG7cOFy4cAGbNm0CACQnJ+Pf//43xo0bB0EQZK6OXM3Zs2fRu3dvjBw5kt3VNfDZZ5+ZTNi8evUqVq9ejf79+8tYlWPx9PQstS5LYGAgvLy80LFjR/j5+cldosP417/+ZfL3cePGjfjtt98wcuRIGauyb+y5qaGHH34YX3zxBZ5//nnMnTsXiYmJiIqKwoIFC+QuzaHk5uaiT58+AICLFy8iKSkJf/75J5o2bYo1a9bIXJ3jmDhxIm7duoVjx45JQyoA0KtXLyxevFjGyhxLvXr10KFDB6hUKigUCty8eROjR4/Gxx9/LHdp5IICAgIQGRkJtVqNwsJCaLVaLFu2DGPHjpW7NLvFdW4sJDc3F1euXEFAQACHo6rBYDDg6NGjpdq9vb3RqlUrGSpyTGfPni1z1dI6deqgSZMmMlTkuERRxI0bN1BcXIyGDRvyaR8LKJlzw3/TVSeKIq5duwZBEBAWFsalMyrBcENEREROhXNuiIiIyKkw3BAREZFTYbghIiIip8JwQ0RERE6F4YaIiIicCsMNERERORWGGyIiInIqDDdERETkVBhuiIiIyKkw3BCRQ9PpdNi4cSMuX75s0r5nzx7s3btXnqKISFYMN0Tk0Nzc3HDgwAFERUUhJycHALB//3707dsXer1e5uqISA7cW4qIHF5hYSEiIyPRvn17xMTEoE2bNhg+fDg+/PBDuUsjIhkw3BCRUzhz5gweffRRNGnSBEqlEocPH4a7u7vcZRGRDDgsRUROoVWrVhgxYgTOnDmD999/n8GGyIWx54aInMKxY8fQuXNnNG7cGP7+/tizZw8UCv7+RuSK+C+fiBxeXl4eRo8ejRdffBG7du3C+fPn8d5778ldFhHJhD03ROTwJk6ciP379+PEiRPw9PTEli1bMHz4cBw6dAjt27eXuzwisjH23BCRQ4uLi0NOTg7Wr18PT09PAMCgQYOwaNEi/PTTTzJXR0RyYM8NERERORX23BAREZFTYbghIiIip8JwQ0RERE6F4YaIiIicCsMNERERORWGGyIiInIqDDdERETkVBhuiIiIyKkw3BAREZFTYbghIiIip8JwQ0RERE6F4YaIiIicyv8BHxQufcX/FtwAAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# truth: a saturating (non-linear) curve the straight line cannot capture\n", - "K = 2.0\n", + "def defect(x):\n", + " return 0.03 * np.asarray(x, dtype=float) ** 2\n", "\n", "\n", "def truth(x):\n", - " return (0.8 * x + 1.0) / (1.0 + x / K)\n", + " return M_TRUE * np.asarray(x, dtype=float) + B_TRUE + defect(x)\n", "\n", "\n", + "rng = np.random.default_rng(7)\n", "x = np.linspace(0.2, 5.0, 30)\n", "noise = 0.02\n", - "y = truth(x) + rng.normal(0.0, noise, size=x.size)\n", - "observation = rxmc.observation.Observation(x=x, y=y, y_stat_err=noise * np.ones_like(y))\n", - "\n", - "xg = np.linspace(0.0, 5.5, 120) # fine grid for predictions\n", - "\n", - "plt.errorbar(x, y, noise, ls=\"none\", marker=\".\", label=\"data\")\n", - "plt.plot(xg, truth(xg), \"k:\", label=\"truth\")\n", - "plt.xlabel(\"x\")\n", - "plt.ylabel(\"y\")\n", - "plt.legend()\n", - "plt.title(\"data from a non-linear truth\");" + "data = rx.Dataset(\n", + " x, truth(x) + rng.normal(0.0, noise, x.size), np.full(x.size, noise), label=\"toy\"\n", + ")\n", + "x_fine = np.linspace(0.0, 6.0, 80)" ] }, { - "cell_type": "markdown", - "id": "c05", + "cell_type": "code", + "execution_count": 3, + "id": "81c09486", "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "defect / noise at x = 0.2, 2.5, 5.0: [ 0.1 9.4 37.5]\n" + ] + } + ], "source": [ - "## Building the constraint with a GP discrepancy term\n", - "\n", - "`rxmc.covariance.kernel_term(kernel)` wraps a scikit-learn kernel as\n", - "a kernel `Term`. It **auto-derives one `Parameter` per free kernel hyperparameter**\n", - "(sampled in sklearn's log-theta space). The constraint then carries those\n", - "hyperparameters as its covariance parameters (`constraint.params`), so it is\n", - "auto-detected as a parametric constraint." + "print(\n", + " \"defect / noise at x = 0.2, 2.5, 5.0:\", np.round(defect([0.2, 2.5, 5.0]) / noise, 1)\n", + ")" ] }, { "cell_type": "code", "execution_count": 4, - "id": "c06", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:07:54.039335Z", - "iopub.status.busy": "2026-08-11T03:07:54.039172Z", - "iopub.status.idle": "2026-08-11T03:07:54.043021Z", - "shell.execute_reply": "2026-08-11T03:07:54.042513Z" - } - }, + "id": "cf684d62", + "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "GP hyperparameters (sampled in log-theta space):\n", - " discrepancy_k1__k1__constant_value\n", - " discrepancy_k1__k2__length_scale\n", - " discrepancy_k2__noise_level\n" - ] + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "kernel = ConstantKernel(1.0) * Matern(length_scale=2.0, nu=2.5) + WhiteKernel(1e-6)\n", - "\n", - "constraint_gp = rxmc.constraint.Constraint(\n", - " [observation],\n", - " model,\n", - " extra_terms=[rxmc.covariance.kernel_term(kernel)],\n", + "fig, ax = plt.subplots()\n", + "ax.errorbar(data.x, data.y, data.y_err, fmt=\"o\", ms=4, color=\"k\", label=\"data\")\n", + "ax.plot(x_fine, truth(x_fine), \"--\", color=plotstyle.COLOURS[1], label=\"truth\")\n", + "ax.plot(\n", + " x_fine,\n", + " M_TRUE * x_fine + B_TRUE,\n", + " \":\",\n", + " color=plotstyle.COLOURS[0],\n", + " label=\"the true line, without the defect\",\n", ")\n", - "evidence_gp = rxmc.evidence.Evidence([constraint_gp])\n", - "\n", - "print(\"GP hyperparameters (sampled in log-theta space):\")\n", - "for p in constraint_gp.params:\n", - " print(\" \", p.name)" + "ax.set(xlabel=\"$x$\", ylabel=\"$y$\", title=\"A line, and a truth that leaves it\")\n", + "ax.legend()\n", + "plt.show()" ] }, { "cell_type": "markdown", - "id": "c07", + "id": "000c2900", "metadata": {}, "source": [ - "For comparison we also build two reference constraints over the *same* data:\n", - "a plain line (statistical errors only) and a line with an uncorrelated\n", - "**model-error** term (`model_error_term`, the diagonal $\\gamma^2$ inflation).\n", - "Neither can represent the *correlated* curvature the GP captures." + "## Four ways to say \"the model is wrong\"\n", + "\n", + "We'll fit the same line four times, and the only thing we'll change between fits is the covariance:\n", + "\n", + "1. **Statistics only.** We use the reported errors and nothing else, which amounts to claiming the line is perfect.\n", + "2. **An uncorrelated proportional error** (`T.proportional_error`). Every point gets some extra slack, in proportion to its size, but each point's slack is *independent* of its neighbours'.\n", + "3. **A GP with a constant amplitude.** Now the discrepancy is smooth and mean-zero, but it's allowed to be the same size everywhere.\n", + "4. **A GP whose amplitude grows with $x$** (`T.exp_growth_amplitude`). This is the same smooth discrepancy, except that it can be small where we trust the line and large where we don't.\n", + "\n", + "We'll call these four the *rungs* of a ladder, from claiming the model is perfect to saying exactly how we think it fails. Only the last one encodes what we actually believe about this problem. The nice thing is that each of these is a single `Term` in a `Constraint`, so the inference code doesn't change between them at all. The kernel is a [Matérn](https://en.wikipedia.org/wiki/Mat%C3%A9rn_covariance_function) with $\\nu = 5/2$: smooth, but not as unrealistically smooth as a squared exponential.\n", + "\n", + "The priors say what we know before seeing the data. The line's $m$ and $b$ get wide normals. The proportional error's fraction $\\gamma$ is centred on 5 % with a factor-of-$e$ width. The GP's length scale $\\ell$ gets a log-uniform prior between the two natural extremes of this dataset, the spacing of neighbouring points and the whole range they cover, as in `alpha_ca_error_model_comparison`. Its amplitude $A$ (the size of the discrepancy at $x = 0$) is centred on the noise level, 0.02, with a width of a factor of $e^{1.5}$ either way. The slope $s_A$ of its growth, in $A\\,e^{s_A x/5}$, is centred on *zero*, no growth, so any growth the fit finds comes from the data." ] }, { "cell_type": "code", "execution_count": 5, - "id": "c08", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:07:54.044477Z", - "iopub.status.busy": "2026-08-11T03:07:54.044335Z", - "iopub.status.idle": "2026-08-11T03:07:54.048000Z", - "shell.execute_reply": "2026-08-11T03:07:54.047249Z" - } - }, + "id": "1a201944", + "metadata": {}, "outputs": [], "source": [ - "constraint_plain = rxmc.constraint.Constraint([observation], model)\n", - "evidence_plain = rxmc.evidence.Evidence([constraint_plain])\n", - "\n", - "gamma = rxmc.params.Parameter(\n", - " \"log fractional err\", float, latex_name=r\"\\gamma\", unit=\"dimensionless\"\n", + "m = rx.Parameter(\"m\", prior=stats.norm(0.0, 2.0), latex=\"m\")\n", + "b = rx.Parameter(\"b\", prior=stats.norm(0.0, 2.0), latex=\"b\")\n", + "line = rx.Model(lambda x, m, b: m * x + b, [m, b])\n", + "comp = rx.Comparison(data, line)\n", + "\n", + "spacing, span = np.diff(x).min(), x.max() - x.min()\n", + "gamma = rx.Parameter(\n", + " \"log_gamma\", prior=stats.norm(np.log(0.05), 1.0), latex=r\"\\log\\gamma\"\n", ")\n", - "constraint_me = rxmc.constraint.Constraint(\n", - " [observation],\n", - " model,\n", - " extra_terms=[rxmc.covariance.model_error_term(gamma, averaging=True)],\n", + "log_A = rx.Parameter(\"log_A\", prior=stats.norm(np.log(0.02), 1.5), latex=r\"\\log A\")\n", + "amp_slope = rx.Parameter(\"amp_slope\", prior=stats.norm(0.0, 1.5), latex=r\"s_A\")\n", + "log_ell = rx.Parameter(\n", + " \"log_ell\",\n", + " prior=stats.uniform(np.log(spacing), np.log(span / spacing)),\n", + " latex=r\"\\log \\ell\",\n", ")\n", - "evidence_me = rxmc.evidence.Evidence([constraint_me])" + "\n", + "\n", + "# a Matern-5/2 kernel in the sampled log length scale; jitter=1e-6 adds a\n", + "# nugget of 1e-6 of each point's own variance\n", + "def matern(log_ell):\n", + " return tinygp.kernels.Matern52(scale=jnp.exp(log_ell))\n", + "\n", + "\n", + "gp_const = T.kernel(\n", + " matern,\n", + " params=[log_ell],\n", + " amplitude=T.constant_amplitude,\n", + " amplitude_params=(log_A,),\n", + " jitter=1e-6,\n", + ")\n", + "gp_grow = T.kernel(\n", + " matern,\n", + " params=[log_ell],\n", + " amplitude=T.exp_growth_amplitude(5.0),\n", + " amplitude_params=(log_A, amp_slope),\n", + " jitter=1e-6,\n", + ")" ] }, { - "cell_type": "markdown", - "id": "c09", + "cell_type": "code", + "execution_count": 6, + "id": "54264f30", "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "statistics only ['m', 'b']\n", + "proportional error ['m', 'b', 'log_gamma']\n", + "GP, constant amplitude ['m', 'b', 'log_ell', 'log_A']\n", + "GP, growing amplitude ['m', 'b', 'log_ell', 'log_A', 'amp_slope']\n" + ] + } + ], "source": [ - "## Sampling\n", - "\n", - "The physical parameters $(m, b)$ are sampled in the model block; each parametric\n", - "constraint's covariance parameters (GP log-theta, or $\\gamma$) are sampled in a\n", - "Gibbs block by a `likelihood_sampler`. GP hyperparameters get a broad\n", - "$\\mathcal N(0, 2)$ prior **per log-hyperparameter**." + "problems = {\n", + " \"statistics only\": rx.Problem([rx.Constraint([comp])]),\n", + " \"proportional error\": rx.Problem(\n", + " [rx.Constraint([comp], terms=[T.proportional_error(gamma, averaging=True)])]\n", + " ),\n", + " \"GP, constant amplitude\": rx.Problem([rx.Constraint([comp], terms=[gp_const])]),\n", + " \"GP, growing amplitude\": rx.Problem([rx.Constraint([comp], terms=[gp_grow])]),\n", + "}\n", + "for name, p in problems.items():\n", + " print(f\"{name:24s} {p.names}\")" ] }, { "cell_type": "code", - "execution_count": 6, - "id": "c10", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:07:54.049326Z", - "iopub.status.busy": "2026-08-11T03:07:54.049168Z", - "iopub.status.idle": "2026-08-11T03:08:09.762020Z", - "shell.execute_reply": "2026-08-11T03:08:09.761234Z" - } - }, + "execution_count": 7, + "id": "699a541c", + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "line only: model acceptance 0.45\n" + "statistics only acceptance 0.70-0.72, run = 599 tau, split R-hat 1.002, stragglers: none: converged\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "proportional error acceptance 0.64-0.65, run = 485 tau, split R-hat 1.001, stragglers: none: converged\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "line + model error: model acceptance 0.35\n" + "GP, constant amplitude acceptance 0.54-0.56, run = 269 tau, split R-hat 1.004, stragglers: none: converged\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "line + GP discrepancy: model acceptance 0.38\n" + "GP, growing amplitude acceptance 0.42-0.44, run = 174 tau, split R-hat 1.005, stragglers: none: converged\n" ] } ], "source": [ - "model_prior = stats.multivariate_normal(mean=[0.8, 1.0], cov=np.diag([0.5, 0.5]) ** 2)\n", - "\n", - "\n", - "def make_model_sampler():\n", - " return rxmc.param_sampling.BatchedAdaptiveMetropolisSampler(\n", - " params=model.params,\n", - " starting_location=model_prior.mean,\n", - " prior=model_prior,\n", - " initial_proposal_cov=model_prior.cov / 100,\n", + "def fit(problem, seed, n_walkers=24, n_steps=budget(20000), label=\"\"):\n", + " \"\"\"emcee from a ball about the MAP; checked, then burnt in and thinned by tau.\"\"\"\n", + " theta_map = rx.optimize.find_map(problem, rng=seed).x\n", + " z_map = problem.to_unconstrained(theta_map)\n", + " jitter = 1e-3 * np.random.default_rng(seed).standard_normal(\n", + " (n_walkers, problem.ndim)\n", " )\n", - "\n", - "\n", - "def make_nuisance_sampler(params, prior, cov):\n", - " return rxmc.param_sampling.BatchedAdaptiveMetropolisSampler(\n", - " params=list(params),\n", - " starting_location=prior.mean,\n", - " prior=prior,\n", - " initial_proposal_cov=cov,\n", + " start = np.array([problem.to_theta(z_map + dz) for dz in jitter])\n", + " sampler = emcee.EnsembleSampler(\n", + " n_walkers, problem.ndim, problem.log_posterior_batch, vectorize=True\n", + " )\n", + " sampler.random_state = np.random.RandomState(seed).get_state()\n", + " sampler.run_mcmc(start, n_steps, progress=False)\n", + " tau = sampler.get_autocorr_time(discard=n_steps // 5, quiet=True).max()\n", + " discard, thin = int(5 * tau), max(1, int(tau / 2))\n", + " walkers = np.swapaxes(sampler.get_chain(discard=discard, thin=thin), 0, 1)\n", + " rhat = float(np.max(blackjax.diagnostics.rhat(walkers)))\n", + " walker_log_post = sampler.get_log_prob(discard=discard).mean(axis=0)\n", + " stragglers = np.flatnonzero(walker_log_post < np.median(walker_log_post) - 20)\n", + " acceptance = sampler.acceptance_fraction\n", + " converged = (\n", + " n_steps >= 50 * tau\n", + " and rhat <= 1.01\n", + " and stragglers.size == 0\n", + " and acceptance.min() > 0.1\n", + " )\n", + " print(\n", + " f\"{label}acceptance {acceptance.min():.2f}-{acceptance.max():.2f}, \"\n", + " f\"run = {n_steps / tau:.0f} tau, split R-hat {rhat:.3f}, \"\n", + " f\"stragglers: {stragglers.tolist() or 'none'}: \"\n", + " + (\"converged\" if converged else \"NOT CONVERGED\")\n", " )\n", + " return sampler.get_chain(discard=discard, thin=thin, flat=True)\n", + "\n", + "\n", + "# the growing amplitude mixes slowest, so it gets twice the run\n", + "n_steps = {\n", + " name: budget(40000 if name == \"GP, growing amplitude\" else 20000)\n", + " for name in problems\n", + "}\n", + "samples = {\n", + " name: fit(p, seed=i, n_steps=n_steps[name], label=f\"{name:24s} \")\n", + " for i, (name, p) in enumerate(problems.items())\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "f08f7fc9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "statistics only m = 0.953 [0.951, 0.956] (pull +60.1) b = 0.858 [0.850, 0.865] (pull -18.8)\n", + "proportional error m = 0.927 [0.919, 0.935] (pull +16.1) b = 0.916 [0.901, 0.932] (pull -5.3)\n", + "GP, constant amplitude m = 0.957 [0.913, 1.001] (pull +3.0) b = 0.983 [0.807, 1.201] (pull -0.1)\n", + "GP, growing amplitude m = 0.877 [0.825, 0.969] (pull +1.0) b = 0.974 [0.887, 1.060] (pull -0.1)\n", + "\n", + "amplitude slope s_A: median 1.65, 68 % [0.03, 2.68] (prior: 0 +/- 1.5)\n", + "length scale ell: median 3.51, 68 % [2.31, 4.42] (data span 4.8)\n" + ] + } + ], + "source": [ + "def summary(problem, draws, params, truths):\n", + " \"\"\"Median and 68 % interval of each parameter, and its pull from the truth.\"\"\"\n", + " out = []\n", + " for q, true in zip(params, truths):\n", + " s = draws[:, problem.columns(q)].ravel()\n", + " lo, mid, hi = np.percentile(s, [16, 50, 84])\n", + " out.append(\n", + " f\"{q.name} = {mid:.3f} [{lo:.3f}, {hi:.3f}] (pull {(mid - true) / s.std():+5.1f})\"\n", + " )\n", + " return \" \".join(out)\n", "\n", "\n", - "theta_prior = stats.multivariate_normal(\n", - " mean=np.zeros(constraint_gp.n_params), cov=4.0 * np.eye(constraint_gp.n_params)\n", + "for name, p in problems.items():\n", + " print(f\"{name:24s} {summary(p, samples[name], line.params, (M_TRUE, B_TRUE))}\")\n", + "s_grow = samples[\"GP, growing amplitude\"]\n", + "q = np.percentile(\n", + " s_grow[:, problems[\"GP, growing amplitude\"].columns(amp_slope)], [16, 50, 84]\n", ")\n", - "gamma_prior = stats.multivariate_normal(mean=[np.log(0.05)], cov=[[1.0]])\n", - "\n", - "walkers = {}\n", - "walkers[\"line only\"] = rxmc.walker.Walker(make_model_sampler(), evidence_plain, rng=rng)\n", - "walkers[\"line + model error\"] = rxmc.walker.Walker(\n", - " make_model_sampler(),\n", - " evidence_me,\n", - " likelihood_samplers=[\n", - " make_nuisance_sampler(constraint_me.params, gamma_prior, np.array([[0.04]]))\n", - " ],\n", - " rng=rng,\n", - ")\n", - "walkers[\"line + GP discrepancy\"] = rxmc.walker.Walker(\n", - " make_model_sampler(),\n", - " evidence_gp,\n", - " likelihood_samplers=[\n", - " make_nuisance_sampler(\n", - " constraint_gp.params, theta_prior, 0.04 * np.eye(constraint_gp.n_params)\n", - " )\n", - " ],\n", - " rng=rng,\n", + "print(\n", + " f\"\\namplitude slope s_A: median {q[1]:.2f}, 68 % [{q[0]:.2f}, {q[2]:.2f}] (prior: 0 +/- 1.5)\"\n", ")\n", - "\n", - "for key, walker in walkers.items():\n", - " walker.walk(n_steps=4000, burnin=1500, batch_size=500, verbose=False)\n", - " print(\n", - " f\"{key}: model acceptance \"\n", - " f\"{walker.model_sampler.overall_acceptance_fraction():.2f}\"\n", - " )" + "q = np.exp(\n", + " np.percentile(\n", + " s_grow[:, problems[\"GP, growing amplitude\"].columns(log_ell)], [16, 50, 84]\n", + " )\n", + ")\n", + "print(\n", + " f\"length scale ell: median {q[1]:.2f}, 68 % [{q[0]:.2f}, {q[2]:.2f}] (data span {span:.1f})\"\n", + ")" ] }, { "cell_type": "markdown", - "id": "c11", + "id": "bf2aeeb7", "metadata": {}, "source": [ - "## Posterior of the GP hyperparameters" + "### What those four rows tell us\n", + "\n", + "Every fit passed its checks: split $\\hat R$ at most 1.005, no stragglers, and runs of at least 174 autocorrelation times.\n", + "\n", + "**Statistics only** is the cautionary tale. It gives $m = 0.953$ [0.951, 0.956], sixty standard deviations from the truth. The line has no way to say \"I'm wrong at large $x$\", so it tilts to chase the defect and then reports a precision of a few parts in a thousand. An unmodelled discrepancy doesn't make our answer vaguer; it *moves* it, and confidently.\n", + "\n", + "**The proportional error** barely helps: $m = 0.927$ [0.919, 0.935], still sixteen standard deviations out. Each point gets independent slack, and independent slack cannot describe a smooth, coherent departure: the likelihood still reads the trend in the residuals as thirty independent votes for tilting the line, just with slightly wider error bars.\n", + "\n", + "**The constant-amplitude GP** knows the defect is smooth, and that alone helps a great deal: $m = 0.957$, three standard deviations out instead of sixty, with a far wider interval. It is still out, though. One amplitude cannot be small where the line is good and large where it is not, so the fit compromises, and its slope still leans towards the defect.\n", + "\n", + "**The growing amplitude**, the one that matches what we believe, covers the truth: $m = 0.877$ [0.825, 0.969] and $b = 0.974$ [0.887, 1.060] (68 % intervals, as everywhere here), within one standard deviation for both. Did the data really ask for the growth? They lean that way: the slope $s_A$ has a posterior median of 1.7, against a prior centred on zero, but its 68 % interval, 0.03 to 2.7, only just leaves zero out. Thirty points cannot settle it on their own. The growth is mostly our prior knowledge, which is why it is worth stating." ] }, { "cell_type": "code", - "execution_count": 7, - "id": "c12", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:08:09.763535Z", - "iopub.status.busy": "2026-08-11T03:08:09.763375Z", - "iopub.status.idle": "2026-08-11T03:08:11.031094Z", - "shell.execute_reply": "2026-08-11T03:08:11.030356Z" - } - }, + "execution_count": 9, + "id": "1b55f904", + "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -373,49 +410,157 @@ } ], "source": [ - "gp_walker = walkers[\"line + GP discrepancy\"]\n", - "theta_chain = gp_walker.likelihood_samplers[0].chain\n", - "fig = corner.corner(\n", - " theta_chain,\n", - " labels=[p.latex_name for p in constraint_gp.params],\n", - " show_titles=True,\n", + "p_names = list(problems)\n", + "pooled = np.vstack([samples[n][:, problems[n].columns(line.params)] for n in p_names])\n", + "span_mb = list(zip(*np.percentile(pooled, [0.1, 99.9], axis=0)))\n", + "fig = None\n", + "colours = [plotstyle.COLOURS[i] for i in (1, 3, 5, 0)]\n", + "for name, colour in zip(p_names, colours):\n", + " p = problems[name]\n", + " fig = corner.corner(\n", + " samples[name][:, p.columns(line.params)],\n", + " fig=fig,\n", + " labels=[\"$m$\", \"$b$\"],\n", + " truths=[M_TRUE, B_TRUE],\n", + " range=span_mb,\n", + " **plotstyle.corner_kwargs(\n", + " color=colour,\n", + " fill_contours=False,\n", + " plot_density=False,\n", + " show_titles=False,\n", + " hist_kwargs={\"density\": True},\n", + " ),\n", + " )\n", + "fig.legend(\n", + " handles=[plt.Line2D([], [], color=c, label=n) for n, c in zip(p_names, colours)],\n", + " loc=\"upper right\",\n", + " fontsize=9,\n", ")\n", - "fig.suptitle(\"GP hyperparameters (log-theta)\");" + "plt.show()" ] }, { "cell_type": "markdown", - "id": "c13", + "id": "61c8dadf", "metadata": {}, "source": [ - "## Propagating the total uncertainty\n", + "## Propagating the whole uncertainty\n", + "\n", + "The line's own posterior band can't bend. It has two parameters, so all it can ever produce is a fan of straight lines. The GP supplies the piece that *can* bend. But once we have a discrepancy in the mix, there are actually three different things we might draw, and they answer different questions, so let's go through them carefully.\n", + "\n", + "Because our kernel declares a **mean-zero** discrepancy, the likelihood we fit was already the marginal over $\\delta$, a [multivariate normal](https://en.wikipedia.org/wiki/Multivariate_normal_distribution) whose covariance is the sum of the experimental covariance and the kernel:\n", "\n", - "`rxmc.predictive.total_predictive_band` takes the posterior draws\n", - "$[m, b \\mid \\log\\theta]$ and, for each draw, conditions the GP discrepancy on the\n", - "residuals and samples\n", - "$y_* = y_m(x_*) + \\bar f_*(x_*) + \\mathcal N(0,\\ \\mathrm{var}_* + \\sigma^2)$ on the\n", - "fine grid. The line-only and model-error bands are credible intervals on the mean\n", - "line (they cannot bend); the GP band tracks the non-linear truth." + "$$\\mathbf{y} \\sim \\mathcal{N}\\big(y_m(\\mathbf{x};\\alpha),\\ \\Sigma(\\alpha)\\big),\n", + "\\qquad \\Sigma(\\alpha) = \\Sigma_\\mathrm{exp} + K(\\alpha).$$\n", + "\n", + "In other words, the fit integrated the discrepancy out rather than estimating it. The first predictive that matches this is a correlated draw from the inferred kernel, centred on the model's *own* prediction, with one draw for every posterior sample:\n", + "\n", + "$$y_* = y_m(x_*;\\alpha) + \\delta, \\qquad\n", + "\\delta \\sim \\mathcal{N}\\big(0,\\ K_{**}(\\alpha)\\big).$$\n", + "\n", + "We get this from `rx.predictive.grid_draws` by naming just the kernel in `terms=`. It's a statement about **the model**: where it may be wrong, and by how much. Notice that it carries no experimental error, so it isn't what we should compare our data against. For that we need the second object, which includes every term:\n", + "\n", + "$$y = y_m(x;\\alpha) + \\delta + \\varepsilon, \\qquad\n", + "\\varepsilon \\sim \\mathcal{N}\\big(0,\\ \\Sigma_\\mathrm{exp}\\big).$$\n", + "\n", + "`terms=` is how we choose between them. Below we'll draw the first on the fine grid, naming only the kernel. We have to, because the reported errors are one number per *measured* point, and they simply don't exist at a new $x$. (If we wanted experimental noise on the grid too, we would declare it as a term that is defined at every $x$, such as `T.noise(...)` in a constraint built with `statistical=False`, as in `linear_calibration`.) Then we'll draw the second at the measured points, where they do exist.\n", + "\n", + "The third object, which we're deliberately not going to use, conditions the discrepancy on the observed residuals $r$:\n", + "\n", + "$$\\delta \\mid r \\sim \\mathcal{N}\\big(K_{*t}(K_{tt}+N)^{-1}r,\\;\n", + "K_{**} - K_{*t}(K_{tt}+N)^{-1}K_{t*}\\big).$$\n", + "\n", + "This is ordinary GP regression, as in [Rasmussen & Williams (2006), ch. 2](http://gaussianprocess.org/gpml/), and it's available as `rx.predictive.gp_predictive_draws(..., conditioned=True)`. What it does is interpolate the residuals, stacking a data-driven regression on top of the model. Where that band is narrow, it's narrow because the data pinned it there, not because the model is any good. Our question in this notebook is where the *model* fails, so we want the first two objects.\n", + "\n", + "One more detail matters for what follows. Each draw is a whole curve, not a column of independent points. For every posterior sample, `grid_draws` re-evaluates the kernel, growing amplitude included, on the new grid, takes its [Cholesky factor](https://en.wikipedia.org/wiki/Cholesky_decomposition) once, and draws a single correlated vector from it. That's what lets us ask a question like \"how far does the truth wander from the model *anywhere* in this range?\" and get a sensible answer." ] }, { "cell_type": "code", - "execution_count": 8, - "id": "c14", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:08:11.032555Z", - "iopub.status.busy": "2026-08-11T03:08:11.032395Z", - "iopub.status.idle": "2026-08-11T03:08:12.461318Z", - "shell.execute_reply": "2026-08-11T03:08:12.460505Z" + "execution_count": 10, + "id": "152c7f05", + "metadata": {}, + "outputs": [], + "source": [ + "p_grow = problems[\"GP, growing amplitude\"]\n", + "rows = s_grow[::5]\n", + "\n", + "# the model plus its discrepancy, on any grid we like: name the kernel alone.\n", + "# With n_rep=1, draw i belongs to rows[i], so subtracting the same rows' model\n", + "# curves leaves each draw's discrepancy on its own.\n", + "draws_gp = rx.predictive.grid_draws(\n", + " p_grow, line.bind(x_fine), x_fine, rows, terms=[gp_grow], rng=4, return_draws=True\n", + ")\n", + "draws_line = rx.predictive.grid_draws(\n", + " p_grow, line.bind(x_fine), x_fine, rows, model_only=True, return_draws=True\n", + ")\n", + "draws_delta = draws_gp - draws_line\n", + "band_gp = np.percentile(draws_gp, [16, 84], axis=0)\n", + "# every term the error model declares, at the points that were measured\n", + "draws_data = rx.diagnostics.predictive_draws(\n", + " p_grow, rows, n_rep=2, rng=4, return_draws=True\n", + ")\n", + "\n", + "\n", + "def mean_band(problem, samples_, levels=(16, 84)):\n", + " # the fan of model curves alone, with no error model at all\n", + " return rx.predictive.grid_draws(\n", + " problem,\n", + " line.bind(x_fine),\n", + " x_fine,\n", + " samples_[::5],\n", + " model_only=True,\n", + " levels=levels,\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "d8b317c3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "model + discrepancy half-width (68 %) at x = 0.2, 2.5, 5.0: [0.121 0.213 0.431]\n", + "the line alone half-width (68 %) at x = 0.2, 2.5, 5.0: [0.088 0.171 0.33 ]\n", + "the discrepancy alone half-width (68 %) at x = 0.2, 2.5, 5.0: [0.076 0.138 0.29 ]\n", + "mean 68 % width including the experimental errors: 0.496\n" + ] } - }, + ], + "source": [ + "at = [0.2, 2.5, 5.0]\n", + "half = {\n", + " \"model + discrepancy\": 0.5\n", + " * np.subtract(*np.percentile(draws_gp, [84, 16], axis=0)),\n", + " \"the line alone\": 0.5 * np.subtract(*np.percentile(draws_line, [84, 16], axis=0)),\n", + " \"the discrepancy alone\": 0.5\n", + " * np.subtract(*np.percentile(draws_delta, [84, 16], axis=0)),\n", + "}\n", + "for name, h in half.items():\n", + " print(\n", + " f\"{name:22s} half-width (68 %) at x = 0.2, 2.5, 5.0: {np.round(np.interp(at, x_fine, h), 3)}\"\n", + " )\n", + "print(\n", + " \"mean 68 % width including the experimental errors:\",\n", + " np.round(rx.diagnostics.sharpness(draws_data).mean(), 3),\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "9e91d84f", + "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmEAAAGsCAYAAACVa3C8AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvctoD+AAAAAlwSFlzAAAQ6wAAEOsBUJTofAAA2g5JREFUeJzsnXeYVOXZh+/Tps9sZ9nC0kFQsGFBBQFRUUHFEhRbYsWWqLFrbIkaY/mMxt6NxhjFggpqLGBBNBZAEaSXZWH77uz0074/hj3sbKHoAou893VxXcw757xtZvf89nmfItm2bSMQCAQCgUAg2K7IO3oCAoFAIBAIBLsiQoQJBAKBQCAQ7ACECBMIBAKBQCDYAQgRJhAIBAKBQLADECJMIBAIBAKBYAcgRJhAIBAIBALBDkCIMIFAIBAIBIIdgBBhAoFAIBAIBDsAIcIEAoFAIBAIdgBChAkEAsEG5s2bx7Bhw/jss8929FQyiEQiDBs2jOeee25HT0UgEHQi6o6egEAg+PVhmibPP/88b7/9NtXV1ey22278/ve/Z4899si4Ttd1XnzxRWbMmEFFRQW5ubkccMABTJkyhdzc3M2O88477/D4449j2zbnnHMOxx13XJtrLrzwQnr16sU111yz2f6ampr45ptvaGho2OK1bg8Mw+Cbb75h3bp1O3oqAoGgExEiTCAQdCqNjY0cffTRNDQ0cM0119CvXz+WL1/OWWedxauvvkrv3r2BtFAbO3Ys3377LbfddhvDhg1j1apV3HzzzfzjH//g66+/pri4uMNxPv74Y0488UQefPBBNE3jlFNO4fXXX2fcuHHONVOnTuXVV1/lxx9/3ObrFggEgq1FiDCBQNCpXHTRRaxbt465c+cSCoUAOOigg5g8eTKGYTjXffLJJ3zyySf8+c9/5vLLLwdgxIgRlJWVceihh/L0009z4403djjOQw89xHHHHcd5550HwMyZM3nggQccEVZfX88ll1zC/fffT0FBwbZarkAgEPxshE+YQCDoNJYuXcpLL73E5Zdf7giwZmRZxuVyOa91XQegqKgo47pm61cqldrkWMuXL2fAgAHO60GDBrFs2TLn9RVXXME+++zDaaed9rPW8sknn3DiiScyYsQILr30UtauXZvxfmNjI8OGDXP+HXzwwZx22mm88847Gde19DP78ssvmTRpEocccggXXXQRFRUVbcaNxWLcfvvtjB49miOPPJJnnnmmwznOmDGD008/nZEjRzJx4kTuvfde4vH4z1qvQCDY/ghLmEAg6DTef/99bNtm4MCBXHvttXzxxRfIsswBBxzAZZddRvfu3Z1rDz30UAYNGsTjjz/OxIkTyc3NRdd17r77bgKBAKeffvomx8rJySEcDjuvGxoayMnJAeCDDz7gtdde44cffvhZ6/joo49Yvnw5559/PtFolFtvvZWpU6fy1VdfUVpaCoDf7+fRRx917qmvr+eDDz7guOOO45FHHnEsdM1+Zu+88w5Llizhd7/7HYlEgiuvvJJZs2bx/fffI8vpv4d1Xefwww9n0aJF3HHHHfTr149p06axaNGiNnN89tlnOffcc7n55ps577zzaGpq4tNPP+XMM8/klVde+VnrFggE2xlbIBAIOok//vGPNmDn5OTYv/nNb+z33nvPfumll+w+ffrY3bt3t1esWJFxfX19vX3SSSfZXq/XHjx4sJ2Tk2Pvscce9oIFCzY71l//+le7Z8+edmNjo93U1GT379/fvummm+xIJGL37t3bfuihh+xoNGpfffXV9ujRo+0pU6bYVVVVm+zz008/tQF7n332sU3TdNqrqqpsv99vn3baaZud18UXX2wXFxe36fPAAw+0Lcty2mfMmGED9rRp05y2hx56yAbsDz/8MKPPCy+80AbsO++802kbO3asPWrUqDbjx2Kxzc5RIBB0DcRxpEAg6DSSySQAAwcO5OWXX+aII47glFNOYcaMGdTU1GT4eFmWxSWXXML777/PbbfdxsMPP8wDDzxAKpXijDPOoLKycpNjXXrppeyxxx706dOH3r1706tXL6688kpuuOEGSktLufDCC5k0aRKff/451113HZWVlYwdOxbLsja7jtNOO82xTgEUFBQwYcIE3nrrLWzbdtoXLVrEH//4R8aOHcv+++/PsGHDmDZtGhUVFRlWOoDJkycjSZLzevjw4QAsXLjQaZs2bRo9evRgzJgxGfeeddZZbeZYWFjIt99+y5tvvukc7QJ4vd7Nrk8gEHQNxHGkQCDoNLKysgA4/vjjM9oHDBjA4MGD+eijj5y2F154gRdffJHnn3+eM844w2kfMWIE/fv354YbbuDJJ5/scCyfz8fbb79NRUUFtm1TUlLCl19+yRNPPMG3337LqlWrePvtt/nqq6/Yb7/92HPPPenevTszZ85sI3JaU1ZW1m5bOBymqamJUCjEnDlzGD16NKNHj+aCCy6gtLQUTdP45z//yQMPPEAsFsvwi+vRo0ebvVIUherqaqdt7dq1HY7dmjvvvJO1a9dy/PHHEwgEOOiggzj66KM577zz8Pl8m1yfQCDoGghLmEAg6DQGDx4MQDAYbPNeKBQiFos5r+fMmQPQRhD17NmTPn368MUXX2zRmMXFxZSUlJBKpTjnnHO48cYbGThwIMuXLwdwnPe7detGXl5ehvN+RzQ2NrZpa2hoQJZlx9J0//33EwqFePPNNzn55JMZPnw4w4YNy7B2tURV2/+bt6Vlze/3dzh2a3r06MHHH39MeXk5jz/+OKWlpVx77bUccMABmw1qEAgEXQMhwgQCQadxxBFHoGkac+fOzWhPJpMsXLiQ3Xff3WnLzs4GaBMhaJomVVVVzvtbyu23346maVx11VUAjpN+87GgZVk0NTU57Zvi008/zXht2zafffYZ++yzD5qmAWlhVFRU5LxuHmPGjBlbNe+WHHDAASxevLjNUWzr+bSkpKSEU089laeeeoq//vWv/PDDDz87IEEgEGxfhAgTCASdRn5+PldccQXPP/88M2fOBNLC5JprrqG2tpZrr73Wufa0005D0zSuvvpqamtrgXRm+Kuvvpr6+np+97vfbfG4CxYs4J577uGpp55yLE6DBw+mpKSE559/HoB///vfKIrCiBEjNtvfokWLePvtt53Xt99+Oz/++GPG/A8++GB++OEHRyCZpskf//jHNqk5toZLL70URVG46KKLSCQSQNpnrOVcmrnxxhuZN2+e89o0TebPn4/b7aakpORnz0EgEGw/hE+YQCDoVO644w5s2+aYY46he/fuNDQ04Ha7eeGFF5gwYYJz3e677867777LlVdeSWlpKb1792bdunV4vV4effRRzj333C0az7IszjnnHC699FL22Wcfp93tdvPss89yyimn8Mwzz1BZWcljjz1GYWHhZvu86qqreOmll7j44ouJxWIkEgkeeOABTjzxxIxr5s+fz6hRo+jfvz/19fVcdNFFnHbaaXz99ddbsWMbaU5JcfbZZ5OXl0dJSQk5OTk8/fTTvPXWWxnXDh06lHPOOYdly5ZRWlpKRUUFRUVFvPbaa1u0RoFAsOOR7JYOCQKBQNBJxGIxVqxYgcvlom/fvhnRhq1pbGykvLycvLy8jFxiW0I8HmfBggUMGTIEt9vd5n1d11m+fDllZWWbjRyMRCIsWrSI/v37k5WVxfr166mpqaFv374d3ltbW8v69evp2bMngUCAqqoqVq9ezV577YWqqm36bMk333xDYWGhk3usGcuyWLx4MS6Xiz59+mCaJt999x2lpaVt9qexsZE1a9ZQUFAgxJdAsJMhRJhAIBAIBALBDkD4hAkEAoFAIBDsAIQIEwgEAoFAINgBCBEmEAgEAoFAsAMQIkwgEAgEAoFgByBEmEAgEAgEAsEOQIgwgUAgEAgEgh3Ar0qEGYZBeXk5hmHs6KkIBAKBQCAQbJJfVcb89evX06NHD9asWdMm+WFnUldXR25u7jbrf1dC7GXnIfaycxD72HmIvew8fi17ads26xvjXHPDjfzz4f9z2q+//R4m/fa8n9+vZWE0VZOsWIjRVIW7+wBc3fqieIIYiRSpugh14QRBP4w4YLfOWEqn8KsSYdsLkd+28xB72XmIvewcxD52HmIvO49fw16mDIuvF6/m0vN+y7ezZzntx5wwiWMnnfaz+zWTUfSaVaQqlyJpbnwDRqCFumHbkKyPEK8KYxkWKArYVmcspdMQIkwgEAgEAsE2pSGu8/p/Z3HtlN9Rta4cAFXTuPqWO/nNWeciSdJW92lbJkZjJam61ZiNVWj5Zbi7D0DSvBixFKnGKJZh4sryYcRTGA1xbG/X8sISIkwgEAgEAsE2wbJs1tRHue8fj/DI7Tei6ykA8guLuPnBpxl58EHOtbZtUxVJv98t4MoQZjXRFIZpURBwo8gSZqIJvWYlVTW1pJAo7r0/nqxu2KZFojZCXX2EOBL5IS+qIqN6XUgNMbqWHUyIMIFAIBAIBNuAhG7y3doGrrj4AuZMn+q0733gIUy+8X4CBd2I6SY+TQGgKWmyuiEOgFdTCHnSEiWmm6yuj5MyLTTZJpSqQ69bTTKVolLKIeHrRlDJRo0mSTXGsE2LSkOiNmEgazrdVBnbMvF0z0LWzO2/EZtAiDCBQCAQCASdSm00xffrGllUFaW0pMRpP+eSK/jdZdeytklHUyTcysbjQa8mk7VBeHm1je1uRSbLq5KMNSFXrSKZbEDxBAiU9qPA8BOJpZAbmkgYVtri5XGRZSWxLQu3riO7Pbjys7BsCTnZtP02YQsQIkwgEAgEAkGnYJgWq+rjLK+N4tUUhvfM4YA/3UJjxSqOOXESo488BoCBHlcbPzBNkemf7wfIeE+2TXpQix5fA7aFlleKmtMDSdEobkqQMHWMSBLbpYAkgW1TqEp0C7pwZflwBT1IsgxxHVUWPmECgUAgEAh+ZTQlDBZU1PPJZ59y2OgxaBusXIqicM/jz2dc25Ejfut2I9aAXr0CM9aI4g2hFfRC8eVgJnVStWHMZArV7ULzuNAjCVINUWSXihbw4Mr2o7i6tszpWpJQIBAIBALBToVl2ZQ3xHjvu5+4cPJErvvdyXw357Nf1Kdt6qRqVpIsX4CVjOHK74m7dA9kTxaphiiJqkYsw0L1eZBUBSSQZJBdKp5uITz5oS4vwEBYwgQCgUAgEPxM4rrJ0poI7300i7uuuICaqvUA3PCHKUyfPRfN5QLAtGzqYilcikyWV3Put22bupiOJEGuz4Vt25ixevTqldQ0hpE8QQpL+6D6sjHiKVINjTREU1iqSo5HBUnCSupYhknC48b0avh8HiR5o0UtljKJpAxkCVzbd3s2ixBhAoFAIBAItprqSJI5K+uY/uITPHH3bZhmOvIwt3sJl/7tMWR1o9hqiOssr43h1RR20xRcavogrilpsLwuhipLuGwDV3QdekMFcVNmvVaM7c4jYHlxV4dJ1kewPC4qDIgnkkgSZGEhu1Vc+SFWhpM0NSSRFJXCoNsZe01DnOpokjyfC793++7R5hDHkYKdgsWLF3P11Vfv6Glskptuuon58+dv9rqamhrOPffcTh+/trZ2m/QrEAgELdFNi0Xrm3j5yyXcfvl5PPrXmx0Btv/Iw/jLCzMYsue+tDBG4VZlfC4FryajtHhDU2R8mozbaMKq/JFU3RpkT4hAjz0I5hXhtm2M2ib0SAIkGckwcUs2HtNCs0xcOX58hdm4fC4CLpWAW8WtZkobv0sh2E57V6DrzWg7YlsmtqFv/T9zK661fllOkoULF26V+Gjv+i0RMD/3vu1FVVUV06ZN29HT2CTTp0+noqJis9dFIhH+/e9/d/r40Wh0m/QrEAgEzTTEdb4tb2DWV99y93nH8+UH7wBph/qLrryBx158lf0H9KBnrjfDyT7gVtmtW4C++f4MEeZGp5e9ntL4clRLx13YH0/p7mguP6WYlGHhc6toIR9a0AO6SYlpsFthgPzSXNxZfiRZRpIkeuZ6GdQtQHaL406AkiwPgwuD5Pm62mHkLnwcaVsmsaVzMBrXI6luFLd/s/dYegIrFSMRjREtKNlsmQXbMpBUF74BhyDJys+aZ2VlJdOmTeNvf/vbz74+JyeHESNGbJP7BAKBQPDrx7Rs1tTHWVob5bvPZ3LTxb8lEY8BkJ2Ty50PPclBhx4GdGzd0VrkBLNtG6OpBqNmJXYqhubPxdWtN7LmQ29KkArHARtPwJNOO2HZ2LqB6nPhyvHj8m9IO9ECWZKQlbbPZUmS0BQJ6FqJWmEXFmFY1gYB5kLLLtrs5Wa8CTPWiOzyImcVofiyNt29nsSoWY/kcoNlwWZEmG3bvPjii3z++ed0796dKVOmkJuby+233866des4/fTTAXj88cdpbGzkqquuAiAvL48JEyYwduxYdF1v9/r6+no+/fRTJkyYsFXjtLwP0hacJ598ksWLF3PQQQc517bXZ2FhYbvrrKys5IknnqCiooLhw4dz1FFHAbBgwQL+9a9/cfzxx/Pyyy8jyzIXX3wxPXv2bNPHZZddxvnnn8/gwYOdtiuuuIKzzz6bPfbYo8M9XrduHbfddhvnn38+//nPf4jFYlxyySVkZWXxj3/8g9raWk4//XSGDx/u3BMOh3nsscdYvnw5e+65J+eeey6qmv6xqaqq4qGHHqKpqYkTTzyxzXi6rvPUU08xb948evfuzUUXXUQgEOhwfpsbs3n+v//973n++edJJBKcc8457a75tttuY8yYMRxyyCFO21/+8hdGjhzJyJEjNzsHgUAgaCaaNFhcE6WyKe1XNWyfvQmGQiTiMYbsPYy7H3uWopIeW9yflYqTql2FGa5CVj24iwaiBgswdYt4VRgzoaN4tHTUIziO96rfgzvLi6z9eqTLLn0cKalutOxiJEXb5D8rFceM1KB4g2h5PZFV1yavty0Ts3E9kqKheENbNJeHHnqI22+/nSFDhiDLMieccAKKorD//vvj9/sZN24c48aNQ9O0jNelpaWcccYZvPbaax1e3/Iob2vGaXlfJBJh77335qOPPmLIkCG89957PPTQQx322R61tbXstddeLF26lMGDB3PXXXc5YnLdunU8+OCDXHvttfTr149169YxZswYDMNo049t2zz22GPO6/nz5/P000/Tr18/rr76ambOnNnu+I2NjTz99NNcdNFF9OjRg+rqasaOHcvEiRMJBoPk5+dz+OGHs27dOgCSySQHHHAAs2fPZsiQITz//PNMnDgRgEQiwUEHHcTChQvp27cvl19+OUuWLHHGsiyLMWPG8Oabb7Lnnnvyww8/MHLkSMdvoiM2NWbz/M8991xKS0sxTZORI0fS2NjYph+v18v//d//Oa8rKyu5/fbbGTBgwCbHFwgEgpZUNSX5uryBuliKfJ9GNGUQzMnnb48+y+RzpvDMazPoVlRKXSxFXM/8/WbZNvUxnVgq3W5bFnpjJYk186mrqSTuycPdYw+UQAHJ+hiRlVXU1TQRVeS0ADMtjGgCZDCyfCR8bkeYNRNLmdTHdCzbzmiP6yZ1sRSmldluk/l6R/PrkZM/gy05gjTjYYzG9cguL2p2SRvzZ2ssPYFRVw6SjJZbgq3Htmgu8+bN44ILLuCiiy4CYMqUKciyzOGHH87UqVMdqxOApmkZr/v06cPDDz/MCSec0O71P3ecljz88MMUFxc7ouzCCy+kpqamwz7b45FHHmHPPffk2WefBWDChAkMGDCA2267zbnmjTfeIBgMct5559GtWzeWLFnCoEGDMvo5++yzGTt2LPfccw+apvHMM89w8skn4/F4mDZtGgMGDGDUqFHtziGVSvHKK69QWlrKueeeSygU4s4772Ty5MkAfPLJJ8ycOZNTTz2Vl156CVVVee2115AkidNPP52ysjK++uorFixYQFZWFv/5z38AmDhxIr169XLGefXVV2loaGDmzJkoisKUKVMYPnw406dPZ8iQIe3ODdjkmKFQiFQqxcsvv0xpaSkAH374IV999RWHH354Rj9nnnkmt9xyC7W1teTl5fHCCy8watQounfv3uHYAoFA0IxhWiyvjbGyPsYPX8xi6NChVOnZrGmIUxh0s8/+w9ln//SpwfpwgpX1cbK9GgML/I6rTl1MZ3ltFL9LpX+2jFW7CjNSTZPlodxVhkvNxpOQkKKNWCmThKKwsj4JiSb65XoJqDKuLC+W182a2jhGRKdPnt/x+TIsmxV1MaIpgz55fvL9aZ8v27ZZVR+nIa7TK8dL95DHWZdudq0S3ru0CNscv0yA9QAJbH3LxjrvvPM444wzWLRoEaNHj+aYY47Z5PXvvfce7733HjU1NdTV1bFixYptMk4z8+bNY+zYsRlt+fn5W9XnggULMnzMevbsSUlJCQsXLkSWZXr16kUwGATSGZYLCgqoq6tr08+ee+5JWVkZ77zzDscccwwvvvgiU6emi8PefffdGceUrcnJyXEEjMvlIjs7O+M4r7Cw0BlzwYIFHHLIIc4vlFAoxF577cUPP/zAwoULOeigg5z7iouL6du3r/P6u+++c44LbdvGtm1qampYuHDhJkXYpsY86KCDMuYPUFRU1O4eFRYWMnbsWF566SUuueQSnn32Wa6//voOxxUIBIJmYimDb8obWFUd4eMX/8HTD97L3vsP589PvoJblTN8uwBURcalyGiKlOErrcoSmgxSrJZkZD2ymUIJFeELFuOq17GjKVIpHbdLTR81GhZqOIkZS6GpATyFWahuDd20Nvh0yagtnPolQFMkXEqr9g0+YC5FRm011017cm9/hAjrgF8qwCRVwza3UIEB+++/Pz/++CP/+9//eOedd7jmmmv4+uuv2732xRdf5Prrr+eiiy5i6NChlJeXd3jtLxmnJT6fj3g8vlV9Nou0Zrxeb5s+4vE4Xq+XZDKJ3M4e23b7puOzzz7bsagFAgHH96nZf60j2hujdVvzmF6vl+rq6nbn6/F4aGhoaPNeM263m9LS0gzhesQRRzB06NBNzm9TY3Y0/03t0Z///GcOPPBAVq1axfHHH7/JsQUCgaA6kuTH9WFWrV3PQzdcwleffwLAd199wbyP32HMcSfjaZXqId/vwudSMopxAwTlJL30VUiJRlRfAK17f2RfDkosSQ8rjuyS8PjcIMtg2Wi6zoBcH1rvPAJZPue5qyky/fL9WDYZaSYUWaJ3rg/DsvFqmceUvXJ8JEMWvlbtmvLzguS2Fbu0T1hHdIYA21qmT5+OYRgceOCB3HbbbciyzPz58wkEAkQikYxrP/vsM8444wyuueYafvvb32aGAbdz/c8dpyVjxozhpZdeor6+Hkj7RH355Zeb7LM1Bx98MFOnTiUWSx/R/ve//yUajW5WmLTH5MmT+eijj7j33ns5/fTTnT3YlE/Y1nLwwQczffp0amtrAfjhhx+YN28eBxxwgPNeOBwG4PPPP2fVqlXOvYcddhjLli3jqKOO4vTTT+f0009n6NCh+P2bPgLf1JhbyzHHHEN5eTlXX301J510kiPkBAKBoDWGabGsJsp35Y0s+OYrrpx0hCPAVE3j2r/czTEnTsKnKcjtZAbwaYqTesK2DFK15cRXfodLb8KbV4K7ZA8kVxbJ6jCJ2ggel4on4AVZxkrpGPEEitdNVkkOwZxAm+eupsjt5vnSFLmNAIO0QGstwLoiu7wlzDYzHb/NeJMjwJRgN7BN7FbO1LZpOFYuS09m+IAh4bzXuu9NsXr1agYNGuRYtrKysjjggAOQJAnTNDnyyCMpKCjg8ccf57jjjuOkk07i+++/p66ujkQi4fQzePDgNtf/3HFacsoppzBjxgwGDRrEAQccwE8//cTf//73TfbZmrPOOotXXnmFIUOGMHjwYD799FPuuOMOsrI2HWnaHjk5ORx99NG8/PLLPP3000775nzCtoYjjzySo48+mqFDh7Lvvvvy2Wefceutt9KnTx/69OnD8OHDGTJkCHvuuSfLly/POCYcMWIE55xzDoMGDWL48OHU1taSSCR444032g022JIxFy1atFXzV1WV008/nXvvvZePPvroZ++DQCD4ddMQ11lcFaE2luTdF57gobtudYKIikp6cPdjzzFk7323qC8z3kSqYiFGvBE1kIdW0AvZm4XRlCJRU48RT6Fl+dIRjqaFkUwhqwqe/CxUn2uzqZ9+bUh2R2cZOyHl5eX06NGDNWvWZDwQ28O2TBIrv8VKbLT+NOcBk2QV2RPs8MvQGG4kK5SFbRmYiTAgoXhDSFJb1S17Anh67bNFecIqKyuZM2cOOTk5HHzwwSgbzKa1tbV8/vnnhMNhJk2ahKZpLFu2zEl90Lt3bz788EMnTULr6xsaGpgzZ45zVLel47S+D9I+S0uXLmXYsGGUlJRsdu5t9t22+frrr1m3bh177703Pp+PvLw81q9fz7fffsvRRx/tXPvWW29x4IEHUlBQQHV1dZu53Hvvvbz66qt88cUXGfcMHjw4wz+rmXA4zPvvv89JJ53ktE2dOpWxY8c6QvCzzz6jW7duGVGE8+bNY8WKFeyxxx7069cvYy1ffPEFkUiEAw88kM8//5y99tqLoqKNKU9Wr17NvHnzyM/PZ7/99kNVVaLRKG+//TaTJk1qd486GrO9+X/44Yf069ePnj17snr1ar744ouMfl9++WWuvvpqVq5cucv9cvu5NAczCH45Yi87j22xl4ZpsaYhztKaGNFwA/fdcBmf/ne68/4hYw7n1vsfw+XPwudSMvyuLNsmkjTxamkfMds0SNWvJVG+gKjsI1TYE19eCZYpoTdEMeIp4rKMrJuopoUkSyguBS3oJeXRUFS1jeUqppvYto2/VSHuhG5iWDYBd2Z7yrBIGBZBt5Lx+043LeK6hWlZeIwYB+xW1pnb+IvYZUUYpIUY1tZHStTW1ZKXu4U/DLL8sxO17gr8kl8s++23H+eddx7nn39+J89q56S9vZw4cSJDhgzJiEAVbBohHDoPsZedR2fvZWNcZ0l1hJpYipAq8ZvDD2LtymVA2vf0oiuv55xL/8jacJKKcILikIce2RtdGtaFE6xpiJPnd9HLa5BctxC9tpymYE/WakVkBUP0dEmYTelyQxEkVoSTaLZFL9nGE/Tg6ZZFAomlNVFkWWJAvh/PBiGW0E0W10SxLJt++X5HcOmmxeLqKEnDok+ez4mUtGybJdVRmpIGvXJ9TqQkwLLaKLXRFNkejR4eo0uJsC7nE2ZZFitWrNikf1JnIckKkqpt/T9lK64VAqzT+eijjzj88MOprq7mtNNO29HT6ZLMnTuXY489llmzZjmpQwQCgcC0bJZVR5m1vIamlElR0EPA5+Hwk9LpibJy83j0X69z3h+uajcQKAPLRK9fS2zJ5xiRWjx99sNVPBhwk6htItUYR3a7ULxpQWQlU9imha8oB39JLqp76/2nf210KZ+wp59+muuuuw5N07Asi0mTJnHPPfd0eLQl2DXp0aMH5513HqNGjdqso/uuSkFBAZMnT+Yf//iHyA0mEAgAaEoYLKpsorwhTkm217E6AVx86R+Q9QSTTj+L7sUbXU2KQh6yPBo+18ZrbdsmT46hpFahNKxGzSvBVTwISfMRrI/Sw9TxBty4fG4ALN3AbxkM7J6FN9uLb0M7pGtK9t+QW6zlfDyaQr98f5vjSE2R6Zvna3McKUvpSMmkaRFwZWqGsmwvBX43pmXBJnxydwRdRoS98MILXHjhhbzyyisce+yxWJbFww8/TFNTE9nZ2Tt6eoIuRP/+/enfv/+OnkaXpqSkhFNOOWVHT0MgEHQBLMumIhxncXUUkJAa1vLqGx9y+nkbreQuVeEPV7fNJajKEiHPRqlgGSmMujWk6tfi1ZO4++6Hmt0dM2GQXN+A3hjDp6lomtLG8T7QgeN9a5+vZjqKbvR00O5SZVwdRFBqikxjfMvTRm0vuoQIsyyL66+/nvPOO49jjz0WSJ9JX3LJJTt4ZgKBQCAQ7LzEUgZLa6KsDSfI9bqY+c7r3HrV74nHohSV9uCwozadW7EZ27YxY/Xo1Ssx42EUTxBXr31A8pCsj2NE48guDU9BiFRTgmRdFNWr4c7xowW9yKo40WqPLuETtmjRItasWcPxxx9PNBpl2bJlpFKpHT0tgUAgEAh2SmzbprIpyf/WNLC2MYFXMrnvpqu49uJziMeiALz0zONEU22P5yzbdiITIZ05IFW1lET5D8QSSdTuA3CX7YmZUohXNmDGk+iahq0o2JaNLIMr5MVXnIMV8GK2Y/1KGla7JYRShkXKaNuumxbJDtpb16yEtO9brJ32rkaXsISVl5cDMGvWLE455RSCwSDr1q3joosu4p577unQOTAcDjvJMgGn8LJAIBAIBLsqScNkeW2M1fVxfJrC8uXLufvK81m16AfnmpNO/x0n/eFP/FQVpSzHmxFNuLYxQXUkSfegm25yFL1mJVYqRrWUQ62rG/mGj8KaKEYiieJyUWdYrKmLE8Cid5YXd24QLeihMWmysiqCz6XQN8/vJHONJA2W18bQFIl++X6nDFJcN1lakxaI/fL9ThJW3bRYWhNFN2365PkcXzBzQ+3IWMqkV+7GSEmAlfUxGuNGm7XpZtcSZl1ChDU73v/3v/9l6dKlZGdn8+233zJixAj69u3LxRdf3O599913H7feemub9vr6+m2aHbyl8BP8MsRedh5iLzsHsY+dh9jLzmNL9zKcNFhWE0U3LbK9Lj55931uu/YKYpEmALw+H9fdeidHjD+e1Q1x7GSMpJokYbUQKtEEZiRGvKmRJqsJWXWhZJUhm270miaaausJZXlQPC4s0yAVTWLFEkh+F5LfiyWnSEZTJBIGVjyOaSgk3AbKBoNYImliJ+JYkky8ycDc8EZCN7Hj6eTjiSYdaYMIS5k2ViyObVskmnTUVLrdtMGMxbB0k0REJ2GkJY1tgxGNYyeNjLXpSRNSUaciybZia1KJdIk8YUuWLGHAgAE89dRTnH322U77hAkTUFWV119/vd372rOE7b///lucJ+znInLfdB6b28uPPvqIWCzG+PHjt+Osuib33nsvp556KsXFxe2+37yXFRUVvPTSS/zxj3/s1PG3Vb9dDfHz3XmIvew8NreXhmmxsi7Gj5VNZHs0/JrEA3fewvOP/cO5pu/AQdzz2HP06T8QSFue4rpJlkdrUXLIItZQSWPlavwkcWcX4sorw7IUYrVN1IcT+LBxuzRUnwtLN7AkmYRHIxDy4WsRsWjZNo1xA7cqt4mubEwYqLLUJuFqOJF2ng95MtNXRJIGhmWT5VEznPtjKZOkYZHlVTPKKbW3tsa4jqZHOHC3nlu26duBLuET1pzxu3Xh4pqaGnJycjq8LxQKUVpa6vxrmal8S7AtC9vcxv9+RjLYrsgHH3zA22+/ndH20UcftWnrbD755BPefffdbTrGzsKDDz5IRUXFZq+rqKjgwQcf7PTxt1W/AoHglxFO6Mxd28jS2iglWV6yfS6efOCeDAE2/sRTeOHtDx0BBuDVFHJ9LkekWKkYyXULoXoJOV4Vf4/d0fL7okdN4lWNyLZEt4IQ/pwAZlIn2RhD9XsIFGXTrSCUIcAgnTYix5eZ3gJAkiSyvVobAQZp8dVagEE6lUW2V2sTXelzKeT4tDb1LFuvzRmbrlU5pEscR0qSxB133MGll15KUVERu+22G6+99hrffPMNDzzwwDYZ07YsIqtr0CNJZEVG7iBENuMew8LUDWKRJrSwudkyMLZpIakywV4Fmy0C3tWZOXMmDQ0NGRYpVVXRNJFsTyAQCHYELVNPSEgUBT3Oc+n08y5i+mv/Yf26tVz3l7uZeOqZHT6zbMvEaKrGqFmNZaZQs4tRc0qxdIlkdRjLsFDdLlBkbMPETKZwZftw5wZQ3G2FkWDL6RIiDGDy5Mn4fD4ee+wxamtr6d+/P1988QX77rtlRUO3Ghts00ZSZMyUAbKE5vds+h43SEkZu9HCShloQe8mv3y2ZWMmUrAFB77Lli3j3XffZdy4cUyfPh2/38+kSZOcZKTN7x999NHMmDGDsrIyxo8fz+rVq3nnnXfQdZ2jjjrKyZ/1/vvvY1kWwWCQ2bNns9tuu2XUXQQ2e292djaffvopu+++O7NmzSKRSHDjjTdSUlLChRdeiGEY6Lq+xf3l5OTwySefUFZWxsknn+wEXHz55Ze89dZbSJJEWVkZEydOJD8/f/ObBtTV1TFt2jRqamoYPXq0831pvYbx48cze/ZsDjjgAFasWMG8efO47LLLCAQCTJ8+ne+//56+ffsyceJEFEXBsixuuukmfv/73/Puu+/S1NTUoW9iy/W//vrrTJgwgRkzZmDbNmeeeSYAL730EpFIhFNOOSWj5mYikeC1116jvLyc/fbbj9GjRzvvNTY28vLLL2MYRrvHsZZl8dZbb7Fo0SJ22203Dj744C3as47GbJ7/CSecwLRp07Btm8mTJ5Obm9umj/vuu4/jjjsuo0bnQw89xKhRo9h99923aB4CgeDnk3Zij1DeECfkcRFsZVXyB0Pc9dhzyMBuewx12i3bxrRsxxneTEZIVa3AjNZhuQL4SgYjaSFS4XTaCUlVsN0atgRWPAXYuLL9uIJejA6ebbppochSG+tUR+2GZSNBG6uVadnYkFGzsr01bK7dtm0Ma4d7XrVLlzLPHH/88cyYMYOvvvqKF198cdsJsBa4gl5UnxsrZWLEU0iKvMl/qs+NGvBgmzZGNAmy1PH1G97bElasWMHNN9/M8ccfz+rVq3nqqacYNWoUxobsvs3vn3jiiaxZswZN0/jmm2/Ya6+9+PLLL/nxxx/Zb7/9+Oijj4D0UeFFF13EVVddRVVVFZdccglXXXWVM97m7r344ou55ppriEajaJqGoigoioLH48HtTmc7bnlUuCX93XDDDdTV1XHDDTdw7bXXOnNp7tflcvHee++x9957U19fv9k9W7p0KXvuuSczZsygqqqKY489ln/961/trkFRFP75z38yceJE/vnPf2LbNpIk8dvf/pbLL7+c2tpa7rzzTsaNG4dt21iWxe23387hhx/O//73P8fid+edd7Jw4cJ257N69WpuueUWTjjhBNasWcPzzz/P0UcfzZFHHsnChQuZM2cOBx10EMlkEkiLoeHDh/Poo49SXV3NmWeeyY033ghAPB5n+PDhvPzyyyxfvpyjjjqKuro6ZyzLshg3bhx33HEHDQ0N3HHHHVtUnmhTY7ac/+rVq3nzzTcZOXIkVjtH6suWLePhhx92XpeXl3PllVdutUuAQCDYeqojSb5e00B5Q4Jw3GT+kpVcfNYkVi1P1340LZtlNVHMvF6U9h/s3GfbNqvq4iysilAfTaDXryVZ/gN2IkyVq5hlai+qIgqR1TUkq8MoHjc1BiysbKKiNoLiVvEWZuPO8lMbN/ixsom1jYmMuTXEdRZWRVhVF6ely3kkabCoKpKeVwtBFNdNFldHNkQ/bvxd0xwRubg6kpGConlti6oiRJIb02u0XFtDq6SsaxsT/FjZRG2s66W+6jKWsB2JFkhbwMwNDoHNrztCdqtobg96JIEejqOFNm0R21Lq6+v5/PPPGThwIIZhsMcee/Cf//yHyZMnA+lAhGnTpjlBB0cffTQXXXQRf/nLXwAYNGgQV199NV9//XV6nrLMrFmz0DSNCy64gCFDhnD55ZdTXFzMn/70p03eGwgEmDlzprOuWbNm0dDQ4DywW7O5/goKCvjggw8AOOqoozjjjDP429/+BsCwYcMYNmyY09cZZ5zBc889x2WXXbbJ/br++us544wzuOOOOwD4zW9+w/HHH+/sV+s1AIwaNYonnngCgG+//ZapU6eyYsUK8vPzSSQS9O/fnzfffNOxPF1//fVMmjTJuf/ee+9l0KBBDBo0qN05RaNRpk+fTnFxMWvXrqW0tJRXX32VE088EYABAwYwe/ZsRo8ezdNPP40kScycORNZljnvvPMYOnQoU6ZMYdq0aYRCIT744AMkSeKkk05i+PDhzjgvvPAC1dXVfP311yiKQiqVom/fvsydO3eTe7apMZvn/+abb1JcXIyu6xQVFbFgwQKGDBmS0c/ZZ5/NMcccw1133YWqqjz33HOMGzeuXauZQCDoHHTTYnlNlFUNcXyaSo7XxcyPP+aRGy+lqb6G6oq1PD/tv8iam7iezp+VNCwCG6oEWTZEdYNwUxPhcDUuwsjeEK783iTroa4qjM8tEfR7sGwwogmisRSNCZOc3BCe/BDSBqtUwjBpShp4WiVhTRoWkaSBLKXHa46ITBoWsZSJbaeFVLPVSzctoikTVZbQTZvmZPi6mc7zZVg2umk56SpMy97k2iJJo00+sWgqPVeXIkMX86ARImwDWyvElA2Og50pxHr27MnAgWmnSVVVOfzww/nuu+8cUdG7d++MqM/vvvsuQxSNHz+eq666CnNDHpQxY8Y4Fpx+/frRq1cvvv/+e4qLizd77yGHHLJV69lcfwceeKDzXp8+faiqqsq4/6OPPuKbb74hHA6zbt06Fi9evNkxZ8+ejdfr5ZZbbnGsVxUVFY7FqL01jBw5MmPO++23n3P06fF4GDt2LN9++60jwlpeD2lRNnjwYDqiZ8+eTvRiSUkJiqJkrL2srMxZ+3fffce4ceOcY9kBAwbQu3dv5s+fz3fffccRRxzhzP/AAw/MKN81e/ZsPB4Pf/7zn7FtG9u2cblczJ8/f5Pz29SYoVCIsrIyZ/6aplFaWtrmswLYd999KSws5N1332X8+PE899xz3HXXXR2OKxAIfhnRlMFPqxtoShrk+13I2DzxwD08dt9fHWt1U1Mjlesq6NmnLz1zvKRMKyN3lmybFFNPMLmWHDdoeb1Qg93R4wZ5ySY8fo28kAdVVdAtCzOeojgvQF6pi2y/xxFgAIUBNy5FJtDKnzrP70KS0o7xLY8Xs70affJ8uJTM0kJBt0qfXB+SRIYDv8+l0DPHi22TcdTqUuV216bIEj1zfMR1k1zfxnQbAD2yvRuc9wEz/jM/gW2DEGEt2NFCrHW2kOYjs2Za5z6TJCnjntbHRpvqb3P3bm2etc31p6qZX7WW11555ZW89dZbjB8/nuzsbFRV3aKcOLZt4/V6M/q+7bbbnLxz7a2hZVvrOTfPe1N7fsUVV2xyTu0Vm2/d1jzm5sZv7/Nr+X+Px5Ox9kmTJm1SgG3JmK0/p/bm0czvfvc7nn32WbKzs6mtreWYY47Z5NgCgWDrMUyLtY0JfqqMoPmz6B50U1dTzfWXnsecT2c6140+8hhuu+8hQtnpjAJZ3kyTjxkPk6pejjsexpudjSu/N7bkJlEbw0ylCPjcBFUF27QwogkUj4q3MAvV2369R02R6RZwt2lXZanddkWWKGinXZIk8vyuNu1AGzHVTOu1NRN0q2184yAt6HwuJV07smvlau1aPmFdAS3gQfFomAkdPZLY7PWKR0MLeLB0Ez0c7/CBtSWsWrWKH3/8EQBd1/nvf//LPvvs0+H1++67L9OmTXNev/nmm+y9997OQ//DDz90yj8tXryYVatWOcdKm7u3NT6fz/Fl+jlz2RRvvvkmTz31FPfeey9/+tOfnGCEzXHwwQfTvXt3brzxRuffkUceSVZW1hbdv88++/DVV19RWVkJQCwW44MPPsg4Gm3NpnzCtpZ9992X6dOnO9bCH3/8kVWrVjF06FD23Xdf3nvvPUfMfv755zQ2Njr3HnzwwcRiMa677jpn7SeffDK9evX62WNuLaeffjrvvfce9957L5MmTcLlav8XpkAg+Hk0xNOpJxZWNuHTFPL8Lr7+4jN+c8QhjgBTVZU/3nQ7//fUi44Aa4lt6qRqVqZ9v/QErm59cRXuhh6DeGUjlmmh+jzpILV4Ciul48ry4u2WheZzi8jHbcwubwmzLRtoZbXxurAtCyOWxLasNlGTzfnFmpE1BdXnQo8ksBssJ2rS3spojLy8PH7zm98wZswY5syZQ05ODieddFKH1992222MHTuW1atX43a7eeONN3jzzTed9xVF4ZBDDuHAAw/ktdde4w9/+IPjOL25e1szbNgw7rvvPrKzs+nTpw8XXnjhVs1lU4wYMYILLriAo446innz5rF06dItivT729/+xmGHHcbXX3/NgAEDmDdvHvn5+bz88stbNO5ee+3FqaeeykEHHcT48eP56KOPGDp0KOPHj3dESms25xO2Nfz2t7/liSee4JBDDmG//fbjlVde4dprr6WkpISzzjrLiTYcOnQoM2fOJBQKOfeefvrpTJ06lX322YcxY8awbt065s+fz8cff/yzx1yxYsVWzT8/P58jjzySqVOn8sUXX/ysPRAIBG3RTYvV9XGW10ZRFZmikId4OM4Tf7+bh++5w/njrHtxKX975Bn2HLa/c2/LEw8j1oBetRwrGUXyZuHq1hvbchGvbCTZGE8bHdxqOu1ESkf1uNGyfahurUODQusTmm3RDmzTMboSu64Ik0B2qVjtFC8F0hXfXXbawtUUz8gjZiUNzKTe5h7V48LUDfRwHNmdzuoru1S2NDdcSUkJ06ZN491332X//ffnxBNPdI6H+vXrxyWXXJJx/d57783333/Pu+++i2EY3HzzzfTu3dt5/7jjjuOUU07hiy++4Omnn+aII47YonuPPPLINseJRxxxBP/5z3/45ptvnOjIMWPGEI/Ht7q/rKwsbrnlFuf1448/ztSpU1m/fj0TJkzA6/U6dUBbjtGaZh+36dOnU15ezrHHHsuoUaM6XMM555zDHnvskdH25JNP8uGHH/L9999zxx13cMwxxyBJEoqi8Oc//7nNceSmfMJ69uzZJpjgtttuIxgMOq9/97vfOVYnt9vN7NmzmTZtGmvXrmXq1KkcdNBBQPoYdPbs2bz22msYhsENN9zA1KlTnfQWsizz5ptv8vHHHzN//nwOOugg7r77bgoLC7EsiyuvvLLdOW5qzPbmf8kll9CvXz8g/f1s3e/YsWOZP39+ht+bQCD4+dTFUiypjlDZlKQpaaJJJh+99iYLvv2Kt6b+x/m9ts+Iw/jbPx6nYINPq2nZrKyPoZs2PYIKangtRmMlkqyy3tuTuByge72JOxVG1hRcIR/ldTEaq5ooyw2QXxhC87uRZJnKpiTV0SRFQU/GUWFtNMW6pgQFfjeFwY1Hi41xnfLGBFleldKsjb8zoykjXb/SpVCWvdFdJ66brKqPoykSvXJ8GU76K+piAPTO9W1Mo9FibT1zvI6Tvm3brG6IE0uZlOV48bd4Tpc3xmmMG5RmeTKOL40ulkC9S5Qt6izKy8vp0aPHFpctsi1ri3J4tWarSnFIbFGi1g8++IArr7xys9FtW8q1116LYRjcc889ndLftkKUNek8dsReHnPMMRx88MFcf/3123XcbYn4TnYeYi+3HN20WFEbY1V9DLeqYNk2P1bU88DlZ/LTt3Myrp045WqOOvNCBhWGCHnSwiOmmyyqbCIeDdPbqiRLTiD7c5Fyy1iwLkF9XZS+ITfdc/wgS5jJFAvWNhJWVXbrmUuPvIDT/5KaKGsb4vTJ81OWs1FUNVvnSrK99M/f6DZSEU6wpDpKvt/F4MKAI7aqIkmWVEcJulUGFQYcUVUXS7G4OopLkdmtMIBvg6gKJwx+qo4AMLAg0GptEVKmxYACv+MrppsWCysjNCUN+hf4HV8027b5sTJCTTRF/wI/xaH0aVZjXIdEmBG7bzRW7Gh2XUsYWyaO2r1vQx4wgWBX5bvvvuPRRx9l9uzZPPPMMzt6OgLBTk1dLMX3FWEShkW+34WmyOiGycIPXmsjwAB6lXSnV66foHujz60Hg8JkOYlYLaGQF1fBQCR3NnpjnAJTJyfHS37IC3Y6x6WsKfTtV0hSkcn3ZzrMFwXd+LR0OaCW5AfSZYCyPK0iIn0uKAC/pmQc/+VsiIh0q3JGAtUsj0avHC+qIjsCDCDoTlvMmv/fjE9TKMvxYpgWWS1KGmmKTGm2h6RhkdPC2iVJEqVZHnJ8WnpuLVC72LN7lxZhXYn2jht/Ce0dxwkEnYWiKPTp04dPPvmEbt267ejpCAQ7Jbppsao+zoraKG5VoWiDxaautoYbfn8+VevXtXtfY+Ua5zjQtm3MaB2JtQvIsm3yuhei5ZZhxG2SFQ3IqkxBTtrKZSYNTMvEFfKihbz4OwicCrjVdus6+jQFX1bbe9yq7FibWqJt8GdrjSJLdG+nXZKkjGPOluT/jAjK9qIoZVE7UtAevXr14txzz+20/lqWvxEIOpuhQ4f+rIhKgUCQpj6WYnF1hIa44Vi/AL79cjZXX3Q21R0IMIAePdPHaVYqTrJyGXrNctSsIlzd+mCrQZJ1UZL1MZBBcXnTdY+TKVSvCy07iOruYhlLd2GECBMIBAKBYDuxMfIxhkuR6R5Mp4GwLItnHvo/Hrr7dic6u6CwiNz8An5aMN+5f7+DRjD+xFPQw1UkyxdgpaK4igahZpdixk30ukaQFdz5AYxIgmR9BC3gwZ0XdBzvd0UMyyaqm3i6liFMiDCBQCAQCLYHzdavdeEkiQ1+TJKkUVtTzY1/uIDZMz90rj141Fhuf/BxAsEQb7z8Igt/XEBR7wGcfspvMKsWo1cvB38e1QX7YpkeCmqiKKaN6nFhyxJr62PEEzqluUF8hUEULf24XxdOEEmZlIQ8GRnqqyNJGuI6hUGP4xAPaX+12miKPL8r4+gvnDCobEqQ7dUykrDGUiZrwwkCLiXjKDKhp9vdqkxJyOP4jummRXlDAlmG0iyvEylpWjbljXEsC0qzPY6l0LZt1oYTJA2LkpAHTwufsvbWppsWy2rT9Sp3LwySu/nUldsVIcIEAoFAINiGNFu/VtTG0BQZryqzpiGBYdms+f5/XH/puVRXrgdAVhROuOCPXHnVNXg3pFw4/MTT6L3/OnTTIFK+AE+qAXfJHiR8haxbFSYVa8Cf7ycn5AXTIhaJUxPXSblcFGX7HAFmWjbV0RT1MZ3ghizyzdREU6wLJ/FqSoYIa4wbrGqIo8pyKxGmO2toKcLCCZ2KxgQ5Po1uAbcjqiIpk/XhJD6XQoHfjVtNt0dTJpWRJIoskedzOb5ocd2kKpLCtGxyfBrZ3rQIS5k21ZEUsZRJlkdzRFjrtSmyREM8hSRJDC4M0DPHT9CjUltb27kf7i9EiDCBQCAQCLYR9bEUC9Y3EU2Z5PlcuFSZhC7TK8fmjacf4Nm/3+UEUXXrXswf//YIe+8/PMPC4yVJTqoKO9WEN+TGU3YQtu3GrmykGxZKnp+g350uuWeZBLJ89MoJYiC1qa9YFHST7dEy2gEKg258rrYRkXl+DVn2k+PNdIDP8Wn0zfcRauVflu3V6J3rw+fKrB2Z5VEpy/Gma0cqG9sDbpXSbA+yJLWpHVmS5cGy7YwgAZciURzykDKtjCjN5rV5VYWUmS4i3ifPT/egG387QQZdha47M4GgC/H111+TSCQ45JBDOr3v+vp63nrrLc4888xO77sz2Zp5bsv9+jnzEQi2Ny0jH11K5tGcR1PomeujsWqdI8BGjDmCP//9UXJyN+ZVsy0To3E9Zl05uXISX1lvFH939EgSvSkMhkl3j4rsUbHjKWSPhis7gOpxUdTBvNqr3wjpKMP2Ig1DHo2Qp60jv9+lZiRHbbm2lrnFmtEUmR7ZbdtVWcpI8NqMLEntRlx2FEGZMixMyybXp9Ez10txq6PKrsouLcJMy8b6GblqddNCN7cs/YMsSRl/DWyOZDLJp59+ypo1ayguLmbfffclf0NG5NraWl555RUANE2jZ8+ejBo1qt2iy12F7fEw3h68/fbb1NTUcMghh2Ss6X//+x/JZPIXrW/t2rVcffXVXV5MbM08W+7X9prPr+W7Jtj5afb9qo8ZFAQ25P1KpZj2yr8oX72SHj17M+HkyVx961/5cf53jDvuRM684FLkFk7zZqKJVPUKrHgjsjuIK9QDScshURMFbLSgF9u0SNZGsG07Xesx6NnlHO9106I+lkKSJXrn+SjN3phRf2eg6z69tzGmZfNteQOR5NaXVG8Mh8lq3DJhFXAr7FOavUVCbObMmUyePJm8vDyGDh1KfX09P/74I5dddhmXXXYZa9as4cILL+SCCy5wsuG7XC4+//xzAoHAZvvfEaxfv55oNLqjp9GptFzTm2++SUNDg3jwdwF+jd81wc6FscH61Rz5WJyVtuToqRQXnHo838z53Ll2+uuv8Mi/XueFtz/K+EPatgz0hvUYdWtAknEV9AFPHrHqGqxoBMWjIakKlm5gpXQ8BQFc2QGUdqxSv2Z006I+ni4fWJrjpUeWt0sfO3bEzjfjTsKybSJJE59LQZUlqiPpaJXCgBuXuvEvibpoiqhuku93baxXlVLBtmlI6uR6XRnn1ZGkQV08RbZbw+dWiSRNLNtG2UyCuHXr1nHcccdxww03cPXVVzvt8Xi8TVHmRx991Hmvd+/evPHGG5x++umbXXMikeDDDz/EsiwOPfRQ3njjDSZMmEBOTg5r167liy++4LDDDuPTTz8lNzeXQw45hMbGRj755BN0XWfkyJHk5+eTTCZ57rnnOO+885AkiR9//JHZs2c7ec6+//57qqurGTNmDN27dyeRSADw5ZdfYts2hYWFzJkzh7KyMnbbbbeMOVZWVjJz5ky6d+/O7rvvzvTp0zu0vCxYsIBPP/0USZIoKytj1KhRTq3H5rEKCgr48ssv6d27N8OHD6empob333+fvLw8jjzySKev5uvz8/P53//+x8CBA9lnn33aHbd5TatXr+bbb78lHo/z6KOP0q1bN0444QRmzZpFVlYWe+21F5C2YM6YMSPjM6qqqmLmzJkUFhaSk5PTZoxmi2hNTQ0HHXQQZWVlm/18f866gXY/4209z2bi8ThTp07dou/v5ubT8rsGMGfOHJYsWcLQoUPZc889M+b82WefUVtby2GHHeaU1WneO5fLxfvvv8/w4cPp1asX1dXVfP7558iyzKhRo5xC6q+99hr77bcfa9euZeXKlRx88MH06NHDGee9995jxYoVaJrGoEGDnBqdLe9dv349ixcvZv/996d///4Z66muruaLL75AURSOOOIINE1j3rx5rF+/PuMzXLJkCT/88AMTJ07coj0UbBsa4zqLqyOUN8SxgYIWWehffOrRDAEG8L/Zn/LWK//imN+cQUV9HI8mk6ck09avRBjLnUWNuxg5KpMbDmOZNq6gG9OwqKgKIysKpcVZuP0eJFnCtm3WNyUxLZvCoDsjQ31VJElCtygMunG3eL7VRlNEUyb5AVdG5vrGuE5DQifX5yLY4vnWlDSoi6XI9mQmQo3pJjWRFH63kpGhPmlYVDYl8WiyU1II0gKqsintjN+cogPSxpH1TUkAugc3OvW3XFu+30UkZWJaFsVZXsqyvQQ9O6+U2Xln3kmoGz7k6miKcMLA71Ip3PCls22b6liKmkgKt6o45+KqLFEd11ndkEDNl8lpGTGSNFhZl6AsG0LtZOvtiOeff57S0lKuuuqqjHav18vRRx/d7j0ejwefz9dhgeuWJBIJRowYgWEYDBgwgJtvvpmlS5eyzz77kJOTw8KFC7n00kspLCxkyJAhjB8/nsWLF3PYYYcxcOBAPB4PU6ZMYcaMGey7777ccsstDB8+nCFDhvDQQw/xyCOPMGrUKPr168f999/PwIEDGTNmTMax1Ouvv867776LLMvsvvvuvPvuu1x00UXceuutAPzwww+MHj2a/fbbD8uyqK2tZc2aNR2KsOrqaubOnYtt2zz77LNcffXVfPnll/h8Pl5//XXefPNN3G43u+++O2+++SaXXnopb731FnvttReffvopkyZN4m9/+xsAr7/+OtOnT8cwDPbcc0/ee+89rr/++nYLYTev6YILLqCyspJkMsncuXPp2bMnAP/85z/p16+fI8LWrFnDtdde6wiNH3/8kVGjRrHvvvtimib19fUZ/a9bt44jjjiCUChEz549+f3vf8/zzz/PuHHjqKqq4rXXXuOCCy7IKA/SzNaue1Of8S+Z55bS2NiYsTebYnPzafldu/LKK5k6dSqHHnoo999/P5MmTeLqq6+mvLycI488Eq/XS79+/fjLX/7C22+/TVlZGa+//jozZszAMAyGDx/O4MGD+eijjzjllFM4+OCDSaVSXH755cyaNYvS0lLuuOMOIP1zWFBQwAUXXMA777zjWEVXrFjB3LlzSaVS3H777YwdO5bHH38cgDvuuANFUfD7/eTn53P++efzwQcfMHz4cADef/99Tj31VA444AAUReHvf/8777//PgCnnXYaFRUVuFzp3zu33347xcXFQoTtIEzLZk19nKW1URQ57X6yrDaObaezts+e9SGP3HNHu/euWbWChrjOytomfKl63GotLlVF69aPBsPPiuU1KEmDQK88VEXBTBqEEymqbAnNpdFN0/BseIbFDYt1G1I3+FxKRn3FdeEE4YSBW5UzMu2va0pQE0mhyFJGJvyqSJLVDQn65ZMhwupiKZbWxCjLziyKXR/TWV4bJT/gIterOb+bGuI6q+pjhDwqOV7NEYZNSYM1DXHcqkyWV3MEYDRlsrYx/TwLulUnSjNuWFQ0xqmL6fTO89Enz0+vXF+b4IKdkV1ehEFaVBUE3PhcakZoriRJG0JplTa1spq/4NmtHBazPRpl2Z4OSyl0xPz589lnn302fnkbGvj3v/8NpP2/zjnnHOfaRx99FMMw+Oijj2hsbOxQpLXk6aefBuB///sfqqry9ttvM2HChIxrqqur+fDDDxk8eDAAJ598MhMmTODhhx8G4Oabb+aKK65g1qxZjBw5kpkzZzJkyBA++eQTjjvuOGbNmkW/fv2YNWsW559/frvzME2Tr7/+GlVVee+995gyZYojwm666SbOOussp+j4ZZdd5uxBe4waNYpRo0Y5r4877jief/55pkyZ4uxb81h///vfueaaa1iyZAk9evRg3rx5jBw50hEjkLZY/fTTTwQCAb799ltGjBjBWWedRUFBQbvjDxkyhKOOOoqGhgb+8Y9/dDjP1tx0002cfvrp3HfffQBcfPHFrFmzxnn/hhtu4JBDDuGRRx4B4MMPP+TCCy9k8eLFLF++nAsvvJBzzz23Q1/ArVn3DTfc0OFn/EvmuS3Y3Hxa8uqrr/LWW28xZMgQAL744gsArrvuOvbdd1+ef/55IC0kdV137ovFYsyaNYvi4mJM06Rfv3488sgjnHjiic79d9xxh7NfZWVlvPbaawDcfffdXHnllcyZk6711/w9BGhqamLAgAEsWbLEsXjtv//+PPjggwBcddVVPPvsswwfPhzDMDjnnHO47777OOuss4C0lQ5gzz33pKysjLfffpsTTjiBSCTC1KlT+eqrr37R3gp+Ho1xnR8rm2iM6+T501YmVZIoy7bJcsk8+NfbeOof92F34Hvco2dvfFaU3NhqPFYcLZiNlt8bI26jNMXI97pQXSpSPIVBEi3oI7c4h1Qi7UbTMprQo8oUBNzopkWgxdHk9ni+ZXlUSrK9hNxqxh+HIY9K95AH/4YTp2YCLtWx1nlaWOZ8LsWxmLVcm25YaIrMfmXZDC4Mkud3tftH6M6IEGGkv4ztRWFAOmy3vUiMPL+LvHZqWbWsV7WlzvuQFicez8Y5NFtXqqqqeP/99zNE2Ny5c1FVlQMPPJB//OMfFBcXb7b/r776imOPPdZ5cB9zzDG43Znr6t27tyPAIH2c8+KLLzqvJ0+ezF133eUcZ3744YecdtppRCIRzjrrLF577TXGjRvH+vXr2Xfffdudx+jRo505DB48mMrKyow5trQEnnjiiZsUYQCLFi3iu+++IxwOoygKCxYscN5rGbQwYMAABgwY4BwXDRgwgHA4TCwWw+fzATBu3DjHt26fffahpKSE+fPnc9hhh21yDlvLnDlz+OMf/+i8njRpElOnTnVef/zxx0ycOJEnn3wyXRfONFm6dCmNjY0UFhZywQUXZDjwtmZr1r2pz/iXzHNTLFmyhA8/TCelDIfDRKNR54gd4JRTTiE7O3ur960lRxxxBDfeeCPnn38+I0aMcCxMn3zyCc8995xzXVFRZgzZ2LFjnZ+LlStXsnr1ampqanjiiSewbZt4PM7//vc/5/qTTz45Yz7XX389pmmiKAq2bTN79myWLl1KPB4nJyeHH3/80RFhhx9+uHPv4MGDef3114G0Ba2qqirDOnjAAQc4/z/77LN59tlnOeGEE3jllVfYbbfdGDRoULv7INg2GKbF6oY4y2piqIpEUYvko1lejXhdJVeffy7fffWFc092bh4NdRtzVA0bfghHHnoAUtUi+gY0lLwBSEqIZF0c2zTx+T30D3jRm+JYhokc9OItDCHJMr18beckS1K70Yfb6vnWkoBbpX87/lheTaF/vr9Nu0uV6ZPXtl2VJXrlphdn2TYNcZ2YbhLyqBw+sBv5ftdWBbrtDAgR1kXo168fH330kfO6sLCQRx99lDlz5jjHEM20fGBtKalUyjm+gPQPZmtLit/v3+Q9LpcLwzCwLIuRI0dy880388knnzBy5EhGjhzpHNUcdNBBHVppWs+hZZHx1uNp2qZNzXfddRf/93//x6GHHkp2djbr16/PWEPrsVq/BjLGb/l+8+tUKrXJObRH67/QmkuQNNPevrYkHo+zatUqYrGY03b++edjGAa9e/fe7Oe/Neve1Gf8S+a5Kerr65k7d67Th67rzmugw2O1zc2nJY8//jgff/wxH374Iddccw2TJk3iT3/6E8lkcpP3tfz+xONxVFXlu+++y7jmqKOOancOLpcL0zQxDANFURg3bhxr1qxh2LBh+Hw+IpEIDQ0N7d7b8mchmUyiqipKB8WVTzvtNK677jqqqqp49tlnOeOMMzpcj6DzqY+lWFIdpS6eIs+X6WMFMPP9Gdx0+YU0NqSPyzWXiz/edDsnnvZb3n71JdasXEFxUTfGjRgG0VqUYB5yVg+MmIXR0ITs0lDcng2O9wZawIMr24+ejOwSkY+6adGYMNBNizyfxm7dAuT6NFTl17l2IcK6CM0WiPfee6+N4/SW8tRTT3HEEUdkOAc3s/vuu/PJJ59wzTXXAPDdd99tNpJsjz324KOPPuLAAw8E0sdNgwYNQlVVx2L2yCOP8Jvf/Ibc3FxCoRDPPvsshx566M+af/Mcm61on3766Savf+qpp3j55Zed8X77299uVgBsik8//RTbtpEkiYqKCpYuXZphGWwPt9udcZwFkJubS0VFhfP6m2++yXh/jz32YNasWc46Z86cmfH+vvvuyyGHHMLll1/utK1YsYK8vLzN+oRtLZv6jH/JPDfF/vvvz/777w+kIxo//PDDLfrDYnPzacnKlSsZPXo0o0eP5pxzzmHAgAHccMMN7LvvvsyYMcNxkk8mk0SjUXJzc9v00b9/fzweDxdffLFzrNncdzOzZs1yjipnzpxJ//79cbvdrF69mk8//ZRwOIyqqui6zvvvv9/hsVTrcVVVZdasWc53u6KiwrF45+TkcPTRR3PbbbcxZ84cXn311c32KfjltKz5qCkSRUFPm5/Bl555nL/euNGaX9arD3979BkGDdkLgONPPgW9ZhVmpBpJVVDz+mJaHhK1MSQkVJ8HbBszlgBZxpMXQPWlHe/15PZc7fYnZVjUx1OARFHIRUmWl+wW/mW/VnZpERbXTWK6QVHIm3Fe3WwCLWhR2R7StbIiKQPFyDxmjKYMGuIG2d7M5HVJ3aQpuWWiYPDgwTz88MMcf/zxnHTSSey5556kUimmTZvG0KFDt6iPSy65hHfffbddEXb++efz4IMPcsYZZ7D77rvz0ksv4fG0/SXSkptuuokJEyZQX1+P2+3mwQcfdI5yJElixIgRvPbaazz00EMAHHrooTz44IPcdNNNWzTf1lx33XWcdNJJVFdXY1kWL7/88ibnN3ToUG666SYmTpzIvHnzmD59OkccccTPGhvSPmHjx4/n0EMP5fnnn2fy5MmOs31HDBkyhMcff5y///3v9OjRgxNOOIEJEyZw1FFHkZubSyqVanNkdsMNNzBx4kRqamowTZOXX3454/277rqLww8/nJ9++okBAwY4EXHvvffeFvmEbQ2b+ox/yTy3BZubT0tOPPFEhg0bxqBBg/jvf//L8OHDkWWZv/zlL4wZM4aKigr69+/PtGnTeOqpp9oVYW63m//7v//jqKOO4re//S2BQIAPPviAMWPGcP311wMwdepUJ6r2/vvvd3wDu3XrRigUYsqUKQwePJhp06Zt9pi25bh33XUXJ5xwAlOmTEFRFD744ANmz57tXHP22Wczbtw4JkyY0KHPoqDzaM77tbYhgarKZHncGb+bmp8Bw0YeRjCURVO4kaOOP4kr/3wPKdVLY1zHb4bRa1Zi6wksXwF1Sj5arYk7UovqdaOGvKQSOlXRJN6Ah+LuIeQNP+OWbVMX01GlJAUt/KFsO12qx7ahIOBCbjGn2miKlGlREHBv1fMt16tlJDnt6PmW0E3q4jqBVr5mumlRHU3h05QMx3nDsqmOJHEpcsZRp25aLKmJ4tVkBnULUpzlycg48Gvn12nf20KakgbLamLURpJOAtaEbrKiLsaS6giVTQmnXd/gA7CwsonKSCqjvaIxwaLKJioaM69fH0k6eUy2hPPOO48ffviBoUOHOg7Ht956q/PLNz8/nwsuuKDdexcsWEBZWRkjRoxo9/2CggIn9UIqleLll1/Gtm2CwSAApaWlGf4tkBZVs2fPJhgMIssyH3zwAccff7zz/rnnnstll11Gv379gLQ1b8qUKY6VA2DYsGHOnA488EDHNwcgEAhkHKUcccQRvPfee9i2Tffu3XnwwQed+bXHM888w7HHHsvatWsZO3YsL7zwguO/1XqssrIyx2IBoKoqF1xwQcaR52mnncYFF1xAbW0tV1xxBU8++WS762j5/+OOO47bb7+d5cuX89NPPwFwyCGH8MYbbxCNRikuLuatt97KWOdhhx3mWEWKiop49913HQdsSFt85s6dy2677UZFRQWHH34477zzDsBmfcK2dt2b+ox/yTxb7tGm8Pl8W3yctrn5tBzz888/Z7/99mP16tWMHz+e6dOnA7D33nszb948Bg4cSDgc5pFHHnH8qVrvHaTFzltvvYXH4yEcDnPDDTc4Agzg4YcfZvDgwcRiMV555RVOO+00IB0x+fnnn9O9e3fq6+u59dZb+fOf/8zAgQOBtEhsmc5j4MCBGQE2U6ZM4e2330ZRFLxeL2+++WbGvMaOHbtVeyf4eRimxfLaKF+vaSSh2xg2rKyLURPNdFOoakqxpDqCml3Erfc9xM33PMid/3iShOzhp3X1rFq+kGTFIkBC6z6IWjufn1Y3sqYhgRz0YhkmidommnSD9ZJKtSSjt3g8NyUM1jclWNMQJ6ZvdG+I6SZrGuKsrI/RlNj4B3/SsFjTEGdFXYzGFs8g07JZ0xBneW2U2lZrqAgnWFwd6XBtVU2Z7TXRtDCtCCcy2mujKZbXRlnTEMe0Nlp+G+M6K+pirGmIkzQsbNumMa6zuiFGr1wvY/oVMKBbYJcSYACSvSX28Z2E8vJyevTowZo1aygtLd3ktaZl8/mKOqojSYJudWOFdmyaEiYp0yToVnGrG/8iiKQM4rqJnYzRLXdjjqKYbhJNpdNbtMy1EjdMfJrCiD5529yZ8Msvv6ShoWGTR5nV1dXOX82ffvopxx13HDU1NZt08t7W1NbWOsdX4XAYt9vtOEbffPPNLFiwYLsct1x77bVOAtydlZZ7Kfj5bOk+Dhs2jL/85S9blZKjs5g9ezbjx49n3bp1bQJsuhI783cynND5cX0TjQmdPF86f+S6cILaWIqSkBevZPDY/Xfx2ym/J6X5qYwkKQy4nbJAtmVRU7Oe1WtWk6NZlBZ1R/IVoodTNEQSrNch6FHprkrYhokrx4fl87C6MYlbkemZ63UsW0nDYlVFJZIvRK8cr/O80k2LlfVxLMumV67P8U+zbJtVdXGSpkVZjtd5Ltm2TXljgqakQWmWN8OC1XJtLetHVkeSbdYG6bQUa8Nx8nyujJJM4YRBeWOcoFulNGvjaUtMN1ldH8etyHQLumiM62R7Nfrm+8nfjtGOXe07uWtJzhYossTBvXN/Vtmi9IfY9viiPba2bNHPpWX0VEdMnjyZ/fbbD03TePjhh7nuuut2qABrTWNjIyeffDLHHXcca9as4YUXXmDGjBk7eloCQZfiqaee4pFHHmHKlCldWoDtrJiWTXlDnCXVURRFonsL36+ikIc8t8TTD93LS888TkNdLcsW/8Tfn/5XhpCwUnGSVcvwxRoZlO9Dy+2FZWgka2NIskJOToCslI6lG6geF67sbCfj/cACtY0gcavpuoveUGbwlKbI9M/3O76szchSuoRP63ZpQwRl6/bmtbVMnNpMQcDdrkjK8Wlke9vONeRRGeQOtGn3aQq9crw0JnQSusXu3YMUhTy/Wof7LWWXFWGQFmKby2TfHpoiZ5yl7yy89NJLPPvss9TV1fHiiy/+Iv+pbUGPHj144okneOWVVyguLmbOnDmbdYzvLA488MA2UYwCwaZofaS4vViwYAEnn3wyf/jDH7b72L92IkmDxdURqiKpNr5RAKlkkpMOP5hVy5Y4bZ9+8C7LFi+i38BB2JaF0VSFUbsa2zJRc0uQ3QUkG+LYtonqdoGE43jvzgui+dwZUY8dWYQ2ZSjq+J6u0R7TTcJxHU1Jp6YozvLsVPUdtyW77HHkL6GrmTN3ZsRedh5iLzsHsY+dx86yl5ZlUxGOs7g6HTGe52tr+YlGmjh/0nH8MPebNvfffPcDHHfiSaSql2PFGpG9IdScnhgJmWRdGNtgQ3FtCcswUQMe3CEvsrbldpBEUwOeYPYvWuf2JpI0aErqeDWFnjk+CoPuNsJ2e9PVvpO7tCVMIBAIBLs2sZTB0pooS2uiuBSZkixvm8jHud99x51XnM+alcvb7WPlovkky9N1cK2sMuqsIN7qFB5VwpUVwIgmiNVFiPrc5BSECLQYw7Rs6mLNpfE2PpKdiEhZyogytG2bug3O9rmtUjg0xHUMyybXp2VESoYTBknDJNeXmew0mjKIpsyMkkKQtlw1JQyyvVpGHrSkYdEQ1wl51AxLVnMxbb9LwacphBMGUd0k6JLZo3uIglY1mQUbESJMIBAIBLsctm1T2ZTkp+oIcd0kkjJJ6GmrTbMDumVZPPrQg7x4/+2YRseR7t1zfEguH2p2GeWVSVbW1FOU5aVfvh8zoSOpMrHcIOUpi0TSJKvFvXWxFMtqY/hcCoO6BRwx1Bg3WF6bFoYDuwUcx5lIymRVXTpBsqsg4NR2jOsmK+tipEwLRQo4zvVp5/0YsVTa3cIJHLBtVten6zH2yfNlONevbUywPpygZ46PspyNWfgrm5Ksqo/RPeTJyIRfE01tELFpn7Mcn8aAblnk/YqTrHYWQoQJBAKBYJcioZssqYpQ0ZQk5FHJ8mjEdQtZMjMi4n+c/x3P33OL83rPYQdgWxbzv91YumrI0D05fvK5yO48kg0JNMsiO+TFp8kY0QSq140rx4du2GQ1JPC5lAzrlVtV8LkU/C4lw0rlVmX8LhVNkVBliWaPVZciO1YoVwuBo8oSPpeCZsoZ1itFlvBvqMPYcm2SlL5eN+02Wf/9rrRVzqNltns0mZBHdfqDdP6vaMrAo8kMLgzQPz9Ars+F/CsrL7StECJMIBAIBLsEtm1TE03x4/omUqZFt4DbET69c32Ylp1xLLfHXvvy2wv/wHOPPsB5f7iKCy6/BiMW5o1n/s7qFSso6bsbJ5x2AWbUxohEUP0eurtdZMcSqLKMO8eP5k873ue6IOhWMxKnwoZowm4BFFnKOEL0uRTHAqa0EGFuVWZAQbrGbUvRpikyffP82JAxhixJ7a4NoCzbixFq214UdLdJ5grQLeAmx6uhyhKGZVMfT2FZMKDAv8tkuO9shAjbBaipqWHhwoVblDxTIBAIfo2kDIvldVFW1cXxu1QKfZk1RGVJwsZyCrA3c8k1f2LMuPEM3XsfUnVr0CsWMX7cYbgKB2KZPvRwHCOuIykyRlJHAjwBL+6sto73HUXVd9TeWrA101Hao47aZUlCVtq+J0kS2la0N/dVG9MxLYuikJuyHB8hz6br/Ao6RhzWdhFqa2s3WQvvl/Qzd+5cLr300l/ct0AgEOyM1MVSfF3ewKq6OPl+V4YDfDOVFWs57zcTeOah/8to1zSNPQYPJLF6Lsm1P6DmluLqvjd6TEPfcNzozvZh6wbYNp6CEJ68wFZFPu4MWLZNbSxFdTRJvl9jv7Ic9ijKEgLsF/Lr+pbsxHz//fdMmTKFRYsWdYl+BAKBYGfHMC1W1cdZsD6MLEmU5fgy3o+mDHTT5rtP3ufmKy6msaGeuf+bwx77H8SAocPIcoFRuxq9fi2SJCH32J/6uIq3Lo7LraJ63ZhJA90wSOYEyMkPoLky6yWGEzp+l5rhd2XZNg1xHY+mZFRZsW2bxoSBpkgZdRoBIkmTlGa0EZDhhIFt22R5M8VQ89qyPJkJVWO6SUI3yfZmRlAmDYtoyiDk0TIscEnDZG1jApeaTlzbK9dHjjh27DSECOsCWJbFF198QTQa5e233wZg3LhxNDQ0sHDhQg488EC+//573G43OTk5rFmzJiND/vvvv8/BBx+M1+ttt59mdF1n3rx5yLLM3nvvLX6IBALBr5bGuO7UNqyNpJBlmWzvRhGjmxYLK+p48f7b+eiVZ537ikp7UB23sNasp9SqIteOoIS6IQdKWVTeRG08Tq+8AN2lZsd7F5Wqh8qEQXFEp1fuRjFU2ZRkdX2MfL+L/hv8uCAdTbiiNkbQo7Jbt4AjhurjOstqY7hVOSNSMpwwqAgnsJIqA7oFHOEW002W10axbOiX789Y27LaGEnDom+ej9wNR6+WbbOyLl1nsneej24tyhCtrk/XxOyZ66M45MG00kKxIpygJORhSHGIXJ8QX52NEGFdANM0mTZtGvX19Tz66KMAjB49mrlz53L22WfTvXt3/H4/kyZNIjs7myeffJIPPvjAuX/y5Ml89tln9O3bt91+AOrr6xkxYgQej4effvqJww47jBdeeGH7L1YgEAi2IZZlU96YLjskyxJFQQ+xlIVp2xkWnlXLl3Lb+WexavGPTtvRE0/m2tv+ytrK9TTWr0bJ0nAV74Eek0lUNOJSVLweF5KuY2mkM9773XiaUngMq41vlypLuNW2FVYUWcK1oV1qdb1LkXApcobYUeV0+TtFkVFatCuShKbIbdYmSek+7NbtpP3PXKrcxn9MUzZEVdrpepGmZdMt6GbPkpCwfG1DdmkRdv/993P//fdv9rpx48Y5oqaZvfbai4aGhs3e++9//5sDDzxwk9domsadd97JlClTHAtWM+Xl5bz00kscfPDBTn8/p5+1a9fy+uuvs88++1BZWUnPnj3561//uk0rCwgEAsH2JJYy+KkqQmWrskMDCvxYdjqy0LZtpv3nX9xxw5Uk4ul8W6rm4vo77uHYCcdg1K6mVElQXNINr787qSYd2zSQNZVuhkmuRyGY7ced7UPZ4PdVFHKT49PwqK2jCV0EPSruViIsz+fCpylpEdZC3IQ8GgML0pGSLcWTz6Wka0cG/RmCLh0puXFtzaiyRN+8dERkywz10oZISd202pQNSteNBFmCwqCL0mxfm6NMQeezS4uwhoYGVq1atdnrqqur27StWbOGurq6zd6bSCR+1tya6dmzpyPAfgn9+vVjn332AaCwsHC7lHcSCASC7UFz4tVFVREMy6Z70J3h79QsXBLxOLdceQkz3ng1435DT/HOv5/l8L17o/lDeLrthpGQSYWTKB4NyaWiWwk0VSbULRu1VVkjWZIyfLuakTpoBzqsndhRWR+XIrUbRbmpiMv2ulJlCVVum+3etqFvnp/SbI9wtt+O7NIiLDs7m549e272uoKCgjZtPXr0IBgMbvZej8ez2Ws2RVZW1mav2ZLyn63noSiKKFgtEAh2epKGydKaGGsa4mR5VHJdHT/WXG43dTVt/6gG+Oabb5kx638cd9K5pMIpkEH1px3vscx0zq+QF1n5dRSebim+SrI89Mj2EmwnalSwbdmld/yyyy7jsssu+1n3zp07t1PnomnaFomirKwsampqnNfr16/PsMhtaT8CgUCws1MTSfLD+jBNCYOSbF/GEV5zmR5fi+zusizzp/seYfIRBxNuqG/T37IVlaQiSTSvG9u2MaJJLE3ByvLjD2XWlDQsm1jKbJPp3rRsoikTn0vJmI9t2zQlTbxapo+YbdtEUiYuRW6TuT6SNFBkqY3VrL21Qbp0kWnZBNyZj/akYZEyLQIuZUOS1Q3iK+SmR45PiK8diMgT1kXo06cP5eXlPPPMM7z99tsYhtHudfvvvz/Lli3j5ptv5sUXX2TSpElomrbV/QgEAsHOim5aLK6K8PnKOn6sjBBOmljWxhOBWMpkaU2Urxet4Ksv5zjtKcOiXgpw3O8uardfKdCNsCRjpnQs3cSV7WO9qrE0nKIqksq4trwhzqKqJtY3JTPa1zclWVTVRHlDPKO9KpLip+oIK+piGacXdXGdJdURltdGMVusIZzQWbKhsHjKsNqsbWlN1BFjzWtbWhNlSU2UcGJjnUvTslleG+X7ikZ+qo7QkNApDnk4sGcOg4tCQoDtYMTudxGKiop47rnneOONNwiHw4wePZqCggJGjhyZcV1eXh4ffPABjz76KJWVldx3333cd999BAKBrepn9OjR5Obmbrf1CQQCQWdQH0uxuDpCQ9wgy63S0MHx47zPP+axWy9HlWVe/eBz8rsVYukxUtXLOeCA/Zi3117Mb3GisdvQ/Tlg5DHojVGUomxcWX5kTUGqiW6nlXU+zfnIwkmdoiwPexaF6BZ049vEka1g+yLZW+JQtJNQXl6+XRzOa2trycvL22b970qIvew8xF52DmIfO4/O3EvDtFjdEGdZTQyXIpPjS58AtD6ySyWT/P3OW3nhiYeceyecdCo333oTRl05CcPGDBTjtj289drLVKwvp7RHL0aNGQ+KRm5hCM3nQdpwlKibFnHdIuhWduhxZKKpAU8wG9j8caRXU6iPp0sL5fhc9Mj2kufTUDtw4t+V6Go/311GDl9zzTUsWLAgo23kyJFcffXVO2hGAoFAIOgKNGw4squNpcj3uXG1ECsBt4qeSjH1xX+yYN53fP7xf1lfsdZ5f+xRx3Dp+WegV69E8gTxZpVgxGzAZuIpZ2ImDWzLRAt4cIV8yGqmsElHGbYVL6ostVv+SOmgXZI6bg+6238Ut/btaqa1+GrGpcjUp3SiKYPCYLquo0gz0bXpMiLs888/p6ysjMmTJzttJSUlO3BGAoFAINiRGKbFmoY4S2tiaEo68WprQaGnUkyZPJGvv/gso93t9vDHa65lwmEHISkKUrAEI+nCbjJRNqRgMGIJFJcLV34A1ZNZ0HtnwtzgbG+YFt1DQnztTHQZEQYwYMAAxo8fv6OnIRAIBIIdTGNcZ1FVhNpokoKAJ+OoLqGbKHI6b9Z/nn+qjQADOPPMyUw47EAkdwDdVUiyLomix1EDbiw9fZwnh3xIfjeqKzMvlmHZ7SY0NS2bpGnhVTOTrFq2TcKw8KhyRn4y27aJGxZupW2G+rhuoilyxpFl67W1JGXaKGZmVn7Tsp3s9iXZHiG+dkK6lAibPn0633//PUVFRRxzzDEcddRRO3pKAoFAINiOGKZFeUOC+esbWVUXpyjkwaVsFBXhhM6KuhhuVaFfvp/nH/tHu/0k4nGU7N5E4yrLKmLgUumhyRCJ48kNouQEWBFOkqyJ0TvX5yQotW2bFXUxIkmDshwveb6NFrI1DXHqYilKsrwUBjfWXVwXTlLZlKAw6KEka2NOxqpIirWNcXJ9LnrlbiweXhtLsbo+TsCt0i/P54im1mtrFmixlMmahjgkVKe9Ia4T003yfBoDuwXIFqWFdkq6jJdeKBRi9OjRnHzyyWRnZ3PyySdz1VVXbfKecDhMeXm582/dunXbabYCgUAg6GzCCZ25axtZVNWEKsl41HReq5bRY4ZlkzJtUqaFbduMO/7Edvsq7T2UVFTBssDSVFJJHVtVCPQswFuYjawppEyLlGljtEgNYZN2xk8ZVkbKCDa0J410HcrW7QnDQjetjHbDskm2025aNqkN7ZtaW8v2dF8m1dEk1dEkOT6Ng3rlcEDPHHJaZfAX7Dx0mejIcDhMKBRyXr/88suceuqpLFy4kIEDB7Z7zy233MKtt97apn3+/PkUFxdvt7kKfj5iLzsPsZedg9jHzmNL99KybWoiKdY0xNMO7G4VG4ikDFyKnFGT0bYhmjJRFPCqCqlEnNOPOzKjBN1ee+/PPfc8jMvnwzIsokkdyaORk+PLyHgfN0xME/wuhZYaJuEkN1VpeVqYMm0ShonfpdLCOJeOlNRNfFpmRKRpQzRl4FGVDGueZW/Z2lpeX1lTD24f3YIuuoc8BF2KEF4/g+3x87010ZddRoS1JhaL4ff7+de//sWpp57a7jXhcJhwOOy8XrduHfvvv79IUbETIfay8xB72TmIfew8tmQvI0mDpTVR1oWT5Pm0DmsnAnwwfRqv/es5/v7Mv1FVFTPWgF69Aj0ZY/oHsylfW0tRYSnjT5iE5nJjxpPIbhV3diBdA3InEy22bdOYMIjpJlnEGdCjiFzfzreOrkRX+/nuUj5hLamvT5eUaJkNvjWhUEj8xSoQCAQ7IZZlsy6cYElNFMu2KQplFt1uSSwW5Z5brmfqi88C8PDdf+aCs07FijeA6kHLHcD4Y3fDiCZBlpFSNhY6rhw/rqAXSe4ynjdbRDqnmEEkZZDrdTGoMICUkMnz77wRnIL26RIibMWKFSxatMhxxNd1neuuu46srCzGjBmzg2cnEAgEgs4kmjRYWhOhIpwgx+fG18L6pZsWqiw51p5FP8zn2ovPYcXSxc4165YuwIw3IvsK0O0crKiBy62iZcnojXHkgBtXbgDFpTlJV5sxN/iYtY5KtGwb07LbRCXadtofa0vb21vDlrQrsoQsSUSSBuGkQZZHZe+SbPL9LhRZojYZ2cyuCnZGuoQIy8rK4oknnuCiiy6id+/eLFq0iFAoxLRp00RpHYFAIPiV0Gz9mlsRZlltlH75/gwBVhdLUd6QIMur0iPLw4tPPsLf77wFPZWu2+j1+fjjJecx/vgTwVNEU9RmVVMct0elDB1VlfGV5GK5NZbVx4EkffL8TnoL3bRYURdDN2165/qcpKfWhojIaMqkV44vI6nq6oY4jXGD0mwPuS0iJdc1JamOJCkKeegW2BgpWRVJsi6coCDgpji0MVKy5dp65myMlAwnDFbWx1AkyPZqhNwqQ4uCdAu4RYb7XYAuIcJyc3N57bXXWLt2LYsXL6aoqIj+/fujKB37BggEAoFg58Hx/WpKEE+ZKJJEXM+MGozEEsx45Z/UrlrC0u++YNniRc57PfsN4LzLr2TUfvtjEcJKWBiKQtxKokeS2FnZ+PL8yJpKU9IgviEXWMq0HBHWXGootSHKsVmENZcaiqVMkoZJ86PRttPXNyUNkkbmXKMpk3DCIMeb2Z7QLcIJo019xqRh0ZQ00BQJ27Yz0lKsCyfok+djj+5Buoc87VrXBL9OuoQIa6akpERkyRcIBIJfEaZlU9EYZ0lNFBsoCnrQfTZZXi3D4qSnUtxywSl8M+fzNn2cecpEjj9rCoFQGUaTjeqzUT0u/PEkvbLceLP9ZOf4HWETcCn03JCXK9CixI9XU+iV68OwbLK8G8fWFJleOT6Shplh7ZIkKZ0rzO8ix5vpn1ya5SHkVslu1V4YdONW5TYlipqPFf0bohp106IulsKlSpwwpDul2V7cqjA87Gp0KREmEAgEgl8PsZTJqopGqiIpcryak4HerUoZyU4Bpr3yr3YF2CknH8dFf7wV0wpgpwwsxcJoimObJp4cP8GgNyPtBKTFU8skqy1pLZqaSYumto9Ev0vF72rb7tWUNhn102uT26wN0kKvW8CNYdlUR5PYNvTM8VGa7WljNRPsOohPXiAQCASdimnZlDfE+amyCdWfRVHQvdm0CuWrV7bbrvm7Y+heZJeM7HVjx5O4sn2480Oo7o6j57satp2u75gyLYpDbnrm+Am2U9BbsGshvgECgUAg6DQa4jpLqyPURFMENIVQi7QKLX2hml9/9fkn7H/wSEp6lLXbX3FRT1SPGzOlYwOeghCqz9XG+tVe/1vy3vZob0qaRFIGBX4XvfN85IgSQ4INCO8/gUAgEPxidNNiWU2UD5dU87/yhnSW+BbZ4KsjSRZUNlEdSQJQV1vDH353KudPOpann/8nQ/ccwt57Dc3oc7c992fP0RPQ4wkUrxtv92wMj4vFtXFW1MawWuQaTxoWi6ujLKmJZpQJ0k2LJTVRFldHM5zrLdtmRW2Mn6qjxDY48UNaNK1piLOwKkI4YWTMZ104wYLKJupjekZ767U1s7YxweyVdaRMi71Lsti7JItcUWJI0AJhCRMIBALBL6I+lmJxdYT6uE5Ct9DNDWV8WhirIkmTmkgKv6ay5JsP+dNlF1JTVQnAk3fewOAnX+CBh//JtKlvsnbtarJ79KJsvyOIWTKuvCzcgfSRZjyaoi6Wwqcp6KYHt5oWNAndpCGho8oSKdPtRBimTItwQsewbBK62SJdhU1jIl0Eu8DvclJlWHbamteY0MltFTzQmDCoiabI9mjk+LR211YQgLhu0hDXsW2Lo3frRkm2V6SbELSLEGECgUAg+FnopsWq+jgraqO4FIWioIeASyPP7yLXq0Fio2WoW9CFZKX41/238vLTjzrt+fl5XHLVn+hdPBAJmeNOPh09HMdSJCJ+D6EcP57AxnxbWV6N3rk+XIrsCCqAoEelV44PSSIj95hPU+iR7cW2yfDBcqsyPbK9pEyLrBbO+oos0SPbS57uapOhvjjkIeRR02trQbegC7cm41El1jcl0GSZgQUBirLcIuJRsEmECBMIBALBVuNYv2IGBQGXY3kKeVTHepRIbLx+3YolXHfxuSxe+IPTdujIEVx3410EgoVIsoysyJhJHU+uD1dukPx2HO9VWaKoRRLUZmSpbcQlpCMlWyZTbUlHZYCyvVq7UZQt19YSTZZRpLQVrW+en5IszyZrYAoEzQgRJhAIBIItpqX1y60qFGe1FUR6KsW0V/7FyiU/0av/bsTjMR648xaSG1SZx+PmssuuYPxxvwUUFLeGldKxDBt3TgAt6N4p6j3qpkVdXEeWoFeuj9Jsb7tpKwSCjhAiTCAQCARbRF0sxeKqCI0Jg3y/q/26iakUUyZP5OsvPmu3j4EDBnDLn++ntLQfsqqBJGEmkqg+D64sH8pOkDPLtGzqYiksG0qzPZRle/G7u/68BV0P8a0RCAQCwSbRTYuVdTHmVTQSSVoMKgxkCLDKpiThpEFR0M17r/6rQwF22mlncs45V9EUNVlWnyDXZ5EfdOPJD6F63UR1k3U1UUJuNeNoMaabrG1M4HcpGTnHUoZFeWMcTZEpyfIgb2g3NuQpAyjN9jrFui3bZm1jAt20KM3yOtGbtm2zrilJNGVSmuXJsGa1XJvPpdCwIddXvk+jX0GAkGfnyVUm6HoIESYQCASCDqmLpfipKkJdNEVTwiC2oTZis1Cx7XQG+JpIOmKxfNXKdvsZe/gxXHjxn1BcGusTEdbUxdACXnp0y0Le4LzemDBY2xAnGXDRLbAxlUNTwmB9OEHIo1Lgd6Ep6fZIyqCyKYlblclrEeEYS5lUbUgXketzbfRRMyyqI0mShkW2VyNXTfuEGZZNdSRJOGEQcqtt1lbdlMQ0bUJeVeT6EnQqQoQJBAKBoA26abGiNsaq+hhuVaFHjg+3ppDQrQyndUmSKAp6CLk1qlcsYsYbr7bb377DDkFxuzCTKQqyfXgLQ+Rl+RwBBpDj0+iT58fvVjIETrZXo2eOD48mZ1jggm6VHtleFFnC2yJS0u9SKMnyOv9vxqvKFIU8mJZN0J1ZO7Io5CHH23ZtQZeK4bMpzfbQL99Pvt+FLAvxJegchAgTCAQCQQbN1q9wK9+vjqIMc7wq77zwOA/89Vb0VAqPx0OiRWjkPvsO5+hjTsDSTdzZAQJBD93acbz3aQplOd427W5VbrddU2RKs9u2K7JESTsBA5LUfmRle2uLpgwa4zp5ARf7lWVTEHCjCPEl6GSECBMIBAIBsNH3a2Vd2vrVkWBpSeW6Cv50+YV8+elMp613736MGnUUjeE6ynr3Z9wRx+H2e3Fl+7u8431MN2mM6/hdCkOKQhQG3SLRqmCb0bV/GgQCgUCwXejI+rUpPnjnTW67+g80NtQDIMsyZ541hTNOuQBF1TCtBJ5QNu5sH6rPg9SFLUlJw6IulsKtygwqDNA96MkouyQQbAuECBMIBIJdmOa8X3PXNmBYNgMKgk40oW3bVEVSpEyL7sGNpYCikSZuve5K3nvt304/RUXF3HjzffTafV+qkwbZloUv4MHXPQtZVQkndOrjOjleV0bC02gqXQoo5M4sBZTQTaoiKbyaTEGLo0LdtFjflMSlyBnO+4Zls74pgSxJdA+6nUhJy7ZZ35TEsm26Bz1t1hZNGbjVdPb9/gXpRKsiy71geyFEmEAgEOyi1MVSLKmOUNGYoDaqI0kSkaThOKenTJuKcIJYysSrKeT7XSz8YR5Xnncm5atXOv0cOe44rvjjrYRyclhYGaYyZTK4LI9sn4Wsph8ztVGdZXVR+uaSIcLqYzrLamIUhdwZIqwhrrOiLkaOTyPX53L8sRoTBqvr4/hcCtlezakdGUkalDckUGSJkFslsMHxPpZKp7cwLZuAS3XWFtMtFlY24XcrHNQzh565Pnxd/KhU8OtDfOMEAoFgF6N1zcdeuX5URcayMqMJXYpEQcBF0rAIuBRsy8RlRKmtXg+Azx/kD1fexoQJE7ENC8sw6F4YJKio5Ia8SHrE6SvLq9Iz20uWN/OxE/Jo9Mj2tCkTFPJoFGd5CLiUDIf4gEuhe8iNW5VxKRvb/S6FwoAbWSYjz5dXU+gWcDlrMy2b+riOYZqM7JtH3zx/Rk1JgWB7Ir55AoFAsAvRUc3Hnjm+NtdKkkTphlQPZjJComIpRX6F31/8e97778fc+Kd7KO7VEyulo3rduLJ9BFwtjxQ39pXrc5Hra1urMV2PMdCm3edS6J/vb9Pu0RT65rVt1xSZ3nlt16DIEj1zfFi2TUNcJ2lYFAbd9MrNarc+pECwPREiTCAQCHYBmq1fK2tjaIrcbs3H1ti2zRv//ifhytVUr11JcXFPjjpmMsccdw7jjvotGCaWbuDODaL5u2a9R9u2CScMYrpJvt/FkCIfuT6RaFXQNRAiTCAQCH7lNFu/GuJbHvlYX1fLzZddwKwP/5vR/t+PP+P+B59H9WhovgDuHD+y1jUfJeGEQSRlkOvV2K0wQJ5PJFoVdC263p8tAoFAIOgUdNNiWU2Uj5fWUtGYpCjkcQSYbdtUNiWpbEpi23bGfdOnv8PEQ/drI8AAvv1mDm+/PRVvtyw8BSFkTaUxrlMRTpA0rIxr4xtqPsZ0M6O9uRZkJGlktCcNi4pwgsa4ntGumxbrwgnqYqmMdtOyWR9OUBPNbI8kdRasD6NbFnsVh9i3RzrZqhBggq5G1/zzRSAQCAS/iIa4zuKqCKvqY1RFUvhdKjHddOorNiVNVm8ocu3VFEIelXg8xt03XcPUfz2/yb5XVa1F86XTRti2TXnjBiFUAMUtErzWxHTWJiL0yfNnZLyviaRYXhulJNtL/xblg2pjKZZUR8n3p9NYNB8Z1sd1ltfGCLpVgm7VEZKNCZ2V9XFciozPpSBtWLcqS4zonUv3kEckWhV0aYQIEwgEgl8Rxgbfr+W1MTRFoke2FxsJTZFwtxAkXk0ma0NUoFeT+XHu11x38TmsXLnSuaZvn4EsW/5TmzF69+3n/F+SJCfi0a9l5tfyawr5qgu/u1W7WyE/4CLkVtte73eR5VUzfLb8LoVcn4bPpTh5vtLzTqepsG2b+piOR5XZrVuAopBItCrYORAiTCAQCH4lNFu/6uIp8n1uR4gMLPC3cUTXFJn++X5M0+Tp++/g0b/fh2mmjw29Xj9/uPxGxhx0JFffOIW5c79y7hs2fAQnnXp6Rl+lWV5KQnabMXJ9GkWBYJv2PJ+LXG9b5/gsr5ZhAWvG71LZrVugTbsEZHvSlrGyHC8lWR48mki0Kth5ECJMIBAIdnJ002J1C+tXUdCTIVg6igS0TZ2v35vKQ/fd7bQNGbIPN932fxQVFqP6PTz2yjSmv/Ef1qxaQY+evZlw8mQ0rW1qh47G2BbtCd2kIaGjyTJ98/0UZ3kycoMJBDsLQoQJBALBTkxtNMXSmnTkY57PtUXHcLZtY0Zq0WtXs3v/vpxw/Mm8+dbrnH3eHzjttPNwedy4svyovnRZoBMmn7UdVrJ5MsRXnhBfgp0fIcIEAoFgJyRpmKyoi7FgXRNeTaE0e6Pju2nZ1MVSuBSZrA0JSfVUijf/8y8W/DCf0sI8Th43Gtv2ILlLuPjyWxl5zGn07bcb3uwAriwfspIWN41xnZRpZZQOAmhKGsR1k1yfK8NPK5YyiaQMclolQk3oJo0JgyyPmnFkqJsW9XGdgEvF1yJbv7FhDV5NQZMlR3z1y/dTHBLHjoJfB0KECQQCwU5Ec+HpJdUR1jTEqYvp5Pg0iiyPI5IaNkQTejWF3TQFyTKYMnkiX3/xmdPPzP9+yD23P4FblTEkCU/pACoUjWyfB88GAZYy0k7+cd1EliTy/OmM96Zls6o+Rjhh0DcPCoMbC2yvaYhTHU3SK9dHfguj3PqmJGsa4vTI9tIrd2Nm+8pIkpV1MQr8bgZ225g5vzaaYlFVE4osMbAgIMSX4FeJEGECgUCwkxBLGSyvjVLemCToVinJ8mLa4NdUWqbAcqvplA0eVUaRJV5+5vEMAQYwf943fPDJdMYfdRKBvAA5uoWFlJHIVZElvJqMJKX7bEaW0mNadmY7pCMZE4aKR1WgRdowjyoT8qh4Wl3vURWCbjWjZmXSsAjHU3QLuNm7JIseOV5x7Cj4VSJEmEAgEHRxLMtmXTjB4uoohm1TGHA7Vi//hgLXLR3XA+50NKGMzfefv88j9/613X7X16wj0KsAxaXS37KxIeNoUZEl+ub7MS07Q5xJkkTPXG+bdoCSLA+FQTeaIpNoijnthUE3ef7Mo0sgnZLCo6LKEinDoj6eQpEl9irNFj5fgl89QoQJBAJBFyaSNFhaE2V9U4JsjyvDbwrosASRlWji0btv5ZmnnsG0rHav6bXbQBRX+jGgdJBNXpYkZKXtex21S1I6J9mWtjdTHUkiyRK9cn2UZHnwucTjSfDrR3zLBQKBoAtiWjZrG+MsqYkiAd2DHuQtKDptWyZL537BTVf/kR8XLnLa/f4A0WjEeb3fQSM49jeTt8XUtxjdtKiL68hAWU5afPnd4rEk2HUQ33aBQCDoYoQT6aSrK+riFAXdhFpEGpqWTWNCx6spGUd1lm1T19jI0jkf8PuLLiKZTAKgqiqnnXkJvznzfL6Y/S4VFWucfF9xE+KmTsiTGckYSRoYlk1Wq8SpsZRJ0rDI8qoZgjCum8R1kyyPlmFR002bWCyVUWqo+fr/b+++4+Qq6z2Of86c6XV7yZZkUwmhSItUaQIiRQQiGFREUFCxgAp6LYgiV3pVQUClGAWUgHgFGwKi9F7Sd5Nsy5bZ6e3U+8duJjvZDQTYZHaT3/v18nUzZ84583DuZvabp/yerkSOoEeltcJPS4WPoIQvsROSn3ohhJgkDNOiK55ndTRDX6pAKq/jUpWSEDaQLrA2lqPC5ypWwrctkw1da1nTO4Az0MTcuQt4/fWXmDlrLl//1k/xzFlA1O/lxDPOKk6kTxcM1kQzAMypCRRDUMGwaI9mMSyLmdUBKkY+27BsOoayZDSDmdUBakZWStq2zbpYjnhOZ0alj4ZRe0cOZAr0xW1aKnw0V/iwRrYX6k/nmVUdZF5dkJBXfg2JnZf89AshxCSQyOmsGkgzmNGoDngwLRvdtMbM+XKqDtyqA5c6PBnfzKXQBtqx4nkU3Y0nVM13f3gdDy/9LV84/5solRHWJTVcqlKyglJ1KMVJ8qN7rxwKI3O3HCWT6BWGj7vVzY6PzPVyq44xm2U7HQ48TgcOZbhsRk43qQ952Ks5Ugx3QuzMJIQJIUQZGaZFZyzH6mgGp+qgMTy85VBDyEPE5xpT0qEmMDw5343FwKqXuPInl3HMEcewcP+PsEs4gBMLpzPIBd//EU6/F8WhMM/rHglXozfwVplXO1yXa3SVfZc6XBB18/ITqkOhrcqPYdljVizOqPRTCFv4NzteE3DhcfgwTBOfy8Gu9UGqA+4tbk0kxM5GQpgQQpRJPKezelTv1+jQoyjKmFCzkVtP8dRf/sBlP/5fBgYHeenl17l7yVGEPDbOoA9PxIfDuenrffNaXsX7bOH4llZculQH4zVJdSj4HaVvpAoGiaxORZXKrOowNQH3FldgCrGzkhAmhBDb2egNt52qUuz9eie2qZNY/yY3XXMdf1j6YPG4pmmsX9/Ovod9CNXrKmtPU7pgkMjrhL1OZtcEmNlUMWaYUggxTEKYEEJsR9GMxvK+FBtSBVoqfCXb8BiWTVYz8bvVknlXlm2TiA2y8um/c9mPfsL6rq7ie/t+8EN87/LrmDF3JopjU9hJFwycDmXMNj8ZzRi3ly2rm9i2TWCz+lx53cSw7DGrFzXDIm9YhDwqiqKQ0QySI6s292gMUx/ykIjHJIAJ8TYkhAkhxHaQ14c33O6M59iQKqAZFkGPk8ZRYag3macnmWda2EvLyIbclqGxZsWb3H7bbfz1D0uwbbvkvimtQDZUja0obIxtG/eO9DgdzK0NFIcXNxZ+dTgU5tYEigEtr5usHsxgWTazR62U1E2LNdEsBcNiZrW/OJnesodXSqYKBtPCXhQF/G6VBQ0h6kPeLQ5nCiFKyd8UIYTYhmzbpi9V4PnOOF3xPNV+N6GtqIll2zZ6aoCOZ//GxV/6Ao/e/9sxAQxgxcvP8sTD92+Lpr8tw7KJ5zV0y2JObYAPtlbSXOGXACbEuyA9YUIIsY3kdZPVAxm6kjlCHhf1IQ8ArRU+agMegp7SIcHGsJeI14VXMch3vo6eTqMaQRKxOACK4sC2x25BlI92lxRPrfC5mFsbwOko3ZA76HEyZ6S22OhhSq9LZXZNYMxwpEt1MKvaXzIcubHWV4VPZY+GOmZU+6XKvRDvkfyTRQghJtjo3q/eVJ66oLek98ulOgh7nWO2IVIV8BWiFNqfR0vksJU6qmbsysXfvIzZc3bh7C9fMO7nzWibOeZY0OMcMx8MIOB2jrvq0u9Sx8wHg+GAFvQ4sW2bZF6nL1WgwufkgBnVLJgWlgAmxPswKf/2dHd3s2rVKubNm0djY2O5myOEEFstr5usiWbpiucIepzUh7zvfBFgaTlyPct5+P4/smC3DzJ93r4oThcKNoeeeByHn/5xAF558VleePqp4nX7HXgIJyzatntAZjWTeE4j4nOxd3OEGqn1JcSEmHQhLJPJcNRRR7Fs2TJuu+02zjnnnHI3SQgh3pFt2/Snh1c+JvM6zRX+krpYpmVTMMcWNDVNk0y0h6EVL3LldT/nP88+yx57Ps2NN92NrSoEq8O4ve7i+bf87kH++Pt72NC5jtYZw3tAulzDE+ZzujlmCBKGtyLavFgrDK9whLH1wnTTwrKHq+QP5TTcqoPdGkM0hLyy2lGICTTpQtiXvvQlTjjhBFauXFnupgghxFbZ2Pu1Pp6lP6WhABGfUbI1z9pYlkTOoLXSV9x30dKyrFm9kkf+9Gfu/80vSaUSALz26gs88doLtOxzCHV5k5ZRnWkJzWbu4Sezn8/JrOpA8Xg8p7N2KIvfrTKrOlAMgOmCQXs0i0tVmF2zaaVkbmRFJMDsmkCxCr5uWqzsTxPN6cys9jG3NkRzxDvu0KYQ4v2ZVCHst7/9La+//jq33XYb11xzTbmbI4QQb8u2bQbSGisG0uR1k2q/h3jWIKMZGJZdcp5u2mimhWFa2JaJHuumd/UyLr7o+7SvXlE8t7a2nkuuvpm2fQ+hM55DN0sn4humhWZa6KaNbdvFYUHDGr6/y3Qweg2lYdkYlgU4GNUkTMsuttEc+b+2bTOU1cloJh9srWCXupBssC3ENjRp/natXr2aCy+8kMcffxy32/3OFwghRBnldZP2wQzrExtXPg53V7VV+SkYFhHfpq9XRVGYXumjLugmqBTId63k8b8+xvcu+zGGYRTPq6qu4d6/PUV1XR26aeF3qwQ3myxfG/TgdjrwudSSeVlVfheqEsTjLN1gO+J1MrN6eKXk6O2Lgh4ns6r9xT9nNINE3qDK5+LjezRS5S9v5X0hdgaTIoRpmsZpp53GJZdcwvz587f6umQySTKZLL7u7e3dFs0TQogi27YZzGis6E+T0y3qgt6S0ON3q/jdY4fuvKqNI9ZFvLeLm372S/70fw+POWcoOsgT/3iEkxefiUt1UOUf+w9S1aGMe9yhKFT6XWOOK4pSMiw6WtjrQjMsNqTyeJ0Odm8I0RD2yh6PQmwnkyKEXXnllWQyGXbddVcef/xxYPiLbsWKFTz33HMsXLhw3OuuvfZaLr300jHHY7EYPp9vm7V3dPAT7488y4kjz3JivN1z1E2LnmSevmQBr0sl4lYxMjmMLV4xzCpk0WK9GNkC69YN8sjfHt3iuR0rl5NPxd9b498Fy4ZkQce2h+uT1QXduMws8Vh2wj5DfiYnjjzLibE9nmN1dfVWnzspQpjf76ehoYEf/vCHxWOWZfGnP/2Jvr4+7rrrrnGvu/DCC0tWT/b29rJw4UIqKyvf1UN4L7b1/Xcm8iwnjjzLibH5c9zY+7W6P0VSd9NQFx6zt6Np2WNWH5qGTq6vHTuVwEyDM9zMLnvO4fNfuJDbb7seTSuM+ezW2fPwBCNjhgJ108LpUMY9rjqUMTXH3u54Mm+gmRaNtRHaqgLbdN6X/ExOHHmWE2MyPcdJEcIuvPBCLrzwwpJjTqeTb33rW29boiIcDhMOh7d184QQO7GCYdIezdIRzdKXKuBzq1T7LZyO4SFH07Jpj2bIGxZtVf5N+y6mh1i5pp3XX13G7q1zaKhswEbF6fdw1Oe+zMwPn8Dd/3sRrz733+Jn7bHwIGZ+6Hj6UgUawpuWRA5mNLoTOar9bporNvXyx3M66+M5Qm4nM6p8xYCWLhh0DGXxOh3MHLVSMpoZXkQwpybAPs0RqqXelxBlNSlCmBBCTDa2bQ+Hlv40Gd0k7HEykNHIaCa6aRVLOpiWTU63yOkmBcMi4NTJ964iNRjlntt/z6MP/Y6jjlvED777EzxVQZx+D/pABl/tNH5027289LeldK7roGV6G3sceRK9GYO8UboiMm+YpAoGXmfpXLOCYZEuGDiU4eFFVdl0PKuZ2PZw+yzbJpodLp1x3Pw6GsNS70uIyWDShrBDDz1UquULIcpi48rHrmQev0ulYWTl4/RKH7ZNyRZEbqeD6ZU+NNMiaCbJrF3PitdX8r/XXcuqkdITf33495x+5mfYu+UgAFoqfFT6XVT6XMxYfGbJ54YDBuHNtgKqD3pwq44xKyWHe7LA51JLJtNX+FzMrPbjUBQSI/O+ZlT6aa30Sb0vISaRSRvC/vnPf5a7CUKInYw9sjn1W4k4Oc2kOuAumec13qpEgJDLpjC4msxQnCX3LuU3S36DrusAuNxuvvyt77Lnwv2L529xBaVLHTckuVQHdUHPmONOhzLucUUZXi2pmxbTIh5aK/2EveOvkBRClM+kDWFCCLE9ZTWDNdEMXQNpIpVVJXOytsS2bYzUAIUNnax6aw1X3nQDby1/o/j+LrvtwWU33MqcXXbdlk0vaU8ib5DTTeqCbmZU+anwSb0vISYrCWFCiJ2aadn0JnOsGshi2jaVfjf+UcOBtj1cTX7zIGPpefK9qygMJfnd/Q9x+913YJrDxSocDgdf+PpFnPPVbxb3ddx4r/EC0UQcT+YNUgWNar+HXeuDMuleiClAQpgQYqeVyhusGkzTlcgRzxqEvE6Co0btdNOiY2i4blZblR+X6sC2bQqxXla2d5HPmPR3rObW39xact/p83Zj8XlfLwlgXYkciZxBc8RLZFTx1L5UgYFMgcaQl+rApuHOaEajN5WnNuChPrRpyDGR0+lK5In4nDRHfGQ1k3hOw+9W2aupgtqgR4qtCjFFyPIYIcROxzAt1kazPLc+RjxnEHI7yRsWidxw/ayNcrpFIm+MDPFZWFqO3Po3iK1dRywJaU8tvUPxMffvWPYaS+9bUnxt2zaJnMFgRiOjmyXnJgsGg+nhVZejZTSTwbRGslBaCjajmwxmNAZSGr2JHJppsltjiANmVEm1eyGmGOkJE0LsVOI5nbc2pEjmdar8brwuFdOymVFp41QdeK1NFeNDHpXWCh+2beFO95Ae6GND1yC1TXNpbfRhuxy8khoc93NiPeuLf1YUheaIl0q/i+rNJvc3hjz4XeqYLYdqgm5Uh0Jks0KqYY+TKr+TSr+bOXVBmiJePE5Z8SjEVCQhTAixU9BNi/WxHO3RLC5VoTHsLc6ZUh1KcSJ+PrUphCmKQo3bIN+zhsxQmof/8g9uvesWvvyVb7PozLNxh3xMnz1r3M+b3jaz5HXE5yoZhtwo6HEWC7yO5nep+CObwpVp2QzlNCwL9mmpoLXCh98tX+FCTGXyN1gIscMbymqsHEiTyBlU+924ne88E8O2TLRoJ4X+fnq6BrjmFz/juef/A8DNN/2Uw046kebIDE5ctJi/LL2fF55+qnjtfgcewgmLFk9I2y3bJp7T0UyLaWEpNyHEjkRCmBBih6UZFmuHsqyLZfE4VRq3ouwEgJlPketeQyGR5a+P/Zuf3XYT6XSq+P6Jiz5JVXUNMFwH7JbfPcjD9y8pVr4/YdHikkn574Vt26QKBmnNpDbgpq3aT6WUmxBihyIhTAixQ9q4T2J/qkDesKj0DVeS3yivm3Qn83icDppGhiZtyyDTv56u/jTx/hi/v/tW/vv0E8VrahubOP/S6zjuI0cVi7jatk1f1mDPY07lo2FvSbHV3mSetGbSFPaWFGcdSBeI53TqQ17Co+Z8DWU1ohmteG6Fz8XeTRFqAm4cMuFeiB2OhDAhxA5FMyw6hjKsi+XwOVX8LpXOeB7DsqkbVb4hrZlsSBbwu1VqAx7UQoLkmje4/8FHeOK5F1n91stohXzxviee/hmO+vxFuH1BMppJhW84hGmmzUBaI6uZRLyuYggzLZuBjEYsqxParEL+YEajN1nA51JLQthgWuOtvhQfaIqwd3OYhpDs8SjEjkxCmBBih7Bxw+03NqQoGBY1I1sOeZwO2qr8+N2l+ytGvE5aK324sDB7lhHr6uFbl/yI1956reS+tfWNXHrtzRxw6JFsSBWwbLtkIr1bVZgW9qKZVslKRtWh0BjyUOF1lfTAAdSHPPjdm1ZEmpZNLKfhcztYtOc02qr9ssejEDsBCWFCiCmvYJi0R7N0xnP4XSpVo+Z+eV0qrZW+Mde4VAcNzhy5tcvIpg3+9u8XxgQwgLO+/DUOOuzDAEwbZ06ZoiglxVRHqx1nX0cY3oOyyu/GHpl0n9dNGsIeZlTJpHshdiYSwoQQU5Zt2wxmNFb0p8nqJtX+0g23t3idqZPtXEG+r4+C5iJQP4u++F/GPXewv2+imw1ARhsuAlvpc7JrfUS2GRJiJySTDYQQU1JeN1nen+alrgSg0BDyvmMAs20bPdFPavnL5HoG+ddzb7L4i59l2bqVzJg/b9xrWqa3TWi7C4ZFb3J4jtruDSH2bamkJuiRACbETkh6woQQU4ptD0+EXzGQZjBdQFEU/JvNn8rqw1v+BDxqsUK9pRdIrFtBZ3ecbCLDb393B08++XcAfnLpN7lyyf+xx37389rz/y3eZ98DDmGfo0+mO5GnIbRpUr9t22xIFTAtm/qQpyT89acL5HWL+pAHz6h6ZH3JPL3pAvVBN3NqgzRHfFtVr0wIseOSECaEmDI0w2JNNMP6WI6gx4lTdbB6MItp2SXV6GNZnfZohpqgm0qvEyPRT66nk97+PA8/8Sz/9/ubyaTixfPn7bE3vckCX7n+Llb+/X6ig/20TG/jsBM+wepYHjAIeZzFlYy5kd6sgmHhd6tUjQQ93Rw+nswbeJwO6kMeLNtmKKPRk8yzx7Qwc2uDBMapkC+E2PnIN4EQYkoYymq83pMkP2rlo2XZtFZ4iyFoo4jXSVOFj6DDILf2TQqxNNGhFD+741ae+vc/iufV1jfwvZ9ez4FHHENXIodLdbDbaYvxhysAhsta6DZASYkJr9NBbdCDbloER20d5HQo1AY9+N1OQh6VRE4no5vUBd3s3VIxZpWkEGLn9p5CmGVZpNNpwuHwRLdHCCFKGKbFuliO9mhmTNX7Le3HGHA5aLWHyHf1kstbPP7cS9z486tIJGLFc0449ZNcdOn/Eq6oBGBmdQCAfKpQPMfpUJhR5R9zf4ei0FIxdsWlogyXq0gXDOIjk+53qR8utipzvoQQm3tPIUzTNHbZZReuvvpqFi+emP3RhBBic4mczor+NEM5jdqAZ6tWPppalszalejJLODhgb//nZ/9/Mri+xt7vw47+tgJb29eN4nldPxuld0bQjSEvSW1yYQQYrT3NCvU4/Fw4YUX8oUvfIEjjjiCZcuWTXS7hBA7Md20WDOY4bn1cTK6SePWrHy0LHIb1pJ44zXyAzlMVzV/ffYZBlNRfP7h3qzjTzmdBx57ZsIDmG5a9KXypDWDebVBPthaSVOFTwKYEOJtvacQpigK3/zmN1m2bBmRSIQ999yTb3/722QymYlunxBiJxPNaLzQGefV7gQ5wyTgUkuG8jKaQXciT0YziseMXIrBFa/QvqqHaELBDtRy8Q++xhWX/w/33n0HuWyWmfN25YfX3FwcfjQsm95knmhGK/l8y4a+VIH+dAHbtovHbdumP12gb6Rq/vC5w1X618dyNIY87D+9khnVfln1KITYKu/rm6KlpYWlS5fywAMPcO+99zJ//nweeOCBiWqbEGInktdNlvWleLErjm7aGDasHcoyuFlI6k9prBpI05/SsC2TXPdqksvfpLevwNLH/8sXv/k5/vzkQ7z0wtMl17WveIuH7ltSfJ3I6XQMDVfZLxhW8XhWM1kbGz6e1c1Nx3WTzniOtbEsqbxBMm+wIVUg5FE5fE4Nu02L4HfLWichxNabkH+uHX/88bz11lucdtppnHLKKRx77LGsXr16Im4thNjB2bZNX6rAfzqG6Irnqfa7qfC5iHid1ATcBDYLNkGPSk3QjdfMklrxKtnufvoHMtxw4+Xcf8uPGdjQxQO/v3vcz+pe11H8s2+ktETE68KlbuppczsdVHhdhL0u3KOGQN2qg7DXhc+pEs/pOBywV1OEvZtl1aMQ4r15X/9sGxwc5Omnn+bpp5/mv//9L88//zwATz31FLvvvjuXX345F1xwwYQ0VAix40kXDNqjGboTecJeF6FR9bMaw14aQmMryVf7VPyD3RSiCTRD4a//fZaf3XINmXSqeE5NXR1dowLXRi0zNlW/97tU5tUGxtzfrSrMHec4QMSjUuVzMbPaz7TIO89TE0KIt/OeQpiu6yxYsIBVq1YBMGvWLA4++GA+9alPcfDBBzNv3jz+8Ic/cP7555NOp/n+978/oY0WQkxthmnRFc+zZmh4Hmlj2ItjnNCzeRDSk0Nk17WTjxUYTGe4/vYbeO7Zp4rvN0xr5gdX3cDCAz/EeYs/zgtPb3pvvwMP4YRFpau5t1Q2YvRx27YZyukYpkVzhY/plT4ZdhRCTIj3/E1y7LHHcvnll3PwwQfT0NAw5v1FixYxffp0Tj75ZAlhQoiiaEZj9WCaoaxOtd+Nd7Mth8Zj6TqZ9cvRYikMzcEjT/+HW2+/nmx202KgUz91Fhd870cEQ8P1C2/53YM8fP8SOtd10DK9jRMWLcblenfDhqmCQaqgUxvwMLPaT+VmRWGFEOL9eE8hzOVyccMNN7zjeXvuuSeJROK9fIQQYgeT183iRHjdtPGoypjhvIxmkNFMKn2u4nuZ/i7uveN21q7vom36bDq61vLQ0t8Vr6lvauX7V93IIYceXjymmxaxgsUxp55RMqfMtGyGshoep1rcggiGVzkOZXWcDgUvw5PwEzmdgFvlA9Mi1AU9OKTchBBigm3TPnWPx0NfX9+2/AghxCS3ceL9yoE0ed0i4nWyKpolq5koyvA2PxvPWx/LMZTVmVntp96rEF/9Bl//+td49c3Xi/ebv/ueKIqCbdscv/hzHH7mBTQ0VJd85mBGoz2apcrvYpe6YHF4cSirsSaaxe9WmV8XLAa9RG54bhpAnaoRVv3sUhekMeyVchNCiG1mm09s8PvHbvkhhNg5ZAoGb25IsSGVpybgoSHsxrJtAiP7MHqcm4YiFUXB71bRDAuS/cTWbODPf/5zSQADWPb6qxxzwsmcftbnaV6wD73JfPF+G3mcDkIeJ353aY0xj1PF71YJuNWSQqoOBTTToi7oZkbIydyWyq0aJhVCiPdDZpcKISacadn0JnOs6M9gWDYtFf5i6HEoCm1VfkzLHjMcOc0LoZ52jKEMeU3hX88+Pd7taZo+nb0/eCAAlT4Xzs2GCqv8bkIe55jjYa+T+XVBVIeCQ1GGhydzGrYNR8ypobXCRy6VkAAmhNguJIQJISZUMq+zejBDf1qjwufCP06gcSgKjlG1uSzLQuvvJtvdg6VbrI8nueqGy1m+7PUx1wK0TN9UamJLZSLe7rht28RzOjndpDHsYUaVn7B3eNJ+bqv/S4UQ4v2RECaEmBAby06sjmZwKAqN49T4Gve6bJpM+0r0TB7dULj3r3/mrjtvwTSMcc8fr9TEu5HVTOJ5nUqfk13rI1QH3FvVTiGEmGgSwoQQ79tQdngroVhOx+VQcTmUMcEmoxnopk3E60RRFCzTJNuzjnhnJ3nTw0A0ylXXX8aaVcuL18yevxvfv/IG2pe/WSw1cezJp5PSbUIOq6S3y7BsknmdgNuJZ9Rkemuk10t1KOR1C5eqsFtDkIaQF6cUWxVClJGEMCHEe6YZFh3RDOvjOdyqSsTrYtVABsuG2TWBYhkI3bRYE81SMCxmVfsJWQVSK99ET+dZk3Py0J9/x78evAvLGt7D0eV2c+oXLuDgRWdTVxfhA3vvW/zMtUNZepJ5poW9zKjatPCnL1VgfSxLTcDNnNpgyfHXNyRpCHpY2FpJa6VP5nwJISYFCWFCiHfNtm0GMxrPrYthM1zx3qU6KBjDvVOmbZdMilcUBbfqwDQM8l0dWP096AUn7rpmbvjR51iz7NXiuXvsvR8/vOZm1JpWhrIa6mY9ai7VgdfpGDPny+lQ8Iw6bts2sZxORjM5pK2a+fXB4rwvIYSYDCSECSHelaxm0B7NsjaWJeh2UhXYVEXe43QwtzaAZVMyJOh0KLS6NBLrV+HMZVCC1UTmtOKpDPGpc77Apd/4Ml6vj/Mv/j6Lzz4PVVUxLZu6kAffZnW6GsMeKv0uvJsdrwu6CXmdeFQHybxBWtOp8bvZvTFMld8l876EEJOOhDAhxFaxLJveZJ6VAxlMy6Ip7CuptbXR5j1UpqaT7VxNuruHv/3rcTak08zcdQEf23U+qtvJx087g+617Zx0+qdomTGzeJ3qUPA7xl9ZOd6Ky40hqz+dJ+R1sVdTBbUBt1S6F0JMWhLChBDvKJU3WDWYpi9doNLrxu9+5z0UbdtGGxok27mWXDzJN39yCW++tankxF//8iC/WLIUl8vFV779g/fVPs2wGMppuFUHu9aHaBgZHhVCiMlMQpgQYos2lp1YE82gKAoht5PxRvWymgmAf6RyvZnPk2lfRaw/gaU6+NV9vysJYADP//ff/Om+JZxyxpnFY7ppkdMtQp7SSveGZZPVzDGV7guGRXciR8DtZGZ1gOaIVybdCyGmDAlhQohxxbIaK/uHy05UBzwUDJM10SxOh8K82mBxT8WsZrJ6cHjfxVlVfhyJQXJd68mkNF6PZrnvd7/g1acfG/czVq1ZXfyzbdt0DGVJ5A1aK3zUhzzF97riOfrTBZoiPpoiXizbJpbVGcwUmF0dYE5dkKBHvs6EEFOLfGsJIUropsWawQwvdMaZFvbSGPaiKAoFw3zb68xCgeSKNbhyOWyHk8dff4mf3XQluUxqi9dMa53xrtuXzA+veKwLutmrOUKFT1Y8CiGmJglhQoiiaEZjxUCavmSBmdWBkt6lsNfFnJoAqkMp9oIBeFVoMhLk+rtxmRYD+QJX33wZLzz7n+I5tfWNRCorWb38reKxvfY/mNMXf7r4WhnZU3LjcORozRU+fC4V3TRxOJzs1RShNiiV7oUQU5uEMCEEBcOkYyjL+lgOn1NlVk1g3PM2H/LT02ky7auws1l8Ti9aJMLnTvwQ2UymeM6iT3+Or3/3UjxeHw/fv6RY+f6ERYtxuUp7sVzq2PpfumkxlNVwOhzsUhemMSyV7oUQOwYJYULsxGzbZiCtsXIgTVY3qfa7t2pVoWkY5Hu6Sa/rBsDX2Ihv2jScPg8nf/JM7rn957S2zeKSq25k3wMOLl538uIzt3TLMSzbZiirY1o2rZU+Wiv9+GTSvRBiByIhTIidVE43WTOYoTuRJ+hxEvGOX9A0r5uoDgWX6sC2bfRUmmzHKjKpLIYNlbPnEKyvwaEOB6QvfOM7BCsqOeu8r+D1+Yr30U0L07LHrF40LBvdtEoCVjKvkyoY1Ac9zKoJEJF5X0KIHdCkCWHJZJJf/OIXPPnkkyiKwn777cf5559PdXV1uZsmxA7Fsmw2pPKsGsygGxZ1QQ/xvM7qwRxBj5PZ1f5iGEvmdTqGsnicKm1hN1rPegoDAyTzBj+///f8959/Zq+F+3P97ffgUFUKhkVXVuGg08/DUjfVEjMse2TvSJO2Kn9x+6CNKyLTBYPWyuF5X/GsRsTnYt+WCmoCMu9LCLHjmjQTKz7ykY+QzWb56le/yuc+9zkeeeQRDjnkEAqFQrmbJsQOI10weGZdjEeX9+NWHdSFvKgOBdOy0QwL3bSwR51vWDYF3SITSxB/81UKG/pI5rOc87XP8fel95BJxnnqH49y5klHo+s6pj3cq2WYNoa16U62baOZFtrmxxnuIctqBhuSefK6yYKGEPu1VFAb9EgAE0Ls0CZNT9g//vEP/H5/8fWcOXPYY489eP3119l3333L2DIhpj7TsulN5ljenyaRN1jQEC4Z/qsJuHE6FLwuFceo4BNy2DSmNmDHh3C6XTzf0c5ll32XVDJRcv83X3mJh+9fwsmLz2RmdQDbtgl7N329uFQHs6r96KZNxFv6tRPyOPG7HOxSF6JlpDdMCCF2BpMmhI0OYABPPvkk4XCYtra2MrVIiB3Dxi2H+tMalT4XdUHvmHMcikKVf9PwoW1Z5IeGyKxux5XNk1YMbvj1L/jHow9v8XM613UAlISv0QLu0uPJvE5aM2mKeGmr8su8LyHETmfShDCAJUuWcOONN9Lf349t2/zrX/962zlhyWSSZDJZfN3b27s9minElGBaNl3xXHHLocbQ1g3v6dk82XXt6PE4OFSeWPEaN9145Zjer821TN+6fzDldJPYyLyvfZojMu9LCLHTmlQh7PDDD6etrY3u7m6uvvpqzjvvPJ544gl8o1ZYjXbttddy6aWXjjkei8W2eM1EGB38xPsjz3LijH6WGc2gM5YjnjeIeJw4HAp5Qxmz76Nh2ajK8HHLstBjCfIDGzB0A3c4xEsrlnP5Zd8tnl9dU8vXv3MJS39/Dy89/0zx+N4LD+DDx3yUfCpecn/LHp73pSrDn5XM66gOB9MjXqoDKo5CmqFJNu1TfiYnjjzLiSPPcmJsj+f4bhYUKrZt2+982vYXj8epq6vj1ltv5ayzzhr3nPF6whYuXEhnZyfNzc3brG3RaFRWbU4QeZYTJxqNEqmoZH0sS/tQDlVRqPK7GMho9Cbz1AY9TAtvGoocymp0xfOEvU6a3JDuWI2ZTpFRXPRHGqisqaStOsB5p3+M5/7zJCee9mmOP+9iKisraQm5eOSB39O5roOG5hnseviJOF0uZlYH8IxU09dNi46hLAXDotLnwq06aK70Mn2S1/uSn8mJI89y4siznBiT7TlOqp6w0SoqKvD7/QwODm7xnHA4TDgc3o6tEmLyShUMXlg1wIZUgV3rw8UwlNctknkD/2ZzsgqGRSJTQBsYIJAbQMGiv1Cgco89MVM6WcPGsuH7V1zPhp5u5ux1AKsG02Q1E1RfsfBqqmCwaiCNrptoplX8XMOyGUgXMCybuTV+5tSFZJ9HIYQYZVKEsOXLl/Pyyy9z+umnoygKlmVx3XXXkUqlOOaYY8rdPCEmNc2wWBfLsmJDkrwaYH5dqBiEAOpDHjxOR8mEeduyiZgaVb2r+Pdf/8wjQxtYP9DH88/8h6tuvYsPHHoMHqeKS3XQ2jaL1rZZWLbNzOoATodS0pMVdKtMr/IX/wzDBV7jOZ359SHm14eoDbhxOGTelxBCjDYpQlhjYyNXX301559/Pi0tLfT09BAKhbj33nvZY489yt08ISYl27aJZjRWDmZI5Q2qfG6CkeCY8zxOB/UhT/G1qRnkenpIdbZzxWXf59U3Xys5/6ff+yYPPnEoIW+k5LhDUagJuNmcoihUj6ysNCybaKaAqsC82iBNFd6t2gZJCCF2RpMihEUiEW6//XZuvPFGVq9eTXV1NdOmTZMVU0JsQV4f3nC7M57D71JpDHvJp/Jve41tWRTiKTIdKzCzOf70j0fHBDCAfT54EP7A2DD3tve2bRJ5g7xhMi08XHIi4JkUXy9CCDFpTapvSb/fLz1fQrwN27bpH9lwO6eZ1AQ9qFv4t4pt28V/yOi5ArmebvI9naA6eOLN17jj7l+Pe13T9Omoqjrufca7f3ak5ESV38WChgqq/OPvQSmEEKLUpAphQogty2oGKwfS9KU0Qh4nDWEvvck80axGU9jH6KIsA+kCfekCtX4X4VyG9JrVWHqa9mSGG2/7BW+9+PQWP6e5dVO9r6xusj6Ww6M6mF7lK1bTLxgWqwczZAo6M6sD7N4YoiHkxSlDj0IIsdUkhAkxyVmWTXcixxNrhnA4YH5dCHVkknsibzCY0ajwuvCNqvqQKhhsiGawu+OQ7gcHhOfO59EbbygJYNW1dUQH+ouv5+9zAMed+sni65xmMpTV8LtUdNOLx6lg2zYbknnSms7C6RXMrQ1N6pITQggxWUkIE2ISS+Z1Vg9maI9mCHpUWip8xQAGMC3sJex1UuVzQX646qmlG4QzKRpjnQTNDN6aCIFZ83F6fXz1ov/hP3//M26Xm0uuuoG9P3ggD9+/hHUd7UQaWjhx0WK8nk2T7yM+F21VftyqA4/TQUYzSOQNGsIeDp5ZRaV/7ER9IYQQW0dCmBCTkG5arI/l6BjKoioKc2qC486zCnudxdITuZxNIZkl17kekkOEzAyrYzEO/9BhxWurKyu45bd/pLl1Bt6RXSU21vsaj9Oh0Bj2opsWfakCHqfC7g0hGsLekjAohBDi3ZMQJsQkYts2gxmNVYMZkjmDmoAbt/Od51nl01n+8Ks76G5fxbT6eirqarjplp8TG4py34I9mTlnXvHc2fPmb3V7LNsmltUxLZvWkWr3Xhl6FEKICSEhTIhJIqsZdAzl6IrnCLhVpkW873iNbVmkB2N8+dMn8+obr4x7zrU/+h43333/u2qLbdukCgZpzaQu6GZmdUCq3QshxASTECZEmVmWTU8ix4qBDLZtUztSdqInmSejmTRHvCUT3/tSBZIFg1q3gjMW44G7b9tiADv8I8fz5e9ezqqBNFV+N9Wjiq2mCwa9qQJhj7OkmOtApkBHNMus6gB7N0WokWr3QgixTUgIE6KMknmdV7oTvNiVYJe6IE2R4XlaumkxkC6QzBuEPc5iCLNtm/5kjt6+JLoWpY4cy9csH/feRxx7Atfdfg/rYllWD2YBSkJYIm/QHc9RCLqpC7rRTJuhrIaiwEfm1dIQlpITQgixLUkIE6IMNk68b49miGZ05tYEqAtu6o1yqQ4aw14qfVZxGNC2bYysRjgew0puwO/S+NWf/sgjf3903M845IijAKjyu5ldAxXe0uHESr+LmdUBvC4H/RkNVYE5tQGaIl48Tpn3JYQQ25qEMCG2o833e6z2u6kPjT/3a3QoM3WDwmCSXM9aAnqOylof3ukLWHn9Vdi2Peba/Q48hBMWLQYg5HESGmcLIZ/TQdCjohkWTRU+ZlT6ZKshIYTYjuQbV4jtJKebtEezdCdy+JzD+z2+E9uy0DMFMuu7KfT34Qo5CExvwlPfgsOh8r2fXs+nTzySM8/7Kn6vh4HBQVqmt3HCosW4XFueSJ8uGCQKOrV+N7OmhaXelxBClIGEMCG2Mcuy2ZDKs2owg2ZY1AQ8OLdiorup6RSiCXLd6zD1LH9/4TGa5u/BEfseUDxnxqzZ/PW5N/EHguRTcbyhire9Z8Gwhivgu1U+MC1CXdAj9b6EEKJMJIQJsQ0l8zpvbUgylNOp8nmo9LmxbJueZB7Ltof3WxwJQRs35y7oBpW2iTXYjx4bYF3vOq665ecse+NVausbWXjokQRDYQCGshopzUGNy0Dd7HNjOZ1Kn5uw14lhDU+6NyybWVV+plf5t6r+mBBCiG1HQpgQ28DwxPssT7ZHiWcN9mutwO8ejklZzaQ7kce0bIJuZ3HifcGw6BxIMdA7SMc/fs9Q3zrW93bz/IsvYJkmAAN9vTz12N/5yMdOAYbLVfQmC6iKQs2oFBbN6KwZyjCz0sawLDTTYlrYy4wqP0GZ9yWEEJOCfBsLMcGiGY3Vg2kGMxpBl4uaWg8B96a/aj6XSl3QjWVBYCSYWYaJFU/j7u3i1z84nxXLXx9z39bZu/Ddn17H/gccWDxWE3DjdCiEvS7QC8XjEZ+TWr8b3bYIulVm1oSp9LnG3fpICCFEeUgIE2KCFAyTtUNZ1g3l8LpUWir8456nOhSmVw6/Z1s2eiZPvn+IbOd6/v3IfeMGsCOOPYErf/HrMZPta4MeakdWUeb1je2wKBgWbdV+Zo2UvpB5X0IIMflICBPifbJtm4G0xsqBNFndpDrgxrUVRU5NzUCLp8n39WLlYqzcsIJf/+6ucc+dMWv22652BDBt6EsXUBWYWxugKeKTeV9CCDGJyTe0EO9DTjd5c0OKl7sTgEJDyPuOAcy2LLRkjmxXH5m1K7ELMXy1Yfb+yEn4/IFxr2mZ3rbF+1m2TTSrkchpTAt7+WBrJW3VAQlgQggxycm3tBDvgW3bbEjm+Xd7lA3JPHVBD2GvE9MaPj6Y0cac35cq0BNNk9kQI93RTq6/HXdIpdA6i2T1bLzBCi65+iZq6xtKrt3ngIOLhVcBEjmdnmSegmGRzBtsSBWIeJ3sUh9iQUNICq4KIcQUId/WQrxLWc1g5UCaf62OEnQ72bs5UpxzlcjrrI3lcKsO/G4V/8iej8msxurOKIXBODMdCV57/Wlu/c0dXHXH78lrXrRcDrfTwYc/eiKHHnUsD977W155ayWRhmY+9enPFIcibdumK5GnJ5GnIeymrTrAXk0RagNuYrGhsj0TIYQQ756EMCG20sber5WDGRI5nYagh6DXWVJ41edSqfC5cKkKHtUxvN9jTsMaTODs6yHR28EVD/yK/z79XwCu+sFFfPeX92NYanGTbpfLxalnnMnCeI6sZhIJbKqsb1jDJSdmVPnYpzlCU4Vvq+afCSGEmHwkhAmxFbKawZpohu7E8NDfjKoAtm2PKfngc6nMqw2gKAqWYZBP5NCiUQr963jxH0u58/e/I5/PF8+PVFbR6LXxB4Il91KU4RWUGz/Dsm2GsjqmZbNfawXTK/3F0CaEEGJqkhAmxNswLZveZI5VA1kM26Z+VLmHLdbcskHP5Ej1RXn43l/x6mvP8+qytxgcHCye0tjUwrcvu5LDjv7oO7YhkdPJ6ib1IQ9tVX4ivrdfJSmEEGJqkBAmxBYkcjqrBzMMZDQqvK5ixfu3Y2oGWiJDuncDX7vgTN5cvqzkfYfDwWfOPZ9zL7gYfyD4tvdKFwySBYNKn5Nd6iPUBNxSbFUIIXYgEsKE2IxmWKwdyrJ6MIPPpdIY8qAoSnH/RZ9LJTRqBaJp2UTTBcgVcMWS6EO9PPLPB8YEMIAvfP0ivviN7zCU1chlNKr8pVXsEzmdVMEAIOx1skdjiPqQV4qtCiHEDkhCmBAjbNtmMKPxaneCF7sStFT4aK7wFd+PZjTWRDOEvU7m14WKwWgwkWX52ihqNs1MRwy/3yCq6eN+hqYVyGom62I5DMvGpQaGtxwCMgWDV3oSVPndHDi9kqYKKbYqhBA7MglhQjA88b59ZOJ93rCYFvEWN9beyON0EPQ4CbicOBSwTBM9mcPqi2H0tjMUXcceB+5OsGU+09/sGPdzWqa34VIV/C4V07ZxqY7ipHvDsjhydjVtNUGZdC+EEDsBCWFip7b5xPuN+yzqplVSegKgwuci4FZxKGDkNApDafR4lOef+DM33/4LTNvmwx97EYfbx4mLFvOXpffzwtNPFa/f78BDOGHRYlyqg9k1AWwgq5nEcgUaZNK9EELsdCSEiZ1WPKezeiDNYFanwucqFlYFtlh7S7UsCvEseiJF58pXuPn2G/jvs88W37/1uiv55iU/weV2c8vvHuTh+5fQua6DlultwwFspOiqblrEcjpBj1ostuqQeV9CCLFTkRAmdjqaYbEulmXtUA6nqhQn3r8d27LQMwXy/QlSPd388c93cc/9v6NQKBTPOezoj7L47HOLr10uFycvPrPkPqY1vM+jQ4F5tUGaKt55r0khhBA7JglhYqdh2zb9aY03epPkDbNks23dtEgVDIJuZ8lkeNOyiaVyONJ51EyG5556hBt/eSPrOzuL5zQ2tXDxj6/g8GOOw7Zt4jkdp0MhuNkejl3xLJppM7vGT1tVQPZ4FEKInZz8FhA7hXRheOL9K90JhrI6c2uDJT1QfakCnfEc9SEPM6sDwHDvV3dvguUd/bzwf3fxzON/Yt369cVrVNXJcZ8+l4u+8z+EgsM1vxL54c9xOhzMqwvicTrI6ybdyRw+p8rBbZVUS70vIYQQSAgTOzjdtOiO52kfymADFT43ls2YuluqQ8HjdOAa2e/RLOhosTTZ3n5uveTzrF7+Wsn5e+53AKd948fM2WU+fn+geNzpUHA6HLhUZaTnrYCiwF7TKmToUQghRAkJYWKHZI+UfVg1kCae16nyufG6VKr9NnUhD77N6m81hDxEfC7c2BSiaQqxFFY2yvP/vH9MAAP42KJPcsT+e+N0KCWBLuhxMrc2QFoziOV0GsPDPWubD00KIYQQ8ptB7HDyuknHUJbO+PAQ4LTwpoKrDkUpWQVZZINL08nHMvStWsMdd17HaZ/4GP2pxLif0bW+Y9xaXsMlJzQqfS5mNQZkqyEhhBBbJCFM7DAsa3j4b+VAmoJhURPwjKn1NZ7h/R6zFGIpHl76G277zS0kkkl641GOO3Ux8Jsx17RMbyt5rRkWQzkNj9PB7o0hGkJenDL0KIQQ4m1ICBM7hHTBYPVAmvahHPVBN/Uhb/E93bTI6RZBj4pjVK+Ubpgkh7KouTwrX32e6274EW+N2u9x9coV7LVwf/Y94OCSoqv7HHAwJyxaDAyvnhzKaRQMkzk1QVoqfHil2r0QQoitICFMTGmmZdMVz7F6MEP7UAYFhQqfi9Coc9bHc0QzGi0VPmq8Dv50/xLWt7fjDdbSNP+DPHnfzfzz7w9jWVbxmoOO/wTnfPP7zJrTWiy6unLVatzV0zjm46fjUFWGshqaaVEfHJ73FfLKXychhBBbT35riClrY8X7gczwHKwKr5tUwdji+bqmce5Zp/PiM/8pHnOoKpZpFl/P23V3zv3e/xJq241IwA1sKro6mNFYO5RFsxU2pPLUBjzMrAlT6XPJvC8hhBDvmoQwMeXopsW6oSwdIxXvp4W9KIpCW5WfgmkRdJcOB7ZW+Kjxu3n0d78pCWBAMYAFQ2G+9K3vctqZ5+BQVdIFE5+rdE6X3+Wg0uekJuBmTm2QuqBHthoSQgjxnkkIE1NKNKOxciBNImdQE3CXVLd3Ox0lrzdSLQt3Js+6FSvHveesufP55b0PUVNXXzwWHjW0qJsWQ1kNp8PB3s0VTItIvS8hhBDvn4QwMSUUjOGyE+tjI2UnIt53vMa2bPRsnkIsQ0/7GhqqguOe96nPf7EkgG1k2TaxrI5h2bRW+mit9I9blkIIIYR4LySEiUlt436Py/tSpAoGjeHSXijdtDAse0w40vI66WiK9W+9wbXX/IDOrnXcc+dt/Ovpp3jp+eeK5+134CGcsGgxtm2TMyy8TgcORSGZN0hrBvVBNzOrA0R8ru323yyEEGLnICFMTFob93tcH88xkNJwqQ6q/FYxhJmWTcdQlqxmMqPKT4XPhW1ZaKksL73awe/v/hlPPnpvcdXjbx/8Gz+47Y88eN9vyQ50M3/uHE5YtBiXy0VvMk9vMk/Y6yLgVgl6VPZqilAbcMu8LyGEENvEpAphg4ODvPbaa0QiEXbbbTc8Hk+5myTKwDAtuhN51kSH93usDXiIZw0Ma7jXayMb0E0bbaQ3zMhrFIbS/GXpfdz48ytIxoeK586cM4/DPnI8tkNl/+NOo6XCR3PFpkr6mmHRn9EIeZ3Mqw3KPo9CCCG2uUkRwmKxGOeffz6PPfYYu+66K11dXeTzee655x4OOeSQcjdPbEexrMayvjTJvE6l310cZpxZ7cewbCKjJsw7HcMrInMFHX+hwOsvvcy111zCa6+9VDzH5/fzxW98h8VnfxGXy4VmWMN1xEb2crRtm2TeQHUoHDO3ltk1AQKyz6MQQojtYFL8tkmlUhx33HHcddddqKqKbducd955nHrqqfT29uJwSI/Ejk4zLNYOZVkXy+JSHTSOlJ3YaLwNsG3bxqUbZDYMcPVNV7B06RJMa1PNr4987BQu/P5l1DdOKx5zOx1UOYfrf+V0k1hWo9LvYmF9BdWyz6MQQojtaFKEsNbWVhYvXlx8rSgKp512Gr/85S/p6uqitbW1jK0T25Jt2wykC6zsT5PWTGoC7q0aBsynsyy9+04617ZTV13Nv//912IAmzlnHt/5ydUsPOhD415rWDbRrIZTUZhfH6IpIvs8CiGE2P4mRQgbzxNPPEE4HKapqWmL5ySTSZLJZPF1b2/v9miamCBZzaBjKMugaRJwOWkMl5adMC0bG0o24bYti/RQki+fuYhXX9m0ynFm23T8/gBf+MZ3+NTZ5+FybVrNaNs2hmXjdCgk8gZ5w6Qp4qOtyoffPWn/CgghhNjBTcrfQM888wxXXHEFV1xxBaq65bpM1157LZdeeumY47FYDJ/PN84VE2N08BPvnm3bDGY0OuN5cukUWcVDxqHgjHiLgcuwbHoSeSxsGkNePE4Hpm4y0NnLxRd9heVvvFRyz/aOdXzugu+w8COnkEgkCXo2/dz0pzUGMwX8bpXGkIc5FX5CzgK5lEZuu/6Xb1vyczkx5DlOHHmWE0ee5cTYHs+xurp6q8+ddCHstdde4/jjj+ecc87ha1/72tuee+GFF3LOOecUX/f29rJw4UIqKyvf1UN4L7b1/XdUqbzB6sE0G3ImlZFKnA6FgayK06Hg8AXxjmw5lNVMMmkHhmXT4PZh5fMsvWcJt95yNclkfNx7D8SSJPBS4wngDQ2vrDUtm56hGB6fm4Uzq2mu8O3QQ4/yczkx5DlOHHmWE0ee5cSYTM9xUoWw119/nSOPPJJFixZx0003veP54XCYcDi8HVom3i/DtOiK53irP43X6aAx5MWhKCgulZlVfhQF/KP2fPS7VVorvOg5jeX//jfXXvkDVqx4820/Y9d5c5hdE6DK7y6ueszqJvu3VjJLVj0KIYSYZCbNb6U333yTI488klNPPZWf//znskptBxLP6aweSDOY0ajxu/GOqm6vKFAdcI+5xtINcus7ufnqn/DIow+UvHfCKYtYv249r77wbPHYfgcewqJPfgqXy0VWM4nnNCp8Lvauj1Ajqx6FEEJMQpMihHV1dXHkkUdSX1/P0UcfzUMPPVR879BDD6WysrKMrRPvlW5arI/laI9mcanKmLIT47Etm1wixZLbbuFXt91AJpsuvjd/wW585/Jr2HPf/dF1nYfvX0Lnug5aprdxwqLF4FDpSxVwqQq7NYZoCMmqRyGEEJPXpAhh8Xic/fffH4A777yz5L1dd91VQtgUFM1orBxIE8/p1AY8uJ2lYci27TGBzNQMCrE0V132XR544J7i8YqKCr5y8ff4+BmfKy7UcLlcnLz4TGB4qDOe1zEti+mVPlorfSW9bUIIIcRkNClC2G677caDDz5Y7maICVAwzOGiq0M5rJF5WYZl01rhK4aunG6yLpYb7h1zMbLfY45MLMPaaJaFR3+Mhx++F9M0OfX0T/LFb/+YGF5WRXNMr/QVq+hblsWbfWkKhsneTRFm1gQIe2WjbSGEEFPDpAhhYurbWHZiZX+ajG5SHXATy+kMZXV008YI27jUTSEsntNxqw7c8SH+ePXVaPkC1fWNtO17AMGaAF/9xjfZ75APM/8D+5LVTRJ9aTTToi44vJVRqmAQy2nUhzx8YFpYqt0LIYSYciSEifctp5us6k+zZihDbcBLQ2i46Gqlz8XMaj8ep6OkCn7E66Il5Oaph5fyhUsuQNe14nu777knP7n1Lg764EXF7ar8LpXWSh+GaeFWHfQm8wTcKvs0V1AX9KA6JHwJIYSYeiSEiffMsmw2pPKsGsygGRbTKwMl1e037gE5mm3ZtL/xBldd+j88+8yTY+75+quv8uK/n2D6yHyvjSJeJ9GMRsGw2KUuyLSId6u2NxJCCCEmKwlh4j1J5nVWD2boTxeIeF1U+saWmdhcfHCIW66+nPuW/BrTNLZ4Xue6juKfLdtmKKtjWjYzqvy0jJoTJoQQQkxlEsLEu6KPFF1dE83iUBQaRoquvh3TMFh6913cfM1lxGLR4vGKigjxeGLM+S3T24DhoJfRTOpDHtqq/ER8MuleCCHEjkPGc8RWsW2baEbjhc44KwbSKCjEshrRjFZyXlYzWTWYoTeZB6CzvYMzjj2CH3/vgmIA83m9fOm8z/Onfz3FXvvtX3L9fgcewlEnnUZXPEfesNirKcKe08ISwIQQQuxwpCdMvKOcbrKyP01fuoDXqTIt7KMrnqMznsewbGqDnuK5ybxOTyJPhUclrGm40jbxocHi+ws/dDjfvvhbzNx9IYrq4qe/uJN7/rCUwZ717DZvNkec+Ak028Gu9T6aKnwy70sIIcQOS0KY2CLTstmQzPNiVwLLtmmt9Bcn3lf6Xcyq8RP2DPdQ6ZrGn+5fQkf7GkI1TRx1xPGYeSf+gJevnH8+v7nzDj7zpa+yz2EfpbG2plhOIhTw8olPn0m6YFLlc9JS6Wd6pQ+/W340hRBC7NjkN50YVzyns2Yww0BGoy7oKdlcGyDgdhIYCUq6pnHe4o/zwtNPFd9/+v8e4PobbsFpDXHYIXtzxLFH462dgaKW/sgVDBOnU2FOTYCZ1X4q/e88wV8IIYTYEUgIEyU0w2J9PEdHNItTVWgMed6xCOodN19bEsAAXn75Wf7yp9/w8VNPxV0zD9UXKnk/r5vEcjoeG/ZqqqA24MYh9b6EEELsRCSECWBUxfuBNOmCSU3A/Y7zsZKJOLdc878s+dWt476/YSiNt2lXFMemHzPTsolmNRQF5tUG8ZkO6kOeca8XQgghdmQSwgRZzaA9mqU7kSfgduJ3qfQk81T53YQ8m35EUgWDoaxGyOXgsQd/x81X/JjYUHSL922auwedCR2vy6Qu6CGR08nqJtPCHtqqAwQ9TqLR3Pb4TxRCCCEmHQlhOzHTsumO53i1J4nXrRa3AFo1kGZ9PM/sGkpC2FBW42//fJw///wy1q54s3jc4/HiD4eJDfQXj+134CEcfNyptMeyeJ0O8iP7Se5dH6FG9nkUQgghJITtrBI5nWV9Kd7sSzGj0l9SZqJqZHJ8hbe0NlfY5eCZ+39VEsA+cswxfPr0EzGqZ/HyS6+QHOyjZXobJyxaTN5S8KR1aoNudmsI01QhWw0JIYQQG0kI28mUTLx3KOzbXDGmV6o64KY6sGmVom3ZGNk87niOb37pIj797OPMmTOPr3/5LHadMxNP03xc4Xo+sM8Bw+fbNrGcjmaa7D+9graqAAGP/KgJIYQQo8lvxp2EbdsMpDVWDQ5PvK/2u3E7t9wrZds2jzz4B7DhsAM+TCGZRXU5aZ3dyi9v+QWzW2twBSrxNM7D4fYVr0vmDTK6QY3fzcxqPxU+lww9CiGEEOOQELYTyBQMOoYydCcKBNxOGsPetz3/leef4X++ei7d69fi8/vZ5dePUN1Qh+pKo+QGmTe7GXf9bJzBTUVXs7pJIqcR8rr4wLSIlJwQQggh3oGEsB2Yadn0JHKsHsxi2jZ1QQ+pgkFPMk/tZiUoknmDdV1d/Pb6n/DI0vuKx3PZLOd/67PcccdtRDBQvCG89bPRcDGQKuBVHWimhUt1sGt9iIawzPsSQgghtoaEsB1ULKvxfGecWEZjRnUAn0vFtGw64zkSeR0H0DDSI5bP5bj5umtZesfNaPnsmHt1r+/ggT//hXO/dD5qoApFUeiPZXmlJ0lblZ99WiLMqPTjdaljrhVCCCHE+CSE7WDyusnaWJZXuhKkNZMFDSF8I+HIoUCFz4XqUPC7ndi2zd8eXsp1P/kBvV2db3vfREbDGawGhuuFFQyTw2ZVsVtjhAqf622vFUIIIcRYEsJ2EJZl058usGowQ163mFMbxOlQSibFK4pCS4UP27ZRFIU/3beE71/wxeL7TqeTvfb5IM8/+58x999l3lw0wyKa1Qi4VQ5qq6Yu6JF5X0IIIcR7JJN3dgDJvM5rvUle6UmgKgr1IQ8u1bHFVYmKomBbFocfcSzTprUAcNBBR7Dkvoe55n8vYa8P7FFy/r4HHMKBHz2FeF5ndk2Aha2VNIS9EsCEEEKI90F6wqYwzbDojOfoGMriUBQaQl4cWwhe+VyOZ596gkOP+ghGQUePZ7AzGt/85o9QPSof3HsOtpZAcXu4ZclS/vJ//0fnug5qm6Zz8HGnUhcJMKs6QMgrPzJCCCHERJDfqFPQlmp+xXM6hmVT5XfhUBR0TeOh+5bwr78/yqvPP0MqEeOu+x9lZtNsbN0kpyrM2W8fKux+bD2Js6IRV2UzOUthv49+gv1sm4jPxZzaIHVB2WpICCGEmEgSwqaYdMHgrQ0pXupOMKPKz7SRFY453WTtUBbNtFCVIEGnzadP+DDL3ni15Prr//eH3HjT3TgDKj19XQxlMsysDtI6fRdUXwjLtnmjJ4Ft2xw2s5rpVf63LeoqhBBCiPdGQtgUYVo23YkcK/pTtA/liHicVPs3bS3kdCj43Sou00FioJevfPmsMQEMYN+FB+L06diZbvyKiVVVT7i5GYfXSyKnk9FN9mwMMa8uSNgrqx6FEEKIbUVC2BQQz+msHkgzkNGo8rtZ2DLc+6WOmhjvUh1M88FvfnEjd99yE/l8btx75TP92Mm1KN4ws+bNwHYF0E2b3mSeCp+Lfeoj1ARk6FEIIYTY1iSETWK6abEuNrLZtqowLezdYjiKDw1x6lEHMrCh923v2dRYi6u2DWe4Ht1SGMpquFUHuzWGaAh5cUq1eyGEEGK7kN+4k5Bt2wymCzzfGWfNYIZKn4tq/9v3TlVUVbHbnnsD4Ha7+eTp57DHnvuWnLP3Pnvx8XMuwBFuZDBnEM/rtFX52X96Jc0VfglgQgghxHYkPWGTTE43WTOQoSeVx+dUi5ttJ3I6iqIQHikR0bWug4amFrIGWJZF0AHnnXMhqqnwhS9cSHVLK3l9iH8/vISeng20ztuNE8/4PEMapKNZ5tT6aauSkhNCCCFEuchv4EnCsmw2pPL8pyNGXyrPfq2Vxe2Gosksd919JwPd65kzo4WB7vXce+ftfOPSK9jl8JPRMnmasajxVnPJJdeiBBSW96ynkM9y6PGn0NA6hxwuBnM6btXBobOqqJZ5X0IIIURZSQibBJJ5ndWDGTqGssRzGnUhL66RoUFd0/jGZ0/l5XG2EvrlNZfz43kH4XR4cFX5CFRFwBxCT/TjRsVR24qroZ6+PPhcFns0hmkIe0sm9AshhBCiPCSElZFuDle8b48OV7yfVR2gJeJDdSg4R4LSQ/ctGTeAuVxuTj3508wKePBWhAj4bYzYKhTbwB2sYm5LK9GCAxuF2TV+miu8eJzq9v5PFEIIIcQWSAgrA9u2iWY0Vg1mSOYNqvxuPCMFUb2uTUFp2RuvctuNV417jxNP+ARnnvVlXAEXdmED2oYunIFKXDWzyahhMrrJtIiHmdV+qfclhBBCTEISwraznG7SHs3SnciVTLzf3BU/uJjf/epWbNse9/25u+6GO2hjRF/H0gu4q1qxKloY0BWCTtirKSJbDQkhhBCTmISw7WTjxPsV/WkMy6Ym4MHpULBtm7Rm4lYdxd4wgNr6hmIA83p9JcVXP7DP/hz+4QMpdD6LM1SDu3EBScWPrsPsaj+tlbLVkBBCCDHZSQjbDpJ5nWUbUjzbGafS52KPxnCxh2oop9MxkMJhauw5o6E4af74M87moQce4KAPf4wzjj+Zxx/7PzYM9FDf3Ejb7nvQ3tPNLjPnYVe1kDAVGoJuZlYHpeSEEEIIMUXIb+xtSDct1sdydAxliWY0fC61WHZio+f//Rg3/uQHzFnwAa792a0AmLqBnTH51k/vwqmALxzk1M98GivTTXKwm7UFJ9TtQdxfSa3LxV4NAWpl6FEIIYSYUiSEbQO2bTO4ceJ9zqAm4KY24CZVMHHaBg8suZPXX3qB1156njUrlwPQ076SVV/+MjOnz0WLZ/FpBrMrvHiCXvzuPFasAyOXItQwkwZnPS63i3m1AZorfMVyFkIIIYSYOiSETbBMwaBjKEN3okDArTItsmnivc9h8blTj+e1F58fc90H9v0g2lCWlNWP6nHiCvmoCjgwk50YqQSK04MxbW/Sqo8ZEQ9tVQGCHvl/nxBCCDFVyW/xCWJaNj2JHKsHsxi2TV3QU1IUNZtJc/GXzh43gJ1y+me44Kvfx9ItbMvCU+nHoWQwB7uxsTAiLaTdNVQEPOxaE6BGqt0LIYQQU56EsAkQy2qsHMgQzRSoDniK875s2yZnWDzzz0f5yXcuYLC/b9zrvaoX27RxBbwYbhMjvR5HIYnlCZMONuPyBti1OsC0iFeGHoUQQogdhISw90EzLNYOZXm9N0l3Is/smkDJxPv+tEZ3IkdG8WwxgAE0t87AU+knmY3S3t6DW4HGxhbsYC3NlQFmVPoIyNCjEEIIsUOR3+zvgW3b9KcKrBxIk9FMANxOB4Y1XNcrn8vh9fkwLJuCYbHL3vtz+DHH4fZ46V7XwRuvvlS81977HsDHT1+ElWqnkEiStv04ww3Mralnbl2QKr9Lhh6FEEKIHZCEsHdJNy06olmitkXQ7aQx7EU3LaoDbjKDvfzPJT9h1bI3+f1fn6Q+5MHnchBwO/npTXdgpwukNgzxyKNLWT/YS9ucWXz8+A9jx9dg4sCumsH8YDW7NYZpCHlxytCjEEIIscOaNCGsUCjwxz/+kdtvv52enh6eeeYZKioqyt2sMVIFg4GMRmNdpDjxPpdOcufN17LkjlvQCgUAHrrvt5z8yc9Q6XWipXIYyRyWbuINBfjEWefg9JoYsXUYqQ0k1AjOqlZm1VUyvdI/ppaYEEIIIXY8kyaEfeITn8Dv93PooYfywx/+EMMwyt2kLXIoCqpDQSsUuO+uO/jl9VeSiMeK71fV1OLxeDHyGlosjZHXwQbV68IVdGPlNqD39ZOxnGRDM5lW18Cs2iAVPtloWwghhNhZTJoQdt999+HxeHj00UfL3ZR3ZFkWjzz4B2766Y/o7lxXPO71+fnMuefzyc99ER9Ocv0JbMNCUR24Ql4s8hjRFeTzWZLOSiqmzWC/xirqgh4cDpn3JYQQQuxMJk0I83g85W7CVlmxfBlf/8ynWfXW68VjDoeDj3/y05z79W9jqAGWt8eo8ao0BN04fR5cQSfRwU46+gZRXG5mtMxhQfM0Wipko20hhBBiZzVpQth7kUwmSSaTxde9vb3b/DOrqqrpWtdefL3foUfx7Ut+TFvbHLREho6eJLFkDp/iw9MaxEEGfWAVG6J5Ms4IB82fzYKWGql2L4QQQuzkpnQSuPbaa7n00kvHHI/FYvh8vm3ymW63i1M/dRbPP/UkZ33tIg488ECUgkGyswfbNKny2PibfYTDLgpDq8mlE2Rw09zUwkENdUS8TgrpBIX0NmnelDM6RIv3R57lxJDnOHHkWU4ceZYTY3s8x+rq6q0+V7Ft296GbXnXHn30UY499lgGBgaoqal523PH6wlbuHAhnZ2dNDc3b5P2DWU1/vtGO83TGrA0Ay2WxcxrgI3icuIK+1CsFIXBtQzldFzhOubNnE1LTVhKTowjGo2+qx9YsWXyLCeGPMeJI89y4siznBiT7TlO6Z6wcDhMOBze7p+rqip6IouWzGFbNooDnAE/Lh9oQ6uJJ+JoaoAZs+cxu2UafveUfsxCCCGE2AYkHbxLlmaQj6bIOnRUnwvV48Id8WHmo6S6uhnKG9TUN7PvrDlUh/1S7V4IIYQQ45o0IezKK6/kV7/6FZlMBoADDjgAVVW58cYbOfroo8vcuk0swyKb06kK+nCH/ahem651b7JmIMP0mhD77LEbzQ31MvQohBBCiLc1aULYWWedxYknnjjmeFNTUxlas2WKAyyvi2BrFWZ2gJ7VHQxpTg7ZrY0Fc+bg906NUhtCCCGEKK9JE8Jqa2upra0tdzPekep1Ew6qDK5/hXQ6TVN9HQfN3ZWqqskz0U8IIYQQk9+kCWFThZlNYgysRvV72P8De9LYPAOHKo9RCCGEEO+OpId3KeBxMbepjrnz98ATjJS7OUIIIYSYomT2+LvkD0WYNnNXCWBCCCGEeF8khAkhhBBClIGEMCGEEEKIMpAQJoQQQghRBhLChBBCCCHKQEKYEEIIIUQZSAgTQgghhCgDCWFCCCGEEGUgIUwIIYQQogwkhAkhhBBClIGEMCGEEEKIMpAQJoQQQghRBhLChBBCCCHKQEKYEEIIIUQZSAgTQgghhCgDCWFCCCGEEGUgIUwIIYQQogwkhAkhhBBClIGz3A2YSIZhANDb27tNPycWi5HL5bbpZ+ws5FlOHHmWE0Oe48SRZzlx5FlOjO31HBsaGnA63zli7VAhbGBgAICFCxeWuSVCCCGE2Fl1dnbS3Nz8jucptm3b26E920U+n+f111+ntrZ2qxLoe9Hb28vChQt57rnnaGxs3CafsbOQZzlx5FlODHmOE0ee5cSRZzkxtudz3Cl7wrxeL/vtt992+azGxsatSrnincmznDjyLCeGPMeJI89y4siznBiT6TnKxHwhhBBCiDKQECaEEEIIUQYSwt6lcDjMJZdcQjgcLndTpjx5lhNHnuXEkOc4ceRZThx5lhNjMj7HHWpivhBCCCHEVCE9YUIIIYQQZSAhTAghhBCiDCSECSGEEEKUgYQwIYQQQogy2KGKtW5rTzzxBL/97W9Jp9MccsghfP7zn99mlfl3ZLqus3TpUv74xz+yyy67cOmll5a7SVOSZVk88MADPPbYY+RyOfbZZx/OPvtsfD5fuZs25ei6zpIlS3jyySdRFIX99tuPz3zmM/Is3wdN0zjvvPMYGhri97//PV6vt9xNmlIefvhh7rjjjpJjqqryxz/+sUwtmtrS6TS33347zz//PI2NjZx//vnMmDGj3M2SELa17r33Xj71qU9x8cUXs9dee3HVVVfx97//nQceeKDcTZtS4vE4u+++O/vvvz89PT1Eo9FyN2nKOvLII6mtreWwww7D6/Vy4403ctttt/Hf//6XQCBQ7uZNKYcffjgLFizgQx/6EJlMhuuvv55f//rXPPXUU/IPrffo4osv5vHHH6ejowPDMMrdnClnzZo1vPzyy9xwww3FYw6HDF69F729vRx66KHU1dVxzjnnkM/n+fjHP84TTzxR/nIVtnhHpmnaTU1N9re//e3isRdeeMEG7CeeeKKMLZt68vm8vWHDBtu2bfvMM8+0jzzyyDK3aOrq6ekpeT0wMGA7nU77rrvuKlOLpq6BgYGS1y+++KIN2C+++GKZWjS1/fnPf7Z32WUX+84777QBO5VKlbtJU851111nL1iwoNzN2CGccsop9p577mkXCoXisVQqZWuaVsZWDZNYvRVee+01uru7OeWUU4rH9tlnH9ra2njkkUfK2LKpx+PxUF9fX+5m7BA234C2srISn89HIpEoU4umrpqampLXK1aswOv1Mm3atDK1aOrq6enh85//PPfccw9+v7/czZnS+vr6+MxnPsPZZ5/NL37xCzRNK3eTppxYLMbSpUv5yle+gtvtLh4PBoO4XK4ytmyY9LNvhY6ODgBaWlpKjre0tBTfE6LcfvWrX5HNZvnwhz9c7qZMSQ899BC//vWv6e/vp6+vj0ceeYSGhoZyN2tKsSyLM844g69+9avss88+8v34PiiKwiGHHMJhhx1GOp3m2muv5ZZbbuHpp5+WcPsuvPHGG1iWxbx58/jud79Le3s7M2fO5Nxzz6W1tbXczZPVkVujUCgAjPnBDwaD5PP5cjRJiBJPP/00X/va1/jxj3/MLrvsUu7mTEkLFizgzDPPZPHixbhcLq644gp0XS93s6aUyy67DNu2ueiii8rdlCnvs5/9LA888ACf+9zn+OpXv8p//vMf1q9fz4033ljupk0pmUwGgDPPPBNVVTn++ONZtWoVu+66K8uWLStz66QnbKtEIhFguFszFAoVj0ejUebPn1+uZgkBwPPPP8+xxx7Ll7/8Zb7zne+UuzlT1uzZs5k9ezYAp556Ks3Nzdx///0sXry4zC2bOq6//nrmzZvHySefDAwPTQJ88pOf5IwzzuD0008vZ/OmlI2/dzaqq6vjgAMO4IUXXihTi6amiooKYPhn8Ec/+hEAixcvZs899+S6667jl7/8ZRlbJyFsq+yxxx4AvPrqq8XuS03TWLZsGaeddlo5myZ2ci+++CJHH300Z599NldddVW5m7PDaGhoIBQK0dnZWe6mTCl33313Se/h008/zfPPP88ZZ5zBBz7wgfI1bAcRj8fLv5pvilmwYAEul6v4DywYHuqdOXMmfX19ZWzZMBmO3ApNTU0cccQRXH/99cWl1rfeeiuFQoFFixaVuXViZ/Xyyy9z1FFHcfbZZ3PNNdeUuzlTVnt7O//6179Kjt1zzz3E43EOPfTQMrVqajruuOM46aSTiv/bb7/9ADj++ONlmPxduvPOO0sm4i9dupRnnnmGj33sY2Vs1dQTCoU45ZRT+MMf/lD8/d3d3c2///1vDjrooDK3TnrCttrtt9/OMcccw5w5c6ivr+eNN97g9ttvp7m5udxNm3LOOeccBgcHeemll8jn85x00klShPA9OPnkk8nlcqxevZqTTjqpePykk07is5/9bNnaNdWEw2GuvfZazj33XGbOnElXVxcbNmzg5ptvZv/99y9388ROqqurqzhEHo/HWbFiBT/+8Y/55Cc/We6mTTk33XQTH/3oR5k7dy6zZ8/mueee45hjjuGCCy4od9NQbNu2y92IqcIwDJ599lnS6TT77rsv1dXV5W7SlPTXv/6VXC5XcszhcHDiiSeWqUVT0yOPPFJcNDLanDlzWLBgQRlaNLWtX7+e5cuXU11dzfz582UF2gTo6enhueee44QTTkBV1XI3Z8pJJBK88soreDwe5s+fP2aemNh6tm3z0ksvEY1GmTNnDm1tbeVuEiAhTAghhBCiLGROmBBCCCFEGUgIE0IIIYQoAwlhQgghhBBlICFMCCGEEKIMJIQJIYQQQpSBhDAhhBBCiDKQECaEEEIIUQYSwoQQQgghykBCmBBCCCFEGUgIE0IIIYQoAwlhQoidWiKR4MEHH6S7u7vk+BtvvMFDDz2EpmllapkQYkcnIUwIsVMLhUL88Ic/5Atf+ELx2NNPP83+++9PR0cHbre7jK0TQuzIZANvIcRO71//+hdHHHEEjz32GBUVFRx++OFcdNFF/M///E+5myaE2IFJCBNCCOCkk05i9erV9PX1ce6553LZZZeVu0lCiB2cDEcKIQSwePFi3nzzTQ499FAJYEKI7UJ6woQQO71XXnmFww8/nObmZgYHB1m1ahXBYLDczRJC7OCkJ0wIsVNbtmwZRx99NGeffTZPPfUUhmFw+eWXl7tZQoidgPSECSF2WmvWrOFDH/oQJ5xwArfccgsAN9xwA9/+9rdZvnw506dPL3MLhRA7MglhQoidkmmafOMb38DtdnPFFVegKAoAuq5z1llncdhhh3HOOeeUuZVCiB2ZhDAhhBBCiDKQOWFCCCGEEGUgIUwIIYQQogwkhAkhhBBClIGEMCGEEEKIMpAQJoQQQghRBhLChBBCCCHKQEKYEEIIIUQZSAgTQgghhCgDCWFCCCGEEGUgIUwIIYQQogwkhAkhhBBClIGEMCGEEEKIMpAQJoQQQghRBhLChBBCCCHK4P8BqIkSKgDshs8AAAAASUVORK5CYII=", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -423,79 +568,66 @@ } ], "source": [ - "draws_gp = np.column_stack([gp_walker.model_sampler.chain, theta_chain])\n", - "\n", - "band_gp = rxmc.predictive.total_predictive_band(\n", - " model.y,\n", - " kernel,\n", - " x,\n", - " y,\n", - " xg,\n", - " draws_gp,\n", - " n_model_params=model.n_params,\n", - " noise_std=noise,\n", - " levels=(16, 84),\n", - " n_draws=300,\n", - " rng=rng,\n", + "fig, ax = plt.subplots()\n", + "for name, colour, hatch in (\n", + " (\"statistics only\", plotstyle.COLOURS[1], plotstyle.HATCHES[0]),\n", + " (\"proportional error\", plotstyle.COLOURS[3], plotstyle.HATCHES[1]),\n", + "):\n", + " lo, hi = mean_band(problems[name], samples[name])\n", + " plotstyle.band(\n", + " ax, x_fine, lo, hi, color=colour, hatch=hatch, label=f\"{name}: model only\"\n", + " )\n", + "plotstyle.band(\n", + " ax,\n", + " x_fine,\n", + " *band_gp,\n", + " color=plotstyle.COLOURS[0],\n", + " hatch=plotstyle.HATCHES[2],\n", + " label=\"GP, growing amplitude: model + discrepancy\",\n", ")\n", + "ax.plot(x_fine, truth(x_fine), \"--\", color=\"k\", label=\"truth\")\n", + "ax.errorbar(data.x, data.y, data.y_err, fmt=\"o\", ms=3, color=\"k\")\n", + "ax.set(xlabel=\"$x$\", ylabel=\"$y$\", title=\"68 % bands\", ylim=(0.5, 6.5))\n", + "ax.legend(fontsize=8)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "58b57dfa", + "metadata": {}, + "source": [ + "### Which of those belongs next to the data?\n", "\n", + "The band above shows the model and its discrepancy. A real measurement also carries its own experimental error, and only the sum of the two predicts what a *measurement* would read. `predictive_draws` at the measured points includes every term by default, which is why that's the one we use for a [coverage](https://en.wikipedia.org/wiki/Coverage_probability) check, and why we don't use the band from `grid_draws` for it.\n", "\n", - "def mean_line_band(walker, levels=(16, 84)):\n", - " chain = walker.model_sampler.chain[:, : model.n_params]\n", - " return rxmc.predictive.predictive_band(\n", - " np.array([model.y(xg, *p) for p in chain]), levels=levels\n", - " )\n", + "How much of the band is the discrepancy? We can split it. At $x = 0.2$ the band's 68 % half-width is 0.12, of which the line's own parameter uncertainty is 0.088 and the discrepancy alone 0.076; at $x = 5$ the three are 0.43, 0.33 and 0.29. So the band is roughly half line and half discrepancy all the way along, the two added in quadrature. The experimental error, a flat 0.02, is small next to both, so the measurement predictive and the model-plus-discrepancy band are nearly the same curve here. The choice of terms matters when the terms are comparable in size; in `alpha_ca_error_model_comparison` the inferred noise and the discrepancy are, and there a coverage check run against the wrong object would tell us nothing.\n", "\n", - "\n", - "band_plain = mean_line_band(walkers[\"line only\"])\n", - "band_me = mean_line_band(walkers[\"line + model error\"])\n", - "\n", - "fig, ax = plt.subplots(figsize=(8, 5))\n", - "ax.plot(xg, truth(xg), \"k:\", lw=2, label=\"truth\")\n", - "ax.errorbar(x, y, noise, ls=\"none\", marker=\".\", color=\"k\", alpha=0.6, label=\"data\")\n", - "for (lo, hi), c, lab in [\n", - " (band_plain, \"tab:blue\", \"line only (68% mean band)\"),\n", - " (band_me, \"tab:orange\", \"line + model error (68% mean band)\"),\n", - " (band_gp, \"tab:green\", \"line + GP discrepancy (68% total predictive)\"),\n", - "]:\n", - " ax.fill_between(xg, lo, hi, color=c, alpha=0.3, label=lab)\n", - "ax.set_xlabel(\"x\")\n", - "ax.set_ylabel(\"y\")\n", - "ax.legend()\n", - "ax.set_title(\"Only the GP discrepancy band follows the non-linear structure\");" + "How should we read a coverage check here? The discrepancy's length scale comes out at about 3.5 (68 %: 2.3 to 4.4), pressed against the top of its prior, the 4.8 the data span: the data would take a longer one if we let them. At that length, the thirty residuals are close to a single correlated draw rather than thirty independent checks: one realisation of a smooth curve tends to sit inside the band, or outside it, more or less as a whole. Pointwise coverage on one dataset like this carries little information; coverage over many independent datasets would carry more. Keep that in mind for the count below." ] }, { - "cell_type": "markdown", - "id": "c15", + "cell_type": "code", + "execution_count": 13, + "id": "30f35b57", "metadata": {}, + "outputs": [], "source": [ - "## What the GP actually captured: the correlated residuals\n", - "\n", - "The smoking gun for model discrepancy is **structure in the residuals** $y -\n", - "y_m(x)$ — a good (well-specified) model leaves white noise. Conditioning the GP on\n", - "those residuals (`rxmc.predictive.gp_posterior_predictive`) recovers a smooth\n", - "discrepancy that matches the true mismatch `truth(x) - line(x)`." + "lo_d, hi_d = np.percentile(draws_data, [16, 84], axis=0)\n", + "inside_d = np.mean((data.y >= lo_d) & (data.y <= hi_d))" ] }, { "cell_type": "code", - "execution_count": 9, - "id": "c16", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:08:12.463263Z", - "iopub.status.busy": "2026-08-11T03:08:12.463090Z", - "iopub.status.idle": "2026-08-11T03:08:12.747816Z", - "shell.execute_reply": "2026-08-11T03:08:12.747122Z" - } - }, + "execution_count": 14, + "id": "21bc61b5", + "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -503,84 +635,132 @@ } ], "source": [ - "mp_mean = gp_walker.model_sampler.chain.mean(axis=0)\n", - "theta_mean = theta_chain.mean(axis=0)\n", - "residuals = y - model.y(x, *mp_mean)\n", - "\n", - "disc_mean, disc_cov = rxmc.predictive.gp_posterior_predictive(\n", - " kernel, theta_mean, x, residuals, xg, train_noise_var=noise**2\n", + "fig, ax = plt.subplots()\n", + "plotstyle.band(\n", + " ax,\n", + " data.x,\n", + " lo_d,\n", + " hi_d,\n", + " color=plotstyle.COLOURS[2],\n", + " hatch=plotstyle.HATCHES[0],\n", + " label=\"model + discrepancy + experimental\",\n", ")\n", - "disc_sd = np.sqrt(np.clip(np.diag(disc_cov), 0.0, np.inf))\n", - "\n", - "plt.figure(figsize=(8, 4))\n", - "plt.axhline(0.0, color=\"0.7\", lw=1)\n", - "plt.plot(x, residuals, \"k.\", label=\"residuals $y - y_m(x)$\")\n", - "plt.plot(xg, truth(xg) - model.y(xg, *mp_mean), \"k:\", label=\"true discrepancy\")\n", - "plt.fill_between(\n", - " xg,\n", - " disc_mean - disc_sd,\n", - " disc_mean + disc_sd,\n", - " color=\"tab:green\",\n", - " alpha=0.3,\n", - " label=\"GP discrepancy (68%)\",\n", + "plotstyle.band(\n", + " ax,\n", + " data.x,\n", + " np.interp(data.x, x_fine, band_gp[0]),\n", + " np.interp(data.x, x_fine, band_gp[1]),\n", + " color=plotstyle.COLOURS[0],\n", + " hatch=plotstyle.HATCHES[2],\n", + " label=\"model + discrepancy\",\n", ")\n", - "plt.plot(xg, disc_mean, color=\"tab:green\")\n", - "plt.xlabel(\"x\")\n", - "plt.ylabel(\"discrepancy\")\n", - "plt.legend()\n", - "plt.title(\"the GP recovers the correlated residual structure\");" + "ax.errorbar(data.x, data.y, data.y_err, fmt=\"o\", ms=4, color=\"k\", label=\"data\")\n", + "ax.set(\n", + " xlabel=\"$x$\",\n", + " ylabel=\"$y$\",\n", + " title=\"With and without the experimental errors (68 %)\",\n", + ")\n", + "ax.legend(fontsize=8)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "6b2e05c6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "fraction of the measured points inside the 68 % predictive: 1.00\n" + ] + } + ], + "source": [ + "print(f\"fraction of the measured points inside the 68 % predictive: {inside_d:.2f}\")" ] }, { "cell_type": "markdown", - "id": "c17", + "id": "6771e3c7", "metadata": {}, "source": [ - "## Takeaways\n", - "\n", - "- A GP discrepancy is **just another covariance `Term`** — `kernel_term`\n", - " (a `kernel_term`) added to the constraint. Its hyperparameters become\n", - " constraint parameters and are sampled like any other nuisance.\n", - "- The kernel term only inflates the covariance at the data points. To predict the\n", - " discrepancy at new $x$, use `rxmc.predictive.gp_posterior_predictive`; to get a\n", - " full data-space band that propagates model, discrepancy, and noise uncertainty,\n", - " use `rxmc.predictive.total_predictive_band`.\n", - "- Uncorrelated model error (`model_error_term`) inflates the variance but cannot\n", - " represent correlated mis-modelling; the GP can." + "All thirty measured points land inside the 68 % predictive interval. That does not tell us the predictive is too wide by an amount we can read off: the thirty residuals are close to one correlated draw, as above." ] }, { "cell_type": "markdown", - "id": "6e491de1", + "id": "7f6aebb1", "metadata": {}, "source": [ - "# GP discrepancy on a differential cross section\n", + "## The departures the data allow\n", "\n", - "The same machinery on real reaction physics: we generate mock\n", - "$n + {}^{40}$Ca elastic scattering data from a **full** optical potential\n", - "(volume + surface absorption), then fit it with a **deficient** potential that\n", - "has no surface term. The missing physics leaves a smooth, *angle-correlated*\n", - "residual — exactly what a `kernel_term` over the angle grid absorbs.\n" + "Because this is synthetic data, we know the defect exactly. We can take each draw of the model plus its discrepancy, subtract that draw's own line, and look at the discrepancy $\\delta$ on its own. We drew it mean-zero, so what comes back isn't an *estimate* of the defect: it's the envelope of departures from the line that the data are willing to allow. We compare it with the truth minus the posterior-median line. That is not $0.03\\,x^2$ itself, because the fitted line has already absorbed part of the curvature by tilting and shifting.\n", + "\n", + "The envelope contains the truth minus the line over 81 % of the data's range (68 % of the whole grid, which runs out to $x = 6$, past the last point), and it is centred on zero. Where the departure is small, below $x \\approx 3$, it sits comfortably inside. Beyond $x \\approx 4$ the true departure grows faster than the envelope does, and leaves it. A mean-zero discrepancy describes how far the model *may* stray, as learned from the data, and here it learned a little too little about the far end.\n", + "\n", + "When our question is \"where is my model wrong?\", this is the honest thing to look at. A conditioned GP (`gp_predictive_draws(..., conditioned=True)`) would thread through the residuals and hug them instead. That would look far more impressive, but it would be answering a different question, one whose answer depends mostly on where the data happen to sit." ] }, { "cell_type": "code", - "execution_count": 10, - "id": "a2cefc08", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:08:12.749919Z", - "iopub.status.busy": "2026-08-11T03:08:12.749754Z", - "iopub.status.idle": "2026-08-11T03:08:24.846032Z", - "shell.execute_reply": "2026-08-11T03:08:24.845346Z" + "execution_count": 16, + "id": "940dde08", + "metadata": {}, + "outputs": [], + "source": [ + "p_cols = p_grow.columns(line.params)\n", + "line_median = line.bind(x_fine)(*np.median(s_grow[:, p_cols], axis=0))\n", + "disc_lo, disc_hi = np.percentile(draws_delta, [16, 84], axis=0)\n", + "true_departure = truth(x_fine) - line_median\n", + "resid = data.y - line.bind(x)(*np.median(s_grow[:, p_cols], axis=0))" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "7a96ab0c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "fraction where truth minus the line lies inside the 68 % envelope: 0.81 over the data's range, 0.68 over the whole grid (out to x = 6)\n", + "inside the data's range it leaves the envelope beyond x = 4.1\n", + "envelope is centred on -0.002\n" + ] } - }, + ], + "source": [ + "inside = (true_departure >= disc_lo) & (true_departure <= disc_hi)\n", + "in_range = (x_fine >= x.min()) & (x_fine <= x.max())\n", + "print(\n", + " \"fraction where truth minus the line lies inside the 68 % envelope: \"\n", + " f\"{np.mean(inside[in_range]):.2f} over the data's range, {np.mean(inside):.2f} \"\n", + " \"over the whole grid (out to x = 6)\"\n", + ")\n", + "leaves = x_fine[in_range][~inside[in_range]]\n", + "if leaves.size:\n", + " print(\n", + " f\"inside the data's range it leaves the envelope beyond x = {leaves.min():.1f}\"\n", + " )\n", + "print(f\"envelope is centred on {np.mean(0.5 * (disc_lo + disc_hi)):+.3f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "e1b7d5ba", + "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -588,26 +768,59 @@ } ], "source": [ - "import jitr\n", - "from jitr.optical_potentials.potential_forms import (\n", - " thomas_safe,\n", - " woods_saxon_prime_safe,\n", - " woods_saxon_safe,\n", + "fig, ax = plt.subplots()\n", + "ax.errorbar(x, resid, noise, fmt=\"o\", ms=3, color=\"k\", label=\"residuals of the line\")\n", + "plotstyle.band(\n", + " ax,\n", + " x_fine,\n", + " disc_lo,\n", + " disc_hi,\n", + " color=plotstyle.COLOURS[0],\n", + " label=\"departures allowed (68 %)\",\n", ")\n", + "ax.plot(\n", + " x_fine,\n", + " true_departure,\n", + " \"--\",\n", + " color=plotstyle.COLOURS[1],\n", + " label=\"truth minus the median line\",\n", + ")\n", + "ax.set(xlabel=\"$x$\", ylabel=\"$y -$ line\", title=\"The departures the data allow\")\n", + "ax.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "1a4be8ce", + "metadata": {}, + "source": [ + "## The same thing on a cross section\n", + "\n", + "Now let's try a real physics model with a real piece of physics missing. We generate mock $n + {}^{40}\\mathrm{Ca}$ elastic scattering data at 14.1 MeV from an [optical potential](https://doi.org/10.1016/S0375-9474(02)01321-0) with both **volume and surface** absorption. Then we fit those data with a potential that only has volume absorption. The missing surface term is our structured defect.\n", "\n", - "from rxmc.params import Parameter\n", + "There are two differences from the toy. First, we compare in log space, so the discrepancy is a *fractional* defect as a function of angle. Second, we drive the fit with [pocomc](https://pocomc.readthedocs.io/) ([Karamanis et al. 2022](https://doi.org/10.1093/mnras/stac2272)) rather than emcee (recipe 16). Optical-model posteriors tend to be strongly correlated and can be multimodal, and an affine-invariant ensemble sampler mixes poorly on them. [preconditioned Monte Carlo](https://pocomc.readthedocs.io/en/latest/background.html) copes much better, and it hands us the evidence as a by-product. We run it at eight times its default resolution: on `n40ca_gp`, the benchmark's copy of the GP rung below, that setting is within the reference's resolution on every seed, while at twice the default two seeds of three are 0.3 to 0.4 posterior standard deviations off ([benchmarks](/benchmarks.md)).\n", "\n", - "Ca40 = (40, 20)\n", + "This half of the notebook gets its own random generator, so changing anything in the toy above leaves the cross-section data untouched." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "9cf85214", + "metadata": {}, + "outputs": [], + "source": [ + "rng_xs = np.random.default_rng(2024)\n", + "reaction = jitr.reactions.ElasticReaction(target=(40, 20), projectile=(1, 0))\n", "E_lab = 14.1\n", - "rxn = jitr.reactions.ElasticReaction(target=Ca40, projectile=(1, 0))\n", + "R40 = 40 ** (1 / 3)\n", "mso = 1.0 / jitr.utils.constants.WAVENUMBER_PION\n", - "R40 = 1.2 * 40 ** (1 / 3)\n", - "fixed_spin_orbit = (6.0, -3, R40, 0.45)\n", "\n", "\n", "def full_central(r, Vv, Wv, Rv, av, Wd, Rd, ad):\n", - " return -(Vv + 1j * Wv) * woods_saxon_safe(r, Rv, av) + (\n", - " 4j * ad * Wd\n", + " return -(Vv + 1j * Wv) * woods_saxon_safe(r, Rv, av) - 1j * Wd * (\n", + " -4 * ad\n", " ) * woods_saxon_prime_safe(r, Rd, ad)\n", "\n", "\n", @@ -615,206 +828,289 @@ " return -(Vv + 1j * Wv) * woods_saxon_safe(r, Rv, av)\n", "\n", "\n", - "def spin_orbit_potential(r, Vso, Wso, Rso, aso):\n", - " return (Vso + 1j * Wso) * mso**2 * thomas_safe(r, Rso, aso)\n", + "def spin_orbit(r, Vso, Rso, aso):\n", + " return Vso * mso**2 * thomas_safe(r, Rso, aso)\n", "\n", "\n", - "omp_full = rxmc.elastic_diffxs_model.ElasticDifferentialXSModel(\n", + "so_args = (6.0, 1.1 * R40, 0.45)\n", + "full_truth = np.array([48.0, 3.5, 1.1 * R40, 0.7, 21.0, 1.2 * R40, 0.5])\n", + "volume_truth = full_truth[:4]" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "0f3057a0", + "metadata": {}, + "outputs": [], + "source": [ + "full_params = [\n", + " rx.Parameter(n, prior=stats.norm(0, 1))\n", + " for n in (\"Vv\", \"Wv\", \"Rv\", \"av\", \"Wd\", \"Rd\", \"ad\")\n", + "]\n", + "omp_full = rx.reactions.ElasticXS(\n", " \"dXS/dA\",\n", - " interaction_central=full_central,\n", - " interaction_spin_orbit=spin_orbit_potential,\n", - " calculate_interaction_from_params=lambda ws, *x: (tuple(x), fixed_spin_orbit),\n", - " params=[\n", - " Parameter(n, unit=u)\n", - " for n, u in [\n", - " (\"Vv\", \"MeV\"),\n", - " (\"Wv\", \"MeV\"),\n", - " (\"Rv\", \"fm\"),\n", - " (\"av\", \"fm\"),\n", - " (\"Wd\", \"MeV\"),\n", - " (\"Rd\", \"fm\"),\n", - " (\"ad\", \"fm\"),\n", - " ]\n", - " ],\n", - " model_name=\"full_potential\",\n", + " full_central,\n", + " spin_orbit,\n", + " lambda ws, *x: (tuple(x), so_args),\n", + " full_params,\n", + " lmax=10,\n", ")\n", - "omp_vol = rxmc.elastic_diffxs_model.ElasticDifferentialXSModel(\n", + "volume_params = [\n", + " rx.Parameter(\"Vv\", prior=stats.norm(48.0, 8.0), latex=\"V_v\"),\n", + " rx.Parameter(\"Wv\", prior=stats.norm(4.0, 4.0), bounds=(0.0, 30.0), latex=\"W_v\"),\n", + " rx.Parameter(\"Rv\", prior=stats.norm(1.15 * R40, 0.2), latex=\"R_v\"),\n", + " rx.Parameter(\"av\", prior=stats.norm(0.65, 0.1), bounds=(0.3, 1.2), latex=\"a_v\"),\n", + "]\n", + "omp_vol = rx.reactions.ElasticXS(\n", " \"dXS/dA\",\n", - " interaction_central=volume_central,\n", - " interaction_spin_orbit=spin_orbit_potential,\n", - " calculate_interaction_from_params=lambda ws, *x: (tuple(x), fixed_spin_orbit),\n", - " params=[\n", - " Parameter(n, unit=u)\n", - " for n, u in [(\"Vv\", \"MeV\"), (\"Wv\", \"MeV\"), (\"Rv\", \"fm\"), (\"av\", \"fm\")]\n", - " ],\n", - " model_name=\"volume_only_potential\",\n", - ")\n", - "\n", - "full_truth = np.array([48.0, 3.5, 1.1 * 40 ** (1 / 3), 0.7, 21, R40, 0.5])\n", - "volume_truth = full_truth[:4] # the deficient model's share of the truth\n", - "\n", - "obs_xs = rxmc.elastic_diffxs_observation.ElasticDifferentialXSObservation(\n", - " x=np.linspace(5.0, 160.0, 25),\n", - " y=np.ones(25),\n", - " Elab=E_lab,\n", - " reaction=rxn,\n", - " quantity=\"dXS/dA\",\n", - " measurement_quantity=\"dXS/dA\",\n", - " y_units=\"barn / steradian\",\n", - " dataset_label=\"mock elastic dataset\",\n", + " volume_central,\n", + " spin_orbit,\n", + " lambda ws, *x: (tuple(x), so_args),\n", + " volume_params,\n", + " lmax=10,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "b6343957", + "metadata": {}, + "outputs": [], + "source": [ + "angles = np.deg2rad(np.linspace(5.0, 160.0, 25))\n", + "meta = {\"reaction\": reaction, \"Elab\": E_lab}\n", + "y_full = omp_full.bind(angles, meta)(*full_truth)\n", + "y_xs = y_full * (1 + rng_xs.normal(0.0, 0.04, angles.size))\n", + "d_xs = rx.Dataset(angles, y_xs, 0.04 * y_xs, label=\"n+40Ca 14.1 MeV\", meta=meta)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "c07ec26a", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "ax.errorbar(\n", + " np.rad2deg(angles),\n", + " d_xs.y,\n", + " d_xs.y_err,\n", + " fmt=\"o\",\n", + " ms=3,\n", + " color=\"k\",\n", + " label=\"mock data (full potential)\",\n", ")\n", - "y_true_xs = omp_full.evaluate(obs_xs, *full_truth)\n", - "stat_xs = 0.04 * np.maximum(y_true_xs, 1e-4)\n", - "obs_xs.y = np.clip(y_true_xs + rng.normal(scale=stat_xs), 1e-6, None)\n", - "obs_xs.y_stat_err = stat_xs\n", - "\n", - "plt.errorbar(\n", - " np.rad2deg(obs_xs.x), obs_xs.y, stat_xs, ls=\"none\", marker=\".\", label=\"data\"\n", + "ax.plot(\n", + " np.rad2deg(angles),\n", + " omp_vol.bind(angles, meta)(*volume_truth),\n", + " color=plotstyle.COLOURS[1],\n", + " label=\"volume-only potential, at the true volume parameters\",\n", ")\n", - "plt.plot(\n", - " np.rad2deg(obs_xs.x),\n", - " omp_vol.evaluate(obs_xs, *volume_truth),\n", - " \"tab:red\",\n", - " label=\"deficient model at the true volume params\",\n", + "ax.set(\n", + " xlabel=r\"$\\theta_{cm}$ [deg]\",\n", + " ylabel=r\"$d\\sigma/d\\Omega$ [b/sr]\",\n", + " yscale=\"log\",\n", + " title=\"The missing surface absorption\",\n", ")\n", - "plt.xlabel(r\"$\\theta$ [deg]\")\n", - "plt.ylabel(r\"$d\\sigma/d\\Omega$ [b/sr]\")\n", - "plt.yscale(\"log\")\n", - "plt.legend();" + "ax.legend(fontsize=8)\n", + "plt.show()" ] }, { "cell_type": "markdown", - "id": "f1652855", + "id": "c3199959", "metadata": {}, "source": [ - "## The discrepancy term acts on the angle grid\n", + "### Three of the four rungs\n", "\n", - "The kernel's input coordinate is `obs.x` — the scattering angle **in radians**\n", - "— so the `length_scale` is an angular correlation length. Everything else is\n", - "identical to the toy section.\n" + "We'll fit three of the toy's four error models: bare, an uncorrelated proportional error, and a mean-zero GP whose amplitude grows with angle. We leave out the constant-amplitude GP: on the toy, one amplitude for the whole range had to compromise between where the line is good and where it is not. The growing amplitude carries the same prior belief as in the toy: we trust the model at forward angles and are suspicious of it at backward ones. The priors follow the same rules: the length scale log-uniform between the angular spacing and the range, in radians, and the growth slope centred on zero." ] }, { "cell_type": "code", - "execution_count": 11, - "id": "1f0df948", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:08:24.847679Z", - "iopub.status.busy": "2026-08-11T03:08:24.847514Z", - "iopub.status.idle": "2026-08-11T03:08:24.851771Z", - "shell.execute_reply": "2026-08-11T03:08:24.851045Z" - } - }, + "execution_count": 23, + "id": "2ee90995", + "metadata": {}, + "outputs": [], + "source": [ + "comp_xs = rx.Comparison(d_xs, omp_vol, space=tf.log)\n", + "xs_gamma = rx.Parameter(\n", + " \"log_gamma_xs\", prior=stats.norm(np.log(0.05), 1.0), latex=r\"\\log\\gamma\"\n", + ")\n", + "xs_amp = rx.Parameter(\"log_A_xs\", prior=stats.norm(np.log(0.05), 1.5), latex=r\"\\log A\")\n", + "xs_slope = rx.Parameter(\"amp_slope_xs\", prior=stats.norm(0.0, 1.5), latex=r\"s_A\")\n", + "xs_spacing, xs_span = np.diff(angles).min(), angles.max() - angles.min()\n", + "xs_ell = rx.Parameter(\n", + " \"log_ell_xs\",\n", + " prior=stats.uniform(np.log(xs_spacing), np.log(xs_span / xs_spacing)),\n", + " latex=r\"\\log \\ell\",\n", + ")\n", + "gp_xs = T.kernel(\n", + " matern,\n", + " params=[xs_ell],\n", + " jitter=1e-6,\n", + " amplitude=T.exp_growth_amplitude(np.pi),\n", + " amplitude_params=(xs_amp, xs_slope),\n", + ")\n", + "xs_problems = {\n", + " \"bare\": rx.Problem([rx.Constraint([comp_xs])]),\n", + " # in log space a constant noise is an error proportional to the cross section\n", + " \"proportional error\": rx.Problem(\n", + " [rx.Constraint([comp_xs], terms=[T.noise(xs_gamma)])]\n", + " ),\n", + " \"GP, growing amplitude\": rx.Problem([rx.Constraint([comp_xs], terms=[gp_xs])]),\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "8c902ca0", + "metadata": {}, + "outputs": [], + "source": [ + "def smc(problem, seed, n_effective=budget(4096), n_active=budget(2048)):\n", + " \"\"\"pocomc on the unit cube: ``prior_transform`` maps it onto the prior, so\n", + " the evidence is the problem's own. Eight times pocomc's default\n", + " resolution, the setting at which the benchmark's runs of the GP rung below\n", + " are all within its reference's resolution (docs/benchmarks.md).\"\"\"\n", + "\n", + " def log_likelihood(u): # every particle in one vmapped call\n", + " return problem.log_likelihood_batch(problem.prior_transform_batch(u))\n", + "\n", + " sampler = pocomc.Sampler(\n", + " pocomc.Prior([stats.uniform(0.0, 1.0)] * problem.ndim),\n", + " log_likelihood,\n", + " n_effective=n_effective,\n", + " n_active=n_active,\n", + " vectorize=True,\n", + " random_state=seed,\n", + " )\n", + " sampler.run(n_total=budget(4096), n_evidence=budget(4096), progress=False)\n", + " u, _, _ = sampler.posterior(resample=True) # equal-weight draws\n", + " logz, logz_err = sampler.evidence()\n", + " return {\n", + " \"samples\": problem.prior_transform_batch(u),\n", + " \"logz\": logz,\n", + " \"logz_err\": logz_err,\n", + " \"calls\": sampler.calls,\n", + " }\n", + "\n", + "\n", + "xs_results = {name: smc(p, 10 + i) for i, (name, p) in enumerate(xs_problems.items())}\n", + "xs_samples = {name: res[\"samples\"] for name, res in xs_results.items()}" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "26258f3e", + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "GP hyperparameters: ['discrepancy_k1__k1__constant_value', 'discrepancy_k1__k2__length_scale', 'discrepancy_k2__noise_level']\n" + "bare log Z = -467.21 +/- 0.01, 299008 likelihood calls\n", + "proportional error log Z = 91.12 +/- 0.01, 231424 likelihood calls\n", + "GP, growing amplitude log Z = 103.91 +/- 0.04, 292864 likelihood calls\n", + "proportional error against bare: Delta log Z = 558.3 +/- 0.01, favours proportional error\n", + "GP, growing amplitude against proportional error: Delta log Z = 12.8 +/- 0.04, favours GP, growing amplitude\n" ] } ], "source": [ - "kernel_xs = ConstantKernel(1.0) * Matern(length_scale=0.5, nu=2.5) + WhiteKernel(1e-6)\n", - "\n", - "c_vol_plain = rxmc.constraint.Constraint([obs_xs], omp_vol)\n", - "c_vol_gp = rxmc.constraint.Constraint(\n", - " [obs_xs],\n", - " omp_vol,\n", - " extra_terms=[rxmc.covariance.kernel_term(kernel_xs)],\n", - ")\n", - "print(\"GP hyperparameters:\", [p.name for p in c_vol_gp.params])" + "# every rung compares in the same space (log), so the Jacobian is common to all\n", + "# three; we add it anyway, so the numbers are the evidence for the cross section\n", + "evidence = {\n", + " name: rx.diagnostics.logz_summary(\n", + " res[\"logz\"] + xs_problems[name].log_jacobian(), res[\"logz_err\"]\n", + " )\n", + " for name, res in xs_results.items()\n", + "}\n", + "for name, res in xs_results.items():\n", + " mean, err, _ = evidence[name]\n", + " print(\n", + " f\"{name:22s} log Z = {mean:8.2f} +/- {err:.2f}, {res['calls']:7d} likelihood calls\"\n", + " )\n", + "for a, b in (\n", + " (\"proportional error\", \"bare\"),\n", + " (\"GP, growing amplitude\", \"proportional error\"),\n", + "):\n", + " v = rx.diagnostics.compare_logz(evidence[a], evidence[b])\n", + " print(\n", + " f\"{a} against {b}: Delta log Z = {v['dlogZ']:.1f} +/- {v['err']:.2f}, favours \"\n", + " + {\"a\": a, \"b\": b, \"tie\": \"neither (a tie)\"}[v[\"verdict\"]]\n", + " )" ] }, { "cell_type": "code", - "execution_count": 12, - "id": "1059d23b", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:08:24.853287Z", - "iopub.status.busy": "2026-08-11T03:08:24.853128Z", - "iopub.status.idle": "2026-08-11T03:08:58.711360Z", - "shell.execute_reply": "2026-08-11T03:08:58.710543Z" - } - }, + "execution_count": 26, + "id": "2f8e7c6e", + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 33.9 s, sys: 2.23 ms, total: 33.9 s\n", - "Wall time: 33.9 s\n" + "bare:\n", + " Vv = 26.820 [26.411, 27.245] (pull -50.9) Wv = 16.626 [16.391, 16.859] (pull +55.9) Rv = 4.431 [4.409, 4.452] (pull +31.6) av = 0.659 [0.653, 0.665] (pull -7.2)\n", + "proportional error:\n", + " Vv = 29.984 [27.487, 32.801] (pull -6.3) Wv = 18.182 [16.819, 19.657] (pull +10.3) Rv = 4.277 [4.153, 4.391] (pull +4.4) av = 0.690 [0.655, 0.725] (pull -0.3)\n", + "GP, growing amplitude:\n", + " Vv = 43.797 [42.463, 45.357] (pull -2.7) Wv = 13.637 [12.686, 14.601] (pull +9.6) Rv = 4.288 [4.221, 4.347] (pull +8.0) av = 0.487 [0.466, 0.511] (pull -8.8)\n" ] } ], "source": [ - "%%time\n", - "vol_prior = stats.multivariate_normal(\n", - " mean=np.array([50.0, 3.0, 1.2 * 40 ** (1 / 3), 0.65]),\n", - " cov=np.diag([7.0, 7.0, 0.2, 0.2]) ** 2,\n", - ")\n", - "\n", + "for name, p in xs_problems.items():\n", + " print(f\"{name}:\\n {summary(p, xs_samples[name], volume_params, volume_truth)}\")" + ] + }, + { + "cell_type": "markdown", + "id": "56cddf05", + "metadata": {}, + "source": [ + "### What the three rungs did to the potential\n", "\n", - "def make_vol_sampler():\n", - " return rxmc.param_sampling.BatchedAdaptiveMetropolisSampler(\n", - " params=omp_vol.params,\n", - " starting_location=vol_prior.mean,\n", - " prior=vol_prior,\n", - " initial_proposal_cov=vol_prior.cov / 100,\n", - " )\n", + "The [evidence](https://en.wikipedia.org/wiki/Marginal_likelihood) $Z$, the probability each error model assigned to the data before fitting, is blunt about the bare fit: $\\log Z$ goes from $-467$ to $+91$ once we allow an uncorrelated proportional error. The difference of two log evidences is the log of a [Bayes factor](https://en.wikipedia.org/wiki/Bayes_factor), and a gap of hundreds isn't a mild preference, it's a verdict: the bare fit's claim that the reported 4 % errors explain every disagreement is simply false. The GP's advantage over the proportional error is smaller but clear, $\\Delta\\log Z = 12.8$, a Bayes factor of about $4 \\times 10^5$. The errors quoted are pocomc's own from a single run, a lower bound, but at these sizes they could be ten times larger without changing either verdict.\n", "\n", + "The parameters tell a more mixed story, and we should read all four rather than pick one. Each comes from a single pocomc run. Three runs with other seeds (the [benchmark](/benchmarks.md)'s `gp_seed_check`) move each $\\log Z$ by at most 0.06 and every median by at most 0.16 of its 68 % half-width, and the GP rung's medians lie within 0.12 posterior standard deviations of the benchmark's reference for it.\n", "\n", - "theta_prior_xs = stats.multivariate_normal(\n", - " mean=np.zeros(c_vol_gp.n_params), cov=4.0 * np.eye(c_vol_gp.n_params)\n", - ")\n", + "- The bare fit is confidently wrong everywhere: $V_v$ at 26.8 MeV against a truth of 48, 51 standard deviations out, and $W_v$, $R_v$ and $a_v$ between 7 and 56 standard deviations out.\n", + "- The proportional error widens the answer about sixfold, and is still wrong: $V_v$ at 30.0 MeV is 6 standard deviations out, $R_v$ 4 and $W_v$ 10; only $a_v$ lands on the truth.\n", + "- The GP gets $V_v$ much closer (43.8 MeV, 2.7 standard deviations out), but it is *more* confidently wrong than the proportional error on the geometry of the volume term: $R_v$ is 8 and $a_v$ 9 standard deviations off, and $W_v$ 9.6.\n", "\n", - "walker_vol_plain = rxmc.walker.Walker(\n", - " make_vol_sampler(), rxmc.evidence.Evidence([c_vol_plain]), rng=rng\n", - ")\n", - "walker_vol_gp = rxmc.walker.Walker(\n", - " make_vol_sampler(),\n", - " rxmc.evidence.Evidence([c_vol_gp]),\n", - " likelihood_samplers=[\n", - " make_nuisance_sampler(\n", - " c_vol_gp.params, theta_prior_xs, 0.04 * np.eye(c_vol_gp.n_params)\n", - " )\n", - " ],\n", - " rng=rng,\n", - ")\n", - "for w in (walker_vol_plain, walker_vol_gp):\n", - " w.walk(n_steps=5000, burnin=1500, batch_size=500, verbose=False)" + "The data were generated with volume **and** surface absorption, and we fitted a potential with only volume absorption. At a single energy the two shapes are hard to tell apart, so the fit reshapes the volume term to imitate the missing surface term — a much deeper volume absorption ($W_v$ 13.6 MeV against 3.5) with a smaller diffuseness — and none of the three error models can undo that. This is an honest limit of the method. A discrepancy model describes how far the model may be wrong, and it improves the evidence, but it cannot recover information the measurement never contained, and it does not make the parameters of a model with missing physics trustworthy." ] }, { "cell_type": "code", - "execution_count": 13, - "id": "0fcd16d6", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:08:58.713058Z", - "iopub.status.busy": "2026-08-11T03:08:58.712866Z", - "iopub.status.idle": "2026-08-11T03:08:59.631340Z", - "shell.execute_reply": "2026-08-11T03:08:59.630582Z" - } - }, + "execution_count": 27, + "id": "9f34319b", + "metadata": {}, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "no discrepancy Vv=32.20±1.17 Wv=22.95±0.67 Rv=4.28±0.05 av=0.66±0.01\n", - "GP discrepancy Vv=44.56±2.89 Wv=17.74±1.27 Rv=4.17±0.14 av=0.60±0.05\n", - "truth Vv=48.00 Wv=3.50 Rv=3.76 av=0.70\n" - ] - }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -822,67 +1118,110 @@ } ], "source": [ - "for name, w in [\n", - " (\"no discrepancy\", walker_vol_plain),\n", - " (\"GP discrepancy\", walker_vol_gp),\n", - "]:\n", - " ch = w.model_sampler.chain\n", - " print(\n", - " f\"{name:16s} \"\n", - " + \" \".join(\n", - " f\"{p.name}={ch[:, i].mean():.2f}±{ch[:, i].std():.2f}\"\n", - " for i, p in enumerate(omp_vol.params)\n", - " )\n", + "labels = [f\"${q.latex}$\" for q in volume_params]\n", + "fig = None\n", + "xs_colours = [plotstyle.COLOURS[i] for i in (1, 3, 0)]\n", + "for (name, p), colour in zip(xs_problems.items(), xs_colours):\n", + " fig = corner.corner(\n", + " xs_samples[name][:, p.columns(volume_params)],\n", + " fig=fig,\n", + " labels=labels,\n", + " truths=volume_truth,\n", + " **plotstyle.corner_kwargs(\n", + " color=colour,\n", + " fill_contours=False,\n", + " plot_density=False,\n", + " show_titles=False,\n", + " hist_kwargs={\"density\": True},\n", + " ),\n", " )\n", - "print(\n", - " \"truth \"\n", - " + \" \".join(f\"{p.name}={v:.2f}\" for p, v in zip(omp_vol.params, volume_truth))\n", - ")\n", - "\n", - "fig = corner.corner(\n", - " walker_vol_gp.model_sampler.chain,\n", - " labels=[p.name for p in omp_vol.params],\n", - " truths=volume_truth,\n", - " truth_color=\"k\",\n", - " color=\"tab:blue\",\n", + "fig.legend(\n", + " handles=[\n", + " plt.Line2D([], [], color=c, label=n) for n, c in zip(xs_problems, xs_colours)\n", + " ],\n", + " loc=\"upper right\",\n", + " fontsize=9,\n", ")\n", - "corner.corner(walker_vol_plain.model_sampler.chain, fig=fig, color=\"tab:red\")\n", - "plt.plot([], [], color=\"tab:blue\", label=\"with GP discrepancy\")\n", - "plt.plot([], [], color=\"tab:red\", label=\"no discrepancy\")\n", - "fig.legend(loc=\"upper right\");" + "plt.show()" ] }, { "cell_type": "markdown", - "id": "65f86f5a", + "id": "c580f46a", "metadata": {}, "source": [ - "## The learned discrepancy vs the missing physics\n", + "### The learned discrepancy against the missing physics\n", "\n", - "Conditioning the GP on the posterior-mean residuals\n", - "(`rxmc.predictive.gp_posterior_predictive`) recovers the smooth angular\n", - "structure the deficient model cannot produce — compare it with the *true*\n", - "defect, the difference between the full and volume-only potentials.\n" + "The defect our GP has to describe is the log of the ratio between the full potential that generated the data and the volume-only one we fitted. We'll draw it at the posterior-median volume parameters, on a finer angular grid than the data, so we can see how the GP interpolates between measured angles and how it behaves beyond them." ] }, { "cell_type": "code", - "execution_count": 14, - "id": "d4fb9bb3", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:08:59.633011Z", - "iopub.status.busy": "2026-08-11T03:08:59.632823Z", - "iopub.status.idle": "2026-08-11T03:08:59.846393Z", - "shell.execute_reply": "2026-08-11T03:08:59.845548Z" + "execution_count": 28, + "id": "1799733e", + "metadata": {}, + "outputs": [], + "source": [ + "p_xs_gp = xs_problems[\"GP, growing amplitude\"]\n", + "s_xs_gp = xs_samples[\"GP, growing amplitude\"]\n", + "theta_xs = np.median(s_xs_gp, axis=0)\n", + "fine = np.deg2rad(np.linspace(2.0, 178.0, 90))\n", + "resid_xs = comp_xs.y - comp_xs.predict(*theta_xs[p_xs_gp.columns(volume_params)])\n", + "\n", + "# again each draw minus its own model curve, both in log space; naming the\n", + "# kernel gives the model plus its discrepancy, with no experimental error\n", + "rows_xs = s_xs_gp[::5]\n", + "draws_xs = rx.predictive.grid_draws(\n", + " p_xs_gp,\n", + " omp_vol.bind(fine, meta),\n", + " fine,\n", + " rows_xs,\n", + " terms=[gp_xs],\n", + " rng=5,\n", + " return_draws=True,\n", + ")\n", + "draws_xs_model = rx.predictive.grid_draws(\n", + " p_xs_gp, omp_vol.bind(fine, meta), fine, rows_xs, model_only=True, return_draws=True\n", + ")\n", + "mu_fine = comp_xs.space(\n", + " omp_vol.bind(fine, meta)(*theta_xs[p_xs_gp.columns(volume_params)])\n", + ")\n", + "disc_lo_xs, disc_hi_xs = np.percentile(draws_xs - draws_xs_model, [16, 84], axis=0)\n", + "true_defect_xs = np.log(omp_full.bind(fine, meta)(*full_truth)) - mu_fine" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "b1b56ab1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "fraction of the grid where the true defect is inside the 68 % envelope: 0.58\n" + ] } - }, + ], + "source": [ + "print(\n", + " \"fraction of the grid where the true defect is inside the 68 % envelope:\",\n", + " f\"{np.mean((true_defect_xs >= disc_lo_xs) & (true_defect_xs <= disc_hi_xs)):.2f}\",\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "31b28438", + "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -890,67 +1229,61 @@ } ], "source": [ - "mp_vol = walker_vol_gp.model_sampler.chain.mean(axis=0)\n", - "theta_xs = walker_vol_gp.likelihood_samplers[0].chain.mean(axis=0)\n", - "residuals_xs = obs_xs.y - omp_vol.evaluate(obs_xs, *mp_vol)\n", - "\n", - "angles_vis_rad = obs_xs.visualization_workspace.angles\n", - "disc_mean, disc_cov = rxmc.predictive.gp_posterior_predictive(\n", - " kernel_xs,\n", - " theta_xs,\n", - " obs_xs.x,\n", - " residuals_xs,\n", - " angles_vis_rad,\n", - " train_noise_var=obs_xs.y_stat_err**2,\n", + "fig, ax = plt.subplots()\n", + "ax.errorbar(\n", + " np.rad2deg(angles),\n", + " resid_xs,\n", + " comp_xs.y_err,\n", + " fmt=\"o\",\n", + " ms=3,\n", + " color=\"k\",\n", + " label=\"log residuals\",\n", ")\n", - "\n", - "true_defect = omp_full.visualizable_model_prediction(\n", - " obs_xs, *full_truth\n", - ") - omp_vol.visualizable_model_prediction(obs_xs, *volume_truth)\n", - "\n", - "angles_vis_deg = np.rad2deg(angles_vis_rad)\n", - "disc_std = np.sqrt(np.diag(disc_cov))\n", - "plt.plot(angles_vis_deg, true_defect, \"k:\", label=\"true defect (full - volume)\")\n", - "plt.plot(angles_vis_deg, disc_mean, color=\"tab:blue\", label=\"GP posterior mean\")\n", - "plt.fill_between(\n", - " angles_vis_deg,\n", - " disc_mean - disc_std,\n", - " disc_mean + disc_std,\n", - " alpha=0.3,\n", - " color=\"tab:blue\",\n", + "plotstyle.band(\n", + " ax,\n", + " np.rad2deg(fine),\n", + " disc_lo_xs,\n", + " disc_hi_xs,\n", + " color=plotstyle.COLOURS[0],\n", + " label=\"GP discrepancy (68 %)\",\n", ")\n", - "plt.plot(np.rad2deg(obs_xs.x), residuals_xs, \".\", color=\"gray\", label=\"residuals\")\n", - "plt.xlabel(r\"$\\theta$ [deg]\")\n", - "plt.ylabel(r\"$\\delta(d\\sigma/d\\Omega)$ [b/sr]\")\n", - "plt.legend();" + "ax.plot(\n", + " np.rad2deg(fine),\n", + " true_defect_xs,\n", + " \"--\",\n", + " color=plotstyle.COLOURS[1],\n", + " label=r\"defect: $\\log$(full truth / fitted volume)\",\n", + ")\n", + "ax.set(\n", + " xlabel=r\"$\\theta_{cm}$ [deg]\",\n", + " ylabel=\"log residual\",\n", + " title=\"What the GP learned about the missing surface term\",\n", + ")\n", + "ax.legend(fontsize=8)\n", + "plt.show()" ] }, { "cell_type": "markdown", - "id": "35d64f79", + "id": "67bd0f36", "metadata": {}, "source": [ - "## Takeaways, continued\n", + "## Takeaways\n", "\n", - "- **Same API, real physics**: `kernel_term(kernel)` on a\n", - " differential cross section works exactly as in the toy — the kernel just\n", - " acts on the angle grid (radians), so its length scale is angular.\n", - "- Without the discrepancy term the deficient potential's parameters must\n", - " contort to mimic the missing surface absorption (note $V_v$ lands many\n", - " $\\sigma$ from the truth, and $W_v$ inflates to play the role of $W_d$);\n", - " with it, the GP absorbs the angle-correlated defect and the geometry\n", - " parameters relax to the truth. $W_v$ remains partially biased — volume and\n", - " surface absorption are genuinely degenerate at one energy, and no\n", - " discrepancy model can restore information the data do not contain.\n", - "- `rxmc.predictive.gp_posterior_predictive` reconstructs the learned\n", - " discrepancy on any angle grid — useful for comparing against candidate\n", - " missing-physics terms.\n" + "- A mean-zero GP discrepancy is just another covariance term. `grid_draws` can propagate it onto any grid from the problem alone, and it does so as whole correlated curves rather than columns of independent points, so questions about the curve as a whole make sense.\n", + "- We met two predictive objects, and they answer different questions. The model plus its discrepancy tells us where the model may be wrong. Adding the experimental terms tells us what a *measurement* should look like, and only that second one belongs next to data. `terms=` is how we pick. There's also a third, conditioning the discrepancy on the residuals with `gp_predictive_draws(..., conditioned=True)`, but that's data-driven regression stacked on the model, and we deliberately didn't use it here.\n", + "- An unmodelled discrepancy doesn't make our answer vague; it makes it *wrong and confident*. On the toy that meant a slope sixty standard deviations from the truth.\n", + "- An uncorrelated proportional error only adds independent slack, and independent slack cannot describe a smooth departure. On the toy it left the slope sixteen standard deviations out; on the cross section it widened the answer but stayed six out in $V_v$ and ten in $W_v$.\n", + "- The envelope isn't a fit to the defect, and nothing guarantees it covers the defect: it contained the toy's over 81 % of its data range and the cross section's over 58 % of its grid. A mean-zero predictive describes plausible error, and it can be too narrow as well as too generous.\n", + "- Pointwise coverage on one dataset says little when the discrepancy's correlation length is comparable to the range of the data.\n", + "- The amplitude is prior knowledge, and it's worth stating. A constant amplitude has to compromise between where the model is good and where it is not; letting it grow with $x$ says where we expect the model to fail. Here the data leaned towards the growth without settling it.\n", + "- None of this creates information. Where the data can't separate two effects, like volume and surface absorption at a single energy, a discrepancy model improves the evidence and some parameters, and leaves others confidently wrong." ] } ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -964,7 +1297,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.3" + "version": "3.12.13" } }, "nbformat": 4, diff --git a/examples/gradient_based_sampling.ipynb b/examples/gradient_based_sampling.ipynb new file mode 100644 index 0000000..db00bb9 --- /dev/null +++ b/examples/gradient_based_sampling.ipynb @@ -0,0 +1,774 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "79c094db", + "metadata": {}, + "source": [ + "# Sampling with gradients: NUTS against emcee\n", + "\n", + "The densities of a compiled problem are written in JAX, so their exact\n", + "gradient is available, through the models, the covariance and the reaction\n", + "solver. A gradient sampler, the No-U-Turn sampler ([NUTS](https://blackjax-devs.github.io/blackjax/examples/quickstart.html#nuts)) of\n", + "[Hamiltonian Monte Carlo](https://en.wikipedia.org/wiki/Hamiltonian_Monte_Carlo),\n", + "uses it to take long, directed steps instead of a random walk. Whether that\n", + "pays depends on the problem: a NUTS draw costs tens of gradient evaluations,\n", + "while an [emcee](https://emcee.readthedocs.io/en/stable/) step costs one\n", + "density evaluation per walker.\n", + "\n", + "We compare NUTS with emcee on two problems, by *effective* samples per\n", + "second, the number that decides how long a calibration takes:\n", + "\n", + "1. a hierarchy with 33 parameters, where NUTS should win;\n", + "2. a 5-parameter Gaussian-process discrepancy, where it should not.\n", + "\n", + "On the GP, both samplers start about the\n", + "[posterior mode](https://en.wikipedia.org/wiki/Maximum_a_posteriori_estimation) (MAP), found\n", + "by [L-BFGS-B](https://en.wikipedia.org/wiki/Limited-memory_BFGS) with the\n", + "exact gradient (`rx.optimize.find_map`, recipe 33), and the search's time is charged to each. On the hierarchy both start from prior draws, for reasons we give there. On the way we use the\n", + "gradient once more, for a\n", + "[Laplace approximation](https://en.wikipedia.org/wiki/Laplace%27s_approximation)\n", + "from the exact Hessian.\n", + "\n", + "For reaction models with a handful of parameters, the\n", + "[sampler benchmark](/benchmarks.md) compares these two with nested sampling (dynesty) and\n", + "preconditioned Monte Carlo (pocomc), scoring each against exact or\n", + "long-run reference posteriors. On the $p + {}^{40}\\mathrm{Ca}$ optical model pocomc reaches\n", + "the reference fastest, and the reaction notebooks use it; on the funnels a\n", + "hierarchy and a GP make, the samplers that work their way in from the prior as a whole population (dynesty and pocomc) get the means or the widths wrong.\n", + "\n", + "Recipes: 7, 16, 33, 38, 41 (see [the recipes](/recipes.md))" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "18425b01", + "metadata": {}, + "outputs": [], + "source": [ + "import logging\n", + "import time\n", + "\n", + "import blackjax\n", + "import corner\n", + "import emcee\n", + "import jax\n", + "import jax.numpy as jnp\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import plotstyle\n", + "import tinygp\n", + "from budget import QUICK_NUTS, budget # sampler budgets, cut in CI's quick run\n", + "from scipy import stats\n", + "\n", + "import rxmc as rx\n", + "from rxmc import terms as T\n", + "\n", + "plotstyle.use()\n", + "logging.getLogger(\"emcee\").setLevel(logging.ERROR) # score() reports tau itself" + ] + }, + { + "cell_type": "markdown", + "id": "ff7d991a", + "metadata": {}, + "source": [ + "## The two samplers, and how we compare them\n", + "\n", + "rxmc owns no sampler; each of these is a few lines on the problem's\n", + "densities.\n", + "\n", + "- **emcee** moves an ensemble of walkers, each by a\n", + " [stretch move](https://emcee.readthedocs.io/en/stable/user/moves/) along\n", + " the line to another walker: no gradient and no tuning, one density\n", + " evaluation per walker per step.\n", + "- **NUTS** ([NUTS](https://blackjax-devs.github.io/blackjax/examples/quickstart.html#nuts)) follows Hamiltonian trajectories with the\n", + " gradient and stops each one when it starts to turn back; its step size and\n", + " mass matrix are tuned in a discarded\n", + " [warm-up](https://blackjax-devs.github.io/blackjax/examples/quickstart.html#use-stan-s-window-adaptation).\n", + "\n", + "NUTS runs on `log_posterior_unconstrained`, the posterior on\n", + "$\\mathbb{R}^n$: a bounded parameter is sampled as a log or a logit, so a\n", + "trajectory never meets the $-\\infty$ wall at a bound, and `to_theta` maps\n", + "the draws back (recipe 41). Its chains run one after another; vmapped,\n", + "every chain would wait at each step for the longest trajectory.\n", + "\n", + "The comparison:\n", + "\n", + "- The [effective sample size](https://mc-stan.org/docs/reference-manual/analysis.html)\n", + " (ESS) of a correlated chain is the number of independent draws that would\n", + " estimate a posterior mean as precisely. We take the smallest over the\n", + " parameters of blackjax's rank-normalised *bulk*\n", + " [ESS](https://blackjax-devs.github.io/blackjax/autoapi/blackjax/diagnostics/index.html)\n", + " across chains, and report it per second of wall time (compilation and\n", + " the start search included) and per thousand calls. A call is one\n", + " evaluation of the log posterior and, for NUTS, its gradient; ESS per call\n", + " does not depend on the machine, and the time per call shows what a call\n", + " costs. The calls are split into the start search, warm-up (NUTS's\n", + " adaptation, emcee's discarded burn-in) and sampling.\n", + "- The rank-normalised split [$\\hat R$](https://en.wikipedia.org/wiki/Gelman-Rubin_statistic)\n", + " ([Vehtari et al. 2021](https://arxiv.org/abs/1903.08008)) compares the\n", + " spread within each half-chain with the spread between them, so it also\n", + " catches chains that drift together. Above about 1.01\n", + " the chains have not yet forgotten where they started, their ESS means\n", + " nothing, and we report the run as not converged.\n", + "- emcee's walkers are taken as chains, which flatters its ESS: they are not\n", + " independent, since each move uses another walker. So we also print\n", + " emcee's own\n", + " [integrated autocorrelation time](https://emcee.readthedocs.io/en/stable/tutorials/autocorr/)\n", + " $\\tau$, the number of steps over which a walker remembers its past; emcee\n", + " trusts a run only when it is longer than about $50\\tau$. We report a\n", + " run shorter than that as not converged, whatever $\\hat R$ says: walkers\n", + " that move toward one another can agree long before they have explored\n", + " the posterior.\n", + "- NUTS reports *divergent transitions*: trajectories that met curvature too sharp for the step size and were stopped. Where they happen, NUTS can under-explore the posterior, so we report no ESS for a run that has any." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "8f73efd4", + "metadata": {}, + "outputs": [], + "source": [ + "def run_nuts(\n", + " problem, starts, warmup=budget(1000), draws=budget(1000), seed=0, target=0.8\n", + "):\n", + " \"\"\"One window-adapted NUTS chain per row of ``starts``; draws in theta.\"\"\"\n", + " logdensity = problem.log_posterior_unconstrained\n", + " t0, chains, divergent, n_warm, n_draw = time.perf_counter(), [], 0, 0, 0\n", + " for key, theta0 in zip(jax.random.split(jax.random.key(seed), len(starts)), starts):\n", + " k_warm, k_draw = jax.random.split(key)\n", + " adapt = blackjax.window_adaptation(\n", + " blackjax.nuts, logdensity, target_acceptance_rate=target, **QUICK_NUTS\n", + " )\n", + " (state, tuned), warm = adapt.run(\n", + " k_warm, problem.to_unconstrained(theta0), num_steps=warmup\n", + " )\n", + " step = jax.jit(blackjax.nuts(logdensity, **tuned).step)\n", + "\n", + " def one_step(state, key):\n", + " state, info = step(key, state)\n", + " return state, (state.position, info)\n", + "\n", + " _, (zs, info) = jax.lax.scan(one_step, state, jax.random.split(k_draw, draws))\n", + " chains.append(np.asarray(jax.vmap(problem.to_theta)(zs)))\n", + " divergent += int(info.is_divergent.sum())\n", + " n_warm += int(warm.info.num_integration_steps.sum())\n", + " n_draw += int(info.num_integration_steps.sum())\n", + " return np.stack(chains), dict(\n", + " wall=time.perf_counter() - t0,\n", + " warmup=n_warm,\n", + " sampling=n_draw,\n", + " divergences=divergent,\n", + " )\n", + "\n", + "\n", + "def ball(problem, centre, n, seed=0):\n", + " \"\"\"``n`` points about ``centre``, jittered on the unconstrained scale so\n", + " that every one is inside the support.\"\"\"\n", + " z = problem.to_unconstrained(centre)\n", + " dz = 0.01 * np.random.default_rng(seed).standard_normal((n, problem.ndim))\n", + " return np.array([problem.to_theta(z + d) for d in dz])\n", + "\n", + "\n", + "def run_emcee(problem, starts, steps, seed=0):\n", + " \"\"\"emcee from ``starts`` (one walker each), the first third discarded;\n", + " walkers as chains.\"\"\"\n", + " n_walkers = len(starts)\n", + " t0 = time.perf_counter()\n", + " sampler = emcee.EnsembleSampler(\n", + " n_walkers, problem.ndim, problem.log_posterior_batch, vectorize=True\n", + " )\n", + " sampler.random_state = np.random.RandomState(seed).get_state()\n", + " sampler.run_mcmc(starts, steps, progress=False)\n", + " kept = sampler.get_chain(discard=steps // 3)\n", + " tau = float(np.max(sampler.get_autocorr_time(discard=steps // 3, quiet=True)))\n", + " return np.swapaxes(kept, 0, 1), dict(\n", + " wall=time.perf_counter() - t0,\n", + " warmup=n_walkers * (steps // 3),\n", + " sampling=n_walkers * (steps - steps // 3),\n", + " tau=tau,\n", + " steps_kept=len(kept),\n", + " )\n", + "\n", + "\n", + "def overlay(runs, colours, labels, title):\n", + " \"\"\"Corner plots of several runs on shared axes, each histogram normalised.\"\"\"\n", + " ranges = [np.percentile(runs[-1][:, k], [0.2, 99.8]) for k in range(len(labels))]\n", + " ranges = [(lo - 0.3 * (hi - lo), hi + 0.3 * (hi - lo)) for lo, hi in ranges]\n", + " fig = None\n", + " for run, colour in zip(runs, colours):\n", + " fig = corner.corner(\n", + " run,\n", + " fig=fig,\n", + " labels=labels,\n", + " range=ranges,\n", + " hist_kwargs={\"density\": True},\n", + " **plotstyle.corner_kwargs(show_titles=False, color=colour),\n", + " )\n", + " fig.suptitle(title)\n", + " plt.show()\n", + "\n", + "\n", + "def score(name, chains, info, search=None):\n", + " \"\"\"Print a sampler's cost and result, its start ``search`` (an\n", + " ``rx.optimize`` result) charged to it; ESS only for a converged run with\n", + " no divergences. Returns the wall time and the ESS (None if not trusted).\"\"\"\n", + " found = 0 if search is None else search.nfev\n", + " wall = info[\"wall\"] + (0 if search is None else search.wall)\n", + " calls = found + info[\"warmup\"] + info[\"sampling\"]\n", + " print(\n", + " f\"{name}: {wall:.1f} s, {calls} calls ({found} search, \"\n", + " f\"{info['warmup']} warm-up, {info['sampling']} sampling), \"\n", + " f\"{1e3 * wall / calls:.2f} ms per call\"\n", + " )\n", + " # the rank-normalised diagnostics sort every draw, so a long emcee run is\n", + " # thinned to at most 2000 draws per walker first; thinning by far less than\n", + " # the autocorrelation time costs almost no effective draws\n", + " thinned = chains[:, :: max(1, chains.shape[1] // 2000)]\n", + " ess = float(np.min(blackjax.diagnostics.ess_bulk(thinned)))\n", + " rhat = float(np.max(blackjax.diagnostics.rhat(thinned)))\n", + " enough = \"tau\" not in info or info[\"steps_kept\"] > 50 * info[\"tau\"]\n", + " trusted = rhat <= 1.01 and enough and info.get(\"divergences\", 0) == 0\n", + " if trusted:\n", + " line = f\" ESS {ess:.0f}, {ess / wall:.2f} per s, {1e3 * ess / calls:.2f} per 1k calls\"\n", + " else:\n", + " line = \" not trusted\"\n", + " line += f\"; R-hat {rhat:.3f}\"\n", + " if \"tau\" in info:\n", + " line += f\", tau {info['tau']:.0f} steps\" + (\"\" if enough else \" (< 50 tau)\")\n", + " if \"divergences\" in info:\n", + " line += f\", {info['divergences']} divergent\"\n", + " print(line)\n", + " return wall, ess if trusted else None" + ] + }, + { + "cell_type": "markdown", + "id": "cd3aace4", + "metadata": {}, + "source": [ + "## 1. A hierarchy: where gradients pay\n", + "\n", + "Thirty groups each measure a line. They share the slope $m$, and their\n", + "intercepts scatter about a common $\\mu$ with an unknown spread $\\tau$,\n", + "written non-centred as $\\mu + \\tau\\,\\eta_j$ with\n", + "$\\eta_j \\sim \\mathcal{N}(0, 1)$ (recipe 38): 33 parameters, most of them the\n", + "$\\eta_j$. (This $\\tau$ is the hierarchy's spread, not emcee's\n", + "autocorrelation time.) A stretch move proposes along the line between two\n", + "walkers, and in 33 dimensions few such lines point anywhere useful.\n", + "\n", + "Here both samplers start from prior draws. Neither point estimate is a\n", + "good start on a hierarchy. The likelihood depends on $\\mu$, $\\tau$ and the\n", + "$\\eta_j$ only through the intercepts $\\mu + \\tau\\,\\eta_j$, so its maximum is\n", + "not a point but a ridge, and L-BFGS-B stops wherever on it its start\n", + "leads. The MAP is a point, but not a typical\n", + "one: the $\\mathcal{N}(0, 1)$ prior rewards small $\\eta_j$, so the mode\n", + "trades them for a $\\tau$ well above the bulk of the posterior." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "612763ce", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "33 parameters\n" + ] + } + ], + "source": [ + "rng = np.random.default_rng(5)\n", + "x = np.linspace(0.0, 1.0, 5)\n", + "m = rx.Parameter(\"m\", prior=stats.norm(0, 5), latex=\"m\")\n", + "mu = rx.Parameter(\"mu\", prior=stats.norm(0, 5), latex=r\"\\mu\")\n", + "tau = rx.Parameter(\n", + " \"tau\", prior=stats.halfnorm(scale=1.0), bounds=(0.0, np.inf), latex=r\"\\tau\"\n", + ")\n", + "comps = []\n", + "for j in range(30):\n", + " eta = rx.Parameter(f\"eta_{j}\", prior=stats.norm(0, 1), latex=rf\"\\eta_{{{j}}}\")\n", + " y = 0.8 * x + 1.0 + 0.3 * rng.normal() + rng.normal(0, 0.1, x.size)\n", + " group = rx.Model(\n", + " lambda x, m, mu, tau, eta: m * x + mu + tau * eta, [m, mu, tau, eta]\n", + " )\n", + " comps.append(rx.Comparison(rx.Dataset(x, y, 0.1 * np.ones(x.size)), group))\n", + "hierarchy = rx.Problem([rx.Constraint(comps)])\n", + "print(hierarchy.ndim, \"parameters\")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "a27f9cfc", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "NUTS: 37.2 s, 301594 calls (0 search, 115346 warm-up, 186248 sampling), 0.12 ms per call\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " ESS 453, 12.19 per s, 1.50 per 1k calls; R-hat 1.007, 0 divergent\n", + "emcee: 11.6 s, 408000 calls (0 search, 136000 warm-up, 272000 sampling), 0.03 ms per call\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " not trusted; R-hat 1.505, tau 443 steps (< 50 tau)\n" + ] + } + ], + "source": [ + "h_nuts, h_nuts_info = run_nuts(\n", + " hierarchy, hierarchy.sample_prior(4, rng=1), warmup=budget(1000), draws=budget(2000)\n", + ")\n", + "h_walkers = hierarchy.sample_prior(2 * hierarchy.ndim + 2, rng=2)\n", + "h_emcee, h_emcee_info = run_emcee(hierarchy, h_walkers, steps=budget(6000))\n", + "score(\"NUTS\", h_nuts, h_nuts_info)\n", + "score(\"emcee\", h_emcee, h_emcee_info);" + ] + }, + { + "cell_type": "markdown", + "id": "39d26c82", + "metadata": {}, + "source": [ + "emcee has not converged, and by its own estimate of $\\tau$ its run is\n", + "too short. Is it only a matter of a longer run? Nearly seven times the\n", + "steps:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "9c6cd361", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "emcee: 69.9 s, 2720000 calls (0 search, 906644 warm-up, 1813356 sampling), 0.03 ms per call\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " not trusted; R-hat 1.062, tau 975 steps (< 50 tau)\n" + ] + } + ], + "source": [ + "h_long, h_long_info = run_emcee(hierarchy, h_walkers, steps=budget(40000))\n", + "score(\"emcee\", h_long, h_long_info);" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "ab9be6bc", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "emcee, 6000 steps: worst split R-hat eta_17 1.505, eta_7 1.431, eta_15 1.408; walkers' mean log posterior spans 7.3\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "emcee, 40000 steps: worst split R-hat tau 1.062, eta_7 1.056, eta_18 1.052; walkers' mean log posterior spans 3.4\n" + ] + } + ], + "source": [ + "# what the emcee runs disagree about: the parameters with the worst split\n", + "# R-hat, and how far apart the walkers sit in log posterior\n", + "for name, chains in ((\"6000 steps\", h_emcee), (\"40000 steps\", h_long)):\n", + " thinned = chains[:, :: max(1, chains.shape[1] // 2000)]\n", + " r = np.asarray(blackjax.diagnostics.rhat(thinned))\n", + " worst = [f\"{hierarchy.names[k]} {r[k]:.3f}\" for k in np.argsort(r)[::-1][:3]]\n", + " log_post = np.asarray(\n", + " hierarchy.log_posterior_batch(chains.reshape(-1, hierarchy.ndim))\n", + " )\n", + " walker_mean = log_post.reshape(chains.shape[:2]).mean(axis=1)\n", + " print(\n", + " f\"emcee, {name}: worst split R-hat {', '.join(worst)}; walkers' mean log \"\n", + " f\"posterior spans {walker_mean.max() - walker_mean.min():.1f}\"\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "a9ae1e58", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "col = hierarchy.columns(tau).item()\n", + "fig, axes = plt.subplots(1, 2, figsize=(9.0, 3.4))\n", + "axes[0].plot(h_emcee[:4, :, col].T, lw=0.6, color=plotstyle.COLOURS[1])\n", + "axes[0].plot(\n", + " np.linspace(0, h_emcee.shape[1], h_nuts.shape[1]),\n", + " h_nuts[0, :, col],\n", + " lw=0.6,\n", + " color=plotstyle.COLOURS[0],\n", + ")\n", + "axes[0].set(\n", + " xlabel=\"step (NUTS stretched to emcee's length)\",\n", + " ylabel=r\"$\\tau$\",\n", + " title=\"four emcee walkers (vermillion), one NUTS chain (blue)\",\n", + ")\n", + "bins = np.linspace(0, 0.7, 50)\n", + "for chains, colour, name in [(h_emcee, 1, \"emcee\"), (h_nuts, 0, \"NUTS\")]:\n", + " axes[1].hist(\n", + " chains[:, :, col].ravel(),\n", + " bins,\n", + " density=True,\n", + " alpha=0.6,\n", + " color=plotstyle.COLOURS[colour],\n", + " label=name,\n", + " )\n", + "axes[1].axvline(0.3, ls=\"--\", color=\"k\", label=\"truth\")\n", + "axes[1].set(xlabel=r\"$\\tau$\", title=\"the spread of the intercepts\")\n", + "axes[1].legend()\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "becf1e2d", + "metadata": {}, + "source": [ + "NUTS converges in about 40 seconds: 453 effective draws, $\\hat R$ of 1.007 and no divergences, at under 40 gradient evaluations per draw, warm-up included.\n", + "\n", + "emcee's 6000 steps of 68 walkers take about twelve seconds, but its $\\hat R$ is 1.5 and its run is far shorter than $50\\tau$. No walker is stuck: their mean log posteriors all lie within about 7 units of each other. The worst $\\hat R$ belongs to individual $\\eta_j$, whose values differ more between walkers than any one walker moves during the run. On $\\tau$ itself the walkers move together rather than apart: the left panel shows them creeping up from about 0.23 towards 0.30, and the pooled emcee histogram on the right is narrower than NUTS's and misses its upper tail. A stretch move proposes along the line through one other walker; in 33 dimensions most such proposals are rejected or tiny, so each walker crawls.\n", + "\n", + "The longer run shows that this isn't cured by patience on any reasonable budget. emcee's estimate of $\\tau$ keeps growing with the run, from about 440 steps to about 980, because a short run cannot see the slowest motion of the walkers, and after about a minute $\\hat R$ is still 1.06, now worst for $\\tau$ itself. NUTS uses the gradient to move all 33 coordinates together, and converged in half the time. The [benchmark](/benchmarks.md) scores both against this hierarchy's exact posterior (it is Gaussian once $\\tau$ is fixed): NUTS's means and widths are within 0.1 standard deviations of it." + ] + }, + { + "cell_type": "markdown", + "id": "94f63177", + "metadata": {}, + "source": [ + "## 2. A GP discrepancy: MAP, Laplace and NUTS\n", + "\n", + "The data and model of `gp_discrepancy`'s toy (recipe 7): a line fitted to data that bend\n", + "away from it, with a mean-zero Gaussian-process discrepancy whose amplitude\n", + "grows with $x$. Five parameters: the line's two, and the GP's log length\n", + "scale, log amplitude and amplitude slope. The hyperparameter priors differ from that notebook's: here they are unbounded normals, which suit a MAP and a Laplace approximation, where `gp_discrepancy` caps the length scale at the data's range, which could put the mode on a boundary. So the posteriors are similar, not identical.\n", + "\n", + "The gradient gives the posterior mode cheaply: `find_map` runs L-BFGS-B\n", + "with the exact gradient from eight prior draws. The exact Hessian $H$ at\n", + "the mode gives the Laplace approximation, a Gaussian with covariance\n", + "$-H^{-1}$ (recipe 33). NUTS then starts its four chains around the MAP, and emcee its walkers too." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "d95aa564", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['m', 'b', 'log_ell', 'log_A', 'amp_slope']" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def truth(x):\n", + " return 0.8 * x + 1.0 + 0.03 * x**2\n", + "\n", + "\n", + "rng = np.random.default_rng(7)\n", + "xg = np.linspace(0.2, 5.0, 30)\n", + "toy = rx.Dataset(xg, truth(xg) + rng.normal(0.0, 0.02, xg.size), np.full(xg.size, 0.02))\n", + "line = rx.Model(\n", + " lambda x, m, b: m * x + b,\n", + " [\n", + " rx.Parameter(\"m\", prior=stats.norm(0.0, 2.0), latex=\"m\"),\n", + " rx.Parameter(\"b\", prior=stats.norm(0.0, 2.0), latex=\"b\"),\n", + " ],\n", + ")\n", + "log_A = rx.Parameter(\"log_A\", prior=stats.norm(np.log(0.02), 1.5), latex=r\"\\log A\")\n", + "slope = rx.Parameter(\"amp_slope\", prior=stats.norm(1.0, 1.0), latex=r\"s_A\")\n", + "log_ell = rx.Parameter(\"log_ell\", prior=stats.norm(0.5, 1.0), latex=r\"\\log\\ell\")\n", + "gp = T.kernel(\n", + " lambda le: tinygp.kernels.Matern52(scale=jnp.exp(le)),\n", + " [log_ell],\n", + " amplitude=T.exp_growth_amplitude(5.0),\n", + " amplitude_params=(log_A, slope),\n", + " jitter=1e-6,\n", + ")\n", + "gp_problem = rx.Problem([rx.Constraint([rx.Comparison(toy, line)], terms=[gp])])\n", + "gp_problem.names" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "8ec363cb", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MAP in 1.3 s\n", + " m 0.829 +/- 0.040\n", + " b 0.944 +/- 0.057\n", + " log_ell 1.831 +/- 0.701\n", + " log_A -3.356 +/- 0.854\n", + " amp_slope 2.391 +/- 0.588\n" + ] + } + ], + "source": [ + "g_map = rx.optimize.find_map(gp_problem, rng=2)\n", + "laplace_cov = np.linalg.inv(-gp_problem.hessian_log_posterior(g_map.x))\n", + "print(f\"MAP in {g_map.wall:.1f} s\")\n", + "for name, v, s in zip(gp_problem.names, g_map.x, np.sqrt(np.diag(laplace_cov))):\n", + " print(f\" {name:10s} {v:7.3f} +/- {s:.3f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "80a561f4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "NUTS: 60.4 s, 545245 calls (390 search, 228257 warm-up, 316598 sampling), 0.11 ms per call\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " ESS 904, 14.97 per s, 1.66 per 1k calls; R-hat 1.004, 0 divergent\n", + "emcee: 49.4 s, 960390 calls (390 search, 320000 warm-up, 640000 sampling), 0.05 ms per call\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " ESS 4741, 95.99 per s, 4.94 per 1k calls; R-hat 1.006, tau 128 steps\n", + "effective draws per second: NUTS 15, emcee 96\n" + ] + } + ], + "source": [ + "g_nuts, g_nuts_info = run_nuts(\n", + " gp_problem,\n", + " ball(gp_problem, g_map.x, 4, seed=3),\n", + " warmup=budget(1000),\n", + " draws=budget(2000),\n", + " target=0.99,\n", + ")\n", + "g_walkers = ball(gp_problem, g_map.x, 32, seed=4)\n", + "g_emcee, g_emcee_info = run_emcee(gp_problem, g_walkers, steps=budget(30000))\n", + "g_nuts_wall, g_nuts_ess = score(\"NUTS\", g_nuts, g_nuts_info, g_map)\n", + "g_emcee_wall, g_emcee_ess = score(\"emcee\", g_emcee, g_emcee_info, g_map)\n", + "if g_nuts_ess and g_emcee_ess: # only when both runs can be trusted\n", + " print(\n", + " f\"effective draws per second: NUTS {g_nuts_ess / g_nuts_wall:.0f}, \"\n", + " f\"emcee {g_emcee_ess / g_emcee_wall:.0f}\"\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "3390aa59", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "NUTS, target 0.8: 24.0 s, 142205 calls (390 search, 83458 warm-up, 58357 sampling), 0.17 ms per call\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " not trusted; R-hat 1.010, 41 divergent\n", + "emcee, 10000 steps: 17.4 s, 320390 calls (390 search, 106656 warm-up, 213344 sampling), 0.05 ms per call\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " not trusted; R-hat 1.019, tau 105 steps\n" + ] + } + ], + "source": [ + "# the two runs the discussion below compares against: NUTS at blackjax's\n", + "# default target acceptance, and emcee at a third of the length\n", + "g_nuts_08, g_nuts_08_info = run_nuts(\n", + " gp_problem,\n", + " ball(gp_problem, g_map.x, 4, seed=3),\n", + " warmup=budget(1000),\n", + " draws=budget(1000),\n", + ")\n", + "g_emcee_short, g_emcee_short_info = run_emcee(\n", + " gp_problem, g_walkers, steps=budget(10000)\n", + ")\n", + "score(\"NUTS, target 0.8\", g_nuts_08, g_nuts_08_info, g_map)\n", + "score(\"emcee, 10000 steps\", g_emcee_short, g_emcee_short_info, g_map);" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "b54a2de0", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "laplace = np.random.default_rng(4).multivariate_normal(g_map.x, laplace_cov, 4000)\n", + "overlay(\n", + " [\n", + " g_emcee.reshape(-1, gp_problem.ndim),\n", + " laplace,\n", + " g_nuts.reshape(-1, gp_problem.ndim),\n", + " ],\n", + " [plotstyle.COLOURS[1], \"0.4\", plotstyle.COLOURS[0]],\n", + " [f\"${p.latex}$\" for p in gp_problem.params],\n", + " \"emcee (vermillion), Laplace at the MAP (grey), NUTS (blue)\",\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "9c17584f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "posterior standard deviations\n", + " m Laplace 0.040 NUTS 0.081 emcee 0.075\n", + " b Laplace 0.057 NUTS 0.224 emcee 0.196\n", + " log_ell Laplace 0.701 NUTS 0.688 emcee 0.678\n", + " log_A Laplace 0.854 NUTS 0.913 emcee 0.905\n", + " amp_slope Laplace 0.588 NUTS 0.784 emcee 0.766\n" + ] + } + ], + "source": [ + "print(\"posterior standard deviations\")\n", + "for k, name in enumerate(gp_problem.names):\n", + " print(\n", + " f\" {name:10s} Laplace {np.sqrt(laplace_cov[k, k]):.3f} \"\n", + " f\"NUTS {g_nuts[..., k].std():.3f} emcee {g_emcee[..., k].std():.3f}\"\n", + " )" + ] + }, + { + "cell_type": "markdown", + "id": "58beec16", + "metadata": {}, + "source": [ + "The MAP takes under two seconds. Started around it, NUTS gives 904 effective draws in about a minute, with $\\hat R$ of 1.004 and no divergences, at a target acceptance rate of 0.99 and 2000 draws per chain. The target matters here. At blackjax's default of 0.8, the run printed above gave 41 divergences in 4000 draws, and an $\\hat R$ of 1.010: trajectories that met the sharp curvature where a small amplitude leaves the length scale unconstrained. A run with divergences can under-explore exactly there, and on the benchmark's GP problem, whose exact posterior is known, NUTS's widths came out 0.23 standard deviations too narrow, with 31 divergences of its own. A higher target means smaller steps and more gradient evaluations per draw, and here it takes 0.99 to remove the divergences.\n", + "\n", + "emcee is cheap in five dimensions, but it needs a longer run than it first appears to. At 10 000 steps (printed above) its $\\tau$ of about 105 steps passes emcee's own $50\\tau$ rule, yet the rank-normalised split $\\hat R$ is 1.019: the walkers drift together, slowly enough for the $50\\tau$ rule to miss it. At 30 000 steps it passes both, with 4741 effective draws in under a minute, about six times NUTS's rate. On a problem this small emcee is the cheaper choice, provided we check it with split $\\hat R$. The two posteriors agree, their widths within about 15 % of each other, but two samplers agreeing is not a check against an exact posterior: on the benchmark's `gp` problem, whose posterior is exact, neither NUTS nor emcee got the widths within the tolerance (0.23 and 0.30 standard deviations off).\n", + "\n", + "The Laplace approximation gets the length scale's width roughly right ($\\log\\ell$ 0.70 against 0.69 from NUTS), but not the line's: $m$ comes out 0.040 against 0.081, and $b$ 0.057 against 0.224 (standard deviations, which the posterior's tails dominate). The posterior is not Gaussian. It puts more mass at larger amplitudes than the mode does — its $\\log A$ marginal sits nearly a unit above the Laplace Gaussian, which is centred on the mode at $-3.36$ — and a larger amplitude lets the line move further. A curvature taken at the mode cannot see that. Laplace is a quick check of where the posterior is, not a substitute for sampling it." + ] + }, + { + "cell_type": "markdown", + "id": "edfcec53", + "metadata": {}, + "source": [ + "## Takeaways\n", + "\n", + "- **Choose the sampler by the problem.** With many parameters and a smooth posterior, NUTS wins outright: the 33-parameter hierarchy converged in about 40 seconds, while emcee had not converged after a minute. With a handful of parameters, emcee is cheaper and agrees with NUTS, given a long enough run; neither is exact on a GP's funnel (see the benchmark's `gp` row). For reaction models with local modes, or when the evidence is wanted, the notebooks use pocomc, which the [benchmark](/benchmarks.md) finds correct and fastest there.\n", + "- **Gradient samplers need the unconstrained density.** `log_posterior_unconstrained` and `to_theta` handle every bound, including those implied by a prior (recipe 41).\n", + "- **Read the diagnostics before the ESS.** An ESS means something only when the rank-normalised split $\\hat R$ is below about 1.01 and, for NUTS, there are no divergences; raising the target acceptance rate is the first cure. For emcee, also check that the run is longer than $50\\tau$, and remember that the two checks catch different things: on the GP, the $50\\tau$ rule passed a run that split $\\hat R$ rejected.\n", + "- **Start where the problem allows.** On a hierarchy the MLE is a ridge rather than a point, and the MAP is not typical of the posterior, so both samplers start from prior draws.\n", + "- **The Laplace approximation is a quick check.** The exact Hessian makes it nearly free, but it misses the width that a non-Gaussian posterior adds.\n", + "\n", + "The benchmark behind these numbers, on more problems and scored against exact or long-run reference posteriors, is `benchmarks/bench_samplers.py`; its tables are on the [benchmarks](/benchmarks.md) page." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/hierarchical_calibration.ipynb b/examples/hierarchical_calibration.ipynb new file mode 100644 index 0000000..637f5bb --- /dev/null +++ b/examples/hierarchical_calibration.ipynb @@ -0,0 +1,958 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "9ca1c7a6", + "metadata": {}, + "source": [ + "# Hierarchical calibration: a hierarchy on the physics parameters\n", + "\n", + "Several experiments at different energies constrain a model whose parameters run\n", + "with energy. We have to assume *something* about how they run — and if that\n", + "assumption is wrong, a global fit is confidently wrong everywhere, including at\n", + "energies nobody measured.\n", + "\n", + "The repair is to stop insisting that one smooth curve describes every dataset,\n", + "and instead let each dataset have its own small deviation, with the *size* of\n", + "those deviations learned from the data. That is a [hierarchical model](https://en.wikipedia.org/wiki/Multilevel_model), and the\n", + "textbook version of it opens this notebook: the eight-schools problem from\n", + "[Gelman, Carlin, Stern, Dunson, Vehtari & Rubin, *Bayesian Data Analysis*, 3rd\n", + "edition](http://www.stat.columbia.edu/~gelman/book/) (BDA3), chapter 5.\n", + "\n", + "Recipes: 11, 17, 22, 24, 30, 35, 38, 40, 41 (see [the recipes](/recipes.md))" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "b449277b", + "metadata": {}, + "outputs": [], + "source": [ + "import blackjax\n", + "import jax\n", + "import jax.numpy as jnp\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import plotstyle\n", + "from budget import QUICK_NUTS, budget # sampler budgets, cut in CI's quick run\n", + "from scipy import stats\n", + "\n", + "import rxmc as rx\n", + "\n", + "plotstyle.use()" + ] + }, + { + "cell_type": "markdown", + "id": "3416ec59", + "metadata": {}, + "source": [ + "## Prologue: eight schools\n", + "\n", + "Eight schools each ran a coaching programme, and each reported an estimated\n", + "effect $y_j$ on test scores together with the standard error $\\sigma_j$ of that\n", + "estimate. The estimates range from $+28$ to $-3$ points, but the standard\n", + "errors are 9 to 18 points, so the spread between schools is roughly what pure\n", + "noise would produce anyway.\n", + "\n", + "Two extreme readings are available. *No pooling* takes each school's estimate\n", + "at face value, which over-fits eight noisy numbers. *Complete pooling* says the\n", + "programmes are identical and averages them, which throws away any real\n", + "difference. The hierarchical model sits between: the true effects $\\alpha_j$\n", + "(BDA3 writes $\\theta_j$) are drawn from a common distribution,\n", + "\n", + "$$\\alpha_j \\sim \\mathcal{N}(\\mu, \\tau^2),$$\n", + "\n", + "and we infer $\\mu$, the spread $\\tau$, and every $\\alpha_j$ at once. How much a\n", + "school is pulled towards the common mean — *shrinkage* — follows from how big\n", + "$\\tau$ turns out to be relative to that school's own error.\n", + "\n", + "We write it non-centred, $\\alpha_j = \\mu + \\tau \\eta_j$ with\n", + "$\\eta_j \\sim \\mathcal{N}(0, 1)$, because sampling $\\alpha_j$ directly leaves a\n", + "funnel-shaped posterior that samplers struggle with. We sample it, and every\n", + "hierarchy below, with the\n", + "[No-U-Turn Sampler](https://jmlr.org/papers/v15/hoffman14a.html) (NUTS) through\n", + "[blackjax](https://blackjax-devs.github.io/blackjax/) (recipe 41). NUTS follows\n", + "the gradient of the log posterior, so it moves through many parameters at once\n", + "where a random walk would diffuse; on a 33-parameter hierarchy it is the only\n", + "sampler we benchmarked whose means and widths match the exact posterior\n", + "([benchmarks](/benchmarks.md)). It runs on the unconstrained scale,\n", + "$\\log\\tau$ in place of $\\tau$. Each of four chains starts from its own prior\n", + "draw rather than at the posterior's mode, for two reasons. In the non-centred\n", + "form the mode is not typical of the posterior: the $\\mathcal{N}(0, 1)$ prior\n", + "rewards small $\\eta_j$, so the mode trades them for a large $\\tau$, well above\n", + "the bulk of the posterior. And starts spread across the prior make the\n", + "convergence check meaningful: we accept a fit only when the rank-normalised\n", + "split $\\hat R$ is below 1.01 and count the divergent transitions." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "b9a36078", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "columns: ['mu', 'tau', 'eta_0', 'eta_1', 'eta_2', 'eta_3', 'eta_4', 'eta_5', 'eta_6', 'eta_7']\n" + ] + } + ], + "source": [ + "Y = np.array([28.0, 8.0, -3.0, 7.0, -1.0, 1.0, 18.0, 12.0])\n", + "S = np.array([15.0, 10.0, 16.0, 11.0, 9.0, 11.0, 10.0, 18.0])\n", + "schools = rx.Dataset(np.arange(8), Y, S, label=\"schools\")\n", + "\n", + "mu = rx.Parameter(\"mu\", prior=stats.norm(0.0, 25.0), latex=r\"\\mu\")\n", + "tau = rx.Parameter(\n", + " \"tau\", prior=stats.halfnorm(scale=10.0), bounds=(0.0, np.inf), latex=r\"\\tau\"\n", + ")\n", + "etas = [\n", + " rx.Parameter(f\"eta_{j}\", prior=stats.norm(0.0, 1.0), latex=rf\"\\eta_{j}\")\n", + " for j in range(8)\n", + "]\n", + "model = rx.Model(lambda x, mu, tau, *eta: mu + tau * jnp.stack(eta), [mu, tau, *etas])\n", + "p_schools = rx.Problem([rx.Constraint([rx.Comparison(schools, model)])])\n", + "print(\"columns:\", p_schools.names)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "b4c01254", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "R-hat 1.001, min bulk ESS 2250, 1 divergences\n" + ] + } + ], + "source": [ + "def nuts(problem, seed, chains=4, warmup=budget(1000), draws=budget(1000), label=\"\"):\n", + " \"\"\"NUTS on the unconstrained density, one window-adapted chain per prior\n", + " draw; the draws pooled, in problem.names order.\"\"\"\n", + " logdensity = problem.log_posterior_unconstrained\n", + " starts = problem.sample_prior(chains, rng=seed)\n", + " runs, divergent = [], 0\n", + " for key, theta0 in zip(jax.random.split(jax.random.key(seed), chains), starts):\n", + " k_warm, k_draw = jax.random.split(key)\n", + " adapt = blackjax.window_adaptation(blackjax.nuts, logdensity, **QUICK_NUTS)\n", + " (state, tuned), _ = adapt.run(\n", + " k_warm, problem.to_unconstrained(theta0), num_steps=warmup\n", + " )\n", + " step = jax.jit(blackjax.nuts(logdensity, **tuned).step)\n", + "\n", + " def one_step(state, key):\n", + " state, info = step(key, state)\n", + " return state, (state.position, info.is_divergent)\n", + "\n", + " _, (zs, div) = jax.lax.scan(one_step, state, jax.random.split(k_draw, draws))\n", + " runs.append(np.asarray(jax.vmap(problem.to_theta)(zs)))\n", + " divergent += int(div.sum())\n", + " runs = np.stack(runs)\n", + " rhat = np.max(blackjax.diagnostics.rhat(runs))\n", + " ess = np.min(blackjax.diagnostics.ess_bulk(runs))\n", + " print(f\"{label}R-hat {rhat:.3f}, min bulk ESS {ess:6.0f}, {divergent} divergences\")\n", + " return runs.reshape(-1, problem.ndim)\n", + "\n", + "\n", + "s_schools = nuts(p_schools, 0)\n", + "mu_draws = s_schools[:, p_schools.columns(mu)]\n", + "tau_draws = s_schools[:, p_schools.columns(tau)]\n", + "alphas = mu_draws + tau_draws * s_schools[:, p_schools.columns(etas)]" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "f019a0e5", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhQAAAFpCAYAAADELrFnAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvctoD+AAAAAlwSFlzAAAQ6wAAEOsBUJTofAAAQ2BJREFUeJzt3XlcVOX+B/DPsAmMwyoMiApqKq6IKQolpoJKJlpWpGZampaWlV3T9my/1XXPUnOpMOvnit4iRa8hqUiauCYuNwlkEGQblmF/fn/44lzHQRvmHGXAz/v14lXznGfOfM/jzPDhnOecoxJCCBARERHJYNPYBRAREVHTx0BBREREsjFQEBERkWwMFERERCQbAwURERHJxkBBREREsjFQEBERkWwMFERERCQbAwURERHJxkBBzV5paSkqKyulx0IIlJSUoKqq6qbPqaioMGqrqalBSUkJampqblmt9D9lZWUm/wbWrDHrLSsrQ3l5eaO8tpJqa2tNPmP1tZF1YqCgv1VSUnLDL8q6X7LV1dW3uSrzubq64rXXXpMeX758GRqNBitWrDDqV1hYiHHjxsHFxQVarRYvv/wyAODEiRMIDQ2FRqOBj48PduzYcVvrb4jKykqUlJQ0dhlmu9kv4Q4dOmD69Om3uSLLNWa9ffr0weOPP94or62klJQUaDQaxMfH37TNEgwktx4DBd1UeXk5NBoNpkyZUu/yvXv3QqPR4KuvvrrNlVnOxsYGarUaDg4ORu0fffQREhIScPr0aZSUlGDZsmUAgMmTJ8PV1RX5+fkoKSnBmDFjGqFq83z44YfQaDRN5q/Vbt26YdKkSY1dBjVTGRkZmDVrFtq3bw9nZ2d4enpi+vTpKCoqauzSmiW7xi6A6Hbz9vau96/4X3/9FX379kWbNm2kNoPBgN9//x0LFy6Eo6Pj7SyTiGRau3YtOnXqhMOHD8PDwwMJCQl48MEHkZeXh02bNjV2ec0OAwXdcpWVlSZ7A4Cr8xTs7e2NllVUVKCqqgpqtRoqlUpqLykpQYsWLWBvb/+3r1dbWwvg6p6I+gghUFpaKq2vpqYGBoMBly9fhoeHh1HYyMjIAACoVCqUlJRApVJBrVabrLOqqgp2dnZGNV/7Wo6OjrCzu/pxKy8vh729PWxtbY363micKisrUVlZiZYtW0rrrK2tNXl+RUWFNFektLRUOgzl7Ox8w7Gorq6W9maoVCo4OTnV27e+GgwGA5ydnY361e1Wvr62+pSUlEAIgerqamnMbW1t4eTkdMNa68bwZhpSw7WEEBBC3HCsru1X3/hfz9x6q6qqzHpfm9vveuZu182UlZXB1tYWLVq0kGoRQpi8X2/0Hq77HNQx97Ncn7rPq5OTU73/BmVlZbCxsYGjoyPeeusto2XDhg1DWFiY7MMnVD8e8qBbIicnB08++STc3d3h5OQEd3d3TJkyBVeuXJH69OvXD4899pjR8+rmKvz73/+W2n7//XdoNBps27btpq/5119/ITo6Go6OjlCr1Xj44YdRUFBg0u/6ORTx8fHw8fHBf//7X+n/63769u0LAJg7dy58fHzQvXt3aT0GgwGvvvoq2rZtCycnJzg5OWHUqFE4d+6c1CctLQ0ajQaxsbFYsWIF/P394ezsjISEBADAyZMnMXr0aKjVajg7O8PX1xdvvPGG0ZyUt956CxqNBqWlpZg0aRJatmwJR0dHREVFQafTSf1eeOEFfPbZZwAAf39/aRtOnTp1wzH74YcfpH5eXl6wt7dHr1698O233xr1q6uhqKgIjz/+ODQaDTp06CAtX7NmDXr16gUHBwc4Ojqib9++2Llz503/vXx8fJCRkYG4uDiphqFDh5r0S05ORnBwMJycnODh4YH33nuv3vVZUgMAbNy4UVq/i4sLgoODERsbCyGEUb+1a9ciODgY9vb2cHV1RXh4OPbt22dRvdXV1Zg/fz7atWsHR0dHODo6YsSIEUhNTbWon5ztMkfd/JCkpCT06dMHzs7O0i/r/Px8zJgxA1qtFs7OzmjZsiUmTJiAy5cvS8/PyMgw+ly1aNECbdu2xeuvv37TydH1ycrKgpubm0lYAICLFy9Co9Hgo48+qve52dnZ+O2339ClS5cGvSaZSRDdhMFgEABETEyMKC4uNvnZsWOHACC++OIL6TklJSWiS5cuon379uLgwYOiqqpKHDhwQPj7+4tu3bqJ0tJSIYQQs2bNEq6urqK6uloIIURubq5QqVSiZcuW4rnnnpPW9/HHHwsbGxtx5cqVG9ZZXFwsOnToILp27SpSU1NFZWWl2LVrl3jssceEra2tePnll6W+Op1OABBLly41WkfHjh3F6NGjjdr+/PNPk+0TQoiqqioRHh4uWrduLeLj40VFRYXIysoSo0ePFt7e3kKn0wkhhPjjjz8EABEVFSXmzp0r8vPzxZkzZ8Thw4fF77//LtRqtRg1apS4cOGCqK6uFnv37hU+Pj7iiSeekF5r7ty5AoB4+umnxc6dO0VlZaU4cuSI0Gq14sEHHzSq6+233xYAhMFguOFY3UxhYaH46KOPhI2Njdi1a5dJDRMnThTx8fGivLxcfPfdd0IIIV577TVhb28vli5dKvR6vdDr9eLdd98Vtra2IiEh4aav5+/vL2JiYupdptVqxeDBg8Vjjz0m0tPTRXl5ufjkk08EABEXF2fU19IaDh8+LGxsbMSHH34oSktLRVVVlTh+/Lh44oknRF5entRvzpw5ws7OTnz88cciNzdXVFRUiKSkJDFt2jSL6n388ceFk5OTiI2NFeXl5eLixYsiIiJCqNVqcfLkyQb369Klixg7dmyDt8tcWq1WhIeHizFjxog///xTFBQUiH//+9+iqKhIBAYGisDAQLF//35RVVUlzp07J0JDQ0VgYKD0Wb9eRUWF2LZtm3B1dRWvvfaa1H7w4EEBQOzYseOmbWPGjBFarVZUVFQYrXfu3LlCpVKJP//80+Q1c3JyRPfu3YWnp6c4duxYg8eA/h4DBd1UXaCws7MTarXa5MfR0dHkF+7ixYsFAJMv8p07dxr9It++fbsAIPbv3y+EEGLDhg3C0dFRvPLKK6JLly7S84YOHSruvvvum9a5aNEiAUAcOnTIqH3lypUCgOKBYt26dQKA+PHHH43ai4qKhJubm5g7d64Q4n+BIiQkxKTm++67T7Rr106UlZUZtX/zzTcCgDh9+rQQ4n+/zNetW2fUb/78+UKlUon8/HypTU6gqK6uFiUlJaK4uFgEBQWJ8ePHS8vqali+fLnRcy5cuCBsbGzEnDlzTNY3ZMgQ0b9//5u+5t8FCldXV1FYWCi11dbWig4dOhj9O8mpYdmyZQLATcNqWlqasLGxES+++OJNt8Xceo8dOyYAiNdff93o+VeuXBEtW7aUgoG5/YQwDRTmbFdDaLVa4eTkZLK+d955R6hUKqNwI8TVz42NjY3J50aIq2NS9z577rnnROvWraVl5gaKXbt2CQBiw4YNUltFRYXw8vISERERJq9ZUVEh+vbtK9zc3MTRo0cbvP1kHh7yILPExMSgpKTE5Ke+Uyh/+eUXODs7IyIiwqh92LBhcHJywt69ewEA9913H+zt7bFr1y4AQEJCAgYOHIjo6GikpaXhr7/+gsFgwP79+xEZGXnT+n755Rd4enoiJCTEqP2BBx6Qs9k39NNPP8HJyQnh4eEoLy+HwWCQjjP36tULSUlJRv1Hjhxp9LikpAT79u1DREQEVCoVDAaDtI5+/foBuDpJ9FrDhw83etytWzcIIXDx4kWLt6OsrAyvvPIKAgICYG9vDy8vL/j4+ODkyZO4cOGCSf/rt2Pnzp2ora3F/fffbzQOZWVlCA0NxW+//Sbr2gwDBgyAq6ur9FilUqFr1674888/Fanh7rvvhkqlwiOPPIK4uDgUFhaa9ElISEBtbS0effRRRer95ZdfAACjR482eq6npycGDhwofT7M7WfpdjXUgAED4OnpadT2008/oWPHjujYsaPR2Ht5eaFdu3ZGn4MVK1agd+/ecHBwgIeHB3x8fLBy5UpkZWU1+KykiIgIdO7cGcuXL5faNm7ciNzc3HrPSPvhhx9w+PBhrFu3Dr17927YhpPZGChIcQUFBfD29q53mbe3tzSvQaPRoH///lKg2L17N4YNG4b+/fvDxcUFu3btQlJSEsrLy/82UBQWFsLLy8ukvb42JeTk5KCiogI+Pj5o1aoVvLy84O3tDa1WiyNHjpj8AmvdurXR47y8PNTW1iI2NlZ6ft06+vbtC7VabXImilarNXpcN0FSzilwU6ZMwYoVK/D555+jtLQUZWVlKCkpwYABA+q9tsj125GTkwPganC7dhy8vb2xaNEiODk5Qa/XW1zf9dsMXN3ua7dZTg0DBgzA1q1bUVVVhYcffhienp7o168fvvnmG6lP3bwfX19fReqte//X9xm59vNhbj9Lt6uhrv+3B66O/Z9//olWrVqZfA5yc3NhMBgAXA0TzzzzDCZOnIjs7GxUVFSgpKQEc+bMAYAGX8dGpVLh2WefRVJSkjRH6IsvvoCHhwcefPBBk/5paWkArv4RQ7cOAwUprlWrVsjOzjaZ/CWEQHZ2ttEv+cjISKSkpODQoUP466+/EBkZCTs7OwwePBgJCQlISEiAk5MT7rnnHrNe83r1tSnB29sbGo0GxcXF9e65OXz4sFH/62f7e3p6wsbGBtOnT6/3+SUlJXjppZeMnnP9GSRyVVdXY9OmTXjyyScxcuRIo7Mr/vvf/9b7nOu3o+6X3b59+264HXJCnTnbLLeG0aNHIykpCUVFRdi1axdat26NSZMmYcuWLQCuTh4F/nfGj9x6W7VqBQBGE2rr6HQ6qVZz+93I321XQ9V3xoq3tze6det2w3Gve60NGzYgKCgIL7/8stFejhu9z8wxefJkODs7Y/ny5Th+/Dj279+PCRMmSGeiXMvW1hZqtdqss27IcgwUpLhhw4ahvLzc6EwNAIiLi0NFRYXR3obIyEjU1NRg3rx50Gq16NWrl9S+Z88e7Ny5E+Hh4fV+SVwrIiIChYWF0m7iOps3b1Zmo64zZswYFBUV4ccff7To+S1btkRERAS2b9+u6JUt6/ZamHOYQaVSwdbW1uR0wp9//rneX2L1uf/++2Fvb4/vvvuu4cXiar1yL1ctt4Y6zs7OGDp0qHSGS3JyMgAgKioKdnZ2+Prrr2Wtv07dYa6NGzcatWdnZ2Pfvn3S58Pcfn/nRtsFXD39U85lrceMGYNTp07h2LFjN+1nZ2dn8j7Ly8uTddVZNzc3jB8/Ht9++y0++eQTALjhBfhef/11ZGdnm5zmTMpioCDFPfHEE7j77rvx9NNPY/v27dDpdIiLi8P06dMREhKCJ554QuobEhICV1dX/PLLL9IXKHA1lOTl5eHEiRNmfXFOmjQJPXv2xKRJk7Br1y7odDrExsbi2LFjDb4egTliYmLw0EMPYdKkSfjyyy9x4cIF6HQ67Nu3DzNmzJC+4G5m6dKlMBgMGDFiBPbs2YPLly/j7Nmz+L//+z+Eh4cjPT29wXUFBQUBuHrMuLCwECUlJdJ1Oa5na2uL6OhorFmzBvHx8cjOzsaWLVswf/58hIaGmvV6/v7++OSTT7Bo0SK88sorOHnyJHJzc3H48GF8+OGHGD9+/N/Wm5KSgj/++AMlJSXSLvKGkFPD+++/j+eeew5JSUm4fPky0tPT8eGHH0KlUklzVtq1a4cPP/wQa9aswezZs3Hq1ClcunQJmzdvxsMPP9zgert06YKZM2di6dKlWLRoETIzM5GSkoLo6Gg4Ozvj3XffbVA/S7cLABYvXizrstYvvvgi+vfvj1GjRuG7775Deno6MjIykJCQgAkTJmD9+vUAgIceeghHjx7FwoULkZ2djYMHDyI6OhpRUVEWvW6dmTNnori4GOvXr8fdd98tvf+vN3v2bGg0Gly6dEnW69HfaORJoWTlysvLhVqtFlOmTKl3+d69e4VarRZfffWVUXtRUZF0toabm5vo0qWLmDt3riguLjZZR0xMjFCr1eLbb781au/atatQq9Vmn+KVm5srpkyZInx9fYWfn5945plnRGlpqcmpaZcvXxZqtVqsWLHC6Pm9evUSjz32mFFbenp6vdsnhBA1NTVi5cqVYuDAgcLb21v4+fmJwYMHixUrVkhnWaSlpQm1Wi1iY2PrrTkrK0u8+OKLomvXrsLd3V0EBgaKcePGiaSkJKnPW2+9JdRqtclzExIShFqtFvv27TNqf/3110WHDh2ERqMRarVaHD9+/IZjVlBQIJ599lkREBAgfH19xaOPPioyMjLEAw88IAYOHPi3NdTZs2ePGD16tPDz8xNeXl4iJCREvPnmmyI7O/uGzxHi6viOHDlSeHt7i5YtW4rQ0FBpWYcOHcT06dNNnjNp0iTRrVs3RWooLS0VX3zxhRg0aJDQarXC399fPPDAA2L37t0mfXfs2CEiIyOFt7e3dHZK3Zk4Da23trZWLF++XPTt21d4eHiItm3biokTJ4oLFy5Y1K9Pnz7i8ccfb/B2vfnmmwKASE1NveEY3WzbhBDS6bEhISHC09NT+Pv7ixEjRogNGzaIqqoqaTs+++wz0a1bN9GqVSsxaNAgsW/fPvHPf/5TqNVqUVJSIoQQIiUlRajVahEfHy+tv762a4WFhdV7BtK1Zs+eLdRqtbh06dJNt5PkUQlhwVVOiIioyQsPD4enpye2bt3a2KVY7L777kNKSop0wStqPJyhQkR0BzIYDDh9+jQSExMbuxSLZWVlISkpCY8//jjDhBVgoCAiugM5OTkZXQq/KamqqoJer8drr70GGxsbzJ07t7FLInBSJhERNTELFy5E+/btkZKSgm+//RbdunVr7JIIAOdQEBERkWzcQ0FERESyMVAQERGRbAwUREREJBsDRT2qq6uRmZnZ4BvWEBER3akYKOqRnZ2Ntm3bKnpjqfz8fMXWRVdxTJXF8VQWx1N5HFNlKT2eDBS3CU+mUR7HVFkcT2VxPJXHMVWW0uPJQEFERESyMVAQERGRbAwUREREJBsDBREREcnGQEFERESyMVAQERGRbAwUREREJBsDBREREcnGQEFERESyMVAQERGRbAwUREREJJtdYxdAluny8X/M6pc2b8gtroSIiIh7KIiIiEgBDBREREQkGw953CbjYo8g3fD3w81DFERE1BRxDwURERHJxkBBREREsjFQEBERkWwMFERERCQbAwURERHJxkBBREREsjFQEBERkWxWcx0KvV6P77//HqdOnYKnpyeio6PRu3dvk36bN29GYmIi1Go1YmJiLO5DREREyrGKPRRnzpxBSEgIjh07hrvuuguXL19GSEgIli9fbtRv2rRpmDlzJry8vFBUVIR+/fph+/btDe5DREREyrKKPRReXl747bffoNFopDYnJycsXLgQM2bMAAAcOXIEq1atQmJiIsLDwwEA9vb2mDVrFkaNGgWVSmVWH2tn7k2/iIiIrIlV7KHw9PQ0ChMAkJOTA61WKz3esWMH/Pz8pKAAAOPHj0d6ejqOHz9udh8iIiJSnlXsoajz0Ucf4ezZs/jjjz+g0Wjw7bffSsvOnz8Pf39/o/7t27eXlgUFBZnVpz56vR56vV56rNPpFNkeIiKiO4VVBYru3bvDzc0NDg4O2LhxI/bv3y8FAoPBYLIXo+6xwWAwu099FixYgPnz55u0FxQUwMnJyfINuoZPixpF1tNQeXl5jfK6t8O1IZDk43gqi+OpPI6psvR6PTw9PRVbn1UFiujoaOn/O3fujOnTp+PBBx+EWq2Gi4sLMjMzjfrn5+cDAFxcXKT//l2f+syePRtTp06VHut0OoSEhMDd3V2xwc6usDXrbqNKU/LNYo2a+/bdbhxPZXE8lccxtV5WMYeiPn369EFZWZl0+KFHjx44e/YsqqurpT6nTp0CcHXPhrl96uPi4oI2bdpIP76+vopvDxERUXNmFXso9u3bh169esHNzQ0AIITA+vXrodVqERAQAAAYO3YsXn31VcTGxmLy5MkQQmDZsmUICQlBx44dze5zp2nIWSNp84bcwkqIiKg5s4pAUVxcjNDQUPj7+8PDwwNHjhxBRUUFNmzYADu7qyUGBARg8eLFmDFjBjZt2gSdToesrCzs2rVLWo85fYiIiEh5KiGEaOwiAKCsrAwHDhxAbm4u2rVrh/79+0th4loXL17EgQMH4OzsjKFDh5pMwjS3z81kZmaibdu2yMjIQJs2bSzepmsNW7yrUeZQNERT20ORl5fH46kK4ngqi+OpPI6pspQeT6v5Defs7IyIiIi/7RcQECAdBpHTh4iIiJRjtZMyiYiIqOlgoCAiIiLZGCiIiIhINgYKIiIiko2BgoiIiGRjoCAiIiLZGCiIiIhINgYKIiIiko2BgoiIiGRjoCAiIiLZGCiIiIhINqu5lwc1PnNvdd7UbiJGRES3HvdQEBERkWwMFERERCQbAwURERHJxkBBREREsjFQEBERkWwMFERERCQbAwURERHJxutQ0C3D61oQEd05uIeCiIiIZGOgICIiItkYKIiIiEg2BgoiIiKSjYGCiIiIZONZHtRg5p69QUREdw7uoSAiIiLZGCiIiIhINqs65PHXX38hPT0dAQEBaNu2rdGyyspK/Oc/prvag4ODodVqjdqKi4tx9OhRqNVqBAcHw8aGuYmIiOhWsopA8dtvv+HFF19EZmYm2rVrh+PHjyM8PBzfffcdNBoNACA/Px9RUVG455570LJlS+m5b7zxhlGg2LJlC5588kkEBATgypUrcHV1RXx8PPz9/W/7dhEREd0prCJQ6HQ6/Otf/8KAAQMAADk5OQgJCcFrr72GpUuXGvX98ssv0aNHj3rXk52djYkTJ2L+/Pn4xz/+gaqqKkRERGDq1KlISEi45dtBRER0p7KKQBEdHW302NvbG1FRUTh06JBJ3zNnziA/Px933XUXWrdubbRs06ZNsLGxwXPPPQcAsLe3x8svv4zRo0cjMzMTbdq0uXUbQUREdAezyskFtbW1SE5ORpcuXUyWzZs3D6+88go6duyIsWPHorCwUFqWmpqKwMBAODo6Sm3BwcEAgOPHj9/yuomIiO5UVrGH4nrvv/8+0tLSsH79eqnN0dERP/30E6KiogAA6enpCA8Px4svvoh169YBAAoLC+Hh4WG0Lk9PTwBAQUHBDV9Pr9dDr9dLj3U6nVKbQkREdEewukDx5Zdf4oMPPsDGjRvRrVs3qd3NzU0KEwDg7++Pl156CW+99RbWrl0LlUoFBwcHGAwGo/WVlZUBABwcHG74mgsWLMD8+fNN2gsKCuDk5CR3kwAAPi1qFFlPc5SXl2fR864NgSQfx1NZHE/lcUyVpdfrpT+6lWBVgWLVqlV44YUX8P3335vMq6iPh4cHiouLUVpaipYtWyIgIAAHDx406pOZmQkACAgIuOF6Zs+ejalTp0qPdTodQkJC4O7urthgZ1fYIt1gVcNtNeSMsZIfBuJ4Ko3jqTyOqfWymjkUq1evxnPPPYcNGzbgwQcfNFle3yGLH3/8ER07dpROIx0xYgQuXryIY8eOSX02b94Mb29vaS5FfVxcXNCmTRvpx9fXV4EtIiIiunNYxZ/MGzduxNNPP41p06bB2dkZP//8M4Cr8ybuu+8+AMBXX32FAwcOYOTIkdBoNIiLi0NcXBz+7//+T1pPeHg4oqOj8fDDD+P1119HVlYW/vnPf2LFihWws7OKTSUiImqWrOK3bG5uLoYNG4aLFy9i0aJFUruXl5cUKObMmYOdO3di69atyMvLQ6dOnfDHH3+gffv2RuvauHEjli9fju3bt8PZ2RlxcXFGcy+IiIhIeSohhGjsIqxNZmYm2rZti4yMDMWuXTFs8S7OobiBtHlDLHpeXl4ej6cqiOOpLI6n8jimylJ6PK1mDgURERE1XQwUREREJJusQJGQkCCdpmkwGPDII48gICAAH3zwgSLFERERUdNgcaAoLCzEjBkzEBgYCABYuXIljhw5gsmTJ+PTTz81uR4EERERNV8WzxJMTk5GYGAg3N3dAQA7duzAe++9hwkTJqCyshI///wzQkNDFSuUmq8uH//HrH6WTt4kIqJbz+I9FAUFBVCr1QCAqqoqHDp0CEOGXP3C9/X1NbppFxERETVvFgeKwMBA7NmzB2lpaVi9ejXatm0rXWHyzJkz0qEQIiIiav4sPuQRHByMgQMHIjAwEDY2Nvjmm28AACUlJYiPj8e7776rWJFERERk3WRdaWnTpk04ceIENBoNOnToAAAoLi7G+vXrefERIiKiO4jFgeLkyZPIycnBPffcgxYtWkjtvr6+vLkWERHRHcbiORQnTpxAREQE3N3dMXz4cHz66adITU0Fr+RNRER057E4UIwbNw46nQ6rVq2Cr68vFi9ejODgYGi1WowbNw67d+9Wsk4iIiKyYrKulKnVajFhwgSsW7cOmZmZSEhIQLt27fD999/j+++/V6pGIiIisnKyJmWWlpYiMTERCQkJSEhIwB9//IHevXtj7ty5iImJUapGIiIisnIWB4rNmzdj/Pjx8PHxQWRkJN58800MHToUrVq1UrI+ogbjlTeJiG4/iw951NbWora2FjY2NkY/REREdOexOAE88sgjyMvLw6JFi+Dg4IA33ngDXl5eCAkJwRtvvIHjx48rWScRERFZMVm7FFxcXDB69GgsW7YMaWlp2LlzJ2pqavDBBx9gyZIlStVIREREVk7WpMycnBzs2bMHu3fvRkJCAjIyMtCqVSs8+uijnJRJRER0B7E4UGzYsAETJkyAg4MD7rnnHsyYMQORkZHo06cPVCqVkjUSERGRlbM4UHTv3h3x8fEIDw+Hk5OTkjURERFRE2NxoOjVqxd69eqlZC1ERETURMmaQ1FTU4N169bh0KFDyM3NNbqPR2RkJGbOnCm7QKI6119fwt+pGukGWW9hIiJSiKxv44ceegi//fYbtFot9Ho92rZti+TkZLi4uOD+++9XqkYiIiKychafNpqamor9+/fj5MmTmDlzJgYPHoxffvkFx44dg0qlQp8+fZSsk4iIiKyYxYEiLS0NQ4YMgYeHB2xtbVFRUQEA6NKlC6ZPn47t27crViQRERFZN4sDRXFxMVxcXAAAXl5euHTpkrTMzc0N+fn58qsjIiKiJkGRm2/06dMHhw4dwpYtW/D7779j1apV6Ny5sxKrJiIioibA4kmZd911l3QBq9atW2Pu3LkYO3YsgKsB46mnnlKmQqJbhHclJSJSjsV7KAYOHIhJkyZJj9966y1kZ2fj5MmTSElJQcuWLc1el8FgwNKlSxEWFgY/Pz/cc889WL9+vUm/S5cuYdy4cWjdujU6deqEd955BzU1NQ3uQ0RERMqyeA/F119/jQMHDuCrr76S2rRaLbRabYPXtWjRImRnZ+Nf//oX2rVrh927d+Opp56CwWDA1KlTAQDV1dUYPnw4/Pz8sGfPHuh0OsTExKC8vBwff/yx2X2IiIhIeRbvofDw8EBeXp4iRcybNw+LFy9GaGgo/Pz8MGnSJMTExOCbb76R+mzfvh2nT5/G2rVr0bVrVwwZMgTvvPMOlixZgtLSUrP7EBERkfIsDhTh4eFITU3F+fPnZRdR383ESkpKjO4RkpSUhK5du6J169ZSW2RkJAwGA44cOWJ2HyIiIlKexYc80tLS4O7ujqCgIAwfPhy+vr5GwSAsLAzjx4+3aN1JSUmIi4vDt99+K7VdunTJ5HCKt7c3ACArK8vsPvXR6/XQ6/XSY51OZ1HdREREdyqLA0Vubi4cHBzQs2dPZGVlmfzC9vPzs2i9Z86cwdixYzFlyhSTQGJjY7xDxc7uavnX3kPEnD7XW7BgAebPn2/SXlBQoNidVH1acGKo0m7XmCp1aM/aXRuqST6Op/I4psrS6/Xw9PRUbH0WB4ro6GhER0crVggAnD17FkOGDEFUVBS+/PJLo2Xe3t44e/asUVtOTo60zNw+9Zk9e7Y0+RO4uociJCQE7u7uig12doUtb2R1C9yOMVXyA2ft7qRtvR04nsrjmFovRS5spYRz585h8ODBiIiIwNq1a032NPTv3x+nTp0yugJnYmIi7O3tpfuGmNOnPi4uLmjTpo304+vrq/DWERERNW8NChRCCFRXV5v1U1tba/Z6L1y4gMGDB2Po0KFYt26dSZgAgLFjx8LHxwcvvfQSSkpKcOHCBbz//vuYOHEi3N3dze5DREREymtQoFi9ejXs7e3N+pk2bZrZ6120aBEuXbqEuLg4eHh4wM3NDW5ubujevbvUx9nZGfHx8dJk0O7du+Pee+/F0qVLG9SHiIiIlNegA9ARERHYuHGj9Pjzzz/HhQsX8PTTT6N9+/bIzc3F+vXrcfnyZTzzzDNmr/eTTz7Be++9Z9J+/Z6KHj16IDk5GRUVFbCzs4Otra3Jc8zpQ0RERMpqUKAICAhAQEAAgKtzHs6fP4+jR4+iVatWUp9Zs2ZhyJAhOHfuHPr27WvWep2cnBp0NkWLFi0U6UNERETKsHhSZkpKCsLCwozCBADY2tpi9OjROHjwoOziiIiIqGmwOFA4Ojri1KlT9d546/jx43B0dJRVGBERETUdFgeKiIgIZGdnY+zYsdi/fz8uXbqE1NRU/OMf/0BsbCweffRRJeskIiIiK2bxVYFcXV3x888/Y9q0abj33nuldj8/P/zwww9mz58gIiKipk/WZQb79u2LI0eO4OzZs0hPT4dWq0VgYCAnRBIREd1hZF+3WKVSoUuXLujSpYsS9RAREVETZDWX3iYiIqKmi4GCiIiIZGOgICIiItksDhQ1NTWorq5WshYiIiJqoiwOFF9//XWD7tdBREREzZfFgcLDwwN5eXlK1kJERERNlMWBIjw8HKmpqTh//ryS9RAREVETZPF1KNLS0uDu7o6goCAMHz4cvr6+UKlU0vKwsDCMHz9ekSKJiIjIulkcKHJzc+Hg4ICePXsiKysLWVlZRsv9/PxkF0dERERNg8WBIjo6GtHR0UrWQkRERE2UItehKC4uxokTJ5Cbm6vE6oiIiKiJkXUvj/T0dMyYMQM//fST1NarVy988cUXCAsLk10ckTXo8vF/zOqXNm/ILa6EiMh6WRwoqqurMWLECDg4OGD16tXo0KEDcnNzsW7dOgwbNgynTp2Cv7+/krUSERGRlbI4UOzbtw9lZWVISUmBRqOR2h955BHcf//9+O677/Dqq68qUiQRERFZN4vnUGRmZmLAgAFGYaJOZGQkMjIyZBVGRERETYfFgUKr1SI1NRVVVVUmy5KTk6HVamUVRkRERE2HxYFi0KBBKCsrw8iRI5GQkIDz58/j4MGDmD59OrZu3YqYmBgl6yQiIiIrZvEcCkdHR/z000946qmnMGzYMKm9TZs22LJlCwIDAxUpkIiIiKyfrNNGe/bsiZSUFJw7dw4XL16Ej48PAgMD4eDgoFR9RERE1ATIChQAoFKp0LlzZ3Tu3FmJeoiIiKgJalCg2LdvH9asWYNBgwahY8eOWLNmzQ37Dho0CE8++aTsAomIiMj6NShQlJaWIjMzEwUFBdL/30hBQYHs4oiIiKhpaFCgiIqKQlRUFACgpqYGkZGRsLOTfdREsnfvXmzatAkBAQGYM2eO0TK9Xo/Zs2ebPOfZZ5/F3XffbdS2efNmJCYmQq1WIyYmBr1791asRiIiIjJl8WmjX3/9NZ555hlFiigpKUHXrl3xzjvvICUlBT/++KNJn7KyMqxevRrt2rXDgAEDpB9PT0+jftOmTcPMmTPh5eWFoqIi9OvXD9u3b1ekTiIiIqqfxbsXPDw8kJeXp0gR9vb22Lp1KwIDAzF16lScP3/+hn0feugh9OjRo95lR44cwapVq5CYmIjw8HBp3bNmzcKoUaOgUqkUqZeIiIiMWbyHIjw8HKmpqTf95W+uFi1amH3diiVLlmDWrFlYsmQJrly5YrRsx44d8PPzk8IEAIwfPx7p6ek4fvy47DqJiIiofhbvoUhLS4O7uzuCgoIwfPhw+Pr6Gu0BCAsLw/jx4xUpsk7r1q3h4eGBVq1aYfPmzZg/fz4SEhLQp08fAMD58+dN7nDavn17aVlQUFC969Xr9dDr9dJjnU6naN1ERETNncWBIjc3Fw4ODujZsyeysrKQlZVltNzPz092cddyc3PDqVOn4ObmBgD4xz/+gREjRmDGjBlITk4GABgMBpObldU9NhgMN1z3ggULMH/+fJP2goICODk5KVK/T4saRdZD/2NtY6rUIcDGcm2oJvk4nsrjmCpLr9ebzEOUw+JAER0djejoaMUK+TuOjo5wdHQ0aouJicG0adNQWVkJBwcHuLi4mJzKmp+fDwBwcXG54bpnz56NqVOnSo91Oh1CQkLg7u6u2GBnV9gi3aDcGTF0lTWNqZIfzMbSHLbBmnA8lccxtV6KfBtfvnwZ58+fh0ajQa9evZRYpVkMBgNqa2ulxz169MC2bdtQXV0tnc566tQpAED37t1vuB4XF5ebBg4iIiK6OYsnZQLAhQsXMGrUKPj4+ODee+/FkiVLcO7cOdx9990QQihVIwAgKSlJ2tsAAIWFhfj8888xdOhQ6d4hY8eORWlpKWJjYwEAQggsW7YMISEh6Nixo6L1EBER0f9YvIeivLwckZGR6NGjB5KSkpCcnIwzZ86gU6dO8Pf3x44dOxp0SGTevHm4cuUKfv31VxQVFUmHIL766isAV69VERYWhoCAAGg0GiQmJqJTp07ScgAICAjA4sWLMWPGDGzatAk6nQ5ZWVnYtWuXpZtJREREZrA4UOzZswctW7bE1q1bYWtrizNnzkjL+vXrh8TExAYFiuDgYBQXF2PAgAH1Lo+KisKgQYNw4MAB5OXl4dVXX5XO7rjWs88+i6ioKBw4cADOzs4YOnSoyURNIiIiUpbFgSIvLw+BgYGwtbU1Webg4IDKysoGrS8mJuZv+zg7OyMiIuJv+wUEBCAgIKBBr09ERESWszhQdOzYEfv27UN+fj48PDyMliUnJ2Pw4MGyiyNqSrp8/B+z+qXNG3KLKyEiuv0snpQZGhoKrVaLsLAwrF27Funp6SgqKsKCBQvwyy+/4LHHHlOyTiIiIrJiFu+hsLGxQVxcHGJiYvDUU09J7cnJydi6davJXgsiIiJqvmRdhyIgIACHDh3CqVOnkJ6eDnd3d/Tt2xf29vZK1UdERERNgMWB4ty5c8jNzUVYWBi6d+9udOGoa5cRERFR82fxHIrExESsWbOmwcuIiIio+ZF1pcwbKSgogKur661YNREREVmhBh/y+PXXX7Fu3TqkpaUhNzfX6KZaAFBWVoaff/4ZS5cuVaxIIiIism4NDhRFRUU4f/48cnJyoNfrcf78eaPlLi4ueO2113jaKBER0R2kwYFi5MiRGDlyJOLj4/HHH39g9uzZt6IuIiIiakIsPssjKioKUVFRStZCRERETZSsSZkJCQk4ePAgAMBgMOCRRx5BQEAAPvjgA0WKIyIioqbB4kBRWFiIGTNmIDAwEACwcuVKHDlyBJMnT8ann34qBQ0iIiJq/iw+5JGcnIzAwEC4u7sDAHbs2IH33nsPEyZMQGVlJX7++WeEhoYqVigRERFZL4v3UBQUFECtVgMAqqqqcOjQIQwZcvUuir6+vigsLFSkQCIiIrJ+FgeKwMBA7NmzB2lpaVi9ejXatm0LX19fAMCZM2ekQyFERETU/Fl8yCM4OBgDBw5EYGAgbGxs8M033wAASkpKEB8fj3fffVexIomaky4f/8esfmnzhtziSoiIlCPrbqObNm3CiRMnoNFo0KFDBwBAcXEx1q9fD09PT0UKJCIiIusnK1DY2NggKCgIxcXFOHHiBHx8fODr6ysd+iAiIqI7g6zrUKSnp2PkyJFwcXFBr1694O3tjaCgIBw4cECp+oiIiKgJsHgPRXV1NUaMGAEHBwesXr0aHTp0QG5uLtatW4dhw4bh1KlT8Pf3V7JWojsK51oQUVNicaDYt28fysrKkJKSAo1GI7U/8sgjuP/++/Hdd9/h1VdfVaRIIiIism4WH/LIzMzEgAEDjMJEncjISGRkZMgqjIiIiJoOiwOFVqtFamoqqqqqTJYlJydDq9XKKoyIiIiaDosDxaBBg1BWVoaRI0ciISEB58+fx8GDBzF9+nRs3boVMTExStZJREREVsziORSOjo746aef8NRTT2HYsGFSe5s2bbBlyxZeKZOIiOgOIus6FD179kRKSgrOnTuHixcvwsfHB4GBgXBwcFCqPiIiImoCZAUKAFCpVOjcuTM6d+6sRD1ERETUBMkOFFlZWfj3v/8t7aEYPHgwevbsadG6qqqq8Ouvv0KtViMkJKTePsXFxTh69CjUajWCg4NhY2M6DcScPkRERKQcWYHiq6++wgsvvICamhr4+PggLy8PZWVleP7557Fo0SKz11NVVYX58+fj66+/Rnl5Obp3745ffvnFpN+WLVvw5JNPIiAgAFeuXIGrqyvi4+ONLqBlTh8iIiJSlsV/ul+8eBEzZszAm2++iaKiIly8eBF6vR6bN2/GqlWrsHXrVrPXZTAY4OjoiJSUFIwePbrePtnZ2Zg4cSLefPNNHDt2DBcvXoSXlxemTp3aoD5ERESkPIsDxf79+xEWFoZ58+ahRYsWAK7OpxgzZgyef/557N271+x1ubi44I033rjpTcU2bdoEGxsbPPfccwAAe3t7vPzyy9i9ezcyMzPN7kNERETKszhQtGrVCm5ubvUuc3NzQ6tWrSxddb1SU1MRGBgIR0dHqS04OBgAcPz4cbP7EBERkfIsDhR9+/bF4cOHkZKSYtR++fJlrFmzBkOHDpVd3LUKCwvh4eFh1Obp6QkAKCgoMLtPffR6PTIzM6UfnU6nZOlERETNnsWTMs+ePQtvb2+EhoZiyJAhCAgIQG5uLnbv3g1XV1ds2LABGzZsAACEhYVh/Pjxsgp1cHCAwWAwaisrK5OWmdunPgsWLMD8+fNN2gsKCuDk5CSr7jo+LWoUWQ/9D8f0qry8PEXWo9frFVkPXcXxVB7HVFl6vV76o1sJFgeK3NxcODg4oF+/figuLsaJEycAAD169AAAHD58WOrr5+cns0wgICAABw8eNGqrmxcREBBgdp/6zJ4922jipk6nQ0hICNzd3RUb7OwKW6QbZJ+lS9fhmELRLwQl10Ucz1uBY2q9LP42jo6ORnR0tJK13NSIESPw0Ucf4dixYwgKCgIAbN68Gd7e3tI8CXP61MfFxQUuLi63fiOIiIiaKav58y4xMREGgwGZmZnIz8/Hzz//DOBqSACA8PBwREdH4+GHH8brr7+OrKws/POf/8SKFStgZ2dndh8iIiJSntX8ll2zZg0uX74MAGjdurV0Yay6QAEAGzduxPLly7F9+3Y4OzsjLi4OUVFRRusxpw8REREpSyWEEI1dhLXJzMxE27ZtkZGRgTZt2iiyzmGLd/F4v8L8nao5pgDS5g1RZD15eXk8Pq0gjqfyOKbKUno8eZMLIiIiko2BgoiIiGRjoCAiIiLZGCiIiIhINs5oI7pDdPn4Pzddfu0kV6UmehLRnYOBgqiJ+7ugQER0O/CQBxEREcnGQEFERESyMVAQERGRbAwUREREJBsDBREREcnGQEFERESyMVAQERGRbAwUREREJBsDBREREcnGQEFERESyMVAQERGRbAwUREREJBsDBREREcnGQEFERESyMVAQERGRbAwUREREJBsDBREREcnGQEFERESy2TV2AURkfbp8/B+z+qXNG3KLKyGipoJ7KIiIiEg2BgoiIiKSjYGCiIiIZGOgICIiItmaTKDIycmBm5ubyc/27duN+l26dAnjxo1D69at0alTJ7zzzjuoqalppKqJiIjuDE3mLI/a2loUFRXhwIED6Nq1q9SuVqul/6+ursbw4cPh5+eHPXv2QKfTISYmBuXl5fj4448bo2wiIqI7QpPZQ1FHo9EY7aGwt7eXlm3fvh2nT5/G2rVr0bVrVwwZMgTvvPMOlixZgtLS0kasmoiIqHlrcoFi1KhRaN26NcLDw7Fx40ajZUlJSejatStat24ttUVGRsJgMODIkSO3u1QiIqI7RpM55KFSqfDEE0/g+eefR6tWrRAXF4cJEyYgPz8f06dPB3B1/oRWqzV6nre3NwAgKyvrhuvW6/XQ6/XSY51Odwu2gIiIqPlqMoFCq9Xi66+/lh6/8MILSE9Px/vvvy8FCgCwsTHe6WJnd3UThRA3XPeCBQswf/58k/aCggI4OTnJLR0A4NOCE0OVxjFVliXjmZeXdwsqaR6u/SOFlMExVZZer4enp6di62sygaI+ffv2xcKFC1FaWgq1Wg1vb2+cPXvWqE9OTg6A/+2pqM/s2bMxdepU6bFOp0NISAjc3d0VG+zsClukG5r0cFsljqmyGjqeSn4ZNUccH+VxTK1Xk/42PnPmDDQajbQXoX///lixYgXy8/Ph4eEBAEhMTIS9vT369Olzw/W4uLjAxcXlttRMRETUHDWZSZlffPEFfvjhBxQXF6O6uhrbt2/HwoULMX36dOkwx9ixY+Hj44OXXnoJJSUluHDhAt5//31MnDgR7u7ujbwFREREzVeT2UMxatQovPnmm3j22WdRVlaG1q1b45133sELL7wg9XF2dkZ8fDymTp0Kd3d32NraIiYmBkuXLm3EyomaL96VlIjqNJlA0aZNG6xduxYAUFVVZXT9iWv16NEDycnJqKiogJ2dHWxtbW9nmURERHekJhMornWjMHGtFi1a3IZKiMgc3JNB1Pw1mTkUREREZL0YKIiIiEi2JnnIg4hISTwkQyQf91AQERGRbNxDQURWg3sKiJou7qEgIiIi2RgoiIiISDYGCiIiIpKNgYKIiIhk46RMImpyOHmTyPpwDwURERHJxkBBREREsjFQEBERkWwMFERERCQbAwURERHJxrM8iIjMxLNLiG6MeyiIiIhINgYKIiIiko2HPIio2TL3EAURycc9FERERCQbAwURERHJxkBBREREsjFQEBERkWyclElEpLAuH/8H/k7VSDco8xXL61pQU8A9FERERCQb91AQEVk5XqGTmgLuoSAiIiLZGCiIiIhItmZ5yGPz5s1ITEyEWq1GTEwMevfu3dglERERNWvNbg/FtGnTMHPmTHh5eaGoqAj9+vXD9u3bG7ssIiKiZq1Z7aE4cuQIVq1ahcTERISHhwMA7O3tMWvWLIwaNQoqlaqRKyQiunWUnrzZkHuhKD0htL7Xru9UXE5EtR7NKlDs2LEDfn5+UpgAgPHjx2PJkiU4fvw4goKCGrE6IiLrcCtumsYzUahZBYrz58/D39/fqK19+/bSshsFCr1eD71eLz3OyMgAAOh0OsVqKy/MRVV5sxruRldeUc0xVRDHU1kcz/plZmaa1a+qKNekrb4x7fDqD2atb9/Me8zq11jCP99vVj8lt6OgoAAGgwE+Pj6ws5P/Xm1W73aDwQCNRmPUVvfYYDDc8HkLFizA/PnzTdpDQkKULZAU9WdjF9DMcDyVxfGsX9uPLX+unDGV87rW5FZsR0ZGBtq0aSN7Pc0qULi4uJik3/z8fGnZjcyePRtTp06VHpeXlyMjIwPt27dXJLXpdDqEhIQgJSUFvr6+stdHHFOlcTyVxfFUHsdUWdeOp4+PjyLrbFaBokePHti2bRuqq6ulIHDq1CkAQPfu3W/4PBcXF5PAcddddylen6+vryIpkP6HY6osjqeyOJ7K45gqy9fXV5E/nIFmdtro2LFjUVpaitjYWACAEALLli1DSEgIOnbs2MjVERERNV/Nag9FQEAAFi9ejBkzZmDTpk3Q6XTIysrCrl27Grs0IiKiZq1ZBQoAePbZZxEVFYUDBw7A2dkZQ4cONZmoebu5uLjg7bffvuk8DmoYjqmyOJ7K4ngqj2OqrFsxniohhFBsbURERHRHalZzKIiIiKhxMFAQERGRbAwUREREJBsDBREREcnW7M7ysDZJSUmIjY1FcXEx7rnnHkybNg329vaNXVaTlJiYiIULF5q0r1+/Hmq1uhEqanp0Oh1Wr16Nw4cPY9asWRgyxPRGTX/99Rc+//xzXLx4EXfddReef/55xa6k19xUVVVh27Zt2LRpEzp16oT333/faHlhYSEmT55s8ry5c+ciNDT0NlXZdOj1enzzzTc4fPgw1Go1IiMjMWbMGJN+hw4dwrp161BYWIj+/fvj2WefRYsWLW5/wU3Azp07ER8fj/z8fHTv3h3Tp0+Hm5ubtPzQoUP46KOPTJ63evVqeHp6Nui1GChuoU2bNmHcuHGYM2cO+vTpg08//RQ7d+7E9u3bG7u0JikjIwOJiYlYu3atUbuDg0MjVdS0fPfdd5g7dy4mTpyIHTt21PtFnZ6ejr59+2LgwIEYNWoUfvjhB/Tt2xe///47vL29b3/RVkyv16NHjx7o168fcnJycPnyZZM+5eXliIuLw+LFi9GuXTup/fqbGBKQk5ODkJAQREdHY/DgwcjJycHUqVMRHx+PFStWSP3i4+MRHR2NF154AcHBwVi4cCF27NiB3bt3Q6VSNeIWWJ9JkyYhNzcXw4YNQ58+fbB27VosXboUhw8flv5I0Ol02LlzJzZs2GD0XIv+SBN0S9TW1op27dqJf/zjH1JbamqqACD27NnTiJU1Xd9++63QarWNXUaTlZWVJSorK4UQQtja2oq1a9ea9Jk6daoICgoSNTU1QgghKioqhL+/v5gzZ87tLLVJqKysFDqdTgghxJQpU8SgQYNM+uh0OgFAnDhx4jZX1/SUlZWJgoICo7aNGzcKACIrK0tqCwwMFM8884z0+Ny5c0KlUom4uLjbVWqTce24CSGEwWAQWq1WvPvuu1Lb1q1bhVqtVuT1OIfiFjl16hT++usvjB07VmoLCgpCp06dEB8f34iVNW0lJSV48skn8eSTT2LRokUoKytr7JKaDF9f37893BYfH48xY8bAxubqV4ODgwOio6P5nq2Hvb292YeC3n33XYwfPx5vvfUW0tPTb3FlTZOTk5PRrngA8PPzAwAUFRUBAC5evIgzZ84Yfa/edddd6N27N9+j9bj+JmqOjo7w9PSUxrNOZWUlpkyZgkmTJuGzzz5DcXGxRa/HQHGL/Pnn1Rvttm3b1qi9bdu20jJquHvvvRehoaHo168f1qxZg549e0p3lCV5KisrcenSJb5nFdalSxeEhIRg2LBhOHHiBLp164akpKTGLqtJWLRoEdq3b4/OnTsD4PeqXAkJCTh9+jRGjBhh1H7vvfeiX79+CA0Nxffff49u3brVewjv73AOxS1SUVEBAHB2djZqb9myJcrLyxujpCZv1KhRePzxx6XHEydORNeuXfHhhx/is88+a8TKmofKykoAfM8qycPDA0ePHoWTkxMAYPLkyRg7diyef/55pKamNm5xVu6zzz7Dtm3bsGfPHmmP2c2+V6//q5uMnTt3DhMmTMC0adMQEREhtQ8ePNhoPtXkyZPRo0cPvP322/jyyy8b9BrcQ3GLuLq6AgAKCgqM2vPy8uDu7t4YJTV5dWNaR6PRYMiQITh8+HAjVdS8ODs7w97enu9ZBTk4OEhhos7o0aNx8uRJ6ZcjmVq+fDlef/11bNq0Cffee6/Uzu9Vy/z3v//F0KFDMXToUCxfvtxo2fXfq46Ojhg2bJhF36sMFLdIz549oVKpcOzYMamtqqoKp0+fRq9evRqxsualsLAQdnbc0aYEGxsb9OjRw+g9CwCpqal8zyqosLAQKpVK+qubjH355Zd46aWXsHHjRowaNcpoWbdu3WBnZ2f0HhVC4MSJE3yP3sCff/6JwYMHIzQ0FLGxsbC1tf3b51j6vcp39C3i4+ODyMhILF68GFVVVQCAr776CqWlpXj00UcbubqmKTY2FgaDQXq8d+9exMfHY/To0Y1YVfMyceJEbNq0CRcvXgQAnD59Gj/99BMmTpzYuIU1UTt37kRGRob0OCsrC4sWLcL999/P69HUY+XKlXjxxRexceNGREdHmyx3dXVFdHQ0li1bJh2Gi42NxeXLlzFu3LjbXa7VS09Px3333YcBAwZg/fr19YaJDRs2oKSkRHqcnJyMLVu2WPS9yj/tbqGVK1di+PDh6NSpE3x9fXH8+HGsXLmS56BbqLCwEIGBgQgICEB5eTmOHz+O2bNnY+bMmY1dWpNw8uRJvPHGGwCA2tpaLFmyBNu2bcOQIUMwa9YsAMDzzz+PgwcPonfv3ggKCsLvv/+OcePG4YknnmjM0q3WtGnTkJOTg9TUVJSUlEjHordt2wbg6pkLUVFRcHR0hEajweHDh3Hfffdh1apVjVe0lTp37hyeeeYZtGnTBmvWrMGaNWukZW+//TaCg4MBAMuWLZO+V9u1a4ejR49i6dKlCAwMbKzSrdbkyZORmZmJsrIyPPzww1J7WFgYXnnlFQBAWVkZevbsibZt26KqqgpHjx7F9OnTMWfOnAa/Hm9ffotVV1cjJSUFxcXFuPvuu9GqVavGLqlJKykpQWpqKlQqFbp27QoPD4/GLqnJuHLlCn799VeT9nbt2qFPnz5GbadPn0Z6ejo6duwozbAnU7t27ar31OVrJ7lVV1fj5MmTyMvLk34JkqmioiLs3bu33mVhYWFGF1arqanBb7/9hsLCQgQHB0Or1d6uMpuUxMREk/kmwNXTcfv16yc9LisrQ2pqKmpraxEYGGjx7ykGCiIiIpKNcyiIiIhINgYKIiIiko2BgoiIiGRjoCAiIiLZGCiIiIhINgYKIiIiko2BgoiIiGRjoCAiIiLZGCiIiIhINgYKIiIiko03ByOiRrNixQqju3Feq127dpg2bdptroiILMVAQUSNJjY2Vrp50R9//AFvb294enoCAB544IHGLI2IGog3ByOiRqfX6+Hm5oYffvgBjzzySGOXQ0QW4BwKImp0R48ehRDC5DbqRNR0MFAQUaM7evQoXF1d0aFDh8YuhYgsxEBBRI0uNTUVwcHBUKlUjV0KEVmIgYKIGt1ff/3FvRNETRwDBRE1Om9vb+zatQsffPDBDU8jJSLrxkBBRI1u0aJFePjhh3HkyBHY2fFsdqKmiKeNEhERkWzcQ0FERESyMVAQERGRbAwUREREJBsDBREREcnGQEFERESyMVAQERGRbAwUREREJBsDBREREcnGQEFERESyMVAQERGRbAwUREREJBsDBREREcnGQEFERESyMVAQERGRbP8PBb77y9vIO1IAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(5.2, 3.2))\n", + "ax.hist(\n", + " s_schools[:, p_schools.columns(tau)],\n", + " bins=40,\n", + " color=plotstyle.COLOURS[0],\n", + " alpha=0.85,\n", + ")\n", + "ax.set(\n", + " xlabel=r\"$\\tau$\",\n", + " ylabel=\"posterior draws\",\n", + " title=r\"How different are the schools, really?\",\n", + ")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "ec0f35b1", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "ax.errorbar(np.arange(8) - 0.15, Y, S, fmt=\"o\", color=\"k\", label=\"reported estimate\")\n", + "ax.errorbar(\n", + " np.arange(8) + 0.15,\n", + " np.median(alphas, axis=0),\n", + " np.abs(np.percentile(alphas, [16, 84], axis=0) - np.median(alphas, axis=0)),\n", + " fmt=\"s\",\n", + " color=plotstyle.COLOURS[1],\n", + " label=r\"$\\alpha_j$ after pooling (median, 68 %)\",\n", + ")\n", + "ax.axhline(\n", + " np.median(mu_draws),\n", + " color=plotstyle.COLOURS[1],\n", + " ls=\"--\",\n", + " lw=1.0,\n", + " label=r\"common mean $\\mu$\",\n", + ")\n", + "ax.set(xlabel=\"school\", ylabel=\"effect on test scores\", title=\"Shrinkage\")\n", + "ax.legend(fontsize=8)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "183a4d1b", + "metadata": {}, + "source": [ + "The posterior of $\\tau$ piles up towards zero, much as BDA3 reports (BDA3 uses a uniform prior on $\\tau$; ours is a half-normal of scale 10, which changes the details but not the story). The data are consistent with all eight programmes having much the same effect, so every school is pulled hard towards the common mean: the first school's $+28$ becomes about $+10$, and the school reporting $-3$ moves up towards the others. Nothing was discarded — the shrinkage is what the model concludes, not a choice we imposed.\n", + "\n", + "The fit reported one divergent transition in 4000 draws. A single one is not a concern; a cluster of them would mean the sampler is missing a region where the posterior's curvature changes faster than its step size, and raising the adaptation's target acceptance rate is the usual cure.\n", + "\n", + "Now the same idea, on physics parameters." + ] + }, + { + "cell_type": "markdown", + "id": "89f604ab", + "metadata": {}, + "source": [ + "## The study: a quadratic whose coefficients run with energy\n", + "\n", + "The truth is $y = a_0(E) + a_1(E)\\, x + a_2(E)\\, x^2$, and each coefficient's\n", + "energy dependence is a smooth trend plus a small non-monotonic bump — the kind of\n", + "structure a global parameterisation usually misses. Seven synthetic datasets at\n", + "known energies constrain it, and an eighth at an energy between two of them is\n", + "held out to test prediction.\n", + "\n", + "Every dataset reports an absolute error of 0.03 on each point, and those errors\n", + "are honest: the noise really is drawn from them. So the only thing that can go\n", + "wrong here is the *model*, which is the point." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "77630c43", + "metadata": {}, + "outputs": [], + "source": [ + "BUMPS = (0.16, -0.13, 0.1) # amplitudes of the departures from each smooth trend\n", + "\n", + "\n", + "def a_true(E):\n", + " return np.array(\n", + " [\n", + " 1.0 + 0.010 * E + BUMPS[0] * np.exp(-(((E - 35.0) / 8.0) ** 2)),\n", + " 0.6 - 0.008 * E + BUMPS[1] * np.exp(-(((E - 25.0) / 6.0) ** 2)),\n", + " -0.20 + 0.004 * E + BUMPS[2] * np.exp(-(((E - 45.0) / 7.0) ** 2)),\n", + " ]\n", + " )\n", + "\n", + "\n", + "def quadratic(x, a0, a1, a2):\n", + " return a0 + a1 * x + a2 * x**2\n", + "\n", + "\n", + "rng = np.random.default_rng(12)\n", + "energies = np.array([10.0, 20.0, 25.0, 35.0, 40.0, 50.0, 60.0])\n", + "E_new = 30.0\n", + "x = np.linspace(-1.0, 1.0, 12)\n", + "noise = 0.03\n", + "\n", + "\n", + "def dataset(E, label):\n", + " y = quadratic(x, *a_true(E))\n", + " return rx.Dataset(\n", + " x,\n", + " y + rng.normal(0.0, noise, x.size),\n", + " np.full(x.size, noise),\n", + " label=label,\n", + " meta={\"Elab\": E},\n", + " )\n", + "\n", + "\n", + "datasets = [dataset(E, rf\"$E = {E:.0f}$\") for E in energies]\n", + "held_out = dataset(E_new, rf\"$E = {E_new:.0f}$ (held out)\")" + ] + }, + { + "cell_type": "markdown", + "id": "1d0d39ab", + "metadata": {}, + "source": [ + "### The data, energy by energy\n", + "\n", + "Seven datasets on the same $x$ grid would overlap into an unreadable smear, so we\n", + "offset each one vertically and label it. The dashed lines are the truth at that\n", + "energy; the points are what the experiment saw. The held-out energy is drawn in\n", + "grey." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "86c7868f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "x_fine = np.linspace(-1.0, 1.0, 80)\n", + "offset_step = 0.6\n", + "shown = list(zip(datasets, energies)) + [(held_out, E_new)]\n", + "colours = plt.cm.viridis(np.linspace(0.05, 0.9, len(energies)))\n", + "\n", + "fig, ax = plt.subplots(figsize=(6.4, 5.2))\n", + "for k, (d, E) in enumerate(shown):\n", + " held = E == E_new\n", + " colour = \"0.55\" if held else colours[k]\n", + " shift = k * offset_step\n", + " ax.plot(x_fine, quadratic(x_fine, *a_true(E)) + shift, \"--\", color=colour, lw=1.2)\n", + " ax.errorbar(d.x, d.y + shift, d.y_err, fmt=\"o\", ms=3, color=colour)\n", + " plotstyle.label_at(\n", + " ax,\n", + " 1.03,\n", + " quadratic(1.0, *a_true(E)) + shift,\n", + " rf\"$E = {E:.0f}$\" + (\" (held out)\" if held else \"\"),\n", + " color=colour,\n", + " )\n", + "ax.set(\n", + " xlabel=\"$x$\",\n", + " ylabel=f\"$y$ (offset by {offset_step} per dataset)\",\n", + " title=\"Seven datasets, one held out\",\n", + " xlim=(-1.1, 1.45),\n", + ")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "bfafc8d9", + "metadata": {}, + "source": [ + "## Three fits of the same data\n", + "\n", + "One `Model` per comparison, closing over that dataset's energy (recipe 35); the\n", + "coefficient objects are shared, so the problem has one column per global\n", + "parameter. The held-out comparison is part of every constraint but fully\n", + "masked: it contributes nothing to the likelihood, and any parameter only it uses\n", + "is sampled from its prior (recipe 30).\n", + "\n", + "1. **The correct mapping**,\n", + " $a_k(E; \\varphi) = \\varphi_{k0} + \\varphi_{k1} E/50 + \\varphi_{k2}\n", + " \\exp(-((E - c_k)/w_k)^2)$, with the bump centres and widths known: global\n", + " $\\varphi$. Dividing $E$ by 50 puts every $\\varphi$ on the same scale, so one\n", + " $\\mathcal{N}(0, 1)$ prior suits them all.\n", + "2. **A misspecified smooth mapping**, $a_k(E; \\varphi) = \\varphi_{k0} +\n", + " \\varphi_{k1} E/50$: global $\\varphi$, no bumps.\n", + "3. **The misspecified mapping plus a hierarchy**: per-dataset deviations\n", + " $\\delta_j = \\tau \\odot \\eta_j$ in parameter space, non-centred, with\n", + " $\\eta_{jk} \\sim \\mathcal{N}(0, 1)$ and $\\tau_k \\sim \\mathrm{HalfNormal}(0.2)$, so\n", + " the spread of the deviations is learned (recipes 22, 24). The scale 0.2 says\n", + " we expect deviations of order 0.1 in each coefficient, about the size of the\n", + " bumps, and allows rather larger ones. The held-out\n", + " dataset gets its own $\\eta_\\mathrm{new}$, driven by $\\tau$ alone." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "943e52d1", + "metadata": {}, + "outputs": [], + "source": [ + "centres, widths = (35.0, 25.0, 45.0), (8.0, 6.0, 7.0)\n", + "all_data = datasets + [held_out]\n", + "masks = [np.ones(x.size, dtype=bool)] * len(datasets) + [np.zeros(x.size, dtype=bool)]\n", + "\n", + "\n", + "def correct_mapping(E, phi):\n", + " phi = jnp.reshape(jnp.asarray(phi), (3, 3))\n", + " return jnp.stack(\n", + " [\n", + " phi[k, 0]\n", + " + phi[k, 1] * E / 50.0\n", + " + phi[k, 2] * jnp.exp(-(((E - centres[k]) / widths[k]) ** 2))\n", + " for k in range(3)\n", + " ]\n", + " )\n", + "\n", + "\n", + "def linear_mapping(E, phi):\n", + " phi = jnp.reshape(jnp.asarray(phi), (3, 2))\n", + " return jnp.stack([phi[k, 0] + phi[k, 1] * E / 50.0 for k in range(3)])" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "dbdb2f5e", + "metadata": {}, + "outputs": [], + "source": [ + "def global_params(prefix, n_per):\n", + " return [\n", + " [\n", + " rx.Parameter(\n", + " f\"{prefix}{k}{i}\",\n", + " prior=stats.norm(0.0, 1.0),\n", + " latex=rf\"\\varphi_{{{k}{i}}}\",\n", + " )\n", + " for i in range(n_per)\n", + " ]\n", + " for k in range(3)\n", + " ]\n", + "\n", + "\n", + "def build(mapping, phis, hierarchy=False):\n", + " \"\"\"The case's problem and constraint, and its global parameters.\"\"\"\n", + " flat = [p for ps in phis for p in ps]\n", + " if hierarchy:\n", + " taus = [\n", + " rx.Parameter(\n", + " f\"tau_{k}\",\n", + " prior=stats.halfnorm(scale=0.2),\n", + " bounds=(0.0, np.inf),\n", + " latex=rf\"\\tau_{k}\",\n", + " )\n", + " for k in range(3)\n", + " ]\n", + " comps = []\n", + " for j, d in enumerate(all_data):\n", + " E = d.meta[\"Elab\"]\n", + " if hierarchy:\n", + " etas_j = [\n", + " rx.Parameter(f\"eta_{j}_{k}\", prior=stats.norm(0.0, 1.0))\n", + " for k in range(3)\n", + " ]\n", + "\n", + " def fn(x, *v, E=E, n=len(flat)):\n", + " phi, t, e = v[:n], jnp.asarray(v[n : n + 3]), jnp.asarray(v[n + 3 :])\n", + " return quadratic(x, *(mapping(E, phi) + t * e))\n", + "\n", + " model_j = rx.Model(fn, [*flat, *taus, *etas_j])\n", + " else:\n", + "\n", + " def fn(x, *phi, E=E):\n", + " return quadratic(x, *mapping(E, phi))\n", + "\n", + " model_j = rx.Model(fn, flat)\n", + " comps.append(rx.Comparison(d, model_j))\n", + " c = rx.Constraint(comps, masks=masks)\n", + " return rx.Problem([c]), c, flat" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "c94dbbec", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1. correct mapping ndim = 9 active points = 84 of 96\n", + "2. misspecified ndim = 6 active points = 84 of 96\n", + "3. misspecified + hierarchy ndim = 33 active points = 84 of 96\n" + ] + } + ], + "source": [ + "cases = {\n", + " \"1. correct mapping\": build(correct_mapping, global_params(\"phi\", 3)),\n", + " \"2. misspecified\": build(linear_mapping, global_params(\"psi\", 2)),\n", + " \"3. misspecified + hierarchy\": build(\n", + " linear_mapping, global_params(\"chi\", 2), hierarchy=True\n", + " ),\n", + "}\n", + "mappings = {\n", + " \"1. correct mapping\": correct_mapping,\n", + " \"2. misspecified\": linear_mapping,\n", + " \"3. misspecified + hierarchy\": linear_mapping,\n", + "}\n", + "style = {\n", + " \"1. correct mapping\": (plotstyle.COLOURS[0], plotstyle.HATCHES[0]),\n", + " \"2. misspecified\": (plotstyle.COLOURS[1], plotstyle.HATCHES[1]),\n", + " \"3. misspecified + hierarchy\": (plotstyle.COLOURS[2], plotstyle.HATCHES[2]),\n", + "}\n", + "for name, (p, c, flat) in cases.items():\n", + " print(\n", + " f\"{name:28s} ndim = {p.ndim:2d} active points = {c.n_active} of {c.n_total}\"\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "ce3ad648", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1. correct mapping R-hat 1.002, min bulk ESS 1835, 0 divergences\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2. misspecified R-hat 1.004, min bulk ESS 1336, 0 divergences\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3. misspecified + hierarchy R-hat 1.003, min bulk ESS 1069, 0 divergences\n" + ] + } + ], + "source": [ + "samples = {\n", + " name: nuts(p, seed=i + 1, label=f\"{name:28s} \")\n", + " for i, (name, (p, c, flat)) in enumerate(cases.items())\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "cc95901b", + "metadata": {}, + "source": [ + "## The coefficient mappings against the truth\n", + "\n", + "For each case, the 68 % posterior band of each coefficient $a_k(E)$ across the energy range. The hierarchical case has two things to show: its global smooth mapping (the band), and the per-dataset values $a_k(E_j) + \\tau_k \\eta_{jk}$ it actually used (the points, with 68 % intervals), which are what can follow the bumps." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "cdceaa49", + "metadata": {}, + "outputs": [], + "source": [ + "E_grid = np.linspace(5.0, 65.0, 100)\n", + "A_grid = np.array([a_true(E) for E in E_grid])\n", + "p3, c3, flat3 = cases[\"3. misspecified + hierarchy\"]\n", + "s3 = samples[\"3. misspecified + hierarchy\"]\n", + "tau_params = [q for q in p3.params if q.name.startswith(\"tau\")]\n", + "\n", + "\n", + "def per_dataset(j):\n", + " \"\"\"Case 3's coefficients at dataset j, a_k(E_j) + tau_k eta_jk, per draw.\"\"\"\n", + " eta_j = [q for q in p3.params if q.name.startswith(f\"eta_{j}_\")]\n", + " base = np.array(\n", + " [\n", + " linear_mapping(all_data[j].meta[\"Elab\"], row[p3.columns(flat3)])\n", + " for row in s3[::10]\n", + " ]\n", + " )\n", + " return base + s3[::10][:, p3.columns(tau_params)] * s3[::10][:, p3.columns(eta_j)]" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "c6c8c542", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(1, 3, figsize=(10.5, 3.4))\n", + "for name, (p, c, flat) in cases.items():\n", + " colour, hatch = style[name]\n", + " curves = np.array(\n", + " [\n", + " [mappings[name](E, row[p.columns(flat)]) for E in E_grid]\n", + " for row in samples[name][::10]\n", + " ]\n", + " )\n", + " lo, hi = np.percentile(curves, [16, 84], axis=0)\n", + " for k, ax in enumerate(axes):\n", + " plotstyle.band(\n", + " ax, E_grid, lo[:, k], hi[:, k], color=colour, hatch=hatch, label=name\n", + " )\n", + "for j, E in enumerate(energies):\n", + " lo, mid, hi = np.percentile(per_dataset(j), [16, 50, 84], axis=0)\n", + " for k, ax in enumerate(axes):\n", + " ax.errorbar(\n", + " E,\n", + " mid[k],\n", + " [[mid[k] - lo[k]], [hi[k] - mid[k]]],\n", + " fmt=\"o\",\n", + " ms=4,\n", + " color=style[\"3. misspecified + hierarchy\"][0],\n", + " mec=\"k\",\n", + " mew=0.5,\n", + " label=(\n", + " r\"case 3 at each dataset, $a_k(E_j) + \\tau_k \\eta_{jk}$\"\n", + " if j == 0\n", + " else None\n", + " ),\n", + " )\n", + "for k, ax in enumerate(axes):\n", + " ax.plot(E_grid, A_grid[:, k], \"--\", color=\"k\", label=\"truth\")\n", + " ax.axvline(E_new, color=\"0.6\", lw=0.8)\n", + " ax.set(xlabel=\"$E$\", title=f\"$a_{k}(E)$\")\n", + "axes[0].legend(fontsize=6.5)\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "c473b0aa", + "metadata": {}, + "source": [ + "### What each case predicts, dataset by dataset\n", + "\n", + "The same layout as the data figure — one offset row per energy — but now showing\n", + "what each calibration predicts. The three cases are told apart by **hatching**\n", + "rather than colour, so the comparison survives a greyscale print and does not\n", + "fight the energy colour-coding." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "e2b80ed8", + "metadata": {}, + "outputs": [], + "source": [ + "def case_band(name, E, rows):\n", + " \"\"\"68 % band of the case's model alone on x_fine, at energy E (a fitted or\n", + " the held-out dataset: its eta columns are in the chain either way).\"\"\"\n", + " p, c, _ = cases[name]\n", + " j = [d.meta[\"Elab\"] for d in all_data].index(E)\n", + " comp = c.comparisons[j]\n", + " return rx.predictive.grid_draws(\n", + " p,\n", + " comp.model.bind(x_fine, comp.data.meta),\n", + " x_fine,\n", + " rows,\n", + " model_only=True,\n", + " levels=(16, 84),\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "b9f2f5e2", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "shown_energies = [20.0, 35.0, E_new, 50.0]\n", + "fig, ax = plt.subplots(figsize=(6.6, 5.6))\n", + "for k, E in enumerate(shown_energies):\n", + " shift = k * offset_step\n", + " d = held_out if E == E_new else datasets[list(energies).index(E)]\n", + " for name in cases:\n", + " colour, hatch = style[name]\n", + " lo, hi = case_band(name, E, samples[name][::20])\n", + " plotstyle.band(\n", + " ax,\n", + " x_fine,\n", + " lo + shift,\n", + " hi + shift,\n", + " color=colour,\n", + " hatch=hatch,\n", + " label=name if k == 0 else None,\n", + " )\n", + " ax.plot(x_fine, quadratic(x_fine, *a_true(E)) + shift, \"--\", color=\"k\", lw=1.0)\n", + " ax.errorbar(d.x, d.y + shift, d.y_err, fmt=\"o\", ms=3, color=\"k\")\n", + " plotstyle.label_at(\n", + " ax,\n", + " 1.03,\n", + " quadratic(1.0, *a_true(E)) + shift,\n", + " rf\"$E = {E:.0f}$\" + (\" (held out)\" if E == E_new else \"\"),\n", + " color=\"0.3\",\n", + " )\n", + "ax.set(\n", + " xlabel=\"$x$\",\n", + " ylabel=f\"$y$ (offset by {offset_step} per dataset)\",\n", + " title=\"What each calibration's model predicts (68 %)\",\n", + " xlim=(-1.1, 1.5),\n", + ")\n", + "ax.legend(fontsize=8, loc=\"upper left\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "0f394744", + "metadata": {}, + "source": [ + "## Coverage, in sample and at the held-out energy\n", + "\n", + "`predictive_draws` on the fitted problem gives the in-sample posterior\n", + "predictive; on `Problem([c.complement()])` — the same parameters and terms, with\n", + "the held-out points active — it gives the prediction at the new energy, with no\n", + "extra code (recipe 30). For the hierarchical case that prediction includes the\n", + "prior-sampled $\\eta_\\mathrm{new}$ scaled by the learned $\\tau$, so it is wider than in sample.\n", + "\n", + "We score the held-out energy two ways. The held-out log predictive density is the single number; it is a Monte Carlo average over posterior draws, so we compute it on every draw and quote it to the nearest unit. The coverage curves show the calibration at each level, but the held-out curve rests on only twelve points, so each step is $1/12 \\approx 0.08$." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "8022b6e5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "case held-out log predictive 68 % predictive width\n", + "1. correct mapping 25 0.062\n", + "2. misspecified 8 0.061\n", + "3. misspecified + hierarchy 20 0.244\n" + ] + } + ], + "source": [ + "levels = np.linspace(0.05, 0.95, 19)\n", + "scores, curves_cov = {}, {}\n", + "for name, (p, c, flat) in cases.items():\n", + " s = samples[name]\n", + " held = rx.Problem([c.complement()])\n", + " draws_in = rx.diagnostics.predictive_draws(\n", + " p, s[::10], n_rep=2, rng=1, return_draws=True\n", + " )\n", + " draws_out = rx.diagnostics.predictive_draws(\n", + " held, s[::10], n_rep=2, rng=2, return_draws=True\n", + " )\n", + " ci, ch = p.constraints[0], held.constraints[0]\n", + " curves_cov[name] = (\n", + " rx.diagnostics.coverage_curve(draws_in, ci.y[ci.active], levels),\n", + " rx.diagnostics.coverage_curve(draws_out, ch.y[ch.active], levels),\n", + " )\n", + " scores[name] = (\n", + " rx.diagnostics.log_posterior_predictive(\n", + " rx.diagnostics.heldout_log_predictive(held, s)\n", + " ),\n", + " rx.diagnostics.sharpness(draws_out).mean(),\n", + " )\n", + "print(f\"{'case':28s} held-out log predictive 68 % predictive width\")\n", + "for name, (lp, width) in scores.items():\n", + " print(f\"{name:28s} {lp:10.0f} {width:.3f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "407ccfb5", + "metadata": {}, + "source": [ + "The held-out scores are the cleanest statement: 25 for the correct mapping, 8 for the misspecified one, and 20 for the misspecified mapping plus a hierarchy. Giving each dataset a small deviation with a learned spread recovers most of the predictive power that the wrong energy dependence threw away, without our ever having to discover what the right energy dependence was.\n", + "\n", + "It pays for that in width. Its 68 % predictive interval at the new energy is 0.244 against 0.062, four times wider, because the hierarchy does not know what the coefficients do between the measured energies 25 and 35, where two bumps overlap, and predicts with the spread it learned. The coverage curves below show what that width buys:\n", + "\n", + "- the misspecified fit sags far below the diagonal, in sample and at the held-out energy: it is confidently wrong;\n", + "- the hierarchical fit sits *above* the diagonal in both panels, from a nominal level of about 0.3 up: it over-covers, more so at the new energy, where all twelve held-out points fall inside its 60 % interval. That is the conservative failure, and the right one to have when we do not know the energy dependence, but it is not calibration: its predictive is wider than the 0.03 noise warrants;\n", + "- the correct mapping follows the diagonal in sample, and sags a little at the held-out energy (0.83 at a nominal 0.9), which, with twelve points, is within a step or two of the curve." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "86d573ec", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(1, 2, figsize=(8.4, 3.8))\n", + "for ax, which, title in zip(axes, (0, 1), (\"in sample\", f\"held out, E = {E_new:.0f}\")):\n", + " ax.plot([0, 1], [0, 1], \"--\", color=\"0.5\")\n", + " for name in cases:\n", + " ax.plot(levels, curves_cov[name][which], \"o-\", color=style[name][0], label=name)\n", + " ax.set(\n", + " xlabel=\"nominal coverage\",\n", + " ylabel=\"empirical coverage\",\n", + " title=title,\n", + " xlim=(0, 1),\n", + " ylim=(0, 1),\n", + " )\n", + "axes[0].legend(fontsize=8)\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "fd066d32", + "metadata": {}, + "source": [ + "## The learned spread\n", + "\n", + "If the smooth mapping were adequate, the data would have no reason to ask for per-dataset deviations, and the posterior of each $\\tau_k$ would pile up near zero, as it did for the eight schools. Below we draw each $\\tau_k$'s posterior over its $\\mathrm{HalfNormal}(0.2)$ prior, so we can see how far the data moved it." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "b93c1029", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "tau_prior = np.linspace(0.0, 0.6, 200)\n", + "fig, axes = plt.subplots(1, 3, figsize=(10.5, 3.0), sharey=True)\n", + "for ax, q in zip(axes, tau_params):\n", + " draws = s3[:, p3.columns(q)].ravel()\n", + " ax.hist(\n", + " draws,\n", + " bins=50,\n", + " range=(0, 0.6),\n", + " density=True,\n", + " color=style[\"3. misspecified + hierarchy\"][0],\n", + " alpha=0.7,\n", + " label=\"posterior\",\n", + " )\n", + " ax.plot(\n", + " tau_prior,\n", + " stats.halfnorm(scale=0.2).pdf(tau_prior),\n", + " \"--\",\n", + " color=\"k\",\n", + " label=\"prior\",\n", + " )\n", + " lo, mid, hi = np.percentile(draws, [16, 50, 84])\n", + " ax.set(xlabel=f\"${q.latex}$\", title=f\"median {mid:.3f} [{lo:.3f}, {hi:.3f}]\")\n", + "axes[0].legend(fontsize=8)\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "f41c814d", + "metadata": {}, + "source": [ + "Every $\\tau_k$ has moved away from its prior: the posteriors are concentrated between about 0.03 and 0.13, where the prior is flat and falling, and they disfavour the values near zero that the smooth mapping alone would need. Their medians are smaller than the prior's own (0.13), so the data are not asking for large deviations, only for some. With seven datasets this is a modest statement, and it comes with a caveat: with few datasets the global mapping and the deviations can trade against each other, and the coefficients' behaviour between measured energies, such as at the held-out energy, where the bumps centred at 25 and 35 overlap, is not something the hierarchy can predict. It can only widen for it.\n", + "\n", + "## Takeaways\n", + "\n", + "- The correct mapping covers in sample, and at the held-out energy to within what twelve points can tell. The misspecified smooth mapping is confidently wrong in both.\n", + "- A hierarchy on the physics parameters recovers most of the held-out predictive power the misspecification threw away, at the price of a wider, conservative predictive: it over-covers rather than under-covers.\n", + "- A $\\tau$ posterior pushed away from zero, against its prior, is the misspecification made visible.\n", + "- A parameter attached only to a fully masked comparison is sampled from its prior. That is the whole mechanism for predicting a new dataset: `complement()`, `predictive_draws` and `heldout_log_predictive` score the new energy with no extra code, and `grid_draws` draws its curve on any grid." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/linear_calibration.ipynb b/examples/linear_calibration.ipynb new file mode 100644 index 0000000..ff4d957 --- /dev/null +++ b/examples/linear_calibration.ipynb @@ -0,0 +1,705 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "96a94733", + "metadata": {}, + "source": [ + "# Calibration of a line\n", + "\n", + "We'll start with the smallest problem that contains the model calibration workflow: fitting a line to noisy measured points. First, we will declare the model ($y = m x + b$), what we believe about its parameters — our [priors](https://en.wikipedia.org/wiki/Prior_probability) — and how the data compare with a given model prediction — our [likelihood](https://en.wikipedia.org/wiki/Likelihood_function). Then we compile that problem, hand it to a sampler, and draw samples from our [posterior](https://en.wikipedia.org/wiki/Posterior_probability). Finally, we push those posterior samples back through our model to generate a [posterior predictive](https://en.wikipedia.org/wiki/Posterior_predictive_distribution), and compare it to the data we fit to see if it worked. [Bayesian inference](https://en.wikipedia.org/wiki/Bayesian_inference) always has these ingredients: a prior over parameters, a likelihood for the data, and a posterior we explore with a sampler. \n", + "\n", + "In this synthetic data case, we know the ground truth, and therefore know our model is correctly specified. We also know the data-generating process: every point will scatter about the true line with the same standard deviation $\\sigma$. Our imaginary experiment reports that $\\sigma$ for each point, but rather than take it on trust, we'll infer it alongside $m$ and $b$. That's our first, and simplest, *error model*, and we'll check that it recovers the reported value. It will also pay off later, when we want predictions at $x$ values nobody measured. Other tutorial notebooks in this series explore the more realistic cases in which our model is only an approximation to reality, and we may not have complete information about the experimental uncertainties.\n", + "\n", + "We could write this model calibration problem as follows:\n", + "\n", + "\\begin{equation}\n", + " y_i = \\eta(x_i) + \\varepsilon_i, \\qquad \\eta(x) = m_\\text{true}\\, x + b_\\text{true},\n", + "\\end{equation}\n", + "\n", + "where $y_i$ is our (synthetic) data, $\\eta(x_i)$ is the ground truth, and $\\varepsilon_i$ is the discrepancy between the two. We model the truth with $y_m(x;m,b) = m x + b$, and the model is *correctly specified* because it contains the truth: $\\eta(x) = y_m(x; m_\\text{true}, b_\\text{true})$. We treat $m$ and $b$ as random variables, and start with a prior $p(m,b)$ for them. $\\varepsilon_i$ is also a random variable, which we model as Gaussian with mean 0 and standard deviation $\\sigma$:\n", + "\n", + "\\begin{equation}\n", + "\\varepsilon_i \\sim \\mathcal{N}(0, \\sigma^2),\n", + "\\end{equation}\n", + "\n", + "This determines the likelihood, and, through Bayes' rule, the posterior, we will write below.\n", + "\n", + "Recipes: 1, 2, 17, 33, 40 (see [the recipes](/recipes.md))" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "4487f98f", + "metadata": {}, + "outputs": [], + "source": [ + "import blackjax\n", + "import corner\n", + "import emcee\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import plotstyle\n", + "from budget import budget # sampler budgets, cut in CI's quick run\n", + "from scipy import stats\n", + "\n", + "import rxmc as rx\n", + "from rxmc import terms as T\n", + "\n", + "plotstyle.use()" + ] + }, + { + "cell_type": "markdown", + "id": "26b7c934", + "metadata": {}, + "source": [ + "## Parameters and a model\n", + "\n", + "A `Parameter` is a random variable we will do inference on. Typically, we name it, and assign it a prior (or finite bounds, which is just a uniform prior). A `Model` is a mapping from some domain space $x$ and some parameters $\\alpha$ to a prediction $y_{m}$, which we want to compare to some data $y$.\n", + "\n", + "We deliberately choose a prior that disagrees with the data we are about to generate: $m \\sim \\mathcal{N}(1, 1)$ while the truth is $m = 0.6$, so we can see the data pull the posterior away from it.\n", + "\n", + "We also need a parameter for the noise level. $\\sigma$ is a positive scale that could plausibly be anywhere over an order of magnitude, so we will sample its logarithm, with $\\log\\sigma \\sim \\mathcal{N}(\\log 0.2, 1)$: centred a factor of two above the truth, and wide." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "bd5cc6df", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Model(params=(m, b))" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "m = rx.Parameter(\"m\", prior=stats.norm(1.0, 1.0), latex=\"m\")\n", + "b = rx.Parameter(\"b\", prior=stats.norm(1.0, 1.0), latex=\"b\")\n", + "log_sigma = rx.Parameter(\n", + " \"log_sigma\", prior=stats.norm(np.log(0.2), 1.0), latex=r\"\\log\\sigma\"\n", + ")\n", + "line = rx.Model(lambda x, m, b: m * x + b, [m, b])\n", + "line" + ] + }, + { + "cell_type": "markdown", + "id": "fd08ef0d", + "metadata": {}, + "source": [ + "## Data\n", + "\n", + "We draw twenty points from $y = m x + b$ with independent Gaussian noise of\n", + "known size $\\sigma = 0.1$, which our imaginary experiment reports honestly as\n", + "`y_err`. We keep `y_err` in the dataset, so it shows up as error bars in our\n", + "plots, but as we'll see in a moment our likelihood won't use it." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "a655b824", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Dataset('toy', n=20)" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "rng = np.random.default_rng(49)\n", + "sigma = 0.1\n", + "truth = {\"m\": 0.6, \"b\": 2.0, \"log_sigma\": np.log(sigma)}\n", + "x = np.linspace(0.0, 1.0, 20)\n", + "y_true = truth[\"m\"] * x + truth[\"b\"]\n", + "data = rx.Dataset(\n", + " x, y_true + rng.normal(0.0, sigma, x.size), sigma * np.ones(x.size), label=\"toy\"\n", + ")\n", + "data" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "00228baf", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "ax.errorbar(data.x, data.y, data.y_err, fmt=\"o\", color=\"k\", label=\"data\")\n", + "ax.plot(x, y_true, \"--\", color=plotstyle.COLOURS[1], label=\"truth\")\n", + "ax.set(xlabel=\"$x$\", ylabel=\"$y$\")\n", + "ax.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "eb2f8834", + "metadata": {}, + "source": [ + "## A comparison, a constraint and a problem\n", + "\n", + "Three objects carry us from a declaration to something a sampler understands.\n", + "\n", + "- A `Comparison` binds the model to this dataset's grid: it is the pairing of\n", + " one model with one dataset.\n", + "- A `Constraint` is one likelihood over one or more comparisons, and it owns\n", + " the *error model*: a covariance built as a sum of terms. By default it\n", + " includes the diagonal of the reported errors (`statistical=True`), which is\n", + " the \"the experiment told us everything\" assumption. Here we switch that off\n", + " and add a single term, `T.noise(log_sigma)`, which puts\n", + " $\\sigma^2 = e^{2 \\log\\sigma}$ on the diagonal at every point.\n", + "- `Problem` compiles the lot: it gives every parameter a column, assembles the\n", + " prior, and exposes the densities a sampler needs." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "3e2eb131", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Problem(ndim=3, constraints=1)\n", + "columns: ['m', 'b', 'log_sigma']\n" + ] + } + ], + "source": [ + "comp = rx.Comparison(data, line)\n", + "noise_term = T.noise(log_sigma)\n", + "problem = rx.Problem([rx.Constraint([comp], terms=[noise_term], statistical=False)])\n", + "print(problem)\n", + "print(\"columns:\", problem.names)" + ] + }, + { + "cell_type": "markdown", + "id": "b84afe70", + "metadata": {}, + "source": [ + "### What our prior alone predicts\n", + "\n", + "Before the likelihood is involved at all, we can draw parameters from the prior\n", + "and push them through the model, noise included. This is the\n", + "[prior predictive](https://en.wikipedia.org/wiki/Posterior_predictive_distribution#Prior_vs._posterior_predictive_distribution):\n", + "the data our prior thinks are plausible. If it cannot produce anything like\n", + "the data we measured, we have learned something before fitting.\n", + "\n", + "We draw it with `rx.predictive.grid_draws` on a plotting grid wider than the\n", + "data, and hand it prior rows instead of posterior ones. We'll say much more\n", + "about that function once we have a posterior." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "26214803", + "metadata": {}, + "outputs": [], + "source": [ + "prior_rows = problem.sample_prior(200, rng=1)\n", + "x_fine = np.linspace(-0.5, 1.5, 60)\n", + "on_fine = line.bind(x_fine) # the same model on a plotting grid\n", + "prior_lo, prior_mid, prior_hi = rx.predictive.grid_draws(\n", + " problem, on_fine, x_fine, prior_rows, n_rep=5, levels=(16, 50, 84), rng=2\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "fee892f7", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "plotstyle.band(\n", + " ax,\n", + " x_fine,\n", + " prior_lo,\n", + " prior_hi,\n", + " color=plotstyle.COLOURS[0],\n", + " label=\"prior predictive 68 %\",\n", + ")\n", + "ax.plot(x_fine, prior_mid, color=plotstyle.COLOURS[0])\n", + "ax.errorbar(data.x, data.y, data.y_err, fmt=\"o\", color=\"k\", label=\"data\")\n", + "ax.set(\n", + " xlabel=\"$x$\",\n", + " ylabel=\"$y$\",\n", + " title=\"The prior predictive: what we believe before we see the data\",\n", + ")\n", + "ax.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "28b9123a", + "metadata": {}, + "source": [ + "### Calibrating to data \n", + "\n", + "To determine the posterior $p(m,b,\\log\\sigma | y )$, we use Bayes' rule (the prior is on $\\log\\sigma$, so the posterior is a density over $\\log\\sigma$ too):\n", + "\n", + "\\begin{equation}\n", + "p(m,b,\\log\\sigma | y ) = \\frac{1}{\\mathcal{Z}} \\, L(y | m,b,\\sigma) \\, p(m,b)\\,p(\\log\\sigma)\n", + "\\end{equation}\n", + "\n", + "The relation between $y_i$, $\\varepsilon_i$, and $y_m(x_i;m,b)$ above gives us the following log-likelihood:\n", + "\n", + "\\begin{align*}\n", + "\\log L(y | m,b,\\sigma) &= -\\frac{1}{2}\\chi^2(m,b,\\sigma) - N \\log\\sigma - \\frac{N}{2}\\log 2\\pi\\\\\n", + "\\chi^2(m,b,\\sigma) &= \\sum_i \\frac{(y_i - y_m(x_i; m,b))^2}{\\sigma^2}\n", + "\\end{align*}\n", + "\n", + "If $\\sigma$ were fixed, the last two terms in $\\log L$ would be constants and we could\n", + "forget about them - optimizing $m$ and $b$ to maximize the log-likelihood would then simply reduce to good old least-squares, or $\\chi^2$-minimization. Because we also infer $\\sigma$, they matter: we could always make the $\\chi^2$ smaller by inflating $\\sigma$, and the $-N\\log\\sigma$ term, which is $-\\tfrac12\\log\\det\\Sigma$ for this diagonal covariance, is what charges us for doing so. One could still do an optimization to find the Maximum Likelihood Estimate (MLE); the $m$, $b$, and $\\sigma$ maximizing $L(y | m,b,\\sigma)$. However, by invoking Bayes' rule and using our priors, we will instead draw samples from the posterior. \n", + "\n", + "`problem.chi2` is the [$\\chi^2$](https://en.wikipedia.org/wiki/Goodness_of_fit#Regression_analysis)\n", + "and `problem.log_likelihood` is the whole thing, so we can check both against the sums we'd type out ourselves. When the covariance stops being diagonal — and it will, in every other notebook — the $\\chi^2$ becomes the squared [Mahalanobis distance](https://en.wikipedia.org/wiki/Mahalanobis_distance)." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "b416f0f2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "problem.chi2 = 335.902 by hand = 335.902\n", + "problem.log_likelihood = -154.141 by hand = -154.141\n" + ] + } + ], + "source": [ + "prior_mean = {\"m\": 1.0, \"b\": 1.0, \"log_sigma\": np.log(0.2)}\n", + "theta0 = np.array([prior_mean[name] for name in problem.names]) # by name\n", + "on_data = line.bind(x)\n", + "s0 = np.exp(theta0[problem.columns(log_sigma)]).item()\n", + "resid = data.y - on_data(*theta0[problem.columns(line.params)])\n", + "chi2_by_hand = np.sum((resid / s0) ** 2)\n", + "loglike_by_hand = (\n", + " -0.5 * chi2_by_hand - x.size * np.log(s0) - 0.5 * x.size * np.log(2 * np.pi)\n", + ")\n", + "print(\n", + " f\"problem.chi2 = {problem.chi2(theta0):9.3f} by hand = {chi2_by_hand:9.3f}\"\n", + ")\n", + "print(\n", + " f\"problem.log_likelihood = {problem.log_likelihood(theta0):9.3f} \"\n", + " f\"by hand = {loglike_by_hand:9.3f}\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "763566ce", + "metadata": {}, + "source": [ + "## Running the calibration with emcee\n", + "\n", + "The problem exposes everything a sampler needs: `log_posterior` is the density, `ndim` is the dimension, and `log_posterior_batch` evaluates every walker in one vectorised call, so emcee takes it with `vectorize=True`. We use [emcee](https://emcee.readthedocs.io/), the affine-invariant ensemble sampler of [Goodman & Weare (2010)](https://doi.org/10.2140/camcos.2010.5.65), described in [Foreman-Mackey et al. (2013)](https://arxiv.org/abs/1202.3665). Nothing here is specific to it: any other third-party sampler, like ptemcee, dynesty or pymc, can be used. [`black-box-bayes`](https://github.com/beykyle/black-box-bayes/) provides a uniform interface to all of these that works seamlessly with `rxmc`, which is useful for production-scale inference. For the small problems in these tutorial notebooks, we can just run the samplers directly.\n", + "\n", + "Where the walkers start matters. We could draw them from the prior with `problem.sample_prior`, but with $\\sigma$ free a prior draw can strand a walker where the noise is large enough to explain everything, and the ensemble can take a long time to reel it back in. So we first find the posterior's mode with `rx.optimize.find_map` (recipe 33), and start the walkers in a small ball around it.\n", + "\n", + "The chain of samples from the posterior comes back in `problem.names` order, so we always look columns up by name through `problem.columns`, never by position." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "10df06dd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 8.41 s, sys: 139 ms, total: 8.55 s\n", + "Wall time: 4.93 s\n" + ] + } + ], + "source": [ + "%%time\n", + "n_walkers, n_steps = 32, budget(6000)\n", + "theta_map = rx.optimize.find_map(problem, rng=0).x\n", + "start = theta_map + 1e-3 * np.random.default_rng(3).standard_normal(\n", + " (n_walkers, problem.ndim)\n", + ")\n", + "sampler = emcee.EnsembleSampler(\n", + " n_walkers, problem.ndim, problem.log_posterior_batch, vectorize=True\n", + ")\n", + "sampler.random_state = np.random.RandomState(2).get_state()\n", + "sampler.run_mcmc(start, n_steps, progress=False);" + ] + }, + { + "cell_type": "markdown", + "id": "802fa9f1", + "metadata": {}, + "source": [ + "Before we use a single sample, we check that the run has converged, and we let the code give the verdict rather than our eyes:\n", + "\n", + "- emcee's walkers are correlated from one step to the next, and the [integrated autocorrelation time](https://emcee.readthedocs.io/en/stable/tutorials/autocorr/) $\\tau$ is the number of steps over which a walker remembers where it was. emcee trusts a run only when it is at least $50\\tau$ long. We estimate $\\tau$ after dropping the first fifth of the run, since a walker still climbing out of its start inflates it.\n", + "- The [rank-normalised split $\\hat R$](https://arxiv.org/abs/1903.08008), taking each walker as a chain, compares the spread within each half-walker with the spread between them; it should be below about 1.01. Walkers are not independent chains, since each move uses another walker, so this is a necessary check rather than a sufficient one.\n", + "- The acceptance fraction of every walker should be reasonable, and no walker should be a *straggler*, with a log posterior far below the others: still climbing out of a bad start, or stuck.\n", + "\n", + "If all of that passes, we drop the first five $\\tau$ as burn-in and keep every $\\tau/2$-th step." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "da9d0443", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "acceptance 0.64 (min) to 0.66 (max); run = 156 tau; split R-hat 1.004; stragglers: none\n", + "converged\n", + "9760 posterior rows\n" + ] + } + ], + "source": [ + "tau = sampler.get_autocorr_time(discard=n_steps // 5, quiet=True).max()\n", + "discard, thin = int(5 * tau), max(1, int(tau / 2))\n", + "walkers = np.swapaxes(sampler.get_chain(discard=discard, thin=thin), 0, 1)\n", + "rhat = float(np.max(blackjax.diagnostics.rhat(walkers)))\n", + "walker_log_post = sampler.get_log_prob(discard=discard).mean(axis=0)\n", + "stragglers = np.flatnonzero(walker_log_post < np.median(walker_log_post) - 20)\n", + "acceptance = sampler.acceptance_fraction\n", + "converged = (\n", + " n_steps >= 50 * tau\n", + " and rhat <= 1.01\n", + " and stragglers.size == 0\n", + " and acceptance.min() > 0.1\n", + ")\n", + "print(\n", + " f\"acceptance {acceptance.min():.2f} (min) to {acceptance.max():.2f} (max); \"\n", + " f\"run = {n_steps / tau:.0f} tau; split R-hat {rhat:.3f}; \"\n", + " f\"stragglers: {stragglers.tolist() or 'none'}\"\n", + ")\n", + "print(\"converged\" if converged else \"NOT CONVERGED: do not use these samples\")\n", + "samples = sampler.get_chain(discard=discard, thin=thin, flat=True)\n", + "print(f\"{samples.shape[0]} posterior rows\")" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "1b1fd4cb", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "median and 68 % interval\n", + "m = 0.642 [ 0.562, 0.724] (truth 0.600)\n", + "b = 1.984 [ 1.938, 2.031] (truth 2.000)\n", + "log_sigma = -2.206 [-2.362, -2.028] (truth -2.303)\n", + "sigma = 0.110 [ 0.094, 0.132] (reported 0.1)\n" + ] + } + ], + "source": [ + "print(\"median and 68 % interval\")\n", + "for name, parameter in zip(problem.names, problem.params):\n", + " lo, mid, hi = np.percentile(samples[:, problem.columns(parameter)], [16, 50, 84])\n", + " print(f\"{name:9s} = {mid:6.3f} [{lo:6.3f}, {hi:6.3f}] (truth {truth[name]:.3f})\")\n", + "lo, mid, hi = np.percentile(\n", + " np.exp(samples[:, problem.columns(log_sigma)]), [16, 50, 84]\n", + ")\n", + "print(f\"{'sigma':9s} = {mid:6.3f} [{lo:6.3f}, {hi:6.3f}] (reported {sigma})\")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "4c3f3437", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig = corner.corner(\n", + " samples,\n", + " labels=[f\"${p.latex}$\" for p in problem.params],\n", + " truths=[truth[n] for n in problem.names],\n", + " **plotstyle.corner_kwargs(),\n", + ")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "48d80632", + "metadata": {}, + "source": [ + "## The posterior predictive on any grid\n", + "\n", + "The model $y = m x + b$ is not tied to the $x$ values our data were measured at: binding it to a finer, wider grid gives us the prediction where we have no data — a forecast.\n", + "\n", + "But a forecast of *what*? There are two different posterior predictive distributions we might mean:\n", + "\n", + "1. **The model alone**, $y_m(x_*;\\alpha)$ with $\\alpha = \\{m, b\\}$ drawn from the posterior. This is our uncertainty about the *line*: where the true curve is. If we are comparing to the ground truth, this is the predictive distribution to use.\n", + "2. **The model plus our error model**, $y_* = y_m(x_*;\\alpha) + \\varepsilon$ with $\\varepsilon \\sim \\mathcal{N}(0, \\sigma^2)$ and $\\sigma$ drawn from the posterior too. This is our uncertainty about a *new measurement* at $x_*$ - if we are comparing to data, then this is the predictive distribution to use.\n", + "\n", + "To draw the second at an $x_*$ nobody measured, every piece of the error model has to *have a value* there. That's why we inferred a constant $\\sigma$ instead of using the reported `y_err`: a reported error is one number per measured point, and it says nothing about a point that was never measured. Our noise term, on the other hand, is a function — the same $\\sigma$ at any $x$ — so it can be interpolated and extrapolated along with the physics model, just like $y_m$ itself.\n", + "\n", + "This is the split between rxmc's two draw functions:\n", + "\n", + "- `rx.diagnostics.predictive_draws` draws at the **measured** points. Every term of the error model is defined there, reported per-point errors included, so this is what we compare against the data. \n", + "- `rx.predictive.grid_draws` draws on **any grid**. It re-evaluates each covariance term at the new points from its own definition, so it can carry anything that is a function of $x$ and the prediction — inferred noise, a normalisation uncertainty proportional to the prediction, a Gaussian-process discrepancy — but it refuses anything that is just an array of per-point numbers.\n", + "\n", + "Both return a percentile band by default, and the draws themselves with `return_draws=True`." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "a9ec6693", + "metadata": {}, + "outputs": [], + "source": [ + "post_rows = samples[::20]\n", + "model_lo, model_mid, model_hi = rx.predictive.grid_draws(\n", + " problem, on_fine, x_fine, post_rows, model_only=True, levels=(16, 50, 84)\n", + ")\n", + "full_lo, full_mid, full_hi = rx.predictive.grid_draws(\n", + " problem, on_fine, x_fine, post_rows, n_rep=2, levels=(16, 50, 84), rng=5\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "046ac161", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "ax.axvspan(x.min(), x.max(), color=\"0.92\", zorder=0, label=\"data range\")\n", + "plotstyle.band(\n", + " ax,\n", + " x_fine,\n", + " full_lo,\n", + " full_hi,\n", + " color=plotstyle.COLOURS[2],\n", + " hatch=plotstyle.HATCHES[0],\n", + " label=\"model + noise: a new measurement (68 %)\",\n", + ")\n", + "plotstyle.band(\n", + " ax,\n", + " x_fine,\n", + " model_lo,\n", + " model_hi,\n", + " color=plotstyle.COLOURS[0],\n", + " label=\"model alone: the line (68 %)\",\n", + ")\n", + "ax.plot(x_fine, model_mid, color=plotstyle.COLOURS[0])\n", + "ax.plot(\n", + " x_fine,\n", + " truth[\"m\"] * x_fine + truth[\"b\"],\n", + " \"--\",\n", + " color=plotstyle.COLOURS[1],\n", + " label=\"truth\",\n", + ")\n", + "ax.errorbar(data.x, data.y, data.y_err, fmt=\"o\", color=\"k\", label=\"data\")\n", + "ax.set(\n", + " xlabel=\"$x$\",\n", + " ylabel=\"$y$\",\n", + ")\n", + "ax.legend(fontsize=8)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "ef728bd6", + "metadata": {}, + "source": [ + "## Is our error model calibrated?\n", + "\n", + "Now we check both predictives against what we actually observed, at the\n", + "measured points, with `predictive_draws`. If a predictive distribution is properly calibrated, a central 68 % interval of its draws should contain about 68 % of the points, and likewise at every level, so the empirical\n", + "[coverage](https://en.wikipedia.org/wiki/Coverage_probability) should follow the diagonal. Twenty points make a coarse curve, but systematically being under(over) the diagonal corresponds to under(over) covering the data, with errors being too small(too large).\n", + "\n", + "We expect the model-alone predictive to undercover the data. It isn't *wrong*; it answers a different question. It describes where the line is, and the data don't sit on the line: each point scatters about it by $\\sigma$. Which\n", + "predictive we want depends on what we're predicting. If it's the physical curve itself — say, a cross section we'll feed into a transport code — the model band is the right object. If it's what a new measurement would read, we need the error model on top.\n", + "\n", + "In later notebooks we'll meet a third source of uncertainty that sits between these two: *model discrepancy*, the part of the disagreement between model and reality that no choice of parameters can remove (`gp_discrepancy`,\n", + "`alpha_ca_error_model_comparison`)." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "1f79f3c1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "nominal 0.50: model + noise 0.70, model alone 0.20\n", + "nominal 0.70: model + noise 0.75, model alone 0.35\n", + "nominal 0.90: model + noise 0.90, model alone 0.55\n" + ] + } + ], + "source": [ + "rows = samples[::10]\n", + "draws_full = rx.diagnostics.predictive_draws(\n", + " problem, rows, n_rep=4, rng=4, return_draws=True\n", + ")\n", + "draws_model = rx.diagnostics.predictive_draws(\n", + " problem, rows, model_only=True, return_draws=True\n", + ")\n", + "levels = np.linspace(0.05, 0.95, 19)\n", + "c = problem.constraints[0]\n", + "coverage_full = rx.diagnostics.coverage_curve(draws_full, c.y[c.active], levels)\n", + "coverage_model = rx.diagnostics.coverage_curve(draws_model, c.y[c.active], levels)\n", + "for nominal in (0.5, 0.7, 0.9):\n", + " full, model = (\n", + " rx.diagnostics.coverage_curve(d, c.y[c.active], [nominal])[0]\n", + " for d in (draws_full, draws_model)\n", + " )\n", + " print(f\"nominal {nominal:.2f}: model + noise {full:.2f}, model alone {model:.2f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "c59df024", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(4.2, 4.2))\n", + "ax.plot([0, 1], [0, 1], \"--\", color=\"0.5\", label=\"nominal\")\n", + "ax.plot(levels, coverage_full, \"o-\", color=plotstyle.COLOURS[2], label=\"model + noise\")\n", + "ax.plot(levels, coverage_model, \"s-\", color=plotstyle.COLOURS[0], label=\"model alone\")\n", + "ax.set(\n", + " xlabel=\"nominal coverage\",\n", + " ylabel=\"empirical coverage\",\n", + " xlim=(0, 1),\n", + " ylim=(0, 1),\n", + ")\n", + "ax.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "e6e24789", + "metadata": {}, + "source": [ + "## What the coverage tells us\n", + "\n", + "The model-plus-noise predictive follows the diagonal about as closely as twenty points allow. It sits above it in the middle (0.70 of the points inside the central 50 % interval, 0.75 inside the 70 %), and on it at 90 %. With twenty points, each point moves the curve by 0.05, and the binomial scatter at a nominal 50 % is about $\\pm 0.11$, so this is within two standard deviations of a calibrated predictive. The model alone covers only 0.2 to 0.55 of the points at the same levels, as it should: it describes the line, and the data scatter about it.\n", + "\n", + "We knew the error model was right here, because we generated the data. The next notebook, `normalization_and_covariance_structure`, starts from the same workflow on data whose reported errors are incomplete or wrong, where choosing the error model is the whole problem." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/linear_calibration_demo.ipynb b/examples/linear_calibration_demo.ipynb deleted file mode 100644 index 500f59f..0000000 --- a/examples/linear_calibration_demo.ipynb +++ /dev/null @@ -1,1851 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "5add9362-edc2-4c55-a0ff-1fc5cf1d4ed7", - "metadata": {}, - "source": [ - "# Calibration of a line\n", - "\n", - "Simple demo demonstrating the workflow of `rxmc`." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "69d96b52-427c-4345-8622-d2726544a77c", - "metadata": { - "execution": { - "iopub.execute_input": "2026-09-09T18:23:07.173521Z", - "iopub.status.busy": "2026-09-09T18:23:07.173398Z", - "iopub.status.idle": "2026-09-09T18:23:09.655789Z", - "shell.execute_reply": "2026-09-09T18:23:09.655058Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Using database version X4-2024-12-31 located in: /home/kyle/db/exfor/unpack_exfor-2024/X4-2024-12-31\n" - ] - } - ], - "source": [ - "from collections import OrderedDict\n", - "\n", - "import corner\n", - "import numpy as np\n", - "from matplotlib import pyplot as plt\n", - "from scipy import stats\n", - "\n", - "import rxmc" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "315006bb-c255-4555-b458-e00bfef26ef9", - "metadata": { - "execution": { - "iopub.execute_input": "2026-09-09T18:23:09.657738Z", - "iopub.status.busy": "2026-09-09T18:23:09.657494Z", - "iopub.status.idle": "2026-09-09T18:23:09.660733Z", - "shell.execute_reply": "2026-09-09T18:23:09.659881Z" - } - }, - "outputs": [], - "source": [ - "rng = np.random.default_rng(49)" - ] - }, - { - "cell_type": "markdown", - "id": "4443b51f-20b9-42f4-8292-1bd5098c8f17", - "metadata": {}, - "source": [ - "## define parameters" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "ab500ce6-552f-4c9e-9b0f-648d456e4a53", - "metadata": { - "execution": { - "iopub.execute_input": "2026-09-09T18:23:09.662224Z", - "iopub.status.busy": "2026-09-09T18:23:09.661954Z", - "iopub.status.idle": "2026-09-09T18:23:09.665195Z", - "shell.execute_reply": "2026-09-09T18:23:09.664616Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Help on class Parameter in module rxmc.params:\n", - "\n", - "class Parameter(builtins.object)\n", - " | Parameter(name, dtype=, unit='', latex_name=None, bounds=(-inf, inf))\n", - " |\n", - " | A single scalar model parameter.\n", - " |\n", - " | Parameters\n", - " | ----------\n", - " | name : str\n", - " | Human-readable name of the parameter.\n", - " | dtype : type, optional\n", - " | Data type of the parameter value. Defaults to ``float``.\n", - " | unit : str, optional\n", - " | Physical unit string (e.g. ``\"MeV\"``). Defaults to ``\"\"``.\n", - " | latex_name : str, optional\n", - " | LaTeX representation used in plots and documentation. Defaults to\n", - " | ``name`` when not supplied.\n", - " | bounds : tuple of float, optional\n", - " | ``(lower, upper)`` bounds for the parameter. Defaults to\n", - " | ``(-np.inf, np.inf)``.\n", - " |\n", - " | Methods defined here:\n", - " |\n", - " | __eq__(self, other)\n", - " | Return self==value.\n", - " |\n", - " | __init__(self, name, dtype=, unit='', latex_name=None, bounds=(-inf, inf))\n", - " | Initialize self. See help(type(self)) for accurate signature.\n", - " |\n", - " | ----------------------------------------------------------------------\n", - " | Data descriptors defined here:\n", - " |\n", - " | __dict__\n", - " | dictionary for instance variables\n", - " |\n", - " | __weakref__\n", - " | list of weak references to the object\n", - " |\n", - " | ----------------------------------------------------------------------\n", - " | Data and other attributes defined here:\n", - " |\n", - " | __hash__ = None\n", - "\n" - ] - } - ], - "source": [ - "help(rxmc.params.Parameter)" - ] - }, - { - "cell_type": "markdown", - "id": "fcf6b674-c76d-47a4-852c-11e57538e625", - "metadata": {}, - "source": [ - "## make the model" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "0669a9b0-3941-429b-887f-edcfeb909453", - "metadata": { - "execution": { - "iopub.execute_input": "2026-09-09T18:23:09.666500Z", - "iopub.status.busy": "2026-09-09T18:23:09.666383Z", - "iopub.status.idle": "2026-09-09T18:23:09.669683Z", - "shell.execute_reply": "2026-09-09T18:23:09.668842Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Help on class PhysicalModel in module rxmc.physical_model:\n", - "\n", - "class PhysicalModel(builtins.object)\n", - " | PhysicalModel(params: list[rxmc.params.Parameter], transform=None)\n", - " |\n", - " | Abstract base class for parametric physical models.\n", - " |\n", - " | Represents an arbitrary parametric model\n", - " | $y_{\\mathrm{model}}(x;\\,\\alpha)$ for comparison to an experimental\n", - " | measurement $\\{x_i,\\, y(x_i)\\}$ encapsulated in an\n", - " | :class:`~rxmc.observation.Observation`.\n", - " |\n", - " | Subclasses implement :meth:`evaluate` in physical space. An optional\n", - " | *parametric* ``transform`` (see :mod:`rxmc.transforms`) is applied on top by\n", - " | :meth:`__call__`; its parameters are appended to :attr:`params` so they flow\n", - " | through the ordinary model-parameter machinery (priors, ``split_parameters``).\n", - " | Typical uses are a latent normalisation :func:`rxmc.transforms.scale` or one\n", - " | per dataset via :func:`rxmc.transforms.per_observation_scaling`. Comparison-\n", - " | space transforms (e.g. comparing in log space) are *not* the model's\n", - " | business: declare them on the :class:`~rxmc.observation.Observation`.\n", - " |\n", - " | Parameters\n", - " | ----------\n", - " | params : list of Parameter\n", - " | Physical parameters of the model. Each entry should carry a name\n", - " | and a data type.\n", - " | transform : Transform or callable, optional\n", - " | Model-side transform ``y -> transform(y, *values)`` applied after\n", - " | :meth:`evaluate`. Its parameters (if any) are appended to ``params``.\n", - " |\n", - " | Methods defined here:\n", - " |\n", - " | __call__(self, observation: rxmc.observation.Observation, *params) -> numpy.ndarray\n", - " | Physical-space :meth:`evaluate` followed by the model transform.\n", - " |\n", - " | __init__(self, params: list[rxmc.params.Parameter], transform=None)\n", - " | Initialize self. See help(type(self)) for accurate signature.\n", - " |\n", - " | apply_transform(self, observation, y, transform_values=())\n", - " | Apply the model-side transform to a physical-space prediction.\n", - " |\n", - " | evaluate(self, observation: rxmc.observation.Observation, *params) -> numpy.ndarray\n", - " | Evaluate the model at the given parameter values.\n", - " |\n", - " | Must be overridden by subclasses.\n", - " |\n", - " | Parameters\n", - " | ----------\n", - " | observation : Observation\n", - " | Observation containing the independent-variable grid.\n", - " | *params : float\n", - " | Model parameter values.\n", - " |\n", - " | Returns\n", - " | -------\n", - " | np.ndarray\n", - " | Predicted observable values on the observation grid.\n", - " |\n", - " | Raises\n", - " | ------\n", - " | NotImplementedError\n", - " | Always — subclasses must implement this method.\n", - " |\n", - " | split_params(self, params)\n", - " | Split a full parameter tuple into ``(base_params, transform_values)``.\n", - " |\n", - " | ----------------------------------------------------------------------\n", - " | Data descriptors defined here:\n", - " |\n", - " | __dict__\n", - " | dictionary for instance variables\n", - " |\n", - " | __weakref__\n", - " | list of weak references to the object\n", - "\n" - ] - } - ], - "source": [ - "help(rxmc.physical_model.PhysicalModel)" - ] - }, - { - "cell_type": "markdown", - "id": "b497f926-7772-4b57-a8e4-707e69efdee1", - "metadata": {}, - "source": [ - "# Clearly to make a model, we need to understand these things called `Observation`s. \n", - "\n", - "This is an important detail, the whole point of `rxmc` is to compare predictions of a `PhysicalModel` to data contained in an `Observation`, to calibrate the parameters of the `PhysicalModel`." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "3c64a7e3-c4a4-41e4-a7de-34eb7ab4728a", - "metadata": { - "execution": { - "iopub.execute_input": "2026-09-09T18:23:09.670969Z", - "iopub.status.busy": "2026-09-09T18:23:09.670850Z", - "iopub.status.idle": "2026-09-09T18:23:09.674074Z", - "shell.execute_reply": "2026-09-09T18:23:09.673577Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Help on class Observation in module rxmc.observation:\n", - "\n", - "class Observation(builtins.object)\n", - " | Observation(x: numpy.ndarray, y: numpy.ndarray, y_stat_err=None, y_sys_err_normalization=None, y_sys_err_offset=None, label=None, transform=None, mask=None)\n", - " |\n", - " | Experimental data: ``x``, ``y``, and the statistical error on ``y``.\n", - " |\n", - " | Parameters\n", - " | ----------\n", - " | x : np.ndarray\n", - " | Independent-variable data.\n", - " | y : np.ndarray\n", - " | Dependent-variable data, same shape as ``x``.\n", - " | y_stat_err : np.ndarray, optional\n", - " | Statistical (uncorrelated) error on ``y``. Defaults to zeros.\n", - " | y_sys_err_normalization : float or np.ndarray, optional\n", - " | Reported *fractional* (dimensionless) normalisation uncertainty —\n", - " | inert metadata; see :meth:`systematic_terms`.\n", - " | y_sys_err_offset : float or np.ndarray, optional\n", - " | Reported *absolute* offset uncertainty, in the same units as ``y`` —\n", - " | inert metadata; see :meth:`systematic_terms`.\n", - " | label : str, optional\n", - " | Human-readable dataset identifier used in error messages.\n", - " | transform : Transform or callable, optional\n", - " | Parameter-free *comparison-space* transform (see :mod:`rxmc.transforms`).\n", - " | Pass **raw** ``y``: the observation stores ``y = transform(y_raw)`` and\n", - " | propagates ``y_stat_err`` by the delta method, and the\n", - " | :class:`~rxmc.constraint.Constraint` applies the same transform to the\n", - " | model prediction — so ``transform=rxmc.transforms.log`` compares in log\n", - " | space with the model written once, in physical space.\n", - " | mask : array_like of bool, optional\n", - " | Which points are *active* in a likelihood (default all). Inactive\n", - " | points stay in the block (supports/terms are authored over all points)\n", - " | but are excluded from the residual; use :meth:`masked` /\n", - " | :meth:`masked_where` to derive fit/held-out views.\n", - " |\n", - " | Attributes\n", - " | ----------\n", - " | x, y : np.ndarray\n", - " | The data, ``y`` in comparison space.\n", - " | y_raw, y_stat_err_raw : np.ndarray\n", - " | ``y`` and its statistical error as given (physical space).\n", - " | y_stat_err : np.ndarray\n", - " | Statistical error on ``y`` in comparison space (raw, not squared).\n", - " | transform : Transform\n", - " | The comparison-space transform (identity by default).\n", - " | mask : np.ndarray of bool\n", - " | Active points.\n", - " | identity : Observation\n", - " | The root observation this one is a view of. Views made by\n", - " | :meth:`masked` share it, so anything routing by observation (e.g.\n", - " | :func:`rxmc.transforms.per_observation_scaling`) treats a masked view\n", - " | and its root as the same dataset.\n", - " | y_sys_err_normalization : float or np.ndarray or None\n", - " | Fractional normalisation uncertainty (dimensionless).\n", - " | y_sys_err_offset : float or np.ndarray or None\n", - " | Absolute offset uncertainty (units of ``y``).\n", - " | label : str or None\n", - " | Human-readable dataset identifier.\n", - " | n_data_pts : int\n", - " | Number of data points.\n", - " |\n", - " | Methods defined here:\n", - " |\n", - " | __init__(self, x: numpy.ndarray, y: numpy.ndarray, y_stat_err=None, y_sys_err_normalization=None, y_sys_err_offset=None, label=None, transform=None, mask=None)\n", - " | Initialize self. See help(type(self)) for accurate signature.\n", - " |\n", - " | masked(self, mask, label=None)\n", - " | A shallow copy of this observation with a new point mask.\n", - " |\n", - " | No data or pre-computed workspaces are rebuilt: the copy shares them and\n", - " | only changes which points enter a likelihood.\n", - " |\n", - " | masked_where(self, predicate, label=None)\n", - " | :meth:`masked` with ``mask = predicate(x)`` (points where it is True).\n", - " |\n", - " | num_pts_within_interval(self, ylow: numpy.ndarray, yhigh: numpy.ndarray, xlim=None)\n", - " | Number of active points of ``y`` that fall within ``[ylow, yhigh)``.\n", - " |\n", - " | Useful for empirical-coverage diagnostics. ``ylow``/``yhigh`` are in\n", - " | comparison space and indexed over *all* points of the block.\n", - " |\n", - " | Parameters\n", - " | ----------\n", - " | ylow, yhigh : np.ndarray\n", - " | Interval bounds, same shape as ``y``.\n", - " | xlim : tuple, optional\n", - " | ``(x_min, x_max)`` range to restrict the count.\n", - " |\n", - " | statistical_term(self, support=None)\n", - " | The always-on, genuinely uncorrelated statistical diagonal.\n", - " |\n", - " | Parameters\n", - " | ----------\n", - " | support : np.ndarray, optional\n", - " | Indices of this observation's block in the stacked vector\n", - " | (``None`` for a single-observation constraint).\n", - " |\n", - " | Returns\n", - " | -------\n", - " | Term\n", - " | ``diag(y_stat_err**2)`` on ``support`` (comparison space).\n", - " |\n", - " | systematic_terms(self, support=None) -> list\n", - " | This dataset's reported correlated systematics as fixed rank-one terms.\n", - " |\n", - " | Opt-in — **not** added to any covariance automatically. Pass the result\n", - " | via ``Constraint(extra_terms=[*obs.systematic_terms(), ...])``.\n", - " | Zero magnitudes are skipped, so an observation without reported\n", - " | systematics yields an empty list. Magnitudes are reported in physical\n", - " | space and propagated to the comparison space by the delta method\n", - " | (``|t'| * omega`` for an offset, ``|t'(ym_raw)| * eta * ym_raw`` for a\n", - " | normalisation).\n", - " |\n", - " | Parameters\n", - " | ----------\n", - " | support : np.ndarray, optional\n", - " | Indices of this observation's block in the stacked vector\n", - " | (``None`` for a single-observation constraint).\n", - " |\n", - " | Returns\n", - " | -------\n", - " | list of Term\n", - " | The absolute offset mode (``outer(omega, omega)``) first, then the\n", - " | fractional, prediction-scaled normalisation mode\n", - " | (``eta**2 * outer(ym, ym)``).\n", - " |\n", - " | ----------------------------------------------------------------------\n", - " | Readonly properties defined here:\n", - " |\n", - " | log_jacobian\n", - " | ``sum(log |t'(y_raw)|)`` over the active points.\n", - " |\n", - " | The log-Jacobian of the comparison-space transform: a constant in the\n", - " | parameters, needed only to compare marginal likelihoods (log Z) across\n", - " | different comparison spaces (``log Z_raw = log Z_transformed +\n", - " | log_jacobian``). Zero for the identity.\n", - " |\n", - " | n_active\n", - " | Number of active (unmasked) points.\n", - " |\n", - " | ----------------------------------------------------------------------\n", - " | Data descriptors defined here:\n", - " |\n", - " | __dict__\n", - " | dictionary for instance variables\n", - " |\n", - " | __weakref__\n", - " | list of weak references to the object\n", - "\n" - ] - } - ], - "source": [ - "help(rxmc.observation.Observation)" - ] - }, - { - "cell_type": "markdown", - "id": "09fdde46-187c-4849-947e-15d98bcef3ae", - "metadata": {}, - "source": [ - "Ok, so basically it's just some `x` and `y`, ans some information about the errors of `y`. We can think of `Observation`s like experimental measurements of an observable, and we want to build a model to make uncertainty-quantified predictions of that observable." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "9f859e53-c6f9-4d88-b7bf-bbc5bc9ab686", - "metadata": { - "execution": { - "iopub.execute_input": "2026-09-09T18:23:09.675382Z", - "iopub.status.busy": "2026-09-09T18:23:09.675238Z", - "iopub.status.idle": "2026-09-09T18:23:09.679017Z", - "shell.execute_reply": "2026-09-09T18:23:09.678407Z" - } - }, - "outputs": [], - "source": [ - "class LinearModel(rxmc.physical_model.PhysicalModel):\n", - " def __init__(self):\n", - " params = [\n", - " rxmc.params.Parameter(\"m\", float, \"no-units\"),\n", - " rxmc.params.Parameter(\"b\", float, \"y-units\"),\n", - " ]\n", - " super().__init__(params)\n", - "\n", - " def evaluate(self, observation, m, b):\n", - " return self.y(observation.x, m, b)\n", - "\n", - " def y(self, x, m, b):\n", - " # useful to have a function hat takes in an array-like x\n", - " # rather than an Observation, e.g. for plotting\n", - " return m * x + b" - ] - }, - { - "cell_type": "markdown", - "id": "74fd0a56-9c1e-4a99-a20a-286d373ced62", - "metadata": {}, - "source": [ - "Well that's not too complicated." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "b83c6308-935b-4c8a-b1ef-0d65677ec809", - "metadata": { - "execution": { - "iopub.execute_input": "2026-09-09T18:23:09.680343Z", - "iopub.status.busy": "2026-09-09T18:23:09.680183Z", - "iopub.status.idle": "2026-09-09T18:23:09.682461Z", - "shell.execute_reply": "2026-09-09T18:23:09.681975Z" - } - }, - "outputs": [], - "source": [ - "my_model = LinearModel()" - ] - }, - { - "cell_type": "markdown", - "id": "a841a40b-cddf-4921-a660-2ee3bfa3de71", - "metadata": {}, - "source": [ - "Let's test it out:" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "27f09315-06dc-44ee-8190-f5d393974b68", - "metadata": { - "execution": { - "iopub.execute_input": "2026-09-09T18:23:09.683764Z", - "iopub.status.busy": "2026-09-09T18:23:09.683648Z", - "iopub.status.idle": "2026-09-09T18:23:09.688346Z", - "shell.execute_reply": "2026-09-09T18:23:09.687910Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "array([1., 2., 3.])" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# true params are obviously m = 1, b = 0\n", - "observation = rxmc.observation.Observation(x=np.array([1, 2, 3]), y=np.array([1, 2, 3]))\n", - "my_model(observation, 1, 0)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "f5de0b99-d85b-4acf-bfb4-eabdc4580688", - "metadata": { - "execution": { - "iopub.execute_input": "2026-09-09T18:23:09.689720Z", - "iopub.status.busy": "2026-09-09T18:23:09.689590Z", - "iopub.status.idle": "2026-09-09T18:23:09.692850Z", - "shell.execute_reply": "2026-09-09T18:23:09.692199Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "array([3, 5, 7])" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "my_model.y(observation.x, 2, 1)" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "bf846a07-d5d2-4f34-838c-06b1deca0739", - "metadata": { - "execution": { - "iopub.execute_input": "2026-09-09T18:23:09.694092Z", - "iopub.status.busy": "2026-09-09T18:23:09.693952Z", - "iopub.status.idle": "2026-09-09T18:23:09.696803Z", - "shell.execute_reply": "2026-09-09T18:23:09.696336Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "array([3., 5., 7.])" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# now with parameters that are obviously wrong\n", - "my_model(observation, 2, 1)" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "fb8188e6-7e47-479f-8b72-a8825ae5dacd", - "metadata": { - "execution": { - "iopub.execute_input": "2026-09-09T18:23:09.698094Z", - "iopub.status.busy": "2026-09-09T18:23:09.697955Z", - "iopub.status.idle": "2026-09-09T18:23:09.700984Z", - "shell.execute_reply": "2026-09-09T18:23:09.700393Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[3. 5. 7.]\n", - "[3. 5. 7.]\n" - ] - } - ], - "source": [ - "# just to show some ways that may be convenient to pass around params\n", - "# note they must be in the same order as in my_model.evaluate,\n", - "# which should be in the same order as my_model.params\n", - "\n", - "p = [2, 1]\n", - "print(my_model(observation, *p))\n", - "p = np.array([2, 1])\n", - "print(my_model(observation, *p))" - ] - }, - { - "cell_type": "markdown", - "id": "0f73f0a7-667b-485f-9753-591d17464409", - "metadata": {}, - "source": [ - "## define a prior\n", - "\n", - "Let's imagine this line corresponds to some physics, and we have some backround knowledge to inform us what we expect $m$ and $b$ to be. We can encode that into a prior distribution:" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "d251f717-09be-4280-b59d-de137fd7cfc2", - "metadata": { - "execution": { - "iopub.execute_input": "2026-09-09T18:23:09.702304Z", - "iopub.status.busy": "2026-09-09T18:23:09.702188Z", - "iopub.status.idle": "2026-09-09T18:23:09.704818Z", - "shell.execute_reply": "2026-09-09T18:23:09.704037Z" - } - }, - "outputs": [], - "source": [ - "prior_mean = OrderedDict(\n", - " [\n", - " (\"m\", 1),\n", - " (\"b\", 1),\n", - " ]\n", - ")\n", - "prior_std_dev = OrderedDict(\n", - " [\n", - " (\"m\", 1),\n", - " (\"b\", 1),\n", - " ]\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "016fc2de-c206-44c1-916a-a3b663a8fd25", - "metadata": { - "execution": { - "iopub.execute_input": "2026-09-09T18:23:09.706006Z", - "iopub.status.busy": "2026-09-09T18:23:09.705881Z", - "iopub.status.idle": "2026-09-09T18:23:09.708580Z", - "shell.execute_reply": "2026-09-09T18:23:09.707834Z" - } - }, - "outputs": [], - "source": [ - "covariance = np.diag(list(prior_std_dev.values())) ** 2\n", - "mean = np.array(list(prior_mean.values()))" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "d28fcb22-9ca7-4846-9cba-24b7b4808e2c", - "metadata": { - "execution": { - "iopub.execute_input": "2026-09-09T18:23:09.709810Z", - "iopub.status.busy": "2026-09-09T18:23:09.709694Z", - "iopub.status.idle": "2026-09-09T18:23:09.712937Z", - "shell.execute_reply": "2026-09-09T18:23:09.712205Z" - } - }, - "outputs": [], - "source": [ - "n_prior_samples = 1000\n", - "prior_distribution = stats.multivariate_normal(mean, covariance)\n", - "prior_samples = prior_distribution.rvs(size=n_prior_samples, random_state=rng)" - ] - }, - { - "cell_type": "markdown", - "id": "a5f9acb2-90e3-4e7e-bcd1-6c12ef2baa44", - "metadata": {}, - "source": [ - "Let's plot some samples of lines from this prior" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "70a97727-68ec-4eea-880f-203a3f0817cc", - "metadata": { - "execution": { - "iopub.execute_input": "2026-09-09T18:23:09.714160Z", - "iopub.status.busy": "2026-09-09T18:23:09.714001Z", - "iopub.status.idle": "2026-09-09T18:23:09.719998Z", - "shell.execute_reply": "2026-09-09T18:23:09.719429Z" - } - }, - "outputs": [], - "source": [ - "x = np.linspace(0, 1, 10)\n", - "\n", - "# array to hold the lines\n", - "y = np.zeros((n_prior_samples, len(x)))\n", - "\n", - "# propagate the prior through to the observation\n", - "for i in range(n_prior_samples):\n", - " sample = prior_samples[i, :]\n", - " y[i, :] = my_model.y(x, *sample)\n", - "\n", - "# grab confidence intervals for plotting\n", - "upper, lower = np.percentile(y, [5, 95], axis=0)" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "e8476136-5ab0-42c7-a3fe-88539ee7a019", - "metadata": { - "execution": { - "iopub.execute_input": "2026-09-09T18:23:09.721383Z", - "iopub.status.busy": "2026-09-09T18:23:09.721216Z", - "iopub.status.idle": "2026-09-09T18:23:11.427947Z", - "shell.execute_reply": "2026-09-09T18:23:11.427321Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 1.0, 'prior')" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "for i in np.random.choice(n_prior_samples, 1000):\n", - " plt.plot(x, y[i, :], zorder=1, alpha=0.2)\n", - " # pass\n", - "\n", - "plt.fill_between(\n", - " x, lower, upper, alpha=0.5, zorder=2, label=r\"inner 90$^\\text{th}$ pctl\"\n", - ")\n", - "plt.xlabel(\"x\")\n", - "plt.ylabel(\"y\")\n", - "plt.legend()\n", - "plt.title(\"prior\")" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "30ed8fc8-d5e9-4e58-85e8-aba6b8683d00", - "metadata": { - "execution": { - "iopub.execute_input": "2026-09-09T18:23:11.429402Z", - "iopub.status.busy": "2026-09-09T18:23:11.429243Z", - "iopub.status.idle": "2026-09-09T18:23:11.567585Z", - "shell.execute_reply": "2026-09-09T18:23:11.566891Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 0.98, 'prior')" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig = corner.corner(prior_samples, labels=[p.name for p in my_model.params])\n", - "fig.suptitle(\"prior\")" - ] - }, - { - "cell_type": "markdown", - "id": "278a52b1-4326-43a4-8157-0b9e7e24a352", - "metadata": {}, - "source": [ - "## Now let's update our prior by comparing to some data\n", - "\n", - "This will require learning how `rxmc` encodes our assumptions about the error on an experimental `Observation`: as a covariance built from explicit terms, evaluated under a likelihood functional. These are a necessary ingredient for comparing to the predictions of a `PhysicalModel`.\n", - "\n", - "In our case we will mock experimental data by synthetically generate some data with noise about a \"true\" $m$ and $b$. Our calibration posterior should converge to be centered about this true point.\n", - "\n", - "Let us assume that the experimentalists made a perfect estimate of the experimental noise in their setup. That is, the error bars they report will correspond exactly to the true distribution from which we sample.\n", - "\n", - "This noise will correspond to statistical noise. Later on we will look at systematic experimental error." - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "d07c4b8c-fb40-4af3-9a76-7c798943a213", - "metadata": { - "execution": { - "iopub.execute_input": "2026-09-09T18:23:11.568951Z", - "iopub.status.busy": "2026-09-09T18:23:11.568808Z", - "iopub.status.idle": "2026-09-09T18:23:11.572069Z", - "shell.execute_reply": "2026-09-09T18:23:11.571523Z" - } - }, - "outputs": [], - "source": [ - "true_params = OrderedDict(\n", - " [\n", - " (\"m\", 0.6),\n", - " (\"b\", 2),\n", - " ]\n", - ")\n", - "\n", - "x = np.linspace(0, 1, 10)\n", - "noise = 0.1\n", - "y_exp = my_model.y(x, *list(true_params.values())) + rng.normal(\n", - " scale=noise, size=len(x)\n", - ")\n", - "y_stat_err = noise * np.ones_like(y_exp) # noise is just a constant fraction of y\n", - "obs1 = rxmc.observation.Observation(x=x, y=y_exp, y_stat_err=y_stat_err)" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "664d9b5e-d7d2-4d08-91f6-763e75b40ab4", - "metadata": { - "execution": { - "iopub.execute_input": "2026-09-09T18:23:11.573283Z", - "iopub.status.busy": "2026-09-09T18:23:11.573166Z", - "iopub.status.idle": "2026-09-09T18:23:11.702710Z", - "shell.execute_reply": "2026-09-09T18:23:11.701937Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 1.0, 'experimental constraint')" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.errorbar(\n", - " x,\n", - " y_exp,\n", - " y_stat_err,\n", - " color=\"k\",\n", - " marker=\".\",\n", - " linestyle=\"none\",\n", - " label=\"obs1\",\n", - ")\n", - "plt.plot(x, my_model.y(x, *list(true_params.values())), \"k--\", label=\"truth\")\n", - "plt.xlabel(\"x\")\n", - "plt.ylabel(\"y\")\n", - "\n", - "plt.fill_between(\n", - " x,\n", - " lower,\n", - " upper,\n", - " alpha=0.5,\n", - " zorder=2,\n", - " label=r\"prior inner 90$^\\text{th}$ pctl\",\n", - ")\n", - "\n", - "plt.legend()\n", - "plt.title(\"experimental constraint\")" - ] - }, - { - "cell_type": "markdown", - "id": "766bb583-3be2-469a-85bb-4f364610f175", - "metadata": {}, - "source": [ - "Clearly, our prior is at odds with our observation. We will now determine a posterior distribution of $m$ and $b$ that takes `obs1` into account. To do this, we will need to think about a likelihood for `obs1` — in `rxmc` that means a covariance model (here, just the reported statistical errors) and a likelihood functional (the default `GaussianLikelihood`)." - ] - }, - { - "cell_type": "markdown", - "id": "4818c696-b984-4145-b911-5307782e0dd5", - "metadata": {}, - "source": [ - "## set up the likelihood and `Constraint`\n", - "\n", - "We will use the simplest assumption about the error on y: that the experimentalists exactly reported the statistical error, and there is no systematic error at all. This implies that each data point in `obs1.y`, say `obs1.y[i]` can be modeled as being an random variate, each sampled independently from normal distributions with mean `obs1.y[i]` and with standard deviation `obs1.y_stat_err[i]`.\n", - "\n", - "This is exactly the default behavior: a `Constraint` automatically includes each observation's statistical diagonal in its covariance, and evaluates it under the default `GaussianLikelihood`:" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "id": "1ca25e05-9b9d-4c22-94bf-0caf31854835", - "metadata": { - "execution": { - "iopub.execute_input": "2026-09-09T18:23:11.704213Z", - "iopub.status.busy": "2026-09-09T18:23:11.704025Z", - "iopub.status.idle": "2026-09-09T18:23:11.708161Z", - "shell.execute_reply": "2026-09-09T18:23:11.707585Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Help on class GaussianLikelihood in module rxmc.likelihood_model:\n", - "\n", - "class GaussianLikelihood(Likelihood)\n", - " | Multivariate-normal likelihood over the stacked residual.\n", - " |\n", - " | Parameter-free — all uncertainty lives on the covariance terms.\n", - " |\n", - " | Method resolution order:\n", - " | GaussianLikelihood\n", - " | Likelihood\n", - " | builtins.object\n", - " |\n", - " | Methods defined here:\n", - " |\n", - " | log_likelihood(self, d2, logdet, n, *like_params)\n", - " |\n", - " | ----------------------------------------------------------------------\n", - " | Data and other attributes defined here:\n", - " |\n", - " | __annotations__ = {}\n", - " |\n", - " | ----------------------------------------------------------------------\n", - " | Methods inherited from Likelihood:\n", - " |\n", - " | chi2(self, d2, logdet, n, *like_params)\n", - " |\n", - " | ----------------------------------------------------------------------\n", - " | Data descriptors inherited from Likelihood:\n", - " |\n", - " | __dict__\n", - " | dictionary for instance variables\n", - " |\n", - " | __weakref__\n", - " | list of weak references to the object\n", - " |\n", - " | ----------------------------------------------------------------------\n", - " | Data and other attributes inherited from Likelihood:\n", - " |\n", - " | n_params = 0\n", - " |\n", - " | params = ()\n", - "\n" - ] - } - ], - "source": [ - "help(rxmc.likelihood_model.GaussianLikelihood)" - ] - }, - { - "cell_type": "markdown", - "id": "685dec98-6cf8-49e4-b1aa-3bad227ffe8b", - "metadata": {}, - "source": [ - "With a purely statistical (diagonal) covariance, the likelihood is proportional to the familiar form:\n", - "\n", - "\\begin{equation}\n", - " \\mathcal{L}(\\alpha|y) \\propto e^{ - \\chi^2(\\alpha,y) }\n", - "\\end{equation}\n", - "\n", - "where the Chi-squared is simply\n", - "\n", - "\\begin{equation}\n", - "\\chi^2(\\alpha,y) = \\sum_i \\frac{(y(x_i) - y_m(x_i;\\alpha) )^2}{\\sigma^2_i}\n", - "\\end{equation}\n", - "\n", - "In a later tutorial we will use more complicated `Observation`s that include systematic error, and look at other `LikelihoodModel`s." - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "id": "8b698c69-7a23-4955-ab7a-15107774bec9", - "metadata": { - "execution": { - "iopub.execute_input": "2026-09-09T18:23:11.709520Z", - "iopub.status.busy": "2026-09-09T18:23:11.709400Z", - "iopub.status.idle": "2026-09-09T18:23:11.711656Z", - "shell.execute_reply": "2026-09-09T18:23:11.711076Z" - } - }, - "outputs": [], - "source": [ - "likelihood_model = rxmc.likelihood_model.GaussianLikelihood()" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "id": "211990b6-85ba-47b1-89c4-796c5b396168", - "metadata": { - "execution": { - "iopub.execute_input": "2026-09-09T18:23:11.713223Z", - "iopub.status.busy": "2026-09-09T18:23:11.713084Z", - "iopub.status.idle": "2026-09-09T18:23:11.715482Z", - "shell.execute_reply": "2026-09-09T18:23:11.714951Z" - } - }, - "outputs": [], - "source": [ - "constraint = rxmc.constraint.Constraint(\n", - " [obs1],\n", - " my_model,\n", - " likelihood_model,\n", - ")" - ] - }, - { - "cell_type": "markdown", - "id": "6e59d72f-7175-4ac8-9b08-bdeb1119379f", - "metadata": {}, - "source": [ - "Let's test this `constraint` thing out. What is the reduced $\\chi^2$ for the prior mean?" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "id": "51b72666-3986-42f1-8262-8de23eb87ee3", - "metadata": { - "execution": { - "iopub.execute_input": "2026-09-09T18:23:11.716786Z", - "iopub.status.busy": "2026-09-09T18:23:11.716668Z", - "iopub.status.idle": "2026-09-09T18:23:11.720105Z", - "shell.execute_reply": "2026-09-09T18:23:11.719481Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "64.18631209285807" - ] - }, - "execution_count": 23, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "constraint.chi2(prior_distribution.mean) / constraint.n_data_pts" - ] - }, - { - "cell_type": "markdown", - "id": "5cc86910-5ded-4339-ad1b-0ff82fabd5f6", - "metadata": {}, - "source": [ - "Here is proof that, in this case, we reduce to the form described above:" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "id": "a845e4ff-1d51-455b-97c8-e7ad561a89ce", - "metadata": { - "execution": { - "iopub.execute_input": "2026-09-09T18:23:11.721495Z", - "iopub.status.busy": "2026-09-09T18:23:11.721360Z", - "iopub.status.idle": "2026-09-09T18:23:11.724730Z", - "shell.execute_reply": "2026-09-09T18:23:11.724208Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "np.float64(64.18631209285807)" - ] - }, - "execution_count": 24, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "y = my_model(obs1, *prior_distribution.mean)\n", - "np.sum((y - obs1.y) ** 2 / y_stat_err**2) / constraint.n_data_pts" - ] - }, - { - "cell_type": "markdown", - "id": "fbb7e0d9-8a86-4228-9372-ee63dfad5ee3", - "metadata": {}, - "source": [ - "## running the calibration" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "id": "dd9fa5b9-10ab-4649-96c0-58f9cb6896f6", - "metadata": { - "execution": { - "iopub.execute_input": "2026-09-09T18:23:11.725920Z", - "iopub.status.busy": "2026-09-09T18:23:11.725804Z", - "iopub.status.idle": "2026-09-09T18:23:11.728856Z", - "shell.execute_reply": "2026-09-09T18:23:11.728456Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Help on class Walker in module rxmc.walker:\n", - "\n", - "class Walker(builtins.object)\n", - " | Walker(model_sampler: rxmc.param_sampling.Sampler, evidence: rxmc.evidence.Evidence, likelihood_samplers: list[rxmc.param_sampling.Sampler] | None = None, rng: numpy.random._generator.Generator | None = None)\n", - " |\n", - " | Gibbs-style MCMC coordinator for a Bayesian calibration problem.\n", - " |\n", - " | Manages one sampler for the physical-model parameters and, optionally,\n", - " | per-constraint samplers for parametric likelihood parameters. The samplers\n", - " | alternate in a Gibbs framework: model parameters are updated with the\n", - " | likelihood parameters held fixed, then each set of likelihood parameters is\n", - " | updated with the model parameters held fixed.\n", - " |\n", - " | Parameters\n", - " | ----------\n", - " | model_sampler : Sampler\n", - " | Sampler for the physical-model parameters.\n", - " | evidence : Evidence\n", - " | Evidence object containing the observations and likelihood models.\n", - " | likelihood_samplers : list of Sampler, optional\n", - " | One sampler per entry in ``evidence.parametric_constraints``.\n", - " | rng : np.random.Generator, optional\n", - " | Random number generator. Defaults to ``default_rng(42)``.\n", - " |\n", - " | Raises\n", - " | ------\n", - " | ValueError\n", - " | If the physical-model parameters in *evidence* and *model_sampler* do\n", - " | not match.\n", - " | ValueError\n", - " | If the number of *likelihood_samplers* does not equal the number of\n", - " | parametric constraints in *evidence*.\n", - " | ValueError\n", - " | If any likelihood sampler's parameters do not match those of the\n", - " | corresponding parametric constraint.\n", - " |\n", - " | Methods defined here:\n", - " |\n", - " | __init__(self, model_sampler: rxmc.param_sampling.Sampler, evidence: rxmc.evidence.Evidence, likelihood_samplers: list[rxmc.param_sampling.Sampler] | None = None, rng: numpy.random._generator.Generator | None = None)\n", - " | Initialize self. See help(type(self)) for accurate signature.\n", - " |\n", - " | log_likelihood(self, model_params, likelihood_params)\n", - " |\n", - " | log_posterior(self, model_params, likelihood_params)\n", - " |\n", - " | log_prior(self, model_params, likelihood_params)\n", - " | Log prior probability of model and likelihood parameters.\n", - " |\n", - " | Parameters\n", - " | ----------\n", - " | model_params : tuple\n", - " | Physical-model parameter values.\n", - " | likelihood_params : list of tuple\n", - " | One tuple of likelihood parameter values per parametric constraint.\n", - " |\n", - " | Returns\n", - " | -------\n", - " | float\n", - " | Sum of log prior densities for model and likelihood parameters.\n", - " |\n", - " | run_likelihood_batches(self, n_steps, starting_locations, model_params, burn=False)\n", - " | Sample each set of likelihood parameters for fixed model parameters.\n", - " |\n", - " | Parameters\n", - " | ----------\n", - " | n_steps : int\n", - " | Number of MCMC steps per likelihood sampler.\n", - " | starting_locations : list of np.ndarray\n", - " | Starting locations for each likelihood sampler.\n", - " | model_params : tuple\n", - " | Fixed physical-model parameter values.\n", - " | burn : bool, optional\n", - " | If ``True``, treat as burn-in (samples are not recorded).\n", - " |\n", - " | run_model_batch(self, n_steps, x0, likelihood_params=None, burn=False)\n", - " | Sample model parameters for fixed likelihood parameters.\n", - " |\n", - " | Parameters\n", - " | ----------\n", - " | n_steps : int\n", - " | Number of MCMC steps.\n", - " | x0 : np.ndarray\n", - " | Starting location for the model parameters.\n", - " | likelihood_params : list of tuple, optional\n", - " | Fixed values of the likelihood parameters for each parametric\n", - " | constraint. Defaults to ``[]``.\n", - " | burn : bool, optional\n", - " | If ``True``, treat as burn-in (samples are not recorded).\n", - " |\n", - " | walk(self, n_steps: int, burnin: int = 0, batch_size: int = None, verbose: bool = True)\n", - " | Run the full MCMC chain.\n", - " |\n", - " | Updates the internal state of ``model_sampler`` and each entry of\n", - " | ``likelihood_samplers`` with the accumulated chain, log posteriors,\n", - " | and acceptance statistics.\n", - " |\n", - " | Parameters\n", - " | ----------\n", - " | n_steps : int\n", - " | Total number of active (post-burn-in) steps.\n", - " | burnin : int, optional\n", - " | Number of burn-in steps discarded before recording.\n", - " | Defaults to ``0``.\n", - " | batch_size : int, optional\n", - " | Steps per batch. If ``None`` the entire chain is one batch.\n", - " | verbose : bool, optional\n", - " | Print batch completion messages. Defaults to ``True``.\n", - " |\n", - " | ----------------------------------------------------------------------\n", - " | Data descriptors defined here:\n", - " |\n", - " | __dict__\n", - " | dictionary for instance variables\n", - " |\n", - " | __weakref__\n", - " | list of weak references to the object\n", - "\n" - ] - } - ], - "source": [ - "help(rxmc.walker.Walker)" - ] - }, - { - "cell_type": "markdown", - "id": "cc7f9eff-e473-4d7d-b081-4ba1fa6a94b5", - "metadata": {}, - "source": [ - "First we need to put together our `Evidence`. With one constraint this seems trivial, but this will be useful down the road when we may want to combine multiple constraints together." - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "id": "1ff7c728-b0ac-4c48-8779-19da58277cc9", - "metadata": { - "execution": { - "iopub.execute_input": "2026-09-09T18:23:11.730328Z", - "iopub.status.busy": "2026-09-09T18:23:11.730196Z", - "iopub.status.idle": "2026-09-09T18:23:11.732694Z", - "shell.execute_reply": "2026-09-09T18:23:11.731967Z" - } - }, - "outputs": [], - "source": [ - "evidence = rxmc.evidence.Evidence([constraint])" - ] - }, - { - "cell_type": "markdown", - "id": "bf1e4ad1-a94a-42c2-b084-c29b9945c29e", - "metadata": {}, - "source": [ - "Another chore we have to do is configure how we will sample our parameter space." - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "id": "5470a662-4880-418d-85aa-deadeca0cfe7", - "metadata": { - "execution": { - "iopub.execute_input": "2026-09-09T18:23:11.734066Z", - "iopub.status.busy": "2026-09-09T18:23:11.733940Z", - "iopub.status.idle": "2026-09-09T18:23:11.736842Z", - "shell.execute_reply": "2026-09-09T18:23:11.736379Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Help on class MetropolisHastingsSampler in module rxmc.param_sampling:\n", - "\n", - "class MetropolisHastingsSampler(Sampler)\n", - " | MetropolisHastingsSampler(params: list[rxmc.params.Parameter], prior, starting_location: numpy.ndarray, proposal: rxmc.proposal.ProposalDistribution)\n", - " |\n", - " | Metropolis-Hastings sampler with a fixed proposal distribution.\n", - " |\n", - " | Parameters\n", - " | ----------\n", - " | params : list of Parameter\n", - " | Parameters to sample.\n", - " | prior : object\n", - " | Prior distribution with a callable ``logpdf(x)`` method.\n", - " | starting_location : np.ndarray, shape (ndim,)\n", - " | Initial parameter vector.\n", - " | proposal : ProposalDistribution\n", - " | Callable proposal distribution. Must accept ``(x, rng)`` and return\n", - " | a proposed parameter vector.\n", - " |\n", - " | Method resolution order:\n", - " | MetropolisHastingsSampler\n", - " | Sampler\n", - " | builtins.object\n", - " |\n", - " | Methods defined here:\n", - " |\n", - " | __init__(self, params: list[rxmc.params.Parameter], prior, starting_location: numpy.ndarray, proposal: rxmc.proposal.ProposalDistribution)\n", - " | Initialize self. See help(type(self)) for accurate signature.\n", - " |\n", - " | ----------------------------------------------------------------------\n", - " | Methods inherited from Sampler:\n", - " |\n", - " | batch_acceptance_fractions(self) -> numpy.ndarray\n", - " | Acceptance fraction for each completed batch.\n", - " |\n", - " | Returns\n", - " | -------\n", - " | np.ndarray\n", - " | Per-batch acceptance fractions, or ``[0.0]`` if no batches run.\n", - " |\n", - " | most_recent_batch_acceptance_fraction(self) -> float\n", - " | Acceptance fraction of the most recent batch.\n", - " |\n", - " | Returns\n", - " | -------\n", - " | float\n", - " | Fraction of proposals accepted in the last batch, or ``0.0`` if\n", - " | no batches have been run.\n", - " |\n", - " | overall_acceptance_fraction(self) -> float\n", - " | Overall acceptance fraction across all completed batches.\n", - " |\n", - " | Returns\n", - " | -------\n", - " | float\n", - " | Total accepted / total proposed, or ``0.0`` if no batches run.\n", - " |\n", - " | record_batch(self, n_steps: int, n_accepted: int, chain: numpy.ndarray, logp_chain: numpy.ndarray)\n", - " | Append a completed batch to the running chain.\n", - " |\n", - " | Parameters\n", - " | ----------\n", - " | n_steps : int\n", - " | Number of steps in the batch.\n", - " | n_accepted : int\n", - " | Number of accepted proposals in the batch.\n", - " | chain : np.ndarray, shape (n_steps, ndim)\n", - " | Sampled parameter vectors.\n", - " | logp_chain : np.ndarray, shape (n_steps,)\n", - " | Log posterior values for the batch.\n", - " |\n", - " | sample(self, n_steps: int, starting_location: numpy.ndarray, rng: numpy.random._generator.Generator, log_posterior: Callable[[numpy.ndarray], float], burn: bool = False)\n", - " | Run the sampling algorithm for one batch.\n", - " |\n", - " | Updates ``self.state`` to the last sample; records the batch unless\n", - " | *burn* is ``True``.\n", - " |\n", - " | Parameters\n", - " | ----------\n", - " | n_steps : int\n", - " | Number of steps to run.\n", - " | starting_location : np.ndarray, shape (ndim,)\n", - " | Starting parameter vector for this batch.\n", - " | rng : np.random.Generator\n", - " | Random number generator.\n", - " | log_posterior : callable\n", - " | Function ``f(x) -> float`` returning the log posterior at ``x``.\n", - " | burn : bool, optional\n", - " | If ``True``, discard samples (burn-in); only ``self.state`` is\n", - " | updated. Defaults to ``False``.\n", - " |\n", - " | ----------------------------------------------------------------------\n", - " | Data descriptors inherited from Sampler:\n", - " |\n", - " | __dict__\n", - " | dictionary for instance variables\n", - " |\n", - " | __weakref__\n", - " | list of weak references to the object\n", - "\n" - ] - } - ], - "source": [ - "help(rxmc.param_sampling.MetropolisHastingsSampler)" - ] - }, - { - "cell_type": "markdown", - "id": "628ad075-8062-4420-8e1f-76a5ed69f3b4", - "metadata": {}, - "source": [ - "This means we have to decide on a proposal distribution. We will use a simple form: just sampling from a scaled down version of the prior about the previos point:" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "id": "9c0ac067-047a-4357-a462-415e32d0481c", - "metadata": { - "execution": { - "iopub.execute_input": "2026-09-09T18:23:11.738159Z", - "iopub.status.busy": "2026-09-09T18:23:11.737999Z", - "iopub.status.idle": "2026-09-09T18:23:11.740430Z", - "shell.execute_reply": "2026-09-09T18:23:11.739854Z" - } - }, - "outputs": [], - "source": [ - "def proposal_distribution(x, rng):\n", - " return stats.multivariate_normal.rvs(\n", - " mean=x, cov=prior_distribution.cov / 100, random_state=rng\n", - " )" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "id": "5362bf0b-76d4-419b-af34-2ee94e3b2dda", - "metadata": { - "execution": { - "iopub.execute_input": "2026-09-09T18:23:11.741585Z", - "iopub.status.busy": "2026-09-09T18:23:11.741426Z", - "iopub.status.idle": "2026-09-09T18:23:11.743814Z", - "shell.execute_reply": "2026-09-09T18:23:11.743184Z" - } - }, - "outputs": [], - "source": [ - "sampling_config = rxmc.param_sampling.MetropolisHastingsSampler(\n", - " params=my_model.params,\n", - " starting_location=prior_distribution.mean,\n", - " proposal=proposal_distribution,\n", - " prior=prior_distribution,\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "id": "784ebdb9-b5f2-4a2f-9882-a65d2f107c05", - "metadata": { - "execution": { - "iopub.execute_input": "2026-09-09T18:23:11.744999Z", - "iopub.status.busy": "2026-09-09T18:23:11.744868Z", - "iopub.status.idle": "2026-09-09T18:23:11.747235Z", - "shell.execute_reply": "2026-09-09T18:23:11.746588Z" - } - }, - "outputs": [], - "source": [ - "walker = rxmc.walker.Walker(\n", - " sampling_config,\n", - " evidence,\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "id": "194af035-fafd-4c64-8b58-0f7af34bb685", - "metadata": { - "execution": { - "iopub.execute_input": "2026-09-09T18:23:11.748479Z", - "iopub.status.busy": "2026-09-09T18:23:11.748344Z", - "iopub.status.idle": "2026-09-09T18:23:17.635768Z", - "shell.execute_reply": "2026-09-09T18:23:17.635315Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Burn-in batch 1/1 completed, 1000 steps.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 1/1 completed, 20000 steps. \n", - " Model parameter acceptance fraction: 0.273\n", - "CPU times: user 5.89 s, sys: 40.5 ms, total: 5.93 s\n", - "Wall time: 5.88 s\n" - ] - } - ], - "source": [ - "%%time\n", - "walker.walk(\n", - " n_steps=20000,\n", - " burnin=1000,\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "id": "b57ce430-2014-4999-9e4f-3f16f0c3c8fc", - "metadata": { - "execution": { - "iopub.execute_input": "2026-09-09T18:23:17.637295Z", - "iopub.status.busy": "2026-09-09T18:23:17.637172Z", - "iopub.status.idle": "2026-09-09T18:23:17.639377Z", - "shell.execute_reply": "2026-09-09T18:23:17.638835Z" - } - }, - "outputs": [], - "source": [ - "chain = walker.model_sampler.chain\n", - "logp = walker.model_sampler.logp_chain" - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "id": "8bd838cf-8ed2-43b9-a545-416b9f5b802c", - "metadata": { - "execution": { - "iopub.execute_input": "2026-09-09T18:23:17.640592Z", - "iopub.status.busy": "2026-09-09T18:23:17.640474Z", - "iopub.status.idle": "2026-09-09T18:23:17.643253Z", - "shell.execute_reply": "2026-09-09T18:23:17.642785Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "(20000, 2)" - ] - }, - "execution_count": 33, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "chain.shape" - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "id": "122e8c8e-4975-42b0-96ef-611cb9187c85", - "metadata": { - "execution": { - "iopub.execute_input": "2026-09-09T18:23:17.644574Z", - "iopub.status.busy": "2026-09-09T18:23:17.644455Z", - "iopub.status.idle": "2026-09-09T18:23:17.944915Z", - "shell.execute_reply": "2026-09-09T18:23:17.944215Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 0, '$i$')" - ] - }, - "execution_count": 34, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig, axes = plt.subplots(chain.shape[1] + 1, 1, figsize=(8, 8), sharex=True)\n", - "for i in range(chain.shape[1]):\n", - " axes[i].plot(chain[:, i])\n", - " axes[i].set_ylabel(f\"${my_model.params[i].latex_name}$ [{my_model.params[i].unit}]\")\n", - " true_value = true_params[my_model.params[i].name]\n", - " axes[i].hlines(true_value, 0, len(chain), \"r\", linestyle=\"--\")\n", - "\n", - "\n", - "axes[-1].plot(logp)\n", - "axes[-1].set_ylabel(r\"$\\log{\\mathcal{L}(\\alpha_i | \\mathcal{O})}$\")\n", - "\n", - "axes[-1].set_xlabel(r\"$i$\")\n", - "# plt.legend(title=\"chains\", ncol=3,)" - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "id": "6b20814a-1595-4881-9190-6f03ee4811e3", - "metadata": { - "execution": { - "iopub.execute_input": "2026-09-09T18:23:17.946425Z", - "iopub.status.busy": "2026-09-09T18:23:17.946297Z", - "iopub.status.idle": "2026-09-09T18:23:17.949919Z", - "shell.execute_reply": "2026-09-09T18:23:17.949142Z" - } - }, - "outputs": [], - "source": [ - "posterior_range = np.vstack([np.min(chain, axis=0), np.max(chain, axis=0)]).T" - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "id": "21ca84ce-5d9a-44db-8651-f9c80e9b1f68", - "metadata": { - "execution": { - "iopub.execute_input": "2026-09-09T18:23:17.951275Z", - "iopub.status.busy": "2026-09-09T18:23:17.951157Z", - "iopub.status.idle": "2026-09-09T18:23:18.106585Z", - "shell.execute_reply": "2026-09-09T18:23:18.105865Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 0.98, 'posterior')" - ] - }, - "execution_count": 36, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig = corner.corner(\n", - " chain,\n", - " labels=[p.name for p in my_model.params],\n", - " label=\"posterior\",\n", - " truths=[true_params[\"m\"], true_params[\"b\"]],\n", - ")\n", - "fig.suptitle(\"posterior\")" - ] - }, - { - "cell_type": "code", - "execution_count": 37, - "id": "4aaec946-4f48-47e0-ad46-f6d71e866341", - "metadata": { - "execution": { - "iopub.execute_input": "2026-09-09T18:23:18.107941Z", - "iopub.status.busy": "2026-09-09T18:23:18.107811Z", - "iopub.status.idle": "2026-09-09T18:23:18.110248Z", - "shell.execute_reply": "2026-09-09T18:23:18.109767Z" - } - }, - "outputs": [], - "source": [ - "x_full = np.linspace(-1, 2, 10)" - ] - }, - { - "cell_type": "code", - "execution_count": 38, - "id": "2aab97fb-db36-4a05-aef0-8774173188df", - "metadata": { - "execution": { - "iopub.execute_input": "2026-09-09T18:23:18.111547Z", - "iopub.status.busy": "2026-09-09T18:23:18.111429Z", - "iopub.status.idle": "2026-09-09T18:23:18.178487Z", - "shell.execute_reply": "2026-09-09T18:23:18.177824Z" - } - }, - "outputs": [], - "source": [ - "n_posterior_samples = chain.shape[0]\n", - "y = np.zeros((n_posterior_samples, len(x_full)))\n", - "for i in range(n_posterior_samples):\n", - " sample = chain[i, :]\n", - " y[i, :] = my_model.y(x_full, *sample)\n", - "\n", - "upper, median, lower = np.percentile(y, [5, 50, 95], axis=0)" - ] - }, - { - "cell_type": "code", - "execution_count": 39, - "id": "92fc68f8-9be2-4e5f-9bf0-65eb796f5e0a", - "metadata": { - "execution": { - "iopub.execute_input": "2026-09-09T18:23:18.180170Z", - "iopub.status.busy": "2026-09-09T18:23:18.180004Z", - "iopub.status.idle": "2026-09-09T18:23:18.301745Z", - "shell.execute_reply": "2026-09-09T18:23:18.300991Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 39, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.plot(x_full, my_model.y(x_full, *list(true_params.values())), \"k--\", label=\"truth\")\n", - "plt.xlabel(\"x\")\n", - "plt.ylabel(\"y\")\n", - "plt.errorbar(\n", - " x,\n", - " obs1.y,\n", - " y_stat_err,\n", - " color=\"k\",\n", - " marker=\"o\",\n", - " linestyle=\"none\",\n", - " label=\"experiment\",\n", - ")\n", - "plt.fill_between(\n", - " x_full,\n", - " lower,\n", - " upper,\n", - " alpha=0.5,\n", - " zorder=2,\n", - " label=r\"posterior inner 90$^\\text{th}$ pctl\",\n", - ")\n", - "plt.plot(x_full, median, \"m:\", label=\"posterior median\")\n", - "\n", - "plt.legend()\n", - "# plt.title(\"predictive posterior\")" - ] - }, - { - "cell_type": "markdown", - "id": "cf93c216-e2e7-44f0-91d5-09e0725a9fdf", - "metadata": {}, - "source": [ - "# Nice!\n", - "\n", - "Hopefully this simple example served to illustrate the basic function of the working pieces of `rxmc`. The true power is the ability to compose different `Constraint`s, and easily manage and test different model forms for both the `PhysicalModel` and the covariance terms describing the uncertainty. \n", - "\n", - "\n", - "Check out the other demos to see how `rxmc` helps us handle more realistic problems." - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.12.3" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/examples/local_optical_model_calibration.ipynb b/examples/local_optical_model_calibration.ipynb new file mode 100644 index 0000000..56b6209 --- /dev/null +++ b/examples/local_optical_model_calibration.ipynb @@ -0,0 +1,1106 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "c1391575", + "metadata": {}, + "source": [ + "# Calibrating a local optical potential to a real measurement\n", + "\n", + "This is the production path from start to finish. We take a measurement as EXFOR reports it, convert it into the library's units, calibrate a local [optical potential](https://doi.org/10.1016/S0375-9474(02)01321-0) against it with preconditioned Monte Carlo, and predict on angles the experiment never measured.\n", + "\n", + "The data are real, and that shapes everything that follows. They're [EXFOR entry C0076](https://www-nds.iaea.org/exfor/), subentry C0076002: $p + {}^{40}\\mathrm{Ca}$ elastic scattering at 35.8 MeV, measured by [Gross *et al.*, Nucl. Phys. A **102**, 673 (1967)](https://doi.org/10.1016/0375-9474(67)90194-2) as a differential cross section at 47 angles from 10 to 170 degrees. Each point carries a statistical error, and **no systematic uncertainty is quoted at all**.\n", + "\n", + "We'll calibrate the same potential twice, with two different statistical models, and compare them:\n", + "\n", + "1. **Log-space residuals with an inferred error model**: the reported statistical errors, plus a point-to-point and a common relative error in log space, after the `jitr` [$\\alpha$ + Ca Bayesian calibration notebook](https://github.com/beykyle/jitr/blob/main/examples/notebooks/alpha_ca_calibration.ipynb).\n", + "2. **Linear residuals with only the reported statistical errors**, which is what we get if we take the measurement entirely at its word.\n", + "\n", + "We'll judge them in three ways: **(A)** the evidence; **(B)** the posterior predictive, both for the model only and for the full predictive, the potential plus every error term; and **(C)** the empirical coverage of each of those predictives.\n", + "\n", + "Recipes: 10, 14, 15, 16, 17, 18, 21, 40 (see [the recipes](/recipes.md))" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "b2831405", + "metadata": {}, + "outputs": [], + "source": [ + "import time\n", + "\n", + "import corner\n", + "import jitr\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "import plotstyle\n", + "import pocomc\n", + "from budget import budget # sampler budgets, cut in CI's quick run\n", + "from jitr.optical_potentials import kduq\n", + "from jitr.optical_potentials.potential_forms import (\n", + " coulomb_charged_sphere,\n", + " thomas_safe,\n", + " woods_saxon_prime_safe,\n", + " woods_saxon_safe,\n", + ")\n", + "from scipy import stats\n", + "\n", + "import rxmc as rx\n", + "from rxmc import transforms as tf\n", + "\n", + "plotstyle.use()" + ] + }, + { + "cell_type": "markdown", + "id": "b4359118", + "metadata": {}, + "source": [ + "## The measurement\n", + "\n", + "We pulled the file from the EXFOR database once and committed it next to this notebook, so the notebook runs anywhere. The query looked like this:\n", + "\n", + "```python\n", + "import exfor_tools as et\n", + "from exfor_tools import curate\n", + "\n", + "reaction = et.reaction.Reaction(target=(40, 20), projectile=(1, 1), process=\"EL\")\n", + "entries, failed = curate.query_for_entries(reaction=reaction, quantity=\"dXS/dA\")\n", + "```\n", + "\n", + "`process=\"EL\"` is the part worth remembering. EXFOR spells elastic scattering `(P,EL)`, and asking for a product tuple instead silently returns nothing.\n", + "\n", + "`exfor_tools` hands back a `Distribution` object. Here we don't want to depend on the database, so we stand in for it with a plain `dict` carrying the same fields. `rx.from_measurement` accepts either." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "7ace23e7", + "metadata": {}, + "outputs": [], + "source": [ + "df = pd.read_csv(\"data/p40ca_elastic_35p8mev_gross1967.csv\", comment=\"#\")\n", + "measurement = {\n", + " \"x\": df[\"angle_cm_deg\"].to_numpy(), # degrees\n", + " \"y\": df[\"dxs_mb_sr\"].to_numpy(),\n", + " \"statistical_err\": df[\"stat_err_mb_sr\"].to_numpy(),\n", + " \"Einc\": 35.8,\n", + " \"quantity\": \"dXS/dA\",\n", + " \"y_units\": \"mb/sr\",\n", + " \"x_units\": \"CM-degrees\",\n", + " \"systematic_norm_err\": 0.0, # this entry quotes none\n", + " \"systematic_offset_err\": 0.0,\n", + " \"subentry\": \"C0076002\",\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "7edf318a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "47 angles, 10.2 to 170.2 deg\n", + "cross section from 0.169 to 5562 mb/sr\n", + "relative statistical error: 2.4% to 5.5%, median 2.7%\n" + ] + } + ], + "source": [ + "x_deg, y_meas, y_stat = (\n", + " measurement[\"x\"],\n", + " measurement[\"y\"],\n", + " measurement[\"statistical_err\"],\n", + ")\n", + "print(f\"{x_deg.size} angles, {x_deg.min():.1f} to {x_deg.max():.1f} deg\")\n", + "print(f\"cross section from {y_meas.min():.3g} to {y_meas.max():.4g} mb/sr\")\n", + "rel = y_stat / y_meas\n", + "print(\n", + " f\"relative statistical error: {rel.min():.1%} to {rel.max():.1%}, median {np.median(rel):.1%}\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "d62f3f00", + "metadata": {}, + "source": [ + "## `from_measurement`: the unit contract\n", + "\n", + "`from_measurement` puts the measurement into the library's internal units. Angles become radians and cross sections become b/sr, so these mb/sr values are divided by 1000. Every error with dimensions is converted along with the data, while a *fractional* normalisation error passes through untouched, since it has no units to convert. The kinematics a reaction model needs to bind land in `meta`.\n", + "\n", + "This measurement exercises two parts of that contract. First, its angles are in the **CM frame**. A LAB-frame entry would be refused outright rather than silently mis-analysed. Second, asking for `dXS/dRuth` instead converts the cross section into a ratio to the Rutherford cross section, which is a closed-form function of the kinematics (recipe 14). We fit the cross section as measured, and use the ratio only to look at it." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "3b3f3ab1", + "metadata": {}, + "outputs": [], + "source": [ + "reaction = jitr.reactions.ElasticReaction(target=(40, 20), projectile=(1, 1))\n", + "data = rx.from_measurement(measurement, reaction=reaction)\n", + "ratio = rx.from_measurement(measurement, reaction=reaction, quantity=\"dXS/dRuth\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "bbdb1656", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dataset('C0076002', n=47)\n", + "cross section: y[:3] = [5.562 3.426 2.354] b/sr\n", + "ratio: y[:3] = [0.8 1.2 1.703] (dimensionless)\n", + "meta: {'quantity': 'dXS/dA', 'Elab': 35.8, 'subentry': 'C0076002', 'k': 1.2921918552594756, 'eta': 0.5425901895505578}\n" + ] + } + ], + "source": [ + "print(data)\n", + "print(f\"cross section: y[:3] = {data.y[:3].round(4)} b/sr\")\n", + "print(f\"ratio: y[:3] = {ratio.y[:3].round(3)} (dimensionless)\")\n", + "print(\"meta:\", {key: v for key, v in data.meta.items() if key != \"reaction\"})" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "c897b34a", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(1, 2, figsize=(10.0, 3.8))\n", + "for ax, d, ylabel in (\n", + " (axes[0], data, r\"$d\\sigma/d\\Omega$ [b/sr]\"),\n", + " (\n", + " axes[1],\n", + " ratio,\n", + " r\"$\\left(\\frac{d\\sigma}{d\\Omega}\\right) / \\left(\\frac{d\\sigma}{d\\Omega}\\right)_{\\mathrm{Rutherford}}$ [dimensionless]\",\n", + " ),\n", + "):\n", + " ax.errorbar(\n", + " np.rad2deg(d.x),\n", + " d.y,\n", + " d.y_err,\n", + " fmt=\"o\",\n", + " ms=3,\n", + " color=\"k\",\n", + " label=f\"EXFOR {measurement['subentry']}\",\n", + " )\n", + " ax.set(xlabel=r\"$\\theta_{cm}$ [deg]\", ylabel=ylabel, yscale=\"log\")\n", + "axes[0].set_title(r\"$p + {}^{40}$Ca elastic at 35.8 MeV\")\n", + "axes[1].set_title(\"the same, as a ratio to Rutherford\")\n", + "axes[0].legend()\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "bf89a76a", + "metadata": {}, + "source": [ + "## The potential\n", + "\n", + "We use a [Woods–Saxon](https://en.wikipedia.org/wiki/Woods%E2%80%93Saxon_potential) potential with volume and surface absorption, a fixed spin-orbit term, and, because the proton is charged, a Coulomb term from a uniformly charged sphere. `ElasticXS` is a `Model` whose `bind` compiles a [jitr](https://github.com/beykyle/jitr) solver for the dataset's kinematics, which it reads from `meta` (recipe 15).\n", + "\n", + "The model's quantity and the dataset's have to agree. If we tried to compare a cross section with a ratio-to-Rutherford model, the `Comparison` would refuse at construction, rather than letting us discover the mismatch after a fit.\n", + "\n", + "Two simplifications are worth saying out loud. The imaginary volume term shares the real volume term's radius and diffuseness, and the radii are absolute, in fm (for example $R_v \\approx 1.18\\,A^{1/3} \\approx 4.0$ fm), rather than reduced radii $r_0$. The spin-orbit term is held fixed, since we have no analysing powers to constrain it. The priors are centred near the [Koning–Delaroche](https://doi.org/10.1016/S0375-9474(02)01321-0) global potential at this energy (for example $V_v \\approx 45$ MeV, $a_v \\approx 0.67$ fm, $W_d \\approx 6$ MeV), with widths of tens of per cent, wide enough for a local fit to move." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "22704ba5", + "metadata": {}, + "outputs": [], + "source": [ + "A13 = 40 ** (1 / 3)\n", + "mso = 1.0 / jitr.utils.constants.WAVENUMBER_PION\n", + "\n", + "\n", + "def central(r, Vv, Wv, Rv, av, Wd, Rd, ad):\n", + " return -(Vv + 1j * Wv) * woods_saxon_safe(r, Rv, av) - 1j * Wd * (\n", + " -4 * ad\n", + " ) * woods_saxon_prime_safe(r, Rd, ad)\n", + "\n", + "\n", + "def spin_orbit(r, Vso, Rso, aso):\n", + " return Vso * mso**2 * thomas_safe(r, Rso, aso)\n", + "\n", + "\n", + "def coulomb(r):\n", + " return coulomb_charged_sphere(\n", + " r, reaction.target.Z * reaction.projectile.Z, 1.3 * A13\n", + " )\n", + "\n", + "\n", + "so_args = (5.5, 1.0 * A13, 0.6) # held fixed, no Ay" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "ad1d1cda", + "metadata": {}, + "outputs": [], + "source": [ + "names = [\"Vv\", \"Wv\", \"Rv\", \"av\", \"Wd\", \"Rd\", \"ad\"]\n", + "latex = [\"V_v\", \"W_v\", \"R_v\", \"a_v\", \"W_d\", \"R_d\", \"a_d\"]\n", + "start = np.array([45.0, 3.0, 1.18 * A13, 0.68, 6.0, 1.28 * A13, 0.55])\n", + "prior_sd = np.array([8.0, 3.0, 0.25, 0.15, 5.0, 0.25, 0.15])\n", + "lower = np.array([0.0, 0.0, 1.0, 0.2, 0.0, 1.0, 0.2])\n", + "params = [\n", + " rx.Parameter(n, prior=stats.norm(mu, sd), bounds=(lo, np.inf), latex=lt)\n", + " for n, mu, sd, lo, lt in zip(names, start, prior_sd, lower, latex)\n", + "]\n", + "omp = rx.reactions.ElasticXS(\n", + " \"dXS/dA\",\n", + " central,\n", + " spin_orbit,\n", + " lambda ws, *x: (tuple(x), so_args),\n", + " params,\n", + " coulomb=coulomb,\n", + " lmax=30,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "87699850", + "metadata": {}, + "source": [ + "### A sanity check: the global potential\n", + "\n", + "Before fitting anything, we check the data against an independent prediction: the Koning–Delaroche global potential (KD03), which `jitr` provides. KD03 was fitted to a large body of nucleon scattering data, so on a careful measurement of a well-studied nucleus it should get the diffraction pattern right and the magnitudes to within tens of per cent. If it missed by factors, we would suspect the data, or our setup, before trusting any calibration." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "d7747957", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "KD03 against the data: chi2/N 96, rms log residual 0.39 (a typical miss of 48%)\n" + ] + } + ], + "source": [ + "cp, sp, cou = kduq.Global((1, 1)).get_params(40, 20, measurement[\"Einc\"])\n", + "kd03 = rx.reactions.ElasticXS(\n", + " \"dXS/dA\",\n", + " kduq.central,\n", + " kduq.spin_orbit,\n", + " lambda ws: (cp, sp, cou),\n", + " [],\n", + " coulomb=coulomb_charged_sphere,\n", + " lmax=30,\n", + ")\n", + "y_kd = np.asarray(kd03.bind(data.x, data.meta)())\n", + "log_miss = np.log(data.y / y_kd)\n", + "print(\n", + " f\"KD03 against the data: chi2/N {np.mean(((data.y - y_kd) / data.y_err) ** 2):.0f}, \"\n", + " f\"rms log residual {np.sqrt(np.mean(log_miss**2)):.2f} \"\n", + " f\"(a typical miss of {np.exp(np.sqrt(np.mean(log_miss**2))) - 1:.0%})\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "feece892", + "metadata": {}, + "source": [ + "KD03 passes the check: its root-mean-square log residual is 0.39, a typical miss of about 48 %, with no factor-of-several departures, which is what a global potential usually manages on one dataset. It is also a reminder of the scale of the problem: even a carefully fitted global potential is nowhere near the 2 to 5 % statistical errors." + ] + }, + { + "cell_type": "markdown", + "id": "8fec4194", + "metadata": {}, + "source": [ + "## Two statistical models for the same potential\n", + "\n", + "### 1. Log space, with an inferred error model\n", + "\n", + "The cross section spans four decades, and the disagreement between a local potential and real data is naturally *relative*: a fraction of the cross section, whatever its size. So the first model compares in log space (recipe 10), with residuals $r_i = \\log y_i - \\log y_m(\\theta_i)$.\n", + "\n", + "On top of the reported statistical errors we add two inferred error terms, after the `jitr` [$\\alpha$ + Ca calibration](https://github.com/beykyle/jitr/blob/main/examples/notebooks/alpha_ca_calibration.ipynb). Think of each measured point as the prediction multiplied by two independent [log-normal](https://en.wikipedia.org/wiki/Log-normal_distribution) factors, $y_i = y_{m,i}\\,F_i\\,G$, with $\\log F_i \\sim \\mathcal{N}(0, \\sigma_A^2)$ and $\\log G \\sim \\mathcal{N}(0, \\sigma_B^2)$:\n", + "\n", + "- $F_i$ is a **relative error uncorrelated from point to point**, one for each angle;\n", + "- $G$ is a **relative error common to all points**, like an uncertain normalisation, or more generally a coherent misfit of the model.\n", + "\n", + "Both factors have [median](https://en.wikipedia.org/wiki/Median) one, so $y_m$ is the median of what a measurement would read: a potential is as likely to be a factor $e^{\\sigma}$ too high as too low, which is the symmetry that makes log space the natural place to compare. (A mean of one would instead put the truth's median below the model, $E[y/y_m] = e^{(\\sigma_A^2+\\sigma_B^2)/2}$ being the price of median one.) In log space the covariance is then\n", + "\n", + "$$\\Sigma^{\\log}_{ij} = \\sigma_{\\mathrm{stat},i}^2\\,\\delta_{ij} + \\sigma_A^2\\,\\delta_{ij} + \\sigma_B^2,$$\n", + "\n", + "where the first term is the reported statistical error $\\sigma_i$ carried into log space, $\\sigma_{\\mathrm{stat},i} = \\sigma_i / y_i$. That is exactly two library terms: `rx.terms.noise` for the diagonal $\\sigma_A^2$ and `rx.terms.offset` for the constant $\\sigma_B^2$. Both $\\sigma_A$ and $\\sigma_B$ are log-space standard deviations, so a value $\\sigma$ means a factor $e^{\\pm\\sigma}$ at one standard deviation, about $\\pm\\sigma$ relative when it is small; we give each a log-uniform prior between 0.05 and 2.\n", + "\n", + "(Counting errors are unbiased in linear space rather than in log space; carried exactly into log space they would shift each point by $-\\sigma_{\\mathrm{stat},i}^2/2$, which at these 2 to 5.5 % errors is at most 0.15 %, so we ignore it.)\n", + "\n", + "### 2. Linear space, with the reported errors alone\n", + "\n", + "The second model is the simplest thing we could do: compare the cross sections directly, with the reported statistical errors as the whole covariance. It tells the sampler that every disagreement between potential and data is a statistical fluctuation." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "21d928bd", + "metadata": {}, + "outputs": [], + "source": [ + "def log_uniform(lo, hi):\n", + " return stats.uniform(np.log(lo), np.log(hi) - np.log(lo))\n", + "\n", + "\n", + "log_sigma_A = rx.Parameter(\n", + " \"log_sigma_A\", prior=log_uniform(0.05, 2.0), latex=r\"\\log\\sigma_A\"\n", + ")\n", + "log_sigma_B = rx.Parameter(\n", + " \"log_sigma_B\", prior=log_uniform(0.05, 2.0), latex=r\"\\log\\sigma_B\"\n", + ")\n", + "point_to_point = rx.terms.noise(log_sigma_A) # sigma_A^2 on the diagonal\n", + "common = rx.terms.offset(log_sigma_B) # sigma_B^2 on every entry" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "86942c24", + "metadata": {}, + "outputs": [], + "source": [ + "comp_log = rx.Comparison(data, omp, space=tf.log)\n", + "comp_lin = rx.Comparison(data, omp)\n", + "problems = {\n", + " \"log space, inferred errors\": rx.Problem(\n", + " [rx.Constraint([comp_log], terms=[point_to_point, common])]\n", + " ),\n", + " \"linear, reported errors\": rx.Problem([rx.Constraint([comp_lin])]),\n", + "}\n", + "# pocomc's resolution for each posterior: eight times its default for the two\n", + "# islands of the log-space one, the benchmark's setting on this problem (below it\n", + "# pocomc weighs them differently from seed to seed), twice it for the linear one,\n", + "# which loses the evidence comparison by hundreds (docs/benchmarks.md)\n", + "settings = {\n", + " \"log space, inferred errors\": dict(n_effective=budget(4096), n_active=budget(2048)),\n", + " \"linear, reported errors\": dict(n_effective=budget(1024), n_active=budget(512)),\n", + "}\n", + "colours = {\n", + " \"log space, inferred errors\": plotstyle.COLOURS[0],\n", + " \"linear, reported errors\": plotstyle.COLOURS[1],\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "f2d363c0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "log space, inferred errors 9 columns: ['Vv', 'Wv', 'Rv', 'av', 'Wd', 'Rd', 'ad', 'log_sigma_A', 'log_sigma_B']\n", + "linear, reported errors 7 columns: ['Vv', 'Wv', 'Rv', 'av', 'Wd', 'Rd', 'ad']\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "chi2 per point at the starting potential, reported errors: 86.8\n" + ] + } + ], + "source": [ + "for name, p in problems.items():\n", + " print(f\"{name:28s} {p.ndim} columns: {p.names}\")\n", + "chi2_start = problems[\"linear, reported errors\"].chi2(start) / data.n\n", + "print(f\"\\nchi2 per point at the starting potential, reported errors: {chi2_start:.1f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "35ad8e12", + "metadata": {}, + "source": [ + "## Calibrating with preconditioned Monte Carlo (recipe 16)\n", + "\n", + "Optical-model posteriors are correlated and can be multimodal, and an affine-invariant ensemble sampler mixes poorly on them. [preconditioned Monte Carlo](https://pocomc.readthedocs.io/en/latest/background.html), here through [pocomc](https://pocomc.readthedocs.io/) ([Karamanis et al. 2022](https://doi.org/10.1093/mnras/stac2272)), copes much better: it moves a population of particles from the prior to the posterior through a sequence of tempered distributions, learning a [normalizing flow](https://en.wikipedia.org/wiki/Flow-based_generative_model) that undoes the correlations as it goes, and it returns the evidence as a by-product. On `omp`, the benchmark's copy of this problem, it is the only sampler that the reference does not show wrong, at eight times its default resolution (and even then it is wrong on one seed of three, so run it more than once); below that, how it weighs the posterior's two islands changes from run to run ([benchmarks](/benchmarks.md)).\n", + "\n", + "The linear model's posterior has a single narrow mode, and we run it at twice pocomc's default resolution, at which the benchmark's single-mode `elastic` problem is correct; its moments matter little here, since its evidence is 726 below the log-space model's.\n", + "\n", + "pocomc samples a prior of its own, so we give it the unit cube and the likelihood of `prior_transform(u)`. The transform maps the cube through every parameter's truncated prior, and the problem assembles it for us; the evidence is then the problem's own." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "cb9e602b", + "metadata": {}, + "outputs": [], + "source": [ + "def smc(problem, seed, n_effective, n_active):\n", + " \"\"\"pocomc on the unit cube: ``prior_transform`` maps it onto the prior, so\n", + " the evidence is the problem's own.\"\"\"\n", + "\n", + " t0 = time.perf_counter()\n", + "\n", + " def log_likelihood(u): # every particle in one vmapped call\n", + " return problem.log_likelihood_batch(problem.prior_transform_batch(u))\n", + "\n", + " sampler = pocomc.Sampler(\n", + " pocomc.Prior([stats.uniform(0.0, 1.0)] * problem.ndim),\n", + " log_likelihood,\n", + " n_effective=n_effective,\n", + " n_active=n_active,\n", + " vectorize=True,\n", + " random_state=seed,\n", + " )\n", + " sampler.run(n_total=budget(4096), n_evidence=budget(4096), progress=False)\n", + " u, _, _ = sampler.posterior(resample=True) # equal-weight draws\n", + " logz, logz_err = sampler.evidence()\n", + " return {\n", + " \"samples\": problem.prior_transform_batch(u),\n", + " \"logz\": logz,\n", + " \"logz_err\": logz_err,\n", + " \"calls\": sampler.calls,\n", + " \"wall_s\": time.perf_counter() - t0,\n", + " }\n", + "\n", + "\n", + "n_seeds = 1 # runs per model; runtime scales with it; raise it to see the spread\n", + "runs, samples = {}, {}\n", + "for i, (name, p) in enumerate(problems.items()):\n", + " runs[name] = [smc(p, 1 + i + 10 * k, **settings[name]) for k in range(n_seeds)]\n", + " # the runs pooled: each is an equal-weight sample\n", + " samples[name] = np.vstack([r[\"samples\"] for r in runs[name]])" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "103e4e7f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "log space, inferred errors run 1: log Z = -6.71 +/- 0.02, 342016 calls, 915 s\n", + "linear, reported errors run 1: log Z = -526.69 +/- 0.01, 101888 calls, 375 s\n" + ] + } + ], + "source": [ + "for name, rs in runs.items():\n", + " for k, r in enumerate(rs):\n", + " print(\n", + " f\"{name:28s} run {k + 1}: log Z = {r['logz']:9.2f} +/- {r['logz_err']:.2f}, \"\n", + " f\"{r['calls']:7d} calls, {r['wall_s']:.0f} s\"\n", + " )" + ] + }, + { + "cell_type": "markdown", + "id": "706a6b87", + "metadata": {}, + "source": [ + "## (A) The evidence\n", + "\n", + "The [evidence](https://en.wikipedia.org/wiki/Marginal_likelihood) is the probability each statistical model assigned to the measured data, averaged over its prior, and the ratio of two evidences is the [Bayes factor](https://en.wikipedia.org/wiki/Bayes_factor) between them. There's one subtlety here. The raw $\\log Z$ from the log-space fit is a density for $\\log y$, while the linear fit's is a density for $y$ itself. Adding `problem.log_jacobian()` converts the first into a density for $y$, the [change of variables](https://en.wikipedia.org/wiki/Probability_density_function#Function_of_random_variables_and_change_of_variables_in_the_probability_density_function) $\\sum_i \\log |\\mathrm{d}\\log y_i / \\mathrm{d}y_i|$, and only then are the two comparable (recipe 18)." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "b469b3ef", + "metadata": {}, + "outputs": [], + "source": [ + "logz = {\n", + " name: rx.diagnostics.logz_summary(\n", + " [r[\"logz\"] + problems[name].log_jacobian() for r in runs[name]],\n", + " [r[\"logz_err\"] for r in runs[name]],\n", + " )\n", + " for name in problems\n", + "}\n", + "verdict = rx.diagnostics.compare_logz(\n", + " logz[\"log space, inferred errors\"], logz[\"linear, reported errors\"]\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "0d591420", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "log space, inferred errors log Z = 198.9 (density of the cross sections)\n", + "linear, reported errors log Z = -526.7 (density of the cross sections)\n", + "\n", + "dlogZ = 726 -> log space favoured (a quoted error from few runs is a lower bound, irrelevant at this size)\n" + ] + } + ], + "source": [ + "for name, (mean, err, _) in logz.items():\n", + " print(f\"{name:28s} log Z = {mean:9.1f} (density of the cross sections)\")\n", + "words = {\"a\": \"log space favoured\", \"b\": \"linear favoured\", \"tie\": \"a tie\"}\n", + "print(\n", + " f\"\\ndlogZ = {verdict['dlogZ']:.0f} -> {words[verdict['verdict']]}\"\n", + " \" (a quoted error from few runs is a lower bound, irrelevant at this size)\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "5c4d8ab7", + "metadata": {}, + "source": [ + "The evidence isn't close. The log-space model scores $\\log Z = 198.9$ as a density for the cross sections, and the linear model with only the reported errors scores $-526.7$, a difference of about 730. Before we look at a single prediction, the data are telling us that the claim \"every disagreement is a statistical fluctuation of a few per cent\" is untenable. The starting potential already hinted at this: its $\\chi^2$ per point against the reported errors is 87." + ] + }, + { + "cell_type": "markdown", + "id": "638d57f9", + "metadata": {}, + "source": [ + "### The two posteriors\n", + "\n", + "Before we look at predictions, let's see what each model believes about the potential, and what the first one inferred for $\\sigma_A$ and $\\sigma_B$." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "d88e6ea9", + "metadata": {}, + "outputs": [], + "source": [ + "# chi2 per point against the reported errors alone, at each posterior median:\n", + "# how far each fitted potential sits from the data in units of the reported errors\n", + "p_reported = problems[\"linear, reported errors\"]\n", + "summary = {}\n", + "for name, p in problems.items():\n", + " s = samples[name]\n", + " theta = np.median(s[:, p.columns(params)], axis=0)\n", + " summary[name] = {\n", + " \"chi2/N (reported errors)\": p_reported.chi2(theta) / data.n,\n", + " \"Vv\": np.percentile(s[:, p.columns(params[0])], [16, 50, 84]),\n", + " }\n", + "p_log, s_log = (\n", + " problems[\"log space, inferred errors\"],\n", + " samples[\"log space, inferred errors\"],\n", + ")\n", + "sigma_A_draws = np.exp(s_log[:, p_log.columns(log_sigma_A)]).ravel()\n", + "sigma_B_draws = np.exp(s_log[:, p_log.columns(log_sigma_B)]).ravel()" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "536e4eff", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "log space, inferred errors Vv = 45.8 [ 43.1, 48.1] MeV chi2/N at the median, reported errors only = 36.9\n", + "linear, reported errors Vv = 45.4 [ 45.1, 45.6] MeV chi2/N at the median, reported errors only = 35.2\n", + "inferred sigma_A = 0.197, 68 % interval [0.176, 0.222]\n", + "inferred sigma_B = 0.130, 68 % interval [0.068, 0.394]\n" + ] + } + ], + "source": [ + "for name, row in summary.items():\n", + " lo, mid, hi = row[\"Vv\"]\n", + " print(\n", + " f\"{name:28s} Vv = {mid:5.1f} [{lo:5.1f}, {hi:5.1f}] MeV \"\n", + " f\"chi2/N at the median, reported errors only = {row['chi2/N (reported errors)']:6.1f}\"\n", + " )\n", + "for label, draws in ((\"sigma_A\", sigma_A_draws), (\"sigma_B\", sigma_B_draws)):\n", + " lo, mid, hi = np.percentile(draws, [16, 50, 84])\n", + " print(f\"inferred {label} = {mid:.3f}, 68 % interval [{lo:.3f}, {hi:.3f}]\")" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "ccdbbd11", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig = None\n", + "for name, p in problems.items():\n", + " fig = corner.corner(\n", + " samples[name][:, p.columns(params)],\n", + " fig=fig,\n", + " labels=[f\"${lt}$\" for lt in latex],\n", + " **plotstyle.corner_kwargs(\n", + " color=colours[name],\n", + " fill_contours=False,\n", + " plot_density=False,\n", + " show_titles=False,\n", + " levels=(0.68, 0.95),\n", + " ),\n", + " )\n", + "fig.legend(\n", + " handles=[plt.Line2D([], [], color=c, label=n) for n, c in colours.items()],\n", + " loc=\"upper right\",\n", + " fontsize=10,\n", + ")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "0f16759a", + "metadata": {}, + "source": [ + "The two posteriors tell very different stories about the same potential. Taking the reported errors at their word, the linear fit pins $V_v$ to 45.4 MeV, with a 68 % interval only 0.5 MeV wide, and its potential at the posterior median still sits $\\chi^2/N = 35$ away from the data. It's precise, but the precision is meaningless, because it comes from pretending the misfit is noise.\n", + "\n", + "The log-space fit is far wider, $V_v = 45.8$ [43.1, 48.1] MeV (68 %, as every interval here), and it is not one blob: a second island, carrying less of the probability, shows in several pairs of parameters, most clearly $R_d$ against $a_d$ and $W_d$. It gets its width by inferring a point-to-point error of $\\sigma_A = 0.197$ [0.176, 0.222] in log space, a factor of about 1.22 either way: that is how well this seven-parameter potential describes the measurement angle by angle. The common error is barely constrained, $\\sigma_B = 0.13$ [0.07, 0.39], reaching down towards its prior's lower end. That makes sense. A single measurement can't tell a coherent shift of all its points apart from the potential itself moving, so the posterior for $\\sigma_B$ mostly reflects its prior.\n", + "\n", + "In the corner plot the linear posterior is a tight speck inside the heavier log-space island, the narrow one around the posterior's highest point." + ] + }, + { + "cell_type": "markdown", + "id": "2229eb51", + "metadata": {}, + "source": [ + "### How much of the posterior is in each island?\n", + "\n", + "The corner plot shows the log-space posterior in two islands, and the question a sampler has to get right is how the probability splits between them. We count the draws in the island away from the highest point, which the corner plot separates most cleanly in $R_d$ and $a_d$.\n", + "\n", + "Why not check pocomc against a gradient sampler here? The benchmark did, on this same problem, and it is instructive. [NUTS](https://arxiv.org/abs/1111.4246) and HMC, from blackjax and from PyMC, started about the posterior's highest point (`rx.optimize.find_map`) as is usual, stay in that island: blackjax's HMC and PyMC's NUTS and HMC are 0.30 to 0.32 posterior standard deviations off in their means and 0.68 to 0.79 in their widths, while their rank-normalised split $\\hat R$ is 1.005 to 1.007, comfortably converged by the usual rule. Chains that never visit an island agree with one another about it. Only blackjax's NUTS, whose two chains disagree, has an $\\hat R$ that flags trouble (1.69). So a gradient sampler checks pocomc only if its chains are started in both islands, and even then it cannot weigh them; `gradient_based_sampling` shows NUTS where it does work." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "7c712a5e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "run 1: fraction of draws in the island away from the mode (R_d < 4.37 fm, a_d > 0.34 fm): 0.15\n" + ] + } + ], + "source": [ + "cols = {n: p_log.columns(q).item() for n, q in zip(names, params)}\n", + "for k, r in enumerate(runs[\"log space, inferred errors\"]):\n", + " s = r[\"samples\"]\n", + " away = (s[:, cols[\"Rd\"]] < 4.37) & (s[:, cols[\"ad\"]] > 0.34)\n", + " print(\n", + " f\"run {k + 1}: fraction of draws in the island away from the mode \"\n", + " f\"(R_d < 4.37 fm, a_d > 0.34 fm): {np.mean(away):.2f}\"\n", + " )" + ] + }, + { + "cell_type": "markdown", + "id": "065e2234", + "metadata": {}, + "source": [ + "15 % of the draws are in the island away from the mode, so the island with the highest point also carries most of the probability, as in the [benchmark](/benchmarks.md)'s runs of this problem: its reference puts 13 % away, and its pocomc runs at this resolution 14 to 16 %. This needed the resolution we gave it: at a quarter of it, the benchmark found pocomc putting anywhere from 23 to 85 % of its draws away from the mode, depending on the seed. One run's split, and its quoted $\\log Z$ error, are only as good as that: the quoted error comes from within a single run and is often an underestimate, since the spread between seeds can exceed it. Raising `n_seeds` above runs the model more than once, pools the runs and lets `logz_summary` take their spread into account; the runtime grows in proportion." + ] + }, + { + "cell_type": "markdown", + "id": "5df6b5e2", + "metadata": {}, + "source": [ + "## (B) The posterior predictive\n", + "\n", + "There are two predictive distributions we care about, and it's worth being precise about them:\n", + "\n", + "- **The model only**: the potential, $y_m(\\theta;\\alpha)$ with $\\alpha$ drawn from the posterior. This is our uncertainty about the cross section the potential predicts, and it's what we'd hand to a transport code.\n", + "- **The full predictive**: the potential plus every error term, the reported statistical errors and, for the first model, the inferred $\\sigma_A$ and $\\sigma_B$. This is our uncertainty about what a *measurement* would read, and it's the one that belongs next to the data.\n", + "\n", + "The model only has a value at any angle, so we draw it on a fine grid with `rx.predictive.grid_draws`. The full predictive is different. The reported statistical errors are one number per *measured* angle, and at an angle nobody measured there's simply no statistical error to draw, so `grid_draws` refuses them (recipe 40, and the forecasting discussion in `linear_calibration`). We therefore draw the full predictive at the 47 measured angles with `rx.diagnostics.predictive_draws`, and show each interval as a vertical bar at its angle. The inferred terms, on the other hand, *are* functions of angle, so for the first model we can also show the potential plus $\\sigma_A$ and $\\sigma_B$ on the fine grid.\n", + "\n", + "`physical=True`, on both `grid_draws` and `predictive_draws`, returns the log-space draws as cross sections, so every band is in the units of the data." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "2012d2ec", + "metadata": {}, + "outputs": [], + "source": [ + "x_fine = np.deg2rad(np.linspace(3.0, 175.0, 140))\n", + "on_fine = omp.bind(x_fine, data.meta)\n", + "fine, at_data = {}, {}\n", + "for name, p in problems.items():\n", + " rows = samples[name][::10]\n", + " c = p.constraints[0]\n", + " inferred = list(c.source.terms) # functions of the angle, so they live on any grid\n", + " fine[name] = {\n", + " \"model only\": rx.predictive.grid_draws(\n", + " p, on_fine, x_fine, rows, model_only=True, physical=True, levels=(16, 84)\n", + " )\n", + " }\n", + " if inferred:\n", + " fine[name][\"+ inferred terms\"] = rx.predictive.grid_draws(\n", + " p,\n", + " on_fine,\n", + " x_fine,\n", + " rows,\n", + " terms=inferred,\n", + " n_rep=5,\n", + " physical=True,\n", + " levels=(16, 84),\n", + " rng=4,\n", + " )\n", + " at_data[name] = rx.diagnostics.predictive_draws(\n", + " p, rows, n_rep=5, rng=4, physical=True, levels=(16, 84)\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "26893f77", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(1, 2, figsize=(10.5, 4.2), sharey=True)\n", + "for ax, name in zip(axes, problems):\n", + " colour = colours[name]\n", + " if \"+ inferred terms\" in fine[name]:\n", + " lo, hi = fine[name][\"+ inferred terms\"]\n", + " plotstyle.band(\n", + " ax,\n", + " np.rad2deg(x_fine),\n", + " lo,\n", + " hi,\n", + " color=colour,\n", + " label=r\"+ $\\sigma_A$, $\\sigma_B$ (grid)\",\n", + " )\n", + " lo, hi = fine[name][\"model only\"]\n", + " plotstyle.band(\n", + " ax,\n", + " np.rad2deg(x_fine),\n", + " lo,\n", + " hi,\n", + " color=\"k\",\n", + " hatch=plotstyle.HATCHES[0],\n", + " label=\"model only (grid)\",\n", + " )\n", + " ax.vlines(\n", + " np.rad2deg(data.x),\n", + " *at_data[name],\n", + " color=colour,\n", + " lw=2.2,\n", + " alpha=0.8,\n", + " label=\"full predictive (measured angles)\",\n", + " )\n", + " ax.plot(np.rad2deg(data.x), data.y, \"o\", ms=2.5, color=\"k\", label=\"data\")\n", + " ax.set(xlabel=r\"$\\theta_{cm}$ [deg]\", yscale=\"log\", title=f\"{name}: 68 % intervals\")\n", + "axes[0].set_ylabel(r\"$d\\sigma/d\\Omega$ [b/sr]\")\n", + "for ax in axes:\n", + " ax.legend(fontsize=8, loc=\"lower left\")\n", + "fig.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "c2130314", + "metadata": {}, + "source": [ + "On the left, the model only (the hatched grey band) is already wide, because the fit is honest about how well it knows the potential, across both of its modes. Adding $\\sigma_A$ and $\\sigma_B$ on the fine grid widens it further, and the vertical bars show each measured angle's 68 % interval of the full predictive, which is where we compare with the data. On the right, the reported-errors fit gives a razor-thin potential and intervals barely larger than the points themselves, and many of the data sit visibly outside them." + ] + }, + { + "cell_type": "markdown", + "id": "8c2c671f", + "metadata": {}, + "source": [ + "## (C) Empirical coverage\n", + "\n", + "A predictive distribution is calibrated if its central 68 % interval contains about 68 % of the measured points, and likewise at every level, so its empirical [coverage](https://en.wikipedia.org/wiki/Coverage_probability) follows the diagonal (recipe 17). We check these predictives for each model, all at the measured angles:\n", + "\n", + "- **model only** (`model_only=True`);\n", + "- **+ statistical**: the reported statistical errors (`terms=[]`, which keeps `statistical=True` and drops every inferred term);\n", + "- **+ point-to-point**, for the log-space model: the statistical errors and $\\sigma_A$ alone (`terms=[point_to_point]`), to see what the common term adds;\n", + "- **full predictive**: every error term (the default), the same predictive as in (B), checked point by point.\n", + "\n", + "For the linear model \"+ statistical\" and the full predictive are the same thing, because the reported errors are its only term, so its two curves lie on top of each other.\n", + "\n", + "Two cautions. These are the points we fitted, so this is an in-sample check, mildly optimistic with nine parameters and 47 points; holding data out is recipe 11. And with 47 points, a coverage fraction near 0.68 is uncertain by about $\\pm 0.07$, one binomial standard deviation, the grey band in the figure." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "4893d5ad", + "metadata": {}, + "outputs": [], + "source": [ + "levels = np.linspace(0.05, 0.95, 19)\n", + "kinds = {\n", + " \"model only\": dict(model_only=True),\n", + " \"+ statistical\": dict(terms=[]),\n", + " \"+ point-to-point\": dict(terms=[point_to_point]),\n", + " \"full predictive\": {},\n", + "}\n", + "coverage, cov68 = {}, {}\n", + "for i, (name, p) in enumerate(problems.items()):\n", + " c = p.constraints[0]\n", + " rows = samples[name][::10]\n", + " y_obs = c.y[c.active]\n", + " coverage[name], cov68[name] = {}, {}\n", + " for kind, kw in kinds.items():\n", + " if kind == \"+ point-to-point\" and not list(c.source.terms):\n", + " continue # the linear model has no inferred terms\n", + " extra = {} if kw.get(\"model_only\") else dict(n_rep=5, rng=10 + i)\n", + " draws = rx.diagnostics.predictive_draws(\n", + " p, rows, return_draws=True, **kw, **extra\n", + " )\n", + " coverage[name][kind] = rx.diagnostics.coverage_curve(draws, y_obs, levels)\n", + " cov68[name][kind] = rx.diagnostics.coverage_curve(draws, y_obs, [0.68])[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "f01ec16a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "log space, inferred errors: coverage at a nominal 68 %\n", + " model only 0.70\n", + " + statistical 0.70\n", + " + point-to-point 0.85\n", + " full predictive 0.89\n", + "linear, reported errors: coverage at a nominal 68 %\n", + " model only 0.06\n", + " + statistical 0.26\n", + " full predictive 0.26\n" + ] + } + ], + "source": [ + "for name, row in cov68.items():\n", + " print(f\"{name}: coverage at a nominal 68 %\")\n", + " for kind, value in row.items():\n", + " print(f\" {kind:18s} {value:.2f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "85fd7f5a", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "styles = {\n", + " \"model only\": (\"s:\", 0.6),\n", + " \"+ statistical\": (\"^--\", 0.8),\n", + " \"+ point-to-point\": (\"d-.\", 0.8),\n", + " \"full predictive\": (\"o-\", 1.0),\n", + "}\n", + "fig, axes = plt.subplots(1, 2, figsize=(9.0, 4.4), sharey=True)\n", + "for ax, name in zip(axes, problems):\n", + " ax.plot([0, 1], [0, 1], \"--\", color=\"0.5\", label=\"nominal\")\n", + " binomial = np.sqrt(levels * (1 - levels) / data.n)\n", + " ax.fill_between(\n", + " levels,\n", + " levels - binomial,\n", + " levels + binomial,\n", + " color=\"0.88\",\n", + " label=r\"$\\pm 1$ binomial sd\",\n", + " )\n", + " for kind, (marker, alpha) in styles.items():\n", + " if kind not in coverage[name]:\n", + " continue\n", + " ax.plot(\n", + " levels,\n", + " coverage[name][kind],\n", + " marker,\n", + " ms=4,\n", + " color=colours[name],\n", + " alpha=alpha,\n", + " label=kind,\n", + " )\n", + " ax.set(\n", + " xlabel=\"nominal coverage\",\n", + " xlim=(0, 1),\n", + " ylim=(0, 1),\n", + " title=name,\n", + " )\n", + "axes[0].set_ylabel(\"empirical coverage\")\n", + "axes[0].legend(fontsize=8, loc=\"upper left\")\n", + "fig.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "9ff14350", + "metadata": {}, + "source": [ + "For the linear model, even the full predictive covers only 26 % of the points at a nominal 68 %. The reported errors aren't a sufficient description of the disagreement.\n", + "\n", + "For the log-space model, the model only already covers 0.70 of the points, on the diagonal: the potential's posterior is wide enough that its spread alone accounts for the misfit, and adding the 2 to 5 % statistical errors leaves it there (0.70). Adding the point-to-point error then over-covers (0.85), and the full predictive more (0.89), about three binomial standard deviations above 0.68. So $\\sigma_A$ and $\\sigma_B$, which the fit needed to reach its posterior, make the predictive of a new measurement too generous here, mostly through $\\sigma_A$. A correlated discrepancy in place of the independent $\\sigma_A$ (`gp_discrepancy`) would be the next thing to try." + ] + }, + { + "cell_type": "markdown", + "id": "4c1788a7", + "metadata": {}, + "source": [ + "## The guardrail: a covariance that can't be factored (recipe 21)\n", + "\n", + "Sometimes a subentry reports no statistical error at all. Then the covariance of those points is singular, and there's nothing sensible to do with it. The library says so when the problem is built, naming the dataset, rather than failing somewhere inside the sampler an hour later." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "57c5d001", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "the constraint's covariance is singular on its active points; the diagonal is zero on rows of ['a subentry with no errors']: those comparisons have zero statistical error and no diagonal term covers their points (a block covered only by correlated modes is singular here even when the full covariance is not). Remedies: comparison.reported_terms(), a noise term, a fixed Term covering those points, or statistical=False with an explicit covariance.\n" + ] + } + ], + "source": [ + "no_errors = rx.Dataset(\n", + " data.x[:6],\n", + " data.y[:6],\n", + " np.zeros(6),\n", + " label=\"a subentry with no errors\",\n", + " meta=data.meta,\n", + ")\n", + "try:\n", + " rx.Problem([rx.Constraint([rx.Comparison(no_errors, omp)])])\n", + "except ValueError as err:\n", + " print(err)" + ] + }, + { + "cell_type": "markdown", + "id": "f2e2cc8f", + "metadata": {}, + "source": [ + "## Takeaways\n", + "\n", + "- `from_measurement` is the unit contract, and it takes an `exfor_tools` `Distribution` or a plain `dict`.\n", + "- Check real data against an independent prediction, such as a global potential, before calibrating. It costs one cell, and it is how a faulty dataset gets caught.\n", + "- Real data arrive with whatever the experimenters chose to report, and often that's statistics only. How the potential and the data are allowed to disagree is then *our* declaration. Declaring nothing is itself a strong claim, and here the evidence rejects it by about 730 in $\\log Z$.\n", + "- A log-space comparison with a point-to-point and a common relative error, after `jitr`, describes this measurement to a factor of about 1.22 per angle. Its full predictive is conservative here: it over-covers, because the potential's own posterior is already wide.\n", + "- Optical-model posteriors can be multimodal, and this one is. Gradient samplers started at the mode stay in its island and pass $\\hat R$ while wrong; pocomc weighs the islands, but only at enough resolution, and one run's split and evidence error are only estimates: raise `n_seeds` to see how far they move.\n", + "- Evidences from different comparison spaces are only comparable once the Jacobian is added.\n", + "- The model only and the full predictive of a measurement are different distributions, and they need different coverage checks. Only the second should follow the diagonal; here the potential's own spread already puts the first on it, and the full predictive over-covers.\n", + "- Reported per-point errors live at the measured angles. Terms written as functions of the angle, like $\\sigma_A$ and $\\sigma_B$ here, can be drawn anywhere." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/measurement_to_calibration.ipynb b/examples/measurement_to_calibration.ipynb deleted file mode 100644 index 19f4055..0000000 --- a/examples/measurement_to_calibration.ipynb +++ /dev/null @@ -1,618 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "78ffc016", - "metadata": {}, - "source": [ - "# From a measurement to a calibrated potential\n", - "\n", - "This notebook walks the **production path**: an EXFOR-shaped measurement —\n", - "reported in its own units, with statistical *and* systematic errors — is turned\n", - "into an `ElasticDifferentialXSObservation` via `from_measurement`, its reported\n", - "systematics are composed as explicit covariance terms, and a small optical\n", - "potential is calibrated against it.\n", - "\n", - "The unit contract, up front:\n", - "\n", - "- **dimensionful** errors (statistical, absolute offset) are divided by the unit\n", - " normalization `norm` when the observation is built;\n", - "- the **fractional** normalization error is dimensionless and passes through\n", - " untouched;\n", - "- `norm` itself is retained as `obs.norm` for provenance.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "9585b106", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:07:06.821526Z", - "iopub.status.busy": "2026-08-11T03:07:06.821389Z", - "iopub.status.idle": "2026-08-11T03:07:09.182945Z", - "shell.execute_reply": "2026-08-11T03:07:09.182237Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Using database version X4-2024-12-31 located in: /home/kyle/db/exfor/unpack_exfor-2024/X4-2024-12-31\n" - ] - } - ], - "source": [ - "from types import SimpleNamespace\n", - "\n", - "import corner\n", - "import jitr\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "from jitr.optical_potentials.potential_forms import (\n", - " thomas_safe,\n", - " woods_saxon_prime_safe,\n", - " woods_saxon_safe,\n", - ")\n", - "from scipy import stats\n", - "\n", - "import rxmc\n", - "from rxmc.params import Parameter\n", - "\n", - "rng = np.random.default_rng(11)" - ] - }, - { - "cell_type": "markdown", - "id": "213805bd", - "metadata": {}, - "source": [ - "## The reaction and optical model" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "63f8c4a7", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:07:09.184651Z", - "iopub.status.busy": "2026-08-11T03:07:09.184357Z", - "iopub.status.idle": "2026-08-11T03:07:09.213438Z", - "shell.execute_reply": "2026-08-11T03:07:09.212848Z" - } - }, - "outputs": [], - "source": [ - "Ca40 = (40, 20)\n", - "neutron = (1, 0)\n", - "E_lab = 14.1\n", - "\n", - "rxn = jitr.reactions.ElasticReaction(target=Ca40, projectile=neutron)\n", - "\n", - "mso = 1.0 / jitr.utils.constants.WAVENUMBER_PION\n", - "\n", - "\n", - "def central_potential(r, Vv, Wv, Rv, av, Wd, Rd, ad):\n", - " return -(Vv + 1j * Wv) * woods_saxon_safe(r, Rv, av) + (\n", - " 4j * ad * Wd\n", - " ) * woods_saxon_prime_safe(r, Rd, ad)\n", - "\n", - "\n", - "def spin_orbit_potential(r, Vso, Wso, Rso, aso):\n", - " return (Vso + 1j * Wso) * mso**2 * thomas_safe(r, Rso, aso)\n", - "\n", - "\n", - "R = 1.2 * 40 ** (1 / 3)\n", - "fixed_spin_orbit = (6.0, -3, R, 0.45)\n", - "\n", - "\n", - "def extract_params(ws, *x):\n", - " Vv, Wv, Rv, av, Wd, Rd, ad = x\n", - " central_params = (Vv, Wv, Rv, av, Wd, Rd, ad)\n", - " return central_params, fixed_spin_orbit\n", - "\n", - "\n", - "params = [\n", - " Parameter(\"Vv\", unit=\"MeV\"),\n", - " Parameter(\"Wv\", unit=\"MeV\"),\n", - " Parameter(\"Rv\", unit=\"fm\"),\n", - " Parameter(\"av\", unit=\"fm\"),\n", - " Parameter(\"Wd\", unit=\"MeV\"),\n", - " Parameter(\"Rd\", unit=\"fm\"),\n", - " Parameter(\"ad\", unit=\"fm\"),\n", - "]\n", - "\n", - "omp = rxmc.elastic_diffxs_model.ElasticDifferentialXSModel(\n", - " \"dXS/dA\",\n", - " interaction_central=central_potential,\n", - " interaction_spin_orbit=spin_orbit_potential,\n", - " calculate_interaction_from_params=extract_params,\n", - " params=params,\n", - " model_name=\"measurement_demo\",\n", - ")" - ] - }, - { - "cell_type": "markdown", - "id": "895e8324", - "metadata": {}, - "source": [ - "## A measurement, as EXFOR reports it\n", - "\n", - "EXFOR entries report cross sections in their own units — here **mb/sr** — with a\n", - "statistical error column and, often, scalar systematic errors: a *fractional*\n", - "normalization uncertainty (e.g. from the flux calibration) and an *absolute*\n", - "offset uncertainty (e.g. from background subtraction), in the same units as the\n", - "data. We mock up such a measurement (`exfor_tools.Distribution` carries exactly\n", - "these fields) from a known truth so we can check the calibration at the end.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "c7dff4fd", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:07:09.215225Z", - "iopub.status.busy": "2026-08-11T03:07:09.215072Z", - "iopub.status.idle": "2026-08-11T03:07:20.015257Z", - "shell.execute_reply": "2026-08-11T03:07:20.014738Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "angles_deg = np.linspace(5.0, 160.0, 20)\n", - "true_params = np.array(\n", - " [48.0, 3.5, 1.1 * 40 ** (1 / 3), 0.7, 21, 1.2 * 40 ** (1 / 3), 0.5]\n", - ")\n", - "\n", - "template_obs = rxmc.elastic_diffxs_observation.ElasticDifferentialXSObservation(\n", - " x=angles_deg,\n", - " y=np.ones_like(angles_deg, dtype=float),\n", - " Elab=E_lab,\n", - " reaction=rxn,\n", - " quantity=\"dXS/dA\",\n", - " measurement_quantity=\"dXS/dA\",\n", - " y_units=\"barn / steradian\",\n", - " dataset_label=\"template\",\n", - ")\n", - "\n", - "y_true_b = omp.evaluate(template_obs, *true_params) # b/sr\n", - "y_true_mb = y_true_b * 1000.0 # the measurement is reported in mb/sr\n", - "\n", - "stat_err_mb = 0.08 * np.maximum(y_true_mb, 1e-1)\n", - "y_mb = np.clip(y_true_mb + rng.normal(scale=stat_err_mb), 1e-3, None)\n", - "\n", - "measurement = SimpleNamespace(\n", - " x=angles_deg, # degrees\n", - " y=y_mb, # mb/sr\n", - " Einc=E_lab,\n", - " quantity=\"dXS/dA\",\n", - " y_units=\"mb/sr\",\n", - " statistical_err=stat_err_mb, # mb/sr\n", - " systematic_norm_err=0.04, # fractional (dimensionless)\n", - " systematic_offset_err=2.0, # absolute, mb/sr\n", - " subentry=\"toy-subentry\",\n", - ")\n", - "\n", - "plt.errorbar(\n", - " measurement.x, measurement.y, measurement.statistical_err, ls=\"none\", marker=\".\"\n", - ")\n", - "plt.xlabel(r\"$\\theta$ [deg]\")\n", - "plt.ylabel(r\"$d\\sigma/d\\Omega$ [mb/sr]\")\n", - "plt.yscale(\"log\")\n", - "plt.title(\"A mock EXFOR-style measurement of n + $^{40}$Ca\");" - ] - }, - { - "cell_type": "markdown", - "id": "ac41e21a", - "metadata": {}, - "source": [ - "## `from_measurement` keeps the systematics as inert metadata\n", - "\n", - "The observation stores its data in internal units (b/sr). Everything\n", - "**dimensionful** — `y`, the statistical error, the absolute offset error — is\n", - "divided by `obs.norm` (here $10^3$, mb $\\to$ b); the **fractional** normalization\n", - "error is dimensionless and untouched. The systematics are *metadata*: they do\n", - "not enter any covariance until you ask.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "480644cd", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:07:20.017049Z", - "iopub.status.busy": "2026-08-11T03:07:20.016896Z", - "iopub.status.idle": "2026-08-11T03:07:21.846957Z", - "shell.execute_reply": "2026-08-11T03:07:21.846224Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "unit normalization obs.norm = 1000.0\n", - "fractional norm error 0.04 (passed through)\n", - "absolute offset error 0.002 b/sr (= 2.0 mb/sr / norm)\n", - "y[0]: measurement 1834.19 mb/sr -> stored 1.83419 b/sr\n" - ] - } - ], - "source": [ - "obs = rxmc.elastic_diffxs_observation.ElasticDifferentialXSObservation.from_measurement(\n", - " measurement=measurement,\n", - " reaction=rxn,\n", - " quantity=\"dXS/dA\",\n", - ")\n", - "\n", - "print(f\"unit normalization obs.norm = {obs.norm}\")\n", - "print(f\"fractional norm error {obs.y_sys_err_normalization} (passed through)\")\n", - "print(f\"absolute offset error {obs.y_sys_err_offset} b/sr (= 2.0 mb/sr / norm)\")\n", - "print(f\"y[0]: measurement {measurement.y[0]:.2f} mb/sr -> stored {obs.y[0]:.5f} b/sr\")" - ] - }, - { - "cell_type": "markdown", - "id": "5b9b64d7", - "metadata": {}, - "source": [ - "## Nothing is folded in silently — systematics are explicit terms\n", - "\n", - "By design there is **no compatibility path that re-folds systematics into the\n", - "covariance automatically**: the default constraint covariance is the statistical\n", - "diagonal only. `obs.systematic_terms()` turns the retained metadata into\n", - "fixed rank-one terms — the absolute offset mode\n", - "$\\Sigma \\mathrel{+}= \\omega\\omega^T$ and the prediction-scaled normalization mode\n", - "$\\Sigma \\mathrel{+}= \\eta^2\\, y_m y_m^T$ — which you pass in as `extra_terms`.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "551698f3", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:07:21.848441Z", - "iopub.status.busy": "2026-08-11T03:07:21.848289Z", - "iopub.status.idle": "2026-08-11T03:07:22.186513Z", - "shell.execute_reply": "2026-08-11T03:07:22.185864Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "['Term', 'Term']\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "terms = obs.systematic_terms()\n", - "print([type(t).__name__ for t in terms])\n", - "\n", - "constraint_stat = rxmc.constraint.Constraint([obs], omp)\n", - "constraint = rxmc.constraint.Constraint([obs], omp, extra_terms=terms)\n", - "\n", - "fig, axes = plt.subplots(1, 2, figsize=(9, 4))\n", - "for a, (c, title) in zip(\n", - " axes,\n", - " [\n", - " (constraint_stat, \"statistical only (default)\"),\n", - " (constraint, \"+ reported systematics\"),\n", - " ],\n", - "):\n", - " im = a.imshow(c.covariance_matrix(true_params), cmap=\"viridis\")\n", - " a.set_title(title)\n", - " fig.colorbar(im, ax=a, fraction=0.046)\n", - "fig.tight_layout()" - ] - }, - { - "cell_type": "markdown", - "id": "293e0e6e", - "metadata": {}, - "source": [ - "## Guardrail: a measurement with no statistical error\n", - "\n", - "EXFOR subentries that report only a systematic error come back with\n", - "`statistical_err = 0`. The old pipeline would let that propagate and crash deep\n", - "inside the sampler; now the `Constraint` fails fast, names the dataset, and\n", - "suggests the remedies.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "5321385f", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:07:22.187926Z", - "iopub.status.busy": "2026-08-11T03:07:22.187773Z", - "iopub.status.idle": "2026-08-11T03:07:24.064179Z", - "shell.execute_reply": "2026-08-11T03:07:24.063596Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Constraint covariance over [toy-subentry-nostat] is singular (Cholesky factorization failed). The covariance diagonal is zero on rows belonging to ['toy-subentry-nostat']: these datasets report zero statistical error and no other covariance term covers their points. Remedies: pass the dataset's reported systematics as terms (extra_terms=[*obs.systematic_terms()]; for a multi-observation constraint place them with support= from rxmc.covariance.stacked_supports(observations)), add a noise_term or a fixed Term covering those points, or compose the full covariance explicitly with include_statistical_term=False.\n" - ] - } - ], - "source": [ - "measurement_nostat = SimpleNamespace(**{**vars(measurement)})\n", - "measurement_nostat.statistical_err = np.zeros_like(y_mb)\n", - "measurement_nostat.subentry = \"toy-subentry-nostat\"\n", - "\n", - "obs_nostat = (\n", - " rxmc.elastic_diffxs_observation.ElasticDifferentialXSObservation.from_measurement(\n", - " measurement=measurement_nostat,\n", - " reaction=rxn,\n", - " quantity=\"dXS/dA\",\n", - " )\n", - ")\n", - "\n", - "try:\n", - " rxmc.constraint.Constraint([obs_nostat], omp)\n", - "except ValueError as err:\n", - " print(err)" - ] - }, - { - "cell_type": "markdown", - "id": "d98cea7e", - "metadata": {}, - "source": [ - "As the message says: supply the dataset's reported systematics as terms, add a\n", - "`noise_term` (a free noise nuisance), or compose the covariance explicitly. Note\n", - "that the offset and normalization modes alone are rank-two, so a dataset with\n", - "*only* systematic errors still needs a diagonal contribution (a noise term or an\n", - "error floor) to make $\\Sigma$ positive definite. Our measurement has statistical\n", - "errors, so we proceed.\n" - ] - }, - { - "cell_type": "markdown", - "id": "9489bae8", - "metadata": {}, - "source": [ - "## Calibrate" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "17319787", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:07:24.065831Z", - "iopub.status.busy": "2026-08-11T03:07:24.065682Z", - "iopub.status.idle": "2026-08-11T03:07:24.069721Z", - "shell.execute_reply": "2026-08-11T03:07:24.069224Z" - } - }, - "outputs": [], - "source": [ - "evidence = rxmc.evidence.Evidence(constraints=[constraint])\n", - "\n", - "prior_mean = np.array(\n", - " [50.0, 3, 1.2 * 40 ** (1 / 3), 0.65, 18, 1.2 * 40 ** (1 / 3), 0.65]\n", - ")\n", - "prior_cov = np.diag([7, 7, 0.2, 0.2, 10, 0.2, 0.2]) ** 2\n", - "prior = stats.multivariate_normal(mean=prior_mean, cov=prior_cov)\n", - "\n", - "walker = rxmc.walker.Walker(\n", - " model_sampler=rxmc.param_sampling.BatchedAdaptiveMetropolisSampler(\n", - " params=omp.params,\n", - " prior=prior,\n", - " starting_location=prior_mean,\n", - " initial_proposal_cov=prior_cov / 100,\n", - " ),\n", - " evidence=evidence,\n", - " rng=np.random.default_rng(7),\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "84438127", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:07:24.071394Z", - "iopub.status.busy": "2026-08-11T03:07:24.071248Z", - "iopub.status.idle": "2026-08-11T03:07:40.796744Z", - "shell.execute_reply": "2026-08-11T03:07:40.795972Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CPU times: user 16.7 s, sys: 1.4 ms, total: 16.7 s\n", - "Wall time: 16.7 s\n" - ] - }, - { - "data": { - "text/plain": [ - "0.206125" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "%%time\n", - "walker.walk(n_steps=8000, burnin=1000, batch_size=1000, verbose=False)\n", - "samples = walker.model_sampler.chain\n", - "walker.model_sampler.overall_acceptance_fraction()" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "f7b9a4c4", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:07:40.798239Z", - "iopub.status.busy": "2026-08-11T03:07:40.798069Z", - "iopub.status.idle": "2026-08-11T03:07:42.595527Z", - "shell.execute_reply": "2026-08-11T03:07:42.594833Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig = corner.corner(\n", - " samples,\n", - " labels=[p.name for p in omp.params],\n", - " truths=true_params,\n", - " truth_color=\"k\",\n", - ")" - ] - }, - { - "cell_type": "markdown", - "id": "dccca3bf", - "metadata": {}, - "source": [ - "## Predictive check" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "1ec6c533", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:07:42.600185Z", - "iopub.status.busy": "2026-08-11T03:07:42.600011Z", - "iopub.status.idle": "2026-08-11T03:07:42.979739Z", - "shell.execute_reply": "2026-08-11T03:07:42.978808Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "draw_indices = np.linspace(0, samples.shape[0] - 1, 60, dtype=int)\n", - "y_draws = np.array(\n", - " [omp.visualizable_model_prediction(obs, *d) for d in samples[draw_indices]]\n", - ")\n", - "y_low, y_high = np.percentile(y_draws, [5, 95], axis=0)\n", - "\n", - "angles_plot = np.rad2deg(obs.visualization_workspace.angles)\n", - "fig, ax = plt.subplots(1, 1, figsize=(8, 4))\n", - "ax.errorbar(\n", - " np.rad2deg(obs.x), obs.y, yerr=obs.y_stat_err, ls=\"none\", marker=\"o\", label=\"data\"\n", - ")\n", - "ax.plot(\n", - " angles_plot,\n", - " omp.visualizable_model_prediction(obs, *true_params),\n", - " \"k:\",\n", - " label=\"truth\",\n", - ")\n", - "ax.fill_between(angles_plot, y_low, y_high, alpha=0.3, label=\"90% predictive band\")\n", - "ax.set_xlabel(r\"$\\theta$ [deg]\")\n", - "ax.set_ylabel(r\"$d\\sigma/d\\Omega$ [b/sr]\")\n", - "ax.set_yscale(\"log\")\n", - "ax.legend()\n", - "fig.tight_layout()" - ] - }, - { - "cell_type": "markdown", - "id": "e95379dc", - "metadata": {}, - "source": [ - "## Takeaways\n", - "\n", - "- **The unit contract**: `from_measurement` divides everything dimensionful\n", - " (data, statistical error, absolute offset error) by `obs.norm` and passes the\n", - " fractional normalization error through untouched. `obs.norm` is retained, so\n", - " you can always convert back.\n", - "- **Systematics are opt-in**: they ride along as metadata and become covariance\n", - " terms only via `obs.systematic_terms()` passed to\n", - " `Constraint(extra_terms=...)` — nothing correlated is hidden in a default.\n", - "- **The guardrail**: a dataset contributing zero variance fails at construction\n", - " with a message naming the subentry, not with an opaque `LinAlgError` mid-chain.\n", - "- To adapt to production: replace the `SimpleNamespace` with an\n", - " `exfor_tools.Distribution` — the fields are the same.\n" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.12.3" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/examples/normalization_and_covariance_structure.ipynb b/examples/normalization_and_covariance_structure.ipynb new file mode 100644 index 0000000..161174b --- /dev/null +++ b/examples/normalization_and_covariance_structure.ipynb @@ -0,0 +1,1323 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "beb5b987", + "metadata": {}, + "source": [ + "# Normalisation, systematic errors, and the structure of the covariance matrix\n", + "\n", + "Four synthetic experiments measure the same curve, and each has an uncertain overall normalisation. Three of them quote that uncertainty honestly; one quotes a normalisation uncertainty far too small. We fit the same data with six error models — three defensible, three not — and see what each does to the answer. Along the way we meet the covariance structures that `rxmc` builds as sums of terms, and the classic mistake behind Peelle's Pertinent Puzzle.\n", + "\n", + "Recipes: 2, 3, 4, 5, 6, 17, 19, 27, 33, 40, 41 (see [the recipes](/recipes.md))" + ] + }, + { + "cell_type": "markdown", + "id": "eeb35366", + "metadata": {}, + "source": [ + "## Where a $\\chi^2$ comes from\n", + "\n", + "Every fit assumes a likelihood, whether or not anyone writes it down. Counting events in a bin — say, counts in a detector — gives a [binomial](https://en.wikipedia.org/wiki/Binomial_distribution), which, for many trials each with a small probability, becomes a [Poisson](https://en.wikipedia.org/wiki/Poisson_distribution), which, in the further limit of many counts, becomes a [normal](https://en.wikipedia.org/wiki/Normal_distribution). If the bins are independent, that is a diagonal [multivariate normal](https://en.wikipedia.org/wiki/Multivariate_normal_distribution), and for fixed errors the logarithm of such a likelihood is $-\\chi^2/2$ up to a constant. That result rests on three assumptions: the points are independent, our model can reproduce the truth exactly, and the errors are what the experiment says they are.\n", + "\n", + "When the points are not independent, we generalise to a multivariate normal with a non-diagonal *covariance* $\\Sigma$,\n", + "\n", + "\\begin{equation}\n", + "\\log p(\\mathbf{y}\\mid\\alpha) = -\\tfrac12 (\\mathbf{y}-\\mathbf{y}_m)^\\mathsf{T} \\Sigma^{-1}(\\mathbf{y}-\\mathbf{y}_m) - \\tfrac12\\log\\det\\Sigma + \\text{const},\n", + "\\end{equation}\n", + "\n", + "where $\\mathbf{y}_m = y_m(\\mathbf{x};\\alpha)$ is the model's prediction for parameters $\\alpha$. If our model can't reproduce the truth exactly, or we don't trust the reported errors, we can still model the disagreement between experiment and model as multivariate normal, and infer the pieces of $\\Sigma$ we don't know along with $\\alpha$. In `rxmc` a covariance is a sum of terms — statistical errors, correlated systematics, and anything we have to infer — and this notebook is a tour of what choosing them does." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "577d7258", + "metadata": {}, + "outputs": [], + "source": [ + "import blackjax\n", + "import corner\n", + "import jax\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import plotstyle\n", + "import tinygp\n", + "from budget import QUICK_NUTS, budget # sampler budgets, cut in CI's quick run\n", + "from numpy.polynomial import polynomial as P\n", + "from scipy import stats\n", + "\n", + "import rxmc as rx\n", + "from rxmc import terms as T\n", + "from rxmc import transforms as tf\n", + "\n", + "plotstyle.use()" + ] + }, + { + "cell_type": "markdown", + "id": "c2d9e410", + "metadata": {}, + "source": [ + "## Several experiments, several normalisations\n", + "\n", + "We compare several datasets, labelled by $k$. Each measures the true curve $\\eta(x)$ multiplied by its own overall normalisation $\\rho_k$, with independent statistical noise of reported size $\\sigma_{k,i}$:\n", + "\n", + "\\begin{equation}\n", + "y_{k,i} = \\rho_k\\, \\eta(x_{k,i}) + \\varepsilon_{k,i}, \\qquad \\varepsilon_{k,i} \\sim \\mathcal{N}(0, \\sigma_{k,i}^2).\n", + "\\end{equation}\n", + "\n", + "Each experiment also quotes a normalisation uncertainty $\\sigma^\\text{sys}_k$: its belief about how far $\\rho_k$ may be from one. We model the curve with $y_m(x;\\alpha)$. There are three defensible ways to handle the $\\rho_k$:\n", + "\n", + "1. **Infer the normalisations.** Put $\\rho_k$ in the model, $\\rho_k\\, y_m(x;\\alpha)$, give each a prior centred on one with the quoted width, and sample the joint posterior $p(\\alpha, \\rho_1, \\rho_2, \\dots \\mid y)$. We use a log-normal prior, $\\log\\rho_k \\sim \\mathcal{N}\\big(0, [\\log(1+\\sigma^\\text{sys}_k)]^2\\big)$, which keeps $\\rho_k$ positive and is close to $\\mathcal{N}(1, (\\sigma^\\text{sys}_k)^2)$ for small widths. This option uses the quoted widths too, through the prior.\n", + "2. **Marginalise them with the quoted widths.** With a Gaussian $\\rho_k \\sim \\mathcal{N}(1, (\\sigma^\\text{sys}_k)^2)$, the term $(\\rho_k - 1)\\, y_m$ is a Gaussian random shift along the prediction, so integrating $\\rho_k$ out of the likelihood adds a rank-one block to the covariance,\n", + "\\begin{equation}\n", + "\\Sigma^\\text{sys}_{k,ij} = (\\sigma^\\text{sys}_k)^2\\, y_m(x_{k,i};\\alpha)\\, y_m(x_{k,j};\\alpha),\n", + "\\end{equation}\n", + "and sampling $\\alpha$ alone gives the marginal posterior $p(\\alpha \\mid y) = \\int p(\\alpha, \\rho \\mid y)\\, d\\rho$.\n", + "3. **Marginalise them, but infer the widths.** As in 2, but with each width a free parameter $\\omega_k$ with its own prior, centred on the quoted value; we sample $p(\\alpha, \\omega \\mid y) = \\int p(\\alpha, \\rho, \\omega \\mid y)\\, d\\rho$.\n", + "\n", + "And three ways to get it wrong, each of them common:\n", + "\n", + "4. **Peelle's Pertinent Puzzle.** As in 2, but build the systematic block from the measured $y_{k,i}$ instead of the prediction $y_m(x_{k,i};\\alpha)$.\n", + "5. **Ignore the systematics.** Use the reported statistical errors alone, as if every normalisation were exact.\n", + "6. **Infer the statistical errors instead.** Notice that the datasets disagree, blame the noise rather than the normalisations, and infer a free noise level in place of the reported one." + ] + }, + { + "cell_type": "markdown", + "id": "38d41ffa", + "metadata": {}, + "source": [ + "## Synthetic data\n", + "\n", + "The truth is a quartic, $\\eta(x) = 1 + 0.5x - 0.1x^2 - 0.4x^3 + 0.1x^4$, measured by four experiments over overlapping ranges of $x$. We pick each $\\rho_k$ by hand rather than drawing it. Experiments P, Q and R are a reasonable draw from their quoted uncertainties. Experiment S quotes 5 % and is actually 25 % off: five times its own quote." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "f9c7d04c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "exp P: quoted 10%, actually -8% (-0.8 times its quote)\n", + "exp Q: quoted 50%, actually +30% (+0.6 times its quote)\n", + "exp R: quoted 20%, actually -15% (-0.8 times its quote)\n", + "exp S: quoted 5%, actually +25% (+5.0 times its quote)\n" + ] + } + ], + "source": [ + "settings = {\n", + " \"exp P\": {\"domain\": (-0.3, 0.4), \"n\": 50, \"noise\": 0.1, \"sys\": 0.10, \"rho\": 0.92},\n", + " \"exp Q\": {\"domain\": (0.3, 0.5), \"n\": 30, \"noise\": 0.1, \"sys\": 0.50, \"rho\": 1.30},\n", + " \"exp R\": {\"domain\": (0.1, 0.6), \"n\": 25, \"noise\": 0.1, \"sys\": 0.20, \"rho\": 0.85},\n", + " \"exp S\": {\"domain\": (-0.5, 0.1), \"n\": 15, \"noise\": 0.2, \"sys\": 0.05, \"rho\": 1.25},\n", + "}\n", + "for label, s in settings.items():\n", + " pulls = (s[\"rho\"] - 1) / s[\"sys\"]\n", + " print(\n", + " f\"{label}: quoted {s['sys']:.0%}, actually {s['rho'] - 1:+.0%} \"\n", + " f\"({pulls:+.1f} times its quote)\"\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "d40b3b06", + "metadata": {}, + "outputs": [], + "source": [ + "rng = np.random.default_rng(42)\n", + "a_true = np.array([1.0, 0.5, -0.1, -0.4, 0.1])\n", + "\n", + "\n", + "def truth(x):\n", + " return P.polyval(np.asarray(x, dtype=float), a_true)\n", + "\n", + "\n", + "datasets = {}\n", + "for label, s in settings.items():\n", + " x = np.sort(rng.uniform(*s[\"domain\"], s[\"n\"]))\n", + " y = rng.normal(\n", + " s[\"rho\"] * truth(x), s[\"noise\"]\n", + " ) # the noise is absolute, as reported\n", + " datasets[label] = rx.Dataset(\n", + " x, y, np.full(s[\"n\"], s[\"noise\"]), norm_err=s[\"sys\"], label=label\n", + " )\n", + "x_fine = np.linspace(-0.6, 0.7, 140) # covers every experiment's range" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "382fbf3f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "ax.plot(x_fine, truth(x_fine), \"--\", color=\"k\", label=\"truth\")\n", + "for (label, d), colour in zip(datasets.items(), plotstyle.COLOURS):\n", + " ax.errorbar(\n", + " d.x,\n", + " d.y,\n", + " d.y_err,\n", + " fmt=\"o\",\n", + " ms=3,\n", + " color=colour,\n", + " label=rf\"{label}: $\\rho$ = {settings[label]['rho']:.2f}\",\n", + " )\n", + "ax.set(xlabel=\"$x$\", ylabel=\"$y$\", title=\"Four experiments, four normalisations\")\n", + "ax.legend(fontsize=8, ncol=2)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "7f5ff026", + "metadata": {}, + "source": [ + "## The model\n", + "\n", + "We fit a quartic, $y_m(x;\\alpha) = \\sum_{j=0}^{4} a_j x^j$, with all five coefficients free, so $\\alpha = (a_0, \\dots, a_4)$. The constant term $a_0$ is not zero in the truth, and an overall normalisation can trade against it: that confounding is part of what the error models have to sort out. Each coefficient gets a $\\mathcal{N}(0, 1)$ prior, wide on the scale of the truth." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "172b8852", + "metadata": {}, + "outputs": [], + "source": [ + "coeffs = [\n", + " rx.Parameter(f\"a{j}\", prior=stats.norm(0.0, 1.0), latex=f\"a_{j}\") for j in range(5)\n", + "]\n", + "quartic = rx.Model(lambda x, *a: sum(aj * x**j for j, aj in enumerate(a)), coeffs)\n", + "comps = {label: rx.Comparison(d, quartic) for label, d in datasets.items()}" + ] + }, + { + "cell_type": "markdown", + "id": "499d43bd", + "metadata": {}, + "source": [ + "## How we sample\n", + "\n", + "We use [NUTS](https://arxiv.org/abs/1111.4246), through [blackjax](https://blackjax-devs.github.io/blackjax/), for every fit in this notebook. Free normalisations make a posterior shaped like a funnel: when a normalisation's width is small it pins the curve, when it is large the curve is free, and the sampler has to work in both regimes. NUTS follows the exact gradient and adapts its step size to the narrow end, and on the benchmark problem closest to this notebook it is the only sampler, of emcee, dynesty, pocomc and NUTS, whose means and widths match a long reference run ([benchmarks](/benchmarks.md)); that reference is itself a NUTS run, so the benchmark checks it against its own diagnostics rather than an independent algorithm. It runs on `log_posterior_unconstrained` (recipe 41); every prior here is an unbounded normal, already on the logarithm of each positive quantity, so the unconstrained coordinates are the parameters themselves.\n", + "\n", + "Where the chains start needs care here. A systematic mode built from the prediction, $\\sigma^2 y_m y_m^\\mathsf{T}$, lets a Gaussian normalisation go negative, so the likelihood has a second basin where the fitted curve has the *opposite sign* to the data. It fits the data far worse than the main mode, but the two basins are separated by a wall where the prediction passes through zero and the covariance collapses, and a chain started on the wrong side can never cross it. Chains started from prior draws, which often have the wrong sign, get stuck there. So we first find the main mode with `rx.optimize.find_map` (recipe 33), and start four chains from a ball about it, 0.5 wide in every unconstrained coordinate: wider than most of the posterior's own widths, so that the chains begin well apart and the convergence check means something. A start that lands across the wall would be stranded, so we keep only starts within 50 units of log posterior of the mode.\n", + "\n", + "`fit` prints the [rank-normalised split $\\hat R$](https://arxiv.org/abs/1903.08008), which compares the spread within each chain with the spread between them, the smallest bulk effective sample size, and the number of divergent transitions. We accept a fit only with $\\hat R \\le 1.01$, and we look at every divergence." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "ec19fe94", + "metadata": {}, + "outputs": [], + "source": [ + "def fit(problem, seed, chains=4, warmup=budget(1000), draws=budget(1000), label=\"\"):\n", + " \"\"\"NUTS on the unconstrained density, one window-adapted chain per start\n", + " in a ball 0.5 wide about the MAP; the draws pooled, in problem.names order.\"\"\"\n", + " logdensity = problem.log_posterior_unconstrained\n", + " best = rx.optimize.find_map(\n", + " problem, rng=seed\n", + " ) # best.fun: the maximum log posterior\n", + " z_map = problem.to_unconstrained(best.x)\n", + " # a wide ball about the mode, keeping only starts on the mode's side of any\n", + " # wall: within 50 units of log posterior of it\n", + " rng, starts = np.random.default_rng(seed), []\n", + " while len(starts) < chains:\n", + " z0 = z_map + 0.5 * rng.standard_normal(problem.ndim)\n", + " if problem.log_posterior(problem.to_theta(z0)) > best.fun - 50:\n", + " starts.append(z0)\n", + " runs, divergent = [], 0\n", + " for key, z0 in zip(jax.random.split(jax.random.key(seed), chains), starts):\n", + " k_warm, k_draw = jax.random.split(key)\n", + " adapt = blackjax.window_adaptation(blackjax.nuts, logdensity, **QUICK_NUTS)\n", + " (state, tuned), _ = adapt.run(k_warm, z0, num_steps=warmup)\n", + " step = jax.jit(blackjax.nuts(logdensity, **tuned).step)\n", + "\n", + " def one_step(state, key):\n", + " state, info = step(key, state)\n", + " return state, (state.position, info.is_divergent)\n", + "\n", + " _, (zs, div) = jax.lax.scan(one_step, state, jax.random.split(k_draw, draws))\n", + " runs.append(np.asarray(jax.vmap(problem.to_theta)(zs)))\n", + " divergent += int(div.sum())\n", + " runs = np.stack(runs)\n", + " rhat = np.max(blackjax.diagnostics.rhat(runs))\n", + " ess = np.min(blackjax.diagnostics.ess_bulk(runs))\n", + " print(f\"{label}R-hat {rhat:.3f}, min bulk ESS {ess:6.0f}, {divergent} divergences\")\n", + " return runs.reshape(-1, problem.ndim)\n", + "\n", + "\n", + "def curves(problem, samples, grid, n=200):\n", + " # the bare quartic's curves on a grid: the physics, not the renormalised data\n", + " rows = samples[np.random.default_rng(0).choice(len(samples), n, replace=False)]\n", + " return rx.predictive.grid_draws(\n", + " problem, quartic.bind(grid), grid, rows, model_only=True, return_draws=True\n", + " )\n", + "\n", + "\n", + "def band_of(problem, samples, minus_truth=False):\n", + " draws = curves(problem, samples, x_fine)\n", + " if minus_truth:\n", + " draws = draws - truth(x_fine)\n", + " return np.percentile(draws, [16, 84], axis=0)" + ] + }, + { + "cell_type": "markdown", + "id": "14b5d687", + "metadata": {}, + "source": [ + "## The three defensible treatments\n", + "\n", + "Each is one `rx.Problem` on the same four comparisons:\n", + "\n", + "1. **Inferred normalisations** (recipe 6): the model becomes `quartic | tf.scale(rho)`, one scale per comparison, each with the log-normal prior above.\n", + "2. **Quoted systematics** (recipe 3): `comparison.reported_terms()` turns each dataset's `norm_err` into the rank-one mode $\\Sigma^\\text{sys}$, built from the prediction.\n", + "3. **Inferred systematics** (recipe 4): the same mode with a free width, `T.normalization(parameter=log_omega, on=comparison)`, one $\\log\\omega_k$ per dataset with the prior $\\log\\omega_k \\sim \\mathcal{N}(\\log\\sigma^\\text{sys}_k, 0.7^2)$." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "400e1030", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1: inferred normalisations ['a0', 'a1', 'a2', 'a3', 'a4', 'log_rho_0', 'log_rho_1', 'log_rho_2', 'log_rho_3']\n", + "2: quoted systematics ['a0', 'a1', 'a2', 'a3', 'a4']\n", + "3: inferred systematics ['a0', 'a1', 'a2', 'a3', 'a4', 'log_omega_0', 'log_omega_1', 'log_omega_2', 'log_omega_3']\n" + ] + } + ], + "source": [ + "rhos = {\n", + " label: rx.Parameter(\n", + " f\"log_rho_{k}\",\n", + " prior=stats.norm(0.0, np.log1p(settings[label][\"sys\"])),\n", + " latex=rf\"\\log\\rho_{k}\",\n", + " )\n", + " for k, label in enumerate(comps)\n", + "}\n", + "omegas = {\n", + " label: rx.Parameter(\n", + " f\"log_omega_{k}\",\n", + " prior=stats.norm(np.log(settings[label][\"sys\"]), 0.7),\n", + " latex=rf\"\\log\\omega_{k}\",\n", + " )\n", + " for k, label in enumerate(comps)\n", + "}\n", + "good = {\n", + " \"1: inferred normalisations\": rx.Problem(\n", + " [\n", + " rx.Constraint(\n", + " [\n", + " rx.Comparison(d, quartic | tf.scale(rhos[l]))\n", + " for l, d in datasets.items()\n", + " ]\n", + " )\n", + " ]\n", + " ),\n", + " \"2: quoted systematics\": rx.Problem(\n", + " [\n", + " rx.Constraint(\n", + " list(comps.values()),\n", + " terms=[t for c in comps.values() for t in c.reported_terms()],\n", + " )\n", + " ]\n", + " ),\n", + " \"3: inferred systematics\": rx.Problem(\n", + " [\n", + " rx.Constraint(\n", + " list(comps.values()),\n", + " terms=[\n", + " T.normalization(parameter=omegas[l], on=c) for l, c in comps.items()\n", + " ],\n", + " )\n", + " ]\n", + " ),\n", + "}\n", + "for name, p in good.items():\n", + " print(f\"{name:28s} {p.names}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "ac0d80af", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1: inferred normalisations R-hat 1.002, min bulk ESS 1270, 0 divergences\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2: quoted systematics R-hat 1.001, min bulk ESS 2487, 0 divergences\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3: inferred systematics R-hat 1.003, min bulk ESS 1708, 0 divergences\n", + "CPU times: user 5min 5s, sys: 4.17 s, total: 5min 10s\n", + "Wall time: 1min 40s\n" + ] + } + ], + "source": [ + "%%time\n", + "samples = {\n", + " name: fit(p, seed=k, label=f\"{name:28s}\")\n", + " for k, (name, p) in enumerate(good.items())\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "92b0c36d", + "metadata": {}, + "source": [ + "All three converged. On the scale of the data the fits look much alike, so we compare them as residuals: the fitted curve minus the truth, $y_m(x;\\alpha) - \\eta(x)$, as a 68 % band over $x$, where zero is the truth. For each treatment we also print the band's mean width and the constant term $a_0$." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "a2040f20", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " mean width a0 (68 %), truth 1.0\n", + "1: inferred normalisations 0.16 1.10 [1.03, 1.16]\n", + "2: quoted systematics 0.17 1.12 [1.05, 1.19]\n", + "3: inferred systematics 0.26 1.13 [0.99, 1.24]\n" + ] + } + ], + "source": [ + "style = {\n", + " name: (plotstyle.COLOURS[i], plotstyle.HATCHES[i % len(plotstyle.HATCHES)])\n", + " for i, name in enumerate(\n", + " [\n", + " \"1: inferred normalisations\",\n", + " \"2: quoted systematics\",\n", + " \"3: inferred systematics\",\n", + " \"4: PPP, mode from the data\",\n", + " \"5: systematics ignored\",\n", + " \"6: statistics inferred\",\n", + " ]\n", + " )\n", + "}\n", + "residual_bands = {\n", + " name: band_of(p, samples[name], minus_truth=True) for name, p in good.items()\n", + "}\n", + "\n", + "\n", + "def scorecard(problems):\n", + " # the mean width of each treatment's 68 % band of the curve, and a0\n", + " print(f\"{'':28s} {'mean width':>10s} a0 (68 %), truth 1.0\")\n", + " for name, p in problems.items():\n", + " lo, hi = residual_bands[name]\n", + " q = np.percentile(samples[name][:, p.columns(coeffs[0])], [16, 50, 84])\n", + " print(\n", + " f\"{name:28s} {np.mean(hi - lo):10.2f} \"\n", + " f\"{q[1]:.2f} [{q[0]:.2f}, {q[2]:.2f}]\"\n", + " )\n", + "\n", + "\n", + "scorecard(good)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "891c1333", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def residual_plot(names, title):\n", + " fig, ax = plt.subplots()\n", + " for name in names:\n", + " colour, hatch = style[name]\n", + " plotstyle.band(\n", + " ax, x_fine, *residual_bands[name], color=colour, hatch=hatch, label=name\n", + " )\n", + " ax.axhline(0.0, ls=\"--\", color=\"k\", label=\"truth\")\n", + " ax.set(xlabel=\"$x$\", ylabel=r\"$y_m - \\eta$\", title=title)\n", + " ax.legend(fontsize=7)\n", + " plt.show()\n", + "\n", + "\n", + "residual_plot(\n", + " good, \"68 % bands of the fitted curve minus the truth: the defensible three\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "a152ddc9", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABQQAAAUECAYAAACKnh2bAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvctoD+AAAAAlwSFlzAAAQ6wAAEOsBUJTofAABAABJREFUeJzs3Xd0VOW+xvFn0gtpJJSQCkGqCb0IUQEFUURBULGg2EGwoF7PUTm2w9GjWJEjiiL2CiooiqCCGopKM6F3SGBoKaRPMjP7/hEZCJmEJIS0+X7Wcp2Z/e797t+emXiXz32LyTAMQwAAAAAAAABcgltdFwAAAAAAAACg9hAIAgAAAAAAAC6EQBAAAAAAAABwIQSCAAAAAAAAgAshEAQAAAAAAABcCIEgAAAAAAAA4EIIBAEAAAAAAAAXQiAIAAAAAAAAuBACQQAAAAAAAMCFEAgCAAAAAAAALoRAEAAAAAAAoIosFotsNlu1rrXb7SosLKzhis6MzWaTxWKp6zLOiuLiYlmt1nLf18Y96xsCQQAAAAAA4HKOh3KGYVTr+ri4OH3wwQdVuubQoUMaMGCA/P39FRwcXK37ni0ffPCB2rdvX9dlnBVjx47V+PHjy31/ppyFfzV9j5pGIAgAAAAAAFxGWlqaHn/8cUVGRsrX11dbt26tVj8+Pj5yd3ev0jWvvvqqiouLlZWVVe9GCLoSLy8veXp61lh/1113nSZNmnRW71HTPOq6AAAAAAAAgNry4osvKjg4WG+88YauvPLKavezceNGeXiciFUsFos8PT3l5uYmwzBkMplKnW+xWLR9+3Z17NhRhmGouLi4TGBkt9vl5lZ27NbJfdvtdtntdrm7u8tiscjHx0eSZLVa5ebmVur68vo7mbNanbHZbLLZbPLy8qrUdeXd+9R+ioqK5OXlpeLiYplMJsdnemr/5d3ParU6Rud5e3tX6llmz57t9Dxn9zhd/1arVXa7XTabzRHyent7l3sPqfzP5nSfwelqrQpGCAIAAAAAAJfx8ssv64knnlCrVq3KPcdqtZ52Pb1Tpwy3aNFCTz75pC644AI1adJEzZs310svveRoT0hI0Jdffql3331XwcHBuu222yRJubm5Gj9+vEJCQuTr66suXbro+++/L3WvFi1a6IknnlCfPn3k6+urf/3rX9q4caN8fX31v//9T61bt5a/v78WLlwoSfrmm2/UpUsXeXl5qXnz5rr77ruVk5NTqs9p06YpNDRUTZo00QUXXKBNmzZV+LzTpk1Tr1699NhjjykqKko+Pj4aNGiQUlNTS5335ptvKiYmRh4eHmrVqpWee+45p/3885//VEhIiAIDA2Wz2TRy5Ehdf/31uuKKK9S0aVP5+fnpzjvv1N69ezVs2DD5+voqJCREzzzzTKn+HnnkEQUHBys4OFgBAQEaMGCAkpOTK3yWU6fzfv/994qPj5e3t7ciIyP1+OOPq6ioqFL9T548WfPnz9ecOXMc56WkpJS5R1FRkSZPnqymTZvK09NTnTp10oIFC0rVNXLkSI0bN07XXXedQkNDFRgYqFtvvbXUb7GiWquCQBAAAAAAAOAkDz30ULXW05s1a5aeeeYZHTt2TLNmzdJDDz2ktWvXSpK2bt2qkSNH6vbbb1dhYaHef/99SdLo0aN16NAhJScnKzc3V//61780atSoMqHW66+/rv/+97/Kz8/Xs88+6zg+e/Zs/fDDD7JYLBo+fLh+/vlnjR07Vv/5z3+Un5+vNWvWaNOmTaWmtM6fP19PPPGE3n33XWVkZOi+++7Tq6++etrnS05OVl5enjZu3Kj9+/fLYrHowQcfdLR/9913uvfee/XCCy+ooKBA77zzjqZOnap33nmnTD+ZmZnavXu3CgsLHVOv582bpzFjxujgwYNasmSJ3nnnHXXv3l233HKLcnJy9Pnnn2vKlClas2aNo69p06apsLBQhYWFOnDggHr16qURI0ZUeoOUwsJCjR49WnfddZfy8vK0du1a+fj46K+//qpU/6+99lqp77WwsFAJCQll7vPkk09q3rx5WrJkiXJzc3XHHXfoqquu0ubNm0ud98knn+jSSy/VgQMHtGrVKn3zzTd68803K1VrVTBlGAAAAAAA1IjE15KUdqz218aLDPJR0j2JNdafp6envL29q3zd5MmTlZhYUseIESPUrl07rVixQt27d3d6/urVq7VkyRIdPHhQISEhMgxDV1xxhS6++GJ9/PHHpYKliRMnauDAgWX6+O9//6t27do53j/zzDMaP368hg4dKsMw1KJFCz399NO66KKL9Pbbb8vT01OvvPKKbr75Zg0fPlySNGrUKI0ZM0a//PJLhc8XFhamF1980RHg3XHHHZoyZYqj/YUXXtANN9ygq6++WpI0dOhQ3X333XrhhRd06623Os4LCAjQq6++6pjufNxll12m66+/XpKUmJio7t27KzY2VqNHj5YkDR48WB06dNDKlSvVo0ePMvX5+PjoySef1Guvvab169erT58+FT6PJGVkZCg/P18XXXSRPD091bx5cz366KNOz61O/1LJiNNXXnlFM2bMcNQ9efJkzZ07Vy+//LJmzZpV6jO46aabJEmdO3fWlVdeqRUrVujee++tUq2nQyAIAAAAAABqRNqxQu3NLKjrMs7YtGnTNG3atCpf16ZNm1Lvg4ODlZWVVe75a9euld1uV1RUVJm2wMDAUu87duzotI9Tj69du1a//vqrXnnllVLH3d3dtX//fsXGxmrz5s2O4O24Hj16nDYQjI6OLrWRyqnPt3nzZkcYeFyfPn300ksvyWq1OtbGa926dZkwUCr7+QUGBqp169Zljp18zw0bNuihhx7SypUrlZeXJw8PD1ksFqWmplYqsGvVqpXGjBmj888/X1dffbUGDhyooUOHOj7/M+1fkvbu3auCggL16tWrzGfz559/VvgZBAcHKy0trVK1VgWBIAAAAAAAqBGRQWVDnsZ831NVZ5MHPz8/5eTknHbzj/J2rHV2/Pnnn9f9999fbl/HNz45md1uP22tp3u+45uenNrvqZudlPcszvo/3T2vvPJKDRkyRHPmzFHLli1lMpnUpEkTx0YglfHJJ59o9erVWrx4sV555RXdfffdWrRokXr27Fkj/R9/dmefzak7VZ/ueSuqtSoIBAEAAAAAQI2oyWm7dclqtcpms1Vr2nBV9OjRQ/n5+Vq2bJkGDRpUY31+9913FQaCnTt31u+//64777zTcez3338/43t37txZq1at0sSJEx3HVqxYoQ4dOpw28KyOo0ePateuXZo4caLCw8MlnVjnsKp69uypnj176tFHH9WFF16oOXPmKDY2tlL9e3p6ymazldt3dHS0mjRpolWrVqlLly6O4ytXrqxykFderVXth01FAAAAAACAy7DZbCosLHTszFpUVKTCwsJSgU51NxWpqh49emjkyJG69dZbtWjRIqWnp2v9+vV66KGH9Omnn1arzyeeeELLli3TQw89pN27d2v//v2aO3duqam8Dz74oD788EN98MEHOnz4sGbPnq25c+ee8fM88sgj+uyzzzR79mwdOXJEn3/+ud5880098sgjZ9y3M6GhoWrZsqXefPNNHT16VGvXrtXNN99cpT7Wrl2rG264QStXrlRmZqZWr16tHTt2qH379pXuv3Xr1lq3bp2OHDmiwsLCMqMv3d3d9fDDD+vJJ5/Uzz//rEOHDunpp5/W+vXr9cADD9RIrVVFIAgAAAAAAFzGyy+/rODgYA0aNEje3t7q3bu3goODNWfOHMc5ldlUxMfHp9R0z1PfS5K3t7dj3TxJ8vLyKjNd9tNPP9W4ceN03333KS4uTrfddpsiIiJ01VVXVdi3m5ubvL29y0wxTUxM1NKlS5WSkqKePXvqvPPO09y5c/XUU085zhk6dKheffVVPfHEE0pISNDXX3+txx9/vMJn9vDwKNPu7u5eai3AgQMH6v3339f06dMVFxenJ554Qi+99JLGjBlTYT/lfTbOjp38mZpMJs2bN0+///674uLiNGbMGI0bN04RERGlPq9T+zn5fbdu3TRs2DA9+OCDiouL0w033KC77rpLkyZNqnT/kyZNUmhoqDp27Kjg4GClpKSUueejjz6q8ePH67bbblO7du20aNEiLVq0SHFxcRU+r6enp7y8vE5ba1WZjFNjSwAAAAAAAACNFiMEAQAAAAAAABdCIAgAAAAAAAC4EAJBAAAAAAAAwIUQCAIAAAAAAAAuhEAQAAAAAAAAcCEEggAAAAAAAIALIRAEAAAAAAAAXAiBIAAAAAAAAOBCCAQBAAAAAAAAF0IgCAAAAAAA4CIuu+wyffbZZ3VdRr01YMAAffXVV3VdxllHIAgAAAAAAFzGtm3bdM8996hv374aNGiQnnnmGeXl5dV1WRU6//zz9c0339RIX7t27VJmZmaN9FUVNfkMNcVZTTt27NCxY8fqqKLa41HXBQAAAAAAANSGgwcPauTIkbr77rt1ww036OjRo3rooYe0bNky/fDDDzKZTHVdolPbt29v8CFVfXwGZzX98ssvCgsLq6OKag8jBAEAAAAAgEto1qyZUlJSNHHiRPXt21eXX3653njjDS1ZskQ7duyoUl95eXl64IEH1K1bN11++eWaO3duqem4NptNHTp00B9//FHquksuuaTUlF2LxaKnn35affv2Vffu3TV58mRlZGQ42q+44godPXpUDz/8sDp06KAePXpIkgzD0BtvvKGBAweqZ8+euvnmm8s8g7MaT2fx4sUaPny4unfvruuuu07r16+XJD322GMaP358mfMvv/xyTZ8+vcJrz+QZevfurdmzZ2vChAnq06ePLr74Yv34449KTU3Vrbfeqm7duunKK6/Uxo0bS103evRodejQQR07dtRFF12kadOmqbi4+LSf62233aaff/7ZcZ5hGHrzzTd18cUXq2fPnnrggQeUnZ192s+r3jMAAAAAAABc1C+//GJIMrZt2+Y49swzzxiDBg2q8LrRo0cbnTp1Mn744QdjyZIlRnx8vOHu7m7MnDnTMAzDKC4uNiQZS5cuLXVdXFyc4xzDMIzrr7/eiIuLM7799ltj6dKlRt++fY1evXoZdrvdMAzD2LVrlxEWFmY8//zzxubNm42tW7cahmEYEydONLp06WIsWLDAWL16tfHYY48ZQUFBxv79+ytd46k2bdpkeHt7GzNmzDDWrVtnfPHFF0afPn0MwzCMn3/+2fD09DQOHz7sOH/9+vWGJGPz5s0VXnsmzxAUFGQEBgYaM2fONFavXm3ccccdhq+vr3Huuecab731lvHnn38aN954o9GmTRujuLjYcd2ePXscdS1YsMDo2LGjMXnyZEd7eTVFREQYc+bMcZx31113GS1atDDmzJlj/PHHH8ZLL71kPPDAA6f9vOo7pgwDAAAAAIAasXtqoqyZabV+X4+QSLWeklTl6+x2u5588kl17dpVbdu2dRw/dOiQdu7cWe51mzdv1ty5c7V27Vp169ZNkvTRRx8pISGhSvffvHmzPv74Y61YsULnnXeeJGnu3Llq06aNFixYoCuvvFKtW7eWu7u7wsPD1aFDB0kl69y9/vrr2rVrl2JjYyVJPXr00IoVK/TWW2/piSeeqFaNf/31l5o3b66JEydKkrp27aoRI0ZIKtlsIyYmRh9++KEmT54sSZo9e7b69eunDh066NNPPy332uo+w3ETJ050jE6cNm2a3nrrLV199dW6/fbbJUn//e9/FRkZqe3bt6tjx46SpJiYGMf1HTt2VJMmTXTFFVfopZdeKremU23ZskVvvvmmFi9erMGDB0uSevXqJavVetrPq74jEAQAAAAAADXCmpmm4qN767qMSrv33nu1fv16LV++vNT6gY8++qjuueeecq9bt26dAgICHEGbJMXHxys0NLRK91+/fr18fX0dYaAkRUREqGPHjlq3bp2uvPJKp9clJSXJZDLp8ssvl1QyrdUwDB04cEDh4eHVrjExMVE5OTkaMWKExowZo4EDB6pFixaSJJPJpFtvvVXvvPOOJk+erKKiIn388cd67rnnTnttdZ/huC5dujheBwUFydvbu9Sx4/c5fPiwIxDctGmTXnrpJW3cuFFZWVmyWCzKzc3VkSNH1KxZs3LrOtmKFSvk7e2tiy++uNRxDw+Paj1zfUIgCAAAAAAAaoRHSGSDue9DDz2kjz76SD/++KMjRDquefPmat68ebnXFhQUyMfHp8xxPz+/KtVQXj++vr7Kz8+v8DpfX1+nawIGBgZWu8bIyEht3LhRH3zwgebMmaNbb71VV1xxhT744AN5enrqlltu0eOPP64///xTu3fvVmFhoa699tpKXVudZzjO3d29zDnOjhmGIUk6cuSILrjgAl1zzTV67rnnFBoaqh07dmjEiBGyWCzlPv+pLBaLfHx8yt1spqrPXJ8QCAIAAAAAgBpRnWm7deHhhx/W22+/rSVLljg2k6iKtm3b6ujRozp8+LAjOMzIyNCBAwcc53h4eMjHx0e5ubmOYzabTQcPHizVT2Zmpvbv36+IiAhJJSHUtm3bdOuttzrOc3d3d4RdktS+fXvl5eWpuLhY8fHx1a7RmVatWukf//iH/vGPfyg1NVXt2rXTggULNGrUKLVs2VLDhg3TO++8o927d+vqq69WkyZNKnVtdZ6hulatWqWioiK9/vrrjmMpKSllzju1plN16NBBx44d065du9SmTRun51T0zPUZuwwDAAAAAACX8c9//lNvvfWWlixZol69ejk959lnn9VFF11Ubh/nn3++2rdvr//7v/+T1WqVzWbT//3f/8lms5U6r1u3bvrkk09kt9tlGIaefPJJ5eXlOdoTExMVHx+vBx98UMXFxTIMQ0888YRMJpOuueYax3nh4eHavXu34/2AAQPUvXt33XnnnY6Ar7i4WB9++KF++OGHKtV4sq+//lpz5851rJFXUFAgm82moKAgxzm33367PvroIy1ZskS33XZbpa+tzjNUV4sWLZSXl6c1a9ZIkvbt21dqTcLjTq3pVBdeeKESEhI0fvx4x87Pu3fv1ttvv12pZ67PCAQBAAAAAIBL2LJli5577jmZTCaNHTtWHTp0cPyzbNkyx3mn21TEzc1NH330kX777Tc1bdpUzZo1k8ViKbWRhSS9+uqr+vXXX9W8eXO1aNFCBw8eVGRkZKl+PvvsM23dulUhISEKDQ3VZ599pi+++KJUqPTggw/q+eefV1xcnHr06CE3NzctXLhQLVq0UGxsrKKiotS0aVMtWbLEsbZeZWs8Wffu3fXFF18oJCRErVu3Vs+ePfXQQw+VWkPv0ksvVVBQkNq2bavExMRKX1udZ6iu3r1767777tN5552n6OhoxcfHa9CgQWXOO7WmUx2v0TAMtWzZUhERERoyZIhjinllPq/6ymRUNDYSAAAAAACgkSgqKtKuXbuctkVFRcnf319SyeYUOTk5iouLq7A/u92u1NRUtWjRQj4+PurQoYPuv/9+x464Usm6dvv371ezZs3k7e2tXbt2qWnTpgoODi7Vl9lsVnFxsaKiopyuWWexWLR//35ZrVa1a9fOcTw3N1dHjx5VZGSkY7OLimrcvXu3QkJCytz/1HsdOnRI4eHhZdbCMwxD55xzjm6//Xb985//rNK11XmG7du3q2XLlgoICHAc27ZtmyIiIhzfl1QS9kZHR5daI/H4JiLHp2Pv2rVLbdu2LXWPU2vauXOnwsLCyozyy8zMVH5+vqOvyj5zfUUgCAAAAAAAUAOcBYKNzbx58zR27Fjt27dPYWFhdV0OqolNRQAAAAAAAFCho0ePql+/ftq3b59eeOEFwsAGjhGCtchqtergwYNq2bKl02G8AAAAAACg4arMdNyGymazaceOHWrevLlCQkLquhycIQLBWpSWlqaoqCilpqaWWkT0VBkZGWratGktVnZmTt5Ke968eVW6NvG1ki3pk+5JPM2Zpe2eWnL+mWxpf7Y/57PxbA3ttyE1zJoBAAAAAGjM2GW4HiKjrR0N8XOmZgAAAAAAcKYIBAEAAAAAAAAXQiAIAAAAAAAAuBACQQAAAAAAAMCFEAgCAAAAAAAALoRAEAAAAAAAoIruuusuLVu2rErX2O12vf322xo3bpxGjx59dgqrpmXLlunuu++u6zLqrUWLFum+++6r6zJqDIEgAAAAAABwGXa7XXPnztXEiRN1xx136PXXX1dubm6V+1m4cKH27NlTpWtmz56txx9/XBdeeKHGjBlT5XueTXv27NF3331X6/dduHChHnjggVq/b0Wc1bRjxw798MMPdVRRzfOo6wIAAAAAAABqy5VXXqmgoCBdcMEFslqtmjVrlt544w2tXLlS/v7+le5n1qxZ6ty5c5XunZSUpEsvvVS33HJLVctutLZv367FixfXdRmlOKvp0ksvVbt27eqooppHIAgAAAAAAFzG7Nmz1bx5c8f7YcOGKTY2VsuXL9eQIUMq3c/8+fPl5+enmJgYSdLNN9+sO+64Q5s2bdIff/yhwMBAjR8/3hEi3X333frpp5/k7e2t0aNHKzExUffff78k6bffftPnn3+unJwcde7cWePHj1dAQIDjXjfffLNuv/12rV+/Xr///ruGDBmigQMHavLkyXruuef07rvvaseOHXrggQfUq1cvZWVl6a233lJycrKaNWumq666SomJiaXq37p1q15//XXl5eWpd+/ecnd3r/B5i4uL9cEHH2jFihXy9fXVsGHDNHToUO3du1cPPvigZsyYoZYtWzrOX7lypaZPn6733ntPJpPJ6bW//fab3n33XaWmpjqmUN9+++0aOnToaZ/h66+/1sqVK3XFFVdowYIFMpvNGjRokMaNG6fly5fr448/lsVi0VVXXaXLLrvMcd2qVav0wgsvSJL8/f3VsWNHjR8/XsHBwY7vwllNkvT999+X+o0cO3ZMs2fP1rp16xQREaE777xTbdq0qfDzqi+YMgwAAAAAAFzGyWGgVDIV1M3NTdHR0Y5j77777mnX0zt1yvD8+fN11VVXae3atTr//PN14MAB9enTR0ePHpUkDR8+XFFRUYqLi9OYMWN03nnnSZKmT5+ua665Rq1atdLAgQO1YsUKde/evdQ05vnz52vkyJFav369LrvsMnXr1k3Hjh3TvHnzNGDAAJlMJo0cOVIRERE6dOiQunfvrjVr1uiiiy5Ss2bNNGLECM2ZM8fR386dO9W7d28dOnRI/fr106JFi/Twww9X+Lz33Xefnn/+efXo0UPnnnuuZsyYoXfeeUcxMTFKTk7W+++/X+r86dOnq6CgQF5eXhVe261bNwUFBWnMmDEaM2aMzjnnnEo9w5YtW/T666/r7rvvVps2bdShQweNHz9ew4cP1z333KOuXbsqOjpaI0aM0E8//eS4LioqynGvgQMHKikpSd27d1d+fr4klVvTqVOGDxw4oK5du2ru3Lnq16+fmjZtqquuukpZWVkVfl71hoFak5qaakgyUlNTKzzv6NGjtVRRzbjqqqsc/1RV/+m/Gf2n/1bl63b9u7+x69/9q3zdyc7253w2nq2h/TYMo2HWDAAAAKBxW7p0qTFq1Chj4MCBRlRUlPH111+Xar/vvvuMmJiYCvuIiIgw5syZ43gfFBRk3HnnnY73xcXFRvPmzY13333XcWzUqFHGXXfd5XhvNpsNLy8v488//3Qcs9vtRrdu3Yxp06aV6vv6668vdf+UlBRDkvH666+XOn7HHXcYo0aNKnXs008/NcLCwhzvb775ZmPgwIGl7tmnT58KnzkmJsb4+OOPSx07cuSIYRiG8dxzzxkdOnRwHM/MzDR8fHyM+fPnn/bal19+2ejcuXOVn+HZZ581vL29DbPZ7Dg2duxYw9/f39G3YRjGyJEjjdtuu63c57LZbEaHDh2M2bNnO445q+m1114z2rdv73h/yy23GPHx8YbVanUcy8nJMQoLC0/7zPUBU4YBAAAAAECNSFw4Q2n5x2r9vpF+QUoaNqnS57du3VpjxozRwYMHNWvWLL300ksaPHiw/Pz8JEm33HKLLrnkkirXccEFFzhee3h4KCYmRvv37y/3/J9//llWq9UxhdUwDBmGoYyMDKWkpJQ696KLLnLax6nHFy1apLCwMI0ZM8bRX3Z2to4ePSqz2azw8HAlJSXpnnvucVxjMpk0YsQIvfHGG+XW2r17d7344otq0qSJLrzwQgUGBiosLEySNG7cOE2ZMkUrVqxQv3799NFHHykoKMgxVbeia52pzDNI0jnnnFNqmnJsbKw6duxYqu/Y2Fht2bKlVP9Lly7VN998I7PZrOLiYh07dkzbtm0rtx5nFi9erEmTJpWaat2kSZNKfV71AYEgAAAAAACoEWn5x7Q3N7OuyzitmJgYx9p/N954o6KjozV79mxHSNalSxd16dKlyv16e3uXeu/m5ia73V7u+VlZWfL19XWsVXfcNddco8jIyFLHAgMDnfZx6vGsrCxdeumlGjx4cKnjt99+u+PcjIwMx5p5x536/lTvv/++pk+frmeeeUbXXHONzj//fM2YMUPt2rVT8+bNdfnll+udd95Rv3799M477+imm26Sh4fHaa8t73M53TNIzj/v030H06dP1xNPPKFJkybp0ksvlZ+fn/bs2VPlnaaPHTum0NDQctur+sy1jUAQAAAAAADUiEi/oAZ33+DgYLVo0UL79u2rwYoqJyoqSnl5eerTp4+ioqJqrE8PD48yIePJYmJitHv37lLHdu3aVWG/TZo00aOPPqpHH31UmZmZGjt2rMaPH6+ff/5ZknTHHXfo2muv1W233aa1a9fqo48+qtS1JpOpWs9QXXPmzNG//vUvPfDAA45jTz75ZKlznNV0qpiYmApHFZ7u86prBIIAAAAAAKBGVGXabl04fPiw1qxZo0svvdRxbPHixdq1a1ep6b7vvvuu/vjjD73++utntZ7BgwcrKipKkydP1kcffeQY3bZ27VpZrVb17t27yn3edtttmjJlisaNG6devXpJkgoKCvTFF1/opptukiRde+21ev311zVx4kQ1a9ZMBw4c0Pvvvy8fH59y+3377bc1btw4eXh4KCQkRO3bt9fy5csd7ZdccomCg4N1/fXXq1+/furQoUOlrg0LC9PRo0dlGIYjiKvMM1SXl5eXDhw44Hj/+eefa+PGjRowYIDjmLOaTnXzzTfrmWee0W233eZ41p9++kk9e/ZUUFDQaT+vukYgCAAAAAAAXIKvr69mz56t++67T+ecc44OHz6sLVu26IknntDw4cMd561fv17ffffdWa/Hx8dH33zzja655hq1adNGCQkJSk1NlZ+fn957771q9Xn//fdrz549uuCCC9S9e3d5eXlp+/btmjTpRFh777336vvvv1enTp3UrVs3bdiwQQkJCRWOeEtOTlZsbKw6d+6snJwcbdu2TZ999pmj3c3NTbfeequeeuopTZkypdLXDh48WDabTX379lVUVJRuv/32Sj1DdU2ZMkXXXnutfv/9d9ntdu3du1edOnUqdY6zmk71wAMPaNu2berevbt69+6tnJwchYWFaf78+ZX6vOqayTAMo66LcBVpaWmKiopSampqmbUATpaenl7hPPT6ZtSoUY7X8+bNq9K1ia8lSZKS7kms0nW7p5ac33pKUpWuO9nZ/pzPxrM1tN+G1DBrBgAAANC4paamasOGDQoODlbnzp3LrMP3119/6cCBA6VGEp7qu+++U+fOnR1rES5YsEA9evRQRESE45ylS5cqPDzcMYJs1apV8vb2Vrdu3Ur1ZbPZtHbtWh06dEhxcXHq0KFDqZFpzvrOzs7W4sWLNXz48DLr5knSwYMHtW7dOvn7+6tLly4KCio9rdput2vVqlXKz89XQkKCCgoKtGnTpgqf+ciRI1q3bp18fX3Vo0cPxyYsx33yySe64447dPDgwVIbbJzu2uzsbP3555/KyspS165dFRcXd9pn2Lp1q/bv369BgwY5jm3atEmHDx8uNdovJSVFx44dU2Liif82P3jwoNauXSs/Pz/16dNH69evl6+vr7p27VpuTZK0c+dODRkypNRz7dmzRxs2bFBUVJQSEhJKfW+n+7zqEoFgLSIQLItAsCwCQQAAAABAQ3ThhReqU6dOmjlzZl2XgtNgyjBwBiasmKeUTLPTtmTfbPnbAyVVLRAEAAAAAKAh+d///qePP/5YW7du1YcffljX5aASCASBM5CSaVZyplkJIeFl2nLcM5TjnqHEhTOcXhsfEq6Z/UY5bQMAAAAAoKHo06ePoqOjdd555yksLKyuy0ElEAgCZyghJNzpTlrhs2Yozy3b6TXJ5YwqBAAAAACgoenZs2ddl4AqIhBEvWV+d4IK01KctllSk+UdlVDLFVVNnKWrJClpWNkpw+WNGgQAAAAAADjb3Oq6AKA8hWkpsqQmO23zjkqQT2R8LVcEAAAAAADQ8DFCEPWad1TCGe0kDAAAAAAAgNIIBHHWTZibrBRzOWvpmXOUEB5QyxUBAAAAAAC4LqYM46xLMWcr2ZzjtC0hPEDx4YG1XBEAAAAAAIDrYoQgakVCeICS7im7uQYAAAAAAABqFyMEAQAAAAAAABdCIAgAAAAAAAC4EAJBAAAAAAAAwIUQCAIAAAAAAAAuhE1FgLMo2ZyjxNeSyh73zZa/l3sdVAQAAAAAAFwdgSBwlsSHB5bbll9kq8VKAAAAAAAATiAQBM6SmaMTym0LfPvXWqwEAAAAAADgBNYQBAAAAAAAAFwIgSAAAAAAAADgQggEAQAAAAAAABdCIAgAAAAAAAC4EAJBAAAAAAAAwIUQCAIAAAAAAAAuxKOuCwBQliU1WbunJpY5brVaVRTbTeHjZtZBVQAAAAAAoDEgEIRLmbBinlIyzZJKwjUPjxN/AvEh4ZrZb1St1ZLvlq3EhTPKHC+K6KVzglpr6rHdZdqsBzaq0IM/WwAAAAAAUH0kC3ApKZlmJWealRASXur48sN7tPzwHkdYeKqaDgv97YHltm3x9JNXmz5qPeyDMm3bn+xbYzUAAAAAAADXRCAIl5MQEq6kYZOUnp6u0NBQSaVHDp4quZzjZyLO0lWSlDSs7LRgZ6MGAQAAAAAAagqBICBVOPqPgA4AAAAAADQmBIJAA/JE0zht8/KXTzkhZW2vgwgAAAAAABoeAkGgAdnq6adtnn7q4qTtbExtBgAAAAAAjQ+BINDAtC/OV9KwSWWOM7UZAAAAAABUhltdFwAAAAAAAACg9hAIAgAAAAAAAC6EQBAAAAAAAABwIQSCAAAAAAAAgAshEAQAAAAAAABcCIEgAAAAAAAA4EIIBAEAAAAAAAAXQiAIAAAAAAAAuBCPui4AaAiSM81KXDjD6fGEkPA6qAgAAAAAAKB6CASB04ivIPBLCAmvsL26ygsgt3r5q0Nxfo3fDwAAAAAAuA4CQeA0ZvYbVav3qyhgbF+Up/bWwlqsBgAAAAAANDYEgkA9U1EAuf3JvvLw4M8WAAAAAABUH5uKAAAAAAAAAC6EoUaoU+Z3J6gwLcVpmyU1Wd5RCbVcEQAAAAAAQOPGCEHUqcK0FFlSk522eUclyCcyvpYrAgAAAAAAaNwYIYgaY0hKfC2pzPFkc44SwgPKvc47KkGtp5S9DgAAAAAAADWPQBBnXUJ4gOLDA+u6jEbDkpqs3VMTyxwvDOskN2//OqgIAAAAAAA0JASCqFFJ95QNqlBzPMI7lrvLsGHJl72W6wEAAAAAAA0PgSDQgASOfkGhoaFO20xv3FnL1QAAAAAAgIaITUUAAAAAAAAAF0IgCAAAAAAAALgQpgwDjchWTz8lLpxR5nh8SLhm9htVBxUBAAAAAID6hkAQaCTaFxc4PZ6caa7lSgAAAAAAQH1GIAg0ElOP7ZYktR4/q9RxZyMGAQAAAACA62INQQAAAAAAAMCFEAgCAAAAAAAALoRAEAAAAAAAAHAhBIIAAAAAAACAC2FTEaCOJJtzlPhaktO2+PBAzRydUMsVAQAAAAAAV0AgCNSB+PDActuSzTm1WAkAAAAAAHA1BIJAHaho9F95owYBAAAAAABqAmsIAgAAAAAAAC6EQBAAAAAAAABwIQSCAAAAAAAAgAshEAQAAAAAAABcCIEgAAAAAAAA4ELYZRiNzoQV85SSaXbalpxpVkJIeC1XBAAAAAAAUH8wQhCNTkqmWcnlBIIJIeGKJxAEAAAAAAAujBGCaJQSQsKVNGxSXZcBAAAAAABQ7zBCEAAAAAAAAHAhBIIAAAAAAACACyEQBAAAAAAAAFwIawgCLiA506zEhTOctsWHhGtmv1G1XBEAAAAAAKgrBIJokCasmKeUcnYSTs40K4GdhB0q2lW5vN2YAQAAAABA40UgiAYpJdNcbvCXEBJeYQjmaioa/VfeqEEAAAAAANB4EQiiwUoICVfSsEl1XQYAAAAAAECDwqYiAAAAAAAAgAshEAQAAAAAAABcCIEgAAAAAAAA4EJYQxBnnfndCSpMS3HaZklNlndUQi1XBAAAAAAA4LoYIYizrjAtRZbUZKdt3lEJ8omMr+WKAAAAAAAAXBcjBFErvKMS1HpKUl2XAQAAAAAA4PIYIQgAAAAAAAC4EAJBAAAAAAAAwIUQCAIAAAAAAAAuhDUEcdZNCWqtrZ6+8lk4w2l7fEi4ZvYbVctV4bjkTLMS+W4AAAAAAHAZBII467Z6+mqrp5+6OGlLzjTXej04IT4kvNw2vhsAAAAAABonAkHUivbF+UoaNqnM8fJGpqF2VDT6j+8GAAAAAIDGiTUEAQAAAAAAABfCCEHUOdawAwAAAAAAqD0EgqhTrGEHAAAAAABQuwgEUadYww4AAAAAAKB2sYYgAAAAAAAA4EIYIQg0IpbUZO2emljmuE9kvMLHzayDigAAAAAAQH1DIAg0Ej6R8U6PW1KTa7kSAAAAAABQnxEIol4rbwfi5EyzEirYkMQVlTcC0NmIQQAAAAAA4LoIBFFvVbQDcUJIeIXtAAAAAAAAcI5AEPVWRTsQAwAAAAAAoHoIBIF6KNmco8TXksoct1qt6hbVVDNHJ9RBVQAAAAAAoDEgEATqmfjwwHLbNh7Ol4cHf7YAAAAAAKD6SBZQxoQV85SSaXbaFh8SzlTes6yi0X99X15We4UAAAAAAIBGya2uC0D9k5JpVrKTQDA501xuUAgAAAAAAICGgRGCcCohJFxJwyaVOpa4cEYdVQMAAAAAAICaQiCIKknONJcJBoO83eVjscni7e40NNzq6af2xfm1VSIAAAAAAAAqQCCISosPCa/Wde2L89W+uKCGqwEAAAAAAEB1EAii0srbTGTUO0slSd4WW5lpxpK0e2riWa0LAAAAAAAAlUcg2IhVtFuwxI7BOD1nU8SP4/cDAAAAAEDDRCDYiB3fLTjByVRfZ7sIAyeraIo4vx8AAAAAABouAsFGztluwRI7BuP0Khr9x+8HAAAAAICGy62uCwAAAAAAAABQewgEAQAAAAAAABfClGFU2oS5yUoxZ5c53lySqfbLAQAAAAAAQDUQCKLSUszZSjbnKCE8wGm7mwztnppY5rglNVneUQlnuzwAAAAAAABUAoEgqiQhPEBJ95QO/UYte/nvV4bTa7yjEuQTGX+WKwMAAAAAAEBlEAiiBpnUekpSXRcBAAAAAACACrCpCAAAAAAAAOBCCAQBAAAAAAAAF8KUYReWnGlW4sIZTo8nhITXQUUAAAAAAAA42wgEXVR8BYFfQkh4he0AAAAAAABouAgEG7gJK+YpJdPstK2ikX4z+406m2UBAAAAAACgnmINwQYuJdOs5HICQUb6AQAAAAAA4FSMEGwEEkLClTRsUl2XAQAAAAAAgAaAEYIAAAAAAACACyEQBAAAAAAAAFwIgSAAAAAAAADgQggEAQAAAAAAABdCIAgAAAAAAAC4EHYZBhqYZHOOEl9LctoWHx6omaMTarkiAAAAAADQkBAIAg1Ix2Z+8vBw/mebbM6p5WoAAAAAAEBDRCAINCAvXBqn0NBQp23ljRoEAAAAAAA4GWsIAgAAAAAAAC6EQBAAAAAAAABwIQSCAAAAAAAAgAshEAQAAAAAAABcCIEgAAAAAAAA4ELYZRhwAZbUZO2emui0zScyXuHjZla5z+RMsxIXznDaFh8Srpn9RlW5TwAAAAAAcPYRCAKNnE9kfLltltTkavUZHxJebltyprlafQIAAAAAgNpBINgATFgxTynlhCzJmWYlVBDOABWN/itv1ODpVDT6r7xRgwAAAAAAoH5gDcEGICXTXO6oq4SQ8ApHawEAAAAAAAAnY4RgA5EQEq6kYZPqugwAAAAAAAA0cASCAGrcyRuOWK1WeXic+FcNG44AAAAAAFC3CAQB1Cg2HAEAAAAAoH4jEARQo04d/Zeenq7Q0FBJbDgCAAAAAEB9QCAIoFadPJ34VEwnBgAAAADg7CMQBFBrmE4MAAAAAEDdIxAEUGsqGv3HdGIAAAAAAGqHW10XAAAAAAAAAKD2EAgCAAAAAAAALoRAEAAAAAAAAHAhBIIAAAAAAACAC2FTkXpiwop5Svl7l1Wr1SoPjxNfTXKmWQkV7M4KnAlLarJ2T0102uYTGa/wcTNruSIAAAAAAHA2EQjWEymZ5nKDv4SQcMXXYiA4YW6yUszZZY4nm3OUEB5Qa3Xg7POJjC+3zZKaXIuVAAAAAACA2kIgWI8khIQradgkpaenKzQ0tM7qSDFnOw3//lv0ptrt3KvdU/1LHTepuQyZarNE1JCKRv+VN2oQAAAAAAA0bASCcCohPEBJ95QOhHZP/acsqTslJdRNUQAAAAAAADhjBIKoEu+oBLWeklTqmDFqVMn/MkoQAAAAAACg3mOXYQAAAAAAAMCFMEIQaESSzTlKfC2pzPH48EDNHM1UbwAAAAAAQCAINBrx4YFOjyebc2q5EgAAAAAAUJ8RCAKNRHkjAJ2NGAQAAAAAAK6LQLAOjPxpjrzDQkodS840KyEkvI4qAgAAAAAAgKsgEKwnEkLCFV+LgeCEuclKMWc7bUs25yghPKDWagEAAAAAAEDtIRCsA19ddIsiIyPrtIYUc3a5wV9CeEC569EBAAAAAACgYSMQdGEJ4QFKuiexrssAHJIzzUpcOMNpW3xIuGb2G1XLFQEAAAAA0PgQCAIolyU1WbunOg+NfSLjFT5uZo3dq6Ip88mZ5hq7DwAAAAAAro5AEGWY352gwrSUMsctqcnyjnK+ky0aH5/I+HLbLKnJNX6/ikb/lTdqEAAAAAAAVB2BIMooTEtxGv55RyVUGBKhcalo9F95owYBAAAAAED9RyAIp7yjEtR6SlJdlwEAAAAAAIAa5lbXBQAAAAAAAACoPYwQBFxAsjlHia85H/EZHx6omaNZGxIAAAAAAFdBIAg0cvHhgeW2JZtzarESAAAAAABQHxAIAo1cRaP/yhs1CAAAAAAAGi/WEAQAAAAAAABcCCMEAdQo87sTVJiW4nhvtVqV7XHiXzU+kfEKHzezyv0mZ5qVuHBGmePxIeGa2W9U9YoFAAAAAMAFEQgCqFGFaSmypCbLO6rsVGVLanK1+owPCXd6PDnTXK3+AAAAAABwZQSCAGqcd1SCWk8pWZ8wPT1doaGhkqTdUxOr1V95IwCdjRgEAAAAAAAVYw1BAAAAAAAAwIUwQhBAg1be2oKSlDRsUi1XAwAAAABA/Ucg6KKu3/uCIgt2affUwDJt5a3/BtQ35a0tKLG+IAAAAAAA5SEQdFGRBbsUkb9TUrcybd5RCfKJjK/9ooAqqmh3YdYXBAAAAADAOQJBF7bfL049/t74AagqS2qy001CGGEKAAAAAED9RiAIoMoqGkHKCFMAAAAAAOo3AkEAVRY+bmZdlwAAAAAAAKqJQLARmzA3WSnmbKdtE4ts8vdyr+WKAAAAAAAAUNfc6roAnD0p5mwlm3Octvl7ucvPk0AQAAAAAADA1TBCsJFLCA9Q0j1lN37YPTWwDqoBAAAAAABAXSMQbMSu3/uCIgt2OQ3/2AkWxyWbc5T4mvPdpuPDAzVzNL8TAAAAAAAaEwLBRiyyYJci8ndK6lamjZ1gIZUEfuUpb7o5AAAAAABo2AgEG7n9fnHqMcX56C+gotF/5Y0aBAAAAAAADRubigAAAAAAAAAuhBGCAGqVJTVZu6eW3ehGknwi4xU+bmYtVwQAAAAAgGshEARQaypat9KSmlxum/ndCSpMSym3T0JEAAAAAAAqj0AQQK2pKLgrb9SgJBWmpTjdGbuiEBEAAAAAADhHIAigQfCOSlDrUzbIqShEBAAAAAAAzhEIAihXsjmnWrsNx4cHVriDMQAAAAAAqDsEgg3chLnJSjFnO22bWGSTv5d7LVeExiI+PLBa1yWbc2q4EgAAAAAAUJMIBBu4+FWP64Jj250GfxHWPcr0b1cHVaExqO4Iv+qMKAQAAAAAALWHQLCBiyzYpQjrHjWN6eaktZtaVbCrKwAAAAAAAFwPgWA9YX53ggrTUiRJVqtV2R6lvxqfyPhyd2jd7xenHlMYlYX64+S1B61WqzxO+j2zviAAAAAAAHWLQLCe2Lh+lUKObdN+vzgZhiGTyeRoi8jfqf3mbD2fUzb0Y51A1DcVrT14uvUFLanJTncOtqQmyzvKeYhY3jWFYZ1OUykAAAAAAK6JQLCeyC+26YhHrP7X4fUyI6oe3nK3IvJ36uEtd5e5jnUCUd+cOvovPT1doaGhkkrWFyxv5+Lrs8LUzjdOcU769I5KkI+T6e/Ojh1nWPKrVjgAAAAAAC6CQLAWWa1WSdKn9w9QU3/PUm3N8/eowC9Wn46MVWZmpkJCQhxthz7vIovZW2FO+rT4dVJIeAelpaWdzdIrlJ9/InipyzqqKjMzUwUFBXVdRpU09JpbexXI4lMgS2bZZ5iYfaUkqac9yHlH+yQ9/eUpBwf//U9Z2cc+V1pamlq2bFkqYAcAAAAAwNWZDMMw6roIV/Hnn3+qd+/edV0G4FJSU1MVGRlZ12UAAAAAAFBvEAjWosLCQqWkpKhZs2bljlgym83q3bu3/vjjD4WHh9dyhdVDzbWDmquHEYIAAAAAAJTGfyXXIh8fH/Xq1atS54aHhze4UU3UXDuoGQAAAAAAnAm3ui4AAAAAAAAAQO0hEAQAAAAAAABcCIFgPRMYGKgnnnhCgYGBdV1KpVFz7aBmAAAAAABQE9hUBAAAAAAAAHAhjBAEAAAAAAAAXAiBIAAAAAAAAOBCCAQBAAAAAAAAF0IgWIusVqvS0tJktVrruhQAJ+FvEwAAAADgSjzqugBXcvDgQUVFRSk1NVWRkZHlnpeRkaGmTZvWYmVnZtSoUY7X8+bNq8NKqqY+fs6jfn5PX+5NkSQdve4phfr4l2p3VvOmrIPq/NULkqQJHc7T6+eNUmX1WPCy1qbvVxMPb+WM/U+Vat2SdVgdv3peknRX+756o99op+fVx8/5VMf/NpOTkxUfH1/X5Zx1DeE7qYzdUxMlSa2nJJXbFnT3ghp51vr+77nG8p0CAAAAqB0EgvUQGz/Xjob4OVMzakJ9/E4mzE1WijnbaVt8eKBmjk6oVr/18VnPBld5TgAAAAA1gynDQD1hGIbSLXln1IfNXvlQILuoUEcLq38/QwQQqDkp5mwlm3PKHE8255QbFAIAAAAAqocRgkA9YBiGHl79rX45uEuS1MzHX4FePpW6tplPE5lkkiFDX+1L0Qu9L1eAZ8XXpuVladiS2dqXlyVJaukbUOWa16SnOV439far8vXAqRLCA5R0T2KpY4mvlZ0ODAAAAAA4M4wQBOqBJ9cv1gsbfpEkuZlMev28q+Tp5l6pa5v5NNHYuO6SpCOFeZqWsqzC89en71efb6crOdP89/X++vjC66tc88c71zlej4w+t8rXAwAAAACAukEgCNSx55J/1tPrl0iSTDLpvfPHaHRslyr18e/uQ+XtXjLg98WNv+hA/rEy5xRYi/VCyjKd/93rOpBfMgWzfVAzrbr8XvVqFl2l+x0pzNXiA9skSW0DwtQzLKpK1wMAAAAAgLrDlGG4pOKM/cr437XK9fVXxB3vySO4ZZ3U8fa23/XPNd853r/Zb5RujOtR5X6im4Tovo6Jen7DMuVbi/XkusWa1f9qSZLVbtOc7X/qqfVLtP+koPDClm305aBx1ZruO3dPsmyGXZJ0fVw3mUymKvcBVMb1e19QZMEu7Z4aWKbNkpos76jqbTYCAAAAAK6MEYJwOfZii9JmjFLxzuXK27BYe5+7SNbsI7Vex9d7N+iuFXMd71/pfaXuaN+32v09knCRI9ybvf0Pbcw8qM93r1enr6bpzhVzHWGgu8lNkzr21w9D7qz22n8f7zoxXfi61t2qXTNwOpEFuxSRv9Npm3dUgnwi42u5IgAAAABo+BghCJdz6OPJKtj5u+O95cAm7X3+YsU8/KM8ApvVSg2/HtypMb98KLtRslPvlC4X677O559Rn8HevprS5WI98McC2Q1Dvb55VQW24lLnXBPbRf/uPlTtgqr/nPtyM5V0aLckqXtohDoENz+juoHT2e8Xpx5T2FwEAAAAAGoKIwThUvI2/azMn2eWvPHyk2dYjKSSqYc7/q+NDn78gIqO7j2rNeQWW3TVz+/JYrNKku5s11dPd7ukRvq+u0M/xTYJkaRSYeAlEe21Zvj9+mzg2DMKA6WSac7HXd+G0YEAAAAAADQ0jBCES8lZ/63jdeBV/1XznsO155kLZM1Ilb0wVxk/vKyMJdMV2OtqhQ37h3xiutZ4Dd+lbVa6JV+SNCyyo14/76oaW4PP291D03pdrquXfiBJ6tssRs/2uFQDwtvWSP9bsg7ruZSlkiRPN3eNYbowakh5awVG5O/Ufr+4OqoKAAAAABonAkG4lIIdK0pemNzknTBcXs1i1eaJP3R04X+V+cvbMix5kt2m7N8/VfYfnyv0sofVbOSTcvP0rrEavty7wfH6kYRBcner2YG6o2O7aOWwYNkMu/o1j62xsNFu2HXHii9UZLdJkh5NGKQI/6Aa6Rs4sVZg6ZB5v1+c0nzb1E1RAAAAANBIEQjCZdiLClSwZ60kyTsqXm4+AZIkj+CWannDK2o24gllLpuljMXTZc06IBl2pS/8r3LXf6NWd7wn39ZV3/1Xkgy7XVm/zlbOum/k1WOkFqZulyS19A3Qec1jaubhTtH3LPQ7a+sqx9qBHYOa65GEi6rVz7GiAm09dkRbjx2RySRdGd1ZAZ4+NVkqGihnawWOfa3k/d11URAAAAAANFIEgnAZhXvWSH+vq+fXtl+Zdnf/EIUN+4dCL5msjB//p8NzH5VRXCjL/o3a/XQfhQ1/VM2umCKTh1fl75m2QeY5d6pgx0pJ0rLUjcqNHylJGhF9rtxMDWMZz/15x/Tw6oWSJJNMerv/NfJ2P/2/PnblpOuzXX8qdVuetmQd1pZjR2QuyC51Tqi3n/4RP1ATO/aXXxU+WwAAAAAAUD0EgnAZ+dtXOF77tu0nWznnmTy8FDp0spp0uUwH3hqngp2rJLtNR+f/W7nrvlGrO96VT3SXCu9lLyrQkfn/Vvr306S/Nw+RpB/DznG8vnDLj7Kee0Gt7WxcXUU2q8b++rFyii2SpIkd+6lfi9gKrzlckKOn1y/Rm1tXyWrYKzw33ZKvh1cv1Isbf9Uj8YN0V/u+8vHwrFathdZiZRcXOt439w2oVj84OybMTVaKOdtp28Qim/y93Gu5IgAAAABwTQSCcBmO9QMl+bU9TzmnOd87vL1ipyQp/fsXdeTLf8mwFqlw33rterKXgvpeJ7/2F8i3TW95R3SSye1EkJG78UeZ59yl4iO7HMfsUQk6cuF4Ld27RZIUWFyojitmacefn6r5qKkKGTRBphpeS7AmGIah25d/oaUHd0qSovyD9UyPS8s9v8hm1fMpy/RcylLlWi1l2qP8g9U+qJk6BDVX+8BmWp9xQO/uWC2bYdehghzd/8d8TduwTI93Haw72vWp9PqHhdZiPbLmO72xdaUKTwpgjVteqNoD46xKMWcr2ZyjhPCyQa2/l7v8PAkEAQAAAKA2EAjCZRTs+kOS5B7YXJ7N20gZGae9xuTmrrBhD6tJl2E68NbNjmnHx5a/r2PL35ckufk0kU9sT/m26a08S77W/v65dviHamfrRO0MaK7dYXHaazdkpO2U3EtGvg08lipPwy57fpYOfjBJhXvXKfyWN0sFi/XBT+bt+mDnGkmSn4envho0rtz1/g4V5GjUz+9p+eE9jmOBnj66J66Prjqnm9oFNVMTJ5uz/DNhkJ5ev0Qf7Voru2Fof/4x3bVirjZkHtSrfa6sVCj40J/f6H9bVpz2PNS9hPAAJd2TWOb4qbsLAwAAAADOHgJBuAzDWiRJcvdvWuWdd30iO6v1v1bq6ML/6ui3/5VRlO9os1jyteRomuZ5BCsptLVsPceWvthedsrs/aOeVEizcGUumyUZhrJ+nS1r9mFFjP9I7vVommtTLz/H6yKbTcsO7tChghxF+gcpyj9YwV6+MplMWns0TSN+flepeVmSJE83d03s0E+PdblYprxChYaGlnuPtoFhev+C6/RowkV6cv1ifbZ7vSTptc1JMmTo1T5XVrjWYrHdpo92rXO8vzyqo3zdqzflGPVTsjlHia8lOW2LDw/UzNEJtVwRAAAAADRsBIJwGe4BzWTLTZct50iVr80uLNZ3mw/ry2OXannLrupm2qt4vz3a5Zuhn3z9lF7BLrlNvf3UObiFOgW3UJemrTSgZZw6BreQ2ryhJl2GKe1/V8sotih3/Tfa8+/zFHX/Ank1b3Mmj1pjuodF6rGEi/Sf5J9kNex66M9vS7X7e3gpyj9Ye3MzVfD3hi2xTUL09UW3qEvTVpKk9LzCMv060yG4uT4dcKNGxcRrzC8fym4YmrF5ufKtxZrVb7Tcy5lS/evBXcoqKpAk3RTXQ+9dcF11Hxf1UHx4+SMHk82nm/gPAAAAAHCGQBAuwyOwuYrMW2TLTZdx0jpz5TmSa9GCjYf0VYpZS7YdVZHNLskuBR/WgZBMLfSXpKalrgm1GuroF6VuUR00ODpWvZq3UgvfgHJHJAZ0G67o/1uitNeuki3naMmOxk/1VuSkufLvOOCMn7kmPN39Eu3MSdenf4/cO1metUhbjh12vB/QMk5fDLxJYT7+1b7f1a27yJChG375WFbDrne2/6F8a5Hev+A6eTqZUj1/30bH65Ex8dW+L86+6/e+oMiCXU6nBz/iEagdwZHyWTijdIOvFN8jXDP7jSpzTXmjBgEAAAAAFSMQhMtwDzixm68tN13l/fy3H8nVxC9T9NP2o7IbJzX4HZNabZN88ktfYHeTssOkzHCl5wUpSSYlrS3WDNN2tW9mVq+oYPWMClLv6BD1jgqWm1vpcNC//flq/cSfSn31SllSk2XLTdfeaYPV8obpanrRhBp6+upzM7np4wtv0H2dzte27CNKzctSal6W0vKOOV7bDEO3teut53oOcxraVdU1rbvK191To5e+ryK7TZ/uXq8CW7E+GzBW3u4nvjfDMDR/3wZJko+7hwa3Oqe8LlEPfNPMW2bveHk4CYzXeJeEhP1POZ6caa6FygAAAADAtRAIwmV4BDZ3vLZmH5b8WpU5Z+WeDA2f/YfS84tPHHQvVkDMPuX4pZU6t2NgS/Vu0lG++S21sbBQ66zHlCubo90wpC2Hc7XlcK4+WFNybf/YEH10Q3fFNPUr1ZdXs1i1nrJc+98cq5y1X0s2qw6+f7csaSlqecOrMnnU7Zp4JpNJfZvHqG/zGKfthmFUeV3G0xke3VkLB9+mK3+ao3xrsebv26grfnxHX100Tn4eXpKkvzIOaN/f6xYObtVO/k42LUH9sde3ifb4Bah7eNsybf0lxYeUHQmYeOqIQQAAAADAGSMQhMtwPykQtOUcKRMIfpVi1vUfrlWhtWQTkLhQP3XpWKileeuVWXxiVGC/5rF6pfcV6tUsutT1NruhbUdytSbtmFanZml1apbW7j+mguITm4os35Opri/9qg+u76bLO7Uodb2bTxNF3jNPR756QkcXTJUkZf48U5a0DQrqd4O8WnWS3aeFVMEGHXWlpsPA4y5u1U4/DLlTly15WznFFi0+sE1DF7+l7wffLn9P71LThYdHdTorNaBmxebnKGnYpLouAwAAAABcGoEgXIa7f4jjtTXnqHRSHvfFXwd03YdrZft7jvClHcMU2WG/3tq+ynFOiJevnu91uW49p5fTXW/d3Uzq2CJAHVsE6MYekSX3sdm15XCu/kzN0rM/7dD2o3nKKijW6PdWa/PDA9U6tPRIQZObm5qP+re8I8/VgbdvkVFUoPxtvyl/22+OczICmsm7VUd5t+okn9juCuh5lTya1L+QsKYktmitny65S5csfkuZRQX67dBuTduwTE92u0RJh3c7znvoz2/1+5F96t0sWsfjyTva962bogEAAAAAqMecb9sJNEJFB7Y4XnuGnBgd+GWyuVQYOLZPc2WHrykVBt4U10NbR/1Dt7fr4zQMLI+Hu5vODQ/ULb2jtfaBC3Rt15L7Wqx2PfLd5nKvC+pzrWIf/U2eYWWn6Npyjih/66/KXPqGzHPu1LZ7w5U6/Splr/lahrWo0rU1JL2aRWvZpRPk8fdn/8HOtTIMQ+e3aO04J7u4ULO3/6G7VszVnX//AwAAAAAAymKEIFxG/vblkiSTh5d8YnuqICdP8zcc1LUfrHGEgTed10y/m5Zp6+EjkiRfd0/NTrxG17Xpdsb3b+LtodnXdNFvuzJ0ILtQn60/oPvOb63zYps6Pd+3dQ+1fW6bCvaskeXAZln2b1Lunr9kHN2h4qN7TpxoK1bOmq+Us+YruTcJVWDf6xTc/yb5tO551qby1oWEpq10SUR7LUzbrF056Vp1ZK/+1WWwLgo/Rx/sXKPPdv+lrKKCui4TAAAAAIB6j0AQjZrVZte+rALZ87NUtL9kN1ojoqu2Z1n1y5YjmvTtDln/DgPH9AnRMvuPjk0qYpqEaP5Ft6hL07Kbj1SXv7eHnrmsg8Z9ul6SNHn+Rq28N7Hc4M7k4SW/tufJr+15kqT09HSFhobKbsmTZf8m5az9WlnLP5A1I1VSye7JmT/OUOaPM+QT010Rd38i75btaqz+unZjXHctTCsZWfnSxl/1xcCb1L9Fa/Vv0Vqv9hmhpeYdSrfkn6YXAAAAAABcG4EgGq2kXeka8+Fa7T9WqMSiNXrTKAn+5hxupReeW1rq3JE9m+hn2486XJgrSeoU3EJLLrlTrfyCaryusT0i9epvu7Ruf7Z+35elz9Yf0JhuEVXqw83bX75tesm3TS81u+rfyt/6i7KS3lfO6rmy//0MhXvXavfTfRU1aa78Ow2q8eeoC6NiExS1eqFS87I0b0+Kth07onZBzSRJ3u4eGhrZoY4rxIS5yUoxZzttsxmG3BvRqFUAAAAAaKhYQxCN0idr9+uiN1Zp/7FCSVK34hPr9a3z6Fjq3Mu6e+tn20+OMLBXWJR+vfTusxIGSpKbm0kvXtHZ8f6fCzersNhW7f5Mbm7y7zhQEXfMUbvpBxVx14fyjkqQJNnzMrX3hUuUuXTWGdddH3i6ueuhcy+UJBkyNG3DsrotCGWkmLOVbM5x2uZuMsnNjUAQAAAAAOoaIwTR6Dz/8w79Y+GJADCxdVNdumuP9Pfycp37XKw2PqGyFFrUKtKu6WnzlW8tliQNaBmnBRffogBPn7Na48C2YbqycwvN33hIezML9PKvu/TIReeccb9u3v4K6neDAnqM0P5ZNyln9ZeSzSrzu3fJcmCzWlz3okxuDfv/D3DbOb319PolSrfk670dq/Vk1yGK8D874S2qJyE8QEn3JJY53vON96vVX3KmWYkLZ5Q97pstf3ugpLL3AgAAAACUj0AQjcpfB46VCgPvv6C1noo7qLQ1ayRJns3j9OrYkumz6enpunzlx44wcHhUJ302YKx8PTxrpdbnh3fSws2HZbUbenzRVhmGdGffaIU18T7jvt28/RU58Qsd+fJfOvrNM5KkjMWvyF5wTOG3viWTm/sZ36Ou+Ht66872ffVs8s8qttv0k3m7bmrbs67LcikVTQtONucoITygxu4VHxJeblu+m/MaAAAAAAAVIxBEozJ1yXbH66eHttc/Ety166lrJHvJlNyQgeMd7YZhaGPWQUlSm4BQzRt0szxrMShr16yJ/jGorf7z43ZZ7YYe+36Lnly8VSPPDdftfaJ10TlhZzS90uTmpuaj/yOv8A46MPtWyWZV1m9zZLdaFHHHezK5V+7P37AWq+joHlmzDsg3tofcfJpUu6aasj37qON15Fma2o3yHZ8W7Cz4SwgPUHx4YI3da2a/UeW2Bb79TI3dBwAAAABcCYEgGo2NB3M0N9ksSWoT6Ka7fVZp7wtPy56XKUkK6DlKoUMfcJyfbbUop9giSWof2KxWw8Djnr6kvQ7nWvTWqn2SpGKboc//OqDP/zqg2Ka+uq13tG7pHaWIIN9q3yO4/1i5+wUrbcZoGdYiZa/8WJa0DfJqHid3/6Zy9w8p+d8mTeXmEyjrsYMqOrxDRYdK/ilO3+sIVD2btVH0A9/Ku1XH09z17Mm05Oub1E2SSsLAAeFxdVaLKytvWnBtyy+yKfG1pDLHHzZny8/TXd2cXGN+d4IK01LK7dMnMl7h42bWYJUAAAAAUL8QCKLR+M+P2xVrTdPVhT/ohpxfdOjtLEebd3QXRdz5Xqn181LzjzlexzQJqc1SHdzcTJp1dRc9MugcvfPHPr3zR6oOZJdshLIno0D/WrRVTy7epvvOb60nh7Sv9n0Cug1X1P3fKHX6CBlFBbKkJsuSmlzlfoqP7NLuf5+nyLs/V5P4IdWu50x8sSdZFptVknRDXHe5mRr2moioPn+vv0P8grJteUXlb9RTmJYiS2qyY/Odk1Xn7wIAAAAAGhoCQTR4hrVIW5Z+qsHLXtCU4rKjfnzj+ipy4mdy8/YvdTy14MT6Y3UVCB7XOtRP/760g54Y0k6Lth7R26v26tvNh2WzG7LZDb30yy59tv6A/j0oWuP6N5XJVPWpxE3ihyj6we9lfne8isxbKnWNe0AzebVoK6/mbWU5sEmFe9bInn9M+166TC1vnK6mF91d5TrO1Ac71zhej43rIUnKKS7Ut6mb9W3qJmVY8h3t3w+5o9brQ+2JCy35m04aVnak4oKJFY/49Y5KUOspZUcW7p5a96MeAQAAAOBsIxBEg2XLzVDm0jeV8eNrMrLM6nNSm8nLT0HnXa+QgXfJt7XzDSf2F9T9CMFTebi76fJOLXR5pxYyZxfqrVX79PzSHcorsmn/sULd+tU2fb45UzNGxisuzP/0HZ7Cv8OFavvfzTKsxbLlZ8mWnylbboZseZmy52XIlp91UggYJ/eT1uezFxXowNu3Kvv3TyW7TQffn6gi8xa1uO6lSq9HeKZ25aQr6dBuSVJcQKjWZezXY2u/16L9Wx2jBgEAAAAAQMUIBNHgFO5dr8ylbypr+fsyivJLte30jFWvqyer2fk3lwqznNmbdyIQjPYPPhulnpHwQB89PqSdbukVpfvnb9CXKSUboCzackSdpy3TtV1b6eourTSsY/Mqjxg0eXjKI7CZPAKbVfoaNy9fRUz4WF7h7XX066ckSRlLXlPR4Z2KuvcrmTy8qlRDdczdc2I6586cdI399ZOzfk9UTUXr8xkBsTJ5+9VyRQAAAACAUxEIokGw5R9T9up5ylz6pgp3/VG6TW763vt8feJzmW4YcZWGD2p72v5yiy365qRps60DmtZ4zTUlKsRX88b10nebD+nuuX9pb5ZFFqtd769O0/ur0/TYxedo6qUdaqUWk8mk5iOflHfL9jow+xYZxRbl/vWdDn/5hFpc8+xZv/9vh3Y5PR7TJESjYxI0OjZBCU3DZVL1d2fGmalofT6Tt1+ZqfsAAAAAgNpHIIh6yVaQo/xtScrfslR5m5eqcM9aybCXOifPzV+few/WRz7DZXZvpq6tAnV3Yuxp+86w5GvYktlK+3sNwSGt2qnVaUYT1geXdWyh3+7oqlnrMvRa0m4dKyyZIvufH7erZYC3JiW2rrVags67Tp5hMdr73CAZxRalf/ec/DtfrCadLzqr900vLD0idFRMvP6ZMEg9QiOrta4izo7y1ufzWTijDqoBAAAAAJyKQBD1RtHhXcpc9pbytyxVwe7Vkt35LqGpgfF6wz5Ii7wTVWjyliSN7RGpV0d0lp9XxT9pc362hvwwSxuySqbfhnn7681+o2v2Qc4iP093/fvSDnp8SDvNWrlXk77aIEm69+sNahngrdFdWtVeLef0U4trX9DBD++RDENpM0Yr5p8/yzem21m7Z1ZR6e1kbz2nt3qGRZ21+6Fhi8jfqYzXhinbo/S/F8obwQgAAAAAroJAEHXOMAxl/TZHBz+4p8yagJIkk5u8ortqvW9XPXWkqzaYYh1NfWNC9MqVndUn5vSbguzOSdfgH2ZpZ066JKmVT4B+unSCYuvxdOHyeLq7aWJia2UWFOtfi7bKMKQbPlqnMH8vDWgbVmt1hFw8UXmbflLO2q9lz8/SvucHK+aRZfKJPPes3O9YcWGp97EB9WMzmMZowtxkpZiznbYlm3OUEB5QyxVVTZpvG0lSoJM276gE+UTG125BAAAAAFCPEAg6YbVa9cMPPygzM1MXXHCBoqOj67qkRsuWlynznLuU/ecXJw6aTPKJ7iq/DgPkec4F+iQrVv9OOqTDR4t0fGm4iCAfPTeso67rFiE3t9NPFd2UdVCDf5ilA/klAUfbgDB90ecadQhufjYeq0bY7HaZC7JVZLepdZOmTqfEPnbxOTqQXaiZK/aqyGbXlXP+1G8T+yuhlbMYpOaZTCZFTPhY+14apvzNS2XLTdfe5y9W7KO/yrtluxq/36kjBGP8CQTPlhRzdrnBX0J4gOLDa+c3Vl0fxzykZHOOOgX5ysOj7P+pi28SqJl1UBcAAAAA1AcEgqc4fPiwLrnkEuXk5KiwsFAHDx7U+PHjNW3aNPn6+tZ1eY1K3pZftf/NG2XNSHUcazr4HjUb8aRsPsF65499mvr9du0/dqLdx8NNDw9sq4cHxsnfu3I/39VHUzV08VtKt5SMPkwICdcPQ+6QZ0FxzT5QNZnzs/Xjge3ak5uhPbmZ2pObob25mdqXl6Xiv6dNh/sGalB4W/UObKkrvbsqpknJqEaTyaTXRsbrUI5FX6YcVHahVUPfWqWV9yQqpmnt7Obq5uWr6MnfaO+0S1Swfblsxw5p738HKfbRX+XVvE2N3afYblO+9cR3FubtL39P7xrrH2UlhAco6Z7Eui6jWo4HllartUxbsjmntssBAAAAgHqFQPAUd911ly688EK98sorMgxD7733niZNmqR169bp+++/V2Bg5UfFZGdnKzv7xJQ7s9l8NkpukDJ/fUfmd+5wbBTiHtBMre54V3mtB+m5Val6c9Va7cs8MRrMzVSyTuDTQ9srOqTyQdeqw3s1ZPEs5RRbJEnnNYvRwsG3KcTbT+kF6TX7UNUwb0+yxv76iQpsFYeT5oJsfbRrrT6SdN/679Q+qJlGRJ+rkTHnqldYlD66obuGzFql33ZlyJxt0dC3ftdfD14oLw+3WnkON29/RT/4nfY+P1iFu/6QNXO/dv/7PAX1GSN73AAZfUec8aYfx4qYLtwQTAlqra2evk43EEnONCshJLxW6pg5umSNwPT0dIWGhpZqS3yt7IYnAAAAAOBKCARPYrfbtXDhQv3555+SSkZfjRs3TvHx8RoyZIiuuuoqLV68WG5ulQtZXnrpJT311FNljmdmZlY42vDkELGhSU+vXMiW/sN0Rxjo1X6QAq97TdM2FOvZD3+U1W6UOndEx1D94/wonRPmJ9kLlJ5e4KzLMswFORr2y2xHGDiwWWu92+sq2XMLlJ5bUOef8/bcdN1cThjYzMtPUX5BivILVpHdqhXpqaXWz9t67IieS1mq51KWqpmXny5uEadr+7bWoVxPbTtcrC2Hc/Xt+t26sHVwLT6RFHDrx7LOHCnr/hTZsg8rY8l0acl05f92iYJueENuPtVfdy7DUnp9yWjvwNP+3k4NgnD2bfX01VZPP3Vx0pYQEq74WgoEAQAAAADlIxA8iZubmwICArRy5Up16XLiP2d79OihBQsWaODAgXrttdd03333Vaq/Bx54QLfffrvjvdlsVu/evRUSEnLaoKKhBhmVrTujIFOS5BESobh/LtFXGw7p38tWO9rd3Uy6snMLPT6knbq0CqpWLXf+/K0y/l5z7tKIDvrqonHydi/9k6+rz7nQWqwJSe8p7+8wcET0ubqzfR/FNmmqaP/gMlNhbXa71mXs1zc7krXiWJqWmXfK+negeqQoX5+kpuiT1BS5N3eT/AKlnFDtKGitq0LjavfBQkMV8sjPOvj+ROWsmy/j7zC2aOMPyn59uKLu/0ZezWKr17VC9UjCID2b/LP8PDz1QJeBDfbvpLFrX5yvpGGT6roMAAAAAEA5CARPccMNN+iJJ57QlVdeqfDwEyNZ+vfvr8mTJ2v69OmVDgQDAwOrNMXYlVhzS0Z2eQQ2166MAt3y2XpH24MXttHkC9soIqj6azYu2LdRX+5NkSRF+AXp0wE3lgkD69LDqxdqfcYBSVKXpq30yYU3yMfDs9zz3d3c1DMsSq1NfnoqNFRZlgItTNusb1I3adH+LY7ptDbZpSZZUpMsPbJjl6yBQ/Vw/AB5uLnXxmNJkjwCwhQ58TPZLXnKWb9QB967W0ZeuixpG7T7qd6KuvdL+bWr3rp0z/S4TOPbnydJim7ClGEAAAAAAKqjdhYYq6dsNpuSkpK0evWJkWlPPfWUfHx8NGzYMGVmZpY6f8yYMdq9e7cMwzi1K1SBvdgiw5InSTL5heiaD9You7Bk4f9xvaL0whWdzygMzC22aNKqrxzvX+s7QoFePmdWdA2av3eDXttcsoaZv4eXPhtwY4VhoDPB3r66Ia67Ph1wo45c95SWDh2vh869UK39wxzn2GXosbXf68LvZ2pn9tEafYbKcPP2V1CfaxR6/2J5R3SWJNlyjmjPfwcp67d3q91vdJMQwkAAAAAAAM6AywaCR44cUe/evTV16lSlpKQ4joeEhOi7775TWlqazj//fG3bts3RlpKSoh49epzx5giuzp53ImhNPuaptWnHJEmdWwbof1ede8b9P77uB6XmZUmSrozurJEx8WfcZ01Jzc3SLUmfOd7/r+9ItQ9qfkZ9erq5a0B4W03rNVxrhz8obestHY6WySj5na44vEdd5r+kt7f9XidhtntojGL/tUJNugwrOWAr1oG3b9Ghzx6W8fcuygAAAAAAoPbUnzmUtWzixInq37+/pk+fXqatc+fOWr58uUaPHq0uXbro6quvlp+fn7766it9++23dVBt43J8urAkrckwSU0kfy93fXFTD/l5ndlPcu3RNL266TdJJaPvXusz8oz6q0lWu03X//qRMv9e1/DGuO66qW3PGr1HkI+H/NRE+Ydbq613jNyjt2rLscPKsxbpjuVfaMG+jXqr/9Vq4Vv9zT2qw903UFH3z9fhz/+p9O9fkCSlfzdNlgObFTnhE7n5NKnVetB4JGealehkR2NJig8J19T2A2q3IAAAAABoAFwyECwoKNBXX32lTZs2OY7t3r1bn3zyiUwmk2688Uadc845WrNmjT799FMtXbrUsdlImzZt6rDyxsGWl+F4fcxUEky9OTpBHVucWUi15miarv/lI9n/HgU3tftQRTUJPqM+a9K0DcuUdGi3JKltQJheP++qGh9tajKZFBnko21H8pSZ4aN9kybrn6sXavrfU5S/Sd2k+K9f0MzzRqlzcEu5mUwy/X2dm8kkd5NJrfyC5HkW1hw0ubmrxZhp8m7VSQfevUuyFSt3/bfa/9Y4Rd0zt8bvh8avoh2LkzPNtVgJAAAAADQsLhsIWq1W5eTkSJK++eYb3XDDDUpISNCOHTv0/PPP68cff1SPHj1044036sYbb6zjihuXLTt3yO7uqUI3D6X6BOnq3kHqGCMt/zss6xEaWaU19fKKLXp83Q96ZdNvjjCwR2ik7ulYvY0rzgbDMPTm1lWSSqb4fjrgRgV4+sheVKj8rb+o+OgeBfa6Wu5Nmp7xvWJCfLXtSJ6O5hUpu8CuV/uO0OVRnXRL0mfan39MRwrzNHrp++VeH+zlq6ER7TU8qpMujeygEG+/M66pVP8X3CKPkFba98JQSVL+1l9rtH+4jpn9RpXbVt6oQQAAAACAiwaCTZs2VWxsrGbOnKkXXnhBt956q77//nv1799fOTk5Gjx4sO69914tX768rkttVDIt+br9l68137xBtvPvPdGQv0BffHPibVNvP93ctqfubNdXHYLLX18vOeOA5mz/Ux/uXKujf29SIkk9wyL1+YCxcnerP0tkbj52SHtzS9ZOHNwsWm02fK/UvxYqd8MSGUX5kqTD86aoxZgXFNT/pjMaOdg3JkRLtpVsIvJlilkT+sVqcEQ7pYx4UFf+NEe//R28lierqECf7l6vT3evl7vJTYktYnVFVGcNj+qkc4KaVbuuk9kLcx2vA3uNrpE+AQAAAABA5bhkIChJDz30kO655x4FBgZqwIAB6t+/vyQpICBADz74oMaPH1/HFTYedsOu97av1r0rv1GuvUByqzjsyrDk6+WNv+rljb/qwpZtdGe7vhoVmyBvdw9lWPL18c61mrPjT61N31/qOj8PT03tfqnu7ZhYr8JAe7FFX635zvG+x29vyXzgrzLn2XKO6sBb45T12xyF3zxT3q06Vut+V8WH699LtkuSnlq8TTd2j1SAj4dCvP303eDb9da237X12GEZhmTIkN0wZKjkdV5xkZYe3KEjhSUBq82w65eDu/TLwV168M9vdE1sF713/pgq74p8qpx1CxyvA/tce0Z9AQAAAACAqnHZQHDChAlasmSJXnrpJfXs2VOGYThGZW3btk29e/eu4wobh+SMA7pz+Tz9fnSv45ivtVi9j+2Tt82q5r2vkb+3r3zdPeXr4SlzfrY+3/OX8q3FkuQIo+79/Wv1aRatHw9sV9EpO9P6eXjq6tguerLrEMUGnPmU2zNlLypUwa7flb95mVK2r9TcggJ93rKT5OUvSbogfZfjXI+mkQrocrnsllwdW/GhJCl/yy/aOaWLwi57WGFXPCY3L98q3b9rRJBu6B6hj9bu16Eci55fukP/vrSDJKmJp7cmd76gwuttdrv+OLpPC/Zt0jepG7Ux65Cj7fM9fyndkq+vLxqnJp7eVarrOMNmVe76ks153P2byu+c/tXq51R5xRa9uPEXHSzIcRx7/bzyp5QCAAAAAOCqXDYQdHNz02effaZx48bp008/1W233aaJEydq1apVmj59un7++ee6LrFByy4q1JPrF2v6xt9kk3GiIauFvtz9hqKP7ZJHUEu1G/hNmWtf6XOlPtq5Vm9uXeXYGCDdkq/v0raUOq9/81jdck4vXdO6iwI8fc7q85xO0aGdyl7zlXL/Wqh9+/7Sd01b69vmHbWx2bmlzuuQc1hxUfFq0nWYArpcLu+oeEcQHXzBbTK/N0FF5i2SrVhHv/mPjq36ROE3/U9NEoZWqZ7/XNpBc5PNsljtevGXnbrrvBhFBlcuWHR3c9N5zWN1XvNYPdvzMu3OSdeCfZv0xPofdKyoUD+Zt2vID7P03eDbFexdtbBSkvK3L3dsLNOkyzCZ3M/8X0M2u13XLPugzG+EQBAAAAAAgLJcNhCUJG9vb33yyScaMWKEXn31VQ0dOlTdunXTkiVL1Llz57our0H68cA2fZe2RZ/uWi9zQfaJhkI/Nc3qpM9HnK/w5/4pSfJsHue0jyAvX93dsb8mdOinP47u05tbV+nTXetVYCtWK79A3dy2p8a17aV2NbSenTPW3HQZ1iK5+wXL5OlTZk0/w25T4b6/lLP2a+Ws+VqFaSlaGxShN2L6alWvcbKbSk9Z9pChi/yD9ezgW9U6spPTe/p3HKA2/16v9O9f0NEFU2UUF6r4yC7te/FStRw7Q00vnljp+mOa+mnyBW303593qKDYrn8t2qo5Y7pW+XOQpNYBobqv8/k6v0VrXbL4LR215Gnlkb0auGimFl9yp5r5NKlSfzlr5zteB3S/slo1neofqxeWCQNx9kxYMU8p5eziu9XTT+2L82u5oqrZ6b1eeW7ZSly4vkxbYVgntS8u0Ee1XxYAAAAA1JpGGQgePXpUjz32mFasWKHo6GhNmDBBl19+ebnnX3vttbr2WtYxqy5DkklSvo+7Bv8wq3SjzU06HKuLQ7vqw0k9FJyzSzsNuyTJq5xA8DiTyaQ+zWLUp1mMXu59hQ4W5KhtQNhZWR/QXpirvK2/Km/DEuVtXCLL/o0nGt095e4XLHe/YLn5BcnN01eFacnKKirU78FRWtE0Viv69Faab3CZfvs2baWx7fromtZdFebjf9o63Dy91eyKxxTUZ4zM79+tvA2LJUmHPnlA3pHnSqeMOKzIPwe11du/79PRvCK9tzpVd/eLVa/osjVWVvewSP1y2QQN/mGWDuRna33GAQ1d/Jb+uPy+Sn8nht3uCARNHl5qEn9Jtes57scD2/Tixl8kSV5u7vpi4E1qGxh6xv2ifGu2Jmmz3XAa/LWz5Kv9adYJrS3JmWYNS/pAHh6l/0/dQc89f78KLHPNVk8/GZZ87Z5aepdyk5rLkEmmk0c8AwAAAEAD1egCwdzcXF1wwQU6//zz9fDDD2v+/PkaPny4br75Zs2aNUteXl6Oc202m1auXKnExMQKekR5Vh3eq1c3/aZ8X3f5F9hknDyKzm6SssPkdjhO/7m4ix4e2FZubiYdXvyx4xTvyMqHW0Fevgqq4lp6p1N8YKOOJP2ivI0/Kn/HSslW7PxEW7FsOUeUl5epvwLD9WdwlFa0v0wpgS3LjASUpHMCw3RTXE9dH9dNbQKqF0x5tYhT9EOLdPizh5X+/QsyrEVKfXm4gid8KYVeXKk+gnw99dQl7TXxyxQZhnTzp+u0dvIF8vF0r1ZNktQpuKV+u2yiLl70pnbnZmht+n59vucvXdemW6Wuz01ZpOIjJWso+nceLLcqji505mfzDsfrV/pcqSuiGd17ttkteWpnydcXOXuctvtExtduQU7Eh4RLkqxWa5m2AFtT+dsDlTRsUpm23nMmy+7tJ+WUaQIAAACARqPRBYLvvPOOIiIi9Oabb0qSxo4dqy+++EI33XSTMjIy9NVXX8ndvSQQmTlzpu6//3598MEHuu666+qy7Abnf5uXa9KqryRJl+h4EGhIx5pJWc2lvGD1aBWqGePj1TcmRFLJZhuZS9+QJJk8vRXc/6ZardkwDG09nKvlezK1b/UiXfvHXc5PdPeQX9x5sgS30h9Wq1bJXb97+CvZJ0jFbs7DND8PTw1oGaerYuI1rm2vGhnFaDKZ1PzqZ1V0eKdy1nwle2GOMmddq5DHfpN3hPNpx6e667wYfbgmTSv3ZmrzoVz9a9FWTRteuWvL0yYgVB9ecL36fzdDkvTkusW6OjZBHuV8NidL//4Fx+umg+85ozqOs9hOBD69w6JrpE+cnsnbT63vS6rrMso1s1/J+pHp6ekKDS0dzCe+Vn7dx0cutx5ferSzMYr1KAEAAAA0Ho0uENy1a5dCQkJKHbv66qsVHBysyy+/XFOmTNGzzz4rSRo/frxWr16tqKiouii1wVpq3qH7fj+xDpzJKJlC51tgk1I7KdTPU/8d1VG39o6W20lTB7P//EK2nKOSpMA+18kjqMVZr3XbkVzN33BQy3dnaPmeTB3NK5IMQ58ee6HUeVvcY/RLaB8dbNtNlohwHbBnaV3Gfln/nt7sTPfQCA1p1V5DItqpX/NYedfA5hinMrl7KGLCJ0p9ebjyNi6RkZehvc8PVuyUJHk1a33a693dTHrvuq7q8uIvKigu2WDkis4tdH6bM5tS269FrC6JaK8f9m/Vtuwj+mTXeo1t26PCawp2r1H+5qWSSkaH+p875IxqOO7kXae9KhFKAgAAAADg6hpdINijRw+99dZb2rdvn6KjT4wWGjx4sJ5//nn93//9nyZMmKDo6Gh5eHjo3XffrbtiG6A9ORm6eun7sh0Pyo5Eybdwt6SSdQQn9IvR1Es7qKmfV5lrM3/6n+N104vLTtWraR+tSdO4T9fLai+95teFxavVybpDvzWN1aKQeC0M7qZiv0LJ3SbpqHTkqNP+zg1uqQtbttGFLeM0IDyuyptpVJebp7ei7vtKe58frIIdK2XNOlASCj72mzyDw097/TnNmuj5yzvpnq82yDCkcZ+u118PXqgm3mf25/9UtyH6Yf9WSdLT65foujZdKxwlmL7oRcfr0EsfKrNRS3UV2U4KBN0JBAEAAAAAOJ2a352hjl177bWKiIjQmDFjVFBQUKrtnnvuUcuWLbVo0aI6qq5hy7cWaeTP7yrd8vdGAtmh0qETo9RMkl4fleA0DCzY9acKdv4uSfKN6yPf1hWPJjtT/0varRs/XlcqDGwZ4K3Lzw1S+1brNaTv7RqfMEpfR7VTcUDe32HgSQxJBU2koxHS3s5qe2SwBpmG6rLg/rqsVedaCwOPc/P2V/QDC+URXrI+XvHhndo3bYhsuRmVuv7ufrG66JwwSdKu9Hw9/O2mM66pT7MYXRbZQZK0I+eoPty5ttxzi47uVfYfn0uSPIJbKahvzU3RL7KfmDLMCEEAAAAAAE6v0QWCXl5e+vTTT5WSkqIrr7xSeXl5jjY3Nze1bt26xkYmuRLDMHT78i+0PuOAJMlk8ZfSOsjPy0OV+TQzThodGHLR2RsdaBiGpi7ZpklfbXAcm9Q/Vh/cEavECw5qkb7RrJbtdNCn9O6irZs01eiYBN0WPUCX+wxR89RB0s4e0sG2Uk6Ydhwq0vTfdmvY23+o6b9+0JgP1mjn0bxTb39WufuHKHj8F/Jq0VaSZEnboL0vXip7Ye5pr3VzM+mda7so4O9RgTNX7NWmg2e+a8KTXU9M+3149bfan3fM6XkZP7wi/T21t+mQ+2TyKBsaV1fpKcONbtAzAAAAAAA1rlH+13P37t21cOFCXXHFFerdu7dmzJihAQMG6Ouvv9bWrVs1cuTIui6xQfkr44DuXfW1fj1Usjusj8lLhXs7SXYPTewXq53bKr6+6PAuZf/+qSTJPaCZAntffdZqfemXXfrXoq1/vzM0PNGmRbaFmrGy9DRgD7tNlwQ20119rtR5zWMV5uNfqt1uN5RsztbirUf0w9YjStqdoSJbyTTpIptdn60/oIWbD+nLm3tpcPtmZ+15TuUe0FzRD/+oPf9JlDUjTYW7/tCRBVPV4pr/nvba6BA/PT20vSbP3yip5LN6+9ouZ1RPr2bRuia2iz7f85eOFObp/j/m64uBpTeLMYoKlPXr25IkN58mChlw5xnd81SlAkGmDFfJhLnJSjFnO21LNucoITyglisCAAAAANSGRjdC8LgLLrhAa9euVUxMjAYNGiQPDw898MADWrBggcLCwuq6vAZhT06GJqyYp+4LXnaEgW4mk3qbzpOK/CRJd54XU2Efhs2q/W/eKKPYIkkKGTRebp7eZ6XeRVsOO6bCmkzSkPNz9U3Wcu3IOREGtizM0aTdy7X8SIreHXinhkd3LhMGSiUj6rpGBOnhQW3104TzlPHvS7Tw9t667/zWahXoI0nKtdh02du/6/3VqWflecrjFRajmId+cLwv2PVHpa+9oXuEfD1L/uxn/7FP7/y+74zreTh+oOP1saLCMu22jL2OUYwBPUfJ3T/4jO95MreTxqja7OVvAoOyUszZSjY7HymaEB6g+PBAp20AAAAAgIatUY4QPK5Nmzb67rvvdOjQIaWnp6t9+/ZyZwTRaa08vEcvbfxVX+5Nkd04sQZfx6DmmtF3pJ7/Nl3SEUlSq8CKw72j3z6rgh0rJUle4R0UNuyfZ6XmbUdyNeaDNTq+ZODQ/oX6PrNkTTuTTBpYmKmR25fpgoxd8g2NUezk5cq2V37quL+3hy7r2EKXdWyhZy7roNs++0ufrj8gq93QzZ+sV1pWoR65qG2tTUf3jugkk6e3jGKL7JbKT11u1sRbs67uorEfr5MkjZ+XrPbNm6h/66bVruW7tM2O11dGdy7Tbss+5HjtGRZb7fuUJ+CkgDmn2KKWNX6Hxi0hPEBJ9yTWdRkNRoG3uxIXznDaFh8Srpn9RtVyRQAAAABQdY06EDyuRYsWatGiRV2XUa9Z7TZ9tXeDXtr4q1Yd2VuqLcjLR092HaKJHfvL081d/8w/KEny9nCTr2f5AWvBzj905OunSt64eyhi/Edy8/ar8dqPFRTritl/6FhhyeYSvbsU6PusE6PmpuWbdekfH5WUEdRCMQ8vkWdIKyk9vVr38/Py0Ec3dFdksK9eWLZTkvTY91uUmlWg10aeKw/32hl46+bdRLZii4xKrCF4sht7RCrFnK3nl+5Usc3QVe/+qT/vP1/RIdX7bubtTZFUEryOiokv024/ORCsxK7IVXVyIJj990hUnLkJK+YpJdPstG2rp5/aF+fXckX1g72c0D+5nM8KAAAAAOojlwgEUb70wjy9t2O1XtucpD25maXaIv2CdF+n83V7uz4K9vZ1HM/IL5IkNfXzLHdEnL0wV/vfvMGxkUTzq/4t39juNV5/QbFNYz5co61HSkbJtW6dp9X2NY72J2y5jjDQzS9IMQ8tdmzKcSbc3EyaNryTooJ9dP/8jTIM6Y2Ve3Ugu1Cf3Nhdfl5n/0/Lzdtfttx02YuqvrnJM5d11IaDOfpu82Edzi3SiDl/KmlS/yrXbbFZHaFRr7BItfQrO8X05EDQI6jmx++VHiFYdsoyqicl06zkTLMSQsqGuO2L89W+uMDJVY2fm2EoaVjZjZHKGzUIAAAAAPURgaALMgxDvx3apTe3rtLcPcmlNmWQpJ5hkXqw84UaFZsgT7eyIwAzC4olSSG+nuXe4+AnD6ro0A5Jkl+78xV62f/V4BOUOHCsUCPm/Kk/U7MkScFhOUpr8pdjmvO9lkxds/IdSZLJy1fRkxfKJzqhRmu49/w2igjy0Q0frZPFateCjYc0cs5qLbqzz1mfPmzyLln7sDK7DJ/K3c2kj2/orj6v/qatR/K0bn+2bv3sL31yY/cq1b3t2BHH5x3vJDiSJHvO4RP3PeuBICMEa1JCSLjT8Gv31MY9xTg501wm4AvydpePxVbOFQAAAADQsBAIupACa7He3LpSb25dpS3HDpdqM8mkEdGdNbnzBUps0br8kX92wxEINvXzcnpOztoFylo2S5Lk5huoVne+L5OTYPFMrE7N0pXv/KkD2SUjwvyD8lTYKkXFf4ebN+Ye1J2rS0YGmjy8FDlpnvza9a/RGo4bldBKLZp464p3/lRmQbEWbzuiL1PMGpXQ6qzc7zg37yaSVKU1BE8W5OupBbf1Vp9Xk5RVUKzP1h9QQnigHr34nEr3sSnrxOi/TsHOp+XX5pRhAkGcqfKC7ePc7EaF7QAAAADQEBAIuogf9m/VhBXztDs3o9Txlr4BuvWc3rqtXW+1CQg9bT/HCot1fJ8RZyMEbXlZOvDO7Sf6H/s/eTWLPaPaT/XJ2v269bP1KrSW7Cjbppm3cqLX6IilJKi8/OgO/WPDfJlUMk046r758u9wYY3WcKrENqH6bGwPDZm1SpJ0z1cb1Cc6RJHBvqe5svrc/h4haBQXyrDbqhW6tmvWRJ+N7a5L3/pddkOasmiLrujcQudWcnfZk4PljsHNnZ5jO3mEYGDNr+UZ4OnjeE0giDN24BzJXPZ36m1ZWvK/xexkDQAAAKDhIxBs5AzD0DPJP2nK2kWOYyaZNCSine5s11fDozs5nRZcntyTpswF+Zb9+Rz5+knZckp2IA7sfY2C+t1wBtWXZrMbeuy7LXpu6Q7HsUFtw9Sn5zE9u6Fk2my/jD2auvEbuUnyCIlQ9EOL5BN5bo3VUJHB7Zvpis4ttGDjIZmzLbp89h/6bWJ/BficnT8zk8eJEZqGtVgmr+qNwhzSvrn+c2kHPfLdFhmGNGP5Hr0xunJTqz3cTmygYjPKGTlltzqtuaZ4nfT7tRqENaeaMDdZKebsUsesVqs8PDyUbM5RQnhAHVVWP6WYs/lcAAAAADR6BIKNWIG1WLcmfaZPd693HBsa0V6v9hmhdkHNqtVnfvGJQNDPyQ7DGT+WrLvl5tNELW54pcbW0TtWUKwbPlqrhZtPjDab2C9GbVof0KPrl0gmkzztVj2xbYk8ZShk4F1qNmqqPALCauT+lfXumK46b3qSth7J018HsnXNB6v1za29z87Ow6aT+zyzaYz3nt9a//15h44VWvXhmjRNHdpeYU28T3td25M+3x3ZR52X6XFiBJ9RbJHJy8fpedVlnPTsZ3fVxoapooArITxA8ZUcDdrYJJtzlPhaktPjCeEBSrqn9DqJo5a9XFulAQAAAMBZRyDYSO3PO6YRP8/R6qNpkiQ3k0kv9hqu+zqdf0YhXX7RSYHgKSPSTDIcuwqHXfGvGlsvzmK1adAbK7U27ZgkydPdpCcvj9J3hxbof39lSX8/z/X71+uc6AS1vHG6fGO61ci9qyrEz0vf3dFHfacn6UhukRZtOaJ7vtqg10fF1/gmI6aTRufpDEfG+Xl56PY+0Xrxl13KK7LphWW79N/LO572unMCTwSC28sLBD1PDgQLpZoOBE/KQs/2Ri4N1akBV3p6ukJDT79EQGNVUQjqyiEpAAAAANdBINgI/XFkn0b89K7MBSXTBIO8fPTZgLG6JKL9Gfdd8QjBkmTGq8U5ajrkvjO+13FPLd7mCAObNfHUdQOK9O+d76vw7/FgJsPQTUe2aNrFdyjsvOvrPBRqE+qvBbf21sDXV6jQatcbK/eqbZi/HhwQV7M3OmmEoGE/86myDw2I0+sr9qig2K7Xlu/WAxe2UfOAikcJtg08/QhBnbTph724QO4KPuNaT8YIQVTVzEpOiQcAAACAxopAsJH5eOda3br8c1lsJeu2nRMYpm8uvlXtg5xv+FBVFY0QPK7F9S/LzfP0000r4499mXru55I1A718CxXZKVnT92TqePQTm5+hl4x8DZ/wrjwCqzcN+mzoGxOi96/vpmveXyNJ+r9vNym2qW8N7zx8UvxVA2vntQz00aT+rTVt2U7lF9n03NIdevGKzhVeE+jlo5befjpoydefh/eo2G4rsyalyfPExipGceEZ13mqkydLm4gEa0zR4Z2yW/K0e2pimTZLarK8owjVAAAAAKChIhBsQDIt+XouZanm7klWkd0mD5Ob3E1ucnczycPkJpNM2pB10HH+xa3O0ecDxirE26/GanA2QtAkQ8bfQUyThEsV0HXYGd/Hbti1NfOorpr3k+xhRyWffBmBR7Quv6TdzbBrnDlZU/tfp5YX3lrnowKdubpLKz03LF//WLhZhiHd+NE6RQT5qm9MSI30X3rK8JmtIXjc/w0sGSWYV2TT68v36MEL49QqqPwpvvaiQp13cJO+ColVprVIX374gK654UWZ3E/8q8XkcSIcNooKaqTOkxknPXt9/B00VHZLngxLvtM276gE+UTG13JFAAAAAICaQiDYAGQXFerVTb/pxY2/6FhR5UZY3dsxUS/2Hi6PKuwgXKlaCosdr/283GXLy1LJGK2SIKbF9dVfeD8lw6yZW1doffoBpWQeVK7VopNnlx6/c5u8dE3LM+vyO9+SV7PW1b5fbfi/gXHakZ6nt1btU6HVriFvrtL8W3tpYNsa2OzE7cSfb+G+9fLvOOCMu2zWxFsT+sXqhWU7VWi164M1afrHoLblnp+/9RddlLZOX4XESpK+3/OXLlnxoYLPH+c45+Q1BO1nIRDcm5fpeO1GIFijTN5+an1f2Y03AAAAAAANG4FgPZZvLdL/Ni/XcylLlX7KSJ1o/2DZDUM2w5DNsMtq2GUz7Grq5afHulyk29r1OSs1rfl7Lb/L932sJS8W62fZHaMDDZl0471T5Ovrq/fff79K/S5M3aSrl36gAltxued424p14/51+lf7Poq++22ZajjsPBtMJpP+d1W80rIK9f2Ww8qxWDV01u/66IZuGt3lzKYP+3e+WDmr50mS9r95o9o8va5Gpk2vSctyvG4TWvHoUjdvfwVaLY73HoYhr1alNyM5eX3Dmv7O0vKy9GzyzyV9y6R+zWNqtH8AAAAAABojAsF6KMdq0cebkvSf5J90qCDHcdzTzV13te+rRxMuUrhf3eyCmbQ7Q5LkYS+WIUPWUmu2mWS321VQULVRYO/vWK1bkz6X7e918Nxkkt3iKxX6S4X+eqR/Fw1ZOVXBm36Ul2FXxOR5DSIMPM7T3U1f3dJTN360TnOTzSqy2XXNB2v0v7wiTegXW+1+QwbcqZy1Xysv5QdZM/dr/5s3KvrB787os/l5+1Et3ZEuSerUoomuiq94p2jftufpQLMTm6XE979RfnGnhNEnBYamGlpb8rj7fp+vnOKS/id17K9OwS1rtH8AAAAAABojAsF64mhhnhbs26gv96ZoyYFtKrKfWKvP3eSmW87ppSldLlJMk6Z1VmOuxar1B0p2Lq6piZnTUpbq4dULHe9HRnbRL781VUZeSTj4xOBzNCl7vg5v+lEy7PJq1bFebR5SWd4e7vp0bA/d+9UGvb5ijwxDunteig5mW/TkJe2qtfadyc1NEXd9qF2Pd5M1I015Gxbr6IL/qNmIx6tVo2EY+teiLY73Tw9tL3e3iusyubkrO/FWaU+KJKlTxwvL9msrOnG+R80Fgsf/XiQpwi9IU7sPrbG+AQAAAABozEyGUUO7EeC00tLSFBUVpaGXDpWvn58MSTZ3k2xubrK5S2VjNkMeNkOexXa51ZNv6XgZNREIFnm6qdjjxMYYnla7PItPml6qkg1LTt5H1vj7aENXemfcM+/NVEOfUXXqsni5yepe8j36FlrL/FZP/g4NuakmGJIKfNxl/B2kehfZ5GEr+0cyb968SvV3/G8zOTlZ8fGNa7OMxNdK1gBMuufEbsHp6ekKDQ2t8Lqeb9wpSVo9ftbZK64WVOZZK2PUqFGSSn7Pc+d9WaY9ceEMJWealRDifFRtfEi4ZvYbdcZ1lKemnhMAAACAa2CEYF0wJJNREri4WQ15ynbaS+qLmozivIrt8jopAHSmsQSAp6rZJzI51nE8856qzrvILm+V/z2eje/QJMmvsOH83aDxiy8nCJSk5ExzLVYCAAAAAKdHIFgHCnw9ZPiW/ujd7IbcbYY8/p+9+w6PqtoaOPybkkx6D+mN3hJ6B6ULKKAIioIdFHvFcu2f2HtH7L0gigqKgBTpHRJ6SSA9pE/KJJlyvj8mTBJTSJlAEtb7PHk4c8o+6yQzuTfLtfcyt5xqwP+qWj1W0Vm4QWOooNRBjVlzplJMQVdmQVOpukv1n4o361ltMzFoz0rBqtWUDU8SNjaW4vJKPbWi4FxDks7eFYIWlbU6EFSoFAXnUjOqFvqZEReOuqr/hi9/7xxGIoQQQgghhBBnJwnB88DrmnG4tPNFBcR4B3FFRDSdPSvWxWuJU7+Ky0y0e3olRWVmnjd9yf5kI6U41HiuWq1m8eLF1fanFuczfPn7JBRaG5O4aB14t9/VPPtLFom5BlSKhYeMP3Kj/nvbNU4RfQm95xcc/ezfPbYlfJ/Xn8hi9IdbsCgQ7OFEytPj6jy/rpjNRXnEP90PY2Y8AKF3/YzHgLqnKBaWmpj70z5+2JsKgJNWTexDF9PJ361e8X96dBtzNll/1oP8w9l62T3Vzjn+4jjKDq8GoMPLR9EFdqrX2LW5ddNiPj66DYA3Bk7h/h4XNWk8IYQQQgghhBDiQmOfBb1Eg7w3ZBrfXTyLby+exSMxo6skA1uqpfvTKSozM7xsF5fnLcFDZcARI//tOaFWq3F2dq52fXZJEeP+XmRLBrZzcuOLQTfw1M+ZJOZauxK/rnxWJRnoOfxGIp/Y2CzJwJbi4g5+DAz3BuB0YSlNWdJT4+pF0E0f2V7rd1Vf56yyg+kFDHx7gy0ZCPDW5T3qnQz84tgO5m762fb6po4DajzPseMw23bWH8/Xa+y6pFfqvF3bPYUQQgghhBBCCFE7qRAU9fLNrhR8Lbk8X/AWAPe4ribopkV4j5xrW2wfqLEysMBYwqRVn3AwLwOAzh7+fNz/eq7+PI70glIALm5n4pJDy6wXaLQEznob79G3N6r7bmvj7WyttDRZFIrKzLjpGv+xdO02Co27P+aCTAr3LUcxlaHSOlY77/vdKcxdvI+iMrMthm9m9WFSt4B63eer4zu5eeNPKOVTgf8XM4Zbuwyu8VyXYTdj+PdDzPrT5G/6Gr9LH0UX3LWRTwiFxlLbtptD9WcTonkpJCwYXuMRp9Bogm788BzHI4QQQgghhBANJxWC4qwyCkpZdSSD5wvexk/JB8C9/5V4XTznrNeWmIxc/s8XbM9KAiDM1Yt3+1zL9M9ibcnAAWFefNMjHhRrYwr/yU/gM+aOCyIZCODlXDH1Os9gbNJYKrUG9z5TALAU51Ow5/cqx41mC3cuiePab3fbkoH9wzzZ/cBF9U4GfnNiFzdu+NGWDHwkehQL+k6o9eel0rnid9lj1heKhcylzzTiySoUmcoA0Gm0aNWaJo0lRMPV/D4vTYqlJDnuHMcihBBCCCGEEI0jCUFxVt/vSeGa4t8ZYdwNgNYnlOCbFp01YWeymLlm/besSTsOgL+TK+/0voZrPz9AZqE1qTMkwptVtw2mbOcPtus8h13XTE/SMnlXSgjmNjEhCOA5dJZt+/TPj6OYKsa8b+kBPth80vb69qERbLxrGJE+LvUa+7sTu7lhww+2ZOD8niN5sd+ks74XvEfNQ+sdAoB+24+UJMbW93GqKSxPCLrVUPkoRHOzoCLqiY3VvnRhMec7NCGEEEIIIYSoN5kyLM7q3w1rearoS+sLlYqQ275B4+ZT5zUWxcItG39iaeJ+ADwcnPhs0PXc8uVxsoutCaqL2vuw7JZBOOaeoCRhJwDOHYfi2K598z1MC+TtYr8KQQCXriNx7TGWogOrKUs/Su76j/EZcwc/7U21JQOdHdR8PKMXs/qF1nvcH+L3cN2G77GUr3P4QI+LeLn/pfWq5FQ7OuE35QnSv7wdgMxfnyLs3qUNfjaoqBB0c9A16npRIe2L22utalPcI1Hp6pcoFkIIIYQQQgjRukiFoKjTweTT3HTiGRwxAeB32f9w7XrxWa97fNcKvjqxCwAnjZafLr6Bh346xenyysCRHXz5c84g3J205G/51nZd5eq2C4WXU6UKweKmJwRVKhUBV78K5Ym6zF+fJj4lnTk/7bOd09Bk4B+JB5j9b0Uy8N7uI3htwOQGTev2vuhmHPwiASjY/RuG+B31vrayM2sIukqFYJOVJMdRmlRztaZK54Ja53qOIxJCCCGEEEIIcS5IhaCo078/vMVF5mQA9O360O3yp896TbGpjNcPrAdAq1KzZNQNnEp25EhmEQAxQR78dvMAXMubZxTs+tV6oUaLx8CrmuEpWjY/14rE1onsIruM6RTRG89h15O/8UvMBVmsW/IxBaW9AZgzKLxByUCAx3evwFy+xuPd3Ybz5sApDV7jUaV1xH/qU6R+ejMA+Vu+w7l9w7sEGy2W8n/NDb5WVKcLiyHqiY3V9jstf+88RCOEEEIIIYQQ4lyQCkFRI7NF4Y+4ZDoc/AywrpvV8fYvUGkdznIlHNdn2ZI113fsz6Swbqw9nmU7/unVvfAor4ozF+VSmmydVuzcfhBadz97P0qLN6J9xfTrX+LS7Tauz9i7bNvqE/8CoFGreG1y9waNk1SYR1xuGgAD/MJ4e9DURjd8cYuZaNs25iQ2aozePsEAHNNnkVKU36gxhBBCCCGEEEKIC5kkBEUV2UVlvLr2OB1f/IevFr5EiDkDgJSQUfi1r9+i+Uf1mbbtbp7tUBSFdSeyAWsDjb4hnrbjxcc227ZdOg+3xyO0Oh38XOkT4gHAppM5pOaX2GVcp4g+qF28AOis3wWKwoAwLzydz57UrWxFymHb9pUR0U3q/qzxaAcaa2WoKTelUWNcEtLFtr0y9UijYxFCCCGEEEIIIS5UkhAUAOxKyuOmH/YS+n+reHjZIUozTzG/6DPb8T6znqn3WMf0FdWAnT39OZpZRHqBdd23izv4olZXJJSKj1ZMVbxQE4IAM3pZq94UBX6JS7PLmCq1BtduowDwt+TSwZzEqI6+DR5nRUpF0m1CaNcmxqRG6xkEgNEOCcG/U442KR4hhBBCCCGEEOJCJAnBC1xynoFRH2ym/1sb+GJHEiUmCyrFwoLCd3BTDAB4jZpHux4j6j3m0fyKCsFOHn6sO1GRIBzZoWpCynBsk23bpePQxj5Gqzc9Jsi2vXhfqt3Gde0+xrY9yBjL6I4Nm5JttJhZnXoMgGAXD2K8g85yxdk5eIcAYMpLQ2nEOoB9fIPxd7I2u1iVehRz+ZqCQgghhBBCCCGEqB9JCF7Atp7KZcBbG2zTecHa4OKziB0MNlo7jzr4tydw5qsNGvdoeYWgWqWivbsv645XjD+yUoWaxViKIWE7ALrg7mjcfLhQdfJ3o1ewddrwhoQc0vX2mTZcOSE41LSPoZHeDbp+8+mT6I3WWCaEdG3SdOEztOUJQSxmTPrTDb5erVIzLrgzADmlxezKTm5yTEIIIYQQQgghxIVEEoIXqH+OZjLyg822qbwd/Vz56prexM9rz6D9b1pPUqkInvsFaie3eo+rKApH8q1Jnig3HxzVGlvC0cfFgehAD9u5JSd3oRit93e+gKcLn3GmStA6bdg+zUXy3CI5rbYmWgeZDuCsbVhC76/kivUDJ1SaqtsUZyoEofHrCI4vTwgC/J0i6wgKIYQQQgghhBANIQnBGhgMBq644gr2799/vkNpFhaLwj1L91Nqsk61HN/Zn+33Due6/mHoly1AKSsGwOeS+3HtUv+pwgBLTsWSXWq9vrtXACeyi21Jx4vaV10/MG/DF7Ztl84Nu09bdGYdQYAvdybZZczMojL2aa3JMxdzIaa8hq1PeCCvIjE5LCDSLjEZcyqeTTE2rhJyfKXk5D9px5ockxBCCCGEEEIIcSGRhOB/GAwGpk6dik6no1u3buc7nGaxdH86BzMKAWuTj+VzBuLt4khp+jHyN38DgMYzgHbTnmvQuApw/7bfba/v6DqUzSdzbK+HR1VMCS7LOkXexi+s93LzxaPf5Y17mDakSzs3BkdYp/RuT8xjd3KeXcYM0FYk3TZn1nFyDULLuxQDpBcXNDmeksR9FOz6FQCtTxhOUQMaNU6QiwddPP0B2JaZSKnZ1OTYhBBCCCGEEEKIC4X2fAfQkpxJBvr4+PDtt9+i0WiaNJ5er0ev19tep6XZp3tsUyiKwvP/VFRUPTO+M1qNNS+c9fsCUKxVg36THkGtc2nQ2EYHNcnF+QBcEd6TCaFdmbc11na88vp12ctfBrMRAJ8JDzRoWnJbNm9IBFtP5QLw0ZZTfDTDq0njOWjUdHHMh2LIUXnw6N8n2dw5pN5rAZ5JugEc1WfS1y+0SfFk/vqMbdt/yuOoHXSNHuuigPYcyc+kxGxiZ1YSwwKimhSbEPU1/N2N1fY9nKbHxUGDvAuFEEIIIYQQrUGzJgRzc3NRq9V4eno2523swmw2M3XqVAwGgy0Z+M033/D8888THx9Pnz59ePPNNxkyZEi9x3zjjTd49tlnq+3Pzc3F2dm51usqJxHtIaEol2VpRzikzyQhv4jd2lxob8ZZB9fv3EPRNiNuKjUDstIZ5t+JoUYD7XpNJzs7++yDV2IsX5/OWaPlqc4XkZ2dzYbj1pI0R42KCGcz2dnZmPNSyV3/KQAqZ0/oe22D72UP9v4+28OYMB2eThryS8x8uyuZx4YF4q6r+Jg2NGZFUdAVWaf9pqv92Hoql2+2HmdS5/o1cAlUVSTs9qSfYpxneIPuDxUxG5NjKdi9FAC1dxjm7lOa9HPv41qRrPw74QBdtR7VzvH19a22T1R4wjOKIw7OOC1/r9qx2Nw0u3SVvlAUlTW8Y7YQQgghhBBCnC/NmhB8+eWX8fLy4tFHH23O29iFRqNh3Lhx/O9//2PJkiWcOnWKd999l8cffxw3NzfefvttRo0axfr16xk0aFC9xnzggQeYM2eO7XVaWhoDBw7E29v7rImKpiQyFEXhYF4GS07F8sup/ezLSa16QnkxngFIMli3c4DEoGiWBEWjBgbtWsolIV2YENqF/r5haNT1mV1uTQg+0WscvcPak28wcijLup5gv1AvggOsCZz0v54FcxkAfhMewD8kstHP2lQtMWF008Bw3vo3gSKjhRUnDcwbGlnleENiNhVmc9po/SFnaPwAeGlDMtcO6ohGffYqwQEOCmyzbicbixr9/fL19SXx67dsrwMufwrvgKYlmybpYmDPMgB26tNb5M+ypTvi4MwRBxd61XAsxjuIaEkIVqMCNt5dvQnS73c2raJcCCGEEEIIIc6lJicE9+7dW2vzjQMHDjBs2LCm3uKcmT9/PgCzZs3C29ubffv2ERRk/YN4xowZDBkyhPnz5/Pvv//WazwPDw88PKpXLTWXhIJsPj66jSUn4ziqP8ticYoKb50T7g46XIDE/NMUax0BsABbMk+xJfMUz+xdiZ/OlWkR0cyIimFkYAe06qp/+Jo0KrRmBYBOHn482PNiwLoOnmLdbZsubMxLI3fdIgDUzh74jLvHPg/fhtw6OIK3/k0AYOGWU9w2JKLeU3z/y5STbNvWeIeAGQ5mFPL1zmRuHBh21usj3LxxUGswWswcyW/gAoSVGBJ2UrjHur6kg38UXsNvaPRYFbH5EO7qRWJRHptOn8RssdQzcS0q62IsZuOld53vMIQQQgghhBBCnENNTgj+8MMP/Prrr0RFVV856ejRoy06IVhcXExycjKdO3e27TuTFIyPj7clAwEcHR2ZO3cujz/++DmPsz42ZSQwYeUnFJpKq+xXoWJ4QCRXRsSwZHMpG47pwaLh5+sHcGWMtattyqIbyNz8DXs9g9k77Bb+1XmyJyfFNkZWaRGLjm5l0dGtBDl7cHOnAcztMogINx82ZSRQ5qBGa7ZOl3t38BXoNNa31aZKDUWGRlqnqGYvfwXFaI3RZ/y9aFy9mu170lp1C3Dn4g6+rD+Rzb5UPTuS8hgY7n32C2tgrJQQHBTdE/Zat5/6+zCXdm+Hv1vda/hp1Ro6uPtyOP80R/WZmCzmagnhs1EUhdM/V3xu/Kc8iUrr0KAxajMioD3fxu9GbyxhX05qk9c4FEIIIYQQQgghLgR2mTJ800031TgtuCVPFTabzUyePJm4uDjWrFlDz549bcfmz59PRkZGtWuysrKIjo4+l2HWy+6sZCat+tSWDNSq1IwO6si0iGguj+hJgLM7AC/89DeYHQh013FFT2uyszT1EPlbvsVRsTDEUsb1Ux9GrXMhw1DAqtSj/JV8mGVJh9AbrZ1q0wx6no/9hxdi1zCkXQRbM08xrrx6TWu2cElIFwBMZgtf7kyyxTg00puyzJPkrvkAALWTG77j7zsn35/WaFLXdqw/YV1f78jpwkYnBEuT42zb7Tt2ZZo5kF/i0knKK2Hswq2suX0Ivq6OdY7RyyeYw/mnKTCW8ur+dTwWM6ZBMRi2fkXR/pUAOLTrgOew6xr+IDUoM5uIy61o1JNVWmSXcYUQQgghhBBCiLauyQnBXr164erqWuOxsWPH4uTk1NRbNAu1Ws22bdvo0qULo0ePrpYUDAgIqHL+wYMHeeutt1iyZMm5DrVOB/PSGb9ykS1hd1lYN74YPhNfp+o/Ez9XR04XllFisqBWq1BMZaQsnA0Wa3Wf78SHbJ2FA5zdmd2hH7M79KPUbGJlyhG+i9/DL6fiKLOYUVDYfPpklfEdyyy27R/2pnIyx7p23eU9Awn0cCJ54eMoprLye81H41a/xhYXoti0iuYhMcGNn3ZedHidbdu50zDe6d6O3Sn5nMwxEJumZ9xHW/hn3hC8XWpPCj4SPYolJ2MxKRYW7FvNrZ0H1/j+qklp2hEKfnvS9jro+g9QaeyzdOlz+1YTW54Q7O8XyuigjnYZt6259tRrhBriSVhQ8T4ymUzotVoU90hUDewmLoQQQgghhBCi9WvyglvXXHMNU6ZMqfHY2LFjGT68+uLrLYFKpaJjx4588MEHREVFMXr0aNtaiIWFhbbzdu/ezeOPP87YsWN5//33ufjii89XyNXEF2Qz7u9FZJdaG3eMCerE4pHX15qsCfW0djbOMxgpKjWRufRZSk7tBkAXFlPren46jZbJ4T34fuRsUq5+ilf7X0YnD2uDCieNFkejNaF4ZpU7i0XhpTXHbdc/NqYjhoRd6Ld8B4DWMxDfCQ807eHbuDPTrT2ctPQMbFxCUDEZKT66EbCu2+foF0GIpzNrbx9KuLf1vbAnRc/4RVvJMxhrHaePbwj3dLd+jotNRhYe2VKv+1vKSkj58Foos74/fS65H7fo8Y16lv/akZnIi7FrAOv788sRMxs8lflCEWqIJ6T4RI3HVDoX1Lr6JXeFEEIIIYQQQrQdF/QK/F27diUpKYmVK1fakoJvvvkm/fv3x2i0JkicnJzo3LkzcXFxXH311ec54gopRfmMXfERqcXWSrIh/hEsHXMjTnWszRbiWVGtmbxvLVnLXgJA5aAjZN63qB3qXk8OwM/JlYeiR3Jk2iPsnHwfJ6Y/hoNJqXLOsoMZHEgvAGB0Rz8GhHmR8eN823H/af+H2smt/g97gUnJN9iqKweHe9erG3BNDCd3oZRPo3XtOtK2P9LHhTXzhtjeDzuT8pmwaCv6ktqTgvf3uAityvrr4t1Dmygx1X4uWNcNTPvy9ioJ53bTX2jUc/xXicnIDRt+wKxYK1Kf63MJ3b0C7TJ2W5Xi0oGoJzbavnzuXk7UExtxCovBsV2H8x2eEEIIIYQQQohzrNEJwYyMDMaPH4+7uzudOnVixowZvPzyy/zzzz/k5eXZMcTm06VLFw4cOICnpycrV67E39+fBx54gCeffBIHB2tirXv37txwww34+vqe52grZJYUMu7vj0gotFaR9fYJ5s9xc3A7S0LvTALI1VJM6bdzoTyh0m76iziF9qzr0mpUKhX9/EIJdvGssr/MZOGxPw/ZXj82piOFsSsoPrQWAMfgbniNuKlB97rQbErItW0Pi2r8tOriStOFXSolBAE6+Lmy9vYhBHlY3zPbEvOY+PE2CkpMNY4V6urFzPa9AcgwFPBd/J4675275kPyN34BgErnRugdP6J2tM/yAU/v+ZtD+acBayL8gR4tp2pXCCGEEEIIIYRoDRqdEHz++efR6/V89NFHFBUVkZKSwpNPPsnYsWPx8fHh0KFDZx/kPOvatattmvD69evJycmhT58+3H///bb9LU1+mYFL/v7YlhDp4unP3+Pn4qVzPuu1ZxKCjxZ9jDbvFACu3cfgM/5eu8X31r/xHMywTrm+qL0Pozt4c/qnh23HA6562W5ryLVVlbszD29CQrCoSkKwetKsk78ba+YNIcDdmhTcfDKXSz/dRlFpzUnBBysl3l7bvw6LYqnxvOKjG0n/tuI95XHtB+iCuzbmEapZlnSQ1w6sB8BZ48AXI2aiUV/Qhc5CCCGEEEIIIUSDNfov6Z07d/Lss89y7bXX4uPjw6JFizh+/Dh9+vThqaeeIjCw5U/hO5MQ/P3337ntttv4888/Wbt2LVFRUYwdOxa9Xn/2Qc6xGzb8wJ6cFAAi3LxZfclttCvvInw2oV7ODCnbw7TSfwBQu3gRPPcLVHZMqDy76igAGrWK96dFU7DtR0qTrclVly4X4db7Mrvdq63amGBNCGrUKgaFezVqDEtpcbX1A2vSNcCdNfOG4O9mbSqyIT6H236OrfHc3r4hjA3uBMCh/NOsT4+vft8yA8nvXw1ma1LRb8oTOEVPatQz/NeurGSmrfkSi2Kdov5iv0l09vS3y9hCCCGEEEIIIcSFpNGlWnq9nuDgYAB0Oh0Gg4GePXvy448/cu211/LMM8/YK8Zm06VLF06cOGFLBvbp0weAlStXsm7dOjw8Gt/dtTmkFev5PfEgYO0CvPqS2wh19ar39acLSplcus72Oui693DwCbVrjMVl1gYj946IomeQB8m//Wk71m76C6hUjVsP70JxNLOQ3cn5APQP9cRV17iPaPbKtyrWD+w+ts5zuwe6s+yWgQx625pAPJhRUOu50d5BrE49BkBWSVG148WH12PKS7Xet+d4/K94hpzcvMY8QhUWxcLtW5ZgLO+IfVOnAdzdfViTxxXiXInNTWP48veq7Y/2DuLDoVeeh4iEEEIIIYQQF7Imzd08k9wJDg4mOTmZAQMG0KlTJzIzM8nIyCAgIMAuQTYXFxcXPvnkE6Kjo23JQABPT0+mTp16HiOr2R9JB1GwVkfd1XUYHcs7/dbX8oNp3FtmbfKgOHngMci+TVLOtBZxcdTwvzHWSrKSU9a15lSOLjh3HGzX+7VFn25LtG1f3z+sUWOY9KfJLm8Yg0aL76T5dV8AVdYOHBJR8zTlMrOJb09Y3z9OGq2tWrCywgOrbds+Y+9CZafOv58e3c6OrCQA+viE8PHQGahVMlVYtCwhxSdIWDC82v4IzyjK3Kr/vo7NTTsXYQkhhBBCCCFENY1OCDo7V6xZN3z4cL744gsuv/xysrKyyMzMpLS01C4BNobJZOLjjz9m8+bNhIeHc8stt9C+ffsaz73++uvPcXSN9+upONv25RE9GnRtidHMqf1b8VOs1Wce0Zc021p+tw4Ox9fVEUtpEWVpRwBwCu9lt+RQW1VmsvDFDmvSy0mr5tq+IQ0eQ1EU0j6/DUuJtcrPZ/Tt6AKrJ+7+a+2JbNv2qI41N9D5I+kgp0us60NOj4zBW+dS7Zzig9bp6Kg1Na5b2Bg5pcU8tqui0vT9IVfIuoGixUl2tv5vTE3p9Cf3/4YuLIaom96ssr+mikEhhBBCCCGEOBcanRHatm0bSvlaXrfccgtvvPEGERERFBcX07FjR8LCGlfd1FRms5kpU6aQl5fHkCFDWLJkCa+99hovv/wy9913X7Xz09LSCAoKOveBNpC+rIR/0o4D0MHdlx5eDVujcf2JbAYUb7e9du9ln3Xd/stBo+KBizoAUJIUa+tk7BTRt1nu15YsO5jB6cIyAGb0CsbL2aHBY+St/5SC3UsB0HgG4Hf50/W6bu3xLNv2yA41JwQ/PrrNtj2386Bqx00FWZQk7gXAuf1ANM72mXL/+K6/yC4tBqxThYe0i7TLuELY03cRDwGw8e7qFYI1VQ0KIYQQQgghxPnU6DIbtVqNRmOt+PLz82P79u3Mnj2befPmsXLlyvO2Vtx3331Heno6GzZs4PXXX2f//v3Mnz+f+++/n0cffbTKuZ9//jndunVj+/bttYzWcvyVfNi2ftoVET0b/P3942AGw8unCwO4RU+wa3xnzO4bSpi3tXr0zHRhAKeIPrVdIsp9Umm68JxB4Q2+vjT9aJXuviFzvkDrVnNyr7LCUhPbE/MAiA5yx89NV+2cU4U5rEyxNozp4unPiIDqFbdFB9fYtl27j2lo+DXamZXER0e2AuDl6MxL/ZonkS2EEEIIIYQQQlxI7DZnNCIighdeeMFewzXazp076dmzpy1ZqdVqWbBgAQEBAdxzzz107NiROXPmADB16lTef/99Dh06xMCBA89n2Gf1a+J+2/bl4T0bdK2iKKyPO8Y8k3X6rmN4H7QNrDCsjdFsQQHOpCcfHtXBdqzkZEUC0ilSKgTrkpRrYMWR0wB08nNlRPua1/GrjWIykrJwNkqZtZLOZ9w9uMXUL+m7+WQOJou12ndUx5rXpfzs2A7b+pVzOg2qMSFddGa6MPZJCFoUC3dt/dV23wV9J9S7o7YQQgghhBBCCCFq1zyLyJ1HnTp14tlnn0Wv11fpEnz33Xdz/PhxHnzwQa688kq8vb3x8fFh69ataLUt+9tgtlj4M/kQYO0uPNg/okHXH8ooJCRzG+ryxIpH70vtFtvS/em2bRXQNaAiYXNm+igaB5xCGrbm4YXmq11JlM/AZ86g8AZXgGb+/hwlCTsA0IX0oN1VL9X72rXHK60fWMN04eP6LN45aO1ArFWpub5jv2rnFMauQL/9JwBUjs44dxzSoPhr8u2JPWzLtFZN9vYJZl6Xpo95IfowvBunnN14pdJ6dSaTCa1WS2xuGjHeLX/JBCGEEEIIIYQQ9tWyM2GNMHv2bJ5++mnmzZvHd999V+XYiy++yDfffMOyZcu47rrrAFp8MhDAaDFTYLQ2aenu2a7BDRVOZBfhZdHbXuuCu9kttkMZhbUeMxdaE01aj3aotI52u2db9Oeh07bt6/qHNuhaQ/wOsv6wVueqtI6EzPsWtaPzWa6qsKZ8/UCVCi76T0Iwp7SYS1d9Sl6ZAbCu4fffKr2sZS9xevFjttfu/a5A7VB92nFDmC0Wno+t6Fj83mBpJFKX23+OJS5NX+OxTCdXklzca2x2EeMdRLQkBIUQQgghhBDigtPys2EN5OXlxWeffca0adPw8/Pj7bfftlVbubi40Lt3b/T6mv9wbqmctA54OzqTW2YgzVDQ4OtzDUby1RVJHHNRrt1iMxjNtR5TOTgBoJjK7Ha/tkhfYmRb+Rp+vYI9CPJwqve1ljIDKR/fAOXrS/pPew6n8F71vj7fYGRnkvXefUM88XGpSNyWmU1MW/MFR/WZgLVK742BU6pcX3RwTdVkYP9pBF33fr3vX5tfE+M4km+97yUhXRgWENXkMduyuDQ9sWkFxARVn1KtUaloX1LIxkvvsu3Lzs7G1/fs60sKIYQQQgghhGib2lxCEKxrA3700UfcdtttJCYmsnDhQgIDAzl06BB79+5l0aJF5zvEBgtx8SS3zEBqccOTmXkGI3mqSgnBwuw6zm6YuhOC1ioxxVRqt/u1Rf/G52AuX8NvbKea1/CrzeklT1KWap1O7txxCL4TH2zgvbMpvzWjK60fqCgKczctZn16PGB9/y0bewtulSr/zEW51mRkuXbTX8D3skeb3FBIURRe2FfRoOR/MaObNN6FIibIvcYOt/0XfnUeohFCCCGEEEII0ZK1yYQgwJw5c4iIiGDu3LlERkbSrVs3EhISWLhwIR06dDj7AC1MsIsH+/PS0RtLKDSWVknMnE1usZG8yhWChVl2i6vOhKBWEoL18c+xTNv2mAYkBIuObCDn7zcA67p9wXO/RKXWNOjeZ6YLA4yudO/n9/3DVyd2AeCqdWTZ2JsJcfWscm3aV3diykkGwC1mol2SgQB/pxxhT04KAMPaRdbY0ViIlig2rYDh726stv/hND3hJfEkLKiasC3x645a53quwhNCCCGEEEIImzabEAQYN24cx44dY+3atWRlZTFy5EiCg4PPd1iNEuxS0SAltVhPZ0//el+bV2IkX1VxvcmuFYKWWo+pzyQEjaUoimKXZFFbtPqoNSnnoFExon39pnGaDQWkfnwjZzqRBFz1CrrATg2+95pj5es8qlUMj7KuMvd9/B6e3LMCALVKxQ8jZ9PbN6TKdflbvke/9XsANG6+BN3yqd1+vq/uX2fbfixmtLxvRKsQHeRR67FYJQycIPo/+5XSYmr/DSqEEEIIIYQQzadNJwQBHBwcGD9+/PkOo8lCXCqqs1KL8xuUEKxeIXiupgxXrIWnmMpsU4hFhXyDkf3p1nUhB4V746Y7+0dSURTSPpuDMdM6ndel+2i8x9zR4HtnFpYSW96IYlC4F246LZsyErhxww+2c94aOJXLwrpXuc6YnUTaV7fbXgfd9DEOXvZpTLE7K5k1accB6OEVwKRQ+zXAEaI5fTg9ptZjw999jBVQbUq3auGtzRyVEEIIIYQQQtRM2na2EpUrBFMauI5gnsGIAR1l5fnfc72GIIClOM9u92xLNibk2Lb7hXrWcWaFori/0W//CQCNqw8hcz5H1YgOvP/GV7wPRnfy43Deaab88zll5Q1K7u42nLu7V01gmPSnSXzjUizF+QB4jbgJj/5XNPjetfng8Gbb9kM9R0p1oBBCCCGEEEII0QwkIdhKRLh527bjCxqW0NNq1ARZsnDEBIDGrWGNK+qSqi+p9ZgupIdtO2/T13a7Z1thMlt47M9DtteVm3rUpTD2L9t24A0f4OAb3qj7x2cX27bbt9MycdXH5JRa910a2o03/9NR2JSXzqkXR1GaHAeAQ7sOBMx6u1H3rs22zEQAnDUOXNu+j13HFkIIIYQQQgghhJUkBFuJTh4VU4SP6RvWFMTf1ZG+xgO21y5dRtgtrpM5hlqPeY+aByrrWyx39bsoZpPd7tsWfLItkbg063ThYZHeTO4RUK/rio/8a93QaHHvfVmj759RUN7sRWXm1YTfOVmYC8BAvzB+HDkbTaWqQ2NOCidfGklp6kEAHPyjiHh4NRpn92rjNlaZ2cTh/NMA9PQOxFHT5lc0EEIIIYQQQgghzgtJCLYSUe4+aMqTa0f1mWc5uyo/V0f6mQ7aXrt2ucguMeUbjOQajLUed/SPxL2fdTqpMTsR/c5f7HLftiC3uIwn/joMgEoFb1/es17TYy3FeZQk7QPAObJfkzqUpheUAgqEHuagPhWAKDcf/hh7M66VpnsXHVxD/DP9KEs7AlgrAyMfW4+jf2Sj712Tw/mnMSnWFgvR3vZZk1AIIYQQQgghhBDVSUKwlXBQa4hys3aBbXCFoJsj/csrBC0aHU5RA+wS08nc4rOe43vJ/bbtnL/ftMt924JnVx4lu9iaTL1pQBj9wrzqdZ0xYZuts7BLl4ubFEN6QSkExoOn9f3k5ejM8nG30K686k+xmMn89VlOvTIWc34GAI6BnYl8bD0OvmFNundN4nLTbdvR3oF2H18IIYQQQgghhBBWkhBsRTp5WNeYyykttq31Vh9BSjYdzEkA6Nv1Qm2nbr91TRc+w7nTUFsC0nBiK8XHt9rl3q3ZoYwC3tt0EgB3nZbnJ3at97Vl8Vts2y5NrPQ8aDwCfsmANeH86+gb6OZlnbZsys8g8dVLyFz6jC0B6dZ7MlFPbsHBJ6RJ961NbE6qbVsqBIUQQgghhBBCiOYjCcFWpLNn5XUE6z9tODzuM9t2cruhdosnIefsSUmVSlW1SnDlW3a7f2ukKAr3/3YAs8WaZHtibCcCPZzqfX3ZifIuvCoVLp2H131yHf5KPkSa637b60+GzWBkUEcAik9sI/7J3hQd/Md6UKMl4JrXCbvvNzTlVarNoXKFYIyPJASFEEIIIYQQQojmIgnBViTM1dO2nVCQU69rFEXBLfY7AIpxYlfINLvFk5R39gpBAI8B09H6hAKg3/Ez5uJ8u8XQ2hzPKuLvI9ZkbgdfF+69KKre15oKsjAlW9cPdArvjcbF8yxX1GxXVjIz1n4N5UsWhpV14fqO/W3H0z65GVO+NTnn4BtO5P824DvhgXqtcdgUcblpAAQ4u+Pv5Nas9xJCCCGEEEIIIS5k0sazFVmdesy23cHdt34XKRZUJXoA4hw64eLVzm7xtHOr39RjldYB9z5TyP3nA7CYKcuMxzmij93iaE0MRotte2xnf3RaTb2vzd/4JVjMALjFTGrU/U8V5nDp6k8pMpVZd+QGoDZE2o5bygy2TsKOwd2Ienxjs1YFnpFZUkhyeaK4l0wXrtXtP8cSl6avtj82rYCYIPt1fBZCCCGEEEII0bZJhWArkVasZ2XqUQA6e/jT36+eTR1UVX/EXdrZr/JqcIRXvc918A23bZuyk+wWQ2sT4lkxPThNX1Lv6xRFIXfdIusLlQqvi+c0+N4WxcING34gw1AAgLfZH1I7cyqnhPzybtGm3Ip1/Jwj+5+TZCDAnuwU23Zf39Bzcs/WKC5NT2xaQbX9MUHuRAd5nIeIhBBCCCGEEEK0RlIh2Ep8F78bS3lzh+s79qv39M3K56kUhc7+rnaLqX+oFxp1/eJw8KlICBqzE+0WQ2vj4+KATqum1GQhJb/+CcHiw+spS7cmhF17XoKjf2SD7/3uwU2sT48HoKO7H2M141ioWBNx+9MLGBblgzG3IjGn9W6e5iE1qZwQ7OMbfM7u2xrFBLmz8e7Grx8pWpYjDi4MX/5ejceivYP4cOiV5zgiIYQQQgghxIVAKgRbia+O77JtX9ehX4OutZQvFqfGQmd/+1UIuuq09Z6mWLlC0Jhz4SYEVSoVweVNRBqSELRVBwLeI29t8H2P5J/m0V3LAVCrVHw5YiYDgv1sx2PLp6GaKiUEHc5hQnB35YRgM3UxFqKl6WI00MVYc3Om2Nw027qaQgghhBBCCGFvUiHYCuzLSSW2/A/DUYEdCHfzbtD1CipAwUmrwk1n3x/54Ahv0jed/TwH34opzsYLeMowWKcNJ+QUk1FYislsQaupOy9vKsiiYOcSANQeAbj3vqxB9zNbLNy44UdKzCYAHupxMUMDInEsy7OdE5tanhDMq5gyfE4rBHOsCUF3Bx0dPOq5PqYQrUhsWgHD391YZd/Dh/fh4qBh7LxF1c6vrWpQCCGEEEIIIexBKgRbga+O77RtV+4GWx8FJSYs5T9mF639u8QOjqhfclLrFWxbz/BCnjIM2CoEFQXSC0rPen7+xi9RypuAOA+chUrr0KD7vbZ/HVszTwHQ3SuAZ/tcYt0OcOPMjO8zFYLGZqgQVMqnutfmZEEOx/RZAPT2CUatkl9Lom2JDvKosZq6qMxMsdF8HiISQgghhBBCXOikQrAVWJp4AABnjQNXRkY36NqTucWYUeMAuGosZz2/oQZHeLO0Pieq1Kid3LAY9Jj0GXaPozWp3FgkKc9AqJdzreea9Jlk/fmK9YVKhfPg2Q2615H80zy1528ANCo1X424BqfyhKKLo5ZAdydS9SUczypCURSKj1ZUMGl9mtbco8hYynX/fs/vSQfwc3IjxMWDEBfPii9XD7ZnJvHZse22a2S6sGiLPpweU+P+3+/UEFJ8goQF1deELPHrjlpnvzVfhRBCCCGEEKIySQi2cEaLmZOFOQD08Q3B3cHpLFdU5emk5ZDamzBLBq4G+yfiOvpW/MFaVx1Y8ZF/sRisVWhO4b3sHkdr0qlSY5dDGYUMiay9k2/al7dj1p8GwGPwNWgqNWc5G0VRuG3zz5RZrBVIj8WMpp9fRZLveFYRqeWdjru2c0O/fTElCTsAcIroi9YrqP4P9R/ZJUVcuvpTtmVaq0EzDAVkGAqqrBX4X16OztzYaUCj73khu+HzezlQaqjx2GGNE13N9V+vUpw7yc7tAajpN4BSWoz9/xOOEEIIIYQQQlhJQrCFSynKt3UXjmzg2oEAQR5OrNYEEGbJwK0sG0tpkV2rTtT/6TJc25p4+Zu/tm17DmlYlVtb0yOgYurggYyCWs8rTT1kWztQ6xlI4Ox3yD/7DGObz4/tsHUV7uLpz+MxY6ocXxJb0bDgypggclbOt70OuOa1eney/q/EwlwuWfkxh/OtiUx3rQ5/ZzdSivMpLV/HsDIvR2fu6z6Ce7oPx1vn0qh7XugOlBpqTfx1NZfQQ1d7Fao4f76LeAigxq7RqoUNbx4khBBCCCGEEPUlCcEW7kx1IEBEIxKCDho1OU4hYIwFoCwzAafQnnaLD6By2uhEdjFd2lXtZGwpM6Df8TMAaldv3HpNsuv9W5segZUSgum1JwSLDq21bfte9hhaN18oza7XPTIMBTy04w/b64+GTrdNFT6jckJwakAxRce3AOAU1R/XbqPqdZ//OpSXwfi/F5FcnA9AuKsXPw68isGRnVEUhZzSYlKK88u/9DiqNVwe3hMPx4ZVvorquppL2FlDcwohhBBCCCGEEOK/JCHYwp0qzLVtR7rVPrW0LsXuYVCedyrNOGH3hGBlBzMKqiUEC/b8YZsu7DnwKtQOuma7f2vg6+pIgLuOjILSOhOCxUf+tW03NEF337bfyC2zTiGd03kQFwd2qHI8MbeYHUl5AAwM98L5wM8UlR/zHHpdg+51xtbTp7h09afklBYD1gYmf4+fi3OJdcqySqXC18kVXydXYnyCG3UPIYQQQgghhBBCNJ2082zhTlZKCDamQhDA4h1h285JPtrkmOpysIYpsFWmCzcy2dTWnJk2nJxfQr7BWO24oii2hKDa1RtdSI96jasoCi/G/sMPCXsBCHB255X+l1Y779e4dNv2lT0Dyd/8jfWFWoPn4JkNeRQAViQfZszfC23JwCH+EWyYdCehrl4NHksIIYQQQgghhBDNSxKCLdyposoVgo1LCDr4t7dt61NPNDmmuhxML6zy2qTPpDBuRXkcUTh3Gtqs928tKk8brimJWpZxHFOedUqvS+cRqNRn/6gezjvN9LVf8b9df9n2vTNoao3r8i2Jq5gufIVHIsbT1veFW/QEtB7t6v0ciqKw6MhWJq/+jGKTNbE5MaQrqy65FR9ZD1AIIYQQQgghhGiRZMpwC1dorOgisTs7hS6e9U/WnOHr62fbLsrLtEtctTmZW1zldUnSPihvJOEWM7HRjSramoyCip9rVlFZteOG8vX8AFy7XFTnWHE5aSzYt5rFJ2NRyns9q1Dx+sDJXBXVu9r5fxxIZ0O8dW3KXsEeuMZ9Q175Mc+h9W/4klKUz9xNi/kr5bBt3+wOffls+NU4qDX1HkcIIYQQQgghhBDnliQEW7iro3qz+KS1Ichtm3+mv28onTz9GzRGRzJs2+kOgXaN77/8XR2rvNYFdweVCipNgb3QLYlN5ad9qQD4uToyPKr62pAlSbG2bafIftWOWxQLW08n8ur+dSxN3F/lWICzO58Om8GlYd2rXZdRUMqcn/bZXj861J/8z74DrFOT3ftOPWv8iqLw9Yld3LNtKfllFV1t5/ccyUv9J6FWSeFxc7n21GuEGuJJWOBRZb/iHolKKjKFEEIIIYQQQtSTJARbuCsjY5jTeRCfHN1GgbGUGeu+Zsuld+P8n46xdQk2JNi2jztENkOUFSJ8qiYlHLyDcek2iuKDayhN3k9JUhxOYdHNGkNLdrqglHk/x9lef3hlNN4ujtXOK02uOEdX/v0qMJawPO0I6w8lszz5EBmGqlONQ1w8eSR6FHM6D6rx/XEyp5hLFm3ldKG1InFGryDGFa4ho8xa1ek14ibUjs51xp9erOe2zUv4PemAbV+4qxefDb+aMcGdzvb4oon+8NeRpotG6+RaZf9RBxe6qaX6VgghhBBCCCFE/UhCsBV4Z9DlbM9MJDY3jX05qdy37Tc+Gja93tfrsg5zZoJqfHMnBL2rJ5Q8B11D8cE1AORv+Q6nsBebNYaWSlEUbvs51jZF+No+IUzvVXO33TMJwQz/DqxJPMQfSQdZl36CMou52rmRbt48Gj2aGzsNQKep+SMdl6ZnwqJtpOqtFX2RPs58MC2avBdutJ3jPfLWOmP/MWEvd2791dY4BKwdjF8fMBkPR6e6H17YxSlnN066uNM3qGOV/b2AaO+g8xOUEEIIIYQQQohWRxKCrYCz1oHFo66n3+9vUWgqZdHRrVwc2J5rO/St3wAZhwAoQ8sJpXmnDNeUEPQYcCVpX90BZiP6bd/TbsYLF+Ragt/sSmbpfmt33yAPHe9O61njeQfTjvKxRxirOozmgHsgbFta7RwPBycmhHTh8oieTI+MqXPNvg3x2Uz+dDv5Jda1HHsGurPi1kG4pO7gdIq10s+l+2h0QV2qXasoCn8lH+bluLX8mxFv2x/s4sEnw2YwMbRbvZ9f2EdkcQEbL73rfIchhBBCCCGEEKIVk4RgK9HZ05+Ph03nmvXfAvDAjj+YFhGN01mmDisWM2WpBwFI0ISSVWJp1jjDvaqvY6Zx9ca91yQKdv+GMesUhuNbcLnAug0n5xm4+9eKtf4+vaoXPuVThRVFIS43jSWn4lhyMpYDeRnQfkS1MTq6+zHWP4oZnfoyIrB9vRp3/LY/nZlf76LEZP25D4/y4febB+Dt4kjK9wtt5/mMmlflOpPFzE8J+3g5bi2xuWlVjl3foR9v1dK9WAghhBBCCCGEEC2fJARbkZnt+7A08QA/Juwlw1DAF8d3MK9r3Ym1stPxKEbrNNFj2ghyDUa7x6UAZ+r9aqoQBPAYfA0Fu38DIHfdIpw7DrlgqgTNFoXrv99jq9CbOzicid0CACg1m5iy+jNWph6t8doBTs7M6DmaKeE96OLZjuzsbHx9fet138+3JzLnp31YrI2HmdojgO+v64ezgwZTQRb6HYsB0HoG4t73ctt1yUV5jPt7EYfzT1cZL9o7iOf7TmByeI+GPL4QQgghhBBCCCFaGEkItjL/ixnNjwl7AXh0159MDO1KhFv1LrVnWEoLbdsR5lQKDaW1nmsP/m7VG2QAuPeejNrJDUtJIfkbv8R4Oh7nTkNxjuqPU2R/HPwi2myC8PnVx1h7PBuwJkxfn1yRUHty94oqyUC1SsXA0gJGn9rG2MzjDHliA04RvRt8z3c3JHDP0oqKxDmDwvnwymi0GmsHYP3W71FM1rUMvS66GVV5pamiKNy66ecqycCLA9vzSPQoJoR0bbM/IyGEEEIIIYQQ4kIiCcFWJsYnmFs6DeTTY9vJLyvhun+/Z+2E29Go1TWe7xQajS40mtLkOKJNx7ix4Efg0maLr7aEkVrnQsCst0n79BYAio9uoPjoBttxjZsvTlH9cW4/EO9R83DwrrnZRmuzIT6bZ1ceAUCrVvHjdf1wd7J+7NalHee1/esBcNJoeX3AZKY4u6B/2ro2pGNQV3ThvRp8z/8mAx8d3ZEXJlVN5uVv+da27TXiJtv2jwl7+SvlMGDtHvzjyOsY3C6iwTEIIYQQQgghhBCi5ao5iyRatLcGTaWThx8AGzISeDF2Ta3nqjRagm/5FHP5j/rm/K/J2/il3WJRFKXe53pfdDOhd/6EY0DHasfMhdkUxf1N1m/PkfzulQ0at6XKKS5j1re7bVN2X5jUlUER3gDklRq4fsMPKFgPvjZgMnd0G4bm309t1/uMu7vBFXmfbUuskgx8fmJXXry0W5VxyjKOYzixDQCn9gNtP4+c0mLu3fab7byPhk6XZKAQQgghhBBCCNEGSYVgLRRFwWKxoNGcvXHDuebmoOO7i2cxZNm7mBQLz+xdyZjgjgxpF1nj+c7tB/CR/+3ckfk+AKmfzUHrGYhb9CVNjiXvP2sSmi0Wvovfw1cndjK8XRSP9xqDtlLzC4+BM/AYOANTYTYlCbswnNxJScJODAk7MeUkAWA4sRXDia24dBzS5PjOF0VRmPPTPpLyrOs3XtLFnwcv7mA7ftfWX0kqygNgQkgX7ug6FLNBT/4ma7JW7eyB17DrG3TPH/ekMGfxPtvrFyZ15bExnaqdl7/lO9u255BZtu1n9qzkdIl1ivm17fswIbRrg+4v7OP2n2OJS9PXeMysKGhk2rYQQgghhBBCiCaShOB/KIrCK6+8wssvv0x+fj4XXXQRCxYsYNiwYec7tCr6+4WxoO8EHt31J2bFwqz137F36gN4ODrVeP6v7lPRFaZxi+EXMJtIevdKIv/3L86RfZsUR0ZBxZqEZo2KHktf5Uh+JgCrU4+xPSuRH0bOxt2halxaN1/cosfjFj3eti9v0zekLroOgJxV77bqhODCLaf4NS4dgAB3HV9e0we12prI+T5+D9/G7wbAV+fCZ8OvRqVSkbfhCyzlCTmvETejdnKr9/3+OJDO7O/2cKaw8n9jOtaYDFQUhfzN31hfqDV4DroagKySIj45aq0a9HR04s2BUxr+0MIu4tL0xKYVEBPkXu2YRqWyvY9E23dY40T/hbfWeKyHzpkvb3r7HEckhBBCCCGEaCtkyvB/vPrqq/z4448sX76cVatWodVqueiii3j99dfPd2jVzI8eyahAa9VZQmEOd239tdZzTRYLb7pcz3rPsQAopUUkvjGJssyEJsWQVlCCWWNNUJQ6amzJwDP+TD7M8OXvk1iYe9axPAddjdbLunagfsdijLmpTYrtfIlL03P/bwdsr7+6pjcB7joAkgrzuH3LEtuxj4fNIMjFA8ViIXf1u9adKhU+Y++s9/1WH81kxle7MJXPTb5nRBQLJtZc3VeSsJOyjGMAuPYYi9bT2u34/UObMJit1Z7zugyhnXP1ZJQ4d2KC3Nl49/BqXy6OGpy08mu7LYlNK2D4uxurfTkXKUSWFtd4zWGNEwdKDec4UiGEEEIIIURbIhWC//HKK6+wdOlShgyxVqeNGjWKp556ioceegiVSsUDDzxQ77H0ej16fcXUv7S0NLvGqlap+eqia4hZ+jq5ZQa+PrGLyWHdmRFVvRGF0aygqNR8FPIwk0IUig7+gzk/g8TXJxL19HY0zh6NiuHp/b/j4qhBazDZ9o0L7sy17fvw8M5lZJYUEZubRr/f3+LZPuOZ22UwDuqap2GrtA54j55H5i9PgdlE7rpFtLvimUbFdb4UlpqY+fUuSk0WAOaP7MD4Lu0AKDObmP3vd+SXWacR39JpIFdERAOQv/kbyjKOA+AWM7HGdRZrcjSzkKmf77Dd7+aBYbw5pUeNaw8qFgtZy1+2vfYcMtsW13uHNgHgoNZwT/fhDX5uIUTDRQfV/nt3X/Y0a2J4XvXPY/+Ft3LEwYXhy9+z7TOZTGi11v9Jj/YO4sOhV9o/YCGEEEIIIUSbIQnBShRFIT8/n+LiiqoMlUrFc889h6IozJ8/n8GDBzN06NB6jffGG2/w7LPPVtufm5uLs7NzrddVTiKejTPwZsxEbtz5CwCPbP+DEW5B1ZJuuvIqvpN6Iw63foT2w6mY0g5QlnaEkx/diOfsRQ1uYAEQpz/FoEqvbw0ayQv9rcnU6GHXce22xRwtzCartIg7t/7K63HreLzbxfTxCsJgNlFsNmI482UyYQzqR6izN2GGXPL3LEdz0d0Njqk+FEVhddJh0k+VUmgqo8hUZv3XbP232GSkm4c/c6P646tzqdeYFkXh5l+OcDDDOu23T5Ab9w/yJzs7G0VRuHfvn/ybEQ9AhLMHjzp7krzyI0wpcRT/u9A2jnbQjWRnZ9d4j/++N15fnUBxmRmAy7v58uLoUHJzc6o/r8VMweIHMey0VieqnDwwRo0gOzubxOI8skqLABjtH4XOYCLbUPP9G6Mh72d78/X1PW/3FuJsPpweU+ux4e9urPVYF2Pt1YGxufb9D09CCCGEEEKItkkSgpWoVCpGjRrFCy+8wNixY1GrK6bmPffcc2zZsoWnnnqK1atX12u8Bx54gDlz5thep6WlMXDgQLy9vc+aqGhIIuMG36EsTj/E8uRDJBTn8UdOPHO7DK5yzqTuAXy2PYn8EjOxBnfGzP+L+Kf6YC7MpnTPr2h6T8R75Nx63/OMzy66ikV//5/t9aLkDThoXXlv7Ch8fX3ZFnAf923/ja+O70JBIb4ol1t2Lq170EE3E1SiZ1BBOpfnxDM6qBNhbl4Njq0mZouFxSf38VLcWvbl1D0leXn6URbG7+Tu7sN4sMfF+Dq51nn+86uPsuyINRnn76zm5yvC8NQfJ/N0PP+XeJjvDNY/4p3NJl7b8D5lfz1N2X/G8B5zB4FDp9eZnD3z3jCaLfx6eCcAro4avrluIK666h9pxWwi9ZObMGwrXztQoyVk7ud4BFs7CLt5eaJChYJCEeZmSaJJYk4I+1mQb13qIWreItu+7OxsfH19q1QNCiGEEEIIIURtZDGq/1iwYAEbN27kscceq7JfpVLxyCOPsH79epQznRvOwsPDg9DQUNtXUFBQc4QMwLN9KjoGP7JzOSlF+VWOT4+puPfifak4+IYRPPdL2770b+6hNPVQg+97RWRPnErNFTs0Zt5PWs6IJV9SZjbhpXPmixEz2TP1fi4J6VLvcdOcPFjq35kbN/5I+OIFdPr5JeZt/pktp0/W+/tfWanZxMdHttL1l1e4Zv23Z00GnlFoKuXF2DVE/fwCT+5eQW4ta3qtPpTKrqXv82n+E6zMmcPalMvRP9eVZz+/i177N/NZeTJQpSi8evAPuheerjqASo3vpY8QeN179a7UXHU0k8xCa0pxWnRQzclAUxnJH15jaySi0joSdtcSPPpPs52j02gJc/UE4ITefpWBQgghhBBCCCGEaJku6ArBP/74g08++QQHBwf+7//+j+7duzNw4EDeeust7r7bOlX1pZdesiVo3N3d8fb2btTU2ubWzy+UGzv254vjO8ktM3Dzxh9ZMX6uLdYxnfzxcnYgz2Bk6f50Fk634N77UnwmPEjOitdRjCVkLXuJkFu/PMudqlOX5+e05evYAWzUx9Hxu7c5fs29OGq19PIJZsX4ufyTeozv4/dgUiy4aB1w0TjionXAuXy7xGxk9d4VbCk1UKTV2cY7XpDF8SNZfHRkKwP8wri3+whmRMbgqKn7LVxoLGXRka28fmA9qcVVp64O8Q3jlq6D8dG54O6gw02rs/7r4IhZUXjv0CY+PLyZErOJAmMpC/at5p2DG7m/xwhu6jSAcFdvFGMJJ1d8iHrpyywwW5N8FmB5u668EzWcFGdP2/2czEb+d2wN48wlOHYfjS6wC45BXdAFdUUXGo2Dd3CDvu/f7Eqxbc/uF1LtuKWshOT3r6Jw7x8AqBycCLt3KW7Rl1Q7t6OHH4lFeaQZ9BQZS3F10FU7RwghhBBCCCGEEG3DBZsQfPzxx/nmm2+4+uqr+euvv5g4cSInT55EpVJx1113AXD//fezbds2/ve//+Hi4sLdd99drXKwJXlr0FTWpp/gVGEuK1OP8sHhzdzZbRgAjlo1U3sE8OXOZHKKjaw7ns24Lv60m/48+Zu/xqw/jX7bDwRc/Yqt82xD6YwWrvYfxY8Z60FtIcmURu9PfuGfa6cQ5OEEwJjgTowJ7lTnOPOKMjj10SwOugVwYOTtbHMPZGNGgq0L7o6sJGb/+x0P7fiD27sO4bYuQwhwdseiWDimz2JbZiLbMhPZnpXIvpw0jBZzlfEvDe3GYzGj6ar1qHMq6xsDpzC/50hejlvLwiNbKDWb0BtLeHbvKp7duwoXlYqowizaF2TQPiSS9sUeqBWFDzuM4KBLxbhq4DqfAJ7sOoTIWQvQ2KGDb0GJiaX7rWuFBbrrGN3Rr8pxS2kxSW9fTtGBVQCodK6E378M124jaxyvo7sfa9KsTU1OFGQT49Ow5KQQQgghhBBCCCFajwsyIfjPP/+wePFi9uzZg4+PD3fffTdRUVGUlZWh01kro+666y4GDRrEk08+yZQpU/D29ubRRx/l3nvvPc/R187T0ZkvR8xk1F8LUVCYv2MZY4M70cXT2uV2Rq9gvtyZDMDi2FTGdfFH7aDDe9Q8sn77PxRTGblrFuJ/xdONjuGHyy4lYp0XryT8CsAhy0F6v+HJD7P7Meo/Sava6EK6o1UUYgrSuSg/keemP0Wp2cSvp+J4++BGtmaeAiDdUMDTe1by/L5/GOAXxoG8DPLKal5sX61ScVVkLx6NGU2v8mRXbY07Kgty8eCtQVOZ33MkL8WtYdGRrZSVJxiLFYUDrr4ccK09qTglrAcv9p9Id6/Aej17fa05noXBaK3InNknGK2mYva/paSQxDcvo/jwegDUzh6EP/gXLp1qb4bTwaPiGSQhKIQQQgghhBBCtG0X5BqCH3zwAW+//TY+Pj6AtdlHcHAw48ePp1+/fnz11VcADBgwgBUrVlBSUkJaWlqLTgaecXFgBx7ocREABrORKas/Z39518mxnf3wcLLmgH+NS8dotiaUvEfPA40DADlrP8RsaHxXWEVReGRIn4odzoWctmQwduEWnlpx2HbPujgGdgGV9a1ZmnIAsK5zN7N9H7ZcdjfbLruH2R362jopl1nMbDp9sloyUKNS09snmHu6DefwFQ/z/cjZtmRgQ4W4evLOwKmsS93JXQmbGH/6CB2KstD+p/rwjEH+4fw78Q5+G3uT3ZOBADuT8mzbYzv527YVk5HEt6dWJANdvYl45J86k4FgrRA845g+y77BCiGEEEIIIYQQokW5ICsEY2JiuOQS6zpq6enpzJo1i/79+3PVVVexevVqbrjhBry9vZk8efJ5jrRxFvSdwN8pR9ifl85RfSYD/nibdwdfwS2dBnJ5z0C+2plMVkkhL2zZQTs/MwfzMjg59FYKc1MoVWsxf/8kFv8oSkwmSswmHDUa/HSu+Dm52v711bngq3Mh31hCmYMaR6MFg06D17dPojeWVA1IY8KiwHOrjrHySCbfzOpLR7/aO/aqHZ3QBXWlNPUgJad2YykpRO3kZjs+0D+cr/2v5dX+l7HwyBYWHtlKhqGASDdvBvqFM8g/nIH+4fT1DcFF62i372vexi/wPLyG2wGTSsvPurF86jyUVGdP7hzdjuB2FtINBYwK6sDl4T2bda3JHZUSgn1DresUKopC+jd3U3xwDQAadz8iHv4Hp/CYs46XXikJrKblrZEphBBCCCGEEEII+7kgE4JPP10xJfb7779n1qxZPPPMMwDMnDmTpKQkvvrqq1abEHTSOrB83C1MX/sVO7KSKDGbmLtpMT8m7CVLVwpd00Br5JljwLHyizRO4NehYpCs5Hrf7xKtNSFoUauqJQPv6z6C4MgePPHXEcrMFrYl5tH79fV8elUvru5TvRHGGa49x1GaehDFVEbRwTW4951S7ZxAFw+e6XMJT/UeR5GpDHcHp3rH3FDm4nxOL65YP/Imj+fY7dADB42Kdyb14O4RUc127/+yWBS2JeYBEOHtbFufMXf1e+Su/QgAlaMz4Q+uqFcyEOCHhL227cvCuts1XtEw1556jVBDPAkLPKodU9wjUelczkNUQgghhBBCCCHakgsyIVjZ/fffX21fhw4dKCoqOg/R2E+4mzcbJ93JY7v+5I0D/wKwOrU8+3eWn7pKUdApZlx0bui0jpRaTOSUFp/1nipFobtXAJFu3kS5+XBlZAyjgjoCMK6zP9d+u5tDGYUUlZmZ9d0evJwduKRruxrHcouZSM7KtwEojP2rxoTgGWqVulmTgWUmC/8ufIhgvbWL8O+6kex26EGEtzM/Xd+PgeHezXbvmhzNLCTPYG2wMjjCeu/CuJWkf3uf7ZyQW7/COapfvcZLLspjQ0YCAL19gunqVfPPRJwboYZ4QopPAH2qHVPpXFDraq+uFUIIIYQQQggh6uOCTwj+V0ZGBkuWLOHnn38+36E0maNGy+sDpzAysAM3bvzRltTz0bqTk+sAJS6MjYhgwei+RLh646J1JOvTmzFs/R4V4Nb7MsLu+x2VSoXJYia3zEB2STFZpUVklRSRVVqEu1bHD38+B4BLiZkDV8yvMZbeIZ7suv8i7l26n4+3JmK2KFz19S423TWMnkHVK6FculyMytEZpcxAYdxfKIrSrFNwa1JqMvPZ9iS+WbGGD059DkAxTrzhcgNXxgSxaEYMPi72m5JcX1tP5dm2B4V7UZp6mOQPrgLFuj6j/7T/w2PA9HqP91PCPtv2zKje9gpTNEGKSwf6PbGx2n6n5e+dh2iEEEIIIYQQQrQ1khCs5ODBg8ycOZNbb72VESNGnO9w7GZyeA9Sr36K4/osIty8Ucwagv9vJYWlZnbka+l5eQiuOutbwfX69zlx5F9MuSkU7l1G3vpP8R45B61ag7+TG/6V1vI746ez9wkBwNlBw0fTYygsNfP9nhT0JSYu+3Q72+4dQYC7rsq5akcnXLuNpnDfcoxZpyhLO4wuuFuTvxf1UVhq4tNtibyy9gSp+QY+0r+HA9bmIf9G3czymy9nQLjXOYmlJlsTc23bQ/wh6a3JWIrzAfAYNBO/KU80aLzvE/bYtq+WhKAQQgghhBBCCNHmtdmE4JYtW9i8eTPh4eFMnjwZJ6fap5SazWZmzpxJYmIiTzzxBFddddU5jPTc0Gm09PAu73brALP7hrJwyynyS0z8sDeVWwaFA6Bx9SZ4zuckvjoegPTv7sO12ygcAzrUNnSDqFQqPru6FydzitlyKpdTuQamfradtXcMxdlBU+Vct5iJFO5bDlinDTd3QjA+u4h3Nybw2fYk9CUmAEaW7WC40ZowU3yiuO/xN1A76OoaptltPWVNCDqrzbT7bS4lGccBcIoaQPCcz+pVSVlkLCXdUMDBvAx2lq8XOcQ/gkh3n+YLXNTLh+HdOOXsxis1VAPG5qYR4x10HqISLU1pUiwJC4bbXptMJvRaLSV+3WVauRBCCCGEEOKs2mRCcP78+Xz99df06NGDLVu24Ovry+eff87YsWOrnWsymdBqtXz//fdotW3y21Gj24dGsnDLKQA+3ZZoSwgCuPUch8+4u8lZ9S5KaRGJr08g/KG/cWzX3i73dnLQ8NvNAxj09kYScorZlpjHVV/tYskN/XHUqiviiJlo285d8yEeA2bg4BvWoHuVph6iJHEfFoMeS0kB5vJ/LQY9Bn0WZT7BFIcO5p2UEN6PM2C2KLZrO5iTeLHsI9vr8OvfPu/JwJ/2ZxKXZu0I/KDDP5QcXguA1juEsHuXonZ0rvXag3npfHJ0O9/F7yHDUFDt+Mz2vZslZtEwp5zdOOniTk2p2RjvIKIlIXjBcwqNrvWYUlpMbUXbt29eQlxuWq3XRnsH8eHQK5sYnRBCCCGEEKI1aHMZsL/++ovFixdz6NAhvL29OX36NHPmzGHixIl8/vnnzJ4923bun3/+yfz581m5ciUhIbV3vG2LYoI9iPJxISGnmISc6g1D2s14icL9qyhLO0xZxnFOLhhG+EMrcArvZZf7+7vpWD5nIEPe2Uh+iYllBzOY+c0ufryuHw4aa1LQsV17nKIGUJKwg7KM4yT83yACZr6Ge79pqB3rbiJSfHwrWb8vsFUY1qYUgA+5DRirCWOHQ0/2ufRicNcOTN33FJRmA9bkpFvvy5r+4I1kMJq559f9fLIt0bbvYs0R23boXT/j4B1c7boiYyk/ndzHJ0e3s/n0yVrHd9PquCrSPj9b0XSRxQVsvPSu8x2GaKGCbvyw2r7s7Gx8fX1RLbyVIw4uDK+hwnRT+e+AYe0iqx2LrSNRKIQQQgghhGh72lxCcNWqVYwaNQpvb2v31Xbt2rF06VLmzZvHTTfdRFBQEGPGjAEgKiqKnJwcvv76ax599NHzGfZ5oVFbp5aqa5hiqta5EPHwKhLfvIzSxH2Y8tM5+cJFhN33O65dL7bL/bsFuPPnnEFc8vFWCkvN/BqXzqxvd/PdrL5oy5OCoXf+ROIbkyhLPYQpL42UhbPQuPrgOew6vC6ei1NoD9t4iqKQuGsVmb8vwOXUhgbH08GcRAdzEjNL/oLNFfudOwwm5LZvznlTkzOOZhYy48tdxJZXBgLcOSySqH25lAIqrSPO7QdWuSYuJ40PDm/mu/g96I0lVY65aB0Y3i6KIBcPAp3dCXB2Z0JIFwJdqjd3EY13+8+xtmrOmkQHefDh9JhzGJG4EHQxGmo9NqxdZK1VgDUlEIUQQgghhBBtV5tLCPr7+/Pbb7/ZpgIDqNVqFi5cSFpaGjfeeCPHjx9Hp9PRrVs39uzZQ2Bg4HmO+vywKNbpsepa8lwOPqFEPraepLenUnx4PRaDnsTXLiFk3vd49L/CLjEMjfLhzzmDmPDxNorLzCzel8b2xDVM6RHI1B4BXNQhnKgnNpH8wUyK9q8EwFyUQ87Kt8lZ+TZloQPYF3oFsQU6Bh7/jOjSA7hUGj9RHchPThPIVHtTpHKmSOVCodqFIpUzxTgRYUljhHKQqc5H8c/eC6ayKvG59hhH2D2/oK6hmcq58NPeVG75aS+FpdamJm6OGj69ujdX9Q7myLokwDpdWKWumGr9d8oRLlv1KSal6sTB/n6hzOk0iGva98HjLBWWouni0vTEphUQE+Re7VhsWvUp20LYw4L8BEqTYtFlHazxuFNoNMi0YCGEEEIIIS54bS4hOGvWLJ555hmee+45nn32Wdt+tVrNxx9/TFRUFMuXL2fatGkAF2wyEColBGvLCAIaF0/CH1xBykezKNj5C4qxlOT3phN040K8R861Sxwj2vuy7JaBXPrJNgxGC6dyDby7MYF3Nybg5ezApK7tmDr2M/qNOU7GPx/hemgpDmZrFYxj8g4GJO9gwH/GPKEJ4yPnGezyHUMHfw+cHDQ4adR4aFQ4atU4atRYTGX0DhvOrUMi8HJ2wFJmwHBiK0WH1mE4vgVdcDfaXf3KeVk3UFEUFqw+xlMrKqYF9wr2YNGUDgzsFIxiKsOcnwGAg0/Fuor5ZQZu2fiTLRno6ejE7PZ9mdN5EL19L6xp8S1BTJA7G+8eXm3/8Hc3nodoRGsTm1ZQ63ultgrTutYXLE2KtVtsQgghhBBCiNatzSUEw8PDeeGFF5g/fz6hoaHMnVuRtAoMDGTw4MEkJSWdxwhbjjP9M+rIB1qPOzoReudPpH15B3nrFoFiIe3zWzHlZ+A35XG7xDKqox/r7hjKglXHWHU0kxKTNaGVZzDy3Z4UvtuTUn7mNbh6TmVS6b9ML11JT9PxKuOkuHbmZJ87CRg8nYVh3oR4OtU61ffMmlsVz+mMa7dRuHYbZZdnaiyj2cK8n2P5bHvF+3Tu4HDevrwnxfo86zm5KbZjWp9Q2/b8HctIKc4H4LKwbvw48jpctI7nJnAhhN1EB9U+hb+uCtOa1hc8o3JXYiGEEEIIIcSFrc0lBAEefPBBEhMTue2220hOTubJJ59Eq9WSm5vLoUOHePXVV893iC2CxXJmyvDZ18ZTqTUE3bgQrWcAWb89B0DmL09iLsi0WzwDw735/ZaBFJWaWHU0k98OZLDsYAZZRVWn8RapXVjiMoETna5mqncGo3L+JMCSRdDYeXTrNem8rfVnD/oSI1d+sZPVx7IAa7L27ct7ctfwKADOtH8x5iTbrjlTIbg69SgfH90GgJejMx8NnS7JQCFaqbrWl5QKUyGEEEIIIURTtcmEIMDbb79NeHg4jz/+ON9++y0jRoxg7dq1zJ07l/79+5/v8FqEMxWCafoSlh/M4NLuAXWer1KpaDft/9C6tyP923tAUchZ9Q5wBWC/JJyrTsvl0UFcHh2E2aKw+WQOv+1P50R2MTFBHgyP8mFwhDfuTmfevjPsdu/zyWJRuOab3bZkoIujhu9n9WVKz+rT2s3607ZtrWcg+3JSuXb9t7Z9bw6cQrCLZ/MHLYQQQgghhBBCiFanzSYEwVopeNVVV/H999+TlZXFp59+auswLKB/mCe/HyjBYLRw2afbuXNYJC9f2g1XXd1vC59xd6F29iD14xsAaypQaaYYNWoVI9r7MqK979lPbuXe/DeePw9ZE33+bo78OWcQ/cO8ajxXsZht23vNCjP++pDcMuu6ihNDunJDR0l6CyGEEEIIIYQQomZtOiEIEBYWxsMPP3y+w6jivUMb8czxR4WKaO9AxgZ3Rqc59z+Kb67ty62L9/HD3lQA3t90khWHT/PlNX0YFuVT57Wew64jZ/W7lCTsxJoObL3TdFuC7Ym5PLr8EGCdJvzz9f1rTQYCqMqnAu/xCOb206kUlDeIuTiwPT+Omt2qp00LIYQQQgghhBCiebX5hGBL9HLsWvBxt712d9BxWVh3pkX0ZEJI13MWh7uTlu9m92VsZ3/u+20/haVmTmQXM+L9Tcwf2YFnL+mCk4OmxmtVKhV+lz5C8nttY7ru+ZRvMDLz692YyudwPz2+Cxd1qLsiUqV1ZLtXKHdEX4GhPBk4Prgzv465UdYNbCVq6yBrVhQ0ktAVQgghhBBCCNGMJCHYAhQYS/k+fg/fx+/BSaNllH8U0zv0QatWk1qsL//KJ81QQGpxPsUmI1PCe/BYzGjauzdtKq1KpeKWQeGM6eTHTT/sZd2JbBQFXll7guWHTvPVNb3pG+pV47Xu/a7AMaATFDYphAvevJ9jScixtgsZ2cGXx8d2qvVci6KwIvkw78THsaLXVSjliaPJYd35aeR1OGkdzknMomnq6iCrUalQn631txBCCCGEEEII0QSSEDwPvr7oWvyDAykylvF3yhGWJu7ndIk1q1ZiNvFX+jH+Sj9W5xifHN3G58d2cH3HfvwvZgwdPfyaFFOkjwv/zBvCe5sSeGTZIUpMFg6kFzDo7Y3MH9WB24dEEubtXOUalVqD76SH4d3l1tfNsJKgoiikFOdzIC+DDEMBYa5eRLn5EOrqiVZdc/Via7I3Jd82ZdvP1ZFvZ/VFU0MyKLukiM+P7eCDgxtJKM6z7ixPBl6mVfPzqOtxPA/TzkXjPFX4ISX5cTUem+4eiUrrco4jEq3NfytMTSYTWq31d0B0kEedXYqFEEIIIYQQQjII58HIoA6EhoQCMC0ymg+GTGPz6ZP8ciqOX07FkViUV+N1apWKQGd3ikxl5JeVYFYsfH5sB18d38XsDn15a+BUvHTONV5bH2q1intGtOeSLu244fs9bEvMw2RRePGf47y05jgXt/dl/qgOTOpW0Y3Yc9h1toQgKJSdjsexXftGx6AoCv+kHePHhH3sz03nYF4GemNJtfO0KjURbt60d/elg7svg/zDmRnVu0VWyCmKwoJ9q/k+fg9GiwWtWo1GpUKr1pCUWwLtjaCoCA7w4bF9OQS7eBLjE0SMdxB+Tq78b9dffBe/mxKzqcq4YYZcZiXv4a6YsZIMbGVKkuMoTYpFF1Y9aaPSuaDWuZ6HqERrUVeFaWxawTmMRAghhBBCCNFaSRahBdCo1YwIbM+IwPa8MXAKa+IPEFuSg6vWkWAXD4KdPQh28cDfyQ2NWk2BsYQPD2/h1bh1ZJUWYVYsfHl8J346V14bOLnJ8XRp58bGu4bx2roTPPX3EYxmBUWBdSeyWXcim6fHd+apcZ1Rq1WoHXQolRqKpH9zD2H3/Y5KrW7wfdemHeehHX+wOzvlrOeaFAsnCrI5UZDNKmDhkS28EPsP7w+exriQzg2+d3Nak3acp/b8XfsJ5cVgsYV6YgtP1jmWChinUTFtz88MyzmJGtBEj7JXqOIc0oXFEPVE9TUEnZa/dx6iEa1JTdV/2dnZ+Pr61rgupRBCCCGEEEL8lyQEWxiVSkVvryDG+Pas9Rx3Bycejh7FnV2H8tbBDTyxewUAKcX5dotDq1Hz6JhOXNc/lO92p/D1rmTiyitPnl15lAPpBXwxszeuOi2VOwwX7ltO9oo38Jv0UL3vZVEsvBy3lid2r8CiVEw71qjUdPTwpbtnAD28Awl28SC5KJ/4gmwSCnOIL8gms6TIdv4xfRbjVy7i6qjevDFwMsEuno1+/jKzyW5Vd35OVau9XLQOOGkcKDMZKSkrQ6WyYFKpbesB1sQBuKUghWkH/iSkRF/lmGvXkXaJUwghhBBCCCGEEBcGSQi2Yq4OOm7vOtSWEPzvlFJ7CPF0Zv6ojswf1ZEPNp3knqX7MVsUfo5N40R2Eb/dNLDaNacXP4pLp6G4dBp61vHzywzcsOEHfks8YNs32D+CR6NHMSG0K7qzJOUKjCXE5qTx9J6V/JNmXXfxx4S9/Jl8iOf6TODObkPPutagoigkFOawKeMkm04nsCnjJAfyMujtE8y/k+7AzUF31ueoSy+fYMYEdbLFN0Wr5YVjKzGc2GY7xwIUanXka51IcvbiqKsfR938OOoeiAVYcOgvuheetp2vctDh3m8aPmPuwKXz8CbFJ4QQQgghhBBCiAuLJARbOWdNxZp5BrOxWe91x7BIOvu7MuOrXeQZjOxJ0TP8/U30t51RXuFmMZP8wdW0f24vWrfauyAfyE1n2povOarPBKxrJL7UbxIP9RyJqo5qucrcHZwYFhDFqktu5YeEvTyw/XfSDQUUGEu5b/tvfHF8B8/0Ho+jRkORqYwiYxnFZiNFxjJO6/OIL81n0+mTpBuqr7u1JyeFL4/v5M5uwxrwXarZeyEdGJR8EL3GgR9KDPQpyOeySscVjxA8ijLwKMknrCSfobmnahxHG9Ybv1Fz8Rx8DRpX7ybHJYQQZ8TmpjG8linr0d5BfDj0ynMckRBCCCGEEKK5SEKwldNpKqrfSpo5IQgwtrM/2+8dzuRPt3Mks4jEXIMtIaigwrXHOIoOrMKUk0zqohsIu/+PGpN7P8bv5eZNP1Jsssbs7+TKDxfPZnRwp0bFpVKpuKZ9HyaFduXJ3X/z/uFNWBSFvTmpXL7miwaN5ajWUGYxA/D+oU3c0XVovROUNTEVZsP7V/KMWwAP9JgCwP91Houf2Y2Nhp6s0g1l7/M34KOD0vSjlCbvpzTlQPm/+1HMRtz7Xo7XiJsocg3Fx7f2JKsQQjRGtHdQrcdic9POYSRCCCGEEEKIc0ESgq2cWqW2JbCaY8pwTTr5u/H97H70ffNfABQqVhEMmfcN8U/2xpSXRuG+5RTs/AWPARVVJUaLmUd2LufNA//a9g30C+PnUTcQ5ubV5Ng8HZ15Z/Dl3NixP7dvWcL2rKSzXuOrc2FYuyiGBUQyrF0k/XxDmfzPZ6xOPcah/NOsTz/ByKCOjY4pe9lLWAx6LjHomZmfzA+eoRRpdczrPBnj8V4EuTvj6+oIgFNoT5xCa18/sig7u9FxiJbjCc8ojjg419hAJDY3jZg6kjNCNIe6qv9qqxoUQgghhBBCtF6SEGwDnDQOlFnMGEzNXyF4Ru8QD9r7uhCfXVxlv9ajHcG3fEbi6xMByPjhQVx7jkfj7E6p2cQV/3zBXymHbefP6zKEtwZNPetagQ3V1y+UzZfezZJTsezPTcdF64iL1gFXraPty1RcQvegMDp7+FerALyj61BWp1rX/Hv/8OZGJwSNOcnkrH4XAJXOlY+ue424f7/nQF4GRp0e2p2kh0f1dRhF63ftqdcINcSTsMCj2rHD7pEcdXChVw3XxXgH1VmtJYQQQgghhBBCNJUkBNsANwdH9MYSEgpzSCvWE+RSPQFhbyqViukxQbyy9kT1eGIm4NZ7MoV7/8CYdYpTL44k9P4/uCV2nS0Z6KTR8uGQK7mx04Bmi1GjVnNVVG+uiqr5eHZ2Nr6eNU+/nRzWnTBXL5KK8vjlVBwHctPp4R3Y4BiyV7yBYiwFwHfCA3j4hvLDyNlEL33deoJvMt19RzV4XNHyhRriCSk+AfSpdkylc6GbWsXGS+8694EJIYQQQgghhLjgqc93AKLppob3AKDAWMptm39GUZRzct+regXXeixw1lto3P0AKDm1mwc+uoVv43cD4KbVsXbC7c2aDGwqrVrDfd1HAGBRFObvWNbgMSxlBvI2fgFYqwN9L3kAgA+3H7Wdoyp148b+EU0PWLQ4H4Z347o+M2v8Ourmj2O7Duc7RCGEEEIIIYQQFyipEGwDXug7iT8SD5JcnM8fSQe5/J8vmBLenUtCuhDq6tVs9+0b6kkXf1c4Wf2YY7v2RD25hcTXJ7IYR94PsCYtNaj4adRsBrdr+UmwO7sN4/3Dm4kvyOavlMP8nXKES0K61Pt6/fbFWIpyAfAcfC0aVy9+jUvjg2P/gqv1nPu6jqRPqGdzhC/s5PafY4lL09d6PDrIgw+nx1Tbf8rZjZMu7vjUcI1MCxatjXQgFkIIIYQQom2RhGAb4KVz5pPhVzFh5ccA/J50gN+TDgDQwyuAS0K6MCGkKyMConDSOtjtviqVimv7hrJ3R83HHQM6cuq2H3h6/be2ff87voYhnXtBaDcAFEVBKS3CbNBjMeixlBaCSo1KrUWl0YJGi0qlAY0WjbMnmmZMcP6XTqPllf6XMn3tVwA8uP13xkx9AK1ac5YrrXLXLrRte4+ex9ZTucxc8g9E5AMQ6ODL66Musn/gwq7i0vTEphUQE+Re7VhsWkGd10YWF8i0YHHOxaYVMPzdjdX2P5ymx8VBQy2rKNRKOhALIYQQQgjR9khCsI24JKQLHwyZxrN7V5FhqEhSHMjL4EBeBm8c+BdPRycWDZ3OVVG97Xbfa/uGsLd8+78TlQ/nnWb61qUYVdaZ6Tcm7WRm8m5SF13H6Z8fw1JSgMVQAIql3vdzHzCddtNfQBfYyS7xn820iGhGBESxISOBA3kZfHZsB7d2GXzW60oS92E4vgUAp/YDSXHrwuR3NlLmf9J2zjvDJlVrZiJappggdzbePbza/pqSLkKcT9FBta8hW1RmbtSY0oFYCCGEEEKItkcSgm3I7V2HcluXwcTmpLEi5QgrUg6zKeMkpvKEW35ZCTPXfctpQyF3da+e3GiMjn6uVV6fyCqig58rmSWFTFr1CXllBgCmhffkeR3knVgPgCknuVH3K9jxMwW7l+I9ah7+U59E69GuaQ9wFiqVijcGTmHAH28D8OTuFcyM6o2Ho1Od1+WuqagOzImZzeT3NpGlZIJbHgDdPQO4MjK62eIWQlyYapq+fsbvd9Ze3Zz2xe2UJMfVetwpNJqgGz9sUmxCCCGEEEKIlkMSgm2MWqWmt28IvX1DeDRmNPqyEtamHee7+D38dHIfCgp3b1uKwWxkfrR9uttWrnH7fk8KD46KYurqz0kozAFggF8YX198LS5aR5yDu5C94nUUYwlqJw/Uzh5onK3/qp09UetcQVFQLCawmFHMJlDMKCYjRYfXWhOJZhO5q98jf+OXeI+6De9Rt+EY0NEuz1KT/n5hXNehH1+f2MXpkkJejF3Di/0n1Xq+2VBA/pZvADA5ejBqcyCFDtkQesx2zpO9x6JWSU8fIcS5FVJ8goQF1f+DkOHYJgCcOw2rdqw0KbbZ4xJCCCGEEEKcW5IQbOM8HJ2YGtGTKeE9iIkN4ondKwB4df86uyUEK1t1Monf//qLHVlJAES4efPH2Jtx0ToC4D1yLt4j5zZqbEuZgZyVb5O17EXreoMlBWT/9RrZf72Ga8/xtJv+PM5R/e32LJU933ciP5+MxWA28vbBDdzbfTiBLjVPzdv38+NscAskNjiI1Z49KXTbCZqKqXpdPP2ZEdmrWeIU59YJ3V6K1HqGL99b7dhJF3cii+teY1CIcynZuT1AjY1unDsNq7UKsKYEohBCCCGEEKJ1k4TgBUKlUnFJSBdbQrCPT4jd72FWq9iqXU1ZlhEAT0cnlo+9hQDn6s0YGkPt6IzfZY/idfEcsn5fQO66RSjlU5KL9q8k4cAqvC6aQ7sZL6B197PLPc8Ic/Pi3u4jeCluDQazkZnrv6Gjux96YwkFxlL0xlL0ZSWcLsrhtMkRek6tdHVFMtDL0ZmPh85Ao5bqwLagSK2ngHxia+irEFakJ6Kk6NwHJUQtvot4CKDG9TBt3bTt2IxECCGEEEII0XJJQvAC8s2J3bbt6zr2q/PcE/os/kw+zJq04zhptFwV1YtLQ7vhqKn+llGwThsu1Wkow5oM7ObZjp9GXUcP70B7PgIAWnc/Ame9hf/lT5O36Wty13xAWdoRUBTy1n+MfufPtLvyebxH3Yqqnh2BKyvLOIF+168A6IK7oQvpjoNvBA/1vJj3D2+iwFjK+vR41qfH12s8fwdPxod1YJB/ODPb98bfya3BMYnzp64qwBJNAe5mT2IM1btFP3z0B1wcGv7+E+J8qKub9tmakcTmptXYXCTaO6jOhiRCCCGEEEKI80cSghcIk8XM9/F7AHDROnB5eM8qx0tMRv7NiOfP5MP8mXyIY/qsKsd/SNiLj86FmVG9ub5jPwb6haNSqTiWn0mJToNzacUfjDd1GsC7gy7H1UHXrM+kcfXGd/w9+Iy9k9y1izi95HEsRblYinJJ/+oO8tYtIvD693HpNPSsY5kNBRTs+Jm8DZ9TfHRDteMqR2d0Qd24N6wfC7TVpwqrFQtupjLczKV0LMrGs0jF36opfDrlImb3lrqa1qxIradYrQeq/9x7U0InQzIL8v+sdqzUdBJdUO0NHoRoaWrrpl1XM5IOp49RUmqgpDCzyv4jDi6UnT4BkhAUQgghhBCiRZKE4AViVepRTpcUAnBFeDRuDjpO6LNs3YjXpB2n2GSsc4yc0mI+OLyZDw5vpounPxNDuvLJ0e0MU1vbiqgUhU+HXc3NnQc0+/NUplJr8BlzOx4DZ3B68f/I+/cTUBRKEvdycsEw3Pteji60J1qvYLReQTh4BaP1DkYxaSg6tI68DZ+j3/EzSllxrfdQygyUnNrNzFO7GeDiS4lGi5upDFdzKW6mMpwsJltzlXyVKzcHf8T62yYxOML73HwTRLNysXiw8dK7qu1PWDDc2nAhrHriTxcWg1OodJIWLUtsWgHDa5gWXFt14Nk8k7KL0qRYdP/5DEx3j8Sic2l0nEIIIYQQQojmJQnBC0Tl6cLbsxLp9PNLHC/IqvFcR7WGkYEdmBjalYmhXUk3FPDV8V0sPrmPAmMpAEfyMzmSX7UixKnUfM6TgZVp3f0IvnkR3iPnkvb1XZTEbwegYPdSCnYvrfc4mtDeuA+7DlffUMpSD1GaepDS1EOUpR8BUxkdi7OrnJ+r9iRe40e6xo80tT87Ay7l97un0slfpga3Bf4lKegsJTU2VjiTCIl6onqCRYiWJjqo5kZIYK0OrOt4bd2Ja/sMqBbeyhEHlxqnEgM1JtiFEEIIIYQQ544kBC8AuaXFfFc+XRioNh0YINzVi0mh3ZgU2pXRQR2rTPft4tmOiwM78O7gy1l6aj9fndjFqtSjWBQFAK3JAoBaaeYHqSfn9gOIenILeRu/4PTixzDrT5/1mhyVB8t0I1nqNIYjJVHwD3g5O3DnsKt5dE5H3HRaFLOJsswEytKPkmJQc/2fp9lX5EaZytpB2cVRw30jolg8qiOezg7N/ZiiGVz/82Fc1+VX2ae1GHBUSms8X6oARWvy4fTGTWGvqztxbZ+BLkZDrePF5tbQhUcIIYQQQghxTklC8ALwSty6avt0Gi0XB7RnQmhXJoZ0pYunPyqVqtp5lbloHbm2Q1+u7dCX1OJ8/kg8SFauml3LXmmewJtApVbjfdHNeA29juSEw/y1bR9b9h9CyU+jnSWHdpYc/C05ZKu9WKa7mI2O/TCqqibx8gxGnl99jM+3J/HSpV2Z1TcUXWAnHAM6cusHm9lRbAIVaNUqbh0cwRPjOhHk4XSenlg0F41KhUnjLFWA4oJVV3fi2izITwAgat6iasdqqxoUQgghhBBCnDuSEGzj0ov1vH2wapOMy8N78u3F1+KidWz0uMEuntzWdQj6EiM3lu9TsHaqrGvaWWOl6UvYlJCDr6sjEd7OhHo646hVVzuvzGTh0OkC9qbo2ZeqZ3dKPhvis7EonsBgKF/SKtBdx/gOXnQP8WFEmZm+ZSaKjWaKyqxf+QYjGxJyKDVZSNWXcP33e3l/00neurwnJ7KK2BCfA0DXdm78cctAOvq52v2Zxbn31fSuREdXrXbqv/Cr8xSNEEIIIYQQQgjRPCQh2MYt2Lcag7lqs5C16ccxKxa7jO/h5EDlusJHlx9i+ZxBdhn7DJPZwsXvb+ZYVpFtn0oFwR5ORHg7E+HtglatIjZNz8GMAozmmucuq1VwabcAbhkUzqRu7dDn5eLr61vrfU/lFPPwskP8tC8VgG2JeQx5ZyMujhUdNz+4MlqSgW1I3ufXk+BT9eepuEeikuYIQgghhBBCCCHaEEkItmEJBdksOroNAE9HJyaFduP7+D3kl5Xw2dEd3NtjhN3v+eeh06w7nsXIjn52G3PrqdwqyUAARYGU/BJS8kvYfDK3zuu7+Ltyff8wbhgQSoinc73vG+Hjwo/X9+Ou+EjuXbqfPSl6AIrLzABc3TuYUXZ8TnH+3eHXDZ1P1WYwRx1c6Kauezq9EEIIIYQQQgjRmkhCsA17du8qjBZr8mp+z5FcFdmLH+L3oqDw1sF/ubPbULRqzVlGabiHlx1i273Dz7omYX39dbiiKciMXkE4atScyjVwKreYlPwSLOUFgY4aNT2D3Okd7EGvYA96B3sSE+yBVxMbfIxo78uO+y7iix1J/O/PQ5wuLMPTSctrk7s3aVzR8mgDOuMUWDXJ2wuI9g46PwEJ0ULEphUw/N2a19GMDvKosWFJaVJsjZ2JS/zkd6cQQgghhBDnmyQE26iDeel8fWIXAO2c3Li3+wjcHHRMCe/Ob4kHOFmYy9LE/UyP7GX3e+9IymPxvjSu6h1sl/FWHMkErFN+P7wyBl/XirUPjWYLKfkllBjNdPBzxUFTfV1Be9CoVdwyKJwZvYJYeSSTvqGehHrVv9pQtA5fDbyy2hqCQlzo6loXNjatoMb928uCcdbqIU1f7ZjJraiGK4QQQgghhBDnkiQEa7F48WIuueQSPDzs3yDjXHh2zyosirV07vFeY3Bz0AHwYI+L+S3xAABvHthg14Rg5XrAx/86zIxeQU2uEswoKGV3cj4AA8O9qyQDARw0aiJ9zt36bh5ODkzvZZ9EpxBCtAY1Vf+dMfzdjTVWD24qug6cYFikd7VrDJbP7B6jEEIIIYQQomEkIViDDz/8kBdffJF+/fq12oTgvxnxAPjpXLmtyxDb/uEBUXT3CuBgXgZbM0/Z/b4jO/iy7kQ2x7OKSMkvaXIV3eHTFdUnF7X3aWp4Qggh7Ki26sFhkd61TiXu/s7nzR2WEEIIIYQQ4iwkIfgfZ5KBa9asoX379uc7nEY7Ux3o5+SKTlPxY1apVPjpXKucY09hlRKA9hi/8hDODvZf71AIIUTj1VU9KIQQQgghhGi5JCFYSeVkYMeOHcnMzGTRokXEx8fTp08f5syZg5OTU73H0+v16PUV6yelpaU1R9hCCCGEEEIIIYQQQtSbJATLmc1mvvvuO3Q6Hc7OzuzatYuJEyfSpUsX3Nzc+Oabb/j8889Zs2YNnp6e9RrzjTfe4Nlnn622/9ChQ+Tm5tZ6XUFBAe7u7o1+FgBTZh4YDZSUaomLi6tyrDA9E3KtU3H/e6wxiouLbdtlaUlQkA3A4YMHyffQNWnsE8l6KMgCICPRgbi4siaNV5k9vs/nmsTcMN7e3gQGBqLV1v2rzmQyAZCeno63d/U1z9qa3NxcDAbD+Q7jnLDXs1b+PZecnNzk8eytNf1MjXlFJCcn1+uzKYQQQgghhGgeKkVphnmjrVRhYSETJkwgIyODsrIyXn75ZWbOnAnArl27GDVqFDNnzmTRokX1Gu+/FYJ79+5l8uTJzRK7EKJmSUlJhIaG1nnOjh07GDhw4DmKSAgB9ftsCiGEEEIIIZqHJAT/40xS0MfHh99//73KsWeffZYPPviAjIyMRo1dUlJCXFwc/v7+tVZFpKWlMXDgQLZv305QUFCj7nOuScznhsTcOPWpQiopKWH16tVMnjy5VX1/G6Ml/EzOlQvlWVvrc0qFoBBCCCGEEOfPBf3/xI1GIw4ODlX2ubm5sWLFCjZu3Fjt/MDAwHpPF66Jk5MTAwYMqNe5QUFBra5yQmI+NyRm+3NycqJ3795Ay4/VXi6U54QL51kvlOcUQgghhBBCNJ36fAdwvixatIghQ4bUuJafm5sbEyZMqLLPZDLx+eefM3fu3HMVohBCCCGEEEIIIYQQdndBJgTz8vJ46qmnSElJYezYsXU2+ABrE5Bx48YRFBTE/ffff46iFEIIIYQQQgghhBDC/i7IhOAXX3zBjBkzWLNmDampqXUmBb/55hvuuecebrjhBn755ZdmX+/Iw8ODp59+Gg8Pj2a9jz1JzOeGxNy8WlOsTXGhPCdcOM96oTynEEIIIYQQwn4uyKYi//d//8fVV19Nly5dOHToEKNHjyY4OJjVq1fj7e19vsMTQgghhBBCCCGEEKLZXJAJwf+qKSloNpvJyMggODj4fIcnhBBCCCGEEEIIIYTdSEKwXOWk4N9//819992Ho6Mjn3322fkOTQghhBBCCCGEEEIIu5GEYCVnkoLFxcUMGTKE3377DZ1Od77DEkIIIYQQQgghhBDCbi7IpiK16dy5M4MHD2bgwIGMHz+eefPm8euvv9ptfJPJRHJyMiaTyW5jCiGaTj6bQrRM8tkUQgghhBCiebTZhGB2djb//PMPx44dq/c1c+bMIT8/n6ysLJYsWUJKSgrTpk3j77//tktM6enphIWFkZ6eXud5OTk5drnfuXLllVfavs5YEpuK6sE/UD34B+9uSKj3WEdOF9quu23xPgCOP9adgzeoOHJXuzqvtZQWc/AGFQdvUJH4+qSz3qu1fZ9BYm4uZz6bhw4dOt+h2EXv19ejevAPvB7/q8bj5+pn8uehDNvn+ZU1x8/JPf/LXs9a0++5lqQ1fM4ao77/u1mbtvR9aYnP0pjPRUt8jsaSZxFCCCFEa9YmE4JfffUVkZGRXHXVVXTu3JmxY8cSHx9/1utuueUWAEaPHs2mTZtYuXIl06dPZ/v27Y2KQ6/Xk5ycbPtKS0ur13Uyi/vcaI3fZ4nZPhr72WwrWuLPpLlcKM96oTxnQ7Wl70tbeZa28hwgzyKEEEKI1k17vgOwt927d/Pggw+yZcsWevbsycaNG7n11lvp378/y5cvZ8iQIbZz4+LiWLBgAV988QXOzs54eHiwbt06li1bZjtHp9MRHx/PVVddRXR0NPPnz8fJyalesbzxxhs8++yz1fbn5ubi7Oxc63V6vb4BT9yyZGdnAxCfXvFfmouKimz7zyY3z2Dbjs/Uc/p0BiZDAQAWRalzHKWs2LZdmHGKBb9v54dDBZSaFJ4fF8mYDt5Vzm+N32eJuWF8fX1r3F/bZ7OgoKDe79WWzK04nd7GU7ihIm27CSxm6x97igWAEs/25yQOvb7Atr1sfyrjI50J86zf70/7xWD/919LfI+0tt8NtX02hRBCCCGEEOdGm0sI/vjjj0yaNImePXsCMHz4cLZt28bkyZOZNGkSW7ZsoWvXrgCkpaXx22+/8cILL/Dcc89hNBpRFIWVK1dy+eWX88UXX7B06VLmzZuHv78/L730Ehs2bGDlypX1iuWBBx5gzpw5ttdpaWkMHDgQb2/vs/4x1Fr/WHL18OL9TSd5YvUp274+ke3q/TyKrhStWoXJorD6RB6/vf8Iw3KTAdC1a1/nOGaTJ+lOnqhL8iHjIJ1+m02Gx+NkqX24+sdD3DMiipcu7Yazg8Z2TWv8PkvMTVfbZ9Pd3b3FxdoQiqJw/Ien+PD4C2iwJv9y369+ntojEPentuDoH9ms8XQt0QLWadgbTuUz+KO93DM8isfGdMTbxbFZ712ZvX+mLfU90lLjEkIIIYQQQrQ8bS4hqNPpOHDgQJV97u7uLFu2jOHDhzNr1ix27tyJSqVi/PjxrFu3jj59+gDQr18/Zs+ezbRp02xrFq1YsYJRo0YBMHLkSC699FK2bt3K4MGDzxqLh4cHHh4e9n/IFqzzS2tIyiuxvb6uXyjjOvvX+3o/Nx2fz+zNTT/sZWLxGoZlfWk9oHEgYOZr1c5XFIUT2cX8sCeFT7cnEuD4EG+VvoSHUkS06Rg/5D3EXR6Pc1jbgXc2JPDPsSy+m9WXmOAL6+ciqmqLn03FYib9qzsxrv0IzVnOtejTSXxjElGPb0Tj5tNsMfUO8eSLmb15eNlBTheWUWqy8Oq6E3yyLZEnxnXizmGR6LRni1YIIYQQQgghhL21uTUEp02bxq5du/jqq6+q7Hdzc+Pbb79l7969rFmzxrZ/8ODB6HQ62+uvv/6aU6dO8cMPPxAVFWVLBgKMHz8etVpNcXExwqrymjMK2JKBahXcf1F7Pp/ZG7Va1aAxZ/cLZdUEFf9X+K5t30eB95MfOACT2cKupDze/jeeGV/uJPjZVXR6cQ1PrjjCyRwD2xx7McvzFVK0wQAEWbL4qfB/XGLZBcCB9AIGvLWBN9efwCLr5Yg2wlJmIPndK8ld+5H1NSqWuk3CbeKj+E19Er/Ln8b/imfxn/YcuuDuAJSlHiLp7cuxlJXUNXST3TAgjOOPjeGpcZ1xcbQm/3INRh78/SDdXl7H6qOZdruXqSALxSzdaIUQQgghhBDibNpchWDv3r2ZN28e8+bNIzIykosuush2rEePHgwaNIi4uDjGjBlT6xhhYWEcPHiQpKQkkpOTCQ0NBWDJkiWEhoYyfPjwZn+O1mDd8SweXX6IYKByyu/KmCAWTOhC1wD3Ro1rzE4kaOnNmLH+Yf+F01TeKR3Ot6+to8RkoajMXON1GrWKy7q1Y87ggVwUMoO0D2ZQfHg9GpOBN/IW8GnYfN4oGkqZ2cIDvx/kt1hPvpzVn3BvZ1SqhiUthWgpzIU5JL45GcPxzQCU4sDD7g9yw013Et4vtNr5XsNv4MSzg7Dkp1F8dAOpi64n5I4fUKmb778PuTtpeXZCF+YNjeCZv4/wybZELAok5BQz7qOt3D40glcu646brnH/k2TKSyf9hwfRb/kOrVcwvhMfwnvUrah1rnZ+EiGEEEIIIYRoG9pcQhDg7bff5sSJE0ycOJGvv/6aadOmAWAymcjMzKR79+5nHWP48OH4+/szcuRIHnnkERITE1m4cCF//PEHjo7nbu2rligxt5j7fzvAL3HpAFxR6di2e4czMNy75gvrwVJaRNJbUzHrTwOg7jqO35U7IbuE7GJjtfN9XRwYHuXDRR18mdk7hOBKDQsi5q8k9fNbyd/4JVjM3HLqJfpH38fstFFYULH+ZD6Rz/+DVq3C19URXxcH/Fwd8XV1xM/VkYvb+3JNn5AGVzgKca4YsxM59doEylKt6/Tlq1y5y+MJ/HuOZFbfkBqvcfANw2vuj+S9fxkWgx79jsVofwwj8JrXmz3eIA8nPprRi3tHtOeB3w/w9xFrdeCHm0+x4nAmn8/sxcUd/Oo9nmIxk7tmIaeXPI6lOB8AU14qGd8/QNayF/C55H7ocw0ga+sJIYQQQgghRGVtMiHo6OjIH3/8wZw5c7jyyiuZMmUKo0eP5o8//iA6OpoOHTpw8uRJIiMjax3D1dWV1atXc8cdd/DII48wcOBA1q1bR48ePc7dg7QwRrOFV9eeYMHqoxiMlmrHVdCkZKBisZCy6HpKEvcC4Bjcjah7F7PR4sS0L3eyIT6H9r4uDI/ysX118XerNWGn0joSPOdztJ5BZC9/CYBecW+xY0Ah03Onk5BXBoDJopBRUEpGQWmV6z/emsjCLaf4eEZMo6sdhWguJUlxJL42AVNeKgDpaj9u9XiGNJcolkyPqbPq1SG4O2H3/Mqp1yaA2UjOijdw8AnD95L7zkns3QPd+WvuID7fnsR9vx2goNREQk4xIz/Ywj0jonhhYldcz1ItaEjYRdqX8yhJ2Gnbp3bxwmLQg2LBXJBF5s+Po1r2Muaxd5MWczN+7YII9XKSimAhhBBCCCHEBa/NrSF4hk6n4+uvv+bvv//G1dWV5cuXM3z4cLKysujYsSNRUVH06tWLdevW1TpGx44dWblyJTk5OaxYseKCTgYCPLb8EI//ddiWDAzxdOL72X2xx5/WhpO7SXr7cgp2/gKAxtWH8Pt+R+PiiZ+bjvV3DKXghYmc+N8YvrymD3MHR9AtwP2s1XsqlYqAq14kYNbbUJ4EcNrxCau0r/J4Xycu6x7A4AhvOvm54u3sUO36jQk5jHh/M5mFpdWOCXG+KBYzye9eaUsGpjlHMsvzZU5ow1kwoQuRPi5nHcO1+2hC5nxue53x/QOUJB+o4wr7UqlU3DwonP3zL2Zc54qqwHc2JNDztXX8dSijxusURSF7xZskPDe4IhmoUuE9+nY6vRZPh5cO4TXiJtBYE4pKiZ6cZc9jeaEb/3v8HoKeXcXkT7fzfyuP8uehDPlsCyGEEEIIIS5IbbJCsLLx48czfvx4wDoNeMiQIaxatYrjx48zf/58xowZwzvvvMOdd95pu8ZisfDggw8yd+7cek0vvlCsj88GrHm1h0d25IlxnXDTaVncyPEURaEwdgXZf71K8aG1FQc0WkLv/hnHgI62XSqVqtHriwH4jr8HrWcgqYuuQzGVUXr4H2anxPHA1CdRTKWYCrIwF2RiKsiiND8DQ34Wh0vcWL+Bw1MAAQAASURBVKP0YKuxF++uD+H/Lu3Z6PsLYW+KqSKRlaj4kKf2INzbmXtGtK/3GJ5DZ1GaeoisP54HRaH48DqcQs/tf/gI93bh71sHs+j/2bvr8KbOL4Dj30iTurtQobQUKO7urkPGfGMbzDeYu/GbMoNtjA22MQYbMoa7u0uBonV3j8vvj5S0XVtocXk/z9OH5N733vumTVJyet5z9iXx8opYynRGEvPVDJ59gE8GN+aN3uFgNqPLvoAm6SjF+/6m5Mgy6/G2wa3we+Qn7Bq2B0Dm4IbvhDkciHyKuH8+oXfBGpTosUPHm2WzOZ0fxqqSZqyKrQg4hrrb81j7IF7sFoqzbfU/DAiCIAiCIAiCINxp7viA4EWnT5/mwIEDbN26FRsbG5o2bcrq1at5/fXXee6557C3t+exxx4DID8/n9WrV7NixQrOnDmDjY34gAiQkGfprhzu4cBnQ6Ou+DwmvZbifX+Rt3Ya2rSqGUlyVz98H/4Rh6hetRx95Vw6jMPGI4i0H8ejz0vGVJJN5p/P1zhWDjQDmnGMF5hP6eIPiD/TC5fofjg06YMyoKlYdijcNBKpjICn5pP81WBMmhI6aI4w0/gRvwZ+iayeNS8dWw6xBAQBXdb56zHdy5JIJEzqFMKASG8mL9zHhdPHiDAmULboJ7asTMdfdR6ztuy/B+E14n08h7+N5GI2oNnMmtPZvLP2DMfSi0H2OJ7uo5hSNpcRWssfHT4tm8Fwl+loJBXd5RPyVby37izf7ojntV7hPNcl5LJLlgVBEARBEARBEG5nd80nHpPJhF6vJy0tzVo7UCKR8MUXX1BWVsYzzzxD165dadSoEZ6enmzbto2EhAQRDCxXojFYm3qE1mE5Ym2KDy8j849nMBRmVNmuDGyGx6BXcOl4HxJ53Zq2lOm1rE87x8qUU6Sqigh38qSJq4/1y9fOqVrQzj68E2EfHSV9zuNVsoyqkEiR2btiLMu3bnI0q9DErEYTsxoAG89gnNuNxbn9OGxD24rgoHDD2Ud0Jfi1TSRNG4BJVUh7/Qk8417BqOpIphmcFUqcbGwvex6Fb4T19rUMCKqTjlK4fTbatFhkjh7InbyQOXtX/OvsjdmgRZtxFl3GGbQZZ9BlnOV/5cugrTRg/s+5ZU6eBEz6E8foAYAlELjlfC7vrjvL3qSCKmObhIXSa+hi7BeNQxW7hQBDBieabedEu7c4mFLIweRCtsfnoTeayVfpeWP1ab7eHscbvcN5qnMIdjaya/Y9EQRBEARBEARBuFXcNQHBJk2a0LBhQ15//XUWLlxYZd+3337Ltm3b+Prrr5k5cyYA/v7++Pv734yp3pIS8lXW26EeVxYQzN/yE5l/PAPmio/3Dk364DHoFRyiB9QpqJalLmFlSizLk0+yKf08GqPBum8TVYMZrgo7oly8aecZxMTIjjR18wVA5uhO4AtLydy/DFtNHjInT0uQovxfqb0rEqkUfX4aiQfXsmTpX7TXxeBnyrWeW5+bRN7aaeStnYaNZwjO7cdZgoMhrUVwULhh7Bq2x+fljZya2gd3czEOukRGz3mO5Y4+OMgVPNO4M68064G3Xe1NceSOHkgd3DCVFaDLvLqAoElbRtG+vynYOgtNwsGrOpf1nEhIlPmT59KY3t174xbeFvtGnZHaOgKwPS6X99adZUd8fpXjOoe4MXVQY5q7SfDw8EA3YTZxb0dj1pah2/EDA7qOZ9TgLgAk5auYuuk8vx1MwWgyk12qY8qKWKZti+ftvo14smODa/JYBEEQBEEQBEEQbhV3TUBQIpHwzTffMHz4cFq0aMFbb71l3WdjY8PEiROZN2/eTZzhrS0+r2K5Xn0zBM1mM7krppKz9D3rNqe29+A57G3sQlrX6RxLEo/z9ckd7MtJxlwtX6hmhTo1e3OS2JuTxPTTu+jr34gXm3RjcGBjpBIpikbdcfPwqPV4G/cAGg14glO5rXnrcCrBpnSmN82hZelByk6ux2ywdCnW5yaSt+YL8tZ8gY1XGE6tR+DYfBD2kd2R2ihrPb8gXAsG32gedp1KX6d/+DO4OWqZJcO2zKDjy5Pb+OHMbp5p3JlXm/WsNTCo8GmEJv4AutwEzEaDdQluXWlSTlCwdRZFe+ZZuvzWg0oqJ97Bg/MOnsR7hBDv7E+c0hFPhR39nEOZu9eFLK0l07HJeUfW9eyIo60dexLyeW/9WTafz61yvtaBLkwdGMnAxt5IJBLy8iy1TxVeofiM+5zMec+B2Uz6nAmEfXwMqcKOYHd7fhnXgjd6h/PRxnP8eTgVkxnSizU8u/QEK2MzufK8aEEQKite8grFObX/8cE2MBq/R2fewBkJgiAIgiDcne6agCDAsGHDmDp1Km+//TYqlYqPP/7Yms1VWlpKWFjdi/HfbSpnCIbVI0PQbDKRtWAy+RunW7d5jfwAz5Hv1SmTzmw289bhtXx2Yku1fcGOboxs0IwRDZrS2iOAuOI8YouyiC2s+IorycNUnpG4Kf08m9LP08jZkxebdGOUR3i1c9bkjd7hzD+SRpIsgMk5jTj7+ttItCWUHF1J8YFFVYODOfHkr/+G/PXfIFE64BDVG6eWQ3FuPw6Zg2udricI9bEm5QwJUVn8omhr3eamU6GRK1BL5agMeqad3M4Pp/fwdONOvNOib7VzKMsDghgN6HMTqzT0MZlNfHVyO4sSj/NCVDceCm8DgCb1FEV75lEasxZtSky1c9o17Ihb76dwanMPZp0KQ0kOxuJsDCU55Bdm8kFOOtsMJlLMNYf4U3Rajuaewa2JPY65vpRmehGbBQ2mbiLAxZa0Ik2V8dF+Tnw4IJKRzXxrfW9x6/00xQcXozqzHV3mOXKWvofP+C+t+xt6OjD3vla82TucDzecY+HxdMxmWHcmh1FwTTqqC8LdzpBxGmNGLMqg5tX21fReIgiCIAiCIFwfd1VAEODtt9/G3t6e1157jc2bNzNx4kRyc3OZPn06mzdvvtnTu2Wdzi613q5rhqBRXUzaTw9SemylZYNEgu9D3+Pe55k6X3fayW1VgoGt3AMYGdyUEQ2a0dzNr8oH/9aegbT2DKxyfJley4L4o3wbu5PYQktX0fPFuTy371+m2bvyVYcR3BMSfck5NPNzZlgTH1bGZhGfp2LW3iSe7RqKa5cHce3yIEZVESVHV1B8YBGlJ9aD0VJr0awto/TYSkqPrSRz/os4tb0Hr5EfoPRtVOfHLwiXMuv4MZ46/CeUl92UIuHR3HNMPL0OnVTG70Ft+TugFSqZDWqjnq9P7WBZ8inmthlF10rZsZXrCCZ93geXro9iH9kdc0hrHtu/gn+STgDw6K6/aZqXgMf2nyk7tbHafKS2Trh0eQi3npOwbVDpw76dE3IXH+vdybsW8kd6Sq2Py11pT77W8keIAr0KXOLBOR7K3KDAl7RiT0AKQJSPIx8OiGR0tB/SyzRUkUil+E+YQ9w7zTHrVOSt+xrndmOtHYovauzjxF8PteH5rqEMmXOAQrX+kucVBKF+lEHNCX1nV7XtCVO73oTZCIIgCIIg3J3uuoAgwOTJk+nduzfTpk1j2rRpREREsGnTJpo1a3azp3ZLKtbo+fuopdC/o1JGlLfjZY/RZcWR8t2Iii7CMhsCJs3DpcO9db7usbw03j6yznK4RMqszqN5PKJDvebuYKPkyciOPBHRgU3p5/kudierU08DkKgqZPTWuTwR0YHpHUZiJ6+9gcw7/Rqx6nQWZjO8uiqWvhFeRJZ/H2T2Lrh2eQjXLg9hVJegOr2F0pi1lBxfgyHfEvQw6zUU711A2ckNBL+2uWqwRBDqqUitZ8LiQyxVr7IGAylx45PWQ5ky0ovMP56h5OgKXo7fyWMph5gb2IYFAa1QyRXEl+TRZ8dvvFbQizeb98ZersCx5VBy/n0fAH1eMrnLPyJD6cRz0SM54+htva7JbObvFZ/xaOrhislIZdiFd8K1yyO4dBxvre13KfEledbb3XxCaerqSzM3X5q6+tDUzRcvW0di8tP5NnYn8+OOoDMZLel5jgWWL6MMJ50PjzduzUddO+GkqPvSfIVPQ7zHfkLW/JfAbCL994mEvX8QSQ2v/86h7mx+qiP9Z+2zbjMD/2zeSffS7WhTYjDpVJh0Ksw6FSZtxW2ZvRtObUbi3P5elEHRoraoIAiCIAiCIAi3lLsyIAjQokULUTOwjubsT6ZEa2neMaF9AxyUl37alBxZTvrsCdYuvTInTwKfX4pDZLc6X1Nt0PPAjgXoTUYA3m3Rt97BwMokEgn9AiLoFxBBbGEmrx1cbQ0Mzj63n0O5KSzp9TANnT1rPL59AzemdA/jq+3xqPUmHlpwlH0vdK2WkSSzc8Kp9QicWo/A12xGm3qSoj1/Urh7LsaiLIwluSR93pvg1zdj26DFFT8e4e6VVaJlwM/7OC45AG5aABx0XvzZ62FGRvsBEPTiMrSZ5ynY/CPSXb8xOWEXD6Qd5aWmwznu4o/OZGTq8U38GXeY6R1GMiykNYHPLSH7n3fQZZzhmLMfLzQbQZ7Codr197oF82jqYRT+UXj0fxHn9vfWezm8wWQCQCqRsGPwszWOae7uz69d7+WzNoP548Jhfj1/gNNF2ZadMiMldul8m5TOz2nrGRwYxejgaIYERdWps7J73+co2rsATfwBtMnHyVv/NZ5DXq9xbOtAVw681I1XJ/5imTMmov7oTs7lHmNhBtr0WHJXfoLCPwqX9vfi3OFelP6NLzs/QRAEQRAEQRCE6+2uDQgKdWM0mZm+KwEAiQRe6Bp6yfGpP9xL8YFF1vvKoOYEvbQChWdwva775uE11iW+Hbwa8HaLPvWcee2auPqyqt/j/HpiFy8dX0uJXsux/HRar/iW37vdy6jgmpcQTx3UmA3ncjiRUcLBlEJWn85iWFPfWq8jkUiwDYrG9t7P8RrxLsnfDEV1ZjvG0jySPisPCga3vGaPS7jzJear6DdrHxfUKRBqeX3YS5XE3j+RBk5uVcYqfRvh+8A3eI/+mKK981Fu+p7fjy1idoP2/BLcHp1UTmJpAcM3/8awoCZ812EE4Z+d5reYzTx1ZB268tqboap8fjjxLxObjybVzpVD7sH4TFmDe/OBV5z1ZjBbAoJyifSyY73tnHgluicvN+vB/pxk5l44xNKkE2RrLGUMVAY9SxJjWJIYg1Imp4NnA1q6+9PSw58Wbv74mqpn/kmkMvwf+4X4D9qA0UDOvx9g494AqdJSDsFcqRO6PjsO9i9EQgBmap+vxEaJRGGPVGGPxMYWfV4SlHdB16WfJmfZB+Qs+wBlgxa4dpuAe99nkUhldf+mCcIt5uk9/6BRyrDVGtEoZXRd/X2V/dFufszsPPomzU4QBEEQBEG4HBEQFC5p2ckMEvPVAIxo6ktDz+oZQxdJMFUJBjq3H4f/43PqtISwso1p5/gudicADnIF87rdh/w6fHAe4R9F1waRjNn6BycKMijWa7hny1xebtqDT9sOxuY/17S1kfHVsKb0/9myfHDatrhLBgQrk9o60mDKapK/HorqzDaMZfkkft6b4Nc21bnTsnB3O5VZQv9Z+0gv1kBIRf292d3GVAsGVia1dcSt1yRce05EdXYHL8x6kKEHYvm0UW92eFgaKa1MiWVj+jn6+0eyIuWU9diBAZH82W4YiuQx9Dl3iLmlxWgkUmK8G9HrKpbAXswQlEsvHxC8SCKR0NE7mI7ewXzfcRS7shNYkhjD0qQTpKssnY21RgM7suLZkRVvPU4ukdLYxZsW7v5EungR5uRBQycPwrxCcR/4CvmrP8Os15D20/2XmUGA9dYRRVPW2HRlm6IdahsXXu3XjFf7RGAjq3g8htI8Sg79S/GBhZTFboHyIKg2+ThZ81+k9PhqAp5egNyx9k7ngnArO1GQgVMtbwMxBRk3djKCIAiCIAhCvdX905hwV/pme8UH68ndq3dh1uclI/lPj1CZiw+Bzy0h8NmF9Q4G5mtVPLrr74rrtx9OIxeves667iJcvNg39HkeDa/o0PrVqe30WjuThEp1zi7qG+FJcz9nAHbE53MguaDO15IqHWgwZTX2TXoDYCorIOnzPqgTDl/mSOFutz+pgO4/7LYEA21LwLEQgGauvowPbVmnc0gkEhwa9yD41Y0Ey2348cS/TD+5nACTpWGGxmioEgyc0rQ7q/o+joebL04tBjOk7Qjrvo3p567q8VRkCF5ZoF8mldLDtyEzOo4iZdw77B78HJObdqdRDUv+DWYTJwszmR9/hPeOrufBHQvotHoGPn9/SLhWwj0dn2RKk6GcqlQrsWaWyIcZKa0/3svxkHvJkHlTaFLy9vrztP1mJweTC62j5Y4euPV8guDXNhLxXTq+D/+AfWR3S6o1UHZyAwnvt0WTdOyKvgeCcCuQlv/6t9Ua2TXkOetXcze/mzsxQRAEQRAE4bJEhqBQq0MphexOtAS8WgU40y3MHbNBjz4/BX1uIqq4feSt+hToy8UPy67dHsNn/DRkju71vp7ZbOapPUus2T7Dg5ryxFXUDawre7mC37qNp5tPGM/uW4rGaGB3diJhSz7FQ2lPYxdvGrt4E+bkQYijGyPa2RKzKg9MNny1LZ6FD7ep87WkSnsavLSSlG+HUxa7GZOqkKQv+hL82kbsQtte/gTCXWf9mWxGzz1Emc5ST9MrONtav25Ks+71Xrar9G+M26TFFM4cSZ/cC3Ta9SO/d5rAz0pX9CYjNlIZP3UazYSIqp13e/uFI0GCGTOb0s/zSd2f9tUYyzMEZdeg0YZUIqWzTwidfUL4uv1winUaThRkcCw/neP56RzKTuZ0SQ6a8uW7lZUZdJy1deasrTO7fBqzzN2TVgqFNWgHIFXY4xA9APOkKdZtTXydODy5O59sPs+nmy9gMJmJySim4/SdvNAtlLf6NMLLsaLRidzFB/c+z+De5xlUF/aROmM0hsJ09LmJJEztTMDEeTi3E0srBUEQBEEQBEG4cURAUKiR2Wzm43Wx3KteQ0vDGXpll3F+SiaGgjTr0rdqxyDB/4lfr+h6OqOBd4+sY3FiDADeto780mXMDe3MOSGiPa09Ahiz9Q/iyrMD87Qqdmcnsjs7sergJoBOyaICRwyrE3iseRNauQfgb+982TlLlfYETV5JyrcjKDu1EZOqkNQZo2n4aSxSZe1LsoW7i9ls5qMN5/hw4zksJe3MREYVcFaWCoCvnRP3h13ZcnObgGgCnlpAytdDsDcZeGb3zzz5ykZWmyQMCmxMK4+Aasd42DrQ2iOAw3mpHMpNZWXyKYY1aFqv65bptbx/dAOxRZb6h/9dln8tOCts6eITShcfS73TvLw8XNxciSvJI74kj7jiPOJL84kvySO+JJ+4klxUBj1lZjMPqjQc6D2RBo61L8G+yNZGxkcDGzO2hT9PLjrO/uRCTGb4dkcCs/Ym8Wi7IEY186NbmDu2NhWP0z68I2EfHiblh7Goz+3CrFOT9vPDOET1uqI/pAiCIAiCIAiCIFwJERAUarT4wDmG7H+Orvqjlg0ZUD2/hvJMmosBsCsL3h3ISeaJ3Ys5UV5zSIKE37rei7ed0xWd72q09Ajg8PCX+PbUTg7mpnC6KJuEknzM/1kWDYBCCwotS7PzWLrJUlfQ29aRfv4RjA6JZmBAY+zk1RsaAEgVdgS9tJzkrwajOrMNfV4y2Uvfw/e+r67nwxNuIx9uOMeHGy4uzTUT0TyTs6aKpbrvtuiLUnZlb+GGvEQK/nrZel9q60TT4Ba0cL708vzHI9pzeG8qZsyM3/4nOwY9SxvPwDpdc1P6OSbuXkJCab512+DAG9NxVy6VEeniTaRL9WXBWqOBoZvmsCn9PFnqEoZt+pVdQ56tU7digGg/Z3Y/35Ufdifw1pozlOmMqPUmZu5JYuaeJOwVMno19GBgY28GNvYm3NMBuasvIa9vJu2nByk+uBizTkXZ6a0iS1AQBEEQBEEQhBtGBASFarJS4lD+Mpiu+or6gUgkyF39sfEMQeEZgo1nCCaPIMyhHTC9/DESwAyU6DVIkSCVSLGVyS+ZLVem1/Lu0fV8F7sTU3lXTxupjOkdRjA4KOr6PshLcFHY8X6r/tb7GoOeCyW5JJUWkFhaQFxJHsfz09mTmYzGrKtybLamlPnxR5gffwQHuYLBgY0ZE9KcwYFRONooq4yVKuzwf+I34t5qglmnJn/d1zg2H4Rj07435HEKt645+5OtwUCJ1ETzdmkcL6t4PX7VbhjPRHW5onOrLuwj/7thmEtzAZC7+hE0eRXyywQDAZ6K7GTt9Ksy6Bm6aQ77hj5P8CUy2/K1Kl4+sILfLxyybrOX2/C/1oN4PqrrFT2Ga0kpk7Ok18N0Xv09sYVZxBRkcP/2+Szr/RiyOjY9kUklvNAtjHtbBvDtjnh+2J1IidbyJxSVzsjq09msPp0NQEMPe8a3CuDdfo1w6/M0xQcXA1B2apMICAqCIAiCIAiCcMOIgKBQhSY5hoSp/Wikt3x4LbNxo8nL/2DfqAsSuQKT2cTWjDhmn9vPv8kn0SaeZ4CdHAe1AZWdHOc/37GeK8Deha4+oXTzCaWrTyjNXH2tH7Bryhbq4NWAOV3G0dStbp17bxRbuQ3N3Pxo9p8i6SaTiQcX7+Wv0+fArgSZfRmObiqK9JauzGUGHYsTY1icGIOtTM6ggMY8E9WZPn6NrIFShVcIPuOnkfnHswCk//wwYVNjkDtVb44g3B3Wnclm0hLL0nmkBsLbJHC8LB2wBMzndhvPfWGtrujchbv/JOO3JzHrNQAog5rTYPIqbDyC6nS8RCLh585jSCkrZEvGBTLVJQzZOIddg5/DVWlnHVekU1vq9+Wm8vmJrWRrSq37+vtHMKvzGEKcbp3lsS4KO1b2nUCHldPJ1ZaxKuU0rx1axVfth9frPD5OSj4dEsXbfRux5Xwua89ks/ZMNkkFauuYuDwV/9t0nt0J+Sx9sC0ShR1mnZqy2E3X+mEJwm0nLrcMld7IQzN21bg/2s+ZmWOa3+BZCYIgCIIg3JlEQFCwKj2xgcTpo3HWWT68J8sDafXOBhxCokhXFfH7qZ3MOX+A+Bq679YkTVXEwoRjLEw4BoCLwpbOXiHYy234J+mEdZy93IZPWg/muagudc7IuRVIpVLmje2Meb4tfx9LxwiQJeOXewM4VhrHP0knyFSXAJYOrv8mn+Tf5JN09Qnlw5b96eUXjkQiwa3305TGrKP02EoMhRlk/PoEgS/8e0PrJwq3hiOphYyZewijyQy2pXhGxnFeXQiAk42Sf3s/Sh//RvU+r0mnIWvBSxRsnWXd5th8EAHPLERWz6X5Cpmcf3o9Qpc1loy6U4VZjNzyG718w62NPCoH+i9yV9rzbfsRPNiw9S353A5z8uDfPo/SZ91P6ExGvj61g0gXbyZGdqwyziSB98rrnWZrSpncpDsvN+tRpTyAo1LO8Ga+DG/mi9ls5lxOGevKg4NbL+ShM5rYFpdH91mHWRLaGePZzeiyLqDLTULhGXyjH7og3DJUeqO1gdJ/xWSU3ODZCIIgCIIg3NlEQFAAoGD7HDJ+n4TUZPmP+CF5E2wf/5uDMjM/b/qV1amnrct6L/Kzc6aDVwP0xiQAZEYTQwKjMGNGYzRwJC+NQl1FZkyRTsPatDNVznErZgvVh0wq4Y/7W1GqM7IqNositZHXF2Ww5oleTO84kj3ZSfyTGMOSxBhSVUUA7MpKoM/6WXT3CeODVpbAoP/jc4h/pzmGokxKjiyncNvPuPWadJMfnXAjJearGDL7AGV6PXgnIfFOIddoec352jmxtt8TtKyh2cfl6HISSJ0xBk3SEes2u65PEjThRyRXWIPQVWnHmn6P03HVDDLVJWzPjGd7Znyt4+8Pa8U37YfflLqg9dHVJ5TZXcbx8M6/AHh271IaOnkQ6OCCXi7FxmBCbSvn4+MV2XzvHl3Hz+f28XnbIYwPbVkt2CmRSIj0diTS25EXu4dxLK2IQb/sJ7NEy8nMEmaZQnmifGxZ7GYU3SfcqIcrCLckB4WMXc9XLyfQtZasQUEQBEEQBOHKiICgQM7yj8lZ+p71/mpld1a3f4WC7A3EnM2oMlYqkTAkMIonIjowOLAxcqmM0T+uBMBWZ+Kffo9bx5rMJk4VZLErO4FdWQnszEogpawQuPWzherDRiZl0cNtGDJ7P1sv5JGv0tP7p72seKwdfSIsy6W/aj+MFcmxfHBsA8fzLcs/d2TF03vdT/TwDeOHjvcQ/ORckqcNACBzwWTsI7uj9L95tRSFG6dIrWfw7P1kagug4SmwVVnb2LTxCGRJr4frHTQ3qkso2jOP7CVvY1IVAiBROuA/YTaGRv2uOBh4UbCjOyv7TqDH2h9RGfTW7W4KO1q6+9PC3Z+W7v508AqmsWv1Zh63qofC23C2KJv/xWzGYDbRd70lq3KAjSUgeJFMIkUqkaA3GUkpK+T+7fOZEbuLHzrdU2OX5otaBriw94WuDPx5H2dzylhnaloREDy1CTcREBRuE7rsOCh/p5JgJmFqRRBP49kEqdLhJs1MEARBEARBqAsRELzLGUpyqwQDZ9mNZY7/SFDupaygomFGqKM7T0R04JHwtgQ4uNTp3FKJlGh3P6Ld/Xi6cWcAkksLSCjNp4Wbf5WaY7c7OxsZKye0Z+wfh1l7JhuVzsh9849w5vVeuNsrkEqkjAxuxvAGTViWdIoPjm2wdlXenhlPm5Xf8lRkJ+7rPwWnDV9j1qlJ+W4koe/tR+bgenMfnHDd/XU0jdP5uRB2HGwsrzuFVMaHrQbwSrMeyKWyOp9Lm3mO/A3TKdr9ByZNxRI7pX8TAp9fgtI/iry8ui37v5y2nkHsHfI8m9LP08jZkxbu/gQ5uN72Qf6PWg/gbHEOSxJjqu2TGU3M6jyGe4KjKdSpefXgKpYlnwRgb04S7VZ+x8tNu/N+q/7YyxU1nj/E3Z7dz3dl+K8H2JsQSqHECVdzCUVHV+FXVihe88It5ek9/1h/X1V22mSmtlZEZq0KUy37BEEQBEEQhFuDCAje5cyVlvRuVnRguucI7IJPojZYghIdvBrwYasB9PNvhFRy9fX9Gji60cDR7arPcytyUMpZPqEdY+ceYvmpLHJKdby28jSz721hHSOVSLknJJqRwU35N+kk7x9dz6nCLLRGA9/F7mQ6Uvq2e5gHz22mTeY5UmeOp8GU1UjqERASbj86tBASYw0GtnIPYH6P+4ly9anT8WazGdXZneSt+4rSYyvhP8v7XTo/hN8jPyK1dbzmc2/u7k9zd/9rft6bSSqRMrfbePI0ZWzLjKebTygKfSJgyYS+WFfQ09aBf/s8ytaMC7y0fzkxBRkYzSa+OLmNeXFH6OQdTDM3X6LdfIl28yPcydNaJ9XDQcGmpzoxft5h1uzvxv2aNUi0JZxa8hnNH/nsZj10QajmREEGMQUZNP9PY61IvQqpyfJeY0ZC6DsVS3olP03krI09XVd/X+18ap9oGhs0zL++0xYEQRAEQRAuQwQE73Irz+bTuPx2vIMLyvBTqE2WoMSQwCj+6f0IyqtcWng3sZFJ+XlsC3YmbCVfpWfOgWQebhtI94YeVcZJJVJGhzRnWFATph7fxDendlJq0GLGzEYHLza2Gk9USRYPpx7m/r9fw3vcZ+RoyrhQlIlek0uupowcTRlmzPjbO+Nv72L5184Z20rNDYRbX6ley49pq0BpCc57y93YPHASbkr7yx5rNugpPriEvPVfo0k4VGWf1M4Z166P4Nb7abH0/ArYyxVsGfQ0GoMeW7kNo+dsrnVsL79wDg9/iW9O7eD9oxtQG/VkqItZmnSCpZUaKNnK5DRx9aGXbzhvt+iDm9KexQ+35VH1U2gPbESJHu3W6RwL7UrL7kNvxMMUhDpp7ubHriHPVdmWMLUrr+q9MVM9IzhSr6627aKzCofbPotYEARBEAThTiAiPXcwlUHHtow41qSeZm3aWXI1ZXT2DmZAQCTt3UL5blMW64+eYw9w2tGbX5pGoTVbgoEDAyJZ0uthEQy8At5OSr4c2oTHFx0HYNKSGI693B2lvHqWn0Im56PWA3m5WQ9+PX+Q6bE7SSwtAOC0kw9vRg3mXbURw7w363x9d6U9/nbO9PAN49O2g3Gysb02D0y45rLUJdy37U/OlpYvx9Mp6Wnb67LBQLPJSP6m78lb+xWG/JQq+2y8QnHv/xKu3R6rdwdhobq6BtjlUhmvRvdidEhzXj24ik3p5ynWa6qMudhs6UheGn8lHGVW5zEMDWrCrxMH82vySHpmLsbBrMY4ZwTHE9+k+YMfIbmNOq8LwkVTixLQpsSgzI2ttm+MUzCI+oKCIAiCIAg3nYj23GHiS/JYk3KaNaln2Jp5AY3RUGX/urSzrEs7a7mjUyILcGKxMppvwrpRJrc8Hfr5R7C096Mi0+wqPNY+iLmHUtgRn8+Z7FI+3xLHe/0jah3vorBjctPuPB/VhRXJsXwTu4NdWQkAGOq5XDhfqyJfq+JkYSb7c5NZ2+9JPG3Fh69bzcL4Yzy7byl5WpVlg8EGEpuTH3zpzBljWSGpM++j7MS6KtvtwjvhMfBlnNqMFEvMb6IwJw/+6f0IZrOZlLJCThRkcKIg0/rvmaJs9CYj6apihm36lYcatuHbDiN46O1fWPNuOtGFu5FhQrb5f5xI3EOTlxYid66tUpsg3JpsA6Nr36mwFw1HBEEQBEEQbgEiIHibM5vNHM5LZVnSSf5NPklsYVaN42xlcjyUDqSpiio2KrQYPbR84NHfuqm3XzjL+jyKnQgGXhWJRMKsMc1p8dUOdEYT/9t0nntb+hPpfekabnKpjHtCorknJJpDuSl8vfU3YrLicdaW4aZX4a5X42Y2ERTZjeBWQ5EqbMlQlZCmKiJdVUy6qpg0VRGJpflojAYO5abSfc0PbBgwkUDRqOCWkKsp45m9/7C4UsMKf3tnSs81plhnR0ph7UvttBlnSfl2OLrMc5YNEilObe/BY+AU7MM7Xe+pC/UgkUisNVOHBDWxbs9UFfP03qXWRiTz4g6zMf2cJVvw8y1M/2QKQ5JmIseEPG4rZ95qQdgLi7CP6FrbpQThluP36Mxa99ks/xa5XPz3UxAEQRAE4WYT/yO7zRhMRg7lprI/J5kDucnszEogpaywxrGhju4MCYpicGBjfKU+DP7lIGgKwbEAHPOROxdjoCKDsIOuhBV9Hqu1M6ZQP419nHizTzgfbjiHzmjiqSUxbHm6U51rJ7X1DGLB2PcwqovJW/sVeeu+wqwts+yM245s9y8EPv0XDk16VTv2XFEO/dbPIrmskNNF2XRZ/T2zOo9hQECkqN10Ey1NPMHTe/8hW1Nq3fZQwzZ812EEvb4/yPHCYlKKNJjN5mo/p7IzO0j5bjim8qC+3MWXwBeW3naBQLPZjNFkRm8yYyOVIJfdXUtife2dWdr7ERYmHOO5ff+Sp1WRqS5hxObfeDKiA9+98y0vz2jOmJNv4WvKQ1qSQcKnPfF/5Cfcej5xs6cvCIIgCIIgCMIdQgQEbxPJpQXMOX+AOecOVM3yq0QmkdLdJ5RhDZoyOLAxEc5e1qDCS8tOklmsA+zx0Ljw45DhjIj2Zk92In/PmYRUr2FCymF0UR1w6D7hBj6yq5dTqiWzREszX6dbLtj1Zp9w/jqaxrmcMrbF5bHyVBbDm/nW6xwyO2e87/kQ977PkrLoXdR7fgOjHmNRFsnfDMPvoe9x7ngfUhul9ZgIFy92D3mOfut/5kxRNsllhQzaOJvefuF83nYIbT2DrvVDFS4hS13Cc/v+ZUmlrEBvW0d+7jyGEcHNAHBSWt6OVTojGoMJO5uKZb+6rAukTB9pDQbahrQh6MVl2LgH3sBHUT8Xcst4c/VpdibkozWY0BtN6I1m9CaTtQmyQialub8TbQNdaRPoQtsgV5r6OmFzhwcJJRIJ48Na0csvnGf2LrU2Hvnl3H5ei+7FNy8+ziOzQ+h16E266Y8gMRnJWf6hCAgKgiAIgiAIgnDNiIDgLcxgMrI65TQ/n9vH2tSzmDFXG+MoV9LHP5xRDZoxNKgJHrXUimvqW9Fc4KnOIYxr6Q9YumM2bdKV3OUfAZAx53FMqiI8Bk6+Do/o2tLojXy5LY5PNp1HYzBxf6sAfhnXHHvFrfO0VsplTB/ZjIG/7AfgpeWn6Brmjrt9/bMw5c7eOI/6hIARb5A+53FUp7di1paRPvsxsha9jluvSbj1egobN8vPNtDBlZ2Dn2Xs1j/YlhkHwJaMC7Rb+R2DAxszskEzhgRF4W/vcu0esFDN0sQTTNyzuKJWIHBvaEu+7zjKWttRozdyKKUQgHBPhyrBQKOqiORvh2MqszSbcWw5jMBnFyJV2N24B1EPKp2BTzdf4IutceiMpkuO1RlNHEop4lBKxR85lHIpzf2cGRzlzRu9w7G1uXPrIfrYObGk18M8tecffj63D4BMdQnhzp788URfOqsU+J98iIbGVPSlhTd3soJwC4jJKKHrjF017ov2c2bmmOY3eEaCIAiCIAi3r1snciJYZWlK+e7IQeacP0C6qrjKPrlEysjgZgwKaEwHrwY0dvFGVoculCOb+fLUkhhMZvj3RAZTBzW27vMa9QFmo568VZ9arv/XFIyqQrxGfXDLZdxdtDo2ixeXnSQuryLIsuBoGqeySlj6aFvCPG6dguX9I73o08iTzedzSchXMX7eYdY80eGKl0oqvEIJenEZqd+PpezkBgCMxdnkLv+Y3FWf4txuLO79nseuYUc8bR3YMvApVqbE8sah1ZwuygZgTeoZ1qSeAaCNRyBDg6IYFtSUVh7+SCV3dnbWjVKkU/Pi/uXMvXDIus3XzomZnUYzsjwr8KLdCfloDJbgWb8IT+t2s8lI2k/3o0s/DYBtg5YEPvPXLRkMNJvNLDuZyeTlp0gqqKiD6OWowNdJiY1MikImxUYmwUZq+TezRMvJzBKMpoo/dmgNJg6mFHIwpZANZ3P497F2+Dgpa7rkHUEikRDu7GG9n18eOFbIpbzWO4KSU5b3MuN/OhYLws0Wl1tmvW2GWgN1/3XKtgxHZf3/+xnt51zrvpiMknqfTxAEQRAE4W4nAoK3kCx1CV+c2MqPp/egMVXtDhzu5MmTkR14JLwtPnZOtZyhdl6OSno29GTLhVxis0o5nVVClI/lPBKJBJ+xnyCzdyV70esA5C7/CJOqAJ/7v0VSh4Dj1TIYTWy5kMvh1CJC3OxpE+RCuIcDUmnVgGRCnoqXlp9kxamK5ik2Mgm2chklWgPH04tp+81O/nqwNQMae1/3edeFRCJh3v2taPvNTtKLNWw8l8uba87w5bAmlz+4FjI7Z4JfXY86/iD5G2dQfGAhZoMOjAaK9/1F8b6/sIvoSuCzi7Bx9WN4+TLy3y8c4n/HN5FYWmA91+G8VA7npfLhsY342TnzVvPePNdENDC4Gtsz43h4x18kV6rveX9YK77vOAo3pX218RvP5Vpv921U0VE2e/GblB5fA4DM2Zugl5bfkt05z+WU8sK/J1l/Nse6TSmX8nqvcN7oE14l4/G/1HojMenFHEopZH9KHruykkjUZGHWy9mbbKT9dztZOaE9zf1rDwbc7jwq/UzztBVBlnuifVliYwsGkJsNnM0qItJHZPQKtwaV3niFx5mQSOp/7KWy/+oajBQEQRAEQRAqiIDgLSBHU8oXJ7byw+k9qI1663YbqYx7gqOZGNGBnn4Nrzpza0wLP7ZcsAQe/onJ4J1+VQOLnkNeQ2bvSsbcp8BsJn/jDIyqIvwfn4NEdu2fKkaTmV0Jefx9NJ0lMRnklumq7HdSymkV4EzrQBfaBLoSl1vGZ1suWDOpAPpHeDF9VDNkUgmjfjvIycwSCtR6Bs3ez/8GNeaN3uG3RJajn7Mt/z7Wlm7f70FnNDFtWxwt/Z15oM3V1YCzC2tHwKQ/8Bn/JQXbfqZgy0wMhRkAqM/tIunTngS/vgUb9wDkUhlPRHTg8UbtOVGQwcqUWFalnGZ/TrJ1OXqGupjn9y+jgaMbwxs0verHfbfRGPS8e3QdX53cYf2euinsmNlpNPeGtaz1uE3nLYE0qQR6N7JkCBbtX0Temi8tA2Q2BD2/FBuPBtd1/jXRGox8uTWOhcfS0RlNSCUSpBKQSSXW26cyS6ssDx7WxIevBwThFruYoiW/IO01CaVvo2rnzteq2J2VwM7sBHYVJnBIl4rexQjlMS+JTzy6TAde/3Ibb7Syo7GyCENhBrahbXHv/QySO6QbukelIHGepiLrWS6T4u/hCqmW+9O3nuaH8R1v8OwE4fIkwK7n6/aHJKdftl/fyQiCIAiCIAh1IgKCN1GupoxpJ7fx/endlBkqgmEOMhteaNqNyU2742XreM2uN6qZL88uPYHZDEtiMninX0S1MW69JiK1cybt54fAaKBo9x+Y1MUEPL3gmixTNJvNHEgu5K+jaSw+nkF6ce3L4Eq0BnbE57MjPr/avgZudnwzvCmjon2tAb+9L3Tl8YXHWXQ8HbMZ3lpzhoMphcwd3won25v/VG/fwI2fxkQzYeFxAJ5YdJwoH0daB7pe9bnlLj54jXgXzyGvU3xoKdlL3kafE48u8xyJn/Yg5I0t1mCSRCKhubs/zd39ebtFX7LVJaxJPcOy5JMsTz4FwKQ9S+jqE4p7DdlsQs1OFWQyftufnCzMtG7r7x/Br13vJcCh9qyuvDIdR9IsNfTaBbniameDNv0MGb8+bh3j9+hP2Ed0uX6Tr8WehHyeWHyc01mllx8MhHnY80Nvd1ol/UXB1FlkqS0lD/I3fItbjyfxHPkeNq5+pJUV8fDOv9iSceGS5zPbGMgMKuKEZxG7T+7BPes0MswU7fmTor0LCHxqAQqfhlf9OG+2yrVf83WqKvuCPF1RlwcEFxyIw9XZhQ8GRN7xjVcEQRAEQRAEQbi+bn6U5C4UvuQTJO7O6ExGTOaK2ln2chuej+rKBP/mRPhf+y6wvs62dAt1Z0d8PsfTizmfU0ojr+oBR5eO45HaOZM6YzRmvYaSI8tInjaQ4Nc3X1WmYIFKx1NLTrDoeHq1fU5KOSOa+TC4sQ+pRWqOpBZxOLWI85VqFIGlK+mrvRryVp/was1DHJVy/n6oNe2CXHl9dWx5vcRMzmTvZOvTnW+JOmSPtW/A0bRiZuxKQGMwMfzXg/x2b0v6RXpd/uA6kMgVuHQcj31kd5I+74Mu4wz67DgSP+1J2EdHkdXQQMTbzolHG7XjkfC2jN36B/8knSBTXcIL+5bxZ4/7r8m87nQZqmJ6rZtJjsbyfLWT2fBlu6E807jzZTNUl53MtHbd7RvhhUmvJfX7MZg0liCca8+JuN3gzt9nskr4ZPMF/jySap2bXCrB00GByWzGaDJjMmO5bTbjpJTzVMdgnixdQMHPn5BnrFryAJORgq0/Ubh7LqltxvCYYyBp+qoZwRKzmUZlObQpSqN5cQY73UNZ4xMFQJqdC29HDeL3oLZ8e2olIeoCNPEHiH+vJd5jP8Ot91NIpLdv8xF3ZcUfW7LVVYOvNko7LlZkVJj0fLL5AgeSC1n75JXXIRUEQRAEQRAEQRABwZtAazRCpQ/MdjIbno3qzKvNeuJt50ReXt51u/aoaD9rxt2O+PwaA4IATi0G0+CV9SR92gMA1dkd6HISalz2VxdbzufyyF9HSS2qyAi0s5EyrIkv97b0Z1CUd411xoo1eo6lFXM4tRCV3si4Fv61zhks2W+v9GpIqwBn7p13mDyVntNZpby07CR/PdTmiuZeFyaziXNFuZwrziHc2YMoF59aA0FfDW/CiYxitsXlkVakof/P+xjR1IefxjTH19n2mszHxs2fkDe3kfhpT0tQMCcB9YW9ODYfWOsxEomEHzvdw/bMeHK1ZcyPP8KQoCjuC2t1TeZ0J5seu8saDGzjEcj8HvcT6XL5GpZbzucyZcUp6/0BkV4U712ANs2yzTa4Nb4PfHd9Jl2DExnF/G/TeWuW7UVdQ935eWxza93R/zIb9GT8PomCnb9Zt0kU9rh2n4CNqz+5a77ApCpkl4M3k2UulJUHAwO1JQzKjKVNUSotijNwNmgtB0tljFMqebHUga8cA9iA5b3hvKMXw9s8zsfntjMi+yAmTSmZ856jcOdv+D0yE7uwdtfnG3Od+dlV1Eecc/4AKqOeHj5h9PBtiFOlLF07LO+fm87nklGsJcjt1msuI9yent7zDycKMmrcF1OQQXM3vxs8I0EQBEEQBOF6EwHBm6Cluz8KT1ekEindfEJ5uVmPK2oUciWa+VZcJ6VQfYmR4NC4O/aNe6A6Y6n3I7Orf1F/rcHI22vO8NX2eOs2TwcF/xvUmPtbB1y206CzrQ3dG3rQvaHHJcf9V58ILw5P7k7H6bvILNHy97F0nujQgD4RtWfi6fNSUF3Yg/rCXtSJh5HZuWDfuAcOjXtiG9zKmh1pNJk4W5zN4dw0a0OOY3nplF4MZgDeto709G1IL7+G9PQNJ9LFyxogtJFJWfxwG8bNO8zWC5bg7/JTWSQW7Gf3c11wuILuizWRu/ig8A5Dl2HpJqwMuHwTE287J2Z1HsPorXMBeGrPP3TyCibEyf2azOlOpDMamHN+PwBKmZw1/R7Huw6v5z8OpfDEouPojZbI2/CmPnQJcSNhzjfWMX4TfkGquDZB4tqYzWY2nM3hu50JrD2TXWWft6OCDwdEMrFjcLUGPxeZtGWkfj+W0pi1lg1SGZ7D38G93/PIHS2vW7feT/Htsk95XWvAWF4LtXVhKjNOLsfVYAlySR3ccOo4HqcWQ3Bo2g+ZgythQH9gf04SD2xZRJwqC6PczFtR3dltH8HniQuQYEaTeJiEjzrg1uspvMf8D5mD23X5Xl0vbkp7RgdH80/SCQD+ij/KX/FHAfCQutKmyVDaFqWCNA8kjjzQsgF6mYo8jQknGyWK61DjVbi7nCjIqDXw19zNj2gREBQEQRAEQbjjiE8RN8HKfo8TGHh1zSSuVJBrRUZJcsGlA4IAmMobBUgkyBzrF5Q7kVHMA/OPcCKjxLptUGNvfr23xTXLhLuUYHd7vhrehAfmWz5YP7v0BMdf6YECE/qCNHTxMeQdjEN9YS+qC3swFKRVO0fp8dUAGOxcONSkP2s9G7HeYKTkv0si/yNbU8qixOMsSrTUC/S1c6KXXzhPRnSgl184no5KNj/VicXHM5iy4hRpRRqOpxfz2MJjLHyozTVphGI2mVCd3wOA3D2ozg0p7gmJ5omIDsw+t59ivYYHdyxg26Cnkd/GSzKvp3+TTlqzA8eFtLhsMNBsNvPxxvO8v/6sdduY5n78cX8rVKe3ok21BIXsG/fELqT1dZt3mdbAvMOpfLczgTPZVZepBrjY8mrPMLpE2bI+/TQdVi8jqbSAAQGRfNpmMIEOrpbHYjKS/NVgVGd3ACBR2BH47CKcWg61nstkNvH26T18rjNBeTBwpMTAR0m7USjtcewwDucO9+LYtC8SuaLGuXbwCiZm9IuM3TyfNemnQAKrQ3zZb/cuf6Utxr/4NJjNFGyZScmR5QQ88zcOkd2uw3ft+vmly1gc5ApWpMRSqKt4b85DwgbvSDZ4RwIFQAHzi48x/58V1jEOcgXD/SL5tss9dQpGC8J/6bLjiNCWMS+x5oYftoHR0Hn0dZ/HzAZRZCjlfPTTxBr3N1XaMfexG5c1LQiCIAiCcCcTAcG7TJBrRSDuchmCAIbiLABkjp51rh9oMpn5dmc8b64+Y+08amcj5avhTXmqU/AN6fprNhrQpp1iYNE+pttsw5CXjG9hLiefK8ROk0OV9ZC10Euk7HNrwDqvSDZ7hVMitwWttsaxEc5etPEMpLGLF8fzM9ieGUeetqI5QKa6xJr109O3IR+26k9334aMa+lPm0AX2n27kwK1nsXHM2jpf4G3+l7Z0uzKtOmxmFSFANg3ql9Dim/bD2dHZjzninPYnZ3I/45v5v1W/a96Tnein87utd5+KrLTJcfqDCYmLYnh94Mp1m2v9mzIZ0OikEolJK//2rrdY8Dkaz9ZIClfxbQtifx5PIdCtb7KvnBPO4a3s8PgmMP01EW8FFe1fMGfcUf4J/EEr0f34tXonmh3/m4NBsocPQiashr7hh2s49UGPY/s/IvFiTHWbW8378NHrQcgffTbes3bXq5gZf9HePvwOj47sQWAXJ8y+tk+xHOZmTxdMBc0RRgK00n6tCde93yE59A363WNm8lNac/c7vdhNJk4UZDBH6dP8sOxY6DIRmdz6ffMMoOOv1JOsG7pBb5oN5QJjdpddVd64e5i0pZh1qpq3KdNialx+/VwzsGTDFsbmhiqz+WMzBa0dfhDpiAIgiAIglAnIiB4l7FXyPGwtyFPpSe5TgFByxJCufPl66GBZYnwwwuOVWkc0jbIhT/vb02k97XrmPxf+vw01PH7UcftRx23D3XCIczl3Tr7VB5YS2Kf1MEN+/BOSMI6csArnHUGM/+mxJKnr94F2V2nomNBEk1LsmhakkVUaTaeQdE4Nh+EY0AYds37YpbAyYJMtmXGsS0jju1Z8eSXf9jalhlHj7Uz6ePXiI9aDaCzTwgLH2rDwF/2YTLDO+vOEO3nxLCmvlf1PVGf3229Xd+AoIONkgU9HqDT6hnoTUY+Or6Rfv4RdPYJuao53WnOFGazLTMOgGg3Pzp5B9c6tkitZ8zcQ2w6nwuAVAIzRkXzTJcQALTpZyg9vgYAhU84jpWy7K4Fs9nMJ5vP8/76cxhNVQPi/SI8adlEy++pW/k6pazG4x3lSkoNWtRGPR8c28Dss3t58dQqBgESIGjyKuwbdqBMr2VHVjwb0s6xMiWWuBJLUFEukTKr8xgmRLS/4scglUj5tO1gGrt48cTuxRjMJnDJ43sbd5ZKv2GxfB6uSVvBbCLnn3dQnd2B/djvwKN+2c03k0wqJSNbzqzVRnS6JgzW5DDJ9DvHXPwxdhiPoUErivUaSvRainUaivVajuWnkadVUaBT8+Tuxfx+/iCzOo+hqdvVvYcIdxeJ0p7QF3dV277ppVaoMop5aEbVfc/qjNd8Djm2AciBQ0+9VW1f21qyBgVBEARBEIQrIwKCtUhISCA0NPRmT+O6aOBmR55KT0qhGrPZXGvGntmgs2aYyeoYEBw6+0CVgMdbfRrxXv8IbK5TN0yTtozUH8ZZAymXokdGltQDvZM/LZs0RW/niWtoC8oatGKjTsfK1NOsTztLWcHhase6K+0Z6R3CMJOaVokH0KQdwlhcUW9Nk3gYTeJhcldMxTakDf5P/k7zwGY0d/fnhSbdMJlNLE8+xftHN1gLt2/OOM/mjPMMCIjkw1b9mTasCVNWxGI2wwPzj7Lvha408b3y5X+qcxUf3uwjutb7+Daegfyv9UBeO7Qak9nMAzvmc2zEFFwUopHBRbOqZAd2rPW1lFKgZvDs/ZzMtCyft1fIWPhQG4Y28bGOyd9QsQzOvd+LSKTX7jWj0hl47O/jVQL1djZSHm4bxAtdQzmljmf89qVVup4rpDL6+DViZHAzhgU1wUGu4JOYzXxzagc6k5FUdQmvhvXgT49GvOToxCq1mg3rZrEzKx6dqWqgwNnGln96P0xf/4hr8ngeadSOECd3Rmz6nSK9GuxLSA++QJekJ3jXrxHjMucgNRspO7mBwvge5Dz4GyHt+lfrTH4rmncohQkLj2MoD9pGNgggPDaPcFUeXvLxeLUZVO2YfK2Kl3YvZV7SMQB2ZyfScvnXvNKsJ++27It9LUuxBaEuVHojZTUE/xwUN76MhFmrImFq9d9nr2UUk2oXBtT/d50gCIIgCMLd6tb/dHQTLF68mAceeIAff/yRJ5544mZP55oLcrXjaFoxar2JvDIdbhI1mqQjGNXFmNRFmNTFGNXF1lpmULcMQTNYg4GOShn/PtqOvpdo4nG1DMXZpP30IGWnNlbbp/CNwK5hR+wadsA2uBV6pwBazIolqUgPmOkqs8XDJZ/0gmwOx8+vEgi5yNnGlpENmjI+rCV9/SOwsdbQexazyYQm6SilMWsoPb4Gdfx+6zJkTeJh4t9rjfeoD/EY/CoSmRypRMqo4GhGNGjKP4kneP/oek4XWQKK69POsj7tLI1dvGnSwoPYCwpKypy55/eDnHy1J/IrDKaqyjMEpbZOKIOir+gcLzfrwfq0c2zOOE9iaQGvHFzFL13GXtG57jRao4HfLxwCLDXcHmxYcxdrg9FEz5l7iM+zZIj6OilZ9Xh72gS5VowpyaVwt6WRi9TeFdduj16zeeaUahk8ez+HUoos55fAy10CeWNAU9ztFRzOTeWBHQusr4GRDZrxQMNWDAiIxMmmaq3Pz9oO4clG7Zm87ntWqiyZhMdd/HkM4NDqate2kcro6duQb9oPv+bZaj18G3Jg2AsM3jjbkoWo0ELDY3xcEsYvzm/xRMEaWpclEazOR/rzMKb90Rd8m9Ir0IZwRyPm8vc7o7oIjAbcB0zGqeWQazrH+lp2IoOH/zpmvf9gmwA+aOtBaqzlvqGw5i6w7kp7vmkxiIlNu/DUniWcKszCYDbx2Ykt/Jt8gvX9nyTYUTQGEq6cg0LGruerBtsSpjpD5pWdTyUtpuvq72vcbm+quYGZVOmACaCk+r4AVdyVTUQQBEEQBOEuJgKCNVi/fj3h4eFMnGhZnnKnBQX9KzX0yDq4nNy/H8ekKb3EEWDjUftSyP/ydFCw9skOtK0U8LjWSo6vJX32oxVZejI5HoNexaFxD+zC2lfrMmowGXmibybv7t4DTnnskqst9fn/Q2ZU4qzzxcfsz7hGTXi3S2SNATmJVIpdaBvsQtvgNeJdDCW5lJ3cQN6aL9EkHwOjnuwlb1FydDn+T85F6RcJWJY8jg1twT3B0SxKPM4HRzdwrjgHgDNF2UA2hAJGGWdL3fnooIwXWrbF09ah3t8js95S79Bs1KPPT0XhWfef4UVSiZS53cbTeOkXlBq0/Bl3mE/bDL6i+dxp8rUqa/MHO5mNZflqDY6kFVmDgY5KGfte6Eqwu32VMXlrvsBcfi63nhOR2l6b5fUpBWr6/7zP2jTE1c6GhQ+1po2nDHd7S9bYzDN70Jdn9D3buDMzOo6qNdNRlxWH7Ncn+OzMNu5xDeTzhr0441T1jwWNXbzp7x9B/4AIevg2xNFGeU0eS00iXLzYN/QFRm35nV1ZCSA1gUsOmS4w1a8nABKzmQBNESGqAtz0Z4jN0mGfrsfeqMfeqMPeqMdVr6bL92OIePxXXDrdd93meznb4ytqNj7WLojZ41pgLKoIAhbtmYdLp/uxD6+5VmVXn1CODJ/M16d28NGxjaiNes4W5RC97Cumth7Is427ILuGmafC3SNAFVctM89SW7Bvvc9lb3RGrTcRk1FcfafOAQd5zQFBhXdDAEKf+rnavhPPNq/3PARBEARBEO52IiBYg8aNG+Pr64tGo6kSFNTr9djY2NT5PMXFxRQXV/yHNyOj5uyOG82+fJnPKM1G+ONHTKZL1wGSOXrg1mtSnc//+ZCo6xYMNOnUZC96nfyNM6zb5G4BBD67CPtGnauN35h2jnlxh1mdetpSw8+zhpOqHaHEHYo9MWocKUBCAfBR/AVOppfy14NtUMgv/SFa7uSJS6f7cW43ltyVn5CzcioYDajj9hP/bku8x32Ge9/nrctAZVIp94W1YmxIc/6KP8bcC4fYkRVvDcwgM4JLDh+fXsmnZ1YzoVF73m3Zl/os1nXt9ii5Kz/BrNeQ9fcrBD23uB5HVwhwcOHpxp348uQ2NEYD38Xu5OPWA6/oXLeKa/Ha9LN3ZnxoS/5OOEautoxXD65iTtdxlzzm8fYNqgUD9flp1uezRGGPx8Ap9Z5LTc5ml9Jv1l5SCi11MIPd7NgwqSMRXo7k5VkCTyaziZUplvQzZxtbvm4/vMZgoNlkJH/Dd2T/8441cNm+MJVNbm5s7ngvh/PSiHb3o79/BA0c3aodfz152jqwacAk3j2yjpln9lJqqNr4xyyRkGrnSqqd6yXP46sp4YPFb3OvQXtNMzTro08jL77dkQBYMq6lUglSN39cOj1A0d75mFRFJH3Wm8BnFuLUeniN51DI5LzRvDfjQlswbNOvxBZmUaLX8uL+5cy9cIifOo2mnVfdOo4LAlC+FBf+m2OqDGoOufU/32DHDpwv0EEtZYyjvWsOCAqCIAiCIAjXlggI1qBx48bMnj2bZcuWATBx4kTKyspYtGgRH3/8Mb17967Teb7++ms+/PDDatsLCgqws6s9tFM5UHFd6LRMUi3kBdV86yZl82HYhLZHauuMxNbJ8qV0QmrrhMy9ASUyO8jLu8RJLaQS6OKnsAYcriV9eizFf07CkHm6yrydx36N2sENdaVrqgx63j61yVpTqzKFVEYLpwBsy9xx0PlhQEGpwkiJs5ESpZESnZFCtQEzsPREJkN+3s1v90RiZ1O3eknS7s/hHtaNogXPYsw8YwnIzX+J/H2LcLn/R2RugVXGD3YLYXC7EEr0WrblJPBXwmk2ZMWB3NIB1mA28fO5fcy9cJAH/ZvxatOeeCrta7p0FZLOE5Hu+A1TUQYlB5eQse9fFI261+kx/Nej/tFMj92J1mTku1M7ecw/Gpf/LCetzXV/Pl+CRy3NJGp7bZaUlNTruft+RHfWp56hQK/h1/MHGOrZkO5eIVXGlJVUZN9qNJpq5y9e8g7m8uY19t0nUWSQ1+m1dinHM0u59+9YclWWLjqRnnYsua8JHlIteXla68/kYH4q2eXZwb29QikpLKp2LkNOPMV/PYs+8aB1m8wrDOdx36Jo2JkhwBB3S8AArYk87bV/7dfF62GdeCW0A8mqIs6X5nG+JI/zpXmcKcomQVVQY4OgyjJtnXgq+h7W7/ybp5PSaD5gEnJpzZmS1+P9DaCNpxRXWzmFGgP/xKQztVcAtnIpyuGfoCjMQnd6E2a9hpTpo3Aa/QX2nR+1Hvvf15kLsLrTA3xyZjtzEo5gwsyRvDQ6rJrOhJDWvBXVo86v4euhttemcOtZEPwKQLUlwwDm0aPrfb5pgxqKn78gCIIgCMItQAQEa9C4cWNOnjwJwLRp09Dr9bz00kv07t27zsFAgClTplRZbpyRkUH79u1xc3O77H+Gr9d/ls0mI73OPkeY6m/rNs9hb+M1+uNalwnWR9dQdyIbXNtaYfqCdAq2zqJgzefWZbASpQN+D87Apduj1eZ9qiCTe/fM41RhlnWbm8KOIUFRjGjQ1FobLS8vr9bv8/a4XIbOOUCp1simuEIe+TeO5RPa4ais40vGozfeTY6R8+/75K35Eswm9HF7KPpxOCHv7MbGPbD6IcCjvv6Mi+yAw1trwLaEgKAyVI4pFOjUaE1G5qQeZ2HmGaY0686Upt0v0+DDA8V9X5H20/0AqFa8i+/Hx5DI6v+y98CDJyM78v3p3ZQYtPyVdZq3W9R9qdit9uGvttemk5NTvebqgQffdBjBo7sWAvDqyQ3EjHy5ShMHL11FVrHMRlnl/Oqko2Tt/xOw1A4MvOc9ZA6uV/qwANh6IZeR82Mp0VqCge0buLLmiQ54OFRtLOHh4cH2hP3W++Mata4yN7PZTMHWWeT/9bK1YzcSKR6DXsZr1IdIb9HmMt540ZZw6/2Lr/MinZpinZZSg5bTuUXMP5rE2nMZqI16cMkC53wA/vVrxu7SZKK/fQ+t3wN0CnZjRLOq72nX8/k8tqU/v+xLpkRr5EC2gVHRfoAHHq+uJeP3pyjcMQfMJkqWvIJSV4jXPR9Z3wP/Oy8P4Gff+5jYrCtP7fmHw3mpmIE5iUdYlXWeb9oPZ3xoy2vy3i8IgiAIgiAIwu1FFBOqQWhoKOnp6ajVakpKSjh48CAtW7Zk69atzJ49u87ncXZ2JjAw0Prl5+d3HWd9eSadmtTvxxJ2zhIMNCEhu++neI+Zes0+EI5sdm2CgWaTidKTG0mZMZrzUxqQu/wjazDQNrQdYR8dxbX7Y1XmbTabmX1uP+1WfmcNBjrZKPmj231k3/cB87rfz5iQFtUaJdSkR0NPNk7qhIutJXi25UIuA3/eR5FaX+fHILVR4jPuM0Le3onCxxKg0Oclk/RFPwwlta+zslfIifB0BLUzxUlBXBj9Ju+26ItDeZCp1KDlo2MbCVvyKV+e2IrOaKj1XM4dx2NX3mFYm3aKgi0z6zz//3q1WU/kEstbxjendlCm117miFvXtXxtPhzelr7+jQCIK8nj42Obquyv3GFbb6qoM2jSqUn76QEo//l5Dn3zqoOBC4+mMfDn/dZgYJ9Gnmya1KlaMPCiFSmnAJBLpAwMiKyYZ2EGKV8PIXPu09ZgoMKvMaHv7cPn3i9u2WDgpbgo7AhydCXK1Yd7wiP4Z2w/Ml++j+969aKztBs2aVEoDZafT7bSic3h9mSq/uLLHWfo+v1uKrcdMtfQhOhaua9VgPX2X0fTrLclMjl+E37Bc+T71m25K6aSPnsCZsOl35faegaxf+gLfN9xFM7l739Z6hLu3z6fPut+4mTBrVHOQhAEQRAEQRCEG0cEBGsgk8kICwtj//79DBgwgDZt2nDkyBGmTJnCxIkTrUuJbyfGsgKSvuxPyeF/AdBiwxSn18ls9tBVn7vyR+P/ZtLUl6Ekl9w1X3Lh9QiSv+xPyaGlYK2rJ8dz2FuEvrMbpW+jKscV6zTct30+T+5ebMn4Adp4BHJk+GQeCm+DXFq35b6VdQx2Y8vTnfCwt2R47U4soO+sveSrdPU6j32jzoS8uxeFfxQAuowzJH81CKO69qW0LfwtNZRKtAYKy8x81Hog8WPe5KmwdijLM/zytSpeO7SaViu+YXdWQo3nkUgk+D04A8oDedlL38NQ3sSkvho4uvFIeFsA8rQqZp3dd0XnuZUtSDrOjNhdLE08QbHu0ktML5JIJMzqPAY7meV58su5fRgrBf4qLzvVGyteLdmL3kCXbln+bteww1XXDvxmexzj/zyCzmi59ujmfqx+oj1OtjVnhF4oziW2PHDe3TcMt/Jl6MUHFhP/VjNKY9Zax7r3f4mwj45gF9buquZ4q3G2teGFbmHsfr4bZW8+xoreU+hYKb5+wcsW+/Cd4BuHsfznaAbCPtnM66tiOZ5efYn11eoe5oGfs6URy8pTWZRoKiYkkUjwHvUBfo/9bH1NF+36neRvh2HSXroxlEwq5dmoLpy55zXGh7a0bt+aGUfL5d/w0v7lFGprKeomCLeBMp2RrjN21fj19JKYmz09QRAEQRCEW44ICNYiKiqKUaNG0aZNG2bMmIFEImHatGnMmDGDPn363Ozp1VvKjNGoz+0CwKBw5kmXD9mo7IxGX3Nn1Lr6b3AszOPKus8aywrInD+Z85ODyF74GvrsOOs+G48GeI2eSqOvk/Ee8z8k8qqNXZYmnqDJv1+yMOGYddvkpt3ZM+Q5wp1r6iJSd60DXdn+bBd8nCwf0A+lFNFv1j7KtLVn5dVE7uRJ8KsbsCnv9KtJOETaj+NrzTS6GBAEOJBcCIC3nRNTm/Xlwug3mBjREVl5QCC2MItua35k3oXDNZ7LNrglbj0tzXFMqkJyllWvnVdXbzTvjbQ8K3Paye2Yaumse7v67OxOXti/jNFb5xK9bBraS2RfVhbm5MGo4GaAJVi6Iyveus9GVjkgaPl+qZOOkr9xOmBZ/h4w6c8rWsp90bc74pmyItZ6/7kuISx8qA1Kee2B8GVJJ623hwc1BSB/80xSfxiHscyyfFbuHkTw65vxfeCb2zIrsD5sZFL6NwxkzxNf8rObO656S3BMpZCBZypapeV7qbKTkei5lS8S/6HlgtmMX7wdneHavQ5kUgn3tvQHQGMw8e66MxhNVd8n3Ho+SdBLy5GU/0zKTqyn8KcxGNUllz2/n70zf/V8kA39JxLp4gWA0Wziu9id9Fw387pmPwrC9WJvI8NBUfP7XUxGCSdq6mgsCIIgCIJwlxMBwVp88MEHPPvss8yYMaPK9meffRYnJ6ebNKsrp02zLA1EImF6sx85bGMJXrjb171rck3yVRVL1a5k0bHZaCB/0w9ceDWcvA3fojPorPN0bDmUoMmrCJ8Wj9fwt7Fxrb6sc3rsTkZvnUuaypKp46G0Z2XfCXzdfjiKqwiwVNbU14kdz3Ym0MWy1O5IahEP/3W03h+cbdwDafDqRmQuPgCUxqylcNsvNY7t2KCiU+v768+i0Vd0gg50cGVWlzGcGPkyXX1CATBjZsKuhWxMO1fj+bxGf4zU3gWAoj3zMOmuLBMo3NmTPn6W7MwMdTF5WtUVned2kKoqoqQey6JHNmhmvf3S/uXWjtGV605eXMqrjquo3ec14j3rkvIrsTshn1dWVgQDPxsSxfRRzZDV0hADLAGgyhmewxs0QZ+fRvai16zbXDo/RMOpMTg0qXvd1DuBRCLhyZFvsTekMYOyzyCtFvSWgEILDkXgkcHC0pX4//YNG5PjazzflXikbRAXqyF8tzOBQb/sI7e06nPRqeVQgt/YiszJ8kcPfdIhUr4dXufXdr+ACGJGvMy0dkOxKc+gPlGQgfEOC/ILd4eGng5E+zmz6/mu1b6a+91+/2cTBEEQBEG4Ee66gODJkyd56623eOeddzhw4ECt45o2bcrUqVNv4MyuL/vyOnKYzeyKt3TIbOhhz6Ao76s6b4hbRdZQXcJjqWWFfHRsA0/uXszwf7+gw08T6XDmIF1ajKNl95do1f0lvuv3KmFfxtNg8kqcWg5BUsty3y9ObOXF/cut90cHR3NsxBSGBjW5qsdUkwgvR7Y83Qk3O0sAdemJTBYcSbvMUdUpfRsR+HRFQ5esv19Gl5NYbVzvRp70Crc0CDiXU0aH73ax8WzVpb5Rrj5sH/Q0k5taOgcbzCZGb53L8fz0aueTO3ni0uE+AEzqYkqOrqj33C+SVqrb6CCvuTbd7a6dZxDr+j2Jp23dM17vCY6mvWcQADEFGXx5YhsATpUCgiqdJUhYOdvuYkDnSuSUarl33mFrBtlHAyN5vXf4ZWuCrs+8wIXyOpZDAqMIdfIg6+9XMJV3HHbv9wIBk/646pqGt7PG/Z/nt5Cm7N31Az/F/IOiPCgvM5nxta0aYMiTZ9B/8490WzGLgznJV33tlgEuzBrT3JpduvFcLm2+3cmhlMIq4+wbdiDkrR3InCyZfqoz20iZfg+mOgayFTI5T0R0sAYB23gEXlF5BeH28PSSmFqX1Kp0RjTXMNNVEARBEARBuPXdVQHBf//9l549e5KSksLmzZvp0KEDDz/8MGp19YyK4uI7a3mJY7MB1ttddEcA+HBAZJWGB1dC/p/jK2ey/deerERar/iG949uYPa5/awszOagvTsXHDzJUzhgkMowSyT8rDcxIXa3NcPqv8xmMx8d28Drh1Zbt33aZjBLej9C4HUMYDTycuSvB1tb77+0/FS1rJ26cIjqiXu/5wEwaUpJnzMBs6nqBzGJRMJPY5pjZ2P5/sZkFNP/533c+3cspzIrlgVKJVKmtRvKveU1wUr0WgZvnE1yaUG167p0qagXWbR7Xr3nfVFZeRanBIm1bt6dIqb/c5gfm8aBYS/SLyCiXsfKpFJmdxlnbbzy0fGNnC3KrlJD8GJ9P6myItBo1pZd0VxNJjMPzj9KWpGl1uGASC/e7tPoMkdZzIyv+GPIlKbdUZ3bTfF+S6Ba7uqH1+iPr2hOdxqvke/h5upLt/xEFAbL+5Gt1kjGfe9T9tAnvNNkCHJDRXB3V9552q+azuANs9mfk3RV136yYzDbn+mMv7MlMzm5QE2PH/ew5XzVhkRK/yiCX9uIxM4VgLIT60ibeR/mOi5335WVgKk827mHb9hVzVm4tZ3IKCYmo+Zl5UazGZPp1l8uHlOQQdfV31f7GuvZhHdcQm/29ARBEARBEG4rd01AUKVS8fjjj7NixQrmzZvH3r17Wbx4McuWLaNv376UlVV8KM/JySE6OpqvvvrqJs742nKIrggIdtYfo4mPI+MrdbO8GpVzkSoHqypbEHeE3ut/IkdTPfjhYjIQZudIe88g69K1v+KPMnLzb6gMVWsUms1m3jmyjvePbrBu+6b9cN5ofmOWNQ5o7M1DbQIByC3TVVmqWR/eYz/FxrshAKrTW2vs/hvh5ciu57rQJaRi+fDm+EKaT9vGpMXHySy2BIKkEilzu423fphPVxUzaONsCv6znNcuvBM2XpYxpSfWoUk9dUVzL9NbfiYOcsU16059p4h29+PN8uei1mjgid2LMWNGUR4415U3FZEoKgKCpisMCH6y+TwbzlmyRgNcbJl3fyukl1gmfNGh3BT25qUA0MLdn54+YWQueMm633vsZ8jsnGs5+u4iVTrg++D0GvfZyxV83KEXKePfpImhDegqupevTTtDp1XfM/vc/hqPratOIe4cmdKdng0t2cIqnZEhs/ez4Wx2lXG2DVrgNnER0vLMxZLD/5L2yyOYa/mjSmXbMivqtfb0bXhV8xVufc39nGpcViu7Dd7Lo938aO5Wc0f4szb2nLW5s+ucCoIgCIIgXGt3TUAwNjaW0tJSOnbsaN02ZswYtmzZwqlTp3jggQes2728vBg2bBhLly5Fr9fXdLrbjo1HAzKUDQBooz/F1D4NLllj7EodT6+aWWk2m3n/6Hoe2LHA2qChe148Kw78xr7TK8lv2oGCCd8QN/4D9g97kVV9J2Bf3jRkTeoZBm74haLymlhms5mXD67kk5jN1vPP7HQPL5Uvmb1Rvh7exNp5eO6hVDadq3/XXqnSgYAnf+diobCsha+hy7pQbVzrQFd2PteFJY+0oaGHpQusyQw/70um0Wdb+HD9WdKK1Chlcv7t/ShNXS31CWMLsxi5+fcqTTEkEgmu3R613DEZSf5qIPrywFB9lBosWZEONnfmcuGr9XaLvkS5WJbi78pKYNbZfSjklp9zTRmCF5fp1se2C7m8v/4sYGlCsfChNng5Kut07DendlhvT27SjeK989EkHALANrQtLp0frPd87mROrUfg2HKY9b7kP8URfJ3siXl8PK8G3AepkaC1BCXMmJm0ewlLE09c1fV9nJRsmNSRsS0sgRCNwcSwOQdZHZtVZZxNcGuCpqy2Nhop3ruAjN+fvmyt0+2ZltqHUonEWpNUEG5FMzuPZteQ52r8itTfufVsBUEQBEEQrpe7JiAYFBSEwWBg7dq1Vba3bduWxYsXs2LFChYvXmzd/v3337Np0yZsbO6MJZGrT2ezSdICAAUG+srOXJfrHKsUEFQb9Ny3fT4fHdto3fZg6mG+P7GM1i0H027qcdzaj62SZdY/IJJNAybhWv6hdmdWAj3XziShJI9n9y21BjMkSPi16zieatz5ujyOS/F0VPLNiKbW+5OWxKDS1a/rMFjqOroPmAyAWacideb9Ndb+kkgkjG7uT+xrvZjaN8Rax7BUa+SDDecI+ngTfWbuZdnxXJb0eAx/e0t2146seN4+XPX57jHwZezCOwFgyE8ladoAjKX59Zr3xSXDjndo/cCrpZTJmd1lHJLy3NnXD61GZmP5nl3sRlslIFjPDMG8Mh0PLjjKxdV9nw2Ookuoe52OTS0rZFHCcQB87ZwY59+I7MVvWvf73v8tEuld82uhzqpmCZrRpJ6ssl8mlfDF0KYsGTEE+6QOkGOpJWnCzPjtf7Il/fxVXd9GJmXBA625vzyrW2c0Mer3gyw/mVllnENkN4JeWIak/LVZuP0XshZMrjUoWKzTcDgvFYBW7gG43OGdpAVBEARBEARBqHDXfPLz8fFh1KhRPPfcc+Tl5VXZ169fP+677z5+//33Ktvt7O6cD0efbj7PbkUr6/2yUxsvMfrKHUu3dPvdlnGBFsu/YmHCMQBkEgnvXtjKmxe2YWPnhM/93yBV2NZ4jk7eIWwf9DS+dpblb8fy0wlb8ikzz+wtP5eUP7vfx2ON2l+Xx1AXD7YJpF+EpRlEfJ6K/226sg/83qOnovBrDIAm4SD5G76tdaxCLuWp9v5ceKs3k7uHWRsOmM2w5UIuExYep/PXhxig7I1teW2/r05t51heRfMTqdKeBpNXofCPAkCXfprUn+6vV8fkyjUE69tp+XaXUazhf5vOMXNPIvuSCmoNBHf2CWFShCUbuUSvpcjV0v35YoagpFIH7PoGBD/eeM5aN3BQY29e7lm3um96k5FJe5ZgKG8g8VxUF8q2/Yyh0NKExrnDvdhHdKnXXO4WCq8QzJWKI2QvfK3GcaOb+3PwxR6EGZpCviWjT28yMmLz7ySU5NV4TF3JZVL+uL8Vj7azBBv1RjNj5h5ib2LVgL5jdH8Cn10E5eUX8jd8R9Ge+TWe86/4o9b6gWK5sCAIgiAIgiDcXe6agCBYsv40Gg2DBg2ioKBq04W+ffuSm5tby5G3v9NZpRyWV3Tf1aafvi7XOaM/T5fV39Nr3U+cL7Z8P51tbPk3ugfjUy3NTFw63of8Mp1Vm7v7s2vws4Q6Vs18kkuk/N3zAe5v2LqWI2+M/zb9+Gp7PEn59V+yJFXYWT68l1Od3XGJ0Rbu9gq+HtGUuDf78OngxjT1reh4WqDW89vOArRpDazb1qedrXK8zNGd4FfWI3ezZBuVnVhfa8CgJhd/JhdKclmSGFPn4+4E9847zDtrz/LMPyfoNH0XTm+tpdmX23howRG+2R7HvycyeGvNabrO2MXslTLQl2dROueA1IB3+bLe/I0zrOe08Qyu1xxiMiqycH8b37JOdRx1RgPjts5jTaolM9hZrmRSZKcqzzfv0f+r1zzuPhXf57LTWzD/p77pRU18ndj3Qjfay9tBkaX7b6lBy4Pb/8ZourourjKphDnjWvBkR8vr22Ayc9+fRyhUVy1t4dR6BAFPzrXeL9j8Q7Vz7ciM4/n9y6z3hzW49t3ZhduL0WyusQNxbY1IBEEQBEEQhNvbXRUQ9PPzY926dSQmJtK5c2eOHTsGgMlkYsWKFfTv3//mTvA60hlNqKT2lMoswSN9fv1rx9XEaDJhLK9FqLaTkeNykj3Zidb9vf3COTz8JfpX6V5Zt9qFDZ09OTT8JT5tM5iOXsEE2Lswv8f9jAlpcU3mfrXCPBx4paclq0ZrMPHG6isLstoGRSO1dwVAlx136cGVBLnZ8UafRpx4pQdHp3TnqU7B1gCludjDOu5AbvWftY1HEP5P/Ga9n/XXZAwldQuI/6/1IOvtF/Yvo1BbvUv3nehgciE746tmY5nMlkY6fx5OY8qKWO75/RCfbr7A7sQCDHoZFFpqOiI14xdUzOdDolAnHKZw568AyBw9cO/zzBXPydPh8su2tUYDo7fOZVmyZZmrg1zBvPZj8LR1QJtmaSwjc/JE4SMyxOrKrNeiSak9GO7lqGTTpM40NbSx1hTck5PAtJPbr/raUqmEmaOb0zvc8keVpAI1Tyw6Xi1b16XzA9iGtgNAHbcPdeIR674inZqxW+dZO7lPbtqdHiJD8I4XpzxGjN2OGrv0Jtk71dpYpLmfE9F+otGQIAiCIAjCneauCggCtGjRgn379uHu7k6bNm3o0qULTZs2paysjLfffvtmT++60Zd3Ny2wsWSsGPJTr+g8GoOe4/np/BV/lFcPriR0ySdolJalaZWX1LX1DGRe9/vYNGAS4c6e1kL3ACZ93QNI7kp73mjem71Dnyf13ncZF9ryiuZ9vbzWKxw/Z0vW19/H0qst36srRXn3X31OAuZ6ZhFJJBJaBrgwc0xzUt/rx2dDolCa7MFgWZa6KzOxxuMcm/XDpcvDABhLcslaMKVO1xscFMW48qBsprqENw+vqdd8b1fTd8Vbbz/dOZinOwfTMdjNGoT9r2g/J8aHVizTj2ykolOIG5nzX7Ss8wa87vkImYNbjcfXRlLpdXa5Jdtqg56Rm39jVYolWO0oV7Ku/5N08WyASVOKPjcRAGVA00ucRaiJ+sK+S+53spWz5vHOuOdHc7EPyVuH13IiP+Oqry2TSph3fyu8HC0B4X9iMpiyNp6FR9OIzSzBUL403b3vs9ZjKmcJfhazlezyZjZDg6L4su3Qq56TcOsrkxajkhbXuC/KoKKVRFdjB+Jdz3dl5pjmN3i2giAIgiAIwvUmv/yQO09YWBi7d+9m+/btHDlyhIiICAYNGoT0Di6mry8PMhUqvQnSxGPSlGBUFSGzd7nkcdsz49iQdo7YwixOFWYSV5JnrTl10cWFZhKzGVleEMceH0czN78qY6Q2FQFBs+7OyShzVMr536DGTFhoadQwefkp9r7QtU7LOCtTeDdEk3QEs0GHoSANG4+gK5qPu72C13uHYzabefNUDDjlk60tIbmkkAZOrtXG+9z3FaUxazCW5FK0Zx4unR/EMfrymbLfdhjB+vSzFOk0/HR2Lw81bENnn5ArmvPtILNYw8Jjllp7Pk6WpjJKuSUQbjCaOJdTxpG0IhLzVTTzdaJbmAce5dl7scsOElOQwbbMOGJ3z0NyfjcAysBmuPWcWO+5VH5qXSocqDLoGLH5NzaVN7RwtrFlXf8n6OQdQl5eXpWyASIgWH/q+P3Ac5cc08DNnvUP9afTwiwMHkmYMDFgze8k3vcqCtnV/fr1d7Fl7viWDJ59AIB5x7KYd8zSeVgpl9LEx5GW3pG8oHRDoS2gaO8CvO/9ggxkfBtrWSpuJ7Php05jkN3Bv/uEquxNzuwaUv15mzC1602YjSAIgiAIgnAz3dWfAnr06MHkyZMZMmTIHR0MNJrMFxOSKFL6WLfrL5Ml+OWJrfRcO5NPYjazLPkk54tzqwUDbaQy5OXZKHYaI8aMMKJcfKudq0qGoK7+tfZuZY+0DaJVgGU51f7kQv4+ml7vc9h4VyzX0+XEX2Jk3bzcsyHesoplw1N3H65xnNzJE9/7v7Xez5j7VJ2aXPjZO/NZm8HW+xP3LEZnrH+n5dvFT3uTrFm2T3cKtgYDwdLsoYmvEw+2CeSdfhGMjPazBgMBHqxU7/K3HX9ab/vc/22V5iJ1VTnUXFuCYJley9CNc6zBQFeFHRsHTKSTd4h1zMXlwiACgldCHXfpDMGL2ga5sqDfKFA7ApChz2P8+qXXZA6Donz4bEgUMmnVP0BoDSaOphXz29Ec5kp7A2DWayjc8SvvHFmLpvy1OqVpdwIcLv1HIeHO4aVJI1AVR8LUrtW+tJdYAi8IgiAIgiDcme7cKJhgpTdWLEEtUnpbbxsuUUdwQdwRXju0uso2F4Utnb1DeCKiA9+0H876/k+SOf59lLqqS1zVemO180kVd2aGIFhqen09vCKg8tLyk8Tl1q9zrMK7osZifeoI1sZGJuWNThWBqLmnYkkrqvn77tzpfhyiBwCWJcs5/35Qp2tMjOxI5/IA06nCLD6J2XxVc75VaQ1GftqbBICNTMKkTvVrAnJfWMWy4e12luXBTq1H4ti0zxXNp2qGYPWIYI6mlL6rZ7A10/I8clPYsXnAJNp7NagyTpN60npbBATrw/ID0GVdwFBat87BY1sE8kr4EDBZjv038wAPbFmExqC/zJGX93rvcNLe68fi8U34cmgTHm4bSEt/ZxQyy6/3hbaDMJb/qt+9ez7z4iy1BL1sHXgtutdVX1+4fShNGhQmTc37gppjGxh9g2ckCIIgCIIg3Ex35ZLhu83FzCaAUrtLZwimlhXy6sFV/J1wzLrtg5b9eSKiA/72znVaCqvSGXFU/uepJZVZIhlmM6Y7LCAI0DPck9HN/fgnJoPsUh0Df9nPnue74FXeVfZyFJUzBDPPX5M5PdSkCVOOl5/TtoCvt8fz1fDqgR+JRILfIz8R91ZTzDoVeeu/waXLw9gGXfrDoVQiZVbn0bRa/g0Gs4mPjm1idHBzot39Lnnc7WbFqSyySrQA3NvSH19n23odH+jgir+tI+maUs45eCKRK/AZP+2K51O5hqDRVDUgqDHo6b7kE87oLR1w3c0m1rToRWvPwCrjTJoSSo9XBPxFQPDKlB5fi2uXB+s09ot+bdn9Vxx7tYdAAguSDuBxSMH0jiOveh4+Tkp6hbni4VGRFaw3mjiRUcyIXw+yrawdfXT7meUcaA0if9CyP86Kmp/LF2tT1rf0gXDr00ltCX1n182exg0Xk1FC1xk1P+5oP2dRI1EQBEEQhLuSyBC8CyjkFR/qKgcHK6caaY0GPo3ZTOOlX1QJBj4f1ZX3WvYjwMGlTh8OFTIpLnbV48yqszus6xttPOuXYXW7mDOuhXXp8IXcMob/erDGbMmaKCtlZqjObLsm8/G0dSDKuXz5tn0xsUWZtY5VeIXgNeoDyx2TkYy5T9epuUkzNz/eamHJdDNjZn78kcsccfvZfL6i+/Lj7RtcYmTNThdkkqMpAcDFoMW9/4tX1dE30LUiiHMys6TKvte3/mYNBrro1fx66A+cvuxD4me9KTm2CrPJhNmgp2juBHQZZwCwDW2L3Mnziudzt6kcgs1e8madltiDJbi2dexYbLIagcnyq/fX8wco1tWcsXW1bGRSWge6svbJDsxzGoseGeccLD9nB4OW4ceXY9KWYdJpUCceoXDHb2TOf4nEz3pz7llPzj7jRvHhZddlboJwI0X7OdPcz6nGfTEZJZzIqLnRiiAIgiAIwp1OZAjeBZRyGbZyKRqDCbmqIrghd/HBZDaxKuU0Lx9YyYWSin0+dk580XYIDzVsU68skXZBLlXqq11UtO9v623n9uOu8JHc2lzsbFj9RAc6Tt9FcoGafUkFPLTgKIseaoNUeunvodzZC9uQNmgSD6OOP4CxNB+Zo/tVz2lMQFs+Ll4FQJL0HFD7MlWP/i9RtGsu2rRTqM/vpnDnb7j1ePyy15jcpDufxmxBbzKyODGGT9sMvqMyi3YlWDpHK2RSOgbXvSOwSasif/cf3H/mIPrypcIjc87h8eA/VzWfrqHu/HrAstx/R1w+7RtYzr0l/ggzUs6CRIKdUc8fJ5cTXmZZ0qo6vRXV6a0o/CKx8QxFd3YrADInLwKf/rvmCwm1kODUZhQlh//FkJ9K4v+64f/Eb9g2aHHZI5U2MiJkkZzKV4FnGmUGHfPjj/B0487XbbbN/Jzp2G0Aj201kK601Df11xRTvOt7Srf/jElTCqaa/3CR+sM4GkxeVadGQ4Jwq7pU9l9tWYOCIAiCIAh3A5EheJdwtbMBQKm1BDfKZDb8UlxE1NIvGbH5N2swUC6R8nLTHpy753UeDm9b78BOtzCPatvMBh0lB5cAILVzxjF64NU8lFuan7Mta57ogIutJdb+T0wGr66KrdOxjuV1/DCbKD216ZrMp7VTIzBYfvbndAlkqmrPhJDIbfB9ZKb1fvbC1zAU51z2Gq5KO/r5NwIgviSPo3lpVznrW0demY5T5Vl47Ru4YmtTPdj9X/rCDLKXvMP5KQ34fMscjpUHA8PLcnm99SDkzl5XNafulV5jOxMsAb9irYpHtvyOufz1+qYqi6FfnsP/8V9RBjazjtdlnKXsxDoAJAp7GkxZfVXZincrn/u/QWpryTjSJB0l/oO2ZC99H7NBd9lj/ZyUkO9vvf/Tmb3WJbrXy5QeYRy3i0Qtt7wX+OgtjZ1MqqIag4Eyp/LnqFFPyvRRqM7vua7zEwRBEARBEAThxhMBwbvExYCgmhI+a9iT3p0m8XLcUc5VCvj0848gZuTLTGs/rNbaUpfTLax6VlvpqU0YyyyBSKc29yC9wnPfLpr6OvHvY+2wkVmCM19vj2fGzoTLHudQKVB6MWhztQrLTNbggxETM8/uvfQcIrvh2n2CZXxZPlkLX6vTdcaGVGRHLU68c7pV7i7PDgRLZt6laNNPk/bLo5yfEkzuyv9x3mRmemgXAGRmM3PaDiZg2JtXPacwD3v8y+sY7ozPx2Qy8+ySj0iVWTobdy7J5PVHvkOqtMe1+2OETY2hwSvrcWhWKctLIiXw2YXYhbW76vncjRSewYS8sxvb4PLGPUYDucs/Iv79NqjjD17yWF9nJejsoczS3TemIIP9OcnXdb4h7vYMjna23pcFdMep3RhkLj7YhrXHtceT+D44g+C3dhA5s5CI6Zk4d7ofALNORfLXg9EkHbuucxQEQRAEQRAE4cYSS4ZvM0aTifPFucilUpxslDjKFdjLFVUy+cxmM2UGHdmaUrLVpWRrStE6pYJtKp84NbFmEV00MCCSF5t0Y0BA5BUt9TSDtc1B55DqQZPiSsuFXTqOr/f5b0e9wj359d6WPLTgKAAvLj9JAzc7RjTzrfUY+4Ydkdo6WRo+nFiP2Wy+6qW32aVaS0DQMxmkZmae2cOb0b2xLc8Uqon3uM8pObIcY2keRbt+x7Xbozg07nHJ64xo0BQbqax82fBxPmkz6I5YNryrUkCwpmA3gKEwk5xlH1CwfbY128qIhHcbD0QntbzFvt6iL93bDLomc5JIJHQLc2fhsXQK1HpmrpvDnzoDAE4GLb/1fhSFi0+V8Y7R/XGM7o8m9SQlh5Zi8G2OU8uh12Q+dyvboGhC39tH3tpp5Cz7ALNBhzb1JAkfdcRj8Kt4jXy/Snf1i/ycyv8gku8PDkUAzDq7l47e17e26uDmrqw6bLl9IkuB/3OLkF2ilEHAE79jUpdQemwlJlURSV/2J+SdXSh9I67rPAVBEARBEARBuDFEQPA2ojUaGL7pVzakn6uyXYIERxsFjnIlcqmUXE0ZaqO+6sF2li9zeejOzqhnQtMePN+kK5Eu3lc8p/82zbiYiXiRSaem5Mi/AMicPHGI6n3F17rdPNgmkMR8Fe+uO4vZDPf9eZhtz3S21nz7L4ncBoemfS21yQrT0aaevGyn38vJLtWCQQFF3uCWRY6mjAXxR5kQ0b7WY+ROnvjc+yXpcyyZghlzn6bhx8eQyBW1HuOmtKevXyPWpp0hriSPY/nptPIIuKq53wp2lgcEJZLqwW6zyUTe6s/JWfk/zJUaS8icvFjc5UmOaSydiZu4+vBey37XdF7dwzxYeCwdH9L5IOU4KOwB+NzLj4hmfWs9zjawGbaBzcjLy7um87lbSeQ2eA57E6c2I0mfPQF13D4wW54XJYeW4jnsLVw6PYCkUgDe17m883ixJ85yO4oNahYmHOfr9sNxU9pft7na2Fb8TsgvlrD0RAZjW/jXOl4ityHw2YUkfzUY1ZltGEtySPq8L6Hv7MbGI+i6zVMQBEEQBEEQhBtDLBm+jfx6/kC1YCBYuruW6LVkqItJKSusHgysxE9dwmsXtrLz9Cq+73TPVQUDAQ4mF1pv15RrUnZyo6VoPeDcbmyVD8Z3g7f7NrJ2plXrTYz74zClWkOt4611BIGCbT9f9fXj8iy1wsgLrJjTkbWklBZe8jiXro9gH9ENAF36aYr2/XXZa40NrSjcPj12Z/0ne4vJK9NxOLUQgGhf52rB7txVn5K95C1rMFDq4IbPfV8RMi2Br42WV4NUIuH3rveilF3bv710L89WDHXfR255MHCgQcWk4W9c0+sIdaP0jyLknV343Pc1kvKsQF3WedJnP8b5VxuSt2E6Jq3ltejrVB4QNEtp79QYALVRz9KkE9d1jlnqSh2pfS/w8qFlnCzIuOQxUoUdQS+twDbUsrTckJ9C9tJ3r+c0BUEQBEEQBEG4QURA8DZS+QNjb79wxoY0Z2BAJF19Qmnh7k9DJw+CHFxp7RHAwIBIHm7Yhlea9eCLtkMIVbeC+BZ8c3gLj6QewS4/CZNOfdVzOlApIFgT1YWKmnWOLYZc9fVuNxKJhJljoukd7glAUoGad9aeqXW8U+uRSG0dASjY/AOqc7uv+NpZJVpWn84CwE/hwbCgJgBkqksYtvlXVJdogCCRSvEZP816v+Twsste757gaNzLM5x+v3CI7ZlxVzz3W8HvB1PQGy3NHoY0qRo4Lzu9lZyl71nuSGW4D3yZRl/G4TFwCklaFcV6DQBjgpvTzqvBNZ9bsJs9SEwc83IFLBm/34VFI5WKt/SbRSKV4TFwMg2nxlSp12jITyFr/oucfzmYnOVTQVVg3dfWJdx6+8h1bsbT3ScMuaT8+SEzkSKNJ3rZVwzc8As7MuNqbWwis3OiwStrkdpZahCqTm+9rvMUrs7Te/6h6+rva/xKtHe62dMTBEEQBEEQbiHi0+NtokinZluGJcAS5eLN5oFPsajXw6zt/yQ7Bz/LsRFTuDDmTZLHvcPh4ZNZ2/9J5na/jy/bDePlpj3JTnEDlSvpTlGWE5qMaJKOXvW8DpVnUNVGnXDAetsurPZlqncyG5mUX+9tgYPC0qF2+q4E9iUV1DhW7uKD97jPLXfMZtJ/fRyTTnNF1/31QLI1oDWxYzBzu42ncXlG6PH8dCbvX3HJ423D2iF3t2QWlp7ccNl5uCjs+LJtRV26p/b8g9ZYezbkrcxkMjNzTyJgWS48sWNFfTdDYSapM+8DswkA77Gf4nvfNGQOlqXg5ys16mnmVnvNyKshkwJOuWjKux4PzD6L8vC/1+VaQv0ofMIJfnU9oR8cwqndGMsTCDCW5JKz9F2a/d6JF8rmITcbaFKp1uPJgszrOq+uPqGE5vWA3EAwVmSsrk87S4+1M+m65gdWJp/CVP68rkzu6IFdw44A6POS0RdeOrNQuHlOFGQQU0vmZ4iqhGB16Q2ekSAIgiAIgnCrEgHB28S61LMYyj+oXcz0qqu4vDLKdJZaf2rfltbt6oRLd8Osi4MphbXuM5tMaMo7btp4hSJ39rrq692ugt3t+XSwJRhrNsMTi46jM1T/4A3g1usp7CO7A6DLOEvOsg/rfT2jycxPe5MAkEklPNmxAW5Ke1b2nYCTjWXJ4s/n9rEo4Vit55BIJDi1HGaZs05F2ektl73uY43a0d0nDIAzRdl8fuLyx9yKNp7LsS63HhrlQ4i7JfPRbDKSOvM+jEWWzEvHlsPwGPhylWPPFedabzdy9rwu85NJJeBe8aF/TEYMZae3YCjJvcRRwo1kF9qGoOcW0/DT07h2ewzKl43L9WVMUi9mevEn+CkkhDl5AJZATm1ZetfC5vO5nE83QWZDehqGMKvzGCIqvSfvyU5k+ObfaLHsa+bHHcFgqlof1q5hB+ttddz+6zZP4eo1d/Nj15Dnqn19dvYgTyefvtnTEwRBEARBEG4RIiB4m1iRcsp6e3iDpvU6duO5iiCBe0Qn6+2Lwborla/SEX+xRl0NdJlnMWksdavswjrUOu5u8UyXEDoFW7LITmWW8Onm8zWOk0il+D8+x1qLLG/tl6jjDtQ4tjZrz2STXGBZEj6iqQ8BLpZzhTt78nPnMdZxT+5eQkJJ7Q0mnFoNt94uPXrpjEKwBBFndR6DQmrJXPvf8c1cKL39Glj8WJ4dCJaf20W5qz5DdWYbADaewQQ8+TuS/yzTrZwhGHGdguDJZQXgWAiAr9ZAi+IMMBnrtLRbuLGUfpH4P/Erjb6Mx73/ixikloB8D/0hfBaOo1l5QLBApyZdVXzd5vHdzgTr7SndGjExsiOxo15lca+HaF2pAdDJwkwe3LGAyKVfcKzSMuaLGYIgAoI326WWBdeWHSgIgiAIgiAI/yUCgrcBvcnImlRL3TlPpQMdvYIvc0RV685kW29369gJidIBuPoMwUOXyA4EUMeL5cKVyaQSZo9rgUJmedn9b/N5TmWW1DhW4ROO9z0fW+6YjKR8P7pey/R+3J1ovf1055Aq+8aHteLxRpafR7Few/htf6L/TzbQRfaNe1qfLyVHV9Ypg6mxqzdvNrd0k9aZjLwSs/66Zj5dS/uSi1h2IoNVsZYMwDAPe/pHWIJ6ZpOJgs0/WAbKbAh8ZhEyR/dq5zhXVClD0OX6ZAguSTxuve2nD7I29Ck+uPi6XE+4ejYeQfg+8C2LO/xCocRSy02WfICgk2utY05cp2DO+ZxSaz3Rhh72DImyLFWWSaWMCWnBoWEvsb7/k/TybWg9Jr4kj+GbfyOnvClU5fdwddy+6zJPoW4utSy4uZsf0W5+N3hGgiAIgiAIwu1IBARvA7uzEigsbwAyJCgKWT0aB2gNRrZcsAQoglxtaeLngl1wawB0mecwlhVe8bwOpRRdcr8ICFbXxNeJt/s2AkBvNPPEouMYTTUHy9wHvIR9VC8ADPmppHw7AnMdGsHE55Wx7qwlCNzI08Ha0KSy7zqMIKq8nuCB3BTeOby22hgAqcLW2vnYUJiOJvHIZa8P8EZ0b2t23K7cJO7dNo/9OUm3fGBw4vLzjPr9EBd/JE93CkEqtYTbNImHMZQHZZ1aj8CuYc3P6YsZgr52TjjZ2F6XeVbuNi4jGoVvBABlsZsx3IYZmXeT03ZRPOzyKZlSS2ZgaEbFEs7rFRCcsSuRiy+957uGWp/TF0kkEvoHRLJl0NPsHfI87T2DAEgpK+TerfMwmIzInTxR+FiaoKgTDmKu5Y8Iwo1R27LgXUOeY2bn0Td7eoIgCIIgCMJtQAQEbwNH89Ottysv7aqLU5kl1vqBvcM9kUgk2FYKzuWt//qK5xWTcenlbdq0WOttZWCzK77OneaN3uE087VkCO1LKmBHfM0BHIlURuBzi60fwjUJByn+59XLBtVWxWZZP/xP7Bhc7cM/gIONkoU9H0JZXtds2qntnC/KqTYOsNYRBCg7ueHSD66crdyGnyp9KF2cGEPHVTNo9M9nvHdkHWcKsy9x9K3B2VbOY+2DrPcrL5N0KA/U/tf+nCSSy4Ps12u5sOU6yZYbWjsUZjtsPEMs901G1Od2XbfrClevVGsgTt6AB10+R+bdiEZlFa+7fRd/rtfQPzHp/LDbslzYSVn1OV2Tjt7BrOr3OEEOrgBszYzj/aOW1/3F0g9mbRm6zHO1nUIQBEEQBEEQhNuACAjeBlq5+1tvf396d63LO2vi71yRoZRcaMkuc+3yEMhsAMhdMZXSmHVXNC+dseamGBdZgxSANu1U7QPvMgq51JolCLAnMb/WsXJHD4JeWonUzhkAzcG/Kdjy0yXPrzNUBAwjvR1qHRft7sfHrSzZfyazmS9ObqtxnH1EN+ttTUrMJa9dWS+/cL5tPwIHmcK6La4kj4+PbyLq3y9os+Ibvju185bqRPxMB38+GhjJ/wY1ZseznfFwqJi7wrfiZ6Y+v6fasVqjgQm7Flnv3xva4rrN015a/rqWGXhQt8YaqJXaOWMb2u66XVe4es39LK/lDJk3R4cvJsLWAR+tpXTAmpRYiq+wq3hNNpzN5r4/j1gzXt/oHY6zrc1lj/OydWRp70estUA/idnM+rSzVd7TDcW3flBfEARBEARBEITaiYDgbaCnXzj9/S1LAs8X5zLrzN46H+vrbEuklyUotDexAK3BiG2DFvje95VlgNlM2k8PoMtNqve8ZJLqmWeVOTbrZ71ddnJjvc9/J7vYXATgQHLhJccq/RsTMPEP6/3M+S+iulD7c8BGVvFz0RsvnU34dOPOeCgtHXTnXjhEag1LyG28Qq0NTrT1CAgCvNi0G7EDnmdBjwcYEhiFXFLxlnMkL42XDixnyMY5lOm19Trv9fJUe3/e7RfBW30b0cLfpco+hyZ9kDlbllkXH/oHQ3mnYQCz2czrh1YTW2jZ1tk7hEmRnbhuNOWBXrmeyPMzrZsDJv2JjZt/LQcJt4IxLSrqu/11XovXgJcYlH0WAI3JyL9JJ67JdY6mFnHP74es7wHPdA7hzT7hdT6+rWcQX7evaCr04PYFZNm5Wu8bxdJ0QRAEQRAEQbitiYDgbeLLdkORlLcO+PDYRorqUEvuou4NLbWqNAaTte6fW9/ncG4/DgBjWT6p34/FVM+gjKyGpaiVOTTpY71dGrupXue+0zVws8PHydJtdH9y4WWXATu1HoHnsLcsd4x6UmeMwVCYWeNYhbziZa01XDqL09FGyQtNugKW5jVfn9pRbYxEKsU2yJLtpk2PpeTI5bsNV+YgV3BfWCtW9XucjPHv82One+jiHWLdvznjPAM2/FKv5/TNIJHJce3+OABmvYa8dZagutZo4OGdf/Fd7E4AlDI5v3YdV69an/VxMqOYvLyKzMWz9pbGJp7D38Gp1bDaDhNuEe2CXAl2swTY15/NQdbhYYYWVPxBZv6Fq2v2BJBSoGbonAPWchH3twpgxqhmSC7zR5z/eqZxZ8aGNAcgV1vGxOJiDOXnEAFBQRAEQRAEQbi9iYDgbaK5uz+PNmoLWD6YTT1e9wBb9zAP6+3tcZYPcRKJBL8Js1H4RQKW+nSF22fXa06XyxCUu/igDIwGLF0pjeqaO+rejSQSCe2DXAHIKtGSXHD5YJjXPR+hiCxvMlKYTuqP92I26KuNc1DIrLdV+ssvL38uqiuOcktwctbZveRpyqqNcR8w2Xo74/dJGEtrX+Z8KZ62DjzduDO7hjzHgaEvWLMTd2cn0nvdT+TWcO1biceAyUgUljnnb/qB9PJ5/xlnabYilUj4oeMoIssbtlwPP+xORKq2t94/7eSNQ/QAvEZ9cN2uKVw7EomEMc0tWYJag4k1CRo6txlBWJnlvXlzZjxpZZdu2HQpxRo9Q+bsJ73YsvS4V7gHv41vWWMt0brM9ZcuY2noZPkdsk+jYkZIFwBrgx1BEARBEARBEG5PIiB4G/m41UDsymv/TTu5nSWJx+t0XOeQiuWplRuByOycCHz6b+v94v0L6zWfy2UIAjg07Wu5YTSgOls9++xu1iHY1Xr7QErhZcdLpDJcHpyFjWcwAKqzO8ha9Hq1cY4KufV2qfby9fnclfY81bij5ZwGPdNPV29K4dx+LE5tLU1CDEWZZP75wmXPezntvBqwfdAz+NpZGqwcyUuj59ofyVBdulnNzSR39sK9zzMAnLOxo+Oa79mTnQiAo1zJij6P8XhEh+t2/UK1nj8OpfBS3lLrtrPuoQQ+tQCJVHaJI4VbyZgWFcu6l8Rk4NH/BYZmW7oNm4DPYjZf0Xn1RhNj5x7mRIbljy9RPo7880jbKlnD9eWisGNxr4et9QRnB3f4P3tnHWZV2fXh+/R0d5NDDd0pISAlChioIIKKrRivXZ/xGuhrgSiKgYoCBt0g3V0zDMww3V0n9/fHnjlnhhmmZ6jnvq5zsePZz14n9h7O76y1fmz3aEFJQuOUNgsEAoFAIBAIBIIrgxAEryECHV35sOdY6/q07Us4kplY43Gh7g7oSr8QRqYVVNhnF9oVu5CuABSd24mxDlkfdRIEgcJTomy4PH1CbELtvovZtTpG6ehB0BN/otDIGX1Z6z8l78CyCmPKZwgWGGpn2PFMx8HWL/xzT/7LmvgzFfYrFAr8p89D5ewFQO6eX8g79Het5q6Oju5+7BjzGCGljqanclIZvGZelb0MrxY8b3mOwx4tuKfb3cSXVnqHOrmze+zjjA3u0KTnXrQ/jum5v/BA3lpcjHIGWJRvOConjyY9r6Bx6RPiRrCbbAyz9kwaBtcQZnkF4WSS2zZ8E7mnXtfAM/+cYkOU7Frs46Rlzaw+uDtoaziqZrp5BvK/Prda119sfwv/ZiQ0eF6BoDE5q7Kj59cPVfmYvuipKx2eQCAQCAQCwVWHEASvMR5rP4CHw+VsrmKzkZk7/8Bsqb5PnEqpoG2psciJlHzOpFYs3XXuPlFekCSKz+2qdSz2mpo/Po7hg6G0tLg4puG9sa4nugXaTCtOpxZUM7Ii9mHd8Z9mM5JIWfwkFr2t1La8M+7iQ4nkFlcuK76UAAdXHizNbCs0GRi76TumbP2pQumi2sUH/2nzrOvJP86ud+lweVq7eLFjzGO0LhUbo/MzGL5uASlXaaagwtmbtzqNp7C0zLq3gzP7xz1JhId/DUc2nNNHdvNI0e8ogPYFsstrbEkBm5PONfm5BY2H2SLhVXqdlpgsHEvKo9WYZ5mWcAgAgyQx70xlJ+vqyNeb+XqP3IvQXqNk1cw+hHk41HBU7Zkd3o87Q+V+grkae+4LHcD4jd9xJie1hiMFgqano86eduaqHbrPquw4pb+6e9QKBAKBQCAQXAmEIHiNoVAo+KLvbfT0CgLgSFYiX0fW7Dp8Xw95vNkiMWfFqQr76ptddFunmgUQhdYBSg0zFCp1DaNvLEpMtv5+LnZ1e23cBs+wmsKYcpLJXPOxdV/3QFd6BMli49m0Au755TBmS/WmJQAf9hrHxJBO1vVlscdp9+eHfHZqByaLHKtL7ym49JoCgDk3lZRfGifrIsTJne1jHqV9ae+9qLx0hq9fQJa+qFHmb0wWR+0jWimX7vfITWTziJn4lJY9NyWSxcKUmLmokH8AmOzbzrrvkT3LKamin6Tg6uTdTec4kigL3q29HOkR5IpD637McnBEXXqtLT67E4tU/Y895UkrNFiv8zu7BtIrxK3R437rwjZ65cRb11clnCHi77k8umc5aaJHrOAK8uOMzzg4+5sqH+3MJUj6ImLeGVjp8cLZR5l68eOaTyAQCAQCgUBwHSIEwWsQjVLF/H6TrK7DrxxeS2oNX8aeHNSCVp5ytsi6s+msOWPL6rAYbb+qKzR2tY5jRFsvhrb2rHaMZLAJOkpt42WrXA+k5Nlcncsch+uCzx0foFDLWUYZaz7EmJ0EgFKp4M/7e+LjJO9bfSaN19edrXE+B7WWP4dNZ+nQ+whwcAGgwKTn6f3/0Hvl5+xPjwPAb9qXttLh3YvJP7KyzrFXhb+DC5tGP2zNFDydk8oTe/9qlLkbC6PFzJsHbC7Lbzg54eQZ1Cznzt31E0E5ct/QSFUorTs9yDD/1gCcy8vgw5NbmyUOQcPYcSGTtzdGAaBWKvjt3u7YaeRy/bYTXuGmzAsAxBsNbEs+X+t5M4tsgnDZtd+YpC19CfOORSw6+gdzz64nzM4JALNkYf7ZPbRe/l/+e3wLxUKYFlxlKHWOKHRV//8jsOg8QcUXmjkigUAgEAgEgqsDIQheo/T0CraWDucaSnjhwKpqx+vUKj4eb+tvNuefUxjNcvaJZLQJUwp17YUphULBf8e2t65LQMklrrblS1kVOsdaz30jkFpQThB0qrsgqPUOw2OknKEnGYpI//N1674QdweWT++JRiWLxu9tjub3IzX3m1QoFEwO68KZ217gqQ6DUJaWex/JSqTvqi9468gG1C4++N33lfWY5B8exlxYux6INRHg4MqW0bPxtpM/K79eOMKKuFM1HNV8LIraT2yp4DEk4zw3j26evlTmwmxSf3/Buv6O02wiM/XM63e7tffje8e3EJ2X0SzxCOpHTrGRe345TFnC7vtj2tOz1G0cwKHdEKaobNm83+3/u9ZzZxTZ+oV6O9b9flIdmes+JXP1B4BsbvTg3e9z9o5X+bjXOFy18o9I+UY9Lx1ag+PPL+P88yv4/vYmLZe+R8RfH9Nn5WcMWzufUeu/sT4ETcMjy44z8IudVT4KDTW7zl+PaH1aYRfcmRav7qz0SHRodaXDEwgEAoFAILhiCEHwGubdHrfgVSqy/XT+EDtSqv+V+9ZOfgxrLWdfRaYX8tWuWACkemYIAvQOcae8tci83bEV9lvKZwgKQbAC5TME/eqRIQjgNe5lVE5ylmbOju8piTtu3TewpSdf3hZhXZ/x+1GOJuZWmqMqXLR2/K/Prewf95S1PF1C4s2jG/jh3IFS1+HbAblkOeXXZ+oVf1UEO7nxVd/breuzdy8n+yooHZYkiU+PrLWuP6+yYBfUqZojGo+05a9hzpfNIv7RDeWwpiORaQWEu/rwn4ihAOjNJh7b8yeSVHN5uODK8L/tF4jPke+3I9t6M2dIywr7FQoFk29+DDej3O/s78wkCgz6SvNciqWkoEKGoHcjZgjm7FpM6m9zrOsBDyzEues4dCo1z3a6ifOTXuLJ9gNRK+T/TkhIFJj0pJUUEFOQxcmcFPZnxLM15TwbkqKsD0HTcCI5j+PJVVcMOGpVOGiEG/mlBBadr7KcOPmHR650aAKBQCAQCARNihAEr2E8dA582MvmOvzonj8xWi6fAaBQKPjfxI6UmQO/tSGKjAI9ksn2hVNZhwzBqnh307kKJhblMwRFyXBFKmQI1lMQVDm64T3xDXlFkkhd8lwFQeihfqE80j8UgGKjhVsXHSC9oGaBoYweXkHsHftkBXfr2XuWczAjHv9p81A5yv0nc3f+SP7R1fV6DlUxpUUXJoXKYmZycR5z9q+o4Yim50R2MmdLZGGyb/ZFhtz8WLOctzj2MNlbZBMZpb0LnzrdD8j9IQFe6jycls6yKLwhKYo/Yo41S1yCulFiNFt/MNGqlHx/VxeUVTi1u0eMZEKJnHFbpFTx265fLzunMTuJ+C8mc/ZhZ3qsvIPORrk1QGMJgvnH1pL03Qzrus8dH+A26P4KYzztHPms70RO3/Y8D7TpzUDfFnTzCKStizdBDq64a+2tWayCxsGQdp6S+OOX7Ym3OPc//Jz7YqVHW1MsrbzED3PlSbBvWWWWoD7+OCUJJ65ARAKBQCAQCATNhxAEr3Gmt+5Jf58wAE7mpDD/bPXOlBH+LjzcTxaIcoqNvL4+soIgWNcMwUvJKjLy8TZb36sKgqDIEKxAan7DBUEA96Gz0fq2AaDw1EYKT26osP+ziZ0Y3FIW7uKyi7njp0NYamEyUoZKqeT5iKHM6TgYkDPRbt/yI/l2zvjd96Xt+fw2p1Gz077qdzsepX2ffog+yLqEmvsgNiW/RO2zLk8ozsKx083Nct6UxU9CqbmE9+3/h4tXICALgpIkYa/W8FXf26zjn97/DwXG2ou+gubhtyOJpBcYALi7WwCBrvZVjlMoFDzQc4J1/Yezu6q8roqidnL+5Q7kH1wOgGf2KX7LfYEHi/5ocBaYJEnk7v6FhC8ng1kuRfYYPQfPMc9f9pg2rt58N/AOdox5jMO3PkPkpP8Qf+drZN3zf+inf4Bx+geUTPuv9SGoPxZ9IVI9sqZ1wZ2xC4qoeeANxK+hz/Fhu3mVSol1wZ2vdGgCgUAgEAgETY4QBK9xlAolT7YfaF3fnBRd4zFvjwrHzV52SV24L46CEkOjxrT4cIJ1WTKVm1uladTzXOuUmGwOogV6UzUjq0eh1uBzh+0Ldv7hfyrs16iULJvekxB3WYDYdj6TdZFpdT7PBz3HMtxfFh4TinL5JnIvLn3vwr5VHwAMKVHWstbGwNfemc/7TLSuz96z/IoKXdHJ56zLncK6oVBUzu5qbEwFmRSf2wWALqADHsMfpYWHLJJmFxspLu3ZOTqondVgJKU4n+NZyU0em6BubIqy9Xd8bECLascO6nsHbQzyjyl7dK7EnNpSYb8pL42EL6dgKSptAVDu3jqlZANTfjrE2nLGUXVBkiQSvpxC4oJ7raZQrv3vxffOjxr0mVcrVehUautD0DAUOocqe+J92G5elQJX2cP//vlXOnSBQCAQCAQCwVWCEAQvQ1ZWFrGxsVc6jBqRJImvzu6yrk8Oq/lXbS8nHc8MlntXGc0S+7JsXyZNuQ0XEmKziknKlftkqexdrNstJdU7Id9ojGjjZV1efKhmw4/qsG/Zx7pclcGHt5OOBZNtn4252+ruqqhWqvh+4B1Wo5EFkXuRkFC5+FrHKFSN6246tWU3xgS1A+BiQTavH1nfqPPXhQH6HOvyd/bVu2s3FuUFdV1wZxQqNcZy2Z06tZwJJkkS50oNRexVGrp6BjRLfILak1dO9G/rXX22tFKp5M6gcAAkhYJfdy627pMsFhK/mY4pNwUAx4hRhH+RiqSSs4zzFI5kFBoYs3A/z604haHcDw+1QR93zJp1COA2aAYBM79HoRT/XRBcnxxPzq9kwHIiOY/zGYU1HywQCAQCgUBwDSP+h38JRqORRx55BG9vb1q0aEHLli1ZsmTJlQ7rsqxLPMuO1BgAItz9mdqyW62Oe2xAGA5aWUxYk2TL1jBmJVzukBopnzuyKzYLAKWDm3WbpSin3nNfj4zv6It7aabmH8eSKDLUP0tQ5eBqXbYUV20cMircm05+zgBsic5g38W6OwOHOLkzLkh2q44pyGJDYlQFoVdp51TnOatDoVAwr9/tOKplofGz0zs4mBHfqOeoLeMTjuJX+lz/yc1sHvfjKkpFC0s/J/YaJarSHnRHMhOJL8wBYGRgWxzUjSvMChpOUTmH17J7b3Xc0+9O6/I/xcUYMi4CkLnuEwpPrANA7R5I4OxfQJJQmOXsWaVboPW4uf9eYMCXO4nNqn15aUm8zZjI+/a3CZj1PQq1yO4WXJ9E+LvQ2d+50vZCg5ki443pyiwQCAQCgeDGoUkFQZPJhNl8bf2H6uWXXyY6OpqEhATOnz/PsGHDuPvuu3nyySevOvdOi2ThpUM219P3etyCqpZZHJ6OWh7oFQzARbObdbspu2GZamXsipEFQVU5QdBcVDuH2xsFnVrFXd3kTK58vYm/T6bUey6FzhFKXT7NxXlVj1EoeH6orXn6i6vP1Osz/Ui7ftbl+Wf3YCmRzS0UGjsUTVAKGOrkwTvdRwNgkSQe3LW0WvOcpkCSJCwX9jHnwnbrtgd3LSW99Lk3C6WZmYWlwpKj1vZa/x130rp8W0jzOB8L6kaZkKtRKdCoar5Pt/Pwp6Nafo8PuQZyZuMXFJ/fT9qyl+QBCiWBj/yG2skTY5ZNJO/TpRMLJnfGTi2f42B8LmMX7qt1pqA+0fZZcmg7sJqRAsG1z/zJndn5xMBKD8daiPYCgUAgEAgE1zoNFgQlSeLxxx/Hzc2Nnj17smfPHuu+V199lY8++qihp2g2JEliwYIFvPfee/j7+9OyZUsWLlzIt99+y1dffcVzzz1Xp/ny8vJISEiwPpKTG7ev1+8xxziWlQTAAJ8wxga1r9Pxc4a0QqmAFKWtdNXYQEGwzDRzd6ycfaa0c7YKGSJDsDLTewZbl5/55xQnkqsW82pCoVCgLC3PtlxGEAS4p3sQHUuzBLedz2R9ZN17/o0MbEsLJ9mkZFXCaRJMsqt0Y2cHlueJ9gPp5SW/Vkezkvjg+FZSivJqfFyOul6bxrTzmAuzGJN2lnFGuYwsraSAh3cta9ofCqqYu6zfZPkvrH9dlEUcpULBuOAOTRePoN6UZRuVF3Jr4q52siAnKRT8cWILcZ+Os5p8eN/2Jo7hgwAqCIIaj2Ae6hfKgacHEV5amnw6tYCPttXcXxagJN7mrKoTBhSC64Tj2ckMXP1llY9Hdi+veQKBQCAQCASC65AGp/OsXr2atWvXsnXrVuLi4pg2bRrz589nxIgRjRFfs6JQKDAajSQkJNCrVy/r9lmzZmEymXjkkUcYOnQo48aNq9V8n3zyCW+99Val7dnZ2djbV+0wCbJYURMGi5mXD6y2rr/UZiBZWVm1iqsMF2BCO082n7JlORWlXiAzM7NO85Sno48jJ1ILOZKYS3xKGg4aFQqdM1JJHob8zAbN3djU5nVualo5SgwKdWXHxVzSCgwM+WoXy+7uQBe/qsW1amPWOUFRDsbCnGpf5xcHBnLfMtmx9/l/TtDDq4u1L2BtuS+4M2+f2YZFklji6MvjgKRxqPK8jfU6f9TxZoZvX4RZknjtyDpeO7KuxmOkGR9Xuf1y12Z+fn6Vz6H42GZALot/x82bAyYlqfoC/oo7ybyj27grpGkcKc05trJug15PZmamVRC0U0FmZiYXCrI4mSNnl/bzCIbCEjILS6qd92r47DcXTfFc63Mfyy+W+0HaqRS1Pn6kTzivsQ2Add5tuSfxCACa1gNR9H/YOk9RvM2BW691JzMzE38tfD+xDTd9dwyjReL/NkQxMtSBlh6X/9sDUBx3DAClsw+5BgU00T3b07N5+nBeqyT/8AglCScqbDOZTOSp1UjOYShKHdgFNRPh7n/ZfcezhQGTQCAQCASCG5cGC4JHjhxh6tSpdOvWjW7dutG1a1dGjx7Nl19+2RjxNTtjxozhrbfeYsyYMeh0Ouv22bNns2XLFt55551aC4Jz5sxh1qxZ1vXk5GR69+6Nu7t7jV+Gatr/TeReYksz7sYGtWds2661iulSXh3Vgb9PZ1CEDgf0KArSG/RFbUhrb06kFmKySJwvUHJTa0+ynNwxluShMBRcdV8Cr4Z4Vj/Un7Hf7WPHhSyyi03c/utptjzSj+5BblWOv1zMOY7u6LMTQJ9f7fO6p68HXx9MZVdsNifTitiaYOCOrnUzoXjc8Sb+G7kDg8XMUo+WzFYocLR3vux5G+N1HuLpyfNZQ/nviS01D66By12bzs5VP4eU9DPW5VbtB7LIPZgxG78D4KVTmwj08GZiaOOX6hoVJZR502rt7PD09KTIKJd+ujro8PT0ZFGSTTSY0qpbrV/rq+Gz31w09nOtz3wlpVXu9lp1rY93d3YkQq3ihMnMYbcgUrVO+BoKcAxsjy7pEA6t+6JydMdUZHMNdw9pj2Pp/P09PfnPsELe2XQOvVnixU3xbHy4L0pl1T8AmAuzSS01lrIP6XxDfUauNkoSTqCPP44uuPKPDQqdA0pd9cY0Ahvz+0+67L6Bq6/N/6sKBAKBQCAQNAYNFgTbtm3LX3/9ZV0PDQ1l1apVjB49Gn9/f8aMGdPQUzQr7733Ht26dWPmzJn89NNPKMv15HviiScYMmQIkiShqEVGlYuLCy4uLjWOqw9rE2wZIW93G1XveXoEuzGwpScZ2e6EWFIoyUltUFwDWnjw5a5YAP49n8lNrb1QOXtjzLiIMScZi1GPUqOrfpIbDGc7NWtn9eHWRQfYfC6D3BITo77Zx47H+tPOt3Kz88uhcpK/vFuKcrDoCy/7hVGhUHBvjyB2lZZ1H0nMrbMg6G3nxG2hEfwec5QMrQNnnXzokpdW62ujvrzVbSRalYrI3LqXOpenrtdm+TLs1CXPMuL5DTwc3pcFkXvJN+q5bcsPTGvVg8/6TMRNV30GVl0ob9iiUGmJySxCX9oLztNBi0WysPDcPuuYiaEdG+3cgsbFw0FDSr6emKwiFuyJ5eF+YZcdW3zxCDnbvyd3zy8M8G7PiTC5b2eUkxe+WQXk/PstOf9+C4A2oD3GjFj5QIUCrW+bCnO9MqINS44mEZ1RyJboDD7dfoFnb2pFVZhybfd/jWdI/Z+soFHQBXemxas7reuZmZl4enpiJ0QsgUAgEAgEAkEj0GBBcNKkSXz44YecOHGCiAi531CrVq1YuXIlQ4YMueYEwfDwcBYvXswdd9yB2Wzm+++/t5b36vV6goODm1TwqC1xhbKYo1Op6epZNzHnUmb1CaH4sB0AxuKGmSQMbW3rR7jpXAZvjArHLqQbJTEHwWxEH3cM+1a9G3SO6xFHnZqVM3sz/rv9bD6XQUahgREL9rLz8QGEedSuNEzn346is9sA0Cedwb5Fz8uOLW9gMqGjb71iHuLXkt9jjgJwxsmHTskn0MefwK6JymcBtCo1bzVAAK+Jwd8eRe2WhEqp4PYIP+ZO6Ii9RoXX+FcoOLURU1YC+oSTXPzvMD5+aTu5hhKWlL4GP50/xKbkc3Rw86XQaKDQZHsUmYzoVCoW9J/MbaG178tmSDtvXdb6tGT5adv7NryNFxsSo6zi6KjAcEJLezsKrj7eGBnOnT8fAuDxP0/SytOREW29rfsli5mcfxeSvXUBJRePWLc7ehisy2ZF5ba/hiRb9qr7sEfReARW2G+nUfHDXV0Z/NUuLBK8tOYMw1p70S3I9dKprD8qgJwtKBAIBAKBQCAQCK5fGmwqolarOXTokFUMLKNdu3bEx8fz7LPPNvQUzc7tt9/O8uXLWb16NV27duWbb75h8eLFPPjgg7z//vtXOjwA4gpyAAh2cENZxZfEunB7hD96pSwIqkxFGEz1d3D1ddYR4S9nte29mE1+iQn7ljYBsDjmQINivZ6x16j4e0Yv+oS4AZCYW8LNC/aSkld9P7gydEG2klV94qnLjkvIKWZDlCwihXs70jfUvV7x9vAMsi6fdpZFxYKTG+o119VCTomJjEIDqfl65u++yM1f7yGz0IDWtxVhr+y0Zl8Zks+SueAefh10F0uG3ItHaT+vpKI8NiWdY0/6RY5nJ3M+P5OU4nzyjCWklxQya9dSMksKax2PIc1mBKH1bcPKU7YMrgkdffn8tC176KkOwhH2auaOrgG8MkL+/JgsErf/cJCjiTbn9ZSfnyD5h9kVxEClnRMO5e6fwU+voO3nKQQ9+ReeY57Hvu1AFKUZ15pWA/Cb+kmV5x7QwoPXbm4LgNEscffiQxSW9qIsj8rJw2oCZcpvWBauQCAQCAQCgUAguLppsCBYHVqtFo1G05SnaDJuvfVWTpw4wdChQ5k7dy5fffUVn376KVOnTr3SoVFkMpChl0WFUKf6iTnlcbZT4+wiZ4uosLDhdMOchkeWZr2YLBLrItMqCoIX9jdo7usdJ52aNQ/2sYqq0RmFjPxmL9lFhhqOvEQQTDh52XE/H0qwmtfe36v+Ga8R7v6oSsXo004+ABRe44JgSw87Ovg6WR18d8VmM+CLncRkFqH1CiX0xS2oXf0AKDy1kZRfnubOll05OfE5JoZ0QoH8WqoUSlw0dvjZO9PK2ZNAB/n6ytIX8crhtbWOx5BqEwQNbmFsOy8bPIR7O2LRFrE2UW4d0NbFm1GB4Q1/AQRNytujwrmztDw/X2/ilm/3EZNZRPa2b8neMt86zr7tQAJmLaLt5ym49b7Dul0C1K6+uPSYiO+dH9LilR20+zqP1h9G4z57OQq19rLnfnVEG/qHyX8vItMLmbOi8o8GCqUKlZOc5W3OS6u0XyAQCAQCgUAgEFw/1FsQTE1NZeTIkTg7O9OmTRumTJnCBx98wObNm8nJyWnEEBsPo9HIf/7zH3x8fPDz8+Phhx8mOfnyDnOhoaF8/fXXREZGsmfPHiZOnNh8wVZDfGGOdTnEya1R5vTztJUaLj1wrkFzTezkZ13+60QKusAOKLRy2bUQBGvGw0HLhof60spTzjo7kZzP6+siazxOF2jrH1dyGUFQkiQW7Y8HQKmAaT2D6x2nvVpDRzc5MzDKyQejQklR1HYshuJ6z3ml+fueTpx6YSj7nhpEkKucNRuZXki/L3ZyKD4HjUcQwU/9g0Ij78ve/BVZm77C38GFv4bfT8F971Iy7b8Yp39A7r3vkHzXG0RPfokjtz6DW+k18E3kPg5mxNcqnvKC4L85LpgsspI7oaMfX5TLDnyi/YAGZwoLmh6lUsGPd3dlaGu5NDclX8/Tny0k+afHrGMCZ/9Ki1d24DbofpQ6xwqCvaVMyS+HQq1F69sKhar6DiBqlZLFU7vjYieP+2ZvHH+dqPz3T+1c+oNOI2cIFhj1xORnWh8CgUAgEAgEAoHgylLvb5DvvvsueXl5LFiwgMLCQhITE3nttdcYMWIEHh4enDlzpuZJmpmHHnqIo0ePsnTpUt59913Wr19PREQEO3bsqDR26dKl5OXlVTHLlaesXBggxNGtUeb08bAJgltPx9cqI+1y9AvzwNtJzlRZfSYVo6TELqwHAIaUSMxFudUdLgD8XOzYNLuf9cv7jwcTKKiixK88amcvVK6yQKdPrFoQ3B2bzbkMObt0VLgPAaWiV33p7in3KzMoVZx38EQy6imKrHw9XWt09HNm71MDrZmaqfl6hszbzbqzadi36k3Agz9Yx6b88hQFJzcC4KDWolOpK2Vdets58U730QBISDy+9y8skqXGOIylJcMqJ0/+Pm8rHR8a7soP0QcBcNHYMb3N5ftFCq4udGoVf93fi87+LviYM3k27g0wGwHwHPsfXPvdXWG8EttnSaKyIFgXWng6MH+Srb3HzN+PcTK54t85lYuc7WspzEYyGRt0PpB/hPjk5L94//YGLZe9b30IBFcLx7OTGbj6ywqPF8N7MT+k/ZUOTSAQCAQCgaBJqbcgePDgQd566y2mTp2Kh4cH33zzDdHR0XTr1o3XX38dPz+/midpRuLj41m8eDF//PEHQ4YMYebMmRw7doxu3boxatQodu/ebR2blpbGzJkzGTVqFEZjw78QNTZx5Zq9hzg2vGQYQGVnc6RVm4pZdKD6DKZp06YxZcoUpkyZUmH7lClTmHH/dCZ0kN//vBITG6LSsW/RSx4gSRTHHGyUmK93wjwcuK+H3KcvX29i6bGkGo8pyxI0ZSVgLpdJWsby47aMoPt71T87sIzrsY9gGYGu9ux4bADDSo1yCg1mxn23n7VnUnHtcyfeE9+UB1rMJHw1BWNmXLXzzQ7vRyc3+brYlx7HnxdPVDteMhkxpMcAoHT0YN1p+b3zdNCQYEmg0CSL9jPa9MJZ0zBhV1A11d3npk2bVu95Xe01rH2wDx/q5+El5QBw0WcgPpPfrTS2vLZcVYZgXZnaPch6X8kuNtJl7r/c8dNBdl7IRJIka4YggKkgo8Hnm3d2N88eWEmJufofNASCK0GEuz+d3f0rbY91cOaivdMViEggEAgEAoGg+ai3IJiXl0dAgNwLSafTUVxcTEhICL///jurV6/G3b1xhKrGIj09HYvFglTuC5WrqyurVq2ib9++TJ48maysLAB8fHxYvXo199xzz1XZA1FRLmMk11g7w4ka5yxXbqjEwmvrIolKv7zjcHFxMRaLBYulYpaTxWKhuLiYyV1s/8F+Y30kdmWCIFB8YV+jxHwj0DPIzbqcVlBz1qZdSDfrcuGpjZX2J5UzKOlXTzOR8gSXy1DNKRWlTFm1K4e9FigTbqZ2kzMhzRaJuxYf5kxqPl4TX8elz50AWIpySVr0UIX7y6Usij7A2VxbX7a0Wjh6l5UmG1PP8XLa+2gkI2M7+FJo1lvHhDVCH1FB1dR0n2sIAa529NIfBSBV6cGLLs+hUKoqjcs12K5ZB3Xj/D368vZOtPORxQ6LBEuPJTPoq930+HQ75wtsfwskfe0NcC7HD9E2I6kpYZ25v3VP7m8tMloFVwfz+09i59jHKz3CivKvdGgCgUAgEAgETU6Dmk6VlcUFBASQkJAAQJs2bUhPTyc1NbW6Q5udTp064erqyscff1xhu06nY+nSpZjNZv73v/9Ztw8aNIjHH3+8maOsHYP9WlqXNyc1rN9fGeYSW9lYocKeIoOZ+349gtFcc1ljVYwK97a65R5OyGVdcZh1X3H0noaEekOxPtImIA1u6VHNSBnnbhOsy3kHl1fa72pn6zNWaGh4xk6mvsi67G6UBRKF1qHB815NaNVKfp7ajbtLRcG8EhN3/XwYgIAHFqLxCgOg8MR6cnf8UOl4SZJ46eAaHty1FFNpmfDtoRHMbNun2vMq1BqCZv9qNYoYbdjFV3nvMKWdK6MD21nH/RFzrKFPUXAFkEwGa6nwBVUwCQZdleMic229/Nq4eFc5pq642GnY++RA3hvTztorE+BIYh57Ltj+dheYG9aXstCo50imnNnc3TOQP4ZOY9Ggu1g06K4GzSsQCAQCgUAgEAgajkKqLqWlGnr16sWiRYvo1KkTH3zwAbt37+bvv/8mIyODsLAwzpw5Q0hISGPH2yA+/fRTnn/+eVasWMGYMWMq7Hv77bdZt25dhdLhxiYhIYHg4GBGjx6Ng0PDRJNiOxUWhQKFJOFQYm5wbAokKO1PJaG0dqqqn/+sjfIfLiWWctuFAUJtKP/61fa9UNTwOjfWewtgVCswaOSsJnu9CZXFgvxpaozZG87y5ZVF0aqo7bVZ9fshlV4/ZWsVX/PyrxGAxmhBa6qL0F5x/rLXt1inwqKUo7AvMaFseDWpoJmxXasKLBVyv23Y3mcJx+KG3+svR9nHR3nJ34KGYFYqKNHJn32NyYLWaPvc1/XajI+PJygoqOYDLiEzMxNPT886H3elueeL+4jU2GMX3Nm6zWQyoVarOZ6dTGd3f3aOrfyj5cAvZLOhnU8MbJY4J02aZF2u7Xt6LbwnHT6fCcDpJ7+rdty18Fxqy/X0XAQCgUAgENSO6m0Jq2Hfvn3W8riZM2fyySefEBoaSlFREa1btyY4uOH9yRqbp59+ml27djFp0iR+//13JkywZVN5eXnh5HTt9IuxbwQRsDyygGP7OtpYck75eYQIWHfq8z7U9Do3plSnMUloTLZMw+v9Pa76tateAL30NarPWaua317fdOKQoHkof71c7hPUXO9z2fkv/VvQEFQWCcdi0TuwPkRq7InUONClin2OFhfOJ9rEv/IcT86nc6kZkkAgEAgEAoFAUB31FgSVStsXGS8vL/bv38+CBQtQKpU88cQTlVw2rwYUCgW//vor06ZNY+LEiTzxxBPMnj2bjIwMPvjgA77++usrHWKtMakU6LWlmRd1zjiqzKUZglC/7LSqsGWk2TKdGvNL5/VM/bL5ymeUVRaTGjNDUK9RYlLLnxfHEiMKSarynNcTl7suKmZmKjArFeh1KutroTWa0Zjql8Zne1XLZyIqKLRXAwqUktToPxIImp6yz4xU+u5eetVIQJG9/GdaZbZgZ2jYfb52Mdn+FlguEfjrelWXaJWYVfIcDiUmFCKLtU6EG4sqZAGWZXAN/GInx5PzobIXBp39nYnwd2nGKAUCgUAgEAgE1yr1FgQvJTQ0lPfee6+xpmsytFotS5YsYeTIkbz//vt8/vnn+Pv78/HHH3PLLbc0SwzffvtttaVPtSnbSCvOx3fJWwD08w5l97gnGhTTuedaYUy/gNotgLafJWKxSIxYsIet0ZkAfDOlMw/2DbWOnzJlSqVG+2UolUqWLl1qXX92xSk++fcCXY1n+CX3PwC4D30Y//uvrAB7NZfHSJJE2Lubicsuxk6tJOPtUTjq1LWKWTIZiXzSF0thNkpHd8I/T0VRakaw8lQKE76Xm/x/OK49zw9t3aA4b9nwLesTIwHYv+NzHM1GfO/6GM9bnrWOuZpf50v58MMPiYiIqHbMg38cY+E+2VF42fQeTOosmysVnNhA3MejAIh3C+Le3tPJKDWEmB3ej3n9bq/zDyVGswX/NzeQWWTExU5N4hPhpHwyGkOq3Dv08W53stVVvpfsGPMYA31b1Grea+k9aSgNea51uc/VlaLz+4h9uy8A39vfxlzH+zn8zGC6Bblax+xIucDgtfMAeK7TED7qNf6y8zXWexr7wXCKTm8BYNV9Z3ll/TlMFlnJc7FTM+/2CO7pUXPprkWy4PXrG2QbiglycCX+ztcaHJvARmd/52YrCxYIBAKBQCAQXJ9c3/V91fDAAw9w7tw58vLySEpKYurUqVc6pDrhY+9MVw9ZiNifEU9accMc8SxWUxEJyWRAqVTwv1s7Wff/fTKlwnh7e3uUSmWFTFGQvyTb29tX2PbqiDZ4OGg4rW6FsVSDLjq3q0HxXu8cTcwjLls26RgZ7o2jrvbavUKtsZqLWAqzK7zWXo5a63JsVsNcUgGSSz93dgoFDqUGCQqdY4PnvZqZ3tMmhry/OZoCvVwS6RQxEvehs9ErVTzWZrhVDBwT1I4v+k6sV9b07tgsMovk13VoK0+c/FoS9soO7EK6AjA+4bB17DeRe+v7lASXoS73ubpiKbG5TOuRr8vsYmOFMZF5NkORto1kKFITkqnUzVyh5IUR4ex9ciBtveVrOq/ExL2/HuHP48k1zhOdl0m2Qb7H9PMJrWG0QCAQCAQCgUAgaG5uWEGwDGfna7fXzrjgDgCYJQsfnNjaoLm0fuEAmHKSSf7pcSRJIsLf2epAeSA+p8L4n376iaVLl1bKkFm6dCk//fRThW3uDlqeGNgCg0LLcXVbAPQJJzFmJTQo5uuZLdEZ1uXxHXzrfHyZ8y2ARW8THsJ9nNCoZGHq+/1xxGYVXXporYnMTeNYluwg2hqLtZxQ41H3xv/XEgNaeNDeV+43eighl1u/P0CJUS7X9b3rI77qMJbzjl4AdDQW89uAO1ArVZedrzp0attxq86ksfJUCmpXX0Jf3Ira1Y+bMi/gbpTfw8XnD3MkM7EhT01wCXW5z9UVjZut3nOw4SBIEqHuFUXGU9m2H2Laufo06Hy1RVkm6EsWzIXZ9Ah24/Azg3mor80k7JW1ZzFbqq//tVdprMunclKpp3+ZQCAQCAQCgUAgaCJueEHwWubJDgNxUusA+OrsbhIKc+o9l999X6DQyu6qOf9+S/amL1EoFHQJkHsRpRcYSMvX13v+Nl7yl8zt2h7WbQXH1tR7vuudHRcyrctDWtW9DLDk4hHrcnmXSg8HLc/d1EoeY7Lw1N8n6x3j12f3WJcnpZyWF1QaHMKH1HvOawGFQsGyaT3xdJAFjy3RGUz+8SAGk4W9uRl879UGADuzkY8O/0ru9zORLPXr79c31J2Xhstl3WaLxB0/HWJXTBYqRzfcRzyOzmLmsRjZGV1C4ul9/wjh5RpB49+eaCf52uxoPs874Zm08qqYXXuinCDYyd2vWeLSlf44BKBPltsBOOrULJjShZvbykL32bQClh1LqnaeYCc3RgTI18LpnFQ2JZ1roogFAoFAIBAIBAJBfRCC4DWMt50Tz3QcBIDebOKdY5vqPZd9aDcCH7JlvKT8+gwFpzbRyc/WnPxkSv3Lkv1d5EzD7dqe1m35x1bXe77rGYtFYmdMFgC+zjpae9W9BLdMEFQ5eqD2qOj4/crwNgS7ye/HilOprDqdWuf5C416FkXLvQgdVRrGRMk9xxzCB6Gyv3azbmtLBz9nNjzcF1c7uZR79Zk07v7lAPfvXGK1/ZgTv5/Q4hzyDywjedHD9Rbq3r2lHQ/0lt/DEpOFcd/t52RyHu43PYRCo2NK8nHaFGcDsD31AssvHm/w8xM0PZ/vjOELxRjr+tTCvyqNOZEtl+YGObjirnNolri0/u2sy1nrPiF1yfMkff8g8V9M5qPkF/k9Zw4f5X3EH1t31zjX0x0GWZf/d3p7k8QrEAgEAoFAIBAI6ocQBK9xnu00BHetXGb2XdR+zudl1HDE5XHpNQnviW/KKxYzCV9OoYe9bb6TKXlVH1gL/F3kTMYoVRh5dnKmS+GpTVhK+6wJbJxJK7D2jRvc0qPOvedMBZmYsuIBsAvrXul4R526Qn/IJ/86SbGxbhlsS2KOklv63t3h4ICTWe475hQxuk7zXMt0D3Jjzaw+OJa6ff+ZtptzpdffEL+WvHjneyg08uc+Z/t3pP3+Qr1EQYVCwYLJna2l4znFRkZ9s49EkyOufaeiliReiNpsHf/8gVWUmIyXm05wFXA2NZ+XVp9hi7YPCUr5fS0+vgp9ii2LLrU4n7TSPoOdPaqwk20idAE2QTDvwFIy135Mzr8LyT+4HE3MdjqZohlj2MFTxx/i7JHqe8HeEtSONi5yVuGahLNE5aZXO14gEAgEAoFAIBA0H0IQvMZx1drzQsRQAEyShTePbmjQfF63voZzr8kAWIpyaL92Fk6WQqBxMgRRKDjl1g8AyVBE0dltDYr3eqR8ufCgFg0sFw7tVuWY2yL8GN1ONimIySriwy3RtZ5fkiS+OmPLDror2VZ27NS5eZy6rxb6t/Dgnxm90DgWgafcv0+jUPP9wDtx7jCUoEf/gNL+gZlrPyZ787x6nUetUrLkvu4MCHMHICmvhFHf7EUx8BE5juyLDC2UxZbYgmw+OSWysa5WjGYL9/12hBKTBYtCRVLnB+QdkkTWhs+s48qyAwEi3JtPELQL64nK+fIGJpJC/jx7STmUfDmKwlJH4qpQKpQ8VS5L8IMTW4nOyyC6AT9cCQQCgUAgEAgEgsZBCILXAU+0H4BvaZnmL+ePVGhEX1cUSiWBD/5gdTFVpkcxN/8jVJKZk8n1FwRd7dTo1PLHbbd9b+t2UTZcmR0XsqzLg1p61Pl4fbytZLTsfbwUhULB5xM7oVXJ78n7W6I5n1FYq/n3Z8RxJEsWvwb6tCDktCxCq90D0QV2rHO81zrD2njRtnMyZa4qlpQwHJFNR5y7TyBg1iLr2LTlr2KuZ69PB62alTN709FPvtYj0wuZuL4Eu7aDAXju5Eo0pdmg7x3fTHJR/TN6BU3H+5ujORifC0CEvzN3znoBpb3cmiFnxyLMBfL1X75/YHMKgip7Z1q+fYSgx/4g5Nm1hL2+l1b/PUvbL1Jpt7CEgE9SOKiNAEBrKuTi3FvI3ffHZeeb3ronrlr5B6Hvz+2nzfL/0mb5f5vluQgEDUFrKWHFY52rfPz++h1XOjyBQCAQCASCBiMEwesAR42OVzoPB2RjgU8bmB2k1DkS/PQ/qFxkV8uBxsM8XfQTJ1Py690HTaFQWMuGN1s6oNDIXxDz9v+BKV9ki5Rn90VZEHCxUxPh71LD6MroE09Zl3XlDEUupY23Ey8MlQ1G9CYL72+uXZbgT9GHrMsPBbbGUpQDgH3rfnUub74eOJSZwKn8UsfsEgfM6f78cCDeut9twH24D50NyFm3Obt+rPe53B20rH+oDyGlbrT743I40mIqAGHF2dyXKb+HhSYDc0/+W+/zCJqGf89n8PbGKAA0KgU/T+2GvbMbbkMeBOSs6dy9vwFwsoIg2DyGImVoPAJx6T0Fp86jcWjVB51/OGoXH5QaHe4eXqwfuIB12gHyYJOBxPl3kbXxiyrnctLouDOsa/MFLxA0AhaNPQalXZX7/Aujsc8828wRCQQCgUAgEDQ+QhC8TnBQa6zLTqV9yxqCxjOE4Cf/svZAe6D4L3rm7SSvxFTvOVt6yOYYFwsV6LrcCoA5L42kb6cjWSwNjvl6Iau0f2CYuwMqZd0FNlOerU+X5hJDkUt5aXhryk5xNq12GaDppX3NAAZ7BlqXFWptHaK8figyGWwrha6AkovZRRXGOPe83bpclgFWXwJd7fntnu7W9eWmbugCOgAw8/Q66/aDmfGVjhVcOfJLTEz/7Shmi/yjytujwukS4AqAc9dx1nGmXFkIvFiQbd3WurQP39VAfHYxq6JyeN75OX6xGytvlCRSFj9J6tKXK/1oZLZYOJ1bd+MigeBK4hXSDo9W3Zjw1fFKj2TH1lc6PIFAIBAIBIJGQQiC1wkLIvdalx9o06tR5nRo0x+/e21ZH+8WfEZSbP1/Fe8SYMt2SxjyBmo3uQyu4NgaMtd9Uv9ArzMammNnMdhKf5W66h2KHbRq3OxlMTm7uHZGFHYqm/gsOfuAQr6NGJJuzIyJXl4haEv7BOIol4IWGysK3OZ8m0irdm14tlffUHfr+7Y9Npfg59ahC+iAm6kEvxK5VPhsZmKDzyNoPOasOMXF7GIARrb15j/DLiMqlF5PycXy++imtcfhKhHbLRaJGb8fJa/EhEWhIn34O3hPfte6P3PV+yQtfADJbPvh6I0j69mZGnMlwhUIBAKBQCAQCATVoL7SAQgazqGMBA5kyNlA/X3C6OwR0Ghzuw2Zxe4tK2lxcSWuUiGGH6dh+b+9KOuRhVheEDyaq2PmI79x8b/DQLKQtuwlHNoOxKF130aL/VqlrOxWon7l2ZJeFgQVai0KVc2XuLu9hqwiozUzsSbsywmCegXogjqhjz9OycXD5B9djXPXsfWK+1rFXq2hn08o/6ZcALsiUBsquTaXZX1B4wiCSqWCAWHurD6TRmJuCUkKT8Je2UHcp+MJK84mxc6FVKOelNNb8eswtMHnEzSMNWdSWbgvDpD7qX53Z5eK5fWSTUBWlIrLZT0g/Uv7w14N/Gf1GTafk1s8tPR04JNbO+Gk64ra1Y/kRQ+BxUzuzh/AbCTgoR9ZEX+Gd4/LDtgapYo1N8+ko1vzlj8LBPXleHYyA1d/WWl7VngvQosLmHAFYhIIBAKBQCBoTESG4HXAgsg91uWHwxtXUFMoFMQP+y/RKrn0VJN8lNTfnq3XXOUFwWNJeTi2G4L3bW/KG8wmEufd2eByyuuBMpmgnu0asZQJglqHWo33cJCzj7KKjLXqEWlXTmQsNhnxnvimdT3ll6ewGErqEO31wVC/ctlejjlVCIK2kkl1Iwkig1raHKh3XMhE5eRB6AsbaeNgu852fTeLkrhjjXI+Qf3IKjIw6w/be/DFbZ0IcrOvMEYqJwiiUFJsMpJtkLMJAxxcmyXOmpi3K5aPt50H5P6HP93dDSedfC9wH/wAwU/9be0Nm7vnF3Z+9xDTdiyxHv9Zn1sZEdAWfwcX/B3q3hv1eiT5h0eIeWdglQ9JX1TzBIImI8Ldn86XMfOJdXDmor1TM0ckEAgEAoFA0PgIQfAaJ89Qwq8XjgDgrrVnSliXRj+Hr6c7c5z/QxFyVmD25q/I3fd7nedp7+uEurRh3bEkOfvFa/zLOHaQDVGMmXEkLpxRb+OS64WyxKH6vgqW0i+SNZULl+HhIGf8GcyWSkJWVdiX61dZYjbh3GMijp1GAmBMO0/m+huv/HuofyvbimMOJZeUDFfIEHTxbZRzDmxhc6DeGSML6UqdA53732PdHqdQcfHjUehTzjXKOQV154k/T5KcpwdgYic/7u0RVHmQxXbdKZQqUoptDtH+Dlc+Q3DlqRSe+OuEdX3hHV0Y0KKiA7pz13GyKKjWUqRUM7PERJ5R/nFgWqsezA7v16wxXwuUJJyo4ApfHoXOodb3cEHjM7//JHaOfbzKR1hR7frtCgQCgUAgEFztCEHwGueXC4cpLDU1uL9NrwpiTWPh72LHeXUIbzk9at2W/P0s9MmRdZpHp1bRwVf+cnssKY9ioxmFUkXg7F9QucoiScGRFWRt/Lzxgr8GsWUI1k8SLOshWNsvk+72ts9MbcqGK2QImo0oFAr87v0cSkuJM1a8Q3Hs4bqEfM3TxzvUVkrtmk6OuaDC/oolw40jCPYMdkWnlm/hO2JsmbUtXbyty4l2rphzU4n76GaM2UmNcl5B7Vl6LIlfj8i9HL0ctXw9uXOVTtwVTJWUSpKKbIJggP2VzabbFp3BXYsPU+qFwpsj2zKtZ9VmRU4Rowh8fDlvtBvNOSf5c9gRM/P7TbohHchrgy64My1e3VnpYRfcGa1Pq5onEAgEAoFAIBAI6okQBK9xfivNDgR4qG3T9N/zd5YzA1fZDWW//0QALCUFZG2q3FunJvqHuQNgskjMXnYcs0VC7epL4MO/WFPjUn97ltx9fzRO8Ncgth6C9aOsh6CyliXD5Z2Mc2vhIl2+h2BOaVmjzj8cz1HPyOc3FBPzRg8ufjCC/CMrbwgHaZ1Kzb2tSp1/VSYO67ayKv60db8pTy4ZVto5NVrWj06tok+IGwBnUgt4bPkJ9CYzLZxtmVvLQnqRaOeCMeMiacteaZTzCmrH9/viuOcXmzA+f1IEvs6Ve69aDMXkbF9o26BQkVFiMwbSlBnWNDL7Lmbz1vpIvtoZw18nktl3MZuEnGKMZvl6PZmcx8Tv9zN0/h6KDHIG4/SeQbw+sm2188aEdmeNTzgALsYS5u5dhPn0piZ5DgKBQCAQCAQCgaD+CFORa5yUYrl0xdfemXZuPk1yjmA3e/xddCTn6flIP4Kl/A3IomBdub9XMN/ui8NskfjpYAIms8QPd3fFqeNwvMa/QsaKd8BiJnH+3WAx4dpvaiM/m6sfU2kqjlpZv4waqaz8UFVztmhmoYG/TsrZa846NWHu9jUcAR3dbT3wtiRHc1toBABeE16l4Pga9AknASg8vZnC05tRebXA8bHfsW/ZOO7XVyvv9RjDtyePglaPSaln/KbveaBNbz7tPQFzQSYAKmfv6iepI7P7hbH9gpwdOG93LIcSclhyX3c6uvlyKieVixoH7ul+D18fW0aHI/8gmU21MpoR1J8ig4kXV5/li502Z937ewUzuUtlsydTXjrxn91KcXRpH1iVGsd2Q4jw8EepUGCRJBZE7uWFiKG4aO0aLcZfDiVw/5Kj1ntNeRQK8HbUkl5oqNDHdFS4N99M6VJjpp+vnRNqhRKTZEEjmfExFJC18XOcu4xptPhvBM5nFlJoMDPwi53WbSaTCbVazfHkfDr7X/lS8hsZsyQx8Iud1vekPBH+Lsyf3PkKRSYQCAQCgUBQe0SG4DVOsUku8XSohfhTX5RKBTN6ySViwcY463ZdYMc6z9Un1J2l03qgVckfvV+PJDLph4OUGM143/427iMelwdKFhIX3EfOzh8b/gSuMcoydDSqel6edSg1nr871pr983C/UBx1NYtFw/xbW8uGV8aftpY2q+ydafH6PvzvX4AuoIN1vDkjhvjPb8NcmFOHJ3Ht4aqxh/PdIdfLuu37c/vp/M9c9ijlzDCVo8flDq8Xd3cP5Jd7uuGglbPI9sXl0Ot/O3m19SQiShvip2sdmN7tTvZqHCk6t7tRzy+wIUkSy48n0f7DbRXEwBeGtmLhHZV7u+pTooj5v35WMVDp4ErIs+uwb9mLls6e3N9aFtAz9IV8fHJbo8U5d9t57v31SJVioPw8IK3AJgaGutvz491dWT2rD1p1zfckPwcX7mrZFYBMrSOrfNpTeGJ9nVtM3OgUGszWe/OldPZ3JsJfGLNcKZRKBarLCOPHk/M5kZxX5T6BQCAQCASCqw2RKnKNU2wuFQQbuXdgnqGE/Rlx7E+PJ8dQTImrBF5xFJZk8odTBHYWE4EOXoSmnEdSgKIO9a23RfizamZvJv5wgCKDmZWnUxmzcB//zOiN372fo1BpyFr/qSwKLpzBrvxcvtU6czonlfd7jGFS2PX9y7vRLL+Y2voKgmXFxjVk8hQbzXxeKlyolQqeGtSiVrM7qLWMCGjDqvgzXCzI5mR2ChEesvik1DngPvQh3G56kMLTm0lb9golF/Zjyk4kdcmzBMz8rp7P6eqn0GAGsxbiO9DNWU+M3XFyDMVcLMjm/k4TuS/+EK/YNb5wP7V7EJ39XZj040Gi0gvJKDQw9cdTvDZqFO7a7WxPvUCBWsdDnSdhOrSCWe0GN3oMNzpnU/N58u+TbIzKsG6zUyv59o4uVZqIFEbuIOGziZgL5exOjWcIwXPWYBdk+5Hlza4j+eXCYfRmE3NP/cuj7frj1wB3XotF4vlVp/nk3wvWbY8PCKN/mAdJeSXyI1f+NzG3BJ1ayex+YTzULwSdum5ly891uonF5+Vy6R+Ce3JbykmyN38l9xoV1BoHrYqdswZa1zMzM/H09KzmCEFzYFcqjO+cPbDSe1I+o1MgEAgEAoHgakcIgtc4ZYJgQ8xELJKFqNwM9qTHsjctjj3pFzmZnYJ0aRc7P9iJGzuRHWWJOQkxJxllp8ax2ESxTsUtG76lhbMHLZw8cFRrAVsvvLJMMqVCQQc3X1bO7MHtiw6TW2Jia3QmIxbsYe2DffC9ey5mlYY/DvzN98E9OZliy0q8c9ti/ho2nfEhdc9OvBaQJAmDNUOwnk34S1/nmkr7fjoYT3qBbEhzT/dAgtxqLhcuY3xwR1bFnwHkLMEyQbAMhUKBU8cR6AI7Ev1iB6TiHHK2f49zz8k4d7mlLs/mmsGWzaMgXNuSFRNvZubOP9iQFAXAz8E9SMHMOsmCUtG4ydmd/F048PQgZiw5yp8nUpAkeHtdDJ/fNhJPzTb+SjiLUanmIb2E/swu7vJp16jnv1Ep0Jv4v41RfLr9glXIB7i1oy+f3tqJFp6V+3jm7vmNpIX3I5WaQdm16EnI0ytRu/lVGBfs5MaT7Qfy0cltFJmMvH1sI/P6TapXnAaThRlLjloNTgA+GteB54Y2jWlFF48Abg5oy8akKC44evKvZ0uG7/gB70nvorIXpa4CgUAgEAgEAsHVgBAEr2EkSaKotGTYvo4lw3mGEjYmRbEq/jRrEyNJLe1F2BAsSgXrE2tfFqZWKGnfw5/oODXFOU7sTzQw6Kvt3D1cxfdKV2I6jq90jFmycMe2n1k38kGG+F1/DozmcmV8GmVDRaPLC4Jmi8TH22yZQs/dVLfXclxwe+vyyvjTvNxleJXjNG7+ON/2Hnm/yg7VyYsexOG9U6gcXOt0vmuBIqOtvM9BqyLI0Y11Ix/kkxUf8lp6EsUqDRtR8dbRjbzVbVSjn9/FTsOy6T35eNt5Xlgli7Vz/jnLxtm34nhuJ4vtvZAUCh7f+xcX2w7kwwETGz2GGwVJkvj9aBLPrTxNYm6JdXtrL0c+n9iRW9pXdpKWJImMle+RvvxV6zanbhMIeuTXyxrNvNh5GN9G7SPHUMy3kft4psNg2rjWrQ9lfomJST8esGYvqpUKFt3VtcrMxcbk+U43sbFUDF8U3IuhR38nd+ePeNz8eJOeVyAQCAQCgUAgENQOIQhew+jNNkdYXQ1GARbJwvGsZDYkRbE+MZIdqTEYLVX3J9IqVXT3DKKfTyh9vUMIcXSnxGwkt6iA8/PuxKRUcl4bRKs7XiXTkM+pDXKfP0UdetcBmCQLJ3ITwRX5AZy2KHntWEVX2oi8ZGbEH2CHR0v+8u9EidnE+E3fs/2WR+nqGVinc17tlGUHAmjV9TQVqcX78M/JFKIzZCfTW9r50KmO/agCHFzp4RnEocwE9qXHkVacj89lMn/sekzBcmYdBUdWyKXDv825LkuHy/f7ctTK16NCoWBqzkW8j69gZpcpmJQq3j66ke4egdwa2qnRY1AoFDw/tDW5JSbe3XQOk0Xijp8Os6NLB9yO/sWXLQYA8FHUTjr4BHJ/m+vb6KWpGDp/D/+ez7Su22uUvDqiLc/e1LLK8lpJkkj+fhY527+3bvMY+RS+d89FUY2LsIfOgRcjhvLioTWYJAuvHl7H70Pvq3WcWUUGbl6wl8MJuQA4alUsn96TUe2axoCqPCMC2tDVI4CjWUkccgviuLMfLH6ClMVPANDhx/r6qAsEAoFAIBAIBILGQAiC1zAmySYebUo6x4O7lvLfHrKT44nsZE5kp3A8O5kT2cmczE6hsLRE7VJctXaM8G/DAN8W9PUOobtnUJUCY0nCSS5kyBkff+oCaUkbXugVwCTDIgAcSsxkTX2bmPwsLhZmYzDLAklZ5aoCBQoFFJmMHMiIZ2dqDMeykiuWJittz2lCcEeej7iJ8AO/k374V4ZnRJOv1rHJuw35Rj3PH1zFxlEP1/8FvArJLbGJvPXpIShJEpR9LqopS/10uy078IV6lg2OD+7AocwEJCT+jjvFQ+F9qxynUCjwv/9rzkftwFKYTc6OH/C9ay4qR7d6nfdqpcRkEwTLG0QbUqPpmZvIC+e38V4bOZPy8b1/MSa4PZpqxKCG8PaocI4l5bHqdCrpBQbuPOTHrwl78TAW8XbbmwF4ct/fjAvugJdd1dlpgstTXgyc3NmfuRM6EOJeuTy4jJKYgzYxUKHEd+qneI58slbnujmgLS8eWgPAnxdPoDebavwBqIwn/zppFQO9nbSsmdWHnsFutTq2oSgUCu4ODOdoVhIAG7zb0jk/pVnOLRAIBAKBQCAQCGpGCILXME4aHRNDOvF33EkAFkbt48fog5fN/CtPuKs344M7MDaoPQN8W9RKmDCkRluXY1VB6LKKKo1x1zngrnOgu1f15WjTWvcEINdQzN70OHamxvD3hUhOZqRDoTs++lb8fPdYXOw0MO5FJEMxGf+8zUenVzNp4KNcUGnZkhxNekkB3nZONcZ+rbAt2iY0dK6Hi6SlKBdK33+VU9WOtseT8tgZI5sZdA1wYUir+jWpn9KiM28e3QDAz+cPXVYQhNLS4c5jyN3zC0gWLCX5150g2NLDJggdScy1LusC2lN4aiNTE49ytNvtrCnIJaEolz9jT3BnqRtrY6NUKlg8tRtD5u3mWFIex0rcSVZ5c2fScSLdgvndpx35Rj3vHNvE//rc2iQxXK+U/XzhoFXxz4xejGhbcwmvorSfKoDrgGm1FgNP56QwZpMtm3aYf+tai4FnUvP55bDcM9DHScvOxwfQxrt57pWSyUjSpi/5KuYM2Mn3se65iTUcdePxqmsLIjX22K3+stK+ImUeDhbhJCwQCAQCgUAgaDoat7O9oNlZPmwa3/SfjLtWNoSoSgxUKhS0c/XhrhZd+ab/ZGImv8zZ2//DR73Gc5N/61pnKZUXBONU/sTnlFQzuna4au0ZFRjO/3UfzYnJT3Gb3a2Q1Ja0TBUvrT5rHec1/mU0XqFoJTOj4g8BYJEk/rp4ssExXE2sj0yzLo8Kr1uvMABTri0DR+3qV+WY+btjrcuPDQir0XzkcnRw86N7acn2ztQYzudlVH9AhfNcf+WCXk46wr3lbLv9cTkYTHKmpkvfuwC5o+M9e3+yjv/s9I4mjcfVXsO/j/ZnRBsvAE6p5EzQx89twalUVJp3djcx+ZmXnUNweW5p51MrMRBA7W5rbVDmLFwTp3NSGLZugbW/az/vUJYOnVbr+D7YYrtfv35z22YTA/OPreH8qxG8v/sP4krFwAG5Cdw1YjZtv0wnfF424fOymyWWq51IjT2RmqozSx0sLjgKQVAgEAgEAoFA0ISIDMFrHKVCyYPhfbk1pCOvHl7HjtQYQhzdiHD3J8Ldj84eAbR39cGuAS7EZRjTKgqCjjnFDZ7zUr68LYLN5zLIKzExb3csU7sHMqCFB0qNDu+Jb5K0cAaj0iOZH9YPgKWxx6rNTLuWkCSJDVHpALjYqekT6l7nOWoSBPNKjPx8KAEAVzs1U7s3rAfjtFY9OZwpZ/4sPn+YN7qNrGa0TRCsTZ/Da5GBLTyJTC+kxGThSGIufULdsW/VF4fwwRRFbqdLRjQd81I45eLHnvSL7E+Po7d3SJPF42qvYfWsPjy09Bint7dihGEvHsZiBhXZsVZXgNFi5tXD6/hlyD1NFsP1ym2dqhbcq0Ll5IlCo0My6jFlJdQ4/nROCkPXfk1aSQEA/X3CWHvzLFy0drU638WsogrZgQ/0aZrPmGQxY0iNpiTuKCVxxyiK2kFx1E7i7Fz5tvdoALRIfDvlLbwCw5skhmudcGMRO8dWNloZ+MXOKxCNQCAQCAQCgeBGQmQIXif42DvzzYApnLn9BdaPeoiPe49neptedPMMbBQxECpmCMar/EjIbXxBMMDVjo/GdbCuz/rjGPrS3myuA+5DG9Ce1oWZtCyUs5q2Jp8no6Sw0eO4EpxIzic5Tw/A8DZeaOrRQ7A6QbDEaObR5ScoLDW/mNE7GAdtw34TuLtlV1SlvQo/P7OTpKLcyw8unyF4nQqCA1rYRNxdsXImmEKhIOTZNbgPfxQFcF/iYeuYj3f82uQxadVKFt3Vla69h1i3hR0/g6NCzir+9cIRjmSKcs66oFYqGNuhspPw5VAoFKjd5TYKxpzqX+tT2Q0TAwE+3nYeU6lj+TODW2KvaZxelZLZRO6+30la9DAxb/fl7MMunH+xHYnz7iJz1fsUR+1EAt5vMwyDUr63/KfLzbQXYqBAIBAIBAKBQHDVIQRBQa0xlGYIZqvcKVLYN0rJcFXM6hPC4JZy/7uzaQW8t0k+r0KpwmfSOyiAkemyuYlZslh7KF7rNLRcGMCUl2pdLi8IJuWWMGTebmvWkEal4NH+YfULtBw+9s5Ma90DgCx9Effv+B2LZKl6cD1Lk68lBrSw9W0s69MIoNQ54j/tK0KeW8dYQz5eelns+Ss7lUPfzMBcnZDaCCgUCmbdPsG63sUQTWGCrc/niwdXN+n5rzeGtvbEzb5uP7RoPOTX25ybinQZg6dT2SkMW1dRDFw3sm5iYGq+noX74gA50/iRRrjOJbOJnB0/cP6l9iTOu4ucbd9QfH4fkqFyH9ntbW5iu2dLAFo4efBS5+ENPv+1zCO7lzNw9ZdVPi5XLiwQCAQCgUAgEDQHomRYUCssRj3GzHgAMu2DAfmLp95Us4FJXVEqFXwzpQtd5v6L3mTh/S3nmNLFn07+Ljj3uA27Fj0ZlRbF16Vlw3/EHGNW2z6NHkdzsz4y3bo8KtynXnOYcipnCJ7PKGTQV7us2YfOOjW/3NOt0XqKfdp7AluSo7lYkM3GpCi+PLOLJzsMquGo6zNDsI2XI95OWtILDOyKycJskVCVsxx2ihhF+3ePM/3XF5kLmJQqvo2LYs4rEYQ+vwFdQLsmi03t6ovaPRBTdiIdTOchyxe8EkBXzIakKDYmRnFzYNsmO//1xG0R/nU+RuNuE2CN2UlovcMq7D+SmcjoDd9axcABPmGsHTkLZ03txUCA/22/QElp/8rHB4ThWkfh8lKKYw6RMO9OjGnnK+5QqtD5t0MX0gW7kK7YBXeh0Lct/922GApzAPi870TsGylD/VrlRHYyx7OT6exe+TMTWlyAd2F+leXBx5Pz6ezv3BwhCupBpMaBgau/xGQyoVbb/it93D6vtPfjwCsXnEAgEAgEAkEtERmCglphKcmH0swvVykftWQCIL2g6kyXhhLu48TrN8vihNEs8difJ5AkCYVCgc/k92hTmEGLIjkDa2NSFH/EHG2SOJqLjZHpbD4nm3K09XYkzKN+mSPGjFjrcpkguOhAvFUMBPjngV6M71j7/mc14aq157sBd1jXf4w+WHVs6THWZYXq+hQJFAoFA8LkLMG0AgMzlhzFbKkofqoc3Xnh3o/RlmZMLgnsSm5uCtnbvmny+OxCuwPgKeXiJeVCagvrvsf3/kWxydjkMVyLHEnIrSBhT+hY+3LhMpQOrtZlc0FFA5418WcYvGZeg8VAgD9PJANgp1by1KCWdT6+PPqks8R9PKqCGOjUZQyhL22j3YICWr13kqDZv+A15nlSQ7szeMfvxJWKgROCOzIuuMNlZr6x6Ozuz86xj1d6vHdmP9Oiq85w7+zvTEQ9nOYFTU+4sZhwY+XsWJDdoQuVec0ckUAgEAgEAkH9EBmCglqhdvbCvnU/iqP34F0Yw73SSn5wuA0HbeP0pqqK54e24pfDCZxOLWD7hSx+P5rEXd0Ccew4AodWfXj44l5ebD8GgAd2/kG4qw9dPAKaLJ6mIqNAz/QlR6zrzw5pVe+5ii/sA0Bp74LGWxZ77uoawJc7Y8gtkUXcGUuOsmpmbzo14pfN8n0ce3oGV44r5hBFkdsB0AV1quC6er3xwtBWrD2bht5ksRq4LLqra4VMQR97Z6a16c3CqH3kauxZ5h/B08amKcEvj84/nIKjKwH4uL899++1gwJXcMolKi+dt45u4L89xzZ5HNcSCTnFjPtuP2U5yAog0NW+zvOUxB+3Lmt9WluX553ZxRP7/sZS2lfzJr9WrBgxo15iIGC9zkPc7fFx1tVrDgBjVgIXPxqJuUDu12rfZgB+Uz/FvmWvSmN3p8Zy6+ZFZOjl+0Cwoxtf9r2t3ue+kXDUqtj5hMgmu5Z4J1f+cavF7G/IzMzE09PTus9l4XtXKiyBQCAQCASCOiMyBAW1xn/6fFDKAuBjRb/ib07DWdd0mrJGpeTziZ2s68+tPE2B3oRCocB9+OOMTz3DlKRjABSaDNy0dj67UmMuN91ViSRJzPrjmDWDb0JHXx7sWz9HUFNOijULz75lHxRK+fLu5O/CnicH0qI06/BidjFD5+8hu6jxsjt/Om/LCpzeumel/ZlrP7Iue97yHIrruJ9gvzAP/p7RC51afv1/PpTAA79XzhR8odNNKEudl38M7om+GaqoNd62jLFbA/Q8M7gVJIWDRY7145PbOJRRswvujUKB3sT47/aTlNcwsVYyGSmJPQSA1r8dKkc3zBYLc/av4LG9f1nFwHtbdWfdyAfrLQYCFBvlNg4NMRIxF2QR99EoTFlymwj7Vn0JfX59lWLgkgtHGLb+a6sY2MUjgL3jniDYya3e5xcIBAKBQCAQCARNjxAEL4PRKErnLsUupAseI58GwAE9bxR9g1rZtMLO8LbeTOos915KzC3hvc3nAHDpPQWViw8vn9tKz1zZKCPHUMzN679hdfzpJo2pMfl+fzz/nJKNQPycdSy8o0u9xbKi6D3WZfvW/Srsa+/rzL6nBtIvVHbBzSg0sOZMGo1BSlEe6xNlk5fWzl708wmtsN+ceZG8/UsBULsH4tr37kY579XM6HY+/D2jF9pSp+ifDiYw8xJRsI2rN5P8wgBI1TnzJ02XbVuG1scmCBrTLvDR+A7c2iYMUuU4zJLEfdt/o0SUDmMyW7jr50McTWp4+V9J4kkkg+zKbt+qL4VGPZO2/sinp7Zbx7zZdSQ/DbobnaphP7IUGRomCEpmE3H/m4A+Sb6PagPaEzxnFUqdY8VxksS7xzZx97+/oDfLWYljg9qzY8yjBJQrjxYIrkf08ceJeWcgWV+MJeadgdZHUNF5vEuEa7tAIBAIBIJrAyEIVsGxY8cIDw9nz549NQ9uAiRJIqOkEEm6+owXfG57kzS1bHgxSL+f/EN/Nfk5547vgL1G/qh++u8FEnKKUWp0uN/0EFrJzIJjyxillXvSFZuN3Lr5B366TB+7q4kLmYU8/Y+tf9QPd3XF26n+JX7F522fV4dLBEEAbycdcyfYenptjEqvNKY+/HrhCObS/pLTWveoJGgW/jvf2n/SY+TTKNTaRjnv1Y4sCva0ioI/HkygzftbeGdjFAk5sjj0TFiEdfxWqekFwfIZgob0C6iUCn65pzs9HDpCkWxgcCY3laf3rWzyWK5mJEli9rITrC4Vzb0ctTTkp4/i8/usy7mhPRiydj7/xJ0CQKNU8fPgu3mj28gGZ86azBZMpaJz2T2zruTu+YXic7sAUHsEEfrcetROnhXGGMwmHtj5O68eXmfd9kT7gfw9/P4GZTcKBNcCdkER6II7V7lPaylBZ2n69g8CgUAgEAgEjYEQBKtg7ty55OTkMHr06GYRBU0WM4cyEvjs1A4mb/mRjhu+wPu3N7h5/Tfk6Iub/Px1QWnnxGeej1nXk76djqJcu33JYmn0c4Z6OPDMYFnIKDFZeH1dJADuQx8GpQo7i4lPDv7C/a16AGCWLEzfsYS5J7c1eiyNhdkiMf23oxTo5WyexwaEMapd/ZyFy6iQIdiqatflXsFu1jLvTecyGiw6WyQL353bb12/r/Q9KMNUkEnx/l8Bua+h+9CHGnS+6jiamcjQtfMJ/v3/rI8rzS3tffmrnCgYk1XEa+siCX1nE2MX7iMz2YKzSf7yeLwZbsdar1AoFZ0M6RcAcNSpWfVAH/zzu1hLhxdE7eaP8yeaPJ6rlbc2RPHd/jhANuf4Z0blUtm6UCYIxtm5MiojjUOZclm2h86BTaMe4t5Lrpt6n8dou//WJ0NQMhlJ//tt63rQY0vRXNITNFtfxOgN3/JD6Y8uSoWCz/rcyud9J6JWNr2oLRBcafzvn0+LV3fS4tWdeDyx2rrc4tWdGJRCEBcIBAKBQHDtIATBKmjbti2PPvoovXv3bpAomJeXR0JCgvWRnJxcYX9qcT4vHFiF129v0HPl/3h6/z8sv3iCtNJeTJuTz3HTuvlk6at2s7tSrFP0YKO2LwCWkgIoFQQVWDj3TDCZ6z7FYmhcIfOFoa3xcpQzy344GM/GyHQ0HkG49LhdHpAVz4e5sTzf6SbrMc8dWMWDu5aSfZW9fiBnOu6MkV2S23o78uG49g2aTzIZKImRv6BrA9qjcnSvcpxapWRoaznbJzG3hMi0gnqf02yx8M6xTZzOkUueh/m3JszZo8KY7M3zwSC//u5DH0Zl3zSumefzMhi67mu2pZwnoSjX+rgcNV2bjcmY9r5sf6w/t3b0tRqLWCRYcyaN9//aTvt8OQstDmWTX+sKtRaNhyzwlHeO9XOxY8uM4bhkt7Nuu2fbb/wTc6ZJ47kaWbAnlrc2yCXwSgUsua8H/Vt41HDU5ZEsFoqjd5OjtuPBrlNIKH2PWzt7sWfsEwz2q7+J0KWU9Q+E+gmC2VsXYCwVip26jsOhdd8K+wuMegas/pKtKfJnx1Gt5Z/hM3iyw6AGRC0QCAQCgUAgEAiuBMJluAratWvH8uXLWbFiBRMmTGD06NGsXbuWJUuWMHXqVPr27VvzJMAnn3zCW2+9VWl78O//Bx7Olz3OQ2MHCgVZhmKOZSUxau3XLO93N45XQamlJEnoTRZec3oSLZ7cZNgH5TQlU04Sqb/NIX31hzjf/gF2nRvPsXRO/0Be3hiDJMHob/fy6k2hPNzrXjgg96dLX/YyD7UZjMOAh3grVnbtXRi1j39iT/By+yFMDemMSmHTwPPyGt4brD6kFhh4c/1ZAFQK+HJsS4rzc6mNhHq5mPWnNyCVutQqg7uTmZl52Tl6+tmzQq5WZGdUEt5qrzrFD3AmL52nj63hUHaSddszLftWOm9u5E7bSufbq42rISyLOUROORE6zMGt2vGXuzbz8/ObJMbWTvDdra1IGR7M78fTWH4klrGJi7i3ZCX/yx/IfnfZSGZbzGmGlLpDNxUKzxaQGYcpJ5nkvX+jbSOLOd5qWDduBEM3ZaB3TMOkNDBx23eMOxvO+51vxt/u8vesq5m6XOfLT6XzyD/nrOsfjW7JQH9Npc9EXT4j+SteR58SxZsdx5NgJ/fWi3D1ZVnfu/A0KRvt85aXl0euZCtVVFpMdZq75NhKcn992rquHfp0peP3ZyVwJtfWe3TlgHvo7OBbr+dQ3plVIBAIBAKBQCAQND9CEKyCdu3acerUKezt7a2i4ODBg+nRowfvv/9+reeZM2cOs2bNsq4nJyfTu3fvSuMc1BpuD41gsG9LBvm2xMukJF+nYPCaeSQU5XIwO4kHj65k5YgH0Daw4Xxj4OGgIbPIic+85zD7P0ORJk8u3aMAhRIkC5a8FHJ/non3B+fQeoc1ynmfu9mdAynF/HUiBYsEb2+9yIlOfnw2+nny18kutoZz27nz4kECxr3GC/kF5BpLSDcU8cyxtfwQf4xPe09gqH9r65xX4kvpy1uOUVha2vfkoJbcHBFWp+Orijn+8O/WZZ9B03Cq5nl5u+Vbl52cnOr0GujNJt47vpn3j2/BaJGzkZQKBW90vZlxbbtWGm8KiSDz1HoAHAxZODfR691D3wJKK1xnh/djfv9J1Y6/3LXp7OzcpJ8JDw+J59J2cW/W05hKG8+HF9p6Oc4/EcPtUyq7NDcm6hGPkBj1LwDFa/4PvzcPWB2p+3l6st1pBgNXfIvRXs5gXZUSyb+ZsbzdbRSPtx9wTZaF1uY9XXEyhUdXRlsbILw5si1zRoTXez6AzA2fUbRtHv/4dmCjd1sAfOyc2DD6YfwcGj9bVm+y/Wjk5mRf6zjzj64idfGDUHpNe97yHL5dh1caN8zNlYDDLiQVySJrsJcvni5C2BMIBAKBQCAQCK5FRMlwFbRp04bo6GhMJhN2dnaEhYVhb2/P2bNnOX78eK3ncXFxISgoyPrw95fdcvt4hzDYtyU3+bXi1S4jiJ3yCj8PnsqD4X1p5+aDQqGghbMnG0Y9hKfOAYANSVHct/03zE3Qo6+u+DrLxhepBYYKTfAlFLR67xROXUqzAs0msrd+3Wjn1aiULJvWk/fGtKPM3Pivk6mMuDga6eE1aHzk0jvJUMTAP19iQ/xu7g6wiX/HspIYtu5rbt/8A+fzMhotrrpwKiWfhfvk3mTu9hpevblNg+c0ZieRf3QVABqvMBw7jqh2fDmjW5R1MDHYnRpLt38+4e2jG61iYGd3f/aOfYLXu46s8hiH8MHW5aLI7VWOaQx6e4WgKLV9OJaVVMPoy1+bTYkhNZq4uWNI+HIKpmxZDFToHPFtbxMvN8Vf5Js9F5s0Dpfed6AO6Q5AycXD5O75tcL+3kHeHLj1MRxTO4FRFpjyjXqe2b+CDn99xOLzh66K+1BjsjkqnTt+PmR1gZ4zpCWvj2zboDnz9i8l9ddnSLRz4b02w6zbvx94R5OIgVC/HoIFJzaQ8MUkKHUKdh/2CD53fljlWJ1KzZyOtmv6oxPb6h2rQCAQCAQCgUAguLIIQbAKdDod/v7+REZG8vDDD3Pu3DliYmKsPQX37t3boPmXDZvOv2MeZestj/B/3UfjbedU5bj2br6svXkWTmpZgPsj9hiP7f3zirsPlwmCOcVG9CZzhX26gHYEPPQjilKnyZx/F2IxNJ7jnlKp4KXhbVj/UF9rT8Go9EJ6r5T4oucvGPs/ZjVNcDq7ldeWPsMaezW9dPbWOf6KO0n7Pz/k9YN/kt3MwuALq05bBbnXbm6Dh0PDy8BzdiyyZva4DZ5pzfa6HJZynx9lLfRAg9nE8wdWMnDNV9ZyQa1SxTvdR3NwwtP08g657LEObQda34+mFARdtHZ0dPMF4GBmAiPXf8PI9d802fnqSvbWbzj/SicKT9hcWZ173k7r988wddobqMpuxXYFPPrnCdaeSW2yWBQKBc4TbOXS6ctfqdTzs0ugK1unTsQprh9kBJa1CeVcXgb3bf+NTn9/zG8XjlzzwqAkSaw9k8qtiw6gN8nPZVafED4e36FBjr+FZ7eTuOBezBK81O4WCkvv4Q+H92VscIcajq4/FXoIqmsWBAvP/kv85xORTAYA3AbNwO++L6t97g+H98NdK99Pf4g+QFI1vToFAoFAIBAIBALB1YsQBC9Du3btuOuuu4iKimL16tV4eXlZy4c9POrfYL6u9PIO4e/h96MtLdNbELmX1w6vq+GopsXXSWddTi8wVNqvdvLEte/dAJgLMsnb/0ejxzCirTeHnhlEr2A3AIoMZr7Yn0bXqFG80uILClxLswWNJYSu/YBF69/ho9Or8CuRS92MkoV5SZH4LX2H7vNm8uDCR/j27/c4fXw95uL8y522QWyKSmfNGVlQa+XpwGMDGt4rTrJYyNn+nbyiVOE2aEaNx1QUBKsXPc7nZTBgzZd8fPJfpFJVaKBvC47d+iyvdBmBpobyUZWjO2r/jgAUxxzAUmqY0xT09QkFwGgxszEpio1JUU12rrpgSI8l+cdHkIx6ADTeLQmes5rgJ5aj8QxGq1LT0V0WM9EVYbZYmPLTIQ4n5DRZTNqW/XDucRsAxsw4sjZ+XmlMrxA31j7QH4escDjfA/Jt972zuWlM/fcXOv31MUtjjmGRri1h0GCy8PPBeHp8up0xC/dTaJCFtDu7BvD15M4NEgMLTmwg/rMJSCYDi4J7csgtCIA2Ll7M7TW+UeK/HBVNRar/8150bjdxn4xFKhWDXfpNxf+Bb2v8QcFJo+PJDgMBMFjMfHKy6YR+gUAgEAgEAoFA0HQIQfAyzJ49Gz8/P1avXo2joyMA9vb2/Pzzz7Rt27BSsroyPKANvw251yrevHt8M5+f3tGsMZSnLEMQIDVfX+UY9+GPWZezNn/VJHGEuDuw4/H+PH9TK5x1tt6Kf+eFMEj9Ad86TMGMLFgpgDFpkazev4gnYnZib5aFTINSzRF7dxaqHHkoO4uOhzbi89N/GPbFNOb8+Aw/7P+bwxkJlJiMDYrVbJF4buVp6/p/x7ZHq2745Vd4ejPG9BgAnLqMReMRWOMxFUuGLz/utwtH6LbiUw5mJABgp1LzRZ+J/HvLI7Rz86l1jJqW/eQFs4mi6IZl11bHE+0HENBEpZgNIXvLPCgVzNyGzKLVeydx7jKmwpjOHqUly0oLaIspNJgZu3A/cdlN5zrsc8d/obQnacbK9zDlpVcaM7ClJytm9EJncoGLEXC+KxTYHKzP5qVxx7af8fjxHbouWcC4lUt4avt6vj55kF0psSQU5lzxjObyZBToeXdTFGHvbmLab0c5kmgzHJnQ0Zefp3azOkHXFUmSyFj5PnFzR2MpyuWMkw9ftpQNW1QKJYsHT8VRo6thloZRbKpdyXBJwilZDCwV6J17TiLwwR9R1LI/5BPtB1pNrr6O3NPk7tgCgUAgEAgEAoGg8bnyDhXNTFFREZs2bUKpVDJkyBCcnat2zhw/fjzjxzdtNkdduD0sgm/6T2bWLtlRd87+lXT1CGCwX6tmj6W8IJiUV3U5sH2LHti36kPx+X2UXNhP4ektOHYYVuXYhqBTq/hwfAfeHNWWP0+ksGh/PFuiMzAotPzP4T7+0I2kvekCjlIxDlIJjlIxjmnFPJKfxCF/Z2KddMTZOSKVywjK0jqwVevAVgtwaiec2omXxo7d45+ijat3nWOUJIlP/j3PsSRZfOgX6s6kzo3Tsy57m60s1v2mB2t1TG0yBF85tJb3jm+2rnd082XJTffSyb3ucWtb9aN457eAXDbs1LGyWUFj0NkjgPg7XsV0FZWxSiYD2f8uBEChtcf3jg9Qau0rjetc7nVt18LM2UhIydczZuF+9jwxEGe7xr9V6/za4j50NtmbvsRSnEfqr88Q8NBPlTLEhrf1ZsvsfnywNZq9F7WkxbqCQy74xIJTDgC5Uh7HivM4VgxkAOdtx/tI/szwHU3XADc6+7vQ1tsRtap5f4vaezGbD7dGs/p0GgZzxc/HwBYePDO4JRM7+aGspxioTzxNyi9PUXhqEwDxdq483/0ujKXX12tdRtC7mtL6xqLIUD5DsGpxz1yQRdzcW7AU5QDg1HUcQY/8iqIOhlWedo48HN6XT05tp9Bk4MszOy/bR1QgEAgEAoFAIBBcndxQguCJEycYM2YMdnZ2pKSkoFKpeO+993j00UevdGi1YmbbPiQV5fH6kfWYJQt3blvM4QnP4N/MWVGtPB2ty+9sOkfQZca5D3+c4vP7AEj4cgphr+5EF9C+SWJy0Kq5t0cQ9/YIIjariB8PxPPDwXhis3xJUvlWfVCq/FAq9PjrYnB3SEblVEyivZrMSzJ5MowlvPv3eyyc9Cpqp9q7aibmFjN72QlWnbb1hJs7oWH9ycooiT9B/sHlAKjdA3GKGF2r406nFFiXqxKaFkbtqyAGPhzel096T8BBXb9+h5qWfW0xxxyo1xy1RalQom1msak6zMV5WAqzAbAL7ozKqep2A+XFomSH07QK6M35JAWnUvKZvuQIy6b1rLdYVR3et75O7q6fsBTnkbvnFxQaO7xvewtjRiyG9AsY02MwpMcQkH6BufnpaH1ao2/biWhdK/Yae/NnViGnpVNYHHMue440RTKfRC8nZLMz/sZc/Mmho0MhrbT56OzsuODSlZP2XUgy2pFVZCCr2EhWkYFAFzvu6RHE9J5BhLg71Ov5JeYW88yKcyw9WTH7Ua1UcEeXAJ4Z0pKepW0H6oO5MIf0v98ka9OX1j6ep539eLjnvWSVCu99vEN4pUvTiODlsUgSX+2Ksa77uVSdjZjy2xxMWfEA2LfuT9Bjf6Cox7U9p+MQvjizC6PFzDeR+3il8whUNZQbX888sns5J7KTK20/lhZDuD6fmHcGVtoXWHSeRIfm/1FPIBAIBAKBQCCAG0gQNJvNTJo0iTfeeINZs2ZRUFDAm2++yWOPPcaJEyeYN2+eVaQpLCxk8uTJPPvss4wYUb1ja3PzSpfh7EuPY3XCGVKK87lz289sHj27xl5ujcmEjr609XYkKr2Q/XE5BAJlUkVSbgkBrrKhiGu/u8nbt4SCY6sxF2YR9/Fowl7dXauy1oYQ5uHAG6PCee3mtuyMyeJkSj5ZRQYyiwxkFhpJzishLqeYuOxiSkwWLJKOpJJ2JJW0gywACTtVHr01B+muPcHCgA4UqHUsN5h46sV2hEx4DfehD6OspvxPkiS+2xfHsytPk1dism5/ZUQb+oU1Tg/KtGWvQKno4DXupVpl+OhNZpYdl1143e01DLgkli1J53hk93Lr+jf9J/NgeF8agsrZB5WzN+b8dPRJp2s+4DpC5eSJLqgT+oSTFF/YjzEzDo1n5Uyxwb4tuS2kE3/FnSTXWIJL0Anc8yLILlDw14kUvt5zkUcHhDV6fGoXbwIf+on4LyeD2UTO9u9sPSmrwJB0BlhJKBAK3O3ghi6kK1nKFsQVl5CgLybVbCRDkjhvZ88mbzlmo0seeW2TePnMWvrmxIGtUpeO/MgYlJxRt2Svpgv7NJ1J17QnUm/m9XWRvLE+kpvbeDOjdzATO/lhVwv33GKjmbnbzvP+lugKWXPBbnbc2yOIR/uHEeRWOVOztkhmEznbvydt+SuY823GRJGhPXmw9XBySh17O7n5sfSmaaib4f7805FUtl/IAqCttyPjO1T+IaTgxAZyd/4IgMrRg+An/6wyY7U2BDq6MjGkI0tjj5NYlMuGpEhuCWqaH3yuBU5kJ3M8O7lCti9AuD6f1jkJVR6T6NCKBPuWzRGeQCAQCAQCgUBQiRtGEDx58iSxsbHMnDkTACcnJz7++GMiIiJ44IEH8PDw4N1337WOLyoqYvbs2Zw5cwaNRnOlwq6EUqHk58F3033Fp8QWZLMjNYaXD63hoyZuVl8eO42KxVO7M/a7fRVMRSQg+P82Mirch/t7BTOhoy9Bj/3OxQ+GU3x+H8bMOOLm3kLYy9tRObo1eZxKpYLBrTwZ3KrqjL70jAzSTTr2XMxmT2w2e+OyOZ2ajyQpKDG7st08nD3Fg2ltv5Uz3lCg1rHewZsJvzxF6m9z0HiFofVtjdantfxv6XKiOoCH/jzF5nM2oSDI1Y4FUzozpv1lshXrgMVQQuqS5yg4uhIAjXeLWpcLrzyVSm6pQDm5i3+FPoZnclKZtPUnTKX97l7qPKzBYmAZusAOFJ39F2PGRSwlBSgv46x9vaFQKHAdMJ20358HSeLccy1l4VahBBRyea5CicYzhPmT3yexKJj9GfHEF2XTPiKa7H0twaLilbVnmdLFH2+nxu9B59z9VoIfX14qCl6+V6bSzhlLSUXDHUtRDsVnt2HPNsKB8EuO2ecWzH/ajyFd50S6zolZXSbzQPwBHo/ZhbacEYkKC51M0XQyRTOreDkmhZqD6o6s0N3ERl1/NkSlsyEqHTd7DVO7BTK6nTeBrnb4u9jh46Sz9v2TJIllx5N5fuVpLmbbnJN9nLS8e0s7ZvQOqXePQBsS51/tXCqOlr02TsTf8iIzCorJNcptFIb7t+Hv4ffj1MR9A0HOhHxr60Xr+sI7ulQSTi0lBST/8LB13fee/6F2bdj9aGbbPiyNPQ7Ad1H7b2hB0JB2nrb6Qn6O/bfC9tyYo8TZteS+dvMqHXO8KJ/O/s5cGzUKgtpiliQGfrGzyn0R/i7Mn9y5mSMSCAQCgUAgqJobRhB0cnLCaDRy7Ngxunbtat0+ffp0srOzmTNnDuPHj6dv3744OjqyZs0aUlNTryoxsAx3nQPLh06n/5ov0ZtNfHzyX/p5h3F7WESzxdArxI2Lr47g7xMpLH33B+t2iwRrz6ax9mwavs46nh7Ugoce+QvzxzdhSIlCn3CC+M8nEvLsOpRau2aLtyqUCgUd/Jzp4OfMzD5y1lZusZH9cTmsi0zj6z0XKTLAmdx+4H0YgOX+EUxIPQMWM8a08xjTzlPI+grzlih0zFC1oJe6DafUrenUczD/uXMQrg4Nf76mtGhi/zebkrij1m2+d3xQq5K/7CIDc1acsq5P7WbL1NyZGsOtmxeRU+o4Oik0gne6164EuTboAjtSdFb+oqxPPot9i56NNvfVjmu/qaQtfVEuKbWYkSy2jLWybo76hJPoP7uVH6b8lzFO7sQWZHMmP4mwCDWxx8LIKTbyytqzfDOlS5PE6Nx9AiHPriFz1X9ROrih9W6BxrsFWu+WaLxboPEMRaHRYcpOoiTuCCUXj1ASd5SSi0espjblUWgdUNm7MMjegbUZJ3nRJ4JNGrlX53chvTkcPpz/C+mDZ2EBLgm7UV3Yjjn+iNV8RS2Z6Gs8Rl/jMV4rWsA6zQD+thvOIakD83bHMm93rPVcSoXc1zTAxQ6TRbL26gTQqBQ81NOfd8d3xtW+6nu5JEkUmPQ4a2q6PiVAgQKpghjoOnA6scOfZPLuP8krFQNvDmjLP8NnYK9u+r8fkiTxyLIT5Ovlz9Uj/UMZ1LLyjyBpy1/FmBELgGPEaFz739vgc4/wb0OwoxvxhTmsiD9NekkB3jeI2H8pFn0hUhXmKnF2LTkuBVd5TGd/ZyL8rz4jJEH9USoVcJk2tseT86veIRAIBAKBQHCFUEhXkwVkE9O7d2+0Wi3btm1Dra6ohQ4ZMoTAwEB+/fXXJjt/QkICwcHBxMfHExR0uc57kJmZiadnzX3qvovaZzUZcdboODD+KcJda+/+Wl+ictNZnXCGXakxhDi5E/vhjyhKP0XHez5GdEZhhfHOOjXPdVYzZdc0pLwUeVuvyQQ9uqTWrpZNQU2vc1q+ng+3RvPlrhj0oQfAXn5ezx6LZLAhBq+SRNzMObU6l9LOCbvQ7jhGjMKl+0S0Ae3r3Ecwd/cvJC16GMkgx6HQOeI/bR5uA6fVeKwkSdy9+DC/H5XLhUe382bNrD4oFAp+v3CU6TuXoC8tc+zrHcrm0Q/Xu2fgpWRmZqI4soSUnx8HIODBH3AbOL1R5m4syq7N48ePExHR+MJ6zs4fydn+PZLJAEhIFossfkkWLIYiDMmR1rHpg2cx0c6XHIMsLulyQtAnhKFQKNj/1KAG9bwro7b3mNpgLszBmJ2AUueEyt4Fpb1LpfJ1SZKYd3Y3zx5Yaf2cOal1fNF3ItNa90CpUGIuzKEo8l8KT2+h4OQGDMlnK50rUeXH39qbWGV3E3GqgGrjGt/Bl7kTOuCh1Fd6rilFeWxOjmZjUhSbks6RWJTLnS26sqD/JFwvKaE1pJ4nbdnLPL3FgIQSBRbedvobh/ZD8b3zI446ejJ6w0KrGDgqMJy/ht3fLGIgwG+HE5n6i/yDRZCrHadeuAkXu4rnLoreS+w7/UGSUOgcafXeKbReoY1y/tcPr+P/jslmKp/0nsAzHQc3yrxl1Pbv5uVozM96dfT8+iEADs7+psL2skyxnU9U7iFYV5rrudSFSZMmWZeXL19ezUgbV+PzqC+XPpeeXz+EpC9iWX5spbEnkvM4LgWzrv1LVc51pbMHr6f3RSAQCAQCQe24YTIEAebPn0///v2ZOXMmixYtQlmuAfrUqVP59ttvr2B0dWdm2z7sSbvId+f2k2/UM2nLj+wZ90QtMl3qhsliZmvyeVYnnGF1/Bmiy/XMAhhtp8Kh2IwERL04lN2x2Xy9J5bfjiRhtkjk6028ccDEUvXL/KR+CZ2pkPwDy0j56XH8ps+7rDCWWJjLpqQodqXFsistlkx9EfP73c5toc2TCenjrOPjCR159qZW3L2miH+L9wMwN2AEc1Nbgj04WQoJtqQQak4ixJxMC3MCHUznaWVOQIFNa7eUFFAUuZ2iyO2kL3sFrW8bnHtMxLnHbdi36lutOGjRF5Ly8xPk7Fhk3aYL7ozX7F+xeLeo1XNZfCjBKgZ6OWpZdGdXAD48sZX/HFxtHTc+uAO/Dbmn0cRAa7yBHazL+sQbq48ggNvA6ZcVQSVJInP1B6QtexkkCe/tC5nfaQzTvDtilCzo3eLAPh0p24+H/zrAgcdHNInBSH1RObrV2AJAoVDwWPsBDPZtyd3/LuZUTioFJj0zdv7ORye38VynIUxt2R3n7rfi3P1WJEmi5OIRcnf+SO6eXzAXZFKsVBPnosXJMYo7OYdG5UiuXStiNOGcMLUhNVeNwaigs78LH41rT78wR9Iv7Od09GH0hanE56ayR+vMDqUdZ6v4Gez3mKPsSzzLdx5edCxIw5QVjzErnqJzu0tLqSeWPRuC56zBqfNo9qRdZPSGb8k36gG4JbAdfw6bjl0ziYHbojN44Pej1vX5kztXEgMtRj3J38209hv1nfLfRhMDAWa06WUVBL+L2sfTHQY1immSQHAtotQ5ygmCVSQDhpRcADtYV8VxIntQIBAIBALBleCGEgR79OjB4sWLmTp1Kvn5+fzwww+4uMjlOpGRkXTr1u0KR1h3vuh7G4czEzmSlcipnFRaL/svt4dGMMy/NUP9W+Nl51jzJKXozSaSi/JIKsojqTiXpKI8Yguy+T3mKElFeZc9Tiq1FCmxU5FnLGFACw8GtPDgndHt+GT7Bb7de5Fio4WTyjAecXiRr/PeQouJ7K1fo/FugdfYFyrNeSgjgQGlJdHlmbHzd/p6hzars7K/ix3LJ44l4PdDGCxmFO6pqDJa4OVgh6ejMx4Owdg5aDE5aMh10hHY2Z92Xiq5pDLmIMWxBymJOYghJco6pyH1HJlrPiJzzUc4hA/GZ/J7KO2cMRdkYMpPx5yXjik/HVNOMgXHVmHKkd0rU7VOHBgwg23+ndiy5Wf0ZhPedo50cPOVH66+1mVfe2cUCgXFRjOP/XnSeu7v7ujMsfyL/N+OjexKi7Vuf7z9AP7X+9YmcQrVBXa0LusTT1Uz8sZDoVDgNe5FtP7tSFxwL5K+kM4n1/Bu60JeCCotrdYVg18Mh80XeXiLiW+Gj74mRZcID38OjH+a5w6sZN7Z3QCczknlgZ1/8NKhtcwO78vD4f3wd3DBPqw76pAuHBw4k58Or2F1ThpFiqo+m+nyww+c1TouYGH0npVIey4ZpvOW/71EDHQy6VEikae2I9ZQwuikWN6I2sRtKVV/TiUUOHe5hV2pMYzesJACkywGjg1qz/Jh09HVwtynMVh+PInpvx2lxCTXJ97X1ZdxVRiJ5Py70GrmY9+6P+7DG7djXQtnT4b5t2ZLcjSnclI5mpVEN8+mNY4SCK5WtD6tOJ6dzH3Bd1XaV+LVgXBjcZXZopfrOSgQCAQCgUDQlNxQgiDAlClTcHJy4r777iM8PJypU6eSkZHBjh072LVr15UOr87YqzUsGzaNHiv+R46hmLSSAr6O3MPXkfK34a4eAQz3b8Mw/9Z0cvcjqSiPiwXZxBVmE1eYU7qcQ0JhDplV9D+6FK1SxU1+rRgb3J6hfq1ZGnuMA5u+B8CiULAgci8vRAwFINTDgc8mduK1EW34clcsX+yMYR9d+I/zs8zN/xAlEmnLXsa+VV8c29nKzCRJYs7+FZXEQIBcQwmP7fmT5cOmN6sg4mnnyO2hESyJOYqkNjBvpk+NhhuO4YNwDB9kXTdmJ5F/ZAX5h/+m8PQWq4FDUeR2jn8wHEtpfzKlJEusCiQUkkScvTtbQ/uyzbstJ528ZUEjySYuppcU8m/KBf5NuVDh/CqFEp1KhUahJj/MDJISJ42GOWdPcj4/s8LYub3G80zHwU32mpoLyp/vhulSUCdcekxE++ou4j4djykrnrHR/+JVkssffaaxITMJCxKoLCyM30zchni+G3gHQc1gztPY2Ks1fNXvdiaFRvDe8S1sTj4HQGpxPm8d3ch7x7dwR1gXnDU6lsYes92XqhQDK5JfKs5Vh9pipkteMn2zL9I/+yKd8lPI1DjyfIexHHILwqhU82q70Zxz9GLOhe3YuQfhMewRpB8OAmBSKRi94VvWJ9rKvMcHd2Dp0GnNIgaaLRKvrDnLB1ujrdsmdfbno9FhVY7Xlyu99prwqmxk08j4lOsbWFY6LRDciERc4jJdnkiNQzNGIhAIBAKBQFAzN4wgeOHCBdzd3XF3d+eWW24hKiqKb7/9lsOHD9O2bVv279+Pl5fXlQ6zXrR09mTHmEd548gG1iScoaSckHY0K4mjWUnMPfVvNTNUj1qhZFJYZ6a27MZw/9Y4lnPNjPDw5za9rdT6f6d28FSHQRW+GHs56XhzVDjP39SKR/88wU8HB/CZ+V6eKfoZLGYS599Fy7ePWB0v1yScYXuqLG51cPNl4YAptHL2pNuKT0kqyuOvuJMsiz3OlBZNY7BwOV6IGMqSmKMA/N+xTYwNbk+Ag2utj9e4B+AxbDYew2ZjLsol/+gqlm1ZyCcuQZxxrrvbZwsnD9q4eBGZl87FguxK+82ShSKTBTBCaRVhASUUlKtM6uoRwH97jmVU4KX+sI1L7t4l1mWnLuOa9FzXMnYhXWj5xn7i5t5CSdxR+iQcpV9WDPEDn2RMkhMmrzQANiRF0envj/my723c26rHFY66fgwLaMOwgDYcykjgf6e383vMMYwWM0aLmV8uHK403sfOiSlhnRng2wIHlYaMwmyS446RfOEgibkppGudyNA6opIsOJoNOFhMuLj44uTkhYebLx4uPvRwdqe/Ro1dYRamvDRMuSno447imHKOpRozH9npmF8ii4o/Bvckuffd/D50GnGF2Rh+OYzWaEGvVVUQA28JbMeyodPQNoMYmFloYOriw2yISrdum9k7hHmTIsjPrXwPALAL6WpdNiSfhS63NGpMqcX5LL94AgA/e2f6eTdeObJAcK0xv/+ky+4r6zMdDqB0AAEAAElEQVQpEAgEAoFAcLVwQwiC0dHRDB8+nE8//ZTbb78dAA8PD/7zn/9c4cgaj07u/iwfNp0Sk5E96RfZnHSOzcnRHMiIxyxdxvKuFHuVhmBHNwIdXAhwcCXAwYXA0n8DHFxo5+qDZzWlx8pyCV/JxXksPn+ImW37VBrnqFPz+cROrDqdynfSJHqYzjDYcBBTTjIJX08l9PkNWFDw4sE11mM+7DmWfj5hAMzvN4lbN8t99B7f+xfD/FtXG1dj080zkAnBHVkRf4r4whwGrv6KTaMfpqVz3Ztw78rL4OXsbHYF1l7MUaCgh7s/t7fswoTgjnRw87Vm9BUY9UTmpnM6J5XTOamcyU0lo6SQErOJErORqIx8jJIZhdKCs52Kzh7+/CdiKGOD6m5uUlckSSJvX6kgqFTh0mtyk57vWkft5kfoS9uI/3Q8RVE7sBTlErjh/9iucORD70ls6RhCnlRMrqGE+7b/RlpxAXM6DbnSYdebHl5B/Dx4Kh/1HMeCyL3Mj9xDarGsWjtrdNweGsHUlt0Y5t8a9aUmRB3kDNzimINkrHiH/IM/oXYLwH3ow7jd9CAaN/86NcqfB/Q5d4CHdi/DYDGzIfkcIUvfId+oZ5RaidZou5e2dfHmwbZ9eKLDwGYRA48m5nLbDweIzZKdwDUqBV/eFsFD/aoX4BzKZSkXRe3Ac/QzjRrXt5H7MJY6Zz8c3rdZXguBQCAQCAQCgUDQcK77/7mXiYFvvvmmVQy8nrFTaxha2j/wHSDPUML21AtsSY4msTCXQEdXQh3dCXFyK/3XHU+dQ6OKQh+d3MaMNr1QVlHi52qv4dURbZiz4jQvOj3N6sLncNenUHR6C+l/v83qiLGczJGdiIf4tWRMUHvrsRNCOnJXi64siTlKWkkBT+//h58HT220uGvDvH63czY3jai8dGIKshi4+is2jnqIju5+tTr+cEYCrxxey7pyGUYAPTyDCHF0w4KEJIEFi/yvJOGs0TEqMJyxwe1RFxmqFDecNDp6eAXRw6tqF86J3+/nn1OpSMDp10cQ6Gpf5bimwJR4wto/0bHjCNQu3s127msVlYMrIc+vJ2XxU+Ts+B4sZlylQt5N+4msHBe+HvQgv8gaDM8eWImTRsdDNZSwX+34ObjwRreRvNR5GJuSzmFBYrh/m1q59dq36EnwU39jLsyWXY4b4F4+vU0vwl19uG3LD6QU51sNQ8pQmyzsGPMYA3zCmq1twZozqUz+8SDFpYJkgIsdy6b3oF+YR43Han3boHLxwZyXRlHUTiRJarS4jRaztT2FWqG85j+DAoFAIBAIBALBjcR1LQiWFwNnzJhxpcO5Irho7RgX3IFxwR1qHtxAVGb5y2pkbjor4k4zMbRTleMeHRDGZztiuJgNj9g9y2/Gl1FYjCSsep/Ximzlzh/0HFvpi+vnfSeyKekcGfpCFp8/zN0tujEmuP2lp2gyAh1d2T7mUUZt+JZjWUkkF+cxeO081t08i17eIZc97lR2Cm8d3cDS2OMVtnfxCODd7qMZU8tMvcyizBrHVEVHP2f+OZUqx5KS36iCoDE7ieIL+9F4BKEL6IBSV7FPUsmRv6zLrn0qN1oXVI1Sa0/AA9/gNf4lLvz5HsW7f0SHEQ9DHi9vnot/aF8+bjEAgNm7l+Os0XF3y2vPGOlStCp1va9plaN7o8TQ1yeUA+OfYsrWn9mbfpH+PmHoDLEA6IwWBvrWzt27MTiamMsdPx2yioEDW3iwdFoP/Fxq5yavUChwaDuQ/IN/Ys5Px5AShc6/cVoE/BN3ksSiXABuD42oUwuFa5FHdi/nRHZylfsiNQ6EG2vuwyu4sZH0RcS8U9lU5IXkPBLsWwKV9wkEAoFAIBA0FY3fXfwqQYiBzY/GZKsd/uDEViSpavMInVrFO7e0A+CEJpwlgbLr5eKAriSWZuNMDutMnyp6UXnbOfF534nW9Yd3LyPP0LxN7H3tndk2+hH6l5YyZ+mLGL5+AVuToyuMy9EXszbhDOM2fkenvz+uIAa2dvbityH3cHjC04wN7tDkmUad/GyuzKdS8qsZWXuKonaR8OUdnHs2lITPbyPmzV6cfdiZ6BfbkfDlHaT/8w4FJ9ZTcmQ5AAq1FucetzXKuW8ktN4t0E3+jJEe37LIfiIGlSzmzri4l0di5ewsCYn7tv/Gijjh4NxYBDm6sXvs4+Tc83/sGvs4anPzm+Ek5ZYw7rv9FBrkdNB7ugeyeXa/WouBZTi0sYkMRVGN42YqSRJfnrEZcT3efkCjzHs1cyI7meOXEQTDjUWEG4ubOSLBtYRS54hCV7WxSGDReYKKL1S5TyAQCAQCgaCpuC4zBIUYeGVQWSR6egVxMCOBvekX+TpyD7PD+1Updk3tFsjcbec5mpTHO0XDsOuUzKdewfI8koU3Qi6f0XhXi678duEIK+NPk1CUy4ydv/PHTfehagL3zMvhprNnw8gHuW3Lj2xMiiLfqGf4ugVMDotArVRxID2e6PyMSscFOrjyRtebub9NLzQNKGusKx39nK3Lp1MLGjSXuTiP1F/nkLP9u8o7JQuG5EgMyZFwYGmFXU6dx6C6zjOImgq1UkGG0oOPHR8gp88TvOu6jYxV7/NY7G4Ktfb8FNAVs2Thjm0/s3PMY/QsvZYEDUOhUOCqbb7y+vKYzBam/HSQxFz5B48hrTz5/s6uaNV1v8/Zt7aV8hZH78F9yMx6x5VUlMsP5w7y0/mDRObK5iad3f2bNWvyStLZ3Z+dYx+vtL2qrC+BoDxan1YAtJj9TaV9Jx7r3NzhCAQCgUAgEFx/gmBGRoYQA68gr3QewW1bfgDg0T1/sjTmGHN7T6CbZ2CFcUqlgg/HdWDkdzvAP5pX3WwCxtCMaDRzR1H4xDIc2w+tdA6FQsH8fpPYkRpDjqGYPy+e4OHdy/h2wJRm6+kF4KjRsXLEA0z99xf+vHgCCalSSXAZrZw9ea7TEKa37lWrnmiNjUZle11MlvpnOhWc2kTSwgcwZcVbt6k9gnDtdy+WohxK4o+hTziBpaSy6Og2ZFa9z3uj46izicdpkhM+t7+NZDaRuep9XojaTImzL384+6M3m5i89ScOjX+6WQ13BI3PB1uj2R0rOwe39nJk+fSe9RIDAXJ3/WxdVjl71Tumnakx3LJhIQWmin0VX+o8rFnvvQLB9UihwczAL6rO4I3wd2H+ZCEaCgQCgUAgaFyuO0HQy8uL5cuX07Nnzysdyg3JrSEdeaHTTXx4chsAW1PO02PF/5jWugfvdB9NkKObdazRIQOHDkcokmxlVhPyk3kpcgNmk56LH43E794v8Bg2u9J5Ah1d+WvYdEZvXIjebOK7c/s5n5/JF30n0sndv6mfphWdSs0fN93H15F7eOfYJlJK3VGd1Dp6eAXS0zPYao7SnBmMl3KmXFZgOx+nOh9v0ReSuuR5srfMt25TOrjhd/cnuA64D0U5Z1HJYsGYEUvJxcNkb/uW4otH8Z7wCs5dxzbsSdzAuNtrUCsVmCwSaQUGALxvfZ2CoyvRJ5zklcO/kTj8eXaZzFwsyOae7b+yesTMK/qZE9Sfwwk5vLleNuJRKxUsubc7no7aes1VFLXLet0qHVzxGPlUveY5mpnIuE3fWcVApULBzQFtebRdfyaEdKzXnNcT5zMKKTKaue8SQed4cj6d/Z0vc5RAIOOguXzFwPHkxmnzIRAIBAKBQHAp150gCAgx8AqiUCj4oNc4Bvu15PkDqziTm8b/s3fX4U1ebwPHv7EmdXeHlmLF3Z0NGDJgGzJgwMbGmO+d/ubuPtgYgzFgMGRjuLtrW2ihFGipu7fx5/0jJaW0heJ2PtfVq8kjJ+dJ8kTunHPfEhJ/JBzk77NRvNS0O0817Mg7R9bzW/y+yh2NKkgLp3Gzh/GnnOJD/4DJSMYfT6FLOYbPmG+rBJ0AeviG8XePR3lw8x+YJDNbM07TYvk3TG3Yifdb9sdFfXOm+inkcp5u1JnHwttyMCcZD409EU5et1Uw5kTW1QcEzbpSkj7vR3nCbusyh2b34/vYTFRu/tW2l8nl2HjVw8arHk5tR5Cbm1tjZWSh7mQyGV4OatKKtGQWVwRkbDT4T5nHmXfbojQZ+HjHdB7p/hzp+nLWpZ7ktUOr+KjV/dgo7sqX+btWucHE2AVHrCN53+nXgNaBLlfVlmTUkz77Cet174c+Q+Vy5T+YnCrMpv/6mRRW5GsdFNiIXzqNuOuLiFyJMoPJmuvxQs18HYn0daphD0GoVN/DMqJ75zPVp57XNmpQEARBEAThWolvisINMTCwMf39I5gZv493jqwjW1tKucnAh1Eb+TBqY5Vte3lFsGuXBzqdkk93ZtB98s+0CmhKzvIPAMjf9BP6jJMEPP13tSqig4OasKH/E0zds4wThVmYJDM/xO3krzNH+KTNACaGt0UuuzmBOTulDd186t+U27pScVmVIwwaedc9IGg26Ej+bpg1GCjXOOI9+htcuk0UUwRvMi8HG9KKtGSVVE7X1AQ1x2v4B2T9/RoeumK+PbWBMSHdMEpmvjy2jT9PH2ZSeDueiGhPsIPbLey9UFdvrI6zjujtEOzKa73CrrqtnFWfoUuLBcA2vDMu3R+/4jZSSgvou/5XsirSAPTwqc/iHuPQ3ILUB7c7extFjQEdQRAEQRAEQbgd3T5DmIS7jlKu4KmGnUgY/jqvN+uF+qKRSs42Gv7sNoqNAybz7aCW1uVjFxylrMdr+D/1FzKVpZpm6fGNnH2vPWWndnOxnr5hRA15kS/bDsJRpQYgR1fK47sW037l9+zNSrqBR3lnOD9CUKWQEepWc5XDi0kmI6nTR1F6fAMACgd3Qt/ei2v3SbckGJhaWshHURtp8s8XtF3xLetTT970PtxK3o6W53ap3kSpzmhd7n7/y9g2sAQhmp7dxwdUBgwzy4v5OHoT9ZZ8wgMbZ7E6OQ6T2Vyt7XKjgdTSQuIKMik3Gm7wkQi12RSfzbfbzwJgZ6Pgz9EtUSqu7m26/Owhspe/b7miUOH32K/IrnDUco62lH7rfiWpxJLLsI1HAMt7PyaCgYIgCIIgCIJwFxAjBIUbzslGw8etB/BkREfeOLSGJUnR9PULZ3rH4dacglM6BrPpVA5LotPJLTMwdPYBdj8zgpA36pP83RCMBenoM0+R+GFn7Bv3xmPwm9g17GENTNkolLzUtAdj6rXitUOr+SPhIAAHc1LotOpHZnUZyWPh7W7VXXBLSZJkDQiGedijqkOAQTKbSfttomXqNpaRgUEvr0PtX3v15xtlXepJvo/dwdrUk5ilyoIo/dfP5IHAxnzQ6j6au/nd9H7dbF4OauvlrBI9oWrLy7dMrsD/8T8481ZzzNoSBm/5nvZPLuJ3g5G/z0ahN5swSxIrk+NYmRxHiIMrgRoniswGcrWl5OrKKDdVBgFVcgVt3APo6h3K5AbtCXf2vOnHei8qKDcwYeFR6/WvBzcmzOPqCsOYdaWkzhgNJkvg2HPIW1d87hbptdy/YSZxhVkANHT2Yk3fx3Gy0VxVnwRBEARBEARBuL2IgKBw0wQ5uDKv+2j+MD9SLb+eTCbj94dbEJtZTGxmCVFpRYyZf4Ql49sQ+s4Bkn94EO2Z/QCUxm6iNHYT6oBI3Po+i3OnMchtLPkCfeycmNP1EaZEdOCZvf9yKDcFCYkpu5fS169BlaIm94rMYh0lOktuq/rudQsw5K76jMLdlsqkMpWGwBdWYhva+ob1sSYlBh3P7VvO76f217rNiuRYViTH0sEzmCcjOvBQaItbUsX5ZvByqCwqsTsxj1D3ypGeNl718B79Lem/Wyo5+y96kTmfxPJNuyHMPrWfGSf3cqY4F4DEknwSK0Z81cRgNrEnO4k92UksOHOEsyPfQCmvPeG9cO1SCsoZ/Pt+UgotOfoGNPLiiQ7BV9WWPvssKT+MQJ9hKUpiG94Zj0GvX1EbpwqzGbZ5DscLMgEIsndhQ/8n8LjHK1efzi2ttRLs03oT9jbiPBEuLTo/nS6rfqy2XOvRmAhDOfNvQZ8EQRAEQbh3iYCgcNPVVmzDUaNk+cR2tP12BwXlBv49lsHz/x7j+2FNCX1rN0X7FpG9/AP06ScA0KXEkD77cbL+fhXnTmNQOvsiU9sht7Gnsdqejf4hPCOTmJeTisFsYnXKCZ6I6HAzD/W24GyrwlYlp9xgZtfZPMr0Ruxsaj/1yxL2krXsLcsVuYKAZ5Zh37DbTeqtxcGcZEZvm8+pohzrsjBHDyY1aMe4sNbsyUripQMrrFMZ92YnsTc7iRf2/0c7zyDOT2he0+/Kc6bdrnqEefDVtjMAPLU0hlYBzjTyrqxe6tJtIsWHl1NydAXG/FSyFr+B77gf+b/InrzUtDsb0k4x/cRuVibHYZLMOKrUuKntcFfb4a62x11th1qh5HBuKsfyM5CQSCkr5GBOCh28ri44JVzegXMFDJm9n/Qiy1RvLwcbfnuo+VVNyy+OWk3qL2Mxl1rOC7mdC/5T5lUryFSbcqOBL49t5dOYzZRVTB330jiwof+Ue/LHlIvZFZ3DyVTOK/ELq63zNyaSb9/gFvRKuFNEutZe0Oekqm6pPARBEARBEK4nERAUbithHvb8+1gb+v2yD73JzI+7EglyteX/eobh3HE0Tu0fpvjwf+Rt+J6yE1sBMJXmkbfhhxrbG2bvyby24wDYmBZ/TwYEbVUKxrYOYObec+SXG1hwOJXJtYw+MpUVkjp9FJgtIwq9HvwAx+b338zuklicR4810yk16gFLrsmfOzzIqHotrUGS4SHNGBjQiAVnjjDj5B4O5CQDkF9RYfduNLCRF4+1DWT2gWSKdUaGzT7Avue64mxrGREpk8nwHT+d0ye3YS4vIn/zz7j2egpNQBPkMjn9/SPo7x+BzmQkLy8PX0+vWm/rj1MHmLBzEQAb0uJFQPAGWRyVxrgFR9AaLXkdG3jas3JSO3ydrmxarmQ2UbLmE0o3fGVdZuPXiMBnlmHjGXL5/SWJpUnRvHxgpTXIDtDCzY9lvcYT6iiqhAOozVpsJF0tVYNb4hcQedP7JNw5pncaXuu6NjOeqHWdIAiCIAjCjSICgsJtp3t9D+aOasEj8w4D8MrKOAKcbRnVyh+ZXIFTm2E4tRmG9lw0eRu+p3DPfCSDtsa2GpRm46YvI8/Gjo1J0RhNJpSKe29a1zNdQpm59xwAP+xMZFL7oGojkCRJIn3OFAw5iQDYNe6F+8BXbnZXmZNwwBoM7OwVwvzuo2uskKtRqpjYoB0TG7TjUE4Kv5zcw19njlJi1FXb9m4gk8n4eXgkMRlFHEwu5GR2KSPnHuTlHvXpEOyKk0aFys0fzwc/IHP+cyBJ5G/8Ad8JM6q0o1YosbnMFOB+/hHWy+vT4nmrRd8bckz3KkmS+HDjKd5eWxm87h3uweJxrXG1s7nEntUZS3JJnT6a0mPrrcuc2j+C38SZyDWXrygenZfGc/uWszXjtHWZSq7ghcZdeadlP+yUV9afu51eriH0f9WnDAuCIAiCIAjCnUYEBIXb0sMt/Ukp1PLyilgAxi88go+Tmp5hHtZtNEHN8Jv0G96PfIE25RiSvgyzrtT6J+lK0Wcm0CEjidXejciXYNOCF+k35psrrrZ5p4v0daJ7fXe2nc4lOr2IHWfy6Fa/ctSPZDKS/e97FO2zjApTOLjj/8SfyG5y7jhJklh0NsrSB5mcf3pPwLMOQY3WHgH86jGS6R2Ho68Y3Xg30qgULBvfltbfbie7RM+G+Bw2xOcgl0FzPyc6h7jRNeB+mtq+A+UFFOz6E/N976BVOlGqN1FmMGE0malnX73S8IV87ZyIdPUlJj+dvVlJFOm1opjEdVJuMDFpURR/HUm1LnuqUzDfDW1ap4I/FzIUpJP0WW/0aXGWBQolPqO+xrXPtMtOOU4vK+L9oxv4NX5vlWI9gwOb8GXbQXd1MZmndi8lJj+91vWRrr6XHM0lCIIgCIIgCHcDERAUblsvdq/HuYJyvt9xFoNJYtjsA6yf0oF2Qa5VtlPYu2If0bXWdu777wtW51qS46+N30vTmePxm/T7De377eiZLiFsO20pLPHDzrPWgKA++yypM8ZSnrDbuq3f43NQud78yr0x+emcqKhq2ss3rE7BwAsp5HJs7/Jgb6CrLUvGtWHw7/sp1FqqyJolOJJaxJHUIn4EXqInE/kHSV/Gm++9yR92w6q04eNgw9opHWju51zr7fT1CycmPx2jZGZrxmkGBzWxrpPMJowF6RhykjDknkMyaHFqN7JOI9LuVZIksflUDq+vPsGB5AIA5DL4dkhTpnUJueKcgYa8VJI+62UtHiJ38iHo2aXYhXeqdZ8zxbn8kxTDP0nH2J2VhERlILCRsxfftB9C/wtGh96tYvLTic5Pp1kNOd2iLxEoFARBEARBEIS7iQgICrctmUzG14ObkFqoZWl0OoVaI51+2MWrPevz/n0NUcjr9gV6SK/JPLv4IwD2ugZRuHseprJC7Mb8eiO7f9sZ0sSHQBcNyQVa/jmWQWp+KXbRC8n860XM5UWWjRRKvB/5CscWg25JH8+PDgR4KLT5LenDnaBbfXfOvNmbrQm57Dybx86zeRxJLcRolkBh4OcGzSkqyuaZs7sYpV3Nn7aDMcsqR3tmlOjp9tNuVk1qR5d6NeeH6+cfwdfHtwOwOnoDrdd+jiEnEUPuOQz5KWAyVtk+b8P3BL26EaWDyDd3sQ0ns3l5RSzR6UXWZU4aJYsebc19DWvP5VgbQ14KiZ/0wJBlmeZr4x2G05Rl2NWvnsNOkiR+ObmHGSf3EpWXVm29i40t77Xsx1MNO6G6h6pJN3P1ZefAadWW11QBVhAEQRAEQRDuRiIgKNzWFHIZf45uSV6Zni0JuZjMEh9vSqCg3MiPDzat06iaIAdXGjh5El+UzUHnAA45+9P66AoUzVZB70k34ShuD0qFnK6h7iw4nELP8t1kfvASmtx463obnwb4P7kA29DWt6yPm9JPWS8PC2p6y/pxJ3Czs+HBZr482MwyyqlUZ2R/cgGvH/6PfaXFzHRtT/OiNHrmnmG+7R/sbvUOtmobdp7NY3diPkVaIw//eZjE//WucapquFPl9PytZw/z7ME/L9kf7bmj5G34Aa9h717X47zTncwqYcBv+yzB2gqNvB1YMq4NjX0cL7Fn7dJnP1EZDPSNIPjVzRSZ1TVuOzN+H0/tWVZteUs3fx4MjmRKww5XPBJXEARBEARBEIQ7nwgICrc9W5WC9U904NvtZ3lzzQn0JjM/707E31nDG33C69TGY+Ftef3QaoxyBc81GczCw/NxqCiecS+QJIlzx/fitu8XFpfuoLHpTJX1Lt0fx2fMN8jV9reohxbemsoASXxRNh01t7Y/dxJ7tZKeYR4oTpZBqWVZtsZSDbVZyr90CbTDf/IcdJKc/jN2sT2xkLQiLf/EZPBQi6rTw3UF6Yz75zPOv0U0LMmyrlO6+KJyD0blHoRZV0pJ1CrrOo1/E4SqXl0Zaw0Gdgpx5ZWeYQxq7F3nEc4XK4vfRUn0GgBUHiGEvL4NpbM35OZW2zZfV8Ybh1Zbr3f1DmVYcCTDgpoS4li9UI9gEZ2fXuNIwUQ7R0LKim9Bj4R72eikLwkoP8PZD2uqbg2agEh8J0y/yb0SBEEQBOFuIAKCwh1BqZDzcs/6BLvZ8vCfh5AkeHPNCfycNExoF3jZ/f+vaQ92ZyWyIjmWfBs7no4cxj8XFZ+QJImDOcnMPX2If5KOUd/RnZmdR9LgDk2ubyzJpfTYBkpi1lISsw5TYQZPXbSNXeNeeA3/CLuwDrekjxcbXa8l/yUfB2De6cN09Aq5tR26A33aegB91/9KoJ0LTw1/h7yfH0Yy6inaswBJX07A1IW81i2Q7YmFAPy8O9EaEDTry8lb9y3vH1nLrsC2APiXF/J24TkCpi3BocUg5CrLSDTJaODsh5X56tz6Potj2xE3+WhvbzvO5LL8uCV/abCrLZue7IhGdW3TcrOWvWW97DXiI0swsAb5ujKe2L2EXF0ZABPD2zGry0PXdNv3gsga8gqeF1JWTHB5yU3sjXAvOamyqzEQnRfkTuNiHV9I1YPRuuTom9E1QRAEQRDuUiIgKNxRRjb3I71Iy3P/WoJGkxdH4e1ow/2Nav5SfJ5CLmd+99F0XPopx8tLSLD34Bm9gY1mM+nlRcw7fZi5CQeJK6wcCZVaVkir/77hhw5DmRDW9oqT/t8q2pTjZMx/lrK4rSDVXE3Wpn5HfIZ/gEOT3je3c5fxQFBjHFVqig06Fp09yjftBmOjEC9TV6KrTz0yHn4HB5UNSrkC+xdWkvzdECR9OcWH/iH5u6G0GvwxQ13SKMo8h8+xHI7/vhhnfRZlJ3ewxyTxU4uRACjNZn4PCqflEz8hU9pUuZ2cVZ+iPXsQAHVgM7wf+eKOOUduBkmSrFXSAT4e0PCag4GlsZspi9sCgNqvMU7tH662jcls5rf4fbx5eI01GOik0vBx6/uv6bbvFZeqLvzf081uYk+Ee0mEoRxJV4Y2uazaunO29oAfoc/Oqrbu7IddbkLvBEEQBEG4W4lv2sId59mu9Ugt1PL5ltOYzBIj5x5iy1OdaBvkcsn9HFUaFke0pev+leTa2LPVLNH03y85WZhdpdrmhUqNeibu/Ju1KSf5pdMIXNS2N+CIrg/JbCZv449k/f0KkkFXZV2xzJ7dqubssmnFS09MoWPz2zM/n53ShuHBkcxJOEiuroxVKXEMC65eKEG4tAufpw5N+xL00lqSvxmIWVtCSfQaSqLX8NGFO2yDIiBPZcsrbR7FLLPkFPy4RV/61RBI0iYdJXv5+5YrChX+T8ytFjC81/19NI395woAaB3gzCMt/K+pPUmSyFpaOTrQ88H3kV1UBGRn5lme2fsPRy8oHuKoUjOn68N4215dvkJBEG68Lx0d0KbEQA0z0gc6RaCTa25+pwRBEARBuOuJgKBwR/pkQCPSirTMO5RKqd7EwFn7WPd4B1oGOF9yvyCNPd8d+4/HWozEIFdy4oIRgTJk9PELZ1xYa+73b8h7RzfwQ9xOAP5OjGJvdhILuo+hs3foDT22q2HITyNt1kRKY9ZZl9n4NMCu9XCei/Pln8JATDIF/+sTTsfmDW9hTy9vXFgb5iRYRp59cHQjQ4KaIJdVL3oh1J19w24Ev7KJpC/7Yy4rqHEbM/BGw/vJUlsCRwMDGvFSq/7VtzPoSP11nLXKsOfQd9AEiYrQF9IZTby2Os56/csHGiO/ypyB55XGrKM8YTcAmqAWOLYeZl2XUlrAc4eWsyw1tso+E8Pb8XHr+0UwUBBuc5fKAZjy28c3sSeCIAiCINxLREBQuCPJ5TJmPdSCrGI96+OzyS7R0+67HUzrEsJjbYNo5ldz8m1kcloWpfHByfW80WgAZqChsxfjw9owtn4rAuxdrJt+32Eo/f0bMGHHInJ0pZwrLaDbmp95t0U/3mze+7YJUpXGbiblp4cwlVQUFZDJMN33Cg4D/4/PN2ewpOgMyKBNoDNv92twaztbBz186tPBM5i92UkcyUtlaWIMI0NFwOla2dZvR8gb28le9jZ6owl7n3qsSlOyNEnGaQdn0hqWUSLpAfC3c2ZO10dqfI7nLH8fXUoMAJrQtngMfPWmHsftzmyW+HDDKRLzygEY1NibHmEel9nrMm0adGQtft163TI60PLYzDt9iCm7l1BmNFjXt/cM4vv2Q2nnGXRNt3u3yjl3ArmhvNYpwOXuDXn4/b9vcq8EQRAEQRAE4eYSAUHhjmWjlLNkfBvun7mXXYn5GM0S324/y7fbzxLp68iYVgGMbulPoGvl9EmZUgXAA5lxtPBrgu+474h09a0199nAwMZED32J8TsWsiEtHrMk8faRdUTlpfFH10ewryiwUBud0cTquCzmHUrhUEohj7UN5M0+4SgV1yeYaCovJuXnhyuDge7BzLv/DT5PTcC85BOkEhdw9sFW6838Ma1QXafbvZFkMhkvN+3OiC1zAfjz9CERELxONIGRBD73D7m5ubi7u9M5s5jJn2+FgKNQEQwEeKZRZzxqqPBs1pWRu/YrAGQqNf5P/MHqtHjWpcbTwMmDlu7+NHfzw+Ey58XdRJIkTmaVsDkhl80JOWxJyCGvzBKcU8hlfD6o0VW3rUs/ScH2WRTs/ANTkWU0s6ZeOxxaDEKSJD6O3sT/Dq+1bu9j68hnbQYytn6r2+YHi9uR3FCOjVlb4zqf0gTitUa6/LCz2rqn9Sbsba4tD6QgXI0yvanG5+Qr6UXYqRTcfvMWBEEQBEG4E4iAoHBHc9Qo2Tq1E59tSeDDDafQGi1FNGLSi3ltVRyvr46jT7gHM0Y0o567PZqgFiicvTEVZhJ4ZAkhg15E5uZ3ydvwtXNibb/JfH1sO68dWo1JMrM0KYaE4lyW955AsINble3NZondiXn8eSiFv6PSKSivHLnz7vp4Np7KYf6YlgS52l3ydrOKdXy6OYGotCICXTSEedjjrZZoGaogzMMeF1sVeWu/xlScA0Bqswd4OaQr0SnxlY04FIBDAZL8NJ+fLGeCuS2dvUJu++IPixMrKye2F6OcbpiG3o6MaxPA3DOpYF9oXf7W4fWcSZPT2jkUOxsFdioFdjYKXNP34ViRn1LZYTz/SznNl8e3VmlThozwiuBgSzc/uniH0ukOeM5didiMYnYl5rHttCUImF6kq3G7l7rXo6GHLdqUY2iTjqBNPIw2OQqZTI7avwnqgKaWP/8mKGwto5rNulKK9i8mf/ssyuOrBgBkKjU+o7/BKJmZsnsJs08dsK4bF9yCH7qMwMlG5BqrC71cw+Cfqldo3fh8SxoVxvPKianV1vkbE8m3v/1HWQt3F2sQurz6ulK96eZ2RhAEQRCEu4oICAp3PKVCzpt9GvB051CWRqcz71AKW09bRsxJEmyIz6HdtztYMr4NPcI88BrxMemzJgGQMe85Qt/ea51+Vxu5TM7LkT1o6e7PyC1zydeXE5WXRpv/vmNpr3F086lPbqmeb7afYf7hFOt0wZrsPJtHi6+2M+vh5gyL9K22Xmsw8d2Os3y08RTFOmMNLVgCfvXUpSxK/xwNMNe/NV+4REBRpmUTswwMGlBb+qE1G5h1aj+zTu2nvqM7LzXtzpMRHW/LIM2s+H0sOnsUAD87J55v3PXWdugu99tDzSn508iyOA/wjwfHPAySkV/TVsH+hlDoZd12ctliXgAKlWqGlDiSfVEwEEBCIr4om/iibOvjOCm8HTM6DUcpv3Wjq7QGE3qTGUkCCcvIPst/y3qlXIZKIUOlkKOUy6znRpneyIHkAms7EtDki6213o63o5pJrgncp9+N/8F4Tvwbg2SoPhqtNHZTlesq9yBsvMMpP7Mfs7ZqZQGZSoNT2xG43/cSWp8IBq//jU3ppwCQy2R8224Io70biWDgddCkRQe0Kfa41bi2JX4BosiRcHPVd7eM1t45sHpF4f+erv019akl0cSkF9W4LtLXiekjRNVsQRAEQbjXiYCgcNdwsVUxqX0Qk9oHkZxfzl9HUvl1bxKnc8vILTPQ95e9fD+sKU92mUD+pp/RJh5Ce/YA2cvewmvER5e/AaC3Xzj7H3iOIZtmE1uQSY6ulN5rf+HtpgOYs97EmdyyKts7aZSMbObH2Nb+2NsoGT3/MAk5peSXG3hwzkGmdgrhy8GNsVUpkCSJxVHpvLoqtjKgKDeC0gBGGzBX/eA/InchhSoFzzQcwV7XYDhfKVlrDykNQWvP4z3cUHlk8deZI+TrLW2eLs5l6p5lFBt0vBLZ85ru8+tt+ondTN2zzHr941b3X3ZatnBtVAo5Cx9tzYS/FCw4orIEBV0zQSZBQJzlOZhvGUXb0nCCBDt3nmk6hOzzA1zNMsish7ONhkc6OnGsIJ2ovHRKjJWj5mad2k+WtoSFPcZid4OrERdpDcRllnA8o5jjmcUcTc4jPldLSmHNU0Rrcz5AqDdJmMwSw4Cawucutip61HenV5gHvcM98Dk+j4y5TwNwJbdoyD2HIfdclWWa4Fa4dJ+Mc4dRKOxdSCrJY8DqH4ktsAT+7ZQq/uo+lsFBTcjNzb2i4xNqdqniDoJwJ4lJLyI6vZhmvlWLCkWn11DKWBAEQRCEe5IICAp3pUBXW17pFcZTnUJ4dMFhlh/PxGiWmLo0hpj0Ij4d/R0pn3YHs4mcFR+j8qyHa/dJdWo7zMmDPQOf4dHtf/Ff8nGMkpm3Y1aCjS/IwlDJFQxo6MXY1gEMauyNRlUZyDv8QjemLotm3qFUAH7enciOs7m8068BX287ze60NLArAr8iy39NqXVfO4UN9tiixhaFzkxKRjHDfMZRrKwYFSRBI0Ujunm2xj1YTbd67vSL8EQmk/FV2wdYkRzLHwkHWZViqX766sFVBNg5M7p+q+t0r1+b747v4Pn9y63X/9e8D+PC2tzCHt07VAo588e24p3+DUgv6sw38RtYnnHIEgHzP8XASDc62jZDu0nHqLDRlFUE9WwkDe65LUjPVVMI+JVGMGPgcMySmYSiXDann+KF/f+hNRlZkRxLv3W/8l+fibipLz1d/kqdzCph9v5k/o5K42xe2eV3qAOjWcJolmpc91BzPzqHutI5xI0W/s4oKioIFx9dSfKf0yo3lCtQ+zVCE9QSTXDFX1ALkMnQpcWiSzmGLuUY2lTLf1NRFnI7F5w7jcW12yQ0wS2sTR3MSWbQxt/JLLd8mfexdWRln0m09gi4Lsd7t0mf8xTalBiMRiNFyqofdWwcgtHLxWhK4e5QWkt+wfPBwJ3PVB1ZWNO2giAIgiDcm0RAULirOWqULJvQlrfXneSjjZYpdtN3J3Eiy53pD3yKafn/AZA+Zwoqt0AcIvvVqV0nGw3/9B7PhE3/8mfybstC93QcnHSsuH8sXf0DUNQwDdlRo+TP0a3o28CTqUtjKKWYGH0yI7buBtsiaFDTFGGLMpOeMvRAISghKaCldV2ogxt/dH2Erj71atxXo1QxMrQ5I0Ob8/Wxbbx0YAUAE3YuwtfOiZ6+YXU67hvly5it/N/Bldbr77fsz1st+t66Dt2jGng60MDTgW71HuGDKHfeObIegFV5+yhxO8e2hpWPSTuPQJb1moBeq6LhZ1vQm8x8viWBJzoE4eOkoYGzJw2cPYl09WXQxt8p0JezKyuRrqt/Yl2/x6tU9L4axVoji6PS+H3/OXYl5l9yW29HNY28HHBQK5EBMhkV/2XIZGCSjJSb9WjNerRmAzqzHp3ZgB4DCpmMbl5hFCRa2pIBi8a1rnYb5WcPkfLTwyBZ8ph6PPAGHoP/h9zGttq2AHZhHbEL61hlmam0ALnGAZmi8q05vjCbWfH7+PHELmsl4SYu3qzqO6la/lKhkjYlBl1yNArfxtXW6eUadCIgKNwF7FS1Txlu5utIpK/TTeyNIAiCIAh3GhEQrEV5eTlnzpwhPDwcG5sbO8VNuLHkchkf3t+QSB9HJiw8itZoZktCLv1zmrGq50vItnwFZhMpP47A97FfcWr30GVzCpYbTEzfncii9WqwbwwBJ0BupkSVR8+N32OnVNHRM4Tnm3RlYECjKrn6dCYj5Q4p+LaKIaEku9bbsJEraO0eQJiTB1naEtLKikgtLSBPXzU/4aTQFnzTeQSOqrp9wX2hSTfOlRbwXewODGYTwzbPYe/AZ2no4nX5na8zk9nMe0fX80HURuuyT1oP4LVmvW56X4RKMpmMt1v0w83Gjmf2/QvAtrx06/pRtnb8fv9UNEoV2MO0LiF8ve0MpXoT76w7yS8jK6tCd/YOZeeAp+m/fiapZYXEFmTSadWPbOo/hXBnzyvum9Zg4u21J/l5d2K1hPpqpZyOwa408XG0/Hk74mtjIDzQp8a2dmWe5aUDK9iXfQ7kWP5qkFR6lH4qOWqDucb1uox4kr8ZhKS3jE507jwOz+EfXnGOTkVFkNRkNrMiOZZvjm9ne+aZKtv08QtnSc9xONcSaBQqqQOb4fTUctzd3assT/nt41vUI0G4vup7VOQXfKZ6fkFBEARBEITLEQHBGsyaNYsXX3yRoqIiGjVqxJYtW/D29r7V3RKu0cMt/QnzsGfI7AOkFmpJKtARmd+VX5yP0LlwM2ZtManTR5G94hO8h3+AQ8sHkMlkSJJEodZIRpGWjGIdR9OK+GLLadKKKjKEFXnSWxFIvN0+kksLACgzGtiUfopN6ado6uLDa816MSSoCXNOHeCzmC2klBVW65+L0p7e/vXp5BVMR69gWrkHoFZUPUWzUxPJ+e0RktPiyFQ7Et52OB16jL2i++H8FOLk0gKWJcVQqNfy8oEVrOxbtynT10tqaSHjdyy0FkcA+LLtIF5q2uOm9kOo3bTGXXBV2zF+x0JMkhmFZObVhC0823KAJRhY4c0+4fy+P5mCcgMz951jbOsAutarDMI0cfVh98Bp3Ld+JnGFWSSXFtB73S/sGDC1zqPcCsoNLI5K49vtZ4jNLKmyrnWAM+Pb+NOivpL6Li742Tlb19WUW6/UoOONQ2v4IW4XEjVPC76QwWzCqLQEBC/euix+J8nfDsFUmgeAXeNe+E2ceVUFe8qMev5IOMjXx7aTUFE9/Dy1QsmTER35ou0gVLewOMud4n/OoZxU2aLc+SfKi6YMl8mLsDOLkVPCnSM6P50uq36stlzr0ZiwghQ++bDmgKAmIFLkxRQEQRAEoVYiIHiRX3/9lc8//5w1a9bg4ODAkCFDmDNnDq+++uqt7ppwHbQOdOHA810ZOvsA+88VIMnkTFNO5XObcvrq9wCgT4km+bshnLMNY519L5bKOpEs1Ry0kMvg2a6hfPlAEwoNnfkj4SAHc5LZn51s/UJ/rCCDsdsXoJTJMUpVRxj19KnPkKCmDApsRD1H90sGEcy6Ugp+G4V0Zh8BQIitI6EPvHZV94NCLmdet9FE/vslp4tzWZUSx96sJDp4BV9Ve3WRVV7MjsyzbMs4w7aM08TkZ1iDMQqZnO/bD2Fqo8437PaFqzOmfiuC7F2YF7WBbqs/omVBMrlpUTg06Y19Y8tITjc7Gz4e0JCpS2OQJHhs4VGiXuqOvbryLSbIwZUdA57mvg0zOZiTQnJpAT3WTOex8LZ09a5He8+gagVH9EYza09k8eehFFbEZqIzVp4/djYKHm8fxNg2fhwrP83H0Ys5lZCDDBl9/MKZENaGocFNqx3PprRTPL5rMWdL8qzLmrv50cDOGdvyAmyLs1Dnp2CTnYi9rpgMtSPzAyrzbOrUcrIzz+DpXY+i/YtJ/fVRJIOlgIomtA2B05Yiu0zhlFKDjviiHOILszlZlMXJQktV5riCLEqN+irbNnP15YmIDoyu1xLX65x78W52UmXLSZUdTWpYZ2d2wl4EBIU7RKSrb63rTqodwSUAcmKrrdMlR9/IbgmCIAiCcBcQAcELFBYW8vzzz7Nnzx6aN7dMeRs6dCh2dnbs37+fsLAw3NzqnrOpqKiIoqIi6/X09PRLbC3cLL5OGrY81ZG3V8awK6WUo6mFPO/0Oq0Nx3iudB6tjZYP1kHlCTxensAkZnJQ1ZRV6m5ssOlEodwRmQwebu7HO/0a0NDbUsHPTW3HC026ASBJEuvT4vk0ejNbM04DWIOBMmSMDGnGm81708zNr059Nuu1JH83DMOZvQAonLwIfnUTKpfavyhcjq1SxTst+jFux18AvHNkHev6P3HV7QGYJTPZ2lKSSwtIKS0kubSAwxlJ7CtIJa4wq8Z9guxdWNhjLB29Qq7ptq+EODevTFefenT1mUKuVErmXy+BJJEyYzT13z+K0sUyHXdKh2CWRKWzOSGH07llvL76BN8PqxqQc9fYs7bv4/RYM51jBRkkluRb8xSqZHKaq5S0Lskm8twRAkt1vK15jihD9dHZXULdmD6iCbsLTzByz3QSSypzCEpIbEiLZ0NaPE4qDYN9I3iyaReauvrwyoFV/Bq/17qtg1LNex4+PLB9Boa06l+oz+udk8DvUncATHI53Ra9y5y0gzimx1W21eIBAqb+hVxtX2s7ySUFDN70O0fz0i51dwMwIKAhLzXpTk/fsKsabShAhKGMVV0erTZlWBRVEO4k0zsNr3Vdl1U/Ep2fzqOBj1Rbp/VoTIShnPk3snOCIAiCINzRREDwAkePHkWr1RIYGAhAfn4+//77LyUlJZSWWqq9zp49m4cffrhO7X399de899571Zbn5+dja1t7/qcLAxV3mpqm592unm7pwuvdgzCYzJzMKedoen02p/ViY8I2+qbOpZXhOAByJNoZYmhniOFt2S9k+3XBqe0IQjq0RKbU13rMbTQeLGn3EAfzUvkuYQ87c87Rz7s+LzboTISjB0h1u78ko56CORPQx24AQGbnivMTSyix8aDkGu/vfs5BhDm4kVCSx/q0eFbFH6WDe2Cd95ckicUpx1mQHE1yWSHp2mL0ZtNl91PK5LR08aWbZwhP1WuLi8L2hjx3Lg4EnFfbuVlcXHxHPYev1tW+xkhtxmETvR798XWYCjNJ/PEhXKYsQVYxhfXLfkF0PZdHqd7MDzvP0jvYji7BztXaWdRuJBP3LmRfUWUOTYNk5qBez0EbZwjrAYCb7jD2OldK9Z4448x9gQGMbxJMtO4s/bd8R5q2uEq73T1CSNcWE19ieQyLDFrmnYti3rkoVDI5hgtG6Pb0DOVjDDgtfBZDDceq8AhFFdIOhYs/LZMOYJtpxFJSBE44ejE6oD0z85Lx0ZVg23kSdsM+Jr9ECyXamu87SeLRPQtrDQaqZHJC7F3p6B7IlHptLa8RQF5eXo3bX+xOe9+o7dwUBKHuLjl6UCVGFAuCIAiCcGkiIHiBZs2a4e7uzoABAxg8eDCzZ8+mc+fOzJxpyQc1ceJEJkyYQPfu3fHxqTlJ/YVefPFFJk+ebL2enp5Ou3btcHV1veyXoTv1y9Kd1u/z/fXxgu7WYpTtMZn/D2NOEsUHFlG4Z4F16o1CMuKTuhVSt5Kz9nWc2o7AudNY7Bp2twZFLtbf3Z3+4c2uqn+SyUjq9NHoYy2jqGQaR0JeWY9taJuraq8m77e+n9HbLGMIvj6zl00NWtRpv4yyIp7YvYQVybWPrDpPrVDS3iOI7j716O5Tnw6eQdir1NfS7WtS27np6Oh4xz2Hr9bVHqfr1AWceacVhpwk9Kd2IO2cjsewdyrahK8HG5myxHK+PL/mDDEv98BBXfWtxiZqP7NXv02G3IbDzv4ccvHnkLM/p+w9kS4YDZentgO1DkihkBQWlR9n0cHqfRoS1IT/Ne9DG49AJEniYE4ycxIOsuDMEQoqivCcDwY622j4pt1ghuWeJW3GaGsbtmEdsWvQFbvwTtiGdUTpVLXIjmy4ZZSOXLJMcz9j7864lo+wPCCMRoNeuewovpkn97ItJxEAH1tHhgQ1IcLZiwgnSzXmEAdXlNeYG/Beee4KgmBxqdGDbWZc24h/QRAEQRDufiIgeAFXV1e2bNnCzJkz0Wq1lJSUMGvWLNRqS+Bi+vTpLFq0iMOHDzNgwIDLtufk5ISTk8hTdCdSyGUovEJQD3wVj4Gvok05RtHevyjcswBDxZd6s7aYgh2zKdgxG6WrP84dx+DcaSzqgKbXPMXPkJtMaewmCvf+RemximCg2h6Xxxdd12AgwEMhzfkoaiPHCzLZnJ7A1vQEeviGXXKfRWeOMnXvMvJ0ZdZlPraOBNg7E2jnQqC9i+WyvQsuJjk9QhtXKUJxq4lz8+opHNzwn7qIxI+6gMlI9vL3sIvoas0n+HiHIJZEp7EhPofEvHJeWRnLz8MrA+Jl8TtJ+XE4klGPN3ruzz7JIH0RhwoULNY5sNcllFwHGS3s4khSKclSO9bYDxkyRoRE8mbzPjS/YOq9TCajrWcQbT2D+KrtAyyI28eyjJNsSj/FgIBG/NBhKI4nt5P861ioCBK6D3gFr4c+rdN5q9GZaOjsxYnCLFI1zjxYbmBbST4hjrWnkzhXks9LB1ZYr//VfcxlzzFBEIRrJenKOHtRwZFX0otIsa0HiMrEgiAIgnCvEwHBizRt2pTvvvuONWvWMHfuXGxsKpPDn5+S1bhx49p2F+5SmoCmaEZ8hOfwDylP2EPhnvkU7V1orSxqzE8ld/Xn5K7+HKVbIE7tHsK542g0wS2rBRnMZom4rBL2JeWz91w++5IKKDeYmDGiGR2ViaTPfRrtmf1V9pGp1AQ9/x9a7+bX/dgUcjnvtuzHyC1/AjB08xy+bPsAQ4Ka4KlxqLJtudHA47sWM//MYesyfztnZnV5iP7+ETW2n5ube1sFA4VrZ1e/Pd4PfU7mXy9a8wkGv7IJTUATZDIZsx5qQdMvt1KkNTJ9dxL3RXgxuKkP5af3c+6bQUgVo/acOozCZfC79F+aye6kArABtV7O/PtaMryxO6kzRpN8YC6n7D045eBJeocxnFHZUd/RnRebdqOxy6VHamuUKob4NWJiZBckSUImk1EWv5OkH0eAyQiAa59pdQ4GAsgk2D5gKn3X/UpUXhrnSgvouXY6x4f9X7WiKOc9tWcpxRWFR55u2EkEA6/CsN/3o3ZNrLY80teJ6SOqj8DWGs2YzRID58ZUqzIcnV5MM9+aA82CcLeQq+0xA1TNrIB/2elb0R1BEARBEG5DIiBYi9DQUM6dO8fbb7/N+++/T25uLmPHjuX5558nJCTkVndPuEVkMhl24Z2wC++Ez+hvKIleS+HueRQf/c9aadSYl0ze2q/IW/sVNr4Nce44mrLGD/JbgoI9SfkcSC6gSGus0q5G0hHz27P4ZC6yjlo6T+Hkhf/jf2DfuBfaG5Tf7sHgSJq5+hKdn06hXsvjuxYzZfcSevjUZ3hwJMOCI5GQGLJpNgdzUqz7javfmu/aD8VFXXtOTOHu5Nb/eUpPbKXkyH+YCjM581Zz3PpMw3PoOwS6uvLN4CZM+jsKgJFzD7GyWykB/01E0lnysTq0HIz/43/wx+EMSzAQcLNTsfyxtnSpZ5n6GjB1EYo5U3DZ/jttC1NQbcuj/qcnkV/FdHOZTIZZW0LqL48iVVTyden6GD5jvrviEb2eGgc29Z9C73W/EJWXRmJJPhtS4xlSQ1XjAl05q1NOABDs4MqnbQZecd8FiNPsQ25bNR9lmd5EdIGCmFXbq21/RuNAYGnNeRWb+ToS6StGCAt3Nxuv+gCEPvlrleUxTzejVG+qVlzHaDSiVCrZ+YwYOSgIgiAI9woREKxFw4YN+fDDD3nzzTf58ccfKSsrY8qUKXzxxRe3umvCbUKmtMGx1WAcWw3GVFZI0cGlFB9cRmnsJiSDpbCAPv0E2cvehmVvE6kMw1PuwX2oMMiUGFChr/jfU7+PIHOGtW1NUAuc2j+MfaNeaEJaIVPc2FNVLpMzt9soRm+bT2xBJgBmSWJzegKb0xOYtvdfHFQ21lFOTioNc7o+zLDgyBvaL+H2JZPJ8H98Dkmf9UGbdBjMJvLWf0fh7nl4Dv+QCd0ns+NsHnMOJNOtbCeei79EwhIIt4/sT8DURUhyJV9sTbC2uXpye9oHu1behkKJ78TfMBZlUXJ0JYacJAq2/YZbn6evqs+Zf79qnfJv36QPvhNnkliaz9LEGFzVttR3dKe+owf+9k7IZfJLtuWuseepiI48uWcpAKUVQcaLpZYVWi/394vA4RbmzryTNfJ2QO1RNYgXnV57IZWQsmKCtaXMmxwpcisKwgXsVLXnKo1OL651nSAIgiAId597LiD433//MWfOHORyOUOGDGH06NEoFDV/OHrjjTcYOHAghw4dom3btkRGiuCHUDOFnTOu3Sbi2m0ipvIiig/9Q+Hu+ZTEbkJWMeKvqTGBpiRcuiGVLd4jPsSt33O1Fim5UZq7+XFs6Mscy89gSVI0SxOjOV4RHJSQrMHAMEcPVvSZSEMXr0s1J9wDFPauhL69h9z135Oz/H3M2mJMJblk/PEU+Zun8/3ob2mecojeMZ+jsExeo6DBYBo9vxiZ0oaVsZnEZpYA0Cfco0ow8DyZTIbXyE8oiVoFkkTOfx/i0vUx5Oorq6BZGruZ/E0/AyDXOOI3aRaSTMagjb9bg+DnqRVKQh3cqO/oTiMXL55o0KHm45dXBg1NFcVGLpZeXhm08rUT01Sv1j+9HyMgIKDKsp9fHkpA+RkiM6qP9ss7fYRUu/o3q3uCcFuKzk+ny6ofqyzTNmxLhKG82kjA3NxchiyIu5ndEwRBEAThFrunAoLffvst3333HZMnTyYhIYGJEycyffp0li5diq+vb5VtT5w4QUREBM2bN6d58+uft024eylsnXDpMp64gAcYPWMNnYu2MUi3jWbG+Evut0fVHI9Hp9O4e8eb1NPqZDIZkW6+RLr58l7L/pwoyGJpUjRLEqM5mpfGff4RzO8+BrcrDMYIdy+Z0gaPAS/j0vlRspa8QcGO2SBJ6JKjSf6sF/0u2Hah5j4+yXuMWUczGdcmkM+3VAbIX+lZe149TUBTnDuMpnDPfIyFGeRt/BGPga/UuY+m8mLSZk20Xvce9TUq9yC2Z5yuFgwE0JmMnCjM4kRhFqtS4vgudif9VXJsDFWn8ytlFwYEzRc3A0Ba2QUBQVsxTfVqnftuGAbnqqMre2TvAiAmvfqPdaXKEPJt692UvgnC7SjS1bfG5SdV4v1bEARBEASLeyYgmJ+fzxtvvEF0dDRhYZYvns8++yxDhw6lc+fO7Nq1yxoUzMrKol27dowcOZLffvvtmivGCvee7adzGfDbPkoNTiTaPkBW88dYNqYpthgwG3VIRj2SUYdk0LErIZ3H/z3NWYU/b5S6MORWd/4CDV28eNOlD28270OZUV9r0QRBUDp74zdpFq69niJj3nOUJ+yusv5wxBN8kDMQkDFh4VEOpRSy44ylKE8LPyf6NPC4ZPuew96lcN9CMJvI/udtyuJ3YN+kD/aN+6D2b1ztddpYkEHJ8Q0UHlpBzqltmIqyAMt0ZZfukwCYk3DQuv0LTbqhlis5XZzD6eJcThfnUqi3TP03mE0YlJaAoFEhwyyZkcvkKC4ICBprCQimXxAQ9LMTAcHrKc21BfHKYBYEv1zj+khfJx6+yX0ShNvF9E7Da1zeZsYTNVYfNhqNvJJdBkTfhN4JgiAIgnA7uGcCggkJCRgMBoKCgqzLWrZsyc6dO+natStDhgxh165dqFQqvLy8+PTTT9mzZw9ms7nWKcWCUJON8dkM/n0/5RWjiQY28mLJ+DZoKvL2XPxsauIcztmVlum4R9Nqz4l1q4lgoFAXtqFtCPnfTor2LiTz71cwFWXh9dBnjOn3HNEr4/hi62kkCb7fcda6zys9wy77w4uNdxguXSdSsG0mkkFHydGVlBxdCYDS2Qf7xr2xi+iKPus0JTHr0CVX/1Irt3XC77GZyGQySgw6/j5rKXrirrbj09YDsLkgV6ckSeTqyphxYg+fxGyyLtfZKGi/8nu+bz8UxQV9NpnrMEJQBASvWtBz/1SbMhwK9AGmXmK/3BtUiEkQ7lS1VR8GUYFYEARBEO4190xAMDw8HJlMxoIFC5gwYYJ1eWBgICtWrKBt27bMmjWLJ598EoCpU6cydeqlvmYIQnWnc0oZNGs/OqMlODAs0oeFY1tjo6y9QIGPkwYfRzUZxTqOpBbWup0g3ClkMhnOHUfh1P5hzLpSFLaW3HmfDWqEjVLORxtPWbcNdrVlZPOap7ZdzPvhz5HJ5RRHrcKYV1nt2liYQeGe+RTumV/jfnJ7V+wb98Zz8Fuo3AMBWJYUYy0EMqZeqyrBwPPH4KGx538t+jAhvA1Prn7cuu5gTgqdVv1IP78G1mW1TRm+MIegGCEoCMKtVlv14dzcXOLe7knrW9EpQRAEQRBuiXsmIOji4sLkyZN58cUX6dy5M+Hh4dZ1kZGRTJ48mcWLF1sDgoJwNf47nmENBo5s7sv8Ma1QKS5drRSgoZcDGcU60ot06I3mSwYQBeFOIZPLrcFAsATZPry/IWqlnLfXngTgtV5hKOtwjgAo7F3wnTADH0lCn3mK0uMbKY3dRGnsZsxlBZUbyhXYhnXEoWk/TIHt8W7Ru1qRnkM5lQHFkaGXzhMbYO+CWm85r+XmyuIh69Mq84LWVlQkX19uveyutr/sMQqCINxoNRUbMRqNFEW0ZfAt6pMgCIIgCDffPRMQBPjss8/Yvn07ffv2ZdOmTdSvX1mBsFWrVhw5cuQW9k64GxgvCBaMbxNYp2AggEoh8lQK9463+jagXaAL+eUGHm7hd8X7y2Qy1D4NUPs0wK33VCSzCW3SEcpP70Pp4od9414o7JwBy6iXmip2Xxi+c1Kpq62vjUZnuuL+nicX+WgFQbjFais2ApAoKqELgiAIwj3lngoIOjo6sn79evr27Uv79u2ZPn06I0aMoKSkhFmzZvHwwyL9uCAIws3Qv6HXdWtLJldgG9oG29A2161NQRCEu1FtxUZyc3PpOr/u1dsFQRAEQbjz3VMBQQA/Pz92797NCy+8wCOPPIKbmxs6nY5HH32UZ5555obettFoBCA9Pf2S2+Xn51NeXn7JbW4nZWVl1sspKSmX2PL2ciPu54LsdCjOASAnI40UJ0Od9tPmZ0GxpeJqSkpKrVOG77TnBtz6Pvv4+KBUXvql7vy5mZGRgaur683o1i11qx+Tm6m2Yy3JyoE8S1b9zNQ0UspqzgF43oWvc+f3q3I7GVmkOFV//dNm51u3T0lJQVXDaMXr4U58TK/k3Lzc+2Zt7sT7pTa347Fczfv/7XgcV+tuOxZDQSkpKSl1OjcFQRAEQbjzySSplsRHd5lffvmFsLAwevfubV2WlpZGVFQU4eHhhIWF3fA+HDhwgHbt2t3w2xEEoVJycnK16qQXE+emINx84twUhNtTXc5NQRAEQRDufPdEQHD69Ol88cUXbNmyheDg4FvWD61WS0xMDJ6enrX+8pqenk67du3Yv38/vr51q7x5q4k+3xyiz1enLiMdtFotGzdu5IEHHrij7t+rcTs8JjfLvXKsd+px1vXcvNz7Zm3u1PulJnfLsdwtxwF397GIEYKCIAiCcG+469/tb5dgIIBGo6Ft27Z12tbX1/eO+3VW9PnmEH2+/jQaDS1atABu/75eL/fKccK9c6x343Feyftmbe6m++VuOZa75ThAHIsgCIIgCHeuupVAvUPdTsFAQRAEQRAEQRAEQRAEQbgd3LUBQREMFARBEARBEARBEARBEITq7sqA4J0cDHRycuKdd97BycnpVnelzkSfbw7R5xvrTurrtbhXjhPunWO9V47zSt1N98vdcix3y3GAOBZBEARBEO58d11RkZycHPr06cPy5cvvuGCgIAiCIAiCIAiCIAiCINxod11AEECSJGQy2a3uhiAIgiAIgiAIgiAIgiDcdu7KKcMiGCgIgiAIgiAIgiAIgiAINbsrA4KCIAiCIAiCIAiCIAiCINRMBARvIqPRSEpKCkaj8VZ3RRCEC4hzUxBuT+LcFITbkzg3BUEQBOHOJwKCN1FGRgaBgYFkZGRccru8vLyb1KPrY/jw4da/O8mddj8DfHVoI7LZLyOb/TILzxxh/Pa/rNeTSm7P47kT7ufz52ZcXNyt7spNcTMek63pCdbn5rtH1tW63asHVlq325eddN37cb2O9XZ/nbsTzrOrUdf3zdrcrvdL4Z4FxI6XETteRv6WX63Liw4stS7P2/BDlX2u5Fie2fuP9byKyUuvtv6dI+us67dlnK65j/py6zZDNs6ucZvz58SDw4dbtx288fdL9u12fUyuxr18LHfrZ9p7pb+36j3tXrl/BUEQ7hQiIHgbugvrvNyW7sT7WeIO7PMdeD/f7e6lx+ReOdZ75Tiv1N10v9wtx3K3HAeIY7mV7d4oor83luivIAjC7UUEBAXhDlVmNGCUzLe6G4JwWV8e28b2jNM1frAu0GtvQY8E4fZRcmwdpooR3ob8lOvSptZU92mcB7KTr7kNQRAEQRAE4c6jvNUdEASh7gJsnayX3z6yjnx9GQAquQJ3tf2t6pYgVBPi4Ga9XGrU033NdFq6+fN8k648HNoCtULJP0kxzIzfB4BcJiPI3vVWdVcQbiqli5/1cvHBZSTEbcWpwyjyt8yo3MbZ56rajs5L48/ThwDLeeVr51RtG19bR+vl/zu4kqN5afzc8UGcbDTW5a8eXGW9HGDvfMnblGSVl51Umto3FARBEARBEG4bYoSgINxBennVo69fAwBSywopMxoAeLZRFxxU6lvZNUGoIsTRjd+7PESwQ2WQ70heKuN3LCR48Ue8sG85o7fNt06Df6dF3xoDF4JwN7Jr2B2fsT8gr/iRx1SaR/6mn8BsAsCl20Qc21x5bq8yo55Hts5DVzG675WmPfHQVP+xaFKD9jzVsKP1+vwzh2mx/Gv2ZlnyeP515gh/JBy09MXGllcje17ydk2KyohgR6/gK+63IAiCIAiCcPOJgKAg3EEUMjnzu48mwK5ytIafnRPvtOx7C3slCDV7LLwdCcNfY0nPcXTxDrUuzywv5tvYHdYpiY83aM9bzcVzWLh3yGQy3PpOI+yzeFy6TQJZZUDNfcAr+E78DZn8yj+ivbDvP+IKswBo5xHI+63617idSq7g547D+afXBNzUdgCcLcmjy+qfeO3gKp7cvdS67czOIwhyuPToXYOysq89fOpfcb8FQRAEQRCEm08EBAXhDuOpceDvno9ip1Qhl8n4of0wHMUULeE2pZQrGB7SjB0DnubgA8/zaP3WqOQK6/qBAY34ueODyC4IiAjCvULp7I3fpN8IfWc/rj2n4PfEn3g//NlVnQ9LE6P5NX4vAI4qNX/1GFvlXKvJ0OCmRA150RrEM0lmPovZQpHBkttzcoP2jAhpftnblir6+0hoC5q4Xt1UZ0EQBEEQBOHmEjkEBeEO1NErhBPDXqXMpCfC2etWd0e4BQ7mJKOQyWnp7n+ru1JnrT0CmNttFJ+1GcichAMYzWZeatod5WWCFoJwN8jWlvDXmSMYzCaauvrS1MUHPzsnZDIZtqFtsA1tc9VtnyvJZ/KuxdbrMzoOp56je532DbB3YWP/KXx+bAtvHV6HqaJYVQMnT75tN/iS+5rkMhRmy7R/N7Ud37UfcpVHIAiCIAiCINxsIiAoCHeoQAeXW90F4RYoNxp4ft9y60ig+/wj+KjV/bTyCLjFPas7XzsnXm/W+1Z3QxBuiiK9ls9itvBd7A5Kjfoq61xtbGnq6mP5c/FhQEAjQhzdammpZsUGLQ9u/oMCfTkA48PaMLp+qytqQyGX83qz3vTyDeOZvf9SbNCxqMdY7C+Rm7bMqEdvI8dWa8l7+HXbB/C6oFiJIAiCIAiCcHsTAUFBuEUkk5HioyvJ3zwdXcox1AFNsWvQFbuIbtjWa4fcRkwDFqp7Yvdi5p0+bL2+NvUka1NP0ts3nJebdqe/f4SYfisIt4kSg47ua37maF5ajevz9eXsyDzLjsyzANjI/+Olpt15s1nvSwbjANLKCnn/6AZmxe/HWDGqL9zJgx86DL3q/rb3DGb/A8/Vaduf43ZjrnitUZjMjAu7+hGOgiAIgiAIws0nAoKCcB1IkkRMfjp7s8/Rxy/8klO1jAUZ5G/7jfytv2DMS7lgeRqlx9YDIFPaoAlti11EN+wb98a+cS8R5BHYm5VkDQY6KNV42zpwujgXgE3pp9iUfoomLt681LQ7o+u1Qq24fi/xkiQh6csxleZhKsmz/K+4LFOqcGw5BIW9y3W7PUG405klM49u/8saDNQolDzdsDNtPAI4XpBJTH46x/IzOFOcZ622rTeb+CR6M38mHOKrdg8wMqR5tdf+PF0Zn0Vv5vu4ndbCPABqhZK/uo+9aTlldebK25ZJiPcoQRAEQRCEO4wICArCVTKaTezKSuTfpGMsP3ecsyV5ANgpVXzXfiiTwttZvyBJkkRZ/E7yN/1M0cGlYDJUaUtu54K5rMB6XTLqKT+1i8yzB0nZOguXsA4EjfwUo8wOld4eW6XqssnihbuLJEm8dGCF9fr9zh3p5t4IU0QGv5zaZa0serwgk4k7/+Z/h9fyWmQvHm/QHo1Sddn2TWYzxwsyKNCXU2Y0UKorpTA1loLUWAozT1GWn4ajrgRnQzkuBi3ORi3OBi0uxnLUZhMKZ298xnyHU7uHRGBAEIC3D6/j33PHAEt+vb0DnyHc2bPadqUGHXGFWfyTdIyvj29DazKSUlbIw1vnMcNnDz90GEYTVx9KjXp+idrE58e2UKjXWvd3tbFlbP3WTInocFMLekxt2Imd0q8AGJVy9mYl0cEr+KbdviAIgiAIgnBtREBQEC5Spjcye18SZ3JLMUhyjGYzBpOE0SxhMJlIMaVRqE7njD6ZImN59f2NBh7ftZjVp/bxpdKMKn4nZSe3YyrOrrqhQolTq2G49p6KXcPuGPNTKTu5g8KTO1ibeoIlKge2utfDIK84TTfMqrq7TE5jF2+md3yQzt6hN+ruEG6x/DI9uxLzmRV3iN1FiZaF5fYs3mZmMbHYKOQMj+zNhKZG1uUeYXN6AgBpZUU8u+9fPovZwuvNejG5QXv0UavJXfsV+rJiSt39UTr7kOTgyWK5LX+Xl5N6UX4zK+cQy18tnAzlPJAZx4RZj9Ng5x/4jPsZG8/atxeEu92C04f5KHoTAEqZnKU9x9UYDASwV6lp4xFIG49AHm/QnpcOrGBZUgwAWzJO03z514yq14L1KSfJ0pVa97NTqni+UVdeimiHm6PHjT+oi7iq7bAxmK3Xn9n3D/sGPYtcJr/pfREEQRAEQRCunAgICsIF0rNzmP3lS/TOXEI3SUuO3IUsuTuZcney5G4sCw0mztsOyqrupwK62mjwkkks1OkA+CfrHHu1RXx2ai+tLwgGKl38cO3xBC49Hkfl6gdYRn9Fm2GuzJYFNp7k+Nldtq8myUxMfjo9187g104jmBDe9rrdD8KtdTa3jMVRafwdlcbh1EIkzBB2AM6nFMuoD1hG4elNZv46msZfR6GhVwQvtmzBWflJ/k0+hoREalkh0/b+w0d7lzI5fjMPph9Dq1Cy1mhkucyRozJnoJZAYB0VqWyZH9CKhf4tGJB5gkkfdqVz/+dw7/88sus4bVkQ7gQbk08zceff1us/dXyQHr5hddo3xNGNpb3Gsz71JM/u+5eThdmYJHOVvKEqSeKRohSmnNuP66bPyZDMFIZ3xq3PNJzaDEdWhxHB14vSJFkvH8xJ4fvYnfT2DafEqKPYUPlXbjLQtiLoKQiCIAiCINwexDc1QQAks5nY1b+St+xNhpryrMu9zXl4m/OI5BR/+0YS593Ius7JUE6P3DP0zDlN5/xE7CumAXd3C+XNhveRZ2NHusaJCS0eYmp6NC86OePeYRSOLYdQjsTR/Axi4vdzrCCDdakniS3IrNavADtnBvjWpzx+J0XZZ9DJVZTLleg1DuR51udkeQkGs4nHdi7iWH4Gn7UZiEJe++iMgznJvHZwNY4qNSNCmjE4qPFNyzd1L1uTEseq5DjCnTxp6e5Hczc/nG1sq2xzLr+MxVHp/B2Vxv5zBVUbcE8DtWWKoIPek0ebt6BziBuxmcX8vj+ZjGJLEPpEVgkn1pWgVnrQPaIfufYJHCs7jQSkI+eDBn2YHtyBYqUG3UWBOpXZSPfcM9QvzcXWbAQbF7IUvhzXe5NAIKXYg8JI80A72obYo1KbyNOVk6srZV/2OYoNOkwyOSt8GrPCpzHdY3cx9fBKHhj9Bbb1RLBauPsZTWbe2RTDx4mLQGXJrzc6qB1PRHS44rb6+UdwqNsoPl/9LV/qjZQpbJBJEoMy43g6cTeB2sIq25ef2kXqqV1kuvji2mMKrj2noHS5edOHz3th/3+XXN/RM5hJQS0Z79oR5SXSXkiSRH65gVKdiQAXjUhDIAiCIAiCcAOIgKBwzyuL38mpWU+jyojmfCkQvUwFfs1RlWYhK04nyt6Dj8J7W/d5/8Q6BmfGopLM1drrlneWXw//x/uRg4i2d8Ask/OjXwsOeAbhV1RCzL9fcbo415pE/mL2ShuGB0cyLqwNPXzqWwJ83UZTtH8xqbOnIJXlA2CSyZnR81l+Nlu+VH11fBuxBZnM7vow3raO1vYkSeJsSR5LEqN56/Ba9GYTAP+eO4ZGoWRAQCPuD2hIExdvGjl746K2rd4p4ar9mXCI8TsWVnu86zm609TFF3m5I6ln3TiQVFLj/q2C7Ih1TkYrgVwmY+9D46vkCXu3fwQrjmfyy54k1sdbRqLqjGa2HitnvPYg77CKmcFtWecVAUCO2qFK+246FW10SnrpdDiU+rCtpCmbzQ3JlbvW2J+oAoiKgfsa+vBy9/r0DPOgyKBl+sndfHt8O1lay5TGbe712QY0W/Et9/k3pGWrQdR3dKeeoztuajvxBV+4q5zJLWXM/CPs1R4Ez4oRtyUuLFitIff0Xt7rH0H74JrPqYsZCtLJ+fd9Cnb8zsNGPb1s7NniXp+WRamEl1qKCMlsbFE6+6J08cWsLUaXHA2AsSCd7H/fJXvFRzi1HYHnsHdR+zS4Icd8IaWx+nthTfZkJ7EnO4n3TmzlmUadGRfajiVHszidW0ZakZbUQi1pRVrSCrVoK9ps6uPIq73CGNPKX7xuCIIgCIIgXEciICjcsyR9GRnzPyBv/XdcOMFqv2sv7nvhZ3yCLQGUs0U5vLjqB4wVgY7nnN14uv/TyORKJJmcMwU6otLLOJxewsk8PfGKYJLlPnAWlF6pSF5nMWFmX/a5WvsiQ0Yv3zDGhbXmweBIHFTqats4tRuJ1qMR5ctepjRmHQrJzNObv8XfN5L3GvRFL5OxJvUEwYs/4rGwtjR382V75lm2Z5whtaywhlsFrcnIsqQYa74qgA6ewbzctDtDg5pecrShcHnZ2hIm7/q7xuDvmeJczlRUCMbkCTS2rmsX5MLDLfwY0cyXT+LWcPikJcAwObx9taIBKoWcB5v58mAzX87klvLbvnP8uT+JKWlf8qDOksPs69iV/JeSwfv1BlLuUoKTwhZlkS95aW7k6exZD6y/sNELHvZwD3v6NvDEz1nNjN1JpBRaRiquPZHN2hPZ1HO3Y3L7IKZ17s7zjbvxR8IBPj+ynrNaS4Az2smX6OJC2Dbf2qazjYZ6Du742TmhUShRV/xpFErUcsvlQHsXunqH0tTVR+QkE257D809xKG0XGiQYVlglkNyI0DGupPZbE7IYeOUjnSrX3sFekmSKNr7F+l/TsNcmm9d7i2X8VSr+zEHdcAtqCFKF1/ktk5VilaVn95L3sYfKdq/2FK0ymSgaO9fFO39i/LB36D3iECvcbP8KR0xmCVMkoRZAkkCsyRhliTrZXd7G7qGuuOoqdvHRBuDmecbdyVXV4aDygZHpRpHlQZHlRpHlRq92cisU/s5mJMCQHJpAa8cXMXbBzehTQuAPF+qvPBc4FhGMY8uOMLWhFymj4hEpRCvB4IgCIIgCNeDCAgK9wSzQYc+/SS61GPoUo+jTTlGacJepOIs6zbRygYcaP4qHz01Ho3KMuouX1fGwI2/k1ERDOzr14Cv+k6uEihzA9oAk7DkfvtlTxKz9p8jp1SPMSsAipyxD4unFEuAxNlGQ1MXHyJdfYl0Pf/ft04j8xTOvgS9tIb8TT+Tuej/kPTlDE2PIaQ0h2ebDiHXxh6dyciMk3tqbeP1Zr0YHNiEvxOj+PtsVLVg4d7sJEZsmUuYowcvNe3G+LC22N7EnFR3E0mSrCMyGzl7E6lszIZzZ8m3SQXVBZWmTSpaBzjzUHM/HmrhR4ibJYfk6hO7rY+lo0rNey37XfL26rnb8247O5488SMlZy3BQDNyVvuN52NpGOUpQJqRxv6uqG1s2KbLrbGdYZE+DGzkTZ9wD4LdKvNZ/l+PMOYdSuGzLQnEZ1vOiTO5Zbyx+gR/HUll9eT2PNmwE5MbtGfJ2Sg+3bWQKFP1kUOFei1H8lI5kpd62fvQTW1HV+9QuvvUp7t3PZq7+YlAtXDbSS3UgkcyKC1ThSdHtKNN49Z8ve0M8dmlGEwSD845wL7nulLfw77KvqbSfMoS9lKwfRbFB5dal8vtXHDv9zxufZ9B4eBGbm4uavfqAUWZTIZdWEfswjpifOQr8rb8Qsaab1DqLK/ttv+9wIXvLgaU5MmdyJB7sFfVnB02rYlSRmCWVZ3Cq1LI6BTiRr8GnvSP8KSlvzNyec0j9GTAN+2H1LjOrCvFWJTF46FT2FuQwWdHNrIqIx6zJKFFC34JlvsuJwgKfPCxt8XfWYOfk4YCrYEdZyxpPGbtP0dyQTmLx7fGSSPekwRBEARBEK6VCAgKdx1jSS7axMNokw5b/idHo888BRWBmYuVoeEL+8eIeGAaX/RvZP3CozMZGbppDnGFlqBhExdv/u7x6CWDEaHudnw6qBHv9m/A22tP8sXW06B1pPRYSzw9jHw9oDljmtW/pmlPMpkMtz5P49jmQQq2ziR/ywxaFKSz/MAf/Onfkr/8W1Ckqvz652yjsQRUvOtzX0AETV19AejgFcyXbQdxICeZo7lpxBZksjPrLIdzLUGahOIcntqzjLePrGNao8483bAz7hr7Gvsk1MzL1pEAOxdSygqIy8slLs4EbgrwrQwG1lcFsWjUWFr7u2EoSKcs7l/S4rZwOn43k4K7gMYy/fsjBwc8TDUX/5DMZkqPbyBv08+UHF0JFVPZZTa2BD/9N6+0GMSLJjOtvtlOTHox+5KLSXunL7MPJLM1IZdzBeWcyKqcsvxKzzA61DC90UYpZ2L7IMa3DWR1XCYz955jVVwmZgli0otp/91OVk1uRwt/Zx6p34pH6rciauFr7Ny/mGRbF1LtPchp2p8ko5EzJXnoTMbL3od5ujKWnzvO8nPHAcvz+ZHQFnzdbjB2Spu6PxiCcB1JRgP6nLMo7N1Q2LuisTWBu2X0m1qh5J2WfQiwd2Fy+2CGzT7AithMcssMDJ61l20jPFAkH6D89B7KEvagT4ur1r5L18fwHvU1CnuXK+rXrlwlLyX25Ix9fRYbXsDXnFNtGxVGa37c5sZ4ppQvpkDmyC6blmxXtWaXTSvy5c4YTBLbTuey7XQub645gYe9DX0beHJfQ08GNvLG3b7q+Vewax76zHiM+akY8lIs//NTMZcVAJbXo8DGvfkprAdf9BrP0B3bOaE7Y4km2ujA7xS+9TN4uWkPpkS0x75ipPy/MemMnn+YcoOZ9fHZdP1xN6smtyPARaS3EARBEARBuBYySZJqTmQmXHcpKSkEBgaSnJxMQEBArdvl5ubiXsMogNvV8OHDrZeXLl16iS1vDF3aCYoOLkWbeAht0mEMOUl12q9Q5sB+VVO+d5rMR2Pv45GW/tZ1ZsnMmG0LWHj2KAB+dk7sHfgsgQ4uV9S39SezGPfXUTIrij6AZfTV14ObWEeBXYmanhuS0UDRoWXkbfyR8vidlCpUrPdsgFaupFtoK3pO/BWlsm6xf0mS2JF5hi+ObWVlctUvqbYKFU836sSbzfpcUZ7BO+H5fP7cjI6OJjIy8rq1uyo2kxFb5qK1qygYU+AFLpWjUp9o0JEv3D0p3fsXpSe2oE8/CUCirSuTm48gXeMEQPec0/x07F9kCiUOzQbg0nkcDi0GIelKKdgxm7zN0zFkna5y2woHdwJfWIFdWEfrsldXxvL5Fst2ax9vT/+GXtZ1fxxIZsLCowB8PqgR/9ezblVRE3JKeWDWfmtA0UGtYPG4NtxX0bZkNpP26zgK91imDCudfQh5ey9K90BKDHp0ZiM6k+VPW/G/zGQgJj+dbRln2JZxmozy4mq3284jkBV9JuJ1Qb7Mmlyv59+tfp27nDvhPLsadX3frM2NuF9Kjm8idfojmIorgm0yGR+E9WWhv+W143FdAW8ZCjBrizFrSzCWF5GalYPSWIaDVIYNtQfCFc7e+E34FcdWg6/oWBJySnllZSz/xGRYl3mY85nmeYZQdSl2+nxs9fnY6vJR6/JQ6/KwLUlFVkMeXAkZ2W6RbFK2ZbG+GScVIXDRj1hyGXQJccVjy9dYkl6Yed/h30vfcRc5pQrlb6cOrAkKJd9ZV2Wdh9qeF5p04+lGnXC2sWX/uXwemLWfrBLLjyJ+Thrrjw+30t103l3psdytn2nv9v4+tXspMfnpOM/fjkZnQqtWUDimm3V9pKsv0zsNv0QL1+Zuv38FQRDuNGKEoHBHK9y7kNRfx1lyJtVCrnFA7d8EpV8TNhR68FuiPQmKILLlbvg52/LPY21oF1R1NNTrB1dbg4GOKjWr+06+4mAgQL8IL6Jf6s5ji46yOs4SCPonJoM1cVm81iuMV3qFYauqvdJiXciUKpzbP4xz+4fRJh0lb+OPPLj7TySjHtKiyLa1x2fs93UalSiTyejmU59uPvWJLcjgy2PbmHf6MAaziXKTgS+PbWP2qQO817I/T0R0QHWJKpH3svwyPS8sP84fB1PA3R7Ox34vCAZ+ENmLiTH/kbL1lyr7xjp4MaXZcPJsLDvVN5Tx/sn1yABMRkqO/EfJkf+Q27kgGbRIBm2V/VWeobj2egqXbhNROlT9ENv+guf5/uSCKgHBLqFu1ss7z+bxfz3rdqxhHvbsfqYzw+YcZNvpXEp0JgbN2s/04ZE83iEYmVyO3+TfMRSkURa3BWNhBue+up/QN3fi5OBWa7tdvEN5qmEnJEniVFEO2zJOsy3jDCuSYykyaNmfk0zHVT+ypu9kGjh71q2zgnCNCnfPJ/W3x6q856TZOLDU11KB3s6oZ/zBBRQbyqvs50XNZCoNtqFtsQ3riF14J+wa9UJxmSB3lf6UG3hvfTw/7jqLwVT5+267IBe+HtyZzqG1n2OmkjxKjq2nJGo1JTFrrAFOGRJeedGMIppRgM7Bj2iXTizSNWOTuTEu5mKG6Dbx4KGN/EYHJGp+b5HbOaNy8Ufp6o/CwZ3yhN0Ycitz6YYbzvJm7lnezIWzgS2YHTmYf8rLMEsSObpS3jy8hs+PbeGz1gOZ0rAje5/tyoDf9nEiq4S0Ii1df9rFqkntL5mXURCEqmLy04nOT6drDeui89Nven8EQRCEW0sEBIU7wuKoNP4+moaDWombnQo3WyXNEuZSf+/HVbaT27tiG9IaTXArNCGt0AS3wsarPiezS3lw3mGOphVBxSyn+xu4MXdMGzwcKgt4SJLER1Gb+PzYVgCUMjlLe46nuZvfVffdy1HNykntWBqdzov/HSe5wFI98d318cw5mMy3Q5oyuIn3dameqAlugd+k33BsM5zk74aAyUD+xh9R2DrhNeKjK2qrsYsPv3d5mA9a3sf3sTv46cRuSo16cnVlTNv7Dz/G7eLLtoMYENBIVH68wKrYTJ5YHE1aUUWgrrzql3ulTM7P9ZvRY+E0CrLPWpfLVGqiGvXjcbcGnJ+829YjkNV9J+M4+AUKd8+jcNdcDDmJANZpeJadZTg0H4hrr6k4RPZHVsu09nZBLtbL+5Lyq6yr526Hj6OajGIdu87mYTZLteYLu5irnQ3rnmjPxIVRLDiSisks8cTiaM7mlfHhfQ2RK20IfGYZiR93RZdyDH1aHMnfDSXo/9Yjt9Fcsm2ZTEYDZ08aOHvyeEQHjmclMmjbfBJL8jlTnEunVT/wX++JdPIOqVNfBeFqSJJE7povyVr0inWZXUQ3FA7uzJQ7YJBbPk6NTzmE64XBQLkCucYRucYBndyO2AKJZLkP8XaNeefxR/Fr2BbZVU591xvN9J6xh0MplXlgA100fDqwEY+08L/s+atwcMO5wyM4d3gEyWxCe/YQxdGrKYlahfbsQet26pI02pYsoS1LkFS2SEYd8hpGFs7RDGGHTWuaNWrEswM70zDYt8p6SZLQpR4nc/ffHNjyLxFlx1FgaSc0+SjvJx/lcfcQ5rZ6iL+NEkbJTKFey5N7lhKVn8Z37YdW+/Fh7ILDxL7SEwe1+DgrCHXVzNUXje4EABqdiVUDpwHQZdWPt7JbgiAIwi0gPkEJt72DyQWMmncYk7li9IMk8Urp79TXLrduM18zkMSmk2gdGUk9d3tC3e0IdbPDRq1k5t5zvPDfccr0lhyCtio5Xw9uwogGDtWCgc/vW873cTuty2Z2Hklf/wbXfAwymYwRzf24v6EXn2xO4Istp9GbzCTmlTN09gH6R3gy+5EW+DpdOjhSV47N7yfgyfmk/PwISGZyVnyM3NYZj4GvXH7ni/jbO/NZ20E836Qb/zu8ltmnDiAhcaIwi0Ebf6evXwN+7/IQAVeY6+puU6Y38vSyY8w5kGxd5man4svBXZh2IpYyowEHpQ0zZXqa/fYo58cXyW2d8B71NZv8WzBh92JrXr3evuH803s8jioN+ITj9eB7eA59h7JTuyjcNZfiQ/8gU9rg3Hkcrj2fxMYz5LJ99HfW4OukJr1Ix+7EfGbvP0eomx313O3wd7alhb8Ta09kk1tm4GR2CY286z5SSa1UMG9MS0Ld7fho4ykAPtmUQGJeOXNHtUBp70LQi6s5+0FHjPmplMXvIO3Xcfg/vahOAWVD7jmylr2DbM88/nTyYVrrsUQZDeTqyui1bgbzu41meEizOvdXEK5E5sKXyVv7tfW6W7/n8R71FSeLcljy7xeWUr1GJTNKX+DNTxbh7aBGrnFEplJXeX7/tCSaX/ZY0lpoo+2Y2/Tq82B+sCHeGgx0UCt4vVc4L3Svd1WjzmVyBbb122Fbvx1ew97FUJBOydFVlEStpOTYBiR9mWU7Q3nleECZHCqumZHzhcMEAPaehpk/HGRMK39e6xVOEx/L64hMJkPt34S1PqN50q4tzppinnQ/xVS7/ZRErQYgMDeRNzd8zkR7d/5oO5o/K37Bm35iDycKslje5zHWPdGewbMOsD4+m+QCLW+sPsF3Q5uIH6YEQRAEQRCukAgICre13WfzGDL7QGUwEGhhPMH4C4KBn9s9xh+2QyFRxoLE6snZL9Tcz4kFY1rR2MeR3NyqFVY/iNpgDQbKkPFDh6FMCG97/Q4GsFcr+fD+hkxoG8gLy4+zMtaSW27dyWyGzznIzmmd6zwq63Kc2o3EV1tM+qxJAGQtfh2nNg9i41233HAX87VzYlaXh3imUWde3P8fWzIsueg2pMXzwv7/WNxz3HXp953IaDLz0NxDrIqrnBI8tKkP04dH4uOkwc1rDCtT4hhfloPbvKnWbeyb9MXzsV95N/EYX+z4y7p8eHAk87uPQa2o+hItk8uxj+iKfURXmDjzivspk8loF+jC8uOZ5JcbmLgoyrpOpZBVmXJ4JLXwigKC59v/8P6GhLja8uTSGExmib8qRgzOfqQ5du6BBL20hsSPumAuL6LowGJMn+fh+9iv2HjVq7FNs76c3DVfkrPyEyS9ZeSVW34KM7d8xVv3/Y91pUXoTEZGbvmT6R0fZErDjjW2IwhXqzzpSJVgoPcjX+J+/0scyU1l8MbfMZ9PxZwdhCSpKVY44+9U87nzyYCGLItJJ7tEz5+HUnirbzjhng5X3KecEh2fbUkAQK2Us+eZLjT1dbryg6uFysUX1x6Tce0xGbO+nNK4rZQcXUHp8Q3IVBqcO4zGuct4pMnPAJaw4IwRkXy08RTJBVokCeYdSmXeoVTua+jJM11COZFVwm/7zhGXaRkDXSh3pMuDTxLU+B10qbHkrv2awop0F76luby29QfaNurHK74t0ZqNbMk4zcdRm/mkzQB+HdmMxl9spUxv4oedZ4nNLObn4ZE0uIr7UhDuVE8tieZIcl6NeaIjfZ2YPkL8SCYIgiBcWu3lUgXhFlt0JJVeM/aQU2pJIt7Ux5GTr/Vk1sim1m3SGj6C/wP/h38dqg0+1zWUvc92obFP9S9q/yTF8M6R9QAoZHL+6j6Gpxt1vk5HUl2Yhz0rJrVj5aR2BLpYRgXuScpn1v5zl9nzyrh2m4jH0HcsVyQzhbvnX3ObLdz92XTfk/zba4J1WY629JrbvVNJksQz/xyzBgNdbFUsGNOKZRPa4FMx4nNIcFNmdh6J/5651v18Hv0RjxdWMPDgGr6omKIO8ESDDizq8Wi1YOD1MrFdEMoags4XBgMd1Apa+F19sv7JHYL5Z0Ibzt/M31FptPl2B0dTC9EERuIz9gfrtqWxm0h4JYykL++n+PBypIoRkpIkUXToX06/3pjsZW9bg4Hn2ZsM/HByLVMiOli2R+LJPUv5KGojolaWcD0cyD7H5zFb+OLYNuYEtOaPgFb80/81/gpuz8dRm+i86kdSyiwj9DyULpBnSS1xYcXui7na2fBar8ofZdadzL6qvq05kWU9Z5/vWu+6BgMvJrexxbH5/fiO/5mwz09R/6MYPB54HZVr1VQaUzqGcOr1Xnw3tAnejpWj79eeyGbgb/t56b9YazAQoG8DD+6vyGOq9m+M36TfCP8qCY8H3kRub8l32jtuPX+d241NRb7apUnRAAS72fHVA42tbW06lUPkF9t4b91JtAbTjbkjBOE2E5NexPGssmrLo9OLiUkvugU9EgRBEO40YoSgcNuRJIlPNiXw5poT1mUDGnmxcGxrHDVKDPJITlUsb+gs0WdAI97pF0F0ehFn88o4m1tm+V/x5+Wg5r3+EfQK96jx9mLy0nl0e+XorK/bPcDD9VrcwCOsNLCxNwttW9P5x10AvLoyjiFNfPC64MvUtXLr9RQ5/30IZhOFexfgMfTta55aJZPJGBjYyHpdfg9P1fpy62lmVEwBVCvlrJrUjk41JPLXpcZSfnovAJp67XDp/RQjt/zJ1oqRlmqFku/bD+XxBu1v6NS3wU19iJrWmjSdkrN5ZZy54HzJLtHTM8ydt/o2uKoq2Bd6oIkPC8a0YvLiKEp0JuIyS2j33Q4+GdCI57uMxi3xIPlbZ1qKokgSpTFrKY1Zi9ItAJeuEyk/vZfSY+ut7cmUNrj1fxGPB94g6dOeaBMPYUjYwzfjG+Bj68h7RzcA8L/DazlXUsBPHYehFEVvhKtgMJv436E11lyyAIT1sPzXGWDfv1W27+5Tj8d972Ps0eMAHE0rYmhk1fx5F7q/oRcv/RcLwIb4bKZ1Cb3iPl44GvnBZj5XvP+NolYqeLZrPSa3D2LuwRS+3naGUzlVfzDqEerM1K5hDGnig+KiHyeULj54jfgQl24TSfykB8a8ZBok7KCdWz122nlwqiiH+MJsGjh78mSnEMI87Jm6NIZTOaXoTZbcvAuOpDJ9eLNa3/MF4W7SxMuOnc90qbKsyw87a9laEARBEKoSAUHhtqI3mnlySTSzL8jDNq1zCN8MaYJSYRnQqnT1A4USTEZrgQUbpZw2gS60CXS5otvL0ZYyeNPvlBotoxAnhbfjmUZdLrPX9dUp1I3J7YP4bd858ssNvLIyljmjWl639pXO3tg36UNpzDr0GfFoEw9jG9r6mts1XzAK614NCC6OSuOVlZXT1OeNblljMBCgYMds62XXbhN57eBqliXFAOBiY8vG/lNo7RFwYztcwdvBhsbBN74y58Mt/WkT6MKY+YfZd64Ag0ni5RWxrDuZxR+jPqfB0Hcp2DWX/C0z0KefBMCYl0LO8vertOPQYhDeo75G7RMOgGvPKaTPfgKAgm0zeffRH/BQ2/PsvuVISPwav5eUsgIW9Xj0hh+jcHc5V5LPqG3z2Z2VWKftp0R04Pv2Q8ksMgAVAcHUwkvu09DLAX9nDamFWrYk5GIwmVEp6j5hw2gyW0cWejrY0CbApc773ix2Nkqe7BTCEx2CWRmbycq4TPycNIxvE4gT5bi7X/r1x8arHiGvbyXp054Ycs/RLTWaneG9AFiZHMuLzt0B6NPAk+iXu/Pp5gQ+2ZSA3mQmPruU3jP28E6/BrzTr4HILSgIgiAIglALMWVYuG3kl+m5f+Y+azBQJoPvhjbhhwcjrcFAsCQ/V7kFAaCvCAheDYPZxMgtc0kssVRb7ewVwk8dH7wlXx4+HdgID3tL8vQ/DqawNSHnurbv3HGM9XLh3gXXpc0qAUHuvS9cu87m8eiCI9brXwxqzIjmNVejlowGCnZZpgvLVBoWeTSwThNWyuQs6zX+pgUDb7b6HvbsmNaZ//UJt04h3hCfQ+QXW1mVqMe9//PU/ySO4Nc249R2pCXYX8HGO5zAF1cR9MIKazAQwLnDKOQay9T/wt1/YtaVMa1xF5b0HIemYv/VKSfovuZnMrS1T98UhAutTI6l5X/fWIOBaoWSL9sO4i93T36I+Zfvjy1nbmA4i3qM5a/uYzjwwHPM6DQCG4WSABcNbnYqwDJC8FJkMhl9G3gCUKwzcuBcwRX1c09SPgXllrJE9zf0um55Z28EuVzG4KY+/DqyOe/2jyDUve4jj2286hH8+jZUHiF0zz1tXf7f2aNVttOoFLzbP4Lol7vTK6xyVOB76+N59p9jmM0ihYAgCIIgCEJNREBQuGJFei1fxGyh0bLPeWDjLK7HR+1SnZG+v+xlc0UgzM5Gwb8T2vJs15oLDagqKqqaCjMxX5RbrK7ePLbROl0z0N6Fpb3G37C8bZfjbm/DlxfkQ5q6LAa90Xzd2ndsNRSZypLPrmjvX0jma8+xZL7gkVfI7q2XklPZJQz5fT+6isdoaqcQXupR83MVoCR6NaYiyxS/I+1GM+3QGuu6mZ1H0tP36gq93ClUCjkf3N+QrVM7EeRqyfeZW2ZgyOwDzN5/DplMhn2jngRM+5sGXyfjPeprfMZPp95HMTg2H1CtPbnGwRrkNpcVUrT/bwAeDIlk831P4qG2B+Bwbir375hLbEHGTTpS4U5kMJt4ef8KHtj4O3k6Sz6ucCcP9g58hpea9qCPUk6v3NP0zklgqIc/D4W24JF6LWnjEWhtQyaTWfNuJuWXk1+mv+Rt9rlgOuuG+CvLI7gqtnK68MBG3le076WYygop2D6bpC/6k/hxd0qi1163tq+WjWcIIW9sI9TRg7BSy+eDndlJZGeerrZthJcDG5/swA/DmnL+d70fdyXy6IIjGEzX7/1UEARBEAThbnFvfYsXrkl6WRFvHlpD8OKPeOXgKk4UZrEyOQ6t+trydJUbTIxdcIRDKZZpVr5OanY83YnBTWvPi6Ryq/wiZshJqvNtGcwm1qWe5MFNc/g98TAAtgoVy3s/hrftlVVUvd7GtQmgWz3LdNO4zBK+2Jpw3dpW2Dri2HIwAMaCdMpObLvmNu/VKcP5ZXoG/Laf3DLLCJ2Bjbz4bmiTS44sPT9dONrRhyc1npgky5fT/zXvc90rWd/OutZzJ+ql7jzSonIk5ZQl0Ww/XVnxW+nig/t9L+DW60nkqtpzabr0fMJ6OX/LDGshkY5eIewZ9AxhjpaAS3J5IZ1X/cT2jOoBBEHI15XRbfXPfHW88jVxVL2WHBr8PC3c/QGQDDrrOpmy9udkpG/le0j0ZRL696kYIQjwX2wmxVpjnfprNkusjLNUp1fIZfSL8LzMHpdnKi8mdeYETj7lQtqsiZQeW0/Zye2c++p+kr68D1NpwTXfxrVQuQcR8sY2epfnWforkzPrtycwFmZW21YmkzGtSygLx7ZGpbC8Ji84ksrQ2QfQGUWxEUG4nOj8dLqs+rHGv6d2L73V3RMEQRCuMxEQFC7reH4GE3cuImTxR3wcvYmCi0bkmSumK5WrFSxJjMJkrvsv8UdSCmnzzXb+PWYZweNqq2Lb1E60qiUnkrEom/S50yjcPe+CZVk1bnueyWxmS3oCT+5egt/C97lv/Uz+OXfMun5O14dpWfHF71aSyWRMH97MWgH27bUnWRqddt3ad+442nq56OCya27vwvDXmeLcK3rc72Sz9iWTUJEkv1WAMwsfbV1lSvvFtOeiyT+ykhnB7Xm01SiKK6rojqrXkvdb9r8pfb6duNiqWDC2Ff/Xoz5gqW48+Pf9l827djHb4JZoQi3B1PLT+0j7dRxSRS7QMCcPdg+aRgfPYAAK9OX0Xz+TtSknam1PuDfNit/P3mzLj0oahZJfO41gfrfROFaMqAYwl1c+N2UXLD8vpaCcqUuj+Xl3onXZmdzqlT8v5O2opllFZeDDKYUEf7iR99fHcy6/rNYq2dmllrQaxzOKAegS6oaLrapuB3oJRXv/onDnHzWuK41ZR/7WX6/5Nq6Vyi2AUcPesl5/07c5T/77GUV6bY3bP9TCjxUT22FnY/nBcnVcFk8tiREVyAXhEiJdfWnmWnNBpOj8dGLy029yjwRBEIQbTRQVqYXJZCI1NZWgoKBb3ZVbplBfzoQdi/j3guAZWPIqTQpvx5h6rXhm3z+AJeefWS5j5JY/qe/ozktNuzMhrC22ypq/rJjMEl9tPc3/1p7AYLJ8QLe3UbB0QhvCPR2qbW/Wl5O3/jtyVnyMWVtsXW7j1whNUPMab6PMqOeDoxuZk3CAjPLiauu91PbM7PIQg4Oa1On+uBka+zjyTr8GvLX2JGYJRs07zIqJSvo39Lrmtu2b9AW5Aswmys/su/b2VGo6e4WwKyuRuMIsfojbyfNNul1zu7e7qPTK4MAfj7TAQV37y6gkSWxe+AqvtnyYY06VH7J7+4bze+eH7tlk9zKZjE8GNiI+u4TlxzMp1Brp9+tedk7rTIMazv/aeA3/gHNfD7RU0N49D2NBOv5TF6JwcMdT48Dm+55k5IbZrMqIR2sy8uDmP9g+YGqVqZ7Cvc3ZpjLA92Gr+3g8okO1bcrid1guyGRo/CvfL9IKtXyy6RS/7j2H/oIpqT6OanrUv3yF2//rWZ8JC49iMkvklxt4Z91J3ll3Ejc7FS38nGnu50QLfyda+DmTU6pn9LwoMkssI5MVchmv97o+qQbsIrqhdPXHmJ9abZ3C0RP7Jn2uy+1cq671WzMg/gCrM89glsmZZYYVSz/l49b3MyGsLQp51R9m+jf0YtOTHen7yx5KdCZmH0imhb9TralIBOFucVp9lFJ5EV1WHa22Ljo/vdag3/ROw2tts8uqH69X9wRBEITbiAgI1mDhwoW88MILdO3ala+//pqAgLsz2f+lSJLE5F2LqwQDPdT2PN2oE1MbdsKrYnrtgQeeY9i8XVX2PV2cy9Q9y3j78DqeatiRqQ074WPnZF1/Lr+McX8dZdsF0wTbB7kwb0wrwjzsq7RlLM4hf9PP5G36yZqDDUBu54zHoDdw6/sscpvqIzYO56QwZvsCThRWHT3oqFIzLKgpD4e2oKXGHV/Paw+0XW9v9gknrUjL9N1JGEwSw+Yc4N/H2tIv4tr6KlfboQ5oiu5cFNpzUZgNuktOyayLr9sNpv3K7wF4Yf9/pJQW8kmbAajk1zaN/HZ2MssyOlAplxHhVXvwqsyo5/XV3/OTR2NMFTkWlTI577fqzytNe1b78nqvUchlLHy0NQN+28eWhFyyS/T0mbGHndM6E+Rat8IDDpH9CXx+BSk/jUTSlVIau4n4aZ7IVBqUTl4oHD35UuOC2qshy+Qayk0GBm+czf4HniXA3uXGHqBwR2juVjl9/XRxbrX1prJCys8cAEAT1BKFgxuZxTo+2XSKGXuSrHlEwTL69aXu9Xi2ayhOmsuP3BvbOoBOIa58tjmB2QeSrT+O5ZUZ2JyQY82pe7FAFw0Lx7autaL5lVL7NST86ySMBRkYC9IwVAQG1b4NsfGqj6yWH/ZuNrlMzvL7pvDh9Mf4wsaFMqUNWdoSJu9azE9xu/mu/RC6+lQN9nUIdmXe6FYMnW15DF/8L5Ym3o70bnDtU60F4XZVKi+iTF4EOFVb18zVl0hXXy49t0YQBEG4V4iA4EUOHz7MtGnT2Lp1K02bNr3V3bllZp86wJLEaADc1XZ81Op+xoW1qTbiTy6To6z4EqPRmRgU2IiVyXEA5OhK+SBqI5/FbGF0vZZMa9SVfScNvLE6jsKKfEkKuYy3+oTzZp/wKtMudRnx5K39hoJdfyBdOEVZocSt11Q8hryF0rH6CAyT2cxXx7fxv8NrMVQUzrBVqBgc1IRHQltwn38EmopjyM2t/uXvdiCTyfhxWCSF5UYWHEml3GDm/pn7+HxQY8Y3db6mtm1D26E7FwUmA+UJe7Bv1OOa2mvnGcSrkT35LGYLAF8d38a+nHMs6jEWP7tr6+vtSJIkTmZbqtbWd7dDVctU4XWpJ3lq1xLOluZDRTAw0s6ROb0n0eourSZ8NTQqBcsfa0fvGXs4kFxAcoGWvr/sZfvTnfF2rFuw2rH5/YS8vo1z3wzEVJFTTDJoMeSew5B7DoC3T24hrdmD7HUNJr28iAc2zGLHwGk4XGNAXLjzNXX1QS6TYZYkovKqT4crO7kdKnJ+ysO78/qqOL7feZYyfWU+OmeNkhe61eP5bvVwvsIpvPXc7fllZHPe6tuA2QeSOZRcwNG0IpLyay6WNbCRF3+Maol7RVX660UmV6By80fl5o8tt29eU6VcwXORPeg27zm+qdeVld6WYlxH8lLptuZnHgppzudtBxLsUBksHdLUh/fvi+DttScxmSVGzj3E7mc609D71uYNFoQbyc7sxM6B02pdP/yrBTexN4IgCMLtSgQELzJjxgweffTRKsHAI0eOkJCQQKdOnfD3r3uuuaKiIoqKKhOLp6ffGbk34guzK6YCW8ztOooBgY0uu5/CLPFvn0kcz8/gq+PbmH/6MHqzCb3ZxJyEg8xJOAglLqAMANyo727PvDGt6BDsCliCLWUnd5C79itKjq6AC3P9KJQ4tx+Fx5C3UPuE13j7ySUFjNvxl7VyMEBHz2DmdR9NPUf3q7ovbhW5XMacUS0wSxILj6ZhluDlFbHsO+vJH2NdsVVd3Qg8h2b3U7BtJgAFO/+45oAgwKdtBhLu5MHTe/9BZzKyM/Msrf77loXdx9DjNq2ee7XnZmaxjqKKYHZNowMzy4t5Yf9//HXmiHWZrcnAi8Zi3h3/Gcq7eOTk1XLUKFnzeHu6/7yb4xnFxGeX0v/XvWyd2qnO+dFsQ1sT+vY+8tZ+hS7jFKbibIxFWZiKs5EMWlSSma+Pr2BMq9GctXPjaH46j6z5meWDnrvnR2rebmo7N7v+uAuVsycKuYwhTSwBHhvltT92dkobwp08OFmYTXReOmbJjPyCqumlsZusl6ccdWU9lcWeHNVKnu8Wygvd6uFqd20BugAXW97q28B6Pb9MT3R6EVFpRRxNLSIht5T+9Zx4vX9T5PJ7M9XAeY4tBuHz+2Q+i1vDuPJcvmwzmv05ltQlfydG8V/ycV5o0o0Rwc1o7uaHQi7nzd7hRKUVsTQ6nfxyA71m7GHLU50uOcpbEG4HTy2JJqaWIkXR6cU09rS9yT0SBEEQ7iYiIHiR1NRUIiMjAdDr9UyYMIElS5agUCiQJInZs2czatSoOrX19ddf895771Vbnp+fj61t7W/gF34Zutn0ZhMP7ZhLmdGSp+jx0Na0t/Oq82i63NxcfFDxRaM+vBzagbeP7ObfzBhMckuyfxwKwKEAd9z4ruMgwh3M5ObmYi4vomjBVHTH11ZpT2brjG3H8dh1eRyFiy8lQEkNffknNZaXo9dRaLAkGFfIZLzcoAsvhHdCqa95NOCtvJ/r6of7gwlzUfLR1nNIwOJj2cR/u425Ixri73Tlo5ukwA7I7N2QSvMo2r8Ym4HvIldf+xeioe5h1OvyKBMP/ENiWQGZ5cX0XvsL/2vUnXFeja+5/avl7l5zILi2c7O4uPiSz/X9SZX5A4McFdZtjWYzc5OO8tGJbdbnIEDX3DO8dWYnzV9YR2F+wVUexfV3Oz73Fz0UwaC5MSQW6IhKK6L/jF0sfqQx9jZ1DKLKHFDd/w4XhhAlSaIoJwN7uQ6HmNX8vPlHRjUfQYHKllW5qTz15yt8fN9LyJRXFsy5HUcX346P6aVc6bmZmFcGBst0/RNZCew4ncWcByNws7t00Lgu90tDe0tAsMSo43DyGULtLT9SlRtMnNu3GhfAgIIdUkOQga1SzuQ2PjzTwR83OxXm8mJyax7Qd02ausho6uLMmMbO1mPJz8+7/jd0ndT1vLj256oCm4he6E9soknifpYNeJPlgc15P3YrmboStCYjn0Rv5pPozTgobWjr6k97twBGtvbndI4tR9PKSS/S0f2nnSwZ1QhvZznFBj0lRj1uNrb42tZ95OCddt5dyvljqe3cFG6NmPQiotOLaeZb/XnZzNeRcNfrO1pYEARBuLeIgOBFIiIiWLJkCR988AFvvfUW+fn5ZGVlYWtry5NPPsljjz1Gjx498PWtOSHvhV588UUmT55svZ6enk67du1wdXW97AeuW/GBLF9Xxmv7lhNVaKn429TFh++7jLBOsa2L8/3OLdXz3OJ4Np5yAFk7cMkC9xTQWCov5pLH4L1/8kLjbrwdGEHWj4PRp5+0tqPyDMWt3/O4dpuIXFN7wMosmXli1xJmndpvXVbf0Z153UbTwSu4zv29nX3wgAcd6vswev5hirRGojJK6Tsnhhe61WNMqwACXa/s12Fjp7HkbfgeSV+K8uQ6XHs+cV362dPdncP+oYzfsZAVybGYkXg/biuLU44T4eqNg8oGR5UaB6Xa8l+lxkvjQHvPIOo7ut/UAhu1nZuOjo6XfE6kx1cWp2kZ5Im7uztxBZmM2D6X2IJM6zoPs5HX4tZyX/ZJvIa+i2d4yxtzINfgdnvuu7vD5qnOdPlxF2lFWvanFPPoslP89GAkTX2r50GqK5lMZjnWBq3x7vQQM+Y+y1iPxhjlCmaaof4fk3hx8q+o3Oo+lft2u+/Ou137dSVqOze9HGxQOKnJLTWgN5nZfa6IAfNi2f9cl8uOzrvc/dLOJ4TlaZZUF+fM5bRxD+NISiGTftvAvMJTAEQrIzAp7XimYzBv9A7Dx6l67tqb4XZ+jK+kb9d6HKq+U0k5YRm9qVvzIaP7PsOofo/xVVIsXx7fhq6imnuJUc+W7LNsyT4LgNJdjo2LGr3ZSKbcSNc9G6u1HeLgSmv3AJq5+dLM1Y/mbr6EOLjV+h51Oz8mV+puOpa7STNfR3Y+06XGddfzB6pLjka0Lar7D3SCIAjCHUMEBC8yefJkfvjhB9577z2WLFnCrl27cHFxASzTiRcuXMiBAwcYPHjwZdtycnLCyenqv8jeLOVGAz/G7eTj6M0UVOTr0yiU/NVjzBUFA8/LK7MUBziaVvGhQlLQybkxn/R7kHJNLq8fXM2RvFTMksRXx7ex4uByPinKoyGWioY+j/6IU9vhyOowvfLDqI1VgoETw9vxbfvBOKpuzZe1G2VgY2/2P9eVQTP3kpBXTlaJntdXn+D11SdoHeDMA429GdzEhxb+TpcNrLl0fYy8DZZCIBnzn0Xp6o9ji4HXpZ+uajv+7T2Bz2O28ubhNZglibjibOKKsy+5n5fGgU5eIXT2CqGzdwit3ANQK27cy9PVnJtms8RfR9Ks1xt6OXAsP53ea38hS2vJKyhDxjhnd6asehdnow6VRwjuA1+5rn2/m4W627FhSge6/rSLvDID28/kEfnlNoZF+vC/PuG0CnC5pvbVvhE89H+ryVn2IdOKLcHdj1zr0fuL+2jx2iaUzt7X4SiEa1HbuXnoxe4EBARwJKWQzj/upNxgJiGnlOXHMpnQ7tqqRqsumDaeXl7EqewS7vt1N2+lf2Ndrv9/9s4zLIqzC8P3Nlh67yhFRERB7L3X2GOLxmhsKab3qklMMdXExHymmcQWjTX23gv2BiqCgCC997Jsme/H4AIBFBXUJHNf117MzrzzzjvL7OzMM+ecx7s7Uc/2xsu+boY3Eg2LVchQFNbO6PPTKb12iuSfJwMw1TOI0S36c6RRC07J1RxJj+NaYUVUpU4wgLwEbpJtHleYQ1xhDuviwyu2pzJlom8bvu04ApMG/G2SkLif3CwasXLdVAkJCQmJfw/SVc3fCAwMZM6cOcyaNcuYJnyDsrIyDAYD/v7+N+nhn8WZzETG7F9CXGGOcZ65UsWiruNoaXfrKMiaeG79RaMY6Gmj5n+jghjWwqVcqHKkr5sf30cc5d3TWyk26Ikys2V820d5NTuWD6Z+j6lj4zptZ0fiFT44txsAhUzOip6PMs4n5I7G/E+gmbMlu6YE8fa+RFZfSDaWWDyTmMeZxDw+2BWFp42aYS1cGBboQm8/R9Q11BpUe4Vg02USeaHLELQaEr57GM+ZK7BuP6ZeximXyXkruA8dnRrz3PG/qkTO1UZ6aSEbrl80ulqbKpQM8mjGT13G4HIb6VsNyRf7o43O2E0czDG1KqH39p/J1IhpjO0cPflfUC+sv+iDQacBwHXSAuQmUn2f2yHQ1Yot0zswZskZkvPF9Ou/wlP5KzyVwc2dmdWvKZ2979xdVSZX8OyY9zm362d+TYqiQKnmJ1M73viwE57PrcHMp1197YpEA3Dieg4lWtHkw8pUSd+m1c2lbodiXRlfXzoEiIJ+C8tGDPj5OOPTF9OnrPxhk7kdk5+dhUoSAx8YZEoTXB/7jpQlMzEUVVy/aBLDMU0Mpy/wkIsf9gNeoqjfVEJz0jicFsvR9DjSSwuxUJiSnKOlqBTQK1HJVQwPcKeQQo6lx5NfqfQDQIFWw4+Rx5DLZPyv86h7u7MSEveQ2qIRrRcdug+jkZCQkJBoaCRBsAbeeecdioqKmDt3LpMmTWL58uUolUqmT5/OI488QkBAwP0eYr2wNPo0T4auNabWKGRynvDvyHsh/XEzv7PIxgvJeaw8lwSAs6UJB5/tgq+DRZU2SrmCJxTQ7OwK3vDtwUVrN7RyJZ85+nP81FaWdp9AI0vbm24nriCbiYdWICCqYl+1H/qvFgNvYK1W8uektnw1LJAVZ5PYcDGV49dzjOJgYl4pP4TG80NoPM6WJvwythXDW7pW68d9xm8gl5N3ZAnotST+7xHcZ/yGbbfH622svd38uPTw66RkpGNqbUmBtpRCbRkFWg0FWg2FOg0x+VmEpscZb9JuoNHr2Hj9EgVaDbsHPlmlyP/94Hh8DrN2iCntCrmMWcPcGLDrJ7I1Ygp8NxcftvabRu7/xlFYfnNq020KViFD79uYbweDQeBgbBYHY7JobGtGLz8HfOzN72kad2U6e9sT804ffj+VwGf7orle7ri6LSKdbRHp9PC15+nO3owKdsVUeWcpTB91G8+KtXMp0etY7tmGx06cQ/dxV1wenY9dn6fv275L1MzgX45jYutMWKV0tqUTQm67ZMLf+V/EUVJLxGjRMV6teP7PWAJSdvFUyWqxgVyJ14t/3VZKucS9wabjI1i3H0PJtdMUXdxF0cXdFMccg/JrmrK0aFKXPYd8/Wx69X6aUf2eQ1VJzMsv1TLs15McistGC+xIUbB5en969XcgvjCHsJwUwrJTuJCTzNaECEr0WhZeCaW9YyOmNH1wnZglJECM6Ou24EiNy4LuogyHhISEhMS/C0kQrIVPPvmETp068fbbb+Pu7m4UBOfPn3+/h3bXaA16Xj+1hW8vHzbO6+XahJ+6jMHfxumu+p61vaIO4JyBzaqJgQAFF7aRuGA0XtpSlp/7k9/aPcr3lq4YBIEDqTG02zyfDX2n0NnZu8ZtlOq0jNm/1CjGPOITwouB3e9q3P80PG3NeKOPH2/08SOtQMPWy2lsvpzGrqgMY1pHemEZI34/xdOdvZg3PBBzk4qvu0yhxH36b8hNLcnZ+z8QDCT/MgWDpgj7vs/U61hN5ArsTc2xN609ukYQBGIKsjiado3Q9Hj+uh5ORmkR+1Ki+eriQd4I6l2vY7odcku0TFh+Br1BVF2f6m3PK2ErySlPr+/h4svW/tPRHV9J4fktACjtPHB99Jta+3xQiM4sYunpBJaeTiQ+p6orQiNbNT2bONCriSO9mjjg63BvBUK1SsHMLt5M79CYP84mMndvNNGZYjTmodhsDsVm47jBhCntG/FEp8b4O92eOY6buTUvBvbgs/B9lCpUjG43iWaFGfgdXUVQzGm6Dn6dli7e/7ryA/9UwlMKoLDCSOntvn6MDLqzKPYbZJQW8ln4fkB8IBYb4YQ+8TwfF3xrbOM2+XssAnre1Xb+K9zIqLiX5wmZXIF5k46YN+mI04jZ6EsKKI7YR86BXyi8sBUAQ1EOWVs+JWv7V9h0HI/9wJdQe7XGWq1i+xMdGbPkDNuvpFNUpuehX06wYWp7BgU4421lz/DGLQD4M/YcEw7+AcDTx9YRZOdGW0dJJJZ4MDHW+qvB7CgsRXwAIhXIkJCQkJCA/6AgePz4cZYuXYpcLmfEiBH079+/1rbDhg1j2LBhpKenY25ujqXl3bux3m8ySgsZt38ZB1JjjPNeCuzOl+2HoqxDzb5bseWymB7q62DOtA7VU3/zT/9F4sJxxif49m1G8M1Tixifk8KkQyuJKcgivbSQXtt/YFHXcUzya1utj+dPbOBMViIAzW2cWdR17H86msfFypRpHRszrWNjSrV69kVnsujEdf4KF81hfjwWz4GYLFZMbENrTxvjejK5XExpVVuStfVzAFKXPktZyhWsO03AzLdDneo41gcymQw/a0f8rB15vGl7pjRtR/dtC9ELBt49s50+bn60c7y7OmF3giAIPLUmjLhs8aq6fVMFK3K2G2tt9nZtwuZ+0zAz6Li6qqJWoPv0X1FY2N7z8daFvBIty86nsS7iCkeu1e5YmpBbyvIzSSw/I0b8NrYzY+GoIIYE3tvbCBOlnKkdGjOprSdrLqTw2b5oY5RYZlEZXx2I4asDMfT2c+CpTl48HOSGibJuEaVvBPXih8hQ8spKyTKxINTeglB7b3Hh7kUAeFna0cbeA51Shkp3IyZZ4l5jplIgN1Egl8l4OMiVjwbdfaT+yyc2GR8seRi8iYtOY1X+J5hRBoBd32ew6/3UXW/nfqDVG1h04jrH4nIYHezGsEAX5PKG+50UALO3ttHMyZINU9vj43B/0qsVZlZYtRmBVZsRaJKvkLXzG/KOLkXQloJeS17oMvJCl2Hi1gzr9mOxbj+Wv6a0Y+KKc6wLS0GjMzDit1Osmdy2SnT9eN/WnMpM4OtLh9DodYzat5gzw1/mv3vlIfEgkLJ4JoVx58hXVr2d83AMRG5qUWPqb7cFRwhLKaAfIEP87t6IJKytfqCEhISExL+X+5uHd49ZtmwZI0aMQKFQEBMTw4ABAxgxYgR5eXnV2qamphqnnZ2d/xVi4NnMRNptmm8UA9UKJUu7T+CbjiPqRQysfKM8Z2CzajflJfHnSPppolEMtOn2OJ7PrkauMqWzszdnhr/EQx7iTV6ZQc/kwyt5+/Q2DILB2MevUSdYFHUCAEulKev7TMFSZcqDzmdh+/BZ8wm/RZ28deO7QK1SMLi5C+seb8fSCSFYmYoXiVfSC+n43WG+2h+DwVDxn5LJZDiP/RSn0R8b52XvXkDcR12Ies6ZxB8eJffocnT5NzcFqW86O3vzfogo1usEA48e/INCreaejgHg1xPXWX1BNBJxsFBR5HzZKAb2c2/Klv7TsVCZkrP/J/Tlxik2XSZhGTTwno/1Zmj1BtZfTKT1kuXYLfmYlyNXc0R7FByvg1UmCnUJw1s4sWJiG74cGsiQ5s5Yq6veYFzPKWHcsjPEZxffl31QKuRMaOPB+Vd7cOyFbkxt3wgzVcU5Zn90FuOXnyXg8/1sj7h13UoQTXDW9p5MP/emuNZSqzK+MIe/rl+krLweZ7GZEq/VHzN63xK+vniQgr/VGpNoGKLe7kPhp4PJn/sQSya0RnGX4tb2xAj+iD0LgBpTkiMc+Db/U9wMmQCYB/TC9dH5dzvse44gCGyLSCP4q4M8sy6cZWcSGfn7KQI+388PoXEUl+nuehtx2cXMPxRLz/8drfK7r9EZCEvJp8uCI4Ql1+xUei8xdQ/AfepPNP36Ok6jPkRh7WxcVpYSSeamj4md3YqEWYF8b76BV/yLQRAo0xsYveQ0ay8kV+nv83ZD6OXaBIDrRbmMP7AcncGAhMT9ojQxHF3ypWrzBU0xhvL6xn8nyM26VtEv2M1KSieWkJCQ+I/xn4kQLCgo4Nlnn+XQoUOEhIQAsGfPHsaPH0/Pnj05cOCA0U04PT2d4OBgZsyYwdy5c+/foOsBvcFAfFEO6+LCeO/cTkrLxbhGFrb81WdKg6S8tHC1YkJrj6rjKMoh8duRCOViim3PGbhN+QlZJXdHGxMzNvebxuunt/BNeZH3z8L3EVOQycqej3EpN5Vnj/9lbP9793EE2DpT32y6mMone6/iYmnKa72a0KOJwx33dTUvg48u7GFZzBkAZh5bh7+NE91cfOpruDUik8mY1K4RXX3seeyPcxyLz0GrF3h9y2X2RmewZnI7LMvFQplMhtPwd1GYWZP252sIOjE6Rl+UTf7xleQfXwkyGfb9X8B14vwGHXdl3gnuy67kKI6kXeNqfiZvnd7K9/ewmHtcdjEvbLhofP/qQw68c0V8UNDesRGb+k7DTKlC0JWRte1LsZFMjuOI2fdsjHVhV2Q6j607TIbjGVCVwQ393KyiZqMe2K04h3dZRz7uNojXejdBbxA4n5THwdgs1oelcDQuh+IyPS9suMjGaR3uy76AeLx28rKjk5cdX49owfIzifx0LJ6LqWIa1LXsYgYvOsnENh4sHB10y/76ufvTz100isoqLeJ83HlCt3xBRGkh0eYORFk6kaeqWqfuelEu14tyWR8fzoKII2ztP51A2+q1OiUeTMKzU3gqdJ3xfWmCL7Pzl9BadwUAlZMPns+tQaZU3a8h3hEanZ7H/jjH2rCUasuuZhbxzLpw3t8ZyYYp7enic/vGPAk5JUz58zz7ojON8x6utFytlFOqM5BaoKHH/45y6NmuBLvff3FBae2E04jZODz0Ovkn/iTv2AqKIvaBQSyvUZYaRfaWT5gODLEOZILiddJxYPzys/yi0TG1PNtBKVewqtdjtN00n8TiPPamXOWLyMPMc5JMRiTuH0r3FvjMqlorUPbjk7W2/2FMMACjD4hlTWRQYyShhISEhMR/g/9MhGBkZCSlpaUEBVXcIPbr149Dhw6RnJzM2LFjjfVvnJ2deeaZZzh79iw63d0/Tb9XxBVks+TqKd45s43R+5bQ8q8vsVj+Dk3Wfsobp7caxcCerr6cHvZig9W/+WhQs2rRG5lbP0ebdR0A84CeuE1eWEUMvIFCLufrDsNZ1HUsynIjiTVxYbx0ciNvnd5mNEB5rWVPxni3qtdxx2cXM+K3k4z4/RQnr+ey+XIaPReG0v37o+y4kl7FcfpWnMq4zph9S2i2/gujGAhi5GPfHT/ya3mUY0Pj62DBoWe78P4Af278S3ZcyeChX06g0emrtLXv/zxNv03G4+kV2HR5DIVVJfdOQSB717foC2tPMa1vFHI5y3tMQK0QhcstiRH3bNsAuyIzjG6mz3X1RqOu2PfXWvbErFws0OYko8sThULz5r0wdW16T8d5M74/co2Hlhwkw/G0KAYCCDLkNZz6S/Ravos4QrvVHxGbFoNCLqNtI1te6dmEHU92onG5ecOmS2nsjbq3EaO1YWum4rluPoS91pPQ57syKKCiBuofZ5No+81hwlILb9JDVRzUFvQN6Mq7L65mnlcgiy+s4ejRhew6/gvq8sgqpd6AtbaiMFNcYQ7dty3kZMb1+tsxiQZBZ9DzWdg+2m6eT0JRLgDKIkdcswXGlu4EQGZqQaMXN6K0ujv34nuNTm/g0eVnq4iBffwcWTGxDYObVzw4yygsY9SS06Tk315k69Fr2bSbf6iKGFgZGZDywQC6+4pCY16pjkkrzlGme3Ai6OQmamy7T8HrjV34f5eK29RfsGg5ACplSLjmX2at7iNsDAXoDQLTVl3g7a0Rxsh6ZzMr1vV5HJPydRbGnCRHc3+ipiUkboagKebax91qfKUsnnm/hychISEh8YDwn4kQ9Pb2Rq/Xs2HDBkaPHm2cHxgYyF9//UXPnj1Zvnw5kyZNAuCDDz5Ar9ejUNybGmp3ytW8DNbFh7M2LsxYV+9mTG7SlkXdxqFqoNpwaqWcoX+rMabLTSV793cAyEzM8Hh6xS0jL6b7d8TH0p7Be35Fo9fxfcRR47Km1o7MbTu43sas1Rv45mAsc3ZHGQ05KnPkWjYP/XKCtp42vNO3KSNbutZYi0kQBHYmRfJ5+P4qNRoBzJUqinVaQBQFZxxdw9msJL7pMBwTRcN+DZUKOR8MbEZ/fydG/HaSrGItR65lM3t7JF8MC6za1tIBm84TsOk8AcGgp+TaadLXvkPx5X3i2DNiMbO8/ciSO8XD3AZ9uRDrpK5uUNOQVE5HDXa3JpmKG21H04qxqOw8UFjYoy/KpjTuLIKuDJnSpMHHd/J6Dgm5JXjamOFpq8bVSm0U4rV6Ay9tuMTCE1HgGwYq8dhraebI/7LCcLx+gfjSfKKVamLM7YmycOKAoy8lChOiyjR0Xf8FS7IjCQnshWXQICx82zNvWCBjl4ri9utbLnP6pR7I5TLSSgrYm3yVjNIisjRFZGqKyCotJktTTJamCLlMRi/XJgzyCKC7iw/qBoi6kslkdPa2Z9uMjqy5kMLMdWFkF2uJzixi0JJwvhkhMLOLV51rjcpVprhNWoBl0EDyjq3APDMOZaYBATnqMh2hRxcSbeHAB/4DOG/jTrammD47fmRD3ynGaEOJB4uovAweP/wnxzPijfMCrFy5csWH8aUrUSAKV04j3kPd6NaRpQ8SBoPA1FXnWV9eN9bSVMGyCa0Z0dIVmUzGhDYeXE4t4Lm/wtkfnUV6fgm/fPEaU9yzMG8UjNq3PWbe7Wqte/rbies8vS4MrV48F/s5WpTX63TljacWG9vZmqnY+WQnevzvKKcT8ghLyeeTPVeZM6hZQ38Et43SyhG7XjOw6zUDXWEWBWc2kLnpI7SZ8TgUxLLR/nMGC+9SLDPjs33RXM0sYumEEMxNlHRwasxLgd354uIBSg06fr96ildaSsYzEg3Do/Ff4VkSy7WPq0fbahLCULgFVpsvN7UQz2gF1fvTJISVT0m2IhISEhIS/yFB0NHRkQkTJvD888/TpUsX3Nwq3Am7du3K5MmT+eOPP4yCIPDAioERuWmsjQtjbVwYYTnVU4NuYKE0wd/aiWY24quTkxcDPZo1qAFHW08bVIqq0UcZmz8xpgrb938BlZ17nfrq496UJd3GM/7g8irzZ7XqV2+C5uHYLGauC+dSasVVUyNbNd+ObInOIPDJnqtcKK+FdCYxj9FLThPoYslXwwJ5qHnFxZRBMDD9yGoWR5+u0n8jC1teadGDGf4dMVOoePfsdj4vd7VceCWU8JwU1vaejHMt9cvqk64+9uyb2YWO3x6mVGfgq4MxDAl0pmeTmiNhbrg3WrUaWiEIpsdi5tOuwcd6g9iCbLTlaV0BNvWfHn4znC0ralOmFWhQm1ecLm9E2wLIlCqs2owg9/DvGIpzKYo4gGXQgAYd27aINIYsqlqPUiGX4W5tiqeNGSVaPedTc8D7IpiK371Wdm4sCf8LVbQornuVv/qWr59sasXTwaOIsXAkVW3FOKcW/Lj3J4I3zEFh6UCnlgOYateB37N9OZeUz7KzCWSbxfHe2Z0U6m5e3/FsVhJfXzqEmUJFbzdRHBzk0Qw/a8d6PR/JZDLGhbjT2cuO8cvPEBqXQ5le4Nn14eyPzmTRuFbYmNVdkLQKGYpVyFAAhPIHSQJyGj23Fpsz6/nlxGpebjGcIw4+FOnKGLL7V1b0nMho7+B62yeJu2dFzFlmHF1DiV4UxhUyObNa9UWd48172kuMLt0NgEylxrbn9Ps51NtGEARmrgszmv+YqeRsnd6xWqmLQFcr1j3ejs7z9vDk9c8ZlHWUwgQoPPGnsY2Jix9qn/aY+bTHvHkvVJ6teHXzZb47fM3YZnBzZ1ZMbFPr98hMpWDx+Na0+foQZXoDc/deZWRL1yqGVg8aSksH7HpOx7Jlf6593BVddiJO2WHsavQ9/UpfplRQsi4shYTcEvY81RkrtZKnAzrz5cWDCAj8cOUYL7Xojlz2n0m6kbiHeJbE4lEcA7Sutsy0UTA4Vc9KMHEWa136PP1ztWXXPq49PThl8UxKE8NrHod1MzRydR1HLSEhISHxT+E/IwgCzJ8/n3bt2tG/f3/27t2Li0uFoNO9e3d+/rn6D+eDRJFWw9Qjq1gTF1bj8i7O3jzcuCWtHTxoZuOEh7nNPXff7ehlV+V9WWY8Oft/AkBuZo3j4DdqWq1WHvEN4VphNm+f2QaAn5Ujj/pWvyi6XbKLy3hhSzQrwtKN8xRyGS/38OX9Af7G+npjgt3YFpHOJ3uuciw+B4DLaYUM++0Uh5/tQmdvewRB4IXjG6qIgS1tXXmteReGawvRRuwkY/1baJIjeNLFDy+vjrwqM6NEEDicdo12m79tsHqOfyfY3ZovhwXy/F8XEQSYvPI8Ya/2vKlIcuPCEkCbEXtb29MVZqFLvYJg3+WOjsWI3ApziOY29/ZpdmVBML2wjCbuFZ+RxlC1lIBVu1HkHv4dgPzT6xpUEBQEgfd2RFabrzcIJOSWkpBbCjIDNL4E5qLQ7W1pxyp7B/TlYiBKNabOvqicvFE5eKFy9MLDwYu9phaMDj/EGb1AnsqMaSFj+fbiJrrmxJN/fCWvsZJBSj/mOYziyTNnKTOpIfygEhZKEzR6HbpyY6ASvZZtiVfYlijWamtq7cgT/h2Z2rQDjvUYAdrIzowDz3Rh9vZIPt8fDcDasBQuJOezeXoHmjnfnUmUdfvRWLUeRllqFAsubuCdgIfY7hJAmUHPuAPL+KnLGGb4d6yPXZG4S6IKMpl6ZBVl5Q8WAm1dWNp9Am0dPRn8ywkGao5gL4gPfaw7jkdpeec1Y2+F3mBgf2o0HuY2NLe9+/OZIAi8uukyPx8X09VNFHL+mtK+1rq3Vvp8VpfN4ZhlOi+6DSfawgELXRk2ulKsdRqsdaVYpyVgnRSN296fEJQt+EUzHmSiCPBG7ybMHdz8loYuLVyt+GCgP+9su4LOIDDlz/Oceql7nd2/7xcqh8Z4vb6LuE+6oy/Mwi7hMEcCHRiQP4PsUgMnr+cyfvkZNk5tj4+VA4M9A9iaGEF0QSZ7kq8ywOPBi4SU+HeQZN6Etn+rEwgwM3Qd5zISUG79vsr8sJwUgu3cqrW/FaWJ4WgSwkSh8W+YGCQDLQkJCYl/I/8pQdDR0ZFdu3bRt29fOnbsyNKlS+nRowdarZZVq1YxdOjQ+z3EWkksymX4nt85l51knCdDRg9XH8Z4BfOwVxAeFvf/CXzHxlUFwcwNc6A8KsPhoddQ3EG66ZtBvdELBjYnXOabDsPvyhFZEATWhqXw3Ppw0gvLjPO7etvxw5jgau5qMpmMIYEuDG7uzMGYLD7cHcX+6Cz0BoEJy89y/tWezIvYy/+uhAKgkslYYGbCgIjNlG55lxRdWZX+Sq+dpue10yyzdOKFliNIVtuQUJRLl83z8bd2xMHcGgdTC+xNzXEwNcfe1JzGFrYMadQcK1X9PJl9tqs3Wy6nsTMyg+s5Jbyw4SJLJtQusqqcfY3TZekxtbYztsmIo+DcRgrObKA48hAIBoRBr+A6Yd5tj/VKXoVge88jBK0q0n7TCzW0UNQcIQhg0aI/crUVhtICCk6vQ5i0oMHShndHZXAmUXRGb+FqxQB/JxJyS0jMKyUxt4Sk/BIEj0iwEgVsR1MLtvd6DNknXY192D21GrcOw6r1bQMcbDmA0fuXsjMpkhKFCc8Gj+aza4cYdP00hQoTNno35pSHDkEmioFymYxnA7rSw9UHB1MLHEzNcVRbYG9ijlqpokBbyr7kaHYmR7I98QpxhTnG7V3Nz+SN01uZfW4n47xbMTOgM52c6p7aezNUCjmfDW1Oa2cVz22JIbOojKuZRXT89jCrJ7dlQLO7O55kShM8nl6B5r3WfB6xDWtdKas8QjAIAk8cXUNKcT5Tm7a/Lw9mJET0BgMvnN9qFAOnN+3A950eRq1UodUbOBSTyS+lW43t7fs+0yDjMAgG1seH897ZnUTkpSNDxlPNOjG37UPYmZrfcb/v7Yjkm0PiQxqFXMaqSW0YGFDzcZ0QH8Z3f77FSrdgkszqfq3gWbybkhI3JrTuyWtdG9fZ3fn1Xk1YH55iTB2eu/cqHwx88AUzU/fmNH51O/Gf98FQWojZ5Q0c7uRAz+QxZBZr2RaRziubLvPdwy15JqALW8tr2y68EioJghL3nPCcFC7lp9PKvmrmTbCdG0F3IAiCGHX4d5MSgLLv/lnR0xISEhISdeM/JQgC+Pv7c+LECWbMmEHPnj0JDAwkLy+PTp068eabb97v4dXI6cwEhu/5nZQSMYrB3tScj1oPZJRXEK7m99/BT0AsKA7QsbGtcb4mJZLcI0sAUFg5Yj/gpTvqXyaT8W6rfrzbql+1ZTnFZczZFUV4SgHdfOzp5+9IJy+7amnLAMl5pTyzLoyNlyqizuzNVXwxNJCp7RvVWBew8hh6+TnSw9eBAT8fZ29UBkJmDBN+2c8OKzFdUi4Y+PzSVrpnRFFSQx8qR2+02Qlg0NO8MINVZ/7glcChnLJrTBlwMT8T8msu2G6uVDHOuxVjXAIYbG9/VwKDTCbjt0dCCPrqANnFWpaeTmRYoAtjWtWcym3iVOGIrEm5gjY3BW4YrJT/1eWnUXhuMwVnN1B6/Xy1PrJ3fI1FYF+sWt1e7cfKgmDzBnCUvhlOFlVThk0VFRGCpeUi9w3kKlOs2o0m78hi9IVZFJzfinW7h2kIPt0bbZz+bEjzKjU7BUHgpRMb+S5C/NzMlSq29Z+O/eFFZOaIDxOs2o/BpEmXWvu3UJmyqe9UphxZxcrYc2hlMl7z7cWGoOFE5aWTpqz4XFoUpDIn6Tw9nZywcHLHxNYXxd/S361UakZ4tWSEV0sEQeBqfibbr19ka+xZ9manYkBAo9exLOYMy2LOEGLvzsyALjzq2xpLlenfh3fb9Gtix7lXejDy91OcScwjr1TH4EUn+WZ4C57r5l3jd0mrN7DpUio/HYsnLruEAc2caugZTF2b4vbYApJ/ncbsq3uxl8v5wU2MrHjv3E7eO7cTe1Nzgu3caGXvbvwbaOtiNKWRaDi+izjC6ZxkAFrYuvC/zqMwLRf2Tyfk0rdgD610UQBiqqxv+3rdviAIbE+8wqyzO6o8zBMQ+DHyGOviw/ii3VAm+7W97XTTuXuu8vGeqwDIZLB0Qggjg6oKAHqDgSPp1/j+1CY2pl9H61y11pjcoMSAHuS1G2YlmluDeRHfX9/G99e3EWTnxgB3fyb4tqaNg0et6ykV8iqpw5/sucqIFg926vANzHzb4/nCBhK+HoygK4Pjv7Kzhx1donqh0RlYcOQaTR0teLZbM7zMbYkvzmVzwmWi8zPxs/5nmdFIPPj80Lg58WaWfPG3KEAQIwFbWDtzZMhz92FkEhISEhL/Bv5zgiCAu7s727Zt48KFC5w9exZ/f3+6du166xXvA+eykuixbaGx9lEzGye29Jv+wFx03nDeu8ENJ1JBEEhf8zaUpwo6Dn27mlBwtyTklNBlwRES88Q0hn3RmXy4OwpvezNWTGxDZ++KaMRT13MZ8PNxcksqhJyHAx35cVwbnK1qFx30JQVoM2IpS49Fm3mNsvRYFuZEcj3/LEsbB7PMqq2x7QeRuxmYEWV8b+oeiHlgHyya98Y8oCdKSwcMZSWUXr9A6bXT2MSdZum1M8zPT2abczNyVWYUKGuOAizWaVkcfZrF0adxObuRPm5+9HHzo7drE3ytHG5bIHS3UfPTmGCjScRTa8No38gWL/vq0SpyUwsUNi7o89IoiTrC1RfrVgMSQOXka0wzTv51Gn6fRaIwr/sNYUS5IChDRhOrhkvlqwkTpRxbMxW5JVrSCzWoFWbGZRp9dfdx2+5TyDuyGIDcI4sbRBA8nZDLgZgsAILcrBjSvKpIujT6NN9FiE/2lTI563o/TohCTvS2LwGQqUxxeeTLmuqMV8FEoWR5jwk4mlqwIOIIAgKHi/KgXAw00+t5OfYg45POo0AgfXXFwxSVozemni0x9QxC7RmEwtqJstSrlKVGUpYahSwlkv6ZcfQXDCSbWrGp7SOssnYnvbQIgPPZyTwVupaZx9bRzNqJVvbuhNi706r85WpmddvHu6etGYee7cLUPy+w+kIyeoPACxsuklpQyieDm1dpezEln9FLThOVUWScdzWziIepePBRGZvuUygM207+qTU8F7kbJ3tPPjStOPdka4o5kBpTxWhILpPha+lAoK0LLexcaGHrSqCtCwE2zpJQWE9E52fy7pntgPh5/97tEaMYCHDu+D7eKlpkfO88dm69j+HFExtZEFE10qarszcXc1PJKyslo7SIqUdWsS8lmqU9JtS53w3hKby7/Ur5O4HZQ90xsc/iy/CrxBZkE1uQxbXCbOIKc4w1WG846coFgaHuTZnZshcDPPxJydew7Uoq26KSOBSfRramBBRarEzS8LaIJNLShjJ5xecWnpNCeE4K8y4dxN7UnE4mctRlBvRyGcnFebhXOr83MyvmN98wss9spKM2DO0sOKyywaC2wczWCRs7Z6zsHFFaO2PdYdwDZeZi2aIvHjNXkvj9WBAMqA99xV+DvBl8ujEAL228SDNnC6b7tOW9S3sxCAIfnd/Nktv4P0pI1IV4M0vizK2oKb8m2M6NpmZ2NSyRkJCQkJCoG/9JQfAGrVq1olWrVvd7GDfl3TPbjWJgX7emrOk96a5SjOqbP85WdTa+caOed2QJBWf+AkBp54Fdn5n1ul29QWDSynNGMbAycdkl9PhfKF8Mbc5LPXy5mlnE4EUnjGKgh42aH8cE09lFiYOVKYIgoM9LozTpIprE8lfSJcrSo9EXVI3YMwA7nJvxRbuxZJhW1CF7PfYQE9WmmPV9BvNmPbAI6IWyhpp3chMzzP06Ye7XyTjv+/x0rs8bTGncGXQyGbrA/pg9sYTsshKyNMXsT4lmWcwZsjTFAKSVFLAy9hwrY88BYkpoB6dGdHRqTEcnLzo4NqrTMTKmlTuT2qax7Ewi2cVaRvx+iqPPdcXCtPppQd24NUXhO27ZJzIZZk27Yt1mJFZtRqBybkLs1yPQhG1Gn5dG3vGV2Pd5+tb9lFNS7swsIPDlxQM1Rok2JC6WJuSWaEkt0GBf6TONyE2v1tbcvztKe0902YmURFVPt6kPYjIrRKrBAS7VhLH18ReN0793f4RBngGkr30XQSt+TxwGvYaJkzdkZd1yW3KZnG87jsDFzJJZZyv+96O8gpjd4iGmfeWHrelqBmmOGB1aAbSZcWgz4yg8v+WW23DXFPB06CKe8WrD6TGf80tiFIfSRAHZIAhE5KUTkZfOn9fOG9dxUlswyCOAOa0H4HMbIrG5iZI/J7WhpZuVsQbj3L3RNHex4rG2Yv3OP88lMX31hSpu40q5DF2lBx8CMPiXE7zbryldfcRoXbepP1EUdQh9XhrjT69k8KdX2JoQwYXsFMJykqukSd/Yt+iCTKILMtmUcMk4Xy6T0cPFly/aDaG9U+M675tEVQyCgWlHVhl/O19r0bPK55l7ZClddzyBShBLOqg6TsayRf2fW/68ds443cnJi0/aDKKPe1PSSgp449QWlsaID2SWxZzhCf+OdHf1ra2rKqw+nwzqArBNw9olhw+vFcO1m6/jpCnkUUHDy498glel9EIPGzOe6OjDEx19MBgEwlLy2Xs1E5kMZnb0JHP7Z+w9+DsnbDw4aduIMGs3dOXiYramGL1CDhgoNVXgseojWlra8axMS9+IXWhjjtNaqPrQ0LKsBMpSIT8S/XXILZ+fvvkzynq9TstHP8DEpOFd2uuCdbtRuE39mZTfZgAQmLSZOQO/4/2dkRgEeGzFOTZPCuQbk1ByykpYGnOGPm5+PN60fiNNJSS8iwtqjQLMqsPveX0RZ25FtxoiFQGC7Nz4ocvoezYWCQkJCYn64T8tCD7onMtKYntSRfH97QNm1Ju7bn1QotXz7vYr3PCcvSFNaJKvkLKs4sLFbfJC5CZm1da/G77YH83B8kgpH3tz/prajoi0Qn46Fs+BmCx0BoFXNl3mQEwWF5LzySwSb/wG+Dux+tGWKOKPkblxPQVpEWgSL6IvrP2CSgAiLJ3Z6tKc7c7NSDOtiHRU6gUG4cFnsw4gv0OhVmntjNcbe4h9rzVkxqG8tAvn43/Q/KFXARjeuAWftRvC5oRLLLlykqNZ18kpq0hKztQUVTFqAPC3dmKwZwAfthl409qD349qyenEXCLSCrmQnM/jf55n9aS21dKnXR/7luwdX6Mvzi2fU75cJgOZDJlChbl/d6xaD0NpXTVqzfKht9GEbQZEofh2BMFP2w5m2N7fMAgCs87uwM/KkUd8Q+q8/t3iaq0mMqOI7GIt7e29UCuUlOp1/HntPG8H96mSsi+TyzF1a44uOxF9UTaG0kLk6rszr/g73X0dkMvAIMD68BQ+HRJQRRTUCRVC1sONWyLotOQc+lUcn9IE+4Ev3db2bqTrN7NxYntiJA97tWRoIzHt8OunHuHJNc35Ni2G7mVnaaK/TrA8mRZcR1acXWufCitHTFz8UTk0ovDCVgylhRjiz9Jh0SRGvbiB2M4P82vUSY5lxBOek0Kxrmp6dkZpEctizrDq2nmeb96Nd1v1rfNDEplMxuz+/rhZmfLEGtGcacbqCzRxMGddWArzDlaY5nTysuOLoc0Jcbfht5PXOfhtRT/br6Sz/Uo6vZo4sHh8CF72dpi6NqM4Lw1BW0oHR1Gcv0FeWQnhOalcyE7mQnYyl3LTuFQeJVYZgyBwIDWGDlu+Y2rT9sxt89ADURbin8aCy0c5nCYqZH6W9nzQeiAAgl5H2qo3yN75DTfiMM+Zt2H81JpvcO+WEp0YSRxk50bokOeM31UXMyuW9JhAT9cmTD+6GhBTzPc/dPMHZ8kl+fwaHsZW3RHwE+uI5utrbutgao5ncTYemdcYkBHFUA9/fF/ahOwm1xByuYwQDxtCPCqi/Bo9/D7jggbS+6/3KbqwmkK5ir2OfuxzbMJFq+o1yi4W5jATaOQQyLSiQkamXsZE0JOvdiFTsMRMm4eNoRBzqh77ckGHev+nbDiyji1BH9IyqC29/Rxp42lT57qFDYFdz+lkrJ+NLjcFTUI4s19tyoXkPNaHp5JRWMYrW+P4bshIJh1eCcBTx9bR0s7tnpiESUjcS7xKCmtdFpaTcg9HIiEhISFRn0iC4APMp2F7jdNvBfV5oMRAgO8OXyMht9QoCAKUxp8nft4gBI0YyWTX7zms2gyv1+2evJ5jjPBRyGWsfKwNrdxtaOVuw9hW7ny8O4o5u6MQBNhUXi/QRZ/JJMsInimKJPnVvcbx1YpcQZJ7C7a5BbHZwpkYaqjvlOeELqUJLXu0uGMx8AYKC1s8nlpO3NweIBhIW/M2FoF9UXuFAGCqUDLGuxW9rTyxtbMjLCeFvclXCU2P40TmdZKL86v0F5WfQdTlDHYlR7GhzxSa2tRcA81arWLTtA50mH+YnBIt68JS+Gh3FO//rfi7qas/blN+vKN9U7r4o/btQGnsSUpijqNJicTUrW7F1wc3as78DiN44cQGAB4/8ieNLW3p7Ox9R2O5XVwrpZMXaQRGeQWxIvYc6aWFPLxvCfsHPY26UoqnyqEiCkmbnYCpe9V01LvF3UbNwGbObL+SztXMIo7F5dDFpyKRSFYpqVUACs5tRJ8nfges249FaXVnpQbGeLdijHfVaOpefo5cfqMXS0/78fImT/JLRfHDVCFjwcNOjHfLpSzxIvriXExc/DBx9cfUtVkVYyFN6lUS5g+jLCUSXV4q8Z/2pNH03/im86OAWAMtpiCL89lJXMhO4UJ2Mscz4snSFFNm0DPv0kF+jz7Fe636MzOgMyaKuv2kzejkxaW0AuYfuoZGZ6Db90epXP3g6c5efDuypdEV9cUevhz6tno/B2KyGPDzcUKf71bVREavhUrvbUzM6ObiQzeXinqcgiCQUpLPpZw0LpcLhIfTrhnrZv5+9RRr48KY1aofLwZ2r5LuKlE7V/MyjK70cpmM70OGYqZUoS/MJnHhIxRd2mNsu1g9gtSu7zCxnstZ3OCGG7mF0qTGNPcpTdvx9aWDXMpN40BqDPuSr9LHvWmVNqU6Levjw/nt6in2pVzl79X+zBQqhjduQXtHT3ytHPC1csDb3IaCxU+Sf2wFAAprZ7ym/3ZTMfBmmPt1wuv1nWizE8k7tgK36GOMuX4e7aXNzC4Rk+lNtHra5CZy1lYUwhLMbJnTbAA/BQzk5SZteKbjKCxNTMkqKmPf5etEZ5dy6VoCMQlJBGcf5JnilajQ01IbRZOzk/k6cgpvqQdjY27Kp4MDeLqL9x2NvT4w9QxCl5uCLjcZQ1EOvz4SwrmkQ1zLLib0ej59rrrwUmB35l8+jEavY9S+xZwe/hJO9fxASOLfS8rimZQmhte4zMTSizJ5/ZjK3Q0zr4sGOsNf+LXasg6/v0xpQhjXPu5W47pqzyDcpvzQoOOTkJCQkLgzpDuM+8DUw39i5mSPDBltHT2Y6NuGJn+rCXglN521ceLFgae5DY81aXM/hlormYUa5u69+re5AnFze2AoFSuUqX3a4fLIl/W63YJSHY8uP2tM4Zsz0J+OXhX1UxRyGe8PbEY3H3seXX6Gfpl/Mbp0NwH6a5ADJQnV+1Q5+WDi0ZI09xaE23pwVq4mtCiP8zU88TRVKBnWKJC25s15e3UqANbq+vkamft3xXH4LDI3fgh6LYk/PorvB6eriY0KuZzWDh60rlTQPbEolxMZ142vU5kJlOi1XM5No/2Wb1ne41FjZNff8XO0YM3ktgz85QR6g8Cc3VH093eqIjTdLbbdHic19iQAuUeW4HIb9bqeD+xGVH4G30ccRaPXMWLv7xwf+gI+lvYU68rI0hSTrSk2/jXWzAIevcvvTWVBMLVAw3cdR3I84zqxBVkcz4jnydC1LOk+3nizr3KsiArTZsbXuyAIMKV9I7ZfEUWjxacTqgqClTQHAYGc/T8Z39v2fqrex6JUyJnWsTG9/RyZsPwMJ67notELPLkznW0tXfn1kedxNq89/c/UtSk+s4+LQs3FXQhaDUk/TkSTdBmnUR+ikMvxt3HC38aJcT4hABRpNcy7dJAvwg9QpCsjW1PMSyc38n3EUT5vN4SHvVrWqcbgl0MDuZRawO6oTKMYaKqUs3BUENM61p6uKwNWPtaG2Tsiic4sIiqjiOG/nWS5omI/DVoNilu4TMtkMtzNbXA3t6G/hz8gCqCLok7w7tntZGmKKdBqePP0Vn6JPMHXHYYxtFGg5Fh8EwyCgWlHVxtThV9t0ZN29h5okiO4/s0wtOUu6XqFCbPMnmGTug8/NmkYsyKDYDCei0wVNQtxcpmcOa0HMmb/UgBmn9tJbzc/ZDIZl3JS+SXqBMtizpBdXi7CiAAU2UKuC7GvTMDVokJ4Egx6kn+ZYhQDZSpTPGeurLGExe2isvfEccgbxvf6ohyYLDqPmugMrMmN5oJcx08ugewsEcecKgi8GX2GLxOuMLFJG3q5NiHE04ax7f2AlgAk5EzkxPFHcd7yPI6FMZhRxrtFP9Or7CSzDS8wc52WMr2BF7rXLaW6vjH1DKLo4i4ASmJPYhs8iFWT2tL1+yNo9QKf7L3K1ukdOeeaxMHUWK4X5TL+wHJ2DngC5QP2IFfiwaQ0MRxNQhimjYKrLSuTq9E8AILgzTBoihD+fp4qR5MQdo9HIyEhISFxO0iC4H1gT/JVKBUjEjYlXOL9c7vo6uzNZL92jPUWLwY+D9+HUB4L8HpQrzpHvtwrFobGGyOCbtyeyhCMYqB5QC8avbgBuUn9XsS8sOEiMVniRUcPX3ve6tO0xnZ9/Z043uo0JZt+rr7QvhH5wYOJdQ3mmrM3J3PSOJ4RT3pxIRTHVWuukMnp596UR31bM7JxS6xN1GINJ0RB0KqGmnt3itOI2RRd3EVJzHHKkiNIW/U6bpP/d8v1PC1s8bSwZXT58RNXkM3D+xZzPjuZvLJShu35jTmtBzCrVb8a3Sz7+jvx5dDmvLLpMoIA01ad5/yrPVGr6udmxqbjeNJWvIygKyMvdBnOoz+6rWiVbzoMJyY/i+1JV8goLaLlX18Z3Wlvxt0Kgm7WFcdvSn4p7RrZsqnvVDpvXUCBVsOymDO0tHPljaDewN8iBLOu39W2a2N4Cxej2cmf55KZP6IF5ibVj0FNWqwxGsrEvTnm/jU/ua8PfBzMOfxcV2Zvj+Tz/aIL8oaLqZxOyGXFY23o7lt7rT+FhS2NX9lK2spXyN69AIDMzZ+gSYnAfcbvKMyqpsxaqEx5L2QAT/h34v1zO/n16kljTb7R+5fQ160py3tMuGWqrVIh589Jben07RGuZhbRyFbN+intadfI9pb7O761B9197en83REScksJjcvhDMXckNwFfdkt+6gJhVzOUwGdGefTijnnd/N9xFH0goHogkyG7/2d0V5BrOg58YH7PXhQWHD5KEfKU4Wb2Tgxp/VAitJTuD7vIbSZ8QAobd35xW8um+JEIb2bT8OYFWkNFXU1TeW1/78e9mpJiL0757OTCU2P463TWzmSHkdoely1ts2sHJni34FtxwQOx4m/g5Vrm4pi4FTyQpcDohjY6MWNWAT2qae9qorCwo4bVwACMnznnMYXeBi4kJ3Mp2H7WH3tAgICmZoivr18mG8vHwagpa0rPVx96enqSw8XX8Y89BCGvhfJWD+brB3zQBDoqj3PX7nP86vZGD5cn4NSLueZrt4Nsi83wyKgJ9k75gFQeGk3lsGDaN/Ylq+GBfLihksIAjz6x3l+fXQIMflLSSzOY19KNG+f2caX7Yfd8/FK/DMxbRSMz6zq9YcTF9W/4VFDIDM1x+fF6uOvLWpQQkJCQuLBoIY8SIn7wdH0OJ4KXYvbqg8ZcGgxi6NPA2IB/Rn+He/z6KqzNUJMQxSDVaomMVm1G03jV7fflptsXVh9PpnFp8QQP1szFcsebV1rbaGiiAOUbH6fKAtH/vBozZftHuXF/m8xcvAcQkIm0BlLJqbGMitsH5sSLpFeWrU2ilwmo4uzNws6jiTpkdnsGPAEk/3aYV0ucBZoKoSo+ooQBJAplHg8tdxYey5n70IK6mDO8He8rew5OuQ5JvpWCGLvn9vFw3uXkFep/mBlXuzuS3df8SY5MqOID3dH1djuTlBY2mMZIt4Y6bITKYrYf1vrK+UKVvV+jCA7sWZViV57SzGwPvh7hCBACztXVvacaEzPfev0NjZfF40h7oUgqFYpGB8imgIUaHQ8/9dFhPLC/ZVThnPKHY8B7Ho/1eCRZSqFnM+GNmfXk51wKf/cEvNK6bUwlHe2RaDR1VLsDPG4d33sO1wf/8Hohlpwej2x77WhJPZUjeu4mVvzc9exXBjxCoM8KlLQ96Zcpc2m+UZh6GbYm5tw9pUebJ7egYuv96qTGHgDDxsztj/RCZvy739cpWJugu7OBMEb2JmaM7/jCMJGvkJ/d3/j/HXx4Uw8tAKdofbP8r9KRG5alVThxd3GY6ZUUbjzC6MYqPZph/cHp1idLX5/7MxUNHdumLTOyucnk1oiBMWxyvmwvMYhwBcXD1QRAy2UJszw78iJoS9wpNcM3grug9JQUZNXWf4bKBj0JC+aRl7oMqBcDHxhA5ZBFX3fS1rZu/Nnr8e4MuoNpjXtUK3kycXcVBZeCeWRA8txW/UhTdZ+ymPH1rEqeDhpz65H49wEABuhiFeKl7A3expliyeyevVShEpi673APKAXlIvwRRd3G+c/382HIf7ib2ZuiZZHfg9nkvMATMr39auLB1kVe/6ejlVCQkJCQkJC4naQwgzuA5cffh0PT08KtBrWxYexNPoMZ7JEt16NXsfZ3IpU1Zdb9MD8Fqln95rMQg2nEnIBeNb8FCkICOVChF3vp3Gd/P0d1yqqjT1RGTyx5oLx/U9jgmlsV71unyAI5B//k+Rlz/JTo/Ys8OmKcEMI0WrFVw24mFnRyakxnZ286OTsRVsHTyxVpjW2Bcgvrejn64OxZBWVMSrIDS/7u3eANnFpgutjC0heNBWA5EVTafTS5irOxHXBXGnCsh4TaO/YiFdPbUYvGNiUcInu2xayb9DTOKotqrSXy2UsGteKVl8dpFRn4Iv9MUxp3wh/p/q5YbbtPoWC0+sAyAtdftuunlYqNVv7TeexQytIKMrFQW2Og6kFDqbm2JuaG/+qFapbd1ZHKguCyZUcrYc0CuSLdkN4/fQWBAQmHlpByiPvobKvLAjG19s4/s4L3X348ZjY/28nE+jX1IkJbTzQCxU3ynmhyzEHZCo1tl0nN9hY/k7/Zk5ceLUnj688x87IDAwCfLo3mnVhKXw3siUDA2pP0bTv8zSmrv4kfj8WfVE22vQYrn3YEYuWA7Hv+wyWrQZXO7e0tHNj+4An2JUUyZOha4kvzCGlJJ/u2/7HII9mPOYRxHg7OxTymp9/WZoqGRp4Z+mULVyt2DC1PQN/PoFWVvFzWlvq1O0SaOvKzgFPsPH6JSYdWkmhTsPauDCSi/P5tuMI2jk2qpft/NPRGvQM2f1rlVThTs5eaFKvUnxIrH0qMzHH87m1JAu2JOeL3+WuPvbVDJTqixv1AwF0txCwhjYKpINjI05mVtS0aGfvzhQ3X0abmaPOT0N3ahXFRUVkWFrTNv4aLiU69DI5eUcy0GUnkntkCdoM0RRHpjQRxcDgQQ2yb7eDv40Tv3Ybx/yOwwlNj+dQaix7EyM5m5tSpbxDbEEWsQVZrIwtd2YOHIlLcwM+uYmMSQ5jUEYkA8pCYWsoh45+TtCMb7EPujeu8wozK8yadKIk6giaxHBSl7+Aw0Ovo3JoxMLhTXl5Zzzrw1PRGQQ+3ZLOoE6d2VEoRkpNO7qKbi4+eFjU7wNSCQkJCQkJCYn6QBIE7wNWJmqsy18vBHbnhcDuXM5NZVn0WZbFnCGpWHQPtDUx45mALvd5tNVZG5aCIICJUMbkjEV8zo0IRhmujy+s10ikrKIy3thymd9OVtwoTW3fiHHlEVKV0eWnk7JkJmlnNzErYBA7nasbV9iamNHU2hE/a0fclea0c/Omk5MXXpZ2tzVul0pC0YXkfF7ZdJlXNl2mXSMbunrb09zFkgBnS5o7W+FkWXNB+Zth0+1xCi9sI//UGvQFmcR91BmrdqMx6fsqOHSucz8ymYwXW3Snlb0b4w4sI6O0iPCcFNpvns9kv3aM8goi2M7NOD5/J0tGBbmx4lwSeoPA9ZySehME1Y0qTCn0BRl31EcjS1sODn6mXsZTF/wcK0TTvy6m8t4Af2QyGWV6HRdzU43LinRlZGqKcLmVWU09oTNUjcqNzykmIjeN3cliXU9LQY8qv9xMpOP48tS+e4eLlSnbZnRk/uFY3tl2BY3OQFRGEYN+OcHIlq58M6IF3rWI5xaBffD9+AJJPzxKcdRhEASKwndQFL4DlUNjbHs9iW2PaahsqzqcDvBoxplhL/HYoRXsSBJNh3YkRbIjKZJZl/fydLPOPNmsU50dietKLz9HFo0L5vSiijqwuYd/x3nMx/XSv0wmY6RXSzb3m8qg3YvQ6HWEpsfRYfN3PO7XlrltB+P2H3ciLtFpSSz/3QR4L6Q/AIUXtkK56OQ47B1MHL3QpFdEgxuEv1t01B/WKjU2JmryykrZkRTJqtjztTqky2QyfvHw5Y2UCJwLM3k46SzNMsUI17/7dRcCUyu9T/lbfX+Z0gTPB0QMrIyVSs1Aj2YM9GjGK94dMLex5niGKBAeTrvGyczrFGg1VdZJk8lJs2vMcbvGrMxvx3tXduBXnIVT7mVSv+pPgv8AAp/+pUpkdoONP2QYJVGiyJe9ewHZ+37EtvtUTLs+yZrJ7Zi94wpz94rlEnYcV9AkqAkxQgzFOi3LY87wZnDDpG1L/Dt4wdSTGFOLGtODC8jDigdDUC4q09NtQfW04GJB32APVyQkJCQkGhZJEHxACLR15dN2g/m4zSBWXD7B3px4HvVtjY2J2a1XvscsOyNGM44v3Y5FcUU0o4Cs3sRAQRBYfiaRVzZdJrOoIv1uVJAr/xsdVK19/sk1pCx9huvaMp5rM4EoSzEKSS6T8XZQH4Y3boGftWOVektZWVk4ONxZ/ahHQjzIKtKy5HQCZxIrbkRPJ+RxOiGvSls7MxXNXSxp4WrFU528aFuHtESZTIbbtF8oy4ilNO4MgBhdd+YvdF0n4/TwB5hUMrC4Fb3c/Dg59EV67fiB+MIc4gpz+PD8bj48vxtfKwdGebVklFcQHRwbERov3oKqlXK6eNefkFR05YBx2qxJ3UXN+0kTRwt6+NpzKDabC8n5HI7NpoWHmtH7l3AwtTwaBxnfdhiBl6U9WeXpegBmTbs22LgWHKlIhx3g78SzXb0Zvn+RMeJmatwxVIIBpa0bLmM/bbBx3Ay5XMYrPZswOMCZZ9dfZF90JiDWFtxxJZ23+vjxRh8/zGqoU6my98TrrX3k7PuR7D0LKEsV09e1WdfJWDeLjPWzMWvSCau2D2PVZiSmrmItUQe1BVv7T+enyOPMv3SYqHxReI4rzOGtM9v49vIRlveYUM3J9W4Z39qDt8wH83jJRtSUkbXza+z6PoPKrvqDizull5sf+wY+zcxj6wjLEeOyF0efZm1cOO+06sMEl+Y0TDW8Bx9rEzWjvIJYde08AJF5GbR19KQk5kRFm7YPA+DvZIGvgzmxWcXsjsogp7gMu5sY39wppgolX7QbylOhawGYemQVftaOtHX0rNJOk3qV9FWvozy7ka/vZoNyBZathuA47B3Mmzx4ZUb+jplSRW83P3q7+QGioc6VvHROZFznbFYikfkZROSmGx+QnrF2ZVSHKTyUFMN7sVux0GtRRe3iwuwuBH949LZ+D+8E+wEvYigtIHvXt2KtZL2W3AM/w6Ff0XWeyHvD3qGpYwhPrLmAziAQE+EEAaKJza9XTzIzoIux5IiExN+JMbUgzsyqxpsyK2xopHasYcm9xfwmNaX1ggD3NpNfQkJCQqKekATBBwyFXM5gN38mtXwwBZOYzCJC43KwMBQzs3Rtg2wjKqOQmWvDjQICgL25ii+HBjKlfaMqTyENZaUk/zad/GMrOGnrycvB48hViSKqnYkZq3tPol+lGlz1hUIu4/nuPjzf3YdrWcWsC0thXXgKx+NzqrXNKdESGpdDaFwOv51M4K0+fszu3xRT5c3TqhXmNvi8d5zcI0vI2PABuuxEEAzkHVlM3rE/sO/zNI7D3q2ze6S3lT37Bz3NzGPr2Z0cZYyOiS3I4quLB/nq4kGcTC3JsDADpRn+ji6cz0mkqY0jjqYWdy323jC4ALC4zXTh+8mL3X05FCuKpHMPhxNrdZyr+eKxaaE0YWXPiQxr3AKAosv7jOtZNO/dIOPR6PSsvSAK8TZqJRuntWft9fMcSBVvPn2Ks5l2/TQolHg+uxqlrWuDjKOuBLhYsefpTqwLS+GVTZdIyC2lVGfgg11R/HryOo+19eSREHeC3ayrHGMyhRL7/s9h1+9Zii7vI2ffDxSc3SBGfAkCJdHHKIk+RvqqNzD1aIFVm5FYtX0YtXcbZgZ04almndiXEs03Fw6wI+0qBkEgpSSffjt/5q3g3sxpPbBaXbM7RaWQY+7UmOXFw5hRsg6hrISMvz7AfVoNpkZ3QRcXb84Of5lFUSeYdXYHmZoiCnUa3jmznVnsoJW9O11dvOnq7E03Fx88LWzrdfsPMv3cmxoFwSNp18oFweMAyM2sMXELAMSHLY+EuPPp3mi0eoG/wlNv6ip9NzzZrBNh2cn870ooJXotI/f+zqlhL+Jqbo2+KJeMTR+Tvfs70FeUoJCb26Cy80Rp54HKzgOlvSdKW3dWROtYE56OQtBjIhN4q5c3rd0tEfQ6ZHIF5oF9qkXN/pNQyOW0sHOlhZ0r0+hgnL8rKZLnj28gKj8DPbDFown7XV/kuajDTEo7gXlREqdnd6P1R6GYNWAKvVxlivPoj3AYJJofZe2aj6EoBwx68o4uJS90Gf06jGPn8JmM3F5MgQYotAXLXK7mZzJ0z69s7z8Di5uUIpH4b+NdUsDlF+bfk21pEsKQ0U98kI9gNP6ozekYxAekAEeer24SEvjd7w03WAkJCQmJBkUSBCVui+VnEmmhvcrHhd9hrb8RCVc/UYEanZ4v9sfwyZ6raHQVjxont/Pkq2GBOFlWvZA2lBaS8O1ICi/vZYVHCJ/79UZf7qDbwtaFjX2n0sS64Z+q+jiY81rvJrzWuwk5xWVcSS8kIq1Q/Jsu/o3NKsIggN4g8Mmeq2y6lMri8SG08bS9ad8yhRK7ntOx6TyRnP0/kr7xY4SiLNBryd69gJxDv+Ey9lPs+j6LrJYaaVXGauXAjgFPkFFayObrl1kfH87u5CjKyiPLMjSFYCOm1IVxna7bREMHGxM1zaydGO/bmmcDuty2y6kgCEZBUG5mjZlPu9ta/34yvIULje3MuJ5TzM6igyCITtqe5jZs7jeNEAcPQCzqXxx5EBCdTE1c61+IBthxJYOcElFAGB3sRolBw6vH/zIunxW1B7WpOR7PrGpQZ+HbQSaTMaaVOw8FOPPpvmi+3B9Dmd5AQm4pn+6N5tO90TRzsmBciDvjWrnT0s26yrqWLfpi2aIv2pxkco8spuD0emPkLIAm6RKapEtkbv4EtVcb3Kb9gpl3G/q5+9Pa1IEiUznPHf+LzQmXERD4NGwf+1KiWdFzIr5W9RNX5+9kwaL00Ywp3YWtUEDuoV+xH/ACas+W9dL/DW44ET/iE8KHF3az4PIRdIIBAwLnspM4l53E9xFHAWhsYUt3F19ebdmT1uXH6b+Vrs7exukj6dd41tMfbWYcAGa+HaqcH28IggCrzic3mCAI8E3HEVzOTWN/agyJxXmM3reEtWZK8v96D31BxUMvlUNjnB/5AusO46o9fPliXzRvRkaAiRdyGfw5qS29WtVf9OmDzACPZoSPfJVvLh3iowt7KNKVUaQQ+Lx5Nza7N+PLK5vxLk7k+LvdCJ5zGAfXhk0fVljY4TTyPewHvkzOvh/I3PYVhsIMEATyT6zC9cQqQlsM5ZncwRxObgo+50Gl5XDaNR7et5hNfaehVtZfnVsJidtF7VmeZZNZfZlpo+CK5RISEhIS/wkkl2GJOqMvK4WdH7Ii73X89aKhgdzc1mgocjfEZRfT+bsjvLcj0igGNnW0YO/TnVkyoXU1MVBfmE38F/3Jv7yPOf79mNu0r1EMHNm4JceGPn9PxMC/Y2duQmdve6Z1bMwXwwLZPL0DV9/uQ9Gng/lyaCCmSnGM4SkFdPz2CB/sjKRMd+s8C7mJGoeBL+H47mmcRn2I3EwUTARNEanLXyD+015oUq/WeZxOakum+XdgS//pZEyYw8qeExnrHYxCqFnoyysr5WRmAq+c3ESLv75iY3yFs21dKEu5gi43GRAj52S3KSjeT5QKOc928QbLbDAXxcDmNs6cGPaCUQwEKI0/j6E8vc2iee8Gc/VdcTbJOD2xjSdv7PqR9DLRJGFIWgTdlQq8Zx/DqtVDDbL9u8HCVMnHDwVw6Y1ejA52Mzqkguhs/dHuqwR9dZAWX+znkz1RpOaXVllfZeeO07B38J1zmqZfx+P62HeYN+9tdCYGKI0/y7UP2pO68jUM5TUdG1vasbHvVBZ0HIlp+bF3IuM6IRu/ZkXM2XrZN38nCwrklvxsPlacIRhIWjjeOIb6xtbUjK87DOfSw6/zcosetLZ1Qymr+pN+vSiXP2LP0nnrApZcrdmt+d9CgI0zDuUlIY6mxVEcfdy4zKxJVUOmYDdrmjmJ0S57ozPJKKxau64+UckVrO49GR9L0Y02NCOeZ05sRFsuBspMLXAa/TFNPruCTcdHqp03dkWm89a2COP738eHMPY/IgbewESh5M3gPlwZ9QbjvCtq0V62cWJ0u0lscQ7ApfQ6Z97rQVx83D0Zk8LMCschb+A46wwuE79FaVvxP5Ff2sKPSc+wtGA+TaOtQSeec3YnX2XorsVVzFQkJO41blN+wGfWEeO1u4AMn1lHjC+3KT/c5xFKSEhISNxLJEFQok6UXDvD5XdbMzZrBcryQiFmTTriMzv0rvveE5VBu28OcS4pHwCVQsZ7/f0Je60nfZpWF/V0uanEfdqLopjjzGnWnzXuFTcI74f0Z12fyVipHqxaPWqVgtd6N+HcKz3o0NgWEI0h5uyKosO3hwlLzq9TP3K1FU4jZuP3VSz2/V+A8pvH4qjDxM4KJmvH1wi3cLT8O9Ymasb7tubHjuMRIrpCZEd88jrxQ+dRvNyiB0MbNaeZjRPy8m1FF2Qyct9i+u38iYs5KbfoXaRKunBgw6ULX83LYF/yVeOrvpjesREylwrX4E9aD8HdvGqR76KI/cZp8wZKF84v1bLpkmhm4mZlgi5iEb9miAKhpU7De4ZifN4/idqzRYNsv77wc7Rg7ePtSJszgF/HtWKAvxOKSuLg5bRCZm2PpPHHe3h0+VkOxWSh/5uRisqhMfb9n8f7rX34L0jD/YnFqL3aiAsFA9k75hHzbhCaSPH/IpPJeC6wGyeGvkCAjVhjtECrYeKhFTx2cAXns5Io0+u4U26Y76xQD6HISYwK1CRdImXx07clnt/2dm2c+LrDcHb3mELuxI/YN+hpPmo9iEEezbApr1mm0euYcmQVzx//618rRshkMro6+wCQUpLPlZsIgjKZjPGtRTFfbxBYF1a389id4qi2YGOvx7Aodx7e4NaSV1oMQ9VtCn6fR+E0/F3kNdQLjssuZsLys9w4fD7o48Xkdv9dZ2lPC1tW9Z7EnoFPGb/DpQoVbwYO4b1mA3DQJnHxoz6cvhJzz8YkMzHHYcAL+H0Zg+vkhVUMTtoWHGdD2jvMC9+OqU783u1Ni6TD2p/R3sW5RkJCQkJCQkKivpAEQYlbosvPIP6zXijSrwCgQUVyt1l4zzqKqXvzu+o7JrOIob+eJKtYTIFs7mLJ+Vd6MmdQM9Q1FDA2aDVcn/cQBUmXebv5Q6xzE1MbTOQK1vaezAetByKXPbiHdXMXK44+15VPBwdgohDHeSE5n67fHyE2q+6RREpLB1wf+xbvd49g4ia6KQvaUtJWvkr2ngW3PS5BEPh8XzQGA6BVM8G/BU8HdOHrDsPZ3G86V0a9SfjIVxnoUeHcvC8lmk5bFnAlN/2W/Rec22SctmjR97bHVxc2xl/Ef/3n9N35k/FVXxzIiEQwE6MDKbYiO62q83JZRhyZGz80vm+o+oEbLqZSWh5R+q5TGB9ePYVQLtS+SRntXt+B0tqpQbbdENibmzCtY2N2PtWJ1Pf789OYYPo2deSGNqjVC6w8l0TPhaF4fLibp9ZcYMeV9GpRtUpLB2y7PY7P+ydwmTAPmYkYKabNuEbuT2NJ+mUq+iKxvmcre3fODH+JJ/0rRKI/Ys/SetM3WCx7h8D1XzB2/1I+OLeTtXEXOJeVxNnMRPTlpxW9XMaWhMusjwvnQEq0UezzL6+vpJWp2NNhHvJywTgvdDnZO+7KLqLOWKhM6e3mx6yQfmwf8ASZE+bwaouexuXfRxzlvbM778lY7gfdXLyN0wdjKiIizXw7VGv7SCWn+vXhDSsIArif28Bnl7agLBdkdzv581XgkFqNZwRB4LE/zpJd/ts4tpUbz3b8b0UG1kZf96acHf4yMwMqai2vcwvihZYj8NLGETp/Gil/iy5uaOQmauz7zsTvi6u4TVuEysnXuGxQXhi/hq3GTC8apJ0viiFg9bdE59eQsykhISEhISEhcQ95cJUTiQcHgx5BV+H0u1Pdnc6T30NWDwX5V51PNqYIj2jhwokXuhPoalVr+4z1s0lNvsKMVmPY4hIIgFImZ03vyYz2rrkQ8oOGUiHnrb5NOfNyd0LcxdTfQo2ed7ddue2+zJt2wffDczgMedMYLZh74Jfb6uNEfA7dvz/KF/sroipGtKxuRBFo68r2/jPY2m86zWxE0alIV8aMo6sxCLVHJWoi9hojBFXOTYzF/eubHyOPNUi/WaVFPHNsfcWMdC82X04DoCwthuRfZxD9ZlPReRJQOXqhcvJpkLHcMBNBEOiZ+AfXzWwBsJHJeGvaQuT/4IL1jpamPNnZiz1PdyZhdn8+GOCPq1XF/qQVaPj5+HUe+uUEAZ/v53xSXrU+ZAolDoNeocnci1gEDTTOzzuymJi3A0lf/x75p9aiyLjGj51Gsqb3JGwrRWbpBAMReemsjQtjzvndjN2/jDabvqHt5vmUmoppf6WmCobt+Y3R+5fQe8ePfBomGsl42lb0c03mgscTSyvG/udr5IX+UX8fVh1RyhV81WEYf/R41JgqvfBKKEXahkuRvZ90qVRH8Gz5KUnZqHWNIrm/kyUqhXjOvCG6NSQlMcfpkxXDT2HrjPMu5qbW2n7F2SSOxokidjMnC34dF9JgZQj+iZgpVSzsPJpVvR7DujwjINTemwU+XQkpvcCHu6Luy7hkShPsek7H7/NI3J9cinmzHshUprTOT+b78A2o9KIgHFuaQquN8/jhSmiDRhBLSEhISEhISNwMSRCUuCVKW1ccp/6GvvxwGV66j8INs+rlIvaGsAKwcHQwVuraa8sVXTnI2f2LeLTNBM7YegJgpTJlc79pDG/8YKdI1kRLN2sOP9cVd2vxZmZtWModRTXITcxwGfcZ5gG9gHKDhTrUE4zLLmbCsjN0+u6I8cYT4IlOjWnfyLbGdWQyGYMbNef88FdoXp6ydTQ9joURNaeOC7oyCja8Y3zvMu6zBrmpLdRq2JcimgS4m1szp/UA5rQeUC99P39iA+mlotGKWbErFDpwNeI88T9OIvqtZuQe+hXK07/kFna4TPi6QfYxv1TLrqgMAAaYX0eefAHrcmFHI1egVNSPY+6DgLuNmvcHNiN+Vj/WTG7L+BB3LE0r9u9adjFdvz/KX7VEdpk4+dD41e24P7kUmbkdALq8VDI3fkTi92OJeSuAK09Z0ua3qewtSuQjG1um+LamvWMjLJQmtzXWOed3cTUvAwuTivEVafRYtRmO8yNfGOclLZpCYfiu2+q7vni0SRumNW0PQL62lD/L3Xj/bbRSW6Io/10Kt3JFaeuOzWM/1tg2Ka8ErV5s28TBosHHpssRU/s75iYY56lqMYIq0uh4c2tF3cAfx9z8t/G/zDifEHYOeMLoGP6LV0fOOTix9PhVrqQV3LdxyRRKbLtOwvudg/i8L0ardspN4LW4RCgVI5iLdVqeObaekXsXk1naMLVGJSTqE01CGNc+7lbtZWK4txG5EhISEhL1hyQIStSJ2EaDecfyRQzlRYiztn1B+tp370oUTC/QcOK6KES19bTB3ab2un/64jw2L3+ZR9tMIN5cLM7uaW7DkcHPMsizYSLO7gWWpkqe6uwFiDUFF524fsd9Wbd92DhdcHZDre3ySrS8ueUyAZ/v58/zycb5QW5W7HqyEz+PbXVLQUutVPFrt3HIyo+Ht85sI74wu0obQRDI3PIZ+gwx8tA8sA9W7Ubf7m7VicpOyeO8W/FeyADeC7l7QfCv+HBWxp4DwEltwRS7VnxeMI8/02dSdGw5lG9TYemA85i5NJ0Xh3W7UXe93ZrYejndGE37pPIwALa6EgBK9TqKK0Xx/lswUcoZ08qdlZPakvnhQLbO6EBXb1HgKy7TM2rxaT7ZE1XjeUgmk2HbdRIObx7Fuv3YassFrYbS+HOojy5m1MbZzN47j+ODnib/sY+5NuYdtvSbxufthvBc86680qIHqvLP3kSr58t2Q5noK9YrLDPoeeb4esxVFT+nxVrxuHB46DXsB74sztTrSFgwipJrp+v1M6orTzerSK9sqGja+4m+KJf0b4bgXyiWMIiydMLljd0onZrU2D46s9g43cTRvMHHd8NUCWsX4zylrGYR/4v9MSTliTfYo4Pd6OV37w2y/kl0cvZiQceRxvfvBDyErSKJYb+dIjG35P4NrBx9YUVqcCcHV4hpA5kVhlSbEi4RvGEee5LvT1SjhERdUHsGYdqo5kycMrkajfzBqt0tISEhIVE3pEfOEnXidEIuW9S9kSMwt/BbZAhkbfkUmUJ1x31ui0g3Fktv11TJ5EMr2Z0chVImx1JliqXKBEulqRixc/08u316UCYXD9nW9h5s6T+tmrHDP5EnOjXmo91R6AwCPx2L5+0+figVt6/VW7UZQeryFwAoOLMBx8GvV2sTei2bkYtPkVFYIR65Wpny8UMBTGnfqIqxw63o7OzNC4Hd+PbyYYp0ZUw/soZdA58AbRl5x/4ge+c3aJIuiY3lClwnftdgKW+bEy4bp4c1CqyXPjNLi3g6tCK974fOo2m69AWUmoPGeQprZ1H06TMTudqypm7qjXXl0XAqQUuzFDHSzLaSQUS2phjz24xu+ydhqlQwuLkL/Zo68cy6cH49KYrns7ZHcjGlgN/Gh2BWQ91RhZUzns+tRpudRGnCBTSJ4WgSwilNDEeTHAF6MV20NP4c6WvfxXXCV3hb2eNtZc+QSsfSaO0SAFQ6gdeCelGq03Ii4zrRBZnsSb7KluSLxrZFZWLEqEwmw2X8V+jyUsk/vhJBU8T1eYPxmR2KiYtfnfddl59O4fmtyM1tsGjRD0W5y/jtEGzvThdnb0LT4zidmcjpzATaOf47DCr0JQVcn/cQpddOEaSyIcLKBa1cwRUTC2r7lGMq1Wz1a+AIQUEQ0OaIgqDcrkIIUtYQIRifXcwX+8VoZ1OlnC+H1s/57N/Ok806cfD0RlZqdRQrTRC8E0mObUTvH46xf2bnKin99xpdbkUkc4CvLyQqINWPYCtvMmzDSSnJJ6Ukn/47f+a1lj35pM1DmCiky3OJB4ubuQ8nLpp7D0ciISEhIVGfSFccEnXidKJYr2uTug8fDfRDuf55EIRyI4U7i4jafDkVLLPBMYGfMnIh4yaN5RW1xAa7+LKq/3Qs/8H10irjZq1mVJAbqy8kk5RXyqZLaYwKdrvtflQOjVF7taE0/iwlMcfQ5aaitK2oBXguMY+HFp0gv1QUK8xUcl7v5cfrvZtgaXpnp4JP2gxi0/VLXCvMZm/KVT76cxbjjy5CX1D1n+k47J0Gc741CAa2JojpdTYmarq7+t5ijbrx/PG/jKnCj/iEMEQhIzZGFAOzZdb8Yj6Wue99gaOTfb1s72YUl+nYfkWMfBqpvIC8NBcAJwdPY5tsTTGeFrYNPpb7jYlSzi/jgglys+KVTZcwCPDn+WSis4rYOLVDrZHGKnsPVPYeWLUabJwn6LSUxJ4k/sv+CGUlZO+Yh2XwICxb3NoJW61UsbDzKAbs+hmAN05vRq5shUGnpLisQqiVyeV4PLEYfUEGRZf2oC/IIP7LATR6cSPqRkE33YauMIusbV+SvXsBQll5RJtCibl/dyyDB2PVajAm7s3rLLQ/3awzoelxAPx45RiLuv3zBUGDppiEb4ZSEiO6CrfSlbC6fNnJjAT8XGo2vorOrBAEGzpC0FCSX/H/s604tytrMMB6c2uE0Tjo1Z6++Dg0fPTivwGZTMY8Tz/CLhzgkrUrJWoDeEQSnRB430VBXV5FrUhXD29auFpxKbWASzEqLr/9HK+d3WB8qPXVxYPsTY5mZa+JOJpacK0wm2sF2VwrzCa2IItrBdnIZDI+azuYEAeP2jYp8QAyc20Y4Sn5NS7TCwIKqUaohISEhMR9QEoZlqgTpxNyAVAr5TQfMhPH4bMqLb39tOE/os+yoXQLeIeDZa5xvr2pOT6W9jirLTFXVo0+VBr0PG3vwqZBT/9rxMAbPNPVyzi9MDTujvuxajtSnBCEKs6+kemFDPzluFEMHBTgxNW3+zBnULM7FgNBdDX9vc0A5OWhnh8Xl3BRqLioNQ/sg+2MFTg9POeOt3ErTmYkGIW7QR4BxlpSd8P6uHBjnTUntQULOo0kZ1/F0/FvLSax1GwEKy5m19JD/bLjSoZRZJosP2qc7+JZIShlaYqrrfdvRSaT8WIPX7bN6IhNeW210wl5tJ9/2HiuqlM/ShXm/l1xmVDhApz88+PoCrPqtH5/D38m+LYGIK20EIVrHABFlQRBcTsmeD6/HrWXmGaszbjGtQ/aiSn1RTn8HX1JPunr3yf6VR+ytn5eISYB6HUUR+wnfdXrxLzTgujXfEhZ8gy6tFvXDR3rHYy9qSgwrYg9R67m/qdT3g0GrYaEb0dSHHkIAIWVE4PGf25cfiKj5hIMWr2B8JSK+nJ+jg0bIWhMF4aqguDfIgQPx2axqryMg5u1KW/3bdqg4/q3YeXkzfxLm7C78X2xyQTHBKIzi+j9w7H7lj5cOUJQaevKiBZi2rjeIHAitoiNfaeysPMo1OVRgeeykwhY/wWOK9+n/eZvGXdgGW+e3spPkcfZlRzFzqRIum37H1sqRcZLPPiEp+QTllJzXUuFTIb8NjI0JCQkJCQk6gtJEJS4JUUaHZfLi3O39rBBpZBj0by3cfntXsIsiz7DY4dXYDCtiNBobuPMoq5jSRo3m9ix75A24QOKJn1KfFk6Jw9/x4HQHzivSeWHEa+jqKUQ+z+ZHr4OtCh3V957NZPrOXcm7lhVqiOYf2qtcfqljReNacK9/Rz4a0p7PGzuPlpCMBjw/G0aT8WL0Tk6uYKvm/TEptsUfD86j/ebezENHNCg7pg7kyKN0/WVLvz66S3G6R86j8aurITco+WusWprtql7istC4ykuTw9tSHZEitGBKkGLT7pYP1Dl0BgX94r6mdn/IUHwBgMDnDn+QjejoJOcX0rvH0LZWsmsqC7Y9X4Ky5BhgCjeZKybXed1v24/DBsTMSpRa5MEqhIyisowGKo+KFGYWdH41W2ovdsCouFO+pq3iXzehevfDCfv2Ar0JfnkHPyV6Df9ydz4odG5WmZihv2gV3EY/Dqm7lWPcW1mPDn7fiD7f8PQF+XedKxqpYqpfqK5SIley/KYM3XezweRnL0LKbq0GxANfbze2EOrpp2NxjCnMisMPK5lFfNDaBwP/34Kh9k7jRG3aqUcN6uGrX1VWRDSWTobpxWVIgQzCzVMW3XB+P6zIc3v6mHNfxGVgxfumgK+urzF+JAKl2tglk90ZhEzVl+4eQcNhC4/vcr7ES0rIvff2XaFUwm5zAzowpnhLxFsV7fsgCJdGRMO/EF+mWTm8E8i2M2KI893q/YyN1GgVv77rm0lJCQkJB58pF8fiVtyOa2QG/e2rT3Emn26nOSbrFE76SUFzDy6vmJGoS2ftxzLxYdfY7p/R9SVogJLYk9RGLoMC70WV1MLmk3+/o734UFHJpMxpHnFjeKNgvK3i6lHC0zcmgFQdHkP2iwxQuZi+VNpRwsTNk7tgLqGWmt3QmH4TjSJ4SiFiogo95b98Hjid9SNW9XLNm5FUSUzDR/L+knfvSFfmsgVDPZsTuamjxA0ooBt32sGvZs3BkS323e2XamXbd4M8/L/lwzBWPNOad+I4vJpwBhd8l8jwMWKEy92o29T0XihUKNn+G8nWXD4Wp37kMlkuE//FXl5TdK80OUYNHVz/XQ1t+atoD7lHQGWOSTllbLxUmq1tkobF3xmh4oR1jfEIL2WwvObSfpxIpEzbUn5bQb6PFHQlKlMsR/wIk2/jMV1wle4PPIFTT69hN9X13CdvBDLkKFQHhErFGaSsfHDW473yWadjNPLY8/WaR//CTgMehV142AUcjlNrcVjIak4D71BYPqq8/jO3csz68LZcDGVAk2FiD8owLnBI3MUlYxEdpSnbAPGcer0BsYuPWNMY+7sZcdjbTyRuD1MnHxQ2rrTKTeBl2LFByfIwKRRDCCwMzKDmMx77+arrmTEkLr0Wdq4mBHgLNacTcwrpcuCo3y8O4pm1i4cG/QUr5goCC7OomdWDI8mnuON6P18d3Ej604t5cewirq2CrkMM+Wd13GWkJCQkJCQkJAEQYlbUrnmSZCbGMWWc/g347zbSRgeu2s1RQaN+CbHhW9aPcob7Tsi/1stJUEQSF35ivG98+iPUVo63P7g/0FUNkS44SZ7u8hkMmy7TxPfCAK5h34HQFuu6DqYq7BS159wlLNnAYlqa35u3BEAlVzBx5XcHu8FTuqKdL/MOoo4t2KAhz8gOsjuvXKE7H0/AiA3s8Zx6NsseDgICxPx//Xt4WsciqlbiumdMipIjBopk5mQY+YOgCb5MvGFFemmXpZ2DTqGBxl7cxO2zujA5HaiiGIQ4IUNF3l+fTg6Q93OUEprJ2w6PyauX1pA/sk1dd7+4MpO5xa5AHy4qxb3Y6UJzqM/osncSzgMfRuVk0/FwkrtbTpPxO/zq7hOnF+lFiiAiZM39n1n0vjlzfh9EY3MREwDzt6zAE1KJDfD38aJDuVmIicyrhOdn3nT9g8yliFDjdNFEfuM0w6m4jmhSFfGc1si+e1kQpX13K3VTG3fiJWPtWHVpLYNPk5Tj0BUTmJt03XaCjHyRrr5W1sjOFB+DmlsZ8bax9tJ6YN3gEyhxHmcmDI+JeE0zYvEY7vMJB/sxCjN308l1Lp+Q2HX91lMyx+QlcafI3P9u+x6shPdfcUHWHqDwOwdkYybt5L4D7sxfdcXrDy5mIXhG3g3eh+PJ56lb2Y0ztpivm7S09jvh8271EuJDIl7Q4zpecLMDtFt6/fVXpEqqVaohISEhMT9QRIEJW7JxdSKmictXa0oiTlJ8WXx5svUowV1TRo+mZ7AoWzR/AGdijeaD+ClHjUbQBScXkdJ1BFxG55B2Pacfuc78A+hcrpI6R0KggC23R6H8mixnEO/Ihj0lJX3p7oD9+La0KRepSBsO3Ob9kFT7jb9WsueNLNxvsWa9YtTJXffjPJagnfLQx4VAs+GY38ao/Ich7yF0soRHwdzvhpWkbo5ddV5ijQNlzrczcceN2uxbuZFgygIGopyuJ5XkYrW2OK/KwiC6EK8eHwIHz/UzDjv+6NxPLYmgvxS7U3WrKDyeSbn0K913nZLO1ccymvzqazzAYHzyfksOZVY+3jdA3AZOxe/L2Pwfu849gNeROXkg3lAL7zfO47H08tROdza9MPEyRunGzVd9TrSKj1IqY2JTdoYp/+I+edGCZq6Ni3/DYLiKwfRF4o1Pe1NK8ohrLkiRmqaKuV8NqQ54a/1JPG9fvw2PoTxrT0wuQdpejKZDKu2I0k1teSkjShat7R1JdjOjdXnk5l3MNY4xr+mtKvVGEfi1th0mYhV24dRIDA7clfFAtdroChj8akEdPo7/329E+QmajxnrkRmIh6X2Tu+xi7hIPtnduGThwJQymBU6S7evjgNIUlMa5ap1FgE9sV+4Mu4z/id9Fd2ML7vG0RZiFGlLfNTGJ9x67qhEg8ORfJ8iuU1m4o00xbTTPvPrukqISEhIfHPRBIEJbiQncyBlOgao1mgaoRgC1crMrd8anzvMOStOm9n+oENxukQZTCfDQqusZ1BqyFt1RvG9y4T5iH7DzwFr5zGW6rV36TlzVHauGDVegQAuuwECsN3ojXcEATrL+okZ+9C1rgFc9ChCQCNLWx5N7hvvfVfVypHCGaU1k+EYG83P0zKj7l9ZeUpunYe2A940djmqc5exjTV2Kxi3toaUS/brgm5XMbYVqIQeFVeIRLF54tuzjYmaqxNJBFBJpPxbj9//nysDablQs+emFy6fX+0TnU5zbxao/YSo7ZKoo7cMtruBnKZnJ6u4vdAK9eAqbitp9aGEXrt5sYzMpkM8yYdcZ04n6ZfxeL99n7Mm3Ss03ZvYD/wZRT2ojFR4YVtFIbtuGn78T4hxvp1i6JOoDXc+fnmfmPVZqQ4YdBTcGErAHYmlaJtFFpUChnrp7TjzT5+tHSzbtCaprVh3fZh/nQPQSjf9mNN2nA5rZBpq84b2/wwOog2nrb3fGz/JmQyGR5Pr8A8oCet8lMYnRwmLlDowPUaSXml7IzMuOfjMnVvjuuj843vk355HKEgnTc7O3LG5Tc+Kvwec8TsiUiFNwvbLsXuxe24TJjHUocm9D+3l6QS8VrMtTSfT6/soOjEn/d8PyTuDnODNUeGPFfttSbzMh/n1b3MhYSEhISERH0hCYI1cOzYMcaOHUu/fv345JNPyM3Nvd9DahDK9DpeO7mZkI1f03vHjwzevYikorxq7cLLIwQ9bdSY58ZQcHYDACpHL2w6PlKnbe1NusrFonjxjcaMn/oOrPWmLHv3d2gzxAsjy1ZDsGzZ/zb37J+JaT1FCALY9XrCOJ174Be0elHsNamnCEFDaSFnT63jc79exnmLuo7D4j64PzdEhKClypTuLmIq5zVzexLV1jg9PAe5aYXQIJPJ+HVcKyxNReHw+6Nx7I9uuPTLR8oFwViFKAgKQEK5APpfjw78O4+09mD/zM44WYrmEuEpBXT49gjH46s7+v4d2x4VUYK5h367Scuq9C4XBAF6BYsRumV6AyMXnyIuu2ENX+QmaiyHVzh5p654GUFXe1Sks5kVo71Eh+rE4jzWxYU16PgaEqOzOhh/my4mVUTayJU6Vj7WhsHNXbifRNl78Xtj0dBFZdAzzLU5D/9+yuhI/VRnL6Z2aHw/h/ivQW6iptGLG1E3DuHla0ewuRF5ZZcKZnn8erJm9+mGxrbXE1i1GwWAPj+dhO9GETs7BOXFDcY2y9TDGG/7Fd9Hq3l4yXEeObCcF09sRCeI1wQD3P3ZnHER3+JsSmKOU5YhiUgSEhISEhISd44kCP6NHTt2MGLECIKDg+nQoQPz58+nZcuWHD9+/H4Prd4QBIGDqTH02L6QeZcOGufvSIqk5Yav+DJ8P+HZKQiCQEahhrQC8al1SzcrMrd+bmzv8NDryOpQ0FoQBGYe3Wh8HyxvRYfGNZs/6PIzyNz0sfhGocRl/Fd3sov/SCqnDN9pDcEbWLToj8pRjBgqOL8ZmzJRqKqvlOH0I0t53bcnpeWpwq+06EH/8rp79xrHyjUE6ylCEKBPpY/qqG9XMRX7b3jZm/P18BbG99NWnaewgVKHO3nZ0chWTUy5IJivNKWoPKq3sYVtg2zzn0xnb3tOvNCdZo5iml5agYZu3x/l/R2R1RyAK2PT+VFkKjHaMvfokpsKa5Xp5VYhCDo4F/NQgJg6n1FYxtBfT5JVVFbbqvWCadAQzAN6AVCWcoXsfQtv2v6lFt2N099cOlRrhPiDjtq7LUo7DwAKw3bw5a6LhEZXlLl4spMTo4Pd79fwANAZ9EwPXYuuPCrz2bhQlv++hKvlBhcdG9vy7cgWN+tC4jZRmNvQ+LUdONu5VxiMADL3KDZdSuFiSs2pmw2JTCbDfeovKO3FtPGS6FCj8ZfCyolGL2+h0/M/Y2VhAaaF7DPsZk1ceQoxMt4L6c+2/jPw6TDW2Gf+cSlKUEJCQkJCQuLOkQTBv/Hyyy+zcOFCZs+ezdy5c4mIiMDPz4++ffty6NCh2+orPz+fxMRE4yslJaWBRl03rhfm8NH53fit+4xe23/gRIZ4IapWKPEod9fMLSvhjdNbCd44D7dVHzJ233KwSwazfB7OX0fekSUAKKydse0x7ZbbFASBl09u4mpRueNmsRXzevaotX3m5rkYytNi7PvMxNQ9oNa2/zbUyoqU4eK7SBkGkMnl2PaYIb4x6OmnCQUgp0RbLzf+q09v4LKVGHETZGnP3LaD77rPO8VGVZEqm6WpWyRWXb6bHS7vNE5/7BzIk8f/Irm4egTtjI6NGeDvBEBcdgmLG6hovVwuY1wrdzLkYjRgiqm1cVljS9sG2eY/HR8Hc7ZPDqK/v5jarTcIfLg7ire31Z7erbCww7rdaLF9XhqF4TdPv71BC1tXY/r6jqQrfDjCkxauognTpdQCWnx5gI0XqzsP1xcymQzXifON7sWZmz5BuEkqcCcnL6O5yMnMBM5lJTXY2G6H2/3dlMlkxrRhoayYnVtWgVARfR7kfu+jlv/OloQIzpZ/vs0L0piScBqXaPEhmZOlCWsfb4ep8t9fFuNeo7Rxwev1XYwvziAoXzyOBLNiTD1OETRvH70XhrLybNJdlei4XRSW9ng8tRwqZUhYtOiP78cXsAoZwvAWLozqowW/s6AWf89sVGZs7T+NOa0HopDLse4wzrhu4cWd1bYhISEhISEhIVFX6s9u9F+AwWDgypUrNG5ckbbj6OjIzp07GTZsGA8//DAXLlzA09OzTv19/fXXzJkzp9r8nJwczMzMalhDJD+/fp9clxn0vHh+K2sTL1VzBG5q6cCitiNpbG7D7Et7WX79gnFZWkkBaSURIAZf8IxgwKf94wQUphPi3YE2sZdpbetWpb+srAq3VUEQ+ODyfv4Xc6J8BnhrAglxkFdpdwN9fqrRzVVmaomi+3M1tqsv6vtzvlvUgsY4HZ2SQ1aWVbU2tzNmnXuIcbqleREIojCx/Hg0g/1rjtCsU7+pkZikRYOLWAOyh0tTCnPzqC1Zt6E/520pUcZpd5V5lWPGwaFmZ+ravpsFBQXG9RvnZ9BTCwcdm2BArLX2R8wZnmnSgbGeLfEytzU6PL7a2ZVdUWJdqvCELLKyrKv1XR+MaWaNfodYKD/DtCIy0g7VbX1XHrRjv0EpK2b5qKYsPGnBJweuozMIfLE/BidTgaltXGtcRdZqFBz7A4CMQ0soa9ylyvLaPusx7i34IfYkRboyHj24lF+HP8K4FVdJLSwjrUDDyN9PMaaFI58O8MHO7NbR1bdDfn4+WHti2moYmvMb0RdkkHpuDybe7WpdZ5JnMCczRQF72ZUTeDWv/Xepvrnd7+bNfjeFpn1g7/8AGKQ9zl7bbsZljeTmDfo7UhfOpFSkdT4VfxyVYMBSENNYFw71w0xfTFbWrR9mPOjf27p+zvd0PxQ22D6xivcXT2Ni8yFoFCqKbUrw0hzmQEwvDsRkYWemZFxLJyaHuNDM6fbcXu9oX5xaYj3hf5SE/o46ZCRm3Z4gXy+HrCy+u3qMX+IOVni1FVthU9CaFgoH4+erTah4oKFXWdXb8X1jX2r7bkrcmplrw6rU3a5MsUKPuYkk/EtISEhIPFhIgmAl5HI5LVu25LfffqNDhw7G+aampqxdu5aQkBBmzZrF4sWL69TfK6+8wowZM4zvU1JS6NChA3Z2dre84KqvCzJBEJh8eCVrEi8Z5ylkch7ybMZUvw4MbdQck3JH2mWuk5hTMJhdSZHsSb7K3uRociu5nullcqItHIm2cGRLSSEcW4lKrqC/iRx1mQGDrGLcgiAw6+yOKmIgic15tU87HB0daxxr6vY5oCsV93/gSzh5NXwK6oN04dtaZgaI/6eUEqHWsdV1zKWFntyomNbHywzixOm5hxKZ0KEJyjtMH04/uIOQ/GRkgoAgk3EmP/WeHc81sT+ioh7UI/7t6rSt2r6bVlZWxvVL7N2Zf3o9f3q04pfmD5GtLaVEr2NeVCjzokJRyuQ0sXagmbUz7mo7sEsHjTnZWucG218bU7Ao2wJAqkmF6Ojr4HLb23yQjv2GxsHBgQ+GOOLtZMfUchOHN3fGEujpWGNtOaHDcApWOKPPT0dzaQd2lmbV+quJr7s+zKn8ZE5nJnK1MIt3Y7Zz/OXJvL4pkjUXxAiltZcyORifz1t9/Hi6sxfmJvX3M+zg4ICiwxiSz4vRZ4r4UBzaDqy1/aOWHXn5wnZ0goFtadF83XXUfTHcqMyd/G4K7YeRv8wOQ1EObmbXwVxMGbYV7Oni0eS+H+u5VyvKCHiUimKBDgXdfe0Z075JbavVyP3el5txO2O7p/vh0INhb+1h2aIZTHVsTpHSlHhn4bEdrAABAABJREFUGaNz/mBT2ThySuCnUyn8dCqF3n4O/DouBB+HuguDd7QvA2eKr0r8EnmcDyMOGN831jTneqwj15Hx8ZEUfh7bCoD0AxWlXhw6jcG2Hj/LB/n4+icQnpJPWEoBwW7VH+iamyiw+BcLgsVlerotOFJt/hsp+ZirFPjchzFJSEhISNwaKWX4b7zxxhv8/PPPbNiwocp8a2tr5syZw/r16+vcl7W1NZ6ensaXm5vbrVeqZ2ad3cHymLMAWChN+KLdEBLHzWJzv+mM8g4yioE38LVy4OmALqzt8zgzTAby2oXzvB+5m3HJFwjOT8HsbzeLWoMefbmwVKJWErD+c14/tZlXTm5ibthesZEAJAVgWuTKxDYeNY4z79hKsncvAECutsJh4Mv1+Cn8M/C0UaOQi59vbNbd18KTqysuSD3NdEZH3CvphXec1ioIAvnHV2Kt0+BfJNYlPJ2ZQJFWc4s1Gwa9wcCWhMsA2JqY0cPVt07r1eW7qbB2wkTQMznxLJc6j+DNoN6YVvq+6AQDkXkZbEq4xI9Xj4BHFPieZ51uLe02zefF4xtYFXuehMLcetlXgKzt81BoxWNjv3lr43xLxe1FtfxXmdKhEe/1Fx80GAR4ZNkZzidVTwOXKZRYtxfrdAmaIgrDttWpf7VSxbrej+NiJn73Dqdd44kTK1n6aCtWT26Lo4VocpJRWMarmy7j88le5h2Ioage605aBg00piPeatz2pub0dvMDICo/g8u5afU2jjvlTn43ZUoV5k27ArDaqeIckJvozOG46v/fe01lsy5njRhLrUfB23387teQ/nOYOHkz5vVtfG5aIcjs8XVgifwzvBUVZkP7o7No880hNjVgen9NrI27wNPH1hnff9txBAfHTcBaLZ4zfjl+nXVhyQAUnC2vySyTY9lqyD0dp8StCXaz4sjz3aq9AhQZeBTHcO3jbtVemoR/rrETgIWJotbox6Iy/V2XwZGQkJCQaDgkQfBvTJo0ifHjxzNhwgS2b99eZVlwcDA6ne4fU3z958jjRlFOIZOztvdkXg/qjav5zdMZBUHg1F8LGb5tKFNz9jIuJYz3Yw9zpPsj5E/+jEsPv8YfPR7lpcDuBNg4V1k3Mi+Dry4eZP7liiLeJPlDrgujgtywMzeptr2iK4dIXjTF+N55zFwUlnee0vpPRamQ42UnRiJdqwdXUnkl911DaSGfDWlufP/+zijySupmllCZ0rizlKVFA9CpXAjWCQZjPcp7zbGMeDLKjUQGewYYU3jrA6VVxbFtWZrHZ+2GcHXUW8xt+xCPNWlDe8dGWFeqX3gDQSZwJiuR7yKOMP7gchqv+ZjGqz9m0qEVxOTfuQuxLj+D7N3fASAzMeOaU7Bx2Xf7EtHfxChDooIPBvozqa1Y9qFQo2fIopMk5pZUa2ddyUE9L/SPOvff2NKO3QOexL7ckXp3chTjDixjZJALl17vxePtPCnX/UkvLOO1zZfxnVt/wqDS2gm1j+hmW3rtNLr89Ju2v+E2DLAu/p97U2ri7Ee2yoztzs3EGToV5DsxZ3/cTU1k7gVJ5bVHlTI59lrx3G5hZsqgAOebrSZRz8iUJjw7eT7jrMXrizyVGfPdvdlS/AYrOxfh7ySWYcgt0TLi91O8sfkyWv3dGXzVhT3JUUw8uAJD+bXleyH9eSGwO9725vwwuuL7+cTqMK5HX0aTGA6AuX83lFY1Z1xIPHgYNEUItdQ5Nm0UjNozqMZl/wSaOFgQ7GZdoxD6b46KlJCQkPg3IAmCNbB48WIGDx7MsGHD+PDDDykuLkar1fL1118zYcKE+55SVRe2JlxmZqWnzT91Gc0gz1sbdJQmXuTa3J5YbHgWB0G8idGaWOP1+i6s2gxHKVcQaOvKo03a8E3HEUSMegOzUvEmVqE3VBNkWgltIVeM8JjeoVG17WmSI0j4dgSCTnTgtO//Anb9nr2znf4X4GMvigjphWV37VZbOULQUFpIu0a2PBIium0m55fy+Mpzt32jnH+iwtGwp09FhNrhtGs1NW9wNsRfNE6PaFy/Lp0KayfjtD5frA/YyNKWt4P7sqzHo5wc9iK5Ez8i5ZH3OPjQTGyzAyHLHZMyaxSyqqfWhKJclsecpfu2hXcsCmZt/wpBI4qfdn2eoXXTitSu0OgiZu+4ckf9/teQyWT8Mi6Ynk3Ezy85v5Qhi06SX1pVIDdv2hWVg1hPtuDCltvaRpC9G7sGPGkUjDcnXGbiwT+wt1CyeEJrrrzZu0Zh0GfuXt7aEsHaC8nEZBbd8cMnq+AKk5/C8JubDoz0aomsvGDZ+krfp38aJq5NWesWhFYuRvG66XxAkHM+pYjVF5Lv69iSi8U0YbXBxHjR5e9i84+4lvg38suwV/A2Ex+YnbRrzK+2jQne+hgHWpzhsTYVjtRfHoihzw/HSMqr/sCgvjiREc/IvYspKzcAeiagCx+EDDAuf7SNJ4+1FTMrckq0LFn6o3GZVZsRDTYuiYZBZmqOz6wjNb7cpvxwv4fXIPzQuDlvNWtPt63f023r9ww5ssw43W3r98wMXXfrTiQkJCQkGgxJEKwBExMT1qxZw6effsq8efNwcHDAwcGB7Oxsvvvuu/s9vFtyKuM64w4sq/K0ebp/x5uuIxgMpK+dRex7rSmNqojuO+EwkOZfXMEioHZnYHn5Pau6zEDmhDms7T2ZlwK781unR7kYIYpSPvbm9Par+iRbV5DJ9XmDMRTnAmDVZiQuj379n75J8q1UtyjuLqMEZSZmRsdRQ6lYU2ve8ECcLMUozY2X0vhgV2SdRQfBYCCvXBCUqUzp32GUcdn9EAQFQWDjdbHmokquYJBH/TpSK60qBEFtTmKNbWQyGa7m1vRwbYJjmTekNMUhtRO5Ez9i36Cn+bjNIB7yCMDGRBSGUkry6bvzJ1KLb68QvS4/new934vbNDHHccgb5OkqHR96FZ/ujWbtfRY+/imYKhX8NaUdAc6iKBCWks+QRSe5mlFhjSOTy7HpPlV8o9dBNUumm9PW0ZPt/WdgoRS/b2viwphxdA2CINDUybKKMHijVEBGYRmf749m7NIz+H26D9tZO+i1MJT3d0QSei27zlGglsEPGacLL9w8bdjFzIruLmJ1pwvZyXcVxXo/kTv5sqrcSEkBfNezv3HZO9uuoNHdn5Q1vcFASol4/i0rqbjk8rSzrG0ViQbG2kTNyj5TUZRfayzw6Uq4hSM5a99gbvZnLBrph6lS/F8duZZNyLxDrD6fXO/ZIVF5GQze/StF5Q9Ex/uEsKDTyGrXQP8bFWR8WNgoab9xvlVrSRCUePCJN7Mkzrx6TUWAsJwUwnNu7iQvISEhIdGw/OcEwYsXL/LOO+8wa9YsTp48WWs7uVzO66+/TkpKCrt27eLYsWNs3rwZCwuLWtd5ELiQnczAXb9QrBOjXab4tavytLkmBEEg7c/XyNz8SfmNL8QoGvGU/Vy6v7MOE7u61z60NlEz2juYbzqOICbO3HgDO7VDI+Tyqhe5Oft+RJsZB4DatwMeT/+BrB5TPv+J+NpXCIJXM++yjqAgIFOKTqZCmSgeediYsXpSW6MA8dHuq0z841ydohG1WfHosm8IYzIsI/bibWkHwJmsmgWzhiRTU0R0gSheqBVKYgrq10lUYV1hNpG+5m1S/3gJfVFure3NVOLptLhMj6XKlN5ufrzbqh/bBswgbsy7BJV/j+ILc/g9+tRtjaXg7Ebj/9C+37MorZ3JKBXFK3O5KQjitmfviLytfv/L2JmbsG1GR5zLBfIj17IJ/OIAM9eGkZwnmhvZdp9qrMcnu01BEKCLizeb+k411p5cEn26SjmFysLglPaNjN/LG+SX6jgYk8WHu6Po+v1R+v54jJI61GJS+7QzlgwoiT1xy/ajKqUN706OuknLB5d9qEgtj4p+SF/KmEAfhgWK3+Fr2cWsPn9/xPL4ohz0gph2KiurVLNXd3/qrkqIdHL24oMQ0XBHJ1fwZvMhFMuVFJxeS++9kzk+tSlNyh/QZRaV8ciyM3RdcJSItIJ6G8N3lw+TXZ5CaiJX8FZwH+Sy6pfl1moVf0xsTYg+inY68SGYqWdLTFxuz5BGQuJ+4V+YwbJzf1Z7+RdmUJYec7+HJyEhIfGf5j8lCP7111/06tWLhIQE9u7dS8eOHZk8eTIlJdXTQfLzxQgec3NzunfvTosW9ZuO2BBczEmh346fyCkT92egRzN+7jr2lhF3mZvnkr3zGwAMMiVfmz/OaNv59BzwMH6OdyaAphdomH8oFgC1Us70Do2rtSmNO2Oc9nx6BXJTyRihhWvFU9RzNZgd3A6l188jlJt9mLhVRM/18nPku5Etje9Xnkui47eHb3mjo7R1R+3TDgBBW0ryL1PILRfk7O/D/87exJwuzt4AFGg19Ny+kP0p0fXWv5lve0wbi66OGPRk7/qW6DebkrP/ZwRDdVHmhmFEXqmuWjSSQi4z3vgBdHCs/n24KZWEchNXsUbajfR8hQI6e4nCbGRGYb0aVPzb8XEwZ/dTnWlkK0Zw6gwCPx6Lx+/Tvby9NYIiczes2oy8q230cW/Kut6TjWm5b5zawvH0+Cpt/Bwt+H18CKnv92f7Ex2ZOziAMcFuRkHiBgdjsnhj8+VbblObnYChXDBWOXrfsn1jS1vjdKn+n3n8rEyNNU4/qhV/v98bUOFUv+zMvX9oAbAtIcI4XVZiT5bMBoCiiH3GUhkS94e3g/sYo2Pjze34upn48LT02mksfu7P8XH2jG1V8UD0WHwOrb8+xOf7otHVQ23BQZ4BKMsFwDKDno5bvuPL8P3oDdX7bmddwnf5c5GXP5iw6Tr5rrcvIXEv0MjVlMmr11sGEDTFGDR3b6InISEhIXHn/GcEweLiYqZPn86mTZtYtmwZx44dY82aNWzYsIF+/fpRVFTxg5SRkUFQUBDz5s27jyO+PWILsui382cyy39Ye7s2YX2fx29pslB05SAZ62aJb2QyFnm/w6/mo9HKVDzezvOOx/PpvqsUlYmiyHP/Z++so6M43zZ8zUrc3SG4huDuWrxIW1pa6var96u7u7tTalCkhUKB4u4anCTEiLttsjbfH7OZ3RBPNljmOmfPGXln3ndlZmfuuZ/nGRJJiGfVi4Hy81K+KpWLJ9qA+lWHvdrpHeYlTx9IaZogWHJiozzt2mV0pXX3D27Nyjv64e0sOQhPZBTT9+NtLDp0vsb9qbSOtH5mC96j7gMgT+tMviD9vtqpL76zU61SsXrsnYyyVEktMpQz4b/vePnQWj45vo1Pjm+rYw+1o3Jwps1Lewm4/l3ZbWUqyiZt/j0kfzQF0Vg551yQu/U3nl5Y2f3z0qH/5MICM1p1Z3RI+waNRettrc5tzJO+IzetIwDFBj1RwZKQLIpSFWmF+hMV4sGpp0byzqTOeFmOB53BzNsbY2nz5kaWh98HF1RjbyiTwrvwUrQUwmoUzVy3+Rfyqkku7+cmFZp4ZnR7Fs/rQ+yzo8l4eRwL5kTLidk/35HAqhO1VwMuPmotiGUbPlwTtpGQFcLllUR6aSF/p54FILC8iIEm6aFY7zBPOvhKhZo2nM1u1lxwNbEi2SrgikX+bHLoB4BZV0jJyU01baZwEVCrVPw89AbcNNK59I/AzuyKHAiAISeJ7PdH8GPvfDbcO5Bulod15UYzT686yaDPdnAivWluwcnhXdgz+SHZPV5uMvLk/lUM/fcLzhRkye3Meh3Jn16LrykXgGPuffAd/2iT+lZQsDdH89Iq5QaseCW6uJPi0lbOlejz4Cp5WnB04bTWpdrtlPyCCgoKCheHFiMInjhxguLiYgYMGCAvmzVrFhs3buT48ePcdNNN8nJ/f3+mTJnCsmXLMBgaXon1YpOhK2Lc2m/JsOQpGhIYyT9jbsdFU7Wiry2iKJK5+Fl5Xj31bT4pkhxg/SK8aO/fuBxHyXk6vtopOWDcHTU8NbJqWIu5vFQOE3AM696i8wbaEuLpRJC7dHNyIKWgSTmLSk5skKddu4yqsn5Sl0AOPjaM3mEWx4rexA2/HmTG/H38uCeJ5LyqN88qRxeC531J+CMrSPJtLS8POraa2Ge6kPj+NaT+dA9Z/7xJwc7fKDm9DXNRVpX92AsPByf+HXsns1pLFXf1ZhOvHF7HI3uX88je5U3ev6BxwG/iE7R95wyeQ+bJy4uPrib998o3ZMEejvJ0WpEkCJrMZh7ds5yPjm8FwFXjwMf9Gp73SWMrCOZLoY/ulptYEZH2gc7y+uN2DGlrKbg4aHhyVDvinx3FM6PbyeHf+ToDD24vY6nrZLltY0KHAZ7vMYYxFiE4uSSf146sr9d2Ae6O3NwnnM+utbp6b1t0mPTCshq3aaggaMbqSFJdgefi78/sxWgJy52VGoPact4UBIHruku5QM0i/H6w5gcezUGhvozN6dL/nKvoDnoXNjhar0GKDvx9UcejUJVId18+HWA9J7/QcRzFHYYDkmib9ME19ExbwYFHh/HC2PZyWP++5Hx6friVT3amNMkt2MsvjH1THua5qNFyMapdWYn0WP4Bi88dQRRFUn+8k7JzUpqJBFUIf/d4G6GJDykUFOxJd+9gompIL+Ri9sDV7FHtuo4GHR0N1efLVvILKigoKFwcWswVRXh4OEajkdWrVzNp0iR5eZ8+fVi8eDHjx49n8eLFzJ49G4DPP/8cnU6HVqu9VEOuF4X6Miau+17OnxbtE8LKMbfjqnWsY0sp2bwudicATq168ovLFEAKuZzbq/HuwOfXnKLcKF0gPza8DX5uVcdSnnpStqU4hXarsr4l0zvMk1UnM8koKietsLxad2VdiEY9pZbiMFq/1jj4R1bbrrWPC9sfGMwjy4/zzS5JxP0rJp2/YtIB6OjvytgO/ozp4M/Idr54OEnHg3vPKRQJTnBIqmAaWZKLPu0k+tSTVTtRqWH6y/hPe77B76M+OKo1LBw+l4ed/uaLUzubpQ+tVzChd83Ha+htJH1wDaJeR96GL3AM7YrPaMkxGWzjEEwrLKNQX8acLb/yb4q1+u97fScTbhOeWf/+rZUvDbJD0Cr4t/K1Th9vomulJePt4sCbEzvz4JBIXlt3hu92J2E0i3ygmcUYllhaiRQnHcMtomHnLbVKxYKhc+iw9B2KjeV8fnIH93UcSHtP/7o3Bm7tG87qU5ksPpJGVrGe2xYdZtUd/avkZjUbyuWHARqfMBxD6053UdkheGVhNJv45vQuADRmE7PSjoJfkLx+Vld/Xt+cBMCfR1J5YmS7iza2tedPY7CkF3ApC6AEOOLSE5XeDXNZMUWHlhN0yxcIqhbzbPay5NZ2fVmedJzlScdJKyvm9s4T+d0rGM3ehWAykvbDHfhmxPLKzNeZ3i2I2xYe4WhaIXqTmdc2J7EmrpCf50TTObD6wgl14ajW8Hrva5gW0ZV52xZysiCTMpORm7b+jvbwCjrs+h2AIsGFBzyeZ5JvgD3fvoJCk/lq0Mwa1w35bHuN614vkArSRd77bdXtVn3e9IEpKCgoKNRJi7kKDQwM5Nprr+WBBx4gJ6dy8YGxY8cyZ84c5s+fX2m5s7MzlzPlJiMzNv7MwRxJIIh082H12DvxdKh73KLZbA0VBvxnvMZvh6QncWqVwPXRITVtWiubYrNZsF/K1eTn6sCjw6oPBS4/f1yedgxTBEFbKocN5zdqH7r4fYiW8PELw4UvxEmr5utZUSyYEy0XWKjgdFYJn+9IYPpP+/B5YS1vrj8rr4s1WMNiO3r4onLxrL4Ds4msZS+Q898njXov9UGtUvH5wBkcnvYYy0bNk1/2xrXTcELunC/Pp//6oByabesQPJaTxeBVn8tioINKzS/D5nBfp0GN6lfl6o2gteS5swiC7lqrABnmowiC9iTYw4kvZ0Zx8qmR3Nw7jEK1B6KNVLb07Tv4aW9Sg51BwS4ePBMluXUNZhNP7V9V720FQeCbWVFyvsM1p7L4dHvV6t6lZ7bJx75b1MR6ua/NNorgleYQXJl8khRLOP7o7FgC9CWVFM4wT0fZBX34fGG9irLYixXJ1v85Xa4XAME+Xrh1l1ybxvw0dPE1FzdTuDgIgsB3g2fTzt0PgOMFmdwW1g/NpKflNjkr3+L8tzfTM8SDfY8M5cWxHdDYuAWHfbGTnJKm5YTs6x/BwamPcmeH/oB0jrg5O5Mzrn6ICPyf+xOc04QR2oiHhAoXhxsT3+fJU/dz7vUhVV5iNWkiFBQUFBQULjUtRhAEyfVXVlbGNddcQ15eXqV1Y8aMITs7+xKNrOGIosht2xexIU0SaPydXPlv/N0EuVRvy7+Qov1LKUs6DIBzu0Gc9B4oV7Ud39GfAPe6HYbVce+So/L0B1O74OlcvcOyIn8gKILghVTcvELj8wjWFS5cHTf3CSftpXHsf2Qob03sxKh2fjioracIk1nkudWn2BYvCeqnbXIcjXzkbzp9lU/Hr/Jp8/pRwh9dSdAtX+A98l65TcZvj1CwZ1Gj3k996eETwrWtusuv5sCz/3X4TXtRmjGbSP58FmUpxwn2sNykOZbwduKfHMuXXJb+Tq5smnAfc9v2bnSfgiDIYcOG3BREUcTNJiWAg9aMr4s1H6SCfWjn58qCG3ty/IkR2Hrn+pbs5cdffqTbe5tJyW9YXrpHuw4j3NULgL+SjrE1vf4VFr1dHPj1xl4VhY95auVJjqUVVmrT0HBhkMLOK7jSBMEvTu2Qp29IPQyAKFYWavuGewFS0ZgjqZU/r+bCaDbJDwS8HVwozpMKdLXydsa993S5XdGBvy7KeBRqx9/JjQ0T7iHCcmwezD3PrS4huM77Wi7qVLjrd/I2foWDRsUrEzqy9+GhdA2wViJ+c8PZmnZfb5w0Wr4eOJNrLcVOijWO3Bs1g70DnmK7g/QfEuZ1eT+sbsmE6eIJLa3+nC44uqBybFyhPgUFBQUFheaiRQmCwcHBrFmzhoSEBAYNGsThw4cBMJvNrFixgnHjxl3aATaAP+IP8Uf8IQDcNI6sHnsX7Tz86r19wZ6F8nTArNdZddIq7tzUK7S6TerFmSxLUZN2vtzcu+awY32GtRqso00FXAWIDrWKuicamQ9OF79HnnbpNKLe26lUAr3DvXh6dHs23DeQvNfHs/bu/pXaLD0qOUlTdVaxcoulwqfaxROn8O64R0/CZ/T9BN/6FW6TXpDbpc2/B6NFKLuS8Z/+Eu59pBAZc0keCW8MwS9jDyBC6BlKzVJ+t25eQeyd/DCDAls3uU8HS7VYU1EWOSvfxt0mLUCBvgxHjXTTml5U1qTckwpVqS4U8N2i9zGnHefJldWEydeCs0bL270nyvMvHfqvQdsPa+vLs6OlXIR6k5kf9yZXWq87awmbV6nrdAdXh/kK+u2IosjmNOnmO9LVi775lkrCFwiCtg9ZYtIujiCYUlIgVxaP8gqlQlAOcHPErcckWWQqPb31ooxHoW4i3LzZOOFegp2l/+BdWYnMKdXj8eAyKlT4nDXWYnM9wzxZfEMXueDPt7sTKbODA1WtUvFBxjF6WX7PGY7uPOfuASpp30bTlXOMtkTO2xTQsH05hUfhEFA1p7aCgoKCgsKlpEUJggA9evRg9+7d+Pj40Lt3bwYPHkzXrl0pKSnhueeeu9TDqxe55aWVCib8MeImevs1LOefqdgaNu3ScVilQgRDI30bNS7bS9Q3rulUe6iaYPPTq6MSckvDzdGa2tPQyAt/Y55UeEJwdEXr3bjwb5CKLfQO85ILnQBM7CzlL7q9fT952bztC9mRUTV8EcBl1EN4DbsdAHNpAem/P9Lo8VwuCCoVoXf/jHM7KQTYXJqP+scZ9HLaCi6S4BDlHcyOSQ/Q2t3HLn36jHtYns5c8iza5CPy/IpTqaRaikyMbu+vFOlpVqTP1lMs4buClzhyZH+DRYAb2kTLlUU3p8exOzOxQdvfP6i1PJ16QXERU6nkfle7+qB2rl9OM08HawhioaG8lpaXF4IgEGJxxRfYjttc+fuwdVRlFTctrLO+hLp64m1J33E0PwUshVuS8nWoXTxRWUQnc7ni6L2caOvhx4YJ9xBgqSy/KyuRmefPYew2HgBD1jn0GVYHWICbA3MtDz+Ly02sP2ufSBPj8f/47NhyIi3Hc5ohB8JOAiLf7m7Y+ULh4vFVRGee7ti32oq5R5UCGdVSnny02hDrsuSjcvFBBQUFBYXmo8UJggBt2rRhx44dbNy4kVmzZvH++++zZs0anJyujLwsT+xbSVaZ5MS7qU0vJod3afA+zDpJtFA5uSGo1LITzc1RTZhX0z6HSB8XBrTyrrWNyib/mWiouVpmS8Q2ZK+xTi9jgeTC03gG1dGydkRR5J4lR0m3VM29tnsQ4zpKguC9HQfyP0tOvHKTkdmbfiHH8ru0RRAEAm/4ALVnIACFexZRdGR1lXZXGipHV1o9tR733tcCYDIbKAi23gy+23cyHg72O6e495xC4E3WPIxmm/Dr3w9bbxBfHNvBbn0qVEVEwKXDUAD8xTx+yHqM7asX1rFVZVSCiqe7j5Tn347Z2KDtfV2tqRiyL8hbZrZUm1c51b/AgY+jizyde4XluerlK4kxuXodqU6SyHZhyLCvizW8/sLPq7nQqtRMjZAKuuTpdfgHSaHlpzIlAVCllcRCs75hIecKzU9nr0A2X3MfQRZBfW92MvOCoimwVHYvOVG5QvjM7tbqqhUO+qagz4jDkBWPl7GMn/XZ+FYcnx45EBTHrsQ8DiTnN7kfBfuT6OxGgkv1594o72D5QZCChFNYdxzDo6pdJ5aXYi6vek2poKCgoGBfWqQgWMHw4cN59NFHmTRpEqorpMrf5rRYfjwrJSH3cXThw35TGrUfkywIemAwmTlrCfXtHODeZHfRjb1C69yHoAiCNWL7yZkboQeKZhPGIikEvKmC4IL9KfINTqC7I9/Msl64CYLAx/2ncU2oFPKdpivkzh2LqxUx1a5eBNmIWekL7rsqLvRUDs6EPbAY7zEPsCKwK3GuUth+T60b40LsL8z5jnsIv2lSCLar0Xrc6Iql73tS5wD6RnjZvV+FyoQ/+g/64J4AeIglBC+9meyVbzdIwL8usgeRbpJ7dHnScY7n1T+U3lGjxt3iJK4iCJZZBMF6ugNBynFXwZUmCPb2tbrjT7hZqq9e4BD0c7UKgjmlF0cQBJhpk8fU0TsXgIyicvJ1Bvk/UPn/uzypEAUrwocPGwzc3uM60h3dKD62rlLbEe188bbkS15+LB1DA4sNXUjxMWsagS6dR/D36NtwqIik8DsPPqk8uuI4psZcICg0O61Li9g+6YFqX7VV422JBN/6VbXh1ZHPb0eweVCloKCgoNB8XBkqmAIAWWXF3Lbd6gp6v+9kAhpw02eL2ZL/TeXsQWx2CUbLhWWXQLcmj/PGnnXnIBRs8p+Zr6AQtYuBrZbamMt9U3GOfEPcFEEwPqeEB/6Kked/vL4H/m6Vi81oVGp+HnYDgZbf4d9Jx/j+zB6qw6PfdXKRA0N2Ill/v9LosV1OCCo1gTd9wmftxsrLnjz4S6VK2vbE/9pX8B55L24mq7Bxu/5P/q/kR14aXP88ogqNR+3iSZeXtvGfi+TyExDJXPwM57+ag7megppGpeaJ7iPk+XdjNjVoDBUil60gKJrNcgiq2ql+BabgSncIWv9vTrhLLmTxAkHQ1lHZ1EqwDWFsSAfcLK6yHE0qFWf005nFqCzhxKLiELxs6egZwJZr7iPURcpBeco9gOt6z2V78rFKvzGtWsXUrtJvL09nYEtcTrX7qy8lNoKga7dxDAmM5Ich11kbBJ9lW0Ycb6xvehETBQUFBQUFhZaNIgheIehNRmZu/JmEYimfzKjgdtzarm+j91cRMqx28axUuKK65PkNoUeIB12C6t6H4hCsmaaGDNsW7dBYwnQbiskscsvvhygul2567h/Umomdq9+Xv5MbPw+9QZ5/ZO9yThdkVmknCAJBt3yJYHEj5az5kLKkI1XaXYmcLcomUyOdTgflJhCVE0/yR1MwFmbVsWXDkT7Hzwkffoe8rFyt5jbd37h/3JOsv17BpGtcMRqF+uPg7MrxER/ynsttmCx/pYV7FpHw+mD02fXL8XVru75yrrLf4w+RWJxb7/5tBcGK84S5vAQs0w1xCHrZhLbnXWECVSVB0M1yjrogZNjdUYNGZSkKUWq4aGNz0miZHN4ZAJ1YBi7Sg7hTmcXyf6BZ+f+7rGnv6c+Wa+6jg4c/ADkOrtzS8Rq+3LW4UruZUfYJGxbNZkpOSikENF4hOIZKKWHmtu3Ni9GWh04CEHqGl9edYHt808RHBYXLmdNal2rzMd63c+mlHpqCgoLCVYMiCF4hPL7vH7ZZijaEu3rx+/CbGh3aazaUIxoll4TKyYMTGdak5k11CM6phzsQQNBYnWaKIFiZpoYMV+QPhMY5BE1mkcdXHGdHgiQ+d/R35b0pnWvdZnxoRx7pIuVVKzUauGnL7xjNVQstOPi3xv9aizPQbCLt5/saPL7LkbXnT8vT7fOlUGhDdgLJn16LWW//37egUhM6+BZ5Pk/jCkjholl/v0zsE20oPrrG7v0qVGZmjxDmu1zLfR4vUqaRBLiypMOce7kP+qzqi+zY4qzR8khX6bgximY+OFb/irMVgmC50Uy+ThK5KsKFAUzFuZhKC6rd9kI0KrVcWORKcwgGuXjIhUUOe4ZgFIQqDkFBEPC1fF4X0yEIMMMmbBgPKcfolricSiHDSlXwy5u2Hn7smfwQY1yk6yOjSs0DZ/bz4kHrOXZsB3/cHKWw3r+OpTc6nNdcmi8/sHWK7FPpOu/l6HHWVBQOZYh+Sdz420HOZCmFaRSuPjoadHQ0VP0/OpqXRoxSoEVBQUHBbiiC4BVAsaGcb07vBsBV48A/Y26XQzQbg60AJ2gdSci1/uG293Nt+P5spm+Irl9FW0Fjzekkmi7uDdrlju3n2RjN11RkdaVpPAIatG1aYRljvt7FJ9skMUOjEvj1pl64OGjq2BLe6j1RTph9ICeF+bH7q23nO/4RHII7AqCL3XVVuNl22lSJXSdch8Y3AgDd2R2kfn8borlpOaWqw0mwurqWhPQkb+zD8nFlKsom6eMp6OL32b1fBSuj2vnh7axlh0MvbvT5AHWQlE/TVJRNzpoP67WP+zoOwsMiDv14di+F9RSQW3lbK+fO+fUgZUYzgk3Fdl3cbs7+XyRZ/7yJuaxuwaDCqXi2MJuCK8wl2M9POt6KNY682HEchRlxVVJRVAioWRdZELwmrBNOasv50zMLEPlpXzJn8y2ipWgG08VzLSo0Di9HZ/4Zczt3JO2Vl71+ZANHLQ/gnLRqJlgKbmUUlROb3bgcuWZjzdWyBUHgq0EzrfkEPbJJzi+j78fbWH6s/jlIFRSuBF4vOMfi7BNV8jBGKYVZFBQUFOyKIgheAWzLiMdguTC8q0N/evjUT3SrCZWTO1guKE3FOZQbrWKFm2Pdwo8tFybPbuVTzyTAthe6qob1ebVTVG6Up93qIcRdSEXBGJAcoPVlX1I+PT/cymZL/iOtWuDb2VH0Cfeq1/ZOGi0/2uQ5eunQWkqNVW++BbUGQS3l9BIcXFA5NlyEvtyILbRUFzYLpJb4kjP7V7nKa+GehWQufd7ufXb28cW5RLowNqlM3OkSQsAbx3DvY0labjJy/tub653TTqHhOGhU3NFfEqNOm4NYPHiBHBJftH9ZvYRgL0dnbmsvpX8oMer5Ne5Avfp+ZFgbuZDB2tNZPLQyFo1nIH7TXwLL8WUuySNryXOcfbIdeZu+RTQZa9zfFEu1ep3JwML4w/Uaw+XCs1GjcLSIbsuDujGrwzh2bltQqU2AmyQI5usM6I32F+hrwk3ryGTLZ4tWL4cNny2wjkGpNHxl4OQbwdNl2TwetwUAEZFnYtbJDs8uNilXkvMb951qPALReEuRFsXH/sNYWDn9Rht3X1m8d9BK/RaWGZn+0z6e/fekUmhE4bLkaFoRQz7bzpDPtjNpQYw8PeSz7dy35GiN25UnH+Xc60MqvcqSj6LPjLuIo1dQUFC4ulEEwSuA9anWxNFjQto3eX+CSoXaXSo+YCrKqiQIOqgb9pM4kmoVnxpiZrO9MRXUiiBoi60g6N5AgRaoVL1X5VS/EPDkPB1TftxLRpHkTmjt48z2BwZzW7+IBvXdxy+c6yOjAUgtLeTj49uqtBHNJvTpZwBwDO6IcIVU+K6NuCJLHieDEyDwd44vYQ8uBctvO2flW+Rt+taufQqCwJzAkaCTvuNTBZncdmwbIff/gXO7QQDo006T8edTdu1XoTKPDmsjnzc/3JuDUzepcI4xPxVd7K567eO+TgPl6S9P7axXCGnHADf+u2cAHk7Sb2zZiWxOZhQRcO3LtH8vFu+R98i/P1NBBmnz7yHu+SiKDq+sdv93dOgnT39/tvrCQJcrff0jWDh8Lq6Wh0uxrn6MTjjJx8e3Yra81wCbgkgXVmZubm6wnBMBhvUy4eqgpgyrS/7j9ccwNrEyrcLFwa3bOG5JOUB7S2X3Pbkp/BF/CIAwL6trOyW/cakiBJUKr2GW/LAmA/nb5ldp42A5rv3ctczrY62y/daGWK75bjeJucpDIIXLh+7BHkQFVx/VdDStiJi0wmrXOYV1xzE8qspysby00nWugoKCgkLTsNudeHm5Nczh8OHDnD59upbWCg2hQhDUCCqGBbWxyz417lJoi7EwE73NjYiDpmE/iZ0J9U+CXwmzjSCoOAQrUVRmIwg6qWtpWT0VVUahfoJgSbmRaT9ZxcBR7fw4+Ogw+kV4N7hvgDd6TUBrcaC+E7OJnAscaoasBDmHpUNwp0b1cTmRW15KvsXhI+ilMM6VJzJw6zaW4Hlfy+3SFtxP0eFVdu17RtdQSOoKRskR9k/yCV4+soHQe36Rv/u89Z9THLPWrv0qWAnxdOLWvtJNeZ7OwE73YfK6zKXP1csl2NEzgNHB0sOe4/kZbEirX/XQPuFevD3Jmt/zq51S6LrWN4LgW7+m3Ttn8Bx4k7xen3qS5I+mkPj2KHTnKjsRu3gFMSigNQD7s1M4nHO+XmO4XJjeqhuHpj9OVLmUgkAvqHh07wqu372ItNLCSoJgZvHFrWw/Mawz7lqp/+O6ePY9OgQPd+u5+eONJxj+5U7iGhlmqnDxcO02Do0o8kystSr4E/tXUmwoJ8zTRhAsaLzr03v4HSBI12L5W76rcg7RWh6iGc1mfrohmq9mdkerlh7JrjuTTad3NvHy2tOU6mt2BCsoXCy+mhXF9geHyK9Vt3SXp6OC3Su5B21fs4tu4t1OXxL5/PZKL8GxnpFICgoKCgr1osmCYGlpKYMGDcLZ2ZkPP/yQO+64g7Fjx9K/f3/mzJljjzG2aDJ0RRy1JM8dENAKd5vqvE1BbamYZ9YVYrLJKeigbljSuh3n8hrVf6XQNVXDRa+rmaY6BEVbh6BD7eG4oihy26LDHDovPaHtFODGslv74O3iUOt2tdHWw497O0qOp0JDGR+e3VlpfXnaSXna8SoQBOMqwoWBEGdJRD2RUUx8Tgnew+/Ab8pz0kqziZTPZ9pVnBvV3g9nXCCpC4jSsfv6kfWsKC0i8MaP5Xap39+GsVipRtlcPDmyHZYitjyX1BZtkJQjs/TUFvK3/lCvfTzUZYg8/caRDfXue26vMPk88fP+ZIptzh8O/pGE3vsrkS/vx6XzSHl56anNnHu5Dylf34QhL1VefqeNS/CHs9ZcaVcK7T392RA1nLsTdyNYnIGbss7R/e/3yVFb32fFw4+LhbNGy7UR3QDIKS8lUZ/KxKjW8npHUc/OhDx6fLCF+XuTL+rYFBqGa6fhoNbSPz+Za4qka7PU0kLePLqBMC9rXs+UgsYXk9L6RuAWJTmN9RmxlJzcVHm9IF0zGcwmBEHg3kGt2fq/wYRbHIplRjOv/HeGTu9sYtGh80rRGjuTNv++KmGsFS8Hs1IkryE01j2ooKCgoGA/miwILlmyBLVaTUZGBitXruTEiROkpKSQnJzM/v372batasigQv3ZmBYrT48Jbnq4cAUVDkEAR51V1KtvyPAtt9zC7NmzMSx/q9Ly2bNnc8stt9SwlRVRcQjWSJNDhm0KCAh15Od7bd1ZFh+Rbmq8nbWsuL0vnpa8ZE3hhegxsiPmx3MHOFdkFaPKU0/J044htVcvvhKItXlvfQOtVZ1XnsgAwH/ma3gOmQeAaCgn+ZNpFMf8Z5e+nbVqxnbwh1IvSGsnL5+3bSFJ3Sbg1nMqAMb8NNLn36fcGDaQivPc7NmzKy2/8DzX1s+V63pIuV0Ti8wc7P+avC5j0ROVRLeamBzeWU6Wvjk9ju0ZdVcpBnB30nCLJWywsMzI7werOvucI3vT6qkNhD+6EseQLvLywl2/E/9CD4qOrJbeV+se8nH7a9xBdMYrr9iFb79ZPJ4bx/zDiwguk24mc8pL+T3nP+i4CyIP8/rJf3jt8Dp+izvI7szEi1JZ+YY20fL0H/GHUNu4XDp5SwJPid7EbYsO88yqk5gv41xw9T0urkZUjq64tB8MwGPH/sHZ8kDzg2NbcHC0Hi8pjcwhWIH3iLvl6fzNldNNVDjwjaLVOTiglTcnnhzJs6Pb4WiJ9EjOL+OGXw8y4sudHD5fv4rjCnVTlhJDeXL1ee/0KifKVfZ5cN8SuNA9aPuqSShUUFBQULAvTRYEExISGD16NP7+/vTq1YsJEybg6OiIu7s7EyZM4OjRmpPFKtSNbf7A0XbIH1iBxuIQBNCUSYKGSgBNPQVBnU6H2WxGQKyUO9BsNqPT1eNCWMkhWCMXK4fg0qOpvLRWCu1XqwT+vKU37f3rl3OwLvyd3Hiym+RIMohmnjmwWl5XlmCtPnw1hAzHFVoFwQltWsnTi4+kIYoigiAQcscPeA6aC1hFwbLkGLv0P7WrRYTMDaaPq/R5lhoNTN84H/ebP0ftLh3rhfsWU1BNPiqFmqk4z5kvCNmr7jz39GirIPvcKR88R94jtS0tIH3B/XWKsSpBxbNRo+X51w6vq/c47xvUWp7+cmdCtW0EQcA9ehJtXj9C8G3fovGUfjemomySP5xI3ubvcdM6MieyJwD5eh3XbpzPoSssdFjQOOA96j76FJxn2f4FTFHZ/ENp9eBawPb8k7x4aC1zt/7OwFWfEfjHy/zUzI7IMSEd8LWIgH8lHUOvsYoGC2Z35MEhkfL82xtjeebfk1X2cbnQkOPiasSt2zgAQsqLuMNR+h71ZhOLkg7g6iCJdU1xCAK49ZgoFxcpPPAXhQf+ltdVhAwbLqhC7Oao4Y2JnTnx5Aimd7M+nNoan0vvj7byxfb6PWRQqBvH8KgqoayRz28nxaUtWU6hl3p4CgoKCgoK9abJgmC/fv1k0a9v37707t1bXpeRkUFISNMq4rZ0YizhwlqVmv7+DSvwUBsqFy95OjVTqmLn04Qw0YZiKs2XpyuqcipI2BZ5cWxgTkcAfcYZeVrtWn0ewIMp+dz8+yF5/qOpXRnTwb/ato2h3GTkXLE1v+TuLCm3We66zyncswiQxEqHQPuJ3JcKvY3bdVHyHjoHSr/n7edy+XBLPACCSk3IXfPlfG6ioYz8Ld/Zpf9JnSvcvgKajA4MtuSBSyjO472EGEJu/15um/bzvZSe2WGXfhUq0yPEk4mW7yIup5QzvZ9E4yX9/xUdXF7F5VMds1pH0cHysOa/1DOsO3+mji0kuga5MyBcqih+JLWwVneSoNbgPeIu2r51Eo++VodXxh+PYshN4a6O/eVla8+fpteKjxix+kv+TjyGqR75EC8HvEfeA4KAh7Gc9xO288fwm+juHg4GR6hGlzWKZt46urFZHbRalZoZrboDUGQo56jW+r+n0eXz6bXd+OG6HqgtAubnOxKUHHCXKRXhvACzd/2IxpLv77vTewj3lhy2sdklTXJ5SsepxSVoMpDy6bWkfHE9xsJMnDWSi7/MZMR4gSgI0MbXlb9u68u6ewbQNUhyWZlFeOCvY0R/sIX3NsWSnHf1C7cKCgoKCgoKdSOIdrgCvvvuu3nyySdp187qkIiJieH+++9n48aNaLVND0G8GkhJSSE8PJwJEybg4lI/EUznpMYsCAiiiEtZ1Qu/xiIgUnFnJFp8fg3LHmjP/q/8KrP2puKgbMx3ImCWp8Qa9mB70Nv7ezcLUO6gxmzjzHEwmNAazZbvvWIMQjP0XpmlS5fWq11jjs0KRKTjVBSk96I1mtEarMLJhe/Q+v3Y77df6SQuWMaDgICIU5kJtShWaqUcc81H5WNXvOA3X/fnblQLlFtcRiqziHN5/c/7jTlv2J6LK84ZBo2AQaOSf9MVqEQRjdGMxljTmaX+NPexWd1xVvEuRQFEQcCsAqNaJZ+rnMuMqJoxUtf2u3XUm9CaTJZxVT4XNuX8r3BxsD1uyhw0GC3RFY7lJtQWIdAe31/l45Mq/bmUGRHq8ZutqUl1Y2zosZmcnExYWFiN7XJycvD19a3XPi8H6hrvudelfK+Rz2+vss7j+zcBKLzz2eYZXDU09vOdOXOmPF3f79we1He8Qz6TPt/tDw6ptLzP15JQvv/euh+y2YMr7feroKCg0FDsEqv57bdVT8pdu3Zl69atCIJySdsUnO0oAtpy4Q3Ixf6WLoYYdCXTlE+mPqJDc37yKpEaRIyaBcorGQEaJNY3hxhX6VMVwUVXeTzK8XbxEC6Ya+hvXmMS0ega5wxrzDdc3W9DaxTRGpvnv+diUd1xVvEuBREQRdRmLur7vPC7relcoByplz+2x42j3owjzeOere74bEx/ym9KQUFBQUFBoTqaLXmbSqU4UOxBibMaEFCbRZwa4BSpiwsdghf7crE+LraWTGMdIvX5XpvDHSgCeq0Ko02Is8os4qg3oRIru6Su1u/c1v0jIOJYZqrkNrL1/wjNcOzZ/mYudC06WVwr1bnBFOzPhcdvQz93swp0lvyhgijiXGaq1zfV+GO7diejSSVg1AgY1ZV/r1qjGQfD5RlGfKELvabPRhSg1En6rBvqyGwoIlBq85/uXF5RhKLyb6I5HdwK9sR63JQ6aTEL0tnXucyEINr/u6v4TRs0asq10n+Nk40jsSFcviVrFBQUFBQUFC4mjRYEMzIyuPnmm9m1axdBQUFER0fTp08f+vTpQ+/evfHy8rLjMK8uvvvuu3qFV5Qa9bj+IoUdjA/tyNJxd9ml//MFOr55/hZuKFwCwPZJS7j7upl1bFWZ2bNnV0koXoFKpWLx4sU1blt8fANJ744BwHfS0wRe91aNbZuTyzUMYHt8DkO/2AnAM6Pb8eZEayXe2sYsiiJnH4vAmJuCysmNjl/kIGiseSH/jknj2vlSQQ83RzV7HhpKl6CmV3E7XZDJjI0/cyI/Q152T8cBfNRvGiQfJeGtEYjlUuVjr2G3E3z795etc/jdd9+le/fujd7+0T3L+fiEVFk9wtUb7bnexGVKN/33DGzF17OiMOQkcfYxqfiIS4ehtH5ua5PHXao34v38WvQmMx39XTn19CgWxO5n3raFAPT2DWPvlIcw5aZw7rVBGPOkQhFu0VMIf2jZVV3YpynHeWPOc3sS8xjwqRTq1Dfciz0PD0GfEcu5l3rJFcDDHvoLj97Ta+37pi2/8Xu8lOfzhR5jeLXXhFrb5+TkMPKnGGLSinBQqyh8cwKOGnVdbxGQzh3JH02h+MgqAHwnPUXgdW9XaRdXmM2rh9exIO6AvGxoYCSLRtxMsItHvfpqLHX9b15I1vLXyVr2AgBhj6wkaBHoDGa6B7tz9P9GVGo7YOWn7MlKAiD5uucJc/Wy17Cr0H7J28QWZePp4MSeffMx5Z1H4x1Kh49T5Da3LzzMT/uSAVhzV3/Gd5JyU14u/1lN+f+Hy+d92IPEhc9Ssvotfgrvw/tthwPgluFLcVY3JnTyZ/VdA+zaX+G+pXz895u81E4q2vVu5nEeuet7tD4NL2RxMqOIPw6d56+YdHJK9ZjNZuVhvoKCgoKCQguj0f/8b7zxBoWFhXzzzTeUlJRw/vx5XnjhBcaMGYOPjw8nT16+FfKuFPL11qTPXg7OdtmnwWTmhl8OUqY3yMvm9ml4sRJnZ2fLhWNl75dKpcLZufax6tNPy9OOwR0b3PfVjouD9SZeZ6i/W0WfdgpjrnRT6dJpZCUx8HyBjjv+PCLPfzmju13EQLNoZvqG+bIY6KF1YtGIuXw1cCblO38l4a3hshjo3mcGwbd+c9mKgfbg3b6TGRbYBoCkkjyCupzDxUE6zX6zK5G3NpxF4xOOY3gUAKWxOzHZFF9pLC4OGoZE+gBwOquE5Dwdc9v2oo+fJKAcyEnhl9gDaH0jiPi/NQjOngAUH/6HtPn3NGsxhSuZivPchTfJtZ3n+kV40T/CC4B9yflsP5eLY1B7gm75Um6T+sPtGPPTa+37rd4TcbIIte8f20JKSX6d4x3YSioipDeZOZhSUGf7CgRBIOjmzxEs/zM5az6gLOVYlXZtPfz4edgcfhxynTy2bRnn6LXiI7amx9W7v4uBQ0AbeTo94SQ6i5Oxa2DV8970iG7y9Iqk4806ru7eUvXXAn0Z2cFdADDmncdcXiq3mRkVLE8vi0lr1vE0hsYcF1crrmMeI/i277g2OxatpcCUo1cSI8p3ceh8od378+g7k87Tnpfn04tyOPfaAMqSjjZ4X50D3Xl1QidinhhB6kvjOP5QX1JfGmfP4SooKCgoKChc5jRaENy/fz+vvPIKN954Iz4+Pnz77bfExsbSs2dPXnzxRYKCguw5zhZJgb5MnvbUOtlln+9vjmP7udxKAVSNcQctWLCAxYsXM+ShdyotX7x4MQsWLKh1W32aVRB0UATBKrhorYJgqb7+gmDxsf/kabfu4yute2DZMXJLJRH4xp6hzO1df6dNbaxJOc2pAqlKdaSbDwenPsJ1kdHkrHyb1B9uRywvAcC1y2hC7/39qnaigVRJdNGIuYRY3FI7suPo2T8VBOl7fPbfU7y9MRb36MnSBmZTpe+tKYzt4CdPbzibjUpQ8XG/afKypw/8S255KU5h3fC683cEyzklf+uPZP/zpl3GcLVRcZ670PFU23lOEAQeH9FWnq+oNO01+GY8B80FwFySR85/H9fad4SbN491lRxHOpOB14+sr3O8A1v5yNO7EvPqbG+Lg39r/Ke/JM2YjGQsfKLGtre178fOSQ8S6Sb1l64rYvSabziQnVLjNhcbrb9VEMxOtv7ndK3mQci1rWwEweQTzTquKB+r2LfSv4M8rc84K0+Pbu+HuyVk/O9jtQvHl4LGHBdXK4Ig4D3iTno9t5UJxdKDsRxHV6Y5LqF1zl7SCsvq2EPDaRXZW57OdnDBmJtCwptDKU89Zfe+FBQUFBQUFK5uGi0IFhYWEhISAoCjoyM6nY6IiAgWLVrEqlWr8Pb2ttsgWypuGkd5em92kl1cPEuPSm6DIHO2vEzt1PhQryD3hguV+qx4edohsH2j+75aKbVxBWoaEL5jzLc6SRzDrGGvZQYTq05KNyqhnk58ObO7XVx6pUY9D+75W57/dMB02nr4UZYcQ+ZfL8rLnQffQfij/6DSOlazl6uPIBcPloy8Ba1KEnZ35J0mMPo4OEgOoP9OZ6HxtoZ3mUrz7dJvG19XeTq7RA/A4MBIro+MBiTR5q4dixFFEYfI/oT970+wjDHrr5cojdtjl3EowLXdggjzlM6N689mYbLk+Aq86WPZuVt8eGWd+3k6aiSOFhF9b1Zyne3b+lmr8GYW6Rs8bt/xj6Hxkv7XdfG1/x56+oZyYOojTAqTUhoYRTMfn2h6+Lu9cPCPlKfFPOtnF+Re9Txk68Av1NtfwLFlRJBVLH5bcOLV9qPRCyqKDv0jL3fSqglwk34n+Tqj4uC9AnAK786j1z4nz68M7Mzk8s2UG+2fYzPM1VOeTvOThG+zrpDkz2Zg0hXZvT8FBQUFBQWFq5cmJQupEBVCQkJISZGcAe3btycrK4uMjIzaNlWoB+FuXnL44eHcVHZlJjZpfzqDiSOphSCK9DGfAUDt6oPWJrTqYmDIlt6H4OiK2u3qyCNkT2KzraFjtjf4dVFxIw9gLLC6Sg6mFGAwSTeUU7oE4umstcMo4aVDa4kvygFgbEgHJoV1RjQZSf3hdjBJoVP+M17FY+Y7qOwU8n6lMDCgNX+PulUWGjIMedDuIISc5owhnoSTm+W2Lu0H26XP4+nWG8EuQW7y9Cf9pxHoLLmiliXG8N0ZSehx7zmFgJmvS43MJs5/fZNyM2knNGoVw9pI57bichMnM6TPVePmi3NbKadY+fnjGAsza92Pu9YJF7V0vBrFuoWFnBKrCOjn6lBLy+oRNFpUztIDIkFVt5vX29GFv0bfSoCT9HtbmhDT7IJafVG7+8viq0up9WFJhVPalmWJMfL0hLDmda2PCG7H8z3GyPOLQqO5q8cs4nf+hmjJyxebXUJcjvQ/MKyNz1WdZuFqYnh4F8JcJLFuq28kYZosWnnb/78v2NlD/m+J92+HU2vJMahPPUnaD3coArKCgoKCgoJCvWm0IGibJ2bIkCHMnz8fURTJysoiKyuL8vJyuwywpXN/p0Hy9JendjZpX4dSCjCaRYLM2fgYJYegc7sBTbrZEBtRq86QKyVv1/pGKDc61RCbXSJPt/dzraVlZbQ+1jBgY541dM82dHBAK/s4d/dnJ/PhcckN5KLR8s2gmQiCQM7ajyg7JxUucYqIxm/S03bp70pkYnhnDkx9hJ4Vyd5VJvBJJ9XjML1dI5je5xbe6TKR/0SVXUSUo2nWfFVRwVbXb6CzO/OHXC/PP7JnOWeKpOPfd+ITuHSSwlINmXFk/P5Ik8ehING/lZc8vScpX5526TRCni49XbejrsIlbDTXnT4gy0YQDHBvuCAIgCUPmqCu34MDrUrN3La9ACm0eXHCkTq2uDgIKhUab+mcqC2yCoLZJVWdk4vOHZanr2sd3dxD47VeE1g4fC7Ols94v1c4M1oPYc8hyTW6+qRVKJ7UJbDZx6NgH1SCimG+kmPWoNIQ7+XYLNc4giDQzZKLMr44D+/7FqJ2lcL3C/ctpmDHL3bvU0FBQUFBQeHqpNGC4J49e+jcWbrwueOOO9i9ezetWrWic+fOtGvXjvDwcLsNsiVzbatuBFncPYsTjpDZBAfPniRJGIoyWvMpVbhVGktDH0SbSgswl0rJ7rW+rZrU99XKWRtBsF1DBEFvqyBoyK1eEBzYuumCoMFs4o7tf2K2fPmv97qGSHdfytPPkLXMEiqsUhN8548IGvu4Ea9U2rj7snPSAzzUeQgqsXLF17Nu/iwI6My0DT8Ruug1/rJxKTWGCkHQy1lLqGflUP4JYZ14tOswQBJt7jm4ArNoRlCpCb17ASqLqyV/648U7lvapHEoSPSPsB5rFedeAFeLAAtQYuMUrQmNIP1u6uMQzCq2il3+jXAIAogmyUHXkHyf89r1kafnx+5vVL/NgdZXKpilKslCK0rv60JBMLW0gK3p5wCI8g6mk1fARRnb9W2i2THpAcK00veU6uTJqCNbWJYQw7+nrBEWEztfnPEo2Af3MmuOyA2+ERiLsmtp3XgqitOIiMSqHQi97w95XdbyVxEtLn0FBQUFBQUFhdpotCCoUqlQq6UbFT8/P/bu3cvcuXO59957+e+//xTnl51wUGu4u6Mk2unNJr4/s7fR+9prcan0MNgIgu0GNml8DfUHVoQLg/VmTaEyFQ5BQYA2vg0IGbZ1CNoIgrstgqCPi7ZBjsOaeC9mM0fzJMdNP79wHuo8BNFsJvWHOxANktPNb9JTOLfq2eS+rgacNFo+GTCdmZqZEN+DXueL6ZWfgsbG8VVsLOfGLb+xNyupUX0UlRmJt4QYRgW7V3v+fav3RKJ9pLDymIIMNqTGAtJxGHzrN3K79F8eQDRWDatUaBjRoR44qKW/2D2J+fJy57YD5FDW0lOb69yP1SFYtyCYWWx15ge4NS5npywk1NMhCBDlE0IvX8kJuz3jHDG5l0dlXK2P9cFkRd7cCwXBJQlHZad7Rb7Ni0VP31D2T/s/ehdJAqBOELh+8y9sSE4AoK2vi13O2QoXj5hzZnx00m9st3cEyYnN45jt7m0VHo/lp+PWfRxulmJVhsw4Cnb91iz9KkBcdgkxaYUM+Wx7lVdDCsEpKCgoKChcDjQph6AtrVq14s033+T1118nMFAJcbEnd3cYgFqQvqqvT+/CVI8bw+qoCFvrZckfiCDgHNm3SWNraK6ainBhAK2f4hCsjgpBMMLLGUeNuo7WVjSegXKRCIMlZDg5T8f5AkmkG9DKu8lC/an8TF45LFXF1Qgqvh98HWqViryNX6E7sx0Ah+BO+E19oUn9XI2EerpAqRcPJOzkl8OL2LnjC1YMmMaMVlIBmDKTkakbfiKpuGHVYQGOZ1idw7bhwrY4qjW81muCPP/jWevDBc/+1+PeZwYg5Z8sjlnT4DEoVMZRo6ZnqPRdHEsvpLhcEtpUji44t+kP1C+PoMZy7m+wQ9Dt4jkEAW5rZ/0vuW7zL5dFLkGtr1UQDBGlfKcXCoJ/nrMKNtdF9rg4A7Mh0N2HZT5+zEiTHMJG0Ywh+CQIZiZ2DlQerl5BFJYZ2JNUQFCu9J2ZBRWL4w82S1/dvILk6Zg8KWewXCUcyFr+muISbCZKDSZKahD+XBzUuDrU/7pNQUFBQUHhUmM3QfBq5HJJzBzq6sn0iK4AJJfksyL5eIP3kV1czrncUtSiic6GOAAcQ7qgdvGsY0v7os+0qTCshAxXoUBnIL1Icvk01BkiqNRovCTXQEXI8N5km3BhO+QPfHzfCvQWZ9szUaPo7hOMubyUzMXPWAYhEHLnj6gcGl59+monyN0JrWigp+EkAB6u3kzuMJBFI+YyLqQDABm6IuZs+a3B554Ym/yBkbW4SieEdiTYUjRiWWIMeeXWAjbeo+6Xpwt2/tqg/hWqp7/lmDOL8K9NXjiXziPk6ZITG2vdR2Mdgt7OjcwhaGpYDsEK7uzQn96+kkv5VEEmb8fU/r4uBhobh2CU6jwgiedb4yRxMKEolx2ZCQD08g2lnYffRR8jQMDw23npzDq6FVqclU4l4J2mhAtfYWw/l4vJLCIU+MvLFuc1T4G9ihyCAMcsgqBzZB/cekwEJJdg0aEVzdK3Arg6qNn+4JAqr6hgD9r6Kq5eBQUFBYUrB0UQrIZdu3bRv39/Bg0aJFdPvtQ80NlaifTdmM0NFgzKTdLNpICICknQaegNX3VU3KzWB1EUK4WxOIZ1b3L/Vxt/xVirA/cIqd7pVRMmXREmi9tI5eRWZb3e1DhnaQVlRgPrU88C0MrNm+cslTL1WfGYyySHmke/63FpYhj61Uq4lySSlgpSQSZTYSbnv70FNbBoxM109JRuIndmJrAu9UyD9u3pZD2W398cR0ZR9UWdNCq1nO9NbzbxV+IxeZ1r55Hy76Y87VSD+leonnEdrMLAvUuOcs4S1u3WbZy8PG/LdzVuL4oi6Za8sR4OdYcAB3tYhfilRxsZtlvhSGugE91Jo+XnoTfI88ebSQhpCM6W6qsAtxb/iYu5lMIyIyO/2skLq0/JuQMBZre++O7ACpzCu+PWug9PxG2Rl2lddAxv63vJxqTQcPIsFaydy9V0LZT+y/eb4Vie/UPovR1d0FoiAgoNVjeu17A75Gl9Rqzd+1WAryI683THvgxZ9XmV19Fm+K4VFBQUFBSaE0UQvID4+HimTJnC888/z65duwgLC6t7o4vA8KC29PGTxrI7K5FtGfF1bFGZYHcnXB3UGAUNCY5tAShLicGs1zVpXA0JjSg9vY2yeClM0alNP5wioprU99XIz/uT5embejXst1dyfB2iUQqHc4u6BoDhbXzl+/t1Z5qW3HxfdrLsDpwQ2hFHS0ihaPMb0niHNKmPq5kuge4YBC2PuT+JUSWJO4W7/yD1u9vw1DrwXp/JcttXDq9rkOg/KypYdhOlFZZz028HMZmr3/6GNtHytG11VUGlQu0uCVimktx6961QMxM7BzCnp5RbL09nYNaC/ZQZTDi3H4xjWDcASk9spCzlWLXbJxbnUWSQxF3bEMGaeGhopDz9+vozGBvxEEDQSqKi2dDwkF/bsOZQ14Y90GgOnNv0xbG7dFx56bP4t/T/eLXoU2bq1rBkzVqe3WANm6/4f71UeA6Yg5PZGuLZ3tcdZ60SenglUZG3s70xkdlpR+Xl35zebfe+yk1GDJb/Yw+t9UGAoLL+Zuzx0FehKonObiS4uFe7Lso7uFJ+RwUFBQUFhcsdRRC8gM8++4xrr72WKVOmyMvy8/OJiYlBr9fXsmVVCgsLSUlJkV9paY1/cigIAk93HyXPP7l/FWUNSPyvUgl0DJDcPwcFSRDEbKIs6XCjxwQNEwRz/n1Xnvab+EST+r0aScgtZbMllK17sDvRoQ27obYND3KPln6/fm6O9AyVwsL3JuWRV9qw37At2zKsbpqhgW3kaVtRWaV1bvT+Lyb2PDbrS6cAN1QC7HHowadt30LQSjePBTt/Ie3Hu5gU2kku+rEzM4FNafV3d6hUAgvm9JRdiBvOZvPqf9W7DKO8g2nn5iO1S4slq6xYXqd2lZabihVB0B4IgsC3s6PoEmg596YU8OBfxxAEAZ8xD8rt8tZ/Xu32MTZukyifum8y+4R7MckiDMfllPLbwfMNHrPKQTqGxUYIgikl+fJ0mItXg7cH+x+b7tPfQHCUQvj8y1KYWb6el4u/ZGn+I0QUW8Oau6gvrfjm1n08esE6hh7BXpduMAqNIsBdCtNvZ0pkYuYpXI2SmP9b3MFG536uCVtXoIfW6h6uyAEKiiDYnLQuLWL7pAeqfX01aOalHp6CgoKCgkK9aVjW8BbAmTNn6N1bCjMSRZHXXnuNN954A71eT3BwMH/++SdDhgyp174+/PBDXnnllSrL8/LycHauWTgpLCysdvlQt2Dau/lytjiHPVlJzNmwgG97T0NVz6TjkZ5aDqbAYXV7ZrMagJyYTei8O9Rr++owlpVUms/Jyam+Xfppio+sAkDtG4m+9bAa214savqcLxVfb7O6A2d18SE3t6ooU9OYRbOJwkMrARCcPdH5dqLM8vkOCXfjYEoBZhFWHEpgcqfGhaFtSrFWp+7m4CV/f+W51txoOqNY5Xu9lJ+zr2/177WmY7OoqKhZf5etvZ2Izy1jcWlHXpk3n4Kf5oFJT/62nyg3Czwy8HZuzf0LgBf2r6bHYJ8G7f+7ae2Z8ssxDGaR19adoY27UO33fY1vGz4rzsUkmllwfDe3tpYqQpsdJNeDqC8lO/287Ba7kmmO319DfyM/TG/PmJ+OUKI38/2eJLr7abmx0wQEZy9EXT552xegGf0EqgtEtD3nrU7w1hq3WvuteJ8P9w9klSVf4StrTzGhtTMaVf0LU5gFSUQwlZc2+H2eykyVp71Eda3bN/TYrOt/syZK1O543bWQ4pWvYUg5AkZrOH2cRRj3Ky8m6bl+JF//Le16jWhwH/Yg1+xNhsZ6vIc6Vf2dXW7/WRdS39/L5f4+GoLte9EYpAdu7Y1JuJoMjMiJZ1VgZ/L0OrYlnKK7p/0K7iWWWPMDO5itn31ZgXV5SVkZYgOO4Yr3UtOxqaBwsTmaVsSQz7ZXWlYqmlA14D9NQUFBQaF2FEHwAsLDw1m1ahWvvvoqH3/8McuWLWPnzp24ublx//33M23aNOLi4vDy8qpzX4899hh33nmnPJ+Wlka/fv3w9vau84KrpvVLRs9jyL9fUGQo5+/Uk3TwCeSdvpOrbXshUWG+LD2ezTFNe3mZKuNEky7+QvSVn0DXtK/Uv76Xp/0nPYGP/+WRLP1yufAVRZElJw4DoFYJ3D2kA74e1Ysx1Y259MwOxBLpwt89ehJ+AdbwwqlRZj7dJTmFdqeVMW9ww9+zyWxmb550sx/h6kWPcKtDsMhJS75l2s3Lt9rxXS6fcwU1HZvu7u7NOtaoEC/ic9MpLDdB1DTCH1pK8qczwGRAt+NHxvuF0d07mJi8NHbmJHHckM+woLb13v94X1/em2LmkeXHEYH7/jlL53B/+kVULihzfWQ0nyXuB2BV5lke7y3lg9R5B1LhIfV0FNB6X17fW2Ox93fa0P35+sL8G1TMXnAAgCfXnmNs12H4jLyLnH/fA4MOIeYvfCf+X6Xt4soL5OlBER3w9aj7f2Osry8TO2fw78lMzuWVsTZRxy19wmvdzpYCZ1eMAKbyBr/PgkRryGungNBGfe5N+d+sCd/IydB3MqJRT1nyUXTxe0k8u5tMR0kA71iShYchF8Ov17Po8JPMvOdFAms4/zYXi08ncFhrfTjnVp5/RZxLbWnI2C7n99FQKt6Lp5cZRJF2pkQA+pn1rLK0iSnLZUSbLnbrMxmrQ9DfzVMeQ76zExVnDTcPb7wbfK66er4XhSub7sHVR8mYRBHsa7hVUFBQaNEoIcMXcPPNN3Pw4EG+/fZbvvnmG/7880969+5Nx44dWbx4MYWFhezYsaNe+/Lw8CAsLEx+BQc3Pa9IlE8IS0fOQyNIX927xzbz5cn6jaeTJWQ4Xh2GUSNVItXF761tkzqpT8iwIfc8+ZaqpWp3f7yG3tqkPq9GdpzLJc5ScGBCR3+CGngzWnT4H3m6Ily4gsGRPjhppN/LujNZjRrfsfx0OUTJNlwYKocMC1dIyHBzHJv1oWuQNe/Q8fQi3KMnE3bvb3Ihh9zlr/KoYBVVXjuyvsF9PDQ0krsGRACgM5iZ8sNeuZhFBZ08/OnqJblVtmTEk14qOUMqQoZBySNob2b1COHx4dKxU24083//nJAqO1vO5XkbvkC05ASroCJk2EWjpY17/d2iL42zCkuvrTvboFyCFWH/oqGswcWrUkqtAmaoa+Mq2DfnsSloHHCO7IPP6PvJnfqCtc9y6dmoFhMjjr3Fgqem8P6/+yjVG2valV0xmUU+2XaOY1ob8T+jYYWFFC49GrWKTo4FeIpS5MQgm2O2oXmf66JSyLCD9Xqhcsiw8sy/sdy35ChDPtte7cvUwPOiQuP4alZUtZWc1fWMilJQUFBQqB+KIHgBgwcP5u677+ahhx4iKSmJoCCr08rd3R0HBwcCA+0X9tEYxoZ24LvBs+X5B/f8zfLE6pPS21IhCJoFNekenQHQZ5zFkNvwPFMVuDrUfcGZt+U7sFyk+ox5QM5RpSBhNou8seGsPD+vb/3dPABmfRmFexZKM2oNbt0nVFrvpFUzrI301D8up5SU/IYXktmTlSRPDwpodUH/VrFJ+W5rp2ugVRDceFZydHr0m03wvK/k5X3/epbOrl4ArE89y9mChom4giDwxYzucoXbzGI9037aS0l5ZXHj+shoAMyiyNLEGOACQbAwEwX78sbETrTxlR7G/Hsyk8M6T9x7TgXAkJ1AyfENcluj2cRpy3ffxSsQlVD/v+t+Ed5c00lyYcdml/DG+rN1bCEhiqL1eBZF+bxdX86XWAXBYOdLX1SkNo7nWyu6dxp1E7HRD8jzk0rXM3LRED57bDrzV22osUCPvdgSl8OpzGJOa63n1uLUkw0WZBUuPT201t9V54A2eFv+E3dkJti1n2KDNR/wqYJMzJaCPmK59f9YySHYeLrvfpH/Hb2HJ0/dX+XlLJYrIasKCgoKClcNiiBYDZ9//jlTpkxBp9Px8MMPYzAYMJvNPP744/Tv358+ffpc6iFya/u+vBw9DpBu6Ods+Y3dmYm1btMxwBUHtfSV79D2kJfn/vdxo8dRn0uikuNWl5P3qHsb3dfVynub41hzSrrxD/V0YkqXhgnOOf++iyFb+u7dul+D2iIm2eLhZBVuzY24yXS3SVpu6wICMOamyNMVVWoVqmdoGx+0aumo+XBrHDFpkjPPe+Q9+E19HgCVaKZveb68TaGhvMp+6kKrVrF4Xm+6WRyJMWlF3Lv0aCWBYXZr6zngn+QTADgEWdMJlMbuanC/CrXjqFHzwhire2/ViUw8+l8vz5ennpCnVYKAg6XQRYmh4cWAXp3QkYp71pf/O8NHW+Lq3KZo/zLKEqSwZoegDggahwb16efkKk+fLri8BeW27tbQyI9ObiVx/PV43bsYvUZ6D87omVK0it5/juOtd19Bb2y+GLVii1iv01vH9KtbMLknNta0icJlSrjNA+OEuNP08pWqV6eWFlLSiHN5TXTw9EdrqSi8JOEod+9Yglk0U3Twb7mNQ1Dj80O3dMJ08XQwJtA92KPKS+Pkiotr9VWGFRQUFBQUrjQUQbAatFotixYt4t1332XZsmWEhoYSGhpKTEwMixcvvtTDk3kxeiy3t+8HgM5kYPL6HzhTi5vIUaOmd5gUxvWpcZRceTF341eNripaXsdNklmvk8OSHcO6ofG4PHIHXi6czSrmhTWnAFAJ8PtNvXDS1r/apT4jjuyVbwJSOFzgnPerbXc6S6ok6+KgJsyz4S6+CaEd5TD1ZRY3mXUMVveRraCkUJUwL2deHCvdpBlMIrcvOiyHc/pOeFwu4hGba62s2t7Dr1F9eThp+fu2vnhaxOBfD5znyx0J8vqOnv60c5f2vSktliJDGa5dxsjrS46va1S/CrUzqYv1HLjuTBZaP6srzGAjrqsEFdE+oQCcKshqsJjQJ9yLT6d3k+cfW3Gi0vd/ISZdIem/PiTPB875oEH9AYwNsQoQa89f3iGvk8K78Eava+T5h/b8za9uvnR97zTqkY+i00g3/GrMTDr5Jg99/gtlBlNNu2sSciqBclc66aWHL+lOHny4ZUGz9KfQfMy45hoKBOnaShW3mVY2D+hsC4E0lXYefiwecbMsCv5wdi+3rf+RQouI7BjaFafWve3WX0vkvEtbIp/fXuXlFB6FQ0D9c/sq2J8EF3eGrPq82td9O5de6uEpKCgoXFG0OEEwOTmZDz/8kI8//pjY2Nga26lUKp544glSU1NZsmQJq1evZtOmTZdVwmVBEPh60EyuCe0EQE55KRP++44MXVGN2wxsLRUXyBc8KOxxMwBieQm56z5r1BjK68hNpYvfK4eduXQc1qg+rmae+OcEBpPk2nphbAeGta3/70sURdJ/fRDRIhT4TnwSx2ocASazyJksKadRBz/XRoW6eDu6MDK4HQCnC7I4mZ8hr9NnWI4jlRoHv8gG77ul8dSodkSHSOGU+5ML+GCLlFtK7eqFe+9rAUhwkMJKA5zcKuWHaiht/Vz59aZe8vyjK46zK0ES/wVBYEqElORebzax7vxZtD6hOIZIy0rP7sRcVtzovhWqx9/NkZ6h0ve/JykPnbPVUWTMS6nUtpevJAiKiByxEYnry/+GRPLu5M7W+WUx/Lgnqdq2WUtfwJgvFQ5y7zMD9+j6FauyZVyo9fzzX+rpWlpeHjzbYzRv9raKgk/tX8UbicfoMO8Den6RSkmveQA4YmDGkSe5/uv1VULv7UGkjwsulny8pqK+qC3hn59r3MlIOW73/hSaj4Ft/Dnr2RcAT2Me6jyroz6x2H6CIMC0Vt1YOvIWWRRckHKK5zuNx4SA17A7EOqZay05T8eexDwOnC9iT6J9x6igYG9a6YppXVr9fc7RvDQ5966CgoKCQv1oUYLghg0biI6OZt26dXz55Zd06tSJxx57DKOx6gW+Xi+FaLm6ujJs2DCio6Mv8mjrh1al5s+RN9PbEpZyrjiXB3f/VWP7Qa2t1UY3h8yRQ8Jy1n2CqRYhsSbqcgiWnt4qTyuCYGU2xWaz/LgkrEV4O/PUqHYN2r7owN8UH10NgNY/Er8pz1bbLilPJ39PFXkkG8OMVla3ka1LUJ8pCYJav9YImqbnLDKLZs4UZJFk55unywWtWsWP10ejtgizL609zakM6djzGnob5So1aY6SYNRYd6Atk7sE8sJYyblpMInMXnCArBLp/DYl3Fr1cmWKFK7q2m2stMBkoMTm+FWwH+M6SC5BswhbsrRyYRFbhyBYBUGAAzmV19WXJ0a249UJHeX5Oxcf4dcDlfelO3eA3PWfA6ByciPopk8a1VeIiyfdvaUiILsyEynUl9WxxaXnmajRfNRvqjz/yuF1PL1/FYKjK30e+B5jq0EAhJkzmXDkea75dheFZQ3LrVgXKpUg5xeNz9BwncW9X6h14rUN39u1L4XmJ7jvJHm65LQ1v3NCM/ynTYnoyl+j5uFgEQVXBHXl6S6TcBl4Y722X34snYjX1zPg0+2M/zmGAZ9ut/sYFRTsyX1JJ3n79D62T3qgyivK++IUiFNQUFC4mmgxgmBZWRk33XQTv//+O6tXr+b06dN8/vnnfPnll0ydOlUWAAFycnLo2bMnP/300yUccf1x0zqyauwdhLhIIsLSxBgSawgBHtjKWjRgY6YDnkNuBcBckkfaj3dWqXJZF+XG2ttXEgQ7DG3Qvq9mTGaRR5dbnR/vTOqMcwNChc3lJaT/9rA8H3Tz5zUW9DiVaRV6OzZBEJwW0Q3BkjXyL0sRG3N5KaaibAAc/Fo3eJ+iKBJbmM3C+EM8se8fRq7+Cq/fXqDjsndotfgNrvnvO3ZknKv3/rLKijmamyq/Lld6hnnytEUALjeauX3REUxmEdcuo0gL7IRocXa0dbZPnqKXxnWUi4ycLyjj9mVnKNUbGRIYiafFgbgq+SRm0Yxr17HydiXHlLDh5mBsB6vQuy42D42XdBNjzE2u1K7iQQ/AwUYKgiC5j58bI4nCogjz/jjE4iPS8SGaTaTNvwcsrjT/ma+j9QmrcV91Mc4SNmwUzWxMq9mFfznxSNdhfD1wpjz/7rHNPLTnb0SVis6PLUF0k1ycww376XLiG8Z8vZvc0obndayNoW2k/2aTWSQ+sw/OFmf9d0aRhKza8wMrXF4MGW8t+haRdkSetrdDsIJJ4V34SSviYJYebv8b0JGb9q9Gb6rdzSqKIs+tPtUsY1JQUFBQUFC4MmgxguDx48fJzc1l3DipEIcgCNx77738+++/bN68mbvuuktu6+XlRXR0NJ988gkGg32dAM1FoLM7j3SRBDezKPLFyZ3VtgvxdKK1jyQc7U7Kw3viU3IuwcK9f5L6wx0NqmxYm0NQNBrkwgTagLZovUPqvd+rnfn7kjmSKhWUGNjKm+ujG/bZ5G36RhYP3Htfi3uPiTW2PW0JFwbo6N94QTDYxYOBlgrDB3JSSCzOxWAjYGh9I+q9L5PZzCN7luPz+4u0X/o2c7b8xvvHtrA5PY4im1xpa86fZsi/XzBi9ZfsqeWmOKEol4d3/03QwlfosfxD+XU588LY9nQJlL6PXYl5PLXyBIJKTWaPKXKbiLzkmjZvEGqVwO9ze9HKWzr2dyUXcs13e9AbRCZYUg5klhWzNysZ107DwVKdUskj2DwMjvTBWSv9/f53JksW4Az5qZUeynT2CsRRLeWAPJjT+GrwAK9N6Mjjw9sAkjPxxl8PsuJYOrnrv5ALiTi16oXPmAdq202djA+1uhHXnr/8w4YruKfTQOYPuR6VRYz//OQO7t6xBJVHIK0f/BPR4sB6oPR3NHGbGPnlLrKL7Vck4vkx7WnnJ/0X70lRMTJfclfqVRqeVVyCVxTO/q0o9pJyzA0vtrrpm8MhCJCz9mOi177HlzF/4WQRkv9KOsaMjT/XKgquPpXJ8XTpgWG3IHceHBDCkyOV3HgKCgoKCgotiRYjCAYFBWEwGNi8eXOl5aNGjeKXX35hwYIFrFq1CgC1Ws2CBQvYtGkTWm3TQyAvFnd26I+LJWTz+zN7KK/hQrBXqFRYpLDMSKo6kIhHVsjFDAq2/0zR/von5K1NECxPO4VYLolRLu0G1XufLYH3NlmdMx9N61rvXD8V5O+wJJsXVARe/26tbU9kWB2CTQkZBrg2who2/N/5MxQdWiHPa3zC672ff5JP8MmJbeTrdVXWtXP34/rIaDp4WCsWb0mPZ9Cqz3li3z/ojNINj85o4Le4g4xZ8w2RS97k05PbG1VB+VLhqFHz4/XRciXYD7bEszUuh8zW1irmASfXIxrt81DC19WB5bf3xcdFOkdsjc/l/c1xlcKG/0k+gcrJDZd2AwEoP38c3bn9dulfwYqTVs1wS77Q+JxSdC5B0gqTEV3sbrmdVqWWQ6CO52dQ1oTfgiAIvDelC/8b3BoAo1nknj8Pkr38VUsDFcG3fYOgqr9TuTqGBkbibBGUN6VfGQ7BCua178sfw2+SCyj9cHYv12/+BU37QQRd9w4AKkQeKv2No2mFPLnypN369nZxYPltfXFzlD7/Q6k98daXAvCHTkenHz7l453JbI/PQddMxU0U7EdgLylsOESfLy9LKcmvvnETMOmKyFj0JAAD85JY0qojbhqpMM2qlJN8drLmEOCf91ldx+9P6cJLo1rzzuQuNbZXUFBQUFBQuPpoMYJgaGgoEyZM4P7776e4uHKi/JkzZzJ9+nS+++47eZlarcbb2/vC3VzWeDu6cENkTwDy9DpWp1QNBTGazOxMkJ5SO2pU+Ls54NplFKH3/SG3yV3/Rb37LNHXfGOidrWGJxsLM2ps19IoN5o4ky0JpQNbedO/VSN+Z2ZJiBW0TmjrqHa325Ik3EGtonNg0wRBT5sCF6bMODKXWPIWCkKDihAcyrW6nTp5BvB274msH38PuTe+ytlZT7NwxFxOXPsEC4fPlXOSmUWR949toeeKD7l7x2KCF73C3K2/syHNWuXYSa3hhshoHuw8hAc7D2nSe70Y9G/lzbs2N2C/HUzB2dNaZMKQn0beFvu5g3qEeLLpvkGohYr+zjMhtCNqiwCyIkkKY/cceJO8Tdr8exucSkChbiZ3tn7P+5ytInDaT3dXEoF7WioNm0Qzx/Obdh4VBIFPp3ejra9UtCaoLBFTcQ4gFRJxjuxT2+b1wkmjpYOnJOanlhY2eX8Xm+sio1lqk5NtaWIMt2z9A6/xj8gPPYJEKSXH74fOk2VHl2CXIHf+mNsbVwc1aUIoo5Ks3/dpVRKvx61l6Bc78HxuNf0/2cajy4/x5+FUzhdUfbCicGnxtQiC55085WWBdkoBYYtK64RgEeA1PuFMGns//42/S3a6fnpiO8Yazt96m6JwvcI8q23TUvkqojNPd+xbbRXbo0rRCgUFBQWFq4gWIwgCfPHFF6SnpzNt2jRKS0srrZs8eTKpqZdvzrH6MrettaLob/EHq6xfczqL9CLpBmZG92A8nKQLSfde03AMjwKg9NRmys+fqFd/RbVUXNT6hKK15JXTxe5ErCOfTUshMU9HhZGtg79ro/bhECjlnxP1pRgL0mtsl68zcMwSEtQ7zBOnBuQprA7bkCeXNe+B5Tv1n/4yzm361ns/54qsOS7/GXM7T0WNYnRIe7wdXeTlapWK69tEc3jao3zcb5rsOjpdkMV3Z/ZQYFOwoKtXIO/3nUzi7Of4Y8RcPh0wnU8HTG/s27yo/G9wazycpLDQpUfT8LbJBZmndSbr75cx6ewnrESFeDAi0guAs9klJGUbGRLYGoBj+enEF+XgNfwOnFr3BqAs4QB5G76yW/8KEtdFh6Cx2ENfz++Hc4UrM/UExTah2tG+1nQCh3ObFjYMUgGLMouzux9WB5+rHYs++Vh+w0WG8jrzmF2OTI3oyppxd+GulZxWfyYc4cVD/6GyOOndtNL3Vm40880u++b3m9wlkHPPjeavW/vQo89jvHR6i5wbDs8scMvFYBLZm5TPx1vPcf0vBwh7dT2vrL1ywrNbAq6dRyA6unPIw3r8DrKk3LAngkYrpXlAykGqz4hjYEBr2c2fVJLP30nHqt02yN1Rns4osp+wfTWQ6OxGgkv1Am6Ud7D8oFJBQUFBQeFKp0UJgm3atGHlypXs27ePESNGcO6ctVjB5s2bGTbsyq+COzyoDaEu0pPef5JPUHBBSOaPe5Pk6dv7WUM8BUHAZ/T98nzuxvoJAMW1CIJgrSxsLiumLOlIrW1bCnHZ1px+bXybJggC6DNqDsvblZAri4+DI31qbFdfztkUqwnOlo4ft6hr8Jv6fKP2IyAQ4epVa1uVoOLhrkM5Ov1xhgZGyss9HZy4t+NA9k5+iJjp/8fj3UYQ0AwOjObGSatmWlcpZDSn1EBKjtXNkad1wVSYSe66z+za5/Qu1qIWiw6nMjW8qzz/T5KUyzD41q/B4jLJXPIshrwr/4HJ5YS/myPjO0pOutjccrIHPCKvKzq4XJ6O9rEVBO3zHVQUxOhhsIpIzm3622XfAL5O1vNaXjVpAa4ERga3Y9moeXL48JtHN7DES8qT6qoVZDH3ix0JdRbXaij+bo5M7x7MC9cO5rEZT/LuiVXyurDgfczwTJJTDVTwzqZYCnRXRs7jloCgccC90zAOeVorhbd2DGqWvly7jpGnS06sB+DhLtYibp+cqD5sONBGEExXBMEqtC4tqraS7fZJD/DVoJl170BBQUFBQeEKoEUJggCDBw9m+/btFBcX07lzZ6ZNm8bgwYM5c+YML7300qUeXpNRCSrmtIkGoNxkZGmCNaF1ZlE5/xyXQpAivJ0Z1c6v0raeA29C5SQJKgXbf8ZcVjm0ujpqcwhC5crCthWHWzLxOVZ3ahtfl1pa1oxDgFUQNGTG1dhuR4LV0Te4ddND4BMszj61aCawvAitX2tC7/kVQdWwU0l8kRSmGObqiYOlaEJdtPPwY/M197Fk5C0sHnkzade/xFeDZtLXP6LBORgvN2yLyuyOtwrGeRbHZO76zzDbOCKbysQOPjiope9s0ZHzTLXJI7jc4iZxjuyD9+j/AWAuKyLjj8fs1r+CxNze1mq+v+S3ReUkhfQXH1qBaEkL0N07WK7ufcQOgqDOYEJnkPbdoUxKKyFoHXFqFd3kfVfg42A9r+WWl9bS8vJmTEiHSjf+LwRFsdsrHBWifMymF5Wz8FDzieUe/WYzs8MA+uVJD/NSHJ3prPueMz4fsXW8kSmdAwDQGcwsPNx0B6mC/XAM68ZhT+l3IpjhYGzNOZebgm1l+OLjkiA4JDBSTjewPeMcB7OrVilXHIIKCgoKCgoKLUYQ3L17t+wIjIqK4ujRo/z2229069aNu+++m61bt+LufuW5i6rjpjbVhw3/ejAFo1myi93WNxzVBRYDlZMbnkPmAZIAULDrtzr7Kiqv3Rnh0tFGEDyzre7BtwDic603yG0bKwjaOATL08/U2G7HOaujb1DrpjsE4y0usaCyIrQaB8IeWILarWH7LTMa5Nxibdwbtq1KUDGzdRSzWvfAWXPlFPypi7Ed/PFylt7P5lMF8vLiQKkCsKkgg4Kdv9itP08njexOS8jVkZOvoYuXlNNuS0Y86ZbvJ2Dm62g8JVdL4Z5FFMestdsYFGBq10C5iMTvR7Nw6TYBAGNBOrpz+wBw0zrSzkMqQHI4NxWz2DRRocId6GIuJbg0HgCniJ4IGocm7dcWH8erQxAEqVjXU91HAmAUVDzSbSpxju48OqyN3OajrfGIzVjQKPTOn3iv+wgESx9fRA4iM24nvr/N4O2khxmiPwCiyI977VOVXME+lAV1ItZVevDqV2LktwOpmM32/504hnVD7SEJw6UnNiKaTQiCwMNdrHl0PzlR9fqrpTsE0+bfx7nXh1R55X42CQez/R7AKSgoKCgoXM60CEFw165dTJs2rVKIsEajYebMmbzxxhvMmzcPR0fHWvZwZdHDJ0S+ud+UFkdicS6iKPLDHmu48K19q68I6zPqPnk6d8OXdd7k1BUy7BDUwXqhemZbs940XSlUdgg2MmQ4qKM8rU+vPneUwWRmT5LkEGzv50qAe9N+4wWpp8iwFDsIKSsgaO7nOEf2bvB+EkusrsXIBoqJVysOGhXXdpOEt4ISq1BfZMnBCZCz+n3ZNWYPbF2JC/ancENkNCAVb/k9/hAAahdPAm/8SG6X9vP9mK/QENDLERcHDTO6S7mockoNxAeNlNfZhg1XOH2KDOXsy26a6JNbKh3D3Y1nEZDOx85t7RcuDODjaM2DeaULggBv9r6GWa2lHLtFGifuaTeaCH+NXCn6SGohm2Jzmq1/Qa1h2Nj7mWPJ85uvdeabVgOklYl7+KbwFT4reoNDiVkcS7vyCrlcrRx285en2xfmkZinY1Nstt37EQRBDhs2leRSliidv29o05MAi+v4j3OH5Qc9FbR0h2BZSgzlyUerXadXOVGucqp2nYKCgoKCwtXEVS8I7tq1i+nTp/Prr78yatSoSz2ci4IgCLJLUERkyKov+PbIMU5kSCHAo9v70dqnemeaY2gXOe9fefJRDNm1J0w31CFQCIKAS7tBAJiKsjHkJNXaviWQlC8JKk4aFQFujXPlaLysuYgMWQnVtjmTVSKHBg60Q7jw7k3WardtPAPwHnFno/aTXJIvT7dyu7IqeTcnskAnqtCIklsw0WjApft4APTpZ8hZ9Y7d+pvaNQgnjfQX8OXOBPbFWG8OPz25HZ1F/PXof70ckmbIiifrr5ftNgYFmNvLGjb8u64rWKrbFh/9V14+LcKa43FJQvU3sPWl4iFOa5M1vDRj0w8c++MVTOX2EXuvJocgSM7kBUPnEF0muXdTnDx49eBa7uofIbdZfKT5c2w+22UErhYn5x8RfSmOtAq5o/R7uat0MV/sSGj2cSjUj/02uSV7FkrH2+a45hGO3brY5BE8JhUlclRruMlSaM5gNrEq5WSlbSqKygFkl+ibZVyXO47hUUQ+v73Sy+fBVaS4tCXLKbTuHSgoKCgoKFzhXNWCoK0YOHbs2Lo3uIq4u+MAuVhDSmkB9x1aAL4pIJi4e0Dtle7U7tan2hVVFWuiohgCgAjsTcqr0kZQWy86VZqrx4nZWCqS0YvQ6Nx3hfuWytMOQR2qbWO2cWN6ONYvT19trHXxlaf7qRufs89RZR2L0Y6Otyud0e39aO8nOUaNJZKrI74oh5xxj8siUebS5yk5udku/bk7aXhuTHt5/p/DBTiWSsd+YnEe7x3bBEi/0eB5XyFYKsfmrH4f3bn9dhmDAoxs54unpcr0qnN6ubpzeXIM5nIpn+Tk8C6oLcUt1qeebVJ/3YM96B7szh5tFHmClCZDayhGteZltt7fmg8+fou/j56nqKyy+9tsKEeXcJD8bfMp3Le0VrdqxVgBrhZPuLNGy3xHAVej5KT66exe1sVZRcCeoZ7NPoYgJzce7So9sNOLIqumvkL4w3+DRSS8U7eU/3btI71QCXe8HDiUZj1WHUula5/G5g2ui8qFRTYAIIoiG9OsRceifSoLXPuT8+XpDv6Ni1ZQULgUhJbGVRvuXZZ8FH0tebUVFBQUFKpy1QqCLVkMBPBzcmXflIcZEyLd8IuIEBwHXXbybfo/vBuziYPZKdXmozLkWkLS1Fo53LcmRrTzw1YamvXzfrKKK4eeGIutITJqN19aOu4Wca7caEZvbLggZshJIu3ne+V5zwFzqm1X4f4CKGtEP7aIosgKo3RrrzGbGLz3d0y6xoWmeTlYwwmv1AqkzYFGreKDqZbiHgXWgj//miFg1hvSjGjm/FdzMOan26XP58d2YOm8PvhbnKrlKZFglo7ot49uIqlYEvgdAtsSMOM1eQyp39+OaGyZjhJ7o1GrGGkp8JRaWEZZUA9phWiWQ/88HJzo5yeleTicm0pWPQo+1YSbo4Z9jwzloRnjeLLTL/ziNAUDkuAcaMzkmkPPUv7JSG595nl2/Pwy57+eS9xz3Tl1jxvnXupN6ve3kfL5LDIW/l+NfZhs/ldUV3jBH1va9L6WWWlSoa4Ss4nfEiRh3NtZy9zeF8dN9L9Og9BaHhB8fXoX2qiJ+E16CgBHDDxW+C2fbDtX2y4ULgJGs4kdedJ52ldfwmmxIy4OamZFhdSxZePQ+objECylEik9ux2zXsemtFi5ENHQwEh6+4VV2sbWrTjigiJzCgqXKynObTjv0rbadWJ5qfwgTUFBQUGhflyVgmBLFwMrCHB2Z83Yu4hSd7faNAQzG9LO8tT+VfT+52MC/3iFGzb/yq9xBzCapfAWo0UQ1HqHNrh6bHJ+GXN+PYjJJnG2qSgLAJWLJ8JVVAiisXg4WR1ydVVpvhDRZCTlqxsxW/LweQ68CbeeU6pt66RRy9NlxtqLv9TFoZzzxBVLBUoG5SXiXpJLwY7GFbnwdlQEwZqY3CWQcR38ochPPmaXJsbge80TuEVPBqSCEylf34hobtp3WsGMqGCOPzGC2T2CQe8MOdJNo85k4JaNVieqz/hHcGrTD4DylBiy7Ri+3NIZ0956M35cY3X86uL3ydNjQ63LNzTRJeioUfPo8LbseHoa97+9iCM3rOO473B5fXfjWV7LfQfvja9QsOs3ylOOganyuSp37Ufkrvu82v3bupNt3YJXOm5dR3NLzlnUFsHT6JUCgpm7BkTg4lDZhd1c+XKDXDyYY8n3mVlWzB/nDuE36WlUPlL48kj9Xg5v+JMCnaFZ+leoH3uyksi3/AYG5yawX9udWVHBuDs13a1fE65dRgMgGsopPbuDj05sldc91nV4lfYV+QzdHNX0Dmt+h+vlRlx2CTFphQz5bHul16QFMZTq7fP/qmB/fm/1f7zb6csqod6Rz29HcGweB66CgoLC1czVc6VuITs7mxkzZrR4MbCCM1klHDvqA/HROBeG0c698lPg7PISFp07zM1b/6D/yk85kHEOY4H0VFvrU33hkbrYcDabF9ackudNRdJFp9pNeQINVocgQGFZwwTBkrXvoDu7AwCHwPYEzfuqxrBjJ62NQ9DQNIfgwnOH5enxmVIRk7x6FJ2pDm9bh+BVkF/MngiCwEfTuqI2O0KpBwBHclOJL84l9K6f0fpJ4f6lJzeR9fcrduvX382RP2/pw8K5vfAubgsGyTG4JecU0xb9R3G5EUGlJuSOH8GSAiBr+WuUpRy32xhaMmM6WNM0rC21nnd18XutbYKt4d1NDRu2JdzbmVuuGcnsDzcT8uQG9BUORRsErRNOkX3xGn4nPhMel5en//YwRQdXVGlvKwheTQ5BQeNAxy6jGJdpqeyu1SN4ZfK/wa0BSMnX8cyqkwS+tJZO72ziVEZRs4yjImwY4KPj2xAcnAm56WN52cN5X/PNtuqLTSlcHFYlW/P1dc3LJUPtV2MxN3vhapNH8EjMOlZaxtDW3Zcp4V0qtT2XU0pinvRAbmikL1r1VXc7UCelBhMlNQh/Lg5qXB3U1a5TuHwpM5op1ZuqiLwVr/uWNC0Hr4KCgsLVyFV3BeDn58fBgwcVMdDCi2tOYxYBnSdv9ZzK2VlPkzD7Wb4bPJvrI6PxtXmadjDnPP3+/ZJ32wyjRK1F49uwi1cB0Fpyy721IZblx9IRRVEOGdbY5CZsydjm82uIQ7D42DpKNnwMSDemof9bhNrZvcb2lR2CjRcEj+Wl8dnJ7QBoVWom+0sOsvLUE5Se3lrbptXionFAY3EN5euVXFcX0iXInfsGtoJC6/GyJOEoajcfwu7/Uxbksle8TnHMWrv2fX3PUI7/3xh6qKPlZStydtDjg01sj8/BKawr/lOfl1aYDKT9eIfdnIotmQ7+roR5SvlaF6e6oXKSjmvdOatDcEBAK9wsOVjXpZ5pFgeaV9dR9HjrIL73LuZ3v3n8n/v/McXrC5bMOkCbl/cScvt3BM15H/8Zr0obiGZSvppTJaek2SZzoIqrRxAESI0Yx23J1u/FLTSN8wVlzPnlAK3f2MDbG2PJLNZzJquEMd/s5lyO/R96RPuGMiJICpmLyUtjU1os7r2no+4kCUIR5nQyVr2HzqAcm5eK1YlHAFCJZpyLnGnl7czwNs2bMsW18wiw/Ld+lWEt4PZIl6GoL4j2sK12PLJdy03l4uqgZvuDQyq9Vt3SnahgD9r6KnkVrzTMZhFTDf+NR9OKiFGqsCsoKChU4aoTBAGCg4Mv9RAuCw6lFLDkaBoAYZ5O3DNQche1cvPhzg79WThiLplzXmbbxP/Ry1fKf2RG5OfwPkzvO49Yr7Aa910Tn07vJk/f+NtBdp1KlEPN1O6KQxAqhwwXltUd1iWKIkVHVnP+m7lgudAJvOF9nFv1rHU7ZxuHYGNvDA/lnGf2pl8os3yHj3QZSutR98nr89Z/0eB9CoIghw3n6RWHYHW8PL4jnuXW89i3J/chiiLObfsRNOcDaaEokvzpDEpOb7Nr38EeThy8bRZtnS0Fg5xLiBfjGPrFTrq8u4n5rrPQhkrHuS5uDzmr3rVr/y0RQRAYa3EJFurN6IMll54hMw5jsZTnS6tSMzyoDQBJJfnEFmZXv7OmjkWlInDgLKY/8jHrnIcTrwnn5fVx7ErIldv4TX0er6G3ASDqS0n6aDK6OKub8Wp1CH63O5Hh652JLC5gYG4iAEUUMmj+chYeTq2UKgPgfEEZY77ZRWy2/XNaPdJlqDz95tGNALS+7QtMgvT/cmP+Quav3W73fhXq5mR+BocLpeM2qjCNeNowr084KlXzHgtqV2+cIvuQ5eDKUlcp/7OXgzO3tu9bpe2mOOv5Y0Rb5dpM4epBLQhVRN7tDw4hKrjmB+gKCgoKLZmrUhBUkFh1MkOevrVvOE7aquEPKkHFkMBI9kx+iA/6TsHF8nQ51cmT2/UChQ10cN0zsBXz+khCYqnexKsrD8nrlCIEUFRmZOWJTHm+rirDxcfWce7VASR/OBFTobSde6/peI95oM6+1p7OkqfVDbwpjyvMZs7mX+m14iNOFUj99vUL5/VeE3CPniyLuyWnNjVovwBm0SwLBqVGJc9Vdfi6OvDamB5QIuV1ii/NYs7KfxFFEe8xD+DRdzYgiTEpn0zHkJNs1/5VKhWLxtyAUOHuCjwH2jJOZhTz5Jo47jDfhWg5V2QueVbJJ2gHokM95Okcz47ytD5VSr+QUpLPmULrMR2TZ5/CMjXRJ9yLtyZ2BsAswk/7rL8xQRAIvvUbubKpqSCDc68NJGPRkxSXFvBzrNUx6GqpgHs18Mb6s+hwZJtDb+alWN9jb6etBJmyCPFw4s2JnTj7zCiigqXvMz6nlL4fb2O1zf+xPZgc3oW27pKza0PaWe7asRhNQDtUwx8CwBk9puVP8sHmuGbLZ6hQGVEU+fb0bvos/1BeNiznHDHa9tzSp+EPWBtDbufRzIu+jjKLk/xWD2/ctI5V2u1MkPIQuztq6Glz7lFQuBI4mlZUbUhwTe5ABQUFBYWaUQTBq5ixNnmpfj90HoOp5rBRjUrNY92Gs9XLnW6FkqvwnMnIPTuXNOhmQhAEvp3dg25B0pO4tWlqRB/JmVhyYgPGAvveFF1JmMwiN/12kKOWkIXOgW70j/Cqvm1pAanf307Se+Mos8kjpo0cQMgdP9QpJKYWlHHrwsPy/E31rICZXlrI/3Yto9OydyvlDezkGcCfI27GQa0BUcRsqTCs8W54Zc192cnkWHIHVlROVajKfYNa0c8pSp5flLGVcT9tJl9nIPiOH3DpJCWJN5XkkvLl9Yh2Fld7+4VxX6eB0ozahHubeARBOhdsM0TykfPNctvMP58m/Y/HEc1Ny1XZkkkvslZndxWsjl6VkzuJxbkM+/dLzlpcgW3dfRkV3K7Zx3RdtNWleqHLWNBoCXtgCc4dhkgLRDNZ/77H7G/vYV92sjzOkRdhnBeLR4e1QasW+Mh1HsWiNZywZ1ks6wrvZ1+7f3mirxft/Fz5754BsiiYrzMw6Ye9vLbuDGazfW5Y1SoVH/efJhdt+eHsXm7bvoj2179IscXdO0q/l3+X/MhtCw9T3MACVgoNI7W0gInrvueenUsotaRRaFOSQ9tMI0NHTaKtX/OHnx7PS2eayYFEFx8AwnX5zFr+POe/nYdJZw2VLDOYOJcr/Qd3D3ZH0wLzBypcuXQP9qjR7acWhGZ34iooKChcbShXAVcx/Vt5M7lLICC5FH7cm1THFhCcm8zHx//B0yAlm1547jA/nN1bx1aVcdCoeGhopDQjCBwMnCRNm00U7Pq9Qfu6mnhq5Qn+OSEJor4uWlbe0a/aC/HimP+Ie64b+dt+kpc5telH+GOr8H7gH9RuPrX2YzKLzP39INklkiPzuh4h3Ny7dneCyWzm/ZjNtF36Fl+e2onRUkUz2NmDrwfO5Oj0x2ntLvVbfv647PZ0btWrfm/ehr8Sj8nT01t1q6Vly0ajVrHz9qn0dbUkg1ebWF+6negPt3Agy0j4I//gECRVntXF7iJj8TN2H8M7fSbR2s0bgCJtFteMzaF/tA7BuYgfXK/lLdc75ba5az7k/FdzMCt5IRuM2Szy+8HzAKhVAj5Yb94ztM6MWvMN5yxVvjt5BrB14v142VTrbi5snyFV5zJWu3jS+pnNBM75EMHBmc9bD2KNp3Su8TCU8dXJfyn57xO7O1gvFQ8Pa0PKC2P539RRfNDqYXl5a10eKlM5+f99TOwTbchc9iJ+6jJ2PjiYOT2lhyaiKOX0nTF/n90qAE8O78Jfo+bhoJLc/7/EHeDmPStoe6c1lcOzJd+yeN9Z+ny0lSOpBXbpV8GKWRRZGH+IzkvfY815ayGXuSkHeex0HB0eXMZH06Nq2YN9WHzuCEP+/YLUsmIAOolGfjm0EG+DjoIdC4h/vgelZ6QQ8tjskorsI3T0d2v2sSko2JOvZkVVGxK8/cEhuDiocdIot7YKCgoKDUE5a17lvH6NNfTstXVnKasjl5wh+xzB5UW8cWqNvOyuHYvp9td73LNjCQti9xNXmF2na/D66BBcLBXa3i2w5q/J3/FzY97GFY3ZLPL+pjg+2BIPSIVX/rqtL20uSFht0hWR+tM9JL0/HmNuCgAqV29C7/mVyBd3495jYp3OQIDv9ySyKVbKX9Tax5lvZ0fVut2xvDQGrvqMJ/avlEN4PR2ceKv3RGJnPc09nQaiVVnDzXWJB+Vpp0YIgn8nSYKgRlAxKaxzg7dvSahVApuuvYkwZ0mUw7WAJPUZhny+g8/3ZRH6vz8RtFIxitw1H1B0cLld+3fTOvLD4Ovk+X9Tj7PHuBex7UFUXXfwa9cwrunyGL+F9GRZUDd+TjrOR1/cyPzjW/gl9gC/xh1geeIxzpcoQkRtrDuTJVf8nNo1EI1OOn5ztM5M2LmM+CJpvrt3MFuuuY8QF8+LMi7b8CuNqvrLBUGlxnfCoxx7YDnftJYcpWrRzEfH/yE0djuZi57g7GMRJLw5nPTfHyP9j8dJ/+Pxavd1JRDg7shTo9oxZ3CgvCy693RUTpKwYi4rJnv5a8Q90wVtYTK/3dSTD6d2QW1xrSw/nkHUB1v4ZGs8RQ2sMl8dUyK6snz0bTippdyBfyYc4a6CQhx7TQMg2JzNXaWLOZ1VQv9PtvPljgQlhLiJpJTk89PZvdy45Tc6r/2UOVt+o9AoPQgJKivkh8OLmWHyY96765jQLaJZx1Kg1zFv6x9ct/kX8vXSOWRwQGt23vQmPe+ej8pV+u8wZCeQ8NYIimPWcjqrWN6+Y4AiCCooKCgoKLRkNHU3UbiS6RHiyfXRISw6nMr5gjK+2ZXIw8Pa1NjekJ0AwBh9IY91HcaHx6UqssfzMzien8G3Z3YDEOjsziD/VvTwCcGoFtCYRMwC6IwGnDVaPJy0XN8jhJ/2JXNM70tJ6ABcz++mPOkIZYmHcWoV3dxv/bIgJq2Qe5cclfP1AHw3uwdDL6g2WHJiI6k/3I4hO1Fe5hY9meDbvkXrVf8iOaV6I6/8d0ae/+3GXng6a6ttqzcZeTtmI68f2YDBEuKkFlQ81GUIz/cYg49NBWpbyhIOyNNOkb3rPTaQkq2fLpDyoI0Mbod3DX0oWHHVOrJ09M0MWvU5JtEMAQkYir15ZPlxtnYP4os5n5C74B4Azn83jzavHsLBP9Ju/Y8Kac9H/abyzIF/5eIyAGbM4FJEkovAmwGjKm+0958q+wl18WSAfwT9/SMY4N+K3n5huFxF+eWawnd7rO7tu/pHYFyQSb7Gibt63sBpS97ATp4BrB9/NwG1VBa3N0Ybi6BGXfNDhfMlBdx73Frc5l2fAEb6h6PLt76v0tNbK1Ull4vjXKHY5nPsP/UZvCY8TPaqt8nb8AWioRxjfippP99HxOOreXR4W6JDPbluwQGyS/Qk5el4ZPlxXlx7mrv6R/DQ0EgivBt/LpwQ1omVY+5gyvof0ZkM/JV0jPL2Y3jj2Hoc9CXMNm7mU3Eu5Ub437IYNsZm8/11PfCq4b9BoTIms5l1qWdYnXKK/1LPyHl1L2Ra+jGeObsJ52EP033eO/V6gNcUtqXHc/O2P0gstl5f3NK2N18NmimdW/vOwrntQFK/v5WS4+vBbCLlyxtIGbtYbt/RX6mkq6CgoKCg0JJRHIItgFfGd6QipcZHW+Mr3eTZIprN6C2ClNYvknf6TOL9vpMZFNBaDkmqIENXxF9Jx3j58H+UW5yAOicNLr88Q8AfL9Fnxcc4BZ8HJCfCCierYJC//ep3CZaUG3lq5Ql6fbi1khj46oSOzOtbOW9e5pLnSXxntCwGqlw8CblrPuGPrKhRDCwzGrh/11Imr/uBb07tIqdMqmL56bZzpBVKucjm9AxlUGT14cX7s5Pp888nvHToP1kMjPIOZs/kh/iw39QaxUCAsgSLQ1BQ4RTesFCoCncgwLVKuHC96ecfwYvRUgEHVCKEnQLBzLKYdGYc64xz/7kAmEsLSPniOsyG8lr21nAe6TqM/JteZ/+UR/hq4AzuaN+PHj4hcv6y+nC+tICliTE8uX8Vw1Z/icevzzNw5WcsiN2P3tRy85tlFJWz/JhUICTC25lxHQMoKMnnnqgZnLbkAmvj7sv68fdcVDEQwGRjJKupMJFZNHPLtj/IteQFvbltbx6b/jSRz2+n3QcJBFz3No4RPS7GcC8qFQ82vB2c8XV0QePhT9CcD2j3bixaf+mhW0nMWgp3LwRgZDs/Djw6lOndgqj4KAvLjHywJZ42b27khl8OsDcpr9q+6sPokPasGXcnbhqpgMS/GQk83G8eOpUGb0M270VZKx0vPZpG9Adb2J3Y+P5aAjqjga9O7aTTsne5Zt33fHpyexUx0NWgZ3zmab4+upQ3Tv1H2xveJ+rWd5tVDNSbjDx74F+Gr/5KFgO9HZz5c8TN/DxsTqUHLVqfUCL+by0e/SSnt7k0n+gN9+Jilo5XxSGooKCgoKDQslEcgi2AjgFuTO8WxLKYdBLzdCyLSee66JAq7Yz5aWCSQkYd/FqjUal5vNsIHu82gjKjgQM5KezMTGBHZgI7MhLILi+psg+ArLISsspKOJCTgnNHb3RJrfgwL4o5Di6gL6Vg5y/4z3gV9UW+ub1YxKQVMu3HfXLSboBuQe58PSuKwRcIdEUHV5D9zxvyvGv38YTc/j1an5pz/omiyOP7/uGrU7sAWJVykgd2/8WU0O6s3+4KaNGoBF6d0LHa7T8+vpXH9/0jV/rVqtS80GMMT3UfKRUNqQXRZKQs+QgAjsGdUDk2zF1gmz9wanjXBm3b0nk2ajT/ppxiT1YSOJXiFJpEWUprdiXlc0PQTfwafBBD2gnKzu0nc9ETBM391K79O6o19PYLo7ef9bdZatSzPDaWGxfvBET6+JqZVbgMQ16q9ChA60T50Ns5pNKyJytJLiYDYBLN7M5KZHdWIk/v/5eno0Zyd4cBOGlalmvp8+3nMFoKTdzRL4K8siLubDOcYx7Sw4AwF082jL+HUNeLEyZsi9Fct0PwkxPb2ZgWC0Ckmw+fD7hWXufg1wq/SU/hN+kp9FnnMFnyIF7pGMwm4ouk99LazaeS+KP1CSN43lckvT8egPTfH8Et6hrUrl5EeLvw1219ic0u4ZOt8fy4L5lSvQmTWWTR4VQWHU5lRvcglszr0yhBaVhQW/4bfxcT/vueQkMZWzXO3BM1k5fPrGOOaSPd7nyDmxceJqtYT2KejqGf7+D3ub2Y3aPq9UBL52huKuP/+450XVGl5Q4qNT29w0k9mc+ryd/TuygJNSKotYTevxDP/tfVsEf7oDcZGbP2G7ZlnJOXjQlpz/whN9R4jhBUKkLu/JHytFOUJx/FvziOlx2/5BnPJ2jre/U7BNPm30dZSkyV5QtCQjnhHsK7qz6vtNxoNHKiKIso7/pHZyhcPojlpZx7fUiV5U+mFZLi3Aaouk5BQUGhJaM4BFsIj9iECVe4US6k9NRmeVob0LbSOieNlsGBkTzRfSR/j76NzDkvc3bm06wZdxeOeslhpjGaGRXcjnbufvJ2Om0etD1Maes4tredDICpOIfzX81BNNeez/BKZN3pLAZ/tkMWA521Kt6e1JmDjw2rIgYC5K7/TJ4OuP49Ih5fXasYCPDesc18eWpnpWVG0cxfKUcoarULQs5wYz8/2vm5UmrUsz3jHB8e28INm3+l1Z+v8+jeFbIY2NcvnINTH+GF6LF1ioEAeZu+QbTkKXKK7FNne1vWpJySq4/294+4JALHlYxGpeaXoXNwsQhmboE5hHpK+QP3phvYNfRjBAfJ2Zm77jNKTm5u9jG5aByY06kL7TVtID+I40lhPP7AQuZ6+TEz/Rgzk/dz46KH+KkwkYxrn+DszKf5ZdgcHug8mGgfqwiRpivk4T3Lab/0bb4+tbPFOAY/2RrP6+vPAqASYERnZwau+ozDnlIhCn+zkQ0T7pUL+lxs9idbcz+6OairrC816nnjyHoAVILAr8NuxMPBqdp9OfhH4hzZW35dyRQbyqXwfeBQ7nke27sCo83/mVv3cXgMvBEAU2EmBbt+q7R9Oz9XPpvRnZQXxvD2pM7ycQywLCadw+cLaSwDA1qzfvzdeDlIRWcOeIUxpd9tjC/WsW/fO6y7ryej2kn/0UazyKPLj2OoIWqgpWIWzdy+/c9KYuCksM6sHHM7uTe+ynTX8bx8djH9ihJRI6Lyi6T1M5ubXQwEiCvKkcVAB5Waj/tNY+24u+r8P1U5uhL+8N8Ilod448p3EurphEMLKMBQlhJDefLRKstPuIdwroZ8rFHewXRXBMErDpWjK2fc/Jjt16XK68X23fnH3/FSD1FBQUHhskNxCLYQBrX2wVmrQmcwczSt+puNvE3fyNMefWbUuj9BEGjn4Uc7Dz++tcSVORrMrJxwLwC7MhO4Y/ufnKwIr/HI5R6PcCZqZ3D/2U1EHllF1rIXCZj1Rk1dXHEsPpLKjb8elN0+g1t788uNvYj0rT781lxWLOfUcghsh9/E/6uzj9+TjvLU4VXy/HNRozl0voB/M46AxgCCCD5pLCr9m0N/7+BEfoZ843ohz/cYw0vRY9Goqt7oV4cxP53MJc9KM4KAz5gH6rUdSK6Gh/dYC1480W1EvbdVsNLe058+vuFszYgnu7yYA3f0ofeHUuXI905o2XLjR6TPl/IJpv5wB5Ev7kLjEdDs4+rg78rZ7BJ0BjOlGjci/m8Nqd/dSuGehWAykr3idfK3fI//zNe5aeitzG0rCUL7s5P54NgWFp07gohISmkB9+1axtsxm3i153hubtu72fNwXSre3nCWZ/49Jc/fN8qP6Vu/Jc8iuAeWF/GrqYAOnv6XZHwms8g7G2Pl+VlRVV1kC2L3y67P29r1ZVBg64s1vEuKt6MLz0SN4q2jGwH46PhWDuecZ9HIm/G3FBfxn/4yhbt+ByB/xwJ8xvyv6n5cHHhqVDseG96GOb8eZOnRNAC2ncuhZ1jjH5j09Y9g04R7mbT+B1JLpf/7Yx7BHDPBy/++w9jIjnRTe3LsjCPnC8pYciSNOb1CG93f1cZvcYc4kCMV9oryDub34TfR1TtIXu+YG8sAgyQwlXu3pccbh+WiMs1NOw8//J1cySorQaNScUeHfqjqmbpB4xUiR4HEqcNrTANwNeIYHkXk89srLUv5/k20wPZJla9lcnJy8PWtnOdZ4cqgd8chOOSlVbvuYFoselVRtesUFBQUWjJX/6NBBUCqVtotyAOAU5nFlBsru/PKz5+g9IyUFN6pVc8Gu78uZGBAa2Km/x/zh9yAyuAsL//XJ5Kp/W7l9h6zeCVmEys2/UCJnfOdXQrO5ZRy+6LDshh4Q3QI6+8dWKMYCFBychOiUQ+AW9TEOvv4J+k4jx75V57/oO9USlLC+XeLK5zpD+mRaJFyB5WbjcTkpVURAz20TowObs+PQ67j1Z7j6y0GAmQs/D/MOunm0nvkvTi36VvHFlY+PbFdTsI/Org9M1p1r/e2CpUJcfGQp/09Bdntcyy9iJjwa3HtMhoAQ1Y8CW8Ox5B7vtnHFOhufeqeXlSOSutI6L2/4T/jVbkKsrEgnbQf7yT+xV4UH5dcZX38wvljxFyOXfs4s1tb81EmFucxb9tCXjy09qqriCqKIi+uOVVJDHz1mnZsLNsmi4Fdi9JZeOA3OpovnVNy6dE0zmZLaSGu6RRQRaAyi2Y+sikk8mjXYRd1fJeaN3tPZP6Q63G0OKs3pcfRZ8XHHMyWhCTHoPY4tx0AQFn8XspTT9W4L61axWs2KR62n2t6aHW0byjHpz/BFwOupZ+zNSzUJAisSTvDMe0+6LQTwk7y0s5dLcaVWxelRj3PHLD+z34+4NpKYiBAm9O/ytP50bdeNDEQpBQfcyJ7AlBqNFTKy1sXZUmH5WuOo9oOlaqIKyhcDXw1aCbbJz1Q7at1qSIGKigoKFSH4hBsQUQFe7AvOR+jWeRUZjE9Qqw3eHmbv5WnvUfeYxdXjlqlYl77PizaYmD1+aMQkAhaPWZBxR7vVuzxbsWXCSfRJD5Pb79whgZGMjSwDaOC2+GmvXJs/WazyK0LD1FcLomsd/SL4NvZUahUtX+GxUdXy9NuUdfU2nZ7xjmu2/yLfAH/SOfhbNjtyL8nLXmEzGqe7TGK/xvVik9ObuPTE9spNuqJ9gmhn184/fwj6OcXQQdPv3q7CWwpOblJDntTewQ0yNmZXlbMK4fXSdsKKj7pP+2qdX1dDGwFwVRdAQ8Mac3G2GwAPt1+jqGjH+Ejz3boRZF2Jdl0+uE+Bo65n54R3ensGdAsOfqCbAXBwnI6+LshqFT4T3sBryHzyFz8rPz7KU8+StK7Y3GLnkzg9e/hGNKJLl5B/DnyFo7mpvLSof/km9zXj6xHLQi83HO83cd8KTCbRZ5adZL3N8fJyz6Z3pUUpxOcTJbc1P19Qvh86ye4mI1wiY4TURR5a8PZihme7edKyamt6DNjMWTGoXbzY3u7IbLIPyG0YxXRxJaSU1vJXPocxtxkeVn7DxKa8y1cFOa170tX7yCu3TCflNICkkryGfzv53w/+DpuatsLz8G3oIvbDUDBzl9qPW92CnDD10VLTqmBbfG5iKLY5POkl6Mz93cezP2dB3P0wAq+W/UB//i2JdFSrAa1GbwyOUsmAb8f4cZ20dzYpheDAlo16n/iauDDY1s5XyqFys9s1Z2hQW0qrTfpCml97m8AigQXijpNu9hDZG7bXnx6UnK7/Rp3UHZc10XFbxHgiKYjJrMiCCooKCgoKLR0FEGwBREVYi3icTS1UBYEzXqdXPlX5eSGx4Ab7drv0Eg/Vp8MgfxAbhyjYl/JCc4WZsvrjaLInqwk9mQl8f6xLTiqNYwNac+1Ed2ZEtFFDsG6XPl4Wzxb4yVHRwd/Vz69tmudYqAoirIgKGidcOk0vMa2MblpTF7/A2UWB8e1YdGs3ORCbLYkIDioVXx/XRQ395GqF7/cczwvRY/DKJrRNsABWBMmXSGpP9wpzwfe8D5qV+96b//6yc0UGyUX6AOdB9cqHCjUTahNzqPU0kKmdOlKuJcTycbzLCvbx7KYUnCUjpl0J3e2A98fXg+H16MWVLT38OO2iGie9B1ntzHZOgQziis7frW+EYTe+ys+Yx8i/Y/H0J3dAUDx4ZUUx6wl7H9/4tF7OgBRPiH8NfpWfjyzlzt2/AnAK4fXoRZUvBA91m7jvRScySrmjkVHZPeXIMDXM6Po2sbMI/9uAcBZreWnPhMRlz0uteHSCIJbls/ntlPfEmFKo7WYjsOH5SRe0ObN3nPBPRCAx7pWf/4STUay/n6F7H/ehBpSF1zp9PEL58DUR5i96Re2ZsRTZjIyd+vvrEo5SWePMEyh0fiUF+N/eDU9Rz9IgIsH3g7OVcQ+QRAYHOnDiuMZpBeVE59TSls/+xV8iOo9lXf9wvnfB9dwxAz/BHZhdWAXci0O3gKjjq9O7eKrU7uIcPXi9vb9eDpqlOyAbAmklRbydowUBq5VqXmnz6QqbQp2/ILWKIXJ/+04mkENLKxlD/r4hdPR05/TBVmsSz1DWmkhwTYPimpCF2sVBGM0HRRBUKHFkeDizpALishU0N07mK8GzbzII1JQUFC49LScKz0FooKtF4xHUgu52TJduPdPzKX5AHgMuNHu1X8Ht7a4EUQ1niWtODNzKucLsvj7u9vZpSthv1cYZ1z9ES03SOUmIyuTT7Iy+SSqnQJDAiKZ3qob0yO6Eul+eeV1OZFexLOW0D+VAD/P6YmLQ92HlT79DIbsBABcO49E5eBcbbuEolzG//cdBfoyAKJdW7F2oxeleumGJMDNgWW39q1SsEQQBLRC08VAgPQFD2DIipfG2mU0noPm1nvbXZkJLEyWqvv5O7nycrT9RKiWiq1D8HxJAWeKMnFqdwLKrO4rlSDg7+BMhk1VX5Aq+54qyOSpmP/w9fDkjg797TKmIHdrUYT0wupTADi37Ufr57ZRtH8pGYuexJB1DkwGzn81B82T63HpMFhue3uHfphEM3fvXALAi4fWohZUPNtjtF3GezExmsx8tDWeF9ecpswoiWIqAebfEM2MHgH0WP4holSTmXf6TKK9qxdnKja+BA7B85sXEPDX7Yyppc0JtwD2WsTATsYyhmmqnmv0Wec4//VN6GJ3ycs0nkEIV5D7u74EOLuzfsI9PL73Hz6zOLf+iD8krWxv85v9+30AunoF8nH/aYwJ6VBpP0MjfVlxPAOAbfG5dhUEAZxb9aTNC7vQvDee7rGbeDJuM3u8Ivg7sDvr/dqht3yPSSX5vHz4P47lp7Nw+FzUqpbhFnzh4BpKLCG1D3UeQlsPv0rrRVEkd8MX8vxCp2sYfAlEe0EQmNumNy8cWoNZFFl47nC9QvYrHIIlKlfi1WH4KSHDCi2IVrriGtcdrSHvoIKCgkJLQBEEWxDdbQTBisIiotFA7tqP5eXeI++xe799I7zQqgUMJpEtcTmIokiopz933/ENY1/qjTF2E4UaR85NfJa9YT34O+kYCcV5AJhFka0Z8WzNiOexvSvo4OHPmJD2jAlpz4igtng71pyjrzZEUWRrVgKBxqJGJ8I3mUXmLTxEueUm/+lR7RjQqn7OuaJDK+TpmsKFDWYTk9b/QJolb19rx2AO7w0Hy0V8/wgvlszrQ5hX9WJiUxFFkZzV71Ow8xcAVK7ehNw1v95hbOdLCrhzx2J5/q3eE/FybJ6xtiRsBcEH9/yNWlBVyhWp1Xmzbupchoe1Ij0nmQ3f3s7xohzOuPpx1iOIo25SkZH/7f6LcFcvxoV2rNJHQ7ENGf55fzIR3s5M7ByAVl1ZSBAEAY++s3CLnkL6gvvJ3/ojoqGMpI8mE/7QMlw7j5Tb3tVxACbRzH27lgHw3EHJUXuliYI3/naQxUesNxudAtz48foeDGztw4O7/yKuKAeAkUFt+V/nQZgKMqwbX2RB8PCRg5jn302FvFumcsIztCMOgW1xCGiHQ0BbtH6teGn33/I2c2M3E//cD/hNeRbfa54AQSB33adkL38Nc5mUs0nQOBBw3Tv4jH0I4SoVl7QqNZ8OmE5v31D+t/svWViqjuP5GYxd+y3fDJrF3R0HyMuHtLE+2Nl2Lodb+4XbfZwO/pG0fmEnKZ/PpvTUZgbnJTI4L5EylYYtvpGsaT2Qza7+6IElCUe5Q/yFr3tVzjerdvNBsIP7/HIhq6yYD45t4cez+wDwdXTh+R5VJfGSY+vQp54EYIc2mgRN2KWK6uemtj154dAaAH6NO1CnIGjMT5cfQp517ogoqBSHoEKL4r4k6did+tAPVdbV5BpUUFBQaAkogmALwtfVgRAPJ1ILyzieXkxp7G7S5t9DebJULc8psg/OrXvZvV9nrZr+Ed5sP5fLiYxivtmVyL2DWqP1DiHsoWUkvDkMD2M5/Q4uZs7MF/mw31SO5Kbyd9Ix/ko8VunJ3ZnCLM4UZvHlqZ2oBIE+vmGMCenA+NAODA1sUy+xKrE4l7t2/D975x0dRfX34Wd7eu+dBBJa6L33Ll1ABRRFFBVRLD9fe6+oKE1BFBBEEaT33nsNoaaQ3utmd7N13j82bIhJqKEI85yTk5079965szv1c79lGVvSrXY47zfpyYdNet10vKY5B5M4mmKNNdQ4wIUPet2YsGLMSyF3TXksqeoSihzKSeZsoVUc8FN4cPlEOAjWl7Bn24QwfUhDVFVY5tQEgslIxu8vUXhVbMmAp39B4RF0Q+33ZiUyfMdCsnRWQaCFVxDj6tx4EhKR6qnj4o0Eic2q7IoY6IwT6qRQjGpPXl+WxPbnA/HzDGbUK8tJ+W4A2ovWOI5TwzvxW0hL9GYT/Tf9zDfGQka5eKBwD0ThGYxDva7InW7OEjfCq1yYP5ZaxODfjuDjpGRsi2CGNfLHUSlDELCNWRCAnl/jlJ+F4cw6LNpCkr7uie+oqXj0mmw7F5+v2w6zIPDSwRWAVRTUW0y3dL7eCy5kl9jEQJlUwptdI3i/ZyR2ChkHs5OYeW4/AE5yFb92GIlUIqUk/pCtvdT+1jPN3iy5JXo2zPuEQYLVwnOpQ3+6vz6fZhFeleqmJV2EHKsTsYPZgGAsJeef9ynatxDBYrFZFAMo/aMInLgE+9Cmd2dH7jFP1mnJ0LBoLhTlkFuqIVtbxNk/3yTPYqFA6cDlWq05Vmq13P3y9PYKgqBSVn5MF+qMd2yMcmcvQt/aTunlY2Rt+5mcvYtxtOjonXOJ3jmXOOQWzHONhmKUylmQFMPlYyuZenatNa4lIPcIIuztPSi9w+7YGO8Gmdpipp7ZxewL+9Gayr/vD5v0qjR5ZdFryFj4gm15iZ31vn2d6CB3jFrOnrTyCuZwbgrH89IoNRmvGR/2asvGfRarZaqP04NnrVsV8bkatEYzY6ZXzDKslZlxUD44wrbI9dEYzHT413EAcNq+GEfxWBAREXlIEQXBh4woH0fUhbk8kz6Ly59uslmbIVPgO/KbO7bdj/tE0W221XXstTVn6VbHi0hvJxxqt8UuKJrSpBMYMi8imE1IZHKaeAbSxDOQD5v2JkGdx8qkM6xPPc/e7ET0ZbH0LILA4dwUDuem8PnpbTT1COT9Jj0ZFNKgSrHAIlj4+cJB3jyyzhbTDuDjk1vI1pUwo82QG3aNyi3R806Zq7BEAr+MaIxSfv22gsVC+i/jsJQFLXfrPB6lb0SVdY/mlruAZiZ6g8V6un4/qAGvdAqvsk1NYNYUkDrjUTRnt9nKfEZ8iUuLoddtKwgCs8/vZ/KhVZjKhKpwR3f+6PTEQxukvqbxd3BhSoNOfBtrjTvnY+fE/6K7MiSgOV1mHSQZHUdTihj462FWjGuJm70LIa9vIHPRyxTu/pVXEveQrXJinW89TBIpryo9uHx2D88mH0YCSJT2uHV6Bs8+U1B617qhMQW62vPLiMZ8tvUSiflWsSO7xMDUnfEVEmj8GweeYomvltpZO8BiJuuPV9ElHiFg3FykZda/L9ZrjyAITDq0ErCer0klBQwKaUArrxACHe+eaHazrIktt/b7ZkA9Xu1sPdeNFjMT9i+zCaRftuhHmLPVOqxga7mlgmubUXdlnCazhTELDvB+sVU0LpXa8+xH8wn0qSwGArzWsDPDdywE4IuGA2m9fw5uejWGrLjySlIZHt1fxOfRz5Hegzhr9xJnhR0tvMqt+4p6PkfaT09YFxL38tKAj9mRn0FiST5JJfmEOll/+7kHk21tBtT3vaNjlEgk2NdqQdj4Fqyt9TLb/5nL0NKtNDOdo3VhCt/FruX1+v3RyxTs8org6SYjmBWzAg+jDlN+KhkLJhLy2voKfcblavB1UuFsd38/WqZpivg6ZgdzLh60xeYFawzP1xp25oV67Sq1yfrrfxizrdeyDO9W7LS0AkB2DycmIl29OVz2nJCpU9uuIf/GVJxN/uZpAJSiZJmdNUnTx31u3zr8v4DWaEZjMFcqd1DKRBHoIcJBISNQG8+b51+otO6NyBaYSkUPFhERkYeT+/up7QGl24bZKLzckCJhcGhDPm7a+65YuwiCwADDHj4s+BIvodBWbh/RGv+nfsYupPEd23bX2l5M6RzOd7sS0BrMDP7tCKufbkVtL0eUAfUoTTqBYDJgyElE5VenQttwZ0+mNOzMlIad0ZmM7M++zNb0S2zNuMix3DTbS/WJ/DSGbJ9PY48A3mvcgyGhDW0iVII6j2f2LmVnZrk44W/nTJa+BIsg8NOFA+TqNSzq9PgNBVF/Z8N5CsosOJ5tHUKLYLcb+h4Kts20CW0K71r4PvZdtXWP5qaWL+iscR0/7h52R8VAQ1Ycyd8PwJBxAbCKQ4ETFuLScvh125aajLx4cAW/XjpsK+sXVJfp0X0Jd/W+Y2N+GPm6ZX8aefhjEQRG1GqMg1wJwJbn2tBhxj5ySgzsjM+j1bQ9rBzXkvp+zgQ8Mw+3LhPI3zSNqenn8UNgnm99AH4I70imypl3Lm1HZtBRsHUGBdtm4dLqUTz7voF9retnsXymdQjjWgazKyGPXw8ns+xUhi1mXnVoUTHYNJmXnIN4Tr0ICQLFB/7AkHaWoJf/sQmSL9XvgFIm5/n9yxEQWBB3lAVxRwGrC3VLr2BaeYXQ0iuYMCd33FT2uCntaySpzu2w+mym7fPQaH/b5+9jdxNTZvnc2juE56PaAqBPO2u7PqgCG+BQt8tdGefb688jO7sGV0EDWIXI6sRAgGFhjRgR1pill0+RI8CMYV/zxanlaGK3AtYwCL6PfYsqoJ6tTYlRT4FeZ1sOdnK7MztzH+La9nG0l/ZTsG0mGLQ0O7eVHb4NANiVmcDY2h6U6E0sPp5mrW8nZ2STgLs2vhe6NuSfi6MYE9eTWqZUPvA6zmD3IoIMeYyz86ZQIiPGxZ8xbZ9lzrn1BObEoYnZyC9zvrf1IQB1vtiOn7OK7RPbUs+3ZmMR1wS5pRo+OrmZORcOYrCUC0SOciUv1m3Haw0741NFDOWiQ39Zfzusidd2N/8E4ah1UlF2r0wEAX/7qzLOa4urFAQFk5HUmSOxlFrjp/1p15dsmScf9ork0cZ37xi71zgqZeyd1KFCWYd1J+/NYETuCQ2atKE01ZGqZHN7QY/Bcv97HYiIiIjcCURBsApyc3NZtGgRubm5DB06lGbNataN9lJxLsitD5NnCjNxUah4I7rrdVrdHobsBDIWvkCfmE22MrPShcDHvsK9y4S7Etfps7512XQhh9hMNeeySmjx/W4WP9GMVgH1y8eZfq6SIHg19nIF3QPq0D2gDl/Qj3y9lq3pF/nh7F72Z18G4FR+OsN3LKShmx/vNelBpk7N/x1bX8ElaFK9DrxWqzVHdTk8vmsxBouZZZdPU6DXsaL7kzgr7KoZARxNKWTuIaslh7u9gs/61r2h/dennyfrrzetCxIJAc8uuGYCl10Z1v3BLAW9A1/2r8f4xjee3fdmMGuLKNq3kJwVH2LWWLOgyt38CX5lNfa1Wly3fZqmiKHb59usFQDebdyDj5r2oiC/4I6M+WFGKpEytnbl3yXS24lNz7ahz9yDZJcYuJSrofWPe1j4WFOGRPvjENEahxeWkJeXxy+enkTH7OTVo2sRgL8Cm1AU3ITPD/2KSlMAgoXiQ39RfOgvHOp3w6vfmzg2vLarrlQqoWttL7rW9mLGECN/nUwnpixe6ZV2V5qbzAJ/nkwjX2tkuupRTkpqMbXkW5wsGkqTT5L4QQuCX1mFQ2QHikuN1FfU4QnfbizJ2omZ8pf5dG0xq5JjWZUcW2k8jnIlLnIVHnYO+Ng5MbFuOx6tdecmPq4mt0TPvrKMwo0DXAj1sFo8Jqrz+PDEZgDkEilz2g23WSbnX2Ud6N7jpbsyUfTXiTS+2RnPb/ottrKAHs9ft92MtkPYnhFHrl7DkvQ4Ro78nh66fCRyJQ61y91g07VFfHJyK/MuHcZ4lQgjjJtasztyn+P3+HeUXj6GLv4gzdNOQZkguDMznrG1W/DniTTUequ12pjmQTeUnKqmkEolzB/VhOipu0gsDeKpwiDWD29Fj3BPZl5KYNKJJeSb1FyWKugfOZhFpb/TUJ1F1IFP2EC3Cmk1MtV6ev18kH2T2hPifmsxfmsao8XMzHP7+OjkFgoN5aK0s0LFpHodeLVBJ7zsKluxCoJA/sbvyPrrDVuZ72PfU1gYACQC91YQvDqebLquqMo6mYsnoz2/E4AMqRdzHR7lsaaBvN8rssr6IiIPKv5Pza52neHHZ+7iSERERETuL0RB8F8cPHiQgQMHEh4eTk5ODl999RWbNm2iW7duNbYNd6UDMpUjeXotAgL/O7qe+m6+9A+uf/3Gt4CpMJPEj1tjVufaytYrO2Ie8AX/69b+Gi1rFjuFjLXPtGLQr0c4nVFMUamJR349zJy6rlxx0NFnnMOZgZXaGnIS0aecRuEZitK/LlKlVbDzUDkwolYTHg1rzPaMOD46uZk9WdYH9TOFmYzcuahCP7Wdvfi1wwg6+oWTl5fHsLBGbFDaM2jbfEpMerZlXKLrhp/Y0Gs83nZOlcZhsQi89E+MzdP6s3518bqBODyC2UTanLEIRmu2YM++r+MY1bHa+hdyC0nVWcUESp35oFcU/+tWm7y8vOtu62YoTT1DwdaZFO7/HUGvsZXbhTQh+NU1tpiBmdpiViafochQisFixmgxV/j/9+XTtniBTnIVCzqOYmhYdI2OVeTGaBrkyrFXOzFswVEOJxdSojczdP5R3u1Rh496RyG96gV2cnQXgpw9eGL3H+jNJjZaIK/3u/wqNaLc+iOmwnQAtGe3k3x2O+49XsJ/zPQbGoervYIJbUOvWefTvlF8tvUS0/deZo+yBY+6fsv04s+obU7BrMnn0hfd+d73DRYYr8qGLGsN9sVgrwYHtfW/vOp4axqTAY3JQEapmliy2JEZz486NZPqd6iyfk2y7lw2V2L2D2rgB1gFhokH/kFnto73tYadaeRhtdIxa4so3Gd1w5U6uOJ2E9m8b5WYjGKeXnqKEHM6rYzWbOCqoGjswq8f79PbzomZbYfYrrHPH1hO7JA38Chz9S7Qa/k6Zic/nN1j29+HGYlcSdCk5SRP7UP9tFjszQZ0MiU7Ek5gbvso0/Yk2upe77y5E4S4O/Dj4IY89edJAIbMP4rBbLHe6+QNIPQM2JdgVAiMbvIYE5IPMi7lKFIEhDJJMMrbkQs5GlKLSun180H2vtT+hu6Pd5L1KeeYcmQ1F4pybGUqiYLHQ1rzddueeNlX7c4uWMxkLn6lggu/e7eJuHV+BvOKM7Yy2T00KqogCGqLK63P3zaLgu1WEUSHkkku7xAVFsK8kY3/EzFYRURERERERO48oiB4FSUlJQwdOpQZM2YwYsQITCYTPXr0YMqUKZw8efKm+ysuLqa4uPwhLSPD6iJ2eshrBAUF8U3MDt48ug4Bgcd2LebQgJep51bzcYOy/3mvXAz0rMUE45PsUzbjiZK7Hy8jzMOB/ZPaM+Hv0/xxIg1BgC9ipKwpW68vy+AH1gdy9Yk1FOz4Cc1Vlo1IpCh9wlEFNrD+BdTHLrwV3QPq0M2/Njsz4/n45JYK7sESJExp0ImPm/W2uVdeoVtAHXb2nUjfLXPJKdVwLC+VDutmsrHXeGo5lydXEASBjzZf5FByIQBNAlyY0Ob6L26CxUzWktcoTbRmMFQFNcR7yMfV1jeZLYz4eydXUn1GOPryQQ3O5gsmI+rjK8nfNhPt+V2V1ru0eYyAcXOQ2jmRV6rh65gdTD+374Ze6uu4eLGy+1PUd/OrsfHeCao7Nx8Ugtzs2fVCO178J4ZfD1utNj/deonjaUUsfqKixfOwsEb42DkxcNtvFBp0HMlPp5e9C/+8tZu68XvJW/8N+jSr9V3B1hk4NxuMU4OayfTr7qBk6sAGvNA+jP9bd56lp+Axt6l8pf6WbobDKCwG3sz4DLnDk8yzH2o1LzQroMTT+geAAAp9mUhYYhUHpSaQmXB1lOBoZ0EnGCgoswx6+dBKLILA5AbVC/I1werYcnfhgQ18KTLoePHACjalWd3xazl58H6TnrY6uWs+s4nybh3GIa1iQqImydcaGPzbEbQGM8NKy60D3bs8e8NiwaNhjVkaeorlSTFk6tS8emgVs9sN48eze/kqZkcFayw3pT19g+peN+bag3xuKtwDqPXeftLmPkXTonT2e4Rx2Wxi7Q9juZgxFCQKutX2Itrf5fqd3QHGtghi5ZlMVp7JRH+1u79JBYmNkYSeRXAswCiTMbNWe/7xj6bVjjxkZpAA+1/uQMcZ+zibVcKFHA39fjnMtufb3nJMQY1Rz6GcZLJKS8gpLSGnVENOaQnZuhJy9Bp0JiNBjq6EOXkQ5uROmJMHUa7e1HX14XxRNlMOr2Zj2fkGWP2a8wPQZ4fxW4yM9bv3MaiBL4Mb+tEz0ht5WVZ0i15D6uzHKTmx2tbUZ8RXePZ7A4lEgumq7Lzye2ohWB4/NUOrrrBOc3Y7mYteti2/4/wKas8GbB/XEnuFGDdPRERERERExIooCF7FokWL6N27NyNGjABALpczZcoUBg8ejF6vR6W6uZnu7777jo8++qhSeUFBAfb29ozzj+ZI0GX+To1FbdQzYPMvbO/8NBZtaY3sD4ApJ57C3fMAkDi44zZ5E4dnXACLQGxGYY1bnN1ofz/0CaGBp4L3t10mWeaPERkKzBQmnMIuLw9TbiLFiydiTDpaubFgwZAVhyErDvXxVbZi1zFzsWs6hEZKd5a1GsH+vGRmxB1CYzLwbr3OtPQIQlek5sor6tUvnWESe9a2G82jB/8kWVvExeIcGqz4hseCG/FseAt85a68uj6eVefL9++z7iEUFuRfcz/1F3dTsvp9TOllFgUyBY4jp1Og1gCaKttM2nKC0+YY2/JL0XXIz8+vNOZbwZgWQ+GvY7EUpFQol9i5YN/qMezbjUPuU5sCjR6DWkub7T+TrK3aFenf9PGrw8ymA3A1KyocB7c75tvB07PqbLnVnZtqtbrGz4l7yVfdg6jrruDtLYmYLALrz2UT/fV2Jrf0ZnAjI+721qyU9RWurG8/micO/U2itpAMXTFdNs9hSesRdJyyE93eX1Cv+D8A0uY/j+eb+2s0zIArMKt/GOMae/L+tstMTv0//qeZx+jStQBM0S6gn2smmV0+pl6wL54OCkwWwfpnFjAJ1s8phXq+3pPC2RxrYpMiQCuVMG9oFBcl5/n0nFUAf+XwKnLVhUyu3faWLGWqO0YEQSC1WM/epGL+ibEKgr7OMtal72P67kPkGrS2ul817ImuSI3WYkaz8Us0W8visUnlSFo8cdPH4c2cZwn5Op5ffYmEPC1ulmIeNW63rpCrMEf1valtfxLVlR0ZceQbdCyMP8bC+GMV1tvL5Eyo1ZJJtVvjprz+JNT17ps3y728/lSH/ajZtN/4DfvLRLefDYXM1rzLR/av8ELL+tV+/3djX77oHkRCrpr4PB31fRxp7OdIIz9HGvs7Eebelu8u7WN2wmEMFjMZdi6UKotw1JkwSyVYtMX8NSKKfgvPkFKk50hKIV1m7mH+0CgCXMqfn663HyUmA/MSjzEz/hD5V4nKVXEsL/Wa68s7dYOMCNCXC+1Zaj1zDiYz52Aywa4qXmgVwKgQPYZF4zClld2DZUpcH5+JpOkQ8vPzuZirZW98ubWhVqO5J/cMQRDYm3zRtpxYkE1eXh6CIFB67G/U//wPylz0Z9uPZI9TJ9YOi0Rh1JCXV/Wzx5Xfpbr75n+V2SH1SLJ34ut1MyqUny7IoJG7fzWtREREREREHg5EQfAqkpOTmTBhQoWyOnXqIAgCGo3mpgXBKVOmMH78eNtyRkYGrVq1wt3d3fbAtbDraJI2zOJwbgoJmgK+StjPJ5FdauyBTJt3jrwy/1aFizc+Pn74OF8mraiUIr1Q4w9+N9Pf2329aB/pz4iFx0goDCbKfBlL+mkub5qNw84vK7iwKv2jcGn5KKaiLPRpsejTY22Zeq+gUKdW2P4jnp48Etn0hsfr6enJAe+X6b1pLmcKM9GZTfx6+Ti/Xj6Og94bbYYf4I5EIuGbAfXp16T6DKzWeIFvUHJybXmhVIb/mBm4N+pSZZv44lzGbF3BAe0FKPNikgBD6jbG06k8DPKt/mam4mwSfqsoBqqCG+HR/UVc2z1RKRNooV5Hmq7c6mBMRHNG1WqCUiZDKZWhkMpQSuUopTLclPbXTBJwv71gVHduOjs733djvV3e6OVF29p+DF94jCy1ntRiA29sS+OtHem0D3NnQH1fBtT3pU1oJEf9pzBy5+9sTb+E3mJmzJHlbOvzHK0G/Y+kc5vQnt+JOTsO+9xYHOt1qfGx9vH0pHejUPYl5pNb0gpF3CKMq98CQaBuxiait8URNHEJ9rWqd2kd3bYOfxxP5d2NF0gu0GG0CIxfcZE1z7Tmy+aOvHXMmhn103O7KJFY+LbVIzedAdvT09Mq/hWWcjS1kGOpRRxNsf7P1RislSRm8MhAHZDOB2fLRQ0PlQO/tH+UIaHRmIpzSJv9eIWM3v5PzsY96vpxO6sb17UQBIE5B5N4bfVZNAYzcsHETO3XuJqscT5dW43AO6T2zW0TT2a0HcrjuxZXKJdLpDwb1Zr3GvfE3+HGLd5u5L55s9yP5/SY/q/y7apvsQAbfOtywCOUFxN+IrrIAU/P6t3F7/S+eHrCqTeqF0mm+Q1jUuPOvH54DStTyuN2lqpkDDj4B8/UacX7w7x5c0U8BcVSjqer6T4/hj9HN6dbnfJENVXth8aoZ+b5/XwTs5NcfdWi1RUkSFDKZOivyhJcFVKjPZb0cFB74utsx4ROIdT1cWLVmSzWn8+iRG8VzVKK9Kxct5KO6q9xF6z3Pb3ChfgB8wis3Q1fVHy3K4GfDiRhLrMQlEsl1PK99ePyVjmRl8akQyvYVxY3GcDLyQVXhZmM355DfXylrXyLsg0zHR5j3tBoujYIuW7f9+O5ciNMXHbaFq/23+TYOZLi4FwpmUQjd3+iRUFQREREROQhRxQEr+KTTz5B+i+rF0dHq0giCOUuIjExMURHXz8+mouLCy4u134RspMrWNp1DNErv0Vt1DP7/AG6uYUwvIYeyuzrtMchsiPai3swZF7kwkQ3ZinCOCaNJEcZjT49AKVf1F1JKlIVnSO8OPpKJ+Z91omonMvIsGC/6T2ufNtK/3r4jZmOY/1uFSx5BEHAVJhB6oxH0cXtB8CpYa/bHk+Agyt7+r3Ip6e2MvfiIYrLYv5pVTkQloPM4MgLUe2Y0D6wyvYmdS45Kz6kYMdPttl5APvabfEb/WOFBB0WwUKWroREdT6LEo4x58IhzIKFKxHavRUuzOk4lFCnfz/G3jyC2UTqzJGY8q1ioCqkMX6jp+MQ2aFaCyk3lT1vNOzClzFW66FzRVn0DIy855lba4IbOTcfJDqEe3L81U48+/cp1p/LBsBsEdidkM/uhHzeXHuOcE8HBtT3ZU7HJ3jr9AqWXj6FxmSg7+Zf2N3vBUJ6lQenL9q/6I4IgmBNPtIhvOz61+hN1OH1SZ/zJGZNPsbseBI/bYf3oPdx7/4CcqfK10mZVMKYFsGMaBLAi8vPMO9wMgazhcG/HeHXkU2Y2kLO60etroDTzu4hp1TDrx1GoLyB7OJXiM1U8/RfJzlcFj7AigByAzhprHENPdJBYUBbdjGTSiSMiWjO5837EuDgijbuIKkzH8WUX2bhJFPgP2Y67l3G/3tzNUJGcSnjl5b//gBfWhbQpPQ0AHKPIHxHfXNLfY+q1YRNaRdsmZ9beAXxR6cnqHML2cUflnMz2sOfhZ0eZ9L+ZRSYDBQq7PksqhtrYtYzIK0QlV8vdEYzOqMZrdGMIMCgOi4MuA8EmwgXL1b0GMeaXfP5aUuSrfxQTjKHcqwJtwgs+7NIyDEp6b75ICH73Alx9CBY5UTLgGBa+vnT0tcHE2Zmnz/A12d2kFNaLgTKJVJGRzSjpVcw3nZOeNs52v57qByQSaTk6jVcVudzuaSAxJJ8dmTEsSX9EmbBQhvHhhw87A6ClMeaBjJ/VBOUcuuzzuPNgig1mtl2KZd5h5JwPPILb2jmIcdqtRkvC2aS09sk7VHBnn2VvoNwTwdmDY3G1e7u3A8tgoVdmQn8dukIixOOY7nqmXSETygvnd9M3PynsJSWT+JdqDWMt4pHIUikNPR7sM+pmIxiTmeoaeRfOVGbTCIhvLSEvf1fugcjExERERERub8RBcGrkMkqP9hdEUvMZqu4M23aNGbNmsWpU6duyX2pKkKdPJjWahDP7FsKwMsn19MjvCFuqtvvXyKR4PfkLBI/bIFg1INgobYhgdokQPpG4v/vG6QOrjjW7YrvqG9Q+t6cdUhNEOxuz8Tnp5D3ycIK5YvsBvCn3XNMyAzh2TAjno7lsf8kEgkyBzdKk08CIHcLwD6iDTWBm8qeDxv3JfWSD3+lnwDPNFBZLXzMSg3TE7fwU9J2OvrWok9gFL0DIonITUR9ZCmF+xZWsFyUedeidNCHXAxpyl9FOVzev4zEspeXJE1B1dYNRiXdXJuxYfjgmxIprkXWX2/axBy5RzChb2xB7nL9l/UPm/Zifeo5ThdkcDQ3lc9PbeODprcvvIrcfQJc7Vj7TCsOJxfy19FEtiWqOX2VRUVCnpYf9yTy96l0jr06jGJjKRvTLlBg0NFr01z29J6AzNEDsyaf4iN/4zdmOtIbcAG9XZybDCD801Ok/fQE2gu7wWwi55/3yV3zGS4thuPW9bkqhW2VXMbPjzaiUKNleWwuOqOFxxYdx0klo01UW45YDmHGwuKE4+TqNfzZefQNX3Obf78bvUQDbkVgpwG7Euv/KpKbSJDwRERT3mvck0hXb2vm0q0zyfzjVSiLyyn3CCb4pWXYR7S6/S+sCpadSuf5ZafJ05aP76egI3Q8aQ25IFHaEzx5FXLXW4thK5FI+KntMOq4eKGQyphUrwP2ckWNjP1B5omIZvQKjGTyvhUsST4FwGnXAE6bL+N4ZjGanAZgKD8mlxyXcibUlzCP+yN774AOo1nw4yoEpMgslqorSQVQ6kGpJ1lQk1ySDCWwJA+IAQQJEkGKIC2fQJNJpDxZuwXvNO5OuPO1BVCrQOhES2+r9dub0V3JK9VwuaiYrj+cBMGEUibly/51bWLgFewUMvrWcaPpgXco1Myzle+wb8eb9i+jlVb+nl3s5LzXI5JJHcNQyWV33F34bGEmv8cdZ3HCcVI0hRXW1VcoeTf5II13fsvV377czR//p+exICWU0h3WWMpXC4gPKo38ndk7qXLCqBY/LayitoiIiIiIiAiIguB1uWIxKAgC06ZNY+bMmezYsaPGxMArjKvTkhXJMaxNOUdGqZqXD61kYafHaqRvu6CG1PrgCIW75qKNO4g68QQKyoUoi7YI9fGVaM5uxW/MTFzbj7nrGeh8azdGU7s9pXH7KJB78j+HSexTNgO1wP+tP8/HWy4yunkQo5sF0b6WBzKphJKYjQhlMbmcWwy9KStHk9nC2vN5pJfmo9abKNGbUetN1r9SE+dzSkgu0AGBkB/A0HYq1I5JbMmwxuwxWsxsz4hje0Ycb7IOH72a9vlJtHIOoNAjgkuuAVz2b8gFJGjiTkPc6esPyiyDnBB6eDVmw/B2tgDnt0vR/sXkb7LGJ5MoVAS/vOKGxEAAlUzO750eo8WaHzBazHx9ZgdvRHeplJhF5L+BRCKhdag7tZ0sfDfMk+QCLevOZbMmNovtcbnoTRYyivW8vvo8y0c9Se/Nc9mblUiGrpieW39lacuROOycjUVXTMnJtbi0evSujFvhEUToW9vJXfUpOas/AYsZwain6MBiig4sRhVQH7euz+HWfgwyR3dbO5lUwowBtUGmYPlpa3KKEr2Zg6eV4NQAQmJBamFT2gV8//yQ7v51GBzakIHB9fGrxs3VIJeiDz0M9td3aRxZqzHvN+lJPTdfBIsFbdwB8jdNo/jwUls9xwY9CZz4B3Jnr2v0dmsU6YxMWnGG34+Vx1kLcrXj976e+P78qM0SO2D8fOzDmlXdyQ1iJ1fwTuMet9XHw4i3nRN/dB+DbEUg29P+Jr3MK0HjrgHXI5AfADmhYFagMVp47u/TbJzQ+r7IEiuRybli0m6vN7HGzY3sBr1I1xaTriuy/tcWc7EgnyKTFiRViFISAUFiFQOlSBhbuznvNu5BhMutnw+edo58vvkyar31OWdiu1BC3CuLe6aiLFJ+HGrzMgDwHvoJEx95m2ElBs5nl9j+EvK01PN14vUuEXjf4czJ+XotC+OO8nv8MY7npVVa7y5YmJi4j5EpR5BfJfRJHVxxa/8k3oM/QObkgTS1PEnbwyAIioiIiIiIiNw8oiB4Ha48dE+bNo1ly5axY8cOgoKC7sh25rR7lIYrp5Kv1/J7/DGGhDZkSOj1XZNvBLvgaPxG/wiA4+v/UMcQz0CXFCYEZKO9sBtTYQaW0hLS5z5JScxG/J+cjeyqDHZ3g5BXV6E9v5vIul34Okfghz2JLI/JwGwR0BktzD2YzNyDyXg7KRnc0I9nExZfCbWHS4thN7QNs0Xgr5NpfLT5Ihdzrv1CD+Bmr2D+qCYMqKXCkOnOKaWU+Wnn2VpSTLxduWCQrXJmhX9DVvg3LG9sqj4rr4fKgTAnd0Id3YlJNhCXJkCxN3U93Vk2unWNiYG6pBOk//asbdn/qTnY12p+U3008gjg2cjWzDq/H63JyOa0iwwObXj9hiL3PSHuDkxsF8bEdmFkqfU0/GYnuRoDf5xI49HG/qzp/jRdN87mZH46iSX5dJI6M6x2F55OPorT/kV3TRAEkEhleA/5ANcOT1K4ay4Fu+dhLsoCQJ9+lqzFk8n++y2cGvXDsX53HBt0R+lbB4VMyt9jm7P1Yi7LYzJYEZNBdokBSjwgsTGExoDchMFiZkPaeTakned5oI13KINCGtDA0ZVZZ88j2MlwKDVjVEirFAODHd1o7OFPY/cAGnsE0Mo7mBAHN3QJh8hc/xXFR/4udw8uw2vgu3gP+RDJHXDDP55ayPAFx0jML09kMrp5INOHRKNZ+DRFRj0Ann1fx7X1iBrfvsjN8dvALmyNDefQmheY7RlMlsrZal3nlYaLfx7y3DDyU73ZfDGHBUdSeapV8L0eMgAC5cJk1P759B/0dpWTcxq9kcOZWRzJyuBYeiqphhJStYXkmYrQmEtB44osL4xnu3QnwuX2wmSkFOj4Ze8FQIGjUsbb3etUqqO7fJyUHwbZzkmJypHA5xbh0nwwAH4udvi52NGlds0L9ddiX1Yiw3csJPOq+L0ASqmMHhY9fc6so2NeIkqh3KLSIbIjbl2exaXl8ApW21cnQLY84Hrg40lTCdIlkPhp5YkcwTkMier+sKoVERERERG533joBEGLxVIpTuC1uOJGfCfFwCv4O7gwu+1QRu5cBMBjuxYzs80Qnq7TqsasASwWAa2g4JSiLu4B7fn4hXZYDDqy/nydgm2zACg+uARd3H4Cn1uMQ2T7GtnujSB38sSlxRAA2jlBu1oepBTomLnvMnMOJlGgswpsOSUG5h+I55n8jQBoFO6s1YYTnakmwssBlbzyy7XRbGFFTCYfbb7A2aySasfgYSmkjfEUIZYsWjvk0UaWj+SneC6ocwFwAV4u+0tXObPPI4x9nhEc9KyF+l+JCWQSKVGu3jR086Ohu/UvwtmTUCd3XJX2CILA5JWxrDiTCIC7vYLVT7fE1b5mXO1MJXmk/jgUoSxLo0fPSbh1GHtLfQ0LjWbWeasVxcrkM6Ig+ADi66xi1rBoRiy0Zol9fnkMsW90YVOvZ+m0YRYXinLQWcwsCmrOXwGNGZJ1js8z44nwi7ir41R6h+Ez/DO8B3+A+sRqCnb8jCZ2KwCCQYf66HLUR5cDVldceUQH5M360735EHpGNWLm0Gj2JeazPCaDf05nkBrf3BoWwCUXlNaYoQJwICeJAznl8dF6X3UNlgIdfMN5JLg+LbyCaOQRgIfKAbNOjTEvGWNeEpoDC7hUhQgIIHP0IGDCApybDLgj39GcA0m8vPIM+rIsth4OCn4e3ojhjQPQXT5O+n7rPUbm6ov34A/uyBhEbg65TEqfRmF0D5nH4I/b8qujH7+EtEIrV1pj2bqeB4dEyAnilTVSetf1xt/F7l4PuwLG7Hg057bj1KCypaijSkHX0CC6hgaRlxdeIXnFlFWxfL87ASMweP4RjkzuSOgtuEULgoD62ApS5k3mgDaVZKkf5pDWKI6mUFq7HarA+kikMooOLSX9l6ds90aFVxjBr6zGLrhmJmBvlZ/O7+flQ6swXhV/uL1PGMNlAu02TcUpP9lWLnPyxLXDk7h3Ho8qoF6V/UmvumY96BaCQboEArXxQOVEchKVQ6WkaSIiIiIiIiJWHipBcN++fTz//POsXbuW0NDQa9a9Ihx6eXnx4osv8tZbb91RMfAKI2o1YVncCf5OjUVvNjF+39+sSo5lZpuh18zieqMYr4rzIy+bPpYq7fEfOxOnhr1Jn/c05pI8jLlJXP6iM74jv8Gj9yv3zD0p2N2eLwfU4/1eddhwPpt/Tmey9lwWDYpP4CxYLV9ihUCeXnwCQSJFKoEwDweivJ2I9HYkyseJuFwNi46lWq2CrqJ7uBuTOtfBU2HCJXErylN/YTm/pTwZiAYsOdUMTKYgsm4nWrQeybvNBmFROXIwO4nDucn42bsQ7e5HlKsPqmvEAPx2ZwLT91rFQIVMwvKnWlDH2+m2vzMAi6GU1OnDMOZeBqwWBL6jvr3l/jr6heOutKfAoGNtytkaGaPI/cejjQN4tHE6f5/KIEut54NNF5gxNJoD/SfxzZmdzDi3D7VRj1EqZ6l/NKs2zGZKo278X6NuOCvurjghkStxaTkcl5bDMWTFUbBzDkX7fsdUlGmrY8pPwZS/hLQjS5A6uuNQux1ytwDquvnzgasfH/fz42KpGzsuS8k6k4hCF0ueq5EDXsHEOvtV3F6Zg62dwcSufbPw8wjEIaoTpuJsCvKSyc5LxqItrH68CjucGvXFpeWjODUZgMy+cvD7mmD1mUyeW1YeoqBTuAdLRjcnwNX6++T8855tnc+Qj5Da1cw1R6RmULj5Ezl5Bc9/2oGhmTHMCmvHsoDG1hhxCj0ExFNUmkHX+Sa2ju1FkNudj+N5M2QteQ3FxCWoAuvfcJtvHqnPhZwS1p/LJqfEwCO/HmbfSx1wtrvxR1R9+jkyF72MJnYrbmVlIZZMuLyKjPnWWJlSOyckMiVmTb6tnUPdzgS9tOyOuOzfDJ+f2sY7xzfYlvsG1mVG2yE4b59FztL3beVSexd8hn+OW+fxSBXVuy6bzJYKMWIfdEEQIM0hgubv7q1Ubrduxj0YjYiIiIiIyH+Dh0oQfO655yguLqZLly7s3LmzWlGwsLCQ3r178+abbzJs2DBmzLi7DxM/NulPqJsXU8/sAmBNyll2ZMTzZYt+TKzbFqnk1t1JFVIpHg4K8rVGDiYXUKI34aSyHgbOzQYSXus06XPGojm7DSxmspZMQZdwmMDnfi+LF3RvcFDKGdYogGGNAtCbzOzbYQKrkQutTGeYUfwZb7i8jhZ7EvK0JORp2XC+6r661fbi4z5RRBQcxXLoXYqP/I1FV0yVIdElUhReYSj9IlH51UHpa/2zj2hdMVYZVtGso1/4De3P0pPpvLG2XFhb+FhTutaQa5JgNpE+Zyza89bjR+4eSNBLfyO5jSD/UiS27MLmh+DF4mFm5tBoNpzPpkRvZu3ZLGYMjcZd5cDnzfvxRsMufH94NT+c20uxwg498MXp7cy/dJQ3o7vwTGSruy4MAih9a+M78mt8RnyFPi0WTexWNGe3oT2/y5Z106IpoOTUukptHYEKdnqF8GqS1QJ4q1cdTjmE0bI4hbO6QASkyM0WPIw6DFlxGLLirjmuuyUCXk1MZrkI8HzbUKYPaWgLQWAszKDktNWyWulbG7dOz9zx8YjcPPahTQl8bhHC9KF8cHErY3IvMb/P2/yTftEqS9tpuaDaQ935qawb+Cidw33u9ZBt6FNOE/92A+zCmuPafiyubUYhd7n2+GRSCUtGN6Pd9H3EZqqJyVDzxOLjrBjXEpn02pORZm0ROSs/In/rdLgqSdcFWSgRkhzkpnKXeUtpRe8A967P4zf6x9u6N9YEs8/vryAGvtOoOx817U3xrrlk/FMuBrq0HoXf498jd/OrqhsbJXoTI38/ZssoLpNKCHETXWZFREREREREKlMzgcr+A+zatQs3NzcOHz6MSqWiS5cuJCUlVVnXwcEBX19f3n33XYzG6uPA3SkUUhnftHyE9T2fIdjRDYASk56XDq6g4/pZnC3MvHYH10AqlfBEM6ulY4nezJ8nKgasVrgHEPLGZryHfgxlVoHFh/6kYOecW95mTaOSy+jW8xH8xs6CMpGyi/EIvyvm0S7UDU+Hyg/39gopo5sHsuuFdmyb2Ja6l34n/4feFO6eh0VX/gKt8A7Ha9B7BE9ZR8QX56j3i446U+MJfX0DfqN/xKPnJJwa9akgBt4sexPyGLvkhG35mwH1GdU08Jb7uxpDbhKXP+9M8ZG/Aas1QciUdbecPfQKh3OTyS57meoTGHXb4xS5f/F2UtGxltWdL6lAR9JVMejcVQ583HEUx10cmHj5AKqyLLkZumJePbya4KWf8tbRdaRpiqrs+04jkUiwC2qIZ+9XCHl1DVEz83CftB63Ts8guUGXMZmLDy6tRtBg+Je0HbiAru2+4vl3diOU3S4FJDg17me79gBIlA4oA+rh2LAXbp3H4z30Y4JeXErk9GyCX/4H17aP3RUxECq6CQ5u6FchHmnxwT9BsE59uHYcd08neUSujUuLIbh1mQBAeH4S359fz54u42nqXhY7UAIa10S6bprJh7uO3cORWhGQILUrP8ZLLx8ja/FkLk4OIPn7Ryg6tBRTcTZCNRNKLnbWkBlejtaEVWvOZvH2+nNV1gUQLBYKdv9K3P8irUmzysTAy9IAnnd5nyPDN9Dgp0JqfXQMv9HTcW37BArvsgk7mQK/MTPwf2r2PRcDlySc4MUDK2zL01sP5tPmfdEcX0nGghds5X5jZhD0wpLrioGZxaV0nrXfJgaq5FL+GtOMWp6iICgiIiIiIiJSmYfmbSA1NZVJkybh5+fHzp076dKlS7WWgkqlkmXLlpGfn49Cce8eFvsG1SN2yOu8e2wj08/tQ0Bgf/ZlGq/8jggXT9yVDrgp7XBXlf1XOuCsUGERBCyCgFmwYBYsZZ8FHOQKWnoFM7K5t81Vde6hZMa3qbj/EqkU70HvYRfWnJTv+gOQu/ZL3DuPR3IfZZf16D4RVWADUn8cglmTT93Mzax75AncOowlT2PgYk4JF7I12Cmk9Kvng4ud9bfM2/wDWYtfsfUjdXDDtfVIXNuNwb5OuzvqHn0hu4RBvx2xxfZ6sX0Yr3W5MavC61F89B/S5z1jc1u8klHYLqTxbfe9KjnW9nlgSIPb7k/k/qZTuAcbzltfKHcn5DHmX/G8ag39mCkfNGPo4d/4PrwjG3zrIQBFhlK+itnBd7G7eTy8Ka816Ey0h/892AMrErkCZa1WeLboi//Tc7FoCzEVZmAszMBclImxMANTUSYWXRF2IU1wrNcVZUA92zVgUNW9EjJlHWZNAcaCNBRuAUgd3e+LrK9w7bhhRQcW2z67tnm8xrd9sSiHVE0h9dx88bN3vm++k/8qviO/puTUOkwFaaiPryK0fj+ODJzEF6d28sGJjVgkFgQ7DR/FL2F5ynH+GTCUOm6e1+/4jiChzndJFB9eSuG+39Fd2mcttpgpObmWkpNrrbUUKqSuAai9w1B4BKPwDEHhGYJjw16Ee4Xyz1Mt6P7TAYxmga93xFPPx7lCAhVBENDEbCJ72TuUJh23lWsk9vxkP4JlrkOYO6olI5oEAGAf1syaQbvnSwCYiq1xQOQu3nfjS7km61POMXb3EoSycAQfNe3FS/U7oDm/i7SfHreJ916D3sejx4vX7e9sppp+vxwiqcAaG9HTQcHqp1vRrtbtJWkREREREREReXB5aATBJ554wvb5WqJgdnY2Pj4+KJVK/PyuPRN7N3BW2PFDm8E8Ft6U8fuWEluYhUmwcKGouuB2N4Z9PWd0RY4cVrvwz0V/BtcJr+SK7Ny4H84thqE+uhxTfgqFexfi3mX8bW23pnGs24mACQtI+f4RADJ/fxGHyA54+oTT1tGDtmEVH4TzNk0j649XbcveQz/Gs9+b14zFU1Nkq/X0++UQ+VqrVdUj9X35YXDD235pthh0ZC15jYLts21lSt86BL7wp/VF6DaxCBb+vmyNSSaXSEULwYeAzhHlosKu+HzGtKiY0VSqtCNg/G8YPmnHN+fWMyn1GCuHfM7CtEvozEaMFjML4o6yIO4ovQIiebpOKwaGNMD+HlrjSCQSZI7uyBzdbyq+WXVc6et+4+qrydVyoD7jAqWXrZZk9nXao/QOq7Ftlhj1vHp4Nb9cPGQr81A5UN/Nl4ZufjRw86WBux9eV1lp3kuh+L+CzMEV/ydnkzJtIADFi59HmnSQ/w3/jCFhDei5dj4ZphyQwBnjBSL/+ZKhQU2Y2rYPtZzvvjAoc3THvetzuHd9DkNWHIX7F1G073eMOQm2OoJRjzk3EW1uYsXGEinOTQfStMdL/DQ0mmf+tt5zJiw7xYWcEsI87IkoPoX//q+RXN5foekqVVe+dxiLk3cwe8a1pFFA5UyzV7jXQmCpyUhMQQaHcpJ58+g6TGWi3+T6HXmvcc/yhCdlWcDduz6H95APr9tvSoGOjjP32Z4vIjwd2PBs6xqLSywi8qBz2cGZDlXEmzSZTDT1DmZ2u2H3YFQiIiIid56HRhD8N1WJgitWrGDx4sUcPnz4vrNsaOMTyvGBrzL1zC4WxR8jV6+hQK+zPUzeLDqZGjzUQCbD9l0k5KQbv3d6jE7/yhjqPfBdW8bO3LWf49bhyXvuYvNvnJsMwL37CxRsm4WltIS0n0cT9vbuSu5w/xYDnQa8j/eg9/7d3R1BazDxyK+HScizul+2CHZlyehm14yPZCrMpHDfQgzZ8Sh9a6MKbIjZMQDBw8N2fOrTz5E6cyT61BhbO9d2Y/AbO7PGXBR3ZsSToM4DoE9QFO4q0fXoQad5kBv2Cik6o4XdCXlV1nGIaI1n39fJW/81Ieos3jm7jk+fXcjs8/uZfm4vOaUaADanX2Rz+kWcFSqGhUYzOqI5XfwikN1EtneRG6eihWB5eQXrwLZPUFMcyUnm8V1/EFeWif0K+Xote7MS2ZuVWGU7YdzUGhvDg4xz00dw6ziOwj2/gSBQuOc3ig4vxeeRt7n86MuM3bGVv9IOgMwMEoF/0k6wctlJxkQ0553G3anjWrUAdsV190496yh9a+Mz5EO8B3+A7tJ+io+twJgdjzE/BX1uEkJJxeMFwYL6+ErUx1fSKaAevwQP4+WkhmhxYNXmTbysWUSAsaJr9El5FFMdx3FCUZ/udbz4a0xzPB3vHy8Gi2DhQHYSR3NTOZGfxvG8NM4WZmH+13PbmIjmfNuiPznL3yN3zWe2cucWQ/EbO/OGfqMPNl2wiYGtQ9xY80wrvJ3u/ETn3SRj/kRKr3rWuZpAbTxpDnc3473Ig0OorgSzIFRIxHMFjbSYpCI9s9vdg4GJiIiI3AUeWkEQKoqCzZs3x93dnR07dtx3YuAVlDI5bzfuztuNuwPWB3qtyUCBQUehQUehoRS1sRSpRIpMIkEmkSIt+y+TSMjUqTmQncSBnCSO5qZQelUA7mRNIT03zWFm26GMjWiOskxMswttglPTgZScWI0xJ5Gig3/g1uHJe7L/18J35Ddozm7HkHEeXdwBspe9jffQT5AqVAiCQP7G78j683VbfZ8RXyFpc3cC6pvMFh5fdJzDyYUAhHnYs/aZ1jiqqj79tJf2k7fxO9QnVlUIkn6FfDtnVIENUPrWpvjocgSD1T1IonLEf+ws3DqMrbGxC4LAzxcO2pafjWxTY32L3L8o5VLahXmw7VIul3I1ZBSX4u9SOVmI95CPKDq4BFN+CuoTa/A3lfJek5680bALv8cf47vY3Zwvsroeq4165scdZX7cUQIcXHg8vCn/16g7HqLAXKNcrbNayhRBQRAo2l8mCMrkuLR69La3Y7ZY+DJmOx+e2GybmHJV2vFkRAsSS/KJLcwiUZ1vc4cUuXX8n56LXXgrspa9i6DJQ9BryFn2DoU75zDnse/4X5M3GLhqJamyOJCbsCCwIP4ov8cfs1nmFup1FBh0FBi0FOitzwxmQcDf3plgRzeCHF0JcnQj3MmD1t4hNPEMtCWSuh0kEgkOke1xiGxvK8vLy8Pd2QFjfiqm/BR0iUco2P4TxtzLABjSz9E2/VP2yhzJF+zxt1QUDy/IwvjBcQy7FC1AIuG1zuF82b9ehXiZ95qY/AzG71vK4dyUa9YbHtaIuS37kz5jOOrjq2zl7t1fwO/xaUhu4Dc4m6lmwVHrdrwclWx+ro0tRMqDRGlqDPqU06iCG1Val+YQQap9zYRfEXn4eC3jIlqjma/rPl1p3QHZDjRK8z0YlYiIiMjd4aEWBMEqCo4aNYrFixezY8cOgoKC7vWQbhiJRIKjQoWjQkVQWfKR6zEkNBoAg9nEqGW7WRF/AZxzwakIg8XMs/v+5v+Ormd0RDOeqtOSxh4BeA96j5ITqwHI3/zjfSkISlUOBE78g8SPWoPZSN76byjYOReXFsMwZF5Ee3GPra7PyK/x6vcGeXlVWz7VNIuOpbEqNgsAFzs568e3xte58sy9pbSErKX/o2DbrGv2ZylVo4s/iC6+XKizC21K4At/ovKLrJEx680mliScYNrZPZzKTwfA396FfkF1a6R/kfufTuGebLtkfRH/flcCXz9S2c1WqrTDrf0Yctd8DmYjhbt+wav//7CTK3g2qg3jI1tzMCeJRfHH+SvxJHl6q4VsuraYqWd2sTX9EkcemYy8BoQHEStXWwgW660TCvqUGJvbpn1YC+TOt5fRPF+v5fFdi9mUdsFW1tG3Fr93eoxQp/IwDVqTgXOF2cQWZnK2MAuNyXBb231YkUhleHR7HnNkL8x7ZpG/5UcwGzHmJpE6fRhBQz8hYfz/8eG2c3xxYheCZyrIjVgQWJl85pp9p2qLSNUWwb+ikHipHPm+9UCeCG92RyZJpUp7VH51UPnVwbF+Nzz7vk7JqfXkb52B5sxmAFRmDf5obG1KnEPZW2ciOx07U1Skp4VMwpROETzWrGaSctUUfyee4sk9f6IzV0xKp5LJaeTuT1OPQJp5BtLCK5hmnoHkrvqkXAyUyfEfMwP3rs/d0LYKdUbGLDlhswZ+t0edB1IMvIIquBG13t1bqXzMdGvZC5XWiIhcnwgvaziLvZM6VFrnPHfX3R6OiIiIyF3loREEY2Nj8fT0rBQXcObMmf9JMfB2UcrkfNK5JWuOajHlBYJfPHhZMw7n6jVMO7uHaWf30NQjkCGhDXGu0xm/zAuEFWVTSxDuSytK+9Cm+I6aStbiyQBYtIUU7p5Xoc4VMfBukqctfwme3LEW9Xwru/KWxG4j49fxNgsJALlHMO5dnsUpug+GnET0abGoE44j5F7CkHnJFnDco9cr+Iz48rpxEC8V5bA+9TzbMi5hFiwEOVitQgIdXMusQ1xxkClZEHeUWef327IKX+H/GnUThZuHiKHRfny0+QIWAb7ZGY+fi4opnSu7ZLl1HEfuuq/AYiZ39ae4th2NwsP6gi6RSGjrE0ZbnzC+bzWQTWkXWBR/nKWXTwFwMj+d3y4d4dko0fK0pmhw1fVl5r7LPNEs0BrrUKYAsxFd/EEK9/2OW/sxt9T/ybw0hm5fQGJJPmCNK/pR0978L7prJTdwB7mS5l5BNPd6eO6tdxKpvSvej03FvetzZP/1hk1EyvnnPfI2TmWcszejlO7sT1OywiOYPQG+aJXlj3lyiRR3lT3uSgfcVfZIkJCmLSJdW1zJjTVXr2HM7iWsTo5ldttheNrdWJbuW0UileHc9BGcmz6CPv08BdtnUbhnPpZSNXL3QLwHf4Bbh6doJVcw5Y6O5NaxCBY+PrmFj05usZU19gjglfodae4ZRF03nyqtLqX25TEPVX5RuHUcV2X/pSkx5K79AmPuZbwHf4BQpzt95x7ieKo1q3uEpwPPtwutsq2IiIiIiIiISFU8FIJgTEwMvXv3Zu7cufTv37/CulatWj10YuAVGvg58/fY5oz8/TiGzNpQ7A3uGeCaA1Lry8GJ/DRO5KdBYAvrH+C06F3CnT0Id/Yk0MEFo1yKwmTBJJOwMyMObzsnfO2d8brDLxBV4dnrZezDmlG4dwHFR5bZMu6qghri+/g0nBp0v+tj8rvKGjCgCrfLrKVvkbfuK9uy1M4Z31FTcev8jM1dyD68JQCyvDw8PT2xGEoxZF5A5uKDwq3q4Px6s4ndmQmsSz3H+tRzXCrOrbLe9ejsF86UBp3F7MIPGQ39XZjzaGPGL7WKd6+tPosgwKudwpFeFftS6Vsbj54vk7/pe6uV65+vE/TCkkr9KWVyHglpwCMhDZic1ZH2663Bu7+L3c0zka0qJTUSuTV6RHrRLMiV46lFHEwqYNOFHPrUDcb/qZ/ImGcNk5Dx27Oo/KKwj2h1w/1maov59NRWfr5w0OYi7G/vwt9dx9Det9Yd2ReRqlH51SF48kryt80i8/eXQBCwaIswaIuQAR2BjsVgSJKSau9GVmAvRv5vPo5yZZWTeWaLhUydmhRNIbGFmWxIPc/yJGustr8vn2Zv1mV+7TCCPnfJQlwVUBe/0T/iM/xzSpNPYhfWAqmy8r3zfkJj1PPU3r9YVpaAC+D5qLb82GbwdV2v3btNpHDPb+hTTqNPiyV7+bv4jvzatl6fdpaclR9RfHiprSx5ah92+A7nhGkkSFT4u6jY8GxrVPIHd9IuPleD1mi2WQNezekMNY38ayZusoiIiIiIyMPEAy8IXhEDf/zxx0piIEDLli3vwajuHwZH+3Pmjc4sOJrKXyfTiUtzhYza4JID7lngWFSpTYlJz+mCDE4XZADQW2EVBPVKGV03/mSr1ysgkj+7jL7rSSgcIjvgENkBvzEz0MRuRTDpcW46sFKSkbvF1e7BWWp9hXVFB/6oIAY6RvcmYNwcFJ4h1+xTqrTDLqRxleuKDaW8cngVSxNP3bKLnkIq47FaTXilQSeaet5f7lgid49nWoeQrzXw5tpzALy+5izLT2fwy4jG1Pcrf/nyHvIhxQeXYCrKpPjQn2i6TsCxXtdq+23nG0avgEg2p1/kfFE2m9Iu0Deo3h3fn4cBiUTCh70iGfjrEcCabKB3lDfunZ5Gn3Ka/M0/IBj1pPw4mFofHkXhHnDN/gr1Or45s5NpZ3ejNZW7QHbwrcXfXcbg51B9RleRO4tH9xdQeIaQv2U6poI0TCW5mNW5YLHGu1IKFsK1+fjErUFpqd6yXyaVEujoSqCjK218QnkmsjWrk2N5dt/fZJeWkKErpu+WX3ihbju+btEfx+tYo9cUUjsnHCIru/Ddb6SUFDJo22/WyVNAJpHyY+tBvFCv/XVaWpEqVAQ+/weJH7ZAMJaSt/4bHBv2RuEeSM6qjyk+9CcIlWNxds1axt+yQ3zp8ya/PP/kA59RWGs0ozFUHcutkb8z0f7itUhERERERORmeaAFwavFwOHDh9/r4dy31PF24tO+dfmkTxTHU4v462Q6f51yJjnRHxSlYKfhWcsSdAoD6Q6eZIe3IaEkr8LLYVVsTr9I940/s7n3hHtiLShVqHBuUlkEvttcbSGYeZUgaMi5TMaCieX1Rk/HvceLt+WOLQgCE/Yv46/EkxXKlVIZXfwi6B9cj35B9fC2cyRVY40dlaopJE1bRKqmiOzSEpp4BPB8VFvxRV8EgDe61qbUZOGDTRcQBDiQVECT73bxTvc6vNW9Niq5DJm9C76jppL282gAMha+SMQnp66ZkfzVBp3YnH4RsFoJioJgzTGgvi8tgl05mlLE4eRCNp7Ppm89X3xHTUWfFosmdiuGwgzO/TiMwE7jsKhzMBdnYyrOxqTOxlycjV7pyMpuk5mafJaCssRFYE0c8r/orrzesEuNJJ0QuT2cmwzAuckA27JgsWDRFmIqyWXtdy9SL2srToKGfdtW07XfiBvud2BIA9p4hzBh/zJWJccCMOv8frakX+T3To/R2lt0TQWIKcpi1OG/ydKpAXBX2vN317F0D6hzU/3YBTXAd9RUq8UnkPrjECx6jS00CIDcPRD3fv/H7EOp9IubhgOlRJhTmJP1Kt6H1Qj937yhJCT/ZRyVsirjvImIiIiIiIjcGg+sICiKgTePRCKhebAbzYPd+GpAPQ4mFfDyyjMcTSmiR2ECDU1xSJT21HttGYIgkF1aQqZOzQfrXwZAaTTzbuMe5JSWsCblLOnaYk7kp9F1w2y29nkOX/uH052jgoVgiVUQFMwm0n4ejUVXDIBb5/F49Hzptrc1P+6ITQx0UdgxqlYT+gfXo7t/7UpWHa5Kexq4+1XRi4hIRd7rGUnPSG/GLz1FbKYao1ngw80XWXoqnV9GNKZtmAcubR+nYOcctBd2Y0g/R97mH/Dq93q1ffYOjKK+my9nC7PYmn6J0/npNPK4trWayI1htRKMYsCvB8CxiCc2rmNkridqi4bkegNIdK1NptwOk1SGNPE8LiY9rkYdLiYprjI3XJztOOYWRFbcMVufdjI5L9frwP8adRMzQ9/HSKRSZE4eyJw88Oo4FpZtBSB1/zK4CUEQwMfemRXdnuK3S0eYfGgVJSY9l4pz6bh+Fmt6PE3vwKg7sQv/GTK1xTx+6G+ySq1iYJSrN2u6P00dV+9b6s+9+wuUnN5Ayal1WMr6BJC7+eM14P9w7TSex/6K5e/CEOa5h/GNZhoNDeeRWExkL3sb9en1BE5YiNJbdOEXERERERERuTEeyKBNohh4+0gkEtqGebBqXCv8XVRYyg4Vk8lkW+9r70xjjwBkZentFCaBT5r14ad2w9nT70VCndwBOFOYSecNs8jQFt+bnbnHeDoobZ8zi62CYO6az9Fd2geA0i8Svyem3fZ2LhRl89LBFbblxZ0f5+f2wxkY0uCuuXiJPLi0CXXn+Kud+LhPFEqZ9XpwNquE9jP28fKKM+hNFvzGzoQyC5XcVR9hzE+ttj+JRMKrDTrZlqed3VNtXZGbx8VDg6recQiLocDtLD/F7WFxwnH25KaQqnTEVPY7WSRSChX2JDl4EOPiz17PWqz3rUeWyjqBIwOei2pD3LD/46uWA0Qx8D9E2x5D0Ums1/6gtO2oS69t1V8VEomEpyNbcXrwFDqUxYo0WswM376QE3lpNTre/xJ6s4lhOxaSUSbcdfIN52D/l29YDPzq9HYC/vyY949vRFsW2kMikRAw/lfk7tYwHTJXX3wf/57a38Tj0XMSO5JK+PuUNVRLvkMwIf+3G++hH9uuubqLe0l4tzG6y8drendFREREREREHlAeOEEwNzdXFANrkABXO/55qiUWSZkbisVMQnbluIL/JtzZk119JxLu7AnAhaIcPj219U4O9b4lPk9j+5xWXEpp6hlyVn1sLZApCHz+D6Sq23ep/ipmh82Ne1K9DgwIrn/bfYqIXI1SLuW9npGcfK0T7cOsgr8gwPS9ibT9cS9JyjA8elothi2lJSR92RV95sVq+3sivBleZcf+wrhjbEw9f+d34iEgtiCTvlt+QS/VVrnez96Zlq7e9FDZ0drOgbp2jvgq7VD8K7FL3+zzrDm1lNmtBxPo6Ho3hi5SgyjtHcn0s7pX+lrymLv071vuq5azJzv7TOTx8KaANZbwZw/pPR3gq5jt7M++DFifd/7p9iRuKvsbalug1/LO8Y1k6Ir55NRWwpd9wbdndqIx6pG7+BD+yUlCXt9EnW8S8Oz9ClKltd+fDiTZ+pg3ogltwr3xHvQeoW9stpVbStXkb/q+5nZURERERERE5IHmgXMZ9vLyYseOHURFPdyuLDVJm1B3coPqQeI5ZFg4d2Qb4f2HXrddqJMHSzo/Qeu1PwJgsFQdDPpBJqO4lF5zDtqWWwW5WmMElX0X3kM+xL5W8xrZVqBD+Qu79z2I2Sjy8FDP15ndL7bn54NJvLn2LCV6MyfTi2n2/W5m9XuGdt4rMeYkYsiK4/LHbQl+dQ0OddpV6sderuCtRl15/chazIKFR3f8zp5+L9BETGRzyxTqdQzZPt+WUKiddy0ux7uQngsYVZx5tRcNfN2qbCsIAlqTgXy9jrxfnkJ5dh0AZl0RcifPu7QHIjVJrS5PwJJtAOj2/sqqZt0Y1PDWQkXIpFJ+bjecPxJOAJCr1/AwHhUpJYV8eXoHYI3Pu7LbU3jexD33ZH465qtiA2bp1Lx+ZC2fH1rJ+MIkRqYew9FYikuLYXj0fgWVfxRag4n157IACHS1Y1gjfwDUJ9eRseD5Cv3bhTS5zT387zFx/3JiyhLd/ZvTBRk0cve/yyMSeRi41nEHEO3uz+x2w+7iiERERERungdOEAREMfAO4BTdGxL/AaD0zEa4AUEQoNRc7qLkY/dgZ8D7N4U6I33mHOJyvjUgf/MgV6aHnyd/xy4AlAH18OpbfYy1m+X5qLZ8eXo7JsHCjHP7eKNhF+yukdRBROR2kEolTGwXRpcIT0b9fpzTGcVoDWaeWpnAM/Vm8z/7tzEmH8esySfp654ET16JU8OelfqZ0qAzJ/LSWZxwnBKTnv5b53Gw/8sEO7nd/Z36j2MRLIzZ8weXinMBaO0dwva+zzH3QAqTVpwB4O+TWTTo7VZle4lEgqNChaNChdTRjSu24BZtEYiC4H+Sut0f5/SK11GW5tNHv4eBi/dQb0pfIm8xI22+vtzqNMDBFf016j6ovHl0LbqyZ5sXIloR7XFzYtPx9HKraYkgIEHAIpGSL5XztUcEPzsH8GTKMcbtnEPBjp9wavIIsZFPoTPIQSJhaLQ/QkkuqX+8QvGBP2x9Se1d8B35NW5dJtTMjt4hMuZPpDQ1psp1L6uCOGvvSY5d5Ukh/8gWhJdqGFhFu5iCjGqFv0bu/kSLgqDIHeBax93pawiFIiIiIvcTD6QgKFLzhLXuj3q1FBkW3JJ33XC77NIS2+eHSRDUGc0M+vUwpzOscRPreDmy9ol6FH860lbHf8wMJHJldV3cNIGOrjwW3pTf44+RXVrCHwkneDqyVY31LyJSFfV8nTk0uQP/W3eOH/ckAjDvnIE9rh+yNHIWiosbEQxaUr4fQOALf+HSfHCF9hKJhHkdRpCmLWJnZjzp2mL6bfmFvf1fxFV5Yy54IlY+PbWVtSnnAOv1dlnXsahkckY2CeCVVbGYLQKLjqXyQa/I62Yzl9mXZxm/kvxI5L+HVKHCr8s48jd+iz0GuhRtZeh8bw6+3AEn1c0/AmZcdSz42ztzuQbH+l9gT2YCf5Yl7vK3d2FynbY31d5UlMXBPQvBNQiA5UcXYmcxMTekNav96mOWSClS2PNjeAfS7F35+MJmSk6uIfTkGpbKIlhgP4jHSCP+7fcwq3Nt/To1HYj/2FkoPO5/6+rS1Bj0KadRBTeqtC5FISNDpajy5STF0QWFrPpIR43c/dnb//aTs4mI3AzVHXcd1s24B6MRERERuXlEQVDkhggNDOBPZRSNDefwL7mIsTADhdv1Z1yzdFcJgvYPhyBoMlt4fNFxdifkA+DnrGLThDaw+T1MRZkAuLQeiWP9bjW+7dcadub3eGtm0O9idzGuTsvrvviLiNwudgoZPwxuSI86Xoz78yR5WiMXi6C15DlWhckJvrwWwWQgdcZwAsbPx6396ArtVTI5/3R7kvbrZnCuKJszhZkM3b6Ald2fwllhd4/26r/F5qw4PjyxBQCZRMrfXccQ5OgGgLeTit5R3qw/l018npZDyYW0CXW/Zn9S+/IQBGbd9ePGity/uHd9jvyN3wIwonQjf2T0Z/zSUywZ3eym7w/pVyUHC3BweagEQbPFwuRDq2zLX7boh7P8xhN2GQszSPqyG+cCrGFCFBYL7R//FkePILq5+ZMss+PruKPMv3QEk2BhhX80E0oyCUo7DUADczxfl3wHK+FKABaZszd+Y2bg0urR/8y9Pj5Xg1YexteuX1Zap7P8SphOzdmXp1Va1+KnCSB/4EKfi9wn6FNOk/hph0rlwS5RJDq4Vinwie7oIiIiDwLinVXkhpBIJMR7lscAKzy54YbaPWwWgoIgMHF5DCvPWIU/Vzs5mya0wV+XQP7mHwCQqBzxHTX1jmy/sUcA3f3rABBbmMWq5Ng7sh0Rkap4pIEfp1/vQrfaXgDoBRn91M+w3qWvtYLFTPrcseRv/6lSW3eVA+t7jsfX3prddntGHE1Wfc+BssD9ItUTV5zL88dWI2DN+P5ty0fo5BdRoc7oZkG2z4uOVZ/9+QpS0ULwgUHlVweHsgmoOuZkmprO8dfJdH4os+i9GTK0V1sIulyj5oPH/LgjnMi3ZlZu5RXM6IhmN9zWKgZ2RZt5gUuO1utjXTcffDqMxbF+N1QB9ajjW4u57R/l65YDALAAi/v8j+wh8zgur1epT9f2Y4n48hyurUf8Z8RAAK3RjMZQdUxpmUSCVPrf2ReRBwO7oOgqLVYB6qvTqaWtelKsrlFLaMIhEj/tUOmvNOU0huz4OzlsERERkRpBtBAUuWG0tbpCxjwAso6uxbvL09dtk32VhaD0Jh5YC/Ra4tV5JKjzyv7nY7SYGR3RjB4BkTc/+LuAIAi8u+E8vxxKBkAll7L66VZE+9hz+fPx5YlEBn+AwiPoWl3dFm9Gd2FbxiUA3jiylr5BdVHJxFNd5O4Q4GrH5ufa8M2OON7deAGzRcYbiufJslcxTrcSBIHMBRMRjKV49n6lQtswZw/W9XiGnpt+psCgI0GdR8f1s3itQSfeiO6Kl5gspxIao54h2+ZTbLJGc3sivBkv169s5TCooS9OKhklejN/nkjj+0ENrul+J7vaQrCalyGR/w7uXZ5De3Y7AI+VrueEoj6vrY5Fb7LwSqdaqOSyG+rn3xaCDwtFBh1vHyufCP2h9WCkkhubUzfmp5L0VXcMmRdJcvDAILXejxt7h1RZ/7moNnx5ejvZpSUsTjiJzu4R/nb7imjjBeYFHsDblIPXI2/j1KjP7e/YPcJRKWPvpMrXqRY/LbxmuwsKB9FSS6TG8X9qdrXrxrwQTZBuNx7FFyqt013aZ/1Qp32ldYJei6VSqYiIiMj9h6gSiNwwXlGtyDvgiqdQBOc2YixIR+EecM02xcZS2+fuG3+md2AkT9dphbvKnixdCdmlJWSX/c/SqcnQFZOgzqfQoKuyvwVxR+kRUIcvm/enudedE9Vuhe92JfD5tjgApBL4a0xzOkV4UhKzGV38IWslqQzPXpPv6Dh6BkTSMyCSLekXiVPnciQ3hQ6+te7oNkVErkYmlfBW9zr0refDp1susTwmg6kO4yiRODBJaw2Cn/Xn67i0GIbCM7hC2+ZeQZwa9Bpj9yxhZ2Y8ZsHC12d2MuP8Pp6NbMNrDTqLCUeuYub5/ZwptFokN/YIYE774VVaCzko5fSM9GZFTCZ5WiPns0uI9q9e0LnaTVgwVn09Fvnv4NJ8MJkuPpiLs+mv302JxIEvHJ/lrXXnmL3/Mp/2rcvjTQOva52VepU47P8QCYLrUs7ZPB5GRzSjjU/oDbXTp50laWofTPkpAKQHNLCtKzEaEASh0vnqIFcyIaoNn57ailmwsCPnPODHRft6NHrt1RsWbx80oq5xHRITh4jcKVLtwpFIJHhUsc6+TnvsgqKrFBQlP93fyX1EREREriAKgiI3jIeDHSvtuvOM7h+kJh3Zy94m8Nn512zzWHhTlifFoDebEBDYmHaBjWmVZ9luhq3pl2iRPo1RtZrwabM+RLh43VZ/NUGhzshHm8szB855tDGDGvoBoPAOs5Wr/KJqNJFIVUgkEvzK3C4BnBU3HuNIRKQmaRzgyt9PtuB8lpp3Npznp5hR2Al6ntUtB4uZgp1z8Bn2SaV2wU5ubOvzHN+e2cV7JzahN5vQmoz8cHYPs87v54nwprzesAsN3P3uwV7dXyxNPAWAFAl/dxmDQzXXF6PZwv7LBYDVejnItfrYjBZDKfmbplkXJBIcIitb8oj8t5DIlfgM/YSM+c8BMLJ0I5Gmy7zq/D+SCjwZ88cJvt0Zz9cD6tMzyrvafs4WZgEgl0ip5VTVK/KDiUkot/Xp/C93/OrQXT5O0tc9sGis553Svy79xs/DbftCCg06ViafYdTORfQJiqKzXwS1nDyQSCRYBAtrU87a+glSepML6E0WstUGgt0fzmRLnxZZXdxrPT/nHo9E5GHi9+BXOZujo5Grc5Xro51cqN6+UEREROT+RxQERW4YlVzKHPtHGVy6DU+hiKK9C/Do/mKFOtr4Q5gK0jCX5OEQ1YkBwfVJfvQdFsYdY+7FQ1wszrnmNpRSGbWcPQh38iTCxZNwZ08inD0Jd/bgYlEubx9fz4Uiax9/Jp5k2eXTPBfVhvea9LTFHrsX/HwgCbXeBMDEdqE807rcFUjlF4nSPwpDxgUM2XFYSkuQ3uF4igeykwBwlCtp4OZ7R7clInI96vo6M39UU7Zd2sICy2Ce1K1CiYmCXXPxHvRelSK5VCLljeiujIlozvexu5l94QBqox6jxcz8uKPMjztK38C6vN6wM139a/+nYmjVFGaLhdgy68C6zl7Uca1eyFl7NosstdWteFi0P+4O1U9MFOycg6kwHQCXViNQBVSOXyby38O96wSkDm6k/zIOwaClqek8a0umMNn+VQ4qm3AyvZhecw7SM9KL93tGUs/XGQ8Hhe3csgjlx1uUqzfKhygUhYfKwfY5X6+9oTZZi1+xiYH2tdsS/Ooa5E6eLOg4ikHbfgNg6eVTLL1sFfWDHFzp5BeOj50TJ/Ot5187nzD6q+pz8qJ1InXbpVyeahVcxdYeHAS9tsrkDtVlJhYRuZPU83ZALq/6Wnc6Q32XRyMiIiJS8zw8T3Mit41SLqFE6sh0hyf4UDMLgOSpfZDQCQEpEixc/riNrb7U3oXwT0/j4xXK69FdeK1hZ7akXuK3c6cJc3ckxNkVXztnfOyd8LGz/rkq7ap9sW/o7s/AkPr8dukIH5zYTIauGJNgYeb5/cyPO8o7jbszpUHnux4vT28yM213AmB1lXyza+1KdZyi+5KfcQHBZEBzfifOTQbcsfHklmqIU+cC1sDncunD6V4kcn/hbCdnYrswvtxuYqOqAwP1OzEXZZE0tQ++I77CPrxlle38HFz4onEPns06y/QTG/jdpx4FSuvL+Ya082xIO08zz0Beb9iF4WGNUDxEx3uCOo9Ss3Uioq5L9WIgwNyDybbPz7apOnYZgEWvIW9dWfZPiQTvwR/c/kBF7htcW49A5V+XlB+HYMxJwMlYwC/GD1jj/yTvGAZhkcjYcjGXLRet9xA7uZRAVzsCXe1wcbFa6gI0dHu4rHM9lDcnCFr0GrTxBwBQ+kUS+uZWpGWi4sCQBkxvPZi3j29AbdTb2qRqi/gj4USFfj5p2htnkzfvbCgTBONyHmhBUKpytMZdq0JnUQU3wi4o+m4PSeQhZ2rfCDw9Patc12H6Xk5nqOkwfW+ldVrBLCbIERER+U8gCoIiN8yVuDXL7XoyRbkdl4LzmDX51da36IrJ+G0CIa9vxCLA/CMpvL8xifRiFV6OUmYODWNo3WvHIPw3cqmMZ6Pa8EREM344u4evYnZQZChFYzLw9rENzLt4mGmtB9E/qN5dsxhadCyNzDLLm5GNAwjzcKhUx6lRH/I3TwOg5PTGOyoIHspJsn2+0ThHIiJ3g5c71uK7XQkssnuEfvrdyLGgPbeDxI9a4dxiKD7DPq1gjSZYLBQd+IOc5e9gzEvmOeDJhL2s9q3P/ODmJDlYXRaP56Xx+K7FvHV4NW827sFzUW0eCiE8tsx9E6Cec/WCYHKBlo0XsgGo4+VI54iqX24Actd8jqkwAwCXNo+J1oEPIHYhjQj/6Bjp855GfWwFEgQGZsyne0gcL6kmc7igPMxEqclCfJ6W+DwtOOdC2S3lZIKZnJb6arbw4HG1hWDeVYKgIAikF5Xi6aioENtPG3cQysR6p+jeNjHwCi/V78DzddtyPC+NXZnx7M5KYE9WIkWG8rjLXf0i6BZQB7NFwM1eQaHOyLZLuVXGHbzfmLjsNDEZ1gQ0JpOpgoXViwYzjsqqr89KH6s7tugWLPJf4JpxeAUBMauIiIjIfwFREBS5YVRlGSktEhnHWn9CjwMvYdEVX1VDgkef11C4B5C/dQbGnEQ0Zzaze+mPvJjcmNjM8infXI2Bkb8f4+9T6cwcGo2P883FuXOQK/m/Rt2ZENmGz05vY/rZvZgEC/HqPB7Z+it9A+vyfeuBRLn61MSuV4vFIvDNjjjb8htdq44t5BDVCYnCDsFYiubMpjs6ph0Z8bbPbb1FQVDk/sHfxY4xzYOYd9jCiy7v8Z10MY6F1vNHffQf1MdW4tbhSbyHfIg+4wLZf71JafJJW3szMlYpeyAUK1lxagX7nDz5LbgFx92sCYaSdWpeOriCWbG7+LHdo3QPqHMvdvOmsRhKKTm1lpJT61EFNcSj96s39MJ/piDT9jnKufpYqr8eTkEQrJ/Htw6ptm995kVy138DgERhh8+wz25iL0T+S8gc3QiatJz8LT+S9ecbYDbimLyXhS6XiO02jS3m+qQVlZJWXEp6QQny4jQMznFkl7VPTDbQaOou2t3Tvbh7eNpVtBDUm8wsPZnOdzsvcTJDQyN/F3a/2A5XewUA2ot7bPUdojpV2adcKqOVdwitvEN4I7orZouF0wUZ7MqMJ7dUw+QGHQGr50GXCE9Wnskko1jPuawS6vvduxApN0JMRjGnM9Q08q88TkelDAfFgz9hI/LgM3t49S7s9X/87S6OREREROTWEQVBkRtGJZfaPme4NSTyB6sViTB8uPU/Evwem2qtG9yY5K97AKDc8A6BTi9yXtkWs0RGsyBXjqdaMxUuO53Bzvg8lj/Zgk7XsFqpDk87R75rNZAJkW145fAqNpUlLNmQdp6tKy/xSdPe/K9Rt1vf6euw5mwWF3I0APSK9KZJoGuV9aRKexzqdkYTswlDVhyGrDiUvpVdi2+XvFINa8qCkcsk0hsOfi4icrd4rUs48w4ns1fZnKHObdjW+zKSrV9gzEsGwULhnt8o3FP5QXqrsg3THMaSKLeKf18KT/Jh0CWWG7dx4Pge5gc1Y4t3JIJEwll1Pj02/cyQkIa8H9mpWnefe4nFqEcTu4XiI8tRH1+B5arsrTInL9w6jL1uH1eyCwPUq8Zl2GwR+PWw1V1YLpXwZMuq3Q0tRj0Z858Hs9Ul1OuRd1BelRBJ5MFDIpHg2WsyDhFtSZ01AmNuEubiLOquepzm9bohdXDDkHcJQ+ZFcpHQ3W0CVx4btyS/zhpVdxKQAPe3tVpN4K4sT+RxMDWb0E+32WJyApzOKOaF5TEsHt0M+JcgGNnxhrYhk0pp6hlIU8/ASi8/fkYAAQAASURBVOu61/Fi5Rnr+b7tUu59LwgCNPJ3Zu+kDuTl5VW4Bid++vBkpxYREREREbnfEQVBkRvG3UFh+zxz32X61vWhfa2KWQbTi0q5kFPChgR/nO16Max0M66Chu/VX5Or8se5+yQaDXyJdfEanlt2mky1nlyNgUcXHuXUa53xc6k+8+W1qOvmw4ae41mTcpZXD68mQZ2H0WLmrWPrUUhlTGnY+bb2vToWHk2xfa7OOvAK9rVaoomxWgeWpsTYBMELRdkczE6itosXzT2DsJMrrtVNlRgtZmad28+HJzdTaNAB0MY7BBflrX2fIiJ3inq+zjxS35c1Z7NIVRuJ2hZI3zq/80ajXQQc+RFzSW6F+mft6vO5aiwnFPUBCHK1I7WoFKNEwTtp9bncpg8znnajx76F7D+whE98G3GszGJwRfIZNqad593GPXmt4d2PL1oVJTGbKdw7n5KTa7GUVh2QPOO3Z5E5e+PcuG+1/ezLSmRFUgxgTR4U6uBWZb29iXmkFFrdEAc19MO3CmtsY2EGqT8ORRd/EACFTwSefV+/md0S+Q9jH9GK8I+Ok/bLOEpOrAZBQHN2W4U6sR61MErLz59XG/WjV85FyA0DAUBAsFiQSKU8aORrDby55hwSswJBZiTdlAXyRKBiyJM/TqTxTo86hOYfQXtuB2CNHyh3vf3EXj5O5edtQr7mtvu7l7zrWosLCnvs1s2otO50QQaN3P3vwahEREREREQeTu7925HIf4aGfs70ivRm88UcCnVGev58gBfahdnWC0Dgx1tsy04O4wg0Z9LGeBoAL30GrH+bSzu/onF4a/b7B7LSJGVvgT2ZBm/emFfAr8/2QaYoE8Su+LiVIZErq8xGalsvkTAwpAG9AiL5KmYHH57cDMBrR9bgoXLgqTpVJy24VSwWgV3xeQD4OqvoXqd6lz0A7YXdts92wdHozSY+ObmFL2N2YBasgUYUUhnNPYNo5xNKe59atPUJxd/h2rPpG1LPMeXwGs4XZdvKXBR2TG35yK3umojIHeWL/vXYdzmffK3VGm1DXBEbaEK411w+D9tGdNJSiiTOfMCjbFG0BYkEL0cln/ery7iWwaw/l83I349RarIw92AyAS52fDjoPR7pM4U2qz9j0aF/mBrRmUw7Z3RmE+8c38D8uCO817gng0Mb4Ky4M0K5IAisSo7l/RObKDHq+b3TY7T3rWVbn79lBpmLJlVqJ3V0x6Xlo+gu7UOfFotgMpA6fQjBk1fhFN27Uv3L6nyGbJ+PwWIGYHL9jkircQNed7b8ujCqSeWYrbqEI6T8OARTQZp1LHZOBD47H6k4mfBQIXPyIHjySvI3fkfW32/Z4t9JlPYofevQNaA+DaRSYi3We9VxtyCOuwXROzkFR50Jk1zK9veb06z787h1Ho/kAYnhaTRbGPLbEXYn5INXEPglWg0iAy/RItSFz5u0JV4NE5dbxflFe07x1N4xtucXj16Ta2QMH26+YFvuVvvazxr3OxcU9lxQONC4inWN3P2JFgVBERERERGRu4YoCIrcMBKJhJVPt2TkwmOsOZuFzmjh210JDKFqhyGzypns/n8TGJBB8ZZpqE+sAkHAoi1Cc8Yq1vUu+wPgJFx68Rrblytx6zgO76EfI3epPjagnVzBB0174SBX8ObRdQA8s28pzgoVw8Kqj/dxI2iMeramX8JRocTe5EZemaDROdzzmjG/TMU5aC9as5CpgqKJkdnx1OppFVz+wGrpdzAniYM5SXwXaxUQAx1cCXRwwdfeGTepklA3L/zsnfFSObIg7igb0s7b2kslEp6NbM0nzfrgbed0W/sqInKnaODnzKX/68aCIyn8fCDJ5nafUCJjVEkvUPWqUL9XpDfzH2uCf5kF8cCGfiwZ3YxhC45iEeCjzRfxd1HxXNswfB/9nNGChU4bv2NOSGvmB7fAJJVxqTiXsXuWYLdfTv+geowKb0L/oPrY34JFblWczEvj1cOr2ZlZHsOz9+a5rO3xNF38a6M5t4PMP16xrZO5+ODcbDAuLYbhWK8rErkCwWIm/ZenKdq3EMGoJ+WHwQS/uganBj1s7dTGUh7Z+is5pdbvrF9QXT5u2pvCgoIqx7XunDXxiFwqoWdkRbfiov2LSf/1GYSyTKcKnwiCJ6/CLqhBjXwnIv8tJBIJnn1fw7X9WAyZF1F4hSF387dZ/R01GZl+bi9/JJzgZH56hbZ6hYweEd1pELOH4Sc2Mn7Q2wRF3P4kXFGZxbtKKkclk9/1ZBqvroq1ioGAS0ktwuVOnDRZxb+jpmPs1bjwWrNevLbmLFq9iVrbXseks343Tk0G4N5t4m2PYc6BJM5llQDQtbYnA+rfvsXhvSbKqGVv/5fu9TBERO4oZkGoMgMxWBOSXCsGoYiIiMjdQhQERW4Ke4WMf55qwfilp1hwNLXS+iHRfkR6ORHp7Ujvut4EutoDkbjW74w+8xL5m3+g+NCfmEvybnrbgslAwY6fKTq4BK+B7+LR82WkiuqTkbwR3ZV8vY4vY7ZjEQQe27WYNQoVvQOjbnrbGqOeWef383XMTnL1V7nr1LEHrQt4ChzO8aaxR0CVbonqE6tBsGCQyJjboD/T1/5oswpUyeS8Ur8jRYZS9mdfJqYgE4Fy68g0bRFpV8UXI+nfvVvp6hfBtNaDaORxc5mbRUTuBR4OSl7tHMErncLZFZ/HzweSWB6TgdFcfuwrZVK+6F+XVzqGI5VWFAIGR/sza1g0zy+zvpy/sDwGXycVg6P98Rn+OYasS7x69B8GZZ3li/r92e9knUQoNZtYnhTD8qQYnOQqBoU0YFR4E/oERt1SZuJMbTHvHt/Ir5eOVDhvATQmA/22zGNZi75EzHwUyiz6vB55B++hH1WyopJIZQSM/xUEC0X7FyEYS0n5/hFCpqzDsX43zBYLj+9abJtIaODmy5LOo5FV46Z5OV/L2TIhoUMtD1vCA0tpCdnL3iF/y4+2uo71uxP04lJkTh5V9iXy8CB38UZeRUxKO7mCN6K78kZ0V+KLc1meFMPOLbMr1Il19iMW+GznH/Te/zfPtn+cfmHRKG7i3DJZzPyTFMPUM7s4kptSYZ1SKsNOpsBOJsdJoSLKxZsG7r7Ud/OlgZsf9d18cbrGc8HNMO9QMjP3XQbAXiFl58T2NA1y5YvT23j72AYAPj63A5mdguHRfhj3zqG97hAAcjd/Ap759bYFzEKdkQ82Wa0DJRL4bmCD+z7DsIiICEilEpJVjsh0lWMimwWBM0kyYO7dH5iIiIjIvxAFQZGbRi6T8tuoJoxpHoTRIjD3nfmA1Upw+VPVWwSo/OrgP3YG/mNnYNapMRWkYsxLwZifwtbDJzh/6QKelkI87OW0s8UmvPLgK6CNO4BFU4BFV0z2X29SsP0nfEdNxbn54GofkD9v3pcio47Z5w9gtJgZsm0+W3pPqODGdy2qFQJtO6UDlY6l2VksXbsbhVRGpIsXdV19iHL1oa6rD2HFGThv+ZGLzr68U7cPcXqjrXlr7xB+6zCSem7lM/7FhlIO5SSzP/sy+7Ivc64wi6zSEoxlYsK/CXf25NuWjzAoRHxREPnvIZFI6FLbiy61vchW65l/JIXfj6XiqJTx0/BG1SbqAXiubRgZxXo+2nwRiwCjFh1ny3Nt6BjuSeCE37mcl0x44lHmHP2duAZ92NlmLEtTz5Kut1odlZj0LE44zuKE49TCwv85uzI8KAqVdy2U3rWQOXtXe06VmoxMO7uHz05to8RUnlygnqsP37QcwG+XjrA8KQad2ciQAyv4QelCJ/JwbjYY76EfVxtrTSKVEfDsfASLmeKDSxCMpSR/P4CQKev5sETN2pRzAHipHFnT4+lrxgldf67cXbh/PV8EQUB9ZBmZf7xqcxEG8Oj5Mr6PfYvkPoixKPLfIMLFizeju3JIb40DpzSaCRIcSZVY75MmqYx1Jgvrdi3Ce7+SMZFtGBjSgGZVJMy4gsao59dLR/g+djeJJflV1jFYzBgsZoqNkF1aQoI6r4KVPECIoxtNPQN5pk4r+gfXQyqxnmvWRD5bwWLCsWHva7rFH0wq4IUyN2CAeSOa0DTIei36v0bdsZcpePXwagA+OLGZJz0jeUPzq3U7SAiY8HuVourN8umWizZPhHEtg695PRQREbl/aO7oiJ1eB8rKkyHHVC5cBDpUEUcz2t2f2e2G3YURioiIiFgRn/5FbgmJREL3MvezW5nfktk7I7OvhyqgHgBDOlho/v0eTmcUA3D5qe6EejhUaGMqySN35Ufkb5sFFjPGnARSpw/FoW5nfB//HvvQplWOc0abIRQZSvkj4QQ6s5F+W+axs+9EQqj+ZaA6IVAmkTI6vAleKkd+OBaDSVkMMottvdFiJrYwi9jCrIodRvSssKiSyfm0aR9ebdCpknWPi9KOnoGR9AyMtJUJgkCBQceFjBRKVTKydGoydWq87ZwYHtbovkiWICJyu/g4q3izW23e7HbjGbg/6BVJRnEpcw4mozdZ6P7TAV7pGM67PesQ/Mpq4j9ogaUwnTqxG6kTu5FngBOugaz3qctm70jyldbrTCJSJqjVfHd4PZMT99IxPxGp0gGlb22cGve3bc8olzBw66/szIxHbSwXAj1UDnzctDfPRbVBLpXROzCKsbuXsCTxJAapjEkNBzE94yTPTlh43cQLEqmMwAkLQbBQfOgvBIOO7xe9xtTaXQGrldSK7k9Ry/na2ZOvuAsD9PMuJnlqH1u4BgCJ0gG/MdNx7/T0DX/fIiJVITcJqOPbcGpyNAu2/8QfhTlkqqyZcHOMBr6L3c13sbuRAJFOXrT2DaWFVzAtvYLxs3fml4uHmHV+PwVlLsJXaOYZSJCDG6VmI6VmE3qLyfrfbCJPr7G5zl9NsqaQZE0hq5JjiXTx5qWA2vRP2IfxwO+Y1dakRXJXPzz7vo571+eQ/iu8RnpRKUPnH8Fgtt7b3+gSwWPNKgqZrzTohEom54UD/wCwIO8ibTyC6JSfyK/2Q5kS2I7bDdoRl6vhx72JADgqZXzat+5t9nhn2PxOT7ycKoZesAuqS7qjMy1+WoggCBUmVs7L7KhrLr3bwxQRuassGPdDtev6fjWSJHsn8AmrUH66IOMOj0pERESkMqKKUAUZGRl88sknnDhxgoEDB/LWW2+Jlld3GLlMypjmQbyx9iwAcw8lV3r4lTt54jf6R9y7TSTrz9cpObUeAO35XSR+0JzA5xbh2vbxSn1LJVLmdxxFidHA6pRYio2ldNv4E4P869LIJ4icUg3ZpSXklJaQU6ohp7SEdG0xOnO5JZ9MImVMRDMm5lzAZfFzWEpLGCJx5iOnidCiD6PauXA4N5mjuamcL8pGYzJUu69tvUP5tcNI6rpVHwfx30gkEjxUDkQ6e+HpeW0RQETkYUIikTBzaDRZaj2rYrMwmgW+2RnPb0dSeLSxPwP6/EytFY8h6K2us1KgeVEazYvS+L+47RxyC2FBcHP2eViths87+zCx0VBaFyTx6flNBKScZntJETq7VtiXmjEoZGxKOWvbvlwiZVL9DrzXuAfuqvJJDLlUxrTSHHQZZ1jp3xCTVMakoJbkXzzMlAadrptNXCKT4/vsAvYhZ1V+Bn8FlIfgn+YXQofrWDnrjGa2XbKKH89LtyH5fnaF65Jzi6H4Pf49Cs+QG/uiRUSuQ1GpiZ0XDHw76lM+zbjAP3+8zp9GM1u96lAqsx7vAnChJJcLJbksjD9WZT8SJAwMqc/rDbvQ3ifsms9fuaUaYgszOVuYRWxBJrGFWZwpyLRN5F0szuHl4hzeN+oZ6x7BE9pinMwGTEWZZP35Orlrv8Bn5Ne4dRyHRCJBbzIzbMFRMoqtYn+vSG++6F+vym1PrNuOEnUxb57ZCsAHUT358vgepjs8gdvhFN7vFVlluxtBEASmrIq1hVB4q1ttWwzV/wLpjs4kOThTz6SttK6uuZQGKvt7MCoRkfuDiclWS/+BL8+rUF6VxaCIiIjInUYUBP/FxYsX6datG7169aJly5a8//77hIWF8dhjj93roT3wDGvkbxMEP9t6CY3BxDcD6iOXVbSmUQXUI2TKOkpObyRzyRQM6edAEMhY+CKO9bohd/Or1LdCKuOvLqPpt+UXdmTGU2jQsSDpBCSduOaYZBIpY2s3563aLbD742VKTq3nij2gu6Dms5LpxPg9wtORrXg6shUApWlnOfBhaxIdPEhw8CDZpzYpAQ3RObgxMrwpL9frUG3MLxERkZtHLpOydGwLvtkZx+fb4tAazORqDMzen8RsoJvr+7xmWYGnmys+gWE4+4Qidw9E4RFElHsg4xw92JFwnPfOH+SQ1mqlfMg9lCGtxtE+P5FN3pH03lYxllmQgyu9A6N4M7orka6VXQMFs4mCdV/ySXE2CsHC3wGNMAkW3jm+galndtLMM4gmHgE09gigiUcAdd18UEhl6ExGNqddYEXyGdaknCXf3g8Cy69pzyQfpvPOb8lWp+M99JMqrQ0FQWDistPojWZe0C7hRd2ftuiGCp8I/EZPx7lx3xr7/kVErjB5ZSxzDiYzLNqf4aN+p+/FpSQse4ftDl7EuPhzxtmPc07e6GWVBXGlxcSgzFjG5cURleCGPGYl2X6RePR8GYVncJXb87JzpLNfBJ39ImxlgiCw8fw+vtw2l92O1nOzUGHPj+EdWFCrHePNGh4/8Bt2ZiPmkjwy5j1D0f5F+D/1M8/v1HAwyZqgJ9zTgSVjmiGTVhYkjQXpFO7+lQE7fmZjYHO2e9UmW+XMmwHjManlTN0ZzzOtg8viKN88H2y6wJqzVgvfIFc7pnQOv6V+7ga9PttCUFBQhbKv183AA9jb/yXy8vLEiUwREREREZH7FFEQvApBEBg+fDhvvfUWL71kzX6m1WpJTEy8pf6Ki4spLi62LWdkiKbg16KWpwMf9Y6yBdCetjuRs5kl/DmmGe4Oykr1nRr1IaJBD9LmPknxgT+waAvJXDKFoIl/VNm/nVzBqh7jePngSv6+fLpKKz65RIqXnSPedk609Q7lzeguBOQnk/pND0pyL9vqpUu9CbDk4Cjo6HT0HYReO2wv5hZdEb6GEnwNJfSJ7o7/079c10VQ5O4inpsPHkq5lHd6RPJki2De33iBpafS0RiscTe3W+qynf+DQqAQGuW70LW2J11dvejs6ombvYKejXvRo1FP1qee45VDq4lT51IiU7DJu6KVj8pgYrW9GzOLu7P+vJqLpy7SyD+TxgEuNPJ3oaGfM44qOZrYrZiLs5EC33n6ULdxD744vR2TYKHAoGNbxiW2ZVwqH79URpSrD/HqXLQmI//GXiJllL6AVxL2AJC75nNKU2IIfH4RMnuXCnW/33ic4r0L+E2/k1bG8jhonv3/h/fgD68ZO+1eI56b/02ulsxiM9XEZqr5eMtF6njVZky35Qws2cijujRMxdlo484QX1pMrMqZMy5+pKtciFZn8ljaCTyNVpfh0jwg+SQlQNGBP6j10VEUbv43NBZ9SgwRP49idkEacQ6eLIjoyGrPCExAkUTKt3JnVvd5j6+Kkojaa7XQ0Z7bwcW3o/FU9qO3vA7Z9sEsfGI4Hlc9ewgWM5ozWyjY8TPqk2tsSYJGSORs97KGOQiN9CT3GKj1Jl765wwrxt18puVfDibxyRbrtUEmlTBvZGMclPfv4/qQbb+h8nKvUHa6IING7jf2e4mIiJRzuiCjWktBMTO3iIjIneD+fcK4Bxw5coQzZ84wYcIEW1lGRgZpaWk0atSI6Ohovv32W/z8KlugVcV3333HRx99VKm8oKAAe/vqZ42vfhn6r5GXd/PZg6/mxeaeeClr8+r6eAxmgc0Xc2j5/S4WPVqPOp5Vf2eq/h8jPbMVizqb4oNLSI8ejKpe92q3MbV+Tz6N6sqO1AtYlHI8lQ54qRzwUjrgqrCr4J6k27uYxOVvQlnSALOjN8+pXuOkJJzlBZMJtWRguLSblJVf4Nj5eQD02eXB+o1OfuQXFNzWd3I1/8Vj416OuTqrhOrOTbVafdvH8H+B/+JxdKPYA9/0DObjLgHsSCzin5gMtl8uoVhfnpTndEYxpzOK+WFPIhKgkZ8jjzb05vFGPrRx8GVbxyd5P3a71YoYcJIrUZWJiwqzhZANH5LhqiJDUZeMYj17EsoTIEiAMHc7Pi+eRqOyMmnDgUwObUk/z3C+vbCPg/kppOoq/gYGi5mYf8UPclPY0du3Nv38I+nqHY6DXIE2oC7qf94Ci4mSk2uI+6Albk//jkbiiO74cpL2/EX3pN30wVTekUSK87Cvkbd7igK1BqgiQdJd5mbPzevdN6vjQTrW7/d9mdYvguWxuexLLsJSZpJ6KVfD+7nwPm0rVpYKeBiKCM1KJ8ScgZ+jK64NQ1BqMjEXpmIuSIMycdBUmM7lbx/B/cVVSBTXFrONKScomD0ModT6XUU5ezJ70Ae8Z+fCtEsH+CP5FEbBwiVNEcPkbowZNJVnds3CqzABmVnP07oV1o7UwPuTOO8ehNy7NjL3IPQXd2EpqGgpjERGk6BGtkVn5xL8nf3IUBtYeSaThfsv0j/qxqzjjGYLH+9IYvbh8uvA171r0dxLdlfuS1eOr5qw5mvk7k+0KAiKiNwU1zpnxPiCIiIidwqJIAjC9as9HJw7d44GDRrw1Vdf8eSTT/Ldd9/x+++/89FHHyGVSnn//ffx8PDg+PHjyOXX11KrsnRo1aoVKSkpldwrrua/5l4xbFh5Nqzly5fXSJ8HkwoY8tsRMtVWIc7VTs6fY5rTp27VcfeKDv5J2myrW7fCuxYRn51BqnKosu4VrvU9WwylZC6aROGuX2xll12b8KTsFXKl1gzIXzYs4pFdT4JgQaKwI/zjE6gC6lJ8ZDmpM4YD4PvENDx7Tb65nb/FMd+v3I9jru7cPH36NNHR0fdwZHeH+/E3uVPk5eXh7OrO7oQ8dsTlsiMujyMphZgslW99jkoZT7UMZlKHWkT5OLE9/RL7si8zOrwZr4+zThRJsPCx00rSpd487TeTFENlgcJB0LErbywO6NGpPIj4LhU3p4piVr5ey+n8dE7mp3Oq7H9sYRa+dk4MCmnAkNBoOvmFo5BWzlCoubCH1OnDMKtzAJDaOWOxmMFQOV6X0r8uviO/xrnpI7f0/d1tbvW+WR0P0rF+P+5LVff/nBI9q85ksux0Btsu5VZ5rlWFm72ChY814ZEGfgiCgCk/lctfdsWYHQ+Aa7sxBExYUH3m76STXP6qGxaNdRLOIaoTwZNXInMst16LK85l/N6l7MpKKG9oUDEkPpkPspagwPzvbqtE4RWKW+dnERoOwie8If5/fkSmTo2/vQs/NZzAoN+OABDgYsfZN7vgan/tmKGphTpG/n6M/ZfLJxDf7l6bz/pVHb/wTnCzx1dqairBwcEP3DPtwzLeO/HsfiM8LN/vtVj9onUSYeDM0xXKM+ZPpDQ1pqomPOpVn6PPz6nRcYiIiIiAaCFYgXr16vHxxx/z4YcfMm/ePJKTkzl69Cj169cHIDo6mlatWrF37166dOly3f5cXFxwcXG5bj2RyrQJdefIKx0Z/NsRjqUWUVRqov8vh5g2qCGTOlYOpu/SeiSFe+ejidmEMSeRnFWf4Dvii1vatj7jAmmzH6c06bitbL79YL6Xj8UksZ4ybUPdmTy6H0WOZ8hb9xWCsZS0uU9S6919WMqSF4D1RV3k/kM8Nx8ulHIpPSK96VGWGb1Eb2JvYr5NIDyaWogggMZgZua+y8zcd5k+db15uUMthvm1Yfzi/2fvrOOqOv84/r5Nd6egIBY2dnfM6ebmym1O3ea6O37rLtfp3Jyb023O7u4WCxUB6Y7bfX5/XLzAABNQ9LxfL+Dcc55zzvc53FOf5xuH8eZMWKTjd5i9iM1Bv+A7dQ5Hy+wk56qdnofBqf/ihmMwY4GkDz9+sIm3RyUwJSnKmY/MT+XGwNBWDAytqqj832qc9eHeuh8x/9tN9mfjMWYewG7U1FieLQ0iL2YsN9/1MC5RHZtVUSzx3Gz+BHqomNYzmmk9oynTm1l8tICVKUUYrDbkUgk2iwV3VxfkUgkKmYRNaaWkFGopN1gY99NunhvcijdGtkbhH0nko/+S8UYv7EYNFdt+xSWqI/6jnqy1T2P2YU5/MMwpBrq3G0bkY4uc4fEao5Udp8vYlFZC9sHWYJdBcBrIbKA08U+bYLZFv817vj6M8VFjzj+BOf845vwTWCvyHTuRyvDsdB2+g+7Dvf0wJNIqz71OfmGsyDlOnkFNj5bu3JgYyl/JeeSqjdw4ew9PD2zJkLiAWjmRAVYdL+T23/ZTrHOkMXGRS/nyhg7c00Ms+CMici1hzD6EKSsZVWRirWWCqfaAn4iIiEhDIAqC/+Gll17ipZdeYseOHdxzzz1OMRAgMTERqVSKQnH2kV6RhiHCx5XND/Vh6ryD/L4/B7sAjyw8THaFgXdGt0FaLdG3RCIh9M6vOPVCOwSLkZIVH+Ld6zZcIs/f20uwWSlZ8TFF/7yCYHG8zOskrrzk8QirVH0AiPJ15ZVh8dzZLQKFTIpywmtoDy7DlH0IY9ouipe+h8zV27lNqcqjgY6GiIhIQ+GhkjMyIcjpcZxarOPLren8tCsLtdERarsipYgVKUXOdSZU/hWQIPEKRlAXoDuwBN0jvvgHxDAyoj3jI9qj6tKe/JNznX5GS1QDKdKamT4/ma+2ZfDZ+Pb0i63b2+BChDtlQDQtXtpK7qzpqLfPpUzuxxJ5H5ar+uGf0IcV9/VEUYf4cD7sL8lhZ9Fpwt28ifH0I84rEJVMfFwQuXB83ZTc2S2SO7tVFQX5r8eNzmTlvgXJ/LbPkW7j3XWp7Dhdxu93dCEkoh3h9/9G1mfXgyBQMO8ZlGFtaxTFMeWmcPq9Idg0jqrabgkDUd7zB38dK2VLuuPnQE5VGLODMND4IY9MxermEPUK3Ap5RW5mUP8HifKo8iq06SswF6Wh8A1H7lV3lEJn/3BW5DjyHx8ozWXm+PasPlGE2mhl7cli1p4sJthTxa2dw7ijSwRdIryxC/DG6hO8vvoEZ2J1WgW4s+CurnQM865zPyIiIlcHobpUp6fgGcL1p8hxa8n73u/Wam8QZjWVaSIiItcYYqWDetDr9aSmpnLgwAHnvM8//5wOHTrQq1ev+lcUaVBcFTJ+u70zb4xs7Zz3/vpTvLAspVZbZVAsgeNfdXywWcmf8/AF7Sv7i5so/PNZpxh4UhbFJO+PWKXqQ4inii8mtOfEc4OY2iPK+aItVagIv/cXqHxZLlr4P4yZVZWLRQ9BEZErn1YB7nxyfXuyXx7GFxPaEx/oftb2UQ/8AZLK26cgYClKQ7t/EcWL3ybnm9sc+c8AiW8kXXoOdK63P0dN/y+38eWWiytU9V+kKjci7v+Nb4eto7/3j7zrMR1DWFcW3N3tosXAExVF9Fwykxnb/2bc2ll0WPgRLRe8Q6a24XKhiohUx10l59fbOvP1jR1QVn5vN5wqofunmynVm/HsfB1BE992NBbs5Hx9C1atQ8QTrGZOfzAcm7oQANe4Pmwd8DWR723j5l/2MnNzOvuya4qBUgmMbhPEn7f2QXPv08zqOwkfpSOkP1NXzoztNcMnZW7euEZ3rlcMBIeH4BkOlOQQ5u3CvMldCfZUOecXaEx8uimdbp9u5pF/DjP9z4O8tqpKDLwxMZQ9j/UTxUARkascg38Cee6tas3PcWtJtmvdFcVtYoYvERGRRkIc8q+Hfv36kZiYyMCBA5k6dSqZmZns2rWL9evXIxUrxjYpEomEl4bFE+njyj3zDmAX4N8j+bw7tnZuHf+RT1K+6UfMBanoUzYiWC1I5Of26BTsNjT7FgJgl8j43uUGvna7BYtEwYfXtWVG7+h6q/y5RHciYMxzFC96E2xWNAeXOpdJlReeBF9EROTy4Oki58G+Mczo3YJVJ4r4fEs6h/M13Nszin1fV7VzbzOQmJe3U751NqbswxizDzlDFavj4h/B7Nu68ECfGB5deJidmeUAzE/O48G+tVMfXCx/nDRjl8jwUMlYMjWpzqrs58ua3BOY7TXzqOXoK1iRc5x7W/e8VFNFROpEIpFwf+8WdIv0YeLsPZwuM5BdYWRPVjnDWwfhP+ZZDBl70exegN2gRp+yEa9uN2BI24W11FHowyWmG1FPLuOBOUexVVMAZVIJncO96BvjR98YP/rF+BNUTai7O647w8LiafPP+2gsJlbkHD/v8P0zJHhXiYUZleL5yIQgsl8eypqTxczZm80/h/PRVxYn+m1fDmcslEslfHhdWx7pF9OswvtFREQujkmv/3nW5Q/UMa/tTNFDUEREpHEQBcF6UCgUrF69mldffZXt27eTlJTE3r17CQgIuNymXbPc1T2S55YeI19jwl7PSJlErkAREIO5ILVyznmOqFXbXn5AN2YKkwFYP6MXA1ud+3+uiqgWmlz9ZVp8uBcRaXZIpZIaIcUAN35ds41ryyRcWyYBjtx/1op8TNmHyfp0HILFCICkckCgR7Qv2x7ui+zpJQD1Xr8uljPiR7SvG3GBl5amoLoXgkomx2SzVs63X9J2RUTOh26RPtzfK5rnK6MAzuh6EokE94SBaHYvcMyovM8Ktqpq2h4dxyBz9aohBq6Y3oM+MX54qM7+uBvu7k0X/3A25qdd1PlZV/EfALlM6ryWaE1Wuny8iZPFuhrnWfsQTx7tX7dXkIiIiIiIiIhIY3JNubodPHiQAQMGUFhYeF7tfX19mTlzJtu2bePTTz8VxcBrBIEqEc/zHC8RIiIiIhKJBIVPKB7th+ES063ONlKppNmND4yLbHvuRiIiVzCDWgWcUww8g4TGPUE9VHLclXULhyIiIiIiIiIil4NrSu2YOnUqGRkZDB48mHXr1hEUVHc+GJ1Ox8SJE3nyyScZOnRog+3fanWMZOfl5Z21XVlZGQaDocH229jo9VWVr7Kzsxt1XzZ1EWjNWJT6eveVV25Er3NMe2ZnI5HXHT5X/TgLNiv5lesUuZhAcCQnL8jLIVuirXP96qgLS5zryyQ2bJXT8vxC3Dwa7pg0t+8GXH6bQ0JCkMvPfqk7c27m5+fj6+t71rZXA5f7f9KUNFRfz/c6l1dhwlh5/rtWGJFXaytoikEAU5m1Qa+VNnURGKxYXIyXvN2y/EIodVQt1ruXOqfL8gvJbsBrGVzYuXmu+2Z9XE3f9SuxLxdz/z9XPyqK8qGyQEhRfi7ZHo7qu2VFZRRVnluSghLU2dno84uc915zsRpzdjbGskLQlDptUsrPb+zbWFzm/L5nZ2efV/jumb7kVxQ519UWltR7LMzlhaDRYjdXfu9NVszll37eNgTV/y8NeW5eid/bs3Gt2NuUz+7VuVaOb0NjKdeRnZ19XuemiIiIyIUgEYRrI0vpzp07eeCBB5g/fz4DBw7Ey8urXlFQp9MxevRocnJyOHbsWINVFd69ezdJSUkNsi0REZHzIysri4iIiLO2Ec9NEZGmRzw3RUSuTMRzU0TkyuR8zk0RERGRC+GaEQR/+OEHFAoFd911F2lpaeclChYUFBAb23B5XYxGI4cOHSIwMLDe0Z28vDySkpLYtWsXoaGhDbbvxkS0uWkQbb44zmc01Wg0smbNGq677rpmdXwvhivhf9JUXCt9ba79PN9z81z3zfporselLq6Wvlwt/YCruy8NdW42t2Mk2tu4iPZeOqKHoIiISENzzVxRpk2bht3uSIoeGxvLhg0bGDhwYK3wYa1Wi4eHB+7u7g0qBgK4uLjQvXv382obGhra7EaARJubBtHmhsfFxYVOnToBV76tDcW10k+4dvp6NfbzQu6b9XE1HZerpS9XSz/g2u3L1fxMK9rbuIj2ioiIiFw5XFNFRaTSqu6eEQXVajWDBw+msLCQX375hUGDBnGNOE2KiIiIiIiIiIiIiIiIiIiIiFyDXDMegnVR3VOwe/fu2O121q5de16JpEVERERERERERERERERERERERJoj15SHYF3ExsbywAMPYLVaWbt2LfHx8ZfVHi8vL1599VW8vLwuqx0Xgmhz0yDa3Lg0J1svhWuln3Dt9PVa6eeFcjUdl6ulL1dLP0Dsy+XcbmMh2tu4iPaKiIiIXHlcM0VFMjIy8PHxwcfHp8b8X3/9lRdeeOGKEANFREREREREREREREREREREREQam2vCQ/BMVeG1a9fWWhYWFiaKgSIiIiIiIiIiIiIiIiIiIiIi1wxXvYdgWloagwcP5sUXX2T69OmX2xwREREREREREREREREREREREZHLylXtISiKgSIiIiIiIiIiIiIiIiIiIiIiIjW5agXBK1EMtFqtZGdnY7VaL7cpIiIi1RDPTRGRKxPx3BQRuTIRz00RkSsT8dwUERG5EK5KQfBKFAMB8vPziYyMJD8//6ztSktLm8iihuHGG290/jQnzvc4Z7w9gKN3STh6l6TeNoV/vexsozu+uaFMrEVz+25A87D5zLl57Nixy21Kk3A5/yfHprlw9C4J6a/3PGu7rM/GO88pm678ovfXUH290q9zzeE8uxjO975ZH1fycen52WYkTy7G5dmldS73f3kFIx56znkeHL1LwpIZ/khmPYVk1lPcv21BrXV6L/kcyaynUM5+9oJsSX+zr2MfU+QA6FI2OvdZ+Per9a53MefFlfw/uVCu5b40l2fa/DmPOr/LxsyD52xfn725P013bseUf7KhzbxoLvb4Xq572uX+Plwozc1euPT75n9pjsfgvzT3PvzX/iv9mfS/NPfjD1dHH+rjqhMES0pKrkgx8EK4ytM6XjE02nFuxP9fc/xuNEebr3aupf/JtdLXa6WfF4p4XK48rqb/idiXy7fdxkK0t3ER7W1+XA3HoLn3QbT/8nM19KE+5JfbgIbG39+fefPm0aNHj8ttishlxm7SUb5lNubCU8g8/JF7BCDzDEDmEYDcMwC7RYrNTQl2K4LNCnYbQuW0YDGiP7kVbfJyDGm7Lmi/p98dSPxneci9gxupZyIizRPtkTUIVssFr5fz3WS8kibh2WUcMlevRrBMROTyYRcEbHYBmbTKC11vtmKy2lEI9Z8vFlvtcDCD7cLPL1P+SSwlp89ioBh2JnJlIVgt2Ixq5B7+Z29nt2EuPNUYFjTCNkVERERERJqeq04QBEQx8BrHZtBQtvZLSlZ8hE1TfNa2RRewXYV/VL3LlEEtqz4IAumv9yTy8SW4RLS7gD2IiFydWNVFFPz+BBXb5jjnyX3CzrqO3C/SOa09sATtgSVI5Erc24/Au/cdeHW7AYnsqryFiVwjhHq5AGCxCfy4M5N7e0VXfrZz8y97MZuMTDP8VWMdP7MeqWDHLpGyIGUrj6dvpWXfO3GJ6cYvqXs4UJoLQJS7zzn3L9htlKz4hKK/X0awGAGQ+4Q6/nqHONtVbJtDwHUvIlW5XXKfRUQuFc3BZeT9fB/W0mzc2w3Dd8gDeHYaW+t+YDOoyfn6NrQHK0PyJVJknoEXvV+Zu69z2pR1CFVI/EVvqzE4UaRFIZUS4y+epyIiIiIi589VFzLcEFitVlasWMGcOXMoLCy83OaInCc2fQVF/75J6pMtKJz//DnFwPNF7h2Cd9+7iXxiWb1tvHvdRsjkL5BVegVaijPIeLM32kOrGsQGEZHmiCAIlG/+mVPPJdQQA93bDydk8hdnXTdo4lv4j36mhhAvWM1oDywm56tJpD7dkpLlH2HTVzS83TYrhox9lK7+goI/n6di228Nvg8RkWcHt3JOP7/sGCU6M4IgMP3Pgyw9VsgD+t+Jtzk891SRibgPfZwArwAm5h0CQC1X8UZWCumvJbHytZ48sPVP5/Y+6D623v0Kdjv61O2kv9GbwnlPO8VAZWhrIh9Z6NhfaGs8u1wPgKUkk5LlHzZo30VELhSbroyc7+8m6+MxWEuzAdAdWU32zAmcfCqWokVvYa0oAMBcmEbGG72rxECZgrBps1D4nn0g6mx4dKw6p9S7a+fvvJz8eSCXNu+tJ+7ddfyyJ+tymyMiIiIi0owQ3Sv+Q3p6OuPGjSMnJweDwYCrqysbN26kQ4cOl9s0kXqw6cooWfkppas/w15dHJDJ8elzJ9597kIw67FqirFpi7FpirBqijGU5KCQ4hhVlsor/8qQVE4rg1rhnjgSl8iOSKRn184lciV+Qx/EK+kmsj4bjyF1O3aDmsyPRxMy+Qv8Bt/fyEdBRKTpEew2cn+cinrnHwh2e+V5IgGJFCSO8EfBpHO2l3kGEnLbJ3j1ug2JpP4iPQAyVy+CJ71H0M3vYkzbjXr3fNS752MpdggklpJMCv54iqKFr+EzYBp+wx5BGdiimm12LMUZGI9upagiA3P+SaSunsi9gpF7hyD3DkHm7ZiWylUYMvZgSN2O/uQ2DGm7EMz6GvZIGI+AFAkCRf++iWurnrjGJokhzCIXTc9oX+5JiuSnXVmU6i28uDwFHxcFs/dk08FynKmGvwGQKFyIeGAeWlUgUbd/yPuHVrFy7yoqJFLmhyZyXf5RXgtog74yv83dFjXD1LkI9rZIpDIALKXZ6A6vRnt4Fbqja2oOmEll+I96msDxryJVujhnB9/yEdrk5QhWM8VL38Wn391n9ZQXEWksNPsWkTf7fqzlec55Mu9gbJUCoLU0i6K/XqJo4Wt4drkefcoG53dc5hlI5CP/4Bbf55JscIvv49yn9uAS7GYDUqXrJW2zIUjO13L3H4exC4AgcNfvB9CabDzQp8XlNk1EREREpBkgCoLVsFgsjB07lltvvZUXX3yRsrIyBgwYwMMPP8yGDRsueHtqtRq1Wu38nJeXd5bWIheKIAiot88l/7dHsWlLqhbIFPj2vwf/Mc/VEAj+S0lJCf7+Z88/c6HIvYKIfnYduT9MQb3zD7DbyJ89A3P+CYJv+cD5ciZyeRHPzYah8M/nqNgy2/lZsNXf1qffFIJu+eCcOZ/+i0QiwbVlEq4tkwia9D6Gk1spWfkpmr3/gGDHbtRQuvITSld9hme3G5C5+2HKSsaUcxi7UXuxXTsLAgV/v8zMmL4c9Q5jUkJfpg+7Hxe5ohH2de1xrZ2b745pw9+H8ik3WPh2e6U3oGDiHe2nyLADDm9ZVVgC2pISJFIp0R1H8qbCg4d3LkSQSJjaeRJmiWPQqp0mn0f3/UHm1u+R+0Xi0W4ohlM7MeUerXP/qshEwqb+hGtM11rLlMEt8RvxBCVL30UwGyiY9ywRD/zeSEdC5ErncpybVm0JBXMepWJ7lZe2zN2PkMmf49XzVvQpGyld+6XjfmC3gc2Cppr3niqiA5GPLTrrs+D5IpHK8Op6A2XrvsZu1KI7vMrpRXu5KNKauHNBCgaLvcb8B/8+hNZk5ZlqXsgiIiIiIiJ1IQqC1Zg/fz4tWrTgpZdeAsDPz4/nn3+eu+66C6vVilx+YYfr448/5rXXXqs1v6ysDFfX+kcVqz9wNTdKSkrO3agBsJXnol7wJOajq6tmypS49pyM++BHkPmGo3EYVO82Guo4W2x20suMpBTpSS8zOgSMmBdoZ/ClZfLXAJSu/ITsk8mE3fM9KreL9yhqjt+Ny2lzfYJvfeemRqNpsu/w5aQh/ieGHXNQnwkjlClQRHQEQUAQ7IAAgh0EAalHAO6DH0YZ158KE2C6xOPr3wa3275FOeJ5DJu+x7BrjsMLUbDXeBG8FPJVkewgjgOKBHKkwSRY00BbdcwWhHbg+2hHrtqt+ad5fe7LTGvViyktuuB/mfKsNbdrw4Wem+e6b9ZHUx8XS+5RtMveRCKR4tp3Gsr4AWf1hpUCz/eL4NlV6c55j+rmEGPLAUAR0xOh6x2UlJTU6MtNga35yjOQY5oipxjoCXycuQtlpTJvLc2ifPOsWvuUuPuhjB+AKmEoLp0noJcr0ddz3ZP2uQ/p5lnY1QWod/5BXvfbUcb2qrPt+V47m9t39WxcjX1p6HPzYo+R8fAyNPOfwq6pSt2j6jAWz4nvY/UMorS0FII64HbrN6hGv4phx68Ytv+CXZ3vaNtuJF63f41G6nnWZ0FwPMf9uDcfN4WMoZHKetsJ8cNgneO5rmjLb5ij+15U3y6WPKMGGVKCXNyx2OzcMPco2WozAL0ivejXwpv3NztChp9deozCcg3P9Y88p0d+Uz73NLdz5kqyt6GdGERERERAFARrsGPHDh555JEa8zp06IDVakWtVuPn53dB23viiSeYNm2a83NeXh5JSUn4+vqe86LeXC/6jW23IAiUb/ieonlPYzdU3aS9+9xJ0MS3UfiFX9D2ztdes9VOntpIrtpIVrmRlEItR/I1HCnQcKJIi8VWV8W5UYz1cOEN7ecoseKWtpbtr4/i0JifmT6oI+HeFxdq0hy/G1eazfWdm56enlecrY3FpfRTl7KRgr+edn4Om/IdPv3ubgCrLgB/f4jviu3Wdynb+D2lq2c680ohkaIMicclogO2gFb4xfdAGdYGwWzAWlGAtSIfq9rx11ZRgM2gJl0ZzezCMBaqIymTejt3o5RJ2WbrzAR+RgLYkPJWq+E1TCm2WXn3+GY+S93B3XHdmNyyK538wnFtYq/Bq+G7eyn3zfpoiuMiWC0ULXqT0iVvQ2X1X9ORFbhEdyFg7HN4dp9Y70v5k8P8+P1wCQdy1XSxHOFO4yIAJEo3omfMQRkYVGdfvuh9A0NWfuv8/OPAyQy76z20h1ZRvulHNPsXgc0CMgVucX3waD8c9/bDcYnufM40GFX4o5j0Prnf3wWAYfErhPxvd53e7hdynK+G7+oZrpW+NNUzrd1soGDuE1Ss/8Y5T+YZQMjkL/FKuqnu88jfH2LfQ7j5TbSHVyJYjHh2veG8v+eP/3uYtWtXIcXOm+7xTO7Rksf6x9LCr+YAj5B0HZo5/ti0JZiPrcLXywOpQnXefTsfzDYruXo1BUYNBQYth8vy2VWcya6iLPIMauQSKR8njePoUU+2Zzmeg6N8XVk4tSdBnipC/bx4/N8jAHy0NRurVMEn17c7qyjY1N/h5nbONDd7RURERC4EURCsxttvv42Li0uNeV5eDm8uQagSfEpLS89LHPTy8nKuL3LpmAtSyf1pOvqUDc55cr9IwqZ8h0fiyAbbz/7sCn7Zm8WJIh25FUZy1EaKtOaL2tYSl0HkyoKYqX4bX0FDG/NxbIsnk7TzHWbe2psbEy8+wbXIxSOemxePYLeT+92dDqEB8B/9TNOLgdWQufsQMPpp/Ic/hiFtJxKlG6qwNs7cTiUlJXie5WH+VLGO6fMPsj610kOi8v2xU5gXLwyNY3z7EHacLuPTp38GwOQiw1qphbQvLiPWmsuyoASsUhkGm4WvU7bzdcp2vJUufNFzAne0rB2KKVI/zeXcrDBYKNVbiPZ1RSqVkDf7fso3/YQA6GRK3G1mJIDx9D6yv7wZ36EPEXLHzDpfymVSCfPv6sbzS4/x9P6nkOB43gi+5QOUwS1rtT/D4LA4egVGs73IEWq8OOso89IPoLda0LcajDayJyqblSkJvZnSpi+y8xYBa+Ld+w5K136JMW0XxtP7Ue9egHePSRe1LZHmS1Odm4Xzn6esmhjolXQzIZO/QO517grBErkCz071F9Spi6wyAzlrvucP9UwATBUKDi2O46vV7ejebxQTxl6P3MPxzC+RyfHsOoHyjT9g11eQ/noP/Ec8gXfPW5DI6/csrI7FbuNAUQFHS4swSHRk6srJ0JZxWltGhraUPL0GgboGmR1YBTuP7FwIVjlE+KHQBfLr7aMJ8nQIk4/1j8VDKePeBckIAny2OZ1Yfzce6Rd7QcdFREREROTaQBQEq+Hh4VFrnrTyAdpud+TnWLRoEY8++ihHjx69qPAlkQtHEARKV31G4fznndUQAXyHPEDQTe9iVbiRpzYS4qk6Z1hEfZisNv5KzuOLLRlsP1123uu5KWW0CfKgXYgn7YI9aR3kgVwqQW+xYXD+tGNvUWeSVt6Jl6mQ9tZU3i98mTt/fo31fdvw4XVtcVE0Xm5BQRBI05SwNi+Vtbkn2VqYQZxXAN/1nkic97kfsEVEqmPTFmMpyQTAtWVPgm565zJb5EAiV+AWf/7hWxabnY83pvG/lccxWqvyL/WN8eOFIa0YmRDkvJ7EhSgwKaWozHbslfOkVheOFoziubKXeSxtC79FdGZBbF8qrI7BgwqzkcmbfmdTfhqf9Rjf5N6CIo3DrswyZm5O44+Mfdhcy5EpbPgrKvCw2invPYMKhQs2iZQohYq3c/fT+chyAMrWfIHM1ZugiW/Wud1WAe78fn0EJ9adAMC1ZQ98B9VfjOpERREv7F3mFAMBfj21t86223YtYubJ3bzUfiQdPKMo01soNVgI9lDRLdL7nPdNiVRK0A1vkPnhCAAMp3aKgqBIo2HTljqn/cc8S/DN7zbq/j7dkMJ92rnOzyosdLMepZv2KCyfz4nlIAttS/Dop/DpPwXv3pMp3/gDAKbMg+R+fxcFfzyJd5+78B0wFVVYGwAKDRr2l+aypzCPXfm5pJQXkWMsQyfoQFK/4FcfARIJakHAOTwtt4JPIRafQoZsPMaA4y25sUUHJrfsyrSe0Xio5Nz+2z7sAry9NpVpPaJwU4qvfSIiIiIiNRHvDOfgzIOyIAgsWrSI++67j2XLloliYBNh01eQ+8MUR8LoSpTBcYTe8wPuCf3ZlVnGTb+sJ7PMQKCHkqRIH3pE+9IjyofukT74up19xDarzMA32zP4YWcmhXV4AbopZYR7uRDm7eL8G+alIi7Qg3bBnk7vkHMTi7nvVtLe6o+9Io/O1hS+VL/J/VteYVtGKfMmdyUusLYgfbEUGjSsyT3pEAHzTnJaW1PkzNFX0HnRJ3zW43ruiUu6aCFV5BrEXiWeKQKiLyD0sPEQBIH9ORVszygjyteVEa2DUMrrt2t3ZjnT5x/kYG5V2oG4AHe+vrEDQ+KrRHK7YOf74zt5bu8yesikqCqLPIwIb80bHcYyKG0/xVJfOptTeCJtMx88/Dv/luSyOOsof58+BMD3J3ayqziL+QMniwJ8M8VktTH/YB6fb0lnV2Y5+OZC+EkAbEAhUKiq6YWaaTExObAddw/qzZMbXkUi2Cle/BZSN28CRj9dax8AhtP7ndPubYfWeW4VGDS8dmAV3x3fiU2w11peHakgwy5x5BM8VJbHpM2zQOML+S3B5A7ApE5hzL61Eyr52QelVJEdnNOWktNnaSkicml4972Lim2/AmDMqFvkbihKdGayN/xKqL2yInFIa+x2AaHwRI12tryj5P54D3vKFAR1H0fIw0vQr3wP/YnNAGh15eze9jvJhzewP6gt+z1CKJHWc37W87glFewEm7SEGdWEmDQEmHUEmHWEG9W01+QTZnTcrzb7xfB3cCKb/WIwVg4mWwU7a/NOsjbvJM/vXca0uB483LYPd3SN4Jc92RRoTHy/I5NH+4tegiIil5MZC5I5lFd/XsoOoV58PTGxCS0SEREFwXNyxkPw33//5ZVXXmHZsmV07tz5Mlt1bWDMPEj2FxMxF6Q6Zkgk+I9+hsDxryJVuvLjzkwe+OsQZpvjoatIa2bpsUKWHqtKQB0f6E5cgDsCYBcEbHYBuwA2u4DWaGJfrhb7fwZqu0Z482CfFoxvH4KPq6LBxDJlcCtinl1DxjsDsGmKSbIcYqb6bR7Kfokun2zi3ylJDI4LuKR9FBg0vHlwDd8e34HFXnfJV7lEilWwo7OambZ1PkuzjvF9n5vwd3G/pH2LXBsI1UUIyeUTA40WG+tSi1l8pIAlRwvIrqjmPeyqYGLHUG7tHE67qnSAaE1WXl6RwszN6c7zXi6V8PSglrw8LB5XhYwyk551eamszDnOypzjZOrKa+xXZbaxcNg0JBIJTw5Qo1pQNZDg7e7D3X7h3B3XnXlpB5i2dT5aq4mDpbl0XfwpP/W9mYktOjbmYRFpQDJK9czalcW3O05ToDE5Zqp0EHqqRjupYMfbYkRphQIhBKR2cNUiIDBLKGdN+0dYeOQLXOxWCuc9w9ZsPUdjb6XMYKXcaKFMb6HcYKH/6YXcWLlNl+iazxkai5H3UjbzVdoudNaq75yHxB1ZcQsqSl3BLqv8kYIgxY4EXNUQcgrcK19APMvAYw+UhUBhC+YdyCVfY2LhlO74uNbvxSr3CkaiUCFYTFiKMi710IqI1It728Gowtpiyj2K7sgajNlHcIlo1yj7+nJLGndoqopRRd0/B71XDD4qCVs3LGPVqiW00R2kszUFAMU/j9B/g4QKqRe+bs8T13EcRS7pZLqosNW4H9YtBnpbDEQbyojWlxNpLCfcUEGYSU24UU2QSYui8v5qdA1EZlKjsJtqbaN/aTr9S9OxSiQc9ApjU6sBbPKP4YTZcQ+sMBv56MhGPjm6iWHBbcBNCXov3lufyr29onFtxIgUERGRs3MoT01ynobEUM9ay5LzNJfBIhERURA8J2cEweeff57Vq1eLYmATUb75Z/Jmz3CGCMs8AwmfMRePdkMxWW08uiCZb7dXeSm0DfagzGAhT13z4elEkY4TRbpz7k8pkzKpUxgP9mlBUpRPo3nMqcLbEv3MGjLeHYRdV0Zfy34+0rzPEzzLfQuSOfbMQOSyCxdZyk0GPjy8gU+Pbq7xsgjgLlfSPziWIWGtGBIaR5xXAM/tXcYXx7YC8E/mYXYWZzK73y0MDYtvkH6KXMXUEAQv7jyx2wVm7c4iV21kSKsAekT7IjsPT9vMMj2rTxSz5GgBq08UoTPXLXqXGSx8vyOT73dkEuKhZFCiC3mydHZnl6HTS8BfATYFrXy9eWFAW2IDlLx3eA2rck6wszgTu1A7nEtRGVYstwnO68OTA2NZ9LfF2eZ4qZU2oY7pSbGd6OwfzsT1v3CoLA+NxcRN63/lkTbpfNB9LEqZePu90ig3WFifWszqE0WsOVHMyeL/3DskNlxjj2Oo9Px5KLwVt897HA+rEYnSg32TVrFb48n+3HJ2FB3EGpAOEsjylzGs64PMS/6JMJOGuK3/Q79zLovdbme7opPzPBqpPurc1fP75dwbXkFiqBc/p+7muT3LKDRqncuVKLEWRKAtDgOh7hd8iQQiVEH4m8OxKYtJVxxGi9bhoeSXDz6FUBbKxiwDfb8ws3xaDyJ9645+kEilKPyiMBecFD0ERRoViUSC3/BHyPvZETJftuYLQu/+usH3ozNZ2bfqdybaHFV55a0H4xrTDX1JCTIPP/qPvYO2A29i+p8HKd7+GMPM2wkUynhF+zVP+j5KWcBJdnmVArXPGU+rkQ7qfNpr8mmpKyHKUE6UoRwfq7FWW6vMhYPyeJa4JLBfkcBBeQJqqQe4g4tgwteuxltQ42tX428vZ6Swn4HGbchtZrpW5NB171weB9L9W7Cg8038KcjQ2yzYBYGV+UchFtB7klcSwTtrT/D6yDYNfixFRETOn8RQT7Y8XDvFTd/Pt1wGa0REREHwnPj6+jJkyBA++OADUQxsAuxmA/lzHnHmZwFwbdWbiAfnofCLIKfCwMTZe9lRLc/f0wNb8vboBGRSCdnlRnZllbHzdDk7M8vYk12Bvh7RAKClvxvTekQxtUcUgR4NWynuDIUGDT+n7iG5NI+kwEjubNmN6KdWcvr9odgNaoaYd/Ku5mO+tt3CX1u9ualnO6RKl3NvGNBbzXxxbCvvJq+jzGxwzvdSuPBgm96MjmhDUkBkLfHh854TGBWewJQt8yg0asnVqxm28jueaNeft7uORiWKFSL1UU0QlFyEh2C+2sjkuftZc9IRovUKx/F1VTC8dSCjEoIYmRBEcGVy9BKdmfWpxaw9Wcyak8Wk/legqcRNKWNE60CGxgWyL7uCBcm5VBgdlV7zFRn8Xp4KUgHccfxUkgrcs3t3vba6yRUMDm3F8x2G8NGSJ2st93JREOslgSIwI+fNVSdZcFc35/J470B2jn2Eh3f8w48ndwEw89gWluek0C84lkTfUBL9QungG0qA6KF7WUgt1vHz7ixWnyhiT1Z5LY9xAIVMwqROYWj8j/JvrmMEv7t/ODPWfw6VL/ghk95l8tBeTK5cx2LrzZfJe3k++R+MdjOl7nKu6zaVbw4voHtFNh2tJ/hB/Sp75G353P0O9ija08aWBoBW4srXKfBV+gr8WmVQKi1y2iJFir04DHNRFNgcHn2eKjlJUT7EBbgTV+kV3yrAnVh/txqhwGbbeL45vp3XDqym1KR3eDL654BfDkfUAXT5tpC1d44gMayaW2314xAQjbngJDZtCXajFqlLw6W5EBGpjnfvyRT8+Sx2fQUVO38n+LZPzvu56Hz5aWcmk8r/cH4Ou/6FWm0CPFT8PaU7h/vNwfJxD2T6YtT+GpRxOzFXu/1JjB4ESgNI8AhjuNLC0PxVeJ1cg2CocLaR+4Si8I9G4R/l+AlogWtsEi5RnWhpk2Dcn8PGrRmoq6WyQOFKdHgI3SK86RbpQ7dIHxKCPBD0pVRsm0P5hu8x5TgqCseUZPD0mg94ossNLBs4gy9StpOtr9y/mwbcjvHG6XSkewbzdMc+DXosRUREapL38wyM2YdqzX8mT022ayxw/jmvRUQaG/Gt/xyoVCrWrFlzuc24JjAXpZP9+Y0Yq+VR8hv+GMGT3kciV7A5rYSbftnrDN1yU8qYNakTN3eqqtQb6etKpK+rs3qvzS6gM1uRSSRIpRLHX4mjqmNpaSn+Z6k+erGozUaOVxRyXF3Ekqxj/H36kDN897e0fTy3Zxm3xnbm9mm/EvLdbWDSMcq8hVHmLfAjpPwIEqUrMjdfZO6+KIPjCLzxDVwi2jv3obOYmHVyN28nryPPUPXw6CKT83CbvjzbYdA5Q4BHR7bh0Pgnmbr1T5ZkHQPg4yObWJuXyh8D7iDBJ6jBj41I80ewnztkWG81syjzCFsLM9BbLfQPjmF4eGsOnDZw9x8HauXrLDNYmHcgl3kHcgHoEuEQJPbnVFCHsx4A4d4uXNc2mHHtghnUKqBGYZ4vb2zPwiM5vLB/KWnCqbo3UA9d/MMZHtaa4eHx9A5q4RTHP6qnfZDKkeTdIFHxV3IeuzPL6R7l41zuKlfwQ9+b6Rccw4ztf2OwWTipLuakurjGdkJdvUj0C6W1VyCxnv4k+ATRxjuISPfG81i+1ll0OJ9bf9tX56CRSi6lX4wfw1sHMrlrBJtLjnPzhgMAeCpUfGEuhVyHR59rXB98B8+osb5CJuWxzt0ZFRvN+LU/k1JRiFEhY2rnSdxRnE63vIOEGytIMKYyu+IFVLFJmIpzEYAt3h0QgjIhMJNSabUToDwIe0EMWBzCSIC7ksf7x/JgnxZ4nyXc9wxKmZxH2vbjzpbdePfQOr5O2Y7aYnR4DHoXU+xdTJd/U3iz6wieS+pRa31FQAvntLn4dKOFcYqISFVueCVNonzDd9j1FWj2L8K7x80Ntn2Lzc7KFf/wvrUyV2BEF9zbDq6zrUQioUNcLLsnf8aDO/9lt0+kc1mkuw/vdx7HzS07/Cef9CTsps8x5RxB5uGP3DccqaL+QWd3OUzvGc20HlHszirnVLGediGetA32qDtqxMMf/+GP4jfsEQr2r8Z+YD4V2+YgWIzI9v3Nbdh57P7fWJhzgk+ObmJnkaMQGEojrx1axucnNtBbLkVpPXseUhERkYvDmH0IU1Yyqsia+QDD9Rf2TCoi0hSIgqDIFYFgt5P16ThM2YcBkLp4EDb1J7ySbkIQBD5Yn8rzy1KwVbpvtPR3Y+GU7rQP9TrrdmVSCV4uDVPds8SoY3XuCTbmp1Fq0qO3mdFbLRisFvQ2C3qrmQqzsUZYV10YbBZ+OrmLn4CYgU8wInUjY/IOE6uvqqwnmA1YzQas5bmYco5gykuh1bvHKDMb+PLAKmYe3UKJSV/VT4mUafFJvNxxGOHudXt31EWQqyeLhtzDN8e38+SuxRhsFg6W5tJ32ResHzmDDn6hF3ycRK5u7MZqOU6qCVWCILCzKJNZJ3fzR/oBh9BQyU+V3nEY3cHDF/AlQhHCcwPj2ZFZxsrjRRRVEwn3ZVd5VZzBRS6lb4wfQ+ICGN46kM7hdVdHtdntzE3fy0spK8gVqsTyRHk7prdOoku0G6VmAyVGHSUmPSUmPXqrme4BkQwNiyPItXZel7NicXjmughmEqxpvLwikBX39qzV7K647nQNiODB7f+wrTAD638KQuQZ1OTlqFmZc7zGfHe5kgTvINr6BHNLTCdGR4rhXg1Bic7M7XOrxECJBLqEezM0LpBh8QH0jvFz5tqy2m08uPRv57ofenjgsfBFx3pyJWH3/FBvcZ3W3kHsHPsIkzf9zqKsI9iA2QExzA6IcbbxshgIN6oJ7BDOcY9AClSeQLWwXJMr5MaDzgeACG8Xnh7U8qKrhvqoXHm32xheSBzCTyd38fHhTWTpywGwuah5/vB8At1cmNq+Zr5LhX+0c7p8w3eE3PHZBe9bROR88el7F+UbvgNAvXt+gwmCZqudaX8epH/xYue80GH31zvwklyay9vJ6/gz/SBCNTHwbomVmROewlNRt+eiVOWGa2z3C7JNIpGQFOVLUpTvebdXRHfFv8twvPvcSeZHoxBMOjT7FmJ+szfX3/cbk8Y+wrqcU4z99y8MLoUggVKTHotCFARFRBoTVWQiMS/VDAM+9GD9BUNuO/0hEYY00t+s/W5rtVoxt+jcKOkTREREQVDkikB3ZLVTDFQGxxH5+GJUoa2x2QUeW3iYL7ZmONuObhPEb7d3OWsC9IbAarexqyiLlbnHWZGdwu7ibATqcVc6C2FuXkyL78Go8AT+Op3MTyd3O8K1gHSTnm8iu/NNZHd8jGbiK8oZYiljvL0YX00hliJHCFmuSc/Xuxbxbcp2dDZLje3fEtOJ1zuPuOgKphKJhBkJvRkY0pLbNv7GgdJcSkx6hqz8hg2jZtDWJ+SititydVK29kvntCq8PSVGHT+d3MWsk7s5VlF4ljUBF53jJyCbIukxfis/QWiIFzdEu2OzKMgttXMy38zJfDMSq5KuwUEMjwthSFwgvVv41vAC/C8ai5Fthad5bs9SDpTmOue7yxTM7n8rN7ZonKptqqiOmAtOosLCzxUv8MDhl9mTlUC3SJ9abdv7hrJx9AOYbVZSKgpJLssjuTTP+be6t+8ZdFYze0uy2VuSza+n9vJgQm8+ShonhvVfIgdz1WhNDjHwurbB/DSpIwH1pI04Wl5AkdERrj7crKHvP1X+ogHXv4IqLOGs+/JSuvDPkLt448AaXjuwutZ9RK1wRa1w5dh/1pNLpIwPTiLjRAB7dBpifF14cVhrJneNOGsV7fPFS+nCY+3681CbPsxLS+bhzcspoxQk8ODWRdwQ2wZfN6WzvXu7oRT9/TIApatnIvcRB4xEGg9VWFvntGA6dy7o86HCYOGGn/ewLrWYZyVVg6fFS97Bs/M45N7Bznk7Ck/zdvJaFmcdrbGNFvpSXj++iuG9b61XDLwcuLfuR9STy52ioCnzIOn/60rQze8xcMhDxGi7czSrEAKzwDf/cpsrIiLyHyIMaZUehLVTlFlzj2CUi899Io2D+M0SuSIoWfmpczr49s9QhbbGZLUxee5+5h/MAxweHG+NSuDZQa3+E5pxaQiCQK5eTarGEcaXqi4mpaKQjflplFfLy1cfCqkMN7kCN5kSN7mCFh5+JHgH0to7iHY+wfQPiUUudQgZPYOieaPzSP7NPMJvaftYnp3i9BQqd1GyyyWIXQTxDq1p7xNCpyPL0UvlLA5ph+XIphr7vLNlV55sP4A2PsF12nWhtPEJZsvoBxm9+kc2FaRRZNQxeMW3bBw1g9beYviwiCNMsGzTTwBI3X3ZHj+Qe/5+n+L/vKx5K124ITKRbQcVHC/UgnsFeJSBmxokDjHEZLeyvaiO4gSuQAwIwB4gvdyNZUd9iDztQ5S7D5HuPhhtVrJ05WTrKxx/dRU1PBLPMCmmE8/E9qJLVMsGPhJVhE39kSxNMfqUDXgKer6veJX585R0e+qJetdRyuQk+oWR6BcG1UwrMepI05RwUl3MsYpCjpUXcKyikJPqYmfagS9TtrGzOJM/B04mxrPhUx5cjVhKstAcWIzcOxSXFl1Q+EdxuqzKw/q6dsH1ioEAe4qzndPdTld6u0ok+I95joCxz5+XDVKJlFc7D+eOll3YU5xNhraUDG0ZGdpS0jWlZGiKMQkCnhIJgyLaMiSsFddFtiXG0x9hpEC+xoTcrCUw4NIq0deFXCrj9ladmRidiP/sd9DJyjEpK5i2fD1/3TjC2c6tVU9C7vyS/F8eBKBw/vPABBwxxyIiDYulNMs5LfeLPEvL82NzWgkz/jrEkXyHl/sPPncxSZKJKu8AlqJ0Mj8dR/Sz69hYlM4Xu/5kfX7N0L5wN2/uSdvMhBPrUAl2fAbee8k2NTTurfsR+7/d5HxzO8bT+xEsJgp+e4zTW/+huOJukPkzxK036/jncpsqIiJSBzluLen6Uu3iIif/VzvyRESkoRAFQZHLjin3GLpDKwBQhrbGo8MI1EYLE2Y5RnHBUQV4zu2dualj2Nk2dd7k6it4/uByDqgLSNUUo7dazrlOt4AIRoS1ZkR4a+K8AnCTK3GVK1BI6/daqgsXuYJJsZ2YFNuJYqOO+RkHWZR5hFXZqdglVbmsDpfnczi85iiRu0zBfQm9eKLdgAsKDT5f3BUqlgy7h5GrfmBbYQYFBg2DV3zDxlEP0Mqr4V9ERZqeUr2Zg/lajIVW8tUm8jRG8tUm8jUmdGYbEzqEMK1HVJ3hUyVL3gGbBbNExjd9Z/Dt5qqE7BIkDA2LY0pcd/r4xzH2+z0cz9MAPkgNPjycMJAnB0ezvzyT1bknWJVzgpPq4nN63Z4J663u9XcuegVG83HSOHoGRVNSUnLe610MMlcvop5cTtZXt6Db/y8umLn10NMcnW8iokU8NkMFdn2F469Bjd2gRhWZiN/g+5HIlTW25e/ijr+LO90Do2rMt9ht/J62nxnb/0JvtbCnOJsuiz5ldr9bGBcl5nE7G4IgkDVzPMbT+5zzZB7+RHu05nFdKEflLYm1BSBYw5DIa3udC1YLm3YucH5urylA7hNG+H2/1ptz7Gy09AqgZR3XUrtgp9RkwEfp4hxAOoNEIiHUy4WSkobxkqoPlULG1/2u485tvwLwb+5+SnSD8Hev+p76DXkA7Dby5zzisA0B4RyCYE6FgS+2ZNA22IPbukQ0XgdEriqqC4KKSxAED+ZW8MKyFJYdq/JgD/FUsXRaPzp49iH9jV6Yi9JZVlHCD78+w0F5zarBLT39ebbDICboCilc9goAHh3HoAqJu2ibGhNVWBtiXtlB4T//o2TpuyAIuGRsZKFkL697zOCRAU+yd9+V49koInI18pJ3DMcVrrgs/aLG/NLW3Yk2aBl3mewSEakLURAUueyUrprpnPYb9igFWjOjvt/JgcpKa54qOQundGdw3KULUoIg8NPJXTy5ezEV5toeRdUJdvVkeFg8I8NbMyw8nsBGqKgY4OLOjITezEjozROLDvHJ7oPgXka7VjZOaHKwVIolfhIJj3Uazq3BbWgV2rgvVJ4KF5YPm8bwVd+xsyiTXL2aQcu/ZuPoB4gVPZKaLWqjheeWHuPb7afrrKR6huUphfx9KI9ZkzoR4lX10nDGOzDD1Zen2o/jmMnkXHZTi0Q+6D6WaA8/CjUmhnyzncOVXhjRvq4snNKdTuEOATvSq51TxLLZ7ZSYdBQatRQZdRQatBQaHT85ld5/mdpysnTlGGx1i/beShci3LyJdPchwt2HUeEJTIhu36SFOKRKF6IeXsC6d28j9MR85NhhyQtkn2Udzd6/iXj4L+Qe5z6nFFIZd7bqRreACCau+4VjFYWUmw1cv3YWT7UfwNtdRzdcZ64ybAUnaoiBADZtCSHabUw7M+O79zn2vRSFXwSKgBYoAmMcf/2jKFv/LXt9WoFXKDLBTtfY7sRO+xG5Z8MOkEgl0iui0vTt8R14eIcHFXYtNvdi3tpwmI/HdKnRxm/Ywwg2KwW/V/eCrfuicqJIy9BvtpNV7rjfvr/+FC8PiODmRijoJXJ1YS2tuoIq/C9cEDxVrOOVFceZuz+nxvxukd4suLMb0X5uAEQ+vpR7f32CX4NrDq609w7mhU5DualFInKpjNPvD3Mu8xv+6AXb05RI5EqCb3obj8RRZHx1B5LyTLwFLR9pPsBzfRa+AeceSLLbBfI0RoI9VLUKmxjSdqPZtxDPLuMvOE+iiMi1wHGFK8cVbnT8z/wMtwvMUy0i0gSIgqDIZcWmLaV862wApG4+lCTcyMgvtpJW4gjnCvZUsXxaDzpH1O0NJwgCX6dsY09JNr2DWjAirDWRHj51tk3XlHDvtgWsyT3pnOcikxPnFUicVwBxXgG0qvwb5xVAqKtXk4oKg1oG8slGb9B7M6Z9S/7VfM7ag8sxS+XcPPVbgtoNaXRvpzN4KV1YMWw6Q1d+y96SbLL1FQ5RcNQDtPD0axIbRBqO5ccKuG9BsvOl/FysSCki8aON/DSpE2PbOkLSixa/zT+B8bwVNxiDzOEx5CpTMLPneKbGJSGRSCjQmBj89TaOFjgK67Twc2XDjN7OF6//IpNKCXL1PGchD0EQKDXpydSVk60rx0WmIMLdmwh37ysmh5NEJqfX03N5/0k7N6v/Omd7fcpG0l/rQdTji1GFnV+hkLY+Iey67lFmbP+LOaccIteHhzeyvfA0X3Ucgz+iyPJfTIeXO6c9u4wHwHh6H5aSzJoNBTuWkkzH/ONV6RnMEinH+/UCoI1SRdxjC6/qqs9SiZR7E3rwwdG1IIGvj+7i1cEdalUx9h/5OILdBj9uBRyegqVrv3J4EFZyIKeCEd/tqFFV/HC+hknzjvHj/mI+uK4tiWFnLwwmcu1ysR6C+Wojb6w+yXc7TmOtNvrVKsCdN0e25qaOYc60M3bBziMZh2uIgYnqXO49vZOhEjsh4dHIYjphzD6C7sgawJHb0L3d0EvtXpPg3rofv/afh9fKFxlvWgeAZucfuCVNqbO9IAgcyFEzd38Of+zPIbvCyJg2QSye6rjHC3Y7Jcs/pHDBC2C3Ubz4bXz6TSHopndq5F8UERGB1hY9W8Y8VGNe25lTz7qOzmyj7+e1Q4afLtThrpQTU8c6IiKXiigIijQ5eqsZt8pQubKN3yNU5ukzdb2T4d/td748tPR3Y+W9PWkZUL/XxDvJ63hxn+OFb9bJ3QC09QnmxugOvJA4BJfKELAfTuzksZ3/orNWvZjcFd2ZmX1vxEt5ZQgK/WL9kUhAEGDjqRKm562nb5kjx1pAXJ8mt8dH5cqqEfcyZMU3HCjNJVNXTuK/H/Fsh0E812EwsnqqaopcOZisNu6dn8wve6o8Lbxc5ExsG0DLYB9CPFWEeqkI8XQhxEtFSqGWO+fuJ7vCSJHWzHU/7uKB3i14pJOdR4ryWZUw0rmdRN9Q/hh4hzOHZYHGxKCvt3GsUgyM8XNjwwO9iPKtWwy8ECQSiTOctrN/+CVvr7FwU8pxn/AOU//pSEfrcbQSN3QSNzQSN7SVPx6Cnre0nxFqL8ZSeIr013sS8dACPNoPO/cOAA+Fil/63Ur/4Fge3rkQk83K1sIMeq/7jje7juLRtv2uasHqQjEdWeGcDpn8BQo/x/en25v/oCw4RILqNCPjBQJKMgkqOI60rKZfZ6p7ABap41EpqUXna+LYPtSup0MQBIweuXyxJZ0Xh8XXahcw+imEH7c5P+f/8iCCxYjf0IfZmaNl5Hc7qDBaAYdXlqtCxua0UgBWnShi9ccbmdI9ks/Gt8dDJT6OitTkYnII/r4vh/sWJKMxWZ3zQr1UvDo8nnuSolBU83Sz2e1M2TKPX0/tdexDIuVTqZmBB+YjsVuxATlfTaJ01afYjVrnen7DH2lW14Fl6UYOeT7GBpeezLR/j11ThKdJA1QdC0EQ+GprBp9vSed4Uc3UBEuPFTJ3Xw43RVnJn/Mw2gNLaiwv3zwL9Z6/CJ70Pr6D7muKLomIXJW4naVwnt5iR1ItrZSISEMiPoGJNBmCIPDU7sXMPLqFkRGt+a3vLZSucVQsFSQyrk/pTKHgEOw6h3uxfHpPgj3Plug9yykGVudoeQFHywtI05QyZ8BtbCvIYPrW+c7lsZ7+/NDnJhKVvleMGAjg46qgY6gXB3LVHMkqwFx03LmsZMVHBFz3QpPb5KdyY/WI+xi84hsOleWhsZh4ad8KSkx6Pk4SM2Bc6by37lQNMfC6tsF8PbEDLlY9/nWE7IV6uZD81ADuW5DsLOazdssq/i48SX5gVb6kh9r04YNuY52Cu8Fi47ofdznFwJb+bqyf0ZtIX9da+7jaebBvDBvShjPnVFd05rof3m7x+ZDP1W+TaD2B3aAm85PriH5y2XnnpJNIJExv3ZPuAZHctP5XUjXF6GwWHt+1iF5B0fQIjG7ILjVbzEUZWDIdL/suMd1Q+IVjtlnZlJ/OAZdMbG1tbHfxZRZAiB/S0M5EufkQ6+JGC6mESKuBeTodVKaX6BZwbeS/i/LwpV9gSzYXnQIXPf87+i+j202lc1hd3uE1hZGC35+keOVnzJGMwSzpD55GQsI1FHpX4KdyY2iUPwdSbRQXuyCY3PlpVxYVRivz7+zarEQWkcbHnF8VzaHwPfdA0I7TZdw+dx9CpVOgj6uC5wa34uG+LXBT1n7deW7vUqcYqJTK+HPgZK6Pbk9B91swrXwH7f5FABhStzvXkbr74t178qV0q0lRGy0cynOk79DHjaLVXY+SN+tevI1GwDFYZ5fCrgWfMWuzgVJpKEj9QCJBKZNittmJsuWin/sNqWWrwFYptEqk+PSbgmbfQmzaEuwGNXk/349bwkBUoa0vU29FRJo3Zxxgtjzct9ayfx8QnTBEGg9REBRpEgRB4Ildi/j06GYAlmQdY9i/H/KZuhAvYJWiB6cFh0AxJC6Av+/uhpdL7QTv1bf3zO6qUco7WnahnU8IK3OOs6UgHatg57e0fYyPbsdPJ3Y7281I6MUH3cbirlA1WfjthTAsPpADuWq0diX6oA64FR4CoOivlzCe3o/LjR9BE4cFBri4s3HUDF4/sJovjm3FKtj55MgmYjz8eLht7ZuWyJWB3S4wa7cjLFIhkzD7ls7c0jkMiURCSYm+3vV83ZTMm9yVMQlZbJnzJoUh2SxyaQuAi81Ca1N3lIXxLDxUSPdIH2L83LjnjwPszioHINbfjQ0P9CbC59oTA8HhJbh0Wg8AjBYbpXoLJXozpXozJToLRwo0fLIxjbslb/GmZiajzZvBauLEh2MRpi2iS+/zD0Xr5B/O3nGPkbTkM45XFAGQrikVBcFKytZ+CYKAQSpnRfvr2LR2FmtzU9FaTXVeRu2CQIaujAxdWa1l/io3bozu0ARWXxm82mUoQ1c6qqxavQroteRL9t84gzb+9eVOdIh5OpmCzTIX0gIzkfhtA7mSfAAdZOrKgVzwwfEjSMDgwV9Fnry3RcVz/a6d4ytydsxFGXxjNPFvt8nYlW4ol31Zq02omxevdhpO3+AYLDY7981PdoqBd3WL4JPr2+Hrpqy1HsDPJ3fz4eGNgEMM/HfIFEZGJAAgD4oj+LF/0R5ZS8EfT2LKPAhSGRKZAv9RTyFVXbrXe1OhkkuRSyVY7QIGqx25VxARj/zD6GWfsuzQDgBMShnS5c/wS2WeXgNKcuQhhMa0ZdvpcgabdyHD7tym3CeU8Pvn4t5mILZbPiDz4zFO0VSoJ9eviIjIuamvEAlAaUKSWIxEpNEQBUGRJuHlfSucYuAZduk1TO14E98l/8UfLo6k+A/1acHH17erEdZRFytzjrM+3/Gy0tYnmFl9JyGXyngucTALMg5y03pHlcSpW+ajtji8O+K8Avi8x4QrOtT1hsRQPthwCiQSPmrzFTP7b6Lo71fAbkOz5y/02UfwfmIxyuBWTWqXr8qNT3pcT9eACCZv+h2AR3f+S5S7D9dHt29SW0TOj60ZpWSUOsLxRycEcWuX8w+1tWlLGLT1QSoUKTwaej0AblYLrifbcNDmzcG0NGdbT5XcGZ7l7SJn6dSka1YM/C8uChlh3jLCvKs8kW8glIf6tODLrRl8sOk5pPl2Rpq3orIZqPhuAo9s/5AXbxyAn6cbSGRIpLLKl1E5UjefWl5UXkoXXus0gls2zgEcVZlFwG7SUbbxB3QyBZO73MZxjRo0R2o2EiBKFcKk+ATyDRpS1cWc0pRQWC08ECApIJK5A24/Z67Lq4khYXH8M2gKE9f9ik1ixaSooPO/n7JhzHR6BjsEZ0EQECQgEcAkl/H4hA/YUJqLWVL7HuuJgFEiwyJUCQtIBHDTgJuG54//Ru+oR+gfHdZUXRS5glm//gfebzWwakZ5Qa02R8oLWJeXymudRqAojSI5z1GIrkeUDz9N6uTME/hfthakc9+2qsrh3/We6BQDq+PRbgjur+2lYtscXGO6O7zmQpqX95tKLqN9iCcHctUcylNjttpRyqU8NPpRVs5xhPvbJRIe6DCB4UUn6KDOJ0FbRCtrJpzMpHoiC5lnAL4jn0TT43Y2GrUUntxNn6AWKF2r8oAq/MXBKBGRc5Hh5knfOkS/rR6OFDx1JYkSi5GINCaiICjS6Lx9cC1vJTvyEUmQ8FbXkXyavIFCi4GjnsHc1uk2crIT+Pb6RO7tde6HCbtg59k9S52f3+k6Grm0Ku/CxBYduS32MHPT9jvFQIAXEodc0WIgQFKkD+HeLuRUGFl0Us2PdzyDa2wPcr6ahE1bgi0/hbT/dSdixu94JI489wYbmDtaduW0toyX9q1AQODWjb+xYdQMkgKjmtwWkbPz696qUOE7up5/qKMuZSM5X99Gnr6c/3W7yzm/q6o/hX6+lPwnv9AZMVAqgT/v7EpCsPjQci583ZS8NCyeJwbE8tO2luyeN5nu+t14C1ruT76fkmSoy39ZGRyH7+AZ+PS7G5m7r3O+XzWPlVJREASgfOuvWPXlPNf+eo67V3m1hbt5EyELY+cRCWh9effWpFpiucZi5JS6hFOaEtzlSoaExaGQ1p/b52plfIt2rB46g2ErfsCmMGCSGOm77CvuTUjilLqEfSU5dHWR426wYlFIWVWWD9XEQH+zjqFFJxlanEr38iyk7n5oHvqbbXojKYYy9pRkk1yah4AAMitjl/9G/j2P1xneKXLtYLdZebXgNFS+HPsoVMj+c/5ZBTsVZiN2QeDl/SuQ6n1B3hqZ3YXvbupYrxh4WlvKhHU/Y7Y70jk83X4gd8XVXyVXIpXh0/euepc3B7pG+HAgV43FJrD2ZBGj2gQjlUhRWarE+T0+kezxceRplNtttNYW01GdS4K2kEyVP5mxvSj2CSClrBj9ks9qbL+jWzhjwzoxWleA7BoaNBERuRiiDdp6l3U1qWltMfDblA9rLTtXMRIRkUtBfOoSaVQ+PbKpRp6/H/rcRAtJLDfs/4F/W3mS5+JFprsPEZ1SGNVhyHltc27afpLLHPnN+gbHcF1k21ptvug5gQ35p8jVO0aMW3j4cnvLLg3Qo8ZFKpUwoX0IX2zNQG+2sep4EeM7DCHmf3vImjkeU+ZB7PpyMj8eTdDEt/Ef82yT5116IXEIGdoyfjixE4PNwtg1P7Jj7CPEeooVTq8UjBYbfx7IBRxee2cqBZ8NwW6j6N83KP73DQTBzqsdxlOmdAhNt8V25rcBNwJQbrCwN6uc3dV+inVmZo5vz/DWQY3XqasQN6Wchwa2xpS0jgOvD8Yzb/dZ25sLTlLw+xMU/vUi3r3uwG/og7hEdRQFwf8gCAKlq2fyZYverAtweFP7q9xYPmwa3QIiuX9BMjvVjnD6hCCPWut7Klzo5B9Opyu4gE1TMSgqmn/738d1q2cjeJRhw8bXKdvrX8GsAnUAgbZwjt/TC8umbylduxe7YAdtMYE/3sVdDy0jsIXD9yhXp6bFH+9jkRrRqAoY+9di1t06oYl6J3Il8u/2eeysFANb2c0cu+29GoO+4BgY/uDQBl7ctwKbYMfuVgat9jLBf1CdlauLjFpW5ZzgneS1FBkdg1pjItrwTtfRjd6fy8317YP5cZfjevfi8hRGtA5CKpUgqQyvlghCjfZWqYwjXsEc8ar23CBYoPK5+78cdPXlYPwQ3hPsjFz9I1094rFr/HGRKlDJpbjIpY6/ChkucikKm5ERXj64nKWAgojI1cqMzGMAjHvkx1rL0t8U0zCJXB5EQVCk0fg2ZTuP71rk/Px5j/F46CMYM2czq0uWcaNGYEqnm8l29SHbUEa/5V+ybuT9ZxWWjFYLL+2rqhr5XtcxdQpivio3fuo7idGrf8AuCPyv0/Bm4+FxQ2IoX2zNAOCvQ3mM7xCKMrAFMS9tI/3rOzDt/wcEgcL5z2PM2EfYfb8iVdRffKWhkUgkfNXrBrJ05azMOU6RUceoVT+wbcxD+LvUXxFapOlYeqzAWd3z5k5h5/XgXfD7k5Sucoz8zw/twEb/lgBEuHnzRc+qF3QfVwVD4gMZEh/YCJZfm6jcPOj26loyl3/Oqi3bKNEakGJHhp3EEA/aBrph0xajP74RBAHBbKB84/eUb/we17g+yPtNc25LFARBd2QNiy02vonvBYBMImX+oDvpXunJnFJYNULfOki8Zp2LMQkRfFJ0C4/tWAQBOc75CpsLMpvDy0hlshFfOoQTuRZAwme3d8E3KBwmvon/mGc4/d5QjOm7sRSlU/bj7fi/tBmpyo0wdy++7nkj03b9BsB63U6+3d2W+7o3r9BMkYbBLth5MWUnyBy5/95s1a2WGAgglUh5NnEwVo0XLx3+B5QmkFtYULGKZ3ebea3zCPaX5rA8O4UVOcfZU5zt8EStpK1PMHMH3H7FR400BGPbBtMr2pftp8vYn6PmjwM53NalKmrAzWjj4PVPsKs4i51FmewqyuRweT72/wiFCqmM1l6BtPUJpo1PEB5yFfPT9rGr1DH4aJVIWZJ9jCUcA5sMiiMdP0LtY+yuTGFYfCDXtQ1mdJsgQryunAJ/IiLny4xtf3GoHqH8uMKN1hbxeUykeSAKgiKNwh9p+5mx/W/n5/e6jWFaXC9avLmG6do/8BPUYIK/ZHbu9g7iWEUhp7Vl9Fv2JZtHP1ivKPj18e2c1joSvo+Pak/v4Bb12jAivDU7xjxMudnIsPD4Bu1fY9Ivxg9/NwUleguLjxQ4c75IVW543/EdxPem8M9nQbCj3j0fVUR7Ase/0qQ2KqQy5g+aTL9lX3GwNJcT6iLGrPmR3wfcTozoKXjZ+Xl3tXDhLucOF7aqCylb/w0Ap90D+CBhBGeys//c7xZ8m1ES9eaKzNWTmBte4O5xNh746xA/7cpyLNDBhNgQPr+zPa2MuZSt/4ayTT9iryx8YTi5FWPabuj3MAClZvEBdOvab3gxoSqlwmc9rmdQaFXe1TOCYLSvqxieep480jeWAzmD+PnwEZBZweCBxaZEZXZ4O8jsAidyrYCEPi18uaVzVS5AmasXUY8vJv2NXliK0rFm7iP7y5sIvfs7FH7hTG3XmTmpB9lQehhkVh7a+TchLncztl0IsnpCP0WuTmbvXsSxSjGwi66Im/reVm/bCoOFL9eUgrYrhJ8A72IA3j+8gU+ObsZir7vKe7xXIIuH3oOX8toQoSQSCe+PbUO/Lx05A19cnsLAljWLAyX6hZHoF8a0eEdBLK3FxL6SbI6UFRDq5kVbn2BiPf1qibMz3D3Y9P4wlgS3YW5IN8pdKou4yGwQnAE+BZATD3qfGuvpzDYWHs5n4eF8AJKifHhjZGsxykCkWXGoLI/ksjwSfUNrLWtt0dPaYrgMVomIXDjik7BIgyMIAk/uXuwcjX210zCebj+Qe/88yL35n3GLsSqEuMOwGWwMa8Pwld9xoDSXXL2ap3Yt5u8hd9e57ZmVhUmkEsl5hXp0b4a57eQyKde3D+GnXVlUGK088Nchvr85EYlEgkQiwX/0U7hEdiDz4zFgt1G6eib+Y55tUi9BcITVLR06lZ5LZpKtr2BnUSZt/vmAx9v25/nEwdfMw/aVxl/JuSw56kjAHu3rSt8Yv7O2NxdlkPnxaASLCTvwes+70dsc5+7j7fozJCyusU0WqYZKLuOHmzvSMcyLJxYdxWYX+OdQPitSCpncNYLR7Z9k4OhXEA4soHTNFxhP78PVXlXZsdxkPMvWr37sRi1vWsEgc1SpnxzVkQcSejuXr08tplBrBqBNcO1wYZG6kUgkfDOxAwlBHqw7WUxmuYHTZbXFZ5lUwqfj29fy3Jd7BxP1xDLS3+iFXV+O9uAyUp9piU//aQSMeZZ/R91C2Ny30Ql6rO4ljP97OdH/RnFfr2juSYoi2LNp728iTYsx8yBFi97kc6scvB2h+q8HhiOV1f2aYrcLTJ67nzy1CVBwk+9QBvUw8/iuRZhs1hpioAQJ3QIiGBWRwKjwBLoHRF4TnoHV6Rvrz7h2wSw6UkBGqYG4d9dRXxbqUr2ZzWllbDhlYH8OqGRa/N3N+Lvl4+emxN9dgb+bkiKdmS0r1/K6oZwHM7YTnafg2aDp+IeXUe6ahU2wg8qAJPYgYwO7M8q/OxYr7D9dzOq0CnIqqu5VuzLLGfvjLpZO7cGw1mL0gUjzIdE3lC1jHqo1Xwz/FWlOiIKgSINTbNI5c/cNCmnJq52G8/HGNKQbPqohBnr3vQvX2O64AmtH3k/EvDcw2Cz8k3mYb1O2c19CrxrbzdKWk1HpHTgsLJ4En6t3JPGRfjHM3ZeD0Wrnx12ZqORSPp9QVc3Xo8MIvHtPpmLLz9i0JWgPLMGr+41Nbme4uzerR9zH8FXfkaUrx2Sz8u6hdcxK3c2bXUYypVX9ybpFGp4CjYn75ic7P784NK7e5OoAhlO7yPz0OmzqQgAWtOzHjkoxMME7iLe7jGpcg0XqRCKR8Ei/WNoGe3LrnH0U68wYLHa+25HJdzsykUsl9I1pzcgBfzBacpDTCx9zrhuirjt85VohqySHbb6O4lQt7FbeSxzhFKe0JitT5x10tr21s5gj8EJQyWU8O7gVzw52eFsKgsDEiT8BIAE+n9CerhHedIv0qXv9sAQiH1tE5ifXIRgqECwmytZ+SdmG7/Ab8iC/9LqNG7fNczQOSeP0SX9eWJbCKyuOM759CPf2jGZIXMBZr2kizQtTbgoFfz6Ldr8jvczp3jMAiDLrGHHjs7XaW212DuSq+W7HaRZXDnwFeij5bEJ7Qr1c6BPUgnu2/EmuXs3g0FaMikhgeHg8gS6i+P/xuHbsyiwnX2NCb7Yh4DhvARYeymPDqRI2nCohOU/Nf6KF68XbHslTEne8BB1jTZvo3HUKQ65/iJOaIh7c/g9r804iAIuLdlMg5DN3wO3c3tYbPz8/DuaqWXy0gH8O5bE/x1H05IbZu9n7eH/iA8X/l8iVz6kSHTqzjb6fb6m17Jk8NW4KGTGXwS4RkQtFFASvAQoNGl7Yu5zD5fkMDm3FdZFtSQqIarQR0pTyQud0F/8IFh8pYMOCr3hPPwcAAQnh037Cu1rlNj+VG58kjeP+7X8BMGP73/goXZkU28nZZlthhnO6b9DVfYntGObNn3d2ZcLPe7DZBb7aloHeYuO9IVXhnz79plCx5WcAyjfPuiyCIECCTxDHJjzN+4c38MGhDRhsFgoMGqZvnc8Xx7byv4SBjPcXw4gbG0EQmPFXMiV6h7fYHV3Dmd6z/qrd6t1/kfPtHQiVlbhLWnTj45g+YLUgQcIPfW7CRa5oEttF6mZofCCpzw/m/fWpzNySjtbk8Hqx2gXny9tzqOgedBdgAiDmyArUe7vh1XX85TP8MvLb6UPYKyvd3iyYUVYLcXthWQrppQ6vtmHxAUy+gOrbIrX5rxfgQ33PfV92b92PgBf3Iuz5ldJVn2LXV4DNQumqT2m/609G9J3BSm05KI1IArIRiqKw2gUWJOexIDmPGD83pveMYkr3SDHv2BVOocbE6hNFLErO5mDBQdxVckI9VYR6uRDqpSLecIyOy6cgM1UAoJMpKK0sZBUXlYjcK9ApAG5ILWHDqWI2p5eirsyPCyCXSlhwZzdCK78LiX5h7Bn3WJP3tTnQMsCdY88O4t21qXy6Oc05XwAm/LznorZZIfVkSfwz3Hb8VQCi1j6DfchoWnsHsXrEvXx+bAtP716C2W5jV3EWnf79hPc6DGOG3wA6hXvTKdybF4fEcdtv+5h3IBetycY3207z8fXtGqLLIiKNis5sQ2+uOzWBrp75AOH6U3V6EJqyklFFJl6wHTMWJHMoT13v8g6hXnw98cK3K3LtIAqCVzGCIPBz6m6e3LWYMrMjj8HOokzeSV5HgMqd0REJjI1sy4jw1g0a3nlcXeScdhM8+fCnn/lcM9M5L+T2T/Hpd3et9e5L6EWeQc1rB1YjIHDHprl4K10YGZEAwNZqgmCfs+QOvFq4rl0If9zRhVvn7MNqF/h5dxZlWj3zp/ihkElxa90PZXArzAWpaJOXYynPQ+FTO49FU+CuUPFa5xFMi+vBC/uWMefUPgAOluYyYdtcPrFqeaxd/8ti27XC7/tz+OeQIx9PqJeKmePb19lOEAR06z5Hu/R1Z55AXYfRPNZqMJrK5MgPtulNn+CrW3RvLni7KnhrdBteHhbPlvRSVqQUsjylkKMFVYUxdqsCAEexh3bqAjK+vA3Zg6to1/XaClkRBIE52SmAo3LmxGrprjadKuHzLekAeKgcYdlNXaFdxIHUzQf/Cf/Df8TjlK6eScmy97EbtVjLc3lk7cesS7obi0SKa1gO9yf25s89xWRXhheml+qdXoPj2gXzzKBW9Ij2vcw9EgEwW+1sP13KyuNFrDxexL7sinrbdrUc5jr1G8gEx7NptjSIj3xvci7fkKIncPtKjFabcyDkv8ilEr6ZmEj/luKA4/ni46rg3bFtmNE7miem/1RruVwqoXukDwNa+jOwpT+9W/ghk0KJzkKpwUyJzkKJ3kyJzozZZmdE6yDiA8eS8/VR1DvnYdMUkfvTdCIfXejwdG/bj4EhLbl1428cLS9AazXx4P4lHDOW8WnS9cikUqRSCd/f1JG/D+VhsQksTykUBUGRZoObUsaWabWftRY9WHcxv2zXWADqSuajikzEJaLDBdtwKE9Ncp6GxFDPWsuS8zQXvD2Raw9RELxKSVUXc9+2BazLS61zebFJxy+n9vLLqb3IJVKGhcXzSY9xtPa+9DDc6h6Cf60+xA+lb6LAMaLrN/xR/Ic/Uu+6r3YaTqnJwOfHtmAV7NywbjarR9xLn+AYthY6XuZkEilJAZGXbGdzYGLHMFwVMm6cvQeT1c6/x0q48ec9/HlnV1wUMrz73k3RXy+BYKdi668EjHnmstob6eHDr/1v4+E2fXls579sLzoNwPN7lzEhuj3RHmfPZydyceSpjTz092Hn5+9v6oivm7JWO7vZSMHcx9Cu/9Y5r3jg/dzpHs7pSjEw2sOXt7uKocJXGi4KGUPjAxkaH8iH49qRWaZn5fEiVqQUslB3EHtluwRtIXKbmfwvxvNQ628YldSJ4a0DaR/iiVx2defN2luSzTFdOQA9yjOJDHaEBOvNVu6Zd8DZ7sPr2hLlKxbKudzI3LwJvP5lfPrdQ/7cx9DsXkALQxm3Ze9jdmQ39DYzJe7HSH/xFlYcL+K77adZeqwAu+Dwkv37UD5/H8rnurbBvDGqNR3DvC93l65JYt9ai8QzAJsgYLPXHWvqrpRhtQuYrHZ6mffzufotXHHk8tyk6MpjXs9h8tQCjvuYzaSiWGeutZ1IHxcGtgxgYEt/hsYHXNHn8fJjBczancWI1kHc2S0CxRV0/Y32qzpuEuCFIa0Y2DKA3i18cVfVfjV0U8qJ9HWtd3uhd36F/vhmrOW5aPcvonzTT/gOmApUem1e9xhP7V7MVymOwiZfHNtKvkHDr/1uxUWuwNNFTr8Yf9alFpNSqCW9RE+M/5X7vxURuVjmRj8FwJaHG3bANjHUs85t1hXOLCLyX0RB8CrDYrfx4eENvH5gNUZbVVjFPXFJvJA4mF3FWSzJOsry7BSn16BVsLM8J4WNi07xadL1TIvvcUmeEzuLM53Tr53+AG9BB4B7l/EE3/rRWdeVSCR82mMc5WYDv57ai8FmYcyaH1k6dCoHSx2CRWf/MNybuIDG5WRM22CWTk1i3Kzd6M02Fh8t4Lofd7FwSnd8+txJ0d8vgyBQvnkW/qOfviK8XpICo9g65iGe2r2Yj49swmiz8vTuJfw56M7LbdpVhyAI3Dc/mTKDI1R4SvdIxrQNrtHGlH+SsvXfUrF5FjZdqXN+6oS3uFtnoKxSRIn19GfFsGl4KsRQvCudKF83pveMZmqPSHzmLERjBXfBnWPSBJJsyYTYS3jgxHPcVfgOzy51wV0po0eUL71a+NIr2pee0b74u9cWjZszs1Orwt6uzz+CJNwxEv/CshROlThChQe3CuDes4TSizQ9Cr9wIh+aj+bgcvJ/fYj7T+9gUXBbypRuzE7bxzRvP8Z2GsnYtsFklxuYtTuLH3ZmklnmeIZZfLSAxUcLuLljGK+NiCchuLaXhEjjYbHZwWavMU8qgaQoX4bHB9IzVMmw9tHIpBIKdi2k9Nu3oFIMzI8aTkbX95hilbJHf4Q9lc6AsZ7+KCUeCIJAUpQvA1v6M7CVPzF+blfEM865WH6sgLG/rcfuWcj8E/68sTqYF4bEcXf3SJTyK0cYPMNbo9tc0voyDz/Cpv9M5gfDAcj/7VEMJ7di05dj05Vh15fzmL6MWBc/no8dgEUqY0FGMkVGLQsHT8FH5croNkGsS3VUil6eUsgDfVpcardERERERM4DURC8isjSlnPd2p84WJrrnBfnFcC3vScyKNSRBLylVwC3xnbGarexrTCDJVnHWJCRTLq2FL3Vwr3bFrA46ygze4ynheeFe3PtK85mW0EGANHaCtqaswBQtEgi8v7fkEjrdqGujlQi5ce+N1NhNrIo6wgVZiN9l33pXN47sMUF29XcGRIfyKp7ezLq+x1oTDbWnCxm9A87WTejN+7thqE7vApzXgqGUztwa9Xr3BtsAiQSCa91HsHcU/vIN2qZn5HMxvxTDAhpeblNu6r4dW+2M7l6hLeLM9TGbjGh2beQ8g3fozu6tuZKchf23PoZ03NOYa6sxtgjMIpFQ6YQ5Cq+TJ/BlHccQ9puPDueu6L55eKUugSN1ZE/cExMK8aMXcnpN3vhVpFBO9sp3tF8wmOez6Ez21iXWux84QLoEOrJDzd3JCmq+Ydcmm1Wfk/bD4Cb1czQopNIFC6sTi3js80O73J3pRgqfCXj2XEU7m0O4734bR7Zu5TX4gYDcP/m39ni7o1PXC8ifFx5eVg8zw9uxZy9Oby2+jgZpQ5h8M+DuSxIzuW+XtF8cn07VPJzP2+IXDqdI7xR+fgiAdoGezIiIZAhcQH4VXqpl5SUIJdJ0SavoPTbm6FysNqr5620mT6bwZW5ap/clcGeI45t/jqxF72baWqY5Fw1N8zdgr3FfpDZICiT0yVh3LdAz9trT/LP3d3pHHH1ebN6tB+G79CHKFvzBYJJR/nmWbXajOI0ftpiHml/PVq5io35afRb9iWrRtzLqIQgnlp8FBAFQREREZGm5MobphK5YEw2K18e20q3xZ86xUC5RMoLiUM4eP2TTjGwOnKpjP4hLXm/+1iOTniax6vld1ucdZQ2/7zPa/tXYbBazt8OpZSuiz/FjiNkZHiJI5cT/rHEPLkEqer83f8VUhnzBt7BwDrEo77XaG6zPjF+/HNbO/zcHA/Pm9JKWXuyCJ9+U5xtytZ+dbnMqxMPhYpX2w5yfp51cvdltObqQ2O08nTlAzTADzd3xEtmpWDeM5x8NIycr26pIQZKlG74DJjGqjt/Ykr2SacYeH1UO9aNvF8UAyuxaorJm/0Ap55vS+53kzn5ZDQSzrPsYhOTpq3y+MwzqPELCKLDCyuRujtEvmHm7bwbdpCoOsK9DuVpnHn1mjt7S7IpMVUWDCk+gZvdikQmZ/b+fGebj8e1E8PQrnCkSleCbnyDZx76jbYWR3TBEY9AXpr7DOVb5zjbyWVS7k6K5Pizg/n6xg6EVRaVsAvw9bbTDPt2BxtSi7H+x3NNpOFZdE8S2x/py7ZH+vLDpI7c1DHMKQZWp2D+c04x0Kf/PYTf9yuSaoWrUiqq0s3EXMSA9JXCrN2ZGH0yHGLgGfxzIfA0p8sMfL0943KZ1ugE3/weLlGdas2Xungg94tEFd6OHuVZzN4/j0CTIw/u4fJ8Bq34GoXKgkLmGKw5XqittQ0RkebGmQrE1X/EnH4iVyKiINiMMdusfJuynbi/3uWhHf9QaHTcQOO9Atk37nHe6joK1/OoEuoiV/Bx0jhWDp9OhJtj1NJos/K/A6to88/7fHd8B9sLMygwaBAqixBYbHa+2ZbBgG/XY1I4vkbWavlRAvQm7s5yhG9FTfkKuVfgBffPRa7g3yFTuD6qHRIcDwlDw+KYEF13sYTGxGC1kKYpYUtBOn9lJLMo8wjr81LZW5zNiYoi8vVq9Faz8/g0Fp1CPfi0WrLlYwVaPLtOQO4dAkDFzj+wlGY3qg0XyvVhbZz/vzRNyWW25uri/fWpFGodoVd3dA1nREIQebPupWTZBzVCg1VhbQm5Yybxn+bwd8+7eDxtL/bK7+qMhF78Negu3ORXV/joxSBYzZSs+ITUZ1pRtu5rEBxigt2ohUpBUIKApSTzLFtpWnoHRRPt4RD/Nhek8+bBNahC4omY8buzzaDUrzAaTbXW9XdTMDUpqslsbUyKjTrndCud4zpjN2ooN1a9lE/veXX09VrALawNv49/DmXlOfhtRDfW/fYEBfOeRbBX/U+Vcin3925B6guD+XhcWzxUDq/AzWmlDPp6OyH/W8XUeQdYcrQAo6X+qo8ijYulLBdT5kEAXGKTCJ3yfY2IEavdxuYCx+BEpLsPIc14cKptqBt4F9ZeEHwaPEuYmHh5ir81BVKVGy1e3k7s6/tp+d4J4r8oos2PZhK+1RD/SSYt3z6M7wMLaSeFufvmEqUvA+B4RRG9l3yJReIoHtQvtvkKwiIiAG4KGe7K2l7qiaGedAj1ugwWiYjUjxgy3Ayx2G3MTt3DmwfXcFpb5pwvQcLNMR35JGkcoW4XfrEZHt6alBue4e3kdXx4eANmu43T2jLu27bA2cZNriDGw5/iMikF5XbwKmSEXIrKUjkKb1XSQdqeb1LfxMdqBJkCt/iLT5zqpXRh4ZApFBm1ZGnL6eQfhlTSuDp2gUHDu8nrSC7LI0+vJtegpsJsPK915RIpLTz8aOMTRBvvINr4BJPgHUQbnyC8lfUnZL4Q2lTLj3SyWIdUocJ32MMULXgRbFZKV88keNL7DbKvhkAplRHq5kmuXl3j+ypyaWSXG/ho4ykAXORS3hqVgHr3Aiq2ObxoJEpXvHvehs+Aqbi27Mn+khze3vkvf50+5NzGcx0G83bXUdd8CKUgCGgPLqXg9ycx559wzpe6eePZ6TrUe/6u3pqTT7fCp8+dBIx9DmVwbQ/spsRT4cK8gXfQd+mXWAU7rx1YTb/gGPq1HUZayGBi89fhYcgnsXwLa1S9AegR5cMDfVpwU2XRoquB8mrXaK/KEGqbrgxzpYeYSi695r/nzY3EoGhe6TKKl/avxCqV8VLCCH5f/iGmnMOE3z8XmVtV2KWrQsbjA1oyOC6AcT/tduYXLNFb+GlXFj/tysJDJWN0QjC3dwnnunbB4vehCdEdXuWc9uw8Dom05nPcvpIcNBbHeTsopGWz/t+Y3Quc3oHumigUNjfKfRwRM6oWx2kRMuZymtfoSJUuuER3qne5slVfop9ZjfDOQGYfmMeUTjeT4eZHsbUCYvcjLQ9lROeWmG1WlDLxNVWkedIywB1o+OIhIiKNgXilvQzsK84mW2nDLggUGrVk68rJ0avJ0VeQrSsnU1NGsUWPXCLFVabATa7ETa5wTp/SFJPxH2HlphaJvNppOO18Qy7JNneFire6juKeuO48vmsRi7OO1liut1o4Up7vKEv2n7RTSouN4jtextum58Sm2wFwjemOVOV+STYBBLp4EOjiccnbORf7irMZv+5nsiqLLFwoVsFOqqaYVE1xrWMX7ubNHS278ES7/pcUmtkqoOp4nixyeMX4Dbqf4kVvIZj1lK3/loBxLyFzvXJGoKLdfcnVq8nRq7HabcjPI5ekyNl5ecVxDJVC/OMDYgmTqDn18/3O5eH3/oJX94lszk/j7dU/sCLneI313+oyihc6DmlSm69ETLnHyJ/zKLojq6tmSqT4DrqPwAmvIfcKJPjWj2HKfc7FeXIXPso+QdGsxxjfaxK39bkFl/Pwxm4segRG82rbQbx8ZC0CArdu/I322kGoDUOZzToAJpuWEt3vFmb0jqZrpM9ls7WxKDPrndOeVoc4aNOVYbE5PDtVV2Aif5Fz80ziYP7OPMy+khyOeQbzU2R37ju4jPTXexL52CJUIXE12ncM8ybl2UGsSCnk70N5LD5SQIXREaaqNdn482Aufx7M5YkBsXx4XdtmLTw1J7SHVjqnPTqMqLV8fV6qc7quNDfNibkZe53TuoJAMLoDpeBTiEmwMGHdz+wY+/A1XbzLJaoj0U+thPeH8vOBP7mn402kufuD0oQ9KINJW3/CbaeCfsGxDA5txeDQVnT2C0cmFa/jItcuma7udPvmXgCCVVJcTHaMKimlwiz8LVJAFB9FLg5RELwMXL92Fvg1TDjEhKj2/K/zcBL9whpke2do6RXAoqH3sKPwNHuKs0jTlpJaUcLGrGzUdg3IHEKEQiJDYa2ctgr4u7qi3lv14OeWMKBB7WpM/kjbzz1b/sRgq8qb6Kt0JczNi1A3L0JdHT8BdgvIlWilMjQWE2qz0fHXYqTUpOeEupjyygrO1cnRV/DeofXMPLqFGQm9eKr9wIvy5PRxVRDgrqRYZya1xCEIyjz88B0wldLVn2M3qCnf+AP+I5+4+IPRwLTw9GN70Wlsgp0cfQXRHmI4yKVwKE/N7D2Ogj0B7kqeGdiS3G9vxKZ1hEp69bqdbaHteWvZl2wpqJkjLtLdh+fj+zKj48CmNvuKwm42UrzkbYqXvAvVznn3dkMJvu0TXCKqUhPIvQIRKsPeTQo5o3pMxVIpai9OO8jTOSe5q1U3psf3oI1PzQrPTcX9sd3Zrc5nUdYRCo1a1hk3g7wDJ+UtiLNm0M18iJt7S3G5CsVAoMY117vS08imL8NU6SGolIkvks0RhVTGrL6T6Lb4Myx2G1+36MXgklTi8lJI/183XCI7IlG5I/3PT3/vEMYMnwg3d2LDqWL+OZTPP4fzKdA4vhsfb0xDVelZLYqCl8bHhzfiXRSIVCKhZ2A0Q8PiahxTwW5zegjKPANwie5Saxvr8085p+vKHd1cOFqez7bCDMcHvScYHQPZIZpEAloc4XB5HkfLC7h78zwWDLqzwb57Nl0Zmv2LkLn54NF5XLP4Tru2TML3wX8xfDyKWQf+5Km2Y9jtW5XWQW+1sDLnOCsrBzPD3Lx4ueNQpsb3QCEOKotcY/ibJYAO6ghDznR1dywTEblIREHwCsRf6UqYuw92wY7eakFvs2CwWtBZzdgEO1KJhDERbfhfp+F0CYhoVFt6BkXTMygas9XOxNl7UB8NAATc3ex8NrEVExJimb54co11dEfWOKfdEwY2qn3nwmqzk1aqR2+2oTPb0Jtt6C02dGYrhWVq+reW0THMi5f2reDdQ+uc6w0Macm8gXcQ5OqJIAiYsg6h3jUP9a4/MRc4RrLlPmGoIhNxieyAKqIDLi2TUIYmIJErKTBoOFZRSEpFIcfKCzlWUcDWggwMNgsGm4WPj2ziq5RtTI/vyTMdBhLh7nNB/YoLcKdYZyajVI/Zakcpl+I3/DFK13wJgp2SlZ/iN/ThGgm7LyfR7lXupBnaMlEQvERmbk7nTLrKV4fHY9/1CyeObSQ5MJ7koHj2BnXg8OofaqwT7xXIc4mDuD22C5ryistg9ZWDLmUjebPurREerAyOI/jWj/DoNLbWy9T+khxMSikqsx2LXOoUA89QatLzyZFNfHJkE32DY7g3vicTWySeVw7XhkIikfB86zEsTT+FTW4Ej3LcInKI6PMoLHrcYeeaLwib8m2T2dSUlJmqBEGvyn+fXVeORSl6CNaFIAgIAkilV75wkOgXxksdh/Dq/lVYpDJeSryB33b8gNygRn9ic73rFcx7Gvf2I+g5YBrDxl/HFzd0YPbuLKbNP4ggwDtrU1HJpLw6onUT9ubq45MjmyCvapC7nU8wT7QbwO0tu6CSybFmHXDmtHVvP7xWuLDFbnMOXLXw8KVFMy4o8uOJXc5phSYMCyCXSlgwOYnwgCS6Lv6UUpOev08f4t1D63g+8eK99AW7De2hVZSv+5bCw8sRrI58wv6jniJo0vtXvCioNloYt16OzPMFvlK/wc8H51OkdGeXbzR7o7uz0zOEjMoiNAC5ejUztv/Nh4c38nrnEdwS26nRUwiJiFwpWGR34CeRs+V+hxfgjatvBMDFZCfKIIqBIpeGKAheBmYk9MYrOACAAJU74e7eRLh5E+7uTZirF7oKNf7+/nWua7E7Qo1VTZxX4555B1h8tAAAD5WcFff0pE9M7Yc2Y/ZhKrbOBhwVTd3iejepndU5mFvBhFl7SC/V199o+QkSe+SQrK3yonqoTR8+6jYGa/oeCvYtRLN3IeaCk7VWtZbnYi3PRXdoRdVMmQLfQfcRcuvHhIS2qhH6UmjQ8PGRTXxxbCs6qxmjzcrnx7bw7fHt/Nj3Zu5o2fW8+xYX6M7202XYBUgv1dM6yANlUCye3W5As3sB1tIsKnb+gU+fyefeWBMQ7eHjnBbzCF4aaqOF3w5kgk8BKk8tf5ak8mpBKqW97q1qVFHknOzoF8aLiUO4IbrDNR9uY9NXUPDHU5RvrBJLJXIlAeNewn/0M0gVqlrrPLj9b75K2cYImRQVDm+zAJU797ooab3haxYFt2V5WCJnrjJbCtLZUpDOU7sXs3L4dDr5hzdF19ibo+HW+SnYhDYQewAkAgbfNFbHDmOYZyCumiIqtv1K8M3vInP3Pef2mhvVPQR9KvO12vRlmKRVOQSvJgRBIP/kDp7aPp+/bWCWSJBJpEglMmRSCVKkyKQSglw8eLXTcG5vWeWVZbXZGfDVNvZmV3BHlwieH9LKme/oSuX5xCH8c/owB0pzOazy4of+D/LArl+wG9T1ryQI6A6tQHdoBXKfMCIeXsA9PXohkcA98xwFLv636gSuChnPDG7eYapXEkfKC5i69U9e3b+SFcOn45FSNdjq0WFkrfbbCzPQVYpZzTlc2GSz8kuqI1zYTa7g40GD+H5bLk8PbOl8Xp438A5GrPoeuyDw4t4VqKRyHmrT54Jy5VnKcinf8D1lG7/HWpZTa3nJ8g9BKif45ncapmONgNpoYdT3O9mVWQ7Kzrwe/DJvFr9JoFnHmIKjjClwpNzJcfHiQMJQNrfoweJyR6GWU5oSbt80l1f3r+L6qHaMjWxD3+AYMRWNiIiIyEUiCoKXgRc6DiEion7PvrPp/JfDTb5AY+K3fY6HDg+VjBXT6xYDQSD9tSSEyhcz34H3Im2CvH91cSCngiHfbKdUb6m/kdQK0YdJ1jq8pRRSGZ+168cN6dvImPsA1or82uvI5Li3GQyCgCn7UO02Ngtla77AnHeciIcX1MjjF+TqybvdxvB0+4F8enQzM49uQW0xYrbbeP3A6gsSBGP93JzTGZWCIDhGhjW7HUVgCn57DFVYW1xjzn+7jYXVbndOn0kcLnLhqM1GXtmzHkOL7aAwYwI2lwKKmgVrJEjoG9yC5zoMZlTElRcSV2bS89yeZWwtTMcq2LHY7VjtNsdfwfE3zM2LsRFtuD6qPT0Coy5JzBQEAe2BJeT9fD/W8lznfLeEgYRO+RZVSHyd6+XqK/gqZVuNeUqLjdM3v4jKqOX4ktfoVpHDy+Yydtw6k+9O7GBfieNaWWjU8uCOf9gy+sFGP/5b0kq48fejaM02wIsoUzsyXQ4jAM8fWM1rXe5gUOEJxhQeIyzvON6tejaqPZcDYzVPEomh0gPWbkNe6QFXqDWhM1lxVzXvxx5zUQYV239jyYEVPB/UlgKVJ5zxiBQEEKxQdbmlwmzkjk1zOV5RyGudRyCRSNiaUcq2DMfAzI+7Mvl5Txa3dwnnhSFxznvJlcaZ0OHuiz/DKtj5XKLCY/rvvNl5JFiM2E067CYdglmP3ahFd3wT5Zt+wJznCDe0lueS+dEoWjy/kSlJHbHYBO5bkAzAs0uPEeXryi2dm0a8v9qYN/AOAsNCKTbq+Pb4DtbmOQZQs/UVTNkyj99KMpxtVWFta6ybq6/gzs1/OD8PCa2ZE7I5kVyaS7HJ8QR/Y3Qi9/VoxX09agqcQ8Piea/rGJ7eswQBgSd3L+bzY1t4rfMIbo/tctb7nKU8j8I/nqZi1zyodr0DkPuG49F+OOVbZjuiRJa+i3u7oXi0u/LyBJcZLNz26w52Z5UDEOyp4p0HnqCFbRIVW39Fs28hppwjAIQb1YQf+JsxB/7mvrbD+TJxPMsrw8tTNcV8dGQjHx3ZSLSHLx93H8eE6PZX3POOiEhTkOHmSd+lX9San+yqxt3uhZhfUORsNO8nY5Em4XBe1Qj8g71j6hEDQYLgFANdYroTOP6VJrHvv+zPdoiBZQaHGBjqpWJiYhgeKhluChluShlmiYHnD/8FrhoAvKUyvi9Lpd0XH1ByJhbzDDIF7m0G4ZV0M15dJyCrFu5qVRdhyj6EMfsQpqxkKnb8gWDWozuymoy3+hH1xDIUfjVfMvxd3Hmjy0ieaNef4au+Y09xNifVxeToKgh39+Z8CPSo8mQ6008At5Y98OpxC+qdf2DTlZLxZm+Cb/sE38EzLutD0u/pB5zTg5uxB8Dlosio5bMjm/kyZZvDE+o/kaihRjXxuiL6tx/GgMRhdA+IxEt5ZSYsP1lRxHVrf+J4NS/Guig3GzhaXsD7hzcQ5OLBdZFtuT6qHUPD4s8aimszqDFlH8aUfRhj9iG06fsoLjjuzK8IIHXzIfjWj/DpN+Ws58XG/DTntLxarlQ3uRI8/FCFtcGUlYwy5zD3xidxX0Iv9hZnc/OGX0nTlLCtMIM/0w8yKbbTeR6dC2dreikjv9+JzuyoajkyIZD5k0fyxqGVfHRkEzbBjlEiZXlwAsuDE3h551JuKsjmtpad6Rccc9WEXMV6VnnVp8tUhAIenccxTObLj3vz0Zps/HEgl6k9ourfyBWK3WKiYstsSjfOIi1zLx/F9mdeZA/ncrndRlttAVIBbBIJdokEOxLMMiWn3BzeoG8cXMPJikJm9buVIq25xvZtdoFf9mQzZ282kzqF8+LQONqFNEye44akk384M3uO54Htjqrf7ySvY86pfYwKT2BURAJDwlo5CzW4tkzCf9ST6E9soeifV9EfW49dX8HpD4bT4sUt3NsrDq3ZypOLHJ5Id/9xgAhvF/rG1h2dIVI/vYNjiAh1DHLfFNORAyU53Ln5Dw6V5bG7OIv5QW0YX9lWd3QNrjFdsQt2Zqfu4bk9yyg0agHoHhDJxBaJl6cTDUCOvupZOdE3tN52T7YfQLa+gplHtyAgkKEt467Nf/DeofW82WUk46NqilqCIFCxZTb5cx/Hri+v2pBMgVfXCUg7TSS01w1IpDJcW/Ygr7K4WO4PU2j51qEa1bgvN0VaExN+O8LhQodPfbCninX396ociGhN0MQ3CZr4Jqb8k2j2LaRi2xxMWQ7hPuboKr6Wwuk7vuSdQ+tZm5eKxe64753WlnHj+tkMD4tnZs/xtPYOulxdFBFpcqIN2nqX6aVn8aIXEalEFARFzsnhfI1zukNozZcEY9YhJNgRqHqp9Bv+GMGT3kMiVzaZjWfYl13O0G92OEWyQa38WTI1CTdl1Vd9SdZR7t78J7g6Hkh8zQZ+PPgnrXXFzjYShQrPTuPw7HYDHomj6n2gknsFIm87GPe2gx3bGjyDzI/HYFMXYspKJv2NnkQ9sQyXyA611vVVuTE+qj17irMBWJ+fet5egr6uVYJIdUEQIPTub7CW56I/vgnBaib/lwfRH99E6JTvLkvl4QxdmTPJdlf/iMtWdKE5kqkt48PDG/nhxM4axW4QJFARCKVhbG+xB68d3wPQ4vqncQu7cj0s1uWeZOL6XyirHDhQyeR4K1xQSGXIpVIUEsdfqUTCiYoirIJDhCs0avnx5C5+PLkLV5mCASGx9AqKpmdgND0Co3A3aihb/y3lm3/GUpR2NhPw7DqBkDu/ROFT/wvbGTbkVSW6l9uEWstVEe0xZSUjWIyYC9NQhcTRNSCC73pPZOhKR66+Z/cu5fqodo1ShVgQBO6df9ApBo5rF8yfd3ZFJZfxXvex3BOfxGfbF/Dn6UOUKB0hoWVmA9+d2MF3J3YQ6e7Dt71vZFREmwa3ralpW+26kubmR++y0/gNfYi7yl35ca/Dk/uHnZnNThC0W0xkfjgSfcoG9niH81K3O8ly9XEuH+Huxff9b8M76wDq3X+hPbgYu7Hq5eDP0ETejB+CTSLlj4xkTqZs5gWNkRuMPhyQt8E9si0FGhOFWjN2AX7fn8MfB3IY3z6E6T2iGBYfiPwKKsgyI6E3Kqmc6dvmYxcEsnTlzu+zQiqjb1ALhzgYGke0hy9+8X2JemIpmR+NQp+yEZu6kMz3h9Li5e083j+WjFIDn29Jx2S1c/2s3ex4pC9xgVeml+SVyvrUYgK1SmQSCUlRPnTyD+f7PhPpteQLBAQ+MJvop3DF32JAs3chp5Ju4eEdC9ldnOXcRpxXAEuHTW3ydDgNSa6+Kjdv2FkKxkkkEj7tcT33xHXn5X0rWZTl8IY7Wl7ADetm0y0ggpc7DqOdTzC++jI0cx5GV61Kc5ncj41BN3I0egKufmG459mI2pxBgLuSbm1uxaPjYrQHl2ItzSL/t8cInz6r8Tp9AZisNoZ+s8MpBkZ4u7B2Ri/i6zjfVCFxqEY/jf+op9AeXErerPscKXoOryJh688sn/gmarORVbnHmXVyN8uyUwBYlXuCDgs/4ol2/Xmp41A86kgDIiJytTEj8xjh+lP4qY/XWjbGqzUmqaaOtUREqmi+d16RJqO6IHjGa0AQBMo3/kj+nIeBqpwwkY8uxLPL9U1tIgB7s8oZ+u0OyisFssGtAlg8tbtTDDTZrDy3ZymfHq1KQh5pKOfb5L+INpQDjsICvoPuw7vvXcg9Ay7YBteYbsS8soPMj0ZhzjuOtTSbjLf6EvHw33WGblT3lluXd/6CYLBn1UPOqeKaQeYyN2+in11L4d+vULLEkUNGvXMexox9RDw0H5eojhfcr0thfvYR5/TkCwiLvtZZmXOcG9b9jN76f/bOMjqqqwvDz3jcXYiRQJAEd3d3txZroVB3d6V8FSpQWqQFWijursE9SBJIiLt7Mvr9uMNMUoImgdDOs9Ys7lybM2Huvee8Z+93G4VAhUTKtMDWeKsCeWtTPADpyWncHHqIzetOJIBOp6PgxJ8UXd6NtryYFSh4z8IVtT7yoX5RDh9EhGGlk6GU26IxswMLeyQW9sisHXH2D+GGhxfbspLYnhRhSDUv1ajYmRzFTn3lQZFOh39pDqH5KYRKLeklNcNOXVapLTInXxReTbHr/CTWLYffc7TsQX1qkplEilh7qyBo5tmEm3Ov5UmXUbgJYmxPj0AGezdiS+JV4oty+fbqEd4I6XG/f8K7cjQ2h6vpgvjTxsuav6e0Ql7BK6+BrQvvZUUx6/giTtt5c6DrbLYUF1GgEv4+icV5DN23jA09nmCgd6MqP+NxIbhCREiMpSOWTfuhcG9AI3k2rbxtOZOYz8mEXDKLyitFWNdldDodqb9NJ+daGN8HdOV3r5bo9L9da6mc79oN48n6rYXfs1t9bFqPQqsso/jqPgrPrqfw3CbGpIbjUZbPS40HUyxVcNbMlhd0Wn7WrMSvKJcil4E0nPU9S67DVweiSS0oR6dDqMp7KQ03awUTW3gypZU3IR4Pf0KpKqYFtaGelR3fXw1jX+p1wz1SpdVwIC2mUsVauViCu4UN7o2HYWftg0NuEg6qEhx+fwHffi/RpZkFp3PgRGwBOWopfRcf48wL3XCwePgTmo8rU1adB2tB3AtwtODyq91o6+zDzKC2/HLtBHlqJd+FjuDZ8A18K7Vl49YFlY6fFNCCr1sPxvkRWczUFCkVIgTd7yAI3iTEwYNNvaZyIiOet85uN/xuz2QlMXSfUcQzt2uAQ1tvHFXFlKutiFUHoszxg+tqIEG/l9FL8KMOrzE6+hja4lzyw5Zh03I41i2G1Mh3rA4bL6URrs848nOwYN+s9vg5WtzxGJFIhHWzQUieXUvcZ11BoyJry6eY+7fGpsVQRvmGMso3lG2JV3n+5CZiCrNRaTV8eekAK2POMb/NYEb7hprSiE38q0ky9wegqvw9ubbstunEAE3t3fm5w8habJ2JxwGTIGjirtwUBMUiaOhihaa0kNTlsyg4vqrSfjrEj0wMPJ2QR59fjGJgr0AnNk0zioHX8zMZd2iFwd8LoH96JB9c24NCo+GqW2/6P/EGFsHdq91xkDv74ffOMRK+G0rptTC0pQUkzO+Hx7Rfsev0RKV9Wzl5IxGJ0ei0ROoNk++Fll62iESg08HRuFuLdIgkUlxHf4ZFUCdSFk1GU5yDMv06sR+1w23SAuy6TkdTmCmkViZfoTz5CmXJV1Bl3EDh2Rj7HrOxbj4YUTVn63U6HWuSLgMgEYkZV4upk/8m1sddYtyhFYZ0GGuZgmcaduCFRp1xs7Ahu1jJe1sSUGt1pGZkcDMmsK6kBmmK80hZMp3CM+tRi0TMC+jKCi+jGNwr8xqfR+zAQqv3Qaqq7s9xaAm0c/bjs/rtOe8Zym65DTvzs0gozjPsphOJiLFwJMbCkfXuTfk+sDvr5BDi3RSFVxOKzd1w9vS97++QWlLAtQIhrbm9sw8ibi0spPBsbFguT74MrYYb3n/dejA7kiJR67R8Fr6PqYGtcTWv2TTMRSfiDcuzWrtXEgMBdFotBafXItXp6FCcydQBz6KUyNmeFMmiqOPsTrmGSqthxP7lbOo5lX5eDWu0fQ+ThnYuiHQ6dCIRNywccOjxpGHbgIaunEnMR6eDXVGZTGp5ew/fukTmhvc5f3EHL7eYwDUrZ8P6Xh6B/NZxDPWsbi0OI5abYd1sINbNBqJ7chFlCRdxjztL/dhzTFbrSJGakWhuz4QW4/nuymbaXNtG8nsHmDT0XZ5+7XmWnE3jywPRJOYJonFaYTnzD91g/qEbhHrYMKWVFxOae+Jm82gtCXp5BNHLI4hyjZoj6TfYkRTJjqRIIvIrP0eVWg3xRblCMStLZ+F1k2OC3y5iIEBYjFVL6bk6hzNPjEZiKlJw38Rkl7DxchrjmnvyWcv+rIsPJ7u8hHVWbuxoM52SCpkjLRw9+b7tMDq6+j3CFtccqaXGyfM7RQj+k3YuPuzvP5t9Kdd57eQWzlXwuQUolchINrcl2TDhlw6OmZDlLbx0lX+n7x3LJ8f1eWbe+ACAlKUzCQjscNtJbq0IStWqO1px1AS/nkwwLK+Y0PyuYuBNsouVXBUH4Tz0K7TrXwQg+Zcp+H1w2uD/O9C7ET3dA5l/5RCfXtxHqUZFUkk+Yw+u4Hevs/zVbZIpWtDEv5ZVPq8AEPbsrT6B7l+ORXmbCMHw3NRabZeJxweTIGjijuh0Oq7oBcFAJ0tIuUTsj2P+UXX30c68nUrIpc+iE+SXCeJC7yAnNk1rg7lM6CStiDnL7GPrKNJXsTPTqHj7+n6GZ0SyxHwEyxUD8XCux6hG3WqsTRIrB3xe3UPK4icoOLUGNGpSFj9JSeQhHPq9jMItCJFUhkwswd3cmqSSfJIqpJvcDVtzGU3dbAhPLeBsUh4lSnWltOibWIcOwP/jCyT9NJbS6OPoVGWkLp1J+upXK3vRVECdl0LxlT1IHbyx7zEL+64zkNo8mB/LycwEYosFwbKPR1CNCyL/RpZfP820o2uEAgHABP/m/NhuBHYKY+EQR0s5fRo4sz0iA8qMUQmPOkKwRKnm5NF9WPw9A+viJAolcl5pNIgwR+OAb0b8KabGnaNIZEO5RIu1phApmtueU5UZiyozlmBWEQw8LxKTJrfgoo074TYeXLRx54q1G0r94D1bLGOszJqDzYbQ0M6F4qwsFp+IZ+W5ZAYGu/BS1wAk4rvfsw5X8A/s5h7ARfbeso/Cq4lhuVwvfN8kyNaZOcEd+e7qEQpV5bx7bie/dBx918+9V3JKlPx9UejMuVjJ6Rd069xwafQxQxEV69BBiBWWmAEjfJsyzKcx08PWsCz6DEqthmH7l7G551T6eDaosTbWJGUpEZTpcoVZEG5Ga978f9ShTruGR1kByea2xFi5YNW0r+HY/sEufLTnGgA7IzMeC0Ew9/ASlpxYy0ctJ1IqEUQUC4mMea0HMath+3vyfhRJpJj7tcTcryU9usPZkgIG7/mNMznJFMjMmRkyio+idjM0/SoZf7+JPGwZT0xawNNv9WTf9Sx+P5PEhsuplKqE1P2LKQW8vPkqb2yLYHJLL17pFlCrf4N7QSGRGsTB+W2GEF+Uw86kKC7kpJBaWkBKifBKKy1Eo9Pe/YRSNRc4Q8M1KWzrP5kgW+e7H/Mf540e9dFYOjLvoBDhtuRUAuOae+JoZslXrQYx/egaAIMY6KBV80WncUwLbFOtYlF1CZ1OR3JBBV/cv14hJuE8qqw4JDauyJ18kVV4yZ19ESmsiIu6QGLkWcoSL2OdG8XvqlSOOPhxys6bbLkF2TILos3cyVLYoJOq0N6890m04BqPc71sxru2potzM66kFfPp3usoNVq+LWhBgEUXepQcRlOQQery2XjNWWOY8E4uzkclFSFT6yg1kxK47gv+6DK+1qo8x2aXsPe6YMsT5GhOe99bJzPKVBoupRZyKbWAy2mFXE4r4FJqIWmFQnaAVBTAkcZjsLmyBm1pAUnfDcfv/ZOG4oVmUhlvh/ZiUkALXjq1hfXxlwDYlhRBz50L2d57Bo5mdbuaugkTdyI8tZBOC8IAcEHoAen060Pcqx5fzU6IAGDIc7/dsu12UYMm/nuYBEETdyQxr5TCckFoGyU5S+zH76LTp+6JLe3xnLkc3SfLHln7jsfl0H/xSYMY2CfImY3TWhvEwLeO/s3n104a9g8qymTe1a00dvTC8oXdHDkgJTsxj7z0IuYdiGZG23rY11CqkFhuhufsP5E5+ZC9fR4AeUeWkndESAURm1khsXTAObA3SWZ2pBTno9Fq77mD3MnPgfDUAlQaHW/viOS93kFVtl3m6I3vm4dI//tNcnbOB6haDBSJkFg5oikUOm3qnEQy175N1pbPqPfCZoNP4v3wY+RRw/Lk+qZ04buxKzmKJ8NWG97PatCeH9sPr3LwP765J9uvpuOszRFWiMSPrKq3Vqtj0Yl4Nq5fyVeZHyBDTZ7UjCnNxhFjpTfp14oILG+Gc5vpFI5zpIOvA9ZmUnQ6HSVFBWRnppGbk05BdiaXbsQTefEkIeooQtTXsNKVGj9Mp8WtvAi3zOsMkctx6DIJ87ZjuVycxwsnN3E0I4700kJ67lrIslYzeHNjFGdThLTaQzHZrDibzItd/BnfwgOF9PYRQHtSrhmWu7j6c7GKfWROvojkFuiUJZTGnkGnVlbyTn2vWW9+jz5DrrKU366fYm5wR0IcPKr1t77JyrPJlOsLnUxrUw95FT5vBaf+NizbtKksRopFYn7tOAaNTscfMWcp16gZum8ppwc/T5M7GOI/KhK+6oPyLmO5gKbDSTa3JVeqIEtZYkhBbO1th4OFjJwSFbuiMtFodfckCj8KBDuOX/l6z0I+Cx5gWN/cwZOFzQbRxufBPULdLGz4JnQSA3cup0CRhlos4a3g/ly08+Sl6ENYpUaRMK8PNm3G0GPit/Sd1IKCMhVrL6by+9kkDsUIhXlUGh1LTiWy5FQiI6r9jWsWHysHnm7Y/pb1Gq2WrPJikovziT22ksRDv1EslVNs6Yi060xKzG05lZbKkWzhuo8uTSFk43zCBs6hlZP3w/4ajxVzOvnh6enJ1oh0ItKL2Hs9i/icEnwcLHgysBWLI45zIicRiU7L+OQLPJN4mjYTPnqsxUCtsoySqMMUXd5FSeQhytKvE9V0JFg4YKFWojn2h2GaS1tWhCoj5rbn+uf0RJecWLrkxBIr9eZU20/4rOdAOvk5IBJBWmkh/7tyiO+vhqHUasgsL+L7hANEqJPZ1ns6A4NdGPvHWWKyS3jX7ClCSsNx0uVReHotqevf42STASxJvMr2pEh6yyTI1ELfObkkn547F7Gow0hmNqj5KvTLzxj9Iic2c0EkEpFRWM6xuByOxuVyLC6HM4n5KDW3F+3VOhiQM44wzyhIvkh5ylWSfp6A19y/EVeI/vOxcmBdjyfYlRzFpEOryCov5lRWIv33/MqJQc/+awppmfhvEexsgVRatWwT4m5NU/e6Yelh4vHEJAiauCM3/am6l59g3JWv0OmEzoN5/Q54PfMnMsd6wLJH0raNl1IZv+IcZfpBcd8Gzqwf3xD1lR2kXdnL4ZgzfO5t7NiMTb7Aa7FH8Br4Os5D3iEnv5C29VI4nZiHRqvjta0RfLD7GlNaevFcZz+CXasfzSYSi3Ed+xVy10Ay1ryBpjjHsE1bVoS2rAg31zQws0ODjqiLO2jUfOA9nbt7fUd+OhYHwLeHY1lyKpEXu/jzQhd/7Mwrp36IpDLcxn+NZYMuZG54H01JHgrPxsaXVxMU7g0Ryc0piTxEzr4fKTy7AbQadOXFJC2cQMAn4fccKRiRl84rp7cYjJ6tpAqG1mt8l6NMhKXHGpbbOtfjp/YjbpvC7mWj4PXi3wjWCMfInP0eiU/OlbRCpq++QGRcApty5yNDTb5UwYRmk4m3EjoodjIL1nV7gh5et0YUiUQiLK1tsbS2pZ6/EJ3WGfh07zVm7ohCrNPgp0mmmTqSvuZxtJIk4OgRgEOvZ7Bs1NPwnVuZW7O99wz67P6Fk5kJpJQU0OfvdZDpW+nzwlMLmLr6Aq9vu8ozHXyZ3cEXF+vKqUSH0mJYGn0aAAupjLbOPlR2vdK3XSzG3L81JZGHUGXeIOnHsUIUhj71ykFhwQfN+/D8yU1odTrePreDLb2mV+OvbeRGjtE7tFtA1ZVRlRUKrJgHtL1lu0QsZmmnsWh1OlbeOEeZRs3Pkcf5sX1dk3nujcDiLA47Cl46O5IimVK/FQASsYjeQc6svpBCVrGSq+mFdbLzrCktIHXp0xSc/Ivf2xp/J3MaduDr1oMpzn+waoE6nY7917P4fH80+65nAUHgKgVnoaDVavcQDrs05N0rW+maE0vBqTUUXdqJ+xM/Y9t+AtPa1mNa23rE5ZSw9FQiPx2LI6tYiLjXYYzTvJiST6hH3bAt+CcSsRhXc2tcza1pPvg1kmJPUHhuIwDi1HC8n9+EZZvBDFq3iW0Fgs9wuVbNqcwEkyB4Fw6kXseJQjo2gYhMNTqtlB2RGczq4ItYJGZ1uzEcKkzB58ivOEUfAECZEYO5T/NH3PJ7R6fToUyNoujyLorCd1ISdQidvjiWDvisfg/iLIQobb8SoZ9XjoxEiRv22gIcdXfPAMkTWZNhFYDWtRGOQW3oMWQGA80rz4K4W9gwr/VgZjfswFtnd7A69gIgTGC9c3YHX7YexNkXu/DU3+GsuQhv2c5hsnglp+282ZKZQcaxdbd87k1/XB06Zh1fh6eFLQO8a7bQVHyucVJvxYUM/ri4n+h/+F9XhZetGU3crSlXazkQnU2uSspfLb9gQt4EtMW5FF3YQuJ3w/B+dh1iReUU5L6eDQgbOIc+u34hoTiP01mJXMlNp6lD3ZvwMlF3mb02nEupVT97SyQaLOQPx1ri6/4BODoa+3ojD34DCM/fqlKFTZi4H0yCoIk7EplRRLfyU3xT+BViBDHQrutM3Kf8aBj0Pgp+DIvl2Y2XkWpVtFRHMck2hsHpEcQ9fwo0aqGD1ny8Yf/Xow/yjKMbzu8ex9y3hWH9O72DSCssZ/2lVLQ6KFFqWHg8noXH4xnUyJWvBzeigUv1o67su83Etv0E8o4sozjiAJriHDTFOWiLc/FVGitCHl35It5iEdahA+5wNoFhTdx4tVsA3+srJBaUqflw9zW+OxLLi138eb6zH7b/EAatWwy5q7m0ZXA3LIO7ocpJInXpUxSF70CTn07Kr1PxfnHrHUWnzLIiPjy/m4VRJyqlZ70Z0gOLR1B1+nFjemAbQ4rpycwEtidFVFnsQafTEbnidaaUbRbeiyS4jZ//sJtLYm4pXX48Sk6Jiq+LFuKsy6VQImdGm2nEy4XOubelHfv7zaK+zf0V6Xm7VxBu1ma8vyuKmPx6xEjrsU4HqMElR07IEUtCYq7S1M2Gpu7WNHKzRiGW0VPehZO6lSDSgWMKZHnTzN2eKa282Hg5jcM3hMFaRpGSD3Zf47N90Uxs4cn0tvVo72NPjrKECYdWGlK2P2zW947eSq5j5xH/ZQ+0ZUUUnttI8qJJeM5aafDfnNWgPd9dDeNGYTZbEyM4mh5bI55Z7X0c+BZBDN4fnUUr51urd5t5h1B0YSsAZfEX9BM4lZGIxSzuOJqNCZcpVitZH3+J79sOeyyjd/pmRPFbvTYALL1+2iAIghBRvfqCkD59Ij63zgmCZQkXSVwwElVGDJlyS5L0lYR7utfnB71A+8/hc1ZROe/vusbWiHRszaT42FvgY2+Or70FPg7Cv4l5pXx5IJpTCXkVjhRRT9mEQT6NWZFyiAJVGakSOc+EjGBQThyvR2zHobSA5IUTKby0i7LhH3O6MJsTGfGc1SQR0l6Gg8aNo+EiiBPOqAOazT/MkMauvNItQB/RVDejMEUiER4zl5HwzSDB57ckj4Sv+1Ay9TfOqaKNO5Za0db28fXVfFhMOfwXOOgnUIOkkNiIwzdymNXBFwBLqZzJ9VuScuhn8vTHiBWPR+qmplSoYJ+7/ydUmbFV7rPItz2rvARxU6rT4VvgzRC7H4iTeKIRCWKBua4MD00GHtoMPDQZeGozsNYVI3UJpF5wS4JD2tCyQQMUsnsTF/ytHfmr2yRmN2xP312/UK7V8NXlgwTaOqPT6bDwi8ddEs1RZRlHubVggHdpLgqVEMNoUa7meRs7vivIQ6vTMebgHxzu/wwtnGrOWuHNnvXZHpFORpGS69mlt2wXiaCxqzVt6tnRytuOpm7WNHazNmS9FJapcftwNyVKDT9Hinh57gZSvxuEtqyI4ks7SZjfH+8XtyAxr3xfb2DrwqyG7Xnr7A4A4otzTYKgifviUmrBbVNyLeQSLB+SIGjCRG1iEgT/gUql4s033+S1117DxeXBfNP+TZRd2s43hV8gqygGPrkQ0SMaLGqU5Xyz6m+iT+5kseoyzVQRmKOEfCivsN8ep0Au2gqpeU0lEj58cT0Kp1sHw67WCv5+ohVxOSX8eDSOX08mGAqTbL2azs7IDJ7v7Md7fYKwMaueACpWWOLQaw4OveZUWt/x+il+DhM8dm7IrUj8bhhes1dh03rUHc8nlYj5anAjnu/ixxf7ovnlRAJKjZa8UhXv74rih6OxrJ3Sii63iR66GzIHLzye/oMb74Sizk2m6OJ2cvZ8j2Of52/Zt1yjZsHVMD4J30u+0ljh1c/KgXcbduXJJh0eqA3/NXytHfi+7TCm6tOGpx/9m0vDXq5UfbEkN43z30+lS9xOALSIcJ+57KEX9NFqdTzx13lySlT0Lz9Mf2UYxRIZs5qP5apeDPSwsOFAv1kE3KcYeJPpbesxuaUXqy8kM+9gDJdSBT/TjCIle69nGTyJQCh6ZGMmE65fT1ewTwOpihEd1awZ2gWJWMSLXQM4l5THd0di+fN8MiqNDqVGy9LTiSw9nYiXnQK5XwQpKmE2uL9nQ15q0uWObTT3b433S9tJ+LofOmUJBafWIJLI8HhqOSKxBLlEykfN+zLpsFCE6Y2z2znc/5lqiyV9GzgjFYtQa3VsvpLOa+1vFQTN6xuvu5Lo47edDDCXyhjk3YjVsRdIKy3kWEYcnd38q9W+mibo20S8vG4/QFXlpaJ7wYugokyuWTlzMC2GG4XZ3IxXa+9j9Kw6HpfLzHY+tdzie6fgzAaSF01CpxSq64S7BBm2dapCPFZrtCw6Hs+7O6PILTVWIb95fdyJYFcr3uhRn/HNPZFJxLxV3IZnjq9nc6JQDX6rgy9HO8xieOIZblg4Eq6zJGfr91Wc6Tq4Q5lCgnm5Bp3+57z5Sjqbr6TTytuWl7oEMCrUHW1mNKXRJ5C71se8/q3pvI8CiYUtPq/uJvnnCRSe20iiRMHES0fIUgj3WnGJJdq4UH44nMjScQ/2DP1PIlWDbzjb01Votc0QV+grakuNUTYSs7olyP8TdWEWOXu+J2fvD2iLby3cJnP2Q9GkHwtdGrIg3VgsQ5PUiG35LiAFhVTMx32C6B3kjEQkQiLWv0RC1LK1Qlrt4jxd3QL4rElvXg4X+gMzj/59233FWh1ts5OZkXyMNnmJfKAehg4xoGPm5neJbdiPzW6NKVYr6bfxK7ZJNQR4NcK6+RBkjtWLkg1ytmLfrPb0WnSC9MJyLOQS2tazo6OvAx39HGjnY39LZktFrM2kjApx5/czSWQVKzmgCaHva/uIn98PbXEuJVGHif+iB/Ve2XlL8ZR6lsZ7f3zRrf+XJkzcjRB36yqj8Dptu/DwG2PCRC1gEgT/waeffso333zDzp072b9//39aFCyJOUn/0y8ZxECrTlMfmRhYdGkXmTvmkx9xhAHastvup6gXijy4Fz9gDuXCLOQ3vWZUKQZWxNfBgnmDG/FBnyB+P5vE1wdjuJFdglqrY/6hG6w4l8znAxryRCtvxDXsPRVsb/QUi7VwAI2KpB/H4jFjKXadptz1eE9bcxaMaMrrPerz+b5ofj0pCIOZRUp6LTrOL6NCebLNg3XmpFaOeD69gvgve4BOR8bat7HrOAVJhQ7WsfQ4Jh1eRWyRMR3aVm7Gu6G9mBvciaK8/DobKVIXeaJ+K7YmXmVd/CXSSwuZefRvNvR4kvTCcjatXUbjsLdw0Bg7teEdPqVJx0kPvZ3zD8VwIDobF0027xcvokQsZXbTEVywEu6ZbubW7K+GGHgTuVTM5FbeTGrpxe6oTBYej+d0Yh7J+ZXvA1odBjFfnO2N1j4NgLPKSHRoAWEWt4WXHcvHN+eLgcH8fCyOn4/FG9IfkyTRoBK8jiQaBQ1ULbmYXIivgzl3wrJBZ+q9uIWE/w1Epyoj//hKRFI5bk/8jFimYLx/M766dIDw3FTC0mPZkRRZ7ZQsW3MZ3QIc2Xs9i8iMImJySnH8h25hXt9omVAafeyO5xvl29SQfrY2LrzOCYJ3Q2bnjlWjHgxLu8xX9bsDsDz6DM/VE6IEQzxsMJeJKVVpOR5fNwaFOp2OrC2fkbnuHcM688COxHZ5BmLOAdDBxbfSMQejs3hu4+VK4p+lXIJIBEXlty/O06aeHW/2qM+Qxm6VnmGelrZs7Pkkf8ddZO6JDWSWFZMrErNEH2n5T0SI0BmKuoBWf65SMymyBmdRpXsiynWh/MYpTkV+j536ND4qo2Bi5tMceYfpaHvOqOT79SgQy83xenYtMcvn8GxRqUEMbFqQyi/h6yjVWhK314trBW1x9G2CdfPByJ3/HRVxa5I3Q3pg6+rM4fQbgk2ICPIdIph4YDXLuxm9SzWVCmDVTUFQlZ1I4YZPyTj5h0GgB0AkxqppX6xC+mPZtB8RMgvGHV3DuQpiICmB6PKF5197H3uWjA2lYQ1Yz9yNKT7NOFOUzp83zldabyaR0trJm3bOPlip7fl6ezbHS0RcEw9gqNtViDb65IqAD6N2k6aw5pR9PTIlcsYXZbHiz5exWfUi9l2m4zT4zSqjzO+VJu42RL3encvxabQJFCYk7ocnW3vz+xnB5mDZ6USGTWuD75uHiJ/XG01+OmVxZ4n7rAs+r+5B5uBpOM7HyiQImjBhwsSdMAmCFVCpVPz2228cOHCASZMm0aNHj2qJggUFBRQUGDtAqamPT3lvrbKUlMVPINMJA+zd1n14fvqvj0QMLLy4ncRvBoNOyz+TTuWugVgEd8eyYTcsG/dEauPCjxFHiTmxAYB+ng3o6XHvJuyWCimzO/gytbU33xy+wad7r1Os1JBeWM601RdZeDye74c1oW2FaJPqUrGKYZJnU7i+D3RaUhY/gba8GIees+/pPF525vw4silv9KjP3A2X2HwlHZVGx9TVF4jKLOLT/g0fSMy0DO6GQ6+55OxZgK68mNyDv+A08HUAStUqhu1fSmaZkMwmEYmZ3bA97zfrg5O+mlvRbc/86KjL16ZIJGJRh1Ecy4gntbSATQlXaL98OYNO/MmI0t2G/TJF9mxp/B4fTZ370Nt4LimPt3dEItJp+aT4e6SU8kzT4Zy1EyK4nM0s2dfvaRrY1tyEikgkom9DF/o2FM6ZU6Lksr4iYXiqUI0wNqeE1t52fDEwmLeulLAp4QrxJXmsi7vEWP9mlc7nbmPGR/0a8mbPQLZcSefn8+Ec1OlTwnSgiW/ItxFJfLtfGIAMx1jRrfMPR3G0kOHvaMk7vQNxsJBj2agH3s9vJPHbIejUSvKOLKXoyh6cBr2JXZfpfNayP4P2LgHgrXM76OfVoNrm5oMbuxqiJHddz6VNYOUIOqmVI3L3hihTIymNPY1Orbqt1UN/z4aYS2SUalSsj7/EN22HPBLz9epcm7btJjD49zn8z78LarGE5dFnmOstFDOSScS08rbjyI0cIjOKyC1R1lgBqQdBqywl5ddpFJz8y7DOrusM3Kf8yImdiwBBfGvrLAzAE3JLeG5DFJsisg37i0TwVDsfPunXAEdLOTklKuJzS4jLKRX+zS2lXK1lbDMPugU43nZiRiQSMcavGT3dA3np1GZ+jzlr2OasURKSE0/TwjRCC1Jo49kY3YiP2JSZyMbU64CxWIBKVgReUXxV8AMDssOr/Kyy+POUxc+leNtH2PeYjUP3WUjt3B7471hddCIRb/i055q+ImlgUSaLL67FWqPEhnJctTmoj4aTfhQy1rxGvZd3YBnc/ZG191Fyu2vzmeCOeHl58aquG/02rmZPnvD7+SvhLEm7cljcbDCOOKIt1YvYYgki+Z0nWR42mpJ80v96hbyw5aAxRt2KpHLsOk/Fsf+ryF0DUGrUfBq+j88u7kN90xZFJ4I0P8jxwFwm5tP+DXmus/9DK1wkEon4pcMonBSW5CpLaONUj/YuPoQ6eCATG9MZR/kVMvC3k8TlwBJ1R4ZzXf9ME+MxcxnlyVf4NSWSkWX5XDezJcbSiecbD2FR+DpyDywk9/Bv2HedgdPgt5A5PFg6sa25jIbOFvctBgJ09XfE18GcuJxStkVkkFFYjot3U3zfOkLCvN6osuJRpkQQ92knfF7bg9xVqJhcz9LOcI6E4rwHarcJEyZM/JsxCYIVOHHiBO3bt6dLly4cPHiQbt26VUsU/N///seHH354y/rc3FzMzW/fGarY4apNtDodO9Ou82vsWYrU5cwKaMMwj2DEIhGFm99HmRoFwBlpI7Y0eJPJuXefWcvOzr7rPveDKvkSOT+MAX3HK0nswjmzUFp27Eto+z5I7IToOjWQr4LCtBQ+OLcLEAbvb9bvdNs23e3v/FQzBwYHNOPD/fGsvSIMuk8l5NHu+zAmhrrwSS9frBU1cwl5mFmTUlZItMIWi+5zKTkglIJP+/0ZinIzsOw+957aDGAB/DrEn4+tJSw4IXhmfbE/msvJOfw0JBCLe/SoqYi43XTY9xNoNWTt/BZaTUEklfN7/AWDGNjG3pPvmg0k0NoRisvILi675zbXFo7/DJnSc7trs7CwsMZ/w/dKQZma2LwyorNLuZ5dim9RU1IlQpXmU9pLTLC8AXrrnSvO3XEcM583A+pRWpjPrY48d/msavyflKg0jF0ejkqjY3bpalqpw5nbZBin7AXhwkFuzrp243DVyGr9b9nYDhrb2TAu+J/RJkqerteCTQlCGuSnF/bQ08brtoJIKzcdsRZnoESIfPJXNyChzB51hUioioTFGqNhz8Rns3Z8I2Hw59EK2yeWkrdsKmiUqHOSSPt9DhmbPqFp9+doY+/BqdwULuaksOLKCQa6N6jW9+/kYYyw2hqRwTNtb/17i71bQmokOmUp6ZcPIfO+vZF/Txd/tqZGkVSSz57oy7SqEGVR09zvtXm35yaA1r8bDjotXbNvsM85kPiiXHYlXKW/SChoFOpixhF9nZU9lxPoGVBzEzv3gyY/lbwlk1EnXhBWiMRYD/0YeeenSM3J5Wy2IEIHWzuhKijm09PRfHowgVK10Ze1jZc1n/fxI9TNCsqLyNF7ZviYg4+nHDzlgJ1h/5wc42/2TvyvcR+mezUjviSPpraueCosKdn7DcW7twrP4bwkRFd2MQwYBrxbJkjlEq2xbT/7tKB35mVkOi0qJJyRNeGkrCmdlOdopb4q/A0KMsja+CFZWz7DrPlwLLo+g8yzyYP8OavF11FhrNOLgfYSGUs8gnBRTKI87TppcVdx0RivKZ2qnIRvh2I/dysyD+E39SifbzXNze9SnWvz1frt2bO+FLwiQawlLD2WHgeXsLLdaDz10VkihfU9/x4fBjq1ktxfxqCKDjOsEyksMe8wFYuus5DYuFEInIu+xPMXthNRmGk8uNQKkhtAmRXtvW34bmAA/g7m5OU+vO9XUFCADfB+YOfK63PzKr13lcH2SY2Z+Hck51MrT9VqggchDR6EB/B3ST59jywnvbyYU/b1+CR4AB9d3QoaFbn7fyb30G+Yt5uMZc8XkNjdvx9fda6Z0Y0cmReWhFqr45ewa8xu4wEyB2yf2ULuwpFoMq6jyorjxscdsXt6LTKPRii0WiQiERqdjpi8jPvul9Sla/x216YJEyZMVAeTIFiBzp0706iRYODv7+9fbVHwpZdeYsaMGYb3qamptGnThjKFhDIzKVJ91buqqO2bfk55CZMPrWRXcpRh3VNnN/Fbwnm+8wvB6tDPiIBS5Lxr/RzDvZ3uqU012W51XhoxSyaBUhCcNim6s8DjdbbPbEczz6orGS4O30+WPs3jifqt6OJ/57S8u7XX0RH+nubB0dgcnt1wifPJQsdg5cUMDsYVMH9wI8Y086h2SmwjBzdSUgpJLy8ipu9zhNg5k7nhfQCKtnyAtYs39l2m3VObb/L9aCdC6zkza204aq2OrVE5ZK+5xq6n2mFtdp+XvqMjytajKTj5F9qCNGRxh7FtO5bfwy4adnkppDsujo6US6SYSWSYSaSY6Qsr1LVOzO2uTWtr64fW1sTcUrZcTWfzlTROJ+aRU6L6xx5SmtipuOwlQycS8XrwALae/Yv6o75gVI8nq/2be5DveS2ziBnrLhKdU0oX5Wlmlq7h2aZDOebgC4C93Jx9/WbRzLH2hKR7pb+jI52uhxGWHsul/HQ+u3GMPh5BZJUXk11WQnZ5MdnlJWSVFXMo/Qbp+uiVbm4B7O07nbxSNesvpXI8LldIKY4znlskAn3NEY7E5/PS7gQWjwnFXCaBLhNwDGhG5sYPKTj9N+h0aPNTKdr4Js837s9EZ+EZsyzxIlOq6a3p6AhN3a9zKbWQ0ykl5OrMqO9U2axf3KQ7qadWAlC241PsJnyDmU+zKs83IagVW/UTQduyb9A3MKRa7XsQbndt2tvb38Nv1pGy5oMZduM8+5yFyPCNWdFMaiH4QHZvoOQH/STJ1VwNYx7BfUmrLCXmi2GoM2IAEFvY4vXMaqya9gXgaHosSq2Q+tvJPYD3D6UaqskDuNsomDeoERNaeNaaFUOXf/5dJnxBSavBJC+cgCo7odImkU6HDhHm5Wra5CZwyr4eNywdeaXj08wPaoVNQF+unsvjrxMJLC4fQ7A6hsmlm+lffgQ5atCoKDuzhrIza7BqNginwW9jUSHVvTY5mRnPF1FCRWGJSMzfvabRqUJGwZ87o/h61wV8tSnMM9+Kb+p+dGWFFC6dTMAXUYjlgv9bXXu+VYc7fZd7uTa729ljscqNkhvmSH2vopaWklpexNBjq9iqLsUJkFra1qm/WdqqlwxioNjCDvMus/Aa8prBGiUqP4O5JzawN+W64RgJYhQ5/pSkuANiXu9en88GPFgWRk1wr39PR0cIe86ZSavOVyoI1GTBWWzNpFjIJVjIJPgp2pElO4QGNetcGjCxXijBh39EW5IHGiWlR3+j7NQKHPq8iPOQtxGb3V/xvQf9/5/VxYx5YcKEyapLWbzZt4kwGefoiMO7R0n4uh9l8efQFmaQ99MQvOaswbFJb7ws7YgvyiW5rOiBPrsu/V5NmDBhoqYxCYL/oOJNvypRUK1WM27cODZu3IiDg8Mdz2VjY4ONza0+KW22fGeoyNbdLYB1PZ7AXmFRs1/kDlzMSWH4vmWVPN9ucjIzgfYZ8Tzp14ln4o7xg9lEEiQehHo8XL8XnVpF0o9j0OQmA3BK1pTFXq9wdE5n/Bxv/7e6lGtML3u5Sdcaa09HPwdOv9CF304m8Pq2CPJKVSTnlzFuxTkhjXh4k2pVrezi6m/obPbZ/QuftujP9LHzyFz9KgAZa97AptWtleLuxvS29fB3tGDksjPklqo4Hp/LkCWn2D6zrSBe3AdWoQMM6W03B4V5SmNs2rhDK6o8TiGWYKewwF5uLrwU5tjLLbBXmONn5cDUwNYP9fcPt782axOdTse5pHy96X4aF1JuP+vsosnmreJFtMk7Ty+3pyiRyimTyLB7dQc+/i1ue1xtoVRrmXcwmo/3XKdcrcVHk8y8wvl849+Zow6Cp5aNzIzdfZ+qE2LgTd5s2oOB6b8B8M2Vw3xz5fAd93dSWLKy6wQkYjGOlnJmtvMxFJ8YuV3YRwSovhrE8bgceiw8jkqjY+W5ZKIyi9jwZGu87MxReDbCa85qypLeI2vzxxScWgM6HaFXdtCgWzBRiDiQFkNYemyVRSPuh2lt6vHipivogJ+OxvG/oY0rbbcM7m5QMEsiD3LjvebYtB6N84gPUXhUnjAZ6BWMhVRGiVrFoqjjPBvckcAKlgYPg+pem7ZtxtD5zHqcyovIUlixKSWSxKI8vK3s2H3NGNljJn00hbHywpaj0ouBctf6eL+wBYWHsZLtHxXSdUvzrPhDLwaKRDCnrQefDQ69/wmdGsAiqCP+H18ke+d8lGnXEMktEMvNYXOafg8RXwa2pFdWFhp07JVa0Db+Gq/bePLJgB681zuIRcfj+faIgrcKAphv+SRjynYyrnQHTro8AIoubKXowlYibVqyz/sJEhzaYGMmY3wLTwYGu9S4ABpTYIwUmlK/5S32Is938eN/h2O4Wl6fsZq5nPYrRRt7HFV2AiVRh7Fq2qdG21PXuZdrc1dUJiVKDWCFY1o7HBpfISI/g0JVOcnKcpwAuUv9h9Lee0GVnUDOXiEjQyS3wOf1fZRY+xjEwPPZyfTZ9QtZ5cYa37JyW1QJgZSUC5MvHXzt+aR/g0cmBt4vFnIpf09pxZgtxnVpheWkFZZX3tEuALyECaIRqXYMbLSaOezA98pSdKX56FTlZG/7gvxjf+A67mts2o6tdb9of0dLutd35EB0NhHpRfx4NJbnOgt+t1IbZ3ze2E/iN4MpuXZEqB4+vz+u4/+HvdyceHIpUN3eg9yEiX8rniUxxH5ya1GUMqdGj03FdxO1y6PpET9G3BQFCwoK6NGjB927d2fIkCF3FQPvlQNpMfTf8yuFD+khtSrmHO23LjCIge7mNjztPoh6ue2gVLgp6EQiltZrzZA2U9ns2pJJLT2Z0KJmBvmZZUX8Hn2G5ddPsz7uEruTozieEcfl3FTii3IMf4f01a9Sck2YuU8Su/Cmw5tsmtnpjmIggGOFG5u6QgpTTSARi3iqvQ+XXunKqBBjmsTBmGya/+8wz2+8bChqcL+81LgLQ7yFgbxWp+PNs9uZLndA12kqAJrCTLK2fPpA5+5e34mwuR1xtpIb2jty2Rk02qrTIW9HWdw5w7KZjyBKLes8DivpnY3hy7Ua0ksLiczP4HhmPNuTIll54xw/RBzl5dNbaLD+S5ZeP4VWV7P/X3UFrVbHV/uj8f54L62+PcJHe67dIgb62JvTt4Ezs9t783fQBfaVPEdv5QnmBXSjRCr8vw3zbkwLv9une9YGOp2ObVfTCfn6IO/siKJcrcVCW8LC4i844OLDH3p/NjOJlN19Z9LKqXqVCGuaAd7BfNm0D+aSO1cIF4tEDPZuxKEBs/GwqDr6uCISsYhO/o6sf7K1wTbgTGI+Lb85TNgNo8hg5tUYr2f+wu+9k4jk5oiA6Ve3G7a/d27ng32xCjzZ2htLuSDuLz2dSHG5utJ2uYs/XnPXIXM2FgkpOP03MW81IXnRFMrTjMbyNnIzXmsi+KMptRoG7V1iiJx8XDDza4VMp2VismCwr9Zp+fbqYY7H5bDoeDwAduYyprZ5cHP8B0Wn1ZC942vDe6/nNlYSAwuUZazQFxOxlChYcdDYL/hrUks+6OH7SMTAm0gs7XAZ+TFec1bjOXMp7k/8hA5BANAhotvg19nYaype+muoTKPmwwt7CN7wFXvTI3i1ewCxb/dkwaD61Pf142eL8fRy+I0PrJ4hQWz0EWxYcJY5V55j/PEnSD65kaG/HqfbT8c4WcPFYHp7BiHR+2SeyIhHp6v8THSwkPNy1wAAirRS1tqPMWwrurwbE5XJLlYyY40xa2Be/xCDz56ZRkXDogyQSHEZ9dmjauItZG7+1OAZ6DToDcx9jRNux9Lj6L7zZ4MYKFWbQ3IgquuhUG6JWARPtPJi87Q2SB/AE+9R8k9/Qz8HC1ys5FgphAJFAOS7gFp/v7HJZFt8CQPietDe4md2ek5FIxUiZNW5yST/PJ74L7pTllC1d2hN8tWgRtxs/js7okjON05MSyxsqffKTmxa64vZaDWkr3yegmzB69RS+uh8Y03UXWYfW0enbT9U+Qo3P0yM4sKjbuIDk2TuT7JFQJXbtGWFqPPTiP2kU5Wv1GX35mFv4vHHFCF4D/j7+7Nq1So6d+7MvHnzeOWVV6p1vmH1GmPh4siB1BhSSws4mZnAkL1L2d57Bua3MXyvLiqthtdOb+Xbq0cM6zq6+BJY2ppFezIABdACqWM8UpcYyiQyUs1swCeWMndr1LrGKLh/77mbJBXn8fXlQ/wSdYJSzZ1Fs5cdXZm2+zsAypDzvM2bfDmm0z1F4DmbGQXBjLLaKWfhZWfO30+0Yu+1TJ7beJmI9CI0Wh3fH4nlz/PJ/G9IYybeZzqXpUzBhp5PMO/SQd46twOtTseWxKtctvHjI6cApOXFJJ3bTpZTY9LlCmIKs7lRmINCImV4vSZMDGhBM4fbpy43crNmz9Pt6PbTcfJKVeyIzGDtxRTGNr93obfkuuBnh0iMub9QgbKrWwBnhjzP8ugz5ClLKdOohZdapV9WkV9WQqFWRW55KbnKUjT/EP4yy4qZFraGxVEn+bH9CJrXoQiz6lJQpmLKqvNsupJeab1IBB187BnS2I0hjV1p4GJFefJVUpc+ZagGe8zehw3ugqeWvdycnzuMfKjVmq+kFfLSpiuVoqpkYlhv9htFyhI+CBpqWL+owyjaOvs8tLbdD9P9WjKqQUtWx15ApwNHhQWOZhY4KixxVFjgZGaJo8ISheT+H4eDGrly6vlODF16mmuZxWQUKemx8DgLhjfh6fa+hv3M/VvjPuUnUn6dSr+MKH7xbU+0hQMH0mI4kBpNd/cHj5ixM5cxuaUXC4/Hk1eqYtX5ZENU401sWg3Hutkg8sKWkbnpI9Q5SaDTkn/sD/KPr8SmzWicBr2FWb0QXmvanb/jLnIlL51rBZn03vULB/rNwtHs8ZhFljn5Ija3YWzKRRb7tqdELOWXqBPsOGxm2OeLgQ1xtX74FW4Lz24wRAdaNRuEmVflaM4VMWcpVgsVr5VZzui0wjP30/4NGdPM45H5m94Pg7wb0X1EAJ+H72fe5YMotRrii3IZdeB36ls70crJi4YWDnw+Jgi5qgGrz2aw5aoNh0oH0KXoAFMK1hCgEQbvzdRR/FTwMfkiK04VNuWbK6HYNe3FSyP7EORS/eqtzmZWdHcPYG/KdSLyM7iSl0YT+8qeaC93DeCnY3FkFin5Mt6dEWIpaNUUX94FfF31if+jPLPukiHKbERTNzo3sOT6JcF/uUV+MgqtBpexX2EeUHUF64eNMjOOvCNCoSexpT0OfZ43bNuXcp2h+5YarkeK7FAnNAGtIJiNa+bJ+32CaOByf6mydRERcOPtnob3Op2OcrWWEpWGOcfL+CvhNEg0YJMF+a7ki6x4uXw47tad+EL3B63yDgJQEnmIG+81x6HXHJyHf2iIsqxpWnnbMaejHwvCYiksV/P8xiusfaKVYbtYYYHnnNUoNjUxWO+UlJeAmTWW4gcfx5j493I2KowIrY4GqpJbtqmlFlgokx9Bq2qGVT6CZhH27K0RgtKlL6ItL66y+mN5Yu2L+ybqDiZB8B5ISUlh+vTpNSIGAixoPwIvLy8i8zLosuNHMsuKOZgWw8j9y9nY88nqN/gfqLUaBu35jd0pxkiQOQ07Is+szzfH4wAQi6BHfReedirCbvc7fBLUk0OOwozC2rhw8pVlbOk17b4HzdEFWXx56QDLo8+g0vsi3Y352enUd/CjS04sH1jNoXOn7kxpdW+RRy4VfExqSxC8Sa8gZy6+3JUFYbF8sOsaheVqMouUTF51nh0RGfw0sim25vcu8IpFYl4P6UFb53qMO7SS9NJCYkvymdxkmHGnhEu3HDf/yiHmXzlEsK0LEwNaMMG/OX7Wt/qdhHrYsu6JVvRceByAz/dH37P/oba8hLIEIeLGrF4okgrelw1sXfis5YDbHpudnW1IxdfpdBSqyslVlpBVVsL3V48YKloez4yn1ZZveaZhBz5u3g87Rd2qQni/XM8sYujS00SkC79DiVjE0MauDGnsxoBgF5ytBEFCqywjc8P7ZG39whCpUC6W8lnoCMO5vms7DDeLh5PinFVUzge7r7HweHylKNIe9Z343nYn+fuOML3lJMr0UXdzgzsypX6r252uTuBv7cibIT3vvuMD0NDVmlPPd2biynNsi8hApdExa+0lziXls2B4U+T61FS7zk9SHHmI/LBlPBMbxkuNhwDw3vldHHYLqJbYO6ejLwv10W8/hMUxo229W84nksqw7zYT2w6TyT34C1lbPkVTkAE6LQUnV1NwcjVWzQbjNORtdvd9ii7bfyKmMJtLuan027OYfX1nYSM3q+rj6xQikQiFdwi218IYlXKR371aUqRWEqG6DtSjvY89M9s+GvE699CvhmXH/pX7Ejqdjp8jjxveqzIFYWpySy/e7Fl3UizvBUuZgk9a9mdqYGtePLWZLYlCIZHowiyiCwWBiKv7AQiwdqRNBy9G+4UwwucrRLqvKDi7gcwtn6GMF6IlbXVF9FYep7fyOJxYSOIpJy55dqRNr1F4dRmPqBqD/DG+oQa7jjWxF28RBK3NpLzdM5AXNl2hSGRBom1TvHPPU550GVVuCsJk6n+beh/vAWsng6+qi5WchaNCWBu+2bBPu9wErEIH4tjv5UfUylvJ2vwJaISIasf+ryAxF56xO9OuM/3sRsr12yhwhMRGoBMzoqkbH/ZtQJNqWMTUdUQiEWYyCWYyCS+GtBcEQaBDcxW95UGsuZhCRHoRqRJnnuAlXg4dxazMn1CmXAWdlpw9C8g/8Sdec9di2bDmrHsq8kn/BqwLTyWloIx14alsvZrOoEaulb6D87D3UHg2JvmXKZToxy7SnATKEsIxq/fw/XFN1F205cUElZfwd2HcLduGW/mgFNf9vs+dCE8tpNOCsFvWR5o7Y2nhht87v9yyraoUYxP/Xh6vGPdHxLVr15g9e3aNiIEVaWjnwp6+T2MnF4SPHcmRTDy8qsZTXZdcP20QAxUSKcs6jcUhP5hvDsUBghj41+SW7JnVns7ay3iUF/LjpY384dMQB723256Ua4w7uOKeRb3LualMPLSSBuu/5NdrJw3HWcsUvNakG791HMO3bYbycfN+vNakG7MbtmeIR5Dh+Hca9uUXqyEkBQzl+2H3XnnQuYIgeLP6bW0ik4h5qWsAUW90Z3JLL8P6VeeTafa/QxyPu/9Kc93c63NuyAt39BYTIcLLwraSQBuRn8E753biv/ZzOm77ga8vHeRAajQ55cYZrx6BTnTxF9LdL6YUsCMy457aVBp72tBxNq//4IUQRCIRNnIzfKwcaOnkxfIu4znc/xma6gdhWp2OHyKOErT+i8c6jXhnZAatvz1iEAOdLOXsfbod655szROtvXG2UqDMjCVj/XtEvx5I1qaPDWKgwrMx6yYtJFZ/e+7pHsikgNr3DVRptHx7+AaBXxzgx6NxBjGwvpMlm6a2ZmOHXLS7P+HVRgNJNhdSAju5+vG/NkNqvW11HVtzGZumteHtXkYPsl9OJDBi2WlKVcZ7pvvkBUjtPemdeZ2gIuHaC0uPrWRW/yA0cbehYz1hgBqeWlCpCvI/EcvNcOzzHIFf38B1wjdI9ZXaAYoubCHuo3aoFoxks38TvPWpn2eykhi49zeKVeW3O22dwsw7FIDJiWeR6FNacUxCItGyaHTII/H6UuWlUnx5DwBytyAsGnSptP1oRhyX8/R+fEV2oLSgo689i8eEPNTI4JokwMaJzb2msb33dLq7BVRpLxFTmM2auIuMPvAHTTfO56+4i1i1HE7Ah2eo9/IObNqNR2JTuaCbuzaL4MRNFC6dTNj7fdCqlA/cxuE+TQ1pw3/Hhd+SNgzwVHsfXPSWGxuVxqjO4it7Hvhz/03odMYiSwCLR4dilXWFrcf+NKzr4eCG19y/EYnrxrBDmXGDvLBlAEisHHHo9SwAq29c4MnT641iYJ4zJDTCRiHnwOz2rHuy9b9aDPwnrZ28aWgrXH8nsm8ws5MbV1/rzonnOmGnn/Cen1yPn9usxHX8/xDrRVVNYRZJP41FXVQ7Uc02ZjK+H268FmesuciPYbEUllW2zLBpPRK/d45SJhGuXzNlCTc+7sAPC7+n+fxDfLArCrXm8exnmqhZRAoL/N4Ju+X1uIuBTd1tCHGvOqK+RKmhWHlv43oT/25MEYL3QLdu3ejWrVutnDvUwYMdvWfQa9ciitVK1saFI9XoWNlzMmJR9TtOhaoy3ju/y/B+d5+ZhF3W8vGeSEBIXVw+vjmjQ4VBYUnkAf16EePbjqRhaRE9di6kUFXOxoTLTD2ymt+7jLtt246k3eCrywfYmhhRab2DwoIXGnVmbnDH2xaQSFgwipJSJXudg8iWW/JTw7ZEjG+J2X0Uv3AxrxAhWFq7EYIVcbcx4/cJzRkZ4s601RfIKVERl1NK5x+P8UGfIN7sGXiLZ8ud8LCwZX+/WXx/9QjHMuJxyk/D4fRqvMvyqe/gSefX92AuU5CvLGV9/CVWxpxnf2o0OoRe+bGMOI5lxBnO521pRzMHD5o5eNC1mRWH45WgkfPp3uv0b3h3s/bS68cMyxaBHe/afq2yjLwjS8k/tgK1Diwmf4+5X8sq9+3s5s+5IS/wY8Qx3ju/iwJVmSGN+IeIo3zTZghd3Kr2v6hr6HQ6vjoQw5vbIwwDpOaeNmx4sjU+DhZChOSZ9eQeWEjxlb2VjhXJFDgNeZfcTlOZt0VImZeLJfzUfkStCwKpBWWMXHaG4xU8umzNpLzXJ4i5Hf0g+wY3PpjId34dDRWFPSxs+LvbZGSmFBxAiAD9pH9DmnnY8MRfFyhRatgWkUH/xSfZPK01NmYyxGZWuI77muSfx/Ns7DGebToMEKIEe3kEVuv/eXpLN44mCN6UPx6No7P/nasiihWWOPZ9Afses8kPW07Wti9QZcYCUHx1H1zdxyJbD6aEjiJLLCMsPZbh+5ezuedUzGrJ2qKmMKsnCIIe5YX45qiJcZCATEX/dlSr+FN1KDi+CvQTHLYdJlf6v04symN62Brjzjke+DqYs2FqaxTSx//66u8VTH+vYDRaLdcLsjgUH8m18jzOZidxPjvFYPR/NS+dCYdW8sH53bwT2ouJTftgFdJPSGFMvkJe+G6uHt2KdfIJLHWCb5hjwn7+emc4/d9bj73l/UfrOZlZ0sO9PntSrhGZn8Hl3DSaOlSOEjSXSXi5awCvb4sgTNqcZxEKaBVd3o158KBq/nUef1p726Gwd0AsgpEh7vS2TiX2y16cCB0HgJ1WTd9nVglFaOoIWZs/Af1EteOAV5GYW/PbtZPMPLrW0I8ixw1SgnCyVLDrqba08LJ7dA1+RIhEIqbUb8lbZwUrm5U3zvFa0+609bFnw5Ot6PPLCVQaHf8LS8R32DBmfzGe5MVPUHx5N5r8dNJXPI/nrKoLzlWXEU3dGRjswraIDNILy5m74TJv7YjkydbejApxp7GbNQ4WcvBoglLfTzHXqEBZTI/jz3PZYiIfJo/hQHQWf05qiYft4y38mDBRFT+Pun00rM2vdy60Z+K/Q92YqvuP087Fhy29pmGmj/b6K/ESy6PP1Mi5f4w4ZjCFnxTQgvgkOW/viDRs/2VUCJP0kW2a4lxKY4XPNavXHImlPa2cvNnWa7rBlH/ljXNMOLTKOHtagXK5mC47fqokBrqZW/N160HEj36bd5v1vq0YWBpziqIz6/gwag9OegNnlVUOe7NuTZG9Ew8zZbgqhjZxI/yVrnSvLwzGNVod7+6MYuQ/IoXuBZlYwstNurGuxxMsHPoqMxUyumXfwOv6EcqO/gGArdycqYFt2NvvaZLGvsP81oNpUYUHX2JxHlsSr/Lxxb18fG0jBB+H+qc5pjzJx6fCSC7Ov2NbSm+cNCzf9A+8E8mLJpH2+zOURh9DFXOMtBXP3XF/qVjC8407EzXiNSYHGIXDc9nJ9Ni5iENpMXf9zLrAirNJvLHNKAaOb+5J2NyO+DgIv/vcA4tI+mFUZTFQIsOm9Wj8PwnHecjbvHZ+F0r9QOWNkB4E1XKV18yicjr/cNQgBopFMLuDD9ff7MFLXQPQpUcSP68POy2c+a2e8H8vE0tY1/2Jh5bG/DgxKtSDvU+3M0RPHIrJZtwf5wyRRzZtx2LRsCvds2NoVCh4S57IjGf+5UPV+tz+QQ546gc068JTuZJ2b8VAxDIF9t2fov6X1/B46g/kFSoP++Sn8OvZldipBPFlT8o1xhz8454jxR8VNyMEAQYnGp938eLqRWJWh3x9hXYA2w6TDMulahV9dv/CtQK9V2eZBVblrmyd3tZgK/BvQSIW09DOhVFejZnfZggH+z9D7sSPONBvFj3djdG11woymXLkT3rsXEh8UY6QwujVBLcBL9Hj0/34fZ/JjvY/UqJP122Wtp0vPnntluige2W0r3HA9NLpzSQW5d2yz+wOvtiby7gq9SdPJERbFF/eja6GMzoeR9ZPbc2RuR05NKcjzzSzIeHrfkQiJUcuPPe6eAQjNas7XnuqnCTyjv4OgMTaCYeec7iUk8qMo38bxcAsT0gJwtPWnCNzOvwnxcCbTPJviUgfaf2/K4c5lZkAQLf6TiwZ28yw3wubLnM0W4rn0yuQWDsBkH98JSXXbk1VrAlEIhFLxzWrlCpcUKbm+yOxdPnxGI7v7sL5vV1YvbPVsD0XO8PycyUrGVJ+gMM3cmj73RGis2o/q8iECRMm6iImQbCO0N29Pv09jdUGS9QPVq32n+xIMg6GJnt1ZtY6o8C2YHgTZlQwn88/udowY2rZpI9hfWc3f9b3eMIQCbQ69gJ9dv1CbnkJGq0WlVToKKgrVFkLsHbkp/YjiB31Fi836YaV7PYDG51WQ/zSWQDYqctoEGesAvby6S3EFGTd8/etWLBE8ojSrDxtzdnzdHu+GBiMVB8VuOlKOr0XHien5MFSm0RiMW4TvjG8T1/9Cqqcyia3Hha2vNSkK2eHvMj1kW+wossEXmnSlV4egThVVVberAQcUnn/6ia81nxM/bWfMy1sNfurSF8UWxjNoQvObrhre3X/qJqtU99bqqGbhQ2/dxlP2IA5tHUWqoBqdFpePLn5sUgfvppuFKHf7hXIyonNsZAbA7GVFSq6yt0b4Dp+PkHfJuM1dw0KtyDii3LYnCD4bfla2fNm0x612t5SlYYhS04Tky2klfs7WnDmhS78NDIEZysFRZf3EPtxeyKK83m7YT/DcT+0G047l7pZRKQu0N7XgYPPtDekGe6IzOD3M0mAMIhxm/g9IuC5WONA6dUzW/n04t6qTndPyCRi5nb0BUCt1THuj7P3NQkhkkix6ziJgE8v4/XcBmw7PYnM2Z/A4mx+ubgWK/01vCXxKhMPraRAWXaXMz46FN4haM2EdOfpubtwLBOE0ku5aUTfx/OkJlFlCR6PctdA5M6+hvUfXthNZL7euqHMAuJCmNvRn8Zu1S+a8TggFonp5l6fvf2eJmzAHPp6NjBsO5R2g5CN/2Nt3MVKxzjZWPLyrGcoHrMUjb4bOzD1dyYsDUP1AOl/I3yaYq3vo+xNuY7f2s8Yd3AFJzPjDftYm0l5rrMfWpGEk7KmgJAWqcmMvu/P+zeT/tcraAoyOGFvrOLdxaVuRfiXRB4y9HUdej2L2MyKfakV+j25rpAWQICjJWFzO9LQ9b9xLd4Obys7Bns3AiC9tJDO23/kt2vCJPGkll583E+4ZrU6mPrXRcoU9riM+dJwfLHeL7Q2cLZSsGV6GyJf787cjr5YKSpHVGcVK9GoRaAV7hPXrZzY5jjcsD3ITOizJeWX0fXHY0RlPPxAAhMmTJh41JgEwTrCxZwUNiZcAcBZbsGU+lWnV94PSo2aU1nCTF6QjTMvrI2mRO8V8GwnP+Z2quxRl3d4iWHZrtOUStv6eTVkW6/phk7z4fQbdNz2A+23LUBZIaXX1dyaP7qMJ2rE68xu2OGeUsvitv+ANlEoWHFZWh+t+wjmNhTSUovVSqYc+QvNPc7CXy8wVkQNsqndyKo7IRGLeL1HffbNam+IFDoal8uAxScpu89IwZtYBHbAvP0TAGhL8kldPrtKvyOA+jZOTAxowbzWg9nT92kyxn9A8th32dZrOu+G9qKJtTdoKwumMYXZLL1+mp67FjHx0EoySo0RRo79XwG9IJy16UNUeal3bKvn7FU4DX4bJDLEdh64jPzkvr5rR1c/jg2cSzt95drzOcmsjDl/X+d4FJhXuBa6BTjekgIqd/Y3LDsPeRfHfi8hrfA7/fXaKUOEwpyGHWs1NVOr1TF51XlO6CMDfezNOTq3I829BCElZ/9CEub3J1ut4tkmwyiRCuLWjKC2PNWgXa21699CqIctKyYYvR9f3HSFtAJBRDOrF4J5UCc658TxavRBwz7vnNvJW2e33/P97p+81DWAlvr/v8tphbyy+ep9n0MkFmPTchieM5cS+HUMth0m07gog4Xh67HUR7H/HReO95pPeP301rtGFwNcz89kwdUwPr6wx/CqTcRyM9a7zxCW0TEt95xh26aEy7X62XelQor9maxE5l0+CIBCLIWExqBWcCD60YiWj5qOrn7s7DOTIwPmUF8fYVSgKmPMgRV8d+XILft3HTgeWSshLdVJl4fjpT+YvfbSbZ+Lt8PRzJL1PZ7ARiYIxxqdltWxF2i3dQHtty5gTewF1FoNz3byw0Iu4ZyskeFYZezJ2532P0fx1f3khy0H4KSzsRBO1woCeF2gYsaDRcNuAGy5bhR/yfGgvY8DR5/thK9D1Vkt/zWWdh5LLw8hilep1TDj6N/MOraWco2at3oG0itQuF5jc0p4dctVLIO7G44tewjVShu4WLFgRFOS3+vNsnHNeKmrP30bOOPvaEFrbwfqSfWZMzIlDZoaIwpffmKC4ZmZUlBG15+OcfUeo+tNmPg3UKLU0GlB2C2vS6kFxJiiZv8zmATBOsLrZ7YZhIBXG3TCWlZ9L4tz2cmU6VN7tUU2hgIHrb3tmDc4uNK+ZYmXKIsVKomZ12+PwqPydoDenkEcGTAHD32aYER+BqezEg3bZWotkcNfY1JASyT3aBydmpxA1rq3hTYi4o96L7FxWju+aj3IYGR8LCOOr/WDprtxLd84kAq0cbqnY2qTLgGOHJnTwZDKdzIhjznr73/AchOrwR8gdRBSvIsubKHgxF93OUJAJBLhYWHLAO9gPmrRj19aTYaITnAjlE4WLejtEYRFBfFp1Y3zBG+Yx7Lrp9HpdJh5Ncah11wAtGVFZPz95h0/T2Jug8uoT2i0RInze+FYhfS74/5VIRaJ+bq10Z/p7XM7KK2hyNnawqKCIFhVdJbczZgWV55eORJTpdXw27VTwn5iCU8Gtq6lVgq8vi2CdeGCsGtrJmX7jLa42Zih02pIW/kiactnUw4822QoCfoI0dZO3ixoO6xW2/VvoncDZ6a3ESJlcktVPFPh2rfrKIj7Tyad5bMKbr6fh++ny46fiMq/t4I/FZFLxfw5qYUhSuKnY3FsuHRn8f5uqAuFSZbmBSls6DLBYB9RoCrjq8sH8Vv7GU8e+YvLucbP0eq0nMyM580z22m0/iuC1n/Jcyc38t75XYZXbXIxJZ8PCzpxUSoUquoTZ4zEvDnx9tAxTA4I//9KjZppYWvQ6n8Pn7bsR2tXwcv3ZEIeSXmlj6KVdYJOrn6cH/oi0wIFiwIdOl44tYnXTm+9JVLcb/QH6PSextNK1rHy5HU+2Xv/qeG9PIK4MepNPmvZ39DHASGdf+zBFfiv/Zzf407wZBtPzkuN/SOVSRCk5PpxiiMOkLrsaQCUIjFn7YT7no+VPb4Wdo+wdbdSekN4ziISY+bTnE/3XmN/grEvO8Tfi/2z2+Nq/e9K2a8ODgoLdvSewWtNuhnWLYo6Qeim+WxPjuDXMSHYmAkPsoXH4zmYbY7YTIisLE+6P+uf6mBjJuOJ1t7MH9KYnU+1I+atnpx6oTOfd+ps2GdzjlC8SSQzwyW4A3tntadtPTsA0gvL6fbzMcJTCh5am02YeFRYyiVYyKv2KS5Waih5wAAWE48fJkGwDrAv5Tq7kqMAQcSa7NOsRs57NCPWsBydIDyo7c1lrJnS8haj8rwjSw3Ldp2n3facoQ4enBj4HE3s3AzrxPpqpHKVFjvFvZtGZxWVs+mrGVhqhRmIXXaD+eXFqbhYKzCXyvi98zhD9b93z+/iYk7KXc9ZKUKwlr3X7pUm7jbseqqdYZC+5FQiPx2Ne6Bzic2scX/SWB4+bcWzqAvuXzhwtJSDTgwldjSgMbv7PkXexE9Y0WUCzmZCenFOeQlTw1bTa9cioguycB72gdEXJmw5JTG1PxDq6OrHCB8hPSuxOI/vrt4aJVKXMJcZb6mlqlujvOQuxqgJ5T8Ewa2JV0ktFTqhI31DcDKrIs27hlhyNpWvDwq+jDKJiPVPtqaRmzWa0kISvxtGzu5v0QHvNOjLeVthZt3b0o5Nj0FBibrG10Ma4WEjTAhsuJTGWr0Ia9NmNCL9xM+I0yv4pf0IxHrR6FhGHM02/Y/5lw/ed7RgoLMVP41oang/ffVFfj0Rz09H4/j6QAwf7b7GG1sjeG7DZV7dcpXzSXeO8FPnCfddkcKS3r4hXBn+CnMadjAIgyqthuXRZ2i6cT79dy/m6aNr8Vr9Ce22LuCLS/uJeABhs7rMOxCDViThQ6s5aEUSPMoLCS4Sng1H0+MqRT8/NP4RLfx5+H4u6UXUNk7evNCoCyNDjMUs1ldTyH3csZIp+LXjaD5vOcCwbt7lg0w5/BfKCh7GCrdA7PSejE66fMaWbue9nVEsP514yznvhqOZJW+G9CRu9Nus7DKBVk5ehm2JxXm8dGozW5RbiXKyoVjvX6i8YRIEk34cQ/wXPVCmC+nT0SGDKNYLtz3dq1csqabRqsopixeyDRSejXlldzzv7IgCuSDAm4kU/Dak8X0Vs/uvIBVL+LL1IFZ3m4SlPmMgKj+TwXuXMP3UCl7qa6wGPn3NJSQeTQChr6MtL3kkbb7JIO9GyPXR2bvMHdEB5gHtEMsU2JnL2P10Ozr4ChOfmUVKuv987K7PRhMmHncCHC0Jcbch7NlOt7wsbyMUmvh3YhIEHzFanZbXzhgNbz9r2b/GqnaGpccZ35QIM97fDG18SwqETq0k/5hQpEIkt8Cm7Zg7ntfbyo6wgXP4tEV/lnQag3n5/c8g5JQoeXb+QrrkCaljeRI7xrz+M+42xsjI1s71eDe0FyAMOicf/rPKYiYVua73hxKLRPhb37nK5sOksZs1v49vbnj/wqYrHIp5sLQw69D+2HaYDICmKJvM9e/d9zkcLYw+jdl6X0OZWMLEgBZEjnjdEJkBsD81mqYbv+armLPYj/zUsD7tj2cfiqH6Fy0HINULw5+F7yPzERSLuVfM7xIhKHPyAX3apTKtsiC4KOqEYfmpoLa11ELYdjWdN3YbJwt+HRNKj0AnVDlJxH3WmaILwv3oR//ObHcVImGsZQq29ZqOu6mIyH1jZy7j55FGgW7u+ktkFyuRWNhi3VLwMtLkpzOuPI/jA58lWB8ZXaZR88rprXTe/uN9RwtObuXNZH2xqNxSFTP/DmfO+ku8uvUq7++K4ssD0SwIi+XrgzG0+OYww5acuu3gR623B5DZCWKVn7UjP7QfQcKYd/ioeV/DBALAzuQofrl2wiBsA0hEYnq41+e7tkPZ0/cp9vZ9mr19n76v73M/xOeU8NcFQcTMt2+IeRfBn7ZHpuDfqUPHlsT7T6WuLjdN+dHpCM9J4RO9X6RMLGFJp7FIxOJ/CIJpD72NdQ2RSMQbIT1Y3nmc4Rmw8sY5Bu1dQmEFn1qnIe8YUrGnla7HXFfGjDUXWXwi/oGi8WViCRMCWnBq0POEDZjDKN8Qg1ifWJKL2juSCS0mEm7thjY7FnV+eg18238HIrk54W3GG973dK9/h70fPuWJ4ejUQp/npC6Abw/HAjqQCb+npo4udUrArIuM8WvG6cHPVyoEtC/1Oh/G/IV34wSQlpOUX8afqUIqLjodmTcu3uZsDwcbuRm9PYSI8SRzOyKtXLBo2NW43UzGrqfa0cXfAYCcEhW9Fx3ncqopUtCECRP/fkyC4CNmdexFzmULxSHaOtdjpM/ty4PfDzqdzhghqJaB0hxnKznjmnvcsm/h+S1oCgVxyqbNaCTmdx/028rNeSu0J1MD715x9p/kl6oYsPAI4+PnG9a5jP0Kb49b2/ZWaE/DLP2l3FRGHVjO5dzU23byb1Zq9LG0RyGRVrnPo2J4U3fe6y10SNRaHaN/P0tC7oPNmrpO/AaxpTCbmXtwMWVJ95cGZ2cuMwSsZP+j0ImDwoLfOo1hf79ZBh+nMo2at87uoGN2NvuD+wrrYk+Ts3dBrYuCgbbOzG7YAYBCVTkf1bL/WHWoGHpflSAokkgNPoLK9OuG33FsYTa7kwXBooGtM13daseE/XxSPmP/OIs+qJcP+gQxpZU36sIs4r/sSXmC0Gnf7NOGn/UVhSUiMX93n0JTB/fbndbEXRjSxI3xzYVIy4wiJS9sEnzs7Do9adgn78hS2jjX49yQF3mjaQ+DAHE8M94QLXg/4saPI5oS5HxvUaabrqTT4pvDDF1yqlKlRZ1ahUafMiy1rfz/72RmybvNehM/+h0WdRhVybPVSqpgtG8IK7pMIHP8B+zrN4vnGnWml0cQPT0C6ekRSG3x7ZEbaPQ/8Oc7+2Hb7zVkTr70zDIWf9gY/+h8BMsQ8cSRv1DrI6jeC+1NY3sh4r6+kzBbD3DkRjYZhfdWjOnfzpT6rdjSa5ohKmlPyjW6bv+ZtBJhsK5wCzRUbnbS5TOmdAdqrY6n/g6n58LjxGY/2HNWJBLR0dWPv7tP4fKwVxjoZUwVjraxZ3zLibwe3J/rVw5U8xs+3jj0fRGnYe/jPPxDfN86zMGCbMO2HnVMEDSkCwMb8oV7skRRDmLhnlG/DljNPA4E27myp+9TbO01jQb6bBwdOhJFsRB0GpzjuST1New/98e/6PfLCRafiCe75NFYv4z0NU7M7XYOxLKCIAhgpRCsU3rUF34D2SUqei06QUzOf9e+wcS/n/DcVDpt++GW1xsNWvNzvVvtw0z8OzEJgo+QErWSt85uN7z/qtXAGpmZVGk1vHJ6C5ll+oFdsS0gYnqberekCgPkH1thWLbrMr3an38ndDodk1adJ/j6SuprhJQekX8HAvrMqHJ/mVjCH50nYKYX97YmRtB043warP+S105v5Vh6HBqtlrSSAqYc/tPwneuCf2BVvN8niMGNBEPjzCIlz214sIGp1MoR56H6yECdloy1b93X8WqtFjOpcPnn3KZz1t29PuHDXubtkJ6G6IzowmyedW3CFn3kWPrKF7j+sg9pf75CUfhONMV5D/R97sZ7zXobDN8XRh4nq6xuGt1WjBC8nfeG3FUQQ7QleWiKcwD4OfK4wUP0qaB2tRKhkF2sZMTy0xTrCwtNaeXFe30EgTr9z5cNFZCPB3TiXX9jR/mn9iMqVf408WB8N6wxTpaCoLHibDIn43OxbNwTqb0wKC08vZaEb4ciyojm81YDODHwWRrZCfeKm9GC6+Pv3YvJ2kzK4Tkd+XVMKEvGhvLXpBZsntaavU+349izHbnwchd+GR2Cr4PR5mHzlXR6LjxOuVr4jZTGG4txSO2qFoTNpTKeatCOiBGvcrj/M+zr+zRZEz5kTfcpTAxogb3i4ZryLzstVHO2UkiY1cEXkcISr+fW00BVjFdpHgB7kqPuGm1ek+h0OnQaFYcc/Bjo340LevuLZg4evB7SvdK+I5oK4qBWB9siTJFnN+nn1ZCD/WcbIlLP5yTTduv3XM0TIimdK0QJztVsQq4TJroORGfT+tvDHI3NqdbnB9u5srX3dHb3eYqm9sZrYatrIzpEnOJg6n+32rBT/5dwGf4BzsPeY7/UgmMZQoGOxnauuNWxqPJSvVc2wCVpEBZyCR8P8TGsq1+HMkvqOiKRiIHejbg07BUWtB2G4817vVgDrnFsCbVhk2sjtMDA0v3sj0zhqb/DCf3hLH+dT37o7R3i3RiJfiJmr1MgqpykW/axVEjZPK01nfyESMH0wnJe33XjobbTRN1Dri0j9pNOt7zKEsNRZsQ86uY9ME3t3Qmxr7pvF2dhTby51UNukYlHRd0KofqP8cnFvcQVCRU+h3g3pksNRAUlFecx9uAKjmXEGVfmCyloN6uAVUSn01ESfQwAqa0bFkGdqt2GO/HN4RucuBzJtlJ9MQyxBL/pi+4ogDS0c2FLr2lMOLTSIPhdL8hi3uWDzLt8EFdza0rVKgoqpBD18Qyq1e/xoIjFIlZMbE6TeQdJzCtje2QGuSVK7Cuk8N4rDj2fIWfP96gyYyk6v5my+AuY3aP/5LeHYw0ed8Eut7/hm0tlfNKyP+P8m/H6mW1sT4oE4NPg/rTMS8KjvBB1ThI5O+eTs1OI+JR7BGNRvwPm9dtjUb89Onn1vRydzCyZHtSGb64cRq3Tcjk3lW51LPIABNHtJtaKqm+vYgtbw7JOWUZWWTE/RQrXoIVUxhP1W9V4u9QaLWP/OEucfqa7nbcNi0eHIhKJ0BTnUnBqNQAXXRvyrG9H1Hqx5NUm3UwVhWsIZysFnw9oyMy/hYqLu6Iyaetjj2P/V0hf9SIARec3U3x5Fx7TfqN1h4mcHfwCr5/ZxvcRQlGMs9lJjPS99yhyV2sF09vWu+32UA9bnmztze9nkvh4zzXic0tJyC1l46U0RjeyJ+XXqYZ9LYI63/Y8IBQB6uzmf8d9ahudTnczMReFRIyVXEJ+iZAmiLKU+sXZJJnbUa7TUqZRPbQo8qsXdjDXtzMHnYzPeHOJjCWdxt5iEdLK286wnFlUOXr7v04rJ2+OD3yWvrsXE1OYTUJxHv13/8rpwc/j4lof2/YTyT/6OxblORzuncCk6FCis4rJLlHRc+Fxlo9rxlh9pO6D0tsziPPuL/L2kZ38GrmFbLkleWIxg/Yu4drI1/GocH//r7E27iLjD65EoxddJvi3uMsRD5/clBuGSIgsS1/2PtUOrXk+RAjr8pVltz3WRNXIxBLmNurExIAWfHpxH99HhKHSaiiXangruD8rvFrwasxB5hXO42Xr1ylTw+RV53GwkNGngcvdP6CGcDSzpJ1WyVGJGTcsHTnx+7M0vbQLl7FfIbM3ZihZKqRsm9GG4C8PklJQxsW0ujkBbaLmKFNr0Wp1dFoQdsu2YhS3DZ/SlhWiLSsk9pNbx87lieEovGsm66+2+LnDyNtua/R97QYImahbmCIEHwEvntzEE4f/5OvLhwAwk0j5tu2Qap93X8p1mm/6xiAGmkmkDLHrAgW3j5ZTZcWj0RelMPNrVaveKbsiM3h1y1WeK/4DK50gTDj0nIOZV5O7HtvLI4jIEa+zsP1I+nk2qDSISi8tNIiBzmaWLOk0hpcad73dqR45NmYyJrYQ0qBVGh1brj5YFIhIKsdpkDEyMHPzJ/d0XHJ+KR/vEaLBpGIRH/W7e/RXE3t3tvWewVNBgjhUiIgPer2CRauRiGSVK/EpUyLIO/wbqUtmEPNWY7I+bELh+S33+rVuy82q0wCxRdWL9qgtbuQYU9P8HaqOjNKpKqQBSmR8dekAxXpPo2cadsCxFoqJvLEtgn3XBVsAT1szlgwPQq6PEM0/vgqdqpwoSydmBw+kVC8GTg5oyRetBtz2nCbun4H66GAQUkIBHPo8j+fTK5A5+QLC7yN50STS17yJQizh5SbGe1lMhVS8mkImETO9bT1WTTQO3hefTCB99WsoU4RRsnlAW+x7zKrxz65pRCIRA4KF+0R2iYpjcbmoEs6RuvQpAMrFRgHwZlGU2qRUreLD87tpeX5vJTGwj0cQpwc/T3PHW8Upk33ZnQmwceLEoOdo6ywI3QnFeYzYv5xyjRrHfi8b9nM8t5hzL3RikP6aK1drGbfiHF/uj34gX8GKSMRivug6gK+uX6NrthAdUqxW8unFfdU67+OK75pPkS17jdEH/jCkwk8NbM3rTbvf5ciHi06nIy1ViEwrFFnwbr8mtPd1IKSCHcaFeyheZ6Jq7BUWfN1mMBHDX2V0hYmrq9auTG02ls1BrnxlsRyRTotaq2PEsjOcScx7qG0c2WqoYfmQoz/5x1cS/XoQWVs+R1tBDLYxkxksN3JL1SjVte+XbeLRodXq0NzmuZBr4UWuXRB+74Td8pLauhmqaf8ThXcIZl5Nq9xmwkRdwyQIPgLWxoXze8xZVFohLeud0F74VTNN4Vh6HAP3/kZWuTCTVd9a6DS3sW4I+piJf97sylMiSZjX2/De3LfmI5NuEpleyNg/zhKsvM7wcqHTLLFyxHn4B/d8DgeFBU83bM+OPjPJHP8Bf3WdxDi/ZljLFIhFIuY07EDUiNeZGtimzptCj6pgHr/24oNXk7TrNAWZozAwKjyzjrKku6cgv7olwpA2+lxnP4Jdq36YVcX8NoMNvoJHiwtY3fUZghZk4PXsehwHvIp5UCdD5dSbaAszSPppLGWJ957uWBX+1g6G5RuFdVMQrOhV5e94q7Cn0+mI0sJfHqG8EjwQ3x3VY6c1AAEAAElEQVQ/M+/yQUAQKF5p0q3G27TqXBLzDwkpLwqpmPVPtsLFyhiRmnf4N6ItHJgROpqbZSUGezfit05jEItMj4iaxN3GjABHQSg+Hp+LWqNFJBJh22EiAV9E4tD7OcO+2du+IPH74biJxIbqiDeKal4QvEl7X3sauQrRwsorO8nd9yMAYjMrPJ9eiaiOebLejmFN3AzLO85Gkrd8uqGIgFp/rxQhqrHiXbdja+JVmmz8mg8u7KZcfx15KItZ320yO/vMNPgGmrh/nMws2dJrGr5Wgo/u0Yw4Zh9fh8K7KZaNhT6NMiWCks3vsHaEN3M7+hqOfWNbBE+vDUelqf4Av2XPyXwesQMb/YTkL1EnuFFYe9doXUWj0xqEQBAmtn7tOBqJuO48P3Q6HZ/uvY68TOg7FEnteEb/u7CWmRGg74NfzE2ptmD8XyfAxok13acQNmAObZy8Dev3O9XndT9fenhtBXkRxUo1A349Wcm3trYZ7G8s7ndYb32jKy8mY+1bxLzViIIzGwz//67WxsnujCKTn+u/HYlIVGW13RB3GwKq6M8DyF0CMPMOqVIs9HsnDPcnf37I38KEiQej7jyt/6O0da5XbRHgRmE2Q/ctNXgiDa/XhDNDnifUwQNJBWHsptE6QFH4TmI/bocyXfC9kdq5Y9+9dio/5pQoGbzkNPllal4pWYZY75XmPPITJPrCGPeLrdycsf7N+LPbJLLGf0jOhI/4of2Ih+5X9aC08LI1eHftisqkoOzBTJZFUjmOA183vM/a/Okd9oa91zL5U+/d4mqt4P0+95dabSVTsKLreCT6Ae6753cRXlKITavhuI79Cr+3j9BwYT5+75/CdeK3WDTqAYBOWUrSghFoSqquZHovVKwaHVtHBcGbEYISsQhvO0EY1el0bIy/zMj9y3H58wN62/jycVAvdrg2JKW00HDs3OCOuJrfuzh7L1xIzmfGGmN1v59HNqVNPeM1Vxp/noiMOKY1G0OOXLh2urj6s7rb5FoXTP6r3PQmKlZqOJ9srGAolilwm/Qd7lMXgz56rej8ZhI/64SP/ndRGxGCNxGJRMxoWw8LXSmfFH5vWO828XvkrrVT5KY26NvABYVUjEinJfjgS2hzBa9ai+DuaOyFyGxzqbTWJo1K1SpG7FvG4L1LDOKQTKvmqfgTHHNxY7hfaJ2fsHoccDazYnPPaVhJhUH70uun+fbqERz7vWTYJ3v7PGJersfrqZ+yrE0xIn3fY/GJBIYuOU1RefV8JJv2GI2ZVsy0RMGXTq3T8sKxbdU65+OIo9gRF7EzbmIXnvbpyQ/thtepySSdTsdrWyN4d0ckdjrhnuvg7I5MYmxjMwchZTRfWUZi6YP3U0wY6ejqx/FBz7Kq60S85UJ/SC2WsM/eFoLOYhFwhEzzKLov2UNawcNJ1a5v42QognLazhNZ35dBP9mlyowlacEI4r/qRVnipUqCYLqpwJMJEyb+xdSdJ/Z/iGMD5xI76i3iR7/NsYFzq+VjlFtewoA9vxoiAwd4NWRN98nYygWxSSI2Djy0OqFjlL3rWxL+NxCtXpwx82uF3/unkdrVfMSCSqNl9PKzRGcV01x1lTYqIUpM4dkY+24za+Qz5BKp4fs+LohEIkaFCB1QpUbL1gdMGwaw6zwNqZ1wroJTqylPiaxyv8j0Qsb8ftbw/qtBwdiY3X/aXFtnH95r1gsQCthMPLSSUrVR0BRJ5Zj7t8axz/P4vLwDmW9rAJTp0aQsfuKBqxJ7W9oZKq/W1SiMG9nCdVjPzhypRMzFnBS67/yZ4fuXsT7+kuE6vYm93Jwh3o1Z0HYYH7foV6NtySoqZ9jS0wavyGc6+DK1TWU/ufOHljCt2Wiy5cLsZwcXX7b2noa5tPbTKf+rdPY3Ctthsbf+ju27zcDntb1I9JG45UmXcUsRIn9zlaXklD9YxdR7YXJLL/qqTuKkywPAquVwbDs/WWufVxtYm0npFejEU6V/06pYqCgqtXPHa/aflGkFAag204W/uLSfDQnGSO3OBalsOr2c5+NP4FFDzzwTAk0d3FnZdQIifRbEK6e3cMTeR5gku9mv0qgpOLWa1tvHc5bXmaTciYW2hB2RGXT/+Vi1KjmLFZaYN+3PxKRzOCqFe/uW5HBWR1yv9nd7nMiOCCQjvBFp4cEs3q7myI26M2Gn0Veb/vpgDDa6YqQIz0NHF49K+wXbGe0cEqoxcWmiMmKRmPH+zYka+z7vu3hjqTZebyXmOnBNIMk5DL81X/DG6R1E5mXUepsGeTUCQKXVEt5hCgGfXsYqdKCxXVf3c+PdZow8OpVni1fQXnmejJy685s2YcKEiZrGJAg+Aryt7PG1dqCelX21ZlFVWg0j9y8nKj8TgFAHD/7qNglphcieioKgRqMhdenTgoG9Pr3Dpu04fN86jMyhekbbt+P5jZfZHy14lz2rWm9Y7zTkHUT/8QikSmnD4Q+eNiyWm+E48DXhjU5H1pbPbtkns6icAb+eIrdUEO6GNXFjkt7H8EF4K6Qn7ZyFynwR+Rm8fqbqqAiRVI7tlN+QWAszsoXnNpG9/asH+kyZWEI9SzugbnoIFpWrydAXAajnKGfWsbW02PwNh9KMFepczKzoX5LFW9f3sf7sSrImfMimXlOZ26hTjRY4UGsEv6z4XMGrs5OfA98MbVxpn6isJEaWqshQCNFnbRw92dF7Btb/SPk2UbN09jemvh+5TeVTy4Zd8Hv/NAq9/4xfQZph26XcB79X3A0nKwVPyo4b3l9t9NRjGc02xS6GuSWrANCKJHg+sxqprath4qK2BMF8ZSnfXxVMyeViCSt9g/n53Cp8SvOwbjm8knG9iZphSL3GfNpSmEzR6nSMO7SS3D4vETg/HufhHxomywAUWZG8WfATB3Kn8UTpRs4k5NFhQRhxOQ8usjsMfgdLuQVPx58UVohg0t717Nd7tv7X0OpgwspzZNWBFEu1RsuEFef49WQCAE4YI7KlNpWLnTlX8O7NUZY+nAb+hzCXyvhg4PNcbTOQjzIiaZcbj7hCmnmZpIgvL+8jeMNXzD62jvPZybWWuj24XiPD8rzLB9E5+1Pvpa14v7QdubveU1unxSnjDLNK1/Brwft4f9uA2I/akbH+fTQVMjtMmDBh4t+ASRB8jFkfd4kDaYKhtYeFDVt7TbtlMF8xZVh2bTd5hxYb3juP/ATP2asQ11J03cn4XH4+Fg+ArzibtiVCtIbcNRCbNqNr5TMfJ9rUszOkle6IyKiWp5F915lIbIUZ7vzjKyi6tKvS9h+PxhGrH/S09rZj5cTmiMUPPtCXiiWs6DIeS6ngRbcgIozTmQlV7iux88BrzmrQi9+ZG95HW/5gnjE304bTSgvJLCt6oHPUFgYfHImKq+ZHWRR1Aq2+Qxts68KO3jNIHfse38WFMTH5Ag2VhbWWVrXmYkqlIiJrn2hlKCICsCH5Kq23fU+aXPCMC9Gp2dV3FjZykxhY2wQ6WRo8HI/F5d52P7mzL77vHMW6xVAaFmUa1l9Ii661tmlV5QTkCMJGnNiD31PvvUK4Sqvh/fO7+OziPoM/7qMi5PTHBmuKH62f4IK8MWqthhylcA80qyVB8I/os+TpxYTpQW3ocnW3oeqxQ4/Z93SO65nGe+NjqMU+Et5o2oMJem+wAlUZTx37G5m9B87D3iNwfhxez67DslFPw/5WuhJeK17CsPL9xGSX8Oa2iAf+bIlDPTymLWZ0SjjuZYLgpLbKpOcf23jq74vklgiTRCqNlsj0QtaHp/Lp3mtMXHGOjgvCaP99GB0XhNFpQRidfzhK1x+P0u2nYwxdcorwlII7fXSd4fDcjlx/swf9Ggr3i+T8Mj7Yfe0RtwqWnEpkzUWhSIhcIuanvsZJ2JuTlDcpqZDlkKcyVRquLeqF9mP29GXs6TWdkymneT9q9y3i4MKo47TY/A0Baz/nlVNbOJ4Rh1ZXc0U9Orj4Yqcf95zMTMD1rw+ZeuQvjjv54/PRBVwnfIPCo1GlY8RaNaUxJ8na9BGxH7Y22C2ZMGHCxL+Bx8Ml3ESVVPT4eiqoHV766KmKBDobZz2vpefjo1927P8KzkPertX2/XE2ybD8ZXsL2CQsW7ca+Z+PDgQhbbiznyOrzidTptaSmFdaZSGKe0GssMB56Huk/T4HdDqSfh6P//unDd5fyfnGDu4vo0OwkFf/0g+wceLr1oOYfVyI/Hz1zFYO9JtdZUSRRcNuSG3dUOelIJIqEEkVt+xzL7Rz9mF/qtARm31sHWu6T64zXkVHbuSAtBx8w8nUCsKDrdyMj5r3ZXbDDsjEEoou7UaVIYj45v5taq0tqy8YKyWumNDc4IVTqlbxwslN/HLthGF7cGE623rPxE7xeKXdP66IRCIau1mTEZ1NemE55WoNCmnV90OJuTVez67H64O2hnWZRbcXEavdNrEEsUyBTlmKRiRm45U0CspU92Qt8NnFfXx0YQ8AKSX5/NB+RK21806Up11HmybYJpyVNmKhbCjLFx3npcE25OurSLZyevDo6DuxLckoLD0X3BnVnq+FN2IJFg273fX46Kxi3t5htHzoFuBU0038VyISifi14xjCc1K5nJfGkfRYwtJj6eTqh0gqw6bVCGxajaA8JZLsnf8zTIy+XLKM/fK2nE2qXoqobdsxOIfv4PnrYbwRrK/M7nmNxads2Hg5DWdLOdcyi1Fr7y/i6UpaIeGvdK2R53Vt4udggZeTJcvHNSfwi/0UlKlZejqRj/o1wMFCfvcT1BILj8cZlrdMb0374hMk6t9LrIzXVolayY8RRw3vm9i4PKQW/jcRiURYhfSjZdO+NLy8h+Gr36Xw6jY2uzbiB78OlEqE30xsUQ7zrxxi/pVDeFrYMi2wNe82611tf2OZWMLc4I58cnEvIEwiLIs+w7LoM7iYWTHGL5QJL24j4nI2f65fSyvVFYZbxWCVHQE6HcrUKJIXTcL33eOPZQS9CRP3ikano9OCsCq3NXW34edRIVVuM/H4UTdG0iYeiFAH42zn1byqPei6+Dsi1UeC7cs2Dvi1tZwSodJoDTOzVgoJ3Y1NrRWvwscVP0djEZSKFWofBPses7FpMwYAbXEuid8PN0TiySuYZ0urERn4T2YEtaWR3nvnUNoNNsRXXeVYmRqJOk/4PVgEd3/giqWzGrTHXj+zuy7+kqFDVxfYFh0H/hfATPh/9LKw5fjAZ3muUWdDB7ZiunRF8/uapLBMza4oIaLMx96crgFCVGV2WTE9dy6sJAaOTL3EmoxwPBt2rpW2mKgad2tjJGZawZ1T60RiMc6exnTvQk3tRd+JJFLMfFsCEKBJQlJeyJoK4vLtSCspMFTLBvgx8hiLIo/f/oBapCh8u2E52acfiESUqrR8dv6QYf3shu1r/HNL1SoO6iP2/a0daWDrjKZEEG8llvaI7lJxVa3RMnnV+UoV4FvXs6vxdv5bMZfKeFfvbQvwefi+W/ZReDTEY9ov2HaYDICDNp/nSlYQn1uK9j7Fun/iOm4eQ4vS6Zot/AaQl4NbDJlFSq6mF1UpBopFIJOIkIpFiEW3RoTGZJfw7s6oarXrYeJireCpdsK0c4lSw6Lj8Y+sLWcT8wxFmzr7O9CngQuaYqNFg8TKaN3w1aUDJOl9A0f4NKWFKbX/oSASibBq2oemHx3na7ePCU0rZu/xxXwSuZOu2THIK6QMJ5fk8/HFvTx7YkONpBJ/3KIfh/s/w6wG7XGsUIwwo6yIHyKO0mHbD3yYfJC9Vi34wmomqrlHqD/vBnL3hgCUxpyk6PyWarfDhIm6ilgsqpRlWJHw1EIupT4eEewm7o26Pe1o4o74WTtgLVNQqCrnQk7VgzYrhZR2PvaExeZwOMfKsF6VFVerbdt3PYtMvZ/a8CbuSEqMIoTU+t7T0P7t+DkYOyJxudUTaUUiER4zllCeEkF50iXKky6RtuJ5PKb/ilxqvKmrNDXnyyIVS/hfmyH0262PuDi9mQFeDTH7R1GKosu7DctWjXs/8Od5W9nxd/cp9N29GI1Oy/vnd9PEzp0Rvk0f+Jw1wcnETHYp94NciEAKtHFiT9+n8Kkw6CiNO0fxVWGQqvBohFXIgFppy47IDMrVQnrNiKbuiEQiYguz6b/nV4PfqBU63ru6nYEZkbhO/NY0y/2QcbcxRsimFpbj43Dn6uiWWmM6W4HmwSqS3yvm/m0ovSbMCDdWR7P0tBcz2vnc8ZgPL+yhWK2stG7uiQ0E27nQxe3hViguumgUBJ+d8TTnduXw9/U4dJZ5APhZONPZ1b/GP/dQWgxlGqFoSX/PBohEIjTFekHQwv5OhwLw0Z5rnIgX9m/kasUXA4NrvI3/dkb6hBBo48T1giy2J0VyITuZZo63+iO7jptH4flNaEsLGFu2g/VmvUgp6IGX3YNHSUutnXAd/TkfrHqJoa09KZCZgUMa4iJnzMucCXa1opGrNcEuVgS7WtPI1Qo/BwukkluF4tjsEpp8fZASpYZvDt9gdKgH7Xzu/huqCzzbyZdvDt9Ao9WxICyWl7s+mgrlv5wwipEz2wrFtNR5Rv9VqT4KMKEoly8vHQBAIZEyr/UgqHwrM1HLiMVi/Fv344lDAcwp+ZOn09YwPO0KRRI5R/3bc7jZCLZnJ6PUalgUdYJgW1eeb1z9SczObv50dvPn+3bD2JN8jVU3zrMx4bLhWZagToX6GZAaSEMXS+SWDrhN/JaErwXP0ox1b2PVbKAp4+k/QHhuKp22/VDl+hB79yqOePwx09sMhc3qdMu220UNmnh8MUUIPsaIRWLDjeh6QRbFqqojTXoGCqkR+SIrNHrPMFV27c7crjqXbFie0MITTYGxcpjElI5hoKIgGFsNY/ObiBWWeD+3AbG5DQB5h38j//ifyCpEpyir4VVYFX09GzDQSxi8xhXl8s3Vw7fsU3x5j2HZssmDC4IAPT0C+abNEMP7yUdWcfE2gvjDQKnW0G/77yAXBF1XqQNhA+ZUEgMBsrfPMyw7Dnj1rhFDD8q2CGO08IimbpzPTqbDth8MYqC3hS1/XtnCwIxIRDIFdvpoGRMPD3cbY4RgasHd/aqsKlRmLNSLTrVFxVT2FuoIjsXlEpVxe7/OqPwMFl8TfAft5OY8Gyx0HtU6LSP3/05c4cMrAKQtL6Yk8iAAcrcgLD2C+HFwfZo0MprAp8Q5cLEWvNl2JBlTfft5NUSn0xkEQbHlncWczZfT+HiPUJlWJhGxYkILzGWmQeb9IhGLea1pd8P7d8/vrHI/qa0rLiM/AUCMjneKFhKbXX1PWruuM6jn1Zi3ovcb1rk1iCfh/a6cfqELy8c3542egQxt4kags1WVYiAImQOfDxAikXQ6mLb6AuXqR+vLea/Us7dgTKgHiDSkqjJ5et9OXrm4kwG7f+WjC7sfivdvUbmaVeeFPqiduYxRoULEnyon0bCPzMEbgNfObDMI+S837mrwKTbxcBnWxA2NSML3lpNY1vQ7JFaOWGmU9L1+iM82vsYiJ2MV6JdOb2Z74oP7fv4TmVjCAO9gVnSdQPq491nVdSJ+N/tvEg14RTLzxJ9klhVh2aQPFg26AFCedJmCE3/VWDtM1E2a2rvfVvQLsXen6b9UEDTx38IkCD7mhDoIHR0dOi7lplW5Ty+9IIhIRLZcSNdVZcXVWgWvEqWaDZeFmVhnKzk9A51QFxoFQam1SRC8ia+DMSKhuinDN5G7BuA+9RfD+9RlT+NQavRzrGlBEGB+m8FI9V5+n17cR0qJ0ZNJp1ZSrB+kSx28kbsFVfvz5gZ3ZEaQ4KtWolYxdN/SR1ZkZOimjeTJhd+7VCvn+NDZuJhbV9pHmRlLwem/hX3sPLBtP6FW2qLT6QzFRGzMpBTJMumy/SfS9FXxQuzd2ePbAP9MQXywbjmiUuqUiYdDpQjBu6QMA1hWMLkvUNduhKBFYEfD8qTSLdhqC1h2OvG2+795ZjsaveH72yE9+bbtEIbWE1Kcs8qLGbJvKUW3mayqaYqv7EOnj+64GYGbWV5MjFZf6VsjoTzLmf6LT1arsmxV7EwWUjvlYgnd3QLQKUtAH80puYMgGJVRxOQ/zxve/29IY5p72dZo2/5LTA5oia+V8PfemhjBvpTrVe5n32M2hY5C4YBQ9TUKw5ZW+7NFYjHuU35kUEYkPbIEr9uU0gJeOn3/qYVzO/rRwVf4HhHpRXyyp+rvURf438mNfHjkT945vIrxB/7guGwXNAqDgPMsS9nPsvjz7EiO5P3zu6m35hNmH1vHtfzMu5/4AfnrfDJF5YKAOrmll0FcV+UY+0FSBy+OpN1gdewFANzNbXgzpEettcnEnenk50A9e6E//G2GP3ZvnMC8fgcAdKpy2qx5mdfUQh9PqCa+gks5qbc934NiKVMw3r85R/s/DzlGoWdDwmWabPiazQlXcBn9uWF9xvr3DM8cE/9Ofu4wkrCBc2/7+rnDyEfdRBMmqo1JEHzMuSkIAreNkmrrY4+duZDCeV0tDP61ZUWV/FRqkq1XMwydsTGhHsgkYjQFxs6fxMaUMnwTbztzg7/flfTCu+x979i2HYtd15kAaMsK6XT8ZaQ6YRa8JlOGb9LA1oVnGwmRQcVqJW+d3WHYpoo/g07vZWjVpHeNpKeKRCJ+bDecTq5+AMQX5TJy//KHXt309ytX2ZmvT4fXwYLWo/GzuXXwn7PrG9C3zaHvC4iktWO0fi2z2FBAJtC/hMH7llCkjy7r7hbAof6zURxcZNjfvtvMWmmHiTtzvxGCCnU5Mq1w/RbU8uBD5uCFXZdpANjpCnm/6Cc2n7yEpgoPtKPpsWxIEHxD61naMTe4I2KRmD+6jKeJ3iv2Um4qkw6voryWIxuhsn+gVaggCH57/RilemHOWxsAWglpheX0++UE2cU187e8UZjNNf0zroubP5YyhSE6EG6fMlxUrmb4stMUlAl/mymtvJjT0bdG2vRfRSGR8mWrgYb3L53ajEZ76ySYSCKleIDR09X96Oeoi7Kr/fnmfq1w6PY0713bg61KiBpfHn2GXcn35wUoFov4bUwoCn3a1uf7o7mQXL3iJ7XFN3GX+CD6LJ/GnOOvuIvElWTDbR7zZRo1C6OO03D9Vwzft6xWRJ1fTiQYlme2q2dYVusjBEVyczC34/mTmwzbvmw1ECvZgxU7M1F9xGIRk1sKxZ5UGh1r4yX4vnkQx/6vGPaZEraI4WXCuKVQVc7gfUvIKiuu8nzVJTlXBSlBENcEc4TndUZZEcP2L+OFjGTMmw0S2pp5g9zDS2qlDSZMmDDxsDAJgo85zSoIgvtSq55BlknEDGgoROXFYRTjlKm1Y1ZdMWVxfHPBv0ddaBQEpVamyok3kUnEhHoI6b2XUguIyaq5zo3bxG9ReAgREA45l2mnugjA2aS8GvuMirwX2hs7fcGPP2LOUqaPZCq7aIyOsKyGf+A/kUukrOs+hXr66tpH0mP588b5Ox9Ug5SqNDx7eCeIBKGku20LZoU0v2U/nVZLXthyAMRm1th3e6rW2rTpsjFKOEYWjlofuTXevznrAkLI+3YwJVeFdDaZSwAWDbrWWltM3B6PCoJgWGzOHaO1S2JOUhpzAmu9EBhXlIu6loVvl9FfILawA6Cv8hgr4ydy9fuJlMadq7Tf+vhLhuUPmvcxeIday8zY3Guqwax9U8IVOm//kWPpcVzITuZCdjK1QUmMXpyXSA1pXRuSI/RtUnBozBiaugvRu1GZxcxYc7FGIuUPp90wLPfzbAAIEzE3EcnMbjkGYPGJeCLShaiXFl62LBwVYvLzrAFG+4bSwcUXEDyePquiwAiAV2hX1it6AqAoz6Pg5Joa+XyXUZ/iJjfnrevG1OH5lw/d4YiqaehqzQd9hIh6jVbHrycT7nJE3cBSLCHQwh2yPSA5iDHmfbgx6k3eDOlh6CPo0LEx4TKhm/7HE4f/rDFhp7BMzenEPMP7L/ZFk5ArRAOr84Xno9TGlT2p1zifI9yH2jrXY2LArc9uEw+Xm4IgwGf7osku0+I6bh7ez29CbG6DCHj31O+0VAr3zPiiXBbWUvEqg4VPkSNznYYw1q+ZYdviayfZ3f5Jw/usTR+jVd59Ys/Eo+WVHTF0WhBW5UtTSxlzJkw8LpgEwcec5o6eeFgIgtL6+MskFOVWud/QJkK0xhVpfcO6m2mcNU3FiJcW+tSnm9VuRTIzRP8oOPFfZ1SIkJag1cEHu2tOpBUrLHAc+LrhvadWEGU/3H2N+BpOl7tJiV60qGdph0IiRVOcR9mpVUJ7zKyxCulfo5/nYm7Nn10nGd7XVuewKt7eHkmBVp+mrBOxY+iYKvdTZcWhLRU8y6xC+iOxqJ10QI1Wx0J9VUexCFwsLAGQi8R8euFvUj/tZBADAVxGfFxrPoYm7kygkyUNnIX/n4Mx2eyIzKhyv9Ibp0mY1wdtWRGt84TolvSyIjYnXK3V9kltnDnW8kOU+rpjctRIzv9J7Pstif20MwWn16LTanFUWBqOUf0jCsvP2pH1PZ7AQn+/P52VSMftP9B88zc03/xNrbRbZq8fUGrUqHOFwb6ZvqK5pVSOn50dO2a2xc1aiATaeDmNpadunw59r+QpjQWhbnqQyRx9QCJ897LY01Uety7cGB21aqLJN7CmEIlEfN92mMHG4oMLuzlSQbS9SX1HS8469zW8T09NumWfB0Fi5YDT0PcYmBGJo1Lo+8QUPlj04TB93w1qx+6jJviBMn6N3MHii2vZfvI3Yt3cGaDoC6mBkOtOKwdP/Kwd+azlABLHvMN3bYfio0/r1qHj95izTDq8qkbaYiGX0LeBceJ71flkgr44wFvbIxDZCD506rwU1sWGG/Z5L7Q3YpHpWfioaeBixdDGwv9RSkEZU1cLEzbWLYbg8/p+JJYOKLQaPj/3p+GYk1m144deqeBflpa/uk3i146jDet+SovDuu1YQPg95R1aXCvtMFFzRGSWEJ5adSaWRCRCLDZNxpn472J6Aj7myMQS5gYLnk8anZYfIo5WuV//hi7IJWJOyEIN64qv7K2VNmWXCJFh5jKxYYCj03tg3S5S4r/MnI6+uOoHqCvPJXMlreZShyUVKjoP8BEGxsVKDXPWX6pxD8nNiVdQ6iOXxviGIhKJyD20GJ1+QGTXdUatiGEdXH1p5SQIAccz4wl/CAVGDkRn8c3hGyARfusOCnMU0qqLtpcnXzEsKzwb11qbdkRmGGa1BzdyJdRKmChQ6rRcu3rQsJ/cIxi7mX9h2358rbXFxJ0Ri0V8OaiR4f0rW66i/sdgvzT2LPHz+hjE5OnmxnS27yOO1Gr7DkRnMTPSjz72i1lkMRathTGqu/RaGEn/Z++so6O6uj78jGXi7h4CBHd31wKFAm2hTo26l+r7Vam7K0VboEjR4u7uBEKUuOtMMjP3++NO7kwgngkEep+1ZuXqOWcyV87ZZ+/f/mYKsf/XjWH6XGn7PwmnrypngH8kB255mii3ayMT4dTaklCiyGz8buEsGuhSSwrI1ZcQ5ObA73d0ko57asWpBntmF1vpOjqa5QCUWkccI3sB4jPAkJdW4ZyUfB17zFmFOwe5EuXr3KA2yFSkq3cw73cVJ6BMgsD0HQvJ1lecCFMqFUzqEiGtH4itXIe5Prj3vx+Vgyv+Zk/RpMKcer1zs4st15anQ+NITTSUCbe/x7SZ8+iTE09YSS66y2f545BoXHWyUzGlneX54azR8lSb/kRPepmve96Kp9mL+N/L522SgEilVLDmwZ78MrWjZPjXG0zM3nyRNdnis8BgKOOfBNG72VVjz7DAFg2uV8Y2/DSlo6Sxu/pMGl/tjAXAIaIrYS9vRuXkSaAuXzK0H8m0jRH/SjoHueFqL/bpdsfnIQgCM1r2ZKC/mKH+RE4K8YNmgtmjO3P1bExWE0MyTZMOAS7serLfVR9HO5WUVVdG5r+IfPXfBDwS1RsHsyfCT9H7KhVwd7FXM6ylN2kqby6pxDDekgu7Melt7ymWXSx6iXk5WjqvgllLR2nnUOk5/2WctGpeHSp6bgoCvLn+XA1n1B61syVj3uBAJWFm0eY1Z9P5zQaeMdaUi3MDTI3ohKm0hOwNX4obFEo8Rzxt0/qseTSqt7T83bk9FJbpGy2RQb6ujPv/PCauqETtLx8HpyqP1ydbvLka0yD47W6x4+wolPBqwQ/4750r7bvg5I3GO4zAh+YQ+d5JtK2HNVo7ZGrH+LZ+DIwU78+zaYUVwgFL4o8S//FwTMW5ADi1H8mkR+ZJmrHbUy81muF7R0wWU+cexiRAhsqLkKnv0ebLRAIfmoN9mCWsThd/FKdvJxNiFO+zzSkXKs1039bDn4PjnubT7uN4uk1/6dMYOLaxJAUoOlvRIAhw3pztflQrX54wa/UVlRq5a+HRqwyydaFcoxDAQWWZGKjQnis88leeSqXcPjSpvZylsDF4vt1ARppDuBOLcpmxa/FVRrmx7S0ac9HJWaQX2Oa9oXJwwWv0i/jrRYNgqWAiOfFqo3lN5JRYGQQdm250hdYqWdjliyfINbf7rq7BuGivniyzU6l5ok0/XrVK5LE47rhN2qJSKpjRM5QLrwzhjeEtcNCIQ52TgphZ+JhbIBnmEM8xwa2wU1U+mSdz7fF10TJ/WpdyOxsvrT7L0SRRO9M+rBNhs7agdvaiTYE4wZJcUkByju11KFVKBQOaie+O5IJSYsxJ/x5u2Us6Zk52Gq497wDAkJtCzrafri5IRkZG5gZANgjeBHhqHbmvRTcA8kp1/HbhQKXHTTSHnpR7CQqGUoovVO5R2BCyisxeU1YGwfKZM4VGNghWxiO9wwhxF70nl51M5ZCVBk5DULlYZuaVxdn8OLmDtP7UilOcs1Eikxx9MRsuRwNiyFwXryCy/v1cCttz7TEFO+8wm9RVGXdEdMLV7H364/l9uMx/DZf5rzVKXc+uPE18TgkgoDAbBD3tHKs8Xp9k7SHYpsrjGsLFzCLWn8tAJRj5UfcJzkd+p0WhRbcztd/9RH5wHvd+96JQymGJTQGFQsGn4yzXw5v/nidfV4Yu4TgJHw7DZE5K4dR2GCFPLUeldeDJ1pYMwF9X4Q1eXwRB4NNtMQz5YS+Z5mQb49r48fygZijt7HHvdy8Rbx0mbNYWHMyebwpgYIp4feuMBtad3VFp2S4ae55rN5Avek6QPo2BfUhHlOaMvsVntyIIAs2tDILnci2h2R/e0prWfqJX3r74HF5ZW/+JmGKrRC+OVgmDKvNYLGfZScsgVjYINg5KhZI/+t+Bnznr+4qEU3x3bk+FY5ycLRnh1SY93+6Os1n93uNeJcTNV1o/9NuDGIvrlhikfIIVwKMJGwSV9s6oPUWDmyktWtr+aO/q3/tTwztJy9aTirbAWavm7VGtOP/yEO7uGsw5tejdtcnbIp0zMaydTeuUaThDWnjz6lDRa7PUaOL2eYcpMCdesg/tSNjLW2hr1hEE+PfXhzCW2C6yppzBzS3vjq0XMwGYFNZe8mpdFHsU7dhZYA43z1r9gewlKCMjc0MiGwRvEp5pM0BafufYJnIq8fwb39YfpQL2ajpJ24rOVC62XV/KjCYK9OKL28vJ0nktDxlWyiHDlaJVq/jfiChp/fV1tvESVFkNho2FWYxs5cvT/cUQqeJSI3fOP4Le0PAEBSsSTkkJLG6P6IgxL42s1bPNjdDgM+mdBtdRHU4aLfc279aodYDo1VPuWenmqEQwJxQp7yBWhhQyrNJg59u8yuMawvd74kAQeKXoZ7oUiXplLQ0WLc9LXuEo5QyKTY6uIe6SkHpGYSnfL1tH/EfDpAzwjm2GiILqZs/qac26SNfagpgjV4VA1pcCnYGpcw/zwqozUjbhcW38mD+9c4UkFwqFAqfWgwl/Yw/BTy3HLqAVgzNjpP1/rvmU1AXPIliF0F5LFEolTq0GAWICgdKUc7RwsTII5lmM5I52auZP64xGJX6/T7bF8P6myhNz1YR1yHC5tz6AQ2QvSSaj+KzFIJhdXMrWi6KmXCtfZ9r4W4xSMrbFz8GF+QPuRGFOe/v8wVUct/KutZ6ktBf0fLs7luJS22TEViiVRHW/TVpPzM8k6bvbEeqQcbtCyHATNggCaANaAeBuyMbFVEivMA86BVUvExLi7E5fcwKYI1mXiba6R21FiIcDc6d15rGptyIAm71FY5NWpWZ0cCub1yfTcP5vREv6houTOxcyi3hiuSWBlX1oBwaOfEpaP5aXScJnYzDZOCpkcKRlQr38eW2v1nBPZFdAfO4vKy7CrZcov2LISyVnyw82bYOMTFNkWvwnvHTuMWLf7XfVJ2XOzOvdPJl6IBsEbxJauvlIL6lMfRFvHFl/1TG+Llr6RnhyUNMOo/mnt7WOYMXOayUegnLIcJXc2y2YFt5i6Om/5zPYeal+IuTWKB1cwRwOYywUy/vwltZSZuNjyfm81gDPGIASQxmfWGVQnBrekfRlb2LSiTO4jv1moPVvfI2ed7qM5JGoXowNbi19bMnRpDymL7BkWX1rTDNp2asKg6BgMqFPEbOcagOiGiWhTnGpgd8OJDJNt4Y7dWsBUGi09HniLymhwqkc22ljydiW90a3wl6tJMCYQd+N92AsED0RHFsNJPSZf1BaXVsOag0PtewJiGGqv0Tvb3D9iTkl9PhyJ0vNCS4UCrFNK+7vjqt95derQqHAteutRL53krG3vo6zUfRi2uYZQeaGL0j766UGt6u+VPDKO72pQsjw2St0/LoEu/PTZIuu7mvrzvHRlot11nqzDhl2tLrHlRotji1Er87StIuUZsQBojaWwWx4ndTekjRCpnEYFtiSl9uL14XeaOD2bfOk8HZrGRM7oYys4jJ+2me7bL7WHoKpWheKTv5L2p8v1vp865BhjyaqIViONtBiXGtmTGJmn9pFBdxhlcHV1l6C1nRoHs4OlyguO4hGymEBLXCRJ6mbJGqVkoV3dcHdQXyezj2UxPzDFr3AXi37SMtnXHwpid5F+tJXbdqGjoGueJjr33oxU3ovPBTVUzrmp+h9eN/6puQlmLn2w0aRYpKRaUoEl1wiqDjmqu36xBPokk5WcoZMU0c2CN5EfNT9FpzM4UrL4k9VesyEtv4UKJ05o44EQBd/BFOprtJj68O5dIvbvo+T2BZTmd5KQ7BqT6r/OmqVkrdHWbwEv7NB6JJCoUDlKM6yGovFEEStWsWiu7pIujrf7YmTvILqiiAITNwyhzO54kC7uYs3HT0DKTwpGqQVdg44DX+hoV+jVrjZOfBDn8msHj5D+tiSN9afo6hU9Ka8p1swQ6M8pH3GKgwIGcv/h2A2hmuDGic0aXtMFhRl8WyRRTMw8KG5uLToQ5R5MHoxP7NR6pZpOCEeDjzZL4KR+l14msRwQm1we0KfXY1Se7U25WOt+kjeTqsTG5ZtuFBvYNxvBziXLhrvvRw1rH+oJ68Oa1GrjHsKlRq/wQ8xJqILAFl2TiwLaE/2xi/RJdhGD6yuOLa2aJKlL3sTz8xY6b0YW0nSgvt6hPDNRMu9+fKaszy5/FSdNAVVVhlKF8QcrdgeKx3BpK9vw1iYze5YSzvGtZUNgteCt7uMpJePaKA6n5fB/45uEHdY6cfZIXruvbMxukKobkOIcPaUln8N60Gy1oXsDV9QcOSfWp2flGvpn1lHXTRFrDVy/1f0HZMia+eVPiLI0u85mGlbbWNrwjwcOOwSLq33uEbJjmTqR6iHI7/dbpmweezvk5xKEZNshTl7SN7y+z3CKFTZkb3xK8qyL9usfqVSIen8phbo2WV+brdx96/g1Zrg4IFb7+kAGPPSyNn+i83aICPTVLnsGEnE67sqfLQhHWo+UaZJIhsEbyK8tI4YzWGbVXkslWcyvKQSw9QQBAw5tsvStfCI5WU8pIXobq9PPkO5erpdQFSl58mITOkYiI+zOHhdfz6jQUL3ElLIn2WA39rPhTGt/QAoKTORXli/UIvFscf59/J5QAy/+bLnBBQKBRovUahdKC1BMNjO4Hy9yCjUs/68GMoU5uHAz1M60tLNB3ezd8m6y+coM1UMvc7dPZ/Mf94VV5QqPIc90Shtu5RVzD0lK3FE/D97Dn8Kt55TAbAz6wUK2DajtIxt0agU7LXrJHlul2XGYjQnFLmSUGcPyQutuAGhuSaTwN0Lj3I8WRxgRfk4cfjZAYyI8q3hzKt5qt1AafnTZv1JtnMmbfHL9W5bQ9AGtcGl2yQATMW55P00FYX5/WNtuLPm8X4RfDbeouf47e44Jvx+UNKtqol7m3dFaX7OvnF0PUtiLcZQj4EPovYU37e6+CPEfzQcN8Gif6VVyd2wa4FGqWLhwGnSvfP5mR0czkySPHIBfP1ELcfs4jL+t/68Tert5RtKb7MhMlXrwoyOU8iwcyT51wcoy6k5MdCu2PJQRSWtmngmatcet5OtFQ3cUYY4Ej4ajrGw5szBu9JipeX2Ho2np+mihhF5Fu+VFSkx9cr8LHPtmNg+gGmdxUSIBXoDHT/dzv1/HiMuu4TbI0RjYYFay5+BHcFoIGfbjzatf3qXIGn5s+2XpOVJYe2l5a2pMXiPe0Vaz1j+Pwz5Fr1amabB3YmfVxnmKshenZVyXuNIvzXfXPWZFdWd70NtG4Ulc32Re6I3ERfyM9GZtWnKs1FeibfZay9FaZkZLcuyXXjM4uNi2JmbvZpxbUSDk97KU8Q+pGOl58mIqJQKxrQSB+S5JWXsictpeKFmI7HiisFwsJslVMbaC6G2FBtKefHQaml9+ZB7GRMiviCcO4yWtpee23LVuTcafx5Nlrwo7+8egp1aiZ1KzYRQ0SMiW1/MthSL+3xx9G5SfrN4KPrf/Q2OLfvSGKSkpTBdJ/4Ogtoe71ssHdPyCYKqDCEyTYNDiXmcV0ew0H4sACZdIakLqs7KrTEbeq80QteF//17nhWnxFByT0cNqx/sSZhn/Ty4+/pFMKNFDwDyNQ480GkKl87vptDGkhS1QaFQEPTIfBzNWoKmwgz0Zg1bbTXZRJ8dGMmfd3VBqxbvlbVn0xnw7W4u59UsEj/AP5LPuo+X1u/d+SeHzJ5OaldfwmdtrWAUHL/3EewE0QPNVp5oMjUT4eLFu13Ed5NJEHhw92JKrDyKerRpiZu9eI18tyeOk2ZvpIagVChZPXwG7dxFQ1mCowcPdZhMlq6I5J/vRTBVPemXVqDnfEYRAL3CPNCqm3ZCKJWTO2du/ZPk8v5l8gniPxomZUuviiVW2YWnhDeeh0nxxb20K0qma644CX40+7J0n8o0XT4Y25oI87vJJMCcg4m0/GALeYkBUt9mbkg3ilQacrb+aFMtwVvb+RPqJnq6rjydyoUMcTJncIBFD3prykW0ga1xH/Sw2MbiXNIWXZvIGJnas9pPy5st2jPFu81Vn2hn70ojMv7LRJWVEFVWuaE0ztGFeIemPUElUzfkUeJNhLVQdkfPymdZvcyi1CkqK4Ngdt07RPfccw9TpkxhypQpFbYPOvsLtyQsZErHQOw1YufVOnRMGyobBGviFrMhFUStqQZTPuBQVrzdQ9wt2kmJuXXPjPbhya0kFuUCMDG0HaOtNPuc24+SlvXnbJu45now/4jFi3a6OQkEwGSrwcvSuBMAlGbEkvjVRARz5lHPEc/gOeTRRmtb0InfcBbMYcn9HkTtbglBNJh/e7VSftTXh6qec1OmTOGee+6xSR2CIHAoKReAZYEzUHuYvSEOLaPg6KpKz1GbB0HliXzqSmahntlbLoplKRX8fW83mns3rDP8cfdbaOsuPrsSHTyY0WkKp5e+Xq3Bo7FQ2jkQ8sw/2Ed0xwSUmQ2odjX8v27vHMSWR3tLE2fHkvPp+eUuYrNq9h54qk0/HokSsy+XGMu4ZdNvLI49hiAI2Pk1r2AU9Mw+zbSSNUBFjbgbhWtxXzQWT7XuRzdv8Xc4lp3Ml1benG6+IfxvREtANDw8veKUTTzIPLWObBz5MM1dxKiJC84+PNphEunntpP8y/3oUyr3RrTWER7QzKvSY5oaA7p24X6390hRit9VF3+UnB9uw2juK1xJtr6YTcliMp9yyZHGovjsVgCmpJyQtv14fl+j1dcUuRHv3RAPB06/NIjPJ7SVImgMJoGF+7MQcsUJ9Cw7R74O74sxP52Cg0ttVrdapeTh7uJ4ShDgy52iN2tHzwA8zBEi21JFT1O/KbNRuYhjq7w9867KLC9zfYl3cCHa2Qf7kA5XfTr6N6drVL/r3cQmxbt5sSzJPMOusU9c9Qkvtn1Wb5nrizxKvIk4np0iLdfkIZiqtGTPqo+HYElJCSaTCdMVgz0lAmpTmZQ5E0CXaO0hKOsL1MSIKB/UZv2u1WcbbhAUygfB1XkI1sILxpr4wmw+Oil2rrUqNZ/0GFdhv31YZ1SuYket9Py2OmVVbGpEZxRyICEXEL00rA0nwwNb4mLO3rs84ST6whwSP7sFY4EYXuzccSx+d37SaG0zFuXSPeFPAPRoCBk/q+J+2UOwQVT1nDOZTJSU1N2IXhlx2SVSMqa2YYH43/WVtC913hOY9EVXnVNu4K2vh+Cas+mSx+vzAyMZ1Ny7hjNqxkPryKaRjxDlKg6IYh09me7Viku75zW47PqgcnAh9IV1mAIsumam+COUZVcvkdEnwpN9T/WjpY94n1/O0/FeLbIPKxQKvu41kaEBYgKltJICbt82nx6rv2RL8gXs/JoT+vx6MBsnHy5ZjJupoEIirhuFa3FfNBYqpZJf+k6VnokfZFwm3sEdALWbP0/0i5BCc7dezGLZyZSqiqoT/o6ubBr1MMGOYkKLk64BPN7uVtL2LiRmViviPxlN4Yn1FQzoOy5Zwm3LtcyaOlG+zii8wrnf7T3SlWKbDUnHif94RKVGwX8STksTG1MiOlTIam5rii/sAmBERjQKg3gfLoo9Sl5p075mbcmNeu86aFQ8M6AZl14dyvtjWknJRkypYWAU7+X5wV047hpA9qavbVr39I5+uJo9h38/mEh2cSlKhZKB/qIWe2pJAefzMlA5e+J356fSeSl/zLR55mOZhhFeXFCpgWvX2Cf4vs9tNRcgI3OTIo8SbyIqeghWbhB0s9egUioaLWQYRKW6fhGikLYgCFLIsMY7HJW5MyxTNa72GqnzfzatkJjMqw0CdaKqkGErD8G6hgy/eHC1FJ7+fNuBNHOpOFhRKJU4txspVl+SR0lMw7OhXi8WHLaElN1lpScDojF0fIhocMjQFbHslwdFzUzExBBBMxehUDZemFf2xq9wNInXx0b3MWi9KravfKCllg2CTZZy70CAbsHuuHSdiHOnWwDx2Zyx/P+uOqc8ZNhQT++7f05bsk5P7mg7zS5/R1c2j3qUZvaiMS3GyZtbTu4ks9AG0gf1QO3shcMDlmQ76pJ84t7tiz41utrzIr2d2PtUP5y14v95Q3R6rTzFNEoVSwbfzS0hFm/pQ5lJDP33R0b++xNnHdzxGPggAG5CEQ+WLJVDhq8DHT0Dean9IAB0wP+1HI4AqN0D0KiUfDHBYkR+/p8zlJTVPzTfmjBnTzaNegQf8/1x0COUl1qPwQQUnVxPwqejiXmlNdkbv8FYUsAOs4egWqmgV5i7TdrQ2CgUCkZG+ZKoCuBet/cwuoge67rYg8R/PBxDYVaF463DhSeHNd6EsWA0UHxxLwBp+CDkiu0qNpSx8NLR6k6VaUI4a9W8MrQFsa8N5Y3hLXBWOkFaMwAEhYI3o0aQd+kgJZcO2qxOF62Kh3uJOqDFpUZ+3BsPwOCASOmYramix71bn7skuYrS1Giy1n5ks3bIyMjINBYKQVbUvWYkJSUREhLCqFGjcHS0fbbdYnsVgkKBQhBw1FXdgS3/wZWUDyYVCDTerKziGtVzs1H+OzX0P1bd/78+dRiVCnTmgbJCEHDQGas4X0BhVcP1+O3//vvvWh1X3b1p/YCs7BsYVAr0duL/Q2MwojUPHoVrMN9i+W0rr6/EXoWpFs8EmetLZfdhdb9tQ3/Xmq7phiIoQKcV2wigMgnY6yu20xb3Zq3aAhQ7iN4daqMJ+1KDeXvN92dD/k9GpYJSjRLTFdmaNQYT2jKLx/S1eE7IXI0A6Owt16h9qQGVseL+cmx9j5jM94dgrltjMGFXZrR6X17J1S1ozPepLd+bCio+y6z7AoJC7LeCAqW5L9GYWPeFjAoFJWavL6VJwEEvvx9vVARAr1VhND9r7QxG7MpMNr9HrnwmmBRI15DaaEJbarLaX33frL7U9d5MTEwkODi45hNqICsrCy+vG8NLuSrafCXqep956tfr3JL6ceVvcNttFo/G2l4XdSH2XTGEOuL1XVftq+p/Wd05N8M1dDN8h6qoWmFb5oajtgPD8lfktRqIyAOe+mGrrkx1///61KEyCTiV1CYE+OYwANf0DdRGAXXJ9Rng11RXYw+wZGxDZddYdb9tQ3/Xxr4rFULTufYUUOF5VZf7syH/J1U1Rgb5nXj9UVD9NdqY94hSqKy/dnO8L8ux/iZVXe8KAZxKrt1zwrodSoFa9mNkmjoKuGrCqTHupStLrO4akp/xMjIyNxKyQfAmoUytoNScxMOuzIjGULXjp8VDUJDWBPM8rq1RVKhDfkHWBVt5KFQ1U1nf8q094qq/1q6/h6AtqI0Xpc48O61AwLHEUMPRtkFRzf17pfdLTc8EmetDTffgld69ggJKrDyL6vO7NrZ3YIW6lFCsvf5eONbe8046i2Zfbd57tvLUFt/RSqkkbakBjdHEjfxsvBnQ2ykxqMT3orbUgNoocOWzFBrnXjGoxGtCsNLNU5oEtGVGVCbL870qmnqf6spnzZV9Eb1GicGc1dtBb0DZqPmHLP0RwXzPmWod7SBzI1CmUlBqZ3nGqg0mtGW2vaiuvKat+8MgYK83oTIJjeYhKCMjI9MYyAbBStiyZQsff/wxOTk5DB48mGeffRZfX1+blf/zzz9X68JdH5fUHqu+5GCmmC04YcrrhDi7V3pcYk4Joe9uAuDxyGIe238HANqQDjR751itBZ2nTJlylShxOUqlkiVLlqBLOM6lNzoB4BDZi4g399bhGzU+Td31N+TtjSTl6QhxtyfhjeFA/doc80Yn9AnHUdo70+pHMTPUcytP8/mOSwCMb+vHygd61Lq82IIsmi2dDcC4kDb8PeyBSo9LmfsEOZu/BSBs1lacWg+qU7uvBx999BHt27eX1h9afJxf9osam/ue6kfPMI9Kz7v1h4dYqxX1MU/1HEvbNoMbtZ0mk8CWmc0I1MWhR8OyyQd4Z1wnaf+9OxaxPOYwICY+WTHiQZRWOoJN/dq3JQ35rrV5ztUHQRC4Z9FR5pv1KbsGu7H7yb5o1RX1JqOfCsCQl4raPZBmnycw7N8f2Z4q3reTwtqzdPA90jO7Nt/zVEo+7T/ZDkDnIFcOPzugUUX8M1a8zfC4cxx3EzVt9459kl6+YfUqq6b3ZlVkZWXx9Kl/WXDpCAAbwloR9MdDANiHdiLirUNV6nyuP5fO6J9F/dP3x7TilaEt6tX2cv5JOM2tm+cgIKAxGVlyeB7NinLw+jCJQP+atRybyn3b0PuiqXwPgFM5KbRfISYC8NcVsO7Ab4Q/8DPu/e8jMaeEyNmbKTMKeDpqiH99GM7ait3mhn6XTF0RbxxZz0/R+zBZKfjcGtqO4vhwNpwuAEHgxDO9aO0mkL35OzJXvg2AW797CXpoTr3rvpL6fpfK7s2SMiPdPt/BmbRCAP43oiUPX/6U3O0/A+Az+T3G4MihzCTUCiUFd72HvVrT8C9RBYbcVKKfFu+xjXa9eMb1VZ4f2IzLrkf5M/YYAM+06c/nPSc0qeuzNtSlvY31TqsLjfX/XXc2jTv/WkhRSAIG8zN9XHBr/hp8Dw4NuLas2zvhtwP8c1pM9jelYwBL7+7KS4dW88kp8b3qbufAKictnsvfAMBj6OME3PNNQ76WjIyMTKPTKNMWGzZsYOfOnY1RdKOzcuVKpk2bxogRIxg/fjxz586lXbt2bN269Xo3rUriC7MlY2BPn9AqjYEAcTnF0rJzaAdJ/FafeILi87X/zRwcHFAqlSiUSmnGTEBMXOHgICaryNn2s3S8+6CHal22jEiIOelHcr5eyghaH1TOYkfGpCtEMJRyNCmPL3eKRgUnOxVfT2xXp/LCnT3xd3ABYG96fJVi+8Xnd5gboMEhsmc9W3992RsvJkPQqpV0Dqo8IY6xMJvg1DPSepyLX6O366dNhwjUxQEQ7diaCT29+eHcHu7esZBmS95nrtkY6GHnwO/9bq9gDJSpPeXPOaWy4v9PqbQ85+rDz/sSJGOgu4OGJfd0u8oYCKAN7QiAITeZN/evkIyBEc6e/Np3ap2Ned/viZeWZ/YJb1RjIIBTuxFMv2wR7H/n+EbWJ51jfdK5Rq33SkYHt5KWt7sF4RDZCwBdwjFyd/1R5XnlmSwBcksang14fGhbKZlFmVLFi63HUqZUcnbXPw0u+1rSWPfF9aCdRwBTwsVkFqn2Lizzb0vyL/eTveUHQjwcuK97CADZxWX8YHX/2Apveye+73Mbh8c9wwC/ZtL2FQmn2KfeAg75oFCw9mI+ajc/vMe+hMpVnKDO2z0PffK1vZdqi4NGxYLpXdCoxGfMOxujSejyOKhEg2ra+s84kS1mcG7r4d+oxkAAlZsfCq2YzCXUKNarN5j4pPs4nNVaAL4+u5sTVsn5bkZupnv3Ska39qN3UG9mnDuHg1F8Xq9KOsuYjb9QbLBN8qafpnTEx9kOgCXHU5h3OIkPu41lUpg4kZxbWsItGWmccPEHlRqvMS/apF4ZmeuBPvEEse/2u+pjZ9JhFAT6fb2rwudkSn7DE2HKXBca7CF4+PBhTp48WWHbkiVLcHR0JCYmhq5du1bwuGnqvPDCC/z4449MmDABgMcff5w777yTUaNGsXr1aoYPH17rsvLz88nPz5fWU1JSbN5egGXxp6Tl28Kq/1/HZVsMguGeDngOe4Lic9sAyN7wBU6tBtSqzrlzxcyNS44ns+jtJwHRfX7pUnF20aQvJm/vfACU9i649by9VuXKWAh2t4d4MJoEUgt0BLnVr7OmcvKUlksLsnhk6UXK7Ytvj4oi1KNuQv0KhYLePmEsTzhFpr6ImIIsmrt6VzjGWJiNPkl8LmhCu6C0a1odzdrcm3klZZxJEz0quwa7Yaeu3KiWf3g54UWWzIkX8jNt3NqKXMgo5J+1fxMf1JndnuEc82xGwZovKj32xz6TCXKSM3vXl/LnHFQUcG6IF8WRpFyeWmF5Zs+9sxMRXpXfg/YhHSk6+S//+rTkg3Oih7VGqWLx4Ltx19btnirQGZh3OAkAV3s10zoH1XBGw3GI6MaoolQ+0ReQrnVhbdI51pqNgcL9n1R6TmO8N0cGRSEG9Ausv3yeV6d9Ttw7vQHIWPoart2noDJPcljjbm/pItnCIAjwdueRbEq+wOGsJC44+/BZs/7cfnI9TH7EJuVfCxrjvrievNlpOEviTgDwc2hPJqWcIvWPmQhlOmYNeYjfDiRiNAl8sj2Gx/qG4Whn++CaTl5BbBs9k8Wxx3nx0GoSi3LJNxZDxDFIbsnas568PKQ5Sq0T3mNnkbboORBMZKx4i+DHFtm8PZVR13uzU5Ab741uxUurz2ISYOqqdLb0vIfSPb8RLSgpNYkSAl28Gv9ZpFAosPNrjj7huGgQFAT0RhNBTm78X+fhvHBwNUbBxOP7lrO8x83bX73Z7t0r+XRcWx6a3Y+fj3/HY+0nkq+xZ1tqDFO3zmP50PvQVOENXlv8XLT8dnsnxv16AIAnlp2if4QX8wbcSdq/BexOjyNPreWBTlP4hRLaeNfPI15G5npjH1y1PcGgdsCA9ipVi6LSpqEdLVN3GtyrWbp0KQsXLqxg9Dt//jwajYaSkhKcnZ1vGIOgyWQiJiamQniwm5sbK1euZPLkyUyePJnjx48THh5eq/I+++wz3nrrrau25+TkVDsTZ93hqg1/XTwiLQ9xCyErK6vKY08nWfZ5qg2UhvVD6RGCKSeRgiMrSIs+jNorvNZ1/7ArBmtzQ3ndJQf/xFScB4C28yRyCnVQqKt1udeCuv6frzXeWsvyqfg07INc6tVmg9pJWp6/9SAHE8UZ+/Z+Tkxv41bt9VIVHZx9WG5e3njpFB4hFe9x3al10rIQ1KVeddiCqsJSqro3CwoKpLZui82l3Pmxk58DWVlZnMxL44sLewAFflonfO2dcDq8lmw7Z6mME+mJZPk3zvc1mgTGL9xBdosC1jkOqfQYZ7Ud3T2CmB7akSGuwZX+75v6tW9LGuO71vd6ztcZuO334+gNYsjWk70C6eOvqbI8nUczvozoy09hvaRtb7cZQoTC8apzavqevx9JpUAvCqDf0c4HXWEeusJ6fY064disH3cnHeHTyIG1Or6+782qyM/PxxXo4hHA4ZxkDmclEecQgH3nSeiOLsOQl0rS32/hPPqVq8416SxeJWl5RTZ7jn3bcQxDtv9OsbGMBcFd6Hx6A5kZGSiU1XvyNvX7trb/n6b2PQKwY0JgK1YmnyPV3oVFQR25N+kIaQufxTk3i9vajGXxqQzSCvS8vfYUL/YPkc619XcZ5hbCtgH389ChFWzJiBUzFwSfZ2dWIecTmuHtZIfQcQrKNR9hyk8l/8BfpA14HHVA6wbXXf5d6vrerO7evK+9O8uPObE3qYjEXB0PMJQflHM562LpZ0fZu1+bPoJbCHAcB0rxMWWTX+RLVlYW0/3a8LPLPs4XZLIrLZbNiecZ1sje07bEFtfgteyjNeb976eBtj2H47rpB34/tpj7O00lX2PPmqSzTNs0l++6jENZx9/2yvb29lNzX2c/5hxNo0Bv4M65B1h5VzsWdBrP3UtnsdM1kBKVHfcptJSc2MWtQQ2/N8u5kULZZW5sAu77vsp97mu+wR3YNbZfhe3/PN4wg7vM9aPBBsFnn32WixcvEh4ezjvvvIO9vT2zZs3C3d2dWbNm2aKN1wylUknHjh356aef6N27t7Rdo9GwcOFCunTpwmuvvcaCBQtqVd5zzz3Hgw8+KK2npKTQo0cPPDw8anyo1/ahn1Kcz4FsMfSss2cQXUObV3t8ui5RWu4Y7o+3rzOKkU+T9ucLIAgIhxbgNe2zWtWdmFPC1thcbq2k3XGH/5K2+Y96Cocm+hJryi/XFv65gDgDny/YSW2ta5sNXoGUmJe3nk0AxBnLn2/vjJ9P5Zp4NTHM0Ia3zohh9CeKs5h5RZtSk49Jy47BbZrc/7mqe9PFxUVq6+nDlg7ykFYBeHp68syuPzh+ZUiRR4T4MZOgL2y07ztl1T+cc9kDCsvgK9TJnb5+EfT1DaevbzjtPQJQ1WBYgKZ97dsaW3/X+pb3/cZo4nL1APRv5slnkzqjVlX9W72AgjlWxsCHW/bi5W4jqgz1rapdgiAw97jFk/+ZIVF4eV3tEdcotBvMvYtewLu0iOLut+MY1b/awxvy3qwKLy8vxoe343COeO+uyorhubs/5+KptQhlOoq3fYNPz0k4tuhT4TwnV8tsd4lRabPryMvLi697TWTG7sUAvN+iH9OzL+Af1aeGM5v2fVuXtjW17/Fej1tYtfI8JkHgxxZDuDX1NG4GPYVr3+WtXklsUIwhV7Dnq32XeXxgFCEelmewzZ8vwIYxM5l1eI2kTSZ4Xebu/as5MEWUX1He+gapcx8HQaB06xf4PbnUNnVX813qe2/OmdyG8QvOcD6jiJ25LuzxGcsZ5wJpf/+QqGtyPRhC2qA/uRqANsZLCMr2Ur3vdB3N1G3zANiUl8DtXn0bvT22pKH/v2t9PzZmfbMnuDBr/y08m/sD359cxoOd76BEoWTp5dN09gvl1Y5D61zmle39dqobe5N2cD6jiP1JBSzbf5pbs5fw9dG/eK3VKNb4taZMEHjo8EoCPLwYE2I7o6CMjIyMrWmwsJSvry9Lliyhc+fODB06lH379tmiXdeNV155hTlz5rBoUcUQDCcnJ9566y1WrlxZ67JcXV0JDg6WPgEBNYuG15XtqTEIZp/diWE1a8GlFuil5UBXewDcBz4IKlG/RdJ9qwWbL2RShXwc+rRoAFQu3jiEd6l1mTIWyr2IrlyuKyoni9GvMNcSztqQMrt6BaM1awGtSTqLSahYlqkkT1rOX/I8KfOepDQjrt712Zra3Js6g8UYEJddwqbkC1cbAyuhzNQ4LvPLL51hacZOKd1l19wkNpdlEz/1dRYOnM7jrfvSySuoVsZAmevD+QyLS95bI6OqNQbGFmQx57L4HFWbjLxXksEPfW6rl+7fkuMpnEwRB+CDIr1o7XdtjIH5h1eQsfz/UCEwPu0sj6NnVochzOpQuXcrNN57c3xIW2l51uG1fHL5Ap4jnwVAKNMT/+EQ8vYvrnCOvUaFvVkqILvENhpU5dzfojvt9OJvmW3nyM97ttu0fJm60dbDn4dailq3eYLAtrFvSPtM++awvuhZupWdoqTMxOvrG1+3T6VU8nH3cbzZejyYxOvkYMF5Xvn3OIIg4D5gBhqvUAAKDi+jNNP2+oZXUt9708tRw78P98LDrMn5lmE8hzxEL0uVYKKtVlvd6TbDPrSTtPxewRdcOHWQzEKxTzw2pLXkOXYqL+2atEemcfBysqPd2EcoUjjQKT+FL04sk7xf5sYcskkd9pTxffs0ZhX+zKqcmQxcMoiczd+iEUx8cHYtjwaJCagEBD49LT/bZWRkmjY2GzlOmzaNpUuX8uGHH7J48eKaT2iiTJ06lRkzZnDvvffy999/V9jXqlUrBEGoMonC9eBwVpK03LsW2RtLjRbDjYNG/PlVjm6o3fwBMBbWXv/sUFJulfvKtQeMBZkYclNrXaaMhXXn0qXlAc08qzmyepT2lsH/uEjL8uhf9rPtYv307hzUGsYGizOeiUW57E6Lq7DfZ8Kb2Id1FleMpeRs+oaLLzXn8g93oUs4Ua86rzXTuwSjUooDhLc3nueNI/9K+77vPYnD457h77Z9eefcvzx9aScz1AoeatmTr3vdavO2XMjLYNqO+aAQnz0Pxu9nzrG/aFkmi/feSHSxSkyz35ywpip+jT4gLT97aScz2w2slzGw1GDilbVnpfX/jWhZ5zLqimAykr70dZK+mohJJxoi7cO74mU2wF0POnkF8WoHi2fIq4fX8U5gFxw6jgFEo+Dl724nc9XsCu94T0dRQD6n2DYaguUoFAr6uFi0I7fG5pGvs20dMnXjxXaDpOV5aAh8ZL70/nQpvsxvea8zSr+TeYeTOFJN/8eWvNVrAL2dxORCKOCDAwe4c/4R3tsWz57AKeJ2QeDHL95i4Le7uXPeYTIK9VUXeJ0I83REazauCz4+RDuJusOd8y5Tsu7Ta9IG1+634dhGnIzwEAr4In0Wny8V3+uOajscVeK9Xmw0XJP2yDQe3VqE8qbzEwD0y4knKl8ch1wqyMbQgEnbwtObiP94JOcf88Bv8TTu1q2imfFyhWP8bnuX74Y/TBt3McHcttQYMq6FPocMKXNmVpoEozwRhoyMTOXY1JUkICCA5cuX8/PPPzNx4kRbFn1N+eGHH7j99tuZMmUKL730Ejk5ORQXF/P+++9z3333NXpmxrpwJMvyIuriFVzj8eUGQYUCydgBoHYRO2eGgjoYBBNzq9zn0NwS+lR8cW+ty5QRySkuZXecaDBoH+BS58Qf1ii1Fn278S2cmdheNP4WlxoZ88t+tlyon1FwWrPO0vLCS0cr7NN4hRDx5n58Jr2NotwgaTKSt3cBl97oSMKnYyg6t71JGdevpK2/Cw/3Ej0w8lVZ7Dd7YHT0DOSRqN508Q5mjF8Ek1JP8XDCAd5VlPJT3yl08Ay0aTvySksYs/E3dILooaTO9+bp2F0oAWPh9dFmlKkfUzoGUv7Y/fVAYpXXv8Fk5PcLokFQYzIwMTcetx5T61Xnj3vjuZQlJpMa09qXQc29azijYRgLs0n47BYyV70nbXPrdx/hr+1E7erTqHXXxHtdR/N5j/HS+rfR+3ip01QchjwubUtf+iopvz2IYM5K6ekoejVl29ggCOCksbyDc/UKPtxy0eZ1yNSeSFdvhgWKnj1n89I5FdmHyPdP4dR2GAAqTHxU8CljS7bywqoz1+z99cVQq2Rvztn8dSyZN9ef55nLnSk1+z51TFrO3pg0/jyWzJS5hzEY6x8B0BgUlxqkCBVnL4smW/+sWHI2f0NZVkKjt0GhtiP0mX/QRIrhwN5CHsO338+pk2L/xd4c9aAzyob5G51AV3vWa/vzkeP9AISViP3pMpORxKLcepVpKtWR9NUkik5tQCizGN1LUaNoMQjf2z8mcvYZfMa/hkKhYLI5e7lJEFiZcLphX0imVuiSTqJPrNzpoFRpj15pf41bJCNzY9AosWVDhw4lKiqqMYq+JqjVaubNm8e3337L77//jre3Nx4eHqhUKj799NrMZNYGQRAkg2CEsyee2pqNRqXmMFE7lbKCYVPlLA4SBX0RptKSSs+1psxo4lhy1cLA1lpMJRf31FieTEU2nM/AaE4FPKaVX4PKss6eqSwr5q+7u3JbBzHUp6TMxNhf9rPxfEadyx0T3BpXjfhyXRx3nNIrZtUVag0+E97A+43j+E79QPJCBSg8sY742YOIe6cP+pTz9fla14S3RkbhZq8GH0s41hsdh0n3jsIqe7KpzPazj0aTiTu2zedigfn3KXHmyWZjUGnFRDGyQfDGItjdgdGtRDH9i5lF7LhU+e+3LukcySWiZ92wzIuEdZ2I0t650mOrI19XxtsbxbBjhQI+GGsbHSNBEBAMZZj0xRiLcjHkZ1CWk0zxhT1c+r/uFJ1cLx6o0uB/z3cEPvhbk8k0/kzbAfw58C7szNkml8af5D6fNtjd+an4TwJyd/xG/KejMRblSgbBXF2Z9Ey2FUaT5ZlpUGj4bPslknJrfv/KNB6PRFk0O388vxeNVyihL27Ac/hTgGgUnF34BW6n/mLt2fSqirEp3byD8bE3JwdzyaE8tWOu0pV/teXGrVwGl+4HYHtMFi+vOVtZUdeN2GzLda2zt0xC9s+ORSjTk/TtVEpibRPOWR1KrRPNXlxHrk8nAHxN2eR9NRp9eiwOavFe15lkD8EbnQBXMQz9D4db2e4/mdCSXGnf6dgjVZxVPfqkk5LHu8o9kD8db2Gm6xtMa7GcVq9twXvMC2gDLe/YyWEdpOWlcTdGZMzNgDakAxGv77rqk+jQjAz7xs9oLiNzI1Jvg2BaWhojRozAxcWFFi1aMGXKFD788EM2b95Mbm6uDZt4/Zg5cybJyckcOnSI8+fPs2jRIuztm87swqWCLHLNxrsuXrV7yJV7CNpdoV2lcrF4jdTGyHAmrUDSoKvMX9KhWU9pcFV8QTYI1pW1VuHCY9v4VnNkzSisPARN+kI0KiWL7urC1I6iJ5vOYGLcbwf491zdBjcOag2TzLqV2fpiNiRHV3qc0sEV77Ev0/yTWALu/wk7vxbSvpKYfcTNHoj+8pm6fq1rgo+zlun9XMA5FwBnwbWCVqdCY3keCLUwpNeVlw6tZv1ls8G0TINLWkdeH9oKtbMocG0syrZ5nTKNy4M9Q6XlX/ZX7hXzi1W48G0pJ/EY+GClx9XEx1tjyCwSPd3u6xZC+wDXOpchGMooiTlA1r9fkPTNVKKfCebsfUrOzrDj3MNOnH/Mg+gnfbnwTBBx7/alLOMSAGr3AMJf2Ybn0JkoFApSi/M5lJkofa4ntzfrxLrhD+KiEQeNO9Iu0Scnj513/Qh24sRa8ZktxL7bh0iFaIwXBMgtsa3nkMloCV0rQ43OYOK1dY2vTydTNeND2uJrNr4viTtBtr4YhUKB3/Qv8Bz1PABKBN4r/Ip/536EwcZG4spQKpSMDmolrqgMvDc5kA0P92LfU/0YN+M16bhPvPdKmpefbb/En0cvV1bcdSEm0yxvoTCRYhLDN4McXGht7oqWxOwn9v+6k/Tt7ZSmNa6nrMrBhc5vbuaivSif4FGaxrl3B2Fv7s3q5JDhGx57jQp3Bw0oFHzn+QhRfs2kfYdWza6XlJEu3hIJk97rWd5xfJgddt0Z0ias0sixdh7+tHAVx1abky+Qoy+uxzeRkZGRaXzqbRB87733yM/P58cff6SoqIjLly/zxhtvMGzYMDw9PTl7tmnNTtYXjUZD586dCQ8Pv95NuQrrcOGu3jWHCwOUGsXOq52q4stLbW0QrEXY8KHEvGr3q5zc0QaJIu66uEOYypqepk1TxWQSJP1AdwcNvcPqlwm4HGvPIpNZx0SjUrJgemfu7CwakvUGExN+P8jas3UT057WzJIw5p1jGyk2VC28r7Szx2PQQ0R+cJbgJ5aiDRYNa8a8NOI+GIwu6VSd6r5WXFBajJWFSUFsirbcH0org2BKdh5/Hr3M5TzbGAZ3pcXy2Wlzkh+TAhLa8XL/tng62qEyGwQNsofgDcfYNn74uYiGqKXHU8gprnjPJBfnsSZJvOaCS3IZ4OSGfbPuda7HYDTx7e44AOzVSt4eVXuv/ZKYA6QtfoW49wdybqYbsW/3JG3hs+QfXIIhp2Yjg0PLfjR764jkKb7xcjRBi9+h+6ovpc/1ZkhgC3aOeZwAB9FImqEr4tHE8zw8+k1i/UXjS2nyWR47+gAtDbEAZBfbNrGItYego1Z8lsw9lMSra882aTmFmxk7lZoHWvQAQG80MPei6LWmUCjwu+NjvG6ZJR37aMpn7Pjri2vSrrFWWUrzNWkMj/KhZ5gHrXsMQ2vWbFbF7mTOUEukyIzFxzmZUnUkx7XkUrbZGOKYR6kgGtZHh7Qh9NnV2AW0ko7LP7CYi6+0JmXekxgaMbmHg6sn6odXcl4VDoAmLwFlVhwAJbJB8KYg0OwleLnAQPfxFsP5JaNAwmdjpf5wbdHFWzwLtxZbnDDKvf6vxDps2CCY+EcOG250XneLYIp3G/qt+eaqT7GqoOYCZGT+o9TbIHjo0CHeeustpk2bhqenJz/99BMXL16kc+fOvPnmm/j7+9dciEyDqGAQrIV+IFhChjVXeAgqHS1Gp9oYGQ4kVC+IDxYdQcFQii7ucK3aJyMma8koFAeeI6N8qs1EWhsUajtp2aS3dIDUKiVz7+zE9C4Wo+DE3w9xJrX2L83BAZEEOooD6gOZiUzdOq/m9ihVuHa/jfDXd0vXiDE/nYRPRtUqXP1acionhY3lno96B8jz4dmVp0kv0LPiZAqvWIVlHYhJ4c75R2j+/hZO1+F/WBVfn9llWUlpga/Km6f7i7Pc5QbB2ob4yzQdNCol93UTM2zqDCYWH6+YuXp+zBGMZmPQpJRTeA58sF66tfvic8gxe7RN6RhIsHvtQnYLjvxD7Du9yFrzAcXnd1zl+apy8sShZT+c2g7DucNonDuPx6Xbbbj2vAO3PnfjN/0Lwl/ejNpd7AOkFOdz/66/MDVBA1dHz0COTXiWuyO7Stt252Vwa+txfN1xEjqlGsfSHD4s+AyFYOLzHZdsahQ0WYnbT+0SIi3P3nyR2+cdJs/GHokytePBlj2k5S/O7ORykTgBqlAo8J38PoYhL0v72x58j8xD/zR6m0YERqFSiH2BtUkWL1KFQoHHkEel9YFZq3nIrH1bXGrk/j+PNXrbakO5jinOFq/2UUFROEb2JPK9kwTc/zNqd7P+rtFAzqZviH42hKRvpjZaYrrRXaKY1+U7LqrEe09bKnox6uWQ4ZuCAFdxkiWnpIwQV0tG7ARHd3TxR0iZ90SdyiuJMxsElSr+TBXHTFq1ksHNvao85zarsOFl8U1z0vtm4rzGgfOayuWzHI0uOJnqHiUhI/NfoN6Whvz8fAIDxZe3VqulpKSE0NBQ/vrrL9asWYOHR8O8mmRqpj6dFncHUSMlrVAvaRWZyvTk7/9TOkbl6Fbpudbk1GKg4tiyv7RceHxtXZv6n+V8usVoNzCy6o5GbRAEgcx/3pXW1S4VZzLVKiV/3NmZe7qJBuVSo4kvd16qdflqpYqFA6fjZDY6rkk6y4ns5BrOElE5uBL6wnocIkXNJkPO5SZnOI4vtBi+Q5QhgIIzaYX4/d8GJv5+kICtr0v701Tib6UzmHhv04UG13252MoLN8+bp/pH4KwVRc813uHSrtztvzS4LplrSytfi9dueUhvObEFlgFz39wE3PpMr1cd0RmWDNS1zVIumEykL31VjI81YxfYGvcBMwiY8SuRs8/S8psMIl7bSdhLGwl9fi2hz6wk5MmlBD+2iKBH5uI14mlpEmJVwmk6rPi0wrX8TJv+PN92YL2+U2Pg6+DC3AF3sm30TFq7ic9Hg2DiB48IJvZ+mH3uobQ0xtPVcIbv98TT7L3NvL/pAkX6hhsNvO0tA5ec3AP8OrWjlHRmyfEUuny+g4MJuQ2uR6ZuRLp6SyG68YU59F37DRfyxNBxhUJBh3s/YFvzx6Tjo9d82+htctc6SNIwZ3LTMAmWpCFufe4Cc0KM1ONbWX3G4ll3OU+H6RqENdeEuvzCVlravSJBNJAoVGo8Bj1I848u4Dv5fZRmr12MZeQfXELClxMQTLZPkqJQKHh3cj8edn+PTIUbxeYsw4rr/++SsQEtvJ2k5dVnU6RlQSV6Dubv/6tOE6qm4lwAVA5uxBWIkzmtfJ1xtFNXeU4XryD8zDreR7ObTgj/zUxUWTG7xj5x1adtYV8i9Z2ud/NkZJokDXI9KvdaCAwMJCkpCYAWLVqQkZFBWlrjufrLiAy00sSQdMZqoDyZhCDAgiPiyyl7/WeUpopeUE5thmIf3rXK88uJ9HKq8RjnjqPBLNxecHh5rdonAwV6i9eIh9mAW1/yds+l4NAyANRu/ngMe/yqY1RKBT9M7iAZixccuUxxae0HuwP9I/mk+y3S+s/R+2t9rsrBBff+90nrja0dVFc6W2lzhvgbKmhv3qP7h1GluwEoUruiHvK8tO+vY5eJzWqYXkxv3zDLilMeIVYeXu797pOW0/58gZLYpmVIlame5acsg5PhLStm3g3SWn7ngsB2kl5kXSkuszxH3Gr5HCk8sQ79ZTGsyT6sM1HfZtF89hkCZ/yCx4AH0Aa2QqGsudtQYijj8b3LGL/5dzL1omEy1Mmd/bc8xec9J/BJj3H1+EaNy0D/SI5NeI7ZXcdI2UYTNA7M6DSF+zpOoZ3jQUAgT2fgtXXniJy9he/3xDXI2PLgwPtRmw0dv+h03BaYx5oHe+JlTmRyKauYvt/s4vPtMXII8TXmp76TiXIT7834whz6rf2Wo1ZRGd3ueYdkpbjfMW47pmugDxZknqw1Ciay9RZDhsrBVdLmLU09R0qemODK30XLn3d3Qamsu4exrZlmjkQgIxS1Sby+58ccYd5Fy7tLqXXEe9wrNP/kEt4T3kDlJiZU0106QN6e+Y3Srjb+Lix6bDQ7fccR7+AOgKZIYOvFmqVzZJo25RPdAF8etYT79vUQryuhTEfR2W21Lk/jLfbJjEXZBDuI79eanCMUCgXhzqKDTGpJQQVDvoyMjExTod4GQQcHy6ClX79+zJkzB0EQyMjIICMjA71e1oxrbIYENkdjNritS6qdEPn0LkHluT6YeygRffolMv55R9yg0uB/9ze1Ck9r6VOzQVDt7IVjK9ETRJ98Bn1q5UknZCpSaOV5Uu4RVh9KM2JJnfektB4w47cKWpHWOGhU3NFJ9PgtKjWyK7ZuySruiuwqCfTPizlcrZbglWh8Iy1tTo+pU72NTaCjGxHOonfVibzLfHtbW7wcNdzpHseLxXPEgxQKWj+zmDduH8aH5iyuJgE+3d6w7zI8sKVlxTMZR41KWnVs2RevsWLYmmAoJenbqRiLchtUn8y1IV9Xxr/mrN6hHg50D3GvsD+g2OKVmh5Y/6zAxaUWg6D1tVMdWWs/kpZ9p8xG5Vw7z0JrTmQn023VF3x3zpJM6vaIThyf8Dw9fEKrOfP6Y6dSM6vDEE7d+gLDAi3Jjw56hDInqhke7Y+g9EwBhZG0Aj2P/X2SyXMPVXhm14Vw/0gmOYpegll2Tvy4cjajWvly7PmBkldnmVHguX/OMP63g2QXyyHE14pgJ3d2jnlckmNJ1xXSf+23/Bq9H0EQ6B7qwXH3fgDYmfRc2re60dvka6UHnK6rKEuRpBHDXp2FEnxN2Yxv68eJFwYyMLLyd/61pluIOz1C3cGgxZBoebc9tncZF/MrGt/Uzl74Tnqb4MeXSNvSl8zCWNI4GmCDm3szetQAypRif8urRM+tvx/kRHLT0F+UqR+9wjzoFCh6m0YXW4z5w1tYMokXnVxX6/I03hHSchuNKK2UXqCvcbKmXKe2zGQkS04sIiMj0wSpt0Fw//79tG4tDlZmzJjBvn37CAsLo3Xr1jRv3pyQkJAaSpBpKC4ae/r7iS+oc3npxBXUbMQJdndgaHOxg3g2NZ/o7+6TNKK8Rj6LNrBVdadLtPRxrvkgwLXLRGlZ9hKsHYVW3nnOdrUbyF+JYDJy+ad7MJkHDR5DZuLScXS154yMsngqbb5Qt9lxZ42W6eYEI3mlOhbHHq/1uXa+zaXlpuYhCNDXLxyAQoOers01pD7fif/LeB+lIBpcfG79P5zbjwTgkd5huNqLg4rfDiSQUVj/iZGhAS3wVpvD911ySC7NqLDf97Z3pbD8soxLJP/6gOxFdAOw5ky6lKF9coeAqyZgfDMshuRU99ppw1ZGiZWHoEMtDILFMfspPi8msdGGdMCp3Yg61WcSTHx5eic9Vn/FmVwxQsBZrWVOv9tZNHA67traaRg2BSJdvdkw4mEWDZxOa6v4wRyhEFNgNNq2B8E3FlSlLD+ZSt+vdxOfXb+B3qyhlgzSP6Il//g6gt0d2Pxob94c3lKawFt9Jo1JC09LOsAyjY+PvTNbRz/KYH9x0qrIUMqDu5cwacsfZOqL8Oph6d+c3/ZnVcXYDD8HS78rrcQiLRKdUcjqTHdp/cs+albc3x0fZ22jt6kuPN43XFwo8CZKJRrcCw16pm1fQGkliTycovrj2vMOAAy5KWSunt1obbvkbDGchhbnka8zMPrn/STkyAacGxWFQsHMPuGAAM7iRJubnT39utwiyVoUnlhf6/LsfCwGweZKsY+sM5gospp8q4xynW2A5GLZyCwjI9P0qLdBUKlUolKJgwxvb28OHDjAXXfdxaOPPsqGDRvqJYIuU3fKdW4A1l+unZdguRv97br1qGJ3AmDn1xyfW/9X63qjrDwEqzNBuHS9VVqWDYK1o9AqZNilnh6CWWs/piRaTEph598Svzs+qfGcQc29Jf2quhoEAR6Ossy6/nh+X63P03iFgEoMIWpqHoIA/XwtncCdKRdJ+u52DHmiyLlzh9F4j7foCLo5aJjZOxyAkjIT3+yKq3e9KqWSXo4dpfW/Uw9U2K9QqQmauQiVi2jILTi8nOyNX9W7Pplrw5ITFo3NKR0Dr9rvnXBMWk62d6l3PdYhw461mFjIWvuxpQ1jXqrTO/xIZhK9V3/NMwdWojcP7Lt7h3B0wrPc26L7DdkfUCgU3NGsM4eH3sfPx5fSNztW2qdHD74JELUf3NI5kZJP9y93sutS3bN+d/YNZ7CzOwCXnLz4a+V7lOWmoFYpeWtUFJse6Y2/OSv1qfRiPt9Re41XmYbjorFn7fAHeaJ1X2nbioRTtF/xKZrObclXiH0hz7jNlJbaNgv1lVTwEDQbBA1GE/cuOka0wiJvMcIjp0nec1M7BuLtJBpi4s4EEOUqanYezEzk0b1/S88Oa/xu/xCFnTiZkL3+U0rTG+f6j1FZjKddzZNvyfk6Rv283+bZxWWuHdO6BOHkogeN+Bv2922GxsFFSmhXmnYBY0ntjHQaX4tMU6iQLi2n1zDxW9EgmFfNkTIyMjLXh4alL7UiLCyM999/n3fffRc/Pz9bFStTA6ODLQbBdUm10xGc2D6AFsp0ni/6XdygUBD44O8otZVnZqoMLye7WunbaTyDsY/oDkBJzH7KZFHdGqngIVgPg2Bx9G7Sl70prihVBD0yv1a/rbuDhm7m8MUjl/Pq3Anu7BVEd2/RM3hfRnytk4solCpp5rU0vel6CAJsObpG8qLSeIcT9Mj8qzTVnh4QIWkNfrM7tkHJB5qpIqBUHKjszDzP2dyK2qwazyCCHl1AuRtR2p8vUBxTew1HmWtLod7AurPiQCLE3Z6eoe4V9guCgOuFnajMOkOJDTAw1CVkWJ96gYLDotaoxisU1x5Ta1VHfqmOJ/ctp/vqLzmQmQiAAgWvdhjK7rFP0Ny1aYQrNgSHkPYMcffhpxPLWHFwDvcGtcTOLNWB0gQhZ8E3joxCPUN+2Mtv+xPqXMfLvSdLyz+7BBH3Tm90SaKW45AW3mx8pJeUlOGtDecbrE8qUzfs1Rq+7jWR9SMewt+cICCtpIC79i7k9XZTKFGqcTPl89fSRY3ajvLkBABpZu//T7bFsC8+h4tqSzi+LqlpZjO116h4sKfYTn2ZgrHOg9Ca9Tp/v3CQPmu+lpK3lKPxCsV7jEUeI+3PFxqlbResPC4HGhJo6y/+r8+mFTL+1wMVPK5lbhyctWq6RFncFpzLxHeSNridtK00uXbOFHZWIcOBBkvm6/TC6t/TsoegzM3IiZwU+q35psJnVlR3vg+tv9SNzPXDZgZBmetDG3c/QpzcAdiccoH8Ul2N5zhr1byn+htHxFmt3K4P49iyX53qVSgUtdIRBHDtagmrydu3sE71/Bex9hB01tYtZLgk/igJn48Fo6g15TPhTRyada/1+QObiQkMBAF2XaqbjiDAjBY9pOW5F2uX6EIwmVBqRc8HU1EOxqKcGs64trRx98Pd7KGwpygfIwoUGi3BTyytVGMtwNWee7uLXrjZxWUsPFp/I7jeIECmaGQVgI9PbbvqGOd2w/Ee/4a4YjSQ/Mv99a5PpnH5ZX8COnPI522VhAuXpkajKMzEVy8OTuMbcC+UlFlCSx001b/qs9Z+LGUW9hz5LAp1zZM9JsHEuE2/8c3Z3ZjM53byDGTP2Cd4r+toSd/2ZsC9/wMAtCjKYnbyERKmvs4jVh7R+MaDRwplRoEZi4+zrY4JCUYERdHORXz2HnQPYY7Wk0uvdyDp29spuXSQdgGuPD9QDFstKTPx0uoztvliMnViZFAUJ299gUlh7aVtm728eKflUABSds4nX9d4Oo++V4QM5xSX8r9/o9EIZUQZLYZofRM1CAI82jtMikSYvyeH2e0n4mh+3hzJukyXf75gfkzFvoPXmBdRe4rvwYLDyym+WPsIhNpyscByz/pmxrBmchBBbvYA7I7L4b1NF2xep8y1Qe1q8crbcdJESr4OrZU+rz7lbK3KsfYQjExaS0uD6DX+w564ahPxBTu6S8uxtZB2kqk/OoOJ4lIj/b7eddXndLo8kWYr2nsE0MEj4KrtcY4uxDvUTlJMpmkhGwRvcBQKBbeGijNdRYbSSg0GldFCEL23DChZ4HNfvepu7Ve7cDbXHlMkD6bMVe9hyE+v4Yz/NvXVgdMnnyXh4xGYzCEJzp3G4T3u1dqfbzCy8rRl1tPTsW4ZjgVBYHWSZaBam4glQRBIW/Q8ungxA5zS3kXSdmkqKBVKhgSIOocZWmd2eEXgM+F/OERUno1bEAQScy0ZIA0NyEJqNAmQ4w8G0YtiZcJpDKarPRW8Rj4LCvFxbtI1jvC6TMOIzijk1bWWgcc9Xa/W2S06tYFkrQtpZgO5h139dfeEasUcLJRmxpO7S/QWVzp54DHwwRrOEPntwkF2pInhe64ae77sOYGD456ml3V27JsEt153oDSHb+ds/RGnC7v5oc9kvu1lmezyCs2gXEBjwZG6TQIoFAre6GrReH2/xRC+D+1B3oHFxL7Vg7j3BvCC71mCnMXnwPJTqaTm1zz5J2N7vO2dWDr4Hn7vdzvOatF7e41vazI1jrTVn2X1mbQaSqg/jirLO1lvNBAXc45H8/9gU/YM3iv4XNqnMmcjboqEeTpyWwdxIJleWMrbf+fwU+f7aW8eXBYa9Ny9YxH37FhEQZl4jSu1jvhOelsqo/CY7RO4+FiFYz/Vdjy5Cx9k/QNdpH7MjnrIAchcf0yCieN5ovc6ZXYkpysZ8v1e8vOtQncVtZu8Urt44xDZEwCtLpsFuS8xUr+LPw4l0fmzHRxIqHwCrzxbOUB0fkalx8jUnpQ5M4l9t1+lH7WhBGMVY6i2vo60D3CtdJ9M3fi+z23sGvvEVZ/wYnn8caMiGwRvAl5sNwh7c9jFZ6e3k1ILl3Q3L1G7RY2JjdGZ9TJClWfvqgk7v+Z4DHoEAFNxHumLZ9W5rv8SLvaWMGFrb8HqKE2LIf7DoRjNs9yObYYQ/PhiFKrahxx/vv0S0RlFAAyK9KJvRN0yjP50fh+rE0WDR5CjG690GFrjOZn/vEv2hi/EFbMmnlJbO8/Ta8lDwVHS8vzQnngOf7LKY1edTmP9ObHT18zLkfu71z/Bkp1KCYIKCsXfIltfzL6Mq0MSCw4vB3OYaW3DPWWuHWVGE3ctOCp57T03sBmdg68etBeeWMdfgR0xmY2797WovXfvlTjZWe794mrC3TL/eQ/M2l1eo55HaV/z7G6mroiXD62R1tcOn8FTbfqjvom8Aq1ROXngN/0Laf3yL/dhyM/gsdZ9GRogJkfIMubi4Cp6IKw/l17nd+qU8I683XmktP5NRF8+aD4IE1AcvZP0b29jQd5LRBiSMJoE5h1OavD3kqkfCoWC+1p05/l2AwAwKFWs8m9DmDGZVUcaTwdXbzUZpDv0N9pPO/FIyRK8hVxpu31YF/zv+a7R2mALfprSkX7m/kVuSRkPzrvAy2GTmdmqt3TMvJjDdF75OQfN7zvnTrdI+4rObrF5m/7XaTjuGtEj8LB7MHe4hMGuDwhwEbcl5JRUd7pME+V8XgbZ5sy+zkZPQMG59EL2bLJomju26FPr8kKeWiHpDzqi57OCj3iuaA4X0/Pp8/Vu/rf+PAZjxcRPwU5uUmh8TIFsWG4ouqST6BNPVLqvVGmPQeXArif7XfVZc097vp/c4Rq3VkbmxkA2CN4EhDi781RrMeS32FDGM/tX1jgY0bhaZqwKstM5m1ZYzdGV0zmo9rPQvpPfQ+UshkTl7vy9UUI+bhac7awNgjXrz5VlJxH/0VAMuSkAODTvQ+jTK1Ha2de6TpNJ4Pu98QColQp+mNyhTqLk0XkZPHfwH2n9j/534FmDbmHWhi/JKNc6VCgIemguLp3G1rrOa0mno8uJLBKNrfvcAjldVPksWEmZkWdWnpbWv5jQFvtaZHitCo3K/BsUeEnbVideHS6Yu/sPadm97z31rk+mcXh/0wUOJuYC0NbfhfdGX53N3VRaQva5HfwdIIYj2qvUFULw64q1bmBxFVkQSzPiJO9AlZNntYZua2YdWiMNsh5o0YO+fhE1nHHj497/fly6TQLAmJdG8m8PIggC91sZbf1CRA+RpDxdnd+pCoWCNzoN59teE1Eg3vfzg7vyRtdplJkNxD45p1ia+wz3lKzk9/3xclbx68z9LbpT/pZc5t8OBQKXzhxskG5sdZSUWL13Us9LYf6lqDnmN5rw13YR8dYh7HzCG6V+W+HuoGHDI70Y10bUG9cZTNw1/wTGpOYs7H+X5BkdU5BFnzXfMGPXYo7pS9CGikm2SmIPYtLVvc9aHe08Atgx5nH8zf2mcy6+jM3KZqBKTOZ1OU8neuzL3FDsTo+Tlp/v3plmXo5EGJLoUHgIAJV3BBqf2r+/1O7+hL+yFY8hM6VtM0qW8UP+Wzgb8nl7Y/RViWiUCiURZnmZi/lZ8nPbBmhDOhDx+q6rPkmOkWTYB9VcgIyMTAVkg+BNwqwOQyQDzOK443xwsvoZVLWzxcDgLuSz7lzdw3g71tJDEEDl7Inv5Pel9dR5TyCYTNWc8d/FWjewoIaBhSEvjfgPh1KWKRrz7MM6E/rcmlp5+Viz/VKWNAM+trUvUb61P7/MZOSuHQspNojaSc+2HcDQwBZVt7kgk6RvbydtwTPSNv+7v8Wt9511avO1wlicR+7WH7gr6ai0rceCP7lv0VGWHE8mr8SiGfXx1hhis0VDyZjWvtzSpmEJlsqTk1DggcpsoF2TWFHvpjQjjuJz2wGxk2Qf2hGZpsOBhBzeMetPaVQK5k/rXKmROP/g36z3CCXHTnyO3xHRCS/7+nvLWmcWrsogmLnK4h3oOfp5VA41P9P3psfx6wVxkOypdeTDbk3TiG9rFAoFAff/hNrdHNp49B9yt/3MxLB2uJo9i9JUiaAQ/9f/nq+fNMZjrfuyYOA01GYj4AqXAF6ZMBshRLyv7Snl5aJfefnC0+w/crS6omQamTBnTwaajW+XnLw45+xLhC6G9fX87Wsidcv30rKdyYjGtzkfOd7PYM85/BrxBo4t+zbJ7MKV4aBRsey+blKSEYCf9iXw1tJsFvR8iP7mSQaDYOK3CwfovupLboscyjL/dpQIUBy9y+Ztau8ZwO7xzxJq9nROcPRgs3ciPuoEDCaBtILqs8nKND12p1myw48Na8GWR3vzpOkflGZ5h4WOE+pcpkJtR8C93xHwwC+SxE3fsmMsznuOKEMsmy9k0vPLXZxLsxjwm7uKY678Mh1ZelnLTubmxc6kqzScO/vrsaTMmVlzATLXBdkgeJPgoXVk/oA7UZo7g68dXs8/CaerPF7lbMn+6G4qqJdB0M1BQzOv2mcmdh84A/uIbgDo4g6Tt3tunev8L+BilVm4sIqBPICxMJv4j0dQmhoNgF1ga0Jf+BeVOclMXZh7yBJ+dl8dQlxNgomXDq7moDnDaDt3f97vMrrK4wuOriLmtXbkH1gsbfOd/D6eQ5vmS6K41MDa32djKslnXNoZ7A3i76FzSuGPI3FMnXsY7zf/ZfB3e3hvUzSzN4uGHzuVki8mtG3w4MxObX5EmzS0cxUTlZzKTSW+0CJMnbdnvrQsewc2LYr0Bu5acFTyLHlnVCs6XeFZrU+NJvGrSST/dDeLgjpJ2x9v3bdBdTtZGwQrCRkuzYgld9ccwOwdOKxm70CDycjMvcuk9Q+6jsG7AUbLGw21sxeBD1m8cVMXPkPe/Ke5zcUdgBJTKbiKIWH/nq+/VtSdzTqzatgDOJg149blpjOz94MYhjyDYDYUdjecxv7bfmRv+UH2OLmOTAxqIy1v9G5OK2Msy06kVnNG/cg/vIKc05ukdb9BD9H8w/MscZ9MrtKV3EZMZtJYqFVKfp7akfnTOkv9nvMZRUz46QS32I/gvS6jK0QaHBcUvNFqJIP7PMKzxzdzLtf2htdmLl6sGTqTVibx/5mudaYk8jwq+2wScuWw4RuNcg9BR7WGTl5BBJLDyKLNAOQoXPi4qA9LT6TUq2yPgTMIe3UHavdAAIKNaSzMe4nB+v1czCyi51e7WHdW1BSNdLGMuWIK6pZ0SkbmRkGvtKdUWXl0miH5NLqkk9e4RTK1RTYI3kSMDm7Nx91EnRUBgenbF3Iyu/IXncrq5eQh5LPzUnatwlOvpLY6ggAKpQr/u76S1tOXvGLzsI+bAWdtzSHDJl0h8Z+OlnQ0ND7NCHtpE2qrUPDaUqQ3sPSEmGTGy1HDmNa182orKNNx25a5fHFmJwB2ShULBk7DvpIMpcaSAi7/fD+JX4zHmCd2kFSuvoQ8vQLvca/Uuc2NTW5JGW+sO0fk22txPfgTABqTCVW2+b5RmsBNHPAbTALbYrJ4fd15KYPsC4Oa0cKn4Zm2NEqLQbGnR3NpudxLUBAEi2FdocSt9/QG1ynTMPSpF4j/aATRTwVw4KXOPBT7Fk8VzedJ95M828Pima1PPkvq/KeIebUtBYeXc8rFjxOu4sCip3cI3bzrrz0JFT0EiyqZWMhc9b5FO3D0C6gcak4StS7pHMezxWdFT59QZrSsf0jzjYpzu+F4jngGAKG0hJytPzB802fS/jCPk/gYs9gek0VJNdqNNTEquBWbRj4iZTjfmR7H3S5BOL+4iQS1GBJlZywh9Y+ZJHw8krLs+mczl6k/o/1boDIbaTf6tCTKEMvqs2noDfX/7a/EkJtKyu8PUWql0eka3BaFUom7vfi+tfZUv9GY3jWY488PpHeYBwBlRoGX15xj615HDo1+kbn976S3jyVZUYHanl8MAm2Wf8yHJ7bY3CAe4ODCrimv06VEnHgr1NihjDjOmoRzNq1HpnFJLyngQr5ofOvhHYpGqSLr38/BKN4rCxzGUaKw55U1Zyk11C9iyTGyJ83eOoxDC3ECz17Q82XBB4zXbSFfZ+CWXw/w+fYYmrtY3v0X82UdQZmbkwz7IJIcIysN51YHtr3ezZOpBtkgeJPxbNsB3Ndc9MIrNOgZtfFnLuRd7amgsgoZ9jLlUmo0sS++8gxZ1VEXHUEAx+a9ce0lhoYa8lLJ+veLOtd5s+NsV3PIcOa6T9BdEsP2lE4ehL28GY1HYL3qW3UmTUpeMq1LsMUrrRp0hjLGbfqNFQmnxDYoFHzf+zY6eF7dBsGgJ/GL8eSZvZEAXLpPJvL907h0qXu4RmMydu5Jmr+/GZ83/+XdTRfomLsbH0G8L076DOPrUZOkYzu30fHioEja+FU0/AW72fPq0KpDpuuC9W/RydWic7Pc/H/XxR2mNE30SnRuPxK1u79N6pWpH4a8NOI/GEzR6Y0Y8lLxyz3FWP0OHilZzKMXX+PiE97Evt2bi7NaE/NKG7I3fi0Z5X5pPkgq53GzJmxDsNYQTC+sGOqmiz9m8Q509sJj2BO1KnNtkmVA/FbnkSgV/80uhO+U2bgPehiF2VjXIT+FZkXiIC/BScXfBY/xYfa7rF+7vEHGij5+4WwfPRN/s7H2RF4qk2KO8c/IP5lrP146ruj0RuLe7UNp2sUGfCuZ+uBp58gg/0hADBt21ORAcS4bo23nBZS59iOMBZmUWmVD1SrFiUN3B/FvZlHpDe0pGuHlyI7H+/B/I1pSPg+26UImQ787wADP1uy55UmOTXiOafmXcTSI+mwCArMOr2Xcpt9ILs6rpvS64+Xqw4axT9I3W5RjKVMpef/CUl4/vI4yk+2MvTKNxwFz5ApAX99wTPoicrf9CIDCzpH09vcCEJNVzPKT9fMSBLOu4KwtuA+YAYAKI+8VfU2kIQGTAM/9cwZdkZ10/IKYI5QaG0dnVEZGRqY+/Dd78zcxCoWCH/pMpq9vOADJxfkMWv/9VUZBOz+LwSKcWFCV4eNsR11pWQ8vKL+pH4A5FCpn87eYymRdFmtqFWZqtHgDeN/ySoNExHfFWsJPJ3cIqLlqk4lp2xewPfUSAF5aRzaOeJgHKvEWEgSB/D+fovjcNkA0XgY9upDgxxejtvJSbSok5umJySrGYA7x9MdiJL9lygzu79gaL3MIkw4dH41rw+mXBnPp1aF8PbEdT/aLYMMjvXDS1j67c3U087SES8VcFmjlJmYH35x8kdiCLEpiD0n7XbrcapM6ZeqHYDSQ9N3tGHIsnlplXKEVKJgoidlHaYrFsKa0d+H4+LfY6CaGhAc5ujElvOGZ8Nr5Wzz+FhyxtMlUquPyj3dZvAPHvFQr70CAxKJcabmXT2jVB97kKO3sCbz/R6K+zSb0hX/xGvksoYL4/xQUClDAsNJ9RC2bwoU3upG3dyGCoX4eXB08A9k55nGCHMXJtyNZl9mi3MuHbvdyr9v7ZGnFZ3ZZVgJx7w9Anyx7MV1runkHS8uFGg0PlSzhz6O289gsyxIz7WqtDFEl5j5AK7Peb57OwP6EXJvVeT1Qq5T8b2QUOx/vS7inaGyPzS5m6A97ScnX0dEzkHfzYtm29wdmxlkS061JOkvb5Z8wP+awTY2iXmGd+abVUMakiR75JoWC905spt/qryudaJdpWqis+tIqpZKCI/9IUUnu/e9jSm+Lx1JqA/UhFWo7Ah74Gc8RTwOgFIx84W4J8U9M0Uje3usun2PK1nmyUbCevO4WwRTvNvRb881Vn2Jl/vVunozMDYlsELwJ0arUrBr2gNRJtTYK5pWWsCX5Al/m5fB0+0kM7fUQ73bvhKLVPmLLEmso+Wr8XOpuRNR4heLW83ZA9BK01pOTAZ1VmJl9Fd565eEJIHolNYQD5kGESqmga3D1Hp+CIPDY3mWSh5qrxp7Nox5lSCVJRARDKWkLnkF35G8AlPbOhL+8BbfedzZZ4XNfZw1BbvaEuNtzf/cQ/jfKysVdEENKynU6rYcdEV6OPNEvgq8mtqO1X+2MK7VhVCtfKdPwilOpPNSyp7lugZ+j96NPOiUdq5WTiVxX0hbPkpK7aLzD+GjAJrp6LWWEx08w42+8xryEfWgn8WClCqc2Q/G/5zsCPzjPayaLAfnzHuMrDbuvK11D3OkZ6g6I9/ghc5bj9CWvoL8s6svaN+uB18hna11mgdXkjYtG2+A23ugo7exxbj8C/2mfEecvZo72VChQqj2kYwyJR7j8w3QuvNiMzLUfY7QyqtaW5q7ebBs9k0B78dlyviANu+YnOWTfkokun6AO6SzWlZtC3OyB6BJlnZ5ricrKU9akUHBXySr2HztOcaltBvxKc6IhjzKLhl2mrgiAyR0sXvmLjyXbpL7rTZ8ITw483Z/2AeL1HpNVzPAf95FZUIIu8SROxjKeK81mw4iHCTFrJueWlnD3jkVM3DKHNOtszA2k45hHcE9vzfMXt6Mxib/ngawkOv/zOb9E77+hvTJvdtq4W+RvTuekkrdvkbTu1ucu9EZLmLC15m59USgU+E6ZjcpVnLhtlrgGf5PoKXwwroh/ht6PkzkJyT+Jp7lt6x/oZaNgnTmvceC8pnL9ekeTK06m2ktZycjIiMgGwZsUD60jG0Y8XMEo2HHlZ3gseJOh//7IK0fWsckrglR78cEpKESvr0OZdTMK+jnXb1BYrsEEkP3v53KnygqdlZZJZdlIARxb9gPzIKT4/PZ616U3GDmeLM6otfN3qdGz7f+ObeCnaHFmXqtS88+w++lYSZhwScwBLv2vK9kbzZqRShXBTyzFPqxTvdt6Ldh0f0eS3hxOwhvD+e2OTrg7WzodgtkjQ8G1M2a6OWgY2kL0pIzJKqanSyu0KvE3+jX6AAWXLYmDtIFtKi1DpvHJP7CE7PWfAqDQaAl+4m82XzZhVKgodg6hVb+J+N3+Ic3eOUrUd9lEfZdD2Mub8Bw6k48uHSPWnCRmZFAUk23gHVjOE/0sYebf7o6j8PQmsjd8IbbTzpGgR+ajqIPxMb9MB4CzWvufDReujKIyPXGFojdxO98IWn1ykf/zfZ2j6lbSMYbsJNL/eonoZ4NJX/YmgqlumlXNXb1Z2Xe6ZAAp1RRAxAmyVFp2DZ+DQ6Q4WWDMTyd+9iBK4o7Y5svJ1IjSaoJLAOww8FDeH6w+Y5ukF0qzV7q7lUEwTScavW5p4ydNHC45nozJdHP0pXyctWx8pDctvMWkRadTC7j/2+UIpWKGVvvQTgwPasnJW5/ngRaW6ISVCadpu/xj/rp0zCbtUCgU6Drczr78W/jj8BJaFIqegUWGUh7avYRJW/6QjLMyTYtQJw+c1eIY5XR2MoUn1wOg8Q7HIbJXBW1dJzvbRHUo7RzwHP6UuGIs4xnlvwAcTMylq2co/454SGrT6sSzTNoyB1013uOCIGASTNJHRiSqrJhdY5+46tOhZACR+k7Xu3kyMjccco/+JuZKo2CJsQyBip1F17ISIosypf3jNv1GYmFurevwc7EYBOvSDXWI6Cp5uenij1IcvasOZ9/c6MqsDIJVeAiqHFyxD+8iHh93BGM99XNOJBdQap4l7WH2JqqK787u5u1jGwFxALRwwHQGmrWTyjHpi0ld9Dyx7/S2eK+pNATO+A3n9iPr1cbriUJt8YAVjBU7bVfeS43Fre0suoBbo/OYGi56AqbrCllbJA4KNd7htQ77lLEt+stnuPzL/dK6/z3fkenehqQ80XjWO9wDpVVyGJWTh/RbnctN56NT2wDRwP5Nr4k29Z6d0jFAkoJYc/gcST/dZ2nntM/Q+tdN67LcQ9DVTvYOtOZsnsXw09bDDy9nB+6693Hucv+IO90+YovjAGkCR9AXkbnyHTGpSx2JcPJg++iZhDmbPRDtiyDiOHPOZhH64kYcW/YHwFiUTfyHQymO2d/wLydTI9ahiUZHUZ/5Fv12dmzfaJPyFWYPwRBdrjQddTJHzGTsYq9mbBvREyopT8feemhBN1X8XLRserQXIe5i1sqypOPSPnuzR7ybnQO/9pvKmmEzCHQUJ7iz9MXcsX0+P57ba5N29An3ZLddF2arn2XBqTXclXRY2rci4RQdVnzKuqSzNqlLxnYoFArauIveehcKsig1T8K49hKjVKyT9jlrG+4hWI7nkJkotKIhe2TualxMhRhMAvsTcunrF8G/Ix6SPOzXJp1jotkoWFimZ296HN+f28Mju5fSc9WXOM17FdWcl6SPjIyMTGMgGwRvcsqNgsMCW+CqsaefXwTPth1AV6EXzc74s2f3d/x9aB79jOJAL7WkgFs2/UqB2ROkJtwd6h/a5jXyGWm53GtFBnQG65DhqjspTq0GiQuCieILu+tV14EEy+Che4h7lcetjD/FE/tWSOvf976NSeHtKxxTdGYLMa+1J3v9Z1J4rUNkL7ye34Z7v3vq1b7rjUJldX2Xewhe43DnCW39Ka9y+alUHo3qLe3701P0ANMGt7umbZIRMZbkk/j1JAS96CHiPvAhPAY8wJ44iy5neebMKxHD7/+WBOpf6zCU5q621dXUqlU82DMUBIGXcr/DlCvqmjl3ugX3QQ/XubxyD0E5XLgip83GGYA2bqJxZnw7f6Z3CeKEphVPOr7AF71X4DnyWTBnis1Y/iYFx9bUua4IFy+2j55JhLOnuMG+mJ1s5UyBjtAX1uHYZggApuJcEj4aLk+2XQOsPQQ9B1gmB7qf/JSc4tKGl282CDoZy2jhIGoGHs26LHkMTe1oFTZ8/OYIGy4n1MORzY/2xs9FS5QhVtquCqzY/xgT0ppTt77APZFdpW1P7V9R56iXyih/hp/URLGs1y+8kX2RH48vxVsv6tGllOQzZuOv3LV9IRlmjTqZpkFbD3FC1QjEOYq/o5s5sWFjeAgCqJw98Rj4IAB2hiKm6kQvwR0xYuKpPn7hbBjxMK4a0dC9/vJ5ghe/g+v81+mz5hse27uMn6L3cSAzUdIKlZGRkWlMZIPgfwAPrSMbRz5C3l3vsnPM48wIHczh01pijS0oVLqgEUx8fnolrc0JC07kpHD71vkYaxHS1BDjiEuXW9F4icL0BYdXUJoRV++ybib0FUKGq75FHVsNlJbLk3bUlQNmXTGo2kNQEASeP7hK8oh7u/NIHo7qZdlvKCX5t4eJ/3AoZRliohGFnSN+078k/PVdqP2j6tW2poC1QfDKpADXKsrd39WeXqFiR/ZIUh6Bah/ae4iJBPZ7hHHQLRhtkGwQvNYIgkDyL/dTmnIeAPuI7vjf/TUAO60S9fQJ96z0/IWXjrI1NQaAlq4+vNR+cKO089HeYYwr3c6Y0p0AqFx8CHzgl3o9uyUPQfNARkbkdK5Fx7V8AArw5a3tJC/6n6NhV9sX8Lv9Y3GnIHD5h2noU6PrXF+YsyfbRs/EQ2X2CtYWM2D9NxwtyCH02dU4dxgNgElXQPzHIyk8ZRtPNZnKUVp1pZ06jCLXpRkA3ctOsm31ggaXr9BapCs6mQ2CRYZSovPE6I6xrX1xNGug3Uxhw+W08HFmw8O9aC/ESdueP6TEeMX39NA68seAO5nVXjSKl5qMTN46l6wGhvR2CXbDTiX+xmuzPIh4fTdD7B1YcWguQzMuSMctuHSE1ss+YkX8qaqKkrnGtLXSEbzo5IU2qC32IaIxuaJB0HYegkCFyZ+7S/5BI5RV6Bf08g1j48iHcbMT36VZ+uKrok5UCiVt3P0Y7B8pfWRkZGQaA9kg+B/kp33xAAgKJfoQ0bDjmJ3I8s7D8bEX3dzXXT7HppQLVZZRFXXRAlSo1HgMe9J8oon8/X/Wub6bDaNJYE+cxWuvOg9Bx5b9LTqC0XX3EMwo1LPunBjq5qBR0raKZBibUy4QUyDObA4NaMHrHYdV2J+z/Vdyt/8srTu1HU7k+6fxGvEUCqVtO1nXHKv2X6+QYYCJ7S1Ghl8OJDKzlcVL8Nm248i8gY2uNyolF/ZQcGgZACoXb0KeXIpSo2VffA4/7xOzgioVlRvaSwxlvHRotbT+Xe9JkjakrQlxd+B5ncUoUTDuC9RuftWcUTmZuiJ0ZgF02UOwIhfyM6XlFlZenl5Odvxwm8WT6d4/j3Ey8i7cek8HwFSSX6/QYYBQZw/+HvAg6MXMlbnGIgas/pGE4lKCn1qOS5cJAAilxSR9PQlDvm307GSuxtpDUC+YcLrV8puadn7X8PLN4YcAbcuKpeV9GWJfzkmr5pbW4j2dkq9nkQ0zHDcVOgS60stR7IfosGPuWR0fbKm8j/pOl5EMMhtP4gtzuGXTbxSW1T+LrL1GRRdzwrWTqflcMnoS/tpOAkLa8+Xpf/jozBop4UuWvpip2+YRV5BdXZEy14i27pa+0yG3YFzN3oEA2Vbeu7Y2CNp5h+FqTp7oI+QwTbdGSuBXTg+fUDaNfIRQJ3dcNFr6+UXwROu+/NJ3CgfHPU3BXe9xeuKLbBk9U/rIyMjINAayQfA/yH6zxoxSAc3adpO2+xXnSGK3AMGO1WecrYwCfd0yZmmDLIkQBFkwlzfXn2PLRXFw6e+ipUNg1bpwKkc3lPait4CptG4z4IIg8MBfx8koFDtEk9oHoFZV/jh4//hmafmpNv2u8iwyWg00fSe/T+iL/2LnE16n9jRVyjLjpGW1mz8mwSR5G3jYOVyzdtzRKQitWU/yk20xDPFsx4Ai8f+eY+fI/VkZcra6a42VAc+122Q0XqFsis5g2A97JV3OqR0Dca4kUc/35/aQXCwm85kS3oGhlWTpthVfbjmDT5nowXbUri0hfW6rVznfnbNMOvTyCbNJ224Wgp0s78pj2RVDNm9tH8A93UQd3+JSI2N+PUCi2hLiqfEIqne9g8ODGMBQKBK104qFElrN+5kfD6bg/+hfOHe6BQCTrpDMNR/Vux6Z6ol08ZKWD2cl0X7IFArN3pvqonROpeQ3qHynKEs0QOs9f0jL/yRYkko93CtUWn5y+SmS82on+3Ij4RomesLbU8p4/Rb+79/oCrIn5aiVKhYNnE6QuQ+7LyOeCZt/rzZ5Q01MMk/KCQI8ufwkKmcvwl/ejHPbYYxNP8eqA78zIkv0+C4zGfnmbP1kXGRsS0+PAJzMk7nLA9pR0PlWQOwDl/e17dVKmnlVnrW2IXiPnSVN2j9evIjmdldrfXfzDiF+6uvkTRcjuL7uNZEZLXvSzTsEhzok/PovoTOYKC410u/rXVd9TqTYLsO4jMx/Cdkg+B/DaBI4Ye6ctvJ1xtEzQNq3KOmslO1yXEibCqFP1WFtHkorqNssrCE7SVpuyMDoZmDJ8WTe33wRAI1KwZJ7uqKtxkMQQDDrjykUdZvd/G53HKvPiEaCQFd7vry18pDTvelxUlhjO3d/bglpfXUbrAy5Di36XHONvcZEf/mMtKwNakumrgiD+fsG1cNgXl9CPBx4cZDo8aA3mPhu0d98fOQvwovF+/VgbhpPWWk8yjQ+1lmd9SnnWH4yhbG/HJDCkMa09uW3OzpddV5hmZ7ZJ7YAomfRu11GN1ob151N44vVFg25yBZtKiSCqi0lhjJpgKtRqni8dR+btfFm4JYQy7WwKuHMVft/mdqRKR3Fd61QWoJx94/iDpUGj6GPN6judQ/048XICWAQB49651Qe27CVTl/u4dzADyVx+5zN31KWm9KgumQqZ6B/M2l5W0oMSqUSjVacMLITyvhmd1yDyrcP6yRdJ62zLuFvEg0c6y+fp9ggTuoNbenDfd1DAMgpKeOhJcfrFLFxI+Az/nVp+bHiP1EYS5ky9zCZhVf3O/0dXdk48mG8zdf/lpSLTN46l9J6Tpw91T+C5uaMxxujM1l2MgWlvTMhT6/EudMteJSV8H9n1+FgNj79cmF/g7wSZWzEwSXck3gIgFKlmo8TzwFi1uq4bNGrc2gLbxxtqCFYjn1Ie0y9Ra1eJ6GEV4p/q/LYm6nf3NiYTALGKp5tHQJcaB/geo1bJCNz4yMbBP9jnE8vpMScxbZLsBtqN9HoZ1Ao+CTNIr78xhVhobUltY4GwbIcS2iL2iO4XnXeDJxIzue+P49J619PbEe/Zl5Vn1BOuTGuDqG5p1LyeX6VOGhVKGDetM54OdlVeux7Vt6Br3YcilJRySPDZNFhueFDhK9Af9nsgaFQYuffksvFFk+PIKdrZxAEmDWkOcFuot6My5mlOBtL+fLUSpzMv8lP0fv4NVrOKnqtUDm4oPEWPeXy4k8y+Y9DkmfgHZ0CWX5fdxw0V98PX53ZRaY5Ccm9zbvR0s2nUdqnNxh5cPEJfIyW0LWIiOb1KuuPiwfJMHvG3hXZhcBraAy/ERjkHyl5169OOnOVIUajUrJwehfu6BTIrbrNeJjE54h7n7vQeAReVV5dcLRT89HojnzfZ5JlY2A0ZzJzGLkgho0+okeoUKYja/XsBtUlUzn+jq60Mmsw782IR2cow9FB9Diyo4zfDyRyIaNhySZ8p8xG4xWKEhicImrUlRjL+GvRLHJ2/EZJzAE+GxkmZeRdezad3w40PKFGU8KhWXdcutwKQKApgym6f0nIKeHO+Ueu0hMEaO3uxwYrnbY1SWe5e8eiWuljX4lWreLriZaJ02dWnKZIb0CpdSTkyWW49b0HN4Oe8alinyGvVMfci4fq8S1lbIVgMpG17mPuSTqMqzkh1q8XDhBXkM2qMxbd13Ft6y6hUVv2RD1GulLUEW6btpHC05sara7/EiqFgl1P9qv08/3kDte7eTIyNxyyQfA/xtHLFpf1zkFuqN3Fwch6nygumWdORwe1ortPaKXn10SdPQRzZA/BrKJSbv39IMVmz6KHe4XySO/w2p1c7iGorN2tXFJm5M75R6TEJS8Pbs6QFpVnNj2WdZk1SWcBaO7izdTwjpUeVyHUuzKD4Q2KIAjok0XDqZ1fc5R29iQXW+6fQMdrOwvppFXzybg2qAUDo/Si11cLYym/9p0sHfP4vuU2yaooUzu0QW0B0JRk4W7MBeCR3mHMn94FO/XV90KuvoSPT20DQK1Q1nvipTYsOpJMcr4OP2OWtK0+z1ijycSnp3ZI6y+0G1jN0f9NtCo1I4JaApBcnM+RrKs13NQqJT9PbscM/UppW2bXR23WhkfbdmdyuHkgpCmDANHb/M3ikRQoRONU5pYf0WUk2KxOGQvlmnU6o4EDmQmo7EQDsUYoo9Ro4snlpxrksadycCHgPtGzdFjGRWn7iqSzpPw6g9i3e5LyjCersx7m/YLPub1kLd8u/YfYzJsrhM7ntnfEmUzgUd1SogyxHD1/gTfXnq70+M5eQawb/iBOanHSc3HccR7as0TK0FwXRrXy5dZ24iR6Up6OdzeJGoYKtYbAB3/Hc+SzTL98VDr+8wMrMFpNmMpcWwqOrKQ0NRpXg56Hy8S+W5nJyFvHNjL3kGXscUubxjMI7rhcxodOM6T19D9fRKiHQVpGRkamMWkcFXOZJsuRKwyCGk8tRhT8GGbJGvtGp/oPUutqEKzoIfjfMwiaTAJ3zj9MbLYoFN4n3IOvJ7av4SwL5SHD1DJk+IV/znAqVRwgdA9x5+1RVSejeP+ExTtwVofBqKoyOt6kBkFDzmVMJaInT7nhp4KH4BVeUuWDvcYM/ZjaKZAday/imSW2Iyl0BLe36MGh3DQ+ObUdvdHAbVv+4PD4Z/G2d6qhNJmGIAgCh0sDKL+DmhsSGDyyG7PHtqryGnj50BpyS8UwpQdb9iTCpRZewPVs26fbxVB/X5PFIFifZ+zKhNNcLDBnMw1uTRv32klJ/NcYF9KGZfEnAViVeJqu3ld7vBsO/0mgQQzb3WrXg/VHYFVn27Xh214T2ZYSI3qguqfjLwSTetmFPxwm8ETxIpTGUr5793G0U77ivu4hOFWibylTPwb6N+OH83sB2JYaw3Szx6i9Qpxo/fd8BstOpnBbh/p7hDp3GEXgjN8YcOAv3Ax68tRatnk1o0yhRGN+D6tz4phAHBP0W6EIsl96GUVUHxxb9MGl6604hNnwgrsO2Ae3w7XXneTvXYiXMZtluU8DYFyi5MQaT5w8A1C7+WEf1hnvW15B5eRBb99w/hl6P2M2/YreaOD3CwcJdnTj7S6j6lz/5xPa8u/5dErKTHy6PYb7uocQ5euMQqnE785P6e3iQ5/ow+zxDOeiSeCvec9w591f3HTREzcC2Ru/lJafH3gPc06I3vlzLx7ClNsNcGRIc2+C3BpPD3p3XDZxdv241241HUrPoks4Rt7ehbj3vatW5xeU6cgvtYyrrnVkyvVi5tITnKxCe9UoCKjkEOsbjv95RhJt54T9mm8q3d/eI4Dv66lxLdNwbp7Ru0yVnMxOYcyGXwj48y3mpK+FgAvgncD50hh2lhTzS3gvLjmJA9PhgS3p7Rte77rSKtFyqY5yDUGlgysqh6oTaNysfLb9EhujxcF2oKs9f9/brVLPoioxDwJq09lccTKF7/bEAWJGtQXTO6OpIpHIudx0lsaJg9tgRzfujuxadROsdHIUN5FBUAoXxqIXd7kKD0HBZCJ1/lOcfUBD5tqPG61NCoWCmfaWsOAPc7qQUahndtcxDDZ7qCQU5XLn9vk3nX5UU0IQBF5YdYY5iZZn1nNROj64pXWVxsD1Sef4KXofAG529g2aeKmJDeczJMN/V1dLwqG6eggKgiB5NILsHVgdY4JboTAr6v6TcHXYsC7hBCl/PCat/+YwidVn0th1KQtb4evgwne9LaHDpoBofri9FSci7yJPISagGpq7jtlLNxH67ibe2RiNwSh7q9iCgebnL4g6ggqzQdBRafEQe3rFaQrrmHjtStwH3E/zF9YzIUrU8czXOHBpysd4DH0cx6gBkmZkOQ7GYorPbCJz5dvEvtmF3F1zG1R/U8B34lsorsh0rsKEujgTfdJJik5vImvtx8S+2xdDbioAQwJb8Pfge1CZ+yjvHN/Egpgjda473NOR14aJSaDKjAJPLj9ZYTLQe9wrPN3KorH6fUYySd/dgUnWE7ym6C+fofjcdgC0oR3xazuMl9sPBsCEAL7xKBTwybg21RXTIJLzdKJOoULB1pZPS9szlr2OqbRi0h+DyUhMfibrk87xzZldPLN/JYPXfY/7gjcIXvyO9PmvsCJ7B/tUWznhsOOqT6KTK0qlbBC80TivceS8pvLkPSdyUjiZI2scX09untG7zFUcyUxi4uY5dFj5KesunyO1pIBsVRp4JYN/LDP3L2Hohp/4KtzSeXktqlc1JdbMsct1y6ZnyBd1PFQujaOj1ZQ5nVrAa+tEgWOlApbc0xV/V/tan2/SF4sp76BCxtOq+HBrjLT8/W3taeHjXOlxgiDw1P4VCIhlv9h+EHZVlC+YjBQctYTAXdlJv5EpzYiVlvUpZxFMJnL0JZZt5hB7Q0EmCZ+NJWfTN2Aykv7XS43aLk3sdmn5lDGQhUcuo1aq+LTHeGn7puQLnDYPhGRszwdbLvLZ9kvEqSzePgPdq372lRjKeHTv39L6Vz1vbVQdvkVHLZ7X3T0tBgmVk2edytmWGsO+jHgAunkHVzB6yFTE18GFXmapjaPZl3ly3/IKWmVpi19GKBU9wTPb38URjTgQffTvk5SU2S6scEpER6aYQ4fTdYUcKD3KzudHoxwkDkg1GHm98Eeyi0p5c/156R0k0zACHF1p7iLKbxzMTEJhDlFVGkulMNPLeTrmHU6qsoy6MNwcog5wJrgDAfd8Q/ir22n1fS7N3j5K8ZiPWK0dSKKyYjhkxrI3bFL/9cTOrznhr+7E59b/w33Io0T7DeGIujXxygCKlBaDaGnyWbI3fyutjw1pw7e9JkrrrxxeW6/6XxgUWSHByO9XaDVOHvMMzc26hbu8IjhxajOXf5iGUM+EJjJ1x3pi1nPITBQKBSODrCJiXDO4r1swnYMb7z18OClXWg7oMAiXLhMAKMuMp+jsVkCcfO+/9lsc5r5C878/YPTGX3hy/wq+PLOTbakxmP6jE7tFynywL6JDgOtVnzaGYjoKsoH9RiSqrJhdY5+46tPBI6Dmk2UaFdkgeBOyPyOeWzb+StdVX7Ai4VStzxuacYHWh5c0qO5VZ9I4nVp7zZpyDUNDTtJ/qrNUZjRx76KjUhKC14a1oE9E3QbrxRd2S8vWGU+rIilXNGaFejhwd7eQKo/7OXo/G5OjAQh39uDBlj2rPDZ3+y+UmQ1n2qC2aINrH+7c1HFqNUjytig4tIzU+U/S3y9C2v/m0X8pPL+LS290oujk+mvXrjYWz7IPCz5lb0waF/MzmbhljrQ90sWLFq7/PSP7teLVtaIRxVOwGAFVrr5VHv/JqW3EF+YAYthtdR63tiCzqFRaDoywZAbXJRyt7PAqeevYBml5VvshcibEGni5/WDJS/Dbc3sYu+lXcvTFlOUkU3RK/F/a+TWn71O/0DPUHRAnhl5Zc9am7fi29yQ8teJM/G8XDrA3PZ7ud8xC7Sk+9weUHWayXmzPFztiic0qtmn9/1X0JrEP42Znj2CWBlDYOfDe6FbSMf+cts1Ezc5Uy4RVC1eLDrBCpcY+rBPdbn+R/X0+ZpTnzzzq+qa0386vhU3qv944NOuOz8T/EXjv94x8bwNftv+BMZ4/0sNzEX8Hz5SOUzm6VzjvkVa9GRog/g8Si3JJL6m7xqJWreK7SZa+ztMrT3Epy+KJrVQoebqzJRx5QXBnCg4tI/mXB2T9uGuALukUebtFT1iVizduvadzuSiP8ZutsvwWeTCqVeNpBwIUlVomenydtTi2HiKtC6XFbEm+QO81X7MrLRZDFZqWrd18uSOiE9OadWZasxs73L+uOJpcKzUeLck8w7t5sTUXIHNdKFbm02/NN1d9ztvJMkZNGdkgeBNxLOsyI//9iV6rv5aSQQCEOXvwQ+/b0N3zAQdGvoz6UjeIa4c2PYpnWg3irpA23Hv5GLPPrSN7wxcY8jMa1I7Zmy/U+lj7ENGTQSjTo0+9UCFpw83MR1svcjhJ/K4dA115fVjLGs64mqIzW6RlpzZDazw+V1cGgJejpspj4gqyef7AKmn9t36346iuPAOxoTCL9CWvSuuBM36rdXKTxkAQBHamXmJ+zGHp0xC0ga0IeWo5qMT/V87m7xhwZCk9vMVB9ZGsy3zz26MYcq5OINCYxu2Ae79D4x0OQHfDaVqffJV+a76RDE6t3HzZNnom2lp4jcrUHev5+qejyqRlbUCrqw8GEgpzmH1CvFftlCq+6Dmh0Q1r1gMR1zaDLdvPbqt1GdtTY9ieegmAdu7+TAxrV8MZMhPC2vHnoOnYmSUc/r18nh6rvuLgjjmSvINb//tR2WmZN60zjnbicV/ujGXD+XSbtcPH3pkPuo6R1u/cPp90k4nAB3+Xtr2u+51gYyqlRhOvrrWtQfK/iN5oIKlIfKc3c/HEpBMNTSp7F1r7OUseZVsuZFGga9j7ocRQxl9xxwDR+Dg+pG2lxw2KFA2FXcss8hdufe9uUN1NEQeNin8e6CFlWM7MsoTha4Ovfm519bJIJ5zMqZ+BdniUD4/3DQegUG/knoVHK4Tf39uiG64asT3L/NuTbudE3p55pM57QpbzaGTSl7wqPW+9x79ODgpGbPiJOHMfiRJnSGyN3tC4CV+sM1+rlQowWvoL8/OyGLnhZ0lTONLFi+nNuvC/TsOZP2Aa+255ksw73+LMpJdYNOguFgyczoKB0xu1vTIyDcXJ5IqjqfKEi1GlRUSVlVS6T+b6IxsEbxKOZCbRb+23bDB7doH4gvm171Qu3DaLR1r1RqtS0z3Qhye6tYNCL/Tp/uguhzJv2AN8ENkRJ2MZJl0hWWs/alBbFh29TExmUc0HguRRlqNxYNiuxQT99Q5jN/5CQZmuhjNvXE4k5/PWBvF3UisV/HFnp7rpBpopOms2CCoUOLUeVO2xBqOJQr3Y+XF3qNwgaBJMzNi9mEKD6Ir/ZOt+DA5oXmWZGUtfx1iULZY5YAYOkT3q+A1sR0GZjilb5zJg3XfcvWOR9Gkozu2GE/zoAimrYdY/7/KGPkfa/2V4X0qUapzaj8Qh0uJJaSptvJeeysmD4CeWolc6cMw1gM9atSVNVwhAV69gdox5jGAn90arX0bkqf4R9HCwTJ7YVWEQfPHgakrMA4Hn2g6kuWvlWb1tSblB0F6txLllHyl8sdgcplQb3jpq8Q58s9NwlDeRPmhjMjWiE9tGz8TfrIl7sSCTERnpbPVqBgoF7n1Eg0wLH2e+mGAx5Nz35zGyrDw7G8qMlj0Y4NcMEHVFx23+DUXLfngOfxIAjaGYj0u+QikY+fNYMgcTcm1W93+R+MIcSWYjwtliEFTau6BQKBjfVvRGKjWa2BDdMOPvyoRT5Jk1yO6I6IS9uvJ3ej9z1MGg0oPiBqUKl87jKz32RifA1Z7VM3riolXT3BgvbdcEXm0QbO9pCU9riG7VR7e0pqWPaOjdHZcjZR0GcNHY82TrvgDoVWp+Cu8NQM6W70lfPEs2CjYSxdG7KDwmTmprvMPR9LufMRt/4UyuKE/kb+cOce3BpEZvaFxvTaPVb6xSKhCMZZiAz5r15/HEaMkr8Law9py49XnmD5zG/3UeyfTILvT0CcNLTgwnc4MRqe9Eh5IBlXp2/pl2UvbsbMLIPfybgPjCbMZu+pUigziYiHLzYW7/Ozk36SUeaNkDzRUJJ94Y3lIyCv28P4EzqQV4j31ZCo/M3vQNZbl17ySV+7yYBFFjqzZog9uTaO/GXZ3vYHex2IFem3SOAWu/I6W4bnqENwJlRhP3/XmUMqPYUXhzREs6BtZdw8RYlIsu9hAA9mFdUDl5VHt8npVHwpUGwbiCbD47tZ2+a75lS4r4u0W6eDG76+gqyyuJPUzOth8BUDq64ztldp2/g624kJdBr9Vf87c5w6etce0xhYD7fpTWm616i+EZokE31d6Fv0fNIvS5tWi8wqRjyrXCGguHiK7MGfYlMzpOId/shdBDl8fG/rfjY1+5NqRM/Ukr0FfwDLy1nT+fjW+LPtmsv6ZQYud3tfF8W8pFFscdB8QkNK91rNmT1xYUlYr3u5OdCqWdAw6RojasPvkMhvyajRE7Uy+xNVXUHG3r7sdt4TePFMC1oLdvOIfGPUN3szdxkUrNk+1uZU63O1F7WrIPP9gzVDIUpeTreXjJcZsZCpQKJUuH3EOkOZP1ocwkpu9YiNdt72PnL3qkd9CdYknuc0zUbeSVlUdkI0UDuFRg8Upr5uKF0cogCEi/M8Cq02kNquuPi4ek5Xubd6vyuA6BrrRWZ9DCmACAY9SAGvsKNzIdAl1ZfE9XWhpEg2CewpkH16delTjHWq+qvh6CAI52ahZO74JGJfZ+39kYzU6rJEHPtxuIm1lLcGlQJ5Ltxb5e1tqPyFz1fr3rlakcQRBIWzxLWne99S0m7VjEgUxR4zHY0Y03WkwGozhB1ugGQSsPQZVCQVGZnufajuPXUMvk+az2Q1g8+O4qI3FkZGRkrgWyQfAGJ0dfzOgNv5Bq1kEZ7B/JiQnPc3fzrqiryDzr6WjHG8NFDRWjSeDlNWdRu/riNUIUHRfKdPXurHiaw1H/OJRIYk7NXlKnnX2Z3uVO4hwr6ucdy06m1+qvOJvbsI5zU2P25oscNSde6RLsxqwhVXvgVUfRmc1SSIRTmyE1HA25JZZQBXd7DdF5Gcw+sZlu/3xBxNL3ef7gKil5gAIFv/e7HacqEoQIJhOp856QEpr43vYu6uukV7cm8QzdV38pzf56aR35oscEfu47hZ/7TrFZPR6DHqpg9HwuZgcak+iF9XWpiTRdIQo7B2m/qZENgkezLvN92UV05nDmgVkxfH9gDtmfjJSyKsrYhiK9gXG/HqiwbcH0zigVYrIZADvfZiivuF8MJiNP77ck3Pmw21icr1HSnXIPQSetGDbu2GqQtK8882J1vHVso7T8RkfZO7A+BDm5sWP0Y0xWiL+FoFDwsVMAt2+bR5E546hCoeCXqR3xcxGvi2UnU/lpX3yVZdYVH3tn1gyfgYf52bQy4TSzTm4h8OG5YO4ftDLG8m7h17x1+FZ2f/8UZVmJ1RUpUwXWBsEIZw8EvRgloTR7ivYN98TDPBm3+kxaBWNBXUguzpMiQVq4etPLJ6zKY1VKBXc5nJDWjVFVT/LdLIyIcCLEJL4DL6hCmX8kmSlzD1cID23l5ova/Ew7kZPcoPq6hrgze4yo02oSYPqCI+QUi5PzHlpHXmg7CIAyQWDuiBel8zL+fp2sDV82qG6ZihQeW02JWVs7JrIPI7My2Jwiem16a53YOPIRgq00JfWNnGHd+h4vMBYxMb+QjT7iZIxaoeCXvlOY3W2M/H6VkZG57shPoRsYQRCYsnUeZ/NEj4+27n4sG3JflRlhrXm8bzgRnqLo+OozaWyKzsBr9AsozZkvc7b+SO6uPzCV1i1095kBYohSmVHg7Y3R1R67LeUiQ/csJcssNNqqJJedYx6XBLITinLps+YbjmTaJivf9WbD+XTeMf9PNCoFc+7ohEZV91tQEATy9i6Q1p07jKnmaBHJIKgtYk3pOqKWfcirh9dxOKvi/7aLVxBLB99Df/9mVZe1aw4lMfvE4kI74jH4kTp/B1vw/bk9jNv0uxQ61ckzkEPjnuHptv15sGXPapOh1AevsS+jHvkaJrU9zVv04zFz+YUGPU/sW06xxlE6VmjEkGGAd45tpEwwG31ynPnf+T3Ymwzok04S935/ii/sadT6/ysIgsBdC49yMDFX2qZA9AwxFmRgKhLDxysLF/7p/D5OmMPRevuEMb1Zl2vRZMDKIGjWqLOWFCiqIWz4n4TT0iCqtZsvk80Za2Xqjp1g4p0Dc3np4laU5gmcJXEnCFr8Dt+dFQeuPs5afru9o3TOo0tPctucgxxIyKm0zLoS5ebLiqH3SZECn53ewddFRYS+uAHHqAHScR5CAZ77v+HCCxHEfzKKzFWzKTi2hrKsBNlzsBZcKsiWlsO1lsmhcg9BtUrJmNZi4qGs4jL2xmVTHxbEHJEyj97XvHuNeqR9SvZLy8fc+tSrzhsJfZJFLzFdI3plrjiVyvhfD0qegnYqNVFu4iTm6Zy0CtnA68OzA5oxMkosLzFXx90Lj1KkF720n27bDy9zgp+FBXkU3fmFdF7agmfI2fZzg+qWERFMRtKXvopBoeC7sF5MCunDcfP710Wj5d8RD9HK3RetlTyPrqxxDYKGcoOgqox3Li3mqHndtUzHynb9mGHjPqqMjIxMfZENgjcw8YU50sAN4Ic+k3G36ogCFBtKWXTpKOM3/Ua/Nd9wLEtMgKBVq/hgrCX75F0Lj5JqsMdr1PPiBmMZyT/fx4XnQshY+Q6CqXbiu0/0DcfF7JXyy/4EPtkaU+lxeaUlTN+xkGKDaKjqnR3PH4fm0V0wsHvsE/T0CQUgt7SER/f+fcMPSN5cf46RP+2XOgj/NyKK9gGVC69Wh6k4l6SvJlJweDkgZlBzbNmvxvN+PZAASgOEnibdmFVhX2+fMD7pfguXJr/C4fHPMqma8EB98llS5z8lrQfc/Q2K65C8othQyvMHVkmaTdObdWH32CcId6lbpuaaMJkEDibk8vq6c3T8dDtRh3vSyW0Ro8ue44VOYyTPm7/jT9LfpGWVX2sEQLASj24MtqSKod1qkx1Fl7twl/P7KL1FI25p2kXi3u1L8q8PIhgatx03O2vPprPi1NUel4LJSNpfL0vr2sDWFfZn6Yp4/YiYeVqBgq97TbxmGXpzS8rIMU8AuJqfxQ6RvSUdwZKLe6s8d1XCaaZumyetv9NlFKrrmCjoRqc05TymomzuTTrCLzHb8TCH9+eV6nh833KWxIrh5GNa+/FkP0sG82UnU+n55S4Gfrub1WfSMNXTm6ycAf6R/NZvqrQ+6/Ba7k9LwuOF9US8fZS9vuPQYQ5ZMxkpOvkv6UtfJfHzW7jwXBjnH3Uj9p0+JP/+CNkbv0afcr5B7bkZSSmxSJwEmsNEAQSDRRdyVCtLJvJ98bn1qqdc1gNgemT1WUcNuan4pIn6gRdVIewtdK9XnTcSpRmXpOXhfqW42ovPwA3RGWI/yEwHz0AASoxlHMxsmFesUqngjzs74+ss3kNrzqbT5fMdHE7MxUVjz6z2YhSHUTAxxy0E36kfSOemzH0cXcLxBtUvAwVHVnIxM5F7O93BtxF9MZj7ht28g9k79km6eItSDRujLbq/amXjvpPjss0Tw065ZJSKzwfP0mIWHF3EYK/gas6UkZGRubbIPf0bmDBnD/r6hkvrD+5eTIauEKPJxMbL0dy7YxF+i95i2vYFrEo8w+70OMZs/JXL5kx4UzoGSDPWaQV63toQjdeo53DuYAkrMRZkkrHsTdIWvVCrNnk42vHJuDbS+ourz/DFjktXHffK4bUkmzUCh2nt+e7kMpyNpeRs+hofe2e2jHqUzp5iJriDmYmsTjxTt39OE+LrnbG8s9FiuJ3Q1o+XBkfWuZyS2MNkfzaUgiPmMESFEr87PqnRIPfn0ct8vyceAi6CVuygBDq68nXPW0ma+gZ7bnmS59sNIsKsNVUVxpJ8Er+aKIVCeQx+pFbGyMZga8pFKVHDPZFdmTfgTptosOyMy2Xd2TT+PpHMo0tPEPLOpv9n7zzDo6jaMHzP7qb33kNIgIQWWui9V0Ga0rELIhawfvbeEAsoCqKCCIoIgvTeewsJhBBI771uts/3Y5ZNIgkECCHK3te1V2ZmZ2bPbnZnznnO+z4vnb46wAc744jKkNLy9YKcy7llfHsgjR+6P4CNMW03S5DzSvNhvN5iOBbeobfdlusRYEx7Mch0IBhIl3lycsRvVQqbFO5fSvrSRxBvM/rhXsVgEE3Ff6DCIxUg+fNhFB38WdpuaYtzr0erHPv22e0UGKNEH2nakQ7u9df5XxOZbkpVulplVGZpbYpiVGfGVvud+C3+DGN2L0NtrJA9KbgdYxqZvQNvByu/FlgHdQCgc+pp/kw+SO9K9+xHDq4m1hjh/+WoliweH26qlAqwPz6f+5Yep9W8vSw9lnxbnldTQjowr+MIBOM3eU3iOSI2fMU6nYGOc5Yzzu8X5ttOJ1nmfc2xBlUJ5ZePULh3MZkrnuHKqy0oPLj8ltvyX8TdqqIAQIHcEgt3KZVXGbsfg/Geaag0selkc2sTaUKlK1Hl16yOwsMrEIyR5FusepKv/O9PENm1HGDyw7ZMP83WCRVC+zvbL6E0+quO8K+YxPkxrqolxK3g5WDF71M7mATISzlldF1wkE93X+aJZl1NFYdXXDmNzaDncBtq7FPrtaQtmV5FODZzc4iiyOL9yxkTMY2zTpLQayGT82GHoRwZPpuWLtI1bUdsDp/vk8Yj1goZo1tfe62rK9Q6PT+ekAToyvZN49MjCVbmIzN7PZu5x0goKCcqo5geCw5e8ziXUcyVvNoVIzVzZzALgtWg0fw7bsyCILC+/8O0dJbSImKLcui+aSH+q99j0PbFLL9yylQx9ioZ5cWM2vUTSp0GQRD4dXJ7k+/fzydSSFUKBM7dTOO3T+Dc82Ewih3527+kYM/31IYnujbi85EVouDz68/zzcGKykKHshJYdFGKUnG0sGbp4BlYGztwhQd+Qq8swlZhyYeVilq8eWYbBvHfJ2xsiM7kufXRpvUFo1ux7uGOKG4iVVgURfJ3LSLx/W7o8yV/KbmjJ41e2oFzj+nXPTY2u5TH/4gE50xwkXz2XCxtODJ8Nk+36IGfXe0KmoiiSPoPj6AxRoZYN+6I1+S753+zKTXGtDwxuF2dRV/N+vsyw344zrhlp/j+SBLpxRUp8zIBegW7Ym1MOZm39wrNbYKIHfMyY5wrPBT/8gzjh/gzddKemujhJQ1yDBjAVhL41ySIBL1+GN9Hf0SwlFKUig6vIGvVnH99hO3dYPnJVFOqcMcAZ9N2AQNl0cYKvHIL/GeuxMqnQgDemnqxyvXtg+sU57kT/Ho6zbQ8uYOfadnKKFKLmnK0+VUjYpbEHmXSvpWmqoePNO3E8p4T6y2q8b+KIFcQ+PxGkzjkFbuP5XE7eKypZCpfqlMzbvdylDoNMpnA410aceV//fllUjvCK0WQx2SV8tjqSCIWneabgwmotLWL2P8nc1v1YfPAR00pjJdLcpm8fyWD9n3F4KFWbPIfy1DXxQxyWcyHPm9Q0vMFHCLGSEVIKvtciQbSf3jILApWItDe2bScUlZkquYralWUnd8JQHpRxf3Ex9GaW8G2UkVh5XUi0UVRpOjATwAYEFhv1Z8i1X9fEFQ4uOM64GlAutYFX/iRie2k62BGsZqvDkh90dGNWuNsjPD/LeGsydfzdujTxJ3Iub3pFiQVbtHqJY/uwHd346qR2lCsVbEq/iye4z40TRaokyPJ2fD+bb/+vYhKp2X8pq940aUJSuOkcKijB0eHz+bV8P4mMS6nVM20VRX9si9GtaSpx50T5dZEZpBTKo0lRwRXiNJJRr/0q1YCZsz81ziXUVKt6JddqqW4UoHLyig1epPVjZm7g1kQ/AdXrlwhLCyMzZs33+2m1Ao3azu2D36CIHupAxJXnGsqMALSDPKssG7sHPwkzYyFH07lpfLwgd8RRRFnGwuer+T795kxxdemcQS+j/2I32M/mc6VsXwWped31apdc3qH8EmllOSn10Xz/ZFE1Hodjx/6w7T9k4hhBLr549zrEQAMqlIKjZ3YwX6hpgjIs/nprEuqENb+DZxILmTCilNczfZ6f2goT/dofFODbIOqlLTvp5C5/CnTDLJtaC+C3z1zw2IiSo2O8ctPUiqWgE9FhOKPPR4k0P7mKg3mbfqEkpN/AiC3dyNg9ppriijUF6IosjlVqu5qI7egt/fNR1vWFnsrOePCfVg+sS3Z7wxm36zuvDFQMoXW6kVm/hmFv50TXyQdZv75Dabjnjn21x31vhzg29S0bOGXBIhsv5RDuc6Ac6+HCZj9JxgjR/O3f2WuaHiT5Cs1vLSpIipZinquKqoqnH0I+t8+HNqPMm3blhbL/bt/Rm8U1t5sOwAvm/rr+KcWlrPPWOWytY9DFVsCS98Kn0NNxkXT8vzofTxxeI0p/f7ZFj1Z0n2cOVW4jlA4exM4dwsyY3XX0jMbeOn077S2kgSh6MJMZh1Za9rfQi5jSgd/zs7txbYnOjOgqbvpuYwSDU+viybkw90sOHBrwuAQ/zDOjJxDn0rXzazyEr67fIAcvwPYN4klzdGaX7URdInpxSzblzG8cIqwxaU0fucULkaxBVEk/YeH+Ofv4l4lsFL13uSyAuzbVVwXrkb1pxdXiE6+jrd2/7SrFAlfpq158loVfwJ1unQNO2oRTobco8bB2H8NtyFzTZNi+Tu/4d0erqb00E92XyZfqcFGYcHkYCnlukSrZk3iuRrPdzMEudqy76luvD2oGVczUotUOhIvO5v2mblnG5N/i+JYl4/B+P/M/ftDyhNOVnNGM9fj0+g9/JlT0dd61Nmd06OeN6UIg9RnfOT3SDJLpN/fqJZePNm15mI8dcHCQ4mm5Vd6tDZFiF6wl7Ky5DY3bxlkxkxDp7WPI+E+1fd5HazktCKZX4peuebRTJeIhyqt2uPM1A/mHv8/eO2117CysmLMmDG3LQoWFxeTmppqemRkZNRRK6via+vEjsFP4m0ceFrLFUxo3JaNAx4hfcKbLOw6hv6+Tfl7wCOmGdHViZG8a6wk+XSPxqY0hyXHksmsFBXl1G0y7iNfl1YMelIXjqu1f9BL/Zrw/tCKyJkZf0YycENFEZQeXo15IrQLAK4DZoNRKCvYvQhRFBEEgffaDzEd/+aZbbdt/lxfJOQpGbH0GOVG0+JHOwXyv/5Nb3BUVQyachI/6EnxkZWmbbb9nqXRy7uwcPG94fHPrDtPVGYRBMSAXGrHrLBu3N+o1U21o/j4H2T/8aq0Isjwe+o3LNwCb+ocdcmFwiySSiXD/f6+TbCpFDFRW2r6bT7XzY+Phzfnk+HN2fxYJ3LeGcwf0yOYGhGAm53UcX+hTwhhntLM8r4refy27ySlkZsYnBPH4znSb0Nj0DN+7y8U3aHiIvcHtqK9mxRxoLUsBpdMyrUGdsXlAmAfPgS/x5ebflM5f75e6whfM/Da5oum2f3p7b1pdvxDhErCh03T7jR+5xS2Tbqatu1Iu8T9u34ypdxODenAcy16UZ+sOpN2tfg3k9tXTVO2qlT4RJ0RiyiKvH1mG3NP/G3a/mbbgXzRaeRdrXpYX/fN+sTKtzmBz21AME6iaE+t5dN9C7E3RvD/fPkkny95nNzNn1F0bDVlF3ajTo2mn5eB7Y9FcPr5Xoxv42NKFk0vVvHMX9EEf7iLr/bHU36TwmCAvTO7h8zg6IjZTA3pgKUxikYvGii1zoTGkRByGiyV/H0hi5af7mXO5iuUe7bCe8rXuA17STqRKFb5XdzLVI4QTC4rxC60l6lIW8np9RjUyioR5763GCFoZ1FJELxOmunViVWATbYDAEmYuh3+Lb9NhaMHrv2fAkDUKHE4/r1JACpS6fh4l+TDWLmow9I6SBs2vb5cxluDQzk8uwdTOvjh42gFantQSn10nVUxq2IuMmlnOYsdpkgHGfSkL55+04X87mVEUWTFJen/JhcNLErYz5L75lxjH/PtoUQ2XpAyZHwdrfnhgTZ3NPr9VEohR5OkPmrHAGc6N3KhnZvUZ0+2daFEYWVKazdj5r/EonHhHJzdo9pHeJsInBq3rfY4S4MKK4P52nc3qf9qAA2YrKwsDh48SGxsLI888ghjxoxh7dq1DBt24yqu1TF//nzeeeeda7YXFBRgY2NTzRESxcXFNT5XEy4I7Ov1CJFFmXR08cPBOPAoLig07eOGjB/aj+LBY7+jF0XePrudAIUto3yb83gHbz4/lIpaZ+D9red5p3+Q6ThZr2ewSopCHbkeg7KQxHlDcX12GzK7aws45OVVLVgxo50bxaUBfHosFgJiOFBYCoClTM6nLQZQkG+spKhwxrJZHzSxe9BkXiIrah8Wfq0Jt3Shh3sjDuYmcaEwi8XnDvBAwM0JWjVxK59zbSgs1zF0eRTZRkGhb2Nn3u/rS37+zVUVLNv5BarkswAINs44Tf4WtX8X8guLbnjs71HZkoG2dzzYSJ95S0dPXg3pfs3/6HpoEo5T8P1U07r9iDdRe7dDfRPnqOvP+Y/Lp0zLvZwDr/t+3Nyq90Ws6bc5vpk9oaEVkR5lxYVU52rx0YBGjF4pVTM8tvYb2hiL7rwc0JooW0+O5qcSX5LHlN0r+CnizhSU+KB5P4YeNBaA8EqAInd+P5VEN2+jQNpsEA6jP6ZkrVT8ImPZTJSiJdZtRt6x735D5Gbf6+n0Er4/IqXm+1sUMTbhazIv7wZGGvcQcHj8D4r1lmD87u3PSWTSsT9QGaQB9zi/lsxrMYDCgrqpFFsbiouLWX48ybQ+JMi2ym9Da+NlWi5KOMtbB9bwzZWKCqRvt+jH04ERN32dulVu9rd5o/tmTTSY77pbcxwnf0/xqlmI6jICVUW8f3Erz7WSIsleE2xpvPEzwspyrjnU2saJ9+zdedG9NX8JHfkyuwlKwYaMYjXPrT/Phzsv8XB7bya18cTvJiLPmsjs+aLlIP7XpDsrkiL5OekMaVeLY9iUIg8+hz4+HJ3Glq8OJLDsRAov9vDn4T5zsVWpUO7+utLZxFrfWxrM/6QOuPpe7Ctpc1fys8kvKsay1QhUx39FX5ZP6qYvSM7rDoBcAJm6lLxb8EwSKom/6Xk5eBuunRATNeUUGicSBWsHTjr0ABXkl6mu+z+6+l7q+rd5N/7fQpdHYOc3oC0nf+cCnnp+Cj8fl1GmNfD1gXimtnIm0NGa1o5eRBVncSArgWNJl2hi71Zn7W1iD18OboQ4KJDLeeV8cUHH6kKpujiuGZDuwALZfXRSHKKtLhZ1+gWSV76Ew31v3dTr1EV7b6ZfeLvU1ed7viibuLJCADoXJDOs1VDyi0qq7BOTXcbcDVJfTQAWDg9GUJeSpy69Y+2dv7ui8M9Dbd3Jy8sjzNaNfUj+hZecA2lyi/fZmn6b/zU8VGlYGVQkvH+tT7k65RxWAeF3oVVmbgfHcfNq/P5qvn602u1m6g+zIFiJ3NxcZs+ejZ2dHStXrmTSpEm3JQrOmTOHxx57zLSekZFBp06dcHFxueFF/VYu+m640cw34Lr7jHVz40tRxexjfwHw9JlNpOiUTO3RhkUn0lFqDPx0JovXhrSs4nHjOmsliR/1pizhFIllhexa8xLZfZ5EEGRoFQIWOhG9TCBVUONuZYejpRWR+RkcyIonyjYBRbM4dBg7sgYZc5oOo2tQ1cILsh5TyIjdA4BwcRtu4X0A+LjTCHps/gaAl6K2Y21nw9SQDlWMem+Vur65iqLIg98fJS5PigwL93Hkr8e64Gh9c1FsuuJscnYbPfrkFgS/eRgr3+bk5eXdsM1Hkwp4cVsC2OeDuxSCbauwYE3/h/Bz9rzusZVRp18k8aepYIxicek3E++xb96SuFVXn7PeYGBdpXTHB8I64GZ/85WFa/ptOjg41Kqt97u5MSW2kBUnUxlSsk3aKMgIHPI0ayztaLt+PrnqMjZmxLI277IpErYuGeLmxvTMGJZdPgkKLXglsP2KHXJbR5xtpO+b26iXyDYoyf3rHRBFin+dgbNvCHi0vGc6llD7759Kq+fV5ecRLZXYucRR4JrDSHkbHD2b0W9HJjIDiAi4e/mYjjlfkMnk42tMYuDE4Hb80nNivafc7k8oJDpbCUhel22Cq0YRG+w6k4+U4Pm1Rm0SAwUEvus29o58R2+F27lv1kSD+a73nY535/tRJZ1GlXKO8cmRnCtK4UenANRyC+a0HMHak79gbagaySWWF6EvL8Iu5wqT+YvJCiuO+D3ArLJRqLEku0zLJwdS+PRgCjO7BvHV/S1vyqfWDTfe9w3k7c7D+DvlAm+f2c65ggz0CjWOzc+jv9KGslJLClU6XtuZyKITmQwLe5jJHfWwR7rHCIhYxO/FsePY2r1mQ/mf1AFubm64iC5YyORoDXoytWW4ublhP/ZNrpxYCaKIat835LpJKapeDtZ4erjf4KzV4+5Q4ftrYWdT7edYdGQVokoSMZy6TMQ60xFUZZRqxdvqe9Z3n/a2cHPD0G8G+du+QFSX4X5+JXP6TOW9HXGo9SILTubw/bhwnmje1dQfXpMdy2eN7rsj7XV3h59CvNj2+ymKNCpsPfIY4eXJ6jPZvGb/LH8WPoc1Gkr3fIN1xHi8W/W8ybd7e+2t7/9PXbzejvgjpuUh+Qn4zViCvFLqvkZnYOaPUaj1UhTzS32bMDri1ixmatvefKWGtRekTA13O0se6d4Maws53f2a8H28VPE7xsWfqf+h69+dwMqgwrKGiDGrgHCs/c0Fz8yYqUvMgmAlWrZsScuWLQGQy+U1ioIJCQk0btz4eqcCwNHREUfHa30iFsUcxrnAA4VMzsiAFoQ43lrH8FaZ1bw75wuz+C72COV6LW+f3c7bZ7ejaCYHtSVKrTVtVl1hRkQzGju6UKJVcy4/g8i2DxId0B2VzPi1iZSMsgdbyLHQ6VBZyWm7fv71X7zcDlKbc8XCDv4x8ePYYTQZP88AvZaSk2vwHP8hgiDQ3asxk4LbsTL+DKU6NY8cXM3H5/bwdrtBPNi4zV1Nb/snhxLyTWmbvo7WbHqs002LgQAlZzdiUEkzmK79n8LKt/kNjpDYEpPFuOWnUGr04FYx4/tB+6GE3awY+HEf9KXSOezbDMd7ytd3vcjAnOMbOFcgpSm1dvGh0S2IgVDzb/NmmHdfS46ejSLQkAmAXatBWLj44gd8HDGMx4xemRuSz98xseXjDsNYlxRNsVYFbhnkKJ3pufAQmx/rTICLFLHhcf9b6EtyKdj1DaJOQ9p3k3CZswfMHdIqaPV6+q/YxCl5FDQrMEaGSr/dYgsb1BZybNTXpmb+cuWUqeL1g43bsrznhHoVA0VR5Iv98by8saLQzpQO11Y1NqhKEWVy5gd140d7SdAUEFjeawJTQjrUW3tvRF38Nhsyclsn7Jr3xa55XwC+M+iJ2fwNR3KSSbJ15ciodxlvUKEvyUFXkoO+JAd9cQ7a/BQMKmP0i05N16RfOO19ih+CXmdBvAM6g4gowreHE8ksUbFySnusFDc3aaaQyRndqDV9vZswaPtiTuSmUKxX4tcihlFCP347nodBhNQiFYuPpbBYHMQYfjYdn7zsaZq1GoKlzb2XDicgYKuwoEijJ19ZRPGJNahSoxEsrBE15egKM9AKaSD3JsTd9pZf52pBGIDt6Zfo49Pkmn3KLuw0LTv3mI77FgOXc8vIKlHzxB+RDGjqQXt/J4JdbZHJan9P/7f9Nt2GvShZ0GhV5G2dz9NvTufTPTLUOgNLjiZjZynn9UHteOHkRtR6HV+eP8C4oHCayO5MsQlbhSVTQzqwMOYQSr2GyX3seaVPGC9vusCXkVN5pWwpMgyc/vohWn90lgA3c+GJ67H20lFAShceHdy+ihgIsORoEtGZ0jUzIsCJd4eEXnOOOm/TuQxUugqrIGsL6RrcwbVigm69Wwjvi4YGNXZpiGhk1jR+/eDdboYZM/cE5qvRdbgqCo4aNcrkKbhu3Tq6d+9+W2lVH57bxUsnNzHn+AZa/jWPXelxNz6oDhEEga+73M/MsK5YVIqy06EHq3KwLyDHMon3zu3gkYOrefbYepbGHedkQWaFGHiTBNo581KrvhDfHtR2FJZfW+1ObueCfUvJ60aTdRl1akURke+7jWNcUEWI+KXiHCbt+5U2f81nXVJUg6miWrnC5xejWuLvfPMpbiCFxF/FseO4Wh2z/GQK9/14QhIDgXDnigqjuarapyaZxMAiyXPFJqQL/k/9hiC/u/MHX50/wNcxUufAUiZnfqf77mp7vBysaOVcIRBZeVd4RFYugDOm0Z2byfS2deTrzhXm9fjFEl2YQdcFB4nKkCJEBEHAe8rX2LeRJjR0BWkUrzZXHr5KiVbFl+f34/HL+xxmPzhUpPnaVvLoMtQwcM5XK03L77QbVCeRy7UlJquEAd8dZe6GC+iM1YuGhHnwUMdrI8Vzdy7k/ZA+/BjYybRtUdcxDUoMvBexkMlZ2GWMaf1PK2c8x7yDz/RvCXj6D4Je3UvIR+cJ/SYPl5nrcB30HILRC5jMCzx2YjpxXSP5eGgzUwX0tVGZ3Lf0OGXqW/OMc7ayYfugJ0w+pWnKQo7L9rNjVnvGtPbG1tL4HRcERCp+F7KSTF5+fS5/nku/Z64vhrJ8cjd9ysHvplJk9H8LSjpJ6sLx5P71DqLRR3abZTdSZV7IZQKvD7g5P+HKjG0UjrXxXvzl+QOkK6+1ENFkx5uWrRu1q1KYZsnRZB785RRNP9qNyxtb6f3NIZ5fH80nuy/z9ZFUPqmU7vhvx8LZB9fBzwNStWf1X6/w1f0tTc9/uT+BZ/6M5eVWkjivEw2M3rWMbZl3rk8+yLeZaflEbgrt/J3Y/mRXpj7zARespInfIHU88z58kW0Xs++Z39HNklSazwXj7619URohfZ+o8vyayHSeXX/etL5obDiWijs/5P3b6FUIMLF9hQgYXF5A2yJpfHDB2om1SVF3vC1mzJgxU1vMguAN+Kco+NRTT7FlyxZcXW8tMumfqPU6Ru76kYNZCXVyvtpiIZPzbdexJI1/jXfbDea+gBa0dfXFyaJmAUshyGjl7M04Oweev7KfRefW8lPMZqyMApSl1sDTzbszoXFbBvk24/Fmnfml10QSx/+PpAde5+OIYcgFaSBRU3lxhw4VA6OSkxWVF+0trPij7zSOjXiGwX4Vs3zRhZmM2b2Mjn9/xeXi3Nv6TG4Xjc7A6sh0ABysFNzX0usGR9SMKrWis2Dld33PRFEU+WzPZaavOoveKApM7eDPtonDkBtnINcnn7/eKUxUJwYGvrgNmfWdmTGvLeuSonj+eEUV3597TmBApY713cJVVpHSIFhJs/nHcpLYlCpFa4U4uDG1yZ0VXKY37chTYd2kFZkBAs+TVlpC168PsvBgAgaDiCCT4fvYT8idpO+kOmojBbu/u6PtauiIosjqhLOErf2U549voEis8B4KUubzv7jdHMk5x+6+U69zlqrG/nb/MDO/U5Sqdby88QLh8/ax+7J03ROAd4eEsvHRzlj8I11UU17MzIQofvNrC4AMgWU9J/BkWFfM3H3aufnRytkbgD2ZV6q9lwkKCyyb9sR78hcEv3sG68YdpSf0WpTrX2fS+ZfZ+mh7HKwksWjHpVwGLT5a7eRbbXC2smHboCdo6SxdMy6X5DL77Eq+m9Cc/PcGs3tmV17pd2102ri8lUz7+SCDvj9KTFbJNc//VxANBgr2/0jux13IXv0yBxLOmJ5rW1y12MY2y2687DAXBIGfHmzDoNDaR+v/Ez87J55tIaWTluu1puJwldHmJgKgcPJGZmnDrO5BhPtcG9lXrNKxPz6fL/cn8MqmGN7dk8wrm2Ku2e/fjMfI11C4ShHTJafWMdk+ll8nt8NCLgnZK8+kceSEI708gwHIKC9m8vE1jNix9I70KTu6V0zWnMhNMS0PDPMiYvaP6I3Dsil5y3n4u430/vYwB+Lrz9/v38L6CwdMy/105Vg3jjCt/34mjQkrTpv6w7N7NCYiwPmOt6lcq2fHJckDNsDZuspvTpV4imcSDpnW3zz97ymSaMaMmf8+5pThWiCXyxk3bhy7du1i69attGnT5rbO93PPB3H38eanuBP8mRSFUqdl2I4f2DX4STp61G/1Vh9bR95oO7DKttXnknnwt8NgoQZLNXN6NGFa6zDCnDyxkisQRZH0gssUHZb8MP7WhwECFjoDC7qMrvG1BEHAzlJOsUpXsyDYfiQZPz8JooHiU2vxGF3VXLmTRyBbBz3Ogcx4Xj+9lf1Z0kz4qbxURuxcyrERz+BkeWtRebfL9ks55CulwdeY1t7YWNx6pJA6RRIEFa4ByO2ca9zPYBB5ceMF5u+riAh4sU8IHw9vjkwm0MMriH2Z8UQXZhJfkkewQ81pourMS9WKgXKbu5sidCwnicn7ViIaq1l+2GEoE4Pb3dU2XcVZqBAE9ZaSIPjWme2mbW+2HVglCvdO8UWnkUTmp3MoOxEsVeAfQ1lSa2avi+a3M2n88EAbwrw88Xt8GcnzpMrdWauex7ZJV6wbtb3j7WtoXC7OZdaRtWxPv1SxUYQe+QlMSTtN9/xEHNsMx3/WamRWtvTwOghIgzf9PyIF61MQFEWRP89l8Pz686QWVXz3mnnY8emgIEa1D77mGI1ex/j189jgLkUlWYgiK/tNZVzQ7d3HzNQdgiDwWLPOPHd8PQALLhzkqy7317i/lU8ojV8/RO7fH5Kz4T0w6Ck5vZ4QS1t2P7mAIT+cIE+p5XBiAX2+Pcy2J7rg5VD7YiNXcbe2Y+fgJ+m15VviinO5UJjF4G1L2D1kBn2buNO3iTtjfzS9CwBcxBKGqA+wNm4Q4fP28VyvYN4c2AwH6/9Od1OVfI6MZTMpv3zYtC3SqSIaqEdgazw6j2V3iQdzT4ikySRR9ctRLZkacX2f59rwcuu+LI49SoGmnB8uHef5lr0IdZJERlGvQ5svXassPCRrG29HayJf6E12iZozaUWcSSvidFoRZ9KKuZx784VN/k3IrOzwnjif1G8eACBzxTNMeP8c7nadGPPzSco0enZcyqWNqin9msrZnSVFB25KjWFH+iVebNWHV8P7YWdx87+f6vC2dcTf1olUZREnclMQRdFkxRLUuguJ/Wah3L0AO7GcX4pe5rnYV+kVn8/gUA/eHxpWL8LWv4G/L1aIa6Na9DJ9hqtOpzFl5WmMWiBPdQuqEhV6J9kVl0u5VhL5Rrb0rmKxo0o4QefCFLoUJHHUpRExRdmsSjhzz0foZ/w8s0oAxFUs7Ruhkd1aJXYz/04saygiA2Dt3xqfhxbVc4vuLcwRgpVITU3lyJEj12zfvn07zzzzDLt27bptMRCgv28zhge0YFWfKYwMkG5UJVo1g7cvITI//bbPf7s8EB7IxwMioNQV8n1Ysk2NXG2PlTFNRRAEPMa+D8abnUDtUxrsLK8fIahw9MQ2VJr9VqecQ5NVffpKT+9g9g6dyY7BT9Dc2BGOLcph2v7fMIj1P+smiiLfHko0rU9uf62HV23RFWWhL5FmGa2vU0lLozMwbdWZKmLg5yNb8Ol9LUy+QKMCK6ILrxclKBr0pH03ucGJgfEledy380eTR9vjzTrzSut+d7VNlXGiIl1Ua2HPoawEtqXFAhDq5MGkehIuLeUK1vSdhs/V/5dDgVR5GDiUWECbz/fzwc5LWLUYiNtwqeqwqFWT+u2D6Mv/XVE8BUoNSs2tpUKqdFrePrONVn/NqyIG+ufr2Hj8R76PWkvP/ERcuk4m4Jl1yIx+Xf8Lr/jOaS1kVdK4SrX1IwheyillyOJjjF9+yiQG2ljI+HBYGOde6E2PRk7XHFOu0zJ6189sKJe+p1Z6LX90GGIWAxsgDzWNwF4hiQ4/XT5BsaZ6Q/WrCAoLPEa/RaOXdyNYSt/T4qOr8N39P/Y/1Q0fY7XhyPRiOn65n9OphbfULm9bR3YNnkEje8mf60x+GoO2L+bcP/oqlVOHJ+ml4mA6g8i8vVcI/WQ3v55K/denP+rLS8hcNZf4t9pXEQOdez5MTKiUdmohk9NoxOeMSerJhFOeJjHwzYHNeLbXtYL9reBiZcurxmuSXjTw+umtpue0+algrHpv4R5U5ThPBysGh3nySv+mrJ4WQdyr/Sh8fwgHZnVj82Od+O3B5mx+rBP/NRw6jsOuRX8ANJmXyN/+JYNCPdn7VDfc7aRrdmSyiqTIJnzfcSKBttK1VGPQ88G5XTRf9xl/JETW2ff3apRgvlpJfEnV6L+AB97HwkuKvPUx5LK86BXuV+1kW2wOHb88wJifT5jsQO5VSlVK9mulPqG/qoiIXg8B8Oup1Cpi4OwejVk4plW9eV//fT7TtHxfi6oZQuXGgiKzEyvGmG+d2Y7WUP1Y6F7hhZJSxjkEMd69RZXHJXsP1GZB8J5BLbPmkr3HNd+D8e4tGOcQxAslta8KbubWMAuCRlJTU+nbty+nTp265rkOHTqwY8eOOhEDK2Mhk/N7nykmT5ECTTkDt31PbMndTX0FeKlvCFM6SP5BJWodw344RnqliBRL90bYtRp00+e1tbgqCNY8oK+cNlx8al2N+wmCwADfZmwb9AQe1pKJ+YaU87x3dmeNx9wpvtgfz5aL2QD4OVnTt8mtF2yoki5cQyWthDwlw344ZvIsVMgEVkxqx5zeVSuojQxoYVpenxxNTeTvXIgq4aTpNRuCGJivVjJsxw/kGP0PB/uF8k3XMXe9sEllHCg3LWsUdlWiA99qW79+ct62jvzZb1pFRKJHCo38pQrRGr2B17fEEvHFAVI6zcUiSBr0aTIvkblsZoMfqJeqdfx0PJle3xzC9Y1tuL6xjdE/neC3M2m19knblhZLq7/m8c7ZHaj10jHWahkPxcSx7dxXNC6XvANdB87G94nlCIqKYkBD/MKQGUcZepnAgawKEf5qhKBCkGF5h3w2N17IovVn+9huTEcCGN3am5iX+vJq/6bVFo/QGwyM3b2MzWlSVW4bvYafyzMY1WbgNfuaufs4WdrwcFMpDbhEq+anuBO1Os4urBcBz/6FYBSjC/cuxm3fexyY1Y1gN0koTClU0X3BIVaeTr2ltgXYO7Nr8JP42kr3hBO5KbRZP5/xe5ZjqHQ5vpq217z8PAu6W5i8BjOK1UxZeYb+3x0hraj8mvP/Gyg+8SdXXm1O/tb5JsHNyr8VLk9vxH7at5wvla4fnnI3On15iIMJFT7TL/dtwtuD69bi4unmPfA3CldrEs9xPCcZqEgXhmsFwepwsrGgR7AbQ5t7MSDEhaHNb93qpKFy1UcX4/U5Z/17qDMvERHgzKHZ3QlylbJKruQqefvPPP6MmMbbbQeZvBpTygp5YO8vDN+xtIpn7K3S0aP6tGEAuY0jjd84YhIwrdDyQenXvF76HRailnVRmYTP28eA747w57l0tHppAjytrIhNKReILqiarv5fZPOxP9AY+zkDFTIsHNz55WQK01adMYmBz/VqzFf3t6y3/qIoimy8II0B7K3k9Kk0BhB1WlTJZwHobO/McH/JKzK+JI+fa3md/68Sa2HDJXt3rAPCqzwUeKK0rF0xRTP/fpSWzVHgec33wDognEv27sRex87MTN1gFgSpEANnzZrF008/fc3zbm5utGp1fR+3W8VaYcG6/g/Rx1sScnJUZYw9sooS7fWjA+40giCwZHwbugVJUQEphSrGLjtZRThw6f34TZ/XzlLqYJVcZxDv2KEi7bj46CrEG/hsBNg7s7rPVJNf3ttnt/N59N56ixQ8m1bES8YKn4IAPz7YBoX81n5aBo2KokO/mNatA64VBKMyimk1b6+pmrGdpZyNj3ZicjWVRUMc3U0eUAeyEsirpriIJusKOX++Lq0IMnwf+/Gui4EAU/atJLZIEkDauPryR9+p9ZJ+ezPY6is+z4Np0ezKkNKNWjh78cBdiMLq6hnEl51GmtatAq/wQv9AFMaI0XMZxXReeJRT3T5BZqzIV3TkV4oOr6j3ttaW+Lwymn+yh0d+j+RAvDTIVusM/BWdycQVp/F6ezuPr47keHJBtcKm1qBnxuE1DNm+hCvGaAwLYGpSJIeOfcGLWRXelB6j38Fr8lcI/6gSLAiSJcJV3jqz3XR9uXqttq+jlLJ/otbpmbU2Co1x4BfiZsvmxzqx9qGONHKtuVrp22e3s8UoBjpqVSyNXMN9A2fdkTaaqRtmN++OYIy0+/LC/lqLD/atBuI38zcwXh/ztszD8dCXHH2mB31CpIGpSmdg8q9n+HJ//PVOVSMhju7sHPwkjStVdl+TeI5ya+k1RcC55yOm58ZrdnHxpb482LYilXbP5TzazNvHhpi7P+l5M+Rt/YLUhePQFUgTcIKVHV4T5hH8zmksg7uwPyseg/Hak5ZhgVYvLTf3sufArG58PKJ5nQsTNgoL3mk32LT+6qnNAGhzKvyoLY0pw2bAyq8FrgOfBUBUl5H0cT9Kz++imYc9h2f3oI2v1OfJKFYz++9E3mgzkAujX+T+SlkWW9Iu0nXjAgpuUxSs7CM4++hfrE2MQqOv6BMrHNwJfGErbkNfMG2bqNrMXyVzGaA+DHIVuzJjGbflT1wWz6PZlq/wX/0eI3b+SOu/Pmf6/lV1Ilw2VDZUShe+r3lvvtwfz/TfzprEwLm9g5k/sv7EQIBDCfmkF0t9ge5BrlUm6dRp5xGN/QTrxh15r/0Q03Pvnt1xz3sJhmqVHBz+dJVHeHkvQtRt73bTzNQTIeq2hJf3uuZ7cHD404Rq/7vXsobEPS8IVhYDn3vuubvWDn+7inSvTFUpiSUF19m7frC2kLP+4Y6m1KOjSQWoKg2KHdqNRO54c+bYnvZSFEOpWl9jCpOFWwA2IV0AUCWdIffvD2543j4+TapUnX3hxEaG71hKVj2kQ648nWYyL35rYLNbNgwvu7Cb+NdbU3RouWmbddC1/iLz98WbKgm721mye2ZXBofV/JpXO7QGUWRjyoUqz+nLS0j5ahQGlRSO7TrwGWwqmTPfLdLKikxihp+tE5sGPIqDRcNKH9gRm8Ph9Iob1VdFFTPzr3gHIbtLqSAzwrrS00saCF4qzmGndhe7n46go9F7yCDC84fVeD5iMv8i6/cXG2zq8EsbY6r45YX7OBLoUjFbWKbR88OxZDp/dZA2n+/jw51xHEnMR6s3kKcqY9yR3/g+9qhp/45Fmfx17EdeSdiJtUEahMnsXPB56Hs87n+zxkGEQl8hNu7NvMK86H1sT4vlfKGUZn81eqquWXwkmeQCKaqqd4gb0S/2uWEUz96My3wQuUtqt0HPoqi1dHbzwza01x1po5m6oamTB8MDwgBILC1g0LbFtRYfHCNG4/vYT6b1nLVvID/6A9uf7MLsHhXC0At/X+DgLRYpaO7sxcUxL7Go6xhTdNpV70CVtZzTwV0RjNfpgn1L8LXW8tvUDuye2dUUrZin1PLIuktM+fU0BUpNdS/ToFBePkLW6pdM6w4RY2nyUQxuQ+ciKCzIVJUy4/CfFQeUOWMpl/HukFDOzOlFj+Bbzxa4EdOadKCFccJvd8ZlIvPT0ZdXVB2W2zrfsdf+N+I55h1TFKuuII3kTweQ8fNMPC207Kn0HT2aUsyK06k0dnBjXf+H2DLwMdP1/VJxDrOO1py5Uhs6ugeYog9z1WWM3bMM/9Xv8eKJv7lYKEWZCXIFXhM+w3vGSmJcAvjVry0Lm7QkumU+ND8GjaLBM4ky62zy/zFgXn7lFC3Xfca6/2AlW4NayT5jf9vGoCNb1onn15/n6lzgS31D+Oy+FvWeSZJSWNFH2Rabw3N/RXMhU+pTlcXsNj1nE9yJdm5+9PeRPH1TlUVkqRpm38uMmfrkXEYJPRYcvOah1OiraA9m7gz3tCDYEMTAuKIcum5cwIorp03bnmvaldauPnelPf/E3d4KK4X0NfG0t6xSKENQWODYcXylvW+cdjilUhTb53trjlTwmjDPFO2Qs+4tSqOvraT3T2Y378G77QYjM3YEtqbFEv7X5yZPtzvFseQK8faZnjc/I6/JTSJtyUMkfdLf5JkoWFjhNfFzrHxCq+wriiLbYyvSBi+/2o9OgS7XPf/oRhVRhmuTKtKGRYOB9MXTUKdJ3oJWAeF4jnv/ptt/J6ickjkjtCt+lQTzhsCxpAJG/3yC1ZaD+NuqN1EOXiZT+ZYlmbT77gEuznQm8ZP+5Kx7h7KYPRjqacZeJshY3nMiAcZiNGfz03nm7Eo2PtGOoUbhOLNUw1ZZBI5dJwGgL8oib9PH9dK+m+F4cgF/npOEVn8na87M6UXkC71J+F9/Ds/uzuwejXGxqUjtjcoo4bUtF+m24BBO7/xJ4MrPOJQnpdJZG3R8HLOZn878SpAxPfiie288Z68n9OtMXPo+UctWSde5/53awtT9q0xbX2rV5/bf8D8oU+v4YJcUdSoI8M2Y1ljfoFhRvlrJlP2rTEV4Xryyj7al2XhP+bpBpdubqZ6vO99vEttO5aUyaPtiCtW1S7N17j4V76kLTeuZvzyN8tgqvh7dineHSPcSvUFkworT5JSqb6l9lnIFM8K6cXncq3zd+X4E40jcIAgM3LuCt3s8yTkHb/TKIgr2fA9A3ybunH6+l8mGBODX02m0nrePHZXuZw0NfWk+qd88CMboLfdRbxIwew0WblKEV4lWxcRjq0lTGkW4Umc8RG/OzOnFGwObVZvKX5coZHLmtuxtWv825jAWLhWfsTb/1lLE/6vIrOwInLsFu9YVEVoFe74j/vXWWCQc4OcJbU3bX9oYQ7FK8qkb4h/GsRHP4G4lWdOsij/Dr5X67DeLk6UNy3pOoKmju2lbjqqMedH7aL7uU7pvWsirJzczaNtiGl2OZlybB/iwaX+2eIaRae1wzfkErQJKXHHT+uGgkAT5zPISxuxexoN7fiG7gU723QoXIreQai1dHzvLBD7bm2R67r0hoXw8vO6jcWtDv6bueNhXeAh/dSCBlp/tpefCQ1zev8a03T5c+u6pjL7YMkHAw9q+fhtrxkwDo7WPI+E+117bAPSiiMFwY33BzO1xzwqCd1MMTCsrJLm0gN/jzxLx91ecM3p+OFpYs7bfdF5v3qde23M9VFo9ScbolGYe1960HDs9YFquzS14Yjs/U8Th6sh0UgqqH+jYNuuO14OfSiuiSNp3k9DmpVS7r+n1BYE32g5kz5AZpgFVtqqUIduX8OrJzejuQMSWTm/gZKo0GGjmYYeL7fWLCogGA6qUKPJ3LSL1u8nEzWnE5blBFB1cZtrHtkU/gt+Pwm3InGuOv5RbbkpLGNXSC6dKYkhNtHfzMxnCb0uPpVQrDQRz179Hyem/AJDbuxHw7Hpkxg7v3eZAVkXaUw+voLvXkGq4kFnCsB+OUabRoxKsiOw1n43DXjc9Py3lFDJA1ChRXthNzl9vk/RxP2Kfdid/93f10sYgB1f2DJlRRRQcsmMJz/erSFVadDgJr/EfmSJ68rZ+jiY3qbrT3RVEUeSVTTGm9XeHhNLWT/pdy2QCXYNc+Xp0K9LfGsivk9uZUiMBsMunPPAkSkGKfPVUl/LL6VXclxWDAByw6kTUAxsZPW8P7hEjTf5rtcHSWEVQLxrINkbWDvMPY1qTuo+sXXAwgawS6fc6ub0fLb2r7zBdRRRFnjj0h0mg6JUXz+S0M3iO+xDbJl3rvH1m6p7GDm7sGToTP+M97GTuzYmCrgNm4THmPdN62pLpFB//g9f6N2VImIe0rUjF1JVnbquTbSVXMLtFD2zUVe+rq0UFEztMZmTHh/jk9FbSjLYPTjYW/DKpPX9M64CrjcLUjkGLj/L02qhae4HWF6IokrZkOjpjxV67lgPxuP9N0/MavY4xu5cRZSzEhdoai/RW/PVQZ1rc4Hdal0wIbouLpRQxvSL+FEqnislkbV7DuZ43FBQO7gTO3YzPo0uRGa1RtLlJJH86gCb7X2d6a2cAskrUvLcjznScv50zP3SvmAB/6shakkrzuVUeaNyW2DEvs2/oTKaFdMBGXtGXO5ydyMdRu9mRfolSXVXh3tGgo0deAjMSj7Ag6i92HfmeY4e/4tXzR7C9YIfhUgS93cNM+69OjKTFus9YFX+mwXsF14YdMftNyyE2AVzJkyZahzX35PWBze7apJeXgxWHnu7O410CTcUTAc5dScYm7RgABY5N0DsHApBk9Bz1s3VqcFY4ZszUN4vGhXNwdo9qH3LzRHa9cE8KggaDgeHDh9+1yMAuGxfQ6I8PmLBvBcVGX4lwFx9O3vdslWiuhsCVPKUpFL+Zx7VikW2z7pXWxBtGQVkqZDzdXYqi0xlEFhxMqHFf18HP4xAxFgB9SS6p3zyAqLtxilEv7xAi75/L6EreLx9H7WbAtu/JUNZtdbYLWaWm9N1Ogc7V7iPqtBQeWkHy/OHEznIl/vVwMpc/RfGRlWiN0UsgiXK+jy+j0Us7sfJuWu259iQUmpZrm5osCAJjjN8rtV7H5tQYik/9Rc5fb0s7yOT4P70GS4+gWp2vPrgqCFrI5HT2aHSXW1NBUr6SQYuPkq80Rg6EefD56KasyZUiMdwtrZl+38s493oUS6+q/0NRU07mspnkbfuyXtoa4uheRRQ8k5/Gy9G/Ex4gDR4PJuQTo3Y2+RSJWjXZq1+pl7bVhu2xOey5LKU2tvCyZ1pEQLX7WVvImdTenz1PdSPljQFMGyQgNI4GufS7bF6cze+nVtCiNJvjila802wR/T7YxYPDh9/S4MFCJzLUr2LA5WhhzffdxtX5QKSwXMune64AUtGgtweF3uAI+DHuOH8a08TcNGW8f3ErnqPfwX34Szc40kxDoonxt1u5iMfg7YtN/YUb4T7yNVwHPy+tGPSkfvMAeZs+YvmEtvg5SRMA22Jz+Gh33HXOUjsEY//ASqM3CVMA8XZuzPNrR6O1nzBix1L+TDxHqVbNuDa+HHi8LSMqVeH85lAi7ebv52jS3bdKuUr+1vmUnt0IgMLZB78ZKxCMA3eDaODhg7+zM934+eksICmcJWM60K2xa02nvCPYKixNxWiUOi2rSiv6ONoGNMHTkBAEAZdejxDyQfQ10YIvR06hj+EcAF/uj+diVkV03ahGrXi8WWcAirUqpu5fdVv+b4Ig0Ms7hGW9JpIx4U2+6zqWCPeqXtCN7V2ZGtKB77qOJfr+Fyh4ZD7bR7/Ma14B9CtIxFtdip2oYopqI5sLZjA/413Cth7iLdfmeBkjz/LUSibt+5Vxe5ajrLYPLd5wwr0hIIoi+/IrrFnO5QWZluf+o6De3aCphz2Lx7ch461BfDeuNe38HOmhPYUC6TuyRtuGCb+cQqnRkGYci1ydrDdjxoyZu8mdKYnYwJHJZGzevBk/P78b71wPPNy0I990GYON4sbRXvXNpZyKUt/VRQhKHeSKgXDpuc04dhx33XPO6NaID3bFodToWXw0iTcGNsPB+tqvoiAI+D72Iwkp59BkxVF+5SiXnvHBrvVg7MOHYd96MApHj2pfw9XKlj/7Tefbi4eZc3wDGoOefZnxtF0/n1W9J9PPt3rB7WY5XilduPM/UncN6jIK9i0lf+vnVYS/yhQ5evJH2GDOOfvh4xNKY1tPguJO0MjehUb2LgTYOWNVqXLp3kqC4MBm7tWcsXrGNGrNF+elmdU/Yg4Rvr5C+PGe9AV2DSgqtUCtJLogE4AIN/8G87swGFPt0ox+dl0bubBmWgTfxR1EZUwpeyy0G14Rw6DXQwDoCjNRXjpASeQmUxRo1srnQTRUGwFa11wVBftu/Y6UskLO5KcR6KWB9Kagt2DR4US+GfEyhfuXoivMoPjYb5T2fAjbZj2RWdVcsOJOYzBUjQ78cFhz5LLrC25qvY6PY7awPP2wadvgvAQ+OL8BG4OOkw7dSBj2Hb8Maoml4vbmwn7pNZHeW74ltiiHxd3G4W8UXeuSz/deoaBcEp4f7RxIiPv1o3fjSvN45nBFatIHF7cSdt+reIx6o87bZubO09TJg71DZtJ7yyIyyos5nptCr71LebVNfx5p2gnr61wXBUHAa8I8RK2Kgt2LAMhZ8xpOaRf4fcKn9F5yGr1B5M2tsfRs7EavkNv3uVPoRdIefJO/kqNZGrWb3XnpiIKAHtiUGsOmVOn3HGDnTBNbF1q19GOKrwVrThaiKrEmLhe6LzjI//o35Y2BzW77N3o7KC8fIesP4z1SkOE3YyWKSn7JL53YxMr4M9KKXgaJrZnYsgnTO1Y/aXGnmRHalfnG+/v3iVEMtrACrbrGfocZCQu3AALnbqbwwE9krXweQ3kxYn4y3/A6f1gNYp7dwzy3/jxbHu9smvCZ32kkezKucLkklwNZCXwWvZdXwvvddlucLG14MqwrT4Z1Jbogg+TSQtq5+eFTjTetTUgn/J/6DU1uEvk7vqZgz2JEdSkyRHpoz9BDewbW/sxAKwfmh9/PWjvpu7s2KYqcVTEsLUlGlhaNQAgiMgRE4l5ojFPnCbiNeAVrf2kyPV+p4UJmCWGe9rjb35miWTeDOvMSR22kfraDQc+JeKlv3MbXkb5N7pxX583iYK3gya5BPNGlEVHzF4CkL7PXshNnz2fx6LrjJkuPILMgaMbMDdGLIj0WHKz2udY+jiwaF17PLfrvcU8KgsBdFQPHNGqNnacbckFgREALxgY13C/ypZyKKqrVRQhCVefA4mOrbygIutpa8lBEAN8eTqRIpePH48k82yu42n3lNo74P72GhPe6IGrK0ZflU3x0FcVHV4EgYN24I/bhQ7EPH4pN4wjTDD5Ig6JZzbvT2SOQ8XuWk1haQLaqlIHbF/NO28E86d+21p9DTRxLLjQtX40Q1JXmkb9jAQU7F6IvrWrernANwDa0J0WNu/C9wo6l6XEodVrQaCEpWnpUQkCghbMn33QdQxf3IA4nS7OKQa42NLmBQFCZrh6N8LJxIKu8hC3pl/ifphwrwLnXI7gMuLay9t3kWE6yqbPUw6vhVElcejzZFMES5mnPxsc6YWMpY9HFI4D0v3oytEuVYxTO3jh2Go9jp/FY+bYge/XLAGStmotoMOA+7AXuNP8UBZNVOQhNCxFLXfjpUg4vqgLwHPsB6UulCqHJ86SICcHKDoWjJ3IHDxSOniicvLFr3g+H9qPuuFj4+9l0zqZL3/VuQS6MbFlzEY1MZTHfxR5h0cUjphRegFnpkcy4tBMZYNdqEFOe24CsjioBu1nbcXrk86j0Ohwt677YTXaJmi+M1WCtFDLeGHj9CQyNXsfj+35EaQznnpJ6mjF9HsVj1OvXPc5Mw6apkwd7h86kj1EUTC0vZtbRdbwXuZMXWvXmydCuNVa3FmQyvKd9g6VXU7J+ewFEA0VHfsU3J555febz/O4cDCI8tjqScy/0vqE3ZW2wUVgwMbgdE4PbceTL0azKz+Av75ak2FQMelPKCkkpK2TP1Wq4VwOiSp0xZDTh/Z1xbIrJYvnEdrTyqf9q9//0DfQY/U6VCbP50fv4/Pw+aUUUIKUl1jonPh4eVs3Z6oemTh4M9gtlW1osscU5nPJvT4eEI+aU4VpwNVrQvuVA0n96grKorQCMV2+nh/Y0b0fN4u/zQYxs5Q1I1eR/7T2JbpsWohcNvHF6KwN8mxLhXndicCsXH1q53NhH3NK9Ed4TP0feazayqLXk71iINrci68ZFXcJ7J35hoGtjXm4+lGILGw7odExR6fgmPQaoFFVn0FN05FeKjvxKsk8ffrYfz+rCAERRilAf2MyDSe39uL+VN/ZWd2foGHn6b7KspHT8QI2c88ZghDm9gxumP65eh+XlXRgAg60bsdZhoIffzseDsWsbZF+/EcUNDZXOgMFwrdhzLqOkRk85M/cWMpkANQRin8v47/ij3m3uyZThu81XXe5nea+J/NRzQoMWAwHOZ1b82EKriRCUqLgRl0RurFXxhOd7B3P1/v3Z3iukFdXsj2QdGE7Qawdx6jYFuUOlqDhRRBV/nNy/3iHx3S5cesaHtCUPU3xybZWKqRHuAZwe+TwjA1oCUrXdN85speuOH3n9wCF2JCeQWlaIUqe5KY+VHbE5bDgvRbJZymW08XVElXSWK6+2IPevdyrEQEHAIWIMQW8epdkXyRwY9AJdsjNZkHxBEgOvg4jI+cIshmxfwp8xCSiN/mUDm3ncVAdILpNxf6D0/svkFhx3lio5e0/7tkF1pAyigdWJkab1jnXYyb4dNDpDlYi1pQ+0wdXWkr0ZV7hSIv2fh/qHEuRQc+fOffhLeD74mWk9+/cXKTy04s41uhL/TB8WFVpwzkbtc4GQdR/Qv6CQBW3HcdzZH60g3RZEdRnanARU8ccpPbuRwn0/kPbdJK78ryWq5MjrvNrtcSqlkBc3VlTDrskkPKYwi8cOrqbRHx/wztkdJjHQSiZnfuIhnjKKgRYh3Ql4Zl2diYFXsZQr7ogYCPDejkuUGa0IZnUPws/JpsZ9DaKBxzd+SbRRwGhWmsOH4f3MYuB/hGZOHhwaPouxlexEMstLeOHERgJWv89LJzaSXFqA3mBApdNSolWRr1aSXV5CurIYWd8nCXhuAzJjMYLyy0cYvnsi4/2l1MG43DLGLjtJZnHt0pFrS5vhLzIj6Rhbjv3IqpRjzArtSh/vELxsahjk2RdCk1PglsKZtCLafL6P8ctOcjA+r169z9J/eqKKb6D7fa+anvst/gxzT/xdsXNqKJS68nzvYAJd7l5ENcDM0AqP0O2ezQDQl+ahL7t+GnZsdildvjpAo/d30nbhSRq9v/OOtrOhcjVa0PexnxBsJP9OH0Mu3xe/Q/ziR1CVFJr27eQRyFttBwKgEw103biABReqj16pD2TWDrgNmUOTeVcI/iyeHe0+5HfrIVySS3YrvfITWBq5Bket1M8+7hLIlA6TMQhXh4ACSquKvnVgxl7ejJvF/KKP8dbnoDOIbLmYzdSVZ/B6ezvTVp5hd1xuvRv974o/ZVrOyJeyg3wcrZjQtmFke/0TZdwhDMpCAFzaj2DFlI7SuMei4lp7r6cMGwwi+mqu7+E+DrS+CxNCZhoe1goZtpbyav0FzaJx3XHPRgiauTEpBeWsjkwHwM5SToj7jTu8oqYcbUFajR54V2nibsfoVt6sjcokrUhF32+PsOeprjUOfG2C2uP35C+IBj3lCScpPbeF0sjNqBJOmPbRl+RQdPBnig7+jKCwxDasDw5t78Oh/SicXf15t/kYtCUObCk4BoLIFVU2H1xexweXK15HgRwnSxs8bexo7uxJH+8Q+niH0NLFC5mx85RaWM6cDef5I7LCy6R/Ezc057eR9t1kUwdAUFji1H0abkNfwMonlHKdlicPrWHxpaOm4+wUlswM68rTzbuj0etJKisgsbSAJONjW1os2apSVHodvyeeBSRRo8ct+BQJlYRblUyB/+w/61wkuR3KdVqmH1jFH4lSfoWFTE5Xz4bhH1iq0VGsqjC9P5VaRFs/Rwo0FUL26bw0UkoLCbB3rvE87sNeQJDJyFo1F4CsVXNwaDsC+R1IOf0nIY7uHBj2FK+d2sqG5POUVDIrP52fxmnnRnzXthE+op5pZdk8kHsJ+8J0dCXZpmgZAG1uIgnvdcPviWU4dhyHUqMjX6nF19Famsm7AaIook6OpDR6O/qyAiw9Q7D0aoLo2pgPT5by6d4E9MaBxogWXvQMrpoKdCAznk+j97AxJabKdguZnAcDWjBp37c0SjwOgE2Trtg/suKupj/fLPuv5PHN4UQA7K3kvNKvSY37ag16njj4B8vzpYkJK72WH/xCCDCLgf8pGju4sabfdA4lXGRR8mlWJZzBIIoUasr5LHovn0Xvve7xC7uM5tE3DpPyxX1ocxPR5ibytvYZIi3e4hI+bI7JpuVne1k4ujUT2vnWySSRbdNu2Ib2Qhm7n/ArB+nXqh+eY94B4EpGKjlyPTFFWVwszGZdcjRxxbmSIaFPPDjkY0gNY825DNacy8DPyZqBzTwY2MydAU098HS4M/et0qjtlJz8EwCFkzd+T/5iyjrYk3GZaQd+M+0rywrGUOSFm43iur/R+mJAJRuUZNuKa2bOhvfxnvh5tcdo9QYm/HLKFI19ryMIAs49H0LjF4Fq/f8oPSuJv4OKtnDhlVaEzv4VuzCpqvOr4f3YmhbL4exEdKKBZ479hZ3Ckkeadbqr7bf2bMwzz77Cq5vuZ/SeyzgaSmmju0hH8TJP5Aos9BJQyURi7dwJslZiV67HgEB3++8YpdjNI+VrCTRI95NBmsP01Z/mglVzcnRWlAk2lAq2lO23YdUBW363dabYJZRUu2YYFNYoZAJymYBckP7KBAFBkCrpCoBMkNpoKzMwpp2aoWGe2FrWbhiqK8xkh1oFxriE/DKpOMfsHo3vqr3A9Sg9t8W07NB2BG52FlgrZJTbFZm2h9Zge3QvIRcEDs7ucbebYcbMPY1ZEDRTI18fTECtkyLS5vQOxkpRu5QiQV47z7dvxrTmfGYJsTllxOWW0ffbI+x9qhu+TjVH3QgyObYhnbEN6Yzn6LfRFWdTGrWNorObUEZtRSyXbrSiTkNZ9HbKoreTvuJZNjkO41PFA+TLnMGmDfjGgU3ZNefXoSdPU0qeppSYoizWGg36Bb0F8nJnZEoXdCWOGMptuRoZOc0nj9dyvyRl/m7TeWyb98XvyRVYuPgCUjTTxH2/EpmfbtrnydAufNhhGK6VxIqmTlU7B6llhQSsfh+AcyVJgDTz73WTfi75aiXLr5wEwFGroqdOaWpbQyC7vIRRu37maI6U4qQQZHfMm+1WcLW15MNhYby0URKhnvkrmje2XuTBtj50cQ3maH48meUljNr1EweGPYXddYRWtyFzUCWdpejwL+hLcshZ9xbeU76ql/fRyN6VFb0nkZ2bQ5sf95IpZiJzKADbEgzGWdoMQc4n9j587RTI9CYRPNO8B80sLVGnnSfr95cpv3wYUaMkdeF4TjefwSzlAIp1Wpo6ejC7ezDTO/rjaF31GqAryaUsegelUVspi96Oriiz2vaNxZJOch+S5D5YOHowWPQhY/lyBJkMLXLeNsj4UV9VrHAVZDzi4MijTu5YH1mK0igGWvm1JHDOJgpVt276Xt+UqnU89NtZUyGnz0a0wKOG33qpVs0De35hS9pFABQGPV+XJNPzsfr5Lpmpf8IcPVjRexJvtxvE59H7WH7l5A2jzAFePrmJsWNfofFbx0j+bDCq5LNQlM4au9eZ6fI+h1Q+5Cu1TPr1NGvOpbNobHidiG7eUxeS8HYEok5D7t8f4NBmODYhnXC2tCHEzY0uxgmfd9sP4YPInXxwbpd0HbIvRNb0FIa0plDsQVqRip9PpPDzCSlyr52PHU9YHydCeRI3KxG5qAO9FvHqQ6dFkCtQOHmjcPaRHk4+pmWZhQ16ZQH6MulhMC4X7l9a0fYpX6NwkqwKdqRdYtye5WgNUtRuV/tWHImWJuUe7uB9zfXubmBdqd8lcwtAsLJDVJeRv/0rnHs8hHXAtQXrPtgZZxIDHa0VOFvJkckbprhSn8idfAh4bj1Rm5dQ9sccnMQyrEvTSPq4L+6j3sRj1BsoZHI2DniEuSf+5qc4aWL6icNr8LdzYpDfjQtA3UkEQeDjEc0J9bTjxb8vcEAZwQEiIA8oUYL/RbAt4WofVmUlR+NYzEbrwTj0eJjJ8qP4HvoIQ1E6FnoVbZRnqn8hJZALWuTEyRtxzqIZUQrpkSD3QwBsRJX0QI2tcVmHnPVnAxCtHRjR3IvxbXwY1vz64mDaoeUcMVbotVfrKVXb0SfEjTm9q7cbuhucTClky8VsLGQCtpZyuh7bgB0gCnLWlofx1JJjlOt04JgLgJuVbYOZ9DZjxsy9jVkQNFMt5Vo9Px6XDKltLGQ8X4PHX3UICsta7eftaM2ep7rR99vDFaLgosO8ObAZzjYWOFkrcLr619oCmSBwJa+MSzllXMopJS5XWo7L8SBPORmF7YO0t7hAH80J+miO08ggRfDJMHBf8Ub6CLtZbDOeFeJ9NFP2xt+lEKWinMTiYjKVpWhEDch1INeCQmuqUgogyrXo7HPAPgc8AZUtQYWeLBf24ha9Fl2lkHf7diPxf+o3ZJY2FKiVvHt2BwtjDqETJWHCXmHFku7jmBDc7oafkb+dM61dfIgqyCBZnQmyYDAocLWt3Wd8lSWxR00Dx7EZUTha1d5/8E4TU5jF8B1LSSjNB8DJ0po/+06nfx0VfqkrXugTQmqRiq8PSB49RSodi4+mgMwHq9As1PIyzuSn0XztZ9zv35buTs0RtdZklqjJLFYjIvJ8r2C8Ha3xfPATSk7/hUFVQv6ub3Du/Vi1A7Y7hVyQMSKoGT8cs8aQHcSmJ9pRbpXP7wlnWZsUjV40UK7X8l3sEb6LPcJQvzCeCO2CauJX7N25lOTCFBJtXUi0taRcLnkoxhW588z6Yr7YeIDHgzWM8irFtSwJ5eXDUiRvLdL+bNDQTJ9EM30S5IL6AKiBPAsb5rS8j5POFSnkAeUFTE85xf2Z57Ex6DAgjU8AFM6+BM7djNzOBVR51b1Ug+SljRdIyJfexYCm7jzZtfrBQnZ5CcN3LuWksbq1tV7L5xc2MvnxpdXub+a/RRNHdxZ1G8sHHYayJPYoO9LjEBFRCDIsZHIsZHIUMhkpZYUcy0mmTKfhrTPb+b77OBq9spukeUNQxR9HXpbDEl5lefhXfBwnpUmujcpkf3w+345tzfg2tzdpZB3QGo8x70neqQY9KQvH4fvYj+Bd9d5nJVfwbvshDPYLZcr+lSSWFmCQayHwAoFiY/LjAyk1BmN305zhhQs/EapPBKBms5Fbx7Z5Xxw6jqNIU84LJzbyw6VjpufGNGrNkQM+gBqFTGB6O+870IKbR1YpqtMgt8Tj/rfJ/v1FMOjJWP4UQf/beHcNOAAAteJJREFUXyXy83RqIR/slKokW8plHHq6Oz6WWtzcGk5xhruJIAiED3+Cx9L86Hz8Dbprz4AokvvXOyhj9+M341dcnH34sceDeNs48NG53ehFA+P2LOfAsFm0cb37E64Pdwrk/lbevLk1lkVHkqTIe40tjukRWHimIyD18Q0yARqdRyvIuOwcxBG/MPp330XgwaUU71+K4QZp5xboaaGPp4U+nglIHox6ZMhrMv4ykirz5FJuEPsPB/GLdTB+oR3o2iacxq5WBDha4m1ngVwQwaBn4+nNqP0jpPYWexDu48RfD3esdaDCnebHY8k89kekqZvjoc9jb4E0WXdKHsrD643ejvYFprHF6EatUcgaRvvNmDFzb2MWBM1Uyx+R6eQrJQFpcnt/XG5CgKpthCCAj1EU7PPtYaPQV8aUlTXMRt4AnaDguGU4xy3D+VR8hMb6NAZpDjG9/C+cxDIcRCVzlct4wWYffr0+RRPcF3d3yTdFFEUu55ZxNKmAY8mFHE8pIE9XRLllPkqLPMos8tDJKlIssVaS6J3IkyU2zHYJold+AlbezfB84BMc2o9CLxpYfPEwr5/eSl4lT8U2rr780WfqNZGA12OIXyhRBRkYEMGuEErccbWt/WesNehZGHMIALloYFLaGWQ+zWp9/J1kV3ocY/cso0gjeaoE2buwaeCjtHBuGIOsygiCwFf3t2JqB3+WHktm5Zk0KY3YoEB9pQUEnwGFjhRlIQsu7WWBuBdKXaDAB0rcQJRxIqWQ3TO7YeHsg8f9b0lm/wY9mStm0+iVPfXq5zigqTs/HJMGBMcSynhnSDhjg8JJLi1gYcwhllw6RqExJXpL2kVTJBpWduBVjYG+Uy5N5Rf5NmotvoclD8/8al5Xb+VISWBP8vx68tMVBUJBIo30GQTqM2guzyJAlwHait9MtIMXz7YcRabRA81ar+X1uF2MzLyAnGtFRpm1A4FzN2PhFngbn079s+xECosOSxGyDlYKlj7Yptrvw+XiXIZsX2LyrnTWlrPo3Fo6uAVia0xnM3Nv4Gply8vh/Xi5hiqnBWolIWs+okBTzg9xx3i2ZQ9aOHvT6KUdpMwfgfLSAcSyfKafmUn/0cuYdsyejGI1uWUaHlh+irm9C/h0RItaWQHUhNvQuZSc2UB53CF0+SkkfzoQ644TcHpoIQr7quJTd6/GnB01h9lH/+KXK5JfWLKQgGvzLB53DGT4kRU0zd133deLsffgD59wEm1dcNMo8VKX4qUuwVNTire6FE91KR6aUhQ1TFDIrB3wnrKALakXeeLwGtKUFel99wW0YLRzX9YWSx6qY8N98HG4ucm5O4UgCCgEGTrRgE404Db4WYoO/ow67Tzllw5SdGg5zj2mA6DW6Zm+6iw6ozXDO4Ob0crHkby8f8/kSX0xd1QvWsW+zdTy9cwpW4YCPcqYPcS/0Ra/J1dg32og77cfQmJpAaviz1CiVTN8x1KOjpjdIDIcXGwtWTCmNR8Oa06ZRoerraUpxXb0uK1V9tWJBvZnxbM/K57Xka4vA8Z/xZNNO9Lb2RN9eTGG8mIMqmL05cXoCjNQJZ6iPP44qpTIKtYiNxIDAfwN2fhrsunHcUnZP2p8AGXAlUr77ggbbFq2J4Qtj3fGyebuR+bCtWIgIAnIRg5atjctBzcuJ964X2VfWDNmzNRMrIUtPTYtvGb7OZti7AyOgDnl/HYxC4JmquXbQ4mm5Zndbi6kvbYRglfxcbRmz8xu9F10uEpV49oglwkEudjQ2NUWF1sLnG0scLa2wMlGgbN1a5xt7kNn+RZOZ76maM8iMOgR8xJJ/eYBLII6YTv5c2yadkcQBJp62NPUw56pEdcWshBFkej0WLYc+IW1WYkcc5QqwMU4ePFU+Bg6WlnzUc8pNAkIY3d6HM8d30BUQYXHoL3Citfa9Oe5Fj2xVtxcJ2aIX2iFR5RD/k0LgmsTo0g1DmoG5MThqy5BZut0U224FdKVRezLjOdURiKW1laIolQAQUQq7FKm0/DDpWOmyMnOHoGs7/9wzabzDYSIAGciApz5fGQL1pzLYOmxZPbHAwltwStB+h8JopSN41AgPXQKKPRiT6KGPZdz6dvEHdeBz1Cwfyma9BiUF/eRu/Ej3Ee8Wm+iYL+mFSbiO+NyeGeIlOYUaO/Cpx1H8GbbgSy/fJIvzx8griT3muMFA4So8mlclssx5wCKLWyIs3dnQofJfB29nrbF0vffgMB5RRMOWrTnoGV7ohTN0BfI4WrQgXUz7CzlfDy8OQO7BSEIoCvMwFBezIq0WGZdOITaIH1HAq1s+a1ld9r0egBRp8agVSPq1Ig6DaJODXodtqG9sPQKuaa9DRWt3sCLf1/gqwMV1SG/GNWy2iIFJ3KSGb5zKTkq6ToZoNfw3elVBJUXYDv2kwZVIMjM3cfFypY32g5kzvENGESRl05sYuPAR5HbOBL4wlZSFoylLGorBlUpfmsmc/LxVbx8JZAVp9IA+HxfPCmFKpZNbHvLVYgFmZyAp9eQtngqZeelghWqE79x5eJOvCd9iWPXSVW+t06WNizvNZFh/mHMOPInRRoV+RolS3IvsqpxayZZ6piecgorz1bsCJnFjgJXTmeVonQsQOuWg2hbWlNTTFjoDfiUqvAq0RMms6Wvlx+dmwTRyM8XpVsQT0bvY/mVigIGzpY2fNlpJNOaRNDrm8Om7bN7NIZqJiXuFnKZDJ3egF40ICgs8J72DUkf9QEg67cXcWg3ErmdC+9sv0S0sWBcp0BnXujz77le1jfNvRyYEhHAspP3c1rRnG9Vn+OqzkRfnE3yvMG4j/gfHqPf5qceD5JWVsT+rHjSlEUM27GUA8Oewsmy5oJQ9YmDtQIH66pDPpnxq2ut1jOnZS+2p10iurDCziNfrWR1YiSrEyN5tGkn5nW8D2ePoKon7v0oAAZNOarkSMrjj1EefxxtdjyCpQ0yK7sqD8HSDmVRHkJuHKqUcxjKqps2rIpOENjnJn1HLfSwa9qQ61oL1SdLjyXz2OqKImvP9wpmQDN3XNcuhkvSti4DxxPsFEZTD1uejD4BaikTpp/P3fceNWOmoROqrTkPQCkz+9/WFWZB0Mw1nEop5FhyIQCdA51p7+98U8ffTITgVXydrImc25vNMdlkl6opUukoUmkpKjf+VenQ6Aw0drOlmYcdzTzsaepuR2NX29oZCrdegPuAWWT9/pLJKFqbeJzED3pi4RGMY+cHce42BSu/Ftccqsm6Qt7Wz1Ec/JkRmnJGAMecA1gQ3JMzRmHwhFrFgJ0/0MzRg0vFORWfBQIPNY3gg/ZD8bG9tYpZ3b0aY6uwkFJ+7SWxyekmPIu+vHDAtDw19TQAcuu6r96l0mn5Kzma3RmX2Zt5RTKJryXjg8JZ1nMiNjcplt5NbC0VTIsIYFpEAHE5pfx4PIWDCQFYGXQUW6cRb7hCnt4YXaLQgXsaOGcxc4eOmJAHpAHblK9J/lSqVpiz5jXUKVH4PvoDsnpI6fawt6KNryOR6cUcSy6kWKWt4oVlb2HFk6Hd2HHUgrjEC2BXBDoLmjl58lSH5jzZIRRZYSqpX48mNv4AT7ceTbytK3mWdkxvN5FemTLyMj2Jl/tTIqupQjn0a+LODw+0obFbJQHMyYuXYo/zdUxF5cZ+Pk34vc9U3K0bTrr77ZJdoubBX06x90pFZM7zvYJ5pNO1kxJbUmMYt2e5KfW/naMbX2x9Hw+NEkuvJli1GlJv7Tbz7+GpsG4sjDlEfEkem1Jj2J0eRz/fpsisbAl8bj2p302m5MQaRK2Kwu/Hs/DJFQxs1o1Hf49EZxBZHZlOerGK9Y90vGmriqsonL0JfHE7RYd+IWvVHKn6bUkuad9PofDwCnymLkTh5IU2PxVtQSranET6ZMSwLfsyn6s0rPMMQyeTU6qwYnGjLvzauBszW/Skn08TstPjOBMXg0ZT++RhrVxGspMtyU5wAvjFkAVR5ThFZaF12IJSrDjXyICWLOo2Bl9bJ86mFXEwQRIw2vk50i3Ihfz8Gwsa9YVCkKEGdMYJFLuw3jh1m2ryq81e8xrJfT7gk91SJTVrhYxlE9qiMPsGXpfP72vB7rhcoopCGS6fz5+eP+KbslNKIf77A5SXDuD31G+s6/8Q3Tct5GJRNlEFGYzf8wubBj6KRQNPC5UbRD7vNBKQJnJ3pF1iR3oc29NjTZNPS+OOszn1Igu7jGZ0o1bXTD7JLG2wbdIF2yZdbvh6eXl5uLm5IYoiusIM1CnnKE+OJPXiSUoLsinXgVInUqaDNFHBNk9vCi0kYbWvT0taed/5Ce3a8MPRJB7/45xp/bUBTXlvSCgY9MSmHsQAyJ28ePj+EQgyGbvS40wZQ6MCWmIpvzeG4L+/+QA2eRerfc6yaWs0soYh7pppmLxfJE2WN56x+JrnHH/4sL6b85/l3rgambkpfjIadwPM6Bp008cfzEvj0/P7ae7sydyWvfGupRBmbSFnTLjPTb9ebbHyDSPw+Q2Unt9J1qq5qFOkG7k2J568jR+Rt/Ej7Fr0x3XgM9i3HY42N4ncDe9TeGg5GCr8BJFbMLjtUCaPepNdymJeP72V03lSREVlMbC7ZxBfdh5FhPu1g/ubardcQT+fJlJVVUs19u4FtU7h+iMh0lSoo6OzJ22LpaImMuu6jcI7lJXAo4dWE1uUc+OdKyETBF5u3Zf32w8xVXH+N9LUw56Phjevsk0URQ5lJ7L00jFWJ0ZKQo5CR6ziBO8d8+PNLj2wbzkAzwc/lTy2RJHiY78hd3DHZ+qCeml3/6buRKYXozeIbI/NYdw/PMMWHU7kr+gswA1HnRd/PdyRPiFuFYMBjyAav3OSgMJMTtk6MXH/KramxaITBHb7iCwcMhBdqfT7lwmCqcqg9Bcau9oysJlHlcGFzqBn2v5V/JZw1rTt+Za9+DRi+H/Gb0dvEPn+SBKvb7lIQbkk8FkpZCweH860f0Qoq3RaPjy3iw+NHlUAg3ybsTDjLFqNNLhwHfw84n/kszFTt1jJFXzUYSgP7l0BwPPHN3By5HNYyOQICkv8Z64i3cqeooM/g15H2qKJjJm7Fb/HOzNm2UmKVToOJuQzePFRDszqfuuRgoKAc49p2IcPJfnnWahO/QFAWdRWLr9UfaSMA/A28GTCIX4K7skar+aogTKDgXnR+5gXfW36cCf3AJ4M7cpA7+YUa1VklheTqSomTVlERrn091h2CsnKSkKeTAT7Ioooqgj40ynwKWuJl11r9l4soYm7gRlrKgb/s3s0bnARuXLjPVRbqb/iNeEzSs5uwKAsomDPd7yZ2g2DKAkqHwwLI8yrYUfkNwTc7a34fWoHen17mGLsGVw+m70D+uC25x3Qa1HG7id1wVgav3GYzQMfpcvGBWSrStmRfonnj61nYdcxd/st1BpfWyemN+3I9KYdMYgGfrl8iuePb6BAU05GeTFj9yyjmaMHT4V1Y3qTCERE4kvyiS/J40pJHvElecSX5JOrLsPNyhYvGwe8rO3xtnGQlm3skau0OBvKEJCuC/i2RPBthdBlMoXKIk7lpXIqL5XTeWmkK6tGAD3VquPd+WD+wYnkwipi4OsDmvLukFAEQUAZfxyDshAA+1aDEWTS77KyF+nYoPB6be/dxCbvIj5ll8mwu/Y6r5FZY7BoGFG0Zszcy5gFQTPXUNkH43hKAQ9VE61SE98HdWXh9sUYRJFNqTF8E3OYmWFdeal13waTCmrfcgB2754mbddSDFEbKI3eDnppUF52YRdlF3ahcPWXKqFW8kSR2Trh0ncmrgNnmyr0DnX1Y4hfGOuSonnzzFbOF2YRYOfMpxHDebBx2zobMIxr1EYSBIEyz2j+Tj7PfYEtr3vMgcx4ph5YZVqf27wHwgY5GPQoLx9GFMU6ad+8qL28dHITYqXUKWu5gm6eQfTxDqGFlQverm7IBAEBwfgXZIIMX1vHW46cbOgIgkAPr8b08GrM/E4jGb5pJUeKpFnSzy9t59n2HXCytMF92IuUxx+n5MQaAESN8nqnrVNGtPBi/r54AN7fGceY1j5VxObC8ooKpnN6BdO3ifs15xBkcixc/XAGNg54lOePb2CBMbIvTpvEl71G1bo9KaWFTN7/KweypBlBa7mCxd3GM7VJh1t4dw2TA/F5zF4XTWR6xUAnwNmadQ91pEOAc5V9d6fHMePIn1WibaeGdOCH7uNJekXycRQsbXHu8RAFpXeivIKZ/wLjg9rwhccBjuYkca4ggy/O7+el1n0BEOQKfB9ditzGkfwdX4Mokvb9FHq9d5aDT3dn2JJjpBapOJlSxHPrz/PduNsbyCocPXCavAjPvo+S8fMMtLmJ191f7uBBq16PsGz4K3wmyPg8eh+LYg9Xqa5sq7BgcnB7ZoR2pb27f6WjHWhJ9X69Vy0tNiVdYmf6ZbI0lQonFLlDelMy9JYsSUlhybGUKsf6OVkzoZ3fzb71O463jQPFWhVxxbmodFqsFRYonLxwH/E/06STV9pesBlFl0YuPNuz4VRobeh0a+zKR8PCeGljDAYEhl5ox6HJK7FYPh4AvdFWo7GDG5sGPkrvLd+i1Gn55uJhenuHML5xm7vZ/FtCJsiY3rQjg/1CmXV0HWuTogBp4vu54+uZc0KyIqgvnm/Zi5E36PfWF0uOJZmWX+3fxCQGgjSOuIp9q0EArEuKMk1yulnZMsi3Yfh41weLApuTZNMR15BrCymmFmQQ7nLnAkHMmDFTO8yCoJlreG1AU1acTqVYpWPR4SQmt/ene2PXGx6nslTwdVC3KopiuV7L/PP7WXTxCE+FdeOl1n3wbADCoCCTY9N+LG4Dn0Bfmk/Rsd8p2LkQdfoFAHT5qaZ95Q7uuA17CZe+M5BX03ZBEBgT1JpRgS2JLc4mxMEdqzpOBejlGgb5PuCagSiIjN2znHX9pjM84NoUZ4ALhZmM3PUTaqOgOTOsKw+EdiWl9WBKIzejzb5C4d7FuPR98rbadaEwk1dObTaJgb28gnmv/WA6ezQyfQZX00PuZVysbHkt7D5GbMsD5xyK9UreOrOdLzuPouzCbpMYKFjZ4T7y9XprV58QN7oHuXAosYDI9GJ+P5vOxPYVA90H2/ryxtZYADZcyOKtwaHXPZ9cJuPDDkP59uJh9KKBvZlXrrt/ZdYnRfPIodXkG1NqLGVyNvR/hIF+/52O86LDiTz1Z5RpXRDg0U6BfDQsDHd7K9P2XFUZL5z4m2WXT5q2WckVvNtuMC+26oO+OBtttvTZ2jTpgszKFsyCoJkaEASB77qNpcOGL9GLBt46s42xjVoT4igJ/IJMhtfkL9EWpFFy8k/0JTmkfTuBVq/sZvuTXej45QHKNHq+P5JE10YuTO94e1HvAPatBxPyYTT5uxZRemYDgpUtFi5+KFz8sXANwMo3DEufMBQOFZMQPsC8Tvfxcnhffoo7weXiXDp5BDI+KPymvdp8bZ2YGNyOicHSIDVTWcyutCtkFhooybdnn2UeR5MKUOmqFkdo4WXPH9MisLnFSMk7SV+fEC4V51Cu13IkJ4m+Ro8yhw6jJUEQ6KyN4hebUcztHYz8NorF3Iu80CeEqIwSfjmVSplGz08bt/KE8TnHLhNM+0W4B/Bd13FMM07Izjq6lsF+oTha/jtTI71tHfmz33S2pl7kqwsH2Jom9QmuJwbaKSwp02lu63U9re3p4OZPezc/hvk3p5tX0G2dr65QafWsPitl2zjbWPDmwGZVJtfLLuw2Ldu26EdMYRZPHFpj2rawy+ib9hL/N5NkY0+irQPVjSLDXXxobRYEzdwAdco5Et6/tnCIv2MoanPKeZ1gFgQbMOU6LSllhdc88tRKQhzcCHf1IdzFhzAnzzr1ovB1subTEc2ZsUYauD62OpIzc3rVmCqklwnIDSI6ow+NXJDxbrvBlOrUfH3hIGU6DeV6LZ+fl2b2Z4V155XwfrhaXWuafzeQ27vi2n8mLv1mUHZhNwU7F1ByZgNyWxfchr+Ea/9ZyKxr9kAznUcmu2PVcS9ml0F6U0AE10y0Bj1jdi9jWc8JeFrbk1JWSHKl78iJ3BRThdhRgS1Z0Hk0giDgNmQupZGbAcj89TlsmnTDOuDWK529cHyjKY3xldb9+KDDvzv1907iZK2AzBCp6Ihcz4KYg0wPCsd+6SOmfbwnzsfSo3G9tUkQBD4e3pyeRqP817deZGy4j8mXs6mHPT2DXTkQn8/p1CLOphXR1u/6/j32FlZ0dA+QopHyM8hXK6/7W1fptLx4cqOpEjZAiIMbv/WZctvp9g2JBQcSeOavaNN610YufD26FRGVogJFUeSXK6eYc3xDlerk/Xya8F3Xsabq5Mq4isIGtk273/nGm/nX08bVlxda9eaTqD2o9DpmHPmT7YOeMA1kBUHA99GlxCedQZsTj/LSAQr2LqZ5/6dY+kAbJqyQ/GdnrDlHWz9H2vjevo+XzMoO92Ev4D7shZs6zsPa3hThWFd42zoyuWnVCBa1Ts/x5EL2x+dxJLGAZh72vDckFDurhtl1HuDblO9jpTKtu9LjTIKgpVcTZM5+GArTiNBG42UrZ2TLO9NX+S8jCAI/PNCGlMJy9l3OYUjhJuMTMlx6P1Zl36lNOrA17SIr48+Qoyrjk6g9fNBh6F1odd0xxD+MIf5hXC7OZdHFwxzISsDD2o5gBzfpYe9qXHbFzsIKlU5LtqqUrPISMstLyLq6XFSAtY21KXZArJRf4mRhTTs3Pzq4+eNr69jg0vIBNsdkU6SSJtvHt/GpMjYyaMopvyzdny19m3NKo2H4zqWmic5Jwe2YEHxtpNx/nSBlCQeHP323m2HmX4i1f81jVEuDqh5b8t+mYfZq/uNcLMyi0E6OQRTJVpWSWlYkPZSFpJYVkVScR4a6tMqA8HooBBnNnb0Id/GhmZM7oih5yGhMDx0avR4fW0eebt69Vqm7j3duxK+n0zgQn8/F7FKmrzrLqintq6QT6g0G3ovcgcpKhl255Fnjo1OxZuQLppm8OS17My96LwtjDlGm06DUafksei8bUy5w7L5ncLBoOMq+IAjYt+yPfcv+6MsKECxtkVlY3fjAeiAmuxQQIL0ZvZu4sS//PBqDnon7fr3ucV09GrGy92TkRg8Tuxb9cBv6Anlb5iFqVaR++yDBb5+4pSIW29Ji2ZImpcCGOLjxdrtBZjHwOjjZWIDOCrKDwOcKBlFk5p5l/JCbhAywaz0E5z6P13u7egS7Mby5J5tisonPU7LwUALP9wo2dcQf7hjAgXjJb+unEyl8dQNBEKC3dzBHc5IQETmQGc+oRq2q3S+2KJsH964gMj/dtG1ScDsWdR37r42mqI4v9l1hzoYLpvW3BzXjjYHNkMkERFEktiiHvZmXWRV/lv1Z8ab93Kxsmd9pJFNDOlQZGCnjKsRTsyBopra81XYQaxLPcaUkj53pcfxy5RTTmkSYnpfbOuE/63cS3pZ8uvK3f4VL3xk82M6PI0kFfHUgAZXOwNifT3Ly+V442/y3o1ysFHJ6BrvRM/jfEeHe17sJAgIiIjsz4ngfSYASBIF0j054F67DQVTyXEhx7YqxmbkGS4WMtQ9FMPPjrwjMkyryRjt3xUnhQXJiPvF5SuLzlcTnKbmc74lgLUMUDMw/v48ZoV0JsHe+u2+gDmji6G4qQnI9rBUWBNq7EGjvUmX7vzVrpFSrZnHsUb44FQmOdlDizpT2/lX2UcYdRjRGRh4NG8ATW7+j3GhJ1NkjkG//RX6SN0PGzzNRpUZV+5ylfSNz4RAzt4zPQ4tqfE7z9aP12JL/NmZB8C4wcNticK27tFmdaCCqIIOogowb7vtT3An+7DeNzh6NrrufTCawZHwbOn11gGKVjtWR6fg7W/P5SMm/I1NZzKR9v7In8wqDkQaqCr2BzcUJtK0U1u9ubcfHEcOZ26o386L2svDiIZQ6LTFF2cw8vJZfek1skDOAcjuXG+9Uj1zILDUuCXwRMZovr1iz/MqpGvd3sLBioG8zvu82DltF1cqQnuM+oCx2P6r442jSY8hc8Sy+j/5wU+3RGfTMPb7BtP5ZxxF1nib9X8PJ2vj55Pnh7JtHoVjIsfJS1nu3ZHTmeTxGvnbXfgsfDmvO5ovZiCLM3XCBFadSebp7Yya292N8G19mr4umTKPn97PpfDGy5Q2L2vT2DuaTqD0A7MuqKgheFcC2pF3k9dNbTF5gtgoLvukyhulNIhrkNeFWmbfnCi9urBADPxgaygOdXFkad4w9mVfYm3GFjPLia46b3iSCeR3vq7aqcvlVQVAQsAm5cVVHM2YAbBQWfNdtrNQHAeYc38Dl4lxsFBbYyI0PhQWlHR7AM3YvLTIvUXZ+B/atB/PpiBacSCnkcGIBV/KUPPr7WdZMj7jBK5qpT9ys7Wjn5svpvDQpS0BdjrOVlEq9QdXMlN460ibu7jXyP4CLrSXvOB3iaumWb/T9ePDdndXv7OkPnsmo9DpeP72FZb0m1ls7zdQNRVoVi87u5IsL+02RfgSCTG/J1gILGpV2oZG9lBCrjJHShdd7teANgyV6pP7NUL8w/ug7FbsGEmRQ16hSo1CnnMMq4FqPWY3M2pzWacZMA8c8gm+A2MgV+Ns5E2B8BFZaDrBzxtnShkvFOUTmp3OuIINz+RmcL8xEVakARk2kKYvotflbvu06hkebdb7uvqGe9qx7qCNDlhxFqxeZvy+eAGcbOjSDCftWVKr+JQX7W2t0uNcQfehhbc8nHUcwI6wrHTZ8SYGmnF/jT9PXJ+SG7TADMdklAMgEaO7pwI8+D9LC2YvY4hz8bJ2M3w0n03fken5KVytLxr/ZDkN5MYX7l2LXoj9OXWvfUf3h0jHOF2YBkvhzf2D1EWBmKnC0vhpNI9BC347DMkkw+zy4F4MMKmyadLtrbQv3dWRm1yC+PZwIwJm0Yh5dHcmLGy/wSKdAbCzklGn0ZJWoOZFSSOdG1xfMu3s2Ri7I0IsGfk84y0DfppzKTeNITiJHc5IrOtVG2rr68lufKYQ6edb5e0ssUPH05lNsjMnC0cqCJu62hLjZ0czDjr5N3OkY4Fzrqt03y8e74nh180XT+guDvPmt9G9e+7PmyZtQJw++7TKGfr5Nq33eoCmnPFGaDLDyb43c9vZTN83cOwzwbcb0JhEsu3ySPLWS9yKrETIcAiBiKt3yE3lz9/cMbj0YS4WM1dM60G7+fnJKNayNymTBwYT6fwNmqkUURf6KzkRX7AykYRBF2n2/Hn2RG/lKLU7lTUyCoF3KoeucycyN0Bako4/eCECG3IODFu1r3jk3AFwzQKHllyuneLZFz38UvjHTUFHptHxwbhdfnT9AiU59zfMGuYaPonbzSfQehvmH8VKrvvhd2M2PARF8HtLbtN/UkA4s7fEAFrKG5ztal1gFhNP49YPXbE/94cO70BozZszcDGZB8C4wvUkE9p5SuLy7tR3+ds742zrhZ+uEv50T+hIl7u7XVvOsjJ+dk8kfBqSIrcvFeSSVFWAhyLCUK7CUybGQybGUyRERef74Bnamx6Ex6Hns0B8cyU5iQZfR2FzH3LZfU3d+erAtU1aeAUslz59eDVcqKl42snfBRl1pUHCDG15jBzd+7jmBUbt+AmDmkbXYKSzvSU+N2lJUriUqQxIEGzlbm/xKXg7vd8vntPQMxufhxaR9KxlhZ61+GccuE2oVmaXSaXn77A4ABATmdxz5n4roulPYVvKZUaicmeDlwm8lBRRY2vJp+Gj+kN3dFK4Fo1vRK9iVbw4nmlKE85Va5u2tWhhkZ1zODQVBR0tr2rv5cSI3hXRlMcN2LK1x32ea9+CTiOF3zGR70uoYLuVJfpqlaj3pxSr2G98fgJeDFcObe/JCnxCae9VN5LbeIDJnw3m+PlBxbXx7WCN+yF1PqrKoyr7Oljb09g6mr3cT+vqE0MrF+7qp9wV7F5uqopvThc3cCp93vI+9mVdIKi247n6HXYMYKopM376YD3tMwM/JkRWT2jFkyTFEEV7ZFMO/2xXtv8PeK3mM+fkk2MnAaEObqM6AQinCuEzuRa7gjLtYSPmVo3expf9+ik+sAYMUH+jYbhS9FZ44WVsQ7GZLsKstwW62BDlb4VUQyaL1u/g805kC/xxEYNzWNRy/f2aVIlJmGiZvntnGZ9F7TesWMjme2gDSUuzBORsLlzy0oh6DKLIxJYZNKRdp4RzCeYcKf84XWvXmk4jhZjsdM2bMNGjMguBd4P0OQ/H3r3mGMO8WqkUqZHLCnD0Jc645wmbLwMd47dQWPjXe4JbGHedkXipr+k6jiWPNAuTAFk507pLDsZIYECqqig32C+XXXpN44rdppm0lJ9agGfMelp7BNZ5vZGBL5rTsxfzz+9EaffCyykt5tmXPm3jH9w5vbYulRC1Ff3Zv5Fhn53Xq/CA5695Gk3ERfUm2VB26FsLe7wlnySqXBMpJwe3Ms921ZPulHNNykKstLxmUbNaWU2xhwxqdiP/v79HeaKbd3s2P9vVsqi2TCTzYzo8H2/kRmV7EN4cSWXEqlXJt1SqbIW6185ucGNyOE7kp12z3tXWku2cQ3TyD6O/TlNaud7bCXH651rTs52RNWlFVE+KsEjU/Hk9h1Zk0Fo0Nv+0KqhnFKh5fHcmmmGzTts9GhvJH8RaTGNjU0Z0ZoV3p69OEcBcfk8fnjSg6+htZK583rTtE/Df9iMzcWdys7bgw+kXOF2Si1Gsp12kpr/S3SKPi2zNbuKLTIQoCP6dd4o8/P+aV1v2Y06oXo1t5szYq85prg5m7x6EE4ySHvmJixUIhcPXq101zBnexEADByQ8zt47Cycu0bB+5go0vP4xt044YNOWURe+g5PB6Ss78TWZJDqOB+wSBAW4zybGxIUGTSuPPNvNyj5Y83yu4wRaoMQOn8lJNy083786LrfowfFEkaaUlOOm8uDyzFz/FHef72KNcKclDRKwiBn4WMYIXWve5Cy2vf67klqHU6pm64NoIQaVcj63lfzs60oyZfzvmO9E9hEIm55OOI+jkEcjDB3+nRKsmMj+dDhu+5NOI4bha2aLUaUzFP5R6DdnlpSy7fIpSnRqu6hJaK54N7cv8Xv2umfUSdRqyVr9MwNN/XLctn3UcgV4U+erCAQCeO76ejPJiPuowzBxtVolz6cWmtCx7Kzkv9wyss3OLoog2XxJsLD2bINRClBBFkQWVqsHOadmrztrzX+en48mm5akd/HE5kMV7sft4ttUoQErnT1MW8XdKhd+cl40DXT0a8VCTCIYHNEdRTyknbXydWDy+DZ8Mb8622ByOJhWQVaJmdGsfHmjrW6tzPNuiB+U6LSdyU2jh7EU7N186uQcSYOdcr7/xEFcbcpWSgH3lf/0wiJCQp+RUaiEbL2SzNTabYpWOcq2Bh347y74reSwc0wpby5u7PeoNIt8eSuT1rRcpNlYgtJTL+PHBcP4u2cdxozga4uDGkeGzcavGG/B6lEZtJ23xNK6WZvQY8y72LQfc1DnMmLmKrcKSjh41309mNenA+58OY4F3a4osbCjTaXjjzFa+jz2CHy0ACyo6BWbuNhezjT7DFhWpjbM6hfJznkCJUsXLZRU+wd/aTOAzncFcWOQWcez0AGUXdlO4dzGiVkXKF/dhG9qT0ujtiJprJ/QVosiU9BN8EdILBAhW7OKTzWoWHkrkhd4hPNE1sJKliJmGQkpZIQCuljYs6DIawFQNWSETcLe248XWfZnbqjefRu3l1VObAfBVFfFxUTJTW8+r/0bfJZRaPWUafbXP2VrKsTMLgmbuEMk2dkR890S1z7W0smHZw1/Vc4v+nZgFwXuQsUHhhLv4MG7Pcs4VZFCsVTHjyJ83PM5ObkVZmi/k+bGtQI6hR/UZwiUn1lB2cT92YTWLRTJBxhedRuJj48ArxpvoJ1F7yCwvYUn38XfVayO1rJCPz+3GSq6gn08TenkH35VqyKIo8vS6KAzGHsjbg0LxcbC8/kE3ga4oE1FdBoClV/V+Zf/kSHaSada0u2eQOTqwluSUqtlwXvJcDHSxoV8Td1I3ZjAg9zJfRq9ny8A5nC7IJEdVVuW4rPIS/kqO5q/kaPxsnXi0WScebdrpmqp9dwoXW0smtPNjQrubjyiRCTL+16b/HWjVzRHiasOxVKMgmKukhbeD6TE1IgC1Ts/LG2P4ypje+9OJFE6kFPLHtA6E1TKF+ERyITP+PMfp1Ip0YC8HK9ZM68CuolP8nnAWACdLazYOeLTWYqAoiqgST1Ny9m/yNn9mShV2HfgM7iNfr+1HYMbMTWNlbc9zHUcxbM1rLG7UhV/9O6AVBFKVRaRyBHz8ICPkbjfTjJEYoyAot9KYil38dCiHIqUz/yv7gSZ6aULihKIlXxe1oezPKJY8EG6egL0FBEHAZ9o36ArSKI3chL4sn5LT66vsI7NxxD58GFb+rSg6tJxRWef5OrgHekFGnpuanVce4W9lX779awTv7wziqe5BPNszGC8HcypxQ0AURVLLpPu5n3VFZo7BOCFX2XdYJsh4Jbwfvb2D2bVoGoOTjuLsenuZBv9G7CzlHJzd45rtPTadrf/GmLkncNPKgDKoRnC+KLcG9c1nXN6rmAXBe5SmTh4cGTGbWUfW8vPlk9fd11Im5+nm3Xm1dT8e/DmK3bm5XMwuZenxZJ7sGmTaT6wULZC1ag6N3zp+3agzQRB4ObwfXjYOPHboD/SigWWXT3KxKJvvu42jjWvtIpHqko0pF3jowG/kGYsezD+/H4Ugo5NHIP19mtDftyldPBrVS0XdzTHZJi+3Fl72PNOzMcWF1/d8uhk0mZdMy5bezWp1zIKYinSA2c2vvfGbqZ5fT6ehMyq7D0UEIJMJ6AqlwhKDitN4ZvAMQIoSPJWbyun8NE7npXIiN9WUnp2mLOLdszt4P3InQ/3CeCK0C8P8w+otavDfSohrhZgfm1NKC++qIp+VQs6X97eiZ7Arj/weSbFKR3RmCRFfHmDx+HAmta9Z9C4s1/K/zTF8dyTpauAeggBPdQvi/aFhbMs4z9tntwMgF2Ss7jP1urYOIBUNKbuwi5Izf1N6diO6wvQqzzt1nYzXpC/MA3kzdxyXfjNw3fQxL17Zx4MZUSwZ9T5rM4yeom5pYKFCTDTHCd5tDAbRFCHo7Kgnz7i9qFjGjPLfmazaBIAot+BLlydBFFh6PJk2vo7M7tn4LrX6340gV+D/1G8kftwXVYLUh1a4+uPQbhQO7UdhF9YbQSFN4LqPeBXv6O30P7KO7ZYOpNk4Ee3swaSCzUxSbeZwWRtWbh7Ol3s7M61TEC/0CaGJ+81FkJupW/LVSsqNE3C+lYolGoz9uOqueV09g/DUFqHWa9GX5lazhxkzZuoS0XI6rsDBGdeOR2uKGjRTPWZB8B7GVmHJTz0nMCWkA6fyUrGVW2BnYYmt3BJbhQV2CktsFZY0dXQ3RbR8dl9zOnwhpfm+uTWWSe0qD5YFrBt3RJVwAlXiKYoO/4Jzj+k3bMdDTTviYW3H+D2/UK7XciwnmQ4bvuTZFj14p91g7C3u/IypRq/jlVOb+eL8/mue04kGDmcncjg7kfcid2KrsGBScHs+jRiOi5XtHWmPKIq8t6NCsJt3Xwss5HWb3qPJjDMt10YQTFcWsSbxHCD5wI0Jal2n7fkv89PxCi+9h4wedVcFQYWTj0nc8bdzxt/OmVGNpKrNBtHA3owrfB97lHXJ0WgNkoH1ptQYNqXG0MTBnU0DH6WZk0c9v6N/D03cKipuX8opq3G/seG+tPV1Yvzyk5xJK6ZMo2fyr2fYFZdLp0DnKvu+seUi5Vo9v5xKJbtUY9rewd+J78aFExHgzPGcZB46+Jvpua86j2KQX2iNr69KOkvOhvcoPbel2rQzBAGnblPxfeSHWqX3mzFzu8is7HAbMpfsP14lUJnPgoyzPNB7JhP3rkQUDOCYh8pKjo26+lQxM/VDWpEKpTFdT2ZVkTI8ouQIs5UrpRVBIGDGr7xh3YOxyyQB6/kN52nuZc+AZub7x60gs7Yn6NV9lJzZgKV3M6wbtat2okaQybAPH8LTzgFsNxbUW+vXjq4Fko1IN20k3bSRpJV58tuuoXQ6PJCBbcP4YFiYWRi8S1xNFwbws6kcISj9ldUwISd3kPzYDeXFiDqNSRQ2Y8aMmYaMWRA0Q3/fpvT3rV3KaHt/Z6Z28DcNhD/be7nK896TviDxA0mpz/rtBWyCO2PlG3bD8w4PaMGBYbN45ODvnCvIQC8amH9+P6sTIvmhxwMMvs5A+nbJUBYzctePnMytMBB+IKgNU0LasyfzCrvS4zhXkGF6TqnT8sOlY2xJvciq3pPp6V1zAZVbZeelXI4lFwIQEeDEkLDrRxXdCpqsShGCtUgZ/u7iEXSiZCI/M7TbXU3r/jcRm13KuYxiAHqHuNHYzRbRoEdXLBWdUDh513isTJDRz7cp/Xybkl1ewrLLJ1kce4zLJdLs8+WSXPpsWcT+YU9dtzDQvUyIa2VBsPT6+7rbcXh2D+ZsOM+iw0kA/Hg8hR+PpzAaKSpABN7fGVflOEdrBR8ODWNGtyDkMoHUskJG7foJlV7yEpwV1o1ZzauvCKwtzCBn7VsU7v/B5A94FcHKDvvWg3Foex/2bYahcKz764AZM9fDpf8s8jZ/hr4sn8IDPzFm5GuElnXjovVRUOgwGFPnDOYwwbtGTHaJaTlHXQy2Uv239wu/M233nvoNjp3GMwZ4Z3Aob22LRW8QGb/8FAef7k5L77qpsH6vIbOyxanLhFrtO9Q/DB8bRzLKi9npGYrl5AUIexahTpd8g/0M2cxVLmOWchWbD/bkvshxTBnaj1f7Na2SomrmzlOTIHj1Dl2TIKiwr+iH6UpysXCp/0ynO0XGzzNRpUZV+5yf8gpptmYLCTNm/q2YwwzM3DTvDw3F2mhG/dmeK1Wes23WHcfOUudIX5JLyoIxGLTqa85RHR3c/Tk58jnmdRyBrUIyWE5VFnHfzh85mp1Uh++gKq+c3GQSA23kFizpPp7f+kzhvsCWzO80ksj755I14S1+7zOFJ5p1wdUYFZimLGLy/pV3pE0f7qoQHF4f0KzO0wO1hRkUH68o/GLpfWNB8GpquaVMzhOhneu0Pf9l1kZViMnjw6WKuvrSfDCKq7qCVLQF6dUeWxlPGwdebN2X2LEvsWvwk3Rwk6JzM8qLeeboX3Xf8P8IQS4VKcNX8pQ33N/aQs63Y8NZNaU99lY3Fr0ntfMj9uW+zOrRGLlx0HbVDxVgoG8zvuw86prj9GWFZP3xPy6/GELhviUmMVDh6o9L/6cInLuF0IW5BMz+E+eeD5nFQDN3BbmNA66Dn5NW9FqS5w/Hu1QL8e1AU/Hb0liYu5N3i7+N/rQAWEgRy26aMiyQ7jEe97+Na/+Zpl1eH9CUccZ7UWG5lg5f7GfiL6d4akMc01aeqb+G32MoZHIeahoBgMagZ5FzIMEfRtPo5V04dBgNxiJ91mgYo97FH7lPoVj9BAvX77ibzb4nyVZVTB4WaVUA6PQG0oul5eoSdkSDHm0liw+DsvCOtrG+UaVGoU45V+1zabYhpNrUfXCEGTNm6gdzhKCZmybQxZbnewfz0a7LqHSGa573mb4ITVYcqsRTaNJjyP37AzzHvFurc1vI5Mxt1YfxQW2YdXQtG1Ni0Br0jNuznFMjn8PLpvaz2KIxtTJPVcbE4HZY1uD7dzA7EQAHCyuODJ9NS5drI7Y8bRx4oHFbHmjclnfaDSLwjw/QGvQ1zhLeDidTCtl7RXIBauXtwH0tvOr0/PrSfJI/G4Q2NxEAm2Y9rhulBlCmVZtmTLt7BuF5E/+HexlRFFl+UhKbBQFGtZI+Z7mdC5a+zdGkx6DNSybpo964j3oT+9ZDUDheP33ratTgzsFP0nbDfJJKC9iZEUexRoWjZf0Xv2noZJRUpPS62da+kuOEdn70DnFjV1wuArD2w58BKUpw31PdsFLI8HG0ItClqm2AvqyQC8nRpvXvXd3RXD6K3s4FuZ0rgqUNBXsXk7vxIwxlFZ6gMjsXPEe/g0vfGQgKc8VJMw0H14HPULB3Cbr8FNSp0XxqPYsPFZPYcLkbgihFmhvMEUx1hkavI11ZTCN7lxtOBu69nMs3hxNN684qNYUWkGtlR7K1E226T8H9/jerHCOTCfw8oS1JBeWcSClErTPw29kKIWP5pHZ1+n7MVPBkaBe+PH+Acr2W+ef3o9Rp6eHVmC4PLabJpC8o2P0dBfuWYCjNQ/b/9u47vKnyiwP4N7t7700LpS17lL33kA2yUZaKiAhORH5uRUFUUAFBQKaA7CF77713B917N0mzzu+PQErooIVCGno+z8NDcu9Ncm6a9+bm3Pc9Lwi9Cg5Du/kozkUMQJ0R30JWysVbHekggIDry1aAFm4BEAoE0BHht3un0TuoHuSZtoah+c389RO7kU4LVUokCmKvIOf8Riju6Otsix08y1yb21xEpOVDLg7Aj/Yzi6y7Is9FXU9bvG2CuBgrjlKjg05HaDXvWLHr63jaYf7Aui84qsqLE4LsqXzUvjrmn7iPLIUaBOMCuyJrB3i/uRKRM+qBNCqkbf8edo0HwsKv7A3Pz8YRmzq8ju57F2Nfwl3Ey7Px6sEV2NftzTIPVf3m8j787+JuAMC66Mv4t/1rsHzsh7ZCo0ZUrn7ijrqOnsUmAx+nIR3UOv1JQb3nMBzg0V6XH7YPqtChIprcNMT+/AoK4vQJC6l7dfi+8+8TTyBjHhk+Uc3WucLiedmdjc0yFHvvXMMVPg764asCkRj+H+7F/R86QJV0B6rke0j4cxQgEMAysAls6vWETd0e+ppEJdSLc5BZYlBAXcy+dhhqnRa7429jULV6L2zfzMWlxMIr/eG+DuV6rKedBUY00vfE3PjI8jZBxm1AlXwPuRe3IffSNsjvHEVKvVcBO09IdBrIfxuA6FJeQyC1hFPnyXDp+RFE1i9m9mjGykNkZY+A6UcRM7srVIm3Ya1Mxbf4FWMUG7BA1wwAQAIBspQKOFhYPuHZWGm0Oh1a7/wdZ9Ji0cMnBH+2GARva/tit81RqvH6P5cMlQb6aY+hevIhzLJtBwA41nwUuo74pdjvd2uZGEcmtsA3++5i1sEIqLRFL+6yiudv44Q5TXphwkn9N8qC2yex4PZJAICbhQ2auQaj6diV8I29hOizm6HUqZAjliFXnoLcpZOgcKuBAtcgyIUi5KkLkKcpQJ6qAPlaNRRaNYLtXPFfl3EI5PO0p6JTKZB7cRsc7x7HNKEI32qF0IHw6p4/MT5ei0GKAkihxnvpCkR+eQcFcddAqsdGHogk8Jm4HoIXMPngi/STZzAiLayRaFm01joCgQipqNgZha9kJqKuo+fzD5CxR+h0BC1RsTMAXUnMLbqwinu5jlbshXGwlOCDdoH47L/bxa6XeYXApe/nSP13OqDVIGHJWFSbcbJcX5BioQj/tB2BRtt+wf28TBxJjsTggyuwrPWQJ/aEmnvjqCEZCAA7427hlX1/YUvH0UaTlNzOTgE9qAoS5lC2nniXMwqvpNdzqtgvucj0fPx7Rf/83vYWGFLfu0Kel3RaZB5ahJR/PzX0ShI7+cDvo30Q27tDrdPiZlYy7uSkIsTeDbUf+/KOzssw3A6w4aRFWS07WziZyGvhxrPVSpy84T/tEGLnvALl/Qv6hURQRJyGIuI0Ujf+D2J7D1iFtIXY3hNie3eI7dwhsnMz3H7FOwSzrx0GAGyLvcEJwWJcfIaEYGkKEm4i6+gy5F7aBlXCTaN1OWL98clOU1DyDKxCERzbjoNLn/+9VHWG2MtJ6uKPgM+OI3HpG8g9p09mBGnjIHyk7uWgf45g2/BOsJBwfdmn9W/0FZxJ039v7Iy7hVqbZ+HnJr3xevXwIom9qVtu4H6mfgKi4b5yfHLpJyTJrTCrejsAwF7nIHxTygREFhIRvukegmkdqiNdrkJmZhYcHR2ey36xQm/WbI6I3HT8fP0otFSYiE1R5mFr7HVsjb2uXxBUdOZMAEB6XPHLAdzJSUWPvYtxsuek5zbp3cuGdFrk3zyI7BOrkHtuA3RKfbJgKIDTtXphn2swMoiw3TYFKxT/QKbTApcAZTHPJZDI4Dl6EayCi68ZbM7uW9og1soWDT3tnrzxI+o6eqIOJwSZCYgEAhybVPQ4WlKvwaqME4Lsqb3bKhC/HIkqcb1L9w+Rc2YdCmIuQxl1Dhl7foVz9/fL9RrOFtbY1OF1tNgxD0qtBptiruH6tl+xocOoIkmrh5bdPYvJp7cY7luJJZBr1DiQeA9ddv+JnZ3HwUGm78VwMzvFsF1omROChTXh6jlV7A/5OYcjDbOYvdc6EFLxs9dlkkecRtLyiVBGn9ffF4px1yMEKX2+xNVbp3ExYyOuZSZBpSucKbKxiw/G1miCoYENYC+1RHRe4dDGABunZ46pKlCqtfjnoj65a2chRt/aRXufShw8Ue2Ls1BGnUPu5R3Iu7zD8HcCAE12EnJOry3xNVyd/ODYYCgytRrsiLsJjU4LMU/2YuRiQmFCsFEFJQQ1WUmI+rIJdMqik5RIvUKRZ6VPmjtZO8Lt1R+gzc+ENj8DuvxMaOWZkLhUg3OPD0sd/sVYZSO2cYbvpA1QRJxByobpyL++zyghWOPmLPScdgm3bRtAJBJCJBBAJBRAJACkYiHaV3fB9I41wEeo4hERvr96wGhZtkqJMcfWYV3UZfzZYhB8bRwAADtuJOOvM/pZah0sJfjC/QpUpIVXQS688hRIsLHEmbRYxORlwu8JF/GsZWL9P50Czo6cRHreBAIBZoX3wpcNuuJcWixOpcbgZMp9nEy9j2RF2XquiHVaWOu0sLWyg6XUGvYWlkiU5yJeno3b2anof+Bv7O4yvsRSOVUdaTVQxlxG9qnVyDm1BpqsxCLbCAB8e2s3Iq2cEWntjOu2Hvi2Rkd8dXuPfgOhCDLPEMh868LCty5kvnVhWa3xS13vN0Cei2M93zF1GIyxCsbfFOyp2VqI8XH76jhxvfj1ArEEXmOXIOrLJoBOi5SNM2DbsC+k7uWbiaqBsze2dxqLIYdWIq0gH3dyUtF0+1z82WIQhgc1NNp2Y/RVjD2+znD/+0Y90NW7Jrrs/hNpBfk4mXofHXYtwJ6ub0AA4GZWYTHup+shWHEJwbS8Aix5cIJvZyHGG839nun5NDmpSFk/DVlH/gIAqARCLPULx58BLaEUCICbJ0p87Lm0OJxLi8PUM9swKKAuch+ZGMb/wQ8SVrptN5KRqVADAF6t5wUrafGHW4FQCMugJrAMagK3/l9Ck5WEvCv/IffyDuRf22O4Wl2sjBi0SriCbe5hyCiQ42TK/ecy67W50uoIV5L1SbsaLtZwsKyY2nwZBxcUJgNFYljVbAPb+r1gW78XJG6ByP77Y4B0cHHwhEvPSRXymoxVFpZBTeD/0V7k3zwI4f9+MywXyfIx7/4nuJPhj9UWPbHDoi3kgsIhxFcTc7H0TCwmN/fCp90cYPmgJ6GuQA6B1LLK1z7bFX/LcH7R3NUf9Zy8DMNJd8XfRu3NszGnSS/09qyHsesuGx73W7/aEG6eBgDQQYDM3CDARv88G+9fxXu12rzgPWFlYSWWoo1HENp46M+JiQj38zJxMvU+4vOzYS+1gIPUEln5hHf/vQVSqjE4fw/ek2+ATKMwPI+sQT/4v/4HkiQWaLp9LhLkOTiUFIE3T/yLJa0GV+l2pclJQUH8daiS7qAg6Q5USXehSr4DVUoEoNUU2V5k7QS7Jq/CrumrEFo5gNRK/BUXic4RF6ERAhs866BRra6YUr8DpF6hED4y4ogxxswVJwTZM3m7pT9OPPg9QACuJ+WilkfhhBOWAQ3h3O19pO/8EaRSIGHpePh/tBeCcvZi6uhVAxd6T8GgQ8txOjUGco0aI46sxqWMeMwK7wUAOJR4D0MPr4TuQY+Fj+u0xyd1OwAADveYgE67/kSiIgcXM+LR9r8/sKRhH1zLTDK8Rqh92a7qXX4wI6yNWIZA24rrLffHiftQqPXDR95s5g87i6dLXpBOi6zDfyF5/SeG4cERVk74oP4g3JHaFNleLBCilqMH6jt5obqtC3bG3cTJVP2szgqtGssjzhttzz0Ey+bvR4YLvx7uW+bHiR084NBmNBzajAZpNdBkJUCTnQxNTgo0OcnQPritjLkE+a1DaJcWgW3uYQCALRHnOSH4iKuJOchX6dtURQ4Xzjy4QH9DJEGNWRGQOBf+fXNUSsMwMEcZ11NjLy/r0PYAFSYE71vqe6IFa+/ji/w/8KFiGbba9cJSu+FIUwlRoNEht0CDHw5GIPboarxtdR4OmTehyUqAQGoJiUsApK6BkLoFQeIWBKl7dcg8giFxC6oSSY3vrxT2DpxRvxO6+4RiYEBdjD2+DvfzMpGjVmLc8fXwwDEk5wUBEGFAXU8M9FUjIuYSAOCSOASKHB/AU3+esoETgmZDIBAgwNYJAcWcV9qpXTFk5QUsl76KE9K22OS4BsK7+s9LwcVNuHf7ADxfX4jtncai9c7fka9RYdm9c6hh54pP63V80btSKWQdWYqEJeMAKr0+pkBiAdsGvWHffDhs6naDQCw1Wp+Q5gJNXAHgdwMA8EVWMjpbO6MxJwMZq9SirWzRasdvRZZfscyBtc4OQAllGaogTgiyZ2IlFRvVyOq/7CyOTmwJN9vCL0rXfl8g9/xGqJLvQX7zIBKXvQXP0X+W+wTf18YBR7q/jffPbsNvN48DAGZfO4zXqjdGbUdPfH5xj2HY65s1m+H7Rj0Mjw1z8MDRHm+j4+6FuJ+XiRtZyWhz6C/D9jZiGXytHZ4Yg1Kjxt2cNABAHUcPCAXPPqQX0CdSfzh4DwAgEQkwuU21cj8HadTIPrESadu/hyr5rmF5kqMv3mw4FIla/b5KhCK8Xr0xmrn6o4GzN8Ic3CF7ZFjJZ/U74UZWEpbcOYu/751DWkG+YZ1EKIKXVfnqh1RFRIQ9d1IB6P+ewa7WT/U8ApEYEmc/SJyL9hYlImTsnYuW66dDrNNCIxRhx5U9+DaofpUfivpwduepWwu7L4f7OVTIcwtA0GbrexbbNx1slAwEgCxVYc8NRykPv2MvN2HhiGGkBjaFlbAA8hv6RIW1To6hWWvxus0N2Iz7G7+dS4X8yCL0U+yBE+UAAB720SGVAqqEm0XqcQKAZY2WcB8yG1bVmz3v3TGZJHkOjibrS7B4W9mjm3cIAP3F0HO93kP4tl8MpTuSkAjY2wFZHpj1SihS14w2PM8BaVNAbYkaNm64m5eC48nRUOu0ZZ6MjVVOgxt441RMJn45EoV7cEcn9Uc4NHwkBNs/gTY7GTp5NuIXDEfNaYfwT7sR6LN/KXRE+N/F3RgaWL/KTQaXf+sIEpe/XWwyUGhlD6lHTcjca8C6VifYNu4PkWXR81q5SoMv99zBT4ciAHIFUn0B11iodFrMvHIA/3Z47UXsygs14d8ruJqYU2S5RqOBVkgQVYELM8y8XEnMLbYmoFd+LqQ6JZSx8iLrNGIrWKniX0R4ZoMTgqxC3UnNR/fFp3FwQnNDDzeh1BJe45bh/g8dQBoVsg4vBqkUcB82p9y1NqQiMeY16wc7iQW+u7IfAHA9Mxm1HT0R9WDiCy8rO/zerH+RhGOQnQuOdp+IbnsX4UZWslHNvA/rtC1TgjI6L9PQAzHEoWLqhOQo1ei/7CzkKn08E1sGwNu+7D2LdColso4uRfrOH6BOu2+8ru0beNvOH4kPZlJu6OyN5a2HPnE25TAHD8xu0gvfNeqObbE38NedMziYdA/vhLbkGnVlIBAI0KmGK/67lQK1ljBs5QXseqMZRBU4Y7RAIIBzl8mwCmqOmrsW4LqVE+5JbXDnm5YIencjrIKr5pWvyPR8vLn+CvbdTTMs83O0xGuNfUp5VHk8yICIJHDu+XGRtTnqwlLj9k+Y/Iixl4mFnRsCPt6PgvgbyNj/O7KOLgWpFCiIuwrVzGYYqtUU+YGeInRCvMwPte00kGXfL7ZEguLucUR/3Ry24QPhPuh7SN2rv6hdemFcLWxQzcYJUXkZiJdn40DiPXTwrI51UZfxyfkdRnV8RToJtHJ9AmPjb5+ie+R6AIBCbIdtFu0AEHIeDCl1lllBXEEXLplp/fhKGC7EZeNIZAaS81TodMobhz44B8mWD6A8txbQaRE7bwBa9J6Bz2q1wVfXDkNLOsy5fgTzmvUr5ZkJ6qxESBxejokfFPcvIvaXXqAH38ViJx+49fsKUo9gSD2CIbJ1eeL5/t7bqXhrwxVEphcmE9rZNsY5cTLyNCrcyUkr5dHma3PGEaSKMmElNT7PJyJoBXYILKZuMmOmUqeUCW76p6sQrLmLIJeiHTL62fhDJeTz80dxQrAEGo0GCoUCtra2T96YGbkQl43eS87iv/FNDTWCrIJbwmfiOsTOGwDotMg+uQq5l7bBpfcMOHWeVO46HOEuhb1yYh4Mi01/0JPNw9IWohJm1vO1ccD5Xu/h2yv78cOVA5CIRPi1aV+MrdGkTK8bkVt4EhBoU/YrrrlKDbbfSEZ8thIpeQVIzVchNa8AKXkqxGQpkJyrr9HX1M8BM3uGluk5dco8ZB5ahPT/ZhUpiGxTtzssX5mGXncv4naqvi5hbQcP7Ov6ZrlmnpOKxBgQUBcDAuqW+TFMb9mQ+mj08xHEZSux724aZuy6he96lO1vWx6WQU0QHnoD1+9fg0Yowl0dIP6hI7zG/w37ZkMq/PUqq9icPEw5dBDbL+SiILfwuD28nhvmDWwARytpKY8uP7eB38HCp3aR5TmqwnqbtjykiL3kCDCMErCT6E+wZd5h8Bz1O5y6TEb8/GFQRp8HaVSFDxLLkFWzDz5Ma4kTWn1veCmE2PJeY3TyEUGVEgF1SgRUKRHIOfsvCmKvAAByz/6L3Atb4NRhAlz6zIDY1uUF7unzJRIK8UPjnnj10AoAwKRTm+AgtTSU7wAAkUCIt0NaYJRfC3SbfwHV886hS+SD4VACAZZU/wJpaU6ARInkB4nVpq5+VWK4dVUgEQmxbWwTdF54CmdishCfrUTH5bewZegsOBZkI//qLmhzUpC0chJesXbCz+GvIxcC/HXnDP5XvzNcLfQlY7SKHORd2g4BCAQBBCDc+6gG3AfNhGPHtyEoZWbqyq4g6Q5iZnWFTqHv5WbbqB98Jq6DoJTJVdRaHa4m5uBsbBbOxGThbGwWriYWXpiwFAvxVbcQvNemGuptPYEbWcmG3x0vm3xhDmCRj7ruxhdQNRoNNIn3UZMKSngkYy/e/IGl/TYtuVOEau7YEocTA0AdR0/MbzHgGaMzL5wQfIxGo8GMGTMwb9485Ofno0ePHlizZg3s7HiY5JMIALjbypCcW4DDEel4dfl5/PtaI8jE+qSgbcM+8Jm4DglLxkGXnwmdIgcpaz9E5sEFcB8yG7YN+5T5xPXR4b2x+dlQatSQa/QTODg9IeFlIZbg64bdMNqrDlycnGFXjl48kQ962gFAkF3ZEoI3knLRffFpxGQqSt3O2UqC9aMaG94v0mqgTo+BKjUS6tRoqNOikBd/Gzk5CVCnRRc7K5pto35w6TUdYv/66Ld/GU4/SAb6Wjvgvy7jypUMZM/GzVaGf19rjNa/H4daS/h+/z0EOllhbNOK/4HWwCMIy+5fAwDctnFFSH4q4ucPhSLqHNwHfQ+BuGIm06hMNFodzsVlY/etFGy/HY9z4iOAZR7gDyDdC9VUtbF4UEPUcxJUSDLw4Y8nALAK6wDnblOL3S5XwwlBVnWQABA86DRrJzX+vMs8glFtxgmkbPwf0nfNgcTJB44dJoBq90WYXw1syFFi3LrL2HEzBSqtDn2XncOW0eHoGtIUCGoKAHDp9Smyj69AyobPoMmMB7RqZOydi6xjy+DyyjQ4tB330iQGBwbURQu3AJxIicbN7BSjdb18w/Bj41cMIxM29nGH6LcfIYK+x2VS849xNLcBgFxY2uXj4dlGU9dnm5yMVS52FhLsGt8UHRecxMX4HMRkKtBv9U0cGbsYNmvfQt6l7QAA6/wMvBpzFn/5NYFCq8asvQvxqaMLcs7+i/xrex4k6PviYTqfCvKRtHIScs6sg+fYv8yy7Ig6Iw4xs7pAm6sv12IV1gHeb60uNhmYlleAmQfu4Xh0Ji7FZ0OpKb7OYJdgV3zfyRcNg7wBAH7WDriRlYxslRLZKgXspS9fnWArnV2RmYTT09ORM7+PiSJirGL5K0ru6Xols+hv66qAE4KPGT16NGJjY7F9+3YkJiZiwoQJ+Oijj7BgwQJTh2YW9rzRDG1+P47sBz3iBiw7h39fawyLBz0F7Rr3h1VIW6Rt/hIZ+/8AdFqoUyIQN7cfrELbw2PYz7Dwq/fE1/G1tjfcjs3PQoaqsFu/s0zfPZg0auTfPACdMg9WNdtAbOdq9Bz2EotyJQMB4N4jwwTKMqHIoXtp6Lv0LLKVRWczA/T15QKsNOggvI1x1TUQb9uO+ykRUKfcgyotuthZ0IoQCGHXdDBcen0KC5/aSJBn45Nj67AjTl+LyUlmhd1dxsOnDDUSWcVq6u+IuX1rY8KGqwCA8euv4MC9dMwfUAf2FTTjLQDUdSwc6nM/rDOQrC9+nbHrJygjz8D77X8gcSx5RmxNbhoyDy5E7sWtEAgEEFraQ2RpD6GVvf62lT1ENs6wrtUJMo/gCou7rOQqDe5nKnA/U4GItHwcikjHvrtpyFKoAZEKqHYFsCisdQnnBIhtVbB2qAmg6EQ65ZVzZj0e7QvlPf7vEntR5KgKhww/7DHFWFVgX8znXSCWwv3VmXDt+wUEEhkEAgHS09MBAB52FtgypglG/3MJK87HoUCjQ5+lZ7F1TDi61NQnvgRCERxavw67Jq8ifc8vSN8+Ezplrv6C4vppSPl3OqxqtoZtw76wbdgHUtfy19+tLAQCAX4K74XmO+YZltVz8sJP4b3Q0aswQaNTKeGzbTyUpO/FtFfaDJ9EtIRSq78vteWE4MvM0UqKPW80Q/v5J3EtKRfRWQXotPw2Dr+9HkH595F5YAGyji3FyLgLWO7TEGqhGAsTIzFo0zRYa9XFPKMAEAgAIsjvHEXkjHpwG/ANnLpMLvcEgKaiyUtHzKyuhrI5FtUaw/fdzRAWc46vVGvR9o8TuJFcfFJAJhaigbc9JrUKwNAG3sjIKOwI4GftaLgdm5/1UiYEGXvZTYi5CW95BJxybhdZN8glDCp10bqDLztOCD7i5MmTOHnyJC5dugQbG/2PyPv37+O77757qoRgTk4OcnIKi7MmJr78Wee6XnbYOa4pui46hbwCLXbcTEHfpWexaXS4Yfiw2MYZHiPmwrHDBCSveR95V/4DAMhvHkTk/xrApt4rcGj1Gmzqv1LiUGJXCxvIRGIUaDWIyc9ERkFh47VT5iJxxSTknP4H2odDfAUCWAQ0gk3d7vrhtIFlGyL8qIwCOVZFXtA/HQSo8ViC8XGrL8Th9X8uQa3Vd59o5u+ITzpUh6u1FG62MrhYCKE9uRhpm76ANj8DiADKNAhBIITE2RcSl2qw8K0D+44TcV1ihcWxN7D9wj6cT48zbGopkmB7pzEIdXAv9/6+zF5k23yzuT8i0+WYdSgCALDmYjxO3s/AqmEN0aJaxczYXM+pMNl3zyMEnqMXIWnlOyB1gf4E//OG8JnwD6xD2xk9riDhJtJ3/4Ls48sN9XaexCKwCeybD4d9syHlrgFaFrmKAqzcvguxMVHIzM1DZm4eCpRKSEkFKdSQkAYCgRXqipwRJ3VAdLV06Cz0vfJshFbQCTSQa1W4m5uGFtt/wzv2rvjESgJhdhKEFrYQ27tDbOcGkZ37g9vuEJbSc1adEYeEZW8CaAsAIAggcSq5HmGuurCHoB33ECy3qvi9ac7oQSIBQKkX2Ir7YQ4AIqEAS4fUh44Iqy7E65OCS85i29gm6BRc+B0rlFnBtdencGw7Dqmbv0LmoYX6C2akg/zWYchvHUby6imQ+daFRYM+kFZvBkleBjRZ8dBkxkOdWfi/UGIJ69pdYNugN6xC2pa7ZElZHbyXhl+PRKKRrwPebOZvNNlaSZq5+WNB8wHYHHMNgwLq4bXqjY1KoBARkpa/DWX0eQBAhk01TJe+B6W2cHYXnUW24XYTl4pLCHLbrDxcbGTY91ZztPvjBG6l5OFOaj46LTyFgxOaw2P4z3Ab+A3cT67GgMv78Y+dD3IkltjgWQej4i5A4hIAu/CBoPX6cxKCAAHTjyHhrzFQJd4GqRRIXvM+cs7+C6+xSyDzCjHx3pZOp8xD7JyeKEjQXwiVetaE3/v/ATJrnEiOhr+NI7wf6UTw6c5bhmSgQADUcrdFuK8Dmvg5INzXAXU87SAVF3/Bz8/GwXA7Ji8LtR1fjrqLjFUlcZaBAIDifoHplLnQKXMR9U0xQ45da8D5zaXPNzgT4YTgI1avXo1p06YZkoEA0KFDB0ybNg1ZWVlwcHAo1/PNmTMHX375ZZHlmZmZsLQs+arSoydc5iY9PR017YD1g8Pw6tobyC3QYvftVHRfcBwrB4UYkoIAAJkbrF9fAfHNfcjd+j9ok+8ARMi7tA15l7ZBYOkAq3Zvw7rDu8V2+feysEVUfibu52bgXkrhianw5EpkRp8w3pgIyqhzUEadQ9qWryGwdIC4/RSg08Qy79vHV3Yj/UHicbBvbVCeAul5RYcBZyrUmHM8DvPPFMb0Sk0nzO9d48H+E7SZ95CyaCg0SUVnVAQAgbUTRM4BELtUg8g5ACInP4ic/CCXOsHeJxgCkQRH0+5jbexVHDi4GimPzAT8kEQgxKJGfRAssjX0yDAFU36enZ2LH9ZdUtvMzc19Lu/Vxy3cUddFgsk77iFDoUF0hgKtfz+Oz9r5YVIz7woZQuxtaYd4RQ4upcdD23UyHCcFInvZGGgz7kObnYz7P3SETa/PYdX2beQkRiFrySgUXNtp/CQCof6fruSeqcrIM1BGnkHymqmQ1ekJ237fQ2T3bAlnIoIm9iISDi6B6uoOtNUVnVjgcddt3PBB4CvQWeiv2Puq5FhjI4LyzmF84hiIc/Ze0IEwNzsFu+JTMTbmDLqk3oWUtEWeSyC1hsDGGSJbNwjtPCC0c4fI3gMCS3soTi6HzqhekKDUz0hi1iPrlOoX1vbM7XujvG3zSd+bJTG396U0lX1fRGptqZ93HRHiFTm4mhKHpKgCROZnIDI/E4mKXPg52aN2LSmuRYmhVNig119nMLtbIF6t4wqh0fFRBGnPL+EUPgpJ59bhVsRJRCiyEWXlhGhLR0RZOSEmKxeCc3vw6d0DeDXxarGxqJLvInP/7xDIrGHZajxse372VPtc0t/kvzsZGL3xNjQ6wpbryfh27x2MaeSBz9r5Q1ZCsuGhga7BGOiq74mdlVl47NHlpiL/0B+QH9X/IBHIbFBtwko0OKDGsfsP49AhX6RPCNawcYY2T470vLL1dni4LxXdNiv75/Zx5hKvGMD6wSF4ZfkV3M9W4XpSLpr9egT9Ql3Q0s8OjUP64L2Atlh78E8QgGXV2+P1/t/B0b+R/pxj/RuG51I41YTD5H3I2/0j5Id+B0gHxb2TiPisHmR1e8Kq5RhI/BpCIH725HlFvr+k1SBr0RCoIk4DAIQO3rAbtw5n0tPxxp4luJ6TAgGAjm5B+F9YO6RnyPDzkUgAgJVEiANj6qG686OfXS1ys40vzT8ar5W28Fh0IyUOTa0q/qJoaUpqm4yxslvt/wEA4Nikokk/8dIp0BXkA491IC6IvQKRpgyj9swUJwQfMXr0aFSrZjzcxNVVf4Vaqy36I/JJpk6dinHjxhnuJyYmokmTJnB0dHziQd1cD/oP4+7m7Ix9jvbo+udpZCnUOBydjbe2R2Hj6+FFr7y1Ggxq1h+ZBxciffccqFOjAACkyEL+f99Be2svvN/4GzIv4wkZati7Iio/E+kqBUafWG1Y7qrSJ8cEMmvYNR4AiYs/8q7uhjLqrKEnAymyoDkwG06vzihzMmZLor5rsa1Ehl9b9oezpfGEM3kFGvx8JBKzD0Ug55Ehwu+1qYbZvWoZZpglItxfNKgwGSgQwKHV67Cu0xVSt+qQugVBVMLw3vT0dDg7O2N1xAUMf2SfHxJAgGaufnjFNwyvVquH6naVo7ZSZfs8l9Q2bW1tn1usI5o7o0OYL0atuYj9d9OgI+CrgzFIVwnxa9/azzwDcQMXb8TH5iBdpYDGSgqPeh3g+s1FxP/5GvIubQNIh7ytn0OYfBOqW4ehy34kiW7tCMd2b8Cp0zsQO3qDVAroFDnQKrKhk2dDq8iGKvEWsk+uhiLilP5BOi0KLm+FJuoUvMYtg2297uWOWavIQfbJ1cg+uBDKmEuwAPCkQbb5IgnmBbTEKp8G0D2YPTNAnoG/Lq+HY4H+G3xp9Gks92mEXwNbQSUU446NKz4O64mZKjn6Jl3HwMSrCFAUnvSTKh+UkQ9dRkyZ4i7pMxKVm46FD3ruAECgq8cL/exXtnb2NJ7le7MkL8P78lBl3pcVsVfQzDsIeWoVEhU5SJTnIEGRg0R5LuLl2YjKy0BBCWUwruYk60fkBwIgAZRKa7xz/jbm3HJDj1rOkFlokKDIQYI8GwnyHCTIc5CvAeDfvMR4vqzZBXliGcbEntMvEIkhtveANjfN0COaCvIh3/8L3JoNeOqZ2R//m6i1OkzbewEaXWGvvQItYf6ZRFxIUmD9qMbwdXxycluryIX89hHk39iP/Ov7UBBnnNzUDFqA727b4nJS4agAWGdDJ9Cfr7bwqFbuz0tp21elc1pzidfZGdg6ktBn9Q1EZygQmaHET8fj8NNxfUmacF8H1HQOwK2CaCQD6BV1EVuD6hcZNfJwf11enwtFm5FIWDwaBfHXAa0KBRc3oeDiJggkFrAMagarkLawDmkLy8CmIK0a2rx0aPPSoclNe3BbPzLHofVoiKzsHw/Z6PWeVfI/H0J15xAAQGTrgoBP9uOwDhh0cAVyHrZxAPtSInAgNRLWeb6AyAfQSvBT71poGlxyb39Af74enZ+JY5nROJYchT/vnDKsKxALzOZzwhgrG6lbEACg2lt/Gi2P+qYVNJwQrBoaNmxYZJlYrH+L6EEiKS4uDm+//TbWrl37xN4KdnZ2VXoykiZ+jtj3ZjN0XHAS2UoNdtxMwYjVF7B6eEOIRcZJQYFYAqfO78Cx49uQ3z2O7GN/I+v4ckCrhjLqLCL/1wAuvWdAbOdmGPozLC8be218QQIBsh48j4cyBwMd3eDdexVsG/aB8EE9Qbf+X0GTk4r863uRsGQ8SCWHQGpVrp5Zkge1VFwtbOD2SDKQHgx1+mj7DSTmFA4XtJQI8eMrYXinlXGSOfv4CshvHtQ/p2sgfCb9C0v/BmWO42xqDMYeX2e4byexQFfvYLziG4buPiGGmeRYyUzVNr3sLbDnjWaYdSgC03beBBHw+/FoJOcWYOXwBoYJZZ5GLQcPbI/VJ5lvZCXDw8oOImtH+E7ejLQdM5G64TOACDmn/zE8Ruzkoy/M3+o1Q1sBAIHMCkKZFcQOHoUvULsznDpPgir5HrJPrkbmoT+hyYyHNicFsXN6QGTvDplnKGSeIZB6hUDmGQqpZ00IbV2gy06GOiMOmsy4wv/TY5B3fR/osd6t2QIbXLdvipYt2sDV3g5CqQWEYhlu6nTYmJeDVVmpSFQXzlhaVy3H3Etr4fpIHVGhQIh3XLzQQ6LDByTEeZ2+YHim1ApL/cKx1C8cLYXAMFU2OmXFQpyTDE1uKjQ5ycXW7RTZuYHySu/VE5OXiQ67FiA2PwsA0NjFBy3cAkr/o7Eiqvr3prkRPpL0up+XiVf2LSn3c0iFIqh0j1x0FZB+giDLPEQiAb9FlP25bMRSkFaDfNK3+Z+C2kLc4W183aAbxPbuEAiF0BXIkX9jP7JPrUHOqTUAgNSt38L/g//KHXtxNl9LQly2PhlR19MOr4S54ZejUZCrtDgdk4UGcw5jzYhG6OhvCXVWIjTZSdDmJEOTlQRNTjI02UkoSLgJReTpEusIb/Eag0932QGINl7hlGC42d+/ToXsz0PcNisnbzsZDrzVAiNWX8CJ6MILXWot6e8nuALVEgCJCvdy01B/8y+YXrN3ic9nGRiOal+eR/LqKcg8uKDwQrpaCfmtQ5DfOoRUAPesnaGFEDKdBjKdBhYP/pfpNBATIfvUGgR8crDUkhzPIv2/n5D+32z9HZEYvlO2Y0l2Oiad2gztg/bvJLOChUiMBHkOdETItY4BghNQk2phTFPjZGCOSonY/CzE5mfhdnYqjqdE4VhyNBIVRXs02kstMCjgyfXOK6PEZROgjCu+57SPXU0UCLn2MXv5XUnMRat5x4out8yBtdQ8aqdWJE4IPsHDhJFOp0NcXBzat2+PiRMnPtXQpaqoka8D/hvfFJ0XnkK+Sov1lxNhJbmMJYPrQ1hMjyiBUAjrmq1hXbM1nDpPQvzCkSiIuwpSF+gTGo8IB/CVR23MCOkKAKiZn4YNNcMR1mlhsYk+sZ0r7MIHIX7hSACAyDmgXPviamGNREUOUpWF/YjPxWbh3U3XcPJ+4UmYRCTAm8388WmnGvC0M/5i1eSmIXlN4eykXmMXlysZmKTMQ99jf0P54EfCxJAW+LlpH0OyklV+QqEAH3eojkBnK4xYdREqrQ7/XkmEpUSEv4fWL3OSWlcgh0AkMcwgHPbIFf/rWcno8KAIvUAohGuvTyHzDEX8wuEglX6Yu3WtzvCesLrcM3RK3avDte//4NR5EhKWjEfKhS24buuOBAs7JMoVSIiPQGJ6ChLvXEKihR00AgHq5CShcXYcGmbHo0F2Amy0qiLPe0lWG6slXbBX1gLH3uuIUD8HROSk4Z+oS/gn8hKuZSUZbW8jluGbht0wxtISscfnG60T2TjBb8pW+AHYnZ6OCF0+/rh1AuuiLkPxoKj6cR1wXGwPZ29PDG/dEC4W1pBrVFAocqFQ5CBfkQNFgRwWQiHGNuoJfPBNie9JXH4W2u9agOg8/XGgnpMXdnUeb1T7i7GX0cOj1aOJweI4SC1RzcYJNexc4COxRl13X9Swc0WwvSucZVaIyE3HqdT7OJVyH6dSY/SlD1D8c9qLrRBgaw9va3sEP3iOmnauqGnvBi8rOwgEAvx8/QimntkKAPjh/nUorBzxc9PeEEBfj9C2QS/Y1OsBZfR5qJLuIO/qLhy9vAcOvnVQx+nZ6oLNPRpluP3HgDpoWc0JQxt4Y8Df53AnNR9WuTG4NfsLeKnOQFDCPhYhEiPbtT62KGtiJzXAVVXh5E52FmKMauSD+v4WGHf5iH6hSgZHDdcOriqqOVvh+KRWSMktwJHIdByOSMfhyHRcTcwFVFZAREPA7zpglQsVqfH5zQ3oJRZAotF//mYfjIBap4NKo4NaR1BrdVA7TISs60DUL7iCGjmXYBN/GpqkW4i3sMOUWr1w3dajxHicVfmYGH0C4/4cCZ+J60uchOtpZR1bjuR/PjDcdx/zFz5NS8KvN44alg2pVh9LWg2GSCDAhyf2Ye7tg4BIC4g0uI3LqLslAUG2zojNz0ZMfiayVU+uoywTidHC1R+zwnsh2L70OuKV1RupmYi18YeqmMRfjKU1/BRFSxAx9jKp41nyhS25qvwjQl8GnBB8goc/zmNjYzFkyBBMnDgR7733nmmDMjPNA5ywbWwT9Fh0GkqNDn+fi0OmQo3PuwSjoY9DiY+z8KuHal+cRermL5G+4wfgwRW/Rw3IjEK1+ycQ5VYDb/R4B26B4aXGok6PMTyPyKl8xbbdLG2ATP2kATFZefhqdwSWnI15ePEUAPBqPS/88EooApyKvyKasvYjaPP0NZbsW70G69D2ZX59pUaN185uQIJcf7Wyo2cN/NK0D8ScDDRLg+p5wcVaij5LziK3QIMV5+PQPMARE1oEPPGxeVd3I27+UIAIHsN+hn2r11Drkd58y67cgjDDG6Ob+MJKqj/M2zXuB4nLMaTv/BE69zD49pv+TDMIZomk+KvVeMy1C0KmrvQv0AsOPrjgoL8aLyQdQvNS0CgrDjW0BZAENcdBXXXsTgAgIDTwzcfGlBOYePkuzqbFFnkusUCI/v51MDu8F3xtHB7MAGxMKDPuJdvE1Q9NXP3wS5M+WBlxHn/eOY2rmfoh0+kFcsy9WfQq4aNWH1qFHlIhLFRFj0EJ8mx02LUAkbn6dl3LwR17u74BZwvrItsy9rKyKNDiqwZdIdeo4WllCy8rO3ha2sHLyg4elnawFBfOqv6w9MWjqtu5oLqdC0YENQIAyDUqnEmNxZrrd7HrRiZiUnSARgpopMgmIQRednitYw20r+4MV5uidc2m1GoDW4kMbxz/FwTC3JvHkKspwKIWgwyJeoFQBHT/EEv3LcQGzzqIurAHuLAH3b1D8EWDLmjyFDP0XozLxrEo/aykDbzt0CJAX+O0tqcdTr/dCKt/morm0SsgQ3GzvRqT+daFdVgHXLZqgI+uO+FKBhmdtTf2tcdbzQMwpL4XrGVifHNpn753JQBkemLs2iu49H4bw3dASVQaHXILNMiQqwELFZytpeXeb1Y5uNnKMLCeFwbW0080lp6vwrGoDByKSMPBCCdcVp0HHPTD81USESQaDQjAh9tvlPKsQQCCIBAMQI3ayYh1ug2FsPREdrrUGl8Fd0ZszFl8u/YjeA6dXWH7mHtpBxL+GmO4b/Xqj3hNocaOu4XJwP/V74wv6neBQCBAgUaLfSdlQFoTwD0aAqckEAi3s1NxOzu11Ndyklkh3MELHXxropVbNTRy8YGsmJrm5iRCZo1oS1uIBUXrH/rJIxBUTE1yxl4m8wfWLXGd3eIjkKu0RXoPfpSYAwuxADWed3AmYt5HtQqm0+mQn58PW9vC4aDCByeOr7zyCj7++GNOBj6l9tVdsOH1xui79CzUWsLW68nYej0ZHaq74IN2gegW4lZszyihRAb3Qd/BvukQ5N88AJGVA8SO3pA4ekPs6A2hpR1CyzHsV5UaabgtcvYv1z48OhS31s97kZdX2Hzqetphbr9aaBtUcm+r/JuHkPWgGLjIxhnuQ8p+gkREeOPEvzifqR8OFGTrjLXtRnAy0My1r+6ClcMaoM/SswCAyZuvoYG3PZr5O5b4mLzr+xD7a19DDayExaORe2ELqo/8zbDNhbREXDh7Dd/su4tpHavjjWb+sJCIYBnQED5v/4P09PQyJQOzFWrcTs3DrZQ8pOer0CnYFY52Osy5fgR/3j6FfE3Rnn4POQDw0qqgJi3uigt7VOsEQly39SjsXaAFgEjgQaeci2rg4mOjWQQQoJ1HIIYGNkB//zpGyTZV8r0ir/3o8GejmGSWeCesFSaGtsTp1Bj8eecU/om8ZOg1WBqtSAhAhwKpEHezU1HD3hVJ8hx02LUAd3P0NZNC7d2wv9tbPGyfVTkCADPqd66w57MSS9HOMwjtPIOg60DYfiMZX++7g3Ox+gkzLiXkYPAKfb1OZysJQt1tEepug1A3G4S62yLA0RKt7MMwu35/fHx5EzSkw9K7ZxGXk4fPQnvjeHIUtiZcwtnse9AGtTV67f/ib+G/+Fvo4ROCL+p3QXg5EoPzjhX2Dny3VSAEAgGICLnnNiB1zftol15YpzRB6IpTkrpIFzogU+yEIP8AtKsfhsZhNSF19MKxRDU+3n4Tp2OygEd6Eg5t4I2pbQPR2NfBsEyr0xnqmwlIAMr0wF1NPj777zbm9KlVbKxZCjW+338Xvx2PNuoVQT/1KvP+ssrN2VqKPrU90Ke2/vs2I78lPji5B8tijxi2UcpEgEQJqEsbKkoglxjccY4u7BastALyHeFkLYKrrRgO1iLYWAigIjWOJuvbwVK/cCTF3MLi/X/Aq+Pbz7w/8rsnEPf7IODBRUh1tw/QRy3ElRR9uRSpUIQlrQZjeFBhCajv9997MKuwFC2kTfFbr2p4/+xWHEzS1yKwEcvgZ+MAX2sH+Fnr//e3cUS4iy9q2rsiMyPzpasVGKDIxY13fymyvNiZVRmrQgzDhR+bMzRfpQXRyzvqhxOCD+h0OowePRrOzs6YM2eOYbmNjQ1sbGw4GVgBeoS6Y+Pr4Xhj/WVDrb0D99Jw4F4aanvY4v22QRjW0LvopCMALPzqwsKv5Ix+WamNEoIB5Xqs6yNJhjyNAoAtnKwk+KZ7CMY39StSF/FROnUBEpe9abjvPmR2uYZqzrl+GCsi9D9+bCUybOk4mnsgvSR61/bA9E418O2+u1BrCQP/PocLU9rAzbZor5f8m4cQ+0tvQzLwodwLm5F47QgsGo2BUkaATF9PLym3AJM3X8esgxGY3qkGxjTxK9K+iAgJOUrcSMrDzZRc3ErJM/x7tCYmpHLgXCwEjskgQeGPU4lQhOGBDdDU1Q9+1o7wt3GEr7UD7KSFPy7Slfk4lhyFI8mROJIciYvpCYYaP6Vp5uqPIdXq49Vq9eBpVXwXf1VK0YSgoISEoGG9QIBmbv5o5uaPn5v0xpnUWAgFAliIxLAQSWAhEsNSrP//aFIUZlzcBUDfW1EjEiJ00yyMqRGO4ynRhh4GwXau2N/tLbg/NtkQY+zZCIUC9K7tgV613LH3Tiq+3nvX0AsPANLlahyLyjBaZsQ2DPC9DggJe5NvYm/CHf3QwUcIiNA88z5uW3og3VJ/7NoZdws7426hp08ovmjQBY1dfEuNMy2vAKsvxgMAnG1E0NglYuye/+B16yC6X94MB43+uC2QyKBoORm/KrtjR0Ru4SiDJAC7gKCzCQhwysL+u2lGz98l2BUze4aigU/RiRp2x9821C/t5hWKI3etkA8tfjkaiX51PNA6sDChodLosOBkNL7acwfp8idfDGEvDydrGZZ06oVX42rg133/AwDohAKIQ86iiWMQurvXRUuXIFhKJJAIBdAS4Vx8Ombf24EozSM99rNdgfiagE6EDACPtrzqLtZo5euBk+qT0AL4zy0Eva8ewUZHX/g1fPpkszLuOmJ+fsVQ9gStXsdIS3dDb39XC2ts7jAaLdwDDI+5mpiD7/bfBQBIRUIsfrUeQl1scaD7BCTJc2AhksBealGueuKMsZdXkLP+98OxnsbJ8a0TRYb5JF5GnBBEYTIwMTERCxYsMFpna2uLO3fuwNPz2WrKML1XwtwRPb0T1lyMx+xDEbiWlAsAuJaUi9FrL+GjHTdQ38sO9hYS2FmI9f9k+tv2FmK42cjgblv4z1JSvh5yqpRHEoLlHDJ88X7hpAVwSsIAX3eMa+YHOxlw9pGr/mKBEBKhCBKhCGKh/nbOnrnIzoiDTCyDY/XmsGs5qkyvSURYdOc0Pjq3A4D+wuyqNsNQy7Hk2i3M/HzZtSbOxGRi7500xGcrMXD5OewY2xS2FoWHaGXMZcTM6Wk4GbZrOgT2LYYjetFYiPJSYKPKQNO8ezgsCwLEagTWjUFkkg4gAeJ0Qkw4GIFpJ6VoFeACSxIgp0CKhAwtolI0yJMDhZf9dYBMoU8quuXr/5c9+F9Q2E9FoBOhrWNtzG/XHSFOpSe3nS2s0ce/Nvr41wYA5KqVOJEcjb8vRWLNhUSABPC2s8If/evCWiKBRChEgI0T/GxK7impUxcg7/IO5N84UGRdST0Ei2MvtURn7+AS1w8OrI/+AXUwcO1gwzIt6bDozmnD/SBbZxzo9laJSUvG2LMTCAToUtMNXWq64UhEOrbdSMbN5FzcTMlDVIYcJZ6r5zoD9+sAftcAkc44GaiWQpjhitVRc1BHGQeNQIARfu/jmrcFSKo/1u6Iu4kdcTcxpkYTzG/eH9JihgxqdYTPd99BgUYHWGVBUe02xp98cOHG1hs/tngTn9/ei5HeNeA+dA6kboHYBiA6Q46/TsdgyZlYJOTot49IlyMivfB8o5GPPWb2DEWn4OJrlqUr8/HjtYOG+5PrtMQrtjJM3HgVRMDr/1zCgbeaw8/REhuuJGLazlu4l1Y4LNBKKkLnGi7QatSQSnm4cFXQzScECwsK24GGdDiRcRcnMu7C09IOC1oMQG/fWkhX5mPUuQ2I0ugvfIkEQnwY2gn1JGE4F5eNo1EZuBCXbTSj9r20fNxLkwLWdSH1uwSVSIjz9j5of2ozjrhUg4V1+X9P6QryETO7K3T5+jq9uQ36YqpnQ1xNvQ8AqGHngt1dxqOarT7xTUS4mZyHkasvQq3Vx/a/LjUQ6l54wc6jCnxfx/zaD2p744vL0hLqBzLGqq4qnxB8NBm4ZcuWYicL4WRgxZKKhXgt3BejGvtg9+1UzDoYgQP39FfCU/NU2Hsn7QnPUMhWJoa7rQwetjL4OVjCz/HBP4fC/+0tC2sX6R6ZLYxKmL2vOD8fjsDR23LgYQcBpwRsyE/Ahv1lfgqgxQTDTeHyj2Epkuj/iSWQCcUgEAiAjnTQkf62SqdFsiLX8LjpoW3Ry6/44T/MfImEAqwe3hCNfjmKmEwFjkZmoP38E9gxrincH/QUzDm/CfRgJl3bxgPgOX45Zh2Jxo+yOfhMNR/dVMcRnJeGw85BAIBIXRTwWImYLADbH50wz+bBPwKglQA6ESApKKxDVRyNGEj3AWV44ZBWgqbnz2JoA2+IhQJkyNVIz1chQ6FCer4aGXIV5GotLMQiWEqEsJSIYCkRwUoqglZHuJygxcMglwxpii7+RWvaPE4RdQ5Zh/9C9pm1hh8HACB28IIm68EMm+Vo22UhEYogfvCjQqouWi/xYLcJ8LYu2muHMfZ8tAlyRpugwl5vCrUWt1PycDM5DzeSc5GUWwChQJ9EFAoAoSAAKVofbM8/ACUVoKalH9o51UYrl+pwsZLB9XwusOdziInwz/3Z2JXYDF/5DEK2ewYg0yfqltw9g2sZKVjSfBh8bGwNQ4ui0uUYufoCjkdnAlI5BH7XICfj44RKKMZXYT0xuP9HkNoVXkAJcLLC191D8HmXYPx3KwV/norBzpvJ0BEQ6GyF77qHYFA9r2InYdORDsvunsNH57YjvUD/3eBlZYdOnjXQ2VOADVcSceBeGiLT5Wj08xEEuVjjTEyW4fECATAm3A9fdasJL3uLYms7spfXwzKAErUOftYOiHnQwzRRkYM++5fivbDWyFUXGHrBu1nYYG27EWjnWR0AMKShvi5wfoEGp+5n4mhUBo5GZuBUTKZ+CHq+I1SRjWHvdxLZMhkiLR3R69AqbO/2XrljVUSdgyZT3/t2t2swvnKqiawHyUAPS1vs6fIGvCwdsO9OKrbfSMb2G8mQp0Sja8Fx6CRhEPiF46P21Z/h3Xp5qIQWpc4kXBB7pcjQYY1GA23iDch8n32kFmOs8qnSCcGyJAPZ8yMQCNAtxA3dQtxwIS4Lsw5GYPO1JCg1Tx5K+FBugQa5BRqjq92Ps5QI4WApgb2FBB2UPpj4YPmxzYuQpmuAMU18YVFKT8NV5+MwdesNQOAKKOIAy7wSty0rHRHyNSp9DbaCJ28PAO/XaovJgc2f+bVZ5eRiI8OW0eHo8ucppOapcD4uGy3mHcP2sU1gLRUhVSHBwyPUFklrrP/zDI5EZgACO7xv+xF88DOGxZ/FJTtPnHUsZzF8AQCxGiih0L21WIpaDu4YGtgANcXVsfB4HLamJYMA5Cg1WHjyfqlPr9ZqkFvK53x6pxroUvPJycCsY38jYfFoPN4VSOLiD4+RvyFp5WSoUyOhjL0M0ukqfGZDAIbE4KNsJNyrhjFTspSIUN/bHvW9S0/MKzStodZpjUoaAABV/wRxGZeRe24jAKCb6hTaRF7C3OShWOUZDp1nFCDS4Ux6NGpv+Bm4XxtQWUEqEkBH0PeQEqkh87uAArE+GdgiIxpj4i9gZ+Mh2FigQgHpMOnUZuzoPLbIEEWxSIhetTzQq5YH4rMVuJ2Sj1bVnIotoQIAVzMSMeHkBhxPiTYsc5Ra4u/WQwyTpiwfVh+dF57CzeQ8pMvVSH8kGdgtxBU/vhJW6myLrGqQanSIGvQpDiVGYO7NY9gScx0A8MsjM/Y6SC1xrtd78LVxKPJ4a5kYHYNd0fFBD1a1VofDEen452IC1lyKx9vXbmFZrWpItLDDRa0a9Tf9g+/r9cWAel5weOSCfUmiM+TYnuKNAPdmWOxojy0etQ0X/ZzEthjh3B3vb4jAnjupyCvQwlaXh/GKfzFCsQ0yqKGGGOJOxyAppazPy8pv8ib4+PgYLYtb/F2J21v41Clxncy3bqnrGXvZ+SgiS6yzWe2z0icnrOyqbEKQk4GVS0MfB6wZ2QhEhAKNDjlKDXIKNMhRqvW3lRpkKtRIzi1ASl4BkvMKkJxbgORcFZLz9MtKGi6kUOugUBcgMacAERSKwQJ7uFA2qiftx7h/T+KHg/fwfY8QDKnvXeQq/O5bKXj9n0v6OyTEl8Gvwtk7E/HybMM2j74ugaDR6aDWaVGQm4qMC1uh1qqhFQhBLv4QBDSGQqeBQqOGXKOGQqv/V6DVQAABhILCfwIAQoEQnpa2+Lx+F3T2DkZ6enrFvvGsUqnvbY8Tk1qh65+nEJkuR2S6HGE/HgIA9FRm4scH2x27cgtHLAMBAEIB8F3PMLSXd0Pq+kNYdnk91OOWIT+4LVQ6DQp0Wqi0Gqh0WqTJlbiQkIlcZS5s7cTQCFTIUMmRVpCPVGUeslRK+Frbo5aDB2o5uCPMwR21HDzgZ+MAoaDwZLp7TS/cS8vHr0ciseRsrFFBegCwEAvhbC2Fk5UE1lIxlGot5GotFGrtg/aovx3gZIVf+tRCr1pPHgKvTo9B0opJhgYntLSDXZNXYd9iJKyCW0EgFCL72HKoUyOhU+RAlRIBmUfFzwdWICn6o+Lf6CsYX7NZhb8WY6xiWYolsETRJIRALIXPO/8i9/xmJK16F5qMOFhBiU/yl6Jf1EF8kjced4LyAIlKX1Ih6CIQEwZV/sOyBhr4+R1BzIMyD7Vyk/B7/DkEv70GQwMa4cKmWYjOy8R/8bew8f5VDAgouaeNt70lvO2LPyfNUxfgi4t78MuNo0Z1WF+v3hg/hr9iNKGRt70lTr/bGqPXXsKGK/o6aw197PFjz1BD8oYxQH+u2cGrBtp7VseSu2cw6dRmo8m2Pq/fudhkYHEkIiE6BbuiU7ArfugZjJipwxF+9RKGNxwGhUiCVGksxl35E28cd0FTpyBMrFcf/Wp7GWbDJiJcTczFpquJ2HwtCZcSswCrbCCoAyAtvLLYO+k6LOJ9MVuWrH9dUmO4chcmyP+BIxWOrJFAA8ut74HqHivTZGovk377l0LmYlx6RS7MgZWu+AsBnq/PL3Y59x5mVd2swKZIl4TDSlr0GEIFcpw3QUwVqUomBImIk4GVlEAggIVEBAuJqNhJFUqi1uoQn61ETKYCMVkKw//3M+VIyVMhW6FGlkKNbKUAWy06YIxiEyygQo+CI1ib2QPDV13EL0eiMKd3GFo9KL59JiYTA/4+Z6iNMqVNIGZ0DC1T8WFV8j1EfdsK2mz9iYpN3e7wHf0rBGLuScRKV93FGicmtULPxadxPq4w8ZwmdDDcdtZlAQD8HC2xbEh9tK/ugrxrhbPqeSTehHvr14p/gbCKObmr7mKNef3r4OvuIbiWmANbCzGcrfRJwIcn9qV5WJy3LO2JiJCw9E3olPqTfIc2Y+Exch6EUuNjt0W1Rsg5ux4AoIw+/1wSgtoHvQxcZNZIK9D3TF4RcZ4TgoyZOYFAALvG/WBdqxNSN3+BjD2/AjotamqjsSlpOi6IOmCGXx1Ey8SASANBwFX4yWvDV+EEa/EW7LbWDwV2L8jFUk0Oan95zjB52G/N+uGVfUsAAJNPb0EX72DYSspex6tAq8HiO6fx7eX9SHyk9EltBw/80bw/WnsEFvs4Wwsx1o9qhO03kiESCtCtpluxw48ZA/RtYGxwUzR19cOrB1fgZnYK6jh64u2QFk/1fFYp1yAryELNAuB/WamY5uSlH5EgKYDOKR4nEY+TF45DdMwJTRyqI8DaGftiYpCqztTXLbaWA2GKwhLHACw0Wnx3eye6pt4BAPho0nFFHIwPFcvho0ko3BepFUQ2TtBkxEERcQqZ++fDqfM7z/L2vBSsdHawLiEhyBgDrmQmotWO34yWHXfSjz6w1ToV2V4jTnkhcT1PVTIhKBAI0KpVK4wYMYKTgS8JiUiIACcrBDhZlbodESE7JgAJ/9sEABgrOIS16AEAOBubhda/n0D/Oh4Y38wfI1dfRP6Dnk/DGnhjdq+wMiUv1OmxuP9jJ0My0Cq4NXze+ZeTgazM3G1lOPR2C0zdeh23UvLgbWeBWtAC+/Trx9WywMcjOsLb3hKiBz/uLPzqGx6vjLn0wmJ1sJQYkujlUZ5Z/bKPL0f+1V0AHgwPHv5LkWQgAFgENDbcVkafh32zIeWOqyQEo98kWN5mCD49/x8uZSTgaHIUonMzEGBb9ESBMWZeRJa28Bj6ExxajETi329BEaGfQKhh/AH8m3gE00K7Y69rMEhAuG99FW7aRByz09eattSqscrdG437zDcqWdDTNwz9/GpjU8w1xMuz8eXFvZjd5Mkzrmp0Wiy/dx5fXd6L+3mFNVOtxVJ8Ub8LJtdqDckTej0JBIIy9cJm7KHajp640HsKjiZHoZGLT7ET6ZRF3oPvbQB4q1k3NK7WDF+e3YfTmTFQ40GtX5EWWttUnNSm4mQOAIeSn6+hvT/eD+oBf6ElkPo9AGCsYqPxRgIBHFqPgWv/r6DOiEX0180BIqT8Ow22DftA4lz6bOEvk00dRxcZMtxqnnkPbWTsearjWPy8ER4iV+jkVqihblBkXapuyfMO67mrkglBABg/frypQ2AmIBAI4OBfG5nBraC4cwzeebdwdJgNJp8R4cKD3lgbryZh49Ukw2O6BLti6ZD6ZbqqrslJwf1ZnaFO09dUswhoBN+p2yGUlZ6oZOxxNjIx/hxUz3Bfk+OHOw8Sgi6UDV9H48+U2M4VYkdvaDLjobx/EURUrqRbZaXOSkTSqvcM9z3HLIbwkWFxj7IMKOwlqYiu2A78KokQMrV+iN7wwIbo7hOKm1kpuJSh75GwKvICptfrVKGvyRgzHQv/+gj47ASyDi9CyqbPoc1OhqVOgznXt2FetZb401/fK/jsg2SggAhLQpuhY8uhxT7fL037YHfCbcg1avxy4yhGVW+Euk5exW6rIx3WRV3G5xf34E5OqmG5AAIMDayPmY16lnkIJ2NPw0IsQWfv4Gd6jrwrhQlBm9pd0MnBAw0snGFlb4f9CXex+MYF7E26DTkpin28vcQCYQ/Kl7TzDMKwwAb68iX1vkNWcDASlowDdIUlS6zrdIX7qz/Cwk8/JF/i6AWnTu8gY+886JR5SFw+Eb7vbXkpzo3Kot+SM5A5Rhstu5KYi7qetsU/gLEqbn6LASWuK2l0Vdjcpc8zpBeiyiYEWdXm0Ho0FHf0V8mCkw/i7OQvsepCHD7deQtx2UrDduG+DtjweuMSC3s/Lu73wVAl3gYASL1C4ffBLogsuWs+e3YiG2dAKAJ0Wmge9D59nIVffeRlxkObkwJNdhIkDuY/Q3rymvehk2cBABzajoNNrZKTbiJrR0hcA/UTi0SfB+nKPkFRaY4lR0Ej1icEBUT4uWlvAMDQwAb48Nx26IiwMoITgoy9bARCIRzbvwmHdm9Ak50EVdIdqJLu4KukOwjJSMLHFq5QP6iv+l3tthjSpHeJz+Vn44gv6nfBR+d2QEs6vHd6Cw50n1DstoMPrcS/0VeMlvX1q42vG3ZF7RJ6MDBWmWjzM6GIOAUAsPBvALFDYS9VS7EEr/iF4RW/MOhIh1MpMZh/9QKyVAq09fFFQxdPhDq4w8PStsTknUPr1yGyc0fS8rchsnODW/+vYVOnS5HtXAd8i5zzm6HJiEXepW3Iu7wDtvVfeT47bQbqetryZEKMMSOcEGRVkk3twpOGgrhrEAoFGNnYFwPqeuLnI5GYezQK1V2ssXl0OGxkZWsmmrx0yG8dAgCInXzh/+FeQ/0gxp6VQCiEyMoB2rx0aOWZxW4j9QwBLu8AAKjTol+KhGD+tT0A9AlR9yGzn7i9zLuWYWKRh4nEZ7U34Y7htlStMxTu97SyQwu3ABxLjsKt7BQoNGpYip88ayJjzLwIBAJIHDwhcfCEdUhbAMAUADXvXMbCmAto6xGIKbXaPPF53qvVBn/ePo17uWk4mBQBrU5nmBX4Ia1OZ5QM7OIVjG8adkO4azlnj2fMhAqS7gAPJr6xCm5d4nZCgRAt3APQwj2g3K9hW687bH+KKnUbkaUtPIb9jLjfBgIA8q/trTIJwU1jmhQZMswYY4/jhCCrkoQy68I7j0wTbCUVY3qnYEzvFFz+IZePDFuwCmoGiZN3RYTKWCFB6T1VBaKXLxlFD35QiB28ILKyf+L2gkcScoQSph4vJ90jxwjBY09pKy6c/KiiXo8xZh6aOvugR3C9J2/4gEQogr+NI+7lpgEo/pjx6LK2HoHY3fWNZw+UsRft0e/NYmr+vkhSz5qG2/TIuTpjjDGgbOMgGauCqkqNEcYYY4xVPmJB6ROGMMYYY4w9C+4h+AJpNPoZtRITE0vdLjMzEwpF8QV2KyO5XG64HRcXZ8JIyk4rz0JSvv52XpYCggqIW5ObZnjO/Ew58BzeC3P7bACmj9nDwwNicemHuodtMykpCY6Oji8irKeSlKeFNh+Q5KhhUcznKzU9B5kPPoOSxBRYWhT/GTT136Q8kvJ00MkBaY4asjK0qcRMOfIevAdW8QnIVeGZ9zUnORVKuRwChQY6ocDoOKdIzQAycgEA8XFxsDTRbOLm9Dd9qDxt80nfmyUxx/elJJVxX57m+78y7sfTepp9UaZmGo4ZcXFxED82S7BGpzWsV4ozX9h51aP7UpFt09z+3lUl3ud97q5ITDGcExek50D94DVM8f4qE5MMsSgy8qAtx/5Wts/Di/jefFxlew+ehrnvw+Pxm9tvb3N//4GS90GdlY+4uLgytc3KSkBEPMbpBTl79iyaNGli6jAYq1JiY2OfWEOF2yZjLx63TcYqJ26bjFVO3DYZq5zK0jYrK04IvkBKpRJXr16Fq6triRnkxMRENGnSBGfOnIGnp3lMCMAxvxgc89MpyxUbpVKJffv2oVevXmb1/j6NyvA3eVGqyr6a636WtW0+6XuzJOb6vhTnZdmXl2U/gJd7XyqqbZrbe8TxPl8c77N73t+bj6uM70F5mfs+cPymV5Z9MOceguYZtZmysLBAeHh4mbb19PQ0uywzx/xicMwVz8LCAvXr1wdQ+WOtKFVlP4Gqs68v436W53uzJC/T+/Ky7MvLsh9A1d2Xl/mcluN9vjje56sivjcfZ27vQXHMfR84ftN7GfahODypCGOMMcYYY4wxxhhjVQgnBBljjDHGGGOMMcYYq0I4IVjJ2NnZ4fPPP4ednZ2pQykzjvnF4JifL3OK9VlUlf0Eqs6+VpX9LK+X6X15WfblZdkPgPfFlM/7vHC8zxfHa35ehvfA3PeB4ze9l2EfSsOTijDGGGOMMcYYY4wxVoVwD0HGGGOMMcYYY4wxxqoQTggyxhhjjDHGGGOMMVaFcEKQMcYYY4wxxhhjjLEqhBOCjDHGGGOMMcYYY4xVIZwQZIwxxhhjjDHGGGOsCuGEIKtQGo3G1CGwSkin0yE2NhZqtdrUoZTL4cOHsXDhQlOH8UJotVpTh/Dc5ebmYsqUKVAqlaYO5bkjIuh0OlOHUSkREc6cOYMLFy6YOpRntnbtWuTl5Zk6jKfyspwv/PPPP5DL5aYOo0LcvHkTR48efe7HjpycHOzfvx9JSUnP9XWqqszMTOzcuRPJycmmDqVE5tT+U1JSsHXrVuTk5Jg6FFaFmFMbYeaNE4KV0N9//43g4GA4ODige/fuOHHihKlDeqLFixfD09MTUqkUTZo0wY4dO0wd0hP9+eefZncyunnzZjRs2BCOjo549dVXkZmZaeqQnmjz5s3w8/ODn58f6tati9jYWFOHVCaHDx/GwIEDERgYaOpQnqu4uDh07doVMpkMzs7OmDJlykt50pubm4uuXbsiPz8fMpnM1OE8NzqdDl988QUcHBwgk8nQpUsXnD171tRhVRr3799HeHg4mjVrhkaNGuHdd981dUhPbc2aNRgyZAh69OhhVknByMhItG/fHjKZDG5ubvj444+Rn59v6rCeyooVKzB06FD06NHDrJOCeXl5GDRoEGrVqoU2bdqgffv2z+0C3qpVq+Dl5YXOnTsjODgYx48ffy6vU1EOHjyIFi1awMHBAT179kRCQoKpQyrVvn37EBYWhp07d+Lu3bumDqeI5cuXw8fHBxKJBI0bN8aWLVtMHVKp1q1bhzp16uDIkSOIiIgwdTgmsWvXLjRp0gQODg7o27cvUlNTTR1SuVy9ehWbNm0ydRhlFh8fj+7du8PCwgJOTk6YPHkysrOzTR1WmWm1Wvz0009QqVSmDuWpmdtx/5kRq1TmzZtHgYGB9N9//9GJEyeoadOmJBQK6fvvvzd1aCVatWoVBQYG0oEDB+jYsWM0cOBAAkAffPAB6XQ6U4dXrI0bNxIACg0NpcTERFOHUyZ//vkneXl50R9//EHz5s0jJycnGjRokKnDKtW///5L3t7etGXLFjp16hQFBgbSRx99ZOqwnujQoUPk4uJCe/bsMXUoz5VCoaDg4GD67LPP6Nq1a/T777+Ti4sLBQYG0u3bt00dXoXJycmh5s2b0/jx4yvtMamizJgxg5o1a0anT5+m3bt3U+vWrUksFtP8+fNNHZrJZWZmUlBQEH3//fekVCpp2bJlJBQKSaFQmDq0p/LHH39Qhw4dyNHRkVq3bk25ubmmDumJsrOzyd/fn7799lu6du0a/fzzz+Tg4EAhISEUFRVl6vDKbe7cudSxY0dycHCgtm3bUn5+vqlDKjetVkvdunWjESNGUHZ2Np05c4YsLS3p+PHjFf5aGzZsIB8fHzp9+jTl5eVR165daeTIkRX+OhVl06ZN5OLiQj/99BMtWrSIvL29qU2bNqYOq0TZ2dnk4uJC+/btM3UoxdqwYQP5+fnR3r176cSJEzR06FACQJMmTSKtVmvq8IqIi4sjOzs7unTpkqlDMZlVq1aRu7s7zZ07l+bPn09ubm7UvXt3U4dVZnK5nNzd3UksFtO///5r6nCeSKlUUkhICE2bNo2uXbtGf/zxB7m6ulJAQADdvHnT1OGVyaeffkoAqGfPnlRQUGDqcMrN3I77FYETgpVITk4OWVlZ0dmzZw3LUlJSSCKREACaOXOmCaMrWb169WjNmjVGy3777TcSCoU0ZcoUE0VVutatW9OiRYvI39/fLJKC6enp5OzsTNeuXTMsW7x4MQkEAkpPTzdhZCVTq9Xk6+tL58+fNyybNm0aff3113T69GlKS0szYXQlO3ToENnZ2RmSgdnZ2TRt2jQKDw+nLl260JYtW0wcYcVZs2YN1atXz2hZTEwM1apVizw9PSk6Oto0gVWgh8nAUaNGGZKBa9eupc6dO1N4eDjNmDHDLH/EF0etVpO1tTVdvHjRsEyr1dKUKVMIAC1cuNB0wVUC06dPp759+xruK5VK8vLyolOnTtF///1HcrnchNGV34EDB6hr1650/vx5o6RgYmIiZWRkmDq8Yi1atIhatmxptCwiIoJq1KhB/v7+lJCQYKLIns6ePXuoZ8+edObMGaOkYEJCAmVmZpo6vDLZtGkTVatWjdRqtWFZgwYNaPfu3bR161ZKTU2tkNfRarXk7e1N27dvNyz7448/6L333qPt27fThQsXKuR1KkpBQQF5e3vT4cOHDcu2b99OACrtD/P169dTWFiY0bL9+/fT9OnT6c8//ySlUmmiyPSaNm1KS5cuNVq2aNEiEolENGHCBNMEVYp58+ZRhw4djJZt27aNPv30U1qxYgVpNBoTRfZi5OXlkZubm9Hv0n/++YcAUGxsrAkjK7u//vqLhg0bRqNHjzaLpOD69eupVq1aRsvi4uKobt265O7uTpGRkSaKrGwUCgV5eXnR2rVrycrKyuySguZ43K8InBCsRE6fPk0AjE4idTodubi40NSpU0kkEhn90Kss/P396a+//iqyfP78+QSg0h1879+/bzjYRkVFmUVScMGCBfTOO+8YLUtOTiYARgm3yuTo0aM0ePBgw/2cnByqUaMG2dnZkUQiIUtLS1q7dq0JIyzenj17yMLCgj788ENKTU2l0NBQ6tSpE3355ZfUoUMHAkC//PKLqcOsEPPnz6caNWoUWZ6SkkI1atSgJk2aVMqr9uWRmZlJjRo1olq1alFycjJ99NFH5OvrS59++ilNmDCBZDIZNW/e3Gx7iT1KLpeTQCAotmfPe++9RxKJpNL96H6RXnnlFRo6dKjh/vfff08ymYxCQ0NJJpNRcHAwxcXFmTDC8klISCBvb28iIkNSsGXLlhQSEkJLliwxcXTFmzVrFjVo0KDI8vj4ePLz86N27dqZIKqnFxMTQ/7+/kREhqRgmzZtKDg4mJYvX27a4Mroiy++oJCQEMOxfs+ePSSRSCg4OJjs7e3J0dGxQnoLJiUlEQDav38/ERHl5uZS/fr1ydXVlapXr04AaPLkyc/8OhVl8+bNNHDgQKNlarWaJBIJ7dixw0RRle6vv/4iX19fw/2JEyeSk5MTtW7dmmQyGTVt2tSkF8Bq1qxJv//+e5HlS5cuJQC0cuVKE0RVsm+//ZbCw8OJiEij0dCrr75K7u7u1LJlSxKJRNStWzejRPrLZuXKlfT6668bLcvLyyMARgmTyqx9+/Z0+vRp0mq1ZpEUXLRoEVWrVq3I8rS0NKpZsyY1atSoUieiN2zYYOj1fejQIbNLCprjcb8icEKwEklPTycLCwt64403DCdmX3/9NXXp0oVUKhXVqFGDxo0bZ+Ioixo9ejSFhoYWe+Vx5MiRVLNmTRNEVbqIiAjDbXNICl66dKnYH/JCoZBOnTplgoieTK1WG3o0KhQK6tChA/Xp04eSk5NJqVTSyJEjycrKqlL2cHyYFPT19aX33nvPaN0777xDUqmU4uPjTRRdxbl58yYJBIJiE7OXLl0isVhMmzZtevGBVbCHSUFfX18KDAw06j114sQJkkgkNGvWLBNGWHGaN29OPXr0KLJco9FQs2bNqE+fPi8+qEriYa/qYcOGUd++fcnR0dFwXL137x55enrSsGHDTBxl+djb2xsuIu7YsYMAULVq1Srt8OFz584RgGJPrE+ePEkCgYD27t1rgsienq2treH93rJlCwGg6tWrm03P43PnzpFIJKKOHTvSmDFjyMLCgtatW0dE+mNn8+bNKTg4+JlfR6fTUYsWLcjd3Z0mT55MNWrUoN69exvep19//ZUA0IEDB575tSpCZGRksUkPT09P2rx5swkierJLly4RANq+fTtt2LCB6tataxiNceHCBbKysqIff/zRZPFNmDChxLYxfvx4CggIMEFUJdu1axcBoLNnz9Lvv/9Obdu2NbT1/fv3k1gsNpvE/9O4efMmnTx5sshyW1vbSjss/XH37t0z3DaHpODdu3dJKBTSqlWriqy7du0aSSQSWr9+vQkiKxuVSkUxMTGG++aWFDTH435F4IRgJbNw4UISCAQUGBhIYWFhFBISYuiW/d133xmuVFUmERERZG1tTcOHDy9Sn+v69esEoNIm2h56PClYUFBAo0ePNkocVkZSqdTwZa1Sqei9996j5ORkE0dVlFarpUWLFhld1crKyiIAdOzYMRNGVrI9e/aQjY0N5eXlGS3Pzs4mgUBAGzduNFFkFev1118ne3t7unLlSpF1vXr1qlQ9NsoqNzeXVCqV0bKHScEFCxYU2X7AgAHUu3fvFxXec3Xw4EESCAT01VdfFVm3YcMGsre3f/FBVSKbN2+mr7/+mgYNGkQ//PCD0bpvvvmGQkNDTRTZ02nSpAkdO3aMEhMTKSQkhCZOnFjpawoOHDiQXFxciq1T2r59e5o+fboJonp6DRs2pFOnTlF8fDwFBwfTpEmTzK6m4KlTp+irr76iqVOnFqlN/DApUhH7kpWVRbNnz6bffvuN3NzcigxHDggIoJ9++umZX+d58vPzM1wo0+l09Mknn1Sqc8VOnTqRr68vDR48uEiPu2HDhtGYMWNMFJm+R62dnR0NHDiwyOiDiIgIAlCpaolqtVqqW7cu1apVi7p161YkCdahQwf69NNPTRSd6Tg5ORku3Gg0Gvrggw/Mpnd9cUnBlStX0rx580wcWaFx48aRnZ1dsaMC+/XrRxMnTnzxQT2Dx5OCycnJNGTIELMq01LZj/vPimcZrmTeeOMNnDlzBqNGjcLUqVNx4cIF+Pj4AABsbW3h6Oho4giLCgwMxN9//401a9bg9ddfN5pVyNbWFhKJBDY2NiaM8MkCAgJw6NAhyOVydOjQAf369UNubi78/PxMHVqpBAIBdDod1Go1Bg8ejPv371fKz4hQKMS4ceMgEokMy1JSUiCVShESEmLCyICYmJhil3fu3BnHjh2DtbV1kXUCgQD+/v7PO7QKlZOTg88++wxt27bFJ598goKCAgDAvHnzUL16dXTs2LHIbLS2trZwcnIyRbhPLTc3F126dMGQIUOMZsl0cHDAvn370K1btyKPMce/JxHh+++/R2hoKKZOnWpY3q5dO3z33Xf43//+hy+//NLoMeb496xoffr0wWeffYbU1FQIBAKjdQ9nIDYnISEh2LdvH9q3b4/XXnsNv/32G/bt24dr167hxx9/NHV4xVq0aBE8PDzQvn17XLlyxWidOX5GQ0JCsGfPHrRv3x7jx4/H3LlzsWfPHly+fBmzZ882dXhl0rRpU8yYMQNCobDYdhEWFgYrK6tnfh17e3u8//776NatG9LS0oxeKy8vDxkZGZW+DT487yIivPnmmzh58iTc3d1NHZbBkiVLoNVqsXbtWkRFRRmWExHu3r2LJk2amCw2X19frFq1Cps3b8bw4cOhVCoN62xtbSESiWBvb2+y+B4nFAqxZs0axMfHY9euXUbvp1qtRnR0tEnfT1N52Aa0Wi1ee+01XL16FS4uLqYOq0yEQiEWL16MkSNHYsiQIZg0aRI+/vhjdOrUydShGfzyyy8ICQlB586dcfr0aaN15vgd2bZtW+zcuRMHDx5E37590b59e9SqVQuWlpamDq3MKvtx/5mZNh/Jykoul1PdunUrddf0devWkaWlJTVo0IA2b95Mp0+fpg4dOtDUqVNNHVqZ3b59myQSCQ0cONAs6oJYWFjQwYMHqV+/ftSvX78ivaIqq4KCAurQoQN9+OGHJo3jzJkzZG1tTd98802ZHzN16tQiRaYru8TERKpZsyb17t2bpkyZQpaWlvT1118b1mdkZBhqDH322Wd04cIF+uOPP8jDw8PsivyfOnWKXFxcyMLCgvr37//ENnH27Fmyt7c3u1mVv/32W2ratGmJQ9d/+OEHEgqF1KVLF9q/fz8dOnSIwsLC6M8//3zBkVZOkydPJkdHRzpw4AAVFBTQ/PnzycPDw2ioizn4+eefCQB9//33Rstv3bpVqYfnJCcnU3h4OFlZWdHXX39NFy9epJ9//pl8fHwq7YRTJZk1axYBKFJ24ObNm2bznfzQihUrSCgU0uLFi0mlUtGuXbvIzc2NDh48WKGvo1QqycnJibp160YpKSmUmJhomOm4sgsICKD169fT+PHjqW3btkVGEVQGd+/epeDgYLKwsKDffvuNzp07R6+//jo1bdq0UnwmN2/eTNbW1lSnTh3auHEjnT17lrp27Upvv/22qUMr1oULF8jb25vs7e1p2bJldPr0aerbty/17NmzyMioqsDFxYV27NhBw4cPp65du5p8spqnodVqqV27duTh4VEpJ4vIzMyktm3bklQqpU8//ZQuXLhACxYsIA8PD7OZ0OVx69atIwBGvz/MhTkc958FJwQrubS0NPruu++oRo0aNGnSJFOH80Q3b96k/v37k5WVFTk6OtKMGTMqdfHTRxUUFFDv3r3NJhlIRGRlZUUhISFmkwzMy8ujXbt2Uf369WnUqFEmf5979uxJvXv3JgClJgVVKhUdP36cBgwYQI0bN66Uw7JL079/f5oxY4bh/meffVakHqlarabZs2dTYGAgiUQiatWqldGs1uYiKyuL3N3dDXUgS0oKRkRE0OzZs8nDw8Ps6oKo1Wqys7MzmvmPiCg6OtroRPHo0aPUsWNHkkql5O3tXexw6aoqOzubWrRoQQBIKBRSaGgoXb9+3dRhlZtGo6GtW7eaOoynUlBQQN999x35+/uTWCym9u3b0507d0wdVrmZ89/gcTqdjkaPHm1oFw9/+D8Pu3fvJjs7OxIIBCQUCumNN94wi/OYwMBACgkJqfQ/CvPy8mjGjBkUHBxMXl5e9NZbb1FOTo6pwzK4c+cOvfrqq2RtbU0ODg70ySefmPycsDTp6ek0depUqlatGvn4+NCHH35olomw8irub+Lm5kYhISFmkQws6TO1cuVK8vb2rpTJwIc0Gg39/PPPFBQURCKRiFq2bFlseR9zkJycTGFhYWaZDCQyn+P+0+KE4Au2Zs0aatGiBTVs2JA+/fTTMk2osHPnTrp79+4LiK545lI49lFPE/P58+dp5MiRJjsheZqY3d3dTZoMLG/M58+fpwkTJlSKouFRUVEUEBBAGo2Gfvzxx1KTgpmZmTRx4kRauXJlpT5hLU5iYiIFBwcbxf3aa69R69atKTg4mHr27GlUdPll4OnpSampqUZJwRUrVtCoUaMM2/zyyy/03XffmeWV1piYGAJg6L0ZHx9Pbdu2JQAEgAYOHGhWtVkqSmxsLI0aNYpq1apFffr0eeJxRqvV0tGjR+nw4cOV7sLVli1bqE2bNlS/fn16//33KSkpydQhlUlMTAyNGDGCatWqRf369aNDhw6ZOqSntmnTJmrdujU1aNCAPvzwQ7O7EPRQfn4+ffDBB1S3bl3q0KEDLV++/Im9mi5fvky7d+8u9w+f/fv3l6vHVHp6uknPcQ8ePFjutl+vXj2T/Sg8fvw4devWjWrXrk3jx4836W+D4phbm9m1axe1b9+e6tWrR5MnTzabOngvyvr164sdERMUFGQWycDo6GgKDQ0t8nfVarXUr1+/Sp0MfNksX768XKOxKhtTHvdfBE4IvkC//fYbBQUF0eLFi+m7774jNzc38vT0LHYGp3PnzlWKguALFy4kAGUa2nn+/PlKcfXxr7/+IgA0ZcqUJ2574cIFys7OfgFRlW7ZsmUEoEy9QC9dumSYVfLq1asmSwaWJ+bLly8bzexaGSQmJtLq1asN95+UFDRXSUlJtHDhQsP9pUuXkp2dHf3444+0atUqCg0NpYCAAFIoFCaMsmK1a9fOMMTtYVJQJBLRpUuXTBtYBVEqlSSVSg0T9dSpU4fef/99ioqKorVr15KNjQ298847pg7zhUpJSSE/Pz+aMmUKLVu2jLp3704AaPLkyUWK1yuVymK/dyuLFStWkI+PDy1cuJB+/PFH8vHxIRcXF9q/f3+RbSvTsTUpKYl8fX3pgw8+oGXLllGXLl0IAE2dOrXYv8GpU6dMFOmTLV26lPz8/GjhwoX0ww8/kLe3N7m6uhab4Hz0O7my0Wg01LZtW+rfvz+tXLmSxo4dSyKRiLp27Vrsuc+zJHBXrlxJAOjtt98uU8LR1J/bnTt3klAopCFDhjwxKXjnzh3DBZjbt2+b5EfhkSNHyMXFhebMmUO//fYbhYWFkaWlJa1YsaLItrGxsS/8Qp+5tZmNGzeSh4cH/f777zRnzhyqVq0aOTg4FNsj9tatW5V+csSKtn79evL09Cy2R9qNGzfMIhlYrVo1+uOPP0wdCnsJmOq4/6JwQvAFUalUZGdnR+fOnTMsS0tLo7Zt25KVlRWdOHHCsDw/P5/c3NyodevWJp2hTqvVUmBgIE2bNo0EAkGpSUG5XE4eHh7UokULkyYydTodVa9e3RBzaUlBpVJJ3t7e1LRpU5MnMmvWrEnTpk0joVBYaoKtoKCAfH19KTw83OSJzLLGrFKpKCAggBo2bGjyE8AnKS4puGPHjiI/Zs2VSqWijh07Gg0FjoqKIoFAYJgx7mXw1ltv0W+//UZERP/88w95enqWuaaguRg+fDh5eHjQ+vXrqW3btkbrZs6cST4+PqYJzERmzJhBQ4YMMVq2aNEiEovFNGrUKKMExeeff04ymYx27tz5osMsEy8vL6Pe19nZ2dSjRw+SSqW0Z88ew/LKdmydNm1akRpw8+fPJ5FIRKNHjzZaPn36dLKwsKDdu3e/yBDLRKfTkZubm1EiIzMzk7p27UoymcwoMVuZvpOLs2XLFgoODjb6Djt8+DA5OTlReHi40fnatm3bCECR2bfLqlatWoZzgtKSgpXlc9u6dWv66KOPSCqVlpoU1Ol0VL9+fQoODjZpUqh169ZGZR9UKhWNHz+eBAIBLVq0yGjbjh07ko+PzwubBdMc20yNGjWMyoXk5eVR//79SSwWGy3X6XRUp04dCg0NrfQ9HitKaclAc8DJQMbKhxOCL0hiYiIBKPLlrFAoqF27duTm5mb0RbN//34aO3asSYcx7dixg7p3705E+p6CT0oKHjp0iEaPHm3SmHfv3k2dO3cmIn1PwSclBY8cOUKvvfaaSYeB7t+/n9q3b09E+l53T0qwHT9+nEaOHGnSxEZ5Yz516hQNHz68Uhe5f+jRpOCsWbMoODiYUlNTTR3Wc1NQUEAymaxS95gqr59//pneeust+ueff8jLy4uuX79u6Ck4aNAgU4dXIeLi4sjNzY0cHR1p2LBhRuv++usvatiwoYkiM43hw4fThAkTiixft24dCYVCmj17tmGZXC6nwYMHV8oeowqFggDQ+fPnjZar1Wrq1asX2dvbU3R0tGF5ZTq2Dh48uNjvgdWrV5NAIKBffvnFsCw/P58GDRpUKX9w5ubmEgC6fPmy0XKVSkU9evQgR0dHo1IDleE7uSQ///wzhYeHF1l+6dIlsre3L5JEf//992n9+vXlfp3Dhw9T69atiUjfU/BJSUFTf26vX79OYWFhRES0ffv2JyYFr127RgMHDjRpDxFvb29au3ZtkeWTJk0isVhs9B0eFRVFffv2fWG9MM2xzYhEIjp8+LDRMq1WS4MHDyZra2ujicauXLlCgwYNMmknjReFk4GMVT2cEHxBdDod+fj40Pvvv19kXXp6Onl7e9O7775rgshKlpaWZtSjsSxJQVNLT0+nM2fOGO6XJSloapmZmXT69GnD/bIk2EzNHGMuj4dJweDg4BJncX1ZzJs3j+rVq/dSzZT333//kbu7uyEZ+NCePXuK/UFlri5cuECurq4kk8kMPTNiYmIoKCjIaDh8VTBnzhxycnIqdobazz77jGxsbEw+RLGswsLCaOzYsUWW5+bmUvXq1Y1qYVYmP/74I7m6uhb7Pn/yySdkZ2dHWVlZJois/GrWrElvvvlmkeU5OTkUGBhIY8aMMUFU5XfkyBESCARG50UPbd68mQAYjVB5WllZWUYJqbIkBU1JLpcbJYPKkhQ0td69e1O7du2KLNdqtdS2bVtq0aKFCaIqZG5tpkmTJjR48OAiyxUKBdWpU4f69+9vgqhMi5OBjFVNnBB8gf744w8SCoXF1qeYO3cuVatWzQRRlc/jSUGlUkkzZ86slFfGH3o8KVhQUFDpY348waZSqWjmzJmVohdIScwx5pI87Bn4MicDdTod/frrr+Th4WGWs6uWRqFQ0NChQ1+6/SpOdHQ0de3alYRCIYWEhBjqQ1Y12dnZ5OnpSd26dSvS41sul5O9vT1t2LDBRNGVz+rVqwkArVmzpsi65cuXk6OjowmierLMzExyc3Ojnj17Fkmq5Ofnk62tLW3ZssVE0ZXP8uXLSSAQFNtbbsmSJeTq6mqCqJ5OmzZtqHr16sX2dG/RogVNmzbtubzu40lBtVpNM2fOrLS1xx5PCup0Opo1a5bJS8o8dOrUKRIKhcXWOT5x4gQBKNNEhc+LubWZrVu3EgBavHhxkXUbN24kmUxWKZPZzwsnAxmrusRgL8xbb72F/fv3Y+DAgdi4cSO6detmWFe9enUIBAITRlc2b7zxBgD9vmi1Wty+fRs2NjYQCoUmjqxkY8aMAQCMGzcOOp0OUVFRkEqllfr9fu211wDoYycixMfHAwDHXE7JyclYv349dDodunfvjho1ajzxMdu2bcOiRYtw8OBBeHl5vYAon11eXh7WrVuHjIwMtG3bFuHh4aVuf+HCBYwYMQINGzbE2bNn4ePj84IifTYajQZbtmzB3bt30bBhQ3Tu3LnYz5eFhQVWr15tgggrzoEDB3D27FlUq1YNffr0gUwmK3Y7f39/7Nq1C3fv3kVkZCTq1q0LT0/PFxyt6dnZ2WH16tXo2rUrhg4dilWrVkEqlQIALC0t4e3tXamPn48aOnQo9u3bh1GjRkEsFmPgwIGGdZX5XMHBwQGrV69G9+7dMXz4cCxfvtzwN7CysoKnp2eljf1xI0eOxL59+zB8+HCIRCL069fPsK4y/w2Ks2LFCjRt2hSdO3fG7t274ebmZlj3PPdl+PDhAIBRo0aBiJCamgqVSoUpU6Y8l9d7Vj179sTGjRvRv39/jBgxAjY2Nrh79y4mTJhg6tAAAE2bNsU333yDTz/9FBYWFnj//fcN66pXr27CyPTMrc306tUL7777Lt58801IJBKMGjXKsK569eoQCoUgokoX9/OSmJiI3bt3o06dOqYO5amkpKTg008/xbhx40wdCmPmx7T5yKpHqVRS3759SSQS0YwZMygjI4NSU1OpTZs29P3335s6vDKbN28eAaDBgwdX2uEVj5s/fz4BoIEDB5q0ZmB5LFq0iABQv379KnWPxkdVlphPnjxJrq6u1LFjR6pRo4ah92JxPRYfjVOj0VBKSsqLDPWZ3L9/nwIDA6l58+bUsGFDAkB9+/YttqfAo597c2m3D8nlcmrTpg3VqlWL2rRpQ0KhkBo3bmxU5+dR5tLGizN+/Hjy9fWlzp07k6WlJfn5+RlmTX6cuRwXXpRt27aRpaUlNW7cmE6dOkVarZaWLFlCfn5+ZlX/Sa1W08iRI0kgENDUqVMpJSWFMjMzqXv37vTxxx+bOrxSbd68mSwsLKhJkyZ0+vRp0mq1tGjRIrObzVytVtOwYcNIKBTShx9+SGlpaZSRkUFdu3al6dOnmzq8crl+/Tp5e3uTj48Pbdq0iTQaDR07doxcXV3p5s2bz/W1ly5dSgCod+/eZjFi4GHPsbZt21bKWSVnzJhBAGj48OEUHR1NCoWC3njjDRowYICpQzO7NqPVaunNN980zI6dmJhIOTk5NGDAAJo4caKpw2OMsReCE4ImoNVqac6cOeTs7EwCgYDEYjFNmTLFbGYyVSqV1LNnT7NKBhYUFFDv3r3NKhmoUqmoX79+Jk+slUdliVmj0VBAQIBRvbjFixeTpaUldezY0ehHaVZWFjVo0KDILH3monv37jRjxgzD/d27d5ObmxuFhIRQQkKCYblOp6N+/fqZbZ3HadOmUZ8+fQzHyWvXrlHt2rXJycnJqNYpkX4W2c6dO5tV8uGhtWvXUmhoqOGHaGJiInXv3p0kEkmR+of//vsvhYWFGf2dmf6z0bZtWwJAQqGQQkNDzXb4+IIFC8jd3Z0EAgGJRCIaP368WXwfXLlyhVq3bm34G9SqVeu5J56elz/++IPc3NwM52tvvfWW2ZxHPCo5OZmGDRtGIpGIhEIhubq60vbt25/ra6rVaho4cKDZJAN1Oh2NHz++0iYDH9q8eTMFBQUZ2levXr0q1SzX5tZmli1bRt7e3gSARCIRjRw5stIObWeMsYrGCUETUqvVdO3aNbObwfS3334zq2Qgkf5HlTklA4n0CSxTJ9bKq7LEfPv2bQJQ5ITu6NGjZG1tbTTTrFarpZEjR1LNmjXN8gRQIpEUSYjdu3ePfH19qUGDBkb79OOPP5KDgwNFRUW94CifXXh4eJFaP1lZWdS8eXNydXU1msFw+/btZGVlRfv27XvRYT6z8ePH0zvvvGO0TKPR0KhRo0gikdDRo0cNy69du0Zubm5Gs7dWRfHx8dS3b1+Sy+VFlt+8edNsLrYR6euuzZw502iZRqOh69evU1JSkomienpxcXF069Yts/obFMec/waPy8jIoKtXr1bo911xn1sifaKlMiYDt2/fTp988kmxyytjMvDQoUNFvheIiO7cuUP37983QURPZm5tRqvV0s2bN/kCG2OsyhEQEZliqDIzX0QEnU4HkUhk6lDKzBxjBvQ108Ri8yr1WRlizsjIgKurK7Zu3YqePXsarduxYwd69eqFdevWGWpz6XQ6ZGZmwtnZ2RThPhMfHx9MmjQJH3/8sdHyGzduoGnTpnj//ffxxRdfGJanpKQY1ZAyF6+88gpsbW2xZs0ao+WZmZlo3Lgx6tSpg82bNxuWm+t+fvbZZ9i8eTOuXLliVJtVq9Wie/fuiIyMxK1btwxtzFz3s6IkJCSgffv2GD9+PD744ANTh/NMVq1ahY8//hj79u1DSEiIqcNhrEye9LmtDOcEj9qxYwfGjh2L7du3o3HjxkXWq9VqSCQSE0RWvMOHD+PVV1/FunXr0LZtW1OHwxhj7CXDCUHG2Eupf//+uHLlCs6fPw97e3ujdcOHD0dKSgr27t1rougqzv/+9z/88ssvOHfuHIKDg43Wff/995g7dy4SExNNFF3F2bhxIwYOHIgdO3age/fuRuv+++8/9OzZEwkJCfDw8DBRhBXjzp07qFWrFr7++mt88sknRutiYmIQFBSE7du3o2vXriaKsPLgZCBjpmVun9snJQMrG04GMsYYe94q79SwjDH2DObOnYvs7Gy88soryMvLM1rXu3dvwyzI5m7atGnw9/dHt27dEBsba7Sud+/eSE5OhkajMVF0Fad///7o378/Bg8ejJMnTxqt69atGyQSCRISEkwUXcUJDg7G559/junTp2PFihVG6/z8/FC/fv2X5rP7LDgZyJhpmdvnlpOBjDHGWFGcEGSMvZR8fHywY8cOXLt2DW3atMG9e/cM644ePYpWrVqZMLqKY2lpiZ07d0IgEKBFixY4ceKEYd3Ro0fRrFmzSjVc61msWLECDRs2ROfOnY2GDp86dQq2trYIDQ01YXQV57PPPsO4cePw2muv4ZtvvoFWqwUAJCUlISIiAi1atDBxhKbFyUDGTMvcPrecDGSMMcaKx0OGGWMvtevXr2PIkCG4e/cuunfvjpycHKSkpODQoUNmWTOwJMnJyRgxYgT279+Pjh07wsbGBmfOnMHevXsRFhZm6vAqjFKpxKRJk7B48WI0btwYNWrUwN69e7Fs2bIi9SLN3cyZM/H555/Dz88PzZo1w4EDBzBlyhSzT4I9C04GMmZa5va55WQgY4wxVjJOCDLGXnparRabN2/G2bNnUa1aNYwcORJWVlamDuu5OHDgAA4cOAAHBwe89tprcHV1NXVIz8Xly5exdetWEBGGDBlSpH7iyyImJgbr1q1DZmYmevbsWeV7B/7xxx+Qy+VmnwzUarXo27cvZs2aZRZJFcYA8/zcDh48GB9++KFZJAMBYPTo0Xj99dc5GcgYY+yF4IQgY4wxxhhjjDHGGGNVCNcQZIwxxhhjjDHGGGOsCuGEIGOMMcYYY4wxxhhjVQgnBBljjDHGGGOMMcYYq0I4IcgYY4wxxhhjjDHGWBXCCUHGGGOMMcYYY4wxxqoQTggyxhhjjDHGGGOMMVaFcEKQMcYYY4wxxhhjjLEqhBOCjDHGGGOMMcYYY4xVIZwQZIwxxhhjjDHGGGOsCuGEIGOMMcYYY4wxxhhjVQgnBBljjDHGGGOMMcYYq0I4IcgYY4wxxhhjjDHGWBXCCUHGGGOMMcYYY4wxxqoQTggyxhhjjDHGGGOMMVaFcEKQMcYYY4wxxhhjjLEqhBOCjDHGGGOMMcYYY4xVIZwQZIwxxhhjjDHGGGOsCuGEIGOMMcYYY4wxxhhjVQgnBBljjDHGGGOMMcYYq0I4IcgYY4wxxhhjjDHGWBXCCUHGGGOMMcYYY4wxxqoQTggyxhhjjDHGGGOMMVaFcEKQMcYYY4wxxhhjjLEqhBOCjDHGGGOMMcYYY4xVIZwQZIwxxhhjjDHGGGOsCuGEIGOMMcYYY4wxxhhjVQgnBBljjDHGGGOMMcYYq0I4IcgYY4wxxhhjjDHGWBXCCUHGGGOMMcYYY4wxxqoQsakDYKwySUpKgkajAQDY29vD1tbWxBExxgBum4xVVtw2GaucuG0yVjlx22SViYCIyNRBMFYZqFQqhISEQKVSgYiQnp6OgIAA/PXXX2jZsqWpw2OsyuK2yVjlxG2TscqJ2yZjlRO3TVbZcEKQsRIUFBRg0qRJOHbsGG7cuGHqcBhjD3DbZKxy4rbJWOXEbZOxyonbJjM1riHI2GOICGlpaUhNTUWdOnUQFxdnWKdUKvHRRx+hWbNmGDZsGGJiYkwYKWNVS2lt85NPPkH9+vVRv3597Ny504RRMlb1lNY279y5gzFjxqBVq1aYPHkyUlNTTRgpY1VLaW0zLS0N7733Hlq2bIkRI0bg2rVrJoyUsaqltLb50NmzZ9GgQQNs3brVBBGyqoITgow9sH//fnTs2BFWVlYIDg5Gs2bN8MknnyAoKMiwzYwZM3D69Gl8//33cHNzw4ABA0wYMWNVQ1na5oQJE7Bs2TJYW1sjIyPDhNEyVnWUpW0OGjQIbdq0wcyZMxEbG4shQ4aYMGLGqoaytM3JkyejZs2a+Omnn1CtWjV06tQJOp3OhFEz9vIrS9sE9D0Hp06dCpFIxOe17LniSUUYA3DkyBF07doVc+bMwebNmw3FXcPDw1GvXj3Ddn/99RcOHjyIevXqoW3btvDx8cHFixfRoEEDU4XO2EutrG3T398f/v7+XJiZsRekrG3zzJkzkMlkAABXV1eEh4ebJF7Gqoqyts1ly5ZBIpEAABwcHDB37lxotVoIhdxfhLHnoaxtEwA+++wzvPXWW1izZo0pQmVVCB/xGQOwYcMG1KhRA++++67h4Lxv3z6cO3cOjRs3BgBkZGQgKysLtWvXBgAIhULUrl0b9+7dM1ncjL3sytI2GWMvXlnb5sNkIABs374dnTp1euGxMlaVlLVtSiQSTJ8+HbVr10abNm2wfv16Q4KQMVbxyto2T548icjISAwfPtxUobIqhBOCjAGoXr06IiMjsXHjRty6dQvz58/HW2+9BQCGA7RCoYBYLIZIJDI8TiaTQaFQmCRmxqqCsrRNxtiLV962uW3bNixduhTz589/0aEyVqWUp22++eabWLx4McaMGYPJkydDqVSaImTGqoSy/t58//338fvvv5syVFaF8CzDjAHQaDSYNm0atm/fDqlUih49eqB27dqYPn067ty5A6lUCo1GA5lMhoSEBLi7uwMAGjRogFmzZnGPB8aek7K0zUd169YNI0aMwIgRI0wUMWNVQ3na5r///osvv/wSu3fvhpeXlwmjZuzlV97vzYf8/Pywbt06NGvW7AVHzFjVUJa2uWnTJowdOxZ+fn4AgKioKNjb2+Pjjz/GxIkTTbwH7GXECUHGyqFbt25o2bIlZsyYgTNnzqB79+6IjY2FlZWVqUNjjIETgoxVNitXrsTMmTOxd+9eeHp6mjocxhgArVaLBQsW4O2334ZAIMCFCxfQqlUrREZGwsPDw9ThMVZlZWdnIyoqynD/3XffRadOnfDGG29w22TPBU8qwlg5zJw5Ez169MDixYuRnp6O33//nZOBjFUCCxYswIIFCxAZGYmbN29i9uzZ2LlzJ/dGYsyE5HI5XnvtNfj6+qJ79+6G5WfOnCmxlxJj7PkTiUSIjo6Gm5sbHBwckJ6ejnnz5nHCgTETs7e3R/369Q337ezs4Ofnx22TPTfcQ5CxclKpVIiIiICXlxfs7e1NHQ5jDEBSUhKSkpKMloWFhXHSgTET0ul0uHLlSpHl9erVg0AgMEFEjLFH5ebmIiUlBb6+vvx9yVgl9HDIsJOTk6lDYS8pTggyxhhjjDHGGGOMMVaF8CzDjDHGGGOMMcYYY4xVIZwQZIwxxhhjjDHGGGOsCuGEIGOMMcYYY4wxxhhjVQgnBBljjDHGGGOMMcYYq0I4IcgYY4wxxhhjjDHGWBXCCUHGGGOMMcYYY4wxxqoQTggyxhhjjDHGGGOMMVaFcEKQMcYYY4wxxhhjjLEqhBOCjDHGGGOMMcYYY4xVIZwQZIwxxhhjjDHGGGOsCuGEIGOMMcYYY4wxxhhjVcj/AbQD8VGFttmDAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "pooled = np.vstack([samples[n][:, p.columns(quartic.params)] for n, p in good.items()])\n", + "span = list(zip(*np.percentile(pooled, [0.5, 99.5], axis=0)))\n", + "fig = None\n", + "for name, p in good.items():\n", + " fig = corner.corner(\n", + " samples[name][:, p.columns(quartic.params)],\n", + " fig=fig,\n", + " labels=[f\"${c.latex}$\" for c in quartic.params],\n", + " truths=a_true,\n", + " range=span,\n", + " **plotstyle.corner_kwargs(\n", + " color=style[name][0],\n", + " fill_contours=False,\n", + " plot_density=False,\n", + " show_titles=False,\n", + " levels=(0.68, 0.95),\n", + " ),\n", + " )\n", + "fig.legend(\n", + " handles=[plt.Line2D([], [], color=style[n][0], label=n) for n in good],\n", + " loc=\"upper right\",\n", + " fontsize=9,\n", + ")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "170a3d38", + "metadata": {}, + "source": [ + "None of the three is right everywhere, and the reason is experiment S, which quoted 5 % and is 25 % high. Treatments 1 and 2 both take that quote at face value — 1 through its prior on $\\rho_S$, 2 through the fixed width of its mode — so S's points count as nearly exact measurements of the normalisation, and they lift the whole curve. $a_0$ comes out at 1.10 and 1.12, against a truth of 1, and their bands sit above the truth over most of the range. Treatment 3's band is about 60 % wider, but it does not correct S: its centre is just as high ($a_0 = 1.13$). As we'll see below, its inferred width for S barely moves from the quote. Among the coefficients, $a_0$ and $a_1$ are pinned down well, $a_2$ moderately, and $a_3$ and $a_4$ only loosely: four experiments over $-0.5 < x < 0.6$ cannot fix a quartic's higher terms, which is why every band flares at the edges." + ] + }, + { + "cell_type": "markdown", + "id": "d1850376", + "metadata": {}, + "source": [ + "### What the normalisations came out as\n", + "\n", + "Treatment 1 infers each $\\rho_k$ directly, so we can hold them up against the values we planted. Treatment 3 infers each *width* $\\omega_k$: it does not say which way a dataset moved, only how far the fit is prepared to let it move." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "df3d2f90", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " quoted true rho inferred rho (68 %) inferred width (68 %)\n", + "exp P 10% 0.92 0.83 [0.79, 0.88] 15% [9%, 26%]\n", + "exp Q 50% 1.30 1.23 [1.16, 1.30] 39% [22%, 73%]\n", + "exp R 20% 0.85 0.82 [0.77, 0.87] 22% [12%, 37%]\n", + "exp S 5% 1.25 1.06 [1.01, 1.10] 7% [3%, 15%]\n" + ] + } + ], + "source": [ + "p_rho, s_rho = good[\"1: inferred normalisations\"], samples[\"1: inferred normalisations\"]\n", + "p_omega, s_omega = good[\"3: inferred systematics\"], samples[\"3: inferred systematics\"]\n", + "print(\n", + " f\"{'':6s} {'quoted':>6s} {'true rho':>9s} {'inferred rho (68 %)':>21s} {'inferred width (68 %)':>20s}\"\n", + ")\n", + "for label in comps:\n", + " r16, r50, r84 = np.percentile(\n", + " np.exp(s_rho[:, p_rho.columns(rhos[label])]), [16, 50, 84]\n", + " )\n", + " w16, w50, w84 = np.percentile(\n", + " np.exp(s_omega[:, p_omega.columns(omegas[label])]), [16, 50, 84]\n", + " )\n", + " print(\n", + " f\"{label:6s} {settings[label]['sys']:6.0%} {settings[label]['rho']:9.2f} \"\n", + " f\"{r50:7.2f} [{r16:.2f}, {r84:.2f}] {w50:7.0%} [{w16:.0%}, {w84:.0%}]\"\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "6858767a", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "positions = np.arange(len(comps))\n", + "rho_q = np.array(\n", + " [\n", + " np.percentile(np.exp(s_rho[:, p_rho.columns(rhos[l])]), [16, 50, 84])\n", + " for l in comps\n", + " ]\n", + ")\n", + "ax.errorbar(\n", + " positions,\n", + " np.ones(len(comps)),\n", + " [settings[l][\"sys\"] for l in comps],\n", + " fmt=\"none\",\n", + " ecolor=\"0.6\",\n", + " capsize=8,\n", + " label=\"what was quoted\",\n", + ")\n", + "ax.errorbar(\n", + " positions,\n", + " rho_q[:, 1],\n", + " [rho_q[:, 1] - rho_q[:, 0], rho_q[:, 2] - rho_q[:, 1]],\n", + " fmt=\"o\",\n", + " color=style[\"1: inferred normalisations\"][0],\n", + " label=r\"inferred $\\rho_k$ (median, 68 %)\",\n", + ")\n", + "ax.plot(\n", + " positions,\n", + " [settings[l][\"rho\"] for l in comps],\n", + " \"x\",\n", + " ms=11,\n", + " color=\"k\",\n", + " label=r\"true $\\rho_k$\",\n", + ")\n", + "ax.set(\n", + " xticks=positions,\n", + " xticklabels=list(comps),\n", + " ylabel=r\"$\\rho$\",\n", + " title=\"Planted and inferred normalisations\",\n", + ")\n", + "ax.legend(fontsize=8)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "159ffe63", + "metadata": {}, + "source": [ + "Treatment 1's normalisations tell the same story from the other side. Where the experiments overlap, the data fix the *ratios* of their normalisations, but the overall scale trades against the curve, and it is set by the priors, weighted by how tightly each was quoted. S's 5 % prior is by far the tightest, so it wins: $\\rho_S$ comes out at 1.06 rather than 1.25, the curve moves up to stay consistent with S, and the other normalisations move down with it — P to 0.83, against a true 0.92. Treatment 3's widths do not rescue S either: its inferred width is 7 % [3 %, 15 %], a little above its quote but nowhere near the 25 % it needed. Fifteen points with noise of 0.2 cannot say much more.\n", + "\n", + "The lesson is uncomfortable, and general. A badly wrong, tightly quoted systematic biases every treatment that trusts its quote, and comparing the inferred normalisations with the quotes does not find the culprit: measured in units of its own quote, P looks the most discrepant ($\\rho_P$ is 1.7 quoted widths below one, $\\rho_S$ only 1.2 above), because the overall scale follows S. Finding the dataset to distrust takes a different tool, such as leaving each dataset out in turn and asking how well the others predict it (recipe 30)." + ] + }, + { + "cell_type": "markdown", + "id": "3ed8a321", + "metadata": {}, + "source": [ + "## Three things not to do\n", + "\n", + "4. **Peelle's Pertinent Puzzle.** The tempting shortcut is to build the systematic mode from the measured values, $\\sigma^\\text{sys}_k\\, y_{k,i}$, instead of the prediction. `rxmc` will let us: any vector is a term (recipe 19), so the mistake is easy to spell. It is the covariance behind [Peelle's Pertinent Puzzle](https://en.wikipedia.org/wiki/Peelle%27s_Pertinent_Puzzle): the fluctuations feed back into the covariance and pull the fit *below* the data. [D'Agostini (1994)](https://doi.org/10.1016/0168-9002(94)90719-6) diagnosed it, [Frühwirth, Neudecker & Leeb (2012)](https://doi.org/10.1051/epjconf/20122700008) wrote out the solution, and recipes 27 and 37 carry the closed forms.\n", + "5. **Ignore the systematics.** The default constraint uses the reported statistical errors and nothing else.\n", + "6. **Infer the statistical errors instead** (recipe 2): `T.proportional_error(log_eps)` with `statistical=False` replaces the reported noise with a free one proportional to the prediction." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "3276affc", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "4: PPP, mode from the data ['a0', 'a1', 'a2', 'a3', 'a4']\n", + "5: systematics ignored ['a0', 'a1', 'a2', 'a3', 'a4']\n", + "6: statistics inferred ['a0', 'a1', 'a2', 'a3', 'a4', 'log_eps']\n" + ] + } + ], + "source": [ + "log_eps = rx.Parameter(\n", + " \"log_eps\", prior=stats.norm(np.log(0.1), 1.0), latex=r\"\\log\\epsilon\"\n", + ")\n", + "bad = {\n", + " \"4: PPP, mode from the data\": rx.Problem(\n", + " [\n", + " rx.Constraint(\n", + " list(comps.values()),\n", + " terms=[\n", + " rx.Term(settings[l][\"sys\"] * datasets[l].y, kind=\"mode\", on=c)\n", + " for l, c in comps.items()\n", + " ],\n", + " )\n", + " ]\n", + " ),\n", + " \"5: systematics ignored\": rx.Problem([rx.Constraint(list(comps.values()))]),\n", + " \"6: statistics inferred\": rx.Problem(\n", + " [\n", + " rx.Constraint(\n", + " list(comps.values()),\n", + " terms=[T.proportional_error(log_eps)],\n", + " statistical=False,\n", + " )\n", + " ]\n", + " ),\n", + "}\n", + "for name, p in bad.items():\n", + " print(f\"{name:28s} {p.names}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "5181b7b0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "4: PPP, mode from the data R-hat 1.001, min bulk ESS 2407, 0 divergences\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5: systematics ignored R-hat 1.002, min bulk ESS 1559, 0 divergences\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "6: statistics inferred R-hat 1.004, min bulk ESS 2707, 0 divergences\n", + "CPU times: user 20min, sys: 7.87 s, total: 20min 8s\n", + "Wall time: 3min 3s\n" + ] + } + ], + "source": [ + "%%time\n", + "samples.update(\n", + " {\n", + " name: fit(p, seed=10 + k, label=f\"{name:28s}\")\n", + " for k, (name, p) in enumerate(bad.items())\n", + " }\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "36fb8570", + "metadata": {}, + "source": [ + "We compare them the same way, alongside treatment 3, the defensible treatment that makes the fewest assumptions about the quotes." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "5145f7fb", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " mean width a0 (68 %), truth 1.0\n", + "1: inferred normalisations 0.16 1.10 [1.03, 1.16]\n", + "2: quoted systematics 0.17 1.12 [1.05, 1.19]\n", + "3: inferred systematics 0.26 1.13 [0.99, 1.24]\n", + "4: PPP, mode from the data 0.13 0.81 [0.76, 0.87]\n", + "5: systematics ignored 0.08 0.89 [0.87, 0.91]\n", + "6: statistics inferred 0.12 0.96 [0.93, 0.99]\n" + ] + } + ], + "source": [ + "problems = {**good, **bad}\n", + "residual_bands.update(\n", + " {name: band_of(p, samples[name], minus_truth=True) for name, p in bad.items()}\n", + ")\n", + "scorecard(problems)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "c2249ea7", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# treatment 3 as the reference: it trusts the quotes least\n", + "residual_plot(\n", + " [\"3: inferred systematics\", *bad],\n", + " \"68 % bands of the fitted curve minus the truth: the other three\",\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "eeb4bb99", + "metadata": {}, + "source": [ + "The three mistakes go wrong in three different ways.\n", + "\n", + "- **Ignoring the systematics** gives the narrowest band of all (mean width 0.08): it treats the four normalisations as exact, so their disagreement becomes a confident compromise.\n", + "- **Peelle's covariance** does what the puzzle predicts and pulls the curve below the data: $a_0 = 0.81$, and its band lies under the truth over most of the range.\n", + "- **Inferring the statistical errors** lands closer to the truth than we might expect ($a_0 = 0.96$). A noise term proportional to the prediction gives every point the same relative weight, so S's tight quote no longer dominates, and with these four normalisations the compromise happens to land near the truth. It is close to the truth for the wrong reason (its 68 % interval still misses $a_0 = 1$): the band's width comes from the scatter of the datasets about each other, not from any model of their normalisations, and it has no way to say which dataset is off. Mis-quote a different experiment and it lands wherever the compromise does." + ] + }, + { + "cell_type": "markdown", + "id": "68790f1d", + "metadata": {}, + "source": [ + "### Are the predictions calibrated?\n", + "\n", + "The bands above are the curve alone, with no experimental error, so they show where each treatment puts the truth, not whether its error model is believable. That is a question for the posterior predictive of the measured data: if a treatment's error model is right, its central 68 % predictive interval should contain about 68 % of the points, and likewise at every level, so its empirical [coverage](https://en.wikipedia.org/wiki/Coverage_probability) follows the diagonal (recipe 17). The grey band is one binomial standard deviation for the number of points we have." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "88384cd4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "120 measured points; coverage at a nominal 0.7:\n", + " 1: inferred normalisations 0.75\n", + " 2: quoted systematics 0.62\n", + " 3: inferred systematics 0.84\n", + " 4: PPP, mode from the data 0.76\n", + " 5: systematics ignored 0.38\n", + " 6: statistics inferred 0.70\n" + ] + } + ], + "source": [ + "levels = np.linspace(0.05, 0.95, 19)\n", + "coverage = {}\n", + "for k, (name, p) in enumerate(problems.items()):\n", + " c = p.constraints[0]\n", + " draws = rx.diagnostics.predictive_draws(\n", + " p, samples[name][::20], n_rep=2, rng=30 + k, return_draws=True\n", + " )\n", + " coverage[name] = rx.diagnostics.coverage_curve(draws, c.y[c.active], levels)\n", + "n_points = problems[\"1: inferred normalisations\"].constraints[0].n_active\n", + "print(f\"{n_points} measured points; coverage at a nominal 0.7:\")\n", + "for name, cov in coverage.items():\n", + " print(f\" {name:28s} {cov[np.argmin(np.abs(levels - 0.7))]:.2f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "32eaf3f2", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(1, 2, figsize=(9.0, 4.4), sharey=True)\n", + "binomial = np.sqrt(levels * (1 - levels) / n_points)\n", + "for ax, names, title in (\n", + " (axes[0], list(good), \"the defensible three\"),\n", + " (axes[1], list(bad), \"the other three\"),\n", + "):\n", + " ax.plot([0, 1], [0, 1], \"--\", color=\"0.5\", label=\"nominal\")\n", + " ax.fill_between(levels, levels - binomial, levels + binomial, color=\"0.88\")\n", + " for name in names:\n", + " ax.plot(levels, coverage[name], \"o-\", ms=3, color=style[name][0], label=name)\n", + " ax.set(xlabel=\"nominal coverage\", xlim=(0, 1), ylim=(0, 1), title=title)\n", + " ax.legend(fontsize=7, loc=\"upper left\")\n", + "axes[0].set_ylabel(\"empirical coverage\")\n", + "fig.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "789acd2d", + "metadata": {}, + "source": [ + "Ignoring the systematics is the only treatment whose predictive is plainly miscalibrated: at a nominal 0.7 it covers 0.38 of the 120 points, because it gives the measurements no room to disagree by a normalisation. Treatment 3 over-covers (0.84), the price of its wider band, and the rest sit within about two binomial standard deviations (0.04 at that level). The band understates the real scatter, since points from one experiment share a normalisation and are not independent.\n", + "\n", + "The right panel holds the lesson: Peelle's covariance and the inferred statistical errors both predict the *data* about as well as the defensible treatments do, while their curves are off the truth. A calibrated predictive of the measurements does not make the physics right." + ] + }, + { + "cell_type": "markdown", + "id": "43ee1717", + "metadata": {}, + "source": [ + "### Peelle's puzzle in a two-point case like the one it was found in\n", + "\n", + "The puzzle is easiest to see with two measurements of one constant $t$: values $1.5$ and $1.0$, each with a statistical error $\\sigma = 0.1$, sharing a 20 % normalisation uncertainty. With the mode built from the data, the best fit has the closed form (recipe 27)\n", + "\n", + "\\begin{equation}\n", + "\\hat t = \\frac{\\bar y}{1 + (s/\\sigma)^2 \\sum_i (y_i - \\bar y)^2},\n", + "\\end{equation}\n", + "\n", + "with $s = 0.2$, and it lands *below both* measurements. Built from the prediction, the mode leaves the estimate between them." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "77f56dc8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "mode from the data t = 0.833\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "mode from the prediction t = 1.204\n", + "closed form (data mode) t = 0.833\n" + ] + } + ], + "source": [ + "y2 = np.array([1.5, 1.0])\n", + "d2 = rx.Dataset(np.array([0.0, 1.0]), y2, np.full(2, 0.1), label=\"two points\")\n", + "t = rx.Parameter(\"t\", prior=stats.norm(1.0, 1.0), latex=\"t\")\n", + "const = rx.Comparison(d2, rx.Model(lambda x, t: t + 0.0 * x, [t]))\n", + "from_data = rx.Problem([rx.Constraint([const], terms=[rx.Term(0.2 * y2, kind=\"mode\")])])\n", + "from_prediction = rx.Problem(\n", + " [rx.Constraint([const], terms=[T.normalization(magnitude=0.2)])]\n", + ")\n", + "closed_form = y2.mean() / (1 + (0.2 / 0.1) ** 2 * np.sum((y2 - y2.mean()) ** 2))\n", + "for name, p in (\n", + " (\"mode from the data\", from_data),\n", + " (\"mode from the prediction\", from_prediction),\n", + "):\n", + " print(f\"{name:25s} t = {rx.optimize.find_mle(p, rng=0).x[0]:.3f}\")\n", + "print(f\"{'closed form (data mode)':25s} t = {closed_form:.3f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "1c94ba90", + "metadata": {}, + "source": [ + "## A gallery of covariance structures\n", + "\n", + "Every term writes a pattern into $\\Sigma$, and the compiled constraint's `matrix(theta)` (`problem.constraints[0].matrix(theta)`) hands us the assembled covariance at any parameter values, so we can simply look. We evaluate them at a reference point: the posterior median of treatment 2's coefficients." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "dd06628c", + "metadata": {}, + "outputs": [], + "source": [ + "def correlation(S):\n", + " d = np.sqrt(np.diag(S))\n", + " return S / np.outer(d, d)\n", + "\n", + "\n", + "def show(ax, S, title, dividers=()):\n", + " im = ax.imshow(correlation(S), cmap=\"RdBu_r\", vmin=-1, vmax=1)\n", + " for k in dividers:\n", + " ax.axhline(k - 0.5, color=\"k\", lw=0.5)\n", + " ax.axvline(k - 0.5, color=\"k\", lw=0.5)\n", + " ax.set(title=title, xticks=[], yticks=[])\n", + " ax.grid(False)\n", + " return im\n", + "\n", + "\n", + "first = comps[\"exp P\"]\n", + "p_ref = good[\"2: quoted systematics\"]\n", + "theta_ref = np.median(\n", + " samples[\"2: quoted systematics\"][:, p_ref.columns(quartic.params)], axis=0\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "d05c8386", + "metadata": {}, + "source": [ + "### 1. A systematic correlated across $x$: flat mode versus smooth kernel\n", + "\n", + "A normalisation is a rank-one mode: every pair of points is correlated by the same fraction, however far apart they are. A Gaussian-process kernel instead correlates neighbours in $x$ and forgets across the range. Both are one term, and both sit on top of the reported statistical diagonal, which keeps the off-diagonal correlations below one." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "08d4ad41", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "p_flat = rx.Problem([rx.Constraint([first], terms=[T.normalization(magnitude=0.1)])])\n", + "p_kernel = rx.Problem(\n", + " [\n", + " rx.Constraint(\n", + " [first], terms=[T.kernel(0.05**2 * tinygp.kernels.ExpSquared(scale=0.15))]\n", + " )\n", + " ]\n", + ")\n", + "fig, axes = plt.subplots(1, 2, figsize=(7.6, 3.6))\n", + "show(\n", + " axes[0], p_flat.constraints[0].matrix(theta_ref), \"normalisation mode + statistical\"\n", + ")\n", + "im = show(axes[1], p_kernel.constraints[0].matrix(theta_ref), \"kernel + statistical\")\n", + "fig.colorbar(im, ax=axes, shrink=0.85, label=\"correlation\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "b373132d", + "metadata": {}, + "source": [ + "### 2. Correlated statistical errors: bring the matrix, do not diagonalise it\n", + "\n", + "If an experiment reports a full statistical covariance, we pass it as a fixed `Term` (recipe 19). Treating correlated noise as independent over-counts the information, and the naive posterior comes out narrower than the data support." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "28c217a4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "full matrix: R-hat 1.002, min bulk ESS 1239, 0 divergences\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "diagonal only: R-hat 1.002, min bulk ESS 1101, 0 divergences\n", + "diagonal only m = 0.797 [0.769, 0.823] (truth 0.8)\n", + "full matrix m = 0.809 [0.758, 0.858] (truth 0.8)\n" + ] + } + ], + "source": [ + "xs = np.linspace(0.0, 4.0, 20)\n", + "cov_corr = 0.15**2 * np.exp(-np.abs(xs[:, None] - xs[None, :]) / 1.2)\n", + "y_corr = 1.0 + 0.8 * xs + rng.multivariate_normal(np.zeros(20), cov_corr)\n", + "d_corr = rx.Dataset(xs, y_corr, np.sqrt(np.diag(cov_corr)), label=\"correlated noise\")\n", + "m_ = rx.Parameter(\"m\", prior=stats.norm(0, 5), latex=\"m\")\n", + "b_ = rx.Parameter(\"b\", prior=stats.norm(0, 5), latex=\"b\")\n", + "line = rx.Model(lambda x, m, b: b + m * x, [m_, b_])\n", + "p_full = rx.Problem(\n", + " [\n", + " rx.Constraint(\n", + " [rx.Comparison(d_corr, line)],\n", + " terms=[rx.Term(cov_corr, kind=\"matrix\")],\n", + " statistical=False,\n", + " )\n", + " ]\n", + ")\n", + "p_diag = rx.Problem([rx.Constraint([rx.Comparison(d_corr, line)])])\n", + "s_full = fit(p_full, seed=21, label=\"full matrix: \")\n", + "s_diag = fit(p_diag, seed=22, label=\"diagonal only: \")\n", + "for name, p, s in ((\"diagonal only\", p_diag, s_diag), (\"full matrix\", p_full, s_full)):\n", + " lo, mid, hi = np.percentile(s[:, p.columns(m_)], [16, 50, 84])\n", + " print(f\"{name:14s} m = {mid:.3f} [{lo:.3f}, {hi:.3f}] (truth 0.8)\")" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "5930c6e2", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig = corner.corner(\n", + " s_diag,\n", + " labels=[\"$m$\", \"$b$\"],\n", + " truths=[0.8, 1.0],\n", + " **plotstyle.corner_kwargs(\n", + " color=plotstyle.COLOURS[1], fill_contours=False, show_titles=False\n", + " ),\n", + ")\n", + "corner.corner(\n", + " s_full,\n", + " fig=fig,\n", + " **plotstyle.corner_kwargs(\n", + " color=plotstyle.COLOURS[0], fill_contours=False, show_titles=False\n", + " ),\n", + ")\n", + "fig.legend(\n", + " handles=[\n", + " plt.Line2D(\n", + " [], [], color=plotstyle.COLOURS[1], label=\"diagonal (overconfident)\"\n", + " ),\n", + " plt.Line2D([], [], color=plotstyle.COLOURS[0], label=\"full matrix\"),\n", + " ],\n", + " loc=\"upper right\",\n", + ")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "e821df5c", + "metadata": {}, + "source": [ + "The diagonal-only posterior for $m$ is little more than half as wide as the full-matrix one (68 % half-widths of 0.027 against 0.050). Here both happen to contain the truth, but the diagonal fit claims a precision the data don't have.\n", + "\n", + "### 3. Unknown or misreported magnitudes\n", + "\n", + "A `proportional_error` term adds a diagonal error proportional to a reference value, and its fraction $\\gamma$ sets how far the total error exceeds what was reported. With `averaging=True`, as in KDUQ, the reference is the mean of the data and the prediction, $(y + y_m)/2$, rather than the prediction alone. Because the noisy data enter that reference, the total error below is jagged from point to point." + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "bd8b75b5", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "log_gamma = rx.Parameter(\n", + " \"log_gamma\", prior=stats.norm(np.log(0.05), 1.0), latex=r\"\\log\\gamma\"\n", + ")\n", + "d0 = datasets[\"exp P\"]\n", + "p_gamma = rx.Problem(\n", + " [rx.Constraint([first], terms=[T.proportional_error(log_gamma, averaging=True)])]\n", + ")\n", + "fig, ax = plt.subplots()\n", + "ax.plot(d0.x, d0.y_err, \"--\", color=\"k\", label=\"reported\")\n", + "theta = np.zeros(p_gamma.ndim) # filled by name, never by position\n", + "theta[p_gamma.columns(quartic.params)] = theta_ref\n", + "for g, colour in zip((0.02, 0.05, 0.10), plotstyle.COLOURS):\n", + " theta[p_gamma.columns(log_gamma)] = np.log(g)\n", + " total = np.sqrt(np.diag(p_gamma.constraints[0].matrix(theta)))\n", + " ax.plot(d0.x, total, color=colour, label=rf\"$\\gamma$ = {g}\")\n", + "ax.set(\n", + " xlabel=\"$x$\",\n", + " ylabel=\"total standard deviation\",\n", + " title=r\"Experiment P: reported error and the $\\gamma$-inflated total\",\n", + ")\n", + "ax.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "d9918c68", + "metadata": {}, + "source": [ + "### 4. A systematic shared across datasets\n", + "\n", + "Two datasets may share one normalisation *magnitude* without sharing the normalisation itself (recipe 5, case B): one parameter, and one mode `on` each comparison, leaves the covariance block diagonal, so the datasets stay independent. If both were normalised against the same uncertain flux, one mode `on` both comparisons couples their blocks (case A). Both spellings have exactly one nuisance parameter; which is right depends on whether the two experiments really shared a calibration, and treating case-A data as case B is overconfident." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "90888842", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "log_omega_shared = rx.Parameter(\n", + " \"log_omega\", prior=stats.norm(np.log(0.1), 1.0), latex=r\"\\log\\omega\"\n", + ")\n", + "two = [comps[\"exp Q\"], comps[\"exp R\"]]\n", + "case_a = rx.Constraint(two, terms=[T.normalization(log_omega_shared, on=two)])\n", + "case_b = rx.Constraint(\n", + " two, terms=[T.normalization(log_omega_shared, on=c) for c in two]\n", + ")\n", + "fig, axes = plt.subplots(1, 2, figsize=(7.6, 3.6))\n", + "for ax, c, title in zip(\n", + " axes,\n", + " (case_a, case_b),\n", + " (\"case A: one mode on both\", \"case B: one magnitude, a mode each\"),\n", + "):\n", + " p_two = rx.Problem([c])\n", + " theta_two = np.zeros(p_two.ndim)\n", + " theta_two[p_two.columns(quartic.params)] = theta_ref\n", + " theta_two[p_two.columns(log_omega_shared)] = np.log(0.1)\n", + " show(\n", + " ax,\n", + " p_two.constraints[0].matrix(theta_two),\n", + " title,\n", + " dividers=(datasets[\"exp Q\"].n,),\n", + " )\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "c170692f", + "metadata": {}, + "source": [ + "## Takeaways\n", + "\n", + "- Model every dataset's normalisation: as a parameter (1), as a mode with the quoted width (2), or as a mode with a free width (3). Ignoring it gives the narrowest and the most overconfident answer.\n", + "- Build a normalisation mode from the prediction, never from the data: that is Peelle's puzzle (recipe 27). `T.normalization` and `reported_terms()` do it for us.\n", + "- A tightly quoted, badly wrong systematic biases every treatment that trusts the quote, and comparing inferred normalisations with the quotes can point at the wrong dataset. Leaving each dataset out in turn (recipe 30) is the check that finds it. Inferring the widths widens the answer, honestly, but here it did not correct the bias.\n", + "- An inferred statistical noise is not a model of the systematics: even when it lands near the truth, it cannot say which dataset is off.\n", + "- Pass a reported correlated covariance as a matrix term. Diagonalising it gives an overconfident posterior.\n", + "- A mode built from the prediction has a sign-flipped basin the sampler cannot cross, so start near the mode (`find_map`), in a ball wide enough for $\\hat R$ to mean something." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/normalization_inference.ipynb b/examples/normalization_inference.ipynb deleted file mode 100644 index 6b89d43..0000000 --- a/examples/normalization_inference.ipynb +++ /dev/null @@ -1,2196 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "196a680f-91b8-4c45-8894-f56175a73082", - "metadata": {}, - "source": [ - "# Bayesian calibration of polynomials, including inference of overall normalization" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "c549ae62-7f81-4a8e-a54e-a7331a298c90", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:07:06.821557Z", - "iopub.status.busy": "2026-08-11T03:07:06.821382Z", - "iopub.status.idle": "2026-08-11T03:07:07.527172Z", - "shell.execute_reply": "2026-08-11T03:07:07.526332Z" - } - }, - "outputs": [], - "source": [ - "import corner" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "a55118c3-ccbf-45bf-81a9-bdf6e9daf46c", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:07:07.528701Z", - "iopub.status.busy": "2026-08-11T03:07:07.528499Z", - "iopub.status.idle": "2026-08-11T03:07:07.958886Z", - "shell.execute_reply": "2026-08-11T03:07:07.958243Z" - } - }, - "outputs": [], - "source": [ - "import numpy as np\n", - "from matplotlib import pyplot as plt\n", - "from scipy import stats" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "22715d9f-6d09-4444-b9a5-243a1274c05c", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:07:07.960611Z", - "iopub.status.busy": "2026-08-11T03:07:07.960418Z", - "iopub.status.idle": "2026-08-11T03:07:09.174374Z", - "shell.execute_reply": "2026-08-11T03:07:09.173736Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Using database version X4-2024-12-31 located in: /home/kyle/db/exfor/unpack_exfor-2024/X4-2024-12-31\n" - ] - } - ], - "source": [ - "import rxmc" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "1f8e822c-4807-452b-b4b9-a6e25af16006", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:07:09.175847Z", - "iopub.status.busy": "2026-08-11T03:07:09.175620Z", - "iopub.status.idle": "2026-08-11T03:07:09.178149Z", - "shell.execute_reply": "2026-08-11T03:07:09.177591Z" - } - }, - "outputs": [], - "source": [ - "rng = np.random.default_rng(42)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "31abc19d-08d7-49c4-98f8-0c58d235fcd8", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:07:09.179441Z", - "iopub.status.busy": "2026-08-11T03:07:09.179298Z", - "iopub.status.idle": "2026-08-11T03:07:09.181657Z", - "shell.execute_reply": "2026-08-11T03:07:09.180998Z" - } - }, - "outputs": [], - "source": [ - "poly4 = rxmc.physical_model.Polynomial(4)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "715c0ed6-62e7-41da-b5c0-4d0e12c0d414", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:07:09.182953Z", - "iopub.status.busy": "2026-08-11T03:07:09.182815Z", - "iopub.status.idle": "2026-08-11T03:07:09.185509Z", - "shell.execute_reply": "2026-08-11T03:07:09.184903Z" - } - }, - "outputs": [], - "source": [ - "true_params = [1, 0.5, -0.1, -0.4, 0.1]" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "67038d92-ffcb-491c-8d62-eb9a4843e62d", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:07:09.186991Z", - "iopub.status.busy": "2026-08-11T03:07:09.186844Z", - "iopub.status.idle": "2026-08-11T03:07:09.190165Z", - "shell.execute_reply": "2026-08-11T03:07:09.189599Z" - } - }, - "outputs": [], - "source": [ - "settings = [\n", - " {\n", - " \"domain\": [-0.3, 0.4],\n", - " \"N\": 50,\n", - " \"noise\": 0.1,\n", - " \"systematic_err\": 0.1,\n", - " },\n", - " {\n", - " \"domain\": [0.3, 0.5],\n", - " \"N\": 30,\n", - " \"noise\": 0.1,\n", - " \"systematic_err\": 0.5,\n", - " },\n", - " {\n", - " \"domain\": [0.1, 0.6],\n", - " \"N\": 25,\n", - " \"noise\": 0.1,\n", - " \"systematic_err\": 0.2,\n", - " },\n", - " {\n", - " \"domain\": [-0.5, 0.1],\n", - " \"N\": 15,\n", - " \"noise\": 0.2,\n", - " \"systematic_err\": 0.6,\n", - " },\n", - "]" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "abf487e6-041c-457c-9216-5a15e3c08f6c", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:07:09.191643Z", - "iopub.status.busy": "2026-08-11T03:07:09.191485Z", - "iopub.status.idle": "2026-08-11T03:07:09.195421Z", - "shell.execute_reply": "2026-08-11T03:07:09.194734Z" - } - }, - "outputs": [], - "source": [ - "def generate_observations(settings, true_model, rng, true_params, scale_err=True):\n", - " obs = []\n", - " for setting in settings:\n", - " x0, x1 = setting[\"domain\"]\n", - " synthetic_obs = rxmc.observation.Observation(\n", - " x=rng.random(setting[\"N\"]) * (x1 - x0) + x0,\n", - " y=np.zeros(setting[\"N\"]),\n", - " y_stat_err=np.ones(setting[\"N\"]) * setting[\"noise\"],\n", - " )\n", - " renormalization = rng.normal(1, setting[\"systematic_err\"])\n", - " y_true = true_model(synthetic_obs, *true_params)\n", - " if scale_err:\n", - " synthetic_obs.y = rng.normal(y_true, setting[\"noise\"]) * renormalization\n", - " else:\n", - " synthetic_obs.y = rng.normal(y_true * renormalization, setting[\"noise\"])\n", - "\n", - " synthetic_obs.renormalization = renormalization\n", - " synthetic_obs.sys_norm_err = setting[\"systematic_err\"]\n", - "\n", - " obs.append(synthetic_obs)\n", - " return obs" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "b1fa98b8-d52d-44f1-849b-ad89b318c37b", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:07:09.196840Z", - "iopub.status.busy": "2026-08-11T03:07:09.196635Z", - "iopub.status.idle": "2026-08-11T03:07:09.199797Z", - "shell.execute_reply": "2026-08-11T03:07:09.199178Z" - } - }, - "outputs": [], - "source": [ - "observations = generate_observations(settings, poly4, rng, true_params, scale_err=False)" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "30849732-090e-4c2d-be1e-f212fb83845e", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:07:09.201576Z", - "iopub.status.busy": "2026-08-11T03:07:09.201373Z", - "iopub.status.idle": "2026-08-11T03:07:09.204499Z", - "shell.execute_reply": "2026-08-11T03:07:09.203733Z" - } - }, - "outputs": [], - "source": [ - "observations_unreported_sys_err = [\n", - " rxmc.observation.Observation(\n", - " x=obs.x,\n", - " y=obs.y,\n", - " y_stat_err=obs.y_stat_err,\n", - " )\n", - " for obs in observations\n", - "]" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "b56c8f2a-f6e3-46a9-bd46-6799a7edf0d6", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:07:09.206187Z", - "iopub.status.busy": "2026-08-11T03:07:09.205934Z", - "iopub.status.idle": "2026-08-11T03:07:09.209932Z", - "shell.execute_reply": "2026-08-11T03:07:09.208921Z" - } - }, - "outputs": [], - "source": [ - "N_fine = 100\n", - "domain_fine = (-1, 1)\n", - "truth = rxmc.observation.Observation(\n", - " x=np.linspace(*domain_fine, N_fine), y=np.zeros(N_fine)\n", - ")\n", - "truth.y = poly4(truth, *true_params)" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "d7349134-bbd3-4fef-b7d0-99d501afad7d", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:07:09.211828Z", - "iopub.status.busy": "2026-08-11T03:07:09.211561Z", - "iopub.status.idle": "2026-08-11T03:07:09.472241Z", - "shell.execute_reply": "2026-08-11T03:07:09.471426Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.plot(truth.x, truth.y, \"k:\", label=\"truth\")\n", - "for synthetic_observation in observations:\n", - " plt.errorbar(\n", - " synthetic_observation.x,\n", - " synthetic_observation.y,\n", - " synthetic_observation.y_stat_err,\n", - " linestyle=\"none\",\n", - " marker=\".\",\n", - " label=f\"renormalization = {synthetic_observation.renormalization:1.3f}\",\n", - " )\n", - "plt.xlabel(\"x\")\n", - "plt.ylabel(\"y\")\n", - "plt.legend()" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "65d77c5b-4498-4eb7-9e10-23ae52198504", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:07:09.473577Z", - "iopub.status.busy": "2026-08-11T03:07:09.473406Z", - "iopub.status.idle": "2026-08-11T03:07:09.476110Z", - "shell.execute_reply": "2026-08-11T03:07:09.475205Z" - } - }, - "outputs": [], - "source": [ - "correct_model = poly4" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "ed7e3fce-125d-49a9-8742-718e06d3d764", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:07:09.477481Z", - "iopub.status.busy": "2026-08-11T03:07:09.477328Z", - "iopub.status.idle": "2026-08-11T03:07:09.483737Z", - "shell.execute_reply": "2026-08-11T03:07:09.482771Z" - } - }, - "outputs": [], - "source": [ - "# block supports come from the library helper\n", - "_block_supports = rxmc.covariance.stacked_supports\n", - "\n", - "\n", - "evidence_models = {}\n", - "\n", - "# Unknown per-dataset normalization: a latent scale rho_i for each dataset, routed\n", - "# to it by identity and sampled as ordinary *model* parameters. This is the v2\n", - "# form of the old per-dataset UnknownNormalizationModel -- rho moves onto the\n", - "# PhysicalModel (via rxmc.transforms.per_observation_scaling) and is sampled in\n", - "# the model block (jointly with the physics) rather than as a per-constraint\n", - "# covariance nuisance. All constraints share the one model instance, so they\n", - "# still share a single model-parameter vector.\n", - "norm_model = rxmc.physical_model.Polynomial(\n", - " order=correct_model.order,\n", - " transform=rxmc.transforms.per_observation_scaling(observations),\n", - ")\n", - "evidence_models[\"unknown_norm\"] = rxmc.evidence.Evidence(\n", - " [rxmc.constraint.Constraint([obs], norm_model) for obs in observations]\n", - ")\n", - "\n", - "# reported systematic errors folded in as fixed per-dataset normalization modes\n", - "evidence_models[\"marginalized_sys_err\"] = rxmc.evidence.Evidence(\n", - " [\n", - " rxmc.constraint.Constraint(\n", - " observations,\n", - " correct_model,\n", - " extra_terms=[\n", - " rxmc.covariance.normalization_term(\n", - " magnitude=o.sys_norm_err, support=sup\n", - " )\n", - " for o, sup in zip(observations, _block_supports(observations))\n", - " ],\n", - " )\n", - " ]\n", - ")\n", - "\n", - "# systematic errors omitted entirely (statistical only)\n", - "evidence_models[\"unreported_sys_err\"] = rxmc.evidence.Evidence(\n", - " [rxmc.constraint.Constraint(observations_unreported_sys_err, correct_model)]\n", - ")\n", - "\n", - "# omitted systematics absorbed by a single unknown (averaging) model-error term\n", - "gamma = rxmc.params.Parameter(\n", - " \"log fractional err\", float, latex_name=r\"\\gamma\", unit=\"dimensionless\"\n", - ")\n", - "_N_unreported = sum(o.n_data_pts for o in observations_unreported_sys_err)\n", - "evidence_models[\"unreported_sys_err_with_unknown_model_err\"] = rxmc.evidence.Evidence(\n", - " [\n", - " rxmc.constraint.Constraint(\n", - " observations_unreported_sys_err,\n", - " correct_model,\n", - " extra_terms=[\n", - " rxmc.covariance.model_error_term(\n", - " gamma,\n", - " averaging=True,\n", - " support=np.arange(_N_unreported),\n", - " )\n", - " ],\n", - " )\n", - " ]\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "1cf0e309-c459-4c42-90aa-7cec410bc017", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:07:09.485199Z", - "iopub.status.busy": "2026-08-11T03:07:09.485039Z", - "iopub.status.idle": "2026-08-11T03:07:09.488431Z", - "shell.execute_reply": "2026-08-11T03:07:09.487748Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "dict_keys(['unknown_norm', 'marginalized_sys_err', 'unreported_sys_err', 'unreported_sys_err_with_unknown_model_err'])" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "evidence_models.keys()" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "94719fd0-383c-4a7d-aec5-f904bec9a357", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:07:09.489984Z", - "iopub.status.busy": "2026-08-11T03:07:09.489815Z", - "iopub.status.idle": "2026-08-11T03:07:09.493318Z", - "shell.execute_reply": "2026-08-11T03:07:09.492611Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "hyperparameters for each model:\n", - "unknown_norm: []\n", - "marginalized_sys_err: []\n", - "unreported_sys_err: []\n", - "unreported_sys_err_with_unknown_model_err: ['log fractional err']\n" - ] - } - ], - "source": [ - "print(\"hyperparameters for each model:\")\n", - "hyperparams = {}\n", - "for key, evidence_model in evidence_models.items():\n", - " hyperparams[key] = []\n", - " for constraint in evidence_model.parametric_constraints:\n", - " for p in constraint.params:\n", - " hyperparams[key].append(p)\n", - " print(f\"{key}: {[p.name for p in hyperparams[key]]}\")" - ] - }, - { - "cell_type": "markdown", - "id": "7255a93d-771b-448a-962b-4f285d7fa312", - "metadata": {}, - "source": [ - "## Priors\n", - "We will put a tight prior on $a_0$, to avoid identifiability issues, as $a_0$ corresponds to an additive offset of the entire model, which is pretty confounding with a multiplicative bias." - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "5ccbf1c3-e622-4476-9216-6bbe692570bf", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:07:09.494912Z", - "iopub.status.busy": "2026-08-11T03:07:09.494703Z", - "iopub.status.idle": "2026-08-11T03:07:09.498523Z", - "shell.execute_reply": "2026-08-11T03:07:09.497852Z" - } - }, - "outputs": [], - "source": [ - "cov = np.diag(np.ones(len(correct_model.params)))\n", - "cov[0, 0] = 0.001\n", - "model_prior = stats.multivariate_normal(mean=np.array([1, 0, 0, 0, 0]), cov=cov)" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "e75ea172-6a1b-4411-a4e4-b38311461ce2", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:07:09.500201Z", - "iopub.status.busy": "2026-08-11T03:07:09.499992Z", - "iopub.status.idle": "2026-08-11T03:07:09.504289Z", - "shell.execute_reply": "2026-08-11T03:07:09.503599Z" - } - }, - "outputs": [], - "source": [ - "unknown_log_norm_priors = [\n", - " stats.multivariate_normal(\n", - " mean=[0], cov=[[np.log(1 + (setting[\"systematic_err\"]) ** 2)]]\n", - " )\n", - " for setting in settings\n", - "]" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "6c8372b5-8418-4142-9284-642561a76405", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:07:09.505849Z", - "iopub.status.busy": "2026-08-11T03:07:09.505662Z", - "iopub.status.idle": "2026-08-11T03:07:09.509179Z", - "shell.execute_reply": "2026-08-11T03:07:09.508156Z" - } - }, - "outputs": [], - "source": [ - "unknown_model_err_prior = stats.multivariate_normal(mean=[np.log(0.1)], cov=[[0.01]])" - ] - }, - { - "cell_type": "markdown", - "id": "e0529a9e-b937-4a3e-ab0c-8660c5fe6d23", - "metadata": {}, - "source": [ - "## Walkers" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "id": "0d765083-b158-4170-beac-430689778a0a", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:07:09.511081Z", - "iopub.status.busy": "2026-08-11T03:07:09.510871Z", - "iopub.status.idle": "2026-08-11T03:07:09.513731Z", - "shell.execute_reply": "2026-08-11T03:07:09.512908Z" - } - }, - "outputs": [], - "source": [ - "walkers = {}" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "id": "8986c8a1-c24a-4693-a94c-fda660e36d95", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:07:09.515337Z", - "iopub.status.busy": "2026-08-11T03:07:09.515114Z", - "iopub.status.idle": "2026-08-11T03:07:09.520762Z", - "shell.execute_reply": "2026-08-11T03:07:09.519950Z" - } - }, - "outputs": [], - "source": [ - "# combined prior over [physics params, per-dataset log_rho] (block-diagonal):\n", - "# the per-dataset scales are now model parameters, so they are sampled in the\n", - "# model block -- this walker has no separate likelihood samplers.\n", - "n_physics = len(correct_model.params)\n", - "rho_prior_vars = np.array(\n", - " [np.log(1 + setting[\"systematic_err\"] ** 2) for setting in settings]\n", - ")\n", - "norm_prior_mean = np.concatenate([model_prior.mean, np.zeros(len(observations))])\n", - "norm_prior_cov = np.zeros((n_physics + len(observations),) * 2)\n", - "norm_prior_cov[:n_physics, :n_physics] = model_prior.cov\n", - "norm_prior_cov[n_physics:, n_physics:] = np.diag(rho_prior_vars)\n", - "norm_model_prior = stats.multivariate_normal(mean=norm_prior_mean, cov=norm_prior_cov)\n", - "\n", - "walkers[\"unknown_norm\"] = rxmc.walker.Walker(\n", - " model_sampler=rxmc.param_sampling.BatchedAdaptiveMetropolisSampler(\n", - " norm_model.params,\n", - " starting_location=norm_model_prior.mean,\n", - " prior=norm_model_prior,\n", - " initial_proposal_cov=norm_model_prior.cov,\n", - " ),\n", - " evidence=evidence_models[\"unknown_norm\"],\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "id": "a55021b0-5fbf-4c62-a6e1-4754bccf4236", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:07:09.522378Z", - "iopub.status.busy": "2026-08-11T03:07:09.522190Z", - "iopub.status.idle": "2026-08-11T03:07:09.526059Z", - "shell.execute_reply": "2026-08-11T03:07:09.525352Z" - } - }, - "outputs": [], - "source": [ - "walkers[\"unreported_sys_err_with_unknown_model_err\"] = rxmc.walker.Walker(\n", - " model_sampler=rxmc.param_sampling.BatchedAdaptiveMetropolisSampler(\n", - " correct_model.params,\n", - " starting_location=model_prior.mean,\n", - " prior=model_prior,\n", - " initial_proposal_cov=model_prior.cov,\n", - " ),\n", - " evidence=evidence_models[\"unreported_sys_err_with_unknown_model_err\"],\n", - " likelihood_samplers=[\n", - " rxmc.param_sampling.BatchedAdaptiveMetropolisSampler(\n", - " params=hyperparams[\"unreported_sys_err_with_unknown_model_err\"],\n", - " starting_location=unknown_model_err_prior.mean,\n", - " prior=unknown_model_err_prior,\n", - " initial_proposal_cov=unknown_model_err_prior.cov,\n", - " )\n", - " ],\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "id": "c9b000c6-4219-4e7f-9c47-abe793d631ff", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:07:09.527512Z", - "iopub.status.busy": "2026-08-11T03:07:09.527343Z", - "iopub.status.idle": "2026-08-11T03:07:09.530468Z", - "shell.execute_reply": "2026-08-11T03:07:09.529824Z" - } - }, - "outputs": [], - "source": [ - "walkers[\"marginalized_sys_err\"] = rxmc.walker.Walker(\n", - " model_sampler=rxmc.param_sampling.BatchedAdaptiveMetropolisSampler(\n", - " correct_model.params,\n", - " starting_location=model_prior.mean,\n", - " prior=model_prior,\n", - " initial_proposal_cov=model_prior.cov,\n", - " ),\n", - " evidence=evidence_models[\"marginalized_sys_err\"],\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "id": "53080b07-1708-48e3-ace7-89e34a9a5494", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:07:09.531884Z", - "iopub.status.busy": "2026-08-11T03:07:09.531684Z", - "iopub.status.idle": "2026-08-11T03:07:09.534956Z", - "shell.execute_reply": "2026-08-11T03:07:09.534233Z" - } - }, - "outputs": [], - "source": [ - "walkers[\"unreported_sys_err\"] = rxmc.walker.Walker(\n", - " model_sampler=rxmc.param_sampling.BatchedAdaptiveMetropolisSampler(\n", - " correct_model.params,\n", - " starting_location=model_prior.mean,\n", - " prior=model_prior,\n", - " initial_proposal_cov=model_prior.cov,\n", - " ),\n", - " evidence=evidence_models[\"unreported_sys_err\"],\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "id": "5edcfc20-5f56-4851-ac52-4883236950a8", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:07:09.536899Z", - "iopub.status.busy": "2026-08-11T03:07:09.536665Z", - "iopub.status.idle": "2026-08-11T03:08:43.365354Z", - "shell.execute_reply": "2026-08-11T03:08:43.364712Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Running unknown_norm\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Burn-in batch 1/4 completed, 2000 steps.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Burn-in batch 2/4 completed, 2000 steps.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Burn-in batch 3/4 completed, 2000 steps.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Burn-in batch 4/4 completed, 2000 steps.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 1/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.247\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 2/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.306\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 3/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.266\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 4/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.277\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 5/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.294\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 6/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.286\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 7/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.276\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 8/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.248\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 9/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.292\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 10/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.288\n", - "\n", - "Running unreported_sys_err_with_unknown_model_err\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Burn-in batch 1/4 completed, 2000 steps.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Burn-in batch 2/4 completed, 2000 steps.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Burn-in batch 3/4 completed, 2000 steps.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Burn-in batch 4/4 completed, 2000 steps.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 1/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.283\n", - " Likelihood parameter acceptance fractions: [0.423]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 2/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.281\n", - " Likelihood parameter acceptance fractions: [0.451]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 3/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.291\n", - " Likelihood parameter acceptance fractions: [0.4215]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 4/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.302\n", - " Likelihood parameter acceptance fractions: [0.455]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 5/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.311\n", - " Likelihood parameter acceptance fractions: [0.436]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 6/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.290\n", - " Likelihood parameter acceptance fractions: [0.4425]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 7/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.278\n", - " Likelihood parameter acceptance fractions: [0.4445]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 8/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.267\n", - " Likelihood parameter acceptance fractions: [0.474]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 9/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.305\n", - " Likelihood parameter acceptance fractions: [0.4405]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 10/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.292\n", - " Likelihood parameter acceptance fractions: [0.4275]\n", - "\n", - "Running marginalized_sys_err\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Burn-in batch 1/4 completed, 2000 steps.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Burn-in batch 2/4 completed, 2000 steps.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Burn-in batch 3/4 completed, 2000 steps.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Burn-in batch 4/4 completed, 2000 steps.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 1/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.294\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 2/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.288\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 3/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.288\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 4/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.264\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 5/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.290\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 6/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.311\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 7/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.287\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 8/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.292\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 9/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.310\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 10/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.301\n", - "\n", - "Running unreported_sys_err\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Burn-in batch 1/4 completed, 2000 steps.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Burn-in batch 2/4 completed, 2000 steps.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Burn-in batch 3/4 completed, 2000 steps.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Burn-in batch 4/4 completed, 2000 steps.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 1/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.301\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 2/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.284\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 3/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.289\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 4/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.295\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 5/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.282\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 6/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.296\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 7/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.310\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 8/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.315\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 9/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.290\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 10/10 completed, 2000 steps. \n", - " Model parameter acceptance fraction: 0.291\n" - ] - } - ], - "source": [ - "for key, walker in walkers.items():\n", - " print(f\"\\nRunning {key}\")\n", - " walker.walk(n_steps=20000, burnin=8000, batch_size=2000)" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "id": "6ebeb608-b331-4114-827a-31b74773ae0e", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:08:43.367063Z", - "iopub.status.busy": "2026-08-11T03:08:43.366905Z", - "iopub.status.idle": "2026-08-11T03:08:43.370243Z", - "shell.execute_reply": "2026-08-11T03:08:43.369708Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "{'unknown_norm': 'tab:blue',\n", - " 'unreported_sys_err_with_unknown_model_err': 'tab:orange',\n", - " 'marginalized_sys_err': 'tab:purple',\n", - " 'unreported_sys_err': 'tab:green'}" - ] - }, - "execution_count": 26, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "colors = dict(\n", - " zip(walkers.keys(), [\"tab:blue\", \"tab:orange\", \"tab:purple\", \"tab:green\"])\n", - ")\n", - "colors" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "id": "c37c4279-fe7f-4e7a-b261-b368abcc34ae", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:08:43.371935Z", - "iopub.status.busy": "2026-08-11T03:08:43.371791Z", - "iopub.status.idle": "2026-08-11T03:08:44.883123Z", - "shell.execute_reply": "2026-08-11T03:08:44.882505Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "model = correct_model\n", - "fig, axes = plt.subplots(\n", - " walkers[\"marginalized_sys_err\"].model_sampler.chain.shape[1] + 1,\n", - " 1,\n", - " figsize=(8, 8),\n", - " sharex=True,\n", - ")\n", - "for i in range(walker.model_sampler.chain.shape[1]):\n", - " # plot walkers\n", - " for key, walker in walkers.items():\n", - " axes[i].plot(walker.model_sampler.chain[:, i], alpha=0.4, color=colors[key])\n", - "\n", - " axes[i].set_ylabel(f\"${model.params[i].latex_name}$\")\n", - " true_value = true_params[i]\n", - " axes[i].hlines(true_value, 0, len(walker.model_sampler.chain), \"r\", linestyle=\"--\")\n", - "\n", - "# plot likelihoods\n", - "for key, walker in walkers.items():\n", - " axes[-1].plot(walker.model_sampler.logp_chain, alpha=0.4, color=colors[key])" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "id": "a9dd5361-1428-4b53-a50f-a8d2cc71917f", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:08:44.886306Z", - "iopub.status.busy": "2026-08-11T03:08:44.886135Z", - "iopub.status.idle": "2026-08-11T03:08:44.892077Z", - "shell.execute_reply": "2026-08-11T03:08:44.891619Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "(20000, 5)" - ] - }, - "execution_count": 28, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "prior_samples = model_prior.rvs(walker.model_sampler.chain.shape[0])\n", - "prior_samples.shape" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "id": "f716e401-7712-49f0-9771-5e90cb016cb4", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:08:44.894051Z", - "iopub.status.busy": "2026-08-11T03:08:44.893889Z", - "iopub.status.idle": "2026-08-11T03:08:44.902271Z", - "shell.execute_reply": "2026-08-11T03:08:44.901462Z" - } - }, - "outputs": [], - "source": [ - "domain = np.zeros((len(walkers), correct_model.n_params, 2))\n", - "for i, (key, walker) in enumerate(walkers.items()):\n", - " chain = walker.model_sampler.chain[:, : correct_model.n_params]\n", - " domain[i, ...] = np.array(\n", - " [\n", - " np.min(chain, axis=0),\n", - " np.max(chain, axis=0),\n", - " ]\n", - " ).T\n", - "domain = np.array([np.min(domain[:, :, 0], axis=0), np.max(domain[..., 1], axis=0)])" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "id": "a45db89b-5c4d-43ea-893a-336a88d5432a", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:08:44.904009Z", - "iopub.status.busy": "2026-08-11T03:08:44.903854Z", - "iopub.status.idle": "2026-08-11T03:08:44.906797Z", - "shell.execute_reply": "2026-08-11T03:08:44.906226Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "(2, 5)" - ] - }, - "execution_count": 30, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "domain.shape" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "id": "2986eac1-ea7a-4f66-926e-8e6cd1121548", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:08:44.908463Z", - "iopub.status.busy": "2026-08-11T03:08:44.908324Z", - "iopub.status.idle": "2026-08-11T03:08:46.895046Z", - "shell.execute_reply": "2026-08-11T03:08:46.894436Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 31, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig = plt.figure()\n", - "for key, walker in walkers.items():\n", - " corner.corner(\n", - " walker.model_sampler.chain[:, : correct_model.n_params],\n", - " fig=fig,\n", - " color=colors[key],\n", - " range=domain.T,\n", - " labels=[f\"${p.latex_name}$\" for p in correct_model.params],\n", - " truths=true_params,\n", - " labelpad=0.1,\n", - " max_n_ticks=2,\n", - " truth_color=\"k\",\n", - " )\n", - "\n", - " plt.plot([], [], color=colors[key], label=key)\n", - "fig.legend()\n", - "# plt.tight_layout()" - ] - }, - { - "cell_type": "markdown", - "id": "6c8a7777-4e29-4137-a7eb-9e69189ac9a1", - "metadata": {}, - "source": [ - "As expected, `unknown_norm` and `marginalized_sys_err` are the same. This is because they originate from the same exact statistical model, in which the normalization of each data set is a random variable. The latter explicitly marginalizes over the renormalization according to $\\mathcal{N}(1,\\sigma_{sys})$, whereas the former takes that distribution as a prior but attempts to learn the real distribution by conditioning the data. \n", - "\n", - "In this case the underlying process for generating $N$ is exactly what the experimentalists report (that is, it is $\\mathcal{N}(1,\\sigma_{sys})$). If the experimentally reported $\\sigma_{sys}$ was incorrect, then `marginalized_sys_err` would not be marginalizing over the correct distribution, and would converge to something wrong (try it!). On the other hand, with `unknown_norm`, incorrect experimentally reported $\\sigma_{sys}$ just means a bad prior: $\\sigma_{sys}$ doesn't enter into the likelihood at all. Eventually, sampling should converge to the appropriate distribution.\n", - "\n", - "Of course, the other two methods, which do not account for systematic error at all, fail to converge to the region of the truth." - ] - }, - { - "cell_type": "markdown", - "id": "dff9485a-74ec-4896-8122-374d4e407a39", - "metadata": {}, - "source": [ - "## Let's explore the performance of the inference of the normalizations from the \"unknown norm\" model\n", - "\n", - "We will look at the posteriors of $\\rho_i$, the renormalization of the model predictions with respect to each data set. We will look at the *maxima a posteriori* (MAP) and compare them to the values we actually renormalized by when generating the synthetic data. Then we will plot the experimental values renormalized by the MAP $\\rho$s, and we should see that they re-align themselves with the truth." - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "id": "9a63cc20-d38d-4e1b-893d-831306dbb73a", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:08:46.898047Z", - "iopub.status.busy": "2026-08-11T03:08:46.897873Z", - "iopub.status.idle": "2026-08-11T03:08:46.902313Z", - "shell.execute_reply": "2026-08-11T03:08:46.901650Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "(20000, 4)" - ] - }, - "execution_count": 32, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# per-dataset rho posteriors live in the model-block chain, after the physics\n", - "n_physics = len(correct_model.params)\n", - "norm_chain = np.exp(walkers[\"unknown_norm\"].model_sampler.chain[:, n_physics:])\n", - "norm_chain.shape" - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "id": "00efd03d-7fdf-4f99-bc68-413a75ce2b72", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:08:46.904501Z", - "iopub.status.busy": "2026-08-11T03:08:46.904332Z", - "iopub.status.idle": "2026-08-11T03:08:46.907957Z", - "shell.execute_reply": "2026-08-11T03:08:46.907231Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "(20000,)" - ] - }, - "execution_count": 33, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "norm_log_posterior_vals = walkers[\"unknown_norm\"].model_sampler.logp_chain\n", - "norm_log_posterior_vals.shape" - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "id": "328e1d8e-d6b0-4429-a852-394eb3613895", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:08:46.910019Z", - "iopub.status.busy": "2026-08-11T03:08:46.909844Z", - "iopub.status.idle": "2026-08-11T03:08:46.913968Z", - "shell.execute_reply": "2026-08-11T03:08:46.913283Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "array([1.0519558 , 0.53718276, 1.2928494 , 1.00432021])" - ] - }, - "execution_count": 34, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "map_idx = np.argmax(walkers[\"unknown_norm\"].model_sampler.logp_chain)\n", - "N_data_sets = len(settings)\n", - "maps = norm_chain[map_idx, :]\n", - "maps" - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "id": "868b71f7-0de1-43b9-a593-295f7ff36099", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:08:46.915908Z", - "iopub.status.busy": "2026-08-11T03:08:46.915735Z", - "iopub.status.idle": "2026-08-11T03:08:46.919544Z", - "shell.execute_reply": "2026-08-11T03:08:46.918903Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "array([1.06789136, 0.53671203, 1.3071512 , 1.05429387])" - ] - }, - "execution_count": 35, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "np.array([obs.renormalization for obs in observations])" - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "id": "7f72afa9-bf06-4e3b-83d2-8344ae36fc06", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:08:46.921824Z", - "iopub.status.busy": "2026-08-11T03:08:46.921656Z", - "iopub.status.idle": "2026-08-11T03:08:46.925448Z", - "shell.execute_reply": "2026-08-11T03:08:46.924832Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "array([1.04462468, 0.5287628 , 1.28785673, 0.99731649])" - ] - }, - "execution_count": 36, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "np.mean(norm_chain, axis=0)" - ] - }, - { - "cell_type": "code", - "execution_count": 37, - "id": "b7acf84b-e98c-4743-9e62-2c3eb16bf677", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:08:46.927658Z", - "iopub.status.busy": "2026-08-11T03:08:46.927485Z", - "iopub.status.idle": "2026-08-11T03:08:47.583693Z", - "shell.execute_reply": "2026-08-11T03:08:47.582931Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig = corner.corner(\n", - " norm_chain,\n", - " labels=range(len(settings)),\n", - " truths=[obs.renormalization for obs in observations],\n", - " labelpad=0.1,\n", - " max_n_ticks=2,\n", - " color=\"tab:blue\",\n", - " truth_color=\"red\",\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 38, - "id": "9861dc77-5683-47b3-84d6-22409195355b", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:08:47.586579Z", - "iopub.status.busy": "2026-08-11T03:08:47.586404Z", - "iopub.status.idle": "2026-08-11T03:08:47.907564Z", - "shell.execute_reply": "2026-08-11T03:08:47.906802Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 1.0, 'Renormalizing experimental data sets based on MAP of $p(\\\\rho)$')" - ] - }, - "execution_count": 38, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.plot(truth.x, truth.y, \"k:\", label=\"truth\")\n", - "for i, synthetic_observation in enumerate(observations):\n", - " rho_hat = maps[i]\n", - " plt.errorbar(\n", - " synthetic_observation.x,\n", - " synthetic_observation.y / rho_hat,\n", - " synthetic_observation.y_stat_err,\n", - " linestyle=\"none\",\n", - " marker=\".\",\n", - " label=r\"$\\rho_{\\text{truth}}$ = \"\n", - " + f\"{synthetic_observation.renormalization:1.3f},\"\n", - " + r\" MAP = \"\n", - " + f\"{rho_hat:1.2f}\",\n", - " )\n", - "plt.xlabel(\"$x$\")\n", - "plt.ylabel(\"$y$\")\n", - "plt.legend()\n", - "plt.title(r\"Renormalizing experimental data sets based on MAP of $p(\\rho)$\")" - ] - }, - { - "cell_type": "markdown", - "id": "11acfd96-4b06-48bf-8664-a0e42ddb9db2", - "metadata": {}, - "source": [ - "## predictive posteriors" - ] - }, - { - "cell_type": "code", - "execution_count": 39, - "id": "e1708552-11c0-436f-bbc3-58d778e99774", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:08:47.909398Z", - "iopub.status.busy": "2026-08-11T03:08:47.909244Z", - "iopub.status.idle": "2026-08-11T03:08:47.912488Z", - "shell.execute_reply": "2026-08-11T03:08:47.911972Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "(20000, 5)" - ] - }, - "execution_count": 39, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "walker.model_sampler.chain.shape" - ] - }, - { - "cell_type": "code", - "execution_count": 40, - "id": "17ae70aa-589c-42ac-b132-f918a3160ce4", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:08:47.914250Z", - "iopub.status.busy": "2026-08-11T03:08:47.914039Z", - "iopub.status.idle": "2026-08-11T03:08:47.917123Z", - "shell.execute_reply": "2026-08-11T03:08:47.916447Z" - } - }, - "outputs": [], - "source": [ - "def predictive_post(chain, model, obs, n_samples, intervals):\n", - " draw_idxs = rng.choice(np.arange(chain.shape[0]), n_samples)\n", - " draws = chain[draw_idxs, :]\n", - " ym = np.array([model(obs, *p) for p in draws])\n", - " return np.percentile(ym, intervals, axis=0)" - ] - }, - { - "cell_type": "code", - "execution_count": 41, - "id": "9c48e1df-130d-445e-8be3-6c35e33642e6", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:08:47.918696Z", - "iopub.status.busy": "2026-08-11T03:08:47.918538Z", - "iopub.status.idle": "2026-08-11T03:08:48.194795Z", - "shell.execute_reply": "2026-08-11T03:08:48.194067Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 41, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig = plt.figure(figsize=(8, 4))\n", - "plt.plot(truth.x, truth.y, \"k:\", label=\"truth\")\n", - "\n", - "for synthetic_observation in observations:\n", - " plt.errorbar(\n", - " synthetic_observation.x,\n", - " synthetic_observation.y,\n", - " synthetic_observation.y_stat_err,\n", - " linestyle=\"none\",\n", - " marker=\".\",\n", - " alpha=0.4,\n", - " # label=f\"renormalization = {synthetic_observation.renormalization:1.3f}\",\n", - " )\n", - "\n", - "hatches = [\"//\\\\//\\\\\", \"|-\", \"\", \"\"]\n", - "alphas = [0.1, 0.25, 0.25, 0.25]\n", - "for i, (key, walker) in enumerate(walkers.items()):\n", - " intervals = predictive_post(\n", - " walker.model_sampler.chain[:, : correct_model.n_params],\n", - " correct_model,\n", - " truth,\n", - " 1000,\n", - " [16, 84],\n", - " )\n", - " plt.fill_between(\n", - " truth.x,\n", - " intervals[0],\n", - " intervals[1],\n", - " alpha=alphas[i],\n", - " color=colors[key],\n", - " label=key,\n", - " hatch=hatches[i],\n", - " zorder=99,\n", - " )\n", - "plt.xlabel(\"x\")\n", - "plt.ylabel(\"y\")\n", - "plt.ylim([0, 2])\n", - "fig.legend(loc=\"upper left\", framealpha=1)" - ] - }, - { - "cell_type": "markdown", - "id": "gal00", - "metadata": {}, - "source": [ - "# Covariance-structure gallery\n", - "\n", - "The sections above inferred unknown **normalisations** — a single rank-one\n", - "systematic per dataset. But a `Constraint`'s covariance is assembled from\n", - "arbitrary `Term`s, so the *same* machinery expresses far richer uncertainty\n", - "structure. This gallery surveys four cases the covariance API handles, each just a\n", - "different `Term` (or `support`) on the stacked residual:\n", - "\n", - "1. a **systematic correlated across $x$** (smoothly, not a flat normalisation);\n", - "2. **correlated statistical errors** — and why ignoring them is overconfident;\n", - "3. **unknown / misreported magnitudes** (the free-$\\gamma$ model error above);\n", - "4. a systematic **shared across datasets** (cross-block coupling).\n", - "\n", - "A small helper normalises a covariance to a correlation matrix for plotting." - ] - }, - { - "cell_type": "code", - "execution_count": 42, - "id": "gal01", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:08:48.196610Z", - "iopub.status.busy": "2026-08-11T03:08:48.196446Z", - "iopub.status.idle": "2026-08-11T03:08:48.297327Z", - "shell.execute_reply": "2026-08-11T03:08:48.296552Z" - } - }, - "outputs": [], - "source": [ - "from sklearn.gaussian_process.kernels import RBF, ConstantKernel\n", - "\n", - "\n", - "def correlation(Sigma):\n", - " d = np.sqrt(np.diag(Sigma))\n", - " return Sigma / np.outer(d, d)" - ] - }, - { - "cell_type": "markdown", - "id": "gal02", - "metadata": {}, - "source": [ - "## 1. A systematic correlated across $x$\n", - "\n", - "A flat `normalization_term` is a *rank-one* mode: every point is **100 %**\n", - "correlated (correlation matrix all ones off-diagonal). A systematic that varies\n", - "smoothly with $x$ — e.g. an energy-dependent efficiency — instead has correlation\n", - "that **decays** with separation. That is a `kernel_term` (a GP prior on the\n", - "systematic). Same API, richer structure." - ] - }, - { - "cell_type": "code", - "execution_count": 43, - "id": "gal03", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:08:48.299491Z", - "iopub.status.busy": "2026-08-11T03:08:48.299204Z", - "iopub.status.idle": "2026-08-11T03:08:48.645254Z", - "shell.execute_reply": "2026-08-11T03:08:48.644419Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "o0 = observations[0]\n", - "xspan = o0.x.max() - o0.x.min()\n", - "\n", - "# (a) flat normalization: rank-one, uniform correlation\n", - "c_flat = rxmc.constraint.Constraint(\n", - " [o0],\n", - " correct_model,\n", - " extra_terms=[rxmc.covariance.normalization_term(magnitude=0.05)],\n", - ")\n", - "# (b) smooth correlated systematic: a GP (kernel_term) over x\n", - "sys_kernel = ConstantKernel(0.05**2) * RBF(length_scale=xspan / 4)\n", - "c_smooth = rxmc.constraint.Constraint(\n", - " [o0],\n", - " correct_model,\n", - " extra_terms=[rxmc.covariance.kernel_term(sys_kernel)],\n", - ")\n", - "\n", - "S_flat = c_flat.covariance_matrix(true_params)\n", - "S_smooth = c_smooth.covariance_matrix(true_params, tuple(sys_kernel.theta))\n", - "\n", - "fig, ax = plt.subplots(1, 2, figsize=(9, 4))\n", - "for a, S, t in [\n", - " (ax[0], S_flat, \"flat normalization (rank-one)\"),\n", - " (ax[1], S_smooth, \"smooth systematic (kernel_term)\"),\n", - "]:\n", - " im = a.imshow(correlation(S), vmin=-1, vmax=1, cmap=\"RdBu_r\")\n", - " a.set_title(t)\n", - " fig.colorbar(im, ax=a, fraction=0.046)\n", - "fig.suptitle(\"correlation of one dataset under two systematic structures\");" - ] - }, - { - "cell_type": "markdown", - "id": "gal04", - "metadata": {}, - "source": [ - "## 2. Correlated statistical errors\n", - "\n", - "Statistical errors are usually taken as independent (a diagonal covariance). When\n", - "they are **not** — shared backgrounds, unfolding, detector resolution — ignoring\n", - "the correlation makes the posterior **overconfident**. We draw line data with\n", - "exponentially-correlated noise and fit it two ways: a naive diagonal, and the\n", - "correct correlated covariance supplied as a fixed `Term`." - ] - }, - { - "cell_type": "code", - "execution_count": 44, - "id": "gal05", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:08:48.647141Z", - "iopub.status.busy": "2026-08-11T03:08:48.646980Z", - "iopub.status.idle": "2026-08-11T03:08:54.150726Z", - "shell.execute_reply": "2026-08-11T03:08:54.150004Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "naive diagonal a0 = 1.101 ± 0.062 a1 = 0.758 ± 0.027\n", - "correlated a0 = 1.048 ± 0.129 a1 = 0.779 ± 0.048\n" - ] - } - ], - "source": [ - "line = rxmc.physical_model.Polynomial(1) # a0 + a1 x\n", - "a_true = [1.0, 0.8]\n", - "xs = np.linspace(0.0, 4.0, 20)\n", - "ell, sig = 1.2, 0.15\n", - "R = np.exp(-np.abs(xs[:, None] - xs[None, :]) / ell) # exponential correlation\n", - "C = sig**2 * R\n", - "y_corr = line(rxmc.observation.Observation(x=xs, y=np.zeros_like(xs)), *a_true)\n", - "y_corr = y_corr + rng.multivariate_normal(np.zeros(xs.size), C)\n", - "obs_corr = rxmc.observation.Observation(x=xs, y=y_corr)\n", - "\n", - "c_naive = rxmc.constraint.Constraint(\n", - " [obs_corr],\n", - " line,\n", - " extra_terms=[rxmc.covariance.Term(sig * np.ones(xs.size), kind=\"diag\")],\n", - ")\n", - "c_correlated = rxmc.constraint.Constraint(\n", - " [obs_corr],\n", - " line,\n", - " extra_terms=[rxmc.covariance.Term(C)],\n", - ")\n", - "\n", - "\n", - "def fit_line(constraint, seed=7):\n", - " evidence = rxmc.evidence.Evidence([constraint])\n", - " prior = stats.multivariate_normal(mean=a_true, cov=np.diag([0.5, 0.5]) ** 2)\n", - " sampler = rxmc.param_sampling.BatchedAdaptiveMetropolisSampler(\n", - " params=line.params,\n", - " starting_location=prior.mean,\n", - " prior=prior,\n", - " initial_proposal_cov=prior.cov / 100,\n", - " )\n", - " walker = rxmc.walker.Walker(sampler, evidence, rng=np.random.default_rng(seed))\n", - " walker.walk(n_steps=6000, burnin=2000, batch_size=1000, verbose=False)\n", - " return walker.model_sampler.chain\n", - "\n", - "\n", - "chain_naive = fit_line(c_naive)\n", - "chain_correlated = fit_line(c_correlated)\n", - "for name, ch in [(\"naive diagonal\", chain_naive), (\"correlated\", chain_correlated)]:\n", - " print(\n", - " f\"{name:14s} a0 = {ch[:,0].mean():.3f} ± {ch[:,0].std():.3f} \"\n", - " f\"a1 = {ch[:,1].mean():.3f} ± {ch[:,1].std():.3f}\"\n", - " )" - ] - }, - { - "cell_type": "code", - "execution_count": 45, - "id": "gal06", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:08:54.152422Z", - "iopub.status.busy": "2026-08-11T03:08:54.152265Z", - "iopub.status.idle": "2026-08-11T03:08:54.370278Z", - "shell.execute_reply": "2026-08-11T03:08:54.369516Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig = corner.corner(\n", - " chain_naive, labels=[\"a0\", \"a1\"], color=\"tab:red\", truths=a_true, truth_color=\"k\"\n", - ")\n", - "corner.corner(chain_correlated, fig=fig, color=\"tab:blue\")\n", - "plt.plot([], [], color=\"tab:red\", label=\"naive diagonal (overconfident)\")\n", - "plt.plot([], [], color=\"tab:blue\", label=\"correlated fixed Term\")\n", - "fig.legend(loc=\"upper right\");" - ] - }, - { - "cell_type": "markdown", - "id": "gal07", - "metadata": {}, - "source": [ - "The naive-diagonal posterior is visibly **tighter** than the correct one:\n", - "treating correlated noise as independent over-counts the information. The\n", - "a fixed `Term` with the true correlation restores honest uncertainty." - ] - }, - { - "cell_type": "markdown", - "id": "gal08", - "metadata": {}, - "source": [ - "## 3. Unknown / misreported magnitudes\n", - "\n", - "When the *size* of an uncertainty is itself unknown, it becomes a sampled\n", - "`Parameter`. The `unreported_sys_err_with_unknown_model_err` scenario above does\n", - "exactly this with a free $\\gamma$ (`model_error_term`, a diagonal inflation). Here\n", - "we just visualise how the covariance diagonal grows as $\\gamma$ increases —\n", - "inference slides along this family to whatever the data support." - ] - }, - { - "cell_type": "code", - "execution_count": 46, - "id": "gal09", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:08:54.372438Z", - "iopub.status.busy": "2026-08-11T03:08:54.372273Z", - "iopub.status.idle": "2026-08-11T03:08:54.586555Z", - "shell.execute_reply": "2026-08-11T03:08:54.585914Z" - } - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "<>:12: SyntaxWarning: invalid escape sequence '\\g'\n", - "<>:17: SyntaxWarning: invalid escape sequence '\\g'\n", - "<>:12: SyntaxWarning: invalid escape sequence '\\g'\n", - "<>:17: SyntaxWarning: invalid escape sequence '\\g'\n", - "/tmp/ipykernel_402344/1563835932.py:12: SyntaxWarning: invalid escape sequence '\\g'\n", - " plt.plot(o.x, np.sqrt(np.diag(S)), marker=\".\", label=f\"$\\gamma$ = {g:.2f}\")\n", - "/tmp/ipykernel_402344/1563835932.py:17: SyntaxWarning: invalid escape sequence '\\g'\n", - " plt.title(\"unknown model error inflates the diagonal by a sampled $\\gamma$\");\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "o = observations[0]\n", - "gamma = rxmc.params.Parameter(\"log gamma\", float)\n", - "c_me = rxmc.constraint.Constraint(\n", - " [o],\n", - " correct_model,\n", - " extra_terms=[rxmc.covariance.model_error_term(gamma, averaging=True)],\n", - ")\n", - "plt.figure(figsize=(7, 4))\n", - "for g in [0.02, 0.05, 0.10]:\n", - " S = c_me.covariance_matrix(true_params, (np.log(g),))\n", - " plt.plot(o.x, np.sqrt(np.diag(S)), marker=\".\", label=f\"$\\gamma$ = {g:.2f}\")\n", - "plt.plot(o.x, o.y_stat_err, \"k:\", label=\"reported stat. err\")\n", - "plt.xlabel(\"x\")\n", - "plt.ylabel(\"total std. dev.\")\n", - "plt.legend()\n", - "plt.title(\"unknown model error inflates the diagonal by a sampled $\\gamma$\");" - ] - }, - { - "cell_type": "markdown", - "id": "gal10", - "metadata": {}, - "source": [ - "## 4. A systematic shared across datasets\n", - "\n", - "If two datasets share a systematic (a common calibration), the coupling is a\n", - "single `Term` whose `support` spans **both** blocks — off-diagonal correlation\n", - "between datasets. Treating them independently throws that coupling away. (The\n", - "dedicated `correlated_observations.ipynb` notebook explores the inference\n", - "consequences; here we just show the structure.)" - ] - }, - { - "cell_type": "code", - "execution_count": 47, - "id": "gal11", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:08:54.588808Z", - "iopub.status.busy": "2026-08-11T03:08:54.588638Z", - "iopub.status.idle": "2026-08-11T03:08:54.933783Z", - "shell.execute_reply": "2026-08-11T03:08:54.933233Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "pair = observations[:2]\n", - "supports = _block_supports(pair)\n", - "full = np.concatenate(supports)\n", - "\n", - "c_shared = rxmc.constraint.Constraint(\n", - " pair,\n", - " correct_model,\n", - " extra_terms=[rxmc.covariance.normalization_term(magnitude=0.06, support=full)],\n", - ")\n", - "c_separate = rxmc.constraint.Constraint(\n", - " pair,\n", - " correct_model,\n", - " extra_terms=[\n", - " rxmc.covariance.normalization_term(magnitude=0.06, support=s) for s in supports\n", - " ],\n", - ")\n", - "n1 = pair[0].n_data_pts\n", - "fig, ax = plt.subplots(1, 2, figsize=(9, 4))\n", - "for a, c, t in [\n", - " (ax[0], c_shared, \"shared across datasets (case A)\"),\n", - " (ax[1], c_separate, \"independent per dataset\"),\n", - "]:\n", - " im = a.imshow(\n", - " correlation(c.covariance_matrix(true_params)), vmin=-1, vmax=1, cmap=\"RdBu_r\"\n", - " )\n", - " a.axhline(n1 - 0.5, color=\"k\", lw=0.6)\n", - " a.axvline(n1 - 0.5, color=\"k\", lw=0.6)\n", - " a.set_title(t)\n", - " fig.colorbar(im, ax=a, fraction=0.046)\n", - "fig.suptitle(\"a shared systematic couples the two datasets' blocks\");" - ] - }, - { - "cell_type": "markdown", - "id": "gal12", - "metadata": {}, - "source": [ - "## Summary\n", - "\n", - "Every case above is the *same* `Constraint` machinery with a different `Term`:\n", - "\n", - "| case | `Term` | structure |\n", - "|------|--------|-----------|\n", - "| flat normalisation | `normalization_term` | rank-one, uniform |\n", - "| correlated-across-$x$ systematic | `kernel_term` | smooth/banded |\n", - "| correlated statistical errors | fixed `Term` | arbitrary off-diagonal |\n", - "| unknown magnitude | `model_error_term` (free $\\gamma$) | sampled diagonal |\n", - "| shared across datasets | cross-block `normalization_term` | off-diagonal blocks |\n", - "\n", - "Declaring the uncertainty *is* the modelling choice — the inference machinery is\n", - "unchanged." - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.12.3" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/examples/overconfidence.ipynb b/examples/overconfidence.ipynb deleted file mode 100644 index e9bc6de..0000000 --- a/examples/overconfidence.ipynb +++ /dev/null @@ -1,1489 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "196a680f-91b8-4c45-8894-f56175a73082", - "metadata": {}, - "source": [ - "# Large N implies overconfidence? Do we need to re-scale the Likelihood?" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "7bb6c48f-b3e8-424e-962a-747343e60742", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:10:29.033340Z", - "iopub.status.busy": "2026-08-11T03:10:29.033193Z", - "iopub.status.idle": "2026-08-11T03:10:29.036142Z", - "shell.execute_reply": "2026-08-11T03:10:29.035405Z" - } - }, - "outputs": [], - "source": [ - "from collections import OrderedDict" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "b11241d5-93d5-4e8f-8ca6-380154ca9a19", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:10:29.037856Z", - "iopub.status.busy": "2026-08-11T03:10:29.037707Z", - "iopub.status.idle": "2026-08-11T03:10:29.696403Z", - "shell.execute_reply": "2026-08-11T03:10:29.695590Z" - } - }, - "outputs": [], - "source": [ - "import corner" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "c549ae62-7f81-4a8e-a54e-a7331a298c90", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:10:29.697955Z", - "iopub.status.busy": "2026-08-11T03:10:29.697725Z", - "iopub.status.idle": "2026-08-11T03:10:29.700409Z", - "shell.execute_reply": "2026-08-11T03:10:29.699835Z" - } - }, - "outputs": [], - "source": [ - "import numpy as np" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "a55118c3-ccbf-45bf-81a9-bdf6e9daf46c", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:10:29.701673Z", - "iopub.status.busy": "2026-08-11T03:10:29.701542Z", - "iopub.status.idle": "2026-08-11T03:10:30.169160Z", - "shell.execute_reply": "2026-08-11T03:10:30.168460Z" - } - }, - "outputs": [], - "source": [ - "from matplotlib import pyplot as plt\n", - "from scipy import stats\n", - "from scipy.stats import norm" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "22715d9f-6d09-4444-b9a5-243a1274c05c", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:10:30.170611Z", - "iopub.status.busy": "2026-08-11T03:10:30.170462Z", - "iopub.status.idle": "2026-08-11T03:10:31.456765Z", - "shell.execute_reply": "2026-08-11T03:10:31.455781Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Using database version X4-2024-12-31 located in: /home/kyle/db/exfor/unpack_exfor-2024/X4-2024-12-31\n" - ] - } - ], - "source": [ - "import rxmc" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "abee925c-9d84-443e-9e6c-ca3dd5a29afe", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:10:31.458299Z", - "iopub.status.busy": "2026-08-11T03:10:31.458063Z", - "iopub.status.idle": "2026-08-11T03:10:31.460632Z", - "shell.execute_reply": "2026-08-11T03:10:31.459993Z" - } - }, - "outputs": [], - "source": [ - "true_params = OrderedDict(\n", - " [\n", - " (\"m\", 2),\n", - " (\"b\", 4),\n", - " ]\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "1f8e822c-4807-452b-b4b9-a6e25af16006", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:10:31.462100Z", - "iopub.status.busy": "2026-08-11T03:10:31.461938Z", - "iopub.status.idle": "2026-08-11T03:10:31.465013Z", - "shell.execute_reply": "2026-08-11T03:10:31.464140Z" - } - }, - "outputs": [], - "source": [ - "rng = np.random.default_rng(42)" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "6c697651-05eb-4082-962e-144f86fd7dbf", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:10:31.466337Z", - "iopub.status.busy": "2026-08-11T03:10:31.466177Z", - "iopub.status.idle": "2026-08-11T03:10:31.469348Z", - "shell.execute_reply": "2026-08-11T03:10:31.468687Z" - } - }, - "outputs": [], - "source": [ - "noise = 0.05\n", - "N = 200\n", - "# x_data = np.sort(np.random.rand(N))\n", - "x_data = np.linspace(0, 1, N)\n", - "y_true = true_params[\"m\"] * x_data + true_params[\"b\"]\n", - "y_err = np.array([rng.normal(0, noise * y) for y in y_true])\n", - "y_data = y_true + y_err\n", - "\n", - "reported_stat_err = noise * y_data" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "31abc19d-08d7-49c4-98f8-0c58d235fcd8", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:10:31.470724Z", - "iopub.status.busy": "2026-08-11T03:10:31.470580Z", - "iopub.status.idle": "2026-08-11T03:10:31.473989Z", - "shell.execute_reply": "2026-08-11T03:10:31.473286Z" - } - }, - "outputs": [], - "source": [ - "class LinearModel(rxmc.physical_model.PhysicalModel):\n", - " def __init__(self):\n", - " params = [\n", - " rxmc.params.Parameter(\"m\", float, \"no-units\"),\n", - " rxmc.params.Parameter(\"b\", float, \"y-units\"),\n", - " ]\n", - " super().__init__(params)\n", - "\n", - " def evaluate(self, observation, m, b):\n", - " return self.y(observation.x, m, b)\n", - "\n", - " def y(self, x, m, b):\n", - " # useful to have a function hat takes in an array-like x\n", - " # rather than an Observation, e.g. for plotting\n", - " return m * x + b" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "5ee482a3-6a9d-4fd2-bcb1-6fbf4d400502", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:10:31.475264Z", - "iopub.status.busy": "2026-08-11T03:10:31.475120Z", - "iopub.status.idle": "2026-08-11T03:10:31.477479Z", - "shell.execute_reply": "2026-08-11T03:10:31.476846Z" - } - }, - "outputs": [], - "source": [ - "prior_mean = OrderedDict(\n", - " [\n", - " (\"m\", 1),\n", - " (\"b\", 4),\n", - " ]\n", - ")\n", - "prior_std_dev = OrderedDict(\n", - " [\n", - " (\"m\", 0.1),\n", - " (\"b\", 0.5),\n", - " ]\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "591b9219-baf9-4a06-80bb-89b8a76b4248", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:10:31.478771Z", - "iopub.status.busy": "2026-08-11T03:10:31.478651Z", - "iopub.status.idle": "2026-08-11T03:10:31.483966Z", - "shell.execute_reply": "2026-08-11T03:10:31.483336Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "array([1, 4])" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "covariance = np.diag(list(prior_std_dev.values())) ** 2\n", - "mean = np.array(list(prior_mean.values()))\n", - "prior_distribution = stats.multivariate_normal(mean, covariance)\n", - "mean" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "66395e1c-6724-4dbf-89e2-b83b94f8ba89", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:10:31.485277Z", - "iopub.status.busy": "2026-08-11T03:10:31.485124Z", - "iopub.status.idle": "2026-08-11T03:10:31.487577Z", - "shell.execute_reply": "2026-08-11T03:10:31.486860Z" - } - }, - "outputs": [], - "source": [ - "my_model = LinearModel()" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "22e4b752-4be1-457e-b934-8316031e2cfc", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:10:31.488915Z", - "iopub.status.busy": "2026-08-11T03:10:31.488798Z", - "iopub.status.idle": "2026-08-11T03:10:31.491463Z", - "shell.execute_reply": "2026-08-11T03:10:31.490701Z" - } - }, - "outputs": [], - "source": [ - "observation = rxmc.observation.Observation(\n", - " x=x_data,\n", - " y=y_data,\n", - " y_stat_err=y_true * noise,\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "0fc8e25a-7544-4b80-ad8b-4b48447dc998", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:10:31.492723Z", - "iopub.status.busy": "2026-08-11T03:10:31.492604Z", - "iopub.status.idle": "2026-08-11T03:10:31.633177Z", - "shell.execute_reply": "2026-08-11T03:10:31.632503Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.errorbar(\n", - " x_data,\n", - " y_data,\n", - " noise * y_data,\n", - " color=\"k\",\n", - " marker=\"o\",\n", - " linestyle=\"none\",\n", - " label=\"experiment\",\n", - ")\n", - "plt.plot(x_data, y_true, \"k--\", label=\"truth\")" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "54636463-a169-43d1-9498-dece057a7550", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:10:31.634679Z", - "iopub.status.busy": "2026-08-11T03:10:31.634544Z", - "iopub.status.idle": "2026-08-11T03:10:31.637091Z", - "shell.execute_reply": "2026-08-11T03:10:31.636348Z" - } - }, - "outputs": [], - "source": [ - "likelihood = rxmc.likelihood_model.GaussianLikelihood()" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "2348c4ad-f2ce-4b38-abc3-2048aa2ed11a", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:10:31.638424Z", - "iopub.status.busy": "2026-08-11T03:10:31.638294Z", - "iopub.status.idle": "2026-08-11T03:10:31.647486Z", - "shell.execute_reply": "2026-08-11T03:10:31.646900Z" - } - }, - "outputs": [], - "source": [ - "evidence = rxmc.evidence.Evidence(\n", - " [\n", - " rxmc.constraint.Constraint(\n", - " [observation],\n", - " my_model,\n", - " likelihood,\n", - " )\n", - " ],\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "ed7e3fce-125d-49a9-8742-718e06d3d764", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:10:31.648771Z", - "iopub.status.busy": "2026-08-11T03:10:31.648639Z", - "iopub.status.idle": "2026-08-11T03:10:31.651407Z", - "shell.execute_reply": "2026-08-11T03:10:31.650875Z" - } - }, - "outputs": [], - "source": [ - "evidence_scaled = rxmc.evidence.Evidence(\n", - " [\n", - " rxmc.constraint.Constraint(\n", - " [observation],\n", - " my_model,\n", - " likelihood,\n", - " )\n", - " ],\n", - " weights=np.array([2 / N]),\n", - ")" - ] - }, - { - "cell_type": "markdown", - "id": "687d0733", - "metadata": {}, - "source": [ - "## The same tempering as a config-level knob\n", - "\n", - "`Evidence(weights=...)` tempers the likelihood **per constraint**;\n", - "`CalibrationConfig(likelihood_scaling=...)` tempers the **whole** likelihood.\n", - "For a single constraint they are two spellings of the same thing — and both\n", - "propagate consistently into the Gibbs conditionals\n", - "(`CalibrationConfig.conditional_posterior` applies\n", - "`likelihood_scaling * weight` to the marginal likelihood, with the prior\n", - "untouched), so the tempered joint is what every sampling block targets.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "c4713daf", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:10:31.652760Z", - "iopub.status.busy": "2026-08-11T03:10:31.652627Z", - "iopub.status.idle": "2026-08-11T03:10:31.656788Z", - "shell.execute_reply": "2026-08-11T03:10:31.656280Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "likelihood_scaling = 2/N : 0.173502\n", - "Evidence weights = [2/N] : 0.173502\n" - ] - } - ], - "source": [ - "model_config = rxmc.config.ParameterConfig(\n", - " params=my_model.params,\n", - " prior=prior_distribution,\n", - " initial_proposal_distribution=prior_distribution,\n", - ")\n", - "\n", - "config_scaling = rxmc.config.CalibrationConfig(\n", - " evidence=rxmc.evidence.Evidence(\n", - " [rxmc.constraint.Constraint([observation], my_model, likelihood)]\n", - " ),\n", - " model_config=model_config,\n", - " likelihood_scaling=2 / N,\n", - ")\n", - "config_weights = rxmc.config.CalibrationConfig(\n", - " evidence=evidence_scaled,\n", - " model_config=model_config,\n", - ")\n", - "\n", - "x_test = np.array([2.0, 4.0])\n", - "print(f\"likelihood_scaling = 2/N : {config_scaling.log_likelihood(x_test):.6f}\")\n", - "print(f\"Evidence weights = [2/N] : {config_weights.log_likelihood(x_test):.6f}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "7739ec4d-bded-476c-8a7f-bb8feac5ff3f", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:10:31.658182Z", - "iopub.status.busy": "2026-08-11T03:10:31.658046Z", - "iopub.status.idle": "2026-08-11T03:10:31.660370Z", - "shell.execute_reply": "2026-08-11T03:10:31.659836Z" - } - }, - "outputs": [], - "source": [ - "def proposal_distribution(x, rng):\n", - " return stats.multivariate_normal.rvs(\n", - " mean=x, cov=prior_distribution.cov / 100, random_state=rng\n", - " )" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "id": "79791e26-f2d9-42da-b896-51c326a09540", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:10:31.661680Z", - "iopub.status.busy": "2026-08-11T03:10:31.661546Z", - "iopub.status.idle": "2026-08-11T03:10:31.663993Z", - "shell.execute_reply": "2026-08-11T03:10:31.663525Z" - } - }, - "outputs": [], - "source": [ - "walker_scaled = rxmc.walker.Walker(\n", - " rxmc.param_sampling.BatchedAdaptiveMetropolisSampler(\n", - " params=my_model.params,\n", - " starting_location=prior_distribution.mean,\n", - " prior=prior_distribution,\n", - " initial_proposal_cov=prior_distribution.cov / 100,\n", - " ),\n", - " evidence_scaled,\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "id": "38e27c49-fbb4-473f-9b1c-68ca55ecb076", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:10:31.665565Z", - "iopub.status.busy": "2026-08-11T03:10:31.665432Z", - "iopub.status.idle": "2026-08-11T03:10:31.667902Z", - "shell.execute_reply": "2026-08-11T03:10:31.667392Z" - } - }, - "outputs": [], - "source": [ - "walker = rxmc.walker.Walker(\n", - " rxmc.param_sampling.BatchedAdaptiveMetropolisSampler(\n", - " params=my_model.params,\n", - " starting_location=prior_distribution.mean,\n", - " prior=prior_distribution,\n", - " initial_proposal_cov=prior_distribution.cov / 100,\n", - " ),\n", - " evidence,\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "id": "214aaf01-78ec-4c0b-a74e-a67d59b0e4a0", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:10:31.669280Z", - "iopub.status.busy": "2026-08-11T03:10:31.669138Z", - "iopub.status.idle": "2026-08-11T03:10:35.105323Z", - "shell.execute_reply": "2026-08-11T03:10:35.104725Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Burn-in batch 1/2 completed, 500 steps.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Burn-in batch 2/2 completed, 500 steps.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 1/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.390\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 2/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.364\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 3/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.336\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 4/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.360\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 5/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.394\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 6/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.386\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 7/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.390\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 8/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.358\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 9/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.342\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 10/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.384\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 11/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.338\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 12/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.370\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 13/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.368\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 14/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.352\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 15/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.362\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 16/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.300\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 17/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.396\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 18/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.342\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 19/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.340\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 20/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.366\n", - "CPU times: user 3.66 s, sys: 5.09 ms, total: 3.66 s\n", - "Wall time: 3.43 s\n" - ] - } - ], - "source": [ - "%%time\n", - "walker_scaled.walk(n_steps=10000, burnin=1000, batch_size=500)" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "id": "eeee43dd-2c5d-43df-9ed2-7610abe4899f", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:10:35.106658Z", - "iopub.status.busy": "2026-08-11T03:10:35.106520Z", - "iopub.status.idle": "2026-08-11T03:10:38.552877Z", - "shell.execute_reply": "2026-08-11T03:10:38.552229Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Burn-in batch 1/2 completed, 500 steps.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Burn-in batch 2/2 completed, 500 steps.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 1/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.382\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 2/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.400\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 3/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.394\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 4/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.352\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 5/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.358\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 6/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.362\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 7/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.350\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 8/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.364\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 9/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.340\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 10/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.352\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 11/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.376\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 12/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.320\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 13/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.344\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 14/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.398\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 15/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.298\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 16/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.306\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 17/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.384\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 18/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.340\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 19/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.378\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 20/20 completed, 500 steps. \n", - " Model parameter acceptance fraction: 0.372\n", - "CPU times: user 3.44 s, sys: 13.1 ms, total: 3.45 s\n", - "Wall time: 3.44 s\n" - ] - } - ], - "source": [ - "%%time\n", - "walker.walk(n_steps=10000, burnin=1000, batch_size=500)" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "id": "5a1c1318-3a89-49fb-bfe9-815bd2689807", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:10:38.554263Z", - "iopub.status.busy": "2026-08-11T03:10:38.554119Z", - "iopub.status.idle": "2026-08-11T03:10:39.693393Z", - "shell.execute_reply": "2026-08-11T03:10:39.692867Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig = corner.corner(\n", - " walker_scaled.model_sampler.chain,\n", - " color=\"tab:green\",\n", - " truths=[true_params[\"m\"], true_params[\"b\"]],\n", - " labels=[\"m\", \"b\"],\n", - " show_titles=True,\n", - ")\n", - "\n", - "_ = corner.corner(\n", - " walker.model_sampler.chain,\n", - " color=\"tab:orange\",\n", - " fig=fig,\n", - ")\n", - "_ = corner.corner(\n", - " prior_distribution.rvs(10000),\n", - " fig=fig,\n", - ")\n", - "plt.plot([], [], color=\"tab:blue\", label=\"truth: $m=2, b=4$\")\n", - "plt.plot([], [], color=\"k\", label=\"prior\")\n", - "\n", - "plt.plot([], [], color=\"tab:orange\", label=\"posterior\")\n", - "plt.plot([], [], color=\"tab:green\", label=\"posterior, $k/N$ scaling\")\n", - "fig.text(0.6, 0.75, \"$y=mx+b$\", fontsize=20)\n", - "fig.legend(loc=\"upper right\")\n", - "plt.tight_layout()" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "id": "2a678f70-58e3-4c4f-a290-7125f334b823", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:10:39.694861Z", - "iopub.status.busy": "2026-08-11T03:10:39.694706Z", - "iopub.status.idle": "2026-08-11T03:10:39.698023Z", - "shell.execute_reply": "2026-08-11T03:10:39.697468Z" - } - }, - "outputs": [], - "source": [ - "def predictive_posterior(\n", - " walker, model, x, x_data, y_exp, y_err, percentile_bounds, added_noise=0.0\n", - "):\n", - " n_posterior_samples = walker.model_sampler.chain.shape[0]\n", - " y = np.zeros((n_posterior_samples, len(x)))\n", - " for i in range(n_posterior_samples):\n", - " sample = walker.model_sampler.chain[i, :]\n", - " y[i, :] = np.random.normal(loc=model.y(x, *sample), scale=added_noise)\n", - "\n", - " percentiles = np.percentile(y, percentile_bounds, axis=0)\n", - " return percentiles" - ] - }, - { - "cell_type": "markdown", - "id": "553d614e-1779-44a9-ab0e-a35260fd4d0b", - "metadata": {}, - "source": [ - "## Empirical coverage" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "id": "c80f57d4-3ca9-46ba-8e4f-afe91f169274", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:10:39.699471Z", - "iopub.status.busy": "2026-08-11T03:10:39.699335Z", - "iopub.status.idle": "2026-08-11T03:10:39.702290Z", - "shell.execute_reply": "2026-08-11T03:10:39.701847Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "array([10, 20, 30, 40, 50, 60, 70, 80, 90])" - ] - }, - "execution_count": 26, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "spacing = 10\n", - "inner_pctls = np.arange(spacing, 100, spacing)\n", - "inner_pctls" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "id": "a239e4c5-a93e-4cbf-a7a9-95fe571c82de", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:10:39.703609Z", - "iopub.status.busy": "2026-08-11T03:10:39.703490Z", - "iopub.status.idle": "2026-08-11T03:10:39.706322Z", - "shell.execute_reply": "2026-08-11T03:10:39.705900Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "array([ 5., 10., 15., 20., 25., 30., 35., 40., 45., 55., 60., 65., 70.,\n", - " 75., 80., 85., 90., 95.])" - ] - }, - "execution_count": 27, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "pb = np.hstack([50 - np.flip(inner_pctls) / 2, 50 + inner_pctls / 2])\n", - "pb" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "id": "5fafba0a-fc4a-4a49-86cf-1ec706eff1ae", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:10:39.707604Z", - "iopub.status.busy": "2026-08-11T03:10:39.707486Z", - "iopub.status.idle": "2026-08-11T03:10:39.709889Z", - "shell.execute_reply": "2026-08-11T03:10:39.709286Z" - } - }, - "outputs": [], - "source": [ - "lower_bounds = np.flip(pb[: inner_pctls.shape[0]])\n", - "upper_bounds = pb[inner_pctls.shape[0] :]" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "id": "b3b2f360-6926-4a3a-ab12-b54150b4392f", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:10:39.711108Z", - "iopub.status.busy": "2026-08-11T03:10:39.710993Z", - "iopub.status.idle": "2026-08-11T03:10:39.713326Z", - "shell.execute_reply": "2026-08-11T03:10:39.712884Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "45.0 55.0\n", - "40.0 60.0\n", - "35.0 65.0\n", - "30.0 70.0\n", - "25.0 75.0\n", - "20.0 80.0\n", - "15.0 85.0\n", - "10.0 90.0\n", - "5.0 95.0\n" - ] - } - ], - "source": [ - "for l, u in zip(lower_bounds, upper_bounds):\n", - " print(l, u)" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "id": "707ad8cb-8b56-4a88-a90f-64efc51cc4de", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:10:39.714736Z", - "iopub.status.busy": "2026-08-11T03:10:39.714618Z", - "iopub.status.idle": "2026-08-11T03:10:40.022224Z", - "shell.execute_reply": "2026-08-11T03:10:40.021499Z" - } - }, - "outputs": [], - "source": [ - "pctls_scaled = predictive_posterior(\n", - " walker_scaled,\n", - " my_model,\n", - " x_data,\n", - " x_data,\n", - " y_data,\n", - " noise,\n", - " percentile_bounds=pb,\n", - " added_noise=reported_stat_err,\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "id": "ae2f5205-f199-4168-a91a-367d4e3eb91b", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:10:40.023673Z", - "iopub.status.busy": "2026-08-11T03:10:40.023539Z", - "iopub.status.idle": "2026-08-11T03:10:40.328092Z", - "shell.execute_reply": "2026-08-11T03:10:40.327564Z" - } - }, - "outputs": [], - "source": [ - "pctls = predictive_posterior(\n", - " walker,\n", - " my_model,\n", - " x_data,\n", - " x_data,\n", - " y_data,\n", - " noise,\n", - " percentile_bounds=pb,\n", - " added_noise=reported_stat_err,\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "id": "37f7ea46-cddf-4a4d-ad5c-a561ed6792d6", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:10:40.329758Z", - "iopub.status.busy": "2026-08-11T03:10:40.329622Z", - "iopub.status.idle": "2026-08-11T03:10:40.616031Z", - "shell.execute_reply": "2026-08-11T03:10:40.615425Z" - } - }, - "outputs": [], - "source": [ - "pctls_unbroadened = predictive_posterior(\n", - " walker,\n", - " my_model,\n", - " x_data,\n", - " x_data,\n", - " y_data,\n", - " noise,\n", - " percentile_bounds=pb,\n", - " added_noise=0,\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "id": "75a16414-2acf-4fa1-8c9c-e17e39524709", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:10:40.617569Z", - "iopub.status.busy": "2026-08-11T03:10:40.617435Z", - "iopub.status.idle": "2026-08-11T03:10:40.619973Z", - "shell.execute_reply": "2026-08-11T03:10:40.619414Z" - } - }, - "outputs": [], - "source": [ - "lower = np.flip(pctls[: inner_pctls.shape[0], :], axis=0)\n", - "upper = pctls[inner_pctls.shape[0] :, :]" - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "id": "72e89091-7a24-4454-becb-f8b71b057e5b", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:10:40.621138Z", - "iopub.status.busy": "2026-08-11T03:10:40.621021Z", - "iopub.status.idle": "2026-08-11T03:10:40.623206Z", - "shell.execute_reply": "2026-08-11T03:10:40.622725Z" - } - }, - "outputs": [], - "source": [ - "lower_l = np.flip(pctls_unbroadened[: inner_pctls.shape[0], :], axis=0)\n", - "upper_l = pctls_unbroadened[inner_pctls.shape[0] :, :]" - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "id": "910d78cf-18ce-4b51-82d1-9b44d9728f74", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:10:40.624449Z", - "iopub.status.busy": "2026-08-11T03:10:40.624336Z", - "iopub.status.idle": "2026-08-11T03:10:40.626802Z", - "shell.execute_reply": "2026-08-11T03:10:40.626149Z" - } - }, - "outputs": [], - "source": [ - "lower_s = np.flip(pctls_scaled[: inner_pctls.shape[0], :], axis=0)\n", - "upper_s = pctls_scaled[inner_pctls.shape[0] :, :]" - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "id": "1b2a4f2a-d4fc-4db8-9b71-46be0b828e06", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:10:40.628270Z", - "iopub.status.busy": "2026-08-11T03:10:40.628119Z", - "iopub.status.idle": "2026-08-11T03:10:40.794660Z", - "shell.execute_reply": "2026-08-11T03:10:40.793817Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnYAAAHWCAYAAAD6oMSKAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlcelbwAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsnXeYXHW9/1+nTZ/Z2b6bLekkhGakRroRuHClCEFFQJALYqXYAMtVryLFRsCKCAiiPyWEIqCAIBKQUJMAaZC6ve/0duac8/tjMpOZ3Znd2bRNwvf1PPM8O6d+zjm7Oe98qmRZloVAIBAIBAKBYJ9HnmwDBAKBQCAQCAS7BiHsBAKBQCAQCPYThLATCAQCgUAg2E8Qwk4gEAgEAoFgP0EIO4FAIBAIBIL9BCHsBAKBQCAQCPYThLATCAQCgUAg2E8Qwk4gEAgEAoFgP0GdbAP2NKZp0tXVhdfrRZKkyTZHIBAIBAKBYEwsyyIcDjNlyhRkeWyf3PtO2HV1ddHS0jLZZggEAoFAIBBMiPb2dpqbm8fc5n0n7LxeL5C5OT6fb5KtEQgEAoFAIBibUChES0tLTsOMxftO2GXDrz6fTwg7gUAgEAgE+wzlpJCJ4gmBQCAQCASC/QQh7AQCgUAgEAj2E4SwEwgEAoFAINhPeN/l2JWLYRjouj7ZZggEk4qmaSiKMtlmCAQCgaBMhLAbgWVZ9PT0EAgEJtsUgWCvwO/309DQIPo+CgQCwT6AEHYjyIq6uro6XC6XeJkJ3rdYlkUsFqOvrw+AxsbGSbZIIBAIBOMhhF0ehmHkRF11dfVkmyMQTDpOpxOAvr4+6urqRFhWIBAI9nJE8UQe2Zw6l8s1yZYIBHsP2b8HkXMqEAgEez9C2BVBhF8Fgu2IvweBQCDYdxDCTjApHHTQQfzhD3/YY+c79thjWbx48R473+4gGAzi8XhYsWIFACtWrMDj8RAMBifZMoFAIBDsLQhhVyaJdIJwKrxHPol0YrIvdxTXXHMNF1988S47XjQa3WOhvXQ6zRtvvMG8efPG3O6oo47i0UcfBeAf//gHHo+HD33oQ6O2mzlzJr/61a92i61jYVkW0WgUwzCATE5oNBrFsqw9botAIBAI9k5E8UQZJNIJnt78NO2RdlyaC5c68Rw8E5NwMoxhGfhsPlS59K332Xyc3HoyDtWxM2bvUhKJBPF4fJcdb82aNdhstl12vPHOlUwm+cAHPlBym7a2NlauXMnJJ58MwKuvvorT6WT58uVs2rSJGTNmANDV1cWmTZs45JBD9oTpY/LBD36QcDiMx+OZbFMEAoFAsJcgPHZloJs67ZF27KqdBncDPrtvQh+35iaQCBBJR6hz1VHlrCq5rV21E0qF0M3yvVlr167F4/HwwAMPcNxxx1FXV8exxx7LG2+8UbDdc889x7HHHkt1dTVz587l1ltvLfD2LF26lKOOOoq6ujqOOeYYHnzwQQB+8IMf8Pvf/55HHnkEj8eDx+Ph+eefB6C7u5tLL72U5uZmWltbueCCC2hvb88d8/LLL+eSSy7h2muvpaWlhcMPPxyAI488kgceeCC3XXt7O5/85Cepr6+nqamJyy67jMHBwdz66667jnPOOYdvf/vbTJs2jWnTppV9f1auXElTUxO1tbUAbNmyhaOPPprLLruMRCLjHf3b3/7G8ccfj8/nA+CNN95g4cKFHH300SxZsiR3rDfeeANZlkuKxM2bN3PeeefR3NzMAQccwNe+9jWi0WjB+k996lM0NTUxc+ZMvvvd7+Y8l7feemvu/jY1NXHmmWeyevXqkte1atUqGhoacqHYP/zhDxx00EHcddddHHHEETQ2NnLmmWcWPA+AH/3oR7l7+OlPf5rrrruOU089tez7KRAIBIK9FyHsysSluWjyNOFUnRP62GQbfbE+TEzmVs6l2lk95vZ2xT5h27Ihueuvv54bb7yR119/nUMPPZTTTjst99Jfv349//Vf/8Xpp5/OW2+9xU9+8hNuvvlmfv7znwMZwfGJT3yCq666itWrV/OrX/2Khx56iMHBQa677jouueQSzjzzTHp6eujp6eH4448nGo1y4okn4na7eeGFF3jppZeoqKjglFNOIZlMAhlP33333YfT6eTll19m2bJlQGEo1jAMzjjjDILBIMuWLeMf//gHq1ev5vzzz89dYzKZ5NFHH2VoaIh///vfYwqekaxcuTInxJ566imOOuoozj33XO6++24cjoxX9PHHH+ejH/1obp833niDww8/nEWLFuUEbnb57Nmz8Xq9Rc916aWXYrPZeOmll3j66adpbm7m//2//wdkWoZ86EMfIpVK8fTTT/PMM8+gKArPPPMMANdee23u/r788svMnj2b//qv/yIWi4353LPiXNd11qxZw+OPP86f/vQn/vOf/xAMBvnc5z6X2+d3v/sdt9xyC7fddhsvvfQS8+bN49Zbby15DoFAIBDsW4hQbJnsSPjVMA22hrYSN+JM903Hpe3eNio//OEPOfHEEwG44447+Nvf/sbdd9/Ntddey6233soxxxzDt7/9bQCampq44YYb+NGPfsRXvvIVNm3ahM1m4+Mf/zg2m43a2tqcIAFQVRVFUQrCfvfddx+KovDLX/4yt+yXv/wltbW1PPfcc5x++ulAplDiRz/6UUm7H3vsMd577z2ee+65nFft3nvvZd68eSxfvpxjjjkmZ/Ptt9+Oqk7s13blypUsWLCA//u//+MXv/gFDzzwAKecckpufSwW4/nnn+f2228HMgKss7OTww8/nOnTp/P1r3+dLVu2MG3aNN58882c17EY7777Ll/4wheYOnUqkMlNzL83NpuNP/3pT7kw9P/+7//m1muahqZpAHg8Hn72s5/xwAMP8MILL/Bf//VfZV2rqqrcd999Oc/jV7/6VS688MLc+p/97GdcffXVnHPOOQBcf/31PPHEEyJPTyAQCPYThMduN7GnRR2QE0CQecEfccQROc/WO++8M6oQ4LjjjmNwcJCenh6OOeYYpk6dypFHHslNN93EK6+8gmmaY57vlVdeYcOGDfj9fioqKvD5fFRWVhIMBtm4cWNuu/Hy0d555x1mzZqVE3UABx54IFVVVbzzzjsFyyYq6iATsvz973/Pgw8+yKuvvlog6gCeeeYZWltbmT17NkAuhP3BD36Q6dOnM3/+/Fw4NuvJK8VnPvMZPve5z/HlL3+ZRx55hHA4nFv3+uuvc+yxx5bMLezu7uaKK65g9uzZVFRU4PF46O/vZ+vWrWVfa2NjY07UAVRXVxONRkkmk+i6znvvvcfRRx9dsM/I7wKBQLA/EY1GkSQJSZIKUmP2V4Sw2w1MhqgDRk0FUBSFdDoNgGmaRddDJqTndrt58803+fa3v83WrVs577zzOPzwwwvy3EaSTqc54YQT6OjooLOzk66uLrq6uggGg1x55ZW57ez2scPLxWzL2petAC3nOMVoa2tjaGiI008/neHh4aKiqlgYdubMmfj9fgDOO+88lixZQk9PD11dXWMKux/96Ec89dRTVFVVccstt9Dc3Mzf/va3Ma8zywUXXEB3dzd//etf2bRpEz09PbS0tEyoeliWi/9JW5aV+5T6PRAIBALBvo8QdruYXSHq0mZ6h8795ptv5n42TZMVK1Ywd+5cAObOnTuqmOL111/H6/UyZcoUABwOB+effz6/+c1v2LBhAz09PblwrKqqozx4hx12GCtWrMA0zVzSf/aTDSmWw9y5c9mwYQOhUCi3bOvWrfT39+fs31FWrlyJ3+/n7rvv5phjjuHss88uyCezLIsnn3yyaH5dlvPOO49XX32Vhx9+GEmSmD9//pjnPOqoo/j+97/Pyy+/zMUXX5wLQx966KElPaGGYfDiiy/yta99jfnz51NdXU0sFqOzs3Onrj8fm83G1KlTc33wsqxcuXKXnUMgEAgEk4sQdruQXSHqYnqMUCo0/oZF+M53vsP69etJJBJ873vfo6+vj8suuwzI5Ho988wz3H333ei6zhtvvMGNN97IV77yFSRJ4rHHHuPGG2+ko6MDgNWrVxMOh2lpaQGgpaWF9evXF7Q8ueyyy3A4HFx00UW0tbVhGAZr167lyiuvZMuWLWXbfc4551BfX88Xv/hFgsEg/f39XHnllRxxxBGccMIJY+5766230tDQUHL9ypUrOeyww5Akifvuuw/TNPn0pz+dyyl78803iUajHH/88bl9Rgq7OXPmMG/ePH74wx8ya9asglDnSM4991xef/110uk0w8PDrF+/PncPv/CFL9Db28tVV13F0NAQkUiEO++8k2effRZFUZg2bRoPPvggqVSKnp4eLr300gKP5a7gS1/6Erfddhuvvvoquq5z33335Yo3BAKBQLDvI4TdLmJXibqt4a0o0o6Fxq688krOOOMMvF4vf/zjH1m6dCl1dXUAHH744fzpT3/ixhtvxOFwsHDhQj7xiU/wrW99C4CTTz6ZRCLBggULsNlsnH322XzrW9/irLPOAjK5Y36/n8rKyly7k+rqapYtW4Ysy8yZMwe3283555/PEUcckRMz5WC323n88cdpa2ujpqaGpqYmZFnmoYceGnec1YYNG8bsT5cVdpCZefrYY4/xn//8J1dE8vjjj3PaaaflcvcGBgZob28fFW4977zzxg3DAlx88cV8/vOfx+v10tLSgs/n44477gBg6tSpPPfcc7z11lvU1dXR2trKihUrcjluf/jDH3juuedwu93MnTuXAw44gJkzZ455voly1VVX8fGPf5wTTzyRqqoq7r//fi688MI91lNQIBAI9gTvt7y6fCTrfVYOFwqFqKioIBgMjvK8JBIJNm/ezPTp03NtMADCqTBPbnoSu2ov2o7EMA3aw+3EjThTvVN3StSpqNS6a/nojI/itRVvqTGSd955h0MOOYTu7m4aGhpIp9NjFhmkUqkxX+SGYZTMuzJNk1gshtPpHLVNsfNm256MzI+LxWLYbLZR2xuGgSRJo3LFUqkUpmkWPBeA6dOn8/jjj3PQQQcVtTcej6OqakFoOJVKoes6brebI488kquuuio3VSN7fW63u0BUptNpEokENputLBE01j3Mrpdluahw1XU9Z28sFiuolo1EIrhcLmRZztmarVROp9OkUilcru2/fyO3yV8OmZy8c889NxeuLkapvwuBQCDYW4lGo7l/93p7e6mvrwcy/4a63e7JNG2HGEu7jES0OykDTdbw2XyEUiGS6WTBuuxECYB6Zz1pM00oObFQatpME0qF8KgevHYvfpsfTS4/R20k41WOjidMxhIksiyXnHRQ7LylCh7yxUc55y5l8+rVq0seC8DpdBY9ls1mo6enh5UrV+baskDp61NVdUITHsYrSBhrfb4IHXlt+TaMtFVV1VHPYOQ2W7Zs4S9/+QtXXHEFLpeL//f//h+PPvooTz/99NgXJBAIBPsh+QJwXxV9IxHCrgwcqoOTW0+e0DSInUGTtb1qnNjezFiibjzq6uoIBoM7dYx9jZaWFkKhEAcddBBDQ0NMnz6dBx54gIULF062aQKBQCDYBQhhVyYO1YGDvVNszZs3j3A4vF/8T2NPIsvy+0rUQcZTeOONN3LjjTeOGy4WCAQCwb6HEHb7AWOFRwWCUghRJxAIBPsfoipWIBAIBAKBYD9BCDuBQCAQCASC/QQh7AQCgUAgEAj2E4SwEwgEAoFAsE/wfm48XC5C2AkEAoFAIBDsJwhhJ5gUkskky5cvz02mEAgEAoFAsPOIdidlktANUoa5R85lU2Qc2t7ViiKZTLJixQrmz59fcprEROju7mbBggW89957zJo1axdYKBAIBAKBQAi7MkjoBk+v7iGYyEyeSBsWwbiOIktUODXGmVM/YSocGqce1LBXibv29nYWLFjA5s2bmTZt2k4fz263c/TRR++W2aNZEXrMMcfs8mMLBAKBQLA3I0KxZZAyTIIJHYeqUOHQqHbbaPQ5iCbTDEWSeG0aFY5d83GoCsGEPiHvYDweZ/ny5ei6TjQa5a233iIQCBTdNplMsmrVKt57772Sx2tra2PNmjXoekbIGobBypUrAVixYgXLly9n3bp1ue1N02TdunW8++67GIZR0rahoSHeeOMNhoeHqaqq4rbbbqO2trZs+0odayRZETpRxrqO1157jfb29oJlW7du5Y033gAyQ6ZXrVoFwMDAAKtWrSKVSk3YBshc56pVq+jo6Bi1Lv887e3tvPrqqxiGwXvvvcfmzZtz1/D222/v0LkFAoFAsG8jhN0EsKsyLpuKy6ZS7bEzr9GHhUR3KI5dVXLrduZjVyf+SDZu3MiCBQv40pe+REtLC4sWLaKxsZHf/OY3Bds98MADNDQ0cO6557JgwQIOPvhg1q9fn1vf39/PUUcdxeGHH84nP/lJmpubeeCBB4jH49x4440A/N///R/XXHMNv/3tbwF49tlnmTZtGmeccQZnnnkmzc3N/P3vfx9l29VXX82cOXP4/Oc/z9tvv50LxeaLpfHsK3WsXcF41/HII4+wYMEChoaGAOjr6+Ooo47iySefBODBBx/kox/9KGeeeSbz58/njDPOYOrUqbz88ssTsuPnP/85jY2NfOpTn+Koo47iiCOOYMOGDbn12fOcffbZHHvssVx11VXE43FuuOEGLr/8cg477DA+9rGP8eMf/3gX3BWBQCAQ7GsIYbcTuGwqM2vdJHSTTQMRDNOaVHvWrFlDe3s77777LnfffTdf/vKXc6Jgy5Yt/M///A+33norGzdupKuri+nTp3PJJZfk9l+8eDGqqtLd3c1bb73Fhg0biEajeDweHnzwQQAefvhhli9fzs9//nPa2to499xzue2229i0aRPr16/ntttu44ILLqC3t7fAtvb29pyH6YQTThhlezn2lXusiVLOdXz/+9+nqamJK664Asuy+MxnPsPs2bP55je/mTtOR0cHs2fPpr29nY6ODs4++2w+/elPk06ny7Jj6dKl3HLLLbzyyiusXr2ajo4Ojj76aC666KKC7To6OjjqqKNoa2tj+fLluXFy//73v/nlL3/J2rVrue+++3b6vggEAoFg30MIu51kbxJ33/rWt3C73QBccMEFHHjggbkX/P33309raytXXHEFADabjR/96Ee88sorvPPOOwCkUikURcmFIb1eL5/97GdLnu/ee++lubmZ1tZWXnvtNV599VWmT5+OqqosW7asYNtvfvObY+bTlWPfWMd67bXXWL58OcuXL8+FjbPfly9fPqZnr5zrUFWVBx54gKeffprTTz+dF198kT/+8Y8F81Y1TeP73/8+AJIkceONN7Jx40ZeeOGFkufO5xe/+AWnnnoq4XCY1157jddff50TTzyRV155hYGBgdx2breb6667btT+Cxcu3CVCVyAQCAT7LntF8YSu6/T399PY2Ig0RiWCZVls3Lhx1PL6+nq8Xu/uNHFMsuJuY3+UTQMRZtR4UORdXFFRBnPmzCn4PnfuXDZt2gRkwpgHHnhgwfoDDzwQWZbZuHEjBx98MF/+8pd57rnnaGpqYuHChZx66qlceOGFJQXZ+vXr6e3t5Utf+lLB8lmzZmGahTmCU6dOHdP2cuwb61jXXXcdsVgMINdC5ZprrsmtP+CAA0p6scq9jlmzZvG1r32N733veyxevHhUEUljY2PB72F1dTU1NTVs2rSJD3/4w2Nc/XY7tmzZwrvvvluw/OijjyYQCFBTUwPAlClTUNXRf7rj3WOBQCAQ7P9MqrDTdZ3rr7+e3/3ud/h8PhRF4Wc/+xnnnXde0e2j0SizZ8+mubm5oOXGrbfeyrnnnrunzC7K3iDuRnbhjkajOTHg9XpHJf/HYjFM08yJkZaWFl5//XXWrVvHv/71L26//XZ+8Ytf8Prrrxc9n8PhYM6cObz00kvj2ibLYzuHy7FvrGM999xzuZ83bNjA7NmzWb58+bh2QfnXMTw8zF133UV9fT333Xcfn//859E0Lbe+WBf0aDSKz+cr245PfvKTuXzGUpS6l+PdY4FAsH+STZkBiEQiuciN4P3JpL4JrrzySh566CGWL19OR0cHK1asKOqRG8mDDz7Ihg0bcp/JFnVZJjss+89//jP3cyQS4eWXX+bwww8H4Mgjj+TVV18tqJb9xz/+gd1u55BDDgG2C5O5c+fy+c9/nvvuu4+VK1fS0dGB0+kEyFXKApx00km8/vrroypY0+n0hCtCy7Fvd1HudVx55ZU0NDSwcuVKuru7+e53v1uw/eDgYC4MDPDSSy8Rj8eZP38+kBGqy5cvJxQKlbRjyZIlBfcYigvGcli3bl1B9bJAIBDsCcTYr8ll0oTd2rVrueeee1i8eDHz5s0DoKqqim984xvj7huLxejs7MSyJrdYoRiTKe5uvPFGfvnLX/L3v/+dc845h+rqai6++GIAPvWpTzFjxgzOPPNMHn/8ce655x6+8IUv8NWvfjXXcuSaa67hc5/7HA8//DD//Oc/+cEPfsDs2bNpaWmhoaGB6upq7rzzTv7zn/+wbt06LrjgAj70oQ9xyimncPfdd/Pss89yxx13MH/+/FHFE+NRjn27i3Ku49577+WJJ57IVe7ed999/PjHPy7In7PZbHziE59gyZIl/PWvf+XCCy/koosuYvbs2QC8++67LFiwgDfffLOoHd/73vcIh8OccsopPPTQQ/z973/ne9/7Hh/5yEd26LquueaagnC0QCAQCPZ/Ji0Um/XGnHHGGQSDQVKpVNkv8NNPPx2fz0c0GuWKK67gpptuwuVy7WaLIZk2gfIqHKdUONg8GGVtd5Bp1R7KjZJlzrFjPPzww9x///089NBDzJo1iz/84Q/YbDYgk/z/r3/9i1tvvZWf/vSnuFwubrrpJi6//PLc/r/+9a+5++67ue+++4hGo3zgAx/gjjvuyIX4HnroIe644w6+/vWvc9RRR/Hzn/+cp556ijvvvJOHH36YeDzOwQcfzNKlS2lpaQHA5XJx9NFH5+zIMrJBcTn2lTrWSBwOB0cffXTZ901V1TGvIxQK8ac//Ylf/epXHHDAAUCmUOG73/0uv/rVrzj22GMBmD59Orfffjt/+MMf6Orq4tJLL+X666/PncftdnP00UeXDM22tLSwYsUKbr/9dn7961/jcDg45phjCtquNDQ08IEPfGDUvgcccAB+v79g2cicRYFAIBDs/0jWJLm9vvrVr/Loo49y2mmn8ac//QlJknC5XNx+++0lQ6uxWIxf/vKXfOlLX8LpdPL6669z5pln8rGPfYxf/epXRfdJJpMF80hDoRAtLS0Eg8FRL9hEIsHmzZuZPn16QcHAyMkT5bKjEyomOnninXfe4ZBDDqG7u5uGhoYJ2SjYNfziF7/gF7/4xX4Z+iz1dyEQCPYO9rYcu91pT7nHzt+ut7eX+vr6ovvsbfeuFKFQiIqKiqLaZSST5rGTJImNGzciSRIDAwMoisLNN9/MBRdcwNtvv53zjOTjcrn4+te/nvt+xBFHcP3113PDDTfwi1/8omjy+E033ZRrQbGjODSFUw9qeF/PihUIBIJ9iX3lhf1+Rjyj3cOk5dhlQ3U33HBDrhfY17/+dSRJ4vnnny/7ONOmTSMej9PX11d0/Q033EAwGMx9RlZelotDU/A5tD3ymaioKzdEKdh9lAqRCgQCgUCwJ5k0j93ChQuBTAuJpqYmIKPYdV3PuRlN02TTpk25PnXpdHpU/64XX3yRioqKkvl5dru9oDXK/siMGTPKbu0h2D0sWrSIRYsWTbYZAoFAIHifM2keu4MPPphPfvKTXHHFFbzwwgu8+uqrXHjhhUydOpXTTz8dyMSUZ8+ezUMPPQTA7bffzjXXXMNzzz3Hm2++yQ9/+EMWL17M//7v/xZMABAIBAKBQLBvsze0TdkbbJgok9qg+N577+Wmm27i2muvRZZljjzySH77299SUVEBgKIozJw5M+fBu/rqq7n77ru5+eab6e/vZ8aMGTzxxBOccsopk3kZAoFAIBAI9lKyYzIBXnjhBU499dT92hk0qcLObrfzve99j+9973tF13u93twQe8gIvSuuuCI3T1QgEAgEAoFgLLKN+gHOOOMMmpubWbx48V4z3GBXI2YQCQQCgUAg2G/p7u4u+N7Z2cmiRYtYunTpJFm0exHCTiAQCAQCwX7FWGMts+17r7nmmoIw7f6CEHYCgUAgEAj2G5YuXVq0F24+lmXR3t7OSy+9tIes2nNMao7dPkV0AJLFh7fvcuw+cNfsmXNNEm1tbRx66KGsWLGC6dOnT7Y5AoFAINgPWLp0KYsWLSp7lnxXV1fu5/2lsEIIu3KIDsBD/wOxoT1zPlcVnPf7vUrcbd68mfnz5/PWW2/R2tq608czTZNgMLhfusEFAoFAsOcxDIOrr766bFEHFMzz3l8KK4SwK4dkKCPqVDuozt17rnQ8c65kaK8SdoZhEAwGMc1dM1attbWV4eHhcWfeCQQCgUBQDsuWLaOjo2NC+wwMDBR8zxZWLFmyZJ8VdyLHbiKoTrC5du9nB4Tj2rVr8fv9/OUvf+Gkk05iypQpnHjiiaxcubJgu/Xr13POOefQ2NjIzJkz+drXvkY8Hs+tNwyD7373u8ybN4/W1lbOO+883nvvPYLBIB/84AcBOPTQQ/H7/bkpC729vVx++eVMmzaNGTNmcPHFF9PZ2TnKtgcffJAFCxZQW1vLE088QUdHB9OmTWPr1q1l21fqWAKBQCAQjKx+3RH2h8IKIez2A7LetK9+9at85zvf4cUXX+SAAw7glFNOIRTK5AVGo1EWLlyI2+3mhRde4L777uPRRx/l85//fO44v/71r7n33nu5++67Wb58OZdccgm33HILPp+Pf//730BmhNuWLVv4wx/+QCwW48QTT0RRFJ5++mmeffZZHA4HH/nIR3IVSVnbvvWtb3HLLbewfv16Tj311FGh2HLsK3UsgUAgEAgaGxvL2i47BKEU2cKKZcuW7Qqz9jhC2O1H/PCHP2ThwoXMmDGDX/3qV9hsNu6++24gM+UjmUzy+9//ntmzZ3Psscfyy1/+kvvvv5/29nYg4zE76qijOOaYY5gyZQpnnXUWd911F5Ik4fV6AfD5fPj9ftxuN/fddx+WZfGb3/yGAw44gOnTp/PrX/+a3t5ennvuuQLbfvKTn3DCCSdQVVWFpmmjbC/HvnKPJRAIBIL3H8cffzzNzc1IklRym5qaGu64446yjrcrPICTgRB2+xELFizI/axpGkcccQTvvPMOAG+//TaHH344Docjt81xxx2HaZqsWbMGgPPPP58nn3ySRYsWcc8994ybq/DKK6+wZcsWamtrqa6upqqqirq6OoLBIBs3bizY9rDDDhvzWOXYV+6xBAKBQPD+Q1EUFi9eDFBS3C1evJiWlpayjleuB3BvQwi7/YiRJdqqqpJOpwFIp9Ooqjpqe0mSctuccMIJrFu3juOOO45HHnmE2bNnc+2115Y8n67rHHfccWzYsIGNGzeyadMmNm3axODgIJdffnnBtna7fUzby7Gv3GMJBALBvsC+OGB+shk593VkHty5557LkiVLmDJlStH9zz777HE9e5Ik0dLSwvHHH7/rDN+DCGG3H5FfLGFZFqtWrWLOnDkAzJkzh1WrVhX8Ebz55ptYlpXbBqClpYVrrrmGRx99lCeeeILbbruNzs7OnOjKr4rN9qFTFAW/31/wmaj4Ktc+gUAgELw/Wbp0KfPmzct9P+OMM5g2bdqo0WDnnntuQaRn5PqxPHvZ77fddltZ/ex6Qwle3jhILJUed9s9hRB2+xHf+c532LhxI6lUih/84Ad0d3dz2WWXAXDZZZcRiUT41re+RSKRoKuri2uvvZaPfvSjzJo1C4Dvfve7PPLII0SjUUzTZNWqVbhcLiorK2loaEBVVd5+++3c+S677DLsdjuf/vSn6erqwrIs3nvvPb74xS+yZcuWCdlejn0CgUAgeH/y6KOPsmjRooKuC1B67mu+KDv22GNHHa+UZ6+5uXl0qxNJBgoFYDJt8FZHgGfW9PBub5hocu+poBXCbiKk45CK7d5POj6+HSW47LLL+PCHP4zH4+Guu+5iyZIl1NfXA1BdXc3f/vY3/vGPf+D1epk+fTpNTU3cc889uf0/+clPct9999HY2Ijb7eaee+7h4YcfxuVy4XA4+OEPf8hFF12Ez+dj0aJF1NTU8MILL6DrOtOnT8flcnHmmWdy8MEHl53DkKUc+wQCgUDw/uQb3/hG0cbDO9OeZKRn78knn2Tz5s2j+tfZm+fhnH00WwdjxFJpNvRFeHp1Ly9vHESRZMwJNETeE4gGxeVg92WmQcSGIJ3c/edzVWXOOUEuvvhivv71r5NMJouGQo877jhWrlxJIpFA07RRbuYDDzyQpUuXYpompmmOynm77rrruO666wiHw8hy5v8Es2fP5vHHH8c0TdLpNDabrWCfefPmMTw8PKq8vFiD4vHsK3UsgUAgEOzfjPTU5ZPfnuSkk06a0HEVRUHSHCieKk444YRR751AXEerakbSHPzrvUFq+xIEYikcqsLUKhcW0BPae7x1IIRdebhrMiO+9pFZsePlt+VXnhZDluWccCtGtvXJyH1Girrscr/fX/bysewbax+BQCAQvL/Z0fYkWk0rWnUrgbiO2124rn0ojmR3kh7sZEqFHd2C1koXqpJ5R+rGrpnGtCsRwq5c3DV71YgvgUAgEAgE2ynVnsSyLGSHFzMRGbUumkxjbzkYxe2nfShOU40/ty6eMtjYH8OMZ/bTFBmvfbQDY29D5NjtB2RDlNl8OoFAIBAI9ieampp2qD2J4q3m5S1BnLOPQa0cLfy2DsWQ7W4kWWNNd5h4antYtX04xnA8hRnbQ9G6XYQQdvsB2RDlWN22BQKBQCDYV7n11luBibUn0Wpacc46hs1DCWSbE1v9TFLp7aHThG7wXl+MdLAXfaCNd/sitA/HgEyI9d2eMA5NBgqLIxLJBGeddRZnnXUWiWRiV1/qTiOEnUAgEAgE+zDjNe3dH7jwwguxLIuGhoaC5UXbk2xD9Wc8dK1+B+lgH4q3hs2Dsdz6rYMxBqMpzFgQIzJIpdvGirZheoIJXni3n85AnGr33h96HYkQdkUoVlItELxfEX8PAsHeS7lNe/cku1NovvHGG7mfS7UnAYim0iiuCszEtokelomZjLK2O0IglmJ9T5iV7cO47Aps+zfugDo3nYE4f3q1jTe2DtHsd6Ip+55M2vcs3o1kB8rHYrFxthQI3j9k/x6yfx8CgWDvYOnSpRNq2runbNqdQjM/3FqsPUmWoaiOZHNipbb3hjWjAYZiKf69vp9/v9uHYVrUerZ75DRFpqXShdumIEsygbi+S2ze04iq2Dyyo7H6+voAcLlcIm9N8L7FsixisRh9fX34/f6yxusIBII9g2EYXH311SWb9kqSxDXXXMPZZ5+9x/52s0JzpE1ZoVkqZLo7GIymyEyLKLSl1msjENdpqXShKfKoHLlKl41Kl43eUILuYIKkc2wNkEwkuerqr3P5uhcJ9XXgHtkvZRIQwm4E2fh9VtwJBO93/H7/qLwWgUAwuSxbtoyOjo6S63emae+OsCeFpqTasczSs1lN06IrkCjw1mXx2FVq7GP3cgWo92W2aRsIoXiqMCJDO27wHkYIuxFIkkRjYyN1dXXo+r7phhUIdhXFJoAIBPsCI/O8Tj311P3qd7ncZrz520WjUTweDwCRSGSXepd2RGjuyDMKxHWcs47C0pMEYqMbCme3CcbTmMnoDl1Llnqfg2QqieLdt3rYCmFXAkVR9qt/BAQCgeD9QL54yXLGGWfQ3NzM4sWL91gocHdTqhnvjm63s0xUaC5dupSrrroqt7zYM0qbJvYZh2Ml46QH20CSWb4liOKpBklizocXkexax8CWtVTkTUQaiqZIpA2sdGqnr6vOa8cID6B4a+gLJ2ktw9s32YjiCYFAIBDsNzz66KNFl09mQcHu4Pjjj6e5uXmHmvbuDiYiNMst+ugYTmCrbsE191g8Hzgd56yjGIylSQ93kR7qRFI0nDOO4Ok1/aztDhGIpTBNi95gAmUX5scbkSGM8AC9oSS9ob2vb91IhLATCAQCwX6BYRh84xvfKLoum/t1zTXX7Bd93hRFYfHixcDEmvbuLsoVmh/60IfGzMWDzDOKJXXe6Qxi6SmSW99CUu3Y6mdS7doeaDQiQ6SDfYQSaV54t5+/rerib2910RGI43Hsmus2TTN3rlBPG12BGH3h5C459u5CCDuBQCAQ7BcsW7ZslBcon/w8r/2Bc889lyVLljBlypSC5WM17d1dlCs0//Of/xTk4kmqHdmxPXSefUbfvOk2vva/N2aKFiyLVM97GKEB/vnq20iaffvBTYN6n50ZNW4qnBrRZJpYMo3PsfPtmV5++WW++IUv5r4vvvn/uP2W/+OF199G8VTt9PF3F0LYCQQCgWC/YEcKCvZ1zj33XNasWZP7PlbT3j1hy3hCs/DeS9iaD8zMca1uzi2VHR7uWvIPhvu6wNo2Asyy0Ic6ePShB9GqWwrFHRnx6LKp1HkdtFS5UOSdC8W+/PLL3HzzTQwODhYsH+rYxNL770Lx1uy14k4UTwgEAoFgv2BvKyjYUxRr2rs7K2DH4txzz+UjH/kIFRUVQEZo5le75t97taIOrboVTAPntA+ScvlBUdF8dUh2N+mhEd5XyyI91IFa2YxW3YI+2I6l7/qwqGma3Pm7Oyk2dMeyMmFZywLFW8NAZO/rniE8dgKBQCDYLzj++ONpamoquX5PFxS8XxlrOkTuGSkqtvqZYJkYoX6MaABbw2xs1S2YaX20qNuGZWY8d5aeLOq52xWsXrOawYHBkuuz4s4ID9AXTSHbnLvchp1BCDuBQCAQ7BcoisKtt95adN1kFBS8n1G8tchu/+jl256RVtWCUlGPERoAwNITpIc6SQd6scbrP2cVirtYqvximI+f/3HOOuusURMn8hkeGi7rWEZkiDq3DUkIO4FAIBAIdg9nn3120eWTUVDwfiWcSOOYeiiumUexaSA6qgL2gyecir1xNmYiuj2HbqLkibvNgzFiqdKTKCZKZVVl2dvWeLSiEy4mEyHsBAKBQLBfM5kFBRMlGo0iSRKSJBGN7tzkhMmwx7Is1vaEkZ0+kGRe2jjMirYAPcEEkWSatzsCLHtvCGQVMxbI7XfDN2/I/VxdXU2pNnQFy7eJO4cqs7E/usvE3UHzDqK6pkwbAFMIO4FAIBAI9hwj87wEu4+eUIINfbFMDlpkCJ9T5fWtQzzxdhd/W9nFy5uGcNpkjPBAwX7zDpyX+/nSz1wKjBZQRbEsplW7cGi7TtzJssxnr/hs+TbsZQhhJxAIBAKBYKdJGyZvtQdIm2YuPOlzqMyo8dBU4cShyTT5HfhdY/eYO/roo7n++huoqqoete7LeWPIsiiyxIwazy4VdwsWLJiQDXsTQtgJBAKBQCDYabYOxXijLUCN15Zbli1WSKdTeB0adrU8z+mCBQv45a9+OWr5kUccWXT70eJu56eLTNSGvQXRx04gEAgEAsFOkUqbvNMZIJZM0xWwMjHMYo3gJoAsT8z3lBV3mwYibB6MIWn2kn3ukokkHz//47vchr2Bfc9igUAgEAj2A/Jn1r7wwgv79Azb9Z0DXHzFl/n5t75MOJZEq2qelAS1nOdOlXN97uwOO4899hh/ffCve9yeyUAIO4FAIBAI9jBLly5l3rztBQNnnHEG06ZN49FHH51Eq3aMVNpkXU8EK53CSsWZVuVA0uyTKu6mVbt2qM/d/oAQdgKBQCAQ7EGWLl3KokWL6OwsnK7Q2dnJRRddtEdsmEgbE0m1o7gr0Y3iPee2DEbpCycxIkMAODUFfbB90sXd7upzt7cjcuwEAoFAIJgAOzOH1TAMrr766lFNeyHTA07ay/prRJNpHNPno3hreXJ1Hwc06lS5bficGqZpsXkgynt9YRw2paDZsKUn0Qfb0apb0KqaMcydy7ebKA67g8cefRTDtNg0EGFjf5Qm3/tD8rw/rlIgEAgEgr2AZcuW0dHRUXJ9McG3J7Asi2BcZyCSQpKgzmtHkSWWbxlGrZyCEexDN0xWtgUwsXLVrcm0QbXbToWtyDHzxN2WwRhzpzhQ5D0rXCdSULG/IISdQCAQCAR7iO7u7sk1QJKRnT7MPAHZE0rw3uYQ/ZEksaSBJIHXruG2K2wdjJMe7gbToNptw2F3AJDUDSzAoWUEXiJZPI8tK+4SaZNNAxFm1Hh2+yWOJCvu1nWl0Kpb0AfbC9b/9cG/5q5rf2DShd2mTZv4/e9/z+bNm5k/fz5f+tKXcDpLD9Q1TZN7772XZ599FofDwcc//nFOO+20PWixQCAQCAQ7RmNj4549oVSYSq9WTsHRchAvbw6ieKqRXRU8/+4gkqJR7bbR4HVgAZFEmkBMp7nSAeZo0WbXyp/kYelJmjwKX/rmd7H0JL/72Y07e1UTZmRBRVzffwsqJrV44plnnuGQQw6hp6eHs846i2g0yoUXXjjmPpdffjnf+c53WLBgAdOmTeOss87izjvv3EMWCwQCgUCw4xx//PE0NzeXzKXblTl2alUTzplHkkxnREzaNNHqZiCpDrYMJ3DOPgbH1EOxqTKtVS7cdhVJkpAlCZ9TY4rfiabsGpmQX1DRNpyY9IKKLUMJJM2+Q8cx8oTu2nXrdpV5u4xJ89jFYjEuuugirrzySn72s5/llg8PD5fcZ9WqVdxzzz08//zznHjiiUCmeeD111/PJZdcgt2+Yw9JIBAIBII9gaIoLF68mEWLFiFJUkFO3a4Udam0ia1uJqq/ng19UY6q8NEdTGJvnE060EOr34EZD2GZBpXjjPjaVeSHZbWqZvShjp1uYjxxIyz0oY5cn7uRYdlyuPbaa3M///jWW1G8o8eOTSaT5rF7/PHH6evr4ytf+UrB8srKypL7/P3vf6empoYTTjght+z8889neHiY5cuX7zZbBQKBQCDYVZx77rksWbKEKVOmFCxvbm7mj3/84w4dU/HWYKufRdrMVKZuHYqheKsxYkHW9kQYiqbY0B/F0hMo7kr6I6lMEYGxZ9uAWHpyp/rcrVm7ZhcYYdFa6djhPnfDQ8UdUHtLD8JJE3arVq2iqamJQCDA5z//eS655BJuu+024vF4yX02b948yoXd2tqaW1eMZDJJKBQq+AgEAoFAMJmce+65rFmzXaQ8+eSTbN68mbPPPnvCx7IsC61uOo6ph7KyI0gkmWZtTwQrGcOMBggn07y+dYjOQAK9fytGeIC+SArFU7UrL6lsdqbP3U0/ummX2LA7+txdd911e8X0kEkTdtFolEgkwic+8QkOOeQQTjzxRO6++26OPfZYUqlU0X2SySQul6tgmcPhQFEUEolE0X1uuukmKioqcp+WlpZdfi0CgUAgEEwURdlegHDCCScUfJ8Ig1Ed1VeLkYjwdmeY5RsHGIikMKIBINO6ZOtAjLRpYaVTGJEh6jw2FG/NpIm7bFg2K+6K9bl75ZVXdrMR28OyG/ujOy3uOjo6WLZs2S4ybseZtBw7v99PMBjk8ccf57jjjgPg1FNPpaWlhccff5xzzz131D4VFRWjcvACgQCGYZQM4d5www0F4d5QKCTEnUAgEAj2GzoDcSTVjhEaoNZjY31vhAqnCmTEksumoKgKsrXdM1brsWGEB1C8NfSFk7ROQruP/D53uYIKy+Lj538cgMqq0qlZ2zbdBUZYTKt20RVOs7E/ysxaNy7bjkujkdNEJoNJ89h94AMfAGDWrFm5ZU1NTTgcDnp7e4vuc9hhh7Fp0ybC4XBu2cqVKwE49NBDi+5jt9vx+XwFH4FAIBAI9m7KC08mdINNAzHMeOa96LarHFDnocpd2DG4wqmNqnA1IkMY4QF6Q0l6Q8WjXrubkQUV+WHZUrlssGtrLrJ97hzaznvurr32WpYuXbrrjNsBJk3YnXbaaTQ2NvLnP/85t+yRRx4hmUxyzDHHAJlw7TnnnMNzzz0HwNlnn43NZuOOO+4AMj3tfvrTn3L44Ydz4IEH7vmLEAgEAoFgJ5AdXmz1MwuqYxVPNc7ZRxOI6+Pu3zEcJxDXMRPbHR6lqmtNc/vIr2wRghEZot5npzuYoG0gyFlnncVZZ51FIrnnhN7OFlTsCvLF3dquYc4+73zOOusskomJTakYGBhg0aJFkyruJk3YOZ1O/vKXv3DTTTdx1FFHccIJJ3DxxRfz85//nPnz5wOg6zqPPvoobW1tAFRXV3P//fdz8803c+SRRzJnzhzeeust7rvvvsm6DIFAIBDsRewNyesTQa2cgmP64fSEMgLCsiy0mqlotdNZ0RbM9aDLxzQz4786A3E29kcynrhxXFgvv/wyX/zCF3Pf84sQ6rx2Gisc9IaS+2RBxep3VheI1gljWeimvl3cbWuFku1zJztlZEehXJJUMsukkYfKPIdrrrlm0n4XJ3XyxPHHH8/WrVtZvnw5sixz8MEHU129vR+M2+3m4Ycf5oMf/GBu2dlnn01bWxuvvfYadrudY445BputyJA6gUAgELyvWLp0KVddddWo5Y8++iif+tSnJsGisUmlTbSqJiRZ4Z3uMDMaqugLp1ArG0kHetg8GOOtjiBHTK3MeeEM0+L1LUO81xcmoZuYpkWNZ+x34CuvvMLPfvrTktrvlVde4cQTTiSZSqJ4a3b1ZZZNfs6dVtWMhyjDg0Pj7vf973+f6ppqPnvFZ1mwYMGo9SkzRX+sH6/sLbp/X7yfwdAgB9UchE22FUyoCCYTOFodSIpEsitJOpCmosGH7ksjO2RMXcJK24hv3K7wLMuivb2dZcuWcdJJJ+3w/dhRJnXyBGQ8dyeffDInnnhigagD0DSNc845J9fSJIvf7+eUU07hhBNOEKJOIBAIBCxdupRFixYVTV6/6KKLJj3vqRi94SSy04s+1EnXcILOQJx1PWFkmwsrGaXWa+PtjiCru0KkDRPLsni7I8BbnUGcmkprpYsZtR7s6tiv8nvvuXdMh969996LaZrUee0FBRWTQX617H+df0nZnruhwUFuvvkmXn755YLl4VSYNYNrWDO4hvZwkWbEMnTHuumL9dEf6wcKW6Gs6u5G8bmQVAnHNAeOVjsfOu9YZKeMmTSRVRnNryE7Rts5WXOBJ13YCQQCgWD/IhqNIkkSkiQRjUZ3+/kMw+Dqq68uyFMbyWSGxkrRPhwHLCw9gSzDWx0BVndHkO0uJM2Ox67isav8Z+MAz6/v453OEG+2DVPlslHh1JDl8kTP4ODg2OsHBlm9ZjWwdxVUTJ81p+ywbPbR/+6u3+XCskOJId4ZeIeh+BA+u4+uWBeqvzBQqfpUAskAaTPNu8PvkjSSuQOaqW7C6SGgHiOuYiZNtFobPrcPI2xg6RZGovTv1B6fC7wNIewEAoFAsE+zbNkyOjo6Sq7PD43tLYQTOp2BBGYsU/RQ57XTMRzHocmYiUhuIkKV20az38WWgRgvbxrEqalUOMcfATbRnLNvffNbuUKB/IKK3eG5y5+1WmrZjhRUWBYM9A+wes1qLCw6I50kjAS1rhpcqgtFUrA12JBs244lgVatEU/HMTAIp8L0xfoyq1Sw1Wr4PAmsRBLFPQUrbSM9nGZG84zCE48wTZIkWlpaOP7448u/KbuQSc2xEwgEAoFgZyk35DVZobFi9AQTRBJpzGTGo2lTZeq8Gpgy+lAHWlUzmwdjOOx2XDaVaTVukmkDuzp+E+OXX36ZO++8c6fsq/PasdugbSCE4qnCiIyf61Yu+bNWs3zpi18ateydVW8W5NxlZ8tKGlgGUEK7Dg8NE0vHCCaDeG1essrLZ/OhulXsTXaGkkOoFSpatYZhGdTYa5AlmY5IB3EtjnO2C9WlUmmvwIh2obinoLinYES7CquOJZDs279n191222073HB6ZxHCTiAQCAT7NOWGvCYrNDaShG6wsT+CbURunNehkUgaoyYiZJvmlhJ1DruDxx57DMiIuptvvmmX9Hmr9zl2qKDC7rDz2GOPkUgmcs2G8ynWny4SiYxadsftt2NZFIi7dLgD51QnZtIg0ZEsKu4qqyoJJAIkjAQV9rzetRakQ2k0v8bz65/H0eJA9apU2auosFdgYdEb6yUYDyIpEnpAR5EUwCoQd8lsmzsJvA0+UnlCr7m5mdtuu63okIU9hRB2AoFAINinOf7442lubqazs7Nonp0kSTQ3N09aaCyfVNrk1c2DbB2IUTtWNesOTEQwTZM7f3fnLm3eO7KgYkcnVBQLv5ZLfrVs7WEHk5TakF12zLRFqjuVHbCBJEF1TQ0HzjuQtwfexqbYyHrr1q1bx1NPPYVlWKSDaZ55+hm0ao3UQIoKewUAaT3NXT+7q5QVOXG3euMAqHY0r8lHTv0Ijz+eCfE/+eSTnHrqqZPmqcsicuwEAoFAsE+jKAqLFy8GSjfnnczQWBbdMHltyxBru8M0VTpHeeygMDdu3Zo1TKtylT0RYfWa1QwOjF0oMVFM08wVVLz2znt0B2I7dJz169dPeB/LAluDDa1WQ1J1oIfZhx+M5GrETJjYG+xoNZl8w+xjv+LyK4ilY4RTYdyqG8iIuiVLluSmViluBcWloA/qGGFjArZlxN2LLzyHva4Vh13jGL2P71et4fMHGTs173dXIoSdQCAQvM/Z01Wsu5poNMp5552HZVk0NDSMWv/HP/5xUkNjkGkqvLI9wOrOIFMqnDi0QgGQTCQ566yz+OQnPplb9v3vf5/PfvZy+ja8U5a4G2sE10hu+OYN426T39TYiAzxxzt/wTdv/DH/+PfL4+w5mkAgUHS57JRRfMXFkOJTsDXacLQ6cM12YWuEphaVQ+cdgZ2pmAkLe6MdxadQXVPD9dffwIIFCwgkA+imjk2xYVkWTz311PZjuhUUj4IRMTCiGS/is88+W7KiesOGDYULJIuprg4u9q3j93UbOG3zA3zU28OBpcfa7nFEKFYgEAgE+w1vvPEGU6ZMAfZEaKz86QhruoOsag9Q53XgtI2257XXXyu639DgILfechPfuO4G6mYdPGZYtrKqfHUx78B5Y64v1tTYiAwR6IS7/vQQelrnzIUnlH0+v98/aplkk3C0OJAdMom2BOlAnmiVwVZry+TFDaeRnBI2v41ql4cDDm1kRuMMlvz1TyD38qkvfYozj/goDtVJykzRF+vDoWRCxm1tbYWeuhGiDiAcDtPW1pb7vcnnX//6FwCaZLLAF+X0hjBHuiN4rDRxy8bmsJtaVQNSZd+L3Y0QdgKBQCCYMNFoFI/HA2QS391u9yRblCFfxO3O0JjircHefBD/WNNHQ6UXRZaIJtPohkmT30lDhROvQ0U3THqCCd7YGqDCqeFxFH/t3n///UWXW1YmzPj73/+O3/72d2wZipUUdwfNO4jqmmqGBgeL5tlJ0riTx3KUamqcrY5d+o9/ccThR9Dod5U8Rn5YeVT7FRnsjTZUr4qpmziaHcTNOEYoI7i0Sg21QiUdSiNpEppXxYya1DprsdsUGisNUGxg1uOq9dAWbqPe1cDm4GaGk8PUOmqB7UUZpURdlmLFGwB+fYhz60OcURWkxZlClmE4KbNJt2EhIakWlFGpvCcRwk4gEAgEggkQSaaxtxyE4vQTjOsEk2GwQFUkJAnahmLYVQW7JmOYFgndwKEqVLpKF0uMFUbN9mdbt24N8+YdzKaBSFFxJ8syn73is9x8802jRNwERq8CYzc1znruXn3nXY45dC71vtEFFSNbrtxy8y0Ftqg1Glq1jXQojWVYKB4FZ6sTfVjHjJtotRqWbiEpElqliqWDHtCRpUwGmV2TcsUMeryStlAn/bEBUmaKWmfttmpW8Hg844o6AJdru0C1SSbH+KKcWhnkKG8Un2qQRKHHtJFMgJWnUS0jQa56Yy9BCDuBQCAQCMpEN0xe2TKMrXEOya2rqPPacRSpFE3oBsm0iVOVqHTaihZKTJThoeHcoPpS4m7BggVcf/0N3HnnnQXirLqmhksuuYSf/uSnO20HZMSdkgzTHcxMp/Bq29XOkgeX8ODDDyLbZbRqDVQw4yZmzEDSZHwtPtLuNGbCxDIsnE4nVtoiJaWw1dkyEW4JTjvhNKqnVSObMvf+4t7R+slIYkS7sCyNSMyF02dR4yxszeKr9+Gp8xDpi5QUdQCPPfYYHz/pg1xSP8DpVUGa7SlkLIbTClvSDixZwtLNAlG3nYk1g97dCGEnEAgEAkEZJHSD1Z1BNvRFsVJxtKpmDLO4t8ahKaMKJHaWbA5dOeLusA8clivE+O53v8v8+fNJ6bs2D2xqvZ+6CgfPv7KSfzz8/zK2eRQeWfYI7oPcqJ7MGC7LtMAEM2kiqRJ2n51UfwpLt7jggguYMWMGqVSKH//4x5jxjEiSNAl/sx+bbKPSXlnaKWYkaaiAgYiDSFTCo1m5UWvBZJBQKsRxHzyOJx56oujuWe/caZXtHLXldbyNBnFTojupkrJkNKeGZRolRZ2qqsDeNapOCDuBQCAQ7JcMRVO805vgsBb/DoustGES0w36Qkne6QzSG0rQWOFA79+CVt3ClsEYc6c4UMqc21qKyqrKkuHYbH+2g+YdlFs2nriT5e0ewoMOPqjgO4zfV666upqhoeK5egDVNdUcNO8gXnnlFf5y72+RPTXYGmux1cbRKjUsLFK9KaxUtskcyHYZM2US6grljtPa2ookSQX2SVom/KrJGnWuOoz02LbaNYnGSpnuYZOeADT4IayHCCQD+O1+ph44FeciJ0/94x+Et+XStdiTnOwPc0ZlkGZHCgWLobTCpkQmdw5A1mR8FT6G+gZLeOqgqqoKInvPRBMQwk4gEAgE+yGSzckrWwL0Rg00ReaDUyfWjyKc0HmzbZj+cJJk2iSaTOPUFKZVu0km47mmues3bEZTNWbWeXdK3F188cXcvvj20deR159tpDgbT9yNRbGxXvmVuZd+5lJ+9tOfliy4uPTSSwG483d3kg4PocrgnD0FxR3GTA6jD6ex9LwdLTAT44css6LO0qHWWYssyRhleMTyxd2G/giaI0CVw59rPjx37lzssknHU/dyWmWQI70xvErGO9eTVElahfdW1mSQocJdgb3eRl9/P+n06FYzLpcLq3jdxaQhhJ1AIBAI9i8UDUfLwXSHEjT4PazuCjLF76ShovTUhOFoCkWR8NhUBiJJlm8apDuYoNJlw2NTqXbbUGW5oCjA0pP84Y5b0KpbsPQk9/3qJ7idzh0y+cgjjiy6vLqmhisuv4IFCxYUv9QdFHfFvIN33L5dWB599NFFc/Xy1+c3RJbsYVRfBCw/elTH0svvqZclX9TlF0qUi12TcLki9A3E8FOJ1+sFwBfvY9rgmyzsfQ5tWieylMmdy/fO5ZMVdZZuIksyHo8Hl8vFho0bAZjS2EjXXjR3eCRC2AkEAoFgv8I+ZQ5aVTPNfgdel42tQ1FWtg/zYXd90SKGaDLNc+v6iOtpnDaVlG4S09NMr3bn8rWg+BzW/HFXTy57nXM/cty4nrtSM1RHks2NG+mpG0kxcVdsj1EtR8ZhwYIFzDtkHpd/43IkVeLLF3yZH9/049z6rDiUHTL2FjuWEUAfSiGpVUh2CysZKHpcr8eTC4lmSRrJAlG3I4WmwWSQuBlgWo2fVETD276SIxJvMCX0LrZ0nCjwXiqTO1eKfFFXEH7NKyt27KB431MIYScQCASC/YbBqI5W3UI6MoSmZF7gVQ6Jj1/2RZJtbzG0cdWonnu9oQSD0SR1XgdJ3UCRJaZWFW4z1hzWrLh78ul/ctihh+10WDZLsdy4UowUd02+0a/3tWvWjn0QW6ZfHDJ0Bbv46le+iq3ehq0+06ZFnaIi2TKx2d5YL1F3FEerHdmhoPk1kh1JLD2JZLeQHdWYUFTcHXzIIbz88vbpFUkjSX+8f4dFXSqV4ie/+AmKR+GrHzuT+Ym1TOt/DVdsABkL3e4h5mzAtCxSvaXjpiVF3T6GEHYCgUAg2G94rz+KpNmxwtvDh5oiY8ZC2BoPoCeUYOYIYfde9xBf+8pXSAd6+OuDf8Vht4867nhzWC09ydDmNazfuAlJnsmMGs8uEXflEkqFiKfjzKipY9NAhM2Dscx90JO5bYYDw8guGVu9DSNkkA7qAChuFdWnoFZoSHYJLFg7vAbnDCdIZCZCSDCYGMQ5zQkqrBteh63Ghn9uJUk9SbI7mcups5IBTCgp7kaKuqHEEJqs7bCnLp4Y4sO1YT5iG+K/N92N3UiQVmxEnVVEDRUZCfs4j2JHRZ1kGWjS3qUCxaxYgUAgEOwXyG4/KzsjRcWBmQgjKSor2kPEU3njpBI63cEkRjw0eqc8ypnDaulJnKkQCd1k00CkZCuU3UFXpItNwU3oVpIZNR4cqoxW3YKkbRepfr8fW50NW40N1wFO3Id4cM/z4JzpRKuxYRom6eE06UCaKns1ZsTECBqZ+2lClb0K2SUjSRKV9kpMTA4/9HCSXUmsROG1WskAZmIQ2VGNZPcXtVnSJFZsWIFNtlHrrJ2YqLMspjuSXNE6yKc2/ILvVW7leFeItKwRcDYQsVdjKRoOTcK0LJI6BcfPtCnJIGsyiqZQW1lbnqizLHyKwXRHisrUIIOGjdf7J2D7bkYIO4FAIBDsVUSjUSRJQpIkotFo2ftp1a0Ypons8KB4qkatTwf76Q4meKsjkBv63htKEkmmsZKxMY9d7hzW+tpKZta696i4S6TjDCYGCSVD9Mf6UWSJadUuJJuOe+4MQolME+HGmY2ofhUzbYIkIasyVtoiHUyTDqaxktttlSQp038uD1mSMUIGZsJkMDFIykxx+JzDOe/s83KFCll8Ph9nn35iSXGXLZRY+fpKah21ZRdKaEaCaQNvcMqG33PX3C1cXtdHhZmgK6GyOWEnqboL8uFkie3iLq+otbW1NbNek6muraZ1Sitej3fk6bZjWThlk2Z7iqpkL07FZHnIzVONZ3PJ4FHct37vGSsmhJ1AIBAI9nlUfyNadTMza9wY4QEUbw194WThRpZJndfG251BVrUHME2LtsEYahkh0+wc1rFGc2V7u7ls6h4Vd8PJAPF0HI/moSvSRcpMkTZTKK4BlAqTl9s2EUjE6Yn3oLgUFIeCETbQB/VMC5KJmCeB5tfQTZ16Vz12xc7cuXP53Oc+l9vkggsu4Mtf/jJOp6uo5y6/+jXYGaSjo2Psc1oWMx0JPtvQx8fW/IQTNtxHU+AdEpLMxriNmL0mVxBhmibvvvce7773HuY28b5d3IGkZCujrVz41ev0opQQlrKZxpUcpjLRQ7WWZmvCzvLGM/if9dP5ansr/3a0EjD2rqw2IewEAoFAsM9imBaru0I4ps8HC9w2BSMyhBEeoDeUpDeUKNjebVepdNl4Y+swr24eojsUx+/Sxj1Pdg4rlJ67eumll+aKHfaUuLMw6Y31YpNteGwewqkw/fF+2iJbUVwyem8H4fQQyzatZ0ugCyQwIgZOaXRl55lnnjnmuUzLRPNrSFqmx5xd2R7mzS/yyDYdjmyrfM0Xd7K7clT1ayRSvKChZ8uGnHfuzgO2cFnDAA49wpBWQa+tkmBKwSpz6IMsgV0FJBlJdZA0UgUtTfKRsKhU00x3JPElB9FVJ2/Xn8g1G1v5zPrprKw7iTbTgVapoclqgadzb2DvkpkCgUAgEJSJaVq8snmQFVsDWKkkZiKcW2dEhqj32ekOJkg6C5VYhVNDluCtzgCWBVO85YXRSs1hzXL00UcXfM+Ku439UTYNRIoWVPz2/t8yoA9gqDs2liqcihBKhnBrbmRJxq7a6Qp3EYgFMCIGlmExo9rD+oFuQok0RkTFiKa4/JrLue222wqONWvWrNInkmAgOYCkgT6cLhB1pfB4PLmfrWQAS5WwVddixlX0QH/OU5i/HVjMcSY4yR/itLdvZorDxO12scWQ6UmpTNO8pC0jI6iMiQkqWQbLSKDYnaTSEpZubc+psyxs6Tit9iSqBCFD4bmAj5ojL6a3+mBilsqKyHoAUkYqJ06rHFU7VPCxOxHCTiAQCAQ7RfbFHIlERrUS2Z1s7I+wtitErddeIOqy1Hnt2G3QNhBC8VRhRIZy67wODUXeFp5j9ESBUoycw3rDN2/gph/dBEAykcz1p8tU1zqKirscEnRGO+lP9hNJRJCdMlbSRPYqyDYZ3dRxULqpMsBwYoiUmaJSyeQAem1eeqO92GU7VjqjOJJmnMoKHZdSBVI9KF1IRdyOVl4vl/b29gI7Nb9G2tRHT5QYg+bm5u2H0CRUdwQzrmKkfEg2HSsZwOv10traysa33+C/qwKcVhnkYHccl2wSNWXa4ip6LAUoSIqEbqaxKTYUaQdy2iwLWQXLSqJIGkh27FIMT3IIm5kiJdtYHXPxzLCPF4NeenWNCyJVzKhzwLapE5ImMZDsz2uivPfk1mURwk4gEAgEexVx3cAx8yjSQ6Vzr4ajKV5+r5drvvQljGjpitV6n4NkKonirRm1LjuhIZEsX9hBYdhx3oHzxt1+pLib4s2cV/EqDCeHqXfVMxAdwDHNARYoTgVJllg7tJZ5dfPwaJ6ixx1ODtMb68Opbg+rKpJCo6eRtJ65JsWtEEwFqXHX4HA4wUihuKdQ7JLvuuuu3M9LlizJ/LBN1Eka1NhryxZ1sP0+FU6U6Eey6dtaoVh8+sR5HLH1ERZs+RtVrQksJAZ0he6Umjn5NiRFQlIlNFlFk9Vc/ly5WEDSzIRfZV2nijAuRwzDhJjmY23t4Wz2zuPrzzxQcN4///nPeL1eFi5cmLsOdSdas+wJhLATCAQCwV5FbyiJrboJ1VfLmu4Qh89wFUyASBsmK9oChBL6mKIuS53XXlBQ0Wof2wu2O8gXd1sGYyBL2GoyjX81RaPaUZ1J5jchHUojaRJrB9dy269vI9Wb4uabbsZut6PKKpqsEUgG6Ip0YZgGVc7CCmBpmzBR3AqKR6HCVkGFvQJd1zGiXSjuKfQFJVDsYGwvMBmV65Yn6vThjKdsomTFkEN1EuoPgQVOfZATKgY4Y0qYk+JbUMNROq0UbQkbRpERX1lRZ6UtVHn8fMiRWEAyncCejtIqJZBsFpKs8PiAjxdSM5l1xBU01rpYs2Y1FDl/OBzm0ScezYnTGnvNXivqQAg7gUAgEOxldATiWEYaK5Xg1a1BTNnG/NZKbKqMYVqsbA+woS/MlDFmv44kG4btDSWx2xLU+yYu7sodBVaKrLhb2zWMvbkVpWIIn80HZNqLGJFMnp2kSWh+lUpbJrxqb7KzMbQRTdWwtikKCwufzVfgrcsnmAyieBSMiEGFvSJvjYUR7UJTLRT3FIxoV4G4yzFC1E3EU5clf0zYpZ+8hCfv/DEf9of49Fw7cqATJIWY1UrYstOnF7GBQlE30Zw6AMVIoiWH8ZgpDNXNs2EXzw5XcMhx1/Cjp+8CRafJ1OgOmDz77HPFbdjJGbZ7GiHsBAKBQLBLMYzthQAvvPACp556KopSXi5SOKHTFUhixMNYyRi1Hhsr2wPEdYPDp1aytjvMyvYAtV47mjSxgoP8ggpgh8TdzuKyqdR4DbRqN7LdjjLiNZwvImocNTmxV+usRdPK81YFk0GCqSBGxMCIFrtHFnU+cmHZUeJuF4m6/ng/LsPgaGmYs7b+gbMP2IJbNnGrDaxN2tAtian1LiwzhSRrWKZeeC92UNSpkkWVmsYf70ZHYtBWSXvdMbRXHMINz9wLSMzStvWsM5I0VMCaTX3ETC8QJt8dN1LU7c2euixC2AkEAoFgl7F06VKuuuqq3PczzjiD5uZmFi9ezLnnnjvu/j3BBNG8hsEum4LbqbG+J0wgptMXTlDndeCxqySSE68kzRZU7Ky4k2wSWqVGWB9dtFGKhJGgLbSVjnAnyL2YyXp6Q9BcnVELu8IzFEwGCSQDVNgqSoi6DLJELixbIO52hahLJ7CF17BweD3nN6ynTtOpCid4b1tl6wxbJbqVCaFrKnhcdoY1B4ZOTtxNVNRJWFSoBpWJXix7igFd5dXK+ayvOIBU7eHYVBe6rlMs1GrXJGxWABTb9nuBVVLU2Ww2vv3tbwMQjsUnfH92N0LYCQQCgWCX8Oijj3LRRRdhWRaSakd2eDAig3R2drJo0SKWLFkyStwNRVNs6AtzQL2XCqfGlsEomlooaOyqwtRqF73BJA0+R67oYUfJirmsuKsYv3NHIRLY623YGuysGV6DvdmOPqCPuYuFyebgZjrCHbgVN8ZwDJQuUmnoCVh4HMkJe4Z0XeeWW24B4LrrriNmxggkA/jtflyyq4wLsQrFXawLzWvusKhzywYnVEf4yPpf0pLowWmlaZMN2pM2JEcdIaN4vzpNgUq/l4EhMyO7pHSZos7CLZtUJPuZ7kgRMhQ2VxzCT1ds4HW5kv8+6cNM8U0pqzVLpc9VcC/MVDdapbJPeeqyCGEnEAgEgl3CN77xjVzLDFvDLJSKOuLvvoylJ5AkiWuuuYazzz47F5Ydiqb497t9dAzH6RiOM2+Kj55QAr9z9KtJlWWaKovnk+0I+eJuZJ+78VD9KmqNRjqYRpVVXLNcpBvSdMY6kVSwilScdgQ6+cHiH2BGTa758jWZhdvCgN0hna5wEEuX0AOpHRIRwWSQqBnFLbu548d3FKxLpVI5AZhlw4YN237aJu48U7DXtWIZ3ehD0fJFnWVRFeukpe81/jhvEw2ONL5oFN1RxbDsoFcvbyRchdfFQH8/kmZDkmRMPYVlWGiqSm1tbUGvO9nUcaVCzHSkiJsyA85mftGpsizo4eMLP8W/+RWSMrqJ8li0trbiddkIR7tQfU3YKpsxoz07/Dwmk707A1AgEAgE+wydnZ0AyG4/Wk0riqcataIeyPRIa29vZ9myZQAMRpI8vbqbVzcN0ex3EorrvL5liFjSwGXbBb3BJOiL9bF6cDW6WdybVu9z0FjhoDeULDpbtuhhbRK2BhsYYBkWkXQEM2Fg6RabQptwznRhb7LTHe0mmAxiYZI0krSF2zL7pEeoBDmFZO8DS8PUa8GamMiE7S1N/Hb/iEKJ0vzrX//KuygLWesHOYmZqsMyx69+taXjzBh4jY+s+xX/tXoxh3b/kwqbSUfSRsQ1BV11lR7RUQopjSSlsSwVLJWmpiamTZ+Ox+NBskycqRAVsR48qWHimpd7eqv54oapPDzrC/y1v4pu3TbhJsq5U0sSCxd+GElOIdv6wLTv8POYbITHTiAQCAQTJm2a2BpmYelJjFgQMxEh08ZfwlY7A0m1YyUiaDVT0Yc6wMzke3V0dbO+J8yq9gCheJqWKidbBmPMrHWTTJu4NBVpgkURI5FsEvZ6G+uG1yEpEm6pdNPksfrcjcQwDewNNhSXQjqQHtW0t8pehazJKHUK6wPrcUQdVNgrcKpOQqnQqJw3SZPoj/fjsTmpq63gGbkwx6scirU0KYdca5NcTp1FqrcD2dZYulrWspjrinNyRYjD//5l6mw61TU1xFQPIc1Pr57A1M2JCzogbepIqoSppzK/R4oNVXXgSEdx6BHAIqm62VR7JFurPsBW9wx+++TPAThNkna4iXKWdevW8ey/n8uEw1NJUuE2FFcmLOtSIiz88Mk88sgjo/azaRqLFp3Hl2//+R5tzj0WQtgJBALB+5wdqWLtDiaxN88DScFKpzCjw6QG28A0UaubMMIDWKaBWlGH6qslHehBdngZUGr597v9eO0q02vcmBZsGoiwsT/KzFo3LtuOFUVkeXvN2zhaHWgVGl6bF0My6I51IymUnCtaTp87C5O2SBtajQ0jbBRt2itLMkYsc5I6Zx3IENbDDMQHqLBVFGi1bGK+JmvUuerQU/roYoZxKN3SpEyKFEoY+uiCCq9icHxFmI9u/B1nztqKSzaJGDLtSRto1WztagOTjKjbAXQzjW6mt+XUmTjlJNVKgsokGJqLzoq5bK2eT4d/Holt7WGMPAGbP8N2ok2UAdavX1/Qpy6bU5d9Hkce99/Mnt08/oH2EoSwEwgEgvcxO1LFalkWG/rCYFmkhzuRFA3Z5aehdTaB/h4kwEqnMhubBmp1C5Ik0XDIsTjqp9Hkd2BXM8JRkWBGjadA3O1wjpAEi+9fjK3ehh7QsSt2FFWhJ9yDUqGSHio9YWJknzu/W2I4MYwiK7g0F8PxYdrD7RgxA9WrltW0V1O0zKgvOwWetPxZo7XOWt5d/y5PPfUUGMkCcffuextKHnv8libFue666+jq6uL+P95fovo1W1DRyMFVbk60dXGqf5BaLY3U0UOfIeemQkgyhGKhnRJ1aVMnbRnYgVo5hVczSVoSW+N23p37Ud6yH4pZWU+lp8R/NEbMsN2RJsrP/vvZ4oUr257Ha2+uYkpTU+Zk+0DCnRB2AoFA8D5l6dKlLFq0qGBGKDBmFSvAH/7yMN+58yGMSAAAy9AxwgMs+PCH+PsznRih/ty2RjSIVlGP5qtj0ScuZGatZ9ScUkWWCsRdk6+8V9Mrr7xS8F2r1rDV2jK93yzYuHEjc+fORZM1tGqNdKC4sEubaRzTHWBFkdQgq7qHMZUhVC2KJEnYFBuGaWBTbKhudadagYycNfreu+8VhvjyxN0//vUmxcREuS1NStHc3ExFUwXxVGzUdfiUNCdWRDizroPZjgQuxSSkW7QnbaTz8s0kGSRNZngosMOiTlZAS4WoNpNIkkKvofC3IT/Lgl7eirj42jkLMVMKwxELJJNK93bJr2ka3/zWN+mL9RFPxXfqeSS1ROnqVyNJuH8D3T0DJT2pyWINnicRIewEAoHgfYhhGFx99dWjRB1kPHLFqlghIwY/943/xdYwGytd+EJ74rHHGHk4K53EX+Hlwk98nIXHLyhpT7642zwYQ9LsWCWmEQCYpsm999yb+SKBWqlib7RjpszcC/7pp59mzpw5eDQPtiot47Ercr0D8QG0Kg0rbTGY3kTcspGMOmn011LpkkgaKQzTYCg2tNOibuSs0WeffXb0hiM8d/liIivqym9pUohpmQwmBvnAER/ghSde2HYdFoe443zEH+LD/hDVWhq3x8eWYYNu3ZUJt5MAMgIuK+p2zFNnYTMSTHWmUBWwSRLtNR9kY8WhfPVfTxI1Cz1zGTFnZsQd28WdaZn0xfpImSlqnRMPv8IEmg8bSTRzKNfnzjS3bxhKhUgaqQmfe3cihJ1AIBDsYqLRaK49QyQS2WuSqvNZtmwZHR0dJdfnV7GedNJJwDYx+LXr0SqnY0aDZZ3nu9/9LvPnz88NhB+LrLhb15VCq25BH2wvue3qNasZHBzMVKnW29BqNEiDGd8uNEKhEG1tbbir3cguBecMJxuDm5ihzsiN4kqZKTqjnVgpCyNqZCY8+DT6Ayl+c/dfMBODfO3qKwjpIfQdTMyHwvFa+bNGw+ESDY5HiDvTtApE3UQKJXJI0B/vx5RN5s+azyrrWU6sDvPfVQEOcCZwyBYhQ6YtYWPqlCYiA5uAJJLiQFIcWEYCSTJ3SNQppk6jTcclm2jpCCvSLv7ZX8FBx32dpKceXdeJmk8V3XekuKtwkRN19a56ZHPiwfv8cHg5fery+9xlm0qH9RCBVAC7MnGBvTsRwk4gEAjeh3R3dxd8VyvqMZPRTHVrke1iqTSPPfMCA1IFNocbfbBz1DGLOMM46OCDyhJ1WRRZYlq1C0tPolW3EEsZOIp0rRgeGkZSwdHqQK1QMSJGUcHVH+4n7U2jD+iYKZOOaAcRM8J0/3RqnbX0x/oJ6+Fc0UMWv1vCTAwiO6rZNDSE263vsGcoO15rwhMl8sTdxoEoTk8Ir7K9T921115bvhHZqlEjyXwzyczel/jI3E1Uq2kMCwZ0lYq6Jvp7ekbtahkJJMWBrDpAToFpliXqJMukWk1ToRp49QBb0yoPRiuwHXouv1j+EkbU5Dp7FeUMSsuKu6GwyUBsCLsjI+rsir1kO5uSdo0Ih3s93tICG/D5fDQ3N+eeRyoNG/rDaI4AfpufUHrvaokihJ1AIBC8D2lsbMz9LDs82FsPwUrFiW9+EysVL9iuL5xg2XsDvLBhGM3fSDrYX+yQuwxFltCHOtCqmtk8GMNht4+aNlFZVYlaraFVaCU9LopbwXJYBblo1Y5q4macNQNraPG2MBAfwKE4iu5vpQIoPo1A1KLKVY9dmbhnKGkk6Y31osml7RwTIwlWL8FEDFWtxOsvfwTaddddh6ZpJFNJ6qvhRN8gn21fQl2iF9lMsVky2ZqwYWwbs1XvGsPzZCWRVAdYdoz0WGO0LGzpGC4jgmSaDAJPDFVQc/inueGVpzDcGp/2zsGILivYS9M0vv3tbxdM0xhJhQsGYkMMRU2m2esn1KcuS7Fw+MKFC4u2Msly6qmnbv/PiZHE5QzREdDxU4nH7yRE8Ykak4UQdgKBQPA+5Pjjj6e5uZnOzk602unIDi84fdibDyaxdQWSadDc3MyRx3yI598dIBBLMbPBRzrYu9tt0w0dR6sNPdiNQ5ULWqFkaZ3VStX0KiKhSElR563zMqt5Fh4lb2qBJOO3+Ymn42wObcbColKrHLV/toUGUoDWSh/RuIpsji5UyM9RbG8vDB1nRZ1NtlFpryxqp9c7trdIcSsorjRTq+2kUm56QwblVmdKlkF9YCM13S+wsOU9KtCpjCeJ2ypIyXYGypwKkcmpk7DSSSzLlgvLZvoWZrBLJtVaGqdsYTOS9HpnssH/Ab727+cYSqtc7mjGcGsYEYNqT3Vu1mq5ZHPq7I4U0+z1ROMqw0phQcV4lAqHz5kzh0WLFvHUU0+NehbnnHMOc+fOzYW9FbdC3AwyraaGWMxNX8jc6+pkhbATCASC9yGKorB48WI+celnsdW0YoQHsQwdraYZjBR6/xZ+9vPbWNEe5LUtwxw1rYoW/8FU11QzNDhYNOwqScXDsROlN9aLc5oLNaRjqT2oTCkQd4Zl0BZp46gPHcU/H/nn6Gvb1rT32A8eS6WjsmgumlN1ZlpjWGAahWFF0zLpj/fnCiXqvHYiKYmBIEh2P1YykNv2rrvuyv28ZMmS3M9JI8lQYgibbKPOVYeR3i4K88XgYYcdxosvvlj0PmSvw4gY1LorMN0y7QPGuH3uajWdk/1hzly7mIpYB5Kp02GYbEnZkB11yBN4UKMLJRK5nDvZiFOp6vgUg7Ql0Zmy8fSwjznHf5mwrxU9nWYo/UJmMoY+8dYsWfILJbLh12Fle86dp4wOJ0kjyZA+xKcvvGTU8wCYO3cu06dP58c//nHB8jlz5uR+zm8GXeOpIGm3aBswiO9cP+1djhgpJhAIBHsp0Wim3YYkSUSj5XlXJsLZ53yM7/z8d1RUVWHpCTANjGA/tQd8kKt/ci8VB36IdzpD2FWZrUNRLCQ+e8VngfGHC0gaKKV6j41BLB1jY2gjqcEUZtykPdpGjM2YUoKN/VFCiQRbglvoi/Vx6OxDR+2f9dSdctwpzD9wPpCpoM3S1taWE1aKpKDIhTZmRUR+ocQtt9zCL3/+I9yajuyoRrL7c9vnJjgUXLvEig0rcqJuZE5dvhh88cUXcTqdOByFIVbFrbDgwwsKxJBdk2ioYHt1Zn7DY8tgSmAdx2/+f9w/dxPXNvXgi7YTVl2EXE0MpFRMJpYLNlLUqaoKWHiJMlWLMNVp4PNX8+ign69tauHiddO5u6eWIdeU3C9ITgxpO9aapZiog0zOXaVHYjhiMRTZ/nxHek2h0HNa7HlkGSsXNGbG+NT/fIorP30lNZ7MlBK7JlFfIWEYIsdOIBAIBJNI2jDpDibYPBChYfah/OzGQ7nkwk8B8L/fuoH58+cT003ah+JUujSm+B1s7I+yaSDCUUcfw/XX38Cdd97J4OBgwXG/fNVV3L74dpDB3uRAcSokjSQOSueFJY0kfbE+qpxVuFU3neFOTMvEjGVe1rWOWoKpAA4lhZxu4N+bAij2QWrdPhSrUJQpboWTzziZOVPnUOnIhFfXrVuXaf67jT//+c94vV5OO+005s6dC+QJPwne2fIOtQ01RQslKlzkCipMKPDcZcnmcK18fSUfOvBDRUXESDEYjxfmrJ39ibPx1nnxKB5e/FuhN8+uSbmCir4Q1GtpTvYHOXvNz6lM9iGbOhstaDMcNNj8OFRH5sImSFt7W4Go82gSrX6NZDhKxJR5LeTiufg0/Cdfzn3/+cPo8WMUTsbw2rwTtsG0TAZjg6NEXZZKt8ymTRv42yvv5Dyp+V5TKF/UjcXIauR87JqEy753BWMnTdiZpsmrr746avnMmTOpra3dZfsIBAKBYDsJ3eCFd/tpH4qDZFHndaCyvXFvtorVY5fx2Le/ImbWulnbNczH/+d69KEO7r33Hi695NKCYx95xJEAaDUaWpWGJEkMJgapcBUfd2VYBpuCm9gc3Iwqqcz0z6Q71o1P8+W2kWWZWnsNw8kAOpuJGhLORCWSS4U8u7OeoVlNswpE3cgXPWRajCxZsoRFixYBZITftqrRZ5//J3bdwcITFxa12UoGMKGouMvvixbsD9LR0cHUqVOBQq/hWChuBVe1i0pHZck+daqZ4Ah5Hf/d8xcundeOT4rjT0Dc5iMlaQSkOMhgU+zIkow5wfi4JIMpm6imhZ8UXkdmGsTqPounA3W8EPCyJWkDLC6wu4vOlt3RyRjbjdjemqWYqIPM8/37o0uQ7P6iz2P1+tVUTa3aaVEXNaNFRV0WdeKO6d3KpAm7WCzGggULOOigg3L9ngC+853v8N///d+7bB+BQCB4PxNNpnFqCrIsYZoWb2wdZvNAlOZKZ26sVyJZetRWFpdNZXq1C0mzo1U1AzKSTUK2yUhqxiMU1IOofhV7gx0zbiKpEr2xXlr9rahy4evGwqIt3EZbqI20mSZNmk3BTSiSgiuvL1i2QvK6664DB1Q7FXoD0D1sUuPZFlLNy0XLvnwtyyrw1BXjiSeeyHjLRsxMTenhMaski4m7Ys1u8z1zY/UMzJKfw1WsT50nMUhz/+v8Yc4mWu0pauPDbEFii+5jhr0GSZZIphMgg6WbOyRkZNnCb7fwyyksw2JAV3lyyM8LQS8rI65cBe22O0GdDzBSBeIuK4Z2dDJG9nnops4Uz5Sioi7/+ZZ6HstWLGPRtEU7LOoUt0IwFaTGXbNjs3gniUkPxd51110cc8wxu30fgUAgeL8RiKX417o+Kt02DmmqoCeUYE1XkMaK7bNaJ4LLpqAPtqNVt7C2fxD3gR5Ur4KZMLFMi3eG3sExNRN2NZMmpDKd+YeSQ9Q567CwiKVjJNNJInqEjcMbiekxPDYPda46JEli/br1/OmpP4069/r16zn44IMBaPBb9ASgJwiK14XiSo/yDLW1tY1ZbQoUFXXl9qnLFxOWKqG6I6Oa3eY7IIrl4uVTTJwCqJLFUd4Izv93FfN9EabV+ui2pehNqajOegZTW5AUhUTaQlZSWJaJpZv5BavlXA1u2cQZ6WK6SydsKPx7yMM/h30sD3mImKV/V2SJgkbKWL0FYihb/VpuM+VsNbKkZebolmppMvL5FnsesVCMeH8c2bNjoi5fZO9LTLqw6+7uZtWqVcyYMQOvt7wY/I7sIxAIBO831veE6Q0n6Y8k6QrEMUyLCqdtVE+4sUgkE3z8/I8DcP/992PpSdKhDjaFOrDVt5Bo24qVyqgIv82PGTOxjG3Kxsq0F+mN9uBUnHRFuuiP95MyUqTMFBE9QoWtIudRKRU6BXjkkUdQVZW5c+ciyxINfljXHUWrbEIf7sSIFo51Gk9IATss6rJYyQCWKmGrrsWMq+iB/pyo83q9tLa25rbNF3kjyRd1WXE60junShbDaYUhez2dqVieESaWkSBlpJFMcGn2skWdTTKp0gzcskncktkiefnrgIfnu510JcsoNd1uBEa0i3M/8wUiegKvzbVDYmhkNfJYfeqKPd9iz2PpQ0v56Ec/msunzJLtm1eMUiJ7X2HSq2L/53/+h09+8pNUV1dz4YUXEgyOP6ZmR/YRCASC9xMDkSTv9YWp89iZUeNBU2RUWabKPfqFbZgGjlY7WnXpGQCSlklEl1SwN0ik5Db0IQlZaySbnN/Z0bld1G3Da/MyGB/irf636Ih0YFfseG1eDMsoEHXlhE6ffvrpXEVrWA+hOYYwYgmQ6mGECBhLSGUuaOdEHWRy6lR3BDM+jJHyIdn8uXULFy5Eyisdbm5uLnqMfBEhx3SO9YU5adMf+eg7P+aojr/RtM07tylhZzitFi1HllVQFQNV0kgbY7/WJcvEoYfwx3uYYk8znFb5w0AN1w7O5FdV5/GnrRUTFHXZ65DRHEP4nW5iMQ/JCd7PYtXIY1Hs+RZ7HolEgiVLlrBu3boyr2O0yN7XmDRhpygKd999N4ODg6xdu5bVq1fz0ksv8aUvfWmX7pNMJgmFQgUfgUAg2FeQbE60mtaCZcm0wTudQZ5d08PSNzt4fn0fG/oihBKZcJdlWazvDhNLGficGbFW6bJR6y3uAemMdqDV2rA32RmID4xar3gUXLPdrBpahftgD46pDqZXNJEOduZab4BU1Ntmk21oioYqq7lwa1+8b1RCezmh0+zs12yVYqW9An2gI5fjlS/uWltbS0d0dpGo0ypVHKqT1EB/rlo22wrF6XQW9Ksr1kojKyLqk3EucPdy75zN3Dy9gxlDb2IhMexooDNlI2mVelVbyJoMMjhUG06bjGmBpIyoQrYsvIrBVEcSf6IPkNhQfTjXb2rmog0z+X2qidVRF3NbD5z4ZIy866i0VzCr1otNlegeNssWd/ktTcod2zby+ebnOBZ7Hvn/KShFfhXvvirqYBKFndPp5DOf+UzufzSzZ8/m+uuv58EHHySdLp7IuyP73HTTTVRUVOQ+LS0tu+eCBAKBYDeg1UzD1ngAgfj2HKW2wRgvbRhgZXuQN7cO8/qWIZ5b28vjq7p4anUPK9sDbOyPUOcdf/zUQHyA9khHblbqxuBGAnmVhaZlotVqSE6JkB5C9akke5N0benKzc7MF3fF8Nl8uDTXmK0nygqdkpn9mm094dW8ZMOAWXGXFROSJHHaaaeNPkCeqFPj2k6JOkuHS8+/FKxMGNBmRXNi4s9//jM33ngj77zzzqj9PR4PTo/ECbUR/te7mXunbeb6ObGcdy7gbCChjZ9mlDJTBYUSsgR2FZBkJMWBYqTwJAapTPTgVkxWRVy8OPV8Hjv0el4+4FKO+eL/cd4VF+VyA0f29CuHcCpcELbMhMmlssVdqT5145H/fIsVrljJQIG4y/6noBQ7XcW7FzHpodh8GhoaSCaTDAyM/h/jju5zww03EAwGc59izQsFAoFgbyScSGOraUFxV9EdTABgmhYb+yM4NIXDWvwc2OgDJJw2Baem0BNM8NqWYQzLLGhXkiWRiPOxiz/GeZ85j42DG9kY2IiEhJW0MCIGKTPFu8Pv5sTdYGIQrVJDkWUkINWbwkpY/Otf/8ocsExxN14/sXFDp2yf/eq3++ne3M1vfvObbWu2i7vXV3fkxMTcuXNZtGjRds/ONlHnrnBzxgn/zRmnnTHuOfOxLCsnIhae9BG+9rmv4XQ4c+vjoZ5RnqJHHnmkIAzYZEvx0/9u4t6ZG/lB5RbOmWJR29BI1Nda4J2LRCJs2bp1lA2xbY2qZS0Tvh5ZKKFIBjVSmBn2GPZEkIi9kjemnM6V707jixumsr52AXFbxbgzbEc+D5/PxznnnFOwrNREiXLF3Y6Kuixz587lnEXn4K53jypcgdHirtR/HrIe4B2t4t3bhopNarsT14iBw//85z+pqamhrq4OAMMweO2113J96srZZyR2ux27feKDggUCgWBXE41Gcy/MSCSC2+0ec/utQzFkhxszHmJTf4zDppl09Ac4/9NXYMaC/OXPf6Tel/HKdQcTyBUSTX5nyeOZlklbpA3ndCeSLLEhuAGHzYHPtr1vXKW9kogeYe3gWmb4Z9AR7kBxKVhpkxr79jBZwUtym7jLVkZmxl1tf9mV0yQ2G1orFY7Nn/3avbm7SNg3I+5efvHfKIrCUYe0Ytek7aOifvJjNL/GSR85icNmHIZDy9y3UjNCzzzzTP72t78VLLvrnrtynqG/P/h3XvS8yMKFHy60okjrjX8/83c+7D+WH01r58iKGFN6e+mXUvQkVLSmllEjviKRCD09PUXvQ09vby78apNtWCZIWNjTUVzpCJZl0WfBQ/1+1DmX0+8/gEoPbEisKPo8Ss2wvfzyy7ntttsAuOCCC5gxY0ZBZGy8iRLZApeeQGFrmiw7K+qy1+Fr8nHcMcfxj4f+UfQ68p8H2uhCiPzmw6X6Bo6FaZkk0vHxN9yDTJqw+93vfsdrr73GWWedhd/v58knn+S3v/0tv/nNb3K5COFwmAULFnDPPfdw6aWXlrWPQCAQ7A/EUmk29MUw4hHMRITBWIreUIKOQAJJ0bDS26tA88Vd/ncLi8F4ZjqEJmv0x/vZHNqCmTSxkha1zlo0TStoRSFLMtXOKoaTAdYPr6c70o1lmOjD6cxs1VKUEHcjZ6aW6ieWDa0Vy9PLn/3qt/u576n7ShiREXdvvr6c5uZmplTK2DWpIPx60NSDcqIOSs8InTVrVqF9mkTKnizwDIXDYR555NHRViQDmFjM9tk5yR7mVN8G5r77LqHKCAHUTGVronT0aKyoVVbUWbqBzdRptqewSxaqqdPpn8cG/2F89fmnCBkq1zQeQCKi0BsyyHhSRz+PkTNTc9ebV6TR2tpa8D2/wGCsiRL54m4govD1676FXZN2majLitODph/EP6x/lNzWSgZweTw4fI0MR00q3ZnfwZETJcptyZLFtEwGEgMYZTaf3lNMmrC7+uqrefjhh3nwwQfp7+9nxowZLF++nMMPP3y7carK0UcfnZsqUc4+AoFAsD/QNhRjKJbCjIUAC8uCDX0R2gdimInRIaVi4m44McyKvhXb8q9kDMvAZ/NhJccLHUlU2CrYGtqKKqvoQ2UWGIwQd2aqm/54P06bs6io03W9oAFxNnSa70HLioiTF5zM/APns3Xr1nGKLCzCfRsYHuxFop56PwyO00JjPMdAsRyuUjhlk2N9YU6vauMD3iRuFWJp6MVFn5nCSltUKqWrj4GSOeOyJqPKJpXoeGwmznSE1Qk7Tw9XUDnr41TMOYJ0Ok3IeBbIjLtqrJRpHzBKPg+DiYUeJ1o1OtJzV++HoN6/y0TdWOI0n9NOPoYqb2a2LJjIarjkmLByyIrTpJnEqe5dbdcmtY/dxz72MT72sY+VXO/xeFi+fPmE9hEIBIK9FcuykJ0+zPjY1fl94QSrO0O47QqSYiE7FfxOle5AgmBCx4wXFzb54i5tGXQnNqHJGtXOakzLRJIk0vr4UyayLy1FVqh1F69S9Hg8xXOWtok71deErbIZRdIm1Pk/34OWLyI+MOcDQLlFFhaaMYyq1rGuJ4Dbmd7p6texRZ3FDEeShf4Qp1WFmGLLeFMHdZVe3Y6k2fHLKlbawjIsEvGJhe4kLKocFhVqZhpEf0rl8YCfVzureaW/OjMNYslTeL3/KQgNt7W1MWPGDOq8FpLNjq2ymcG+IebP+sAOj9fakarRrLjrCpis6wng9eq0+HaNqBspTkf+Xvp8Pk499dS8PnYmncNRJC1Ms3/nRF3KTFHnqKdfHz0ndzKZ9AbFAoFA8H6hI5DAOeMIkl3bk+l1w2R9TxifQ6OhwsFwLMWL7w0QiKeo9dhQqzS0ag2batAfS2FTZCTNQquy0RXtwpV2IUmZ8BZApbsScLC6t5OQEWZadWZuarEXedZbdu211+aWjRy8LpvFBcDJJ588KgctiySnkG19YDZipmrBkiY0h16W5ZKeoXKKLDLbuZBtAyBbGKlaLNMGTOwFPJ6oc8omH/KFOb0qyAc8MTyySdSU6Uhq6NuKICTFQFYMQsE4WCqg09XdXcbZM9MgqjUDTYWQpfDckJdnh3y8EnITLTINYmRo+M9//jNOpxMUkN0KmI088/e3eEl6idNOO3VU096x2PnZr1bueVjJOjBtMMEi3HJyNYvlBuaHkWU1jKSFsfQKzLQbJqgtR4aRMRUm+nu1uxHCTiAQCHYHiorqbyBlmLjJ5Myt6gii+GqxA6GEjstlsao9wBtbh1FkiWq3nbRpEk6kaa10EYlH0Go0VI/KUGqI6dXTSOlJ1CoNR4uDtf1r+NOf/wzApz/9aZIk8ageZlfORpf6iScdhGISlWPXaGynyOB13SyedzQyBy13iKwYSiVJhdtIGxI9AYsGf8ZzUw5jeYbGK7IA8FX4cNQ40K0Uc+vr6Q9IeXl/5ZEyUiVF3QxHgoX+MKdVBWm0pZDY5p1LqeQrWEmRkFQJI5kEywDFlsl0y7unkUgEX14/NptkUmu3cJAmbsqsS7t4Nuzn+R43PbGJv7IT6QSaV8VKpUmF21BcU4gZXpYseYhFi85j5syZ4x5jrNmv5XSayIqh9LbnMRzW6B42aczmQJZBOaIOxs4NzObUNfv9mGl3Liybzbkr9zryw8hJc3wP+J5GCDuBQCDYDWjVLbjnncRLG4c48UAHa7pCdAajSGo3ireGtzpDBFIyq9qD1HntODWF4ZiOYVm0VDqRJIn+RD+KKzOLtTvaTYu/hZSRxFZjw4gZVDtqSAcyLxabbCNlZkZ1rR9ej6JBrdvPb+7+C2ZikG9ccyWaNkZuVxmD18fjnEXn8OQLTxSIoYYKGIhkZruWI+7G8wyNVWSRvY5jFh6Dbum5l2+9L1XQ526s2wAZcTqQ7C+4Dpds8CFfhP8a4Z3rzPPOqaqay4/LijrJkjANE9Azkm+EuBsYGMDncePUw8xwJDGQMCqauOfdOP+xqlhvOtGHjV0WRs7PgXzq6Wf43JXTxzyG4lZys1+LVY3mP4ds6DdfTBUTQ/Zts36Libtio77KFXVjMbJQIuOpM8sWd7ui4GNPIYSdQCAQ7GIiyTS2upmAxPPvDqCjMBxNkaAXR6ONRPcwG/pj9MVMPHYFryOjNGq8GiAhIaGbOt3RbqyUhREziOgRBhODhOJBZIdMeriw9UT+4PVsWNZIG7k+XoGoRa2/uL3lDl4fC0mTsFfbRnm4sgn83cPmuOKu3H5ixYosMkbAh8/+MA0tDQUvX1mWcoKmJwgtmlXSU5QVQ6qsoQdSzLInWVgZ5LTKEPW2NBJWUe8cZDxEmzZtyok6K21tE3UZLDNf3Fl4pSRVahJ3uBPdUcETQxU8H/Bx3Ge/zebqtbS98Qp6V6hA1H3wg/N5880VjEfJMHJegUvM8NDW3lHyGLmWJrYKKuwVRZst5/PnP/8Zr9fLaaedxty5c0uKoZEFFWN57naLqNtGRsxtF3eeEkXf+5KoAyHsBAKBYJfzbl8U2eUj2bGapgoHr28ZxuOKE9B7MHUTW5WETdVRJRdup8U7A+8QT8cxMdEkjVpXLRYWET2SmQhhgSqrdEW6CMVDmPHtYmHkyxe259MZGLk+XoEYqFqRl5cEA8mBsgavl6JQDI3ORStH3GXDfeX2ExvVpmSbx7GxqbHEyzfTCkWydH726wcxol1c97VrCryY2etwGwYfirVxxPQ2DvXEcW/zzvWkHSTS2++9pqpU19QU9JzLF3Uj5+YC2KwkNXICp00ikpZ4I+wm1Hgy6QMX8sOnfg0SzEoGaWhp4NJpl7L4Z4sL9p8xY+a4wm7cgo88cdc9tL0VSj4jJ0pYlsWzzz475nkhk+e3ZMkSzlt0HpUtlSXFUDnibneKuiz54i5t334PrrvuOjRN2+dEHQhhJxAIBDuMaVqjBMpgJMmGvghWOoitQcPpCuKyVDYNd1HptmFEDNRKlYjZQ6PLx5qBNQzGB3HZXMiSTMyIZUKpkoIma7n3rUfzEEgESKVTmImMuBj58i2FlQzgdzHq5ZUVQ+kyB68XI19EVNuqS7YCKSbusoz0OJbbTyzXpiSvT93YHkeLOh9Fw7KSBofUpzjZ3seHHcPMae9m0BtlKK3Ss807N2PGNDZt2gRAU1MTLperYP5o2kwXFXUKFlVaGq9ikrYkOpM2nh5oYFlqOhtCSS760NFM0XyjwuHFCleam5vHvCdlt2bZJu40uzuXf2iz2fj2t79NMBlkIDpQEA4vZ5bvdiPgn6/8k7OnnEW9u6Hk8xhL3O0qUZf9z8JYfx9ZcTcQBMnux9o2dWVfFHUghJ1AIBDsELph8s+1nUypcHNIUyWyLJHQDd7uDNITHsbeaKB47Lz03os0NjYhSTaiMS8odsykzobARpKkGI4PU+uuRZG2lwhWUIFu6ljp7W9lTdZwyk6ccmayRKlxTqXwuyVUTdr+8koFcmIof6JEfl+5MXPyGC0i7v793aO2Wb9+PQcffDAwWtxVu62iHscJkSfqyvE4yhIFYdlZUoTpQ6/xyzltHKjFcWIQTssE7dVsSZZureJ0Ogv8XJIikbbSOVEnYVGhGlTbLEzTZFBXeWa4gheCXt6MuNAtGcmewlPZgq+6BdPSR4nTYoUr+flro9ZNoN8egM9t56CZNTz/78w4ONO0SobDy53lm30e8WSM1KCO3TfO8ygi7pBTOy3qRv5nYTwq3TJpffvEkJHV4fuKqAMh7AQCgWCHeK9vmH9ueBu3zU08fSBz6/28smmQP//rWZ5/dWkmD24ozZN/eRKv18spp56GrWYGqq8J2ZbxAhQTdVk0WUOXCl/sHs2Djj7uOKdS5L+8FJ8GUmD8iRIlKFY1Wuzl/8gjj6Cqaq61Rr642zgQRfGoGJH0DvcTyxd15XocJUwOZgNnDD3MAVtW4TGHCdqiDCQVugwbIDHU3jlqv+yc1lHH2xZ+VSUVh2VQbU9jlyxChkKb/xB+v2KA/4Q8hI3C52wlAyw4/BSGIiY9DJUlTvM9hE6nk/i2nngTFXUAp556Kk67nBO6GweiOD0hqhyjw+FltZkZIbKTsfLagOSLu7bBFJK9D49t50Tdjvxnwe+Wcjmpm4aGcLv1fU7UgRB2AoFAMGGSaYN/bdhALB3AlAM8/o7Bhr5mnnhlGc8t+yuWns7kxm0jHA6z9KEl/PfZH0Vxp8FspMk5gwqPnQk1eKOwFchY45xK4XNZKLYQsrOS1GAaSx+e8DGKVY2OxdNPP12QD3fdddfhcsXo7o1hGXUY0dIJ/KUwLZP+vIkS5Yi6KjXNvMHl/Hb2Fg5wJmgMBghaNnrlGnriKbC2588Vm/7Q09s7alna1NFU8JOiLjWAqaXZkrDz1Dbv3IVnfAVv1UZ46ikoEso87KBptAWHCIQs0lHPuM/jrrvuyv2cL+o+cs5HsAyLV/75Crq1/T8ETqcTy7JIJBK5ZflNe3VdByMJVi/BRAxVrcTr9WIYhdc/bpuZEaLO0q2yew5CRtxVelP09g5ByklTQ+UOibpy0xNKYaUCKD6NQNSiah8UdSCEnUAgEEyYt7t6WdvXRUOFC4dqozfazYqeEMtX/A0jmioIoWaRNIkXVy7DjMYx9Vr6wzIOO9jHab2Rz842ic2KIaQAqcE0klqFZJ9YXt14hRLFCIVCdHRsF2/BZJC4GWVqtRszpebCgBO5jr5YH3oZuYGSZdAYeo9vtHRzUkWYmR0D9LniDBoqkuZHVlRUQ0NSHFhGokDcjYllouoRnKkQkpJkIKnwds1x3PjqW7wVcWWmQWxjZKHHokWLMm1CtvUNtDtMWpWqsp7HSK9o9nkYusExBx3D/Jnzc+fJNuhNpVKjlmVDupqm8eWvf5lAMoBT9hCLuekJWFS7C+2QJImFCxfyyCOPFLnJo0Wdz+ejtbW1vHtJJqeuP9FLvd+GmfLTG4DGytLVy8WYaHrCSLIeYKQArZU+onGVYaX8Pnd7C0LYCQQCwQSIJdP8a8N7ICXx2asBiQZPFRu2biDUFSgqdLIv31gotk0MdWFTx2/1kM9YTWLLIZsztF0MDSPZLWRHNcFYecfID7/W2GvKEnVZsoJkZF+0bBiwNwTN1aOLUYpdRzahvdZZfNwZgDs5TOvQKmYMvIY/1kWwepigoTBsr6VdjyJpMlWygl2xY0kWWGYZ4i4zDaJKM6iIdxNT7GypmMdtK9pYHvJwxalnsSKyseie+fNoW1paihZKlNOaJp/88Otrz73GgoMWFJwn26C32LIsI6tGk3aL7mGT3hCMrJadM2dOESNGizrIhHnHygfMZ2ShBK5MU+uJ/H3saHpClpEe4DqvnUhKGrfPnW6AJGVyN/cWhLATCATvC8KpMH2xPqb6pqLKo//pMy0z00FujJfR1qEgz727kY2D/bRWe8mGUTVZw4yZY4q6wrClRb0PBqPSmC8v08wIDMWtsKFzA3OmzsGjlB/e2m7E9okS+WJoeysUqaAasOghRoRfJxom83g8o3KfsmFAI9pFKk1uQkUpRlYpjqwaVSWL5uBaZgdW0RxYjT0dxZBUoqqXjYnMtXkBSZPBBLu8rVmwBJaRQFIcRcWdJmVGe7kVk7gh817KyRt1J9FfdxSGs4l/PnLLhO5Fsb6BuqmP35omj5G/V7ql09bWxpQpU8q2o1grkGwOZPuAMf60Dgk89R5SZrLAU1c4m3Vsila/SpTd5y57HTuTnlDKAzyyz53fJZHUM152SZJIGxaBmEWd36DCtffIqb3HEoFAINhNBBIBlncvpyfaQ391Px+s+2CuYMCyLHqiPawbWoddsTO/fj5O1Vmw/2AswnPvrufVti5CqSi1Xg3VkvnhD38IZHLGiuUTjZXQnkkYl0q+vNatW8dTTz2VE0P/evJfvCK/wsKFCyd28eO00Mi0QrFy1YDFxN2OhF/z8fl8+Op8pXOfjGTBhIqRYUDY7nGMp+L86c4/YelWbsZtvaazsDLEGVUBjthwNzImSdVFwFEPkoy5reBA+v/s/XmAXFd95o1/zl1qX3vvVqu1WpJteTc2tsGxLZAhiQnEngTCO5OQkGUmk8UzyUtIyGSSIeGFzJsfM1nmzTJMJsmEAAYczBLbyAsYjPGGNyzZsiy1eq+ufb3r+f1RXdW1d7Uk25Kohz+wuqtu31OnzjnP/S7Po4DpmuCCa7nVUEvjZ9FA7oRTJqZaRDUHCSyZOncl4nzbjHFYC/GBiVsYCY3g9CnNUscGuoFdpWkaL9Hle9V35yq99d28umAiCqie7mnyte/VD7/rh/nc//oc0pIdvVl7oZekSb8ixmeiPKH2sDAVmeLnf+nDuBJSpervIj5BPATJnMtqTjAUUkgXJbEgZEuS8aggHq+g9Dnm1wMDYjfAAAOct5BSslJa4fGlx1nMJ9HkKM8nXsRwDLZHtlOxKyRKCV5YniVdAEWzKVpFrpm8hoAewLBMnpo/yddfepmFbJHRsIc90SEUobRprbUWl3c6fFuLz7sdXocPH+auu+6qk7raoZUn37nGqQu6RYZaEQ1QTwO2kjvDMTrq1PXjEVrDW9/+VnJWrufh29gt25YG7BBx1IRka+4IH5mZ5y3RAlHVwZSCoh7F1doL3oVSjdQJIaqkriMkQYoM6wLNC1lT8PV0hEOZCI/lQ1h+vT4fS8eXGNk/0vdnUBtHN93AVistrdiuqwa9Hxb6bVbYSLQXqvPRmiZvHYfQYdS3HgFuTfP2Qj86dRuRu36dSrqhLQIsPSgC9m2p/p1CxWV2VWJa1UFPDyvsmVRZybnMpyRhn2B61GBlLRp8tmBA7AYYYIDzClJKUpUUiXKCk/mTJMtJVjMlfu/3/gHFP8av/tL7KZZP8P2VE+RLgkxeI52PYpoqIxHJd50F5gt3Y9qwnAown3Txahp7x+NoSrssSQ2NHqbdDt9Oxeeth9dETDRF6k63UaIfCQ2Px8Pv/Oa/J5Ex+Zu//zw12mM4Bonyevq1Uaeuk1drKBRqihpFIhHe+va3MrRliKAS3HAcHdOAQqLHdOaX5rls52XEKyn+r7FV3jmU5crj/5vMUJaMraJsuZCAotKJsrnSradfPUp7flN1LSY9JgFFUnIVniv4OFTazrfKkyxmU+AYbfNx6NAhLr744p7jATBNs6oN2ECGGnUDu6FVV00amZ6kLhwOMzMz07GbtxH9ivYCHdLkGr/9O7/NQm6Bf/zM/zllqZzNiA93I3eN5LQfp5JWdBIfThddwn6FrcPKWq2nwkjY5XjCZdso7JpQ8WiC4bBgPCoxnDIJ8ziaenZRqbPrbgYYYIABThGO63Aid4IXky+yXFpGCIFf8yPtMKl0BNU/hlNJkiurGM4kQoBhSzQFJiKQKkhyZUmq4iFRTOB1pzBMP1vjKgFPf1vlvn37ePcd7+bBxx9saJRYl5fYtWtXx/c1Hl7PvrRMCee0SV2/XaONaNTxWskbOHoKTWg9deoa8cEPfpBPfvKTQLX7cmjLEDkzt6nDtykNGJpC0RP4PA7WA19g/Jl/4KYJwYGpVSquoKBHOFbJATDUhRy40sV0jPX061pdpILEb+XwO2UcBEctD19PR/hGNsxL5aoMjRpUUINTIJdRA3bTfOTz+f5r2loaDPolQ43zITWBFix0lZg5cODAhtGyzYr2Ak1p8oWMi+JZ3fT3qhGn4ijRSu4CgQJldz3i2K9TSQ3dHCUME3aMiqYGnlhQ4bJAc+2tEAK/r8xS7jh+1Y9f97f9jTcSA2I3wAADnPPIm3meWn6Kby98m7AnzK7YLjyKj4WU5JVlh0LFwilV/TxHI6Ie1YkH1zdsXXM4vJTFsB18yi40v87YkNhU7YzhGES2RHj3xLv533/+v0E2y0v0OoBqh9fhV9Po8S1Y6Xmcornpz6LfrtFukEYGqQlm0znMQorvPfRQ3zV1jYdfdDxaJ3Wth289itUFx4+9hFOaZ9/UED8UKPF29TgTmoUiJCsplaztQSLY2SH61ghXuhiOgRDKGqmTeJwy23wGKiBReHn0Wl6JXsJ/OHQ3lmwkGVVvWX1kGjXQeT76qWk7VRHl+l2szYdneBS3rGFlEh3no2PHagNOx+HDqwvGY3B4KQOKZNfQ5r9XcHo2YbX1cTRRYGW1xPaRDhFHoZIughKaxi21aw7C+voomBYeZxxL9+BVwbIlmiqIh9rXeythLlklXs29il/1MxWcIllJ9j2O1wMDYjfAAAOck8gaWXJGjryV58XkizyTeIY98T1MhbaQLUleXnVYSLn4PYKxSPPG3FqE7UqXrJUgHLYIGWN4VY2h4OZJXe3Qinvj9cN3M3VHeStHKFLEKVVAjIO6UBWP7RMbdY32A6FXI0Pl3CKPPfISrrn5Y+KUIkNr0KwS7nc/y59csMJl/hcICSg5CguG1kK8eqOR1PklTHosAoqL1zF4tBDkvnSEK2/5DezAMJZlYckvdRiHglBXcEpjHedjw5q2lkaJzZKhI0eO1OfDLWs4ZgThseo1d9dddx2PPvrohtdp7Bo9VYePrJUkHLaQxhiZoqBVCmUjnAnv17yVQ/dliBGnVApieNd17oQeRtGDhLzgllcQevvc1NZHuugQ1saYHvGylHHx6lAwJGG/QsTfe602krptkW24/eoevo4YELsBBhjgnMN8YZ7vLHyHvJknY2TIW3kuHLoYrFGeftUhVZA4rmQoJNA1Qa9MTSMZ2hoZB9ez5mVald7YSFcNqodWqpKqH1qOvfn0aa1m6IKtu3nUeJSSG16vM+uD3HXytuzUKLHROGo1XM998xFcQ+3ZLdsJpxYZkowUZ9mVfYHJ+W9x62RVzDhpqizZGkL1g+KCU9ngOlW40sW0y4ScCiHXxBUKxyyN+9JRtr/5l/jI1/8JEFyoR+imDx0eDWMoBk7BxinOoQanmuZjw5q2Ho0SfX0iUnLo4UMNNXUJhMdqmo/nn3tuw+ucbtdoY+NKbX2cXLU2lkJpwJkgdbX1MeSLEQ6Hm3TucCWKHsRKfZ9LZyRucQltqLn+sbbOkwWHscAIF0/7GY8KhKimd5HtadhWtJI6VVFxnQGxG2CAAQZoguEYzOfn0RSNEf8IAb1ai2W5FgoKakvDQqqS4onFJyiaBj7Vj6rk2R3dSz43xKsJG0VAxC/waBsfHh1rbVSajOo3IndCFyTKCfwef/3QctjcAdrapXjrrQe5667Pt5GJ7jexfvh287aspT5//dd/veMlWhslarZULvRN7jZr5xRVbW6M5XlnPMtNR/4C3TVI2w4nbA+WVZOSk+0ac90gJZpdQjfTRADLE+WV4cs5Fr2EOw99CVMq3OmfYiMbNzWosuOiHbzwxAt1MlTrEK3NR8+atoaaOiNpnlLa8pXjr2DolaaauprOXW0+8oVMz2ucrqh1q1RObX00SaFsMLQzSeoaGz4aa+48qsQ1czjFeVQFXCMDro3lSHR9fZ2XLJOoPs4lW/1VQgjsnlDJlyUVi45p2Bo6kbqzFQNiN8AAA7yuKFklTMfExSVjZDicPMxKaQWAkCdEzBvDcAxMx0QIQVAPEvPGiHljBPUgz68+z1Ihy/HFACUnw67RCZKlOLPJqoCo39Nf2rNbATU0S2/0Ine1LkVd0fs6tGqCwwCzs7Ps3LmTnJlrO7T27dvHHXfczr333kfJWY/cRYJebrnllubO2k6Hbw80eo3W8MKRFxjaNoTeQaeulUx0I3f92jkJJBPFV/kPW5a4OZZjWLdxAUMdJ6kFqUgDy6o0mz9Itye58wiXkJFCdw1KQmEhuI3F8euZG7qUsqda32fKL/f8XBrHoYbUJlK3dhNN5G77zj1As0yJZVltjRJ333V3X3+3EYZjsFhc7Ngosan5aHD42Cw6SeXU0CiFstLBoaJxHK8FqYP1mrvFdFX70CnMwVqEWppZXCtPyQCfd32de+Q4W4e8jEfX13LIJ7hgUmU543ZNw55LpA4GxG6AAQZ4nZA1sryafZWXUi+xUl5BIAjoAfyan63hrQghKJgFVsuraEqVLLnSJV1Js1RcwnEdVEXFdm1yhQBzmSJD/iHmlkMI4TIcEni05o3ZsqyORfq9SF0NG5G7xrTlqH90w0OrJjhcw6c//WkiYxEuv/5yvnX/t3CKDh/60IfQ9WpycN1f9L+iBqc48MM/xRUXTiIaDN5nT852PXy7oZPX6H3fvpeblJu5bPdlHcumNiIT/dg5+aw87xlO88NDGa4/9j/Jj6XI2QqzFQ8Ogq2i2s4QDoRJKSlstyXF2ULuhFPGb+XZ6TNwEBS1EM9ELufV2H4YvhRlE4fvkSNHmsbRjZzeccft9UjqUha26s1epoePHO6rUcLj8TRp1jWiRobC/nBXMei+56PR4WMT6EsqZ00KxbJFx7Tsa0nqalAUQSQgcNxqXd06JG5pmZIpsdfWeUQbxxEeto0qbQ9pEzGFsWjnmtpzjdTBgNgNMMAArwOOpo/yvcT3WC2vkjWzxPQYM5EZPKqnaaOMeCNEvJGu13Fch8X8Kq8kSoyFokzH2l/bSOZqzgSN6FSL1g3dyF1r2rIfUteq+6YGVSqiUid1nVD1+KxGirZMjfL48yd56ltfrf5SwJcOfakvnbpuaNRF+86h73DZrsvqv2sVU+5EJsLhMNcfuJ4HH32wo52TkA5j+WNsX32aranv8Y6ti9gSyuoEr5Q91KVHdIWKUSESiKAKhZGREZaWltpvWDoEZZFhL6hUnSO+moryUCHKzuvej+6LbJpESCk5dOhQX7qBW7dupTYfrV6/juPw0BMPnXKjBDSToUu2X8LDoYeb5qDpvo0MgUCQ0tp81HAmGiVWSiu4isuv/dyv9/5eOQZjUdnmUPF6kLoaigbsmfLyz1/4JwAqlWo0V5ppsmaKkMdiPDBOtqCzY0wQD3W+l/OF1MGA2A0wwABnCFJKTNekYlfwqJ66Ldfx7HEeX34cx3WwXZtR3+imNknXlZRMCHohWUny8moa1R1jKrp5T8h+atFa0Uru4mGTRGW5Y9qy8/27TZE62Dgy1B5plGSWXuKRhx8HNQJaAT3sNpGII0eOsH///j4+hCo6eY3Ozc3Vf99JTLmR3F151dVcc/1eUqVU2zjGdIuLlr/BnvRTxEuLqNKmovg4sRad26n6aCR1KLC6lCCtpBkbHW3rNvWsebWGdNCCUR5fsrivvJOh/T/N3zz4v9DjKru0QFcS0ZYubcDs7Cwlt7RJ3cBmr9/xGBw5+Rxls3RG9d06zUEjbnrLlXz5vm+i+IbJFCUe/5mz1+p7fWjr9YfLORiNGSQqrw+pM6yqRMlEvOVvCNCHKmiaie5MkC3ojEYUto32T8zOVVIHA2I3wAADnAYylQzLpWXSlTTJShLDNjBdE6/qZWdsJ2FPmKeWnsJyLPJWnoAW6HuTtB3Jal4yn3RZyblEwjk8gQRWeYKhQGjz3oybrEVrRI3czSZNlpdTjMc8DPvjG5I6gLm5uaaoy6k6Sjz4wCGcYgE1NIV3bAbpLGKlinUSUXNC6EdapR+v0b1793LHHXdw7733dozcje96BwvZIuPBavq1ZvH1uzPz3BAtsPNkClfRKOsRbNWLKyUOCQBKxSKwTuqk5SJdsF2bhcVFJiYmUJDENYeo5uBIAcNbmd1yA69GL+I3v/GPoKq82w3gGZ/GLS71lQ7vhEQ+cUrzUfP6Xci4HF7KkCmeWVIHG2vT7d69G3nPPbjAfLaIbqzPx2ZxKqSujrW0bNG0SC7nGI+99qROSkmqIJkZUYgG1r/zjnTwTngRHpe9o8Pkyh62jylMDyvoan97xrlM6mBA7AYYYIBTRMkq8e2Fb7NUWsKjePBpvmqkTvdTsSs8tfQUuqpjOiZlp9x1k3RdyYvzDkLASFjB7xGkCi4LaUm26KIqIJU83zteYXpoAscKMRm1+ehHPwHQVJfWFY3eln3WorVBMRHeFTD9uGYM9P5kDhrJ0unYhOXzeRCg6AlQJnDLY0h3HjDqv//DP/zDDT+PXrZU6XS66bXrdX5/DMAdd9zBXXfdhaLlEVoOaQ0RKRU6WnylfWNd69xWk8k2UleFJKK6BHNzXDUdp6wG+NyLWR7KRLjx4O+ieINrETeBUEwU7wq4XlxrFOTmTdizRhbpk6chBSJRPKugSLxiBul6qM1Hv9hs2rI2B41onA9pb/67fVqkbg1CMVE9CSiHqusjIDZqPm5DjdSF9Rh+tb3MQkpZf3DJliDsF+wYV+sPeY7rMJufRXgFxqLB7jEvqq4R8vV/I+c6qYMBsRtggAFOAVJKvp/8PkvFpY6bn1/zE/fFSZfTZIxMz0jdUkZyMlk92WdXXTyqoGJJfB4YDguKdo6ikeHCqRiZfIhCRZLfjD1lS5fiqRxatcM35PGwZSLOcoZ2o/ouqKUVT9f7dX0cEnN5DsUz2VEKpTEl29iFC71JHcAjjzzS9merdX5VbN26FTWo4g8J3sosF2YPMZk9jL1llYojO1p8uVJy9OjRpmu6wm0idT7FZViz8SmSgqvwWNaPte1tFHbcwEfv/R8A3KB4qN1JbRx+j4axMosaWDeq70d3ENa7RndP7+bbyrfJ07mWrRtqtZq2NNk3Pk4qoBEe2UV+9ZW+RaVPpRatWufXPA41pLIlGkQVQVazNsIb61t38IyQurX5CHg0tkar62MzOpBQJXXpSgZNxjGMEJYhCfsh4BVIKUkWJJYNuioJ+qp7xKWTGkHvOqk7kTuBq7r87f/7t3XZpM3gfCB1MCB2AwwwwBpKVomcmWPIN7Shl+V8YZ4jqSOMB8e7bn4lq8RCaaEnqSubkmMrDh4V4iEFx5VYTtUjUwjRlpaJ+yFddFnNun0dXqdr5wSdD9/JuGw2qu+B6elpImMRKqJyBkjd+jgcq1lXrUYm7r77bjSturU31vZtROr6gZ5/lQ9MrfJ2b4rLTi6iIMkrQV61o0jHYscGFl+wnn5VLIe4ahP2uFhScNLwcG86yjezYV6teHjPpbvYo69HbWo2ZI3jGPGOgN1qVL8xmWjsGo374tx6661tUbCe6FCrORmTXHXlpXzzW+W+RKXPiBNDi26grivY1nqDy0Y4E6TOdMym7nCvR2UyLvvWgYQqqUtVMtjGECORENtHVUzb5eVFFyGgaEi8mmDPpMJqTrJacJmKK0zGm0ld2SmzI7LjB5rUwYDYDTDAAMBScYmnlp9itbJKSAsxGZpk39A+4r44UBULPpI6Qskq4VW9zBfm6xpzndBtkzQsyXzKxasJokHByVWHXFkysaYrpSoCde1861ZrEw/2eXidpp0TdD98m4zqG7oBOyFv5bnqLVfxjXu/cVqkLhAJkFvINYyjWVetkUx85StfoVwur1/iNEid7lQ4EMty61ieA8f+Cju8SskWFDxx5NoDwLatYUxbspEIv6ILIppNTFoIDyTX3CAezoZ5uhDEbkindrLrah1HnQw1GNVvRCYylUydDGWXswwHh9d0A9vrCTuiS62mogiuv2IXqqry3cef7hm5a3UqORVS1003MBYUuJVkvaFiNNb5/WcqUrdSToCMYuWyTeujX5Hv2joXdpxtQ2EumVEJeAWuFLguvLxU1Ze7aKvKUEhh67AkVVAI+qouEQNS144BsRtggPMcBbNA3syjiKqLg5QSicSVLpZrkTfzPL/6PJZjMeYb40j6CM8mnmWhsMA1k9cw7Bvm6ZWneSn1Erqq40gHTWhMBCc6/r1um2SuLDky75DIVtNwPl1gOZJ4QLQV/G9UQL3h4XWadk6wcUSlUaS1WxpQDaokS8k6qQuFQk01d5FIpF1wuMM4hA5vveKtfPlEq8huZ3J3+qROEskc4+SX/oyD8Rw/stMGAVKZ4mipKlOyW9HrqVFdrd6saUmEoiNbrMx8isuI18GnuuRNlSeNOF9b8fOtXIic034MdbLraowMdRpHP2Ti6Ref5pGnHqmToU9/+tOEw2FuvfXWrvWEjegl2gvVv3ftpduZnJzi05+5C6e4wB3vua3pOp2cSjaLjXQDaw0umRJoukuoJZB6Zkidgmd0hGIliJUpoXiHm37faT5sF1wJqgBVqXq/ZowMATUGhNgxphBYS60qQrBrQsXrEUT8gliw+jkpimAkcnZF6opWcdPveS0xIHYDDHAeY7m4zHeXvkuqkkIRCgKBXDsRXenWSV7UG2XYN8yJ3Ak0VeNNE28iZ+V4ZO4R4r44C8UFtoS3bHgAFMwiT8/P4VFC7JneUt8klzMuRxYcskWLv/3//ivg8mv/4f/G49XxeTZH6mpoPbziwVpN1/rhO+IdfU1IXR1O9zRgp8P3gx/8IJ/85CcBeN/73sfOnTs39BqtRRwv3nsxvjt8fPnLX65rda19El0jd5sldWHV4Yeied4xlOX6w3+GOZ6kiMK848G0BTs8EWC143t1FVwXUD0IQHFtAk4R3S5h+hzmHC//shzhoWSIS99+O1870t0JotWuS+iCVSPRNo5OQr/dyN3TLz7N/Y/c3xbhyufz3HXXXdxxxx3s2rWr/vPWWrbWCHC3taAogsmYAMdEDU4xNrl+nc06ldRkWhrlbxrTr626gY2QRoZYANIFie1dn/jN6Dh2g+EY6ONTuOUM120Pc0/q+2ijV1I2qxZeNXh1wVhU8PKiS7YkGI0IVLUaictU8hTsAtPRGKYRZmZUqRO2GhRFMDPSmWidLaQuUU5QsAobv/B1xIDYDTDAeQgpJXOFOR5ffJySXWJreGudxIm1VjUhRP1g6bRJBj1BskaWRDnBTHgGTem9XaSKRR45OsenP/MN7LzN7/3Hn2bvVpWFVK1WRjIWAdYSqD5doOunRurq42w4vMAlGqBJMX+jWsFO2HTtU4c0YKNIbOPh20hWZmZmukqTdKsN3LdvH6qq8pnPfKb1k2gjd0LpHeGq3xOSS4NlbonluCWWY2TN4uvkqkERL0JTkLZEOhsTZF11iVEk7ncJVpKY3ihPx/fypy8d58klL/ZaIO/HL7ig53UaZT5qZEjrUzewU6Qoa2aaInWdcN999/GLv/iLnS+6RrJR2Fi0lyohqVtuZQWo3qb5OFVpln5t22qIBQWaLljNUq1JNTOb1nFsheEYHE+nwChTfvV7TMUU3EoKt7hArgSRluqMsgl7t6jMDKuE/QJdg6VCgrlckqHyGEYlTNAr2D6q9i1hdLaQupXSSrWpSm8vG3gjMSB2AwxwFqJYLNZrjAqFAsFgdbeczc2yUFzgTeNvatuILNfiePY4iXKCTCVD1siCgC2hLVUC0WXP7LVJRr3RDQmWaUtOJEs8OZugUg5iriYQqBxbgZLtkCq4BL2CkE/BstpvohaNUIMqP/HTP8FIcGRTivm1wyuVd1ktpdC0zadfa/cgdMFP/cJPbTpNViMTJ1ct/vivPo1QV05LJLaRnLaOY2Zmpss718mdFtmC4llBmkZXMjSsWfxQLM8741ku8FfwKZKco9RFhIUqEJrYmNRJie4a+Kw8imuRweaBzBDWzp/iWHQSx+vw3aV/bBrHyZMn2y7TKfXZaNs24h3puzawkdwdTRTI5I5SWCn0nI9cLtck0FzHKUvlVOdD12TbfLwW6dduaKxJVSOnpuNYg+EYzOVWcF0PlZMvIo1c/XdOYR6PVm2Iqvk1247EdmHHmMpErDrmldIKBXeZvWPjDPuGSOQkiqBvSZKzjdSNB8aR8hQ6kV5DDIjdAAOcpfBu8aIEFNw1ka+KXeHZxLMkK0kmAhNsj26vv3a5uMzzq89zMn8SXdXxql4i3kjX5oYaTneTXEi5vLhQ5vuLGRTp56LJEDgmEhgOQ7rgEvWLtnRrK1q9LTeLaABWSylSRZfpyKmlXzebJmuFVxcE/DnUgA+nNIZT7EASNkAtTWb1qA1slB9ph8Q1FwmN7cQ0JjHzs01kSEVyZbjI22I5bozmiWkOthQkLZWiq1Bj//2QOsW1CdoFdKeCrXpIB6Z4OX4FH/rmN1i0PNx+8wy5imDaE2obR6cO1NbU52Zt21rh1QWBQIGV1RKFXBCnuHGfaKuP7ulL5UhiQRM1aIPbPh/9olsEuF9EAhLVk0Pxx/HIU9NxNByDpeIylUqAiyfCfD4/3/R7aWaZiMFCVuLTq9HpdFEyGlYYXUuxNpKhscAYABOx/jXmzkZSF/fGWSmtbPym1xGbJnZHjx5leHiYeDz+WtzPAAMMAKQqKQK7Agif4ET+BPtD+3kl8worpRV8mo/nV59nPDiOT/VxJHWEZxLPYLkWW0Jb0NUNxHrXcLqb5HLG5XsnyqTNVXaMq0grymreBdULjoGuCsaiGx/GZ8LbMllK4vWZbPeOkyuITel4QXNk6FTTZFkjS9nNYqXnQYz3JYXShAYJjVF/f+S0tRlD6IIbf+SteISXB+5/ATVQvYcpNc9NsTzviGfZ7jPQhSRrqxyveHBbQrm9SJ2QLnHNJq45RMwkJW+cI+PXc3LoMlZC27Fsh0XrO+gxHZ+3wlBgiu8fXjil+UhVUn3btnVCdT4ybB+JcbxAw3x0v1hjJ+6ZkMoRuiBlJnCLS7jWaH0+NjuObjZhnWoMW1GLACMymEmbUsVDurhek9oNtlN1dogGBCgmy6VlKhUf24fi7B5z6fQ5bhkSlCyFpYxLxA9SwtYRBVURHUndZnA2krqxwBiWY238ptcZmyZ2X/rSl/jt3/5t3v3ud/NzP/dzHDhwYIMnyAEGGGAzsFyLF1IvoPgV3IrLs6vPEgqEOJw6TNwXJ+qN8mziWabD0wgEz6w+Q1gPMx4c7/tvtG6SiqPwrtvfBcBnP/tZfD5fz/dnii7PniyTMlYZDqnVjVoK5pLupghNr0OrL3TQE1Ncs6cUSk0PDaquFa7inlJkqFH89/Dxw4THwkQ9UZx8CdT1erceSihN42iU0FDc/u6hsRmjFnHcsXUHU5Ep4iJA9okHuHEiwdW+JaKKjSEFRCc4tpLqfBsdSZ0kqFS9WuNGgqyAr2ciDF/z06wMX4ytrn9XXGk1pS2DXg//9MTD9fnoh9w1do3Gvb1t22ZnZ9m5c+eGXdWRPWEefTRKCbqSu0gkwvT09NpNnL5UTnNtoAlygX/zi7+JK1Vc+pvf2jiinv7Tr42+uLXuV1dx67WB6aJbr0ntRu5sR5LISYZCguWcia2uoEgvQ75h9kzq+Dxmx/eFfILLd6i8sgQnky4TsWpDxPlK6s5WbJrY/eqv/iq7d+/mU5/6FD/yIz/C5OQkP/MzP8MHPvABtm/f/hrc4gADnP+wHIuSXUIVKnOFOWbzs1irFtKRFO0iL6y+QN7Msy2yjUQ5QcWp8NTKU6hCJe6LE/G02+90Q6dNsuJUNn7jGoqG5JnZMgu5JKMRdT1tKWA8Qr0b0LCaO+RakTWyFN3ipg6tJnQgQx/92Eerv/LGUHzDZEu9L3GqkaHDhw/XxX/VoMrXHvoaPunjlutvqb5grVtWDU6xsoFDRScJDcvtLwpQIzSN3a8X4HLB/H38uPkEoQtWSKczZBwvxwwNKSU7QzHoQOxaSZ0uXIY0h5DmUnYUDpd8vHTpu/jtb36LZUvnQ/FLm6LDrbWBXtXL7Ows+dRcfT42Inet6XDH7v29aJUrgc4NOD6Pwi3X7+fLhx7vGrk7ePBgNUhxhqRy2msDJeMRSBYFi2mXybiCV++ehmwcR0DZPJHpJmlSJXPdyZ3tSBJ5yVRcYXrUYNVcIpcNMOSLs2NUZTQiMHpoL/s9Vc25kUhVumS1nBiQutcZmyZ2mqbxrne9i3e9612srKzwd3/3d/yv//W/+C//5b9wyy238LM/+7P8+I//+IZP/AMMMEAVeTPPY4uPsVpeRREKlmMR0kP1iMlkYJJEOcFYYIzE2ia5M7oTQVUgeDMbXa9NUvGPofhGKBqSbsvXsCTfO1HiWDLFWFRhPNhci9bYDbiUha267Hh41eycRoIjp3xo9SJD61Io7WnZWuH+ZiJDjTh8+HC9RqzRJixXzDXr0a2RO8sWXaOYncjQZiF0QXRIcJ0nw4FQkncc+VO8Thlb9VLwDnGslEeoGqge6ELgda+Ggwu2S0zYxHwOElg2db6QjPNwJswLJT93/ugNLFvf7TiOldJKW21gLU1cm49e5K7VwUARCg7rxK7VlqyGRrmSyR2TXbuqL7l4DwAPfPv5pshdJBLh4MGD7Nu3D8M0zohUTrcIsKIIJmKCpQw9yV0rOa364/aPjXTqOpE7w5LkylWR6YmowrZxg4XycfZM+ikFh7FdhW1jKkIIfD4fX/rSl+rXa/xvqGrQTcQGkbo3CqfVPDE2NsZv/MZv8I53vINf/uVf5tChQzzwwAMMDw/z4Q9/mDvvvLNrO/8AA5zvcFyHsl0moAe6pvfSlTSPLT7GUmmp3l0lPAJhr68bTdHYHt3+mm6SZVOixfag+Ed45oRk7xaXybhoEni1HMkzsyVeWkkxGhFMBLs1GFS7AT1a58OrtVHiVA6tfshQVQpFtpGJu+66a9ORofo1pWyK1G3o/eoYjEXlukNFA0/op1Fig7shVniVf78jwQF/hjFRTY/ZyghlTwyEwF3r1pNOBaH6EKqvLTUsVBiNBdByq2i6JOeoPJCJcCgT4bFckJLb+yBsJBGttYGNNWu9yF2rTl2n79WDDz7Y8z7u/+b93DZ5W71coRMuuXgP27Zt488/dRdqcIo7bruR3buqqdzW79XpSOU0RoAbOyZrqeNe5G6zkj+t6EbqcmWJV6P+t+JBBdN2OJFwSeUhHhKMhBUm4woBX5m50vE6GZIxBVeCR+v/PB+QujcOp0zsMpkMn/70p/nUpz7FU089xcGDB/n85z/PgQMH+PznP89v/dZvMTExwU/91E+dyfsdYICzGnkzz3JxmeXSMqlKiopdYVd0F5ePX950WJWsEnOFOY6kjpCqpNga2tq06VTs5sjKa7lJulJyIiER3ihO/iSOC8/N2mTLCrsnVDyaoGJKXpgv8cJiipGwYDJUJUN/9PE/Aqq1anpT3rVz2ulMNEp0igx1Q2LhaN2hokYmGtOW6ZNppvdPN0WGemF2dpZ8Pt8fqVuDV6M9LSvkphsl6tezCtw2nOYdwzmuf+UvscJJcqbCSduDLQW7tWBHPbAauTMtQCjoOAx5HMK6S0CDhfhuPv2yyb3LOotmf6SmlUS01gbOzMwQDofrNl2dyF2/OnVtHasNUIMqZcqUkiW279ze8579XqU+H97oVqQEyea+V53QqH/YGAH+m7/5m/prGlPHe/bsbSN3Z4rUFQyLLeF1UmdYkoolKVZgPFaNqNmORLqCy7YpjEVVIgFB2Adlu8yrueNvKBkakLrTw6aJ3fe//33+8A//kC984QuMjY3xgQ98gC984QtNreo/+7M/y8LCAs8888yA2A3wA4GskeWF1ReYL8xTsAroik5AD2C5FodOHsKv+7lw+EJKVomjmaMcTR8la2YJ6kG2hrf2LNhPlBNknMxrtkmuZCXzaXArKaDaBeciOL7iYlgwEVM4sljm1VSK4ZBgKjzWlibrhNa0UyBQIH8ajRK9IkPd8OCDDyKNQp1MSE2gBQv1yNADhx5g/8X7+76HQqGwKVJXR2NaNjSFoic21SihIJnIv8Ku7HPMJJ/mnTOLuIrAUKO8UqxafPV3H2WCboEdfgewWZUaX1qNs/3aXyYV283oVRaLPSy1GtHJwaC1NlAIwYEDB5pS1I3krnE+MnOZU+p+bZwPWe7zAmvz8X8+/TlwTd7/M28HdfMku4ZWUevGCHArIW1MHTeSu0CgQNk9fVJXtk1UZ5xCWce/9qyVLUnGogpls9r4NBQSJPOSibjCJTMqmlr9/pwNZGhA6k4fmyZ2X//616lUKnzxi19cLzbtgNtvv73Jr3CAAc5H1ESBn0s8R87MMewfZsQ/ghCCklVisbiIV/Hy5PKTGI7BidwJUpUUMW+MbZFtG3ZgajGNRDnBdGz6tDfJKe8U7739vUC189Xr9ZLISY4uOagKTYblXl0wGqkeOPNpg7SxylhU7ZF+7YwquYOjiaqe2HTs1BolNooMdUNjjZfUBJ7hUdyyhpVJgKwesrOzs0xNTfV1PeEXmyd1NTgGIxEHLRIAZYJh78aNEqO6xU3RPO8cynLdy3+J5tqUVS8nXR+OLdiuR4DkBn9Y4lckw7qNR0h8qsvXyiM87EzzyLJFLmvwodAOdKE07edtllpNH0R7NzI0d2TW0OgiUb+jDvPxlXu+ssE42tFKshtTvxvCMXBKC3jHZljJCi6eGkdr6FatSYk02nl1Qienkn6aX+677z727t3LREzU18f2kdNPv0a0cTweD6YNJUOiqSAEzIwoWA48c9wlmXfxeaperANS145zmdTBKXbF/uqv/uqGr7vwwgtP6YYGGOBsQskq1UV/A1oAKSVlu0zRKrJaWSVbydYjb9si2+o1pU2bS3wbqUqKJ5efJOKJ9EXooErq9LjOqH/0tDbJRMEkrm1nNgva6JVIM8dyVlK2HWZXXRQB8Q46xpoqiIVNFvIrjIRPTbQXqkbfui9DjDilsq+uc9cvOtUM9ds1WoPQq5Eht6zhmBGEx6rXePVK8TUia2QJDAfwSR+5Ym7D19fS0/UaQgF5ZxXpLOKWx8gUPYR8HQSIXYvp7Iv87sw8N0QLRFUHSwrK2hSW4qHiGDiuwLVcekXqFNfGb+XZ5TOpSMGrFS/3paNMvuln+dNnv4x04rhSA3Vzumqt3cin2vDRbT66oVWzr5XURSKRHq4cXcYRdpHOIkEtRjqvMxzs4tvbBd3s5zo6WLQgl8sxOztLbCK2vj5KQQxv54ajGlq161rXR66oE48IvBq8suQilGozRDxUveZkXGE+5bJnSiHiH5C6VpzrpA4GzhMDDNAVWSPLdxe/y8nCSRShINb+J9fyRR7Vg1/zMxWcapJ96LS5jAZGGQ2M9v23E+UEelzHSluM+vt/Xw2O63A4McuJpAvGVpZtnZWshR6/ENfI8MysRFNd4sGqK0Qnq69qd98yQU+fnqkdUKsZGvLFCIfDzCWtTencbdTd1w8aa+qsTALhsZpqvL74xS9y55139jWOuC/OwRsP9kxRdr6JBgmNVBHpzmPasJSRDAer36dtXoOlv/1Nbo1nuWJLhMxQloyt8mrFg0SwU/FguSZCKGukrtOfkfisAn6nCEBBj/KPiSG+mQ3zTCGACGrcmEzhFGyc4lxda28jaZoaOnUjbxYbzUc33Hzzzdxzzz1A58aVgwcP9t+s1+gokSqyNa6zWpAsbyBN04hensL9Piwk8gmIU18fSxnZs1tWaEHyZYlqSVwpsR3JajmFz2cyFaquD9t1GQopjIQFyQLkyi5bhpV63eWuCZWwT7BlqHq/ZwMZGpC6M4sBsRtggDVYjsVKeQVXulWR4NUXSJaTbAtXN4matVcvgnOmNpdEOYGVtrAz6xGESqXCT/zETwC9RYQzRZvvzS+ykFHwukP846f+FJwK/+5X7qwW0AuF0ZDE5+s+jl6HVr+o6dQFlSB/+sd/CsCv/fqdfevcnQlSF4qGML1GvaYO2Z/0Rus4Ggvao/ui3HHHHdx77731pgCoCtzecsstzZInNJOhdQkNg3/62/9GODTG/33rBfzxjpNcHioSUl0qrqCgRzhWWY8KCgVMx0BRVDyi/UPzKy7Duo1XSBTpMBu/lOMjV3I8eAH//Wv/DVgnQ9+49xt1MtQqTdNzlltEe0+f1G1uPnbv3t00jsZIXU2upB90cpRY9/p1+nrw2Gh99JMSVoMq0iebauomYnTtlhXeqtuTqlRLJRQhyVoreBwbH9X1YdoSjyoI+wVeXbB7QiGRg+Hw+nWCXsGO8eq+dDaQoQGpO/N4w4hduVzmne98Z9vPf+u3fot3vOMdXd9nmiZ/9md/xqFDh/D5fPzkT/5k/bAbYICNIKUkbaRZLCxStstcEL+AqDdK0Sry2MJjPLnyJDFvDI/qQRMaM5GZ+qa9Ebk5k5vLqH+0idT1A9uRvLxo8dxCkqIpmYmNENJFXbusqTszL5j2yCY5kxpqor2nQ+q66dQpoj8ycaYidTsv28mLz73Y1m3ZSia6oVuX4r59+9ixYwd/vNZo8L73vY+dO3di281z1llCQ7LHb3BzbJmDQ99nz/IT5ONlUobCiqXBWnSuPg4FhK4ghIJX9dblM1QkQSvLLp+BIQXHK17uTUe56IfupBKeBOD555+vvrZrw0ezNM1IqEuk6gyI9nYidfW76HM+WsdR+9z7jdS1zkfjOLy6YCLKujRNF8uQfh566g4WPcYRHguze3p30/eqVpPaSu4qlkQoOtbqM7z5AgXdIziRmyPklNntbufInI7jSspmlbiF1pbLaERhNNJ5/Z4NZOh8IXVuz2/t6483jNg5jsPDDz/Mn//5n3PRRRfVf77RU9f73/9+nnrqKX7/93+fdDrNz/zMzzA3N8d/+A//4bW+5QHOUWSNLPOFeYpWkYyRIVlOUrarjT0ncifYG9/LK9lX+N7K97hs9DJivtim/8aZ3lwiShcnCdWPorcXxBmW5MU5i+cWU3g9FS6cGKvWorVqxK11A9bSgBMxmshdo2jv6ZC63jp1vcnEmUy/diJ19btoIBOdHCo2kp5obDSYmZlpIxetOnVh12Jv6gn++65ZLg6WCaouRUfh5VSFigwDLlAl4cViNZUqFBiZGMXv8+NVvQgp8dhFdngNEGArHj6bGOKhtVSrg+BDvhF0qg8xhw4d6qOLd12aZilLew1kQ9ryVEV7e5G6+l00zEemKBmNNf8+b+bbxtHpc++GfqRyvPq6wPZyDqaHZVNDSL+R7F42m7X5uOHKG4j72j3XW8ndeFSQKYKTP4FbWsSRDgu5hToZ0hU/SymHfLkqabKlRX+yE84GMnS+kDrHdcga2U2/77XEG56KvfLKK3nzm9/c12sff/xx7rrrLr7zne9w7bXXAtUI3n/+z/+Zf/tv/y1+v/+1vNUBzkGUrBLfWfwOc/k5PKoHj+Ih4okwEZxASkmynOTLx76M4RpcOX4lYU/4lP7Gmd5cKpUKKDqI5iWqhbaiBMapmOvuEBVT8tysxZHlFIFAqUm/qiMcg4korBYkS5lq+gfa7ZxONf3an05dZzLRSUKjXxw5cqRpHL1IRP0uujhUnK6eWK1rVAqby+wck+ML3BTLc8HJVVbDJZKWypJZjc6BDcKtCwhLp8Ly8nI9UpdMJPEj2R73E/QoGIqPb+dDfD0d5fK33smf3PuXHW9hdnaWklvqq4u3Jk0zl6Q5FdlYi3Yaor2bnw/QdJfQ2p9TgypZ63WSyuny8HOq5QmhUIiiqSCtEmpAEh4Lc8OVN3DFhVd0fU+N3C2mJS8tSnaMSuzcMRAwm5/FVd0mMjQ9LHh+ttoIFe3i/1rD2UKGzhdSN5ufxXY2l115rfGGE7vf/d3fRdM0du3axQc/+EEuv/zyrq+97777GB8fr5M6gHe/+938xm/8Bo8++ii33HLL63DHA7zRsFyL5eIys7lZIt4I+4b2oSntX2XbtXl65WkWCgtsj2xvW/iudMmZOUKeEJdGLz3rNhctdgFCC+KspYQqlkQJTaJ4YixnJbG1oN6xFYvDKylCwRKTof7IUK2maDHtspSBkM9os3PaDD7+8Y+jBlV+/P0/3vfh20YmSgsdJTQ6wXXXUx+zs7Ns376dQ4cObYrU1dDqUFGrDTwdUrd1RHJF4ttcXXqVofISmZE0eUch7R3heKXY4SbcJncIpIGmQ1xYhDQbyxW8sCJJ7LiF0gU389v3/S0AF2rt39mau0Ein9iUNIuiiCav37LVXovW2pG5EVrttWrz0drhCnDbbbdxzz33rM0HVburkMqv/OavkDEyBJXg6yeV0/LwEw+bJCqnUnOq8K6f+Hk+/Q//E31onDe/9VIu2bWTIX97pK4VQoCuwWRcsHdSAdfAO+HFcAz2xPc07VejEYWQz8VxIezvHq07W8jQ+ULqauOIeWObfv9riTeU2F166aXcfvvtTE5O8rWvfY1rrrmGz3zmM7znPe/p+PoTJ0606U3VahlOnDjR8T2GYWA0OBbnchvLFAxw9mK1vMoTS0/wavZVlkpLjPhGyBk5Lh+7HF3VqdgVDMfAdm2Wiku8nH6ZqdBU28JvXJQ7ozvPus0lV5YowSmE4mE1D8EApAog9DCumWM+DdsnJLmyw7PzSbzeSp3UNepu9er2rJG72aTJQj6LtARWxjy99Ku+OZ26OplwTbxjM5RMm21Dkz1J3eHDh+u2XlBV8w8EApSt8qZJXQ3RALiVJHp0lPlscdN6Yh//+MfRhcsnPvAO/mDPIm8O5tm2soRUPRS1MMcqGQDCosd3RLpIp0zEozGsuwhpkTJUvpiN82AmzFP5IMGFNL+4v3eX9Kc//WkiYxF2X7J70xGuutdvaIqjyTzC46128Z6GaK8mtLb5+OAHP8gnP/nJptfXmiMAYkGBpgvm00WEnmc6FjtlT+FTlcppXB/LyynGY5skdUJDCYwxEgZpPAuhEbZNvAujEmXVdvHpgqCXplRyIufiSvBqAsuRBL0KF29V8agW3gkvwivYFt7Wtl/5PYLJIUGhDL4uDUlnGxk6X0jd9sh2CmZ/XdCvF94wYhcIBPjud7+L11vdwH/sx34MgF/7tV/rSuxM02xLt3o8HhRFwTTNju/52Mc+xu///u+fwTsf4EyjWCwSGY4gvILsQpZgsIOoGtUF/cTSExxJHUEiuXj4YqKeKEfSR1gpryClxHIsLNfCwcF2bEYD7ZIM58LmspiRKIoX6ZqcTEomhyWLGQl2BWnmKFRgLmVzZGUFw3bYOzx2SrVoKCbCuwIVL641CnKTmmY0F7SfSiobIVH0BCgTOOYouB7o8nEePny4o9TI6ZC6GhQtj9A8SDuCa4ehz49zq9fg5liedwxlueTVv6UYzpI2FDL+CRRFrfu19oIuXIZ1h5DqUlI0njFG+JfUMA8v22Ts9Q8jl8s1aaQdPXq07VpqUKUiKjzznWfQHb1vu7Q61uZDCAvXHEO683zoQ7/eYhnXGzVSt3RyiUe//mjbfLzyyisbXkPR8gg9j7SiuHYQV9u8p/Dp1mrW14fpxzVjEBB9m3yo/lHswknGhpJo4TLm8jHeekGEoqWSKUoyRclqXjIaqV6waEg0VTAVr9bU+aRg37RCxC85kVvmP//Rf+65X20fVbEdOtYcnm1k6Gzdd/tB6zh0RR8QuxoURamTuhpuvfVW/vIv/5JUKsXQ0FDbe+LxOMlks8p6JpPBdV3i8c6h7Q9/+MNNjRW5XK63ovoArzsqToXghUHUoEraSHckdrW06uHUYYQQTAWn6otyJjxDxsigKRohTwhd0VEVteOT9bmwueTLkuUMuGYW6RikC1Wh0UwRXDMHSLy65Jn5BNmyywUjw6d0aNUO35DHw9holPuV3t2AnXBK9loNWO9SlJjLcwQ9elcdLyllU6SuhlNJv7aiVphvZ5NsiQaraUBc4l3qlTSnwnTqWT6+4yRXhkqEVQdDqGS1ELOlMtKFoQ0iOwJJVHMY0hwcKViydT5fjvGNXJTnk0HUwBbwmmAv0DioxhTmgw8+2HTN1vnQu4VvumBdCkSyezjCA6axKZ07aCZ1933xvo7zUdOja4RsIMCHjx8mPBZmOhbHtYM8d/gkTz/2YNt7jhw5wv797ZZwZ4LU1brDQx4PWybiLGc6Nxx1QsmQuE4FwSxZe6UuXRTyCUZiKttGq9G5p1+1qVgSr1aN0l8wrnDBlIaUkuoydPver3RVoHfYis5GMnQ27rv9oNM4LGdzDxyvB97wGrtGJBIJFEXB4+lcoHvFFVfw53/+52QyGWKxGFBtqAC61uZ5vd42AjnA2QPbtXl29Vk8Ex6Q8MzqM4xG162W0pU0JavEanmVp5afwpUu06Fmey1VURn2D2/4t86VzWUh7VCxQNrVVk1dg9WCi5SAtEFAhQSZosp0dIig59QPrUZvy9ZuwI0Or8ZGiX5JXePhffzEcUIToaYuxVpDRY3cKdj1tPL73ve+Jt04ODOkrrUwv5YGbCN3UjJcPMm25PfYkXqSQCVNMponZakk8SEVwTYtiHQTrYOu/2elXK5rznmEJO+oHMpE+Ho+ypNajIqprI3DrM/HejND9TqNGmm9nBigqn3YL1qlQLyqXr+H515OcMWFk/g8vclqjdTpQu8YqeuFv/mbv6mP42sPfQ2f9HHwxoPAIt984OsovuGmBheAu+++G03TmtQUzlRXdWt3+GRc1mtSe5E7KSW5MggWUcMVRn2dpYtGwoLpIYXjCXdNokSwZbi6nwghQJ4b+9VGOFf23Y1wJsbxeuENI3Zf+cpX2Lp1K5deeilQrZH7+Mc/zjvf+c76xlUoFPjRH/3Rurbdj/3Yj3HnnXfyiU98gj/6oz/Ctm0+8YlPcMMNN7Bnz543aigDnCIs1+L7ye/zcuZlrKSFdCVzhTmeSzxHzBvjaOYoq+VVHOmQLqcxpcn2yPbzenNJ5l1eWXKJNFQcRAOQLEoiAepdio60uHBiFJ92Zg4tB2dDKZRGZI2qldpmI3W1wxsBX7j3CwQiAd56xVvrNVzrDRU2f/I//qlJKLa12P5MkbpOtYFVMueSLkgCVoZLjBfYsfoEw8WT6I6BpfrIeYd5tZJH0RVQQFouoiVKVygUWEkk0IRkSLPxp4+j6Ouacw9lwixKb3UcZss41uajkdxFIuGOGmmbiZzecccdbensVmkWacm1uapK0zz0wH1897tRbrl+P5dc3HmvbewaLSfK5HP5jq/rhkKh0DSOXDHHXXfdhd/vRxrlriLGNc9VIcQZlcpp7Q5vbTjqtj6KBgi9wm/+zr9me3y0q3SREIJtYyqreUm2LLlkq0rAW73eubJfbYTBON4YvGHEbnp6ml/8xV9keXmZWCzGiy++yG233cZf/MVf1F9j2zYPP/wwP/MzPwNANBrlM5/5DO973/v43Oc+Rz6fZ3h4mC9/+ctv0CgG6AUpJUczR0lX0sR9cYJ6EJ/mw6f6SFVSHE4dZi4/x5BvqH6wj/pGeX71eSQSv+ZnPDBO2kiTU3NsD5zfpC5TdPneqzbLWZctsfWfq0rV/scwZZOd06mSup6SJh2kUFoPr5oUSNTT3ijRGJGrdWc2olAoNElo5BZyfPlE8/pt7c50igvgGE2RqtMhdbXuy161gYprc7F1lPH0k2xNP09EFhCqQkkN8/TsKlBg585wE6mTLRqlhXye0uoC05qN0CBhaXw1FeOhbJhn1zTnhC6ITEUo5Uqdx9FC7t729uvaNNI2mw7ftWtXs7n9mjSLq7hNUiDrRLpK7krAlw9VMySt5K5VCuTF4osb3kcruo2jXK5qTnZzqKh5rm6d2XrapM5VXP71v/vXXbtfu5E725EYdjU4u5jNE42tsj0+ui5d1AU1F4hahBrOnf1qIwzG8cbhDSN2l112GY8++iizs7MkEgl27tzZVicXCoV48MEHm8Lsb3vb25ibm+PZZ5/F6/VyySWX9O8POMDrilcyr3DPK/dQsStMhiZRUNBVHY/qoWJXEAi2hLbgWOubeEAPENSCaIqGqqhnxaJ8LTYX15VYDpg2OK7EtOHlRQdHwsyIIJGR9bRTTc6jOU22+UPLdMy+JE16RSYa9d06dSnWI3JUuzPD4TAHDjTIELXoorV2W9bIYL07syFaNT09TTgcplAp9E3qbr/9dj7/+c83/Wz37t1tJKJGSLd6DaZf+BzXiuNEKglUaVNUAiwzhq6rqIqkVj1vumZHUucVLiO6TSB/EqkKvpMPcV86yrdzIfLO+nenRk5/9B0/yv/5q//TNI4mORDHIKDkufIt7yQ2vhVVFXzkIx9BSsmf/vWfUhGVrqQuHAqR7+VbujYflmsxFZqCrnJcsj4fDzz6AhdcsLuelu2k79aPpVYj+iWn3chdPp87IzV1reOQUradL1LCaESQyFUffkYjstq57hUU7DyqJ82+iVjf+9X0kGA8quLRxFm7X20Wg3G8sXjDa+xmZmaYmZnp+DtN07jpppvafu71ennTm970Gt/ZAKeDk/mT3H/ifgSCayevrXut2q6N6ZiE9TDetYhTI7ED6j8/Gxbl6WwuriuZS7nYSpKiWx3HiH+UIws2KzmJ44DtgCsljlvVrRqLCI4ceYl7H/hO/fD69D99muiWKJdffflp2TmtGut6YhtJNnQid3kr1yTa2+4o0Z4uzefz3H33P6/dRG9SB41k8ACNZEINTmE5ggO3HuCr3/hK35G6TntLq4OBX3F5+Z8+wcd3LFcbIeZfwUBjNTqON1yVFtEdMG2JtvaxKXr10K+ROgXJkO6gLB1h3CM5aXi4b7maaj1ueGhtpWyMOI74R9rG0SgHUrPNMm3a5uPy6y/nW/d/qysZuunmmzs2KkCzZ+qov1rX+srxXt2q65G7Z19a5rK9E6CYHUV7Z2ZmCIfDbTWRnbDZiGMbuTMz2H7nlEid4hsC1LaaU6QgVXQxLEBIgh6BR4NMSeLRBKa1Tu5eWpTsmVKZGE2TMpaZCI4zEex/vxKieu03er+q4Vzfd2s4G8bxRuENJ3YDnJs4mT+JT/Ux4h+pP9G60iVVSbFcXObRxUcpmAWuHL+yvigVoVTdH/pQrz8bFuXpkrqjSw7fO5lD0Qu8eVd1HPMpl1dXXPx6dTMPeKrRMEVUN/hGOQ/hjaH4hlEjOmUzwze+8o3TsnPSFH1TactGcnc0UUD3ZRjynbpo70akroYqGbx77V/r5O5k2sI3HuWmt9zMo19/FEs2E8tairUX1KBKxszgFGx2u0VunsxxMJ5jwlO9VspSSZQ9SASUV5kSOqFQaK3bUGBYLorHA8LGI3SCwmHYa6MKSNsadyfCPJCJ8FQhgCU7k+fWNHInkt0YJarZZnl12ubjou0X8Y3iN7qOt1EbrhHtjRJVMtRKzNtRnQ/LKDGbrEqBhDztaUshBLfeemtHaZpGnGpXdSO5C06GGRqNb5rUCW2taFVzmc+tEg36GAuMYViCTEkSDyjs26JQsVwWU5KiCVuHFaaGFGZXXRZSLn6PQFNhOJYhay0zFTo396sazvV9t4azYRxvJAbEboBN42TuJN9a+BaudJkMTjIVmiJv5lkprbBaXuV49jhhT5grxq44ZxflaZE6KXllyeGZuRyukgUzRjYXIaS5HF108GqCSKC9fKBVzkOaGdSIjuKPYyZtpJXe9Dga068j3vbIUP2eW5wcasbqXl0QCBRYWS0RI044fCo6df2Tus6QuOYiRTuDmvdzye6ruGzXZfzxH/9x06u6kZga1KDKUEQivv4P/LfJZS4KlAkoLkVXYc7QOxKxRCJBMBRCAJoKFdvCo6rEZYVhM0FFdXmuFOBfUlG+kQ2Ttntvqafb8NE2HzFf22s6NUc0olOjRA39pVAlo3FJwU6B6WfLRLwjOd23bx933HEH9957b1vk7rbbbuOrD3wVNaTikz5yxe7C8X6/v15n13QXa+tj97634GVik+lXBeGN4hRewjMWxjC9jI2OIaUgU5TsmlDYMVZNj4LC9FC1hi7sq5LWoFeAhJWcy8xojhJL5+x+VcO5vu/WcDaM443GgNgNsCGyRpaAHkBXdDKVDE8tPwVA3BdnvjDPidwJFKEgECQrSabD06e8KBPlBBknc05uLq6UpAuSk0mXl5dzuGqGiVAUnxLm5KpLoSIpmZLxaOea0NnZ2fUDcI0MITKYSRuhDSG8sqkbcCP0m37t5OQQDoe59dZbmdwxSdnNsH0kRqkU7FvHa/0mTpfU1ciQylhUorgxljMwEupMjDtBRXL1aIWbh/O81ZMlrli4QNLSWKz7tXaGZduUy2X8Pi+qmWHcKuClyKIb4tX4AT7x6JMcKft6XqN5HKfXxZs1sk3zkSwKfvu3fwfHWZeF6anT2dAoMRWZ4nc+9DtNv+7UcduKSDyCb0QnpAhcszofk3HZpjsIVXK3Y8eONhI+PjNej9Td8vZbGiK07fiRH/kRgGaCuPa9uu6Gi9gzs5tiWSOtdtcdbIXiH0FaCbTwIm4+y0hgCNMS5CuSkXAjqavCq1cjpo3/vnBaRUukcbQBqRuM4+zCgNgN0ATDMZqefI9nj/Pk8pN4VS87oztZKi2RNtNsC29DCMF0uHoQ1BZl1BM95UWpxTQS5QTTsemzfnORUpItSZazLtkSVMUxqp2tebMAWobxYLSetgz6YDUnGYuKrs0+9TRYGxlKI7yyo9RDN/Sbfu3m5JDP5/ni177IjbfeyP5d+4l6oxjeZh2vjW/iTJG6KhkaD4yiaypLGclSFlC94KzbBTY2boBku9dky/Of4e8vfpWtPhNdumQthdmKB6cv+wBJQJFEjVW8LpRUH68OXcUnnjrKd40pfviyd/CSuwBkNjWO0yF1jTWOjfMxHOzjgi2NEp0iXK0dt53GcfXNV+NRvdU1GhAsZWRXUelO12zVDdy7d2/HyF4kEuHgwYP15rk6QWz4Xl2x+wpCPi9p1d1QVLqGkiFBdVA9J3GLFsbSCpNRwXxG4vcIdk0oTaSuG7JWAulZZnJAhgbjOMswIHYD1HEid4JnEs8wHZpmT3wPyUqS7y5+F4nElS6PLT2GRLI1vLWJnJyJRanFNPS4zqh/9KzcXKSUnEg4JHJV2x/HhUxRYjly/UleAmoe1ZNhuMVAPuQThHy9D4tQKNSVDLUWjPeC4Rh9pV+7OTnAeu3TU996iusvvB5ob6joSSa6jKOT+XvXS3SoRavq3MFckiYpFKgS44hq85ZogbfFclwaKhFKvoLhU0gYGmW7vyijimRIt4moLhUpWPQM8/LEFaTGb6CsD/ONz38cyBML9Ee2W8cRCUe45ZbeUapWtJI6aJ6P5RxUo4bNc+LxePjIRz6CYRp88q8/2dQosRFa5yoSj3D1zVezc9vO9Zo6USX5Sxl6krsauukGtkb2ag0jjfuMoiht36vaOBp1B3uRO8eVJIsWqnceJ5vCWDJAwlRckDeqdl7D4Y2jfmcDiThfyND5Mo6zCQNidx6jYlfqenCNsF2b+cI8iVKCscAYk8FJZvOzPL70OI50eCbxDCdyJ6pm2QLGA+MAjMgRJLIppXcmFmWinECP61hpi1F/b4PzTng9SN1Lc2V+9//3RYTm5/+641YCfp2QT+DV1z+LrJGl1HL4bgbT09NEt0Qpm6WOEa5GcpcpSkZjze+3LItP/MknNizMr6Ep9duAxoL2bDHL7Ows27ZtA5rJxGKmJv3RQvB6ROo6mb93Qq8IV6vOHcV5rvCnuSmW44eieYZ1GykFaamScDxIG6SzUURLElFdhrWqs0fS0vhsOsZ3PZPsuvGnGKtFuBo6gaMBcCvJnuSudRzve2+VsNh2V12RNmSNLEW32PF7VZuPk6tOg0NFM7o1SmyExrm64713EBjz1yN1jd+rGtneiNxt5CncGNmrNYy0jqNXBLgfcrecNcGT4g8+9AtM+kZ5//veD8Dcq99n7+7LGAptvH+dDSTifCFD58s4zjZbsQGxO0+RrqT59sK3Kdtlot4ow75hfJoPVaiczJ9kvjDPXH4OXejsHdpLwS7gVb1M+CdwpUu6kkYVzVZdQggEZzZSt1JaIVFO1L0UN4vXenNxXcmJVZeXl8EtLqJ4o1RswahXNB1enSIqdQFY4EMf+lBPE3VXuiQqCa665ioevOfBrmnLGrnLlEDTmw+vxkhdp3Rfq3hwuVxqu36nLsXWCJtXF+QTr/DAt59vs7vy+X04Pqfr4duP5mQ/aUtFEYxbx7llSOHWmQTb1Ay6cMk71VSrqyoITSBt2ZPUeUXV3suvSgqOwnfyIe5PR3gkH6YS9vHWa966Tuo6oJuuWrdxdCIsvaAGVbJmlpHgCAElwEc/+lGg+fvk1QUTUUBd8/ptGG6vRomNULtPoQu8w96OpK6GjcjdmfMU7p3W70XuMmWDlJHk4q2CxJEFPvbX/6X+uz/4g99neHiYX/iFX+C6667reh+nTSKkw0JuYUCGOI/GYZfIbKL2+fXAgNidwzAcg5XSCgWzQN7KMxmcZEtoC2W7zONLj7NaXiXui5Mqp1gsLOLigqzKjhi2QcwXY2toK4ZjENJDdUKiCGVD79UzuShH/Z29FDfCa7m5GJZkNSeZT7sk8y5BD0i7gGMX8WjNh1cnUrcZNNogXbX3KoaUoY71RrX0nTQyxAI0HV6GY5AoJ3qSoVbx4ECg+fPqdvi2dkoePnyYf/7iXaB6m71MhWwidbf/2O0byl3Url8jjzUydN211/Pwlx9uG4fqmGzJvsi2lcc5sPcYEdXBwMOqE6Rs2yBdhCp6kjoFSUxziGkOjhTMmzr3rUR5MBPmWMULQhCdjvLWN13FVXuv2jDC1Uju/IEghfR8fRx+b4Cbrr+Jf65p+W0C9bSlJ9pVN7AGr74u6LxSS8sK2dFRohd0XecjH/kIUH0w2dCppAHdyN2peAo3orY+DNvCqQwjdBA6gMRxJa2PS53IneEYHE8l2T4qKJ2Y5xNrD1yNSCaTfOxjH+PDH/5wR3J3uiQCAbP5WVzVHZCh82gcx3PH0dSzi0qdXXczQN+wXZsnlp7g5czLIKtP1y+lXmJHdEc11ZqfZyYyg6qoRDzrXoW1L7MlrbNmUXbzUuyF12pzcV3JUlby6rJDrizxaDAcFuDWog/rRvUnVy0+99k/Qw3Y/Oz7fva0SV1Nh6tbvVFj+q7RqN50DAyxjL5Bo0Rr5K1UWo/YdSN14XC4SeS3qS6v0e4qNIWiJxC6rEdUenZnNqCW8muMcF2+63Ielg/X/ip7/RWumvsquzPfI2ikQLoclXCsUtWcE6qCUH2AgVBlB1InCSouw7qDJiRZW+WrqSiHMhEezwfXpU4EvPNfvZPRiRHGg+sSGo3R106okbuDP/EB7v7C36IFCxy46W1cvutyXNfln9kcsXtp9qX6fPT9vVqbD8sW9fmoNUoobn/doo1ojAD3cippRCu5CwQK5E/BU7iGxvWhu6M4hSRO4SQAanCa1RxMjUiUlihoI7kzHYOCs4Jf93Hp5DC/8f/8p55/86//+q+59tprm1LDZ4LUeSe8GI7Bnvies2LfHZC6MzcOv+7f+A2vIwbE7hxBwSzgyPVN/qXUS7ycfpnJ4GTdqaFsl3k5/TKOdNga3tq2YM7WRdnLS7ETXqtxlAzJSwsOSxkXjwbjDR2sVkPHQs2o/vBiET2+BSs9f8ZI3frfaK836qQ1ZzoWx1NphoI+ZqLRnunXbuiVJjtw4EBT6rCtLs8xcEoLeMdmQJnAXJ7rGRk6efJk28+EEB0bJaKqzVujBd4xlOXCQJmtS1ls1UfBO4QtNDL2OlGVTgXF40eoPlyrgnSqn5UmJMOaTUh1KbsKh0s+Hi6P8y/LOqtWS6xnrTZwaHSoidT1C2lkCPosPMOjuGWN/dv3o6pq07zV0Piz1s9EDarc/8j9p0aGHIORiIMWCYAywbC32ihhuZurAWqNAPdD6mqokbujiare3nRsvVGilkLuFX2soXF9RLRxKqrAyb6CW1kFQBpZYkFI5CRhXzXKLqk+9ChCEA8qmI7B8VQaTfi5bOsQ88ePkEwme/7d1dVVXnjhBS655BLgzKRfvRNehFewLbztrNl3N4uz9fzYLM70OKaCUyQrvb9TrzcGxO4cQMEs8ODsgyyXlrlu8joi3gjPrT5H1ButkzoAv+Zne3R7R3/DwaJcR8kqcSzbPA7Dkrw457CcdRkJC/QN5A7yVg7dl8IpVUCMY1iSHiV0behF6jqho9ZcPMybbn4To6O7UZwhcqV2AjE3N9fzujVSp9s6ZtFs+/3evXub/t3W0SpAD7tIZxG3PIbimcSx1mvuWtEpNdsooiyzJteEitx48gscuPAYw5qNC6xaGmnfxDrhbSGsQhUgDKTjBTxEtCLDWpU8rJg6dyfjPJQJ83zJz4/+6G2sfvnL7eNYK8zPzmfZEd/R9TPrBqELTGUFt5zGMSPkSoLRDiYrrXPZ+Jl0ItlHjhxh//79fd4E5J3V+nxkih5Cvs1pq9Q8UzeKAPdCdX1kiBGnVPa1SdN0gpQSxT8Gcr020HRNRv3jZPI600N2ndQBSLvIvinB0YSCaUnCAQXbhkTWZTQKlmtiiGXiAR9GOcqWIY2j8/2JfKfT1dedif1qNj+L8AqMRaOtka0fnE/77vk4DldupFPw+mNA7M5C1KIsQggqdoXvLHyHx5cfZ2t4K99d/i5hPYzt2owHxzu+f0Dq2iGlJFOUHF0pczy9gibiTIaG8UlBPCh5edFhOecyFhWoG4jv1roU494o1uocanCKpSxs1TuLtLZis6TuyJEjbdIYQhcYeoVvPvhN3nUgzsTWEVazLsIbayrg/3IrgWlAI4k4ePPB+mt7ORc01ds1dr+mikh3vqnm7ujRo70/CNZFlLdIgxs8Kd65J8uM12QsVeC4cDnRqDnXpemgVlPnA2JkCXhUCq7Ot/MBMrtv4ZP3f5+Cu/59feihh1ou0NzF+/Chh7ns4ss21eTQqBtoriYQHqve4BJqIHed5rKGbpHTQ4cOcfHFF/dxE9Vx2K5Vnw/ThqWM7E/njnVS51E8xL3x09LbG/LFCIfDzCWtrh27jciUQNolUHVmM0m8fpvxwDj5ok4sqDAz0j4fYb/gyh3VufXqgkJF8vwszKcNXG0Zr+ohFhrG8guGQ4JkPN7XGOLx+BnbrwzHwFg0kMbmP8xzfd+t4Xweh+sMiN0AUGf4ndIbq+VVnk08i2EbjAfHKZgFHll4hH1D+5gKTeG4Djkzx6R/sq+/db4uSsVReNft7wLgs5/9LD5fu7VSDWVT8uqKw/GEwUo5SVD3Eg8MUzQEz56wCfkE+bJkNLIxqWvtUqx5Z7Y2VHTDZkkdVA/2RrSmLe+/735+5Vf2YVvt3Znd0tytJKLRKqxXbVzd3L2Q7yA90VBzF5ziwQcf6jmugFdyw0SJn1j4Cj838TIR1aHiClYsDc03zqpV3PCzUVWIe2yiwiEaG+aZBZd7l6N8w9zNcSfOL/7wD1O490jTe5qijh2kWfJWvknipRtqGnGFSoG/+Ls/b9INbGxwsb3rB3rrXNbH0SMdns9X72dqaqrrvTRKgYx4R+vzMRGF1YLsqnPXiEZSNxYYw7E3XxPXqZGoUZqmW2S7ZEgcB+zsS3jHo+QqLhfGxylXPKgq7JlU8DWsq25rPuQT7Jw0mCusUC4EiMfjlAzBrvHqurz44osZHh7umY4dGRlhdMfoGduvtoW3DUjdeTgOIaqNQWkjTVgPb6pc4bXGgNi9TnBch8OpwyTKCfJmnqAe5Pqp6/Fp1c3Jdm1eTr/MC6svULSLBLQAL829RNpIszu2m6lQdVNXFZW4r7+nzvN5UVac/ury5Jpv69FlA1NZYTyiMxYYqS9C15UUjGqDhKZuTOo6dymuN1T0InenQuqAppq2ThIauVyufvBvpKvWOI4aiYhEIn1ZSUE1Gnzw1oN86dCXOktPNDRUlJ0IUKCZTEguClS4aSjPwZEcY6rFUDHHKw2NEBtCSjx2mW1+E02FrKXy1XSEoSv+Db/54FfXGiGyqMEgK1nRPQ3YQ2+vUCg0NUzceeedHW+lVy1arcFlNUs9krqRbmC3mrpeos6tUiAedT1E2I/OXW0cjaROEQoOmyN23brDFWW9Y7cW2caVKP5RECrLWYmqSbaOSvRIGikL7B6Okc7reDW4eEZlJKLQTyluySqRMI9z8dYAijXEYlrg0WA0oqzdi8Iv/MIv8LGPfazrNX7y536SRCVxRh9CN4uzdd/dLM7FcaQracp2GVe6qEJlLDCG4Ri8mnsVXejois7J/EkEgpAnxMXDF7M1vLUa4T5LMCB2rxOOZY/xxPITeFQPXsXLifIJAnqAayauwZEOT688zYvJF4l4ImyLbGOltIKiKFw0fNFgUZ7GOFbzkuOrBra6QtjTLtmgKIJIH2UvjZINnRolag0VjVIPjdt5Y83QZkhdI3rpu9UO/l66atCZRBw8eHBDK6nGccS3xnnrzW/l8Qcfx7TaiUpTt+wamRjXTd4azXMwnuWCgEFAdyk6KnMlDTE+TsbuIzrnWgTsArpjUBEqL9pB7l2J8NBKkFVL587IhVjyX9ZeXY2k6pqs38OHfuPXWVhY4O///u83tDtrlXjpBMMxSFVSaEKrz0drI0Q8qHSMpNbH1Ke+W7f7qT0s9NKpa9O5c5tf04nUbRYbSf4oviGkXUFTJPNJB4HENTK4xXn2Tgo8HkHBXatFWyiyZ8LLK6uCrUMKU/H+7qdpv4pXFQG2DElyJUk0uP7AcN111/HhD3+Yv/qrv2qK3I2MjPCTP/eTTO2dOrP7lQ5f+tKX+r7G+bDvwrk5Dsd1yJpZdkZ34lW9ZIwML2VewrANPIoHTdWYCk0xHZ4m5AkR98bPSpeKAbF7DSCl5Fj2GCP+EaLeKMlykmcSzxDUg4z4RwDw634Opw4T1sMUrALfT36f8cA4AT3wA7coGzsEX3jhBa644goURdl4HKoXehSu2o7kyGKZVCXJaGRjHa5uyBpZsn1INrRKPYyE1g7QBuP114LUQfPB343cdSIR7373u9m3b9+muxSv2nsVETfM3d302RwDvTTH9aM6N09muMa/RER1cBCk0FkyFNw+dNXEmuZcXHMImWlK3iGeHrmWJ71T/LdHH8Yp9qpvkYy1pAFnZmYIR8JU1EpXUleTeOnlDiF0QaKcILGY4NGvP1qfj061ibGg6BhJ7ZfUdbufxvlo1KlrFaLeuXNnk87dcg6mhyWKIl4XUmc5EoSCtPIoChTKMDMEdvJZpF1my7DLsnESu7xeizYUEkRCGoE+l0q3/aqbld91113HZZddxnvf+14Afu/3fo8te7ec0Ujd2b7vdsO5Oo68mae4Vr6hCpWYN8bJ/Mm2ceTMHJlKhog3QsQTafrOZ80scU+cayevxat6KVklfKqPx5YeI+aNcdHIRVw2etkp7eGvJwbE7jVAxanwzMozSCQXDl3IUmmJolVkW2S9Zsev+Yl6ojybeJaKXWEiNIFf8//ALcpHH32Uv/qrv6r/+/d/v6oA/8Gf/yCTF012HUe6KNFHrwLpkCpIpjqU2B1LlHg5kWI0otRrhv7o438EbOwEUUPt0Ip6on1JTziOzaf+4hOowSnec/tPguZFD7s9jdc3QjgextArXUldJBJhZmaGF154of6zVnKnaPmOJGLHjh11N4NeaE0jexQPhw490OGVVc25H4rlORjPMemxURSVjO3huOmCroALrtW74Fh3DKa9Jl4hyToq96cjDF/z0xwNz7BqFQkqQZzig03v6SSlogia0oBbNJc33fImHvn2N7tGuFolXlpRI9mL84s88M8PdC1ba+xmrc1HKD5NId19Pjqh0/20RoAbdepahajD4TAHDhyoR1JrDRXxsEmi8tqSOoCyCdIqYiaeZP+0QsXR2Dnu5Z+/8JmetWgbeSvXcKr7VWOUemzn2IDUce6Ow3EdVsur9TN2tbTK95PfR1O1pnFIKVktr7IzupNUOcWJ3AlG/CN1i7uckWsibgE9wA1bbmDEP4KmaFwQv+CsqqXrhgGxe43g4lKxKzy29BgA0+H2Gqa4L77WPTaEV/P+wC3KRx99tGOtSzKV5JP/+5O891+/l3de+86mcUgpWcpInj8pUdYW47OzkrJtMx5TCfkEtiM5lijxyMspgl6VydDIadcMVRsl+kU1DaipLt6xGaSz2LfxeiuELrjyh67k2w9/u6v0xMGDB4H2wvwamdCjowjNg51NnrZIbC3ieOLEiaZ6sbhm85ZonlvjOS4KlAmoLkVHYd5QsdBQNB/CK5G20ZXUqUiGdJuI6hKwCzxf8XJvKspD2TCLpocfy+qEvQXivnjH+ejuclGbD8nhpTQj41M9balaJV4a0Rg5ffyBx3t2jbZ2s0ojw3VXvZ2HHjc2NR9t99MhAtyoU9daj5fP59c7cZ1qQ8VizmJ5OcV47LUldVAldm5pBRyDLUMCn6967JwttWhaTCNRTjAdm/6B2He74Vwex2p5lfHAOG/Z8hY8qoenl5/mxdSLvGniTU3jyJt5InqEK8auQFd0jqSP8PTK0wT1ILZroyoqk6HmxkRN0bh4pI+u9LMIA2L3GiLmjeHX/NWONaVzdCjmjQE/eIvSdd2mSF3VAkkB1sU8v/L3X+E917+n6X3JvOT7cw5SgltOAODT4ciCy4nVagqnYBgcXkphmB5G/BGQgn5q8hvRemj1k6psgpAIbwIUA7c8Bm4HQbONLrFGInZs3cHIgRHuu/e+NpuxgwcPsm/fvjaiVYOi5RGaB2lHcW0TyGzqHrrVBhYKBXThclWoxC2xHG+JFohrNg6QtDQWTY3ahy4UFxQTpBcpPUBjFbzEa5fY7jURQpK0ND6bijFx9Qf4rUNfwl27hhpU+dpDX6tHuG677bZNjQMhUTwJMFUccxTpeoD1hopeEi/1S7Skwy3Z+zvRqZt15wXD5JVdPP/MPGaP+eh6P2u1ga0R4E4iyF2hmAhvGkw/rhmDwOmvj25w3Wo7jGtmmn5+Og1RNZwpUqfHdUb9oz8Q+243nG3jGPOPMezrbWtZg+M6lJ0yVw9dXW8c2hrZyvbo9rZId9pIc/HwxfXv7N74Xubyc6yWVxEIhn3D9XKpcxkDYvcaQ1VUVHp/wc+3RdnPOF544YWmwmU1sgPhjaFq30d4wVg0qBiVJgV415XMrro4riTWUAwd8AoiQUHFgrmUQdpYZSKuMuSNsZyppp0mYv2P43S9X2uHrystzOU5FM/kpnTuoN3OaXrfNDt37GyzGattXJ26Jms1XHY2iWubG3bLdhpHW22glMRLC9zqPMNP7nuVLR6zbtHVpDlXu4QCQlfAdXHsMsOjU6SSq+huiWHdJqBKdGnyUD7I/ekIj+TC5B0V3z/c30TqWtOW999/f39jWBuHHtNxpMW+8VESGbHeIbrWLbuR/VmjiPJmRHsb56UmlXP1vgvYP3MJn/qHL+ACt9/2tjYS1+l+GiVNWiPAGwlR1/De97+XlJUi5PGwZSLetD6UDaR+atjM+ihb4POAa2brPzsT+1XZLrNQXDit/SpRTqDHday0xah/dNPvPxf33U44G8dhOibHc8eZCc+gq71LZhLlBGP+MWbC69aHQ74htoa3slRcwh/y1+/Ro3rYHt1ef11AD3Dh0IU8Mv8IrnS5aPgiNOXcp0Xn/gjOcZyPi7KfcdSU3QGEHkSNbEOPh3ArCSqzc/Vam8bXreYliZxLPCjaDlYhBIpq4GjLjHjW00sjIZM//ZvPgWPy73/+J+qvr8lYtNbanS6pa9cTc3Gs/nXuoLuERiebsW4epu1kqHe3bBtaIkMR12Qm+RQ7Vp9kpHgC3a6w6HNYrmgYsnMKTdM1XMWt19QJJGNek6i3jCthrqJz70oU37b38BfHHqQxbFTT3+vWYNCvDV0rGfLrXsYjZr2hopHcdf0o1kSUN0vqYL2ppVUqJ6BY9YaKyPDGnrqtkiataf1eciiN41gsLnLB2AX19TEZlyymXZYydCF3Co0D7md9mLZEV6trsmRIhgLUP2NHOizkFk5rvxJewYn8CSL+yGntV4lyAittYWe6N8l0w7m677bibByHV/XiyurD5EJxoak2vRWmY1KxK1wzcU0TAVSEwvbodmbzs7jSRREKyUqSHdEdbZHAbdFtHM8dZ7G42FX0/1zDgNi9gTgfF2W/44g3KMCr4W3o8QhCtbGLE0hjru11jis5ueoiBOiaoDUz2q27r7EbcGUDkdZ+SZ1pmh3JVHc9sf507hrHcSp2TqFQiEKh0JUMhXSbQh86dzUypOmSK6wM+048xkz6WXxWARCU9TBFfwwrGsIoL3W8hlAgOhQhncrgdWyGvTYeIdFw+XI6yAOV3TyWD1MuLMPdD9EpF9hv12g3vPvdP0ZRFHnfv3lfUxq5UVetk7Zb4/zW0q9LC8ubno9aN2uymOwolVOrgSxaOr98528T8jhdv1fJUrKnpMlG8iy1cYT94bb1MRlXOpI725EowXGgWrdacnuvD8eVpApy7b9hJFz9/6FQzTmE6kGruqdF6ryTXryq97T3q1H/6IDUnaFxCCmYDk2f9jjivjhz+TmuHr+aydAk2dksqUqKId8QrnQxHROP6kERChkjQ6aSYXt0O1vD7Q9Hk8FJop4oC4UFbNcmqAfZFd3Vlp7VFZ39I/sJaAGGfEObvv+zEQNi9wbhbFqUb8TmUlOATxVdvJPbgAxmooKijaAExnBLKwxP78cM7OXVFQchIJF3GQ61E4CanljX7r61bkDLbkjBtZzQZyJS1+vw7aRz10ruTtfO6eabb+arD3y1Kxm66eabueeee5oid20Q4OaO8P7hFQ7oaa4+toSGg6EGyPlGkWL9O9KNTAgFVF0wqjtEtTKmIjhe8fIvqSja1Lv4+1cfBtVGDfq7zsfpkjoE2H6nh26gbCJ3RofzvbGm7skHn9z0fBw4cICcmespldPNoaLmatFN0qQVvQSma+PwewNcsv2StvXRidwhYDXP2twIjqcKeAN5op4Yrh0mabromkBXwXaqUTrLgZGwwtaR6rXm0y5+fU0nUoB3wovhGOyJ7znl9Kt30os0JDPhmdPeryJKZNPvP9f33RrOxDgKZoHnk88jXcn26HYWSgtsC2/r2VFeskoYjoEqVDRFo2AV6uMY9Y8yV5hja3gr+4b2oas6F49czHcWv0PBLOBKF6/mxbRNXFwCWoA3TbyJPUN7Otaw+zU/O6I7OJY5xkxkhm2RbYwGOqfcJ4ITTAQnNv0ZnK0YELs3AGfDonwjNxfbkeTKcMe//mX+7qv/ArqGtVJAWhLhd1GDW1H841x78KdJFmAlVz0QdZU2d4ianpjf4+/d3ecYjEVlXaS1kUyciZq6hfwCn/v8Z3t2W7bq3DWSuzNh5zQ+M96TDO3evRtolkLJlqq/C6sON0QL3Dqe58YTf4cVXsVwBSU9gquta8m4UtY9YHfu3NnyFyTbxoehsIyGRFW8fHE1zgPpCE8XAjgIQt94svrSDiLGtfk4E6QuuiXK0Gh8A93AdXLX6lCx2UaJTpjYPtGXVE4nhwpo70ZulDRpRTeB6cZxvO3Gt6Gqndd5I7lbTMuqVVsQ7NRhtKjA60tjm6O4SoiQX8HvgUJFYtpVW7fhsMJQSDA1pKCrguGwIOCtdsR6PW69IWpbeNsp71cn8ieQhsRYqhKDzaJ1v+o3nV/Dub7v1nAmxpE1sjy98jS7Yru4bPQyhv3DPLH4BMul5Y4EqWAWWC2v4tW8+DU/tmuzWlnlePY4+4b2MeQbYjY/S8wb4/Kxy+tp1d3x3VURcEVjMjhJ2BOmZJcoWkVi3tiG4794+OJTfpA4lzEgdq8zzoZF+UaTuudmbZYyLmnfFq66/h18/9FvYa6RIbeSJjy2izdfew1XXLwdj1YlPo4raS3/qR1autKf+LBXo41MZI0sRbfYkdT1YynVZLzeg9TV0IncoZjrkTo9zh/94R/1vEYnqEGVrNUeGerWXVklD5JY6lV+fSbDLeEVRn3V9wllmmPlqr3XbtXLRiIUKpJh3SasufhUgycqfr6yHOHC6+7kE/f9TdNrm2rBOpA7Naj0Rer8fj/lcrn9F2vzcfnVlzMenOhDYqbdoeJUGyVg/fNu9xTujVaHik7dyI2SJq3QdZ2PfOQjHD58mHvvvZd8Pt8UqXvbjW/jwn0X9ryHGrl7ZclhKKSwZ1KghS30qM4VMwG8SoyAF6IBgaIIXLdK7HSNNo9lXRXsmVSxHYejqTVHiUUDv9aHzUsLavuVV/ViLBmbjpzCYN+t4UyMY7W0yuH0YW6YuoFrp64l4qlGPt1xl2/Of5OckSPiXY+G5swceSPPvuF97I7tJu6N48iq5/n3lr/HyfxJZvOzzIRnuGr8qibLTF3RuWHLDU1/P07/1l26qm/YfHE+YkDsXkecDYvyjdxcpJQcW3b43nEbry9NOFThxksv5MaLLlzv9nzvv2Jm2w40VTSF9FsPjtau0b51uBrIhD4yTdrIMhYaOa3u12bj9Y3RSO5mkybCu0LIc+qRunphvt4eGerUXTnlMbkplufW+DGuTL5CcTRNwVWYszUsS7JDDyFZ2eCv1mRKDISAVVvna8Vh9Evv4BMPPoSUgu16eOObb5kPoa7gFOwNI3W33normqbVSQzQNB9X7L5iE7qB6w4VWmQLi8XVUyJ1UP28u3sK90ajQ8WxVIpg0Nq0U8m+ffvYsWMH//WT/xU9rnHgprdx+a7LmyJ1rpQUK1CxJM5aPn40IlCVamo15FfYt0XBFMv1rtGp8Cg+X/MaUxSBr4eKjytdThaqNXV/+//+7WnvV+OB8QGpe4PHkSwnOZo5ysFtB7l87PImX+Ktka3sN/bz5PKT+HV/PT2aKqfYP7Kfqyeurr9WRWXEP8IPbf0hXkq/RMWpsH9k/1nv6HCuYEDsXiecDYvyTG0uc5k5PvpbH8XO2Hz2s5/F5+tg+1D7m4akbEp0TZArVYmd5smQq7gMdYhEzMzMoGu9SVov4/W+4Bggl1EDW7AqQ4TjkaboXF+uFC1eo40bXD9QFEE8bLK8nALTz5aJ+CmLKNciXCG9ewF9SHHYlXmG/2f7Sa4Ml4ioDoYUGHqQV60SQvXi2gayR1QIQHVNpjwm/rpMSYiv56M8psbIGRr/Ln45Uj4MNFtb9UTDfDilMZzixtIde/fuRdd1duzYUX0oEHDwPQd56JEHO3aNbgRFgGsu4olPkysFsfJKE4moNaZshLyZ7+kpvBGkmUGN6GSKsr4+NgtLWuhxHWkJ9m/fXyd1tiPJlCS2A0FvNToX8QuWs5JkwWUsIsiWJKMRBY8/xXLh9e0a9fl8TZ6qnfarzXiuwvm1757uOF5MvoiDwwWxCzYch7tm1ShYf8DOGTleSL7AwW0HuXri6o777oVDF7JYXCRRSjAVmqJkleqNLp1Qq6Mb4MxiQOxeB5xvm0u/3WQVU/LsCYd00UVXBY7rkreTRMIVRuU4xbJGWnUJ9cmJLMviE3/yCfS4xr+6/SdOKaICaxGugI2VnsejBFnKSIaDvS/U5L95crangXzH96x5dtY2ScMxSFSWGY95cM2q3t5kXG6Y9mxEq4dto5UUVH1WrcPf4Fe3LHEglmPviVVSsTxpW+VYpZpqnRYChINrGqB4EJ2GIl18dgGfXcRB4ajl4d7lCDve/O/4vYc+XSURRjvJbr0fqB7erbVNjfOBGEcNTuFx05TLpabXXXfddTz66KNNP1MUpU6y46OxvtLhnVBNv6q4xSVGfBHUQLMUys1rjSe90C0d3i9q3ciIDDPxSH19xIPVz7RRhLj1+1SD4RgsFxOgjOOYNq67XsqQyEvGIgpTcYXhsKjXd0YCLt97VZIuuhg2jA6nSZmDrtFzeRw1iQ+ojuNo5ih5K8+Qb6hjOtxxHZKVJGW7jJSy/l5XuqiKik/18ULyBa6ZuIYrxq/o+jCtqzoXDV3EQ3MPYdgGyXKS7dHt54Xo77mEAbF7jXE+bi79dJO5ruSVZYdUsRoJsF2XlWICj3e9Ziitum3dgL3QmH4d8Y6cOqmr13CZTERhtSBZbpBC6SRnUicpAr506Esbkrqm97Du2Xnrrbey44IdTY0SBARLmaqe2Eiov0HVagMbC/NrEaVJj8mNa/ZeO+cP4xuV5B2FrGeIVyvrUSdFV5BSIi0X6bpVUqd6qGaDJQHFxZ+fx6+pGHqQV0au4Wj0Uu489M9YUuGX9aG1yFDntGWnCFdHUtcwH6jVtKxJHCjTeNE3v/nNbcSuXTdw81+KZp06k/GoaNO5qzWetCISiXDLLbdwz/33dE2H1+rfeqFVKmcs7KVgCtIFCbgsn3yJe++9t/76xu/Tvn37gOr6WCouU6z4MFcWkY7Jah6mPJLVnGQkrHDJjNrWjR0PKuyakDw/66B78zjaElNr+9VmI2Rn4351vuy7reNwXAfDMbBci7An3ETkXsm8wpB/iLg3zoncCVZKK1w9fjVFu0jaSDfJerjS5WT+JCOBEfbE9xDzxvCtNUxZrsXx7HGeTTzL3vherpu6bsMo8pbwFrZFtnE0cxRN0dgR3dGzU3aAM48BsXsNsVpeJW/lz7vNpVKpoAQmkFax63vm01XduaGgQAhJ2kgglWbpiWokwm3rBuyE006/0pwmqx2+tYLxk6tOR02zGgqFQlv6tZFEdDKg7+TZ+fl//nydnP76z/96dRyCes3dUpam7sxOaCzM91HdgAOKw5sjRQ7Esly9lmq1pCBpqZRcBRCEGhTVFV0BBTyKh7WsC9K10JCYiVl2BWwqtuS7iwYPl8fRr343U7uvwbIsLHlPV9HeftKvfr8fTVUpyXJ7o0SPbtlWdNcN7B+1BgOtQTdQEe1NNp3GVXP/aNSpq5mJbwbdpHJq6+O5wyf55gNfRxp51OAU0jFwK0ny+Tx33XUXd9xxR/1hoVLxsSUSxU69iHRNhsMwn5IMhwUXbmkndTVMDyks5tLY6gpTofNrv9osztZxlKwSK6UVhBBIJKpQ62K+jnTqZC1v5Rnxj5A1s6TKKSpOhYngBPuG91G2yjy29BhRTxRVUXGly2xulongBNdNXdexfGA6NM1FwxcBNDU2dIMiFPYN7WOhsMCQb+i8khE5VzAgdq8RynaZRDnBtsi282pzAUgVJNrwfnBMlrOSGa9ECIFpS7IlSbrgcjIp8XsFuibbDOQb0doN2AmnI9pbQ680mVcXTESpS6G4na7fg9RBLwP6hku0SGg0ktNaQ8VckjqZ+NBv/HpbrV9TYb4nQuXwI/z7qWXeFssx5qnWx2VslVfXUq2dUCN10nIRouosEFJdhnUbBYOk5eOrpZ0cSvl5Jm1Xr3PyPvjifU3j0DrMx/Ly8oafQ7lc5rafuI17H74Xp+DglV5KNKRd+yB3/Yj2boTG+ZgKT/GR36lG1arNDs06d3/zqb/rOI6NdOo2vol127ZOOnWxgODpxx6srg/Vi2uX1+49hLSqDw73HbqPH5v8McqVAGPBIfaMu0ir2lCyd1LgSypsG1UI+7tHTVYrCQKR848MbRZn6zgsx2K5tMzFwxczGZpEEQq6ohPQAhzNHOWZxDN1YpczcuwZ2kOwEuQ7S99he3g7o4FRpkPTuLjM5meZL8yjKzplp8xkYLIrqYOqg8iwvz/f1hrGAmPsH9lPzBs7Lyy6zjUMPvHXCGW7fF4aS9uO5MSqRAgNqUhemJPkDYeSCWVDUrEkUlb9W4O+3qSuhsZuwExRMhpb/93pivZC767RGno6VGxA6vpBK6nrNA5FEYyvdWeqwSkMS9LI62qNEsOVCtdln2P38e/hT76MOZ6hYCvMGR4s2SvlIZtInSYlITPDLr9J2VF4thDga+koD2fC5LURFN8weJPQEEltHEendHg/DQZqUCVdTtfJUBOpq6EjuavdRG8y1A96kex1rJO7shoFtdgUSb3n/nu4UbmRvTN769+rmrBwfzfRbNvWSadudnaWfGqu6qMc2YmVeBpZSaIPXYTjGAjVpuJxOXGyzNUXTLN3SifkMevvD/kEV+5Ue6bCzlcytFmcreNwpct8cZ7tke1tnahQdVh4YfUFDMdAExqOdNgS3MKu6C5Wy6tUnAoXxC+oy37sH9nPUytPEdJDTIWmqpaBns2LNW+E/SP7z/g1B+gPA2L3GsGv+atEZJM4WzeXGuZTLokcuJUkSIeAt/ozXQWPLhj2VWUTWsVVN6rLqInmZkqg6dWC8TMh2tvYNbphmqyTQ4WQrxmp69SF22h3tZSFrbrEqwsK5SRjyaf47dBx3jyWZ+dsAilUUlqQY+USnSy5WmG6JiiSsGsz5KkWxRtagP+9NMzD2QjfL/nWr+O0e8v2Q4Y2sraqkezhwPDGEa4WcudK+iJDG6GxVnPjCLBsJ5iOUR/HU996iqt3Xd3rAh3R6mHbTaeuRpSlkUWaGdziAm55GeGJoMW3o4UF0jQYFQZX7vTg9whadXcHpG5jnAkP227jKJgFEuUEilDwql4inkjX63cidQuFBYZ9w1w1cVXHcoMR/wjD/mEylQyaoqEJjdHAKD7Nx/7R/czn55kOrzuTTIenGQ2MDqRFzmMMiN1rhFMR4jzbN8lM0eX4ikvQC8jqoRzwCKLB5sN1s6SuhkZ7JdMxMESz92ujFEivjtMaWrtG+0KjQ0VoCkVPIHT5mkbq2lElEx5V4i7Osst8gt2Zpxg2c2TDGTK2SsY3hlBUFNcFVje8os8DUTODV6lQkArfzoX4l1SUK2+8k//xL3/R+S4aHCqkJtCChQ3HMT09TTgcXteWa0CNDPnxs2dmTz8fRBO5W85K9JgHocueZKgXDMcgZaX4N+//aeJ6nD/+xB/38a5mcleVZrFxCg7ZYpa5uY3lWRrRWhvYa33UiLLQg7jlBK6RAunilF/GM2php4oYC0n2v++t+D2bK1AfkLo1nAEP227jSFVSFMwCl45cik/zsVxcZrG4SN7MMxYYa9qz2mqZ7QqLhaox/dUTV3eNqqmKyo7oDr41/y1WSivcuPXGevPDRcMXsSO6o+08GpC68xsDYneW4GzYJE1b8uSJJJaS5ILR9U3SsCRzKYeTq5KKKYn3uLVTJXU1xIICV7E5nkozFPQxPTLSMTLUreO01iFYswnbyM6pE7waOKUFvGMzoExgLs+9jqQOhjSbt0bz/OzyXxDNn0RzykjdR8k3zLG1rtYhoVRjaz2iMQJJTHOIe11cBBXPEH+9qPJAJsKrleq8XNJHJFVqAs/wKG5Zw8okeo5DURRuvfXWtprDxu7Xt7/z7U0WWN2IYB2OgVNaYLWSQwlW56PT92qjNOjpRYDXHCpGpqv6h+n5ahcv/aWfa6itj061gVJKFO8QQvWSKkhCAcn01q2Ew2GKThAndwwcA+EVeMckTvYYxpLByPAI+/dvTgtsQOrWcAY8bDuNo2gVSVVS6IrOtZPXckH8AhShcNHwRczmZ3lq+Slm87NMh6ZRFbU+Dq/ipWyXOZE7gUCwd2gvl41dRlAP9ryHieAEjlv9Pm8NrYuS64qO7vnBc174QceA2J0FOFs2ycPLq7ywUEZ1J5DlELmoRaEiKBqSQkUS9gvGYwqW1ZlMnC6pg+rha4gUQ0EfijNEtlT1rGxFp47TWofg5I7JuvdrP3ZOncahh12ks4hbHkPxTOJY3bszO2EzpM40Tf7kEx/jTeEiH3r7Pm7a9woxzSGSN8hrfjLqBIqisVHPp6Zp2LaNT3EZ0W08QkI4xoOrcO9KmDe95U7+57/8edN7Grt5OxEsoVcjdW5ZwzEjCI/Vs3sZqu4Hd9xxR90VopHU3fb229i3b1+TG8OBAwe4++67u19QgB52iQSKOEUNxTOJ27HDpTtaSd2piEGrQaXqjFEaAzEOajUtu1H6uYbG9dFaG2jZVckd6VSwc8eIB6FiQ6IM19/0o9z/9UO45USV1E16656pSPj5n//5rl6xnTAgdVU40jkjHraN47Bci9n8LAEtwExkhgtiFzAVmqq/XgjBtsg2wp4wTyw9wXxhvhrJKy0T1IL4dT9743sJ6AH8mr9O/DZC1BtlR2wHcSPe1eh+gB8cbL5AZYAzijdqk3RdSabo1lOai4UVDi/lGQmEuHgqyELK5dtHHFZyLkLAeFQQ8nWPDp0JUid0QaKcwKN42DUywlBYIV2oCqdW77lb3+w67v/m/aQr6Y7er/3dBKwaq9U0WaqInZsH1UNoZBf91LHVxqHHNXyav4nURSIR3v3udze8UrLbV+Gqpa/zD/uO8fEdc+xNP4kATlheEp4Yrh4m6NNRhMCwgS4yLwqSfZMxdvoMRnWbE4aXv8hM8bcXfIDfObqFh5NhHKWdGjZG1g4cONBxHNICczVRb3AR3tiGn8G+ffv4pV/6pRadOoe9e/e2vXbv3r3ccccdhMMdaiAbGlcmgyP1+VjO0Te560TqeuHIkSNtP1sfh421OldvcAnHRpienu5wlWZ0Wh/CE0UJTLCcrTpCTMXASjyFkzvGZdsU3rxH47LtGldduot3//APEYspTaRuZHiED3/4w1x33XV9fQ4wIHU1OK7DbH4W4RMYK6fnYVsbhy1tFouLXDh0IQe3H+TGLTc2kbpGDPmGuGr8KhSh8HL6ZYZ9wwghuHj4Yq4cv5J9Q/s2/dlcNHwRFw1dVE/DDvCDi0HE7g3EG7lJLmYkryw57J5U0bwJXk4kUZxxtgyF0VTBnknJUmYt9Rqsmn53w5kidXpcQ1f0+uFbjdS5dZHW1FLvWiY1qFKmTClZYvvO7W2/31BjbY1E2E1psmqN163v/nfc/fnP4hQXuO66dqHc1nFIC972lrfxhS98AVjXPLNtm7hm85Y1AeELA2Wml9PM6xbLpobmGyclSwhNoCsa+ppUgFeHiglC9SGd9ep43akw4zXRhEQKhS8lY3w9E+E5LYarC34+tBtpVYVtjx492nP4q6ur3H777dx3330UKoWmiONtP3ob99xzT1NDRS312WjH1oi81a4b2A01j9OaZ/Add9zBXZ+/q922ba3mzrTpyzFks6ROSsmhQ4eaftZKTmFd5+7Kt7wTy+lN+Dutj5JlIjQfdvowl28TBAMaXsVB2usdwl5dMBUXTMQEu6e2c+Flv8zH/uBjGEsGv/effo8rrrhiEKk7jXHk3Tx/8Ht/gEf14PE2P/SU7TJlu0zFruBRPYQ9YVSh1mvmAMpOuT4ORzrMF+bZG9/LVeNX9WU8P+wf5s2TbyZn5jAcg63hrewb2rfp8dRQ63AdYIABsXuD8Hpskqs5F5+nPdJWNiWvrjjkypInj2cYGl7FKo8T8YbQ1OprG43qF9Muk3Glo7hpTU/sVEhdjRA0kqFR/2jT4VsTaU0XJCuZ3qK9tcNXljsf9p0sro4cOcL+/ft7Oxg4BuMNOnfXXNuZ2LWmX2ukDmD79BRbsofZmniSH9p3jLhm4wApSyPlHWfRrB7otmsjNIG0JdqaibYrZZ2UCdWHqnrxGVkCsowtNJ4q+/iXVJS9b/l1Pnb//+zqYfvggw92/fwAHnnkEbDPqGIAAG3oSURBVMLhMDfeciP3P3pfUxq55rzQ2FDRKk3TiFNpXGkkKVumt7R1I9eJuWNg5+cw1G1NjiGt2CypgzV5kYZ0dCdSV4XkR972Jka2bGUpa3cVle720JMugFNaxsm9ymhE4PMpVCqdCWLFLjNXPI5f99fTrxdffPGA1J3iOI5njzNfmGdnbCeXjF7CiewJkuVkPYW5UFhACEFQCzIdmiZrZlktr+K4DiP+EfYN7eOb89/Edmy2xauRuvnCPBfELuDqiav7InU17Izt5MrKlSzkF7hs9LJTEtkeYIBWDIjdG4DXY5PMlSUvnKweRDsnVKbiVRkSgJOrDrmSJBjIcyJdQMuOo7hh4oHmg2VDctegJ9aJ1DVGcmqSHo0/u/POO/uS0KiRuyUt2tGhovXw7Vbz1KnI/e6770bVVMKT4Z4OBl6N7jp3wDXXX8P3jj7dVlO3zWtwUyzP2x//faZ0A8W1eFVITlQ8OGup3dG1BgihCmxpI22JdFqJSk1EOIeqqBhulGOjb+H40GX8x/s/h4vg17RQT2mWfor8C5VCG6lrRas0TavX7+k0rgDN6fCGcTQS87s++4+Eo8Nc9uZbOzqGnAqpg+bPqDupq+LCfXtRVdEkKt2IRlI35h/Hs5YKLxkSVQUn9yob1W02rvPxwPgp6TgOSF0VtXGslFe4aOQi3rLlLUwEJwhoAb618C3ibpyCVUARCjdsuYGp4BSqomK7Nhkjg+EYjPnH0FUdXdH5zuJ3KFgFUpUUe+N7uXri6k1nKxShcMXYFeyM7hzUxg1wxjAgdq8zXo9NUkrJ0fkyf/7//R2uXeanP/CLLA97GIsKNEVwMilRtDxZM8O2eAyjEkZRAWnz0Y82E7FO5E6BNj2xU0m/Vo3X+2swiAcVds2M8HCDrhq0H76RSISZmZn6+xxnA2Ih4OuPfZ0f/tEf3ljSpJPOHRKhC47MH6mPI6w4XB8p8PZ4lstDJUKKi5nVKE7uxFZ0VjtYsQlVIDSBJrQmUqe4NgEzyy6/SdFReKbg5750jKkr/iN5Nc6Qx8ZFgIAXZ198zUWUa2iUpmn0+q152J5q40rndHgVbQ0z2SSPfP3z6zp3azV3/ZK6Th6utYeCjUhdDTVRaSFU9Pg+5pIufp9L2CfJO4k6qcsUdKofaFXAezoO0kg3Xcvn8zV5s7YV5pubk3aB6oNXxskMSN3aOAp2gbgvziUjl9StrrZHtvNK5hUWCgu4uLxp/E1sDa93lmqK1mZivye+h6yR5XDqMBcOXciV41eecrTNq3pPraN3gAG6YEDsXke8VpukK6v1cBF/Ne2azEuWMuAYaXAMhsJVDbqVHGgK5M0Cqiez3mCwVmtrWZ0PsFZyNxRsF1fdLLp5jfbCUEipF/C7gKK113AdPHiwrg11+PBhvvrVr/a4iSqJKBslrLTVHxlq1LkLTuGai+hxlUquyH4ry01TeW6O5RjRbSTVVOuyqQGCadPB52tP0zSnXzUEkojqECsvIYRC3hPjU0sjPJSJ8J5f+U9c4vHgupKXnj3OPz/+NGhe9LDLQ488+Lrq7cWCAk0Xda/f6sNC1cM26o02db42ijB3Q890eDc06tzlYDRmkKhsPlJXw8zMDOGxMIYwcAourhVE8elIxwTXBlVHqF6QblPNpmuVcBJPc/n2d1C24emTafx+ky3hcSqGh6AXdk2olAyXogFbh3rX5XVa5xabI3ZaTCNRTjAdmz5vSF3UG60+ECp638byjeMI62HGA+Nsj26v/15XdS4cvpBkOcmOyA72DrU3+LRCVVQuG7uMEf8I26Lb0JWBpMgAZw8GxO51wmu5Sc4nJS/O23g1wcyoQiovq+fyWs2PrgoCvuoBlyxlUWRm012jNXK3kHF5KZFFeLxYqWLfpK5T+rWT1+hGqKUBQ2PTmM4KdjZZj9QdPHiwrmN3+PDh3v6tLTZhx48e7/sePGpV00yLbGHbyDA3iKO8zZtkh8/AJyR5R+Gk4cFusfdybLv9NhrSrx7XIWIk2ekzyTsqs7H9HB+7huPBC/irr35y7Q3Va7700hEOffnzqKEpvGMzSGcRK1VsI0O1BgcpJf/9v//3jnpxp6q3B+tev3p0FKF5qh62p9CN3Crau6noxxq5K5oWyeUc47FTI3UA3zv8PaRX4ubDSLwgszjlDIoeAtUDroVTWUXxDpEuwrinmpJ2jSR2/jjjMZeF8iLhEGCOI6SHsim5dEZjy5DCuhCB1hSda8SZIENaTEOP6+eVraFX9bJcXEZTNCy3WraxJbSl5zw3jmM6OE3GzHDh8IVt+9Z0aJqrJ65mS2hL396mfs3P7vjuTY9pgAFeawyI3euA13KTTOZdXl5y6rVvL845SDprv2WNLAU7Q9x3qlIg8v/f3p2HyVWXef9/n3Nq33vfs5MFSAJhCUECSEIyiiCD6AiOo46oM/pTYUZleGbmUR+3YXQUddCZR+dxVxQEAUF2EBRwAUHWQAJJutN7V1fXvpxzvr8/KlVd1V29JekkdO7XdXFddHWd6m9VJV2ffJf7RncNg2Zh55tR9r45P0Tl8mutXqOzoTsSnHXuidx/9xPYZh6IEY/HWb58OVBcir777runeR6Te7/+8Y9/nPXP/9H//DdbIkNsa9nLBm+WoMqRtyyGCw4ytsZUZVEMR/VfN83QMBwQtrJ4nFlMpZFw1fONPngwFuTyN/4tTqcTs1A9U1N+fppCdw6B3oqdKb0ftQ+YaJpWs3DwwYS68mM44miOMZQZRplz7zlZOoBTq2jvrMeg5zFcQ5AJYOcj4NNmW52m7E8v/Il7f3MvdtaLlbWwYk9jZQb3/wNJKwY7Kw8odG8zChhN2pj2/v1yqlDuYPC6ZUt4odtJf8xmSZNBW93sBnMowtBQZghnnZPCaIEm79z3bR2xEkzKpjvRjaEZdAY7q0Kd3+lnODPMqS2n0upvJVlI8tzwc+xL7qMz0Flz9m7i84hmo3QFu6qWWUsM3ZjVTJ0QrwVHTbD73e9+x9DQEFu3bsXjqV2Hx7IsfvWrX026/aSTTppVLakjYT5/SaZyih29Nqal9h8wAL8bbBuYMFtU2tB+oPXdShvBTZVnZVM99+ZzNRvVT2fi8uuBzKiU9j51hAIUxoaqepmWTDzZWD2IyaFuNnr27mGtP83Z4QRb6+O0uk1QEM05eJUASimUnZ3yeofDgdfr3b98p/A7FY0uC4dSGJrBndEw98XCbDrnI3z/V/9Zfh7Lli2b9Fh79+4lkUzsfx6K/EAPuqutqpdpLeXCwXfdRSKZPOhQt3fvXuo76hnLj2GOjWCb+apev7NScQBnYtHe2So9D5/LQVe4joFYsRRKa4Rpy/RUGs2O8psnf1M8Va38WPEXsJLdFfdQVa+rnRlkeTPsGoKWMNiZgUkdDFa127wyYLGsxZjVOA7VDNdQZojCaAEzNnmGeCZHKtQppdiX3Ee9p554Ps7e+F7G8mPl5dfeRC9rm9aypmENuqbT4G3A7/Tz257f0pfqm1TmY+Lz0DUdhWJV/apZz8gJ8Vp1VPwJf/TRR9myZQvZbJbu7u4pQ1omk+HCCy/kda97HZFIpHz7VVdddVQGu/n8JZkrKJ7dazKaLB5oKDF0DUOHykmeyg3tBxPqSiUbdFuv2ah+Ogez/Fr5PEp76oKuYFXpjcrSxVOe/jyAUNfuynN2OMG2Z/6DDy3P4jEUac2gJ++ivJddy6EZnkk15io1Njai2xbuQpzlvjw5zeCltIc7h0KsPvNKPnvv/wPgmf/33fI1pVZpEwsHJxLxSc/DKkxuVF9LqV7cl6770kHP1P3stp8RaA5w1oazuOaqawAYTY3XHZx4WnaSCQdwdHvuQX9iqRy3y6CtTtE3atMfY1bhbiw3xs6enSQHk9h5H2iJSSdca+ls0HC7DTyOAu5W16QOBs1hnfqAVi4hNJ1DuWzZ5G066kJdqpAiZ+XQ0NA0DUMzcOgO9h/FYiQ7QtAZZFP7Jp4bfo4Hux/k+IbjafQ2smdsDyvrV7K+eX3VPwYbvY2c3nY6v+39LXvie4Di76p6dz0j2ZGq59Ed76Yr1EWbv23Oz0mI15ojHuxisRjvfOc7ufrqq/n0pz89q2u+9KUvccYZZ8zzyA6OrWx6Uj2gcUh+SdY5FjGa1IjsL8j6wj6TF/ZZ1Ps1lJq6ZajhN6o2tB/I85hYh6vYeH1/o3rH9HXuoPrD90CXX6eqi1arrlrNcidzCHVPP/4wWyNjbI3E2RBMEzQsCkojahlkNAfYGnahIkoqG2Vlpwh3xTIlHUYKPZdizPBxU6qJB0aC/GnYjULjKuf4+1KrVVpluy1b2Zheq8bzqG5Ub6V6eeflb6t5YKGgCuX3w11wU1Dj/woIhUKcd955k1p8TSxuXJo5TQ4muePnd+C91Mvq1aur6g5WnpadqPKgROkATvHP1exNVSrH7dRoq9NnFe5KM9laVsNKWej+IObIs2BlZvz5uqbR2QB74gN86vOfqvn3/HCHutKp0an2701lPkOdZVsMpgdp8DYUZ7aVImfnSBVS7N8NjNfh5bS202j0NrKqfhU7ojsIuoL0Jntp8bdwUvNJNQ8otAXaOLfrXDJm8f0aTg/zaO+jRLNRTm4+GZ/TR8bMoGs6q+pWHdAqgRCvNUc82F1xxRVcdtllnHXWWbO+5sUXXySVSrF8+XKWLFkyf4M7CMl8koyV4fj64w/6l2SDaxHP7lUksyZhn47fDb1RxfIWneG4mnLZqfThezAb2msVVx1v7aXIjXXjq18yZbibTZ06mP7UZOnDN+QMlUNdZY/TiXXVFi1aVN33dBahzqEpTg6kODuU4Jz4T2hcUpzxGDUNXs26QNfQnDrYVIe68iCqw51uZWhwmgQdNmlLpz+4nOfq1/JHZzPf/83t1eF0po4YJfuXLeub6nAXPOQLE5ebx8NdsHE5LW2T9xLlrBxDmfHl8A999ENcd911QHV3jIkqixvXKgVyzz33sGrVKjRNK4e70mnZiXUHJx6UmO0BnEAgUA6+mlMj3BFmw0kbeODWByb9Y2E24W4sN8ZQagzNqsPpcKD7WlH5Max036zGYymL3njvUXXA4Gg8KDGWG6PeU8/2Jdtx6k5sZRf3U9qF8p99h+4oN7pv8bWwumF1Odyd3Hxy+Xu1VJYi6Qx00uRr4omBJxjKDJG1sqQLaZaGl9Lib5nz8xLiteiIBrtvfvOb7N27lxtuuIGHHnpo1td99rOfpa2tjaeeeorXve51fP/736e5ufYvtFwuRy43viwVj8cPdtizYiv7gBtLd0dT7E300BL00updxHPdxYLDjUGNRNYmmoT6gIbbqeE0ai87VS5bHmioq9VR4sUXX6w6mPDTG35CMBji9HMuBBZVhbuclTvo5b5SqIvui/KLe35Rvn3iIYDKumrA+EGBaUOd4jhvjrPDCc6PxGl353HWONWq6Uwf6soPZxEgSYNbQ8dmMGdw20Ad98dCnP36y0mpNH7dP6kuWk/P9K3SioOoWLYMtbN9y+SDEKXnZKV6OeXszfTHFG11qur9GEgP4KxYDq/cdL5o0aIpS0iUAtVU9d3i8Th79+5l8eLFwPhp2YnL5KV/LBzIQYkrrriC6667Ds2psfXirSzqWESLv4UzTzyz5v2nC3elUKfMCGvaQhjtQR66O0Vs+JUpl7GraJQPSkiom6FYeiHOSU0nlX+H6JqOQ3fgpXZ/Vk3TOC5yHMPpYVbVr6ItMPvlU03T6Ax2Uu+pZ098Dy9FX8Ln8HFc3XEyWyeOGUcs2D3zzDP87//9v3n00UdxOGY3DIejWCLgwgsvBKC/v5/Xv/71/N3f/V1V+6ZKX/jCF2a9xHsoBVyBKRtLW7aiYILHNflDdCSV4re7hrDMEHpDPck4DMVtmsPFzhF1fg0q/vFa68MrUYjPuZ1TlSk6SkxVQiSRiHP/L3/MljddTincoeerZoYONtTd8fM7Zrx/qa7aaFLR0rWSt1z6Fu57/D4y+XRViKh3mGwOJzi/bow1vix+3SZjawwVHGQn7POaTahzajYNTgu/bpOydf4YD3BfZhmPxCPEEkMYfp31hTiN/kY8TD4YlEpNLlhcPQgmLVuWD0LcfXeNgyKK005cxEhKK8+koufLRXvr3HUH9H7MVLR34jJyxK+V6w7GUoqG8PgM8EwHJUplWioVCoXyDHBHawct/pYZP6yn+vtRCnUntIdY1W7gMDQ+8Fdn8oUv/HrmF0Jj0kGJuXqthLq8lUdDm7JN1kzPI2fmcGrOOfcwbfW3cmbHmZMKA8+Wz+ljTcMaFocWM5YrHsIQ4lhxxP4J8773vY9t27axY8cOfvnLX/K73/0OgPvvv5/nn3++5jUej6cc6gBaW1v52Mc+xi9/+cuqYqiVrrnmGsbGxsr/VS7hzaepTl7lCsVWX0/vtTAntI1K5VP8fk8fZsHDisZ60jmN3qhNY3C8HVhJoVDgs5/9LJ/97GfRMWmr08mbip1DCaLZg2vnVJoZqgx1M5YQQfH7h3+J0wF7R/J0xwerZobmqrz86grx8D0Pz/q6Or9OXUAjmrBxNDTwxguLHSWcpsU1F57Cvyzax49W7+Kfuvo4KZAmZensyrrozbvmGOqKRYSXenJ0ugvETIP/19/IB15awkd3dnB7v0ZC8+Ns7MQIOAi7wvS92sd//dd/TRpzLBab+glNmHGsXLZcvXo1f/d3f1f++tJLLy3/f7HuoIbLoZXfjwMt2guz68RQa2+jysWwsyNEU4pdw8MH1FO4pHIGeGJP4emUwl3p70dfPI4yIxxfEeoANm3axDXXXENDQ8Okx/jIRz5S/J/9oW7iQYm5OFQlTeY71MVyMXqTvfSl+uhJ9JA1sxSsAjkrh63squfR7m8nlosxkBqgL9lX3vM2mhul0dc454CmaRqt/taDPsHqc/poC7TNupixEAvBEZuxO+GEExgYGCh/0A0PDwPwgx/8gHw+z/HHHz+rx6mrq6NQKDAyMkJra+uk77vdbtzuuX+IzIdUTvHiPouBmI2uwXBCpzVS/IWTLqT5c383Y4kwS+rrcDkM6mu3PJ0kn8/zla9cixH0ce6b/ooG6ghGapeMmU6tDe0l05YQ2S8RHyMVe5WUyw95L80NwYMKdRF3hFh/bMafO1HYB8PpKNGkxQa3xXsbBjm/box16WFi9WOMmQa7s65iK64pTBXqnJpNk9PCq9skbZ1H4wHuioZ5NB4gbVd8QFs5UAMYvg6sdDO9r/Zz262/qPmzHnvssSkGMfPewMpG8F1dXRO+p1EXzDMwEIW8l47WOnRNx2Jugd/wGziCDsyEOWWom9jKrZLKx7CNKLGUxhL3/lBnMGlGbjoT9wbONZw6HeByJ9nTn6UhEOa0FSGWNBmTDjds2rSJ9evX8/a3v73q9lNPPbUc6v75U//MysYjN1M33x0llFIMpAdQKE5vPZ2AK8DLoy8Xb1MKXdOJ5WLk7TxBZ5A2fxu96V6avE1E3BF0TWdvYi8hV4iMmWFDeIMsgwpxGB2xYPc///M/VV/fd999nH/++Xz3u98tly4xTZO77rqrXKcuGo1SX19fdd3tt99Oe3s7LS1H91R7rqB4bq/FSLK4rBpNKnqjxf/Pmhl2xl5ldCxCxFWP3z33X/aG38DwmSxucJPP+xmIW0xsVD+dmTa0z6aBvObUGEj3sbz5OOx8hMG4DYZ7dnuW9ptYb68nOYv9ZxOeR2psFxtTz3Pi2Ks0pbrJtY2QthQJZ4RXsjOHxMmhThE2bOr3twkrhNr59ksFHogFeSXrplYl3NL7URjdB1oLDz76HHN5Pw603l6lnFVsr9UScWHnIwzEoK1OzWmavjRTN12og+pWbrWeh8edpd7XTirjYNSYQ507au8NrDSatMkWwOUAv1vDUpAvKHLm/gGgSBWSpK0Ex7UGOXVJhOawNuUsTmVYLrGUdVTM1M22o0TBLr5OlUuolm2Rt/L0pfrKoc7r8GLZVtVYRrIjuAwXp7WO90ztCHQwur+3rYbGnwb/xB8G/sDS0FL6Un2sqFvBxraNuA03lm2xI7qDp4efJuAMlHuyCiEOjyN+KnY6yWSSCy+8kO985zu8+93v5sYbb+SWW27hoosuIhKJcOedd3LjjTfywx/+8KieareVYteAxXDCpiWsoesaIS+MJBX9Y2mi5m5isSCq0EhDaO7/sk3kx3umNvnD2H6d7mGrolH9TOObeUN7zRIiFUp7n4LeIK3+ZvBp9IzYM9ZVq1SriPJMP7fEpdl0jj5D28jvWRJ/iaBdAF0n7gjwihkGq8DSGuUSHA5H1SnQylBnmCYtLgtfxezcndEIp7zrGr798PVVj1N5YrMUhs4+/Wzuu/0+MHpJU1FjbppwFwgESKaS5VDnKXh54wWTy4/MJGfliGaj5eVXfBr9seJBm8bA7ELibJZfNU3jkksuKbdyqzRxBjjgcTNqjNe5m024K4W60t5AzRGAilPEuYKiYMNxbQbxjGIsrTA0CPl0wj7wOHUS5gix/BBtgUY6QvW4HHP8XaFBT6oHza2R68tNuXd2Oodq+dXV6CI/kp+yo4RSimg2SmL/iel6dz0hd3HmrDfZSzKfZCw/xklNJ2Eqk91ju1EoOoOduAwXlm2RyCc4s/3Mqg4Nhm5ULadu7tyM1+FlR3QHS8NLOa31tPI/Bg3d4PjG4wl7wiRyCUKuuXcjEUIcuKMm2DU1NXHBBRfg9Y7/0nQ6nVxwwQXlJaYPfOADHH/88dx4440MDQ2xbNkynn/++XIrqaNV/6iie9imPqCVT+W5nRqD8RxP9fYR8QZJJVuI+PRZ1b2qZPgNxgrVByXcTo3WMOON6u3p64nNZkP7pBIiFUqhzuv2sXbJ2uKyiwYtIcDKzyrcTVVEebqfC4oVnhznRooHIU7Y+T/o2JjOEAl3PUrTsZUCawgMF2aNbNLY0ED/wEDxeeigOzVCmESMAsqA3ryLH0XDPBgL8kq2uLy9Xp9cebd0YrMyDK1dsZb7uK+qUf1M4e6cc8/hnt/eg+aEi857M6uWr6pZfmQ6mlNjKDOE1+Ud31OnFQ8O9Megf4wZZ1JnE+qgGCR8vsmzV1PNAFfWuZsp3FWGugZPE4OjFugONN1FMquIOBTRpGJxk87yVh0NyOTBYVAOb4PpQWLpAVaEDmwvWuVBiVxfDpWb+8zpoTwogQLdpdcskWPZFt2JbkKuEJvaNpG38vx5+M/Fg1S2xer61XQGO3lu+DkG04P4HD7WNq0lWUiyO76bxcHFjGRHaPI2sTi0eNrxuA03p7WeRpOvic5AZ82w2xHogFluJxFCHDpHTbBbv349v/zlL6tu8/v9k27bvHkzmzdvPpxDOyAjcQ2HBmMOm139Fi6HVlXjLWflyDCEnvLjKNTjd+v43HMPdUbAIOycfFDC7dTKYeLL3/gRVqqXq6/+BE6nk0KhwLXXXgsavPv/e3f59Ot0lf9n02t069lbMYzxDy1d12oEmtrPY6oiyrV+7vip1jhrfBn8hk0WgzFHAIcrOGk/j7ILaEDBAk13oioK4fr8xSPGbsOmyWPjwSJeMHhoLMg9o2EeiwfIqZlnljRNmz4MzSbcafDrP/66HIaWL14+55no0vvh1J2TDkoUD1RAzwjTvh+VpXJmcwBn4jL9TDPAswl3lTOOIUcTwwmNhiAUBp9Ed0dI56BgKwIejSVNBvr+18lXsYPgYE+NVh6U6PJ3HfFQ53P4yA3kQCseSqj8RzDAQHqAVn8rZ7SdQcQTASDkDvHnoT+zLLyM1fWrMXSjuCcu2UvQFaTB20A0G2U4M8xQZoi0mWZD8wY8jpn36LoMFyvrVs75+Qgh5tdRE+wWkmzB4pV+jdEkmGYBvxuWNo9/eJVmIoJuF5pZh8uhE/TO7QN8YnutmiaEiaqZuwntnGZT+X9iiY3KmbqtZ29lzeo1Na6q7oiQmzD5NJsiyqtXr+btb7mY4d/+nI2ufl4XSlLnKB4BiBYcDKpiAeElzsCUm7SVXcBpAIaruOvKLqCh8JpJlnlz2LpGT97NHYMNPBgL0p2b24GbyuXwWmGoNOs4Zbjb/37k7dwB76nLW/kZT43qulY1kzrx/Ziqw8d0KpfLZzsDPF24q5xx9OlNJLIay1t02sMaKh/DysdY1gL9YxpLWwz8nsl/dw5lqDucy6+D6UEyZoaOQAcO3VH1PGKpGLmBHHbGJmWmyFt5XEZx9jhjZrCVzQmNJ5RDHcDi0GLaA+1VXRtchosl4SXlr+s99axrWsdven5De6B9xtk6IcTRTYLdPFAKLLs4O4Iq1lWLpRV1fo1kNsk3vn89qgBXvu9K3IG5vwVz+vCtCHcDcehsUNOefp3JxF6jW87dyknLT6qaqZtsPNwNjmnlZcDKMFQKdeXZRODqT3yClsIgXaN/5uLcEwROiDI6UjzVmossYl//ALpTBx1UwZ7x5J3DAKw8HodBg57FjQnK4v5sHffFI/y2z03B1otBJVc9C3XhhRdy++2313zcWsvhE23ZsqW4T67WzJ2mah6U2LFjByeeeGJFp4/i6eRly5ZNmsnTnBrDudmdGq2cSa18P0rL4dHe6KxDXeVp2FqdSqY7+Tox3AVcoPsiOOuDJFJe3KqRvFNndbvOoiadfEUKXdKk0RwxqAsc+lBXeVDicC6/9iX7cOrFmm97E3tx626iuSgtvhbC7jDJTJLCcAFzzGRRYBG9yV46gh04NAcD6QFWRlbSGZjcM7tWK66JloWXEc1G6Qh0TFmzTgjx2iDBbp5VfnjlrRxp68BLNsD4AYM51anbHybyJvTGLGx97u2cKlX2Gj1xyYkzhLqSYrhzOhSGvx3UALF8rByGSoEFoG7/UmvXzR9ijS/DoqYIpuEm6a7jlWyxc8gyn68q1KlpGkIA6Ci8hQRLXUlMHOw1Q/xqLIx/w8X8vz8+UHXasrRfrtLxxx/P+vXri8+/ombidMvhE4vsjo6O8utf/7o63AXa0Z1DaE41aabu/vvvxzAM7rnnnvJtP/nJTwgGg+NBkYo9ji4fH//gx2f552ry+zGWH6PeV88v7v/FLK4vKp2Gnar93Ewq/34kHDYXXnYJy1thUaiFbEEj5NVpidSYedQ0GmscNDoURXv3JvbOe6izlU1vshdLFf/MKBQhZ4iN7Rup99Tzu97f8fC+h1kcWkyzr5n+VD8dkQ6yw1kM3SCWjfF43+P0JfuwVHHW/viG4w/4EJlDd3BG29Hdf1sIMTsS7A6DOr9O3sqxOzpKyOM56KK9EXcEnz7HcgtWjuaQYtdIDEtpFEatAy+hMct6YpUzTUWKpqBCd5kYvg7uvOW+chi66YYfsbkZ/mZtiB+t3lW11Br1tKLr+w9C7Je389OGOlspdu7ciVe36XKbuDSFpmn8MhrhvtEQf7I70Bta2K5aJr0fs/1wrNxTN+VyeIWzzjqLJ594gkQyWQx36V7czYtAbyU/0DPp/UgkEvz85z+f9DiJRGJSqJtr0d4iRXOI8vvh1cPEB+Kzrht48cUXs3r16gMOdamsIpFV+NwaLmeBnUNxTl6qsXFxGw5j7r+aDlUnhgM5KKGUImflKNgF9ib2Tgp1BauAQuEyXCil6E32EnaHWVO/hmQhSTwXZ2X9ynJpkDM7zsTr9LJjdEd5eXZDeEP58SKeCFsWb6E/2c+r8Vdp9jZXLcEKIY5dEuwOg5yVI6cNUO/3YOfDaK7JjdFnMrEUyFSdNkomhSoN4uYQwaCikK5Hd7VhFXqnvKbWkl+temLlZdOrr8bpHF/CmdhTtuTbP/i/aE4LK91MIR/hOH+Us4MjnF8Xp8OVxzGsGMNgT9aFtb8+XMuEoKU7i6cCpwp1mrLxFhIs8+TIK42dGTe/ikZYedaVfO6e/9kfhtLYmVF0s/6A3o9SqPvby/6WxkDjtO9H5fJyeUlXA2fQRll92Jnmivdj9mGiMtQd6AxwqpBAMwax0s2kMyGS8aFZX7tq1aoZQ122oHA5KB9uKMnkFcmcoqtBZzCeYyQ7wuoOnU3Ljmyoy1gZFgcXF0OdAbpbR5kKj8fDbbfdNuX1A+kBsmaW4cwwtrJpDDWWQ5hlW3Qnu3HrbgqqgKY0Ip4Im9o3TdmRoVRHrsnXxNODTxN2hWnzV/dMdepOukJddIW6aj6GEOLYJMFunlWWbOhsbGRkzJzUGH0mteq7TWdSqNq/Mf/V7lc5fc3pFNzapFIoE68pLflt376d1atXT6onNl3+mKqnrOE3MJ0mkUyWTc5n2NZeYI03iY8sGQsG8o7pT6AqVV5+demuCaFOYRQyZPpfxakpHM1d3DoS4b7RME8mfdhoXOUMTQhDQ9T5tPL7MdtwV3lwZTbvR6UVK1ZUFx+OplD2vlmVQqk0MdQdaO/X4t5AEyvVg8sBeS0y66LStrIZSY9MGerSueKMnLIh6KV8yCFvFuvNLW/RaW/MYXn2EIn4WN3Ujtt5ZEPd0tBSCvkCrlYXylTYORtHwEE8H8fjqX1SNGNmSJtpzu44m6AryGhulCf6nyCeixNyh+hN9dIZ6GRt41oGM4MMpgZZ37x+xjZbuqazLLyMenc9iXxiVrPCQgghwW4eFaw8A+lYVY/OiY3RmyLTP8ZcQ92OHTuqi9lWhIiH73iYJkcTy5cvrzpQkRx+kZt/PjmIJRIJbrrpJi6+9GJCHaHy87BqFYTbL5fL1Qx1voDGGY1JzjZGOaMpQdhhYaExanrpV2GUlWO6jXIKyFUsv2r7Z6cMFPVOk5DDxmsmeSrj4a5omFVnXcm/3VPd3aTy1GgpDIV9lN+P2YS7Azk1Wqny4Mr4nrrZ17mDQxfqJu4NbAmBYTQTbFxOYnjX9OFOKxbMLZXKmRjqlCqGt2UtOg4D9g4rEqM2pYm7RY06bQ059iR2E3R5WdzYdVClQA5VqHMbbvam95LtzpLryWFlLNwd7mKwy3nwOX2kC2kUiqAriIbG3vheTmg4gWWRZeiaTrOvmYJV4InBJ0iZKTyGh5ObT6bJ10RboA1q1xaeUsQTkWVWIcSsSbCbJ5ayGMtGqff5ymHo89d+vvx9G4ilweGcukjrXEMdFDfcl9VoS3XPPffwgQ98oLyBP5dX3Pvw00zV7kpzajz0x4d4S+dbyuF0ul6jPT2VLcAUa3xZzm1Kcn5dnBYtj64UsaperRaaodAMD8rK1g53SpGz8yhl719+VbisLIvdOQwNRkwHPxuMoHW9iS+/9Bhq/+zcxOdReWq08qmqXAwbZpxJPaCDK1WDgOHccO02YbMsYnwoQt1UpXJ0XaMtonP6aSfz0MOZqYtK1yiVM1EiCwGPRlejgd+t0Rwqzt5pGhgaeDwZ9iZ3H5L6bocq1HkdXnqSPbT720m/nEbliy9udneWdY3reDn5MmP5MfyOYu3D3fHdmJaJ1+FlXfO68lK4pmmsaVhDqpBiV2wX61rX0eSbY5oTQogDJMFunuSsXFWR2IlhSOViRHxMWaT1QEIdML7xfYpeo/F4fDx8WTms1D7SObNmmCiFiNRYiv/56v9w9SeuLi6FTiOZTNLiLLA5nGBb3RjH+XP4HIqUqdGbdZCvsdSqrCya4Zky3OXsPKDw6A6ajAJBl43XzjDQsJrvv5Tnrn4HMdMB+x6nVt/W0vNwTNFrFKrD3Vh68vcrO2PM+eAKlN8Ps0bR3nI7sgnhzqcnSCTik57HwYa66WYcdV1j47olAPz+D3+aMHOnoTk8OOv8aE6DkGO8VI5lKwoWOI3iO5DKKY7vKIY6gJBPI+Qr/n/x1OjBhbqhzBAxK3bI9tRZyqIn2YPf4eekhpPKoQ4ABWvq1tAeacehO4i4I1jKYs/YHp4ZeYZTW06d1DbLoTs4qfkkmn3NUhdOCHFYzX23tZgVHZ0GT8O0G9ojfo26QLHO3WhqPMwcaKgrm6GBfGWngFymWDS3tOeuFIzmGiKsbJKHv341p/z5v/j+6lf4WGc/xweyJHCwK+OiL+usGepKSoFOMzzF3l776U4NVyGF0fcKVu9LZGydnwzV81+uN/DGBzRu6PEUQ90EO3funPQ8Gt2N0z4PlYthZ0eIpTU0d6R8e6kzxoG+H5XLr43uyUV7r7jiivL/X/qXF5bfj1POeiMH+n7UMtsZx1K4e/NFF2D429HcEbZddDm6vxlnvQ9lZMkNDWKZLvpGbfpjNiMJRSYP0aSif0xR59dpr5/8fh+KTgyOiIOhzNBBhboXoy/Sk+zBoTkYyY6Qs3J0Bbs4o/0MGjwN5fsmk0mUUgQDQTqDnbT6W/E4PPidfo5vPJ5LjruEZeFlNX+Ox+FhWWTZAT1HIYQ4UDJjN0/cDnd5H9h0JhZp1R2JeQ11UN0pIBAITO5Qke/DWWfMIkQojvdlOTsc5692fIWLl/RgaMWl1lcLbnAUTxQqa3YppHLmzrDTNLlN/IaFD5uHkj7uioZ5eCxIwjIIxp+n1uxcyUMPPnhAp0aLM6mqvCyrOxIzdsaYzsSeqaVOAZUqTx53dXWV34/W9kVsedPl/P63t5NzZsrPIxQMcd5551XvpZzBxH8slOrrTXWaV9c1WsKgOfzotsUJK5q4/75nsNJJcr1jqJzilGUaqUIxtAQ8Gl6XRs5UpHPgc433ay05VKHOWeekydt0wKHupdGXSBVSnNt5Lk2+JgKuAA2eBnzO4kxsKpWa9ePNpvivEEIcThLs5ok2TeiYqBTu9o2m0JwJOiPzF+pCoRCdnePV6Ts7O6vaXTlCHbjqOrFT/RRi+ZqhLpCL8ramKOdHxljhzeHVbbymk9354lKrZmhoDm1OoQ7A6TDorPdAMoqmawyaTm7qr6PjlL/jn+/7GZVBbqZaa8lc6oBnuEoHKpzhJjSHC3Ns5IBD3Uh6ZMqeqdOycrSGQWntnHnBX/LAHT+hEMtz2dsvY9myZZimOfNj7HcgM8CmpRhOapixlzBjLxAMnwLaMLne8fpuAY9GY6Q6nPncGnX+yY93KELdUGYIV4uLwmiBJu/kPWt5K0/aTON3+qsCV97KY2jFn/fq2KsMpgfZvmQ7p7edfkAlYoQQ4mgmwe4ooTsSaM4EqhDGNv0w14YQswh1UOwUoOuVjeF1tm/fzk033YSm59Fdg2C3YReaQI3vufPpFkujT7F87BlaYy+ytaMfU2mMFAx6bQfLXHXk1WhVqGOWoc6pKY5rDhFwKPK6zv1DXu4xl/HwSCvxsQGu8nUy3ezcpJdiimXLUieIyrpyU9EdCTSHC2WGsc38rH82FGv6GQ5jVj1Tpx9EHs09ipZ1l9+PRYsWzam7wEyhzul0Tmr7VbAUw/Fi8WIz+jSuRvuAivaWzCXUpQtpBjODhJwhwu5w+b4DqQFejr2MlbDQNI2CVcCDp/wco9koLt2Fz+mjJ9FDs68Zr8PLYHqQgl0gb+UZy46RLCQ5peUU1jWtk1AnhFiQJNgdBUofvp2RCLbpn/JARaWqYsLdeyeFuvKG/AqlTgETl99Wr17NxZdezIN/eJB0PE0+sRfD147T38YHNreiP3Mn54UTrHnlB2gaZAw/r2ZdqAlha+JMXUtLCwMDA1M8A0VXnR9HZhSFhu2L8HTjqfze3c51T99HYdREd1k1G9VP51DsRSv1sDXHRrDN/KxL05RMrO+m23MPEJpTYygzRMDlpbkpzL16dd3B2Zgu1Kn9XTwmhsS8qRhJKDobdLrqFa5GG82t0eXvmvdQp5RiID3A0vBSxrJjdCe70dCI5WKMpEdY27KWP/7kj7w69iq747sJqADJQpKx/BintpxKW6ANn8PHi9EXeX7kefqtfpp9zaxrWkfOyvHEwBPo6Jzaemp52VUIIRYaCXZH2KQPXzdU7rmrFe6qiglrcNv9t02aqavV73TVqlU1x5CzcoQ6QlzcejHfu/57dLlynO0bZHtDhvU5B5mmKAlLJ+5uAMOJrdSkUGfa5qTlV79/8pqcU7NpdFr4DBt/oIG7BwLcFQ1z+pZ/ZNDOkMlnyu3OrMLkRvUlpeXjSpWhzmMWq/zPRKnqsDJetLd0ajQ2q9I044OYXN+tYM88jlrPo3Sq2jKtqrqDnQ0zB6yZZuqGEgrbBkNXeJzF99K0FdkCLG7SWd4Kr46O90z1Orxzeg4wc6iL5+PEsjE6Ah3F/qe5GEFXkJObT8ZtuOlL9ZEupEkWkmhorKpfRdgdJugKMpwZpj/VT87KcVLzSZzYeGI5pJ7cfDJ1njqimSir6lcRcBX3lHYFu0gVUjMWBhZCiNcyCXZHUGUJjcoP34kHKirDRFVXh2mWX3ft2jWrMeSsHNFslJBtsi7Tx9qle1nvzxA0LHJKJ6ktYU8hi7JyhHRHzWPUmqFhKnOaPXWKsGFR77QIhsK8MJTh7sEwi8/4EP/73h+DBp35BLZuT1i2rG5UX1lXbcuWLVWHBybO1P3Fm/6i2LqLye3OSsuPL774Iv/zP+NFjEtFe0f7RqtOjU4sTROYfP5h/yBmru82k8oiyqXerxZW+UBF3oT+mKLBP/46T3x+M4W6VE7h0DVWtOsks4poUoEGAZfOogboaoR9qb3zuvxasAqMpEdoCbSwN7GXjkAHo7lRTms5rTzmpeGlNR+73lPPuqZ1/KHvD6yuX10V6qA4C7k0vHTS9V6H94ACqhBCvJZIsDtCSiU0Gv2NNT98a4U7pVTVTN10e+pKoWY6ThcEhn7PGalXWJN6FW8+znAwSdQ0GCoUl1qXuN2gGcUyJIpJW91Ky68OzTEp1Bl2gXZXHq+hSJg6j4wF8Z38Lj72yD3klM5VnpZJYWjysmVxrxdWvircrVq1iksvvZS7776bZDY5afl1xYoV0z73iW3PSqHOSlrcd/t9k+4f8Ws4nMXSNASMSfvSKkuaNHmbDijUTSyiPGkP2P4DFcNJxUAcahWVninU2bYinlasbNdZ3FQMW6al0LXiSdiaPVPnqBTqPHqxLEjWyuLXq2dv+1J9LA4vZkPzBv448Ed2xXbRHmhnRd3071vJ8vByHLqDjkAHDv3Q/hrz+/2TZnKFEOK1QoLdEVBu51SjhEblxv6rr74aAkY53MWHu4vLj7M8KFGTUtSle/nb9mG2NcU5obsft6aRd/iIeZp4NVe9L0/XxsuQ5EzwVMxWVe6pK324aijCDot6h0UoP8qrBSd3D4a5fzTEnpybqy5eS04Vg1OtMFRr2VLXqNGVobg3sGNRB9/84TdQBbhoy0X8/Kafz+IlUFV9cStD3XT13aaaSZ1Y0uRAQ91MRZQB3E6Ntjqd7mGr6rWA2Z1+jaYUDUGdRY3jM2gOo5jWJ3Zi0K3iCWfdr2Pas9voWBnqHHpxOTmZTzKYHsTj8OBz+CjYhWK3hqZ1RDwRNrVvwqk7WRRaNOsZNUM3pqwfJ4QQxzIJdodZZYiYTemJOr+OWcjzX//v59jZkQMOdfUOk/oXfskZjn3UJ17l9e1DZC2duPLh9EeKcz9TzVIoG2VlsRXkCuAyJh+UcNh5Olx5PLoibhncHwsR3PBOPvHgXeRqFSae0F5r5jCkqsJdrqCw9RzDueHyDNeirkWzei327t1b3p8321BXMjHchX3F1la2bvPR91550MuvMxVRhmK4awkpNF8TDmeQgmmTtieHOlsV99EpBZkCpHMKl0NjabM+qcbcxFDnc/pIm2mcTU6shMVgdhBXkwvbtPnyl7+M2+3GcFUvr1Yuv7p0F36Xn9d1vA6X7mIgPcC+xD5iuRimbbK+aX15r5vf6efszrPndNpXCCFEbRLsDqO5hoiSiF8rN6o3Qk7QYrMKdW7N5rRginMjcc4MJanb+xLoOt04GSu4sQsKMkM4HKM0NzXhq3HYoUzZ7Ot+Bc3w0NLahObQwLSp00wiHgt/Ic5LeRe/ioZ5IBaiN+/iqvAJ5NQ9kx9rmvZa0xsPd92jBZy+KJ4ZZrhqKZ0Wns37MXH/GoyHu2jCZjgdxe3Jlw9KzNXE5VeP2zNpmbeWgq1hje0BDZ7tzeD2pQi76sjaAbIZG0VxplPTQNc03E5Y1qLTENBpCM4c6gAG0gOYMZPks0nObD6TbF8W3anTGehEORU98R7qvfW4DBe9yV76Un24dBcejwePw8PGto3lIsIRT4RV9avIWTlShRRhV/U/aiTUCSHEoSHBbh6k02m+/4PvY+dzfOIjH8bpdFY1Xi+FiL1797Js2bJZfaipfAwj5MQTbiXZZ6IKo1PdkzX7u0FsrUvQ5ixgaIox02BP3oVyGmCDXRgvl2KaJr19fbS2ts4wCBvIoZsZOg0Lh5ZnzDK4Ixqm/tR38YkH7sBU0z+XmdprVZZxmer52fk+UmYMI+GluSE455ImgUDggEN2SdgHw+ko0ZTNEveBh7rZLL8W76yXe+jaSpHMgpV4Bc3oZ2nHFrBbaQuG8DiLHR/cTg23o7hvztDB7QSnMfm9mSrUjWZHcegO0i+lsZIW7f52Us8WOzJsatuEy+MqlxWJ5WK0B9o5p/OcYo05u0DYFaYt0Dbp57kN9wG9VkIIIWZHgt1hMFXj9Z/85CcEg0G2b9/O6tWrp7y+FIbQYpy66ix+PZRGcytULla+T7srz+Zwgq2ReLkbRMrW6St1g9BBc+qTQl2l4eHhKcego6h3W4Sdefx6hqGmNfwpfCqfveURBgsOrgquwlR3Tv9CTFh+ndheq6qMS4XHH3+8/P9XfuxKooUoDs3AzkcYjNuTSqHMJNQSItAcIDmYPKBQZyubwfQgbk+eJe4WUhkHo8YsSqFUmEsP24KlMHztKLuAbStSaQh6FJpjEGcYnIkhzjn1+KrC0zMxbZNELsGe+B7SVpoTG04cb6lVSBHPx1lXv45CtHapFqfhZG3T2nJ4q/fUS8FfIYQ4Ckiwm2elkibR3mjNEJFIJLjpppu49NJLa4a7iRvzTztxJW6Hm9/87ln0eIFN7l5eH4lzciBN0LCqukGUG8jPItQBNdtUOa0ci9x5HIZiTDm5bTREy2kfYF9wFXuGLEZce6HQS3d39/QvxAzLrzt27Jiy9+ljjz1WfIj9RXu9Lm9xic+n0TNiTzpEANX7BStnRsdyY8Tzcc7acBZ3/PyOKYc73ftR6ihRWn4dNaavOzjppZhjD9tEBqxMsdDzYBx6e3fzu998F2fYpjBa4Cuf/Qrfb/g+73//+9m0adOMPz9v5elOdOMyXLT4W/C7/AxnhssHYIYyQ6xvXM8K/8wnVKUmnBBCHF0k2M0jw6szlh+j3lfPL+7/xbT3veeeeyYVEK7Va1S3TS7qzPEePYH/lReo0zNoKKIFrXY3iFmGuko6inqnRdiw8JpJns57uTtfz4NDAYbiOleHVvLKrp3cfe+DYIQw/O3cNN1p1IoDH7WWXwHuv//+acdUCkN9+/o444QzimFIg5aKUiiVHSq+/e1vl/+/NDN69razqe+oJ+KOsHjNYryXern77rurCh2HQiG2bds261AH09cdhOrl5e6+bt7593+Nrgy++5/fnXEZWSlF3gQ7uQ8rO0x8YAcPPHgXmrYbdNCdOppDY2RkhC984Qtcc80104a7UqhbHl7O6W2n43V4ydt5nh56mhdHXsSyLU5sOpF1TevIZrLTD04IIcRRR4LdPNEMDcNXLGkSH4jP2LQ+Ho+zd+9e2tvb9z/AeAeDJk8jy40M5zQk+Mvnv0Q4P4JmW+xWebrNIO3tbcT2vDJ5DHMMdV7dptFp4tIUo6bBLSN1eE96O//27K8pJO3yjGPV7JqRnFCGZEJSmXCKd+Lya8l0r0/lDNcfHvgDm04YDy66ro13ZRijvCw7sZ1a2k5z72/u5fyzzmfxmsVAsVzK0qVL+eIXvwjAZZddNuWex6lCXclU4a5yeVlzatz2wK14XT7OPfXc6pdKd6I5vESTCsOwi3XzDI1UDnxusLJDYOW4/97r0fQcdiFPYbiAnbFxtbiw8zbmmMm3vvUtNm7cWHNZNmNm6E32sjy8nE0dm8rPwW24ObXlVCLuCPFcnPXN66dt/SWEEOLoJcFunugODStdLGkykJyqX2q1chjZH4ac+RgbrSgrhn/BhSt349dtAnmDlKuOguZgKJ9E000KFmi6E1VRA87hdGDr9oyhzkBR5zQJGTam5uDllJu7RiM8EAsy6vJwdtyqCnUwYXZtf0eEWuGuVg/buZq4bFlQBfbu3cvixYsr7lU8LXv3nbdP6lAB1adfH7n3EU5afVI5vFUGoEWLFh1QqCuZGO4Gul8qF0HWXAbOhjAql2NsaIxbe24tPUNGU6C761CFJPV+MBw6A2M2TSFIZhUdYYWrSYHmIq0lKIwW0F062b1Zcr05XC0uPIs8uJpcxPIxnnzmSdaeuBZDM8rLq9FslLHcGKvqVnFa22mTnoOu6aysWznl+yBFe4UQ4rVBgt08sU2FlSkGqkAgMKtrAoEAmpVjc1uGc0P9vGX3D/BZGZSCHZZOf97BCncDuqYVi5MByi7gNADDVaxFZxfQdAjXhxiNxqYIdQr//tk5Q4MR08HNw2HM9Rfy1Tv+gI1WDkMP3/3wpL2Bk2bXaoU7TdXsYTsXE0NdaYZr4mxc6Tklh3dVj8HKTTr9GideIxhObbahrmS8FIri7gceH38eTS2Qz2Cm3ejeEKDw+/287W1vI+i2sBJPo8whlre/F7fLga7r9EZt3E4NpyeGlbZwt7sxY2bx5Gm0QH4gDwry/cXZO1ezC3enm4HYAB2ZDixllQsLexweNrVt4ri642Q2TgghFjAJdvOksr1WKpVC07RpZjwUpzY5uJA/0/HsY1zYtgfdVvTvGyNmGixetpyENfVSpcMArHwx3GmgOSy8Xi8jhWjV/QwUjW5F0DDJmPBs2sevomGetNvZuOUCTNPE5o8HVgqkMtwF2tGdQ2hONetQFwwGqwLjVKEOwOfzlf+/ujxKdRFj1ACGz5z0PGoHw8nmGupK6vw6vft6SFtudH8djqAJpkVu4BmsRArNEUTTnYyNaLhzp9DU7kZjGNu0yVpZEtkEnU312MqHhk3C7iW7O0uuJ4fvOB+aUyO7N4syx18UZSpyvTlyAznOaz+PTUs3UbALZK0sOTNHyB0q15QTQgixcEmwm2fTnfZsdhbYHE6wrS7O6W0ePPv2ktMc7Mw6yFlzKx2h7EKxGK3LjbLyuPTSXrbi7FyD06Q+HML0N7ArvJZP3f5n/pzyctlll/M3y4qtmb72ta8dXH03K4eV7sXdvAj0VvIDPbOeqduyZUv5dZou1AHcdttt5RIxPT09E18JrFQvzsZODF8HhdF9WKl81T1mM4N6oKGurDCGMqO4GppQlo4ZexZVGMEZMYAoylJohkY8t4PTQ1uJPxXHjJlsX7Sdffl9PDnwJGs6PbwS20NQi5Drz6EKiqbmJkazo+SH8pN+pKZpdLZ3su2cbRiGzMoJIcSxSILdPJt42tOr22wMJjk3kmBTKEnYsPAFw2S9fhKaE6fhJmfNbkapkqYXZ+qUlUcpJ5Zp0+QsEDJssrbGC2kvzlMuo6dpA0k8/Dm1ExjfV7Znzx7SdvqgivaigTNoo6w+7EwzuqsNq1DjQEUNq1at4tJLL+WOu+7A8plThjqoLhGTy02uX2f4dTRjECvdDFoLGON77kKhEIsWTd967GBDnWkpcHlxBE1UwcJMJ7BSu0m9UCzw62pwgQF2xuaMljPYvmJ7Vb24sBVmJDPCn4f+zGh2lDd1vQmVL74Qn///Ps873/VONKWhKl6c0t7A66677pCFOtlXJ4QQrz1SUXTeFF/aRCKBhuJEX5oPtg/wo9W7+NzSHrbXjWEreCXrYtAVJqu7cDs8B1TkVSl7/+lXhc/KsNgxRiA9QA4XPx2q5yO7FvOBl5fwYtOZ5JzBmo8xlBg6+FBXOigRTWHG94HhKi6JMrt2UUuPW8rF77x42lBX6Z577qlaloXKgxImheGecikU9oezbdu2Tdvp42BCnW0rRpM2vbE8etiFxx0mPzoC5gtkXolSGCpQGCqQejFF+vk0jYVG3rblbZNOCjsNJ+ub1hNwBjiu7jgWhcaD6MUXX8xNP7tp/PT0fp2dndx0001ccsklsx6vEEKIhUdm7OaLw0craTYHomyrG2OFJ4tHVyQtnX05JwVVDHC6U8e0TIJGAF3Tsec4Q6LpYFoZmvU8fs0io+k8nfBwV28Tj+SXE0snyh0q8vk81157bdX1+XyeL/3nlw4o1Hm9XjKZzKSSJsXl16lPy5a4XK5yX9SclWMgPYDb4Z5179d4PF71da1l5NIYgo3LOe/ME1m9euqTn6W6gQcS6pJZk72xOCGvTSgyyuqIm5ZzV/ON73+TfDxFtnu8JtxsZtcavA1sWbyFrJmlJdJSNXN2ySWXsHXrVsLhYr/VO++8k23bZPlVCCGEBLt586ZADx+s30OIFAUbogWDlK1TOXulO3XQwWMcwEydUoQcFg1uC196mD15jVtH67kvFub5tAfQ0NwJdE8DNlS1H6uUyCfKYcireUky+2Xg9evX8/jvHp+6pEnNUiiTlUKdS3dR566bU+/XdDoN1A51RYozTlrKyvWbKZiQKyjczhozdhV1A2cKdZZtM5zM4nE68bscxNIFhtJjbOiqJxQaoz+TxmG4OO7kRXzQ+Fu+97nvMZYfK1/f2dnJddddN+Ps2tLw0im/Vxnizj77bAl1QgghAAl286ZdTxDRc+wx6ynk0+UG7iWlUGfY+qTlxOnotonfTGKYadIuxZ8yAe7va+LeAScJq/rDXeVi2FAOdxMZfoOxwngP260Xb53yoEdNNWfqJpgQ7hwOZ3mWDqpDXbOvGcuc2zJwIBAohzq37SaRmnx6+KyzXodh6PTHFH2jNm11enW404vPo2AXaA+0TxvqxjJ5emJxGgIuYtkM/QmF01BsXd3BhatPw6E76Ev1kSqkqPPU8Ver/oqPv/HjMrsmhBDisJBgN49sZREOhxmJ2igrWw53pVCnCjZNLS0z70BTipBh0eAwCeVGSLoj/Cl0PF95bg/PDRqgpn6EynA3lh6/vRSGws5weYardIDh7rvuIjFDSZBQOESkI4K2a+Y6dWdtOo3fPPaHYneIOHQ2KHRdmxTqdE3HYvbBLhQKEWoOlWfq3vu+93LdddcBxV6vpeLAUOxQ0RqB/hhV4S5ZSOJuc6PpGk7diWVbRAvRcv03lIbCQTavkctraEaBM5e18MbV68jZOV4e6cFtODijay1O3QlQtScOwDTGe53J7JoQQoj5JMFunkWCXjQNRmNxzHwK3UE51LU0t04uvVGxl8qpqWKZktwAacPm8UQA9ylv40++FkzNy3OD353VsmUp3MXSGpo7gu4YX34NuqoPU0xss1WTBmdsOYO6proZQ10wGOScc87h3HPPJVcozpj1xxR1wTxD2epQN1ebz99MvBAvzzhWHopo7WhFc2lVY5sY7rzeOPFclFxfHXa+QL27CUvlibjqUFaYvAk5O4ulMjT7NVraHaxubmZj1+pyR4fF4XaEEEKIo4UEu/mmQSTkw+320DfYj1I5VMFE2ZPrqSWTSQaHBouzc04ThUZ/3sGz2jq+/lI3uywPWxNOFoUCNLnq57QXTeViRHwKZ7gJzeHCHBuZ8qBEZZutQCBQXdBXg/PefB6tXa3UO+tnrFO3ffv2cuByOzXa6nT2juQZGIjSEpldqJs4hlAoxObzN1PfUU/EHeGaq64BIJvLYoQNNDTSZhrNUeygkSwkqXNGAA1d12gMmbw8FGd0VLE0eCKZV79ffFxtKWG/i0xeo7XBw4rmAEG3k6DHQdjrRNdnd7pXCCGEOFIk2B0mmp4HzQbLhVI2TNj1lkmMYUf3sdhhk7J1Ho0HuCsa5tF4gPTzQ2hOL846Bw/d99CkU6OTwtcUdEcCzTGGMsPYZh6IzXjNFVdcUV7eLO2pM5wGzZ5mDMaXFGuN4eKLL2b16tUTBpFHcw9C3oudj4BPm7EaSuUYLrvsMuo76onn40TcEcLu4t61nJVjJDeCFbfID+VZW7+W9MtpHGEHKBhID6Kjo+s6pm2yorGObKqFoNNDvvdF7GyKE9pCDGZs1nYEWdMWwuOUJVMhhBCvLRLs5oFtjc+EZdJpDI8DhY2dy4LmRjM8+/fcKVxWGm8hgRUfZch08NNoiPtiIV7Juiklnpk6Mbz+9a/n9ttvn3ZMpYMS5tgItpmf8kDFROXlzYqDEvf94j4e9zzOli1byverCoD7rVq1qurr0p66gMtFR2sdAzHojylaI0w7G6ZpGrpbR1mKcEt4Uqgby41RsAssDi4muyeDMsEy3Ri+VszoCOsa15HVsqQLaVKFJI3eJiKuRnqMLKd0+LGSxdZrpy2JgMNN0OOcxSsjhBBCHH0k2B1iN998Mx/5xD/y7i0NAPQN9WM4DOrD9ShbAVlcDhcNbkUk04/p9PGisYivvuLm0XiQjF29LDlTqANYsWJFzbGEQiHOO+88br/39gkHJWofqKhl586dNU+/JgqJqhO00xX9hcmnX3VNp62utOeOqnCnuTVQFLst6DCSG0EzNIyAwb7kPhZFFhF2h7GVTTQbxW24WdOwhogeBsOPIxShYNmYsX4cdR1ouGj1RcpjSWZNemNZVreGWNniLd+uaxp+CXVCCCFewyTYHUI333wzl156KZrXDTQUm0/oYOYKDPT3EzLs/Xvn8vRbAXaEtjG66FT+sDfK/bFfTHq82YS6qVx22WUsW7aMkdRIzYMSEw9UTFXn7sEHH5y5pMkMaoU6GN9zVxnuclYO3aODCZqvGPQa3A2kXynumVseXk7GzjCUHgIg4o6wom4FIVeIaCKF4QuR2/cCW1bWk3nlCdyL8vTGsrhdbixbkciZ5E2bDYvrWN8ZoZDLzPn5CCGEEEcrCXaHiGVZfPSjH0UphQZo+19Zh2lS77Dw69V7534bD/HWM/8CO2vg8pmTHu9gQh0Ue8DG83HG8mNTdpQoHaiYcllWg5wzNy+hrmRiuFNGAnPUJNeXw/AaaIbGyvBK7HRxhOsa15HTin1fNU3D7/Tj0l3kTZuBeI58/07yvTsIehxgm+R7nmNpo4/BRBa308DvNti4tJ4VzQE0TaMwudWsEEII8Zolwe4QeeSRR+jp6am4RcOHRbvTpi/v4oZoiPsn7J1rCcFISkMFOgiGG0iMjRSvnEOoe+c734nL5Zp0+1hujJSdIuwKT9smLOwDOzuC7mkgllI0RcrDP+CZOs2hobt0xnJjJO0kHsNDk7cJvWK51rRN0oU0WStL2B2mrc7F3pE8WdNBIWqicgozVwy8hjZ+iMHQDerd9VU/z7IV3aNpljX5yPXtoPIFU2aeM5fVYWouvC4Dn8uBIadbhRBCLFAS7A6Rvr6+qq9fyXq4QzVw37CPx+KBSXvnoFRXTaM/Bhte90Z+fffP0PT8rENdMBhk0aJFaJrGv/zLv1AoFLj22muLByXyYzT6G/HpM3e1GF+WBYfTxue05xTqNFexvIjhN9CcGspU2AWbrJUtHnzQdKLZ4gEFhUJDQ9M0gq4g9d56epO9hN1h/N4EejqC7mrD0nrKNf0sW2EEG7Hzk5dN86ZN92iarnofp3T4wJo8++l2GNT7PTXH7vf7q/qwCiGEEK9lEuwOkba2tqqv7403cnc+iMpMfzqhVDSXJV1Y29/Cn5+/l8xYbFbLr1u2bJl0aKHcUcIVJuwOUygUZjX+4rIsRBM2/UTLoc7v9pNSKTBA0zWUpYqHGko/L2SAVVwWtTIW5qCJlbCwMzZntZ2FbdhYqlg8WCmFQmErG4fuIOQKoaHh0l3sju/G7TI4LtyC5nDjrO+kEO1BdwfojmWxc0l0b5ihZI4udzGkJbMm/YkMK5tDnL6sHs2UdVUhhBDHtrmX+58HmUyG888/nxNPPJGBgYFp75tMJvlf/+t/sXHjRs455xy+8Y1vHBUzLps3b6azs3PG06G16LpGXbBAuNnLptddTCGhz2pP3cRyImO5sfJBiVIpkLkI+RS2ESWWUpipAKqgOPP1Z6L79eLzskF36+i+4h8b3auDBZndGU6qP4nMzgyFgUJxP5wCp+Ek7A5T76mnzl1HvaeeBk8DTd4m6tx1GJqBruksDS9lSWgJzf5m2gL1FEa60f11uBevR3M4OaUrSPqlx8ju/hMo2DWUZNdQkkSuwLrOCK87roGAW/6NIoQQQhwVn4Yf/ehHiUajPPfcczPOML3lLW+hr6+Pf//3f2d0dJS///u/Z2BggE9/+tOHabS1GYbBV7/61eKp2Dlmu5yVYyg7QEvExa4dcQxfO1aqF6zJM1CbNm3isccem3T7WG5s2oMS09F0DaUphjJDuD02i4x6NEc9RkijfVE7ue4cZrSAUuCsd+LucBNuC3PaxtO46/t3YSWsA2oJVqJrOssjy7GVTTabwwg2UhjZS2FoD2asj+NbA2AVMKM9bF7RQH/KpjHopingps7nko4QQgghxH5HPNjddNNN/O53v+Pzn/88b3rTm6a97yOPPMI999zDU089xfr16wEYHR3lYx/7GB/72McIBoPTXj/fLrnkEm666SY+8ol/JF9xe6meXGXdt5LKU6NNniZu/M3PwA5i+GuHu2efeWbSY4zlxojlYjUPSjidTv7lX/4FoBiaNUDB1VdfjdPpJJVLYYQNDK9BPB9ned1ycAOMYvgbCGldFIbHw3ZhpMCHPvghXO0u6hx13D4yfWHkudA1nbFsATuTIP3yY6hcatJ92sIeVrT7D9nPFEIIIRaSI7oUu3v3bj784Q/zox/9CLfbPeP9H3zwQdrb28uhDuCCCy4gk8nw+OOPz+dQZ+2SSy7h0d8+Wv76sssu48Mf/vCkZVOYXAqkp6eHRCK+P9DlMfztYFS/LokJbbtKoa6yE8NUsoUszogTR52Dnbt3UrAKRDNRCsN5Ui+mMGMmI9kRRrIjqFyMbHc/mHUYgepTqGeuO5N1TetYEloy5zIsM0mbOg/d/lMSI9MvyQshhBBisiM2Y2eaJpdddhnXXHMNJ554Iv39/TNe093dPemQQunr7u7umtfkcjlyufFZr3g8fhCjnh3dGC/PUTq1Wunqq6/G1u1J9d3Ge60qrFQvhr99ypk7GC9pUgp10y1jP/PiMzz06EPkBnIoW/GLO36BN+TFjJrkenIoC2687kYaFzfwlxf8JemXUigzRUvQhRFsBCi33gIIuUJkc9kDen1ypkUia5IzbSxb0Rx043EapPMmXqfB4gY/MPl0qxgnp3mFEELUcsSC3b/8y78QDof58Ic/POtrTNOcVLPN6XSi6/qUoeYLX/jCEd9/N1HOyhHNRicV7Q0EAhX3miLc6WAEi8GxVNKkcqZO0zUwKH/oKxRPv/A0d91/F7m+HPn+PCiwEhb5QJ7CcB61f/XWztgM7Rji/+74v6VKIzQFXFiJ4Zrh7kBEU3limQLNQTfNITdKwc7BJIvqfQwn8yxu8NEYcKFp7vJzSKUmL8kKIYQQYrIjFuxuuOEGlFKsXbsWGP/w3rp1K+95z3u4+uqrJ13T0NDAyMhI1W2jo6PYtk1jY2PNn3PNNdfwD//wD+Wv4/E4XV1dh+ppzOjaa68F4KqrrgKKxYeHMkN4Xd5JnRgWLVpEMBgkkUjsv2VCuEv3Emp2kxhJ4G5249JdhN1hLGWRMTPEM3H0YLEd11B2CL/ykylkePjXD5Pdk6UQHS+hYiUsrESNbhSKSYc/SmGuFO5KPG4Pt912G0Bx9k7T0Qwn6MXnZNn7w6VSZAoWI6k8DkPjdcsbWN0WwtA1sgULRTHcGRosbwoc0MniiWRGSwghxLHoiAW7e+65h3x+/IjB448/zvve9z6uv/56TjjhhJrXnHLKKVx33XUMDw+Xg9yjjz5a/l4tbrd7Vvv3DodSRwmn7qTZ1wzAQHoAQyvWnXMaTrZs2cIvbv0FmlNDd+jgAFXoRzNacTV3ccbJq7ntv2+iMFzA/RY3/al+HLoDj8NDV6CLzM4MqqBYEV5BzIyRHkgz+NRgVe25mdTKQ5XhbjCRY5G7uuDvaLqAo64VVciBKrb/6o1lMZIWaBpep05z0M3Ji+poj3jL13mcBpuWNZA3bQqWXfW9uTpaw9zROi4hhBALzxELditXrqz6urTHbtWqVbS2tgKQSCTYtGkTn/vc53jzm9/MRRddRFNTE5/85Cf5+te/TiaT4XOf+xzbtm1jyZIlh/spzEneGu8oUWyvVezGEHFHMGyDL17/RTRd4/LLL8MIGaiCws7Z2HEL3W+gqQGsVAvHdW0GdRuFoRxr6tZg6RYBV4CAM4BVGJ+F6wx0sty9nEd2PDKnUFfpYx/7GG7PeCguhbuBeA63K0tLyINlK/bF0mDbZPf8GTPWXwx2msb245sxdSeGrtHgdxHyOGuWJvG7HZy9solM3sLlOCpKKwohhBCvSUe83Ml0LMviueeeY3R0FCjOfNx6661cdtllNDU1kclkOOWUU/je9753hEc6Pc2pEbNi/M073lVefs2aWRSKJaEl+DU/mVcyGH6D40Irybycwc7Z5VZeV19zNV+87osoaxcBpwtnQxeFkW76dvZx8skno5eWPqleWtXQqKuvO+BxV1+rYfgjoBs0B130jWWLS6ymRWvIywnNHgqDrwDFItJ+/9xKkgTcDikyLIQQQhyko+aTdNOmTTzzzDPl2Too1n975pln6OzsLN92+umns3PnTnbv3o3b7aa9vf1IDHfWdJ+Os8GJQ3OUQ52tbGL5GEtDS2nwNpDL5bDiFlbcosXbgpWsDmgnHn8idqa4vPnVz/4vFH6cDV38n8//G/XhAO9/3/vZtGlTzZ9/wvEn0NDYQHRkpOYSay2aBg2NjZxw/AlomsZ3fnwjg2MprrnqQygzR85UtIQ8PN+X4Pj2EGcub8CjySlWIYQQ4kg7ata9/H4/J554Ig7HeNbUdZ0TTzyRSCRSdV9N01i6dOlRH+oMv44j4sCMmaBBxswQy8UYygzR4G5gUWgRGnM7KDA6EqUQ7UEVcjgbuhiNJ/m3f/tCzW4UUHwN3/++9wOTD0XUUrrP+654HzlT8cpwCqXBxiUR0jseJbv7TzT4nSRzJosavJx9XBMNAXd5H5lSas6zdTOZz8cWQgghFpKjJtgtODroTp30jjSpF1IsCy3DUhZ+h581DWs4ofEEXLpr5scBLHvC6VWlyuHOUd+F5nTzrW9/C9u2a16/adMm/umfrqG+vqHq9mAoSCAYQPcE0T3FUisNjY380z9dw/ITT2YwkWNNW5C/OKGVE9pDKDOHnR7jzGX1LKr3sfm4JhY1+Ob+2gghhBBiXhw1S7ELiaEbqIwi3Z2mMFSsr7cktIQlxmKchgtDM2Z4hGo7duyYfOP+cOes78RR38XISDe7du0qlx+ZaNOmTaw/aT1v/6u3A/DJT36Sk08+mb7RBP/fR4vlYK666h84Z+MGhpJ5LKU4Z1UjyxoD6LpGKjVeJ7De72LbCWGchvy7QAghhDiaSLCbB07dSXZvBjtfve/M4ziwUh6xWKz2NyrCnbOhi4GhUdZO8zilQxagccKJJ5DIWaQLNrme50FZLFl2HLujabxOgzNXNLK8KTDlY0moE0IIIY4+EuzmyyEsWzZxj2H1zxkPdxlXiHTexOeq/bbmTBtnfQfKttgzksHjcXFSZ4jC0KsAnLEswssjedZ1RqYNdUIIIYQ4Okmwew1YtWrVtN/XUIT1LKuWL2PXUIrlTf5J4S5nWvTGsuSH9lAY2cPrVzXg9fpo9Iwn0GWNfla0NeB1zW2pWAghhBBHB1lPew0w9PGgNfFk6/gp1itY3hzE49TZNZQiXbEMnDMtekYzrGjyk+1+BisxwuJ6H0sb/egTHlBCnRBCCPHaJcFu3hxYv1O3x81tt93Gz278Wc3vR+qqCw6XTrFu2rQJQ9doCXpI5Qrs6E+QzpsksgV6RjOsag1y+pIIWIWajyuEEEKI1z5Zip0nmtsHZu6QPFYp7AFE4wmu+PDHsRLD/O9/vqaq80QmbzGcynFiR5iX+pP8dtcwSxsDnL6knrWdYfLZzCEZjxBCCCGOThLs5omm6zjr2skP7GLWLR9mkCtY9CcKWIkhjHALq48/vhzqcqZF71iGE9vDnLKkjlMW59g1lKCzzs/yJj+appE/iJ8tjeyFEEKIo58sxc4Dv8/Pf375S1z58U/grO+cXcuHKehuP4msSTJn0hPLsLLZT3bP01jxIfrGsgAksgW6RzOsbAly6tI6PE6Drnof565qYUVzAO0gfr4QQgghXjsk2M0Th6HTFXajOd046zt55plna3aG2B1NsWckjSPShhGox7KLs2KWrXDUtaM5nORNm0SuwPLmAKctjmBnk+T2PY/LobNzMEkyZ7K+M8zGZfW4HXL4QQghhDhWyVLsPHnyT09yww+/T2FkGGdDF/92/XcI6d/g/Ve8j02bNgHFmTaPQ2ft4gj5/pcxgo3sjWZoDOkMxzNY8UGy3c9ywdoWnG4vPpdR3idnJUY4qTNEwtRZ0xqiOeQ5kk9XCCGEEEcBmbGbB7feeiv/9V//RTQaRRVyFEa60Zxu4srLv137bzz22GMA9I8mueKySzhjZTu5fc+TfvkxXKOvoGGztMFHZvefsDNxvE6DsNc5qdvDqpYg56xsllAnhBBCCECC3SFnWRYf//jHqg5MlMOdw42jvpNvffvb5AomCrBGeysuLvB3f/UmPv72rUSf/y0qL6dYhRBCCDF7EuwOsUceeYR9+yrCmqaB7qgKd2O2h8effo7dLz6DmRiZ9Bj79rzCu//mrw/jqIUQQgixEEiwO8T6+vrGv9B0HHXtOOpa0RyuqmXZnQMJfvzfXwbbnPQYpbIiXV1dmKaJ3+8/XMMXQgghxGuYBLtDrK2trfz/jlAjVmKE/MArOMLNoBuoQg4rFUNlk/S9/OyUj6OUoru7m0ceeeRwDFsIIYQQC4Ccij3ENm/eTEdHOzFNw06Pket5FjubRHe6i+VLgHDAy4nNbn6aTc74eFUzgEIIIYQQ05AZu0PMMAz+40tf2l9r7gWsZBRl5sl2P4sVHyQ/sJPPfOAtnLWqdVaPVzkDeLBK3SOUUrK8K4QQQixAMmM3D9526SVYCj5+1UfYt/82lUvRkOnmuq98hUsuuQTLsujo6GDfvn01H0PTNDo7O9m8efO8jlVahQkhhBALh8zYzZPL3noJzz//fPnrO++8k1dfeYVLLrkEKM7s/fu//3vNa0stwK677joMQzpJCCGEEGJ2JNjNo8pQdvbZZ08KaW9+85trXtfZ2clNN91UDoFCCCGEELMhS7FHmTvvvJNt27bJTJ0QQggh5kxm7I4ytWb2hBBCCCFmQ2bsXmPksIMQQgghpiIzdkIIIYQQC4QEOyGEEEKIBUKCnRBCCCHEAiHB7giyLOtID0EIIYQQC4gEuyPk5ptv5vjjj590+6233noERiOEEEKIhUBOxR4BN998M5deemnN061//dd/jcfjkeLEQgghhJgzmbE7zCzL4qMf/ei0JUuuvPJKWaYVQgghxJxJsDvMHnnkEXp6eqb8vlKK7u5uHnnkkcM4KiGEEEIsBBLsDrO+vr5Dej8hhBBCiBIJdodZW1vbIb2fEEIIIUSJBLvDbPPmzXR2dqJpWs3va5pGV1cXmzdvPswjE0IIIcRrnQS7w8wwDL761a8CTBnurrvuOgzDOJzDEkIIIcQCIMFuHvn9fpRSKKXw+/3l2y+55BJuuukm2tvbJ13zwx/+UEqdCCGEEOKASLA7Qi655BKef/758td33nknpmly+eWXH8FRCSGEEOK1TILdEVS53Hr22WfL8qsQQgghDooEOyGEEEKIBUKCnRBCCCHEAiHBTgghhBBigZBgJ4QQQgixQDiO9AB27NjBM888QyQSYdOmTVVlQSYyTZMf/vCHk24/66yzWLFixXwOUwghhBDiqHfEgt3w8DDveMc76O3t5fjjj2fnzp3s3r2bH//4x2zfvr3mNdlslve85z288Y1vpKmpqXz7ihUrJNgJIYQQ4ph3xIJdLpfjk5/8JGeeeWb5tiuuuIIPfehD7Ny5c9pr//Vf/5UzzjhjvocohBBCCPGacsSCXUdHBx0dHVW3LV68mGw2O+O1jz/+OHv27GH58uVs2LABXZetgkIIIYQQR3yP3T333ENPTw8vvfQSN9xwA9/85jenvb+madxwww20tbXx6KOPsnjxYm666SYWLVpU8/65XI5cLlf+Oh6PH9LxCyGEEEIcLY74VNfTTz/N/fffz69+9SsaGxur9s5N5HQ6eeSRR3j88ce55ZZbePnllzFNk/e9731TXvOFL3yBcDhc/q+rq2s+noYQQgghxBGnKaXUkR5Eycc//nG+973vsXv3bnw+36yu+d73vsd73/teUqkUbrd70vdrzdh1dXUxNjZGKBQ6ZGM/EKlUikAgAEAymZz2RLAQQgghjk3xeJxwODyr7HLEZ+wqve1tb2NoaGjGwxOVfD4flmURi8Vqft/tdhMKhar+E0IIIYRYiI5YsOvp6WHiZOHvfvc7HA5H+VBFPp/nu9/9bjno1brmxhtvZOnSpbS0tByegQshhBBCHKWO2OGJe++9l29/+9ts376dxsZGnnrqKX74wx/ymc98hoaGBgDS6TTvec97+M53vsOKFSt48MEHuf7663njG99IJBLhzjvv5NFHH+VnP/vZkXoaB8Xv908KqkIIIYQQB+qIBbv3vOc9nHbaadxyyy0899xzLF26lCeffJLVq1eX7+NyuXjXu95VLj78zne+k5NPPpmbb76Zl19+me3bt/O9731PZuuEEEIIITjKDk8cDnPZgCiEEEIIcaS9Zg9PCCGEEEKIAyfBTgghhBBigZBgJ4QQQgixQEiwE0IIIYRYICTYCSGEEEIsEBLshBBCCCEWCAl2QgghhBALhAQ7IYQQQogFQoKdEEIIIcQCIcFOCCGEEGKBkGAnhBBCCLFASLATQgghhFggJNgJIYQQQiwQEuyEEEIIIRYICXZCCCGEEAuE40gP4HBTSgEQj8eP8EiEEEIIIWZWyiylDDOdYy7YJRIJALq6uo7wSIQQQgghZi+RSBAOh6e9j6ZmE/8WENu26e3tJRgMomnavP2ceDxOV1cX3d3dhEKhefs5YvbkPTk6yfty9JH35Ogk78vR6XC8L0opEokE7e3t6Pr0u+iOuRk7Xdfp7Ow8bD8vFArJX8CjjLwnRyd5X44+8p4cneR9OTrN9/sy00xdiRyeEEIIIYRYICTYCSGEEEIsEBLs5onb7eaTn/wkbrf7SA9F7CfvydFJ3pejj7wnRyd5X45OR9v7cswdnhBCCCGEWKhkxk4IIYQQYoGQYCeEEEIIsUBIsBNCCCGEWCAk2B0A27a5/vrr2b59O9u2beOrX/0qpmke8mvE3PT09PDBD36Qc889l8suu4xHH3102vubpsn3vvc93v72t7Nt2zauuuoq9u7de5hGe+y4/fbb+cu//Ete//rX80//9E/EYrFZX/uVr3yFM844gx//+MfzN8BjUCqV4tOf/jTnnXceF154ITfccMOsrnv00Ud597vfzXnnncfVV1/N2NjYPI/02PLUU0/xN3/zN5xzzjlcccUV7Ny5c8ZrfvrTn/K2t72Nc889l8svv5w77rjjMIz02JHP5/npT3/KG97wBs4777xZXaOU4r//+795wxvewPnnn89//Md/UCgU5nmk1QMQc/SRj3xENTc3qx/84Afqxz/+sWptbVUf+MAHDvk1Yvai0ajq7OxUF154obrjjjvUxz/+ceV0OtVvf/vbKa9561vfqt7znveon/zkJ+ruu+9Wb3nLW1RdXZ3atWvXYRz5wvbjH/9YOZ1O9cUvflHdeuutauPGjeqUU05RhUJhxmsfeeQRtXz5chUIBNQXv/jFwzDaY8eWLVvU2rVr1c0336yuv/565fF41Ne//vVpr/nOd76j3G63+tSnPqUeeugh9bWvfU1dfvnlh2nEC98zzzyj/H6/+vu//3t15513qre//e2qoaFBdXd3T3nNf/zHfyiv16v+8z//Uz344IPqC1/4gjIMQ/3oRz86jCNf2E499VT11re+VV1xxRXK7/fP6ppPfOITqr6+Xn33u99VN9xwg+rs7FTvete75negFSTYzVFPT4/SdV3deOON5dtuueUWpWmaeuWVVw7ZNWJu/s//+T+qqalJ5XK58m0XXHCB2rp165TXJBKJqq9N01SdnZ3qX//1X+dtnMeaJUuWqH/8x38sf71v3z6l67q64YYbpr0uGo2qJUuWqEceeUQ1NDRIsDuE7rnnHgWoF154oXzbZz7zGVVfX6/y+XzNawYGBpTX61Vf+tKXqm7PZDLzOtZjydve9jb1ute9rvy1aZpq+fLl6sorr5zyms2bN6t3v/vdVbdt375dvfWtb523cR5rYrGYUkqpb37zm7MKdoODg8rhcKgf/OAH5dt+9atfTfo7N59kKXaOHnzwQZRSXHDBBeXb3vCGN+BwOHjggQcO2TVibu6//362b9+Oy+Uq3/bmN7+ZX//611NOgQcCgaqvDcPA6/WSz+fndazHip07d7J7924uvPDC8m3t7e2ceuqp3HfffdNe+7d/+7e84x3v4KyzzprvYR5z7r//flasWMHq1avLt735zW8mGo3y5JNP1rzm5z//OYVCgfe///1Vt3s8nnkd67Hk/vvvr/q7YhgGF1xwwbR/V0499VSeeuop0uk0ANFolBdeeIHTTz993sd7rJhtG6+SX//615imyZve9KbybVu3bsXn83H//fcf6uHVJMFujvbs2UNdXR1er7d8m9vtpqGhgT179hyya8Tc7Nmzh/b29qrb2tvbKRQK9PX1zeoxbrzxRnbu3MlFF100H0M85pT+bNd6X6b7c/+f//mf7Nu3j0996lPzObxj1lR/V0rfq+X5559n5cqVPP7441x00UX8xV/8Bf/6r/86p/2SYmqpVIqRkZE5/1259tpr2bx5M52dnZx88sksXbqU9773vfzjP/7jfA9ZTGHPnj34fD4ikUj5NofDQXNz82H7vHcclp+ygBQKhZrVpb1e75QzQwdyjZibWq9xKUjP5jV+4okneO9738s111zDmWeeOS9jPNaUXvda78tUgeDpp5/mU5/6FI899hgOh/x6mg8H8nclm83S3d3NP//zP/PP//zP6LrOZz/7WW655Rb++Mc/yszdQZru78p0v79uuOEGvv/97/PpT3+atWvX8vjjj3PttdeyceNGtm/fPq9jFrUdDZ/38ptzjurr64lGo5NuHxkZoaGh4ZBdI+am1ms8MjJS/t50nnrqKbZt28a73/1uPve5z83bGI81pdc9Go2yaNGi8u3T/bm/4YYbUErxzne+s3zb2NgYX//613nwwQflxN8hUF9fz+7du6tuK/1dme53WCKR4Ac/+AGrVq0CYN26dSxZsoQHHniAN77xjfM65oUuGAzidDpr/g6b7jPiH/7hH7jyyiv56Ec/CsB5553H3r17+fjHPy7B7gipr69nbGwM27bR9fFF0cP5eS9LsXO0YcMGcrkczzzzTPm2HTt2EI/HOfnkkw/ZNWJuNmzYwB/+8Ieq2373u9+xZMkS6urqprzuz3/+M1u3buWyyy7ja1/72nwP85hywgkn4Ha7q94Xy7J48sknp/xz/8EPfpA77riD6667rvyf3+/nzW9+M5/5zGcO19AXtA0bNvD888+X92VB8e+KpmmsX7++5jWnnnoqUL2s3traiqZpjI6Ozu+AjwGGYbBu3bqav8Om+rtiWRbxeJyOjo6q29vb22tOJIjDY8OGDdi2zRNPPFG+bffu3QwODh6+z/vDckRjAbEsS61Zs0a99a1vVZZlKdu21eWXX66WL19eVcJh69at6lvf+tacrhEH7uGHH1aapqk777xTKaXUq6++qpqamtRnPvOZ8n0eeOABtXHjRjU4OKiUKpYXaGxsVB/60IeOyJiPBX/zN3+jTjjhhPLJsuuuu0653W61e/fu8n2uvPLKaU/+yanYQ2toaEiFQiH1yU9+UimlVDqdVqeffrq64IILyvcZHBxUGzduVA888IBSSqlUKqXa29vV5z//+fJ9vvzlLyuPx6NeffXVwzn8Besb3/iGCoVC6rnnnlNKFcv9OBwOdcstt5Tv861vfavqpP+5556rNm3apOLxuFKq+N6uWrVKvf3tbz+sYz8WTHcq9o1vfKO6/vrrlVJK2bat1q9fry666CJlmqZSSqn3vOc9atGiRSqbzR6WsUqwOwDPPvusOu6441Rzc7NqaWlRy5YtU0899VTVfcLhcPkX52yvEQfny1/+svJ6vWrlypXK7Xard7zjHVXlG2688UYFlOtCbdq0Sem6rjZu3Fj13zXXXHOknsKCMzo6qs477zzl9/vVsmXLVDgcrir7o1SxPMP27dunfAwJdofe3XffrZqamtSiRYtUOBxWGzduVH19feXvd3d3K6Dqvfr973+vlixZopYuXaqWLVummpub1U033XQkhr8g2batPvjBDyqXy1X+HTax9NInP/lJFQ6Hy1/v2rVLnXHGGSoUCql169Ypv9+vtm7dqgYGBg7z6Beua665Rm3cuFEtXbq06vOisnRJS0uLuvrqq8tf79ixQ61Zs0Y1NjaqtrY2tXjxYvWHP/zhsI1ZU0qpwzM3uLAopXjhhRdQSrFmzZqqtXSAP/7xj7S2ttLZ2Tnra8TBi8fj7Nq1i9bWVtra2qq+F41Geemll9iwYQMul4tnn32WZDI56TEaGho47rjjDteQjwm7d+8mFouxevXqSRvtX3zxRYCq8huVnnjiCdrb2ye9n+Lg5PN5XnzxRXw+HytWrJj0vSeffJKVK1dW7VG1bZsXX3wRh8PBsmXL5IDLPBgaGqKnp6fmNpKenh76+/vLS+Ml/f39DAwM0NHRQWNj4+Ec7oL38ssvl/egVlq7di1+vx+AJ598kqamJrq6usrfV0qxY8cOTNNkzZo1GIZx2MYswU4IIYQQYoGQKSMhhBBCiAVCgp0QQgghxAIhwU4IIYQQYoGQYCeEEEIIsUBIsBNCCCGEWCAk2AkhhBBCLBAS7IQQQgghFggJdkIIIYQQC4QEOyGEEEKIBUKCnRBCHITHH3+cX/3qV1W37d27lxtuuKFmyzohhJhPEuyEEOIgeDweLr74Ym6++WYACoUCl1xyCTfffDOBQOAIj04IcayRDs5CCHEQTjrpJD73uc/xvve9j40bN/K1r32NgYEB7r333iM9NCHEMUhTSqkjPQghhHgtU0qxbds2+vr62LFjB/feey/nnnvukR6WEOIYJMFOCCEOgccee4wzzzyTSy65hJ///OdHejhCiGOUBDshhDhIlmVx7rnnEo1G2blzJ4899hgbNmw40sMSQhyD5PCEEEIcpM9//vO8/PLLPPTQQ/z1X/8173jHO8hkMkd6WEKIY5DM2AkhxEH4/e9/z1lnncWtt97KG97wBlKpFCeddBLnn38+3/jGN4708IQQxxiZsRNCiINw++2387nPfY43vOENAPj9fn7yk58wOjpKd3f3ER6dEOJYIzN2QgghhBALhMzYCSGEEEIsEBLshBBCCCEWCAl2QgghhBALhAQ7IYQQQogFQoKdEEIIIcQCIcFOCCGEEGKBkGAnhBBCCLFASLATQgghhFggJNgJIYQQQiwQEuyEEEIIIRYICXZCCCGEEAuEBDshhBBCiAXi/wd9NuEJpByE0QAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# plt.fill_between(x_data, lower_bounds[-2,:], upper_bounds[-2,:], alpha=0.5)\n", - "plt.errorbar(\n", - " x_data, y_data, reported_stat_err, linestyle=\"none\", marker=\"o\", color=\"k\", zorder=0\n", - ")\n", - "plt.fill_between(\n", - " x_data,\n", - " lower_s[-1, :],\n", - " upper_s[-1, :],\n", - " alpha=0.3,\n", - " color=\"tab:green\",\n", - " label=\"posterior, $k/N$ scaling\",\n", - " hatch=\"//\",\n", - ")\n", - "\n", - "plt.fill_between(\n", - " x_data,\n", - " lower[-1, :],\n", - " upper[-1, :],\n", - " alpha=0.3,\n", - " color=\"tab:blue\",\n", - " label=\"posterior+ exp. err.\",\n", - " hatch=\"\\\\\",\n", - ")\n", - "plt.fill_between(\n", - " x_data,\n", - " lower_l[-1, :],\n", - " upper_l[-1, :],\n", - " alpha=0.7,\n", - " color=\"tab:orange\",\n", - " label=\"posterior\",\n", - ")\n", - "\n", - "plt.xlabel(\"x\")\n", - "plt.ylabel(\"y\")\n", - "plt.legend()\n", - "plt.tight_layout()" - ] - }, - { - "cell_type": "code", - "execution_count": 37, - "id": "023b3cd0-3daf-46d1-b748-6857a69a4d54", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:10:40.796167Z", - "iopub.status.busy": "2026-08-11T03:10:40.796024Z", - "iopub.status.idle": "2026-08-11T03:10:40.934389Z", - "shell.execute_reply": "2026-08-11T03:10:40.933670Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# plt.fill_between(x_data, lower_bounds[-2,:], upper_bounds[-2,:], alpha=0.5)\n", - "plt.errorbar(\n", - " x_data, y_data, reported_stat_err, linestyle=\"none\", marker=\"o\", color=\"k\", zorder=0\n", - ")\n", - "plt.fill_between(\n", - " x_data, lower[-1, :], upper[-1, :], alpha=0.5, label=\"posterior + exp. err.\"\n", - ")\n", - "plt.fill_between(x_data, lower_l[-1, :], upper_l[-1, :], alpha=0.5, label=\"posterior\")\n", - "\n", - "plt.xlabel(\"x\")\n", - "plt.ylabel(\"y\")\n", - "plt.legend()\n", - "plt.tight_layout()" - ] - }, - { - "cell_type": "code", - "execution_count": 38, - "id": "22ca7234-5e2a-4249-a15e-9e7c773bd166", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:10:40.935793Z", - "iopub.status.busy": "2026-08-11T03:10:40.935651Z", - "iopub.status.idle": "2026-08-11T03:10:40.938704Z", - "shell.execute_reply": "2026-08-11T03:10:40.937930Z" - } - }, - "outputs": [], - "source": [ - "def coverage_counted(y, err, lower, upper):\n", - " coverage_integrated = np.zeros(len(lower))\n", - " for i, (l, u) in enumerate(zip(lower, upper)):\n", - " coverage_integrated[i] = np.mean(np.logical_and(y >= l, y < u))\n", - " return coverage_integrated" - ] - }, - { - "cell_type": "code", - "execution_count": 39, - "id": "fafbe724-cab5-481d-8f43-ee8a07de0c69", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:10:40.940118Z", - "iopub.status.busy": "2026-08-11T03:10:40.939997Z", - "iopub.status.idle": "2026-08-11T03:10:40.943106Z", - "shell.execute_reply": "2026-08-11T03:10:40.942190Z" - } - }, - "outputs": [], - "source": [ - "def coverage(y, err, lower, upper):\n", - " coverage_integrated = np.zeros(len(lower))\n", - " for i, (l, u) in enumerate(zip(lower, upper)):\n", - " coverage_integrated[i] = np.mean(\n", - " norm.cdf((u - y) / err) - norm.cdf((l - y) / err)\n", - " )\n", - " return coverage_integrated" - ] - }, - { - "cell_type": "code", - "execution_count": 40, - "id": "653ddf7d-568e-40c6-bd59-50d8bc93bf57", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:10:40.944421Z", - "iopub.status.busy": "2026-08-11T03:10:40.944303Z", - "iopub.status.idle": "2026-08-11T03:10:41.175228Z", - "shell.execute_reply": "2026-08-11T03:10:41.174577Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# plt.plot(inner_pctls, coverage_sum * 100, label=\"sum\")\n", - "\n", - "\n", - "# cov = coverage_counted(y_data, reported_stat_err, lower_bounds, upper_bounds)\n", - "cov = coverage_counted(y_data, reported_stat_err, lower, upper)\n", - "\n", - "plt.plot(\n", - " inner_pctls,\n", - " cov * 100,\n", - " label=\"posterior + exp. err.\",\n", - ")\n", - "\n", - "cov = coverage_counted(y_data, reported_stat_err, lower_l, upper_l)\n", - "# cov = coverage_counted(y_data, reported_stat_err, lower_bounds, upper_bounds)\n", - "\n", - "plt.plot(\n", - " inner_pctls,\n", - " cov * 100,\n", - " label=\"posterior\",\n", - ")\n", - "\n", - "plt.plot(inner_pctls, inner_pctls, \"k--\", label=\"expected\")\n", - "plt.legend()\n", - "plt.xlabel(\"inner %\")\n", - "plt.ylabel(\"coverage %\")\n", - "plt.title(f\"$N = {N}$\")\n", - "plt.tight_layout()" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.12.3" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/examples/plotstyle.py b/examples/plotstyle.py new file mode 100644 index 0000000..0a61680 --- /dev/null +++ b/examples/plotstyle.py @@ -0,0 +1,127 @@ +"""Shared plot styling for the example notebooks. + +The notebooks call :func:`use` once, near their imports, and then draw with +the ordinary matplotlib API. :func:`band` and :func:`corner_kwargs` are the +two things every notebook was re-implementing by hand. + +``import plotstyle`` works because a notebook runs with ``examples/`` as its +working directory, under Jupyter and under ``pytest --nbmake`` alike. +""" + +from __future__ import annotations + +import matplotlib as mpl +import matplotlib.pyplot as plt +import numpy as np + +__all__ = ["COLOURS", "HATCHES", "use", "band", "corner_kwargs", "label_at"] + +# Wong's colourblind-safe qualitative palette (Nature Methods 8, 441 (2011)). +COLOURS = [ + "#0072b2", # blue + "#d55e00", # vermillion + "#009e73", # bluish green + "#cc79a7", # reddish purple + "#e69f00", # orange + "#56b4e9", # sky blue + "#525252", # grey +] + +# For overlapping bands that must stay apart in greyscale. +HATCHES = ["///", "\\\\\\", "...", "xxx", "+++"] + + +def use() -> None: + """Apply the example notebooks' rcParams.""" + mpl.rcParams.update( + { + "figure.figsize": (6.4, 4.0), + "figure.dpi": 110, + "savefig.dpi": 110, + "font.size": 10, + "axes.titlesize": 11, + "axes.labelsize": 10, + "axes.prop_cycle": mpl.cycler(color=COLOURS), + "axes.spines.top": False, + "axes.spines.right": False, + "axes.grid": True, + "grid.alpha": 0.25, + "grid.linewidth": 0.6, + "lines.linewidth": 1.8, + "lines.markersize": 4, + "errorbar.capsize": 0, + "legend.frameon": False, + "legend.fontsize": 9, + "xtick.labelsize": 9, + "ytick.labelsize": 9, + "xtick.direction": "out", + "ytick.direction": "out", + } + ) + + +def band(ax, x, lo, hi, *, color=None, hatch=None, label=None, alpha=None, **kwargs): + """Fill between ``lo`` and ``hi``: a predictive band. + + Pass ``hatch`` (see :data:`HATCHES`) when several bands overlap and the + difference must survive in greyscale; the fill is then lighter and the + edge carries the colour. + """ + hatched = hatch is not None + if alpha is None: + alpha = 0.18 if hatched else 0.28 + return ax.fill_between( + np.asarray(x, dtype=float), + np.asarray(lo, dtype=float), + np.asarray(hi, dtype=float), + color=color, + alpha=alpha, + hatch=hatch, + edgecolor=color if hatched else None, + linewidth=0.8 if hatched else 0.0, + label=label, + **kwargs, + ) + + +def corner_kwargs(**overrides) -> dict: + """Defaults for ``corner.corner``; keyword arguments override them.""" + kwargs = { + "levels": (0.39, 0.68, 0.95), + "smooth": 0.8, + "bins": 32, + "color": COLOURS[0], + "plot_datapoints": False, + "fill_contours": True, + "show_titles": True, + "title_fmt": ".2f", + "title_kwargs": {"fontsize": 9}, + "label_kwargs": {"fontsize": 10}, + "truth_color": COLOURS[6], + } + kwargs.update(overrides) + return kwargs + + +def label_at(ax, x, y, text, *, color=None, **kwargs): + """A small text label on a curve, for datasets offset in ``y``.""" + return ax.text( + x, + y, + text, + color=color, + fontsize=8, + va="bottom", + ha="left", + **kwargs, + ) + + +def _demo() -> None: # pragma: no cover - a visual check, not run by the tests + use() + x = np.linspace(0, 1, 50) + fig, ax = plt.subplots() + for i, (colour, hatch) in enumerate(zip(COLOURS, HATCHES)): + band(ax, x, i + x, i + 1.5 * x, color=colour, hatch=hatch, label=f"band {i}") + ax.legend() + plt.show() diff --git a/examples/robust_likelihoods.ipynb b/examples/robust_likelihoods.ipynb index 78a8863..64da06a 100644 --- a/examples/robust_likelihoods.ipynb +++ b/examples/robust_likelihoods.ipynb @@ -2,80 +2,83 @@ "cells": [ { "cell_type": "markdown", - "id": "d8f105f7", + "id": "9ba60e3a", "metadata": {}, "source": [ - "# Robust likelihoods: Student-t vs the multivariate normal\n", + "# Robust likelihoods\n", "\n", - "The multivariate-normal likelihood penalizes a residual quadratically, so a few\n", - "outliers — mislabeled points, an unreported background, a transcription error —\n", - "leave it **confidently wrong**: the posterior stays narrow around a biased value.\n", - "The **Student-t** likelihood keeps the same covariance $\\Sigma$ but replaces the\n", - "Gaussian functional with a heavy-tailed one carrying a degrees-of-freedom\n", - "parameter $\\nu$: small $\\nu$ means heavy tails, $\\nu \\to \\infty$ recovers the\n", - "Gaussian. Sampling $\\nu$ lets the *data* decide how heavy the tails need to be\n", - "— and, as we will see, the multivariate-t's honesty shows up as **wider,\n", - "truth-covering uncertainty**, not as outlier rejection.\n" + "A few gross outliers make a Gaussian fit confidently wrong. This notebook puts four treatments of the same outlier-ridden data side by side, and compares them with each other and with the truth in the same figures:\n", + "\n", + "1. **Gaussian.** Take every point and every reported error at face value.\n", + "2. **Global error scale.** Keep the Gaussian, but multiply every reported error by one factor that we infer from the data.\n", + "3. **Tempered.** Turn the whole likelihood down, so the data count for less.\n", + "4. **Iterative rejection.** Decide which points do not belong to the measurement, drop them, and refit, as the KDUQ optical-model fit does ([Pruitt, Escher & Rahman 2023](https://arxiv.org/abs/2211.07741)).\n", + "\n", + "They make different claims about the data, and we will see that three of them centre the line in the same place. At the end we look at tempering once more, on a problem where nothing is wrong, to see what it costs.\n", + "\n", + "Recipes: 12, 17, 33, 34, 39, 40 (see [the recipes](/recipes.md))" ] }, { "cell_type": "code", "execution_count": 1, - "id": "2bdf89cc", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-03T17:43:52.311562Z", - "iopub.status.busy": "2026-08-03T17:43:52.311358Z", - "iopub.status.idle": "2026-08-03T17:43:54.650591Z", - "shell.execute_reply": "2026-08-03T17:43:54.649500Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Using database version X4-2024-12-31 located in: /home/kyle/db/exfor/unpack_exfor-2024/X4-2024-12-31\n" - ] - } - ], + "id": "7959739e", + "metadata": {}, + "outputs": [], "source": [ + "import blackjax\n", "import corner\n", + "import emcee\n", + "import jax.numpy as jnp\n", + "import matplotlib.pyplot as plt\n", "import numpy as np\n", - "from matplotlib import pyplot as plt\n", + "import plotstyle\n", + "from budget import budget # sampler budgets, cut in CI's quick run\n", "from scipy import stats\n", "\n", - "import rxmc\n", + "import rxmc as rx\n", "\n", - "rng = np.random.default_rng(21)" + "plotstyle.use()" ] }, { "cell_type": "markdown", - "id": "8e3985d0", + "id": "97a2d3d6", "metadata": {}, "source": [ - "## A clean linear signal with a few gross outliers" + "## A clean signal with a few gross outliers\n", + "\n", + "We sample twenty-five points about a true line with Gaussian noise of a fixed size, 0.05 (between 1 and 10 % of the signal), and then push three of them up by about ten times their error. They could stand in for, say, a background the experiment did not subtract." ] }, { "cell_type": "code", "execution_count": 2, - "id": "7594ebbb", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-03T17:43:54.653141Z", - "iopub.status.busy": "2026-08-03T17:43:54.652804Z", - "iopub.status.idle": "2026-08-03T17:43:54.806038Z", - "shell.execute_reply": "2026-08-03T17:43:54.805138Z" - } - }, + "id": "ea62264b", + "metadata": {}, + "outputs": [], + "source": [ + "rng = np.random.default_rng(21)\n", + "m_true, b_true = 1.0, 0.5\n", + "x = np.linspace(0.0, 4.0, 25)\n", + "noise = 0.05\n", + "y = m_true * x + b_true + rng.normal(0.0, noise, x.size)\n", + "outliers = np.array([5, 12, 19])\n", + "y[outliers] += np.array([10.0, 12.0, 9.0]) * noise\n", + "data = rx.Dataset(x, y, np.full(x.size, noise), label=\"with outliers\")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "29524df1", + "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -83,193 +86,381 @@ } ], "source": [ - "class LinearModel(rxmc.physical_model.PhysicalModel):\n", - " def __init__(self):\n", - " super().__init__(\n", - " [rxmc.params.Parameter(\"m\", float), rxmc.params.Parameter(\"b\", float)]\n", - " )\n", + "fig, ax = plt.subplots()\n", + "ax.errorbar(data.x, data.y, data.y_err, fmt=\".\", ms=6, color=\"k\", label=\"data\")\n", + "ax.plot(\n", + " x[outliers],\n", + " y[outliers],\n", + " \"o\",\n", + " ms=12,\n", + " mfc=\"none\",\n", + " color=plotstyle.COLOURS[1],\n", + " label=\"outliers\",\n", + ")\n", + "ax.plot(x, m_true * x + b_true, \"--\", color=plotstyle.COLOURS[1], label=\"truth\")\n", + "ax.set(xlabel=\"$x$\", ylabel=\"$y$\", title=\"Twenty-five points, three of them wrong\")\n", + "ax.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "14326475", + "metadata": {}, + "source": [ + "## The model, and how we sample\n", "\n", - " def evaluate(self, observation, m, b):\n", - " return self.y(observation.x, m, b)\n", + "A line, $y_m(x; m, b) = m x + b$, with priors $m \\sim \\mathcal{N}(1, 1)$ and $b \\sim \\mathcal{N}(0, 1)$: wide, centred on the truth for $m$ and half a prior width below it for $b$.\n", "\n", - " def y(self, x, m, b):\n", - " return m * x + b\n", + "Every fit runs [emcee](https://emcee.readthedocs.io/), much as in `linear_calibration`: the walkers start in a small ball about the posterior mode from `rx.optimize.find_map` (jittered on the unconstrained scale, so every start respects the bounds), and before any sample is used `fit` checks the acceptance fraction, emcee's integrated autocorrelation time $\\tau$ against the length of the run ($50\\tau$ at least), the rank-normalised split $\\hat R$ with walkers as chains, and any walker whose log posterior sits far below the others, and prints a verdict. We drop the first five $\\tau$ as burn-in and keep every $\\tau/2$-th step." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "9d27c882", + "metadata": {}, + "outputs": [], + "source": [ + "m = rx.Parameter(\"m\", prior=stats.norm(1.0, 1.0), latex=\"m\")\n", + "b = rx.Parameter(\"b\", prior=stats.norm(0.0, 1.0), latex=\"b\")\n", + "line = rx.Model(lambda x, m, b: m * x + b, [m, b])\n", + "comp = rx.Comparison(data, line)\n", "\n", "\n", - "model = LinearModel()\n", - "m_true, b_true = 1.0, 0.5\n", - "noise = 0.05\n", + "def fit(problem, seed, n_walkers=24, n_steps=budget(8000), label=\"\"):\n", + " \"\"\"emcee from a ball about the MAP; checked, then burnt in and thinned by tau.\"\"\"\n", + " theta_map = rx.optimize.find_map(problem, rng=seed).x\n", + " z_map = problem.to_unconstrained(theta_map)\n", + " jitter = 1e-3 * np.random.default_rng(seed).standard_normal(\n", + " (n_walkers, problem.ndim)\n", + " )\n", + " start = np.array([problem.to_theta(z_map + dz) for dz in jitter])\n", + " sampler = emcee.EnsembleSampler(\n", + " n_walkers, problem.ndim, problem.log_posterior_batch, vectorize=True\n", + " )\n", + " sampler.random_state = np.random.RandomState(seed).get_state()\n", + " sampler.run_mcmc(start, n_steps, progress=False)\n", + " tau = sampler.get_autocorr_time(discard=n_steps // 5, quiet=True).max()\n", + " discard, thin = int(5 * tau), max(1, int(tau / 2))\n", + " walkers = np.swapaxes(sampler.get_chain(discard=discard, thin=thin), 0, 1)\n", + " rhat = float(np.max(blackjax.diagnostics.rhat(walkers)))\n", + " walker_log_post = sampler.get_log_prob(discard=discard).mean(axis=0)\n", + " stragglers = np.flatnonzero(walker_log_post < np.median(walker_log_post) - 20)\n", + " acceptance = sampler.acceptance_fraction\n", + " converged = (\n", + " n_steps >= 50 * tau\n", + " and rhat <= 1.01\n", + " and stragglers.size == 0\n", + " and acceptance.min() > 0.1\n", + " )\n", + " print(\n", + " f\"{label}acceptance {acceptance.min():.2f}-{acceptance.max():.2f}, \"\n", + " f\"run = {n_steps / tau:.0f} tau, split R-hat {rhat:.3f}, \"\n", + " f\"stragglers: {stragglers.tolist() or 'none'}: \"\n", + " + (\"converged\" if converged else \"NOT CONVERGED\")\n", + " )\n", + " return sampler.get_chain(discard=discard, thin=thin, flat=True)" + ] + }, + { + "cell_type": "markdown", + "id": "e9cabd91", + "metadata": {}, + "source": [ + "## Four treatments of the same constraint\n", "\n", - "x = np.linspace(0.0, 4.0, 25)\n", - "y = model.y(x, m_true, b_true) + rng.normal(0.0, noise, x.size)\n", + "**1. Gaussian.** The default constraint: the reported errors on the diagonal, and the multivariate normal.\n", "\n", - "outliers = np.array([5, 12, 19])\n", - "y[outliers] += np.array([10.0, 12.0, 9.0]) * noise # one-sided: a fake background\n", + "**2. Global error scale** (recipe 34). One factor $s$ multiplies every reported error: a diagonal term $s\\,\\sigma_i$ on a constraint built with `statistical=False`, so that it *replaces* the reported diagonal rather than adding to it. We give $\\log s$ a $\\mathcal{N}(0, 1)$ prior, wide enough to allow the factor of a few that three gross outliers can ask for.\n", + "\n", + "A [multivariate Student-t](https://en.wikipedia.org/wiki/Multivariate_t-distribution) likelihood of the whole residual is this same treatment in disguise. It depends on the residual only through the squared [Mahalanobis distance](https://en.wikipedia.org/wiki/Mahalanobis_distance) $d^2$, and it is exactly a Gaussian whose covariance is multiplied by one unknown scale, averaged over an inverse-gamma prior set by its degrees of freedom $\\nu$:\n", "\n", - "obs = rxmc.observation.Observation(x=x, y=y, y_stat_err=noise * np.ones_like(y))\n", + "\\begin{equation}\n", + "t_\\nu(\\mathbf{r};\\Sigma) = \\int_0^\\infty \\mathcal{N}(\\mathbf{r}; 0, s^2\\,\\Sigma)\\, \\mathrm{InvGamma}\\!\\left(s^2; \\tfrac{\\nu}{2}, \\tfrac{\\nu}{2}\\right) ds^2 .\n", + "\\end{equation}\n", "\n", - "xg = np.linspace(-0.2, 4.2, 100)\n", - "plt.plot(xg, model.y(xg, m_true, b_true), \"k:\", label=\"true signal\")\n", - "plt.errorbar(x, y, noise, ls=\"none\", marker=\".\", label=\"data\")\n", - "plt.plot(x[outliers], y[outliers], \"o\", mfc=\"none\", color=\"tab:red\", label=\"outliers\")\n", - "plt.xlabel(\"x\")\n", - "plt.ylabel(\"y\")\n", - "plt.legend();" + "So we write the scale explicitly, where we can see it and choose its prior. One $s$ is shared by every point: it can inflate *all* the error bars together, but it cannot single out the three bad points and give them less weight, and for any fixed $s$ the best fit is the Gaussian's.\n", + "\n", + "**3. Tempered** (recipe 12). `rx.Constraint(..., weight=w)` multiplies the constraint's log-likelihood by $w$, giving the *power posterior* $p_w(\\alpha \\mid y) \\propto p(y \\mid \\alpha)^w\\, p(\\alpha)$. KDUQ tempers with $w = k/N$, for $k$ parameters and $N$ points: the paper describes it as a rescaling of the covariance, but what was done (the authors, private communication) is a scaling of the whole log-likelihood (recipe 26). Here $w = 2/25$.\n", + "\n", + "**4. Iterative rejection** (recipe 39). Fit, drop the points more than three reported errors from the fitted line, and refit, until the set of rejected points stops changing. KDUQ rejects points this way ([Pruitt, Escher & Rahman 2023](https://arxiv.org/abs/2211.07741)). Masks in `rxmc` are compiled into the problem, so each round is a new `Problem` over the same objects, and the parameters keep their columns." ] }, { - "cell_type": "markdown", - "id": "34ea6351", + "cell_type": "code", + "execution_count": 5, + "id": "643c06d8", "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Gaussian ['m', 'b']\n", + "global scale ['m', 'b', 'log_s']\n", + "tempered ['m', 'b']\n" + ] + } + ], "source": [ - "## The same constraint, two likelihood functionals\n", - "\n", - "The likelihood functional is orthogonal to the covariance: both constraints below\n", - "share the identical statistical $\\Sigma$; only the function of\n", - "$(d^2, \\log\\det\\Sigma, n)$ differs. The Student-t brings one likelihood-side\n", - "parameter, and the **full-tuple convention** applies everywhere: every\n", - "`Constraint` method takes covariance parameters followed by likelihood\n", - "parameters, in `constraint.params` order — including `chi2`, even though the\n", - "chi-squared statistic ignores $\\nu$.\n" + "# the scale multiplies the data's own errors, held as an array: a grid prediction\n", + "# (grid_draws) has no such errors, so it needs model_only=True for this term\n", + "log_s = rx.Parameter(\"log_s\", prior=stats.norm(0.0, 1.0), latex=r\"\\log s\")\n", + "scaled = rx.Term(lambda c, ls: jnp.exp(ls) * comp.y_err, (log_s,), kind=\"diag\", on=comp)\n", + "problems = {\n", + " \"Gaussian\": rx.Problem([rx.Constraint([comp])]),\n", + " \"global scale\": rx.Problem(\n", + " [rx.Constraint([comp], terms=[scaled], statistical=False)]\n", + " ),\n", + " \"tempered\": rx.Problem([rx.Constraint([comp], weight=2 / data.n)]),\n", + "}\n", + "for name, p in problems.items():\n", + " print(f\"{name:12s} {p.names}\")" ] }, { "cell_type": "code", - "execution_count": 3, - "id": "b0ee0605", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-03T17:43:54.807838Z", - "iopub.status.busy": "2026-08-03T17:43:54.807661Z", - "iopub.status.idle": "2026-08-03T17:43:54.812937Z", - "shell.execute_reply": "2026-08-03T17:43:54.811975Z" + "execution_count": 6, + "id": "6a761650", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Gaussian acceptance 0.70-0.73, run = 248 tau, split R-hat 1.002, stragglers: none: converged\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "global scale acceptance 0.64-0.65, run = 177 tau, split R-hat 1.005, stragglers: none: converged\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tempered acceptance 0.70-0.73, run = 260 tau, split R-hat 1.004, stragglers: none: converged\n" + ] } - }, + ], + "source": [ + "samples = {\n", + " name: fit(p, seed=k, label=f\"{name:12s} \")\n", + " for k, (name, p) in enumerate(problems.items())\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "d019a6dc", + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Gaussian constraint params: []\n", - "Student-t constraint params: ['degrees_of_freedom']\n" + "round 1: acceptance 0.70-0.73, run = 260 tau, split R-hat 1.002, stragglers: none: converged\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "round 2: acceptance 0.70-0.73, run = 270 tau, split R-hat 1.002, stragglers: none: converged\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "round 3: acceptance 0.71-0.73, run = 252 tau, split R-hat 1.002, stragglers: none: converged\n", + "round 1: rejected points [2, 5, 12, 19]\n", + "round 2: rejected points [5, 12, 19]\n", + "round 3: rejected points [5, 12, 19]\n", + "rejected, by complement(): [5, 12, 19]\n", + "planted outliers: [5, 12, 19]\n" ] } ], "source": [ - "nu_param = rxmc.params.Parameter(\n", - " \"degrees_of_freedom\", float, latex_name=r\"\\nu\", bounds=(1.0, 100.0)\n", - ")\n", + "def reject(constraint, data, *, k=3.0, max_rounds=6, seed=11):\n", + " \"\"\"Fit, drop the points more than k reported errors from the posterior-mean\n", + " line, refit, until the mask stops moving; the final problem, its samples,\n", + " and the points rejected at each round.\"\"\"\n", + " mask = np.ones(data.n, dtype=bool)\n", + " history = []\n", + " for _ in range(max_rounds):\n", + " problem = rx.Problem([constraint.masked([mask])])\n", + " samples = fit(problem, seed, label=f\"round {len(history) + 1}: \")\n", + " theta = samples.mean(axis=0)\n", + " pull = np.abs(data.y - problem.constraints[0].ym(theta)) / data.y_err\n", + " keep = pull < k\n", + " history.append(np.flatnonzero(~keep))\n", + " if np.array_equal(keep, mask):\n", + " return problem, samples, history\n", + " mask = keep\n", + " raise RuntimeError(\"the mask did not settle\")\n", "\n", - "c_gauss = rxmc.constraint.Constraint([obs], model)\n", - "c_t = rxmc.constraint.Constraint(\n", - " [obs], model, likelihood=rxmc.likelihood_model.StudentT(nu_parameter=nu_param)\n", - ")\n", "\n", - "print(\"Gaussian constraint params:\", [p.name for p in c_gauss.params])\n", - "print(\"Student-t constraint params:\", [p.name for p in c_t.params])" + "problems[\"rejection\"], samples[\"rejection\"], history = reject(\n", + " rx.Constraint([comp]), data\n", + ")\n", + "for i, gone in enumerate(history, start=1):\n", + " print(f\"round {i}: rejected points {gone.tolist()}\")\n", + "rejected = problems[\"rejection\"].constraints[0].source.complement()\n", + "print(\"rejected, by complement():\", np.flatnonzero(rejected.masks[0]).tolist())\n", + "print(\"planted outliers: \", outliers.tolist())" ] }, { "cell_type": "markdown", - "id": "89342ff5", + "id": "88c168cb", "metadata": {}, "source": [ - "## Sampling $\\nu$ alongside the model\n", + "Watch the first round: it rejects *four* points, not three. That first fit is still dragged upwards by the outliers, so a good point at $x = 0.33$ looks discrepant too, and once the three real outliers are gone the second round puts it back. That is why the procedure is a loop rather than a single pass, and why we print the history rather than only the final mask. At convergence it has found exactly the three points we planted. Nothing was deleted: the rejected points stay in the declaration, and `complement()` names them." + ] + }, + { + "cell_type": "markdown", + "id": "e17971bc", + "metadata": {}, + "source": [ + "## The four answers, side by side\n", "\n", - "$\\nu$ is a likelihood parameter, so it goes to a `likelihood_samplers` entry in\n", - "the `Walker` — the Gibbs framework alternates between the physics block and the\n", - "nuisance block.\n" + "First the numbers: each treatment's median and 68 % interval for $m$ and $b$, and how many posterior standard deviations its median sits from the truth." ] }, { "cell_type": "code", - "execution_count": 4, - "id": "08a8ecf5", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-03T17:43:54.814637Z", - "iopub.status.busy": "2026-08-03T17:43:54.814441Z", - "iopub.status.idle": "2026-08-03T17:44:01.618243Z", - "shell.execute_reply": "2026-08-03T17:44:01.617393Z" - } - }, + "execution_count": 8, + "id": "9aeaeda8", + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Gaussian m = 1.002 ± 0.008 b = 0.566 ± 0.019 (truth b = 0.5 is 3.4 sigma away)\n", - "Student-t m = 1.002 ± 0.028 b = 0.562 ± 0.067 (truth b = 0.5 is 0.9 sigma away)\n" + " m (68 %) pull b (68 %) pull\n", + "Gaussian 1.002 [ 0.993, 1.010] +0.2 0.566 [ 0.546, 0.586] +3.3 \n", + "global scale 1.002 [ 0.974, 1.030] +0.1 0.565 [ 0.497, 0.631] +1.0 \n", + "tempered 1.003 [ 0.973, 1.031] +0.1 0.564 [ 0.497, 0.631] +0.9 \n", + "rejection 1.000 [ 0.991, 1.008] -0.0 0.512 [ 0.492, 0.531] +0.6 \n", + "global scale s: median 3.41, 68 % interval [2.98, 3.96]\n" ] } ], "source": [ - "model_prior = stats.multivariate_normal(mean=[1.0, 0.5], cov=np.diag([0.3, 0.3]) ** 2)\n", - "\n", - "\n", - "def make_model_sampler():\n", - " return rxmc.param_sampling.BatchedAdaptiveMetropolisSampler(\n", - " params=model.params,\n", - " starting_location=model_prior.mean,\n", - " prior=model_prior,\n", - " initial_proposal_cov=model_prior.cov / 100,\n", + "style = {\n", + " \"Gaussian\": (plotstyle.COLOURS[1], plotstyle.HATCHES[0]),\n", + " \"global scale\": (plotstyle.COLOURS[0], plotstyle.HATCHES[1]),\n", + " \"tempered\": (plotstyle.COLOURS[2], plotstyle.HATCHES[2]),\n", + " \"rejection\": (plotstyle.COLOURS[4], plotstyle.HATCHES[3]),\n", + "}\n", + "truths = {\"m\": m_true, \"b\": b_true}\n", + "print(f\"{'':12s} {'m (68 %)':>24s} {'pull':>5s} {'b (68 %)':>24s} {'pull':>5s}\")\n", + "for name, p in problems.items():\n", + " row = f\"{name:12s}\"\n", + " for par in line.params:\n", + " draws = samples[name][:, p.columns(par)].ravel()\n", + " lo, mid, hi = np.percentile(draws, [16, 50, 84])\n", + " pull = (mid - truths[par.name]) / draws.std()\n", + " row += f\" {mid:8.3f} [{lo:6.3f}, {hi:6.3f}] {pull:+5.1f} \"\n", + " print(row)\n", + "s_scale = np.exp(samples[\"global scale\"][:, problems[\"global scale\"].columns(log_s)])\n", + "q = np.percentile(s_scale, [16, 50, 84])\n", + "print(f\"global scale s: median {q[1]:.2f}, 68 % interval [{q[0]:.2f}, {q[2]:.2f}]\")" + ] + }, + { + "cell_type": "markdown", + "id": "0acb00f6", + "metadata": {}, + "source": [ + "Then the fitted line itself, as a residual to the truth: each treatment's 68 % band of $y_m(x; m, b) - (m_\\text{true} x + b_\\text{true})$. These bands are the model alone; they say where each fit puts the true line, not where a new measurement would land. A band that contains zero covers the truth there." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "ee625a60", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "x_fine = np.linspace(-0.5, 4.5, 60)\n", + "on_fine = line.bind(x_fine)\n", + "truth_fine = m_true * x_fine + b_true\n", + "fig, ax = plt.subplots()\n", + "for name, p in problems.items():\n", + " lo, hi = rx.predictive.grid_draws(\n", + " p, on_fine, x_fine, samples[name][::5], model_only=True, levels=(16, 84)\n", " )\n", - "\n", - "\n", - "nu_prior = stats.multivariate_normal(mean=[10.0], cov=[[49.0]])\n", - "nu_sampler = rxmc.param_sampling.BatchedAdaptiveMetropolisSampler(\n", - " params=list(c_t.params),\n", - " starting_location=np.array([10.0]),\n", - " prior=nu_prior,\n", - " initial_proposal_cov=np.array([[4.0]]),\n", + " colour, hatch = style[name]\n", + " plotstyle.band(\n", + " ax,\n", + " x_fine,\n", + " lo - truth_fine,\n", + " hi - truth_fine,\n", + " color=colour,\n", + " hatch=hatch,\n", + " label=name,\n", + " )\n", + "kept = problems[\"rejection\"].constraints[0].source.masks[0] # boolean, per point\n", + "residual = data.y - (m_true * data.x + b_true)\n", + "ax.errorbar(\n", + " data.x[kept],\n", + " residual[kept],\n", + " data.y_err[kept],\n", + " fmt=\"o\",\n", + " ms=3,\n", + " color=\"k\",\n", + " label=\"kept\",\n", ")\n", - "\n", - "walker_gauss = rxmc.walker.Walker(\n", - " make_model_sampler(),\n", - " rxmc.evidence.Evidence([c_gauss]),\n", - " rng=np.random.default_rng(1),\n", + "ax.plot(\n", + " data.x[~kept],\n", + " residual[~kept],\n", + " \"x\",\n", + " ms=8,\n", + " color=plotstyle.COLOURS[1],\n", + " label=\"rejected\",\n", ")\n", - "walker_t = rxmc.walker.Walker(\n", - " make_model_sampler(),\n", - " rxmc.evidence.Evidence([c_t]),\n", - " likelihood_samplers=[nu_sampler],\n", - " rng=np.random.default_rng(2),\n", + "ax.axhline(0.0, ls=\"--\", color=\"k\")\n", + "ax.set(\n", + " xlabel=\"$x$\",\n", + " ylabel=r\"$y - y_\\mathrm{truth}$\",\n", + " title=\"Four answers\",\n", + " ylim=(-0.45, 0.75),\n", ")\n", - "\n", - "for walker in (walker_gauss, walker_t):\n", - " walker.walk(n_steps=6000, burnin=2000, batch_size=1000, verbose=False)\n", - "\n", - "chain_gauss = walker_gauss.model_sampler.chain\n", - "chain_t = walker_t.model_sampler.chain\n", - "nu_chain = walker_t.likelihood_samplers[0].chain\n", - "\n", - "for name, ch in [(\"Gaussian\", chain_gauss), (\"Student-t\", chain_t)]:\n", - " z = abs(ch[:, 1].mean() - b_true) / ch[:, 1].std()\n", - " print(\n", - " f\"{name:10s} m = {ch[:, 0].mean():.3f} ± {ch[:, 0].std():.3f} \"\n", - " f\"b = {ch[:, 1].mean():.3f} ± {ch[:, 1].std():.3f} \"\n", - " f\"(truth b = {b_true} is {z:.1f} sigma away)\"\n", - " )" + "ax.legend(fontsize=8, ncol=3, loc=\"lower center\")\n", + "plt.show()" ] }, { "cell_type": "code", - "execution_count": 5, - "id": "9e6a0c15", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-03T17:44:01.620568Z", - "iopub.status.busy": "2026-08-03T17:44:01.620348Z", - "iopub.status.idle": "2026-08-03T17:44:01.822830Z", - "shell.execute_reply": "2026-08-03T17:44:01.821741Z" - } - }, + "execution_count": 10, + "id": "4827d299", + "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -277,53 +468,123 @@ } ], "source": [ - "fig = corner.corner(\n", - " chain_t,\n", - " labels=[\"m\", \"b\"],\n", - " truths=[m_true, b_true],\n", - " truth_color=\"k\",\n", - " color=\"tab:blue\",\n", + "pooled = np.vstack([samples[n][:, p.columns(line.params)] for n, p in problems.items()])\n", + "span = list(zip(*np.percentile(pooled, [0.5, 99.5], axis=0)))\n", + "fig = None\n", + "for name, p in problems.items():\n", + " fig = corner.corner(\n", + " samples[name][:, p.columns(line.params)],\n", + " fig=fig,\n", + " labels=[\"$m$\", \"$b$\"],\n", + " truths=[m_true, b_true],\n", + " range=span,\n", + " **plotstyle.corner_kwargs(\n", + " color=style[name][0],\n", + " fill_contours=False,\n", + " plot_density=False,\n", + " show_titles=False,\n", + " levels=(0.68, 0.95),\n", + " hist_kwargs={\"density\": True},\n", + " ),\n", + " )\n", + "fig.legend(\n", + " handles=[plt.Line2D([], [], color=style[n][0], label=n) for n in problems],\n", + " loc=\"upper right\",\n", ")\n", - "corner.corner(chain_gauss, fig=fig, color=\"tab:red\")\n", - "plt.plot([], [], color=\"tab:blue\", label=\"Student-t\")\n", - "plt.plot([], [], color=\"tab:red\", label=\"Gaussian\")\n", - "fig.legend(loc=\"upper right\");" + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "7e5bd536", + "metadata": {}, + "source": [ + "The four treatments split into two kinds.\n", + "\n", + "The Gaussian, the global scale and the tempered fit all centre the line in the same place, $b \\approx 0.56$, dragged up by the outliers, and the Gaussian is confidently wrong about it: 3.3 standard deviations from the truth. The global scale and the tempered fit cover the truth only because they are more than three times wider. That those two agree so closely is no coincidence. For a fixed covariance, tempering by $w$ is the Gaussian with every error bar multiplied by $1/\\sqrt{w}$, here $\\sqrt{25/2} \\approx 3.5$; the global scale is the Gaussian with every error bar multiplied by one *inferred* factor, and the outliers ask for $s = 3.41$ [2.98, 3.96], almost exactly the factor tempering imposes. Both inflate *all* the error bars to accommodate three bad points, so the twenty-two good points lose most of their information.\n", + "\n", + "Rejection is the only treatment that moves the line: $b = 0.512$, at the Gaussian's width, because it fits twenty-two good points with their honest errors. That tightness is the thing to be careful about. Rejection is a strong claim: we are asserting that those points are not measurements of this signal, and the uncertainty we report afterwards does not include the possibility that we were wrong about that. The inflating treatments make a weaker claim, and pay for it with width. Which is right is a question about the experiment, not about the statistics. If we cannot answer it, the honest thing is to report both, score them by holding data out (recipe 11), and say what we did." ] }, { "cell_type": "markdown", - "id": "883c01ed", + "id": "689a7678", "metadata": {}, "source": [ - "Both posteriors are shifted by the one-sided outliers — but the Gaussian is\n", - "**confidently wrong** (truth excluded at $\\sim 3.5\\sigma$) while the Student-t\n", - "inflates its uncertainty until the truth is covered ($\\lesssim 1\\sigma$).\n", + "## Tempering when nothing is wrong\n", "\n", - "This is the multivariate-t's character: it carries **one** radial tail factor\n", - "for the whole stacked residual, so it cannot single out and reject individual\n", - "points — it broadens the posterior instead of relocating it. Per-point outlier\n", - "rejection would need per-point machinery (e.g. a free noise nuisance via\n", - "`noise_term`, or explicitly masking suspect points).\n" + "Tempering is usually justified as a guard against overconfidence, so it is worth asking what it does to a problem with nothing to guard against. We take a *correctly specified* problem on purpose: 200 points on a straight line, each with 5 % noise, reported honestly (computed from the true line, as an experiment would from its expected rate). We set the prior on $m$ deliberately off-centre, $m \\sim \\mathcal{N}(1, 0.5^2)$ against a truth of 2, two prior widths away, to see how much of the prior a tempered posterior lets back in. The prior on $b$, $\\mathcal{N}(4, 0.5^2)$, is centred on its truth." ] }, { "cell_type": "code", - "execution_count": 6, - "id": "a1f32cc9", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-03T17:44:01.825295Z", - "iopub.status.busy": "2026-08-03T17:44:01.825036Z", - "iopub.status.idle": "2026-08-03T17:44:02.702670Z", - "shell.execute_reply": "2026-08-03T17:44:02.701239Z" + "execution_count": 11, + "id": "0159eaa5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "untempered acceptance 0.70-0.73, run = 256 tau, split R-hat 1.002, stragglers: none: converged\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tempered acceptance 0.70-0.73, run = 247 tau, split R-hat 1.002, stragglers: none: converged\n", + "untempered m = 1.988 [1.928, 2.047] (pull -0.2) b = 4.009 [3.979, 4.041] (pull +0.3) \n", + "tempered m = 1.463 [1.098, 1.833] (pull -1.5) b = 4.216 [3.998, 4.432] (pull +1.0) \n" + ] } - }, + ], + "source": [ + "rng_200 = np.random.default_rng(11)\n", + "x200 = np.linspace(0.0, 1.0, 200)\n", + "m200_true, b200_true = 2.0, 4.0\n", + "y200_true = m200_true * x200 + b200_true\n", + "y200 = y200_true * (1.0 + rng_200.normal(0.0, 0.05, x200.size))\n", + "d200 = rx.Dataset(x200, y200, 0.05 * y200_true, label=\"N = 200\")\n", + "\n", + "m200 = rx.Parameter(\"m\", prior=stats.norm(1.0, 0.5), latex=\"m\")\n", + "b200 = rx.Parameter(\"b\", prior=stats.norm(4.0, 0.5), latex=\"b\")\n", + "line200 = rx.Model(lambda x, m, b: m * x + b, [m200, b200])\n", + "comp200 = rx.Comparison(d200, line200)\n", + "p_full = rx.Problem([rx.Constraint([comp200])])\n", + "p_temp = rx.Problem([rx.Constraint([comp200], weight=2 / d200.n)])\n", + "s_full = fit(p_full, 3, label=\"untempered \")\n", + "s_temp = fit(p_temp, 4, label=\"tempered \")\n", + "for name, p, s in ((\"untempered\", p_full, s_full), (\"tempered\", p_temp, s_temp)):\n", + " row = f\"{name:11s}\"\n", + " for par, true in zip(line200.params, (m200_true, b200_true)):\n", + " draws = s[:, p.columns(par)].ravel()\n", + " lo, mid, hi = np.percentile(draws, [16, 50, 84])\n", + " row += f\" {par.name} = {mid:.3f} [{lo:.3f}, {hi:.3f}] (pull {(mid - true) / draws.std():+.1f}) \"\n", + " print(row)" + ] + }, + { + "cell_type": "markdown", + "id": "0d502f74", + "metadata": {}, + "source": [ + "The untempered fit covers the truth comfortably: both medians are within a third of a standard deviation of it. Two hundred points at 5 % each really do pin a straight line down that well. Tempering by $k/N = 2/200$ widens the posterior about sixfold, and here it makes the answer worse: $m = 1.46$ [1.10, 1.83], 1.5 standard deviations low. That is the deliberately off-centre prior showing through. With the likelihood turned down to a hundredth of its strength, the prior gets a much bigger say.\n", + "\n", + "On the prior's own scale the difference is plain. Below we draw the prior, the tempered posterior and the untempered posterior on one corner plot, zoomed out to about three prior widths either side. The untempered posterior collapses to a spike. That can look alarming next to a wide prior, and it is easy to read as a failure to cover the truth, but it isn't one: in a correctly specified problem with this much data, a spike is the right answer." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "9e6ffd26", + "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -331,84 +592,106 @@ } ], "source": [ - "plt.hist(nu_chain[:, 0], bins=40, color=\"tab:blue\", alpha=0.7)\n", - "plt.xlabel(r\"$\\nu$\")\n", - "plt.ylabel(\"posterior samples\")\n", - "plt.title(f\"heavy tails demanded: median $\\\\nu$ = {np.median(nu_chain):.1f}\");" + "prior_draws = p_full.sample_prior(len(s_full), rng=5)\n", + "prior_span = [(-0.6, 2.6), (2.4, 5.6)] # the prior to about 3.2 widths either side\n", + "# the untempered posterior is drawn last, so the 1-D panels are scaled to its\n", + "# spike and the prior and tempered histograms show how flat they are beside it\n", + "fig = None\n", + "for s, colour in (\n", + " (prior_draws, plotstyle.COLOURS[6]),\n", + " (s_temp, plotstyle.COLOURS[2]),\n", + " (s_full, plotstyle.COLOURS[0]),\n", + "):\n", + " fig = corner.corner(\n", + " s,\n", + " fig=fig,\n", + " labels=[\"$m$\", \"$b$\"],\n", + " truths=[m200_true, b200_true],\n", + " range=prior_span,\n", + " **plotstyle.corner_kwargs(\n", + " color=colour,\n", + " bins=60,\n", + " fill_contours=False,\n", + " plot_density=False,\n", + " show_titles=False,\n", + " levels=(0.68, 0.95),\n", + " truth_color=\"k\",\n", + " hist_kwargs={\"density\": True, \"linewidth\": 1.6},\n", + " ),\n", + " )\n", + "fig.legend(\n", + " handles=[\n", + " plt.Line2D([], [], color=plotstyle.COLOURS[6], label=\"prior\"),\n", + " plt.Line2D([], [], color=plotstyle.COLOURS[2], label=\"tempered, $w = k/N$\"),\n", + " plt.Line2D([], [], color=plotstyle.COLOURS[0], label=\"untempered\"),\n", + " ],\n", + " loc=\"upper right\",\n", + ")\n", + "plt.show()" ] }, { "cell_type": "markdown", - "id": "fd330f6e", + "id": "e4cace26", "metadata": {}, "source": [ - "## `chi2`: the fit statistic without the normalization\n", + "### What coverage says\n", "\n", - "`Constraint.chi2` returns the generalized chi-squared (the squared Mahalanobis\n", - "distance) under the same $\\Sigma$. Note the full-tuple convention: the\n", - "Student-t constraint requires $\\nu$ in the tuple even though the statistic\n", - "ignores it.\n" + "A tight parameter posterior is not the same thing as an overconfident *prediction*, and the check that tells them apart is the [coverage](https://en.wikipedia.org/wiki/Coverage_probability) of the posterior predictive at the measured points (recipe 17). The untempered predictive should already follow the diagonal, because a prediction of the *data* carries the 5 % noise even when the line itself is pinned down. For contrast we also draw the band of the line alone, which should miss, just as it did in `linear_calibration`. With 200 points, the binomial scatter of a coverage fraction is about $\\pm 0.03$." ] }, { "cell_type": "code", - "execution_count": 7, - "id": "b945e231", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-03T17:44:02.704495Z", - "iopub.status.busy": "2026-08-03T17:44:02.704334Z", - "iopub.status.idle": "2026-08-03T17:44:02.709510Z", - "shell.execute_reply": "2026-08-03T17:44:02.708453Z" - } - }, + "execution_count": 13, + "id": "dace4fdf", + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Gaussian chi2/n = 10.98\n", - "Student-t chi2/n = 10.98\n" + "untempered 68 % width 0.500; coverage at 0.5 / 0.7 / 0.9: 0.55 / 0.74 / 0.93\n", + "tempered 68 % width 0.634; coverage at 0.5 / 0.7 / 0.9: 0.52 / 0.76 / 0.94\n" ] } ], "source": [ - "map_gauss = chain_gauss[np.argmax(walker_gauss.model_sampler.logp_chain)]\n", - "map_t = chain_t[np.argmax(walker_t.model_sampler.logp_chain)]\n", - "nu_map = float(np.median(nu_chain))\n", - "\n", - "chi2_gauss = c_gauss.chi2(tuple(map_gauss))\n", - "chi2_t = c_t.chi2(tuple(map_t), (nu_map,))\n", - "print(f\"Gaussian chi2/n = {chi2_gauss / obs.n_data_pts:.2f}\")\n", - "print(f\"Student-t chi2/n = {chi2_t / obs.n_data_pts:.2f}\")" - ] - }, - { - "cell_type": "markdown", - "id": "1ab2a3ba", - "metadata": {}, - "source": [ - "## Predictive comparison" + "levels = np.linspace(0.05, 0.95, 19)\n", + "at = [int(np.argmin(np.abs(levels - v))) for v in (0.5, 0.7, 0.9)]\n", + "c200 = p_full.constraints[0]\n", + "coverage, width = {}, {}\n", + "for (name, p, s), seed in zip(\n", + " ((\"untempered\", p_full, s_full), (\"tempered\", p_temp, s_temp)), (6, 7)\n", + "):\n", + " draws = rx.diagnostics.predictive_draws(\n", + " p, s[::5], n_rep=2, rng=seed, return_draws=True\n", + " )\n", + " coverage[name] = rx.diagnostics.coverage_curve(draws, c200.y[c200.active], levels)\n", + " width[name] = rx.diagnostics.sharpness(draws).mean()\n", + "line_only = rx.diagnostics.predictive_draws(\n", + " p_full, s_full[::5], model_only=True, return_draws=True\n", + ")\n", + "coverage[\"line alone\"] = rx.diagnostics.coverage_curve(\n", + " line_only, c200.y[c200.active], levels\n", + ")\n", + "for name in (\"untempered\", \"tempered\"):\n", + " print(\n", + " f\"{name:11s} 68 % width {width[name]:.3f}; coverage at 0.5 / 0.7 / 0.9: \"\n", + " + \" / \".join(f\"{c:.2f}\" for c in coverage[name][at])\n", + " )" ] }, { "cell_type": "code", - "execution_count": 8, - "id": "57661fd9", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-03T17:44:02.711407Z", - "iopub.status.busy": "2026-08-03T17:44:02.711236Z", - "iopub.status.idle": "2026-08-03T17:44:02.833905Z", - "shell.execute_reply": "2026-08-03T17:44:02.832486Z" - } - }, + "execution_count": 14, + "id": "7fbe8a37", + "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAioAAAGwCAYAAACHJU4LAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlcelbwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAgbVJREFUeJzs3Xl4XGXd//H3mX0mM5N1JkmbpGmzdQPa0gJlLyBQKLuACqI/UcCCCj5uuFJ8HhEXcEVBRRRBUEBUBNnaUvbSvbTN2uzbTCazJLPPOef3R9pAaIEW2k7SfF/X1etqZs45c98WO5/ey/dWdF3XEUIIIYQYhwzZboAQQgghxLuRoCKEEEKIcUuCihBCCCHGLQkqQgghhBi3JKgIIYQQYtySoCKEEEKIcUuCihBCCCHGLVO2G/BhaJpGT08PLpcLRVGy3RwhhBBC7ANd1xkaGmLKlCkYDO89ZjKhg0pPTw/l5eXZboYQQgghPoDOzk7Kysre85oJHVRcLhcw0lG3253l1gghhBBiX0QiEcrLy0e/x9/LhA4qu6d73G63BBUhhBBigtmXZRtZCyrpdJqf/vSne7x+7rnncsQRR2ShRUIIIYQYb7K26yeZTHLzzTezfft2QqHQ6K9UKpWtJgkhhBBinMn61M/y5cs57rjjst0MIYQQQoxDWQ8q//nPf3j99depqqrijDPOwGazHfDPUFWVdDp9wJ8rxg+z2YzRaMx2M4QQQhxgWQ0qVquVrVu3Ulpayq9//Ws0TeOJJ55g5syZe70+mUySTCZHf45EIu/5fF3X6evrIxQKHchmi3EqLy+PkpISqakjhBCHkawFFYvFwqZNm0ZDSSqV4iMf+QhXX301L7/88l7vue2221ixYsU+f8bukOL1enE4HPIFdpjSdZ1YLIbP5wOgtLQ0yy0SQghxoCi6ruvZbsRuDzzwAFdddRVDQ0M4HI493t/biEp5eTnhcHiP7cmqqtLY2IjX66WwsPCgt11kXyAQwOfzUVtbK9NAQggxjkUiEXJzc/f6/f1OWV+j8nZGoxFN04jFYnsNKlarFavVuk/P2r0mZW/PEYen3X/W6XRagooQQhwmsrY9ub6+fszoiKZp3HfffcyePZuioqID9jky3TN5yJ+1EEIcfrI2orJ9+3Y++tGPcvLJJ5OXl8fTTz9Nb28vjz76aLaaJPZBOp2mpaWFqqoqzGbzpPlsIYQQ2ZG1EZWLL76YZ555hnnz5pGTk8NXvvIVmpqaWLx4cbaaNC6k02nq6+vH7Xbq7u5uZs2aRXt7+6T6bCGEENmR1TUqU6ZM4ZprrslmE8ad9vZ2Zs2aRWtrK5WVldluzh7MZjN1dXVYLJZsN0UIIcQkkLURFbEnTdPYuXMnAC0tLdTX19PV1UUqlaK+vh5VVUkkErS0tDA8PEwsFqO+vn7MM1RVpb6+fq9HEfT19Y1u4d0XkUiEnp6eMa95vV4ef/zxPbYAJ5NJOjo6UFV1jza8vf2aptHV1bXHiJGu69TX11NfX09zc/OY9UtCCCEmLwkq40g0GuXzn/88ANdccw0XXnghK1asoLGxkVmzZvGtb32L0tJSli5dyuuvv87atWuZNWsWmUxm9Bl+v59Zs2bR2Ng4+tprr73G3LlzmTNnDkcccQQ1NTWsWbPmXdsRDoc566yzKC0t5bjjjqO8vJx//vOfwN6nX+6//348Hg8LFy6ksLCQm2++eUwbdrf/O9/5DsXFxRx77LHk5eXx5z//efQZ6XSaCy+8kAsvvJCzzjqLvLw8PvnJTxKLxQ7M/7hCCCEmpEkZVKLRKNFolLeXkEmlUkSj0T3+Jb/7Wk3TRl9Lp9NEo1ESicT7Xrs/XC4XTz/9NADPP/889fX1/O53vxt9/4033qCjo4PGxkZOP/30fXpmb28v55xzDl/+8pcJBAL09/fzla98hYsvvphAILDXe+68804CgQB+v5+Ojg7WrVtHS0vLXq9tb2/ns5/9LD/60Y/w+Xy0t7fzwgsv7PXaLVu20NbWRnd3N7fffjvLly9naGgIGCkAuHtEpaWlhba2Nt58801+8pOf7FM/hRBCHFixVIZntvWxumHfR+IPhkkZVJxOJ06nk4GBgdHXfvzjH+N0OrnhhhvGXOv1enE6nXR0dIy+9utf/xqn08nVV1895trKykqcTic7duw4KO2+5ZZbcLlc+3XPfffdx5QpUzj55JNpamqisbGRJUuWoCjKu46q7C7Es7tmTXFxMV/+8pf3eu3999/P9OnTue666wDIzc3llltu2eu1K1asICcnB4Arr7ySaDQ6ZuQHIJPJ0NnZSTAYZOnSpTz77LP71V8hhBAfXncoziPrulhZ72MwuudSgkNpXBV8E+9txowZ+33Ptm3b6OjoYNmyZWNeLywsZHh4eK/3XH/99SxdupQZM2Zw9tlnc+aZZ3LBBRdgMu35n0tLSwuzZ88e89qcOXP2+typU6eO/t7pdAKMjqhomsYXv/hF/vCHP5CXl4fb7SYSiWC32/e9s0IIIT4UTdPZ2BliTaOfoUQahyX7MSH7LciC3V/Qb69a+9WvfpUbb7xxjy/j3YtP3/6Fef311/O5z31uj+qnbW1te1x7IL3z8/ZW4Ozt61VgZJfOvHnz3nNNyjtVVVVRX1/P2rVrWbVqFd/4xjf42c9+ttcpHbvdTn9//5jX4vH4Pn/Wbn/84x957LHHePPNN6mqqgJGpqB+/vOf7/ezhBBC7L+hRJoXGv1saA/itJqp9rpoD0Sz3azJGVR2Tz+8ncVi2euW271dazab91pwbG/X7i+bzQawT3VUPB4PMLIOpby8HIBNmzaNuebEE0/koYceoqOjg4qKitHXdV1HVdW9jpKk02nMZjPHHXccxx13HGeffTYLFiygq6trj2uPOuoo/v73v5NIJEbb/uKLL+5bZ99mx44dLFiwYDSkwMg6HSGEEAdfeyDKczv66QjEmJrvwGkdP/FgUq5RGc9KSkrIzc3lr3/9K9u3b99rONittraW6upqbrrpJtatW8ejjz7KjTfeOOaaK6+8kiOOOIKzzz6bxx57jPXr13P//fdz7LHH0t3dvdfnLl++nG984xusWrWKdevW8Ytf/ILy8vIxUze7XXXVVdhsNq644gpeeeUVHnroIb7zne8A+1fSfvHixaxcuZIHH3yQN954g//5n//hv//97z7fL4QQYv9lVI3Xdgb4+7ouekMJqrzOMSElEwqT8fuz2EIJKuOOyWTiwQcfZM2aNVx66aWsWLECq9VKXV3dHqMfJpOJJ554AkVRuPbaa3n00Ue59957qaurG10Ia7VaWbVqFZ/4xCe48847ufbaa3n++ef57W9/y7Rp0/bahp///OcUFBRw6623snz5csxmM6tXr8ZoNO5R8M1ut7Ny5UqMRiPXX389jz32GHfddRfw1ujQ3tqvKAp1dXWj02+XXHIJt99+O7/+9a+59tpricfj/OIXvxgzwiLF5oQQ4sAJx9I8saWXp7f1YTIqzPA4MRlGYoGeSZNoaiTV1EC6szOr7VT0t+/RnWDe65joRCJBa2sr06dPH/3CFAeHqqpj1s88+OCDXHPNNQSDwUN6Jo/8mQshxL5p9g2zqt5HZzDGtIIc7Ja3/g5XIxGSjQ1kfD46M2ZmT/dyxWfPP6Cf/17f3+80fiahxIS1fPlyjjvuOI488kjefPNNvva1r3HdddfJwYFCCDHOpDIar+8M8MrOAKqmU+N1YTSMTNPrukamu5tEczN6LI6xoBAluP+bIw40CSriQ/v2t7/N97//fe666y6Kioq49dZb5QwnIYQYZwLDSVbW+3izO0yR00qh0zr6npZIkGxuIt3VhWKxYPR49mud4cEkQUV8aOXl5dxzzz3ZboYQQoh3Ud8XYeUOH/2RBNMKc7CZ35rqyQwMkGxoQA0FMeblo+xa46in0+iZDJiM7/bYQ0KCihBCCHGYSqRVXmkJ8PrOAApQU+zCsGukRFczpFrbSLW1oqsaRo8XZddiWnVoCD0ex+QpxVpVncUeSFARQgghDku+oQTP7/BR3xuh2G0jz/HWjklteIhEYyOZvj6UHCemvJE6YLqqogYHUSwWtscCJHNyOOoA1Aj7MCSoCCGEEIcRXdfZ1hNhdYMP/3CS6UVOLKZd2451jUxPL4nmJvRobGTB7K7SEVoshjYUweTxYK2tZUa0htu/8llOXrwom92RoCKEEEIcLuIplReb/KxtG8RiNFDjfWuqR0smSbU0k+roRDGZRhfM6pqGGgyCojBcmEfp/PkoZgvevHw+9rWfYLU73udTDy4p+CaEEEIcBnrDcR5Z38lLzQMU5Vgpy3eMhpTMYID4hvUkW9swuFwY8/JGQkoyier3odusPLb2Ob719avp7mwbfaa3ogqDIbtRQUZUhBBCiAlM03S2dIdZ3eAjHEtR5XFiNu6a6lEzpDo6SLXsRM+kMXmKUAxGdF1Hi0TQ0ynMFdOwVFfR/497SSUTbH19DWUzagnFUsTTKjlZPvdnUgYVLRpFS6UOyWcZLBYMWV6IdLB0dXVx4okn8sILL7xrOX4hhBAHTzSZ4YVGP+vbgzgsRqq9rtH6J1p0mETD7gWzDkx5eQDomQzq4CC6zYZt9mws5eUoioFrv/MTOpp2MOeYk2kdiGIwwKl1XhbPKMxiDydhUNGiUYIP/w01HD4kn2fMzSX/8sv2O6zU19fzq1/9itdff52hoSHKy8tZuHAhy5cvHz0pOdsymQzt7e37dNKzEEKIA6tzMMZzO/rZ6Y9SXvDWicc6OpneXpJNTWjDUYz5+Si7KoWr0WH0aJRhm4X7HrmbWQuP56LPfAmAvEIvxpx8mn1DlBU4WFLnodrrylr/dpt8QSWVQg2HUaxWDAf5PBgtkUANh9FSqf0KKo888ghXXnklV111FT/5yU8oLS2lu7ub9evXs2TJEpqbmw9iq/ddWVkZra2tlJWVZbspQggxaaiazsaOIC80+oklM9R4nZh2T/WkkiRbWki1d7xjwayKOjiIYjJjnTWLrfWb2LbhNXY2bOMjl3wKhzuX7mCctKZx7IxCTqopwmUbH8egTNrFtAabDUNOzsH99QGCUF9fH5/61Ke4/vrrueeeezjllFOora1lyZIlfOUrX6G+vn702mQySWVlJZWVlVRXV3PGGWfwwAMPjHnea6+9RmVlJaqqjr7m9/uprKyksbERGNnKduedd3L88cdz5JFHcvXVV9Pd3f2+7/X19XHqqaeO/rwv7WlsbKSyspLnnnuOSy65hLlz53Leeefx5ptv7vf/VkIIMdlEEmme2NLDf7b2YlAUqryu0ZCSCQ4S27CR5M6dGJzO0QWzWiKO6vdjzMvHfvQCrNNncPzZF3Hx1Tdy6x8ex2B30tQ/hMtm4sJ5U1k6t2TchBSYhCMq491f//pX4vE43/72t/f6vsn01h+ZxWJh9erVAKTTadatW8cNN9yAyWTi8ssvB0ZOFG5vb+fth2Srqkp7ezupXet0fv/73/PjH/+Ye++9l4qKCtatW8fXv/51/vKXv7zne++c+tmX9qRSKdrb21m+fDl33nknFRUV3HbbbZx//vk0NDTIQYZCCPEu2gaiPLejn47BGBX5Dhy7p3pUdWTBbOtO9FQKk8czsmBW01BDIUCnW1F5+rE/sPz7vwRAURQu/uyN9EUSdIfizK/I5+RaDwU5lndvQJZIUBlntm3bRmlpKfn5+e97raIoVFZWjv5cU1PDzp07uffee0eDwb7YvHkzJ598MmeffTYAs2fP5oorrnjf9z5Me37xi1+MPvNHP/oR5eXlNDU1MXv27H1utxBCTAYZVWNde5CXmgZIZNQxJx5rsehIhdmeXhSHA1ORBwA9lUINDmLMzYVp0/j18ksJ+vv415/v4qOf+zLJjEp7IEaew8x5R03hqLK80WeONxJUxplMJoPtHVNGjz/+ODfeeOPozw888AAnnHACAP/+97/57W9/S1tbG9FolOHhYQoL92+F9vnnn88FF1zAZz/7Wc4991yWLFlC3q7V4e/13t7sa3uOOOKI0d+XlJQAI1NSQggh3hKOpVnV4GNzV4h8u4UpeXZg14LZvn6STU2okQimggIUs3lk2/FQBD2ZwlxRgbW6GoPdwdXf+AEvPvkYSy+/moGhJIOxJDNL3CyZ6aXYfXDXa35Yk3aNynhVWVlJR0cHmUxm9LWPfOQjrF69moceeoj29nbi8TgAzz//PJdffjnnnHMODz74IKtWreJLX/oSyWRyvz7zzDPPZMOGDZSVlfGzn/2MkpISVqxY8b7vvdP+tMdo3PM0zrdPTwkhxGTX4h/mb+s62dARpCzPQZFr96nGKZL1DcQ3b0ZLJDB5vSMhJZNB9fvBYGBzuJdOLYVhV1XZ+Seczudv/SW9CQMpTeOsOSVcvKBs3IcUkKAy7lx00UVkMhnuvffe0ddycnKorKzcY3fN008/zZIlS7j++us56qijmD59Oj09PWOucblGtpYNDw+PvtbR0bHH586aNYtbbrmFF154gUcffZRbbrmFvr6+931vf9sjhBDivaVVjVeaB3h0fRf+4SQ1Xhd2y8g/7tRQkNjGjaRamjHkODDl56MoCunhCD2hHfQb+lnX28Jvf7aCu1bcSCw6BEAolqLFP0xlYQ6XLyxncVXR6Pk/493EaOUkctRRR3HTTTfx1a9+ld/97nfEYrHR9965M2bq1Kls2bKF/v5+AJ599lnuu+++MdfU1dXhcrlGg084HN5joe6PfvQjVq9ePbozqK+vD4vFgtPpfM/33mlf2iOEEOLdhWIp/r25h2e29WM3G6kszMFoGNlenOpoJ7ZhA2oggLHIg8FmR9dUMgN+4sm3aoOV5Rs55bQzOOmcj2Iy22gLRIkk0pxa5+XSheWUF2T37J79NWnXqGiJxLj9jDvuuIPZs2dz5513cu2111JcXEw8HmfKlCnccccdLF68GIBrrrmGZ555hoqKCpxOJ3l5eVx66aWsWbNm9FlOp5N77rmHa6+9lh/84AcYjUaWL1/Os88+O3rNaaedxte+9jXWrVuHxWIhJyeHBx98EKfT+Z7vDQwMjGn3vrRHCCHE3jX7hnm+vp/uYJxpBTmjoyhaPEaysYl0dzeK3Y7J4x15PRFHC4fJuHOIRPt4+1LYJSefhOe4C2kdjFNe4ODUOi/V3j3/gTkRKPoEXhgQiUTIzc0lHA7jdrvHvJdIJGhtbWX69OljFqdOlMq0uw0NDTE8PIzX693ruo7d18TjcbxeL8PDw4RCoT2miTRNIxAI4PF4UFWVzs5Opk6dOmY7cCwWI5FIUFBQsMdn7O29TCZDV1cXZWVlY7ZNv1d70uk03d3dlJeXj+lPW1sbJSUleywk3h/v9mcuhBDjWSqjsbY1wMstATKqTkWBY3QHTrq/n1RTI5lweNeCWQu6rqOGgqDrKKWl3P/Az/nIqSfu8VxD7SkcPbduXBVv2+29vr/fadKNqBhycsi//LIJc9aPy+UaXWeyL9c4nc69TssYDAY8npFta0ajccw24t0cDgcOx96HBPf2nslk2utz3qs9ZrN5r/fs7TUhhDjcDUZTrKzv583uCIU5Fgrzdy+YTZNsbSXV1gaAyVs8UmH2bduOLTW1mIq95JdOQ9O0d5xyrHDW0dUsrC7BME63He+rSRdUgNHKsUIIIUS2NPQNsbLBR18ozrTCHGzmXQtmw2GSjY1kfD4MbjcGu31kFCUSRk+mSBbm46iuwVw0MgV0ybVfw9e0kXj37srlCqedtZRjag+P400mZVARQgghsiWRVnmlJcDrrQHQoabYhUFR0DWNdHcXyeZm9EQCY1ERitE4etqx4rDTYVT57f99mTkLj+fz37sTAN1kJlY4E2VXUPn85z+P1+vJZhcPKAkqQgghxCHSG46zcoePhv4hStw28hwjJeu1RJxkUzPpri4UqxVj0chhgrtPOzaVlGCtqcHS2kgo4KNl+2aiQ2Hi2AhEk8yams+S078+Ieqi7C8JKkIIIcRBpmk6m7pCrGnwE46nmVHkHK1jkvH7STY2ooaCGPMLUCyWkW3HgZHTjo3VVdirqlGMJmqPXMiXf/R7aucdS29Mx2HVOHtuCUdPK5gwdVH21+HZKyGEEGKcGEqkefLNXp7Y3IOq61R7R0KKnkmTbG4ivmkj6vAwRo8XxWIZPe3YkJvHKz3NfOvrVxMJh0afN2PBSXQPaxOyeNsHcfj2TAghhMiy9kCUv63r5I3WQUpy7ZTm2kemdCIR4ps2kWhoBKsNU2EhKAqZ4CBaNIZlRhWWI+ay8unH8Pd28fw/HkDV9NHibadM0OJtH4RM/QghhBAH2JgTj9MqVV4nJoMBXdfIdHeTaGpGj8cxFRaiGw10D2wFoNgxA3tdHabiYhQUrl/xC7avf5XF532CJt8QFRO8eNsHIUFFCCGEOIBCsRQr631s7Q6T97YTj8cumLVg3FXbSo28VYD0yfXPUx4b5ISzLwKgrKoOpaCCQDTN4hmFnDgOi7cdbDL1M8lFo1Guu+46OTxQCCEOgGbfEA+v62RzZ4iyPAeeXSceZwb8xNdvIN3RjtHtxujOBVVFHfAT16Kj98+vm8b6//6N6FCYWCpDU/8QLpuJixZM5ey5JZMupMAkDSrRZIbBaOqQ/IomM/vdPlVV+fvf/863vvUtvv3tb/P444+PHgoI4Pf7ue666wgEAh/6f4t4PM7dd9/N4ODgh37W2+1rGw9kX4QQIltSGY01jX4eXd9FYChF9a4Tj0cXzG5824JZqxU1FiMTCKAU5DGkvvX3r8Fg4OyzzyQUz9AdijO/Ip+PH1PBnCm5KMrErjD7QU26s36iyQwPru0gFE0fkjbm5Zj5xDEV5Fj3bZYtHo9zyimnEA6HueKKK7DZbLzxxhts27aN9evXY7fbaW5upqamhtbW1g9den5gYACPx8PWrVuZO3fuh3rW2+1rGw9kX+SsHyFENgwMJ1lZ72NbTxiP00ZBzkhtFDUSIdnUSLqvH4PLhdHhQNc01OAgitFI1O1k4/bXqS7J3eOZOXNP47RFczmqLG/03J/DiZz18x6SGY1QNI3NbBgtV3ywJNIqoWiaZEYjx7pv9zz88MNs3ryZ3t7eMQcAtrS0YDQaicfjfPe73wXgW9/6Fi6Xizlz5nDWWWdxxx13cNddd42e9xCJRPja177Gd7/7XaZMmQJAKpXi3nvvpbGxkZqaGs4+++y9tuO5557jueeew2AwcMIJJ3DuueeOvtfT08Ott97KLbfcwr///W8aGhqYPn06V199NTab7V3b+IUvfGHMZ+zrdUIIMR7puk593xCr6n30RxJUFuZgNRtHFsz29IwsmI3FMBUWophMaMkkWiiEsSAfZdo0/vfai1GTMW666cuMHSxRuPi4OmZMzc9W18aVSTn1A2AzG8mxmg7qrw8ShAYGBrDZbOS84yyiqqoqLBYLRqORWbNmATB79mzmzZtHVVUVPT093H333WiaNnpPLBbbY1rnvPPO48c//jGFhYVs3LiRU045ZY82fP7zn+eaa67B4XDgcrn40pe+xDXXXDP6/uDgIHfffTcnnXQSW7Zsobi4mF//+tecf/75AO/axnfa1+uEEGK8SaRVVtb7+MfGboYSGWqKXVjNRrRkguT27cS3bgVVHVkwazSihkJoQ0NYKqdhX7AAx5SpnH/V5ykorcBUPOOtBysK55x7LjOmerPXuXFm0k39DEZT/OHFVvIc5n2ejvmgoskMoViaq0+aPjoU+H4aGhqYN28eRx11FFdddRWLFy/mqKOOGnMq5t6mS1avXs2SJUtIp9OYTCP96uvro7S0dHRa54knnuCSSy6hpaWFsrKRw6q+8Y1vcPvtt49e88wzz/Cxj32MxsZGioqKAOju7mbGjBm8+uqrLFiwgDfffJMjjjiC3/72t1x77bUAbNq0ifnz54+2SaZ+hBCHq/5Igud29NPQN7YMfiYwMFJhdjCIIS8Pg9WKnk6jBoMYnDl06ynyqmspnjoNGBmRGYhEGYxrTHMpzC0yMrNyyvtOhRwOZOpnAqurq2Pjxo3ccccd/OQnP6G1tZWCggJuvPFGvv3tb3+oxVSrVq3ihBNOGA0pAB//+Me5/fbbR3/+97//jcPh4JZbbkHXdXbnWKvVysaNG1mwYMHotWeeeebo73ePjHR2dn7owCGEEOORpum82RNmdYOPwehbZfB1NUOqo4NUy070TAajpwjFYEQdGhqplVJawvqORu750Tepmj2P7/zmb2Aw0jEYxWRQOLXOy+KqwoO+HGGikqAyDs2cOZN77rkHgP7+fu6++26++93vMnXqVD7zmc984Of6fD4KCwvHvLZ71GS3gYEBCgsL91hY+6Mf/YhjjjlmzGt2u33090bjruPJ37Y76Z3uuOMOGhsbAXA4HNxxxx373wkhhMiCWCrDmkY/69qCWM1GarxOFEVBiw6TaGwk09uHkuPAlJeHrqpkBvwoFgvW2bOxlJczs9iD1eagsHgKg5FhAikD0wocnDLJird9EBJUxrni4mK++93v8ve//50XX3yRz3zmM3sdVbFYRoYeU6nU6NRPKBQac01ZWRmrVq0a81pHR8eYn6dMmcL69eu57rrrPlS799bG6upqHI6Rcs9Wq/VdrxNCiPGkOxTn+e39NPuHmZpnx2Uzo6OT7u0h2dSENhzFmJ+PYjajxeNoQxGMRUUEHVbKdo0we6aU83/3P0nSWsiQpnN8VT4nVE++4m0fxKRdTDtevfLKK9TX1495raenh46ODmpqagDIzx9ZCR4MBkevqaqqQlEUXnvttdHX/vSnP415zoUXXsjatWtZu3YtMDI/+otf/GLMNR//+MdpaWnhd7/73ZjXX3zxxf2qdbK3Np5//vlcd911XHfddfy///f/3vU6IcThLZVKsWLFClasWEEqlcp2c96Vqumsbw/ytzc6aQtEqfI4R0JKKklyxw7im7egp9KjC2Yzg4No8ThKeTn3/ft+vr38MjqaR/4+j6UyBA15uO1mLp5fxllzJmfxtg9i0o6oJNLvPkWRzc9QVZVLL70Um81GXV0diUSCZ599loULF/KlL30JgIKCAk444YTRxbZHHHEEX/jCF1i+fDkXX3wxy5Yto729fXRkZbdjjz2W5cuXc/rpp7N06VLa29tHR2J2W7hwIXfddRdf/OIXuf/++5k2bRrbt2/H5XLx+OOP73M/3q2NH/Q6IcThKRKJ7DEFPR5EEmlW1/vY2BnCZTNT7XUBkAkGSTY2kBkYwJibh8FmQ0+lUENBjO5cLDU1GL0eYvdFUdUMzW9uwFQ0jWgqw4KKfE6p9ZC/j5srxIhJt+tnvBd8g5GRjo0bN7Jjxw4sFgszZ87kiCOOGHNNMpnk2Wefpbe3l6lTp3LOOecA8PLLL7Nz507q6uqYO3cuf/7zn7n88stHRy4AXn311dE6KvPnz+dPf/rTHtf4/X7WrFlDPB5n7ty5zJs3b/S9YDDIww8/zKc+9anRdSq6rnP33Xdz/vnnj9Zsebc2vtO+Xvd+ZNePEBPDG2+8wZNPPgmMTP8uW7ZszEL9bNvpH2ZlvY+OwRjl+Q5yrCZ0TSXV0UlqZwt6KoWxoAAUA9pQBD2ZQikpwVZTjdk5EmjCAT9dHW2YptRRkGPh5BoPRx6mxds+iP3Z9TPpggqMhJVkRuNQsJoMB30btBghQUWI8S8SifCzn/2Mt3/1KIrCjTfemPVtuWlV443WQV5uDpBSVSoKcjAaFLRYdGTBbE8vit2O0eVCz2RQBwdRHHZCOVZ+95sfctTiJVzyuZsA8A0lCMXSzJ7i5tQ6D16X/J30drI9+X2MFGTLdiuEEGLyCQQCvPPfx7quMzg4mNWgEhgtgx+hIMfC1Hz7yILZ/j6SjU2okQimgnwUswU1OowejWIqKcE8YzqJ1/7JJy+7iJ//6i5Ov/T/MZAaKSh61pxiFlYWYDbKctAPY1IGFSGEENlRWFiIoih7jKi8/ciQQ2lMGfyhJNMKHNjMRvR0iuTOnaTa2sGgYPJ6QddGth2bzFhnzsQybdqYfnzpJ3+mP2GgpjiHU+u8lOU7stKnw43EPCGEEIeM2+1m6dKloz/vXqOSjdGURFrl+R39/GPDrjL4Xic2sxE1FCS2cSOp5mYMDgem/AL0ZALV78eYl89OQ5o7f34L6XSGSHfzWw9se41Z5gAfPbpcQsoBJCMqQgghDqlFixZRV1fH4OAgBQUFWQkp3aE4K3f00+QbpjTXTq7dPLJgtrOLZHMLeiqJscgDBgOZ4CBoOpYZVShlU7jnY6cTCvh5+qF7mFniGvPcxnUvkDpxPjbz4V8G/1CRoCKEEOKQc7vdWQkoGVVjU2eIF5sGGEqkqfI4MRsNaPEYycYm0t3dKHY7piIPeipFZsCP0Z2LtbYGU3ExCgqf+9aPWbfmGeqO+wi0vTbm+eNhvc3hRoKKEEKISSEUS7G6wc/mrhDut9VGSff3k2pqRA1HMBbkg8mMGomgJ5OYp5bx0o51THPbqCsuAaBqwYnYZxxNiUOnv12BcbLe5nAlQUUIIcRhr6l/iJX1PnpCcSoKcrBbjOjpNMnWVlJtbQAYvV5QVVS/H8VuxzZ3Ds+/9Ax/+fn38ZSW8X/3/5dAykhG0zh2RiEn1RRRn7d0j5owMppyYElQEUIIcdhKZTRebRng1Z0BdB1qil0YFAU1HCbZ2EjG14/B5cbgcKDGYmhDQ5iLvVhrazG6cznl/MtZ+c+/ctJ5H6dzSKU0z8optV5mlbpQFGVcrLc53I2LoJJOp7nqqqvo7e3l73//Ox6PJ9tNGiOVSnHbbbcBcPPNN+9Rdv5QfP6TTz7J6aefjsvlev8bhBBCMDBaGyWMx2mjIMeCrmmkujpJNjejJxIYC4tGFswGAihGA4bplWzpauY49yIAbA4nX/jVP0jrBo4qy+XkWg95jrHfAdlabzNZjIug8s1vfpNNmzZRX19PMpnMdnPGnUgkwkUXXcTWrVuZO3fuPt0TjUZ59tlnOfPMM0dPLBZCiMlA13V29A6xusFHfyRBZWEOVrMRLREn2dRMuqsLxWpFKSykZ3A7AJ6cSszTq7n1a5+ha2cjNqeLuoWn0BGM4XFaObnWw9wpuRikBP4hl/U6Kk8//TT//Oc/R0csxIHR29vLRRddhM/ny3ZThBDikNldG+XxjbtqoxS7sJqNZPx+4us3kO5ox5ibi8HlIhrqHb3PH20jQ5y5i04kt9BDOKnTFYpxVFkuHz+mgiPL8iSkZElWR1T6+vr4zGc+w2OPPcbQ0FA2mzLu7Ny5k+bmZmpqavaY7tE0jX/9618AmEwmKisrmT17NgbDSO5Mp9M899xzADzzzDN4vV6Ki4s59thj3/M+IYSYyHrDcZ7f4aOpf4iS3bVRMmmSbW2kWlvRNR2jxwuaRsrfx5AhOOZ+35uvcN5V1zPn3E9RVlrCybUejpyai0lK4GdV1oKKpml88pOf5POf/zzHHnvs6Bfre0kmk2OmhiKRyMFs4l4diiPJf/CDH3DrrbeyaNEienp6OPLII8e8r6oq9913HzASSjZv3szUqVP5z3/+Q1FREalUikcffRSARx55BIfDwYIFC1i4cOF73ieEEBORpuls6Q6zusFHOJZmepETi8mAGomQbGwg3e/D4HJhcjh2ndMTgwI3hAbe8SQdXzDMMbOqObXWg9ctBwmOB1kLKj/84Q+Jx+PcfPPN+3zPbbfdxooVKw5iq/Zu8+bNo7+/6667DuqR5Nu2beM73/kOTz75JGeddRaZTIYLLrhgzDVms5nHH3989Od0Os0555zD//3f/3HnnXeSk5PDb37zG2pqarjnnnuorKwcvfa97hNCiIkmmszwQqOf9W1B7BYj1V4noJPu6iTR3Iwei2MqLASDQiYwgGI0YZ1Zh6G4iIEXd77jaQpLjqri+FlT5SDBcSRrQeV3v/sdDoeD008/HYBgcGQI7tJLL+WKK67ghhtu2OOem2++mS9/+cujP0ciEcrLyw9qOyORCE899dToz7qu88QTT1BdXX1QVnk/9NBDzJs3j7POOgsYmaL52te+NrpP/+2amppoa2sjGo1SWVnJq6++uk+f8UHvE0KI8aRzMMZzO/rZ6Y9Slm/HZTO/Y8GsBaPHg55MooZDmAqLoKIM65QyADyzjsO/Y3dlWYWTTj+LU+ZWZK9DYq+yFlT++te/kkgkRn9ev349X/nKV/jyl7/M/Pnz93qP1WrFarUeqiYCh/5I8vb2dmbMmDHmtaqqqjE/x2Ixzj//fNatW8f8+fNxu910dHQQCoXe89kf9D4hhBhPVE1nU2eQ1Q1+osmRwwRNRgOZAT/JhkbUUBBjXj5YLKihEGga5sppPP3Kczz/f3/lf+97AmdeEQPW0tFnfu6665hS7M1ep8S7ylpQOe6448b8nMlkAFi8eDFlZWXZaNJeHeojyQsKCti+ffuY194ZJO655x7a29vp7u4mJycHgNtvv53f/OY37/nsD3qfEEKMF5FEmtX1PjZ2vlUGX8+kSTa3jF0wq2bI+H0YXW6sNTXoBXms/eHXCPr7ee5fjzB36ZVUedwsueGrVBRKCYfxbFzUURnPdh9JfqhKJB9//PH87ne/IxAIUFhYCMA///nPMdf09PRQVVU1Gjb2ds3u996++Hhf7hNCiPGqbSDK8/X9tAdilOc7yLGa9r5gdmgIPR7HPHUqtpoaDI6Rv/OWr/g569ev46hTz2fR9AJOrCnCYZGvwfFO0d85r5ElwWCQzZs3s3jx4n2e3olEIuTm5hIOh/cIDolEgtbWVqZPn47N9uFWbr+9Mu31119/UHfIaJrGMcccg6Zp3HDDDbS1tXH33Xfj8/lGC76tXr2aM844g29+85vU1NTw8MMPs2bNGgoKCmjbdWaFpmlUVFRw5plnsmzZMkpLS0kmk+9730R2IP/MhRDjR0bVWNce5KWmARJplWmFORgUnUxPD4mmJvRYHOOuUW41OIhitaGWFvPAX3/LkYuXcNLSi4mlMnQOxih221gy08vMkpES+CI73uv7+53GzbLm/Px8Tj311EO+BmV/HewyyQaDgeeff57zzjuPZ599FoAXX3yRCy64YPSzTz31VJ588km6u7t56qmnOPPMM3nwwQc588wzxzznySefxOFw8MADD/Dss8/u031CCDGehGNp/r25l6e39WE2GpjhcaKkksS2bqVt67P0JdpQigrRUinUQABTkQfH0Ufz6qZXeeWZf3H/HbfQ2uunOxRnfkU+HzumglmlbgkpE8i4GVH5ILIxopKNs37EvpERFSEOL82+YVbW99MVjDNt14nHmYEBko0NZIKD+IwjdVAK8WA2WrBMn46lshLFZEZTVe669X+YedrFHLngGE6u9XBUWR5GqS47LuzPiIpMzgkhhBhXUhmNta0BXm4JkFF1arwuDLpKsmXXgllVJeEyQ2zk+gB+LM4yXnryYT5+wzdRgIFYmjOXf59ZpS6W1HmleNsEJkFlH1gsFr73ve9luxlCCHHYG4ymeH5HP9t6IhTmWCjMt6INDxFvbCTT14eS4wSng0ioYcx9iWAHLz3xMPnFU6ld8lFyrCbOmlPM0dMKsJjGzSoH8QFIUBFCCDEuNPQNsbK+n75wgmmFOVhNCumeHpJNTWjRKMaCQtB14oP9e6ywNBgMHHHMiXjmnMAMj5NT6zyU5cu248OBBBUhhBBZlcyovNYS4JWdARQdaopdKOkUyR0tpDo6UEwmjB4PWjSKHothLS5F9wcZu9pEYdn1t3L87AqOmV6AzWzMUm/EgSbjYUIIIbLGN5TgHxu6WVnvw20zU1GYgxYKEtuwkWTrTgxOJwa3CzUwAJqKddYs1rY38Z8nnhh9ho5C4ezFfPykmZxc65GQcpg57EdUJvCmJrGf5M9aiIlD13W290ZYVe/DP5yksigHiwGSbW2kdragp1KYPB70VArV78dY5MFaW4Mpv4AjbWYeuuuHOKbWccZHP83C2TM4de407BYJKIejwzaomM1mYOR8G7vdnuXWiEMhFhvZArD7z14IMT4l0iovNfl5vXUQs9FAjdcF8djIgtmeXhS7HWNhEWooCJqOefoM+klTmT9S1M2SV8w1v/wXc6uncWqdhyqPM8s9EgfTYRtUjEYjeXl5+Hw+ABwOhxT4OUzpuk4sFsPn85GXl4fRKP+qEmK86gsneG5HP439Q5Tm2nHbTWT6+kk2NaJGhjAV5IMOGV8/RncuVJTxy5+vYNsbL3PL7x9HKaxEUWDpopmcUF1EjvWw/RoTuxzWf8IlJSUAo2FFHN7y8vJG/8yFEOOLpum82RNmZb2PcCzNjCInZj1Dsr6BVHs7GAyYvF60oSH0ZBJLWTnWmmoUuwOjYeQfHxs2b+XsC+o4pc5Djdcp//icJA7byrRvp6oq6XT6ELZMHGpms1lGUoQYp2KpDGsa/axrC2IzGynNtaGGQiQbG1EH/Bhyc1FM5pFzemw2KCvDNq0Cs8WGpus0tHUTCvhZevIxnFhThNsm07sTnVSmfQej0ShfYkIIkQXdoTjPb++nyT9MWZ4dp8VAuqOdZMvIglljkQctmUQNBDAXe+kzavzmO5/nmCVLOff/3UjHYIwpJV4+dvIcZssZPZPSpAgqQgghDi1N09nUFeKFBj9DiTTVHifGZJz4lrctmC0oRA0GUYwGbHV1WCqn4Vv9ND1tzaz699+ZdfYnOaZmCqfUesjPkTPWJisJKkIIIQ6ooUSaFxr9bGgP4rSaqfI6yfT1E2tqQo1EMBXko2v6yLbjgnws1TWYPR4AFpx6Dudc8y0Wf2QZSxdVM69cDhKc7CSoCCGEOGA6AjGe29FPeyDK1HwHOQZt7IJZjwctEkHPZLBMr2RzVzNPf/sOvv7z+xnKGAhEk1x59TUsqfNSkisHCQoJKkIIIQ6AjKqxoSPEmiY/8ZRKldcJ4TCxpkZU/64Fs0YT6sAABqcT2+zZZHJd/PlrnyY04OPBe3/LWZ+4jjNnF7OwsgCrSdYVihESVIQQQnwo4XiaVfU+NneGyLWbmVFoJ93VSbK5+a0Fs7EYWmQI05RSbDU1GHKcmIFPfPWHbFr7Mh//zOf5yBFllBfIQYJiLAkqQgghPrCd/mGer/fRORijosCBLZMkvrWeTE8Pis2OMb9gZNuxxYJlVh3/XfUf6vQUNUcuomMwxrQjF3PZBedy7IxCOaNH7JUEFSGEEPstrWq80TrIS80DpFWNGq8Lze8bmeoJhzEVFKCnM6gDfkweD9baWv7zr7/y93t+Sr53Ctf84h/UlXk4tc7L9KKcbHdHjGMSVIQQQuyXYDTFygYfWzvDFDgtTHWaSTY3kmprBwVMHg9qMASKgqWmFuv0ShSzhdMu+iRrnv4XJ174KU6fW84JNR4cFvkaEu9N/gsRQgixzxr7h3i+3kdfKM60whzMsWHimxrI+PwY3G4Ug2Fk23FeHpnSEtbu2MTJtbUMJdJ0R3W+94d/cfqsYqq9rmx3RUwQElSEEEK8r0Ra5fWdAV7ZGQAdqj05qN3dxJqb0ZMJjIWFaNEoWjqFuWIa+tRSvnf1Bfh7u4gb7NQsPIXFMwo5saYIl5TAF/tBgooQQoj35BtK8PwOH/W9EbwuG7kGleT2baS7ulCstpEFs4ODKA4H9plHYJoyBUUxMO+ks1j3wtN4PUVcOH8qc6ZICXyx/ybFoYRCCCH2n67rbOuJsKrBx8BwkumFTgzBgZHDBEMhjPkFaOkUejSGqaSYoN1C3tQKcty59EcSDEai1HlsnHN0FQVSAl+8jRxKKIQQ4kOJp1RebPKztnUQq8lIdYGNdGszibY20HSMhUWooSCKyYx1Zh0bW7Zxz/99jaOOP42lX/ohuXYLFxw9jXnleZiMhmx3R0xgElSEEEKM0ROK89z2fpr9w0zJtZOTjpPc/CaZfh8GlwsMCmoggLGwEGttDaaCQjyJYdLpND6/nzKXgaXzy5maZ892V8RhQIKKEEII4K0Tj9c0+Akn0swocqD09RJrakaPxzEWFqIODYGmYZkxg4y3EFNBIaqmY/RWc82P7+eSs07lxBqPFG8TB4wEFSGEEEQSaVbX+9jUGSLHamKGy0Sqfgfpzi4Uq2Vku3EggNHtxlA5jUce+xMv//cffPsPTzBkcFKWb+fST5xLTbFsOxYHlgQVIYSY5Fr8w6zcVQa/PN+BdShE4s0G1FAQY14+WjKJGg5hLpuKraYG1WRi+/pXiQQDvPjsk1x73ec5saaIXLtsOxYHnuz6EUKISSqZUXl95yCv7gygajplbgtqezuptlZ0VcPodo8smLXasFRVYS6bCrpOy3N/AaDf6GX5//sEs0vdGAyy7VjsO9n1I4QQ4j35hhKs3OFjR18Ej9NGrpYguXUL6d4+DE4nBouCOhjA5C0m4Sngtz//Hsecdg61x58z+owvX3UB1VNzs9gLMRnInjEhhJhENE1na1eYh9/oZEdfhGkFdlwhP7ENG8j09WMqyEdPJNCSCSw1tdjnzeO1V1ay6ZVV/OUXPyDR2zD6rAfv+z0bNmzIYm/EZCAjKkIIMUlEkxnWNPpZ3x7EajZSlWsm09hAvLMTxWzBmJuLOjiIMS9/ZNuxxwvAwnOuoL6xkUs//kmSbW8FE13XeeKJJ6iurpbpd3HQyIiKEEJMAu2BKA+9vpO1j92Duv7veJJhkhs3kmxrw+AaCRnqUARzxTT63Tbu/+PPSaYzNPuGyCgKv/zVr7n4+Nm8c1mjrusMDg5mo0tikpARFSGEOIylVY11bYO83BwgnkiOvj68eSMmXcFUUIAaDI2e05PKdXHbRScSG4pgLqrgY5/6HEtmeikvcBCJWFAUZUxYURSFgoKCbHRNTBIyoiKEEIepwHCSf23q5uk3+7EYDeRHWt96T+sjbkqjBoOYSopxHL0A89QyrA4XZ1x1E3OOP4NrP30lly0qp7zAAYDb7Wbp0qWjz1AUhWXLlsm0jzioJKgIIcRhRtd1tvdEePiNTrZ0RygvsJET6CKwc9OY6yLpAYwzprN1sBd/MEAknqbZN8x5l3+Sx//xGBcsnrVHhdmjjjpq9PfLly9nwYIFh6JLYhKTOipCCHEYiadUXmrys7ZtEJPBQKldId3SQrSrmSDBPa7vHlL53U+/T1ntEXzuR/dzTJWXE2s8OK2yMkAcPFJHRQghJqGuYIyVO3w0+4cpzbWTEw2R3NCIGgpidudB9J1BRWHG0Sdjd+Ux95gTuWhBGXPLClAUKd4mxg8JKkIIMcFlVI2NnSHWNPqJJjPMyLeid7YRb21F13SMeflkQiHc9iIiqYFddylYZiwk7ZrC7//zMuceXUOuQ0rgi/FHgooQQkxgoViKVfV+tnSFcNvNTLdpJLduIdPvQ3G5UFQVNRLGXDYVQ7GHyKZnAOh3VjF7ag0n13qYOyVXSuCLcUuCihBCTFANfUOsavDRE4pTkWfH5O8l1tyMnkhgzM9HDYdRrFZsc+ZgLitDR+GRZ16iceOr3PS/P+djx1RQ5LRmuxtCvCcJKkIIMc6lUiluu+02AG6++WY0xcgrLQFebw2ADtVuI+nG7SS6e1CsVgw5TtTgICaPh8zUUgzeEtKaQnsgyuU3fZ8jS6ycs/goTEbZ+CnGPwkqQggxgbT0+Fjfp9LYP0Sx24pzaNeC2XAEQ14e2vAwuprBUlNL21CAu67/GEcvOY/jLr+e2hIXp82cQWmuPdvdEGKfSZwWQohxbvPmzaO//9uf/kDLjq1Mz7Ng72wlvnkTajyOITcXLRzC6HTimDcfW20toVCQQF83G154ihMqXVyyoExCiphwZERFCCHGsUgkwlNPPTX2xY4NJCMRCIQwuHPRUym04SHMFRWYZ8zA5MhhOJkhf86JfPobt/Olz32SeTNKs9MBIT4kGVERQohxbEtz5x4HAYJOKjSAMS8fbWgIjEZsc4/g1ZatfO/zl7Gzd4D+SIKFlfn87Ls3SUgRE5qMqAghxDgUT6m8ujPAa52Jvb5vsjlRw2FMJcXYamtJKPDo735GaKCfTc88yve++TXmTHHLtmMx4UlQEUKIcaZzMMaq+pEKs8VuN9rUWQx27xh9300uxgxYZs3EUlEBBiPhSILzv/R/MNDKT7//bYpctiz2QIgDR4KKEEKME2lVY13bIK+0BEYqzOZa0Np2kuoJUWQoQbMYUKIJrIXFKJUV/P2h3zP3+NOxTzuCghwLX7rqYo4qy8MooyjiMCJBRQghxgHfUILVDX6290TId1ioNGdIbtmGOjCAITcX4gmMSRXLjBqsVVU89uff8NRDf+Dl5/7Dr/+xhjOPLMfrllEUcfiRoCKEEFmkaTpbusOsafQxGE1RnmfD2NdDvKUFPZXCkJePFg5jcDmx1tRgKikhndGpO+PjVL6ymi98+atcvrgKsxRvE4cpCSpCCJEl4Via1Y0+tnSFsJtNVLmMJOu3k+jpQbHZUaw2tHAY05RSkoUFvPrSsyw4+3IGoknmVHp5+eWXmJLnyHY3hDioJKgIIUQWNPUPsbLBR3cwTnm+A2s4QOLNJjLhEMbcPLThIRSLBduc2aTzc/nmx84gMjiA7sjnc5+8jIWVBVhNxmx3Q4iDToKKEEIcQom0yus7A7y6M4CmQXWBjUz7TmJtbaCDweVGi4QxFhVhranFlJ9PLJZizsnn0fXmq1x55rGcUO3JdjeEOGQkqAghxCHSH0nw3I5+mvqH8DhtuNUEyS07yPj6UXKc6MkkeiKBpaqK3kycfEUnFIiiKPDdW1Zw3IxC8lwy1SMmFwkqQghxkOm6zraeCCvrfQSjKablOzD09xJrbkaPx3eNokQw5rqx1NTy8hurufeH36Jm0an8z+2/4dQ6L9VeV7a7IURWSFARQoiDKJFWebl5gNd2BrAYjcxwG0k17CDZ1YVitaDYrCPn9JSXYa2pQbfaMRdNR9d1CuxGLjyymKJcZ7a7IUTWSFARQoiDZGA4yXPb+6nvi+B12XBGQyQ2NKKGQiOjKNFhFJsd29y5RG1WMoqZHt8Q8+Yv4B/PrGHZqcdiMMi2YzG5SVARQogDTNd1GvqHWLnDR39wGMPWf+IHNMWLCROK04k2PITJ64XyMu695yesX/Ms1//qcU6ZV8dJtUW4bTOy3Q0hxoVxEVR0XUdRpOSzEGLi2z3V83rrIAagaKiVwV3vBXQfbnJxpBSstbVYKisZTmZo3rGN+HCEvGA9S+eeIgcJCvE2WRtTVFWVP/7xj8yfPx+bzUZRURGf+tSn8Pl82WqSEGKcSKVSrFixghUrVpBKpbLdnH3WG47zyPpO1jT6ybUZKQp1M9i2Zcw1EcIYZ9ZgqaqmP6bSF83wzR//ln899Szf/NJ1ElKEeIesBZX6+no2btzIX/7yF2KxGK+++irbtm3jyiuvzFaThBDjUCQSyXYT3peq6WzoCPLw2k5afMNUOg3YmhuINWzf6/X3/eY2/vbAn1CAZUeWct0FJ7LsrNMPbaOFmCAUXdf1bDditzvuuIPvf//7BIPBfbo+EomQm5tLOBzG7XYf5NYJIQ6VN954gyeffBIARVFYtmwZCxYsyHKr9i4cT/NCg49NnSFyrCYK42HSzU1kwmHIceCLt8PbBkl0XefOO+/EaLHzxtYdVJXkZ6/xQmTJ/nx/Z305eTqdJhaLsWnTJv785z9zxRVXZLtJQogsikQiPPXUU6M/67rOE088MS5HVlr8w/xtXSfr2oOU5JjI7+8ksWULaiyOwZGDEkuQ65rytjsUjJULOeviT/DqKy9LSBFiH2R9Me0FF1zAs88+SyaT4ayzzuL2229/12uTySTJZHL05/H4F5cQ4sMJBAK8c6BX13UGBwfHzchpKqONlsFPqxozbBqZ7W+S8vlQnDno8TjoRqyzZtEd6MY0PHJf4bHn8ZF51Xz7U+fKBgIh9lHWR1SefPJJUqkU27dvJxQKce655+7xl9Rut912G7m5uaO/ysvLD3FrhRAHW2Fh4R5f4oqiUFBQkKUWjeUbSvDYhi6eq+/HZjJQFg+S3LiRjN+PkpODPjyMMb8A+/wFpArz+fFXr+GWW27Bl7byyVPmUlfikpAixH4YV2tU1qxZwymnnEJ9fT11dXV7vL+3EZXy8nJZoyLEYWY8rlHRNJ03e8KsbvATiCapyDFC607SXV0oFgu6qgJgmVaBdcYMYpqBzmCMnS/9i2jndu67+y5yc+XvKSFg/9aoZH3q5+3i8TgARuPejy63Wq1YrdZD2SQhRBYsWrSIuro6BgcHKSgoyPo/RIaTGdY0+tnQHsRqNjLdkCC9uQk1HEJx5KBHhzHm5mGurubF11dSkFJxl0zj6Gn5fPkjXyHPYclq+4WYyLIWVH72s5+h6zrnnnsuRUVFbNq0iRtvvJFTTz2V6urqbDVLCDFOuN3urAeUVCrFbbfdBoA680ymegqx9HaRbGtFVzUUixU9HsdcUYG1uoZH/3IPj//hDspr5/KPp55nfqVH6qII8SFlbY3K1VdfTTAY5KKLLqKmpoabbrqJj33sY/zrX//KVpOEEGJUKqPxj+deHv3ZWP8MiY1rSDQ2gMEIqgpGI/a5c7HNmYsvrTDjhHPJK/Tw2U9dyfzKIgkpQhwA42qNyv6SOipCiINhYDjJMxtbaVz5MGOihg4ey1SURBpzsRelspKG5nqcM+bhspk5ubaImgILbpecdizEe5mwa1SEECKbNE1ne2+ENY1++rt79hxyViCjJnHVzSJdkMetN1xBb3szK37/Dz520emU5tqz0WwhDmsSVIQQAhhKpHmxaYANHUEsRgPlTivde7nOOXceppIyugNR8ksriIb8HF1qkZAixEEiQUUIMent9A+zqsFHeyDGFJcVq6+HVEsLLlwMMTR6nbNsNgl3IW2+IcrzHfzxD/dQnmejuLg4i60X4vAmQUUIMWklMyqvtQR4rXWQjKoxI0ch07iNZG8fisWCXbMzZBgJKsOOEn785WuZ/5GL+fp3b+XkWg9umznLPRDi8CdBRQgxKfmHkjy/o58dvUMUuSy4h8IktzehDQ+PFHBLpTCXlFBVezIpq4On//MvopEgAw1vcHpNAXYJKUIcEhJUhBCTiq6PLJhdXe/HP5xgmtsC7TuJd7SDYoBdW4qtM+swTJ2CP6kQHozx0Usu5szZHq687BIpPCnEISRBRQgxaSTSKi81+Xm9dRCz0UClOUN66w7UAT+KzY6WSGAqyMdcU8NTTz7Cqice4cu//BvnHjmNeeV5mBd+IttdEGLSkaAihJgUekJxVtb309g/TInTgt3fS7J1J3oqBWYLejqNdXollqpquoIR/vvwH4kE+qF5DYvO/1K2my/EpCVBRQhxWFM1nc1dIdY0+Akn0kx3KKhN20cXzKLpGOwWrDW16F4vrYNx7DYn//vz32KO+rn2c5/NdheEmNQkqAghDlvheJoXGnxs6gyRYzUxLRMhtallzIJZU0kJetkUfnvXj6hefDYfOeMMTq3zUlG45wnuQohDT4KKEOKwtNM/zPP1PjoHY5Q5TZg6Wkl0dICivLVgdtZMDGXl/PFXP+K1/z7Kzs2v8cubPkGey5Hl1gshdpOgIoQ4rKRVjXVtg7zYNEBa1ZhuSpF5czvJwAAGqw0tmcBUWIS1tpaYw0VPIM5lV38Btb+F/1vxXQkpQowzElSEEIeNUCzFynofW7rC5NuMeIL9pHa2omfSKCYzuprBOmMGQZuZlY8+yOILP83xVYWcWONh+Ueey3bzhRB7IUFFCHFYaOofYmW9j+5QnDKLhqGlkWRf/8haFFXD6M7BWlND0GjiW5cvIRkb4iPHzuWscz+Joijv/wFCiKyQoCKEmNAS6d1l8AOomkZlJky6voVMLAZm80iF2alTsNXWMqAaCcXSnHPZJ+mp38iFHzlZQooQ45wEFSHEhNUXTvB8fT9N/UMUmsHR106qqwuMRlBAMRqw1s6mwdeN1hPA6/FwzhGlfP3MOzCbjJhM8legEOOd/L9UCDHhjNZGafQTjqUp0+PoO5pJh4IoVht6MoHR48FWW8sTTz7G3375fY4+6Uwee+xRKgpzst18IcR+kKAihJhQwrE0qxt9bO4MkWOEslAPmY52dFUDkxld07DU1GCurKR7KIOn+khMRhNzq6ZS4pKDBIWYaCSoCCEmBF3XaewfZnXDyILZKcY0pp07Sfv6UWx2SKUw5uZhrq6mL5EgPpikJNfGBR/9CF86exs1NTXZ7oIQ4gOQoCKEGPfiKZWXm/280RZE1zWmJYNkWlrIJBNgsY4smK2oQC0p4ac/+AbNW97gF397jo8uqiU/xwK4s90FIcQHJEFFCDGudQVjrNzho8U/jMesY+tuJd3dA2Yz6KCYTNhmzkQvKaXDHyE86COTipMTbuYXP3kSgJtvvhmLxZLlngghPgjD/t7w5JNP8uc//5lYLHYw2iOEEABkVI032gZ5+I1OWgNRyrUolu1bSHd1v3VOj9eD5cgjiRYW0xqIUVWcxwMPPMAba9fy0UsuGX1WJBLJYk+EEB/GfgeVVCrFF7/4RUpLS7n22mt5/fXXD0a7hBCTWCiW4oktvTy5pRdDJk15oIvM1i1osRiK0QDo2Orq8LvsfPP6j/HMYw9wUk0Rly4s56Sjj2DevHls3rx59Hl33XUXGzZsyF6HhBAf2H4HlQsvvJDe3l5+/etf09TUxOLFi5kzZw4//elP8fl8B6ONQohJpKFviIfe6GRjR5ASkjibtpPc2YJiMkEmgzE3F/u8+agVlax+YTV9bY2s++cfOakqH7vFCIyMoDz11FOjz9R1nSeeeEJGVoSYgPY7qADY7XauvPJKVq5cSUtLCx/96Ef55S9/SVlZGRdffDFPP/30gW6nEOIwl0irrKz38diGLgaH4lTE/LB1E2ooiGK2oKfTWKZXYps/nwGLk+5QnGuXf4Gv3fwt1r/xOlardfRZgUAAXdfHPF/XdQYHBw91t4QQH9IHCipvpyjKaAlqm81GNBrlggsu4IQTTpC/FIQQ+6QnFOeR9V2sbvDh0lJ4O5tJ1zeMvKnpGKxW7EceyWZfFz/85hfRVZVlR5Zywfwybv/B/1JcXDzmeYWFhXuUxlcUhYKCgkPVJSHEAfKBgko8HueBBx7g9NNPZ8aMGTz99NN85zvfobe3l6effprOzk4MBgP33nvvgW6vEOIwomo669tHFsy2+IYoT0Uwb99Mpq/vrQWzJSU4jj6aPgz89pYb2f7KM2gNz3P0tAKMhr2f0+N2u1m6dOnoz4qisGzZMtxu2aYsxESz39uTH3/8cT796U9jMpm48sor+cUvfsGcOXPGXOPxeDj//PPp7+8/YA0VQhxewvE0qxt8bOoMkaNoTPV1kOnedU7PrgBinTUTY1k57eEUJpuLm757Gwl/G1+87nPv+/xFixZRV1fH4OAgBQUFElKEmKAU/Z0Tue/jqaeeIhQKcfHFF4+ZE34nVVXRdf2gHvoViUTIzc0lHA7LX0JCTCDNvmFWNfjoHIwxRY9j3Nk8shbFbkeLxzEVFmGumsG///MI3jnHs+CouSyp81LtdWa76UKIA2B/vr/3O0W8fTj1vRiNxv19tBDiMJfKaLy2M8CrOwNkUhmmDfWRaWtD1TSwWNDTGazTZ2CpmsEf7/opKx++hxl1c/jfN9ZS6HJku/lCiCyQyrRCiEOiP5JgVb2PHX0RCkiT07mTtM+HYrNBOoPBbsdaU4Pq8dIUiHHqRVey4+WnuPkrN1HgtGe7+UKILJGgIoQ4qFRNZ3NXiDWNfkLDSaYmw+itLWTicRSrDT2RxFRagl42lVc2b6TkiOOZVeLmtJnVfP2iZil9L8QkJ0FFCHHQhGIpVjf42dwVIgeVMn8nme4uFLN5ZMGsAtZZs4g6c/ju5y4m7O/lNw/9h4sXzMZi+tDVE4QQhwEJKkKIA07XdXb0DvFCo4++cIJSLYaxtZlMKIRid6An4hgLi7DW1hK3O+kPxqiafQS9TQpHlrklpAghRklQEUIcUJFEmpeaBtjQHsSERnmkF7W9HVXTYXeF2RlVhG1mBtIG1EySxVVFXPPAfbjtFnJzc7PdBSHEOCJBRQhxQOi6TmP/MGsa/XQFYxQbM1jaW8j0+1DsNvR0AqPLjbW2htc2vc69P7yZE5Zdzs/u+Clzp+RieJfibUKIyU2CihDiQ4smM7zSPMC69iBaOoVh0+P4Aa/uxWC1oieTmKdOxVZTQ0g3M5iEVDxKvLuBWcU5ElKEEO9KgooQ4kNpG4iyqsFH60CUEouOubeVnl3vqagYDAZsc+aQKSykIw5GQ4brP/UxPnFcJcvOOUdqLgkh3pMEFSHEB5LMqKzdOcirOwOkMhrT9CjqtmYiQ32jp4gFlAAFpVN4/J8PsnbVf7nl3n+xdP70kQqztedltwNCiAlBgooQYr/1hROsrO+nvm+IIqtC0UAXqY4OVDSGDcNjrh1sf5MtLz3LYE8bpo61VJ91RJZaLYSYiCSoCCH2WUbV2NwV4sXGAcLxNBXGFHpDM6nAAIrdgRoPwx4zOTrfvOV/8eaYuPTSj2aj2UKICUyCihBinwSjKV5oHCne5jIrlA/3k25tQ8+kRyrMJhNYS8vAFxpzn6IofPLic+TgUCHEByJVlYQQ70nXdbb1hPnr2g42dgSZYlZxtzaQamgEgwF0wGDANmcujqPmU98dHL1XURSWLVsmIUUI8YHJiIoQ4l0N7Sretr49iMkAlZkIqYZm9GgMxW5Hj0UxeTxY6+pI2V3s9Ec57pLP8uxvvseNN3yeY445RkKKEOJDkaAihNirpv4hVjf66RyMUeowYO1sI9nZiWIyg8k0UmG2pgaflmL1A79n8SXXMr88nyUzPXzprEez3XwhxGFCgooQYox4SuWVlgHWtg2iaTDdkCCztYlUKISSk4MWHcaYm4u1ppawEb57ySmkk3GWHLuA8869CpNRZpSFEAeOBBUhxKjOwRgr6320+Icpdphw+LpJtbaiazqKzYYej2EpK8daW8MQZgLhOGd/7DNEe5r59CVLJaQIIQ44CSpCCFIZjfXtg7zcEiCWzFBp0dAat5H0+VDsDkgkQFGwzZnL1vYG7H2FONz5nFRTxFd/cwc5NjOKImXwhRAHngQVISY531CC1Q1+tvdEyLMZqUgESbY0oycSKI4c9Ojw6ILZfz72Fx69+8cccfzpPPT3R5lV6paAIoQ4qCSoCDFJqZrOlq4QLzb5CURTlNsV9JZ62vs3A1CoeDGlUliqa7DOmE4goVM081gsViunLDqSWm+OhBQhxEEnQUWISSgwnGRN4wBbukPkWI1M16OkNjcz9PZzevBRMGUOgyYdLZTCZjbyqfNO4eZLmplWXpbdDgghJg0JKkJMIpqm82ZPmDWNfvxDScqcZoydbSQ6OlCVPc/pGeh4k7t+ew9fvetvfPS4+VQW5WSp5UKIyUqCihCTRCg2UgJ/S2cYm9nIdEua9LbtpAYGUJwu1FgQ3jGTYzAoFOS5mW4ISEgRQmSFBBUhDnOaprOjL8ILDX76IgnK3FbM/T0kd7agp9MoThf68BCWwiIIBd9xt8JDDz3E/PnzstF0IYSQs36EOJyF42meerOPf2zsZiiRodqpYGjYRnLHDjAYwWhETyawVFfTZzWz6sWXR+9VFIXzzlsmIUUIkVUSVIQ4DOm6TkPfEA+90cHrrQE8ORZKEiESGzaQ6e3D4HSixaIYbHbsR83DXFvL+o0beGXN6tFnLF++nAULFmSvE0IIgUz9CHHYiSYzvNw8wLr2IApQlWtBbW0m3tGBYjKh2Gxow8NYysqxVFeRttjZ2T/MWZf9P+q8Dr70pS+Ql5eX7W4IIQQgQUWIw0qLf5jVDT7aAzFKc+3kxMIkNzeRCQxicLnQo1EUqxXrnDm8/uZaXrr3Di7++s84oryAJTO9FJ3+nWx3QQghxpCgIsRhIJ5SeW1ngLWtATKaTlWhHa2jg3hrK3omg8HpRB+KjFaYDadT3PeT75GMRzm/4QUuOO8GLCaZCRZCjD8SVISY4DoHY6zadZCg123DnUmQ3LqFTF8fiiMHdG10wax1xgzimgFfPMYV/3Mr+VqY73/1eoxymKAQYpySoCLEBJXKaKxrG+SVlgCxVIZpeWY6Vz/AAFCoFWJx5aNGIhjdbozTp/P4vx9gVvIcHCWVHD0tn/858wvk2s3Z7oYQQrynrAeVlpYWdu7cSXl5OTNnzsx2c4SYEHrDcVY3+Gnoi1CQY6XEamJg4yuj7wcMAdxDadxl1Vhrqrn/tz/hmb/dy7oXn+cfz6xh4XQPRoOc0yOEGP+yFlTWr1/PDTfcgN/vZ/r06WzevJm6ujr+8Y9/UFRUlK1mCTGupVWNTZ0hXmoaIBJPU1HowBgIMNywnXC0Y0xl2YghQkHNdIYNFuYs/SRbX3+BFd/7HsdWebPXASGE2E+Krut6Nj74ueeew+VyceyxxwIQiURYvHgxCxYs4P7779+nZ0QiEXJzcwmHw7jd7oPZXCGyzjeU4IUGP9t6IuTazXhsCqnWVlLtHaT0JEF9YI97rLOWkMkpYuG0fE6oKsBlt2ah5UIIMdb+fH9nbUTljDPOGPOz2+3m3HPP5YknnshSi4QYnzRNZ3NXiDVNfoLRFBUFOZiGI8Q3NaLuOqfHGFf3cp/GQF83n7r4KOZOdaMoMtUjhJh4xs1Sf13XWbNmDbNmzXrXa5LJJJFIZMwvIQ5n4XiaJ7b08O/NPWRUneoiB4beLuIbN6AGAhjcuWhDEcw5TgrKZo/ep+k6L726lnMXVnNEWa6EFCHEhJX1xbS7/fCHP2TTpk3cfffd73rNbbfdxooVKw5hq4TInqb+IVY1+OgKxinPd2DXUiTf3Ea6uxvFbkex2dEiEcxlZQTMCoXTZkDXdgCOXHIBN375K+S7nVnuhRBCfDhZW6Pydr///e9Zvnw5Dz30EBdffPG7XpdMJkkmk6M/RyIRysvLZY2KOKwk0iqvtAR4vTWArkF5gQPN7yPZ1IgaDmPMzUMbHkKxWLBWV/Pyxpe576ff4+izLuPT/3MLp8/0UlPsynY3hBDiXU2INSq73XvvvVx//fU88MAD7xlSAKxWK1arLAYUh6/ecJznd/ho7B+ixG0j16yQbG4k1dYOgNGdixYOYSzyYK2txZSfDw3byaRSqOE+Pjq/lCK3I8u9EEKIAyerIyr33Xcf1157Lffffz+XXXbZft8vu37E4ULVdDZ1hljT6CeSSDOtIAdjdIhkYyMZnw+Dy4WWTIKmYamoQC32Ys3Lpz0Qw24xkjPYyGc/eg5mkzHbXRFCiPc1IUZU/vnPf3L11VdzxRVXYLFYePzxxwEwm82ce+652WqWEIdcOJZmVYOPzV0hXDYzVYUOMt1dxFqa0RMJDLm5aJEIBqcTKsr4y0P3sHXtS3zmJ39jZkUxp88spqKwLtvdEEKIgyJrQSUSiXDeeecRiUS47777Rl/PycmRoCImBV3Xaegf4oUGPz3hkQWzNjVNcvs20l3dKFbr6IJZ05RSbDW1xLUMm155gaCvB0P3Zi69+Gqc1qzP4AohxEEzLhbTflAy9SMmqlgqw8tNA7zRHsQATM13oA/4SDY1oYbDGNxutOFhFIsFy/QZWKZVkNYU2gJRwu1vMttj4+rLzscgZfCFEBPQhJj6EWKyag9EWVnvo3UgSmmuHbcZks1NpNrbQNMxOF1o4TBGj4fhPDc///E3WHLp5yiadQwzS92cduoFFLtt2e6GEEIcEhJUhDhEkhmVdW2DvNoySCKtUu1xogxHiL/ZRMbnQ3G50JMJtEQcS3U11hkzePy3P2HHhtfw9fXwt2df4/gaLzazLJgVQkweElSEOAT6IwlW1vuo74tQlGOl1G0h3dVJsrkFPTmyYFYNhzG63VhrazAVFxNNqhx1/mcJDvj4/orvcdrs0mx3QwghDjlZoyLEQbR72/GLTX5CsTTTCh2YUwkSTU1kuntQ7HZQFLRYFJ/BB8Cb7X6OufwLJNIq8yvyOLnWg9tmznJPhBDiwNmf7+9xc9aPEIebYDTFvzf38MSWHlRNp9qbg2HAR2z9etLd3Rhyc9GTCdBU0iW5o/fNLi+k85V/c8G8KZwzt1RCihBiUpOpHzFhpVIpbrvtNgCuv/56ioqKstyiEbqus703wgsNfvojCcoLHNhRSdY3kOpoB4MRo9uNGgpiKizCWFlO36ZnRu83GAwUKTEq3QbZ1SOEmPRkREVMWJs3bx79/V133cWGDRuy2JoRQ4k0T73Zxz82djOUyFBT7MIyHCG2YSPJnS0YcnJQFAUtGsUyfTobBjqIxPc8BVzXdQYHB7PQAyGEGF9kREVMSJFIhKeeemr0Z13XeeKJJ6iurs7KeiVd12n2DbO60U/XYIwpeXacZoVUWxuplhb0TBpTXv5IjRSnE1vtHB77x/3860+/5sgTP8LFZ5ww5nmKolBQUHDI+yGEEOONjKiICSkQCPDOdeDZGoUYTmZ4dns/j6zvwhdJUu11kZNJEt+8heSOHWAyoVhtqOEwpimlOI4+GnNJKUecfA4Wm4O6ufM4/tTTR5+nKArLli2TBeJCCIGMqIgJqrCwEEVRxoSVQz0KsXsU5YVGPx2DsZHibTYjmd5ekk1NaNEoxtxc1KEIisWCsbaGvlSMSoeDzsEYjuLp/HXlOs5ZWItBV3ll9fMALF++fNystxFCiGyT7cliwnrjjTd48skngbdGIRYsWHBIPns4meGV5gHWtwfRdSgvcKCkk6RaWkh1dKKYTChWK1okjLHIQ8JTyB0rvkR/Vxufu+MR6mqqOLXOy6xSF4oiC2aFEJOLlNAXk8JRRx01GlQO5SjEyCiKj/bAyChKrt1MZmCARFMj6mBw5LTjeAw9FsNSNVJh1mYwoJgsYDCSq4W4bFE5RU7rIWmvEEJMZDKiIsQ+iqUyvNoSYG3bILoOZfl2jJo6smC2rQ1d1TA4naihEEa3m3Spl9yqGnRdoWMwxnCgl0XTPSxbPAeLSZaHCSEmLxlREeIAax2Isrph5CDBEreNPIcFNRIm3tg4ck6P04WiqmjhMOayqTSG+rnni1dwzieXU3PaRynLc3D5omOo9jqz3RUhhJhQJKgI8R4SaZW1rYO8tjNAKqNR7XFiVHRSHR0kW5rREwmMefmo4RCK1Ypt7hzMZWX4Ht1EeNDP6v/8nUuu/AxnzCkl1y4VZoUQYn9JUBHiXfSE4qxq8NHYN4THZaMs34IWixJvaiLT04Nis2NwuVCDgxiLPFhqajAXFJBWNaaffDGXpDRuuv5zHFczBaNUmBVCiA9EgooQ75BRNTZ2hnipaYBIPM30Iidmk0K6r5dkUzPqUGSkeFs0ip5KYaqczgsbX2Lj/T/juh/ei384TbXXyWdv/TpT8+zZ7o4QQkxoElSEeJvBaIrVDT62doVx283UFLvQkkmSjS2kOjvAYMSUn48aDGFwOrHW1jBkVHj0j78kHh1izVP/5JrPXMUJ1R7sFmO2uyOEEBOeBBUhGCnetqN3iNUNPvojCSoKcrBbjGQCAySbmsgEAhhz89AzGdRgCNOUUmw1tRhycrDGE3z9q/8DwEWf/gxHVBRKbRQhhDhAJKiISS+azPBy8wBvtA1iMhioKXahaCrJ5uZd244zmAqLUENBFLMZplfy8L8f4HTnJ7F4KxmKxkefNSUHCSlCCHEASTEHMal1BGL8bV0nLzUPUJhjpbzAgT40RHzTJhKNDWA2Y8hxkgkMYMzLx75gAY8+8SDPPfYXfvbtL6CrKnNtwdHnjZdTnIUQ4nAhQUVMSmlV49WWAf62rpOuYJxqjxOX1Uiqs4PY+vVk+n2YCgrRUym0aBTrjBk4FszHlF/AGZ+4ntIZs/h///M9zptTyLa1a0afu/sU50gkksXeCSHE4UOmfsSkMzCcZFW9j23dEQpyLEzJs6PFYySamkh396BYrRjz88gMBjC63AznOdnUup0TZ86iOxgjY3Vx3z+f56RaL33dHe96irNUSxZCiA9PgoqYNDRNZ3tvhNUNPvxDSaYV5mA1G0j395FsbEKNhDHlF6Alk6jBEOapU4nlufjOZy8kHh0m6fCwYOGxnHtkKbNL3SiKMi5OcRZCiMOZBBUxKQwnM6xp9LOhI4jFuGvBbDpFcsdOUh0dYFDeWjBrsYxWmHUYjMw5dgk9Ha0cVT2Njx0zDY/rrcME3W43S5cu3eMUZxlNEUKIA0MOJRSHvZ3+YVY1jJx2PDXPjstmJjMYGBlFCQxgyM0FHbRIGKPHQ7eWonLeIowWK52DMTKpGCfUlHDizBKspr3XRolEIgwODlJQUCD/LQohxPuQQwmFAJIZldd3jpzTk1Y1qr1OjLpGcmcLqZ2t6Jk0xiIPaiQMuo6luppV617ggV//kNMuuorjP/k/TM2zc9rMMmqKXe/5WW63WwKKEEIcBBJUxGGpNxxnZb2Pxr5hPC4rBTkWtOGhkdOO+/pRchwYcxxkBgYwut1Ya2swFRczZbAPXdPwBwIcOdXNGbNLyHNYst0dIYSYtCSoiMNKRtXY1BnixdFzenIwGyHd3U2iuQk9GsNYUIAWj49UmJ06hZSnEGdxCRlNw1W9kC/98lE+ds4pLJyWj8koO/iFECKbJKiIw0ZgOMkLjf7Rc3qqvU70ZJJEfTPprk4UswVjYSFqcBDFYkGrLOfPD/6Ws05cyMBW0I64gAqvm09+/CymFeZkuztCCCGQoCIOA5qms60nwguNI9uOR8/pGfCTbGhEDYUw5OWBrqEO+DEWebDW1pKymGhr3AYnLgRgbrGFs48ux2UzZ7dDQgghRklQERNaOJZmTZOPTZ1hbCbjyLZjNUOyuZVUWyu6qmH0FKGGI6BpmCqnY6+pQbFY0FWNy677KqR8AOx4/hGq7MtYsGBBlnslhBBiN5mAFxOSruvU90V46I0O3mgLUuy2MTXf/tY5PQ0NYLFidLtRBwIYrFaChW5+8OOvs3ndS0TiaVq6feTvCim7nynl74UQYnyRoCImnOFkhme29fHY+m4GoylqvC5yzAbSnZ0j5/T4/JgKC0HTUINBTKUlOI4+mpdeeZ7W+q386c7/xReJc0TRnjVRdpe/F0IIMT7I1I+YUFr8w6zeVbxtSq4dt92MFo+TaG4m3dWFYh27YNYycyaWigoMJhMXfObL+IIRLvz0DVxwdDnlTtjxopS/F0KI8UxGVMSEkEirrKr38ci6TvrCCaq9Ttx2MxlfP/H160l3tGPMzUWxWEYWzObl06TG+Nvjf8ZgMhEYTtITzfDVW3/MNUsXMXdqLrm5uSxdunT0M6T8vRBCjD8yoiLGvY5AjNUNPpr9wxS7bOTnWNDTaRLNTaTa2gEwejy7FsyqWGZUMeS08bOPXYGqZiionse8k87kjFnFHDO9EIvprXy+aNEi6urqpPy9EEKMUxJUxLiVzKi80TrIazsHiacyVHmcmI0G1HCIZEMDGf8ABpcLxWweWTDrdI5UmC0pwYbCuZ+6gb5+HyctOYOz55UzvWjvtVGk/L0QQoxfElTEuNQdirO6wUdD3xAep5UpeS50TSXV0UGyuRk9mcRYVISWiKMFgxi8Xl5u2MCxc2aSq0NPOM7RF36Wo6cVcHJtkdRGEUKICUqCihhXUhmNDR1BXmkZYCiRYUaRE4vJgBaLkmxqJt3djWK3YywsQB0MophMWGfW8dA//sQzf/8TG9e+xEU3/4r8HAvnz5vKkVNzMRiUbHdLCCHEByRBRYwb/ZEEq+p91PcNkecwU+N1oaOT7u8j2diEGgljKihA13RU/wDGgnystbWYCos4/aIreenpf1I+7yRqi12cMbuYYrct210SQgjxIUlQEVmXUTU2d4V4sXGAUDzNtAIHVrMRPZUi2dJCqqMDDAomjxdtaAg9nUIvLaZTTzGzsAhN11Fzp/LVPz7LkjkVHDujEJt5zxopQgghJh4JKiKrBoaTvNDg483uCC67mRqvE0VRyAQHSTY2og4MYMjNRTGZUQcGUBwO4p4SfvS/NxEa8PO9e/9D3FZAaZ6d044uo7bYle0uCSGEOIAkqIisUDWdrd1hXmzyM/C2gwR1NUOyo5PUzhb0dBqjx4OWSKIGAphLirHW1JKTk0NufhHxWIzmjm7OOX0GS+q85OdYst0tIYQQB5gEFXHIBaMpXmj0s6UrhMNioqbYhUFR0IaHSDQ2kenrQ3E4MLrcqMEgikEh4S3CeeSRGM0WVE3ngptuJyfHwUfmV7GosgCTUWoXCiHE4UiCijhkNE1ne2+ENY1++iIJKvIdOKwmdF0j3d1DorkJPRrDWFAAqorq92HMy2ezv4M/3v4/XPK5mzjlok/RPhilesY0zphV/K61UYQQQhweJKiIQyIcT/Nik59NHSEsJgO1u0dREnGSzS2kuzpRzJaRqZ6hCHoyhbliGtaaaqJPtBAbjvDq808x/eRLmFeRz+kzi8l1SG0UIYQ43ElQEQeVrus09A/xQqOf7mCcsnwHTuvIf3YZv29k23EoiDEvH4xG1AE/is2OZdZMrBXTUAwGllx0JcO6mQWnnsMpM0s5ZrpM9QghxGQhQUUcNMPJDC81+dnQHkJRoMbrwmhQ0NMpkq1tpNrbQNMxerzoiQRaKAiFhfx33Sp2PPRrvvXrh0hldNoHo5x5/qUsmeml2uvMdreEEEIcQhJUxEHR7BvihQY/bYEYU/PsuO0j0zSZYJBkUyPq7nN67HbUYBAAS00twzk2nvn2X4kNR1j1zJNMW7iEBRX5LKnzylSPEEJMQhJUxAEVS2V4tSXA2rZBdB1qip2YDAZ0VSXVuWvbcSqFsagINJWMrx9jbi7WmlrMxcXYgKtvvp2+0DCzj/8IJ9YUsXBavkz1CCHEJCVBRRwwrQNRVjf4aB2IUuK2kecYqWuiDQ+TaGok09uHYrdjKvKQjoTxpTrACC+uWskZxZ+joriY4WSG/DknclShg9NnFlMpu3qEEGJSk6AiPrREWuX1nQFebx0kldGo9jgxGQ3oukamp5dkcxNaNIYxPx8MBjIDfuLG5Oj9Jxw9h+cf+CVnfunHJDIai6YXcEqtR048FkIIIUFFfDidgzFW1fto8Q/jcdkoy981ivL2bccmM0aPBz2ZQBsMQ0EeQ+G+0WcYDAZOOG4RxkySZUdO46iyPDnxWAghBCBBRXxAyYzKurZBXm0ZJJbKMMPjxLxrHcnbtx0b8vJRLBbUUAg0jYDdQndfC8X2sc9TgFMq7cyvyD/kfRFCCDF+SVAR+607FGd1g4+GviGKnFam5I0cBLi3bccjFWb9GJxOIrk53PrFT2CzWbnpppt4+5iJoijUVJRmpT9CCCHGLwkqYp+lMhqvt/Sz8qF7AKhc8glsVivw9m3HfgwuNwaHA3V4GD0Ww1Ragq22DmdODseevoxBfx/x/GocwWZgJKQsW7YMt9udtb4JIYQYnySoiH3SF06wusFHfXdwdCTEkI6jm0zv2HbsAQUyA34Us5kWNcas2loMOSO7dy684XuEkxqzSpw0PD0SVJYvX05RUVGWeiaEEGI8k6Ai3lNG1djUGeLFpgHC8TQFyR6Cu95rf+kf5LnLsIbSo9uOtUQCNRzCVFjEk2+s4vEHfstHGjZz5U0r6AzGMBtNfGROIcdML8Ry3Pey2jchhBDjnwQV8a58QwleaPCzvTeCy2ZmuluhbePaMdeEwl0U51ZhsNhRQyH0TAbr9BlYqqqoU1IoD96Nqis0+4aYVpjDkpleZnikDL4QQoh9I0FF7CGjamzpDvNik5/BaIppBTnYzEZigd49L1Ygo6XAPwx2OzFvIa5ZM1EUA0cccxJfuec/uEoqmF+RL7VRhBBC7LesB5XXXnuNhx9+GK/Xy80335zt5kx6A8NJ1jT62dodxmk1Uet1oSgjq1IMidRe71GG4sRznNz7t3vo7Wrjtr/8F7PdRVsgypTKKk6p9UhtFCGEEB9I1oJKJpNh0aJFmM1mjEYj6XRagkoWaZrO1l2jKP6hJBUFOdgtRmDstmMXboaIjN7nNuTjqJuDtbAA/y+7GQoNsnnjBgprFzKz1MVpM70Uu23Z6pYQQogJLmtBRVEU/vjHPzJv3jxuvPFGXnrppWw1ZdILxVK80OhnS1cIm9lETbELw65RlHduO3ba8xgKbAOgwD6N3COOwlRQCMD13/81g0komVbFcdMLOHZGITazMWv9EkIIMfFl7Uhao9HIvHnzsvXxAtB1ne09Ef66toMN7UFK3Ham5tkxKAq6qpJsayO+cQNqIICxyINit6OHIxQrU1DVfH7wq1vZsm0jANFkhnT+NGbPnsUlC8o4pc4rIUUIIcSHlvU1KvsjmUySTL51mF0kEnmPq8V7GU5meKnJz7r2ICaDYcwoyh6nHXu86Ok0aiCAwZmDrXo26x/9I32drTzyuzsoOeJ44mmVRZX5nFzrJdcuC2aFEEIcGBMqqNx2222sWLEi282Y8Fr8w6xu8NE2EGNqvh33rp04b5123IwWjWLMz0cxm1Gjw+jR3RVmazHkOLns2q+g6wpHnHMVJqOBZbOKZcGsEEKIAy5rUz8fxM0330w4HB791dnZme0mTSjxlMrKeh+PrOukL5ygptg5GlK0RILk9u3Et25BT6cxejxgNJAJDEA6w6ZgDw/+92EUx0iF2eG0wjGX38CR1VP52KKR7ccSUoQQQhxoE2pExWq1Yt11tozYP+2BKKsb/LT4hyl228h3WEbfywz4STY0ooZCGPLyMFitaMkkaiiEqbCAkMvO7753DZqqcuTi0/AecSJGBZbUeWXBrBBCiINqQgUVsf8SaZW1rYO8vnOQREalyuPEbBwZSNMzaVJtbaRaW9E1fWQURVHeVmG2EktVNTlWK5de+xWGozGcNYvwuKwsqfNS7ZUKs0IIIQ6urAaV73//+3R3d/PKK6/Q19fHddddB8DPf/5zGTk5ALqCMVY3+GnqH6LIaWVqvn30PTUcJtnYSMbnQ3G5MDkc6JkM6uAgus3Kc40bWLLgKGxWK7qus+iC/0cspTK/Io+Taz2jU0ZCCCHEwZTVoFJXV4fH49ljm7LRKFMJH0Yqo7G+fZBXWgJEkxmmFzmxmHaNomgq6a5uks3N6MkExsJCFJMJNRpFjw5jKinlgX//hdVPPUpTyw5u+sl9dAzGyHWYOe+oKRw5NVfWogghhDhkshpULrvssmx+/GGpL5xgdYOPHb0RCnKsVHtdo+9psSjJpmbSPd0oVhvGIg/oOpnAAIrRhLVuJpbKaZyT/3k2vfEii868mNZAlNpiF6fP8lKaa3+PTxZCCCEOPFmjcphIqxqbOkO81DRAOJ6msigHq2lXCXx0Mv39JBubUCNhTAUFKGYLWjKJFgqRsJrpU1IcWVUFQGllNV/5w7MoRjPHTM/nxBqPLJgVQgiRFRJUDgO+oQQvNPjZ3hvBbTNT43WOHiSop1IkW1pIdXSAQcHkLQZG1qjo6RThHCu3//SbxKPD/F/tbPJLy2kLRCl2OTi1zsus0rcOJRRCCCEONQkqE5iq6WzuCvFik5/BaIppBTljRj4ywUGSjY2oAwMYcnMx2OyjC2YVhwP7zCPJKfZS8vB0QgEfA6EIYXOUWaVuTp9VjMclC5qFEEJklwSVCSownOSFRj9bu8M4rSZqvW+NfOhqhlRHJ6mdLaPF2xSDETUWQxseImTUmTJvHua8PACu/99fEkgaMNvsLJ5eyOLqwtFpIyGEECKbJKhMMJqm82ZPmDWNfvxDSSoKcrBb3goV2vAwicZGMn19KA4Hptw8dE0jEwigGA2s7WnhgT//iss//zWWfvyzJNIqvoyd4jwrp83yMrPEncXeCSGEEGNJUJlAQrEUaxr9bO4KYzMZxxwk+NY5PU1o0djoOT16MokaCmLMy8daV4thyEc6lWT7+ldZtOxKAtEUc6fmctpML4VOmeoRQggxvkhQmQB0XWd7b4Q1jX56wwnK8x3kWN/6o9MSCVItzaQ6O1FM5pEKs4AaCaMnUzBlCvZZszDY7Jx24Sdw5RVSNPcEEhmNM2YVc+yMwtE6K0IIIcR4IkFlnIsk0rzUNMCG9iBmo4Hat42iwN7P6dm9YDZtMvKvtc/R2t7Ed+95FAMQT6u4Zx1PsdvOabO8VHmkDL4QQojxS4LKOKXrOo39w6xp9NMVjFHiMuN78SFagKozrkSBPc7pUQwGtF0LZk1eL8n8XF79ybNEI2G2vr6G0tnHMvT63zECF934FYpyc7LcSyGEEOK9SVAZh6LJDC83D7CuPYgCVHtdKFoG3673kwP96F29pPt9GHaf07N7waxBwVJTg3X6dBwmM9d++6coRhOumoVouv7Wh6TjgAQVIYQQ45ssTBhnWvzDPPRGBy81D5DvsDCtMAejQSHS3Tx6TdemZxnyd2AqLMTocKCnUqh+H0Nqmt/880/0aSkU08ihgbXHnIqj6mgqChwcYQ+OPuOuu+5iw4YNh7x/QgghxP6QoDJOxFMqK+t9/H1dJ33hBNVeJ7n2kbCRTkTx73htzPURJYKKhhqJoIbDmCum8a/Xn2Xzupf4/W3fQNM0ukNx/ENJjq8q5OzaXF5fs3L0fl3XeeKJJ4hEIoe0n0IIIcT+kKmfcaA9EGV1g58W/zDFbhv5Dsvoezo68a62vd6XCvqw2nKxzZ2DeWoZV5Z/j+HhCJct/ybN/igFOWbOmjOFuVNyaW9vQ3/71A8jYWVwcBC3W2qnCCGEGJ8kqGRRIq2ytnWQ13YGSGY0qjxOzMa3Brn0VJJky07U9vY9b9ahPxajw9fD0iVLAHDlFfC579+NbyhBXYmL02Z6KXbbACgsLERRlDFhRVEUCgoKDm4nhRBCiA9BgkqWdAVjrG7w09Q/RJHTSlm+Y8z7mcFd5/QEBjDn5pKrGwlHe0bfN1oLuP1/v4ymqVQeeTR1846hczAGCpxa6+W4qsIx5/643W6WLl3Kk08+CYyElGXLlsloihBCiHFNgsohlsporG8f5JWWANFkhulFzjHF1nQ1Q6q9ndTOVvTMW+f02BMQ3nXN1Nmn4qiYzomvvEgiHsdTUUNT/xAleXZOq/NSV+La62cvWrSIuro6BgcHKSgokJAihBBi3FP0dy5cmEAikQi5ubmEw+EJ8aXbF06wqsFHfW+EghzrHqcTq5EIyeamkXN6cnIw5jjRdR1tKIKeTLHV18H88z+KI78QgEwmTTCmEoynOWJqLktmeinIsezto4UQQohxY3++v2VE5RBIqxqbOkO81DRAOJ6msihnzOnEuqaR6ekm0dyMHotjLChEMZlGKswGB1Fsdv65YTX//fdDnNbXztVf/wGqptMRTGIzGzlrTjELKwvGrG8RQgghDgcSVA4y31CCFxr8bO+N4LaZqfE6Ud5WAl+Lx0k2N5Pu6kKxWkamehRlpMLs0BCmYi/W2lrmO808++Qj5BV4GE6k6QrFmVbo4PSZxVQWSeE2IYQQhyeZ+jlIVE1nc1eIF5v8DEZTTCvIGbO4FSDd30+qqQk1EsaYl49isaBrGmowiKqrRHLsVCw+cbR420BfN6qjkEgizbzyPJbM9OK2mbPRPSGEEOIDk6mfLAsMJ3mh0c/W7jBOq4lar2vMKIqeTpHc2Upq17ZjY9HIOT16KoUaHCSiaNzz8N0EgwF++JenyXHnktE0wgY3Dl3n3CNKmV+Rj9GgvFsThBBCiMOCBJUDSNN03uwJs6bRj38oSUVBDnbL2FGUTDBIsqkRdWAAg8uNwW4HQB0aQk8kMJeXU1A2leF7f0oiHqVrZyNTZ82nKxhjelEOZ8wqprzAsbePF0IIIQ47ElQOkFAsxZpGP5u7wthMRmqKXRjePoqiqqQ7O0nubEFPpTAWFqEYjeiqijo4SFoB15w5mMvKUAwGbrzttzhcbjKOQvrCcY6ZXsCpdV6cVvkjE0IIMXnINpEPSdd1tvWE+evaDta1Bylx25iabx8TUrToMPGtW0hs3w6KAVORB8VoRIvHUQf8NAV6+N6vvsuW1h0ohpE/kikz6ggZ3CjAuUdO4Zy5pRJShBBCTDryzfchRBJpXmwcYGNHELPRQO07R1HQyfT0kmxuRhsexpifj2I2o+s6aigIuo6luoaG/24kOODjPw/cw9Enn8lwMkN3KM6MohzOmF28R9VaIYQQYrKQoPIB6LpOY/8waxr9dAVjTMmz43rH7hstmSTV0kKqsxPdoOAz9EO4H4+zEiUcw+h2Y62txVTs5dLpX8PuyuXsj11NbzhBIq1yfFUhJ9V4yJFRFCGEEJOYfAvup2gyw8vNA6xrD6IA1V7XHrtvMoEBko2NZAYHMebmEdOjEB15zz/URp8/xNbXdvL5E3+BgoLZYuXcq26gLRAlP8fImbtOPDbIrh4hhBCTnASV/dDsG+aFRh/tgRiluXZy7WNHUXQ1Q6qtnVRrK3omg8njQdM1wsG3DhNEAa/XzdYHV7P51VXMO/40QrEU/ZEEtSUuzphVPHrisRBCCDHZSVDZB/GUyqs7A7zRGiCj6VR7nZgMY9chjz2nx4kpLw+A1HBoj+cZDAYuv+ZG5h57Cu2BKChwSp2X499x4rEQQggx2UlQeR/tgSirG/y0+IcpdtvId4w99E/XNTLdezmnR9dRQyHUZAzdqI8p+AYKR595KS3+6PueeCyEEEJMZhJU3kUqo/HazgCv7xwkkVGp8jj3OPRPS8RJNu15To+eTqMODmJwuXj42b+RiQ2ybNmyXXcp2KsX0RtXOKo8lyV1XvLlxGMhhBBirySovIsW/zCrG3zkOyxMzbfv8X7G7yPZ2IQaCo6c02O1AqAOD6PHYpimlGKrreOSaVO582uffevG2WdhyM3j7OoiFk7LxyQnHgshhBDvSoLKu1A1HU2HQqd1zOt6Ok2ytZVUWxvoOkaPd+ScHk1FDQYJR4foU1QWHnkWitHIlJwqfvjAs8QyOl3BODM8OZw+s5iKQqmNIoQQQrwfCSr7QQ2HSDY0kPEPYHC5MDhGwoaWTKKGggxkktz+m++TSaf4wdHHUlIxHV3X6R9Ok0irLK4q5ORaj1SYFUIIIfaRfGPuA11TSXd1kWxuQU8mMRbtOqdH19HCYfRMBuv06UybPoPKZx8hOhQBRta5tAWiFOSYpTaKEEII8QFIUHkfWjRKoqmRTE8vit2OyeMBQM9k+P/t3X9M1fUex/HXOUfAA8gPTZKTxx/4C4MCU9LRLIVU8OZiu6l/WGvZ5HZbLlvkbatZtt3twsVdp7uu1ZjWbl6d2x1Kay0V2sQ1y7Ga0xS8pXEzQwXhcEDgHL73D8WbGmY38PPB83z8d76HP17bh8N58fl+v+9vuLlZZwPNGv/QPEXf45PL5dbqP2+RNzZOgW7p2/PtSk9NUH56ilKYjQIAwK9GUemP06tQ8wV1nPjuynN6kuSKunx3TjgYlBNsV/XRz/Wvyn9oeWitfrfiD5Kk2BFJamzukNst5aWnaHYas1EAAPh/UVT60fP9GfWcOi0nqud/tx339irc0iKXx6OYqdOU0HVR4XBIpxu+luM4utTTq++ag/IlX56NMuVuZqMAAPBbUFT64XR3ywmH5RmddPn1lQtme7zDlXh/tobddZfmT5qklLHjlTHrITUFutTW2aMZ45I1b9poJcUyGwUAgN+KovILHMdRb1ubOgKt2lmzW00t5/RmRaUkyeVyKf2BXP37XLviYoZp8f2pmuFPYjYKAAADhG/Um3AcR+Fz5ySPW660iTr69Zc6dfJrHf/yc0lS26UenTzXrvGj4rRsll85E0ZSUgAAGEDsqNyEy+3WsJQUxUydqhEJCfrjmxsVNyJBkzIf0H9aOtQd7lXupFGaO2W04piNAgDAgOPf/35839GuHf/coLPDPfIkJEiSsnPna9z0bJ1sCig22qOi7Hu0KGMMJQUAgEFCUenHu+/+XY0nj2jb39bLcRxJUnOwW6cuBJU+JkHLcvzKvCfxuqciAwCAgcRWQD/+9OZf9G1Tm4pL1qnXkb67ENQwj0v56XdrdtpIxQxjNgoAAIONotKPxORk/b7kr/ImedXQFJA/OVbz01M0OSXedDQAACIGReUmQmFH37d2aub4ZM2blqJEb5TpSAAARBSKSj88bpd8ycM1e+JIZfuT5eFhggAA3HYUlX5MTolXauJwJswCAGAQd/30I8rjpqQAAGAYRQUAAFiLogIAAKxFUQEAANaiqAAAAGtRVAAAgLUoKgAAwFoUFQAAYC2KCgAAsBZFBQAAWIuiAgAArEVRAQAA1qKoAAAAa1FUAACAtYaZDvBbOI4jSWprazOcBAAA3Kq+7+2+7/GbGdJFJRAISJL8fr/hJAAA4NcKBAJKTEy86c+4nFupM5bq7e3VmTNnNGLECLlcLtNxbqqtrU1+v1+NjY1KSEgwHQc/wdrYiXWxF2tjp6G0Lo7jKBAIyOfzye2++VUoQ3pHxe12a+zYsaZj/CoJCQnW/wJFKtbGTqyLvVgbOw2VdfmlnZQ+XEwLAACsRVEBAADWoqjcJjExMXrjjTcUExNjOgquw9rYiXWxF2tjpzt1XYb0xbQAAODOxo4KAACwFkUFAABYi6ICAACsRVG5DXbs2KElS5YoLy9P69evVzAYNB0JkhobG7Vu3Trl5uZq8+bNpuPgivr6epWUlGjBggVavny5Pvjgg1sas43B9/HHH+vpp59WXl6ennnmGdXW1pqOhOusWbNGc+bM0cGDB01HGTAUlUG2efNmrVy5UoWFhVq9erV27dqloqIi07EiXm1trebOnSu3262mpiadPn3adCRIqqurU1FRkXw+n9auXau8vDy9+OKLeumll0xHi3ibNm1SRUWFFi5cqNdff10+n0/z5s3Thx9+aDoarti6dav279+vQ4cOqaWlxXScAcNdP4Oou7tbY8aM0dq1a/Xqq69Kko4eParMzEzt27dP+fn5hhNGrmAwqOHDh8vj8Sg7O1uPPvqoysvLTceKeJ2dnYqJiblmpPY777yjF154QYFA4I677XIo6ejoUGxs7DXHHnnkEU2cOFHbtm0zEwpXnThxQvPnz9eePXuUk5OjqqoqPfbYY6ZjDQh2VAZRXV2dWlpatGTJkqvHMjIylJaWpn379hlMhri4OHk8HtMxcB2v13vDcz/i4+MVDocVCoUMpYKkG0rK2bNnVV9fr6ysLEOJ0Kerq0vLly9XWVmZJkyYYDrOgBvSz/qxXd/pBJ/Pd81xn8/HqQbgFnR3d6u8vFwLFixQXFyc6TgRr7u7Ww8//LC6urrU0NCgV155RWvWrDEdK+K9/PLLmj59up588kmdP3/edJwBR1EZRD09PZJ0w3a11+u9+h6An+c4jlauXKkffvhBu3fvNh0HkqKiorRx40YFg0Ht3btXZWVlmj17tgoKCkxHi1iVlZWqqqrSV199ZTrKoKGoDKKRI0dKkpqbm6/ZNr1w4YLS0tJMxQKs5ziOiouLtXfvXtXU1Mjv95uOBEkul0tz5syRJOXn5+vHH3/Ua6+9RlEx6L333lM4HL66Bn2nSEtKSvTRRx9py5YtJuMNCIrKIJoxY4ZcLpe++OILjR07VpLU3t6uY8eOqbi42HA6wE6O4+i5557Tnj17VF1drXvvvdd0JPQjNTVV1dXVpmNEtNLSUjU3N1993draqoKCAq1atUqFhYUGkw0cisogSk1NVWFhocrKylRQUCCv16vS0lJFR0friSeeMB0PsNLzzz+vyspKVVdXKyMjw3QcXLFp0yatWLFCo0aNknR53s37779/x9xZMlRNnTr1mtd916hMmzbtjin5FJVBVlFRoaKiIqWmpioxMVGdnZ3atWvX1Q87zGhtbdWiRYskSQ0NDWpqalJtba2mT5+urVu3Gk4XuT755BO9/fbb8vv9evbZZ695b/v27ZwyNSglJUWzZs1SdHS0pMsDE5966ilt2LDBcDLc6ZijcpucPHlSHR0dSk9Pv/pBhzmhUEiHDx++4Xh8fLwyMzMNJIIkXbx4UcePH//Z97KysuT1em9zIvyU4zj65ptvFAqFNG7cONbDQn1/29LT05WUlGQ6zoCgqAAAAGsx8A0AAFiLogIAAKxFUQEAANaiqAAAAGtRVAAAgLUoKgAAwFoUFQAAYC2KCgAAsBZFBQAAWIuiAsAaPT092rlzp+rr6685XlNTo08//dRMKABGUVQAWCMqKkoHDx7U4sWLFQgEJEkHDhzQwoULFQqFDKcDYALP+gFglUuXLiknJ0czZ87Uxo0blZWVpaVLl6q8vNx0NAAGUFQAWOfIkSN68MEHNWXKFHk8Hh06dIinjgMRilM/AKxz3333admyZTpy5IjKysooKUAEY0cFgHUOHz6s3NxcTZ48WaNHj1ZNTY3cbv6vAiIRn3wAVgkGg1qxYoVWrVql/fv369ixYyotLTUdC4Ah7KgAsEpxcbEOHDiguro6eb1e7d69W0uXLtVnn32mmTNnmo4H4DZjRwWANU6dOqVAIKDt27fL6/VKkh5//HG99dZbqqqqMpwOgAnsqAAAAGuxowIAAKxFUQEAANaiqAAAAGtRVAAAgLUoKgAAwFoUFQAAYC2KCgAAsBZFBQAAWIuiAgAArEVRAQAA1qKoAAAAa1FUAACAtf4LIdGtW6YA8eYAAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -416,50 +699,63 @@ } ], "source": [ - "def band(chain, levels=(5, 95)):\n", - " draws = chain[:: max(1, len(chain) // 300)]\n", - " ys = np.array([model.y(xg, *p) for p in draws])\n", - " return np.percentile(ys, levels, axis=0)\n", - "\n", - "\n", - "lo_g, hi_g = band(chain_gauss)\n", - "lo_t, hi_t = band(chain_t)\n", + "fig, ax = plt.subplots(figsize=(4.6, 4.4))\n", + "ax.plot([0, 1], [0, 1], \"--\", color=\"0.5\", label=\"nominal\")\n", + "for name, colour, marker in (\n", + " (\"untempered\", plotstyle.COLOURS[0], \"o-\"),\n", + " (\"tempered\", plotstyle.COLOURS[2], \"^-\"),\n", + "):\n", + " ax.plot(\n", + " levels,\n", + " coverage[name],\n", + " marker,\n", + " color=colour,\n", + " label=f\"{name} (68 % width {width[name]:.3f})\",\n", + " )\n", + "ax.plot(\n", + " levels,\n", + " coverage[\"line alone\"],\n", + " \"s--\",\n", + " color=plotstyle.COLOURS[1],\n", + " label=\"the line alone (expected to miss)\",\n", + ")\n", + "ax.set(\n", + " xlabel=\"nominal coverage\",\n", + " ylabel=\"empirical coverage\",\n", + " xlim=(0, 1),\n", + " ylim=(0, 1),\n", + " title=\"Predictive coverage, tempered and not\",\n", + ")\n", + "ax.legend(fontsize=8)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "134b05e6", + "metadata": {}, + "source": [ + "The untempered predictive is already calibrated: its coverage is 0.55, 0.74 and 0.93 at nominal 0.5, 0.7 and 0.9, each within about one and a half binomial standard deviations of the diagonal. Tempering has nothing to fix. It moves the line towards the prior and widens the predictive by about a quarter (68 % width 0.634 against 0.500), and its coverage is indistinguishable from the untempered one's (0.52, 0.76 and 0.94): it is less sharp, for no gain in calibration.\n", "\n", - "plt.plot(xg, model.y(xg, m_true, b_true), \"k:\", label=\"true signal\")\n", - "plt.errorbar(x, y, noise, ls=\"none\", marker=\".\", color=\"gray\", label=\"data\")\n", - "plt.fill_between(xg, lo_g, hi_g, alpha=0.4, color=\"tab:red\", label=\"Gaussian\")\n", - "plt.fill_between(xg, lo_t, hi_t, alpha=0.4, color=\"tab:blue\", label=\"Student-t\")\n", - "plt.xlabel(\"x\")\n", - "plt.ylabel(\"y\")\n", - "plt.legend();" + "That is the lesson to carry into real problems. Tempering is worth reaching for when the *predictions* are overconfident, which a coverage check will show, and not merely because the parameters look precise. When a model really is misspecified, as the optical potentials in the other notebooks are, a better first move is usually to say *how* it is wrong in the error model (`gp_discrepancy`), and to learn the weight from the data if we temper at all: SafeBayes, from [Grünwald & van Ommen (2017)](https://doi.org/10.1214/17-BA1085), is recipe 25." ] }, { "cell_type": "markdown", - "id": "9e4a0f63", + "id": "484ea3a1", "metadata": {}, "source": [ "## Takeaways\n", "\n", - "- **The likelihood functional is a drop-in choice**: `Constraint(...,\n", - " likelihood=StudentT())` keeps the covariance model identical and changes only\n", - " the function of $(d^2, \\log\\det\\Sigma, n)$.\n", - "- **$\\nu$ is an ordinary nuisance parameter** — give it bounds on its\n", - " `Parameter`, a prior, and a `likelihood_samplers` entry, and the data choose\n", - " the tail weight.\n", - "- **The multivariate-t buys honesty, not outlier rejection**: one shared tail\n", - " factor widens the posterior to cover the truth where the Gaussian is\n", - " confidently biased; rejecting individual points needs per-point terms.\n", - "- **The full-tuple convention is uniform**: every method — `log_likelihood`,\n", - " `chi2`, `covariance_matrix` — takes covariance parameters then likelihood\n", - " parameters in `constraint.params` order, and raises on a wrong count instead\n", - " of guessing.\n" + "- A global error scale (recipe 34) widens every error bar together. It does not down-weight the outliers, and its centre stays where the Gaussian's is. A multivariate Student-t likelihood of the whole residual is the same thing, with a heavy-tailed prior on the scale.\n", + "- Tempering, `Constraint(weight=w)`, is the same kind of answer for a fixed covariance: every error bar times $1/\\sqrt{w}$. On a correctly specified problem it only lets the prior back in, so check the predictive coverage before reaching for it (recipe 12).\n", + "- Rejection (recipe 39) is the only one of the four that moves the line. It is an outer loop of problems, refitted between rounds; it gives the tightest answer and makes the strongest claim, so report what went and why." ] } ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -473,7 +769,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.3" + "version": "3.12.13" } }, "nbformat": 4, diff --git a/examples/run.py b/examples/run.py new file mode 100644 index 0000000..08c8816 --- /dev/null +++ b/examples/run.py @@ -0,0 +1,53 @@ +"""Execute the example notebooks in place: the committed outputs, full runs. + +:: + + python examples/run.py # every notebook, one at a time + python examples/run.py gp_discrepancy local_optical_model_calibration + +The documentation shows the notebooks as committed, so a changed notebook is +rerun with this script before it is committed. The notebooks run one after +another, so their wall times (printed, and listed in design.md's notebook +table) do not overlap. CI runs them quick instead (``RXMC_EXAMPLES_QUICK=1``, +see ``budget.py``) and never writes their outputs back. +""" + +from __future__ import annotations + +import argparse +import os +import sys +import time +from pathlib import Path + +import nbformat +from nbconvert.preprocessors import ExecutePreprocessor + +HERE = Path(__file__).resolve().parent + + +def run(name: str, timeout: int = 7200) -> float: + """Execute ``examples/.ipynb`` in place; its wall time in seconds.""" + path = HERE / f"{name}.ipynb" + nb = nbformat.read(path, as_version=4) + ep = ExecutePreprocessor(timeout=timeout, record_timing=False) + t0 = time.perf_counter() + ep.preprocess(nb, {"metadata": {"path": str(HERE)}}) + wall = time.perf_counter() - t0 + nbformat.write(nb, path) + return wall + + +def main(argv=None): + ap = argparse.ArgumentParser(description=__doc__.splitlines()[0]) + ap.add_argument("names", nargs="*", help="notebooks without .ipynb (default: all)") + args = ap.parse_args(argv) + if os.environ.get("RXMC_EXAMPLES_QUICK") == "1": + sys.exit("RXMC_EXAMPLES_QUICK=1 is set: committed notebooks are full runs") + names = args.names or sorted(p.stem for p in HERE.glob("*.ipynb")) + for name in names: + print(f"{name}: {run(name):.0f} s", flush=True) + + +if __name__ == "__main__": + main() diff --git a/examples/sampling_algos.ipynb b/examples/sampling_algos.ipynb deleted file mode 100644 index 1ba8e58..0000000 --- a/examples/sampling_algos.ipynb +++ /dev/null @@ -1,891 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "196a680f-91b8-4c45-8894-f56175a73082", - "metadata": {}, - "source": [ - "# Comparison of sampling algorithms for calibration of a line with unknown model error" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "7bb6c48f-b3e8-424e-962a-747343e60742", - "metadata": {}, - "outputs": [], - "source": [ - "from collections import OrderedDict" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "b11241d5-93d5-4e8f-8ca6-380154ca9a19", - "metadata": {}, - "outputs": [], - "source": [ - "import corner" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "c549ae62-7f81-4a8e-a54e-a7331a298c90", - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "a55118c3-ccbf-45bf-81a9-bdf6e9daf46c", - "metadata": {}, - "outputs": [], - "source": [ - "from matplotlib import pyplot as plt\n", - "from scipy import stats" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "22715d9f-6d09-4444-b9a5-243a1274c05c", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Using database version X4-2025-12-31 located in: /mnt/home/beyerkyl/x4db/unpack_exfor-2025/X4-2025-12-31\n" - ] - } - ], - "source": [ - "import rxmc" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "abee925c-9d84-443e-9e6c-ca3dd5a29afe", - "metadata": {}, - "outputs": [], - "source": [ - "true_params = OrderedDict(\n", - " [\n", - " (\"m\", 2),\n", - " (\"b\", 4),\n", - " ]\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "1f8e822c-4807-452b-b4b9-a6e25af16006", - "metadata": {}, - "outputs": [], - "source": [ - "rng = np.random.default_rng(43)" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "6c697651-05eb-4082-962e-144f86fd7dbf", - "metadata": {}, - "outputs": [], - "source": [ - "noise = 0.05\n", - "N = 12\n", - "# x_data = rng.random(N)\n", - "x_data = np.linspace(0, 1, N)\n", - "y_true = true_params[\"m\"] * x_data + true_params[\"b\"]\n", - "y_err = np.array([rng.normal(0, noise * y) for y in y_true])\n", - "y_data = y_true + y_err\n", - "\n", - "# Define priors: (mean, variance) for normal, (alpha, beta) for inverse gamma\n", - "reported_stat_err = noise * np.mean(y_data)\n", - "m_prior = (2, 10)\n", - "b_prior = (1, 10)\n", - "sigma2_prior = (3, reported_stat_err / (3 - 1))" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "31abc19d-08d7-49c4-98f8-0c58d235fcd8", - "metadata": {}, - "outputs": [], - "source": [ - "class LinearModel(rxmc.physical_model.PhysicalModel):\n", - " def __init__(self):\n", - " params = [\n", - " rxmc.params.Parameter(\"m\", float, \"no-units\"),\n", - " rxmc.params.Parameter(\"b\", float, \"y-units\"),\n", - " ]\n", - " super().__init__(params)\n", - "\n", - " def evaluate(self, observation, m, b):\n", - " return self.y(observation.x, m, b)\n", - "\n", - " def y(self, x, m, b):\n", - " # useful to have a function hat takes in an array-like x\n", - " # rather than an Observation, e.g. for plotting\n", - " return m * x + b" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "5ee482a3-6a9d-4fd2-bcb1-6fbf4d400502", - "metadata": {}, - "outputs": [], - "source": [ - "prior_mean = OrderedDict(\n", - " [\n", - " (\"m\", 1),\n", - " (\"b\", 5),\n", - " ]\n", - ")\n", - "prior_std_dev = OrderedDict(\n", - " [\n", - " (\"m\", 0.5),\n", - " (\"b\", 0.5),\n", - " ]\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "591b9219-baf9-4a06-80bb-89b8a76b4248", - "metadata": {}, - "outputs": [], - "source": [ - "covariance = np.diag(list(prior_std_dev.values())) ** 2\n", - "mean = np.array(list(prior_mean.values()))\n", - "prior_distribution = stats.multivariate_normal(mean, covariance)" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "66395e1c-6724-4dbf-89e2-b83b94f8ba89", - "metadata": {}, - "outputs": [], - "source": [ - "my_model = LinearModel()" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "22e4b752-4be1-457e-b934-8316031e2cfc", - "metadata": {}, - "outputs": [], - "source": [ - "observation = rxmc.observation.Observation(\n", - " x=x_data,\n", - " y=y_data,\n", - " y_stat_err=y_true * noise,\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "0fc8e25a-7544-4b80-ad8b-4b48447dc998", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.errorbar(\n", - " x_data,\n", - " y_data,\n", - " noise * y_data,\n", - " color=\"k\",\n", - " marker=\"o\",\n", - " linestyle=\"none\",\n", - " label=\"experiment with bias\",\n", - ")\n", - "plt.plot(x_data, y_true, \"k\", label=\"truth\")" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "54636463-a169-43d1-9498-dece057a7550", - "metadata": {}, - "outputs": [], - "source": [ - "log_noise = rxmc.params.Parameter(\n", - " \"log noise fraction\", float, latex_name=r\"\\log{\\epsilon}\", unit=\"dimensionless\"\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "ed7e3fce-125d-49a9-8742-718e06d3d764", - "metadata": {}, - "outputs": [], - "source": [ - "constraint = rxmc.constraint.Constraint(\n", - " [observation],\n", - " my_model,\n", - " extra_terms=[\n", - " rxmc.covariance.noise_fraction_term(\n", - " log_noise,\n", - " support=np.arange(observation.n_data_pts),\n", - " )\n", - " ],\n", - ")\n", - "evidence = rxmc.evidence.Evidence([constraint])" - ] - }, - { - "cell_type": "markdown", - "id": "de01662a-532d-40ae-b284-232a64e29f82", - "metadata": {}, - "source": "## Sampling configurations for the model parameters" - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "d16ee5a9-5db9-4830-af3a-75faffe0f018", - "metadata": {}, - "outputs": [], - "source": [ - "def proposal_distribution(x, rng):\n", - " return stats.multivariate_normal.rvs(\n", - " mean=x, cov=prior_distribution.cov / 100, random_state=rng\n", - " )\n", - "\n", - "\n", - "metropolis_model = rxmc.param_sampling.MetropolisHastingsSampler(\n", - " params=my_model.params,\n", - " starting_location=prior_distribution.mean,\n", - " proposal=proposal_distribution,\n", - " prior=prior_distribution,\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "16efc114-712a-429a-8a21-38f8785a099f", - "metadata": {}, - "outputs": [], - "source": [ - "adaptive_model = rxmc.param_sampling.BatchedAdaptiveMetropolisSampler(\n", - " params=my_model.params,\n", - " starting_location=prior_distribution.mean,\n", - " prior=prior_distribution,\n", - " initial_proposal_cov=prior_distribution.cov / 1000,\n", - ")" - ] - }, - { - "cell_type": "markdown", - "id": "f9852933-dad1-484e-89e8-b13e19e8d166", - "metadata": {}, - "source": "## Sampling configurations for the likelihood parameters" - }, - { - "cell_type": "code", - "execution_count": 20, - "id": "e65ff4ba-f8fb-4f2e-b113-206a8519d389", - "metadata": {}, - "outputs": [], - "source": [ - "noise_prior = stats.norm(loc=np.log(0.01), scale=1)" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "id": "a4b60043-c490-4b10-b65b-6c6b11b36f17", - "metadata": {}, - "outputs": [], - "source": [ - "def proposal_distribution_log_noise(x, rng):\n", - " return np.atleast_1d(stats.norm.rvs(loc=x, scale=0.1, random_state=rng))\n", - "\n", - "\n", - "metropolis_likelihood = rxmc.param_sampling.MetropolisHastingsSampler(\n", - " params=list(constraint.params),\n", - " starting_location=np.array(noise_prior.mean()),\n", - " proposal=proposal_distribution_log_noise,\n", - " prior=noise_prior,\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "id": "cdab8ed0-1b9e-470c-b4c3-dca64d89d736", - "metadata": {}, - "outputs": [], - "source": [ - "adaptive_likelihood = rxmc.param_sampling.BatchedAdaptiveMetropolisSampler(\n", - " params=list(constraint.params),\n", - " starting_location=np.array(noise_prior.mean()),\n", - " prior=noise_prior,\n", - " initial_proposal_cov=np.array([[1]]),\n", - ")" - ] - }, - { - "cell_type": "markdown", - "id": "e659a30a-50c7-4938-8292-cbc89d8ede1b", - "metadata": {}, - "source": [ - "## Walkers" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "id": "38e27c49-fbb4-473f-9b1c-68ca55ecb076", - "metadata": {}, - "outputs": [], - "source": [ - "walker_metropolis = rxmc.walker.Walker(\n", - " metropolis_model,\n", - " evidence,\n", - " likelihood_samplers=[metropolis_likelihood],\n", - ")\n", - "walker_adaptive = rxmc.walker.Walker(\n", - " adaptive_model,\n", - " evidence,\n", - " likelihood_samplers=[adaptive_likelihood],\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "id": "69de493c-ca79-4369-89d7-29117f10e45b", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Burn-in batch 1/10 completed, 100 steps.\n", - "Burn-in batch 2/10 completed, 100 steps.\n", - "Burn-in batch 3/10 completed, 100 steps.\n", - "Burn-in batch 4/10 completed, 100 steps.\n", - "Burn-in batch 5/10 completed, 100 steps.\n", - "Burn-in batch 6/10 completed, 100 steps.\n", - "Burn-in batch 7/10 completed, 100 steps.\n", - "Burn-in batch 8/10 completed, 100 steps.\n", - "Burn-in batch 9/10 completed, 100 steps.\n", - "Burn-in batch 10/10 completed, 100 steps.\n", - "Batch: 1/50 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.310\n", - " Likelihood parameter acceptance fractions: [0.46]\n", - "Batch: 2/50 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.310\n", - " Likelihood parameter acceptance fractions: [0.53]\n", - "Batch: 3/50 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.650\n", - " Likelihood parameter acceptance fractions: [0.49]\n", - "Batch: 4/50 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.390\n", - " Likelihood parameter acceptance fractions: [0.39]\n", - "Batch: 5/50 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.320\n", - " Likelihood parameter acceptance fractions: [0.44]\n", - "Batch: 6/50 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.330\n", - " Likelihood parameter acceptance fractions: [0.43]\n", - "Batch: 7/50 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.290\n", - " Likelihood parameter acceptance fractions: [0.44]\n", - "Batch: 8/50 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.600\n", - " Likelihood parameter acceptance fractions: [0.42]\n", - "Batch: 9/50 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.380\n", - " Likelihood parameter acceptance fractions: [0.51]\n", - "Batch: 10/50 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.290\n", - " Likelihood parameter acceptance fractions: [0.52]\n", - "Batch: 11/50 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.440\n", - " Likelihood parameter acceptance fractions: [0.39]\n", - "Batch: 12/50 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.500\n", - " Likelihood parameter acceptance fractions: [0.26]\n", - "Batch: 13/50 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.330\n", - " Likelihood parameter acceptance fractions: [0.47]\n", - "Batch: 14/50 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.410\n", - " Likelihood parameter acceptance fractions: [0.48]\n", - "Batch: 15/50 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.440\n", - " Likelihood parameter acceptance fractions: [0.41]\n", - "Batch: 16/50 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.380\n", - " Likelihood parameter acceptance fractions: [0.44]\n", - "Batch: 17/50 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.190\n", - " Likelihood parameter acceptance fractions: [0.46]\n", - "Batch: 18/50 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.450\n", - " Likelihood parameter acceptance fractions: [0.34]\n", - "Batch: 19/50 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.350\n", - " Likelihood parameter acceptance fractions: [0.49]\n", - "Batch: 20/50 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.370\n", - " Likelihood parameter acceptance fractions: [0.5]\n", - "Batch: 21/50 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.450\n", - " Likelihood parameter acceptance fractions: [0.52]\n", - "Batch: 22/50 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.380\n", - " Likelihood parameter acceptance fractions: [0.44]\n", - "Batch: 23/50 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.240\n", - " Likelihood parameter acceptance fractions: [0.48]\n", - "Batch: 24/50 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.330\n", - " Likelihood parameter acceptance fractions: [0.5]\n", - "Batch: 25/50 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.470\n", - " Likelihood parameter acceptance fractions: [0.34]\n", - "Batch: 26/50 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.380\n", - " Likelihood parameter acceptance fractions: [0.51]\n", - "Batch: 27/50 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.310\n", - " Likelihood parameter acceptance fractions: [0.43]\n", - "Batch: 28/50 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.540\n", - " Likelihood parameter acceptance fractions: [0.45]\n", - "Batch: 29/50 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.290\n", - " Likelihood parameter acceptance fractions: [0.45]\n", - "Batch: 30/50 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.350\n", - " Likelihood parameter acceptance fractions: [0.42]\n", - "Batch: 31/50 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.390\n", - " Likelihood parameter acceptance fractions: [0.37]\n", - "Batch: 32/50 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.410\n", - " Likelihood parameter acceptance fractions: [0.52]\n", - "Batch: 33/50 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.450\n", - " Likelihood parameter acceptance fractions: [0.46]\n", - "Batch: 34/50 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.440\n", - " Likelihood parameter acceptance fractions: [0.49]\n", - "Batch: 35/50 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.310\n", - " Likelihood parameter acceptance fractions: [0.42]\n", - "Batch: 36/50 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.430\n", - " Likelihood parameter acceptance fractions: [0.51]\n", - "Batch: 37/50 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.310\n", - " Likelihood parameter acceptance fractions: [0.58]\n", - "Batch: 38/50 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.420\n", - " Likelihood parameter acceptance fractions: [0.46]\n", - "Batch: 39/50 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.260\n", - " Likelihood parameter acceptance fractions: [0.59]\n", - "Batch: 40/50 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.360\n", - " Likelihood parameter acceptance fractions: [0.38]\n", - "Batch: 41/50 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.550\n", - " Likelihood parameter acceptance fractions: [0.38]\n", - "Batch: 42/50 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.200\n", - " Likelihood parameter acceptance fractions: [0.44]\n", - "Batch: 43/50 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.610\n", - " Likelihood parameter acceptance fractions: [0.43]\n", - "Batch: 44/50 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.430\n", - " Likelihood parameter acceptance fractions: [0.38]\n", - "Batch: 45/50 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.160\n", - " Likelihood parameter acceptance fractions: [0.32]\n", - "Batch: 46/50 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.330\n", - " Likelihood parameter acceptance fractions: [0.56]\n", - "Batch: 47/50 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.410\n", - " Likelihood parameter acceptance fractions: [0.37]\n", - "Batch: 48/50 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.320\n", - " Likelihood parameter acceptance fractions: [0.36]\n", - "Batch: 49/50 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.230\n", - " Likelihood parameter acceptance fractions: [0.4]\n", - "Batch: 50/50 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.390\n", - " Likelihood parameter acceptance fractions: [0.43]\n", - "CPU times: user 4.8 s, sys: 224 ms, total: 5.02 s\n", - "Wall time: 4.78 s\n" - ] - } - ], - "source": [ - "%%time\n", - "walker_adaptive.walk(n_steps=5000, burnin=1000, batch_size=100)" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "id": "eeee43dd-2c5d-43df-9ed2-7610abe4899f", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Burn-in batch 1/1 completed, 1000 steps.\n", - "Batch: 1/20 completed, 1000 steps. \n", - " Model parameter acceptance fraction: 0.670\n", - " Likelihood parameter acceptance fractions: [0.825]\n", - "Batch: 2/20 completed, 1000 steps. \n", - " Model parameter acceptance fraction: 0.750\n", - " Likelihood parameter acceptance fractions: [0.825]\n", - "Batch: 3/20 completed, 1000 steps. \n", - " Model parameter acceptance fraction: 0.799\n", - " Likelihood parameter acceptance fractions: [0.839]\n", - "Batch: 4/20 completed, 1000 steps. \n", - " Model parameter acceptance fraction: 0.870\n", - " Likelihood parameter acceptance fractions: [0.83]\n", - "Batch: 5/20 completed, 1000 steps. \n", - " Model parameter acceptance fraction: 0.725\n", - " Likelihood parameter acceptance fractions: [0.827]\n", - "Batch: 6/20 completed, 1000 steps. \n", - " Model parameter acceptance fraction: 0.797\n", - " Likelihood parameter acceptance fractions: [0.839]\n", - "Batch: 7/20 completed, 1000 steps. \n", - " Model parameter acceptance fraction: 0.690\n", - " Likelihood parameter acceptance fractions: [0.839]\n", - "Batch: 8/20 completed, 1000 steps. \n", - " Model parameter acceptance fraction: 0.614\n", - " Likelihood parameter acceptance fractions: [0.847]\n", - "Batch: 9/20 completed, 1000 steps. \n", - " Model parameter acceptance fraction: 0.651\n", - " Likelihood parameter acceptance fractions: [0.835]\n", - "Batch: 10/20 completed, 1000 steps. \n", - " Model parameter acceptance fraction: 0.784\n", - " Likelihood parameter acceptance fractions: [0.834]\n", - "Batch: 11/20 completed, 1000 steps. \n", - " Model parameter acceptance fraction: 0.722\n", - " Likelihood parameter acceptance fractions: [0.82]\n", - "Batch: 12/20 completed, 1000 steps. \n", - " Model parameter acceptance fraction: 0.821\n", - " Likelihood parameter acceptance fractions: [0.816]\n", - "Batch: 13/20 completed, 1000 steps. \n", - " Model parameter acceptance fraction: 0.766\n", - " Likelihood parameter acceptance fractions: [0.819]\n", - "Batch: 14/20 completed, 1000 steps. \n", - " Model parameter acceptance fraction: 0.637\n", - " Likelihood parameter acceptance fractions: [0.815]\n", - "Batch: 15/20 completed, 1000 steps. \n", - " Model parameter acceptance fraction: 0.768\n", - " Likelihood parameter acceptance fractions: [0.839]\n", - "Batch: 16/20 completed, 1000 steps. \n", - " Model parameter acceptance fraction: 0.642\n", - " Likelihood parameter acceptance fractions: [0.851]\n", - "Batch: 17/20 completed, 1000 steps. \n", - " Model parameter acceptance fraction: 0.621\n", - " Likelihood parameter acceptance fractions: [0.833]\n", - "Batch: 18/20 completed, 1000 steps. \n", - " Model parameter acceptance fraction: 0.646\n", - " Likelihood parameter acceptance fractions: [0.838]\n", - "Batch: 19/20 completed, 1000 steps. \n", - " Model parameter acceptance fraction: 0.753\n", - " Likelihood parameter acceptance fractions: [0.849]\n", - "Batch: 20/20 completed, 1000 steps. \n", - " Model parameter acceptance fraction: 0.718\n", - " Likelihood parameter acceptance fractions: [0.834]\n", - "CPU times: user 13.2 s, sys: 130 ms, total: 13.4 s\n", - "Wall time: 13.4 s\n" - ] - } - ], - "source": [ - "%%time\n", - "walker_metropolis.walk(n_steps=20000, burnin=1000, batch_size=1000)" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "id": "d7dbdf6f-a1ab-484f-ae5b-a635aeafe4e5", - "metadata": {}, - "outputs": [], - "source": [ - "def plot_chains(walker, model, true_params):\n", - " fig, axes = plt.subplots(\n", - " walker.model_sampler.chain.shape[1] + 3, 1, figsize=(8, 8), sharex=True\n", - " )\n", - " for i in range(walker.model_sampler.chain.shape[1]):\n", - " axes[i].plot(walker.model_sampler.chain[:, i])\n", - " axes[i].set_ylabel(f\"${model.params[i].latex_name}$ [{model.params[i].unit}]\")\n", - " true_value = true_params[model.params[i].name]\n", - " axes[i].hlines(\n", - " true_value, 0, len(walker.model_sampler.chain), \"r\", linestyle=\"--\"\n", - " )\n", - "\n", - " axes[-3].plot(walker.model_sampler.logp_chain)\n", - " axes[-3].set_ylabel(r\"$\\log{\\mathcal{L}(\\alpha_i | \\mathcal{O})}$\")\n", - "\n", - " lmp = walker.likelihood_samplers[0].params[0]\n", - " axes[-2].plot(walker.likelihood_samplers[0].chain)\n", - " axes[-2].set_ylabel(f\"${lmp.latex_name}$ [{lmp.unit}]\")\n", - " axes[-2].hlines(\n", - " np.log(noise), 0, len(walker.likelihood_samplers[0].chain), \"r\", linestyle=\"--\"\n", - " )\n", - "\n", - " axes[-1].plot(walker.likelihood_samplers[0].logp_chain)\n", - " axes[-1].set_ylabel(r\"$\\log{\\mathcal{L}(\\alpha_i | \\mathcal{O})}$\")\n", - "\n", - " axes[-1].set_xlabel(r\"$i$\")\n", - " # plt.legend(title=\"chains\", ncol=3,)" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "id": "5177b6d1-ab00-475a-aec5-905af482662c", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_chains(walker_metropolis, my_model, true_params)" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "id": "5de6d5d2-c745-4a72-b24c-d75c108be3a9", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_chains(walker_adaptive, my_model, true_params)" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "id": "a0c29d13-2373-452e-9e5e-a31dbcb4f91a", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 0.98, 'posterior')" - ] - }, - "execution_count": 29, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig = corner.corner(\n", - " np.hstack(\n", - " [\n", - " walker_metropolis.model_sampler.chain,\n", - " walker_metropolis.likelihood_samplers[0].chain,\n", - " ]\n", - " ),\n", - " labels=[p.name for p in my_model.params]\n", - " + [walker_metropolis.likelihood_samplers[0].params[0].name],\n", - " label=\"posterior\",\n", - " truths=[true_params[\"m\"], true_params[\"b\"], np.log(noise)],\n", - " color=\"tab:blue\",\n", - ")\n", - "corner.corner(\n", - " np.hstack(\n", - " [\n", - " walker_adaptive.model_sampler.chain,\n", - " walker_adaptive.likelihood_samplers[0].chain,\n", - " ]\n", - " ),\n", - " fig=fig,\n", - " color=\"tab:orange\",\n", - ")\n", - "\n", - "fig.suptitle(\"posterior\")" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "id": "4b6154cb-284f-43f9-b03f-cef4329b0efd", - "metadata": {}, - "outputs": [], - "source": [ - "x = np.linspace(-0.5, 1.5, 10)\n", - "n_posterior_samples = walker_metropolis.model_sampler.chain.shape[0]\n", - "y1 = np.zeros((n_posterior_samples, len(x)))\n", - "for i in range(n_posterior_samples):\n", - " sample = walker_metropolis.model_sampler.chain[i, :]\n", - " y1[i, :] = my_model.y(x, *sample)\n", - "\n", - "n_posterior_samples = walker_adaptive.model_sampler.chain.shape[0]\n", - "y2 = np.zeros((n_posterior_samples, len(x)))\n", - "for i in range(n_posterior_samples):\n", - " sample = walker_adaptive.model_sampler.chain[i, :]\n", - " y2[i, :] = my_model.y(x, *sample)" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "id": "2a678f70-58e3-4c4f-a290-7125f334b823", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 31, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Metropolis Hastings\n", - "upper, med, lower = np.percentile(y1, [5, 50, 95], axis=0)\n", - "p = plt.fill_between(\n", - " x, lower, upper, alpha=0.3, zorder=2, color=\"tab:blue\", label=\"Metropolis-Hastings\"\n", - ")\n", - "plt.plot(x, med, \":\", color=p.get_facecolor())\n", - "\n", - "# adaptive\n", - "upper, med, lower = np.percentile(y2, [5, 50, 95], axis=0)\n", - "p = plt.fill_between(\n", - " x,\n", - " lower,\n", - " upper,\n", - " alpha=0.3,\n", - " zorder=2,\n", - " color=\"tab:orange\",\n", - " label=\"Adaptive Metropolis\",\n", - ")\n", - "plt.plot(x, med, \":\", color=p.get_facecolor())\n", - "\n", - "# truth\n", - "plt.plot(x, my_model.y(x, *true_params.values()), \"k--\", label=\"truth\")\n", - "plt.errorbar(\n", - " x_data,\n", - " y_data,\n", - " noise * y_data,\n", - " color=\"k\",\n", - " marker=\"o\",\n", - " linestyle=\"none\",\n", - " label=\"experiment with bias\",\n", - ")\n", - "\n", - "plt.xlabel(r\"$x$\")\n", - "plt.ylabel(r\"$y$\")\n", - "plt.legend()" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.13.5" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/examples/systematic_err_demo.ipynb b/examples/systematic_err_demo.ipynb deleted file mode 100644 index 7c09426..0000000 --- a/examples/systematic_err_demo.ipynb +++ /dev/null @@ -1,6398 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "5add9362-edc2-4c55-a0ff-1fc5cf1d4ed7", - "metadata": {}, - "source": [ - "# Introduction to the likelihood" - ] - }, - { - "cell_type": "markdown", - "id": "5e1bd043-2bcc-4323-8b6b-0ae67c834ec1", - "metadata": {}, - "source": [ - "When we are fitting the parameters $\\alpha$ in some model $\\mathcal{M}(x;\\alpha)$ to some data $\\mathcal{D} = \\{x_i , y_i\\}$, how do we judge how well a given model prediction $\\{ x_i , y_m(x_i;\\alpha) \\equiv \\mathcal{M}(x_i;\\alpha) \\} $ describes our data $\\mathcal{D}$?" - ] - }, - { - "cell_type": "markdown", - "id": "6dba0045-1a53-46f1-9ee4-7da617d9b630", - "metadata": {}, - "source": [ - "We have to come up with a model for the *likelihood*. This is the conditional probability that our data $\\mathcal{D}$ (also called evidence) is described by a given model prediction $y_m(x_i;\\alpha)$. We can write it as $p(\\mathcal{D} | y_m(x_i;\\alpha))$ or $p(\\mathcal{D} | \\mathcal{M}, \\alpha)$. Sometimes we use $\\mathcal{L}$ instead of $p$ to write the likelihood, but it is just a conditional probability. It tells you the probability, given model $\\mathcal{M}$, with a fixed set of parameters $\\alpha$, that some data $\\mathcal{D} = \\{ x_i,y_i \\}$ is the result.\n", - "\n", - "Every method for fitting or calibrating a model (whether it is explicitly stated or not) makes some assumption about the likelihood.\n", - "\n", - "How do we come up with a *defensible* form for the likelihood for a given set of evidence and a given model? " - ] - }, - { - "cell_type": "markdown", - "id": "a3a790c4-f5cf-42b1-8c0d-c115116ea8b6", - "metadata": {}, - "source": [ - "## A very simple likelihood model \n", - "\n", - "What if there are no errors in our model or in $\\{ x_i, y_i\\}$ at all? Then our model must exactly reproduce $y_i$, and our lileihood is:\n", - "\n", - "\\begin{equation}\n", - "p(\\{ x_i,y_i \\} | y_m(x_i;\\alpha) ) = \\begin{cases} 1 & y_m(x_i;\\alpha) = y_i \\\\ 0 & \\rm{otherwise} \\end{cases}\n", - "\\end{equation}\n", - "\n", - "Can you guess what issues this might have?" - ] - }, - { - "cell_type": "markdown", - "id": "8f4629f7-fe33-4550-ade1-bf425eb4eebf", - "metadata": {}, - "source": [ - "## The general case\n", - "\n", - "In real cases, our evidence $\\mathcal{D}$ is more than just a set of numbers $\\{x_i , y_i\\}$. It is, in fact, a probability distribution itself: $\\mathcal{D} \\equiv p( \\vec{x}, \\vec{y} )$; a given $\\{x,y\\}$ pair is a measurement of a random variable. Based on the uncertainty information provided by the experimentalists, and the limitations in our model, we must come up with a reasonable model for what $p( \\vec{x}, \\vec{y} )$ is, and use it to construct a likelihood. \n", - "\n", - "Then, when we do a frequentist model fit, we are searching through $\\alpha$-space trying to find the $\\alpha$ that corresponds to $\\text{max} \\left[ p(\\mathcal{D}| \\mathcal{M},\\alpha) \\right]$. This is called [Maximum Likelihood Estimation (MLE)](https://en.wikipedia.org/wiki/Maximum_likelihood_estimation). \n", - "\n", - "As we shall see, minimizing the $\\chi^2$ is just a special case of MLE, subject to certain assumptions (which may not always be appropriate!).\n", - "\n", - "When we do a Bayesian calibration, we sample $\\alpha$-space in such a way that the samples converge on a distribution that is related to the likelihood, called the posterior $p(\\alpha | \\mathcal{D}, \\mathcal{M})$, which just modifies the likelihood to include prior belief about $\\alpha$: \n", - "\n", - "\\begin{equation}\n", - "p(\\alpha | \\mathcal{D}, \\mathcal{M}) \\propto p(\\mathcal{D}| \\mathcal{M},\\alpha) p(\\alpha).\n", - "\\end{equation}\n", - "\n", - "This is just the result of Bayes theorem. In Bayesian calibration as well, one often sees the likelihood $p(\\mathcal{D}| \\mathcal{M},\\alpha)$ modeled as $\\exp(-\\chi^2)$. Again, this may not always be appropriate! " - ] - }, - { - "cell_type": "markdown", - "id": "d3cc697b-c225-4b07-8cef-ba27d4149b03", - "metadata": {}, - "source": [ - "## Under what assumptions is a $\\chi^2$-distribution appropriate for the likelihood?\n", - "\n", - "Let us *assume* there is some ground truth $\\{x_i, y_i^\\rm{true}\\}$, and futhermore assume that our model, for some unknown true parameters, is able to exactly replicate the truth:\n", - "\n", - "\\begin{equation}\n", - "M(x_i;\\alpha^\\rm{true}) = y_i^\\rm{true}\n", - "\\end{equation}\n", - "\n", - "This may be a big assumption, and, in realistic scenarios, one may want to to instead use \n", - "\n", - "\\begin{equation}\n", - "M(x_i;\\alpha^\\rm{true}) = y_i^\\rm{true} + \\epsilon_i\n", - "\\end{equation}\n", - "\n", - "Where $\\epsilon_i$ is another random variable describing the model error. We will ignore this for now." - ] - }, - { - "cell_type": "markdown", - "id": "bb2fdf08-fe00-4463-a35f-2767f35b1a7e", - "metadata": {}, - "source": [ - "Now we need more assumptions: the measured values $\\vec{x}, \\vec{y}$ are random vectors from some multivariate probability distribution $p(\\vec{x},\\vec{y})$.\n", - "\n", - "Let's assume:\n", - "- there is no error in $x$; $x_i = x_i^\\rm{true}$\n", - "- each $y_i$ is really a number of counts in the bin $x_i = \\left[ x_{i0} , x_{if} \\right]$\n", - "- each count is independent of all the others (this is akin to saying there is no systematic error; later in the demo we will see a case for which this assumption is disastrous!)\n", - "\n", - "\n", - "If there are $N$ total counts, then $p_i = y_i^\\rm{true}/N$ is the probability of a count being in bin $i$, and $ 1 - p_i$ is the probability of not being in bin $i$. Our model prediction is for the probability of a single count being in bin $i$ is just $y_m(x_i;\\alpha) / N$. The probability of getting exactly $y$ counts in bin $i$ in $N$ trials is a binomial distribution:\n", - "\n", - "\\begin{equation}\n", - "p(y_i | N, p_i ) = B(N,p_i) \\equiv \\binom{N}{y_i} p_i^{y_i} (1-p_i)^{N-y_i} \n", - "\\end{equation}\n", - "\n", - "Plugging in our model prediction for $p_i$, we have the likelihood \n", - "\n", - "\\begin{equation}\n", - "p(y_i | N, p_i = \\mathcal{M}(x_i;\\alpha)/N ) = B(N,\\mathcal{M}(x_i;\\alpha)/N) \\equiv \\binom{N}{y_i} \\left( \\frac{y_m(x_i;\\alpha)}{N} \\right)^{y_i} \\left( 1- \\frac{y_m(x_i;\\alpha)}{ N} \\right)^{N-y_i} \n", - "\\end{equation}\n", - "\n", - "The total liklelihood is the product of this probability for every bin:\n", - "\n", - "\\begin{equation}\n", - "p( \\mathcal{D} | N, \\mathcal{M} , \\alpha)) = \\prod_i B(N,\\mathcal{M}(x_i;\\alpha)/N) \\equiv \\prod_i \\binom{N}{y_i} \\left( \\frac{y_m(x_i;\\alpha)}{N} \\right)^{y_i} \\left( 1- \\frac{y_m(x_i;\\alpha)}{ N} \\right)^{N-y_i} \n", - "\\end{equation}\n", - "\n", - "As long as $N$ is known exactly (it's own can of worms), then this is exactly what we are looking for! In principle, one could exactly use this formula in this situation.\n" - ] - }, - { - "cell_type": "markdown", - "id": "304c3c77-b950-4c16-ba88-bf8c3a4cebf9", - "metadata": {}, - "source": [ - "How do we get the $\\chi^2$ form? Well, when $N \\rightarrow \\infty$ and $p_i^\\rm{true} \\rightarrow 0$ such that $N p_i^\\rm{true} = y_i^\\rm{true}$ stays constant, the binomial distribution limits to a Poission distribution, with mean $y_i^{\\rm{true}}$ and standard deviation $\\sigma_i = \\sqrt{y_i^{\\rm{true}}}$:\n", - "\n", - "\\begin{equation}\n", - "p( \\mathcal{D} | N, \\mathcal{M} , \\alpha) \\rightarrow \\prod_i \\frac{ (y_i^{\\rm{true}})^y }{ y\\! } e^{-y_i^{\\rm{true}}}\n", - "\\end{equation}\n", - "\n", - "Then using the Central Limit Theorem, we find in the limit as $N \\rightarrow \\infty$ and $0 < p_i < 1$ fixed, that our Poisson distribution becomes a normal distribution:\n", - "\n", - "\\begin{align}\n", - "p( \\mathcal{D} | N, \\mathcal{M} , \\alpha) &\\rightarrow \\prod_i \\frac{1}{\\sqrt{2 \\pi y_i^{\\rm{true}}}} \\exp{ - \\frac{\\left( y_i - y_i^{\\rm{true}}\\right)^2}{ 2 y_i^{\\rm{true}}} }\n", - "\\end{align}\n", - "\n", - "Plugging in $y_m(x_i;\\alpha)$ for $y_i^\\rm{true}$ and $\\sigma_i$ for the standard deviation, we have:\n", - "\n", - "\\begin{equation}\n", - "p( \\mathcal{D} | N, \\mathcal{M} , \\alpha) = \\prod_i \\frac{1}{\\sqrt{2 \\pi \\sigma_i^2}} \\exp{ \\left( \\frac{(y_i - y_m(x_i;\\alpha))^2}{2 \\sigma_i^2} \\right)}\n", - "\\end{equation}\n", - "\n", - "Take the log of this function, one of the terms will be of the $\\chi^2$ form:\n", - "\n", - "\n", - "\\begin{equation}\n", - "\\log p( \\mathcal{D} | N, \\mathcal{M} , \\alpha) \\propto -\\frac{1}{2} \\sum_i \\frac{(y_i - y_m(x_i;\\alpha))^2}{\\sigma_i^2} + \\dots \\equiv \\chi^2 + \\dots \n", - "\\end{equation}\n", - "\n", - "\n", - "It is a useful excercise to take this log and see what the other terms are exactly. In some likelihood models, where the covariance is not known a priori but has parameters that are fit along side the physical model, these other terms will also play a role.\n", - "\n", - "If you've taken a stats course, you've probably done these two limits (Binomial to Poission and Poission to Normal) at some point or another. A nice pedagogical source for the derivations is [The Knolly Bible, Ch. 3](https://indico-tdli.sjtu.edu.cn/event/171/contributions/2123/attachments/982/1592/Knoll4thEdition.pdf). Also, I would like to mention that chatgpt was also useful in preparing this discussion.\n" - ] - }, - { - "cell_type": "markdown", - "id": "3b8ef1af-2756-4689-921d-6073c945918e", - "metadata": {}, - "source": [ - "## too long; didn't read:\n", - "\n", - "The main point I want to get across is is that we had to make many assumptions to get our likeliood to look like a $\\chi^2$! These assumptions are not valid in every case. Whether you are doing Bayesian calibration or frequentist model fitting, whether or not you're even doing uncertainty quantification (which you should be doing), or you just care about finding the \"best\" parameters, it is your job to come up with a *likelihood model*. That is, a model for the function $p(\\{x_i,y_i\\}| \\mathcal{M},\\alpha)$. You must carefully consider the data and its errors, as well as your physics model and its errors, to come up with such a model. You must also think carefully about the implications of any simplifying assumptions you make (e.g. ignoring systematic error), and transparently disclose them." - ] - }, - { - "cell_type": "markdown", - "id": "d6095157-c38c-42d1-be67-ae5a10be46e0", - "metadata": {}, - "source": [ - "## In this demo: the multivariate normal liklelihood model \n", - "\n", - "In this demo, we will introduce some systematic error. That is, instead of measuring the number of counts in a bin, $y_i$ will instead be some derived quantity like a cross section, which includes some normalization. In particular, we will consider a scenario where this normalization is not known exactly.\n", - "\n", - "This will break the assumption from above that each $y_i$ is indepent from each other. If the limiting conditions leading to a normal distribution are still valid, but there is some covariance between $y_i$'s for different points $x_i$, one can write the likelihood more generally as:\n", - "\n", - "\\begin{equation}\n", - "p( \\mathcal{D} | N, \\mathcal{M} , \\alpha) = \\frac{1}{\\sqrt{(2 \\pi)^k |\\mathbf{\\Sigma}|}} \\exp{\\left( -\\frac{1}{2} \\vec{\\Delta}^T \\cdot \\mathbf{\\Sigma}^{-1} \\cdot \\vec{\\Delta} \\right)},\n", - "\\end{equation}\n", - "\n", - "where $\\Delta \\equiv (y_i - y_m(x_i;\\alpha))$ and $k$ is the number of elements in the vector $\\vec{\\Delta}$. Then, one must find a model for the covariance matrix $\\mathbf{\\Sigma}$. If $\\mathbf{\\Sigma}$ is diagonal, this will resemble the $\\exp{\\left( -\\frac{1}{2}\\chi^2 \\right)}$ form. The demo will begin with this assmumption, and test out different models for the covariance matrix $\\mathbf{\\Sigma}$.\n", - "\n", - "In fact, one can show that this is a very good assumption for many cases due to the Central Limit Theorem, as any bounded, finite-variance distribution looks like a normal distribution near the mean. One can think of the generalized $\\chi^2 \\equiv \\vec{\\Delta}^T \\cdot \\mathbf{\\Sigma}^{-1} \\cdot \\vec{\\Delta}$ (which is also the squared [Mahalanobis distance](https://en.wikipedia.org/wiki/Mahalanobis_distance)) as the truncation of the Taylor expansion of the log probability of an arbitrary distribution to 2nd order. See [Bayesian Data Analysis by Gelman, Ch. 4](https://sites.stat.columbia.edu/gelman/book/BDA3.pdf). In other words, for cases in which there are many samples and the CLT applies, the above model for the likelihood function as a generalized multivariate normal is often adequate. The job of the modeler is then to come up with a model for $\\mathbf{\\Sigma}$, given their knowledge of the experimental evidence and the model. This is what we will be doing in the demo.\n", - "\n", - "Some good reading is [D'Agostini, 1994](https://s3.cern.ch/inspire-prod-files-a/af06df9041f5b73dcdf6d1ae8172caa1)." - ] - }, - { - "cell_type": "markdown", - "id": "3bb1e807-4a14-4dc2-b3d2-539edd155b77", - "metadata": {}, - "source": [ - "# Comparing likelihood models: there is a right way, and many wrong ways!" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "69d96b52-427c-4345-8622-d2726544a77c", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:08:57.685052Z", - "iopub.status.busy": "2026-08-11T03:08:57.684884Z", - "iopub.status.idle": "2026-08-11T03:09:00.461343Z", - "shell.execute_reply": "2026-08-11T03:09:00.460616Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Using database version X4-2024-12-31 located in: /home/kyle/db/exfor/unpack_exfor-2024/X4-2024-12-31\n" - ] - } - ], - "source": [ - "from collections import OrderedDict\n", - "\n", - "import corner\n", - "import numpy as np\n", - "from matplotlib import pyplot as plt\n", - "from scipy import stats\n", - "\n", - "import rxmc" - ] - }, - { - "cell_type": "markdown", - "id": "baaea2d0-41de-4876-9930-a9e4e7b662e8", - "metadata": {}, - "source": [ - "## Plotting functions" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "81124826-23ca-4713-9b4b-9ed6626dc567", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:09:00.463594Z", - "iopub.status.busy": "2026-08-11T03:09:00.463332Z", - "iopub.status.idle": "2026-08-11T03:09:00.467741Z", - "shell.execute_reply": "2026-08-11T03:09:00.467131Z" - } - }, - "outputs": [], - "source": [ - "def plot_chains(walker, model, true_params):\n", - " fig, axes = plt.subplots(\n", - " walker.model_sampler.chain.shape[1] + 1, 1, figsize=(8, 8), sharex=True\n", - " )\n", - " for i in range(walker.model_sampler.chain.shape[1]):\n", - " axes[i].plot(walker.model_sampler.chain[:, i])\n", - " axes[i].set_ylabel(f\"${model.params[i].latex_name}$ [{model.params[i].unit}]\")\n", - " true_value = true_params[model.params[i].name]\n", - " axes[i].hlines(\n", - " true_value, 0, len(walker.model_sampler.chain), \"r\", linestyle=\"--\"\n", - " )\n", - "\n", - " axes[-1].plot(walker.model_sampler.logp_chain)\n", - " axes[-1].set_ylabel(r\"$\\log{\\mathcal{L}(\\alpha_i | \\mathcal{O})}$\")\n", - " axes[-1].set_xlabel(r\"$i$\")" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "dbdd23dd-ecef-43e4-9954-572e7fe1da0f", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:09:00.469457Z", - "iopub.status.busy": "2026-08-11T03:09:00.469307Z", - "iopub.status.idle": "2026-08-11T03:09:00.472158Z", - "shell.execute_reply": "2026-08-11T03:09:00.471582Z" - } - }, - "outputs": [], - "source": [ - "def plot_posterior_corner(walker, true_params):\n", - " fig = corner.corner(\n", - " walker.model_sampler.chain,\n", - " labels=[p.name for p in my_model.params],\n", - " label=\"posterior\",\n", - " truths=[true_params[\"m\"], true_params[\"b\"]],\n", - " )\n", - " fig.suptitle(\"posterior\")" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "72a48951-4660-4d4e-bb8b-4c8980282eb0", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:09:00.473618Z", - "iopub.status.busy": "2026-08-11T03:09:00.473479Z", - "iopub.status.idle": "2026-08-11T03:09:00.477590Z", - "shell.execute_reply": "2026-08-11T03:09:00.477012Z" - } - }, - "outputs": [], - "source": [ - "def plot_predictive_post(walker, model, x, y_exp, y_err, y_true, x_true=None):\n", - " if x_true is None:\n", - " x_true = x\n", - " n_posterior_samples = walker.model_sampler.chain.shape[0]\n", - " y = np.zeros((n_posterior_samples, len(x)))\n", - " for i in range(n_posterior_samples):\n", - " sample = walker.model_sampler.chain[i, :]\n", - " y[i, :] = model.y(x, *sample)\n", - "\n", - " upper, median, lower = np.percentile(y, [5, 50, 95], axis=0)\n", - " plt.errorbar(\n", - " x,\n", - " y_exp,\n", - " y_err,\n", - " color=\"k\",\n", - " marker=\"o\",\n", - " linestyle=\"none\",\n", - " label=\"experiment\",\n", - " )\n", - "\n", - " plt.plot(x, y_true, \"k--\", label=\"truth\")\n", - " plt.plot(x, median, \"m:\", label=\"posterior median\")\n", - " plt.fill_between(\n", - " x,\n", - " lower,\n", - " upper,\n", - " alpha=0.5,\n", - " zorder=2,\n", - " label=r\"posterior inner 90$^\\text{th}$ pctl\",\n", - " )\n", - " plt.legend()\n", - " plt.xlabel(\"x\")\n", - " plt.ylabel(\"y\")" - ] - }, - { - "cell_type": "markdown", - "id": "fcf6b674-c76d-47a4-852c-11e57538e625", - "metadata": {}, - "source": [ - "## make the model" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "9f859e53-c6f9-4d88-b7bf-bbc5bc9ab686", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:09:00.479244Z", - "iopub.status.busy": "2026-08-11T03:09:00.479091Z", - "iopub.status.idle": "2026-08-11T03:09:00.482357Z", - "shell.execute_reply": "2026-08-11T03:09:00.481750Z" - } - }, - "outputs": [], - "source": [ - "class LinearModel(rxmc.physical_model.PhysicalModel):\n", - " def __init__(self):\n", - " params = [\n", - " rxmc.params.Parameter(\"m\", float, \"no-units\"),\n", - " rxmc.params.Parameter(\"b\", float, \"y-units\"),\n", - " ]\n", - " super().__init__(params)\n", - "\n", - " def y(self, x, m, b):\n", - " return m * x + b\n", - "\n", - " def evaluate(self, observation, m, b):\n", - " return self.y(observation.x, m, b)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "931eb9c2-6dfe-4538-98c1-c940333f5406", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:09:00.483849Z", - "iopub.status.busy": "2026-08-11T03:09:00.483706Z", - "iopub.status.idle": "2026-08-11T03:09:00.486203Z", - "shell.execute_reply": "2026-08-11T03:09:00.485466Z" - } - }, - "outputs": [], - "source": [ - "my_model = LinearModel()" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "6e6b4a56-38df-44ef-8cd0-0454ab01ad2a", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:09:00.487761Z", - "iopub.status.busy": "2026-08-11T03:09:00.487619Z", - "iopub.status.idle": "2026-08-11T03:09:00.490169Z", - "shell.execute_reply": "2026-08-11T03:09:00.489481Z" - } - }, - "outputs": [], - "source": [ - "rng = np.random.default_rng(16)" - ] - }, - { - "cell_type": "markdown", - "id": "cf188ab7-8ee4-47b7-9d77-2e2e358a1bbf", - "metadata": {}, - "source": [ - "## set up prior" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "138cb996-aab0-4a80-b0ae-eb07677b33cd", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:09:00.491723Z", - "iopub.status.busy": "2026-08-11T03:09:00.491579Z", - "iopub.status.idle": "2026-08-11T03:09:00.494136Z", - "shell.execute_reply": "2026-08-11T03:09:00.493380Z" - } - }, - "outputs": [], - "source": [ - "true_params = OrderedDict(\n", - " [\n", - " (\"m\", 0.6),\n", - " (\"b\", 2),\n", - " ]\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "1ee04e0a-9d10-479c-b0d5-cd4e2b2bd55b", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:09:00.495610Z", - "iopub.status.busy": "2026-08-11T03:09:00.495466Z", - "iopub.status.idle": "2026-08-11T03:09:00.498045Z", - "shell.execute_reply": "2026-08-11T03:09:00.497448Z" - } - }, - "outputs": [], - "source": [ - "prior_mean = OrderedDict(\n", - " [\n", - " (\"m\", 2),\n", - " (\"b\", 5),\n", - " ]\n", - ")\n", - "prior_std_dev = OrderedDict(\n", - " [\n", - " (\"m\", 2),\n", - " (\"b\", 2),\n", - " ]\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "5107c785-2e6e-4c10-a5b0-c8eaf906549f", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:09:00.499407Z", - "iopub.status.busy": "2026-08-11T03:09:00.499248Z", - "iopub.status.idle": "2026-08-11T03:09:00.502299Z", - "shell.execute_reply": "2026-08-11T03:09:00.501656Z" - } - }, - "outputs": [], - "source": [ - "covariance = np.diag(list(prior_std_dev.values())) ** 2\n", - "mean = np.array(list(prior_mean.values()))\n", - "prior_distribution = stats.multivariate_normal(mean, covariance)" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "37bd2c80-2873-4f73-b994-2101b42bec7f", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:09:00.503959Z", - "iopub.status.busy": "2026-08-11T03:09:00.503806Z", - "iopub.status.idle": "2026-08-11T03:09:00.507359Z", - "shell.execute_reply": "2026-08-11T03:09:00.506602Z" - } - }, - "outputs": [], - "source": [ - "systematic_fractional_err = 0.1\n", - "# choose a normalization 1 std deviation below the mean\n", - "N = 1 - systematic_fractional_err\n", - "noise_fraction = 0.05\n", - "x = np.linspace(0.01, 1.0, 15, dtype=float)\n", - "y_true = my_model.y(x, *list(true_params.values()))\n", - "y_exp = (y_true + rng.normal(scale=noise_fraction * y_true, size=len(x))) * N\n", - "y_stat_err = noise_fraction * y_exp * N" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "7247bee4-67b8-4ac6-8f21-74373b733177", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:09:00.509189Z", - "iopub.status.busy": "2026-08-11T03:09:00.509040Z", - "iopub.status.idle": "2026-08-11T03:09:00.748450Z", - "shell.execute_reply": "2026-08-11T03:09:00.747747Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 1.0, 'experimental constraint with bias')" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.errorbar(\n", - " x,\n", - " y_exp,\n", - " y_stat_err,\n", - " color=\"k\",\n", - " marker=\"o\",\n", - " linestyle=\"none\",\n", - " label=\"experiment with bias\",\n", - ")\n", - "plt.plot(x, y_true, \"k--\", label=\"truth\")\n", - "plt.xlabel(\"x\")\n", - "plt.ylabel(\"y\")\n", - "plt.legend()\n", - "plt.title(\"experimental constraint with bias\")" - ] - }, - { - "cell_type": "markdown", - "id": "b5284f41-4a29-4c2a-b1ba-3497910bc120", - "metadata": {}, - "source": [ - "## Compare Likelihood Models\n", - "We will look at a few different cases:\n", - "1. Covariance is fixed to just statistical error (disregarding systematic error)\n", - "\n", - " \\begin{equation}\n", - " \\Sigma_{ij} = \\delta_{ij} \\sigma_{stat,i}^2\n", - " \\end{equation}\n", - "\n", - "3. Covariance is just statistical error, but we fit the magnitude of the statistical noise $\\eta$ (disregarding systematic error). This means the covariance is not fixed, but will be updated during calibration.\n", - "\n", - " \\begin{equation}\n", - " \\Sigma_{ij} = \\delta_{ij} \\eta^2 y_m(x_j; \\alpha)^2\n", - " \\end{equation}\n", - "\n", - "\n", - "5. Systematic error is included properly in covariance, making the covariance a function of the model prediction. Again, this means the covariance is not fixed, but will be updated during calibration.\n", - "\n", - " \\begin{equation}\n", - " \\Sigma_{ij}(\\alpha) = \\delta_{ij} \\sigma_{stat,i}^2 + \\sigma_N^2 y_m(x_i; \\alpha) y_m(x_j; \\alpha)\n", - " \\end{equation}\n", - "\n", - "7. Systematic error is included improperly in covariance, using the experimental $y(x_i)$ instead of the model prediction $y_m(x_i;\\alpha)$. In this case the covariance is again fixed.\n", - "\n", - " \\begin{equation}\n", - " \\Sigma_{ij} = \\delta_{ij} \\sigma_{stat,i}^2 + \\sigma_N^2 y(x_i) y(x_j)\n", - " \\end{equation}\n", - "\n", - "9. Unknown *constant* statistical noise, inferred alongside the model (option 2b):\n", - "\n", - " \\begin{equation}\n", - " \\Sigma_{ij} = \\delta_{ij} \\epsilon_0^2\n", - " \\end{equation}\n", - "\n", - "11. An additive **offset** systematic, included as a rank-one mode with a constant basis (option 5):\n", - "\n", - " \\begin{equation}\n", - " \\Sigma_{ij} = \\delta_{ij} \\sigma_{stat,i}^2 + \\omega^2\n", - " \\end{equation}\n" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "b5f05c68-32ab-467d-8635-94f6ffd9c4de", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:09:00.750539Z", - "iopub.status.busy": "2026-08-11T03:09:00.750376Z", - "iopub.status.idle": "2026-08-11T03:09:00.754153Z", - "shell.execute_reply": "2026-08-11T03:09:00.753542Z" - } - }, - "outputs": [], - "source": [ - "# 1 and 2 (reported statistical errors)\n", - "obs_stat_only = rxmc.observation.Observation(\n", - " x=x,\n", - " y=y_exp,\n", - " y_stat_err=y_stat_err,\n", - ")\n", - "\n", - "# 2 (unknown statistical error: reported errors ignored, inferred instead)\n", - "obs_unknown_stat = rxmc.observation.Observation(x=x, y=y_exp)\n", - "\n", - "# 3 (normalization systematic supplied as a covariance Term, scales with ym)\n", - "obs_sys_norm_correct = rxmc.observation.Observation(\n", - " x=x,\n", - " y=y_exp,\n", - " y_stat_err=y_stat_err,\n", - ")\n", - "\n", - "# 4 (the \"wrong\" fixed covariance, built from the DATA -> Peelle's Pertinent Puzzle)\n", - "obs_sys_norm_wrong = rxmc.observation.Observation(x=x, y=y_exp)\n", - "wrong_cov = np.diag(y_stat_err**2) + systematic_fractional_err**2 * np.outer(\n", - " y_exp, y_exp\n", - ")" - ] - }, - { - "cell_type": "markdown", - "id": "4818c696-b984-4145-b911-5307782e0dd5", - "metadata": {}, - "source": [ - "## set up likelihood models and constraints" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "34d5d663-8735-4c87-b05d-12a886204959", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:09:00.756076Z", - "iopub.status.busy": "2026-08-11T03:09:00.755921Z", - "iopub.status.idle": "2026-08-11T03:09:00.758754Z", - "shell.execute_reply": "2026-08-11T03:09:00.758096Z" - } - }, - "outputs": [], - "source": [ - "# 1 and 3 - the default Gaussian likelihood\n", - "likelihood = rxmc.likelihood_model.GaussianLikelihood()\n", - "\n", - "# 2 - free noise-fraction parameter, sampled as a covariance nuisance\n", - "log_noise_fraction = rxmc.params.Parameter(\n", - " \"log noise fraction\", float, latex_name=r\"\\log{\\epsilon}\", unit=\"dimensionless\"\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "ea87d212-bb42-4174-b274-f785b8e29e8f", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:09:00.760562Z", - "iopub.status.busy": "2026-08-11T03:09:00.760403Z", - "iopub.status.idle": "2026-08-11T03:09:00.765403Z", - "shell.execute_reply": "2026-08-11T03:09:00.764617Z" - } - }, - "outputs": [], - "source": [ - "# 1\n", - "evidence_stat_only = rxmc.evidence.Evidence(\n", - " [rxmc.constraint.Constraint([obs_stat_only], my_model, likelihood)]\n", - ")\n", - "\n", - "# 2\n", - "evidence_unknown_stat = rxmc.evidence.Evidence(\n", - " [\n", - " rxmc.constraint.Constraint(\n", - " [obs_unknown_stat],\n", - " my_model,\n", - " extra_terms=[rxmc.covariance.noise_fraction_term(log_noise_fraction)],\n", - " )\n", - " ]\n", - ")\n", - "\n", - "# 3\n", - "evidence_sys_correct = rxmc.evidence.Evidence(\n", - " [\n", - " rxmc.constraint.Constraint(\n", - " [obs_sys_norm_correct],\n", - " my_model,\n", - " extra_terms=[\n", - " rxmc.covariance.normalization_term(\n", - " magnitude=systematic_fractional_err,\n", - " )\n", - " ],\n", - " )\n", - " ]\n", - ")\n", - "\n", - "# 4\n", - "evidence_sys_wrong = rxmc.evidence.Evidence(\n", - " [\n", - " rxmc.constraint.Constraint(\n", - " [obs_sys_norm_wrong],\n", - " my_model,\n", - " extra_terms=[rxmc.covariance.Term(wrong_cov)],\n", - " )\n", - " ]\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "f237192a-4f2f-4b2c-8d0f-30d3e71ca123", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:09:00.767237Z", - "iopub.status.busy": "2026-08-11T03:09:00.767062Z", - "iopub.status.idle": "2026-08-11T03:09:00.769908Z", - "shell.execute_reply": "2026-08-11T03:09:00.769230Z" - } - }, - "outputs": [], - "source": [ - "def proposal_distribution_model(x, rng):\n", - " return stats.multivariate_normal.rvs(\n", - " mean=x, cov=prior_distribution.cov / 1000, random_state=rng\n", - " )" - ] - }, - { - "cell_type": "markdown", - "id": "fbb7e0d9-8a86-4228-9372-ee63dfad5ee3", - "metadata": {}, - "source": [ - "## Run option 1: fixed covariance, statistical error only" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "194af035-fafd-4c64-8b58-0f7af34bb685", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:09:00.771842Z", - "iopub.status.busy": "2026-08-11T03:09:00.771676Z", - "iopub.status.idle": "2026-08-11T03:09:00.774653Z", - "shell.execute_reply": "2026-08-11T03:09:00.773960Z" - } - }, - "outputs": [], - "source": [ - "walker1 = rxmc.walker.Walker(\n", - " rxmc.param_sampling.MetropolisHastingsSampler(\n", - " params=my_model.params,\n", - " starting_location=prior_distribution.mean,\n", - " proposal=proposal_distribution_model,\n", - " prior=prior_distribution,\n", - " ),\n", - " evidence_stat_only,\n", - " rng=rng,\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "25f3b9a2-5bf0-47a3-94f4-17bc1f864d20", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:09:00.776494Z", - "iopub.status.busy": "2026-08-11T03:09:00.776325Z", - "iopub.status.idle": "2026-08-11T03:09:04.497031Z", - "shell.execute_reply": "2026-08-11T03:09:04.496394Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Burn-in batch 1/1 completed, 1000 steps.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 1/1 completed, 10000 steps. \n", - " Model parameter acceptance fraction: 0.336\n", - "CPU times: user 3.72 s, sys: 25.3 ms, total: 3.75 s\n", - "Wall time: 3.72 s\n" - ] - } - ], - "source": [ - "%%time\n", - "walker1.walk(n_steps=10000, burnin=1000)" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "98de6f5c-2c40-44bf-9120-bd2f1c809273", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:09:04.498537Z", - "iopub.status.busy": "2026-08-11T03:09:04.498385Z", - "iopub.status.idle": "2026-08-11T03:09:05.597104Z", - "shell.execute_reply": "2026-08-11T03:09:05.596500Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_chains(walker=walker1, model=my_model, true_params=true_params)" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "id": "2106dc08-96ce-49df-8ae8-5a2cf7f45783", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:09:05.598567Z", - "iopub.status.busy": "2026-08-11T03:09:05.598415Z", - "iopub.status.idle": "2026-08-11T03:09:05.770222Z", - "shell.execute_reply": "2026-08-11T03:09:05.769551Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_posterior_corner(walker=walker1, true_params=true_params)" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "id": "0c8ab69c-5fad-4b2e-a505-b7df7b266a86", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:09:05.772006Z", - "iopub.status.busy": "2026-08-11T03:09:05.771852Z", - "iopub.status.idle": "2026-08-11T03:09:05.988574Z", - "shell.execute_reply": "2026-08-11T03:09:05.987835Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 1.0, 'option 1: fixed statistical error, systematic ignored')" - ] - }, - "execution_count": 21, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_predictive_post(\n", - " walker=walker1, model=my_model, x=x, y_exp=y_exp, y_err=y_stat_err, y_true=y_true\n", - ")\n", - "plt.title(\"option 1: fixed statistical error, systematic ignored\")" - ] - }, - { - "cell_type": "markdown", - "id": "2799a418-343d-428e-a2d2-93bae9444858", - "metadata": {}, - "source": [ - "## Run option 2: unknown statistical error" - ] - }, - { - "cell_type": "markdown", - "id": "57185a88-4e94-445a-af8c-c0da5cc72845", - "metadata": {}, - "source": [ - "We need to come up with a prior for the noise for option 2. We will keep it fairly wide and centered about the reported value." - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "id": "3750e61b-6028-4493-8bea-faa5d8ed6bbb", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:09:05.990533Z", - "iopub.status.busy": "2026-08-11T03:09:05.990369Z", - "iopub.status.idle": "2026-08-11T03:09:05.993357Z", - "shell.execute_reply": "2026-08-11T03:09:05.992820Z" - } - }, - "outputs": [], - "source": [ - "noise_prior = stats.norm(loc=np.log(noise_fraction), scale=1)" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "id": "1424209b-d14f-449e-a433-5265b1162bc0", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:09:05.994650Z", - "iopub.status.busy": "2026-08-11T03:09:05.994512Z", - "iopub.status.idle": "2026-08-11T03:09:05.996913Z", - "shell.execute_reply": "2026-08-11T03:09:05.996403Z" - } - }, - "outputs": [], - "source": [ - "def proposal_distribution_noise(x, rng):\n", - " return np.atleast_1d(stats.norm.rvs(loc=x, scale=0.1, random_state=rng))" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "id": "396e21a8-3866-4f04-9ad3-8e401ddb8ccd", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:09:05.998435Z", - "iopub.status.busy": "2026-08-11T03:09:05.998305Z", - "iopub.status.idle": "2026-08-11T03:09:06.001312Z", - "shell.execute_reply": "2026-08-11T03:09:06.000753Z" - } - }, - "outputs": [], - "source": [ - "walker2 = rxmc.walker.Walker(\n", - " model_sampler=rxmc.param_sampling.MetropolisHastingsSampler(\n", - " params=my_model.params,\n", - " starting_location=prior_distribution.mean,\n", - " proposal=proposal_distribution_model,\n", - " prior=prior_distribution,\n", - " ),\n", - " evidence=evidence_unknown_stat,\n", - " likelihood_samplers=[\n", - " rxmc.param_sampling.MetropolisHastingsSampler(\n", - " params=[log_noise_fraction],\n", - " starting_location=noise_prior.mean(),\n", - " proposal=proposal_distribution_noise,\n", - " prior=noise_prior,\n", - " )\n", - " ],\n", - " rng=rng,\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "id": "92db7ab4-b071-4fc0-900c-1dde26ec5438", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:09:06.002626Z", - "iopub.status.busy": "2026-08-11T03:09:06.002490Z", - "iopub.status.idle": "2026-08-11T03:09:14.493812Z", - "shell.execute_reply": "2026-08-11T03:09:14.493183Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Burn-in batch 1/10 completed, 100 steps.\n", - "Burn-in batch 2/10 completed, 100 steps.\n", - "Burn-in batch 3/10 completed, 100 steps.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Burn-in batch 4/10 completed, 100 steps.\n", - "Burn-in batch 5/10 completed, 100 steps.\n", - "Burn-in batch 6/10 completed, 100 steps.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Burn-in batch 7/10 completed, 100 steps.\n", - "Burn-in batch 8/10 completed, 100 steps.\n", - "Burn-in batch 9/10 completed, 100 steps.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Burn-in batch 10/10 completed, 100 steps.\n", - "Batch: 1/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.350\n", - " Likelihood parameter acceptance fractions: [0.8]\n", - "Batch: 2/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.320\n", - " Likelihood parameter acceptance fractions: [0.78]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 3/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.490\n", - " Likelihood parameter acceptance fractions: [0.86]\n", - "Batch: 4/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.260\n", - " Likelihood parameter acceptance fractions: [0.83]\n", - "Batch: 5/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.390\n", - " Likelihood parameter acceptance fractions: [0.82]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 6/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.280\n", - " Likelihood parameter acceptance fractions: [0.82]\n", - "Batch: 7/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.320\n", - " Likelihood parameter acceptance fractions: [0.81]\n", - "Batch: 8/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.460\n", - " Likelihood parameter acceptance fractions: [0.79]\n", - "Batch: 9/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.360\n", - " Likelihood parameter acceptance fractions: [0.81]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 10/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.490\n", - " Likelihood parameter acceptance fractions: [0.73]\n", - "Batch: 11/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.330\n", - " Likelihood parameter acceptance fractions: [0.85]\n", - "Batch: 12/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.450\n", - " Likelihood parameter acceptance fractions: [0.88]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 13/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.280\n", - " Likelihood parameter acceptance fractions: [0.91]\n", - "Batch: 14/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.300\n", - " Likelihood parameter acceptance fractions: [0.82]\n", - "Batch: 15/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.510\n", - " Likelihood parameter acceptance fractions: [0.79]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 16/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.390\n", - " Likelihood parameter acceptance fractions: [0.85]\n", - "Batch: 17/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.340\n", - " Likelihood parameter acceptance fractions: [0.86]\n", - "Batch: 18/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.310\n", - " Likelihood parameter acceptance fractions: [0.84]\n", - "Batch: 19/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.540\n", - " Likelihood parameter acceptance fractions: [0.89]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 20/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.400\n", - " Likelihood parameter acceptance fractions: [0.79]\n", - "Batch: 21/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.390\n", - " Likelihood parameter acceptance fractions: [0.79]\n", - "Batch: 22/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.420\n", - " Likelihood parameter acceptance fractions: [0.9]\n", - "Batch: 23/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.380\n", - " Likelihood parameter acceptance fractions: [0.82]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 24/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.350\n", - " Likelihood parameter acceptance fractions: [0.8]\n", - "Batch: 25/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.420\n", - " Likelihood parameter acceptance fractions: [0.78]\n", - "Batch: 26/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.380\n", - " Likelihood parameter acceptance fractions: [0.89]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 27/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.370\n", - " Likelihood parameter acceptance fractions: [0.82]\n", - "Batch: 28/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.330\n", - " Likelihood parameter acceptance fractions: [0.83]\n", - "Batch: 29/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.200\n", - " Likelihood parameter acceptance fractions: [0.86]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 30/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.320\n", - " Likelihood parameter acceptance fractions: [0.86]\n", - "Batch: 31/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.420\n", - " Likelihood parameter acceptance fractions: [0.85]\n", - "Batch: 32/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.220\n", - " Likelihood parameter acceptance fractions: [0.85]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 33/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.370\n", - " Likelihood parameter acceptance fractions: [0.85]\n", - "Batch: 34/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.280\n", - " Likelihood parameter acceptance fractions: [0.8]\n", - "Batch: 35/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.340\n", - " Likelihood parameter acceptance fractions: [0.8]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 36/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.310\n", - " Likelihood parameter acceptance fractions: [0.82]\n", - "Batch: 37/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.530\n", - " Likelihood parameter acceptance fractions: [0.83]\n", - "Batch: 38/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.220\n", - " Likelihood parameter acceptance fractions: [0.9]\n", - "Batch: 39/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.440\n", - " Likelihood parameter acceptance fractions: [0.76]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 40/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.410\n", - " Likelihood parameter acceptance fractions: [0.86]\n", - "Batch: 41/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.280\n", - " Likelihood parameter acceptance fractions: [0.88]\n", - "Batch: 42/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.360\n", - " Likelihood parameter acceptance fractions: [0.83]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 43/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.340\n", - " Likelihood parameter acceptance fractions: [0.81]\n", - "Batch: 44/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.330\n", - " Likelihood parameter acceptance fractions: [0.82]\n", - "Batch: 45/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.330\n", - " Likelihood parameter acceptance fractions: [0.83]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 46/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.420\n", - " Likelihood parameter acceptance fractions: [0.84]\n", - "Batch: 47/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.360\n", - " Likelihood parameter acceptance fractions: [0.84]\n", - "Batch: 48/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.290\n", - " Likelihood parameter acceptance fractions: [0.86]\n", - "Batch: 49/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.460\n", - " Likelihood parameter acceptance fractions: [0.86]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 50/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.310\n", - " Likelihood parameter acceptance fractions: [0.84]\n", - "Batch: 51/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.340\n", - " Likelihood parameter acceptance fractions: [0.79]\n", - "Batch: 52/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.300\n", - " Likelihood parameter acceptance fractions: [0.89]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 53/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.220\n", - " Likelihood parameter acceptance fractions: [0.83]\n", - "Batch: 54/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.250\n", - " Likelihood parameter acceptance fractions: [0.85]\n", - "Batch: 55/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.330\n", - " Likelihood parameter acceptance fractions: [0.74]\n", - "Batch: 56/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.660\n", - " Likelihood parameter acceptance fractions: [0.82]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 57/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.390\n", - " Likelihood parameter acceptance fractions: [0.85]\n", - "Batch: 58/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.440\n", - " Likelihood parameter acceptance fractions: [0.85]\n", - "Batch: 59/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.410\n", - " Likelihood parameter acceptance fractions: [0.87]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 60/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.250\n", - " Likelihood parameter acceptance fractions: [0.84]\n", - "Batch: 61/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.280\n", - " Likelihood parameter acceptance fractions: [0.85]\n", - "Batch: 62/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.270\n", - " Likelihood parameter acceptance fractions: [0.84]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 63/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.490\n", - " Likelihood parameter acceptance fractions: [0.84]\n", - "Batch: 64/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.470\n", - " Likelihood parameter acceptance fractions: [0.82]\n", - "Batch: 65/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.310\n", - " Likelihood parameter acceptance fractions: [0.78]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 66/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.300\n", - " Likelihood parameter acceptance fractions: [0.72]\n", - "Batch: 67/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.320\n", - " Likelihood parameter acceptance fractions: [0.81]\n", - "Batch: 68/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.250\n", - " Likelihood parameter acceptance fractions: [0.85]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 69/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.300\n", - " Likelihood parameter acceptance fractions: [0.8]\n", - "Batch: 70/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.270\n", - " Likelihood parameter acceptance fractions: [0.78]\n", - "Batch: 71/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.230\n", - " Likelihood parameter acceptance fractions: [0.75]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 72/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.450\n", - " Likelihood parameter acceptance fractions: [0.79]\n", - "Batch: 73/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.370\n", - " Likelihood parameter acceptance fractions: [0.79]\n", - "Batch: 74/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.340\n", - " Likelihood parameter acceptance fractions: [0.92]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 75/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.220\n", - " Likelihood parameter acceptance fractions: [0.83]\n", - "Batch: 76/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.280\n", - " Likelihood parameter acceptance fractions: [0.86]\n", - "Batch: 77/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.390\n", - " Likelihood parameter acceptance fractions: [0.83]\n", - "Batch: 78/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.240\n", - " Likelihood parameter acceptance fractions: [0.8]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 79/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.290\n", - " Likelihood parameter acceptance fractions: [0.82]\n", - "Batch: 80/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.350\n", - " Likelihood parameter acceptance fractions: [0.77]\n", - "Batch: 81/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.370\n", - " Likelihood parameter acceptance fractions: [0.84]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 82/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.390\n", - " Likelihood parameter acceptance fractions: [0.82]\n", - "Batch: 83/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.310\n", - " Likelihood parameter acceptance fractions: [0.86]\n", - "Batch: 84/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.340\n", - " Likelihood parameter acceptance fractions: [0.83]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 85/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.360\n", - " Likelihood parameter acceptance fractions: [0.81]\n", - "Batch: 86/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.400\n", - " Likelihood parameter acceptance fractions: [0.84]\n", - "Batch: 87/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.350\n", - " Likelihood parameter acceptance fractions: [0.81]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 88/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.370\n", - " Likelihood parameter acceptance fractions: [0.82]\n", - "Batch: 89/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.530\n", - " Likelihood parameter acceptance fractions: [0.84]\n", - "Batch: 90/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.520\n", - " Likelihood parameter acceptance fractions: [0.79]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 91/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.320\n", - " Likelihood parameter acceptance fractions: [0.82]\n", - "Batch: 92/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.360\n", - " Likelihood parameter acceptance fractions: [0.81]\n", - "Batch: 93/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.500\n", - " Likelihood parameter acceptance fractions: [0.81]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 94/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.280\n", - " Likelihood parameter acceptance fractions: [0.89]\n", - "Batch: 95/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.380\n", - " Likelihood parameter acceptance fractions: [0.83]\n", - "Batch: 96/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.310\n", - " Likelihood parameter acceptance fractions: [0.8]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 97/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.290\n", - " Likelihood parameter acceptance fractions: [0.77]\n", - "Batch: 98/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.330\n", - " Likelihood parameter acceptance fractions: [0.88]\n", - "Batch: 99/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.260\n", - " Likelihood parameter acceptance fractions: [0.81]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 100/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.390\n", - " Likelihood parameter acceptance fractions: [0.89]\n", - "CPU times: user 8.51 s, sys: 70.6 ms, total: 8.58 s\n", - "Wall time: 8.49 s\n" - ] - } - ], - "source": [ - "%%time\n", - "walker2.walk(\n", - " n_steps=10000,\n", - " burnin=1000,\n", - " batch_size=100,\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "id": "1a119f59-97fb-4791-9a18-3936d8083509", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:09:14.495247Z", - "iopub.status.busy": "2026-08-11T03:09:14.495087Z", - "iopub.status.idle": "2026-08-11T03:09:14.500168Z", - "shell.execute_reply": "2026-08-11T03:09:14.499467Z" - } - }, - "outputs": [], - "source": [ - "def plot_chains_with_err(walker, model, true_params):\n", - " fig, axes = plt.subplots(\n", - " walker.model_sampler.chain.shape[1] + 3, 1, figsize=(8, 8), sharex=True\n", - " )\n", - " for i in range(walker.model_sampler.chain.shape[1]):\n", - " axes[i].plot(walker.model_sampler.chain[:, i])\n", - " axes[i].set_ylabel(f\"${model.params[i].latex_name}$ [{model.params[i].unit}]\")\n", - " true_value = true_params[model.params[i].name]\n", - " axes[i].hlines(\n", - " true_value, 0, len(walker.model_sampler.chain), \"r\", linestyle=\"--\"\n", - " )\n", - "\n", - " axes[-3].plot(walker.model_sampler.logp_chain)\n", - " axes[-3].set_ylabel(r\"$\\log{\\mathcal{L}(\\alpha_i | \\mathcal{O})}$\")\n", - "\n", - " lmp = walker.likelihood_samplers[0].params[0]\n", - " axes[-2].plot(walker.likelihood_samplers[0].chain)\n", - " axes[-2].set_ylabel(f\"${lmp.latex_name}$ [{lmp.unit}]\")\n", - " axes[-2].hlines(\n", - " np.log(noise_fraction),\n", - " 0,\n", - " len(walker.likelihood_samplers[0].chain),\n", - " \"r\",\n", - " linestyle=\"--\",\n", - " )\n", - "\n", - " axes[-1].plot(walker.likelihood_samplers[0].logp_chain)\n", - " axes[-1].set_ylabel(r\"$\\log{\\mathcal{L}(\\alpha_i | \\mathcal{O})}$\")\n", - "\n", - " axes[-1].set_xlabel(r\"$i$\")\n", - " # plt.legend(title=\"chains\", ncol=3,)" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "id": "9f73ec88-faa9-4c74-b677-61706a3f1223", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:09:14.501674Z", - "iopub.status.busy": "2026-08-11T03:09:14.501524Z", - "iopub.status.idle": "2026-08-11T03:09:14.971962Z", - "shell.execute_reply": "2026-08-11T03:09:14.971410Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_chains_with_err(walker2, my_model, true_params)" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "id": "5d0920bf-a6cf-4fbd-a9d4-dcc213b655e3", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:09:14.973831Z", - "iopub.status.busy": "2026-08-11T03:09:14.973674Z", - "iopub.status.idle": "2026-08-11T03:09:15.362339Z", - "shell.execute_reply": "2026-08-11T03:09:15.361416Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 0.98, 'posterior')" - ] - }, - "execution_count": 28, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig = corner.corner(\n", - " np.hstack([walker2.model_sampler.chain, walker2.likelihood_samplers[0].chain]),\n", - " labels=[p.name for p in my_model.params]\n", - " + [walker2.likelihood_samplers[0].params[0].name],\n", - " label=\"posterior\",\n", - " truths=[true_params[\"m\"], true_params[\"b\"], np.log(noise_fraction)],\n", - ")\n", - "fig.suptitle(\"posterior\")" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "id": "ccee96fa-f877-4cfe-a0bc-d250ca9066b0", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:09:15.364059Z", - "iopub.status.busy": "2026-08-11T03:09:15.363888Z", - "iopub.status.idle": "2026-08-11T03:09:15.586546Z", - "shell.execute_reply": "2026-08-11T03:09:15.585806Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 1.0, 'option 2: unknown statistical error, systematic ignored')" - ] - }, - "execution_count": 29, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_predictive_post(\n", - " walker=walker2, model=my_model, x=x, y_exp=y_exp, y_err=y_stat_err, y_true=y_true\n", - ")\n", - "plt.title(\"option 2: unknown statistical error, systematic ignored\")" - ] - }, - { - "cell_type": "markdown", - "id": "c9732c59", - "metadata": {}, - "source": [ - "## Run option 2b: unknown *constant* noise\n", - "\n", - "Option 2 inferred a **fractional** noise\n", - "($\\Sigma_{ij} = \\delta_{ij}\\,\\epsilon^2 y_m(x_j;\\alpha)^2$, via\n", - "`noise_fraction_term`). Its sibling `noise_term` infers a **constant** noise\n", - "floor,\n", - "\\begin{equation}\n", - "\\Sigma_{ij} = \\delta_{ij}\\, \\epsilon_0^2 .\n", - "\\end{equation}\n", - "Both are *additive* on top of any reported statistical diagonal — so to let the\n", - "inferred noise **replace** the reported statistics, build the `Observation`\n", - "without `y_stat_err` (as `obs_unknown_stat` is built), or pass\n", - "`include_statistical_term=False` to the `Constraint`.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "id": "061e55aa", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:09:15.588203Z", - "iopub.status.busy": "2026-08-11T03:09:15.588033Z", - "iopub.status.idle": "2026-08-11T03:09:15.591783Z", - "shell.execute_reply": "2026-08-11T03:09:15.591325Z" - } - }, - "outputs": [], - "source": [ - "log_noise = rxmc.params.Parameter(\n", - " \"log noise\", float, latex_name=r\"\\log{\\epsilon_0}\", unit=\"dimensionless\"\n", - ")\n", - "evidence_unknown_const = rxmc.evidence.Evidence(\n", - " [\n", - " rxmc.constraint.Constraint(\n", - " [obs_unknown_stat],\n", - " my_model,\n", - " extra_terms=[rxmc.covariance.noise_term(log_noise)],\n", - " )\n", - " ]\n", - ")\n", - "# the true absolute noise scale is noise_fraction * y; center the prior there\n", - "const_noise_prior = stats.norm(loc=np.log(noise_fraction * np.mean(y_exp)), scale=1)" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "id": "dc755e2d", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:09:15.593503Z", - "iopub.status.busy": "2026-08-11T03:09:15.593357Z", - "iopub.status.idle": "2026-08-11T03:09:15.596519Z", - "shell.execute_reply": "2026-08-11T03:09:15.595886Z" - } - }, - "outputs": [], - "source": [ - "walker2b = rxmc.walker.Walker(\n", - " model_sampler=rxmc.param_sampling.MetropolisHastingsSampler(\n", - " params=my_model.params,\n", - " starting_location=prior_distribution.mean,\n", - " proposal=proposal_distribution_model,\n", - " prior=prior_distribution,\n", - " ),\n", - " evidence=evidence_unknown_const,\n", - " likelihood_samplers=[\n", - " rxmc.param_sampling.MetropolisHastingsSampler(\n", - " params=[log_noise],\n", - " starting_location=const_noise_prior.mean(),\n", - " proposal=proposal_distribution_noise,\n", - " prior=const_noise_prior,\n", - " )\n", - " ],\n", - " rng=rng,\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "id": "8c5b3773", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:09:15.597976Z", - "iopub.status.busy": "2026-08-11T03:09:15.597818Z", - "iopub.status.idle": "2026-08-11T03:09:23.667111Z", - "shell.execute_reply": "2026-08-11T03:09:23.666489Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Burn-in batch 1/10 completed, 100 steps.\n", - "Burn-in batch 2/10 completed, 100 steps.\n", - "Burn-in batch 3/10 completed, 100 steps.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Burn-in batch 4/10 completed, 100 steps.\n", - "Burn-in batch 5/10 completed, 100 steps.\n", - "Burn-in batch 6/10 completed, 100 steps.\n", - "Burn-in batch 7/10 completed, 100 steps.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Burn-in batch 8/10 completed, 100 steps.\n", - "Burn-in batch 9/10 completed, 100 steps.\n", - "Burn-in batch 10/10 completed, 100 steps.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 1/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.300\n", - " Likelihood parameter acceptance fractions: [0.72]\n", - "Batch: 2/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.490\n", - " Likelihood parameter acceptance fractions: [0.86]\n", - "Batch: 3/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.240\n", - " Likelihood parameter acceptance fractions: [0.83]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 4/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.240\n", - " Likelihood parameter acceptance fractions: [0.87]\n", - "Batch: 5/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.400\n", - " Likelihood parameter acceptance fractions: [0.87]\n", - "Batch: 6/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.320\n", - " Likelihood parameter acceptance fractions: [0.85]\n", - "Batch: 7/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.350\n", - " Likelihood parameter acceptance fractions: [0.84]\n", - "Batch: 8/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.280\n", - " Likelihood parameter acceptance fractions: [0.79]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 9/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.440\n", - " Likelihood parameter acceptance fractions: [0.89]\n", - "Batch: 10/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.350\n", - " Likelihood parameter acceptance fractions: [0.82]\n", - "Batch: 11/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.260\n", - " Likelihood parameter acceptance fractions: [0.85]\n", - "Batch: 12/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.230\n", - " Likelihood parameter acceptance fractions: [0.86]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 13/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.400\n", - " Likelihood parameter acceptance fractions: [0.83]\n", - "Batch: 14/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.530\n", - " Likelihood parameter acceptance fractions: [0.77]\n", - "Batch: 15/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.240\n", - " Likelihood parameter acceptance fractions: [0.84]\n", - "Batch: 16/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.490\n", - " Likelihood parameter acceptance fractions: [0.81]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 17/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.290\n", - " Likelihood parameter acceptance fractions: [0.83]\n", - "Batch: 18/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.410\n", - " Likelihood parameter acceptance fractions: [0.84]\n", - "Batch: 19/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.300\n", - " Likelihood parameter acceptance fractions: [0.82]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 20/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.330\n", - " Likelihood parameter acceptance fractions: [0.83]\n", - "Batch: 21/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.340\n", - " Likelihood parameter acceptance fractions: [0.85]\n", - "Batch: 22/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.460\n", - " Likelihood parameter acceptance fractions: [0.88]\n", - "Batch: 23/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.330\n", - " Likelihood parameter acceptance fractions: [0.86]\n", - "Batch: 24/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.490\n", - " Likelihood parameter acceptance fractions: [0.84]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 25/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.250\n", - " Likelihood parameter acceptance fractions: [0.77]\n", - "Batch: 26/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.390\n", - " Likelihood parameter acceptance fractions: [0.85]\n", - "Batch: 27/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.380\n", - " Likelihood parameter acceptance fractions: [0.89]\n", - "Batch: 28/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.280\n", - " Likelihood parameter acceptance fractions: [0.83]\n", - "Batch: 29/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.370\n", - " Likelihood parameter acceptance fractions: [0.85]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 30/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.480\n", - " Likelihood parameter acceptance fractions: [0.85]\n", - "Batch: 31/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.480\n", - " Likelihood parameter acceptance fractions: [0.81]\n", - "Batch: 32/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.340\n", - " Likelihood parameter acceptance fractions: [0.85]\n", - "Batch: 33/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.350\n", - " Likelihood parameter acceptance fractions: [0.87]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 34/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.280\n", - " Likelihood parameter acceptance fractions: [0.81]\n", - "Batch: 35/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.300\n", - " Likelihood parameter acceptance fractions: [0.86]\n", - "Batch: 36/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.290\n", - " Likelihood parameter acceptance fractions: [0.87]\n", - "Batch: 37/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.330\n", - " Likelihood parameter acceptance fractions: [0.81]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 38/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.380\n", - " Likelihood parameter acceptance fractions: [0.79]\n", - "Batch: 39/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.240\n", - " Likelihood parameter acceptance fractions: [0.79]\n", - "Batch: 40/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.350\n", - " Likelihood parameter acceptance fractions: [0.86]\n", - "Batch: 41/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.470\n", - " Likelihood parameter acceptance fractions: [0.88]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 42/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.350\n", - " Likelihood parameter acceptance fractions: [0.79]\n", - "Batch: 43/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.520\n", - " Likelihood parameter acceptance fractions: [0.81]\n", - "Batch: 44/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.400\n", - " Likelihood parameter acceptance fractions: [0.84]\n", - "Batch: 45/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.410\n", - " Likelihood parameter acceptance fractions: [0.81]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 46/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.320\n", - " Likelihood parameter acceptance fractions: [0.79]\n", - "Batch: 47/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.420\n", - " Likelihood parameter acceptance fractions: [0.79]\n", - "Batch: 48/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.480\n", - " Likelihood parameter acceptance fractions: [0.74]\n", - "Batch: 49/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.390\n", - " Likelihood parameter acceptance fractions: [0.86]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 50/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.280\n", - " Likelihood parameter acceptance fractions: [0.87]\n", - "Batch: 51/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.430\n", - " Likelihood parameter acceptance fractions: [0.78]\n", - "Batch: 52/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.410\n", - " Likelihood parameter acceptance fractions: [0.91]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 53/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.340\n", - " Likelihood parameter acceptance fractions: [0.91]\n", - "Batch: 54/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.370\n", - " Likelihood parameter acceptance fractions: [0.9]\n", - "Batch: 55/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.360\n", - " Likelihood parameter acceptance fractions: [0.81]\n", - "Batch: 56/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.280\n", - " Likelihood parameter acceptance fractions: [0.85]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 57/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.450\n", - " Likelihood parameter acceptance fractions: [0.79]\n", - "Batch: 58/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.280\n", - " Likelihood parameter acceptance fractions: [0.79]\n", - "Batch: 59/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.460\n", - " Likelihood parameter acceptance fractions: [0.82]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 60/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.400\n", - " Likelihood parameter acceptance fractions: [0.79]\n", - "Batch: 61/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.370\n", - " Likelihood parameter acceptance fractions: [0.81]\n", - "Batch: 62/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.280\n", - " Likelihood parameter acceptance fractions: [0.8]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 63/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.310\n", - " Likelihood parameter acceptance fractions: [0.82]\n", - "Batch: 64/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.280\n", - " Likelihood parameter acceptance fractions: [0.84]\n", - "Batch: 65/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.300\n", - " Likelihood parameter acceptance fractions: [0.89]\n", - "Batch: 66/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.380\n", - " Likelihood parameter acceptance fractions: [0.89]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 67/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.500\n", - " Likelihood parameter acceptance fractions: [0.84]\n", - "Batch: 68/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.240\n", - " Likelihood parameter acceptance fractions: [0.76]\n", - "Batch: 69/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.410\n", - " Likelihood parameter acceptance fractions: [0.84]\n", - "Batch: 70/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.380\n", - " Likelihood parameter acceptance fractions: [0.85]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 71/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.360\n", - " Likelihood parameter acceptance fractions: [0.79]\n", - "Batch: 72/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.480\n", - " Likelihood parameter acceptance fractions: [0.9]\n", - "Batch: 73/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.450\n", - " Likelihood parameter acceptance fractions: [0.85]\n", - "Batch: 74/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.340\n", - " Likelihood parameter acceptance fractions: [0.88]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 75/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.340\n", - " Likelihood parameter acceptance fractions: [0.91]\n", - "Batch: 76/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.320\n", - " Likelihood parameter acceptance fractions: [0.89]\n", - "Batch: 77/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.210\n", - " Likelihood parameter acceptance fractions: [0.87]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 78/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.570\n", - " Likelihood parameter acceptance fractions: [0.85]\n", - "Batch: 79/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.290\n", - " Likelihood parameter acceptance fractions: [0.78]\n", - "Batch: 80/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.400\n", - " Likelihood parameter acceptance fractions: [0.81]\n", - "Batch: 81/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.180\n", - " Likelihood parameter acceptance fractions: [0.79]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 82/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.390\n", - " Likelihood parameter acceptance fractions: [0.89]\n", - "Batch: 83/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.270\n", - " Likelihood parameter acceptance fractions: [0.83]\n", - "Batch: 84/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.250\n", - " Likelihood parameter acceptance fractions: [0.78]\n", - "Batch: 85/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.320\n", - " Likelihood parameter acceptance fractions: [0.82]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 86/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.300\n", - " Likelihood parameter acceptance fractions: [0.86]\n", - "Batch: 87/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.370\n", - " Likelihood parameter acceptance fractions: [0.87]\n", - "Batch: 88/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.320\n", - " Likelihood parameter acceptance fractions: [0.88]\n", - "Batch: 89/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.280\n", - " Likelihood parameter acceptance fractions: [0.77]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 90/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.230\n", - " Likelihood parameter acceptance fractions: [0.77]\n", - "Batch: 91/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.280\n", - " Likelihood parameter acceptance fractions: [0.77]\n", - "Batch: 92/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.370\n", - " Likelihood parameter acceptance fractions: [0.82]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 93/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.330\n", - " Likelihood parameter acceptance fractions: [0.85]\n", - "Batch: 94/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.300\n", - " Likelihood parameter acceptance fractions: [0.8]\n", - "Batch: 95/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.330\n", - " Likelihood parameter acceptance fractions: [0.85]\n", - "Batch: 96/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.390\n", - " Likelihood parameter acceptance fractions: [0.8]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 97/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.370\n", - " Likelihood parameter acceptance fractions: [0.83]\n", - "Batch: 98/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.450\n", - " Likelihood parameter acceptance fractions: [0.75]\n", - "Batch: 99/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.320\n", - " Likelihood parameter acceptance fractions: [0.79]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 100/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.280\n", - " Likelihood parameter acceptance fractions: [0.89]\n", - "CPU times: user 8.08 s, sys: 98.5 ms, total: 8.18 s\n", - "Wall time: 8.07 s\n" - ] - } - ], - "source": [ - "%%time\n", - "walker2b.walk(\n", - " n_steps=10000,\n", - " burnin=1000,\n", - " batch_size=100,\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "id": "0e27db1d", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:09:23.668685Z", - "iopub.status.busy": "2026-08-11T03:09:23.668540Z", - "iopub.status.idle": "2026-08-11T03:09:24.097945Z", - "shell.execute_reply": "2026-08-11T03:09:24.097205Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_chains(walker=walker2b, model=my_model, true_params=true_params)\n", - "plt.figure()\n", - "plt.plot(walker2b.likelihood_samplers[0].chain)\n", - "plt.axhline(np.log(noise_fraction * np.mean(y_exp)), color=\"r\", ls=\"--\")\n", - "plt.ylabel(r\"$\\log{\\epsilon_0}$\")\n", - "plt.xlabel(\"$i$\");" - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "id": "2280e6d8", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:09:24.099536Z", - "iopub.status.busy": "2026-08-11T03:09:24.099385Z", - "iopub.status.idle": "2026-08-11T03:09:24.302912Z", - "shell.execute_reply": "2026-08-11T03:09:24.302349Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 1.0, 'option 2b: unknown constant noise, systematic ignored')" - ] - }, - "execution_count": 34, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_predictive_post(\n", - " walker=walker2b, model=my_model, x=x, y_exp=y_exp, y_err=y_stat_err, y_true=y_true\n", - ")\n", - "plt.title(\"option 2b: unknown constant noise, systematic ignored\")" - ] - }, - { - "cell_type": "markdown", - "id": "52954ccf-9f53-47d2-aa58-d57ac5cd2394", - "metadata": {}, - "source": [ - "## Run option 3: correct formulation of the systematic error" - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "id": "a0642bf9-b6a0-4830-b5b1-ac1994c4e8c9", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:09:24.304694Z", - "iopub.status.busy": "2026-08-11T03:09:24.304543Z", - "iopub.status.idle": "2026-08-11T03:09:24.307551Z", - "shell.execute_reply": "2026-08-11T03:09:24.306753Z" - } - }, - "outputs": [], - "source": [ - "walker3 = rxmc.walker.Walker(\n", - " model_sampler=rxmc.param_sampling.MetropolisHastingsSampler(\n", - " params=my_model.params,\n", - " starting_location=prior_distribution.mean,\n", - " proposal=proposal_distribution_model,\n", - " prior=prior_distribution,\n", - " ),\n", - " evidence=evidence_sys_correct,\n", - " rng=rng,\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "id": "1d51307d-67d8-4336-8e23-05fb441eb815", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:09:24.308991Z", - "iopub.status.busy": "2026-08-11T03:09:24.308869Z", - "iopub.status.idle": "2026-08-11T03:09:28.560186Z", - "shell.execute_reply": "2026-08-11T03:09:28.559514Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Burn-in batch 1/1 completed, 1000 steps.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 1/1 completed, 10000 steps. \n", - " Model parameter acceptance fraction: 0.752\n", - "CPU times: user 4.25 s, sys: 7.86 ms, total: 4.25 s\n", - "Wall time: 4.25 s\n" - ] - } - ], - "source": [ - "%%time\n", - "walker3.walk(n_steps=10000, burnin=1000)" - ] - }, - { - "cell_type": "code", - "execution_count": 37, - "id": "dcc445eb-6592-4973-8943-9fe17110ee57", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:09:28.561691Z", - "iopub.status.busy": "2026-08-11T03:09:28.561553Z", - "iopub.status.idle": "2026-08-11T03:09:28.851942Z", - "shell.execute_reply": "2026-08-11T03:09:28.851222Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_chains(walker=walker3, model=my_model, true_params=true_params)" - ] - }, - { - "cell_type": "code", - "execution_count": 38, - "id": "8aed8b4b-50f2-4752-a61c-7fab12e179c5", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:09:28.853382Z", - "iopub.status.busy": "2026-08-11T03:09:28.853241Z", - "iopub.status.idle": "2026-08-11T03:09:29.011651Z", - "shell.execute_reply": "2026-08-11T03:09:29.010961Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_posterior_corner(walker=walker3, true_params=true_params)" - ] - }, - { - "cell_type": "code", - "execution_count": 39, - "id": "30e58a3f-a243-4ce9-bc27-b0336f1c596b", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:09:29.013063Z", - "iopub.status.busy": "2026-08-11T03:09:29.012906Z", - "iopub.status.idle": "2026-08-11T03:09:29.220335Z", - "shell.execute_reply": "2026-08-11T03:09:29.219575Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 1.0, 'option 3: systematic included correctly')" - ] - }, - "execution_count": 39, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_predictive_post(\n", - " walker=walker3, model=my_model, x=x, y_exp=y_exp, y_err=y_stat_err, y_true=y_true\n", - ")\n", - "plt.title(\"option 3: systematic included correctly\")" - ] - }, - { - "cell_type": "markdown", - "id": "b367eb21-44ab-4146-bbf6-8ad8d0806f67", - "metadata": {}, - "source": [ - "## Run option 4: incorrect formulation of the systematic error" - ] - }, - { - "cell_type": "code", - "execution_count": 40, - "id": "d731b920-451d-4884-aa1a-9fbdb6db2361", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:09:29.221844Z", - "iopub.status.busy": "2026-08-11T03:09:29.221671Z", - "iopub.status.idle": "2026-08-11T03:09:29.224360Z", - "shell.execute_reply": "2026-08-11T03:09:29.223751Z" - } - }, - "outputs": [], - "source": [ - "walker4 = rxmc.walker.Walker(\n", - " model_sampler=rxmc.param_sampling.MetropolisHastingsSampler(\n", - " params=my_model.params,\n", - " starting_location=prior_distribution.mean,\n", - " proposal=proposal_distribution_model,\n", - " prior=prior_distribution,\n", - " ),\n", - " evidence=evidence_sys_wrong,\n", - " rng=rng,\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 41, - "id": "cc8396c2-f7de-4047-92ff-a7e4e30c782d", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:09:29.225791Z", - "iopub.status.busy": "2026-08-11T03:09:29.225632Z", - "iopub.status.idle": "2026-08-11T03:09:32.595207Z", - "shell.execute_reply": "2026-08-11T03:09:32.594603Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Burn-in batch 1/1 completed, 1000 steps.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 1/1 completed, 10000 steps. \n", - " Model parameter acceptance fraction: 0.735\n", - "CPU times: user 3.37 s, sys: 40.1 ms, total: 3.41 s\n", - "Wall time: 3.37 s\n" - ] - } - ], - "source": [ - "%%time\n", - "walker4.walk(n_steps=10000, burnin=1000)" - ] - }, - { - "cell_type": "code", - "execution_count": 42, - "id": "6b19450a-7289-4441-ac48-89ebaa03575c", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:09:32.596660Z", - "iopub.status.busy": "2026-08-11T03:09:32.596527Z", - "iopub.status.idle": "2026-08-11T03:09:32.881801Z", - "shell.execute_reply": "2026-08-11T03:09:32.881124Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_chains(walker=walker4, model=my_model, true_params=true_params)" - ] - }, - { - "cell_type": "code", - "execution_count": 43, - "id": "fce5ffbc-b15c-4fc8-89ab-0d4a5e92dcc3", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:09:32.883231Z", - "iopub.status.busy": "2026-08-11T03:09:32.883080Z", - "iopub.status.idle": "2026-08-11T03:09:33.130689Z", - "shell.execute_reply": "2026-08-11T03:09:33.130095Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_posterior_corner(walker=walker4, true_params=true_params)" - ] - }, - { - "cell_type": "code", - "execution_count": 44, - "id": "647aa074-8511-4a2c-843f-4c11424938e1", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:09:33.132085Z", - "iopub.status.busy": "2026-08-11T03:09:33.131944Z", - "iopub.status.idle": "2026-08-11T03:09:33.339384Z", - "shell.execute_reply": "2026-08-11T03:09:33.338730Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 1.0, 'option 4: systematic included incorrectly')" - ] - }, - "execution_count": 44, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_predictive_post(\n", - " walker=walker4, model=my_model, x=x, y_exp=y_exp, y_err=y_stat_err, y_true=y_true\n", - ")\n", - "plt.title(\"option 4: systematic included incorrectly\")" - ] - }, - { - "cell_type": "markdown", - "id": "09070172", - "metadata": {}, - "source": [ - "## Run option 5: an additive offset systematic\n", - "\n", - "A different systematic: the whole dataset is shifted by one unknown **additive\n", - "offset** (think background mis-subtraction), rather than rescaled. The reported\n", - "offset uncertainty $\\omega$ enters as a rank-one mode with a constant basis,\n", - "\\begin{equation}\n", - "\\Sigma_{ij} = \\delta_{ij}\\,\\sigma_{stat,i}^2 + \\omega^2 ,\n", - "\\end{equation}\n", - "via `offset_term(magnitude=...)`. With `parameter=` instead of\n", - "`magnitude=`, the magnitude becomes a free nuisance ($\\omega = e^{\\theta}$),\n", - "exactly parallel to options 2 and 2b. As with the normalization bias above, we\n", - "shift the data by one standard deviation of the reported offset error, and\n", - "compare accounting for it against ignoring it.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 45, - "id": "aa75c73f", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:09:33.340864Z", - "iopub.status.busy": "2026-08-11T03:09:33.340718Z", - "iopub.status.idle": "2026-08-11T03:09:33.345858Z", - "shell.execute_reply": "2026-08-11T03:09:33.345285Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "free-offset constraint has 1 nuisance parameter(s)\n" - ] - } - ], - "source": [ - "offset_syst_err = 0.3\n", - "# one common additive shift, chosen 1 std deviation of the offset error above 0\n", - "delta = offset_syst_err\n", - "y_exp_off = y_true + rng.normal(scale=noise_fraction * y_true, size=len(x)) + delta\n", - "y_stat_err_off = noise_fraction * y_exp_off\n", - "\n", - "obs_offset = rxmc.observation.Observation(x=x, y=y_exp_off, y_stat_err=y_stat_err_off)\n", - "obs_offset_ignored = rxmc.observation.Observation(\n", - " x=x, y=y_exp_off, y_stat_err=y_stat_err_off\n", - ")\n", - "\n", - "evidence_offset = rxmc.evidence.Evidence(\n", - " [\n", - " rxmc.constraint.Constraint(\n", - " [obs_offset],\n", - " my_model,\n", - " extra_terms=[rxmc.covariance.offset_term(magnitude=offset_syst_err)],\n", - " )\n", - " ]\n", - ")\n", - "evidence_offset_ignored = rxmc.evidence.Evidence(\n", - " [rxmc.constraint.Constraint([obs_offset_ignored], my_model, likelihood)]\n", - ")\n", - "\n", - "# the free-nuisance spelling of the same mode (constructed, not fit here)\n", - "log_omega = rxmc.params.Parameter(\"log omega\", float, latex_name=r\"\\log{\\omega}\")\n", - "free_offset = rxmc.constraint.Constraint(\n", - " [rxmc.observation.Observation(x=x, y=y_exp_off, y_stat_err=y_stat_err_off)],\n", - " my_model,\n", - " extra_terms=[rxmc.covariance.offset_term(parameter=log_omega)],\n", - ")\n", - "print(f\"free-offset constraint has {free_offset.n_params} nuisance parameter(s)\")" - ] - }, - { - "cell_type": "code", - "execution_count": 46, - "id": "fd5dc9b2", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:09:33.347138Z", - "iopub.status.busy": "2026-08-11T03:09:33.347009Z", - "iopub.status.idle": "2026-08-11T03:09:40.111772Z", - "shell.execute_reply": "2026-08-11T03:09:40.111052Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Burn-in batch 1/10 completed, 100 steps.\n", - "Burn-in batch 2/10 completed, 100 steps.\n", - "Burn-in batch 3/10 completed, 100 steps.\n", - "Burn-in batch 4/10 completed, 100 steps.\n", - "Burn-in batch 5/10 completed, 100 steps.\n", - "Burn-in batch 6/10 completed, 100 steps.\n", - "Burn-in batch 7/10 completed, 100 steps.\n", - "Burn-in batch 8/10 completed, 100 steps.\n", - "Burn-in batch 9/10 completed, 100 steps.\n", - "Burn-in batch 10/10 completed, 100 steps.\n", - "Batch: 1/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.820\n", - "Batch: 2/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.760\n", - "Batch: 3/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.740\n", - "Batch: 4/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.830\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 5/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.810\n", - "Batch: 6/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.780\n", - "Batch: 7/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.820\n", - "Batch: 8/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.720\n", - "Batch: 9/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.830\n", - "Batch: 10/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.830\n", - "Batch: 11/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.800\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 12/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.810\n", - "Batch: 13/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.730\n", - "Batch: 14/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.790\n", - "Batch: 15/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.760\n", - "Batch: 16/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.830\n", - "Batch: 17/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.840\n", - "Batch: 18/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.800\n", - "Batch: 19/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.800\n", - "Batch: 20/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.690\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 21/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.810\n", - "Batch: 22/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.880\n", - "Batch: 23/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.830\n", - "Batch: 24/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.740\n", - "Batch: 25/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.780\n", - "Batch: 26/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.860\n", - "Batch: 27/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.770\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 28/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.760\n", - "Batch: 29/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.810\n", - "Batch: 30/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.810\n", - "Batch: 31/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.840\n", - "Batch: 32/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.840\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 33/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.860\n", - "Batch: 34/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.800\n", - "Batch: 35/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.790\n", - "Batch: 36/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.780\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 37/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.820\n", - "Batch: 38/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.770\n", - "Batch: 39/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.740\n", - "Batch: 40/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.730\n", - "Batch: 41/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.780\n", - "Batch: 42/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.780\n", - "Batch: 43/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.740\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 44/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.800\n", - "Batch: 45/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.840\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 46/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.740\n", - "Batch: 47/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.830\n", - "Batch: 48/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.780\n", - "Batch: 49/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.780\n", - "Batch: 50/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.810\n", - "Batch: 51/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.710\n", - "Batch: 52/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.840\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 53/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.830\n", - "Batch: 54/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.730\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 55/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.730\n", - "Batch: 56/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.740\n", - "Batch: 57/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.860\n", - "Batch: 58/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.830\n", - "Batch: 59/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.810\n", - "Batch: 60/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.840\n", - "Batch: 61/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.840\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 62/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.820\n", - "Batch: 63/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.790\n", - "Batch: 64/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.780\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 65/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.850\n", - "Batch: 66/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.800\n", - "Batch: 67/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.760\n", - "Batch: 68/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.840\n", - "Batch: 69/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.800\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 70/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.720\n", - "Batch: 71/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.770\n", - "Batch: 72/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.780\n", - "Batch: 73/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.810\n", - "Batch: 74/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.780\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 75/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.730\n", - "Batch: 76/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.820\n", - "Batch: 77/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.740\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 78/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.810\n", - "Batch: 79/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.740\n", - "Batch: 80/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.880\n", - "Batch: 81/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.710\n", - "Batch: 82/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.850\n", - "Batch: 83/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.810\n", - "Batch: 84/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.840\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 85/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.740\n", - "Batch: 86/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.790\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 87/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.860\n", - "Batch: 88/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.800\n", - "Batch: 89/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.760\n", - "Batch: 90/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.790\n", - "Batch: 91/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.750\n", - "Batch: 92/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.840\n", - "Batch: 93/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.780\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 94/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.820\n", - "Batch: 95/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.820\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 96/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.870\n", - "Batch: 97/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.820\n", - "Batch: 98/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.750\n", - "Batch: 99/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.770\n", - "Batch: 100/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.800\n", - "Burn-in batch 1/10 completed, 100 steps.\n", - "Burn-in batch 2/10 completed, 100 steps.\n", - "Burn-in batch 3/10 completed, 100 steps.\n", - "Burn-in batch 4/10 completed, 100 steps.\n", - "Burn-in batch 5/10 completed, 100 steps.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Burn-in batch 6/10 completed, 100 steps." - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Burn-in batch 7/10 completed, 100 steps.\n", - "Burn-in batch 8/10 completed, 100 steps.\n", - "Burn-in batch 9/10 completed, 100 steps.\n", - "Burn-in batch 10/10 completed, 100 steps.\n", - "Batch: 1/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.480\n", - "Batch: 2/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.350\n", - "Batch: 3/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.430\n", - "Batch: 4/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.400\n", - "Batch: 5/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.460\n", - "Batch: 6/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.440\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 7/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.470\n", - "Batch: 8/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.410\n", - "Batch: 9/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.330\n", - "Batch: 10/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.360\n", - "Batch: 11/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.460\n", - "Batch: 12/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.480\n", - "Batch: 13/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.500\n", - "Batch: 14/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.430\n", - "Batch: 15/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.430\n", - "Batch: 16/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.390\n", - "Batch: 17/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.540\n", - "Batch: 18/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.480\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 19/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.420\n", - "Batch: 20/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.420\n", - "Batch: 21/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.430\n", - "Batch: 22/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.450\n", - "Batch: 23/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.430\n", - "Batch: 24/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.410\n", - "Batch: 25/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.420\n", - "Batch: 26/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.430\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 27/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.440\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 28/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.420\n", - "Batch: 29/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.480\n", - "Batch: 30/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.470\n", - "Batch: 31/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.500\n", - "Batch: 32/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.480\n", - "Batch: 33/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.390\n", - "Batch: 34/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.410\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 35/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.510\n", - "Batch: 36/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.430\n", - "Batch: 37/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.490\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 38/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.460\n", - "Batch: 39/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.480\n", - "Batch: 40/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.430\n", - "Batch: 41/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.390\n", - "Batch: 42/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.520\n", - "Batch: 43/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.340\n", - "Batch: 44/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.460\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 45/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.490\n", - "Batch: 46/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.450\n", - "Batch: 47/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.540\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 48/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.400\n", - "Batch: 49/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.330\n", - "Batch: 50/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.500\n", - "Batch: 51/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.390\n", - "Batch: 52/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.450\n", - "Batch: 53/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.460\n", - "Batch: 54/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.440\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 55/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.380\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 56/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.470\n", - "Batch: 57/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.480\n", - "Batch: 58/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.470\n", - "Batch: 59/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.420\n", - "Batch: 60/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.480\n", - "Batch: 61/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.410\n", - "Batch: 62/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.430\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 63/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.400\n", - "Batch: 64/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.480\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 65/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.420\n", - "Batch: 66/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.460\n", - "Batch: 67/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.430\n", - "Batch: 68/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.400\n", - "Batch: 69/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.520\n", - "Batch: 70/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.410\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 71/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.420\n", - "Batch: 72/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.520\n", - "Batch: 73/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.500\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 74/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.370\n", - "Batch: 75/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.440\n", - "Batch: 76/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.430\n", - "Batch: 77/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.410\n", - "Batch: 78/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.490\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 79/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.360\n", - "Batch: 80/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.460\n", - "Batch: 81/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.410\n", - "Batch: 82/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.480\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 83/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.440\n", - "Batch: 84/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.420\n", - "Batch: 85/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.340\n", - "Batch: 86/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.450\n", - "Batch: 87/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.420\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 88/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.470\n", - "Batch: 89/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.400\n", - "Batch: 90/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.470\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 91/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.460\n", - "Batch: 92/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.340\n", - "Batch: 93/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.370\n", - "Batch: 94/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.390\n", - "Batch: 95/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.410\n", - "Batch: 96/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.430\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 97/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.410\n", - "Batch: 98/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.440\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 99/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.470\n", - "Batch: 100/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.400\n", - "CPU times: user 6.78 s, sys: 83.6 ms, total: 6.87 s\n", - "Wall time: 6.76 s\n" - ] - } - ], - "source": [ - "%%time\n", - "walker5 = rxmc.walker.Walker(\n", - " rxmc.param_sampling.MetropolisHastingsSampler(\n", - " params=my_model.params,\n", - " starting_location=prior_distribution.mean,\n", - " proposal=proposal_distribution_model,\n", - " prior=prior_distribution,\n", - " ),\n", - " evidence_offset,\n", - " rng=rng,\n", - ")\n", - "walker5i = rxmc.walker.Walker(\n", - " rxmc.param_sampling.MetropolisHastingsSampler(\n", - " params=my_model.params,\n", - " starting_location=prior_distribution.mean,\n", - " proposal=proposal_distribution_model,\n", - " prior=prior_distribution,\n", - " ),\n", - " evidence_offset_ignored,\n", - " rng=rng,\n", - ")\n", - "walker5.walk(n_steps=10000, burnin=1000, batch_size=100)\n", - "walker5i.walk(n_steps=10000, burnin=1000, batch_size=100)" - ] - }, - { - "cell_type": "code", - "execution_count": 47, - "id": "fe674eb4", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:09:40.113236Z", - "iopub.status.busy": "2026-08-11T03:09:40.113093Z", - "iopub.status.idle": "2026-08-11T03:09:40.317497Z", - "shell.execute_reply": "2026-08-11T03:09:40.316800Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "offset accounted m = 0.473 ± 0.108 b = 2.357 ± 0.299\n", - "offset ignored m = 0.472 ± 0.099 b = 2.332 ± 0.056\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "for name, w in [(\"offset accounted\", walker5), (\"offset ignored\", walker5i)]:\n", - " ch = w.model_sampler.chain\n", - " print(\n", - " f\"{name:18s} m = {ch[:, 0].mean():.3f} ± {ch[:, 0].std():.3f} \"\n", - " f\"b = {ch[:, 1].mean():.3f} ± {ch[:, 1].std():.3f}\"\n", - " )\n", - "\n", - "fig = corner.corner(\n", - " walker5.model_sampler.chain,\n", - " labels=[\"m\", \"b\"],\n", - " truths=[true_params[\"m\"], true_params[\"b\"]],\n", - " truth_color=\"k\",\n", - " color=\"tab:blue\",\n", - ")\n", - "corner.corner(walker5i.model_sampler.chain, fig=fig, color=\"tab:red\")\n", - "plt.plot([], [], color=\"tab:blue\", label=\"offset accounted\")\n", - "plt.plot([], [], color=\"tab:red\", label=\"offset ignored\")\n", - "fig.legend(loc=\"upper right\");" - ] - }, - { - "cell_type": "code", - "execution_count": 48, - "id": "771d2caf", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:09:40.318840Z", - "iopub.status.busy": "2026-08-11T03:09:40.318702Z", - "iopub.status.idle": "2026-08-11T03:09:40.539397Z", - "shell.execute_reply": "2026-08-11T03:09:40.538767Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 1.0, 'option 5: additive offset accounted via offset_term')" - ] - }, - "execution_count": 48, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_predictive_post(\n", - " walker=walker5,\n", - " model=my_model,\n", - " x=x,\n", - " y_exp=y_exp_off,\n", - " y_err=y_stat_err_off,\n", - " y_true=y_true,\n", - ")\n", - "plt.title(\"option 5: additive offset accounted via offset_term\")" - ] - }, - { - "cell_type": "markdown", - "id": "078dd172-bbc9-4a2a-8141-dca13b7cc1a0", - "metadata": {}, - "source": [ - "# Multiple constraints\n", - "Let's choose a second constraint, with the same normalization bias in the opposite direction and the same coverage over the $x$-domain." - ] - }, - { - "cell_type": "code", - "execution_count": 49, - "id": "70caf730-cc72-4d96-a3f2-6f1eced45e3b", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:09:40.540921Z", - "iopub.status.busy": "2026-08-11T03:09:40.540776Z", - "iopub.status.idle": "2026-08-11T03:09:40.544039Z", - "shell.execute_reply": "2026-08-11T03:09:40.543430Z" - } - }, - "outputs": [], - "source": [ - "systematic_fractional_err2 = 0.1\n", - "# choose a normalization 1 std deviation above the mean this time\n", - "N2 = 1 + systematic_fractional_err2\n", - "noise_fraction2 = 0.025\n", - "x2 = np.linspace(0.01, 0.8, 27, dtype=float)\n", - "y_true2 = my_model.y(x2, *list(true_params.values()))\n", - "y_exp2 = (y_true2 + rng.normal(scale=noise_fraction2 * y_true2, size=len(x2))) * N2\n", - "y_stat_err2 = noise_fraction2 * y_exp2 * N2" - ] - }, - { - "cell_type": "code", - "execution_count": 50, - "id": "29594275-7fa2-48f0-acd0-ff7bac4df1c3", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:09:40.545318Z", - "iopub.status.busy": "2026-08-11T03:09:40.545187Z", - "iopub.status.idle": "2026-08-11T03:09:40.547746Z", - "shell.execute_reply": "2026-08-11T03:09:40.547062Z" - } - }, - "outputs": [], - "source": [ - "x_full = np.linspace(-1, 2, 100)\n", - "y_true_full = my_model.y(x_full, *list(true_params.values()))" - ] - }, - { - "cell_type": "code", - "execution_count": 51, - "id": "74d3bc67-aaaf-48a0-82ee-abc34bb72599", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:09:40.549000Z", - "iopub.status.busy": "2026-08-11T03:09:40.548884Z", - "iopub.status.idle": "2026-08-11T03:09:40.718650Z", - "shell.execute_reply": "2026-08-11T03:09:40.718004Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 1.0, 'multiple experimental constraint with opposite bias')" - ] - }, - "execution_count": 51, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkAAAAHFCAYAAAAaD0bAAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlcelbwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAgdhJREFUeJzt3XlYVOXbB/DvsA2yg4Lgjoh75r6bgmtpalrirqlpmmtm5r7108pyyS01l8zd0srMLRU1NcUE11RE3BAEVFZhgJnn/cOXyYEBZmBmzsB8P9fFdTlnnnPOfQ5nnJtnlQkhBIiIiIgsiJXUARARERGZGhMgIiIisjhMgIiIiMjiMAEiIiIii8MEiIiIiCwOEyAiIiKyOEyAiIiIyOIwASIiIiKLwwTIgj19+hQ2Njb49ttvjVLe0PuXNFu2bIGNjQ0iIiKkDsUkLO16C6O43CN94/z2229hY2ODJ0+eGDky82fK37E+9724PHuGxATIggkhoFQqoVKp1NuioqJgY2OD1atX61S+qOezZCqVCkqlEsVhMvZ169bBxsYG9+/fL/QxitP15sUQ9yE/Rb1Hxo4vm7Y48zt3SfjdG4q+987Q5zJE2ZKCCRBpyC9JKVOmDDIzMzFhwgQJIit5hgwZgszMTFSrVk3qUApkif85amPs+1DUZ8JUvydtcfIZ0Y253rvi9P+RodhIHQAVLzY2fGQMRSaT8X6ShuLyTBSXOM2Rud47c43LmFgDZEYiIiJgY2ODjRs3YufOnahduzZcXV3RtWtXPH78GACwfft21KlTB05OTmjTpg3+/fdfjWOcPHkSNjY2OHLkSK7j29vbY+rUqXme/8yZM6hSpQoAYMKECbCxsYGNjY26xkdbH55XY96+fTtq1aoFJycnNGnSBIcOHdLpurOysrB48WLUq1cPTk5O8PLywoABA/DgwYMi75uZmYmWLVuiUqVKiI2NVe+nUCjQtGlT+Pr64unTpwD+ay9/9OgRPvnkE/j4+MDNzQ29evXCvXv3cp07Ojoao0ePRuXKleHg4IBq1aph9uzZyMjIUJd59ZjTp09HxYoVYWtrC0B7m/ur5adMmQIfHx94eXnhk08+gUqlQmZmJqZMmYJy5crBzc0Nw4YNQ1paWpFie/z4MWbPno3y5cvD1dUVPXr0wKNHj9TlZsyYgY8++ggAUK1aNfVzkf2MHTlyRL3N1tYWLi4uaN68ObZs2VLg7y8v0dHR+Oijj1C1alU4OTmhXr16WLJkCTIzM9Vlrl+/jt69e8PLywtOTk5o0KAB1q5dq3EcXa8RAJ4/f44JEybAz88Pzs7OqF27Nj755BM8e/ZMp/uQ3+9a13uU3zNR1N9TTpGRkbCxscHmzZvV254+fQo7Ozs4OTlpPFdff/017Ozs1J+VnHHqem6VSlXg7yEv+vy+dfkM6/t51+X8BT1Dhb13unye85OZmVngNWp79nR9bnW5brMkyGyEh4cLAKJ3795i4sSJ4uHDh+LmzZuibt26omXLlmLPnj1i7Nix4sGDB+L27duiXr16om7dukKlUqmPceLECQFAHDx4MNfxra2txeTJk9Wv4+LiBACxdOlS9bZ79+4JAGL58uUiMzNTZGZmCqVSmWf57JjfeecdMWrUKBEZGSkiIyPF+++/L6ytrcWRI0fyPZ9SqRTdu3cXHh4eYuvWrSIuLk78+++/olOnTqJ8+fIiNjY2z/ul67737t0THh4eIjAwUGRlZQkhhBg5cqSwtbUVZ8+eVR9v6dKlAoDo37+/WL9+vYiLixMhISHitddeExUqVBDx8fHqso8ePRLly5cXjRs3FmfOnBHPnz8XR48eFRUqVBC9evXKdcwBAwaItWvXiidPnohVq1YJIYTYtGmTACDCw8NzlR8yZIjYsmWLePr0qdi/f78oVaqUWLhwoRgzZozYtGmTiI+PF3/88YdwcHAQU6dO1bgv+sY2fPhw9fX+/fffokKFCiIgIEDjPq9atUoAEHfu3FE/F9nPnUqlUm/LyMgQjx49EosWLRJWVlbi559/Vh9H2/Vq8+DBA+Hj4yPq1q0rjh07Jp49eyauXr0qPvnkE/HHH38IIYS4du2acHJyEm3bthVXrlwRT548EUuWLBHW1tbik08+0fsahRCie/fuolq1auL8+fMiOTlZ3L59WyxdulQsWrRIp/uQ3++6KPfIUL8nbXx9fUVQUJD69a5du4SdnZ2QyWTi0KFD6u0dO3YUDRs2zDNOXe+NLr8HbfT9fevyGdanrK7nL+gZKsy90/XzrI0+16jt2dP1udXlus0REyAzkp1MNG3aVGP7rl27BADRrl07je0//fSTAKDxJV7UBOjhw4cCgFixYkWu/fNLgOrVq6dRVqlUipo1a4r69evnu//u3bsFALFr1y6N/Z8/fy5cXV3FtGnTcsVRmH0PHDggZDKZmD59uvjhhx8EALFs2TKN/bL/s5g+fbrG9ps3bworKysxc+ZM9bbBgwcLZ2dnER0drVH2t99+EwDEmTNnNI6ZM0kRIv8vu/nz52uUHTRokHBychJz5szR2D506FDh4eGhsU3f2ObOnatRbsWKFQKAuH37tnrbmjVrBAARGRmZ6zry0rlzZ9GxY8d8r1eb/v37CwcHB/Ho0aM8y/To0UM4OzuLZ8+eaWwfPXq0sLKyEnfv3hVC6HeNTk5O4tNPP803tvzuQ36/67zoco+M+XsaOXKkKF26tPqPnBEjRoj27duLhg0bqv+vSEtLE/b29hrXpS1OXe6NLtegjb6/b10+w/qU1fX8ujxD+t47XT/P2uhzjbp+PoXI/dzqct3miE1gZqhr164ar2vVqgUAaNOmjcb22rVrA4BZDFvs0aOHxmsrKyv07NkTYWFh6mpzbX777TfY2dnl2t/NzQ2NGzdGcHCwQfZ96623MH36dCxatAijRo3Ce++9l2dn7pzHq1GjBmrXro0///xTvW3//v1444034O3trVG2Q4cOkMlkueLu2bNnntehjbZnICUlBW+99ZbG9tq1a+PZs2dISEgodGxvv/22xut69eoBAO7evatTrCqVCt9++y2aNm0KV1dX2Nraqqvw79y5o9MxXnXgwAEEBgaifPnyeZY5duwYAgMD4e7urrG9T58+UKlUOHHihMZ2Xa7xtddew4YNG/Ddd98hKipK77izaftdG+IeFfX3pE3Hjh3x9OlTXLp0CQBw9OhRdOrUCZ06dVI3wfz1119IT09Hx44dC32ebIW9Bn1/37p8hvUpq+v5DfUMvUrfz7M2+tyPV+n63Brjuk2BCZAZ8vHx0Xjt7Oyc7/bExETTBJaPsmXL5tqW/YGNj4/Pc7+YmBhkZGTA1dUV9vb2kMvlsLOzg62tLY4fP27QfUeMGAErKyukp6djxowZel9L9vEUCgWeP3+OQ4cOqc+bfW4XFxcIIXKdO78vc20K+wwUJracx3RxcQEAjaQqP7NmzcLkyZMxbNgwXL9+HSkpKUhPT0evXr107qOQTaFQIDExMd/7pVAokJKSkitu4L9nLi4uTmO7Lte4c+dOdOzYEVOmTEGFChVQrVo1TJkyRe9+DNpiN8Q9KurvSZvAwEBYWVnhyJEjCA8Px/3799GxY0d07NgRV69eRUxMDI4ePYpSpUqhVatWhT5PtsJcQ2F+3wV9hvUpq8/5DfUMZSvM51kbfe7Hq3R9bg193aZiWV2+iwmZTKbXdvHK0ElXV1cAQEpKikaZJ0+eQKlUGijC3F7tYPzqOQGgdOnSee5XunRpuLi4ID4+Xuv15XXN+u6bmZmJfv36wdPTEzY2Nhg2bBjOnj0LuVyu9VoqV66c61qyr0Mul8PJyQldu3bF1q1btcZmZaX5t0V2Z1hdFfYZKExsujxX+dm8eTN69uyJDz/8UGN7YeY0kcvlcHZ2Vnf6z6uMg4OD1snd8nrmdLnGSpUqYceOHcjMzERYWBj++OMPfPnllzh//jxOnTql8zVo+10b4h4V9fekjYeHBxo1aoQjR47Azc0Nnp6eqF+/PjIzM+Hg4ICjR4/i6NGjaNOmDezt7Qt9nmyFuYbC/L4L+gzrU1af8xvqGcpWmM+zNvrcj1fp+twa+rpNhTVAJUyVKlUgk8lw7do1je0HDhzQaX9HR0cA0Psv999//13jtRAC+/fvR926dVGmTJk89+vWrRuSkpJw/Phx9WiDV3+sra0Nsu/kyZMREhKCnTt3YteuXbh69WqeTWA5ryUiIgI3btxAQECAelvXrl1x/PhxJCcnaz23Lv8pGYsxYsvvuRBCoFSpUhrbbty4oW5W0ddbb72FEydOICYmJs8yAQEBOHHiBJKTkzW279u3DzKZDO3atSvUuYGXCUyTJk0wZ84cDB48GH/99Zf6j4fCfj4MfY/yUpj4OnbsiLNnz2Lfvn3qZhU7Ozu88cYb2L59O8LCwnRq/irsvdGFvr9vXT7D+pTV9/z5PUPa5HfvDPF51ud+vErf51bf65YaE6ASxt3dHb1798aaNWtw7tw5vHjxAr/99hvOnTuXbzLx6v4+Pj44ceIEUlNTdT5vuXLlMGnSJDx58gRPnjzBuHHjcP36dSxcuDDf/fr164cuXbpgyJAh2L59O+Lj45GWloYrV65g5syZWLJkSZH33b17N1asWIGFCxeibdu2aNmyJb788kusXbsW27Zty3XcW7duYfv27UhJScH169fRr18/lClTBpMmTVKX+fLLL2FjY4OuXbvizJkzePHiBZ4+fYqTJ0+iX79+uHjxos73ztCMEVudOnUAAIcOHcr1H1q3bt3w888/48iRI0hPT8f58+cxfPhwtG3btlDxL1q0CKVKlULXrl1x7tw5pKWlISIiArNmzcLhw4cBAAsWLEB6ejr69OmDiIgIJCUlYe3atVizZg3GjBmj92RuiYmJ6NSpE37//XfExMQgKysLoaGh+PPPP9GyZUv1Zye/+5AfQ9+jvBQmvo4dOyIzMxN//vknOnXqpN7eqVMnHDp0CEIInRKgwt4bXej7+9blM6xPWV3Or+szpE1+984Qn2d97serdHlui3LdkpOi5zVplz2iav369RrbIyMjBQCxZs0aje15jdh68uSJeOedd4S9vb1wdnYWw4YNE6mpqTqNAhPi5YipmjVrCmtra2FtbS3Gjx+fZ/lXY16/fr2oXLmysLa2FnXq1BF79+7VOG5e58vMzBRff/21qFevnrCzsxNOTk6ifv36YtGiRblGXeRU0L43b94Uzs7OokePHrmGA/fq1Us4OjqK69evCyH+GzFx79498eGHHwpXV1chl8tF586dxc2bN3Od+/Hjx2L06NGiYsWKwtraWnh6eor27duLXbt2qYfbZx8z5wgOIfIf8ZOzfPZomYcPH2psz2v0SFFiCw0NFQDEjh07NLbPmjVLlC1bVlhZWQlra2tx+PBhIYQQSUlJYuTIkaJMmTJCLpeLNm3aiH/++UcMGDBAlC9fPt/rzcv9+/fF4MGDhZeXl7CxsRHVq1cX//vf/0RaWpq6zMWLF8Wbb74pHB0dhbW1tahevbr45ptv1COa9L3Go0ePip49ewpvb29hZ2cnqlSpIiZOnKgxVDi/+5Df77oo98hQv6e8KBQK4eDgIABojLy7evWqACA8PT1zfXby+l3qe2/yugZt9Pl96/IZ1vfzrsv5dXmG9L13Quj2edZGn2vUFpeuz62unx1zIxOC85abk6ysLFhbW+dqK9d3uzZKpRIymUyjyrSg/bOysmBlZaXeJ2f5O3fuwN/fH+vXr8eIESMKfX3GIv5/aQ9t58x+L/v6li1bhkmTJiE6OjrXiIuinl/bDKva3survL7bixpbfr+n/O7pq1QqFYQQ6r8AixJrYRX2GvU5dvYxCnN9utwjY/+eAKhrHXL+tZ6VlQWZTJZre0HXqs+9MeT/Cfp8ho3xedeFvvfOmOcqbNmcz21xxU7QZiavh0/f7dpoe1gL2j/n+0X98jL1VOv5Te9uiqnf9T1/XuX13V7U2PI7pq7n1NbZ2px+/0WNJeexC3N9utwjY/+eAO3/N+R3/IKOrc+9sbTlF/S9d8Y8V2HLStnH0ZBKxlUQERER6YEJEBEREVkc9gGiIjN1vx5jkaKPChEZjrH6vFDJxASIiIiILA6bwIiIiMjisO5PC5VKhcePH8PZ2bnYN+sQERFZCiEEkpOTUa5cuQJHqzEB0uLx48eoWLGi1GEQERFRITx8+BAVKlTItwwTIC2yV9h++PCherViIiIiMm9JSUmoWLGi+ns8P0yAtMhu9nJxcWECREREVMzo0n1F0k7QJ06cwDvvvINq1aqhcePGmDNnTr4LcGZlZWHz5s3o2LEj/Pz80K5du1yLWb548QLe3t65fnbt2mXsyyEiIqJiQrIaoKtXr2Lp0qUYNWoUateujTt37mDMmDG4efNmnsnKypUrcfnyZUydOhW+vr44ffo0hg8fjoSEBHz00UcAXnZgfvLkCQ4cOICGDRuq93V1dTXJdREREZH5k2weICFEriqqJUuWYMGCBXj+/LnWfVQqVa5e3R9++CEuXryIixcvAgBSUlLg7OyMc+fOoXnz5oWKLSkpCa6urkhMTGQTGBERUTGhz/e3ZDVAOZOfp0+f4rfffkOHDh3y3EfbkDaFQgE7O7tc2wcPHozMzEz4+flh1KhReO+994oedA5KpRKZmZkGPy6VXLa2tsV+BWUiopJA8k7Qffr0QXBwMJ4+fYqOHTtiy5YtOu97+fJlbN++HUuWLNHY3qNHD0ycOBE+Pj44ePAgBg0ahOjoaIwfP17rcRQKBRQKhfp1UlJSvucVQiAmJgYJCQk6x0qUzc3NDd7e3pxjiohIQpIvhfH8+XOkpKTg2rVrmDBhAho2bIidO3cWuN/Dhw/RunVrNGnSBHv27Mn3y2T69OlYu3Ytnj59qvX9uXPnYt68ebm251WFFh0djYSEBHh5ecHBwYFfZKQTIQRevHiB2NhYuLm5wcfHR+qQiIhKFH2awCRPgF51+PBhdOnSBXfv3oWvr2+e5R49eoR27dqhTp06+Omnn2Bra5vvcX/99Vf07NkTT548gZeXV673tdUAVaxYUesNVCqVuH37Nry8vFC6dGk9r5DoZXNvbGwsqlevzuYwIiIDKhZ9gLSxt7cHAKSnp+dZJioqCgEBAahVqxb27NlTYPIDAHfu3IGdnV2eN0Mul0Mul+sUY3afHwcHB53KE+WU/exkZmYyASIikohk8wBt3rwZ+/btQ1paGgDg7t27mD59Ol577TXUrFkTwMtM7tU5fKKjo9XJz88//6y18/OWLVvw008/IS0tDUIIBAcH44svvsCgQYPUCZYhsNmLCovPDhGR9CRLgNq3b499+/bBx8cHLi4uaNCgAapXr45Dhw6pvyCy5/TJTpJWrFiB8PBwnD17FpUqVVJPclijRg31cQMDA7F//374+PjAyckJQUFBGD16NFauXCnJdVqSjIwM3Lx5E0qlUupQiIiI8iV5HyAhhHruHm3vPXnyBK6urihVqhRSUlKQkpKSq5yVlVWuvj0qlQovXryAk5OT3jHl14aYnp6OyMhI+Pr6GrRGydgyMzMREREBPz8/nZoNC3O8a9eu4bXXXkN0dDS8vb2LfI6Sqrg+Q0RE5q5Y9QGSyWR5Llomk8k0vkidnJx0TmisrKwKlfyUVPfv30etWrUQGRmJKlWqmN3xiIiITEnStcDINFQqFe7evQsAiIiIwM2bN/Ho0SONJqv09HREREQgJSUFL168wM2bNzWOoVQqcfPmTWRkZOR5vJznfPToESeKJCIis8QEyAKkpqZi9OjRAICRI0eiZ8+emDdvHm7fvo1atWphxowZ8PHxwZtvvonz58/jwoULqFWrFrKystTHiIuLQ61atXD79u08j5ft22+/RdmyZdGsWTO4ubnpNbklERGRKUjeBFaS5LeSvbW1tUZ/j/zKWllZoVSpUvmWdXR01DkuZ2dnHD58GP7+/jh27Ji6yeratWsAgJCQEDx48EDdFBkcHFyk4125cgX37t2Do6MjVq5ciTFjxuCdd97Js6mTiIhKPoVCAVtbW63LWknBPKIoIbL7KGn76d27t0ZZLy+vPMu++eabGmWrVKmSq4whzZ0716DJybx589QJ2sCBA5Gamorbt28b7PhERFS8hIeHo0WLFli8eLHUoagxASJUrVrVoMcrX768+t/ZyVpycrJBz0FERMXDzp070ahRI4SGhmLZsmVaR3NLgU1gBpTfLzXnjL+xsbF5ls1ZPXjv3r0ixVWQnLFpm6jv1f5AREREBUlLS8PEiROxbt06AECbNm2wY8cOsxmhzQTIgPTpl2OssnnJ7n+ky6gsT09PAC9n3q5YsSIAICwsrNDHIyIiy3Lz5k306dMHV69ehUwmw/Tp0zF37lzY2JhP2sEmMAvh7e0NV1dX7NixAzdu3Mg1bP1V1atXR7Vq1TBp0iRcvHgRP//8MyZOnFjo4xERkeVITk5Gq1atcPXqVXh5eeHw4cP4/PPPzSr5AZgAWQwbGxts374dp06dwnvvvYd58+ZBLpejRo0auR5KGxsb/P7775DJZBg1ahR+/vlnbNy4ETVq1FAvGqvr8WQyGWrUqMHFY4mILISzszPmzp2LwMBAhIWFoWPHjlKHpJXkS2GYo5K4FAaZDz5DRFTSXL9+HVlZWXj99dcBvFzKSqVS5epjamz6LIXBGiAiIiIqFCEENm3ahCZNmqB3795ISkoC8LL239TJj77Mq0GOiIiIioWUlBSMGTMGP/74IwDAz88PGRkZEkelO9YAERERkV6uXLmCxo0b48cff4SVlRX+97//4eDBgyhTpozUoemMNUBERESkEyEE1q1bhwkTJkChUKB8+fLYsWMH2rRpI3VoemMNEBEREelECIFffvkFCoUCb731FsLCwopl8gOwBoiIiIh0ZGVlhS1btmDnzp346KOPzGZh08IovpETERGRUQkhsHLlSowZM0a9zdPTE+PGjSvWyQ/AGiAiIiLSIiEhAcOHD8fevXsBAO+++y4CAwMljspwmABJKFOhxLoJJwEAI5e3ha3cvOdMICIiyxASEoKgoCBERkbC1tYWixcvRkBAgNRhGVTxrr+iEuWnn35CixYtpA6DiMhiCSGwdOlStGrVSj1j/ZkzZzBhwgTIZDKpwzMoJkASUqn+W4XkcXiCxmtLlJKSgocPH0odhtquXbvQunXrAsvdvn0bkydPhr+/v0Y7ORFRcTNixAh8/PHHyMzMRO/evXHp0iU0adJE6rCMggmQRCJCY7Fj3t/q17+vvIwt088iIjRWwqik9e677+Lvv/8uuKCJJCcnF7jK/Z07d/D222/D29sbFSpUQGys5f7+iKj4e++992Bvb49Vq1Zhz549cHNzkzoko2ECJIGI0FgcWnsNqQmaU4anJihwaO01oyVBCQkJ+OSTT1C/fn00bNgQ48aNw7Nnz9TvDxkyBH369EH2+rgqlQo9e/bEyJEjAQBbtmxB+/btsXXrVnTo0AG1atXCmDFj1Gu/ZLt58yYGDBiAWrVqoXXr1li8eDGysrLU72cfZ8eOHWjVqhWqVq2KpKQkHDp0CO+9916ucuvXr0fHjh1Ru3ZtjBw5EklJSVi3bh1atGiBevXqYebMmRrH1yeG3bt3o1OnTnjttdfwwQcfqO/HkSNH8Nlnn+HRo0eoUqUKqlSpgjVr1uS6p76+vrh58yamTJkCV1fXwv5qiIgkoVKpcOvWLfXrLl26IDIyEmPGjClxTV45sRO0ialUAqd3hedb5q/d4fB93RNWVoZ7+BQKBQIDA1GjRg2sW7cOtra2+OKLL9C+fXuEhITAxsYGCxYswOuvv44VK1Zg/Pjx+Oqrr/DXX3/h6tWrAF6ushscHIzExEQsW7YMKpUKY8eOxZAhQ7Bv3z4AQHh4OFq2bInJkyfjs88+Q3x8PCZNmoQHDx5gxYoVGsdRqVRYvHgxypUrBycnp1xNYNnl5HI5Fi5ciJSUFAwYMADHjx9H3bp1sXLlSjx79gz9+vVD+fLlMXr0aL1jsLGxwfz58wEAI0eOxPjx47F161a0bt0aU6ZMwYoVKxAcHAwAcHd3z3VfzX2xPyKivMTHx2Pw4ME4e/YsQkND4evrCwDw9vaWODLTYAJkYtHhCUhNUORbJuW5AtHhCShfI/cXbmFt27YNiYmJ2Lp1q/pL+8cff4SnpydOnDiBjh07olKlSli7di0GDx4MZ2dnzJ49G7t374aPj4/6OCqVCtu2bUONGjUAAD/88AMaNmyI69evo06dOliwYAG6d++OGTNmqPdZu3YtWrVqhcWLF8Pe3h7Ay5WCd+zYUeAHzdbWFjt27FDXrgwaNAirVq3C5cuX4ejoCAAICgrC0aNH1QmQrjHY2tpi9+7d6mN/+umn+PjjjwEADg4OKF26NGxsbFClSpXC3XQiIjN1+vRp9OvXD1FRUbC3t8fly5fVCZClYAJkYqlJ+Sc/+pbT1ZkzZxATE4MaNWpACKFu5kpLS0N4eDg6duwIAOjTpw8OHDiAYcOGYeTIkejZs6fGcby8vNTJDwA0aNAAzs7OuHz5MurUqYMzZ84gMTER1apVU58nKysLSqUSd+/eRe3atQEA5cuX1+mvjIoVK2o0LXl6esLX11ed/GRvu3Llisa16hJDzmN7e3sjLi5O11tKRFTsqFQqfPHFF5g9ezaUSiVq1KiB3bt3o169elKHZnJMgEzM0UVu0HK6Sk9PR+PGjfHDDz/kes/Dw0PjdXx8PADAzs4uV1lt2+RyOdLT09XnGT58uLo25lXlypVT/7tUqVI6xa2tiUnbtuyETp8Y2HxFRJbkyZMnGDRoEI4ePQrgZY366tWr4eTkJHFk0mACZGI+/m5wdJPn2wzm5C6Hj7+bQc9bu3ZtHD16FGXLls03+Vi5ciXOnDmD7du3Y/DgwXjrrbfw5ptvqt+Pjo7G06dPUbp0aQDA48ePER8fD39/f/V5rl+/LmmzkaFisLa21kisiIiKs+XLl+Po0aMoVaoUVq1ahaFDh5b4js754SgwE7OykqFNkH++ZVr38TdoB2gAGDZsGJRKJUaOHInk5GQAQFxcHGbMmIEHDx4AAG7cuIFPP/0Uq1evRr9+/TBjxgy8//77Gs1CSqUSkydPRmZmJhQKBSZNmoS6deuiVatWAIDJkyfjjz/+wLfffgulUgng5YisSZMmGfR68mOoGMqVK4fY2FgkJiYaI0wiIpOaPXs2+vfvj4sXL+L999+36OQHYAIkCb8GXugyqi4c3TSbk5zc5egyqi78GngZ/Jw+Pj44fvw4IiMj4eHhAU9PT7z22mtwcnKCj48PMjIyMGDAAPTq1Qv9+/cHAMyaNQtVq1bFiBEj1MepUqUKbGxs4OXlBTc3N1y5cgXbt29XL4rXpUsX7Ny5E8uXL4eTkxPc3Nzw7rvv6jShoKEYKobAwEC0bNkS5cqVy3MYPADUqVMHVapUwZEjR3Dw4EFUqVIFDRs2NMSlEBEVWnR0ND799FP1H4L29vbYtm2buh+kpZMJ1vHnkpSUBFdXVyQmJsLFxUXjvfT0dPX04NmjiQpLkZaF7yedAgB0G/s6Ktb2MHjNjzbJyclQKBQoU6bMf7EoFIiOjoaPjw/k8v/6H6WkpCA+Ph4VK1bEmjVrsHLlSty8eRNZWVl4+vQpypYtm+d54uPjIZfL4ezsnOv8SUlJKF++vMb2lJQUJCQkoEKFCnmWS0pKQkpKikZfnoSEBKSnp2vtVK1PDOnp6YiJicnVdJacnIxnz57Bzc1N61w/Dx48gEql0thmbW2NihUrarstBn2GiIi0OXr0KAYOHIjY2FjMmzcPs2fPljokk8jv+zsn9gGS0KvJTjl/N5MkPwDg7OycKyGQy+Va+8w4OTlp7SBnY2OTb/IDQCPBKuj82s6lrZyLi0uuhzq/mUr1icHe3l7rPcgr3myVKlXK8z0iIlPKysrC3LlzsXDhQgghUK9ePfTp00fqsMwSEyAJ2cqt8dF3gVKHQUREJcCjR4/Qv39/nD59GgAwatQoLF26VOdRt5aGCRDpbMiQIXjnnXekDoOIiHI4ceIE3nvvPTx9+hTOzs5Yv349goKCpA7LrEmeAKWkpODmzZtwc3ODn5+fTr3SFQoFrly5Ant7e9StW1frPrqUIf0U1BRERETS8PLywosXL9CgQQPs3r0b1apVkzoksydZApSUlIQpU6Zg7969qFq1Ku7fvw83Nzds37493xE0x44dQ9++feHq6ork5GSUKVMGv//+u8YU3rqUISIiKs5evHgBBwcHAC9Ho/75559o2LAhB1foSLJh8E+fPkXbtm0RExOD8+fP49GjR6hduzaGDh2a5z6JiYno06cPRo4ciTt37iAqKgo+Pj4YNGiQXmWIiIiKs99++w2+vr44e/aselvLli2Z/OhBsgTI19cX/fv3Vy9HYGNjgxYtWiAmJibPfX799VckJydjypQp6n2mTp2KM2fOIDw8XOcyRERExVFGRgYmTZqEHj16IDY2FkuWLJE6pGJL8j5Aly9fxtOnT3H79m0sW7YM//vf//IsGxoaCj8/P41hz40aNVK/5+/vr1OZnBQKBRSK/5amSEpKKuJVERERGVZkZCSCgoIQEhICAJg0aRK++OILiaMqviRPgLZs2YK///4bt2/fRr169RAYmPew8OfPn+dauNPd3R1WVlZ4/vy5zmVyWrRoEebNm1fEKyEiIjKOn3/+GcOHD0diYiLc3d2xefNmdO/eXeqwijXJl8L45ptvcObMGURFRaF8+fLo0KEDMjIytJa1s7NDWlqaxraMjAyoVCr1KuW6lMlp2rRpSExMVP88fPjQAFdWsFSlEt4nwuB9Igyp/z9VuSU7d+4cpk2bJnUYRERmJTg4GO+++y4SExPRokULhIaGMvkxAMkToGx2dnYYO3Ys7t27h1u3bmktU7lyZTx+/Fhj26NHj9Tv6VomJ7lcrp5hWNtMw2Qat27dwo8//ih1GGpnzpzBjBkzCiwXERGBpUuX4pNPPsGaNWvYhEpEBtW2bVv06tULn376KU6ePJnndxnpR7IEKHtF8lfdunULMplMvXxBVlYWgoOD1R2jO3bsiCdPnuD8+fPqfX755Rc4OTmhefPmOpcxF8pXlmH7OyFF47UlatGihVm1Z//777/Ytm1bvmWWL1+Obt264eHDh/Dx8cGuXbtQvXp1REZGmihKIiqJfvnlF/UfUzKZDLt378aXX34JW1tbiSMrOSTrA7RhwwacO3cOXbt2RZkyZRAWFobFixdj9OjR8PHxAfByksSAgABs2rQJQ4cORdOmTfHuu++if//+mD9/Pp49e4bZs2dj/vz56rkQdCljDg7EJWDG7Sj16wFXIuEjt8Xn/uXR1dPNaOf9888/8eeff8LKygqtWrVC165d1e99/vnn8Pb21lj9PbtGY+rUqQgODkZwcDAGDx6MvXv3IioqCgEBAbmqYjMyMrBr1y5cunQJpUuXRrdu3VC/fn31+9nHGTp0KH788UdER0fjm2++wbNnz3D9+vVc5fr374/9+/cjKioKrVu3Rq9evXD79m3s2LEDqamp6NatG954441CxTB8+HDs2bMH0dHRaN68OXr37g3gZef8rVu34unTp/jwww8BAO+88w46d+6scZ4uXbpg7Nix6tGMEydORP369bFw4UKsX7++EL8hIrJkaWlpmDhxItatW4e+ffti+/btkMlk6v9jyHAkqwGaOHEihgwZgpMnT2LVqlW4f/8+du7ciVWrVqnL2NjYoG3bthqrfG/btg1jxozB9u3bceLECWzcuBGTJ0/WOLYuZaR0IC4BI67dQ0xGpsb2GEUmRly7hwNxCUY57+jRozFy5Eg4ODjA2dkZEyZMwMiRI9Xvt2zZEqNHj8apUy9XqD969CjGjx+PVq1aAQCuXbuGJUuWoG3btkhISECpUqXUiWa2lJQUtGrVCt9//z3KlSuH5ORkBAYGYsuWLeoy2cfp0KEDMjMzUa9ePVhbW+dqAssu17VrV7x48QK2trbo168fBg0ahG7dusHGxgZKpRIdO3bEsWPH9I5h6dKl6NSpE5KSkuDo6Ijhw4dj4cKFAABXV1dUrFgRdnZ2qF+/PurXr6918dcaNWpo/MdkbW0Nf3//fKdzICLS5tatW2jevDnWrVsHmUwGPz8/CAtvGTAqQbkkJiYKACIxMTHXe2lpaeLGjRsiLS2tUMfOUqlE/TPXRNnjoVp/vI+HigZnrokslaqol6Hh8OHDwt3dXcTFxam3PXr0SNjZ2Yl//vlHvW3KlCmiUqVKIjw8XPj4+IhZs2ap31uxYoUAIP744w/1tj179gh7e3sRHR0thBBi2rRp4o033hCqV+Lfs2ePcHd3F0qlUuM4ISEhGjFu2rRJlC9fXuN8VlZW4t9//1VvGzFihLCxsRERERHqbX379hUDBgxQv9Y1BplMJm7cuKEus3TpUlG5cmX16/Xr12u81sWDBw+Eo6Oj+Prrr/MsU9RniIhKnh9//FE4OjoKAMLT01McOXJE6pCKpfy+v3OSfBi8pfk7IQXRisw83xcAHisy8XdCClq5G27drf3798PBwQFz586FEEL9V4VcLkdoaKh6+ZHPP/8cx44dQ/369VG3bl3Mnj1b4zguLi5488031a979eqFAQMG4O+//0bPnj3V5xk3bpz6PMnJyXj+/DkiIyPh5+cH4OW6NY0bNy4w7goVKqBmzZrq1/7+/qhatSqqVq2qse3kyZO5rrWgGCpWrIhatWqp96tVq1aRRgCmpqaiV69eqF27NsaNG1fo4xCR5Xjx4gXGjRuHjRs3AgACAgKwbds2dVcQMh4mQCYWm5Fl0HK6io+PR+nSpVG3bl2N7V999RWaNm2qfm1nZ4fAwEBcunQJffv2hY2N5iOSc44lKysreHh4IDY2Vn2e1q1b5zpPq1atNCandHd31ynuUqVK5Tqftm3KV6YR0DWGnMextraGSqXSKa6cXrx4gW7dukGhUOD48eN5TrlARPSqlJQUHDx4EDKZDHPmzMHMmTPZ38dEmACZmJedbrdc13K6KleuHP755x91h968nDlzBsuWLcOQIUMwe/ZsdO/eXaO2JSYmBpmZmeqRCOnp6YiLi0OFChXU53FzcyvwPMZkqBhkMplO5dLS0vD2228jLi4OJ06cUI9iJCIqiJeXF3bu3AmlUomAgACpw7EoZjMPkKVo7uYEH7kt8vpqlQEoJ7dFczcng563X79+iIiIyDUy6fTp03j69CmAl0uADBw4EBMmTMDmzZvRtm1bDBw4UKN2JT09HRs2bFC/XrlyJdzc3NCmTRsAwIABA7Bt2zZcuXJFXUalUuHXX3816PXkx1AxuLu7IzExMd9OiOnp6Xj77bcRGxuLEydOwNPTs9BxE1HJl5KSgsGDB2tMsfHGG28w+ZEAa4BMzFomw+f+5THi2j3I8LLPT7bspGiBf3lY61j7oKvGjRtj9erVGD9+PH788UdUrlwZN27cgLOzM3755RcAwJgxY+Dq6qpej23jxo2oV68ePv/8c8yZMwcA4OnpieXLl+P333+HSqXCn3/+iY0bN8LZ+WV/pQkTJuD69eto1qwZOnToAAcHB1y6dAldunRBjx49DHpNeTFUDNlD6zt16gQ/Pz+tw+CnTJmCY8eOoVevXpg1a5Z6e8WKFXWaRJGILMeVK1cQFBSEmzdvYv/+/ejWrRtcXV2lDstiMQGSQFdPN3xftwpm3I7SGArvI7fFAiPOAzRq1Cj06tULp06dQlpaGiZPnqyeGycpKQlt2rTBvHnzIJfLAbxMdg4cOIDQ0FB1LZCHhwcuXryIs2fP4vHjx/j2229RrVo19Tmsra2xYcMGTJ06FRcuXIC9vT2++uorjZlLAwICtNaU5JwIUVu5jh07okqVKhrbunXrhgYNGhQ5hlq1amHNmjXq12XKlMGtW7dw8uRJPHv2TOsw+B49eqBOnTq5trMZjIiyCSGwfv16TJgwAenp6Shfvjx27NjB5EdiMpFf/b6FSkpKgqurKxITE3Mti5Geno7IyEj4+vrC3t6+aOfJykL109cAANvq+aKdh4vBa34MaeXKlVi5ciVu3rwpdSjFmiGfISIyb0lJSfjwww+xY8cOAMCbb76JLVu28I8kI8nv+zsn1gBJyMXGBjEB9aUOg4iIjCA1NRWNGzdGeHg4rK2tsXDhQnzyySewsmL3W3PABIh0llfTFRER5ebo6IiePXti586d2LlzJ1q2bCl1SPQKNoFpYaomMLJMfIaISq6EhASkpqaifPnyAIDMzEwkJyfnmkONjEOfJjDWwxERERlASEgIGjZsiN69eyMjIwMAYGtry+THTDEBIiIiKgIhBJYvX45WrVohMjIST548QVRUlNRhUQGYABVSYZdMIOKzQ1RyPHv2DO+88w4mTpyIzMxM9OrVC6GhofD19ZU6NCoAO0Hryc7ODlZWVnj8+DE8PT1hZ2en85IJZNmEEMjIyEBcXBysrKy4XhhRMff3338jKCgIDx48gJ2dHZYsWYIxY8bwO6GYYAKkJysrK/j6+iI6OhqPHz+WOhwqhhwcHFCpUiUOhSUqxoQQmDBhAh48eAA/Pz/s3r0bDRs2lDos0gMToEKws7NDpUqVkJWVpbFOFlFBrK2tYWNjw78QiYo5mUyGrVu3YtGiRVi2bFmBI47I/HAYvBb6DKMjIjKmVKUSfqeuAgAi3ngNjtbWEkdkuU6fPo3Q0FCMHz9e6lAoD5wJmoiIyEBUKhW++OILzJ49GyqVCvXr11cvlkzFFxMgIiKiPMTGxmLgwIE4evQoAGDgwIHs61NCMAEiIiLSIjg4GP3790d0dDRKlSqFlStX4v3332cfvhKCw1CIiIhy+PLLL9G+fXtER0ejdu3aCAkJwbBhw5j8lCBMgIiIiHIoXbo0VCoVhg4digsXLqBOnTpSh0QGxiYwIiIiAKmpqXB0dAQADB8+HNWrV2dn5xKMNUBERGTRsrKyMGvWLNStWxfPnj0D8HKeHyY/JRsTICIislhRUVEIDAzE559/jnv37mHPnj1Sh0QmwgSIiMiMKV+Zq/bvhBSN11Q0Bw8eRP369XH69Gk4OTlhx44dGDVqlNRhkYkwASIiMlMH4hLwxvlb6tcDrkSi8bkbOBCXIF1QJUBmZiamTp2Kt956C/Hx8WjQoAEuXbqEvn37Sh0amRATICIiM3QgLgEjrt1DTEamxvYYRSZGXLvHJKgI5s6di6+++goA8NFHH+Hs2bPw9/eXOCoyNSZARERmRikEZoZHQVtjV/a2WeFRbA4rpMmTJ6NevXrYs2cPVq5cCXt7e6lDIgkwASIiMiOpSiXKB19GtCIzzzICwGNFJv5OSDFdYMVYRkYGtm7diuy1vz08PBAaGop3331X4shISpwHiIiomIrNyJI6BLMXGRmJvn374sKFC0hPT8eIESMAAFZW/Pvf0vEJICIqprzs+Ddsfvbu3YsGDRrgwoULcHd3h5eXl9QhkRlhAkREZKbyWnVKBqCc3BbN3ZxMGU6xoVAoMG7cOPTu3RuJiYlo3rw5QkND0b17d6lDIzPCBIiIyIzlTIKyXy/wLw9rLsyZS0REBFq1aoWVK1cCAD799FOcOnUKlStXljgyMjdMgIiIzNSq2pVQ1s5WY5uP3Bbf162Crp5u0gRl5h48eIDQ0FCULl0aBw4cwJdffglbW9uCdySLI2kDcmxsLPbt24e7d++iYsWKCAoKgqenZ57l//rrL+zcuVPre7NmzULZsmWRkZGBjz/+ONf7gwYNQrNmzQwWOxGRsXUu44oOpV1Q/fQ1AMC2er5o5+HCmp8chBCQ/f89CQgIwKZNmxAYGIgKFSpIHBmZM8lqgPbu3atul/Xw8MChQ4fg5+eHixcv5rmPu7s7atasqfETEhKCHTt2wM3NDcDL4Y6rVq2Cvb29RjlXV1cTXRkRkeG8muw0d3Ni8pPD7du38cYbbyA8PFy9bfDgwUx+qEAyIaSZSSs8PBwVKlRAqVKl1Nu6dOkCpVKJo0eP6nSMzMxMVKhQAf3798fSpUsBACkpKXB2dsa5c+fQvHnzQsWWlJQEV1dXJCYmwsXFpVDHICIqjFSlEn6nrgIAIt54DQA0XjtaW0sWm7nZtm0bRo0ahdTUVHTq1AmHDx+WOiSSmD7f35LVAPn7+2skPwBQp04dxMTE6HyM/fv3IzY2Vj2vw6s2bdqEKVOm4LvvvkN8fHyR4yUiMgUuflqwFy9eYMSIERg4cCBSU1PRrl07bN68WeqwqJgxm07QKSkp2LNnD9q2bavzPhs2bEDLli1Rp04dje0eHh6wtbWFm5sbtm3bhho1auDChQt5HkehUCApKUnjh4jI2FKVSnifCIP3iTCkKpVaFz999TUBN27cQNOmTbFhwwbIZDLMmTMHf/75J3x8fKQOjYoZs5hFS6lUYuDAgbCyssK8efN02icqKgqHDx/G999/r7Hd3t4e169fh7e3NwBgxowZ6NGjBz744ANcvnxZ67EWLVqk83mJiIzhcHwiPrrxINf6X08y8l4Sw9KEhISgXbt2ePHiBby9vbFt2zYEBgZKHRYVU5LXAKlUKgwdOhQhISE4evQoSpcurdN+mzdvhqOjI/r06aOx3cbGRp38ZBswYACuXLmC5ORkrceaNm0aEhMT1T8PHz4s3MUQERXS/DvR+S5+CsDim8Pq16+PevXqoUOHDggLC2PyQ0UiaQ2QSqXCsGHDcOzYMQQHB8Pf31+n/YQQ2LhxIwYMGAAHB4cCyysUCgBAVpb2dXPkcjnkcrnugRMRGViMDjU9IYmpaF/aska03rx5E35+frC1tYWtrS0OHDgANzc3ruVFRSbZEySEwPDhw3HkyBGcOHEC1atXz1UmLS0NY8eOxfnz5zW2nzhxAnfv3tXa+TkkJATPnj1Tv37x4gVWrVqFJk2awN3d3fAXQkQWL2dfHmOxpMVPhRBYv349GjRogBkzZqi3e3h4MPkhg5CsBmjZsmXYvHkzOnfujBUrVqi3Ozg44KuvvgLwsuZm1apVaNy4scYkhhs2bECjRo3QsGHDXMdNTExEq1at4O/vDzc3NwQHB8PNzQ27du0y/kURERlRJXs7qUMwiaSkJIwaNUo98e3169eRlZUFGxuz6LZKJYRkT1Pz5s01Ep9srzZFOTg4YMWKFbnm8wkMDMS4ceO0HrdDhw4ICQnBqVOnEBcXhw8++AAtW7aENefOICITyjmfT0Hz93jb2eJJRqbWfkAyvFwCwxIWPw0NDUWfPn1w584dWFtb43//+x+mTJnCWh8yOMkmQjRnnAiRiPShLdnRJQF6tczq2pXw0Y0HADQ7PmfP+1zS1/8SQmDNmjWYNGkSMjIyULFiRezcuRMtW7aUOjQqRorFRIhERKZmqr46hdG5jCu+r1vFYhc/ffz4MaZOnYqMjAy8/fbbCA0NZfJDRsUGVSIiieSc9blLGVe0cXeyyMVPy5cvj3Xr1iE6OhqTJk1SL25KZCxMgIiIJHAgLgEzbkepXw+4EgkfuS1m+f03o3FJXvxUCIFvv/0Wr7/+Otq1awcA6Nevn7RBkUVhAkREZGIH4hIw4tq9XB2eYxSZ6n5AJdnz588xbNgw/PLLL/D29saNGzc4TQmZHBMgIiITUgqBmeFRec76XDLre/7z999/o2/fvrh//z7s7OwwY8YMuLm5SR0WWSB2giYiKiJ9VnD/OyEF0Yq8Z30uqcNyVSoVvv76a7Rp0wb379+Hn58fzp49i7Fjx7K/D0mCCRARURFoW8G98bkbOBiXoN72alJkSbM5Z0tPT0f37t0xZcoUZGVlISgoCJcuXUKjRo2kDo0sGJvAiIgKKa++PNGKTIz9979FlbM7OH/uXx5edpb3365cLoezszPkcjmWL1+OkSNHstaHJMcaICKyGPo0VelyrLz68mgTo8jEiGv38CwzCz5y2zz7+pSUtEClUiE1NRUAIJPJsHbtWly4cAGjRo1i8kNmgQkQEVmEvJqqDrzSVKWPgvry5JSdKM258xjzq5UDkDvZKSlpQWxsLN566y0MGDAA2YsNuLi4oF69ehJHRvQfJkBEVOJlN1XFZGgmLNm1MoVJggrTl0cAeKzIhIetTb6zPscE1EdMQP0C1w8zRydPnkT9+vVx+PBhHDlyBDdu3JA6JCKtmAARUYlW0LBzAJgVHqV3c1hR+vL0DotAOw9nnGpWQ71tWz1fhLSoXWyXvFAqlZg/fz4CAwMRHR2NWrVq4cKFC6hTp47UoRFpxQSIiEo0XYadP1Zk4u+EFL2O29zNKd++PLp4dZbn4jzrc0xMDDp37ow5c+ZApVLh/fffR0hICOrWrSt1aER5YgJERCWark1V+jZpWctk+Ny/PADd++4Uz/Qmf0II9OjRA8eOHYODgwO2bNmCjRs3wtHRUerQiPLFBIiISjRdm6oK06TV1dNNa18ebUpi8gO8HOG1bNkyNGzYEP/88w8GDRokdUhEOmECREQlWkFNVTIA5eS2aO7mVKjjd/V0y9WXZ32dyvDW0sF5Ve1KhTqHuYmKisKBAwfUr1u0aIGQkBDUrFlTwqiI9MMEiIhKtPyaqrJfL/AvX6T+Nzn78rzt5a61g3PnMq6FPoe5OHToEOrXr4/33nsP165dU2+3suLXCRUvfGKJqMTLq6kqe9i5MUZelZQOztkyMzPx2Wef4c0330R8fDxq1KgBuVwudVhEhWZ5c7ITkUXq6umGNu5OqH76Za3Ftnq+aOfhUuwTE1N4+PAh+vbti7NnzwIAxowZg2+++Qb29vYSR0ZUeEyAiKjYS1Uq4XfqKgAg4o3X4GhtrXWb1LUyOZfiaOfhgpiA+iaNQV/79+/H0KFD8ezZM7i4uOD777/He++9J3VYREXGJjAiIhMw9FIcpnLx4kU8e/YMjRo1wqVLl5j8UInBGiAiIiM7HJ+Ij248yDUbdfZSHMbqh1RYQgj1gqWzZ89GmTJlMHLkSPb5oRKFNUBEREY2/060wZfiMJZ9+/ahQ4cOSE9PBwBYW1tj3LhxTH6oxGECRERkZDkXYX1VYZfiMDSFQoHx48ejV69eOH78OFauXClpPETGxiYwIqIicrS2LnJn5sKsLm8oERERCAoKwj///AMA+OSTTzBhwgTJ4iEyBdYAEREZQXZS9HN9P53KF2V1+aLYvXs3GjRogH/++QceHh7Yv38/Fi9eDFvbgpf3ICrOmAARkcVKVSrhfSIM3ifCkKpU6lxGl/2yGXspjqJYunQpgoKCkJycjFatWiEsLAzdunUzeRxEUmACRETFXs75dZRCaN2WXSsTE1AfjtbWJonNFEtxFNY777wDDw8PTJs2DcHBwahYsaLJYyCSCvsAEVGxdiAuATNuR6lfD7gSCTcbzeRmwJVI+Mht8bl/eUmGm2cvxTHjdpRGh2gfuS0WmDimy5cv4/XXXwcAVKlSBbdv30bp0qVNdn4ic8EaICIqtg7EJWDEtXu5RlklZCmRkKXZNJU9545UEw9qWzU+pEVtkyU/L168wAcffID69evj4MGD6u1MfshSMQEiomJJKQRmhkdpnV9HG3OYc0eqpTj+/fdfNGvWDN9//z1kMhmuX79ukvMSmTMmQERULP2dkIJoRd7z62hjLnPumNIPP/yAxo0b49q1ayhbtiyOHj2KTz75ROqwiCTHPkBEVCwVZd4cKefcMZXU1FSMGTMGW7ZsAQC0b98eW7duRWl3T6z68DgAYOTytrCVm6YzOJG5YQ0QERVLRZk3R6o5d0zp8OHD2LJlC6ysrLBgwQIcPnwY3t7eUodFZDaYABFRsVTQ/Dra5JxzR9tQ+Zx0HWJvbnr16oXPPvsMx48fx8yZM2FtomH/RMWFZAlQVlYWNm/ejI4dO8LPzw/t2rXDtm3b8t3nxYsX8Pb2zvWza9cujXJPnz7FyJEj4efnhzp16mD+/PnIyir5Vd5EliS/+XW0yTnnzoG4BLxx/pb6/QFXItH43A2NUWLaytT56xqanvs33/2kkJycjHHjxiEuLk69bdGiRWjbtq2EURGZL8nqgVeuXInLly9j6tSp8PX1xenTpzF8+HAkJCTgo48+0rqPSqXCkydPcODAATRs2FC93dXVVf1vIQTefvttAMCuXbvw/PlzDBo0CM+fP8fSpUuNe1FEZFJ5za/jbmMNAWgMhX91zp3s4fM5622yh8p/X7cKAGgtk3N4fc79pJhnKCwsDH369EF4eDju3buH/fv3mzwGouJGsgRo/PjxsLL6rwLKz88Pf//9NzZt2pRnApTNw8Mjz7bsY8eO4dy5c7h58yZq1Hg558bChQvx4YcfYvbs2XB3dzfcRRCR5Lp6uqGNuxOqn74G4OX8Ou08XJCqVObaZi2T5Tt8XuBlTdHM248AmUyvIfYyvBxi36WMq8mGtwsh8N1332HSpElQKBSoUKECPvvsM4McO1OhxLoJJwGwszSVTJI1gb2a/GRTKBSws7MrcN/BgwfD19cXHTp0wJ49ezTeO3XqFCpWrKhOfgCgc+fOyMzMxN9//130wIkoF33WxjLG+bTNr5PXnDsFDZ8XAKIzsowyxN6QS3EkJiYiKCgIY8aMgUKhQLdu3RAWFoZWrVoV6bhElsJshkJcvnwZ27dvx5IlS/It16NHD0ycOBE+Pj44ePAgBg0ahOjoaIwfPx4AEBUVhbJly2rsk/368ePHWo+pUCigUCjUr5OSkopyKURkQKlKJfxOXQUARLzxWpETB2MPgTfFEPtbt27hrbfewt27d2FjY4Mvv/wSkyZNgkyC9cSIiiuzSIAePnyI7t274+2338aYMWPyLOfk5IRffvlF/bpGjRqIjY3FvHnz1AmQEAI2NpqXZWVlBSsrKyjz+Mt00aJFmDdvXtEvhIjMnrGHwJtiiL2Pjw9kMhkqV66MXbt2oVmzZkY/J1FJI/kw+EePHiEgIAD169fHjh079P4LplmzZnj27BliY2MBAJ6enoiPj9co8/TpU6hUKnh5eWk9xrRp05CYmKj+efjwYeEuhoj0YuqmM6Dg4fMyAD52NkUeYm9oycnJEP8/3N7FxQW///47QkNDmfwQFZKkCVBUVBQCAgJQq1Yt7NmzB7a2tnof486dO7Czs4OLiwsAoGnTpoiIiEB0dLS6zKlTpyCTydC4cWOtx5DL5XBxcdH4IaKSKb/h89mvP69eoUhD7A3t/PnzeO2117By5Ur1tpo1a3JQB1ERSJYARUdHq5Ofn3/+WWvn56SkJI15frZs2YKffvoJaWlpEEIgODgYX3zxBQYNGgR7e3sAQLdu3VC5cmV88sknSEtLw5MnTzB//nz07NkTFSpUMOk1EpF5yh4+X9ZO848uH7ktVtWuhOHX7mH4tXtYVbtSrjLuNtZws7HOtZ8xhsALIfDNN9+gdevWuH//PtasWYPMTP06ZxORdpIlQCtWrEB4eDjOnj2LSpUqqSc1fHX0Vva8P2lpaQCAwMBA7N+/Hz4+PnByckJQUBBGjx6t8VeRXC7HgQMHcPv2bbi5uaFChQqoWrUqNmzYYPJrJCLz1dXTDaea/ff/zbZ6vghpURudy/w3r1jnMq65ylxrXRcXWtTKtZ+hk5+nT5+ie/fu+OSTT5CVlYX33nsP586dK1RNORHlJlkn6OnTp6s7Lr/q1eHxrq6uiI6OVk90WKFCBfzwww9QqVR48eIFnJy0t7XXrl0bISEhSE5Oho2NDUqVKmWciyAiveQc0VVYOZeiaOfhgpiA+hplsoec5yevofIFldFlv6I4c+YM+vbti0ePHkEul2PZsmUYNWoUR3kRGZBkCZCTk1OeCUw2mUymdcJDKyurAvcFAGdn50LHR0S605aQGCopyHnsF0oVZoX/N6XFgCuR8JHb4vP/n+W5uIuJiUGHDh2Qnp4Of39/7N69G/Xr15c6LKISR/JRYERUvOmyppYhj/3B9fsay14A/y1FIfV6XIbg7e2NuXPnon///vjnn3+Y/BAZCRMgIiq07DW1CpuQ5Leqel7H1iZ7r1nhUWa5MntBTp48ievXr6tff/rpp9i6datRarFVqv/uz+PwBI3XRJaECRARFUpBa2oB+Sckh+MT86w5yu/YedFlKQpzo1QqsWDBAgQGBqJPnz5ITU0F8LL53xj9fSJCY7Fj3n9LAv2+8jK2TD+LiNBYg5+LyNwxASKiQtFlTa38EpKPbjzIs+Zo2b0YvdfiylbUpSjyq5UypJiYGHTu3BmzZ8+GSqVCkyZNjHKebBGhsTi09hpSEzI0tqcmKHBo7TUmQWRxzGIpDCIqfnRNNPIql99q7OsfxWt5Vzf6LEWRc6TYgbgEzLgdpX494EokvO0MP+z82LFjGDBgAJ48eQIHBwesXr0aQ4YMMfh5sqlUAqd3hedb5q/d4fB93RNWVhxpRpaBNUBEVCi6Jhqjb9xXL3OhS22KAJCQpf+yGEVdiiKvPkdPMjIhA7ChbhX1QqyFXdVdqVRi9uzZ6NixI548eYK6devi4sWLRk1+ACA6PAGpCYp8y6Q8VyA6PEH9mn2FqKRjAkREhaLLmlqvyjmiqyBuNtY6r8VV1KUoitqfSVdCCJw8eRJCCIwYMQLnz59HrVq1Ct6xiFKT8k9+cpZjXyGyBEyAiKhQdFlTK9vh+ESdR3Rl+6BCGa3H0qaoS1EUtT9TQbIXMbWxscGOHTuwY8cOrF+/Hg4ODoU6nr4cXeQ6l2NfIbIUTICISG/Zq7jntV5W9ppa2ebfidZ5RFd2U9bEKt5a1+sqJ7fFyloV1a8NsRRFUfsz5SUrKwvTpk3DxIkT1dvKlSuHvn376nWcovLxd4OjW/5JkJO7HGX9XHXqK8TmMCoJmAARUZFoWy8r55pautb85GzKymu9rjdfSXYMsRSFrv2Z9Olg/fDhQ7Rr1w5ffPEFvv32W4SFhRUyuqKzspKhTZB/vmVa9/HHk4hEvfsKERVXTICIqMgMtTaWtqYsY6+7lX3cgvoz6dPB+vfff0f9+vVx5swZuLi4YM+ePZLP6OzXwAtdRtWFo5udxnYndzm6jKoLvwZeevcVIirOOAyeiMzCjKreGFOprFESnIJk92cace0eZNAcoq9PB+uMjAxMmzYNS5YsAQA0atQIu3btgp+fn1Hi1pdfAy9UqOmB7yedAgB0G/s6Ktb2UA9916evEFFxxxogIjI6b7u8a1eyDSlfRpLkJ1tXTzetfY507WAthECPHj3Uyc/48eNx5swZs0l+sr06z085fzeN17r2FfLxdzNWeEQmwwSIiIzi1SHjfX3cAeQ/WkzK5CdbXn2OdOlgLZPJ8MEHH8DNzQ379u3D8uXLIZcXr5oSXfsKcbJEKgmYABGRweWc82fZ/Vi42ljD1UZz0kBvueFnWS4qffocKRQKXLt2Tf26V69euHv3Lnr27GnMEI1Kl75CRCUB+wARkYZUpRJ+p64CACLeeE2vmY6Bl3P+fHTjQa5h74lZSo1t2+r5oomrI6qfvobiKCIiAkFBQbh//z7CwsJQvvzLOZHc3d0ljqzoCuorRFQSsAaIyIJlz+fjfSJMvVyFLvJbMDSvOX+y1/nKVpQRXYVdisJQfvrpJzRs2BD//PMPVCoV7t69a/IYjC2/vkJEJQFrgIhIL9oWDPWR22JD3Spws7FG77CIPPctzPR5ORcslVJ6ejo+/vhjrFmzBgDQqlUr7NixAxUrVixgTyIyN6wBIiKd5bVgaIwiEyOu3cPh+ESJIjO+8PBwtGjRQp38TJs2DcHBwUx+iIop1gARUb5e7RPkbWebb/PWz0+e63Vsc6rdKcjSpUsRFhaGMmXKYOvWrejcubPUIRFRETABIiKd5bekhQDwNFOJ0rbWeJap1Joo5ZxkUJuidsI2lsWLFyMjIwPz5s1Td3gmouKLTWBEZFC9y3oAKHiFeHOVXSt1wluO6R9/DJVK9XK7oyO+//57Jj9EJQRrgIhIQ84RXk1cHfXav3MZFzRzc8SM21EaNUY+clss8C9fpFXbTWXLli0YPXo0Xrx4AV9fX43V3M1RpkKJdRNOAgBGLm8LW7l51JoRmTMmQEQWLGey80Kpwqzwx+ptA65EwvuVpSG87WzxJCMzz+Ytn/9fMNRaJkMbdyf1HD/b6vminYeLWcz2nJ/U1FSMHTsWmzdvBgC0b98effv2lTYoIjIKNoERWaicszUPuBKJD67fz9XP58krr2dX8wGQd/PWqwuGmmIVd0O6du0amjRpgs2bN8PKygoLFizA4cOH4e3tLXVoRGQErAEisiCvdjDWpUMycpTpUNoF39etUqybt7TZs2cPhgwZgrS0NJQrVw7bt29H27ZtpQ6LiIxI7wTojz/+QHx8PN599104ODgYIyYiMoHCTEr4Q1Q8xlQqWyybt/JTtWpVKJVKdO7cGT/++CM8PT2lDslobOXW+Oi7QKnDIJKc3k1gGRkZGD9+PHx8fDBq1CicP3/eGHERkRn6390YND53A38+TVJvM3TzVn7LbBhSYuJ/kzY2atQIZ8+exR9//FGikx8i+o/eCVDPnj0RHR2NVatWqWdGrVOnDr755hvExsYaI0YiMiMxikx8dOOBUY6trV9S43M3cCAuwWDnEELgu+++Q+XKlXHp0iX19kaNGsHKit0iiSxFoT7tpUqVwsCBA3H8+HFERETg3XffxYoVK1ChQgX06tULhw8fNnScRGQmjFMfU/AyG4ZIghITE9G3b1+MHj0aiYmJ2LhxY5GPSUTFU5E7QctkMsj+v/rb3t4eqamp6NGjBxo1aoT9+/fDw8OjyEESkeHp2glaG13202eZC6UQmBkele8yG7PCo9CljGuhm9v++ecf9OnTB3fv3oWNjQ2+/PJLTJo0qVDHKoriMmcP+wpRSVeoGqC0tDRs27YN7du3R9WqVXH48GHMmjUL0dHROHz4MB4+fAgrKyv+dUVkZl7tT5OdWJiDvxNSEK3If5mNx4pM/J2QovexhRBYsWIFWrZsibt376Jy5cr466+/8PHHH6v/eCMiy6N3AvTLL7/Ax8cHEyZMwGuvvYarV6/i3LlzGD58OBwdX84Y6+npie7du+PJkycGD5iICidn/xogdwJUTm6LlbVMv7p5bEaWQcu96ueff8b48eORkZGBnj17IjQ0FM2aNdP7OERUsujdBCaXy7FmzRr06tULcrk8z3Iff/wxhJFGbxCRfrL71+T8RKpe+Xf2cPZ0lQr49yGAvJvJsmd9DmlR2yAjwLzsdPuvSNdyr+rVqxe6d++O9u3bY9y4caz1ISIAhUiA3nzzTZ3KWeu4gvPTp09x9+5dVKxYUecZV/PbR6lU4vTp07n2qVmzJmd0JYuUX/+aVzVxddSazORMgrTN+lxUzd2c4CO3RYyi4GU2CiKEwMaNG9GvXz84ODjAysoKv/zyCxMfItIg2ZjP69evo0uXLqhZsybGjBmD6tWr4+2339aYm6Mw+6SlpSEgIAAff/wx5s6dq/4JCwszwVURSSdVqYT3iTB4nwhDqlKp3l5Q/5psIYmpubatql0JZV9ZCwx4mYh8X7eKQWd9tpbJ8Ln/y1XWdVlmIy9Pnz5F9+7dMWLECIwfP/6/YzD5IaIcJEuAIiMjMWnSJMTFxSEkJAQRERG4efMmJk+ebJB9Vq9ejeDgYPVPly5djHk5RGarKP1rOpdxxalmNdSvt9XzRUiL2kZZ8qKrpxu+r1ul0AnXmTNn0KBBA/z++++Qy+Vo1KiRxTTDq1T/Xefj8ASN10SknWRrgXXr1k3jtaenJ3r27IkDBw4YZJ/79+9DJpPBz88PZcqUMUzQRMVQUfvXmHJR066ebnovs6FSqfDVV19h5syZUCqV8Pf3x+7du1G/fn2jxWlOIkJjcXrXbfXr31dehqObHG2C/OHXwEvCyIjMm1lNe3rhwgX4+/sbZJ+JEyfiww8/RIUKFdC7d288e/Ysz2MoFAokJSVp/BCVFNn9awpKW5q4OpoknoLok3DFx8eja9eumDZtGpRKJfr3749//vnHopKfQ2uvITUhQ2N7aoICh9ZeQ0QoZ+cnyovZJECrVq3C2bNnMX369CLtY2Njg+3btyM6OhqhoaG4efMmwsLC8NFHH+V5nEWLFsHV1VX9U7Gi6YcBExmLLv1rsssB/01gGBNQH446DmaQSnp6Oi5evAh7e3usX78eW7duhbOzs9RhmYRKJXB6V3i+Zf7aHc7mMKI8mEUCtHv3bkyaNAnff/+9zvNz5LWPvb09+vXrp35dpUoVTJ06FXv37kVWlva+ENOmTUNiYqL65+HDh0W7ICIzk1//mg11qxSLZCfbq/16KlSogN27d+PChQsYMWKERXV2jg5PQGqCIt8yKc8ViA5PME1ARMWM5AnQTz/9hEGDBuG7777DkCFDjLKPp6cnMjIyEB8fr/V9uVwOFxcXjR+i4ibnKupJWVkao8K6erqZrEOzsTx58gSdO3fGvn371NsCAgLw2muvSRiVNFKT8k9+9C1HZGkkTYD27t2LAQMGYPXq1Rg2bFiu97OyshAcHIyYmBid90lOTs617fDhw/Dy8oKXFzsEUsmkbRX1nLM+A6bt0Gxox48fx+uvv46jR49i3LhxUCgs+4vd0SXviWgLU47I0kg2CuzIkSPo27cv+vfvDz8/PwQHB78MyMYGrVu3BgCkpKQgICAAmzZtwtChQ3XaZ/PmzTh58iS6d+8ONzc3/PHHH9iwYQM2btwIKyvJK7yIDC6vWZ6fZBQ8948u9FnUVBf6LgaqVCoxf/58LFiwAEII1KlTB7t37853JnpzlnPIesXaHrCy0j8R9fF3g6ObPN9mMCd3OXz83QoTJlGJJ1kCdO/ePbRs2RL37t3D3Llz1dudnJzw+++/A3iZ2LRt21Y9g7Mu+4wbNw7VqlXDnj17EBcXh6pVqyI0NBR169Y12bURmUpBq6i/Wq64eDXhevz4MboNGKD+Y2fEiBFYvnw5HBwcpAuwCAw5ZN3KSoY2Qf44tPZanmVa9/EvVHJFZAlkwlJmCtNDUlISXF1dkZiYyP5AZNbOPE9G77CIAsttq+eL9qVdkapUwu/UVQBAxBuvSdLxWdcaoLi4ONSpUwdxcXFwcnLC2rVr0b9/f1OGalDZQ9bz0mVUXY0kSNf7lJ1UvToU3sldjtZ9OA8QWR59vr8lqwEioqIz5irqUvP09ESfPn3w119/YdeuXahRo0bBO5kpXYes+77uqXeNjV8DL1So6YHvJ50CAHQb+3qhm9WILAkTIKJiTNdZnuMzMotFM9ijR49gbW0NHx8fAMA333wDIQTs7e0ljqxo9BmyXr6Gu97HfzXZKefvxuSHSAfsFUxUjOk6y/P/7sag8bkbCH6WbLaTHB44cACvv/46+vfvD+X/L+Yql8uLffIDcMg6kTliAkRUjOU3y3NOMYpMjLh2DwfiEowelz4yMzMxZcoUdOvWDc+ePUNycjKePn0qdVgGxSHrROaHCRBRMZfXLM85ZTeAzQqPMpvmsPv376NNmzb4+uuvAQDjx4/HmTNnStycXdlD1vPDIetEpsUEiKgEyDnLc14EgMeKTPydkGL8oApw5d4ZNGnWCOfPn4ebmxv27t2L5cuXF9v5ffKTPWQ9PxyyTmRaTICISgh9ZnWWelSYUpmF3y5sQEJCApo2bYrQ0FC88847hT5epkKJVR8ex6oPjyNToTRgpIbj18ALXUbVhaObncZ2J3d5riHwRGR8HAVGZIF0HT1mLNbWNhjWYRYUlW5i4cL/wc7OruCdSgAOWScyH6wBIiqB8vo6lQEoJ7dFczcnU4YDAPj555+xcuVK9etyHr5Y9L8vLCb5ycYh60TmgTVARCWUDJrLYWR/zS7wL2/SRVDT09MxefJkrF69GtbW1mjapLnJzm0q+q5vRkTSYw0QUQm0qnalXKPCfOS2+L5uFXT1dDNZHOHh4WjRogVWr14NAJgyZQpq16qjfv9xeILG4qBERKbCGiCiEqhzGVd0KO2C6qdfrj21rZ4v2nm4mLTmZ8eOHRg5ciRSUlJQpkwZ/Pjjj/Av2xA/LfxHXaYoi4ESERUFa4CISojsVdSzZ3l+Ndlp7uZk0uRn3Lhx6N+/P1JSUvDGG28gLCwM/mUb4tDaaxqLdgJAaoICh9ZeQ0RorMniKw5erRljTRmR4TEBIiKDq1atGmQyGWbOnIljx47Bx6ecTouB8kv+pYjQWOyY97f69e8rL2PL9LNMEokMiE1gRGQQz58/h7v7y4U8x48fjzfeeAMNGjQAAETdem7UxUBLkojQWBxaey3X9uyaMm1zBtnKrfHRd4GmCpGoRGANEBEVSWpqKt5//300bdoUSUlJAACZTKZOfgAuBqorlUqwpozIRJgAEVGhXbt2DU2aNMHmzZtx9+5dHDt2TGs5Lgaqm+jwBJ1ryoioaNgERlRCZXeKNgYhBDZt2oSxY8ciLS0NPj4+2L59O9q1a6e1fPZioPl9uZtqMVBznrOHNWVEpsMaICLSS0pKCgYNGoThw4cjLS0NnTp1QlhYWJ7JD2D8xUBLyogp1pQRmQ4TICLSyyeffIJt27bB2toaCxcuxMGDB+HlVfAcPsZaDLQkjZjKrinLj6lqyohKOiZARKSX+fPno0mTJggODsa0adNgZWWl82rsfg280G/Of0thdBv7Ogb9r2WRkp+SNLeQsWvKiOg/TICIKF9JSUnYsGGD+rWXlxfOnz+P1q1bF+p4hloM1JxGTOnTBJc9ZP2j7wK19j8yVk0ZEWliJ2giytOlS5fQp08fREREoFSpUujfvz+Al8PcpabPiCljzi0UERqL07tuq18bYnkPvwZeqFDTA99POgXgZU1ZxdoerPkhMiDWABFRLkIIrFy5Ei1atEBERAQqV66MqlWrSh2WBnMYMWXMJjhD1ZQRkXZMgIhIQ0JCAt59912MGzcOGRkZ6NGjB0JDQ9G8efOCdzYhqUdMmVMTHBHpjwkQEamFhISgQYMG2Lt3L2xtbbF8+XLs27dPvcSFOZF6xBQnLSQq3pgAEZFaXFwc7t27h6pVq+Ls2bMYP368WfT30UbqEVPm0ARHRIXHBIjIwgnxXxPNW2+9hW3btuHSpUto3LixzsPbpSLliCmpm+CIqGiYABFZsHPnzqFBgwa4f/++elv//v3h6uoqYVT6MfTcQrqSugmOiIqGCRCRBVKpVFi8eDHeeOMNXL58GdOmTZM6pCLRZ8SUoZbNkLoJjoiKhvMAEVmYuLg4DBkyBAcPHgQA9OvXD2vXrpU4KtMw9Jw92U1wp3fd1hgK7+QuR+s+hZ8HiIiMjwkQkQU5deoU+vXrh8ePH8Pe3h4rVqzA8OHDzbajsyFlz9mTU/acPdr6DOmycjwnLSQqntgERmQhDh06hICAADx+/Bg1a9bEhQsXMGLECIMkP8Zajd1QnbCNPWcPJy0kKn5YA0RkIdq1a4d69eqhXr16WLVqFZycnAxyXH2blbLXwjIlc1k2g4jMB2uAiEqwkJAQKJUva07s7e1x8uRJ/PDDDwZNforDauycs4eIcpK0Big2Nhb79u3D3bt3UbFiRQQFBcHT07PA/Y4cOYJjx47B3t4evXv3Rr169QpVhqikUiqVWLBgAebPn485c+Zgzpw5AAAXFxeDnUPXZiXf1z0lbxIqjnP2SFFTRmRJJKsB2rt3L5o3b47Q0FB4eHjg0KFD8PPzw8WLF/Pdb9q0aQgKCoJMJkNMTAwaN26MvXv36l2GqKSKjo5Ghw4dMG/ePAgh8PjxY43JDg12nmK0FATn7CGinCSrAXrttddw/fp1lCpVCgAwdepUdOnSBdOmTcPRo0e17nP79m189dVX2LdvH7p37w4AcHV1xdixY9G9e3fY2NjoVIaopDpy5AgGDhyIuLg4ODo64rvvvsPAgQONcq7i1KyUPWePtlFg2ThnD5FlkawGyN/fX538ZKtTpw5iYmLy3Of333+Hi4sLunbtqt42aNAgREdHIyQkROcyRCVNVlYWZsyYgS5duiAuLg6vv/46Ll26ZLTkByh+zUpSLptBRObHbDpBp6SkYM+ePWjbtm2eZcLDw1GpUiVYW/83F0fVqlXV7+laJieFQoGkpCSNH6LiJCIiAkuWLIEQAh9++CHOnTuH6tWrF/m4+Q1vL47NSlItm0FE5scs2oOUSiUGDhwIKysrzJs3L89yaWlpcHZ21tjm6OgIa2trvHjxQucyOS1atCjf8xKZuxo1amDt2rWwt7dHnz59DHLMgoa3F9dmJc7ZQ0SAGdQAqVQqDB06FCEhITh69ChKly6dZ1knJyckJCRobEtKSoJSqVSPbtGlTE7Tpk1DYmKi+ufhw4dFuiYiY8vMzMTUqVNx7tw59bbBgwcbNPnRZXi7uTQrZY+Y+ui7QK2zNRMR5SRpAqRSqTBs2DAcO3YMJ06cgL9//gsL1qlTB/fu3UN6erp627///gsAqF27ts5lcpLL5XBxcdH4ITJXDx48QNu2bfHVV1+hX79+SEtLM+jx9Z01mc1KRFQcSZYACSEwfPhwHDlyBCdOnNDaXyEtLQ1jx47F+fPnAQA9evRAVlYWfvjhB3WZVatWoUaNGnj99dd1LkNUXP3666+oX78+zp07B1dXVyxZsiTXYIKCFLS8RGGGtxurWclYS2wUl/MTkfFI1gdo2bJl2Lx5Mzp37owVK1aotzs4OOCrr74C8LJz8qpVq9C4cWM0a9YM5cqVw4oVKzBhwgQcOnQIz549w5UrV/DHH3+o1zPSpQxRcZORkYGpU6di2bJlAIAmTZpg165d8PX1Nfi5zGV4u6FXbjfm+TlpIVHxI1kC1Lx5c43EJ5tc/t+oEgcHB6xYsQLNm/9Xvf7BBx8gMDAQp06dglwuR+fOnXP1G9KlDFFx8fz5c3Tu3Fk9jcPHH3+MRYsWwc7OroA9C8cchrcXZuX2knR+IjI+yRKgFi1aoEWLFvmWsbOzw9ixY3Nt9/Pzg5+fX7776lKGqDhwc3ODj48P3N3d8cMPP+Dtt9826vmyh7fn1wxmzOHtUi+xIfX5icg0JB8FRkS5paenIyUlBQAgk8mwadMmhIWFGT35Af6bNTk/xhzeLvUSG1Kfn4hMgwkQkZkJDw9Hy5YtMWrUKPUaXh4eHqhUqZLJYpByeLvUfZCkPj8RmYZZTIRIRC/t2rULH3zwAZKTk/Hw4UNERUWhQoUKksTi18ALFWp64PtJpwC8HN5esbaH0Zt9pO6DJPX5icg0WANEZAbS0tIwatQo9O3bF8nJyWjTpg3CwsIkS36ySTFrstRLbEh9fiIyDSZARBK7desWmjdvjnXr1kEmk2HmzJk4fvw4ypcvL3VokjB2H6SCZo2Wug8UEZkGEyAiCSmVSnTr1g1XrlxB2bJlceTIESxYsAA2NpbdOi31EhtSn5+IjM+y/5clkpi1tTXWrl2LL774Alu2bIG3t7fRz5lzdmNT9OspDKn6IJnL+YnIuJgAEZnY9evXERkZiW7dugEAAgMDERAQYJKZyo01u7KxZkKWeuV2qc9PRMbDJjAiExFCYOPGjWjSpAn69euH8PD/JtszVfKjywrvRESWgAkQkQmkpKRg8ODBGD58ONLS0tCyZUu4urqa7Pz6rvBORFTSMQEiMrIrV66gUaNG2Lp1K6ytrbFw4UIcPHgQXl6m60jL2Y2JiDSxDxCREa1fvx7jx49Heno6ypcvj507d6J169Ymj4OzGxMRaWINEJER3bp1C+np6XjrrbcQFhYmSfIDcHZjIqKcWANEZGAqlQpWVi//tli0aBHq1auHgQMHqrdJQeoV3omIzA1rgIgMRAiBlStXon379sjMzAQA2NraYvDgwZImP0DhZzcuaNZkIqLiigkQkQEkJCTgvffew7hx4xAcHIytW7dKHVIunN2YiOg/bAIjKqKQkBAEBQUhMjIStra2WLx4MYYOHSp1WFpxdmMiopeYABEVkhACy5cvx6efforMzEz4+vpi165daNKkidSh5as4zW5srBmmi8v5ich42ARGVEifffYZJk2ahMzMTPTu3RuXLl0y++SHiIheYgJEVEjDhw9H6dKlsWrVKuzZswdubm5Sh0RERDpiExiRjlQqFf7++2+0bNkSAFC9enXcu3cPTk5OEkdGRET6Yg0QkQ7i4+PRrVs3tGnTBsHBwertTH6IiIon1gARFeD06dPo168foqKiYG9vj6ioKKlDIiKiImINEFEeVCoVFi5ciICAAERFRaFGjRo4f/48BgwYIHVoRERURKwBItLiyZMnGDRoEI4ePQoAGDRoEFavXs0mLyKiEoIJEJEWBw8exNGjR1GqVCmsXr3abCc2fFWmQol1E04CAEYub8ulK4iI8sEEiEiLIUOGIDw8HP3790edOnWkDoeIiAyMCRARgOjoaEydOhXLly+Hu7s7ZDIZ/ve//0kdllFwdmMiIiZARDh69CgGDhyI2NhYqFQqs1zIlIiIDIujwMhiZWVlYebMmejcuTNiY2NRr149zJo1S+qwiIjIBFgDRBbp0aNH6N+/P06fPg0A+PDDD7FkyRKUKlVK4siIiMgUmACRxTl//jy6du2Kp0+fwtnZGevXr0dQUJDUYRERkQkxASKL4+/vDwcHB1SuXBm7du1CtWrVpA6JiIhMjAkQWYS4uDiUKVMGMpkMHh4e+PPPP1G5cmXI5XKpQyMiIgmwEzSVeL/99htq1KiBTZs2qbdVr169xCU/KpVQ//txeILGayIi0iRpAhQZGYnPPvsMvr6+6NKlS4Hlt2zZAm9vb60/Dx48AAC8ePFC6/u7du0y9uWQmcnIyMCkSZPQo0cPPH/+HFu2bIEQJTMpiAiNxY55f6tf/77yMrZMP4uI0FgJoyIiMl8yIdE3gkKhQO3atTF8+HDcuHEDN2/exMWLF/PdJy0tDYmJiRrbhg4diqioKFy9ehUAkJKSAmdnZxw4cAANGzZUl3N1ddV5hE9SUhJcXV2RmJgIFxcXPa+MzEFkZCSCgoIQEhICAJg0aRK++OIL2NnZSRyZ4UWExuLQ2mt5vt9lVF34NfAyYURERNLQ5/tbsj5Acrkc4eHhsLKywsSJE3Xap1SpUhpJTFxcHI4fP46vv/46V1kPDw94e3sbKlwqRvbu3Ythw4YhMTER7u7u2Lx5M7p37y51WEahUgmc3hWeb5m/dofD93VPWFnJTBQVEZH5k7QJzMqqaKffsmULrK2tMXDgwFzvDR48GL6+vujQoQP27NlTpPNQ8REeHo733nsPiYmJaNGiBUJDQ0ts8gMA0eEJSE1Q5Fsm5bkC0eEJpgmIiKiYKNajwDZu3IjevXvDw8NDY3uPHj0wceJE+Pj44ODBgxg0aBCio6Mxfvx4rcdRKBRQKP77EklKSjJq3GQ8/v7+mDVrFtLS0vD555/D1tZW6pCMKjUp/+RH33JERJai2CZA586dw40bN7B69WqN7U5OTvjll1/Ur2vUqIHY2FjMmzcvzwRo0aJFmDdvnjHDJSPavXs3GjRoAH9/fwDAnDlzIJNZRnOPo4tuI9l0LUdEZCmK7TD4DRs2wN/fH23bti2wbLNmzfDs2TPExmofETNt2jQkJiaqfx4+fGjocMkI0tLS8OGHHyIoKAhBQUFIT08HAItJfgDAx98Njm75JzdO7nL4+LuZJiAiomKiWCZAqamp2LVrFz744AOdyt+5cwd2dnZ59giXy+VwcXHR+CHzduvWLTRv3hxr166FTCbDW2+9BRubYluhWWhWVjK0CfLPt0zrPv7sAE1ElINZJ0BJSUla5/DZtWsXFAoFhgwZkmufLVu24KeffkJaWhqEEAgODsYXX3yBQYMGwd7e3lShkxFt27YNjRo1wpUrV+Dl5YXDhw/j888/t8gECAD8Gnihy6i6cHTTHOLv5C7nEHgiojxI+o3Rrl073Lx5E8nJycjIyFAPW7979y4cHBygUqnw5MkTpKWlaey3YcMG9OjRA15euf9jDwwMxIwZMzBixAhkZmbCyckJo0ePxvTp001yTWQ8aWlpGDt2LDZu3Ajg5fOzfft2+Pj4SByZ9PwaeKFCTQ98P+kUAKDb2NdRsbYHa36IiPIgaQL0888/IzMzM9f27Ll+XF1dER0dDVdXV4339+7dC2dnZ63HrFChAn744QeoVCq8ePECTk5Ohg+cJGFtbY1r165BJpNhzpw5mDlzJqytraUOy2y8muyU83dj8kNElA9JE6DSpUvn+75MJtM6mWHZsmULPLaVlRWTnxJACAEhBKysrGBnZ4ddu3YhMjISAQEBUodGRETFmFn3ASLLlpKSgiFDhmg0X1apUoXJDxERFZll9hols3flyhUEBQXh5s2bsLGxwahRo+Dr6yt1WEREVEKwBojMihAC69atQ7NmzXDz5k2UL18ex48fZ/JDREQGxRogMhtJSUn48MMPsWPHDgDAm2++iS1btqBMmTISR0ZERCUNEyAyCyqVCu3atUNoaChsbGywcOFCTJ48ucgL5hIREWnDbxcyC1ZWVvj4449RqVIlnDp1ClOmTGHyQ0RERsNvGJJMQkICLl++rH49cOBA3LhxAy1atJAwKiIisgRsAiNJhISEICgoCAqFAmFhYfD09AQAODo6ShxZ8WUrt8ZH3wVKHQYRUbHAGiAyKSEEli1bhlatWiEyMhJ2dnZ48uSJ1GEREZGFYQJEJvPs2TO88847mDRpEjIzM9GrVy+Ehoaibt26UodGREQWhgkQmcS5c+fQoEED/Prrr7Czs8PKlSvx008/wc3NTerQiIjIArEPEJnEqlWr8ODBA/j5+WH37t1o2LCh1CEREZEFYwJEJrF69Wp4eXlh7ty5cHFxkTocIiKycGwCI6P466+/MHbsWAghAAAuLi5YsmQJkx8iIjILTIDIoFQqFRYuXIh27dph1apV+OGHH6QOiYiIKBc2gZHBxMbGYtCgQThy5AiAlxMbvvvuuxJHRURElBsTIDKI4OBg9O/fH9HR0ShVqhRWrVqFoUOHQiaTSR0aERFRLmwCoyJbsWIF2rdvj+joaNSuXRshISF4//33mfwQEZHZYgJERdawYUPIZDK8//77uHDhAurUqSN1SERERPliExgVSmxsLLy8vAAArVq1wpUrV1C7dm2JoyIiItINa4BIL1lZWZg5cyaqVq2K69evq7cz+SEiouKENUCks6ioKPTv3x+nTp0CAPz6669s7iIiomKJCRDp5NChQxg0aBDi4+Ph7OyMdevWoW/fvlKHRUREVChsAqN8ZWZm4rPPPsObb76J+Ph4NGjQAJcuXWLyQ0RExRoTIMrXxo0b8eWXXwIAPvroI5w9exbVqlWTOCoiIqKiYRMY5Wv48OH4448/MGjQIM7qTEREJQZrgEhDRkYGlixZAoVCAQCwsbHBr7/+yuSHiIhKFNYAkVpkZCT69u2LCxcu4N69e/j222+lDomIiMgoWANEAIC9e/eiQYMGuHDhAtzc3NC+fXupQyIiIjIaJkAWTqFQYNy4cejduzcSExPRvHlzhIWFoUePHlKHRkREZDRMgCzY3bt30bJlS6xcuRIAMGXKFJw6dQqVK1eWODIiIiLjYh8gCyaTyRAREYHSpUvjhx9+QNeuXaUOiYiIyCSYAFkYpVIJa2trAICvry/27t2L6tWro0KFChJHRkREZDpsArMgt27dQuPGjXH48GH1tsDAQCY/RERkcSSvAVKpVAgJCYGNjQ0aNWqUb1mlUonTp0/n2l6zZk14e3trbFMoFLhy5Qrs7e1Rt25dyGQyg8Zd3Gzbtg2jRo1CamoqJk+ejI4dO8LKivkvERFZJskSIJVKhcWLF2PdunV4/vw5qlatiosXL+a7T1paGgICAtCgQQO4uLiot3/22Wfo0qWL+vWxY8fQt29fuLq6Ijk5GWXKlMHvv/8OX19fo12PuXrx4gXGjx+PDRs2AADatWuHbdu2MfkhIiKLJtm3oFKpxLNnz3DkyBEMHjxYr31Xr16N4OBg9c+ryU9iYiL69OmDkSNH4s6dO4iKioKPjw8GDRpk6Eswezdu3EDTpk2xYcMGyGQyzJkzB3/++SfKlSsndWhERESSkqwGyNbWVr3Ipr7u378PmUwGPz8/lClTRuO9X3/9FcnJyZgyZQqAl0s5TJ06FZ06dUJ4eDj8/f2LHHtxEBkZiSZNmuDFixcoW7Ystm/fjsDAQKnDIiIiMguS9wEqjIkTJ8Lb2xv//vsvunbtivXr18PDwwMAEBoaCj8/P7i5uanLZ/ctCg0N1ZoAKRQK9dpXAJCUlGTcCzABX19fBAUF4eHDh9i6dSvKli0rdUhERERmo1h1BLGxscH27dsRHR2N0NBQ3Lx5E2FhYfjoo4/UZZ4/f65OhrK5u7vDysoKz58/13rcRYsWwdXVVf1TsWJFo16HsVy9ehVxcXHq16tXr8bhw4eZ/BAREeVQrBIge3t79OvXT/26SpUqmDp1Kvbu3YusrCwAgJ2dHdLS0jT2y8jIgEqlgp2dndbjTps2DYmJieqfhw8fGu8ijEAIgfXr16Np06YYMmQIVCoVgJf3i52diYiIciv2346enp7IyMhAfHw8AKBy5cp4/PixRplHjx6p39NGLpfDxcVF46e4SE5OxoABAzBy5Eikp6dDCIEXL15IHRYREZFZM+sEKCsrC8HBwYiJiQHw8ss+p8OHD8PLywteXl4AgI4dO+LJkyc4f/68uswvv/wCJycnNG/e3DSBm0hoaCgaNmyIHTt2wNraGl988QUOHDgAJycnqUMjIiIya5J2gg4JCUFqaioePXqE5ORkBAcHAwDatGkDa2trpKSkICAgAJs2bcLQoUOxefNmnDx5Et27d4ebmxv++OMPbNiwARs3blQ39TRt2hTvvvsu+vfvj/nz5+PZs2eYPXs25s+fDwcHBwmv1nCEEFizZg0+/vhjKBQKVKxYETt37kTLli2lDo2IiKhYkAkhhFQnf//99xEZGZlr+8GDB1GqVCmkpKSgW7duGhMdHjx4EHv27EFcXByqVq2KDz74AHXr1tXYPyMjAytWrMDx48chl8sRFBSEoKAgneNKSkqCq6srEhMTzbI5LDU1Fa+//joiIiLw9ttvY9OmTShdurTUYREREUlKn+9vSRMgc2XuCRAA/PPPPzh16hQmTpxo8ct8EBERAfp9fxfLeYAsjRAC3377LeRyOT788EMAL+c2KmjtNCIiItKOCZCZe/78OYYNG4ZffvkFdnZ2aN++vcXMZk1ERGQsTIDM2Pnz5xEUFIT79+/Dzs4OX3/9NapVqyZ1WERERMWeWQ+Dt1QqlQrffPMNWrdujfv378PPzw9nz57FuHHj2N+HiIjIAFgDZGaEEOjduzd++eUXAECfPn2wfv16s+2MTUREVByxBsjMyGQyNG3aFHK5HN999x127tzJ5IeIiMjAOAxeC1MPg1epVIiPj1fPZq1SqXDnzh1Ur17d6OcmIiIqKfT5/mYNkMRiY2Px5ptvIjAwUL2Gl5WVFZMfIiIiI2ICJKGTJ0+ifv36OHLkCO7evYuLFy9KHRIREZFFYAIkAaVSifnz5yMwMBDR0dGoVasWLly4gDfeeEPq0IiIiCwCR4GZWExMDAYMGIDjx48DeLke2ooVK+Do6ChxZERERJaDCZCJjR07FsePH4eDgwO+++47DBo0SOqQiIiILA4TIBNbtmwZnj17hlWrVqFWrVpSh0NERGSRmACZWIUKFdTNX0RERCQNdoImIiIii8MEiIiIiCwOEyAiIiKyOEyAiIiIyOIwASIiIiKLwwSIiIiILA4TICIiIrI4TICIiIjI4jABIiIiIovDBIiIiIgsDhMgIiIisjhMgIiIiMjiMAEiIiIii8MEiIiIiCyOjdQBmCMhBAAgKSlJ4kiIiIhIV9nf29nf4/lhAqRFcnIyAKBixYoSR0JERET6Sk5Ohqura75lZEKXNMnCqFQqPH78GM7OzpDJZAY9dlJSEipWrIiHDx/CxcXFoMcuaXivdMd7pTveK93xXumO90o/xrpfQggkJyejXLlysLLKv5cPa4C0sLKyQoUKFYx6DhcXF35IdMR7pTveK93xXumO90p3vFf6Mcb9KqjmJxs7QRMREZHFYQJEREREFocJkInJ5XLMmTMHcrlc6lDMHu+V7nivdMd7pTveK93xXunHHO4XO0ETERGRxWENEBEREVkcJkBERERkcZgAERERkcVhAmQCKpUKf/zxB3r16oXmzZsjMTFRp/12796N7t27IzAwEHPmzEFqaqqRIzUPx48fR58+fdCuXTtMnDgRsbGx+ZZfsGABmjdvrvHz/vvvmyha07hy5QqGDBmCtm3bYvjw4bh9+7ZR9ikJHj16hDFjxqBdu3bo168fzp49m2/5U6dO5Xp+mjdvjri4OBNFLJ34+HgsXrwYbdq0wfTp03XaJyEhAZ999hkCAgLwzjvvYP/+/UaO0jykpqZi/fr1aN++PQYMGFBgeaVSqfW52rdvnwmildaNGzcwceJEdOjQAX379sWePXsKXJpCCIENGzbgrbfeQocOHfDVV18hIyPDqHFyIkQTePfdd5GWloa6deti3759yMzMLHCfNWvW4OOPP8bixYtRvnx5zJkzB6dOncLx48cNPju1OTl8+DC6deuGmTNnYsiQIViyZAlat26NsLAwODg4aN0nIiICbm5umDt3rnqbk5OTiSI2vn///RetWrXCgAED8Nlnn2Hbtm1o0aIFQkNDUalSJYPtUxI8f/4cLVq0QIMGDfDpp58iODgY7dq1Q3BwMFq2bKl1n2fPnuHKlSs4fvy4xnZdJ1Mrru7du4dWrVqhb9++UCqVOiXIWVlZ6NChA2xtbTFt2jTcunULvXr1wo8//oi+ffuaIGrp+Pv7480334SbmxsuX75cYHkhBM6fP49Vq1ahYcOG6u1Vq1Y1ZpiSO336ND766CMMHz4c3bp1w61btzBixAhcvnwZn3/+eZ77zZ07F8uXL8eSJUvg7OyMTz/9FJcuXcLOnTuNF6wgo0tISBBCCHHw4EEBQMTFxeVbPjMzU5QuXVosWLBAve3ff/8VAMShQ4eMGqvUGjZsKIYMGaJ+nZiYKBwcHMTKlSvz3GfIkCFiwIABJohOGv379xfNmjVTv1YqlaJ69epi7NixBt2nJJg/f77w9PQUCoVCva1r166iQ4cOee6zb98+4ejoaIrwzEp6erpIT08XQgjRo0cP0bt37wL32b59u7C2thbR0dHqbRMmTBBVqlQxWpzmIvv/8alTp4o6deoUWD4zM1MAECdOnDByZOYlNTVVqFQqjW3ffPONcHJyEkqlUus+z58/F3K5XKxfv1697cSJEwKACAsLM1qsbAIzAX3/kgwLC8PTp0/x9ttvq7fVrFkT1atXx59//mno8MzG8+fPcenSJY3rdnFxQbt27Qq87jNnziAgIAC9e/fGt99+q1MtW3Fx7NgxjXtiZWWFbt265XtPCrNPSXDs2DF07twZdnZ26m09evTAyZMn830mFAoFunbtis6dO+OTTz5BdHS0KcKVlFwu13sOlmPHjqFJkybw9vZWb+vRowfu3buHiIgIQ4doVgpbIzhr1iwEBARg2LBhBTbHlgQODg65WimcnJyQmZkJlUqldZ+//voLCoVC4/+sN954A25ubkb9P4sJkBm6f/8+AKBcuXIa28uVK6d+ryR68OABAP2v28nJCYMGDcL06dPx1ltvYcmSJejUqVOeH7biRKFQ4MmTJ3rdk8LsU1Lcv39f63VnZmbmmdTIZDK8++67+OCDDzB69Ghcu3YNtWvXRmRkpClCLlbyur/Z75Gm+vXrY9iwYZg2bRo8PDzQtm1bbNmyReqwTOrFixdYunQpunXrBhsb7b1u7t+/D2tra3h5eam3WVlZwdvb26jPFfsAFcL777+Pf//9N8/35XI5Tp48WejjZ/+lmvOvs1KlShW7mo1Zs2bh6NGj+ZbZv38/PD09C33d33zzjcY+LVu2RO3atfHbb7+hZ8+ehQ/eDBTmnpSk50dfmZmZWq87+z1tunTpgh49eqhfd+vWDfXr18e8efOwefNmo8VaHBXm/loqGxsbnD9/Xl0b2alTJwDAxx9/jMGDB0sZmskolUoMHDgQL168wKpVq/Isl5mZCTs7u1w1R8b+P4sJUCFMnjwZKSkpeb5vZVW0ijUPDw8ALztnvrpK7tOnT/Haa68V6dimNmTIEHTt2jXfMtlVy69e96uePn2K0qVL57l/zv+Qa9WqhfLly+Py5cvFPgFydHSEXC7X654UZp+SwsPDQ+t1Z7+nTc7nx8bGBu3atcOZM2eME2Qxlt/9LenPVmG82hQLAB06dMA333yDqKgolC9fXqKoTEOpVGLw4MEICQlBcHAwypYtm2dZDw8PpKWlIT09Hfb29urtxv4/iwlQIdStW9eox69fvz6srKwQEhKCKlWqAHhZjXjt2rVi95dDtWrVUK1aNZ3KVqlSBR4eHggJCUGHDh3U2y9cuIBu3brpfM6MjAw8e/YMjo6OesdrbmQyGerXr4+QkBCN7efPn0eDBg0Mtk9J0bBhQ63XXaVKFbi7u+t8nJiYmBLx/Bhaw4YN8e2330KlUqn/0Dt//jzkcjlq1aolcXTmLyYmBjKZLM8RrSWFSqXCkCFDcPLkSQQHB8PPzy/f8tmj5EJCQtCmTRsAQHR0NB49emTc/7OM1r2acslvFNjw4cPFzJkz1a+7d+8umjRpIlJTU4UQQsydO1c4OzuL2NhYk8UrhY8//lhUrlxZxMTECCGE2Lp1q7CyshKXL19Wl5kzZ44YOnSoEEKI5ORk8c0334iMjAwhhBAZGRli7NixQi6Xizt37pj+Aoxg3bp1wsnJSVy5ckUIIcTZs2eFnZ2d2LNnj7rMpk2bREBAgF77lESnTp0SMplM/PHHH0IIISIjI4Wnp6fGiMrjx4+LZs2aqT9LK1eu1BjV9Ntvvwlra2uxYsUK0wYvobxGgd2+fVs0a9ZM/PPPP0KIl/dTLper783z589FzZo1NUZulnR5jQJTKBSiWbNmYu/evUIIIQ4cOCDOnj2rfv/u3buiWrVqonPnziaLVQpKpVIMGjRIlC9fXoSHh+dZrmfPnmLp0qXq182aNROdO3cWmZmZQgghPvzwQ+Hj46P+DjQGJkAm8O2334pmzZqJmjVrCgCiUaNGolmzZuL48ePqMs2aNRNBQUHq10+ePBEtWrQQLi4uonLlyqJMmTLq/9RLshcvXogePXqIUqVKiWrVqglHR0eNoZFCCDFgwADRqFEjIYQQWVlZ4rPPPhMeHh6ibt26wt3dXVSvXl0cPXpUivCNQqVSiXHjxgk7OztRvXp1IZfLxfTp0zXKLFiwQGMoty77lFRLliwRpUqVUl/3gAED1AmyEELs2bNHABAPHz4UQgixd+9e4efnJ/z9/UWVKlWEs7OzWLhwYa6hvCVRQECAaNasmXB3dxceHh7qL6FsoaGhuYZy79mzR7i6uoqqVasKR0dHERgYqB4iXpINHTpUNGvWTJQrV06UKlVKNGvWTDRr1kx97WlpaQKAWLNmjRBCiJs3b4rAwEDh7e0tateuLezs7ES/fv0KnAaluPv5558FAFGlShX1Pcr+efz4sbpc5cqVxYQJE9SvIyIiRN26dYWHh4coV66cqFChgkYCaQxcDd4EHjx4gMePH+faXr16dXW/hOvXr0Mul+dqLoqIiEBKSgpq1aqVqz25JHv06BHi4uJQvXr1XE0RERER6okls2VkZOD27dsoXbo0fHx8TB2uScTFxeHRo0eoXLlyrv4sUVFRePz4MZo0aaLzPiVZUlISIiIi4O3tnet5ePbsGW7fvo2GDRuqP1NCCERGRkKlUqFKlSp5jlYpaUJCQqBUKjW22draolGjRgBeNr1fuXIFtWvX1uiPmJaWhlu3bsHNzU3dTF/SXbt2TWvfz8aNG8PGxkY98WHVqlU1RjPFx8cjJiYGvr6+FtGs+vTpU4SHh2t9r0GDBuo+d6GhofDw8EDlypU1yty6dQsZGRmoVauW0T+HTICIiIjI4nAeICIiIrI4TICIiIjI4jABIiIiIovDBIiIiIgsDhMgIiIisjhMgIiIiMjiMAEiIiIii8MEiIiIiCwOEyAiIiKyOEyAiKjEy8zMxK5du3D79m2N7SdOnEBwcLA0QRGRpJgAEVGJZ2trizNnzuCtt95CcnIyAOD06dPo1KkTsrKyJI6OiKTAtcCIyCKkp6ejSZMmaNSoEZYtW4bXX38d7733Hr7++mupQyMiCTABIiKLcfXqVTRt2hT+/v6wtrbG+fPn1SvCE5FlYRMYEVmM1157DX369MHVq1fx1VdfMfkhsmCsASIii3Hx4kW0bNkS1apVg6enJ06cOAErK/4dSGSJ+MknIouQmpqKAQMG4IMPPsCxY8dw48YNfPnll1KHRUQSYQ0QEVmEkSNH4vTp07h06RJKlSqFX3/9Fe+99x7OnTuHRo0aSR0eEZkYa4CIqMS7d+8ekpOTsX37dpQqVQoA0KNHD8yfPx/79++XODoikgJrgIiIiMjisAaIiIiILA4TICIiIrI4TICIiIjI4jABIiIiIovDBIiIiIgsDhMgIiIisjhMgIiIiMjiMAEiIiIii8MEiIiIiCwOEyAiIiKyOEyAiIiIyOIwASIiIiKL83/bXOc1Wpm6IgAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.errorbar(\n", - " x,\n", - " y_exp,\n", - " y_stat_err,\n", - " marker=\"o\",\n", - " linestyle=\"none\",\n", - " label=\"experiment 1\",\n", - " color=\"tab:purple\",\n", - ")\n", - "plt.errorbar(\n", - " x2,\n", - " y_exp2,\n", - " y_stat_err2,\n", - " marker=\"o\",\n", - " linestyle=\"none\",\n", - " label=\"experiment 2\",\n", - " color=\"tab:cyan\",\n", - ")\n", - "\n", - "plt.plot(x_full, y_true_full, \"k--\", label=\"truth\")\n", - "plt.xlabel(\"x\")\n", - "plt.ylabel(\"y\")\n", - "plt.legend()\n", - "plt.title(\"multiple experimental constraint with opposite bias\")" - ] - }, - { - "cell_type": "code", - "execution_count": 52, - "id": "87e72ee0-7265-4bee-99ae-38f88f56ac3a", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:09:40.720200Z", - "iopub.status.busy": "2026-08-11T03:09:40.720056Z", - "iopub.status.idle": "2026-08-11T03:09:40.723567Z", - "shell.execute_reply": "2026-08-11T03:09:40.722970Z" - } - }, - "outputs": [], - "source": [ - "# 1 and 2\n", - "obs_stat_only2 = rxmc.observation.Observation(x=x2, y=y_exp2, y_stat_err=y_stat_err2)\n", - "obs_unknown_stat2 = rxmc.observation.Observation(x=x2, y=y_exp2)\n", - "\n", - "# 3\n", - "obs_sys_norm_correct2 = rxmc.observation.Observation(\n", - " x=x2, y=y_exp2, y_stat_err=y_stat_err2\n", - ")\n", - "\n", - "# 4\n", - "obs_sys_norm_wrong2 = rxmc.observation.Observation(x=x2, y=y_exp2)\n", - "wrong_cov2 = np.diag(y_stat_err2**2) + systematic_fractional_err2**2 * np.outer(\n", - " y_exp2, y_exp2\n", - ")" - ] - }, - { - "cell_type": "markdown", - "id": "31130c87-281b-461f-bbba-12e10af0dc0f", - "metadata": {}, - "source": [ - "## set up likelihood models and constraints" - ] - }, - { - "cell_type": "code", - "execution_count": 53, - "id": "2d1be262-56ab-4c30-b39f-b4ee2ced788e", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:09:40.724958Z", - "iopub.status.busy": "2026-08-11T03:09:40.724799Z", - "iopub.status.idle": "2026-08-11T03:09:40.729780Z", - "shell.execute_reply": "2026-08-11T03:09:40.729184Z" - } - }, - "outputs": [], - "source": [ - "N1 = obs_stat_only.n_data_pts\n", - "N2 = obs_stat_only2.n_data_pts\n", - "s1 = np.arange(N1)\n", - "s2 = np.arange(N1, N1 + N2)\n", - "\n", - "# 1\n", - "evidence_stat_only = rxmc.evidence.Evidence(\n", - " [rxmc.constraint.Constraint([obs_stat_only, obs_stat_only2], my_model, likelihood)]\n", - ")\n", - "\n", - "# 2 (shared noise-fraction parameter across both datasets -> case B)\n", - "evidence_unknown_stat = rxmc.evidence.Evidence(\n", - " [\n", - " rxmc.constraint.Constraint(\n", - " [obs_unknown_stat, obs_unknown_stat2],\n", - " my_model,\n", - " extra_terms=[\n", - " rxmc.covariance.noise_fraction_term(log_noise_fraction, support=s1),\n", - " rxmc.covariance.noise_fraction_term(log_noise_fraction, support=s2),\n", - " ],\n", - " )\n", - " ]\n", - ")\n", - "\n", - "# 3\n", - "evidence_sys_correct = rxmc.evidence.Evidence(\n", - " [\n", - " rxmc.constraint.Constraint(\n", - " [obs_sys_norm_correct, obs_sys_norm_correct2],\n", - " my_model,\n", - " extra_terms=[\n", - " rxmc.covariance.normalization_term(\n", - " magnitude=systematic_fractional_err,\n", - " support=s1,\n", - " ),\n", - " rxmc.covariance.normalization_term(\n", - " magnitude=systematic_fractional_err2,\n", - " support=s2,\n", - " ),\n", - " ],\n", - " )\n", - " ]\n", - ")\n", - "\n", - "# 4\n", - "evidence_sys_wrong = rxmc.evidence.Evidence(\n", - " [\n", - " rxmc.constraint.Constraint(\n", - " [obs_sys_norm_wrong, obs_sys_norm_wrong2],\n", - " my_model,\n", - " extra_terms=[\n", - " rxmc.covariance.Term(wrong_cov, support=s1),\n", - " rxmc.covariance.Term(wrong_cov2, support=s2),\n", - " ],\n", - " )\n", - " ]\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 54, - "id": "2f0f6a89-f6c8-4306-bec5-95257ab685e2", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:09:40.731148Z", - "iopub.status.busy": "2026-08-11T03:09:40.731020Z", - "iopub.status.idle": "2026-08-11T03:09:40.733637Z", - "shell.execute_reply": "2026-08-11T03:09:40.732868Z" - } - }, - "outputs": [], - "source": [ - "walker1 = rxmc.walker.Walker(\n", - " model_sampler=rxmc.param_sampling.MetropolisHastingsSampler(\n", - " params=my_model.params,\n", - " starting_location=prior_distribution.mean,\n", - " proposal=proposal_distribution_model,\n", - " prior=prior_distribution,\n", - " ),\n", - " evidence=evidence_stat_only,\n", - " rng=rng,\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 55, - "id": "d56972b8-c1ca-4e24-b18b-18661e5c1230", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:09:40.734879Z", - "iopub.status.busy": "2026-08-11T03:09:40.734763Z", - "iopub.status.idle": "2026-08-11T03:09:44.461818Z", - "shell.execute_reply": "2026-08-11T03:09:44.461059Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Burn-in batch 1/1 completed, 1000 steps.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 1/1 completed, 10000 steps. \n", - " Model parameter acceptance fraction: 0.151\n", - "CPU times: user 3.72 s, sys: 18.9 ms, total: 3.74 s\n", - "Wall time: 3.72 s\n" - ] - } - ], - "source": [ - "%%time\n", - "walker1.walk(n_steps=10000, burnin=1000)" - ] - }, - { - "cell_type": "code", - "execution_count": 56, - "id": "756f57d6-b493-4cde-adda-599fc6a34c95", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:09:44.463328Z", - "iopub.status.busy": "2026-08-11T03:09:44.463156Z", - "iopub.status.idle": "2026-08-11T03:09:44.515567Z", - "shell.execute_reply": "2026-08-11T03:09:44.514991Z" - } - }, - "outputs": [], - "source": [ - "upper1, med1, lower1 = np.percentile(\n", - " [my_model.y(x_full, *p) for p in walker1.model_sampler.chain],\n", - " [5, 50, 95],\n", - " axis=0,\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 57, - "id": "18cb26c9-6240-4c58-a157-eaa97eaa1bfd", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:09:44.517091Z", - "iopub.status.busy": "2026-08-11T03:09:44.516956Z", - "iopub.status.idle": "2026-08-11T03:09:44.520148Z", - "shell.execute_reply": "2026-08-11T03:09:44.519511Z" - } - }, - "outputs": [], - "source": [ - "walker2 = rxmc.walker.Walker(\n", - " model_sampler=rxmc.param_sampling.MetropolisHastingsSampler(\n", - " params=my_model.params,\n", - " starting_location=prior_distribution.mean,\n", - " proposal=proposal_distribution_model,\n", - " prior=prior_distribution,\n", - " ),\n", - " evidence=evidence_unknown_stat,\n", - " likelihood_samplers=[\n", - " rxmc.param_sampling.MetropolisHastingsSampler(\n", - " params=[log_noise_fraction],\n", - " starting_location=noise_prior.mean(),\n", - " proposal=proposal_distribution_noise,\n", - " prior=noise_prior,\n", - " )\n", - " ],\n", - " rng=rng,\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 58, - "id": "6326cf53-4e85-428c-9a22-50e377b4d8b0", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:09:44.521481Z", - "iopub.status.busy": "2026-08-11T03:09:44.521362Z", - "iopub.status.idle": "2026-08-11T03:09:54.296171Z", - "shell.execute_reply": "2026-08-11T03:09:54.295520Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Burn-in batch 1/10 completed, 100 steps.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Burn-in batch 2/10 completed, 100 steps.\n", - "Burn-in batch 3/10 completed, 100 steps.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Burn-in batch 4/10 completed, 100 steps.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Burn-in batch 5/10 completed, 100 steps.\n", - "Burn-in batch 6/10 completed, 100 steps.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Burn-in batch 7/10 completed, 100 steps.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Burn-in batch 8/10 completed, 100 steps.\n", - "Burn-in batch 9/10 completed, 100 steps.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Burn-in batch 10/10 completed, 100 steps.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 1/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.530\n", - " Likelihood parameter acceptance fractions: [0.67]\n", - "Batch: 2/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.530\n", - " Likelihood parameter acceptance fractions: [0.75]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 3/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.530\n", - " Likelihood parameter acceptance fractions: [0.75]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 4/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.530\n", - " Likelihood parameter acceptance fractions: [0.67]\n", - "Batch: 5/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.460\n", - " Likelihood parameter acceptance fractions: [0.81]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 6/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.480\n", - " Likelihood parameter acceptance fractions: [0.69]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 7/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.510\n", - " Likelihood parameter acceptance fractions: [0.75]\n", - "Batch: 8/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.500\n", - " Likelihood parameter acceptance fractions: [0.69]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 9/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.490\n", - " Likelihood parameter acceptance fractions: [0.75]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 10/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.350\n", - " Likelihood parameter acceptance fractions: [0.66]\n", - "Batch: 11/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.500\n", - " Likelihood parameter acceptance fractions: [0.74]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 12/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.380\n", - " Likelihood parameter acceptance fractions: [0.62]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 13/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.480\n", - " Likelihood parameter acceptance fractions: [0.77]\n", - "Batch: 14/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.440\n", - " Likelihood parameter acceptance fractions: [0.73]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 15/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.470\n", - " Likelihood parameter acceptance fractions: [0.78]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 16/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.480\n", - " Likelihood parameter acceptance fractions: [0.73]\n", - "Batch: 17/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.510\n", - " Likelihood parameter acceptance fractions: [0.77]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 18/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.480\n", - " Likelihood parameter acceptance fractions: [0.77]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 19/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.480\n", - " Likelihood parameter acceptance fractions: [0.7]\n", - "Batch: 20/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.520\n", - " Likelihood parameter acceptance fractions: [0.77]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 21/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.520\n", - " Likelihood parameter acceptance fractions: [0.75]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 22/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.440\n", - " Likelihood parameter acceptance fractions: [0.71]\n", - "Batch: 23/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.410\n", - " Likelihood parameter acceptance fractions: [0.74]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 24/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.280\n", - " Likelihood parameter acceptance fractions: [0.83]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 25/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.480\n", - " Likelihood parameter acceptance fractions: [0.78]\n", - "Batch: 26/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.420\n", - " Likelihood parameter acceptance fractions: [0.71]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 27/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.570\n", - " Likelihood parameter acceptance fractions: [0.73]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 28/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.530\n", - " Likelihood parameter acceptance fractions: [0.69]\n", - "Batch: 29/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.510\n", - " Likelihood parameter acceptance fractions: [0.69]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 30/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.230\n", - " Likelihood parameter acceptance fractions: [0.79]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 31/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.430\n", - " Likelihood parameter acceptance fractions: [0.81]\n", - "Batch: 32/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.560\n", - " Likelihood parameter acceptance fractions: [0.75]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 33/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.430\n", - " Likelihood parameter acceptance fractions: [0.74]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 34/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.560\n", - " Likelihood parameter acceptance fractions: [0.71]\n", - "Batch: 35/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.320\n", - " Likelihood parameter acceptance fractions: [0.74]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 36/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.410\n", - " Likelihood parameter acceptance fractions: [0.65]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 37/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.400\n", - " Likelihood parameter acceptance fractions: [0.69]\n", - "Batch: 38/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.620\n", - " Likelihood parameter acceptance fractions: [0.8]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 39/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.570\n", - " Likelihood parameter acceptance fractions: [0.76]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 40/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.490\n", - " Likelihood parameter acceptance fractions: [0.64]\n", - "Batch: 41/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.480\n", - " Likelihood parameter acceptance fractions: [0.75]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 42/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.470\n", - " Likelihood parameter acceptance fractions: [0.74]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 43/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.430\n", - " Likelihood parameter acceptance fractions: [0.81]\n", - "Batch: 44/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.480\n", - " Likelihood parameter acceptance fractions: [0.75]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 45/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.450\n", - " Likelihood parameter acceptance fractions: [0.8]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 46/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.460\n", - " Likelihood parameter acceptance fractions: [0.7]\n", - "Batch: 47/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.460\n", - " Likelihood parameter acceptance fractions: [0.74]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 48/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.480\n", - " Likelihood parameter acceptance fractions: [0.78]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 49/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.370\n", - " Likelihood parameter acceptance fractions: [0.73]\n", - "Batch: 50/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.360\n", - " Likelihood parameter acceptance fractions: [0.77]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 51/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.480\n", - " Likelihood parameter acceptance fractions: [0.72]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 52/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.500\n", - " Likelihood parameter acceptance fractions: [0.77]\n", - "Batch: 53/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.450\n", - " Likelihood parameter acceptance fractions: [0.78]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 54/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.550\n", - " Likelihood parameter acceptance fractions: [0.75]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 55/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.440\n", - " Likelihood parameter acceptance fractions: [0.7]\n", - "Batch: 56/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.380\n", - " Likelihood parameter acceptance fractions: [0.71]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 57/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.390\n", - " Likelihood parameter acceptance fractions: [0.73]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 58/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.400\n", - " Likelihood parameter acceptance fractions: [0.77]\n", - "Batch: 59/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.510\n", - " Likelihood parameter acceptance fractions: [0.65]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 60/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.460\n", - " Likelihood parameter acceptance fractions: [0.75]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 61/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.340\n", - " Likelihood parameter acceptance fractions: [0.71]\n", - "Batch: 62/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.440\n", - " Likelihood parameter acceptance fractions: [0.75]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 63/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.290\n", - " Likelihood parameter acceptance fractions: [0.68]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 64/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.460\n", - " Likelihood parameter acceptance fractions: [0.71]\n", - "Batch: 65/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.460\n", - " Likelihood parameter acceptance fractions: [0.67]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 66/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.400\n", - " Likelihood parameter acceptance fractions: [0.75]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 67/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.440\n", - " Likelihood parameter acceptance fractions: [0.72]\n", - "Batch: 68/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.560\n", - " Likelihood parameter acceptance fractions: [0.69]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 69/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.440\n", - " Likelihood parameter acceptance fractions: [0.72]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 70/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.540\n", - " Likelihood parameter acceptance fractions: [0.8]\n", - "Batch: 71/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.420\n", - " Likelihood parameter acceptance fractions: [0.68]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 72/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.360\n", - " Likelihood parameter acceptance fractions: [0.77]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 73/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.510\n", - " Likelihood parameter acceptance fractions: [0.74]\n", - "Batch: 74/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.510\n", - " Likelihood parameter acceptance fractions: [0.74]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 75/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.410\n", - " Likelihood parameter acceptance fractions: [0.71]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 76/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.390\n", - " Likelihood parameter acceptance fractions: [0.72]\n", - "Batch: 77/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.410\n", - " Likelihood parameter acceptance fractions: [0.67]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 78/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.420\n", - " Likelihood parameter acceptance fractions: [0.67]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 79/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.440\n", - " Likelihood parameter acceptance fractions: [0.69]\n", - "Batch: 80/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.460\n", - " Likelihood parameter acceptance fractions: [0.77]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 81/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.370\n", - " Likelihood parameter acceptance fractions: [0.72]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 82/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.470\n", - " Likelihood parameter acceptance fractions: [0.78]\n", - "Batch: 83/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.530\n", - " Likelihood parameter acceptance fractions: [0.76]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 84/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.460\n", - " Likelihood parameter acceptance fractions: [0.79]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 85/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.580\n", - " Likelihood parameter acceptance fractions: [0.66]\n", - "Batch: 86/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.500\n", - " Likelihood parameter acceptance fractions: [0.74]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 87/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.370\n", - " Likelihood parameter acceptance fractions: [0.68]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 88/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.510\n", - " Likelihood parameter acceptance fractions: [0.73]\n", - "Batch: 89/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.430\n", - " Likelihood parameter acceptance fractions: [0.75]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 90/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.540\n", - " Likelihood parameter acceptance fractions: [0.72]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 91/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.500\n", - " Likelihood parameter acceptance fractions: [0.72]\n", - "Batch: 92/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.510\n", - " Likelihood parameter acceptance fractions: [0.71]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 93/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.390\n", - " Likelihood parameter acceptance fractions: [0.75]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 94/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.400\n", - " Likelihood parameter acceptance fractions: [0.73]\n", - "Batch: 95/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.380\n", - " Likelihood parameter acceptance fractions: [0.76]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 96/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.550\n", - " Likelihood parameter acceptance fractions: [0.72]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 97/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.430\n", - " Likelihood parameter acceptance fractions: [0.72]\n", - "Batch: 98/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.350\n", - " Likelihood parameter acceptance fractions: [0.61]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 99/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.420\n", - " Likelihood parameter acceptance fractions: [0.72]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 100/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.610\n", - " Likelihood parameter acceptance fractions: [0.73]\n", - "CPU times: user 9.78 s, sys: 10.8 ms, total: 9.79 s\n", - "Wall time: 9.77 s\n" - ] - } - ], - "source": [ - "%%time\n", - "walker2.walk(\n", - " n_steps=10000,\n", - " burnin=1000,\n", - " batch_size=100,\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 59, - "id": "e05be7bb-9dbf-4b3e-989e-4e585d6af958", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:09:54.297672Z", - "iopub.status.busy": "2026-08-11T03:09:54.297537Z", - "iopub.status.idle": "2026-08-11T03:09:54.351090Z", - "shell.execute_reply": "2026-08-11T03:09:54.350419Z" - } - }, - "outputs": [], - "source": [ - "upper2, med2, lower2 = np.percentile(\n", - " [my_model.y(x_full, *p) for p in walker2.model_sampler.chain],\n", - " [5, 50, 95],\n", - " axis=0,\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 60, - "id": "46043bca-0a01-45b3-b404-33be8cf82dbf", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:09:54.352464Z", - "iopub.status.busy": "2026-08-11T03:09:54.352340Z", - "iopub.status.idle": "2026-08-11T03:09:54.355183Z", - "shell.execute_reply": "2026-08-11T03:09:54.354366Z" - } - }, - "outputs": [], - "source": [ - "walker3 = rxmc.walker.Walker(\n", - " model_sampler=rxmc.param_sampling.MetropolisHastingsSampler(\n", - " params=my_model.params,\n", - " starting_location=prior_distribution.mean,\n", - " proposal=proposal_distribution_model,\n", - " prior=prior_distribution,\n", - " ),\n", - " evidence=evidence_sys_correct,\n", - " rng=rng,\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 61, - "id": "4d0484c6-2cac-4205-9e7a-524dc2c0df26", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:09:54.356461Z", - "iopub.status.busy": "2026-08-11T03:09:54.356343Z", - "iopub.status.idle": "2026-08-11T03:09:59.757763Z", - "shell.execute_reply": "2026-08-11T03:09:59.757135Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Burn-in batch 1/1 completed, 1000 steps.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 1/1 completed, 10000 steps. \n", - " Model parameter acceptance fraction: 0.592\n", - "CPU times: user 5.4 s, sys: 841 μs, total: 5.4 s\n", - "Wall time: 5.4 s\n" - ] - } - ], - "source": [ - "%%time\n", - "walker3.walk(n_steps=10000, burnin=1000)" - ] - }, - { - "cell_type": "code", - "execution_count": 62, - "id": "4ecd35ac-5852-4a02-91a3-d149b9f5dea6", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:09:59.759151Z", - "iopub.status.busy": "2026-08-11T03:09:59.758999Z", - "iopub.status.idle": "2026-08-11T03:09:59.810849Z", - "shell.execute_reply": "2026-08-11T03:09:59.809999Z" - } - }, - "outputs": [], - "source": [ - "upper3, med3, lower3 = np.percentile(\n", - " [my_model.y(x_full, *p) for p in walker3.model_sampler.chain],\n", - " [5, 50, 95],\n", - " axis=0,\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 63, - "id": "dbf399dd-c2b7-49fb-898e-ee5994b6f086", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:09:59.812312Z", - "iopub.status.busy": "2026-08-11T03:09:59.812170Z", - "iopub.status.idle": "2026-08-11T03:09:59.814898Z", - "shell.execute_reply": "2026-08-11T03:09:59.814223Z" - } - }, - "outputs": [], - "source": [ - "walker4 = rxmc.walker.Walker(\n", - " model_sampler=rxmc.param_sampling.MetropolisHastingsSampler(\n", - " params=my_model.params,\n", - " starting_location=prior_distribution.mean,\n", - " proposal=proposal_distribution_model,\n", - " prior=prior_distribution,\n", - " ),\n", - " evidence=evidence_sys_wrong,\n", - " rng=rng,\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 64, - "id": "ced1d78c-42b4-474c-84ca-e5d54d2c0f15", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:09:59.816292Z", - "iopub.status.busy": "2026-08-11T03:09:59.816155Z", - "iopub.status.idle": "2026-08-11T03:10:03.452356Z", - "shell.execute_reply": "2026-08-11T03:10:03.451766Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Burn-in batch 1/1 completed, 1000 steps.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 1/1 completed, 10000 steps. \n", - " Model parameter acceptance fraction: 0.578\n", - "CPU times: user 3.63 s, sys: 30.1 ms, total: 3.66 s\n", - "Wall time: 3.63 s\n" - ] - } - ], - "source": [ - "%%time\n", - "walker4.walk(n_steps=10000, burnin=1000)" - ] - }, - { - "cell_type": "code", - "execution_count": 65, - "id": "8670fc09-6a92-4231-ae5f-2710836d736d", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:10:03.453827Z", - "iopub.status.busy": "2026-08-11T03:10:03.453695Z", - "iopub.status.idle": "2026-08-11T03:10:03.505158Z", - "shell.execute_reply": "2026-08-11T03:10:03.504394Z" - } - }, - "outputs": [], - "source": [ - "upper4, med4, lower4 = np.percentile(\n", - " [my_model.y(x_full, *p) for p in walker4.model_sampler.chain],\n", - " [5, 50, 95],\n", - " axis=0,\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 66, - "id": "92988fb9-05bc-4223-8ae0-e7f620047ca7", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:10:03.506585Z", - "iopub.status.busy": "2026-08-11T03:10:03.506407Z", - "iopub.status.idle": "2026-08-11T03:10:03.709366Z", - "shell.execute_reply": "2026-08-11T03:10:03.708598Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 1.0, 'multiple constraints with systematic normalization error')" - ] - }, - "execution_count": 66, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.errorbar(\n", - " x,\n", - " y_exp,\n", - " y_stat_err,\n", - " marker=\".\",\n", - " linestyle=\"none\",\n", - " label=\"experiment 1\",\n", - " color=\"tab:purple\",\n", - " zorder=999,\n", - ")\n", - "plt.errorbar(\n", - " x2,\n", - " y_exp2,\n", - " y_stat_err2,\n", - " marker=\".\",\n", - " linestyle=\"none\",\n", - " label=\"experiment 2\",\n", - " color=\"tab:cyan\",\n", - " zorder=999,\n", - ")\n", - "p = plt.fill_between(x_full, lower1, upper1, label=\"stat only\", alpha=0.5, zorder=99)\n", - "plt.plot(x_full, med1, \"--\", color=p.get_facecolor(), alpha=1, zorder=100)\n", - "\n", - "\n", - "p = plt.fill_between(x_full, lower2, upper2, label=\"stat fit\", alpha=0.5, zorder=89)\n", - "plt.plot(x_full, med2, \"--\", color=p.get_facecolor(), alpha=1, zorder=90)\n", - "\n", - "\n", - "p = plt.fill_between(x_full, lower3, upper3, label=\"full covariance\", alpha=0.5)\n", - "plt.plot(x_full, med3, \"--\", color=p.get_facecolor(), alpha=1, zorder=89)\n", - "\n", - "p = plt.fill_between(x_full, lower4, upper4, label=\"full covariance, wrong\", alpha=0.25)\n", - "plt.plot(x_full, med4, \"--\", color=p.get_facecolor(), alpha=0.5)\n", - "\n", - "\n", - "plt.plot(x_full, y_true_full, \"k--\", label=\"truth\", zorder=999)\n", - "plt.xlabel(\"x\")\n", - "plt.ylabel(\"y\")\n", - "plt.legend()\n", - "plt.title(\"multiple constraints with systematic normalization error\")" - ] - }, - { - "cell_type": "markdown", - "id": "2ad6cfa0-f9f7-4b5a-bdab-af56cffc1627", - "metadata": {}, - "source": [ - "# Multiple constraints with offset domain\n", - "Let's choose a second constraint, with the same normalization bias in the opposite direction and slightly different coverage opver $x$." - ] - }, - { - "cell_type": "code", - "execution_count": 67, - "id": "48e2d2b2-6199-49e3-a312-df82a796a3c0", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:10:03.710718Z", - "iopub.status.busy": "2026-08-11T03:10:03.710576Z", - "iopub.status.idle": "2026-08-11T03:10:03.714021Z", - "shell.execute_reply": "2026-08-11T03:10:03.713230Z" - } - }, - "outputs": [], - "source": [ - "x2 = np.linspace(0.6, 1.4, 27, dtype=float)\n", - "y_true2 = my_model.y(x2, *list(true_params.values()))\n", - "y_exp2 = (y_true2 + rng.normal(scale=noise_fraction2 * y_true2, size=len(x2))) * N2\n", - "y_stat_err2 = noise_fraction2 * y_exp2 * N2" - ] - }, - { - "cell_type": "code", - "execution_count": 68, - "id": "55153cf1-0153-443f-8e94-7b0cbf9fbab0", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:10:03.715216Z", - "iopub.status.busy": "2026-08-11T03:10:03.715094Z", - "iopub.status.idle": "2026-08-11T03:10:03.891635Z", - "shell.execute_reply": "2026-08-11T03:10:03.891086Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 1.0, '$x$-offset experimental constraint with opposite bias')" - ] - }, - "execution_count": 68, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.errorbar(\n", - " x,\n", - " y_exp,\n", - " y_stat_err,\n", - " marker=\"o\",\n", - " linestyle=\"none\",\n", - " label=\"experiment 1\",\n", - " color=\"tab:purple\",\n", - ")\n", - "plt.errorbar(\n", - " x2,\n", - " y_exp2,\n", - " y_stat_err2,\n", - " marker=\"o\",\n", - " linestyle=\"none\",\n", - " label=\"experiment 2\",\n", - " color=\"tab:cyan\",\n", - ")\n", - "\n", - "plt.plot(x_full, y_true_full, \"k--\", label=\"truth\")\n", - "plt.xlabel(\"x\")\n", - "plt.ylabel(\"y\")\n", - "plt.legend()\n", - "plt.title(\"$x$-offset experimental constraint with opposite bias\")" - ] - }, - { - "cell_type": "code", - "execution_count": 69, - "id": "bb633a19-afb3-413e-b57b-2c489ca0c382", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:10:03.893160Z", - "iopub.status.busy": "2026-08-11T03:10:03.893032Z", - "iopub.status.idle": "2026-08-11T03:10:03.896205Z", - "shell.execute_reply": "2026-08-11T03:10:03.895687Z" - } - }, - "outputs": [], - "source": [ - "# 1 and 2\n", - "obs_stat_only2 = rxmc.observation.Observation(x=x2, y=y_exp2, y_stat_err=y_stat_err2)\n", - "obs_unknown_stat2 = rxmc.observation.Observation(x=x2, y=y_exp2)\n", - "\n", - "# 3\n", - "obs_sys_norm_correct2 = rxmc.observation.Observation(\n", - " x=x2, y=y_exp2, y_stat_err=y_stat_err2\n", - ")\n", - "\n", - "# 4\n", - "obs_sys_norm_wrong2 = rxmc.observation.Observation(x=x2, y=y_exp2)\n", - "wrong_cov2 = np.diag(y_stat_err2**2) + systematic_fractional_err2**2 * np.outer(\n", - " y_exp2, y_exp2\n", - ")" - ] - }, - { - "cell_type": "markdown", - "id": "6e459fb6-f7bc-4447-997d-05569bcc45ad", - "metadata": {}, - "source": [ - "## set up likelihood models and constraints" - ] - }, - { - "cell_type": "code", - "execution_count": 70, - "id": "38796171-1781-4044-82b1-1592abeaed4f", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:10:03.897627Z", - "iopub.status.busy": "2026-08-11T03:10:03.897509Z", - "iopub.status.idle": "2026-08-11T03:10:03.902733Z", - "shell.execute_reply": "2026-08-11T03:10:03.902059Z" - } - }, - "outputs": [], - "source": [ - "N1 = obs_stat_only.n_data_pts\n", - "N2 = obs_stat_only2.n_data_pts\n", - "s1 = np.arange(N1)\n", - "s2 = np.arange(N1, N1 + N2)\n", - "\n", - "# 1\n", - "evidence_stat_only = rxmc.evidence.Evidence(\n", - " [rxmc.constraint.Constraint([obs_stat_only, obs_stat_only2], my_model, likelihood)]\n", - ")\n", - "\n", - "# 2 (shared noise-fraction parameter across both datasets -> case B)\n", - "evidence_unknown_stat = rxmc.evidence.Evidence(\n", - " [\n", - " rxmc.constraint.Constraint(\n", - " [obs_unknown_stat, obs_unknown_stat2],\n", - " my_model,\n", - " extra_terms=[\n", - " rxmc.covariance.noise_fraction_term(log_noise_fraction, support=s1),\n", - " rxmc.covariance.noise_fraction_term(log_noise_fraction, support=s2),\n", - " ],\n", - " )\n", - " ]\n", - ")\n", - "\n", - "# 3\n", - "evidence_sys_correct = rxmc.evidence.Evidence(\n", - " [\n", - " rxmc.constraint.Constraint(\n", - " [obs_sys_norm_correct, obs_sys_norm_correct2],\n", - " my_model,\n", - " extra_terms=[\n", - " rxmc.covariance.normalization_term(\n", - " magnitude=systematic_fractional_err,\n", - " support=s1,\n", - " ),\n", - " rxmc.covariance.normalization_term(\n", - " magnitude=systematic_fractional_err2,\n", - " support=s2,\n", - " ),\n", - " ],\n", - " )\n", - " ]\n", - ")\n", - "\n", - "# 4\n", - "evidence_sys_wrong = rxmc.evidence.Evidence(\n", - " [\n", - " rxmc.constraint.Constraint(\n", - " [obs_sys_norm_wrong, obs_sys_norm_wrong2],\n", - " my_model,\n", - " extra_terms=[\n", - " rxmc.covariance.Term(wrong_cov, support=s1),\n", - " rxmc.covariance.Term(wrong_cov2, support=s2),\n", - " ],\n", - " )\n", - " ]\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 71, - "id": "a1ea1e11-1b1f-44c2-9218-dce25f613a18", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:10:03.904075Z", - "iopub.status.busy": "2026-08-11T03:10:03.903959Z", - "iopub.status.idle": "2026-08-11T03:10:03.906384Z", - "shell.execute_reply": "2026-08-11T03:10:03.905825Z" - } - }, - "outputs": [], - "source": [ - "walker1 = rxmc.walker.Walker(\n", - " model_sampler=rxmc.param_sampling.MetropolisHastingsSampler(\n", - " params=my_model.params,\n", - " starting_location=prior_distribution.mean,\n", - " proposal=proposal_distribution_model,\n", - " prior=prior_distribution,\n", - " ),\n", - " evidence=evidence_stat_only,\n", - " rng=rng,\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 72, - "id": "e2cd9f71-2395-4ee8-84ed-a0ad4b6abc37", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:10:03.907639Z", - "iopub.status.busy": "2026-08-11T03:10:03.907525Z", - "iopub.status.idle": "2026-08-11T03:10:07.489591Z", - "shell.execute_reply": "2026-08-11T03:10:07.488800Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Burn-in batch 1/1 completed, 1000 steps.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 1/1 completed, 10000 steps. \n", - " Model parameter acceptance fraction: 0.331\n", - "CPU times: user 3.58 s, sys: 16 ms, total: 3.6 s\n", - "Wall time: 3.58 s\n" - ] - } - ], - "source": [ - "%%time\n", - "walker1.walk(n_steps=10000, burnin=1000)" - ] - }, - { - "cell_type": "code", - "execution_count": 73, - "id": "a939e980-1479-4619-b7d1-507a5c1ce3f9", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:10:07.490910Z", - "iopub.status.busy": "2026-08-11T03:10:07.490749Z", - "iopub.status.idle": "2026-08-11T03:10:07.540105Z", - "shell.execute_reply": "2026-08-11T03:10:07.539346Z" - } - }, - "outputs": [], - "source": [ - "upper1, med1, lower1 = np.percentile(\n", - " [my_model.y(x_full, *p) for p in walker1.model_sampler.chain],\n", - " [5, 50, 95],\n", - " axis=0,\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 74, - "id": "309bae03-b150-454b-86cb-a1c3e42fb1ad", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:10:07.541679Z", - "iopub.status.busy": "2026-08-11T03:10:07.541511Z", - "iopub.status.idle": "2026-08-11T03:10:07.544922Z", - "shell.execute_reply": "2026-08-11T03:10:07.544100Z" - } - }, - "outputs": [], - "source": [ - "walker2 = rxmc.walker.Walker(\n", - " model_sampler=rxmc.param_sampling.MetropolisHastingsSampler(\n", - " params=my_model.params,\n", - " starting_location=prior_distribution.mean,\n", - " proposal=proposal_distribution_model,\n", - " prior=prior_distribution,\n", - " ),\n", - " evidence=evidence_unknown_stat,\n", - " likelihood_samplers=[\n", - " rxmc.param_sampling.MetropolisHastingsSampler(\n", - " params=[log_noise_fraction],\n", - " starting_location=noise_prior.mean(),\n", - " proposal=proposal_distribution_noise,\n", - " prior=noise_prior,\n", - " )\n", - " ],\n", - " rng=rng,\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 75, - "id": "3ab21666-0ffb-4692-a3ac-ef8e588bd2b7", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:10:07.546286Z", - "iopub.status.busy": "2026-08-11T03:10:07.546127Z", - "iopub.status.idle": "2026-08-11T03:10:17.201635Z", - "shell.execute_reply": "2026-08-11T03:10:17.201079Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Burn-in batch 1/10 completed, 100 steps.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Burn-in batch 2/10 completed, 100 steps.\n", - "Burn-in batch 3/10 completed, 100 steps.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Burn-in batch 4/10 completed, 100 steps.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Burn-in batch 5/10 completed, 100 steps.\n", - "Burn-in batch 6/10 completed, 100 steps.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Burn-in batch 7/10 completed, 100 steps.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Burn-in batch 8/10 completed, 100 steps.\n", - "Burn-in batch 9/10 completed, 100 steps.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Burn-in batch 10/10 completed, 100 steps.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 1/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 1.000\n", - " Likelihood parameter acceptance fractions: [0.83]\n", - "Batch: 2/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.940\n", - " Likelihood parameter acceptance fractions: [0.76]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 3/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 1.000\n", - " Likelihood parameter acceptance fractions: [0.71]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 4/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.950\n", - " Likelihood parameter acceptance fractions: [0.69]\n", - "Batch: 5/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.950\n", - " Likelihood parameter acceptance fractions: [0.79]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 6/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.950\n", - " Likelihood parameter acceptance fractions: [0.8]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 7/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.970\n", - " Likelihood parameter acceptance fractions: [0.75]\n", - "Batch: 8/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.980\n", - " Likelihood parameter acceptance fractions: [0.73]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 9/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.970\n", - " Likelihood parameter acceptance fractions: [0.74]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 10/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.910\n", - " Likelihood parameter acceptance fractions: [0.7]\n", - "Batch: 11/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.950\n", - " Likelihood parameter acceptance fractions: [0.73]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 12/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.960\n", - " Likelihood parameter acceptance fractions: [0.72]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 13/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.990\n", - " Likelihood parameter acceptance fractions: [0.67]\n", - "Batch: 14/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.990\n", - " Likelihood parameter acceptance fractions: [0.71]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 15/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 1.000\n", - " Likelihood parameter acceptance fractions: [0.72]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 16/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.950\n", - " Likelihood parameter acceptance fractions: [0.66]\n", - "Batch: 17/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.950\n", - " Likelihood parameter acceptance fractions: [0.68]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 18/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.930\n", - " Likelihood parameter acceptance fractions: [0.71]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 19/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.980\n", - " Likelihood parameter acceptance fractions: [0.71]\n", - "Batch: 20/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.960\n", - " Likelihood parameter acceptance fractions: [0.73]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 21/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.970\n", - " Likelihood parameter acceptance fractions: [0.75]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 22/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.960\n", - " Likelihood parameter acceptance fractions: [0.75]\n", - "Batch: 23/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.940\n", - " Likelihood parameter acceptance fractions: [0.67]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 24/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.940\n", - " Likelihood parameter acceptance fractions: [0.74]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 25/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.980\n", - " Likelihood parameter acceptance fractions: [0.7]\n", - "Batch: 26/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.970\n", - " Likelihood parameter acceptance fractions: [0.71]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 27/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.980\n", - " Likelihood parameter acceptance fractions: [0.75]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 28/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.960\n", - " Likelihood parameter acceptance fractions: [0.76]\n", - "Batch: 29/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.970\n", - " Likelihood parameter acceptance fractions: [0.67]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 30/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.960\n", - " Likelihood parameter acceptance fractions: [0.76]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 31/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.980\n", - " Likelihood parameter acceptance fractions: [0.69]\n", - "Batch: 32/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.990\n", - " Likelihood parameter acceptance fractions: [0.67]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 33/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.970\n", - " Likelihood parameter acceptance fractions: [0.72]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 34/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.950\n", - " Likelihood parameter acceptance fractions: [0.74]\n", - "Batch: 35/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.980\n", - " Likelihood parameter acceptance fractions: [0.66]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 36/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 1.000\n", - " Likelihood parameter acceptance fractions: [0.76]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 37/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.990\n", - " Likelihood parameter acceptance fractions: [0.66]\n", - "Batch: 38/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.950\n", - " Likelihood parameter acceptance fractions: [0.72]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 39/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.950\n", - " Likelihood parameter acceptance fractions: [0.68]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 40/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.980\n", - " Likelihood parameter acceptance fractions: [0.6]\n", - "Batch: 41/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.920\n", - " Likelihood parameter acceptance fractions: [0.7]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 42/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.910\n", - " Likelihood parameter acceptance fractions: [0.75]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 43/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.970\n", - " Likelihood parameter acceptance fractions: [0.72]\n", - "Batch: 44/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.990\n", - " Likelihood parameter acceptance fractions: [0.7]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 45/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 1.000\n", - " Likelihood parameter acceptance fractions: [0.74]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 46/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.980\n", - " Likelihood parameter acceptance fractions: [0.71]\n", - "Batch: 47/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.970\n", - " Likelihood parameter acceptance fractions: [0.76]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 48/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.990\n", - " Likelihood parameter acceptance fractions: [0.75]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 49/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.920\n", - " Likelihood parameter acceptance fractions: [0.73]\n", - "Batch: 50/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.980\n", - " Likelihood parameter acceptance fractions: [0.69]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 51/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.990\n", - " Likelihood parameter acceptance fractions: [0.75]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 52/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.980\n", - " Likelihood parameter acceptance fractions: [0.71]\n", - "Batch: 53/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.950\n", - " Likelihood parameter acceptance fractions: [0.67]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 54/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.990\n", - " Likelihood parameter acceptance fractions: [0.74]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 55/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.950\n", - " Likelihood parameter acceptance fractions: [0.72]\n", - "Batch: 56/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.960\n", - " Likelihood parameter acceptance fractions: [0.7]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 57/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.960\n", - " Likelihood parameter acceptance fractions: [0.66]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 58/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.940\n", - " Likelihood parameter acceptance fractions: [0.69]\n", - "Batch: 59/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.980\n", - " Likelihood parameter acceptance fractions: [0.69]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 60/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.950\n", - " Likelihood parameter acceptance fractions: [0.75]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 61/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.980\n", - " Likelihood parameter acceptance fractions: [0.7]\n", - "Batch: 62/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.980\n", - " Likelihood parameter acceptance fractions: [0.76]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 63/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.960\n", - " Likelihood parameter acceptance fractions: [0.67]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 64/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.990\n", - " Likelihood parameter acceptance fractions: [0.75]\n", - "Batch: 65/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.970\n", - " Likelihood parameter acceptance fractions: [0.68]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 66/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.980\n", - " Likelihood parameter acceptance fractions: [0.75]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 67/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.970\n", - " Likelihood parameter acceptance fractions: [0.73]\n", - "Batch: 68/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.980\n", - " Likelihood parameter acceptance fractions: [0.7]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 69/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.970\n", - " Likelihood parameter acceptance fractions: [0.71]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 70/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 1.000\n", - " Likelihood parameter acceptance fractions: [0.7]\n", - "Batch: 71/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.990\n", - " Likelihood parameter acceptance fractions: [0.65]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 72/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.960\n", - " Likelihood parameter acceptance fractions: [0.66]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 73/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.950\n", - " Likelihood parameter acceptance fractions: [0.71]\n", - "Batch: 74/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 1.000\n", - " Likelihood parameter acceptance fractions: [0.73]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 75/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.990\n", - " Likelihood parameter acceptance fractions: [0.7]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 76/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 1.000\n", - " Likelihood parameter acceptance fractions: [0.69]\n", - "Batch: 77/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.970\n", - " Likelihood parameter acceptance fractions: [0.68]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 78/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.970\n", - " Likelihood parameter acceptance fractions: [0.72]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 79/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.990\n", - " Likelihood parameter acceptance fractions: [0.78]\n", - "Batch: 80/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.990\n", - " Likelihood parameter acceptance fractions: [0.66]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 81/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.960\n", - " Likelihood parameter acceptance fractions: [0.65]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 82/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.950\n", - " Likelihood parameter acceptance fractions: [0.82]\n", - "Batch: 83/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.950\n", - " Likelihood parameter acceptance fractions: [0.69]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 84/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 1.000\n", - " Likelihood parameter acceptance fractions: [0.57]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 85/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.970\n", - " Likelihood parameter acceptance fractions: [0.71]\n", - "Batch: 86/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.980\n", - " Likelihood parameter acceptance fractions: [0.73]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 87/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.990\n", - " Likelihood parameter acceptance fractions: [0.74]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 88/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.960\n", - " Likelihood parameter acceptance fractions: [0.76]\n", - "Batch: 89/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.980\n", - " Likelihood parameter acceptance fractions: [0.77]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 90/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.990\n", - " Likelihood parameter acceptance fractions: [0.72]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 91/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.990\n", - " Likelihood parameter acceptance fractions: [0.69]\n", - "Batch: 92/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.940\n", - " Likelihood parameter acceptance fractions: [0.77]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 93/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.960\n", - " Likelihood parameter acceptance fractions: [0.72]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 94/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.990\n", - " Likelihood parameter acceptance fractions: [0.71]\n", - "Batch: 95/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.980\n", - " Likelihood parameter acceptance fractions: [0.74]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 96/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.990\n", - " Likelihood parameter acceptance fractions: [0.73]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 97/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.980\n", - " Likelihood parameter acceptance fractions: [0.73]\n", - "Batch: 98/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.960\n", - " Likelihood parameter acceptance fractions: [0.72]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 99/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.970\n", - " Likelihood parameter acceptance fractions: [0.77]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 100/100 completed, 100 steps. \n", - " Model parameter acceptance fraction: 0.960\n", - " Likelihood parameter acceptance fractions: [0.76]\n", - "CPU times: user 9.66 s, sys: 10.9 ms, total: 9.67 s\n", - "Wall time: 9.65 s\n" - ] - } - ], - "source": [ - "%%time\n", - "walker2.walk(\n", - " n_steps=10000,\n", - " burnin=1000,\n", - " batch_size=100,\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 76, - "id": "e78a780b-1336-41dd-a222-ea4333149f6d", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:10:17.203038Z", - "iopub.status.busy": "2026-08-11T03:10:17.202905Z", - "iopub.status.idle": "2026-08-11T03:10:17.251148Z", - "shell.execute_reply": "2026-08-11T03:10:17.250464Z" - } - }, - "outputs": [], - "source": [ - "upper2, med2, lower2 = np.percentile(\n", - " [my_model.y(x_full, *p) for p in walker2.model_sampler.chain],\n", - " [5, 50, 95],\n", - " axis=0,\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 77, - "id": "d0f0d0cc-7f17-4d49-b60f-fe6330a1c10d", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:10:17.252455Z", - "iopub.status.busy": "2026-08-11T03:10:17.252324Z", - "iopub.status.idle": "2026-08-11T03:10:17.254981Z", - "shell.execute_reply": "2026-08-11T03:10:17.254383Z" - } - }, - "outputs": [], - "source": [ - "walker3 = rxmc.walker.Walker(\n", - " model_sampler=rxmc.param_sampling.MetropolisHastingsSampler(\n", - " params=my_model.params,\n", - " starting_location=prior_distribution.mean,\n", - " proposal=proposal_distribution_model,\n", - " prior=prior_distribution,\n", - " ),\n", - " evidence=evidence_sys_correct,\n", - " rng=rng,\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 78, - "id": "c6e0ea79-3fbe-4105-8e34-a1e1db699c77", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:10:17.256193Z", - "iopub.status.busy": "2026-08-11T03:10:17.256076Z", - "iopub.status.idle": "2026-08-11T03:10:22.676338Z", - "shell.execute_reply": "2026-08-11T03:10:22.675665Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Burn-in batch 1/1 completed, 1000 steps.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 1/1 completed, 10000 steps. \n", - " Model parameter acceptance fraction: 0.748\n", - "CPU times: user 5.42 s, sys: 897 μs, total: 5.42 s\n", - "Wall time: 5.42 s\n" - ] - } - ], - "source": [ - "%%time\n", - "walker3.walk(n_steps=10000, burnin=1000)" - ] - }, - { - "cell_type": "code", - "execution_count": 79, - "id": "60262bab-1c58-4a71-9227-43983c7af67d", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:10:22.677794Z", - "iopub.status.busy": "2026-08-11T03:10:22.677622Z", - "iopub.status.idle": "2026-08-11T03:10:22.729234Z", - "shell.execute_reply": "2026-08-11T03:10:22.728390Z" - } - }, - "outputs": [], - "source": [ - "upper3, med3, lower3 = np.percentile(\n", - " [my_model.y(x_full, *p) for p in walker3.model_sampler.chain],\n", - " [5, 50, 95],\n", - " axis=0,\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 80, - "id": "d9c5010e-8f5b-461a-8941-2b967fbfb8f7", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:10:22.730597Z", - "iopub.status.busy": "2026-08-11T03:10:22.730459Z", - "iopub.status.idle": "2026-08-11T03:10:22.733413Z", - "shell.execute_reply": "2026-08-11T03:10:22.732750Z" - } - }, - "outputs": [], - "source": [ - "walker4 = rxmc.walker.Walker(\n", - " model_sampler=rxmc.param_sampling.MetropolisHastingsSampler(\n", - " params=my_model.params,\n", - " starting_location=prior_distribution.mean,\n", - " proposal=proposal_distribution_model,\n", - " prior=prior_distribution,\n", - " ),\n", - " evidence=evidence_sys_wrong,\n", - " rng=rng,\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 81, - "id": "b02c82e3-0cb0-4d5d-9d55-2b1ceacdf244", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:10:22.734633Z", - "iopub.status.busy": "2026-08-11T03:10:22.734464Z", - "iopub.status.idle": "2026-08-11T03:10:26.390364Z", - "shell.execute_reply": "2026-08-11T03:10:26.389705Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Burn-in batch 1/1 completed, 1000 steps.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Batch: 1/1 completed, 10000 steps. \n", - " Model parameter acceptance fraction: 0.735\n", - "CPU times: user 3.65 s, sys: 10.9 ms, total: 3.66 s\n", - "Wall time: 3.65 s\n" - ] - } - ], - "source": [ - "%%time\n", - "walker4.walk(n_steps=10000, burnin=1000)" - ] - }, - { - "cell_type": "code", - "execution_count": 82, - "id": "d24a326a-093b-4e20-80d3-9d267a4c14e7", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:10:26.391784Z", - "iopub.status.busy": "2026-08-11T03:10:26.391652Z", - "iopub.status.idle": "2026-08-11T03:10:26.443882Z", - "shell.execute_reply": "2026-08-11T03:10:26.443172Z" - } - }, - "outputs": [], - "source": [ - "upper4, med4, lower4 = np.percentile(\n", - " [my_model.y(x_full, *p) for p in walker4.model_sampler.chain],\n", - " [5, 50, 95],\n", - " axis=0,\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 83, - "id": "78d9fee2-1f50-460b-b579-62f649785e00", - "metadata": { - "execution": { - "iopub.execute_input": "2026-08-11T03:10:26.445207Z", - "iopub.status.busy": "2026-08-11T03:10:26.445078Z", - "iopub.status.idle": "2026-08-11T03:10:26.648495Z", - "shell.execute_reply": "2026-08-11T03:10:26.647882Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 1.0, '$x$-offset constraints with systematic normalization error')" - ] - }, - "execution_count": 83, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.errorbar(\n", - " x,\n", - " y_exp,\n", - " y_stat_err,\n", - " marker=\".\",\n", - " linestyle=\"none\",\n", - " label=\"experiment 1\",\n", - " color=\"tab:purple\",\n", - " zorder=999,\n", - ")\n", - "plt.errorbar(\n", - " x2,\n", - " y_exp2,\n", - " y_stat_err2,\n", - " marker=\".\",\n", - " linestyle=\"none\",\n", - " label=\"experiment 2\",\n", - " color=\"tab:cyan\",\n", - " zorder=999,\n", - ")\n", - "p = plt.fill_between(x_full, lower1, upper1, label=\"stat only\", alpha=0.5, zorder=99)\n", - "plt.plot(x_full, med1, \"--\", color=p.get_facecolor(), alpha=1, zorder=100)\n", - "\n", - "\n", - "p = plt.fill_between(x_full, lower2, upper2, label=\"stat fit\", alpha=0.5, zorder=89)\n", - "plt.plot(x_full, med2, \"--\", color=p.get_facecolor(), alpha=1, zorder=90)\n", - "\n", - "\n", - "p = plt.fill_between(x_full, lower3, upper3, label=\"full covariance\", alpha=0.5)\n", - "plt.plot(x_full, med3, \"--\", color=p.get_facecolor(), alpha=1, zorder=89)\n", - "\n", - "p = plt.fill_between(x_full, lower4, upper4, label=\"full covariance, wrong\", alpha=0.25)\n", - "plt.plot(x_full, med4, \"--\", color=p.get_facecolor(), alpha=0.5)\n", - "\n", - "\n", - "plt.plot(x_full, y_true_full, \"k--\", label=\"truth\", zorder=999)\n", - "plt.xlabel(\"x\")\n", - "plt.ylabel(\"y\")\n", - "plt.legend()\n", - "plt.title(\"$x$-offset constraints with systematic normalization error\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "3f78b592-f51a-44b1-a969-8b53d2f08ec2", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.12.3" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/pyproject.toml b/pyproject.toml index 254beb5..e4e4842 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -35,18 +35,24 @@ docs = [ "sphinx-copybutton>=0.5", ] examples = [ + "blackjax>=1.2", "corner>=2.2", + "dill>=0.3", "dynesty>=2.1", "emcee>=3.1", "ipykernel>=6.0", "jupyter>=1.0", "matplotlib>=3.8", + "pocomc>=1.2", + "torch", # for pocomc; listed so tool.uv.sources can point it at the CPU wheels "tqdm>=4.66", ] validation = [ "black>=24.0", + "blackjax>=1.2", "build>=1.2", "corner>=2.2", + "dill>=0.3", "dynesty>=2.1", "emcee>=3.1", "ipykernel>=6.0", @@ -55,10 +61,19 @@ validation = [ "matplotlib>=3.8", "nbmake>=1.5", "nbqa>=1.9", + "pocomc>=1.2", "pytest>=8.0", "ruff>=0.6", + "scikit-learn>=1.0", + "torch", "tqdm>=4.66", ] +# the sampler benchmark's extra samplers (benchmarks/bench_samplers.py, which +# also needs the examples extra) +samplers = [ + "ptemcee @ git+https://github.com/NuclearTalent/ptemcee_2025@modernize", + "pymc>=5.0", +] [tool.setuptools.packages.find] where = ["src"] @@ -71,16 +86,16 @@ write_to = "src/rxmc/__version__.py" [tool.black] line-length = 88 -target-version = ["py310"] +target-version = ["py312"] [tool.isort] profile = "black" line_length = 88 -src_paths = ["src", "test"] +src_paths = ["src", "test", "test/recipes"] [tool.ruff] line-length = 88 -target-version = "py310" +target-version = "py312" [tool.ruff.lint] select = ["F", "I"] @@ -88,9 +103,24 @@ select = ["F", "I"] [tool.ruff.lint.isort] # match isort's src_paths = ["src", "test"]: the shared test helpers module is # first-party too, so the two sorters agree -known-first-party = ["rxmc", "helpers"] +known-first-party = ["rxmc", "helpers", "common", "oracle"] [tool.pytest.ini_options] -# bare `pytest` runs the unit suite only; the notebooks are executed in CI via -# `pytest -n 4 --nbmake --nbmake-timeout=1200 examples` +# bare `pytest` runs the fast tier: unit tests plus the sampler-free and +# short-chain assertions of every recipe test. The converged tier is marked +# `slow` and runs with `pytest -m slow`, together with a quick run of the +# notebooks (`RXMC_EXAMPLES_QUICK=1 pytest --nbmake examples`), in the +# "Converged tier" workflow required on pushes and pull requests to main. See docs/design.md section 5. testpaths = ["test"] +addopts = "-m 'not slow'" +markers = [ + "slow: converged-chain tier; deselected by default, run with -m slow on pushes and PRs to main", +] + +[[tool.uv.index]] +name = "pytorch-cpu" +url = "https://download.pytorch.org/whl/cpu" +explicit = true + +[tool.uv.sources] +torch = { index = "pytorch-cpu" } diff --git a/requirements.txt b/requirements.txt index 9987df3..92c51b5 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,7 +1,6 @@ -scikit-learn>=1.0.0 numpy>=2.2.6 -pandas>=2.2 scipy>=1.15 -pint>=0.2 -jitr>=3.0 +jax>=0.4.35 +tinygp>=0.3 +jitr @ git+https://github.com/beykyle/jitr@jax-core exfor-tools>=0.4 diff --git a/src/rxmc/__init__.py b/src/rxmc/__init__.py index 5685810..246cf15 100644 --- a/src/rxmc/__init__.py +++ b/src/rxmc/__init__.py @@ -1,45 +1,71 @@ -from . import adaptive_metropolis as adaptive_metropolis -from . import config as config +"""rxmc: Bayesian calibration of reaction models with composable error models. + +See ``docs/design.md`` for the design and ``docs/recipes.md`` for the +supported use cases. + +rxmc computes its densities with JAX in double precision: importing it turns +on ``jax_enable_x64`` for the whole process (as importing ``jitr`` does). +""" + +import jax + +jax.config.update("jax_enable_x64", True) + from . import constraint as constraint from . import covariance as covariance -from . import elastic_diffxs_model as elastic_diffxs_model -from . import elastic_diffxs_observation as elastic_diffxs_observation -from . import evidence as evidence -from . import ias_pn_model as ias_pn_model -from . import ias_pn_observation as ias_pn_observation -from . import likelihood_model as likelihood_model -from . import metropolis_hastings as metropolis_hastings -from . import model_comparison as model_comparison -from . import observation as observation -from . import observation_from_measurement as observation_from_measurement -from . import param_sampling as param_sampling -from . import params as params -from . import physical_model as physical_model +from . import data as data +from . import diagnostics as diagnostics +from . import likelihood as likelihood +from . import model as model +from . import optimize as optimize from . import predictive as predictive -from . import priors as priors +from . import problem as problem +from . import reactions as reactions +from . import terms as terms from . import transforms as transforms -from . import walker as walker -from .__version__ import __version__ as __version__ +from . import units as units +from .constraint import Comparison as Comparison +from .constraint import Constraint as Constraint +from .data import Dataset as Dataset +from .data import from_measurement as from_measurement +from .likelihood import Chi2 as Chi2 +from .likelihood import Gaussian as Gaussian +from .model import Model as Model +from .model import polynomial as polynomial +from .params import Parameter as Parameter +from .problem import Problem as Problem +from .terms import KernelTerm as KernelTerm +from .terms import Term as Term + +try: + from .__version__ import __version__ as __version__ +except ImportError: # pragma: no cover - source checkout without a build + __version__ = "0+unknown" __all__ = [ "__version__", - "adaptive_metropolis", - "config", + "Chi2", + "Comparison", + "Constraint", + "Dataset", + "Gaussian", + "KernelTerm", + "Model", + "Parameter", + "Problem", + "Term", + "from_measurement", + "polynomial", "constraint", "covariance", - "elastic_diffxs_model", - "elastic_diffxs_observation", - "evidence", - "ias_pn_model", - "ias_pn_observation", - "likelihood_model", - "metropolis_hastings", - "observation", - "observation_from_measurement", - "param_sampling", - "params", - "physical_model", + "data", + "diagnostics", + "likelihood", + "model", "predictive", - "priors", - "walker", + "problem", + "reactions", + "terms", + "transforms", + "units", ] diff --git a/src/rxmc/adaptive_metropolis.py b/src/rxmc/adaptive_metropolis.py deleted file mode 100644 index 44862df..0000000 --- a/src/rxmc/adaptive_metropolis.py +++ /dev/null @@ -1,109 +0,0 @@ -""" -Adaptive Metropolis MCMC sampler with sliding-window covariance adaptation. - -The :func:`adaptive_metropolis` function implements the AM algorithm of Haario, -Saksman & Tamminen (2001), extended with a sliding window so that old samples -do not dominate the estimated proposal covariance. -""" - -from typing import Callable, Tuple - -import numpy as np - - -def adaptive_metropolis( - x0: np.ndarray, - bounds: np.ndarray, - n_steps: int, - log_posterior: Callable[[np.ndarray], float], - rng: np.random.Generator, - adapt_start: int = 1000, - window_size: int = 1000, - epsilon_fraction: float = 1e-6, - previous_chain: np.ndarray = None, -) -> Tuple[np.ndarray, np.ndarray, int]: - """Adaptive Metropolis algorithm with sliding-window covariance adaptation. - - Before *adapt_start* steps the proposal is a diagonal Gaussian scaled to - 1 % of ``|x0|``. After *adapt_start* steps the proposal covariance is - estimated from the last *window_size* samples and scaled by - ``2.38² / ndim`` (the Gelman–Roberts–Gilks optimal scale). - - Parameters - ---------- - x0 : np.ndarray, shape (ndim,) - Initial parameter vector. - bounds : np.ndarray, shape (ndim, 2) - Parameter bounds; each row is ``[lower, upper]``. Proposals outside - these bounds are rejected outright. - n_steps : int - Number of MCMC steps to generate. - log_posterior : callable - Function ``f(x) -> float`` returning the log posterior at ``x``. - rng : np.random.Generator - Random number generator for reproducibility. - adapt_start : int, optional - Step index at which covariance adaptation begins. Ignored when - *previous_chain* is supplied. Defaults to ``1000``. - window_size : int, optional - Number of past samples used for covariance estimation. - Defaults to ``1000``. - epsilon_fraction : float, optional - Fraction of the mean diagonal element added to the covariance for - numerical stability. Defaults to ``1e-6``. - previous_chain : np.ndarray, shape (m, ndim), optional - Chain from a prior run to continue from. When provided the new - samples are appended and adaptation uses all available history. - - Returns - ------- - chain : np.ndarray, shape (n_steps, ndim) - Newly generated samples (does not include *previous_chain*). - logp_chain : np.ndarray, shape (n_steps,) - Log posterior values for the new samples. - accepted : int - Number of accepted proposals in this run. - """ - dim = x0.size - if previous_chain is not None and previous_chain.shape[0] > 0: - start = previous_chain.shape[0] - chain = np.concatenate((previous_chain, np.zeros((n_steps, dim))), axis=0) - else: - start = 0 - chain = np.zeros((n_steps, dim)) - - logp_chain = np.zeros(n_steps) - accepted = 0 - - x = x0.copy() - logp = float(np.squeeze(log_posterior(x))) - scale = 2.38**2 / dim - - for i in range(start, start + n_steps): - if i < adapt_start: - proposal_scale = np.maximum(np.abs(x0), 1.0) * 0.01 - proposal_cov = np.diag(proposal_scale**2) - else: - start_idx = max(0, i - window_size) - history_subset = chain[start_idx:i, ...] - cov = np.atleast_2d(np.cov(history_subset.T)) - cov += epsilon_fraction * np.mean(np.diag(cov)) * np.eye(dim) - proposal_cov = scale * cov - - x_new = rng.multivariate_normal(x, proposal_cov) - if np.any(x_new < bounds[:, 0]) or np.any(x_new > bounds[:, 1]): - chain[i, :] = x - logp_chain[i - start] = logp - continue - logp_new = float(np.squeeze(log_posterior(x_new))) - - log_ratio = min(0, logp_new - logp) - if np.log(rng.random()) < log_ratio: - x = x_new - logp = logp_new - accepted += 1 - - chain[i, :] = x - logp_chain[i - start] = logp - - return chain[start:, ...], logp_chain, accepted diff --git a/src/rxmc/config.py b/src/rxmc/config.py deleted file mode 100644 index 79983fc..0000000 --- a/src/rxmc/config.py +++ /dev/null @@ -1,581 +0,0 @@ -""" -Configuration helpers for calibration workflows. - -``CalibrationConfig`` is the main integration surface for external samplers -such as black-box-bayes. It exposes a flat parameterization of an -``Evidence`` instance together with the sampler-facing methods needed to -evaluate the posterior and generate starting locations. - -Prior protocol --------------- -Both ``ParameterConfig`` and ``CalibrationConfig`` accept any prior object -that implements: - -* ``logpdf(x: ndarray) -> float`` — log-density at a parameter vector of - shape ``(ndim,)``. -* ``rvs(n: int) -> ndarray`` — draw ``n`` samples; returned array must have - shape ``(n, ndim)`` or ``(n,)`` for scalar parameters. - -This covers ``scipy.stats`` frozen distributions (both univariate and -multivariate), the built-in :class:`~rxmc.priors.TruncatedNormalPrior`, and -any user-supplied class that satisfies the same interface. - -Alternatively, a **list** of univariate ``scipy.stats`` frozen distributions -(one per parameter) may be passed; it is wrapped in an -:class:`~rxmc.priors.IndependentPrior` on construction (the same rule -:class:`~rxmc.param_sampling.Sampler` applies). That class and any prior -class that implements ``prior_transform(u)`` support the Dynesty-compatible -:meth:`CalibrationConfig.prior_transform`. -""" - -from typing import List, Optional - -import numpy as np - -from rxmc.evidence import Evidence -from rxmc.params import Parameter -from rxmc.priors import as_prior, clip_unit_cube - - -class ParameterConfig: - """Configuration for a single sector of parameters. - - Bundles a list of :class:`~rxmc.params.Parameter` objects with a prior - distribution and an initial-proposal distribution. Instances are passed - to :class:`CalibrationConfig` to describe the model-parameter sector and - each likelihood-parameter sector. - - Parameters - ---------- - params : list of Parameter - Ordered list of parameters in this sector. - prior : prior object or list of rv_continuous - Prior distribution. May be any object that exposes ``logpdf`` and - ``rvs`` (e.g. a frozen ``scipy.stats`` multivariate distribution, - :class:`~rxmc.priors.TruncatedNormalPrior`, or any user-defined class - with the same interface), **or** a list of frozen univariate - ``scipy.stats`` distributions — one per parameter. - initial_proposal_distribution : prior object or list of rv_continuous - Starting-location proposal distribution. Accepts the same forms as - ``prior``. - - Raises - ------ - ValueError - If ``params`` is empty. - ValueError - If the dimensionality implied by ``prior`` or - ``initial_proposal_distribution`` does not match ``len(params)``. - """ - - def __init__( - self, - params: List[Parameter], - prior, - initial_proposal_distribution, - ): - self.params = params - self.ndim = len(params) - # a list of marginals becomes an IndependentPrior here, so every - # method below sees one prior object (the rule Sampler applies too) - self.prior = as_prior(prior) - self.initial_proposal_distribution = as_prior(initial_proposal_distribution) - - if self.ndim == 0: - raise ValueError("Parameter list cannot be empty") - - self._validate_prior_dim(self.prior, "prior") - self._validate_prior_dim( - self.initial_proposal_distribution, "initial_proposal_distribution" - ) - - # ------------------------------------------------------------------ - # Internal helpers - # ------------------------------------------------------------------ - - @staticmethod - def _infer_dim(dist) -> Optional[int]: - """Return the dimensionality of a prior object, or None if unknown. - - An integer ``dim`` attribute wins; otherwise the size of ``mean`` is - used, *calling* it when it is a method (frozen ``scipy.stats`` - univariates and user classes expose ``mean()``; scipy multivariates - expose an array). - """ - dim = getattr(dist, "dim", None) - if isinstance(dim, int) and not isinstance(dim, bool): - return dim - mean = getattr(dist, "mean", None) - if mean is None: - return None - if callable(mean): - try: - mean = mean() - except Exception: - return None - return int(np.size(mean)) - - def _validate_prior_dim(self, dist, name: str) -> None: - dim = self._infer_dim(dist) - if dim is not None and dim != self.ndim: - raise ValueError( - f"{name} dimensionality ({dim}) does not match " - f"number of parameters ({self.ndim})" - ) - - # ------------------------------------------------------------------ - # Public API - # ------------------------------------------------------------------ - - def x0(self, nwalkers: int) -> np.ndarray: - """Draw initial walker positions from the proposal distribution. - - Parameters - ---------- - nwalkers : int - Number of walkers (rows) to generate. - - Returns - ------- - ndarray, shape (nwalkers, ndim) - One initial position per walker. - """ - samples = np.atleast_1d(self.initial_proposal_distribution.rvs(nwalkers)) - return samples.reshape(nwalkers, -1) - - def prior_logpdf(self, x: np.ndarray) -> float: - """Evaluate the log prior density at a parameter vector. - - Parameters - ---------- - x : ndarray, shape (ndim,) - Parameter vector for this sector. - - Returns - ------- - float - Log prior probability at ``x``. - """ - return float(self.prior.logpdf(np.atleast_1d(x))) - - def prior_transform(self, u: np.ndarray) -> np.ndarray: - """Map unit-cube coordinates to physical parameters for this sector. - - The prior object must implement ``prior_transform(u) -> ndarray`` - (:class:`~rxmc.priors.IndependentPrior`, which a list prior becomes, - and :class:`~rxmc.priors.TruncatedNormalPrior` do). ``u`` is clipped - into the open unit cube first, so an exact ``0`` or ``1`` stays finite. - - Parameters - ---------- - u : ndarray, shape (ndim,) - Unit-cube coordinates, each in ``[0, 1)``. - - Returns - ------- - ndarray, shape (ndim,) - Physical parameter vector for this sector. - - Raises - ------ - NotImplementedError - If the prior does not expose ``prior_transform``. - """ - u = clip_unit_cube(u) - if hasattr(self.prior, "prior_transform"): - return self.prior.prior_transform(u) - raise NotImplementedError( - "Prior transform requires a prior object that implements " - "prior_transform(u) (a list of scipy marginals is wrapped in " - "IndependentPrior, which does)." - ) - - -class CalibrationConfig: - """End-to-end configuration for Bayesian calibration. - - Combines an :class:`~rxmc.evidence.Evidence` object with - :class:`ParameterConfig` instances for the physical-model parameters and - any parametric likelihood parameters. The result is a flat - parameterization suitable for black-box samplers (emcee, Dynesty, - black-box-bayes, etc.). - - Parameters - ---------- - evidence : Evidence - Aggregated experimental constraints. - model_config : ParameterConfig - Prior and proposal for the physical-model parameters. - likelihood_configs : list of ParameterConfig, optional - One :class:`ParameterConfig` per parametric constraint in - ``evidence.parametric_constraints``. Omit or pass ``None`` when - there are no parametric likelihood models. - likelihood_scaling : float, optional - Multiplicative scale applied to the total log-likelihood before - adding the log-prior. Useful for tempering or importance - re-weighting. Defaults to ``1.0``. - - Raises - ------ - ValueError - If ``evidence`` contains no constraints. - ValueError - If the model parameters in ``model_config`` do not match those in - the evidence constraints. - ValueError - If the number or parameter lists of ``likelihood_configs`` do not - match ``evidence.parametric_constraints``. - - Attributes - ---------- - ndim : int - Total number of free parameters (model + all likelihood sectors). - dimensions : ndarray - Array of sector sizes ``[model_ndim, lc0_ndim, lc1_ndim, ...]``. - indices : ndarray - Cumulative split indices derived from ``dimensions``; used by - :meth:`split_parameters`. - """ - - def __init__( - self, - evidence: Evidence, - model_config: ParameterConfig, - likelihood_configs: Optional[list] = None, - likelihood_scaling: Optional[float] = None, - ): - self.evidence = evidence - self.model_config = model_config - self.likelihood_configs = likelihood_configs or [] - self.ndim = model_config.ndim + sum(lc.ndim for lc in self.likelihood_configs) - self.likelihood_scaling = ( - 1.0 if likelihood_scaling is None else likelihood_scaling - ) - - if len(self.evidence.constraints) == 0: - raise ValueError("Evidence must have at least one constraint") - if np.any( - [ - c.physical_model.params != self.model_config.params - for c in self.evidence.constraints - ] - ): - raise ValueError( - "Model parameters do not match those in the evidence constraints" - ) - if len(self.likelihood_configs) != len(self.evidence.parametric_constraints): - raise ValueError( - "Likelihood configurations do not match the likelihood models " - "in the evidence constraints" - ) - for lc, c in zip(self.likelihood_configs, self.evidence.parametric_constraints): - if list(lc.params) != list(c.params): - raise ValueError( - "Likelihood parameters do not match those in the evidence constraints" - ) - - self.dimensions = np.array( - [self.model_config.ndim] + [lc.ndim for lc in self.likelihood_configs] - ) - self.indices = np.cumsum(self.dimensions) - - # ------------------------------------------------------------------ - # Structural properties - # ------------------------------------------------------------------ - - @property - def parameter_configs(self) -> list: - """All parameter sectors in flat sampler order: model first, then likelihoods.""" - return [self.model_config] + self.likelihood_configs - - @property - def parameters(self) -> List[Parameter]: - """All :class:`~rxmc.params.Parameter` objects in flat sampler order. - - The order matches the flat parameter vector consumed by - :meth:`log_posterior`, :meth:`log_likelihood`, and - :meth:`starting_location`. - """ - return [param for pc in self.parameter_configs for param in pc.params] - - @property - def parameter_names(self) -> List[str]: - """Flat parameter names in sampler order. - - Convenience accessor equivalent to - ``[p.name for p in self.parameters]``. Provided for compatibility - with external drivers such as black-box-bayes that export inference - results keyed by name. - """ - return [p.name for p in self.parameters] - - @property - def prior(self) -> list: - """Prior distribution objects in parameter-sector order. - - Returns one entry per sector: the model prior first, followed by one - entry per likelihood sector. Each entry is the prior object held by - the corresponding :class:`ParameterConfig` — a multivariate - distribution, a custom prior object, or the - :class:`~rxmc.priors.IndependentPrior` a list of univariate - distributions was wrapped into. - """ - return [pc.prior for pc in self.parameter_configs] - - # ------------------------------------------------------------------ - # Parameter manipulation - # ------------------------------------------------------------------ - - def split_parameters(self, x) -> tuple: - """Split a flat parameter vector into model and likelihood sub-vectors. - - Parameters - ---------- - x : ndarray, shape (ndim,) - Flat parameter vector in sampler order. - - Returns - ------- - xmodel : ndarray - Model parameter sub-vector of shape ``(model_config.ndim,)``. - xlikelihoods : list of ndarray - One sub-vector per likelihood sector. - """ - parts = np.split(x, self.indices[:-1]) - return parts[0], parts[1:] - - # ------------------------------------------------------------------ - # Posterior evaluation - # ------------------------------------------------------------------ - - def log_prior(self, x) -> float: - """Evaluate the joint log prior at a flat parameter vector. - - Parameters - ---------- - x : ndarray, shape (ndim,) - Flat parameter vector in sampler order. - - Returns - ------- - float - Sum of log prior densities across all sectors. - """ - xmodel, xlikelihoods = self.split_parameters(x) - lprior = self.model_config.prior_logpdf(xmodel) - lprior += sum( - lc.prior_logpdf(xl) for lc, xl in zip(self.likelihood_configs, xlikelihoods) - ) - return lprior - - def log_likelihood(self, x) -> float: - """Evaluate the scaled log likelihood at a flat parameter vector. - - Parameters - ---------- - x : ndarray, shape (ndim,) - Flat parameter vector in sampler order. - - Returns - ------- - float - ``likelihood_scaling * evidence.log_likelihood(xmodel, xlikelihoods)``. - """ - xmodel, xlikelihoods = self.split_parameters(x) - return self.likelihood_scaling * self.evidence.log_likelihood( - xmodel, xlikelihoods - ) - - def log_posterior(self, x) -> float: - """Evaluate the log posterior at a flat parameter vector. - - Returns ``-inf`` immediately if either the prior or likelihood is - non-finite, avoiding unnecessary model evaluations. - - Parameters - ---------- - x : ndarray, shape (ndim,) - Flat parameter vector in sampler order. - - Returns - ------- - float - ``log_prior(x) + log_likelihood(x)``, or ``-inf`` if either term - is non-finite. - """ - lp = self.log_prior(x) - if not np.isfinite(lp): - return -np.inf - ll = self.log_likelihood(x) - if not np.isfinite(ll): - return -np.inf - return lp + ll - - def log_posterior_batch(self, thetas: np.ndarray) -> np.ndarray: - """Evaluate the log posterior for a batch of parameter vectors. - - Convenience wrapper for external orchestration layers (e.g. - black-box-bayes). The current implementation is serial but - preserves the advertised interface for future parallelisation. - - Parameters - ---------- - thetas : ndarray, shape (..., ndim) - Batch of parameter vectors. - - Returns - ------- - ndarray, shape (n,) - Log posterior value for each row of ``thetas``. - - Raises - ------ - ValueError - If the trailing dimension of ``thetas`` is not ``ndim``. - """ - thetas = np.atleast_2d(np.asarray(thetas, dtype=float)) - if thetas.shape[-1] != self.ndim: - raise ValueError( - f"Expected thetas with trailing dimension {self.ndim}, " - f"got shape {thetas.shape}" - ) - return np.array([self.log_posterior(theta) for theta in thetas], dtype=float) - - # ------------------------------------------------------------------ - # Sampling helpers - # ------------------------------------------------------------------ - - def starting_location(self, nwalkers: int) -> np.ndarray: - """Generate initial walker positions across all parameter sectors. - - Parameters - ---------- - nwalkers : int - Number of walkers. - - Returns - ------- - ndarray, shape (nwalkers, ndim) - Concatenated initial positions from each sector's proposal - distribution. - """ - x0_model = self.model_config.x0(nwalkers) - x0_likelihoods = [ - lc.x0(nwalkers).reshape(nwalkers, lc.ndim) for lc in self.likelihood_configs - ] - return np.hstack([x0_model] + x0_likelihoods) - - def prior_transform(self, u) -> np.ndarray: - """Map unit-cube coordinates to physical parameters (Dynesty interface). - - Delegates to :meth:`ParameterConfig.prior_transform` for each sector, - which in turn either calls ``ppf`` on each element of a list prior or - calls ``prior_transform`` directly on a joint prior object. - - Parameters - ---------- - u : array-like, shape (ndim,) - Unit-cube coordinates, each in ``[0, 1)``. - - Returns - ------- - theta : ndarray, shape (ndim,) - Physical parameter vector. - - Raises - ------ - NotImplementedError - If any sector's prior does not support a transform (see - :meth:`ParameterConfig.prior_transform`). - ValueError - If ``u`` does not have length ``ndim``. - """ - u = clip_unit_cube(u) - if u.shape[-1] != self.ndim: - raise ValueError(f"Expected u with length {self.ndim}, got shape {u.shape}") - - theta = np.empty_like(u) - offset = 0 - for pc in self.parameter_configs: - sector = u[offset : offset + pc.ndim] - theta[offset : offset + pc.ndim] = pc.prior_transform(sector) - offset += pc.ndim - - return theta - - # ------------------------------------------------------------------ - # Prediction and conditional posterior - # ------------------------------------------------------------------ - - def predict(self, xmodel) -> list: - """Generate model predictions for every constraint. - - Parameters - ---------- - xmodel : ndarray, shape (model_config.ndim,) - Physical model parameter vector. - - Returns - ------- - list - One entry per constraint, in ``evidence.constraints`` order; each entry - is itself a list of per-observation prediction arrays. For the - conditioning data of a likelihood sector use :meth:`predict_parametric`, - whose order matches :meth:`conditional_posterior`'s ``lm_index``. - """ - return [c.predict(*xmodel) for c in self.evidence.constraints] - - def predict_parametric(self, xmodel) -> list: - """Predictions for the *parametric* constraints only. - - Indexed in ``evidence.parametric_constraints`` order, so - ``predict_parametric(xmodel)[lm_index]`` is the correct ``ym`` to feed - :meth:`conditional_posterior` at ``lm_index`` (unlike :meth:`predict`, - which is indexed over *all* constraints and therefore misaligns whenever a - non-parametric constraint precedes a parametric one). - - Parameters - ---------- - xmodel : ndarray, shape (model_config.ndim,) - Physical model parameter vector. - - Returns - ------- - list - One prediction per parametric constraint. - """ - return [c.predict(*xmodel) for c in self.evidence.parametric_constraints] - - def conditional_posterior(self, x_lm, lm_index: int, ym) -> float: - """Log posterior for one likelihood sector, conditioned on observed data. - - Evaluates - ``prior_logpdf(x_lm) + likelihood_scaling * w * marginal_log_likelihood(ym, *x_lm)`` - for the likelihood sector at ``lm_index``, where ``w`` is the - constraint's :attr:`Evidence.weights` entry. The likelihood is tempered - exactly as in :meth:`log_posterior` (prior untouched), so Gibbs-style - updates that alternate this conditional with the model block target the - same joint distribution. - - Parameters - ---------- - x_lm : ndarray, shape (likelihood_configs[lm_index].ndim,) - Parameter vector for the target likelihood sector. - lm_index : int - Index into ``likelihood_configs`` (and - ``evidence.parametric_constraints``). - ym : ndarray - Predicted observable used as the conditioning data — use - ``predict_parametric(xmodel)[lm_index]`` to obtain it with matching - index order. - - Returns - ------- - float - Log posterior for this likelihood sector. - """ - lp = self.likelihood_configs[lm_index].prior_logpdf(x_lm) - if not np.isfinite(lp): - return -np.inf - ll = self.evidence.weighted_marginal_log_likelihood(lm_index, ym, *x_lm) - return lp + self.likelihood_scaling * ll diff --git a/src/rxmc/constraint.py b/src/rxmc/constraint.py index 73ef398..52d7bd8 100644 --- a/src/rxmc/constraint.py +++ b/src/rxmc/constraint.py @@ -1,483 +1,353 @@ """ -Constraint: the maximal block of mutually-correlated data. - -A :class:`Constraint` pairs one or more :class:`~rxmc.observation.Observation` -objects with a :class:`~rxmc.physical_model.PhysicalModel` and a likelihood -functional (:class:`~rxmc.likelihood_model.GaussianLikelihood` by default). It -owns **one** multivariate distribution over the *stacked* vector of all its -observations, whose covariance is a -:class:`~rxmc.covariance.ConstraintCovariance` assembled from -:class:`~rxmc.covariance.Term` s. - -Each observation *i* occupies a contiguous slice of the stacked vector. The -default covariance is the concatenation of every observation's statistical -diagonal (strictly block-diagonal — reproducing the old summed independent -likelihoods). Correlated modes — a dataset's own normalisation/offset -systematic, an unknown-noise term, or a cross-dataset coupling — are supplied as -``extra_terms``. - -Each observation's comparison-space ``transform`` is applied to the model -prediction here, so the residual ``y - ym`` is formed in that space. Masks — -point-level on the observations, observation-level via ``mask=`` — select the -*active* rows; terms are always authored over the full stack. +Comparisons and constraints: the declarations a likelihood is built from. + +A :class:`Comparison` is the unit a residual is formed on: one dataset, one +model bound to its grid, and one parameter-free comparison ``space`` (e.g. +``log``) applied to both. A :class:`Constraint` is a tuple of comparisons +plus the covariance terms, the likelihood functional, the tempering weight +and the active-point masks; it is the maximal block of mutually correlated +data, and constraints are independent of each other. Each comparison is one +block of the constraint's stacked covariance. + +Masks live on the constraint, not on the comparison or the data, so +:meth:`Constraint.masked`, :meth:`Constraint.masked_where` and +:meth:`Constraint.complement` return constraints sharing every +``Comparison``, ``Term`` and ``Parameter`` object with the original. A +held-out problem built from ``complement()`` therefore has the same +parameter columns as the fit. + +Nothing here walks the parameter graph; :class:`~rxmc.problem.Problem` does +that once. The checks here need only the constraint itself: comparisons are +distinct, every term's ``on`` resolves inside the constraint, and an +array-valued term has the right shape for its support. """ +from __future__ import annotations + +from dataclasses import dataclass, field, replace +from typing import Any, Callable + +import jax.numpy as jnp import numpy as np -from .covariance import ConstraintCovariance, StackContext, stacked_supports -from .likelihood_model import GaussianLikelihood -from .observation import Observation -from .physical_model import PhysicalModel +from .data import Dataset +from .likelihood import Gaussian, Likelihood +from .model import Model, Predictor +from .terms import Term +from .transforms import as_transform, identity +__all__ = ["Comparison", "Constraint"] -class Constraint: - """Pair observations with a physical model and a stacked covariance. + +@dataclass(eq=False, frozen=True) +class Comparison: + """One dataset compared with one model in one space. Parameters ---------- - observations : list of Observation - The observed data that the model will attempt to reproduce. Together - they form one stacked vector ``y = [y1; y2; ...]``. - physical_model : PhysicalModel - Model that predicts the observed data. - likelihood : object, optional - Likelihood functional of ``(d2, logdet, n, *like_params)``. Defaults to - :class:`~rxmc.likelihood_model.GaussianLikelihood`. - extra_terms : sequence of Term, optional - Additional covariance contributions beyond the statistical diagonals — - local systematics or cross-block couplings. - include_statistical_term : bool, optional - When ``True`` (default) each observation's statistical diagonal - (``obs.statistical_term``) is added automatically. Set ``False`` to omit - it and compose the *entire* covariance from ``extra_terms`` — e.g. to let - an unknown-noise term (:func:`~rxmc.covariance.noise_term`) *replace* the - reported statistics rather than add to them. - mask : sequence of bool or of int, optional - Which *observations* are active (all by default): a boolean per - observation, or the indices of the active ones. An integer array of - length ``len(observations)`` holding only 0/1 is ambiguous and - rejected; pass a bool array or explicit indices. Combined with each - observation's own point ``mask`` to give :attr:`active`. - - Attributes - ---------- - covariance : ConstraintCovariance - The stacked covariance. - params : tuple of Parameter - Free parameters of this constraint: covariance params followed by - likelihood params (e.g. Student-t ``nu``). - n_params : int - ``len(params)``. - active : np.ndarray - Stacked indices of the active points. - n_data_pts : int - Number of *active* points (the ``n`` of the likelihood). - n_data_pts_total : int - Length of the full stack. + data : Dataset + model : Model + Bound to ``data.x`` with ``data.meta`` at construction. + space : Transform or callable, optional + Parameter-free comparison transform applied to the data once and to + every prediction. ``y = space(data.y)``, ``y_err`` by the delta + method, and the log-Jacobian are constants. Non-finite values are + allowed here (the point may be masked); the compile step checks the + active points and names the comparison. """ - def __init__( - self, - observations: list[Observation], - physical_model: PhysicalModel, - likelihood=None, - extra_terms=(), - include_statistical_term: bool = True, - mask=None, - ): - self.observations = list(observations) - self.physical_model = physical_model - self.likelihood = likelihood if likelihood is not None else GaussianLikelihood() - - observations = self.observations - supports = stacked_supports(observations) - self._supports = supports - self.n_data_pts_total = sum(o.n_data_pts for o in observations) - - self.observation_mask = self._observation_mask(mask) - self.active = np.concatenate( - [ - s[o.mask] if keep else np.zeros(0, dtype=int) - for o, s, keep in zip(observations, supports, self.observation_mask) - ] - ).astype(int) - self.n_data_pts = int(self.active.size) - - # x and y are invariant per constraint; stack them once. Frozen - # because they are shared across every likelihood evaluation. - self._x_stacked = np.concatenate([o.x for o in observations]) - self._y_stacked = np.concatenate([o.y for o in observations]) - self._x_stacked.setflags(write=False) - self._y_stacked.setflags(write=False) - - if include_statistical_term: - terms = [obs.statistical_term(s) for obs, s in zip(observations, supports)] - else: - terms = [] - terms += list(extra_terms) - self.covariance = ConstraintCovariance( - terms, self.n_data_pts_total, blocks=supports, active=self.active - ) - - self.params = tuple(self.covariance.params) + tuple(self.likelihood.params) - self.n_params = len(self.params) - self._n_cov_params = self.covariance.n_params - - self._validate_parameter_names() - if self.covariance.is_constant: - self._validate_constant_covariance() - - def _observation_mask(self, mask): - n = len(self.observations) - if mask is None: - return np.ones(n, dtype=bool) - m = np.asarray(mask) - if m.dtype == bool: - if m.shape != (n,): - raise ValueError(f"mask must have one entry per observation ({n})") - return m - idx = np.asarray(m, dtype=int) - if n > 1 and idx.shape == (n,) and np.isin(idx, (0, 1)).all(): + data: Dataset + model: Model + space: Any = identity + predictor: Predictor = field(init=False, repr=False) + y: np.ndarray = field(init=False, repr=False) + y_err: np.ndarray = field(init=False, repr=False) + log_jac: np.ndarray = field(init=False, repr=False) + + def __post_init__(self): + if not isinstance(self.data, Dataset): + raise TypeError(f"data must be a Dataset, got {type(self.data).__name__}") + if not isinstance(self.model, Model): + raise TypeError(f"model must be a Model, got {type(self.model).__name__}") + held = (self.data.meta or {}).get("quantity") + predicted = getattr(self.model, "quantity", None) + if held is not None and predicted is not None and held != predicted: raise ValueError( - f"ambiguous observation mask: an integer array of length {n} with " - "only 0/1 entries could be a boolean mask or a list of indices; " - "pass a bool array or integer indices" + f"dataset {self.data.label or 'dataset'!r} holds {held!r} but the " + f"model predicts {predicted!r}: convert the data " + "(from_measurement(..., quantity=)) or use a matching model" ) - out = np.zeros(n, dtype=bool) - out[idx] = True - return out - - # ------------------------------------------------------------------ - # Masked views - # ------------------------------------------------------------------ - - def masked(self, mask=None, point_masks=None): - """A new constraint over the same observations/model/terms with new masks. - - Parameters - ---------- - mask : sequence of bool or of int, optional - Observation-level mask (see the constructor); ``None`` keeps this - constraint's. - point_masks : sequence of array_like of bool, optional - One point mask per observation (``None`` entries keep that - observation's current mask). - - Notes - ----- - The new constraint shares the ``Term``/``Parameter`` objects with this - one, so its parameter vector is identical — it is a *view* for - evaluating the same likelihood on a different subset (e.g. held-out - scoring), not an independent constraint to place in the same - :class:`~rxmc.evidence.Evidence`. Sharing the terms is safe because - both constraints stack the same observations in the same order, so the - terms' bound supports and cached ``x``-dependent values stay valid. - """ - observations = list(self.observations) - if point_masks is not None: - if len(point_masks) != len(observations): - raise ValueError("point_masks must have one entry per observation") - observations = [ - o if pm is None else o.masked(pm) - for o, pm in zip(observations, point_masks) - ] - # hand over the already-built term list (statistical diagonals included) - # so the view shares the exact same Term/Parameter objects - return Constraint( - observations, - self.physical_model, - likelihood=self.likelihood, - extra_terms=self.covariance.terms, - include_statistical_term=False, - mask=self.observation_mask if mask is None else mask, + space = as_transform(self.space) + if space.params: + raise ValueError( + "a comparison space must be parameter-free; put parametric " + "transforms on the model (model | transform)" + ) + set_ = object.__setattr__ + set_(self, "space", space) + set_(self, "predictor", self.model.bind(self.data.x, self.data.meta)) + if space.is_identity: + set_(self, "y", self.data.y) + set_(self, "y_err", self.data.y_err) + set_(self, "log_jac", np.zeros(self.data.n)) + return + # constants of the data, held as numpy; a derivative may come back as a + # scalar, the Jacobian is per point + jac = np.broadcast_to( + np.abs(np.asarray(space.derivative(self.data.y))), (self.data.n,) ) + with np.errstate(all="ignore"): + set_(self, "y", np.asarray(space(self.data.y))) + set_(self, "y_err", jac * self.data.y_err) + set_(self, "log_jac", np.log(jac)) - def complement(self): - """The held-out counterpart: every currently inactive point becomes active - and every active point inactive. + @property + def n(self) -> int: + return self.data.n - An observation excluded wholesale at the constraint level is therefore - restored in full; an active observation whose point mask keeps every - point is dropped wholesale. See :meth:`masked` for the sharing caveat. - """ - # an observation dropped wholesale at the constraint level is restored - # in full; an active one has its point mask flipped - point_masks = [ - ~o.mask if keep else np.ones(o.n_data_pts, dtype=bool) - for o, keep in zip(self.observations, self.observation_mask) - ] - obs_mask = [ - not keep or o.n_active < o.n_data_pts - for o, keep in zip(self.observations, self.observation_mask) - ] - return self.masked(mask=np.array(obs_mask), point_masks=point_masks) - - def _validate_parameter_names(self): - """Reject ambiguous parameter names within this constraint. - - Sharing one sampled value between terms works by referencing the *same* - ``Parameter`` object (identity); two distinct objects with one name would - silently become two sampler columns with identical labels. - """ - model_names = {p.name for p in self.physical_model.params} - seen = set() - for p in self.params: - if p.name in seen: - raise ValueError( - f"Constraint has multiple distinct parameters named " - f"'{p.name}'. To share one sampled value between terms, " - "pass the SAME Parameter object to each term; otherwise " - "give each parameter a unique name." - ) - seen.add(p.name) - if p.name in model_names: - raise ValueError( - f"Constraint parameter '{p.name}' collides with a " - "physical-model parameter of the same name; rename the " - "covariance/likelihood parameter." - ) + def predict(self, *values) -> np.ndarray: + """The prediction on the data grid, in comparison space.""" + ym = self.predictor(*values) + return ym if self.space.is_identity else self.space(ym) - def _validate_constant_covariance(self): - """Fail fast on a singular constant covariance (also warms the cache). + def log_jacobian(self, mask=None) -> float: + r"""``sum(log |space'(data.y)|)`` over the active points. - A routine trigger is an EXFOR measurement reporting no statistical - error: ``from_measurement`` then yields an all-zero ``y_stat_err``, and - without an extra covariance term the stacked covariance is singular. - Catching it here names the offending dataset instead of surfacing an - opaque ``LinAlgError`` deep inside a sampler. + A constant in the parameters, needed only to compare marginal + likelihoods across comparison spaces (``log Z_raw = log Z_transformed + + log_jacobian``). Zero for the identity. + """ + lj = self.log_jac if mask is None else self.log_jac[np.asarray(mask, bool)] + return float(np.sum(lj)) + + def reported_terms(self) -> list[Term]: + """The dataset's reported systematics as fixed rank-one modes, ``on=self``. + + Opt-in: nothing is folded into a covariance automatically. The + absolute offset mode comes first, then the fractional normalisation + mode, each skipped when its magnitude is zero. Both are propagated + to the comparison space by the delta method: the offset is an error on + the *data* and is linearised at the data; the normalisation multiplies + the *prediction* and is linearised at the prediction, which needs the + space's inverse. A scalar normalisation error gives a mode that is a + function of the prediction alone, so it also has a value on a new grid + (:func:`~rxmc.predictive.grid_draws`); an offset, or a per-point + normalisation, is defined only at the measured points. """ - ctx = StackContext.constant(self._x_stacked, self._y_stacked, self._supports) - cov = self.covariance - try: - # warm whichever factorisation the likelihood path will use - if cov.uses_block_path: - cov.block_cholesky(ctx) + d, t = self.data, self.space + terms = [] + omega = _reported(d.offset_err, d.n) + if omega is not None: + if not t.is_identity: + omega = np.abs(np.asarray(t.derivative(d.y))) * omega + terms.append(Term(omega, kind="mode", on=self)) + eta = _reported(d.norm_err, d.n) + if eta is not None and np.ndim(d.norm_err) == 0: + # a scalar keeps the mode a function of the prediction alone, so + # it can be evaluated on any grid (grid_draws), like + # T.normalization(magnitude=) + eta = float(d.norm_err) + if eta is not None: + if t.is_identity: + terms.append(Term(lambda c: eta * c.ym, kind="mode", on=self)) else: - cov.cholesky(ctx) - except np.linalg.LinAlgError as err: - labels = [ - o.label or f"observation {i}" for i, o in enumerate(self.observations) - ] - Sigma = self.covariance.matrix(ctx) - zero_rows = self.active[np.diag(Sigma)[self.active] == 0.0] - offenders = [ - label - for label, s in zip(labels, self._supports) - if np.isin(s, zero_rows).any() - ] - msg = ( - f"Constraint covariance over [{', '.join(labels)}] is singular " - "(Cholesky factorization failed)." - ) - if offenders: - msg += ( - f" The covariance diagonal is zero on rows belonging to " - f"{offenders}: these datasets report zero statistical error " - "and no other covariance term covers their points." - ) - msg += ( - " Remedies: pass the dataset's reported systematics as terms " - "(extra_terms=[*obs.systematic_terms()]; for a multi-observation " - "constraint place them with support= from " - "rxmc.covariance.stacked_supports(observations)), add a " - "noise_term or a fixed Term covering those points, or compose " - "the full covariance explicitly with include_statistical_term=False." - ) - raise ValueError(msg) from err + inv = t.inverse + if inv is None: + raise ValueError( + f"comparison space {t.name!r} has no inverse; the " + "normalisation systematic needs the physical-space prediction" + ) - # ------------------------------------------------------------------ - # Stacking - # ------------------------------------------------------------------ + def basis(c, eta=eta, t=t, inv=inv): + ym_raw = inv(c.ym) + return eta * ym_raw * jnp.abs(t.derivative(ym_raw)) - def _stack(self, model_params): - ym = [self.physical_model(o, *model_params) for o in self.observations] - return self._stack_from_predictions(ym) + terms.append(Term(basis, kind="mode", on=self)) + return terms - def _stack_from_predictions(self, ym: list): - if len(ym) != len(self.observations): - raise ValueError( - f"expected {len(self.observations)} prediction arrays, got {len(ym)}" - ) - ym_arrays = [] - for o, y in zip(self.observations, ym): - y = np.asarray(y, dtype=float) - if y.shape != o.y.shape: - raise ValueError( - f"prediction shape {y.shape} does not match observation shape " - f"{o.y.shape}" - ) - ym_arrays.append(o.transform(y)) - return StackContext( - x=self._x_stacked, - y=self._y_stacked, - ym=np.concatenate(ym_arrays), - supports=self._supports, - ) + def __repr__(self): + label = self.data.label or "dataset" + return f"Comparison({label!r}, {self.model!r}, space={self.space.name})" - def _split(self, params): - params = tuple(params) - if len(params) != self.n_params: - names = ", ".join(p.name for p in self.params) or "none" - raise ValueError( - f"Constraint expects {self.n_params} parameter(s) [{names}], " - f"got {len(params)}" - ) - return params[: self._n_cov_params], params[self._n_cov_params :] - # ------------------------------------------------------------------ - # Likelihood - # ------------------------------------------------------------------ +def _reported(spec, n): + """A reported magnitude as a length-``n`` array, or ``None`` when absent/zero.""" + if spec is None or not np.any(np.asarray(spec) != 0.0): + return None + return np.broadcast_to(np.asarray(spec, dtype=float), (n,)).copy() - def _evaluate(self, ctx, cov_params, statistic, *, invalid=-np.inf): - """Evaluate ``statistic(d2, logdet, n, *like_params)`` on the stack. - ``invalid`` is returned when the prediction is not finite on the active - points (e.g. a non-positive prediction under a log comparison space): - ``-inf`` for a log likelihood (default), ``+inf`` for a chi-squared. - """ - cov_part, like_part = self._split(cov_params) - if not np.all(np.isfinite(ctx.ym[self.active])): - return invalid - d2, logdet = self.covariance.stacked_distance(ctx, cov_part) - return statistic(d2, logdet, self.n_data_pts, *like_part) - - def log_likelihood(self, model_params, cov_params=()): - """Log likelihood of the stacked observations given the model. - - Parameters - ---------- - model_params : tuple - Physical-model parameters. - cov_params : tuple, optional - Constraint parameters: covariance params followed by likelihood - params, in :attr:`params` order. - """ - ctx = self._stack(model_params) - return self._evaluate(ctx, cov_params, self.likelihood.log_likelihood) - - def marginal_log_likelihood(self, ym: list, *cov_params): - """Log likelihood from pre-computed predictions (Gibbs hook). - - Parameters - ---------- - ym : list of np.ndarray - One prediction array per observation (no physical-model re-eval). - *cov_params : float - Constraint parameters, in :attr:`params` order. - """ - ctx = self._stack_from_predictions(ym) - return self._evaluate(ctx, cov_params, self.likelihood.log_likelihood) +def _as_mask(mask, n) -> np.ndarray: + # a copy, so the caller reusing its array can't move the mask + mask = np.array(mask, dtype=bool) + if mask.shape != (n,): + raise ValueError(f"mask must have shape ({n},), got {mask.shape}") + return mask - def chi2(self, model_params, cov_params=()): - """Generalised chi-squared (Mahalanobis distance) over the stack. - ``cov_params`` is the full constraint tuple in :attr:`params` order, - including likelihood params (e.g. Student-t ``nu``) even though the - chi-squared statistic ignores them. - """ - ctx = self._stack(model_params) - return self._evaluate(ctx, cov_params, self.likelihood.chi2, invalid=np.inf) +@dataclass(eq=False, frozen=True) +class Constraint: + """The maximal block of mutually correlated data: one likelihood. - def predict(self, *model_params, raw=False): - """Predictions for each observation (all points, comparison space). + Parameters + ---------- + comparisons : iterable of Comparison + Distinct comparisons; each is one block of the stacked covariance. + terms : iterable of Term, optional + Covariance contributions, authored in comparison space. + likelihood : Likelihood, optional + Functional of ``(d2, logdet, n)``; :class:`~rxmc.likelihood.Gaussian` + by default. + weight : float, optional + Tempering: multiplies this constraint's log-likelihood only. + statistical : bool, optional + Add each comparison's ``y_err`` diagonal (default). ``False`` composes + the whole covariance from ``terms``. + masks : sequence of bool arrays, optional + Active points, one array per comparison; ``None`` means all active. + """ - With ``raw=True`` the predictions are returned in physical space (the - model's own output, before each observation's ``transform``). - """ - ym = [self.physical_model(obs, *model_params) for obs in self.observations] - if raw: - return ym - return [o.transform(y) for o, y in zip(self.observations, ym)] - - def _stack_and_covariance(self, model_params, cov_params, active_only): - """``(ctx, Sigma)`` at a parameter point; ``Sigma`` is a fresh copy.""" - ctx = self._stack(model_params) - cov_part, _ = self._split(cov_params) - if active_only: - return ctx, np.array(self.covariance.active_matrix(ctx, *cov_part)) - return ctx, np.array(self.covariance.matrix(ctx, *cov_part)) - - def predict_and_covariance(self, model_params, cov_params=()): - """Stacked prediction and covariance on the active points, one model call. - - Returns - ------- - (np.ndarray, np.ndarray) - ``(ym, Sigma)`` with ``ym`` of length ``n_data_pts`` (comparison - space) and ``Sigma`` a fresh ``(n_data_pts, n_data_pts)`` array. - """ - ctx, Sigma = self._stack_and_covariance(model_params, cov_params, True) - return ctx.ym[self.active], Sigma + comparisons: Any + terms: Any = () + likelihood: Likelihood = field(default_factory=Gaussian) + weight: float = 1.0 + statistical: bool = True + masks: Any = None + offsets: tuple = field(init=False, repr=False) + active: np.ndarray = field(init=False, repr=False) + + def __post_init__(self): + set_ = object.__setattr__ + comps = tuple(self.comparisons) + for c in comps: + if not isinstance(c, Comparison): + raise TypeError(f"comparisons must be Comparison objects, got {c!r}") + if len({id(c) for c in comps}) != len(comps): + raise ValueError("comparisons must be distinct objects") + if not comps: + raise ValueError("a constraint needs at least one comparison") + terms = tuple(self.terms) + for t in terms: + if not isinstance(t, Term): + raise TypeError(f"terms must be Term objects, got {type(t).__name__}") + if not isinstance(self.likelihood, Likelihood): + raise TypeError("likelihood must be a Likelihood") + weight = float(self.weight) + if not (np.isfinite(weight) and weight >= 0): + raise ValueError(f"weight must be finite and non-negative, got {weight}") + ns = [c.n for c in comps] + starts = np.concatenate([[0], np.cumsum(ns)[:-1]]).astype(int) + offsets = tuple(slice(int(s), int(s + n)) for s, n in zip(starts, ns)) + if self.masks is None: + masks = None + active = np.arange(int(sum(ns))) + else: + masks = tuple(self.masks) + if len(masks) != len(comps): + raise ValueError( + f"masks must have one entry per comparison ({len(comps)})" + ) + masks = tuple(_as_mask(m, n) for m, n in zip(masks, ns)) + active = np.concatenate( + [np.arange(o.start, o.stop)[m] for o, m in zip(offsets, masks)] + ).astype(int) + set_(self, "comparisons", comps) + set_(self, "terms", terms) + set_(self, "weight", weight) + set_(self, "masks", masks) + set_(self, "offsets", offsets) + set_(self, "active", active) + for t in terms: # eager: every on= resolves here, arrays have the right shape + rows = self.support(t.on) + if t.relative: + nonlinear = [ + c + for c, o in zip(comps, offsets) + if not c.space.is_identity + and np.isin(rows, np.arange(o.start, o.stop)).any() + ] + if nonlinear: + raise ValueError( + f"a relative term (proportional_error, normalization) on " + f"{nonlinear[0]!r}: a fraction of the prediction is a relative " + "error only in the identity (linear) space, and every other " + f"space is refused, {nonlinear[0].space.name!r} included; in " + "log space use noise() for an uncorrelated relative error and " + "offset() for a normalisation" + ) + if not callable(t.fn) and t.fn.shape != t.expected_shape(len(rows)): + raise ValueError( + f"{t.kind} term expects shape {t.expected_shape(len(rows))} on " + f"its support, got {t.fn.shape}" + ) + + # -- structure ---------------------------------------------------------- @property - def y(self) -> np.ndarray: - """Stacked observed data on the active points (comparison space).""" - return self._y_stacked[self.active] + def n_total(self) -> int: + return int(sum(c.n for c in self.comparisons)) @property - def x(self) -> np.ndarray: - """Stacked independent variable on the active points.""" - return self._x_stacked[self.active] + def n_active(self) -> int: + return int(self.active.size) @property def log_jacobian(self) -> float: - """Sum of the observations' comparison-space log-Jacobians (active points).""" - return float( - sum( - o.log_jacobian - for o, keep in zip(self.observations, self.observation_mask) - if keep - ) - ) + """Sum of the comparisons' log-Jacobians over the active points.""" + masks = self.masks or (None,) * len(self.comparisons) + return float(sum(c.log_jacobian(m) for c, m in zip(self.comparisons, masks))) + + def support(self, on) -> np.ndarray: + """The stacked rows a term's ``on`` resolves to, in constraint order.""" + if on is None: + return np.arange(self.n_total) + if isinstance(on, (Comparison, Dataset)): + targets = [on] + else: + try: + targets = list(on) + except TypeError: + raise TypeError( + f"on= must reference comparisons or datasets, got {on!r}" + ) from None + keep = np.zeros(len(self.comparisons), dtype=bool) + for target in targets: + if isinstance(target, Comparison): + hits = [i for i, c in enumerate(self.comparisons) if c is target] + elif isinstance(target, Dataset): + hits = [i for i, c in enumerate(self.comparisons) if c.data is target] + else: + raise TypeError( + f"on= must reference comparisons or datasets, got {target!r}" + ) + if not hits: + raise ValueError( + f"term on={target!r} does not reference a comparison of this " + "constraint" + ) + keep[hits] = True + return np.concatenate( + [np.arange(o.start, o.stop) for o, k in zip(self.offsets, keep) if k] + ).astype(int) - def covariance_matrix(self, model_params, cov_params=(), active_only=True): - """Assemble the stacked covariance matrix Σ at a parameter point. - - Convenience accessor (e.g. for visualising the off-diagonal block - structure of correlated observations). - - Parameters - ---------- - model_params : tuple - Physical-model parameters (needed for prediction-scaled terms). - cov_params : tuple, optional - Constraint parameters: covariance params followed by likelihood - params, in :attr:`params` order (matching :meth:`log_likelihood`). - active_only : bool, optional - Restrict to the active points (default); ``False`` returns the - full stacked matrix. - - Returns - ------- - np.ndarray - Shape ``(n_data_pts, n_data_pts)`` (active points) or - ``(n_data_pts_total, n_data_pts_total)`` when ``active_only=False``. - A fresh copy (safe to mutate; never aliases the internal cache). - """ - _, Sigma = self._stack_and_covariance(model_params, cov_params, active_only) - return Sigma - - # ------------------------------------------------------------------ - # Coverage diagnostics - # ------------------------------------------------------------------ - - def num_pts_within_interval( - self, ylow: list[np.ndarray], yhigh: list[np.ndarray], xlim=None - ): - """Count data points that fall within a predictive interval.""" - return sum( - obs.num_pts_within_interval(ylow[i], yhigh[i], xlim) - for i, obs in enumerate(self.observations) - if self.observation_mask[i] - ) + # -- masked views --------------------------------------------------------- - def empirical_coverage( - self, ylow: list[np.ndarray], yhigh: list[np.ndarray], xlim=None - ): - """Fraction of active data points within a predictive interval. + def masked(self, masks) -> "Constraint": + """The same constraint with new active-point masks.""" + return replace(self, masks=masks) - ``nan`` when the constraint has no active points. - """ - if self.n_data_pts == 0: - return float("nan") - return self.num_pts_within_interval(ylow, yhigh, xlim) / self.n_data_pts + def masked_where(self, predicate: Callable) -> "Constraint": + """Active where ``predicate(comparison.data.x)`` is true, per comparison.""" + return self.masked([predicate(c.data.x) for c in self.comparisons]) + + def complement(self) -> "Constraint": + """Every inactive point active, and vice versa.""" + if self.masks is None: + return self.masked([np.zeros(c.n, dtype=bool) for c in self.comparisons]) + return self.masked([~m for m in self.masks]) + + def __repr__(self): + return ( + f"Constraint({len(self.comparisons)} comparison(s), {len(self.terms)} " + f"term(s), {type(self.likelihood).__name__}, n_active={self.n_active})" + ) diff --git a/src/rxmc/covariance.py b/src/rxmc/covariance.py index 86e349e..dead276 100644 --- a/src/rxmc/covariance.py +++ b/src/rxmc/covariance.py @@ -1,904 +1,430 @@ """ -Stacked-covariance model for a :class:`~rxmc.constraint.Constraint`. - -A constraint owns one multivariate-normal distribution over the *stacked* vector -of all its observations, ``y = [y1; y2; ...]``. The covariance of that MVN is -built additively from :class:`Term` objects, each of which writes its -contribution into a sub-block of the stacked covariance matrix selected by an -index array ``support`` (``None`` = the whole constraint). - -Two mechanisms are expressed here (see ``docs/design.md``): - -* **Correlating observations (A)** — a term whose ``support`` spans more than one - observation block writes off-diagonal blocks, coupling the data. A - block-diagonal covariance (every term local to one block) reproduces the old - per-observation summed likelihood as a special case. -* **Sharing a parameter (B)** — terms declare the :class:`~rxmc.params.Parameter` - objects they consume *by identity*. :class:`ConstraintCovariance` deduplicates - them (gather, not slice): two terms referencing the *same* ``Parameter`` object - share one entry in the sampled vector. - -There is exactly **one** term type. A :class:`Term` is a numpy-style callable -``fn(c, *values) -> array`` of a :class:`TermContext` ``c`` (the term's local view -of ``x``, ``y`` and ``ym`` on its support, with ``x`` passed through an optional -coordinate :class:`~rxmc.transforms.Transform`) and its parameter values, plus a -``kind`` that says how the returned array enters the covariance: - -``"diag"`` - ``fn`` returns a standard-deviation vector ``v``; ``Sigma_ii += v_i**2``. -``"mode"`` - ``fn`` returns a vector ``v``; ``Sigma += outer(v, v)`` (one correlated mode). -``"matrix"`` - ``fn`` returns a full block ``M``; ``Sigma_block += M``. - -The factory helpers (:func:`statistical_term`, :func:`normalization_term`, -:func:`offset_term`, :func:`noise_term`, :func:`noise_fraction_term`, -:func:`model_error_term`, :func:`systematic_term`, :func:`kernel_term`) are -one-line conveniences that build the common terms; anything they cannot express -is a direct ``Term(fn, params, kind=...)``. -""" +The structured covariance of a constraint. -from dataclasses import dataclass +The three term kinds describe a decomposition of the stacked covariance over +a constraint's comparisons (one block per comparison): -import numpy as np -import scipy as sc - -from .params import Parameter -from .transforms import as_transform - -__all__ = [ - "StackContext", - "TermContext", - "Term", - "ConstraintCovariance", - "stacked_supports", - "chol_logdet", - "as_2d", - "ones", - "ym", - "averaging", - "x_basis", - "exp_growth", - "constant_amplitude", - "exp_growth_amplitude", - "statistical_term", - "offset_term", - "normalization_term", - "noise_term", - "noise_fraction_term", - "model_error_term", - "systematic_term", - "kernel_term", -] - -KINDS = ("diag", "mode", "matrix") - - -@dataclass(frozen=True) -class StackContext: - """Bundle of stacked arrays passed to every :meth:`Term.add_to`. +.. math:: - Parameters - ---------- - x : np.ndarray - Stacked independent variable, ``np.concatenate`` over observations. - y : np.ndarray - Stacked observed data (in each observation's comparison space). - ym : np.ndarray or None - Stacked model prediction (same space as ``y``). ``None`` when a - *constant* covariance is assembled before any model evaluation (see - :meth:`constant`); constant terms never read it. - supports : tuple of np.ndarray - One contiguous index array per observation block, in stacking order. - """ + \\Sigma = \\mathrm{diag}(D) + \\mathrm{blockdiag}(M_b) + U U^T - x: np.ndarray - y: np.ndarray - ym: np.ndarray | None - supports: tuple +``D`` collects every ``diag`` term (squared), ``M_b`` the ``matrix`` terms that +lie inside block ``b``, and each ``mode`` term is one column of ``U``, zero off +its support. A mode spanning several blocks is a column with entries in +several blocks, and costs nothing beyond its rank. With +``B = blockdiag(M_b + diag(D_b))`` and per-block Cholesky factors ``L_b``, - @classmethod - def constant(cls, x, y, supports) -> "StackContext": - """A stack with no model prediction, for assembling constant terms.""" - return cls(x=x, y=y, ym=None, supports=tuple(supports)) +.. math:: + z = L^{-1} r, \\quad W = L^{-1} U, \\quad S = I_r + W^T W, \\\\ + d^2 = z^T z - (W^T z)^T S^{-1} (W^T z), \\quad + \\log\\det\\Sigma = \\sum_b \\log\\det B_b + \\log\\det S -@dataclass(frozen=True) -class TermContext: - """A term's local view of the stack on its own support. +so the cost is :math:`O(\\sum_b n_b^3 + N r^2 + r^3)` instead of +:math:`O(N^3)`. A ``matrix`` term whose support crosses blocks (a Gaussian +process over the union of two datasets) forces the dense path for that +constraint. Masking selects rows before assembly. Constant parts are +evaluated once; a covariance with no parametric part is factored once. - ``x`` are the coordinates on the support — ``ctx.x[support]`` passed - through the term's ``coords`` transform (so ``x`` may be 2-D); ``y`` and - ``ym`` are the observed data and model prediction on the support (``ym`` is - ``None`` when a constant covariance is assembled without a model - prediction), and ``support`` the stacked indices this view corresponds to. - ``len(c)`` is the number of points. - """ +``B`` must be positive definite. A block covered only by modes is singular in +``B`` even when ``Sigma`` is not; when every term is constant this is caught at +construction and reported with the block's label. - x: np.ndarray - y: np.ndarray - ym: np.ndarray | None - support: np.ndarray +The layout (which rows each term writes, which block it lives in, the active +positions of every block) is fixed at construction and held as numpy index +arrays; only the values are computed per ``theta``, in ``jax.numpy``, so +:meth:`StructuredCovariance.distance` is traceable and differentiable. A +parametric covariance that is not positive definite at some ``theta`` gives a +NaN ``logdet`` there rather than raising (:func:`chol_logdet`), with a finite +gradient; the compiled constraint reads that as zero density. +""" - def __len__(self): - return len(self.support) +from __future__ import annotations +import jax +import jax.numpy as jnp +import jax.scipy.linalg as jsla +import numpy as np -def stacked_supports(observations) -> tuple: - """One contiguous index array per observation, in stacking order. +from .terms import Term - The block layout of the stacked vector ``y = [y1; y2; ...]``: - ``Constraint`` uses this internally; callers only need it to place a term on - a *subset* of a constraint's observations (``support=None`` covers all). - """ - supports, b = [], 0 - for obs in observations: - supports.append(np.arange(b, b + obs.n_data_pts)) - b += obs.n_data_pts - return tuple(supports) +__all__ = ["StructuredCovariance", "chol_logdet"] +@jax.custom_jvp def chol_logdet(Sigma): - """Lower Cholesky factor and log-determinant of a positive-definite matrix.""" - L = sc.linalg.cholesky(Sigma, lower=True) - return L, 2.0 * float(np.sum(np.log(np.diag(L)))) - + """Lower Cholesky factor and log-determinant of a positive-definite matrix. -def as_2d(X) -> np.ndarray: - """Promote a 1-D input grid to a single-column 2-D array (sklearn kernels).""" - X = np.asarray(X, dtype=float) - return X[:, None] if X.ndim == 1 else X - - -# ---------------------------------------------------------------------------- -# The term -# ---------------------------------------------------------------------------- - - -class Term: - """One additive contribution to the stacked covariance. - - Parameters - ---------- - fn : callable or array_like - ``fn(c, *values) -> np.ndarray`` with ``c`` a :class:`TermContext` and - ``values`` the sampled values of ``params`` (in order). A plain array is a - fixed contribution (``constant=True`` implied): a standard-deviation - vector for ``kind="diag"``, a mode vector for ``"mode"``, or a symmetric - block for ``"matrix"``. - params : sequence of Parameter, optional - Parameters consumed by ``fn``, matched *by identity* across terms - (pass the same object to two terms to share one sampled value). - kind : {"diag", "mode", "matrix"} - How the returned array enters the covariance (see module docstring). - support : array_like of int, optional - Indices into the stacked vector. ``None`` (default) means the whole - constraint; it is resolved when the term is added to a - :class:`ConstraintCovariance`. - coords : Transform or callable, optional - Coordinate transform applied to ``x[support]`` before ``fn`` sees it - (e.g. angle to momentum transfer). Its parameters, if any, are appended - to :attr:`params`. - constant : bool, optional - Declare that a *callable* ``fn`` does not read ``c.ym`` (the model - prediction) and has no parameters, so the contribution can be evaluated - once and cached. ``c.x`` and ``c.y`` are invariant per constraint and - may be read freely (e.g. a fixed-hyperparameter kernel over ``x``). A - constant term is first evaluated with ``c.ym is None``, so a - mis-declared term fails loudly. Ignored (``True``) for array ``fn``. - - Notes - ----- - A Term is stateful: its support is bound once (see :meth:`bind`) and - constant or coordinate-transformed values are cached on the assumption that - the constraint's ``x`` never changes. Build a fresh Term per constraint; - only masked views of one constraint (which stack the same observations) - may share Terms. + Where ``Sigma`` is not positive definite the factor is the identity and the + log-determinant NaN, with a zero tangent: the caller reads the NaN as zero + density, and the gradient there stays finite (a failed factor would + otherwise send NaN back through the discarded branch). """ + Sigma = jnp.asarray(Sigma, dtype=float) + L = jnp.linalg.cholesky(Sigma) + ok = jnp.all(jnp.isfinite(L)) + L = jnp.where(ok, L, jnp.eye(Sigma.shape[-1])) + return L, jnp.where(ok, 2.0 * jnp.sum(jnp.log(jnp.diag(L))), jnp.nan) - def __init__( - self, - fn, - params=(), - *, - kind="matrix", - support=None, - coords=None, - constant=False, - ): - if kind not in KINDS: - raise ValueError(f"kind must be one of {KINDS}, got {kind!r}") - self.kind = kind - self.coords = as_transform(coords) - fn_params = tuple(params) - for p in fn_params + self.coords.params: - if not isinstance(p, Parameter): - raise TypeError(f"params must be Parameter objects, got {p!r}") - self._n_fn_params = len(fn_params) - self.params = fn_params + self.coords.params - self.support = None - self._bound_N = None - self._cache = None - self._x_cache = None - if callable(fn): - self.fn = fn - self._array = None - self.is_constant = bool(constant) and not self.params - else: - self.fn = None - self._array = np.asarray(fn, dtype=float) - if self.params: - raise ValueError("an array-valued term cannot have parameters") - self.is_constant = True - if support is not None: - self._set_support(np.asarray(support, dtype=int)) - - # -- structure ---------------------------------------------------------- - - @property - def couples_offdiagonal(self) -> bool: - """Whether the term can write off-diagonal entries (``kind != "diag"``).""" - return self.kind != "diag" - - @property - def bound(self) -> bool: - return self.support is not None - - def bind(self, N: int) -> None: - """Resolve ``support=None`` to the whole stack of length ``N``. - - Idempotent for the same ``N``; a term constructed with an explicit - support is untouched. Re-binding to a *different* ``N`` raises: one - Term belongs to one constraint (masked views of that constraint share - its stack, see :meth:`rxmc.constraint.Constraint.masked`). - """ - N = int(N) - if self.support is None: - self._set_support(np.arange(N)) - self._bound_N = N - elif self._bound_N is not None and self._bound_N != N: - raise ValueError( - f"Term already bound to a stack of length {self._bound_N}; cannot " - f"re-bind it to length {N}. One Term belongs to one constraint " - "(masked views of the same constraint share its stack)" - ) +@chol_logdet.defjvp +def _chol_logdet_jvp(primals, tangents): + # the standard Cholesky derivative, dL = L Phi(L^-1 dSigma L^-T), but on the + # safe factor and a zeroed tangent where Sigma is not positive definite + L, logdet = chol_logdet(*primals) + dS = jnp.where(jnp.isfinite(logdet), tangents[0], 0.0) + dS = 0.5 * (dS + dS.T) + X = _solve_lower(L, _solve_lower(L, dS).T).T + phi = jnp.tril(X) - 0.5 * jnp.diag(jnp.diag(X)) + return (L, logdet), (L @ phi, jnp.trace(X)) - def _set_support(self, ix: np.ndarray) -> None: - self.support = ix - n = len(ix) - # supports from ``stacked_supports`` (and the whole stack) are - # contiguous: index the block with slices instead of a gather/scatter - if n and np.array_equal(ix, np.arange(ix[0], ix[0] + n)): - sl = slice(int(ix[0]), int(ix[0]) + n) - self._block = (sl, sl) - else: - self._block = np.ix_(ix, ix) - if self._array is not None: - self._validate_bound() - - @property - def _expected_shape(self) -> tuple: - n = len(self.support) - return (n, n) if self.kind == "matrix" else (n,) - - def _validate_bound(self): - a = self._array - if a.shape != self._expected_shape: - raise ValueError( - f"{self.kind} term expects shape {self._expected_shape}, got {a.shape}" - ) - if self.kind == "matrix" and not np.allclose(a, a.T): - raise ValueError("matrix term must be symmetric") - # -- evaluation ----------------------------------------------------------- +def _solve_lower(L, b): + return jsla.solve_triangular(L, b, lower=True) - def _check_bound(self): - if self.support is None: - raise ValueError( - "term support is unresolved; add it to a Constraint / " - "ConstraintCovariance (which binds support=None to the whole " - "stack) or pass support= explicitly" - ) - def local_context(self, ctx: StackContext, theta=()) -> TermContext: - """The :class:`TermContext` this term sees at ``theta``.""" - self._check_bound() - theta = np.asarray(theta, dtype=float) - if len(theta) != len(self.params): - raise ValueError(f"expected {len(self.params)} params, got {len(theta)}") - ix = self.support - x = self._coords_x(ctx, theta) - ym = None if ctx.ym is None else ctx.ym[ix] - return TermContext(x=x, y=ctx.y[ix], ym=ym, support=ix) - - def _coords_x(self, ctx, theta): - """``coords(x[support])``; cached when the transform is parameter-free - (``x`` is invariant per constraint).""" - if self.coords.is_identity: - return ctx.x[self.support] - if self.coords.params: - return self.coords(ctx.x[self.support], *theta[self._n_fn_params :]) - if self._x_cache is None: - self._x_cache = self.coords(ctx.x[self.support]) - self._x_cache.setflags(write=False) - return self._x_cache - - def value(self, ctx: StackContext, theta=()) -> np.ndarray: - """The raw array ``fn`` returns (std vector, mode vector, or block).""" - self._check_bound() - if self._array is not None: - return self._array - if self.is_constant and self._cache is not None: - return self._cache - theta = np.asarray(theta, dtype=float) - if len(theta) != len(self.params): - raise ValueError(f"expected {len(self.params)} params, got {len(theta)}") - c = self.local_context(ctx, theta) - v = np.asarray(self.fn(c, *theta[: self._n_fn_params]), dtype=float) - if v.shape != self._expected_shape: - raise ValueError( - f"{self.kind} term fn returned shape {v.shape}, " - f"expected {self._expected_shape}" - ) - if self.is_constant: - v.setflags(write=False) - self._cache = v - return v - - def add_to(self, Sigma: np.ndarray, ctx: StackContext, theta) -> None: - """Add this term's contribution to the stacked ``Sigma`` in place.""" - v = self.value(ctx, theta) - if self.kind == "diag": - ix = self.support - Sigma[ix, ix] += v**2 - elif self.kind == "mode": - Sigma[self._block] += np.outer(v, v) - else: - Sigma[self._block] += v +class _Entry: + """One term placed on rows of the stack, with its gather into theta. - def __repr__(self): - names = ", ".join(p.name for p in self.params) - sup = "all" if self.support is None else f"{len(self.support)} pts" - return f"Term(kind={self.kind!r}, params=({names}), support={sup})" + Every index array here is numpy and fixed at construction: ``kept`` are + the term's support positions that are active, ``at`` their positions in + the active stack, and ``local`` (a matrix term inside one block) their + positions among that block's active rows. + """ + + __slots__ = ( + "term", + "rows", + "gather", + "pos", + "keep", + "kept", + "at", + "local", + "block", + "segments", + "labels", + ) + def __init__(self, term, rows, gather, active, offsets, block_pos, labels): + self.term = term + self.rows = np.asarray(rows, dtype=int) + self.gather = np.asarray(gather, dtype=int) + # positions of this term's rows inside the active stack (-1: inactive) + lookup = np.full(int(offsets[-1].stop) if offsets else 0, -1, dtype=int) + lookup[active] = np.arange(len(active)) + self.pos = lookup[self.rows] + self.keep = self.pos >= 0 + self.kept = np.flatnonzero(self.keep) + self.at = self.pos[self.keep] + # the block a matrix term lives in, or None if it crosses blocks + blocks = { + i + for i, o in enumerate(offsets) + if np.any((self.rows >= o.start) & (self.rows < o.stop)) + } + self.block = blocks.pop() if len(blocks) == 1 else None + self.local = ( + np.searchsorted(block_pos[self.block], self.at) + if term.kind == "matrix" and self.block is not None + else None + ) + # the term's rows are in stack order, so each block's rows are contiguous + # within them: slices of the support per block, and the block labels + counts = [ + int(np.count_nonzero((self.rows >= o.start) & (self.rows < o.stop))) + for o in offsets + ] + stops = np.cumsum(counts) + self.segments = tuple( + slice(int(stop - n), int(stop)) for n, stop in zip(counts, stops) if n + ) + self.labels = tuple(str(lab) for n, lab in zip(counts, labels) if n) -# ---------------------------------------------------------------------------- -# Constraint-local covariance: gather-by-identity over the stacked space -# ---------------------------------------------------------------------------- +def _meta_rows(meta, rows): + if meta is None: + return None + return {k: np.asarray(v)[rows] for k, v in meta.items()} -class ConstraintCovariance: - """The stacked covariance of a constraint, assembled from :class:`Term` s. - Parameters are routed *by identity*: the unique ``Parameter`` objects across - all terms (first-seen order) form the flat parameter vector; each term gathers - its own parameters from that vector. Referencing the *same* ``Parameter`` - object in two terms makes them share one sampled value (case B). +class StructuredCovariance: + """``diag(D) + blockdiag(M_b) + U Uᵀ`` over the active rows of a constraint. Parameters ---------- - terms : sequence of Term - Additive covariance contributions. Terms with ``support=None`` are - bound to the whole stack here. - N : int - Dimension of the stacked vector. - blocks : sequence of np.ndarray, optional - One index array per observation block. When given, :attr:`block_diagonal` - is decided against the true block boundaries. When omitted, only a - covariance whose every term is strictly diagonal - (``couples_offdiagonal == False``) is classified block-diagonal; any - coupling-capable term conservatively forces the dense path — there is no - guessing of block structure from support shape. - active : array_like of int, optional - Indices of the *active* (unmasked) rows of the stack. The full - ``N x N`` matrix is always assembled (terms are authored in the full - space); factorisation and the Mahalanobis distance are restricted to - ``active``. ``None`` means all rows. - - ``terms`` and ``blocks`` are treated as immutable after construction: - :attr:`block_diagonal` and :attr:`is_constant` are decided once, here. + entries : sequence of (Term, rows, gather) + ``rows`` are the stacked indices the term applies to + (:meth:`~rxmc.constraint.Constraint.support`), ``gather`` the indices + into the flat parameter vector giving the term's values in + ``term.params`` order. + x, y : array_like + Stacked over the whole constraint, ``y`` in comparison space. + offsets : sequence of slice + One slice per comparison block. + active : array_like of int + Stacked indices of the active points, ascending. + meta : mapping, optional + ``{key: stacked array}`` of per-point metadata for ``TermContext.meta``. + labels : sequence of str, optional + One label per block, for error messages. """ - def __init__(self, terms, N, blocks=None, active=None): - self.terms = list(terms) - self.N = int(N) - for t in self.terms: - if not isinstance(t, Term): - raise TypeError(f"terms must be Term objects, got {type(t).__name__}") - t.bind(self.N) - self._blocks = ( - None if blocks is None else [np.asarray(b, dtype=int) for b in blocks] + def __init__(self, entries, x, y, offsets, active, *, meta=None, labels=None): + self.x = np.asarray(x) + self.y = np.asarray(y, dtype=float) + self.offsets = tuple(offsets) + self.active = np.asarray(active, dtype=int) + self.meta = meta + self.labels = ( + list(labels) + if labels is not None + else [f"block {i}" for i in range(len(self.offsets))] ) - if active is None: - self.active = None - else: - active = np.asarray(active, dtype=int) - self.active = None if np.array_equal(active, np.arange(self.N)) else active - self.n_active = self.N if self.active is None else int(self.active.size) - if self._blocks is not None and self.active is not None: - self._active_blocks = [b[np.isin(b, self.active)] for b in self._blocks] - else: - self._active_blocks = self._blocks - - params, index_of = [], {} - for t in self.terms: - for p in t.params: - if id(p) not in index_of: # dedup by identity -> sharing - index_of[id(p)] = len(params) - params.append(p) - self.params = tuple(params) - self._gather = [ - np.array([index_of[id(p)] for p in t.params], dtype=int) for t in self.terms - ] - self._const_cache = None - self._chol_cache = None - self._block_chol_cache = None - - self.block_diagonal = all( - not t.couples_offdiagonal or self._within_one_block(t.support) - for t in self.terms + self.n_active = int(self.active.size) + # active rows of each block, as positions in the active stack + self.block_pos = [] + for o in self.offsets: + inside = (self.active >= o.start) & (self.active < o.stop) + self.block_pos.append(np.flatnonzero(inside)) + self.entries = [] + for term, rows, gather in entries: + if not isinstance(term, Term): + raise TypeError(f"entries must hold Term objects, got {term!r}") + e = _Entry( + term, + rows, + gather, + self.active, + self.offsets, + self.block_pos, + self.labels, + ) + if np.any(e.keep): + self.entries.append(e) + self.dense = any( + e.term.kind == "matrix" and e.block is None for e in self.entries ) - self.is_constant = self.n_params == 0 and all(t.is_constant for t in self.terms) - - def _within_one_block(self, support) -> bool: - """True if ``support`` lies inside a single known observation block.""" - if self._blocks is None: - return False - support = np.asarray(support, dtype=int) - return any(bool(np.isin(support, b).all()) for b in self._blocks) - - @property - def n_params(self) -> int: - return len(self.params) - - @property - def blocks(self): - """Observation block index arrays, or ``None`` if unknown.""" - return self._blocks - - @property - def uses_block_path(self) -> bool: - """Whether :meth:`stacked_distance` factors block by block - (:meth:`block_cholesky`) rather than the whole active stack - (:meth:`cholesky`).""" - return ( - self.block_diagonal and self._blocks is not None and len(self._blocks) > 1 + self.constant_entries = [e for e in self.entries if e.term.is_constant] + self.parametric_entries = [e for e in self.entries if not e.term.is_constant] + self.is_constant = not self.parametric_entries + # theta must reach every gather; checked on its (static) shape, since a + # jax gather out of range clamps instead of raising + self.n_theta = max( + (int(e.gather.max()) + 1 for e in self.entries if e.gather.size), + default=0, ) + self._D0, self._U0, self._M0, self._X0 = self._pieces( + self.constant_entries, None, None + ) + self._cache = None + # a singular constant covariance fails now, by label, rather than as a + # zero density at every theta. Modes never enter B, so on the + # structured path every block no parametric diag or matrix term + # touches has a constant B, checked on its own + if self.is_constant and self.dense: + if not _is_pd(self._dense_matrix(self._D0, self._U0, self._M0, self._X0)): + raise ValueError(self._singular_message(self._D0)) + elif not self.dense: + self._check_blocks(self._D0, self._M0, self._constant_blocks()) + if self.is_constant: + self._cache = self._factor(self._D0, self._U0, self._M0, self._X0) + + # -- assembly ------------------------------------------------------------- + + def _pieces(self, entries, ym, theta): + """``(D, U_columns, M_blocks, cross_blocks)`` from a set of entries.""" + n = self.n_active + D = jnp.zeros(n) + U = [] + M = [None] * len(self.offsets) + X = [] # (positions, matrix) for cross-block matrix terms (dense path) + for e in entries: + t = e.term + values = () if theta is None else tuple(theta[e.gather]) + v = t.value( + self.x[e.rows], + self.y[e.rows], + None if ym is None else ym[e.rows], + *values, + meta=_meta_rows(self.meta, e.rows), + segments=e.segments, + labels=e.labels, + ) + if t.kind == "diag": + D = D.at[e.at].add(v[e.kept] ** 2) + elif t.kind == "mode": + U.append(jnp.zeros(n).at[e.at].set(v[e.kept])) + else: + sub = v[np.ix_(e.kept, e.kept)] + if e.block is None: + X.append((e.at, sub)) + else: + b = e.block + if M[b] is None: + nb = len(self.block_pos[b]) + M[b] = jnp.zeros((nb, nb)) + M[b] = M[b].at[np.ix_(e.local, e.local)].add(sub) + return D, U, M, X + + def _check_theta(self, theta): + theta = jnp.asarray(theta, dtype=float) + if theta.ndim != 1 or theta.shape[0] < self.n_theta: + raise ValueError( + f"theta has shape {theta.shape} but the covariance's terms index " + f"{self.n_theta} parameter(s)" + ) + return theta - def matrix(self, ctx, *theta) -> np.ndarray: - """Assemble the full stacked covariance matrix (all ``N`` rows). - - Parameters - ---------- - ctx : StackContext - Stacked arrays. ``ctx`` itself may be ``None`` only when every term - is array-valued. When :attr:`is_constant`, ``ctx.ym`` is never read - (it may be ``None``, see :meth:`StackContext.constant`) and the - result is cached. - *theta : float - One value per unique parameter, in :attr:`params` order. - """ - if len(theta) != self.n_params: - raise ValueError(f"expected {self.n_params} params, got {len(theta)}") - if self.is_constant and self._const_cache is not None: - return self._const_cache - theta = np.asarray(theta, dtype=float) - Sigma = np.zeros((self.N, self.N)) - for t, g in zip(self.terms, self._gather): - t.add_to(Sigma, ctx, theta[g]) + def _assemble(self, ym, theta): + """Constant pieces plus the parametric ones at ``theta``.""" if self.is_constant: - # cached arrays are shared across calls; freeze so aliasing - # bugs fail loudly instead of corrupting later evaluations - Sigma.setflags(write=False) - self._const_cache = Sigma + return self._D0, self._U0, self._M0, self._X0 + D, U, M, X = self._pieces(self.parametric_entries, ym, theta) + D = D + self._D0 + U = list(self._U0) + U + M = [ + a if b is None else (b if a is None else a + b) for a, b in zip(self._M0, M) + ] + return D, U, M, list(self._X0) + X + + def _dense_matrix(self, D, U, M, X): + Sigma = jnp.diag(D) + for b, Mb in enumerate(M): + if Mb is not None: + pos = self.block_pos[b] + Sigma = Sigma.at[np.ix_(pos, pos)].add(Mb) + for pos, sub in X: + Sigma = Sigma.at[np.ix_(pos, pos)].add(sub) + if U: + Uc = jnp.column_stack(U) + Sigma = Sigma + Uc @ Uc.T return Sigma - def active_matrix(self, ctx, *theta) -> np.ndarray: - """The covariance restricted to the active rows/columns.""" - Sigma = self.matrix(ctx, *theta) - if self.active is None: - return Sigma - return Sigma[np.ix_(self.active, self.active)] - - def cholesky(self, ctx, *theta): - """Lower Cholesky factor and log-determinant of the active stacked covariance. - - Cached when :attr:`is_constant`, so a fixed covariance is factored once. + # -- factorisation --------------------------------------------------------- - Returns - ------- - (np.ndarray, float) - ``(L, logdet)`` with ``L`` lower-triangular and - ``logdet = log det Sigma``. - """ - if self.is_constant and self._chol_cache is not None: - return self._chol_cache - L, logdet = chol_logdet(self.active_matrix(ctx, *theta)) - result = (L, logdet) - if self.is_constant: - L.setflags(write=False) - self._chol_cache = result - return result - - def block_cholesky(self, ctx, *theta): - """Per-block ``(L_i, logdet_i)`` factors, aligned with :attr:`blocks`. - - Only meaningful when :attr:`block_diagonal`; cached when - :attr:`is_constant` so a constant block-diagonal covariance is factored - once instead of on every likelihood evaluation. Blocks are restricted to - the active rows; a fully-masked block yields ``(empty, 0.0)``. - - Returns - ------- - tuple of (np.ndarray, float) - One ``(L_i, logdet_i)`` pair per block, ``L_i`` lower-triangular. - """ - if self._blocks is None: - raise ValueError("block_cholesky requires blocks to be set") - if self.is_constant and self._block_chol_cache is not None: - return self._block_chol_cache - Sigma = self.matrix(ctx, *theta) - factors = [] - for ix in self._active_blocks: - if ix.size == 0: - factors.append((np.zeros((0, 0)), 0.0)) + def _factor(self, D, U, M, X): + """Factor the covariance; the cached factors when constant.""" + if self._cache is not None: + return self._cache + if self.dense: + L, logdet = chol_logdet(self._dense_matrix(D, U, M, X)) + return ("dense", L, logdet) + blocks = [] + logdet = 0.0 + Ws = [] + Uc = jnp.column_stack(U) if U else None + for b, pos in enumerate(self.block_pos): + if pos.size == 0: + blocks.append(None) continue - L, logdet = chol_logdet(Sigma[np.ix_(ix, ix)]) - L.setflags(write=False) - factors.append((L, logdet)) - factors = tuple(factors) - if self.is_constant: - self._block_chol_cache = factors - return factors - - def stacked_distance(self, ctx, params=()): - r"""Squared Mahalanobis distance and log-determinant over the active residual. - - Owns the dispatch between the block-diagonal fast path (factor each - block separately, :math:`O(\sum n_i^3)`, cached per block via - :meth:`block_cholesky` when constant) and a single dense Cholesky over - the full stack (cached via :meth:`cholesky` when constant). - - Returns - ------- - (float, float) - ``(d2, logdet)``. - """ - params = tuple(params) - r = ctx.y - ctx.ym - if self.uses_block_path: - factors = self.block_cholesky(ctx, *params) - d2 = 0.0 - logdet = 0.0 - for ix, (L, ld) in zip(self._active_blocks, factors): - if ix.size == 0: - continue - z = sc.linalg.solve_triangular(L, r[ix], lower=True) - d2 += float(np.dot(z, z)) - logdet += ld - return d2, logdet - - L, logdet = self.cholesky(ctx, *params) - if self.active is not None: - r = r[self.active] - z = sc.linalg.solve_triangular(L, r, lower=True) - return float(np.dot(z, z)), logdet - - -# ---------------------------------------------------------------------------- -# Standard bases and amplitudes (numpy-style callables over a TermContext) -# ---------------------------------------------------------------------------- - - -def ones(c: TermContext) -> np.ndarray: - """Constant unit basis.""" - return np.ones(len(c)) - - -def ym(c: TermContext) -> np.ndarray: - """The model prediction — the prediction-scaled basis.""" - return c.ym - - -def averaging(c: TermContext) -> np.ndarray: - """``0.5 * (y + ym)`` — the averaging model-error basis.""" - return 0.5 * (c.y + c.ym) - - -_AVERAGING = averaging # factories take an ``averaging`` flag that shadows the name - - -def x_basis(scale: float = 1.0): - """Basis ``x / scale`` (e.g. ``x_basis(np.pi)`` for ``theta/180`` on radians).""" - - def basis(c: TermContext) -> np.ndarray: - return np.asarray(c.x, dtype=float) / scale - - return basis - - -def exp_growth(scale: float = 1.0, base=ones): - """Parametric basis ``base(c) * exp(slope * x / scale)``. - - Takes one basis parameter, ``slope``; use with - ``noise_term(..., basis=exp_growth(np.pi), basis_params=(slope,))``. - """ - - def basis(c: TermContext, slope: float) -> np.ndarray: - return base(c) * np.exp(slope * np.asarray(c.x, dtype=float) / scale) - - return basis - - -def constant_amplitude(c: TermContext, log_amplitude: float) -> np.ndarray: - """Kernel amplitude ``exp(log_amplitude)``, constant over the support.""" - return np.full(len(c), np.exp(log_amplitude)) - - -def exp_growth_amplitude(scale: float = 1.0): - """Kernel amplitude ``exp(log_amplitude) * exp(slope * x / scale)`` (two params).""" - - def amplitude(c: TermContext, log_amplitude: float, slope: float) -> np.ndarray: - return np.exp(log_amplitude) * np.exp( - slope * np.asarray(c.x, dtype=float) / scale - ) - - return amplitude - - -# ---------------------------------------------------------------------------- -# Term factory helpers (the assembly-time builders) -# ---------------------------------------------------------------------------- - - -def _masked(magnitude, mask=None): - """A scalar/array magnitude with an optional mask. - - Scalar-like values include 0-d ndarrays (e.g. ``np.array(0.05)`` as stored by - ``exfor_tools`` distributions), not just Python scalars. An array magnitude - must have exactly the support's length; this is checked by :func:`_full` - when the term is evaluated. - """ - v = float(magnitude) if np.ndim(magnitude) == 0 else np.asarray(magnitude, float) - if mask is not None: - v = v * np.asarray(mask, dtype=float) - return v - - -def _full(v, n): - """``v`` as a length-``n`` vector. - - Scalars are broadcast; arrays must already have shape ``(n,)`` — a length-1 - array is *not* treated as a scalar, so a magnitude or mask of the wrong - length fails loudly instead of being spread over the support. - """ - v = np.asarray(v, dtype=float) - if v.ndim == 0: - return np.full(n, float(v)) - if v.shape != (n,): - raise ValueError( - f"magnitude/basis has shape {v.shape} but the term's support has " - f"length {n}" - ) - return v - - -def _coefficient(parameter, log): - """Parameter -> multiplicative coefficient ``exp(theta)`` (``log``) or ``theta``.""" - if parameter is None: - return (), (lambda values: 1.0) - if log: - return (parameter,), (lambda values: np.exp(values[0])) - return (parameter,), (lambda values: values[0]) - - -def _scaled_term( - kind, parameter, log, basis, basis_params=(), *, support=None, coords=None -): - """``c * basis(ctx, *basis_values)`` as a term of the given kind.""" - cparams, coef = _coefficient(parameter, log) - basis_params = tuple(basis_params) - nc = len(cparams) - - def fn(c, *values): - b = basis(c, *values[nc:]) if callable(basis) else basis - return coef(values[:nc]) * _full(b, len(c)) - - return Term(fn, cparams + basis_params, kind=kind, support=support, coords=coords) - - -def statistical_term(stat_err, support=None) -> Term: - """Always-on, genuinely uncorrelated statistical diagonal ``diag(stat_err**2)``.""" - return Term(np.asarray(stat_err, dtype=float), kind="diag", support=support) - - -def offset_term( - magnitude=None, parameter=None, mask=None, log=True, support=None -) -> Term: - """A correlated absolute-offset systematic ``outer(omega, omega)``. - - With ``magnitude`` it is a fixed (data-given) rank-one mode; with ``parameter`` - it is a free nuisance magnitude (``c = exp(theta)`` when ``log``). - """ - if magnitude is None and parameter is None: - raise ValueError("offset_term requires a magnitude and/or a parameter") - mag = _masked(1.0 if magnitude is None else magnitude, mask=mask) - - def basis(c): - return _full(mag, len(c)) - - if parameter is None: - return Term(basis, kind="mode", support=support, constant=True) - return _scaled_term("mode", parameter, log, basis, support=support) - - -def normalization_term( - magnitude=None, parameter=None, mask=None, log=True, support=None -) -> Term: - """A correlated normalisation systematic ``outer(eta * ym, eta * ym)``. - - With ``magnitude`` it is a fixed fractional normalisation uncertainty; with - ``parameter`` the magnitude eta is a free nuisance (``c = exp(theta)`` when - ``log``). In both cases the mode scales with the model prediction ``ym``. - """ - if magnitude is None and parameter is None: - raise ValueError("normalization_term requires a magnitude and/or a parameter") - mag = _masked(1.0 if magnitude is None else magnitude, mask=mask) - - def basis(c): - return _full(mag, len(c)) * c.ym - - return _scaled_term("mode", parameter, log, basis, support=support) - - -def noise_term( - parameter, log=True, basis=None, basis_params=(), support=None, coords=None -) -> Term: - """Unknown statistical noise ``diag((epsilon * basis)**2)``. - - ``basis`` defaults to ones (constant noise); pass any - ``basis(c, *basis_values)`` — e.g. :func:`exp_growth` with - ``basis_params=(slope,)`` for noise growing along ``x``. - - This term is **additive**: a :class:`~rxmc.constraint.Constraint` already adds - each observation's reported statistical diagonal, so the assembled covariance - is ``diag(y_stat_err**2 + epsilon**2)``. To make the inferred noise *replace* - the reported statistics, build the - ``Observation`` with zero ``y_stat_err`` or pass ``include_statistical_term=False`` - to the ``Constraint``. - """ - return _scaled_term( - "diag", - parameter, - log, - ones if basis is None else basis, - basis_params, - support=support, - coords=coords, - ) - - -def noise_fraction_term(parameter, log=True, support=None) -> Term: - """Unknown fractional noise ``diag((epsilon * ym)**2)``. - - **Additive** on top of the reported statistical diagonal (see - :func:`noise_term` for how to get replace-semantics instead). - """ - return _scaled_term("diag", parameter, log, ym, support=support) - - -def model_error_term(parameter, averaging=True, log=True, support=None) -> Term: - """Unknown uncorrelated model error ``diag((gamma * z)**2)``. - - ``z = 0.5 * (y + ym)`` when ``averaging`` (stabilises when ``ym`` is near zero), - else ``z = ym``. - """ - basis = _AVERAGING if averaging else ym - return _scaled_term("diag", parameter, log, basis, support=support) - - -def systematic_term( - parameter, basis, log=True, basis_params=(), support=None, coords=None -) -> Term: - """A correlated mode ``outer(s * u, s * u)`` with a user basis ``u = basis(c, ...)``. - - :func:`offset_term` and :func:`normalization_term` are its ``ones``/``ym`` - special cases; use e.g. ``basis=x_basis(np.pi)`` for a mode growing with - angle. - """ - return _scaled_term( - "mode", parameter, log, basis, basis_params, support=support, coords=coords - ) - - -def _kernel_params(kernel, prefix) -> list: - """One :class:`~rxmc.params.Parameter` per free kernel hyperparameter element.""" - params = [] - for hp in kernel.hyperparameters: - if hp.fixed: - continue - if hp.n_elements == 1: - params.append(Parameter(f"{prefix}_{hp.name}", float, latex_name=hp.name)) + B = jnp.diag(D[pos]) + if M[b] is not None: + B = B + M[b] + L, ld = chol_logdet(B) + logdet = logdet + ld + W = _solve_lower(L, Uc[pos]) if U else jnp.zeros((pos.size, 0)) + blocks.append((pos, L, W)) + Ws.append(W) + if U: + W = jnp.vstack(Ws) if Ws else jnp.zeros((0, len(U))) + Ls, lds = chol_logdet(jnp.eye(len(U)) + W.T @ W) + logdet = logdet + lds else: - params.extend( - Parameter( - f"{prefix}_{hp.name}_{i}", float, latex_name=f"{hp.name}[{i}]" - ) - for i in range(hp.n_elements) + Ls = None + return ("structured", blocks, Ls, logdet) + + def _constant_blocks(self) -> list[int]: + """The blocks whose ``B`` no parametric diag or matrix entry touches.""" + varying = set() + for e in self.parametric_entries: + if e.term.kind == "mode": + continue + varying.update( + b for b, bp in enumerate(self.block_pos) if np.isin(e.at, bp).any() ) - return params - + return [b for b in range(len(self.block_pos)) if b not in varying] + + def _check_blocks(self, D, M, blocks): + for b in blocks: + pos = self.block_pos[b] + if pos.size: + B = jnp.diag(D[pos]) + (0.0 if M[b] is None else M[b]) + if not _is_pd(B): + raise ValueError(self._singular_message(D, blocks)) + + def _singular_message(self, D, blocks=None): + D = np.asarray(D) + blocks = range(len(self.block_pos)) if blocks is None else blocks + offenders = [ + self.labels[b] for b in blocks if np.any(D[self.block_pos[b]] == 0.0) + ] + msg = "the constraint's covariance is singular on its active points" + if not offenders: + return msg + ( + " although its diagonal is nonzero: a matrix term dominates it " + "(e.g. a kernel amplitude large against the diagonal)" + ) + return msg + ( + f"; the diagonal is zero on rows of {offenders}: those comparisons " + "have zero statistical error and no diagonal term covers their " + "points (a block covered only by correlated modes is singular here " + "even when the full covariance is not). Remedies: " + "comparison.reported_terms(), a noise term, a fixed Term covering " + "those points, or statistical=False with an explicit covariance." + ) -def kernel_term( - kernel, - coords=None, - amplitude=None, - amplitude_params=(), - jitter=1e-10, - prefix="discrepancy", - support=None, -) -> Term: - """A Gaussian-process kernel ``a a^T * K(x, x; theta)`` over the support. + # -- public -------------------------------------------------------------- - One :class:`~rxmc.params.Parameter` is auto-derived per *free* kernel - hyperparameter **element** (sampled in sklearn's log-theta space): an - anisotropic hyperparameter (``n_elements > 1``) contributes that many - parameters. ``amplitude_params`` follow the kernel parameters. + def distance(self, ym, theta=()): + r"""``(d2, logdet)`` of the residual ``y - ym`` on the active rows. - Parameters - ---------- - kernel : sklearn-style kernel - Duck-typed on ``hyperparameters``, ``theta``, ``clone_with_theta`` and - ``__call__``. - coords : Transform or callable, optional - Coordinate transform of ``x`` the kernel is evaluated in (e.g. angle to - momentum transfer). Default: ``x`` itself. - amplitude : callable or array, optional - ``amplitude(c, *amplitude_values) -> vector a``; the block becomes - ``outer(a, a) * K``. Like the kernel, it sees the *transformed* - coordinate: ``c.x`` is ``coords(x)``. See :func:`constant_amplitude`, - :func:`exp_growth_amplitude`. - amplitude_params : sequence of Parameter, optional - Parameters consumed by ``amplitude``. - jitter : float, optional - Added to the diagonal after scaling, for numerical stability. - prefix : str, optional - Name prefix of the auto-derived kernel parameters. - support : array_like of int, optional - See :class:`Term`. - """ - kparams = _kernel_params(kernel, prefix) - nk = len(kparams) - amplitude_params = tuple(amplitude_params) - # with no free kernel hyperparameters and parameter-free coordinates, - # K(x, x) is invariant per constraint: build it once - fixed_K = nk == 0 and not as_transform(coords).params - K_cache = [] - - def fn(c, *values): - if fixed_K: - if not K_cache: - K_cache.append(np.asarray(kernel(as_2d(c.x)), dtype=float)) - K = K_cache[0] - else: - K = kernel.clone_with_theta(np.asarray(values[:nk], dtype=float))( - as_2d(c.x) - ) - if amplitude is not None: - a = amplitude(c, *values[nk:]) if callable(amplitude) else amplitude - a = np.broadcast_to(np.asarray(a, dtype=float), (len(c),)) - K = np.outer(a, a) * K - else: - K = np.array(K, dtype=float) - K[np.diag_indices_from(K)] += jitter - return K - - return Term( - fn, - tuple(kparams) + amplitude_params, - kind="matrix", - support=support, - coords=coords, - constant=nk == 0 and not amplitude_params and not callable(amplitude), - ) + ``ym`` is the full-length stacked prediction; ``theta`` the flat + parameter vector the entries' gathers index into. Returns two 0-d + jax arrays; ``logdet`` is NaN where a parametric covariance is + singular. + """ + theta = self._check_theta(theta) + r = (self.y - ym)[self.active] + kind, *rest = self._factor(*self._assemble(ym, theta)) + if kind == "dense": + L, logdet = rest + z = _solve_lower(L, r) + return z @ z, logdet + blocks, Ls, logdet = rest + d2 = 0.0 + w = None + for blk in blocks: + if blk is None: + continue + pos, L, W = blk + z = _solve_lower(L, r[pos]) + d2 = d2 + z @ z + w = W.T @ z if w is None else w + W.T @ z + if Ls is not None and w is not None: + s = _solve_lower(Ls, w) + d2 = d2 - s @ s + return jnp.asarray(d2), jnp.asarray(logdet) + + def matrix(self, ym, theta=(), entries=None): + """The dense covariance on the active rows, for display and tests. + + ``entries`` restricts the sum to a subset of :attr:`entries` (the + objects themselves, compared by identity): the covariance of *part* of + the error model, as a predictive draw of the model plus its discrepancy + but not the experimental errors needs. Default: every entry. A subset + is assembled directly, without the constant-piece cache. + """ + theta = self._check_theta(theta) + if entries is None: + return self._dense_matrix(*self._assemble(ym, theta)) + return self._dense_matrix(*self._pieces(entries, ym, theta)) + + +def _is_pd(B) -> bool: + """Whether a concrete matrix is positive definite (has a Cholesky factor).""" + try: + np.linalg.cholesky(np.asarray(B)) + except np.linalg.LinAlgError: + return False + return True diff --git a/src/rxmc/data.py b/src/rxmc/data.py new file mode 100644 index 0000000..db6a3f4 --- /dev/null +++ b/src/rxmc/data.py @@ -0,0 +1,248 @@ +""" +The dataset: pure data. + +A :class:`Dataset` holds an independent variable, a dependent variable, its +statistical error, the measurement's *reported* systematic magnitudes as +inert metadata, and whatever kinematics a model needs to bind to it. It has +no comparison transform, no mask and no solver state: those belong to the +:class:`~rxmc.constraint.Comparison`, the :class:`~rxmc.constraint.Constraint` +and the :class:`~rxmc.model.Model` respectively. + +``x`` is opaque to the library. A model may ignore it and close over a +predictor on another grid (recipe 20), and a covariance term sees it only +through its own ``coords`` transform. +""" + +from __future__ import annotations + +from dataclasses import dataclass, field +from types import SimpleNamespace +from typing import Any, Mapping + +import numpy as np + +__all__ = ["Dataset", "from_measurement"] + + +def _error_spec(value, n, name): + """``None``, a float, or a float array of shape ``(n,)``.""" + if value is None: + return None + if np.ndim(value) == 0: + v = float(value) + else: + v = np.asarray(value, dtype=float) + if v.shape != (n,): + raise ValueError( + f"{name} must be a scalar or have shape ({n},), got shape {v.shape}" + ) + if not (np.all(np.isfinite(v)) and np.all(np.asarray(v) >= 0)): + raise ValueError(f"{name} must be finite and non-negative, got {value}") + return v + + +@dataclass(eq=False, frozen=True) +class Dataset: + """Experimental data in physical units. + + Parameters + ---------- + x : array_like + Independent variable; any dtype or shape whose first dimension is the + number of points. Angles in radians for reaction data. + y : array_like + Dependent variable, shape ``(n,)``. + y_err : array_like + Statistical (uncorrelated) error on ``y``, shape ``(n,)``, non-negative. + norm_err : float or array_like, optional + Reported *fractional* normalisation uncertainty; inert until + :meth:`~rxmc.constraint.Comparison.reported_terms` asks for it. + offset_err : float or array_like, optional + Reported *absolute* offset uncertainty, in the units of ``y``; inert + likewise. + label : str, optional + Human-readable identifier used in error messages. + meta : mapping, optional + Kinematics and provenance a model or a term may read: ``reaction``, + ``Elab``, ``ExIAS``, ``quantity``, ``k``, ... Copied on construction. + """ + + x: Any + y: Any + y_err: Any + norm_err: Any = None + offset_err: Any = None + label: str = "" + meta: Mapping = field(default_factory=dict, repr=False) + + def __post_init__(self): + x = np.asarray(self.x) + y = np.asarray(self.y, dtype=float) + if y.ndim != 1: + raise ValueError(f"y must be 1-D, got shape {y.shape}") + n = y.shape[0] + if x.ndim == 0 or x.shape[0] != n: + raise ValueError( + f"x must have {n} points along its first dimension, got shape " + f"{x.shape}" + ) + y_err = np.asarray(self.y_err, dtype=float) + if y_err.shape != (n,): + raise ValueError(f"y_err must have shape ({n},), got {y_err.shape}") + if np.any(y_err < 0): + raise ValueError("y_err must be non-negative") + set_ = object.__setattr__ + set_(self, "x", x) + set_(self, "y", y) + set_(self, "y_err", y_err) + set_(self, "norm_err", _error_spec(self.norm_err, n, "norm_err")) + set_(self, "offset_err", _error_spec(self.offset_err, n, "offset_err")) + set_(self, "meta", dict(self.meta)) + + @property + def n(self) -> int: + """Number of points.""" + return self.y.shape[0] + + def __repr__(self): + label = f"{self.label!r}, " if self.label else "" + return f"Dataset({label}n={self.n})" + + +# ---------------------------------------------------------------------------- +# EXFOR measurements +# ---------------------------------------------------------------------------- + +_QUANTITY_KIND = { + "dXS/dA": "differential", + "dXS/dRuth": "dimensionless", + "Ay": "dimensionless", +} + + +_REQUIRED_FIELDS = ( + "x", + "y", + "Einc", + "quantity", + "y_units", + "statistical_err", + "systematic_norm_err", + "systematic_offset_err", +) + + +def _as_record(measurement): + """A measurement's fields as attributes, whether it is an object or a mapping.""" + if isinstance(measurement, Mapping): + measurement = SimpleNamespace(**measurement) + missing = [f for f in _REQUIRED_FIELDS if not hasattr(measurement, f)] + if missing: + raise ValueError(f"measurement is missing the field(s) {missing}") + return measurement + + +def from_measurement( + measurement, *, reaction=None, quantity=None, ExIAS=None +) -> Dataset: + """A :class:`Dataset` from an ``exfor_tools`` measurement, in internal units. + + Reads ``x`` (degrees, in the CM frame: an ``x_units`` of ``"LAB-degrees"`` + is refused, and a measurement without ``x_units`` is taken as CM), ``y``, + ``Einc``, ``quantity``, ``y_units``, + ``statistical_err``, ``systematic_norm_err``, ``systematic_offset_err`` and + ``subentry`` from ``measurement``: an object with those attributes, or a + mapping (a plain ``dict``) with those keys. ``x_units`` and ``subentry`` + are optional; a missing required field raises, naming it. Angles + are stored in radians, cross sections in b/sr, ratios and analysing powers + as they are. Every dimensionful error (statistical, absolute offset) is + converted with the data; the fractional normalisation error passes through + untouched. The kinematics a reaction model needs to bind land in + ``meta``: ``reaction``, ``Elab``, ``quantity``, ``k``, ``eta`` and, for the + (p,n) channel, ``ExIAS``. + + Parameters + ---------- + measurement : object or Mapping + An ``exfor_tools.distribution.Distribution``, anything shaped like it, + or a ``dict`` of the same fields. + reaction : jitr.reactions.Reaction, optional + Needed for the kinematics in ``meta`` and for any conversion between + ``dXS/dA`` and ``dXS/dRuth`` (the Rutherford cross section is a closed + form of the kinematics). + quantity : {"dXS/dA", "dXS/dRuth", "Ay"}, optional + The quantity the dataset should hold; defaults to the measured one. + ExIAS : float, optional + Excitation energy of the isobaric analog state (MeV), for (p,n) data. + """ + from .units import MB_PER_B, check_angle_grid, parse_unit + + measurement = _as_record(measurement) + measured = measurement.quantity + target = measured if quantity is None else quantity + for q in (measured, target): + if q not in _QUANTITY_KIND: + raise ValueError( + f"unknown quantity {q!r}; expected one of {list(_QUANTITY_KIND)}" + ) + factor, kind = parse_unit(measurement.y_units) + if kind != _QUANTITY_KIND[measured]: + raise ValueError( + f"measurement quantity {measured!r} needs {_QUANTITY_KIND[measured]} units, " + f"got {measurement.y_units!r}" + ) + label = getattr(measurement, "subentry", None) or "" + frame = getattr(measurement, "x_units", "CM-degrees") + if str(frame).upper().startswith("LAB"): + raise ValueError( + f"measurement {label or 'measurement'!r} has angles in the LAB frame " + f"({frame!r}); rxmc compares in the CM frame: convert the angles and " + "the cross sections to CM first" + ) + x = np.deg2rad(np.asarray(measurement.x, dtype=float)) + check_angle_grid(x, f"x of {label or 'measurement'}") + Elab = float(measurement.Einc) + + meta = {"quantity": target, "Elab": Elab, "subentry": label or None} + kinematics = None + if reaction is not None: + kinematics = reaction.kinematics(Elab) + meta.update(reaction=reaction, k=float(kinematics.k), eta=float(kinematics.eta)) + if ExIAS is not None: + meta["ExIAS"] = float(ExIAS) + + if measured == target: + norm = factor # into b/sr for a cross section, 1 for a ratio + elif {measured, target} == {"dXS/dA", "dXS/dRuth"}: + if kinematics is None: + raise ValueError( + f"converting {measured!r} to {target!r} needs the Rutherford cross " + "section: pass reaction=" + ) + if not kinematics.eta > 0: + raise ValueError( + f"converting {measured!r} to {target!r} needs a charged projectile " + f"(eta = {kinematics.eta})" + ) + from .reactions.elastic import rutherford + + ruth_b = rutherford(kinematics, x) / MB_PER_B + norm = factor / ruth_b if measured == "dXS/dA" else ruth_b + else: + raise ValueError( + f"cannot convert measurement quantity {measured!r} to {target!r}" + ) + + def scaled(v): + return None if v is None else np.asarray(v, dtype=float) * norm + + y_err = measurement.statistical_err + return Dataset( + x, + np.asarray(measurement.y, dtype=float) * norm, + scaled(np.zeros_like(x) if y_err is None else y_err), + norm_err=measurement.systematic_norm_err, + offset_err=scaled(measurement.systematic_offset_err), + label=label, + meta=meta, + ) diff --git a/src/rxmc/diagnostics.py b/src/rxmc/diagnostics.py new file mode 100644 index 0000000..0760d82 --- /dev/null +++ b/src/rxmc/diagnostics.py @@ -0,0 +1,494 @@ +"""Sampler-agnostic posterior checks on ``(problem, samples)``. + +Everything here consumes a compiled :class:`~rxmc.problem.Problem` and a +matrix of posterior ``samples`` of shape ``(n, problem.ndim)`` in +``problem.names`` order (what emcee's ``get_chain(flat=True)``, dynesty's +``samples_equal()`` and black-box-bayes give) and never touches a sampler: + +* :func:`predictive_draws` — the posterior predictive (band or draws) of a + constraint's likelihood on its active points (``N(ym(theta), Sigma(theta))``), + or the model-only predictive ``ym(theta)``. +* :func:`coverage_curve`, :func:`coverage_error`, :func:`sharpness` — + empirical calibration and width of those draws against the data. +* :func:`heldout_log_predictive`, :func:`log_posterior_predictive` — + out-of-sample scoring on a held-out problem (``Problem([fit.complement()])``). +* :func:`logz_summary`, :func:`compare_logz` — nested-sampling evidence + bookkeeping with replicate-based errors and a conservative tie verdict. + +Held-out scoring and a term that spans the split +------------------------------------------------ +A held-out problem built from ``fit.complement()`` has the *marginal* +covariance of its active rows. When no term couples the fitted and the +held-out rows that is the right density, and ``ll(fit) + ll(held) == ll(full)``. +When a term does span the split (a Gaussian process ``on=comps`` over +several experiments), the honest held-out density is the conditional +``p(y_held | y_fit, theta)`` under the full covariance; pass the fitted +problem as ``given=`` to :func:`heldout_log_predictive` and +:func:`predictive_draws` and they compute exactly that. Without a spanning +term the conditional equals the marginal. + +Draws and densities are in the comparison space of the constraint (a +``space=log`` comparison gives log-space draws); ``predictive_draws(..., +physical=True)`` maps draws back through the space's inverse. +""" + +from __future__ import annotations + +import numpy as np +import scipy.linalg as sla +from scipy.special import logsumexp + +from .likelihood import Gaussian +from .problem import CompiledConstraint, Problem + +__all__ = [ + "predictive_draws", + "coverage_curve", + "coverage_error", + "sharpness", + "heldout_log_predictive", + "log_posterior_predictive", + "logz_summary", + "compare_logz", +] + +_DEFAULT_LEVELS = np.linspace(0.02, 0.98, 49) + + +# ---------------------------------------------------------------------------- +# Helpers +# ---------------------------------------------------------------------------- + + +def _rows(samples, ndim) -> np.ndarray: + """Posterior samples as ``(n, ndim)``; a 1-D input is one row.""" + samples = np.asarray(samples, dtype=float) + if samples.ndim == 1: + samples = samples[None, :] + if samples.ndim != 2 or samples.shape[1] != ndim: + raise ValueError( + f"samples must have shape (n, {ndim}) in problem.names order, got " + f"{samples.shape}" + ) + return samples + + +def _psd_factor(Sigma, jitter=1e-10) -> np.ndarray: + """A lower-triangular factor ``L`` with ``L L^T = Sigma``. + + The Cholesky factor when ``Sigma`` is positive definite; otherwise the + Cholesky factor of ``Sigma`` plus a jitter *relative* to its mean + variance, and failing that the triangular factor of the eigen + decomposition's square root (negative eigenvalues clipped to zero), so a + caller may always treat ``L`` as a Cholesky factor. No jitter is added on + the successful path, so draws are never inflated. + """ + Sigma = np.asarray(Sigma, dtype=float) + try: + return np.linalg.cholesky(Sigma) + except np.linalg.LinAlgError: + pass + scale = max(float(np.mean(np.diag(Sigma))), np.finfo(float).tiny) + try: + return np.linalg.cholesky(Sigma + jitter * scale * np.eye(len(Sigma))) + except np.linalg.LinAlgError: + w, V = np.linalg.eigh(Sigma) + # A = V sqrt(w) has A A^T = Sigma but is not triangular; with A^T = Q R, + # L = R^T is, and L L^T = A A^T + L = np.linalg.qr((V * np.sqrt(np.clip(w, 0.0, None))).T, mode="r").T + return L * np.where(np.diag(L) < 0, -1.0, 1.0) # column signs: diag >= 0 + + +def _masks(constraint) -> list[np.ndarray]: + """Per-comparison active masks of a compiled constraint, ``None`` as all-true.""" + if constraint.source.masks is None: + return [np.ones(c.n, dtype=bool) for c in constraint.comparisons] + return list(constraint.source.masks) + + +class _Conditional: + """``p(y_H | y_F, theta)`` for one held-out constraint given its fit.""" + + def __init__(self, held: Problem, given: Problem, constraint: int): + try: + h, f = held.constraints[constraint], given.constraints[constraint] + except IndexError: + raise ValueError( + f"held-out and fitted problems must both have constraint " + f"{constraint}" + ) from None + if h.comparisons != f.comparisons: + raise ValueError( + "given= must be the fitted problem over the same comparison " + "objects (Problem([fit]) with held = Problem([fit.complement()]))" + ) + if held.names != given.names: + raise ValueError( + "held-out and fitted problems index different parameters: " + f"{held.names} vs {given.names}" + ) + if np.intersect1d(h.active, f.active).size: + raise ValueError( + "the held-out and fitted active points overlap; the held-out " + "constraint should be the complement of the fitted one" + ) + if not isinstance(h.likelihood, Gaussian): + raise ValueError( + "the conditional held-out density is Gaussian; the constraint " + f"uses {type(h.likelihood).__name__}. Score the marginal instead " + "(omit given=) or use a Gaussian likelihood" + ) + self.held, self.fit = h, f + # the union of the two active sets, compiled once against the held-out + # problem's own index, so theta's columns mean what they mean there (the + # constraint shares every parameter object, so nothing new is indexed) + union = [a | b for a, b in zip(_masks(h), _masks(f))] + self.full = CompiledConstraint(h.source.masked(union), held.index) + lookup = {int(r): i for i, r in enumerate(self.full.active)} + self.iH = np.array([lookup[int(r)] for r in h.active], dtype=int) + self.iF = np.array([lookup[int(r)] for r in f.active], dtype=int) + self.yF = self.full.y[f.active] + + def __call__(self, theta): + """``(mean, cov)`` of the held-out rows given the fitted data.""" + ym = self.full.ym(theta) + S = self.full.matrix(theta) + SHH = S[np.ix_(self.iH, self.iH)] + SHF = S[np.ix_(self.iH, self.iF)] + SFF = S[np.ix_(self.iF, self.iF)] + L = _psd_factor(SFF) + r = self.yF - ym[self.fit.active] + mean = ym[self.held.active] + SHF @ sla.cho_solve((L, True), r) + cov = SHH - SHF @ sla.cho_solve((L, True), SHF.T) + return mean, 0.5 * (cov + cov.T) + + +def _gaussian_logpdf(r, cov) -> float: + L = _psd_factor(cov) + z = sla.solve_triangular(L, r, lower=True) + logdet = 2.0 * np.sum(np.log(np.diag(L))) + return float(-0.5 * (z @ z + logdet + len(r) * np.log(2 * np.pi))) + + +# ---------------------------------------------------------------------------- +# Posterior predictive +# ---------------------------------------------------------------------------- + + +def _same_space(a, b) -> bool: + """One space: the same object, or parameter-free wrappers of one callable + (``space=np.log`` on each comparison wraps it anew each time).""" + return a is b or (not a.params and not b.params and a.fn is b.fn) + + +def _one_space(constraint, rows, hint=""): + """The one comparison space shared by the comparisons covering ``rows``.""" + spaces = [] + for comp, o in zip(constraint.comparisons, constraint.offsets): + if np.any((rows >= o.start) & (rows < o.stop)): + if not any(_same_space(comp.space, s) for s in spaces): + spaces.append(comp.space) + if len(spaces) != 1: + raise ValueError( + "the comparisons a draw spans must share one comparison space " + f"to map between it and physical units; found " + f"{[s.name for s in spaces]}. {hint}".rstrip() + ) + return spaces[0] + + +def _to_physical(space, physical: bool): + """``space.inverse`` when ``physical``, else the identity; raises when a + physical draw is asked of a space with no inverse.""" + if not physical: + return lambda y: y + if space.inverse is None: + raise ValueError(f"comparison space {space.name!r} has no inverse") + return space.inverse + + +def predictive_draws( + problem: Problem, + samples, + constraint: int = 0, + *, + terms=None, + statistical: bool = True, + n_rep: int = 1, + rng=None, + model_only: bool = False, + given: Problem | None = None, + levels=(16, 50, 84), + return_draws: bool = False, + physical: bool = False, +) -> np.ndarray: + """Posterior-predictive band, or draws, on a constraint's active points. + + For each posterior row ``theta_i`` the constraint gives ``ym_i`` and + ``Sigma_i``; ``n_rep`` draws ``ym_i + L_i z`` (``z ~ N(0, I)``) are + taken. With ``model_only=True`` the rows are ``ym_i`` themselves and no + covariance is assembled. + + ``terms`` and ``statistical`` choose which pieces of the error model the + draws carry (:meth:`~rxmc.problem.CompiledConstraint.entries_for`). The + default, every term, is the only one comparable with the measured data; + dropping the experimental terms gives the model plus its discrepancy + alone. + + The result is a percentile band by default, like + :func:`~rxmc.predictive.grid_draws` and + :func:`~rxmc.predictive.gp_predictive_draws`; :func:`coverage_curve`, + :func:`coverage_error` and :func:`sharpness` need the draws, so pass + ``return_draws=True`` for them. To predict at points that were never + measured, use :func:`~rxmc.predictive.grid_draws`. + + Parameters + ---------- + problem : Problem + samples : array_like, shape (n, problem.ndim) + Posterior rows in ``problem.names`` order (a 1-D array is one row). + constraint : int, optional + Index into ``problem.constraints``. + terms : sequence of Term, optional + Terms of the constraint, by identity; ``None`` means all of them. + statistical : bool, optional + Whether the reported statistical diagonals join them. + n_rep : int, optional + Draws per posterior row (ignored when ``model_only``). + rng : numpy.random.Generator or seed, optional + model_only : bool, optional + Return the predictions ``ym_i`` on the active points instead of draws + around them. + given : Problem, optional + The *fitted* problem when ``problem`` is its held-out complement and a + term spans the two (module docstring): draws then come from the + conditional ``N(mu_c, Sigma_c)`` of the held-out rows given the fitted + data. + levels : sequence of float, optional + Percentiles of the band. + return_draws : bool, optional + Return the draws instead of the band. + physical : bool, optional + Map every draw back through the comparison space's inverse (a log-space + comparison gives cross sections, not their logarithms) before the band + is taken, as :func:`~rxmc.predictive.grid_draws` does. The active + points must share one comparison space with an inverse. Coverage + against ``c.y`` wants the default, comparison space. + + Returns + ------- + np.ndarray + In comparison space, or physical units with ``physical``: the band, + ``(len(levels), n_active)``; with ``return_draws`` the draws, + ``(n * n_rep, n_active)``, or ``(n, n_active)`` when ``model_only``. + """ + rng = np.random.default_rng(rng) + samples = _rows(samples, problem.ndim) + n = samples.shape[0] + c = problem.constraints[constraint] + N = c.n_active + if given is not None and not (terms is None and statistical): + raise ValueError( + "given= conditions on the fitted data under the full covariance of " + "the spanning term, so it cannot be combined with a term selection; " + "drop terms=/statistical= or drop given=" + ) + cond = None if given is None else _Conditional(problem, given, constraint) + back = ( + _to_physical(_one_space(c, np.asarray(c.active)), True) + if physical + else (lambda y: y) + ) + + if model_only: + out = np.empty((n, N)) + for i in range(n): + out[i] = cond(samples[i])[0] if cond else c.ym(samples[i])[c.active] + out = np.asarray(back(out)) + return out if return_draws else np.percentile(out, levels, axis=0) + + out = np.empty((n * n_rep, N)) + for i in range(n): + theta = samples[i] + if cond: + mu, Sigma = cond(theta) + else: + mu = c.ym(theta)[c.active] + Sigma = c.matrix(theta, terms=terms, statistical=statistical) + L = _psd_factor(Sigma) + z = rng.standard_normal((n_rep, N)) + out[i * n_rep : (i + 1) * n_rep] = mu + z @ L.T + out = np.asarray(back(out)) + return out if return_draws else np.percentile(out, levels, axis=0) + + +def coverage_curve(draws, y, levels=None) -> np.ndarray: + """Empirical coverage of central predictive intervals at each nominal level. + + Parameters + ---------- + draws : array_like, shape (n_draws, n_pts) + y : array_like, shape (n_pts,) + The data the draws are checked against (same space as ``draws``). + levels : array_like, optional + Nominal central-interval probabilities in (0, 1). Defaults to 49 + levels from 0.02 to 0.98. + + Returns + ------- + np.ndarray + Fraction of points inside the central ``level`` interval, per level. + """ + draws = np.asarray(draws, dtype=float) + y = np.asarray(y, dtype=float) + levels = _DEFAULT_LEVELS if levels is None else np.asarray(levels, dtype=float) + out = np.empty(len(levels)) + for i, lv in enumerate(levels): + lo, hi = np.percentile(draws, [50 * (1 - lv), 50 * (1 + lv)], axis=0) + out[i] = np.mean((y >= lo) & (y <= hi)) + return out + + +def coverage_error(draws, y, levels=None) -> float: + """``max |coverage(level) - level|``: a single calibration score.""" + levels = _DEFAULT_LEVELS if levels is None else np.asarray(levels, dtype=float) + return float(np.max(np.abs(coverage_curve(draws, y, levels) - levels))) + + +def sharpness(draws, percentiles=(16, 84), transform=None) -> np.ndarray: + """Per-point width of a central predictive interval. + + Parameters + ---------- + draws : array_like, shape (n_draws, n_pts) + percentiles : (float, float), optional + Lower and upper percentiles (in 0-100) bounding the interval; the + default is the central 68 %. :func:`coverage_curve` takes interval + *probabilities* in (0, 1) instead. + transform : callable, optional + Applied to the draws first (e.g. ``np.exp`` to report widths in + physical units for a log comparison space). + """ + draws = np.asarray(draws, dtype=float) + if transform is not None: + draws = transform(draws) + lo, hi = np.percentile(draws, percentiles, axis=0) + return hi - lo + + +# ---------------------------------------------------------------------------- +# Held-out scoring +# ---------------------------------------------------------------------------- + + +def heldout_log_predictive( + heldout_problem: Problem, samples, *, given: Problem | None = None +) -> np.ndarray: + """``log p(y_held | theta_i)`` for each posterior row. + + ``heldout_problem`` is typically ``Problem([fit.complement()])``: the same + comparisons, terms and parameters, with the held-out points active. The + score is that problem's log likelihood at each row, so the constraints' + ``weight`` and likelihood family apply. With ``given=`` (the fitted + problem) the score is instead the Gaussian conditional density of the + held-out rows given the fitted data, constraint by constraint (module + docstring). + + Returns + ------- + np.ndarray, shape (n,) + """ + samples = _rows(samples, heldout_problem.ndim) + if given is None: + return np.array([heldout_problem.log_likelihood(t) for t in samples]) + conds = [ + _Conditional(heldout_problem, given, i) + for i in range(len(heldout_problem.constraints)) + ] + out = np.empty(samples.shape[0]) + for k, theta in enumerate(samples): + total = 0.0 + for c, cond in zip(heldout_problem.constraints, conds): + if c.weight == 0.0: + continue + mean, cov = cond(theta) + total += c.weight * _gaussian_logpdf(c.y[c.active] - mean, cov) + out[k] = total + return out + + +def log_posterior_predictive(logp_samples, logw=None) -> float: + """``log E_post[p(y_held | theta)]``: the joint log posterior predictive + density of the held-out block. + + A log-mean-exp over posterior samples of :func:`heldout_log_predictive` + values; pass ``logw`` (unnormalised log importance weights, e.g. + nested-sampling ``logwt``) for weighted samples. This is the joint + predictive of the whole held-out block, not the pointwise-summed ``elpd`` + of Vehtari et al.; divide by the number of held-out points for a + per-point score. + """ + logp = np.asarray(logp_samples, dtype=float) + if logw is None: + return float(logsumexp(logp) - np.log(len(logp))) + logw = np.asarray(logw, dtype=float) + return float(logsumexp(logp + logw) - logsumexp(logw)) + + +# ---------------------------------------------------------------------------- +# Evidence bookkeeping +# ---------------------------------------------------------------------------- + + +def logz_summary(logz, logzerr) -> tuple[float, float, int]: + """Replicate-aware evidence summary. + + Parameters + ---------- + logz, logzerr : array_like + ``log Z`` and its sampler-reported error for each replicate run (one + value each is fine). Add ``problem.log_jacobian()`` to ``logz`` first + when comparing fits in different comparison spaces. + + Returns + ------- + (float, float, int) + ``(mean, err, n)`` with ``err = max(half-range across replicates, mean + reported error)``: the sampler's own error is a lower bound. + """ + logz = np.atleast_1d(np.asarray(logz, dtype=float)) + logzerr = np.atleast_1d(np.asarray(logzerr, dtype=float)) + if not (np.all(np.isfinite(logz)) and np.all(np.isfinite(logzerr))): + raise ValueError(f"log Z and its errors must be finite, got {logz}, {logzerr}") + half_range = 0.5 * (logz.max() - logz.min()) if logz.size > 1 else 0.0 + return float(logz.mean()), float(max(half_range, logzerr.mean())), int(logz.size) + + +def compare_logz(a, b, sigma: float = 2.0) -> dict: + """``Delta log Z = a - b`` with a conservative tie verdict. + + Parameters + ---------- + a, b : (mean, err) or (mean, err, n) + As returned by :func:`logz_summary`; a trailing replicate count is + accepted and ignored. + sigma : float, optional + A difference no larger than ``sigma * hypot(err_a, err_b)`` is a + ``"tie"``. + + Returns + ------- + dict + ``{"dlogZ": ..., "err": ..., "verdict": "a" | "b" | "tie"}``. + """ + ma, ea = a[0], a[1] + mb, eb = b[0], b[1] + if not np.all(np.isfinite([ma, ea, mb, eb])): + raise ValueError(f"evidence summaries must be finite, got {a} and {b}") + d = float(ma - mb) + err = float(np.hypot(ea, eb)) + if abs(d) <= sigma * err: + verdict = "tie" + else: + verdict = "a" if d > 0 else "b" + return {"dlogZ": d, "err": err, "verdict": verdict} diff --git a/src/rxmc/elastic_diffxs_model.py b/src/rxmc/elastic_diffxs_model.py deleted file mode 100644 index 6842a1f..0000000 --- a/src/rxmc/elastic_diffxs_model.py +++ /dev/null @@ -1,233 +0,0 @@ -""" -Physical model for elastic differential cross sections. - -:class:`ElasticDifferentialXSModel` wraps a ``jitr`` optical-model solver to -predict elastic differential cross sections (dXS/dΩ, dXS/dRuth, or analysing -power Ay) given a parametric central and spin-orbit interaction. -""" - -from typing import Callable - -import jitr -import numpy as np - -from .elastic_diffxs_observation import ElasticDifferentialXSObservation -from .observation_from_measurement import MB_PER_B -from .physical_model import PhysicalModel - - -def _require_observation(observation) -> None: - """Reject observations this model cannot evaluate on. - - Both reaction observations report ``quantity == "dXS/dA"``, so a string - check cannot tell them apart; the class carries the solver workspace the - model needs. - """ - if not isinstance(observation, ElasticDifferentialXSObservation): - raise ValueError( - "ElasticDifferentialXSModel requires an " - "ElasticDifferentialXSObservation, got " - f"{type(observation).__name__}" - ) - - -class ElasticDifferentialXSModel(PhysicalModel): - """ - A model that predicts the elastic differential xs for a given reaction. - """ - - def __init__( - self, - quantity: str, - interaction_central: Callable[..., np.ndarray], - interaction_spin_orbit: Callable[..., np.ndarray] | None, - calculate_interaction_from_params: Callable[ - [jitr.xs.elastic.DifferentialWorkspace, tuple], tuple - ], - params: list = [], - model_name: str = None, - interaction_coulomb: Callable[..., np.ndarray] | None = None, - transform=None, - ): - """ - Parameters - ---------- - quantity : str - Observable to compute: ``"dXS/dA"``, ``"dXS/dRuth"``, or ``"Ay"``. - interaction_central : callable - ``f(r, *args) -> np.ndarray`` returning the central interaction - potential on the radial grid ``r`` (fm), in MeV. - interaction_spin_orbit : callable or None - ``f(r, *args) -> np.ndarray`` returning the spin-orbit potential on - ``r``. ``None`` for a spin-orbit-free model. - calculate_interaction_from_params : callable - ``f(workspace, *params) -> (central_args, spin_orbit_args)`` or - ``-> (central_args, spin_orbit_args, coulomb_args)`` mapping model - parameters to the argument tuples expected by the interaction - callables. - params : list of Parameter, optional - Parameters of the model. Defaults to ``[]``. - model_name : str, optional - Human-readable model name. Defaults to ``"ElasticDifferentialXSModel"``. - interaction_coulomb : callable, optional - ``f(r, *args) -> np.ndarray`` returning the Coulomb potential on - ``r``. When ``None`` the Coulomb interaction inside the channel - radius must be folded into ``interaction_central``. - transform : Transform or callable, optional - Parametric model-side transform applied to the prediction; see - :class:`~rxmc.physical_model.PhysicalModel`. - """ - self.model_name = model_name or "ElasticDifferentialXSModel" - - self.quantity = quantity - self.interaction_central = interaction_central - self.interaction_spin_orbit = interaction_spin_orbit - self.interaction_coulomb = interaction_coulomb - self.calculate_interaction_from_params = calculate_interaction_from_params - - if self.quantity == "dXS/dA": - self.extractor = extract_dXS_dA - elif self.quantity == "dXS/dRuth": - self.extractor = extract_dXS_dRuth - elif self.quantity == "Ay": - self.extractor = extract_Ay - else: - raise ValueError( - f"Unknown quantity {quantity!r}; expected 'dXS/dA', 'dXS/dRuth' " - "or 'Ay'." - ) - - super().__init__(params, transform=transform) - - def _xs(self, ws, params): - """Evaluate the potentials on ``ws.radial_grid()`` and solve. - - ``calculate_interaction_from_params`` returns either two argument - tuples ``(central, spin_orbit)`` or three ``(central, spin_orbit, - coulomb)``; anything else is an error. - """ - args = self.calculate_interaction_from_params(ws, *params) - if len(args) == 2: - (central_args, spin_orbit_args), coulomb_args = args, () - elif len(args) == 3: - central_args, spin_orbit_args, coulomb_args = args - else: - raise ValueError( - "calculate_interaction_from_params must return 2 or 3 argument " - f"tuples, got {len(args)}" - ) - r = ws.radial_grid() - central = self.interaction_central(r, *central_args) - spin_orbit = ( - None - if self.interaction_spin_orbit is None - else self.interaction_spin_orbit(r, *spin_orbit_args) - ) - coulomb = ( - None - if self.interaction_coulomb is None - else self.interaction_coulomb(r, *coulomb_args) - ) - return ws.xs(central, spin_orbit, coulomb) - - def evaluate( - self, - observation: ElasticDifferentialXSObservation, - *params: tuple, - ) -> np.ndarray: - """ - Evaluate the model on the constraint angular grid. - - Parameters - ---------- - observation : ElasticDifferentialXSObservation - Observation containing the reaction data and pre-built workspace. - *params : float - Physical-model parameter values. - - Returns - ------- - np.ndarray - Predicted observable on ``observation.constraint_workspace.angles``. - """ - _require_observation(observation) - if observation.quantity != self.quantity: - raise ValueError( - f"Observation quantity {observation.quantity} does not match " - f"model quantity {self.quantity}." - ) - ws = observation.constraint_workspace - xs = self._xs(ws, params) - if observation.compound_correction is not None: - if observation.quantity not in ["dXS/dA", "dXS/dRuth"]: - raise ValueError( - "Compound correction can only be applied to dXS/dA and dXS/dRuth." - ) - xs.dsdo += observation.compound_correction - xs.t += 2 * np.pi * np.trapz(observation.compound_correction, ws.angles) - return self.extractor(xs, ws) - - def visualizable_model_prediction( - self, - observation: ElasticDifferentialXSObservation, - *params: tuple, - ) -> np.ndarray: - """ - Evaluate the model on the visualisation angular grid. - - Parameters - ---------- - observation : ElasticDifferentialXSObservation - Observation containing the reaction data and pre-built workspace. - *params : float - Full model parameter values (physical parameters followed by any - transform parameters). - - Returns - ------- - np.ndarray - Predicted observable on ``observation.visualization_workspace.angles``. - """ - _require_observation(observation) - if observation.quantity != self.quantity: - raise ValueError( - f"Observation quantity {observation.quantity} does not match " - f"model quantity {self.quantity}." - ) - base, values = self.split_params(params) - ws = observation.visualization_workspace - xs = self._xs(ws, base) - if observation.compound_correction is not None: - cn = np.interp( - ws.angles, - observation.constraint_workspace.angles, - observation.compound_correction, - ) - if observation.quantity not in ["dXS/dA", "dXS/dRuth"]: - raise ValueError( - "Compound correction can only be applied to dXS/dA and dXS/dRuth." - ) - xs.dsdo += cn - xs.t += 2 * np.pi * np.trapz(cn, ws.angles) - return self.apply_transform(observation, self.extractor(xs, ws), values) - - -def extract_dXS_dA( - xs: jitr.xs.elastic.ElasticXS, ws: jitr.xs.elastic.DifferentialWorkspace -) -> np.ndarray: - """Extracts dXS/dA in b/Sr (``jitr`` reports mb/sr).""" - return xs.dsdo / MB_PER_B - - -def extract_dXS_dRuth( - xs: jitr.xs.elastic.ElasticXS, ws: jitr.xs.elastic.DifferentialWorkspace -) -> np.ndarray: - """Extracts dXS/dRuth (dimensionlesss)""" - return xs.dsdo / ws.rutherford - - -def extract_Ay( - xs: jitr.xs.elastic.ElasticXS, ws: jitr.xs.elastic.DifferentialWorkspace -) -> np.ndarray: - """Extracts Ay (dimensionless)""" - return xs.Ay diff --git a/src/rxmc/elastic_diffxs_observation.py b/src/rxmc/elastic_diffxs_observation.py deleted file mode 100644 index d4cc6e5..0000000 --- a/src/rxmc/elastic_diffxs_observation.py +++ /dev/null @@ -1,328 +0,0 @@ -""" -Observation class for elastic differential cross sections. - -:class:`ElasticDifferentialXSObservation` is an :class:`~rxmc.observation.Observation` -that sets up a ``jitr`` :class:`jitr.xs.elastic.DifferentialWorkspace` to pre-compute -boundary conditions and Rutherford cross sections. It carries statistical error -only; correlated systematics are composed as :class:`~rxmc.covariance.Term` s in the -:class:`~rxmc.constraint.Constraint`. -""" - -import jitr -import numpy as np -from exfor_tools.distribution import Distribution - -from .observation import Observation -from .observation_from_measurement import ( # noqa: F401 (re-exported names) - DEFAULT_LMAX, - RUTHERFORD_UNIT, - XS_UNIT, - check_angle_grid, - measurement_kwargs, - normalized_error_kwargs, - ureg, -) - - -class ElasticDifferentialXSObservation(Observation): - """ - Observation for elastic differential cross sections. - - This is an :class:`~rxmc.observation.Observation` (statistical error only): it - inherits ``statistical_term`` and ``num_pts_within_interval``. Any correlated - systematic — the dataset's reported normalisation/offset, or a fixed - covariance block (an array-valued :class:`~rxmc.covariance.Term`) — is - composed explicitly as an - ``extra_terms`` entry in the :class:`~rxmc.constraint.Constraint`. - - It is designed to handle elastic differential cross section - measurements, specifically absolute differential cross sections, - Rutherford normalized differential cross sections, and analyzing - powers (Ay). - - Internally, this involves initializing a - `jitr.xs.elastic.DifferentialWorkspace` which precomputes - things like boundary conditions to speed up computation of - observables for a given set of interaction parameter. - """ - - def __init__( - self, - x: np.ndarray, - y: np.ndarray, - Elab: float, - reaction: jitr.reactions.Reaction, - quantity: str, - measurement_quantity: str, - y_units: str, - y_stat_err=None, - y_sys_err_normalization=None, - y_sys_err_offset=None, - dataset_label: str | None = None, - lmax: int = DEFAULT_LMAX, - wavelengths_beyond_range=2.0, - zeros_per_node=5, - angles_vis: np.ndarray = np.linspace(0.01, 180, 100), - compound_correction: np.ndarray = None, - transform=None, - mask=None, - ): - """ - Parameters - ---------- - x : np.ndarray - Measured angle grid in degrees. - y : np.ndarray - Measured observable values. - Elab : float - Laboratory energy in MeV. - reaction : jitr.reactions.Reaction - Reaction system definition. - quantity : str - Observable to compute: ``"dXS/dA"``, ``"dXS/dRuth"``, or ``"Ay"``. - measurement_quantity : str - Observable represented by the supplied *y* values. - y_units : str - Units of the supplied *y* values (e.g. ``"mb/sr"``). - y_stat_err : np.ndarray, optional - Statistical errors associated with *y*. - y_sys_err_normalization : float or np.ndarray, optional - Reported *fractional* (dimensionless) normalisation uncertainty. - Retained as inert metadata (see - :meth:`rxmc.observation.Observation.systematic_terms`); not divided - by the unit normalisation. - y_sys_err_offset : float or np.ndarray, optional - Reported *absolute* offset uncertainty in the same units as *y*. - Retained as inert metadata, converted to internal units (divided by - the unit normalisation, per-angle where applicable). - dataset_label : str, optional - Human-readable dataset identifier used in error messages. - lmax : int, optional - Maximum angular momentum. Defaults to ``20``. - wavelengths_beyond_range : float, optional - Number of wavelengths beyond the interaction range used to set - the channel radius. Defaults to ``2.0``. - zeros_per_node : int, optional - Number of basis-function zeros per node in the R-matrix solver. - Defaults to ``5``. - angles_vis : np.ndarray, optional - Angle grid in degrees for visualisation. Defaults to - ``np.linspace(0.01, 180, 100)``. - compound_correction : np.ndarray, optional - Compound-nuclear contribution to dXS/dΩ in mb/sr, added to the - calculated cross section before comparing to data. - transform, mask : optional - Comparison-space transform and active-point mask; see - :class:`~rxmc.observation.Observation`. - """ - self.reaction = reaction - self.quantity = quantity - self.lmax = lmax - self.subentry = dataset_label - self.angle_units = ureg.radian - self.compound_correction = compound_correction - - self.angles_vis = angles_vis - angles_rad_vis = np.deg2rad(angles_vis) - check_angle_grid(angles_rad_vis, "angles_rad_vis") - - angles_rad_constraint = np.deg2rad(x) - label = dataset_label or "dataset" - check_angle_grid( - angles_rad_constraint, - f"x values for {label}", - ) - - # set up workspaces to precompute things for the solver - # for quick evaluation of observables - constraint_ws, vis_ws, kinematics = set_up_solver( - reaction=self.reaction, - Elab=Elab, - angle_rad_constraint=angles_rad_constraint, - angle_rad_vis=angles_rad_vis, - lmax=self.lmax, - wavelengths_beyond_range=wavelengths_beyond_range, - zeros_per_node=zeros_per_node, - ) - self.constraint_workspace = constraint_ws - self.visualization_workspace = vis_ws - self.kinematics = kinematics - - # Convert measurement to correct quantity and normalize to `b/sr` - norm, normalized_y_units = self.calculate_normalization( - measurement_quantity, y_units - ) - self.y_units = normalized_y_units - # retained for provenance / manual term recomposition; a scalar, or a - # per-angle array in the Rutherford-conversion cases - self.norm = norm - - super().__init__( - angles_rad_constraint, - np.asarray(y) / norm, - label=dataset_label, - transform=transform, - mask=mask, - **normalized_error_kwargs( - norm, y_stat_err, y_sys_err_normalization, y_sys_err_offset - ), - ) - - @property - def k(self) -> float: - """Entrance-channel wavenumber in fm^-1.""" - return float(self.kinematics.k) - - @classmethod - def from_measurement( - cls, - measurement: Distribution, - reaction: jitr.reactions.Reaction, - quantity: str, - **kwargs, - ): - """Construct from an ``exfor_tools`` ``Distribution``. - - ``**kwargs`` (solver settings, ``compound_correction``, ``transform``, - ``mask``, ...) are forwarded to the constructor. - """ - return cls( - reaction=reaction, - quantity=quantity, - measurement_quantity=measurement.quantity, - **measurement_kwargs(measurement), - **kwargs, - ) - - def calculate_normalization( - self, measurement_quantity: str, measurement_y_units: str - ): - # Determine the xs_unit based on self.quantity - xs_unit = XS_UNIT - rutherford_unit = RUTHERFORD_UNIT - if self.quantity == "dXS/dA": - y_unit = xs_unit - elif self.quantity in {"dXS/dRuth", "Ay"}: - y_unit = ureg.dimensionless - else: - raise ValueError(f"Unrecognized quantity: {self.quantity}") - - # Process different cases based on the quantity types - if self.quantity == "dXS/dRuth" and measurement_quantity == "dXS/dA": - measurement_unit = 1 * ureg(measurement_y_units) - if not measurement_unit.check(xs_unit): - raise ValueError( - "Expected measurement_unit to be dimensionally compatible " - f"with 'b/Sr', got {measurement_y_units}" - ) - - conversion_factor = 1.0 / measurement_unit.to(rutherford_unit).magnitude - return self.constraint_workspace.rutherford * conversion_factor, y_unit - - elif self.quantity == "dXS/dA" and measurement_quantity == "dXS/dRuth": - # rutherford is stored in mb/sr; convert one unit of it to b/sr - conversion_factor = 1.0 / (1 * rutherford_unit).to(y_unit).magnitude - return conversion_factor / self.constraint_workspace.rutherford, y_unit - - elif self.quantity == "dXS/dA" and measurement_quantity == "dXS/dA": - measurement_unit = 1 * ureg(measurement_y_units) - if not measurement_unit.check(y_unit): - raise ValueError( - "Expected measurement_unit to be dimensionally compatible " - f"with 'b/Sr', got {measurement_y_units}" - ) - - return 1.0 / measurement_unit.to(y_unit).magnitude, y_unit - - elif ( - self.quantity in {"dXS/dRuth", "Ay"} - and self.quantity == measurement_quantity - ): - if measurement_y_units != "no-dim": - raise ValueError( - f"Expected measurement_unit to be 'no-dim', got {measurement_y_units}" - ) - return 1.0, y_unit - - else: - raise ValueError( - f"Cannot convert measurement quantity '{measurement_quantity}' " - f"(units '{measurement_y_units}') to '{self.quantity}'" - ) - - -def set_up_solver( - reaction: jitr.reactions.Reaction, - Elab: float, - angle_rad_constraint: np.ndarray, - angle_rad_vis: np.ndarray, - lmax: int, - wavelengths_beyond_range: float = 2.0, - zeros_per_node: int = 5, -): - """ - Set up ``jitr`` workspaces for a reaction at a given energy. - - Parameters - ---------- - reaction : jitr.reactions.Reaction - Reaction system definition. - Elab : float - Laboratory energy in MeV. - angle_rad_constraint : np.ndarray - Angles in radians for comparison to experiment. - angle_rad_vis : np.ndarray - Angles in radians for visualisation. - lmax : int - Maximum angular momentum. - wavelengths_beyond_range : float, optional - Number of wavelengths beyond the interaction range used to set the - channel radius. Defaults to ``2.0``. - zeros_per_node : int, optional - Number of basis-function zeros per node in the R-matrix solver. - Defaults to ``5``. - - Returns - ------- - constraint_ws : jitr.xs.elastic.DifferentialWorkspace - Workspace on the constraint angle grid. - visualization_ws : jitr.xs.elastic.DifferentialWorkspace - Workspace on the visualisation angle grid. - kinematics : jitr.reactions.Kinematics - Kinematic quantities for the reaction. - """ - kinematics = reaction.kinematics(Elab) - k = kinematics.k - interaction_range_fm = jitr.utils.interaction_range(reaction.target.A) + 2 - a = k * interaction_range_fm + wavelengths_beyond_range * 2 * np.pi - channel_radius_fm = a / k - N = jitr.utils.suggested_basis_size(a, zeros_per_node) - core_solver = jitr.rmatrix.Solver(N) - - integral_ws = jitr.xs.elastic.IntegralWorkspace( - reaction=reaction, - kinematics=kinematics, - channel_radius_fm=channel_radius_fm, - solver=core_solver, - lmax=lmax, - ) - - constraint_ws = jitr.xs.elastic.DifferentialWorkspace( - integral_workspace=integral_ws, angles=angle_rad_constraint - ) - visualization_ws = jitr.xs.elastic.DifferentialWorkspace( - integral_workspace=integral_ws, angles=angle_rad_vis - ) - - return constraint_ws, visualization_ws, kinematics - - -def momentum_transfer(observation: ElasticDifferentialXSObservation) -> np.ndarray: - r"""Momentum transfer :math:`q = 2k\sin(\theta/2)` (fm^-1) on the data angles. - - Returns the array of :math:`q` values, e.g. for plotting. For a - :func:`~rxmc.covariance.kernel_term` in :math:`q`-space pass the same map - as the term's coordinate transform of the angle instead: - ``kernel_term(kernel, coords=lambda x: 2 * obs.k * np.sin(x / 2))``. - """ - return 2.0 * observation.k * np.sin(np.asarray(observation.x, dtype=float) / 2.0) diff --git a/src/rxmc/evidence.py b/src/rxmc/evidence.py deleted file mode 100644 index 2940486..0000000 --- a/src/rxmc/evidence.py +++ /dev/null @@ -1,173 +0,0 @@ -""" -Evidence: aggregate of independent constraints for Bayesian calibration. - -An :class:`Evidence` object collects multiple :class:`~rxmc.constraint.Constraint` -objects that share the same physical-model parameters. It computes a joint log -likelihood by summing the individual constraint log likelihoods (optionally -weighted). Each constraint owns its own (possibly correlated) covariance over the -stack of its observations; constraints are assumed independent of one another, so -``Evidence`` is a plain sum. Parametric constraints (those with free covariance / -likelihood parameters) are auto-detected via ``constraint.n_params > 0``. -""" - -import numpy as np - -from .constraint import Constraint - - -class Evidence: - """A collection of independent constraints sharing a common physical model. - - Parameters - ---------- - constraints : list of Constraint - All constraints. Those with ``n_params > 0`` are exposed (in order) as - :attr:`parametric_constraints`. - weights : np.ndarray, optional - 1-D array of per-constraint weights. Defaults to all ones. - - Raises - ------ - ValueError - If *constraints* is empty, if any constraint uses different - physical-model parameters than the first, if the model is - under-constrained, or if *weights* does not match the constraint count. - - Attributes - ---------- - constraints : list of Constraint - All constraints. - parametric_constraints : list of Constraint - The subset with ``n_params > 0``, in the order they appear. - parametric_indices : list of int - Global index into :attr:`constraints` for each entry of - :attr:`parametric_constraints` (e.g. to look up its :attr:`weights` - entry). - """ - - def __init__( - self, - constraints: list[Constraint] | None = None, - weights: np.ndarray = None, - ): - constraints = list(constraints or []) - if len(constraints) == 0: - raise ValueError("'constraints' must not be empty") - - self.constraints = constraints - self.model_params = constraints[0].physical_model.params - for constraint in self.constraints: - if constraint.physical_model.params != self.model_params: - raise ValueError( - "All constraints must use the same physical model parameters" - ) - - self._validate_constraint_params() - - parametric = [(i, c) for i, c in enumerate(self.constraints) if c.n_params > 0] - self.parametric_indices = [i for i, _ in parametric] - self.parametric_constraints = [c for _, c in parametric] - self.n_likelihood_params = sum(c.n_params for c in self.parametric_constraints) - - self.n_params = len(self.model_params) + self.n_likelihood_params - self.n_data_pts = sum(c.n_data_pts for c in self.constraints) - self.n_dof = self.n_data_pts - self.n_params - if self.n_dof < 0: - raise ValueError( - f"Model under-constrained! {self.n_params} free parameters " - f"and {self.n_data_pts} data points" - ) - - if weights is None: - weights = np.ones((len(self.constraints),), dtype=float) - elif weights.shape != (len(self.constraints),): - raise ValueError( - "weights must be a 1D array with the same shape as constraints" - ) - self.weights = weights - - def _validate_constraint_params(self): - """Reject cross-constraint parameter sharing and duplicate names. - - Covariance/likelihood parameters are constraint-scoped (see - ``docs/design.md`` §8): the same ``Parameter`` object in two - constraints would silently be sampled as two independent values. - Names must also be unique across the whole Evidence — they label - sampler columns, priors, and corner-plot axes. - """ - seen_id = {} # id(p) -> constraint index - seen_name = {} # p.name -> constraint index - for ci, c in enumerate(self.constraints): - for p in c.params: - if id(p) in seen_id: - raise ValueError( - f"Parameter '{p.name}' is the same object in constraints " - f"{seen_id[id(p)]} and {ci}. Covariance/likelihood " - "parameters are constraint-scoped and cannot be shared " - "across constraints. To model a systematic shared " - "between datasets, place those datasets in ONE " - "Constraint with a cross-block coupling term." - ) - seen_id[id(p)] = ci - if p.name in seen_name: - raise ValueError( - f"Duplicate parameter name '{p.name}' in constraints " - f"{seen_name[p.name]} and {ci}. Parameter names label " - "sampler columns and must be unique across the " - "Evidence; rename one (e.g. suffix it with the dataset " - "label)." - ) - seen_name[p.name] = ci - - def log_likelihood(self, model_params, cov_params: list | None = None): - """Weighted sum of log likelihoods over all constraints. - - Parameters - ---------- - model_params : tuple - Physical-model parameters. - cov_params : list of tuple, optional - One tuple of constraint parameters per entry in - :attr:`parametric_constraints` (in that order). Defaults to ``[]``. - - Returns - ------- - float - Total weighted log likelihood. - """ - cov_params = cov_params or [] - if len(cov_params) != len(self.parametric_constraints): - raise ValueError( - f"Expected {len(self.parametric_constraints)} constraint parameter " - f"tuples, got {len(cov_params)}" - ) - - ll = 0.0 - pidx = 0 - for w, c in zip(self.weights, self.constraints): - cp = () - if c.n_params > 0: - cp = cov_params[pidx] - pidx += 1 - ll += c.log_likelihood(model_params, cp) * w - return ll - - def weighted_marginal_log_likelihood(self, lm_index, ym, *cov_params): - """Weighted marginal log likelihood of one parametric constraint. - - Applies the same :attr:`weights` entry that :meth:`log_likelihood` - uses for this constraint, so Gibbs-style conditional updates target - the same joint distribution as the model block. - - Parameters - ---------- - lm_index : int - Index into :attr:`parametric_constraints`. - ym : list of np.ndarray - One prediction array per observation of that constraint. - *cov_params : float - The constraint's parameters, in its ``params`` order. - """ - w = self.weights[self.parametric_indices[lm_index]] - c = self.parametric_constraints[lm_index] - return w * c.marginal_log_likelihood(ym, *cov_params) diff --git a/src/rxmc/ias_pn_model.py b/src/rxmc/ias_pn_model.py deleted file mode 100644 index a8cee77..0000000 --- a/src/rxmc/ias_pn_model.py +++ /dev/null @@ -1,177 +0,0 @@ -""" -Physical model for isobaric-analog-state (p,n) differential cross sections. - -:class:`IsobaricAnalogPNXSModel` wraps a ``jitr`` quasielastic-pn solver to -predict (p,n) IAS differential cross sections given five parametric interaction -potentials (proton Coulomb, proton central, proton spin-orbit, neutron central, -neutron spin-orbit). -""" - -from typing import Callable - -import jitr -import numpy as np - -from .ias_pn_observation import IsobaricAnalogPNObservation -from .observation_from_measurement import MB_PER_B -from .physical_model import PhysicalModel - - -def _require_observation(observation) -> None: - """Reject observations this model cannot evaluate on. - - Both reaction observations report ``quantity == "dXS/dA"``, so a string - check cannot tell them apart; the class carries the solver workspace the - model needs. - """ - if not isinstance(observation, IsobaricAnalogPNObservation): - raise ValueError( - "IsobaricAnalogPNXSModel requires an IsobaricAnalogPNObservation, " - f"got {type(observation).__name__}" - ) - - -class IsobaricAnalogPNXSModel(PhysicalModel): - """ - A model that predicts the (p,n) IAS differential xs for a given reaction. - This model requires five interaction potentials: - - Proton Coulomb potential: U_p_coulomb - - Proton central potential: U_p_central - - Proton spin-orbit potential: U_p_spin_orbit - - Neutron central potential: U_n_central - - Neutron spin-orbit potential: U_n_spin_orbit - - Each potential takes in an arbitrary tuple of params, which are - calculated from the model parameters via the `calculate_params` function. - - The ``calculate_params`` function should have the signature: - ``(ws: jitr.xs.quasielastic_pn.Workspace, *params: tuple) -> tuple`` - and return a tuple of five elements, each being a tuple of parameters - to be passed to the corresponding potential function in the order listed above. - """ - - def __init__( - self, - U_p_coulomb: Callable[[float, tuple], complex], - U_p_central: Callable[[float, tuple], complex], - U_p_spin_orbit: Callable[[float, tuple], complex], - U_n_central: Callable[[float, tuple], complex], - U_n_spin_orbit: Callable[[float, tuple], complex], - calculate_params: Callable[[jitr.xs.quasielastic_pn.Workspace, tuple], tuple], - params: list = [], - model_name: str = None, - transform=None, - ): - """ - Parameters - ---------- - U_p_coulomb : callable - ``f(r, *args) -> np.ndarray`` on the radial grid ``r``: the proton Coulomb - potential. - U_p_central : callable - ``f(r, *args) -> np.ndarray`` on the radial grid ``r``: the proton central - potential. - U_p_spin_orbit : callable - ``f(r, *args) -> np.ndarray`` on the radial grid ``r``: the proton spin-orbit - potential. - U_n_central : callable - ``f(r, *args) -> np.ndarray`` on the radial grid ``r``: the neutron central - potential. - U_n_spin_orbit : callable - ``f(r, *args) -> np.ndarray`` on the radial grid ``r``: the neutron spin-orbit - potential. - calculate_params : callable - ``f(workspace, *params) -> (args_p_coulomb, args_p_central, - args_p_spin_orbit, args_n_central, args_n_spin_orbit)`` - mapping model parameters to the argument tuples expected by each - potential callable. - params : list of Parameter, optional - Parameters of the model. Defaults to ``[]``. - model_name : str, optional - Human-readable model name. Defaults to ``"IsobaricAnalogPNXSModel"``. - transform : Transform or callable, optional - Parametric model-side transform applied to the prediction; see - :class:`~rxmc.physical_model.PhysicalModel`. - """ - self.model_name = model_name or "IsobaricAnalogPNXSModel" - self.U_p_coulomb = U_p_coulomb - self.U_p_central = U_p_central - self.U_p_spin_orbit = U_p_spin_orbit - self.U_n_central = U_n_central - self.U_n_spin_orbit = U_n_spin_orbit - self.calculate_params = calculate_params - - super().__init__(params, transform=transform) - - def _xs(self, ws, params) -> np.ndarray: - """Evaluate the five potentials on ``ws.radial_grid()`` and solve (b/sr).""" - ( - args_p_coulomb, - args_p_central, - args_p_spin_orbit, - args_n_central, - args_n_spin_orbit, - ) = self.calculate_params(ws, *params) - r = ws.radial_grid() - return ( - ws.xs( - self.U_p_coulomb(r, *args_p_coulomb), - self.U_p_central(r, *args_p_central), - self.U_p_spin_orbit(r, *args_p_spin_orbit), - self.U_n_central(r, *args_n_central), - self.U_n_spin_orbit(r, *args_n_spin_orbit), - ) - / MB_PER_B # jitr reports mb/sr; internal unit is b/sr - ) - - def evaluate( - self, - observation: IsobaricAnalogPNObservation, - *params: tuple, - ) -> np.ndarray: - """ - Evaluate the model on the constraint angular grid. - - Parameters - ---------- - observation : IsobaricAnalogPNObservation - Observation containing the pre-built workspace. - *params : float - Physical-model (base) parameter values, consumed by - *calculate_params*; transform parameters are split off by - ``__call__``. - - Returns - ------- - np.ndarray - Predicted (p,n) IAS differential cross section in b/sr on - ``observation.constraint_workspace.angles``. - """ - _require_observation(observation) - return self._xs(observation.constraint_workspace, params) - - def visualizable_model_prediction( - self, - observation: IsobaricAnalogPNObservation, - *params: tuple, - ) -> np.ndarray: - """ - Evaluate the model on the visualisation angular grid. - - Parameters - ---------- - observation : IsobaricAnalogPNObservation - Observation containing the pre-built workspace. - *params : float - Physical-model parameter values, consumed by *calculate_params*. - - Returns - ------- - np.ndarray - Predicted (p,n) IAS differential cross section in b/sr on - ``observation.visualization_workspace.angles``. - """ - _require_observation(observation) - base, values = self.split_params(params) - xs = self._xs(observation.visualization_workspace, base) - return self.apply_transform(observation, xs, values) diff --git a/src/rxmc/ias_pn_observation.py b/src/rxmc/ias_pn_observation.py deleted file mode 100644 index c448fe2..0000000 --- a/src/rxmc/ias_pn_observation.py +++ /dev/null @@ -1,242 +0,0 @@ -import jitr -import numpy as np -from exfor_tools.distribution import Distribution - -from .observation import Observation -from .observation_from_measurement import ( # noqa: F401 (re-exported names) - DEFAULT_LMAX, - XS_UNIT, - check_angle_grid, - measurement_kwargs, - normalized_error_kwargs, - ureg, -) - - -class IsobaricAnalogPNObservation(Observation): - """ - Observation for (p,n) isobaric analog state (IAS) reactions. - - This is an :class:`~rxmc.observation.Observation` (statistical error only): it - inherits ``statistical_term`` and ``num_pts_within_interval``. Any correlated - systematic is composed explicitly as an ``extra_terms`` entry in the - :class:`~rxmc.constraint.Constraint`. - - It is designed to handle (p,n) IAS reaction measurements in differential cross - section form. - - Internally, this involves initializing a jitr.xs.quasielastic_pn.Workspace - which precomputes things like boundary conditions to speed up computation of - observables for a given set of interaction parameters. - """ - - def __init__( - self, - x: np.ndarray, - y: np.ndarray, - Elab: float, - reaction: jitr.reactions.Reaction, - ExIAS: float, - y_units: str, - y_stat_err=None, - y_sys_err_normalization=None, - y_sys_err_offset=None, - dataset_label: str | None = None, - lmax: int = DEFAULT_LMAX, - angles_vis: np.ndarray = np.linspace(0.01, 180, 100), - wavelengths_beyond_range: float = 2.0, - zeros_per_node: int = 5, - transform=None, - mask=None, - ): - """ - Initialize a Observation instance for the (p,n) IAS reaction. - - Parameters - ---------- - x : np.ndarray - Measured angle grid in degrees. - y : np.ndarray - Measured differential cross section data. - Elab : float - Laboratory energy of the incoming proton (MeV). - reaction : jitr.reactions.Reaction - Reaction information. - ExIAS : float - Excitation energy of the IAS in the residual nucleus (MeV). - y_units : str - Units of the supplied `y` values. - y_stat_err : np.ndarray, optional - Statistical errors associated with `y`. - y_sys_err_normalization : float or np.ndarray, optional - Reported *fractional* (dimensionless) normalisation uncertainty. - Retained as inert metadata (see - :meth:`rxmc.observation.Observation.systematic_terms`); not divided - by the unit normalisation. - y_sys_err_offset : float or np.ndarray, optional - Reported *absolute* offset uncertainty in the same units as `y`. - Retained as inert metadata, converted to internal units (divided by - the unit normalisation). - dataset_label : str, optional - Human-readable dataset identifier used in error messages. - lmax: int - Maximum angular momentum - angles_vis: np.ndarray - Array of angles in degrees for visualization. - wavelengths_beyond_range: float - Number of wavelengths beyond the interaction range to set the channel radius. - zeros_per_node: int - Number of zeros of the basis functions per node in the R-matrix solver. - """ - self.reaction = reaction - self.lmax = lmax - self.subentry = dataset_label - self.angle_units = ureg.radian - self.quantity = "dXS/dA" - - self.angles_vis = angles_vis - angles_rad_vis = np.deg2rad(angles_vis) - check_angle_grid(angles_rad_vis, "angles_rad_vis") - - angles_rad_constraint = np.deg2rad(x) - label = dataset_label or "dataset" - check_angle_grid( - angles_rad_constraint, - f"x values for {label}", - ) - - # set up workspaces to precompute things for the solver - # for quick evaluation of observables - constraint_ws, vis_ws, kinematics_entrance, kinematics_exit = set_up_solver( - reaction=self.reaction, - Elab=Elab, - ExIAS=ExIAS, - angle_rad_constraint=angles_rad_constraint, - angle_rad_vis=angles_rad_vis, - lmax=self.lmax, - wavelengths_beyond_range=wavelengths_beyond_range, - zeros_per_node=zeros_per_node, - ) - self.constraint_workspace = constraint_ws - self.visualization_workspace = vis_ws - - self.y_units = XS_UNIT - measurement_unit = 1 * ureg(y_units) - if not measurement_unit.check(self.y_units): - raise ValueError( - f"Expected measurement_unit to be dimensionally " - f"compatible with 'b/sr', got {y_units}" - ) - - norm = 1.0 / measurement_unit.to(self.y_units).magnitude - # retained for provenance / manual term recomposition - self.norm = norm - - super().__init__( - angles_rad_constraint, - np.asarray(y) / norm, - label=dataset_label, - transform=transform, - mask=mask, - **normalized_error_kwargs( - norm, y_stat_err, y_sys_err_normalization, y_sys_err_offset - ), - ) - - @classmethod - def from_measurement( - cls, - measurement: Distribution, - reaction: jitr.reactions.Reaction, - ExIAS: float, - **kwargs, - ): - """Construct from an ``exfor_tools`` ``Distribution``. - - ``**kwargs`` (solver settings, ``transform``, ``mask``, ...) are - forwarded to the constructor. - """ - return cls( - reaction=reaction, ExIAS=ExIAS, **measurement_kwargs(measurement), **kwargs - ) - - -def set_up_solver( - reaction: jitr.reactions.Reaction, - Elab: float, - ExIAS: float, - angle_rad_constraint: np.array, - angle_rad_vis: np.array, - lmax: int, - wavelengths_beyond_range: float = 2.0, - zeros_per_node: int = 5, -): - """ - Set up the solver for the reaction. - - Parameters - ---------- - reaction : - Reaction information. - Elab : float - Laboratory energy of the incoming proton (MeV). - ExIAS : float - Excitation energy of the IAS in the residual nucleus (MeV). - angle_rad_constraint : np.array - Angles to compare to experiment (rad). - angle_rad_vis : np.array - Angles to visualize on (rad) - lmax : int - Maximum angular momentum. - wavelengths_beyond_range : float - Number of wavelengths beyond the interaction - range to set the channel radius. - zeros_per_node : int - Number of zeros of the basis functions per - node in the R-matrix solver. - - Returns - ------- - tuple - constraint and visualization workspaces. - """ - kinematics_entrance = reaction.kinematics(Elab=Elab) - kinematics_exit = reaction.kinematics_exit( - kinematics_entrance, residual_excitation_energy=ExIAS - ) - - k = kinematics_entrance.k - interaction_range_fm = jitr.utils.interaction_range(reaction.target.A) + 2 - a = k * interaction_range_fm + wavelengths_beyond_range * 2 * np.pi - channel_radius_fm = a / k - N = jitr.utils.suggested_basis_size(a, zeros_per_node) - core_solver = jitr.rmatrix.Solver(N) - - constraint_workspace = jitr.xs.quasielastic_pn.Workspace( - reaction, - kinematics_entrance, - kinematics_exit, - core_solver, - angle_rad_constraint, - lmax, - channel_radius_fm, - tmatrix_abs_tol=1e-8, - ) - - visualization_workspace = jitr.xs.quasielastic_pn.Workspace( - reaction, - kinematics_entrance, - kinematics_exit, - core_solver, - angle_rad_vis, - lmax, - channel_radius_fm, - tmatrix_abs_tol=1e-8, - ) - - return ( - constraint_workspace, - visualization_workspace, - kinematics_entrance, - kinematics_exit, - ) diff --git a/src/rxmc/likelihood.py b/src/rxmc/likelihood.py new file mode 100644 index 0000000..17bc8ce --- /dev/null +++ b/src/rxmc/likelihood.py @@ -0,0 +1,61 @@ +""" +Likelihood functionals over the stacked residual of a constraint. + +A constraint owns one multivariate distribution over the stacked residual +``y - ym`` of its comparisons, with covariance assembled from +:class:`~rxmc.terms.Term` s. A *likelihood* here is a thin functional of the +pre-computed Mahalanobis statistics ``(d2, logdet, n)``, with no parameters +of its own: + +* :class:`Gaussian` — the multivariate normal. +* :class:`Chi2` — drops the log-determinant normalisation (pure chi-squared). +""" + +from __future__ import annotations + +import numpy as np + +__all__ = ["Likelihood", "Gaussian", "Chi2", "log_likelihood"] + + +class Likelihood: + """A functional of the pre-computed Mahalanobis statistics ``(d2, logdet, n)``. + + Subclasses implement :meth:`log_likelihood`. The chi-squared statistic + is likelihood-independent (always the Mahalanobis distance). + """ + + def log_likelihood(self, d2, logdet, n): + raise NotImplementedError + + def chi2(self, d2, logdet, n): + return d2 + + +class Gaussian(Likelihood): + """Multivariate-normal likelihood over the stacked residual.""" + + def log_likelihood(self, d2, logdet, n): + return log_likelihood(d2, logdet, n) + + +class Chi2(Likelihood): + """Generalised chi-squared functional: drops the log-det normalisation.""" + + def log_likelihood(self, d2, logdet, n): + return -0.5 * d2 + + +def log_likelihood(d2, logdet, n: int): + r"""Multivariate-normal log likelihood from pre-computed statistics. + + Parameters + ---------- + d2 : float + Squared Mahalanobis distance :math:`(y - y_m)^T \Sigma^{-1} (y - y_m)`. + logdet : float + :math:`\log \det \Sigma`. + n : int + Number of data points. + """ + return -0.5 * (d2 + logdet + n * np.log(2 * np.pi)) diff --git a/src/rxmc/likelihood_model.py b/src/rxmc/likelihood_model.py deleted file mode 100644 index a819cf5..0000000 --- a/src/rxmc/likelihood_model.py +++ /dev/null @@ -1,155 +0,0 @@ -""" -Likelihoods over the stacked residual of a :class:`~rxmc.constraint.Constraint`. - -A constraint owns one multivariate distribution over the stacked vector of all its -observations; its covariance is a :class:`~rxmc.covariance.ConstraintCovariance` -assembled from :class:`~rxmc.covariance.Term` s. A *likelihood* here is a thin -functional of the pre-computed Mahalanobis statistics ``(d2, logdet, n)`` plus its -own optional parameters: - -* :class:`GaussianLikelihood` — the multivariate normal (parameter-free). -* :class:`StudentT` — a heavy-tailed variant carrying a degrees-of-freedom - parameter ``nu``. -* :class:`Chi2` — drops the log-determinant normalisation (pure chi-squared). - -All covariance parameters live on the :class:`~rxmc.covariance.ConstraintCovariance`; -the only likelihood-side parameter is ``StudentT``'s ``nu``. The ``(d2, logdet)`` -statistics themselves are computed by -:meth:`~rxmc.covariance.ConstraintCovariance.stacked_distance`. - -Helper functions ----------------- -:func:`mahalanobis_distance_sqr_cholesky` - Squared Mahalanobis distance and log-determinant via Cholesky decomposition. -:func:`log_likelihood` - Multivariate-normal log likelihood from pre-computed distance and log-det. -""" - -import numpy as np -import scipy as sc -from scipy.special import gammaln - -from .covariance import chol_logdet -from .params import Parameter - -__all__ = [ - "Likelihood", - "GaussianLikelihood", - "StudentT", - "Chi2", - "mahalanobis_distance_sqr_cholesky", - "log_likelihood", -] - - -class Likelihood: - """A functional of the pre-computed Mahalanobis statistics ``(d2, logdet, n)``. - - Subclasses implement :meth:`log_likelihood` and declare any parameters via - ``params``/``n_params``. The chi-squared statistic is - likelihood-independent (always the Mahalanobis distance). - """ - - params: tuple = () - n_params: int = 0 - - def log_likelihood(self, d2, logdet, n, *like_params): - raise NotImplementedError - - def chi2(self, d2, logdet, n, *like_params): - return d2 - - -class GaussianLikelihood(Likelihood): - """Multivariate-normal likelihood over the stacked residual. - - Parameter-free — all uncertainty lives on the covariance terms. - """ - - def log_likelihood(self, d2, logdet, n, *like_params): - return log_likelihood(d2, logdet, n) - - -class StudentT(Likelihood): - r"""Multivariate Student-t likelihood with a degrees-of-freedom parameter. - - .. math:: - - \log p = \ln\Gamma\!\Big(\tfrac{n+\nu}{2}\Big) - \ln\Gamma\!\Big(\tfrac{\nu}{2}\Big) - - \tfrac{n}{2}\ln(\pi\nu) - \tfrac12 \ln\det\Sigma - - \tfrac{\nu+n}{2}\,\ln\!\Big(1 + \tfrac{d^2}{\nu}\Big) - """ - - def __init__(self, nu_parameter: Parameter = None): - self.nu_parameter = ( - nu_parameter - if nu_parameter is not None - else Parameter("degrees_of_freedom", float, latex_name=r"\nu") - ) - self.params = (self.nu_parameter,) - self.n_params = 1 - - def log_likelihood(self, d2, logdet, n, nu): - return ( - gammaln((n + nu) / 2.0) - - gammaln(nu / 2.0) - - 0.5 * n * np.log(np.pi * nu) - - 0.5 * logdet - - 0.5 * (nu + n) * np.log1p(d2 / nu) - ) - - -class Chi2(Likelihood): - """Generalised chi-squared functional — drops the log-det normalisation.""" - - def log_likelihood(self, d2, logdet, n, *like_params): - return -0.5 * d2 - - -# ---------------------------------------------------------------------------- -# Math helpers -# ---------------------------------------------------------------------------- - - -def mahalanobis_distance_sqr_cholesky(y, ym, cov): - r"""Squared Mahalanobis distance and log-determinant via Cholesky factorisation. - - Parameters - ---------- - y : array-like, shape (n,) - Observation vector. - ym : array-like, shape (n,) - Model prediction vector. - cov : array-like, shape (n, n) - Positive-definite covariance matrix. - - Returns - ------- - mahalanobis_sqr : float - $(y - y_m)^T \Sigma^{-1} (y - y_m)$. - log_det : float - $\log \det \Sigma$. - """ - L, log_det = chol_logdet(np.asarray(cov, dtype=float)) - z = sc.linalg.solve_triangular(L, np.asarray(y) - np.asarray(ym), lower=True) - return np.dot(z, z), log_det - - -def log_likelihood(mahalanobis_sqr: float, log_det: float, n: int): - r"""Multivariate-normal log likelihood from pre-computed statistics. - - Parameters - ---------- - mahalanobis_sqr : float - Squared Mahalanobis distance $(y - y_m)^T \Sigma^{-1} (y - y_m)$. - log_det : float - $\log \det \Sigma$. - n : int - Number of data points. - - Returns - ------- - float - Log likelihood value. - """ - return -0.5 * (mahalanobis_sqr + log_det + n * np.log(2 * np.pi)) diff --git a/src/rxmc/metropolis_hastings.py b/src/rxmc/metropolis_hastings.py deleted file mode 100644 index 6d158a1..0000000 --- a/src/rxmc/metropolis_hastings.py +++ /dev/null @@ -1,73 +0,0 @@ -""" -Plain Metropolis-Hastings MCMC sampler. - -The :func:`metropolis_hastings` function implements a single-chain MH kernel -with hard parameter bounds and a user-supplied proposal distribution. -""" - -from typing import Callable, Tuple - -import numpy as np - - -def metropolis_hastings( - x0: np.ndarray, - bounds: np.ndarray, - n_steps: int, - log_posterior: Callable[[np.ndarray], float], - rng: np.random.Generator, - propose: Callable[[np.ndarray, np.random.Generator], np.ndarray], -) -> Tuple[np.ndarray, np.ndarray, int]: - """Metropolis-Hastings MCMC sampling. - - Proposals that fall outside *bounds* are rejected outright; otherwise the - standard MH acceptance criterion is applied. - - Parameters - ---------- - x0 : np.ndarray, shape (ndim,) - Initial parameter vector. - bounds : np.ndarray, shape (ndim, 2) - Parameter bounds; each row is ``[lower, upper]``. - n_steps : int - Number of MCMC steps to generate. - log_posterior : callable - Function ``f(x) -> float`` returning the log posterior at ``x``. - rng : np.random.Generator - Random number generator for reproducibility. - propose : callable - Function ``g(x, rng) -> x_new`` that draws a candidate from the - proposal distribution centred at ``x``. - - Returns - ------- - chain : np.ndarray, shape (n_steps, ndim) - Sampled parameter vectors. - logp_chain : np.ndarray, shape (n_steps,) - Log posterior values corresponding to each sample. - accepted : int - Number of accepted proposals. - """ - chain = np.zeros((n_steps, x0.size)) - logp_chain = np.zeros((n_steps,)) - logp = float(np.squeeze(log_posterior(x0))) - accepted = 0 - x = x0 - for i in range(n_steps): - x_new = propose(x, rng) - if np.any(x_new < bounds[:, 0]) or np.any(x_new > bounds[:, 1]): - chain[i, ...] = x - logp_chain[i] = logp - continue - logp_new = float(np.squeeze(log_posterior(x_new))) - log_ratio = min(0, logp_new - logp) - xi = np.log(rng.random()) - if xi < log_ratio: - x = x_new - logp = logp_new - accepted += 1 - - chain[i, ...] = x - logp_chain[i] = logp - - return chain, logp_chain, accepted diff --git a/src/rxmc/model.py b/src/rxmc/model.py new file mode 100644 index 0000000..1179dd3 --- /dev/null +++ b/src/rxmc/model.py @@ -0,0 +1,158 @@ +""" +Models and predictors. + +A :class:`Model` is a spec of "observables from parameters": a callable +``fn(x, *values)`` in physical space, written with ``jax.numpy`` so gradients +flow through it, plus the :class:`~rxmc.params.Parameter` s it consumes. A :class:`Predictor` is that model **bound to a grid**: ``bind`` +is where anything expensive or grid-dependent is built (a reaction model +builds its solver workspace there and overrides only ``bind``). + +Models compose, and the composition happens on the bound predictors so a +reaction model and a plain function add without special cases: + +* ``model | transform`` applies a mean transform after the prediction + (:func:`~rxmc.transforms.scale` for a latent normalisation); +* ``model + other`` is an additive, ``x``-dependent correction (a sampled + mean discrepancy); +* ``model * other`` is a multiplicative one (an additive discrepancy in log + space; ``scale`` is its constant case). + +Parameters are concatenated left to right. A parameter object appearing on +both sides is one sampled value, as everywhere. +""" + +from __future__ import annotations + +import operator +from typing import Callable, Sequence + +import jax.numpy as jnp +import numpy as np + +from .params import Parameter +from .transforms import as_transform + +__all__ = ["Model", "Predictor", "polynomial"] + + +def _check_params(params) -> tuple: + params = tuple(params) + for p in params: + if not isinstance(p, Parameter): + raise TypeError(f"params must be Parameter objects, got {p!r}") + return params + + +class Predictor: + """A model bound to a grid: ``predictor(*values) -> y`` in physical space. + + Parameters + ---------- + params : sequence of Parameter + The values ``__call__`` expects, in order. + x : array_like + The grid the prediction is made on. + fn : callable + ``fn(*values) -> array`` on that grid. + meta : mapping, optional + The dataset metadata the model was bound with; a term evaluated at the + predictor's grid (:func:`~rxmc.predictive.grid_draws`) reads + it through ``c.meta(key)``. + """ + + def __init__(self, params: Sequence[Parameter], x, fn: Callable, meta=None): + self.params = _check_params(params) + self.x = np.asarray(x) + self._fn = fn + self.meta = meta + + def __call__(self, *values): + if len(values) != len(self.params): + raise ValueError( + f"predictor expects {len(self.params)} value(s), got {len(values)}" + ) + return jnp.asarray(self._fn(*values)) + + def __repr__(self): + names = ", ".join(p.name for p in self.params) + return f"Predictor(params=({names}), n={len(self.x)})" + + +class Model: + """A parametric model of an observable, in physical space. + + Parameters + ---------- + fn : callable, optional + ``fn(x, *values) -> array`` on a grid ``x``, in ``jax.numpy``. Subclasses that + build their prediction in :meth:`bind` may omit it. + params : sequence of Parameter, optional + The parameters ``fn`` consumes, in order. + """ + + def __init__(self, fn: Callable | None = None, params: Sequence[Parameter] = ()): + if fn is not None and not callable(fn): + raise TypeError("fn must be callable") + self.fn = fn + self.params = _check_params(params) + + def bind(self, x, meta=None) -> Predictor: + """The model on the grid ``x``; ``meta`` carries the dataset's kinematics. + + The generic model closes over ``x``. Reaction models override this to + build their solver on ``x`` from ``meta``. + """ + if self.fn is None: + raise TypeError(f"{type(self).__name__} must override bind()") + fn = self.fn + return Predictor(self.params, x, lambda *values: fn(x, *values), meta) + + def __or__(self, transform) -> "Model": + return _Transformed(self, as_transform(transform)) + + def __add__(self, other) -> "Model": + return _Combined(self, other, operator.add, "+") + + def __mul__(self, other) -> "Model": + return _Combined(self, other, operator.mul, "*") + + def __repr__(self): + names = ", ".join(p.name for p in self.params) + return f"{type(self).__name__}(params=({names}))" + + +class _Transformed(Model): + """``inner | transform``: the transform's parameters follow the model's.""" + + def __init__(self, inner: Model, transform): + self.inner, self.transform = inner, transform + super().__init__(None, inner.params + transform.params) + + def bind(self, x, meta=None) -> Predictor: + pred, t, n = self.inner.bind(x, meta), self.transform, len(self.inner.params) + return Predictor(self.params, x, lambda *v: t(pred(*v[:n]), *v[n:]), meta) + + +class _Combined(Model): + """``left op right`` on the bound predictors; parameters left then right.""" + + def __init__(self, left: Model, right: Model, op, symbol: str): + if not isinstance(right, Model): + raise TypeError(f"can only combine a Model with a Model, got {right!r}") + self.left, self.right, self.op, self.symbol = left, right, op, symbol + super().__init__(None, left.params + right.params) + + def bind(self, x, meta=None) -> Predictor: + lp, rp = self.left.bind(x, meta), self.right.bind(x, meta) + n, op = len(self.left.params), self.op + return Predictor(self.params, x, lambda *v: op(lp(*v[:n]), rp(*v[n:])), meta) + + +def polynomial(order: int) -> Model: + """A polynomial of the given order with parameters ``a0`` to ``a``. + + ``y = a_0 + a_1 x + a_2 x^2 + ...``; the parameters carry no prior. + """ + params = [Parameter(f"a{i}", latex=f"a_{i}") for i in range(order + 1)] + # jnp.polyval takes the highest-order coefficient first + return Model(lambda x, *a: jnp.polyval(jnp.stack(a[::-1]), jnp.asarray(x)), params) diff --git a/src/rxmc/model_comparison.py b/src/rxmc/model_comparison.py deleted file mode 100644 index 162c679..0000000 --- a/src/rxmc/model_comparison.py +++ /dev/null @@ -1,333 +0,0 @@ -""" -Sampler-agnostic model-comparison and predictive-checking utilities. - -Everything here consumes a :class:`~rxmc.constraint.Constraint` plus posterior -*samples* (rows of model parameters and, optionally, of the constraint's -covariance/likelihood parameters) and never touches a sampler: - -* :func:`predictive_draws` — draws from the posterior predictive - ``N(ym(theta), Sigma(theta))`` on the constraint's active points (or the - model-only predictive ``ym(theta)``). -* :func:`coverage_curve`, :func:`coverage_error`, :func:`sharpness` — empirical - calibration and width of those draws against the data. -* :func:`heldout_log_predictive`, :func:`log_posterior_predictive` — - out-of-sample scoring on a held-out constraint (e.g. - ``constraint.complement()``). -* :func:`logz_summary`, :func:`compare_logz` — nested-sampling evidence - bookkeeping with replicate-based errors and a conservative tie verdict. -* :func:`log_jacobian` — the comparison-space Jacobian needed to compare - evidences across residual spaces (e.g. log-y versus linear-y fits). - -Notes ------ -Drawing from ``N(ym, Sigma)`` in a *transformed* comparison space (an -observation with ``transform=log``) yields draws in that space; map them back -with the transform's inverse (``np.exp``) before comparing to raw data. -""" - -from __future__ import annotations - -import numpy as np -from scipy.special import logsumexp - -__all__ = [ - "log_jacobian", - "predictive_draws", - "coverage_curve", - "coverage_error", - "sharpness", - "heldout_log_predictive", - "log_posterior_predictive", - "logz_summary", - "compare_logz", - "split_samples", -] - - -def log_jacobian(constraint) -> float: - """Comparison-space log-Jacobian of a constraint (sum over active points). - - ``log Z_raw = log Z_transformed + log_jacobian``: add it to the evidence of a - fit performed in a transformed comparison space (e.g. ``transform=log``) - before comparing with a fit in raw space. Zero for identity transforms. - """ - return float(constraint.log_jacobian) - - -_DEFAULT_LEVELS = np.linspace(0.02, 0.98, 49) - - -def _psd_factor(Sigma, jitter=1e-10): - """A factor ``L`` with ``L L^T = Sigma``. - - The lower Cholesky factor when ``Sigma`` is positive definite; otherwise - the Cholesky factor of ``Sigma`` plus a jitter *relative* to its mean - variance, and failing that a symmetric square root from the eigen - decomposition (negative eigenvalues clipped to zero). No jitter is added - on the successful path, so draws are never inflated. - """ - Sigma = np.asarray(Sigma, dtype=float) - try: - return np.linalg.cholesky(Sigma) - except np.linalg.LinAlgError: - pass - scale = max(float(np.mean(np.diag(Sigma))), np.finfo(float).tiny) - try: - return np.linalg.cholesky(Sigma + jitter * scale * np.eye(len(Sigma))) - except np.linalg.LinAlgError: - w, V = np.linalg.eigh(Sigma) - return V * np.sqrt(np.clip(w, 0.0, None)) - - -def _rows(samples, n=None): - """Posterior samples as a 2-D ``(n_samples, n_params)`` array. - - A 1-D input is one sample row (as in :func:`split_samples`). When ``n`` is - given the number of rows must match it. - """ - samples = np.asarray(samples, dtype=float) - if samples.ndim == 1: - samples = samples[None, :] - if n is not None and samples.shape[0] != n: - raise ValueError(f"expected {n} sample rows, got {samples.shape[0]}") - return samples - - -def predictive_draws( - constraint, - model_samples, - cov_samples=None, - *, - n_rep: int = 1, - rng=None, - model_only: bool = False, -) -> np.ndarray: - """Posterior-predictive draws on the constraint's active points. - - For each posterior row ``theta_i`` the constraint gives ``ym_i`` and - ``Sigma_i``; ``n_rep`` draws ``ym_i + L_i z`` (``z ~ N(0, I)``) are taken. - With ``model_only=True`` the rows are ``ym_i`` (the model-only predictive, - no error-model noise). - - Parameters - ---------- - constraint : Constraint - The constraint whose predictive is wanted (its active points). - model_samples : array_like, shape (n, n_model_params) - Posterior samples of the physical-model parameters (a 1-D array is - one sample). - cov_samples : array_like, shape (n, constraint.n_params), optional - Matching samples of the constraint's parameters (required when the - constraint has any). - n_rep : int, optional - Draws per posterior row (ignored when ``model_only``). - rng : numpy.random.Generator, optional - Source of the standard-normal draws; a fresh default generator when - omitted. - model_only : bool, optional - Return the predictions ``ym_i`` themselves instead of draws around - them (no covariance is assembled). - - Returns - ------- - np.ndarray - Draws in the observations' comparison space: shape - ``(n * n_rep, n_data_pts)``, or ``(n, n_data_pts)`` when ``model_only``. - """ - rng = np.random.default_rng() if rng is None else rng - model_samples = _rows(model_samples) - n = model_samples.shape[0] - if constraint.n_params: - if cov_samples is None: - raise ValueError("constraint has parameters; pass cov_samples") - cov_samples = _rows(cov_samples, n) - else: - cov_samples = np.zeros((n, 0)) - - N = constraint.n_data_pts - if model_only: - out = np.empty((n, N)) - for i in range(n): - ym = np.concatenate(constraint.predict(*model_samples[i])) - out[i] = ym[constraint.active] - return out - - out = np.empty((n * n_rep, N)) - for i in range(n): - ym, Sigma = constraint.predict_and_covariance( - tuple(model_samples[i]), tuple(cov_samples[i]) - ) - L = _psd_factor(Sigma) - z = rng.standard_normal((n_rep, N)) - out[i * n_rep : (i + 1) * n_rep] = ym + z @ L.T - return out - - -def coverage_curve(draws, y, levels=None) -> np.ndarray: - """Empirical coverage of central predictive intervals at each nominal level. - - Parameters - ---------- - draws : array_like, shape (n_draws, n_pts) - y : array_like, shape (n_pts,) - The data the draws are checked against (same space as ``draws``). - levels : array_like, optional - Nominal central-interval probabilities in (0, 1). Defaults to 49 - levels from 0.02 to 0.98 (``_DEFAULT_LEVELS``). - - Returns - ------- - np.ndarray - Fraction of points inside the central ``level`` interval, per level. - """ - draws = np.asarray(draws, dtype=float) - y = np.asarray(y, dtype=float) - levels = _DEFAULT_LEVELS if levels is None else np.asarray(levels) - out = np.empty(len(levels)) - for i, lv in enumerate(levels): - lo, hi = np.percentile(draws, [50 * (1 - lv), 50 * (1 + lv)], axis=0) - out[i] = np.mean((y >= lo) & (y <= hi)) - return out - - -def coverage_error(draws, y, levels=None) -> float: - """``max |coverage(level) - level|`` — a single calibration score.""" - levels = _DEFAULT_LEVELS if levels is None else np.asarray(levels) - return float(np.max(np.abs(coverage_curve(draws, y, levels) - levels))) - - -def sharpness(draws, percentiles=(16, 84), transform=None) -> np.ndarray: - """Per-point width of a central predictive interval. - - Parameters - ---------- - draws : array_like, shape (n_draws, n_pts) - percentiles : (float, float), optional - Lower and upper percentiles (in 0-100) bounding the interval; the - default is the central 68 %. Note :func:`coverage_curve` takes - interval *probabilities* in (0, 1) instead. - transform : callable, optional - Applied to the draws first (e.g. ``np.exp`` to report widths in raw - space for a log comparison space, or ``np.log10``). - """ - draws = np.asarray(draws, dtype=float) - if transform is not None: - draws = transform(draws) - lo, hi = np.percentile(draws, percentiles, axis=0) - return hi - lo - - -def heldout_log_predictive(heldout_constraint, model_samples, cov_samples=None): - """``log p(y_held | theta_i)`` for each posterior row. - - ``heldout_constraint`` is typically ``fit_constraint.complement()``: the same - observations, terms and parameters, with the held-out points active. The - score is that constraint's log likelihood at each sample (a 1-D - ``model_samples`` is one sample). - - Returns - ------- - np.ndarray, shape (n,) - """ - model_samples = _rows(model_samples) - n = model_samples.shape[0] - if heldout_constraint.n_params: - if cov_samples is None: - raise ValueError("constraint has parameters; pass cov_samples") - cov_samples = _rows(cov_samples, n) - else: - cov_samples = np.zeros((n, 0)) - return np.array( - [ - heldout_constraint.log_likelihood( - tuple(model_samples[i]), tuple(cov_samples[i]) - ) - for i in range(n) - ] - ) - - -def log_posterior_predictive(logp_samples, logw=None) -> float: - """``log E_post[p(y_held | theta)]``: the joint log posterior predictive - density of the held-out block. - - A log-mean-exp over posterior samples of :func:`heldout_log_predictive` - values; pass ``logw`` (unnormalised log importance weights, e.g. - nested-sampling ``logwt``) for weighted samples. This is the joint - predictive of the whole held-out block, not the pointwise-summed ``elpd`` - of Vehtari et al.; divide by the number of held-out points for a - per-point score. - """ - logp = np.asarray(logp_samples, dtype=float) - if logw is None: - return float(logsumexp(logp) - np.log(len(logp))) - logw = np.asarray(logw, dtype=float) - return float(logsumexp(logp + logw) - logsumexp(logw)) - - -def logz_summary(logz, logzerr): - """Replicate-aware evidence summary. - - Parameters - ---------- - logz, logzerr : array_like - ``log Z`` and its sampler-reported error for each replicate run (one - value each is fine). - - Returns - ------- - (float, float, int) - ``(mean, err, n)`` with ``err = max(half-range across replicates, mean - reported error)`` — the sampler's own error is a lower bound. - """ - logz = np.atleast_1d(np.asarray(logz, dtype=float)) - logzerr = np.atleast_1d(np.asarray(logzerr, dtype=float)) - half_range = 0.5 * (logz.max() - logz.min()) if logz.size > 1 else 0.0 - return float(logz.mean()), float(max(half_range, logzerr.mean())), int(logz.size) - - -def compare_logz(a, b, sigma: float = 2.0) -> dict: - """``Delta log Z = a - b`` with a conservative tie verdict. - - Parameters - ---------- - a, b : (mean, err) or (mean, err, n) - As returned by :func:`logz_summary`; a trailing replicate count is - accepted and ignored (it is informational only). - sigma : float, optional - A difference smaller than ``sigma * hypot(err_a, err_b)`` is a ``"tie"``. - - Returns - ------- - dict - ``{"dlogZ": ..., "err": ..., "verdict": "a" | "b" | "tie"}``. - """ - ma, ea = a[0], a[1] - mb, eb = b[0], b[1] - d = float(ma - mb) - err = float(np.hypot(ea, eb)) - if abs(d) < sigma * err: - verdict = "tie" - else: - verdict = "a" if d > 0 else "b" - return {"dlogZ": d, "err": err, "verdict": verdict} - - -def split_samples(config, samples): - """Split flat sampler rows into ``(model_samples, [cov_samples, ...])``. - - Row-wise :meth:`~rxmc.config.CalibrationConfig.split_parameters`: one - covariance-sample block per parametric constraint, in - ``config.evidence.parametric_constraints`` order. - - Returns - ------- - (np.ndarray, list of np.ndarray) - ``model_samples`` of shape ``(n, n_model_params)`` and one - ``(n, constraint.n_params)`` array per parametric constraint. - """ - samples = np.asarray(samples, dtype=float) - if samples.ndim == 1: - samples = samples[None, :] - parts = np.split(samples, config.indices[:-1], axis=1) - return parts[0], parts[1:] diff --git a/src/rxmc/observation.py b/src/rxmc/observation.py deleted file mode 100644 index 95a177a..0000000 --- a/src/rxmc/observation.py +++ /dev/null @@ -1,354 +0,0 @@ -""" -Observation: a leaf of experimental data. - -An :class:`Observation` is *pure data* — an independent variable ``x``, a -dependent variable ``y``, and the statistical error ``y_stat_err`` on ``y``. It -emits **only** its statistical diagonal, via :meth:`Observation.statistical_term`. - -Every *correlated* mode — a dataset's own normalisation/offset systematic, an -unknown-noise term, a cross-dataset coupling — is an **explicit** -:class:`~rxmc.covariance.Term` added at constraint-assembly time (see -:mod:`rxmc.covariance`). Nothing correlated is hidden in a default. This is a -deliberate change from the old behaviour, which folded normalisation/offset into -``Observation.covariance`` silently; there is no compatibility path that -re-folds them. - -An observation may still *carry* its reported systematic magnitudes -(``y_sys_err_normalization``, ``y_sys_err_offset``) as **inert metadata** — -provenance from the measurement. :meth:`Observation.systematic_terms` turns them -into fixed-magnitude rank-one terms, but only when the caller asks: pass its -result via ``Constraint(extra_terms=...)``. -""" - -import copy - -import numpy as np - -from .covariance import offset_term, statistical_term, systematic_term -from .transforms import as_transform - - -def _as_point_mask(mask, n) -> np.ndarray: - """Coerce a point mask to a boolean array of shape ``(n,)``.""" - mask = np.asarray(mask, dtype=bool) - if mask.shape != (n,): - raise ValueError(f"mask must have shape ({n},), got {mask.shape}") - return mask - - -def _store_error_spec(value, n, name): - """Validate/normalize a systematic-error spec: None, scalar, or shape (n,).""" - if value is None: - return None - if np.ndim(value) == 0: - return float(value) - v = np.asarray(value, dtype=float) - if v.shape != (n,): - raise ValueError( - f"{name} must be a scalar or have shape ({n},), got shape {v.shape}" - ) - return v - - -class Observation: - """Experimental data: ``x``, ``y``, and the statistical error on ``y``. - - Parameters - ---------- - x : np.ndarray - Independent-variable data. - y : np.ndarray - Dependent-variable data, same shape as ``x``. - y_stat_err : np.ndarray, optional - Statistical (uncorrelated) error on ``y``. Defaults to zeros. - y_sys_err_normalization : float or np.ndarray, optional - Reported *fractional* (dimensionless) normalisation uncertainty — - inert metadata; see :meth:`systematic_terms`. - y_sys_err_offset : float or np.ndarray, optional - Reported *absolute* offset uncertainty, in the same units as ``y`` — - inert metadata; see :meth:`systematic_terms`. - label : str, optional - Human-readable dataset identifier used in error messages. - transform : Transform or callable, optional - Parameter-free *comparison-space* transform (see :mod:`rxmc.transforms`). - Pass **raw** ``y``: the observation stores ``y = transform(y_raw)`` and - propagates ``y_stat_err`` by the delta method, and the - :class:`~rxmc.constraint.Constraint` applies the same transform to the - model prediction — so ``transform=rxmc.transforms.log`` compares in log - space with the model written once, in physical space. - mask : array_like of bool, optional - Which points are *active* in a likelihood (default all). Inactive - points stay in the block (supports/terms are authored over all points) - but are excluded from the residual; use :meth:`masked` / - :meth:`masked_where` to derive fit/held-out views. - - Attributes - ---------- - x, y : np.ndarray - The data, ``y`` in comparison space. - y_raw, y_stat_err_raw : np.ndarray - ``y`` and its statistical error as given (physical space). - y_stat_err : np.ndarray - Statistical error on ``y`` in comparison space (raw, not squared). - transform : Transform - The comparison-space transform (identity by default). - mask : np.ndarray of bool - Active points. - identity : Observation - The root observation this one is a view of. Views made by - :meth:`masked` share it, so anything routing by observation (e.g. - :func:`rxmc.transforms.per_observation_scaling`) treats a masked view - and its root as the same dataset. - y_sys_err_normalization : float or np.ndarray or None - Fractional normalisation uncertainty (dimensionless). - y_sys_err_offset : float or np.ndarray or None - Absolute offset uncertainty (units of ``y``). - label : str or None - Human-readable dataset identifier. - n_data_pts : int - Number of data points. - """ - - def __init__( - self, - x: np.ndarray, - y: np.ndarray, - y_stat_err=None, - y_sys_err_normalization=None, - y_sys_err_offset=None, - label=None, - transform=None, - mask=None, - ): - self.label = label - self.identity = self - self.x = np.asarray(x) - y_raw = np.asarray(y, dtype=float) - if self.x.shape != y_raw.shape: - raise ValueError( - "x and y must have the same shape, they have shapes " - f"{self.x.shape} and {y_raw.shape}" - ) - self.n_data_pts = self.x.shape[0] - - y_stat_err = y_stat_err if y_stat_err is not None else np.zeros_like(y_raw) - y_stat_err = np.asarray(y_stat_err, dtype=float) - if y_stat_err.shape != y_raw.shape: - raise ValueError( - "y_stat_err must have the same shape as y, " - f"it has shape {y_stat_err.shape} and y has shape {y_raw.shape}" - ) - - self.transform = as_transform(transform) - if self.transform.params: - raise ValueError( - "an Observation's comparison-space transform must be parameter-free" - ) - self.y_raw = y_raw - self.y_stat_err_raw = y_stat_err - self.mask = ( - np.ones(self.n_data_pts, dtype=bool) - if mask is None - else _as_point_mask(mask, self.n_data_pts) - ) - if self.transform.is_identity: - self.y = y_raw - self.y_stat_err = y_stat_err - self._abs_jacobian = None - else: - # |t'(y_raw)|: the delta-method factor, reused by log_jacobian and - # systematic_terms - # inactive points may be non-finite (inf * 0 -> nan); the guard - # below only inspects the active ones - with np.errstate(invalid="ignore", divide="ignore"): - self._abs_jacobian = np.abs(self.transform.derivative(y_raw)) - self.y = self.transform(y_raw) - self.y_stat_err = self._abs_jacobian * y_stat_err - self._check_finite() - - self.y_sys_err_normalization = _store_error_spec( - y_sys_err_normalization, self.n_data_pts, "y_sys_err_normalization" - ) - self.y_sys_err_offset = _store_error_spec( - y_sys_err_offset, self.n_data_pts, "y_sys_err_offset" - ) - - def _check_finite(self): - """Reject non-finite comparison-space values at the active points.""" - if self.transform.is_identity: - return - bad = self.mask & ~(np.isfinite(self.y) & np.isfinite(self.y_stat_err)) - if np.any(bad): - raise ValueError( - f"transform {self.transform.name!r} is not finite at " - f"{int(bad.sum())} active data point(s) of dataset " - f"{self.label or 'observation'!r} (e.g. non-positive y under a " - "log transform); mask or drop those points" - ) - - # ------------------------------------------------------------------ - # Masks (active points) - # ------------------------------------------------------------------ - - @property - def n_active(self) -> int: - """Number of active (unmasked) points.""" - return int(self.mask.sum()) - - def masked(self, mask, label=None): - """A shallow copy of this observation with a new point mask. - - No data or pre-computed workspaces are rebuilt: the copy shares them and - only changes which points enter a likelihood. - """ - new = copy.copy(self) - new.mask = _as_point_mask(mask, self.n_data_pts) - if label is not None: - new.label = label - new._check_finite() - return new - - def masked_where(self, predicate, label=None): - """:meth:`masked` with ``mask = predicate(x)`` (points where it is True).""" - return self.masked(np.asarray(predicate(self.x), dtype=bool), label=label) - - # ------------------------------------------------------------------ - # Comparison-space bookkeeping - # ------------------------------------------------------------------ - - @property - def log_jacobian(self) -> float: - r"""``sum(log |t'(y_raw)|)`` over the active points. - - The log-Jacobian of the comparison-space transform: a constant in the - parameters, needed only to compare marginal likelihoods (log Z) across - different comparison spaces (``log Z_raw = log Z_transformed + - log_jacobian``). Zero for the identity. - """ - if self.transform.is_identity: - return 0.0 - return float(np.sum(np.log(self._abs_jacobian[self.mask]))) - - def _raw_prediction(self, ym): - """Invert the comparison-space transform on a prediction.""" - if self.transform.is_identity: - return np.asarray(ym, dtype=float) - inv = self.transform.inverse - if inv is None: - raise ValueError( - f"transform {self.transform.name!r} has no inverse; cannot map " - "predictions back to physical space" - ) - return inv(ym) - - # ------------------------------------------------------------------ - # Covariance terms - # ------------------------------------------------------------------ - - def statistical_term(self, support=None): - """The always-on, genuinely uncorrelated statistical diagonal. - - Parameters - ---------- - support : np.ndarray, optional - Indices of this observation's block in the stacked vector - (``None`` for a single-observation constraint). - - Returns - ------- - Term - ``diag(y_stat_err**2)`` on ``support`` (comparison space). - """ - return statistical_term(self.y_stat_err, support=support) - - def systematic_terms(self, support=None) -> list: - """This dataset's reported correlated systematics as fixed rank-one terms. - - Opt-in — **not** added to any covariance automatically. Pass the result - via ``Constraint(extra_terms=[*obs.systematic_terms(), ...])``. - Zero magnitudes are skipped, so an observation without reported - systematics yields an empty list. Magnitudes are reported in physical - space and propagated to the comparison space by the delta method - (``|t'| * omega`` for an offset, ``|t'(ym_raw)| * eta * ym_raw`` for a - normalisation). - - Parameters - ---------- - support : np.ndarray, optional - Indices of this observation's block in the stacked vector. ``None`` - binds the terms to the whole constraint, which is right only for a - single-observation constraint; in a multi-observation constraint - they then fail loudly with a shape error, so pass the block's - support there (see :func:`rxmc.covariance.stacked_supports`). - - Returns - ------- - list of Term - The absolute offset mode (``outer(omega, omega)``) first, then the - fractional, prediction-scaled normalisation mode - (``eta**2 * outer(ym, ym)``). - """ - - def reported(spec): - if spec is None or not np.any(np.asarray(spec) != 0.0): - return None - return np.broadcast_to(np.asarray(spec, dtype=float), (self.n_data_pts,)) - - # the identity transform has unit Jacobian and trivial inverse, so the - # delta-method expressions below reduce to the plain magnitudes. The - # two modes are linearised at different points on purpose: the offset - # is an error on the *data*, so it is propagated at y_raw; the - # normalisation multiplies the *prediction*, so its mode eta * ym_raw is - # propagated at ym_raw. - t = self.transform - terms = [] - omega = reported(self.y_sys_err_offset) - if omega is not None: - if not t.is_identity: - omega = self._abs_jacobian * omega - terms.append(offset_term(magnitude=omega, support=support)) - eta = reported(self.y_sys_err_normalization) - if eta is not None: - if not t.is_identity and t.inverse is None: - raise ValueError( - f"transform {t.name!r} has no inverse; the normalisation " - "systematic needs the physical-space prediction" - ) - - def basis(c): - ym_raw = self._raw_prediction(c.ym) - return eta * ym_raw * np.abs(t.derivative(ym_raw)) - - terms.append(systematic_term(None, basis, support=support)) - return terms - - def num_pts_within_interval( - self, - ylow: np.ndarray, - yhigh: np.ndarray, - xlim=None, - ): - """Number of active points of ``y`` that fall within ``[ylow, yhigh)``. - - Useful for empirical-coverage diagnostics. ``ylow``/``yhigh`` are in - comparison space and indexed over *all* points of the block. - - Parameters - ---------- - ylow, yhigh : np.ndarray - Interval bounds, same shape as ``y``. - xlim : tuple, optional - ``(x_min, x_max)`` range to restrict the count. - """ - mask = self.mask.copy() - if xlim is not None: - xlow, xhigh = xlim - mask &= np.logical_and(self.x >= xlow, self.x < xhigh) - return int( - np.sum( - np.logical_and( - self.y[mask] >= ylow[mask], - self.y[mask] < yhigh[mask], - ) - ) - ) diff --git a/src/rxmc/observation_from_measurement.py b/src/rxmc/observation_from_measurement.py deleted file mode 100644 index 3dfc871..0000000 --- a/src/rxmc/observation_from_measurement.py +++ /dev/null @@ -1,82 +0,0 @@ -""" -Helpers shared by the reaction-observation classes. - -The reaction observations (:class:`~rxmc.elastic_diffxs_observation.ElasticDifferentialXSObservation` -and :class:`~rxmc.ias_pn_observation.IsobaricAnalogPNObservation`) are now plain -:class:`~rxmc.observation.Observation` subclasses carrying **statistical error -only**; any correlated systematic is composed explicitly as a -:class:`~rxmc.covariance.Term` in the :class:`~rxmc.constraint.Constraint`. This -module holds what the reaction observations *and* the reaction models share: -the angle-grid validation, the single ``pint`` unit registry, and the unit -convention (cross sections are stored internally in b/sr; ``jitr`` returns -mb/sr, so model outputs are divided by :data:`MB_PER_B`). -""" - -import numpy as np -from pint import UnitRegistry - -#: The one unit registry for the package. ``pint`` refuses to combine -#: quantities from different registries, so every module must use this one. -ureg = UnitRegistry() - -#: Default maximum partial wave for the reaction solvers. -DEFAULT_LMAX = 20 - -#: Internal cross-section unit: every ``y`` in b/sr. -XS_UNIT = ureg.barn / ureg.steradian - -#: Unit ``jitr`` reports cross sections (and the Rutherford cross section) in. -RUTHERFORD_UNIT = ureg.millibarn / ureg.steradian - -#: Millibarn per barn; divides ``jitr`` output to land in :data:`XS_UNIT`. -MB_PER_B = float((1 * ureg.barn).to(ureg.millibarn).magnitude) - - -def normalized_error_kwargs( - norm, y_stat_err, y_sys_err_normalization, y_sys_err_offset -) -> dict: - """Error keywords for ``Observation.__init__`` in internal (norm-divided) units. - - Encodes the unit contract shared by the reaction observations: dimensionful - errors (statistical, absolute offset) are divided by ``norm`` (a scalar, or - a per-point array); the fractional normalisation error is dimensionless and - passed through untouched. - """ - return { - "y_stat_err": ( - None if y_stat_err is None else np.asarray(y_stat_err, dtype=float) / norm - ), - "y_sys_err_normalization": y_sys_err_normalization, - "y_sys_err_offset": ( - None - if y_sys_err_offset is None - else np.asarray(y_sys_err_offset, dtype=float) / norm - ), - } - - -def measurement_kwargs(measurement) -> dict: - """The ``Observation``-side constructor keywords carried by an - ``exfor_tools`` :class:`~exfor_tools.distribution.Distribution`. - - Shared by the reaction observations' ``from_measurement`` classmethods; the - reaction-specific arguments (``reaction``, ``quantity``/``ExIAS``, solver - settings, ``transform``, ``mask``) are passed alongside. - """ - return { - "x": measurement.x, - "y": measurement.y, - "Elab": measurement.Einc, - "y_units": measurement.y_units, - "y_stat_err": measurement.statistical_err, - "y_sys_err_normalization": measurement.systematic_norm_err, - "y_sys_err_offset": measurement.systematic_offset_err, - "dataset_label": getattr(measurement, "subentry", None), - } - - -def check_angle_grid(angles_rad: np.ndarray, name: str): - if len(angles_rad.shape) > 1: - raise ValueError(f"{name} must be 1D, is {len(angles_rad.shape)}D") - if angles_rad[0] < 0 or angles_rad[-1] > np.pi: - raise ValueError(f"{name} must be on [0,pi)") diff --git a/src/rxmc/optimize.py b/src/rxmc/optimize.py new file mode 100644 index 0000000..44f25e3 --- /dev/null +++ b/src/rxmc/optimize.py @@ -0,0 +1,114 @@ +""" +Point estimates of a compiled problem: the posterior mode and the maximum of +the likelihood. + +Both search from several prior draws and keep the best end, because reaction +posteriors have local modes; the log density at every end is returned too, +so the modes are visible. The two share one signature and one return +convention, and both use L-BFGS-B with the exact gradient: + +* :func:`find_map` maximises ``log_posterior``: where a gradient sampler + (HMC/NUTS, recipe 41) or a Laplace approximation (recipe 33) starts; +* :func:`find_mle` maximises ``log_likelihood``. + +Both stay inside :attr:`~rxmc.problem.Problem.support`, the bounds narrowed by +the priors' supports, where the densities are defined. A search that does +not converge is not silent: the result counts the searches that succeeded +(``n_success``), and a warning names scipy's message when even the best one +did not. +""" + +from __future__ import annotations + +import time +import warnings + +import numpy as np +from scipy.optimize import OptimizeResult, minimize + +__all__ = ["find_map", "find_mle"] + + +def find_map(problem, n_starts: int = 8, rng=None, options=None) -> OptimizeResult: + """The posterior mode, by L-BFGS-B with the exact gradient. + + Returns the best search's ``OptimizeResult`` with ``x`` the mode, + ``fun`` the log posterior there, ``nfev`` the evaluations of all + ``n_starts`` searches, ``wall`` their time in seconds, ``ends`` the log + posterior at every search's end, best first, and ``n_success`` the number + of searches that converged on a finite density; ``success`` is whether + the best one did. ``options`` is passed to scipy (e.g. + ``{"maxiter": 500}``). Warns when the best search did not converge. + """ + return _search( + problem, problem.value_and_grad_log_posterior, n_starts, rng, options + ) + + +def find_mle(problem, n_starts: int = 8, rng=None, options=None) -> OptimizeResult: + """The maximum of the likelihood, by L-BFGS-B with the exact gradient. + + The prior is ignored except for its support. Returns as + :func:`find_map`, with ``fun`` and ``ends`` the log likelihood. Where the + likelihood has no single maximum the result is one point of many: a + hierarchy's likelihood depends on ``mu + tau * eta_j`` only, so its + maximum is a ridge, and the search stops wherever it meets it. + """ + return _search( + problem, problem.value_and_grad_log_likelihood, n_starts, rng, options + ) + + +def _search(problem, value_and_grad, n_starts, rng, options): + support = problem.support + # an infinite end is no bound to scipy; a finite one is kept, nudged + # inside so the search never evaluates exactly on it + width = np.where(np.isfinite(support).all(axis=1), np.diff(support).ravel(), 1.0) + lo = np.where(np.isfinite(support[:, 0]), support[:, 0] + 1e-9 * width, None) + hi = np.where(np.isfinite(support[:, 1]), support[:, 1] - 1e-9 * width, None) + bounds = list(zip(lo, hi)) + + def negative(t): + v, g = value_and_grad(t) + return -v, -g + + t0 = time.perf_counter() + fits = [ + minimize( + negative, + start, + jac=True, + method="L-BFGS-B", + bounds=bounds, + options=options, + ) + for start in problem.sample_prior(n_starts, rng=rng) + ] + # a search that stops on a -inf plateau (zero gradient) reports success, + # so success counts only where it ended on a finite density + value = np.array([-f.fun if np.isfinite(f.fun) else -np.inf for f in fits]) + ends = np.sort(value)[::-1] + best = fits[int(np.argmax(value))] + if not np.isfinite(value.max()): + warnings.warn( + f"none of {len(fits)} searches ended where the density is finite", + RuntimeWarning, + stacklevel=3, + ) + elif not best.success: + warnings.warn( + f"the best of {len(fits)} searches did not converge: {best.message}", + RuntimeWarning, + stacklevel=3, + ) + finite = bool(np.isfinite(value.max())) + best.update( + success=bool(best.success) and finite, + message=best.message if finite else "no search ended on a finite density", + fun=float(value.max()), + nfev=int(sum(f.nfev for f in fits)), + wall=time.perf_counter() - t0, + ends=ends, + n_success=int(sum(bool(f.success) and np.isfinite(f.fun) for f in fits)), + ) + return best diff --git a/src/rxmc/param_sampling.py b/src/rxmc/param_sampling.py deleted file mode 100644 index 7064b41..0000000 --- a/src/rxmc/param_sampling.py +++ /dev/null @@ -1,407 +0,0 @@ -""" -Sampler classes wrapping MCMC algorithms for parameter estimation. - -:class:`Sampler` is the base class; it wraps any sampling algorithm function, -records the chain and acceptance statistics, and manages state across batches. -Three concrete subclasses are provided: - -- :class:`MetropolisHastingsSampler` — plain MH with a fixed proposal. -- :class:`AdaptiveMetropolisSampler` — sliding-window covariance adaptation. -- :class:`BatchedAdaptiveMetropolisSampler` — per-batch covariance adaptation. -""" - -from typing import Callable - -import numpy as np - -from . import params, proposal -from .adaptive_metropolis import adaptive_metropolis -from .metropolis_hastings import metropolis_hastings -from .priors import as_prior - - -class Sampler: - """Base class wrapping a sampling algorithm with chain recording. - - Parameters - ---------- - params : list of Parameter - Parameters to sample. - prior : object - Prior distribution with a callable ``logpdf(x)`` method. - starting_location : np.ndarray, shape (ndim,) - Initial parameter vector. - sampling_algorithm : callable - Function implementing the sampling algorithm. Must have the - signature ``f(x0, bounds, n_steps, log_posterior, rng, *args, **kwargs)`` - and return ``(chain, logp_chain, n_accepted)``. - args : tuple, optional - Extra positional arguments passed to *sampling_algorithm*. - kwargs : dict, optional - Extra keyword arguments passed to *sampling_algorithm*. - """ - - def __init__( - self, - params: list[params.Parameter], - prior, - starting_location: np.ndarray, - sampling_algorithm, - args: tuple = None, - kwargs: dict = None, - ): - self.params = params - self.starting_location = starting_location - # a list of scipy marginals becomes an IndependentPrior, as in - # ParameterConfig, so both drivers accept the same prior forms - self.prior = as_prior(prior) - self.sampling_algorithm = sampling_algorithm - self.args = args if args is not None else () - self.kwargs = kwargs if kwargs is not None else {} - self.batches_run = 0 - self.n_steps = [] - self.n_accepted = [] - self.chain = np.empty((0, starting_location.size)) - self.logp_chain = np.empty((0,)) - self.state = np.atleast_1d(starting_location) - self.bounds = np.array([param.bounds for param in params]) - - _validate_object( - self.prior, - "prior", - required_methods=["logpdf"], - ) - - def record_batch( - self, n_steps: int, n_accepted: int, chain: np.ndarray, logp_chain: np.ndarray - ): - """Append a completed batch to the running chain. - - Parameters - ---------- - n_steps : int - Number of steps in the batch. - n_accepted : int - Number of accepted proposals in the batch. - chain : np.ndarray, shape (n_steps, ndim) - Sampled parameter vectors. - logp_chain : np.ndarray, shape (n_steps,) - Log posterior values for the batch. - """ - self.batches_run += 1 - self.n_steps.append(n_steps) - self.n_accepted.append(n_accepted) - self.chain = np.concatenate((self.chain, chain), axis=0) - self.logp_chain = np.concatenate((self.logp_chain, logp_chain), axis=0) - - def sample( - self, - n_steps: int, - starting_location: np.ndarray, - rng: np.random.Generator, - log_posterior: Callable[[np.ndarray], float], - burn: bool = False, - ): - """Run the sampling algorithm for one batch. - - Updates ``self.state`` to the last sample; records the batch unless - *burn* is ``True``. - - Parameters - ---------- - n_steps : int - Number of steps to run. - starting_location : np.ndarray, shape (ndim,) - Starting parameter vector for this batch. - rng : np.random.Generator - Random number generator. - log_posterior : callable - Function ``f(x) -> float`` returning the log posterior at ``x``. - burn : bool, optional - If ``True``, discard samples (burn-in); only ``self.state`` is - updated. Defaults to ``False``. - """ - chain, logp_chain, accepted = self.sampling_algorithm( - starting_location, - self.bounds, - n_steps, - log_posterior, - rng, - *self.args, - **self.kwargs, - ) - self.state = np.atleast_1d(chain[-1, :]) - - if not burn: - self.record_batch(n_steps, accepted, chain, logp_chain) - - def most_recent_batch_acceptance_fraction(self) -> float: - """Acceptance fraction of the most recent batch. - - Returns - ------- - float - Fraction of proposals accepted in the last batch, or ``0.0`` if - no batches have been run. - """ - if self.batches_run == 0: - return 0.0 - return self.n_accepted[-1] / self.n_steps[-1] - - def batch_acceptance_fractions(self) -> np.ndarray: - """Acceptance fraction for each completed batch. - - Returns - ------- - np.ndarray - Per-batch acceptance fractions, or ``[0.0]`` if no batches run. - """ - if self.batches_run == 0: - return np.array([0.0]) - return np.array(self.n_accepted) / np.array(self.n_steps) - - def overall_acceptance_fraction(self) -> float: - """Overall acceptance fraction across all completed batches. - - Returns - ------- - float - Total accepted / total proposed, or ``0.0`` if no batches run. - """ - if self.batches_run == 0: - return 0.0 - return sum(self.n_accepted) / sum(self.n_steps) - - -class MetropolisHastingsSampler(Sampler): - """Metropolis-Hastings sampler with a fixed proposal distribution. - - Parameters - ---------- - params : list of Parameter - Parameters to sample. - prior : object - Prior distribution with a callable ``logpdf(x)`` method. - starting_location : np.ndarray, shape (ndim,) - Initial parameter vector. - proposal : ProposalDistribution - Callable proposal distribution. Must accept ``(x, rng)`` and return - a proposed parameter vector. - """ - - def __init__( - self, - params: list[params.Parameter], - prior, - starting_location: np.ndarray, - proposal: proposal.ProposalDistribution, - ): - if not callable(proposal): - raise ValueError( - "The proposal must be a callable object that takes in a " - "parameter vector and an rng returns a proposed parameter" - " vector." - ) - self.proposal = proposal - super().__init__( - params, - prior, - starting_location, - metropolis_hastings, - args=[self.proposal], - kwargs={}, - ) - - -class AdaptiveMetropolisSampler(Sampler): - """Metropolis sampler that adapts the proposal covariance with a sliding window. - - The proposal covariance is estimated from the last *window_size* samples - after *adapt_start* steps have been collected. - - Parameters - ---------- - params : list of Parameter - Parameters to sample. - prior : object - Prior distribution with a callable ``logpdf(x)`` method. - starting_location : np.ndarray, shape (ndim,) - Initial parameter vector. - adapt_start : int, optional - Step at which adaptation begins. Defaults to ``100``. - window_size : int, optional - Number of past samples used for covariance estimation. - Defaults to ``1000``. - epsilon_fraction : float, optional - Small regularisation term for the proposal covariance. - Defaults to ``1e-6``. - """ - - def __init__( - self, - params: list[params.Parameter], - prior, - starting_location: np.ndarray, - adapt_start: int = 100, - window_size: int = 1000, - epsilon_fraction: float = 1e-6, - ): - super().__init__( - params, - prior, - starting_location, - adaptive_metropolis, - args=[], - kwargs={ - "adapt_start": adapt_start, - "window_size": window_size, - "epsilon_fraction": epsilon_fraction, - }, - ) - - def sample( - self, - n_steps: int, - starting_location: np.ndarray, - rng: np.random.Generator, - log_posterior: Callable[[np.ndarray], float], - burn: bool = False, - ): - """Run the adaptive sampler for one batch, passing history to the algorithm. - - Overrides :meth:`Sampler.sample` to forward the accumulated chain so - the adaptive algorithm can estimate the covariance from all past samples. - - Parameters - ---------- - n_steps : int - Number of steps to run. - starting_location : np.ndarray, shape (ndim,) - Starting parameter vector. - rng : np.random.Generator - Random number generator. - log_posterior : callable - Function ``f(x) -> float`` returning the log posterior. - burn : bool, optional - If ``True``, discard samples. Defaults to ``False``. - """ - chain, logp_chain, accepted = self.sampling_algorithm( - starting_location, - self.bounds, - n_steps, - log_posterior, - rng, - *self.args, - **self.kwargs, - previous_chain=self.chain, - ) - self.state = np.atleast_1d(chain[-1, :]) - - if not burn: - self.record_batch(n_steps, accepted, chain, logp_chain) - - -class BatchedAdaptiveMetropolisSampler(Sampler): - """Metropolis sampler that updates the proposal covariance after each batch. - - After **every** completed batch — burn-in batches included — the proposal - covariance is replaced by the empirical covariance of that batch, scaled - by ``2.38² / ndim``. Burn-in only affects whether the samples are - recorded, so the proposal adapts during burn-in as is standard. - - Parameters - ---------- - params : list of Parameter - Parameters to sample. - prior : object - Prior distribution with a callable ``logpdf(x)`` method. - starting_location : np.ndarray, shape (ndim,) - Initial parameter vector. - initial_proposal_cov : np.ndarray, shape (ndim, ndim) - Initial proposal covariance matrix. - epsilon_fraction : float, optional - Small regularisation fraction added to the empirical covariance diagonal. - Defaults to ``1e-6``. - """ - - def __init__( - self, - params: list[params.Parameter], - prior, - starting_location: np.ndarray, - initial_proposal_cov: np.ndarray, - epsilon_fraction: float = 1e-6, - ): - self.proposal_cov = np.atleast_2d(initial_proposal_cov) - self.proposal = proposal.NormalProposalDistribution(initial_proposal_cov) - super().__init__( - params, - prior, - starting_location, - metropolis_hastings, - args=[self.proposal], - ) - ndim = starting_location.size - self.scale = 2.38**2 / ndim - self.epsilon_fraction = epsilon_fraction - - def sample( - self, - n_steps: int, - starting_location: np.ndarray, - rng: np.random.Generator, - log_posterior: Callable[[np.ndarray], float], - burn: bool = False, - ): - """Run the sampler for one batch, then adapt the proposal. - - Overrides :meth:`Sampler.sample` to replace the proposal covariance - with the current batch's empirical covariance after every batch, - burn-in or not. :attr:`proposal` and :attr:`proposal_cov` always - reflect the proposal the *next* batch will use. - - Parameters - ---------- - n_steps : int - Number of steps to run. - starting_location : np.ndarray, shape (ndim,) - Starting parameter vector. - rng : np.random.Generator - Random number generator. - log_posterior : callable - Function ``f(x) -> float`` returning the log posterior. - burn : bool, optional - If ``True``, discard the samples (they are not recorded); the - covariance update still happens. Defaults to ``False``. - """ - chain, logp_chain, accepted = self.sampling_algorithm( - starting_location, - self.bounds, - n_steps, - log_posterior, - rng, - *self.args, - **self.kwargs, - ) - self.state = np.atleast_1d(chain[-1, :]) - empirical_cov = np.atleast_2d(np.cov(chain.T)) - epsilon = self.epsilon_fraction * np.median(np.diag(empirical_cov)) - self.proposal_cov = ( - self.scale * empirical_cov + np.eye(empirical_cov.shape[0]) * epsilon - ) - self.proposal = proposal.NormalProposalDistribution(self.proposal_cov) - self.args = [self.proposal] - if not burn: - self.record_batch(n_steps, accepted, chain, logp_chain) - - -def _validate_object(obj, name: str, required_attributes=[], required_methods=[]): - for attr in required_attributes: - if not hasattr(obj, attr): - raise ValueError(f"The {name} object must have a '{attr}' attribute.") - - for method in required_methods: - if not callable(getattr(obj, method, None)): - raise ValueError( - f"The {name} object must have a callable '{method}' method." - ) diff --git a/src/rxmc/params.py b/src/rxmc/params.py index a5fc547..ecc2a12 100644 --- a/src/rxmc/params.py +++ b/src/rxmc/params.py @@ -1,66 +1,83 @@ -""" -Parameter definitions. +"""The sampled scalar. + +A :class:`Parameter` is a declaration: a name, optional bounds, an optional +marginal prior, and display metadata. Its identity *is* the object: passing +the same ``Parameter`` to two places, anywhere in a problem, shares one sampled +value between them. Two distinct objects with the same name are two +parameters, and :class:`~rxmc.problem.Problem` rejects the duplicate name. -The :class:`Parameter` class describes a single scalar model parameter — -its name, data type, physical unit, LaTeX label, and optional bounds. +Prior rules, enforced once at compile: + +* ``prior`` given: the marginal, truncated to ``bounds``; +* finite ``bounds`` and no ``prior``: uniform on the bounds; +* neither: the parameter must be covered by a joint prior passed to + ``Problem``, otherwise compile fails naming it. """ -import numpy as np +from __future__ import annotations + +from dataclasses import dataclass, field +from math import inf +from typing import Callable +__all__ = ["Parameter"] + +@dataclass(eq=False, frozen=True) class Parameter: """A single scalar model parameter. Parameters ---------- name : str - Human-readable name of the parameter. - dtype : type, optional - Data type of the parameter value. Defaults to ``float``. + Non-empty; used for chain columns, plots and error messages. + bounds : (float, float), optional + Support of the parameter, ``(-inf, inf)`` by default. ``lo < hi``. + prior : object, optional + A frozen univariate distribution exposing ``logpdf``, ``cdf``, ``ppf`` + and ``rvs`` (any ``scipy.stats`` frozen distribution). Left ``None`` + when the parameter is covered by a joint prior. unit : str, optional - Physical unit string (e.g. ``"MeV"``). Defaults to ``""``. - latex_name : str, optional - LaTeX representation used in plots and documentation. Defaults to - ``name`` when not supplied. - bounds : tuple of float, optional - ``(lower, upper)`` bounds for the parameter. Defaults to - ``(-np.inf, np.inf)``. Stored as a tuple of floats. - - Notes - ----- - Equality and hashing are by *value* (all five fields), so equal - parameters are interchangeable as dict keys and set members. Sharing one - sampled value between covariance terms is by object *identity* (see - :mod:`rxmc.covariance`); two equal-but-distinct parameters are two - parameters. + Physical unit string for display. + latex : str, optional + LaTeX label for plots; ``name`` when omitted. + logpdf : callable, optional + ``logpdf(value)`` of ``prior`` written in ``jax.numpy``, for a prior + whose scipy family :class:`~rxmc.problem.Problem` cannot translate to + JAX itself (see :data:`~rxmc.problem.JAX_LOGPDFS`). ``prior`` still + provides the unit-cube map, the draws and the truncation mass. """ - def __init__( - self, name, dtype=float, unit="", latex_name=None, bounds=(-np.inf, np.inf) - ): - self.name = name - self.dtype = dtype - self.unit = unit - bounds = tuple(float(b) for b in bounds) - if len(bounds) != 2: - raise ValueError(f"bounds must be (lower, upper), got {bounds!r}") - self.bounds = bounds - self.latex_name = latex_name if latex_name else name - - def _key(self): - return (self.name, self.dtype, self.unit, self.latex_name, self.bounds) + name: str + bounds: tuple[float, float] = (-inf, inf) + prior: object | None = field(default=None, repr=False) + unit: str = "" + latex: str | None = None + logpdf: Callable | None = field(default=None, repr=False) - def __eq__(self, other): - if not isinstance(other, Parameter): - return False - return self._key() == other._key() + def __post_init__(self): + if not isinstance(self.name, str) or not self.name: + raise ValueError(f"name must be a non-empty string, got {self.name!r}") + try: + lo, hi = (float(b) for b in self.bounds) + except (TypeError, ValueError): + raise ValueError( + f"bounds must be (lower, upper), got {self.bounds!r}" + ) from None + if not lo < hi: + raise ValueError(f"bounds must satisfy lower < upper, got {(lo, hi)!r}") + object.__setattr__(self, "bounds", (lo, hi)) + if self.logpdf is not None and self.prior is None: + raise ValueError( + f"parameter {self.name!r}: logpdf= is the JAX density of prior=, " + "so it needs a prior" + ) - def __hash__(self): - return hash(self._key()) + @property + def label(self) -> str: + """The LaTeX label, falling back to the name.""" + return self.latex if self.latex is not None else self.name def __repr__(self): - return ( - f"Parameter({self.name!r}, dtype={self.dtype.__name__}, " - f"unit={self.unit!r}, latex_name={self.latex_name!r}, " - f"bounds={self.bounds!r})" - ) + prior = ", prior=set" if self.prior is not None else "" + return f"Parameter({self.name!r}, bounds={self.bounds!r}{prior})" diff --git a/src/rxmc/physical_model.py b/src/rxmc/physical_model.py deleted file mode 100644 index b47ea22..0000000 --- a/src/rxmc/physical_model.py +++ /dev/null @@ -1,153 +0,0 @@ -""" -Abstract physical model and a concrete polynomial model. - -A :class:`PhysicalModel` maps a parameter vector to predicted observable values -for a given :class:`~rxmc.observation.Observation`. Subclasses implement -:meth:`~PhysicalModel.evaluate`; the base class makes the object callable so it -can be used directly as ``model(obs, *params)``. - -:class:`Polynomial` is a ready-to-use implementation for polynomial regression. -""" - -import numpy as np - -from .observation import Observation -from .params import Parameter -from .transforms import as_transform - - -class PhysicalModel: - """Abstract base class for parametric physical models. - - Represents an arbitrary parametric model - $y_{\\mathrm{model}}(x;\\,\\alpha)$ for comparison to an experimental - measurement $\\{x_i,\\, y(x_i)\\}$ encapsulated in an - :class:`~rxmc.observation.Observation`. - - Subclasses implement :meth:`evaluate` in physical space. An optional - *parametric* ``transform`` (see :mod:`rxmc.transforms`) is applied on top by - :meth:`__call__`; its parameters are appended to :attr:`params` so they flow - through the ordinary model-parameter machinery (priors, ``split_parameters``). - Typical uses are a latent normalisation :func:`rxmc.transforms.scale` or one - per dataset via :func:`rxmc.transforms.per_observation_scaling`. Comparison- - space transforms (e.g. comparing in log space) are *not* the model's - business: declare them on the :class:`~rxmc.observation.Observation`. - - Parameters - ---------- - params : list of Parameter - Physical parameters of the model. Each entry should carry a name - and a data type. - transform : Transform or callable, optional - Model-side transform ``y -> transform(y, *values)`` applied after - :meth:`evaluate`. Its parameters (if any) are appended to ``params``. - """ - - def __init__(self, params: list[Parameter], transform=None): - self.base_params = list(params) - self.transform = as_transform(transform) - self.params = self.base_params + list(self.transform.params) - self.n_base_params = len(self.base_params) - self.n_params = len(self.params) - - def split_params(self, params): - """Split a full parameter tuple into ``(base_params, transform_values)``.""" - params = tuple(params) - if len(params) != self.n_params: - raise ValueError( - f"{type(self).__name__} expects {self.n_params} parameter(s), " - f"got {len(params)}" - ) - return params[: self.n_base_params], params[self.n_base_params :] - - def apply_transform(self, observation, y, transform_values=()): - """Apply the model-side transform to a physical-space prediction.""" - if self.transform.is_identity: - return np.asarray(y, dtype=float) - return self.transform(y, *transform_values, context=observation) - - def evaluate(self, observation: Observation, *params) -> np.ndarray: - """Evaluate the model at the given parameter values. - - Must be overridden by subclasses. - - Parameters - ---------- - observation : Observation - Observation containing the independent-variable grid. - *params : float - Physical-model (base) parameter values only; any transform - parameters are split off by :meth:`__call__` before this is called. - - Returns - ------- - np.ndarray - Predicted observable values on the observation grid (physical - space, before the model transform). - - Raises - ------ - NotImplementedError - Always — subclasses must implement this method. - """ - raise NotImplementedError("Subclasses must implement the evaluate method.") - - def __call__(self, observation: Observation, *params) -> np.ndarray: - """Physical-space :meth:`evaluate` followed by the model transform.""" - base, values = self.split_params(params) - return self.apply_transform( - observation, self.evaluate(observation, *base), values - ) - - -class Polynomial(PhysicalModel): - r"""Polynomial model of fixed order. - - Predicts observable values as - - .. math:: - - y_{\mathrm{model}}(x;\,a_0,\dots,a_n) = \sum_{i=0}^{n} a_i\, x^i - - Parameters - ---------- - order : int - Polynomial order $n$. The model has $n+1$ free coefficients. - transform : Transform or callable, optional - See :class:`PhysicalModel`. - """ - - def __init__(self, order: int, transform=None): - params = [] - for i in range(order + 1): - params.append(Parameter(f"a{i}", latex_name=f"a_{i}", dtype=float)) - self.order = order - super().__init__(params, transform=transform) - - def evaluate(self, observation: Observation, *params) -> np.ndarray: - """Evaluate the polynomial at the observation grid. - - Parameters - ---------- - observation : Observation - Observation whose ``x`` attribute provides the evaluation grid. - *params : float - Polynomial coefficients ``a0, a1, ..., an`` (lowest order first). - - Returns - ------- - np.ndarray - Polynomial values at ``observation.x``. - - Raises - ------ - ValueError - If the number of supplied coefficients does not match - ``self.order + 1``. - """ - if len(params) != self.order + 1: - raise ValueError(f"Expected {self.order + 1} parameters, got {len(params)}") - - x_powers = np.vander(observation.x, self.order + 1, increasing=True) - y = np.dot(x_powers, np.asarray(params)) - return y diff --git a/src/rxmc/predictive.py b/src/rxmc/predictive.py index a7fc92d..6e960ff 100644 --- a/src/rxmc/predictive.py +++ b/src/rxmc/predictive.py @@ -1,31 +1,102 @@ +r"""Posterior predictives on a grid the data were never measured on. + +:func:`rxmc.diagnostics.predictive_draws` draws the posterior predictive at the +*measured* points, where every term of the error model is defined, the reported +point-by-point errors included. Forecasting at new ``x`` is a different +question, and this module answers it: + +* :func:`grid_draws` — the general tool. For each posterior row the model is + evaluated on the grid, every selected covariance term is re-evaluated there + from its own definition, and one correlated draw is taken from the sum. Any + term that is a function of the :class:`~rxmc.terms.TermContext` travels: + inferred noise, :func:`~rxmc.terms.proportional_error`, normalisation, + offset and systematic modes, + a parametric ``Term(fn, params, kind="matrix")`` and a Gaussian-process + :func:`~rxmc.terms.kernel`. +* :func:`gp_predictive_draws` — the same draws for a kernel term, with the + option of conditioning the discrepancy on the observed residuals. +* :func:`gp_posterior_predictive` — that conditioning on bare arrays, and + :func:`predictive_band` — percentiles over any draws. + +All three draw functions share one convention with +:func:`~rxmc.diagnostics.predictive_draws`: a percentile band of shape +``(len(levels), n_points)`` by default, the draws themselves with +``return_draws=True``. + +What cannot go on a new grid +---------------------------- +A term that is an *array*, one number per measured point, has no value at an +``x`` that was never measured: the reported statistical errors a constraint +builds by default, a fixed ``Term(array)``, a normalisation or offset whose +``magnitude=`` is per point, or a function that closes over the measured rows. +Drawing it on a grid would be inventing the error of a measurement nobody made, +so both grid functions raise and name the term. The remedies are to draw at +the data with :func:`~rxmc.diagnostics.predictive_draws`, to say which terms a +draw carries with ``terms=`` (``[]`` or ``model_only=True`` for the model +alone), or to declare the experimental error as a term that is a function of +``x`` — :func:`~rxmc.terms.noise` with ``statistical=False`` — so it is defined +everywhere the model is. + +Which terms a draw carries is a choice of object, not a detail. The model +alone, the model plus a discrepancy, and the model plus discrepancy plus +experimental error answer different questions, and only the last predicts a +*measurement*. A term that belongs to one experiment (its normalisation, say) +drawn on a grid means "a future measurement by that experiment". + +Two predictives for a kernel +---------------------------- +A kernel term declares a *mean-zero* discrepancy, so the likelihood is the +marginal ``y ~ N(ym(theta), Sigma(theta))`` and inference in ``theta`` has the +discrepancy integrated out. The matching predictive draws correlated +departures from the inferred covariance around the model's own prediction: + +.. math:: + + y_* = y_m(x_*; \theta) + \delta, \qquad + \delta \sim \mathcal N\big(0,\ K_{**}(\theta)\big) + +which says where and by how much *the model* fails. That is what +:func:`grid_draws` gives. :func:`gp_predictive_draws` with ``conditioned=True`` +instead conditions the discrepancy on the observed residuals, + +.. math:: + + \delta \mid r \sim \mathcal N\big(K_{*t}(K_{tt} + N)^{-1} r,\ + K_{**} - K_{*t}(K_{tt} + N)^{-1}K_{t*}\big), + +which is data-driven regression on top of the model: it interpolates the +residuals rather than describing the model's error. + +Kernels are tinygp kernels, built from the sampled hyperparameters by the +builder passed to :func:`~rxmc.terms.kernel`. These draws are not +differentiated, so this module works in numpy on the values the JAX terms +return. """ -Predictive-uncertainty helpers. - -A :func:`~rxmc.covariance.kernel_term` -only inflates the covariance *at the data points* with ``K(X, X)`` — it does not -propagate the discrepancy to new ``x``. :func:`gp_posterior_predictive` performs -the standard Gaussian-process conditioning needed to predict the discrepancy (mean -and covariance) at new points, and :func:`total_predictive_band` turns a posterior -sample of ``[model params | kernel log-theta]`` into a data-space predictive band -that propagates model-parameter, discrepancy, and observation-noise uncertainty. - -The kernel is duck-typed exactly as in :func:`~rxmc.covariance.kernel_term`: a -scikit-learn-style object exposing ``clone_with_theta`` and ``__call__``, with -``theta`` in sklearn **log-theta** space. -""" + +from __future__ import annotations import numpy as np -import scipy as sc +import scipy.linalg as sla + +from .diagnostics import _one_space, _psd_factor, _rows, _to_physical +from .problem import Problem, _per_point +from .terms import KernelTerm, TermContext, as_2d -from .covariance import as_2d +_GRID_HINT = "Pass comparison= to predict in the space of one of them" __all__ = [ + "grid_draws", + "gp_predictive_draws", "gp_posterior_predictive", - "total_predictive_band", "predictive_band", ] +# ---------------------------------------------------------------------------- +# GP conditioning +# ---------------------------------------------------------------------------- + + def _train_noise_matrix(train_noise_var, n) -> np.ndarray: if train_noise_var is None: return np.zeros((n, n)) @@ -37,231 +108,512 @@ def _train_noise_matrix(train_noise_var, n) -> np.ndarray: return v +def _condition(Ktt, Kst, r, N, jitter): + """``(mean, v)`` with ``mean = Kst (Ktt + N)^-1 r`` and ``v = L^-1 Kst^T``. + + Callers form the posterior covariance ``Kss - v^T v`` or its diagonal + ``diag(Kss) - sum(v**2, 0)``. + """ + n = len(r) + L = sla.cholesky(Ktt + N + jitter * np.eye(n), lower=True) + alpha = sla.cho_solve((L, True), r) + v = sla.solve_triangular(L, Kst.T, lower=True) + return Kst @ alpha, v + + def gp_posterior_predictive( - kernel, - theta, - X_train, - residuals, - X_pred, - *, - train_noise_var=None, - jitter=1e-10, + kernel, theta, X_train, residuals, X_pred, *, train_noise_var=None, jitter=1e-10 ): r"""Posterior mean and covariance of a GP discrepancy at ``X_pred``. - Conditions a zero-mean GP with covariance ``kernel`` (rebuilt at ``theta``) on - the observed ``residuals`` at ``X_train`` and returns its posterior at - ``X_pred``: + Conditions a zero-mean GP with covariance ``kernel`` (built at ``theta``) + on the observed ``residuals`` at ``X_train``: .. math:: \bar f_* = K_{*t} (K_{tt} + N)^{-1} r, \qquad \mathrm{cov}_* = K_{**} - K_{*t} (K_{tt} + N)^{-1} K_{t*} - where ``N`` is the training-noise covariance. - Parameters ---------- - kernel : sklearn-style kernel - Object with ``clone_with_theta`` and ``__call__`` (as for - :func:`~rxmc.covariance.kernel_term`). - theta : array-like - Kernel hyperparameters in sklearn **log-theta** space. - X_train, X_pred : array-like + kernel : callable + ``kernel(*theta) -> tinygp kernel``, the builder passed to + :func:`~rxmc.terms.kernel` (``term.build``); a fixed kernel ``k`` is + ``lambda: k`` with ``theta`` empty. + theta : array_like + The builder's arguments (the kernel parameters' sampled values). + X_train, X_pred : array_like Training and prediction inputs (1-D promoted to a column). - residuals : array-like, shape (n_train,) - Observed minus model-mean at ``X_train``. - train_noise_var : float, array-like, or matrix, optional - Training-noise variance: scalar (``var*I``), per-point vector - (``diag``), or full covariance. Defaults to none. + residuals : array_like, shape (n_train,) + Observed minus model mean at ``X_train``. + train_noise_var : float, array_like or matrix, optional + Training-noise covariance ``N``: scalar, per-point vector, or full. jitter : float, optional - Diagonal nugget added to the training covariance for stability. + Nugget added to the training covariance. Returns ------- mean : np.ndarray, shape (n_pred,) cov : np.ndarray, shape (n_pred, n_pred) """ - k = kernel.clone_with_theta(np.asarray(theta, dtype=float)) - Xp = as_2d(X_pred) - mean, v = _gp_condition( - k, X_train, residuals, Xp, train_noise_var=train_noise_var, jitter=jitter - ) - Kss = np.asarray(k(Xp), dtype=float) - cov = Kss - v.T @ v - return mean, cov + theta = () if theta is None else tuple(np.atleast_1d(theta)) + k = kernel(*theta) + Xt, Xp = as_2d(X_train), as_2d(X_pred) + r = np.asarray(residuals, dtype=float) + Ktt, Kst, Kss = (np.asarray(K) for K in (k(Xt, Xt), k(Xp, Xt), k(Xp, Xp))) + N = _train_noise_matrix(train_noise_var, len(r)) + mean, v = _condition(Ktt, Kst, r, N, jitter) + return mean, Kss - v.T @ v -def _gp_condition(k, X_train, residuals, Xp, *, train_noise_var, jitter): - """Shared GP conditioning: returns (mean, v). +def predictive_band(draws, levels=(16, 50, 84)) -> np.ndarray: + """Percentile band over ``draws`` of shape ``(n_draws, n_points)``. - ``k`` is an already-instantiated kernel (``clone_with_theta`` applied); - ``Xp`` is the 2-D prediction grid. ``mean = Kst @ alpha`` and - ``v = L^{-1} Kst.T`` so callers form the full posterior covariance - (``Kss - v.T @ v``) or only its diagonal (``diag(Kss) - sum(v**2, 0)``). + Returns ``(len(levels), n_points)``. """ - Xtr = as_2d(X_train) - r = np.asarray(residuals, dtype=float) - n = Xtr.shape[0] + return np.percentile(np.asarray(draws, dtype=float), levels, axis=0) - Ktt = np.asarray(k(Xtr), dtype=float) - Kst = np.asarray(k(Xp, Xtr), dtype=float) - Ktrain = Ktt + _train_noise_matrix(train_noise_var, n) + jitter * np.eye(n) - L = sc.linalg.cholesky(Ktrain, lower=True) - alpha = sc.linalg.cho_solve((L, True), r) - mean = Kst @ alpha - v = sc.linalg.solve_triangular(L, Kst.T, lower=True) - return mean, v +# ---------------------------------------------------------------------------- +# Draws on a new grid +# ---------------------------------------------------------------------------- -def _gp_posterior_mean_var( - kernel, theta, X_train, residuals, X_pred, *, train_noise_var=None, jitter=1e-10 -): - """Posterior mean and **diagonal variance** of a GP discrepancy at ``X_pred``. +def _locate(problem: Problem, term: KernelTerm): + """The compiled constraint holding ``term`` and its covariance entry.""" + if not isinstance(term, KernelTerm): + raise TypeError( + f"term must be the KernelTerm returned by rxmc.terms.kernel, got {term!r}" + ) + for c in problem.constraints: + for e in c.covariance.entries: + if e.term is term: + return c, e + if any(t is term for t in c.source.terms): + raise ValueError( + "the kernel term's support is fully masked in this problem: it has " + "no training rows to condition on" + ) + raise ValueError("the kernel term is not part of any constraint of the problem") - Equivalent to ``mean, diag(cov)`` from :func:`gp_posterior_predictive` but - avoids building the full ``n_pred x n_pred`` covariance — O(n_pred * n_train) - instead of O(n_pred^2 * n_train). Uses ``kernel.diag(X_pred)`` for the prior - variances. - """ - k = kernel.clone_with_theta(np.asarray(theta, dtype=float)) - Xp = as_2d(X_pred) - mean, v = _gp_condition( - k, X_train, residuals, Xp, train_noise_var=train_noise_var, jitter=jitter + +def _term_name(t) -> str: + """A term in a message: its kind, its parameters and the data it sits on.""" + names = ", ".join(p.name for p in t.params) + what = f"{t.kind} term({names})" if names else f"fixed {t.kind} term" + label = getattr(getattr(t.on, "data", None), "label", None) + return f"{what} on {label!r}" if label else what + + +def _meets(c, t, rows) -> bool: + """Whether term ``t`` has an active entry on any of ``rows``.""" + return any( + e.term is t and np.intersect1d(e.rows, rows).size for e in c.covariance.entries ) - prior_var = np.asarray(k.diag(Xp), dtype=float) - var = prior_var - np.einsum("ij,ij->j", v, v) - return mean, var -def predictive_band(draws, levels=(16, 50, 84)) -> np.ndarray: - """Percentile band over a matrix of predictive draws. +def _grid_terms(c, terms, rows) -> list: + """The terms a grid draw carries, or a ``ValueError`` saying why it cannot. - Parameters - ---------- - draws : array-like, shape (n_draws, n_points) - Predictive samples (each row a function evaluated on a grid). - levels : sequence of float, optional - Percentile levels. + ``terms=None`` takes every declared term with an active entry on ``rows``, + and refuses when the constraint's reported statistical errors are among + them. An explicit selection is honoured as given. Either way, a term + whose ``fn`` is an array is defined only at the measured rows. + """ + if terms is None: + stat = [t for t in c.statistical_terms if _meets(c, t, rows)] + if stat: + raise ValueError( + "the constraint's covariance includes the reported statistical " + f"errors ({[_term_name(t) for t in stat]}), one number per measured " + "point, and they have no value at an x that was never measured. " + "Draw at the measured points with rxmc.diagnostics.predictive_draws; " + "or choose the terms a grid draw carries with terms=[...] " + "(model_only=True for the model alone); or declare the experimental " + "error as a term that is a function of x, e.g. rxmc.terms.noise " + "with statistical=False, so it is defined everywhere the model is" + ) + chosen = [t for t in c.source.terms if _meets(c, t, rows)] + else: + chosen = list(terms) + for t in chosen: + if not any(t is u for u in c.source.terms): + raise ValueError( + f"{t!r} is not a term of this constraint; terms= selects among " + "the terms it was declared with (the reported statistical " + "errors cannot be drawn on a new grid at all)" + ) + arrays = [t for t in chosen if not callable(t.fn)] + if arrays: + raise ValueError( + f"{[_term_name(t) for t in arrays]}: an array-valued term has one value " + "per measured point and no value at a new x. Leave it out of terms=, " + "or write it as a function of the TermContext (c.x, c.ym) so it can be " + "evaluated anywhere" + ) + return chosen - Returns - ------- - np.ndarray, shape (len(levels), n_points) + +def _grid_piece(t, x_pred, mu, meta_p, values) -> np.ndarray: + """One term's contribution to the covariance at the prediction points. + + ``y`` and ``ym`` are both the model's prediction there: at a point that was + never measured the only meaning a term's ``c.y`` can carry is the model. """ - return np.percentile(np.asarray(draws, dtype=float), levels, axis=0) + try: + v = np.asarray(t.value(x_pred, mu, mu, *values, meta=meta_p), dtype=float) + except Exception as err: + raise ValueError( + f"the {_term_name(t)} could not be evaluated at the prediction points " + f"({err}); a term closing over the measured rows is defined only " + "there. Leave it out of terms=, or write it as a function of the " + "TermContext" + ) from err + if t.kind == "diag": + return np.diag(v**2) + if t.kind == "mode": + return np.outer(v, v) + return v -def total_predictive_band( - mean_fn, - kernel, - x_train, - y_train, +def _draw_on_grid( + problem, + c, + space, + chosen, + predictor, x_pred, - draws, - n_model_params, + samples, *, - theta_cols=None, + model_only, + joint, + physical, + n_rep, + rng, + levels, + return_draws, noise_std=0.0, - train_noise_var=None, - levels=(16, 84), - n_draws=400, - rng=None, + condition=None, ): - r"""Data-space predictive band that propagates *total* uncertainty. + """The loop both grid functions share; ``condition(theta, mu)`` returns the + GP posterior ``(mean, v)`` to shift the draw and subtract ``v^T v``.""" + back = _to_physical(space, physical) + x_pred = np.asarray(x_pred) + n_pred = x_pred.shape[0] + cols_pred = problem.columns(predictor.params) + gathers = [(t, problem.columns(t.params)) for t in chosen] + # the prediction points carry the metadata the predictor was bound with + meta_p = ( + None + if predictor.meta is None + else {k: _per_point(v, n_pred) for k, v in predictor.meta.items()} + ) + n = samples.shape[0] + + if model_only: + out = np.empty((n, n_pred)) + for i, theta in enumerate(samples): + out[i] = back(space(predictor(*theta[cols_pred]))) + return out if return_draws else predictive_band(out, levels) + + out = np.empty((n * n_rep, n_pred)) + for i, theta in enumerate(samples): + mu = space(predictor(*theta[cols_pred])) + C = np.zeros((n_pred, n_pred)) + for t, g in gathers: + C += _grid_piece(t, x_pred, mu, meta_p, tuple(theta[g])) + f_mean = 0.0 + if condition is not None: + f_mean, v = condition(theta, mu) + C -= v.T @ v + C[np.diag_indices(n_pred)] += float(noise_std) ** 2 + z = rng.standard_normal((n_rep, n_pred)) + if joint: + z = z @ _psd_factor(0.5 * (C + C.T)).T + else: + z *= np.sqrt(np.clip(np.diag(C), 0.0, None)) + out[i * n_rep : (i + 1) * n_rep] = back(mu + f_mean + z) + return out if return_draws else predictive_band(out, levels) + + +def grid_draws( + problem: Problem, + predictor, + x_pred, + samples, + constraint: int = 0, + *, + comparison=None, + terms=None, + model_only: bool = False, + joint: bool = True, + physical: bool = False, + n_rep: int = 1, + rng=None, + levels=(16, 50, 84), + return_draws: bool = False, +) -> np.ndarray: + r"""Posterior-predictive band, or draws, on a grid the data were not measured on. - For each posterior draw ``q`` it splits out the model parameters and the kernel - log-theta, forms the residual ``y_train - mean_fn(x_train, *model_params)``, - conditions the GP discrepancy at ``x_pred``, and samples + For each posterior row ``theta`` the predictor gives the model on + ``x_pred`` in comparison space, every selected term of the constraint is + evaluated there into one covariance ``C(\theta)``, and ``n_rep`` correlated + draws .. math:: - y_*^{(s)} = \mathrm{mean\_fn}(x_*) + \bar f_*^{(s)} - + \mathcal N\!\big(0,\ \mathrm{var}_*^{(s)} + \sigma^2\big), + y_* = y_m(x_*; \theta) + L(\theta) z, \qquad + L L^T = C(\theta), \quad z \sim \mathcal N(0, I) - returning the requested percentile band over the samples. Only the GP's - posterior *variance* is propagated per point (the off-diagonal posterior - covariance is not used for the marginal band). + are taken. This is the grid counterpart of + :func:`~rxmc.diagnostics.predictive_draws`, and at the measured points, + with every term a function, the two draw from the same distribution. + + A term is carried by evaluating its own definition at the new points, with + the model's prediction standing in for ``c.y`` and the predictor's + ``meta`` for ``c.meta``; so only terms that are functions of the + :class:`~rxmc.terms.TermContext` can be carried. The reported statistical + errors and any array-valued term raise (module docstring). + + Because each draw is a whole correlated curve, a functional summary — a + simultaneous band, an extremum, an integral over a region — is well posed + on ``return_draws=True``. Parameters ---------- - mean_fn : callable - ``mean_fn(x, *model_params) -> y`` on a raw ``x`` array (e.g. a model's - ``.y`` plotting helper). - kernel : sklearn-style kernel - The discrepancy kernel (as passed to :func:`~rxmc.covariance.kernel_term`). - x_train, y_train, x_pred : array-like - Training inputs/outputs and the prediction grid. - draws : array-like, shape (n_samples, n_draw_cols) - Posterior chain rows. - n_model_params : int - Number of leading model parameters in each draw (consumed by ``mean_fn``). - theta_cols : array-like of int, optional - Column indices selecting the kernel log-theta within each draw row, in - ``kernel.theta`` order. When ``None`` (default) the kernel theta is taken - as the trailing columns ``q[n_model_params:]`` and the row width is - validated against ``len(kernel.theta)``. Pass explicit columns when the - draw also carries other covariance/likelihood nuisances. - noise_std : float, optional - Observation noise std-dev, used both to condition the GP and as the - prediction-point noise (overridden for conditioning by - ``train_noise_var`` if given). - train_noise_var : float or array-like, optional - Training-noise covariance for conditioning (defaults to ``noise_std**2``). + problem : Problem + The compiled problem the samples come from. + predictor : Predictor + The model bound to ``x_pred`` (``model.bind(x_pred, meta)``). Its + parameters must be columns of the problem; it need not be the model of + a comparison (a bare physics model under a comparison's correction is + fine). + x_pred : array_like + The prediction grid, in the raw coordinates the terms receive. + samples : array_like, shape (n, problem.ndim) + Rows in ``problem.names`` order: a posterior chain, or + ``problem.sample_prior(n)`` for the prior predictive. + constraint : int, optional + Index into ``problem.constraints`` whose error model is drawn. + comparison : Comparison, optional + The comparison whose experiment the grid stands for: its comparison + space is used, and ``terms=None`` takes only the terms that apply to it. + Required when the constraint holds several comparisons and + ``terms=None``. + terms : sequence of Term, optional + The declared terms a draw carries, matched by identity; ``[]`` carries + none. Default: every term (see ``comparison``), refusing if the + reported statistical errors are among them. + model_only : bool, optional + The model's own curves, with no error model and no covariance built. + joint : bool, optional + Draw whole correlated curves. ``False`` keeps only the diagonal of + ``C`` and draws each point independently, for a very large grid. + physical : bool, optional + Map every draw back through the comparison space's inverse before + taking percentiles (``space=log`` gives a band in physical units). + n_rep : int, optional + Draws per row (ignored when ``model_only``). + rng : numpy.random.Generator or seed, optional levels : sequence of float, optional - Percentile levels for the returned band. - n_draws : int, optional - Number of posterior rows to subsample (if the chain is longer). - rng : np.random.Generator, optional + Percentiles of the band. + return_draws : bool, optional + Return the draws instead of the band. Returns ------- - np.ndarray, shape (len(levels), len(x_pred)) - - Raises - ------ - ValueError - If the kernel-theta selection does not have ``len(kernel.theta)`` columns. + np.ndarray + ``(len(levels), len(x_pred))``; with ``return_draws`` the draws, + ``(n * n_rep, len(x_pred))``, or ``(n, len(x_pred))`` when + ``model_only``. """ - rng = np.random.default_rng() if rng is None else rng - draws = np.asarray(draws, dtype=float) - if draws.shape[0] > n_draws: - draws = draws[rng.choice(draws.shape[0], n_draws, replace=False)] - - n_theta = len(kernel.theta) - if theta_cols is None: - n_trailing = draws.shape[1] - n_model_params - if n_trailing != n_theta: + rng = np.random.default_rng(rng) + samples = _rows(samples, problem.ndim) + c = problem.constraints[constraint] + if comparison is None: + if terms is None and not model_only and len(c.comparisons) > 1: raise ValueError( - f"draws have {n_trailing} columns after the {n_model_params} model " - f"parameters, but the kernel has {n_theta} hyperparameters. Pass " - "theta_cols to select the kernel log-theta columns explicitly." + f"the constraint holds {len(c.comparisons)} comparisons " + f"({c.labels}); pass comparison= to say which experiment the grid " + "stands for, or terms= to choose the terms a draw carries" ) - theta_cols = np.arange(n_model_params, n_model_params + n_theta) + rows = np.arange(c.offsets[-1].stop) else: - theta_cols = np.asarray(theta_cols, dtype=int) - if theta_cols.shape[0] != n_theta: + i = next((k for k, u in enumerate(c.comparisons) if u is comparison), None) + if i is None: raise ValueError( - f"theta_cols selects {theta_cols.shape[0]} columns but the kernel " - f"has {n_theta} hyperparameters." + f"{comparison!r} is not a comparison of constraint {constraint}" ) + rows = np.arange(c.offsets[i].start, c.offsets[i].stop) + space = _one_space(c, rows, hint=_GRID_HINT) + chosen = [] if model_only else _grid_terms(c, terms, rows) + return _draw_on_grid( + problem, c, space, chosen, predictor, x_pred, samples, + model_only=model_only, joint=joint, physical=physical, n_rep=n_rep, + rng=rng, levels=levels, return_draws=return_draws, + ) # fmt: skip + + +def gp_predictive_draws( + problem: Problem, + term: KernelTerm, + predictor, + x_pred, + samples, + *, + terms=None, + conditioned: bool = False, + joint: bool = True, + noise_std: float = 0.0, + train_noise_var=None, + physical: bool = False, + n_rep: int = 1, + rng=None, + levels=(16, 50, 84), + return_draws: bool = False, +) -> np.ndarray: + r"""Grid draws for a Gaussian-process discrepancy, optionally conditioned. + + With ``conditioned=False`` this is :func:`grid_draws` on the constraint + and comparison space the kernel term lives in: correlated departures + about the model's own prediction, which is the predictive that matches a + mean-zero discrepancy (module docstring). ``conditioned=True`` instead + conditions the discrepancy on the residuals of the kernel's training rows, - x_train = np.asarray(x_train, dtype=float) - y_train = np.asarray(y_train, dtype=float) - x_pred = np.asarray(x_pred, dtype=float) - pred_noise_var = float(noise_std) ** 2 - cond_noise = pred_noise_var if train_noise_var is None else train_noise_var - - samples = np.empty((draws.shape[0], x_pred.shape[0])) - for i, q in enumerate(draws): - model_params = q[:n_model_params] - theta = q[theta_cols] - residual = y_train - mean_fn(x_train, *model_params) - disc_mean, disc_var = _gp_posterior_mean_var( - kernel, theta, x_train, residual, x_pred, train_noise_var=cond_noise + .. math:: + + y_* = y_m(x_*; \theta) + \bar f_* + L(\theta) z, \qquad + L L^T = C(\theta) - K_{*t}(K_{tt} + N)^{-1}K_{t*} + \sigma^2 I + + with ``\bar f_* = K_{*t}(K_{tt} + N)^{-1} r``: GP regression on top of + the model, which interpolates the residuals. + + Parameters + ---------- + problem : Problem + The compiled problem the chain was sampled from. + term : KernelTerm + The discrepancy term, as declared in one of the problem's constraints. + predictor : Predictor + The model bound to ``x_pred`` (``model.bind(x_pred, meta)``); the + ``meta`` it was bound with is what a callable amplitude's + ``c.meta(key)`` reads at ``x_pred``. + x_pred : array_like + The prediction grid (raw coordinates; the term's ``coords`` transform + is applied for the kernel). + samples : array_like, shape (n, problem.ndim) + Chain rows in ``problem.names`` order. + terms : sequence of Term, optional + The terms a draw carries, including ``term`` itself. Default: every + term of the constraint that meets the kernel's rows, under the rules + of :func:`grid_draws`. ``[term]`` alone gives model plus discrepancy; + adding the experimental terms gives what data is compared against. + A selected term applies to the whole of ``x_pred``. + conditioned : bool, optional + Condition the discrepancy on the observed residuals instead of drawing + it mean-zero. Default ``False``. + joint : bool, optional + Draw whole correlated curves; ``False`` draws each point independently. + noise_std : float, optional + Extra observation noise at the prediction points, in comparison space. + train_noise_var : float, array_like or matrix, optional + Conditioning noise on the training rows; ``conditioned=True`` only. + Default: everything in the constraint's covariance at those rows + *except* the kernel term itself, which is the exact GP regression noise + for the declared error model. + physical : bool, optional + Map every draw back through the comparison space's inverse. + n_rep : int, optional + Draws per chain row. + rng : numpy.random.Generator or seed, optional + levels : sequence of float, optional + Percentiles of the band. + return_draws : bool, optional + Return the ``(n * n_rep, len(x_pred))`` draws instead of the band. + + Returns + ------- + np.ndarray + ``(len(levels), len(x_pred))``, or the draws when ``return_draws``. + """ + rng = np.random.default_rng(rng) + samples = _rows(samples, problem.ndim) + if train_noise_var is not None and not conditioned: + raise ValueError( + "train_noise_var is the noise the GP regression conditions on and " + "applies only with conditioned=True" ) - disc_var = np.clip(disc_var, 0.0, np.inf) - mu = mean_fn(x_pred, *model_params) + disc_mean - samples[i] = mu + rng.normal(0.0, np.sqrt(disc_var + pred_noise_var)) + c, entry = _locate(problem, term) + rows = entry.rows + keep = entry.keep # the active rows of the term's support + pos = entry.pos[keep] # their positions in the active stack + space = _one_space(c, rows, hint=_GRID_HINT) + chosen = _grid_terms(c, terms, rows) + if not any(t is term for t in chosen): + raise ValueError( + "terms= must include the kernel term: it is the discrepancy these " + "draws predict" + ) + cols_term = problem.columns(term.params) + nk, n_fn = term.n_kernel, term._n_fn_params + x_pred = np.asarray(x_pred) + meta = None if c.meta is None else {k: v[rows] for k, v in c.meta.items()} + meta_p = ( + None + if predictor.meta is None + else {k: _per_point(v, x_pred.shape[0]) for k, v in predictor.meta.items()} + ) - return predictive_band(samples, levels) + def condition(theta, mu): + values = tuple(theta[cols_term]) + ym = c.ym(theta) + # the term's own block on its rows, exactly as the likelihood saw it + K_full = term.value( + c.x[rows], c.y[rows], ym[rows], *values, + meta=meta, segments=entry.segments, labels=entry.labels, + ) # fmt: skip + Ktt = np.asarray(K_full)[np.ix_(keep, keep)] + r = (c.y - ym)[rows][keep] + if train_noise_var is None: + N = c.matrix(theta)[np.ix_(pos, pos)] - Ktt + else: + N = _train_noise_matrix(train_noise_var, len(r)) + # kernel and amplitude at the training and prediction coordinates + k = term.build(*values[:nk]) + ctx_t = term.context( + c.x[rows], c.y[rows], ym[rows], meta, *values, + segments=entry.segments, labels=entry.labels, + ) # fmt: skip + ctx_p = TermContext( + x=term.coords(x_pred, *values[n_fn:]), y=mu, ym=mu, _meta=meta_p + ) + a_t, a_p = _amplitudes(term, ctx_t, ctx_p, values[nk:n_fn]) + Kst = np.outer(a_p, a_t[keep]) * np.asarray( + k(as_2d(ctx_p.x), as_2d(ctx_t.x)[keep]) + ) + return _condition(Ktt, Kst, r, N, 0.0) + + return _draw_on_grid( + problem, c, space, chosen, predictor, x_pred, samples, + model_only=False, joint=joint, physical=physical, n_rep=n_rep, rng=rng, + levels=levels, return_draws=return_draws, noise_std=noise_std, + condition=condition if conditioned else None, + ) # fmt: skip + + +def _amplitudes(term, ctx_t, ctx_p, values): + a = term.amplitude + if a is None: + return np.ones(len(ctx_t)), np.ones(len(ctx_p)) + if callable(a): + return ( + np.broadcast_to(np.asarray(a(ctx_t, *values), dtype=float), (len(ctx_t),)), + np.broadcast_to(np.asarray(a(ctx_p, *values), dtype=float), (len(ctx_p),)), + ) + a = np.asarray(a, dtype=float) + if a.ndim == 0: + return np.full(len(ctx_t), float(a)), np.full(len(ctx_p), float(a)) + raise ValueError( + "a kernel amplitude given as an array is defined only on the training " + "rows; use a callable amplitude(c, ...) to predict at new points" + ) diff --git a/src/rxmc/priors.py b/src/rxmc/priors.py deleted file mode 100644 index d7dbb99..0000000 --- a/src/rxmc/priors.py +++ /dev/null @@ -1,304 +0,0 @@ -""" -Built-in prior distribution classes for use with ``ParameterConfig``. - -These classes satisfy the generic prior protocol expected by ``ParameterConfig`` -and ``CalibrationConfig``: they expose ``logpdf(x)`` and ``rvs(n)`` methods -with consistent array conventions. Any user-defined class that provides the -same two methods can be passed directly to ``ParameterConfig``. - -Available classes ------------------ -:class:`IndependentPrior` - Wraps an arbitrary list of ``scipy.stats`` frozen distributions. The - preferred way to combine per-parameter marginals into a joint prior. - -:class:`TruncatedNormalPrior` - Convenience class for the common case of independent truncated normals. - -Dynesty / nested-sampling support ----------------------------------- -When using a nested sampler (e.g. Dynesty) the sampler requires a -*prior transform* that maps unit-cube coordinates to physical parameters. -Prior classes that support this should implement:: - - def prior_transform(self, u: ndarray) -> ndarray - -where ``u`` has shape ``(ndim,)`` with each element in ``[0, 1)`` and the -return value is the corresponding physical parameter vector. Both -:class:`IndependentPrior` and :class:`TruncatedNormalPrior` provide this -method via the ``ppf`` of each marginal distribution; they clip ``u`` into -the open unit cube first (:func:`clip_unit_cube`) so an exact ``0`` or ``1`` -never yields ``±inf``. -""" - -import numpy as np -from scipy import stats - - -def clip_unit_cube(u) -> np.ndarray: - """Coerce ``u`` to a float array clipped into the open unit cube. - - Exact ``0.0`` / ``1.0`` map to ``±inf`` under an unbounded marginal's - ``ppf``; clipping to ``[eps, 1 - eps]`` keeps every ``prior_transform`` - finite. Shared by every prior transform in the package. - """ - u = np.asarray(u, dtype=float) - eps = np.finfo(float).eps - return np.clip(u, eps, 1.0 - eps) - - -def as_prior(prior): - """Coerce a list/tuple of frozen univariate distributions to an - :class:`IndependentPrior`; any other prior object is returned unchanged. - - The single place where the "list of marginals" form is accepted, so - :class:`~rxmc.config.ParameterConfig` and - :class:`~rxmc.param_sampling.Sampler` agree on it. - """ - if isinstance(prior, (list, tuple)): - return IndependentPrior(list(prior)) - return prior - - -class TruncatedNormalPrior: - """Independent truncated-normal prior for a vector of parameters. - - Each component ``j`` follows:: - - theta_j ~ Normal(mu_j, sigma_j), truncated to [lower_j, upper_j] - - The components are treated as independent, so the joint log-density is the - sum of the marginal log-densities. - - Parameters - ---------- - mu : array-like, shape (ndim,) - Mean of the untruncated normal for each component. - sigma : array-like, shape (ndim,) - Standard deviation of the untruncated normal for each component. - lower : array-like, shape (ndim,) - Lower truncation bound for each component. - upper : array-like, shape (ndim,) - Upper truncation bound for each component. - seed : int, optional - Seed for the internal random-number generator used in :meth:`rvs`. - Default is ``123``. - """ - - def __init__(self, mu, sigma, lower, upper, seed=123): - self.mu = np.asarray(mu, dtype=float) - self.sigma = np.asarray(sigma, dtype=float) - self.lower = np.asarray(lower, dtype=float) - self.upper = np.asarray(upper, dtype=float) - self.dim = len(self.mu) - self.rng = np.random.default_rng(seed) - - self.a = (self.lower - self.mu) / self.sigma - self.b = (self.upper - self.mu) / self.sigma - - def logpdf(self, theta): - """Evaluate the joint log prior density. - - Parameters - ---------- - theta : array-like - Parameter vector of shape ``(ndim,)`` for a single evaluation, or - ``(n, ndim)`` for a batch of ``n`` vectors. - - Returns - ------- - float or ndarray - Scalar log-density when ``theta`` has shape ``(ndim,)``; - array of shape ``(n,)`` when ``theta`` has shape ``(n, ndim)``. - - Raises - ------ - ValueError - If the trailing dimension of ``theta`` does not equal ``self.dim``. - """ - theta = np.asarray(theta, dtype=float) - squeeze = theta.ndim == 1 - theta = np.atleast_2d(theta) - - if theta.shape[1] != self.dim: - raise ValueError( - f"Expected theta with {self.dim} columns, got {theta.shape[1]}" - ) - - logp = np.zeros(theta.shape[0]) - for j in range(self.dim): - logp += stats.truncnorm.logpdf( - theta[:, j], - a=self.a[j], - b=self.b[j], - loc=self.mu[j], - scale=self.sigma[j], - ) - - return float(logp[0]) if squeeze else logp - - def rvs(self, n): - """Draw ``n`` independent samples from the prior. - - Parameters - ---------- - n : int - Number of samples to draw. - - Returns - ------- - ndarray, shape (n, ndim) - Matrix of samples, one row per draw. - """ - out = np.zeros((n, self.dim)) - for j in range(self.dim): - out[:, j] = stats.truncnorm.rvs( - a=self.a[j], - b=self.b[j], - loc=self.mu[j], - scale=self.sigma[j], - size=n, - random_state=self.rng, - ) - return out - - def prior_transform(self, u): - """Map unit-cube coordinates to physical parameters (Dynesty interface). - - Parameters - ---------- - u : array-like, shape (ndim,) - Unit-cube coordinates, each in ``[0, 1)``. - - Returns - ------- - ndarray, shape (ndim,) - Physical parameter vector obtained by applying the component-wise - percent-point function of each truncated normal. - """ - u = clip_unit_cube(u) - theta = np.empty_like(u) - for j in range(self.dim): - theta[j] = stats.truncnorm.ppf( - u[j], - a=self.a[j], - b=self.b[j], - loc=self.mu[j], - scale=self.sigma[j], - ) - return theta - - -class IndependentPrior: - """Independent prior built from an arbitrary list of ``scipy.stats`` distributions. - - Each parameter component ``j`` is modelled by the corresponding frozen - distribution ``distributions[j]``. The components are treated as - independent, so the joint log-density is the sum of the marginal - log-densities, and sampling draws from each marginal separately. - - This class satisfies the generic prior protocol required by - :class:`~rxmc.config.ParameterConfig`: it exposes ``logpdf``, ``rvs``, - and ``prior_transform``, and carries a ``dim`` attribute used for - automatic dimension validation. - - Parameters - ---------- - distributions : list of frozen scipy.stats distributions - One distribution per parameter component. Any frozen univariate - ``scipy.stats`` distribution works (e.g. ``stats.norm(0, 1)``, - ``stats.uniform(0, 5)``, ``stats.truncnorm(...)``). - seed : int, optional - Seed for the internal :class:`numpy.random.Generator` used in - :meth:`rvs` to ensure reproducibility. Default is ``123``. - - Examples - -------- - >>> from scipy import stats - >>> from rxmc.priors import IndependentPrior - >>> prior = IndependentPrior([stats.norm(0, 1), stats.uniform(0, 5)]) - >>> prior.dim - 2 - >>> prior.rvs(4).shape - (4, 2) - """ - - def __init__(self, distributions: list, seed: int = 123): - self.distributions = distributions - self.dim = len(distributions) - self.rng = np.random.default_rng(seed) - - def logpdf(self, theta): - """Evaluate the joint log prior density. - - Parameters - ---------- - theta : array-like - Parameter vector of shape ``(ndim,)`` for a single evaluation, or - ``(n, ndim)`` for a batch of ``n`` vectors. - - Returns - ------- - float or ndarray - Scalar log-density when ``theta`` has shape ``(ndim,)``; - array of shape ``(n,)`` when ``theta`` has shape ``(n, ndim)``. - - Raises - ------ - ValueError - If the trailing dimension of ``theta`` does not equal ``self.dim``. - """ - theta = np.asarray(theta, dtype=float) - squeeze = theta.ndim == 1 - theta = np.atleast_2d(theta) - - if theta.shape[1] != self.dim: - raise ValueError( - f"Expected theta with {self.dim} columns, got {theta.shape[1]}" - ) - - logp = np.zeros(theta.shape[0]) - for j, dist in enumerate(self.distributions): - logp += dist.logpdf(theta[:, j]) - - return float(logp[0]) if squeeze else logp - - def rvs(self, n: int) -> np.ndarray: - """Draw ``n`` independent samples from the prior. - - Parameters - ---------- - n : int - Number of samples to draw. - - Returns - ------- - ndarray, shape (n, ndim) - Matrix of samples, one row per draw. - """ - out = np.zeros((n, self.dim)) - for j, dist in enumerate(self.distributions): - out[:, j] = dist.rvs(size=n, random_state=self.rng) - return out - - def prior_transform(self, u) -> np.ndarray: - """Map unit-cube coordinates to physical parameters (Dynesty interface). - - Applies the percent-point function (inverse CDF) of each marginal - distribution component-wise. - - Parameters - ---------- - u : array-like, shape (ndim,) - Unit-cube coordinates, each in ``[0, 1)``. - - Returns - ------- - ndarray, shape (ndim,) - Physical parameter vector. - """ - u = clip_unit_cube(u) - theta = np.empty_like(u) - for j, dist in enumerate(self.distributions): - theta[j] = dist.ppf(u[j]) - return theta diff --git a/src/rxmc/problem.py b/src/rxmc/problem.py new file mode 100644 index 0000000..c046cff --- /dev/null +++ b/src/rxmc/problem.py @@ -0,0 +1,1075 @@ +""" +The compile step: from declarations to the flat interface a sampler wants. + +:class:`Problem` is the only place in the package that walks the parameter +graph. It assigns every distinct :class:`~rxmc.params.Parameter` a slot in +first-seen order (each constraint's predictors, then its terms), checks +that names are unique, resolves every term's ``on`` to rows, factors the +constant parts of every covariance, and assembles the prior so that every +slot is covered exactly once. The result exposes what emcee, dynesty and ``black-box-bayes`` need: ``ndim``, ``names``, +``log_prior``, ``log_likelihood``, ``log_posterior``, ``prior_transform`` and +``sample_prior``, and what a gradient-based sampler or optimiser needs: +``grad_log_posterior``, ``value_and_grad_log_posterior`` and +``hessian_log_posterior``. ``log_posterior_unconstrained`` is the same +density on ``R^ndim`` (bounded parameters mapped through ``log`` or +``logit``; ``to_theta`` and ``to_unconstrained`` convert), for HMC/NUTS, +whose trajectories cannot cross the ``-inf`` wall at a bound. + +The densities are written in ``jax.numpy`` and compiled with ``jax.jit`` once +per problem, so ``jax.grad``, ``jax.hessian`` and ``jax.vmap`` work through +``log_posterior`` and everything under it: the models, the covariance terms, +the likelihood and the prior. Called on a concrete ``theta`` the densities +return a Python ``float`` (what emcee, dynesty and scipy expect); under a JAX +transformation they return the traced value. ``prior_transform`` and +``sample_prior`` are not differentiated and stay numpy/scipy. + +Prior rules, per slot (see :class:`~rxmc.params.Parameter`): + +* ``Parameter(prior=dist)``: the marginal, truncated to ``bounds``; +* finite ``bounds`` and no ``prior``: uniform on the bounds; +* neither: the parameter must appear in exactly one joint block passed as + ``priors=[(params, joint), ...]``, where ``joint`` exposes + ``logpdf(values)`` over ``params`` in that order and, optionally, + ``prior_transform(u)`` and ``rvs(size=n, random_state=rng)`` (scipy's + spelling). A joint that declares its dimension (``dim``, as scipy's + multivariate distributions do) must match its parameters. A frozen + ``scipy.stats.multivariate_normal`` gets a whitening unit-cube map for + free, and a one-parameter block holding a scipy univariate distribution is + that parameter's marginal. Finite bounds truncate a joint: a frozen MVN is + renormalised by its mass inside them, while a custom joint's ``logpdf`` must + already be normalised on its truncated support. A hyperprior is a joint + block that includes its hyperparameter. + +The log density of a prior is evaluated in ``jax.numpy``. A frozen scipy +marginal is translated to an equivalent JAX density for the families in +:data:`JAX_LOGPDFS`; any other marginal needs its density written in +``jax.numpy`` as ``Parameter(logpdf=...)``. A custom joint's ``logpdf`` must +be written in ``jax.numpy``; a frozen multivariate normal is translated. + +Nothing user-facing is mutated by compiling. Compile the same declarations +twice and you get two independent problems. +""" + +from __future__ import annotations + +import warnings +from typing import Any, Iterable, Sequence + +import jax +import jax.numpy as jnp +import jax.scipy.stats as jst +import numpy as np +from scipy import stats +from scipy.stats.distributions import rv_frozen + +from .constraint import Constraint +from .covariance import StructuredCovariance +from .params import Parameter +from .terms import statistical + +__all__ = [ + "Problem", + "ParameterIndex", + "CompiledConstraint", + "clip_unit_cube", + "JAX_LOGPDFS", +] + + +def clip_unit_cube(u) -> np.ndarray: + """``u`` as a float array clipped into the open unit cube. + + Exact ``0.0`` / ``1.0`` map to ``±inf`` under an unbounded marginal's + ``ppf``; clipping to ``[eps, 1 - eps]`` keeps every ``prior_transform`` + finite. + """ + u = np.asarray(u, dtype=float) + eps = np.finfo(float).eps + return np.clip(u, eps, 1.0 - eps) + + +# ---------------------------------------------------------------------------- +# The index +# ---------------------------------------------------------------------------- + + +class ParameterIndex: + """Unique parameters in first-seen order, each with a slot.""" + + def __init__(self): + self._slot: dict[Parameter, int] = {} + self._params: list[Parameter] = [] + + def add_all(self, params: Iterable[Parameter]) -> np.ndarray: + """Register ``params`` and return their gather array (slots in order).""" + out = [] + for p in params: + if not isinstance(p, Parameter): + raise TypeError(f"expected a Parameter, got {p!r}") + if p not in self._slot: + self._slot[p] = len(self._params) + self._params.append(p) + out.append(self._slot[p]) + return np.asarray(out, dtype=int) + + def slot(self, p: Parameter) -> int: + try: + return self._slot[p] + except KeyError: + raise KeyError(f"{p!r} is not a parameter of this problem") from None + + def slots(self, params) -> np.ndarray: + if isinstance(params, Parameter): + return np.asarray([self.slot(params)], dtype=int) + return np.asarray([self.slot(p) for p in params], dtype=int) + + @property + def params(self) -> tuple[Parameter, ...]: + return tuple(self._params) + + @property + def names(self) -> list[str]: + return [p.name for p in self._params] + + @property + def bounds(self) -> np.ndarray: + return np.asarray([p.bounds for p in self._params], dtype=float).reshape(-1, 2) + + @property + def ndim(self) -> int: + return len(self._params) + + def check_names_unique(self) -> None: + seen, dup = {}, [] + for p in self._params: + if p.name in seen: + dup.append(p.name) + seen[p.name] = p + if dup: + raise ValueError( + f"duplicate parameter name(s) {sorted(set(dup))}: distinct Parameter " + "objects with one name would become two chain columns with the same " + "label. Pass the SAME object everywhere the value is shared, or " + "name them apart (prefix= of kernel_params)." + ) + + +# ---------------------------------------------------------------------------- +# The prior +# ---------------------------------------------------------------------------- + + +def _host(x): + """``x`` itself under a JAX transformation; otherwise numpy (a ``float`` when + 0-d), so samplers and user code get plain values.""" + if isinstance(x, jax.core.Tracer): + return x + x = np.asarray(x) + return float(x) if x.ndim == 0 else x + + +def _std_uniform(z): + return jnp.where((z >= 0) & (z <= 1), 0.0, -jnp.inf) + + +def _std_lognorm(z, s): + pos = z > 0 + zs = jnp.where(pos, z, 1.0) + out = -jnp.log(zs * s * jnp.sqrt(2 * jnp.pi)) - jnp.log(zs) ** 2 / (2 * s**2) + return jnp.where(pos, out, -jnp.inf) + + +def _std_halfnorm(z): + return jnp.where(z >= 0, jnp.log(2.0) + jst.norm.logpdf(z), -jnp.inf) + + +def _std_halfcauchy(z): + return jnp.where(z >= 0, jnp.log(2.0) + jst.cauchy.logpdf(z), -jnp.inf) + + +def _std_truncnorm(z, a, b): + log_mass = jnp.log(jax.scipy.special.ndtr(b) - jax.scipy.special.ndtr(a)) + return jnp.where((z >= a) & (z <= b), jst.norm.logpdf(z) - log_mass, -jnp.inf) + + +def _std_invgamma(z, a): + pos = z > 0 + zs = jnp.where(pos, z, 1.0) + out = -jax.scipy.special.gammaln(a) - (a + 1) * jnp.log(zs) - 1.0 / zs + return jnp.where(pos, out, -jnp.inf) + + +#: rows per vmapped call of the batch densities: a reaction model holds every +#: row's partial-wave solutions at once (a few MB a row), so a large batch is +#: evaluated in chunks of this size +BATCH_CHUNK = 256 + +#: scipy family name -> standardised JAX log density ``f(z, *shapes)`` with +#: ``z = (x - loc) / scale``. +JAX_LOGPDFS = { + "norm": jst.norm.logpdf, + "uniform": _std_uniform, + "gamma": jst.gamma.logpdf, + "beta": jst.beta.logpdf, + "lognorm": _std_lognorm, + "halfnorm": _std_halfnorm, + "cauchy": jst.cauchy.logpdf, + "halfcauchy": _std_halfcauchy, + "t": jst.t.logpdf, + "expon": jst.expon.logpdf, + "laplace": jst.laplace.logpdf, + "logistic": jst.logistic.logpdf, + "invgamma": _std_invgamma, + "truncnorm": _std_truncnorm, +} + + +def _jax_logpdf(dist, name): + """A JAX log density equal to a frozen scipy univariate's ``logpdf``.""" + family = getattr(getattr(dist, "dist", None), "name", None) + if family not in JAX_LOGPDFS: + raise TypeError( + f"the prior of {name!r} ({family or type(dist).__name__}) has no JAX " + f"translation; supported scipy families are {sorted(JAX_LOGPDFS)}. " + "Give the parameter its density in jax.numpy as " + "Parameter(..., logpdf=f), or cover it with a joint block whose " + "logpdf is written in jax.numpy" + ) + shapes, loc, scale = dist.dist._parse_args(*dist.args, **dist.kwds) + f, shapes = JAX_LOGPDFS[family], tuple(float(a) for a in shapes) + loc, scale = float(loc), float(scale) + log_scale = np.log(scale) + return lambda x: f((x - loc) / scale, *shapes) - log_scale + + +def _is_frozen_mvn(joint) -> bool: + return type(joint).__name__ == "multivariate_normal_frozen" + + +def _joint_dim(joint) -> int | None: + """The dimension a joint declares, or ``None`` when it declares none.""" + if isinstance(joint, rv_frozen): + return 1 + dim = getattr(joint, "dim", None) + return None if dim is None else int(dim) + + +class _Marginal: + """One slot: a marginal (truncated to bounds) or the uniform on bounds. + + ``dist`` overrides ``p.prior``: a one-parameter prior block's distribution. + """ + + def __init__(self, p: Parameter, slot: int, dist=None): + self.p, self.slot = p, slot + lo, hi = p.bounds + self.lo, self.hi = lo, hi + self.dist = p.prior if dist is None else dist + self.bounded = np.isfinite(lo) and np.isfinite(hi) + self.upper = False + if self.dist is None: + if not self.bounded: + raise ValueError( + f"parameter {p.name!r} has no prior: give it prior=, finite " + "bounds, or cover it with a joint block in Problem(priors=)" + ) + self.c_lo, self.c_hi = 0.0, 1.0 + self.log_norm = np.log(hi - lo) + else: + # far in the upper tail cdf(lo) rounds to 1: work in the survival + # function there, so the mass and the unit-cube map keep their precision + self.upper = bool(np.isfinite(lo) and self.dist.cdf(lo) > 0.5) + cdf, at_inf = (self.dist.sf, 0.0) if self.upper else (self.dist.cdf, 1.0) + self.c_lo = float(cdf(lo)) if np.isfinite(lo) else 0.0 + self.c_hi = float(cdf(hi)) if np.isfinite(hi) else at_inf + mass = abs(self.c_hi - self.c_lo) + if not mass > 0: + raise ValueError( + f"the prior of {p.name!r} has no mass inside its bounds" + ) + self.log_norm = float(np.log(mass)) + # the JAX density, and a point inside the support at which it is + # evaluated when v is outside (so the discarded branch of the where + # has a finite gradient) + if self.dist is None: + self._logpdf = None + elif p.logpdf is not None: + self._logpdf = p.logpdf + else: + self._logpdf = _jax_logpdf(self.dist, p.name) + self.safe = float(self.transform(0.5)) + + def logpdf(self, v): + inside = (v >= self.lo) & (v <= self.hi) + if self._logpdf is None: + return jnp.where(inside, -self.log_norm, -jnp.inf) + lp = self._logpdf(jnp.where(inside, v, self.safe)) - self.log_norm + return jnp.where(inside, lp, -jnp.inf) + + def transform(self, u): + if self.dist is None: + return self.lo + u * (self.hi - self.lo) + inverse = self.dist.isf if self.upper else self.dist.ppf + # clipped: the inverse can round a hair outside the bounds at u ~ 0 or 1 + return np.clip( + inverse(self.c_lo + u * (self.c_hi - self.c_lo)), self.lo, self.hi + ) + + +class _Joint: + """A joint block over several slots.""" + + def __init__(self, params: Sequence[Parameter], joint, slots: np.ndarray): + self.params, self.joint, self.slots = tuple(params), joint, slots + self.bounds = np.asarray([p.bounds for p in self.params], dtype=float) + self.bounded = bool(np.any(np.isfinite(self.bounds))) + # a point inside the bounds, at which the density is evaluated when the + # values are outside (so the discarded branch has a finite gradient) + lo, hi = self.bounds.T + self.safe = np.clip(0.0, lo + 1.0, hi - 1.0) + both = np.isfinite(lo) & np.isfinite(hi) + self.safe[both] = 0.5 * (lo[both] + hi[both]) + self.names = [p.name for p in self.params] + if not hasattr(joint, "logpdf"): + raise TypeError(f"joint prior over {self.names} must have logpdf(values)") + dim = _joint_dim(joint) + if dim is not None and dim != len(self.params): + raise ValueError( + f"the joint prior over {self.names} is {dim}-dimensional; it must " + f"cover exactly those {len(self.params)} parameter(s), in order" + ) + if _is_frozen_mvn(joint): + self._L = np.linalg.cholesky(np.atleast_2d(joint.cov)) + self._mean = np.atleast_1d(joint.mean) + mean, cov = jnp.asarray(self._mean), jnp.asarray(np.atleast_2d(joint.cov)) + self._logpdf = lambda v: jst.multivariate_normal.logpdf(v, mean, cov) + else: + self._L = None + self._logpdf = joint.logpdf + _check_traceable(self._logpdf, len(self.params), self.names) + # a truncated MVN is renormalised by its mass inside the bounds; the box + # probability is quasi-Monte Carlo from 3 dimensions, so it is seeded + self.log_mass = 0.0 + if self.bounded and _is_frozen_mvn(joint): + box = stats.multivariate_normal(joint.mean, joint.cov, seed=0) + mass = float(box.cdf(self.bounds[:, 1], lower_limit=self.bounds[:, 0])) + if not mass > 0: + raise ValueError( + f"the joint prior over {self.names} has no mass inside its bounds" + ) + self.log_mass = float(np.log(mass)) + + @property + def has_transform(self) -> bool: + return not self.bounded and ( + self._L is not None or hasattr(self.joint, "prior_transform") + ) + + def logpdf(self, values): + inside = jnp.all((values >= self.bounds[:, 0]) & (values <= self.bounds[:, 1])) + # reshape(()): a length-1 result is fine, a longer one (a mis-sized + # joint) is not + lp = self._logpdf(jnp.where(inside, values, self.safe)) + lp = jnp.reshape(lp, ()) - self.log_mass + return jnp.where(inside, lp, -jnp.inf) if self.bounded else lp + + def transform(self, u): + if self.bounded: + raise NotImplementedError( + f"the joint prior over {self.names} is truncated by bounds and has no " + "unit-cube map; drop the bounds or use a sampler that needs only " + "log_posterior" + ) + if self._L is not None: # rows of u: (..., k) @ (k, k) + return self._mean + stats.norm.ppf(u) @ self._L.T + if hasattr(self.joint, "prior_transform"): # one point at a time + if u.ndim == 1: + return np.asarray(self.joint.prior_transform(u), dtype=float) + return np.array([self.joint.prior_transform(row) for row in u], dtype=float) + raise NotImplementedError( + f"the joint prior over {self.names} has no prior_transform(u); give it " + "one, or use a sampler that needs only log_posterior" + ) + + def sample(self, n, rng): + if self.has_transform: + return np.asarray( + [self.transform(rng.uniform(size=len(self.params))) for _ in range(n)] + ) + if not hasattr(self.joint, "rvs"): + raise NotImplementedError( + f"the joint prior over {self.names} has neither prior_transform nor rvs" + ) + draws = np.empty((0, len(self.params))) + for _ in range(1000): + d = np.atleast_2d( + np.asarray(self.joint.rvs(size=n, random_state=rng), dtype=float) + ) + if d.shape[1] != len(self.params): + d = d.reshape(-1, len(self.params)) + if self.bounded: + ok = np.all((d >= self.bounds[:, 0]) & (d <= self.bounds[:, 1]), axis=1) + d = d[ok] + draws = np.vstack([draws, d]) + if len(draws) >= n: + return draws[:n] + raise RuntimeError( + f"could not draw from the joint prior over {self.names} inside its bounds" + ) + + +def _check_traceable(logpdf, n, names): + """Fail at compile, by name, when a joint's ``logpdf`` is not jax.numpy.""" + try: + jax.eval_shape(logpdf, jax.ShapeDtypeStruct((n,), jnp.float64)) + except Exception as err: # any tracing failure: a numpy/scipy logpdf + raise TypeError( + f"the joint prior over {names} has a logpdf that JAX cannot trace " + f"({type(err).__name__}: {err}); write it with jax.numpy and " + "jax.scipy.stats so the posterior can be differentiated" + ) from None + + +class _Prior: + def __init__(self, index: ParameterIndex, priors): + self.ndim = index.ndim + self.joints: list[_Joint] = [] + covered: set[Parameter] = set() + univariate: dict[Parameter, Any] = {} + for entry in priors: + try: + params, joint = entry + except (TypeError, ValueError): + raise TypeError( + "priors= must be a sequence of (params, joint) pairs" + ) from None + params = [params] if isinstance(params, Parameter) else list(params) + for p in params: + if p.prior is not None: + raise ValueError( + f"parameter {p.name!r} has its own prior= and is also covered " + "by a joint block: cover it once" + ) + if p in covered: + raise ValueError( + f"parameter {p.name!r} appears in two joint blocks" + ) + covered.add(p) + if len(params) == 1 and isinstance(joint, rv_frozen): + # a scipy univariate over one parameter is that parameter's + # marginal: truncated to its bounds, with a ppf unit-cube map + univariate[params[0]] = joint + else: + self.joints.append(_Joint(params, joint, index.slots(params))) + self.marginals = [ + _Marginal(p, i, univariate.get(p)) + for i, p in enumerate(index.params) + if p not in covered or p in univariate + ] + + def logpdf(self, theta): + total = 0.0 + for m in self.marginals: + total = total + m.logpdf(theta[m.slot]) + for j in self.joints: + total = total + j.logpdf(theta[j.slots]) + return jnp.asarray(total) + + def transform(self, u) -> np.ndarray: + """``u`` of shape ``(ndim,)`` or ``(n, ndim)`` to ``theta`` alike.""" + u = clip_unit_cube(u) + theta = np.empty(u.shape) + for m in self.marginals: + theta[..., m.slot] = m.transform(u[..., m.slot]) + for j in self.joints: + theta[..., j.slots] = j.transform(u[..., j.slots]) + return theta + + def sample(self, n, rng) -> np.ndarray: + out = np.empty((n, self.ndim)) + u = rng.uniform(size=(n, self.ndim)) + for m in self.marginals: + out[:, m.slot] = m.transform(clip_unit_cube(u[:, m.slot])) + for j in self.joints: + out[:, j.slots] = j.sample(n, rng) + return out + + +# ---------------------------------------------------------------------------- +# The compiled constraint +# ---------------------------------------------------------------------------- + + +def _per_point(v, n) -> np.ndarray: + """A metadata value as one entry per point: a length-``n`` sequence as is, + anything else (a scalar, a 0-d array, a provenance tuple, an object) + repeated ``n`` times.""" + if isinstance(v, (np.ndarray, np.generic)) and v.ndim == 0: + v = v.item() + if np.isscalar(v): + return np.full(n, v) + try: + arr = np.asarray(v) + except ValueError: # ragged: not per-point + arr = None + if arr is not None and arr.ndim >= 1 and arr.shape[0] == n: + return arr + out = np.empty(n, dtype=object) + for i in range(n): # element by element: numpy would broadcast a sequence + out[i] = v + return out + + +def _stack_meta(constraint: Constraint) -> dict | None: + keys = set() + for c in constraint.comparisons: + keys |= set(c.data.meta) + if not keys: + return None + meta = {} + for key in keys: + parts = [_per_point(c.data.meta.get(key), c.n) for c in constraint.comparisons] + try: + stacked = np.concatenate(parts) + except (TypeError, ValueError): + stacked = np.concatenate([np.asarray(p, dtype=object) for p in parts]) + meta[key] = stacked + return meta + + +class CompiledConstraint: + """A :class:`~rxmc.constraint.Constraint` with slots resolved and its + covariance factored. Built by :class:`Problem`; not constructed by users.""" + + def __init__(self, constraint: Constraint, index: ParameterIndex): + self.source = constraint + comps = constraint.comparisons + self.comparisons = comps + self.labels = [c.data.label or f"comparison {i}" for i, c in enumerate(comps)] + self.offsets = constraint.offsets + self.active = constraint.active + self.n_active = constraint.n_active + self.weight = constraint.weight + self.likelihood = constraint.likelihood + self.log_jacobian = constraint.log_jacobian + try: + self.x = np.concatenate([np.asarray(c.data.x) for c in comps]) + except ValueError as err: + raise ValueError( + f"the comparisons {self.labels} have x grids that cannot be stacked " + f"({err}); put them in separate constraints" + ) from None + self.y = np.concatenate([c.y for c in comps]) + self.y_err = np.concatenate([c.y_err for c in comps]) + for i, (c, o) in enumerate(zip(comps, self.offsets)): + rows = self.active[(self.active >= o.start) & (self.active < o.stop)] + bad = ~(np.isfinite(self.y[rows]) & np.isfinite(self.y_err[rows])) + if np.any(bad): + raise ValueError( + f"comparison {self.labels[i]!r}: space {c.space.name!r} is not " + f"finite at {int(bad.sum())} active data point(s) (e.g. " + "non-positive y under a log transform); mask or drop those points" + ) + self.meta = _stack_meta(constraint) + self.predictors = [ + (o, index.add_all(c.predictor.params), c) + for o, c in zip(self.offsets, comps) + ] + # the reported statistical diagonals are built here, not by the user, so + # a term selection names them with statistical=True rather than by object + self.statistical_terms = ( + [statistical(c.y_err, on=c) for c in comps] + if constraint.statistical + else [] + ) + terms = self.statistical_terms + list(constraint.terms) + entries = [ + (t, constraint.support(t.on), index.add_all(t.params)) for t in terms + ] + self.covariance = StructuredCovariance( + entries, + self.x, + self.y, + self.offsets, + self.active, + meta=self.meta, + labels=self.labels, + ) + + def __getstate__(self): + state = self.__dict__.copy() + state.pop("_jit_cache", None) + return state + + def _jitted(self, key, fn): + """``jax.jit(fn)``, built once per key (the diagnostics call ``ym`` and + ``matrix`` per posterior sample).""" + cache = self.__dict__.setdefault("_jit_cache", {}) + if key not in cache: + cache[key] = jax.jit(fn) + return cache[key] + + def ym(self, theta): + """The stacked prediction in comparison space, all points. + + A numpy array on a concrete ``theta``. + """ + return _host(self._jitted("ym", self._ym)(jnp.asarray(theta, dtype=float))) + + def _ym(self, theta): + parts = [] + for (_, g, c), label in zip(self.predictors, self.labels): + y = c.predict(*theta[g]) + if y.shape != (c.n,): + raise ValueError( + f"comparison {label!r}: the model returned shape {y.shape} on a " + f"grid of {c.n} point(s)" + ) + parts.append(y) + return jnp.concatenate(parts) + + def predict_physical(self, theta) -> list: + return [c.predictor(*theta[g]) for _, g, c in self.predictors] + + def _stats(self, theta): + """``(d2, logdet, ok)``: ``ok`` is false where the prediction is not + finite on the active points or a parametric covariance is singular.""" + ym = self._ym(theta) + d2, logdet = self.covariance.distance(ym, theta) + ok = ( + jnp.all(jnp.isfinite(ym[self.active])) + & jnp.isfinite(d2) + & jnp.isfinite(logdet) + ) + return d2, logdet, ok + + def log_likelihood(self, theta): + d2, logdet, ok = self._stats(theta) + ll = self.likelihood.log_likelihood(d2, logdet, self.n_active) + return jnp.where(ok, ll, -jnp.inf) + + def chi2(self, theta): + d2, logdet, ok = self._stats(theta) + c2 = self.likelihood.chi2(d2, logdet, self.n_active) + return jnp.where(ok, c2, jnp.inf) + + def entries_for(self, terms=None, statistical: bool = True): + """Covariance entries of a term selection, or ``None`` for all of them. + + ``terms`` are :class:`~rxmc.terms.Term` objects declared on this + constraint, matched *by identity*; ``None`` means every declared term. + ``statistical`` says whether the reported statistical diagonals join + them. ``None`` is returned for the full selection so the caller takes + the cached path. + """ + if terms is None and statistical: + return None + chosen = list(self.source.terms) if terms is None else list(terms) + for t in chosen: + if not any(t is u for u in self.source.terms): + raise ValueError( + f"{t!r} is not a term of this constraint; terms= selects among " + "the terms it was declared with (the reported statistical " + "errors are selected with statistical=True/False instead)" + ) + if statistical: + chosen = self.statistical_terms + chosen + return [e for e in self.covariance.entries if any(e.term is t for t in chosen)] + + def matrix(self, theta, *, terms=None, statistical: bool = True): + """The dense covariance on the active points at ``theta``. + + ``terms`` and ``statistical`` select part of the error model; see + :meth:`entries_for`. The default is the covariance the likelihood uses. + A numpy array on a concrete ``theta``. + """ + entries = self.entries_for(terms, statistical) + key = ("matrix", None if entries is None else tuple(map(id, entries))) + fn = self._jitted( + key, lambda t: self.covariance.matrix(self._ym(t), t, entries=entries) + ) + return _host(fn(jnp.asarray(theta, dtype=float))) + + def __repr__(self): + return f"CompiledConstraint({self.labels}, n_active={self.n_active})" + + +def _warn_on_shared_rows(constraints) -> None: + """Warn when one dataset's rows are active in two weighted constraints. + + Its likelihood would count those rows twice. Disjoint masks (a fit and its + complement) and weight-0 monitor constraints are fine. + """ + seen: dict[int, list] = {} + for k, c in enumerate(constraints): + if c.weight == 0.0: + continue + for comp, o in zip(c.comparisons, c.offsets): + rows = c.active[(c.active >= o.start) & (c.active < o.stop)] - o.start + for j, prev in seen.get(id(comp.data), []): + if np.intersect1d(rows, prev).size: + warnings.warn( + f"dataset {comp.data.label or 'dataset'!r} has rows active in " + f"constraints {j} and {k}: the likelihood counts them twice " + "(mask them apart, or give one constraint weight 0)", + UserWarning, + stacklevel=3, + ) + seen.setdefault(id(comp.data), []).append((k, rows)) + + +# ---------------------------------------------------------------------------- +# The problem +# ---------------------------------------------------------------------------- + + +class Problem: + """The compiled calibration problem: the flat interface a sampler wants. + + Parameters + ---------- + constraints : iterable of Constraint + priors : sequence of (params, joint), optional + Joint prior blocks; see the module docstring. + """ + + def __init__(self, constraints, priors=()): + constraints = tuple(constraints) + if not constraints: + raise ValueError("a problem needs at least one constraint") + for c in constraints: + if not isinstance(c, Constraint): + raise TypeError(f"constraints must be Constraint objects, got {c!r}") + self.index = ParameterIndex() + self.constraints = tuple(CompiledConstraint(c, self.index) for c in constraints) + _warn_on_shared_rows(self.constraints) + self.priors = tuple(priors) + # a hyperprior block may introduce a parameter no model or term uses (its + # hyperparameter); it gets a slot after every constraint's parameters + for entry in self.priors: + params = entry[0] if not isinstance(entry, Parameter) else entry + params = [params] if isinstance(params, Parameter) else list(params) + self.index.add_all(params) + self.index.check_names_unique() + self._prior = _Prior(self.index, self.priors) + self._weighted = [(c.weight, c) for c in self.constraints if c.weight != 0.0] + # the support of each slot: its bounds, narrowed by its marginal prior's + # (a uniform or half-normal prior bounds a parameter on its own); the + # unconstrained map sends a slot with one finite end through exp and + # one with two through a scaled sigmoid, static so the map traces to + # fixed ops + self._support = self.bounds.copy() + for m in self._prior.marginals: + if m.dist is not None: + a, b = m.dist.support() + self._support[m.slot] = max(m.lo, a), min(m.hi, b) + lo, hi = self._support.T + self._lo_only = np.flatnonzero(np.isfinite(lo) & ~np.isfinite(hi)) + self._hi_only = np.flatnonzero(~np.isfinite(lo) & np.isfinite(hi)) + self._both = np.flatnonzero(np.isfinite(lo) & np.isfinite(hi)) + self._jit() + + def _jit(self): + """Compile the densities once per problem (and again after unpickling).""" + self._log_prior_j = jax.jit(self._log_prior_impl) + self._log_likelihood_j = jax.jit(self._log_likelihood_impl) + self._log_posterior_j = jax.jit(self._log_posterior_impl) + self._chi2_j = jax.jit(self._chi2_impl) + self._vg_j = jax.jit(jax.value_and_grad(self._log_posterior_impl)) + self._vg_like_j = jax.jit(jax.value_and_grad(self._log_likelihood_impl)) + self._hess_j = jax.jit(jax.hessian(self._log_posterior_impl)) + self._batch_j = jax.jit(jax.vmap(self._log_posterior_impl)) + self._prior_batch_j = jax.jit(jax.vmap(self._log_prior_impl)) + self._likelihood_batch_j = jax.jit(jax.vmap(self._log_likelihood_impl)) + self._to_theta_j = jax.jit(lambda z: self._to_theta_impl(z)[0]) + self._to_z_j = jax.jit(self._to_unconstrained_impl) + self._lpu_j = jax.jit(self._log_posterior_unconstrained_impl) + + def __getstate__(self): + state = self.__dict__.copy() + for k in [k for k in state if k.endswith("_j")]: + del state[k] + return state + + def __setstate__(self, state): + self.__dict__.update(state) + self._jit() + + # -- structure ---------------------------------------------------------- + + @property + def params(self) -> tuple[Parameter, ...]: + return self.index.params + + @property + def names(self) -> list[str]: + return self.index.names + + @property + def ndim(self) -> int: + return self.index.ndim + + @property + def bounds(self) -> np.ndarray: + return self.index.bounds + + @property + def support(self) -> np.ndarray: + """``(ndim, 2)``: each parameter's bounds narrowed by its marginal + prior's support (a uniform or half-normal prior bounds a parameter on + its own), the box an optimiser or the unconstrained map works in.""" + return self._support.copy() + + def columns(self, params) -> np.ndarray: + """Chain columns of one parameter or of a sequence of them.""" + return self.index.slots(params) + + def _theta(self, theta): + theta = jnp.asarray(theta, dtype=float) + if theta.shape != (self.ndim,): + raise ValueError(f"theta must have shape ({self.ndim},), got {theta.shape}") + return theta + + # -- densities: pure jax.numpy, compiled in _jit --------------------------- + + def _log_prior_impl(self, theta): + return self._prior.logpdf(theta) + + def _log_likelihood_impl(self, theta): + total = 0.0 + for w, c in self._weighted: + total = total + w * c.log_likelihood(theta) + return jnp.asarray(total) + + def _log_posterior_impl(self, theta): + # prior first: outside its support the forward models are not run (a + # cond executes one branch; under vmap it evaluates both and selects) + lp = self._prior.logpdf(theta) + return jax.lax.cond( + jnp.isfinite(lp), + lambda t: lp + self._log_likelihood_impl(t), + lambda t: jnp.asarray(-jnp.inf), + theta, + ) + + def _chi2_impl(self, theta): + total = 0.0 + for c in self.constraints: + total = total + c.chi2(theta) + return jnp.asarray(total) + + # -- densities ------------------------------------------------------------ + + def log_prior(self, theta) -> float: + """Log prior density at ``theta``; ``-inf`` outside its support.""" + return _host(self._log_prior_j(self._theta(theta))) + + def log_likelihood(self, theta) -> float: + """Weighted sum of the constraints' log likelihoods at ``theta``.""" + return _host(self._log_likelihood_j(self._theta(theta))) + + def log_posterior(self, theta) -> float: + """Log prior plus log likelihood at ``theta``. + + A float on a concrete ``theta``, the traced value under ``jax.grad`` + or ``jax.vmap``. ``-inf`` outside the prior's support (the forward + models do not run, and the gradient is zero) or where a covariance is + singular (the gradient stays finite). + """ + return _host(self._log_posterior_j(self._theta(theta))) + + def chi2(self, theta) -> float: + """Sum of the constraints' chi-square statistics at ``theta``.""" + return _host(self._chi2_j(self._theta(theta))) + + # -- derivatives ------------------------------------------------------------ + + def grad_log_posterior(self, theta) -> np.ndarray: + """The gradient of :meth:`log_posterior` (a numpy array).""" + return np.asarray(self._vg_j(self._theta(theta))[1]) + + def value_and_grad_log_posterior(self, theta) -> tuple[float, np.ndarray]: + """``(log_posterior(theta), grad_log_posterior(theta))`` in one pass.""" + v, g = self._vg_j(self._theta(theta)) + return float(v), np.asarray(g) + + def grad_log_likelihood(self, theta) -> np.ndarray: + """The gradient of :meth:`log_likelihood` (a numpy array).""" + return np.asarray(self._vg_like_j(self._theta(theta))[1]) + + def value_and_grad_log_likelihood(self, theta) -> tuple[float, np.ndarray]: + """``(log_likelihood(theta), grad_log_likelihood(theta))`` in one pass.""" + v, g = self._vg_like_j(self._theta(theta)) + return float(v), np.asarray(g) + + def hessian_log_posterior(self, theta) -> np.ndarray: + """The ``(ndim, ndim)`` Hessian of :meth:`log_posterior` (e.g. Laplace).""" + return np.asarray(self._hess_j(self._theta(theta))) + + # -- the unconstrained space ---------------------------------------------- + + def _to_theta_impl(self, z): + """``(theta, log|d theta / d z|)``: ``exp`` away from one finite bound, + a scaled sigmoid between two, the identity otherwise.""" + lo, hi = self._support.T + a, b, c = self._lo_only, self._hi_only, self._both + z = jnp.asarray(z, dtype=float) + theta = z.at[a].set(lo[a] + jnp.exp(z[a])) + theta = theta.at[b].set(hi[b] - jnp.exp(z[b])) + width = hi[c] - lo[c] + theta = theta.at[c].set(lo[c] + width * jax.nn.sigmoid(z[c])) + log_jac = ( + jnp.sum(z[a]) + + jnp.sum(z[b]) + + jnp.sum( + np.log(width) + jax.nn.log_sigmoid(z[c]) + jax.nn.log_sigmoid(-z[c]) + ) + ) + return theta, log_jac + + def _to_unconstrained_impl(self, theta): + lo, hi = self._support.T + a, b, c = self._lo_only, self._hi_only, self._both + theta = jnp.asarray(theta, dtype=float) + z = theta.at[a].set(jnp.log(theta[a] - lo[a])) + z = z.at[b].set(jnp.log(hi[b] - theta[b])) + return z.at[c].set( + jax.scipy.special.logit((theta[c] - lo[c]) / (hi[c] - lo[c])) + ) + + def _log_posterior_unconstrained_impl(self, z): + theta, log_jac = self._to_theta_impl(z) + return self._log_posterior_impl(theta) + log_jac + + def to_theta(self, z): + """Map a point of ``R^ndim`` into the support (see + :meth:`log_posterior_unconstrained`).""" + return _host(self._to_theta_j(self._theta(z))) + + def to_unconstrained(self, theta): + """The inverse of :meth:`to_theta`, for ``theta`` strictly inside the support.""" + return _host(self._to_z_j(self._theta(theta))) + + def log_posterior_unconstrained(self, z) -> float: + """:meth:`log_posterior` at ``to_theta(z)`` plus its log-Jacobian. + + The density of ``z = to_unconstrained(theta)``, finite on all of + ``R^ndim`` where the posterior is. A parameter's support is its + bounds narrowed by its marginal prior's (``stats.uniform(a, w)`` or + ``stats.halfnorm()`` bound a parameter on their own; a custom joint + block's support must be stated as bounds). A parameter with one + finite end is sampled as the log of its distance from it, one with + two as the logit of its position between them. Gradient samplers (HMC/NUTS, + recipe 41) need this, because their trajectories cannot cross the + ``-inf`` wall at a bound. A float on a concrete ``z``, the traced + value under JAX. + """ + return _host(self._lpu_j(self._theta(z))) + + def log_jacobian(self) -> float: + """Sum of the constraints' comparison-space log-Jacobians, each times its + ``weight``. + + A tempered constraint enters the likelihood as ``weight * log L``, so + its Jacobian enters ``log Z_raw = log Z + log_jacobian()`` with the same + weight, and a weight-0 constraint not at all. + """ + return float( + sum(c.weight * c.log_jacobian for c in self.constraints if c.weight) + ) + + def prior_transform(self, u) -> np.ndarray: + """Map a point of the unit cube to ``theta`` (nested sampling).""" + u = np.asarray(u, dtype=float) + if u.shape != (self.ndim,): + raise ValueError(f"u must have shape ({self.ndim},), got {u.shape}") + return self._prior.transform(u) + + def prior_transform_batch(self, us) -> np.ndarray: + """:meth:`prior_transform` over the rows of ``us``, ``(n, ndim)``. + + With :meth:`log_likelihood_batch` it serves a vectorised sampler on + the unit cube, such as pocomc with ``vectorize=True``. + """ + return self._prior.transform(self._rows(us, "us")) + + def sample_prior(self, n: int, rng=None) -> np.ndarray: + """``(n, ndim)`` draws from the prior.""" + rng = np.random.default_rng(rng) + return self._prior.sample(int(n), rng) + + def predict(self, theta, physical: bool = False) -> list[list[np.ndarray]]: + """Per constraint, per comparison: the prediction on all points. + + numpy arrays on a concrete ``theta``. + """ + theta = self._theta(theta) + out = [] + for c in self.constraints: + if physical: + out.append([_host(y) for y in c.predict_physical(theta)]) + else: + ym = c.ym(theta) + out.append([ym[o] for o in c.offsets]) + return out + + # -- black-box-bayes spellings ------------------------------------------------ + + @property + def NDIM(self) -> int: # noqa: N802 - the bbb name + return self.ndim + + @property + def parameter_names(self) -> list[str]: + return self.names + + def starting_location(self, n: int) -> np.ndarray: + """``(n, ndim)`` draws from the prior (:meth:`sample_prior`).""" + return self.sample_prior(n) + + def _rows(self, rows, name="thetas") -> np.ndarray: + rows = np.asarray(rows, dtype=float) + if rows.ndim != 2 or rows.shape[1] != self.ndim: + raise ValueError( + f"{name} must have shape (n, {self.ndim}), got {rows.shape}" + ) + return rows + + def _chunked(self, fn, thetas) -> np.ndarray: + """``fn`` (a vmapped density) over the rows, ``BATCH_CHUNK`` at a time.""" + rows = self._rows(thetas) + return np.concatenate( + [ + np.asarray(fn(rows[i : i + BATCH_CHUNK])) + for i in range(0, len(rows), BATCH_CHUNK) + ] + or [np.empty(0)] + ) + + def log_posterior_batch(self, thetas) -> np.ndarray: + """:meth:`log_posterior` over the rows of ``thetas``. + + ``jax.vmap`` calls of at most ``BATCH_CHUNK`` rows; with emcee, pass + it with ``vectorize=True`` instead of a process pool. + """ + return self._chunked(self._batch_j, thetas) + + def log_prior_batch(self, thetas) -> np.ndarray: + """:meth:`log_prior` over the rows of ``thetas``, as :meth:`log_posterior_batch`.""" + return self._chunked(self._prior_batch_j, thetas) + + def log_likelihood_batch(self, thetas) -> np.ndarray: + """:meth:`log_likelihood` over the rows of ``thetas``, as + :meth:`log_posterior_batch`. + + For vectorised samplers: pocomc with ``vectorize=True`` (on + :meth:`prior_transform_batch` of its unit-cube points), or ptemcee + through its ``mapper``. Unlike :meth:`log_posterior_batch` it + evaluates every row, inside the prior's support or not, where the + models may give non-finite values; a caller that combines it with a + prior masks those rows. + """ + return self._chunked(self._likelihood_batch_j, thetas) + + def __repr__(self): + return f"Problem(ndim={self.ndim}, constraints={len(self.constraints)})" diff --git a/src/rxmc/proposal.py b/src/rxmc/proposal.py deleted file mode 100644 index 7bf4cfb..0000000 --- a/src/rxmc/proposal.py +++ /dev/null @@ -1,93 +0,0 @@ -""" -Proposal distributions for Metropolis-Hastings MCMC. - -Each class is a callable that accepts the current parameter vector and a -:class:`numpy.random.Generator` and returns a proposed parameter vector. -""" - -import numpy as np -from scipy import stats - - -class ProposalDistribution: - """Abstract base class for Metropolis-Hastings proposal distributions. - - Subclasses must implement :meth:`__call__`, which generates a new candidate - parameter vector given the current state. - """ - - def __init__(self): - pass - - def __call__(self, x: np.ndarray, rng: np.random.Generator) -> np.ndarray: - """Generate a proposed sample from the current state. - - Parameters - ---------- - x : np.ndarray - Current parameter vector. - rng : np.random.Generator - Random number generator. - - Returns - ------- - np.ndarray - Proposed parameter vector. - - Raises - ------ - NotImplementedError - Always — subclasses must implement this method. - """ - raise NotImplementedError("This method should be overridden by subclasses") - - -class NormalProposalDistribution(ProposalDistribution): - """Multivariate-normal proposal centred at the current state. - - Parameters - ---------- - cov : np.ndarray, shape (ndim, ndim) - Covariance matrix of the proposal distribution. - """ - - def __init__(self, cov: np.ndarray): - self.cov = cov - - def __call__(self, x: np.ndarray, rng: np.random.Generator) -> np.ndarray: - return stats.multivariate_normal.rvs(mean=x, cov=self.cov, random_state=rng) - - -class HalfNormalProposalDistribution(ProposalDistribution): - """Half-normal proposal, useful for strictly non-negative parameters. - - Parameters - ---------- - scale : float - Scale parameter of the half-normal distribution. - """ - - def __init__(self, scale: float): - self.scale = scale - - def __call__(self, x: np.ndarray, rng: np.random.Generator) -> np.ndarray: - return stats.halfnorm.rvs(loc=x, scale=self.scale, random_state=rng) - - -class LogspaceNormalProposalDistribution(ProposalDistribution): - """Normal proposal operating in log space, for strictly positive parameters. - - Proposes ``exp(log(x) + eps)`` where ``eps ~ Normal(0, scale)``, which - preserves positivity while allowing multiplicative jumps of arbitrary size. - - Parameters - ---------- - scale : float - Standard deviation of the normal perturbation in log space. - """ - - def __init__(self, scale: float): - self.scale = scale - - def __call__(self, x: np.ndarray, rng: np.random.Generator) -> np.ndarray: - return np.exp(stats.norm.rvs(loc=np.log(x), scale=self.scale, random_state=rng)) diff --git a/src/rxmc/reactions/__init__.py b/src/rxmc/reactions/__init__.py new file mode 100644 index 0000000..04e0d8a --- /dev/null +++ b/src/rxmc/reactions/__init__.py @@ -0,0 +1,8 @@ +"""Reaction models backed by ``jitr``: they override ``Model.bind`` only.""" + +from .elastic import ElasticXS as ElasticXS +from .elastic import momentum_transfer as momentum_transfer +from .elastic import rutherford as rutherford +from .ias import IsobaricAnalogPN as IsobaricAnalogPN + +__all__ = ["ElasticXS", "IsobaricAnalogPN", "momentum_transfer", "rutherford"] diff --git a/src/rxmc/reactions/elastic.py b/src/rxmc/reactions/elastic.py new file mode 100644 index 0000000..d88d6ca --- /dev/null +++ b/src/rxmc/reactions/elastic.py @@ -0,0 +1,263 @@ +""" +Elastic differential cross sections from the ``jitr`` optical-model solver. + +:class:`ElasticXS` is a :class:`~rxmc.model.Model` that overrides only +``bind``: given a grid of angles and a dataset's kinematics +(``meta["reaction"]``, ``meta["Elab"]``) it builds the ``jitr`` R-matrix +workspace on that grid and returns a :class:`~rxmc.model.Predictor` that +evaluates the potentials on the radial mesh, solves, and extracts one of +``"dXS/dA"`` (b/sr), ``"dXS/dRuth"`` or ``"Ay"``. The model owns the +solver; the data does not. + +``jitr``'s solver is written in JAX, so the prediction is differentiable in +the potential parameters: the potentials and ``args_from_params`` must be +written with ``jax.numpy`` (``jitr``'s potential forms are). The spin-orbit +potential multiplies ``l.sigma`` (``2 l.s``) for a spin-1/2 projectile, as in +``jitr``. + +The expensive part of a workspace (the mesh, the asymptotics and the +compiled solve) depends only on the kinematics and the solver settings, so it +is cached per model instance and shared by every grid at one energy: the data +grid, a plotting grid, a held-out view (``Workspace.at_angles``). The cache is +dropped on pickling; a bound predictor carries its own workspace and pickles +with ``dill``. +""" + +from __future__ import annotations + +from typing import Callable + +import jax.numpy as jnp +import jitr +import numpy as np +from jitr.xs.coupled import Potential + +from ..model import Model, Predictor +from ..units import DEFAULT_LMAX, MB_PER_B, check_angle_grid + +__all__ = [ + "ElasticXS", + "set_up_solver", + "rutherford", + "momentum_transfer", + "extract_dXS_dA", + "extract_dXS_dRuth", + "extract_Ay", +] + +QUANTITIES = ("dXS/dA", "dXS/dRuth", "Ay") + + +def rutherford(kinematics, angles_rad) -> np.ndarray: + r"""The Rutherford cross section in mb/sr on ``angles_rad``. + + :math:`10\,\eta^2 / (4 k^2 \sin^4(\theta/2))` with ``k`` in fm⁻¹; a closed + form of the kinematics, so no workspace is needed. Zero for a neutral + projectile (``eta == 0``). + """ + angles_rad = np.asarray(angles_rad, dtype=float) + sin2 = np.sin(angles_rad / 2.0) ** 2 + return 10.0 * kinematics.eta**2 / (4.0 * kinematics.k**2 * sin2**2) + + +def momentum_transfer(angles_rad, k): + r"""Momentum transfer :math:`q = 2k\sin(\theta/2)` (fm⁻¹) on the angles. + + For a :func:`~rxmc.terms.kernel` term in :math:`q`-space pass it as the + term's coordinate transform: ``coords=lambda x: momentum_transfer(x, k)``. + """ + return 2.0 * float(k) * jnp.sin(jnp.asarray(angles_rad, dtype=float) / 2.0) + + +def _basis(reaction, Elab, lmax, wavelengths_beyond_range, zeros_per_node): + """The angle-free workspace and kinematics for one reaction at one energy.""" + kinematics = reaction.kinematics(Elab) + k = kinematics.k + interaction_range_fm = jitr.utils.interaction_range(reaction.target.A) + 2 + a = k * interaction_range_fm + wavelengths_beyond_range * 2 * np.pi + channel_radius_fm = a / k + N = jitr.utils.suggested_basis_size(a, zeros_per_node) + ws = jitr.xs.elastic.Workspace(reaction, kinematics, channel_radius_fm, lmax, N) + return ws, kinematics + + +def set_up_solver( + reaction, + Elab: float, + angles_rad: np.ndarray, + lmax: int = DEFAULT_LMAX, + wavelengths_beyond_range: float = 2.0, + zeros_per_node: int = 5, +): + """Set up a ``jitr`` workspace for a reaction at one energy. + + Parameters + ---------- + reaction : jitr.reactions.Reaction + Elab : float + Laboratory energy in MeV. + angles_rad : np.ndarray + Angles in radians the observables are wanted on. + lmax : int + Maximum partial wave. + wavelengths_beyond_range : float + Number of wavelengths beyond the interaction range used to set the + channel radius. + zeros_per_node : int + Basis-function zeros per node in the R-matrix solver. + + Returns + ------- + (jitr.xs.elastic.Workspace, jitr.utils.kinematics.ChannelKinematics) + """ + ws, kinematics = _basis( + reaction, Elab, lmax, wavelengths_beyond_range, zeros_per_node + ) + return ws.at_angles(np.asarray(angles_rad, dtype=float)), kinematics + + +# jitr results carry a leading energy axis; a workspace here has one energy + + +def extract_dXS_dA(xs, ws): + """dXS/dA in b/sr (``jitr`` reports mb/sr).""" + return xs.dsdo[0] / MB_PER_B + + +def extract_dXS_dRuth(xs, ws): + """dXS/dRuth (dimensionless).""" + return xs.dsdo[0] / ws.rutherford[0] + + +def extract_Ay(xs, ws): + """The analysing power (dimensionless).""" + return xs.Ay[0] + + +_EXTRACT = {"dXS/dA": extract_dXS_dA, "dXS/dRuth": extract_dXS_dRuth, "Ay": extract_Ay} + + +class ElasticXS(Model): + """Elastic differential cross section, ratio to Rutherford, or analysing power. + + Parameters + ---------- + quantity : {"dXS/dA", "dXS/dRuth", "Ay"} + central : callable + ``f(r, *args) -> array``, the central potential on the radial mesh + ``r`` (fm), in MeV, written with ``jax.numpy``. + spin_orbit : callable or None + ``f(r, *args) -> array``, the spin-orbit potential (it multiplies + ``l.sigma`` for a spin-1/2 projectile); ``None`` for a spin-orbit-free + model, and for a spin-0 projectile. + args_from_params : callable + ``f(workspace, *values) -> (central_args, spin_orbit_args)`` or + ``-> (central_args, spin_orbit_args, coulomb_args)``: the argument + tuples for the potential callables at the sampled values. + params : sequence of Parameter + coulomb : callable, optional + ``f(r, *args) -> array``, the Coulomb potential. When ``None`` + the Coulomb interaction inside the channel radius must be folded into + ``central``. + lmax, wavelengths_beyond_range, zeros_per_node + Solver settings, forwarded to :func:`set_up_solver`. + """ + + def __init__( + self, + quantity: str, + central: Callable, + spin_orbit: Callable | None, + args_from_params: Callable, + params, + coulomb: Callable | None = None, + *, + lmax: int = DEFAULT_LMAX, + wavelengths_beyond_range: float = 2.0, + zeros_per_node: int = 5, + ): + if quantity not in QUANTITIES: + raise ValueError(f"quantity must be one of {QUANTITIES}, got {quantity!r}") + super().__init__(None, params) + self.quantity = quantity + self.central = central + self.spin_orbit = spin_orbit + self.coulomb = coulomb + self.args_from_params = args_from_params + self.lmax = lmax + self.wavelengths_beyond_range = wavelengths_beyond_range + self.zeros_per_node = zeros_per_node + self._cache: dict = {} + + def __getstate__(self): + state = self.__dict__.copy() + state["_cache"] = {} + return state + + def _kinematics_of(self, meta): + meta = meta or {} + try: + return meta["reaction"], float(meta["Elab"]) + except KeyError as err: + raise ValueError( + f"{type(self).__name__} needs meta[{err.args[0]!r}] to bind: build " + "the dataset with from_measurement, or pass meta={'reaction': ..., " + "'Elab': ...}" + ) from None + + def workspace(self, x, meta): + """The ``jitr`` workspace on the angles ``x`` for this dataset's kinematics.""" + reaction, Elab = self._kinematics_of(meta) + key = ( + id(reaction), + Elab, + self.lmax, + self.wavelengths_beyond_range, + self.zeros_per_node, + ) + if key not in self._cache: + self._cache[key] = _basis( + reaction, + Elab, + self.lmax, + self.wavelengths_beyond_range, + self.zeros_per_node, + ) + basis, _ = self._cache[key] + x = np.asarray(x, dtype=float) + check_angle_grid(x, "x") + return basis.at_angles(x) + + def bind(self, x, meta=None) -> Predictor: + ws = self.workspace(x, meta) + if self.quantity == "dXS/dRuth" and ws.rutherford is None: + raise ValueError( + "dXS/dRuth needs the Rutherford cross section, which a neutral " + "projectile does not have: compare dXS/dA instead" + ) + extract = _EXTRACT[self.quantity] + central, spin_orbit, coulomb = self.central, self.spin_orbit, self.coulomb + args_from_params = self.args_from_params + r = ws.r + + def predict(*values): + args = args_from_params(ws, *values) + if len(args) == 2: + (c_args, so_args), cou_args = args, () + elif len(args) == 3: + c_args, so_args, cou_args = args + else: + raise ValueError( + "args_from_params must return 2 or 3 argument tuples, " + f"got {len(args)}" + ) + xs = ws.xs( + Potential( + central=central(r, *c_args), + spin_orbit=None if spin_orbit is None else spin_orbit(r, *so_args), + coulomb=None if coulomb is None else coulomb(r, *cou_args), + ) + ) + return extract(xs, ws) + + return Predictor(self.params, x, predict, meta) diff --git a/src/rxmc/reactions/ias.py b/src/rxmc/reactions/ias.py new file mode 100644 index 0000000..2df1d0b --- /dev/null +++ b/src/rxmc/reactions/ias.py @@ -0,0 +1,167 @@ +""" +(p,n) isobaric-analog-state differential cross sections from ``jitr``. + +:class:`IsobaricAnalogPN` is a :class:`~rxmc.model.Model` that overrides only +``bind``: given a grid of angles and a dataset's kinematics +(``meta["reaction"]``, ``meta["Elab"]``, ``meta["ExIAS"]``) it builds the +``jitr`` quasielastic (p,n) workspace on that grid and returns a +:class:`~rxmc.model.Predictor` for the DWBA cross section in b/sr. The (p,n) +transition is driven by the difference between the proton and neutron +potentials (the Lane term, ``jitr``'s default isovector ``U1``), so the five +potentials are declared separately. As for :mod:`rxmc.reactions.elastic`, the +potentials are written with ``jax.numpy`` and the prediction is +differentiable. +""" + +from __future__ import annotations + +from typing import Callable + +import jitr +import numpy as np +from jitr.xs.coupled import Potential + +from ..model import Model, Predictor +from ..units import DEFAULT_LMAX, MB_PER_B, check_angle_grid + +__all__ = ["IsobaricAnalogPN", "set_up_solver"] + + +def set_up_solver( + reaction, + Elab: float, + ExIAS: float, + angles_rad: np.ndarray, + lmax: int = DEFAULT_LMAX, + wavelengths_beyond_range: float = 2.0, + zeros_per_node: int = 5, +): + """Set up the ``jitr`` (p,n) workspace for a reaction at one energy. + + Parameters + ---------- + reaction : jitr.reactions.Reaction + Elab : float + Laboratory energy of the incoming proton (MeV). + ExIAS : float + Excitation energy of the isobaric analog state in the residual (MeV). + angles_rad : np.ndarray + Angles in radians the cross section is wanted on. + lmax, wavelengths_beyond_range, zeros_per_node + Solver settings (see :func:`rxmc.reactions.elastic.set_up_solver`). + + Returns + ------- + (jitr.xs.quasielastic_pn.Workspace, kinematics_entrance, kinematics_exit) + """ + kinematics_entrance = reaction.kinematics(Elab=Elab) + kinematics_exit = reaction.kinematics_exit( + kinematics_entrance, residual_excitation_energy=ExIAS + ) + k = kinematics_entrance.k + interaction_range_fm = jitr.utils.interaction_range(reaction.target.A) + 2 + a = k * interaction_range_fm + wavelengths_beyond_range * 2 * np.pi + channel_radius_fm = a / k + N = jitr.utils.suggested_basis_size(a, zeros_per_node) + ws = jitr.xs.quasielastic_pn.Workspace( + reaction, + kinematics_entrance, + kinematics_exit, + channel_radius_fm, + lmax, + N, + angles=np.asarray(angles_rad, dtype=float), + ) + return ws, kinematics_entrance, kinematics_exit + + +class IsobaricAnalogPN(Model): + """The (p,n) IAS differential cross section in b/sr. + + Parameters + ---------- + U_p_coulomb, U_p_central, U_p_spin_orbit, U_n_central, U_n_spin_orbit : callable + ``f(r, *args) -> array`` on the radial mesh ``r`` (fm), in MeV, written + with ``jax.numpy``. + args_from_params : callable + ``f(workspace, *values) -> (args_p_coulomb, args_p_central, + args_p_spin_orbit, args_n_central, args_n_spin_orbit)``. + params : sequence of Parameter + lmax, wavelengths_beyond_range, zeros_per_node + Solver settings, forwarded to :func:`set_up_solver`. + """ + + def __init__( + self, + U_p_coulomb: Callable, + U_p_central: Callable, + U_p_spin_orbit: Callable, + U_n_central: Callable, + U_n_spin_orbit: Callable, + args_from_params: Callable, + params, + *, + lmax: int = DEFAULT_LMAX, + wavelengths_beyond_range: float = 2.0, + zeros_per_node: int = 5, + ): + super().__init__(None, params) + self.potentials = ( + U_p_coulomb, + U_p_central, + U_p_spin_orbit, + U_n_central, + U_n_spin_orbit, + ) + self.args_from_params = args_from_params + self.lmax = lmax + self.wavelengths_beyond_range = wavelengths_beyond_range + self.zeros_per_node = zeros_per_node + + def workspace(self, x, meta): + meta = meta or {} + try: + reaction, Elab, ExIAS = ( + meta["reaction"], + float(meta["Elab"]), + float(meta["ExIAS"]), + ) + except KeyError as err: + raise ValueError( + f"{type(self).__name__} needs meta[{err.args[0]!r}] to bind: build " + "the dataset with from_measurement(..., ExIAS=), or pass " + "meta={'reaction': ..., 'Elab': ..., 'ExIAS': ...}" + ) from None + x = np.asarray(x, dtype=float) + check_angle_grid(x, "x") + ws, _, _ = set_up_solver( + reaction, + Elab, + ExIAS, + x, + lmax=self.lmax, + wavelengths_beyond_range=self.wavelengths_beyond_range, + zeros_per_node=self.zeros_per_node, + ) + return ws + + def bind(self, x, meta=None) -> Predictor: + ws = self.workspace(x, meta) + potentials, args_from_params = self.potentials, self.args_from_params + r = ws.r + + def predict(*values): + args = args_from_params(ws, *values) + if len(args) != 5: + raise ValueError( + f"args_from_params must return 5 argument tuples, got {len(args)}" + ) + p_cou, p_cen, p_so, n_cen, n_so = ( + U(r, *a) for U, a in zip(potentials, args) + ) + Up = Potential(central=p_cen, spin_orbit=p_so, coulomb=p_cou) + Un = Potential(central=n_cen, spin_orbit=n_so) + # one energy: drop the leading energy axis + return ws.dwba(Up, Un).dsdo[0] / MB_PER_B + + return Predictor(self.params, x, predict, meta) diff --git a/src/rxmc/terms.py b/src/rxmc/terms.py new file mode 100644 index 0000000..5da6999 --- /dev/null +++ b/src/rxmc/terms.py @@ -0,0 +1,698 @@ +""" +Covariance terms: the additive pieces of a constraint's covariance. + +A constraint owns one multivariate distribution over the stacked residual of +its comparisons; its covariance is a sum of :class:`Term` s. There is exactly +**one** term type. A ``Term`` is a ``jax.numpy`` callable ``fn(c, *values) -> +array`` of a :class:`TermContext` ``c`` (the term's view of ``x``, ``y`` and the +prediction ``ym`` on its support, with ``x`` passed through an optional +coordinate :class:`~rxmc.transforms.Transform`) and its parameter values, plus a +``kind`` that says how the returned array enters the covariance: + +``"diag"`` + ``fn`` returns a standard-deviation vector ``v``; ``Sigma_ii += v_i**2``. +``"mode"`` + ``fn`` returns a vector ``v``; ``Sigma += outer(v, v)`` (one correlated mode). +``"matrix"`` + ``fn`` returns a full symmetric block ``M``; ``Sigma_block += M``. + +A term is a stateless declaration. Where it applies is its ``on``: a +comparison, a dataset, a sequence of them, or ``None`` for the whole +constraint; :class:`~rxmc.problem.Problem` resolves that to rows when it +compiles. The same term may be placed in several constraints. + +A term whose ``fn`` is a function of the context is defined wherever the model +is, so :func:`~rxmc.predictive.grid_draws` can evaluate it on a grid that was +never measured. A term that is an array — the reported statistical errors, a +fixed covariance, a per-point ``magnitude=`` — exists only at the measured rows. + +Two mechanisms are expressed here (see ``docs/design.md``, recipe 5): + +* **Correlating comparisons** — a ``mode`` or ``matrix`` term whose ``on`` + spans several comparisons writes off-diagonal blocks, coupling the data. +* **Sharing a parameter** — terms declare the :class:`~rxmc.params.Parameter` + objects they consume *by identity*: pass the same object to two terms and + they share one sampled value. + +The factory helpers (:func:`statistical`, :func:`offset`, :func:`normalization`, +:func:`noise`, :func:`proportional_error`, :func:`systematic`, +:func:`kernel`) are one-line conveniences that build the common terms; anything +they cannot express is a direct ``Term(fn, params, kind=...)``. +""" + +from __future__ import annotations + +import inspect +from dataclasses import dataclass +from typing import Any, Mapping + +import jax.numpy as jnp +import numpy as np +from tinygp.kernels import Kernel + +from .params import Parameter +from .transforms import as_transform, identity + +__all__ = [ + "KINDS", + "TermContext", + "Term", + "KernelTerm", + "as_2d", + "ones", + "ym", + "averaging", + "x_basis", + "exp_growth", + "constant_amplitude", + "exp_growth_amplitude", + "statistical", + "offset", + "normalization", + "noise", + "proportional_error", + "systematic", + "kernel", + "kernel_params", +] + +KINDS = ("diag", "mode", "matrix") + + +def as_2d(X): + """Promote a 1-D input grid to a single-column 2-D array.""" + X = jnp.asarray(X, dtype=float) + return X[:, None] if X.ndim == 1 else X + + +@dataclass(eq=False, frozen=True) +class TermContext: + """A term's view of the stack on its own support. + + ``x`` are the coordinates on the support, already passed through the term's + ``coords`` transform (so ``x`` may be 2-D); ``y`` and ``ym`` are the data and + the model prediction on the support in comparison space. ``ym`` is ``None`` + while a *constant* term is evaluated before any prediction exists, so a + mis-declared constant term fails loudly. ``len(c)`` is the number of + points; :meth:`meta` gives per-point dataset metadata (``c.meta("Elab")``). + + ``x`` and ``y`` are numpy (a function of them alone, such as a Legendre + basis from scipy, is a constant) unless a parametric ``coords`` transform + makes ``x`` traced; ``ym`` and the term's parameter values are traced by + JAX, so anything computed from them uses ``jax.numpy``. + + A term spanning several comparisons sees their rows *gathered* into one + stack, in constraint order. :attr:`segments` are the slices of that stack + belonging to each comparison, :attr:`labels` their labels, and + :meth:`split` cuts any support-length array along them, so a basis that + differentiates or smooths along the grid can stay within one comparison:: + + def slope(c): # angle-calibration mode: the slope of each prediction + return jnp.concatenate([jnp.gradient(ym, x) for x, ym in + zip(c.split(c.x), c.split(c.ym))]) + """ + + x: Any + y: Any + ym: Any = None + _meta: Mapping[str, np.ndarray] | None = None + _segments: tuple | None = None + _labels: tuple | None = None + + def __len__(self) -> int: + return len(self.y) + + @property + def segments(self) -> tuple: + """Slices of the support, one per comparison it spans, in constraint order. + + A term evaluated outside a problem (as in tests) has one segment. + """ + return (slice(0, len(self)),) if self._segments is None else self._segments + + @property + def labels(self) -> tuple: + """The label of each segment's comparison (``str(comparison.data.label)``).""" + return ("",) * len(self.segments) if self._labels is None else self._labels + + def split(self, a) -> list: + """``a[s] for s in segments``: views of a support-length array per comparison.""" + if a.shape[0] != len(self): + raise ValueError( + f"split expects an array of length {len(self)}, got shape {a.shape}" + ) + return [a[s] for s in self.segments] + + def meta(self, key: str) -> np.ndarray: + """The owning dataset's ``meta[key]``, one value per point of the support.""" + if self._meta is None or key not in self._meta: + raise KeyError( + f"no per-point metadata {key!r} on this term's support; put it in " + "Dataset.meta" + ) + return self._meta[key] + + +@dataclass(eq=False, frozen=True) +class Term: + """One additive contribution to a constraint's covariance. + + Parameters + ---------- + fn : callable or array_like + ``fn(c, *values) -> array`` with ``c`` a :class:`TermContext` and + ``values`` the sampled values of ``params`` (in order), written with + ``jax.numpy`` so gradients flow through it. A plain array is + a fixed contribution (``constant=True`` implied): a standard-deviation + vector for ``kind="diag"``, a mode vector for ``"mode"``, or a symmetric + block for ``"matrix"``. + params : sequence of Parameter, optional + Parameters consumed by ``fn``, matched *by identity* across terms. + kind : {"diag", "mode", "matrix"} + How the returned array enters the covariance (see module docstring). + on : Comparison, Dataset, sequence of them, or None + Where the term applies; ``None`` means the whole constraint. Resolved + by :class:`~rxmc.problem.Problem`. + coords : Transform or callable, optional + Coordinate transform applied to ``x`` before ``fn`` sees it (e.g. angle + to momentum transfer). Its parameters, if any, are appended to + :attr:`params`. A transform needs numeric ``x``; without one, ``fn`` + sees ``x`` exactly as the dataset holds it (any dtype). + constant : bool, optional + Declare that a *callable* ``fn`` reads neither ``c.ym`` nor any + parameter, so the contribution can be evaluated once at compile. + ``c.x`` and ``c.y`` may be read freely. A constant term is evaluated + with ``c.ym is None``, so a mis-declared term fails loudly. Implied + for an array ``fn``; an error together with ``params``. + relative : bool, optional + Declare that ``fn`` is a fraction of the prediction or the data (as + :func:`proportional_error` and :func:`normalization` are), which is a + relative error only in linear space: a :class:`~rxmc.constraint.Constraint` + refuses it on a comparison with any other ``space``. In log space a + relative error is :func:`noise` or :func:`offset` itself. + """ + + fn: Any + params: tuple[Parameter, ...] = () + kind: str = "matrix" + on: Any = None + coords: Any = identity + constant: bool = False + relative: bool = False + _appended: Any = None # the coords parameters appended to params last time + + def __post_init__(self): + if self.kind not in KINDS: + raise ValueError(f"kind must be one of {KINDS}, got {self.kind!r}") + coords = as_transform(self.coords) + fn_params = tuple(self.params) + # dataclasses.replace re-runs this with the previous coords' parameters + # already appended to params: take them off before appending the current + k = len(self._appended or ()) + if k and len(fn_params) >= k: + if all(a is b for a, b in zip(fn_params[-k:], self._appended)): + fn_params = fn_params[:-k] + for p in fn_params + coords.params: + if not isinstance(p, Parameter): + raise TypeError(f"params must be Parameter objects, got {p!r}") + object.__setattr__(self, "coords", coords) + object.__setattr__(self, "params", fn_params + coords.params) + object.__setattr__(self, "_appended", coords.params) + object.__setattr__(self, "_n_fn_params", len(fn_params)) + if callable(self.fn): + if self.constant and self.params: + raise ValueError( + "a constant term cannot have parameters (constant means the " + "term reads neither ym nor any parameter)" + ) + return + if self.params: + raise ValueError("an array-valued term cannot have parameters") + a = np.asarray(self.fn, dtype=float) + if self.kind == "matrix": + if a.ndim != 2 or a.shape[0] != a.shape[1]: + raise ValueError(f"matrix term expects a square block, got {a.shape}") + if not np.allclose(a, a.T): + raise ValueError("matrix term must be symmetric") + elif a.ndim != 1: + raise ValueError(f"{self.kind} term expects a vector, got shape {a.shape}") + object.__setattr__(self, "fn", a) + object.__setattr__(self, "constant", True) + + # -- structure ---------------------------------------------------------- + + @property + def is_constant(self) -> bool: + """Whether the term can be evaluated once, before any prediction.""" + return bool(self.constant) + + @property + def couples_offdiagonal(self) -> bool: + """Whether the term can write off-diagonal entries (``kind != "diag"``).""" + return self.kind != "diag" + + def expected_shape(self, n: int) -> tuple: + return (n, n) if self.kind == "matrix" else (n,) + + # -- evaluation ----------------------------------------------------------- + + def context( + self, x, y, ym=None, meta=None, *values, segments=None, labels=None + ) -> TermContext: + """The :class:`TermContext` this term sees on its support at ``values``. + + ``segments``/``labels`` describe the comparisons the support spans (see + :attr:`TermContext.segments`); omitted, the support is one segment. + """ + self._check_count(values) + # the data stay numpy constants (x is opaque, any dtype, unless a + # coordinate transform needs it numeric), so a basis of the data alone + # may use numpy or scipy even under jit + if not self.coords.is_identity: + x = self.coords(x, *values[self._n_fn_params :]) + elif np.asarray(x).dtype.kind in "fiu": + x = np.asarray(x, dtype=float) + return TermContext( + x=x, + y=np.asarray(y, dtype=float), + ym=None if ym is None else jnp.asarray(ym), + _meta=meta, + _segments=None if segments is None else tuple(segments), + _labels=None if labels is None else tuple(labels), + ) + + def value(self, x, y, ym=None, *values, meta=None, segments=None, labels=None): + """The raw array ``fn`` returns (std vector, mode vector, or block).""" + n = len(y) + if not callable(self.fn): + if self.fn.shape != self.expected_shape(n): + raise ValueError( + f"{self.kind} term expects shape {self.expected_shape(n)}, " + f"got {self.fn.shape}" + ) + return jnp.asarray(self.fn) + c = self.context(x, y, ym, meta, *values, segments=segments, labels=labels) + v = jnp.asarray(self.fn(c, *values[: self._n_fn_params]), dtype=float) + if v.shape != self.expected_shape(n): + raise ValueError( + f"{self.kind} term fn returned shape {v.shape}, " + f"expected {self.expected_shape(n)}" + ) + return v + + def _check_count(self, values): + if len(values) != len(self.params): + raise ValueError(f"expected {len(self.params)} params, got {len(values)}") + + def __repr__(self): + names = ", ".join(p.name for p in self.params) + return f"Term(kind={self.kind!r}, params=({names}), on={self.on!r})" + + +@dataclass(eq=False, frozen=True) +class KernelTerm(Term): + """A :func:`~rxmc.terms.kernel` term that also carries what GP conditioning needs. + + :func:`~rxmc.predictive.gp_predictive_draws` reads these to condition the + discrepancy at new points; the covariance machinery treats a + ``KernelTerm`` exactly as a ``matrix`` :class:`Term`. + + Parameters + ---------- + build : callable + ``build(*kernel_values) -> tinygp kernel``, as passed to :func:`kernel` + (a fixed kernel is wrapped as a parameter-free builder). + n_kernel : int + Number of kernel parameters: ``params[:n_kernel]`` are ``build``'s, + ``params[n_kernel:]`` the amplitude's, then any coordinate-transform + parameters. + amplitude : callable or array or None + The amplitude as passed to :func:`kernel`. + jitter : float + The diagonal nugget of every kernel block, relative to the kernel's + mean variance before the amplitude scales it. + """ + + build: Any = None + n_kernel: int = 0 + amplitude: Any = None + jitter: float = 0.0 + + +# ---------------------------------------------------------------------------- +# Standard bases and amplitudes (jax.numpy callables over a TermContext) +# ---------------------------------------------------------------------------- + + +def ones(c: TermContext): + """Constant unit basis.""" + return jnp.ones(len(c)) + + +def ym(c: TermContext): + """The model prediction — the prediction-scaled basis.""" + return c.ym + + +def averaging(c: TermContext): + """``0.5 * (y + ym)`` — the averaging model-error basis.""" + return 0.5 * (c.y + c.ym) + + +_AVERAGING = averaging # factories take an ``averaging`` flag that shadows the name + + +def x_basis(scale: float = 1.0): + """Basis ``x / scale`` (e.g. ``x_basis(np.pi)`` for ``theta/180`` on radians).""" + + def basis(c: TermContext): + return jnp.asarray(c.x, dtype=float) / scale + + return basis + + +def exp_growth(scale: float = 1.0, base=ones): + """Parametric basis ``base(c) * exp(slope * x / scale)``. + + Takes one basis parameter, ``slope``; use with + ``noise(..., basis=exp_growth(np.pi), basis_params=(slope,))``. + """ + + def basis(c: TermContext, slope: float): + return base(c) * jnp.exp(slope * jnp.asarray(c.x, dtype=float) / scale) + + return basis + + +def constant_amplitude(c: TermContext, log_amplitude: float): + """Kernel amplitude ``exp(log_amplitude)``, constant over the support.""" + return jnp.full(len(c), jnp.exp(log_amplitude)) + + +def exp_growth_amplitude(scale: float = 1.0): + """Kernel amplitude ``exp(log_amplitude) * exp(slope * x / scale)`` (two params).""" + + def amplitude(c: TermContext, log_amplitude: float, slope: float): + return jnp.exp(log_amplitude) * jnp.exp( + slope * jnp.asarray(c.x, dtype=float) / scale + ) + + return amplitude + + +# ---------------------------------------------------------------------------- +# Term factory helpers +# ---------------------------------------------------------------------------- + + +def _masked(magnitude, mask=None): + """A scalar/array magnitude with an optional mask. + + Scalar-like values include 0-d ndarrays (e.g. ``np.array(0.05)`` as stored by + ``exfor_tools`` distributions), not just Python scalars. An array magnitude + must have exactly the support's length; this is checked by :func:`_full` + when the term is evaluated. + """ + v = float(magnitude) if np.ndim(magnitude) == 0 else np.asarray(magnitude, float) + if mask is not None: + v = v * np.asarray(mask, dtype=float) + return v + + +def _full(v, n): + """``v`` as a length-``n`` vector. + + Scalars are broadcast; arrays must already have shape ``(n,)`` — a length-1 + array is *not* treated as a scalar, so a magnitude or mask of the wrong + length fails loudly instead of being spread over the support. + """ + v = jnp.asarray(v, dtype=float) + if v.ndim == 0: + return jnp.full(n, v) + if v.shape != (n,): + raise ValueError( + f"magnitude/basis has shape {v.shape} but the term's support has length {n}" + ) + return v + + +def _coefficient(parameter, log): + """Parameter -> multiplicative coefficient ``exp(theta)`` (``log``) or ``theta``.""" + if parameter is None: + return (), (lambda values: 1.0) + if log: + return (parameter,), (lambda values: jnp.exp(values[0])) + return (parameter,), (lambda values: values[0]) + + +def _scaled_term( + kind, + parameter, + log, + basis, + basis_params=(), + *, + on=None, + coords=None, + relative=False, +): + """``c * basis(ctx, *basis_values)`` as a term of the given kind.""" + cparams, coef = _coefficient(parameter, log) + basis_params = tuple(basis_params) + nc = len(cparams) + + def fn(c, *values): + b = basis(c, *values[nc:]) if callable(basis) else basis + return coef(values[:nc]) * _full(b, len(c)) + + return Term( + fn, cparams + basis_params, kind=kind, on=on, coords=coords, relative=relative + ) + + +def statistical(y_err, on=None) -> Term: + """Always-on, genuinely uncorrelated statistical diagonal ``diag(y_err**2)``.""" + return Term(np.asarray(y_err, dtype=float), kind="diag", on=on) + + +def offset(parameter=None, magnitude=None, mask=None, log=True, on=None) -> Term: + """A correlated absolute-offset systematic ``outer(omega, omega)``. + + With ``parameter`` (first, like every nuisance factory) it is a free + magnitude (``c = exp(theta)`` when ``log``); with ``magnitude=`` it is a + fixed, data-given rank-one mode. + """ + if magnitude is None and parameter is None: + raise ValueError("offset requires a magnitude and/or a parameter") + mag = _masked(1.0 if magnitude is None else magnitude, mask=mask) + + def basis(c): + return _full(mag, len(c)) + + if parameter is None: + return Term(basis, kind="mode", on=on, constant=True) + return _scaled_term("mode", parameter, log, basis, on=on) + + +def normalization(parameter=None, magnitude=None, mask=None, log=True, on=None) -> Term: + """A correlated normalisation systematic ``outer(eta * ym, eta * ym)``. + + With ``parameter`` (first, like every nuisance factory) the magnitude eta + is a free nuisance (``c = exp(theta)`` when ``log``); with ``magnitude=`` it + is a fixed fractional normalisation uncertainty. In both cases the mode scales with the model *prediction* ``ym``, + never with the data: that is what keeps the fit free of Peelle's Pertinent + Puzzle (recipe 27). Linear comparison space only: in log space a + normalisation error is :func:`offset`. + """ + if magnitude is None and parameter is None: + raise ValueError("normalization requires a magnitude and/or a parameter") + mag = _masked(1.0 if magnitude is None else magnitude, mask=mask) + + def basis(c): + return _full(mag, len(c)) * c.ym + + return _scaled_term("mode", parameter, log, basis, on=on, relative=True) + + +def noise( + parameter, log=True, basis=None, basis_params=(), on=None, coords=None +) -> Term: + """Unknown statistical noise ``diag((epsilon * basis)**2)``. + + ``basis`` defaults to ones (constant noise); pass any + ``basis(c, *basis_values)`` — e.g. :func:`exp_growth` with + ``basis_params=(slope,)`` for noise growing along ``x``. + + This term is **additive**: a constraint with ``statistical=True`` (the + default) already adds each comparison's reported diagonal, so the assembled + covariance is ``diag(y_err**2 + epsilon**2)``. To make the inferred noise + *replace* the reported statistics pass ``statistical=False`` to the + constraint. + """ + return _scaled_term( + "diag", + parameter, + log, + ones if basis is None else basis, + basis_params, + on=on, + coords=coords, + ) + + +def proportional_error(parameter, averaging=False, log=True, on=None) -> Term: + """An unknown uncorrelated error proportional to the prediction. + + ``diag((c * z)**2)`` with ``c = exp(theta)`` when ``log`` (else ``theta``) + and ``z = ym``, or ``z = 0.5 * (y + ym)`` when ``averaging`` (KDUQ's + spelling, which stays finite when ``ym`` is near zero). Because it scales + with the prediction, the covariance changes with the model parameters. + Linear comparison space only: in log space a relative error is + :func:`noise`. + + **Additive** on top of the reported statistical diagonal (see :func:`noise` + for how to get replace-semantics instead). + """ + basis = _AVERAGING if averaging else ym + return _scaled_term("diag", parameter, log, basis, on=on, relative=True) + + +def systematic( + parameter, basis, log=True, basis_params=(), on=None, coords=None +) -> Term: + """A correlated mode ``outer(s * u, s * u)`` with a user basis ``u = basis(c, ...)``. + + :func:`offset` and :func:`normalization` are its ``ones``/``ym`` special + cases; use e.g. ``basis=x_basis(np.pi)`` for a mode growing with angle. + """ + return _scaled_term( + "mode", parameter, log, basis, basis_params, on=on, coords=coords + ) + + +def kernel_params(names, bounds=None, prefix="discrepancy") -> list: + """One :class:`~rxmc.params.Parameter` per kernel hyperparameter. + + A convenience for :func:`kernel`: ``kernel_params(["log_var", "log_ell"], + [(-12, 2), (-3, 1)])`` gives ``discrepancy_log_var`` and + ``discrepancy_log_ell`` with uniform priors on those bounds. tinygp + kernels carry no hyperparameter metadata, so the parameters (and the + space they are sampled in) are declared here and the builder passed to + :func:`kernel` maps them to the kernel. With ``bounds=None`` the + parameters carry no prior: give bounds, or cover them with a joint block + in ``Problem(priors=)``. + """ + names = list(names) + bounds = [None] * len(names) if bounds is None else list(bounds) + if len(bounds) != len(names): + raise ValueError(f"{len(names)} names but {len(bounds)} bounds") + return [ + Parameter( + f"{prefix}_{n}" if prefix else n, + **({} if b is None else {"bounds": tuple(b)}), + latex=n, + ) + for n, b in zip(names, bounds) + ] + + +def kernel( + build, + params=(), + coords=None, + amplitude=None, + amplitude_params=(), + jitter=1e-10, + on=None, +) -> Term: + """A Gaussian-process kernel ``a a^T * K(x, x; theta)`` over the support. + + Parameters + ---------- + build : callable or tinygp kernel + ``build(*values) -> tinygp.kernels.Kernel`` with ``values`` the sampled + values of ``params``; e.g. ``lambda log_var, log_ell: jnp.exp(log_var) + * tinygp.kernels.Matern52(scale=jnp.exp(log_ell))``. The builder owns + the parameterisation (log space, a sum of kernels, an anisotropic + metric), so anything tinygp expresses is a kernel term. A kernel + object itself is a fixed kernel (``params`` must be empty). + params : sequence of Parameter + The hyperparameters ``build`` consumes, in order; see + :func:`kernel_params`. Pass the same objects to several ``kernel`` + calls to share hyperparameters between comparisons. + coords : Transform or callable, optional + Coordinate transform of ``x`` the kernel is evaluated in (e.g. angle to + momentum transfer). Default: ``x`` itself. + amplitude : callable or array, optional + ``amplitude(c, *amplitude_values) -> vector a``; the block becomes + ``outer(a, a) * K``. Like the kernel, it sees the *transformed* + coordinate: ``c.x`` is ``coords(x)``. See :func:`constant_amplitude`, + :func:`exp_growth_amplitude`. + amplitude_params : sequence of Parameter, optional + Parameters consumed by ``amplitude``. + jitter : float, optional + ``jitter * mean(diag K)`` is added to the kernel's diagonal *before* + the amplitude scales it, for numerical stability: each point's nugget + is then that fraction of its own variance, so it never dominates a + small variance (a cross section in b/sr, or the small end of a growing + amplitude). + on : optional + See :class:`Term`. + """ + kparams = tuple(params) + if not callable(build) or isinstance(build, Kernel): + if kparams: + raise ValueError( + "a fixed kernel takes no params; pass a builder " + "build(*values) -> kernel to sample its hyperparameters" + ) + fixed = build + build = lambda: fixed # noqa: E731 + _check_arity(build, kparams) + nk = len(kparams) + amplitude_params = tuple(amplitude_params) + + def fn(c, *values): + X = as_2d(c.x) + K = build(*values[:nk])(X, X) + nugget = jitter * jnp.maximum(jnp.mean(jnp.diag(K)), np.finfo(float).tiny) + K = K + nugget * jnp.eye(len(c)) + if amplitude is None: + return K + a = amplitude(c, *values[nk:]) if callable(amplitude) else amplitude + a = jnp.broadcast_to(jnp.asarray(a, dtype=float), (len(c),)) + return jnp.outer(a, a) * K + + return KernelTerm( + fn, + kparams + amplitude_params, + kind="matrix", + on=on, + coords=coords, + constant=( + nk == 0 + and not as_transform(coords).params + and not amplitude_params + and not callable(amplitude) + ), + build=build, + n_kernel=nk, + amplitude=amplitude, + jitter=jitter, + ) + + +def _check_arity(build, params) -> None: + """Fail at declaration, by name, when the builder cannot take the params + (inside jit it would fail on the first density call, naming nothing).""" + try: + sig = inspect.signature(build) + except ValueError: # a builtin without a signature: nothing to check + return + try: + sig.bind(*params) + except TypeError: + raise ValueError( + f"the kernel builder takes {sig} but {len(params)} kernel param(s) " + f"were given {[p.name for p in params]}" + ) from None diff --git a/src/rxmc/transforms.py b/src/rxmc/transforms.py index 9b8483b..ea91b28 100644 --- a/src/rxmc/transforms.py +++ b/src/rxmc/transforms.py @@ -1,21 +1,24 @@ """ Low-level transforms shared across rxmc. -A :class:`Transform` is a numpy-style callable ``fn(a, *values) -> array`` with an +A :class:`Transform` is a ``jax.numpy`` callable ``fn(a, *values) -> array`` with an optional tuple of :class:`~rxmc.params.Parameter` s (``values`` are their sampled values) and optional analytic ``derivative``/``inverse``. The same type serves three roles: -* the comparison-space transform of an :class:`~rxmc.observation.Observation` - (e.g. ``transform=log`` to compare in log space; parameter-free), -* a parametric model-side transform on a - :class:`~rxmc.physical_model.PhysicalModel` (e.g. :func:`scale` for a latent - normalisation, :func:`per_observation_scaling` for one per dataset), -* the coordinate transform of a covariance :class:`~rxmc.covariance.Term` +* the comparison space of a :class:`~rxmc.constraint.Comparison` + (e.g. ``space=log``; parameter-free, so the delta-method errors and the + log-Jacobian are constants), +* a mean transform composed onto a :class:`~rxmc.model.Model` with ``|`` + (e.g. :func:`scale` for a latent normalisation), +* the coordinate transform of a covariance :class:`~rxmc.terms.Term` (e.g. angle to momentum transfer). Anything callable is accepted wherever a ``Transform`` is expected and is wrapped -as a parameter-free transform. Transforms compose with ``|``: ``(f | g)(a)`` is +as a parameter-free transform. Numpy input (the data) is passed through as +numpy, so a coordinate transform of the data alone may use numpy or scipy; +anything applied to a prediction or a parameter is traced and needs +``jax.numpy``. Transforms compose with ``|``: ``(f | g)(a)`` is ``g(f(a))``, parameters concatenated in that order. """ @@ -23,36 +26,29 @@ from typing import Callable, Sequence +import jax +import jax.numpy as jnp import numpy as np from .params import Parameter - -def _unpack(contextual, args): - """Split a composed transform's positional ``args`` into ``(context, a, values)``.""" - if contextual: - context, a, *values = args - return context, a, values - a, *values = args - return None, a, values +__all__ = ["Transform", "as_transform", "identity", "log", "exp", "scale"] class Transform: - """A numpy-style transform with optional parameters. + """A ``jax.numpy`` transform with optional parameters. Parameters ---------- fn : callable - ``fn(a, *values) -> np.ndarray``; when ``contextual`` is ``True``, - ``fn(context, a, *values)`` where ``context`` is whatever the owner - passes (the :class:`~rxmc.observation.Observation` for model transforms). + ``fn(a, *values) -> array``, written with ``jax.numpy`` so that + gradients flow through it. params : sequence of Parameter, optional Parameters whose sampled values are passed as ``*values``. - contextual : bool, optional - Whether ``fn`` takes the owner's context as its first argument. derivative : callable, optional - ``derivative(a, *values) -> np.ndarray``, :math:`\\partial fn/\\partial a` - elementwise. Used for delta-method error propagation and Jacobians. + ``derivative(a, *values) -> array``, :math:`\\partial fn/\\partial a` + elementwise. Used for delta-method error propagation and Jacobians; + when omitted it is taken by automatic differentiation of ``fn``. inverse : Transform or callable, optional The inverse transform (parameter-free transforms only). name : str, optional @@ -64,7 +60,6 @@ def __init__( fn: Callable, params: Sequence[Parameter] = (), *, - contextual: bool = False, derivative: Callable | None = None, inverse=None, name: str | None = None, @@ -76,7 +71,6 @@ def __init__( for p in self.params: if not isinstance(p, Parameter): raise TypeError(f"params must be Parameter objects, got {p!r}") - self.contextual = bool(contextual) self.derivative_fn = derivative self._inverse = inverse self._inverse_factory = None @@ -108,57 +102,44 @@ def inverse(self) -> "Transform | None": return None return as_transform(self._inverse) - def __call__(self, a, *values, context=None): + def __call__(self, a, *values): if len(values) != self.n_params: raise ValueError( f"transform {self.name!r} expects {self.n_params} value(s), " f"got {len(values)}" ) - a = np.asarray(a, dtype=float) - if self.contextual: - return np.asarray(self.fn(context, a, *values), dtype=float) - return np.asarray(self.fn(a, *values), dtype=float) + # data (numpy) stay numpy, so a parameter-free transform of the data + # alone may use numpy even under jit; traced input stays traced + a = a if isinstance(a, jax.Array) else np.asarray(a, dtype=float) + return self.fn(a, *values) - def derivative(self, a, *values, context=None): + def derivative(self, a, *values): """Elementwise derivative :math:`\\partial fn/\\partial a` at ``a``. - Falls back to a central finite difference when no analytic derivative - was supplied. + Falls back to automatic differentiation of ``fn`` (elementwise, so + ``fn`` must act on each entry independently) when no analytic + derivative was supplied. """ - a = np.asarray(a, dtype=float) + a = jnp.asarray(a, dtype=float) if self.derivative_fn is not None: - if self.contextual: - return np.asarray(self.derivative_fn(context, a, *values), dtype=float) - return np.asarray(self.derivative_fn(a, *values), dtype=float) - h = 1e-6 * np.maximum(np.abs(a), 1.0) - fp = self(a + h, *values, context=context) - fm = self(a - h, *values, context=context) - return (fp - fm) / (2 * h) + return jnp.asarray(self.derivative_fn(a, *values)) + d = jax.grad(lambda ai: self.fn(ai, *values)) + return jnp.vectorize(d)(a) def __or__(self, other) -> "Transform": """``(f | g)(a) = g(f(a))`` with parameters ``f.params + g.params``.""" f, g = self, as_transform(other) nf = f.n_params - contextual = f.contextual or g.contextual - - def fn(*args): - context, a, values = _unpack(contextual, args) - b = f(a, *values[:nf], context=context) - return g(b, *values[nf:], context=context) - - def derivative(*args): - context, a, values = _unpack(contextual, args) - b = f(a, *values[:nf], context=context) - return g.derivative(b, *values[nf:], context=context) * f.derivative( - a, *values[:nf], context=context - ) + + def fn(a, *values): + return g(f(a, *values[:nf]), *values[nf:]) + + def derivative(a, *values): + b = f(a, *values[:nf]) + return g.derivative(b, *values[nf:]) * f.derivative(a, *values[:nf]) out = Transform( - fn, - f.params + g.params, - contextual=contextual, - derivative=derivative, - name=f"{f.name}|{g.name}", + fn, f.params + g.params, derivative=derivative, name=f"{f.name}|{g.name}" ) if not (f.params or g.params): # lazy: composing eagerly would recurse for mutually inverse pairs @@ -196,22 +177,23 @@ def _identity(a): def _safe_log(a): - """``log(a)`` for an ndarray ``a``, ``-inf`` where ``a <= 0`` (no warnings).""" - out = np.full(np.shape(a), -np.inf, dtype=float) + """``log(a)``, ``-inf`` where ``a <= 0``. + + The inner ``where`` keeps the gradient finite at the points the outer one + discards. + """ pos = a > 0 - out[pos] = np.log(a[pos]) - return out + return jnp.where(pos, jnp.log(jnp.where(pos, a, 1.0)), -jnp.inf) def _reciprocal(a): - with np.errstate(divide="ignore"): - return 1.0 / a + return 1.0 / a -identity = Transform(_identity, derivative=np.ones_like, name="identity") +identity = Transform(_identity, derivative=jnp.ones_like, name="identity") identity._inverse = identity -exp = Transform(np.exp, derivative=np.exp, name="exp") +exp = Transform(jnp.exp, derivative=jnp.exp, name="exp") log = Transform(_safe_log, derivative=_reciprocal, inverse=exp, name="log") """Natural log; ``-inf`` (no warnings) where the argument is not positive.""" exp._inverse = log @@ -223,11 +205,11 @@ def _reciprocal(a): def scale(parameter: Parameter | None = None, log: bool = True, name=None) -> Transform: - r"""A latent multiplicative normalisation :math:`\rho\, y`. + r"""A latent multiplicative normalisation, ``rho * a``. The Kennedy & O'Hagan forward-model scale: it changes the *mean*, not the - covariance, so it belongs on the model - (``PhysicalModel(params, transform=scale())``). + covariance, so it is composed onto the model (``model | scale(rho)``) and + the prediction, not the data, is scaled. Parameters ---------- @@ -243,99 +225,18 @@ def scale(parameter: Parameter | None = None, log: bool = True, name=None) -> Tr if parameter is None: name = name or ("log_rho" if log else "rho") parameter = Parameter( - name, - float, - unit="dimensionless", - latex_name=r"\log{\rho}" if log else r"\rho", + name, unit="dimensionless", latex=r"\log{\rho}" if log else r"\rho" ) if log: return Transform( - lambda a, v: np.exp(v) * a, + lambda a, v: jnp.exp(v) * a, (parameter,), - derivative=lambda a, v: np.full_like(a, np.exp(v)), + derivative=lambda a, v: jnp.full_like(a, jnp.exp(v)), name="scale", ) return Transform( lambda a, v: v * a, (parameter,), - derivative=lambda a, v: np.full_like(a, v), + derivative=lambda a, v: jnp.full_like(a, v), name="scale", ) - - -def _root(observation): - """The identity key of an observation (its root; itself for other objects).""" - return getattr(observation, "identity", observation) - - -def per_observation_scaling( - observations, parameters=None, log: bool = True, prefix: str | None = None -) -> Transform: - r"""One latent normalisation :math:`\rho_i` per dataset, routed by identity. - - Contextual: when the owning model is evaluated on observation :math:`i` - (matched by identity of ``obs.identity``, so masked views made with - :meth:`~rxmc.observation.Observation.masked` route to their root's scale), - the prediction is scaled by :math:`\rho_i`. Parameters are ordered as - ``observations``. - - Parameters - ---------- - observations : sequence of Observation - The datasets, each assigned one scale parameter. - parameters : sequence of Parameter, optional - One per observation. Defaults to ``{prefix}_{i}``. - log : bool, optional - Sample :math:`\log\rho_i` (default) or :math:`\rho_i`. - prefix : str, optional - Default-parameter name prefix; ``log_rho``/``rho`` by ``log``. - """ - observations = list(observations) - index = {id(_root(o)): i for i, o in enumerate(observations)} - if len(index) != len(observations): - raise ValueError("observations must be distinct objects (routing by identity)") - if prefix is None: - prefix = "log_rho" if log else "rho" - if parameters is None: - parameters = [ - Parameter( - f"{prefix}_{i}", - float, - unit="dimensionless", - latex_name=(rf"\log{{\rho_{{{i}}}}}" if log else rf"\rho_{{{i}}}"), - ) - for i in range(len(observations)) - ] - parameters = tuple(parameters) - if len(parameters) != len(observations): - raise ValueError("need exactly one parameter per observation") - - def _value(context, values): - if context is None: - raise ValueError( - "per_observation_scaling is contextual: evaluate it through a " - "PhysicalModel, or pass context=observation" - ) - i = index.get(id(_root(context))) - if i is None: - raise KeyError( - "observation was not registered with this per_observation_scaling" - ) - v = values[i] - return np.exp(v) if log else v - - def fn(context, a, *values): - return _value(context, values) * a - - def derivative(context, a, *values): - return np.full_like(a, _value(context, values)) - - t = Transform( - fn, - parameters, - contextual=True, - derivative=derivative, - name="per_observation_scaling", - ) - t._keepalive = observations # routing is id()-keyed: keep the objects alive - return t diff --git a/src/rxmc/units.py b/src/rxmc/units.py new file mode 100644 index 0000000..a12af7e --- /dev/null +++ b/src/rxmc/units.py @@ -0,0 +1,99 @@ +""" +The unit contract, without a unit library. + +Cross sections are stored internally in b/sr (:data:`XS_UNIT`); ``jitr`` +reports cross sections and the Rutherford cross section in mb/sr +(:data:`RUTHERFORD_UNIT`), so model outputs are divided by :data:`MB_PER_B`. +Angles are stored in radians. + +Measurement unit labels come from a small fixed vocabulary: ``x4i3`` converts +every EXFOR cross section to barns while parsing and ``exfor_tools`` labels the +result ``"barns/ster"``, ``"b"`` or ``"unitless"``. :func:`parse_unit` maps +that vocabulary (plus the obvious spellings) to a factor into the internal +unit and a quantity kind, and rejects anything else loudly. +""" + +from __future__ import annotations + +import numpy as np + +__all__ = [ + "DEFAULT_LMAX", + "XS_UNIT", + "RUTHERFORD_UNIT", + "MB_PER_B", + "parse_unit", + "check_angle_grid", +] + +#: Default maximum partial wave for the reaction solvers. +DEFAULT_LMAX = 20 + +#: Internal cross-section unit: every ``y`` in b/sr. +XS_UNIT = "b/sr" + +#: Unit ``jitr`` reports cross sections (and the Rutherford cross section) in. +RUTHERFORD_UNIT = "mb/sr" + +#: Millibarn per barn; divides ``jitr`` output to land in :data:`XS_UNIT`. +MB_PER_B = 1000.0 + +# label (lower case, no spaces) -> (factor into the internal unit, kind) +_UNITS = { + # differential cross sections, internal unit b/sr + "barns/ster": (1.0, "differential"), + "barn/steradian": (1.0, "differential"), + "b/sr": (1.0, "differential"), + "millibarn/steradian": (1e-3, "differential"), + "mb/sr": (1e-3, "differential"), + "microbarn/steradian": (1e-6, "differential"), + "micro-b/sr": (1e-6, "differential"), + "ub/sr": (1e-6, "differential"), + # integral cross sections, internal unit b + "barns": (1.0, "integral"), + "barn": (1.0, "integral"), + "b": (1.0, "integral"), + "millibarn": (1e-3, "integral"), + "mb": (1e-3, "integral"), + "microbarn": (1e-6, "integral"), + "micro-b": (1e-6, "integral"), + "ub": (1e-6, "integral"), + # ratios and analysing powers + "no-dim": (1.0, "dimensionless"), + "unitless": (1.0, "dimensionless"), + "dimensionless": (1.0, "dimensionless"), + "": (1.0, "dimensionless"), +} + + +def parse_unit(label: str) -> tuple[float, str]: + """``(factor, kind)`` for a measurement unit label. + + ``factor`` multiplies a value in ``label`` to give the internal unit of its + ``kind``: b/sr for ``"differential"``, b for ``"integral"``, and 1 for + ``"dimensionless"``. Matching ignores case and spaces. + + Raises + ------ + ValueError + For a label outside the vocabulary, listing what is accepted. + """ + key = "".join(str(label).split()).lower() + try: + return _UNITS[key] + except KeyError: + raise ValueError( + f"unknown unit label {label!r}; accepted labels are " + f"{sorted(k for k in _UNITS if k)}" + ) from None + + +def check_angle_grid(angles_rad: np.ndarray, name: str) -> None: + """Reject a grid that is not 1-D, not finite, or not inside ``[0, pi]`` radians.""" + angles_rad = np.asarray(angles_rad) + if angles_rad.ndim != 1: + raise ValueError(f"{name} must be 1D, is {angles_rad.ndim}D") + if not np.all(np.isfinite(angles_rad)): + raise ValueError(f"{name} must be finite") + if angles_rad.size and (angles_rad.min() < 0 or angles_rad.max() > np.pi): + raise ValueError(f"{name} must be on [0, pi] radians") diff --git a/src/rxmc/walker.py b/src/rxmc/walker.py deleted file mode 100644 index 2c76b52..0000000 --- a/src/rxmc/walker.py +++ /dev/null @@ -1,272 +0,0 @@ -""" -Walker: end-to-end Gibbs-style MCMC for Bayesian calibration. - -:class:`Walker` orchestrates one :class:`~rxmc.param_sampling.Sampler` for the -physical-model parameters and optionally several samplers for parametric -likelihood parameters, alternating between them in a Gibbs framework. It is -intended for smaller-scale prototyping and validation problems; for large -production calibrations prefer :class:`~rxmc.config.CalibrationConfig` with -an external sampler. -""" - -import numpy as np - -from .evidence import Evidence -from .param_sampling import Sampler - - -class Walker: - """Gibbs-style MCMC coordinator for a Bayesian calibration problem. - - Manages one sampler for the physical-model parameters and, optionally, - per-constraint samplers for parametric likelihood parameters. The samplers - alternate in a Gibbs framework: model parameters are updated with the - likelihood parameters held fixed, then each set of likelihood parameters is - updated with the model parameters held fixed. - - Parameters - ---------- - model_sampler : Sampler - Sampler for the physical-model parameters. - evidence : Evidence - Evidence object containing the observations and likelihood models. - likelihood_samplers : list of Sampler, optional - One sampler per entry in ``evidence.parametric_constraints``. - rng : np.random.Generator, optional - Random number generator. Defaults to ``default_rng(42)``. - likelihood_scaling : float, optional - Tempering factor applied to the log likelihood (never the prior) in - both the model block and the Gibbs conditionals, mirroring - :class:`~rxmc.config.CalibrationConfig`. Defaults to ``1.0``. - - Raises - ------ - ValueError - If the physical-model parameters in *evidence* and *model_sampler* do - not match. - ValueError - If the number of *likelihood_samplers* does not equal the number of - parametric constraints in *evidence*. - ValueError - If any likelihood sampler's parameters do not match those of the - corresponding parametric constraint. - """ - - def __init__( - self, - model_sampler: Sampler, - evidence: Evidence, - likelihood_samplers: list[Sampler] | None = None, - rng: np.random.Generator | None = None, - likelihood_scaling: float | None = None, - ): - self.model_sampler = model_sampler - self.likelihood_samplers = likelihood_samplers or [] - self.evidence = evidence - self.likelihood_scaling = ( - 1.0 if likelihood_scaling is None else float(likelihood_scaling) - ) - self.rng = rng if rng is not None else np.random.default_rng(42) - - self.gibbs_sampling = len(self.likelihood_samplers) > 0 - - if self.evidence.model_params != self.model_sampler.params: - raise ValueError( - "Inconsistent physical model parameters between " - "'evidence' and 'model_sampler'" - ) - - if len(self.likelihood_samplers) != len(self.evidence.parametric_constraints): - raise ValueError( - "The lists 'likelihood_samplers' and " - "'evidence.parametric_constraints' must correspond!" - ) - for i, conf in enumerate(self.likelihood_samplers): - constraint = self.evidence.parametric_constraints[i] - if list(constraint.params) != list(conf.params): - raise ValueError( - "Inconsistent likelihood model parameters " - f"between 'likelihood_samplers[{i}]' and " - f"'evidence.parametric_constraints[{i}]'" - ) - - def run_model_batch(self, n_steps, x0, likelihood_params=None, burn=False): - """Sample model parameters for fixed likelihood parameters. - - Parameters - ---------- - n_steps : int - Number of MCMC steps. - x0 : np.ndarray - Starting location for the model parameters. - likelihood_params : list of tuple, optional - Fixed values of the likelihood parameters for each parametric - constraint. Defaults to ``[]``. - burn : bool, optional - If ``True``, treat as burn-in (samples are not recorded). - """ - likelihood_params = likelihood_params or [] - self.model_sampler.sample( - n_steps, - x0, - self.rng, - lambda x: self.log_posterior(x, likelihood_params), - burn=burn, - ) - - def run_likelihood_batches( - self, n_steps, starting_locations, model_params, burn=False - ): - """Sample each set of likelihood parameters for fixed model parameters. - - Parameters - ---------- - n_steps : int - Number of MCMC steps per likelihood sampler. - starting_locations : list of np.ndarray - Starting locations for each likelihood sampler. - model_params : tuple - Fixed physical-model parameter values. - burn : bool, optional - If ``True``, treat as burn-in (samples are not recorded). - """ - wmll = self.evidence.weighted_marginal_log_likelihood - scaling = self.likelihood_scaling - for i, sampler in enumerate(self.likelihood_samplers): - constraint = self.evidence.parametric_constraints[i] - ym = constraint.predict(*model_params) - - def log_posterior_lm(x, sampler=sampler, i=i, ym=ym): - # prior first: an out-of-support proposal never pays for the - # likelihood (matches CalibrationConfig.conditional_posterior) - lp = float(np.squeeze(sampler.prior.logpdf(x))) - if not np.isfinite(lp): - return -np.inf - ll = float(np.squeeze(wmll(i, ym, *np.atleast_1d(x)))) - return lp + scaling * ll - - x0 = starting_locations[i] - sampler.sample(n_steps, x0, self.rng, log_posterior_lm, burn=burn) - - def log_likelihood(self, model_params, likelihood_params): - """``likelihood_scaling * evidence.log_likelihood(...)``.""" - return self.likelihood_scaling * self.evidence.log_likelihood( - model_params, likelihood_params - ) - - def log_posterior(self, model_params, likelihood_params): - """Log posterior; ``-inf`` without evaluating the likelihood (and - hence the physical model) when the prior is not finite.""" - lp = self.log_prior(model_params, likelihood_params) - if not np.isfinite(lp): - return -np.inf - return lp + self.log_likelihood(model_params, likelihood_params) - - def log_prior(self, model_params, likelihood_params): - """Log prior probability of model and likelihood parameters. - - Parameters - ---------- - model_params : tuple - Physical-model parameter values. - likelihood_params : list of tuple - One tuple of likelihood parameter values per parametric constraint. - - Returns - ------- - float - Sum of log prior densities for model and likelihood parameters. - """ - lp = self.model_sampler.prior.logpdf(model_params) - lp += sum( - lm.prior.logpdf(likelihood_params[i]) - for i, lm in enumerate(self.likelihood_samplers) - ) - return float(np.squeeze(lp)) - - def walk( - self, - n_steps: int, - burnin: int = 0, - batch_size: int = None, - verbose: bool = True, - ): - """Run the full MCMC chain. - - Updates the internal state of ``model_sampler`` and each entry of - ``likelihood_samplers`` with the accumulated chain, log posteriors, - and acceptance statistics. - - Parameters - ---------- - n_steps : int - Total number of active (post-burn-in) steps. - burnin : int, optional - Number of burn-in steps discarded before recording. - Defaults to ``0``. - batch_size : int, optional - Steps per batch. If ``None`` the entire chain is one batch. - verbose : bool, optional - Print batch completion messages. Defaults to ``True``. - """ - if batch_size is not None: - rem_burn = burnin % batch_size - n_burn_batches = burnin // batch_size - burn_batches = n_burn_batches * [batch_size] + (rem_burn > 0) * [rem_burn] - - rem = n_steps % batch_size - n_full_batches = n_steps // batch_size - batches = n_full_batches * [batch_size] + (rem > 0) * [rem] - else: - batches = [n_steps] - burn_batches = [burnin] - - if burnin == 0: - burn_batches = [] - - for i, steps_in_batch in enumerate(burn_batches): - self._run_batch(steps_in_batch, burn=True) - if verbose: - print(self._batch_message(i, len(burn_batches), steps_in_batch, True)) - - for i, steps_in_batch in enumerate(batches): - self._run_batch(steps_in_batch, burn=False) - if verbose: - print(self._batch_message(i, len(batches), steps_in_batch, False)) - - def _run_batch(self, steps: int, burn: bool) -> None: - """One Gibbs sweep: the model block, then each likelihood block.""" - self.run_model_batch( - steps, - self.model_sampler.state, - [sampler.state for sampler in self.likelihood_samplers], - burn=burn, - ) - if self.gibbs_sampling: - self.run_likelihood_batches( - steps, - [sampler.state for sampler in self.likelihood_samplers], - self.model_sampler.state, - burn=burn, - ) - - def _batch_message(self, index: int, n_batches: int, steps: int, burn: bool): - """Progress line for a batch. - - Burn-in batches are not recorded, so no acceptance fraction is - available for them and none is printed. - """ - if burn: - return f"Burn-in batch {index + 1}/{n_batches} completed, {steps} steps." - msg = ( - f"Batch: {index + 1}/{n_batches} completed, {steps} steps. " - f"\n Model parameter acceptance fraction: " - f"{self.model_sampler.most_recent_batch_acceptance_fraction():.3f}" - ) - if self.gibbs_sampling: - fractions = [ - sampler.most_recent_batch_acceptance_fraction() - for sampler in self.likelihood_samplers - ] - msg += f"\n Likelihood parameter acceptance fractions: {fractions}" - return msg diff --git a/test/conftest.py b/test/conftest.py deleted file mode 100644 index 1056006..0000000 --- a/test/conftest.py +++ /dev/null @@ -1,6 +0,0 @@ -"""Make the shared test helpers importable under any pytest import mode.""" - -import sys -from pathlib import Path - -sys.path.insert(0, str(Path(__file__).parent)) diff --git a/test/helpers.py b/test/helpers.py index 90eb5dc..67afbd2 100644 --- a/test/helpers.py +++ b/test/helpers.py @@ -1,22 +1,269 @@ -"""Shared helpers for the test suite.""" +"""Shared helpers for the test suite: dense references built by hand. +``STUDY_LEGEND`` and :func:`study_form` build the error-model ladder of the +motivating study (elastic alpha + Ca scattering data with no reported +uncertainties, compared in log space). The ladder is *defined* for users in +the table of recipe 18 (``docs/recipes.md``); the legend here is the test +suite's copy of that table, kept identical so the tests and the docs cannot +drift. +""" + +from dataclasses import dataclass + +import jax.numpy as jnp import numpy as np +import tinygp + +# sklearn's kernels are the independent dense reference for the tinygp terms +from sklearn.gaussian_process.kernels import RBF, Matern + +from rxmc import Parameter +from rxmc.terms import ( + Term, + constant_amplitude, + exp_growth, + exp_growth_amplitude, + kernel, + kernel_params, + noise, + offset, + proportional_error, + systematic, + x_basis, +) + +# ---------------------------------------------------------------------------- +# tinygp kernel builders parameterised as sklearn derives them +# ---------------------------------------------------------------------------- + +#: sklearn's default length-scale bounds, in the log space the parameter lives in +LOG_LENGTH_BOUNDS = (np.log(1e-5), np.log(1e5)) + + +def matern52(prefix="discrepancy"): + """``(build, params)``: a Matern-5/2 kernel in a log length scale. + + The parameter is named and bounded as sklearn's ``Matern(nu=2.5)`` derives + it (``_length_scale``), so the problems these tests compile keep + their columns. + """ + params = kernel_params(["length_scale"], [LOG_LENGTH_BOUNDS], prefix=prefix) + return (lambda log_ell: tinygp.kernels.Matern52(scale=jnp.exp(log_ell))), params + + +def rbf(prefix="discrepancy"): + """``(build, params)``: a squared-exponential kernel in a log length scale.""" + params = kernel_params(["length_scale"], [LOG_LENGTH_BOUNDS], prefix=prefix) + return (lambda log_ell: tinygp.kernels.ExpSquared(scale=jnp.exp(log_ell))), params + -from rxmc.covariance import StackContext -from rxmc.likelihood_model import log_likelihood, mahalanobis_distance_sqr_cholesky +# ---------------------------------------------------------------------------- +# Dense references +# ---------------------------------------------------------------------------- -def make_ctx(x, y, ym, supports) -> StackContext: - """Build a StackContext from stacked arrays and block supports.""" - return StackContext( - x=np.asarray(x), - y=np.asarray(y), - ym=np.asarray(ym), - supports=tuple(np.asarray(s, dtype=int) for s in supports), - ) +def mahalanobis(y, ym, cov): + """``(d2, logdet)`` of a dense covariance by a numpy Cholesky factorisation.""" + L = np.linalg.cholesky(np.asarray(cov, dtype=float)) + z = np.linalg.solve(L, np.asarray(y, dtype=float) - np.asarray(ym, dtype=float)) + return float(z @ z), float(2.0 * np.sum(np.log(np.diag(L)))) def manual_mvn_loglike(y, ym, cov): """Reference dense multivariate-normal log likelihood.""" - d2, logdet = mahalanobis_distance_sqr_cholesky(y, ym, cov) - return log_likelihood(d2, logdet, len(y)) + d2, logdet = mahalanobis(y, ym, cov) + return -0.5 * (d2 + logdet + len(y) * np.log(2 * np.pi)) + + +def assemble_dense(terms, x, y, ym, values=(), rows=None): + """Reference assembly of terms into a dense covariance over the whole stack. + + ``values`` is one tuple of sampled values per term, in ``terms`` order (an + empty tuple for a term without parameters). ``rows`` is one index array + per term giving the stacked rows it applies to; ``None`` means every term + covers the whole stack. This is the dense reference the structured + covariance is checked against. + """ + x, y = np.asarray(x), np.asarray(y, dtype=float) + ym = None if ym is None else np.asarray(ym, dtype=float) + n = len(y) + values = tuple(values) if values else tuple(() for _ in terms) + rows = tuple(rows) if rows is not None else tuple(np.arange(n) for _ in terms) + if not len(values) == len(rows) == len(terms): + raise ValueError("one value tuple and one row array per term") + Sigma = np.zeros((n, n)) + for term, v, r in zip(terms, values, rows): + r = np.asarray(r, dtype=int) + out = term.value(x[r], y[r], None if ym is None else ym[r], *v) + if term.kind == "diag": + Sigma[r, r] += out**2 + elif term.kind == "mode": + Sigma[np.ix_(r, r)] += np.outer(out, out) + else: + Sigma[np.ix_(r, r)] += out + return Sigma + + +def index_params(terms): + """``(params, gathers)``: unique parameters by identity, first seen, and one + gather array per term. A stand-in for ``ParameterIndex.add_all``.""" + params, slot = [], {} + gathers = [] + for t in terms: + g = [] + for p in t.params: + if id(p) not in slot: + slot[id(p)] = len(params) + params.append(p) + g.append(slot[id(p)]) + gathers.append(np.asarray(g, dtype=int)) + return tuple(params), gathers + + +# ---------------------------------------------------------------------------- +# The alpha + Ca error-model ladder +# ---------------------------------------------------------------------------- + +#: Label -> what the error model is; the same table as recipe 18 in +#: docs/recipes.md. All forms are covariances of the residual ``y - ym`` in +#: log space unless stated; ``theta`` is the scattering angle in radians and +#: ``u = theta / pi`` its normalised form. +STUDY_LEGEND = { + "L0": "constant noise: sigma = err on every point", + "E0": "fractional noise in linear space: sigma_i = err * ym_i", + "L1": "noise growing with angle: sigma(theta) = err * exp(slope * u)", + "L2": "L0 plus one correlated mode proportional to angle: sys * u", + "L2n": "L0 plus a free correlated offset mode: sys * 1 (in log space, a " + "normalisation)", + "L12": "L1 plus the angle mode of L2", + "Lgp": "L0 plus a Matérn(5/2) Gaussian process in u with constant amplitude", + "Lgpn": "L0 plus the Gaussian process with an angle-growing amplitude", + "LKp": "noise, an offset mode, and an RBF Gaussian process in momentum transfer " + "q = 2 k sin(theta/2) with amplitude A q^(r/2)", + "custom": "the L1 form written as a direct two-parameter Term", +} + + +@dataclass +class StudyForm: + label: str + description: str + terms: list + values: list # one tuple per term + dense: np.ndarray # the hand-built reference covariance + + +def study_form(label, x, y, ym, X=np.pi, k=2.7) -> StudyForm: + """Build the labelled form on the grid ``x`` (radians) with data ``y``, ``ym``.""" + err, slope, sys, amp, ell = 0.05, 1.3, 0.04, 0.2, 0.3 + log_err, log_slope = Parameter("log_err"), Parameter("log_err_slope") + log_sys, log_amp = Parameter("log_sys"), Parameter("log_amp") + n, u = len(x), x / X + eye = np.eye(n) + L0 = noise(log_err) + if label == "L0": + return StudyForm( + label, STUDY_LEGEND[label], [L0], [(np.log(err),)], err**2 * eye + ) + if label == "E0": + t = proportional_error(log_err) + return StudyForm( + label, STUDY_LEGEND[label], [t], [(np.log(err),)], np.diag((err * ym) ** 2) + ) + if label == "L1": + t = noise(log_err, basis=exp_growth(X), basis_params=(log_slope,)) + sigma = err * np.exp(slope * u) + return StudyForm( + label, STUDY_LEGEND[label], [t], [(np.log(err), slope)], np.diag(sigma**2) + ) + if label == "L2": + terms = [L0, systematic(log_sys, basis=x_basis(X))] + dense = err**2 * eye + sys**2 * np.outer(u, u) + return StudyForm( + label, STUDY_LEGEND[label], terms, [(np.log(err),), (np.log(sys),)], dense + ) + if label == "L2n": + terms = [L0, offset(parameter=log_sys)] + dense = err**2 * eye + sys**2 * np.ones((n, n)) + return StudyForm( + label, STUDY_LEGEND[label], terms, [(np.log(err),), (np.log(sys),)], dense + ) + if label == "L12": + terms = [ + noise(log_err, basis=exp_growth(X), basis_params=(log_slope,)), + systematic(log_sys, basis=x_basis(X)), + ] + sigma = err * np.exp(slope * u) + dense = np.diag(sigma**2) + sys**2 * np.outer(u, u) + return StudyForm( + label, + STUDY_LEGEND[label], + terms, + [(np.log(err), slope), (np.log(sys),)], + dense, + ) + if label == "Lgp": + gp = kernel( + *matern52("gp"), + coords=lambda x: x / X, + amplitude=constant_amplitude, + amplitude_params=(log_amp,), + jitter=0.0, + ) + dense = err**2 * eye + amp**2 * Matern(ell, nu=2.5)(u[:, None]) + return StudyForm( + label, + STUDY_LEGEND[label], + [L0, gp], + [(np.log(err),), (np.log(ell), np.log(amp))], + dense, + ) + if label == "Lgpn": + gp = kernel( + *matern52(), + coords=lambda x: x / X, + amplitude=exp_growth_amplitude(1.0), + amplitude_params=(log_amp, log_slope), + jitter=0.0, + ) + a = amp * np.exp(slope * u) + dense = err**2 * eye + np.outer(a, a) * Matern(ell, nu=2.5)(u[:, None]) + return StudyForm( + label, + STUDY_LEGEND[label], + [L0, gp], + [(np.log(err),), (np.log(ell), np.log(amp), slope)], + dense, + ) + if label == "LKp": + log_b, log_s, r_pow = Parameter("log_b"), Parameter("log_s"), Parameter("r") + b, s, lq, r = 0.05, 0.05, 1.2, 0.8 + q = 2.0 * k * np.sin(x / 2) + gp = kernel( + *rbf("gpq"), + coords=lambda x: 2.0 * k * jnp.sin(x / 2), + amplitude=lambda c, lA, r: jnp.exp(lA) * c.x ** (r / 2), + amplitude_params=(log_amp, r_pow), + jitter=0.0, + ) + a = amp * q ** (r / 2) + dense = ( + b**2 * eye + s**2 * np.ones((n, n)) + np.outer(a, a) * RBF(lq)(q[:, None]) + ) + return StudyForm( + label, + STUDY_LEGEND[label], + [noise(log_b), offset(parameter=log_s), gp], + [(np.log(b),), (np.log(s),), (np.log(lq), np.log(amp), r)], + dense, + ) + if label == "custom": + e, sl = Parameter("e"), Parameter("l") + t = Term( + lambda c, e, l: jnp.exp(e) * jnp.exp(l * c.x / np.pi), (e, sl), kind="diag" + ) + sigma = err * np.exp(slope * u) + return StudyForm( + label, STUDY_LEGEND[label], [t], [(np.log(err), slope)], np.diag(sigma**2) + ) + raise KeyError(label) diff --git a/test/recipes/common.py b/test/recipes/common.py new file mode 100644 index 0000000..3ae251f --- /dev/null +++ b/test/recipes/common.py @@ -0,0 +1,78 @@ +"""Small synthetic problems shared by the recipe tests.""" + +import numpy as np +from scipy import stats + +from rxmc import Comparison, Constraint, Dataset, Model, Parameter, Problem + +X = np.linspace(0.5, 2.5, 8) +TRUE = (2.0, 1.0) + + +def line(prior_scale=5.0): + """``y = m x + b`` with wide normal priors on both parameters.""" + m = Parameter("m", prior=stats.norm(0, prior_scale)) + b = Parameter("b", prior=stats.norm(0, prior_scale)) + return Model(lambda x, m, b: m * x + b, [m, b]) + + +def line_data(seed=0, n=8, label="d", err=0.1, **kw): + rng = np.random.default_rng(seed) + x = X[:n] + y = TRUE[0] * x + TRUE[1] + rng.normal(0, err, n) + return Dataset(x, y, err * np.ones(n), label=label, **kw) + + +def line_problem(**constraint_kw): + d = line_data() + return Problem([Constraint([Comparison(d, line())], **constraint_kw)]), d + + +def map_estimate(problem, x0): + """The posterior mode by a quasi-Newton search from ``x0``.""" + from scipy.optimize import minimize + + res = minimize( + lambda t: -problem.log_posterior(t), np.asarray(x0, float), method="L-BFGS-B" + ) + return res.x + + +# ---------------------------------------------------------------------------- +# Exact posteriors for problems whose model is linear in its parameters +# ---------------------------------------------------------------------------- + + +def line_design(x): + """Design matrix of :func:`line` in its parameter order ``(m, b)``.""" + x = np.asarray(x, dtype=float) + return np.column_stack([x, np.ones_like(x)]) + + +def linear_posterior(problem, design=line_design): + """``(mean, cov, log_evidence)`` of a problem linear in its parameters. + + Every constraint must have a constant covariance and independent normal + priors on the parameters (in ``problem.params`` order); ``design(x)`` maps + a constraint's stacked ``x`` to the rows of the design matrix. Wraps + ``oracle.linear_gaussian`` over the active rows of all constraints. + """ + from scipy.linalg import block_diag + + from oracle import linear_gaussian + + theta0 = np.zeros(problem.ndim) + Xs, ys, Ss = [], [], [] + for c in problem.constraints: + Xs.append(design(c.x)[c.active]) + ys.append(c.y[c.active]) + Ss.append(c.matrix(theta0)) + mu0 = np.array([p.prior.mean() for p in problem.params]) + C0 = np.diag([p.prior.var() for p in problem.params]) + return linear_gaussian(np.vstack(Xs), np.concatenate(ys), block_diag(*Ss), mu0, C0) + + +def oracle_samples(problem, n, rng, design=line_design): + """``(n, ndim)`` exact posterior samples, a stand-in for a converged chain.""" + mean, cov, _ = linear_posterior(problem, design) + return np.random.default_rng(rng).multivariate_normal(mean, cov, n) diff --git a/test/recipes/conftest.py b/test/recipes/conftest.py new file mode 100644 index 0000000..fc73c0e --- /dev/null +++ b/test/recipes/conftest.py @@ -0,0 +1,9 @@ +"""Make the recipe helpers and the shared test helpers importable.""" + +import pathlib +import sys + +_here = pathlib.Path(__file__).resolve().parent +for path in (_here, _here.parent): + if str(path) not in sys.path: + sys.path.insert(0, str(path)) diff --git a/test/recipes/oracle.py b/test/recipes/oracle.py new file mode 100644 index 0000000..3969862 --- /dev/null +++ b/test/recipes/oracle.py @@ -0,0 +1,24 @@ +"""Closed-form posterior of a linear-Gaussian model, the fast tier's oracle. + +For ``y = X theta + eps`` with ``eps ~ N(0, Sigma)`` and ``theta ~ N(mu0, C0)`` +the posterior is Gaussian with the mean and covariance below, and the log +evidence is that of ``y ~ N(X mu0, X C0 X^T + Sigma)``. Recipes instantiated +with a linear model and Gaussian terms are checked against this without any +sampling. +""" + +import numpy as np +from scipy import stats + + +def linear_gaussian(X, y, Sigma, mu0, C0): + """``(mean, cov, log_evidence)`` of the posterior over ``theta``.""" + X, y = np.asarray(X, dtype=float), np.asarray(y, dtype=float) + Sigma, C0 = np.atleast_2d(Sigma), np.atleast_2d(C0) + mu0 = np.asarray(mu0, dtype=float) + Si = np.linalg.inv(Sigma) + C0i = np.linalg.inv(C0) + cov = np.linalg.inv(C0i + X.T @ Si @ X) + mean = cov @ (C0i @ mu0 + X.T @ Si @ y) + log_ev = stats.multivariate_normal(X @ mu0, X @ C0 @ X.T + Sigma).logpdf(y) + return mean, cov, float(log_ev) diff --git a/test/recipes/test_recipe_01_fit_with_reported_errors.py b/test/recipes/test_recipe_01_fit_with_reported_errors.py new file mode 100644 index 0000000..7cc7b43 --- /dev/null +++ b/test/recipes/test_recipe_01_fit_with_reported_errors.py @@ -0,0 +1,41 @@ +"""Recipe 1: fit a model to data with reported statistical errors. + +I have x, y, and a statistical error per point, and a model with a few +parameters. I want the posterior. +""" + +import numpy as np +import pytest + +from common import TRUE, line_problem, map_estimate +from oracle import linear_gaussian + + +def test_covariance_is_the_statistical_diagonal_and_chi2_is_the_weighted_sum(): + p, d = line_problem() + theta = np.array(TRUE) + ym = TRUE[0] * d.x + TRUE[1] + assert p.chi2(theta) == pytest.approx(np.sum(((d.y - ym) / d.y_err) ** 2)) + np.testing.assert_allclose(p.constraints[0].matrix(theta), np.diag(d.y_err**2)) + + +def test_names_and_dimension_follow_the_declaration(): + p, _ = line_problem() + assert p.ndim == 2 and p.names == ["m", "b"] + + +def test_map_matches_the_linear_gaussian_oracle(): + p, d = line_problem() + Xd = np.column_stack([d.x, np.ones_like(d.x)]) + mean, cov, _ = linear_gaussian( + Xd, d.y, np.diag(d.y_err**2), [0.0, 0.0], 25.0 * np.eye(2) + ) + np.testing.assert_allclose(map_estimate(p, TRUE), mean, atol=1e-4) + + +def test_the_flat_interface_is_all_a_sampler_needs(): + p, _ = line_problem() + p0 = p.sample_prior(4, rng=0) + assert p0.shape == (4, 2) + assert np.all(np.isfinite(p.prior_transform([0.5, 0.5]))) + assert np.isfinite(p.log_posterior(p0[0])) diff --git a/test/recipes/test_recipe_02_unknown_noise.py b/test/recipes/test_recipe_02_unknown_noise.py new file mode 100644 index 0000000..33e5eb6 --- /dev/null +++ b/test/recipes/test_recipe_02_unknown_noise.py @@ -0,0 +1,60 @@ +"""Recipe 2: infer an unknown noise level. + +My data have no usable error bars, or I do not trust them. I want to infer +the noise magnitude alongside the model. +""" + +import numpy as np +import pytest +from scipy import stats + +from common import TRUE, line, line_data +from rxmc import Comparison, Constraint, Parameter, Problem +from rxmc import terms as T + + +def test_statistical_false_replaces_and_default_adds(): + d = line_data() + log_eps = Parameter("log_eps", prior=stats.norm(-2, 2)) + theta = np.array([*TRUE, np.log(0.3)]) + replaced = Problem( + [ + Constraint( + [Comparison(d, line())], terms=[T.noise(log_eps)], statistical=False + ) + ] + ) + added = Problem([Constraint([Comparison(d, line())], terms=[T.noise(log_eps)])]) + np.testing.assert_allclose(np.diag(replaced.constraints[0].matrix(theta)), 0.3**2) + np.testing.assert_allclose( + np.diag(added.constraints[0].matrix(theta)), d.y_err**2 + 0.3**2 + ) + + +def test_prediction_scaled_noise_changes_with_the_model_parameters(): + d = line_data() + log_eps = Parameter("log_eps", prior=stats.norm(-2, 2)) + for averaging in (False, True): + term = T.proportional_error(log_eps, averaging=averaging) + p = Problem( + [Constraint([Comparison(d, line())], terms=[term], statistical=False)] + ) + S1 = p.constraints[0].matrix(np.array([*TRUE, -1.0])) + S2 = p.constraints[0].matrix(np.array([TRUE[0] * 2, TRUE[1], -1.0])) + assert not np.allclose(S1, S2) + + +def test_noise_growing_along_x(): + d = line_data() + log_eps, slope = Parameter("log_eps", prior=stats.norm(-2, 2)), Parameter( + "slope", prior=stats.norm(0, 1) + ) + t = T.noise(log_eps, basis=T.exp_growth(np.pi), basis_params=(slope,)) + p = Problem([Constraint([Comparison(d, line())], terms=[t], statistical=False)]) + assert p.names == ["m", "b", "log_eps", "slope"] + S = p.constraints[0].matrix(np.array([*TRUE, np.log(0.2), 1.0])) + np.testing.assert_allclose(np.diag(S), (0.2 * np.exp(d.x / np.pi)) ** 2) + assert p.log_posterior(np.array([*TRUE, np.log(0.2), 1.0])) == pytest.approx( + p.log_prior([*TRUE, np.log(0.2), 1.0]) + + p.log_likelihood([*TRUE, np.log(0.2), 1.0]) + ) diff --git a/test/recipes/test_recipe_03_reported_systematics.py b/test/recipes/test_recipe_03_reported_systematics.py new file mode 100644 index 0000000..0b7bc41 --- /dev/null +++ b/test/recipes/test_recipe_03_reported_systematics.py @@ -0,0 +1,75 @@ +"""Recipe 3: use the reported systematic errors. + +The measurement reports a fractional normalisation error and an absolute +offset error. I want them in the likelihood as correlated modes. +""" + +from types import SimpleNamespace + +import jitr +import numpy as np +from scipy import stats + +from common import line +from helpers import assemble_dense +from rxmc import Comparison, Constraint, Parameter, Problem, from_measurement +from rxmc import terms as T +from rxmc import transforms as tf + +P_CA = jitr.reactions.ElasticReaction(target=(40, 20), projectile=(1, 1)) + + +def measurement(**kw): + fields = dict( + x=np.array([20.0, 40.0, 60.0]), + y=np.array([3.0, 2.0, 1.0]), + Einc=8.0, + quantity="dXS/dA", + y_units="barns/ster", + statistical_err=np.array([0.1, 0.1, 0.1]), + systematic_norm_err=0.04, + systematic_offset_err=0.05, + subentry="E1234-002", + ) + fields.update(kw) + return SimpleNamespace(**fields) + + +def test_nothing_is_folded_in_silently_and_reported_terms_recover_the_old_covariance(): + d = from_measurement(measurement(), reaction=P_CA) + comp = Comparison(d, line()) + bare = Problem([Constraint([comp])]) + theta = np.array([-0.05, 4.0]) + np.testing.assert_allclose(bare.constraints[0].matrix(theta), np.diag(d.y_err**2)) + terms = comp.reported_terms() + assert [t.kind for t in terms] == ["mode", "mode"] and all( + t.on is comp for t in terms + ) + with_sys = Problem([Constraint([comp], terms=terms)]) + ym = comp.predict(*theta) + old = np.diag(d.y_err**2) + 0.05**2 * np.ones((3, 3)) + 0.04**2 * np.outer(ym, ym) + np.testing.assert_allclose(with_sys.constraints[0].matrix(theta), old) + np.testing.assert_allclose( + assemble_dense([T.statistical(comp.y_err), *terms], d.x, comp.y, ym), old + ) + + +def test_zero_magnitudes_yield_no_terms(): + d = from_measurement( + measurement(systematic_norm_err=0.0, systematic_offset_err=None), reaction=P_CA + ) + assert Comparison(d, line()).reported_terms() == [] + + +def test_delta_method_under_log(): + d = from_measurement(measurement(), reaction=P_CA) + comp = Comparison(d, line(), space=tf.log) + offset, norm = comp.reported_terms() + ym = comp.predict(-0.05, 4.0) + np.testing.assert_allclose(offset.value(d.x, comp.y, ym), 0.05 / d.y) # at the data + np.testing.assert_allclose( + norm.value(d.x, comp.y, ym), 0.04 + ) # at the prediction: constant + log_eps = Parameter("log_eps", prior=stats.norm(-3, 1)) + p = Problem([Constraint([comp], terms=[offset, norm, T.noise(log_eps)])]) + assert np.isfinite(p.log_posterior(np.array([-0.05, 4.0, -3.0]))) diff --git a/test/recipes/test_recipe_04_free_normalisation.py b/test/recipes/test_recipe_04_free_normalisation.py new file mode 100644 index 0000000..35d69fb --- /dev/null +++ b/test/recipes/test_recipe_04_free_normalisation.py @@ -0,0 +1,51 @@ +"""Recipe 4: infer a normalisation or offset the experiment did not report. + +I suspect an unreported normalisation (or background offset) and want its +magnitude as a nuisance parameter. +""" + +import numpy as np +from scipy import stats + +from common import TRUE, line, line_data +from rxmc import Comparison, Constraint, Parameter, Problem +from rxmc import terms as T + + +def test_free_normalisation_adds_one_rank_one_mode(): + d = line_data() + log_eta = Parameter("log_eta", prior=stats.norm(-3, 1)) + p = Problem( + [ + Constraint( + [Comparison(d, line())], terms=[T.normalization(parameter=log_eta)] + ) + ] + ) + assert p.names == ["m", "b", "log_eta"] + theta = np.array([*TRUE, np.log(0.05)]) + ym = TRUE[0] * d.x + TRUE[1] + np.testing.assert_allclose( + p.constraints[0].matrix(theta), np.diag(d.y_err**2) + 0.05**2 * np.outer(ym, ym) + ) + + +def test_free_offset_and_shaped_mode(): + d = line_data() + log_w = Parameter("log_omega", prior=stats.norm(-3, 1)) + log_s = Parameter("log_s", prior=stats.norm(-3, 1)) + p = Problem( + [ + Constraint( + [Comparison(d, line())], + terms=[ + T.offset(parameter=log_w), + T.systematic(log_s, basis=T.x_basis(np.pi)), + ], + ) + ] + ) + theta = np.array([*TRUE, np.log(0.1), np.log(0.2)]) + u = d.x / np.pi + ref = np.diag(d.y_err**2) + 0.01 * np.ones((8, 8)) + 0.04 * np.outer(u, u) + np.testing.assert_allclose(p.constraints[0].matrix(theta), ref) diff --git a/test/recipes/test_recipe_05_share_or_couple.py b/test/recipes/test_recipe_05_share_or_couple.py new file mode 100644 index 0000000..f273a9a --- /dev/null +++ b/test/recipes/test_recipe_05_share_or_couple.py @@ -0,0 +1,91 @@ +"""Recipe 5: share an error model between datasets, or couple them. + +Two datasets. Case B: each has its own independent normalisation +measurement, but I believe the two magnitudes are the same. Case A: both +were normalised against the same uncertain flux, so their errors are +correlated. +""" + +import numpy as np +import pytest +from scipy import stats + +from common import TRUE, line, line_data +from rxmc import Comparison, Constraint, Parameter, Problem +from rxmc import terms as T + + +@pytest.fixture +def two(): + model = line() + c1 = Comparison(line_data(0, 5, "d1"), model) + c2 = Comparison(line_data(1, 6, "d2"), model) + return c1, c2 + + +def test_case_b_two_spellings_agree_and_stay_block_diagonal(two): + c1, c2 = two + log_eta = Parameter("log_eta", prior=stats.norm(-3, 1)) + one = Problem( + [ + Constraint( + [c1, c2], + terms=[ + T.normalization(log_eta, on=c1), + T.normalization(log_eta, on=c2), + ], + ) + ] + ) + split = Problem( + [ + Constraint([c1], terms=[T.normalization(log_eta)]), + Constraint([c2], terms=[T.normalization(log_eta)]), + ] + ) + assert one.ndim == split.ndim == 3 + theta = np.array([*TRUE, np.log(0.05)]) + assert one.log_likelihood(theta) == pytest.approx(split.log_likelihood(theta)) + S = one.constraints[0].matrix(theta) + assert np.all(S[:5, 5:] == 0.0) + + +def test_case_a_couples_the_blocks_and_differs_from_case_b(two): + c1, c2 = two + log_eta = Parameter("log_eta", prior=stats.norm(-3, 1)) + a = Problem([Constraint([c1, c2], terms=[T.normalization(log_eta, on=[c1, c2])])]) + b = Problem( + [ + Constraint( + [c1, c2], + terms=[ + T.normalization(log_eta, on=c1), + T.normalization(log_eta, on=c2), + ], + ) + ] + ) + assert a.ndim == b.ndim + theta = np.array([*TRUE, np.log(0.05)]) + S = a.constraints[0].matrix(theta) + assert np.any(S[:5, 5:] != 0.0) + assert a.log_likelihood(theta) != pytest.approx(b.log_likelihood(theta)) + assert not a.constraints[ + 0 + ].covariance.dense # a mode across blocks stays structured + + +def test_sharing_is_by_object_not_by_name(two): + c1, c2 = two + e1, e2 = Parameter("log_eta", prior=stats.norm()), Parameter( + "log_eta", prior=stats.norm() + ) + with pytest.raises(ValueError, match="duplicate parameter name"): + Problem( + [ + Constraint( + [c1, c2], + terms=[T.normalization(e1, on=c1), T.normalization(e2, on=c2)], + ) + ] + ) diff --git a/test/recipes/test_recipe_06_latent_scale_per_dataset.py b/test/recipes/test_recipe_06_latent_scale_per_dataset.py new file mode 100644 index 0000000..2f4d3fa --- /dev/null +++ b/test/recipes/test_recipe_06_latent_scale_per_dataset.py @@ -0,0 +1,45 @@ +"""Recipe 6: one latent scale per dataset. + +Each dataset has its own unknown normalisation. I want a Kennedy-O'Hagan +scale factor on the model prediction, one per dataset, sampled with the +model parameters. +""" + +import numpy as np +from scipy import stats + +from common import TRUE, line, line_data +from rxmc import Comparison, Constraint, Parameter, Problem +from rxmc import transforms as tf + + +def test_scales_follow_the_model_parameters_and_scale_the_mean(): + model = line() + rhos = [Parameter(f"log_rho_{i}", prior=stats.norm(0, 0.1)) for i in range(2)] + comps = [ + Comparison(line_data(i, 5, f"d{i}"), model | tf.scale(rho)) + for i, rho in enumerate(rhos) + ] + p = Problem([Constraint(comps)]) + assert p.names == ["m", "b", "log_rho_0", "log_rho_1"] + theta = np.array([*TRUE, np.log(1.1), np.log(0.9)]) + pred = p.predict(theta)[0] + x = comps[0].data.x + np.testing.assert_allclose(pred[0], 1.1 * (TRUE[0] * x + TRUE[1])) + np.testing.assert_allclose(pred[1], 0.9 * (TRUE[0] * x + TRUE[1])) + + +def test_masked_view_keeps_the_same_columns(): + model = line() + rho = Parameter("log_rho", prior=stats.norm(0, 0.1)) + c = Constraint([Comparison(line_data(), model | tf.scale(rho))]) + assert Problem([c.masked_where(lambda x: x < 1.5)]).names == Problem([c]).names + + +def test_global_scale_on_every_comparison(): + model = line() + rho = Parameter("log_rho", prior=stats.norm(0, 0.1)) + scaled = model | tf.scale(rho) + comps = [Comparison(line_data(i, 5, f"d{i}"), scaled) for i in range(2)] + p = Problem([Constraint(comps)]) + assert p.names == ["m", "b", "log_rho"] diff --git a/test/recipes/test_recipe_07_gp_discrepancy.py b/test/recipes/test_recipe_07_gp_discrepancy.py new file mode 100644 index 0000000..a1b5ff5 --- /dev/null +++ b/test/recipes/test_recipe_07_gp_discrepancy.py @@ -0,0 +1,172 @@ +"""Recipe 7: absorb model deficiency with a Gaussian process. + +My model is missing physics. I want a smooth correlated discrepancy, in +angle or in momentum transfer, learned from the residuals. +""" + +import jax.numpy as jnp +import numpy as np +import pytest +import tinygp +from scipy import stats + +# sklearn's kernels serve only as the independent dense reference +from sklearn.gaussian_process.kernels import RBF, Matern + +from common import TRUE, line, linear_posterior +from rxmc import Comparison, Constraint, Dataset, KernelTerm, Parameter, Problem +from rxmc import terms as T +from rxmc.predictive import gp_predictive_draws, grid_draws +from rxmc.reactions import momentum_transfer + +X = np.linspace(0.3, 2.5, 12) +LOG_ELL_BOUNDS = [(np.log(1e-5), np.log(1e5))] + + +def matern52(log_ell): + return tinygp.kernels.Matern52(scale=jnp.exp(log_ell)) + + +def sq_exp(log_ell): + return tinygp.kernels.ExpSquared(scale=jnp.exp(log_ell)) + + +def defect_data(seed=0, err=0.05): + """A line with a smooth defect the line cannot follow.""" + rng = np.random.default_rng(seed) + y = TRUE[0] * X + TRUE[1] + 0.3 * np.sin(3 * X) + rng.normal(0, err, len(X)) + return Dataset(X, y, err * np.ones(len(X)), label="d", meta={"k": 2.7}) + + +def test_the_builder_maps_declared_parameters_to_a_tinygp_kernel(): + d = defect_data() + comp = Comparison(d, line()) + log_A = Parameter("log_A", prior=stats.norm(0, 2)) + gp = T.kernel( + matern52, + T.kernel_params(["length_scale"], LOG_ELL_BOUNDS), + on=comp, + coords=lambda x: x / np.pi, + amplitude=T.constant_amplitude, + amplitude_params=(log_A,), + ) + assert isinstance(gp, KernelTerm) + p = Problem([Constraint([comp], terms=[gp])]) + assert p.names == ["m", "b", "discrepancy_length_scale", "log_A"] + # the declared parameter compiles with a uniform prior over its bounds + np.testing.assert_allclose(p.bounds[2], np.log([1e-5, 1e5])) + theta = np.array([*TRUE, np.log(0.4), np.log(0.2)]) + u = (X / np.pi)[:, None] + K = 0.04 * Matern(0.4, nu=2.5)(u) + 1e-10 * np.eye(12) + np.testing.assert_allclose(p.constraints[0].matrix(theta), np.diag(d.y_err**2) + K) + + +def test_momentum_transfer_coordinates_and_a_running_amplitude(): + d = defect_data() + comp = Comparison(d, line()) + log_A = Parameter("log_A", prior=stats.norm(0, 2)) + r = Parameter("r", prior=stats.norm(0, 1)) + q = lambda x: momentum_transfer(x, d.meta["k"]) # noqa: E731 + gp_q = T.kernel( + sq_exp, + T.kernel_params(["length_scale"], LOG_ELL_BOUNDS), + on=comp, + coords=q, + amplitude=lambda c, lA, r: jnp.exp(lA) * c.x ** (r / 2), + amplitude_params=(log_A, r), + ) + p = Problem([Constraint([comp], terms=[gp_q])]) + assert p.names == ["m", "b", "discrepancy_length_scale", "log_A", "r"] + theta = np.array([*TRUE, np.log(2.0), np.log(0.3), 1.5]) + qx = 2 * 2.7 * np.sin(X / 2) + a = 0.3 * qx ** (1.5 / 2) + K = np.outer(a, a) * RBF(2.0)(qx[:, None]) + 1e-10 * np.eye(12) + np.testing.assert_allclose(p.constraints[0].matrix(theta), np.diag(d.y_err**2) + K) + + +def test_the_band_finds_the_kernel_columns_itself(): + d = defect_data() + model = line() + comp = Comparison(d, model) + log_eps = Parameter("log_eps", prior=stats.norm(-3, 1)) + gp = T.kernel(sq_exp, T.kernel_params(["length_scale"], LOG_ELL_BOUNDS), on=comp) + eps = T.noise(log_eps) + p = Problem([Constraint([comp], terms=[eps, gp])]) + # a chain in problem.names order with the nuisance column between the + # model parameters and the kernel hyperparameter + rng = np.random.default_rng(1) + chain = np.column_stack( + [ + TRUE[0] + 0.02 * rng.standard_normal(30), + TRUE[1] + 0.02 * rng.standard_normal(30), + np.full(30, np.log(0.05)), + np.full(30, np.log(0.5)), + ] + ) + x_fine = np.linspace(0.0, 3.0, 50) + pred = model.bind(x_fine, d.meta) + band = gp_predictive_draws(p, gp, pred, x_fine, chain, terms=[gp], rng=0) + assert band.shape == (3, 50) and np.all(np.isfinite(band)) + assert np.all(band[2] > band[0]) + # the discrepancy is mean-zero, so the band is an envelope *about the model*: + # it says where and by how much the model may be wrong, not what the data is + assert np.all((band[0] < line_y(x_fine)) & (line_y(x_fine) < band[2])) + # unconditioned, it is grid_draws with the kernel named: nothing GP-specific + np.testing.assert_allclose( + band, grid_draws(p, pred, x_fine, chain, terms=[gp], rng=0) + ) + # the inferred noise is a function of x too, so a measurement's band exists + full = grid_draws(p, pred, x_fine, chain, terms=[eps, gp], rng=0) + assert full.shape == (3, 50) and np.all(np.isfinite(full)) + # the reported errors exist only at the measured points + with pytest.raises(ValueError, match="reported statistical"): + grid_draws(p, pred, x_fine, chain) + + +def line_y(x): + return TRUE[0] * x + TRUE[1] + + +def test_conditioning_turns_the_band_into_regression_on_the_residuals(): + """``conditioned=True`` is the other object: a data-driven fit on top.""" + d = defect_data() + model = line() + comp = Comparison(d, model) + log_eps = Parameter("log_eps", prior=stats.norm(-3, 1)) + gp = T.kernel(sq_exp, T.kernel_params(["length_scale"], LOG_ELL_BOUNDS), on=comp) + p = Problem([Constraint([comp], terms=[T.noise(log_eps), gp])]) + rng = np.random.default_rng(1) + chain = np.column_stack( + [ + TRUE[0] + 0.02 * rng.standard_normal(30), + TRUE[1] + 0.02 * rng.standard_normal(30), + np.full(30, np.log(0.05)), + np.full(30, np.log(0.5)), + ] + ) + x_fine = np.linspace(0.0, 3.0, 50) + band = gp_predictive_draws( + p, gp, model.bind(x_fine, d.meta), x_fine, chain, + terms=[gp], levels=(16, 84), rng=0, conditioned=True, + ) # fmt: skip + # conditioning pins the discrepancy where there is data and relaxes outside + inside = (x_fine > 0.5) & (x_fine < 2.3) + assert np.median((band[1] - band[0])[inside]) < np.median( + (band[1] - band[0])[~inside] + ) + + +def test_the_discrepancy_relaxes_the_model_parameters_toward_the_truth(): + d = defect_data() + bare = Problem([Constraint([Comparison(d, line())])]) + gp = T.kernel(0.3**2 * tinygp.kernels.ExpSquared(scale=0.5)) + with_gp = Problem([Constraint([Comparison(d, line())], terms=[gp])]) + # both posteriors are exact (linear model, fixed covariances) + mean_bare, cov_bare, _ = linear_posterior(bare) + mean_gp, cov_gp, _ = linear_posterior(with_gp) + bias_bare = np.abs(mean_bare - TRUE) + bias_gp = np.abs(mean_gp - TRUE) + assert np.all(bias_gp < bias_bare) + # and the bare fit is overconfident: its error bars exclude the truth + assert np.any(bias_bare > 3 * np.sqrt(np.diag(cov_bare))) + assert np.all(bias_gp < 3 * np.sqrt(np.diag(cov_gp))) diff --git a/test/recipes/test_recipe_08_sampled_mean_discrepancy.py b/test/recipes/test_recipe_08_sampled_mean_discrepancy.py new file mode 100644 index 0000000..d06225a --- /dev/null +++ b/test/recipes/test_recipe_08_sampled_mean_discrepancy.py @@ -0,0 +1,55 @@ +"""Recipe 8: sample a mean discrepancy explicitly. + +Instead of marginalising the discrepancy, I want to sample an additive +correction with a parametric shape. +""" + +import jax.numpy as jnp +import numpy as np +from scipy import stats + +from common import TRUE, line, line_data +from rxmc import Comparison, Constraint, Model, Parameter, Problem +from rxmc import transforms as tf + + +def test_additive_correction_lists_its_parameters_after_the_model(): + phi = [Parameter(f"c{i}", prior=stats.norm(0, 1)) for i in range(2)] + delta = Model(lambda x, c0, c1: c0 + c1 * x**2, phi) + d = line_data() + p = Problem([Constraint([Comparison(d, line() + delta)])]) + assert p.names == ["m", "b", "c0", "c1"] + theta = np.array([*TRUE, 0.5, -0.1]) + np.testing.assert_allclose( + p.predict(theta)[0][0], TRUE[0] * d.x + TRUE[1] + 0.5 - 0.1 * d.x**2 + ) + + +def test_composition_precedence(): + c0 = Parameter("c0", prior=stats.norm(0, 1)) + rho = Parameter("log_rho", prior=stats.norm(0, 0.1)) + delta = Model(lambda x, c0: c0 * np.ones_like(x), [c0]) + d = line_data() + base = TRUE[0] * d.x + TRUE[1] + sum_scaled = Problem( + [Constraint([Comparison(d, (line() + delta) | tf.scale(rho))])] + ) + model_scaled = Problem( + [Constraint([Comparison(d, (line() | tf.scale(rho)) + delta)])] + ) + np.testing.assert_allclose( + sum_scaled.predict([*TRUE, 0.5, np.log(2.0)])[0][0], 2.0 * (base + 0.5) + ) + np.testing.assert_allclose( + model_scaled.predict([*TRUE, np.log(2.0), 0.5])[0][0], 2.0 * base + 0.5 + ) + + +def test_multiplicative_correction(): + g = Parameter("g", prior=stats.norm(0, 1)) + factor = Model(lambda x, g: jnp.exp(g * x), [g]) + d = line_data() + p = Problem([Constraint([Comparison(d, line() * factor)])]) + np.testing.assert_allclose( + p.predict([*TRUE, 0.3])[0][0], (TRUE[0] * d.x + TRUE[1]) * np.exp(0.3 * d.x) + ) diff --git a/test/recipes/test_recipe_09_likelihood_functional.py b/test/recipes/test_recipe_09_likelihood_functional.py new file mode 100644 index 0000000..45dd125 --- /dev/null +++ b/test/recipes/test_recipe_09_likelihood_functional.py @@ -0,0 +1,22 @@ +"""Recipe 9: choose the likelihood functional. + +I want the same covariance under a different functional of the residual: the +Gaussian (the default), or a pure chi-squared that drops the log-determinant. +""" + +import numpy as np +import pytest + +from common import TRUE, line, line_data +from rxmc import Comparison, Constraint, Problem +from rxmc.likelihood import Chi2 + + +def test_same_covariance_different_functional(): + d = line_data() + gauss = Problem([Constraint([Comparison(d, line())])]) + chi2 = Problem([Constraint([Comparison(d, line())], likelihood=Chi2())]) + theta = np.array(TRUE) + assert chi2.log_likelihood(theta) == pytest.approx(-0.5 * gauss.chi2(theta)) + # the functional adds no parameters + assert chi2.names == gauss.names == ["m", "b"] diff --git a/test/recipes/test_recipe_10_log_space.py b/test/recipes/test_recipe_10_log_space.py new file mode 100644 index 0000000..c7e0880 --- /dev/null +++ b/test/recipes/test_recipe_10_log_space.py @@ -0,0 +1,52 @@ +"""Recipe 10: compare in log space. + +Cross sections span orders of magnitude. I want the Gaussian to live in log +space, with the model still written in physical units. +""" + +import numpy as np +import pytest +from scipy import stats + +from common import TRUE, line, line_data +from rxmc import Comparison, Constraint, Dataset, Parameter, Problem +from rxmc import terms as T +from rxmc import transforms as tf + + +def test_delta_method_and_jacobian(): + d = line_data() + comp = Comparison(d, line(), space=tf.log) + np.testing.assert_allclose(comp.y, np.log(d.y)) + np.testing.assert_allclose(comp.y_err, d.y_err / d.y) + log_eps = Parameter("log_eps", prior=stats.norm(-2, 1)) + p = Problem([Constraint([comp], terms=[T.noise(log_eps)], statistical=False)]) + assert p.log_jacobian() == pytest.approx(-np.sum(np.log(d.y))) + theta = np.array([*TRUE, np.log(0.1)]) + np.testing.assert_allclose(p.predict(theta)[0][0], np.log(TRUE[0] * d.x + TRUE[1])) + + +def test_non_positive_prediction_and_data(): + d = line_data() + p = Problem([Constraint([Comparison(d, line(), space=tf.log)])]) + assert p.log_likelihood([-5.0, 0.0]) == -np.inf and p.chi2([-5.0, 0.0]) == np.inf + neg = Dataset(d.x, d.y - 3.0, d.y_err, label="neg") # negative at the first points + with pytest.raises(ValueError, match="neg"): + Problem([Constraint([Comparison(neg, line(), space=tf.log)])]) + + +def test_constant_noise_in_log_space_is_fractional_noise_in_linear_space(): + d = line_data() + log_eps = Parameter("log_eps", prior=stats.norm(-2, 1)) + p = Problem( + [ + Constraint( + [Comparison(d, line(), space=tf.log)], + terms=[T.noise(log_eps)], + statistical=False, + ) + ] + ) + theta = np.array([*TRUE, np.log(0.1)]) + S = p.constraints[0].matrix(theta) + np.testing.assert_allclose(np.diag(S), 0.01) # constant in log space diff --git a/test/recipes/test_recipe_11_hold_out.py b/test/recipes/test_recipe_11_hold_out.py new file mode 100644 index 0000000..fa780ea --- /dev/null +++ b/test/recipes/test_recipe_11_hold_out.py @@ -0,0 +1,39 @@ +"""Recipe 11: hold out data and score it. + +I want to fit below an angular cut and score the prediction above it, or +compare error models by their held-out predictive density. +""" + +import numpy as np +import pytest +from scipy import stats + +from common import TRUE, line, line_data +from rxmc import Comparison, Constraint, Parameter, Problem +from rxmc import terms as T + + +def test_fit_and_held_out_share_columns_and_partition_the_likelihood(): + d = line_data() + log_eps = Parameter("log_eps", prior=stats.norm(-2, 1)) + c = Constraint([Comparison(d, line())], terms=[T.noise(log_eps)]) + fit = c.masked_where(lambda x: x < 1.5) + held = fit.complement() + pf, ph, pa = Problem([fit]), Problem([held]), Problem([c]) + assert pf.names == ph.names == pa.names + assert set(fit.active).isdisjoint(held.active) + assert sorted([*fit.active, *held.active]) == list(range(d.n)) + theta = np.array([*TRUE, np.log(0.2)]) + assert pf.log_likelihood(theta) + ph.log_likelihood(theta) == pytest.approx( + pa.log_likelihood(theta) + ) + + +def test_a_chain_from_the_fit_scores_the_held_out_problem_directly(): + d = line_data() + c = Constraint([Comparison(d, line())]) + fit = c.masked_where(lambda x: x < 1.5) + pf, ph = Problem([fit]), Problem([fit.complement()]) + samples = pf.sample_prior(5, rng=0) + scores = np.array([ph.log_likelihood(s) for s in samples]) + assert scores.shape == (5,) and np.all(np.isfinite(scores)) diff --git a/test/recipes/test_recipe_12_tempering.py b/test/recipes/test_recipe_12_tempering.py new file mode 100644 index 0000000..0eced1e --- /dev/null +++ b/test/recipes/test_recipe_12_tempering.py @@ -0,0 +1,29 @@ +"""Recipe 12: temper the likelihood. + +I have many points and worry the posterior is overconfident, or I want a +power posterior. +""" + +import numpy as np +import pytest + +from common import TRUE, line_problem, map_estimate +from oracle import linear_gaussian + + +def test_weight_scales_the_likelihood_only(): + p1, _ = line_problem() + pw, _ = line_problem(weight=0.25) + theta = np.array(TRUE) + assert pw.log_likelihood(theta) == pytest.approx(0.25 * p1.log_likelihood(theta)) + assert pw.log_prior(theta) == pytest.approx(p1.log_prior(theta)) + + +def test_tempered_posterior_equals_the_oracle_with_inflated_errors(): + w = 0.25 + pw, d = line_problem(weight=w) + Xd = np.column_stack([d.x, np.ones_like(d.x)]) + mean, _, _ = linear_gaussian( + Xd, d.y, np.diag(d.y_err**2) / w, [0.0, 0.0], 25.0 * np.eye(2) + ) + np.testing.assert_allclose(map_estimate(pw, TRUE), mean, atol=1e-4) diff --git a/test/recipes/test_recipe_13_declare_priors.py b/test/recipes/test_recipe_13_declare_priors.py new file mode 100644 index 0000000..dde9b49 --- /dev/null +++ b/test/recipes/test_recipe_13_declare_priors.py @@ -0,0 +1,68 @@ +"""Recipe 13: declare priors. + +I want each nuisance parameter to carry its own prior, the optical potential +to have a correlated multivariate normal prior, and everything to work with +nested sampling. +""" + +import numpy as np +import pytest +from scipy import stats + +from common import line_data +from rxmc import Comparison, Constraint, Model, Parameter, Problem +from rxmc import terms as T + + +def make(m_kw, b_kw, priors=None, terms=()): + m, b = Parameter("m", **m_kw), Parameter("b", **b_kw) + model = Model(lambda x, m, b: m * x + b, [m, b]) + c = Constraint([Comparison(line_data(), model)], terms=list(terms)) + return Problem([c], priors=priors(model) if priors else ()), model + + +def test_marginal_uniform_and_truncated_marginal(): + p, _ = make( + dict(prior=stats.norm(2, 1), bounds=(0.0, 4.0)), dict(bounds=(0.0, 3.0)) + ) + tn = stats.truncnorm(-2, 2, loc=2, scale=1) + assert p.log_prior([2.5, 1.0]) == pytest.approx(tn.logpdf(2.5) - np.log(3.0)) + assert p.log_prior([2.5, 3.5]) == -np.inf + assert np.all(np.isfinite(p.prior_transform([0.0, 1.0]))) + assert np.all(np.isfinite(p.prior_transform([1.0, 0.0]))) + + +def test_joint_multivariate_normal_over_the_model(): + mu, cov = np.array([2.0, 1.0]), np.array([[0.4, 0.1], [0.1, 0.2]]) + p, model = make( + {}, {}, priors=lambda mdl: [(mdl.params, stats.multivariate_normal(mu, cov))] + ) + assert p.log_prior([2.0, 1.0]) == pytest.approx( + stats.multivariate_normal(mu, cov).logpdf([2.0, 1.0]) + ) + theta = p.prior_transform([0.5, 0.5]) + np.testing.assert_allclose(theta, mu) # the median of the whitening map is the mean + assert p.sample_prior(3, rng=0).shape == (3, 2) + + +def test_every_slot_is_covered_exactly_once(): + with pytest.raises(ValueError, match="'b' has no prior"): + make(dict(prior=stats.norm()), {}) + with pytest.raises(ValueError, match="'m' has its own prior"): + make( + dict(prior=stats.norm()), + {}, + priors=lambda mdl: [(mdl.params, stats.multivariate_normal(np.zeros(2)))], + ) + + +def test_nuisance_parameters_carry_their_own_priors(): + log_eps = Parameter("log_eps", prior=stats.halfnorm(scale=1)) + p, _ = make( + dict(prior=stats.norm(0, 5)), + dict(prior=stats.norm(0, 5)), + terms=[T.noise(log_eps)], + ) + assert p.names[-1] == "log_eps" + assert p.log_prior([1.0, 1.0, -0.5]) == -np.inf # halfnorm support + assert np.isfinite(p.log_prior([1.0, 1.0, 0.5])) diff --git a/test/recipes/test_recipe_14_from_measurement.py b/test/recipes/test_recipe_14_from_measurement.py new file mode 100644 index 0000000..bde5046 --- /dev/null +++ b/test/recipes/test_recipe_14_from_measurement.py @@ -0,0 +1,80 @@ +"""Recipe 14: from an EXFOR measurement to a dataset. + +I have an exfor_tools distribution in mb/sr, or as a ratio to Rutherford, +with its reported errors. I want a dataset in the library's units with +nothing lost. +""" + +from types import SimpleNamespace + +import jitr +import numpy as np +import pytest + +from rxmc import from_measurement +from rxmc.reactions import rutherford + +P_CA = jitr.reactions.ElasticReaction(target=(40, 20), projectile=(1, 1)) +N_CA = jitr.reactions.ElasticReaction(target=(40, 20), projectile=(1, 0)) + + +def measurement(**kw): + fields = dict( + x=np.array([30.0, 60.0]), + y=np.array([500.0, 50.0]), + Einc=12.0, + quantity="dXS/dA", + y_units="mb/sr", + statistical_err=np.array([10.0, 2.0]), + systematic_norm_err=0.05, + systematic_offset_err=1.0, + subentry="E0001-003", + ) + fields.update(kw) + return SimpleNamespace(**fields) + + +def test_units_errors_and_meta(): + d = from_measurement(measurement(), reaction=P_CA) + np.testing.assert_allclose(d.x, np.deg2rad([30.0, 60.0])) + np.testing.assert_allclose(d.y, [0.5, 0.05]) # b/sr + np.testing.assert_allclose(d.y_err, [0.01, 0.002]) + assert d.offset_err == pytest.approx(0.001) # dimensionful: converted + assert d.norm_err == 0.05 # fractional: untouched + assert d.label == "E0001-003" + for key in ("reaction", "Elab", "quantity", "k", "eta"): + assert key in d.meta + + +def test_rutherford_conversion_is_a_per_angle_factor(): + m = measurement() + d = from_measurement(m, reaction=P_CA, quantity="dXS/dRuth") + ruth_b = rutherford(P_CA.kinematics(12.0), np.deg2rad(m.x)) / 1000.0 + np.testing.assert_allclose(d.y, (m.y / 1000.0) / ruth_b) + np.testing.assert_allclose(d.offset_err, (1.0 / 1000.0) / ruth_b) # now an array + back = from_measurement( + measurement( + y=d.y, + quantity="dXS/dRuth", + y_units="no-dim", + statistical_err=d.y_err, + systematic_offset_err=None, + ), + reaction=P_CA, + quantity="dXS/dA", + ) + np.testing.assert_allclose(back.y, m.y / 1000.0) + + +def test_ias_channel_and_failures(): + pn = jitr.reactions.Reaction( + target=(48, 20), projectile=(1, 1), product=(1, 0), residual=(48, 21) + ) + d = from_measurement(measurement(), reaction=pn, ExIAS=6.7) + assert d.meta["ExIAS"] == 6.7 + with pytest.raises(ValueError, match="unknown unit label"): + from_measurement(measurement(y_units="fm^2")) + with pytest.raises(ValueError, match="cannot convert"): + from_measurement(measurement(), reaction=P_CA, quantity="Ay") + with pytest.raises(ValueError, match="charged projectile"): + from_measurement(measurement(), reaction=N_CA, quantity="dXS/dRuth") diff --git a/test/recipes/test_recipe_15_reaction_model_on_any_grid.py b/test/recipes/test_recipe_15_reaction_model_on_any_grid.py new file mode 100644 index 0000000..4982f73 --- /dev/null +++ b/test/recipes/test_recipe_15_reaction_model_on_any_grid.py @@ -0,0 +1,57 @@ +"""Recipe 15: evaluate a reaction model on any grid. + +I want the model on the data angles for the likelihood and on a fine grid +for plotting, with the solver set up once per grid. +""" + +import jitr +import numpy as np +import pytest +from jitr.optical_potentials.potential_forms import thomas_safe, woods_saxon_safe +from jitr.xs.coupled import Potential +from scipy import stats + +from rxmc import Comparison, Constraint, Dataset, Parameter, Problem +from rxmc.reactions import ElasticXS + +MSO = 1.0 / jitr.utils.constants.WAVENUMBER_PION +R = 1.2 * 40 ** (1 / 3) +N_CA = jitr.reactions.ElasticReaction(target=(40, 20), projectile=(1, 0)) + + +def central(r, Vv, Wv, Rv, av): + return -(Vv + 1j * Wv) * woods_saxon_safe(r, Rv, av) + + +def spin_orbit(r, Vso, Rso, aso): + return Vso * MSO**2 * thomas_safe(r, Rso, aso) + + +def test_data_grid_for_the_likelihood_and_a_fine_grid_for_plotting(): + omp = ElasticXS( + "dXS/dA", + central, + spin_orbit, + lambda ws, *x: (tuple(x), (6.0, R, 0.45)), + [Parameter(n, prior=stats.norm(0, 100)) for n in ("Vv", "Wv", "Rv", "av")], + lmax=10, + ) + theta = np.array([48.0, 3.5, R, 0.7]) + x = np.linspace(0.3, 2.5, 5) + meta = {"reaction": N_CA, "Elab": 14.1} + truth = omp.bind(x, meta)(*theta) + d = Dataset(x, truth, 0.05 * truth, label="mock", meta=meta) + p = Problem([Constraint([Comparison(d, omp)])]) + assert p.chi2(theta) == pytest.approx(0.0, abs=1e-20) + # the same model on a fine grid, read back through problem.columns + fine = omp.bind(np.deg2rad(np.linspace(0.5, 179.5, 60)), d.meta) + sample = np.concatenate([theta, [0.0]]) # a chain row with an extra column + y_fine = fine(*sample[p.columns(omp.params)]) + assert y_fine.shape == (60,) and np.all(np.isfinite(y_fine)) and np.all(y_fine > 0) + assert len(omp._cache) == 1 # one basis for both grids + # cross sections are in b/sr: jitr's mb/sr divided by 1000 + ws = omp.workspace(x, meta) + r = ws.r + pot = Potential(central(r, *theta), spin_orbit(r, 6.0, R, 0.45)) + direct = ws.xs(pot).dsdo[0] + np.testing.assert_allclose(truth, direct / 1000.0) diff --git a/test/recipes/test_recipe_16_external_samplers.py b/test/recipes/test_recipe_16_external_samplers.py new file mode 100644 index 0000000..926c67f --- /dev/null +++ b/test/recipes/test_recipe_16_external_samplers.py @@ -0,0 +1,139 @@ +"""Recipe 16: drive the calibration with an external sampler. + +I want to use pocomc, emcee, dynesty, or the black-box-bayes CLI, and read the +chain back without positional arithmetic. +""" + +import dill +import dynesty +import emcee +import jax +import numpy as np +import pocomc +import pytest +from scipy import stats + +from common import TRUE, line_data, line_problem +from rxmc import Comparison, Constraint, Model, Parameter, Problem + + +def test_emcee_uses_sample_prior_and_log_posterior(): + p, _ = line_problem() + p0 = 0.05 * p.sample_prior(16, rng=0) + np.array(TRUE) + sampler = emcee.EnsembleSampler(16, p.ndim, p.log_posterior) + sampler.random_state = np.random.RandomState(1).get_state() + sampler.run_mcmc(p0, 100, progress=False) + samples = sampler.get_chain(discard=40, flat=True) + assert samples.shape == (16 * 60, p.ndim) + # the chain is in problem.names order, so columns() is the only bookkeeping + m = p.columns(p.params[0]) + assert abs(samples[:, m].mean() - TRUE[0]) < 3 * samples[:, m].std() + 0.05 + + +def test_dynesty_uses_log_likelihood_and_prior_transform(): + p, _ = line_problem() + ns = dynesty.NestedSampler( + p.log_likelihood, + p.prior_transform, + p.ndim, + nlive=40, + rstate=np.random.default_rng(0), + ) + ns.run_nested(dlogz=1.0, print_progress=False) + res = ns.results + assert np.isfinite(res.logz[-1]) and res.samples_equal().shape[1] == p.ndim + + +def test_pocomc_samples_the_unit_cube_through_prior_transform(): + p, _ = line_problem() + + def log_likelihood(u): + return p.log_likelihood_batch(p.prior_transform_batch(u)) + + smc = pocomc.Sampler( + pocomc.Prior([stats.uniform(0, 1)] * p.ndim), + log_likelihood, + vectorize=True, + n_effective=128, + n_active=64, + random_state=0, + ) + smc.run(n_total=256, n_evidence=512, progress=False) + u, _, _ = smc.posterior(resample=True) + samples = p.prior_transform_batch(u) + logz, logz_err = smc.evidence() + assert samples.shape[1] == p.ndim and np.isfinite(logz) and logz_err > 0 + m = p.columns(p.params[0]) + assert abs(samples[:, m].mean() - TRUE[0]) < 3 * samples[:, m].std() + 0.05 + + +def test_black_box_bayes_contract_and_dill(): + p, _ = line_problem() + blob = dill.dumps(p) + q = dill.loads(blob) + theta = np.array(TRUE) + assert q.NDIM == p.ndim and q.parameter_names == p.names + assert q.starting_location(3).shape == (3, p.ndim) + assert q.log_posterior(theta) == pytest.approx(p.log_posterior(theta)) + assert q.log_likelihood(theta) == pytest.approx(p.log_likelihood(theta)) + np.testing.assert_allclose( + q.prior_transform([0.3, 0.7]), p.prior_transform([0.3, 0.7]) + ) + np.testing.assert_allclose( + q.log_posterior_batch([theta, theta]), [p.log_posterior(theta)] * 2 + ) + + +def test_log_posterior_evaluates_the_prior_first(): + calls = [] + m, b = Parameter("m", bounds=(0.0, 4.0)), Parameter("b", bounds=(0.0, 4.0)) + + def fn(x, m, b): + # counts evaluations at run time (a plain append would count traces) + jax.debug.callback(lambda: calls.append(1)) + return m * x + b + + p = Problem([Constraint([Comparison(line_data(), Model(fn, [m, b]))])]) + assert p.log_posterior([5.0, 1.0]) == -np.inf and calls == [] + + +# ---------------------------------------------------------------------------- +# Parallel evaluation. JAX is multithreaded, so a fork-started process pool +# (Python's default on Linux) can deadlock; batch with vmap, or spawn. +# ---------------------------------------------------------------------------- + + +_WORKER_PROBLEM = None + + +def _load_problem(blob): + """Pool initializer: unpickle the problem once per worker (dill handles the + closures in models and terms that the standard pickle cannot).""" + global _WORKER_PROBLEM + _WORKER_PROBLEM = dill.loads(blob) + + +def _worker_log_posterior(theta): + return _WORKER_PROBLEM.log_posterior(theta) + + +def test_emcee_vectorised_over_log_posterior_batch(): + p, _ = line_problem() + p0 = np.array(TRUE) + 0.01 * np.random.default_rng(0).standard_normal((16, 2)) + sampler = emcee.EnsembleSampler(16, p.ndim, p.log_posterior_batch, vectorize=True) + sampler.run_mcmc(p0, 50, progress=False) + lp = sampler.get_log_prob(flat=True) + chain = sampler.get_chain(flat=True) + np.testing.assert_allclose(lp[-16:], [p.log_posterior(t) for t in chain[-16:]]) + + +def test_a_spawn_pool_evaluates_a_dill_pickled_problem(): + import multiprocessing + + p, _ = line_problem() + thetas = p.sample_prior(4, rng=0) + ctx = multiprocessing.get_context("spawn") + with ctx.Pool(2, initializer=_load_problem, initargs=(dill.dumps(p),)) as pool: + # each worker compiles its own densities on first use + remote = pool.map(_worker_log_posterior, list(thetas)) + np.testing.assert_allclose(remote, [p.log_posterior(t) for t in thetas]) diff --git a/test/recipes/test_recipe_17_posterior_predictive.py b/test/recipes/test_recipe_17_posterior_predictive.py new file mode 100644 index 0000000..6d9792a --- /dev/null +++ b/test/recipes/test_recipe_17_posterior_predictive.py @@ -0,0 +1,90 @@ +"""Recipe 17: check the posterior predictive. + +I want to know whether my error model is calibrated: do 68 % intervals +contain 68 % of the points, and how wide are they? +""" + +import numpy as np +import pytest +from scipy import stats + +from common import TRUE, line, line_data, oracle_samples +from rxmc import Comparison, Constraint, Dataset, Parameter, Problem +from rxmc import terms as T +from rxmc import transforms as tf +from rxmc.diagnostics import ( + compare_logz, + coverage_curve, + coverage_error, + logz_summary, + predictive_draws, + sharpness, +) + + +def test_draws_are_ym_plus_correlated_noise_in_comparison_space(): + d = line_data() + log_eps = Parameter("log_eps", prior=stats.norm(-2, 1)) + p = Problem([Constraint([Comparison(d, line())], terms=[T.noise(log_eps)])]) + theta = np.array([*TRUE, np.log(0.2)]) + draws = predictive_draws(p, theta, n_rep=20000, rng=0, return_draws=True) + ym = TRUE[0] * d.x + TRUE[1] + np.testing.assert_allclose(draws.mean(0), ym, atol=0.01) + np.testing.assert_allclose( + np.cov(draws.T), p.constraints[0].matrix(theta), atol=0.01 + ) + # model_only: the predictions themselves, no covariance + np.testing.assert_allclose( + predictive_draws(p, theta, model_only=True, return_draws=True)[0], ym + ) + + +def big_dataset(err_scale=1.0, seed=3, n=200): + rng = np.random.default_rng(seed) + x = np.linspace(0.5, 2.5, n) + y = TRUE[0] * x + TRUE[1] + rng.normal(0, 0.1, n) + return Dataset(x, y, err_scale * 0.1 * np.ones(n), label="big") + + +def test_coverage_is_nominal_for_the_right_error_model_and_low_for_an_overconfident_one(): + levels = np.array([0.5, 0.68, 0.9]) + d = big_dataset() + p = Problem([Constraint([Comparison(d, line())])]) + s = oracle_samples(p, 400, rng=0) # exact posterior rows stand in for a chain + draws = predictive_draws(p, s, n_rep=4, rng=1, return_draws=True) + y_active = p.constraints[0].y[p.constraints[0].active] + np.testing.assert_allclose( + coverage_curve(draws, y_active, levels), levels, atol=0.1 + ) + assert coverage_error(draws, y_active, levels) < 0.1 + # the same data with the errors claimed five times smaller + tight = Problem([Constraint([Comparison(big_dataset(err_scale=0.2), line())])]) + draws_tight = predictive_draws( + tight, oracle_samples(tight, 400, rng=0), n_rep=4, rng=1, return_draws=True + ) + assert np.all(coverage_curve(draws_tight, y_active, levels) < levels - 0.2) + + +def test_sharpness_in_physical_units_for_a_log_fit(): + d = line_data() + comp = Comparison(d, line(), space=tf.log) + log_eps = Parameter("log_eps", prior=stats.norm(-2, 1)) + p = Problem([Constraint([comp], terms=[T.noise(log_eps)], statistical=False)]) + draws = predictive_draws( + p, np.array([*TRUE, np.log(0.1)]), n_rep=2000, rng=2, return_draws=True + ) + width_log = sharpness(draws) + width = sharpness(draws, transform=np.exp) + assert np.all(width > 0) and np.all(width_log > 0) + # a constant width in log space is a width proportional to y in physical units + np.testing.assert_allclose(width_log, width_log.mean(), rtol=0.1) + np.testing.assert_allclose( + width / comp.data.y, (width / comp.data.y).mean(), rtol=0.15 + ) + + +def test_evidence_bookkeeping(): + m, e, n = logz_summary([-10.0, -10.4], [0.1, 0.1]) + assert (m, n) == pytest.approx((-10.2, 2)) and e == pytest.approx(0.2) + assert compare_logz((-10.0, 0.5), (-10.4, 0.5))["verdict"] == "tie" + assert compare_logz((-10.0, 0.1), (-12.0, 0.1))["verdict"] == "a" diff --git a/test/recipes/test_recipe_18_evidence_comparison.py b/test/recipes/test_recipe_18_evidence_comparison.py new file mode 100644 index 0000000..324948f --- /dev/null +++ b/test/recipes/test_recipe_18_evidence_comparison.py @@ -0,0 +1,126 @@ +"""Recipe 18: compare error models by evidence. + +The alpha + Ca study: several error models for data without reported +errors. I want the evidence for each, comparable across comparison spaces. + +The error-model labels below are those of recipe 18's table in +docs/recipes.md; all are covariances of the residual in log space unless +stated: + + L0 constant noise: sigma = err on every point + E0 fractional noise in linear space: sigma_i = err * ym_i + L2n L0 plus a free correlated offset mode, sys * 1 (in log space, a + normalisation) + Lgp L0 plus a Matern(5/2) Gaussian process in u = theta / pi with a + constant amplitude +""" + +import dynesty +import jax.numpy as jnp +import numpy as np +import pytest +import tinygp +from scipy import stats + +from common import TRUE, line, line_data +from rxmc import Comparison, Constraint, Model, Parameter, Problem +from rxmc import terms as T +from rxmc import transforms as tf +from rxmc.diagnostics import compare_logz, logz_summary + + +def error_models(d, model): + comp_log = Comparison(d, model, space=tf.log) + comp_lin = Comparison(d, model) + log_eps = Parameter("log_eps", prior=stats.norm(-2, 1)) + log_sys = Parameter("log_sys", prior=stats.norm(-3, 1)) + log_A = Parameter("log_A", prior=stats.norm(-2, 1)) + gp = T.kernel( + lambda log_ell: tinygp.kernels.Matern52(scale=jnp.exp(log_ell)), + T.kernel_params(["length_scale"], [(np.log(1e-5), np.log(1e5))]), + on=comp_log, + coords=lambda x: x / np.pi, + amplitude=T.constant_amplitude, + amplitude_params=(log_A,), + ) + return { + "L0": Constraint([comp_log], terms=[T.noise(log_eps)], statistical=False), + "E0": Constraint( + [comp_lin], terms=[T.proportional_error(log_eps)], statistical=False + ), + "L2n": Constraint( + [comp_log], terms=[T.noise(log_eps), T.offset(log_sys)], statistical=False + ), + "Lgp": Constraint([comp_log], terms=[T.noise(log_eps), gp], statistical=False), + } + + +def test_each_problem_compiles_independently_with_shared_parameter_objects(): + d = line_data() + models = error_models(d, line()) + problems = {name: Problem([c]) for name, c in models.items()} + assert problems["L0"].names == ["m", "b", "log_eps"] + assert problems["E0"].names == ["m", "b", "log_eps"] + assert problems["L2n"].names == ["m", "b", "log_eps", "log_sys"] + assert problems["Lgp"].names == [ + "m", + "b", + "log_eps", + "discrepancy_length_scale", + "log_A", + ] + # the same log_eps object is one column in each, at the same slot + assert all(p.names.index("log_eps") == 2 for p in problems.values()) + theta = np.array([*TRUE, np.log(0.1)]) + assert np.isfinite(problems["L0"].log_posterior(theta)) + assert np.isfinite(problems["E0"].log_posterior(theta)) + + +def test_log_jacobian_makes_spaces_comparable(): + d = line_data() + models = error_models(d, line()) + p_log, p_lin = Problem([models["L0"]]), Problem([models["E0"]]) + assert p_log.log_jacobian() == pytest.approx(-np.sum(np.log(d.y))) + assert p_lin.log_jacobian() == 0.0 + # a cut applies to the Jacobian too: only active points count + cut = Problem([models["L0"].masked_where(lambda x: x < 1.5)]) + assert cut.log_jacobian() == pytest.approx(-np.sum(np.log(d.y[d.x < 1.5]))) + # the recipe's bookkeeping: add the Jacobian before summarising + fake_logz, fake_err = -12.0, 0.2 + a = logz_summary(fake_logz + p_log.log_jacobian(), fake_err) + b = logz_summary(fake_logz + p_lin.log_jacobian(), fake_err) + assert compare_logz(a, b)["dlogZ"] == pytest.approx(p_log.log_jacobian()) + + +def run_dynesty(p, seed, nlive=100): + ns = dynesty.NestedSampler( + p.log_likelihood, + p.prior_transform, + p.ndim, + nlive=nlive, + rstate=np.random.default_rng(seed), + ) + ns.run_nested(dlogz=0.1, print_progress=False) + return ns.results + + +@pytest.mark.slow +def test_a_normalisation_defect_is_preferred_by_the_model_that_has_one(): + # Data scaled by 30 %. A line with a free intercept would absorb a scaling + # into its parameters, so the model here has a known intercept: only the + # offset mode of L2n, a normalisation in log space, can explain the defect. + from dataclasses import replace + + d = replace(line_data(err=0.05), y=1.3 * line_data(err=0.05).y) + m = Parameter("m", prior=stats.norm(0, 5)) + slope_only = Model(lambda x, m: m * x + 1.0, [m]) + models = error_models(d, slope_only) + logz = {} + for name in ("L0", "L2n"): + p = Problem([models[name]]) + res = [run_dynesty(p, seed) for seed in (0, 1)] + logz[name] = logz_summary( + [r.logz[-1] + p.log_jacobian() for r in res], [r.logzerr[-1] for r in res] + ) + verdict = compare_logz(logz["L2n"], logz["L0"]) + assert verdict["verdict"] == "a" and verdict["dlogZ"] > 1.5, (logz, verdict) diff --git a/test/recipes/test_recipe_19_bring_your_own_term.py b/test/recipes/test_recipe_19_bring_your_own_term.py new file mode 100644 index 0000000..aa40089 --- /dev/null +++ b/test/recipes/test_recipe_19_bring_your_own_term.py @@ -0,0 +1,62 @@ +"""Recipe 19: bring my own covariance or term. + +I have a full covariance matrix from a correlated measurement, or a noise +model no helper expresses. +""" + +import jax.numpy as jnp +import numpy as np +import pytest +from scipy import stats + +from common import TRUE, line, line_data +from helpers import manual_mvn_loglike +from rxmc import Comparison, Constraint, Parameter, Problem, Term +from rxmc import terms as T + + +def test_fixed_matrix_and_fixed_diagonal_inside_a_problem(): + d = line_data() + C = 0.01 * np.exp(-np.abs(d.x[:, None] - d.x[None, :]) / 0.5) + comp = Comparison(d, line()) + p = Problem([Constraint([comp], terms=[Term(C, on=comp)], statistical=False)]) + theta = np.array(TRUE) + ym = TRUE[0] * d.x + TRUE[1] + assert p.log_likelihood(theta) == pytest.approx(manual_mvn_loglike(d.y, ym, C)) + sig = 0.2 * np.ones(d.n) + p2 = Problem( + [Constraint([comp], terms=[Term(sig, kind="diag", on=comp)], statistical=False)] + ) + assert p2.log_likelihood(theta) == pytest.approx( + manual_mvn_loglike(d.y, ym, np.diag(sig**2)) + ) + + +def test_custom_callable_term_matches_the_helper(): + d = line_data() + e, sl = ( + Parameter("log_e", prior=stats.norm(-2, 1)), + Parameter("slope", prior=stats.norm(0, 1)), + ) + custom = Term( + lambda c, e, l: jnp.exp(e) * jnp.exp(l * c.x / np.pi), (e, sl), kind="diag" + ) + helper = T.noise(e, basis=T.exp_growth(np.pi), basis_params=(sl,)) + pc = Problem( + [Constraint([Comparison(d, line())], terms=[custom], statistical=False)] + ) + ph = Problem( + [Constraint([Comparison(d, line())], terms=[helper], statistical=False)] + ) + theta = np.array([*TRUE, np.log(0.2), 1.1]) + assert pc.names == ph.names + assert pc.log_likelihood(theta) == pytest.approx(ph.log_likelihood(theta)) + + +def test_wrong_shape_for_the_support_is_rejected_at_construction(): + d = line_data() + comp = Comparison(d, line()) + with pytest.raises(ValueError, match="expects shape"): + Constraint([comp], terms=[Term(np.ones(3), kind="diag", on=comp)]) + with pytest.raises(ValueError, match="symmetric"): + Term(np.array([[1.0, 0.5], [0.0, 1.0]])) diff --git a/test/recipes/test_recipe_20_preprocessing.py b/test/recipes/test_recipe_20_preprocessing.py new file mode 100644 index 0000000..416748f --- /dev/null +++ b/test/recipes/test_recipe_20_preprocessing.py @@ -0,0 +1,62 @@ +"""Recipe 20: preprocess instead of asking for a feature. + +I want to mean-subtract, standardise, or project both data and model onto +principal components of a prior predictive ensemble. +""" + +import numpy as np +import pytest +from scipy import stats + +from common import TRUE, line, line_data +from helpers import manual_mvn_loglike +from rxmc import Comparison, Constraint, Dataset, Model, Parameter, Problem, Term +from rxmc import terms as T + + +def test_projection_onto_principal_components(): + d = line_data() + rng = np.random.default_rng(0) + ens = np.array( + [TRUE[0] * d.x + TRUE[1] + rng.normal(0, 0.3, d.n) for _ in range(50)] + ) + mu = ens.mean(0) + A = np.linalg.svd(ens - mu, full_matrices=False)[2][:2] # (k, N) + native = line().bind(d.x) + model = line() + proj = Model(lambda x_pc, *theta: A @ (native(*theta) - mu), model.params) + d_pc = Dataset(np.arange(2), A @ (d.y - mu), np.zeros(2), label=f"{d.label} PC") + stat = Term(A @ np.diag(d.y_err**2) @ A.T, on=d_pc) + log_eps = Parameter("log_eps", prior=stats.norm(-2, 1)) + p = Problem( + [ + Constraint( + [Comparison(d_pc, proj)], + terms=[stat, T.noise(log_eps, on=d_pc)], + statistical=False, + ) + ] + ) + theta = np.array([*TRUE, np.log(0.1)]) + ym_pc = A @ (TRUE[0] * d.x + TRUE[1] - mu) + S = A @ np.diag(d.y_err**2) @ A.T + 0.01 * np.eye(2) + assert p.log_likelihood(theta) == pytest.approx( + manual_mvn_loglike(d_pc.y, ym_pc, S) + ) + + +def test_mean_subtraction_as_preprocessing_or_as_a_pointwise_space(): + from dataclasses import replace + + from rxmc import transforms as tf + + d = line_data() + mu = 0.5 * np.ones(d.n) + shifted = replace(d, y=d.y - mu) + shift = Model(lambda x: -mu, []) + p_pre = Problem([Constraint([Comparison(shifted, line() + shift)])]) + centre = tf.Transform(lambda a: a - mu, derivative=np.ones_like) + p_space = Problem([Constraint([Comparison(d, line(), space=centre)])]) + theta = np.array(TRUE) + assert p_pre.log_likelihood(theta) == pytest.approx(p_space.log_likelihood(theta)) + assert p_space.log_jacobian() == 0.0 # a shift has unit Jacobian diff --git a/test/recipes/test_recipe_21_singular_covariance_error.py b/test/recipes/test_recipe_21_singular_covariance_error.py new file mode 100644 index 0000000..b67f7d1 --- /dev/null +++ b/test/recipes/test_recipe_21_singular_covariance_error.py @@ -0,0 +1,82 @@ +"""Recipe 21: get a useful error, not a LinAlgError. + +My measurement reports no statistical error and I forgot to add any term. +""" + +import numpy as np +import pytest +from scipy import stats + +from common import TRUE, line +from rxmc import Comparison, Constraint, Dataset, Parameter, Problem +from rxmc import terms as T + + +def test_singular_covariance_is_reported_by_label_with_remedies(): + d = Dataset( + np.linspace(0.5, 2.5, 6), + TRUE[0] * np.linspace(0.5, 2.5, 6) + 1.0, + np.zeros(6), + label="E1234-002", + ) + with pytest.raises( + ValueError, match="E1234-002.*zero statistical error.*reported_terms" + ): + Problem([Constraint([Comparison(d, line())])]) + + +def test_the_remedies_work(): + x = np.linspace(0.5, 2.5, 6) + d = Dataset( + x, + TRUE[0] * x + 1.0, + np.zeros(6), + norm_err=0.05, + offset_err=0.1, + label="E1234-002", + ) + comp = Comparison(d, line()) + Problem( + [ + Constraint( + [comp], + terms=comp.reported_terms() + + [T.noise(Parameter("log_eps", prior=stats.norm()))], + ) + ] + ) + Problem( + [ + Constraint( + [comp], + terms=[T.statistical(0.1 * np.ones(6), on=comp)], + statistical=False, + ) + ] + ) + # modes alone are rank two and still singular on six points + with pytest.raises(ValueError, match="singular"): + Problem([Constraint([comp], terms=comp.reported_terms())]) + + +def test_other_compile_time_errors_are_named(): + x = np.linspace(0.5, 2.5, 6) + d = Dataset(x, TRUE[0] * x + 1.0, 0.1 * np.ones(6), label="d") + comp = Comparison(d, line()) + stray = Comparison(Dataset(x, x, 0.1 * np.ones(6), label="stray"), line()) + with pytest.raises(ValueError, match="stray"): + Constraint([comp], terms=[T.noise(Parameter("e"), on=stray)]) + with pytest.raises(ValueError, match="duplicate parameter name"): + Problem( + [ + Constraint( + [comp], + terms=[ + T.noise(Parameter("e", prior=stats.norm())), + T.noise(Parameter("e", prior=stats.norm())), + ], + ) + ] + ) + with pytest.raises(ValueError, match="'e' has no prior"): + Problem([Constraint([comp], terms=[T.noise(Parameter("e"))])]) diff --git a/test/recipes/test_recipe_22_shared_hyperparameters.py b/test/recipes/test_recipe_22_shared_hyperparameters.py new file mode 100644 index 0000000..9ff0a4e --- /dev/null +++ b/test/recipes/test_recipe_22_shared_hyperparameters.py @@ -0,0 +1,104 @@ +"""Recipe 22: share hyperparameters across datasets, with values that depend +on the dataset. + +I have elastic data at several energies. I want one GP discrepancy per +dataset with a common length scale and an amplitude that runs with energy, +so that two shared parameters describe every dataset. +""" + +import jax.numpy as jnp +import jax.scipy.stats as jst +import numpy as np +import pytest +import tinygp +from scipy import stats + +# sklearn's Matern serves only as the independent dense reference +from sklearn.gaussian_process.kernels import Matern + +from common import TRUE, line +from rxmc import Comparison, Constraint, Dataset, Parameter, Problem +from rxmc import terms as T + + +def matern52(log_ell): + return tinygp.kernels.Matern52(scale=jnp.exp(log_ell)) + + +def datasets(): + out = [] + for i, E in enumerate((10.0, 30.0, 50.0)): + x = np.linspace(0.5, 2.5, 5) + out.append( + Dataset( + x, + TRUE[0] * x + TRUE[1], + 0.1 * np.ones(5), + label=f"E{E:.0f}", + meta={"Elab": E}, + ) + ) + return out + + +def test_two_shared_parameters_describe_every_dataset(): + log_A0, p_ = ( + Parameter("log_A0", prior=stats.norm(0, 2)), + Parameter("p", prior=stats.norm(0, 1)), + ) + ell = Parameter("gp_length", prior=stats.norm(0, 1)) + amp = lambda c, lA, p: jnp.exp(lA) * (c.meta("Elab") / 50.0) ** p # noqa: E731 + model = line() + comps = [Comparison(d, model) for d in datasets()] + terms = [ + T.kernel( + matern52, + [ell], + on=c, + amplitude=amp, + amplitude_params=(log_A0, p_), + jitter=0.0, + ) + for c in comps + ] + prob = Problem([Constraint(comps, terms=terms)]) + assert prob.names == ["m", "b", "gp_length", "log_A0", "p"] + theta = np.array([*TRUE, np.log(0.4), np.log(0.3), 1.0]) + S = prob.constraints[0].matrix(theta) + # each block's amplitude is (E / 50)^p times 0.3 + for i, E in enumerate((10.0, 30.0, 50.0)): + block = S[5 * i : 5 * i + 5, 5 * i : 5 * i + 5] - 0.01 * np.eye(5) + a = 0.3 * (E / 50.0) + u = np.linspace(0.5, 2.5, 5) + np.testing.assert_allclose(block, a**2 * Matern(0.4, nu=2.5)(u[:, None])) + assert not prob.constraints[0].covariance.dense + + +class Standard: + """A joint block giving every covered parameter an independent N(0, 1).""" + + def logpdf(self, v): + return jst.norm.logpdf(v).sum() + + +def test_distinct_prefixes_give_each_kernel_its_own_length_scale(): + model = line() + comps = [Comparison(d, model) for d in datasets()[:2]] + terms = [ + T.kernel(matern52, T.kernel_params(["length_scale"], prefix=f"gp{i}"), on=c) + for i, c in enumerate(comps) + ] + derived = [p for t in terms for p in t.params] + prob = Problem([Constraint(comps, terms=terms)], priors=[(derived, Standard())]) + assert [n for n in prob.names if "length" in n] == [ + "gp0_length_scale", + "gp1_length_scale", + ] + same = [ + T.kernel(matern52, T.kernel_params(["length_scale"]), on=c) for c in comps + ] # both declare "discrepancy_length_scale" + with pytest.raises(ValueError, match="duplicate"): + Problem( + [Constraint(comps, terms=same)], + priors=[([p for t in same for p in t.params], Standard())], + ) diff --git a/test/recipes/test_recipe_23_gp_over_energy_and_angle.py b/test/recipes/test_recipe_23_gp_over_energy_and_angle.py new file mode 100644 index 0000000..7ef7398 --- /dev/null +++ b/test/recipes/test_recipe_23_gp_over_energy_and_angle.py @@ -0,0 +1,57 @@ +"""Recipe 23: a discrepancy correlated across energies and angles. + +I believe the model's defect varies smoothly in both energy and angle. I +want one GP over (E, theta) that correlates the datasets at different +energies. +""" + +import jax.numpy as jnp +import numpy as np +import pytest +import tinygp +from scipy import stats + +# sklearn's kernels serve only as the independent dense reference +from sklearn.gaussian_process.kernels import RBF, Matern + +from common import TRUE, line +from helpers import manual_mvn_loglike +from rxmc import Comparison, Constraint, Dataset, Parameter, Problem, Term + + +def test_one_matrix_term_spanning_the_comparisons(): + x = np.linspace(0.5, 2.5, 4) + ds = [ + Dataset( + x, TRUE[0] * x + TRUE[1], 0.1 * np.ones(4), label=f"E{E}", meta={"Elab": E} + ) + for E in (10.0, 20.0) + ] + model = line() + comps = [Comparison(d, model) for d in ds] + lE, lt, log_A = ( + Parameter(n, prior=stats.norm(0, 1)) for n in ("log_lE", "log_ltheta", "log_A") + ) + + def fn(c, lE, lt, lA): + E, t = c.meta("Elab")[:, None], c.x[:, None] + kE = tinygp.kernels.ExpSquared(scale=jnp.exp(lE)) + kt = tinygp.kernels.Matern52(scale=jnp.exp(lt)) + return jnp.exp(2 * lA) * kE(E, E) * kt(t, t) + 1e-10 * jnp.eye(len(c)) + + md = Term(fn, (lE, lt, log_A), kind="matrix", on=comps) + p = Problem([Constraint(comps, terms=[md])]) + assert p.names == ["m", "b", "log_lE", "log_ltheta", "log_A"] + assert p.constraints[0].covariance.dense # a matrix across comparisons is dense + theta = np.array([*TRUE, np.log(10.0), np.log(0.3), np.log(0.2)]) + E = np.repeat([10.0, 20.0], 4)[:, None] + t = np.tile(x, 2)[:, None] + ref = ( + np.diag(np.full(8, 0.01)) + + 0.04 * RBF(10.0)(E) * Matern(0.3, nu=2.5)(t) + + 1e-10 * np.eye(8) + ) + y, ym = np.concatenate([d.y for d in ds]), np.tile(TRUE[0] * x + TRUE[1], 2) + assert p.log_likelihood(theta) == pytest.approx(manual_mvn_loglike(y, ym, ref)) + S = p.constraints[0].matrix(theta) + assert np.any(S[:4, 4:] != 0.0) # the energies really are correlated diff --git a/test/recipes/test_recipe_24_hyperprior.py b/test/recipes/test_recipe_24_hyperprior.py new file mode 100644 index 0000000..5058d3a --- /dev/null +++ b/test/recipes/test_recipe_24_hyperprior.py @@ -0,0 +1,65 @@ +"""Recipe 24: per-dataset parameters drawn from a sampled hyperprior. + +Each dataset has its own normalisation, and I want to learn how spread out +those normalisations are, rather than fix the spread. +""" + +import jax.numpy as jnp +import jax.scipy.stats as jst +import numpy as np +import pytest +from scipy import stats + +from common import TRUE, line, line_data +from rxmc import Comparison, Constraint, Parameter, Problem +from rxmc import transforms as tf + + +class RhoHierarchy: + def logpdf(self, v): + *r, lt = v + r = jnp.stack(r) + tau = jnp.exp(lt) + # halfnorm(scale=0.3).logpdf(tau), tau > 0 + halfnorm = jnp.log(2.0) + jst.norm.logpdf(tau, scale=0.3) + return jst.norm.logpdf(r, scale=tau).sum() + halfnorm + lt + + def prior_transform(self, u): + lt = np.log(stats.halfnorm(scale=0.3).ppf(u[-1])) + return np.append(stats.norm(0, np.exp(lt)).ppf(u[:-1]), lt) + + +def build(priors): + rhos = [Parameter(f"log_rho_{i}") for i in range(3)] + log_tau = Parameter("log_tau") + model = line() + comps = [ + Comparison(line_data(i, 5, f"d{i}"), model | tf.scale(rho)) + for i, rho in enumerate(rhos) + ] + return Problem([Constraint(comps)], priors=priors(rhos, log_tau)), rhos, log_tau + + +def test_tau_is_a_column_and_the_block_covers_children_and_hyper(): + p, rhos, log_tau = build(lambda rhos, lt: [(rhos + [lt], RhoHierarchy())]) + assert p.names == ["m", "b", "log_rho_0", "log_rho_1", "log_rho_2", "log_tau"] + theta = np.array([*TRUE, 0.1, -0.1, 0.0, np.log(0.2)]) + expected = stats.norm(0, 5).logpdf(TRUE).sum() + RhoHierarchy().logpdf( + [0.1, -0.1, 0.0, np.log(0.2)] + ) + assert p.log_prior(theta) == pytest.approx(expected) + + +def test_forgetting_the_block_is_a_compile_error(): + with pytest.raises(ValueError, match="'log_rho_0' has no prior"): + build(lambda rhos, lt: []) + + +def test_prior_transform_draws_the_hyperparameter_first(): + p, *_ = build(lambda rhos, lt: [(rhos + [lt], RhoHierarchy())]) + u = np.array([0.5, 0.5, 0.9, 0.1, 0.5, 0.5]) + theta = p.prior_transform(u) + lt = theta[-1] + assert lt == pytest.approx(np.log(stats.halfnorm(scale=0.3).ppf(0.5))) + assert theta[2] == pytest.approx(stats.norm(0, np.exp(lt)).ppf(0.9)) + assert p.sample_prior(4, rng=0).shape == (4, 6) diff --git a/test/recipes/test_recipe_25_safebayes.py b/test/recipes/test_recipe_25_safebayes.py new file mode 100644 index 0000000..13fbe68 --- /dev/null +++ b/test/recipes/test_recipe_25_safebayes.py @@ -0,0 +1,59 @@ +"""Recipe 25: SafeBayes, learn the tempering exponent. + +I suspect my model is misspecified and want the tempering exponent chosen +by the data rather than by hand: minimise the prequential log-loss of the +eta-generalised posterior over prefixes of the data. +""" + +from dataclasses import replace + +import numpy as np +import pytest +from scipy import stats + +from common import TRUE, line, line_data +from rxmc import Comparison, Constraint, Parameter, Problem +from rxmc import terms as T + + +def test_replace_weight_and_masked_prefixes_keep_the_columns(): + d = line_data() + log_eps = Parameter("log_eps", prior=stats.norm(-2, 1)) + c = Constraint([Comparison(d, line())], terms=[T.noise(log_eps)]) + order = np.arange(d.n) + prefix = lambda i: [np.isin(np.arange(d.n), order[:i])] # noqa: E731 + names = Problem([c]).names + for eta in (1.0, 0.5, 0.25): + for i in range(2, d.n): + p = Problem([replace(c.masked(prefix(i)), weight=eta)]) + assert p.names == names + theta = np.array([*TRUE, np.log(0.2)]) + assert p.log_likelihood(theta) == pytest.approx( + eta * Problem([c.masked(prefix(i))]).log_likelihood(theta) + ) + + +def test_prefix_difference_is_the_conditional_density_of_the_next_point(): + d = line_data() + log_w = Parameter("log_omega", prior=stats.norm(-2, 1)) + c = Constraint( + [Comparison(d, line())], terms=[T.offset(log_w)] + ) # correlated: conditional != marginal + theta = np.array([*TRUE, np.log(0.3)]) + ym = TRUE[0] * d.x + TRUE[1] + Sigma = np.diag(d.y_err**2) + 0.09 * np.ones((d.n, d.n)) + i = 4 + before = Problem([c.masked([np.arange(d.n) < i])]) + after = Problem([c.masked([np.arange(d.n) < i + 1])]) + diff = after.log_likelihood(theta) - before.log_likelihood(theta) + # closed-form Gaussian conditional of point i given points < i + S_aa, S_ab, S_bb = Sigma[i, i], Sigma[i, :i], Sigma[:i, :i] + r = d.y[:i] - ym[:i] + mu_c = ym[i] + S_ab @ np.linalg.solve(S_bb, r) + var_c = S_aa - S_ab @ np.linalg.solve(S_bb, S_ab) + assert diff == pytest.approx(stats.norm(mu_c, np.sqrt(var_c)).logpdf(d.y[i])) + + +def test_weight_is_a_float_by_type(): + with pytest.raises((TypeError, ValueError)): + Constraint([Comparison(line_data(), line())], weight=Parameter("eta")) diff --git a/test/recipes/test_recipe_26_kduq_model_error.py b/test/recipes/test_recipe_26_kduq_model_error.py new file mode 100644 index 0000000..345c11e --- /dev/null +++ b/test/recipes/test_recipe_26_kduq_model_error.py @@ -0,0 +1,64 @@ +"""Recipe 26: unaccounted-for model error per data type (KDUQ). + +I am calibrating a global optical potential to many datasets of several +observable types. I want one fractional "unaccounted-for" uncertainty per +type, sampled with the potential, added in quadrature to the reported +errors and scaled with the average of datum and prediction. +""" + +import numpy as np +import pytest +from scipy import stats + +from common import TRUE, line, line_data +from rxmc import Comparison, Constraint, Parameter, Problem +from rxmc import terms as T + + +def build(): + types = ("dxs", "ay") + delta = {t: Parameter(f"delta_{t}", prior=stats.halfnorm(scale=0.2)) for t in types} + datasets = [line_data(i, 5, f"d{i}", meta={"type": types[i % 2]}) for i in range(4)] + model = line() + comps = [Comparison(d, model) for d in datasets] + terms = [ + T.proportional_error(delta[d.meta["type"]], averaging=True, log=False, on=c) + for d, c in zip(datasets, comps) + ] + return types, delta, datasets, comps, terms + + +def test_one_delta_per_type_shared_by_object(): + types, delta, datasets, comps, terms = build() + p = Problem([Constraint(comps, terms=terms)]) + assert p.names == ["m", "b", "delta_dxs", "delta_ay"] + theta = np.array([*TRUE, 0.1, 0.3]) + S = p.constraints[0].matrix(theta) + for i, d in enumerate(datasets): + ym = TRUE[0] * d.x + TRUE[1] + dT = 0.1 if d.meta["type"] == "dxs" else 0.3 + expected = d.y_err**2 + (dT * 0.5 * (d.y + ym)) ** 2 + np.testing.assert_allclose(np.diag(S)[5 * i : 5 * i + 5], expected) + + +def test_democratic_and_federal_scalings_are_tempering_weights(): + types, delta, datasets, comps, terms = build() + theta = np.array([*TRUE, 0.1, 0.3]) + n_params, n_data = 2, 20 + plain = Problem([Constraint(comps, terms=terms)]) + dem = Problem([Constraint(comps, terms=terms, weight=n_params / n_data)]) + assert dem.log_likelihood(theta) == pytest.approx( + n_params / n_data * plain.log_likelihood(theta) + ) + fed = Problem( + [ + Constraint( + [c for c, d in zip(comps, datasets) if d.meta["type"] == t], + terms=[tt for tt, d in zip(terms, datasets) if d.meta["type"] == t], + weight=n_params / (len(types) * 10), + ) + for t in types + ] + ) + assert fed.names == plain.names # each delta lives in its own type constraint + assert np.isfinite(fed.log_likelihood(theta)) diff --git a/test/recipes/test_recipe_27_peelles_pertinent_puzzle.py b/test/recipes/test_recipe_27_peelles_pertinent_puzzle.py new file mode 100644 index 0000000..c3ec6c1 --- /dev/null +++ b/test/recipes/test_recipe_27_peelles_pertinent_puzzle.py @@ -0,0 +1,91 @@ +"""Recipe 27: Peelle's Pertinent Puzzle, normalise the prediction, never the data. + +My datasets carry a common fractional normalisation error and I want the fit +not to be biased low. +""" + +import numpy as np +import pytest +from scipy import stats + +from common import map_estimate +from rxmc import Comparison, Constraint, Dataset, Model, Parameter, Problem, Term +from rxmc import terms as T + + +def constant_fit(y, s, mode, stat=0.02, t0=None): + """MAP of a constant fit with the normalisation mode built three ways.""" + n = len(y) + d = Dataset(np.arange(n), y, stat * np.ones(n)) + c0 = Parameter("c0", prior=stats.norm(1.0, 100.0)) # effectively flat + const = Model(lambda x, c: c * np.ones_like(x, dtype=float), [c0]) + comp = Comparison(d, const) + if mode == "data": + term = Term(s * y, kind="mode", on=comp) # the covariance built from the data + elif mode == "prediction": + term = T.normalization(magnitude=s, on=comp) # built from the live prediction + else: + term = Term(s * t0 * np.ones(n), kind="mode", on=comp) # t0: a fixed reference + p = Problem([Constraint([comp], terms=[term])]) + return map_estimate(p, [np.mean(y)])[0] + + +def test_data_built_mode_is_biased_low_and_prediction_built_is_not(): + # two measurements of the same quantity, in the spirit of Peelle's puzzle + y, s = np.array([1.5, 1.0]), 0.2 + stat = 0.02 + c_bad = constant_fit(y, s, "data") + c_ok = constant_fit(y, s, "prediction") + # the analytic GLS with a data-built covariance + Sigma = np.diag([stat**2] * 2) + s**2 * np.outer(y, y) + w = np.linalg.solve(Sigma, np.ones(2)) + gls = w @ y / w.sum() + assert c_bad == pytest.approx(gls, rel=1e-3) + assert c_bad < y.min() # below both data points: the puzzle + assert y.min() < c_ok < y.max() + + +def test_data_built_fit_has_the_exact_closed_form(): + # GLS with Sigma = sigma^2 I + s^2 y y^T collapses (Sherman-Morrison) to + # t = ybar / (1 + (s / sigma)^2 * sum (y_i - ybar)^2) + # exact per dataset; the (n - 1) s^2 factor is its leading-order expectation + rng = np.random.default_rng(0) + val, s, sigma = 2.0, 0.3, 0.2 + for n in (4, 12): + y = val + rng.normal(0, sigma, n) + t_hat = constant_fit(y, s, "data", stat=sigma) + closed = y.mean() / (1 + (s / sigma) ** 2 * np.sum((y - y.mean()) ** 2)) + assert t_hat == pytest.approx(closed, rel=1e-4) + assert t_hat < val # biased low + # the fluctuations drive the bias: identical points give no bias at all + flat = np.full(6, val) + assert constant_fit(flat, s, "data", stat=sigma) == pytest.approx(val, rel=1e-4) + + +def test_the_three_spellings_order_as_the_recipe_says(): + # seeded replicates of n noisy points around a constant. The data-built + # mode biases the fit low (D'Agostini), roughly by 1 / (1 + (n - 1) s^2); + # the live prediction-built mode removes that but its log-determinant still + # pulls the mode down; the t0 refit (mode frozen at a reference prediction) + # is unbiased. + rng = np.random.default_rng(0) + val, s, sigma = 2.0, 0.3, 0.2 + means = {} + for n in (4, 12): + est = [] + for _ in range(40): + y = val + rng.normal(0, sigma, n) + est.append( + [ + constant_fit(y, s, "data", stat=sigma), + constant_fit(y, s, "prediction", stat=sigma), + constant_fit(y, s, "t0", stat=sigma, t0=np.mean(y)), + ] + ) + means[n] = np.mean(est, axis=0) + data_built, live, t0 = means[n] + assert data_built < live < val + assert abs(t0 - val) < 0.1 + # leading-order expectation, above it by Jensen's inequality + assert val / (1 + (n - 1) * s**2) < data_built < val + assert means[12][0] < means[4][0] # the data-built bias grows with n diff --git a/test/recipes/test_recipe_28_stacking.py b/test/recipes/test_recipe_28_stacking.py new file mode 100644 index 0000000..6068dea --- /dev/null +++ b/test/recipes/test_recipe_28_stacking.py @@ -0,0 +1,80 @@ +"""Recipe 28: stacking by leave-one-dataset-out. + +Evidence weights assume the true model is among my candidates. I would +rather weight models by how well they predict each dataset when it is left +out. +""" + +import numpy as np +import pytest +from scipy import stats +from scipy.optimize import minimize +from scipy.special import logsumexp, softmax + +from common import TRUE, line, line_data, line_design, linear_posterior, oracle_samples +from rxmc import Comparison, Constraint, Model, Parameter, Problem +from rxmc.diagnostics import heldout_log_predictive, log_posterior_predictive + +DATA = [line_data(seed=s, label=f"d{s}", err=0.1) for s in range(3)] + + +def constant(): + b = Parameter("b", prior=stats.norm(0, 5)) + return Model(lambda x, b: b * np.ones_like(x), [b]) + + +def constant_design(x): + return np.ones((len(x), 1)) + + +def loo_scores(model, design, rng=0): + """One held-out log score per dataset, with exact posterior samples.""" + comps = [Comparison(d, model) for d in DATA] # one model object, shared + c = Constraint(comps) + out = [] + for i in range(len(comps)): + fit_c = c.masked( + [np.full(comp.data.y.shape, j != i) for j, comp in enumerate(comps)] + ) + fit, held = Problem([fit_c]), Problem([fit_c.complement()]) + s = oracle_samples(fit, 4000, rng=rng, design=design) + out.append(log_posterior_predictive(heldout_log_predictive(held, s))) + return np.array(out) + + +def test_held_out_scores_match_the_closed_form_marginal(): + model = line() + comps = [Comparison(d, model) for d in DATA] + c = Constraint(comps) + fit_c = c.masked([np.full(d.n, j != 2) for j, d in enumerate(DATA)]) + fit, held = Problem([fit_c]), Problem([fit_c.complement()]) + s = oracle_samples(fit, 4000, rng=0) + score = log_posterior_predictive(heldout_log_predictive(held, s)) + # p(y_h | y_fit) = N(X_h mean, X_h cov X_h^T + Sigma_h) for the linear model + mean, cov, _ = linear_posterior(fit) + h = held.constraints[0] + Xh = np.column_stack([h.x[h.active], np.ones(h.n_active)]) + Sh = h.matrix(np.zeros(fit.ndim)) + closed = stats.multivariate_normal(Xh @ mean, Xh @ cov @ Xh.T + Sh).logpdf( + h.y[h.active] + ) + assert score == pytest.approx(closed, abs=0.15) + assert h.n_active == DATA[2].n # the whole third dataset was held out + + +def test_stacking_weights_prefer_the_model_that_predicts(): + S = np.stack( + [loo_scores(line(), line_design), loo_scores(constant(), constant_design)] + ) + assert S.shape == (2, 3) + + def objective(z): # softmax keeps w on the simplex + return -np.sum(logsumexp(np.log(softmax(z))[:, None] + S, axis=0)) + + w = softmax(minimize(objective, np.zeros(2)).x) + assert w.sum() == pytest.approx(1.0) + assert w[0] > 0.95 # the line predicts the held-out datasets; the constant does not + assert np.all(S[0] > S[1]) + assert ( + TRUE[0] != 0.0 + ) # the datasets really do have a slope for the constant to miss diff --git a/test/recipes/test_recipe_29_cut_posterior.py b/test/recipes/test_recipe_29_cut_posterior.py new file mode 100644 index 0000000..aa20f33 --- /dev/null +++ b/test/recipes/test_recipe_29_cut_posterior.py @@ -0,0 +1,54 @@ +"""Recipe 29: cut (modular) posterior by multiple imputation. + +One module of my model, say a systematic-error parameter or a GP +hyperparameter, should be learned from its own data only and not be +contaminated by the primary data, which I trust less. +""" + +import functools + +import numpy as np +import pytest +from scipy import stats + +from common import TRUE, line, line_data +from rxmc import Comparison, Constraint, Model, Parameter, Problem + + +def test_stage_two_fixes_the_module_by_closure(): + # stage 1: phi (a background level) from its own data + phi = Parameter("phi", prior=stats.norm(0, 1)) + aux = Model(lambda x, phi: phi * np.ones_like(x), [phi]) + d_aux = line_data(3, 4, "aux") + stage1 = Problem([Constraint([Comparison(d_aux, aux)])]) + assert stage1.names == ["phi"] + phis = stage1.sample_prior(3, rng=0)[:, 0] + + def f(x, m, b, phi): + return m * x + b + phi + + m, b = line().params + d = line_data() + for value in phis: + model_t = Model(functools.partial(f, phi=value), [m, b]) + stage2 = Problem([Constraint([Comparison(d, model_t)])]) + assert stage2.names == ["m", "b"] # phi is not a column of stage 2 + np.testing.assert_allclose( + stage2.predict(np.array(TRUE))[0][0], TRUE[0] * d.x + TRUE[1] + value + ) + + +def test_power_weighted_modules_are_one_problem_with_two_weights(): + phi = Parameter("phi", prior=stats.norm(0, 1)) + m, b = line().params + full = Model(lambda x, m, b, phi: m * x + b + phi, [m, b, phi]) + aux = Model(lambda x, phi: phi * np.ones_like(x), [phi]) + c_aux = Constraint([Comparison(line_data(3, 4, "aux"), aux)], weight=1.0) + c_pri = Constraint([Comparison(line_data(), full)], weight=0.3) + p = Problem([c_aux, c_pri]) + assert p.names == ["phi", "m", "b"] + theta = np.array([0.1, *TRUE]) + assert p.log_likelihood(theta) == pytest.approx( + 1.0 * p.constraints[0].log_likelihood(theta) + + 0.3 * p.constraints[1].log_likelihood(theta) + ) diff --git a/test/recipes/test_recipe_30_leave_one_experiment_out.py b/test/recipes/test_recipe_30_leave_one_experiment_out.py new file mode 100644 index 0000000..5093443 --- /dev/null +++ b/test/recipes/test_recipe_30_leave_one_experiment_out.py @@ -0,0 +1,65 @@ +"""Recipe 30: leave-one-experiment-out prediction. + +I want to know whether the calibrated model, with its discrepancy, predicts +an experiment it was not fit to, and with what tolerance. +""" + +import numpy as np +import pytest +import tinygp + +from common import TRUE, line, line_data, oracle_samples +from rxmc import Comparison, Constraint, Problem +from rxmc import terms as T +from rxmc.diagnostics import coverage_curve, heldout_log_predictive, predictive_draws + +DATA = [line_data(seed=s, label=f"d{s}", err=0.1) for s in range(3)] + + +def split(i, terms=()): + model = line() + comps = [Comparison(d, model) for d in DATA] + c = Constraint(comps, terms=[t(comps) for t in terms]) + fit_c = c.masked([np.full(d.n, j != i) for j, d in enumerate(DATA)]) + return Problem([fit_c]), Problem([fit_c.complement()]), Problem([c]) + + +def test_held_out_draws_coverage_and_tolerance(): + for i in range(3): + fit, held, _ = split(i) + s = oracle_samples(fit, 300, rng=i) + draws = predictive_draws(held, s, n_rep=4, rng=i, return_draws=True) + h = held.constraints[0] + assert draws.shape == (1200, DATA[i].n) and h.n_active == DATA[i].n + tol = np.percentile(np.abs(draws - draws.mean(0)), 90, axis=0) + assert tol.shape == (DATA[i].n,) and np.all(tol > 0) + cov68 = coverage_curve(draws, h.y[h.active], [0.68])[0] + assert 0.3 <= cov68 <= 1.0 # eight points: coarse, but not empty + # predictions on the held-out experiment centre near the truth + np.testing.assert_allclose( + draws.mean(0), TRUE[0] * DATA[i].x + TRUE[1], atol=0.15 + ) + + +def spanning_gp(comps): + return T.kernel(0.1**2 * tinygp.kernels.ExpSquared(scale=1.0), on=comps) + + +def test_a_discrepancy_fit_to_the_other_experiments_carries_into_the_prediction(): + fit, held, full = split(2, terms=[spanning_gp]) + theta = np.array(TRUE) + # the marginal held-out block ignores what the fitted experiments taught the GP + marginal = predictive_draws(held, theta, model_only=True, return_draws=True)[0] + conditional = predictive_draws( + held, theta, model_only=True, given=fit, return_draws=True + )[0] + np.testing.assert_allclose(marginal, TRUE[0] * DATA[2].x + TRUE[1]) + assert not np.allclose(conditional, marginal) + # the conditional density is the joint divided by the fit, exactly + lp = heldout_log_predictive(held, theta, given=fit)[0] + assert lp == pytest.approx(full.log_likelihood(theta) - fit.log_likelihood(theta)) + # ...which the marginal is not, because the GP spans the split + assert heldout_log_predictive(held, theta)[0] != pytest.approx(lp) + s = oracle_samples(fit, 200, rng=0) + draws = predictive_draws(held, s, n_rep=4, rng=0, given=fit, return_draws=True) + assert draws.shape == (800, DATA[2].n) and np.all(np.isfinite(draws)) diff --git a/test/recipes/test_recipe_31_sbc.py b/test/recipes/test_recipe_31_sbc.py new file mode 100644 index 0000000..9ccc7d2 --- /dev/null +++ b/test/recipes/test_recipe_31_sbc.py @@ -0,0 +1,80 @@ +"""Recipe 31: simulation-based calibration of the sampler. + +Before trusting a chain, I want to check that the sampler recovers +parameters drawn from the prior when the data are simulated from the model. +""" + +import dataclasses + +import emcee +import numpy as np +import pytest +from scipy import stats + +from common import line, line_data, linear_posterior +from rxmc import Comparison, Constraint, Problem +from rxmc.diagnostics import predictive_draws + + +def simulate(problem, comp, theta0, rng): + """A dataset drawn from the model at ``theta0``, back in physical units.""" + y_sim = predictive_draws( + problem, theta0[None], n_rep=1, rng=rng, return_draws=True, physical=True + )[0] + d_sim = dataclasses.replace(comp.data, y=y_sim) + return Problem([Constraint([Comparison(d_sim, comp.model)])]) + + +def ranks_from(posterior, n_sims=300, L=20, seed=0): + """``posterior(p_sim, rng) -> (L, ndim)`` draws; one rank per column.""" + rng = np.random.default_rng(seed) + d = line_data() + comp = Comparison(d, line()) + p = Problem([Constraint([comp])]) + ranks = [] + for theta0 in p.sample_prior(n_sims, rng): + p_sim = simulate(p, comp, theta0, rng) + s = posterior(p_sim, rng) + ranks.append((s < theta0).sum(0)) + return np.array(ranks), L + + +def uniform_pvalues(ranks, L): + return np.array( + [ + stats.chisquare(np.bincount(ranks[:, j], minlength=L + 1)).pvalue + for j in range(2) + ] + ) + + +def exact(p_sim, rng, L=20, inflate=1.0): + mean, cov, _ = linear_posterior(p_sim) + return rng.multivariate_normal(mean, inflate * cov, L) + + +def test_exact_posterior_gives_uniform_ranks_and_a_too_wide_one_does_not(): + ranks, L = ranks_from(exact) + assert ranks.shape == (300, 2) and ranks.min() >= 0 and ranks.max() <= L + assert np.all(uniform_pvalues(ranks, L) > 0.01) + # a posterior twice too wide piles the ranks in the middle (inverted U) + wide, _ = ranks_from(lambda p, rng: exact(p, rng, inflate=4.0)) + assert np.all(uniform_pvalues(wide, L) < 0.01) + hist = np.bincount(wide[:, 0], minlength=L + 1) + assert hist[L // 2 - 2 : L // 2 + 3].sum() > hist[:3].sum() + hist[-3:].sum() + + +@pytest.mark.slow +def test_emcee_passes_simulation_based_calibration(): + def chain(p_sim, rng, L=20): + p0 = p_sim.sample_prior(16, rng=rng) + sampler = emcee.EnsembleSampler(16, p_sim.ndim, p_sim.log_posterior) + sampler.random_state = np.random.RandomState( + int(rng.integers(2**31)) + ).get_state() + sampler.run_mcmc(p0, 600, progress=False) + flat = sampler.get_chain(discard=300, thin=15, flat=True) + return flat[rng.choice(len(flat), L, replace=False)] + + ranks, L = ranks_from(chain, n_sims=60, seed=1) + assert np.all(uniform_pvalues(ranks, L) > 0.005), uniform_pvalues(ranks, L) diff --git a/test/recipes/test_recipe_32_emulator.py b/test/recipes/test_recipe_32_emulator.py new file mode 100644 index 0000000..0ce7f03 --- /dev/null +++ b/test/recipes/test_recipe_32_emulator.py @@ -0,0 +1,56 @@ +"""Recipe 32: emulator as the model, emulator variance as a term. + +My model is too expensive to run in the chain. I have a GP or PCA emulator +trained on a design of runs, and I want its predictive variance in the +likelihood. +""" + +import jax.numpy as jnp +import numpy as np +import pytest +from scipy import stats + +from common import TRUE, line_data +from rxmc import Comparison, Constraint, Model, Parameter, Problem, Term +from rxmc import terms as T + + +class Emulator: + """A stand-in: the line itself plus a parameter-dependent variance.""" + + def __init__(self, x): + self.x = x + + def mean(self, theta): + return theta[0] * self.x + theta[1] + + def var(self, theta): + return 0.01 * (1 + theta[0] ** 2) * np.ones_like(self.x) + + +def test_the_term_declares_the_models_parameters_and_sees_the_same_values(): + d = line_data() + emu = Emulator(d.x) + m, b = ( + Parameter("m", prior=stats.norm(0, 5)), + Parameter("b", prior=stats.norm(0, 5)), + ) + params = [m, b] + + def emu_std(c, *theta): + return jnp.sqrt(emu.var(theta)) + + model = Model(lambda x, *theta: emu.mean(theta), params) + emu_var = Term(emu_std, params, kind="diag") + log_eps = Parameter("log_eps", prior=stats.norm(-2, 1)) + p = Problem([Constraint([Comparison(d, model)], terms=[emu_var, T.noise(log_eps)])]) + assert p.names == ["m", "b", "log_eps"] # the term adds no columns of its own + theta = np.array([*TRUE, np.log(0.1)]) + S = p.constraints[0].matrix(theta) + np.testing.assert_allclose(np.diag(S), d.y_err**2 + emu.var(TRUE) + 0.01) + assert np.isfinite(p.log_posterior(theta)) + assert p.log_likelihood(theta) != pytest.approx( + Problem( + [Constraint([Comparison(d, model)], terms=[T.noise(log_eps)])] + ).log_likelihood(theta) + ) diff --git a/test/recipes/test_recipe_33_map_and_laplace.py b/test/recipes/test_recipe_33_map_and_laplace.py new file mode 100644 index 0000000..f0cca24 --- /dev/null +++ b/test/recipes/test_recipe_33_map_and_laplace.py @@ -0,0 +1,25 @@ +"""Recipe 33: MAP and Laplace approximation. + +I want a quick Gaussian approximation to the posterior, and to know when it +is good enough. +""" + +import numpy as np + +import rxmc as rx +from common import line_problem +from oracle import linear_gaussian + + +def test_laplace_covariance_equals_the_oracle_on_a_linear_gaussian_problem(): + p, d = line_problem() + fit = rx.optimize.find_map(p, rng=0) + cov = np.linalg.inv(-p.hessian_log_posterior(fit.x)) + Xd = np.column_stack([d.x, np.ones_like(d.x)]) + mean, cov_ref, _ = linear_gaussian( + Xd, d.y, np.diag(d.y_err**2), [0.0, 0.0], 25.0 * np.eye(2) + ) + np.testing.assert_allclose(fit.x, mean, rtol=1e-6) + np.testing.assert_allclose(cov, cov_ref, rtol=1e-8) + # every search from the prior ends at the one mode + np.testing.assert_allclose(fit.ends, fit.fun, rtol=1e-8) diff --git a/test/recipes/test_recipe_34_error_scale_and_usu.py b/test/recipes/test_recipe_34_error_scale_and_usu.py new file mode 100644 index 0000000..b4beeab --- /dev/null +++ b/test/recipes/test_recipe_34_error_scale_and_usu.py @@ -0,0 +1,54 @@ +"""Recipe 34: global error scale factor and unrecognised sources of uncertainty. + +Repeated measurements scatter more than their stated errors. I want a global +scale on the reported errors, or a fully correlated unknown component per +experimental technique. +""" + +import jax.numpy as jnp +import numpy as np +from scipy import stats + +from common import TRUE, line, line_data +from rxmc import Comparison, Constraint, Parameter, Problem, Term +from rxmc import terms as T + + +def test_global_scale_multiplies_every_stated_error(): + d = line_data() + comp = Comparison(d, line()) + log_s = Parameter("log_s", prior=stats.norm(0, 0.5)) + scaled = Term( + lambda c, ls: jnp.exp(ls) * comp.y_err, (log_s,), kind="diag", on=comp + ) + p = Problem([Constraint([comp], terms=[scaled], statistical=False)]) + theta = np.array([*TRUE, np.log(1.5)]) + np.testing.assert_allclose( + np.diag(p.constraints[0].matrix(theta)), 1.5**2 * d.y_err**2 + ) + + +def test_usu_offset_couples_exactly_the_comparisons_of_one_technique(): + model = line() + techs = ("tof", "tof", "act") + datasets = [ + line_data(i, 4, f"d{i}", meta={"technique": t}) for i, t in enumerate(techs) + ] + comps = [Comparison(d, model) for d in datasets] + log_delta = { + t: Parameter(f"log_usu_{t}", prior=stats.norm(-3, 1)) for t in ("tof", "act") + } + usu = [ + T.offset( + log_delta[t], + on=[c for c, d in zip(comps, datasets) if d.meta["technique"] == t], + ) + for t in ("tof", "act") + ] + p = Problem([Constraint(comps, terms=usu)]) + assert p.names == ["m", "b", "log_usu_tof", "log_usu_act"] + theta = np.array([*TRUE, np.log(0.2), np.log(0.1)]) + S = p.constraints[0].matrix(theta) + assert np.allclose(S[:4, 4:8], 0.04) # the two tof datasets are fully correlated + assert np.all(S[:8, 8:] == 0.0) # and uncorrelated with the activation one + assert not p.constraints[0].covariance.dense diff --git a/test/recipes/test_recipe_35_energy_dependent_parameters.py b/test/recipes/test_recipe_35_energy_dependent_parameters.py new file mode 100644 index 0000000..f27d530 --- /dev/null +++ b/test/recipes/test_recipe_35_energy_dependent_parameters.py @@ -0,0 +1,33 @@ +"""Recipe 35: energy-dependent parameters and per-comparison model instances. + +A potential depth depends on energy through a few coefficients I want to +share across datasets at different energies. +""" + +import numpy as np +from scipy import stats + +from rxmc import Comparison, Constraint, Dataset, Model, Parameter, Problem + + +def test_one_model_instance_per_comparison_shares_the_coefficients(): + V0, V1 = Parameter("V0", prior=stats.norm(2, 1)), Parameter( + "V1", prior=stats.norm(0, 0.1) + ) + b = Parameter("b", prior=stats.norm(0, 1)) + + def depth_model(E): + return Model(lambda x, v0, v1, b: (v0 + v1 * E) * x + b, [V0, V1, b]) + + x = np.linspace(0.5, 2.5, 5) + datasets = [ + Dataset(x, x, 0.1 * np.ones(5), label=f"E{E}", meta={"Elab": E}) + for E in (10.0, 30.0) + ] + comps = [Comparison(d, depth_model(d.meta["Elab"])) for d in datasets] + p = Problem([Constraint(comps)]) + assert p.names == ["V0", "V1", "b"] + theta = np.array([2.0, -0.02, 1.0]) + pred = p.predict(theta)[0] + np.testing.assert_allclose(pred[0], (2.0 - 0.02 * 10.0) * x + 1.0) + np.testing.assert_allclose(pred[1], (2.0 - 0.02 * 30.0) * x + 1.0) diff --git a/test/recipes/test_recipe_36_legendre_basis.py b/test/recipes/test_recipe_36_legendre_basis.py new file mode 100644 index 0000000..80ac6c9 --- /dev/null +++ b/test/recipes/test_recipe_36_legendre_basis.py @@ -0,0 +1,49 @@ +"""Recipe 36: discrepancy on a physically constrained basis. + +I know the shape the model defect can take, say a few Legendre modes in +angle, and want the discrepancy restricted to that basis. +""" + +import numpy as np +from scipy import stats +from scipy.special import eval_legendre + +from common import TRUE, line, line_data +from rxmc import Comparison, Constraint, Model, Parameter, Problem +from rxmc import terms as T + + +def test_marginalised_modes_give_a_low_rank_covariance(): + d = line_data() + comp = Comparison(d, line()) + modes = [ + T.systematic( + Parameter(f"log_s{k}", prior=stats.norm(-3, 1)), + basis=lambda c, k=k: eval_legendre(k, np.cos(c.x)), + on=comp, + ) + for k in range(1, 4) + ] + p = Problem([Constraint([comp], terms=modes)]) + assert p.names[2:] == ["log_s1", "log_s2", "log_s3"] + theta = np.array([*TRUE, np.log(0.3), np.log(0.2), np.log(0.1)]) + S = p.constraints[0].matrix(theta) - np.diag(d.y_err**2) + assert np.linalg.matrix_rank(S, tol=1e-10) == 3 + assert not p.constraints[0].covariance.dense + + +def test_sampled_form_lists_the_coefficients_after_the_model(): + d = line_data() + coeffs = [Parameter(f"c{k}", prior=stats.norm(0, 0.1)) for k in range(1, 4)] + delta = Model( + lambda x, *cs: sum( + ck * eval_legendre(k, np.cos(x)) for k, ck in enumerate(cs, 1) + ), + coeffs, + ) + p = Problem([Constraint([Comparison(d, line() + delta)])]) + assert p.names == ["m", "b", "c1", "c2", "c3"] + theta = np.array([*TRUE, 0.1, 0.0, 0.0]) + np.testing.assert_allclose( + p.predict(theta)[0][0], TRUE[0] * d.x + TRUE[1] + 0.1 * np.cos(d.x) + ) diff --git a/test/recipes/test_recipe_37_correlated_normalisations.py b/test/recipes/test_recipe_37_correlated_normalisations.py new file mode 100644 index 0000000..e4a308b --- /dev/null +++ b/test/recipes/test_recipe_37_correlated_normalisations.py @@ -0,0 +1,230 @@ +"""Recipe 37: correlated normalisations between quantities of one experiment. + +One experiment reports several physical quantities, each measured one or +more times, all multiplied by normalisations that were themselves measured +with correlated uncertainties. I want the covariance across the quantities +built so that it does not bias the evaluation. + +The analytic study (section II.A) and the numerical study (section II.B) of +Neudecker, Frühwirth, Kawano and Leeb, Nucl. Data Sheets 118, 364 (2014) are +recreated: quantity i is rho_i = alpha_i * eta_i, alpha_i measured as q_i +(once or several times, independent errors sigma_i), eta_i as N_i with a +correlated covariance B; the data are the products r_i = q_i N_i. C_F is +the covariance built from the measured q (Peelle), C_I the one built from +the weighted means / the prediction. +""" + +import jax.numpy as jnp +import numpy as np +from scipy import stats + +from common import linear_posterior, map_estimate +from rxmc import Comparison, Constraint, Dataset, Model, Parameter, Problem, Term + + +def experiment(q, N, sigma_q, sigma_N, corr, prior=None): + """Comparisons for the quantities with the products ``r = q N`` as data. + + The default prior is normal with a standard deviation of 1000: flat for the + closed-form (fixed-covariance) posteriors, which the oracle needs to be + Gaussian. A prediction-built covariance has a posterior tail falling only + like 1 / rho, so the sampled cases pass a bounded uniform prior instead. + """ + comps, rhos = [], [] + for i, (qi, Ni, si) in enumerate(zip(q, N, sigma_q)): + qi, si = np.asarray(qi, dtype=float), np.asarray(si, dtype=float) + rho = Parameter(f"rho_{i}", prior=prior or stats.norm(0.0, 1e3)) + rhos.append(rho) + d = Dataset(np.full(len(qi), i), qi * Ni, Ni * si, label=f"q{i}") + comps.append(Comparison(d, Model(lambda x, r: jnp.full(len(x), r), [rho]))) + return comps, rhos + + +def normalisation_term(comps, frac, corr, from_data=False): + """``outer(f * ym, f * ym) * corr`` across the quantities (C_I), or from y (C_F).""" + corr = np.asarray(corr, dtype=float) + + def fn(c): + pieces = c.split(c.y if from_data else c.ym) + u = jnp.concatenate([f * piece for f, piece in zip(frac, pieces)]) + which = np.concatenate( + [np.full(s.stop - s.start, k) for k, s in enumerate(c.segments)] + ) + return jnp.outer(u, u) * corr[np.ix_(which, which)] + + return Term(fn, kind="matrix", on=comps, constant=from_data) + + +def one_hot(x): + return np.eye(int(x.max()) + 1)[x.astype(int)] + + +def exact(q, N, sigma_q, sigma_N, corr): + """Means, variances and covariances from the full information (eqs. 2-8).""" + qbar, var_a = [], [] + for qi, si in zip(q, sigma_q): + w = 1.0 / np.asarray(si, dtype=float) ** 2 + qbar.append(np.sum(w * qi) / np.sum(w)) + var_a.append(1.0 / np.sum(w)) + qbar, var_a, N, sN = map(np.asarray, (qbar, var_a, N, sigma_N)) + mean = qbar * N + cov = np.outer(qbar * sN, qbar * sN) * np.asarray(corr) + cov[np.diag_indices_from(cov)] += var_a * N**2 + return mean, cov, qbar, var_a + + +# section II.A: two quantities, the first measured twice +Q = [np.array([1.0, 1.5]), np.array([1.8])] +N = np.array([1.0, 1.1]) +SIGMA_Q = [0.1 * Q[0], 0.1 * Q[1]] +SIGMA_N = 0.2 * N +C = 0.8 +CORR = np.array([[1.0, C], [C, 1.0]]) + + +def test_the_prediction_built_covariance_is_the_analytic_solution(): + comps, rhos = experiment(Q, N, SIGMA_Q, SIGMA_N, CORR) + mean, cov, qbar, var_a = exact(Q, N, SIGMA_Q, SIGMA_N, CORR) + # C_I in its fixed form: the weighted means stand in for the prediction + fixed = Term( + _fixed_matrix(qbar * N, SIGMA_N / N, CORR, [len(q) for q in Q]), + kind="matrix", + on=comps, + ) + p_I = Problem([Constraint(comps, terms=[fixed])]) + mean_I, cov_I, _ = linear_posterior(p_I, design=one_hot) + np.testing.assert_allclose(mean_I, mean, rtol=1e-6) # eqs. 18, 19 + np.testing.assert_allclose(cov_I, cov, rtol=1e-6) # eqs. 20-22 + # the live term reads the prediction: at the exact means it is that matrix + live = normalisation_term(comps, SIGMA_N / N, CORR) + p_live = Problem([Constraint(comps, terms=[live])]) + S = p_live.constraints[0].matrix(mean) + np.testing.assert_allclose(S, p_I.constraints[0].matrix(mean)) + + +def _fixed_matrix(rho, frac, corr, counts): + u = np.concatenate([np.full(n, f * r) for n, f, r in zip(counts, frac, rho)]) + which = np.concatenate([np.full(n, k) for k, n in enumerate(counts)]) + return np.outer(u, u) * np.asarray(corr)[np.ix_(which, which)] + + +def test_the_data_built_covariance_is_peelles_puzzle_in_two_dimensions(): + comps, rhos = experiment(Q, N, SIGMA_Q, SIGMA_N, CORR) + mean, cov, qbar, var_a = exact(Q, N, SIGMA_Q, SIGMA_N, CORR) + p_F = Problem( + [ + Constraint( + comps, + terms=[normalisation_term(comps, SIGMA_N / N, CORR, from_data=True)], + ) + ] + ) + mean_F, cov_F, _ = linear_posterior(p_F, design=one_hot) + q1, q1p = Q[0] + s1, s1p = SIGMA_Q[0] + xi = (q1 - q1p) ** 2 * SIGMA_N[0] ** 2 * var_a[0] / (N[0] ** 2 * s1**2 * s1p**2) + # eqs. 13-17 of the reference + np.testing.assert_allclose(mean_F[0], qbar[0] * N[0] / (1 + xi), rtol=1e-6) + np.testing.assert_allclose( + mean_F[1], + Q[1][0] + * N[1] + * (1 - C * xi * N[0] * SIGMA_N[1] / (N[1] * SIGMA_N[0]) / (1 + xi)), + rtol=1e-6, + ) + # eq. 15: only the normalisation part of var(rho_1) is deflated + np.testing.assert_allclose( + cov_F[0, 0], + var_a[0] * N[0] ** 2 + SIGMA_N[0] ** 2 * qbar[0] ** 2 / (1 + xi), + rtol=1e-6, + ) + np.testing.assert_allclose( + cov_F[1, 1], + cov[1, 1] - C**2 * xi * Q[1][0] ** 2 * SIGMA_N[1] ** 2 / (1 + xi), + rtol=1e-6, + ) + np.testing.assert_allclose(cov_F[0, 1], cov[0, 1] / (1 + xi), rtol=1e-6) + # the puzzle: both means are biased low, both variances too small + assert xi > 0 and np.all(mean_F < mean) and np.all(np.diag(cov_F) < np.diag(cov)) + + +# section II.B: the five-quantity numerical study, Table I of the reference +Q5 = [ + np.array([1.0, 1.5]), + np.array([1.8]), + np.array([2.2, 2.4]), + np.array([1.9, 1.5]), + np.array([1.4, 1.2]), +] +N5 = np.array([1.0, 1.1, 1.25, 1.15, 1.05]) +SIGMA_Q5 = [0.1 * q for q in Q5] +SIGMA_N5 = 0.2 * N5 +CORR5 = np.full((5, 5), C) + (1 - C) * np.eye(5) + + +def test_five_quantities_reproduce_figure_1_in_ordering(): + comps, rhos = experiment(Q5, N5, SIGMA_Q5, SIGMA_N5, CORR5) + mean, cov, qbar, var_a = exact(Q5, N5, SIGMA_Q5, SIGMA_N5, CORR5) + p_F = Problem( + [ + Constraint( + comps, + terms=[normalisation_term(comps, SIGMA_N5 / N5, CORR5, from_data=True)], + ) + ] + ) + mean_F, cov_F, _ = linear_posterior(p_F, design=one_hot) + assert np.all(mean_F < mean) and np.all(np.diag(cov_F) < np.diag(cov)) + fixed = Term( + _fixed_matrix(mean, SIGMA_N5 / N5, CORR5, [len(q) for q in Q5]), + kind="matrix", + on=comps, + ) + mean_I, cov_I, _ = linear_posterior( + Problem([Constraint(comps, terms=[fixed])]), design=one_hot + ) + np.testing.assert_allclose(mean_I, mean, rtol=1e-6) + np.testing.assert_allclose(np.diag(cov_I), np.diag(cov), rtol=1e-6) + + +def test_the_live_prediction_built_term_carries_the_log_determinant_pull(): + """The live term is the generative model's marginal likelihood, not C_I. + + Its mode is pulled below the exact values by the log-determinant of a + covariance that grows with the prediction (5 % in the two-quantity case, + 9 % here with 20 % normalisation errors), though far less than the + data-built C_F; under a flat prior its mean is pulled the other way by + the 1 / rho tail. The two-step refit (a constant term from a first + estimate, recipe 27) is what reproduces the reference exactly. + """ + comps, rhos = experiment( + Q5, N5, SIGMA_Q5, SIGMA_N5, CORR5, prior=stats.uniform(0, 10) + ) + mean, cov, *_ = exact(Q5, N5, SIGMA_Q5, SIGMA_N5, CORR5) + p_I = Problem( + [Constraint(comps, terms=[normalisation_term(comps, SIGMA_N5 / N5, CORR5)])] + ) + mode = map_estimate(p_I, mean) + p_F = Problem( + [ + Constraint( + comps, + terms=[normalisation_term(comps, SIGMA_N5 / N5, CORR5, from_data=True)], + ) + ] + ) + mean_F, *_ = linear_posterior(p_F, design=one_hot) + pull = mode / mean - 1 + assert np.all(pull < 0) and np.all(pull > -0.12) + assert np.all(np.abs(mode - mean) < np.abs(mean_F - mean)) + # the refit: a constant term built at the first estimate is exact again + comps_flat, _ = experiment(Q5, N5, SIGMA_Q5, SIGMA_N5, CORR5) + fixed = Term( + _fixed_matrix(mean, SIGMA_N5 / N5, CORR5, [len(q) for q in Q5]), + kind="matrix", + on=comps_flat, + ) + mean_I, *_ = linear_posterior( + Problem([Constraint(comps_flat, terms=[fixed])]), design=one_hot + ) + np.testing.assert_allclose(mean_I, mean, rtol=1e-6) diff --git a/test/recipes/test_recipe_38_eight_schools.py b/test/recipes/test_recipe_38_eight_schools.py new file mode 100644 index 0000000..a4e3f05 --- /dev/null +++ b/test/recipes/test_recipe_38_eight_schools.py @@ -0,0 +1,105 @@ +"""Recipe 38: the classic normal hierarchical model (eight schools). + +Several groups each report an estimate y_j with a known standard error +sigma_j. I believe the group effects theta_j are drawn from a common +distribution N(mu, tau^2) and want to learn mu, tau, and the shrunken +theta_j. +""" + +import jax.numpy as jnp +import jax.scipy.stats as jst +import numpy as np +import pytest +from scipy import stats + +from rxmc import Comparison, Constraint, Dataset, Model, Parameter, Problem +from rxmc import terms as T + +Y = np.array([28.0, 8.0, -3.0, 7.0, -1.0, 1.0, 18.0, 12.0]) +S = np.array([15.0, 10.0, 16.0, 11.0, 9.0, 11.0, 10.0, 18.0]) +J = len(Y) +SCHOOLS = Dataset(np.arange(J), Y, S, label="schools") + + +def marginalised(): + mu, log_tau = ( + Parameter("mu", prior=stats.norm(0, 25)), + Parameter("log_tau", prior=stats.norm(1, 1)), + ) + model = Model(lambda x, mu: jnp.full(len(x), mu), [mu]) + return ( + Problem([Constraint([Comparison(SCHOOLS, model)], terms=[T.noise(log_tau)])]), + mu, + log_tau, + ) + + +def non_centred(mu, log_tau): + etas = [Parameter(f"eta_{j}", prior=stats.norm(0, 1)) for j in range(J)] + school = Model( + lambda x, mu, lt, *eta: mu + np.exp(lt) * np.asarray(eta), [mu, log_tau, *etas] + ) + return Problem([Constraint([Comparison(SCHOOLS, school)])]), etas + + +def test_marginalised_form_has_two_columns_and_the_right_covariance(): + p, mu, log_tau = marginalised() + assert p.names == ["mu", "log_tau"] + theta = np.array([5.0, np.log(4.0)]) + np.testing.assert_allclose(np.diag(p.constraints[0].matrix(theta)), S**2 + 16.0) + + +def test_non_centred_form_marginalises_to_the_same_likelihood(): + pm, mu, log_tau = marginalised() + pn, etas = non_centred(mu, log_tau) + assert pn.names == ["mu", "log_tau", *[f"eta_{j}" for j in range(J)]] + assert np.all( + np.isfinite(pn.prior_transform(np.full(J + 2, 0.5))) + ) # marginals only + # integrate the etas out numerically for one school and compare to the + # marginalised likelihood of that school: N(y_j | mu, s_j^2 + tau^2) + mu_v, tau = 5.0, 4.0 + eta = np.linspace(-6, 6, 4001) + j = 0 + integrand = stats.norm(mu_v + tau * eta, S[j]).pdf(Y[j]) * stats.norm(0, 1).pdf(eta) + marg = np.log(np.trapezoid(integrand, eta)) + assert marg == pytest.approx( + stats.norm(mu_v, np.hypot(S[j], tau)).logpdf(Y[j]), abs=1e-6 + ) + + +def test_centred_form_is_a_joint_block_including_the_hyperparameters(): + class SchoolHierarchy: + def logpdf(self, v): + *th, mu, lt = v + return ( + jst.norm.logpdf(jnp.stack(th), mu, jnp.exp(lt)).sum() + + jst.norm.logpdf(mu, 0, 25) + + jst.norm.logpdf(lt, 1, 1) + ) + + thetas = [Parameter(f"theta_{j}") for j in range(J)] + mu, log_tau = Parameter("mu"), Parameter("log_tau") + model = Model(lambda x, *th: jnp.stack(th), thetas) + p = Problem( + [Constraint([Comparison(SCHOOLS, model)])], + priors=[(thetas + [mu, log_tau], SchoolHierarchy())], + ) + assert p.names == [*[f"theta_{j}" for j in range(J)], "mu", "log_tau"] + theta = np.array([*Y, 5.0, np.log(4.0)]) + assert np.isfinite(p.log_posterior(theta)) + with pytest.raises(NotImplementedError): + p.prior_transform( + np.full(J + 2, 0.5) + ) # no unit-cube map for a custom joint without one + + +def test_a_held_out_school_keeps_its_eta(): + pm, mu, log_tau = marginalised() + pn, etas = non_centred(mu, log_tau) + c = pn.constraints[0].source + fit = c.masked([np.arange(J) < J - 1]) + pf = Problem([fit]) + assert pf.names == pn.names + s = pf.sample_prior(20, rng=0) + assert np.std(s[:, -1]) > 0.5 # eta of the held-out school is drawn from its prior diff --git a/test/recipes/test_recipe_39_iterative_outlier_rejection.py b/test/recipes/test_recipe_39_iterative_outlier_rejection.py new file mode 100644 index 0000000..c46c5af --- /dev/null +++ b/test/recipes/test_recipe_39_iterative_outlier_rejection.py @@ -0,0 +1,84 @@ +"""Recipe 39: iterative outlier rejection. + +A few points are gross outliers. I want to reject them and refit, in an +outer loop of problems, until the mask stops moving. +""" + +import numpy as np +import pytest + +from common import TRUE, line, map_estimate +from rxmc import Comparison, Constraint, Dataset, Problem + +X = np.linspace(0.5, 3.0, 12) +BAD = (3, 8) # the points pushed off the line +PUSH = 12.0 # in units of the reported error +ERR = 0.1 + + +def outlier_data(seed=0): + """Twelve points on the line, two of them pushed far above it.""" + rng = np.random.default_rng(seed) + y = TRUE[0] * X + TRUE[1] + rng.normal(0, ERR, X.size) + y[list(BAD)] += PUSH * ERR + return Dataset(X, y, np.full(X.size, ERR), label="outliers") + + +def reject(constraint, data, *, k=3.0, max_rounds=6): + """The recipe: fit, mask the points more than ``k`` pulls away, refit.""" + mask = np.ones(data.n, dtype=bool) + for rounds in range(1, max_rounds + 1): + problem = Problem([constraint.masked([mask])]) + theta = map_estimate(problem, np.array(TRUE)) + pull = np.abs(data.y - problem.constraints[0].ym(theta)) / data.y_err + keep = pull < k + if np.array_equal(keep, mask): + return mask, theta, rounds + mask = keep + raise AssertionError("the mask did not settle") + + +def _rms_from_truth(theta, rows): + """How far the fitted line sits from the truth, over ``rows``.""" + offset = (theta[0] * X + theta[1]) - (TRUE[0] * X + TRUE[1]) + return float(np.sqrt(np.mean(offset[rows] ** 2))) + + +def test_the_loop_settles_on_the_planted_outliers(): + d = outlier_data() + c = Constraint([Comparison(d, line())]) + mask, theta, rounds = reject(c, d) + assert rounds > 1 # the first fit is dragged, so one pass is not enough + assert np.array_equal(np.flatnonzero(~mask), np.array(BAD)) + ym = Problem([c.masked([mask])]).constraints[0].ym(theta) + pull = np.abs(d.y - ym) / d.y_err + assert np.max(pull[mask]) < 3.0 and np.min(pull[~mask]) > 10.0 + + +def test_a_fit_that_keeps_the_outliers_is_dragged_away_from_the_truth(): + d = outlier_data() + c = Constraint([Comparison(d, line())]) + mask, theta, _ = reject(c, d) + naive = map_estimate(Problem([c]), np.array(TRUE)) + kept = np.flatnonzero(mask) + assert _rms_from_truth(naive, kept) > 3 * _rms_from_truth(theta, kept) + + +def test_the_rejected_points_are_named_by_the_complement_and_keep_their_columns(): + d = outlier_data() + c = Constraint([Comparison(d, line())]) + mask, _, _ = reject(c, d) + kept, rejected = c.masked([mask]), c.masked([mask]).complement() + assert np.array_equal(rejected.active, np.array(BAD)) + assert set(kept.active).isdisjoint(rejected.active) + assert kept.n_active + rejected.n_active == d.n + assert Problem([kept]).names == Problem([c]).names + + +def test_the_loop_is_reproducible(): + d = outlier_data() + c = Constraint([Comparison(d, line())]) + first, theta_a, rounds_a = reject(c, d) + second, theta_b, rounds_b = reject(c, d) + assert np.array_equal(first, second) and rounds_a == rounds_b + assert theta_a == pytest.approx(theta_b) diff --git a/test/recipes/test_recipe_40_predict_on_a_new_grid.py b/test/recipes/test_recipe_40_predict_on_a_new_grid.py new file mode 100644 index 0000000..95fff6f --- /dev/null +++ b/test/recipes/test_recipe_40_predict_on_a_new_grid.py @@ -0,0 +1,83 @@ +"""Recipe 40: predict on a new grid, error model included. + +I have a posterior, and I want predictions at ``x`` I never measured — a fine +plotting grid, an extrapolation — carrying the uncertainty my error model +declares, not only the spread of the model curves. +""" + +import numpy as np +import pytest +from scipy import stats + +from common import TRUE, line, oracle_samples +from rxmc import Comparison, Constraint, Dataset, Parameter, Problem +from rxmc import terms as T +from rxmc.diagnostics import coverage_curve, predictive_draws +from rxmc.predictive import grid_draws + +SIGMA = 0.1 +X_FINE = np.linspace(-1.0, 4.0, 40) # past the data on both sides + + +def data(n=200, seed=4): + rng = np.random.default_rng(seed) + x = np.linspace(0.5, 2.5, n) + y = TRUE[0] * x + TRUE[1] + rng.normal(0.0, SIGMA, n) + return Dataset(x, y, np.full(n, SIGMA), label="d") + + +def problems(): + """The same line with the reported errors, and with a constant inferred noise.""" + d = data() + model = line() + comp = Comparison(d, model) + reported = Problem([Constraint([comp])]) + log_sigma = Parameter("log_sigma", prior=stats.norm(np.log(0.2), 1.0)) + inferred = Problem( + [Constraint([comp], terms=[T.noise(log_sigma)], statistical=False)] + ) + return reported, inferred, model, d + + +def chain(reported, n=400): + """Exact posterior rows for (m, b), with the noise at its true value.""" + mb = oracle_samples(reported, n, rng=0) + return np.column_stack([mb, np.full(n, np.log(SIGMA))]) + + +def test_the_error_model_travels_to_the_grid_and_the_model_band_does_not_widen(): + reported, inferred, model, _ = problems() + rows = chain(reported) + pred = model.bind(X_FINE) + curve = grid_draws(inferred, pred, X_FINE, rows, model_only=True, levels=(16, 84)) + full = grid_draws(inferred, pred, X_FINE, rows, n_rep=4, rng=1, levels=(16, 84)) + w_curve, w_full = curve[1] - curve[0], full[1] - full[0] + # a measurement at any x scatters by sigma about a curve known far better + np.testing.assert_allclose(np.sqrt(w_full**2 - w_curve**2) / 2, SIGMA, rtol=0.15) + # and the curve's own uncertainty fans out away from the data + assert w_curve[0] > 3 * w_curve[len(X_FINE) // 2] + + +def test_at_the_data_the_model_band_under_covers_and_the_full_one_does_not(): + reported, inferred, _, d = problems() + rows = chain(reported) + levels = np.array([0.5, 0.68, 0.9]) + c = inferred.constraints[0] + y = c.y[c.active] + full = predictive_draws(inferred, rows, n_rep=4, rng=2, return_draws=True) + curve = predictive_draws(inferred, rows, model_only=True, return_draws=True) + np.testing.assert_allclose(coverage_curve(full, y, levels), levels, atol=0.08) + assert np.all(coverage_curve(curve, y, levels) < 0.5 * levels) + + +def test_reported_errors_have_no_value_off_the_measured_points(): + reported, _, model, _ = problems() + rows = chain(reported)[:, :2] + pred = model.bind(X_FINE) + with pytest.raises(ValueError, match="reported statistical errors"): + grid_draws(reported, pred, X_FINE, rows) + # saying so explicitly is allowed: the model alone + band = grid_draws(reported, pred, X_FINE, rows, terms=[]) + np.testing.assert_allclose( + band, grid_draws(reported, pred, X_FINE, rows, model_only=True) + ) diff --git a/test/recipes/test_recipe_41_hmc_and_nuts.py b/test/recipes/test_recipe_41_hmc_and_nuts.py new file mode 100644 index 0000000..148fb38 --- /dev/null +++ b/test/recipes/test_recipe_41_hmc_and_nuts.py @@ -0,0 +1,58 @@ +"""Recipe 41: sample with gradients (HMC/NUTS). + +My problem has many parameters, or a sampler that walks without gradients +mixes slowly on it. I want the No-U-Turn sampler, driven by the exact +gradient of the posterior. +""" + +import blackjax +import jax +import numpy as np +from scipy import stats + +import rxmc as rx +from common import line_data, line_problem, linear_posterior +from rxmc import Comparison, Constraint, Model, Parameter, Problem + + +def nuts(problem, seed, n_warmup=300, n_draws=1000): + """The recipe's spelling: one adapted NUTS chain, mapped back to theta.""" + logdensity = problem.log_posterior_unconstrained + z0 = problem.to_unconstrained(rx.optimize.find_map(problem, rng=seed).x) + k_warm, k_draw = jax.random.split(jax.random.key(seed)) + warmup = blackjax.window_adaptation(blackjax.nuts, logdensity) + (state, tuned), _ = warmup.run(k_warm, z0, num_steps=n_warmup) + step = jax.jit(blackjax.nuts(logdensity, **tuned).step) + + def one_step(state, key): + state, info = step(key, state) + return state, (state.position, info.is_divergent) + + keys = jax.random.split(k_draw, n_draws) + _, (zs, divergent) = jax.lax.scan(one_step, state, keys) + return np.asarray(jax.vmap(problem.to_theta)(zs)), int(divergent.sum()) + + +def test_nuts_recovers_the_linear_gaussian_posterior(): + problem, _ = line_problem() + mean, cov, _ = linear_posterior(problem) + chains = [nuts(problem, seed) for seed in (0, 1)] + samples = np.concatenate([c[0] for c in chains]) + assert sum(c[1] for c in chains) == 0 + ess = blackjax.diagnostics.ess_bulk(np.stack([c[0] for c in chains])) + mcse = np.sqrt(np.diag(cov) / ess) + assert np.all(np.abs(samples.mean(0) - mean) < 4 * mcse) + np.testing.assert_allclose(np.cov(samples.T), cov, rtol=0.2) + + +def test_bounded_parameters_are_sampled_inside_their_bounds(): + # the intercept's posterior (1.0 +/- 0.07) presses on its upper bound + m = Parameter("m", prior=stats.norm(0, 5)) + b = Parameter("b", prior=stats.norm(0, 5), bounds=(0.0, 1.05)) + model = Model(lambda x, m, b: m * x + b, [m, b]) + problem = Problem([Constraint([Comparison(line_data(), model)])]) + samples, divergent = nuts(problem, seed=2) + col = samples[:, problem.columns(b)] + assert divergent == 0 + assert np.all((col > 0.0) & (col < 1.05)) + assert col.mean() < 1.05 and np.mean(col > 1.0) > 0.1 # mass right up to the bound diff --git a/test/test_autodiff.py b/test/test_autodiff.py new file mode 100644 index 0000000..24d37a4 --- /dev/null +++ b/test/test_autodiff.py @@ -0,0 +1,385 @@ +"""Gradients through ``Problem.log_posterior``: JAX autodiff against central +finite differences, one problem per family of the error model. + +The families follow the recipes: reported errors (01), unknown noise (02), +a free normalisation and offset (04), a latent scale (06), a GP discrepancy +(07), log space (10), a hyperprior (24), a model error +proportional to the prediction (26), and the two jitr reaction models. +""" + +import jax +import jax.numpy as jnp +import jax.scipy.stats as jst +import jitr +import numpy as np +import pytest +import tinygp +from jitr.optical_potentials.potential_forms import ( + coulomb_charged_sphere, + thomas_safe, + woods_saxon_safe, +) +from scipy import stats + +from rxmc import ( + Comparison, + Constraint, + Dataset, + Model, + Parameter, + Problem, +) +from rxmc import terms as T +from rxmc import transforms as tf +from rxmc.reactions import ElasticXS, IsobaricAnalogPN + +X = np.linspace(0.5, 2.5, 10) + + +def line(): + m = Parameter("m", prior=stats.norm(0, 5)) + b = Parameter("b", prior=stats.norm(0, 5)) + return Model(lambda x, m, b: m * x + b, [m, b]) + + +def data(seed=0, n=10, label="d", offset=0.0): + rng = np.random.default_rng(seed) + x = X[:n] + y = 2.0 * x + 1.0 + offset + rng.normal(0, 0.1, n) + return Dataset(x, y, 0.1 * np.ones(n), label=label) + + +def fd_grad(f, theta, h=1e-6): + g = np.empty_like(theta) + for i in range(len(theta)): + e = np.zeros_like(theta) + e[i] = h * max(1.0, abs(theta[i])) + g[i] = (f(theta + e) - f(theta - e)) / (2 * e[i]) + return g + + +def reported(): + return Problem([Constraint([Comparison(data(), line())])]), [2.1, 0.9] + + +def unknown_noise(): + log_eps = Parameter("log_eps", prior=stats.norm(-2, 1)) + c = Constraint([Comparison(data(), line())], terms=[T.noise(log_eps)]) + return Problem([c]), [2.1, 0.9, -1.5] + + +def normalisation_and_offset(): + eta = Parameter("log_eta", prior=stats.norm(-3, 1)) + om = Parameter("log_om", prior=stats.norm(-3, 1)) + c = Constraint( + [Comparison(data(), line())], + terms=[T.normalization(eta), T.offset(om), T.systematic(eta, T.x_basis())], + ) + return Problem([c]), [2.1, 0.9, -2.5, -2.0] + + +def latent_scale(): + rho = Parameter("log_rho", prior=stats.norm(0, 0.1)) + c = Constraint([Comparison(data(), line() | tf.scale(rho))]) + return Problem([c]), [2.1, 0.9, 0.05] + + +def gp_discrepancy(): + params = T.kernel_params(["log_var", "log_ell"], [(-12.0, 2.0), (-3.0, 1.0)]) + gp = T.kernel( + lambda v, e: jnp.exp(v) * tinygp.kernels.Matern52(scale=jnp.exp(e)), params + ) + c = Constraint([Comparison(data(), line())], terms=[gp]) + return Problem([c]), [2.1, 0.9, -3.0, -0.5] + + +def log_space(): + log_eps = Parameter("log_eps", prior=stats.norm(-2, 1)) + c = Constraint( + [Comparison(data(), line(), space=tf.log)], + terms=[T.noise(log_eps)], + ) + return Problem([c]), [2.1, 0.9, -2.0] + + +class Hierarchy: + """``log_rho_i ~ N(0, tau)`` with a half-normal hyperprior on ``tau``.""" + + def logpdf(self, v): + *r, lt = v + tau = jnp.exp(lt) + halfnorm = jnp.log(2.0) + jst.norm.logpdf(tau, scale=0.3) + return jst.norm.logpdf(jnp.stack(r), scale=tau).sum() + halfnorm + lt + + +def hyperprior(): + rhos = [Parameter(f"log_rho_{i}") for i in range(3)] + log_tau = Parameter("log_tau") + model = line() + comps = [ + Comparison(data(i, 5, f"d{i}"), model | tf.scale(rho)) + for i, rho in enumerate(rhos) + ] + p = Problem([Constraint(comps)], priors=[(rhos + [log_tau], Hierarchy())]) + return p, [2.1, 0.9, 0.02, -0.03, 0.01, np.log(0.1)] + + +def proportional_model_error(): + log_c = Parameter("log_c", prior=stats.norm(-3, 1)) + c = Constraint( + [Comparison(data(), line())], + terms=[T.proportional_error(log_c, averaging=True)], + ) + return Problem([c]), [2.1, 0.9, -2.5] + + +A, Z = 40, 20 +R = 1.2 * A ** (1 / 3) +MSO = 1.0 / jitr.utils.constants.WAVENUMBER_PION + + +def central(r, Vv, Wv, Rv, av): + return -(Vv + 1j * Wv) * woods_saxon_safe(r, Rv, av) + + +def spin_orbit(r, Vso, Rso, aso): + return Vso * MSO**2 * thomas_safe(r, Rso, aso) + + +def omp_params(): + return [ + Parameter("Vv", bounds=(40.0, 56.0)), + Parameter("Wv", bounds=(1.0, 8.0)), + Parameter("Rv", bounds=(0.9 * R, 1.1 * R)), + Parameter("av", bounds=(0.5, 0.8)), + ] + + +def elastic(): + rxn = jitr.reactions.ElasticReaction(target=(A, Z), projectile=(1, 0)) + model = ElasticXS( + "dXS/dA", + central, + spin_orbit, + lambda ws, *x: (tuple(x), (6.0, R, 0.45)), + omp_params(), + lmax=10, + ) + meta = {"reaction": rxn, "Elab": 14.1} + angles = np.linspace(0.3, 2.6, 8) + y = np.asarray(model.bind(angles, meta)(48.0, 3.5, R, 0.7)) + d = Dataset(angles, 1.05 * y, 0.05 * y, label="n", meta=meta) + log_c = Parameter("log_c", bounds=(-6.0, 0.0)) + comp = Comparison(d, model, space=tf.log) + c = Constraint([comp], terms=[T.noise(log_c)]) + return Problem([c]), [47.0, 3.8, 1.02 * R, 0.68, -3.0] + + +def ias(): + A, Z = 48, 20 + R = 1.2 * A ** (1 / 3) + rxn = jitr.reactions.Reaction( + target=(A, Z), projectile=(1, 1), product=(1, 0), residual=(A, Z + 1) + ) + model = IsobaricAnalogPN( + coulomb_charged_sphere, + central, + spin_orbit, + central, + spin_orbit, + lambda ws, Vv, Wv, Rv, av: ( + (Z, R), + (Vv + 4.0, Wv, Rv, av), + (6.0, R, 0.45), + (Vv - 4.0, Wv, Rv, av), + (6.0, R, 0.45), + ), + [Parameter(n, prior=stats.norm(v, 5.0)) for n, v in zip("VWRa", (48, 4, R, 1))], + lmax=10, + ) + meta = {"reaction": rxn, "Elab": 25.0, "ExIAS": 6.7} + angles = np.linspace(0.3, 2.6, 6) + y = np.asarray(model.bind(angles, meta)(48.0, 3.5, R, 0.7)) + d = Dataset(angles, 1.05 * y, 0.05 * y, label="pn", meta=meta) + return Problem([Constraint([Comparison(d, model)])]), [47.0, 3.8, 1.02 * R, 0.68] + + +FAMILIES = { + "reported errors (01)": reported, + "unknown noise (02)": unknown_noise, + "normalisation and offset (04)": normalisation_and_offset, + "latent scale (06)": latent_scale, + "GP discrepancy (07)": gp_discrepancy, + "log space (10)": log_space, + "hyperprior (24)": hyperprior, + "proportional model error (26)": proportional_model_error, + "elastic reaction": elastic, + "(p,n) reaction": ias, +} + + +@pytest.mark.parametrize("family", list(FAMILIES)) +def test_autodiff_gradient_matches_finite_differences(family): + problem, theta = FAMILIES[family]() + theta = np.asarray(theta, dtype=float) + assert np.isfinite(problem.log_posterior(theta)) + g = problem.grad_log_posterior(theta) + np.testing.assert_allclose( + g, fd_grad(problem.log_posterior, theta), rtol=1e-4, atol=1e-5 + ) + # jax.grad of the public method is the same gradient + np.testing.assert_allclose(jax.grad(problem.log_posterior)(theta), g, rtol=1e-12) + + +def test_value_and_grad_and_hessian_agree_with_the_scalar_methods(): + problem, theta = gp_discrepancy() + theta = np.asarray(theta) + v, g = problem.value_and_grad_log_posterior(theta) + assert v == pytest.approx(problem.log_posterior(theta)) + np.testing.assert_allclose(g, problem.grad_log_posterior(theta)) + H = problem.hessian_log_posterior(theta) + np.testing.assert_allclose(H, H.T, rtol=1e-8, atol=1e-8) + np.testing.assert_allclose( + H[0], fd_grad(lambda t: problem.grad_log_posterior(t)[0], theta), rtol=1e-4 + ) + + +def test_batch_is_the_vectorised_scalar_and_outside_the_prior_is_minus_inf(): + problem, theta = latent_scale() + thetas = problem.sample_prior(16, rng=0) + np.testing.assert_allclose( + problem.log_posterior_batch(thetas), + [problem.log_posterior(t) for t in thetas], + ) + bounded, _ = elastic() + out = np.array([60.0, 3.8, R, 0.68, -3.0]) # Vv above its bound + assert bounded.log_posterior(out) == -np.inf + # the forward model is not run there, so the gradient is clean + assert np.all(bounded.grad_log_posterior(out) == 0.0) + + +def test_the_compiled_densities_are_traced_once(): + problem, theta = unknown_noise() + for t in problem.sample_prior(5, rng=0): + problem.log_posterior(t) + problem.grad_log_posterior(t) + # one compiled executable per density, whatever theta (and its dtype) is + problem.log_posterior([2, 1, -2]) + assert problem._log_posterior_j._cache_size() == 1 + assert problem._vg_j._cache_size() == 1 + + +def test_gradient_is_finite_where_the_covariance_is_singular(): + """A rejected theta inside the prior has the prior's gradient alone.""" + s = Parameter("s", prior=stats.norm(0, 5)) + noise = T.Term(lambda c, s: s * jnp.ones(len(c)), [s], kind="diag") + # no reported errors, so s = 0 leaves a zero diagonal + diag = Problem( + [Constraint([Comparison(data(), line())], terms=[noise], statistical=False)] + ) + params = T.kernel_params(["log_var"], [(-12.0, 2.0)]) + gp = T.kernel( + lambda v: jnp.exp(v) * tinygp.kernels.ExpSquared(scale=100.0), + params, + jitter=0.0, + ) + # and a smooth kernel alone, without its nugget, is singular on 10 points + dense = Problem( + [Constraint([Comparison(data(), line())], terms=[gp], statistical=False)] + ) + for problem, theta in [(diag, [1.0, 0.0, 0.0]), (dense, [2.1, 0.9, -3.0])]: + theta = np.asarray(theta) + assert problem.log_posterior(theta) == -np.inf + v, g = problem.value_and_grad_log_posterior(theta) + assert v == -np.inf and np.all(np.isfinite(g)) + np.testing.assert_allclose(g, jax.grad(problem.log_prior)(theta)) + assert np.all(np.isfinite(problem.hessian_log_posterior(theta))) + + +def test_bounded_custom_joint_has_a_finite_gradient_out_of_bounds(): + class LogNormalPair: + def logpdf(self, v): + return jnp.sum(jst.norm.logpdf(jnp.log(v)) - jnp.log(v)) + + m = Parameter("m", bounds=(0.0, np.inf)) + b = Parameter("b", bounds=(0.0, np.inf)) + model = Model(lambda x, m, b: m * x + b, [m, b]) + p = Problem( + [Constraint([Comparison(data(), model)])], priors=[([m, b], LogNormalPair())] + ) + out = np.array([-1.0, 1.0]) + assert p.log_prior(out) == -np.inf + assert np.all(jax.grad(p.log_prior)(out) == 0.0) + assert np.all(p.grad_log_posterior(out) == 0.0) + assert np.isfinite(p.log_posterior([2.0, 1.0])) + + +def four_bound_kinds(): + """One parameter per kind of bound: none, below, between, above.""" + params = [ + Parameter("free", prior=stats.norm(0, 1)), + Parameter("pos", prior=stats.norm(1, 1), bounds=(0.0, np.inf)), + Parameter("box", bounds=(-1.0, 2.0)), + Parameter("neg", prior=stats.norm(0, 1), bounds=(-np.inf, 0.5)), + ] + model = Model(lambda x, a, b, c, d: a * x + b + c + d, params) + return Problem([Constraint([Comparison(data(n=5), model)])]) + + +def test_the_unconstrained_map_round_trips_with_its_jacobian(): + problem = four_bound_kinds() + theta = np.array([0.3, 0.7, 0.4, -0.2]) + z = problem.to_unconstrained(theta) + np.testing.assert_allclose(problem.to_theta(z), theta, rtol=1e-12) + J = jax.jacfwd(lambda z: problem._to_theta_impl(z)[0])(z) + _, log_jac = problem._to_theta_impl(z) + assert log_jac == pytest.approx(np.log(abs(np.linalg.det(J)))) + assert problem.log_posterior_unconstrained(z) == pytest.approx( + problem.log_posterior(theta) + log_jac + ) + np.testing.assert_allclose( + jax.grad(problem.log_posterior_unconstrained)(z), + fd_grad(problem.log_posterior_unconstrained, z), + rtol=1e-5, + ) + # finite, with a finite gradient, far out in every direction + far = np.array([30.0, -40.0, 50.0, 60.0]) + assert np.isfinite(problem.log_posterior_unconstrained(far)) + assert np.all(np.isfinite(jax.grad(problem.log_posterior_unconstrained)(far))) + + +@pytest.mark.parametrize("bounds", [(0.0, np.inf), (-1.0, 2.0), (-np.inf, 0.5)]) +def test_the_unconstrained_density_has_the_bounded_densitys_mass(bounds): + from scipy.integrate import quad + + t = Parameter("t", prior=stats.norm(0.2, 1.0), bounds=bounds) + problem = Problem( + [Constraint([Comparison(data(n=3), Model(lambda x, t: t * x, [t]))])] + ) + peak = max( + problem.log_posterior_unconstrained([z]) for z in np.linspace(-5, 5, 201) + ) + + def mass(f, lo, hi): + return quad(lambda v: np.exp(f([v]) - peak), lo, hi, limit=200)[0] + + bounded = mass(problem.log_posterior, *bounds) + free = mass(problem.log_posterior_unconstrained, -np.inf, np.inf) + assert free == pytest.approx(bounded, rel=1e-6) + + +def test_a_prior_with_finite_support_bounds_the_unconstrained_map(): + """A uniform or half-normal prior bounds its parameter without bounds=.""" + log_s = Parameter("log_s", prior=stats.uniform(np.log(0.05), np.log(40.0))) + scale = Parameter("scale", prior=stats.halfnorm(scale=2.0)) + model = Model(lambda x, a, b: a * x + b, [log_s, scale]) + problem = Problem([Constraint([Comparison(data(n=5), model)])]) + np.testing.assert_allclose( + problem.support, [[np.log(0.05), np.log(2.0)], [0.0, np.inf]] + ) + far = np.array([-50.0, -50.0]) + theta = problem.to_theta(far) + assert np.log(0.05) <= theta[0] < np.log(2.0) and theta[1] >= 0.0 + assert np.isfinite(problem.log_posterior_unconstrained(far)) + for z in np.random.default_rng(0).normal(0, 5, (20, 2)): + assert np.isfinite(problem.log_posterior_unconstrained(z)) diff --git a/test/test_benchmarks.py b/test/test_benchmarks.py new file mode 100644 index 0000000..f8df4ae --- /dev/null +++ b/test/test_benchmarks.py @@ -0,0 +1,331 @@ +"""The benchmark's problems, its result merging and its cluster drivers.""" + +import json +import sys +from pathlib import Path + +import numpy as np +import pytest + +sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "benchmarks")) + +import merge_results # noqa: E402 +import problems # noqa: E402 + + +@pytest.mark.parametrize("name", ["omp", "alpha_gp", "n40ca_gp"]) +def test_the_notebook_problems_build_and_are_finite(name): + p, thetas = problems.PROBLEMS[name]() + assert p.ndim == {"omp": 9, "alpha_gp": 9, "n40ca_gp": 7}[name] + assert all(np.isfinite(p.log_posterior(t)) for t in thetas) + + +def test_the_ladder_has_three_rungs_sharing_the_data(): + ladder = problems.n40ca_ladder() + assert list(ladder) == ["bare", "proportional error", "GP, growing amplitude"] + ys = [p.constraints[0].y for p in ladder.values()] + assert all(np.array_equal(ys[0], y) for y in ys) + + +def _sampler_file(path, name, sampler, mean): + row = dict(mean=[mean], sd=[1.0]) + data = dict( + meta={}, problems={name: dict(ndim=1, names=["x"], samplers={sampler: row})} + ) + path.write_text(json.dumps(data)) + return path + + +def test_merge_replaces_what_the_inputs_carry_and_keeps_the_rest(tmp_path): + base = tmp_path / "samplers.json" + base.write_text( + json.dumps( + dict( + problems=dict( + a=dict(ndim=1, names=["x"], samplers=dict(NUTS=dict(mean=[0.0]))), + b=dict(ndim=1, names=["x"], samplers=dict(emcee=dict(mean=[5.0]))), + ) + ) + ) + ) + refs = tmp_path / "references.json" + refs.write_text(json.dumps(dict(b=dict(mean=[5.0])))) + one = _sampler_file(tmp_path / "1.json", "a", "NUTS", 1.0) + two = _sampler_file(tmp_path / "2.json", "a", "pocomc", 2.0) + ref = tmp_path / "ref.json" + ref.write_text(json.dumps(dict(a=dict(mean=[1.5], sd=[1.0], method="m")))) + s, r = merge_results.merge([one, two, ref], base, refs) + assert s["problems"]["a"]["samplers"]["NUTS"]["mean"] == [1.0] + assert s["problems"]["a"]["samplers"]["pocomc"]["mean"] == [2.0] + assert s["problems"]["b"]["samplers"]["emcee"]["mean"] == [5.0] # untouched + assert r == dict(a=dict(mean=[1.5], sd=[1.0], method="m"), b=dict(mean=[5.0])) + sweep = tmp_path / "sweep.json" + sweep.write_text(json.dumps(dict(problem="a", names=["x"], runs=[]))) + with pytest.raises(ValueError, match="not a reference"): + merge_results.merge([sweep], base, refs) + + +def test_merge_refuses_two_inputs_with_the_same_entry(tmp_path): + one = _sampler_file(tmp_path / "1.json", "a", "NUTS", 1.0) + two = _sampler_file(tmp_path / "2.json", "a", "NUTS", 2.0) + with pytest.raises(ValueError, match="a/NUTS"): + merge_results.merge([one, two], tmp_path / "s.json", tmp_path / "r.json") + + +def test_mode_share_counts_the_notebooks_minor_mode(): + p, thetas = problems.PROBLEMS["alpha_gp"]() + share = problems.mode_share("alpha_gp", p) + theta = np.tile(thetas[0], (4, 1)) + theta[:2, p.names.index("V")] = [120.0, 130.0] # the shallow family + theta[2:, p.names.index("V")] = [160.0, 170.0] # the deeper one + out = share(theta, np.array([1.0, 1.0, 1.0, 3.0])) + assert out["mode_share"] == pytest.approx(4 / 6) + assert problems.mode_share("n40ca_gp", p) is None + + +@pytest.mark.slow +def test_the_sweep_runs_end_to_end(tmp_path): + import sweep_pocomc + + out = tmp_path / "sweep.json" + tiny = dict(n_total=128, n_evidence=128) + saved = sweep_pocomc.sweep("linear", [(64, 32)], (0, 1), out, **tiny) + assert [r["seed"] for r in saved["runs"]] == [0, 1] + assert json.loads(out.read_text())["runs"] == saved["runs"] + again = sweep_pocomc.sweep("linear", [(64, 32)], (0, 1), out, **tiny) + assert again["runs"] == saved["runs"] # resumed: nothing rerun + sweep_pocomc.report(saved, {}) + + +@pytest.mark.slow +def test_a_dynesty_setting_sweeps_end_to_end(tmp_path): + import sweep_pocomc + + out = tmp_path / "sweep.json" + saved = sweep_pocomc.sweep("linear", ["dynesty rwalk 50"], (0,), out) + (r,) = saved["runs"] + assert (r["sampler"], r["setting"], r["nlive"]) == ( + "dynesty", + "dynesty rwalk 50", + 50, + ) + sweep_pocomc.report(saved, {}) + + +def test_sweep_settings_read_labels_pairs_and_saved_runs(): + import sweep_pocomc as sp + + assert ( + sp.setting("1024/512") + == sp.setting("pocomc 1024/512") + == sp.setting((1024, 512)) + ) + assert sp.label(("dynesty", dict(sample="rslice", nlive=250))) == ( + "dynesty rslice 250" + ) + assert sp.run_label(dict(n_effective=4096, n_active=2048)) == "pocomc 4096/2048" + with pytest.raises(ValueError): + sp.setting("emcee 3000") + + +def test_the_grid_reports_the_worst_seed_per_problem(capsys): + import sweep_pocomc + + ref = dict(mean=[0.0], sd=[1.0], method="m", names=["x"]) + run = dict(setting="dynesty rwalk 500", sd=[1.0]) + saved = [ + dict( + problem="a", + names=["x"], + runs=[dict(run, mean=[0.05]), dict(run, mean=[0.3])], + ), + dict(problem="b", names=["x"], runs=[dict(run, mean=[0.02])]), + ] + sweep_pocomc.grid(saved, dict(a=ref, b=ref)) + row = capsys.readouterr().out.splitlines()[-1] + assert row == "| dynesty rwalk 500 | 0.30 / 0.00 ✗ | 0.02 / 0.00 |" + + +def test_submit_selects_array_indices(): + sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "benchmarks" / "hpc")) + import submit + + assert submit.indices("3,5,12-14") == {3, 5, 12, 13, 14} + argv = ["--problems", "alpha_gp", "--kinds", "ref", "--indices", "12-13"] + (cmd,) = submit.commands(submit.parse_args(argv)) + assert cmd[1] == "--array=12,13" + + +def test_the_seed_check_summarises_as_the_notebook_quotes(): + import gp_seed_check + + x = np.array([3.0, 1.0, 2.0, 4.0]) + w = np.array([1.0, 1.0, 1.0, 1.0]) + lo, mid, hi = gp_seed_check._quantiles(x, w) + assert lo < mid < hi and 2.0 <= mid <= 3.0 + rungs = {"a": dict(logz=1.0), "b": dict(logz=4.0), "c": dict(logz=4.5)} + out = gp_seed_check.with_differences(rungs) + assert out["delta_logz"] == {"b - a": 3.0, "c - b": 0.5} + + +def test_every_array_job_maps_its_indices_to_runs(): + sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "benchmarks" / "hpc")) + import task + + counts = { + (k, p): len(task.tasks(k, p)) + for k in ("ref", "run", "sweep") + for p in ("omp", "alpha_gp", "n40ca_gp") + } + assert set(counts.values()) == {6, 8, 9, 53} + assert counts["ref", "alpha_gp"] == counts["ref", "n40ca_gp"] == 53 # 50 dynesty + assert task.tasks("ref", "alpha_gp")[11] == ("dynesty", 3008) # indices kept + assert len(task.tasks("sweep", "gp")) == 21 # dynesty's settings too + assert len(task.tasks("seed", "gp")) == 9 + assert task.tasks("ref", "omp")[-1][0] == "dynesty" + + +def test_assemble_pools_reference_parts_and_joins_pieces(tmp_path, monkeypatch): + sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "benchmarks" / "hpc")) + import assemble + + monkeypatch.setattr(assemble, "OUT", tmp_path) + ref_dir = tmp_path / "ref" / "omp" + ref_dir.mkdir(parents=True) + run = dict(mean=[1.0, 2.0], sd=[1.0, 1.0], logz=-3.0, logz_err=0.1, wall_s=5.0) + dyn = dict(run, mean=[1.02, 2.0], method="dynesty") + for i, (part, result) in enumerate([("pocomc", run)] * 3 + [("dynesty", dyn)] * 3): + piece = dict(problem="omp", part=part, names=["a", "b"], result=result) + (ref_dir / f"{i}.json").write_text(json.dumps(piece)) + refs = assemble.references() # the other problems have no pieces: skipped + assert list(refs) == ["omp"] + ref = refs["omp"] + assert ref["corroborated"] and ref["accepted"] and ref["logz"] == -3.0 + assert ref["names"] == ["a", "b"] and len(ref["corroboration"]["runs"]) == 3 + seed_dir = tmp_path / "seed" / "gp" + seed_dir.mkdir(parents=True) + rungs = ["bare", "proportional error", "GP, growing amplitude"] + for i, (base, r) in enumerate((b, r) for b in (20, 30, 40) for r in range(3)): + piece = dict(base=base, rung=rungs[r], result=dict(logz=float(r))) + (seed_dir / f"{i}.json").write_text(json.dumps(piece)) + assemble.seed_check() + out = json.loads((tmp_path / "gp_seed_check.json").read_text()) + assert out["30"]["delta_logz"] == { + "proportional error - bare": 1.0, + "GP, growing amplitude - proportional error": 1.0, + } + + +def test_submit_selects_by_index_and_keeps_indices(): + sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "benchmarks" / "hpc")) + import submit + + def lines(*argv): + args = submit.main.__globals__["argparse"].Namespace( + problems=None, kinds=["ref", "run", "sweep"], samplers=None, + settings=None, seeds=None, seed_sets=None, time=None, + ) # fmt: skip + for k, v in zip(argv[::2], argv[1::2]): + setattr(args, k, v) + return [" ".join(c[1:4]) for c in submit.commands(args)] + + only = lines("problems", ["omp"], "kinds", ["run"], "samplers", ["NUTS", "HMC"]) + assert only == ["--array=3,5 --job-name=run_omp --time=2:00:00"] + sweep = lines("problems", ["linear"], "kinds", ["sweep"], "settings", ["2048/1024"]) + assert sweep == ["--array=3,4,5 --job-name=sweep_linear --time=1:00:00"] + seed = lines("kinds", ["seed"], "seed_sets", [30]) + assert seed == ["--array=3,4,5 --job-name=seed_gp --time=1:00:00"] + everything = lines() + assert len(everything) == 3 * 8 # three kinds on every BUDGETS problem + + +def test_submit_reads_site_settings_from_an_args_file(tmp_path): + sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "benchmarks" / "hpc")) + import submit + + site = tmp_path / "site.args" + site.write_text("--account=acct\n--constraint=feat\n--sbatch=--qos=q\n") + venv = tmp_path / "venv" + argv = [f"@{site}", f"--venv={venv}", "--problems", "linear", "--kinds", "ref"] + (cmd,) = submit.commands(submit.parse_args(argv)) + script = cmd.index(str(submit.HERE / "job.sbatch")) + assert cmd[4:script] == [ + "--account=acct", "--constraint=feat", + f"--export=ALL,RXMC_VENV={venv.resolve()}", "--qos=q", + ] # fmt: skip + + +def test_merge_drops_the_rows_of_a_redefined_problem(tmp_path): + base = tmp_path / "samplers.json" + old = dict(ndim=1, names=["old"], samplers=dict(emcee=dict(mean=[0.0]))) + base.write_text(json.dumps(dict(problems=dict(a=old)))) + new = tmp_path / "new.json" + row = dict(mean=[1.0], sd=[1.0]) + new.write_text( + json.dumps( + dict(problems=dict(a=dict(ndim=1, names=["x"], samplers=dict(NUTS=row)))) + ) + ) + s, _ = merge_results.merge([new], base, tmp_path / "r.json") + assert s["problems"]["a"]["names"] == ["x"] + assert list(s["problems"]["a"]["samplers"]) == ["NUTS"] # emcee's stale row gone + + +def test_equal_weights_give_the_midpoint_median(): + import gp_seed_check + + x, w = np.array([1.0, 2.0, 3.0, 4.0]), np.ones(4) + assert gp_seed_check._quantiles(x, w, (0.5,)) == [2.5] + + +def test_a_reference_of_other_parameters_is_refused_and_a_doubtful_one_flagged( + capsys, +): + import bench_samplers + + ref = dict(mean=[0.0], sd=[1.0], method="m", names=["x"]) + assert bench_samplers.usable_reference("p", ["x"], ref) is ref + with pytest.raises(ValueError, match="not the run's"): + bench_samplers.usable_reference("p", ["y"], ref) + with pytest.raises(ValueError, match="does not name"): + bench_samplers.usable_reference("p", ["x"], dict(mean=[0.0], sd=[1.0])) + bench_samplers.usable_reference("p", ["x"], dict(ref, corroborated=False)) + assert "not corroborated" in capsys.readouterr().err + + +def test_merge_drops_the_reference_of_a_redefined_problem(tmp_path): + base = tmp_path / "samplers.json" + old = dict(ndim=1, names=["old"], samplers={}) + base.write_text(json.dumps(dict(problems=dict(a=old)))) + refs = tmp_path / "refs.json" + refs.write_text(json.dumps(dict(a=dict(mean=[0.0], sd=[1.0], method="old")))) + new = _sampler_file(tmp_path / "new.json", "a", "NUTS", 1.0) # names ["x"] + _, r = merge_results.merge([new], base, refs) + assert "a" not in r + + +def test_seed_tasks_refuse_any_problem_but_gp(): + sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "benchmarks" / "hpc")) + import task + + with pytest.raises(ValueError, match="'gp'"): + task.run("seed", "omp", 0) + + +def test_a_verdict_within_the_references_resolution_is_unresolved(): + import bench_samplers as b + + exact = dict(mean=[0.0], sd=[1.0], method="quadrature") + assert [b.verdict(e, exact) for e in (0.09, 0.11, float("nan"))] == [ + "ok", + "wrong", + "wrong", + ] + checked = dict(exact, corroboration=dict(bias=0.05, width=0.02)) + assert b.resolution(checked) == 0.05 + assert [b.verdict(e, checked) for e in (0.04, 0.06, 0.14, 0.16)] == [ + "ok", + "unresolved", + "unresolved", + "wrong", + ] diff --git a/test/test_config.py b/test/test_config.py deleted file mode 100644 index 605661b..0000000 --- a/test/test_config.py +++ /dev/null @@ -1,446 +0,0 @@ -import unittest - -import numpy as np -import scipy.stats - -from rxmc.config import CalibrationConfig, ParameterConfig -from rxmc.constraint import Constraint -from rxmc.covariance import model_error_term -from rxmc.evidence import Evidence -from rxmc.observation import Observation -from rxmc.params import Parameter -from rxmc.physical_model import Polynomial -from rxmc.priors import IndependentPrior, TruncatedNormalPrior - - -def gamma_parameter(): - """The UnknownModelError gamma, as a covariance parameter.""" - return Parameter( - "log fractional err", float, latex_name=r"\gamma", unit="dimensionless" - ) - - -def model_error_constraint(observation, model, gamma): - """A constraint with an UnknownModelError (averaging) covariance term.""" - support = np.arange(observation.n_data_pts) - return Constraint( - observations=[observation], - physical_model=model, - extra_terms=[model_error_term(gamma, averaging=True, support=support)], - ) - - -class TestParameterConfig(unittest.TestCase): - def setUp(self): - self.param1 = Parameter(name="param1") - self.param2 = Parameter(name="param2") - self.prior = scipy.stats.multivariate_normal(mean=[0, 0], cov=[[1, 0], [0, 1]]) - self.initial_proposal_dist = scipy.stats.multivariate_normal( - mean=[0, 0], cov=[[1, 0], [0, 1]] - ) - - def test_initialization(self): - """Test ParameterConfig initialization.""" - config = ParameterConfig( - params=[self.param1, self.param2], - prior=self.prior, - initial_proposal_distribution=self.initial_proposal_dist, - ) - self.assertEqual(config.ndim, 2) - self.assertEqual(config.params, [self.param1, self.param2]) - - def test_empty_parameters_raises_valueerror(self): - """Test empty parameters list raises ValueError.""" - with self.assertRaises(ValueError): - ParameterConfig( - params=[], - prior=self.prior, - initial_proposal_distribution=self.initial_proposal_dist, - ) - - def test_single_parameter_x0_shape(self): - config = ParameterConfig( - params=[self.param1], - prior=scipy.stats.multivariate_normal(mean=[0], cov=[[1]]), - initial_proposal_distribution=scipy.stats.multivariate_normal( - mean=[0], cov=[[1]] - ), - ) - x0 = config.x0(4) - self.assertEqual(x0.shape, (4, 1)) - - def test_generic_prior_class(self): - """TruncatedNormalPrior satisfies the generic prior protocol.""" - prior = TruncatedNormalPrior( - mu=[0.0, 1.0], - sigma=[1.0, 1.0], - lower=[-5.0, -5.0], - upper=[5.0, 5.0], - ) - config = ParameterConfig( - params=[self.param1, self.param2], - prior=prior, - initial_proposal_distribution=prior, - ) - self.assertEqual(config.ndim, 2) - - x0 = config.x0(3) - self.assertEqual(x0.shape, (3, 2)) - - lp = config.prior_logpdf(np.array([0.0, 1.0])) - self.assertTrue(np.isfinite(lp)) - - def test_prior_transform_list(self): - """List-of-distributions prior_transform uses ppf on each element.""" - prior_list = [scipy.stats.norm(0, 1), scipy.stats.norm(0, 1)] - config = ParameterConfig( - params=[self.param1, self.param2], - prior=prior_list, - initial_proposal_distribution=prior_list, - ) - u = np.array([0.5, 0.5]) - theta = config.prior_transform(u) - np.testing.assert_allclose(theta, [0.0, 0.0], atol=1e-10) - - def test_list_prior_is_wrapped_in_independent_prior(self): - """A list of marginals becomes one IndependentPrior (as in Sampler).""" - prior_list = [scipy.stats.norm(0, 1), scipy.stats.uniform(0, 2)] - config = ParameterConfig( - params=[self.param1, self.param2], - prior=prior_list, - initial_proposal_distribution=prior_list, - ) - self.assertIsInstance(config.prior, IndependentPrior) - self.assertIsInstance(config.initial_proposal_distribution, IndependentPrior) - self.assertEqual(config.x0(3).shape, (3, 2)) - x = np.array([0.3, 1.0]) - expected = sum(d.logpdf(xi) for d, xi in zip(prior_list, x)) - self.assertAlmostEqual(config.prior_logpdf(x), expected) - with self.assertRaises(ValueError): - ParameterConfig( - params=[self.param1], - prior=prior_list, - initial_proposal_distribution=prior_list, - ) - - def test_infer_dim_calls_mean_method(self): - """A custom prior exposing mean() as a method is sized correctly.""" - - class Custom: - def mean(self): - return np.zeros(3) - - def logpdf(self, x): - return 0.0 - - def rvs(self, n): - return np.zeros((n, 3)) - - self.assertEqual(ParameterConfig._infer_dim(Custom()), 3) - params = [Parameter(f"p{i}") for i in range(3)] - ParameterConfig(params, prior=Custom(), initial_proposal_distribution=Custom()) - with self.assertRaises(ValueError): - ParameterConfig( - params[:2], prior=Custom(), initial_proposal_distribution=Custom() - ) - # frozen scipy univariates expose mean() too and stay one-dimensional - self.assertEqual(ParameterConfig._infer_dim(scipy.stats.norm(0, 1)), 1) - - def test_prior_transform_boundary_finite(self): - """u = 0 / 1 are clipped into the open cube before ppf.""" - prior_list = [scipy.stats.norm(0, 1), scipy.stats.norm(0, 1)] - config = ParameterConfig( - params=[self.param1, self.param2], - prior=prior_list, - initial_proposal_distribution=prior_list, - ) - theta = config.prior_transform(np.array([0.0, 1.0])) - self.assertTrue(np.all(np.isfinite(theta))) - - def test_prior_transform_generic(self): - """Generic prior with prior_transform method is called directly.""" - # Use symmetric bounds so the median (u=0.5) maps exactly to mu. - prior = TruncatedNormalPrior( - mu=[0.0, 1.0], - sigma=[1.0, 1.0], - lower=[-5.0, -4.0], - upper=[5.0, 6.0], - ) - config = ParameterConfig( - params=[self.param1, self.param2], - prior=prior, - initial_proposal_distribution=prior, - ) - u = np.array([0.5, 0.5]) - theta = config.prior_transform(u) - np.testing.assert_allclose(theta, [0.0, 1.0], atol=1e-6) - - def test_prior_transform_unsupported_raises(self): - """Non-list prior without prior_transform raises NotImplementedError.""" - config = ParameterConfig( - params=[self.param1, self.param2], - prior=self.prior, - initial_proposal_distribution=self.initial_proposal_dist, - ) - with self.assertRaises(NotImplementedError): - config.prior_transform(np.array([0.5, 0.5])) - - -class TestCalibrationConfig(unittest.TestCase): - def setUp(self): - # Evidence with one regular and one parametric constraint - self.model = Polynomial(1) - self.gamma = gamma_parameter() - self.evidence = Evidence( - constraints=[ - Constraint( - observations=[ - Observation( - x=np.array([1.0, 2.0, 3.0]), - y=np.array([1.0, 2.0, 3.0]), - y_stat_err=np.array([0.1, 0.1, 0.1]), - ) - ], - physical_model=self.model, - ), - model_error_constraint( - Observation( - x=np.array([6.0, 7.0, 8.0]), - y=np.array([6.3, 8.1, 9.6]), - y_stat_err=np.array([0.1, 0.1, 0.1]), - ), - self.model, - self.gamma, - ), - ], - ) - - # Model Config - model_prior = scipy.stats.multivariate_normal( - mean=[0, 1], - cov=[[1, 0], [0, 1]], - ) - self.model_config = ParameterConfig( - params=self.model.params, - prior=model_prior, - initial_proposal_distribution=model_prior, - ) - - # Likelihood Config - likelihood_prior = scipy.stats.multivariate_normal(mean=[0], cov=[[1]]) - self.likelihood_config = ParameterConfig( - params=list(self.evidence.parametric_constraints[0].params), - prior=likelihood_prior, - initial_proposal_distribution=likelihood_prior, - ) - - def test_initialization(self): - """Test CalibrationConfig initialization.""" - config = CalibrationConfig( - evidence=self.evidence, - model_config=self.model_config, - likelihood_configs=[self.likelihood_config], - ) - self.assertEqual(config.ndim, 3) - - def test_split_parameters(self): - """Test splitting flat parameters into model and likelihood parameters.""" - config = CalibrationConfig( - evidence=self.evidence, - model_config=self.model_config, - likelihood_configs=[self.likelihood_config], - ) - x = np.array([1.0, 2.0, 0.0]) - model_params, likelihood_params = config.split_parameters(x) - np.testing.assert_array_equal(model_params, [1.0, 2.0]) - np.testing.assert_array_equal(likelihood_params[0], [0.0]) - - def test_parameters_property(self): - """parameters returns all Parameter objects in flat sampler order.""" - config = CalibrationConfig( - evidence=self.evidence, - model_config=self.model_config, - likelihood_configs=[self.likelihood_config], - ) - params = config.parameters - self.assertEqual(len(params), 3) - self.assertEqual(params[0].name, "a0") - self.assertEqual(params[1].name, "a1") - self.assertEqual(params[2].name, "log fractional err") - - def test_prior_property(self): - """prior returns one prior object per parameter sector.""" - config = CalibrationConfig( - evidence=self.evidence, - model_config=self.model_config, - likelihood_configs=[self.likelihood_config], - ) - priors = config.prior - self.assertEqual(len(priors), 2) - self.assertIs(priors[0], self.model_config.prior) - self.assertIs(priors[1], self.likelihood_config.prior) - - def test_black_box_bayes_interface(self): - config = CalibrationConfig( - evidence=self.evidence, - model_config=self.model_config, - likelihood_configs=[self.likelihood_config], - ) - - self.assertEqual(config.parameter_names, ["a0", "a1", "log fractional err"]) - - x0_single = config.starting_location(1) - self.assertEqual(x0_single.shape, (1, 3)) - - x0_batch = config.starting_location(4) - self.assertEqual(x0_batch.shape, (4, 3)) - - theta = np.array([1.0, 2.0, 0.0]) - batched = config.log_posterior_batch(np.vstack([theta, theta])) - self.assertEqual(batched.shape, (2,)) - np.testing.assert_allclose( - batched, - [config.log_posterior(theta), config.log_posterior(theta)], - ) - - def test_conditional_posterior_uses_parametric_constraint(self): - config = CalibrationConfig( - evidence=self.evidence, - model_config=self.model_config, - likelihood_configs=[self.likelihood_config], - ) - - xmodel = np.array([1.0, 1.0]) - ym = self.evidence.parametric_constraints[0].predict(*xmodel) - x_lm = np.array([0.0]) - - expected = self.evidence.parametric_constraints[0].marginal_log_likelihood( - ym, *x_lm - ) + self.likelihood_config.prior_logpdf(x_lm) - self.assertAlmostEqual(config.conditional_posterior(x_lm, 0, ym), expected) - - def test_parametric_indices_map(self): - # the parametric constraint is second in evidence.constraints - self.assertEqual(self.evidence.parametric_indices, [1]) - - def test_conditional_posterior_tempering(self): - # the Gibbs conditional must apply likelihood_scaling and the - # constraint's Evidence weight, matching log_posterior's tempering - scaling = 0.5 - weights = np.array([1.0, 3.0]) # parametric constraint has weight 3 - evidence = Evidence(constraints=self.evidence.constraints, weights=weights) - config = CalibrationConfig( - evidence=evidence, - model_config=self.model_config, - likelihood_configs=[self.likelihood_config], - likelihood_scaling=scaling, - ) - - xmodel = np.array([1.0, 1.0]) - ym = evidence.parametric_constraints[0].predict(*xmodel) - x_lm = np.array([0.0]) - - lp = self.likelihood_config.prior_logpdf(x_lm) - ll = evidence.parametric_constraints[0].marginal_log_likelihood(ym, *x_lm) - self.assertAlmostEqual( - config.conditional_posterior(x_lm, 0, ym), lp + scaling * 3.0 * ll - ) - - def test_predict_parametric_aligns_with_conditional_posterior(self): - # mixed evidence: constraints[0] is non-parametric, constraints[1] is the - # parametric one. predict() is in constraints order (len 2) while - # predict_parametric() is in parametric order (len 1) -> aligned with lm_index. - config = CalibrationConfig( - evidence=self.evidence, - model_config=self.model_config, - likelihood_configs=[self.likelihood_config], - ) - xmodel = np.array([1.0, 1.0]) - - all_preds = config.predict(xmodel) - param_preds = config.predict_parametric(xmodel) - self.assertEqual(len(all_preds), 2) - self.assertEqual(len(param_preds), 1) - # predict_parametric()[0] is the parametric constraint's prediction (== all_preds[1]) - np.testing.assert_allclose(param_preds[0][0], all_preds[1][0]) - np.testing.assert_allclose( - param_preds[0][0], - self.evidence.parametric_constraints[0].predict(*xmodel)[0], - ) - - def test_starting_location_with_single_parameter_sectors(self): - model = Polynomial(0) - gamma = gamma_parameter() - observation = Observation( - x=np.array([1.0, 2.0]), - y=np.array([1.0, 1.1]), - y_stat_err=np.array([0.1, 0.1]), - ) - constraint = model_error_constraint(observation, model, gamma) - evidence = Evidence(constraints=[constraint]) - model_config = ParameterConfig( - params=model.params, - prior=scipy.stats.multivariate_normal(mean=[0], cov=[[1]]), - initial_proposal_distribution=scipy.stats.multivariate_normal( - mean=[0], cov=[[1]] - ), - ) - likelihood_config = ParameterConfig( - params=list(constraint.params), - prior=scipy.stats.multivariate_normal(mean=[0], cov=[[1]]), - initial_proposal_distribution=scipy.stats.multivariate_normal( - mean=[0], cov=[[1]] - ), - ) - config = CalibrationConfig( - evidence=evidence, - model_config=model_config, - likelihood_configs=[likelihood_config], - ) - - x0 = config.starting_location(5) - self.assertEqual(x0.shape, (5, 2)) - - def test_prior_transform_via_generic_prior(self): - """prior_transform works end-to-end with TruncatedNormalPrior sectors.""" - model = Polynomial(1) - gamma = gamma_parameter() - constraint = model_error_constraint( - Observation( - x=np.array([1.0, 2.0, 3.0, 4.0]), - y=np.array([1.0, 2.0, 3.0, 4.0]), - y_stat_err=np.array([0.1, 0.1, 0.1, 0.1]), - ), - model, - gamma, - ) - evidence = Evidence(constraints=[constraint]) - model_prior = TruncatedNormalPrior( - mu=[0.0, 1.0], sigma=[1.0, 1.0], lower=[-5.0, -5.0], upper=[5.0, 5.0] - ) - lm_prior = TruncatedNormalPrior( - mu=[0.0], sigma=[1.0], lower=[-5.0], upper=[5.0] - ) - config = CalibrationConfig( - evidence=evidence, - model_config=ParameterConfig( - params=model.params, - prior=model_prior, - initial_proposal_distribution=model_prior, - ), - likelihood_configs=[ - ParameterConfig( - params=list(constraint.params), - prior=lm_prior, - initial_proposal_distribution=lm_prior, - ) - ], - ) - u = np.full(config.ndim, 0.5) - theta = config.prior_transform(u) - self.assertEqual(theta.shape, (config.ndim,)) - self.assertTrue(np.all(np.isfinite(theta))) - - -if __name__ == "__main__": - unittest.main() diff --git a/test/test_constraint.py b/test/test_constraint.py index 9b9e632..0bff29d 100644 --- a/test/test_constraint.py +++ b/test/test_constraint.py @@ -1,720 +1,230 @@ -"""Tests for the stacked Constraint: multi-observation stacking and case A/B.""" - -import unittest +"""Comparison and Constraint: comparison space, reported terms, masks, support.""" +import jax.numpy as jnp import numpy as np -from sklearn.gaussian_process.kernels import RBF - -from helpers import manual_mvn_loglike -from rxmc.constraint import Constraint -from rxmc.covariance import ( - Term, - kernel_term, - noise_term, - normalization_term, - systematic_term, -) -from rxmc.evidence import Evidence -from rxmc.likelihood_model import GaussianLikelihood, StudentT -from rxmc.observation import Observation -from rxmc.params import Parameter -from rxmc.physical_model import Polynomial -from rxmc.transforms import log, per_observation_scaling, scale - - -class TestStackedConstraint(unittest.TestCase): - def setUp(self): - self.pm = Polynomial(order=1) - self.model_params = (0.5, 1.2) - self.obs1 = Observation( - np.array([1.0, 2.0]), np.array([2.0, 3.0]), y_stat_err=np.array([0.1, 0.2]) - ) - self.obs2 = Observation( - np.array([3.0, 4.0, 5.0]), - np.array([5.0, 6.0, 8.0]), - y_stat_err=np.array([0.3, 0.2, 0.4]), - ) - - def _stacked(self): - y = np.concatenate([self.obs1.y, self.obs2.y]) - ym = np.concatenate( - [ - self.pm.evaluate(self.obs1, *self.model_params), - self.pm.evaluate(self.obs2, *self.model_params), - ] - ) - return y, ym - - def test_block_diagonal_equals_sum_of_blocks(self): - c = Constraint([self.obs1, self.obs2], self.pm) - self.assertEqual(c.n_data_pts, 5) - self.assertTrue(c.covariance.block_diagonal) - - y, ym = self._stacked() - stat = np.concatenate([self.obs1.y_stat_err, self.obs2.y_stat_err]) - cov = np.diag(stat**2) - expected = manual_mvn_loglike(y, ym, cov) - self.assertAlmostEqual(c.log_likelihood(self.model_params), expected) - - def test_block_diagonal_fast_path_matches_dense(self): - # build a constraint and compare blockwise path against an explicit dense MVN - c = Constraint([self.obs1, self.obs2], self.pm) - y, ym = self._stacked() - stat = np.concatenate([self.obs1.y_stat_err, self.obs2.y_stat_err]) - dense = manual_mvn_loglike(y, ym, np.diag(stat**2)) - self.assertAlmostEqual(c.log_likelihood(self.model_params), dense) - - def test_constant_block_diag_cached_factors_match_dense(self): - # constant multi-block covariance: cold call and cache-warm call both - # equal the manual dense MVN - c = Constraint([self.obs1, self.obs2], self.pm) - y, ym = self._stacked() - stat = np.concatenate([self.obs1.y_stat_err, self.obs2.y_stat_err]) - expected = manual_mvn_loglike(y, ym, np.diag(stat**2)) - cold = c.log_likelihood(self.model_params) - warm = c.log_likelihood(self.model_params) - self.assertAlmostEqual(cold, expected) - self.assertEqual(cold, warm) - - def test_case_A_cross_block_coupling(self): - # one rank-one mode spanning both blocks couples the data (off-diagonal blocks) - eta = 0.1 - p = Parameter("log eta") - support = np.arange(5) - coupling = systematic_term(p, basis=lambda c: c.ym, support=support) - c = Constraint([self.obs1, self.obs2], self.pm, extra_terms=[coupling]) - - self.assertFalse(c.covariance.block_diagonal) - self.assertEqual(c.n_params, 1) - - y, ym = self._stacked() - stat = np.concatenate([self.obs1.y_stat_err, self.obs2.y_stat_err]) - cov = np.diag(stat**2) + eta**2 * np.outer(ym, ym) - expected = manual_mvn_loglike(y, ym, cov) - self.assertAlmostEqual( - c.log_likelihood(self.model_params, (np.log(eta),)), expected - ) - - def test_case_A_differs_from_independent(self): - eta = 0.1 - p = Parameter("log eta") - coupled = Constraint( - [self.obs1, self.obs2], - self.pm, - extra_terms=[ - systematic_term(p, basis=lambda c: c.ym, support=np.arange(5)) - ], - ) - # independent: two per-block normalization modes (no cross coupling) - p1, p2 = Parameter("log eta 1"), Parameter("log eta 2") - independent = Constraint( - [self.obs1, self.obs2], - self.pm, - extra_terms=[ - normalization_term(parameter=p1, support=np.arange(2)), - normalization_term(parameter=p2, support=np.arange(2, 5)), - ], - ) - ll_coupled = coupled.log_likelihood(self.model_params, (np.log(eta),)) - ll_indep = independent.log_likelihood( - self.model_params, (np.log(eta), np.log(eta)) - ) - self.assertNotAlmostEqual(ll_coupled, ll_indep) - - -class TestPerObservationScaling(unittest.TestCase): - """Per-dataset latent rho as an identity-routed model transform.""" - - def setUp(self): - self.obs1 = Observation( - np.array([1.0, 2.0, 3.0]), - np.array([2.0, 4.0, 6.0]), - y_stat_err=np.array([0.1, 0.1, 0.1]), - ) - self.obs2 = Observation( - np.array([1.0, 2.0, 3.0]), - np.array([4.0, 8.0, 12.0]), - y_stat_err=np.array([0.1, 0.1, 0.1]), - ) - - def make_model(self, observations): - return Polynomial(order=1, transform=per_observation_scaling(observations)) - - def test_routes_rho_by_identity(self): - model = self.make_model([self.obs1, self.obs2]) - # params = [a0, a1, log_rho_0, log_rho_1] - self.assertEqual(model.n_params, 4) - self.assertEqual( - [p.name for p in model.params], ["a0", "a1", "log_rho_0", "log_rho_1"] - ) - mp = (0.0, 2.0, np.log(1.0), np.log(2.0)) - np.testing.assert_allclose(model(self.obs1, *mp), [2.0, 4.0, 6.0]) - np.testing.assert_allclose(model(self.obs2, *mp), [4.0, 8.0, 12.0]) - - def test_linear_prefix(self): - t = per_observation_scaling([self.obs1, self.obs2], log=False) - self.assertEqual([p.name for p in t.params], ["rho_0", "rho_1"]) - model = Polynomial(order=1, transform=t) +import pytest + +from helpers import assemble_dense +from rxmc import Dataset, Model, Parameter +from rxmc.constraint import Comparison, Constraint +from rxmc.likelihood import Chi2 +from rxmc.terms import Term, noise, statistical +from rxmc.transforms import Transform, log, scale + +m, b = Parameter("m"), Parameter("b") +line = Model(lambda x, m, b: m * x + b, [m, b]) + + +def dataset(n=4, label="d", **kw): + x = np.linspace(1.0, 2.0, n) + return Dataset(x, 2.0 * x + 1.0, 0.1 * np.ones(n), label=label, **kw) + + +class TestComparison: + def test_identity_space_is_the_default(self): + d = dataset() + c = Comparison(d, line) + assert c.y is d.y and c.y_err is d.y_err + assert c.log_jacobian() == 0.0 + assert c.n == 4 + np.testing.assert_allclose(c.predict(2.0, 1.0), d.y) + + def test_log_space_delta_method_and_jacobian(self): + d = dataset() + c = Comparison(d, line, space=log) + np.testing.assert_allclose(c.y, np.log(d.y)) + np.testing.assert_allclose(c.y_err, d.y_err / d.y) + assert c.log_jacobian() == pytest.approx(-np.sum(np.log(d.y))) + mask = np.array([True, False, True, False]) + assert c.log_jacobian(mask) == pytest.approx(-np.sum(np.log(d.y[mask]))) + np.testing.assert_allclose(c.predict(2.0, 1.0), np.log(d.y)) + + def test_scalar_derivative_is_a_per_point_jacobian(self): + double = Transform(lambda a: 2.0 * a, derivative=lambda a: 2.0) + c = Comparison(dataset(), line, space=double) + assert c.log_jac.shape == (4,) + assert c.log_jacobian() == pytest.approx(4 * np.log(2.0)) + np.testing.assert_allclose(c.y_err, 2.0 * dataset().y_err) + + def test_autodiff_derivative_is_exact_on_tiny_data(self): + y = np.array([1e-6, 9e-7, 2e-6]) # b/sr-sized + c = Comparison(Dataset(np.arange(3.0), y, 0.1 * y), line, space=jnp.log10) + np.testing.assert_allclose(c.y_err, 0.1 / np.log(10), rtol=1e-6) + + def test_non_positive_data_under_log_does_not_raise(self): + d = Dataset([0.0, 1.0], [-1.0, 2.0], [0.1, 0.1]) + c = Comparison(d, line, space=log) + assert not np.isfinite(c.y[0]) and np.isfinite(c.y[1]) + + def test_parametric_space_rejected_and_callable_accepted(self): + with pytest.raises(ValueError, match="parameter-free"): + Comparison(dataset(), line, space=scale()) + c = Comparison(dataset(), line, space=jnp.sqrt) + np.testing.assert_allclose(c.y, np.sqrt(dataset().y)) + + def test_predictor_is_bound_with_meta(self): + seen = {} + + class Probe(Model): + def bind(self, x, meta=None): + seen["meta"] = meta + return line.bind(x) + + d = dataset(meta={"Elab": 10.0}) + Comparison(d, Probe(None, [m, b])) + assert seen["meta"] == {"Elab": 10.0} + + def test_quantity_must_match_the_model(self): + class Observable(Model): + quantity = "dXS/dA" + + model = Observable(lambda x, m, b: m * x + b, [m, b]) + Comparison(dataset(meta={"quantity": "dXS/dA"}), model) + with pytest.raises(ValueError, match="holds 'dXS/dRuth'.*predicts 'dXS/dA'"): + Comparison(dataset(meta={"quantity": "dXS/dRuth"}), model) + # a composite (dXS/dRuth * Rutherford) declares no quantity of its own, + # and data that declares none is not checked + Comparison(dataset(meta={"quantity": "dXS/dRuth"}), model * line) + Comparison(dataset(), model) + + def test_type_checks(self): + with pytest.raises(TypeError, match="Dataset"): + Comparison(np.ones(3), line) + with pytest.raises(TypeError, match="Model"): + Comparison(dataset(), lambda x: x) + + +class TestReportedTerms: + def test_empty_and_zero_skipped(self): + assert Comparison(dataset(), line).reported_terms() == [] + d = dataset(norm_err=0.0, offset_err=np.zeros(4)) + assert Comparison(d, line).reported_terms() == [] + + def test_identity_recovers_the_old_folded_covariance(self): + d = dataset(norm_err=0.05, offset_err=0.2) + c = Comparison(d, line) + terms = c.reported_terms() + assert [t.kind for t in terms] == ["mode", "mode"] + assert all(t.on is c for t in terms) + ym = c.predict(1.9, 1.1) + S = assemble_dense([statistical(c.y_err), *terms], d.x, c.y, ym) + old = ( + np.diag(d.y_err**2) + + np.outer(0.2 * np.ones(4), 0.2 * np.ones(4)) + + 0.05**2 * np.outer(ym, ym) + ) + np.testing.assert_allclose(S, old) + + def test_delta_method_under_log(self): + d = dataset(norm_err=0.05, offset_err=0.2) + c = Comparison(d, line, space=log) + offset, norm = c.reported_terms() + ym = c.predict(1.9, 1.1) + np.testing.assert_allclose(offset.value(d.x, c.y, ym), 0.2 / d.y) np.testing.assert_allclose( - model(self.obs2, 0.0, 2.0, 1.0, 3.0), [6.0, 12.0, 18.0] - ) - - def test_shared_across_constraints_in_evidence(self): - model = self.make_model([self.obs1, self.obs2]) - c1 = Constraint([self.obs1], model) - c2 = Constraint([self.obs2], model) - ev = Evidence([c1, c2]) # all constraints share one model instance - self.assertEqual( - [p.name for p in ev.model_params], ["a0", "a1", "log_rho_0", "log_rho_1"] - ) - ll = ev.log_likelihood((0.0, 2.0, np.log(1.0), np.log(2.0))) - self.assertTrue(np.isfinite(ll)) - - def test_holds_observation_references(self): - # id()-keyed routing must keep the registered objects alive so a - # garbage-collected observation's id can never be recycled - import gc - - model = self.make_model( - [Observation(np.array([1.0]), np.array([1.0])), self.obs2] - ) - gc.collect() - mp = (0.0, 2.0, np.log(1.0), np.log(2.0)) - np.testing.assert_allclose(model(self.obs2, *mp), [4.0, 8.0, 12.0]) - # the first observation is still registered, so a new object can never - # inherit its id and be routed to its scale - stranger = Observation(np.array([1.0]), np.array([1.0])) - with self.assertRaises(KeyError): - model(stranger, *mp) - - def test_unregistered_observation_raises(self): - model = self.make_model([self.obs1]) - with self.assertRaises(KeyError): - model(self.obs2, 0.0, 1.0, 0.0) - - -class TestSharedParameterCaseB(unittest.TestCase): - def test_shared_eta_one_param(self): - pm = Polynomial(order=0) - obs1 = Observation(np.array([1.0, 2.0]), np.array([3.0, 3.0])) - obs2 = Observation(np.array([3.0, 4.0]), np.array([3.0, 3.0])) - eta = Parameter("log eta") - c = Constraint( - [obs1, obs2], - pm, - extra_terms=[ - normalization_term(parameter=eta, support=np.arange(2)), - normalization_term(parameter=eta, support=np.arange(2, 4)), - ], - ) - # one shared parameter, covariance stays block-diagonal - self.assertEqual(c.n_params, 1) - self.assertTrue(c.covariance.block_diagonal) - - -class TestParamCountValidation(unittest.TestCase): - """The full constraint tuple is validated; surplus params no longer vanish.""" - - def setUp(self): - self.pm = Polynomial(order=1) - self.mp = (0.5, 1.2) - self.obs = Observation( - np.array([1.0, 2.0]), np.array([2.0, 3.0]), y_stat_err=np.array([0.1, 0.2]) - ) - - def test_surplus_params_raise(self): - # reviewer repro: these used to be silently swallowed, returning the - # same value as the no-param call - c = Constraint([self.obs], self.pm) - with self.assertRaises(ValueError) as cm: - c.log_likelihood(self.mp, (0.3, 99.0, -5.0)) - self.assertIn("expects 0 parameter", str(cm.exception)) - - def test_missing_params_raise(self): - eta = Parameter("log eta") - c = Constraint( - [self.obs], - self.pm, - extra_terms=[normalization_term(parameter=eta, support=np.arange(2))], - ) - with self.assertRaises(ValueError) as cm: - c.log_likelihood(self.mp) - self.assertIn("log eta", str(cm.exception)) - - def test_correct_count_unchanged(self): - eta = Parameter("log eta") - c = Constraint( - [self.obs], - self.pm, - extra_terms=[normalization_term(parameter=eta, support=np.arange(2))], - ) - self.assertTrue(np.isfinite(c.log_likelihood(self.mp, (np.log(0.1),)))) - - def test_studentt_chi2_full_tuple(self): - eps = Parameter("log eps") - student = Constraint( - [self.obs], - self.pm, - likelihood=StudentT(), - extra_terms=[noise_term(eps, support=np.arange(2))], - ) - # covariance-only tuple is a deficit now - with self.assertRaises(ValueError): - student.chi2(self.mp, (np.log(0.1),)) - # full tuple works; nu is ignored by the statistic - gauss = Constraint( - [self.obs], - self.pm, - likelihood=GaussianLikelihood(), - extra_terms=[noise_term(Parameter("log eps g"), support=np.arange(2))], - ) - self.assertAlmostEqual( - student.chi2(self.mp, (np.log(0.1), 4.0)), - gauss.chi2(self.mp, (np.log(0.1),)), - ) - - def test_covariance_matrix_full_tuple_convention(self): - eta = Parameter("log eta") - c = Constraint( - [self.obs], - self.pm, - likelihood=StudentT(), - extra_terms=[normalization_term(parameter=eta, support=np.arange(2))], - ) - # reviewer repro: forwarding the full sampled tuple used to crash - S = c.covariance_matrix(self.mp, (np.log(0.1), 4.0)) - gauss = Constraint( - [self.obs], - self.pm, - extra_terms=[ - normalization_term(parameter=Parameter("log eta"), support=np.arange(2)) - ], - ) - np.testing.assert_allclose(S, gauss.covariance_matrix(self.mp, (np.log(0.1),))) - # a partial (covariance-only) tuple is now rejected uniformly - with self.assertRaises(ValueError): - c.covariance_matrix(self.mp, (np.log(0.1),)) - - -class TestParameterNameValidation(unittest.TestCase): - def setUp(self): - self.pm = Polynomial(order=1) - self.obs = Observation( - np.array([1.0, 2.0]), np.array([2.0, 3.0]), y_stat_err=np.array([0.1, 0.2]) - ) - - def test_two_distinct_same_name_params_raise(self): - # two equal-but-distinct objects are almost certainly intended sharing - # gone wrong (sharing works by identity) - with self.assertRaises(ValueError) as cm: - Constraint( - [self.obs], - self.pm, - extra_terms=[ - normalization_term( - parameter=Parameter("log eta"), support=np.arange(2) - ), - normalization_term( - parameter=Parameter("log eta"), support=np.arange(2) - ), - ], - ) - self.assertIn("SAME Parameter object", str(cm.exception)) - - def test_collision_with_model_param_name_raises(self): - # Polynomial(order=1) has model params named a0, a1 - with self.assertRaises(ValueError) as cm: - Constraint( - [self.obs], - self.pm, - extra_terms=[ - normalization_term(parameter=Parameter("a0"), support=np.arange(2)) - ], - ) - self.assertIn("physical-model parameter", str(cm.exception)) - - def test_likelihood_param_collision_raises(self): - nu_clone = Parameter("nu") - with self.assertRaises(ValueError): + norm.value(d.x, c.y, ym), 0.05 + ) # constant in log space + + def test_normalisation_needs_an_inverse(self): + d = dataset(norm_err=0.05) + c = Comparison(d, line, space=Transform(lambda a: a**3)) + with pytest.raises(ValueError, match="no inverse"): + c.reported_terms() + d = dataset(offset_err=0.2) # an offset alone is fine + assert ( + len(Comparison(d, line, space=Transform(lambda a: a**3)).reported_terms()) + == 1 + ) + + +class TestConstraint: + def setup_method(self): + self.d1, self.d2 = dataset(3, "d1"), dataset(4, "d2") + self.c1, self.c2 = Comparison(self.d1, line), Comparison(self.d2, line) + self.eps = Parameter("log_eps") + + def test_construction_and_validation(self): + c = Constraint(iter([self.c1, self.c2]), terms=[noise(self.eps)]) + assert c.comparisons == (self.c1, self.c2) and c.n_total == 7 + assert c.offsets == (slice(0, 3), slice(3, 7)) + assert c.n_active == 7 and np.array_equal(c.active, np.arange(7)) + assert c.masks is None and c.weight == 1.0 and c.statistical + with pytest.raises(ValueError, match="distinct"): + Constraint([self.c1, self.c1]) + with pytest.raises(TypeError, match="Term"): + Constraint([self.c1], terms=[np.eye(3)]) + with pytest.raises(ValueError, match="non-negative"): + Constraint([self.c1], weight=-1.0) + with pytest.raises(ValueError, match="finite"): + Constraint([self.c1], weight=np.nan) + with pytest.raises(ValueError, match="at least one"): + Constraint([]) + with pytest.raises(TypeError, match="Likelihood"): + Constraint([self.c1], likelihood=object()) + assert isinstance(Constraint([self.c1], likelihood=Chi2()).likelihood, Chi2) + + def test_masks_validated(self): + with pytest.raises(ValueError, match="one entry per comparison"): + Constraint([self.c1, self.c2], masks=[np.ones(3, bool)]) + with pytest.raises(ValueError, match="shape"): + Constraint([self.c1, self.c2], masks=[np.ones(3, bool), np.ones(3, bool)]) + + def test_masks_are_copied(self): + mask = np.array([True, False, True]) + c = Constraint([self.c1]).masked([mask]) + mask[:] = True # the caller reuses its array + assert np.array_equal(c.complement().active, [1]) + + def test_support_resolution(self): + c = Constraint([self.c1, self.c2]) + assert np.array_equal(c.support(None), np.arange(7)) + assert np.array_equal(c.support(self.c2), np.arange(3, 7)) + assert np.array_equal(c.support(self.d1), np.arange(3)) + assert np.array_equal(c.support([self.c2, self.c1]), np.arange(7)) + assert np.array_equal(c.support([self.c2, self.d2]), np.arange(3, 7)) + stray = Comparison(dataset(2, "stray"), line) + with pytest.raises(ValueError, match="stray"): + c.support(stray) + with pytest.raises(ValueError, match="does not reference"): + c.support(dataset(2, "other")) + with pytest.raises(TypeError, match="comparisons or datasets"): + c.support(3) + + def test_term_support_checked_eagerly(self): + stray = Comparison(dataset(2, "stray"), line) + with pytest.raises(ValueError, match="stray"): + Constraint([self.c1], terms=[noise(self.eps, on=stray)]) + with pytest.raises(ValueError, match="expects shape"): Constraint( - [self.obs], - self.pm, - likelihood=StudentT(nu_parameter=Parameter("nu")), - extra_terms=[ - normalization_term(parameter=nu_clone, support=np.arange(2)) - ], + [self.c1, self.c2], terms=[Term(np.ones(3), kind="diag", on=self.c2)] ) - - -class TestSingularCovarianceGuard(unittest.TestCase): - """A constant singular covariance fails at construction with a clear error.""" - - def setUp(self): - self.pm = Polynomial(order=1) - self.x = np.array([1.0, 2.0]) - self.y = np.array([2.0, 3.0]) - - def test_zero_stat_err_raises_clear_error(self): - obs = Observation(self.x, self.y) # y_stat_err defaults to zeros - with self.assertRaises(ValueError) as cm: - Constraint([obs], self.pm) - self.assertIn("singular", str(cm.exception)) - self.assertIn("observation 0", str(cm.exception)) - - def test_offending_dataset_named_by_label(self): - good = Observation(self.x, self.y, y_stat_err=np.array([0.1, 0.1])) - bad = Observation(np.array([3.0, 4.0]), np.array([4.0, 5.0]), label="C1010-2-0") - with self.assertRaises(ValueError) as cm: - Constraint([good, bad], self.pm) - msg = str(cm.exception) - self.assertIn("C1010-2-0", msg) - self.assertNotIn("observation 0'", msg) - - def test_zero_stat_err_with_covering_term_ok(self): - obs = Observation(self.x, self.y) - c = Constraint( - [obs], - self.pm, - extra_terms=[Term(np.array([0.2, 0.2]), kind="diag", support=np.arange(2))], - ) - self.assertTrue(np.isfinite(c.log_likelihood((0.5, 1.2)))) - - def test_zero_stat_err_with_systematic_terms_ok(self): - obs = Observation( - self.x, self.y, y_sys_err_normalization=0.05, y_sys_err_offset=0.1 - ) - c = Constraint([obs], self.pm, extra_terms=obs.systematic_terms(np.arange(2))) - self.assertTrue(np.isfinite(c.log_likelihood((0.5, 1.2)))) - - def test_parametric_covariance_not_checked_eagerly(self): - # replace-semantics: zero stat err + a free noise term must construct - - obs = Observation(self.x, self.y) - p = Parameter("log eps") - c = Constraint( - [obs], self.pm, extra_terms=[noise_term(p, support=np.arange(2))] - ) - self.assertEqual(c.n_params, 1) - - -class TestConstraintFixes(unittest.TestCase): - def setUp(self): - self.pm = Polynomial(order=1) - self.params = (0.5, 1.2) - self.obs = Observation( - np.array([1.0, 2.0, 3.0]), - np.array([2.0, 3.0, 5.0]), - y_stat_err=np.array([0.1, 0.2, 0.3]), - ) - - def test_covariance_matrix_returns_copy(self): - c = Constraint([self.obs], self.pm) - before = c.log_likelihood(self.params) - M = c.covariance_matrix(self.params) - M += 1e6 # in-place mutation must not corrupt the constraint - after = c.log_likelihood(self.params) - self.assertAlmostEqual(before, after) - - def test_stack_shape_guard(self): - c = Constraint([self.obs], self.pm) - with self.assertRaises(ValueError): - c.marginal_log_likelihood([np.array([1.0, 2.0])]) # wrong length - - def test_include_statistical_term_false_omits_diagonal(self): - sup = np.arange(self.obs.n_data_pts) - cov = np.diag([0.04, 0.04, 0.04]) - c = Constraint( - [self.obs], - self.pm, - extra_terms=[Term(cov, support=sup)], - include_statistical_term=False, - ) - # only the supplied fixed Term survives (no statistical diagonal added) - S = c.covariance_matrix(self.params) - np.testing.assert_allclose(S, cov) - - -class TestScaleTransform(unittest.TestCase): - def test_scale_applied_and_params_appended(self): - base = Polynomial(order=1) - obs = Observation( - np.array([1.0, 2.0, 3.0]), - np.array([2.0, 4.0, 6.0]), - y_stat_err=np.array([0.1, 0.1, 0.1]), - ) - model = Polynomial(order=1, transform=scale()) - self.assertEqual(model.n_params, 3) - self.assertEqual(model.params[-1].name, "log_rho") - np.testing.assert_allclose( - model(obs, 0.0, 2.0, np.log(2.0)), - 2.0 * base(obs, 0.0, 2.0), - ) - # evaluate() is physical space only - np.testing.assert_allclose(model.evaluate(obs, 0.0, 2.0), base(obs, 0.0, 2.0)) - - def test_linear_scale(self): - base = Polynomial(order=0) - obs = Observation(np.array([1.0, 2.0]), np.array([3.0, 3.0])) - model = Polynomial(order=0, transform=scale(Parameter("rho"), log=False)) - np.testing.assert_allclose(model(obs, 4.0, 1.5), 1.5 * base(obs, 4.0)) - - def test_wrong_param_count_raises(self): - model = Polynomial(order=0, transform=scale()) - obs = Observation(np.array([1.0]), np.array([1.0])) - with self.assertRaises(ValueError): - model(obs, 1.0) - # evaluate() counts base parameters only, not the transform's - with self.assertRaisesRegex(ValueError, "Expected 1 parameters"): - model.evaluate(obs, 1.0, 2.0) - - -class TestMask(unittest.TestCase): - """Masks select the active rows; terms are authored over the full stack.""" - - def setUp(self): - self.pm = Polynomial(order=1) - self.mp = (0.5, 1.5) - self.obs1 = Observation( - np.array([1.0, 2.0, 3.0]), - np.array([2.1, 3.4, 5.2]), - y_stat_err=np.array([0.1, 0.2, 0.3]), - ) - self.obs2 = Observation( - np.array([4.0, 5.0]), - np.array([6.7, 8.1]), - y_stat_err=np.array([0.2, 0.2]), - ) - - def test_point_mask_equals_hand_subset(self): - eta = Parameter("log eta") - masked = Constraint( - [self.obs1.masked([True, False, True]), self.obs2], - self.pm, - extra_terms=[normalization_term(parameter=eta)], - ) - sub = Observation( - self.obs1.x[[0, 2]], - self.obs1.y[[0, 2]], - y_stat_err=self.obs1.y_stat_err[[0, 2]], - ) - ref = Constraint( - [sub, self.obs2], self.pm, extra_terms=[normalization_term(parameter=eta)] - ) - self.assertEqual(masked.n_data_pts, 4) - self.assertEqual(masked.n_data_pts_total, 5) - self.assertEqual(masked.covariance.N, 5) - self.assertAlmostEqual( - masked.log_likelihood(self.mp, (np.log(0.1),)), - ref.log_likelihood(self.mp, (np.log(0.1),)), - ) - # block-diagonal path too - eps = Parameter("log eps") - masked = Constraint( - [self.obs1.masked([True, False, True]), self.obs2], - self.pm, - extra_terms=[noise_term(eps)], - ) - ref = Constraint([sub, self.obs2], self.pm, extra_terms=[noise_term(eps)]) - self.assertTrue(masked.covariance.block_diagonal) - self.assertAlmostEqual( - masked.log_likelihood(self.mp, (np.log(0.3),)), - ref.log_likelihood(self.mp, (np.log(0.3),)), - ) - - def test_observation_mask_drops_block(self): - c = Constraint([self.obs1, self.obs2], self.pm, mask=[True, False]) - ref = Constraint([self.obs1], self.pm) - self.assertEqual(c.n_data_pts, 3) - self.assertAlmostEqual(c.log_likelihood(self.mp), ref.log_likelihood(self.mp)) - c2 = Constraint([self.obs1, self.obs2], self.pm, mask=[1]) - self.assertEqual(c2.n_data_pts, 2) - ev = Evidence([c2]) - self.assertEqual(ev.n_dof, 2 - 2) - - def test_complement_partitions(self): - c = Constraint( - [self.obs1.masked_where(lambda x: x < 2.5), self.obs2], - self.pm, - mask=[True, False], - ) - h = c.complement() - self.assertEqual(c.n_data_pts, 2) - self.assertEqual(h.n_data_pts, 3) # obs1's third point + all of obs2 - both = set(c.active) | set(h.active) - self.assertEqual(both, set(range(5))) - self.assertEqual(set(c.active) & set(h.active), set()) - full = Constraint([self.obs1, self.obs2], self.pm) - self.assertAlmostEqual( - c.log_likelihood(self.mp) + h.log_likelihood(self.mp), - full.log_likelihood(self.mp), - ) - - def test_masked_shares_params(self): - eta = Parameter("log eta") - c = Constraint( - [self.obs1, self.obs2], - self.pm, - extra_terms=[normalization_term(parameter=eta)], - ) - h = c.masked(point_masks=[[False, True, False], None]) - self.assertEqual(h.params, c.params) - self.assertEqual(h.n_data_pts, 3) - - def test_predict_and_covariance_active(self): - c = Constraint([self.obs1.masked([True, False, True]), self.obs2], self.pm) - ym, S = c.predict_and_covariance(self.mp) - self.assertEqual(ym.shape, (4,)) - self.assertEqual(S.shape, (4, 4)) - full = c.covariance_matrix(self.mp, active_only=False) - self.assertEqual(full.shape, (5, 5)) - np.testing.assert_allclose( - c.y, np.concatenate([self.obs1.y[[0, 2]], self.obs2.y]) - ) - preds = c.predict(*self.mp) - self.assertEqual(len(preds[0]), 3) # all points, per observation - - def test_coverage_uses_active_points(self): - c = Constraint([self.obs1.masked([True, False, True]), self.obs2], self.pm) - lo = [o.y - 1.0 for o in c.observations] - hi = [o.y + 1.0 for o in c.observations] - self.assertEqual(c.empirical_coverage(lo, hi), 1.0) - self.assertEqual(c.num_pts_within_interval(lo, hi), 4) - - def test_no_active_points_coverage_is_nan(self): - c = Constraint([self.obs1, self.obs2], self.pm, mask=[]) - self.assertEqual(c.n_data_pts, 0) - lo = [o.y - 1.0 for o in c.observations] - hi = [o.y + 1.0 for o in c.observations] - self.assertTrue(np.isnan(c.empirical_coverage(lo, hi))) - - def test_generator_argument(self): - ref = Constraint([self.obs1, self.obs2], self.pm) - gen = Constraint((o for o in [self.obs1, self.obs2]), self.pm) - self.assertEqual(len(gen.observations), 2) - self.assertEqual(gen.n_data_pts, ref.n_data_pts) - self.assertAlmostEqual(gen.log_likelihood(self.mp), ref.log_likelihood(self.mp)) - - def test_ambiguous_observation_mask_raises(self): - with self.assertRaises(ValueError): - Constraint([self.obs1, self.obs2], self.pm, mask=[1, 0]) - by_index = Constraint([self.obs1, self.obs2], self.pm, mask=[0]) - self.assertEqual(by_index.n_data_pts, 3) - by_bool = Constraint([self.obs1, self.obs2], self.pm, mask=[False, True]) - self.assertEqual(by_bool.n_data_pts, 2) - - -class TestComparisonSpaceTransform(unittest.TestCase): - def setUp(self): - self.pm = Polynomial(order=1) - self.mp = (1.0, 2.0) - self.x = np.array([1.0, 2.0, 3.0]) - self.y = np.array([3.2, 4.9, 7.3]) - self.err = np.array([0.3, 0.5, 0.7]) - - def test_log_space_equals_hand_built(self): - obs = Observation(self.x, self.y, y_stat_err=self.err, transform=log) - eps = Parameter("log eps") - c = Constraint([obs], self.pm, extra_terms=[noise_term(eps)]) - ym = self.pm(obs, *self.mp) - cov = np.diag((self.err / self.y) ** 2) + 0.04 * np.eye(3) - expected = manual_mvn_loglike(np.log(self.y), np.log(ym), cov) - self.assertAlmostEqual(c.log_likelihood(self.mp, (np.log(0.2),)), expected) - self.assertAlmostEqual(c.log_jacobian, -np.sum(np.log(self.y))) - - def test_predict_spaces(self): - obs = Observation(self.x, self.y, transform=log) - c = Constraint([obs], self.pm, extra_terms=[noise_term(Parameter("e"))]) - ym = self.pm(obs, *self.mp) - np.testing.assert_allclose(c.predict(*self.mp)[0], np.log(ym)) - np.testing.assert_allclose(c.predict(*self.mp, raw=True)[0], ym) - - def test_nonpositive_prediction_is_minus_inf(self): - obs = Observation(self.x, self.y, transform=log) - c = Constraint([obs], self.pm, extra_terms=[noise_term(Parameter("e"))]) - ll = c.log_likelihood((-10.0, 0.0), (0.0,)) - self.assertEqual(ll, -np.inf) - self.assertEqual(c.marginal_log_likelihood([np.full(3, -1.0)], 0.0), -np.inf) - - def test_nonpositive_prediction_chi2_is_plus_inf(self): - # chi2 is a distance: an invalid prediction must be +inf, not -inf - obs = Observation(self.x, self.y, transform=log) - c = Constraint([obs], self.pm, extra_terms=[noise_term(Parameter("e"))]) - self.assertEqual(c.chi2((-10.0, 0.0), (0.0,)), np.inf) - - -class TestConstantTermsReadX(unittest.TestCase): - """Constant terms (fixed kernels, x-dependent fixed diagonals) are evaluated - once with the invariant x/y at Constraint construction.""" - - def setUp(self): - self.pm = Polynomial(order=1) - self.mp = (0.1, 1.0) - self.x = np.linspace(0.0, 1.0, 5) - self.err = np.full(5, 0.1) - self.obs = Observation(self.x, self.x + 0.1, y_stat_err=self.err) - - def test_fixed_kernel_term_in_constraint(self): - kernel = RBF(length_scale=0.3, length_scale_bounds="fixed") - c = Constraint( - [self.obs], self.pm, extra_terms=[kernel_term(kernel, jitter=0.0)] - ) - self.assertTrue(c.covariance.is_constant) - self.assertEqual(c.n_params, 0) - ym = self.pm(self.obs, *self.mp) - cov = np.diag(self.err**2) + kernel(self.x[:, None]) - expected = manual_mvn_loglike(self.obs.y, ym, cov) - self.assertAlmostEqual(c.log_likelihood(self.mp), expected) - - def test_x_dependent_constant_term_in_constraint(self): - t = Term(lambda c: 0.1 * c.x, kind="diag", constant=True) - c = Constraint([self.obs], self.pm, extra_terms=[t]) - self.assertTrue(c.covariance.is_constant) - ym = self.pm(self.obs, *self.mp) - cov = np.diag(self.err**2 + (0.1 * self.x) ** 2) - self.assertAlmostEqual( - c.log_likelihood(self.mp), manual_mvn_loglike(self.obs.y, ym, cov) - ) - # the eager validation warmed the cache; a fresh copy is returned to callers - S = c.covariance_matrix(self.mp) - self.assertTrue(S.flags.writeable) - np.testing.assert_allclose(S, cov) - - -class TestMaskWithPerObservationScaling(unittest.TestCase): - """Masked views keep routing to their root observation's rho.""" - - def setUp(self): - self.x = np.array([1.0, 2.0, 3.0, 4.0]) - self.err = np.full(4, 0.1) - self.obs1 = Observation(self.x, 2.0 * self.x, y_stat_err=self.err) - self.obs2 = Observation(self.x, 6.0 * self.x, y_stat_err=self.err) - self.pm = Polynomial( - order=1, transform=per_observation_scaling([self.obs1, self.obs2]) - ) - self.mp = (0.0, 2.0, 0.0, np.log(3.0)) - - def _reference(self, obs_list, keep): - # a constraint built directly on the same active points; masked views - # share their root's identity so the same transform routes them - return Constraint(obs_list, self.pm, mask=keep).log_likelihood(self.mp) - - def test_masked_view_routes_to_root(self): - c = Constraint([self.obs1, self.obs2], self.pm) - held = c.masked(point_masks=[self.x < 2.5, None]) - ref = self._reference([self.obs1.masked(self.x < 2.5), self.obs2], [True, True]) - self.assertAlmostEqual(held.log_likelihood(self.mp), ref) - - def test_complement_routes_to_root(self): - c = Constraint([self.obs1, self.obs2], self.pm, mask=[True, False]) - comp = c.complement() - self.assertEqual(comp.n_data_pts, 4) - ref = self._reference([self.obs1, self.obs2], [False, True]) - self.assertAlmostEqual(comp.log_likelihood(self.mp), ref) - self.assertAlmostEqual( - c.log_likelihood(self.mp) + comp.log_likelihood(self.mp), - Constraint([self.obs1, self.obs2], self.pm).log_likelihood(self.mp), - ) - - -if __name__ == "__main__": - unittest.main() + Constraint( + [self.c1, self.c2], terms=[Term(np.ones(3), kind="diag", on=self.c1)] + ) + + def test_masked_where_and_complement_partition(self): + c = Constraint([self.c1, self.c2], terms=[noise(self.eps)]) + fit = c.masked_where(lambda x: x < 1.6) + held = fit.complement() + assert set(fit.active) | set(held.active) == set(range(7)) + assert set(fit.active).isdisjoint(held.active) + assert fit.n_active + held.n_active == 7 + again = held.complement() + assert all(np.array_equal(a, b) for a, b in zip(again.masks, fit.masks)) + # complement of an unmasked constraint deactivates everything + assert c.complement().n_active == 0 + + def test_views_share_objects(self): + t = noise(self.eps) + c = Constraint([self.c1, self.c2], terms=[t], weight=0.5, likelihood=Chi2()) + view = c.masked_where(lambda x: x > 1.5) + assert view.comparisons == c.comparisons and view.terms == (t,) + assert view.terms[0].params[0] is self.eps + assert view.likelihood is c.likelihood and view.weight == 0.5 + + def test_log_jacobian_over_active_points(self): + c1 = Comparison(self.d1, line, space=log) + c = Constraint([c1, self.c2]) + assert c.log_jacobian == pytest.approx(-np.sum(np.log(self.d1.y))) + masked = c.masked([np.array([True, False, False]), np.ones(4, bool)]) + assert masked.log_jacobian == pytest.approx(-np.log(self.d1.y[0])) diff --git a/test/test_covariance.py b/test/test_covariance.py index 86d4840..7ee8b38 100644 --- a/test/test_covariance.py +++ b/test/test_covariance.py @@ -1,812 +1,327 @@ -"""Unit tests for the stacked-covariance core (:mod:`rxmc.covariance`).""" - -from types import SimpleNamespace +"""The structured (Woodbury) covariance against the dense reference.""" import numpy as np import pytest -from sklearn.gaussian_process.kernels import RBF, ConstantKernel, Matern, WhiteKernel - -from helpers import make_ctx -from rxmc.covariance import ( - ConstraintCovariance, - StackContext, - Term, - averaging, - constant_amplitude, - exp_growth, - exp_growth_amplitude, - kernel_term, - model_error_term, - noise_fraction_term, - noise_term, - normalization_term, - offset_term, - ones, - statistical_term, - systematic_term, - x_basis, - ym, -) -from rxmc.elastic_diffxs_observation import momentum_transfer -from rxmc.likelihood_model import mahalanobis_distance_sqr_cholesky -from rxmc.params import Parameter -from rxmc.transforms import Transform - - -def single_block_ctx(x, y, ym): - n = len(x) - return make_ctx(x, y, ym, [np.arange(n)]) - - -def assemble(terms, ctx, theta=()): - cov = ConstraintCovariance(terms, len(ctx.x), blocks=ctx.supports) - return cov.matrix(ctx, *theta) +from helpers import ( + STUDY_LEGEND, + assemble_dense, + index_params, + mahalanobis, + matern52, + rbf, + study_form, +) +from rxmc import Parameter +from rxmc.covariance import StructuredCovariance, chol_logdet +from rxmc.terms import Term, kernel, noise, normalization, offset, statistical -# ---------------------------------------------------------------------------- -# Term -# ---------------------------------------------------------------------------- - - -class TestTermKinds: - def test_diag_array_squares_std(self): - t = Term(np.array([1.0, 2.0, 3.0]), kind="diag", support=[0, 1, 2]) - S = np.zeros((3, 3)) - t.add_to(S, None, ()) - assert np.allclose(S, np.diag([1.0, 4.0, 9.0])) - assert t.is_constant - assert not t.couples_offdiagonal - - def test_mode_array_outer(self): - v = np.array([1.0, 2.0]) - t = Term(v, kind="mode", support=[0, 1]) - S = np.zeros((2, 2)) - t.add_to(S, None, ()) - assert np.allclose(S, np.outer(v, v)) - assert t.couples_offdiagonal - - def test_matrix_array_passthrough_into_subblock(self): - m = np.array([[2.0, 0.5], [0.5, 3.0]]) - t = Term(m, support=[2, 3]) - S = np.zeros((4, 4)) - t.add_to(S, None, ()) - expected = np.zeros((4, 4)) - expected[2:, 2:] = m - assert np.allclose(S, expected) - - def test_bad_kind_raises(self): - with pytest.raises(ValueError, match="kind"): - Term(np.ones(2), kind="rank1", support=[0, 1]) - - def test_scalar_broadcast_raises(self): - # a (1, 1) matrix on a length-3 support used to broadcast silently - with pytest.raises(ValueError, match="expects shape"): - Term([[0.04]], support=np.arange(3)) - - def test_wrong_length_vector_raises(self): - with pytest.raises(ValueError, match="expects shape"): - Term(np.ones(2), kind="diag", support=np.arange(3)) - - def test_asymmetric_matrix_raises(self): - with pytest.raises(ValueError, match="symmetric"): - Term(np.array([[1.0, 0.2], [0.0, 1.0]]), support=[0, 1]) - - def test_array_with_params_raises(self): - with pytest.raises(ValueError, match="array-valued"): - Term(np.ones(2), (Parameter("p"),), kind="diag", support=[0, 1]) - - def test_callable_sees_local_context_and_values(self): - seen = {} - - def fn(c, a, b): - seen["c"] = c - return a * c.ym + b * c.y - - pa, pb = Parameter("a"), Parameter("b") - t = Term(fn, (pa, pb), kind="diag", support=[1, 2]) - ctx = single_block_ctx([0.0, 1.0, 2.0], [1.0, 2.0, 3.0], [1.5, 2.5, 3.5]) - S = np.zeros((3, 3)) - t.add_to(S, ctx, (2.0, 1.0)) - c = seen["c"] - assert np.allclose(c.x, [1.0, 2.0]) - assert np.allclose(c.ym, [2.5, 3.5]) - assert len(c) == 2 - v = 2.0 * np.array([2.5, 3.5]) + np.array([2.0, 3.0]) - assert np.allclose(np.diag(S), [0.0, *(v**2)]) - - def test_callable_wrong_shape_raises(self): - t = Term(lambda c: np.ones(len(c) + 1), kind="diag", support=[0, 1]) - ctx = single_block_ctx([0.0, 1.0], [0.0, 0.0], [0.0, 0.0]) - with pytest.raises(ValueError, match="returned shape"): - t.add_to(np.zeros((2, 2)), ctx, ()) - - def test_wrong_param_count_raises(self): - t = Term(lambda c, a: a * ones(c), (Parameter("a"),), kind="diag", support=[0]) - ctx = single_block_ctx([0.0], [0.0], [0.0]) - with pytest.raises(ValueError, match="expected 1 params"): - t.add_to(np.zeros((1, 1)), ctx, ()) - - def test_constant_callable_cached(self): - calls = [] - def fn(c): - calls.append(1) - return np.ones(len(c)) +def build(terms, x, y, offsets, active=None, rows=None, labels=None): + """Wire terms into a StructuredCovariance with identity-gathered params.""" + n = len(y) + params, gathers = index_params(terms) + rows = rows if rows is not None else [np.arange(n) for _ in terms] + active = np.arange(n) if active is None else np.asarray(active, dtype=int) + entries = list(zip(terms, rows, gathers)) + cov = StructuredCovariance(entries, x, y, offsets, active, labels=labels) + return cov, params - t = Term(fn, kind="diag", support=[0, 1], constant=True) - assert t.is_constant - ctx = single_block_ctx([0.0, 1.0], [0.0, 0.0], [0.0, 0.0]) - t.add_to(np.zeros((2, 2)), ctx, ()) - t.add_to(np.zeros((2, 2)), ctx, ()) - assert len(calls) == 1 - def test_constant_flag_ignored_with_params(self): - t = Term(lambda c, a: ones(c), (Parameter("a"),), kind="diag", constant=True) - assert not t.is_constant +def theta_for(params, values_by_term, terms): + """Flat theta from per-term value tuples, honouring shared parameters.""" + theta = np.zeros(len(params)) + for t, v in zip(terms, values_by_term): + for p, val in zip(t.params, v): + theta[params.index(p)] = val + return theta - def test_constant_term_may_read_x(self): - # constant means "independent of ym"; x is invariant and readable - x = np.linspace(0.0, 2.0, 4) - t = Term(lambda c: 0.1 * c.x, kind="diag", constant=True) - cov = ConstraintCovariance([t], 4) - assert cov.is_constant - ctx = StackContext.constant(x, np.zeros(4), [np.arange(4)]) - np.testing.assert_allclose(cov.matrix(ctx), np.diag((0.1 * x) ** 2)) - # a mis-declared constant term (reads ym) fails loudly, not silently - bad = ConstraintCovariance( - [Term(lambda c: 0.1 * c.ym, kind="diag", constant=True)], 4 - ) - with pytest.raises(TypeError): - bad.matrix(ctx) - assert cov.matrix(single_block_ctx(x, np.zeros(4), np.ones(4))) is cov.matrix( - ctx - ) +def grid(n=12, seed=1): + rng = np.random.default_rng(seed) + x = np.sort(rng.uniform(0.2, 3.0, n)) + y = rng.uniform(0.1, 1.5, n) + ym = y + rng.normal(0.0, 0.1, n) + return x, y, ym -class TestTermCoords: - def test_coords_callable_applied_to_x(self): - t = Term(lambda c: c.x, kind="diag", support=[0, 1], coords=lambda x: 2 * x) - ctx = single_block_ctx([1.0, 3.0], [0.0, 0.0], [0.0, 0.0]) - assert np.allclose(t.local_context(ctx).x, [2.0, 6.0]) - def test_parametric_coords_params_appended(self): - pk = Parameter("k") - coords = Transform(lambda x, k: k * x, (pk,)) - pa = Parameter("a") - t = Term( - lambda c, a: a * c.x, (pa,), kind="diag", support=[0, 1], coords=coords - ) - assert t.params == (pa, pk) - ctx = single_block_ctx([1.0, 2.0], [0.0, 0.0], [0.0, 0.0]) - S = np.zeros((2, 2)) - t.add_to(S, ctx, (3.0, 2.0)) # a=3, k=2 -> v = 3 * 2 * x - assert np.allclose(np.diag(S), (6.0 * np.array([1.0, 2.0])) ** 2) - - def test_coords_array_2d_reaches_kernel(self): - kernel = RBF(length_scale=1.0) - X = np.array([[0.0, 0.0], [1.0, 1.0], [2.0, 0.0]]) - t = kernel_term(kernel, coords=lambda x: X, jitter=0.0, support=np.arange(3)) - ctx = single_block_ctx(np.zeros(3), np.zeros(3), np.zeros(3)) - S = np.zeros((3, 3)) - t.add_to(S, ctx, kernel.theta) - assert np.allclose(S, kernel(X)) - - -class TestSupportNone: - def test_bound_by_constraint_covariance(self): - p = Parameter("log eps") - t = noise_term(p) - assert not t.bound - cov = ConstraintCovariance([t], 3) - assert t.bound and np.array_equal(t.support, np.arange(3)) - ctx = single_block_ctx(np.zeros(3), np.zeros(3), np.zeros(3)) - assert np.allclose(cov.matrix(ctx, np.log(2.0)), 4.0 * np.eye(3)) - - def test_unbound_add_to_raises(self): - t = noise_term(Parameter("p")) - with pytest.raises(ValueError, match="unresolved"): - t.add_to(np.zeros((2, 2)), None, (0.0,)) - - def test_bind_idempotent_and_explicit_support_untouched(self): - t = Term(np.ones(2), kind="diag", support=[1, 2]) - t.bind(5) - assert np.array_equal(t.support, [1, 2]) - u = Term(np.ones(3), kind="diag") - u.bind(3) - u.bind(3) - assert np.array_equal(u.support, np.arange(3)) - - def test_array_length_checked_at_bind(self): - t = Term(np.ones(2), kind="diag") - with pytest.raises(ValueError, match="expects shape"): - ConstraintCovariance([t], 3) - - def test_whole_stack_mode_block_diagonality(self): - one = ConstraintCovariance( - [offset_term(parameter=Parameter("w"))], 3, blocks=[np.arange(3)] - ) - assert one.block_diagonal - two = ConstraintCovariance( - [offset_term(parameter=Parameter("w"))], - 4, - blocks=[np.arange(2), np.arange(2, 4)], - ) - assert not two.block_diagonal - diag = ConstraintCovariance( - [noise_term(Parameter("e"))], 4, blocks=[np.arange(2), np.arange(2, 4)] - ) - assert diag.block_diagonal - - def test_non_term_raises(self): - with pytest.raises(TypeError): - ConstraintCovariance([np.eye(2)], 2) +# ---------------------------------------------------------------------------- +# Single block: every study form +# ---------------------------------------------------------------------------- - def test_rebinding_to_a_different_stack_raises(self): - t = noise_term(Parameter("p")) - ConstraintCovariance([t], 4) - ConstraintCovariance([t], 4) # same stack (a masked view): fine - with pytest.raises(ValueError, match="already bound"): - ConstraintCovariance([t], 6) - def test_local_context_checks_param_count(self): - s = Parameter("s") - t = Term(lambda c: c.x, kind="diag", coords=Transform(lambda a, s: s * a, (s,))) - t.bind(2) - ctx = single_block_ctx(np.ones(2), np.zeros(2), np.zeros(2)) - with pytest.raises(ValueError, match="expected 1 params"): - t.local_context(ctx) +@pytest.mark.parametrize("label", list(STUDY_LEGEND)) +def test_study_forms_match_dense(label): + """See ``helpers.STUDY_LEGEND`` for what each label means.""" + x, y, ym = grid() + form = study_form(label, x, y, ym) + cov, params = build(form.terms, x, y, [slice(0, len(y))]) + theta = theta_for(params, form.values, form.terms) + d2, logdet = cov.distance(ym, theta) + d2_ref, logdet_ref = mahalanobis(y, ym, form.dense) + assert d2 == pytest.approx(d2_ref) and logdet == pytest.approx(logdet_ref) + np.testing.assert_allclose(cov.matrix(ym, theta), form.dense) + assert not cov.dense # ---------------------------------------------------------------------------- -# Gather-by-identity and structural properties +# Gather by identity # ---------------------------------------------------------------------------- class TestGatherByIdentity: - def test_shared_parameter_dedup(self): - p = Parameter("log eps") - cov = ConstraintCovariance( - [noise_term(p, support=[0, 1]), noise_term(p, support=[2, 3])], 4 - ) - assert cov.n_params == 1 - - def test_distinct_parameters_not_shared(self): - cov = ConstraintCovariance( - [ - noise_term(Parameter("a"), support=[0, 1]), - noise_term(Parameter("b"), support=[2, 3]), - ], - 4, - ) - assert cov.n_params == 2 + def setup_method(self): + self.x, self.y, self.ym = grid(6) + self.offsets = [slice(0, 3), slice(3, 6)] + self.rows = [np.arange(3), np.arange(3, 6)] - def test_shared_value_fed_to_both(self): + def test_shared_parameter_is_one_slot(self): p = Parameter("log eps") - cov = ConstraintCovariance( - [noise_term(p, support=[0, 1]), noise_term(p, support=[2, 3])], 4 - ) - ctx = single_block_ctx(np.zeros(4), np.zeros(4), np.zeros(4)) - S = cov.matrix(ctx, np.log(3.0)) - assert np.allclose(S, 9.0 * np.eye(4)) + terms = [noise(p), noise(p)] + cov, params = build(terms, self.x, self.y, self.offsets, rows=self.rows) + assert params == (p,) + np.testing.assert_allclose(cov.matrix(self.ym, [np.log(3.0)]), 9.0 * np.eye(6)) - def test_first_seen_order_deterministic(self): + def test_distinct_parameters_are_two_slots_in_first_seen_order(self): a, b = Parameter("a"), Parameter("b") - cov = ConstraintCovariance( - [ - noise_term(b, support=[0]), - noise_term(a, support=[1]), - noise_term(b, support=[2]), - ], - 3, - ) - assert cov.params == (b, a) + terms = [noise(b), noise(a)] + cov, params = build(terms, self.x, self.y, self.offsets, rows=self.rows) + assert params == (b, a) + S = cov.matrix(self.ym, [np.log(2.0), np.log(3.0)]) + np.testing.assert_allclose(np.diag(S), [4, 4, 4, 9, 9, 9]) - def test_wrong_param_count_raises(self): - cov = ConstraintCovariance([noise_term(Parameter("a"))], 2) - with pytest.raises(ValueError, match="expected 1 params"): - cov.matrix(None) - - -class TestProperties: - def test_is_constant_and_caching(self): - cov = ConstraintCovariance( - [statistical_term(np.array([1.0, 2.0]))], 2, blocks=[np.arange(2)] - ) - assert cov.is_constant - S1 = cov.matrix(None) - S2 = cov.matrix(None) - assert S1 is S2 - assert not S1.flags.writeable - L, _ = cov.cholesky(None) - assert not L.flags.writeable - - def test_nonconstant_matrix_writable(self): - cov = ConstraintCovariance([noise_term(Parameter("a"))], 2) - ctx = single_block_ctx(np.zeros(2), np.zeros(2), np.zeros(2)) - S = cov.matrix(ctx, 0.0) - assert S.flags.writeable - - def test_block_cholesky_cached_and_requires_blocks(self): - cov = ConstraintCovariance( - [statistical_term(np.ones(4))], 4, blocks=[np.arange(2), np.arange(2, 4)] - ) - f1 = cov.block_cholesky(None) - f2 = cov.block_cholesky(None) - assert f1 is f2 - with pytest.raises(ValueError): - ConstraintCovariance([statistical_term(np.ones(2))], 2).block_cholesky(None) - - def test_cross_block_term_without_blocks_not_block_diagonal(self): - cov = ConstraintCovariance([offset_term(parameter=Parameter("w"))], 4) - assert not cov.block_diagonal - diag = ConstraintCovariance([noise_term(Parameter("e"))], 4) - assert diag.block_diagonal - - def test_stacked_distance_matches_dense(self): - x = np.arange(4.0) - y = np.array([1.0, 2.0, 3.0, 4.0]) - ymod = np.array([1.1, 1.9, 3.2, 3.8]) - ctx = make_ctx(x, y, ymod, [np.arange(2), np.arange(2, 4)]) - terms = [statistical_term(0.5 * np.ones(4)), noise_term(Parameter("e"))] - block = ConstraintCovariance(terms, 4, blocks=ctx.supports) - dense = ConstraintCovariance(terms, 4) - assert block.block_diagonal - d_b = block.stacked_distance(ctx, (np.log(0.3),)) - d_d = dense.stacked_distance(ctx, (np.log(0.3),)) - S = block.matrix(ctx, np.log(0.3)) - assert np.allclose(d_b, mahalanobis_distance_sqr_cholesky(y, ymod, S)) - assert np.allclose(d_d, d_b) - - -class TestActive: - def setup_method(self): - self.x = np.arange(6.0) - self.y = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0]) - self.ym = self.y + 0.1 * np.array([1, -1, 1, -1, 1, -1]) - self.blocks = [np.arange(3), np.arange(3, 6)] - self.ctx = make_ctx(self.x, self.y, self.ym, self.blocks) - self.eta = Parameter("log eta") - self.terms = [ - statistical_term(0.3 * np.ones(6)), - normalization_term(parameter=self.eta), # whole stack -> dense - ] - self.active = np.array([0, 2, 3, 5]) - - def _reference(self, cov, active): - """Dense (d2, logdet) on the active subset of ``cov``'s full matrix.""" - S = cov.matrix(self.ctx, np.log(0.2))[np.ix_(active, active)] - return mahalanobis_distance_sqr_cholesky(self.y[active], self.ym[active], S) - - def test_dense_path_restricts_to_active(self): - cov = ConstraintCovariance(self.terms, 6, active=self.active) - assert cov.n_active == 4 - d2, ld = cov.stacked_distance(self.ctx, (np.log(0.2),)) - assert np.allclose((d2, ld), self._reference(cov, self.active)) - assert cov.active_matrix(self.ctx, np.log(0.2)).shape == (4, 4) - assert cov.matrix(self.ctx, np.log(0.2)).shape == (6, 6) - - def test_block_path_restricts_to_active(self): - terms = [statistical_term(0.3 * np.ones(6)), noise_term(Parameter("e"))] - cov = ConstraintCovariance(terms, 6, blocks=self.blocks, active=self.active) - assert cov.block_diagonal and cov.uses_block_path - d2, ld = cov.stacked_distance(self.ctx, (np.log(0.2),)) - assert np.allclose((d2, ld), self._reference(cov, self.active)) - - def test_fully_masked_block_skipped(self): - terms = [statistical_term(0.3 * np.ones(6))] - active = np.arange(3) - cov = ConstraintCovariance(terms, 6, blocks=self.blocks, active=active) - d2, ld = cov.stacked_distance(self.ctx) - r = (self.y - self.ym)[:3] - assert np.allclose((d2, ld), (r @ r / 0.09, 3 * np.log(0.09))) - - def test_all_active_is_none(self): - cov = ConstraintCovariance(self.terms, 6, active=np.arange(6)) - assert cov.active is None - - def test_permuted_active_is_kept(self): - perm = np.array([5, 4, 3, 2, 1, 0]) - cov = ConstraintCovariance(self.terms, 6, active=perm) - assert cov.active is not None and cov.n_active == 6 - ref = ConstraintCovariance(self.terms, 6) - d_perm = cov.stacked_distance(self.ctx, (np.log(0.2),)) - d_ref = ref.stacked_distance(self.ctx, (np.log(0.2),)) - assert np.allclose(d_perm, d_ref) + def test_wrong_theta_length_raises(self): + cov, _ = build([noise(Parameter("a"))], self.x, self.y, [slice(0, 6)]) + with pytest.raises((IndexError, ValueError)): + cov.distance(self.ym, []) # ---------------------------------------------------------------------------- -# Factories +# Several blocks: modes across blocks stay structured, matrices crossing go dense # ---------------------------------------------------------------------------- -class TestFactories: +class TestMultiBlock: def setup_method(self): - self.x = np.array([0.5, 1.0, 1.5]) - self.y = np.array([1.0, 2.0, 3.0]) - self.ym = np.array([1.1, 1.9, 3.2]) - self.stat = np.array([0.1, 0.2, 0.3]) - self.ctx = single_block_ctx(self.x, self.y, self.ym) - - def test_statistical_only(self): - S = assemble([statistical_term(self.stat)], self.ctx) - assert np.allclose(S, np.diag(self.stat**2)) - - def test_unknown_noise(self): - S = assemble([noise_term(Parameter("e"))], self.ctx, (np.log(0.4),)) - assert np.allclose(S, 0.16 * np.eye(3)) - S = assemble([noise_term(Parameter("e"), log=False)], self.ctx, (0.4,)) - assert np.allclose(S, 0.16 * np.eye(3)) - - def test_unknown_noise_fraction(self): - S = assemble([noise_fraction_term(Parameter("e"))], self.ctx, (np.log(0.4),)) - assert np.allclose(S, np.diag((0.4 * self.ym) ** 2)) - - def test_unknown_normalization_error(self): - S = assemble( - [normalization_term(parameter=Parameter("n"))], self.ctx, (np.log(0.05),) + self.x, self.y, self.ym = grid(9, seed=2) + self.offsets = [slice(0, 3), slice(3, 6), slice(6, 9)] + self.b = [np.arange(0, 3), np.arange(3, 6), np.arange(6, 9)] + self.eps, self.eta, self.omega = ( + Parameter("log_eps"), + Parameter("log_eta"), + Parameter("log_omega"), ) - assert np.allclose(S, 0.05**2 * np.outer(self.ym, self.ym)) + self.stat = 0.1 * np.ones(9) - def test_unknown_model_error_averaging(self): - S = assemble( - [model_error_term(Parameter("g"), averaging=True)], self.ctx, (np.log(0.1),) - ) - z = 0.5 * (self.y + self.ym) - assert np.allclose(S, np.diag((0.1 * z) ** 2)) - S = assemble( - [model_error_term(Parameter("g"), averaging=False)], - self.ctx, - (np.log(0.1),), - ) - assert np.allclose(S, np.diag((0.1 * self.ym) ** 2)) - - def test_fixed_normalization_systematic(self): - S = assemble([normalization_term(magnitude=0.05)], self.ctx) - assert np.allclose(S, 0.05**2 * np.outer(self.ym, self.ym)) - S = assemble([normalization_term(magnitude=np.array(0.05))], self.ctx) - assert np.allclose(S, 0.05**2 * np.outer(self.ym, self.ym)) - - def test_fixed_offset_systematic(self): - t = offset_term(magnitude=0.2) - assert t.is_constant - S = assemble([t], self.ctx) - assert np.allclose(S, 0.04 * np.ones((3, 3))) - S = assemble([offset_term(magnitude=np.array([0.1, 0.2, 0.3]))], self.ctx) - v = np.array([0.1, 0.2, 0.3]) - assert np.allclose(S, np.outer(v, v)) - - def test_fixed_offset_in_constant_covariance_ignores_ym(self): - # a constant covariance never reads ym: it can be factored (eagerly, at - # Constraint construction) with a placeholder ym and the cached factor - # is reused afterwards - cov = ConstraintCovariance( - [statistical_term(self.stat), offset_term(magnitude=0.2)], 3 + def reference(self, terms, rows, values): + return assemble_dense(terms, self.x, self.y, self.ym, values, rows) + + def test_case_a_modes_across_blocks(self): + terms = [ + statistical(self.stat[:3]), + statistical(self.stat[3:6]), + statistical(self.stat[6:]), + noise(self.eps), + normalization(parameter=self.eta), # on blocks 1 and 2 only (case A) + offset(parameter=self.omega), # on all + ] + rows = [*self.b, np.arange(9), np.arange(6), np.arange(9)] + cov, params = build(terms, self.x, self.y, self.offsets, rows=rows) + assert not cov.dense + values = [(), (), (), (np.log(0.2),), (np.log(0.05),), (np.log(0.07),)] + theta = theta_for(params, values, terms) + ref = self.reference(terms, rows, values) + d2, logdet = cov.distance(self.ym, theta) + d2_ref, ld_ref = mahalanobis(self.y, self.ym, ref) + assert d2 == pytest.approx(d2_ref) and logdet == pytest.approx(ld_ref) + np.testing.assert_allclose(cov.matrix(self.ym, theta), ref) + assert np.any(ref[:3, 3:6] != 0.0) # the modes really couple blocks + + def test_rank_two_woodbury_with_block_local_kernel(self): + gp = kernel(*matern52("gp"), jitter=0.0) + terms = [ + statistical(self.stat), + offset(parameter=self.omega), + normalization(parameter=self.eta), + gp, + ] + rows = [np.arange(9), np.arange(9), np.arange(9), self.b[1]] + cov, params = build(terms, self.x, self.y, self.offsets, rows=rows) + assert not cov.dense + values = [(), (np.log(0.07),), (np.log(0.05),), (np.log(0.4),)] + theta = theta_for(params, values, terms) + ref = self.reference(terms, rows, values) + np.testing.assert_allclose( + cov.distance(self.ym, theta), mahalanobis(self.y, self.ym, ref) ) - assert cov.is_constant - L, logdet = cov.cholesky( - StackContext.constant(self.ctx.x, self.ctx.y, [np.arange(3)]) + np.testing.assert_allclose(cov.matrix(self.ym, theta), ref) + + def test_cross_block_matrix_forces_dense_path(self): + gp = kernel(*rbf(), jitter=0.0) + terms = [statistical(self.stat), gp] + rows = [np.arange(9), np.arange(6)] # spans blocks 0 and 1 + cov, params = build(terms, self.x, self.y, self.offsets, rows=rows) + assert cov.dense + values = [(), (0.0,)] + theta = theta_for(params, values, terms) + ref = self.reference(terms, rows, values) + np.testing.assert_allclose( + cov.distance(self.ym, theta), mahalanobis(self.y, self.ym, ref) ) - assert np.all(np.isfinite(L)) - L2, logdet2 = cov.cholesky(self.ctx) - assert L2 is L and logdet2 == logdet - - def test_masked_magnitudes(self): - m = np.array([1.0, 0.0, 1.0]) - S = assemble([offset_term(magnitude=0.2, mask=m)], self.ctx) - v = 0.2 * m - assert np.allclose(S, np.outer(v, v)) - S = assemble( - [normalization_term(parameter=Parameter("n"), mask=m)], - self.ctx, - (np.log(0.5),), + local, _ = build( + terms, self.x, self.y, self.offsets, rows=[np.arange(9), self.b[0]] ) - v = 0.5 * m * self.ym - assert np.allclose(S, np.outer(v, v)) - - def test_length_one_magnitude_or_mask_raises(self): - # a length-1 array is not a scalar: it must not broadcast silently - with pytest.raises(ValueError, match="shape"): - assemble([offset_term(magnitude=np.array([0.2]))], self.ctx) - with pytest.raises(ValueError, match="shape"): - assemble([offset_term(magnitude=0.2, mask=np.array([1.0]))], self.ctx) - with pytest.raises(ValueError, match="shape"): - assemble( - [normalization_term(parameter=Parameter("n"), mask=np.array([1.0]))], - self.ctx, - (0.0,), - ) + assert not local.dense - def test_zero_d_magnitude_is_scalar(self): - # exfor_tools stores scalar systematics as 0-d arrays - S = assemble([offset_term(magnitude=np.array(0.2))], self.ctx) - assert np.allclose(S, 0.04 * np.ones((3, 3))) - - def test_magnitude_length_mismatch_raises(self): - with pytest.raises(ValueError): - assemble([offset_term(magnitude=np.ones(2))], self.ctx) - - def test_requires_magnitude_or_parameter(self): - with pytest.raises(ValueError): - offset_term() - with pytest.raises(ValueError): - normalization_term() - - def test_systematic_term_with_basis(self): - s = Parameter("log s") - S = assemble([systematic_term(s, basis=x_basis(2.0))], self.ctx, (np.log(3.0),)) - v = 3.0 * self.x / 2.0 - assert np.allclose(S, np.outer(v, v)) - - def test_parametric_basis(self): - e, l = Parameter("log e"), Parameter("slope") - t = noise_term(e, basis=exp_growth(np.pi), basis_params=(l,)) - assert t.params == (e, l) - S = assemble([t], self.ctx, (np.log(0.3), 0.0)) - assert np.allclose(S, 0.09 * np.eye(3)) # slope 0 == plain noise_term - S = assemble([t], self.ctx, (np.log(0.3), 2.0)) - assert np.allclose(S, np.diag((0.3 * np.exp(2.0 * self.x / np.pi)) ** 2)) - # basis growing with ym in linear space - t = noise_term(e, basis=exp_growth(np.pi, base=ym), basis_params=(l,)) - S = assemble([t], self.ctx, (np.log(0.3), 1.0)) - assert np.allclose(S, np.diag((0.3 * self.ym * np.exp(self.x / np.pi)) ** 2)) - - def test_old_observation_covariance_equivalence(self): - offset, norm = 0.2, 0.05 + def test_masks_restrict_to_active_rows(self): terms = [ - statistical_term(self.stat), - offset_term(magnitude=offset), - normalization_term(magnitude=norm), + statistical(self.stat), + noise(self.eps), + normalization(parameter=self.eta), ] - S = assemble(terms, self.ctx) - old = ( - np.diag(self.stat**2) - + np.outer(offset * np.ones(3), offset * np.ones(3)) - + norm**2 * np.outer(self.ym, self.ym) + rows = [np.arange(9)] * 3 + active = np.array([0, 2, 3, 5, 7, 8]) + cov, params = build( + terms, self.x, self.y, self.offsets, active=active, rows=rows ) - assert np.allclose(S, old) - - def test_bases(self): - c = Term(lambda c: c.ym, kind="diag", support=np.arange(3)).local_context( - self.ctx + assert cov.n_active == 6 + values = [(), (np.log(0.2),), (np.log(0.05),)] + theta = theta_for(params, values, terms) + ref = self.reference(terms, rows, values)[np.ix_(active, active)] + np.testing.assert_allclose( + cov.distance(self.ym, theta), + mahalanobis(self.y[active], self.ym[active], ref), ) - assert np.allclose(ones(c), 1.0) - assert np.allclose(ym(c), self.ym) - assert np.allclose(averaging(c), 0.5 * (self.y + self.ym)) - - -class TestKernelTerm: - def test_params_match_theta_length_isotropic(self): - kernel = ConstantKernel(1.0) * RBF(length_scale=1.0) + WhiteKernel(1e-6) - term = kernel_term(kernel) - assert len(term.params) == len(kernel.theta) - assert not term.is_constant - - def test_params_anisotropic(self): - kernel = ConstantKernel(1.0) * RBF(length_scale=[1.0, 1.0]) - term = kernel_term(kernel, support=np.arange(3)) - assert len(term.params) == len(kernel.theta) - x2d = np.array([[0.0, 0.0], [1.0, 0.5], [2.0, 1.0]]) - ctx = make_ctx(x2d, np.zeros(3), np.zeros(3), [np.arange(3)]) - Sigma = np.zeros((3, 3)) - term.add_to(Sigma, ctx, kernel.theta) - assert np.all(np.isfinite(Sigma)) - - def test_cross_block_values(self): - kernel = RBF(length_scale=1.0) - term = kernel_term(kernel, jitter=0.0, support=np.arange(4)) - x = np.array([0.0, 1.0, 2.0, 3.0]) - ctx = make_ctx(x, np.zeros(4), np.zeros(4), [np.arange(2), np.arange(2, 4)]) - S = np.zeros((4, 4)) - term.add_to(S, ctx, kernel.theta) - np.testing.assert_allclose(S, kernel(x[:, None])) - assert np.any(S[:2, 2:] != 0.0) - cov = ConstraintCovariance([term], N=4, blocks=[np.arange(2), np.arange(2, 4)]) - assert not cov.block_diagonal - - def test_fixed_kernel_is_constant(self): - kernel = RBF(length_scale=1.0, length_scale_bounds="fixed") - term = kernel_term(kernel) - assert term.params == () and term.is_constant - - def test_constant_amplitude_reproduces_constant_kernel(self): - x = np.linspace(0.0, 2.0, 5) - ctx = single_block_ctx(x, np.zeros(5), np.zeros(5)) - A = 0.7 - la = Parameter("log A") - term = kernel_term( - RBF(1.0), amplitude=constant_amplitude, amplitude_params=(la,), jitter=0.0 + np.testing.assert_allclose(cov.matrix(self.ym, theta), ref) + + def test_fully_masked_block_is_skipped(self): + terms = [statistical(self.stat), offset(parameter=self.omega)] + rows = [np.arange(9)] * 2 + active = np.arange(3, 9) # block 0 fully masked + cov, params = build( + terms, self.x, self.y, self.offsets, active=active, rows=rows ) - assert [p.name for p in term.params] == ["discrepancy_length_scale", "log A"] - S = assemble([term], ctx, (0.0, np.log(A))) - ref = ConstantKernel(A**2, constant_value_bounds="fixed") * RBF(1.0) - np.testing.assert_allclose(S, ref(x[:, None])) - - def test_exp_growth_amplitude_and_coords(self): - x = np.linspace(0.1, 3.0, 4) - ctx = single_block_ctx(x, np.zeros(4), np.zeros(4)) - la, sl = Parameter("log A"), Parameter("slope") - - def q(x): - return 2.0 * np.sin(x / 2) - - term = kernel_term( - Matern(1.0, nu=2.5), - coords=q, - amplitude=exp_growth_amplitude(np.pi), - amplitude_params=(la, sl), - jitter=0.0, + values = [(), (np.log(0.07),)] + theta = theta_for(params, values, terms) + ref = self.reference(terms, rows, values)[np.ix_(active, active)] + np.testing.assert_allclose( + cov.distance(self.ym, theta), + mahalanobis(self.y[active], self.ym[active], ref), ) - S = assemble([term], ctx, (np.log(0.5), np.log(0.3), 1.5)) - # note: amplitude sees the *transformed* coordinate - a = 0.3 * np.exp(1.5 * q(x) / np.pi) - ref = np.outer(a, a) * Matern(0.5, nu=2.5)(q(x)[:, None]) - np.testing.assert_allclose(S, ref) - - def test_duplicate_coords_factorizable_with_jitter(self): - x = np.array([0.0, 0.0, 1.0]) - ctx = single_block_ctx(x, np.zeros(3), np.zeros(3)) - term = kernel_term(RBF(1.0), jitter=1e-8) - cov = ConstraintCovariance([term, statistical_term(1e-3 * np.ones(3))], 3) - L, _ = cov.cholesky(ctx, 0.0) - assert np.all(np.isfinite(L)) # ---------------------------------------------------------------------------- -# The alpha+Ca error-model ladder as one-line term lists (study self-checks) +# Constant parts, caching and the singular check # ---------------------------------------------------------------------------- -class TestStudyForms: - """Each error model of the alpha+Ca study is one term list; compare to the - hand-rolled dense covariance from that study's ``error_covariance``.""" - +class TestConstantAndSingular: def setup_method(self): - rng = np.random.default_rng(1) - n = 12 - self.x = np.sort(rng.uniform(0.2, 3.0, n)) # radians - self.y = rng.uniform(0.1, 1.5, n) # log-space "data" (any values) - self.ym = self.y + rng.normal(0.0, 0.1, n) - self.ctx = single_block_ctx(self.x, self.y, self.ym) - self.X = np.pi - self.log_err, self.log_slope = Parameter("log_err"), Parameter("log_err_slope") - self.log_sys, self.log_amp = Parameter("log_sys"), Parameter("log_amp") - self.err, self.slope, self.sys, self.amp = 0.05, 1.3, 0.04, 0.2 - self.k = 2.7 - - def xdeg(self): - return self.x / self.X # theta / 180 - - def test_L0(self): - S = assemble([noise_term(self.log_err)], self.ctx, (np.log(self.err),)) - assert np.allclose(S, self.err**2 * np.eye(len(self.x))) - - def test_E0_linear_space(self): - S = assemble([noise_fraction_term(self.log_err)], self.ctx, (np.log(self.err),)) - assert np.allclose(S, np.diag((self.err * self.ym) ** 2)) - - def test_L1(self): - terms = [ - noise_term( - self.log_err, basis=exp_growth(self.X), basis_params=(self.log_slope,) + self.x, self.y, self.ym = grid(6, seed=3) + self.offsets = [slice(0, 3), slice(3, 6)] + + def test_constant_covariance_is_evaluated_and_factored_once(self): + calls = [] + + def fn(c): + calls.append(1) + return 0.1 * np.ones(len(c)) + + t = Term(fn, kind="diag", constant=True) + cov, _ = build([t], self.x, self.y, self.offsets) + assert cov.is_constant + d1 = cov.distance(self.ym, []) + d2 = cov.distance(self.ym + 0.1, []) + assert len(calls) == 1 + assert d1[1] == d2[1] # same logdet from the cached factor + assert d1[0] != d2[0] + + def test_prediction_dependent_parameter_free_term_is_not_constant(self): + t = normalization(magnitude=0.05) + cov, _ = build([statistical(0.1 * np.ones(6)), t], self.x, self.y, self.offsets) + assert not cov.is_constant + S1, S2 = cov.matrix(self.ym, []), cov.matrix(2 * self.ym, []) + assert not np.allclose(S1, S2) + + def test_mode_only_block_is_singular_and_named(self): + terms = [offset(magnitude=0.2), statistical(0.1 * np.ones(3))] + rows = [np.arange(6), np.arange(3, 6)] + with pytest.raises(ValueError, match="'first'.*zero statistical error"): + build( + terms, + self.x, + self.y, + self.offsets, + rows=rows, + labels=["first", "second"], ) - ] - S = assemble(terms, self.ctx, (np.log(self.err), self.slope)) - sigma = self.err * np.exp(self.slope * self.xdeg()) - assert np.allclose(S, np.diag(sigma**2)) + # a diagonal term covering the block makes it legal + terms = [offset(magnitude=0.2), statistical(0.1 * np.ones(6))] + cov, _ = build(terms, self.x, self.y, self.offsets, rows=[np.arange(6)] * 2) + assert cov.is_constant - def test_L2_rank_one_over_theta(self): - terms = [ - noise_term(self.log_err), - systematic_term(self.log_sys, basis=x_basis(self.X)), - ] - S = assemble(terms, self.ctx, (np.log(self.err), np.log(self.sys))) - u = self.xdeg() - assert np.allclose( - S, self.err**2 * np.eye(len(u)) + self.sys**2 * np.outer(u, u) - ) + def test_modes_alone_fail_at_construction_even_when_parametric(self): + # modes never enter the block factor B, so B is constant and checkable + with pytest.raises(ValueError, match="singular"): + build([offset(parameter=Parameter("w"))], self.x, self.y, self.offsets) - def test_L2n_and_L2y(self): - S = assemble( - [noise_term(self.log_err), offset_term(parameter=self.log_sys)], - self.ctx, - (np.log(self.err), np.log(self.sys)), - ) - assert np.allclose(S, self.err**2 * np.eye(len(self.x)) + self.sys**2) - S = assemble( - [noise_term(self.log_err), normalization_term(parameter=self.log_sys)], - self.ctx, - (np.log(self.err), np.log(self.sys)), - ) - assert np.allclose( - S, - self.err**2 * np.eye(len(self.x)) - + self.sys**2 * np.outer(self.ym, self.ym), - ) + def test_parametric_diagonal_defers_the_check(self): + # B depends on theta here: nothing to check until the first evaluation + cov, _ = build([noise(Parameter("e"))], self.x, self.y, self.offsets) + assert not cov.is_constant + d2, logdet = cov.distance(self.ym, [np.log(0.3)]) + assert np.isfinite(d2) and np.isfinite(logdet) - def test_L12(self): - terms = [ - noise_term( - self.log_err, basis=exp_growth(self.X), basis_params=(self.log_slope,) - ), - systematic_term(self.log_sys, basis=x_basis(self.X)), - ] - S = assemble(terms, self.ctx, (np.log(self.err), self.slope, np.log(self.sys))) - sigma = self.err * np.exp(self.slope * self.xdeg()) - u = self.xdeg() - assert np.allclose(S, np.diag(sigma**2) + self.sys**2 * np.outer(u, u)) - def test_Lgp_matern_in_theta(self): - ell = 0.3 - terms = [ - noise_term(self.log_err), - kernel_term( - Matern(1.0, nu=2.5), - coords=lambda x: x / self.X, - amplitude=constant_amplitude, - amplitude_params=(self.log_amp,), - jitter=0.0, - prefix="gp", - ), - ] - S = assemble(terms, self.ctx, (np.log(self.err), np.log(ell), np.log(self.amp))) - u = self.xdeg() - K = self.amp**2 * Matern(ell, nu=2.5)(u[:, None]) - assert np.allclose(S, self.err**2 * np.eye(len(u)) + K) +def test_chol_logdet_on_a_diagonal(): + L, logdet = chol_logdet(np.diag([1.0, 4.0, 9.0])) + np.testing.assert_allclose(np.diag(L), [1.0, 2.0, 3.0]) + assert logdet == pytest.approx(np.log(36.0)) - def test_Lgpn_angle_growing_amplitude(self): - ell = 0.3 - terms = [ - noise_term(self.log_err), - kernel_term( - Matern(1.0, nu=2.5), - coords=lambda x: x / self.X, - amplitude=exp_growth_amplitude(1.0), - amplitude_params=(self.log_amp, self.log_slope), - jitter=0.0, - ), - ] - S = assemble( + +class TestSegments: + """A spanning term sees the rows of each block it touches, in stack order.""" + + def setup_method(self): + self.x, self.y, self.ym = grid(9, seed=3) + self.offsets = [slice(0, 3), slice(3, 6), slice(6, 9)] + + def capture(self, rows, active=None): + seen = {} + + def fn(c): + seen["segments"], seen["labels"] = c.segments, c.labels + seen["x"] = c.split(c.x) + return np.ones(len(c)) + + terms = [statistical(0.1 * np.ones(9)), Term(fn, kind="mode")] + cov, _ = build( terms, - self.ctx, - (np.log(self.err), np.log(ell), np.log(self.amp), self.slope), - ) - u = self.xdeg() - a = self.amp * np.exp(self.slope * u) - K = np.outer(a, a) * Matern(ell, nu=2.5)(u[:, None]) - assert np.allclose(S, self.err**2 * np.eye(len(u)) + K) - - def test_LKp_kernel_in_momentum_transfer(self): - # b^2 I + s^2 11^T + a(q) a(q') RBF(|q - q'| / l_q), a = A q^(r/2) - log_b, log_s, r_pow = Parameter("log_b"), Parameter("log_s"), Parameter("r") - b, s, lq, r = 0.05, 0.05, 1.2, 0.8 - q = momentum_transfer(SimpleNamespace(k=self.k, x=self.x)) - assert np.allclose(q, 2.0 * self.k * np.sin(self.x / 2)) - terms = [ - noise_term(log_b), - offset_term(parameter=log_s), - kernel_term( - RBF(1.0), - coords=lambda x: 2.0 * self.k * np.sin(x / 2), - amplitude=lambda c, lA, r: np.exp(lA) * c.x ** (r / 2), - amplitude_params=(self.log_amp, r_pow), - jitter=0.0, - prefix="gpq", - ), - ] - S = assemble( - terms, self.ctx, (np.log(b), np.log(s), np.log(lq), np.log(self.amp), r) - ) - a = self.amp * q ** (r / 2) - K = np.outer(a, a) * RBF(lq)(q[:, None]) - ref = b**2 * np.eye(len(q)) + s**2 * np.ones((len(q), len(q))) + K - assert np.allclose(S, ref) - - def test_custom_term_direct(self): - # anything the factories cannot say is a one-line Term - e, l = Parameter("e"), Parameter("l") - t = Term( - lambda c, e, l: np.exp(e) * np.exp(l * c.x / np.pi), (e, l), kind="diag" + self.x, + self.y, + self.offsets, + active=active, + rows=[np.arange(9), rows], + labels=["L0", "L1", "L2"], ) - S = assemble([t], self.ctx, (np.log(self.err), self.slope)) - sigma = self.err * np.exp(self.slope * self.xdeg()) - assert np.allclose(S, np.diag(sigma**2)) + cov.matrix(self.ym, np.zeros(0)) + return seen + + def test_whole_stack(self): + seen = self.capture(np.arange(9)) + assert seen["segments"] == (slice(0, 3), slice(3, 6), slice(6, 9)) + assert seen["labels"] == ("L0", "L1", "L2") + np.testing.assert_array_equal(seen["x"][1], self.x[3:6]) + + def test_partial_support_skips_untouched_blocks(self): + # blocks 0 and 2 only: the support is 6 rows in two segments + seen = self.capture(np.r_[0:3, 6:9]) + assert seen["segments"] == (slice(0, 3), slice(3, 6)) + assert seen["labels"] == ("L0", "L2") + np.testing.assert_array_equal(seen["x"][1], self.x[6:9]) + + def test_masked_rows_stay_in_the_segment_view(self): + # fn sees every row of its support (masking selects after evaluation), + # so the segments describe the unmasked support + seen = self.capture(np.arange(9), active=np.r_[0:2, 3:9]) + assert seen["segments"] == (slice(0, 3), slice(3, 6), slice(6, 9)) diff --git a/test/test_data.py b/test/test_data.py new file mode 100644 index 0000000..51678a4 --- /dev/null +++ b/test/test_data.py @@ -0,0 +1,58 @@ +"""Validation and identity semantics of :class:`rxmc.Dataset`.""" + +import numpy as np +import pytest + +from rxmc import Dataset + + +def test_arrays_coerced_and_validated(): + d = Dataset([0, 1, 2], [1, 2, 3], [0.1, 0.2, 0.3]) + assert d.n == 3 + assert d.y.dtype == float and d.y_err.dtype == float + assert d.x.shape == (3,) + with pytest.raises(ValueError, match="y_err must have shape"): + Dataset([0, 1, 2], [1, 2, 3], [0.1, 0.2]) + with pytest.raises(ValueError, match="first dimension"): + Dataset([0, 1], [1, 2, 3], [0.1, 0.2, 0.3]) + with pytest.raises(ValueError, match="1-D"): + Dataset([0, 1], [[1, 2]], [0.1]) + with pytest.raises(ValueError, match="non-negative"): + Dataset([0, 1], [1, 2], [0.1, -0.2]) + + +def test_x_is_opaque(): + x2d = np.array([[0.0, 5.0], [1.0, 5.0], [2.0, 5.0]]) # (theta, E) pairs + d = Dataset(x2d, [1, 2, 3], [0.1, 0.1, 0.1]) + assert d.x.shape == (3, 2) + d = Dataset(np.arange(3), [1, 2, 3], [0.1, 0.1, 0.1]) # an index is fine too + assert d.x.dtype.kind == "i" + + +def test_error_specs(): + d = Dataset([0, 1, 2], [1, 2, 3], [0.1, 0.1, 0.1]) + assert d.norm_err is None and d.offset_err is None + d = Dataset([0, 1, 2], [1, 2, 3], [0.1, 0.1, 0.1], norm_err=np.array(0.05)) + assert d.norm_err == 0.05 and isinstance(d.norm_err, float) + d = Dataset([0, 1, 2], [1, 2, 3], [0.1, 0.1, 0.1], offset_err=[0.01, 0.02, 0.03]) + np.testing.assert_allclose(d.offset_err, [0.01, 0.02, 0.03]) + with pytest.raises(ValueError, match="norm_err"): + Dataset([0, 1, 2], [1, 2, 3], [0.1, 0.1, 0.1], norm_err=[0.05, 0.05]) + for bad in (np.nan, -0.05, [0.01, np.nan, 0.03]): + for name in ("norm_err", "offset_err"): + with pytest.raises(ValueError, match=f"{name} must be finite"): + Dataset([0, 1, 2], [1, 2, 3], [0.1, 0.1, 0.1], **{name: bad}) + + +def test_meta_is_copied(): + meta = {"Elab": 10.0} + d = Dataset([0], [1], [0.1], meta=meta) + meta["Elab"] = 99.0 + assert d.meta["Elab"] == 10.0 + + +def test_identity_and_repr(): + a = Dataset([0], [1], [0.1], label="A") + b = Dataset([0], [1], [0.1], label="A") + assert a != b and len({a, b}) == 2 + assert "A" in repr(a) and "n=1" in repr(a) diff --git a/test/test_diagnostics.py b/test/test_diagnostics.py new file mode 100644 index 0000000..bc8e80e --- /dev/null +++ b/test/test_diagnostics.py @@ -0,0 +1,330 @@ +"""Posterior checks on (problem, samples): draws, coverage, held-out scores.""" + +from unittest.mock import patch + +import jax.numpy as jnp +import numpy as np +import pytest +from scipy import stats +from scipy.special import logsumexp + +from helpers import manual_mvn_loglike +from rxmc import Comparison, Constraint, Dataset, Model, Parameter, Problem, Term +from rxmc.covariance import StructuredCovariance +from rxmc.diagnostics import ( + _psd_factor, + compare_logz, + coverage_curve, + coverage_error, + heldout_log_predictive, + log_posterior_predictive, + logz_summary, + predictive_draws, + sharpness, +) +from rxmc.likelihood import Chi2 +from rxmc.terms import noise +from rxmc.transforms import Transform, log + +X = np.linspace(0.0, 4.0, 5) +Y = 1.0 + 2.0 * X +ERR = np.full(5, 0.3) + + +def poly(order): + """``polynomial(order)`` with wide priors, so problems compile.""" + params = [Parameter(f"a{i}", prior=stats.norm(0, 10)) for i in range(order + 1)] + return Model(lambda x, *a: sum(ai * x**i for i, ai in enumerate(a)), params) + + +def line_problem(terms=(), masks=None, **kw): + d = Dataset(X, Y, ERR, label="d") + c = Constraint([Comparison(d, poly(1))], terms=terms, masks=masks, **kw) + return Problem([c]), c + + +class TestPredictiveDraws: + def test_draw_covariance_recovers_sigma(self): + p, _ = line_problem([noise(Parameter("log_eps", prior=stats.norm(-2, 1)))]) + row = np.array([1.0, 2.0, np.log(0.4)]) + draws = predictive_draws(p, row, n_rep=40000, rng=0, return_draws=True) + assert draws.shape == (40000, 5) + np.testing.assert_allclose(draws.mean(axis=0), Y, atol=0.02) + np.testing.assert_allclose(np.cov(draws.T), np.diag(ERR**2 + 0.16), atol=0.02) + + def test_terms_select_part_of_the_error_model(self): + """Model plus discrepancy and model plus everything are different objects.""" + eps = noise(Parameter("log_eps", prior=stats.norm(-2, 1))) + p, _ = line_problem([eps]) + row = np.array([1.0, 2.0, np.log(0.4)]) + c = p.constraints[0] + np.testing.assert_allclose(c.matrix(row), np.diag(ERR**2 + 0.16)) + np.testing.assert_allclose( + c.matrix(row, terms=[eps], statistical=False), np.diag(np.full(5, 0.16)) + ) + np.testing.assert_allclose(c.matrix(row, terms=[]), np.diag(ERR**2)) + draws = predictive_draws( + p, + row, + terms=[eps], + statistical=False, + n_rep=40000, + rng=0, + return_draws=True, + ) + np.testing.assert_allclose( + np.cov(draws.T), np.diag(np.full(5, 0.16)), atol=0.02 + ) + with pytest.raises(ValueError, match="not a term of this constraint"): + c.matrix(row, terms=[noise(Parameter("other", prior=stats.norm(0, 1)))]) + with pytest.raises(ValueError, match="cannot be combined with a term"): + predictive_draws(p, row, statistical=False, given=p, return_draws=True) + + def test_model_only_returns_ym_and_assembles_nothing(self): + p, _ = line_problem() + with patch.object(StructuredCovariance, "matrix") as m: + d = predictive_draws( + p, [[1.0, 2.0], [0.0, 1.0]], model_only=True, return_draws=True + ) + m.assert_not_called() + np.testing.assert_allclose(d[0], Y) + np.testing.assert_allclose(d[1], X) + + def test_one_row_masks_and_width_check(self): + p, _ = line_problem(masks=[np.array([True, False, True, False, True])]) + d = predictive_draws(p, [1.0, 2.0], n_rep=3, rng=1, return_draws=True) + assert d.shape == (3, 3) + with pytest.raises(ValueError, match=r"\(n, 2\)"): + predictive_draws(p, [[1.0, 2.0, 3.0]], return_draws=True) + + def test_physical_maps_back_through_the_space(self): + eps = noise(Parameter("log_eps", prior=stats.norm(-2, 1))) + d = Dataset(X, Y, ERR, label="d") + p = Problem([Constraint([Comparison(d, poly(1), space=log)], terms=[eps])]) + rows = np.tile([1.0, 2.0, np.log(0.1)], (6, 1)) + for kw in (dict(n_rep=3), dict(model_only=True)): + draws = predictive_draws(p, rows, rng=2, return_draws=True, **kw) + back = predictive_draws( + p, rows, rng=2, return_draws=True, physical=True, **kw + ) + assert isinstance(back, np.ndarray) + np.testing.assert_allclose(back, np.exp(draws)) + np.testing.assert_allclose( + predictive_draws(p, rows, rng=2, physical=True, **kw), + np.percentile(np.exp(draws), (16, 50, 84), axis=0), + ) + + def test_physical_needs_one_space(self): + a, b = Dataset(X, Y, ERR, label="a"), Dataset(X, Y, ERR, label="b") + model = poly(1) + mixed = Constraint([Comparison(a, model, space=log), Comparison(b, model)]) + with pytest.raises(ValueError, match="share one comparison space"): + predictive_draws(Problem([mixed]), [1.0, 2.0], physical=True) + # a comparison masked out entirely does not count + only_log = mixed.masked([np.ones(5, bool), np.zeros(5, bool)]) + band = predictive_draws(Problem([only_log]), [1.0, 2.0], physical=True) + assert band.shape == (3, 5) + + def test_physical_needs_an_inverse(self): + d = Dataset(X, Y, ERR, label="d") + sqrt = Transform(jnp.sqrt, name="sqrt") + p = Problem([Constraint([Comparison(d, poly(1), space=sqrt)])]) + with pytest.raises(ValueError, match="'sqrt' has no inverse"): + predictive_draws(p, [1.0, 2.0], physical=True) + + def test_fallback_factor_is_triangular(self): + S = np.array([[1.0, 1.0001], [1.0001, 1.0]]) # indefinite: both Choleskys fail + L = _psd_factor(S) + w, V = np.linalg.eigh(S) + assert np.all(np.isfinite(L)) and np.allclose(L, np.tril(L)) + assert np.all(np.diag(L) >= 0) + np.testing.assert_allclose(L @ L.T, (V * np.clip(w, 0, None)) @ V.T, atol=1e-12) + + def test_tiny_variances_not_inflated(self): + d = Dataset(X, Y, np.full(5, 1e-9), label="tiny") + p = Problem([Constraint([Comparison(d, poly(1))])]) + draws = predictive_draws(p, [1.0, 2.0], n_rep=2000, rng=3, return_draws=True) + assert np.all(draws.std(axis=0) < 1e-8) + + +class TestCoverageSharpness: + def test_coverage_near_nominal_for_matching_draws(self): + rng = np.random.default_rng(0) + draws = rng.normal(0.0, 1.0, (4000, 2000)) + y = rng.normal(0.0, 1.0, 2000) + levels = np.array([0.5, 0.9]) + np.testing.assert_allclose(coverage_curve(draws, y, levels), levels, atol=0.03) + assert coverage_error(draws, y, levels) < 0.03 + assert np.all(coverage_curve(0.3 * draws, y, levels) < levels - 0.2) + + def test_sharpness_width(self): + rng = np.random.default_rng(0) + draws = rng.normal(0.0, 1.0, (20000, 3)) + np.testing.assert_allclose(sharpness(draws), 2 * 0.9945, atol=0.05) + np.testing.assert_allclose(sharpness(np.zeros((10, 2)), transform=np.exp), 0.0) + np.testing.assert_allclose( + sharpness(draws, percentiles=(2.5, 97.5)), 2 * 1.96, atol=0.15 + ) + + +class TestHeldout: + def setup_method(self): + d = Dataset( + np.array([1.0, 2.0, 3.0, 4.0]), + np.array([3.1, 4.8, 7.2, 9.1]), + np.array([0.2, 0.2, 0.3, 0.3]), + label="d", + ) + self.d = d + self.model = poly(1) + + def problems(self, terms, cut=2.5): + c = Constraint([Comparison(self.d, self.model)], terms=terms) + fit = c.masked_where(lambda x: x < cut) + return Problem([fit]), Problem([fit.complement()]), Problem([c]) + + def test_marginal_matches_manual_and_partitions_without_a_spanning_term(self): + fit, held, full = self.problems([Term(0.1 * np.ones(4), kind="diag")]) + samples = np.array([[1.0, 2.0], [1.2, 1.9]]) + lp = heldout_log_predictive(held, samples) + for i, (a0, a1) in enumerate(samples): + ym = a0 + a1 * self.d.x[2:] + cov = np.diag(self.d.y_err[2:] ** 2 + 0.01) + assert lp[i] == pytest.approx(manual_mvn_loglike(self.d.y[2:], ym, cov)) + np.testing.assert_allclose( + lp + [fit.log_likelihood(s) for s in samples], + [full.log_likelihood(s) for s in samples], + ) + # the conditional equals the marginal when nothing spans the split + np.testing.assert_allclose(heldout_log_predictive(held, samples, given=fit), lp) + np.testing.assert_allclose( + predictive_draws( + held, samples, given=fit, model_only=True, return_draws=True + ), + predictive_draws(held, samples, model_only=True, return_draws=True), + ) + + def test_conditional_under_a_spanning_matrix_term(self): + rng = np.random.default_rng(5) + A = rng.normal(size=(4, 4)) + K = A @ A.T / 4 # couples every point with every other + fit, held, full = self.problems([Term(K, kind="matrix")]) + theta = np.array([1.0, 2.0]) + S = np.diag(self.d.y_err**2) + K + ym = theta[0] + theta[1] * self.d.x + F, H = slice(0, 2), slice(2, 4) + r = self.d.y[F] - ym[F] + mean = ym[H] + S[H, F] @ np.linalg.solve(S[F, F], r) + cov = S[H, H] - S[H, F] @ np.linalg.solve(S[F, F], S[F, H]) + lp = heldout_log_predictive(held, theta, given=fit) + assert lp[0] == pytest.approx(manual_mvn_loglike(self.d.y[H], mean, cov)) + # and it is not the marginal + assert lp[0] != pytest.approx(heldout_log_predictive(held, theta)[0]) + draws = predictive_draws( + held, theta, n_rep=40000, rng=0, given=fit, return_draws=True + ) + np.testing.assert_allclose(draws.mean(axis=0), mean, atol=0.02) + np.testing.assert_allclose(np.cov(draws.T), cov, atol=0.03) + # the conditional is exactly the joint over the full data divided by the fit + joint = full.log_likelihood(theta) - fit.log_likelihood(theta) + assert lp[0] == pytest.approx(joint) + + def test_conditional_reads_the_columns_of_every_constraint(self): + # two constraints with a parameter each: the second's conditional must + # read b's column, not the first one + rng = np.random.default_rng(5) + A = rng.normal(size=(4, 4)) + K = A @ A.T / 4 + cs = [] + for s, label in ((1.0, "d1"), (3.0, "d2")): + d = Dataset(self.d.x, s * self.d.y, self.d.y_err, label=label) + p = Parameter(f"s{label}", prior=stats.norm(0, 10)) + m = Model(lambda x, s: s * x, [p]) + cs.append(Constraint([Comparison(d, m)], terms=[Term(K, kind="matrix")])) + fits = [c.masked_where(lambda x: x < 2.5) for c in cs] + fit, held = Problem(fits), Problem([f.complement() for f in fits]) + full = Problem(cs) + theta = np.array([1.0, 3.0]) + lp = heldout_log_predictive(held, theta, given=fit) + assert lp[0] == pytest.approx( + full.log_likelihood(theta) - fit.log_likelihood(theta) + ) + S = np.diag(self.d.y_err**2) + K + ym = theta[1] * self.d.x + F, H = slice(0, 2), slice(2, 4) + mean = ym[H] + S[H, F] @ np.linalg.solve(S[F, F], 3.0 * self.d.y[F] - ym[F]) + draws = predictive_draws( + held, theta, constraint=1, given=fit, model_only=True, return_draws=True + ) + np.testing.assert_allclose(draws[0], mean) + + def test_given_needs_no_marginal_priors_and_keeps_doubly_masked_rows_out(self): + # the coefficients have only a joint prior, and a y = 0 point (not + # finite in log space) is masked out of both the fit and the held-out view + a0, a1 = Parameter("a0"), Parameter("a1") + model = Model(lambda x, a0, a1: jnp.exp(a0 + a1 * x), [a0, a1]) + d = Dataset(np.arange(5.0), [0.0, 2.0, 3.0, 5.0, 8.0], np.full(5, 0.2)) + K = 0.05 * np.exp(-0.5 * np.subtract.outer(d.x, d.x) ** 2) + c = Constraint([Comparison(d, model, space=log)], terms=[Term(K)]) + prior = [([a0, a1], stats.multivariate_normal(np.zeros(2), 4 * np.eye(2)))] + fit = c.masked([np.array([False, True, True, False, False])]) + held = c.masked([np.array([False, False, False, True, True])]) + both = c.masked([np.array([False, True, True, True, True])]) + p_fit, p_held = Problem([fit], priors=prior), Problem([held], priors=prior) + p_both = Problem([both], priors=prior) + theta = np.array([0.5, 0.4]) + lp = heldout_log_predictive(p_held, theta, given=p_fit) + assert lp[0] == pytest.approx( + p_both.log_likelihood(theta) - p_fit.log_likelihood(theta) + ) + + def test_given_is_validated(self): + fit, held, full = self.problems([]) + with pytest.raises(ValueError, match="overlap"): + heldout_log_predictive(fit, [1.0, 2.0], given=fit) + other = Problem([Constraint([Comparison(self.d, poly(1))])]) + with pytest.raises(ValueError, match="same comparison objects"): + heldout_log_predictive(held, [1.0, 2.0], given=other) + c = Constraint( + [Comparison(self.d, self.model)], likelihood=Chi2() + ).masked_where(lambda x: x < 2.5) + fit_c, held_c = Problem([c]), Problem([c.complement()]) + with pytest.raises(ValueError, match="Chi2"): + heldout_log_predictive(held_c, [1.0, 2.0], given=fit_c) + + def test_log_posterior_predictive(self): + lp = np.array([-1.0, -2.0, -0.5]) + assert log_posterior_predictive(lp) == pytest.approx(logsumexp(lp) - np.log(3)) + logw = np.array([0.0, -np.inf, 0.0]) + assert log_posterior_predictive(lp, logw) == pytest.approx( + logsumexp(lp[[0, 2]]) - np.log(2) + ) + + +class TestLogZ: + def test_summary_single_and_replicates(self): + assert logz_summary([-10.0], [0.3]) == (-10.0, 0.3, 1) + assert logz_summary([-10.0, -12.0], [0.3, 0.3]) == (-11.0, 1.0, 2) + assert logz_summary([-10.0, -10.2], [0.5, 0.5])[1] == pytest.approx(0.5) + + def test_compare_ties_at_the_boundary_and_rejects_nan(self): + assert compare_logz((1.0, 0.0), (1.0, 0.0))["verdict"] == "tie" + assert compare_logz((1.0, 0.5), (0.0, 0.0), sigma=2.0)["verdict"] == "tie" + with pytest.raises(ValueError, match="finite"): + compare_logz((np.nan, 0.1), (0.0, 0.1)) + with pytest.raises(ValueError, match="finite"): + logz_summary([1.0, 2.0], [0.1, np.nan]) + + def test_compare(self): + r = compare_logz((-10.0, 0.5), (-15.0, 0.5)) + assert r["verdict"] == "a" and r["dlogZ"] == pytest.approx(5.0) + assert r["err"] == pytest.approx(np.hypot(0.5, 0.5)) + assert compare_logz((-15.0, 0.5), (-10.0, 0.5))["verdict"] == "b" + assert compare_logz((-10.0, 1.0), (-11.0, 1.0))["verdict"] == "tie" + + def test_log_jacobian_lives_on_the_problem(self): + y = np.array([2.0, 3.0]) + d = Dataset(np.array([0.0, 1.0]), y, np.ones(2), label="d") + p = Problem([Constraint([Comparison(d, poly(0), space=log)])]) + assert p.log_jacobian() == pytest.approx(-np.sum(np.log(y))) + assert stats.norm(0, 1).cdf(0) == 0.5 diff --git a/test/test_evidence.py b/test/test_evidence.py deleted file mode 100644 index 989c50a..0000000 --- a/test/test_evidence.py +++ /dev/null @@ -1,135 +0,0 @@ -import unittest - -import numpy as np - -from rxmc.constraint import Constraint -from rxmc.covariance import model_error_term -from rxmc.evidence import Evidence -from rxmc.observation import Observation -from rxmc.params import Parameter -from rxmc.physical_model import Polynomial - - -class TestEvidence(unittest.TestCase): - - def setUp(self): - y = np.array([1.0, 2.0, 3.0]) - x = np.array([1.0, 2.0, 3.0]) - y_stat_err = np.array([0.1, 0.2, 0.3]) - self.y = y - self.y_stat_err = y_stat_err - self.observations = [Observation(x=x, y=y, y_stat_err=y_stat_err)] - self.pm = Polynomial(order=1) - self.constraints = [ - Constraint(observations=self.observations, physical_model=self.pm) - for _ in range(4) - ] - self.weights = np.array([1.0, 1.0, 1.0, 1.0]) - self.evidence = Evidence(constraints=self.constraints, weights=self.weights) - - self.model_params = (3.0, 5.0) - modely = self.pm.evaluate(self.observations[0], *self.model_params) - delta = y - modely - chi2 = np.sum((delta / y_stat_err) ** 2) - N = self.observations[0].n_data_pts - log_det = np.sum(np.log(y_stat_err**2)) - logl_single = -0.5 * (N * np.log(2 * np.pi) + log_det + chi2) - self.expected_loglikelihood = 4 * logl_single - - def test_serial_execution(self): - log_likelihood = self.evidence.log_likelihood(model_params=self.model_params) - self.assertAlmostEqual(log_likelihood, self.expected_loglikelihood) - - def test_no_parametric_constraints_detected(self): - self.assertEqual(len(self.evidence.parametric_constraints), 0) - self.assertEqual(self.evidence.n_params, self.pm.n_params) - - def test_parametric_constraint_auto_detected(self): - gamma = Parameter("log gamma") - parametric = Constraint( - observations=self.observations, - physical_model=self.pm, - extra_terms=[model_error_term(gamma, support=np.arange(3))], - ) - evidence = Evidence(constraints=[self.constraints[0], parametric]) - self.assertEqual(len(evidence.parametric_constraints), 1) - self.assertIs(evidence.parametric_constraints[0], parametric) - self.assertEqual(evidence.n_params, self.pm.n_params + 1) - - def test_parametric_constraint_receives_its_params(self): - gamma = Parameter("log gamma") - parametric = Constraint( - observations=self.observations, - physical_model=self.pm, - extra_terms=[model_error_term(gamma, support=np.arange(3))], - ) - evidence = Evidence(constraints=[parametric]) - # one tuple per parametric constraint - ll = evidence.log_likelihood(self.model_params, [(np.log(0.1),)]) - # directly via the constraint - ll_direct = parametric.log_likelihood(self.model_params, (np.log(0.1),)) - self.assertAlmostEqual(ll, ll_direct) - - def test_wrong_cov_params_length_raises(self): - gamma = Parameter("log gamma") - parametric = Constraint( - observations=self.observations, - physical_model=self.pm, - extra_terms=[model_error_term(gamma, support=np.arange(3))], - ) - evidence = Evidence(constraints=[parametric]) - with self.assertRaises(ValueError): - evidence.log_likelihood(self.model_params, []) - - -class TestCrossConstraintParameterValidation(unittest.TestCase): - """Covariance/likelihood parameters are constraint-scoped (spec §8).""" - - def setUp(self): - self.pm = Polynomial(order=1) - self.obs = [ - Observation( - x=np.array([1.0, 2.0, 3.0]), - y=np.array([1.0, 2.0, 3.0]), - y_stat_err=np.array([0.1, 0.2, 0.3]), - ) - ] - - def _constraint(self, param): - return Constraint( - observations=self.obs, - physical_model=self.pm, - extra_terms=[model_error_term(param, support=np.arange(3))], - ) - - def test_same_parameter_object_in_two_constraints_raises(self): - gamma = Parameter("log gamma") - c1, c2 = self._constraint(gamma), self._constraint(gamma) - with self.assertRaises(ValueError) as cm: - Evidence(constraints=[c1, c2]) - self.assertIn("same object", str(cm.exception)) - - def test_duplicate_name_across_constraints_raises(self): - c1 = self._constraint(Parameter("log gamma")) - c2 = self._constraint(Parameter("log gamma")) - with self.assertRaises(ValueError) as cm: - Evidence(constraints=[c1, c2]) - self.assertIn("Duplicate parameter name", str(cm.exception)) - - def test_unique_names_accepted(self): - c1 = self._constraint(Parameter("log gamma 1")) - c2 = self._constraint(Parameter("log gamma 2")) - ev = Evidence(constraints=[c1, c2]) - self.assertEqual(ev.n_likelihood_params, 2) - - def test_two_default_student_t_constraints_raise(self): - from rxmc.likelihood_model import StudentT - - c1 = Constraint(self.obs, self.pm, likelihood=StudentT()) - c2 = Constraint(self.obs, self.pm, likelihood=StudentT()) - with self.assertRaises(ValueError): - Evidence(constraints=[c1, c2]) - - -if __name__ == "__main__": - unittest.main() diff --git a/test/test_likelihood.py b/test/test_likelihood.py new file mode 100644 index 0000000..92eb107 --- /dev/null +++ b/test/test_likelihood.py @@ -0,0 +1,48 @@ +"""The likelihood functionals against their closed forms.""" + +import numpy as np +import pytest + +from helpers import mahalanobis, manual_mvn_loglike +from rxmc.likelihood import Chi2, Gaussian, Likelihood, log_likelihood + + +@pytest.fixture +def stats(): + y = np.array([2.0, 4.0, 7.0]) + ym = np.array([2.5, 4.0, 6.5]) + cov = np.diag([0.1, 0.2, 0.3]) + 0.01 + d2, logdet = mahalanobis(y, ym, cov) + return y, ym, cov, d2, logdet + + +def test_gaussian_matches_manual_mvn(stats): + y, ym, cov, d2, logdet = stats + assert Gaussian().log_likelihood(d2, logdet, 3) == pytest.approx( + manual_mvn_loglike(y, ym, cov) + ) + assert log_likelihood(d2, logdet, 3) == pytest.approx( + manual_mvn_loglike(y, ym, cov) + ) + assert Gaussian().chi2(d2, logdet, 3) == d2 + + +def test_chi2_drops_logdet(stats): + _, _, _, d2, logdet = stats + assert Chi2().log_likelihood(d2, logdet, 3) == pytest.approx(-0.5 * d2) + assert Chi2().chi2(d2, logdet, 3) == d2 + + +def test_mahalanobis_helper_on_diagonal(): + y = np.array([1.0, 2.0, 3.0]) + ym = np.array([1.1, 1.8, 3.2]) + cov = np.diag([0.1, 0.2, 0.3]) + d2, logdet = mahalanobis(y, ym, cov) + assert d2 == pytest.approx(np.sum((y - ym) ** 2 / np.diag(cov))) + assert logdet == pytest.approx(np.log(np.prod(np.diag(cov)))) + + +def test_a_likelihood_has_no_parameters(): + # a functional of (d2, logdet, n) only: nothing for the problem to sample + for like in (Likelihood(), Gaussian(), Chi2()): + assert not hasattr(like, "params") diff --git a/test/test_likelihood_model.py b/test/test_likelihood_model.py deleted file mode 100644 index 2e1aa48..0000000 --- a/test/test_likelihood_model.py +++ /dev/null @@ -1,171 +0,0 @@ -"""Tests for the stacked likelihood functionals and their Term-based covariances.""" - -import unittest - -import numpy as np -from scipy.special import gammaln - -from helpers import manual_mvn_loglike -from rxmc.constraint import Constraint -from rxmc.covariance import ( - Term, - model_error_term, - noise_fraction_term, - noise_term, - normalization_term, -) -from rxmc.likelihood_model import ( - Chi2, - StudentT, - mahalanobis_distance_sqr_cholesky, -) -from rxmc.observation import Observation -from rxmc.params import Parameter -from rxmc.physical_model import Polynomial - - -class LikelihoodTestBase(unittest.TestCase): - def setUp(self): - self.x = np.array([1.0, 2.0, 3.0]) - self.y = np.array([2.0, 4.0, 7.0]) - self.stat = np.array([0.1, 0.2, 0.3]) - self.obs = Observation(self.x, self.y, y_stat_err=self.stat) - self.pm = Polynomial(order=1) - self.model_params = (1.0, 1.5) - self.ym = self.pm.evaluate(self.obs, *self.model_params) - - -class TestGaussianStatisticalOnly(LikelihoodTestBase): - def test_matches_manual_mvn(self): - c = Constraint([self.obs], self.pm) - cov = np.diag(self.stat**2) - expected = manual_mvn_loglike(self.y, self.ym, cov) - self.assertAlmostEqual(c.log_likelihood(self.model_params), expected) - - def test_constraint_is_non_parametric(self): - c = Constraint([self.obs], self.pm) - self.assertEqual(c.n_params, 0) - self.assertTrue(c.covariance.block_diagonal) - - -class TestUnknownNoise(LikelihoodTestBase): - def test_constant_noise(self): - eps = 0.05 - p = Parameter("log eps") - c = Constraint( - [self.obs], self.pm, extra_terms=[noise_term(p, support=np.arange(3))] - ) - cov = np.diag(self.stat**2) + np.diag(np.full(3, eps**2)) - expected = manual_mvn_loglike(self.y, self.ym, cov) - self.assertEqual(c.n_params, 1) - self.assertAlmostEqual( - c.log_likelihood(self.model_params, (np.log(eps),)), expected - ) - - def test_noise_fraction(self): - eps = 0.05 - p = Parameter("log eps") - c = Constraint( - [self.obs], - self.pm, - extra_terms=[noise_fraction_term(p, support=np.arange(3))], - ) - cov = np.diag(self.stat**2) + np.diag((eps * self.ym) ** 2) - expected = manual_mvn_loglike(self.y, self.ym, cov) - self.assertAlmostEqual( - c.log_likelihood(self.model_params, (np.log(eps),)), expected - ) - - -class TestUnknownNormalizationError(LikelihoodTestBase): - def test_eta(self): - eta = 0.07 - p = Parameter("log eta") - c = Constraint( - [self.obs], - self.pm, - extra_terms=[normalization_term(parameter=p, support=np.arange(3))], - ) - cov = np.diag(self.stat**2) + eta**2 * np.outer(self.ym, self.ym) - expected = manual_mvn_loglike(self.y, self.ym, cov) - self.assertAlmostEqual( - c.log_likelihood(self.model_params, (np.log(eta),)), expected - ) - - -class TestUnknownModelError(LikelihoodTestBase): - def test_averaging(self): - gamma = 0.1 - p = Parameter("log gamma") - c = Constraint( - [self.obs], - self.pm, - extra_terms=[model_error_term(p, averaging=True, support=np.arange(3))], - ) - z = 0.5 * (self.y + self.ym) - cov = np.diag(self.stat**2) + np.diag((gamma * z) ** 2) - expected = manual_mvn_loglike(self.y, self.ym, cov) - self.assertAlmostEqual( - c.log_likelihood(self.model_params, (np.log(gamma),)), expected - ) - - -class TestFixedCovariance(LikelihoodTestBase): - def test_dense_term_fixed_full_covariance(self): - cov = np.array([[0.04, 0.01, 0.0], [0.01, 0.09, 0.02], [0.0, 0.02, 0.16]]) - obs = Observation(self.x, self.y) # no stat err -> zeros - c = Constraint([obs], self.pm, extra_terms=[Term(cov, support=np.arange(3))]) - self.assertTrue(c.covariance.is_constant) - expected = manual_mvn_loglike(self.y, self.ym, cov) - self.assertAlmostEqual(c.log_likelihood(self.model_params), expected) - - def test_cholesky_cached(self): - cov = np.diag([0.04, 0.09, 0.16]) - obs = Observation(self.x, self.y) - c = Constraint([obs], self.pm, extra_terms=[Term(cov, support=np.arange(3))]) - L1, _ = c.covariance.cholesky(None) - L2, _ = c.covariance.cholesky(None) - self.assertIs(L1, L2) - - -class TestStudentT(LikelihoodTestBase): - def test_student_t_value(self): - nu = 5.0 - c = Constraint([self.obs], self.pm, likelihood=StudentT()) - self.assertEqual(c.n_params, 1) - self.assertEqual(c.params[0].name, "degrees_of_freedom") - ll = c.log_likelihood(self.model_params, (nu,)) - - cov = np.diag(self.stat**2) - d2, logdet = mahalanobis_distance_sqr_cholesky(self.y, self.ym, cov) - n = 3 - expected = ( - gammaln((n + nu) / 2) - - gammaln(nu / 2) - - 0.5 * n * np.log(np.pi * nu) - - 0.5 * logdet - - 0.5 * (nu + n) * np.log1p(d2 / nu) - ) - self.assertAlmostEqual(ll, expected) - - -class TestChi2(LikelihoodTestBase): - def test_chi2_drops_logdet(self): - c = Constraint([self.obs], self.pm, likelihood=Chi2()) - cov = np.diag(self.stat**2) - d2, _ = mahalanobis_distance_sqr_cholesky(self.y, self.ym, cov) - self.assertAlmostEqual(c.log_likelihood(self.model_params), -0.5 * d2) - - -class TestMahalanobisDistanceCholesky(unittest.TestCase): - def test_diagonal(self): - y = np.array([1.0, 2.0, 3.0]) - ym = np.array([1.1, 1.8, 3.2]) - cov = np.diag([0.1, 0.2, 0.3]) - d2, logdet = mahalanobis_distance_sqr_cholesky(y, ym, cov) - self.assertAlmostEqual(d2, np.sum((y - ym) ** 2 / np.diag(cov))) - self.assertAlmostEqual(logdet, np.log(np.prod(np.diag(cov)))) - - -if __name__ == "__main__": - unittest.main() diff --git a/test/test_measurement.py b/test/test_measurement.py new file mode 100644 index 0000000..656dcf5 --- /dev/null +++ b/test/test_measurement.py @@ -0,0 +1,187 @@ +"""from_measurement: EXFOR measurements to datasets in internal units. + +No solver is touched: the Rutherford conversion is a closed form of the +kinematics, so a real ``jitr`` reaction is cheap here. +""" + +from types import SimpleNamespace + +import jitr +import numpy as np +import pytest +from scipy import stats + +from helpers import assemble_dense +from rxmc import Comparison, Model, Parameter, from_measurement +from rxmc.reactions import rutherford +from rxmc.terms import statistical +from rxmc.transforms import log + +P_CA = jitr.reactions.ElasticReaction(target=(40, 20), projectile=(1, 1)) +N_CA = jitr.reactions.ElasticReaction(target=(40, 20), projectile=(1, 0)) + + +def measurement(**overrides): + """A minimal ``exfor_tools``-like Distribution stub.""" + fields = dict( + x=np.array([20.0, 40.0]), + y=np.array([2.0, 1.0]), + Einc=8.0, + quantity="dXS/dA", + y_units="barns/ster", + statistical_err=np.array([0.2, 0.1]), + systematic_norm_err=0.03, + systematic_offset_err=0.02, + subentry="subentry", + ) + fields.update(overrides) + return SimpleNamespace(**fields) + + +def test_construction_in_internal_units(): + m = measurement(subentry="E1234-002") + d = from_measurement(m, reaction=P_CA) + np.testing.assert_allclose(d.x, np.deg2rad(m.x)) + np.testing.assert_allclose(d.y, m.y) + np.testing.assert_allclose(d.y_err, m.statistical_err) + assert d.label == "E1234-002" + assert d.norm_err == 0.03 and d.offset_err == pytest.approx(0.02) + kin = P_CA.kinematics(8.0) + assert d.meta["reaction"] is P_CA and d.meta["Elab"] == 8.0 + assert d.meta["quantity"] == "dXS/dA" and d.meta["subentry"] == "E1234-002" + assert d.meta["k"] == pytest.approx(kin.k) and d.meta["eta"] == pytest.approx( + kin.eta + ) + + +def test_a_dict_is_a_measurement(): + fields = vars(measurement(subentry="E1234-002")) + from_dict = from_measurement(dict(fields), reaction=P_CA) + from_object = from_measurement(measurement(subentry="E1234-002"), reaction=P_CA) + np.testing.assert_allclose(from_dict.x, from_object.x) + np.testing.assert_allclose(from_dict.y, from_object.y) + np.testing.assert_allclose(from_dict.y_err, from_object.y_err) + assert from_dict.label == from_object.label + assert from_dict.norm_err == from_object.norm_err + + +def test_a_missing_field_is_named(): + fields = vars(measurement()) + del fields["Einc"] + with pytest.raises(ValueError, match="Einc"): + from_measurement(fields) + with pytest.raises(ValueError, match="Einc"): + from_measurement(SimpleNamespace(**fields)) + + +def test_lab_frame_angles_are_refused(): + with pytest.raises(ValueError, match="LAB frame"): + from_measurement(measurement(x_units="LAB-degrees"), reaction=P_CA) + d = from_measurement(measurement(x_units="CM-degrees"), reaction=P_CA) + np.testing.assert_allclose(d.x, np.deg2rad([20.0, 40.0])) + + +def test_exfor_tools_labels_and_millibarns(): + for label in ("barns/ster", "b/Sr", "MB/SR", "mb/sr"): + d = from_measurement(measurement(y_units=label), reaction=P_CA) + expected = ( + 1.0 if "b" in label.lower()[:1] and "m" not in label.lower() else 1e-3 + ) + np.testing.assert_allclose(d.y, expected * measurement().y) + + +def test_ratio_from_absolute_uses_the_per_angle_rutherford_norm(): + m = measurement( + y=np.array([1800.0, 300.0]), + y_units="mb/sr", + statistical_err=np.array([20.0, 10.0]), + systematic_offset_err=5.0, # mb/sr + ) + d = from_measurement(m, reaction=P_CA, quantity="dXS/dRuth") + ruth_b = rutherford(P_CA.kinematics(8.0), np.deg2rad(m.x)) / 1000.0 + norm = 1e-3 / ruth_b + np.testing.assert_allclose(d.y, m.y * norm) + np.testing.assert_allclose(d.y_err, m.statistical_err * norm) + np.testing.assert_allclose(d.offset_err, 5.0 * norm) # a per-angle array now + assert d.norm_err == 0.03 # fractional: untouched + assert d.meta["quantity"] == "dXS/dRuth" + # regression: the reported terms plus the statistical diagonal recover the + # old auto-folded covariance, in internal (normalised) units + comp = Comparison(d, Model(lambda x, c: c * np.ones_like(x), [Parameter("c")])) + ym = np.array([0.9, 0.6]) + S = assemble_dense( + [statistical(comp.y_err), *comp.reported_terms()], d.x, comp.y, ym + ) + omega = 5.0 * norm + old = ( + np.diag((m.statistical_err * norm) ** 2) + + np.outer(omega, omega) + + 0.03**2 * np.outer(ym, ym) + ) + np.testing.assert_allclose(S, old) + + +def test_absolute_from_ratio(): + m = measurement(y=np.array([0.9, 0.6]), quantity="dXS/dRuth", y_units="no-dim") + d = from_measurement(m, reaction=P_CA, quantity="dXS/dA") + ruth_b = rutherford(P_CA.kinematics(8.0), np.deg2rad(m.x)) / 1000.0 + np.testing.assert_allclose(d.y, m.y * ruth_b) + np.testing.assert_allclose(d.y_err, m.statistical_err * ruth_b) + + +def test_errors_are_named(): + with pytest.raises(ValueError, match="unknown unit label 'MeV'"): + from_measurement(measurement(y_units="MeV")) + with pytest.raises(ValueError, match="needs differential units"): + from_measurement(measurement(y_units="no-dim")) + with pytest.raises(ValueError, match="needs dimensionless units"): + from_measurement(measurement(quantity="Ay", y_units="mb/sr")) + with pytest.raises(ValueError, match="cannot convert"): + from_measurement(measurement(), quantity="Ay") + with pytest.raises(ValueError, match="pass reaction="): + from_measurement(measurement(), quantity="dXS/dRuth") + with pytest.raises(ValueError, match="charged projectile"): + from_measurement(measurement(), reaction=N_CA, quantity="dXS/dRuth") + with pytest.raises(ValueError, match="unknown quantity"): + from_measurement(measurement(quantity="sigma")) + + +def test_no_reaction_and_no_errors(): + m = measurement( + statistical_err=None, + systematic_norm_err=None, + systematic_offset_err=None, + subentry=None, + ) + d = from_measurement(m) + assert "reaction" not in d.meta and d.label == "" + np.testing.assert_allclose(d.y_err, 0.0) + assert d.norm_err is None and d.offset_err is None + + +def test_log_space_and_ias_channel(): + d = from_measurement(measurement(), reaction=P_CA) + comp = Comparison( + d, Model(lambda x, c: c * np.ones_like(x), [Parameter("c")]), space=log + ) + np.testing.assert_allclose(comp.y, np.log(d.y)) + pn = jitr.reactions.Reaction( + target=(48, 20), projectile=(1, 1), product=(1, 0), residual=(48, 21) + ) + m = measurement( + x=np.array([5.0, 15.0]), + y=np.array([900.0, 700.0]), + Einc=18.0, + y_units="mb/sr", + statistical_err=np.array([80.0, 70.0]), + systematic_norm_err=0.02, + systematic_offset_err=10.0, + ) + d = from_measurement(m, reaction=pn, ExIAS=4.5) + np.testing.assert_allclose(d.y, [0.9, 0.7]) + np.testing.assert_allclose(d.y_err, [0.08, 0.07]) + assert d.offset_err == pytest.approx(0.01) and d.norm_err == 0.02 + assert d.meta["ExIAS"] == 4.5 and d.meta["Elab"] == 18.0 + assert ( + stats.norm(0, 1).cdf(0) == 0.5 + ) # keep scipy imported for the recipe-style spelling diff --git a/test/test_model.py b/test/test_model.py new file mode 100644 index 0000000..7b35e43 --- /dev/null +++ b/test/test_model.py @@ -0,0 +1,111 @@ +"""Models, predictors and their composition.""" + +import numpy as np +import pytest + +from rxmc import Model, Parameter, polynomial +from rxmc.model import Predictor +from rxmc.transforms import Transform, scale + +x = np.linspace(0.0, 2.0, 5) +m, b = Parameter("m"), Parameter("b") +line = Model(lambda x, m, b: m * x + b, [m, b]) + + +def test_generic_model_binds_to_x(): + pred = line.bind(x) + assert isinstance(pred, Predictor) + assert pred.params == (m, b) + np.testing.assert_allclose(pred(2.0, 1.0), 2.0 * x + 1.0) + with pytest.raises(ValueError, match="expects 2 value"): + pred(2.0) + with pytest.raises(TypeError, match="Parameter"): + Model(lambda x, a: a * x, ["a"]) + + +def test_polynomial(): + poly = polynomial(2) + assert [p.name for p in poly.params] == ["a0", "a1", "a2"] + np.testing.assert_allclose( + poly.bind(x)(1.0, 2.0, 3.0), np.polyval([3.0, 2.0, 1.0], x) + ) + + +def test_scale_transform_appends_and_scales_after(): + rho = Parameter("log_rho") + scaled = line | scale(rho) + assert scaled.params == (m, b, rho) + np.testing.assert_allclose( + scaled.bind(x)(2.0, 1.0, np.log(3.0)), 3.0 * (2.0 * x + 1.0) + ) + + +def test_two_parameter_transform_in_order(): + c, d = Parameter("c"), Parameter("d") + t = Transform(lambda a, c, d: c * a + d, (c, d)) + model = line | t + assert model.params == (m, b, c, d) + np.testing.assert_allclose(model.bind(x)(1.0, 0.0, 2.0, 5.0), 2.0 * x + 5.0) + + +def test_add_and_mul_compose_on_the_bound_grid(): + c0 = Parameter("c0") + delta = Model(lambda x, c0: c0 * x**2, [c0]) + both = line + delta + assert both.params == (m, b, c0) + np.testing.assert_allclose(both.bind(x)(1.0, 1.0, 0.5), x + 1.0 + 0.5 * x**2) + prod = line * delta + np.testing.assert_allclose(prod.bind(x)(1.0, 1.0, 0.5), (x + 1.0) * 0.5 * x**2) + with pytest.raises(TypeError, match="Model"): + line + 3.0 + + +def test_precedence_of_transform_and_addition(): + c0, rho = Parameter("c0"), Parameter("log_rho") + delta = Model(lambda x, c0: c0 * np.ones_like(x), [c0]) + scale_sum = (line + delta) | scale(rho) + scale_model = (line | scale(rho)) + delta + v_sum = scale_sum.bind(x)(1.0, 0.0, 2.0, np.log(3.0)) # m, b, c0, rho + v_model = scale_model.bind(x)(1.0, 0.0, np.log(3.0), 2.0) # m, b, rho, c0 + np.testing.assert_allclose(v_sum, 3.0 * (x + 2.0)) + np.testing.assert_allclose(v_model, 3.0 * x + 2.0) + + +def test_mul_by_constant_equals_scale(): + rho = Parameter("log_rho") + const = Model(lambda x, r: np.exp(r) * np.ones_like(x), [rho]) + np.testing.assert_allclose( + (line * const).bind(x)(2.0, 1.0, 0.7), + (line | scale(rho)).bind(x)(2.0, 1.0, 0.7), + ) + + +def test_shared_parameter_is_concatenated_not_deduplicated(): + # the same object on both sides is one slot at compile; the model just lists it twice + both = line + Model(lambda x, m: m * np.ones_like(x), [m]) + assert both.params == (m, b, m) + np.testing.assert_allclose(both.bind(x)(1.0, 0.0, 1.0), x + 1.0) + + +def test_model_may_ignore_x_and_close_over_another_predictor(): + native = line.bind(x) + A = np.array([[1.0, 1.0, 1.0, 1.0, 1.0], [0.0, 1.0, 2.0, 3.0, 4.0]]) + proj = Model(lambda x_pc, *theta: A @ native(*theta), line.params) + pc = proj.bind(np.arange(2)) + np.testing.assert_allclose(pc(2.0, 1.0), A @ (2.0 * x + 1.0)) + + +def test_subclass_overrides_bind_and_composes(): + class Doubler(Model): + def __init__(self): + super().__init__(None, [m]) + + def bind(self, x, meta=None): + k = meta["k"] + return Predictor(self.params, x, lambda mm: k * mm * np.asarray(x)) + + model = Doubler() | scale(Parameter("log_rho")) + pred = model.bind(x, {"k": 2.0}) + np.testing.assert_allclose(pred(1.5, 0.0), 3.0 * x) + with pytest.raises(TypeError, match="override bind"): + Model(None, [m]).bind(x) diff --git a/test/test_model_comparison.py b/test/test_model_comparison.py deleted file mode 100644 index a214528..0000000 --- a/test/test_model_comparison.py +++ /dev/null @@ -1,213 +0,0 @@ -"""Tests for the sampler-agnostic ``rxmc.model_comparison`` utilities.""" - -import unittest -from unittest.mock import patch - -import numpy as np -from scipy import stats -from scipy.special import logsumexp -from sklearn.gaussian_process.kernels import RBF - -from helpers import manual_mvn_loglike -from rxmc.config import CalibrationConfig, ParameterConfig -from rxmc.constraint import Constraint -from rxmc.covariance import ConstraintCovariance, Term, kernel_term, noise_term -from rxmc.evidence import Evidence -from rxmc.model_comparison import ( - compare_logz, - coverage_curve, - coverage_error, - heldout_log_predictive, - log_jacobian, - log_posterior_predictive, - logz_summary, - predictive_draws, - sharpness, - split_samples, -) -from rxmc.observation import Observation -from rxmc.params import Parameter -from rxmc.physical_model import Polynomial -from rxmc.priors import IndependentPrior -from rxmc.transforms import log - - -class TestPredictiveDraws(unittest.TestCase): - def setUp(self): - self.pm = Polynomial(order=1) - self.x = np.linspace(0.0, 4.0, 5) - self.y = 1.0 + 2.0 * self.x - self.err = np.full(5, 0.3) - self.obs = Observation(self.x, self.y, y_stat_err=self.err) - - def test_draw_covariance_recovers_sigma(self): - eps = Parameter("log eps") - c = Constraint([self.obs], self.pm, extra_terms=[noise_term(eps)]) - theta = np.array([[1.0, 2.0]]) - cov = np.array([[np.log(0.4)]]) - draws = predictive_draws( - c, theta, cov, n_rep=40000, rng=np.random.default_rng(0) - ) - self.assertEqual(draws.shape, (40000, 5)) - np.testing.assert_allclose(draws.mean(axis=0), self.y, atol=0.02) - S = np.cov(draws.T) - np.testing.assert_allclose(S, np.diag(self.err**2 + 0.16), atol=0.02) - - def test_model_only_returns_ym(self): - c = Constraint([self.obs], self.pm) - theta = np.array([[1.0, 2.0], [0.0, 1.0]]) - d = predictive_draws(c, theta, model_only=True) - np.testing.assert_allclose(d[0], self.y) - np.testing.assert_allclose(d[1], self.x) - - def test_model_only_skips_covariance_assembly(self): - kernel = RBF(length_scale=1.0) - c = Constraint( - [self.obs.masked([True, True, False, True, True])], - self.pm, - extra_terms=[kernel_term(kernel)], - ) - ym, _ = c.predict_and_covariance((1.0, 2.0), (0.0,)) - with patch.object(ConstraintCovariance, "matrix") as m: - d = predictive_draws(c, [1.0, 2.0], [0.0], model_only=True) - m.assert_not_called() - self.assertEqual(d.shape, (1, 4)) - np.testing.assert_allclose(d[0], ym) - - def test_one_dimensional_row_is_one_sample(self): - c = Constraint([self.obs], self.pm) - d = predictive_draws(c, [1.0, 2.0], n_rep=3, rng=np.random.default_rng(2)) - self.assertEqual(d.shape, (3, 5)) - eps = Parameter("log eps") - cp = Constraint([self.obs], self.pm, extra_terms=[noise_term(eps)]) - with self.assertRaises(ValueError): - predictive_draws(cp, [[1.0, 2.0], [1.0, 2.0]], [[0.0]]) - - def test_tiny_variances_not_inflated(self): - obs = Observation(self.x, self.y, y_stat_err=np.full(5, 1e-4)) - c = Constraint([obs], self.pm) - draws = predictive_draws( - c, [1.0, 2.0], n_rep=40000, rng=np.random.default_rng(3) - ) - var = draws.var(axis=0) - np.testing.assert_allclose(var, 1e-8, rtol=0.03) - - def test_requires_cov_samples_when_parametric(self): - c = Constraint([self.obs], self.pm, extra_terms=[noise_term(Parameter("e"))]) - with self.assertRaises(ValueError): - predictive_draws(c, np.array([[1.0, 2.0]])) - - def test_respects_mask(self): - c = Constraint([self.obs.masked([True, False, True, False, True])], self.pm) - d = predictive_draws( - c, np.array([[1.0, 2.0]]), n_rep=3, rng=np.random.default_rng(1) - ) - self.assertEqual(d.shape, (3, 3)) - - -class TestCoverageSharpness(unittest.TestCase): - def test_coverage_near_nominal_for_matching_draws(self): - rng = np.random.default_rng(0) - n_pts = 2000 - draws = rng.normal(0.0, 1.0, (4000, n_pts)) - y = rng.normal(0.0, 1.0, n_pts) - levels = np.array([0.5, 0.9]) - cov = coverage_curve(draws, y, levels) - np.testing.assert_allclose(cov, levels, atol=0.03) - self.assertLess(coverage_error(draws, y, levels), 0.03) - # overconfident draws under-cover - cov_narrow = coverage_curve(0.3 * draws, y, levels) - self.assertTrue(np.all(cov_narrow < levels - 0.2)) - - def test_sharpness_width(self): - rng = np.random.default_rng(0) - draws = rng.normal(0.0, 1.0, (20000, 3)) - w = sharpness(draws) - np.testing.assert_allclose(w, 2 * 0.9945, atol=0.05) - w_exp = sharpness(np.zeros((10, 2)), transform=np.exp) - np.testing.assert_allclose(w_exp, 0.0) - w95 = sharpness(draws, percentiles=(2.5, 97.5)) - np.testing.assert_allclose(w95, 2 * 1.96, atol=0.15) - - -class TestHeldout(unittest.TestCase): - def test_heldout_log_predictive_matches_manual(self): - pm = Polynomial(order=1) - x = np.array([1.0, 2.0, 3.0, 4.0]) - y = np.array([3.1, 4.8, 7.2, 9.1]) - err = np.array([0.2, 0.2, 0.3, 0.3]) - obs = Observation(x, y, y_stat_err=err).masked_where(lambda x: x < 2.5) - fit = Constraint( - [obs], pm, extra_terms=[Term(np.array(0.1 * np.ones(4)), kind="diag")] - ) - held = fit.complement() - samples = np.array([[1.0, 2.0], [1.2, 1.9]]) - lp = heldout_log_predictive(held, samples) - for i, (a0, a1) in enumerate(samples): - ym = a0 + a1 * x[2:] - cov = np.diag(err[2:] ** 2 + 0.01) - self.assertAlmostEqual(lp[i], manual_mvn_loglike(y[2:], ym, cov)) - - def test_log_posterior_predictive(self): - lp = np.array([-1.0, -2.0, -0.5]) - self.assertAlmostEqual(log_posterior_predictive(lp), logsumexp(lp) - np.log(3)) - logw = np.array([0.0, -np.inf, 0.0]) - self.assertAlmostEqual( - log_posterior_predictive(lp, logw), logsumexp(lp[[0, 2]]) - np.log(2) - ) - - -class TestLogZ(unittest.TestCase): - def test_summary_single_and_replicates(self): - m, e, n = logz_summary([-10.0], [0.3]) - self.assertEqual((m, e, n), (-10.0, 0.3, 1)) - m, e, n = logz_summary([-10.0, -12.0], [0.3, 0.3]) - self.assertEqual((m, e, n), (-11.0, 1.0, 2)) # half-range dominates - m, e, n = logz_summary([-10.0, -10.2], [0.5, 0.5]) - self.assertAlmostEqual(e, 0.5) # reported error dominates - - def test_compare(self): - r = compare_logz((-10.0, 0.5), (-15.0, 0.5)) - self.assertEqual(r["verdict"], "a") - self.assertAlmostEqual(r["dlogZ"], 5.0) - self.assertAlmostEqual(r["err"], np.hypot(0.5, 0.5)) - self.assertEqual(compare_logz((-15.0, 0.5), (-10.0, 0.5))["verdict"], "b") - self.assertEqual(compare_logz((-10.0, 1.0), (-11.0, 1.0))["verdict"], "tie") - - def test_log_jacobian(self): - y = np.array([2.0, 3.0]) - obs = Observation(np.array([0.0, 1.0]), y, transform=log) - c = Constraint( - [obs], Polynomial(order=0), extra_terms=[noise_term(Parameter("e"))] - ) - self.assertAlmostEqual(log_jacobian(c), -np.sum(np.log(y))) - - -class TestSplitSamples(unittest.TestCase): - def test_split_rows(self): - pm = Polynomial(order=1) - obs = Observation( - np.arange(4.0), 1.0 + 2.0 * np.arange(4.0), y_stat_err=np.full(4, 0.1) - ) - eps = Parameter("log eps") - c = Constraint([obs], pm, extra_terms=[noise_term(eps)]) - ev = Evidence([c]) - mprior = IndependentPrior([stats.norm(0, 1), stats.norm(0, 1)]) - lprior = IndependentPrior([stats.norm(-2, 1)]) - config = CalibrationConfig( - ev, - ParameterConfig(pm.params, mprior, mprior), - [ParameterConfig(list(c.params), lprior, lprior)], - ) - samples = np.array([[1.0, 2.0, -1.0], [0.5, 1.5, -2.0]]) - m, covs = split_samples(config, samples) - np.testing.assert_allclose(m, samples[:, :2]) - self.assertEqual(len(covs), 1) - np.testing.assert_allclose(covs[0], samples[:, 2:]) - # single row - m1, _ = split_samples(config, samples[0]) - self.assertEqual(m1.shape, (1, 2)) - - -if __name__ == "__main__": - unittest.main() diff --git a/test/test_notebooks_index.py b/test/test_notebooks_index.py new file mode 100644 index 0000000..f90b62c --- /dev/null +++ b/test/test_notebooks_index.py @@ -0,0 +1,129 @@ +"""The example notebooks name the recipes they teach, and every one listed exists. + +Design document section 6: a notebook must cite at least one recipe; +its first cell carries ``Recipes: N, M, ...`` and every number is a heading +of ``docs/recipes.md``. The committed notebooks are full runs (the +documentation shows them as committed), executed top to bottom. Nothing +here executes a notebook. +""" + +import ast +import json +import pathlib +import re + +import pytest + +ROOT = pathlib.Path(__file__).resolve().parents[1] +EXAMPLES = ROOT / "examples" +RECIPES = ROOT / "docs" / "recipes.md" +# examples/budget.py's quick-run banner, read from its source so importing it +# here cannot print it +BANNER = re.search(r'^BANNER = "(.+)"$', (EXAMPLES / "budget.py").read_text(), re.M)[1] + +# design document section 6: the eight notebooks and their recipes +NOTEBOOKS = { + "linear_calibration": {1, 2, 17, 33, 40}, + "normalization_and_covariance_structure": {2, 3, 4, 5, 6, 17, 19, 27, 33, 40, 41}, + "gp_discrepancy": {2, 7, 10, 16, 17, 18, 33, 40}, + "robust_likelihoods": {12, 17, 33, 34, 39, 40}, + "local_optical_model_calibration": {10, 14, 15, 16, 17, 18, 21, 40}, + "alpha_ca_error_model_comparison": {7, 10, 11, 13, 17, 18, 40}, + "hierarchical_calibration": {11, 17, 22, 24, 30, 35, 38, 40, 41}, + "gradient_based_sampling": {7, 16, 33, 38, 41}, +} + +RECIPE_LINE = re.compile(r"^Recipes?:\s*(.+)$", re.M) + + +def _headings() -> set: + return {int(n) for n in re.findall(r"^## (\d+)\. ", RECIPES.read_text(), re.M)} + + +def _present() -> list: + return sorted(p.stem for p in EXAMPLES.glob("*.ipynb")) if EXAMPLES.is_dir() else [] + + +def _cited(name) -> set: + nb = json.loads((EXAMPLES / f"{name}.ipynb").read_text()) + first = nb["cells"][0] + assert first["cell_type"] == "markdown", f"{name}: the first cell must be markdown" + m = RECIPE_LINE.search("".join(first["source"])) + assert m, f"{name}: the first cell needs a line 'Recipes: N, M, ...'" + return {int(n) for n in re.findall(r"\d+", m.group(1))} + + +@pytest.mark.parametrize("name", sorted(NOTEBOOKS)) +def test_each_notebook_exists_and_cites_its_recipes(name): + assert name in _present(), f"examples/{name}.ipynb is in NOTEBOOKS but missing" + cited = _cited(name) + assert cited, f"{name} cites no recipe" + missing = cited - _headings() + assert not missing, f"{name} cites recipe(s) {sorted(missing)} with no heading" + assert cited == NOTEBOOKS[name], ( + f"{name} cites {sorted(cited)}; the design's section 6 says " + f"{sorted(NOTEBOOKS[name])} (update both or neither)" + ) + + +def _python(source) -> str: + """The cell's source with IPython magics and shell escapes dropped. + + ``%%time`` and friends are not Python, and ``ast.parse`` chokes on them. + """ + lines = [ln for ln in source if not ln.lstrip().startswith(("%", "!"))] + return "".join(lines) + + +@pytest.mark.parametrize("name", sorted(NOTEBOOKS)) +def test_no_latex_escape_lands_in_a_plain_string(name): + r"""``f"$\rho$"`` is a carriage return, and matplotlib then fails to parse it. + + Every LaTeX macro in a notebook must sit in a raw string, or the Python + escapes ``\r \t \a \b \f \v`` silently eat the backslash and the label. An + ``ast`` walk sees f-strings too, which a ``tokenize`` pass does not. + """ + control = { + "\r": r"\r", + "\t": r"\t", + "\a": r"\a", + "\b": r"\b", + "\f": r"\f", + "\v": r"\v", + } + nb = json.loads((EXAMPLES / f"{name}.ipynb").read_text()) + bad = [] + for i, cell in enumerate(nb["cells"]): + if cell["cell_type"] != "code": + continue + for node in ast.walk(ast.parse(_python(cell["source"]))): + if isinstance(node, ast.Constant) and isinstance(node.value, str): + for ch, shown in control.items(): + if ch in node.value: + bad.append(f"cell {i}: {shown} in {node.value[:40]!r}") + assert not bad, f"{name}: a LaTeX escape outside a raw string: {bad}" + + +@pytest.mark.parametrize("name", sorted(NOTEBOOKS)) +def test_committed_outputs_are_one_full_run(name): + """Every code cell ran, in order, in one kernel, without an error, and not + in CI's quick mode: ``python examples/run.py `` makes such a run.""" + nb = json.loads((EXAMPLES / f"{name}.ipynb").read_text()) + code = [c for c in nb["cells"] if c["cell_type"] == "code"] + counts = [c["execution_count"] for c in code] + assert counts == list(range(1, len(code) + 1)), ( + f"{name}: execution counts {counts} are not one top-to-bottom run; " + f"rerun it with examples/run.py" + ) + for i, cell in enumerate(code): + for out in cell["outputs"]: + assert out["output_type"] != "error", f"{name}: code cell {i} failed" + text = "".join(out.get("text", [])) + "".join( + out.get("data", {}).get("text/plain", []) + ) + assert BANNER not in text, f"{name}: committed from a quick run" + + +def test_no_stray_notebooks(): + stray = sorted(set(_present()) - set(NOTEBOOKS)) + assert not stray, f"notebooks not in the design's list: {stray}" diff --git a/test/test_observation.py b/test/test_observation.py deleted file mode 100644 index 4a1e51c..0000000 --- a/test/test_observation.py +++ /dev/null @@ -1,293 +0,0 @@ -import unittest - -import numpy as np - -from helpers import make_ctx -from rxmc.covariance import ConstraintCovariance, Term -from rxmc.observation import Observation -from rxmc.transforms import log - - -class TestObservation(unittest.TestCase): - - def test_initialization(self): - x = np.array([1, 2, 3]) - y = np.array([4, 5, 6]) - observation = Observation(x, y) - self.assertEqual(observation.n_data_pts, 3) - np.testing.assert_array_equal(observation.x, x) - np.testing.assert_array_equal(observation.y, y) - np.testing.assert_array_equal(observation.y_stat_err, np.zeros_like(y)) - - def test_invalid_initialization(self): - x = np.array([1, 2, 3]) - y = np.array([4, 5]) - with self.assertRaises(ValueError): - Observation(x, y) - - def test_stat_err_shape_validation(self): - x = np.array([1, 2, 3]) - y = np.array([4, 5, 6]) - with self.assertRaises(ValueError): - Observation(x, y, y_stat_err=np.array([0.1, 0.2])) - - def test_statistical_term_is_diagonal_variance(self): - x = np.array([1.0, 2.0]) - y = np.array([2.0, 4.0]) - y_stat_err = np.array([0.1, 0.2]) - observation = Observation(x, y, y_stat_err=y_stat_err) - support = np.arange(2) - term = observation.statistical_term(support=support) - Sigma = np.zeros((2, 2)) - term.add_to(Sigma, None, np.array([])) - np.testing.assert_array_almost_equal(Sigma, np.diag(y_stat_err**2)) - - def test_statistical_term_writes_into_support_block(self): - # an observation occupying the second block of a length-4 stack - x = np.array([1.0, 2.0]) - y = np.array([2.0, 4.0]) - y_stat_err = np.array([0.3, 0.4]) - observation = Observation(x, y, y_stat_err=y_stat_err) - support = np.array([2, 3]) - cov = ConstraintCovariance([observation.statistical_term(support=support)], N=4) - Sigma = cov.matrix(None) - expected = np.zeros((4, 4)) - expected[2, 2] = 0.3**2 - expected[3, 3] = 0.4**2 - np.testing.assert_array_almost_equal(Sigma, expected) - - def test_default_statistical_term_is_constant(self): - observation = Observation( - np.array([1.0, 2.0]), np.array([2.0, 4.0]), y_stat_err=np.array([0.1, 0.2]) - ) - cov = ConstraintCovariance( - [observation.statistical_term(support=np.arange(2))], N=2 - ) - self.assertTrue(cov.is_constant) - self.assertTrue(cov.block_diagonal) - self.assertEqual(cov.n_params, 0) - - def test_systematics_default_none_and_no_terms(self): - obs = Observation(np.array([1.0, 2.0]), np.array([2.0, 4.0])) - self.assertIsNone(obs.y_sys_err_normalization) - self.assertIsNone(obs.y_sys_err_offset) - self.assertEqual(obs.systematic_terms(np.arange(2)), []) - - def test_systematics_storage(self): - obs = Observation( - np.array([1.0, 2.0]), - np.array([2.0, 4.0]), - y_sys_err_normalization=0.03, - y_sys_err_offset=np.array([0.1, 0.2]), - ) - self.assertEqual(obs.y_sys_err_normalization, 0.03) - np.testing.assert_allclose(obs.y_sys_err_offset, [0.1, 0.2]) - # 0-d ndarrays count as scalars - obs2 = Observation( - np.array([1.0, 2.0]), - np.array([2.0, 4.0]), - y_sys_err_normalization=np.array(0.03), - ) - self.assertEqual(obs2.y_sys_err_normalization, 0.03) - - def test_systematics_bad_shape_raises(self): - with self.assertRaises(ValueError): - Observation( - np.array([1.0, 2.0, 3.0]), - np.array([2.0, 4.0, 6.0]), - y_sys_err_offset=np.array([0.1, 0.2]), - ) - - def test_systematics_zero_magnitudes_skipped(self): - obs = Observation( - np.array([1.0, 2.0]), - np.array([2.0, 4.0]), - y_sys_err_normalization=0.0, - y_sys_err_offset=0, - ) - self.assertEqual(obs.systematic_terms(np.arange(2)), []) - - def test_systematic_terms_offset_then_normalization(self): - obs = Observation( - np.array([1.0, 2.0]), - np.array([2.0, 4.0]), - y_sys_err_normalization=0.05, - y_sys_err_offset=0.2, - ) - terms = obs.systematic_terms(np.arange(2)) - self.assertEqual(len(terms), 2) - self.assertTrue(all(isinstance(t, Term) and t.kind == "mode" for t in terms)) - - def test_systematic_terms_recover_old_covariance(self): - # statistical_term + systematic_terms matches the old auto-folded - # Observation.covariance(ym) - y = np.array([1.0, 2.0, 4.0]) - ym = np.array([1.2, 2.1, 3.5]) - stat = np.array([0.1, 0.2, 0.3]) - norm_frac = 0.05 - offset = 0.2 - obs = Observation( - np.arange(3.0), - y, - y_stat_err=stat, - y_sys_err_normalization=norm_frac, - y_sys_err_offset=offset, - ) - support = np.arange(3) - cov = ConstraintCovariance( - [obs.statistical_term(support=support), *obs.systematic_terms(support)], N=3 - ) - S = cov.matrix(make_ctx(np.arange(3.0), y, ym, [support])) - old = ( - np.diag(stat**2) - + np.outer(offset * np.ones(3), offset * np.ones(3)) - + norm_frac**2 * np.outer(ym, ym) - ) - np.testing.assert_allclose(S, old) - - def test_num_pts_within_interval(self): - x = np.array([1, 2, 3, 4]) - y = np.array([10, 12, 14, 16]) - ylow = np.array([9, 11, 13, 15]) - yhigh = np.array([11, 13, 15, 17]) - observation = Observation(x, y) - num_pts = observation.num_pts_within_interval(ylow, yhigh) - self.assertEqual(num_pts, 4) - - def test_num_pts_within_interval_out(self): - x = np.array([1, 2, 3, 4]) - y = np.array([10, 15, 14, -12]) - ylow = np.array([9, 11, 13, 15]) - yhigh = np.array([11, 13, 15, 17]) - observation = Observation(x, y) - num_pts = observation.num_pts_within_interval(ylow, yhigh) - self.assertEqual(num_pts, 2) - - -class TestObservationTransform(unittest.TestCase): - def setUp(self): - self.x = np.array([1.0, 2.0, 3.0]) - self.y = np.array([2.0, 4.0, 8.0]) - self.err = np.array([0.2, 0.4, 0.8]) - - def test_nonpositive_data_under_log_raises(self): - y = np.array([2.0, 0.0, -1.0]) - with self.assertRaises(ValueError) as cm: - Observation(self.x, y, y_stat_err=self.err, transform=log, label="bad") - msg = str(cm.exception) - self.assertIn("'log'", msg) - self.assertIn("'bad'", msg) - self.assertIn("2 active data point(s)", msg) - # inactive points may be non-positive: the guard is active-point scoped - obs = Observation( - self.x, y, y_stat_err=self.err, transform=log, mask=[True, False, False] - ) - self.assertEqual(obs.n_active, 1) - - def test_raw_kept_and_y_transformed(self): - obs = Observation(self.x, self.y, y_stat_err=self.err, transform=log) - np.testing.assert_allclose(obs.y_raw, self.y) - np.testing.assert_allclose(obs.y, np.log(self.y)) - np.testing.assert_allclose(obs.y_stat_err_raw, self.err) - # delta method: sigma_log = sigma / y - np.testing.assert_allclose(obs.y_stat_err, self.err / self.y) - self.assertIs(obs.transform, log) - - def test_identity_by_default(self): - obs = Observation(self.x, self.y, y_stat_err=self.err) - self.assertTrue(obs.transform.is_identity) - self.assertIs(obs.y, obs.y_raw) - self.assertEqual(obs.log_jacobian, 0.0) - - def test_log_jacobian(self): - obs = Observation(self.x, self.y, transform=log) - self.assertAlmostEqual(obs.log_jacobian, -np.sum(np.log(self.y))) - # respects the mask - obs2 = obs.masked([True, False, True]) - self.assertAlmostEqual(obs2.log_jacobian, -np.log(2.0) - np.log(8.0)) - - def test_parametric_transform_rejected(self): - from rxmc.transforms import scale - - with self.assertRaises(ValueError): - Observation(self.x, self.y, transform=scale()) - - def test_normalisation_systematic_needs_inverse(self): - obs = Observation( - self.x, self.y, y_sys_err_normalization=0.1, transform=np.sqrt - ) - with self.assertRaisesRegex(ValueError, "no inverse"): - obs.systematic_terms() - # an offset alone is propagated at the data and needs no inverse - obs2 = Observation(self.x, self.y, y_sys_err_offset=0.1, transform=np.sqrt) - self.assertEqual(len(obs2.systematic_terms()), 1) - - def test_plain_callable_accepted(self): - obs = Observation(self.x, self.y, transform=np.sqrt) - np.testing.assert_allclose(obs.y, np.sqrt(self.y)) - - def test_systematic_terms_propagated_by_delta_method(self): - obs = Observation( - self.x, - self.y, - y_sys_err_offset=0.5, - y_sys_err_normalization=0.1, - transform=log, - ) - terms = obs.systematic_terms() - self.assertEqual(len(terms), 2) - ym_raw = np.array([2.5, 3.5, 9.0]) - ctx = make_ctx(self.x, obs.y, np.log(ym_raw), [np.arange(3)]) - cov = ConstraintCovariance(terms, 3, blocks=ctx.supports) - S = cov.matrix(ctx) - omega = 0.5 / self.y # |t'(y)| * offset - # fractional normalisation in log space is a constant offset eta - eta = 0.1 * ym_raw * (1.0 / ym_raw) - np.testing.assert_allclose(S, np.outer(omega, omega) + np.outer(eta, eta)) - - -class TestObservationMask(unittest.TestCase): - def setUp(self): - self.x = np.array([1.0, 2.0, 3.0, 4.0]) - self.y = np.array([1.0, 2.0, 3.0, 4.0]) - - def test_default_all_active(self): - obs = Observation(self.x, self.y) - self.assertEqual(obs.n_active, 4) - self.assertTrue(obs.mask.all()) - - def test_masked_is_shallow_copy(self): - obs = Observation(self.x, self.y, label="a") - m = obs.masked([True, True, False, False], label="a-fwd") - self.assertEqual(m.n_active, 2) - self.assertEqual(m.n_data_pts, 4) - self.assertEqual(m.label, "a-fwd") - self.assertIs(m.y, obs.y) - self.assertEqual(obs.n_active, 4) # original untouched - - def test_masked_where(self): - obs = Observation(self.x, self.y) - m = obs.masked_where(lambda x: x < 2.5) - np.testing.assert_array_equal(m.mask, [True, True, False, False]) - - def test_bad_mask_shape_raises(self): - with self.assertRaises(ValueError): - Observation(self.x, self.y, mask=[True, False]) - with self.assertRaises(ValueError): - Observation(self.x, self.y).masked([True]) - - def test_masked_rechecks_transform_finiteness(self): - y = np.array([1.0, 0.0, 3.0, 4.0]) - obs = Observation(self.x, y, transform=log, mask=[True, False, True, True]) - self.assertEqual(obs.n_active, 3) - with self.assertRaises(ValueError): - obs.masked([True, True, True, True]) - - def test_num_pts_within_interval_respects_mask(self): - obs = Observation(self.x, self.y, mask=[True, False, True, False]) - n = obs.num_pts_within_interval(self.y - 0.1, self.y + 0.1) - self.assertEqual(n, 2) - - -if __name__ == "__main__": - unittest.main() diff --git a/test/test_optimize.py b/test/test_optimize.py new file mode 100644 index 0000000..fe1f6ca --- /dev/null +++ b/test/test_optimize.py @@ -0,0 +1,107 @@ +"""rx.optimize: the posterior mode and the maximum of the likelihood.""" + +import warnings + +import jax.numpy as jnp +import numpy as np +import pytest +from scipy import stats + +import rxmc as rx +from rxmc import Comparison, Constraint, Dataset, Model, Parameter, Problem + + +def line(prior_scale=5.0, bounds=(-np.inf, np.inf)): + m = Parameter("m", prior=stats.norm(0, prior_scale)) + b = Parameter("b", prior=stats.norm(0, prior_scale), bounds=bounds) + return Model(lambda x, m, b: m * x + b, [m, b]) + + +def data(seed=0, n=8): + rng = np.random.default_rng(seed) + x = np.linspace(0.5, 2.5, n) + return Dataset(x, 2.0 * x + 1.0 + rng.normal(0, 0.1, n), 0.1 * np.ones(n)) + + +def weighted_least_squares(d, prior_scale=None): + X = np.column_stack([d.x, np.ones_like(d.x)]) + A = X.T @ (X / d.y_err[:, None] ** 2) + if prior_scale is not None: # a normal prior adds its precision + A = A + np.eye(2) / prior_scale**2 + return np.linalg.solve(A, X.T @ (d.y / d.y_err**2)) + + +def test_map_is_the_analytic_posterior_mode(): + d = data() + p = Problem([Constraint([Comparison(d, line(prior_scale=0.5))])]) + fit = rx.optimize.find_map(p, n_starts=4, rng=0) + np.testing.assert_allclose(fit.x, weighted_least_squares(d, 0.5), rtol=1e-6) + assert fit.fun == pytest.approx(p.log_posterior(fit.x)) + assert len(fit.ends) == 4 and fit.ends[0] == pytest.approx(fit.fun) + assert fit.nfev > 0 and fit.wall > 0 + + +def test_mle_ignores_the_prior(): + d = data() + p = Problem([Constraint([Comparison(d, line(prior_scale=0.5))])]) + fit = rx.optimize.find_mle(p, n_starts=4, rng=0) + np.testing.assert_allclose(fit.x, weighted_least_squares(d), rtol=1e-6) + assert fit.fun == pytest.approx(p.log_likelihood(fit.x)) + + +def test_an_optimum_on_a_bound_is_found_inside(): + # the intercept wants 1.0; its bound caps it at 0.8 + p = Problem([Constraint([Comparison(data(), line(bounds=(0.0, 0.8)))])]) + for find in (rx.optimize.find_map, rx.optimize.find_mle): + fit = find(p, n_starts=3, rng=1) + b = fit.x[p.columns(p.params[1])][0] + assert 0.0 < b < 0.8 and b == pytest.approx(0.8, abs=1e-4) + assert np.isfinite(fit.fun) + + +def test_likelihood_gradient_matches_finite_differences(): + p = Problem([Constraint([Comparison(data(), line())])]) + theta = np.array([1.7, 1.3]) + value, grad = p.value_and_grad_log_likelihood(theta) + assert value == pytest.approx(p.log_likelihood(theta)) + h = 1e-5 + fd = [ + (p.log_likelihood(theta + h * e) - p.log_likelihood(theta - h * e)) / (2 * h) + for e in np.eye(2) + ] + np.testing.assert_allclose(p.grad_log_likelihood(theta), fd, rtol=1e-5) + np.testing.assert_allclose(grad, fd, rtol=1e-5) + + +def test_a_search_that_does_not_converge_says_so(): + p = Problem([Constraint([Comparison(data(), line())])]) + with pytest.warns(RuntimeWarning, match="did not converge"): + fit = rx.optimize.find_mle(p, n_starts=3, rng=0, options={"maxiter": 1}) + assert fit.n_success == 0 + # a converged search reports every start and stays quiet + with warnings.catch_warnings(): + warnings.simplefilter("error") + fit = rx.optimize.find_map(p, n_starts=3, rng=0) + assert fit.n_success == 3 + + +def test_a_search_on_an_infinite_plateau_is_no_success(): + # the model is undefined for m > 3: searches that start there stop at once + m = Parameter("m", prior=stats.uniform(0, 10)) + b = Parameter("b", prior=stats.norm(0, 5)) + model = Model(lambda x, m, b: jnp.where(m > 3, jnp.nan, m * x + b), [m, b]) + p = Problem([Constraint([Comparison(data(), model)])]) + fit = rx.optimize.find_mle(p, n_starts=8, rng=1) + assert np.isfinite(fit.fun) and fit.fun == fit.ends[0] + # searches that stopped on the plateau are no successes + assert fit.n_success <= int(np.isfinite(fit.ends).sum()) < 8 + + +def test_all_searches_on_an_infinite_plateau_fail_loudly(): + m = Parameter("m", prior=stats.uniform(4, 6)) # every start is undefined + b = Parameter("b", prior=stats.norm(0, 5)) + model = Model(lambda x, m, b: jnp.where(m > 3, jnp.nan, m * x + b), [m, b]) + p = Problem([Constraint([Comparison(data(), model)])]) + with pytest.warns(RuntimeWarning, match="finite"): + fit = rx.optimize.find_mle(p, n_starts=3, rng=0) + assert not fit.success and fit.n_success == 0 and fit.fun == -np.inf diff --git a/test/test_params.py b/test/test_params.py index abc8bcd..7350521 100644 --- a/test/test_params.py +++ b/test/test_params.py @@ -1,52 +1,49 @@ -import unittest +"""Identity semantics and validation of :class:`rxmc.Parameter`.""" import numpy as np +import pytest +from scipy import stats -from rxmc.params import Parameter - - -class TestParameterHashing(unittest.TestCase): - def test_equal_parameters_hash_equal(self): - a = Parameter("g", float, unit="MeV", latex_name="g", bounds=(0.0, 1.0)) - b = Parameter("g", float, unit="MeV", latex_name="g", bounds=(0.0, 1.0)) - self.assertEqual(a, b) - self.assertEqual(hash(a), hash(b)) - - def test_unequal_parameters_differ(self): - a = Parameter("g") - self.assertNotEqual(a, Parameter("h")) - self.assertNotEqual(a, Parameter("g", unit="MeV")) - self.assertNotEqual(a, Parameter("g", bounds=(0.0, 1.0))) - self.assertNotEqual(a, "g") - - def test_usable_in_set_and_dict(self): - a = Parameter("a") - b = Parameter("b") - self.assertEqual(len({a, b, Parameter("a")}), 2) - table = {a: 1, b: 2} - self.assertEqual(table[Parameter("a")], 1) - - def test_bounds_coerced_to_float_tuple(self): - for bounds in ([0, 2], np.array([0.0, 2.0]), (0, 2)): - p = Parameter("x", bounds=bounds) - self.assertEqual(p.bounds, (0.0, 2.0)) - self.assertIsInstance(p.bounds, tuple) - self.assertTrue(all(isinstance(b, float) for b in p.bounds)) - - def test_default_bounds_are_infinite(self): - self.assertEqual(Parameter("x").bounds, (-np.inf, np.inf)) - - def test_bad_bounds_length_raises(self): - with self.assertRaises(ValueError): - Parameter("x", bounds=(0.0, 1.0, 2.0)) - - def test_repr_contains_fields(self): - r = repr(Parameter("V", float, unit="MeV", latex_name=r"V_0", bounds=(0, 9))) - self.assertIn("'V'", r) - self.assertIn("MeV", r) - self.assertIn("V_0", r) - self.assertIn("(0.0, 9.0)", r) - - -if __name__ == "__main__": - unittest.main() +from rxmc import Parameter + + +def test_identity_is_equality(): + p, q = Parameter("a"), Parameter("a") + assert p == p + assert p != q # same name, distinct objects: two parameters + assert len({p, q}) == 2 + assert {p: 1, q: 2}[p] == 1 + + +def test_bounds_coerced_and_validated(): + p = Parameter("a", bounds=(1, 3)) + assert p.bounds == (1.0, 3.0) + assert all(isinstance(b, float) for b in p.bounds) + with pytest.raises(ValueError, match="lower < upper"): + Parameter("a", bounds=(1.0, 0.0)) + with pytest.raises(ValueError, match="lower, upper"): + Parameter("a", bounds=(1.0,)) + + +def test_default_bounds_infinite(): + p = Parameter("a") + assert p.bounds == (-np.inf, np.inf) + + +def test_name_required(): + with pytest.raises(ValueError): + Parameter("") + + +def test_prior_and_labels(): + prior = stats.norm(0, 1) + p = Parameter("V", prior=prior, unit="MeV", latex=r"V_0") + assert p.prior is prior + assert p.unit == "MeV" + assert p.label == r"V_0" + assert Parameter("W").label == "W" + + +def test_repr_names_the_parameter(): + assert "V" in repr(Parameter("V")) + assert "prior=set" in repr(Parameter("V", prior=stats.norm())) diff --git a/test/test_predictive.py b/test/test_predictive.py index 6f8a6e1..f2fb6c6 100644 --- a/test/test_predictive.py +++ b/test/test_predictive.py @@ -1,200 +1,593 @@ -"""Tests for the predictive-uncertainty helpers (:mod:`rxmc.predictive`).""" - -import unittest +"""GP conditioning, and posterior-predictive draws on a new grid.""" +import jax.numpy as jnp import numpy as np +import pytest +from scipy import stats from sklearn.gaussian_process import GaussianProcessRegressor -from sklearn.gaussian_process.kernels import RBF, ConstantKernel, WhiteKernel +from sklearn.gaussian_process.kernels import RBF, ConstantKernel +from tinygp.kernels import ExpSquared +from rxmc import ( + Comparison, + Constraint, + Dataset, + Model, + Parameter, + Problem, + Term, +) +from rxmc.diagnostics import predictive_draws from rxmc.predictive import ( - _gp_posterior_mean_var, gp_posterior_predictive, + gp_predictive_draws, + grid_draws, predictive_band, - total_predictive_band, ) +from rxmc.terms import ( + constant_amplitude, + exp_growth_amplitude, + kernel, + noise, + normalization, + proportional_error, + systematic, + x_basis, +) +from rxmc.transforms import log -def make_kernel(): - return ConstantKernel(1.0) * RBF(length_scale=0.7) + WhiteKernel(1e-6) +def build(log_var, log_ell): + """The tinygp twin of sklearn's ``ConstantKernel * RBF`` in log theta.""" + return jnp.exp(log_var) * ExpSquared(scale=jnp.exp(log_ell)) -class TestGPPosteriorPredictive(unittest.TestCase): - def setUp(self): +THETA = np.array([0.0, np.log(0.7)]) # ConstantKernel(1.0) * RBF(0.7) + + +class TestGPPosteriorPredictive: + def setup_method(self): rng = np.random.default_rng(0) self.X_train = np.sort(rng.uniform(-2, 2, 12)) self.residuals = np.sin(self.X_train) + 0.05 * rng.standard_normal(12) self.X_pred = np.linspace(-2.5, 2.5, 25) - self.kernel = make_kernel() - self.theta = self.kernel.theta # log-space + self.theta = THETA def test_matches_sklearn_gpr(self): - noise_var = 0.01 - # sklearn GPR with the SAME fixed kernel (no hyperparameter optimisation) gpr = GaussianProcessRegressor( - kernel=self.kernel.clone_with_theta(self.theta), + kernel=ConstantKernel(1.0) * RBF(length_scale=0.7), optimizer=None, - alpha=noise_var, + alpha=0.01, normalize_y=False, ) gpr.fit(self.X_train[:, None], self.residuals) mean_sk, cov_sk = gpr.predict(self.X_pred[:, None], return_cov=True) - mean, cov = gp_posterior_predictive( - self.kernel, + build, self.theta, self.X_train, self.residuals, self.X_pred, - train_noise_var=noise_var, + train_noise_var=0.01, ) np.testing.assert_allclose(mean, mean_sk, atol=1e-6) np.testing.assert_allclose(cov, cov_sk, atol=1e-6) - def test_noiseless_interpolation(self): - # a noiseless kernel (no WhiteKernel) interpolates the residuals exactly - kernel = ConstantKernel(1.0) * RBF(length_scale=0.7) + def test_noiseless_interpolation_and_2d_inputs(self): mean, cov = gp_posterior_predictive( - kernel, - kernel.theta, - self.X_train, - self.residuals, - self.X_train, - train_noise_var=0.0, - jitter=1e-10, - ) - # exact interpolation up to numerical conditioning of the Gram matrix - np.testing.assert_allclose(mean, self.residuals, atol=5e-3) - self.assertLess(np.max(np.abs(np.diag(cov))), 1e-3) - - def test_2d_inputs(self): - rng = np.random.default_rng(1) - Xtr = rng.uniform(-1, 1, (8, 2)) - r = rng.standard_normal(8) - Xp = rng.uniform(-1, 1, (5, 2)) - kernel = ConstantKernel(1.0) * RBF(length_scale=1.0) + WhiteKernel(1e-6) - mean, cov = gp_posterior_predictive(kernel, kernel.theta, Xtr, r, Xp) - self.assertEqual(mean.shape, (5,)) - self.assertEqual(cov.shape, (5, 5)) - - -class TestPredictiveBand(unittest.TestCase): - def test_percentiles(self): - draws = np.arange(101)[:, None] * np.ones((1, 3)) # 0..100 on each column - band = predictive_band(draws, levels=(16, 50, 84)) - self.assertEqual(band.shape, (3, 3)) - np.testing.assert_allclose(band[1], [50, 50, 50]) - np.testing.assert_allclose(band[0], [16, 16, 16]) - np.testing.assert_allclose(band[2], [84, 84, 84]) - - -class TestTotalPredictiveBand(unittest.TestCase): - def test_shape_and_finite(self): - rng = np.random.default_rng(2) - kernel = make_kernel() - - def mean_fn(x, m, b): - return m * x + b - - x_train = np.linspace(0, 1, 10) - y_train = 0.5 * x_train + 0.2 + np.sin(3 * x_train) - x_pred = np.linspace(-0.2, 1.2, 30) - - n_kparams = len(kernel.theta) - n_model = 2 - # fake posterior chain: [m, b, *log_theta] - chain = np.column_stack( - [ - 0.5 + 0.05 * rng.standard_normal(50), - 0.2 + 0.05 * rng.standard_normal(50), - np.tile(kernel.theta, (50, 1)), - ] - ) - self.assertEqual(chain.shape[1], n_model + n_kparams) - - band = total_predictive_band( - mean_fn, - kernel, - x_train, - y_train, - x_pred, - chain, - n_model, - noise_std=0.05, - levels=(16, 84), - n_draws=40, - rng=rng, - ) - self.assertEqual(band.shape, (2, len(x_pred))) - self.assertTrue(np.all(np.isfinite(band))) - self.assertTrue(np.all(band[1] >= band[0])) - - def _mean_fn(self, x, m, b): - return m * x + b - - def test_raises_on_kernel_theta_width_mismatch(self): - kernel = make_kernel() - n_theta = len(kernel.theta) - x_train = np.linspace(0, 1, 8) - y_train = 0.5 * x_train + 0.2 - # an EXTRA nuisance column beyond the kernel theta -> ambiguous trailing slice - chain = np.zeros((10, 2 + n_theta + 1)) - chain[:, 2 : 2 + n_theta] = kernel.theta - with self.assertRaises(ValueError): - total_predictive_band( - self._mean_fn, - kernel, - x_train, - y_train, - np.linspace(0, 1, 5), - chain, - 2, - noise_std=0.05, - n_draws=5, - rng=np.random.default_rng(0), + build, THETA, self.X_train, self.residuals, self.X_train + ) + # the nugget keeps a near-singular K invertible; interpolation to 1e-2 + np.testing.assert_allclose(mean, self.residuals, atol=1e-2) + assert np.all(np.diag(cov) < 1e-2) + X2 = np.column_stack([self.X_train, self.X_train**2]) + mean2, cov2 = gp_posterior_predictive( + build, THETA, X2, self.residuals, X2[:5], train_noise_var=0.01 + ) + assert mean2.shape == (5,) and cov2.shape == (5, 5) + + def test_predictive_band_percentiles(self): + draws = np.tile(np.arange(101.0)[:, None], (1, 3)) + band = predictive_band(draws) + np.testing.assert_allclose(band, [[16] * 3, [50] * 3, [84] * 3]) + + +# ---------------------------------------------------------------------------- +# gp_predictive_draws on a Problem +# ---------------------------------------------------------------------------- + + +def line(): + m = Parameter("m", prior=stats.norm(0, 10)) + b = Parameter("b", prior=stats.norm(0, 10)) + return Model(lambda x, m, b: m * x + b, [m, b]) + + +X = np.linspace(0.0, 1.0, 10) +Y = 0.5 * X + 0.2 + 0.3 * np.sin(3 * X) # a smooth defect on a line +X_PRED = np.linspace(-0.2, 1.2, 30) + + +def problem(terms_first, space=None, err=0.05, fixed=True): + """A line with a GP (hyperparameters fixed or free) and a noise nuisance.""" + d = Dataset(X, Y, np.full(10, err), label="d") + model = line() + comp = Comparison(d, model) if space is None else Comparison(d, model, space=space) + if fixed: + gp = kernel(ExpSquared(scale=0.3)) + else: + gp = kernel( + lambda le: ExpSquared(scale=jnp.exp(le)), + [Parameter("log_ell", prior=stats.norm(-1, 1))], + ) + eps = noise(Parameter("log_eps", prior=stats.norm(-3, 1))) + terms = [eps, gp] if terms_first == "noise" else [gp, eps] + p = Problem([Constraint([comp], terms=terms)]) + return p, gp, model, comp + + +class TestGPPredictiveDraws: + def chain(self, p, n=40, seed=2): + rng = np.random.default_rng(seed) + rows = np.zeros((n, p.ndim)) + rows[:, p.names.index("m")] = 0.5 + 0.05 * rng.standard_normal(n) + rows[:, p.names.index("b")] = 0.2 + 0.05 * rng.standard_normal(n) + rows[:, p.names.index("log_eps")] = np.log(0.05) + if "log_ell" in p.names: + rows[:, p.names.index("log_ell")] = np.log(0.3) + return rows + + def test_shape_finite_and_columns_from_the_problem(self): + p1, gp1, model1, _ = problem("noise", fixed=False) + p2, gp2, model2, _ = problem("kernel", fixed=False) + assert p1.names != p2.names # the nuisance and kernel columns swapped + bands = [] + for p, gp, model in ((p1, gp1, model1), (p2, gp2, model2)): + band = gp_predictive_draws( + p, gp, model.bind(X_PRED, {}), X_PRED, self.chain(p), + terms=list(p.constraints[0].source.terms), levels=(16, 84), rng=0, + ) # fmt: skip + assert band.shape == (2, 30) and np.all(np.isfinite(band)) + assert np.all(band[1] >= band[0]) + bands.append(band) + np.testing.assert_allclose(bands[0], bands[1]) # no column arithmetic + + def test_conditioned_band_passes_through_the_data(self): + p, gp, model, comp = problem("noise", err=1e-4) + chain = np.tile([0.5, 0.2, np.log(1e-4)], (5, 1)) + band = gp_predictive_draws( + p, gp, model.bind(X, {}), X, chain, terms=[gp], levels=(50,), rng=1, + conditioned=True, + ) # fmt: skip + np.testing.assert_allclose(band[0], Y, atol=2e-3) + + def test_joint_draws_carry_the_kernels_correlation(self): + """A draw is a whole curve, not 30 independent points.""" + p, gp, model, _ = problem("noise") + chain = np.tile([0.5, 0.2, np.log(0.05)], (400, 1)) # the model is fixed + kw = dict(terms=[gp], return_draws=True, rng=7) + pred = model.bind(X_PRED, {}) + joint = gp_predictive_draws(p, gp, pred, X_PRED, chain, **kw) + indep = gp_predictive_draws(p, gp, pred, X_PRED, chain, joint=False, **kw) + assert joint.shape == (400, 30) + cj, ci = np.corrcoef(joint.T), np.corrcoef(indep.T) + # RBF(0.3) over a grid of pitch 0.048: neighbours move together + assert cj[0, 1] > 0.9 + assert abs(cj[0, -1]) < 0.2 # 1.4 apart: five length scales, nothing left + assert abs(ci[0, 1]) < 0.2 # joint=False has no correlation anywhere + + def test_the_default_draws_are_mean_zero_about_the_model(self): + """Zero mean says where the model fails; the amplitude says where.""" + d = Dataset(X, Y, np.full(10, 0.05), label="d") + m1, m2 = line(), line() + lA1, lA2 = (Parameter("log_A", prior=stats.norm(0, 1)) for _ in range(2)) + slope = Parameter("slope", prior=stats.norm(0, 1)) + gp_c = kernel( + ExpSquared(scale=0.3), amplitude=constant_amplitude, amplitude_params=(lA1,) + ) + gp_g = kernel( + ExpSquared(scale=0.3), + amplitude=exp_growth_amplitude(1.0), + amplitude_params=(lA2, slope), + ) + p1 = Problem([Constraint([Comparison(d, m1)], terms=[gp_c])]) + p2 = Problem([Constraint([Comparison(d, m2)], terms=[gp_g])]) + n = 800 + b1 = gp_predictive_draws( + p1, gp_c, m1.bind(X_PRED, {}), X_PRED, + np.tile([0.5, 0.2, np.log(0.2)], (n, 1)), + terms=[gp_c], levels=(16, 84), rng=8, + ) # fmt: skip + b2 = gp_predictive_draws( + p2, gp_g, m2.bind(X_PRED, {}), X_PRED, + np.tile([0.5, 0.2, np.log(0.2), 2.0], (n, 1)), + terms=[gp_g], levels=(16, 84), rng=8, + ) # fmt: skip + # the band straddles the model's own prediction, not the data + mu = 0.5 * X_PRED + 0.2 + assert np.all((b1[0] < mu) & (mu < b1[1])) + w1, w2 = b1[1] - b1[0], b2[1] - b2[0] + assert w1.max() / w1.min() < 1.25 # a constant amplitude is flat in x + assert w2[-1] > 3 * w2[0] # exp(2x) over [-0.2, 1.2] grows by 16 + + def test_terms_choose_what_a_draw_carries(self): + p, gp, model, _ = problem("noise") + eps = next(t for t in p.constraints[0].source.terms if t is not gp) + chain = np.tile([0.5, 0.2, 0.0], (400, 1)) # noise of 1, kernel variance 1 + pred = model.bind(X_PRED, {}) + kw = dict(levels=(16, 84), rng=9) + narrow = gp_predictive_draws(p, gp, pred, X_PRED, chain, terms=[gp], **kw) + wide = gp_predictive_draws(p, gp, pred, X_PRED, chain, terms=[gp, eps], **kw) + assert np.all((wide[1] - wide[0]) > (narrow[1] - narrow[0])) + # the reported errors are one number per measured point: never on a grid + with pytest.raises(ValueError, match=r"reported statistical.*'d'"): + gp_predictive_draws(p, gp, pred, X_PRED, chain, **kw) + with pytest.raises(ValueError, match="must include the kernel term"): + gp_predictive_draws(p, gp, pred, X_PRED, chain, terms=[eps]) + with pytest.raises(ValueError, match="not a term of this constraint"): + gp_predictive_draws( + p, gp, pred, X_PRED, chain, terms=[gp, noise(Parameter("q"))] ) - def test_explicit_theta_cols(self): - kernel = make_kernel() - n_theta = len(kernel.theta) - x_train = np.linspace(0, 1, 8) - y_train = 0.5 * x_train + 0.2 - # layout: [m, b, log_eps, *kernel_theta]; kernel theta is NOT the only tail - chain = np.zeros((10, 2 + 1 + n_theta)) - chain[:, 3:] = kernel.theta - theta_cols = np.arange(3, 3 + n_theta) - band = total_predictive_band( - self._mean_fn, - kernel, - x_train, - y_train, - np.linspace(0, 1, 5), - chain, - 2, - theta_cols=theta_cols, - noise_std=0.05, - n_draws=5, - rng=np.random.default_rng(0), - ) - self.assertEqual(band.shape, (2, 5)) - self.assertTrue(np.all(np.isfinite(band))) - - -class TestDiagonalMeanVar(unittest.TestCase): - def test_matches_full_covariance_diagonal(self): - rng = np.random.default_rng(4) - kernel = make_kernel() - X_train = np.sort(rng.uniform(-2, 2, 10)) - residuals = np.sin(X_train) - X_pred = np.linspace(-2.5, 2.5, 20) - mean_full, cov_full = gp_posterior_predictive( - kernel, kernel.theta, X_train, residuals, X_pred, train_noise_var=0.01 - ) - mean, var = _gp_posterior_mean_var( - kernel, kernel.theta, X_train, residuals, X_pred, train_noise_var=0.01 - ) - np.testing.assert_allclose(mean, mean_full, atol=1e-9) - np.testing.assert_allclose(var, np.diag(cov_full), atol=1e-9) - - -if __name__ == "__main__": - unittest.main() + def test_physical_band_under_log_space(self): + p, gp, model, comp = problem("noise", space=log) + # 26 rows put the 16th and 84th percentiles on order statistics, so the + # monotone exp commutes with the percentile + chain = self.chain(p, n=26) + pred = model.bind(X_PRED, {}) + kw = dict(terms=[gp], levels=(16, 84), rng=3) + band_log = gp_predictive_draws(p, gp, pred, X_PRED, chain, **kw) + band_phys = gp_predictive_draws(p, gp, pred, X_PRED, chain, physical=True, **kw) + np.testing.assert_allclose(band_phys, np.exp(band_log)) + + def test_amplitude_matches_a_scaled_kernel(self): + d = Dataset(X, Y, np.full(10, 0.05), label="d") + A = 0.7 + m1, m2 = line(), line() + lA = Parameter("log_A", prior=stats.norm(0, 1)) + gp_amp = kernel( + ExpSquared(scale=0.3), amplitude=constant_amplitude, amplitude_params=(lA,) + ) + gp_fix = kernel(A**2 * ExpSquared(scale=0.3)) + p1 = Problem([Constraint([Comparison(d, m1)], terms=[gp_amp])]) + p2 = Problem([Constraint([Comparison(d, m2)], terms=[gp_fix])]) + chain1 = np.tile([0.5, 0.2, np.log(A)], (8, 1)) + chain2 = np.tile([0.5, 0.2], (8, 1)) + b1 = gp_predictive_draws( + p1, gp_amp, m1.bind(X_PRED, {}), X_PRED, chain1, terms=[gp_amp], rng=4 + ) + b2 = gp_predictive_draws( + p2, gp_fix, m2.bind(X_PRED, {}), X_PRED, chain2, terms=[gp_fix], rng=4 + ) + np.testing.assert_allclose(b1, b2, atol=1e-8) + + def test_amplitude_reads_the_predictor_meta(self): + # recipe 22: an amplitude keyed on the dataset's energy is, at 25 MeV, a + # constant amplitude of 0.5 at the data and at the prediction points + d = Dataset(X, Y, np.full(10, 0.05), label="d", meta={"Elab": 25.0}) + m1, m2 = line(), line() + lA1, lA2 = (Parameter("log_A", prior=stats.norm(0, 1)) for _ in range(2)) + gp_meta = kernel( + ExpSquared(scale=0.3), + amplitude=lambda c, lA: jnp.exp(lA) * c.meta("Elab") / 50.0, + amplitude_params=(lA1,), + ) + gp_const = kernel( + ExpSquared(scale=0.3), amplitude=constant_amplitude, amplitude_params=(lA2,) + ) + p1 = Problem([Constraint([Comparison(d, m1)], terms=[gp_meta])]) + p2 = Problem([Constraint([Comparison(d, m2)], terms=[gp_const])]) + chain1 = np.tile([0.5, 0.2, 0.0], (8, 1)) + chain2 = np.tile([0.5, 0.2, np.log(0.5)], (8, 1)) + b1 = gp_predictive_draws( + p1, gp_meta, m1.bind(X_PRED, d.meta), X_PRED, chain1, terms=[gp_meta], rng=4 + ) + b2 = gp_predictive_draws( + p2, gp_const, m2.bind(X_PRED, {}), X_PRED, chain2, terms=[gp_const], rng=4 + ) + np.testing.assert_allclose(b1, b2, atol=1e-8) + + def test_one_bare_callable_is_one_space(self): + # space=jnp.log wraps into a new Transform on each comparison + model = line() + ds = [Dataset(X, Y + 1.0 + k, np.full(10, 0.05), label=f"d{k}") for k in (0, 1)] + comps = [Comparison(d, model, space=jnp.log) for d in ds] + gp = kernel(ExpSquared(scale=0.3), on=comps) + p = Problem([Constraint(comps, terms=[gp])]) + chain = np.tile([0.5, 1.2], (4, 1)) + band = gp_predictive_draws( + p, gp, model.bind(X_PRED, {}), X_PRED, chain, terms=[gp] + ) + assert band.shape == (3, 30) and np.all(np.isfinite(band)) + + def test_fully_masked_kernel_support_says_so(self): + model = line() + c1, c2 = ( + Comparison(Dataset(X, Y, np.full(10, 0.05), label=lab), model) + for lab in "ab" + ) + gp = kernel(ExpSquared(scale=0.3), on=c2) + c = Constraint([c1, c2], terms=[gp]).masked( + [np.ones(10, bool), np.zeros(10, bool)] + ) + chain = np.tile([0.5, 0.2], (4, 1)) + with pytest.raises(ValueError, match="fully masked"): + gp_predictive_draws(Problem([c]), gp, model.bind(X_PRED, {}), X_PRED, chain) + + def test_explicit_noise_and_errors(self): + p, gp, model, comp = problem("noise") + chain = self.chain(p, n=6) + pred = model.bind(X_PRED, {}) + band = gp_predictive_draws( + p, gp, pred, X_PRED, chain, terms=[gp], train_noise_var=0.05**2, + noise_std=0.1, rng=5, conditioned=True, + ) # fmt: skip + assert band.shape == (3, 30) + with pytest.raises(ValueError, match="conditioned=True"): + gp_predictive_draws(p, gp, pred, X_PRED, chain, train_noise_var=0.01) + with pytest.raises(TypeError, match="KernelTerm"): + gp_predictive_draws(p, Term(np.ones(10), kind="diag"), pred, X_PRED, chain) + with pytest.raises(ValueError, match="not part of any constraint"): + gp_predictive_draws(p, kernel(ExpSquared(scale=1.0)), pred, X_PRED, chain) + with pytest.raises(ValueError, match=r"\(n, 3\)"): + gp_predictive_draws(p, gp, pred, X_PRED, chain[:, :2]) + + +# ---------------------------------------------------------------------------- +# grid_draws: any error model whose terms are functions of x +# ---------------------------------------------------------------------------- + +X_GRID = np.linspace(-1.0, 2.0, 16) # well past the data on both sides + + +def one(term_or_terms, err=0.05, statistical=False, likelihood=None, space=None): + """A line on (X, Y) with the given terms, and the model it compares.""" + terms = term_or_terms if isinstance(term_or_terms, list) else [term_or_terms] + model = line() + d = Dataset(X, Y, np.full(10, err), label="d") + comp = Comparison(d, model) if space is None else Comparison(d, model, space=space) + kw = {} if likelihood is None else {"likelihood": likelihood} + c = Constraint([comp], terms=terms, statistical=statistical, **kw) + return Problem([c]), model, comp + + +def cov_of(p, model, theta, x=X_GRID, n_rep=40000, rng=0, **kw): + draws = grid_draws( + p, model.bind(x, {}), x, theta, n_rep=n_rep, rng=rng, return_draws=True, **kw + ) + return draws.mean(axis=0), np.cov(draws.T) + + +class TestGridDraws: + def test_a_scalar_reported_normalisation_travels_to_the_grid(self): + """In log space a 5 % normalisation is a constant mode of 0.05.""" + model = line() + d = Dataset(X, Y, np.full(10, 0.05), norm_err=0.05, label="d") + comp = Comparison(d, model, space=log) + e = Parameter("e", prior=stats.norm(-9, 1)) + c = Constraint( + [comp], terms=[noise(e), *comp.reported_terms()], statistical=False + ) + _, cov = cov_of(Problem([c]), model, np.array([0.5, 1.2, -9.0])) + np.testing.assert_allclose(cov, 0.05**2, atol=2e-4) + + def test_the_band_is_the_percentiles_of_the_draws(self): + """One return convention for all three draw functions.""" + eps = noise(Parameter("log_eps", prior=stats.norm(-2, 1))) + p, model, _ = one(eps) + rows = np.tile([0.5, 0.2, np.log(0.1)], (50, 1)) + pred = model.bind(X_GRID, {}) + draws = grid_draws(p, pred, X_GRID, rows, rng=1, return_draws=True) + np.testing.assert_allclose( + grid_draws(p, pred, X_GRID, rows, rng=1), predictive_band(draws) + ) + at_data = predictive_draws(p, rows, rng=1, return_draws=True) + np.testing.assert_allclose( + predictive_draws(p, rows, rng=1, levels=(5, 95)), + predictive_band(at_data, (5, 95)), + ) + gp = kernel(ExpSquared(scale=0.3)) + pk, mk, _ = one([gp]) + rk = np.tile([0.5, 0.2], (50, 1)) + pk_pred = mk.bind(X_GRID, {}) + gdraws = gp_predictive_draws( + pk, gp, pk_pred, X_GRID, rk, rng=2, return_draws=True + ) + np.testing.assert_allclose( + gp_predictive_draws(pk, gp, pk_pred, X_GRID, rk, rng=2), + predictive_band(gdraws), + ) + + def test_model_only_is_the_hand_push_from_posterior_or_prior_rows(self): + eps = noise(Parameter("log_eps", prior=stats.norm(-2, 1))) + p, model, _ = one(eps) + pred = model.bind(X_GRID, {}) + for rows in ( + np.random.default_rng(0).normal(size=(7, 3)), + p.sample_prior(7, rng=1), + ): + by_hand = np.array([pred(*r[p.columns(model.params)]) for r in rows]) + got = grid_draws(p, pred, X_GRID, rows, model_only=True, return_draws=True) + np.testing.assert_allclose(got, by_hand) + + def test_at_the_measured_points_it_is_the_likelihoods_own_predictive(self): + """Every term a function: the grid draw and the data draw agree.""" + eps = noise(Parameter("log_eps", prior=stats.norm(-2, 1))) + eta = normalization(Parameter("log_eta", prior=stats.norm(-2, 1))) + gp = kernel(0.04 * ExpSquared(scale=0.3)) + p, model, _ = one([eps, eta, gp]) + theta = np.array([0.5, 0.2, np.log(0.1), np.log(0.2)]) + mean, cov = cov_of(p, model, theta, x=X) + np.testing.assert_allclose(cov, p.constraints[0].matrix(theta), atol=2e-3) + at_data = predictive_draws(p, theta, n_rep=40000, rng=1, return_draws=True) + np.testing.assert_allclose(np.cov(at_data.T), cov, atol=3e-3) + np.testing.assert_allclose(mean, 0.5 * X + 0.2, atol=0.01) + + def test_constant_noise_extrapolates_with_the_model(self): + eps = noise(Parameter("log_eps", prior=stats.norm(-2, 1))) + p, model, _ = one(eps) + mean, cov = cov_of(p, model, np.array([0.5, 0.2, np.log(0.1)])) + np.testing.assert_allclose(mean, 0.5 * X_GRID + 0.2, atol=0.005) + np.testing.assert_allclose(cov, 0.01 * np.eye(16), atol=5e-4) + + def test_proportional_errors_scale_with_the_prediction(self): + ym = 0.5 * X_GRID + 1.2 + for averaging in (False, True): + f = Parameter("log_f", prior=stats.norm(-2, 1)) + p, model, _ = one(proportional_error(f, averaging=averaging)) + _, cov = cov_of(p, model, np.array([0.5, 1.2, np.log(0.1)])) + # the averaging basis uses y and ym; on a grid y *is* the model + np.testing.assert_allclose(np.sqrt(np.diag(cov)), 0.1 * ym, rtol=0.03) + # a diagonal term: no correlation between grid points + np.testing.assert_allclose(cov - np.diag(np.diag(cov)), 0.0, atol=5e-4) + + def test_a_normalisation_mode_is_one_curve_scaled_by_the_prediction(self): + ym = 0.5 * X_GRID + 1.2 + free = normalization(Parameter("log_eta", prior=stats.norm(-2, 1))) + fixed = normalization(magnitude=0.1) + for term, theta in ((free, [0.5, 1.2, np.log(0.1)]), (fixed, [0.5, 1.2])): + p, model, _ = one([noise(Parameter("e", prior=stats.norm(-9, 1))), term]) + theta = np.array([*theta[:2], -9.0, *theta[2:]]) + _, cov = cov_of(p, model, theta) + np.testing.assert_allclose(np.sqrt(np.diag(cov)), 0.1 * ym, rtol=0.03) + corr = cov / np.sqrt(np.outer(np.diag(cov), np.diag(cov))) + assert corr[0, 1] > 0.99 and corr[0, -1] > 0.99 + + def test_a_systematic_mode_with_an_x_basis_grows_along_x(self): + s = systematic(Parameter("log_s", prior=stats.norm(-2, 1)), basis=x_basis()) + eps = noise(Parameter("e", prior=stats.norm(-9, 1))) + p, model, _ = one([eps, s]) + _, cov = cov_of(p, model, np.array([0.5, 0.2, -9.0, np.log(0.1)])) + np.testing.assert_allclose( + np.sqrt(np.diag(cov)), 0.1 * np.abs(X_GRID), rtol=0.03, atol=2e-3 + ) + + def test_a_parametric_matrix_term_is_evaluated_from_its_definition(self): + """Any Term(fn, params, kind="matrix") of c.x travels, not only kernels.""" + log_l = Parameter("log_l", prior=stats.norm(-1, 1)) + + def sq_exp(c, ll): + dx = c.x[:, None] - c.x[None, :] + return 0.04 * jnp.exp(-0.5 * dx**2 / jnp.exp(ll) ** 2) + + p, model, _ = one([Term(sq_exp, (log_l,), kind="matrix")]) + theta = np.array([0.5, 0.2, np.log(0.5)]) + _, cov = cov_of(p, model, theta) + dx = np.subtract.outer(X_GRID, X_GRID) + np.testing.assert_allclose(cov, 0.04 * np.exp(-0.5 * dx**2 / 0.25), atol=2e-3) + + def test_a_kernel_through_grid_draws_is_the_gp_function_unconditioned(self): + gp = kernel( + lambda le: ExpSquared(scale=jnp.exp(le)), + [Parameter("log_ell", prior=stats.norm(-1, 1))], + ) + eps = noise(Parameter("log_eps", prior=stats.norm(-3, 1))) + p, model, _ = one([eps, gp]) + rows = np.column_stack( + [np.full(30, 0.5), np.full(30, 0.2), np.full(30, np.log(0.05)), + np.log(np.linspace(0.2, 0.4, 30))] + ) # fmt: skip + pred = model.bind(X_GRID, {}) + kw = dict(terms=[eps, gp], n_rep=3, rng=11, return_draws=True) + np.testing.assert_allclose( + grid_draws(p, pred, X_GRID, rows, **kw), + gp_predictive_draws(p, gp, pred, X_GRID, rows, **kw), + ) + + def test_joint_draws_are_curves_and_independent_draws_are_not(self): + gp = kernel(ExpSquared(scale=0.5)) + p, model, _ = one([gp]) + pred = model.bind(X_GRID, {}) + rows = np.array([0.5, 0.2]) + kw = dict(n_rep=4000, rng=3, return_draws=True) + joint = grid_draws(p, pred, X_GRID, rows, **kw) + indep = grid_draws(p, pred, X_GRID, rows, joint=False, **kw) + assert np.corrcoef(joint.T)[0, 1] > 0.9 + assert abs(np.corrcoef(indep.T)[0, 1]) < 0.1 + np.testing.assert_allclose(joint.var(0), indep.var(0), rtol=0.1) + + def test_a_term_reads_the_predictor_meta_on_the_grid(self): + d = Dataset(X, Y, np.full(10, 0.05), label="d", meta={"Elab": 25.0}) + model = line() + log_a = Parameter("log_a", prior=stats.norm(-2, 1)) + by_energy = Term( + lambda c, la: jnp.exp(la) * c.meta("Elab") / 50.0 * jnp.ones(len(c)), + (log_a,), + kind="diag", + ) + p = Problem( + [Constraint([Comparison(d, model)], terms=[by_energy], statistical=False)] + ) + theta = np.array([0.5, 0.2, 0.0]) + draws = grid_draws( + p, model.bind(X_GRID, {"Elab": 100.0}), X_GRID, theta, + n_rep=40000, rng=4, return_draws=True, + ) # fmt: skip + np.testing.assert_allclose(draws.std(0), 2.0, rtol=0.03) # 100 / 50 + + def test_grid_physical_band_under_log_space(self): + eps = noise(Parameter("log_eps", prior=stats.norm(-2, 1))) + p, model, _ = one(eps, space=log) + rows = np.tile([0.5, 1.2, np.log(0.1)], (26, 1)) + pred = model.bind(X_GRID, {}) + kw = dict(levels=(16, 84), rng=5) + np.testing.assert_allclose( + grid_draws(p, pred, X_GRID, rows, physical=True, **kw), + np.exp(grid_draws(p, pred, X_GRID, rows, **kw)), + ) + + def test_several_comparisons_need_to_say_which_experiment_the_grid_is(self): + model = line() + da = Dataset(X, Y, np.full(10, 0.05), label="a") + db = Dataset(X, Y + 0.1, np.full(10, 0.05), label="b") + ca, cb = Comparison(da, model), Comparison(db, model) + na = normalization(magnitude=0.1, on=ca) + nb = normalization(magnitude=0.3, on=cb) + eps = noise(Parameter("log_eps", prior=stats.norm(-9, 1))) + p = Problem([Constraint([ca, cb], terms=[eps, na, nb], statistical=False)]) + theta = np.array([0.5, 1.2, -9.0]) + pred = model.bind(X_GRID, {}) + with pytest.raises(ValueError, match="comparison="): + grid_draws(p, pred, X_GRID, theta) + draws = grid_draws( + p, pred, X_GRID, theta, comparison=ca, n_rep=40000, rng=7, return_draws=True + ) + # experiment a's normalisation only, not b's as well + np.testing.assert_allclose(draws.std(0), 0.1 * (0.5 * X_GRID + 1.2), rtol=0.03) + with pytest.raises(ValueError, match="not a comparison"): + grid_draws(p, pred, X_GRID, theta, comparison=Comparison(da, model)) + # explicit terms need no comparison when the space is shared + assert grid_draws(p, pred, X_GRID, theta, terms=[nb]).shape == (3, 16) + cl = Comparison( + Dataset(X, Y + 1.0, np.full(10, 0.05), label="l"), model, space=log + ) + pl = Problem([Constraint([ca, cl], terms=[eps], statistical=False)]) + with pytest.raises(ValueError, match="one comparison space"): + grid_draws(pl, pred, X_GRID, theta, terms=[eps]) + assert grid_draws(pl, pred, X_GRID, theta, comparison=cl).shape == (3, 16) + + def test_point_by_point_terms_have_no_value_at_a_new_x(self): + model = line() + d = Dataset(X, Y, np.full(10, 0.05), label="d") + comp = Comparison(d, model) + theta = np.array([0.5, 0.2]) + pred = model.bind(X_GRID, {}) + reported = Problem([Constraint([comp])]) + with pytest.raises(ValueError, match=r"reported statistical errors.*'d'"): + grid_draws(reported, pred, X_GRID, theta) + # the choice made explicit is allowed: the model alone + assert grid_draws(reported, pred, X_GRID, theta, terms=[]).shape == (3, 16) + fixed = Term(np.full(10, 0.1), kind="diag") + p = Problem([Constraint([comp], terms=[fixed])]) + with pytest.raises(ValueError, match="array-valued term"): + grid_draws(p, pred, X_GRID, theta, terms=[fixed]) + per_point = normalization(magnitude=np.full(10, 0.1)) + eps = noise(Parameter("log_eps", prior=stats.norm(-2, 1))) + p = Problem([Constraint([comp], terms=[eps, per_point], statistical=False)]) + theta = np.array([0.5, 0.2, np.log(0.1)]) + with pytest.raises(ValueError, match="could not be evaluated"): + grid_draws(p, pred, X_GRID, theta) + with pytest.raises(ValueError, match="not a term of this constraint"): + grid_draws(p, pred, X_GRID, theta, terms=[normalization(magnitude=0.1)]) + with pytest.raises(ValueError, match=r"\(n, 3\)"): + grid_draws(p, pred, X_GRID, np.zeros((4, 2))) diff --git a/test/test_priors.py b/test/test_priors.py deleted file mode 100644 index 1350323..0000000 --- a/test/test_priors.py +++ /dev/null @@ -1,179 +0,0 @@ -import unittest - -import numpy as np -import scipy.stats - -from rxmc.config import ParameterConfig -from rxmc.params import Parameter -from rxmc.priors import ( - IndependentPrior, - TruncatedNormalPrior, - as_prior, - clip_unit_cube, -) - - -class TestIndependentPrior(unittest.TestCase): - def setUp(self): - self.dists = [ - scipy.stats.norm(loc=0.0, scale=1.0), - scipy.stats.uniform(loc=0.0, scale=5.0), - scipy.stats.norm(loc=2.0, scale=0.5), - ] - self.prior = IndependentPrior(self.dists, seed=0) - - def test_dim(self): - self.assertEqual(self.prior.dim, 3) - - def test_logpdf_scalar(self): - """1-D input returns a finite float.""" - lp = self.prior.logpdf(np.array([0.0, 2.5, 2.0])) - self.assertIsInstance(lp, float) - self.assertTrue(np.isfinite(lp)) - - def test_logpdf_batch(self): - """2-D input returns a 1-D array of the right length.""" - theta = np.array([[0.0, 1.0, 2.0], [1.0, 4.0, 2.5]]) - lp = self.prior.logpdf(theta) - self.assertEqual(lp.shape, (2,)) - self.assertTrue(np.all(np.isfinite(lp))) - - def test_logpdf_out_of_support(self): - """Points outside the support of a bounded marginal return -inf.""" - # uniform(0, 5): value -1 is outside support - lp = self.prior.logpdf(np.array([0.0, -1.0, 2.0])) - self.assertEqual(lp, -np.inf) - - def test_logpdf_wrong_dim_raises(self): - with self.assertRaises(ValueError): - self.prior.logpdf(np.array([0.0, 1.0])) - - def test_rvs_shape(self): - samples = self.prior.rvs(10) - self.assertEqual(samples.shape, (10, 3)) - - def test_rvs_reproducible(self): - p1 = IndependentPrior(self.dists, seed=42) - p2 = IndependentPrior(self.dists, seed=42) - np.testing.assert_array_equal(p1.rvs(5), p2.rvs(5)) - - def test_prior_transform_median(self): - """prior_transform at u=0.5 returns the per-component median.""" - u = np.full(3, 0.5) - theta = self.prior.prior_transform(u) - expected = np.array([d.ppf(0.5) for d in self.dists]) - np.testing.assert_allclose(theta, expected, atol=1e-10) - - def test_prior_transform_roundtrip(self): - """logpdf(prior_transform(u)) is finite for interior u.""" - u = np.array([0.3, 0.7, 0.5]) - theta = self.prior.prior_transform(u) - lp = self.prior.logpdf(theta) - self.assertTrue(np.isfinite(lp)) - - def test_compatible_with_parameter_config(self): - """IndependentPrior works as the prior argument to ParameterConfig.""" - params = [Parameter(f"p{i}") for i in range(3)] - config = ParameterConfig( - params=params, - prior=self.prior, - initial_proposal_distribution=self.prior, - ) - self.assertEqual(config.ndim, 3) - - lp = config.prior_logpdf(np.array([0.0, 2.5, 2.0])) - self.assertTrue(np.isfinite(lp)) - - x0 = config.x0(4) - self.assertEqual(x0.shape, (4, 3)) - - theta = config.prior_transform(np.full(3, 0.5)) - self.assertEqual(theta.shape, (3,)) - self.assertTrue(np.all(np.isfinite(theta))) - - -class TestTruncatedNormalPrior(unittest.TestCase): - def setUp(self): - self.prior = TruncatedNormalPrior( - mu=[0.0, 1.0], - sigma=[1.0, 1.0], - lower=[-5.0, -4.0], - upper=[5.0, 6.0], - seed=0, - ) - - def test_dim(self): - self.assertEqual(self.prior.dim, 2) - - def test_logpdf_scalar(self): - lp = self.prior.logpdf(np.array([0.0, 1.0])) - self.assertIsInstance(lp, float) - self.assertTrue(np.isfinite(lp)) - - def test_logpdf_batch(self): - theta = np.array([[0.0, 1.0], [1.0, 2.0]]) - lp = self.prior.logpdf(theta) - self.assertEqual(lp.shape, (2,)) - self.assertTrue(np.all(np.isfinite(lp))) - - def test_logpdf_out_of_support(self): - lp = self.prior.logpdf(np.array([10.0, 1.0])) - self.assertEqual(lp, -np.inf) - - def test_rvs_shape(self): - samples = self.prior.rvs(8) - self.assertEqual(samples.shape, (8, 2)) - - def test_rvs_within_bounds(self): - samples = self.prior.rvs(500) - self.assertTrue(np.all(samples[:, 0] >= -5.0)) - self.assertTrue(np.all(samples[:, 0] <= 5.0)) - self.assertTrue(np.all(samples[:, 1] >= -4.0)) - self.assertTrue(np.all(samples[:, 1] <= 6.0)) - - def test_prior_transform_median(self): - """Symmetric bounds → median maps to mu.""" - u = np.full(2, 0.5) - theta = self.prior.prior_transform(u) - np.testing.assert_allclose(theta, [0.0, 1.0], atol=1e-6) - - def test_prior_transform_roundtrip(self): - u = np.array([0.2, 0.8]) - theta = self.prior.prior_transform(u) - lp = self.prior.logpdf(theta) - self.assertTrue(np.isfinite(lp)) - - -class TestUnitCubeClipping(unittest.TestCase): - def test_clip_unit_cube(self): - u = clip_unit_cube([0.0, 0.5, 1.0]) - eps = np.finfo(float).eps - np.testing.assert_allclose(u, [eps, 0.5, 1.0 - eps]) - self.assertEqual(u.dtype, float) - self.assertTrue(np.all(u > 0.0) and np.all(u < 1.0)) - - def test_independent_prior_boundary_is_finite(self): - # an unbounded marginal's ppf is +-inf at exactly 0 / 1 - prior = IndependentPrior([scipy.stats.norm(0, 1), scipy.stats.norm(0, 1)]) - theta = prior.prior_transform([0.0, 1.0]) - self.assertTrue(np.all(np.isfinite(theta))) - self.assertLess(theta[0], 0.0) - self.assertGreater(theta[1], 0.0) - - def test_truncated_normal_boundary_is_finite(self): - prior = TruncatedNormalPrior(mu=[0.0], sigma=[1.0], lower=[-2.0], upper=[3.0]) - theta = prior.prior_transform([0.0]) - self.assertTrue(np.all(np.isfinite(theta))) - np.testing.assert_allclose(theta, [-2.0], atol=1e-6) - - def test_as_prior_wraps_lists_only(self): - dists = [scipy.stats.norm(0, 1)] - wrapped = as_prior(dists) - self.assertIsInstance(wrapped, IndependentPrior) - self.assertIs(wrapped.distributions[0], dists[0]) - prior = TruncatedNormalPrior(mu=[0.0], sigma=[1.0], lower=[-1.0], upper=[1.0]) - self.assertIs(as_prior(prior), prior) - - -if __name__ == "__main__": - unittest.main() diff --git a/test/test_problem.py b/test/test_problem.py new file mode 100644 index 0000000..7d0a22c --- /dev/null +++ b/test/test_problem.py @@ -0,0 +1,680 @@ +"""The compile step: index, priors, compiled constraints, the flat interface.""" + +import warnings +from dataclasses import replace + +import dill +import dynesty +import emcee +import jax +import jax.numpy as jnp +import jax.scipy.stats as jst +import numpy as np +import pytest +from scipy import stats + +from helpers import manual_mvn_loglike +from rxmc import Comparison, Constraint, Dataset, Model, Parameter, Problem +from rxmc.likelihood import Chi2 +from rxmc.problem import ParameterIndex, clip_unit_cube +from rxmc.terms import ( + Term, + constant_amplitude, + kernel, + noise, + offset, + statistical, +) +from rxmc.transforms import log, scale + +X = np.linspace(0.0, 2.0, 6) +TRUE = (2.0, 1.0) + + +def line_model(prior=True): + m = Parameter("m", prior=stats.norm(0, 5) if prior else None) + b = Parameter("b", prior=stats.norm(0, 5) if prior else None) + return Model(lambda x, m, b: m * x + b, [m, b]) + + +def dataset(seed=0, n=6, label="d"): + rng = np.random.default_rng(seed) + y = TRUE[0] * X[:n] + TRUE[1] + rng.normal(0, 0.1, n) + return Dataset(X[:n], y, 0.1 * np.ones(n), label=label) + + +def problem(**kw): + d = dataset() + return Problem([Constraint([Comparison(d, line_model())], **kw)]) + + +# ---------------------------------------------------------------------------- +# The index +# ---------------------------------------------------------------------------- + + +class TestIndex: + def test_first_seen_order_predictors_then_terms(self): + model = line_model() + eps = Parameter("log_eps", prior=stats.norm()) + c = Constraint( + [Comparison(dataset(), model)], terms=[noise(eps)], likelihood=Chi2() + ) + p = Problem([c]) + # the likelihood contributes no parameters + assert p.names == ["m", "b", "log_eps"] + assert p.params == (*model.params, eps) + assert p.ndim == 3 and p.bounds.shape == (3, 2) + + def test_shared_object_is_one_slot_across_constraints(self): + eps = Parameter("log_eps", prior=stats.norm()) + model = line_model() + cs = [ + Constraint([Comparison(dataset(0, label="a"), model)], terms=[noise(eps)]), + Constraint([Comparison(dataset(1, label="b"), model)], terms=[noise(eps)]), + ] + p = Problem(cs) + assert p.names == ["m", "b", "log_eps"] + assert np.array_equal(p.columns(eps), [2]) + assert np.array_equal(p.columns([eps, model.params[0]]), [2, 0]) + + def test_duplicate_names_raise_with_hint(self): + a1, a2 = ( + Parameter("log_eps", prior=stats.norm()), + Parameter("log_eps", prior=stats.norm()), + ) + c = Constraint( + [Comparison(dataset(), line_model())], terms=[noise(a1), noise(a2)] + ) + with pytest.raises(ValueError, match="duplicate parameter name.*SAME object"): + Problem([c]) + + def test_index_api(self): + ix = ParameterIndex() + a, b = Parameter("a"), Parameter("b") + assert np.array_equal(ix.add_all([a, b, a]), [0, 1, 0]) + assert ix.slot(b) == 1 and ix.names == ["a", "b"] + with pytest.raises(KeyError): + ix.slot(Parameter("c")) + with pytest.raises(TypeError): + ix.add_all(["a"]) + + +# ---------------------------------------------------------------------------- +# Priors +# ---------------------------------------------------------------------------- + + +class TestPriors: + def test_marginals_bounded_and_uniform(self): + m = Parameter("m", prior=stats.norm(0, 2), bounds=(-1.0, 3.0)) + b = Parameter("b", bounds=(0.0, 4.0)) + p = Problem( + [ + Constraint( + [Comparison(dataset(), Model(lambda x, m, b: m * x + b, [m, b]))] + ) + ] + ) + tn = stats.truncnorm(-0.5, 1.5, loc=0, scale=2) + assert p.log_prior([0.5, 1.0]) == pytest.approx(tn.logpdf(0.5) - np.log(4.0)) + assert p.log_prior([3.5, 1.0]) == -np.inf and p.log_prior([0.5, 5.0]) == -np.inf + theta = p.prior_transform([0.3, 0.25]) + assert theta[0] == pytest.approx(tn.ppf(0.3)) and theta[1] == pytest.approx(1.0) + assert np.all(np.isfinite(p.prior_transform([0.0, 1.0]))) + + def test_unbounded_marginal(self): + p = problem() + assert p.log_prior([1.0, 2.0]) == pytest.approx( + stats.norm(0, 5).logpdf([1.0, 2.0]).sum() + ) + u = np.array([0.1, 0.9]) + np.testing.assert_allclose(stats.norm(0, 5).cdf(p.prior_transform(u)), u) + + def test_joint_mvn_whitening(self): + model = line_model(prior=False) + mu, cov = np.array([2.0, 1.0]), np.array([[0.5, 0.2], [0.2, 0.3]]) + mvn = stats.multivariate_normal(mu, cov) + p = Problem( + [Constraint([Comparison(dataset(), model)])], priors=[(model.params, mvn)] + ) + assert p.log_prior([1.0, 1.0]) == pytest.approx(mvn.logpdf([1.0, 1.0])) + rng = np.random.default_rng(0) + draws = np.array([p.prior_transform(u) for u in rng.uniform(size=(4000, 2))]) + np.testing.assert_allclose(draws.mean(0), mu, atol=0.05) + np.testing.assert_allclose(np.cov(draws.T), cov, rtol=0.1, atol=0.03) + assert np.all(np.isfinite(p.prior_transform([0.0, 1.0]))) + us = rng.uniform(size=(5, 2)) + np.testing.assert_allclose( + p.prior_transform_batch(us), [p.prior_transform(u) for u in us] + ) + s = p.sample_prior(500, rng=1) + assert s.shape == (500, 2) and np.allclose(s.mean(0), mu, atol=0.15) + + def test_coverage_errors_name_the_parameter(self): + model = line_model(prior=False) + with pytest.raises(ValueError, match="'m' has no prior"): + Problem([Constraint([Comparison(dataset(), model)])]) + m, b = model.params + with pytest.raises(ValueError, match="'m' appears in two joint blocks"): + Problem( + [Constraint([Comparison(dataset(), model)])], + priors=[ + ([m], stats.norm()), + ([m, b], stats.multivariate_normal(np.zeros(2))), + ], + ) + model2 = line_model() # marginals set + with pytest.raises(ValueError, match="'m' has its own prior= and is also"): + Problem( + [Constraint([Comparison(dataset(), model2)])], + priors=[(model2.params, stats.multivariate_normal(np.zeros(2)))], + ) + + def test_bounded_joint_has_no_transform_but_truncates(self): + m, b = Parameter("m", bounds=(0.0, 10.0)), Parameter("b") + model = Model(lambda x, m, b: m * x + b, [m, b]) + mvn = stats.multivariate_normal(np.zeros(2), np.eye(2)) + p = Problem( + [Constraint([Comparison(dataset(), model)])], priors=[([m, b], mvn)] + ) + assert p.log_prior([-1.0, 0.0]) == -np.inf + # renormalised by the mass inside 0 <= m <= 10 + mass = stats.norm.cdf(10.0) - 0.5 + assert p.log_prior([1.0, 0.0]) == pytest.approx( + mvn.logpdf([1.0, 0.0]) - np.log(mass) + ) + with pytest.raises(NotImplementedError, match="truncated"): + p.prior_transform([0.5, 0.5]) + s = p.sample_prior(50, rng=0) # rejection sampling inside the bounds + assert np.all(s[:, 0] >= 0.0) + + def test_bounded_mvn_prior_is_renormalised_deterministically(self): + m, b = Parameter("m", bounds=(0.0, np.inf)), Parameter("b") + model = Model(lambda x, m, b: m * x + b, [m, b]) + mvn = stats.multivariate_normal(np.zeros(2), np.eye(2)) + p = Problem([Constraint([Comparison(dataset(), model)])], [([m, b], mvn)]) + # half the mass lies in m >= 0, so the density there doubles + assert p.log_prior([1.0, 0.5]) == pytest.approx( + mvn.logpdf([1.0, 0.5]) + np.log(2.0) + ) + # the box probability is quasi-Monte Carlo in 3-D: two compiles agree + t = Parameter("t", bounds=(-1.0, 1.0)) + model3 = Model(lambda x, m, b, t: m * x + b + t, [m, b, t]) + mvn3 = stats.multivariate_normal(np.zeros(3), np.eye(3) + 0.3) + c3 = Constraint([Comparison(dataset(), model3)]) + lp = [ + Problem([c3], [([m, b, t], mvn3)]).log_prior([1.0, 0.0, 0.2]) + for _ in range(2) + ] + assert lp[0] == lp[1] + + def test_custom_joint_with_prior_transform(self): + class Hier: + def logpdf(self, v): + *r, lt = v + return jst.norm.logpdf(jnp.stack(r), 0, jnp.exp(lt)).sum() + ( + jst.norm.logpdf(lt) + ) + + def prior_transform(self, u): + lt = stats.norm(0, 1).ppf(u[-1]) + return np.append(stats.norm(0, np.exp(lt)).ppf(u[:-1]), lt) + + rhos = [Parameter(f"log_rho_{i}") for i in range(2)] + log_tau = Parameter("log_tau") + model = Model(lambda x, r0, r1, lt: np.ones_like(x), rhos + [log_tau]) + p = Problem( + [Constraint([Comparison(dataset(), model)])], + priors=[(rhos + [log_tau], Hier())], + ) + theta = p.prior_transform([0.5, 0.5, 0.5]) + np.testing.assert_allclose(theta, [0.0, 0.0, 0.0], atol=1e-12) + assert np.isfinite(p.log_prior(theta)) + us = np.random.default_rng(0).uniform(size=(4, 3)) # one row at a time + np.testing.assert_allclose( + p.prior_transform_batch(us), [p.prior_transform(u) for u in us] + ) + + def test_joint_dimension_must_match_its_parameters(self): + model = line_model(prior=False) + m, b = model.params + c = Constraint([Comparison(dataset(), model)]) + mvn2 = stats.multivariate_normal([0.0, 3.0], np.diag([1.0, 4.0])) + with pytest.raises(ValueError, match=r"2-dimensional.*1 parameter"): + Problem([c], priors=[([m], mvn2), ([b], stats.norm())]) + with pytest.raises(ValueError, match="3-dimensional"): + Problem([c], priors=[([m, b], stats.multivariate_normal(np.zeros(3)))]) + with pytest.raises(ValueError, match="1-dimensional"): + Problem([c], priors=[([m, b], stats.norm())]) + + def test_one_parameter_block_of_a_univariate_is_a_marginal(self): + # the natural way to give a bounded parameter a prior + s = Parameter("scale", bounds=(1.0, np.inf)) + c = Constraint([Comparison(dataset(), line_model())], terms=[noise(s)]) + expon = stats.expon(loc=1, scale=10) + p = Problem([c], priors=[(s, expon)]) + theta = np.array([*TRUE, 4.0]) + m_b = stats.norm(0, 5).logpdf(TRUE).sum() + assert p.log_prior(theta) == pytest.approx(m_b + expon.logpdf(4.0)) + assert p.prior_transform([0.5, 0.5, 0.5])[2] == pytest.approx(expon.median()) + assert np.all(p.sample_prior(20, rng=0)[:, 2] >= 1.0) + # and truncated to the parameter's bounds + t = Parameter("t", bounds=(0.0, np.inf)) + model = Model(lambda x, t: t * x, [t]) + q = Problem([Constraint([Comparison(dataset(), model)])], [([t], stats.norm())]) + assert q.log_prior([0.5]) == pytest.approx(stats.norm.logpdf(0.5) + np.log(2)) + assert q.log_prior([-0.5]) == -np.inf + + def test_custom_joint_sampled_through_rvs(self): + class Box: + def logpdf(self, v): + return jnp.where(jnp.all((0 <= v) & (v <= 1)), 0.0, -jnp.inf) + + def rvs(self, size, random_state): + return random_state.uniform(size=(size, 2)) + + m, b = Parameter("m"), Parameter("b") + model = Model(lambda x, m, b: m * x + b, [m, b]) + p = Problem([Constraint([Comparison(dataset(), model)])], [([m, b], Box())]) + s = p.sample_prior(30, rng=0) + assert s.shape == (30, 2) and np.all((s >= 0) & (s <= 1)) + assert p.starting_location(4).shape == (4, 2) + + def test_scipy_truncnorm_prior_is_translated_to_jax(self): + tn = stats.truncnorm(-0.5, 1.5, loc=1.0, scale=2.0) + t = Parameter("t", prior=tn) + p = Problem( + [Constraint([Comparison(dataset(), Model(lambda x, t: t * x, [t]))])] + ) + for v in (0.0, 1.0, 3.9): + assert p.log_prior([v]) == pytest.approx(tn.logpdf(v)) + assert p.log_prior([-0.5]) == -np.inf and p.log_prior([4.5]) == -np.inf + + def test_a_family_without_a_jax_translation_takes_logpdf(self): + dist = stats.weibull_min(1.5, scale=2.0) + + def model(t): + return Model(lambda x, t: t * x, [t]) + + def compile_(t): + return Problem([Constraint([Comparison(dataset(), model(t))])]) + + with pytest.raises(TypeError, match="Parameter\\(..., logpdf=f\\)"): + compile_(Parameter("t", prior=dist)) + + def weibull(x, c=1.5, s=2.0): + z = jnp.where(x > 0, x / s, 1.0) + out = jnp.log(c / s) + (c - 1) * jnp.log(z) - z**c + return jnp.where(x > 0, out, -jnp.inf) + + p = compile_(Parameter("t", prior=dist, logpdf=weibull)) + for v in (0.5, 2.0, 4.0): + assert p.log_prior([v]) == pytest.approx(dist.logpdf(v)) + # the scipy distribution still drives the unit-cube map + assert p.prior_transform([0.5])[0] == pytest.approx(dist.median()) + + def test_marginal_truncated_far_in_the_upper_tail(self): + t = Parameter("t", prior=stats.norm(), bounds=(8.3, np.inf)) + model = Model(lambda x, t: t * x, [t]) + p = Problem([Constraint([Comparison(dataset(), model)])]) + tn = stats.truncnorm(8.3, np.inf) + assert p.log_prior([9.0]) == pytest.approx(tn.logpdf(9.0)) + draws = np.array([p.prior_transform([u])[0] for u in np.linspace(0, 1, 101)]) + assert np.all(draws >= 8.3) and np.all(np.diff(draws) > 0) + np.testing.assert_allclose(p.prior_transform([0.5]), tn.median()) + + def test_clip_unit_cube(self): + u = clip_unit_cube([0.0, 0.5, 1.0]) + assert 0 < u[0] < 1e-10 and u[1] == 0.5 and 1 - 1e-10 < u[2] < 1 + + +# ---------------------------------------------------------------------------- +# Compiled constraints and the flat interface +# ---------------------------------------------------------------------------- + + +class TestCompile: + def test_log_likelihood_matches_manual_mvn(self): + d = dataset() + p = problem() + theta = np.array(TRUE) + ym = TRUE[0] * d.x + TRUE[1] + assert p.log_likelihood(theta) == pytest.approx( + manual_mvn_loglike(d.y, ym, np.diag(d.y_err**2)) + ) + assert p.chi2(theta) == pytest.approx(np.sum(((d.y - ym) / d.y_err) ** 2)) + assert p.log_posterior(theta) == pytest.approx( + p.log_prior(theta) + p.log_likelihood(theta) + ) + + def test_weights_and_two_constraints(self): + model = line_model() + c1 = Constraint([Comparison(dataset(0, label="a"), model)], weight=0.5) + c2 = Constraint([Comparison(dataset(1, label="b"), model)], weight=2.0) + p = Problem([c1, c2]) + theta = np.array(TRUE) + assert p.log_likelihood(theta) == pytest.approx( + 0.5 * p.constraints[0].log_likelihood(theta) + + 2.0 * p.constraints[1].log_likelihood(theta) + ) + + def test_prior_first_skips_the_forward_model(self): + calls = [] + m = Parameter("m", bounds=(0.0, 5.0)) + b = Parameter("b", bounds=(0.0, 5.0)) + + def fn(x, m, b): + # counts evaluations at run time (a plain append would count traces) + jax.debug.callback(lambda: calls.append(1)) + return m * x + b + + p = Problem([Constraint([Comparison(dataset(), Model(fn, [m, b]))])]) + assert p.log_posterior([-1.0, 1.0]) == -np.inf + assert calls == [] + p.log_posterior([1.0, 1.0]) + assert calls == [1] + + def test_non_finite_prediction(self): + d = dataset() + p = Problem([Constraint([Comparison(d, line_model(), space=log)])]) + theta = np.array([-5.0, 0.0]) # negative prediction under log + assert p.log_likelihood(theta) == -np.inf and p.chi2(theta) == np.inf + + def test_non_positive_data_under_log_named_unless_masked(self): + d = Dataset(X[:3], [1.0, -1.0, 2.0], [0.1, 0.1, 0.1], label="neg") + c = Constraint([Comparison(d, line_model(), space=log)]) + with pytest.raises(ValueError, match="'neg'.*not finite"): + Problem([c]) + Problem([c.masked([np.array([True, False, True])])]) # fine + + def test_meta_reaches_terms(self): + seen = {} + + def fn(c): + seen["E"], seen["w"], seen["r"] = ( + c.meta("Elab"), + c.meta("w"), + c.meta("reaction"), + ) + return np.ones(len(c)) + + model = line_model() + d1 = Dataset( + X[:2], + [1.0, 2.0], + [0.1, 0.1], + meta={"Elab": 10.0, "w": [1.0, 2.0], "reaction": "n+Ca"}, + ) + d2 = Dataset( + X[:3], + [1.0, 2.0, 3.0], + [0.1, 0.1, 0.1], + meta={"Elab": 20.0, "w": [3.0, 4.0, 5.0]}, + ) + c = Constraint( + [Comparison(d1, model), Comparison(d2, model)], + terms=[Term(fn, kind="diag", constant=True)], + ) + Problem([c]) + np.testing.assert_allclose(seen["E"], [10, 10, 20, 20, 20]) + np.testing.assert_allclose(seen["w"], [1, 2, 3, 4, 5]) + assert list(seen["r"]) == ["n+Ca", "n+Ca", None, None, None] + + def test_singular_covariance_names_the_comparison(self): + d = Dataset(X[:3], [1.0, 2.0, 3.0], np.zeros(3), label="E1234-002") + with pytest.raises(ValueError, match="E1234-002.*reported_terms"): + Problem([Constraint([Comparison(d, line_model())])]) + eps = Parameter("log_eps", prior=stats.norm()) + Problem( + [Constraint([Comparison(d, line_model())], terms=[noise(eps)])] + ) # parametric: fine + + def test_parametric_covariance_singular_at_theta_is_zero_density(self): + d = Dataset(X[:3], [1.0, 2.0, 3.0], np.zeros(3), label="exact") + eps = Parameter("log_eps", prior=stats.norm()) + p = Problem([Constraint([Comparison(d, line_model())], terms=[noise(eps)])]) + theta = np.array([*TRUE, -400.0]) # exp(-400)**2 underflows to zero + assert p.log_likelihood(theta) == -np.inf and p.chi2(theta) == np.inf + assert p.log_posterior(theta) == -np.inf + assert np.isfinite(p.log_likelihood([*TRUE, np.log(0.1)])) + + def test_prediction_shape_checked_per_comparison(self): + # two x-ignoring models that return each other's lengths + s = Parameter("s", prior=stats.norm()) + c = Constraint( + [ + Comparison( + dataset(0, 3, "short"), Model(lambda x, s: s * np.ones(5), [s]) + ), + Comparison( + dataset(1, 5, "long"), Model(lambda x, s: s * np.ones(3), [s]) + ), + ] + ) + with pytest.raises(ValueError, match=r"'short'.*shape \(5,\).*3 point"): + Problem([c]).log_likelihood([1.0]) + + def test_log_jacobian_carries_the_weights(self): + model = line_model() + tempered = Constraint( + [Comparison(dataset(0, label="a"), model, space=log)], weight=0.5 + ) + spare = Constraint( + [Comparison(dataset(1, label="b"), model, space=log)], weight=0.0 + ) + lj = tempered.log_jacobian + assert Problem([tempered]).log_jacobian() == pytest.approx(0.5 * lj) + assert Problem([tempered, spare]).log_jacobian() == pytest.approx(0.5 * lj) + + def test_constant_singular_block_fails_at_compile_beside_a_parametric_one(self): + model, eps = line_model(), Parameter("log_eps", prior=stats.norm()) + cg = Comparison(dataset(0, 3, "noisy"), model) + exact = Dataset( + X[:3], [1.0, 2.0, 3.0], np.zeros(3), norm_err=0.05, label="E1234-002" + ) + cz = Comparison(exact, model) + terms = [noise(eps, on=cg)] + cz.reported_terms() + with pytest.raises(ValueError, match="E1234-002") as err: + Problem([Constraint([cg, cz], terms=terms)]) + assert "noisy" not in str(err.value) + + def test_kernel_jitter_scales_with_the_data(self): + # scaling the data, and the amplitude with it, by s shifts ll by exactly + # -n log s: the nugget must be relative, not an absolute 1e-10 + from tinygp.kernels import ExpSquared + + s, d = 1e-4, dataset() + lls = [] + for k in (1.0, s): + m, b = ( + Parameter("m", prior=stats.norm()), + Parameter("b", prior=stats.norm()), + ) + lA = Parameter("log_A", prior=stats.norm()) + model = Model(lambda x, m, b, k=k: k * (m * x + b), [m, b]) + data = Dataset(d.x, k * d.y, k * d.y_err) + gp = kernel( + ExpSquared(0.5), amplitude=constant_amplitude, amplitude_params=(lA,) + ) + p = Problem([Constraint([Comparison(data, model)], terms=[gp])]) + lls.append(p.log_likelihood([*TRUE, np.log(0.3 * k)])) + assert lls[1] - lls[0] == pytest.approx(-d.n * np.log(s), rel=1e-9) + + def test_metadata_tuples_and_0d_arrays_stack(self): + seen = {} + + def fn(c): + seen["E"], seen["t"] = c.meta("Elab"), c.meta("target") + return 0.01 * np.sqrt(c.meta("Elab")) + + meta = {"target": (48, 20), "Elab": np.array(14.0)} + d = Dataset(X, dataset().y, 0.1 * np.ones(6), meta=meta) + term = Term(fn, kind="diag", constant=True) + p = Problem([Constraint([Comparison(d, line_model())], terms=[term])]) + assert np.isfinite(p.log_likelihood(TRUE)) + assert seen["E"].dtype == float and np.allclose(seen["E"], 14.0) + assert all(t == (48, 20) for t in seen["t"]) + + def test_predict_and_matrix(self): + d = dataset() + p = Problem( + [ + Constraint( + [Comparison(d, line_model(), space=log)], + terms=[offset(magnitude=0.05)], # a log-space normalisation + ) + ] + ) + theta = np.array(TRUE) + ((pred,),) = p.predict(theta) + np.testing.assert_allclose(pred, np.log(TRUE[0] * d.x + TRUE[1])) + ((phys,),) = p.predict(theta, physical=True) + np.testing.assert_allclose(phys, TRUE[0] * d.x + TRUE[1]) + S = p.constraints[0].matrix(theta) + assert S.shape == (6, 6) and np.all(np.linalg.eigvalsh(S) > 0) + + def test_theta_shape_checked(self): + with pytest.raises(ValueError, match="shape"): + problem().log_posterior([1.0]) + + +class TestViews: + def test_masked_views_share_columns_and_partition(self): + d = dataset() + eps = Parameter("log_eps", prior=stats.norm()) + c = Constraint([Comparison(d, line_model())], terms=[noise(eps)]) + fit, held = ( + c.masked_where(lambda x: x < 1.0), + c.masked_where(lambda x: x < 1.0).complement(), + ) + pf, ph, pa = Problem([fit]), Problem([held]), Problem([c]) + assert pf.names == ph.names == pa.names + theta = np.array([*TRUE, np.log(0.2)]) + assert pf.log_likelihood(theta) + ph.log_likelihood(theta) == pytest.approx( + pa.log_likelihood(theta) + ) + + def test_rows_active_in_two_weighted_constraints_warn(self): + c = Constraint([Comparison(dataset(), line_model())]) + with pytest.warns( + UserWarning, match="'d' has rows active in constraints 0 and 1" + ): + Problem([c, c]) + fit = c.masked_where(lambda x: x < 1.0) + with warnings.catch_warnings(): + warnings.simplefilter("error") + Problem([fit, fit.complement()]) # disjoint rows + Problem([c, replace(c, weight=0.0)]) # a weight-0 monitor + + def test_parameter_on_fully_masked_comparison_keeps_its_slot(self): + model = line_model() + rho1, rho2 = ( + Parameter("log_rho_1", prior=stats.norm(0, 0.1)), + Parameter("log_rho_2", prior=stats.norm(0, 0.1)), + ) + c1, c2 = ( + Comparison(dataset(0, label="a"), model | scale(rho1)), + Comparison(dataset(1, label="b"), model | scale(rho2)), + ) + c = Constraint([c1, c2]).masked([np.ones(6, bool), np.zeros(6, bool)]) + p = Problem([c]) + assert p.names == ["m", "b", "log_rho_1", "log_rho_2"] + assert np.isfinite(p.log_prior([*TRUE, 0.0, 0.0])) + s = p.sample_prior(10, rng=0) + assert s.shape == (10, 4) and np.std(s[:, 3]) > 0 + + +# ---------------------------------------------------------------------------- +# Drivers +# ---------------------------------------------------------------------------- + + +class TestDrivers: + def test_emcee_recovers_the_line(self): + p = problem() + rng = np.random.default_rng(0) + p0 = p.sample_prior(16, rng=rng) * 0.05 + np.array(TRUE) + sampler = emcee.EnsembleSampler(16, p.ndim, p.log_posterior) + sampler.random_state = np.random.RandomState(0).get_state() + sampler.run_mcmc(p0, 150, progress=False) + chain = sampler.get_chain(discard=50, flat=True) + assert abs(chain[:, 0].mean() - TRUE[0]) < 3 * chain[:, 0].std() + 0.05 + + def test_dynesty_runs(self): + p = problem() + ns = dynesty.NestedSampler( + p.log_likelihood, + p.prior_transform, + p.ndim, + nlive=50, + rstate=np.random.default_rng(0), + ) + ns.run_nested(dlogz=1.0, print_progress=False) + assert np.isfinite(ns.results.logz[-1]) + + def test_dill_round_trip(self): + p = problem() + q = dill.loads(dill.dumps(p)) + theta = np.array(TRUE) + assert q.names == p.names + assert q.log_posterior(theta) == pytest.approx(p.log_posterior(theta)) + assert p.NDIM == p.ndim and p.parameter_names == p.names + assert p.starting_location(3).shape == (3, 2) + np.testing.assert_allclose( + p.log_posterior_batch([theta, theta]), [p.log_posterior(theta)] * 2 + ) + np.testing.assert_allclose( + q.log_likelihood_batch([theta]), [p.log_likelihood(theta)] + ) + + def test_batch_siblings_match_their_single_point_versions(self): + m = Parameter("m", prior=stats.norm(0, 2), bounds=(-1.0, 3.0)) + b = Parameter("b", bounds=(0.0, 4.0)) + model = Model(lambda x, m, b: m * x + b, [m, b]) + p = Problem([Constraint([Comparison(dataset(), model)])]) + us = np.random.default_rng(0).uniform(size=(6, 2)) + thetas = p.prior_transform_batch(us) + np.testing.assert_allclose(thetas, [p.prior_transform(u) for u in us]) + outside = np.vstack([thetas, [[5.0, 1.0]]]) # m beyond its bound + np.testing.assert_allclose( + p.log_prior_batch(outside), [p.log_prior(t) for t in outside] + ) + # the likelihood is evaluated on every row, the prior notwithstanding + np.testing.assert_allclose( + p.log_likelihood_batch(outside), [p.log_likelihood(t) for t in outside] + ) + for fn in (p.log_prior_batch, p.log_likelihood_batch, p.prior_transform_batch): + with pytest.raises(ValueError, match=r"shape \(n, 2\)"): + fn([0.5, 0.5]) + + def test_batch_densities_evaluate_in_chunks(self, monkeypatch): + import rxmc.problem + + monkeypatch.setattr(rxmc.problem, "BATCH_CHUNK", 4) # 10 rows: 4 + 4 + 2 + p = problem() + thetas = p.sample_prior(10, rng=0) + np.testing.assert_allclose( + p.log_posterior_batch(thetas), [p.log_posterior(t) for t in thetas] + ) + assert p.log_likelihood_batch(np.empty((0, 2))).shape == (0,) + + def test_kernel_and_offset_terms_pickle(self): + eps = Parameter("log_A", prior=stats.norm()) + from tinygp.kernels import ExpSquared + + c = Constraint( + [Comparison(dataset(), line_model())], + terms=[ + kernel( + lambda le: ExpSquared(jnp.exp(le)), + [Parameter("ell", prior=stats.norm())], + ), + offset(parameter=eps), + statistical(np.ones(6)), + ], + ) + p = Problem([c]) + q = dill.loads(dill.dumps(p)) + theta = np.array([*TRUE, 0.0, -1.0]) + assert q.log_posterior(theta) == pytest.approx(p.log_posterior(theta)) diff --git a/test/test_proposal.py b/test/test_proposal.py deleted file mode 100644 index 7922355..0000000 --- a/test/test_proposal.py +++ /dev/null @@ -1,64 +0,0 @@ -import unittest - -import numpy as np -from numpy.random import default_rng - -from rxmc.proposal import ( - HalfNormalProposalDistribution, - LogspaceNormalProposalDistribution, - NormalProposalDistribution, - ProposalDistribution, -) - - -class TestProposalDistributions(unittest.TestCase): - def setUp(self): - # Set up a random number generator - self.rng = default_rng(42) - self.current_sample = np.array([1.0, 2.0, 3.0]) - self.scale = 1.0 - self.cov = np.eye(3) - - def test_normal_proposal_distribution(self): - normal_proposal = NormalProposalDistribution(cov=self.cov) - proposed_sample = normal_proposal(self.current_sample, self.rng) - - # Check the output is of correct shape - self.assertEqual(proposed_sample.shape, self.current_sample.shape) - - # Check the mean and covariance of the distribution approximately match the expected - samples = [normal_proposal(self.current_sample, self.rng) for _ in range(10000)] - samples_mean = np.mean(samples, axis=0) - samples_cov = np.cov(np.array(samples).T) - - self.assertTrue(np.allclose(samples_mean, self.current_sample, atol=0.1)) - self.assertTrue(np.allclose(samples_cov, self.cov, atol=0.1)) - - def test_half_normal_proposal_distribution(self): - half_normal_proposal = HalfNormalProposalDistribution(scale=self.scale) - proposed_sample = half_normal_proposal(self.current_sample, self.rng) - - # Check the output is of correct shape - self.assertEqual(proposed_sample.shape, self.current_sample.shape) - - # Check that all values in proposed_sample are non-negative - self.assertTrue(np.all(proposed_sample >= 0)) - - def test_logspace_normal_proposal_distribution(self): - logspace_normal_proposal = LogspaceNormalProposalDistribution(scale=self.scale) - proposed_sample = logspace_normal_proposal(self.current_sample, self.rng) - - # Check the output is of correct shape - self.assertEqual(proposed_sample.shape, self.current_sample.shape) - - # Check that all values in proposed_sample are strictly positive - self.assertTrue(np.all(proposed_sample > 0)) - - def test_proposal_distribution_not_implemented(self): - with self.assertRaises(NotImplementedError): - proposal = ProposalDistribution() - proposal(self.current_sample, self.rng) - - -if __name__ == "__main__": - unittest.main() diff --git a/test/test_reaction_models.py b/test/test_reaction_models.py deleted file mode 100644 index 964d89b..0000000 --- a/test/test_reaction_models.py +++ /dev/null @@ -1,158 +0,0 @@ -"""Real-solver smoke tests for the jitr-backed reaction models. - -These are the only tests that exercise the actual solver pipeline -(everything else mocks ``set_up_solver``); they pin output shape, -finiteness, and positivity with deliberately small solver settings. -""" - -import unittest - -import jitr -import numpy as np -from jitr.optical_potentials.potential_forms import ( - coulomb_charged_sphere, - thomas_safe, - woods_saxon_safe, -) - -from rxmc.elastic_diffxs_model import ElasticDifferentialXSModel -from rxmc.elastic_diffxs_observation import ElasticDifferentialXSObservation -from rxmc.ias_pn_model import IsobaricAnalogPNXSModel -from rxmc.ias_pn_observation import IsobaricAnalogPNObservation -from rxmc.params import Parameter - -MSO = 1.0 / jitr.utils.constants.WAVENUMBER_PION - - -def central(r, Vv, Wv, Rv, av): - return -(Vv + 1j * Wv) * woods_saxon_safe(r, Rv, av) - - -def spin_orbit(r, Vso, Rso, aso): - return Vso * MSO**2 * thomas_safe(r, Rso, aso) - - -class TestElasticDifferentialXSModel(unittest.TestCase): - def test_evaluate_and_visualization_smoke(self): - R = 1.2 * 40 ** (1 / 3) - rxn = jitr.reactions.ElasticReaction(target=(40, 20), projectile=(1, 0)) - model = ElasticDifferentialXSModel( - "dXS/dA", - interaction_central=central, - interaction_spin_orbit=spin_orbit, - calculate_interaction_from_params=lambda ws, *x: ( - tuple(x), - (6.0, R, 0.45), - ), - params=[Parameter(n) for n in ("Vv", "Wv", "Rv", "av")], - ) - obs = ElasticDifferentialXSObservation( - x=np.linspace(10.0, 150.0, 6), - y=np.ones(6), - Elab=14.1, - reaction=rxn, - quantity="dXS/dA", - measurement_quantity="dXS/dA", - y_units="barn / steradian", - lmax=10, - ) - - y = model.evaluate(obs, 48.0, 3.5, R, 0.7) - self.assertEqual(y.shape, (obs.n_data_pts,)) - self.assertTrue(np.all(np.isfinite(y))) - self.assertTrue(np.all(y > 0)) - - y_vis = model.visualizable_model_prediction(obs, 48.0, 3.5, R, 0.7) - self.assertEqual(y_vis.shape, obs.visualization_workspace.angles.shape) - self.assertTrue(np.all(np.isfinite(y_vis))) - - -class TestIsobaricAnalogPNXSModel(unittest.TestCase): - def test_evaluate_and_visualization_smoke(self): - A, Z = 48, 20 - R = 1.2 * A ** (1 / 3) - rxn = jitr.reactions.Reaction( - target=(A, Z), - projectile=(1, 1), - product=(1, 0), - residual=(A, Z + 1), - ) - model = IsobaricAnalogPNXSModel( - U_p_coulomb=coulomb_charged_sphere, - U_p_central=central, - U_p_spin_orbit=spin_orbit, - U_n_central=central, - U_n_spin_orbit=spin_orbit, - # the (p,n) IAS transition is driven by the *difference* between - # the proton and neutron potentials (the Lane term) — make them - # distinct or the cross section vanishes - calculate_params=lambda ws, Vv, Wv, Rv, av: ( - (Z, R), # p Coulomb: zz product, charge radius - (Vv + 4.0, Wv, Rv, av), # p central - (6.0, R, 0.45), # p spin-orbit - (Vv - 4.0, Wv, Rv, av), # n central - (6.0, R, 0.45), # n spin-orbit - ), - params=[Parameter(n) for n in ("Vv", "Wv", "Rv", "av")], - ) - obs = IsobaricAnalogPNObservation( - x=np.linspace(10.0, 150.0, 5), - y=np.ones(5), - Elab=25.0, - reaction=rxn, - ExIAS=6.7, - y_units="barn / steradian", - lmax=10, - ) - - y = model.evaluate(obs, 48.0, 3.5, R, 0.7) - self.assertEqual(y.shape, (obs.n_data_pts,)) - self.assertTrue(np.all(np.isfinite(y))) - self.assertTrue(np.all(y >= 0)) - self.assertGreater(y.max(), 0) - - y_vis = model.visualizable_model_prediction(obs, 48.0, 3.5, R, 0.7) - self.assertEqual(y_vis.shape, obs.visualization_workspace.angles.shape) - self.assertTrue(np.all(np.isfinite(y_vis))) - - -class TestObservationTypeChecks(unittest.TestCase): - """A reaction model refuses an observation of the wrong class up front - (no solver is touched, so these need no jitr workspace).""" - - def setUp(self): - from rxmc.observation import Observation - - self.plain = Observation(x=np.array([0.1, 0.2]), y=np.array([1.0, 1.0])) - self.elastic = ElasticDifferentialXSModel( - "dXS/dA", - interaction_central=central, - interaction_spin_orbit=spin_orbit, - calculate_interaction_from_params=lambda ws, *x: (tuple(x), ()), - params=[Parameter("Vv")], - ) - self.ias = IsobaricAnalogPNXSModel( - U_p_coulomb=coulomb_charged_sphere, - U_p_central=central, - U_p_spin_orbit=spin_orbit, - U_n_central=central, - U_n_spin_orbit=spin_orbit, - calculate_params=lambda ws, *x: ((), (), (), (), ()), - params=[Parameter("Vv")], - ) - - def test_elastic_model_rejects_foreign_observation(self): - with self.assertRaisesRegex(ValueError, "ElasticDifferentialXSObservation"): - self.elastic.evaluate(self.plain, 1.0) - with self.assertRaisesRegex(ValueError, "ElasticDifferentialXSObservation"): - self.elastic.visualizable_model_prediction(self.plain, 1.0) - - def test_ias_model_rejects_foreign_observation(self): - with self.assertRaisesRegex(ValueError, "IsobaricAnalogPNObservation"): - self.ias.evaluate(self.plain, 1.0) - with self.assertRaisesRegex(ValueError, "IsobaricAnalogPNObservation"): - self.ias.visualizable_model_prediction(self.plain, 1.0) - - -if __name__ == "__main__": - unittest.main() diff --git a/test/test_reaction_observation.py b/test/test_reaction_observation.py deleted file mode 100644 index d104567..0000000 --- a/test/test_reaction_observation.py +++ /dev/null @@ -1,422 +0,0 @@ -import unittest -from types import SimpleNamespace -from unittest.mock import patch - -import numpy as np - -from rxmc.elastic_diffxs_observation import ElasticDifferentialXSObservation -from rxmc.ias_pn_observation import IsobaricAnalogPNObservation -from rxmc.observation import Observation -from rxmc.transforms import log - - -def make_measurement(**overrides): - """A minimal ``exfor_tools``-like Distribution stub.""" - fields = dict( - x=np.array([20.0, 40.0]), - y=np.array([2.0, 1.0]), - Einc=8.0, - quantity="dXS/dA", - y_units="barn / steradian", - statistical_err=np.array([0.2, 0.1]), - systematic_norm_err=0.03, - systematic_offset_err=0.02, - subentry="subentry", - ) - fields.update(overrides) - return SimpleNamespace(**fields) - - -class DummyElasticWorkspace: - def __init__(self, rutherford=1.0): - self.rutherford = rutherford - - -class TestElasticDifferentialXSObservation(unittest.TestCase): - @patch("rxmc.elastic_diffxs_observation.set_up_solver") - def test_direct_construction_from_explicit_data(self, mock_set_up_solver): - mock_set_up_solver.return_value = ( - DummyElasticWorkspace(), - DummyElasticWorkspace(), - object(), - ) - - angles_deg = np.array([15.0, 30.0, 45.0]) - y = np.array([1.2, 0.8, 0.4]) - y_stat_err = np.array([0.1, 0.1, 0.1]) - - obs = ElasticDifferentialXSObservation( - x=angles_deg, - y=y, - Elab=12.0, - reaction=object(), - quantity="dXS/dA", - measurement_quantity="dXS/dA", - y_units="barn / steradian", - y_stat_err=y_stat_err, - dataset_label="mock-elastic", - ) - - # it IS an Observation (statistical error only); systematics are composed - # as Constraint extra_terms by the caller - self.assertIsInstance(obs, Observation) - np.testing.assert_allclose(obs.x, np.deg2rad(angles_deg)) - np.testing.assert_allclose(obs.y, y) - np.testing.assert_allclose(obs.y_stat_err, y_stat_err) - self.assertEqual(obs.subentry, "mock-elastic") - self.assertIsNotNone(obs.statistical_term(np.arange(obs.n_data_pts))) - - @patch("rxmc.elastic_diffxs_observation.set_up_solver") - def test_from_measurement_construction(self, mock_set_up_solver): - mock_set_up_solver.return_value = ( - DummyElasticWorkspace(), - DummyElasticWorkspace(), - object(), - ) - - measurement = make_measurement(subentry="elastic-subentry") - - obs = ElasticDifferentialXSObservation.from_measurement( - measurement=measurement, - reaction=object(), - quantity="dXS/dA", - ) - - np.testing.assert_allclose(obs.x, np.deg2rad(measurement.x)) - np.testing.assert_allclose(obs.y, measurement.y) - np.testing.assert_allclose(obs.y_stat_err, measurement.statistical_err) - self.assertEqual(obs.subentry, "elastic-subentry") - # systematics are retained as inert metadata (norm == 1 here: b/sr) - self.assertEqual(obs.norm, 1.0) - self.assertEqual(obs.y_sys_err_normalization, 0.03) - self.assertEqual(obs.y_sys_err_offset, 0.02) - self.assertEqual(len(obs.systematic_terms(np.arange(obs.n_data_pts))), 2) - - @patch("rxmc.elastic_diffxs_observation.set_up_solver") - def test_from_measurement_forwards_transform_and_mask(self, mock_set_up_solver): - mock_set_up_solver.return_value = ( - DummyElasticWorkspace(), - DummyElasticWorkspace(), - object(), - ) - measurement = make_measurement( - systematic_norm_err=None, - systematic_offset_err=None, - subentry="elastic-subentry", - ) - mask = np.array([True, False]) - obs = ElasticDifferentialXSObservation.from_measurement( - measurement=measurement, - reaction=object(), - quantity="dXS/dA", - transform=log, - mask=mask, - ) - self.assertIs(obs.transform, log) - np.testing.assert_allclose(obs.y, np.log(measurement.y)) - np.testing.assert_array_equal(obs.mask, mask) - - @patch("rxmc.elastic_diffxs_observation.set_up_solver") - def test_from_measurement_rutherford_array_norm(self, mock_set_up_solver): - # dXS/dRuth requested from a dXS/dA measurement: norm is the per-angle - # Rutherford cross section, so the absolute offset error becomes a - # per-angle array in internal units, while the fractional normalization - # error is untouched - rutherford = np.array([2000.0, 500.0]) # mb/sr - mock_set_up_solver.return_value = ( - DummyElasticWorkspace(rutherford=rutherford), - DummyElasticWorkspace(rutherford=rutherford), - object(), - ) - - measurement = make_measurement( - y=np.array([1800.0, 300.0]), - y_units="mb/sr", - statistical_err=np.array([20.0, 10.0]), - systematic_offset_err=5.0, # mb/sr - subentry="ruth-subentry", - ) - - obs = ElasticDifferentialXSObservation.from_measurement( - measurement=measurement, - reaction=object(), - quantity="dXS/dRuth", - ) - - np.testing.assert_allclose(obs.norm, rutherford) - np.testing.assert_allclose(obs.y, measurement.y / rutherford) - np.testing.assert_allclose( - obs.y_stat_err, measurement.statistical_err / rutherford - ) - np.testing.assert_allclose(obs.y_sys_err_offset, 5.0 / rutherford) - self.assertEqual(obs.y_sys_err_normalization, 0.03) - - # reaction-level regression: statistical + systematic terms recover the - # old auto-folded covariance, in internal (normalized) units - support = np.arange(2) - from helpers import make_ctx - from rxmc.covariance import ConstraintCovariance - - ym = np.array([0.9, 0.6]) - cov = ConstraintCovariance( - [obs.statistical_term(support), *obs.systematic_terms(support)], N=2 - ) - S = cov.matrix(make_ctx(obs.x, obs.y, ym, [support])) - omega = 5.0 / rutherford - old = ( - np.diag((measurement.statistical_err / rutherford) ** 2) - + np.outer(omega, omega) - + 0.03**2 * np.outer(ym, ym) - ) - np.testing.assert_allclose(S, old) - - @patch("rxmc.elastic_diffxs_observation.set_up_solver") - def test_dxsda_from_dxsdruth_conversion(self, mock_set_up_solver): - # the inverse branch: absolute dXS/dA requested from a Rutherford-ratio - # measurement; norm = (1/mb->b) / rutherford, so obs.y is b/sr - rutherford = np.array([2000.0, 500.0]) # mb/sr - mock_set_up_solver.return_value = ( - DummyElasticWorkspace(rutherford=rutherford), - DummyElasticWorkspace(rutherford=rutherford), - object(), - ) - - y_ratio = np.array([0.9, 0.6]) # dimensionless dXS/dRuth - obs = ElasticDifferentialXSObservation( - x=np.array([20.0, 40.0]), - y=y_ratio, - Elab=8.0, - reaction=object(), - quantity="dXS/dA", - measurement_quantity="dXS/dRuth", - y_units="no-dim", - ) - - np.testing.assert_allclose(obs.norm, 1000.0 / rutherford) - # y_ratio * rutherford[mb/sr] / 1000 = absolute xs in b/sr - np.testing.assert_allclose(obs.y, y_ratio * rutherford / 1000.0) - - @patch("rxmc.elastic_diffxs_observation.set_up_solver") - def test_incompatible_units_raise(self, mock_set_up_solver): - mock_set_up_solver.return_value = ( - DummyElasticWorkspace(), - DummyElasticWorkspace(), - object(), - ) - # dXS/dA measurement with non-cross-section units - with self.assertRaises(ValueError): - ElasticDifferentialXSObservation( - x=np.array([15.0, 30.0]), - y=np.array([1.0, 0.5]), - Elab=12.0, - reaction=object(), - quantity="dXS/dA", - measurement_quantity="dXS/dA", - y_units="MeV", - ) - # dimensionless quantity with dimensionful units - with self.assertRaises(ValueError): - ElasticDifferentialXSObservation( - x=np.array([15.0, 30.0]), - y=np.array([1.0, 0.5]), - Elab=12.0, - reaction=object(), - quantity="Ay", - measurement_quantity="Ay", - y_units="mb/sr", - ) - - @patch("rxmc.elastic_diffxs_observation.set_up_solver") - def test_quantity_mismatch_raises(self, mock_set_up_solver): - mock_set_up_solver.return_value = ( - DummyElasticWorkspace(), - DummyElasticWorkspace(), - object(), - ) - with self.assertRaises(ValueError): - ElasticDifferentialXSObservation( - x=np.array([15.0, 30.0]), - y=np.array([1.0, 0.5]), - Elab=12.0, - reaction=object(), - quantity="Ay", - measurement_quantity="dXS/dA", - y_units="barn / steradian", - ) - - -class TestIsobaricAnalogPNObservation(unittest.TestCase): - @patch("rxmc.ias_pn_observation.set_up_solver") - def test_direct_construction_from_explicit_data(self, mock_set_up_solver): - mock_set_up_solver.return_value = (object(), object(), object(), object()) - - angles_deg = np.array([10.0, 25.0, 50.0]) - y = np.array([0.4, 0.3, 0.2]) - y_stat_err = np.array([0.05, 0.05, 0.05]) - - obs = IsobaricAnalogPNObservation( - x=angles_deg, - y=y, - Elab=30.0, - reaction=object(), - ExIAS=5.0, - y_units="barn / steradian", - y_stat_err=y_stat_err, - dataset_label="mock-ias", - ) - - self.assertIsInstance(obs, Observation) - np.testing.assert_allclose(obs.x, np.deg2rad(angles_deg)) - np.testing.assert_allclose(obs.y, y) - np.testing.assert_allclose(obs.y_stat_err, y_stat_err) - self.assertEqual(obs.subentry, "mock-ias") - - @patch("rxmc.ias_pn_observation.set_up_solver") - def test_from_measurement_construction(self, mock_set_up_solver): - mock_set_up_solver.return_value = (object(), object(), object(), object()) - - measurement = make_measurement( - x=np.array([5.0, 15.0]), - y=np.array([0.9, 0.7]), - Einc=18.0, - statistical_err=np.array([0.08, 0.07]), - systematic_norm_err=0.02, - systematic_offset_err=0.01, - subentry="ias-subentry", - ) - - obs = IsobaricAnalogPNObservation.from_measurement( - measurement=measurement, - reaction=object(), - ExIAS=4.5, - ) - - np.testing.assert_allclose(obs.x, np.deg2rad(measurement.x)) - np.testing.assert_allclose(obs.y, measurement.y) - np.testing.assert_allclose(obs.y_stat_err, measurement.statistical_err) - self.assertEqual(obs.subentry, "ias-subentry") - # systematics retained; norm == 1 (measurement already in b/sr) - self.assertEqual(obs.norm, 1.0) - self.assertEqual(obs.y_sys_err_normalization, 0.02) - self.assertEqual(obs.y_sys_err_offset, 0.01) - self.assertEqual(len(obs.systematic_terms(np.arange(obs.n_data_pts))), 2) - - @patch("rxmc.ias_pn_observation.set_up_solver") - def test_from_measurement_forwards_transform_and_mask(self, mock_set_up_solver): - mock_set_up_solver.return_value = (object(), object(), object(), object()) - measurement = make_measurement( - x=np.array([5.0, 15.0]), - y=np.array([0.9, 0.7]), - Einc=18.0, - statistical_err=np.array([0.08, 0.07]), - systematic_norm_err=None, - systematic_offset_err=None, - subentry="ias-subentry", - ) - mask = np.array([False, True]) - obs = IsobaricAnalogPNObservation.from_measurement( - measurement=measurement, - reaction=object(), - ExIAS=4.5, - transform=log, - mask=mask, - ) - self.assertIs(obs.transform, log) - np.testing.assert_allclose(obs.y, np.log(measurement.y)) - np.testing.assert_array_equal(obs.mask, mask) - - @patch("rxmc.ias_pn_observation.set_up_solver") - def test_unit_conversion_divides_offset_not_normalization(self, mock_set_up_solver): - mock_set_up_solver.return_value = (object(), object(), object(), object()) - - obs = IsobaricAnalogPNObservation( - x=np.array([5.0, 15.0]), - y=np.array([900.0, 700.0]), - Elab=18.0, - reaction=object(), - ExIAS=4.5, - y_units="millibarn / steradian", - y_stat_err=np.array([80.0, 70.0]), - y_sys_err_normalization=0.02, - y_sys_err_offset=10.0, - ) - # mb -> b: norm = 1000 - self.assertEqual(obs.norm, 1000.0) - np.testing.assert_allclose(obs.y, [0.9, 0.7]) - np.testing.assert_allclose(obs.y_stat_err, [0.08, 0.07]) - self.assertAlmostEqual(obs.y_sys_err_offset, 0.01) - self.assertEqual(obs.y_sys_err_normalization, 0.02) - - -class TestSolverSettingsForwarding(unittest.TestCase): - """The basis-size settings must reach ``set_up_solver`` on both classes.""" - - @patch("rxmc.elastic_diffxs_observation.set_up_solver") - def test_elastic_forwards_solver_settings(self, mock_set_up_solver): - mock_set_up_solver.return_value = ( - DummyElasticWorkspace(), - DummyElasticWorkspace(), - object(), - ) - ElasticDifferentialXSObservation( - x=np.array([15.0, 30.0]), - y=np.array([1.0, 0.5]), - Elab=12.0, - reaction=object(), - quantity="dXS/dA", - measurement_quantity="dXS/dA", - y_units="barn / steradian", - lmax=7, - wavelengths_beyond_range=3.5, - zeros_per_node=9, - ) - kwargs = mock_set_up_solver.call_args.kwargs - self.assertEqual(kwargs["lmax"], 7) - self.assertEqual(kwargs["wavelengths_beyond_range"], 3.5) - self.assertEqual(kwargs["zeros_per_node"], 9) - - @patch("rxmc.ias_pn_observation.set_up_solver") - def test_ias_forwards_solver_settings(self, mock_set_up_solver): - mock_set_up_solver.return_value = (object(), object(), object(), object()) - IsobaricAnalogPNObservation( - x=np.array([10.0, 25.0]), - y=np.array([0.4, 0.3]), - Elab=30.0, - reaction=object(), - ExIAS=5.0, - y_units="barn / steradian", - lmax=7, - wavelengths_beyond_range=3.5, - zeros_per_node=9, - ) - kwargs = mock_set_up_solver.call_args.kwargs - self.assertEqual(kwargs["lmax"], 7) - self.assertEqual(kwargs["wavelengths_beyond_range"], 3.5) - self.assertEqual(kwargs["zeros_per_node"], 9) - - -class TestSharedUnits(unittest.TestCase): - def test_one_unit_registry(self): - import rxmc.elastic_diffxs_observation as elastic - import rxmc.ias_pn_observation as ias - from rxmc.observation_from_measurement import ureg - - self.assertIs(elastic.ureg, ureg) - self.assertIs(ias.ureg, ureg) - self.assertEqual(elastic.DEFAULT_LMAX, ias.DEFAULT_LMAX) - - def test_unit_constants_agree(self): - from rxmc.observation_from_measurement import ( - MB_PER_B, - RUTHERFORD_UNIT, - XS_UNIT, - ureg, - ) - - self.assertEqual(MB_PER_B, 1000.0) - self.assertEqual((1 * XS_UNIT).to(RUTHERFORD_UNIT).magnitude, MB_PER_B) - self.assertTrue((1 * ureg("mb/sr")).check(XS_UNIT)) - - -if __name__ == "__main__": - unittest.main() diff --git a/test/test_reactions.py b/test/test_reactions.py new file mode 100644 index 0000000..e1855ca --- /dev/null +++ b/test/test_reactions.py @@ -0,0 +1,199 @@ +"""The jitr-backed reaction models: real solves with small settings. + +The first solve on a workspace pays JAX's compilation (about a second); +every later solve is milliseconds and a second angular grid on the same +basis is free. +""" + +import dill +import jitr +import numpy as np +import pytest +from jitr.optical_potentials.potential_forms import ( + coulomb_charged_sphere, + thomas_safe, + woods_saxon_safe, +) +from jitr.xs.coupled import Potential +from scipy import stats + +import rxmc.reactions.elastic as elastic_module +import rxmc.reactions.ias as ias_module +from rxmc import Comparison, Constraint, Dataset, Parameter, Problem, reactions +from rxmc.reactions import ElasticXS, IsobaricAnalogPN, momentum_transfer, rutherford +from rxmc.transforms import scale + +MSO = 1.0 / jitr.utils.constants.WAVENUMBER_PION +A, Z = 40, 20 +R = 1.2 * A ** (1 / 3) +ANGLES = np.linspace(0.2, 2.6, 6) +N_CA = jitr.reactions.ElasticReaction(target=(A, Z), projectile=(1, 0)) +P_CA = jitr.reactions.ElasticReaction(target=(A, Z), projectile=(1, 1)) + + +def central(r, Vv, Wv, Rv, av): + return -(Vv + 1j * Wv) * woods_saxon_safe(r, Rv, av) + + +def spin_orbit(r, Vso, Rso, aso): + return Vso * MSO**2 * thomas_safe(r, Rso, aso) + + +def omp(quantity="dXS/dA", **kw): + names = ("Vv", "Wv", "Rv", "av") + return ElasticXS( + quantity, + central, + spin_orbit, + lambda ws, *x: (tuple(x), (6.0, R, 0.45)), + [Parameter(n, prior=stats.norm(0, 100)) for n in names], + lmax=10, + **kw, + ) + + +THETA = (48.0, 3.5, R, 0.7) + + +def meta(reaction=N_CA, Elab=14.1): + return {"reaction": reaction, "Elab": Elab} + + +class TestElasticXS: + def test_cross_section_is_finite_positive_in_barns(self): + pred = omp().bind(ANGLES, meta()) + y = pred(*THETA) + assert y.shape == (6,) and np.all(np.isfinite(y)) and np.all(y > 0) + # b/sr: jitr's mb/sr divided by 1000 + ws = omp().workspace(ANGLES, meta()) + r = ws.r + pot = Potential(central(r, *THETA), spin_orbit(r, 6.0, R, 0.45)) + direct = ws.xs(pot).dsdo[0] + np.testing.assert_allclose(y, direct / 1000.0) + + def test_ratio_to_rutherford_and_analysing_power(self): + ratio = omp("dXS/dRuth").bind(ANGLES, meta(P_CA, 14.1))(*THETA) + assert np.all(np.isfinite(ratio)) and np.all(ratio > 0) + ay = omp("Ay").bind(ANGLES, meta())(*THETA) + assert np.all(np.abs(ay) <= 1.0) + with pytest.raises(ValueError, match="quantity"): + omp("sigma_tot") + + def test_basis_is_cached_per_energy_and_fine_grid_is_free(self): + model = omp() + model.bind(ANGLES, meta()) + fine = model.bind(np.linspace(0.05, 3.1, 200), meta()) + assert len(model._cache) == 1 + model.bind(ANGLES, meta(Elab=20.0)) + assert len(model._cache) == 2 + y = fine(*THETA) + assert y.shape == (200,) and np.all(np.isfinite(y)) + + def test_missing_kinematics_names_what_is_needed(self): + with pytest.raises(ValueError, match="meta\\['reaction'\\].*from_measurement"): + omp().bind(ANGLES, {}) + with pytest.raises(ValueError, match="meta\\['Elab'\\]"): + omp().bind(ANGLES, {"reaction": N_CA}) + + def test_ratio_to_rutherford_needs_a_charged_projectile(self): + with pytest.raises(ValueError, match="neutral projectile"): + omp("dXS/dRuth").bind(ANGLES, meta(N_CA)) + + def test_composes_like_any_model(self): + rho = Parameter("log_rho", prior=stats.norm(0, 0.1)) + scaled = omp() | scale(rho) + base = omp().bind(ANGLES, meta())(*THETA) + np.testing.assert_allclose( + scaled.bind(ANGLES, meta())(*THETA, np.log(2.0)), 2.0 * base + ) + + def test_solver_settings_reach_the_basis(self, monkeypatch): + seen = {} + real = elastic_module._basis + + def spy(reaction, Elab, lmax, wavelengths_beyond_range, zeros_per_node): + seen.update(lmax=lmax, wbr=wavelengths_beyond_range, zpn=zeros_per_node) + return real(reaction, Elab, lmax, wavelengths_beyond_range, zeros_per_node) + + monkeypatch.setattr(elastic_module, "_basis", spy) + omp(wavelengths_beyond_range=3.5, zeros_per_node=9).bind(ANGLES, meta()) + assert seen == {"lmax": 10, "wbr": 3.5, "zpn": 9} + + def test_dill_round_trip_of_a_reaction_problem(self): + d = Dataset( + ANGLES, omp().bind(ANGLES, meta())(*THETA), 0.01 * np.ones(6), meta=meta() + ) + p = Problem([Constraint([Comparison(d, omp())])]) + q = dill.loads(dill.dumps(p)) + theta = np.array(THETA) + assert q.log_posterior(theta) == pytest.approx(p.log_posterior(theta)) + + +class TestIsobaricAnalogPN: + def test_cross_section_with_a_lane_term(self): + A, Z = 48, 20 + R = 1.2 * A ** (1 / 3) + rxn = jitr.reactions.Reaction( + target=(A, Z), projectile=(1, 1), product=(1, 0), residual=(A, Z + 1) + ) + model = IsobaricAnalogPN( + coulomb_charged_sphere, + central, + spin_orbit, + central, + spin_orbit, + # the (p,n) transition is driven by the difference between the + # proton and neutron potentials (the Lane term): make them distinct + lambda ws, Vv, Wv, Rv, av: ( + (Z, R), + (Vv + 4.0, Wv, Rv, av), + (6.0, R, 0.45), + (Vv - 4.0, Wv, Rv, av), + (6.0, R, 0.45), + ), + [Parameter(n) for n in ("Vv", "Wv", "Rv", "av")], + lmax=10, + ) + pred = model.bind( + np.linspace(0.2, 2.6, 5), {"reaction": rxn, "Elab": 25.0, "ExIAS": 6.7} + ) + y = pred(48.0, 3.5, R, 0.7) + assert ( + y.shape == (5,) + and np.all(np.isfinite(y)) + and np.all(y >= 0) + and y.max() > 0 + ) + with pytest.raises(ValueError, match="ExIAS"): + model.bind(ANGLES, {"reaction": rxn, "Elab": 25.0}) + + def test_solver_settings_forwarded(self, monkeypatch): + seen = {} + + def fake(reaction, Elab, ExIAS, angles_rad, **kw): + seen.update(kw) + raise RuntimeError("stop") + + monkeypatch.setattr(ias_module, "set_up_solver", fake) + model = IsobaricAnalogPN( + *([central] * 5), + lambda ws, *x: ((),) * 5, + [Parameter("V")], + lmax=7, + wavelengths_beyond_range=3.5, + zeros_per_node=9, + ) + with pytest.raises(RuntimeError): + model.bind(ANGLES, {"reaction": object(), "Elab": 1.0, "ExIAS": 1.0}) + assert seen == {"lmax": 7, "wavelengths_beyond_range": 3.5, "zeros_per_node": 9} + + +def test_closed_forms(): + kin = P_CA.kinematics(14.1) + x = np.array([0.5, 1.0, 2.0]) + np.testing.assert_allclose(momentum_transfer(x, kin.k), 2.0 * kin.k * np.sin(x / 2)) + np.testing.assert_allclose( + rutherford(kin, x), 10 * kin.eta**2 / (4 * kin.k**2 * np.sin(x / 2) ** 4) + ) + assert np.all(rutherford(N_CA.kinematics(14.1), x) == 0.0) + assert reactions.ElasticXS is ElasticXS diff --git a/test/test_readme.py b/test/test_readme.py new file mode 100644 index 0000000..cb3bf79 --- /dev/null +++ b/test/test_readme.py @@ -0,0 +1,23 @@ +"""The README's Python blocks run, so the front door cannot drift from the API. + +The blocks share one namespace and execute in order: the linear quickstart, +the normalisation term, and the reaction example (a mock measurement, a +short nested-sampling run at ``lmax=10``). +""" + +import pathlib +import re + +README = pathlib.Path(__file__).resolve().parents[1] / "README.md" +BLOCK = re.compile(r"```python\n(.*?)```", re.S) + + +def test_readme_python_blocks_execute(capsys): + blocks = BLOCK.findall(README.read_text()) + assert len(blocks) == 3, "the README carries three Python blocks" + namespace = {} + for block in blocks: + exec(compile(block, str(README), "exec"), namespace) # noqa: S102 + out = capsys.readouterr().out + assert "['m', 'b']" in out and "['m', 'b', 'log_eta']" in out + assert "['V', 'W', 'a']" in out diff --git a/test/test_recipes_index.py b/test/test_recipes_index.py new file mode 100644 index 0000000..bee41d0 --- /dev/null +++ b/test/test_recipes_index.py @@ -0,0 +1,78 @@ +"""docs/recipes.md and test/recipes/ cannot drift apart. + +Every ``## N. Title`` heading in the recipes document has exactly one test +file ``test/recipes/test_recipe_NN_.py`` whose docstring quotes the +recipe, and the error-model legend of recipe 18 is the one the tests build. +""" + +import pathlib +import re + +import pytest + +from helpers import STUDY_LEGEND + +ROOT = pathlib.Path(__file__).resolve().parents[1] +RECIPES = ROOT / "docs" / "recipes.md" +TEST_DIR = ROOT / "test" / "recipes" + +HEADING = re.compile(r"^## (\d+)\. (.+)$", re.M) +FILE = re.compile(r"^test_recipe_(\d+)_[a-z0-9_]+\.py$") +DOCSTRING = re.compile(r'^"""Recipe (\d+): (.+)$') +LEGEND_ROW = re.compile(r"^\| `(\w+)` \| (.+) \|$", re.M) + + +def _headings() -> dict: + return {int(n): title for n, title in HEADING.findall(RECIPES.read_text())} + + +def _files() -> list: + return sorted(p for p in TEST_DIR.glob("test_recipe_*.py") if FILE.match(p.name)) + + +def _normalise(text: str) -> str: + """Case, backticks, colons, commas, a trailing stop and spacing do not count.""" + text = text.replace("`", "").replace(":", "").replace(",", "") + return " ".join(text.lower().rstrip(".").split()) + + +def test_every_heading_has_one_test_file_and_vice_versa(): + headings = _headings() + numbers = [int(FILE.match(p.name).group(1)) for p in _files()] + duplicates = sorted({n for n in numbers if numbers.count(n) > 1}) + assert not duplicates, f"more than one test file for recipe(s) {duplicates}" + missing = sorted(set(headings) - set(numbers)) + stray = sorted(set(numbers) - set(headings)) + assert ( + not missing + ), f"recipe(s) {missing} in docs/recipes.md have no test/recipes/test_recipe_NN_*.py" + assert not stray, f"test file(s) for recipe(s) {stray} have no ## NN. heading" + + +@pytest.mark.parametrize("path", _files(), ids=lambda p: p.name) +def test_each_test_file_quotes_its_recipe(path): + n = int(FILE.match(path.name).group(1)) + first = path.read_text().splitlines()[0] + m = DOCSTRING.match(first) + assert m, f'{path.name} must open with a docstring """Recipe {n}: ' + assert int(m.group(1)) == n, f"{path.name} quotes recipe {m.group(1)}, not {n}" + heading = _normalise(_headings()[n]) + assert heading.startswith( + _normalise(m.group(2)) + ), f"{path.name} quotes {m.group(2)!r}; the heading is {_headings()[n]!r}" + + +def test_the_error_model_legend_matches_the_recipe_table(): + text = RECIPES.read_text() + start = text.index("## 18. ") + end = text.index("## 19. ") + table = {label: desc for label, desc in LEGEND_ROW.findall(text[start:end])} + assert table, "recipe 18 must carry the error-model legend table" + # "custom" is a test-only spelling of the L1 form + forms = set(table) + built = set(STUDY_LEGEND) - {"custom"} + assert forms == built, f"table {sorted(forms)} vs tests {sorted(built)}" + for label in forms: + assert _normalise(table[label]) == _normalise( + STUDY_LEGEND[label] + ), f"{label}: table says {table[label]!r}, tests say {STUDY_LEGEND[label]!r}" diff --git a/test/test_regression.py b/test/test_regression.py index 2cd8de0..634bae2 100644 --- a/test/test_regression.py +++ b/test/test_regression.py @@ -1,141 +1,116 @@ +"""Regression pins carried over from 0.x. + +The 0.x default covariance silently folded a dataset's reported +normalisation and offset systematics into the likelihood. The 1.0 default +is statistical only, and the systematics become terms when asked for +(``comparison.reported_terms()``). These pins record that the old number is +recovered exactly by asking, that the default differs, and that a mode +spanning two comparisons changes the likelihood the way a dense reference +says it should. """ -Regression pins for the deliberate behaviour change of the covariance refactor. -The old default covariance silently folded a dataset's normalisation/offset -systematics into ``Observation.covariance``. The new default is **statistical -only**; those systematics must be stated explicitly as covariance -:class:`~rxmc.covariance.Term` s. These tests pin: +import numpy as np +import pytest +from scipy import stats -1. the before/after log-posterior gap (the default changed), and -2. that re-adding the explicit terms exactly recovers the old number. +from helpers import manual_mvn_loglike +from rxmc import Comparison, Constraint, Dataset, Model, Parameter, Problem +from rxmc import terms as T -They also pin the block-diagonal fast path against a dense Cholesky and a genuine -case-A cross-dataset coupling, so the new capabilities are recorded. -""" +X = np.array([1.0, 2.0, 3.0, 4.0]) +Y = np.array([2.1, 3.9, 6.2, 7.8]) +STAT = np.array([0.1, 0.15, 0.2, 0.25]) +NORM, OFFSET = 0.05, 0.02 +THETA = np.array([0.2, 1.9]) # a0, a1 of the 0.x Polynomial(order=1) +PINNED = 1.195784087817536 -import unittest -import numpy as np +def line(): + a0 = Parameter("a0", prior=stats.norm(0, 10)) + a1 = Parameter("a1", prior=stats.norm(0, 10)) + return Model(lambda x, a0, a1: a0 + a1 * x, [a0, a1]) -from helpers import manual_mvn_loglike as manual_mvn -from rxmc.constraint import Constraint -from rxmc.covariance import normalization_term, offset_term -from rxmc.observation import Observation -from rxmc.physical_model import Polynomial - - -class TestSystematicDefaultBehaviourChange(unittest.TestCase): - """systematic_err_demo / normalization_inference behaviour change.""" - - def setUp(self): - self.x = np.array([1.0, 2.0, 3.0, 4.0]) - self.y = np.array([2.1, 3.9, 6.2, 7.8]) - self.stat = np.array([0.1, 0.15, 0.2, 0.25]) - self.norm = 0.05 # fractional normalisation systematic - self.offset = 0.02 # absolute offset systematic - self.obs = Observation(self.x, self.y, y_stat_err=self.stat) - self.pm = Polynomial(order=1) - self.model_params = (0.2, 1.9) - self.ym = self.pm.evaluate(self.obs, *self.model_params) - - # the matrix the OLD Observation.covariance(ym) produced - ones = np.ones(4) - self.old_cov = ( - np.diag(self.stat**2) - + np.outer(self.offset * ones, self.offset * ones) - + np.outer(self.norm * ones, self.norm * ones) * np.outer(self.ym, self.ym) - ) + +def old_covariance(ym): + ones = np.ones_like(ym) + return ( + np.diag(STAT**2) + OFFSET**2 * np.outer(ones, ones) + NORM**2 * np.outer(ym, ym) + ) + + +class TestSystematicDefaultBehaviourChange: + def setup_method(self): + self.d = Dataset(X, Y, STAT, norm_err=NORM, offset_err=OFFSET, label="pin") + self.comp = Comparison(self.d, line()) + self.ym = THETA[0] + THETA[1] * X def test_old_value(self): - # pinned old log-likelihood (auto-included systematics) - old = manual_mvn(self.y, self.ym, self.old_cov) - self.assertAlmostEqual(old, 1.195784087817536, places=9) + assert manual_mvn_loglike(Y, self.ym, old_covariance(self.ym)) == pytest.approx( + PINNED, abs=1e-9 + ) def test_new_default_is_statistical_only_and_differs(self): - c = Constraint([self.obs], self.pm) - new_default = c.log_likelihood(self.model_params) - stat_only = manual_mvn(self.y, self.ym, np.diag(self.stat**2)) - self.assertAlmostEqual(new_default, stat_only) - # the default genuinely changed - old = manual_mvn(self.y, self.ym, self.old_cov) - self.assertNotAlmostEqual(new_default, old) - - def test_explicit_terms_recover_old_value(self): - support = np.arange(4) - c = Constraint( - [self.obs], - self.pm, - extra_terms=[ - offset_term(magnitude=self.offset, support=support), - normalization_term(magnitude=self.norm, support=support), - ], + p = Problem([Constraint([self.comp])]) + assert p.log_likelihood(THETA) == pytest.approx( + manual_mvn_loglike(Y, self.ym, np.diag(STAT**2)) ) - recovered = c.log_likelihood(self.model_params) - old = manual_mvn(self.y, self.ym, self.old_cov) - self.assertAlmostEqual(recovered, old) - - -class TestBlockDiagonalFastPathEquivalence(unittest.TestCase): - """The block-diagonal fast path equals a dense Cholesky over the full stack.""" - - def test_multi_block_matches_dense(self): - pm = Polynomial(order=1) - mp = (0.3, 1.1) - obs = [ - Observation( - np.array([1.0, 2.0]), - np.array([1.5, 2.4]), - y_stat_err=np.array([0.1, 0.2]), - ), - Observation( - np.array([3.0, 4.0, 5.0]), - np.array([3.2, 4.5, 5.9]), - y_stat_err=np.array([0.2, 0.1, 0.3]), - ), - Observation(np.array([6.0]), np.array([7.1]), y_stat_err=np.array([0.15])), - ] - c = Constraint(obs, pm) - self.assertTrue(c.covariance.block_diagonal) - fast = c.log_likelihood(mp) - - y = np.concatenate([o.y for o in obs]) - ym = np.concatenate([pm.evaluate(o, *mp) for o in obs]) - stat = np.concatenate([o.y_stat_err for o in obs]) - dense = manual_mvn(y, ym, np.diag(stat**2)) - self.assertAlmostEqual(fast, dense, places=10) - - -class TestCaseACrossDatasetCorrelation(unittest.TestCase): - """A correlated systematic shared across two datasets (case A).""" - - def test_off_diagonal_blocks_present_and_changes_likelihood(self): - pm = Polynomial(order=1) - mp = (0.5, 1.0) - obs1 = Observation( - np.array([1.0, 2.0]), np.array([1.6, 2.9]), y_stat_err=np.array([0.1, 0.1]) + assert p.log_likelihood(THETA) != pytest.approx(PINNED) + + def test_reported_terms_recover_old_value(self): + p = Problem([Constraint([self.comp], terms=self.comp.reported_terms())]) + assert p.log_likelihood(THETA) == pytest.approx(PINNED, abs=1e-9) + + +class TestSpanningMode: + """A normalisation mode across two comparisons equals the dense reference.""" + + def setup_method(self): + self.model = line() + self.d1 = Dataset(X, Y, STAT, label="one") + self.d2 = Dataset(X + 4.0, Y + 7.6, STAT, label="two") + self.comps = [Comparison(self.d1, self.model), Comparison(self.d2, self.model)] + + def test_independent_blocks_match_a_dense_cholesky(self): + p = Problem( + [ + Constraint( + self.comps, + terms=[T.normalization(magnitude=NORM, on=c) for c in self.comps], + ) + ] ) - obs2 = Observation( - np.array([3.0, 4.0]), np.array([3.4, 4.6]), y_stat_err=np.array([0.1, 0.1]) + ym = np.concatenate([THETA[0] + THETA[1] * X, THETA[0] + THETA[1] * (X + 4.0)]) + y = np.concatenate([Y, Y + 7.6]) + S = np.diag(np.tile(STAT, 2) ** 2) + S[:4, :4] += NORM**2 * np.outer(ym[:4], ym[:4]) + S[4:, 4:] += NORM**2 * np.outer(ym[4:], ym[4:]) + assert p.log_likelihood(THETA) == pytest.approx(manual_mvn_loglike(y, ym, S)) + assert not p.constraints[0].covariance.dense + + def test_a_mode_spanning_both_changes_the_likelihood(self): + p_each = Problem( + [ + Constraint( + self.comps, + terms=[T.normalization(magnitude=NORM, on=c) for c in self.comps], + ) + ] + ) + p_span = Problem( + [ + Constraint( + self.comps, terms=[T.normalization(magnitude=NORM, on=self.comps)] + ) + ] + ) + S = p_span.constraints[0].matrix(THETA) + assert np.all(S[:4, 4:] != 0.0) + ym = np.concatenate([THETA[0] + THETA[1] * X, THETA[0] + THETA[1] * (X + 4.0)]) + y = np.concatenate([Y, Y + 7.6]) + dense = np.diag(np.tile(STAT, 2) ** 2) + NORM**2 * np.outer(ym, ym) + assert p_span.log_likelihood(THETA) == pytest.approx( + manual_mvn_loglike(y, ym, dense) + ) + assert p_span.log_likelihood(THETA) != pytest.approx( + p_each.log_likelihood(THETA) ) - - from rxmc.params import Parameter - - eta = Parameter("log eta") - coupling = normalization_term(parameter=eta, support=np.arange(4)) - c = Constraint([obs1, obs2], pm, extra_terms=[coupling]) - - # the assembled Sigma has non-zero cross-block (off-diagonal) entries - ym = np.concatenate([pm.evaluate(obs1, *mp), pm.evaluate(obs2, *mp)]) - ctx = c._stack(mp) - Sigma = c.covariance.matrix(ctx, np.log(0.1)) - self.assertFalse(c.covariance.block_diagonal) - self.assertGreater(abs(Sigma[0, 2]), 0.0) - - # and it equals the explicit dense form - cov = np.diag(np.full(4, 0.1**2)) + 0.1**2 * np.outer(ym, ym) - expected = manual_mvn(np.concatenate([obs1.y, obs2.y]), ym, cov) - self.assertAlmostEqual(c.log_likelihood(mp, (np.log(0.1),)), expected) - - -if __name__ == "__main__": - unittest.main() diff --git a/test/test_sampler.py b/test/test_sampler.py deleted file mode 100644 index a974708..0000000 --- a/test/test_sampler.py +++ /dev/null @@ -1,409 +0,0 @@ -import io -import unittest -from contextlib import redirect_stdout -from types import SimpleNamespace - -import numpy as np -import scipy.stats - -from rxmc.adaptive_metropolis import adaptive_metropolis -from rxmc.constraint import Constraint -from rxmc.covariance import Term -from rxmc.evidence import Evidence -from rxmc.observation import Observation -from rxmc.param_sampling import ( - AdaptiveMetropolisSampler, - BatchedAdaptiveMetropolisSampler, - MetropolisHastingsSampler, -) -from rxmc.params import Parameter -from rxmc.physical_model import Polynomial -from rxmc.priors import IndependentPrior -from rxmc.proposal import NormalProposalDistribution -from rxmc.walker import Walker - - -def floor_slope_noise_term(support=None): - """diag((exp(floor) + exp(slope)*|ym|)**2) — a two-parameter noise term.""" - return Term( - lambda c, floor, slope: np.exp(floor) + np.exp(slope) * np.abs(c.ym), - (Parameter("log noise floor", float), Parameter("log noise slope", float)), - kind="diag", - support=support, - ) - - -class TestAdaptiveMetropolisSampler(unittest.TestCase): - def test_sampling_runs_with_bounds(self): - sampler = AdaptiveMetropolisSampler( - params=[Parameter("x", bounds=(-1.0, 1.0))], - prior=scipy.stats.norm(loc=0.0, scale=1.0), - starting_location=np.array([0.0]), - adapt_start=2, - window_size=3, - ) - - sampler.sample( - n_steps=5, - starting_location=np.array([0.0]), - rng=np.random.default_rng(123), - log_posterior=lambda x: -0.5 * x[0] ** 2, - ) - - self.assertEqual(sampler.chain.shape, (5, 1)) - self.assertTrue(np.all(sampler.chain[:, 0] >= -1.0)) - self.assertTrue(np.all(sampler.chain[:, 0] <= 1.0)) - - def test_multidimensional_regularization_stays_symmetric(self): - x0 = np.array([0.5, -0.25]) - bounds = np.array([[-10.0, 10.0], [-10.0, 10.0]]) - previous_chain = np.array( - [ - [0.2, -0.1], - [0.3, -0.2], - [0.4, -0.15], - ] - ) - epsilon_fraction = 1e-6 - history_mean = np.mean(previous_chain, axis=0) - empirical_cov = np.atleast_2d(np.cov(previous_chain.T)) - proposal_cov = empirical_cov + epsilon_fraction * np.diag(history_mean**2) - self.assertTrue(np.allclose(proposal_cov, proposal_cov.T)) - - chain, logp_chain, accepted = adaptive_metropolis( - x0=x0, - bounds=bounds, - n_steps=4, - log_posterior=lambda x: -0.5 * np.dot(x, x), - rng=np.random.default_rng(42), - adapt_start=0, - window_size=3, - epsilon_fraction=epsilon_fraction, - previous_chain=previous_chain, - ) - - self.assertEqual(chain.shape, (4, 2)) - self.assertEqual(logp_chain.shape, (4,)) - self.assertGreaterEqual(accepted, 0) - - -class TestWalker(unittest.TestCase): - def test_walk_runs_end_to_end_with_multi_parameter_likelihood(self): - model = Polynomial(1) - observation = Observation( - x=np.array([0.0, 1.0, 2.0, 3.0, 4.0]), - y=np.array([1.0, 2.1, 3.2, 4.0, 5.1]), - y_stat_err=np.array([0.1, 0.1, 0.1, 0.1, 0.1]), - ) - noise_term = floor_slope_noise_term(np.arange(observation.n_data_pts)) - constraint = Constraint( - observations=[observation], - physical_model=model, - extra_terms=[noise_term], - ) - evidence = Evidence(constraints=[constraint]) - - model_sampler = MetropolisHastingsSampler( - params=model.params, - prior=scipy.stats.multivariate_normal(mean=[0.0, 1.0], cov=np.eye(2)), - starting_location=np.array([0.9, 1.0]), - proposal=NormalProposalDistribution(0.01 * np.eye(2)), - ) - likelihood_sampler = MetropolisHastingsSampler( - params=list(constraint.params), - prior=scipy.stats.multivariate_normal(mean=[-2.0, -2.0], cov=np.eye(2)), - starting_location=np.array([-2.0, -2.0]), - proposal=NormalProposalDistribution(0.01 * np.eye(2)), - ) - - walker = Walker( - model_sampler=model_sampler, - evidence=evidence, - likelihood_samplers=[likelihood_sampler], - rng=np.random.default_rng(321), - ) - walker.walk(n_steps=5, burnin=2, batch_size=2, verbose=False) - - self.assertEqual(walker.model_sampler.chain.shape, (5, 2)) - self.assertEqual(walker.likelihood_samplers[0].chain.shape, (5, 2)) - self.assertEqual(walker.model_sampler.state.shape, (2,)) - self.assertEqual(walker.likelihood_samplers[0].state.shape, (2,)) - - def test_gibbs_conditional_applies_evidence_weight(self): - from types import SimpleNamespace - - model = Polynomial(1) - observation = Observation( - x=np.array([0.0, 1.0, 2.0, 3.0, 4.0]), - y=np.array([1.0, 2.1, 3.2, 4.0, 5.1]), - y_stat_err=np.array([0.1, 0.1, 0.1, 0.1, 0.1]), - ) - constraint = Constraint( - observations=[observation], - physical_model=model, - extra_terms=[floor_slope_noise_term(np.arange(observation.n_data_pts))], - ) - weight = 2.5 - evidence = Evidence(constraints=[constraint], weights=np.array([weight])) - - prior = scipy.stats.multivariate_normal(mean=[-2.0, -2.0], cov=np.eye(2)) - - class CapturingSampler: - def __init__(self, params, prior): - self.params = params - self.prior = prior - self.captured = None - - def sample(self, n_steps, x0, rng, log_posterior, burn=False): - self.captured = log_posterior - - lm_sampler = CapturingSampler(list(constraint.params), prior) - walker = Walker( - model_sampler=SimpleNamespace(params=evidence.model_params, prior=prior), - evidence=evidence, - likelihood_samplers=[lm_sampler], - ) - - model_params = (0.9, 1.0) - walker.run_likelihood_batches(1, [np.array([-2.0, -2.0])], model_params) - - x = np.array([-2.0, -2.0]) - ym = constraint.predict(*model_params) - expected = float( - prior.logpdf(x) + weight * constraint.marginal_log_likelihood(ym, *x) - ) - self.assertAlmostEqual(lm_sampler.captured(x), expected) - - -class CapturingSampler: - """Records the conditional posterior a Walker hands it; never samples.""" - - def __init__(self, params, prior): - self.params = list(params) - self.prior = prior - self.captured = None - - def sample(self, n_steps, x0, rng, log_posterior, burn=False): - self.captured = log_posterior - - -class NegInfPrior: - def logpdf(self, x): - return -np.inf - - -def parametric_setup(weight=1.0): - """A one-constraint Evidence with a two-parameter noise term.""" - model = Polynomial(1) - observation = Observation( - x=np.array([0.0, 1.0, 2.0, 3.0, 4.0]), - y=np.array([1.0, 2.1, 3.2, 4.0, 5.1]), - y_stat_err=np.array([0.1, 0.1, 0.1, 0.1, 0.1]), - ) - constraint = Constraint( - observations=[observation], - physical_model=model, - extra_terms=[floor_slope_noise_term(np.arange(observation.n_data_pts))], - ) - evidence = Evidence(constraints=[constraint], weights=np.array([weight])) - return model, constraint, evidence - - -class TestWalkerPosterior(unittest.TestCase): - """Parity with CalibrationConfig: prior-first short-circuit and tempering.""" - - def test_log_posterior_skips_likelihood_when_prior_neg_inf(self): - calls = [] - evidence = SimpleNamespace( - model_params=[Parameter("a")], - parametric_constraints=[], - log_likelihood=lambda mp, lp: calls.append(mp) or 0.0, - ) - walker = Walker( - model_sampler=SimpleNamespace( - params=evidence.model_params, prior=NegInfPrior() - ), - evidence=evidence, - ) - self.assertEqual(walker.log_posterior((1.0,), []), -np.inf) - self.assertEqual(calls, []) - - def test_gibbs_conditional_skips_likelihood_when_prior_neg_inf(self): - calls = [] - lm_params = [Parameter("nu")] - constraint = SimpleNamespace( - params=lm_params, predict=lambda *mp: [np.zeros(3)] - ) - evidence = SimpleNamespace( - model_params=[Parameter("a")], - parametric_constraints=[constraint], - weighted_marginal_log_likelihood=lambda i, ym, *x: calls.append(x) or 0.0, - ) - lm_sampler = CapturingSampler(lm_params, NegInfPrior()) - walker = Walker( - model_sampler=SimpleNamespace( - params=evidence.model_params, prior=NegInfPrior() - ), - evidence=evidence, - likelihood_samplers=[lm_sampler], - ) - walker.run_likelihood_batches(1, [np.array([1.0])], (0.5,)) - self.assertEqual(lm_sampler.captured(np.array([1.0])), -np.inf) - self.assertEqual(calls, []) - - def test_log_posterior_applies_likelihood_scaling(self): - scaling = 0.25 - model, constraint, evidence = parametric_setup() - model_prior = scipy.stats.multivariate_normal(mean=[0.0, 1.0], cov=np.eye(2)) - lm_prior = scipy.stats.multivariate_normal(mean=[-2.0, -2.0], cov=np.eye(2)) - walker = Walker( - model_sampler=SimpleNamespace( - params=evidence.model_params, prior=model_prior - ), - evidence=evidence, - likelihood_samplers=[CapturingSampler(constraint.params, lm_prior)], - likelihood_scaling=scaling, - ) - mp, x = (0.9, 1.0), np.array([-2.0, -2.0]) - expected = ( - model_prior.logpdf(np.array(mp)) - + lm_prior.logpdf(x) - + scaling * evidence.log_likelihood(mp, [x]) - ) - self.assertAlmostEqual(walker.log_posterior(mp, [x]), float(expected)) - self.assertAlmostEqual( - walker.log_likelihood(mp, [x]), scaling * evidence.log_likelihood(mp, [x]) - ) - - def test_gibbs_conditional_applies_likelihood_scaling_and_weight(self): - # mirrors test_config.py::test_conditional_posterior_tempering - scaling, weight = 0.5, 3.0 - model, constraint, evidence = parametric_setup(weight=weight) - prior = scipy.stats.multivariate_normal(mean=[-2.0, -2.0], cov=np.eye(2)) - lm_sampler = CapturingSampler(constraint.params, prior) - walker = Walker( - model_sampler=SimpleNamespace(params=evidence.model_params, prior=prior), - evidence=evidence, - likelihood_samplers=[lm_sampler], - likelihood_scaling=scaling, - ) - mp = (0.9, 1.0) - walker.run_likelihood_batches(1, [np.array([-2.0, -2.0])], mp) - - x = np.array([-2.0, -2.0]) - ym = constraint.predict(*mp) - expected = prior.logpdf( - x - ) + scaling * weight * constraint.marginal_log_likelihood(ym, *x) - self.assertAlmostEqual(lm_sampler.captured(x), float(expected)) - - def test_burn_message_has_no_acceptance_fraction(self): - model = Polynomial(1) - observation = Observation( - x=np.array([0.0, 1.0, 2.0]), - y=np.array([1.0, 2.1, 3.2]), - y_stat_err=np.array([0.1, 0.1, 0.1]), - ) - evidence = Evidence( - constraints=[Constraint(observations=[observation], physical_model=model)] - ) - sampler = MetropolisHastingsSampler( - params=model.params, - prior=scipy.stats.multivariate_normal(mean=[0.0, 1.0], cov=np.eye(2)), - starting_location=np.array([0.9, 1.0]), - proposal=NormalProposalDistribution(0.01 * np.eye(2)), - ) - walker = Walker(sampler, evidence, rng=np.random.default_rng(0)) - out = io.StringIO() - with redirect_stdout(out): - walker.walk(n_steps=2, burnin=2, batch_size=2, verbose=True) - lines = out.getvalue().splitlines() - burn = [line for line in lines if line.startswith("Burn-in batch")] - self.assertEqual(len(burn), 1) - self.assertNotIn("acceptance", burn[0]) - self.assertTrue(any("acceptance fraction" in line for line in lines)) - self.assertEqual(walker.model_sampler.chain.shape, (2, 2)) - - -class TestSamplerPriors(unittest.TestCase): - def test_sampler_accepts_list_prior(self): - sampler = MetropolisHastingsSampler( - params=[Parameter("x"), Parameter("y")], - prior=[scipy.stats.norm(0, 1), scipy.stats.norm(0, 1)], - starting_location=np.zeros(2), - proposal=NormalProposalDistribution(0.01 * np.eye(2)), - ) - self.assertIsInstance(sampler.prior, IndependentPrior) - self.assertTrue(np.isfinite(sampler.prior.logpdf(np.zeros(2)))) - - def test_batched_adaptive_updates_proposal_after_burn_batch(self): - sampler = BatchedAdaptiveMetropolisSampler( - params=[Parameter("x"), Parameter("y")], - prior=scipy.stats.multivariate_normal(mean=[0.0, 0.0], cov=np.eye(2)), - starting_location=np.zeros(2), - initial_proposal_cov=np.eye(2), - ) - initial = sampler.proposal - sampler.sample( - n_steps=30, - starting_location=np.zeros(2), - rng=np.random.default_rng(7), - log_posterior=lambda x: -0.5 * float(x @ x), - burn=True, - ) - # burn-in records nothing but does adapt; the public proposal follows - self.assertEqual(sampler.chain.shape, (0, 2)) - self.assertIsNot(sampler.proposal, initial) - self.assertIs(sampler.args[0], sampler.proposal) - np.testing.assert_allclose(sampler.proposal.cov, sampler.proposal_cov) - - -class TestWalkerValidation(unittest.TestCase): - def setUp(self): - self.SimpleNamespace = SimpleNamespace - self.model = Polynomial(1) - obs = Observation( - x=np.array([0.0, 1.0, 2.0, 3.0, 4.0]), - y=np.array([1.0, 2.1, 3.2, 4.0, 5.1]), - y_stat_err=np.array([0.1, 0.1, 0.1, 0.1, 0.1]), - ) - self.parametric = Constraint( - observations=[obs], - physical_model=self.model, - extra_terms=[floor_slope_noise_term(np.arange(obs.n_data_pts))], - ) - self.evidence = Evidence(constraints=[self.parametric]) - self.prior = scipy.stats.multivariate_normal(mean=[0.0, 1.0], cov=np.eye(2)) - - def _sampler(self, params): - return self.SimpleNamespace(params=list(params), prior=self.prior) - - def test_mismatched_model_params_raise(self): - with self.assertRaises(ValueError): - Walker( - model_sampler=self._sampler(self.model.params[:1]), - evidence=self.evidence, - likelihood_samplers=[self._sampler(self.parametric.params)], - ) - - def test_sampler_count_mismatch_raises(self): - with self.assertRaises(ValueError): - Walker( - model_sampler=self._sampler(self.evidence.model_params), - evidence=self.evidence, - likelihood_samplers=[], - ) - - def test_mismatched_likelihood_params_raise(self): - from rxmc.params import Parameter - - with self.assertRaises(ValueError): - Walker( - model_sampler=self._sampler(self.evidence.model_params), - evidence=self.evidence, - likelihood_samplers=[self._sampler([Parameter("wrong name")])], - ) - - -if __name__ == "__main__": - unittest.main() diff --git a/test/test_smoke.py b/test/test_smoke.py new file mode 100644 index 0000000..53c6336 --- /dev/null +++ b/test/test_smoke.py @@ -0,0 +1,8 @@ +"""The package installs and reports a version.""" + +import rxmc + + +def test_import_and_version(): + assert isinstance(rxmc.__version__, str) + assert rxmc.__version__ diff --git a/test/test_terms.py b/test/test_terms.py new file mode 100644 index 0000000..4282f7c --- /dev/null +++ b/test/test_terms.py @@ -0,0 +1,594 @@ +"""Unit tests for the stateless covariance terms (:mod:`rxmc.terms`).""" + +import jax.numpy as jnp +import numpy as np +import pytest +import tinygp +from sklearn.gaussian_process.kernels import RBF, ConstantKernel, Matern + +from helpers import ( + LOG_LENGTH_BOUNDS, + STUDY_LEGEND, + assemble_dense, + matern52, + rbf, + study_form, +) +from rxmc import Parameter +from rxmc.terms import ( + KernelTerm, + Term, + TermContext, + averaging, + constant_amplitude, + exp_growth, + exp_growth_amplitude, + kernel, + kernel_params, + noise, + normalization, + offset, + ones, + proportional_error, + statistical, + systematic, + x_basis, + ym, +) +from rxmc.transforms import Transform + + +def dense(terms, x, y, ym_, values=()): + return assemble_dense(terms, x, y, ym_, values) + + +# ---------------------------------------------------------------------------- +# Term +# ---------------------------------------------------------------------------- + + +class TestTermKinds: + def test_diag_array_squares_std(self): + t = Term(np.array([1.0, 2.0, 3.0]), kind="diag") + S = dense([t], np.zeros(3), np.zeros(3), np.zeros(3)) + assert np.allclose(S, np.diag([1.0, 4.0, 9.0])) + assert t.is_constant + assert not t.couples_offdiagonal + + def test_mode_array_outer(self): + v = np.array([1.0, 2.0]) + t = Term(v, kind="mode") + assert np.allclose(dense([t], np.zeros(2), np.zeros(2), None), np.outer(v, v)) + assert t.couples_offdiagonal + + def test_matrix_array_passthrough(self): + m = np.array([[2.0, 0.5], [0.5, 3.0]]) + t = Term(m) + assert np.allclose(dense([t], np.zeros(2), np.zeros(2), None), m) + + def test_bad_kind_raises(self): + with pytest.raises(ValueError, match="kind"): + Term(np.ones(2), kind="rank1") + + def test_scalar_broadcast_raises(self): + # a (1, 1) matrix on a length-3 support must not broadcast silently + t = Term([[0.04]]) + with pytest.raises(ValueError, match="expects shape"): + t.value(np.zeros(3), np.zeros(3), np.zeros(3)) + + def test_wrong_length_vector_raises(self): + with pytest.raises(ValueError, match="expects shape"): + Term(np.ones(2), kind="diag").value(np.zeros(3), np.zeros(3), np.zeros(3)) + + def test_asymmetric_matrix_raises(self): + with pytest.raises(ValueError, match="symmetric"): + Term(np.array([[1.0, 0.2], [0.0, 1.0]])) + + def test_non_square_matrix_raises(self): + with pytest.raises(ValueError, match="square"): + Term(np.ones((2, 3))) + + def test_array_with_params_raises(self): + with pytest.raises(ValueError, match="array-valued"): + Term(np.ones(2), (Parameter("p"),), kind="diag") + + def test_non_parameter_raises(self): + with pytest.raises(TypeError, match="Parameter"): + Term(lambda c, a: ones(c), ("a",), kind="diag") + + def test_callable_sees_context_and_values(self): + seen = {} + + def fn(c, a, b): + seen["c"] = c + return a * c.ym + b * c.y + + pa, pb = Parameter("a"), Parameter("b") + t = Term(fn, (pa, pb), kind="diag") + x, y, ym_ = np.array([1.0, 2.0]), np.array([2.0, 3.0]), np.array([2.5, 3.5]) + v = t.value(x, y, ym_, 2.0, 1.0) + c = seen["c"] + assert isinstance(c, TermContext) + assert np.allclose(c.x, x) and np.allclose(c.ym, ym_) and len(c) == 2 + assert np.allclose(v, 2.0 * ym_ + y) + + def test_callable_wrong_shape_raises(self): + t = Term(lambda c: np.ones(len(c) + 1), kind="diag") + with pytest.raises(ValueError, match="returned shape"): + t.value(np.zeros(2), np.zeros(2), np.zeros(2)) + + def test_wrong_param_count_raises(self): + t = Term(lambda c, a: a * ones(c), (Parameter("a"),), kind="diag") + with pytest.raises(ValueError, match="expected 1 params"): + t.value(np.zeros(1), np.zeros(1), np.zeros(1)) + + def test_constant_with_params_raises(self): + with pytest.raises(ValueError, match="constant"): + Term(lambda c, a: ones(c), (Parameter("a"),), kind="diag", constant=True) + + def test_constant_term_may_read_x_and_is_evaluated_without_ym(self): + x = np.linspace(0.0, 2.0, 4) + t = Term(lambda c: 0.1 * c.x, kind="diag", constant=True) + assert t.is_constant + np.testing.assert_allclose(t.value(x, np.zeros(4), None), 0.1 * x) + bad = Term(lambda c: 0.1 * c.ym, kind="diag", constant=True) + with pytest.raises(TypeError): + bad.value(x, np.zeros(4), None) + + def test_meta_accessor(self): + t = Term(lambda c: c.meta("E") * ones(c), kind="diag", constant=True) + v = t.value(np.zeros(2), np.zeros(2), None, meta={"E": np.array([5.0, 5.0])}) + assert np.allclose(v, 5.0) + with pytest.raises(KeyError, match="Dataset.meta"): + t.value(np.zeros(2), np.zeros(2), None) + + def test_repr(self): + assert "log_e" in repr(noise(Parameter("log_e"))) + + +class TestTermCoords: + def test_coords_callable_applied_to_x(self): + t = Term(lambda c: c.x, kind="diag", coords=lambda x: 2 * x) + assert np.allclose(t.value(np.array([1.0, 3.0]), np.zeros(2), None), [2.0, 6.0]) + + def test_parametric_coords_params_appended(self): + pk = Parameter("k") + coords = Transform(lambda x, k: k * x, (pk,)) + pa = Parameter("a") + t = Term(lambda c, a: a * c.x, (pa,), kind="diag", coords=coords) + assert t.params == (pa, pk) + v = t.value(np.array([1.0, 2.0]), np.zeros(2), None, 3.0, 2.0) # a=3, k=2 + assert np.allclose(v, 6.0 * np.array([1.0, 2.0])) + + def test_coords_array_2d_reaches_kernel(self): + X = np.array([[0.0, 0.0], [1.0, 1.0], [2.0, 0.0]]) + t = kernel(*rbf(), coords=lambda x: X, jitter=0.0) + S = t.value(np.zeros(3), np.zeros(3), np.zeros(3), 0.0) + assert np.allclose(S, RBF(1.0)(X)) + + def test_fixed_kernel_with_parametric_coords(self): + s = Parameter("s") + coords = Transform(lambda a, s: a * s, (s,)) + x = np.array([0.0, 0.5, 1.0]) + for amp in (None, 0.3): + t = kernel(tinygp.kernels.ExpSquared(), coords=coords, amplitude=amp) + assert t.params == (s,) and not t.is_constant + K = t.value(x, np.zeros(3), np.zeros(3), 2.0) + a2 = 1.0 if amp is None else amp**2 + np.testing.assert_allclose(K, a2 * RBF(1.0)(2.0 * x[:, None]), atol=1e-8) + + def test_replace_keeps_one_copy_of_the_coords_parameters(self): + from dataclasses import replace + + le, s, u = Parameter("le"), Parameter("s"), Parameter("u") + t = noise(le, coords=Transform(lambda a, s: a * s, (s,))) + x, y = np.array([1.0, 2.0]), np.zeros(2) + moved = replace(t, on=None) + assert moved.params == (le, s) + np.testing.assert_allclose(moved.value(x, y, None, np.log(0.2), 3.0), 0.2) + assert replace(t, coords=Transform(lambda a, u: a + u, (u,))).params == (le, u) + le2 = Parameter("le2") + assert replace(t, params=(le2,)).params == (le2, s) + lA = Parameter("log_A") + k = kernel( + tinygp.kernels.ExpSquared(), + amplitude=constant_amplitude, + amplitude_params=(lA,), + coords=Transform(lambda a, s: a * s, (s,)), + ) + k2 = replace(k, on=None) + assert k2.params == (lA, s) + np.testing.assert_allclose( + k2.value(x, y, y, 0.0, 1.0), k.value(x, y, y, 0.0, 1.0) + ) + + def test_non_numeric_x_reaches_a_callable_term(self): + x = np.empty(3, dtype=object) + x[:] = [(10.0, 0.1), (10.0, 0.2), (20.0, 0.1)] # (E, theta) pairs + t = Term(lambda c: np.array([e for e, _ in c.x]) / 100.0, kind="diag") + np.testing.assert_allclose(t.value(x, np.ones(3), None), [0.1, 0.1, 0.2]) + le = Parameter("le") + np.testing.assert_allclose( + noise(le).value(x, np.ones(3), None, np.log(0.3)), 0.3 + ) + + +# ---------------------------------------------------------------------------- +# Factories +# ---------------------------------------------------------------------------- + + +class TestFactories: + def setup_method(self): + self.x = np.array([0.5, 1.0, 1.5]) + self.y = np.array([1.0, 2.0, 3.0]) + self.ym = np.array([1.1, 1.9, 3.2]) + self.stat = np.array([0.1, 0.2, 0.3]) + + def S(self, terms, values=()): + return dense(terms, self.x, self.y, self.ym, values) + + def test_statistical_only(self): + assert np.allclose(self.S([statistical(self.stat)]), np.diag(self.stat**2)) + + def test_unknown_noise(self): + assert np.allclose( + self.S([noise(Parameter("e"))], [(np.log(0.4),)]), 0.16 * np.eye(3) + ) + assert np.allclose( + self.S([noise(Parameter("e"), log=False)], [(0.4,)]), 0.16 * np.eye(3) + ) + + def test_unknown_proportional_error(self): + S = self.S([proportional_error(Parameter("e"))], [(np.log(0.4),)]) + assert np.allclose(S, np.diag((0.4 * self.ym) ** 2)) + + def test_unknown_normalization_error(self): + S = self.S([normalization(parameter=Parameter("n"))], [(np.log(0.05),)]) + assert np.allclose(S, 0.05**2 * np.outer(self.ym, self.ym)) + + def test_averaged_proportional_error(self): + S = self.S( + [proportional_error(Parameter("g"), averaging=True)], [(np.log(0.1),)] + ) + z = 0.5 * (self.y + self.ym) + assert np.allclose(S, np.diag((0.1 * z) ** 2)) + S = self.S( + [proportional_error(Parameter("g"), averaging=False)], [(np.log(0.1),)] + ) + assert np.allclose(S, np.diag((0.1 * self.ym) ** 2)) + + def test_fixed_normalization_systematic(self): + for mag in (0.05, np.array(0.05)): + S = self.S([normalization(magnitude=mag)]) + assert np.allclose(S, 0.05**2 * np.outer(self.ym, self.ym)) + + def test_fixed_offset_systematic(self): + t = offset(magnitude=0.2) + assert t.is_constant + assert np.allclose(self.S([t]), 0.04 * np.ones((3, 3))) + v = np.array([0.1, 0.2, 0.3]) + assert np.allclose(self.S([offset(magnitude=v)]), np.outer(v, v)) + + def test_fixed_offset_is_evaluated_without_ym(self): + t = offset(magnitude=0.2) + np.testing.assert_allclose(t.value(self.x, self.y, None), 0.2) + + def test_masked_magnitudes(self): + m = np.array([1.0, 0.0, 1.0]) + S = self.S([offset(magnitude=0.2, mask=m)]) + assert np.allclose(S, np.outer(0.2 * m, 0.2 * m)) + S = self.S([normalization(parameter=Parameter("n"), mask=m)], [(np.log(0.5),)]) + v = 0.5 * m * self.ym + assert np.allclose(S, np.outer(v, v)) + + def test_length_one_magnitude_or_mask_raises(self): + with pytest.raises(ValueError, match="shape"): + self.S([offset(magnitude=np.array([0.2]))]) + with pytest.raises(ValueError, match="shape"): + self.S([offset(magnitude=0.2, mask=np.array([1.0]))]) + with pytest.raises(ValueError, match="shape"): + self.S( + [normalization(parameter=Parameter("n"), mask=np.array([1.0]))], + [(0.0,)], + ) + + def test_magnitude_length_mismatch_raises(self): + with pytest.raises(ValueError): + self.S([offset(magnitude=np.ones(2))]) + + def test_requires_magnitude_or_parameter(self): + with pytest.raises(ValueError): + offset() + with pytest.raises(ValueError): + normalization() + + def test_systematic_with_basis(self): + S = self.S([systematic(Parameter("s"), basis=x_basis(2.0))], [(np.log(3.0),)]) + v = 3.0 * self.x / 2.0 + assert np.allclose(S, np.outer(v, v)) + + def test_parametric_basis(self): + e, sl = Parameter("log e"), Parameter("slope") + t = noise(e, basis=exp_growth(np.pi), basis_params=(sl,)) + assert t.params == (e, sl) + assert np.allclose(self.S([t], [(np.log(0.3), 0.0)]), 0.09 * np.eye(3)) + S = self.S([t], [(np.log(0.3), 2.0)]) + assert np.allclose(S, np.diag((0.3 * np.exp(2.0 * self.x / np.pi)) ** 2)) + t = noise(e, basis=exp_growth(np.pi, base=ym), basis_params=(sl,)) + S = self.S([t], [(np.log(0.3), 1.0)]) + assert np.allclose(S, np.diag((0.3 * self.ym * np.exp(self.x / np.pi)) ** 2)) + + def test_old_observation_covariance_equivalence(self): + off, norm = 0.2, 0.05 + terms = [ + statistical(self.stat), + offset(magnitude=off), + normalization(magnitude=norm), + ] + old = ( + np.diag(self.stat**2) + + np.outer(off * np.ones(3), off * np.ones(3)) + + norm**2 * np.outer(self.ym, self.ym) + ) + assert np.allclose(self.S(terms), old) + + def test_bases(self): + c = TermContext(x=self.x, y=self.y, ym=self.ym) + assert np.allclose(ones(c), 1.0) + assert np.allclose(ym(c), self.ym) + assert np.allclose(averaging(c), 0.5 * (self.y + self.ym)) + + +class TestKernel: + def test_builder_arity_mismatch_fails_at_construction(self): + params = kernel_params(["v", "l"], [(-3.0, 1.0), (-3.0, 1.0)]) + build = lambda log_ell: tinygp.kernels.ExpSquared( # noqa: E731 + scale=jnp.exp(log_ell) + ) + with pytest.raises( + ValueError, match=r"takes \(log_ell\).*\['discrepancy_v', 'discrepancy_l'\]" + ): + kernel(build, params) + + def test_jitter_is_relative_to_each_points_own_variance(self): + """The nugget is added before the amplitude scales the kernel, so a + growing amplitude does not over-nugget its small end.""" + x = np.linspace(0.0, 1.0, 5) + a = np.exp(4.0 * x) + far = tinygp.kernels.ExpSquared(scale=1e-3) # off-diagonal ~ 0 + K = np.asarray(kernel(far, amplitude=a, jitter=1e-3).value(x, x)) + np.testing.assert_allclose(np.diag(K), (1.0 + 1e-3) * a**2) + + def test_builder_params_are_the_terms_params(self): + build, params = rbf() + t = kernel(build, params) + assert t.params == tuple(params) and t.n_kernel == 1 + assert [p.name for p in t.params] == ["discrepancy_length_scale"] + np.testing.assert_allclose(t.params[0].bounds, LOG_LENGTH_BOUNDS) + assert not t.is_constant + + def test_a_sum_of_kernels_in_one_builder(self): + # sklearn's ConstantKernel * RBF + WhiteKernel, written as one builder + lv, le, lw = kernel_params(["log_var", "log_ell", "log_white"]) + t = kernel( + lambda v, e, w: ( + jnp.exp(v) * tinygp.kernels.ExpSquared(scale=jnp.exp(e)) + + tinygp.kernels.Constant(jnp.exp(w)) * tinygp.kernels.Cosine(1e9) + ), + [lv, le, lw], + jitter=0.0, + ) + x = np.linspace(0.0, 2.0, 4) + S = t.value(x, np.zeros(4), np.zeros(4), np.log(2.0), np.log(0.5), -20.0) + ref = ConstantKernel(2.0) * RBF(0.5) + np.testing.assert_allclose(S, ref(x[:, None]), atol=1e-8) + + def test_anisotropic_metric_on_2d_inputs(self): + l0, l1 = kernel_params(["ell0", "ell1"]) + t = kernel( + # one length scale per input dimension: scale the inputs + lambda a, b: tinygp.transforms.Linear( + jnp.exp(-jnp.stack([a, b])), tinygp.kernels.ExpSquared() + ), + [l0, l1], + jitter=0.0, + ) + x2d = np.array([[0.0, 0.0], [1.0, 0.5], [2.0, 1.0]]) + S = t.value(x2d, np.zeros(3), np.zeros(3), np.log(1.0), np.log(0.5)) + np.testing.assert_allclose(S, RBF([1.0, 0.5])(x2d)) + + def test_fixed_kernel_is_constant(self): + t = kernel(tinygp.kernels.ExpSquared(scale=1.0)) + assert t.params == () and t.is_constant + with pytest.raises(ValueError, match="fixed kernel takes no params"): + kernel(tinygp.kernels.ExpSquared(scale=1.0), [Parameter("ell")]) + + def test_shared_hyperparameters_via_params(self): + build, params = rbf() + t1, t2 = kernel(build, params), kernel(build, params) + assert t1.params == t2.params == tuple(params) + + def test_constant_amplitude_reproduces_constant_kernel(self): + x = np.linspace(0.0, 2.0, 5) + A, la = 0.7, Parameter("log A") + t = kernel( + *rbf(), amplitude=constant_amplitude, amplitude_params=(la,), jitter=0.0 + ) + assert [p.name for p in t.params] == ["discrepancy_length_scale", "log A"] + S = dense([t], x, np.zeros(5), np.zeros(5), [(0.0, np.log(A))]) + ref = ConstantKernel(A**2, constant_value_bounds="fixed") * RBF(1.0) + np.testing.assert_allclose(S, ref(x[:, None])) + + def test_exp_growth_amplitude_and_coords(self): + x = np.linspace(0.1, 3.0, 4) + la, sl = Parameter("log A"), Parameter("slope") + + def q(x): + return 2.0 * jnp.sin(x / 2) + + t = kernel( + *matern52(), + coords=q, + amplitude=exp_growth_amplitude(np.pi), + amplitude_params=(la, sl), + jitter=0.0, + ) + S = dense([t], x, np.zeros(4), np.zeros(4), [(np.log(0.5), np.log(0.3), 1.5)]) + qx = np.asarray(q(x)) + a = 0.3 * np.exp(1.5 * qx / np.pi) # the amplitude sees the transformed x + np.testing.assert_allclose(S, np.outer(a, a) * Matern(0.5, nu=2.5)(qx[:, None])) + + def test_duplicate_coords_factorizable_with_jitter(self): + x = np.array([0.0, 0.0, 1.0]) + t = kernel(*rbf(), jitter=1e-8) + S = t.value(x, np.zeros(3), np.zeros(3), 0.0) + assert np.all(np.isfinite(np.linalg.cholesky(S))) + + +# ---------------------------------------------------------------------------- +# The alpha+Ca error-model ladder as one-line term lists +# ---------------------------------------------------------------------------- + + +@pytest.mark.parametrize("label", list(STUDY_LEGEND)) +def test_study_forms(label): + """Each error model of the motivating study (elastic alpha + Ca scattering + data with no reported uncertainties, compared in log space) is one term + list; the term values assemble to the hand-built dense covariance. The + labels are defined in ``helpers.STUDY_LEGEND``.""" + rng = np.random.default_rng(1) + n = 12 + x = np.sort(rng.uniform(0.2, 3.0, n)) # radians + y = rng.uniform(0.1, 1.5, n) + ym_ = y + rng.normal(0.0, 0.1, n) + form = study_form(label, x, y, ym_) + assert form.description # every label has a legend entry + S = dense(form.terms, x, y, ym_, form.values) + assert np.allclose(S, form.dense) + + +# ---------------------------------------------------------------------------- +# Term-level halves of recipes (the rest of each recipe needs a Problem) +# ---------------------------------------------------------------------------- + + +class TestRecipeHalves: + def test_recipe_19_bring_your_own_term(self): + x = np.linspace(0.0, 1.0, 4) + C = np.exp(-np.abs(x[:, None] - x[None, :])) # symmetric, PD + fixed = Term(C) + assert fixed.is_constant and np.allclose(fixed.value(x, np.zeros(4), None), C) + sig = np.array([0.1, 0.2, 0.3, 0.4]) + stat = Term(sig, kind="diag") + assert np.allclose(dense([stat], x, np.zeros(4), None), np.diag(sig**2)) + e, sl = Parameter("log_e"), Parameter("slope") + custom = Term( + lambda c, e, l: jnp.exp(e) * jnp.exp(l * c.x / np.pi), (e, sl), kind="diag" + ) + helper = noise(e, basis=exp_growth(np.pi), basis_params=(sl,)) + v = (np.log(0.3), 1.1) + np.testing.assert_allclose( + custom.value(x, np.zeros(4), None, *v), + helper.value(x, np.zeros(4), None, *v), + ) + + def test_recipe_27_normalization_mode_is_built_from_the_prediction(self): + x = np.linspace(0.0, 1.0, 3) + y, ym_ = np.array([1.0, 2.0, 3.0]), np.array([1.2, 1.8, 3.3]) + s = 0.1 + right = normalization(magnitude=s) + wrong = Term( + lambda c: s * c.y, kind="mode", constant=True + ) # data-built: Peelle + np.testing.assert_allclose(right.value(x, y, ym_), s * ym_) + np.testing.assert_allclose(wrong.value(x, y, ym_), s * y) + assert not np.allclose(right.value(x, y, ym_), wrong.value(x, y, ym_)) + + +class TestSegments: + """A term's view of the comparisons its support spans.""" + + def test_one_segment_outside_a_problem(self): + seen = {} + + def fn(c): + seen["segments"], seen["labels"] = c.segments, c.labels + seen["split"] = c.split(c.x) + return np.ones(len(c)) + + Term(fn, kind="mode").value(np.arange(3.0), np.zeros(3), np.zeros(3)) + assert seen["segments"] == (slice(0, 3),) and seen["labels"] == ("",) + np.testing.assert_array_equal(seen["split"][0], np.arange(3.0)) + + def test_explicit_segments_and_split(self): + def fn(c): + assert c.labels == ("a", "b") + parts = c.split(c.ym) + assert [len(p) for p in parts] == [2, 3] + return np.concatenate([p - p.mean() for p in parts]) + + t = Term(fn, kind="mode") + ym = np.array([1.0, 3.0, 10.0, 20.0, 30.0]) + v = t.value( + np.zeros(5), + np.zeros(5), + ym, + segments=[slice(0, 2), slice(2, 5)], + labels=["a", "b"], + ) + np.testing.assert_allclose(v, [-1.0, 1.0, -10.0, 0.0, 10.0]) + + def test_split_checks_length(self): + c = TermContext(x=np.zeros(3), y=np.zeros(3)) + with pytest.raises(ValueError, match="length 3"): + c.split(np.zeros(4)) + + +class TestKernelTerm: + """The kernel factory returns a Term that also carries its kernel.""" + + def test_fields(self): + build, params = rbf() + lA = Parameter("log_A") + t = kernel(build, params, amplitude=constant_amplitude, amplitude_params=(lA,)) + assert isinstance(t, KernelTerm) and isinstance(t, Term) + assert t.build is build and t.n_kernel == 1 + assert t.amplitude is constant_amplitude + assert [p.name for p in t.params] == ["discrepancy_length_scale", "log_A"] + assert t.kind == "matrix" and t.jitter == 1e-10 + # a fixed kernel has no kernel parameters and is constant + fixed = kernel(tinygp.kernels.ExpSquared(scale=1.0)) + assert fixed.n_kernel == 0 and fixed.is_constant and fixed.params == () + + +def test_a_relative_term_is_refused_outside_linear_space(): + """A fraction of the prediction is a relative error only in linear space: + in log space it would scale with log(y), so it is refused there.""" + from scipy import stats + + from rxmc import Comparison, Constraint, Dataset, Model + from rxmc import transforms as tf + + x = np.linspace(0.0, 1.0, 5) + d = Dataset(x, np.exp(-x), 0.05 * np.exp(-x)) + a = Parameter("a", prior=stats.norm(1.0, 0.1)) + model = Model(lambda x, a: a * jnp.exp(-x), [a]) + eps = Parameter("log_eps", prior=stats.norm(-3.0, 1.0)) + lin, log = Comparison(d, model), Comparison(d, model, space=tf.log) + Constraint([lin], terms=[proportional_error(eps)]) # linear space: fine + Constraint([log], terms=[noise(eps)]) # the relative error in log space + for term in (proportional_error(eps), normalization(eps)): + with pytest.raises(ValueError, match="relative error only in the identity"): + Constraint([log], terms=[term]) + with pytest.raises(ValueError, match="relative"): # on= picks the log one + Constraint([lin, log], terms=[proportional_error(eps, on=log)]) + Constraint([lin, log], terms=[proportional_error(eps, on=lin)]) + with pytest.raises(ValueError, match="relative"): # on=None spans both + Constraint([lin, log], terms=[proportional_error(eps)]) + d2 = Dataset(x, np.exp(-x), 0.05 * np.exp(-x)) + with pytest.raises(ValueError, match="relative"): # on= a dataset + Constraint( + [lin, Comparison(d2, model, space=tf.log)], + terms=[normalization(eps, on=d2)], + ) diff --git a/test/test_transforms.py b/test/test_transforms.py index f1e4edc..13059f1 100644 --- a/test/test_transforms.py +++ b/test/test_transforms.py @@ -1,41 +1,32 @@ """Tests for the low-level ``rxmc.transforms`` type.""" -import unittest - import numpy as np +import pytest -from rxmc.observation import Observation -from rxmc.params import Parameter -from rxmc.transforms import ( - Transform, - as_transform, - exp, - identity, - log, - per_observation_scaling, - scale, -) +from rxmc import Parameter +from rxmc.transforms import Transform, as_transform, exp, identity, log, scale -class TestTransform(unittest.TestCase): +class TestTransform: def test_callable_is_wrapped_parameter_free(self): t = as_transform(np.sqrt) - self.assertIsInstance(t, Transform) - self.assertEqual(t.params, ()) + assert isinstance(t, Transform) + assert t.params == () np.testing.assert_allclose(t([4.0, 9.0]), [2.0, 3.0]) - self.assertIs(as_transform(None), identity) - self.assertIs(as_transform(t), t) + assert as_transform(None) is identity + assert as_transform(t) is t def test_log_is_safe_and_invertible(self): y = np.array([1.0, 0.0, -2.0, np.e]) out = log(y) - self.assertEqual(out[0], 0.0) - self.assertEqual(out[1], -np.inf) - self.assertEqual(out[2], -np.inf) - self.assertAlmostEqual(out[3], 1.0) + assert out[0] == 0.0 + assert out[1] == -np.inf + assert out[2] == -np.inf + assert out[3] == pytest.approx(1.0) np.testing.assert_allclose(log.derivative(np.array([2.0, 4.0])), [0.5, 0.25]) - self.assertIs(log.inverse, exp) - self.assertIs(exp.inverse, log) + assert log.inverse is exp + assert exp.inverse is log + assert identity.inverse is identity np.testing.assert_allclose(exp(log(np.array([3.0, 7.0]))), [3.0, 7.0]) def test_finite_difference_derivative_fallback(self): @@ -50,23 +41,31 @@ def test_compose_order_and_params(self): lambda a, c: a + c, (p,), derivative=lambda a, c: np.ones_like(a) ) t = shift | log # log(a + c) - self.assertEqual(t.params, (p,)) + assert t.params == (p,) np.testing.assert_allclose(t(np.array([1.0]), 1.0), [np.log(2.0)]) np.testing.assert_allclose(t.derivative(np.array([1.0]), 1.0), [0.5]) - self.assertIsNone(t.inverse) # parametric -> no inverse + assert t.inverse is None # parametric -> no inverse u = log | exp np.testing.assert_allclose(u(np.array([2.0])), [2.0]) - self.assertIsNotNone(u.inverse) + assert u.inverse is not None def test_wrong_value_count_raises(self): - with self.assertRaises(ValueError): + with pytest.raises(ValueError, match="expects 1 value"): scale()(np.ones(2)) + def test_params_must_be_parameters(self): + with pytest.raises(TypeError, match="Parameter"): + Transform(lambda a, c: a + c, ("c",)) + + def test_no_context_keyword(self): + with pytest.raises(TypeError): + identity(np.ones(2), context=object()) -class TestScale(unittest.TestCase): + +class TestScale: def test_log_scale(self): t = scale() - self.assertEqual(t.params[0].name, "log_rho") + assert t.params[0].name == "log_rho" np.testing.assert_allclose(t(np.array([1.0, 2.0]), np.log(3.0)), [3.0, 6.0]) np.testing.assert_allclose( t.derivative(np.array([1.0, 2.0]), np.log(3.0)), [3.0, 3.0] @@ -74,55 +73,7 @@ def test_log_scale(self): def test_linear_scale_names(self): t = scale(log=False) - self.assertEqual(t.params[0].name, "rho") + assert t.params[0].name == "rho" np.testing.assert_allclose(t(np.array([1.0, 2.0]), 3.0), [3.0, 6.0]) t2 = scale(Parameter("eta"), log=False) - self.assertEqual(t2.params[0].name, "eta") - - -class TestPerObservationScaling(unittest.TestCase): - def setUp(self): - self.o1 = Observation(np.array([1.0]), np.array([1.0])) - self.o2 = Observation(np.array([1.0]), np.array([1.0])) - - def test_routes_by_identity(self): - t = per_observation_scaling([self.o1, self.o2]) - self.assertEqual([p.name for p in t.params], ["log_rho_0", "log_rho_1"]) - a = np.array([1.0, 2.0]) - np.testing.assert_allclose( - t(a, np.log(2.0), np.log(5.0), context=self.o2), [5.0, 10.0] - ) - np.testing.assert_allclose( - t(a, np.log(2.0), np.log(5.0), context=self.o1), [2.0, 4.0] - ) - with self.assertRaises(KeyError): - t(a, 0.0, 0.0, context=Observation(np.array([1.0]), np.array([1.0]))) - - def test_masked_view_routes_to_root(self): - t = per_observation_scaling([self.o1, self.o2]) - view = self.o2.masked(np.array([False])) - self.assertIs(view.identity, self.o2) - a = np.array([1.0]) - np.testing.assert_allclose(t(a, 0.0, np.log(5.0), context=view), [5.0]) - # registering a view and its root is still a duplicate - with self.assertRaises(ValueError): - per_observation_scaling([self.o2, view]) - - def test_missing_context_raises(self): - t = per_observation_scaling([self.o1]) - with self.assertRaisesRegex(ValueError, "contextual"): - t(np.array([1.0]), 0.0) - - def test_linear_and_custom_parameters(self): - t = per_observation_scaling([self.o1], log=False) - self.assertEqual(t.params[0].name, "rho_0") - t2 = per_observation_scaling([self.o1], parameters=[Parameter("n")]) - self.assertEqual(t2.params[0].name, "n") - with self.assertRaises(ValueError): - per_observation_scaling([self.o1, self.o2], parameters=[Parameter("n")]) - with self.assertRaises(ValueError): - per_observation_scaling([self.o1, self.o1]) - - -if __name__ == "__main__": - unittest.main() + assert t2.params[0].name == "eta" diff --git a/test/test_units.py b/test/test_units.py new file mode 100644 index 0000000..be31804 --- /dev/null +++ b/test/test_units.py @@ -0,0 +1,61 @@ +"""The unit contract: a fixed vocabulary of labels, consistent constants.""" + +import numpy as np +import pytest + +from rxmc.units import ( + DEFAULT_LMAX, + MB_PER_B, + RUTHERFORD_UNIT, + XS_UNIT, + check_angle_grid, + parse_unit, +) + + +def test_unit_constants_agree(): + assert MB_PER_B == 1000.0 + assert parse_unit(RUTHERFORD_UNIT)[0] == pytest.approx(1.0 / MB_PER_B) + assert parse_unit(XS_UNIT) == (1.0, "differential") + assert DEFAULT_LMAX == 20 + + +@pytest.mark.parametrize( + "label, factor, kind", + [ + ("barns/ster", 1.0, "differential"), # what exfor_tools emits + ("b/Sr", 1.0, "differential"), + ("MB/SR", 1e-3, "differential"), # raw EXFOR spelling + ("barn / steradian", 1.0, "differential"), + ("millibarn / steradian", 1e-3, "differential"), + ("MICRO-B/SR", 1e-6, "differential"), + ("barns", 1.0, "integral"), + ("mb", 1e-3, "integral"), + ("no-dim", 1.0, "dimensionless"), + ("unitless", 1.0, "dimensionless"), + ("NO-DIM", 1.0, "dimensionless"), + ], +) +def test_parse_unit_vocabulary(label, factor, kind): + f, k = parse_unit(label) + assert f == pytest.approx(factor) + assert k == kind + + +def test_parse_unit_rejects_unknown_label(): + with pytest.raises(ValueError, match="unknown unit label 'fm\\^2'"): + parse_unit("fm^2") + with pytest.raises(ValueError, match="accepted labels"): + parse_unit("MeV") + + +def test_check_angle_grid(): + check_angle_grid(np.linspace(0.0, np.pi, 5), "angles") + with pytest.raises(ValueError, match="1D"): + check_angle_grid(np.zeros((2, 2)), "angles") + with pytest.raises(ValueError, match="radians"): + check_angle_grid(np.array([0.0, 4.0]), "angles") + with pytest.raises(ValueError, match="radians"): + check_angle_grid(np.array([-0.1, 1.0]), "angles") + with pytest.raises(ValueError, match="finite"): + check_angle_grid(np.array([0.3, np.nan, 1.0]), "angles") diff --git a/uv.lock b/uv.lock new file mode 100644 index 0000000..cc438ca --- /dev/null +++ b/uv.lock @@ -0,0 +1,3884 @@ +version = 1 +revision = 3 +requires-python = ">=3.12" +resolution-markers = [ + "python_full_version >= '3.14' and sys_platform == 'win32'", + "python_full_version >= '3.14' and sys_platform == 'emscripten'", + "python_full_version >= '3.14' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version >= '3.14' and sys_platform == 'darwin'", + "python_full_version == '3.13.*' and sys_platform == 'win32'", + "python_full_version < '3.13' and sys_platform == 'win32'", + "python_full_version == '3.13.*' and sys_platform == 'emscripten'", + "python_full_version < '3.13' and sys_platform == 'emscripten'", + "python_full_version == '3.13.*' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.13.*' and sys_platform == 'darwin'", + "python_full_version < '3.13' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version < '3.13' and sys_platform == 'darwin'", +] + +[[package]] +name = "absl-py" +version = "2.5.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1f/1d/58e2b5a6e4d703ccb2a029943d665974cb3d5a4fb2b3e3675dd03a9df10e/absl_py-2.5.1.tar.gz", hash = "sha256:286e71c82c1a38e75bbcf185f9b37d0305ad7786535107cb49bf4df9ff2e1f95", size = 118387, upload-time = "2026-10-09T08:38:58.037Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b3/7d/01e62f59e4166af1be6238d9f2b7f3453630c51b8044b412d05b5606532a/absl_py-2.5.1-py3-none-any.whl", hash = "sha256:721200f2f0e9960f2ca9dc3a2a706b201f5f75d812c158f059cbbe29eeafbdb8", size = 137673, upload-time = "2026-10-09T08:38:56.629Z" }, +] + +[[package]] +name = "accessible-pygments" +version = "0.0.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pygments" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/bc/c1/bbac6a50d02774f91572938964c582fff4270eee73ab822a4aeea4d8b11b/accessible_pygments-0.0.5.tar.gz", hash = "sha256:40918d3e6a2b619ad424cb91e556bd3bd8865443d9f22f1dcdf79e33c8046872", size = 1377899, upload-time = "2024-05-10T11:23:10.216Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8d/3f/95338030883d8c8b91223b4e21744b04d11b161a3ef117295d8241f50ab4/accessible_pygments-0.0.5-py3-none-any.whl", hash = "sha256:88ae3211e68a1d0b011504b2ffc1691feafce124b845bd072ab6f9f66f34d4b7", size = 1395903, upload-time = "2024-05-10T11:23:08.421Z" }, +] + +[[package]] +name = "alabaster" +version = "1.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a6/f8/d9c74d0daf3f742840fd818d69cfae176fa332022fd44e3469487d5a9420/alabaster-1.0.0.tar.gz", hash = "sha256:c00dca57bca26fa62a6d7d0a9fcce65f3e026e9bfe33e9c538fd3fbb2144fd9e", size = 24210, upload-time = "2024-07-26T18:15:03.762Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7e/b3/6b4067be973ae96ba0d615946e314c5ae35f9f993eca561b356540bb0c2b/alabaster-1.0.0-py3-none-any.whl", hash = "sha256:fc6786402dc3fcb2de3cabd5fe455a2db534b371124f1f21de8731783dec828b", size = 13929, upload-time = "2024-07-26T18:15:02.05Z" }, +] + +[[package]] +name = "anyio" +version = "4.15.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "idna" }, + { name = "typing-extensions", marker = "python_full_version < '3.15'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a9/d2/f4d173e22df740bc37b1db102b386ba719b66e95b0f0d751f556b387e6d2/anyio-4.15.1.tar.gz", hash = "sha256:9f28306018cbd6d329e64a36d58256edff76dd996fe423bc957326e578b82a94", size = 276966, upload-time = "2026-09-05T10:42:39.44Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/12/b8/4bd346e22b28902df4d651910f5242c28d84e4a5c2435ca5c3f797ed7e2e/anyio-4.15.1-py3-none-any.whl", hash = "sha256:6152fdbbf9a77fdec97731721bebf7c4c44f7c29b424b0065826173efc7ed101", size = 132079, upload-time = "2026-09-05T10:42:37.923Z" }, +] + +[[package]] +name = "appnope" +version = "1.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/11/f7/a82489c2b6ebe32d3e2831895ae19c77861f0eadf3bb16034484d965dbb2/appnope-1.0.0.tar.gz", hash = "sha256:685db59cb6043c3c2e528adc0b3bce3a5f8d09bcf7492c6ea650d1b7421f3c49", size = 5454, upload-time = "2026-08-20T21:36:13.748Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/46/c7/6b687cb0f83d2a51017d47953f2ee430ffad6fec2a8ebc964e0718a33eb1/appnope-1.0.0-py3-none-any.whl", hash = "sha256:6fe0c04218aab65c54c4ff81638cdbf848d89f5653b74d68638a137f200dd16e", size = 4158, upload-time = "2026-08-20T21:36:12.444Z" }, +] + +[[package]] +name = "argon2-cffi" +version = "25.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "argon2-cffi-bindings" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/0e/89/ce5af8a7d472a67cc819d5d998aa8c82c5d860608c4db9f46f1162d7dab9/argon2_cffi-25.1.0.tar.gz", hash = "sha256:694ae5cc8a42f4c4e2bf2ca0e64e51e23a040c6a517a85074683d3959e1346c1", size = 45706, upload-time = "2025-06-03T06:55:32.073Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4f/d3/a8b22fa575b297cd6e3e3b0155c7e25db170edf1c74783d6a31a2490b8d9/argon2_cffi-25.1.0-py3-none-any.whl", hash = "sha256:fdc8b074db390fccb6eb4a3604ae7231f219aa669a2652e0f20e16ba513d5741", size = 14657, upload-time = "2025-06-03T06:55:30.804Z" }, +] + +[[package]] +name = "argon2-cffi-bindings" +version = "26.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cffi" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/0b/43/bb8b6e8708d49a5ab36781333af092d9f483b198a2710d01281204640055/argon2_cffi_bindings-26.1.0.tar.gz", hash = "sha256:63505c71542a44b68b1e38060450fb006404170da375feb31af153e7f9c6205d", size = 1790807, upload-time = "2026-08-20T07:44:22.492Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e7/d2/0ae991f1b2181e5be49007c574710a800ad36c2978683addb3e67c474e55/argon2_cffi_bindings-26.1.0-cp310-abi3-macosx_11_0_arm64.whl", hash = "sha256:21ca0396fe5ec995dd54431c32698189666f9224810acfa752e50d2bd94d9df2", size = 25521, upload-time = "2026-08-20T07:32:43.019Z" }, + { url = "https://files.pythonhosted.org/packages/7e/e4/ad91d8297638aa2258aad4501c306aca99480dfe76ccd638173fa3702db9/argon2_cffi_bindings-26.1.0-cp310-abi3-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:78de2d65e0b9ea7ce9d1b1c3e87297b2d7305a02c266ee2a2d6910daddd7ee69", size = 27177, upload-time = "2026-08-20T07:32:44.158Z" }, + { url = "https://files.pythonhosted.org/packages/6f/86/5363df11b86d02cf3662208e7406496327649cc90eb365bf6f4e8a54a41f/argon2_cffi_bindings-26.1.0-cp310-abi3-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:27f1821903e2ceadcb88ec2b45ef190897b7682449c772f4d9b53e42c520cf29", size = 26597, upload-time = "2026-08-20T07:32:45.172Z" }, + { url = "https://files.pythonhosted.org/packages/f4/b5/a14dcc592652347dad23ee93b278a4da5d2a25c9ed3ebd10d68eea823a4f/argon2_cffi_bindings-26.1.0-cp310-abi3-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d88e5f7e60f28ae0b0cc6b2f16c43e87cd642a196a86f85e0d8bb6fe016fc16d", size = 27403, upload-time = "2026-08-20T07:32:46.13Z" }, + { url = "https://files.pythonhosted.org/packages/b3/81/b4a20d4902af7f796390bf9245ff83c5217dfa7367efa1d14986956c482b/argon2_cffi_bindings-26.1.0-cp310-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:34b7d9c24a4165a2c61cc8ae11d44d48c9ce2830fb536cb7914e11fdd9962728", size = 27132, upload-time = "2026-08-20T07:32:47.13Z" }, + { url = "https://files.pythonhosted.org/packages/7e/1b/c8de358af07b1c490e0fcb863ef98e46ddb486e45567aca5a60bd68d9daa/argon2_cffi_bindings-26.1.0-cp310-abi3-musllinux_1_2_riscv64.whl", hash = "sha256:224865cbbcb7a2bd1356741dff12b0134df726b6d44bb7b500df8e303cbd9e81", size = 27588, upload-time = "2026-08-20T07:32:48.087Z" }, + { url = "https://files.pythonhosted.org/packages/48/2f/7ee62a6e79f9309f9d9982d301b22a00010adb580c05c8109b94d7b33de0/argon2_cffi_bindings-26.1.0-cp310-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:ffff613aaa9ce6236766e2fc6dc560bb5abde7a2e2416e3db1f9ae395a2b4dd4", size = 26785, upload-time = "2026-08-20T07:32:48.977Z" }, + { url = "https://files.pythonhosted.org/packages/e9/10/960d0ee93d4897741bcaf4799c697dae2d81499f66fd1ed042a7dd54c1f4/argon2_cffi_bindings-26.1.0-cp310-abi3-win32.whl", hash = "sha256:a86c069c91a747a2c4e5c51473590aeb48172fff9b2130d23729a42d98665ecb", size = 23898, upload-time = "2026-08-20T07:32:50.114Z" }, + { url = "https://files.pythonhosted.org/packages/6d/3a/0cc14a05810e6add9bce5e87693334baa2222de5f647fa31781885b6573f/argon2_cffi_bindings-26.1.0-cp310-abi3-win_amd64.whl", hash = "sha256:2c36ff87b5dfaa477d0bd51e9d7f6abdae7c8955d2983c97419085d842154b3e", size = 25730, upload-time = "2026-08-20T07:32:51.091Z" }, + { url = "https://files.pythonhosted.org/packages/4e/db/d83cf2af140547f0b9cdaece05b2dc2dcbf991be4667331d073eff771435/argon2_cffi_bindings-26.1.0-cp310-abi3-win_arm64.whl", hash = "sha256:f9c4420a7a864fe1b86ce35befc95b8e39fb852493b81cf798671ddc265de638", size = 24478, upload-time = "2026-08-20T07:32:52.111Z" }, + { url = "https://files.pythonhosted.org/packages/bb/5f/f652055e18d2627e2eed94c7f31a792127cfe38df786635395d742321674/argon2_cffi_bindings-26.1.0-cp313-cp313-pyemscripten_2025_0_wasm32.whl", hash = "sha256:af11ac37a7c53dc16cb7950a6190851b0870fe218b6c60c0bb7ac355234e3083", size = 15434, upload-time = "2026-08-20T07:32:53.143Z" }, + { url = "https://files.pythonhosted.org/packages/76/38/de696045960f5b846d428c0fb6c130ed3da87aac2af209b05c193815404c/argon2_cffi_bindings-26.1.0-cp314-cp314-pyemscripten_2026_0_wasm32.whl", hash = "sha256:db0fcd827ca61622a01b220aadfbece01939acf53888f2cb98cd93e9b1e2c97e", size = 15449, upload-time = "2026-08-20T07:32:54.075Z" }, + { url = "https://files.pythonhosted.org/packages/91/0a/c25af768f6b75a5a71e31207f87c540656b2808c015260444a22763221ad/argon2_cffi_bindings-26.1.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:28524438cd3e723f25412f63d4fd516ff5bae9ae5aa56acbe2a1404398a0cf31", size = 25683, upload-time = "2026-08-20T07:32:55.05Z" }, + { url = "https://files.pythonhosted.org/packages/a8/7e/be212c751ab0bcea7f646615f933bf262e8e50b3f7bef32f861d0a2d066b/argon2_cffi_bindings-26.1.0-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ac82fc756a446b6ccd7139ce70efa9d8bbe541e7ad579a12dcb52764b7175c5f", size = 27311, upload-time = "2026-08-20T07:32:56.166Z" }, + { url = "https://files.pythonhosted.org/packages/a6/ee/f84b28e4afd13d3cac36c1d8fa8c239d2dc2c51cd978d02ee5d5ad98d9bb/argon2_cffi_bindings-26.1.0-cp314-cp314t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6a4e68eed961a8de6928d1c17ff3dc2a547e0e923c17f8f1cd79fb7bc9502f98", size = 26771, upload-time = "2026-08-20T07:32:57.206Z" }, + { url = "https://files.pythonhosted.org/packages/21/c3/95c07a023691ecd529da9cb6a8f0779e13ebc1bdfaa86d145fdc1c6e7e79/argon2_cffi_bindings-26.1.0-cp314-cp314t-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:151dfaad9de753f4af2a7854e707e4784f2acc434340ade64239c5b104b2d605", size = 27568, upload-time = "2026-08-20T07:32:58.361Z" }, + { url = "https://files.pythonhosted.org/packages/e6/31/3a18e31406d8694b4d6a31573c3e572fff6bed318bb744453eb653766d22/argon2_cffi_bindings-26.1.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:061a6919145bbf282ebf1f9c59d3135d4833c25313c8595c0d68cf7712ddfce2", size = 27280, upload-time = "2026-08-20T07:32:59.343Z" }, + { url = "https://files.pythonhosted.org/packages/0b/39/d4be4577e178b2397aa5b5575c8a309bf0da2afe05fe0c72c8f398662d63/argon2_cffi_bindings-26.1.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:62ff20cd130c956c7c9144d5fe35228f98b51c579b2439e988b27ef93e16c02a", size = 27776, upload-time = "2026-08-20T07:33:00.325Z" }, + { url = "https://files.pythonhosted.org/packages/71/47/78f4dd96f7411339f723b96fe24039c1bd5835102b8a5ba71ac4ec712ac7/argon2_cffi_bindings-26.1.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:19423e5d7ac1cc354baab59eaabf18db2ec04ef6593b5abe5a34f323c4a8f87a", size = 26932, upload-time = "2026-08-20T07:33:01.272Z" }, + { url = "https://files.pythonhosted.org/packages/3b/cd/96bfd37434cc0a848a9066c291d84b28846c4c9ea289ed9866b1164d622b/argon2_cffi_bindings-26.1.0-cp314-cp314t-win32.whl", hash = "sha256:4f84cdd868978d7b7350a566c254042d44216d9e37f241f3a6d3b1dfebeede35", size = 24878, upload-time = "2026-08-20T07:33:02.189Z" }, + { url = "https://files.pythonhosted.org/packages/f1/42/d8b6810abd9b1bd2f47ebbccf460da59c9f32e94888bea4f7b137d998797/argon2_cffi_bindings-26.1.0-cp314-cp314t-win_amd64.whl", hash = "sha256:2b741888c93147444fdfc851abd81cc207f37f7f7da42062a00deb3888e57da8", size = 26656, upload-time = "2026-08-20T07:33:03.222Z" }, + { url = "https://files.pythonhosted.org/packages/a9/d1/095d95eaf2ed1d9f77268cf3291bde148c6cd56121f8db2c74c1ba618a0e/argon2_cffi_bindings-26.1.0-cp314-cp314t-win_arm64.whl", hash = "sha256:6ab674f668d5962a3a4136ae0812519b0f1586874263723a32181d60d64137e1", size = 25378, upload-time = "2026-08-20T07:33:04.332Z" }, + { url = "https://files.pythonhosted.org/packages/66/cb/214092c39c4dbcb72cf98b12234ddac2221f8fe2c0acf29c6a70fa83be53/argon2_cffi_bindings-26.1.0-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:1d98e33bd8bd67d7206c124e200bf2229c4cfa8c9c19f7b44a897f0fc71837eb", size = 25683, upload-time = "2026-08-20T07:33:05.337Z" }, + { url = "https://files.pythonhosted.org/packages/83/e5/02015b83e9b05ccb85ff2ced424cf6e83a12d3810bc7f66d679a92b69ffb/argon2_cffi_bindings-26.1.0-cp315-cp315t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ccaf0a46cbb380f1fd102a874e32aa629fd3cb0c0e94f4943fa1f6d5edc5dac6", size = 27310, upload-time = "2026-08-20T07:33:06.344Z" }, + { url = "https://files.pythonhosted.org/packages/c3/4a/85e612787d0796878b3b4f6bd53dcd5484b6fe7b64cc6fc7b6e6a04cf835/argon2_cffi_bindings-26.1.0-cp315-cp315t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f0c3103fcff20183e593459cfea6e012281c0e76ae3ed8b5565ad1b92eac3990", size = 26771, upload-time = "2026-08-20T07:33:07.429Z" }, + { url = "https://files.pythonhosted.org/packages/f6/84/ccb003b6f9969820e87656398f4d49c857def71a85ca1588a0e809afd7ce/argon2_cffi_bindings-26.1.0-cp315-cp315t-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c49e853a3bef9dd10329f31f702e7fa9b5c58229ff9c2ff6d069efaf09177c08", size = 27569, upload-time = "2026-08-20T07:33:08.598Z" }, + { url = "https://files.pythonhosted.org/packages/88/07/c26b76debf0998ee08fbe947ab2058ac5de37d4b9d46b06c17abaa6c4ce9/argon2_cffi_bindings-26.1.0-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:6376d4b3aca039375ca8bf92f770da0ec424a1ce3a37077a8d3c557411aa56ca", size = 27279, upload-time = "2026-08-20T07:33:09.518Z" }, + { url = "https://files.pythonhosted.org/packages/ee/0d/ead6ddc029f91bc9b9390686dad3c808ab08100d348f6266b5f93f8970ee/argon2_cffi_bindings-26.1.0-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:9bacedc04b0402837586a17f0919e3dfdd95291f441f1f56bd80ec274c2840a1", size = 27774, upload-time = "2026-08-20T07:33:10.728Z" }, + { url = "https://files.pythonhosted.org/packages/7d/47/c108530d9eb86036b78d3af4de28b83b4a2d9a70512bd10ff8e59966aab4/argon2_cffi_bindings-26.1.0-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:76ae29acace5d33355344612844d588e19deaaba4639d8bb01601e4b1418ef36", size = 26933, upload-time = "2026-08-20T07:33:11.661Z" }, + { url = "https://files.pythonhosted.org/packages/a9/02/0bfc59e781c89acf64c31c388aade9d9d1c1ea38aa1ba1292fe07f607fe9/argon2_cffi_bindings-26.1.0-cp315-cp315t-win32.whl", hash = "sha256:df612391feca41c44d20118f3b88d1b86419465cd1f5496859f715ca60ec2210", size = 24875, upload-time = "2026-08-20T07:33:12.616Z" }, + { url = "https://files.pythonhosted.org/packages/61/c7/c3e46068cddffccecb8ad94d71135e9bf62bbc789589e7dfadc7c6f59214/argon2_cffi_bindings-26.1.0-cp315-cp315t-win_amd64.whl", hash = "sha256:1a0a29ed86960e44eaace7e081bdfab4f08b012fd96ec8edba71e2ad020939e4", size = 26655, upload-time = "2026-08-20T07:33:13.521Z" }, + { url = "https://files.pythonhosted.org/packages/f4/ca/18b9c8c45fecf34b9100ec6d7946057f14a158f2eaa20ea123a3e82351cb/argon2_cffi_bindings-26.1.0-cp315-cp315t-win_arm64.whl", hash = "sha256:d157ddfab1e8b21f2f1dedda9c09645d98b5ed0b667b0626be600a345d426440", size = 25376, upload-time = "2026-08-20T07:33:14.491Z" }, +] + +[[package]] +name = "arrow" +version = "1.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "python-dateutil" }, + { name = "tzdata" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b9/33/032cdc44182491aa708d06a68b62434140d8c50820a087fac7af37703357/arrow-1.4.0.tar.gz", hash = "sha256:ed0cc050e98001b8779e84d461b0098c4ac597e88704a655582b21d116e526d7", size = 152931, upload-time = "2025-10-18T17:46:46.761Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ed/c9/d7977eaacb9df673210491da99e6a247e93df98c715fc43fd136ce1d3d33/arrow-1.4.0-py3-none-any.whl", hash = "sha256:749f0769958ebdc79c173ff0b0670d59051a535fa26e8eba02953dc19eb43205", size = 68797, upload-time = "2025-10-18T17:46:45.663Z" }, +] + +[[package]] +name = "arviz" +version = "1.3.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "arviz-base" }, + { name = "arviz-plots" }, + { name = "arviz-stats", extra = ["xarray"] }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e6/f2/d295913894dfc5021dc8d1c5a865c4ff3da73ddc3227d1ed1b8ce48a375d/arviz-1.3.0.tar.gz", hash = "sha256:9e332c0a0da370cb1c00823678065e9b0462fbdf1efa0f38c37485cc78c8a576", size = 8723, upload-time = "2026-08-11T08:17:43.668Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/67/b7/f37610512b621cda1153dd82ff61678b787545a2914eaa2b8daacaeee924/arviz-1.3.0-py3-none-any.whl", hash = "sha256:16ab348e94c80295d205ea65e695d835b66daef8b31eddf71b88fd9b48490a85", size = 9219, upload-time = "2026-08-11T08:17:42.379Z" }, +] + +[[package]] +name = "arviz-base" +version = "1.3.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "lazy-loader" }, + { name = "numpy" }, + { name = "typing-extensions" }, + { name = "xarray" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/d1/e6/4cbf049a330a6b36cb4c2ed6913564965d397e30304b1e1ac13067630d26/arviz_base-1.3.1.tar.gz", hash = "sha256:f83c49d1842ca93821d38bc03f1d75df18d56d507694804a07ce6c1b3bbf2d6c", size = 1410984, upload-time = "2026-09-25T09:43:21.898Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/34/8f/1cdf6dbab034fdf9fea31c05599497b1d14e2f62d51a6045c1a647d93af4/arviz_base-1.3.1-py3-none-any.whl", hash = "sha256:4b4d60807f0e136af295a3c64aa13d87d3b7ba78b54acb015f6cb515ffd4b8fd", size = 1428088, upload-time = "2026-09-25T09:43:20.071Z" }, +] + +[[package]] +name = "arviz-plots" +version = "1.3.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "arviz-base" }, + { name = "arviz-stats", extra = ["xarray"] }, +] +sdist = { url = "https://files.pythonhosted.org/packages/4e/08/ff7e5f5edb4e019017a5754a9a211a4589c9d3d51127b64a7b61bf2da941/arviz_plots-1.3.2.tar.gz", hash = "sha256:040b5672f186e39ea21554f8fa60c01786798bd10eb0853cab1fc09e54eacead", size = 167771, upload-time = "2026-09-25T18:17:09.383Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/38/b8/d4c4938e3d3dfbb331c61c9e32b824ab692229eb750c87f705d896b7a2cd/arviz_plots-1.3.2-py3-none-any.whl", hash = "sha256:17d66e373eef7340ca25d8a318a4eebe29532ea76dc4723924d4608e21ed3c64", size = 253332, upload-time = "2026-09-25T18:17:07.804Z" }, +] + +[[package]] +name = "arviz-stats" +version = "1.3.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, + { name = "scipy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/80/e0/3d6815e0026a12b8719ff4dfdbaa7cc45d0c0e0cc7ae371d768fc08d2c6e/arviz_stats-1.3.3.tar.gz", hash = "sha256:3fed50cc2a9bb8e2719fd675691b1c332c15394e13d4b7a2bef64f6a6c2a6ccf", size = 180679, upload-time = "2026-09-25T10:20:45.105Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/eb/c5/b68639b3a766469838d7053b6929e092679d014e8d336034b67441cd0da7/arviz_stats-1.3.3-py3-none-any.whl", hash = "sha256:2fdd79ac91a95235c3820343a31ada37437a195a6d544b7561122429ba54771d", size = 209422, upload-time = "2026-09-25T10:20:42.934Z" }, +] + +[package.optional-dependencies] +xarray = [ + { name = "arviz-base" }, + { name = "xarray" }, + { name = "xarray-einstats" }, +] + +[[package]] +name = "asttokens" +version = "3.0.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/25/1e/faf0f247f6f881b98fc4d6d07e14085cb89d13665084e6d6ac1dc2c03d0b/asttokens-3.0.2.tar.gz", hash = "sha256:3ecdbd8f2cc195f53ccada3a613538bb5f9ef6f6869129f13e03c30a677b8fe2", size = 63136, upload-time = "2026-07-12T03:31:49.084Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d4/2b/04b8a15f3a1c77bc79ddf5c73875327f34b4fa75982df2b76e45e402d364/asttokens-3.0.2-py3-none-any.whl", hash = "sha256:9da13157f5b28becde0bd374fc677dcd3c290614264eff096f167c469cd9f933", size = 28702, upload-time = "2026-07-12T03:31:47.542Z" }, +] + +[[package]] +name = "async-lru" +version = "2.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e8/1f/989ecfef8e64109a489fff357450cb73fa73a865a92bd8c272170a6922c2/async_lru-2.3.0.tar.gz", hash = "sha256:89bdb258a0140d7313cf8f4031d816a042202faa61d0ab310a0a538baa1c24b6", size = 16332, upload-time = "2026-03-19T01:04:32.413Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e5/e2/c2e3abf398f80732e58b03be77bde9022550d221dd8781bf586bd4d97cc1/async_lru-2.3.0-py3-none-any.whl", hash = "sha256:eea27b01841909316f2cc739807acea1c623df2be8c5cfad7583286397bb8315", size = 8403, upload-time = "2026-03-19T01:04:30.883Z" }, +] + +[[package]] +name = "attrs" +version = "26.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/9a/8e/82a0fe20a541c03148528be8cac2408564a6c9a0cc7e9171802bc1d26985/attrs-26.1.0.tar.gz", hash = "sha256:d03ceb89cb322a8fd706d4fb91940737b6642aa36998fe130a9bc96c985eff32", size = 952055, upload-time = "2026-03-19T14:22:25.026Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/64/b4/17d4b0b2a2dc85a6df63d1157e028ed19f90d4cd97c36717afef2bc2f395/attrs-26.1.0-py3-none-any.whl", hash = "sha256:c647aa4a12dfbad9333ca4e71fe62ddc36f4e63b2d260a37a8b83d2f043ac309", size = 67548, upload-time = "2026-03-19T14:22:23.645Z" }, +] + +[[package]] +name = "autopep8" +version = "2.3.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pycodestyle" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/50/d8/30873d2b7b57dee9263e53d142da044c4600a46f2d28374b3e38b023df16/autopep8-2.3.2.tar.gz", hash = "sha256:89440a4f969197b69a995e4ce0661b031f455a9f776d2c5ba3dbd83466931758", size = 92210, upload-time = "2025-01-14T14:46:18.454Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9e/43/53afb8ba17218f19b77c7834128566c5bbb100a0ad9ba2e8e89d089d7079/autopep8-2.3.2-py2.py3-none-any.whl", hash = "sha256:ce8ad498672c845a0c3de2629c15b635ec2b05ef8177a6e7c91c74f3e9b51128", size = 45807, upload-time = "2025-01-14T14:46:15.466Z" }, +] + +[[package]] +name = "babel" +version = "2.18.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7d/b2/51899539b6ceeeb420d40ed3cd4b7a40519404f9baf3d4ac99dc413a834b/babel-2.18.0.tar.gz", hash = "sha256:b80b99a14bd085fcacfa15c9165f651fbb3406e66cc603abf11c5750937c992d", size = 9959554, upload-time = "2026-02-01T12:30:56.078Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/77/f5/21d2de20e8b8b0408f0681956ca2c69f1320a3848ac50e6e7f39c6159675/babel-2.18.0-py3-none-any.whl", hash = "sha256:e2b422b277c2b9a9630c1d7903c2a00d0830c409c59ac8cae9081c92f1aeba35", size = 10196845, upload-time = "2026-02-01T12:30:53.445Z" }, +] + +[[package]] +name = "beautifulsoup4" +version = "4.15.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "soupsieve" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/43/65/318323f98dbee45d42dff61d8f047181bc6f2268a9068cfad035a46be5af/beautifulsoup4-4.15.0.tar.gz", hash = "sha256:288e3ca7d54b06f2ac191970bc275c1939cb46d450b255bf6718b04aa37ab4f7", size = 632571, upload-time = "2026-06-07T16:44:20.453Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/88/c6/92fcd42f1ba33e1184263f25bfabf3d27c383410470f169e4b8163bf9c17/beautifulsoup4-4.15.0-py3-none-any.whl", hash = "sha256:d6f88de62e1d4e38ecb1077eb9724cd0eff29d2a08ca16a401e9b9e93f117cf9", size = 109924, upload-time = "2026-06-07T16:44:21.566Z" }, +] + +[[package]] +name = "black" +version = "26.5.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "click" }, + { name = "mypy-extensions" }, + { name = "packaging" }, + { name = "pathspec" }, + { name = "platformdirs" }, + { name = "pytokens" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c0/37/5628dd55bf2b34257fc7603f0fe97c40e3aaf24265f416a9c85c95ca1436/black-26.5.1.tar.gz", hash = "sha256:dd321f668053961824bcc1be1cc1df748b2d7e4fa28086b08331e577b0100a73", size = 679439, upload-time = "2026-05-18T16:53:36.107Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/24/99/7744b906703228264ef73bdd534df88ec1ef3de45c4e78f6d31b9e32d0c9/black-26.5.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:4ad6fa01f941920f54f2bbb35f3df7673428a0ef98a0b0840c2eaef3b110efa8", size = 2012518, upload-time = "2026-05-18T17:05:20.108Z" }, + { url = "https://files.pythonhosted.org/packages/b7/c0/c5a3b1636dfd09c42534f2b3cf33506814f6d3e066fb0879ffa16c1ae860/black-26.5.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:3915f256e75a2d7cf88d8953d37f780455dc586cc72dee059c528fe77f581217", size = 1816016, upload-time = "2026-05-18T17:05:21.84Z" }, + { url = "https://files.pythonhosted.org/packages/1f/0e/36044316b65ca471d3bb6d3703fd06fb50c6b727c3562f6a5a3153634f88/black-26.5.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9d98d4137277c75dfb898ec8d846c4fd68ba1e9cf77f95e2865c203dc18f4c3d", size = 1884150, upload-time = "2026-05-18T17:05:23.546Z" }, + { url = "https://files.pythonhosted.org/packages/b3/33/dafc5808c2af43672912111d7c3354af1615f7e2be3bed7a878461abbe4d/black-26.5.1-cp312-cp312-win_amd64.whl", hash = "sha256:a1dca32d9f1784af512a13410ec204c6f7f0aa9797a111c42e1c03449821c264", size = 1486825, upload-time = "2026-05-18T17:05:25.004Z" }, + { url = "https://files.pythonhosted.org/packages/82/14/b965ee6ad2a311f28bdbf692def3ee9848d2ae289dab28b27657fcee3e78/black-26.5.1-cp312-cp312-win_arm64.whl", hash = "sha256:1037d5ac7b7b310b2632ad867ec8d0e4c4819dcdb0b820f63135da746a24e418", size = 1288646, upload-time = "2026-05-18T17:05:26.477Z" }, + { url = "https://files.pythonhosted.org/packages/3f/5c/c384363980e11e25ca6b93205949bb331fbf35f4e0dbec376dfa6326cec8/black-26.5.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:2b36cf2ddf5566e205f6535f782a62194a184d33e175b64ae8c40b1737522be3", size = 2009020, upload-time = "2026-05-18T17:05:28.132Z" }, + { url = "https://files.pythonhosted.org/packages/0b/df/9f31c5e0babbfed77d505fc5d120beb98b21b33feaeded3924ea941fe360/black-26.5.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:1f7ea64ebfa01b50f693508fc39f875e264446d3b097088f84f203b9d09618a0", size = 1813335, upload-time = "2026-05-18T17:05:31.266Z" }, + { url = "https://files.pythonhosted.org/packages/fb/24/8e7b9a2fa61b0afd82209efe937557d180a1fa055bd7f6161eb9defc3719/black-26.5.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ecb3e624844c798144e9bd986954e0adc81d8911a1f30f375e1252fe26e8c294", size = 1881614, upload-time = "2026-05-18T17:05:32.718Z" }, + { url = "https://files.pythonhosted.org/packages/49/ad/b4e0d9365ba8ac34f6bbab62a4b1b2dd5d618fac3fa1b8db968c844201b5/black-26.5.1-cp313-cp313-win_amd64.whl", hash = "sha256:e1a26503279b6b310669fb0b219c39e4820b77e8189fe80f522bb511f247db0a", size = 1488925, upload-time = "2026-05-18T17:05:34.259Z" }, + { url = "https://files.pythonhosted.org/packages/a1/4b/652b859bf5df88a751c30451b09338f7fd26a77d1271c666992f836b7711/black-26.5.1-cp313-cp313-win_arm64.whl", hash = "sha256:5c34b25da232ead53a6f335b76dbea124f4d152ad568b9080d6f944bc2b34b52", size = 1289883, upload-time = "2026-05-18T17:05:36.019Z" }, + { url = "https://files.pythonhosted.org/packages/a6/16/a8da8eb208c51c7f4ce74609a45d0dcc6d8a2141e45e81ee5289d1bb0d59/black-26.5.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:e88976690a64b0af98312ca958415849cb42423423c5f2ee74af4b49a97a2168", size = 2004800, upload-time = "2026-05-18T17:05:38.182Z" }, + { url = "https://files.pythonhosted.org/packages/11/8a/a479296a19e383b70a725882a6cf3d786540601ff03cabbaaf1cce864c5a/black-26.5.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:32d5ea7f6c8bdfa6e648326ebca1f02b0764e2a029edc6f8dce2627e19d468c3", size = 1815576, upload-time = "2026-05-18T17:05:40.309Z" }, + { url = "https://files.pythonhosted.org/packages/81/6b/cfaf3d39f25132c156a068f6b805576c9103a84086019507c70e1911ee7d/black-26.5.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ea8d16dc41655aa113cd64665e7219446cd7e4ff2248d7178eaa905190c86b18", size = 1877927, upload-time = "2026-05-18T17:05:42.463Z" }, + { url = "https://files.pythonhosted.org/packages/66/76/302e313964bcff7e28df329d39f84f5270095730d85ff0acc260610a0d82/black-26.5.1-cp314-cp314-win_amd64.whl", hash = "sha256:577f21094ea469ef92ec1adaf2c9441a226d2144d01a5be2fa823cecf6543e50", size = 1511860, upload-time = "2026-05-18T17:05:43.943Z" }, + { url = "https://files.pythonhosted.org/packages/27/4e/a3827e35e0e567f9f9ee59e2a0ab979267dca98718f25547ca8c6733afd4/black-26.5.1-cp314-cp314-win_arm64.whl", hash = "sha256:ed1a20af114c301a0269bf01163d51dbef72737fd65f850001e7cbe7f3c7abae", size = 1316632, upload-time = "2026-05-18T17:05:45.521Z" }, + { url = "https://files.pythonhosted.org/packages/94/51/f975cae76d44274cc2868dc9040ac5d58d464784610234455b4e7b19c6ef/black-26.5.1-py3-none-any.whl", hash = "sha256:4ed7f7da04046d2e488437170797d3b4a4ad83906683bcb7dfc68b673bbce5e2", size = 213693, upload-time = "2026-05-18T16:53:33.964Z" }, +] + +[[package]] +name = "blackjax" +version = "1.7.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jax" }, + { name = "jaxlib" }, + { name = "numpy" }, + { name = "optax" }, + { name = "scipy" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/91/fc/dca22cc8b84c7c50bb2733181112c1a12988b3fa1f96b7062813f9cab9a3/blackjax-1.7.1.tar.gz", hash = "sha256:5e15e5d574afc40d59cfcf2b7fb4561f24bfa7169d846209ecf2a3b3725cc519", size = 5496902, upload-time = "2026-10-02T20:43:51.788Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/99/a0/24f50e0cfd432b47103677c6fc6b220acc716c4b20dc9d6021a01d7924fa/blackjax-1.7.1-py3-none-any.whl", hash = "sha256:be2c7f982f4ab3afef2dd5f075dae271023fdec3d9c5d8b599ba7f2f281524fa", size = 4994604, upload-time = "2026-10-02T20:43:50.363Z" }, +] + +[[package]] +name = "bleach" +version = "6.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "webencodings" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/48/3c/e12ac860709702bd5ebeb9b56a4fe334f1001246ee1b8f2b7ee28912df7d/bleach-6.4.0.tar.gz", hash = "sha256:4202482733d85cedd04e59fcb2f89f4e4c7c385a78d3c3c23c30446843a37452", size = 204857, upload-time = "2026-06-05T13:01:13.734Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/58/9d/40b6267367182187139a4000b82a3b287d84d745bccd808e75d916920e9d/bleach-6.4.0-py3-none-any.whl", hash = "sha256:4b6b6a54fff2e69a3dde9d21cc6301220bee3c3cb792187d11403fd795031081", size = 165109, upload-time = "2026-06-05T13:01:12.504Z" }, +] + +[package.optional-dependencies] +css = [ + { name = "tinycss2" }, +] + +[[package]] +name = "build" +version = "1.6.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "os_name == 'nt' and sys_platform != 'darwin'" }, + { name = "packaging" }, + { name = "pyproject-hooks" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/bd/67/4898a44ea4f3f8e213b0954ec0aa0a16971d62a6212d6ea3931e97115b99/build-1.6.1.tar.gz", hash = "sha256:51cc11666391ab6f092070437ac747002ff46f3e4113a3622177ee6b488bfc53", size = 113427, upload-time = "2026-09-10T07:56:00.417Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ad/9b/9fb3585dabcd73a1b2a6267f63f62649347c9e6d072c9fde365b105abb2c/build-1.6.1-py3-none-any.whl", hash = "sha256:ecd351a4be9d35a9eaaba244a7687143c9c7d4aea6ac964e7e7ddab20cbcf4e7", size = 31179, upload-time = "2026-09-10T07:55:59.148Z" }, +] + +[[package]] +name = "cachetools" +version = "6.2.6" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/39/91/d9ae9a66b01102a18cd16db0cf4cd54187ffe10f0865cc80071a4104fbb3/cachetools-6.2.6.tar.gz", hash = "sha256:16c33e1f276b9a9c0b49ab5782d901e3ad3de0dd6da9bf9bcd29ac5672f2f9e6", size = 32363, upload-time = "2026-01-27T20:32:59.956Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/90/45/f458fa2c388e79dd9d8b9b0c99f1d31b568f27388f2fdba7bb66bbc0c6ed/cachetools-6.2.6-py3-none-any.whl", hash = "sha256:8c9717235b3c651603fff0076db52d6acbfd1b338b8ed50256092f7ce9c85bda", size = 11668, upload-time = "2026-01-27T20:32:58.527Z" }, +] + +[[package]] +name = "certifi" +version = "2026.7.22" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a3/c2/24167ea9858356b47a87a50d39908bfdb72ceeefe0041586e704e5376b3a/certifi-2026.7.22.tar.gz", hash = "sha256:741e2c3b351ddf169a738da9f2c048608ff7f2c5cc02f1ebc6b118bb090d5d55", size = 138112, upload-time = "2026-07-22T03:35:12.644Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0b/a7/71ac2cff56fec219ed242bb11b8efb69fcc4bec75db06fb7bfe35de520e6/certifi-2026.7.22-py3-none-any.whl", hash = "sha256:62f22742b58a1a33014a2b6b706588a8d7e2a88ae7bd1a6ebe8c992928483775", size = 136983, upload-time = "2026-07-22T03:35:11.276Z" }, +] + +[[package]] +name = "cffi" +version = "2.1.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pycparser", marker = "implementation_name != 'PyPy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/9e/ef/008a1939e372c06329a3fce4279c02f328488f3526744906eeec3da7ad5f/cffi-2.1.1.tar.gz", hash = "sha256:dd31f52ea1086513bb9df30f8fcee9b8918323ae067a3d5b78bc826a000712be", size = 530807, upload-time = "2026-08-03T21:21:18.939Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/10/69/43965eccfdead3b9220015fd1320e117be8c6ed01a62ffab76eeb752f5d5/cffi-2.1.1-cp312-cp312-macosx_10_15_x86_64.whl", hash = "sha256:c8c69575568085ba0b1b10c0249d779a214aea6f6522e949a0fc9fb0fcb449d0", size = 184821, upload-time = "2026-08-03T21:19:44.887Z" }, + { url = "https://files.pythonhosted.org/packages/54/7d/16e5a096677b5e313ca80cd5e5170efa3ea44624a82bb111925522da64b1/cffi-2.1.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f81b3b8f3d4e343550fa4baa0e479bba9f2d29ce9c2e9b51d1ce1718d7442fcf", size = 184719, upload-time = "2026-08-03T21:19:46.129Z" }, + { url = "https://files.pythonhosted.org/packages/56/e6/8941622732edec876dd17d0453dce07317ae96db34f2ec1436c9d3785986/cffi-2.1.1-cp312-cp312-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:811bd1e21d32de12efca32393a0ab3f5133b54fce9bd44b8bd77ab07da14bf6a", size = 214799, upload-time = "2026-08-03T21:19:47.218Z" }, + { url = "https://files.pythonhosted.org/packages/44/de/f98430906df1545ffde0d543dd124a7a439bc2cd32b36b9c53f805df7333/cffi-2.1.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:68e62fe11f30d5ca8289242866f0a5291402d8529ca2178ab8afc5c9694ae890", size = 222389, upload-time = "2026-08-03T21:19:48.331Z" }, + { url = "https://files.pythonhosted.org/packages/6a/5b/717f1526b9957b34456313c31645c5b82b8fb5c3fe9e4752999be7128bfc/cffi-2.1.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:4a7c934f7360e8cd64fe9efadcbd10c7c6364f531e432b9a4bf5ccbc9e0e8b50", size = 210249, upload-time = "2026-08-03T21:19:49.543Z" }, + { url = "https://files.pythonhosted.org/packages/64/b3/f8aa4f3e34986c7e4ec45072d1b1b9dd295b6b18007b45518d79726dd725/cffi-2.1.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:3143d81e29e1e20a9ce10901ec369012947876596f75a222235965f2b7ae832e", size = 208775, upload-time = "2026-08-03T21:19:50.918Z" }, + { url = "https://files.pythonhosted.org/packages/b1/db/dceb9dd5b231e1da801793f8acc9f3c52a7e1afe40bb1aae37e02b0faad5/cffi-2.1.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c1453022f490d2459a11819d83ad1d586e9ff65a12ac3e705ffebd46d3685dcf", size = 221822, upload-time = "2026-08-03T21:19:52.054Z" }, + { url = "https://files.pythonhosted.org/packages/a0/d2/6cd24ae3be000a634109c247d1475d62e5616d0dc78c82770942ec384248/cffi-2.1.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:208f941bb9d18e768138677f0a6d2ce01f590df56043dda1df1535ac57c88517", size = 225232, upload-time = "2026-08-03T21:19:53.109Z" }, + { url = "https://files.pythonhosted.org/packages/cb/52/3fa190537004dd7f0ab860a6dc7c0175b8667f68d1e618a46f5498d30250/cffi-2.1.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:210019b6c7cf07f081b4c54635c8cf744377001350e29cc0f81c4377b4797735", size = 223597, upload-time = "2026-08-03T21:19:54.515Z" }, + { url = "https://files.pythonhosted.org/packages/80/fb/0bb75b7039588c074b37ae99f40d9bfddf990ecb2fbc346ebccd2e56b9be/cffi-2.1.1-cp312-cp312-win32.whl", hash = "sha256:046bfc24911b37851ee1b51aab8bffe713d89c68c6a057b09484ce9fd5f69b4e", size = 175292, upload-time = "2026-08-03T21:19:55.566Z" }, + { url = "https://files.pythonhosted.org/packages/d9/79/615cc094e2fb508cade7de88d3b4f6c4ec2bab695c97bce9153dc65aadf5/cffi-2.1.1-cp312-cp312-win_amd64.whl", hash = "sha256:f53e442b08449d42821fa4a4fba000095af9f62742a500f978a9f557ec44339a", size = 185919, upload-time = "2026-08-03T21:19:56.89Z" }, + { url = "https://files.pythonhosted.org/packages/70/c6/d0ea84713fe46b243a436a18fcd47d639732747e21635c8a27191b06dc30/cffi-2.1.1-cp312-cp312-win_arm64.whl", hash = "sha256:7bde5e4cc5c10140859842b9d383af292b22639a4dffb725314baf45968cef80", size = 180093, upload-time = "2026-08-03T21:19:58.155Z" }, + { url = "https://files.pythonhosted.org/packages/9d/f4/035513d4117049066b4779dc3b7c0c0fdad175fa13731c9f4003f1cd1478/cffi-2.1.1-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:b5bdfd1c873d4e093aabc0ca84c4ca6dbc4f752afb5c86f146d9742580c9da2e", size = 194248, upload-time = "2026-08-03T21:19:59.399Z" }, + { url = "https://files.pythonhosted.org/packages/76/af/2aeb4dbb5fc41a04161ae9ff1518de7cec08e164f44a8ce6a4cf7fd2cd1d/cffi-2.1.1-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:31348097ff5bbe827ccc41795d4dd099d9f0625e7def00ee653c137a490c2a6c", size = 196908, upload-time = "2026-08-03T21:20:00.746Z" }, + { url = "https://files.pythonhosted.org/packages/a7/46/2e5fdde8555706dd98139a910ca11be02809f3f605ce956f655d0214e100/cffi-2.1.1-cp313-cp313-macosx_10_15_x86_64.whl", hash = "sha256:9d2055050ea716bd38b7f7f1579c275386646b4894c155a3e2f3cd62ed41b7c6", size = 184805, upload-time = "2026-08-03T21:20:02.02Z" }, + { url = "https://files.pythonhosted.org/packages/55/41/4c7042f317b9217502988f0873af87e16ad606dc20f84e546e3e6ce9764c/cffi-2.1.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:19ee6127ee34de7d83ce3d371ebc5ed91addbdcc39f9ab15ce4eb35a4e534971", size = 184764, upload-time = "2026-08-03T21:20:03.141Z" }, + { url = "https://files.pythonhosted.org/packages/43/1f/1c3d90d91811c8f86ced9ed637956c54bfe5b79ca98fe976d7f8c8979f6b/cffi-2.1.1-cp313-cp313-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:6a8dddef476fab96d066d578fc88526767b836ab5ab21754e1d5bf3879c31c7c", size = 214722, upload-time = "2026-08-03T21:20:04.377Z" }, + { url = "https://files.pythonhosted.org/packages/37/6f/3b5ce4c3b2192d250f04908f2bfd91ef34552ec8f7716a5d4abdb8d67bb2/cffi-2.1.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f16c709686a78c727bbbf059f92b0bf41c6fc60deec706d2dc19f529175a6125", size = 222369, upload-time = "2026-08-03T21:20:05.544Z" }, + { url = "https://files.pythonhosted.org/packages/02/10/4b3c75dde3d9663c9e02ba05c2668b954f671d4bbe346413ca8c696b295a/cffi-2.1.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:fcd22650c908d7b7da162bbfaab594a1227a15d1643a98c68b122ac642fa2264", size = 210175, upload-time = "2026-08-03T21:20:06.75Z" }, + { url = "https://files.pythonhosted.org/packages/df/62/14f74b9543e605d17701dc797b815958b8bb70b7624ce1b832ddad48ed6c/cffi-2.1.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:aa9511c62d14da7aacc9b4bf51f3f697a621e83b2d6919008243c3aad168eea3", size = 208670, upload-time = "2026-08-03T21:20:08.04Z" }, + { url = "https://files.pythonhosted.org/packages/95/95/86342356ff5953b3fb06f7ef7c5bee212d45e770abc7218d451b9148313c/cffi-2.1.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:a931079504ecc49efed7744c476a5c343a92fabf66dec2db95edb1b2fdc770e2", size = 221824, upload-time = "2026-08-03T21:20:09.274Z" }, + { url = "https://files.pythonhosted.org/packages/eb/ff/7b3429ff53aafe931ed8a5fc69f481bbef7ba6de87ddcbb63d08f483f613/cffi-2.1.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a2d7755bef5a12ed488f4ef1f1b69ee9191d7396083b755a5d2295f6edb4768b", size = 225148, upload-time = "2026-08-03T21:20:10.7Z" }, + { url = "https://files.pythonhosted.org/packages/34/34/a95870b9221e09cf4f2ce3178b1a210abdfe63a1bd357da940418d7b8d15/cffi-2.1.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e0bcb7e0f677f543555d2adff3bf19c05f66cdb4796e5ff602442ab2fe3c4ef7", size = 223564, upload-time = "2026-08-03T21:20:12.165Z" }, + { url = "https://files.pythonhosted.org/packages/70/ea/839b50531021a647fb5e929f72cf97bc1ff702b5472166164b5b6e76b851/cffi-2.1.1-cp313-cp313-win32.whl", hash = "sha256:334644fbac4eff73d985a17a91226df55d0f394160c4cfb880e084c8f7161cac", size = 175263, upload-time = "2026-08-03T21:20:13.559Z" }, + { url = "https://files.pythonhosted.org/packages/60/a6/8b149b2c3f2e11aaa1618ef64500b45f50f22c57a977a4dff1aff1f91042/cffi-2.1.1-cp313-cp313-win_amd64.whl", hash = "sha256:1aa5645c30469b09530c4ebca77ebf8f17618293c58f8549cb1a543a50236e7d", size = 185688, upload-time = "2026-08-03T21:20:14.69Z" }, + { url = "https://files.pythonhosted.org/packages/01/9a/11f687cb39d6a3504060d5242f04f48c735afb4d3d533958a20594890cb2/cffi-2.1.1-cp313-cp313-win_arm64.whl", hash = "sha256:63bbfd5ded17c4840ac07cd8f1c21ba9d9708141f840b324f422f41b207e3973", size = 180078, upload-time = "2026-08-03T21:20:15.917Z" }, + { url = "https://files.pythonhosted.org/packages/d3/7b/d6bbf82b8b96e7391438898c42f5bd96dd02030fd5b64937d248220003e2/cffi-2.1.1-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:7dbb61fe3a7699468030f71bbe5f8a0e326a151daa91beb11a6fc1f980c55e1c", size = 194064, upload-time = "2026-08-03T21:20:17.148Z" }, + { url = "https://files.pythonhosted.org/packages/94/e6/bcc91b283be94735e268487a054004f0aa19947b6348fa367db53230abc8/cffi-2.1.1-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:f24fb43132a4c6b4cb4eb029492919b2db645be6808d738f244fd146c03c32cb", size = 196720, upload-time = "2026-08-03T21:20:18.268Z" }, + { url = "https://files.pythonhosted.org/packages/d9/99/c4b0c17cacdc9c3b8f280026286a9826d6a208c0f047591a3c3ce99b91fd/cffi-2.1.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:d28630f5854ab07ab1fd4aba756de52326c82e6be15d414b12793f1975048b54", size = 184964, upload-time = "2026-08-03T21:20:19.708Z" }, + { url = "https://files.pythonhosted.org/packages/b3/a9/9db617d05d7367c1ad0ab00b3aa6e6f9281edd689b4ee9ea0e5a84e89c97/cffi-2.1.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:661c298b4821edebead0c91edd2b00374d67ad7c5a1f7a91d4442633b79d6a72", size = 184962, upload-time = "2026-08-03T21:20:20.833Z" }, + { url = "https://files.pythonhosted.org/packages/67/b8/b42132ca113dc567d37684437b46ca1dafc885902b02a110a02d5b511857/cffi-2.1.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:58acb8ab8e295e6c5ea12f888cbb13cf21511ef2a3303a23f4325c29d17fe5c1", size = 222328, upload-time = "2026-08-03T21:20:22.118Z" }, + { url = "https://files.pythonhosted.org/packages/80/10/c5c0cbf0a657aecf59ef511409734230bf556f05a0d6c9eed7aa5c0a0166/cffi-2.1.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:456a61fa52d579ebf9df2e9552ead5129855dbaff6c1e5a9b1bc408809bdc062", size = 209985, upload-time = "2026-08-03T21:20:23.401Z" }, + { url = "https://files.pythonhosted.org/packages/d5/6c/bfa0b87b03b9238148beca990292843c9396ba069b54496596594173de7b/cffi-2.1.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:a4f00aa42f75d6e4595e8866e748cc1705adc0cddfeb2ca86d0d03993d63ba03", size = 208530, upload-time = "2026-08-03T21:20:24.628Z" }, + { url = "https://files.pythonhosted.org/packages/e9/02/4e7d553a7ac4b4238b38b3c1b80d486e9d4436f8d2acbf87a0997fe3f402/cffi-2.1.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b0431303acaea1089ad4b3e9ce4e6518193def1118d4073ca848635ee4ea2e96", size = 221525, upload-time = "2026-08-03T21:20:25.758Z" }, + { url = "https://files.pythonhosted.org/packages/82/1d/a4aaf9babd75acb4d5f223bff71533bee748dd770a382619a798960ee9ba/cffi-2.1.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:64faea20f4e2613363a1a9b9c7dd73058f3ecd00133a511e72ad7c511658f527", size = 225053, upload-time = "2026-08-03T21:20:26.985Z" }, + { url = "https://files.pythonhosted.org/packages/81/10/5dc0e7bdd18e22107054288283380fc97a06ae3f1656a106908d666a3c88/cffi-2.1.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5c58fe613dc5e5336357eff555824a314d8e43282600435c8d1cb6a7a2fedd13", size = 223213, upload-time = "2026-08-03T21:20:28.277Z" }, + { url = "https://files.pythonhosted.org/packages/0b/e9/d0061c364cde06ee43168a0d076ac1da512cbc380d44767b844ba34fe2b6/cffi-2.1.1-cp314-cp314-win32.whl", hash = "sha256:1a18a57b58cfb21fc28d72e876acf10eaed67a1ed96226f92af4df681d571c4c", size = 177682, upload-time = "2026-08-03T21:20:44.288Z" }, + { url = "https://files.pythonhosted.org/packages/a7/06/1c3e01e3ba14c39f6d10bfbac52753b7e22259e38088e5cfe1d704918690/cffi-2.1.1-cp314-cp314-win_amd64.whl", hash = "sha256:3222ba5d678f80a030e6afbcc33dc1ae5cb45facabb61cee2c7016b8432fde48", size = 187949, upload-time = "2026-08-03T21:20:45.623Z" }, + { url = "https://files.pythonhosted.org/packages/87/5b/da4e39efe18eeb89cf580ea9cfc66b6a7c3eadb808fc0cc1d3a295cb5a5d/cffi-2.1.1-cp314-cp314-win_arm64.whl", hash = "sha256:ab36d55f9ed2d067327667c2fea18dda018eb628dd6347aa01dda6cf1f5d3836", size = 182947, upload-time = "2026-08-03T21:20:46.955Z" }, + { url = "https://files.pythonhosted.org/packages/23/59/40338bf421c5accea1d45158170c87006ef1cd371b05c077e76476949728/cffi-2.1.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:7750c6449dff7864bb9bb27ddfb0267756189201a3afc911d82b3caacd70dfc3", size = 188504, upload-time = "2026-08-03T21:20:29.495Z" }, + { url = "https://files.pythonhosted.org/packages/7d/47/5ecf1023850036e674c77ec4de86182d309ae344e39e7cba984b7df5d647/cffi-2.1.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:0beceaabe56af686895136a2de78db54ecd8e4046b236b8fd6d6cb61389e9bf2", size = 188259, upload-time = "2026-08-03T21:20:31.291Z" }, + { url = "https://files.pythonhosted.org/packages/2a/9c/92934c3bea9f785b23eba304538c0b4d37a2a96d2431eb3a1bc87a11aa19/cffi-2.1.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:49cbc70e6542d4ccccb936558d1064a8012541e78f821f955cff24e357776c94", size = 223864, upload-time = "2026-08-03T21:20:32.571Z" }, + { url = "https://files.pythonhosted.org/packages/4d/45/ba4c93527bc38616a8bd36488acb69a2212d60486794f0c1f318949bbb76/cffi-2.1.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:e2d65b31f36619cda3999b78b2aa9632e76b78448e7a56fc4240824200e7c4fc", size = 211538, upload-time = "2026-08-03T21:20:33.808Z" }, + { url = "https://files.pythonhosted.org/packages/80/e9/b6ef565e452acb932fb0cb5443f44a78efbd1233e566f02b5a83855e9115/cffi-2.1.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:28907ab9bfb6aa13184cfc17c6b8e1023c5ab6fd7076d8c20a35e59fe04f8f29", size = 210688, upload-time = "2026-08-03T21:20:34.974Z" }, + { url = "https://files.pythonhosted.org/packages/9a/95/eff5f0cee78d2eabc7eebffec40d3fc1876b5f3c95582e018bb4b99601f2/cffi-2.1.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:51b31d1c98274844cfd7838ce00bfc27c7423a4dc00fc0772fc3331c2cc90676", size = 223803, upload-time = "2026-08-03T21:20:36.564Z" }, + { url = "https://files.pythonhosted.org/packages/fa/01/579d39fb8bef00a335a23d83757b44feb24cd6345a2c451b64cb67b9c362/cffi-2.1.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:5e7cecbaadb83884793e05828cee59b210b24583b9c7425d0ba6a754fe22eb4e", size = 226763, upload-time = "2026-08-03T21:20:37.816Z" }, + { url = "https://files.pythonhosted.org/packages/8d/b0/0b44f47c60b01b57b6e2bbd92343f13a85a1d93bc46ccf6e47e244acd99c/cffi-2.1.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:25792eac27877609e7bb06d42ff88278a6624fff2ba9bbb523c09616b117e80f", size = 225688, upload-time = "2026-08-03T21:20:38.959Z" }, + { url = "https://files.pythonhosted.org/packages/eb/d2/3b7176cb570a1d3e27faf67b72f591af508036e0d8b2be2ef9af9e8c84bb/cffi-2.1.1-cp314-cp314t-win32.whl", hash = "sha256:8ef53b2de9bcb9197d31854256575d59dbac0cba72ac627bb291ef5eceb74be4", size = 182868, upload-time = "2026-08-03T21:20:40.388Z" }, + { url = "https://files.pythonhosted.org/packages/56/78/31f00c1bcd97c9bbf55f1bfdf5bc809a5de8887473e90bb9960dca825e80/cffi-2.1.1-cp314-cp314t-win_amd64.whl", hash = "sha256:616f097f2fe415bc92a247f02e11f634e1f9e9a83d327e3c915c15089c87869e", size = 194104, upload-time = "2026-08-03T21:20:41.725Z" }, + { url = "https://files.pythonhosted.org/packages/7b/1b/58496f2ed0a35de575250c02a43ab3cc2c04d494a88fed31c1cabc0fd176/cffi-2.1.1-cp314-cp314t-win_arm64.whl", hash = "sha256:ad2c86c495b899d862ea0f4b42891b8713a3bd45dd4105c7fd51c2a72f39f3a5", size = 186402, upload-time = "2026-08-03T21:20:43.042Z" }, + { url = "https://files.pythonhosted.org/packages/c1/8f/9ebe220eab48a093d1a5a5e339ab0dc7316eef3bb04d63c42f0251b61f50/cffi-2.1.1-cp315-cp315-ios_13_0_arm64_iphoneos.whl", hash = "sha256:dddad92b554513a31f272570678ba307fb9f618f05e3d4a5eacafff9eae03e1d", size = 194043, upload-time = "2026-08-03T21:20:48.179Z" }, + { url = "https://files.pythonhosted.org/packages/ff/69/844bad3ece306c4782c2ecb93597035b6690d48704b803914c199da1e8b3/cffi-2.1.1-cp315-cp315-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:da0e573f9f97159390c89d9f1a9e41908b66d408cc5b58d08cf3847d844c531b", size = 196737, upload-time = "2026-08-03T21:20:49.457Z" }, + { url = "https://files.pythonhosted.org/packages/1b/8a/af668013284634733f02d683458a0728739c7d6ddb5e14cb0c20832266fe/cffi-2.1.1-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:fb92203a88b3d3053034db775110081c49d28be6551923805e039924093761e4", size = 184933, upload-time = "2026-08-03T21:20:50.639Z" }, + { url = "https://files.pythonhosted.org/packages/0c/75/2f5207ff6d1a613133b23a5203cc0c2a628313b5eb3974d7956ae3c57950/cffi-2.1.1-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:2ae64be792b8966f2c69538199728b290e34726562896df1e5dc8ffd8d8188e8", size = 185002, upload-time = "2026-08-03T21:20:52.173Z" }, + { url = "https://files.pythonhosted.org/packages/e2/31/9e1313b0a6e30e91b3b3d3fff51ae99c857c07738e3afcce1f7334e1b7ab/cffi-2.1.1-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:507a24c282e0f42f8ed737cf048572cbf580468da5555764a8331735e9c736b6", size = 222271, upload-time = "2026-08-03T21:20:53.462Z" }, + { url = "https://files.pythonhosted.org/packages/50/e3/f6234a833e6e08c7007003074723c406559eecf9b48dfc97471e5a8eb7a0/cffi-2.1.1-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:246fa40ce8645a614ff682e0b70f37134e460eaf93a775e0cbe3cca585a67a80", size = 209919, upload-time = "2026-08-03T21:20:54.783Z" }, + { url = "https://files.pythonhosted.org/packages/0d/fc/5f74e293fced6edb51af3a46c4ccf6c23c9943774ecb375ddbd522c76add/cffi-2.1.1-cp315-cp315-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:471cee653ae88de62096552e6d24ccb4a5adb8c8c9f10b5054d0122c15bf2779", size = 208529, upload-time = "2026-08-03T21:20:56.066Z" }, + { url = "https://files.pythonhosted.org/packages/44/16/29e6d01b388bef055ecd6ca8244b3f4d336bd09e92d5d892187b9601084e/cffi-2.1.1-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:aeae0e330c9f6acd681f647d46cefd30c29f93e3392882e792e82080c9691399", size = 221630, upload-time = "2026-08-03T21:20:57.336Z" }, + { url = "https://files.pythonhosted.org/packages/a4/18/fa7f1f6857d5eb88a4ca99ffcbfb7c387a287ccc154c64a73e86314745d7/cffi-2.1.1-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:42a494cee34437f05546455144f2b5d9ac09b1face62bcfce597d2e521066688", size = 225134, upload-time = "2026-08-03T21:20:58.675Z" }, + { url = "https://files.pythonhosted.org/packages/e0/9f/e8e3dfa04a1b4c241f8c91faacad872b4d4efd051d49764ad4e2fd4b9fea/cffi-2.1.1-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:cc572dace3f60ef98d7b12ff411d20f5362feb31a0439eab0085bbfd349982d7", size = 223197, upload-time = "2026-08-03T21:20:59.968Z" }, + { url = "https://files.pythonhosted.org/packages/f8/7e/8debeb04f1ab9fe2a6963964cd6f1aaf7192627b83926586a6a4e089c9fa/cffi-2.1.1-cp315-cp315-win32.whl", hash = "sha256:4f42141fc14250de6dde5ee7ea4432be017252d91f19c5ad043c084cea629cac", size = 177683, upload-time = "2026-08-03T21:21:14.901Z" }, + { url = "https://files.pythonhosted.org/packages/e0/31/5158704cc474ab65c1647932e88be78dc0873f47130e253be38bcaf13d01/cffi-2.1.1-cp315-cp315-win_amd64.whl", hash = "sha256:e6e8cff14d6fb0be70a09c0bdc58096f501952d04624ebf867e0e56da2df8960", size = 187897, upload-time = "2026-08-03T21:21:16.108Z" }, + { url = "https://files.pythonhosted.org/packages/cc/4b/b3a2da8570c704ffc0f9762cdc3ec0f02c8573798e0b5cf7f11c82bbb70f/cffi-2.1.1-cp315-cp315-win_arm64.whl", hash = "sha256:27350daa11d4f10c540e6e89dada4c54feb7256ad03e9a4dc075ebad7ba360d1", size = 182935, upload-time = "2026-08-03T21:21:17.271Z" }, + { url = "https://files.pythonhosted.org/packages/d0/ef/5443574510a1207e6f6bc38ba6e1f1de36cb48fef07b2728bb896a21f430/cffi-2.1.1-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:c26608d2222fb1e94487e4a387d85f13eb55d5ed725cb25a0c589ac4ee60e7bc", size = 188464, upload-time = "2026-08-03T21:21:01.163Z" }, + { url = "https://files.pythonhosted.org/packages/7e/ae/a56fa8c4686ad50e148fcbc8d3ae0d03915ff5c30d795058988c24118cef/cffi-2.1.1-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:4be96343e422f2dfcd12ab5c9f5aebe03f82f737c6bffeca6830b3875cb44aab", size = 188262, upload-time = "2026-08-03T21:21:02.382Z" }, + { url = "https://files.pythonhosted.org/packages/53/b2/6187f46f2912276a3ae284076109cc5c8680482f11f766ccf26db4a86427/cffi-2.1.1-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:937c0052c05a31ca1daf18de3158eed4dbfcb9cc107adbea227728d647be701e", size = 223779, upload-time = "2026-08-03T21:21:03.553Z" }, + { url = "https://files.pythonhosted.org/packages/8a/f6/c3ad28bd19f77047a03084424fbd4cbe997303267c14423737324be0385d/cffi-2.1.1-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:df423d40ee8654634421812bc3b196da3f9bd7d32929da813f8394c4348a5358", size = 211520, upload-time = "2026-08-03T21:21:04.863Z" }, + { url = "https://files.pythonhosted.org/packages/a0/cd/ccac9013a5bd9fd764de118674ab9c805b5ca10c19270d90ee273f8b2240/cffi-2.1.1-cp315-cp315t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:a730a083190634c65cca36ba5f489531576ebd79bcd5c8e172130f6453127231", size = 210673, upload-time = "2026-08-03T21:21:06.223Z" }, + { url = "https://files.pythonhosted.org/packages/52/86/2976131c639aead931c5bee5aba67e4b09fbeb8018b6f282f70803f923a7/cffi-2.1.1-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:363e05fa78e15116c3c32c210ee36884fd6b9afa6d440e47112c3bd511d64cb6", size = 223835, upload-time = "2026-08-03T21:21:07.539Z" }, + { url = "https://files.pythonhosted.org/packages/ac/0c/33a7aeab2f9c76918c52e084beb39c570db3588133412929e8ec06fab90b/cffi-2.1.1-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:770de9db11e84213beec501cfcaa013b019820ca881e03344dea5844f7876d94", size = 226705, upload-time = "2026-08-03T21:21:08.774Z" }, + { url = "https://files.pythonhosted.org/packages/e3/26/2cde30fdde421130bfc18f70395731a6e6b2053c6a1978a5258ff04e72fa/cffi-2.1.1-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:7da0c5eff80f0197f3b3d1232ec5a682a9325f4ae9016a78f5f5ca35f9ced1f5", size = 225539, upload-time = "2026-08-03T21:21:09.911Z" }, + { url = "https://files.pythonhosted.org/packages/6d/cd/a361394c94b2129d604bb846f624a8e88255a3ee33129c434a00d715e64f/cffi-2.1.1-cp315-cp315t-win32.whl", hash = "sha256:06c72bb76605a4b0cd0aad6930b69d4baf7dd5d806cfc409b824191099700e66", size = 182707, upload-time = "2026-08-03T21:21:11.226Z" }, + { url = "https://files.pythonhosted.org/packages/9b/b5/ba2b299993c26577d529b6ae29841f9e15b9fcf004d65f423f4fcf94ade9/cffi-2.1.1-cp315-cp315t-win_amd64.whl", hash = "sha256:d9c275eaacd24aa73f94ffd6de08fc3f932424d8b6c376f4bed7cde376fe7bc3", size = 193772, upload-time = "2026-08-03T21:21:12.39Z" }, + { url = "https://files.pythonhosted.org/packages/aa/29/35e016098c814cd93de9cd320c66b5bfba14dc6ecedd3cb518fa7c408c69/cffi-2.1.1-cp315-cp315t-win_arm64.whl", hash = "sha256:d18e5ac0f2f03f4f518d3e23db0f0cad7faa1da8620e9c09461d443bbf6e6692", size = 186360, upload-time = "2026-08-03T21:21:13.636Z" }, +] + +[[package]] +name = "charset-normalizer" +version = "3.5.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e5/3f/143b048436775b0f76ac3eec145c019e8173ccc2885c8f20319b996d5e83/charset_normalizer-3.5.1.tar.gz", hash = "sha256:6117b84ea48435e5356dc737f5121485c30920ba43375fa7b434fd753df0eac3", size = 171764, upload-time = "2026-08-15T08:20:44.807Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/30/27/78873dc8b6a56357517b74b6bb9568b80450e7bb4f6ef7e3fa9d22aa0bd7/charset_normalizer-3.5.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:5b6d1386bf0096d26d3a863dc0a487a5b4eb9aa93cf5ba69683d29dde6b9d60f", size = 344456, upload-time = "2026-08-15T08:17:10.072Z" }, + { url = "https://files.pythonhosted.org/packages/9a/4c/be49ada26b1f0232d57aa89bbebf997a5cc2332a5616b6eca26ff680044d/charset_normalizer-3.5.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4582c27e8c889d64811987b5967fbd3ae0c823fe1fd933b543d55ac20bb475fa", size = 238530, upload-time = "2026-08-15T08:17:11.563Z" }, + { url = "https://files.pythonhosted.org/packages/76/84/6f1290fa07ae6978d3960caa3eb1b8019bf9284ab7c2297b00c099ef4250/charset_normalizer-3.5.1-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:1d1c7a53a6c2103925cdd6d7229f8c567379f211c869793df679f2e9f738c369", size = 230200, upload-time = "2026-08-15T08:17:12.919Z" }, + { url = "https://files.pythonhosted.org/packages/e7/a0/47b18adeed31c8f16ba9700f32c1b18594cfa09f47eb672a488c273c22bf/charset_normalizer-3.5.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e6621fb2a4988d6e53eedc455e5903e2679f3967b8acb3d639f1b63c14a2e893", size = 262222, upload-time = "2026-08-15T08:17:14.571Z" }, + { url = "https://files.pythonhosted.org/packages/38/fe/341861ac118dae06f3ec0eb487488af52128f2ef2faf0b11003944d22259/charset_normalizer-3.5.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:7c0c10730342b0c9b35dd1d619beb8214e520bd96a1f870f452680b238aab3e0", size = 258951, upload-time = "2026-08-15T08:17:16.158Z" }, + { url = "https://files.pythonhosted.org/packages/6f/89/bb5108dc6c3651dca963f2b0a3ba19bbcb370c94e1b6d3e0e844a58e6dca/charset_normalizer-3.5.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b9af956078716df40d985fb0dfeb2c2120c5ca92ba4ff4b388acfd01cdc14d08", size = 248801, upload-time = "2026-08-15T08:17:17.683Z" }, + { url = "https://files.pythonhosted.org/packages/b1/ba/ef83ae3aca816393decfa3530976f38a79812d707b80b580ac33b83f9877/charset_normalizer-3.5.1-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f9f8405c2c758532c74fed975dbee57be1f31a6e865c031870c79a6ed3212ada", size = 244070, upload-time = "2026-08-15T08:17:19.191Z" }, + { url = "https://files.pythonhosted.org/packages/f6/0b/c5292a2462d69b7378ea89793bbb5b2b6fcf6f7dd6d1667f9619094ad553/charset_normalizer-3.5.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:96fef3e886d6a9874b14f27fc193fbdc69d5d8035783d86aa4e1cea594e695f9", size = 240110, upload-time = "2026-08-15T08:17:20.547Z" }, + { url = "https://files.pythonhosted.org/packages/46/22/111e5be3b740d5c2a5bfcedb3d237b6591e5c2e82ae9d6ffcb121fe0909c/charset_normalizer-3.5.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:5d8531a6569d025f68e2321e7638fb7978f23db58e5f69f56913837aae03816e", size = 232836, upload-time = "2026-08-15T08:17:21.895Z" }, + { url = "https://files.pythonhosted.org/packages/f9/d2/d2aad6fe0dbb44b194bf3becb60f5a0ac48446ade999a47fe7bb41eb09a7/charset_normalizer-3.5.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:aae2ee51122d3ae968a3837d97dc24a0aeebb0dea23694422cd172bd30017cd6", size = 262712, upload-time = "2026-08-15T08:17:23.727Z" }, + { url = "https://files.pythonhosted.org/packages/35/5a/337e4663a5eae6de99db940ee8066d4145caafb61327db62deda15313cce/charset_normalizer-3.5.1-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:7235dc28fc6dd9d832ac7c7bce95367dedb85929f17368a0c2bee1e080b9acbf", size = 242977, upload-time = "2026-08-15T08:17:25.157Z" }, + { url = "https://files.pythonhosted.org/packages/ca/85/f82f8a92e31c7519410e2e1afdc630f28ec47490ce2c09a11c1a43cbb459/charset_normalizer-3.5.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:4abdc5f9ad448c1ecbfae2974b820535d6bc6e7eef63babbab3d81cf46968c71", size = 260207, upload-time = "2026-08-15T08:17:26.602Z" }, + { url = "https://files.pythonhosted.org/packages/b7/52/643d11ffd60e9ac2fd1fb87e167a19285b9eefeff4a40e63c87cbfbeab36/charset_normalizer-3.5.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ba501e667c17d8411f98e67a022d9604ef179aff0e459b7e292c796837c13573", size = 250562, upload-time = "2026-08-15T08:17:27.971Z" }, + { url = "https://files.pythonhosted.org/packages/62/16/46556278c2168d12df9da7fede5dc6fc70e60301b26a82bbeec238c9cfe3/charset_normalizer-3.5.1-cp312-cp312-win32.whl", hash = "sha256:cfa1c0cc3a8f9f53f1243a5a99ac36fd003880199383b37672e86ddda9cb07e2", size = 178507, upload-time = "2026-08-15T08:17:29.277Z" }, + { url = "https://files.pythonhosted.org/packages/9d/7a/4c6c298171e6b3e745633180ff59350fc0ca0db1ffd28df1e369e0579f71/charset_normalizer-3.5.1-cp312-cp312-win_amd64.whl", hash = "sha256:3617ac3cfd8b9888f145ad89dd6e692285834b0201c6074a5eeaad3fd4d668c2", size = 200551, upload-time = "2026-08-15T08:17:30.668Z" }, + { url = "https://files.pythonhosted.org/packages/cd/d7/eb95a042f0dd22e304b0b6472b154f3546a1a039a9ee89ccb2a7f61591fc/charset_normalizer-3.5.1-cp312-cp312-win_arm64.whl", hash = "sha256:88e85ab89cb822c1e635f51d6d32e488f94e002e70e2f492bdb8b945543f345a", size = 180700, upload-time = "2026-08-15T08:17:32.028Z" }, + { url = "https://files.pythonhosted.org/packages/bc/61/2cb6ad133dbbb449fa2d37ccae973232f4827e799af258d15e589a3d1e9e/charset_normalizer-3.5.1-cp313-cp313-android_24_arm64_v8a.whl", hash = "sha256:4f298bdadb8f0b9e5672877f647d1be9373ef5320c9e2f049795e26cad28b6a9", size = 211584, upload-time = "2026-08-15T08:17:33.597Z" }, + { url = "https://files.pythonhosted.org/packages/18/57/a305c968be1ca13f3dd1b32f445877e97addf55d80b65c7cb35fac82b777/charset_normalizer-3.5.1-cp313-cp313-android_24_x86_64.whl", hash = "sha256:88ca277405c2d3b71c4e1c2ee0e7966e807bcba86a69d11e19ba199d18ae4491", size = 223359, upload-time = "2026-08-15T08:17:35.022Z" }, + { url = "https://files.pythonhosted.org/packages/09/0a/d3646670292ce8d8f8cc11ac067d44885e697a5591f57a9221128da5e7b3/charset_normalizer-3.5.1-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:9362dd90aa7dab48c0054a21187791ccf05473f7dba5d92b8033ae62164675e7", size = 194464, upload-time = "2026-08-15T08:17:36.452Z" }, + { url = "https://files.pythonhosted.org/packages/de/93/d51ec556e01042fed6f993ea859311bc7917b466684182fbbceb6ca24762/charset_normalizer-3.5.1-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:977cdbd483a9cff38179bea4fd754289a6f2195c7abd414aba85410b3e66cc5e", size = 197676, upload-time = "2026-08-15T08:17:37.819Z" }, + { url = "https://files.pythonhosted.org/packages/a4/a0/562247944386f7d4ef94467e84876600cc1e0f1b93239aaa9213d2bc3cbd/charset_normalizer-3.5.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:e90251c0c7bdd54a100a0dce3c07b7e637278c93af29dbf78ebb89a58c4bac7d", size = 340473, upload-time = "2026-08-15T08:17:39.303Z" }, + { url = "https://files.pythonhosted.org/packages/31/e7/1d994be1b93d41e9502b8b0460eaa88a1dd8df335df415db87d6c3e91ab2/charset_normalizer-3.5.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:94d78ecec2605a8d0398b0f365d5f12a63248438516f5dac536a5eff7337df4a", size = 240156, upload-time = "2026-08-15T08:17:40.66Z" }, + { url = "https://files.pythonhosted.org/packages/09/53/27923ce5cc6cbccb832037b27dca98882d9c53e9b69e866bbbef4aae7fc8/charset_normalizer-3.5.1-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:d59b75732e9b6f27388e10c14b0259cc5f2e48c78627d185e6a177b58ad3cffe", size = 228246, upload-time = "2026-08-15T08:17:42.003Z" }, + { url = "https://files.pythonhosted.org/packages/ce/48/5a97e84d63af1d55c07439cb80e56d99a8efb4295700eb4e18c0d1615d2c/charset_normalizer-3.5.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:0d929fc574b4d6fd9e7c0f5c2ede8716a41911923aa7fa5fce38e0818aa4a1ac", size = 263660, upload-time = "2026-08-15T08:17:43.627Z" }, + { url = "https://files.pythonhosted.org/packages/7a/c2/071575791dcc88316c0a9a65ce38897a82e4cfe4a325f0f7fe1b1ac47bcf/charset_normalizer-3.5.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:394fea06235c8543390050ed5f529187074b029fb027213f6c46ac11ab5d950e", size = 260354, upload-time = "2026-08-15T08:17:45.094Z" }, + { url = "https://files.pythonhosted.org/packages/fb/af/63240b0c0248c075c2535a1f1bd992821d8251b9f173abc13329661d09e4/charset_normalizer-3.5.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:62b55f6722735a6c472f88361cde6640608773d9443cebdbb51abf436a1fcdd3", size = 250638, upload-time = "2026-08-15T08:17:46.496Z" }, + { url = "https://files.pythonhosted.org/packages/4d/66/70dfad64f15be09c15ccfee81330a7e515895dbe296dd23114e9a231268a/charset_normalizer-3.5.1-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:fa48b1b63d639f9483e0633e092f5851e2348c352f1f9bb6c8182f87884ef876", size = 244583, upload-time = "2026-08-15T08:17:47.963Z" }, + { url = "https://files.pythonhosted.org/packages/c0/24/ef36367d38b9ddd4bccbf72888c342e8de1f5ae506fa0b2dcf970e2732a1/charset_normalizer-3.5.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:c71fb0d56c920c269cd3e2e3fe7c610e3f1fdb21a6ce60efa6430ff63676cea6", size = 242038, upload-time = "2026-08-15T08:17:49.481Z" }, + { url = "https://files.pythonhosted.org/packages/db/ab/55e683ba0fff2e43adafc10daa3001eac90fdaa419a97227d5a7067eedde/charset_normalizer-3.5.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:485a0d363cafefcd2538a73c7c838daa2035f09b2c9f9b5e3133f80c6aeb84c2", size = 233677, upload-time = "2026-08-15T08:17:50.845Z" }, + { url = "https://files.pythonhosted.org/packages/bd/67/0f40eaf8d1b6e7cf15e82382a2965efaca787fc1c2794b7021d37aaf5036/charset_normalizer-3.5.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:5c0ea61a470e070686aa30892fed79e297d2c8d0ab46b8bcdf027d38c51da591", size = 264491, upload-time = "2026-08-15T08:17:52.61Z" }, + { url = "https://files.pythonhosted.org/packages/5c/64/12b4c2a11ee8df4fcc518c78b0d93e3a92bd3d5253d1617ce74ff0e8c7ef/charset_normalizer-3.5.1-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:90b7481fb62fbe172c558bc6fd1c4c98d82004a54a7551f20e11ac9bf0b8708c", size = 245196, upload-time = "2026-08-15T08:17:54.023Z" }, + { url = "https://files.pythonhosted.org/packages/37/2e/651d910af6d0fba325eee1cda37ec5443462ed25360e666c144166eb6091/charset_normalizer-3.5.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:35fe081843b35aad20ffeccec3eeffbe637b15d14f3fb22cc1b59cd8ec17e93c", size = 261660, upload-time = "2026-08-15T08:17:55.491Z" }, + { url = "https://files.pythonhosted.org/packages/90/c6/b09e05e6db7f64338e0dc067c79577b1138da86c1e38369096851d96be88/charset_normalizer-3.5.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:fd0350afdc3aabd5576f60ea109228bd5538139713c7b094c5cd27c73a98bc6f", size = 252618, upload-time = "2026-08-15T08:17:57.025Z" }, + { url = "https://files.pythonhosted.org/packages/76/4e/362d4f9fdcdf5556fb2aa3ce7d4a58ebce03ed1ff03aa1d9aca8d02f13f3/charset_normalizer-3.5.1-cp313-cp313-pyemscripten_2025_0_wasm32.whl", hash = "sha256:9d9a0dc7cbe9bec24c3f767c9122c41fe5a1bc43f47cd099d00d393e09769de4", size = 140362, upload-time = "2026-08-15T08:17:58.425Z" }, + { url = "https://files.pythonhosted.org/packages/b4/d4/703be739b26acce318bd29eb3b25b7209e1b1f527f9eae3d1f1f01fdde2b/charset_normalizer-3.5.1-cp313-cp313-win32.whl", hash = "sha256:d63600d620ad0064c3a748b950ac5ea38a80190e5498532efefa4b7b3f1da1f3", size = 177755, upload-time = "2026-08-15T08:18:00.037Z" }, + { url = "https://files.pythonhosted.org/packages/8a/33/56d97ade41c8db611e727168c52ae46c9224c362ec28d4b65d7e9869e8da/charset_normalizer-3.5.1-cp313-cp313-win_amd64.whl", hash = "sha256:aea996a6aba25260827c9ea511d1addfde2da9eb686ac961838509086188b7e6", size = 199295, upload-time = "2026-08-15T08:18:01.506Z" }, + { url = "https://files.pythonhosted.org/packages/5b/75/5b20dd1e6573a01a08158fe104104fa2c8abf941745596954185726cd46c/charset_normalizer-3.5.1-cp313-cp313-win_arm64.whl", hash = "sha256:fd0a274c0e5f9a21565cd9d3dd749b61f96b7aa1e20a93aa1ba4029518f2e5c0", size = 179856, upload-time = "2026-08-15T08:18:02.929Z" }, + { url = "https://files.pythonhosted.org/packages/29/cd/2b812ce5e888f1ce69a5350281e58aab07ae64a958ecae8912f30865718e/charset_normalizer-3.5.1-cp314-cp314-android_24_arm64_v8a.whl", hash = "sha256:774d157f112367ff4abd29019f38f023c24e00e56edc7829c20e358a5a913ad8", size = 212318, upload-time = "2026-08-15T08:18:04.403Z" }, + { url = "https://files.pythonhosted.org/packages/9e/4a/a6ee107430768a5334e6d63f31f148a04a1a491ef161a1ac9415a73f2fa8/charset_normalizer-3.5.1-cp314-cp314-android_24_x86_64.whl", hash = "sha256:26422d45fd13551cf564c58932f7d72b4f58b93b0fcf18c35ba6be12b46bb102", size = 224897, upload-time = "2026-08-15T08:18:05.997Z" }, + { url = "https://files.pythonhosted.org/packages/c3/d9/35ae3f64f29d0179c35c3baefe575904df2913dde519129c7f75995a2b1d/charset_normalizer-3.5.1-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:09a7bba9f739468c8e78c36a75c33768e53cb1959fc638f510454c14683f00d5", size = 194848, upload-time = "2026-08-15T08:18:07.397Z" }, + { url = "https://files.pythonhosted.org/packages/74/76/f2fc7380f056cc273a53af37f50d08ad54b2c59f61078f31432edcf1c2bd/charset_normalizer-3.5.1-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:4c9548dc78002099910abaebc0a72ac58b7d30931869e0351c09b507dff4ece3", size = 198163, upload-time = "2026-08-15T08:18:08.989Z" }, + { url = "https://files.pythonhosted.org/packages/e9/40/095ce62fa078483cccc1fa2b36e6bc9580b85422a20ee9f925341c50e44f/charset_normalizer-3.5.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:c428c6c31eb5f4277d7f8eccaf767fbd548ddd5ce3c8b4f4cbbfab3d96b5904c", size = 341823, upload-time = "2026-08-15T08:18:10.458Z" }, + { url = "https://files.pythonhosted.org/packages/f1/5a/0e58b1c04a1596e0256f407274a92d5fb2ee21324409d1fab1da48a65b5b/charset_normalizer-3.5.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2f06b7eae9dbe77fe1d644ca244dad508de8d302870a43f3c559b521270938a0", size = 242458, upload-time = "2026-08-15T08:18:11.989Z" }, + { url = "https://files.pythonhosted.org/packages/22/95/b4618ce912e6db0b1aae89ba788e38e8a7eba0f3025cc66e8c0699f977b2/charset_normalizer-3.5.1-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:6b7430cf5728e68f6c462254009a6ef4086e1bea43cf2f57aa9c55fb4f50ff96", size = 226717, upload-time = "2026-08-15T08:18:13.401Z" }, + { url = "https://files.pythonhosted.org/packages/8a/76/c681192bbda3d55356db5dadd64381d5202b37c6b598fcda5282e88b5d3d/charset_normalizer-3.5.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ab743e9bc90c1f73552ec33e10e3331315acd2c397b36065b591b0181de533cc", size = 266111, upload-time = "2026-08-15T08:18:14.961Z" }, + { url = "https://files.pythonhosted.org/packages/88/be/55127bfca72c0cff6c022488d140d7c5b04c771e3b72e9bdb4836d54979d/charset_normalizer-3.5.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f6f7deae3feb4edfa2efaf7c574fe88cbf055038a6abdb40188e4fff66d5699f", size = 263128, upload-time = "2026-08-15T08:18:16.515Z" }, + { url = "https://files.pythonhosted.org/packages/e0/91/39c3af510b0aa32bbda03374259200f28430febfd1bf5e511fe765282ce5/charset_normalizer-3.5.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:15f024313246a4ed976c60f440bb8d257815513a681d212ff74fd46f7d715a90", size = 251240, upload-time = "2026-08-15T08:18:18.127Z" }, + { url = "https://files.pythonhosted.org/packages/1c/a5/cbe418bbc6ecdfc3e05a0116002897c4b403a5e838d697e64c78e9f0190d/charset_normalizer-3.5.1-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:823f82903d189af463d7df250ef1f7f696f3cee08cc8d91deb565e8d425f6506", size = 245282, upload-time = "2026-08-15T08:18:19.625Z" }, + { url = "https://files.pythonhosted.org/packages/cc/a4/689bb42e8e7cd492f3cb64907c6bc00ad247ec9a3628cd3f8eed126e8ae1/charset_normalizer-3.5.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:01e93745f7f219b703b60ba7afead36cfc4242782be5af484673fc500df12da5", size = 244597, upload-time = "2026-08-15T08:18:21.121Z" }, + { url = "https://files.pythonhosted.org/packages/c1/ce/9962938e179cf9f699d3f1e7b3114b5d7642dee6a893745229f9dd04f274/charset_normalizer-3.5.1-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:329fc3ccb63ad22d867d84c2adea759a64079a37ba4a343433b02c7a2816871e", size = 231376, upload-time = "2026-08-15T08:18:22.57Z" }, + { url = "https://files.pythonhosted.org/packages/85/54/46000450ada53bd9eac5429a2c8c54cd2d9b39c0c255f229aea9af0948a5/charset_normalizer-3.5.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:bb57753e36e4855b8ca375069482250a6246372331a3e4f3407eaebb007443f5", size = 266715, upload-time = "2026-08-15T08:18:24.235Z" }, + { url = "https://files.pythonhosted.org/packages/3d/bb/618749d70f792b44252a777bf89bfb86823b9bbc1ea13fe8ce759b07f38a/charset_normalizer-3.5.1-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:fce8cbd4997efeb450bd298b54f755dcdff18d496f7a5ddbb4867c6d7c88fdc3", size = 245848, upload-time = "2026-08-15T08:18:25.726Z" }, + { url = "https://files.pythonhosted.org/packages/7e/3f/ffb64458527c7668031d5eb095d978de561958dc9f5b53f8e488a533e603/charset_normalizer-3.5.1-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:6c9cdde8becb25a7fde49924511aa2644d6f8081cc8df8e9452724303348d8e3", size = 264521, upload-time = "2026-08-15T08:18:27.193Z" }, + { url = "https://files.pythonhosted.org/packages/4f/ab/74a55fd803916a35ac461daf002708191aac19b546b80dc8cabfedc63d98/charset_normalizer-3.5.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:9ac4444d8d4fd4c4bd08bf451ed3167aa9e7ec6cdb41b648794f1d1103652e36", size = 253054, upload-time = "2026-08-15T08:18:28.568Z" }, + { url = "https://files.pythonhosted.org/packages/a0/2a/6a9034b7d3c60b17499afb482df5878bf9fa20b50cc3887d5ef017a833db/charset_normalizer-3.5.1-cp314-cp314-pyemscripten_2026_0_wasm32.whl", hash = "sha256:f03ac127268b43ef4fe9e6ab6794a6794b49485a0cc0c1db79876d2f33f75bc7", size = 140580, upload-time = "2026-08-15T08:18:30.214Z" }, + { url = "https://files.pythonhosted.org/packages/f3/46/1d362e1a00d035d66b9869e1281eee115907f7e390a16a07824ab5737360/charset_normalizer-3.5.1-cp314-cp314-win32.whl", hash = "sha256:1f5883d77fd409a261abb5dc8ccbe335720d798b1de4abb3b1d47ccbbc76b53b", size = 180325, upload-time = "2026-08-15T08:18:31.877Z" }, + { url = "https://files.pythonhosted.org/packages/7a/7c/4938c329b6a9d446f6a59aa2092ff7118f274209b5ed0e26893d1d30a63c/charset_normalizer-3.5.1-cp314-cp314-win_amd64.whl", hash = "sha256:c658c50ac0c98cd755a2dd50b7977d3bca7df401dcc47fbdfa87db53ef7d4e8b", size = 204175, upload-time = "2026-08-15T08:18:33.466Z" }, + { url = "https://files.pythonhosted.org/packages/ac/33/eeb384dbd8dec570661354592f4f2e1b2fcc92585624d146a000caf53841/charset_normalizer-3.5.1-cp314-cp314-win_arm64.whl", hash = "sha256:4bea7f8ebe90bbd7f0e4a2de42ca6924ba23e3e76418c408ff82f1d46fabd687", size = 184123, upload-time = "2026-08-15T08:18:34.913Z" }, + { url = "https://files.pythonhosted.org/packages/1c/6c/c73fa9d5a85f6ab05395de61c5f6984e0a9ff40bb5ff888d46dff02526c6/charset_normalizer-3.5.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:fbc597639158fd7c14d55e808718848319540f51b0e6746e3eefa59723a4a348", size = 381682, upload-time = "2026-08-15T08:18:36.349Z" }, + { url = "https://files.pythonhosted.org/packages/30/c7/63565f860921457feba93bae6c86fb7746deb4cffeed2f375cb845318146/charset_normalizer-3.5.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e71c909f353863b2b89c83de2ebed71ea6d0df8a6ef65a128193c5e650766bef", size = 240826, upload-time = "2026-08-15T08:18:37.887Z" }, + { url = "https://files.pythonhosted.org/packages/06/ae/7ae8807410dfa33f8e6f1715740adeaafa8a816cc4cb33508f54b1f7c896/charset_normalizer-3.5.1-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:7ac76cf9afd34929d76eb7fcb63be476a4853d8a96f0dcf2d0db68a0cbdf9885", size = 227861, upload-time = "2026-08-15T08:18:39.315Z" }, + { url = "https://files.pythonhosted.org/packages/e9/a3/887c1642f0da26000b0e0652d91071113c0e72cea33952e225cf589f49a9/charset_normalizer-3.5.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a3a370082ce34d0612f421e15fe011c53bb1feff21a26d06ad4fb244dab5a375", size = 260758, upload-time = "2026-08-15T08:18:40.88Z" }, + { url = "https://files.pythonhosted.org/packages/3e/11/e6f5b9a3d0e55b0ef7505cd3765cdd48f22db89994c947b316f52f801fd8/charset_normalizer-3.5.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:256dd4d85d9e4dc595e2bc983c980e73f62ddeb3165c58b4c3dfe78c5c8548c1", size = 259950, upload-time = "2026-08-15T08:18:42.351Z" }, + { url = "https://files.pythonhosted.org/packages/1b/ee/e4e10a94d51cd1ee638aa7e00b65399e6b2a4e8376ab6d2eac9f95586671/charset_normalizer-3.5.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:58d4aa13a59c969dbfdf9e6a9560e242cbfd9e8a8f50c2747714df1a423adf65", size = 249329, upload-time = "2026-08-15T08:18:43.914Z" }, + { url = "https://files.pythonhosted.org/packages/c4/25/d5f4198819e6059735a84e8d0bfb72dc33976da67b97adcd3fb5a5e07ec6/charset_normalizer-3.5.1-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0c6dfb5ca6723eeed15aa8e564a014d69fcb8812f94eef11fe3631e0508199f5", size = 243137, upload-time = "2026-08-15T08:18:45.368Z" }, + { url = "https://files.pythonhosted.org/packages/a5/e9/e925ca7569cf9fb9701fd82503fee73eea5268fdb856bdd64947092d3daa/charset_normalizer-3.5.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c010f5581d9c612804cc59fcf7b524b707fbcb72828551237ab545bb5c7034af", size = 242820, upload-time = "2026-08-15T08:18:46.842Z" }, + { url = "https://files.pythonhosted.org/packages/34/17/672c251a888ed2aebcdd2fe830ad0104e25ff83c43f5c4f9c15e9fc6853c/charset_normalizer-3.5.1-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:52ec005752a56ae79547a05c0139ca2501a0c866390b6115008456b9f0e7cde1", size = 230504, upload-time = "2026-08-15T08:18:48.353Z" }, + { url = "https://files.pythonhosted.org/packages/3f/fc/f6a85abebd42ce4da2f1db0aa56cc6a0df1995e318b3875d14401b8381d1/charset_normalizer-3.5.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:2bced4061f000f7187254a02ad3433ae17eaf991747ceea2f478422590a5bba9", size = 263087, upload-time = "2026-08-15T08:18:49.859Z" }, + { url = "https://files.pythonhosted.org/packages/98/66/7c42677e739ba66746b297e2046918d793078094dc239e1e72768cffccc6/charset_normalizer-3.5.1-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:9eea3ab2597a5e65fe65296e2d6a84570845a6b55532d90333d740d48bbc850a", size = 243269, upload-time = "2026-08-15T08:18:51.601Z" }, + { url = "https://files.pythonhosted.org/packages/de/d8/a50b79237f417af10f8c2a501ce8d1ca87829a22e69117891ca4ba20a69e/charset_normalizer-3.5.1-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:496846868fea80e479324862fa877f02411f2fd0f83b79ccee2607aa68b2a032", size = 258766, upload-time = "2026-08-15T08:18:53.23Z" }, + { url = "https://files.pythonhosted.org/packages/2e/1d/0fc91aeaeb3c83b748f532399ce67cf84604b48297405d740000f7a9e786/charset_normalizer-3.5.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:85d5855daafc240cc045c026d7a15fd198a09b0fc8ff6f5ecbb5297b509cb11e", size = 250814, upload-time = "2026-08-15T08:18:54.768Z" }, + { url = "https://files.pythonhosted.org/packages/ae/10/3d8c777cf9024615295aa1b808324ad5b4a77855869c00824bad74ffaf8a/charset_normalizer-3.5.1-cp314-cp314t-win32.whl", hash = "sha256:58d3e12c88e0950bca850ae1f7c256055c097639c2edb9eb123af9807d8b15e4", size = 191074, upload-time = "2026-08-15T08:18:56.305Z" }, + { url = "https://files.pythonhosted.org/packages/4d/81/ae557d3c44d1a1d688696d60563413a0866a91b7ebc50f20df838be3d8c8/charset_normalizer-3.5.1-cp314-cp314t-win_amd64.whl", hash = "sha256:acaf604462bf330b0d07e7a07c1d6e4adac79e5fb13e9c5140590542cafacc00", size = 216476, upload-time = "2026-08-15T08:18:57.889Z" }, + { url = "https://files.pythonhosted.org/packages/27/e9/61c01fb8b804692569c036b3fc50495814502dcf13a60649c6055390b02c/charset_normalizer-3.5.1-cp314-cp314t-win_arm64.whl", hash = "sha256:fdb8a068947befafba9952162645dc2fecaeb400e64584829ed5e9b2fbe21a7f", size = 194115, upload-time = "2026-08-15T08:18:59.418Z" }, + { url = "https://files.pythonhosted.org/packages/4a/4e/8544831ef59d8f27ce92c80871380fdacc8076a8a56ed62f82e54f991333/charset_normalizer-3.5.1-cp315-cp315-macosx_10_15_universal2.whl", hash = "sha256:9085f87b0e38a2b92b8923059b4e8789fe40d9279712d15dcc670048d77079af", size = 342048, upload-time = "2026-08-15T08:19:01.054Z" }, + { url = "https://files.pythonhosted.org/packages/7f/a6/e3b46852424246065355644f4fb6dbccc0239a42a2eee27ecfc8957f0bcd/charset_normalizer-3.5.1-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2679de311c7946dde5d3b6f44941844133ff5c7cb86099c0061ab1e8901c20a8", size = 242997, upload-time = "2026-08-15T08:19:02.492Z" }, + { url = "https://files.pythonhosted.org/packages/03/3b/0cc9a26777334ab2f2e3089b948bbf4e4fe72ea70b897715ef6415043ec8/charset_normalizer-3.5.1-cp315-cp315-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:baf3775a2635e5a11fbd5e4e64ee69c7e86875d224a5c72aca4c141064589a90", size = 237014, upload-time = "2026-08-15T08:19:03.943Z" }, + { url = "https://files.pythonhosted.org/packages/8c/c2/027335f0aa337a2a2e121bac1ad88c4f02ba6053ea0926802784f3db11af/charset_normalizer-3.5.1-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8ac8c94b6539074e0f40899301273ac8402b9b3e01c7b7ba269ff30340aaaf20", size = 266174, upload-time = "2026-08-15T08:19:05.598Z" }, + { url = "https://files.pythonhosted.org/packages/86/d3/e367787febe4e74769dec0f406f2c3c8d1b955fce5aee1fd0f94e8367a45/charset_normalizer-3.5.1-cp315-cp315-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:8fe532b3c966d1fb794e0698e4589d0444017ae77fc0b31edea13c0e35bcc449", size = 263361, upload-time = "2026-08-15T08:19:07.251Z" }, + { url = "https://files.pythonhosted.org/packages/af/3d/391b193eb9f3e84b02f9314088c386debdc0debee843535aaea2e2c6715d/charset_normalizer-3.5.1-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5c84bec0ab5ae0c64bfe73a7d2adcb5ce73b467523fc27fd6a28ab2aa6cbe35a", size = 252143, upload-time = "2026-08-15T08:19:08.816Z" }, + { url = "https://files.pythonhosted.org/packages/2e/57/de221f1745a90d418199761967e2776bfe2c275a1194220985e8c1d37833/charset_normalizer-3.5.1-cp315-cp315-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:854066be00447fa8de2ccbbe893e2ffc4b123ef16d897af794c1e18bd4a714b0", size = 252086, upload-time = "2026-08-15T08:19:10.255Z" }, + { url = "https://files.pythonhosted.org/packages/c8/e3/d119f86a01f9331e8186175f24873b1d74a7ee9e2e4b4d68f9947dae5afd/charset_normalizer-3.5.1-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:21b82d8082f6f5e7f456ef0bd16323d08de1266efbfeb476e64b2a91d1471a4e", size = 245231, upload-time = "2026-08-15T08:19:11.807Z" }, + { url = "https://files.pythonhosted.org/packages/26/de/d8e48c135ae480879539cdb179c8d3b50c7879497d75dd899b5763b69cee/charset_normalizer-3.5.1-cp315-cp315-musllinux_1_2_armv7l.whl", hash = "sha256:838648accb3a7fd9803fd45c87bce8509648eb0c11bc34e216141300977244f2", size = 241546, upload-time = "2026-08-15T08:19:13.416Z" }, + { url = "https://files.pythonhosted.org/packages/67/c4/217755fd1abc50d326c252922cd642002758095a81ff45010337b8b3ef65/charset_normalizer-3.5.1-cp315-cp315-musllinux_1_2_ppc64le.whl", hash = "sha256:195ce897c6153c0700078142cf8efe3e6454ca4cf4357499e4078dfd83396626", size = 267033, upload-time = "2026-08-15T08:19:14.981Z" }, + { url = "https://files.pythonhosted.org/packages/b8/d7/34d8e404e358d2adcc5a228c2134643af00104c8fb0bf525f3688d756f05/charset_normalizer-3.5.1-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:978eab16f55b4ab2c2a745be9a0a840bf8f09a7f227d9c76eb30214d078865a5", size = 252045, upload-time = "2026-08-15T08:19:16.618Z" }, + { url = "https://files.pythonhosted.org/packages/5e/fa/40414471acf0aa0692ca77305aa00e434fcd8288f0941c93c30e9a5f8f2f/charset_normalizer-3.5.1-cp315-cp315-musllinux_1_2_s390x.whl", hash = "sha256:cc0329df4caaceb950d2f580b5ac716a377f7059624a0bafaeaf8a218c6ed774", size = 264866, upload-time = "2026-08-15T08:19:18.101Z" }, + { url = "https://files.pythonhosted.org/packages/32/90/fcc850bae791abd2e0c041847f13e270aa08692a79f3e00de6d2dce1cb50/charset_normalizer-3.5.1-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:687c9ca3035544b113bea2055e180af96fb63c0c476e22a9180f51925186e7b7", size = 253932, upload-time = "2026-08-15T08:19:19.734Z" }, + { url = "https://files.pythonhosted.org/packages/af/af/53afe99068b3c10b4cbae592a52ef72a7c92c0188440e83ee3a078fd8f75/charset_normalizer-3.5.1-cp315-cp315-win32.whl", hash = "sha256:706bfd38730a5ac7a365793269a00f4e988178cec121391f4248d84ad8c972e9", size = 180320, upload-time = "2026-08-15T08:19:21.37Z" }, + { url = "https://files.pythonhosted.org/packages/c9/bc/f46a132041b29e4a8779ed712d3df1bf112e94ca8de58b66d7ec2c0cf8b9/charset_normalizer-3.5.1-cp315-cp315-win_amd64.whl", hash = "sha256:92caef967d287a407085d61176fce4012b1dd62daed4eb6d5ceb26d3d2538712", size = 204174, upload-time = "2026-08-15T08:19:23.088Z" }, + { url = "https://files.pythonhosted.org/packages/a1/5d/9ed554480eda8e447b673648628fdc29574d23dbad01fe11837adedd1cae/charset_normalizer-3.5.1-cp315-cp315-win_arm64.whl", hash = "sha256:5fc45d653ea8c9a20479167e11d4a0f8cb2fa3470737ab6f9c827532313187b7", size = 184126, upload-time = "2026-08-15T08:19:24.471Z" }, + { url = "https://files.pythonhosted.org/packages/3b/32/9b8929bf384061ee1fe5d9c27c6f9776d3d824039ad4e14c88ec00c7808e/charset_normalizer-3.5.1-cp315-cp315t-macosx_10_15_universal2.whl", hash = "sha256:59171c6e45bf07d0d5cab3b0bf81d945035530f6873398b3b531c31184d46663", size = 381441, upload-time = "2026-08-15T08:19:26.038Z" }, + { url = "https://files.pythonhosted.org/packages/96/10/e9aa7923d3ddac652c99a1c5f7be494e737e151566a44abe018daf757f2c/charset_normalizer-3.5.1-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9dbdd9205662134957cf0c324f639bdc5031c0ca056e2369e238db75187c0f11", size = 241742, upload-time = "2026-08-15T08:19:27.532Z" }, + { url = "https://files.pythonhosted.org/packages/28/53/a2d249ebddf47b889a100c0bdcb61a2f9dbb8bc24ef325cc062e4f476877/charset_normalizer-3.5.1-cp315-cp315t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e4b018dc5a0eee4676e38fe84a47a427816c590b93b55d9025274ec4d6ffc2dc", size = 235298, upload-time = "2026-08-15T08:19:29.274Z" }, + { url = "https://files.pythonhosted.org/packages/7d/07/469f78af590f7d5cd48e20d8dbfa3d66deeff9ba37768c04d886b5afd45c/charset_normalizer-3.5.1-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ced3fdd71aaa83ce593746c2edb42b7a59cb4c19c8b5c407781c72e493aae55a", size = 262500, upload-time = "2026-08-15T08:19:30.955Z" }, + { url = "https://files.pythonhosted.org/packages/55/66/3bb56a47f7dcba014055b1a1d33c6f08bbe9c1e74dba154cfa25f90ae885/charset_normalizer-3.5.1-cp315-cp315t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:19a3dd5aa73cef1c99687c4fc57db016a9c17104ae1185da88ba566a5d3bebe4", size = 258888, upload-time = "2026-08-15T08:19:32.458Z" }, + { url = "https://files.pythonhosted.org/packages/ff/c1/2adc2800903fb013210349313b710a5376856578d9e33e6b9a1d8b36714a/charset_normalizer-3.5.1-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:cc5d36d96478aa9c60654bd932525bf32964c62a7281eafdf16d85003a8d6004", size = 250243, upload-time = "2026-08-15T08:19:33.94Z" }, + { url = "https://files.pythonhosted.org/packages/95/b5/a18d0dd1157ab655cc2cb14a545f4a4784bbad70ab3502412e36097502d9/charset_normalizer-3.5.1-cp315-cp315t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:04368edf83514385ffc3e1cfd4546e595f4f1272dd23ba437a93a9cc3741d47b", size = 249871, upload-time = "2026-08-15T08:19:35.413Z" }, + { url = "https://files.pythonhosted.org/packages/ad/c3/525f508cd1e58d0450ac55ed40ac75bc3a97482c59def5278456a5fbf03c/charset_normalizer-3.5.1-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:9b5db6052055d34d41230fb78d7c439c23dc536a9896f6cb039e8dd92cfc1263", size = 243580, upload-time = "2026-08-15T08:19:36.886Z" }, + { url = "https://files.pythonhosted.org/packages/7c/c1/49a91fe7e97c8140094ca5c64161ab623a70d9f636bf834eace14048acb5/charset_normalizer-3.5.1-cp315-cp315t-musllinux_1_2_armv7l.whl", hash = "sha256:252d099029bcbea642f2a06c4ed5046bdf8b5a8150b64afa5e027e88b106e5ee", size = 239807, upload-time = "2026-08-15T08:19:38.392Z" }, + { url = "https://files.pythonhosted.org/packages/d3/58/56a48c296601274c4689b864a8e2dfb209b81dfcb39472753ce95eea662b/charset_normalizer-3.5.1-cp315-cp315t-musllinux_1_2_ppc64le.whl", hash = "sha256:6199d5606e2bbf2b096cf64d03f8b6790c91081d5ac866b8e7bb6422738cc60c", size = 264083, upload-time = "2026-08-15T08:19:39.856Z" }, + { url = "https://files.pythonhosted.org/packages/10/4c/dc48409274a1817ff349711d26c62aa0c597df865d4d69ef79160c859193/charset_normalizer-3.5.1-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:77efcff2b23071c349402ac1066667a3d011f62398d81408c9b88ad991747c9e", size = 250317, upload-time = "2026-08-15T08:19:41.53Z" }, + { url = "https://files.pythonhosted.org/packages/81/58/d325912115caec62d6bdd77bbab5e0b7da5d234a9f20affdffcbcb530d0b/charset_normalizer-3.5.1-cp315-cp315t-musllinux_1_2_s390x.whl", hash = "sha256:a5cbd90ecf0fc62e64726917ad083b73001f0563657a87ec3c0b504e277dc90d", size = 258173, upload-time = "2026-08-15T08:19:43.07Z" }, + { url = "https://files.pythonhosted.org/packages/34/f7/b13b1ccae2c8ec63980d13be1890eb73f8aeabbfce02a24aabc0908788f5/charset_normalizer-3.5.1-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:4d26f14f041e83dd8edfd61f4cd4fa7285d31798b5bf1f28e70c367ba6c41d61", size = 251960, upload-time = "2026-08-15T08:19:44.587Z" }, + { url = "https://files.pythonhosted.org/packages/1e/25/ed3f9919c5aef8cc818be1f972f565f7610d7b2076b8ebb98839516ffc3c/charset_normalizer-3.5.1-cp315-cp315t-win32.whl", hash = "sha256:ac13b004224fb341e1e25a1ed5e19d32f57cdb2a403e01f003b46f051a550f6f", size = 191186, upload-time = "2026-08-15T08:19:46.293Z" }, + { url = "https://files.pythonhosted.org/packages/69/d5/43c2b3e9d8267092b913eb8b0603f0f71993c395632886bd37a7223f96cf/charset_normalizer-3.5.1-cp315-cp315t-win_amd64.whl", hash = "sha256:35aea775dc2bd5f54cd84a1cd2696cc3207c479cb9cf0bd346f0d343e4300ddb", size = 215947, upload-time = "2026-08-15T08:19:47.853Z" }, + { url = "https://files.pythonhosted.org/packages/a8/76/9aad3e9c8865e5e0efa9a7f6f81c37a67635a985145ecd44528a81e088ee/charset_normalizer-3.5.1-cp315-cp315t-win_arm64.whl", hash = "sha256:fb78f6e7fcd8ad785d28cd577168bc1aaee827b25bb8755638f694794ea98f0a", size = 193909, upload-time = "2026-08-15T08:19:49.383Z" }, + { url = "https://files.pythonhosted.org/packages/5b/97/fb4e82231aba271ffd775a1b4993b0defc4e3059f286ae41d9433409fe85/charset_normalizer-3.5.1-cp37-abi3-macosx_10_9_universal2.whl", hash = "sha256:41876ee62a3dddf48ff1121ad8f0798032aa03f2fd35f21f34a4cab14f18d8d2", size = 331467, upload-time = "2026-08-15T08:19:50.959Z" }, + { url = "https://files.pythonhosted.org/packages/9f/2f/fe3f187327aac18e2d54e9d2b08e15d27bf9b642d9e51c219f130fc34d1a/charset_normalizer-3.5.1-cp37-abi3-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:a6dac12ff6b846103483683f60c5f8fee205121adc58ffd87e90a90a3af69e99", size = 253057, upload-time = "2026-08-15T08:19:52.654Z" }, + { url = "https://files.pythonhosted.org/packages/d7/c7/9e48cee5c161fe24da823b61bf381921d77cb994a0a4de148e95018c1984/charset_normalizer-3.5.1-cp37-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:cee5dd7c6fb5dd52a0fe2a740f9bc6e3593f5f8b1788bde49de02086f30182b2", size = 240930, upload-time = "2026-08-15T08:19:54.163Z" }, + { url = "https://files.pythonhosted.org/packages/49/e0/716601f3cc69be7b198951150c75ead1ece33c3c8036ff6ffa46029659a0/charset_normalizer-3.5.1-cp37-abi3-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:343fb4f2821043bd87095f7b08a1a181febc8e36ac64212143bbfd0a0e1bc235", size = 230822, upload-time = "2026-08-15T08:19:55.807Z" }, + { url = "https://files.pythonhosted.org/packages/d3/05/71bfc5caa0abcc45aea1f6a4d50ac68e59605ddc7666fe8494f4cd229665/charset_normalizer-3.5.1-cp37-abi3-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ae4a097991662cd4fff0ddc74e0fe7874f82e00042fa0ea00855645ed0c79598", size = 260037, upload-time = "2026-08-15T08:19:57.312Z" }, + { url = "https://files.pythonhosted.org/packages/c3/92/de7e32ed05341e7a9c4c877c318418197b7f2d66a3b68d561bf2ac57ca3e/charset_normalizer-3.5.1-cp37-abi3-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4b599739b93b2cbeded49645ae3c8d1405c29ddfbceac1545c87a3f9580a9e96", size = 255097, upload-time = "2026-08-15T08:19:59.056Z" }, + { url = "https://files.pythonhosted.org/packages/f5/7b/ade0a122600319dfa0b1000ab0f9731c94a817904cf3c5de408c73a4ede7/charset_normalizer-3.5.1-cp37-abi3-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b39b69b347e5e47a3b5b8cfc005c68c1ba347474e3960236c4944a8ecd174962", size = 250166, upload-time = "2026-08-15T08:20:00.612Z" }, + { url = "https://files.pythonhosted.org/packages/75/9c/019fbb9f4834491a160951349b1a3714439376f66e5f7cf18b4f18f0c7aa/charset_normalizer-3.5.1-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:a2028475ba855475b8b4d3cfeb4994269c967aea8b9892dfba907f4263a863a3", size = 241821, upload-time = "2026-08-15T08:20:02.321Z" }, + { url = "https://files.pythonhosted.org/packages/2b/b8/11d4840bfc99330cc7fbcc2681ee5a044553a6e77655508d8f9b2bff7b34/charset_normalizer-3.5.1-cp37-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:36047af20e17097c3bb9476c2b7655f2f7aa51322c0ba58c07695bedf755a950", size = 232529, upload-time = "2026-08-15T08:20:04.008Z" }, + { url = "https://files.pythonhosted.org/packages/18/96/2b3a21492d9f65171ac75d872f5018260013d00bfa0ff70ec9f179148cbd/charset_normalizer-3.5.1-cp37-abi3-musllinux_1_2_ppc64le.whl", hash = "sha256:4c4fb141a727957c93edfe5c32a26ceb6b5f6461d67146e2d39f51e16170bea8", size = 260348, upload-time = "2026-08-15T08:20:05.877Z" }, + { url = "https://files.pythonhosted.org/packages/d6/aa/a69a2028e8bd052476c245460ab19d7de595de084dd968f2d75cd50c3e25/charset_normalizer-3.5.1-cp37-abi3-musllinux_1_2_riscv64.whl", hash = "sha256:2f293479cce755c75f1697e87c409b7ae4c555c7dfecb6e988ad13abba943031", size = 247234, upload-time = "2026-08-15T08:20:07.487Z" }, + { url = "https://files.pythonhosted.org/packages/35/8a/3d130aeabcaf3d2466af76b7b141c08d9e89c9016ab4b7cdd0f7dc2d1c62/charset_normalizer-3.5.1-cp37-abi3-musllinux_1_2_s390x.whl", hash = "sha256:3588e376b3ea2eea84976f67273d679f229e24c66dce7b82ae45aef04ff6e072", size = 256917, upload-time = "2026-08-15T08:20:09.142Z" }, + { url = "https://files.pythonhosted.org/packages/80/c2/a7379b840292d0c1ab9fbd17d1f3967aa81794dc95bc74be8999d7fedcf7/charset_normalizer-3.5.1-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:e199fb99720074809a7720f1c0b4d919eea8b87e88713e0f8f602f7bef543d9d", size = 254846, upload-time = "2026-08-15T08:20:10.727Z" }, + { url = "https://files.pythonhosted.org/packages/01/65/d43b714731bb2f40d4053dfa00ecfc1c5a301f8e3316c5db3a09af59fe94/charset_normalizer-3.5.1-cp37-abi3-win32.whl", hash = "sha256:dd732602a7009217f658d5863d12d79d373a4de0eebc111094bcdd3bb8e0a6cc", size = 174216, upload-time = "2026-08-15T08:20:12.334Z" }, + { url = "https://files.pythonhosted.org/packages/35/4f/b911ed898b26a09789eba9c9200c999aff6c61b4bafaf4838e56d1a1e1a3/charset_normalizer-3.5.1-cp37-abi3-win_amd64.whl", hash = "sha256:70055ff39b97c99e7ae40ea3e393fb62aa2e44dbd9b29f8d14f42fb0025c3959", size = 199764, upload-time = "2026-08-15T08:20:13.908Z" }, + { url = "https://files.pythonhosted.org/packages/f0/a7/920baf467bfd9bf689f3b318340f37aee4572a71f162bd8db51da55ba4fa/charset_normalizer-3.5.1-cp37-abi3-win_arm64.whl", hash = "sha256:87e4f41d375c0b9be2fb5251aee4b8a689169e134535aed81bf085c3b647451e", size = 287318, upload-time = "2026-08-15T08:20:15.551Z" }, + { url = "https://files.pythonhosted.org/packages/cc/61/d01fc49b8dea277640b55a9e15960dbca9fdc8c9fde18e572d39c59f4019/charset_normalizer-3.5.1-py3-none-any.whl", hash = "sha256:6df0ec430f9a831772c23ca5a224cba36517a58a84bb32c32bb59a9fa67c47f6", size = 68658, upload-time = "2026-08-15T08:20:43.306Z" }, +] + +[[package]] +name = "click" +version = "8.5.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/c7/0e/7fa0ef50764b67090eca4114772a2abf8b6148198475e54c660b97caeee6/click-8.5.0.tar.gz", hash = "sha256:ba0d2089de75ea0310e2dde03160e6ca10009947fb95a182f9b54021bb272e34", size = 382235, upload-time = "2026-08-26T13:33:14.56Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/58/50/6c0d534c5f134586a8e1ba4e330569e32f057e33372ae556463212fb4cd3/click-8.5.0-py3-none-any.whl", hash = "sha256:255bc9599cf7748b4b1a446ccc735421bd08a2ae529a8b88597d3de5664ee360", size = 125251, upload-time = "2026-08-26T13:33:12.928Z" }, +] + +[[package]] +name = "cloudpickle" +version = "3.1.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/27/fb/576f067976d320f5f0114a8d9fa1215425441bb35627b1993e5afd8111e5/cloudpickle-3.1.2.tar.gz", hash = "sha256:7fda9eb655c9c230dab534f1983763de5835249750e85fbcef43aaa30a9a2414", size = 22330, upload-time = "2025-11-03T09:25:26.604Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/88/39/799be3f2f0f38cc727ee3b4f1445fe6d5e4133064ec2e4115069418a5bb6/cloudpickle-3.1.2-py3-none-any.whl", hash = "sha256:9acb47f6afd73f60dc1df93bb801b472f05ff42fa6c84167d25cb206be1fbf4a", size = 22228, upload-time = "2025-11-03T09:25:25.534Z" }, +] + +[[package]] +name = "colorama" +version = "0.4.6" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" }, +] + +[[package]] +name = "comm" +version = "0.2.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/4c/13/7d740c5849255756bc17888787313b61fd38a0a8304fc4f073dfc46122aa/comm-0.2.3.tar.gz", hash = "sha256:2dc8048c10962d55d7ad693be1e7045d891b7ce8d999c97963a5e3e99c055971", size = 6319, upload-time = "2025-07-25T14:02:04.452Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/60/97/891a0971e1e4a8c5d2b20bbe0e524dc04548d2307fee33cdeba148fd4fc7/comm-0.2.3-py3-none-any.whl", hash = "sha256:c615d91d75f7f04f095b30d1c1711babd43bdc6419c1be9886a85f2f4e489417", size = 7294, upload-time = "2025-07-25T14:02:02.896Z" }, +] + +[[package]] +name = "contourpy" +version = "1.3.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/58/01/1253e6698a07380cd31a736d248a3f2a50a7c88779a1813da27503cadc2a/contourpy-1.3.3.tar.gz", hash = "sha256:083e12155b210502d0bca491432bb04d56dc3432f95a979b429f2848c3dbe880", size = 13466174, upload-time = "2025-07-26T12:03:12.549Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/be/45/adfee365d9ea3d853550b2e735f9d66366701c65db7855cd07621732ccfc/contourpy-1.3.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:b08a32ea2f8e42cf1d4be3169a98dd4be32bafe4f22b6c4cb4ba810fa9e5d2cb", size = 293419, upload-time = "2025-07-26T12:01:21.16Z" }, + { url = "https://files.pythonhosted.org/packages/53/3e/405b59cfa13021a56bba395a6b3aca8cec012b45bf177b0eaf7a202cde2c/contourpy-1.3.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:556dba8fb6f5d8742f2923fe9457dbdd51e1049c4a43fd3986a0b14a1d815fc6", size = 273979, upload-time = "2025-07-26T12:01:22.448Z" }, + { url = "https://files.pythonhosted.org/packages/d4/1c/a12359b9b2ca3a845e8f7f9ac08bdf776114eb931392fcad91743e2ea17b/contourpy-1.3.3-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:92d9abc807cf7d0e047b95ca5d957cf4792fcd04e920ca70d48add15c1a90ea7", size = 332653, upload-time = "2025-07-26T12:01:24.155Z" }, + { url = "https://files.pythonhosted.org/packages/63/12/897aeebfb475b7748ea67b61e045accdfcf0d971f8a588b67108ed7f5512/contourpy-1.3.3-cp312-cp312-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b2e8faa0ed68cb29af51edd8e24798bb661eac3bd9f65420c1887b6ca89987c8", size = 379536, upload-time = "2025-07-26T12:01:25.91Z" }, + { url = "https://files.pythonhosted.org/packages/43/8a/a8c584b82deb248930ce069e71576fc09bd7174bbd35183b7943fb1064fd/contourpy-1.3.3-cp312-cp312-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:626d60935cf668e70a5ce6ff184fd713e9683fb458898e4249b63be9e28286ea", size = 384397, upload-time = "2025-07-26T12:01:27.152Z" }, + { url = "https://files.pythonhosted.org/packages/cc/8f/ec6289987824b29529d0dfda0d74a07cec60e54b9c92f3c9da4c0ac732de/contourpy-1.3.3-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4d00e655fcef08aba35ec9610536bfe90267d7ab5ba944f7032549c55a146da1", size = 362601, upload-time = "2025-07-26T12:01:28.808Z" }, + { url = "https://files.pythonhosted.org/packages/05/0a/a3fe3be3ee2dceb3e615ebb4df97ae6f3828aa915d3e10549ce016302bd1/contourpy-1.3.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:451e71b5a7d597379ef572de31eeb909a87246974d960049a9848c3bc6c41bf7", size = 1331288, upload-time = "2025-07-26T12:01:31.198Z" }, + { url = "https://files.pythonhosted.org/packages/33/1d/acad9bd4e97f13f3e2b18a3977fe1b4a37ecf3d38d815333980c6c72e963/contourpy-1.3.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:459c1f020cd59fcfe6650180678a9993932d80d44ccde1fa1868977438f0b411", size = 1403386, upload-time = "2025-07-26T12:01:33.947Z" }, + { url = "https://files.pythonhosted.org/packages/cf/8f/5847f44a7fddf859704217a99a23a4f6417b10e5ab1256a179264561540e/contourpy-1.3.3-cp312-cp312-win32.whl", hash = "sha256:023b44101dfe49d7d53932be418477dba359649246075c996866106da069af69", size = 185018, upload-time = "2025-07-26T12:01:35.64Z" }, + { url = "https://files.pythonhosted.org/packages/19/e8/6026ed58a64563186a9ee3f29f41261fd1828f527dd93d33b60feca63352/contourpy-1.3.3-cp312-cp312-win_amd64.whl", hash = "sha256:8153b8bfc11e1e4d75bcb0bff1db232f9e10b274e0929de9d608027e0d34ff8b", size = 226567, upload-time = "2025-07-26T12:01:36.804Z" }, + { url = "https://files.pythonhosted.org/packages/d1/e2/f05240d2c39a1ed228d8328a78b6f44cd695f7ef47beb3e684cf93604f86/contourpy-1.3.3-cp312-cp312-win_arm64.whl", hash = "sha256:07ce5ed73ecdc4a03ffe3e1b3e3c1166db35ae7584be76f65dbbe28a7791b0cc", size = 193655, upload-time = "2025-07-26T12:01:37.999Z" }, + { url = "https://files.pythonhosted.org/packages/68/35/0167aad910bbdb9599272bd96d01a9ec6852f36b9455cf2ca67bd4cc2d23/contourpy-1.3.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:177fb367556747a686509d6fef71d221a4b198a3905fe824430e5ea0fda54eb5", size = 293257, upload-time = "2025-07-26T12:01:39.367Z" }, + { url = "https://files.pythonhosted.org/packages/96/e4/7adcd9c8362745b2210728f209bfbcf7d91ba868a2c5f40d8b58f54c509b/contourpy-1.3.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:d002b6f00d73d69333dac9d0b8d5e84d9724ff9ef044fd63c5986e62b7c9e1b1", size = 274034, upload-time = "2025-07-26T12:01:40.645Z" }, + { url = "https://files.pythonhosted.org/packages/73/23/90e31ceeed1de63058a02cb04b12f2de4b40e3bef5e082a7c18d9c8ae281/contourpy-1.3.3-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:348ac1f5d4f1d66d3322420f01d42e43122f43616e0f194fc1c9f5d830c5b286", size = 334672, upload-time = "2025-07-26T12:01:41.942Z" }, + { url = "https://files.pythonhosted.org/packages/ed/93/b43d8acbe67392e659e1d984700e79eb67e2acb2bd7f62012b583a7f1b55/contourpy-1.3.3-cp313-cp313-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:655456777ff65c2c548b7c454af9c6f33f16c8884f11083244b5819cc214f1b5", size = 381234, upload-time = "2025-07-26T12:01:43.499Z" }, + { url = "https://files.pythonhosted.org/packages/46/3b/bec82a3ea06f66711520f75a40c8fc0b113b2a75edb36aa633eb11c4f50f/contourpy-1.3.3-cp313-cp313-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:644a6853d15b2512d67881586bd03f462c7ab755db95f16f14d7e238f2852c67", size = 385169, upload-time = "2025-07-26T12:01:45.219Z" }, + { url = "https://files.pythonhosted.org/packages/4b/32/e0f13a1c5b0f8572d0ec6ae2f6c677b7991fafd95da523159c19eff0696a/contourpy-1.3.3-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4debd64f124ca62069f313a9cb86656ff087786016d76927ae2cf37846b006c9", size = 362859, upload-time = "2025-07-26T12:01:46.519Z" }, + { url = "https://files.pythonhosted.org/packages/33/71/e2a7945b7de4e58af42d708a219f3b2f4cff7386e6b6ab0a0fa0033c49a9/contourpy-1.3.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a15459b0f4615b00bbd1e91f1b9e19b7e63aea7483d03d804186f278c0af2659", size = 1332062, upload-time = "2025-07-26T12:01:48.964Z" }, + { url = "https://files.pythonhosted.org/packages/12/fc/4e87ac754220ccc0e807284f88e943d6d43b43843614f0a8afa469801db0/contourpy-1.3.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ca0fdcd73925568ca027e0b17ab07aad764be4706d0a925b89227e447d9737b7", size = 1403932, upload-time = "2025-07-26T12:01:51.979Z" }, + { url = "https://files.pythonhosted.org/packages/a6/2e/adc197a37443f934594112222ac1aa7dc9a98faf9c3842884df9a9d8751d/contourpy-1.3.3-cp313-cp313-win32.whl", hash = "sha256:b20c7c9a3bf701366556e1b1984ed2d0cedf999903c51311417cf5f591d8c78d", size = 185024, upload-time = "2025-07-26T12:01:53.245Z" }, + { url = "https://files.pythonhosted.org/packages/18/0b/0098c214843213759692cc638fce7de5c289200a830e5035d1791d7a2338/contourpy-1.3.3-cp313-cp313-win_amd64.whl", hash = "sha256:1cadd8b8969f060ba45ed7c1b714fe69185812ab43bd6b86a9123fe8f99c3263", size = 226578, upload-time = "2025-07-26T12:01:54.422Z" }, + { url = "https://files.pythonhosted.org/packages/8a/9a/2f6024a0c5995243cd63afdeb3651c984f0d2bc727fd98066d40e141ad73/contourpy-1.3.3-cp313-cp313-win_arm64.whl", hash = "sha256:fd914713266421b7536de2bfa8181aa8c699432b6763a0ea64195ebe28bff6a9", size = 193524, upload-time = "2025-07-26T12:01:55.73Z" }, + { url = "https://files.pythonhosted.org/packages/c0/b3/f8a1a86bd3298513f500e5b1f5fd92b69896449f6cab6a146a5d52715479/contourpy-1.3.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:88df9880d507169449d434c293467418b9f6cbe82edd19284aa0409e7fdb933d", size = 306730, upload-time = "2025-07-26T12:01:57.051Z" }, + { url = "https://files.pythonhosted.org/packages/3f/11/4780db94ae62fc0c2053909b65dc3246bd7cecfc4f8a20d957ad43aa4ad8/contourpy-1.3.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:d06bb1f751ba5d417047db62bca3c8fde202b8c11fb50742ab3ab962c81e8216", size = 287897, upload-time = "2025-07-26T12:01:58.663Z" }, + { url = "https://files.pythonhosted.org/packages/ae/15/e59f5f3ffdd6f3d4daa3e47114c53daabcb18574a26c21f03dc9e4e42ff0/contourpy-1.3.3-cp313-cp313t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e4e6b05a45525357e382909a4c1600444e2a45b4795163d3b22669285591c1ae", size = 326751, upload-time = "2025-07-26T12:02:00.343Z" }, + { url = "https://files.pythonhosted.org/packages/0f/81/03b45cfad088e4770b1dcf72ea78d3802d04200009fb364d18a493857210/contourpy-1.3.3-cp313-cp313t-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ab3074b48c4e2cf1a960e6bbeb7f04566bf36b1861d5c9d4d8ac04b82e38ba20", size = 375486, upload-time = "2025-07-26T12:02:02.128Z" }, + { url = "https://files.pythonhosted.org/packages/0c/ba/49923366492ffbdd4486e970d421b289a670ae8cf539c1ea9a09822b371a/contourpy-1.3.3-cp313-cp313t-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:6c3d53c796f8647d6deb1abe867daeb66dcc8a97e8455efa729516b997b8ed99", size = 388106, upload-time = "2025-07-26T12:02:03.615Z" }, + { url = "https://files.pythonhosted.org/packages/9f/52/5b00ea89525f8f143651f9f03a0df371d3cbd2fccd21ca9b768c7a6500c2/contourpy-1.3.3-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:50ed930df7289ff2a8d7afeb9603f8289e5704755c7e5c3bbd929c90c817164b", size = 352548, upload-time = "2025-07-26T12:02:05.165Z" }, + { url = "https://files.pythonhosted.org/packages/32/1d/a209ec1a3a3452d490f6b14dd92e72280c99ae3d1e73da74f8277d4ee08f/contourpy-1.3.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:4feffb6537d64b84877da813a5c30f1422ea5739566abf0bd18065ac040e120a", size = 1322297, upload-time = "2025-07-26T12:02:07.379Z" }, + { url = "https://files.pythonhosted.org/packages/bc/9e/46f0e8ebdd884ca0e8877e46a3f4e633f6c9c8c4f3f6e72be3fe075994aa/contourpy-1.3.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:2b7e9480ffe2b0cd2e787e4df64270e3a0440d9db8dc823312e2c940c167df7e", size = 1391023, upload-time = "2025-07-26T12:02:10.171Z" }, + { url = "https://files.pythonhosted.org/packages/b9/70/f308384a3ae9cd2209e0849f33c913f658d3326900d0ff5d378d6a1422d2/contourpy-1.3.3-cp313-cp313t-win32.whl", hash = "sha256:283edd842a01e3dcd435b1c5116798d661378d83d36d337b8dde1d16a5fc9ba3", size = 196157, upload-time = "2025-07-26T12:02:11.488Z" }, + { url = "https://files.pythonhosted.org/packages/b2/dd/880f890a6663b84d9e34a6f88cded89d78f0091e0045a284427cb6b18521/contourpy-1.3.3-cp313-cp313t-win_amd64.whl", hash = "sha256:87acf5963fc2b34825e5b6b048f40e3635dd547f590b04d2ab317c2619ef7ae8", size = 240570, upload-time = "2025-07-26T12:02:12.754Z" }, + { url = "https://files.pythonhosted.org/packages/80/99/2adc7d8ffead633234817ef8e9a87115c8a11927a94478f6bb3d3f4d4f7d/contourpy-1.3.3-cp313-cp313t-win_arm64.whl", hash = "sha256:3c30273eb2a55024ff31ba7d052dde990d7d8e5450f4bbb6e913558b3d6c2301", size = 199713, upload-time = "2025-07-26T12:02:14.4Z" }, + { url = "https://files.pythonhosted.org/packages/72/8b/4546f3ab60f78c514ffb7d01a0bd743f90de36f0019d1be84d0a708a580a/contourpy-1.3.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:fde6c716d51c04b1c25d0b90364d0be954624a0ee9d60e23e850e8d48353d07a", size = 292189, upload-time = "2025-07-26T12:02:16.095Z" }, + { url = "https://files.pythonhosted.org/packages/fd/e1/3542a9cb596cadd76fcef413f19c79216e002623158befe6daa03dbfa88c/contourpy-1.3.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:cbedb772ed74ff5be440fa8eee9bd49f64f6e3fc09436d9c7d8f1c287b121d77", size = 273251, upload-time = "2025-07-26T12:02:17.524Z" }, + { url = "https://files.pythonhosted.org/packages/b1/71/f93e1e9471d189f79d0ce2497007731c1e6bf9ef6d1d61b911430c3db4e5/contourpy-1.3.3-cp314-cp314-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:22e9b1bd7a9b1d652cd77388465dc358dafcd2e217d35552424aa4f996f524f5", size = 335810, upload-time = "2025-07-26T12:02:18.9Z" }, + { url = "https://files.pythonhosted.org/packages/91/f9/e35f4c1c93f9275d4e38681a80506b5510e9327350c51f8d4a5a724d178c/contourpy-1.3.3-cp314-cp314-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a22738912262aa3e254e4f3cb079a95a67132fc5a063890e224393596902f5a4", size = 382871, upload-time = "2025-07-26T12:02:20.418Z" }, + { url = "https://files.pythonhosted.org/packages/b5/71/47b512f936f66a0a900d81c396a7e60d73419868fba959c61efed7a8ab46/contourpy-1.3.3-cp314-cp314-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:afe5a512f31ee6bd7d0dda52ec9864c984ca3d66664444f2d72e0dc4eb832e36", size = 386264, upload-time = "2025-07-26T12:02:21.916Z" }, + { url = "https://files.pythonhosted.org/packages/04/5f/9ff93450ba96b09c7c2b3f81c94de31c89f92292f1380261bd7195bea4ea/contourpy-1.3.3-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f64836de09927cba6f79dcd00fdd7d5329f3fccc633468507079c829ca4db4e3", size = 363819, upload-time = "2025-07-26T12:02:23.759Z" }, + { url = "https://files.pythonhosted.org/packages/3e/a6/0b185d4cc480ee494945cde102cb0149ae830b5fa17bf855b95f2e70ad13/contourpy-1.3.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:1fd43c3be4c8e5fd6e4f2baeae35ae18176cf2e5cced681cca908addf1cdd53b", size = 1333650, upload-time = "2025-07-26T12:02:26.181Z" }, + { url = "https://files.pythonhosted.org/packages/43/d7/afdc95580ca56f30fbcd3060250f66cedbde69b4547028863abd8aa3b47e/contourpy-1.3.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:6afc576f7b33cf00996e5c1102dc2a8f7cc89e39c0b55df93a0b78c1bd992b36", size = 1404833, upload-time = "2025-07-26T12:02:28.782Z" }, + { url = "https://files.pythonhosted.org/packages/e2/e2/366af18a6d386f41132a48f033cbd2102e9b0cf6345d35ff0826cd984566/contourpy-1.3.3-cp314-cp314-win32.whl", hash = "sha256:66c8a43a4f7b8df8b71ee1840e4211a3c8d93b214b213f590e18a1beca458f7d", size = 189692, upload-time = "2025-07-26T12:02:30.128Z" }, + { url = "https://files.pythonhosted.org/packages/7d/c2/57f54b03d0f22d4044b8afb9ca0e184f8b1afd57b4f735c2fa70883dc601/contourpy-1.3.3-cp314-cp314-win_amd64.whl", hash = "sha256:cf9022ef053f2694e31d630feaacb21ea24224be1c3ad0520b13d844274614fd", size = 232424, upload-time = "2025-07-26T12:02:31.395Z" }, + { url = "https://files.pythonhosted.org/packages/18/79/a9416650df9b525737ab521aa181ccc42d56016d2123ddcb7b58e926a42c/contourpy-1.3.3-cp314-cp314-win_arm64.whl", hash = "sha256:95b181891b4c71de4bb404c6621e7e2390745f887f2a026b2d99e92c17892339", size = 198300, upload-time = "2025-07-26T12:02:32.956Z" }, + { url = "https://files.pythonhosted.org/packages/1f/42/38c159a7d0f2b7b9c04c64ab317042bb6952b713ba875c1681529a2932fe/contourpy-1.3.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:33c82d0138c0a062380332c861387650c82e4cf1747aaa6938b9b6516762e772", size = 306769, upload-time = "2025-07-26T12:02:34.2Z" }, + { url = "https://files.pythonhosted.org/packages/c3/6c/26a8205f24bca10974e77460de68d3d7c63e282e23782f1239f226fcae6f/contourpy-1.3.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ea37e7b45949df430fe649e5de8351c423430046a2af20b1c1961cae3afcda77", size = 287892, upload-time = "2025-07-26T12:02:35.807Z" }, + { url = "https://files.pythonhosted.org/packages/66/06/8a475c8ab718ebfd7925661747dbb3c3ee9c82ac834ccb3570be49d129f4/contourpy-1.3.3-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d304906ecc71672e9c89e87c4675dc5c2645e1f4269a5063b99b0bb29f232d13", size = 326748, upload-time = "2025-07-26T12:02:37.193Z" }, + { url = "https://files.pythonhosted.org/packages/b4/a3/c5ca9f010a44c223f098fccd8b158bb1cb287378a31ac141f04730dc49be/contourpy-1.3.3-cp314-cp314t-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ca658cd1a680a5c9ea96dc61cdbae1e85c8f25849843aa799dfd3cb370ad4fbe", size = 375554, upload-time = "2025-07-26T12:02:38.894Z" }, + { url = "https://files.pythonhosted.org/packages/80/5b/68bd33ae63fac658a4145088c1e894405e07584a316738710b636c6d0333/contourpy-1.3.3-cp314-cp314t-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ab2fd90904c503739a75b7c8c5c01160130ba67944a7b77bbf36ef8054576e7f", size = 388118, upload-time = "2025-07-26T12:02:40.642Z" }, + { url = "https://files.pythonhosted.org/packages/40/52/4c285a6435940ae25d7410a6c36bda5145839bc3f0beb20c707cda18b9d2/contourpy-1.3.3-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b7301b89040075c30e5768810bc96a8e8d78085b47d8be6e4c3f5a0b4ed478a0", size = 352555, upload-time = "2025-07-26T12:02:42.25Z" }, + { url = "https://files.pythonhosted.org/packages/24/ee/3e81e1dd174f5c7fefe50e85d0892de05ca4e26ef1c9a59c2a57e43b865a/contourpy-1.3.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:2a2a8b627d5cc6b7c41a4beff6c5ad5eb848c88255fda4a8745f7e901b32d8e4", size = 1322295, upload-time = "2025-07-26T12:02:44.668Z" }, + { url = "https://files.pythonhosted.org/packages/3c/b2/6d913d4d04e14379de429057cd169e5e00f6c2af3bb13e1710bcbdb5da12/contourpy-1.3.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:fd6ec6be509c787f1caf6b247f0b1ca598bef13f4ddeaa126b7658215529ba0f", size = 1391027, upload-time = "2025-07-26T12:02:47.09Z" }, + { url = "https://files.pythonhosted.org/packages/93/8a/68a4ec5c55a2971213d29a9374913f7e9f18581945a7a31d1a39b5d2dfe5/contourpy-1.3.3-cp314-cp314t-win32.whl", hash = "sha256:e74a9a0f5e3fff48fb5a7f2fd2b9b70a3fe014a67522f79b7cca4c0c7e43c9ae", size = 202428, upload-time = "2025-07-26T12:02:48.691Z" }, + { url = "https://files.pythonhosted.org/packages/fa/96/fd9f641ffedc4fa3ace923af73b9d07e869496c9cc7a459103e6e978992f/contourpy-1.3.3-cp314-cp314t-win_amd64.whl", hash = "sha256:13b68d6a62db8eafaebb8039218921399baf6e47bf85006fd8529f2a08ef33fc", size = 250331, upload-time = "2025-07-26T12:02:50.137Z" }, + { url = "https://files.pythonhosted.org/packages/ae/8c/469afb6465b853afff216f9528ffda78a915ff880ed58813ba4faf4ba0b6/contourpy-1.3.3-cp314-cp314t-win_arm64.whl", hash = "sha256:b7448cb5a725bb1e35ce88771b86fba35ef418952474492cf7c764059933ff8b", size = 203831, upload-time = "2025-07-26T12:02:51.449Z" }, +] + +[[package]] +name = "corner" +version = "2.3.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "matplotlib" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/4f/06/0d045530fa994ab450f6a98b7ad9f74c90a8abf5271d3690f60d1aa933d8/corner-2.3.0.tar.gz", hash = "sha256:685ecb1e778809b78c6783f4a4691d023bbd9f781c9efda683c2b793878b561c", size = 6089474, upload-time = "2026-07-05T17:56:05.355Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d6/cb/17a130e548ee1777f2a66e09240c531a9bf79454add7ef1198fe1e41c412/corner-2.3.0-py3-none-any.whl", hash = "sha256:f93f0a4d77ff6852d6ddc80a6a99038117be64e3b5b49d96a82c9f5974cce126", size = 16954, upload-time = "2026-07-05T17:56:03.827Z" }, +] + +[[package]] +name = "cycler" +version = "0.12.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a9/95/a3dbbb5028f35eafb79008e7522a75244477d2838f38cbb722248dabc2a8/cycler-0.12.1.tar.gz", hash = "sha256:88bb128f02ba341da8ef447245a9e138fae777f6a23943da4540077d3601eb1c", size = 7615, upload-time = "2023-10-07T05:32:18.335Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e7/05/c19819d5e3d95294a6f5947fb9b9629efb316b96de511b418c53d245aae6/cycler-0.12.1-py3-none-any.whl", hash = "sha256:85cef7cff222d8644161529808465972e51340599459b8ac3ccbac5a854e0d30", size = 8321, upload-time = "2023-10-07T05:32:16.783Z" }, +] + +[[package]] +name = "debugpy" +version = "1.8.21" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f2/aa/12037145b7a56eaa5b29b41872f7a21b538e807e13f32c4d3c46e59be084/debugpy-1.8.21.tar.gz", hash = "sha256:a3c53278e84c94e11bd87c53970ec391d1a67396c8b22609fcac576520e611a6", size = 1697577, upload-time = "2026-06-01T19:30:35.156Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a2/df/bf625547431a9cadc9f4cbfeda38866e2b17f6aed147b625377e87834449/debugpy-1.8.21-cp312-cp312-macosx_15_0_universal2.whl", hash = "sha256:9f96713896f39c3dff0ee841f47320c3f2983d33c341e009361bb0ebc79adc4e", size = 2483609, upload-time = "2026-06-01T19:30:50.794Z" }, + { url = "https://files.pythonhosted.org/packages/bf/09/59324b903599031ff9faaec1758292409f6561a0ec2492fe4b703327705a/debugpy-1.8.21-cp312-cp312-manylinux_2_34_x86_64.whl", hash = "sha256:c193d474f0a211191f2b4449d2d06157c689013035bd952f3b617e0ef422b176", size = 3968900, upload-time = "2026-06-01T19:30:52.341Z" }, + { url = "https://files.pythonhosted.org/packages/14/cd/27f65b805d7fe005c44e1a36b9183ecdfbcdbf9d3e721a5115d461ecc7ee/debugpy-1.8.21-cp312-cp312-win32.whl", hash = "sha256:4743373c1cac7f9e74a1b9915bf1dbe0e900eca657ffb170ae07ac8363205ae9", size = 5336340, upload-time = "2026-06-01T19:30:54.047Z" }, + { url = "https://files.pythonhosted.org/packages/77/1d/c84e30c0c674184948b66f076ab271c01d940618a2824c23cd035a27bc20/debugpy-1.8.21-cp312-cp312-win_amd64.whl", hash = "sha256:bd7ba9dd3daa7c2f942c6ca8d4695a16bf9ac16b63615261c7982bc74f7ed20c", size = 5374751, upload-time = "2026-06-01T19:30:55.891Z" }, + { url = "https://files.pythonhosted.org/packages/77/6b/d817e1f8cc77aa055d37fba092e0febfdff40fe652d8d53d4cd7a86ad98d/debugpy-1.8.21-cp313-cp313-macosx_15_0_universal2.whl", hash = "sha256:13678151fc401e2d68c9880b91e28714f797d40422994572b24560ef80910a88", size = 2477398, upload-time = "2026-06-01T19:30:57.644Z" }, + { url = "https://files.pythonhosted.org/packages/48/57/412421516afc3055fa577516f00beec3d663f9b0ab330639547ae6c57720/debugpy-1.8.21-cp313-cp313-manylinux_2_34_x86_64.whl", hash = "sha256:ecbd158386c31ffe71d46f72d44d56e66331ab9b16cad649156d514368f23ab2", size = 3962096, upload-time = "2026-06-01T19:30:59.235Z" }, + { url = "https://files.pythonhosted.org/packages/c1/62/2c616337cf6ba7b07ebbc97f02c6c945a8e2f76b365e33ee809c32ee36d1/debugpy-1.8.21-cp313-cp313-win32.whl", hash = "sha256:2c2ae706dec41d99a9ca1f7ebc987a83e65578363be6f6b3ac9067504917fae1", size = 5336288, upload-time = "2026-06-01T19:31:00.79Z" }, + { url = "https://files.pythonhosted.org/packages/f8/99/9175103392f84c4b1bf7622888cdc68da07f0ff7d9e581266428f6776033/debugpy-1.8.21-cp313-cp313-win_amd64.whl", hash = "sha256:aa648733047443eb1d07682c4ef287d36a54507b643ffdf38b09a3ef002c72a0", size = 5376567, upload-time = "2026-06-01T19:31:02.56Z" }, + { url = "https://files.pythonhosted.org/packages/ce/3d/f4bbb323a548bfab2af3d6b4ffd9bf22636e55956a1285d317a1de643aad/debugpy-1.8.21-cp314-cp314-macosx_15_0_universal2.whl", hash = "sha256:9bb2a685287a2ac9b181cde89edcec64845cb51de7faaa75badb9a698bc24782", size = 2477209, upload-time = "2026-06-01T19:31:04.157Z" }, + { url = "https://files.pythonhosted.org/packages/8c/2d/6e7ec524984a1702777868de49a4c53202bddac2a432a76a093469587750/debugpy-1.8.21-cp314-cp314-manylinux_2_34_x86_64.whl", hash = "sha256:3d6922439bf33fd38a3e2c447869ebc7b97da5cd3d329ff1ef9bc06c4903437e", size = 3927115, upload-time = "2026-06-01T19:31:05.863Z" }, + { url = "https://files.pythonhosted.org/packages/97/47/d1aa6d64005a98a9144647d99306b419396f9ad7bf1d73c119e17a81fb4d/debugpy-1.8.21-cp314-cp314-win32.whl", hash = "sha256:15d4963bd5ffa48f0da0947fd06757fa7621945048a14ad7705431566d3c0e7c", size = 5336724, upload-time = "2026-06-01T19:31:07.711Z" }, + { url = "https://files.pythonhosted.org/packages/5f/67/b905b90d163af11878c1af8abafa4a25206335e112e284e413454543a6da/debugpy-1.8.21-cp314-cp314-win_amd64.whl", hash = "sha256:fe0744a12353406de0ae8ccff0d0a4a666f00801a3db8fd04e7a5f761cd520e8", size = 5373803, upload-time = "2026-06-01T19:31:09.469Z" }, + { url = "https://files.pythonhosted.org/packages/95/51/67e7cf11a53e40694f720457d5b3a1cdaaa3d5a9a633e482f225456b93ff/debugpy-1.8.21-py2.py3-none-any.whl", hash = "sha256:b1e37d333663c8851516a47364ef473da127f9caebe4417e6df6f5825a7e9a92", size = 5352888, upload-time = "2026-06-01T19:31:25.186Z" }, +] + +[[package]] +name = "defusedxml" +version = "0.7.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0f/d5/c66da9b79e5bdb124974bfe172b4daf3c984ebd9c2a06e2b8a4dc7331c72/defusedxml-0.7.1.tar.gz", hash = "sha256:1bb3032db185915b62d7c6209c5a8792be6a32ab2fedacc84e01b52c51aa3e69", size = 75520, upload-time = "2021-03-08T10:59:26.269Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/07/6c/aa3f2f849e01cb6a001cd8554a88d4c77c5c1a31c95bdf1cf9301e6d9ef4/defusedxml-0.7.1-py2.py3-none-any.whl", hash = "sha256:a352e7e428770286cc899e2542b6cdaedb2b4953ff269a210103ec58f6198a61", size = 25604, upload-time = "2021-03-08T10:59:24.45Z" }, +] + +[[package]] +name = "dill" +version = "0.4.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/81/e1/56027a71e31b02ddc53c7d65b01e68edf64dea2932122fe7746a516f75d5/dill-0.4.1.tar.gz", hash = "sha256:423092df4182177d4d8ba8290c8a5b640c66ab35ec7da59ccfa00f6fa3eea5fa", size = 187315, upload-time = "2026-01-19T02:36:56.85Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1e/77/dc8c558f7593132cf8fefec57c4f60c83b16941c574ac5f619abb3ae7933/dill-0.4.1-py3-none-any.whl", hash = "sha256:1e1ce33e978ae97fcfcff5638477032b801c46c7c65cf717f95fbc2248f79a9d", size = 120019, upload-time = "2026-01-19T02:36:55.663Z" }, +] + +[[package]] +name = "docutils" +version = "0.22.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ae/b6/03bb70946330e88ffec97aefd3ea75ba575cb2e762061e0e62a213befee8/docutils-0.22.4.tar.gz", hash = "sha256:4db53b1fde9abecbb74d91230d32ab626d94f6badfc575d6db9194a49df29968", size = 2291750, upload-time = "2025-12-18T19:00:26.443Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/02/10/5da547df7a391dcde17f59520a231527b8571e6f46fc8efb02ccb370ab12/docutils-0.22.4-py3-none-any.whl", hash = "sha256:d0013f540772d1420576855455d050a2180186c91c15779301ac2ccb3eeb68de", size = 633196, upload-time = "2025-12-18T19:00:18.077Z" }, +] + +[[package]] +name = "dynesty" +version = "3.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "matplotlib" }, + { name = "numpy" }, + { name = "scipy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c4/75/db494edc8abfe2273b9cb08c87a2a1165c6ae90d76f746980ef07ec5303a/dynesty-3.1.0.tar.gz", hash = "sha256:851717431f04f749bca45e86704c28fecf9f3b10f85a2a69820b26e42cefab68", size = 35564761, upload-time = "2026-07-17T14:38:31.465Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f1/f9/41c72d0b5fb511fdf23cf62ed50da6c73d4497f03ed1cad04f214dc477c8/dynesty-3.1.0-py3-none-any.whl", hash = "sha256:4e5b77bb261abdcb98e3a538d7498a94d5882a848f0ea46924b404396ef036d5", size = 106027, upload-time = "2026-07-17T14:38:28.523Z" }, +] + +[[package]] +name = "emcee" +version = "3.1.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/cb/53/1045ee878cb24281387079f8ee4f0ade1622c6aae1ed1fd91a53e4fa5b19/emcee-3.1.6.tar.gz", hash = "sha256:11af4daf6ab8f9ca69681e3c29054665db7bbd87fd4eb8e437d2c3a1248c637d", size = 2871117, upload-time = "2024-04-19T10:03:19.555Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f9/ef/2196b9bf88ffa1bde45853c72df021fbd07a8fa91a0f59a22d14a050dc04/emcee-3.1.6-py2.py3-none-any.whl", hash = "sha256:f2d63752023bdccf744461450e512a5b417ae7d28f18e12acd76a33de87580cb", size = 47351, upload-time = "2024-04-19T10:03:17.522Z" }, +] + +[[package]] +name = "equinox" +version = "0.13.8" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jax" }, + { name = "jaxtyping" }, + { name = "typing-extensions" }, + { name = "wadler-lindig" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/19/ff/522336d2f8264f2ad97119710b76e2cddf66145d03a1e89899175d26b192/equinox-0.13.8.tar.gz", hash = "sha256:dd075050018e2dd02e252e9d29d3060f7e67f085622d8d27a8e89e24bb8523db", size = 145257, upload-time = "2026-05-05T10:03:43.258Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ae/d6/69a76c8ccdef14af687c497040292a46e59fc7a0ab24724b60e50ca61030/equinox-0.13.8-py3-none-any.whl", hash = "sha256:ca004348533cc30a63ebe8823d7dd4bb626dce17743d40bbddb89b402ef2a240", size = 185813, upload-time = "2026-05-05T10:03:41.673Z" }, +] + +[[package]] +name = "executing" +version = "2.2.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/cc/28/c14e053b6762b1044f34a13aab6859bbf40456d37d23aa286ac24cfd9a5d/executing-2.2.1.tar.gz", hash = "sha256:3632cc370565f6648cc328b32435bd120a1e4ebb20c77e3fdde9a13cd1e533c4", size = 1129488, upload-time = "2025-09-01T09:48:10.866Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c1/ea/53f2148663b321f21b5a606bd5f191517cf40b7072c0497d3c92c4a13b1e/executing-2.2.1-py2.py3-none-any.whl", hash = "sha256:760643d3452b4d777d295bb167ccc74c64a81df23fb5e08eff250c425a4b2017", size = 28317, upload-time = "2025-09-01T09:48:08.5Z" }, +] + +[[package]] +name = "exfor-tools" +version = "1.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "matplotlib" }, + { name = "numpy" }, + { name = "periodictable" }, + { name = "x4i3" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e1/f1/6cf8211da8144189a8ffae98b43e5ff8dfb52a57395c95aad4281636823c/exfor_tools-1.2.tar.gz", hash = "sha256:e5d601bced1c4d7e9693bb8e71a9937c7057acf71584f2e6de71d0a30ed14bd2", size = 2566320, upload-time = "2026-03-02T16:48:10.999Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0d/9d/a9871c61eb68ee88d0bfc7104ac02f3380d556fa014bc4c16a7e829f9939/exfor_tools-1.2-py3-none-any.whl", hash = "sha256:03f0c9d1e794f3836b4c9c0ac85fa19111cbb7fa44b97e106f9a10abdd2e2fda", size = 25321, upload-time = "2026-03-02T16:48:09.51Z" }, +] + +[[package]] +name = "fastjsonschema" +version = "2.22.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/33/a4/9473c7c3b87009d9c1d74034e4a0f6a35ff0d42dd0f9866d0c3ec4e9217b/fastjsonschema-2.22.2.tar.gz", hash = "sha256:72064e12356a7d6ef02165be2946b9abadbdf238536e07eb587e3dbaa33099cf", size = 385171, upload-time = "2026-08-15T19:47:08.853Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/49/82/2755c7c982086f00d4dab85bc120ec35045a9fc2191893a6ce79afe94443/fastjsonschema-2.22.2-py3-none-any.whl", hash = "sha256:0fb3915616adac85ccfdd737d26be1089845d2019819505b42d39888458f74d4", size = 27413, upload-time = "2026-08-15T19:47:04.406Z" }, +] + +[[package]] +name = "filelock" +version = "4.2.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d8/28/3893324bcadf8f89b1616637468d766af3f625008c0735bf704fdfa86617/filelock-4.2.4.tar.gz", hash = "sha256:c6d8663535e1650ee430507b4ffbac7b464dd64b7647ea0112a9f406499d163d", size = 652444, upload-time = "2026-10-19T01:57:51.001Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e0/1b/5e74289a1878e666bb4b65fe5805a04cafcac2aa5f519ef1ead67ef91c56/filelock-4.2.4-py3-none-any.whl", hash = "sha256:301241438c57936ef93f4243a94f2559022268bfcf9b375a9a72eb0f8db8358e", size = 162475, upload-time = "2026-10-19T01:57:49.419Z" }, +] + +[[package]] +name = "fonttools" +version = "4.65.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/77/51/d63c7e52163ac14393a35bd14bd7c0da95f8f74be5d7cc988092f9965129/fonttools-4.65.0.tar.gz", hash = "sha256:762ba5431358d0dbd4a01982484a1d494fb267e91f974cdcf20b80eab8560f6f", size = 3674467, upload-time = "2026-09-10T15:35:54.955Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/58/db/242fa4fce7f632c5f7ab15585343393b25792510c0c32bd218ad24d59f1c/fonttools-4.65.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:e844a45c9e5ced6536f184cf1a65b5d65e8f7e711993b413e10500a8223622e5", size = 3097120, upload-time = "2026-09-10T15:33:46Z" }, + { url = "https://files.pythonhosted.org/packages/a0/b6/42fa4d373416675f74446421cf0b2badb82a4245c60745f05f424f75c649/fonttools-4.65.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:b30e953de049bf43fc0a63c7d0c44d205c923e4bbf24716aae1518c0e65f977c", size = 2584658, upload-time = "2026-09-10T15:33:48.473Z" }, + { url = "https://files.pythonhosted.org/packages/75/6f/d589b9d62280a846c77a2c383d852c6dcb79ae8aa02bf0fa46c8577af145/fonttools-4.65.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:09c34bdeed8915bfb53bee0c8ed2254dbd8ec69c0014b7f3702f347c049bf358", size = 5425737, upload-time = "2026-09-10T15:33:51.473Z" }, + { url = "https://files.pythonhosted.org/packages/b5/09/de2c0c20a42c18e565a2617932beb08c06697bbdd0d3f62b108262e11583/fonttools-4.65.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:05595385ae99f4b9626cebb973bf171b8fe38a8f40708e6e42abba0ed7537778", size = 5402463, upload-time = "2026-09-10T15:33:54.907Z" }, + { url = "https://files.pythonhosted.org/packages/79/2e/bc0f5c9dce21821454bb5812d3b23410bca33c8bbd5468386d0327aa0cff/fonttools-4.65.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:d95b34dd68fbfc0e4a1740c421597656117f979ed8dc85de66e08f9f9981806e", size = 5362168, upload-time = "2026-09-10T15:33:57.481Z" }, + { url = "https://files.pythonhosted.org/packages/1f/0d/2116763ade7e71e0e5d421babe1785d745be9b3d605bf914792ce1c97f79/fonttools-4.65.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:924d06e6130429168318db71c40174a765ad016fc4b56ca811287e3d7373b3a6", size = 5524117, upload-time = "2026-09-10T15:34:00.021Z" }, + { url = "https://files.pythonhosted.org/packages/e2/5e/f9600553b9f645e3068553831685ff1dab6259536a23b38d2e048de38f17/fonttools-4.65.0-cp312-cp312-win32.whl", hash = "sha256:04f73dd01005752a6e75cf4a8dc6b70dc724d1d4bc34cc89522153f4a2f07680", size = 2432089, upload-time = "2026-09-10T15:34:02.803Z" }, + { url = "https://files.pythonhosted.org/packages/3a/02/e436a6a1863b9862bab9f82d6da33055dd7aa3738017edd902a163525dc2/fonttools-4.65.0-cp312-cp312-win_amd64.whl", hash = "sha256:3b5d9ba89edf778b376e669b879ae33a198bf45cf5a23c3f6514f935cf9d0d9d", size = 2483475, upload-time = "2026-09-10T15:34:05.09Z" }, + { url = "https://files.pythonhosted.org/packages/c4/5c/343a4225e83eb06f82c1d8bf41fc5e5f71eab2f62bc7ca215c764722c0a9/fonttools-4.65.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:8b7bb52817a24731d2e4f4df0e71fdde05e6c806c8f8f1517b015d142fdacfa5", size = 3094663, upload-time = "2026-09-10T15:34:07.235Z" }, + { url = "https://files.pythonhosted.org/packages/9b/c9/49b2401be932741d9218181c08948c96db32eab21ecaaf79283b752e13e7/fonttools-4.65.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e2c21772fcf70325189707b19f346812690bb1b0bd7e207e6ac205244806b303", size = 2584521, upload-time = "2026-09-10T15:34:09.648Z" }, + { url = "https://files.pythonhosted.org/packages/51/c9/48b07e6c5cf44fa56f758a04c3772a66c0e9ba82bbe22077e4076746a62b/fonttools-4.65.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:64c9b26816415b5e3d899e9077109d327b22140fe3c4066644d8cdbad5bb1569", size = 5395399, upload-time = "2026-09-10T15:34:12.38Z" }, + { url = "https://files.pythonhosted.org/packages/fa/2d/5cc5a10c8ed56079d6c2e9e3e5920622529a2ae045c9f47a6055ccb1a319/fonttools-4.65.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:6dd6243f60e2d6160c2966e1e14020dc261ffd741b69a2e4ca8bfd051592e4b7", size = 5376659, upload-time = "2026-09-10T15:34:15.239Z" }, + { url = "https://files.pythonhosted.org/packages/ab/6f/ccf33739d936bb3afa1655a225be7ee5d63d6d3c8b7d0e570bc5a2a7b899/fonttools-4.65.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:834962fd7cf21c58e81ac50a59e6ed2306f9df5e3dd481dad1cd7d2c4c60b773", size = 5336795, upload-time = "2026-09-10T15:34:17.817Z" }, + { url = "https://files.pythonhosted.org/packages/7e/c1/ffd17483f2094f0f4118974295b514b5b82afd4f6e3c80c23f01684e97a6/fonttools-4.65.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:580eb68ff7bd6954a7a76afddd864bfc66eaaf5f5c20dd6ead9186d0055a4ffe", size = 5496530, upload-time = "2026-09-10T15:34:20.241Z" }, + { url = "https://files.pythonhosted.org/packages/b1/19/9aca7712d0676ba5f8d1530ce20478a9bb09cccd0153d56693337379cdcf/fonttools-4.65.0-cp313-cp313-win32.whl", hash = "sha256:7a18b2ffd44249fe84289253197aa65ad4f2de554c0d381f18b1f5939bc6bc60", size = 2430392, upload-time = "2026-09-10T15:34:22.906Z" }, + { url = "https://files.pythonhosted.org/packages/1f/6f/f015dea0f4354e0798751b657cea2dee482914737f88bf1a078349ce92cf/fonttools-4.65.0-cp313-cp313-win_amd64.whl", hash = "sha256:8ae1846b0f192fd485d26a455af19b8f5cf05aff08f9836f533913d8fcea133c", size = 2481620, upload-time = "2026-09-10T15:34:25.816Z" }, + { url = "https://files.pythonhosted.org/packages/64/29/606365ef601668bfebed14cfe3dc72bb7fcd1e23011bbb2833f17fea3065/fonttools-4.65.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:dc87a9f846bec83c3795804f62b4632716d46e3522869a3dd9cd44a5d245b006", size = 3098393, upload-time = "2026-09-10T15:34:28.472Z" }, + { url = "https://files.pythonhosted.org/packages/c7/61/11412939d6b7abf5ac7ce0d61d7f94a0a4fbabc9f1ab0a04fa622e0fc11c/fonttools-4.65.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:aa50dd7b9baf75e2bbd43401fc0d237f7a94a8ad2e0c57ea97160fc631af5eb0", size = 2585766, upload-time = "2026-09-10T15:34:31.207Z" }, + { url = "https://files.pythonhosted.org/packages/db/17/734921d8aee8309801da42590375d32d4d46f771b73373ec9520d5d4220b/fonttools-4.65.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0d2a9892fdb3b7e2d0f4174e3b907d226ff83698249762eeefce08ec5b2de1dd", size = 5380679, upload-time = "2026-09-10T15:34:33.933Z" }, + { url = "https://files.pythonhosted.org/packages/cf/eb/2a4d78d60d978e694cfa04c98e4d8ddbf7f028fd768ddef470bb9da5d69e/fonttools-4.65.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:6d815734e7fede0ad1f233f23f0f191cbe8fc64762ff041e589bc0f78e0b2397", size = 5321833, upload-time = "2026-09-10T15:34:36.295Z" }, + { url = "https://files.pythonhosted.org/packages/d9/ca/1cd48b5c11ef9658732787bf2362e1bf3871dad5945d2f6cc8f675ca769c/fonttools-4.65.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:71e4c67b6196a2f447f46476fd2302604721617f5e0a21b0988bdd87b6bb9687", size = 5320938, upload-time = "2026-09-10T15:34:38.992Z" }, + { url = "https://files.pythonhosted.org/packages/c6/0d/90e6051bded926cccabe9dd0bce3b6ca012f4d5779d61167afbf4989ceb6/fonttools-4.65.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:b11d8a4a0c3ca74bbd4c105b7ef82501945c939e6096d9934ec7d288cdf5aaa9", size = 5451747, upload-time = "2026-09-10T15:34:41.387Z" }, + { url = "https://files.pythonhosted.org/packages/18/74/23e0268e48029ff0752083f69312c49b738163d5af919add9dc4ac81e907/fonttools-4.65.0-cp314-cp314-win32.whl", hash = "sha256:8e44a34d91b3c793879767eb115867ced74d2eb94974e64e72fe9e2eea71cf1a", size = 2434246, upload-time = "2026-09-10T15:34:44.385Z" }, + { url = "https://files.pythonhosted.org/packages/a1/2d/ee69affecd4bc81cb932a213438d4199fb48bf8ca6d664438ccc7f623c2a/fonttools-4.65.0-cp314-cp314-win_amd64.whl", hash = "sha256:0aa8901db22875c831d6a91796549590d7e747da37438f38b69d771b668be445", size = 2486706, upload-time = "2026-09-10T15:34:46.842Z" }, + { url = "https://files.pythonhosted.org/packages/8e/9c/edee5f785198ce3327e1ddeace91c773122d47f086a67e0a84b800f4a940/fonttools-4.65.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:2e4a380ca40d3a5372e31b340f0da0d53b4583aadbb8e41f6a516afa69c509a4", size = 3172027, upload-time = "2026-09-10T15:34:49.269Z" }, + { url = "https://files.pythonhosted.org/packages/9c/c6/252ec9884381089bc30da75978b072593920249de60219817f16cbc9145f/fonttools-4.65.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:661bd91c4be13721408b2d4b67a9b3fa7736713adc9a6c9780c9c60fc7959f90", size = 2619020, upload-time = "2026-09-10T15:34:51.453Z" }, + { url = "https://files.pythonhosted.org/packages/42/79/f71b0d202b8473bb45b07876c08a474de9fe560ed2c0cde642812a81e22a/fonttools-4.65.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:62c5e42c79449def957adf8a9a65a43018efa7e2a6bc6baa3afe955e0d5fb2ab", size = 5545942, upload-time = "2026-09-10T15:34:54.804Z" }, + { url = "https://files.pythonhosted.org/packages/4a/bd/52e1bf33e0aebfe22ecc9a85c634db707c1dd9f6b1b438efeed98c55b959/fonttools-4.65.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:36fca8efc46b5adfca327c666e739fc05b7a7a6ef17840230f81b22f53230f61", size = 5351477, upload-time = "2026-09-10T15:34:57.514Z" }, + { url = "https://files.pythonhosted.org/packages/5c/76/8c6b2ad20beec95cd446f3a8bdc753c7e4a4fd69ef3e66704c0f7c8cb0b5/fonttools-4.65.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8aa1291e4c767abf1b0b79ca2d6895f7c0b661d9d95d03b5791c883a9d1e1f08", size = 5412271, upload-time = "2026-09-10T15:35:00.895Z" }, + { url = "https://files.pythonhosted.org/packages/79/49/fadbf11bbbd2d699d88a5498a0634280206e01e3bd5da9a4e0c504953ce9/fonttools-4.65.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:fcf39949f56911348514b466714efa9118bec3d2be249e1c487263f7cda6edab", size = 5446450, upload-time = "2026-09-10T15:35:03.369Z" }, + { url = "https://files.pythonhosted.org/packages/df/77/5fda646d3a6d5ee26465865c00319cc0925cf484a3b42dd8232d5b39f973/fonttools-4.65.0-cp314-cp314t-win32.whl", hash = "sha256:ffc918702661f1d74d2fbb2f5551036b64f6d2d743139e105289b694bcd16f54", size = 2467858, upload-time = "2026-09-10T15:35:05.744Z" }, + { url = "https://files.pythonhosted.org/packages/ae/0f/afa0f3de70ebe02bba46b32cccb30b1de52624472b14ac2e7cd403d08db9/fonttools-4.65.0-cp314-cp314t-win_amd64.whl", hash = "sha256:5a977e3645dbffaee924209828aa702a215f7ff68bc08010740c10c723787e62", size = 2518248, upload-time = "2026-09-10T15:35:07.846Z" }, + { url = "https://files.pythonhosted.org/packages/86/54/b273cf5712b36a381c13284fbf244e811e1e1d7081aed20f200f0a191ffa/fonttools-4.65.0-cp315-cp315-macosx_10_15_universal2.whl", hash = "sha256:7aa0518b45ff5286ad56f063938db3add3816e899aab58d782b3f9a252523caa", size = 3092770, upload-time = "2026-09-10T15:35:10.868Z" }, + { url = "https://files.pythonhosted.org/packages/36/1d/d3e4511475954d4ec4f3c254e81f0fcc1ade504cb7381eeca48b8c44b8a6/fonttools-4.65.0-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:673e2b3ac4ac8e4f3607d390ecc5a606e5db5c4e88fb4cb2999593efb65afea2", size = 2584364, upload-time = "2026-09-10T15:35:13.54Z" }, + { url = "https://files.pythonhosted.org/packages/e5/3f/7cfaba467bdd1d3d04be21ba7b5bd75c6ca58ba280e0519707ca96a43c4d/fonttools-4.65.0-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7a03cff943b204a90bf3d1c04c97b9509a8aa0ee99e2e544084ca43ad995975b", size = 5377819, upload-time = "2026-09-10T15:35:15.839Z" }, + { url = "https://files.pythonhosted.org/packages/25/17/a68d9b19a97bb2ee37e8098fea50657073df97c7e5392afbe1b9d7c0c581/fonttools-4.65.0-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:41f684ee6212e411196ab054f8308faf6605f154950e6f4686fb8f2103d624b0", size = 5341296, upload-time = "2026-09-10T15:35:18.527Z" }, + { url = "https://files.pythonhosted.org/packages/ad/8d/d744653ed607a241339015d4af6743ca3d85a74a2045a02cc06ea0383c71/fonttools-4.65.0-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:52ea9d2a8385075770db74d5e5718fa80b2222bb4fc62856a377dd2865ca8848", size = 5315310, upload-time = "2026-09-10T15:35:20.853Z" }, + { url = "https://files.pythonhosted.org/packages/f0/c8/1ca6dc69cbaa0e394ff70d9e266777124d3ce3c6433026a6b4de50b890ae/fonttools-4.65.0-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:d0d25027ade65ec46b13c0436e51bcb7c5171a4ea255a5e7a8d0d1d3ab4cffd7", size = 5463840, upload-time = "2026-09-10T15:35:24.022Z" }, + { url = "https://files.pythonhosted.org/packages/07/97/d374df38a14f2ac04ba9ed96bca89d4988e7d63aa5ed85c54fd8f2badd7d/fonttools-4.65.0-cp315-cp315-win32.whl", hash = "sha256:22cb846d35d278235ef3b7e947c6040b2057d72e8305a314f21d5342eca49040", size = 2433149, upload-time = "2026-09-10T15:35:26.59Z" }, + { url = "https://files.pythonhosted.org/packages/62/c5/eb8f7506faf6a70c5a8f2eccbeea3cd826c748a6fd78c7b4b3effb5a3a11/fonttools-4.65.0-cp315-cp315-win_amd64.whl", hash = "sha256:aecc899fdbf9ecbf728f8977977e2e1043ee4d70c257124c8fa4cbcf796fcd83", size = 2485725, upload-time = "2026-09-10T15:35:28.945Z" }, + { url = "https://files.pythonhosted.org/packages/f1/a4/2df0d97514feb8d857d5de854cd8d660d9a7ee1fd081bc98497124f515a8/fonttools-4.65.0-cp315-cp315t-macosx_10_15_universal2.whl", hash = "sha256:6275863dad195ee34b6e0ca3fc61c74096bc37e5d6fb8e049f4d68d65865a2b7", size = 3164065, upload-time = "2026-09-10T15:35:31.197Z" }, + { url = "https://files.pythonhosted.org/packages/15/33/e09661c09e6c8a3b0bd50da0e72918df7576dede31f39c948cc245011434/fonttools-4.65.0-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:d8ffd2f62b402180b0edae8f86a071f583970e2177143117db5cf4c52da60079", size = 2615195, upload-time = "2026-09-10T15:35:33.569Z" }, + { url = "https://files.pythonhosted.org/packages/64/d7/114b05f4193679d0935272220083ec43de7f918b5a777018c5ac5c1ae39e/fonttools-4.65.0-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:830f91327ca83bfc1278e7060068a498938f84d05dc4869675486f84f55d4fe1", size = 5521239, upload-time = "2026-09-10T15:35:36.291Z" }, + { url = "https://files.pythonhosted.org/packages/ba/10/67d615939f859ffe75663a67bca3593966febbcd0109ec72f20f73cbb4cc/fonttools-4.65.0-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:9db2cb95847c18eef74a4ef0fe257a893ae3f4b0395f4866e2f426ab07f3d804", size = 5343802, upload-time = "2026-09-10T15:35:38.82Z" }, + { url = "https://files.pythonhosted.org/packages/d1/06/faa793a806da03acce862fbed353f76026b28103d43860d69be9a6a1f0fd/fonttools-4.65.0-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:be9b9a95ed0af03375e99020e921c4bc6b41fad10e053dea7acad370521a3c46", size = 5388482, upload-time = "2026-09-10T15:35:41.616Z" }, + { url = "https://files.pythonhosted.org/packages/53/d2/eb7258df60e634db60c9a8cd72bc9eaf8dea409d1b1ceec3b9fb49531ad2/fonttools-4.65.0-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:bbd9faf777a9deb6790df4f2b0be611857c45fe86605e840d7154a028d828af7", size = 5435088, upload-time = "2026-09-10T15:35:44.639Z" }, + { url = "https://files.pythonhosted.org/packages/00/6a/58597f16e1265fe9205de3069e338a339e3eef0b1daf049ee08269458091/fonttools-4.65.0-cp315-cp315t-win32.whl", hash = "sha256:c779d838815b91889c95ed64c9be5950ad5a683279f91aeb23384cb757ddc6a3", size = 2464925, upload-time = "2026-09-10T15:35:47.224Z" }, + { url = "https://files.pythonhosted.org/packages/4b/95/122fc172006db747f4968e08c710f52a94f55eb007173b859b3f80b5b810/fonttools-4.65.0-cp315-cp315t-win_amd64.whl", hash = "sha256:d9484b7ee1b49b6b8a0231c849f3983723dec29e3a7366d9b1b02f4036f71944", size = 2513945, upload-time = "2026-09-10T15:35:49.895Z" }, + { url = "https://files.pythonhosted.org/packages/e6/35/f894ceb867118c0261d0f69a9bd516b045a3754238f76c88a49513ac7a83/fonttools-4.65.0-py3-none-any.whl", hash = "sha256:3060b8c1fc2329fa20265b7c138614143ea7c1624e26c5c180c76aeb74deae6f", size = 1196441, upload-time = "2026-09-10T15:35:52.347Z" }, +] + +[[package]] +name = "fqdn" +version = "1.5.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/30/3e/a80a8c077fd798951169626cde3e239adeba7dab75deb3555716415bd9b0/fqdn-1.5.1.tar.gz", hash = "sha256:105ed3677e767fb5ca086a0c1f4bb66ebc3c100be518f0e0d755d9eae164d89f", size = 6015, upload-time = "2021-03-11T07:16:29.08Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cf/58/8acf1b3e91c58313ce5cb67df61001fc9dcd21be4fadb76c1a2d540e09ed/fqdn-1.5.1-py3-none-any.whl", hash = "sha256:3a179af3761e4df6eb2e026ff9e1a3033d3587bf980a0b1b2e1e5d08d7358014", size = 9121, upload-time = "2021-03-11T07:16:28.351Z" }, +] + +[[package]] +name = "fsspec" +version = "2026.9.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/77/cd/9be253869fc42e764de7f3dedd6969af7d44ff9c3375214a3442a6f3fc08/fsspec-2026.9.0.tar.gz", hash = "sha256:0f08147951c8cb31d844c3547d631053b127863b60be04cf06e121333ee0e2fe", size = 333545, upload-time = "2026-09-18T17:50:42.825Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6c/c0/a98505f18594f1bce828bb159cec0fcf9860562f1a2c85913409fc8f3d9e/fsspec-2026.9.0-py3-none-any.whl", hash = "sha256:8dd6e646e99ea382bd85f97a45e6b526a442d79423a7dc673f1e2756d05fcb5f", size = 221738, upload-time = "2026-09-18T17:50:41.341Z" }, +] + +[[package]] +name = "greenlet" +version = "3.5.5" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/0b/d8/7cc97c142388aef03f622e001c572c4f84e9252a439549d483f555771970/greenlet-3.5.5.tar.gz", hash = "sha256:adb4bae02e91a8e863e48b177e4014bdcac8a6b5e047ea1df687a61534b85e6c", size = 207585, upload-time = "2026-08-10T15:09:36.136Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2e/7e/9ecd0285e3153532ae07aeb88063c43c72b4221cf0d4d123b02f3682e3ff/greenlet-3.5.5-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:49520f0c95a48b42cf55414b8e8479beb274ea70431afc33e3f79903c71f4380", size = 295809, upload-time = "2026-08-10T13:25:34.023Z" }, + { url = "https://files.pythonhosted.org/packages/35/73/60e4bbcc89252037b18087f2ec16405d5b2d5be42dde191bbf3667e96102/greenlet-3.5.5-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:55272212cbc5f43d1d723725ab931f1939969b7e9523882ca58b55061769d053", size = 611910, upload-time = "2026-08-10T14:14:35.18Z" }, + { url = "https://files.pythonhosted.org/packages/a4/17/cd5134be659cd4a443e7a61ae670dabec165a814c51162916d637b6dd38e/greenlet-3.5.5-cp312-cp312-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:655bca754a2ef4efcb0eb48a94d3f4593536d0f3d48f8ed44343c01d16a92f95", size = 624198, upload-time = "2026-08-10T14:27:25.229Z" }, + { url = "https://files.pythonhosted.org/packages/78/ac/5c5b959999b6f09c3026b5dfe171575bc3121c5236ce74f495096f25b203/greenlet-3.5.5-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:147b25a42e5ca5be3d42356e8f608b37af715a1c196e9bf9d1627f3341adfe1d", size = 621439, upload-time = "2026-08-10T13:40:49.391Z" }, + { url = "https://files.pythonhosted.org/packages/c8/8b/6acf112ed8aee499f25b4d6949820fb02ac950ff9c1f3d793bd5be0599f2/greenlet-3.5.5-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:27493374cff1d1b7919dc8126547f2aea582737e3046147b434b1e12de56389b", size = 1581342, upload-time = "2026-08-10T14:15:05.653Z" }, + { url = "https://files.pythonhosted.org/packages/b8/d7/734e5f198888876b42d7616ff6644c075baf6b8a2412deadd6b0e1b8b20c/greenlet-3.5.5-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:12e2ee66c2aba86133f10fd99d6a8856c6d351ffb7be0e4d52ef2cc5fbb705b2", size = 1645744, upload-time = "2026-08-10T13:40:30.353Z" }, + { url = "https://files.pythonhosted.org/packages/de/30/1f42b88dc587b5899ee50616ad56ee40cafaf225df4fb829f10183c62a5c/greenlet-3.5.5-cp312-cp312-win_amd64.whl", hash = "sha256:49ddacd36af37735fab103846f4ee4d18a492dde72730d1699c0c8ebe30d9f18", size = 324171, upload-time = "2026-08-10T13:28:44.472Z" }, + { url = "https://files.pythonhosted.org/packages/76/e5/4dee4d8d2e603fe5fdd7b444e63219f7b9bd852c60c6214511c7157cbe88/greenlet-3.5.5-cp312-cp312-win_arm64.whl", hash = "sha256:5f1b1ff4828cdc1aba4266aff814085d04a1d07959287219af021b838b265d52", size = 308362, upload-time = "2026-08-10T13:26:46.839Z" }, + { url = "https://files.pythonhosted.org/packages/fb/3d/8cef5f724ec0d4add2af8961d504535ec60c3cca9e464f6d03bdba29d85b/greenlet-3.5.5-cp313-cp313-macosx_11_0_universal2.whl", hash = "sha256:b79fd2a5bc099b5e744f34c4c9a58954a5f4cb7529fb4b6e8446057d61b6edaa", size = 294730, upload-time = "2026-08-10T13:27:51.206Z" }, + { url = "https://files.pythonhosted.org/packages/88/4b/8e7aa3f514273aecff30a16ab1bac09ff54cfc7e6860fdd8058c37ff2499/greenlet-3.5.5-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:634cf15a233a949136879dd388e25d3296e16f3f1e217d2456797b8579ebc6ed", size = 614536, upload-time = "2026-08-10T14:14:36.589Z" }, + { url = "https://files.pythonhosted.org/packages/85/48/4e95e9dd5a8a397dc6a6345dd7f1935113d0fca4f85e89d3976da9cd988d/greenlet-3.5.5-cp313-cp313-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:499adea519f748407fc6806d20eedabac2884fd73b9f38d81236e190ba20dfef", size = 626924, upload-time = "2026-08-10T14:27:27.048Z" }, + { url = "https://files.pythonhosted.org/packages/89/5d/398a1c71fa7a277deeb376c999979de6786f08fc2d5747a0b9d6e11738dd/greenlet-3.5.5-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2eabb980975cba5b93a95f6f69287d05fc05ac955bfd6a320a7c083eeb52c0b0", size = 623906, upload-time = "2026-08-10T13:40:50.501Z" }, + { url = "https://files.pythonhosted.org/packages/04/1b/745450fc5ea9e0cb17d840d248f284db3363de736d362c7d2d883e3eadba/greenlet-3.5.5-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:03115c2e0a371999bf8ae616aa8d653f96641d4705c457aebaa187276e9f7537", size = 1581430, upload-time = "2026-08-10T14:15:06.853Z" }, + { url = "https://files.pythonhosted.org/packages/d4/29/d51b296e3191bb15d3d81ec375af1909e4466c0f395d744ed475801798a9/greenlet-3.5.5-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4441153ffba21b90d3ca89fe3d31f5c093ae6c0bf0cfdfc98f54cde22f95b62e", size = 1645684, upload-time = "2026-08-10T13:40:32.133Z" }, + { url = "https://files.pythonhosted.org/packages/12/63/369f1a1625e64e9e31df3963c6044056e3fdfa3fa3fdba3c54ffefa6e987/greenlet-3.5.5-cp313-cp313-win_amd64.whl", hash = "sha256:95c5b1f4b3a193f8a0c2de4bfdcb48d119f7f1063941f1de1f2168051b3e52dd", size = 324075, upload-time = "2026-08-10T13:26:58.974Z" }, + { url = "https://files.pythonhosted.org/packages/45/78/649cb5c09d4d81f6dd1444e75474a7206784743283a21d24171562ac4899/greenlet-3.5.5-cp313-cp313-win_arm64.whl", hash = "sha256:1af90aa4bc129883b340cdd6957a3bc74f60528a4993bbd1f53aaebe1d9981cc", size = 308260, upload-time = "2026-08-10T13:27:50.795Z" }, + { url = "https://files.pythonhosted.org/packages/7f/8c/080e881fa2be95ff1ddbd6994b2bab3b1a78df3b3fcab39306011764fcc7/greenlet-3.5.5-cp314-cp314-macosx_11_0_universal2.whl", hash = "sha256:d4a389a852e392a6366058651a20fa5ba40d979865aa81bea2ccbdc44805070d", size = 295309, upload-time = "2026-08-10T13:26:03.032Z" }, + { url = "https://files.pythonhosted.org/packages/25/cc/0ac614e6586c0e42d4cc281a5819150f4f43685744a4c5ff77139286409d/greenlet-3.5.5-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:70b157cd319873e8b544ddc2de158f55bbd0a9b0218c8ce9332039801518e328", size = 661185, upload-time = "2026-08-10T14:14:37.867Z" }, + { url = "https://files.pythonhosted.org/packages/5e/b9/6808725354be8ad305dfe5172377664fc9642d4fc043be246b3314cf4482/greenlet-3.5.5-cp314-cp314-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8bdfd1424abcf26832961e766570cae79efdb9599d709088c9cb6ef82b194926", size = 673419, upload-time = "2026-08-10T14:27:28.652Z" }, + { url = "https://files.pythonhosted.org/packages/42/2e/40c509967da7f254680826a2fa0dd22138ec79946c70b97542d74cde8b43/greenlet-3.5.5-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:182de51c6b572a705f2fafaab2e783bcf7d2760940229dfe73086cbae037af3e", size = 670822, upload-time = "2026-08-10T13:40:51.833Z" }, + { url = "https://files.pythonhosted.org/packages/2d/22/c3c2eee4a8fe191d6d1d183086c56133d646024e3d70bfd414829f64560b/greenlet-3.5.5-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:8fec3f165dfe332e490c3247c0f6c23b0bfc45f06496ad7f00ddb00e3d35e4dc", size = 1628469, upload-time = "2026-08-10T14:15:08.11Z" }, + { url = "https://files.pythonhosted.org/packages/f7/87/25babd09b94cb1f03e71db815fde463f0262e40cfbd953d58a8d77311351/greenlet-3.5.5-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:c6ce25fee6cabc8bf22cb8b52e642cbb821be5b9aec8094d07ff03378141b8e9", size = 1691952, upload-time = "2026-08-10T13:40:33.502Z" }, + { url = "https://files.pythonhosted.org/packages/2e/3d/5cc9701117ea4dc0eb7bf1f4f9b7888a6e2e5277ddfae095805ace50f2b6/greenlet-3.5.5-cp314-cp314-win_amd64.whl", hash = "sha256:7dffc5c859fe6059974df1e37d7923d654a83e2ae18fdd616994270e001115e1", size = 327458, upload-time = "2026-08-10T13:27:02.868Z" }, + { url = "https://files.pythonhosted.org/packages/a7/6b/594fa2de7fae7629168a404a4305d7d7e31a5742c50a801b1839543cb93d/greenlet-3.5.5-cp314-cp314-win_arm64.whl", hash = "sha256:5e2afcfc4d4305dd715809b03da5cbe437c8984f61d8917751eb5fe4aefa3e07", size = 311146, upload-time = "2026-08-10T13:27:25.046Z" }, + { url = "https://files.pythonhosted.org/packages/24/e0/50cd600b469e5734c72709b6b1838b6bc63f307b573c772c3132d6ecfe92/greenlet-3.5.5-cp314-cp314t-macosx_11_0_universal2.whl", hash = "sha256:0e5a7de979d764aea1f5b6e95cf92b5b37741b9823702041f34b126e7f690277", size = 305471, upload-time = "2026-08-10T13:26:20.568Z" }, + { url = "https://files.pythonhosted.org/packages/75/a3/77acd66dfc6387b5219b2080806c0cabb73c10eb1bb44b413c40a62015ba/greenlet-3.5.5-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fef01bd457f11fc158b130ca0027a3c365693280e8e231b65bdaf57999f39f5b", size = 672470, upload-time = "2026-08-10T14:14:39.058Z" }, + { url = "https://files.pythonhosted.org/packages/b9/71/0d178142dca3ec19f46fb2212ae73d30ad53b9d548dc64804086033a7089/greenlet-3.5.5-cp314-cp314t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5173a72310725a74afc82c164f0e52cb8ad0de62f2bb623f24f6c0cc07d80272", size = 679973, upload-time = "2026-08-10T14:27:30.072Z" }, + { url = "https://files.pythonhosted.org/packages/6e/31/46eb8567302eaf787abf88d09df014e14ae3baf460af1b8b0efdbd3efcd5/greenlet-3.5.5-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:44f08341873200ba8a60a8bc14ace3d91f1754f7fa7bc66157714a8cd420a476", size = 676634, upload-time = "2026-08-10T13:40:53.004Z" }, + { url = "https://files.pythonhosted.org/packages/a3/e9/b88bbf5b29970cb84172dc2c32aa3e5e579ceb94c808e81c826454138850/greenlet-3.5.5-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:d246c0db9a2513cd45f019ba178ea4d4d4705bd210ee465e2c15d76a1ab13874", size = 1637320, upload-time = "2026-08-10T14:15:09.317Z" }, + { url = "https://files.pythonhosted.org/packages/6d/8c/7631ed29cc6f0392f11830076e172ce4885e70b0bc2c1bce1731176d4b4e/greenlet-3.5.5-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:72507285b5caa1d17904a3f7c322ca780823a54170a0e04ec3f37bcc60d4db71", size = 1697412, upload-time = "2026-08-10T13:40:34.924Z" }, + { url = "https://files.pythonhosted.org/packages/da/0f/f7dd935f9c4cb1be49098770587f54d8a78518e55c89bce86c4fb4109057/greenlet-3.5.5-cp314-cp314t-win_amd64.whl", hash = "sha256:7805655781fb8f28a55d05fe57ed61f5f10f1892fb587673e3bb5264f28041f0", size = 331514, upload-time = "2026-08-10T13:29:20.611Z" }, + { url = "https://files.pythonhosted.org/packages/b7/e5/681b01f8fbc1b55232822f99e8f8afeb78a55a7c76a7bf9dbdc7ccb03a6d/greenlet-3.5.5-cp315-cp315-macosx_11_0_universal2.whl", hash = "sha256:c0db80fcd5b8aece93f66c64f78a786bbb6b96c5fe63ef5a5a4581ecf8bab206", size = 295975, upload-time = "2026-08-10T13:28:45.985Z" }, + { url = "https://files.pythonhosted.org/packages/11/f2/69b488cd9e7267bf4b0fe8cdebf25d8d6df680d21bdf41150d23e23d6652/greenlet-3.5.5-cp315-cp315-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b241c32f912ada659808d68e308c568baf577eebf757d15471472de0c18cfad", size = 666823, upload-time = "2026-08-10T14:14:40.222Z" }, + { url = "https://files.pythonhosted.org/packages/84/d4/d5bc2fdebbdda0c94555925ba79948b8395d75a7f6a36cc85dce5bab9f11/greenlet-3.5.5-cp315-cp315-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ef6a08349401d8eaf3cb12688ac8557de95788556b8631ef17555a4a173022c0", size = 677613, upload-time = "2026-08-10T14:27:31.543Z" }, + { url = "https://files.pythonhosted.org/packages/bd/93/542d8a3a90f3b35c6ad8bf7e56a03010287f2cafa289a5b7985b5207db39/greenlet-3.5.5-cp315-cp315-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f2e3d061b8e13aec2f0441689b3c71b244a20e5d274a52cb0f7e31bd1d139552", size = 675930, upload-time = "2026-08-10T13:40:54.205Z" }, + { url = "https://files.pythonhosted.org/packages/52/b5/89c9f2e8460d71101037d47a1feed11928615a5edd42370be290e0657eeb/greenlet-3.5.5-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:9ab5f5b93655e77fe0d6c2dfd22b5eac751bb1f876d8ec21761b7c1fb9266007", size = 1633878, upload-time = "2026-08-10T14:15:10.693Z" }, + { url = "https://files.pythonhosted.org/packages/b8/60/297de93f3b02ac78a5e04d32bb8bbe3080f4a73d8ed95016561463b70618/greenlet-3.5.5-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:f0e5a21bd4452a88cf032fc43c4a5b307ab1380eacb63b5988f9c0317885e773", size = 1696597, upload-time = "2026-08-10T13:40:36.252Z" }, + { url = "https://files.pythonhosted.org/packages/18/25/54c6eaff4f337fb670215e89eb2d00d9499487b658e709d4b477be4a342e/greenlet-3.5.5-cp315-cp315-win_amd64.whl", hash = "sha256:469dbb0a78625642f4a626cfd0c6e8bccc0385b5e49189b6308bbe849ec88a8e", size = 327700, upload-time = "2026-08-10T13:28:06.752Z" }, + { url = "https://files.pythonhosted.org/packages/67/67/857e88a36301caa0e029870132c2478bd55d896630321432afab03a3115f/greenlet-3.5.5-cp315-cp315-win_arm64.whl", hash = "sha256:2d57406c3efd32d7a81e17a674314e8bd00792cdab49ea3228a49aa1bfb2e769", size = 311750, upload-time = "2026-08-10T13:34:08.815Z" }, + { url = "https://files.pythonhosted.org/packages/10/e2/3144c0a116067ac1e30457b0139a94d60d1d36a86e015de68e9ac87cb3bc/greenlet-3.5.5-cp315-cp315t-macosx_11_0_universal2.whl", hash = "sha256:68184dfcf50ccaa8e864770fe0633a7e27250ea9329f8192ef47ee9ecfd78e1c", size = 306387, upload-time = "2026-08-10T13:27:00.897Z" }, + { url = "https://files.pythonhosted.org/packages/5c/a1/cb4223a7e9b9f43b8807e8eb212358bfe2dfaa174a9ea2889eb1714dcba2/greenlet-3.5.5-cp315-cp315t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9ec0dc0e59dc9c61af5c47348365ccbbd7addfafe0a93b00336ff3da2907bdc6", size = 676472, upload-time = "2026-08-10T14:14:41.417Z" }, + { url = "https://files.pythonhosted.org/packages/9e/cd/a154b4498e5d8f12ada291cfb3b8d596eadde2177f5bf09a9be699d2a446/greenlet-3.5.5-cp315-cp315t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e604f58e35833fc46ef20302bcb314dddbfd3fcf33a4f936216d51dd678d63ae", size = 684238, upload-time = "2026-08-10T14:27:32.946Z" }, + { url = "https://files.pythonhosted.org/packages/bf/bb/b0031d260c2968a3c87deebc51d80c64e499377f993aafe06ee3b7488cc2/greenlet-3.5.5-cp315-cp315t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:40239b5384f96da3963585cc6d7eaa9b56f8ae67e8d92cc82dd9e202fc847de3", size = 681246, upload-time = "2026-08-10T13:40:55.402Z" }, + { url = "https://files.pythonhosted.org/packages/9a/07/da554b71ab88e649da146e1065d86a48a5c5d92e50ab74ef41b504aa7f56/greenlet-3.5.5-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:a1eaccf5c3a1d3e46dead602c72e6836731e8e245c9de6a27764567b6b62d4c0", size = 1642735, upload-time = "2026-08-10T14:15:11.92Z" }, + { url = "https://files.pythonhosted.org/packages/78/76/26a3782a051677668af9d92beaa47cd87ba9dd5072f762961144a03dd4c6/greenlet-3.5.5-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:19e4e026fe20691f333b8eb1a3bc9625eceba8c3f9d62ec5a6f8581afbc6b5a5", size = 1700925, upload-time = "2026-08-10T13:40:37.656Z" }, + { url = "https://files.pythonhosted.org/packages/28/d9/fe7baf4190c2ae71f267efb9de21b3172bb35bc0ed1ef53dd6027d658e33/greenlet-3.5.5-cp315-cp315t-win_amd64.whl", hash = "sha256:712aee154f648bde84634654bb38bb78c69ac640c37a45c9effed800735049d8", size = 331829, upload-time = "2026-08-10T13:26:48.851Z" }, + { url = "https://files.pythonhosted.org/packages/df/af/419a4e383bd600858a9b67e9b280a60fdc383ee3f2fe5b6c0c1ef04e74d1/greenlet-3.5.5-cp315-cp315t-win_arm64.whl", hash = "sha256:7f049911ee81a16a03c33d5450d8d5867d27f596ca5fb201b86f4524e874468b", size = 315093, upload-time = "2026-08-10T13:29:34.949Z" }, +] + +[[package]] +name = "h11" +version = "0.16.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250, upload-time = "2025-04-24T03:35:25.427Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" }, +] + +[[package]] +name = "httpcore" +version = "1.0.9" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "certifi" }, + { name = "h11" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484, upload-time = "2025-04-24T22:06:22.219Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784, upload-time = "2025-04-24T22:06:20.566Z" }, +] + +[[package]] +name = "httpx" +version = "0.28.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "certifi" }, + { name = "httpcore" }, + { name = "idna" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406, upload-time = "2024-12-06T15:37:23.222Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" }, +] + +[[package]] +name = "idna" +version = "3.19" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/5f/f7/abb373e5757eaec4b922b92f97ec8d6d7e057cf06778247604fbc4e7c3f3/idna-3.19.tar.gz", hash = "sha256:5e0811a4383b21dc5838069f801c4fb62113b7447663d2530d2bd6e77b49bf15", size = 215237, upload-time = "2026-08-18T05:14:24.27Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/57/b0/0e52c878c53f245edd3a11020f20979b3f490f245af532c7cae3027754b5/idna-3.19-py3-none-any.whl", hash = "sha256:815e7be7a7806d54abb586dc943addc79e8b2ee16915059658cbeff4b1b43bf4", size = 68550, upload-time = "2026-08-18T05:14:22.343Z" }, +] + +[[package]] +name = "imagesize" +version = "2.0.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/fb/5e/513ff06670c84e7b9887c1fdf61b2d42b4f574a831f2f1d2222023049d8a/imagesize-2.0.1.tar.gz", hash = "sha256:b2ba6a4dea487a7ebcd53248d3476aca449d30db12a2dde5e0c5ca9624fd77e5", size = 1883774, upload-time = "2026-08-24T12:35:19.13Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/01/f9/575c8d760eae1fc99651b7cc5efd96ad5379ca4d6b53750b0fb4fe983f34/imagesize-2.0.1-py3-none-any.whl", hash = "sha256:ea0c9a0384df69ed86a943a15cde37d0360b82491b3910dc2215e202e62b5b02", size = 14794, upload-time = "2026-08-24T12:35:12.548Z" }, +] + +[[package]] +name = "importlib-metadata" +version = "9.0.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "zipp" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/6f/7e/1e7e8dc30634b93ebb3d58a3dea569ad146e656218d3960ab04f62047b29/importlib_metadata-9.0.1.tar.gz", hash = "sha256:ab830580bc0ef3db61ce8fae716389e5462b67e033018bab6d8f80ef17172f99", size = 59124, upload-time = "2026-08-28T15:30:34.646Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b3/55/ecca97ae19075f1fac62def77731e7f535e6c1fb8f92ff08160c5e6dade8/importlib_metadata-9.0.1-py3-none-any.whl", hash = "sha256:bba5600596a7e21f3eef53281cf28d6a5195634d2f2b78ff9501a3272c6eaab0", size = 27920, upload-time = "2026-08-28T15:30:33.433Z" }, +] + +[[package]] +name = "iniconfig" +version = "2.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" }, +] + +[[package]] +name = "ipykernel" +version = "7.3.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "appnope", marker = "sys_platform == 'darwin'" }, + { name = "comm" }, + { name = "debugpy" }, + { name = "ipython" }, + { name = "jupyter-client" }, + { name = "jupyter-core" }, + { name = "matplotlib-inline" }, + { name = "nest-asyncio2" }, + { name = "packaging" }, + { name = "psutil" }, + { name = "pyzmq" }, + { name = "tornado" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/3d/c4/e4a38f579de4225a561305666f7541cdabb30075def2aa1ac17bd73c1fb5/ipykernel-7.3.0.tar.gz", hash = "sha256:9acaaaf97d16355166e4085afe9d225bfbdf2b7ef520f9df3be8f2b248275e09", size = 184899, upload-time = "2026-06-10T08:41:25.481Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3d/02/77b271f5dc58bfbc0b577c877b2365d1ffea2afe66a80c13f2312820348c/ipykernel-7.3.0-py3-none-any.whl", hash = "sha256:897eb64da762549ef610698fca5e9675195ec6ac8ec7f19d81ce1ca20c876057", size = 120583, upload-time = "2026-06-10T08:41:23.648Z" }, +] + +[[package]] +name = "ipython" +version = "9.17.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "ipython-pygments-lexers" }, + { name = "jedi" }, + { name = "matplotlib-inline" }, + { name = "pexpect", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" }, + { name = "prompt-toolkit" }, + { name = "psutil", marker = "sys_platform != 'cygwin' and sys_platform != 'emscripten'" }, + { name = "pygments" }, + { name = "stack-data" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b9/32/99451b1283ec5d92ad77073f12e1c667dc10775384d8f15c2914207149dd/ipython-9.17.1.tar.gz", hash = "sha256:8919be8c27f20a6f4423145028063f6637b42a03ce57665bb12015ee1f073529", size = 4539289, upload-time = "2026-09-01T08:29:32.6Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2d/1e/65b59cf518c106aa755e7f7da3099027738687a862ec785060702a481320/ipython-9.17.1-py3-none-any.whl", hash = "sha256:6d1645743cfd1a07eb695d85aa2b5fa66721f8cbae9431d4049f7084bbf06509", size = 639038, upload-time = "2026-09-01T08:29:30.673Z" }, +] + +[[package]] +name = "ipython-pygments-lexers" +version = "1.1.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pygments" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ef/4c/5dd1d8af08107f88c7f741ead7a40854b8ac24ddf9ae850afbcf698aa552/ipython_pygments_lexers-1.1.1.tar.gz", hash = "sha256:09c0138009e56b6854f9535736f4171d855c8c08a563a0dcd8022f78355c7e81", size = 8393, upload-time = "2025-01-17T11:24:34.505Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d9/33/1f075bf72b0b747cb3288d011319aaf64083cf2efef8354174e3ed4540e2/ipython_pygments_lexers-1.1.1-py3-none-any.whl", hash = "sha256:a9462224a505ade19a605f71f8fa63c2048833ce50abc86768a0d81d876dc81c", size = 8074, upload-time = "2025-01-17T11:24:33.271Z" }, +] + +[[package]] +name = "ipywidgets" +version = "8.1.9" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "comm" }, + { name = "ipython" }, + { name = "jupyterlab-widgets" }, + { name = "traitlets" }, + { name = "widgetsnbextension" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c9/7c/6db60eddf38547353b06d57941f5eee22a990640ce30479fd71a810507f2/ipywidgets-8.1.9.tar.gz", hash = "sha256:bcccba38a6ec3253f7a39c943cea5b9ad01999ce071396171adbc51c6a6a8613", size = 117252, upload-time = "2026-08-18T08:54:24.123Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c3/55/298e9b3b864a198234997e87a1471c1b17d7f3546ace6d18fb5cf1ce24b2/ipywidgets-8.1.9-py3-none-any.whl", hash = "sha256:f2b8cbcaae10252b809fbe4d7470db75c09b769a32cbf816d20e5ca6d3c5a79d", size = 140101, upload-time = "2026-08-18T08:54:22.339Z" }, +] + +[[package]] +name = "isoduration" +version = "20.11.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "arrow" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/7c/1a/3c8edc664e06e6bd06cce40c6b22da5f1429aa4224d0c590f3be21c91ead/isoduration-20.11.0.tar.gz", hash = "sha256:ac2f9015137935279eac671f94f89eb00584f940f5dc49462a0c4ee692ba1bd9", size = 11649, upload-time = "2020-11-01T11:00:00.312Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7b/55/e5326141505c5d5e34c5e0935d2908a74e4561eca44108fbfb9c13d2911a/isoduration-20.11.0-py3-none-any.whl", hash = "sha256:b2904c2a4228c3d44f409c8ae8e2370eb21a26f7ac2ec5446df141dde3452042", size = 11321, upload-time = "2020-11-01T10:59:58.02Z" }, +] + +[[package]] +name = "isort" +version = "9.0.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "mypy-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e6/43/067e17bfa10b6486b408d5294105ac894149a9abb94b338568b1f53a73c9/isort-9.0.1.tar.gz", hash = "sha256:ba23db109e3e93ef1999f7209a651214994cd807801addd16ac485982eb4edd7", size = 667724, upload-time = "2026-08-27T20:54:26.699Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b1/bd/7221ab6fa6912487953334a9953dcc11816f8568e8d1fec07cda0bc01d87/isort-9.0.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:c3ce022ccedf63aa5fc77bd0e926b8561a1476c9709d7cedf63abd7967772aac", size = 1045272, upload-time = "2026-08-27T20:53:42.378Z" }, + { url = "https://files.pythonhosted.org/packages/65/3e/ef6f9247dd0b7faad0450883808c94b94f22fc254524b5b05b5c6c4f94b2/isort-9.0.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7a75d4c21d8b93345a2743b96cc75c6f085aa89ddbaadd6edd5e9765be12ab77", size = 1659645, upload-time = "2026-08-27T20:53:44.087Z" }, + { url = "https://files.pythonhosted.org/packages/49/16/4f791073e6f91f8e9442ed7eb370886a0f0a52c9dadba540fcd24b4c2074/isort-9.0.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:f6877ed17054eae153d686270678b11c1f6cb79433a1c07453140cccbaf7cc1d", size = 1649411, upload-time = "2026-08-27T20:53:45.597Z" }, + { url = "https://files.pythonhosted.org/packages/1f/17/28a06514565129fbb225138045323fb2876aaf871cf77f5976e62e5624bc/isort-9.0.1-cp312-cp312-win_amd64.whl", hash = "sha256:182918b730772292d33564a6ac5b201ca2bb79a8ad2ac77e7681ecc0f19a8f84", size = 871297, upload-time = "2026-08-27T20:53:47.24Z" }, + { url = "https://files.pythonhosted.org/packages/e1/65/aba682b6d0853de85f5bb5c18f0269d2980760783f5144dfcded6b8a1f14/isort-9.0.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:67680927f739d4b48d67d8b7430faa92c95b02fb6075ca0351c6446214f6c7bb", size = 1021693, upload-time = "2026-08-27T20:53:48.792Z" }, + { url = "https://files.pythonhosted.org/packages/d7/bb/7025f3606b42f7db084fa234d61462a73443af166ecf7c1a0e8e3b448433/isort-9.0.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3727eb33a9759649346481cf2a9287d656a170c31ed7c105856f9c6f5b539756", size = 1648575, upload-time = "2026-08-27T20:53:50.701Z" }, + { url = "https://files.pythonhosted.org/packages/47/78/a92b09507565f8bd27eb72a7df3ba59a1ea0a5baacbf155c587d0be51a13/isort-9.0.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:466b0c3f156a21c10edefba697e641666bc26ffb0122bf08b42caa3d464c20aa", size = 1639624, upload-time = "2026-08-27T20:53:52.22Z" }, + { url = "https://files.pythonhosted.org/packages/52/ba/f5efd28563bc751792a7a1f64ae73db57dcbfa0563dc3e0cbbd825a48252/isort-9.0.1-cp313-cp313-pyemscripten_2025_0_wasm32.whl", hash = "sha256:5832683294dd61c59d00cd043a68d42f6ecd7dc7d04b73ac777f7f90a534d6ae", size = 457708, upload-time = "2026-08-27T20:53:53.837Z" }, + { url = "https://files.pythonhosted.org/packages/53/d6/a776ea214de5403f038b182e1d5fd2211d0cee41f2c62ac9f2f9a0ecc463/isort-9.0.1-cp313-cp313-win_amd64.whl", hash = "sha256:7281cdf538f682b8d75fa44bcdad1b299036bbc440855f7d61412b3b85d5727d", size = 874790, upload-time = "2026-08-27T20:53:56.154Z" }, + { url = "https://files.pythonhosted.org/packages/db/42/d75a674a7fcbbf4374cd358b8529535d3c59e0ab6acc164b6862acb95058/isort-9.0.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:7ea5f505b152fedd2b990b39d8b76108a48b355da874025aad4982e8ceeb0f3d", size = 1020950, upload-time = "2026-08-27T20:53:57.744Z" }, + { url = "https://files.pythonhosted.org/packages/2b/b6/04d74c7c42b9af1c0d47f34a79722dbbcff71bae3765c9250376ebd44ec5/isort-9.0.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:873cf1b6371d41e2a74d57d7c0176d311822f0415441abf8251ad074c9fe4a66", size = 1653678, upload-time = "2026-08-27T20:53:59.292Z" }, + { url = "https://files.pythonhosted.org/packages/53/6c/621969c0cde272b7a183484589cc9f28132775d78fd708c231fd292c7abd/isort-9.0.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:99b7bc28b1f05f7e3267629043a99c6c479a750df3689327a10324e396827f94", size = 1645589, upload-time = "2026-08-27T20:54:00.911Z" }, + { url = "https://files.pythonhosted.org/packages/8c/26/e3db1ae5d5fbe9e2dff0c6a0b2b9dda07a742ede20f8fbc7d78d5d73f472/isort-9.0.1-cp314-cp314-pyemscripten_2026_0_wasm32.whl", hash = "sha256:89ebbcdbdd9d66cc14909bbac36acb9db29f37325606113c9f270242f8a1f896", size = 457029, upload-time = "2026-08-27T20:54:02.551Z" }, + { url = "https://files.pythonhosted.org/packages/b8/f2/b9cf816c8dfd5d9066b65a2f738f8d03fb0f6001bcffa3d436cfdbe1b421/isort-9.0.1-cp314-cp314-win_amd64.whl", hash = "sha256:2057236a764f31c78dac78f7343057621fcc2fd40461ce61061f34fd09066f46", size = 894580, upload-time = "2026-08-27T20:54:03.985Z" }, + { url = "https://files.pythonhosted.org/packages/9b/d7/e5e9e477ff7ec9f75b4c07b25aef10814775200c1e90bc9acbb788def54a/isort-9.0.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:5e72a7063570f1d740f0284c7ae5739dc34c6a2d9f1049b13027a5bdadb56682", size = 1088685, upload-time = "2026-08-27T20:54:05.376Z" }, + { url = "https://files.pythonhosted.org/packages/96/6f/915effa62cdcdc757bd0c567ee4d611c7a73ce7da097c820b3b2f340c2f7/isort-9.0.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c2525606f62742fc4ed9f8ca89043b9522ac3e6f9c9892e6cb16f4870d937f38", size = 1863445, upload-time = "2026-08-27T20:54:06.851Z" }, + { url = "https://files.pythonhosted.org/packages/e5/d4/af84d711cda084ddcb7a01a3d6a2608542c16ae7d418d99169b7deb775a4/isort-9.0.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:e3a2697ebcb54b51af4833de44447dbf31ddf081c5f163772092d21c0267483b", size = 1878639, upload-time = "2026-08-27T20:54:08.618Z" }, + { url = "https://files.pythonhosted.org/packages/58/d0/d77ec7d1c648a0b92ea6a8da3591a342550404af98a338106278a872ea1a/isort-9.0.1-cp314-cp314t-win_amd64.whl", hash = "sha256:fd326823ddbe338357ba1823b7f96481d4421d54c83ebd43c92f1b51314a24ae", size = 919565, upload-time = "2026-08-27T20:54:10.094Z" }, + { url = "https://files.pythonhosted.org/packages/72/d8/9963610d22fa55cbbd3c141a350f7011dd1023be9d3ba06212053c3639c6/isort-9.0.1-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:5022b332ac91ccb39dc28bb206d5ae96ae7f8d45e710b072cb039b2fcda6602a", size = 1020254, upload-time = "2026-08-27T20:54:11.732Z" }, + { url = "https://files.pythonhosted.org/packages/11/20/9f22f2574d94cc2b86f7c1764a186843ed19e7215666b57b10935335614f/isort-9.0.1-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:930879e4cfab3264f1d7346abeec10726b5382dc4be9f4251c25ec7fa057926b", size = 1667500, upload-time = "2026-08-27T20:54:13.193Z" }, + { url = "https://files.pythonhosted.org/packages/5e/4a/5a46b814d7fa49fc778e65a6703e4bb4d60149e01574afd7366b5ac7a1dc/isort-9.0.1-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:825c05d2d63a1b9c608c352503c10b6411a3c6e12bcacc97b306774ee379786f", size = 1655914, upload-time = "2026-08-27T20:54:14.827Z" }, + { url = "https://files.pythonhosted.org/packages/a7/09/b575e1837f3b182c97f937cf39cb55b3942f44dedfec4303403e4aa9bbd0/isort-9.0.1-cp315-cp315-pyemscripten_2026_5_wasm32.whl", hash = "sha256:cc9814ce2ee42c17007d822455e4db55e32e589808ecfc2665d51c848d0bb30a", size = 457120, upload-time = "2026-08-27T20:54:16.145Z" }, + { url = "https://files.pythonhosted.org/packages/65/60/3c73139b71b7031caf54aa098bc589b18374533b5f96f31c541b36112896/isort-9.0.1-cp315-cp315-win_amd64.whl", hash = "sha256:1b8d6c836fb83232f5f4c1c037d332caf743bb24dca63167bad9174ae13e150e", size = 894525, upload-time = "2026-08-27T20:54:17.895Z" }, + { url = "https://files.pythonhosted.org/packages/e5/27/5c17d4c8239a33a876f91e52426cc0d3fc75eb8438f34c40f403998057ac/isort-9.0.1-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:2fb33e0c0f9f87821acf6d82c83f0a0c7e54680fdf3fe4131409d2b95901f00a", size = 1088576, upload-time = "2026-08-27T20:54:19.599Z" }, + { url = "https://files.pythonhosted.org/packages/32/9b/9e80dee125b3d1208fb89afa380cae6fdfac660ad682eb0139a8fd8d790a/isort-9.0.1-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:cdf765657edb2bcccbb1b20d26e710acbcb27379c0a407c6cb376e5619059a7b", size = 1853379, upload-time = "2026-08-27T20:54:21.119Z" }, + { url = "https://files.pythonhosted.org/packages/34/43/f9f456c223ba34293ab28f736f00e26875b26913f24451e5a2938a8c4e02/isort-9.0.1-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:23d3b6657763f9be1b15bb9664b016abfce34849d6215a46a42af7945d4acd68", size = 1871162, upload-time = "2026-08-27T20:54:22.593Z" }, + { url = "https://files.pythonhosted.org/packages/38/5c/17fedc2bee564bb13b50ed3cb2ce7d66dd8e09184fb45d7a263ebaaaa97e/isort-9.0.1-cp315-cp315t-win_amd64.whl", hash = "sha256:8f490acc182253d07071cc8255b57a281855e2e027b929a89eaa7c797f7b213e", size = 918269, upload-time = "2026-08-27T20:54:23.996Z" }, + { url = "https://files.pythonhosted.org/packages/af/6e/4ec84f19b008864656b9f158bad006aa6346e754694aff47a7fa9ee65a19/isort-9.0.1-py3-none-any.whl", hash = "sha256:5aac7263b7a7f9f647f94fb6df2761ff5b60a7168eb492ff39dd30443207fa19", size = 103487, upload-time = "2026-08-27T20:54:25.395Z" }, +] + +[[package]] +name = "jax" +version = "0.12.0.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jaxlib" }, + { name = "ml-dtypes" }, + { name = "numpy" }, + { name = "opt-einsum" }, + { name = "scipy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/2e/5b/5b7f007852809973310ed99eede7db6e9e1cd60914f8fe90b091ae264db4/jax-0.12.0.1.tar.gz", hash = "sha256:f543fb1151c351d328b7dd9e40865c01bf9ae10cdf7e21637196172891d51914", size = 3024361, upload-time = "2026-10-21T21:07:07.969Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f9/5d/be6a4b67161462d1a0a97c7405459c2f76a4c23c66b39ad496527f68a17d/jax-0.12.0.1-py3-none-any.whl", hash = "sha256:e9dfd256ba090259b10f97f0755d4fc92535b8cb38c0a40df6488a8c8a7dd8ae", size = 3466959, upload-time = "2026-10-21T21:04:05.013Z" }, +] + +[[package]] +name = "jaxlib" +version = "0.12.0.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "ml-dtypes" }, + { name = "numpy" }, + { name = "scipy" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/17/73/47d66eeab3bb5a48009772f4fa572e46bdf8049ecb180f83d544c933462f/jaxlib-0.12.0.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:db2cc8584d7d0d166293ef2475b726988a10f6f9b5a8e3b8e3712415e5570380", size = 60710018, upload-time = "2026-10-21T21:05:22.443Z" }, + { url = "https://files.pythonhosted.org/packages/c1/cf/f9baa1ba672ced2a7bce86a6afebbc4b565daf04508b7fdeddefee2e9ac0/jaxlib-0.12.0.1-cp312-cp312-manylinux_2_27_aarch64.whl", hash = "sha256:40812201c3bcd4cb104b88f71f58fec4cbd0c32ba90e5c92b3fa8f40819f6774", size = 80858298, upload-time = "2026-10-21T21:05:27.085Z" }, + { url = "https://files.pythonhosted.org/packages/0d/e0/d39abd53ba408219062c1156bf3b9f965718f66bda8d625cb28453d63c2c/jaxlib-0.12.0.1-cp312-cp312-manylinux_2_27_x86_64.whl", hash = "sha256:78318e9ac79c92972f81c77090f557bdb4a5a49821751c6ee3f6a9c66a948842", size = 86848931, upload-time = "2026-10-21T21:05:31.389Z" }, + { url = "https://files.pythonhosted.org/packages/de/45/e87c51650ccaba0c08dea0206e132db3093b4e5265ebbb5449f664a955b6/jaxlib-0.12.0.1-cp312-cp312-win_amd64.whl", hash = "sha256:aa24baf4aafd78bbf7104a81f01eadc40332b8b90098634d14d585cd0477eeaf", size = 71385367, upload-time = "2026-10-21T21:05:35.413Z" }, + { url = "https://files.pythonhosted.org/packages/df/ce/49eab4b18b65406dd80059a3cbfb27c8d75596d5710a0623ced2bbd7c3d0/jaxlib-0.12.0.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:8be160b0b847bc57168e4305713756f6da0d0bba26715e64f9d2f46c0a7a6b42", size = 60709320, upload-time = "2026-10-21T21:05:39.353Z" }, + { url = "https://files.pythonhosted.org/packages/f6/8d/5c4c74d419be62a09bdf44a13293f726c399623b048805360aaf0788b34e/jaxlib-0.12.0.1-cp313-cp313-manylinux_2_27_aarch64.whl", hash = "sha256:c8de1cad382713114f657f406383edc53ee9fda4679db4e2b09d1dfefe1c4e45", size = 80854031, upload-time = "2026-10-21T21:05:43.268Z" }, + { url = "https://files.pythonhosted.org/packages/78/9d/225a525821b08b4ce85a7343fc8d21dcda6e75a825b90e9b6a29feedc2ee/jaxlib-0.12.0.1-cp313-cp313-manylinux_2_27_x86_64.whl", hash = "sha256:fdc56999ba690bd915f7029613269848eaaf85d231ec8abc46610d3b840c189c", size = 86849021, upload-time = "2026-10-21T21:05:48.262Z" }, + { url = "https://files.pythonhosted.org/packages/d8/34/e020e9279dc6bde837a20c31f97f9c7bbead144caa9b89bf36f7d94801a1/jaxlib-0.12.0.1-cp313-cp313-win_amd64.whl", hash = "sha256:3011a4ef1fc3dbe7c03fee30dee8f0b85a9ce92e5673271f5065d4cb400587a5", size = 71385208, upload-time = "2026-10-21T21:05:52.509Z" }, + { url = "https://files.pythonhosted.org/packages/74/d4/f5870719e158fdf7d4edc3b2ac3f81f48341a813bdf442fcb24a3f4547d3/jaxlib-0.12.0.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:93b8da183f0235603c460b530da8cd6eb23ea7f1c6adc4f82a43a6035497d466", size = 60710508, upload-time = "2026-10-21T21:05:55.865Z" }, + { url = "https://files.pythonhosted.org/packages/67/a7/dd962170691604061286ef750ddd9317efd20c554d587ea2486713033441/jaxlib-0.12.0.1-cp314-cp314-manylinux_2_27_aarch64.whl", hash = "sha256:609deffaea388d1ed9d1c5104d8f6041791f00771adc305f7316b742f502fd6b", size = 80859721, upload-time = "2026-10-21T21:05:59.819Z" }, + { url = "https://files.pythonhosted.org/packages/29/bf/14bbe929413ed61e13d2cc5dd2368b710cc638fcaf4632997b75fceff568/jaxlib-0.12.0.1-cp314-cp314-manylinux_2_27_x86_64.whl", hash = "sha256:b6079a7669d624ebd42d1571339566e62cfe7225f4b5a20b8e16773ea9a8357a", size = 86849658, upload-time = "2026-10-21T21:06:04.735Z" }, + { url = "https://files.pythonhosted.org/packages/e5/7b/940134f193e705dea624e55f597ef475f824e4ec2da34973bf7c3794938c/jaxlib-0.12.0.1-cp314-cp314-win_amd64.whl", hash = "sha256:cfba501b599e4083a4463cd58c36a1271249a415a69f2c8054083554f281efcc", size = 73913218, upload-time = "2026-10-21T21:06:11.627Z" }, + { url = "https://files.pythonhosted.org/packages/39/c3/5402e68283e2d07f8544b777ed1628b0514da62f2a50c1605686b15f3597/jaxlib-0.12.0.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:d35f6faca955676b4b46418028bf7fa7af88c6c9bb6b691c6e3005fc37839fce", size = 60809745, upload-time = "2026-10-21T21:06:15.299Z" }, + { url = "https://files.pythonhosted.org/packages/12/c5/dd642aa73dbc29fd1c1b830a221b9c4483ae7e48086d7e0761c11de0ff71/jaxlib-0.12.0.1-cp314-cp314t-manylinux_2_27_aarch64.whl", hash = "sha256:f5d9e527c1736eca5ca82bdc6d6f45421d8962ec7c9a8db153e4547311cc6876", size = 80951733, upload-time = "2026-10-21T21:06:20.105Z" }, + { url = "https://files.pythonhosted.org/packages/23/4b/1df08833de32175aff13d04c0b02f09ac5e24b797e95a2f8d7d4ebdefa5b/jaxlib-0.12.0.1-cp314-cp314t-manylinux_2_27_x86_64.whl", hash = "sha256:d8f14f5253c032f9a6f688734e3b63d911dbdcac9fd698ceb71f660f1956ddef", size = 86943877, upload-time = "2026-10-21T21:06:24.846Z" }, + { url = "https://files.pythonhosted.org/packages/51/1f/cde063eb5e2e4f9b80b4b6317450027d86c0c4525e9e1ba9f3db477c0ea1/jaxlib-0.12.0.1-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:00acba6d262f20110289e5d3384cd92298ae362226b66f77f92c518fab55c2c6", size = 60712539, upload-time = "2026-10-21T21:06:34.593Z" }, + { url = "https://files.pythonhosted.org/packages/b3/5b/932cb1f2ea25048fe7107eb01a0b2fd704e736a238ed676973e9fc9ef7cf/jaxlib-0.12.0.1-cp315-cp315-manylinux_2_27_aarch64.whl", hash = "sha256:7978a182ce9d1a8314dd693ab466ff24b961950ce6617f03498395e467f72e42", size = 80858593, upload-time = "2026-10-21T21:06:38.689Z" }, + { url = "https://files.pythonhosted.org/packages/af/c2/640a003f7c331e2d3b4dfd7af2283bd4af3f752c385abd30b7882f24e760/jaxlib-0.12.0.1-cp315-cp315-manylinux_2_27_x86_64.whl", hash = "sha256:44d3d534664fe762f32c5b831d556384bd96f9afad2e40aa207050f0b6e2c9f6", size = 86851688, upload-time = "2026-10-21T21:06:42.649Z" }, + { url = "https://files.pythonhosted.org/packages/94/a6/f3c13d4c3c0e6958331f38c6508a7f73d19de1cf44c49612a6286e7853cf/jaxlib-0.12.0.1-cp315-cp315-win_amd64.whl", hash = "sha256:9fa1147a3ccc916c77ab2063229d6ddaf82699d6b485bf6ad4dac265cfd8e0ee", size = 73915243, upload-time = "2026-10-21T21:06:46.511Z" }, + { url = "https://files.pythonhosted.org/packages/44/59/78b61a557fa58feee23e7e4ac4c1cec7c4ad5085536ddb22485d6e2e8a8f/jaxlib-0.12.0.1-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:78d16c6d6342cbe8de117f23b5c6d98339e582453221e977920dcbe5e05d72d6", size = 60812353, upload-time = "2026-10-21T21:06:49.984Z" }, + { url = "https://files.pythonhosted.org/packages/b3/b1/76a8e1368610b210684f8d74e24873365af89db0a6a29693f20ee8032ac3/jaxlib-0.12.0.1-cp315-cp315t-manylinux_2_27_aarch64.whl", hash = "sha256:b8435a50e7f09481156ab15a7522e3dd96ee6655f57f494933c5b9ffc6101332", size = 80950599, upload-time = "2026-10-21T21:06:59.918Z" }, + { url = "https://files.pythonhosted.org/packages/d1/71/f3d7e2408ddb179fd517e5c3b6f8722261d04ba6b5aa583f7e4d25535323/jaxlib-0.12.0.1-cp315-cp315t-manylinux_2_27_x86_64.whl", hash = "sha256:085c5196ac9e735a9313dee67a536e70ca09fe61c4ce19e694849509add2ecac", size = 86944972, upload-time = "2026-10-21T21:07:04.98Z" }, +] + +[[package]] +name = "jaxtyping" +version = "0.3.11" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "wadler-lindig" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/91/c1/091b8852bd7cbf50bd655543c8506033cf4029300c67f8c176c1286879a9/jaxtyping-0.3.11.tar.gz", hash = "sha256:b09c14acf6686feb9e0df5b0d8c6e7c5b6f8d36bf059ee54cd522a186c2ef050", size = 46489, upload-time = "2026-06-13T18:35:23.167Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8b/38/c66bbdc5047f4776c2bd3e47e5295a350e3fa44d5b8942105e71c2a876a0/jaxtyping-0.3.11-py3-none-any.whl", hash = "sha256:8a4bedc4e3f963fa82df41bd13c7ebc2bad925601eb48614c65798f21329d4e3", size = 56593, upload-time = "2026-06-13T18:35:22.01Z" }, +] + +[[package]] +name = "jedi" +version = "0.20.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "parso" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/46/b7/a3635f6a2d7cf5b5dd98064fc1d5fbbafcb25477bcea204a3a92145d158b/jedi-0.20.0.tar.gz", hash = "sha256:c3f4ccbd276696f4b19c54618d4fb18f9fc24b0aef02acf704b23f487daa1011", size = 3119416, upload-time = "2026-05-01T23:38:47.814Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9a/93/242e2eab5fe682ffcb8b0084bde703a41d51e17ee0f3a31ff0d9d813620a/jedi-0.20.0-py2.py3-none-any.whl", hash = "sha256:7bdd9c2634f56713299976f4cbd59cb3fa92165cc5e05ea811fb253480728b67", size = 4884812, upload-time = "2026-05-01T23:38:43.919Z" }, +] + +[[package]] +name = "jinja2" +version = "3.1.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markupsafe" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/df/bf/f7da0350254c0ed7c72f3e33cef02e048281fec7ecec5f032d4aac52226b/jinja2-3.1.6.tar.gz", hash = "sha256:0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d", size = 245115, upload-time = "2025-03-05T20:05:02.478Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl", hash = "sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", size = 134899, upload-time = "2025-03-05T20:05:00.369Z" }, +] + +[[package]] +name = "jitr" +version = "3.0.2.dev42+g4eb3261ad" +source = { git = "https://github.com/beykyle/jitr?rev=jax-core#4eb3261ad21478a5b005325d6459310275411f2b" } +dependencies = [ + { name = "jax" }, + { name = "mpmath" }, + { name = "numpy" }, + { name = "pandas" }, + { name = "periodictable" }, + { name = "scipy" }, + { name = "sympy" }, +] + +[[package]] +name = "joblib" +version = "1.6.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cloudpickle" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/d5/1d/537ab090f302b838943a1b56497dd53059b9a9b46a074936470173a2e207/joblib-1.6.0.tar.gz", hash = "sha256:2ccc96785b12046c08fd6d55839c12857831b54a3c1673ffadd2f04bfc4eda03", size = 327903, upload-time = "2026-08-31T09:39:04.122Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/18/53/84099323c2ec4be98d935f63c033ac4151ee83836ca1050ede3b3aadf155/joblib-1.6.0-py3-none-any.whl", hash = "sha256:3dbbf9f6e4b592a2357b854608e980fe6390d131d7a82f011a377ef2ebef7aba", size = 306115, upload-time = "2026-08-31T09:39:02.298Z" }, +] + +[[package]] +name = "json5" +version = "0.15.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e4/7d/05c46a96a78147ae3bf99c2f4169ce144a70220b8d6fcd56f6ec368b8ce9/json5-0.15.0.tar.gz", hash = "sha256:7424d1f1eb1d56da6e3d70643f53619862b4ce81440bdb8ecfd6f875e5ba4a71", size = 53278, upload-time = "2026-06-19T20:08:27.716Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/eb/be/59527c99478aade6bb33a68d72e6e18dd4e6ff6eacfc7d01bdb15bc76912/json5-0.15.0-py3-none-any.whl", hash = "sha256:56636a30c0e8a4665fe2179c0212f32eae3796dea89ea6f649b9436ecdb39618", size = 36570, upload-time = "2026-06-19T20:08:26.748Z" }, +] + +[[package]] +name = "jsonpointer" +version = "3.1.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/18/c7/af399a2e7a67fd18d63c40c5e62d3af4e67b836a2107468b6a5ea24c4304/jsonpointer-3.1.1.tar.gz", hash = "sha256:0b801c7db33a904024f6004d526dcc53bbb8a4a0f4e32bfd10beadf60adf1900", size = 9068, upload-time = "2026-03-23T22:32:32.458Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9e/6a/a83720e953b1682d2d109d3c2dbb0bc9bf28cc1cbc205be4ef4be5da709d/jsonpointer-3.1.1-py3-none-any.whl", hash = "sha256:8ff8b95779d071ba472cf5bc913028df06031797532f08a7d5b602d8b2a488ca", size = 7659, upload-time = "2026-03-23T22:32:31.568Z" }, +] + +[[package]] +name = "jsonschema" +version = "4.26.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "attrs" }, + { name = "jsonschema-specifications" }, + { name = "referencing" }, + { name = "rpds-py" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b3/fc/e067678238fa451312d4c62bf6e6cf5ec56375422aee02f9cb5f909b3047/jsonschema-4.26.0.tar.gz", hash = "sha256:0c26707e2efad8aa1bfc5b7ce170f3fccc2e4918ff85989ba9ffa9facb2be326", size = 366583, upload-time = "2026-01-07T13:41:07.246Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/69/90/f63fb5873511e014207a475e2bb4e8b2e570d655b00ac19a9a0ca0a385ee/jsonschema-4.26.0-py3-none-any.whl", hash = "sha256:d489f15263b8d200f8387e64b4c3a75f06629559fb73deb8fdfb525f2dab50ce", size = 90630, upload-time = "2026-01-07T13:41:05.306Z" }, +] + +[package.optional-dependencies] +format-nongpl = [ + { name = "fqdn" }, + { name = "idna" }, + { name = "isoduration" }, + { name = "jsonpointer" }, + { name = "rfc3339-validator" }, + { name = "rfc3986-validator" }, + { name = "rfc3987-syntax" }, + { name = "uri-template" }, + { name = "webcolors" }, +] + +[[package]] +name = "jsonschema-specifications" +version = "2025.9.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "referencing" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/19/74/a633ee74eb36c44aa6d1095e7cc5569bebf04342ee146178e2d36600708b/jsonschema_specifications-2025.9.1.tar.gz", hash = "sha256:b540987f239e745613c7a9176f3edb72b832a4ac465cf02712288397832b5e8d", size = 32855, upload-time = "2025-09-08T01:34:59.186Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/41/45/1a4ed80516f02155c51f51e8cedb3c1902296743db0bbc66608a0db2814f/jsonschema_specifications-2025.9.1-py3-none-any.whl", hash = "sha256:98802fee3a11ee76ecaca44429fda8a41bff98b00a0f2838151b113f210cc6fe", size = 18437, upload-time = "2025-09-08T01:34:57.871Z" }, +] + +[[package]] +name = "jupyter" +version = "1.1.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "ipykernel" }, + { name = "ipywidgets" }, + { name = "jupyter-console" }, + { name = "jupyterlab" }, + { name = "nbconvert" }, + { name = "notebook" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/58/f3/af28ea964ab8bc1e472dba2e82627d36d470c51f5cd38c37502eeffaa25e/jupyter-1.1.1.tar.gz", hash = "sha256:d55467bceabdea49d7e3624af7e33d59c37fff53ed3a350e1ac957bed731de7a", size = 5714959, upload-time = "2024-08-30T07:15:48.299Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/38/64/285f20a31679bf547b75602702f7800e74dbabae36ef324f716c02804753/jupyter-1.1.1-py2.py3-none-any.whl", hash = "sha256:7a59533c22af65439b24bbe60373a4e95af8f16ac65a6c00820ad378e3f7cc83", size = 2657, upload-time = "2024-08-30T07:15:47.045Z" }, +] + +[[package]] +name = "jupyter-builder" +version = "1.2.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-core" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/75/3e/56f593e6a664cd14d441724654ce8243f3cac7d3e45867cf084749c8bc75/jupyter_builder-1.2.3.tar.gz", hash = "sha256:01aba6794eb9b19e0e29ae21137ca60ba4135c70347d4b9f664a586822b8c809", size = 1024218, upload-time = "2026-09-04T18:54:09.411Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/84/aa/be79e87c50698673f196d0633fc1664607da2289f9688d1de7a1c9db9e71/jupyter_builder-1.2.3-py3-none-any.whl", hash = "sha256:c5ea5a7190c2a7b082494abade98eece1b2b5bd5dbd7d610606cbcd10a1d08b3", size = 947541, upload-time = "2026-09-04T18:54:07.644Z" }, +] + +[[package]] +name = "jupyter-cache" +version = "1.0.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "attrs" }, + { name = "click" }, + { name = "importlib-metadata" }, + { name = "nbclient" }, + { name = "nbformat" }, + { name = "pyyaml" }, + { name = "sqlalchemy" }, + { name = "tabulate" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/bb/f7/3627358075f183956e8c4974603232b03afd4ddc7baf72c2bc9fff522291/jupyter_cache-1.0.1.tar.gz", hash = "sha256:16e808eb19e3fb67a223db906e131ea6e01f03aa27f49a7214ce6a5fec186fb9", size = 32048, upload-time = "2024-11-15T16:03:55.322Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/64/6b/67b87da9d36bff9df7d0efbd1a325fa372a43be7158effaf43ed7b22341d/jupyter_cache-1.0.1-py3-none-any.whl", hash = "sha256:9c3cafd825ba7da8b5830485343091143dff903e4d8c69db9349b728b140abf6", size = 33907, upload-time = "2024-11-15T16:03:54.021Z" }, +] + +[[package]] +name = "jupyter-client" +version = "8.10.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-core" }, + { name = "python-dateutil" }, + { name = "pyzmq" }, + { name = "tornado" }, + { name = "traitlets" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c5/2a/906772148a06e48885039e0250c340b770a55bbf37b08d6ee0449df369c3/jupyter_client-8.10.0.tar.gz", hash = "sha256:9f7116294dca55f1785be880057d44544db9b1567718d92cb33c58886afb9497", size = 360653, upload-time = "2026-08-28T12:17:10.854Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0f/88/7c548de1f6c2ade7c931a3282da73f9274fa6a1531091be682f89c85efb9/jupyter_client-8.10.0-py3-none-any.whl", hash = "sha256:5f73f24f22fa25192cfff6b23c051932a2473a797b05734aff495b392103e14e", size = 110184, upload-time = "2026-08-28T12:17:09.028Z" }, +] + +[[package]] +name = "jupyter-console" +version = "6.6.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "ipykernel" }, + { name = "ipython" }, + { name = "jupyter-client" }, + { name = "jupyter-core" }, + { name = "prompt-toolkit" }, + { name = "pygments" }, + { name = "pyzmq" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/bd/2d/e2fd31e2fc41c14e2bcb6c976ab732597e907523f6b2420305f9fc7fdbdb/jupyter_console-6.6.3.tar.gz", hash = "sha256:566a4bf31c87adbfadf22cdf846e3069b59a71ed5da71d6ba4d8aaad14a53539", size = 34363, upload-time = "2023-03-06T14:13:31.02Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ca/77/71d78d58f15c22db16328a476426f7ac4a60d3a5a7ba3b9627ee2f7903d4/jupyter_console-6.6.3-py3-none-any.whl", hash = "sha256:309d33409fcc92ffdad25f0bcdf9a4a9daa61b6f341177570fdac03de5352485", size = 24510, upload-time = "2023-03-06T14:13:28.229Z" }, +] + +[[package]] +name = "jupyter-core" +version = "5.9.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "platformdirs" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/02/49/9d1284d0dc65e2c757b74c6687b6d319b02f822ad039e5c512df9194d9dd/jupyter_core-5.9.1.tar.gz", hash = "sha256:4d09aaff303b9566c3ce657f580bd089ff5c91f5f89cf7d8846c3cdf465b5508", size = 89814, upload-time = "2025-10-16T19:19:18.444Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e7/e7/80988e32bf6f73919a113473a604f5a8f09094de312b9d52b79c2df7612b/jupyter_core-5.9.1-py3-none-any.whl", hash = "sha256:ebf87fdc6073d142e114c72c9e29a9d7ca03fad818c5d300ce2adc1fb0743407", size = 29032, upload-time = "2025-10-16T19:19:16.783Z" }, +] + +[[package]] +name = "jupyter-events" +version = "0.12.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jsonschema", extra = ["format-nongpl"] }, + { name = "packaging" }, + { name = "python-json-logger" }, + { name = "pyyaml" }, + { name = "referencing" }, + { name = "rfc3339-validator" }, + { name = "rfc3986-validator" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/18/f8/475c4241b2b75af0deaae453ed003c6c851766dbc44d332d8baf245dc931/jupyter_events-0.12.1.tar.gz", hash = "sha256:faff25f77218335752f35f23c5fe6e4a392a7bd99a5939ccb9b8fbf594636cf3", size = 62854, upload-time = "2026-04-20T23:17:50.66Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/eb/6c/6fcde0c8f616ed360ffd3587f7db9e225a7e62b583a04494d2f069cf64ea/jupyter_events-0.12.1-py3-none-any.whl", hash = "sha256:c366585253f537a627da52fa7ca7410c5b5301fe893f511e7b077c2d93ec8bcf", size = 19512, upload-time = "2026-04-20T23:17:48.927Z" }, +] + +[[package]] +name = "jupyter-lsp" +version = "2.3.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-server" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/36/ff/1e4a61f5170a9a1d978f3ac3872449de6c01fc71eaf89657824c878b1549/jupyter_lsp-2.3.1.tar.gz", hash = "sha256:fdf8a4aa7d85813976d6e29e95e6a2c8f752701f926f2715305249a3829805a6", size = 55677, upload-time = "2026-04-02T08:10:06.749Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/23/e8/9d61dcbd1dce8ef418f06befd4ac084b4720429c26b0b1222bc218685eff/jupyter_lsp-2.3.1-py3-none-any.whl", hash = "sha256:71b954d834e85ff3096400554f2eefaf7fe37053036f9a782b0f7c5e42dadb81", size = 77513, upload-time = "2026-04-02T08:10:01.753Z" }, +] + +[[package]] +name = "jupyter-server" +version = "2.21.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "anyio" }, + { name = "argon2-cffi" }, + { name = "jinja2" }, + { name = "jupyter-client" }, + { name = "jupyter-core" }, + { name = "jupyter-events" }, + { name = "jupyter-server-terminals" }, + { name = "nbconvert" }, + { name = "nbformat" }, + { name = "packaging" }, + { name = "prometheus-client" }, + { name = "pywinpty", marker = "os_name == 'nt' and sys_platform != 'darwin'" }, + { name = "pyzmq" }, + { name = "send2trash" }, + { name = "terminado" }, + { name = "tornado" }, + { name = "traitlets" }, + { name = "websocket-client" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/cf/e0/63b481d5b21f81fe23173dfc9eb25629fa1bc174fdc4a2c19d09c1ff8124/jupyter_server-2.21.0.tar.gz", hash = "sha256:70d9a1883f57d3576ea17f4ce061ec1a7aad7ef388d00428cfb7f5e4f0022271", size = 760357, upload-time = "2026-08-27T16:06:34.049Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cb/8a/cb97c2b353cb46cced413be8f742fa8fcd3cb1659524f27314494aa94968/jupyter_server-2.21.0-py3-none-any.whl", hash = "sha256:2ae2e5ce5e97268553e25aebe040197455673d925b5fc7995477153318160cf7", size = 393961, upload-time = "2026-08-27T16:06:31.814Z" }, +] + +[[package]] +name = "jupyter-server-terminals" +version = "0.5.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pywinpty", marker = "os_name == 'nt' and sys_platform != 'darwin'" }, + { name = "terminado" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f4/a7/bcd0a9b0cbba88986fe944aaaf91bfda603e5a50bda8ed15123f381a3b2f/jupyter_server_terminals-0.5.4.tar.gz", hash = "sha256:bbda128ed41d0be9020349f9f1f2a4ab9952a73ed5f5ac9f1419794761fb87f5", size = 31770, upload-time = "2026-01-14T16:53:20.213Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d1/2d/6674563f71c6320841fc300911a55143925112a72a883e2ca71fba4c618d/jupyter_server_terminals-0.5.4-py3-none-any.whl", hash = "sha256:55be353fc74a80bc7f3b20e6be50a55a61cd525626f578dcb66a5708e2007d14", size = 13704, upload-time = "2026-01-14T16:53:18.738Z" }, +] + +[[package]] +name = "jupyterlab" +version = "4.6.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "async-lru" }, + { name = "httpx" }, + { name = "ipykernel" }, + { name = "jinja2" }, + { name = "jupyter-builder" }, + { name = "jupyter-core" }, + { name = "jupyter-lsp" }, + { name = "jupyter-server" }, + { name = "jupyterlab-server" }, + { name = "notebook-shim" }, + { name = "packaging" }, + { name = "tornado" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/00/c0/45934229995d4c6e38192ca118d93185f60808f64157e3df3c5c28f8c5fd/jupyterlab-4.6.3.tar.gz", hash = "sha256:2e3db6e3a12495ebd188276e985bf5ac502fbde3d1e8628819920210008de498", size = 28319771, upload-time = "2026-08-10T18:50:57.947Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e9/47/242f46de028074651c9bd6d8000fc340ed0d3cdd1a0eae4387826123413a/jupyterlab-4.6.3-py3-none-any.whl", hash = "sha256:0a1ebc6567186f1eabd99536e94df7ed9e96d1e7c5ddf3e4406ae16e88abacb7", size = 17168312, upload-time = "2026-08-10T18:50:53.044Z" }, +] + +[[package]] +name = "jupyterlab-pygments" +version = "0.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/90/51/9187be60d989df97f5f0aba133fa54e7300f17616e065d1ada7d7646b6d6/jupyterlab_pygments-0.3.0.tar.gz", hash = "sha256:721aca4d9029252b11cfa9d185e5b5af4d54772bb8072f9b7036f4170054d35d", size = 512900, upload-time = "2023-11-23T09:26:37.44Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b1/dd/ead9d8ea85bf202d90cc513b533f9c363121c7792674f78e0d8a854b63b4/jupyterlab_pygments-0.3.0-py3-none-any.whl", hash = "sha256:841a89020971da1d8693f1a99997aefc5dc424bb1b251fd6322462a1b8842780", size = 15884, upload-time = "2023-11-23T09:26:34.325Z" }, +] + +[[package]] +name = "jupyterlab-server" +version = "2.28.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "babel" }, + { name = "jinja2" }, + { name = "json5" }, + { name = "jsonschema" }, + { name = "jupyter-server" }, + { name = "packaging" }, + { name = "requests" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/d6/2c/90153f189e421e93c4bb4f9e3f59802a1f01abd2ac5cf40b152d7f735232/jupyterlab_server-2.28.0.tar.gz", hash = "sha256:35baa81898b15f93573e2deca50d11ac0ae407ebb688299d3a5213265033712c", size = 76996, upload-time = "2025-10-22T13:59:18.37Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e0/07/a000fe835f76b7e1143242ab1122e6362ef1c03f23f83a045c38859c2ae0/jupyterlab_server-2.28.0-py3-none-any.whl", hash = "sha256:e4355b148fdcf34d312bbbc80f22467d6d20460e8b8736bf235577dd18506968", size = 59830, upload-time = "2025-10-22T13:59:16.767Z" }, +] + +[[package]] +name = "jupyterlab-widgets" +version = "3.0.17" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/21/8b/e739cf9066ad5037a2d4b0a403f06da374fdccb9748221661c8b492d3dbc/jupyterlab_widgets-3.0.17.tar.gz", hash = "sha256:6e61fe21ca8a66039180a5cc52a433e07279d2fee79c8be963e00d55193f17a8", size = 213919, upload-time = "2026-08-18T08:52:17.511Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/33/ef/6d27fc118f58cb24886da413545a7efb0853d405fddbfd8b2d9ac09fbed4/jupyterlab_widgets-3.0.17-py3-none-any.whl", hash = "sha256:40ac1e9955acf116c4d995d9bfa082d86ad9ec6d91c4f134827cf5e0a5eb75e0", size = 217292, upload-time = "2026-08-18T08:52:15.47Z" }, +] + +[[package]] +name = "kiwisolver" +version = "1.5.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ba/07/bd78e6a8fae171ea041ef5bba3ed21a003522fa088834b069b1909981f30/kiwisolver-1.5.1.tar.gz", hash = "sha256:f1303ef2eec81262a4b708c3e858afe58d7c75ad91c1c05266eda7673369859a", size = 104395, upload-time = "2026-08-28T10:28:27.153Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6b/9b/65b302742389c6f96f2956bef5decf26011309feb2fc5d79613af18adea4/kiwisolver-1.5.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:63fb7294b768f444eb4b068965f2662f28c2fd4161e23bd60fcf3ff27b74c046", size = 123876, upload-time = "2026-08-28T10:25:27.44Z" }, + { url = "https://files.pythonhosted.org/packages/71/74/c21f339956f6f691b2ed7e31d5f3ae767304df6c460192739fc830853051/kiwisolver-1.5.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:0ebdef3eae5336568147c39a55be6a2036ffde53faa9ca2d978989ae7c2da12c", size = 66487, upload-time = "2026-08-28T10:25:28.728Z" }, + { url = "https://files.pythonhosted.org/packages/84/e5/bdb34e21523e01dceda064d63713f3bdec91388af24fba1eca7ea5e85864/kiwisolver-1.5.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1798e83840c3f627246104c4d8a9639c60fa068adf9ce92b61791781fa8a68c1", size = 64660, upload-time = "2026-08-28T10:25:30.071Z" }, + { url = "https://files.pythonhosted.org/packages/fc/f4/dadfec469313c7f428efa7e84b4aba9732f813c13ea7131a24b7b008ef57/kiwisolver-1.5.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:34633ecf50d16187ab8e5528b7a2530f2feb4e23f300db4672538b51cfc5cd38", size = 1477929, upload-time = "2026-08-28T10:25:31.495Z" }, + { url = "https://files.pythonhosted.org/packages/6f/35/09c58daac34e6f6ea5c6dee0094b422118e5a7c265586008a95fd135ac5f/kiwisolver-1.5.1-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d27c2123977cb9269c30a49ba45f03a4323017ef693e19db4ec9dbe1299a3002", size = 1278499, upload-time = "2026-08-28T10:25:33.375Z" }, + { url = "https://files.pythonhosted.org/packages/19/32/739765e24fbad29d13f83e546ea4abc215a78cea9d677ca09025b027724d/kiwisolver-1.5.1-cp312-cp312-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6a797a1cefc8b9c93170db580337e1fe3d011ad18b1299943231279406342048", size = 1296677, upload-time = "2026-08-28T10:25:35.059Z" }, + { url = "https://files.pythonhosted.org/packages/df/32/03304d1010e2cc45e5b3b52cef7e43fed3a2a5cd6c87a89b4a88e1d85b5d/kiwisolver-1.5.1-cp312-cp312-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2551cf9917af48ee7c4b29cc82320489508cf96fd26a51f6fc124de661cd44c7", size = 1346037, upload-time = "2026-08-28T10:25:36.705Z" }, + { url = "https://files.pythonhosted.org/packages/3e/57/4c49377bfd274450dd72ecaa13eaac32ea804a03363e4d1db0c5aa999ceb/kiwisolver-1.5.1-cp312-cp312-manylinux_2_39_riscv64.whl", hash = "sha256:38f6e0deb4d0a4615efe0c4efc5990b06ae450ab50a0b321c0b078b6d238c083", size = 988248, upload-time = "2026-08-28T10:25:38.299Z" }, + { url = "https://files.pythonhosted.org/packages/cb/c3/38df144a08b6c5d75ca4504e5cc3141bb3bfef64c04f4ef48204f42711b6/kiwisolver-1.5.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:bfd1de989b3330420e29de39352f5c049905c9e3ee67233a50d550e3d652c148", size = 2228722, upload-time = "2026-08-28T10:25:40.038Z" }, + { url = "https://files.pythonhosted.org/packages/e7/11/3221838a89cd64d9b386353e000cd8a296069a20fbe3584507fdfd5bebae/kiwisolver-1.5.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:1209042a623ddfda5497e4066c7b77651dde8e1d3a9dd97599dc7e97f3b9b78c", size = 2325216, upload-time = "2026-08-28T10:25:41.699Z" }, + { url = "https://files.pythonhosted.org/packages/83/d4/075c219230697bb5db910d37262b9bacf880f92b4811a02ab81ed073a253/kiwisolver-1.5.1-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:26e8268480be5061d509e29669d59103c067a26377a56491630ece11762e3858", size = 1977689, upload-time = "2026-08-28T10:25:43.559Z" }, + { url = "https://files.pythonhosted.org/packages/bb/08/1d219c3c2dd960983d0d4da623d916e9de6385df2b0bab3d1af0e9b8fccc/kiwisolver-1.5.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:d79308fa689fac89cbcfbd4dbfc80b5f95c54c5a7fd4d194be221f9d33d026e6", size = 2491443, upload-time = "2026-08-28T10:25:45.242Z" }, + { url = "https://files.pythonhosted.org/packages/ba/d3/024208ec1079d273f1047468d1bdffbf38bb75b7b268090fd3a0301b9d9a/kiwisolver-1.5.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b03af77d77e50edba2030fd5f7c352ff209314b09030a3cba7c14edf9a09a444", size = 2295200, upload-time = "2026-08-28T10:25:46.984Z" }, + { url = "https://files.pythonhosted.org/packages/6e/7c/7b210498f9f92e1cd7855f260fa69ef056881087b199ee20c208f0e4189a/kiwisolver-1.5.1-cp312-cp312-win_amd64.whl", hash = "sha256:06a6917674de9e0fe3f66f5430787f59a9f2ddb64af9b714eaec547e29ef5c19", size = 70748, upload-time = "2026-08-28T10:25:48.444Z" }, + { url = "https://files.pythonhosted.org/packages/94/61/ef0daa157c8bb23672f7423e0d14c39db1dc6ef8ed47e6bc54c9c1bef3bf/kiwisolver-1.5.1-cp312-cp312-win_arm64.whl", hash = "sha256:ad8b9671348d7c8716715652ae11f85ed0eb99e265a2df2ca490577d69860b2c", size = 68324, upload-time = "2026-08-28T10:25:49.81Z" }, + { url = "https://files.pythonhosted.org/packages/08/c1/88018321d976f53c421e379c43bc6993e70ce0c8a3ec5edc4bfe102257f6/kiwisolver-1.5.1-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:b6ae6a0328f0bc035741820fdeecdcd67bf4694eee03972e843663107122f450", size = 62272, upload-time = "2026-08-28T10:25:51.02Z" }, + { url = "https://files.pythonhosted.org/packages/85/d2/712bc17ea4f1d216034928069d612defbc6c95a471c55a7203a39faecb1a/kiwisolver-1.5.1-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:886fc26012f0e8b5f69d1cfe6d711f6b11f194621539bf8e6bb1c25c5dc82724", size = 64481, upload-time = "2026-08-28T10:25:52.22Z" }, + { url = "https://files.pythonhosted.org/packages/1b/e6/6c5380d676f43b6d918033962ea5e72360ca69e5a404154bc496b598ffdb/kiwisolver-1.5.1-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:aefe930d113798330e9462f7874542977869c0613cba3262e2de3a8d5dee8f3a", size = 66260, upload-time = "2026-08-28T10:25:53.387Z" }, + { url = "https://files.pythonhosted.org/packages/92/6a/7087f5822cc8bb272679641404b1966a42504dac9ee74e2b33840475a0aa/kiwisolver-1.5.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:a5ca5aebae78a0bc13c1943af4af615d4966c5b650b05d5aa83b50e427196fee", size = 123876, upload-time = "2026-08-28T10:25:54.644Z" }, + { url = "https://files.pythonhosted.org/packages/5c/4b/9f385087ca09ee5ab9c09c6832561a7d2f7c78d3e5661d511e669f70e439/kiwisolver-1.5.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:1ed0f5e49d0ceff8b72190824d9e59c062fbbc02c231b853112c78474b3f5ec2", size = 66487, upload-time = "2026-08-28T10:25:55.899Z" }, + { url = "https://files.pythonhosted.org/packages/47/8b/40d33ffd2f378094ed462e9a9a0907e59d4de9845e65a59561272da350d4/kiwisolver-1.5.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:77a4c8187a5948d7f8795adb765a3c7b553d07d86d88e43038fc32fc1fb9a3f3", size = 64673, upload-time = "2026-08-28T10:25:57.048Z" }, + { url = "https://files.pythonhosted.org/packages/ab/43/86aacc027959108b4c66eeae8b73cedb057dfa6eb3a335d05ad65197081c/kiwisolver-1.5.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:74ad5c3dad54a4641b4c28cd15ded70899d04459c6c7aeacafea716be97cce6d", size = 1477992, upload-time = "2026-08-28T10:25:58.479Z" }, + { url = "https://files.pythonhosted.org/packages/ed/40/b1d0369048c79733a32c8abb0f2718532e6630641368e33a81384246e844/kiwisolver-1.5.1-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:21e46b23a2da695c364124817bc01d970effd5483147f8d66a6a7167e3f6b851", size = 1278821, upload-time = "2026-08-28T10:26:00.121Z" }, + { url = "https://files.pythonhosted.org/packages/61/a1/fa71c1792272ff9461432715ae60ffb7e11a4d7ac3bf68961b9cab6c60cf/kiwisolver-1.5.1-cp313-cp313-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:75d9b1cf8258462dbdc1eeda718c96ea7f079324c09067f6daabfcf37712b7fe", size = 1296805, upload-time = "2026-08-28T10:26:01.868Z" }, + { url = "https://files.pythonhosted.org/packages/a3/49/3f0bd94af8e06ecc47eb834b195a06f05d48711ceb2352c56d6835160f0e/kiwisolver-1.5.1-cp313-cp313-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:8fca690b00c4c48f6c2a547b0160ed511357093a4e4c9b47e0fadf3128066d89", size = 1346109, upload-time = "2026-08-28T10:26:03.59Z" }, + { url = "https://files.pythonhosted.org/packages/a4/44/3afe6ef9cf06d61220953a8963e94eca978491be1d9547cb01d82a1efa08/kiwisolver-1.5.1-cp313-cp313-manylinux_2_39_riscv64.whl", hash = "sha256:876bbfd276473d3daffe30e8c975df4ed9429967b41a6cb362dbb5155b6f13ad", size = 988252, upload-time = "2026-08-28T10:26:05.306Z" }, + { url = "https://files.pythonhosted.org/packages/e4/30/a12bd7a7285a211e1747c3eec77b8c614dbfcc1dad942f7611a1a6921ae5/kiwisolver-1.5.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f942903fde7363d1d879057ec5de01310efda2597161784d752fa9953a01a71a", size = 2228846, upload-time = "2026-08-28T10:26:07.312Z" }, + { url = "https://files.pythonhosted.org/packages/a1/6b/233e2958abf0dab7b18d07e52f286e02e519d7651bfbbe97af9347564109/kiwisolver-1.5.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:c90d3022d8a94778939cda8638c6c8da8fa757b8958dad7ec868ce29c87681b8", size = 2325583, upload-time = "2026-08-28T10:26:09.093Z" }, + { url = "https://files.pythonhosted.org/packages/42/8e/7673060a27b01405b580058510adef34687069d229800239f5e44682d4d0/kiwisolver-1.5.1-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:8a34616dc2521cc8dc1d7d081734da63539f021ac0450ce950908340c6e7aa2f", size = 1978221, upload-time = "2026-08-28T10:26:11.127Z" }, + { url = "https://files.pythonhosted.org/packages/3f/7b/1b882fc1a8b4a0bb8084e7d1d85004116d08c92c0705d31f2928dec607f2/kiwisolver-1.5.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:8bf4df63592c2a66b4f8edc5df2544998c288aa02f96ce0acd880cd1de8c8127", size = 2491819, upload-time = "2026-08-28T10:26:13.348Z" }, + { url = "https://files.pythonhosted.org/packages/39/9c/426deb49e62c5f69464b64bbeca064d3b758a7506b8913d986ef34f4619c/kiwisolver-1.5.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:d09037ca068d784ebc4aec290ef952ca27ac15dd9c0b5801a88c6e1096b83e6b", size = 2295520, upload-time = "2026-08-28T10:26:15.042Z" }, + { url = "https://files.pythonhosted.org/packages/f5/22/deabbb3ad6d918d74b7831b2d8ae7151b09d21c87974e5ee8a456f58c94c/kiwisolver-1.5.1-cp313-cp313-win_amd64.whl", hash = "sha256:dc23390afe9f4ef9ac3bcc72a03a56eebbde03f4c571a32cb38f859cff9a6524", size = 70758, upload-time = "2026-08-28T10:26:16.504Z" }, + { url = "https://files.pythonhosted.org/packages/b9/71/02fa5c2fd92068bb8952847e70ee6c5cb280e7febe11653d17812acc53dd/kiwisolver-1.5.1-cp313-cp313-win_arm64.whl", hash = "sha256:186884a58486651e3c217b6acea0a53eaa9498fdd472057c46f2f0fb5c25aad5", size = 68329, upload-time = "2026-08-28T10:26:17.658Z" }, + { url = "https://files.pythonhosted.org/packages/dd/87/2d5dfad0daf17dcc18d98c48ed2332fc3f051cf599e60be6182a30dd4cf1/kiwisolver-1.5.1-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:0324cd2567259b7a095f6cf18a52b0ffc6f3de9e69528ff1bc0e7a37bd43ff1a", size = 62337, upload-time = "2026-08-28T10:26:18.778Z" }, + { url = "https://files.pythonhosted.org/packages/08/c8/83e1624f15d6262b470dbcc80b09979fd4d5b2ea3ddfc6b6e3327e235726/kiwisolver-1.5.1-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:74ea337e0ec3f6f342a36a4f1b5cd94dd9affddcd28ba9aae2905af932ee8c6b", size = 64513, upload-time = "2026-08-28T10:26:19.909Z" }, + { url = "https://files.pythonhosted.org/packages/c9/2d/827ec30eb07f528c08d8459ffb318ae91a56d793ee8acbea8b491f0ff906/kiwisolver-1.5.1-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:ee9df1f0d77b9c6e94f4ac0fec533fbddd5ea3a327807f18d7b069ae019ded80", size = 66287, upload-time = "2026-08-28T10:26:21.078Z" }, + { url = "https://files.pythonhosted.org/packages/53/11/5c43a562529dad8def4b81e5e1877c612a7e0298105a5939b3b409d2079c/kiwisolver-1.5.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:fc271a6f0a2126958f4090e5507b9da5848927dae331f8f763bd4aa642b3d2cd", size = 123940, upload-time = "2026-08-28T10:26:22.475Z" }, + { url = "https://files.pythonhosted.org/packages/64/db/9bd6c505c95128c258a55236bfbb3a7a3fb6023f863316b6d7d9f3c69052/kiwisolver-1.5.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:9b3092d8992a1d69b7a59c3e39f35e1b9be327a17f68a7c35fc17329e337d6f2", size = 66493, upload-time = "2026-08-28T10:26:23.743Z" }, + { url = "https://files.pythonhosted.org/packages/e1/f4/b3007a3ed5c9be73f81161140684cf7d9bdb9c4b632f5f484d2a1c713fb9/kiwisolver-1.5.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c2306e8bb53601979fcb3fa09cc65e031876d9ae01eff2fcbcd7a84ef94d5bc1", size = 64720, upload-time = "2026-08-28T10:26:24.95Z" }, + { url = "https://files.pythonhosted.org/packages/a1/13/08188f0cafa3a800403e4ff62b9aad4e7a17f9c4c7e080dc8f18c64794cf/kiwisolver-1.5.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:18a0cfb124546a4c2e6087c5f3029c7f44b37c85b142e0ced71f73a7599ac208", size = 1475867, upload-time = "2026-08-28T10:26:26.393Z" }, + { url = "https://files.pythonhosted.org/packages/8a/3e/053bdc3c9abdb8f2606225eda398adca25c0c91ab90add8222a69db65ee0/kiwisolver-1.5.1-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:34ec467940442c9943016fb2d4c81d1ba84351eeca2f1a78f8bc87f1ba0d414c", size = 1282865, upload-time = "2026-08-28T10:26:28.118Z" }, + { url = "https://files.pythonhosted.org/packages/5e/64/a44c341b36b610588cc2f1e89b3cae072a3119aa8be578e90987cd640751/kiwisolver-1.5.1-cp314-cp314-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a83ee7107df13abe42a54a6654670eef9bb39425cf2e27f65e0007465e1286ab", size = 1300865, upload-time = "2026-08-28T10:26:30.125Z" }, + { url = "https://files.pythonhosted.org/packages/60/5e/7e7d716dca38c714478b741257a5b4a321d9932b8d851551a136dcaf3984/kiwisolver-1.5.1-cp314-cp314-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:bebb89489b279b2f5661bbbb2abcc87bcd4a46607bb4a5c966f04f1db6b8df9a", size = 1348071, upload-time = "2026-08-28T10:26:31.829Z" }, + { url = "https://files.pythonhosted.org/packages/10/1a/2b98fdda8bf45b7be317e48ed12393d44334394d315c74b81f4a14c0e31b/kiwisolver-1.5.1-cp314-cp314-manylinux_2_39_riscv64.whl", hash = "sha256:509735237ae0d849e8a843551d423d2500d2e0a9ac1611a145658b29c0fb9f85", size = 992191, upload-time = "2026-08-28T10:26:33.544Z" }, + { url = "https://files.pythonhosted.org/packages/b6/55/d893f5ede0e50f9e3fcf01f6015f42ec7d9cd221e26772701fe4a98745f9/kiwisolver-1.5.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:824c3d763a05ea9e9003610145186b0e9848c7584a5575c79bac5a8e7cd80bad", size = 2233854, upload-time = "2026-08-28T10:26:35.282Z" }, + { url = "https://files.pythonhosted.org/packages/b1/82/f85f6279555a6ee1639fef7bfe83adb037a03e11a6fc9eaa54b8d0380339/kiwisolver-1.5.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:1fff05e239575b1481b6ed1a782f6fad616efbf1f0b1f44e6e85c4dfe426e483", size = 2330621, upload-time = "2026-08-28T10:26:36.9Z" }, + { url = "https://files.pythonhosted.org/packages/56/31/e11aea078f66fc2fffcc179d38ca90d9da97652a241b64519169742ba46a/kiwisolver-1.5.1-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:0627b9bceb9c3cdcf12b8a18655eedfed2692b038df27423383c120d0b7dc2d6", size = 1982848, upload-time = "2026-08-28T10:26:39.01Z" }, + { url = "https://files.pythonhosted.org/packages/af/ea/2956b63bf5140ca46aa2c2818e6aa03e2d5754dd2fa41db1c6b28922940c/kiwisolver-1.5.1-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:8a708a47ade1fe19e8371d5da076bac0dd4b0a5a7985ad6c637f7f7e361b6baa", size = 2494850, upload-time = "2026-08-28T10:26:40.837Z" }, + { url = "https://files.pythonhosted.org/packages/11/d1/3829542258d8b3fc0898d221e7ef0e2c83eca0d348709bb8dbe54f3d4005/kiwisolver-1.5.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:007a5553dfc4f4e8d184f588a0200e2cd4b63a59cc8796df3c39909e679dc7a0", size = 2298067, upload-time = "2026-08-28T10:26:42.803Z" }, + { url = "https://files.pythonhosted.org/packages/4e/0e/49522e1ab5788cbaf63a26fbd3b851f9028616828c961b8a31b35cb96df8/kiwisolver-1.5.1-cp314-cp314-win_amd64.whl", hash = "sha256:f4167e87b397f273dc2356fcf1eaf50a6bac51e6105f45103ef7129c8efb0255", size = 72282, upload-time = "2026-08-28T10:26:44.268Z" }, + { url = "https://files.pythonhosted.org/packages/f5/b6/22e7ca5315d363e6f81c9f37c9472e12e7b298731e77c0428e6a911a2c39/kiwisolver-1.5.1-cp314-cp314-win_arm64.whl", hash = "sha256:5c490db2168a508088f59140dd392556a54b8bd1048fc6383c8baff13c359673", size = 69855, upload-time = "2026-08-28T10:26:45.725Z" }, + { url = "https://files.pythonhosted.org/packages/30/8c/03a9cfbe871964c8758a816eb03ac96c806da2795a9a7cd9bf9648bfb594/kiwisolver-1.5.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:4d4ca09bf13cff792b1884f64b98ee6c2467930d632233be25c56b442d99f10e", size = 126289, upload-time = "2026-08-28T10:26:47.023Z" }, + { url = "https://files.pythonhosted.org/packages/f2/e3/14ce3041ca79dff9c9d884ca00c7bf32374e76028a865a9ecd99b4f5a517/kiwisolver-1.5.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:44b8faef94f1857e77fa0238f3390ff1ac51d2ea20a487e2e452a59fd2b5f5ca", size = 67709, upload-time = "2026-08-28T10:26:48.268Z" }, + { url = "https://files.pythonhosted.org/packages/af/c4/45030471a66ec8ef042e9f96ffe1d522c9ab12da180186a0898966fc1385/kiwisolver-1.5.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:2ae70bc59790d2af72a3f76f24b272403e135070340281108b447cb77ea70819", size = 65909, upload-time = "2026-08-28T10:26:49.523Z" }, + { url = "https://files.pythonhosted.org/packages/42/73/17dce073a6ae259bb32cf9d686c4079d2e538868bc45967462bf33df914a/kiwisolver-1.5.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:43844c1a7ad6d723d5b5b4c4fc7f5bd399c40e288120d16257c7c9e8765c6e85", size = 1584907, upload-time = "2026-08-28T10:26:50.933Z" }, + { url = "https://files.pythonhosted.org/packages/8c/84/ae3c75909f507283cbfcc7e916c7e822579ef962020b97e6882b27b4478f/kiwisolver-1.5.1-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:22d5e5aaad6be121f2515765e3b1c444352cb8eb4c86510801db8f2e50757316", size = 1392474, upload-time = "2026-08-28T10:26:52.638Z" }, + { url = "https://files.pythonhosted.org/packages/34/31/8bcc83caad5bce8fa4577152389848bf6bc110e51e573a2b4e7c2aa34c89/kiwisolver-1.5.1-cp314-cp314t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:3fa5855898f6d3d01b72ccd48a2d65cbdee301251603fefe34e2025bddba219c", size = 1405246, upload-time = "2026-08-28T10:26:54.248Z" }, + { url = "https://files.pythonhosted.org/packages/55/72/220345537d790cf4ae54f8acfff4b5cc2468e0702a384d651cf7a771c63e/kiwisolver-1.5.1-cp314-cp314t-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d66a64dd5dec136040ec2ae94aa026a912ee60fdd45bc28d3db30037fd809e88", size = 1456099, upload-time = "2026-08-28T10:26:56.042Z" }, + { url = "https://files.pythonhosted.org/packages/cd/10/3725fd2398f66d18c34b4e0f81a8d03764cd4f4f089f58a527f0b4428086/kiwisolver-1.5.1-cp314-cp314t-manylinux_2_39_riscv64.whl", hash = "sha256:9e51c119992ea8820706871c30a4642ec76de20ae82f9b50b9a45517d8e9f810", size = 1073695, upload-time = "2026-08-28T10:26:57.658Z" }, + { url = "https://files.pythonhosted.org/packages/86/cb/28d6e09e66b93e4588b2e6b7d84d020ccefea09e2f4de788510a07efeab7/kiwisolver-1.5.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:70ed9a45c7484d2b30cdacf60d220f494a1763b9fec1ad03285c6553fa0889f2", size = 2335355, upload-time = "2026-08-28T10:26:59.202Z" }, + { url = "https://files.pythonhosted.org/packages/6a/b3/a0f31d5e4e40af7dc97c36b8a74fdd3a36cf3c8bbd098da9a23466ff6a94/kiwisolver-1.5.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:98b208a7cc42c803445ef551d6753cc42a5ea13e9cab1ee66cd8b9cb70195330", size = 2426524, upload-time = "2026-08-28T10:27:01.181Z" }, + { url = "https://files.pythonhosted.org/packages/2f/c9/728f63bd58c72cafdc79fc306abeeac7391bec03b757a48dadeb30906521/kiwisolver-1.5.1-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:c6834b92dd2428e2dd85ef3d85f723d3c12f20aaf43a2ddd4f944ca25d833408", size = 2063430, upload-time = "2026-08-28T10:27:03.06Z" }, + { url = "https://files.pythonhosted.org/packages/84/df/ce188b96f92f9a2c958231da140768918cba53c9713dc887b82f85462118/kiwisolver-1.5.1-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:5d142e352eb13facc7dd047489aebdff6ba78576c239f1ea04931979caaf0567", size = 2597513, upload-time = "2026-08-28T10:27:05.072Z" }, + { url = "https://files.pythonhosted.org/packages/69/d6/76947c8203768968382e5bd74d9cc95654746703a61ea53015f2c74a2e06/kiwisolver-1.5.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:f9b1c4900736e489a812c529100de4b8fb617d4db075e931e213c57424b83d9b", size = 2394488, upload-time = "2026-08-28T10:27:07.423Z" }, + { url = "https://files.pythonhosted.org/packages/e4/d4/14b21e4eb203c4d15425e8b6a2c625a320b4a1f2f7557eead63ffc30ffb7/kiwisolver-1.5.1-cp314-cp314t-win_amd64.whl", hash = "sha256:5978c3340f16a35c30f8ab2fa7bcf559973c55f1a5ef6970e1f621acf3c4db13", size = 75404, upload-time = "2026-08-28T10:27:08.892Z" }, + { url = "https://files.pythonhosted.org/packages/cb/f5/53157899fc7f45f76421b77b99eb1639dd0f83f26ff9d76300c96bb4a3b0/kiwisolver-1.5.1-cp314-cp314t-win_arm64.whl", hash = "sha256:ca307d6c259e5c98d3cb9ade55342b47a6839762caf2536f3d7b46ee660cc82e", size = 72946, upload-time = "2026-08-28T10:27:10.944Z" }, + { url = "https://files.pythonhosted.org/packages/75/62/f786c3a27f181fa339d851a77e266d208e776b9883cabc40a5b041a31b5a/kiwisolver-1.5.1-cp315-cp315-ios_13_0_arm64_iphoneos.whl", hash = "sha256:bb7c99f0673c03017a3ee01e54a5c2617a05468b11eabe513b0080e063ed95b1", size = 62420, upload-time = "2026-08-28T10:27:12.308Z" }, + { url = "https://files.pythonhosted.org/packages/02/cd/58a91ed25fbad0facdf503297b03768efab04bdf3141e5e3b49a34be7443/kiwisolver-1.5.1-cp315-cp315-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:0d8924877ce22e17326a99a418c3c82037da078df3c6a260b13eca677444e6e7", size = 64577, upload-time = "2026-08-28T10:27:13.502Z" }, + { url = "https://files.pythonhosted.org/packages/f6/5c/d501ef5a0958b226eac28306d24d5e5f114be0ace50e19cabae7b6b3b197/kiwisolver-1.5.1-cp315-cp315-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:534f02c1abb31ed6dbd3515545285c330b2f12d00fdb1fdb71658b9ca5a13a6a", size = 66284, upload-time = "2026-08-28T10:27:14.813Z" }, + { url = "https://files.pythonhosted.org/packages/a3/a6/8fbecaf4fc18c02f31f05e47a84c010a80e3ec391ed2f0bdade1d62b5954/kiwisolver-1.5.1-cp315-cp315-macosx_10_15_universal2.whl", hash = "sha256:cea20da04494e662b83c872683bf4ff2345206043d036315ed0e924b652e7294", size = 124031, upload-time = "2026-08-28T10:27:16.193Z" }, + { url = "https://files.pythonhosted.org/packages/7c/c6/bf3090d2983b4204347cbdbe952116e7c3b2abf62b4e33e50167a13e75ee/kiwisolver-1.5.1-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:7fd82debf43c6acd0a94359d232f6bb516ee13f269a7993736a9ac9f988bb5d9", size = 66489, upload-time = "2026-08-28T10:27:17.506Z" }, + { url = "https://files.pythonhosted.org/packages/85/de/562dddef55fdd7c291da8626d6619e72b5fc0870e6ccca0e149a5731e7f3/kiwisolver-1.5.1-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:18170a77ddfecf40ec60d0928268dc95880c881864e015a8f34094ed18b9b9ad", size = 64806, upload-time = "2026-08-28T10:27:18.673Z" }, + { url = "https://files.pythonhosted.org/packages/89/b1/ba7b9c0164ce1cf62bf2872db63b8483289cf0f3110d6f9390eb09e409ed/kiwisolver-1.5.1-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ca7f6fe0f37ca978a1e5eb7a3a68e6413f417e78e838324947ffd420202b198b", size = 1482211, upload-time = "2026-08-28T10:27:20.039Z" }, + { url = "https://files.pythonhosted.org/packages/13/dc/34da54efb4976616d45c20aae32d70e89d6e7395ed908029154d1609ef22/kiwisolver-1.5.1-cp315-cp315-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5b973887ff782cfd6b67c9904ad8ca542e0bc5e4961503408b423b5a688b4d38", size = 1283739, upload-time = "2026-08-28T10:27:21.82Z" }, + { url = "https://files.pythonhosted.org/packages/5a/3a/30ffb62bee646e266e98a1b5cd276d9c75b6116fbfcb87c1190838c1b6df/kiwisolver-1.5.1-cp315-cp315-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f76fc85bd054c806960f917ec0f329e24e436f1712267d90588e4c39890caa63", size = 1301681, upload-time = "2026-08-28T10:27:23.876Z" }, + { url = "https://files.pythonhosted.org/packages/a9/8d/13c70be22a8506880b35fdc38dca36629613bc493405c79f4037f2cd2bb9/kiwisolver-1.5.1-cp315-cp315-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:828f75af2b0080c8a972e75f649ab46af008e92c6104a57a759157200b835b75", size = 1349159, upload-time = "2026-08-28T10:27:25.899Z" }, + { url = "https://files.pythonhosted.org/packages/82/0e/993972b8ec6767f47cd69818fb3a5ff14510557d29f7d1a839be7574fa1b/kiwisolver-1.5.1-cp315-cp315-manylinux_2_39_riscv64.whl", hash = "sha256:431dc224a1a92a5c8f582d96e505196a3b5997a7271076678da2dfde67b77e9a", size = 997613, upload-time = "2026-08-28T10:27:27.507Z" }, + { url = "https://files.pythonhosted.org/packages/36/82/ca26eddd2eda2420dfc56693449c1f821f78b485da9cbde9904c03af3f93/kiwisolver-1.5.1-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:61e9a64c7635095a6bfe483e2ff055d437c59bd45f3617a228b37277f0185d62", size = 2235109, upload-time = "2026-08-28T10:27:30.113Z" }, + { url = "https://files.pythonhosted.org/packages/c7/84/97d920881e10840b8d7c7185620298e3e4c88820b05514e3a15a258b08a6/kiwisolver-1.5.1-cp315-cp315-musllinux_1_2_ppc64le.whl", hash = "sha256:3c24cd69455e1b00ddf770c13b6e2c33e07d6dc3f2d34add0bf9277c5c6bbd46", size = 2331207, upload-time = "2026-08-28T10:27:32.795Z" }, + { url = "https://files.pythonhosted.org/packages/e2/ce/34d74b8f25acc58800f4c09268371e8d6159cf0f1206f1e4dc7835629b48/kiwisolver-1.5.1-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:27add358abe374ebaa3b8763ef380bc99051b5a4b18d94878366a9e4f59efef0", size = 1986696, upload-time = "2026-08-28T10:27:34.628Z" }, + { url = "https://files.pythonhosted.org/packages/0e/01/f892644014612527aef7031d3306a2ffc60b3cb044f802c1561f8e5e14f3/kiwisolver-1.5.1-cp315-cp315-musllinux_1_2_s390x.whl", hash = "sha256:255605693a483db7bd5c79f60437f7bf658f7f520d61aa42722e32257c941951", size = 2496400, upload-time = "2026-08-28T10:27:36.818Z" }, + { url = "https://files.pythonhosted.org/packages/32/6d/d8284e66e697026536e5f418b9cfe56567bffd3c775e3ecfbae373605854/kiwisolver-1.5.1-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:7d38b0c279c3032e8c9cc013b405c6df8e1668dbf15465779aa7f15f61201812", size = 2302967, upload-time = "2026-08-28T10:27:38.803Z" }, + { url = "https://files.pythonhosted.org/packages/46/0a/69a355e27f32ba50d5b6369949b6a1702e122f5277c89bc76d452b81c1c4/kiwisolver-1.5.1-cp315-cp315-win_amd64.whl", hash = "sha256:958254518717542d02d0688d0d20cbf771da5e415e6f49543f92481c850a4540", size = 72283, upload-time = "2026-08-28T10:27:40.491Z" }, + { url = "https://files.pythonhosted.org/packages/ef/d8/7a95be90c33dcdd52204d4aa6384d731443225b887283bbd8b61e7931f6c/kiwisolver-1.5.1-cp315-cp315-win_arm64.whl", hash = "sha256:da3275833be0edbaf4830fae08bae3dc7219f40ce0c37eaa6c25825957e06612", size = 69860, upload-time = "2026-08-28T10:27:41.835Z" }, + { url = "https://files.pythonhosted.org/packages/31/f8/9bc493e7f5707788ba7f621902c68f82dc3a7ba03c78fbd337b026cef1ed/kiwisolver-1.5.1-cp315-cp315t-macosx_10_15_universal2.whl", hash = "sha256:470d420f98d368d6f010633a20659b544c5fdfa5329e6b70219f2ef08fd4a7ef", size = 126336, upload-time = "2026-08-28T10:27:43.379Z" }, + { url = "https://files.pythonhosted.org/packages/d1/82/3aea86b3f99712db825e9ac5631bf99571e818a8b8961ff98cebd798413e/kiwisolver-1.5.1-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:83f78128fa28705fa85d01c59771c72fe81c11bd0e6155edbb9f818983a7d761", size = 67698, upload-time = "2026-08-28T10:27:44.613Z" }, + { url = "https://files.pythonhosted.org/packages/84/7d/8daafc5d2e7f9c47a4f78f8865d86d2a9cf399c2a85f86c44a993594410c/kiwisolver-1.5.1-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:9506e892bcc3b409831d363c6f53e5985e1c8d1f6f6b0256d00358684ff85378", size = 65945, upload-time = "2026-08-28T10:27:45.932Z" }, + { url = "https://files.pythonhosted.org/packages/3d/c9/51dc974d9130da70a8c47a96160123443d387ffe1b6b833d6f91d9429339/kiwisolver-1.5.1-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:cea90547bfd93807e0013a004dc76552be44fad3bc1cc2b38610a9e889ed098f", size = 1588030, upload-time = "2026-08-28T10:27:47.678Z" }, + { url = "https://files.pythonhosted.org/packages/e6/86/f3e1a730e7a995149d8d3ff9e313b6d8a17b2cf1d98a8eff139dc30463fb/kiwisolver-1.5.1-cp315-cp315t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e8e4d953faaded9ec7ede36824e9814082d22d4c7b1eafbfa079ecba8cd0d076", size = 1390760, upload-time = "2026-08-28T10:27:49.676Z" }, + { url = "https://files.pythonhosted.org/packages/4f/3b/8ba25a2b5a0d2375e046f1b72de5179513f0be95aba6e7b094c89303929f/kiwisolver-1.5.1-cp315-cp315t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7e9c01d3dd7ceba4d1d436cc021d40d592466e40b9bc7f5d83dc4e98a5c9cd8c", size = 1403279, upload-time = "2026-08-28T10:27:51.242Z" }, + { url = "https://files.pythonhosted.org/packages/18/d0/278d5cb8be812740027d5ca0a7eda0c375488a88d6dce0fa60fcc2591ad2/kiwisolver-1.5.1-cp315-cp315t-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:37f801b5d7cc0e5a548921308e059fd2b057bb42972b591cfa3049f95423c4ed", size = 1454429, upload-time = "2026-08-28T10:27:53.213Z" }, + { url = "https://files.pythonhosted.org/packages/94/37/bcbab41063ec284c1d200efe5087cf087798c2f8916960aa8a20dd303290/kiwisolver-1.5.1-cp315-cp315t-manylinux_2_39_riscv64.whl", hash = "sha256:e68e151428b5384f766cd25739bf77c7e4a3dc93b5ded7a12118d9fbfdf78ab6", size = 1073225, upload-time = "2026-08-28T10:27:55.089Z" }, + { url = "https://files.pythonhosted.org/packages/cb/c5/ab79dcdf5ae28909a51210ae0a1c579e97ff997b3466414f0d04c0994583/kiwisolver-1.5.1-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:8f8fddb8e323bd6eee4e54e69a39243beab22689070f4c66b472c4cc88bb89d8", size = 2334335, upload-time = "2026-08-28T10:27:56.78Z" }, + { url = "https://files.pythonhosted.org/packages/8d/8e/71d047468a189041d9c93f3b76844b924f9793b188c44bd149fa258912da/kiwisolver-1.5.1-cp315-cp315t-musllinux_1_2_ppc64le.whl", hash = "sha256:3cc210010fd2f438a3ed430b45f1b501fd13a8618bf984dc2c5ce5b69b78752e", size = 2424982, upload-time = "2026-08-28T10:27:58.639Z" }, + { url = "https://files.pythonhosted.org/packages/7d/37/1347461bbea6d0e1f0580b94ef603b18e72c2be5f667fa1653867361a00b/kiwisolver-1.5.1-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:b5664603a253efd3a75716d793d1d3a6a82723b61dc6db767b2460bbbeec4c0f", size = 2062857, upload-time = "2026-08-28T10:28:00.407Z" }, + { url = "https://files.pythonhosted.org/packages/1f/87/c7f0976c9cd0d127643351bc0c9929e0b8899d7f49d4ec238cd909e39c42/kiwisolver-1.5.1-cp315-cp315t-musllinux_1_2_s390x.whl", hash = "sha256:a7b85b2cc6ea45e5f7e8c9a30bc9fabd47cda09106cbb4b967335c3e6c43b69d", size = 2596022, upload-time = "2026-08-28T10:28:02.183Z" }, + { url = "https://files.pythonhosted.org/packages/e3/9a/59a6f6ae6f938c15076be2c21b6cedea973d71bb1349ec84fa485fab82cf/kiwisolver-1.5.1-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:ab620eb663952455271ac37f9aaad86b73c969c02f11f53cea405b38e96a4300", size = 2395634, upload-time = "2026-08-28T10:28:03.977Z" }, + { url = "https://files.pythonhosted.org/packages/e9/2d/8982c1fb7926da5bb7ed60318c3665b5c3f941447271ac982960a11b8637/kiwisolver-1.5.1-cp315-cp315t-win_amd64.whl", hash = "sha256:cb6fae641357ed2f6e533c0d3c6504a4a5703621a50c89459e46051d56b61140", size = 75379, upload-time = "2026-08-28T10:28:06.307Z" }, + { url = "https://files.pythonhosted.org/packages/07/78/ba7b6dfa1708b82b373ac056928a30c545d5c1a627df9839dcec3c6c1881/kiwisolver-1.5.1-cp315-cp315t-win_arm64.whl", hash = "sha256:b390aec180a7c054919c04898835e1c77bced23ea8383eb2c570213bf25d1a86", size = 73011, upload-time = "2026-08-28T10:28:07.578Z" }, + { url = "https://files.pythonhosted.org/packages/a9/c4/1407df7512a5b36cc79840e01710dc575733c461b13ab866cae77eaf87f3/kiwisolver-1.5.1-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:482676e5bd48d70ac99d9fc78863469845421e01184fa83f1f9366dc49f7e974", size = 134002, upload-time = "2026-08-28T10:28:08.881Z" }, + { url = "https://files.pythonhosted.org/packages/16/45/c37a21ad5c0ab581a93c55ad544721aaa1f0ae94edb29c6a678a23d013e6/kiwisolver-1.5.1-graalpy312-graalpy250_312_native-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:072bdb15a3c19a5b5dbc8f8fb1f4e1884bf4f3507eeb4cc6334401274d37a5c0", size = 194292, upload-time = "2026-08-28T10:28:11.06Z" }, + { url = "https://files.pythonhosted.org/packages/a6/c1/69f00d627949580e43d57af0aa465df46868d7c29801c137a55374101294/kiwisolver-1.5.1-graalpy312-graalpy250_312_native-win_amd64.whl", hash = "sha256:a5a00665d1a0e26763a7338d7e911d4598fbc1d50dd0d6b7919b7dc6c5d6569f", size = 73362, upload-time = "2026-08-28T10:28:12.449Z" }, +] + +[[package]] +name = "lark" +version = "1.3.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/da/34/28fff3ab31ccff1fd4f6c7c7b0ceb2b6968d8ea4950663eadcb5720591a0/lark-1.3.1.tar.gz", hash = "sha256:b426a7a6d6d53189d318f2b6236ab5d6429eaf09259f1ca33eb716eed10d2905", size = 382732, upload-time = "2025-10-27T18:25:56.653Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/82/3d/14ce75ef66813643812f3093ab17e46d3a206942ce7376d31ec2d36229e7/lark-1.3.1-py3-none-any.whl", hash = "sha256:c629b661023a014c37da873b4ff58a817398d12635d3bbb2c5a03be7fe5d1e12", size = 113151, upload-time = "2025-10-27T18:25:54.882Z" }, +] + +[[package]] +name = "lazy-loader" +version = "0.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "packaging" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/19/8c/0f2ff2a8b7513e68871a74740c17a504b0488c679b379e6445ebb7bd78dc/lazy_loader-0.6.tar.gz", hash = "sha256:2f4b7824d6401958639008a0cae20c776b61dff619accd6890693e2de8260167", size = 18438, upload-time = "2026-09-21T21:31:32.982Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/23/93/4e45e37f26c820216704b36b8e67cc55c490a7abd287a78a26a2c0e21386/lazy_loader-0.6-py3-none-any.whl", hash = "sha256:77253be3391b06124a0e16105bd663b6c54470af1a9ca8e1cf026f38d58ed056", size = 8791, upload-time = "2026-09-21T21:31:31.632Z" }, +] + +[[package]] +name = "llvmlite" +version = "0.50.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/11/c5/907cec40688a34eb489cded74d555e1ee4af8cf49d83e03dba2c2d4cfe27/llvmlite-0.50.0.tar.gz", hash = "sha256:f2a2cd6ec9ffcc1b7147dea0d7a49efebf17a2b434e0c2844fe175999d571eb4", size = 194522, upload-time = "2026-09-29T18:44:46.782Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d9/1f/2576416b3e9b73f77b8331b7f2e41ce5ae7bbff0489eb16d98099a71693c/llvmlite-0.50.0-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:55f50a6b7c0b8de88b05d6bc407d70a60486ce024013997dc97e202bd187c75b", size = 40534277, upload-time = "2026-09-29T18:42:56.244Z" }, + { url = "https://files.pythonhosted.org/packages/7a/c4/e86f30b2b09c310c02ffdd8afd00f7e127d365131d163c926c98fc3ece22/llvmlite-0.50.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6e8df54380110ea5e9127386e739d2b0829cc6dfa4a24a9195226336c91b06d5", size = 58344485, upload-time = "2026-09-29T18:43:00.67Z" }, + { url = "https://files.pythonhosted.org/packages/4c/72/22b6449e15bec4cc86c62b659e6c625ab777d01e87aaec717ecef440f87a/llvmlite-0.50.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d501e5103076b9a14be885d2574dc2f6793171aa54a853d1244e011d476f1399", size = 59696588, upload-time = "2026-09-29T18:43:04.763Z" }, + { url = "https://files.pythonhosted.org/packages/64/70/f395702c20b514363061055b5bdebe3513e544139e6d412a5c86e8ea0b30/llvmlite-0.50.0-cp312-cp312-win_amd64.whl", hash = "sha256:c20595cc3a76e3c85140fdafbf9246c732ddf8e0e646ba2f4e4881f87567300d", size = 41865553, upload-time = "2026-09-29T18:43:08.29Z" }, + { url = "https://files.pythonhosted.org/packages/a6/86/9cde7ac29e183e994dd2d67c998752c66ff6d714ca61837428e1896c3cc9/llvmlite-0.50.0-cp312-cp312-win_arm64.whl", hash = "sha256:4b78a8b669eda09ca1ff4c1a75003023912092974d3e771d1da0777f1b383bdf", size = 37441845, upload-time = "2026-09-29T18:43:12.054Z" }, + { url = "https://files.pythonhosted.org/packages/b8/1f/1d585b2122bcc9fe1615c0097730baebdef1b80e6acd07fe921ee501576b/llvmlite-0.50.0-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:a32980e3d727b0e56974ad89d0764920048602a75805b8917cc0298e798b0ced", size = 40534276, upload-time = "2026-09-29T18:43:16.012Z" }, + { url = "https://files.pythonhosted.org/packages/21/3e/d5dbbc80bd87c3530bae1127cefce56b36434cc8a7fbbac281309e2af435/llvmlite-0.50.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7dde9836d144c446a303b57b2dd906c35308411eb07f1279c1db581d3d774048", size = 58344486, upload-time = "2026-09-29T18:43:20.663Z" }, + { url = "https://files.pythonhosted.org/packages/ed/c2/5e9d0773f1589397a3ea3dcfa4bbee36e2855ad938d738dd6ff9f505a59b/llvmlite-0.50.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:425845f415a06dc50db08db033c6b568e0d85c4937e932c605a4d49e1514b2da", size = 59696589, upload-time = "2026-09-29T18:43:25.605Z" }, + { url = "https://files.pythonhosted.org/packages/d5/17/894321d44cf94fa5cf921eff4e7ff24c7732c3d702236d40d6055b68a693/llvmlite-0.50.0-cp313-cp313-win_amd64.whl", hash = "sha256:266a6a29be71c3e3a22960ddcedf66b4e0388e5abb6cc4991cc093d6df402ad7", size = 41865552, upload-time = "2026-09-29T18:43:29.755Z" }, + { url = "https://files.pythonhosted.org/packages/b1/d7/c3c3a70f057c18313515af3bd970c1faa348121e2545d6074f22011feca9/llvmlite-0.50.0-cp313-cp313-win_arm64.whl", hash = "sha256:1cb21c420a47dcfa56223228d013c6f9d234e05e06e6819a41638d78bbd78e6c", size = 37441843, upload-time = "2026-09-29T18:43:33.292Z" }, + { url = "https://files.pythonhosted.org/packages/b8/08/eecfccb51bc016de4c1fb69da815738076a186158fa61d3cae1458b8f44a/llvmlite-0.50.0-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:ecdc9fae295da8ac793578a27020515e24d970513143efa227e696582aeb16e6", size = 40534277, upload-time = "2026-09-29T18:43:37.013Z" }, + { url = "https://files.pythonhosted.org/packages/9a/96/011ae57fb82e326a79da1c4767b8206502dbac041068b37f1fbe73893a55/llvmlite-0.50.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:987600ce6f7bd6d808f4bb0ea61a8eff2fd17cf32355691e801eb0a65a7304f0", size = 58344485, upload-time = "2026-09-29T18:43:41.242Z" }, + { url = "https://files.pythonhosted.org/packages/5c/ed/54107648386edf3da7def03d42721c72279f6bc2e17b5274c18955dc5833/llvmlite-0.50.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:33ddf12b1e12d7e551e1c1e6ca8087d0aacc931f480019eb33ef2ab77681da4d", size = 59696587, upload-time = "2026-09-29T18:43:46.132Z" }, + { url = "https://files.pythonhosted.org/packages/d1/af/b2e5f9ee84f05a794e62626d83a934e6fccc7a83740918a90cec85df2d6f/llvmlite-0.50.0-cp314-cp314-win_amd64.whl", hash = "sha256:7ae211012c6849528a5f7cd17a78d8b2421a2813c7b4184d6c0b2ffa89a7d296", size = 42986708, upload-time = "2026-09-29T18:43:51.123Z" }, + { url = "https://files.pythonhosted.org/packages/3b/df/6d9ac4237f78bc81e6778d87ec711c6e5ec0fac73f00907b149c414b48b5/llvmlite-0.50.0-cp314-cp314-win_arm64.whl", hash = "sha256:e94f9066f1257a9cef6c832e6c9de0f140e2bb150de2db39f657b2a5996e0f6b", size = 37441844, upload-time = "2026-09-29T18:43:55.097Z" }, + { url = "https://files.pythonhosted.org/packages/d6/23/0f9d73a3603fee0d32a0f66996e00964154f07681c0b0f9c7212e896cb2d/llvmlite-0.50.0-cp314-cp314t-macosx_12_0_arm64.whl", hash = "sha256:423c8d89d13f7eb4488933d5a86b0fa952927956298cfd0087f6753b5123b5df", size = 40534276, upload-time = "2026-09-29T18:43:59.379Z" }, + { url = "https://files.pythonhosted.org/packages/34/14/45f56e4cf192284ba6cb3020ed775d47dd9c69e7fb605f7523047ab16d7f/llvmlite-0.50.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:944133e9621d1dfbfdaf0fed3234b99f85e6ba27c38f4045acc8f8a5e699a5c0", size = 58344486, upload-time = "2026-09-29T18:44:03.923Z" }, + { url = "https://files.pythonhosted.org/packages/82/f8/45f08fe27bd96fa38a7199024d842d6ef502054f1f824b531d55cd533c81/llvmlite-0.50.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a1d5b6eac064f201b4aa091030282e6f240d8d322dddd7381840731455c3e664", size = 59696589, upload-time = "2026-09-29T18:44:09.376Z" }, + { url = "https://files.pythonhosted.org/packages/90/68/e00620b48cd6fd71369877ddbfa000854450b843c3631be41226e8b8f7b1/llvmlite-0.50.0-cp314-cp314t-win_amd64.whl", hash = "sha256:d88c9b325f5fbefc79d95b1daa8fb96018c40bd2958103eea7334e6c8f17fb40", size = 42986716, upload-time = "2026-09-29T18:44:13.366Z" }, + { url = "https://files.pythonhosted.org/packages/4e/97/78e51381def071781a5ec9ead92e2a55562da5b78043566865e20f30be77/llvmlite-0.50.0-cp315-cp315-macosx_12_0_arm64.whl", hash = "sha256:3f490c0f4800c8ddeee6a607acd037497bf6508586804f4e2f11f53a1ee7fe2d", size = 40534277, upload-time = "2026-09-29T18:44:17.301Z" }, + { url = "https://files.pythonhosted.org/packages/61/83/1beb6169126cd1a8199bae88eb3a79e3be3dd609eb42896d8fa8c38b10c0/llvmlite-0.50.0-cp315-cp315-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d5447a6c39171368edfe28a71f605e6e3edd40a1dc31f5e5c9d50585718ae6d0", size = 58344486, upload-time = "2026-09-29T18:44:21.407Z" }, + { url = "https://files.pythonhosted.org/packages/7e/81/334b11c9ebc52ee5339fe401342b2dc856804996fec3abc5ad70ad053901/llvmlite-0.50.0-cp315-cp315-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f1ac2b9f699c46219fbbd66b304105f5e1b218f05ffac6fe03cd851f93718e58", size = 59696588, upload-time = "2026-09-29T18:44:25.755Z" }, + { url = "https://files.pythonhosted.org/packages/4f/c7/f06fe5d262f0cf0f0c85a85b0a4aaa07cbd85a56192861299fd659af4eb7/llvmlite-0.50.0-cp315-cp315-win_amd64.whl", hash = "sha256:51a4a716db98591f0a1bea34c6548cdb4017731ee5e678ded8cf842dca8af3c5", size = 42986709, upload-time = "2026-09-29T18:44:29.203Z" }, + { url = "https://files.pythonhosted.org/packages/be/f9/670bcb2a7214dcf35c48da581ac8d2949ff50255deb83e13c9cbbef46c05/llvmlite-0.50.0-cp315-cp315t-macosx_12_0_arm64.whl", hash = "sha256:e8cc203c1fd509131cd72b7554413d4a3e5527cc5558c5a7ebe19840018c57c1", size = 40534277, upload-time = "2026-09-29T18:44:32.967Z" }, + { url = "https://files.pythonhosted.org/packages/f3/21/3d108d6c9a87142927073fbc3d82d161f2dbfdeb046063a51edb196d1132/llvmlite-0.50.0-cp315-cp315t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c7d4e2bbb29a860a6e85e22afdb96696241263942a5b214cac3e4b704e1d3abf", size = 58344488, upload-time = "2026-09-29T18:44:36.859Z" }, + { url = "https://files.pythonhosted.org/packages/6e/de/496d19b7a54acc487266ac7fa39d902cddf24998f5266b3aa499c8eacbd6/llvmlite-0.50.0-cp315-cp315t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:afd7b438c60e0f60c4368ec603bb9f20d938a203b5f59b80bbe50c749b4b2f16", size = 59696591, upload-time = "2026-09-29T18:44:40.642Z" }, + { url = "https://files.pythonhosted.org/packages/93/73/72553170eada174775d9a738c471c7be4ab3dc2c06368beeee89e002345c/llvmlite-0.50.0-cp315-cp315t-win_amd64.whl", hash = "sha256:4da0e8c6e6f144b433672a632f75d6b4da7bd4fdb5c3e9981d6ea6741319aeae", size = 42986722, upload-time = "2026-09-29T18:44:44.491Z" }, +] + +[[package]] +name = "markdown-it-py" +version = "4.2.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "mdurl" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/06/ff/7841249c247aa650a76b9ee4bbaeae59370dc8bfd2f6c01f3630c35eb134/markdown_it_py-4.2.0.tar.gz", hash = "sha256:04a21681d6fbb623de53f6f364d352309d4094dd4194040a10fd51833e418d49", size = 82454, upload-time = "2026-05-07T12:08:28.36Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b3/81/4da04ced5a082363ecfa159c010d200ecbd959ae410c10c0264a38cac0f5/markdown_it_py-4.2.0-py3-none-any.whl", hash = "sha256:9f7ebbcd14fe59494226453aed97c1070d83f8d24b6fc3a3bcf9a38092641c4a", size = 91687, upload-time = "2026-05-07T12:08:27.182Z" }, +] + +[[package]] +name = "markupsafe" +version = "3.0.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7e/99/7690b6d4034fffd95959cbe0c02de8deb3098cc577c67bb6a24fe5d7caa7/markupsafe-3.0.3.tar.gz", hash = "sha256:722695808f4b6457b320fdc131280796bdceb04ab50fe1795cd540799ebe1698", size = 80313, upload-time = "2025-09-27T18:37:40.426Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5a/72/147da192e38635ada20e0a2e1a51cf8823d2119ce8883f7053879c2199b5/markupsafe-3.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:d53197da72cc091b024dd97249dfc7794d6a56530370992a5e1a08983ad9230e", size = 11615, upload-time = "2025-09-27T18:36:30.854Z" }, + { url = "https://files.pythonhosted.org/packages/9a/81/7e4e08678a1f98521201c3079f77db69fb552acd56067661f8c2f534a718/markupsafe-3.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1872df69a4de6aead3491198eaf13810b565bdbeec3ae2dc8780f14458ec73ce", size = 12020, upload-time = "2025-09-27T18:36:31.971Z" }, + { url = "https://files.pythonhosted.org/packages/1e/2c/799f4742efc39633a1b54a92eec4082e4f815314869865d876824c257c1e/markupsafe-3.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3a7e8ae81ae39e62a41ec302f972ba6ae23a5c5396c8e60113e9066ef893da0d", size = 24332, upload-time = "2025-09-27T18:36:32.813Z" }, + { url = "https://files.pythonhosted.org/packages/3c/2e/8d0c2ab90a8c1d9a24f0399058ab8519a3279d1bd4289511d74e909f060e/markupsafe-3.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d6dd0be5b5b189d31db7cda48b91d7e0a9795f31430b7f271219ab30f1d3ac9d", size = 22947, upload-time = "2025-09-27T18:36:33.86Z" }, + { url = "https://files.pythonhosted.org/packages/2c/54/887f3092a85238093a0b2154bd629c89444f395618842e8b0c41783898ea/markupsafe-3.0.3-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:94c6f0bb423f739146aec64595853541634bde58b2135f27f61c1ffd1cd4d16a", size = 21962, upload-time = "2025-09-27T18:36:35.099Z" }, + { url = "https://files.pythonhosted.org/packages/c9/2f/336b8c7b6f4a4d95e91119dc8521402461b74a485558d8f238a68312f11c/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:be8813b57049a7dc738189df53d69395eba14fb99345e0a5994914a3864c8a4b", size = 23760, upload-time = "2025-09-27T18:36:36.001Z" }, + { url = "https://files.pythonhosted.org/packages/32/43/67935f2b7e4982ffb50a4d169b724d74b62a3964bc1a9a527f5ac4f1ee2b/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:83891d0e9fb81a825d9a6d61e3f07550ca70a076484292a70fde82c4b807286f", size = 21529, upload-time = "2025-09-27T18:36:36.906Z" }, + { url = "https://files.pythonhosted.org/packages/89/e0/4486f11e51bbba8b0c041098859e869e304d1c261e59244baa3d295d47b7/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:77f0643abe7495da77fb436f50f8dab76dbc6e5fd25d39589a0f1fe6548bfa2b", size = 23015, upload-time = "2025-09-27T18:36:37.868Z" }, + { url = "https://files.pythonhosted.org/packages/2f/e1/78ee7a023dac597a5825441ebd17170785a9dab23de95d2c7508ade94e0e/markupsafe-3.0.3-cp312-cp312-win32.whl", hash = "sha256:d88b440e37a16e651bda4c7c2b930eb586fd15ca7406cb39e211fcff3bf3017d", size = 14540, upload-time = "2025-09-27T18:36:38.761Z" }, + { url = "https://files.pythonhosted.org/packages/aa/5b/bec5aa9bbbb2c946ca2733ef9c4ca91c91b6a24580193e891b5f7dbe8e1e/markupsafe-3.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:26a5784ded40c9e318cfc2bdb30fe164bdb8665ded9cd64d500a34fb42067b1c", size = 15105, upload-time = "2025-09-27T18:36:39.701Z" }, + { url = "https://files.pythonhosted.org/packages/e5/f1/216fc1bbfd74011693a4fd837e7026152e89c4bcf3e77b6692fba9923123/markupsafe-3.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:35add3b638a5d900e807944a078b51922212fb3dedb01633a8defc4b01a3c85f", size = 13906, upload-time = "2025-09-27T18:36:40.689Z" }, + { url = "https://files.pythonhosted.org/packages/38/2f/907b9c7bbba283e68f20259574b13d005c121a0fa4c175f9bed27c4597ff/markupsafe-3.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e1cf1972137e83c5d4c136c43ced9ac51d0e124706ee1c8aa8532c1287fa8795", size = 11622, upload-time = "2025-09-27T18:36:41.777Z" }, + { url = "https://files.pythonhosted.org/packages/9c/d9/5f7756922cdd676869eca1c4e3c0cd0df60ed30199ffd775e319089cb3ed/markupsafe-3.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:116bb52f642a37c115f517494ea5feb03889e04df47eeff5b130b1808ce7c219", size = 12029, upload-time = "2025-09-27T18:36:43.257Z" }, + { url = "https://files.pythonhosted.org/packages/00/07/575a68c754943058c78f30db02ee03a64b3c638586fba6a6dd56830b30a3/markupsafe-3.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:133a43e73a802c5562be9bbcd03d090aa5a1fe899db609c29e8c8d815c5f6de6", size = 24374, upload-time = "2025-09-27T18:36:44.508Z" }, + { url = "https://files.pythonhosted.org/packages/a9/21/9b05698b46f218fc0e118e1f8168395c65c8a2c750ae2bab54fc4bd4e0e8/markupsafe-3.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ccfcd093f13f0f0b7fdd0f198b90053bf7b2f02a3927a30e63f3ccc9df56b676", size = 22980, upload-time = "2025-09-27T18:36:45.385Z" }, + { url = "https://files.pythonhosted.org/packages/7f/71/544260864f893f18b6827315b988c146b559391e6e7e8f7252839b1b846a/markupsafe-3.0.3-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:509fa21c6deb7a7a273d629cf5ec029bc209d1a51178615ddf718f5918992ab9", size = 21990, upload-time = "2025-09-27T18:36:46.916Z" }, + { url = "https://files.pythonhosted.org/packages/c2/28/b50fc2f74d1ad761af2f5dcce7492648b983d00a65b8c0e0cb457c82ebbe/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a4afe79fb3de0b7097d81da19090f4df4f8d3a2b3adaa8764138aac2e44f3af1", size = 23784, upload-time = "2025-09-27T18:36:47.884Z" }, + { url = "https://files.pythonhosted.org/packages/ed/76/104b2aa106a208da8b17a2fb72e033a5a9d7073c68f7e508b94916ed47a9/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:795e7751525cae078558e679d646ae45574b47ed6e7771863fcc079a6171a0fc", size = 21588, upload-time = "2025-09-27T18:36:48.82Z" }, + { url = "https://files.pythonhosted.org/packages/b5/99/16a5eb2d140087ebd97180d95249b00a03aa87e29cc224056274f2e45fd6/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8485f406a96febb5140bfeca44a73e3ce5116b2501ac54fe953e488fb1d03b12", size = 23041, upload-time = "2025-09-27T18:36:49.797Z" }, + { url = "https://files.pythonhosted.org/packages/19/bc/e7140ed90c5d61d77cea142eed9f9c303f4c4806f60a1044c13e3f1471d0/markupsafe-3.0.3-cp313-cp313-win32.whl", hash = "sha256:bdd37121970bfd8be76c5fb069c7751683bdf373db1ed6c010162b2a130248ed", size = 14543, upload-time = "2025-09-27T18:36:51.584Z" }, + { url = "https://files.pythonhosted.org/packages/05/73/c4abe620b841b6b791f2edc248f556900667a5a1cf023a6646967ae98335/markupsafe-3.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:9a1abfdc021a164803f4d485104931fb8f8c1efd55bc6b748d2f5774e78b62c5", size = 15113, upload-time = "2025-09-27T18:36:52.537Z" }, + { url = "https://files.pythonhosted.org/packages/f0/3a/fa34a0f7cfef23cf9500d68cb7c32dd64ffd58a12b09225fb03dd37d5b80/markupsafe-3.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:7e68f88e5b8799aa49c85cd116c932a1ac15caaa3f5db09087854d218359e485", size = 13911, upload-time = "2025-09-27T18:36:53.513Z" }, + { url = "https://files.pythonhosted.org/packages/e4/d7/e05cd7efe43a88a17a37b3ae96e79a19e846f3f456fe79c57ca61356ef01/markupsafe-3.0.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:218551f6df4868a8d527e3062d0fb968682fe92054e89978594c28e642c43a73", size = 11658, upload-time = "2025-09-27T18:36:54.819Z" }, + { url = "https://files.pythonhosted.org/packages/99/9e/e412117548182ce2148bdeacdda3bb494260c0b0184360fe0d56389b523b/markupsafe-3.0.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:3524b778fe5cfb3452a09d31e7b5adefeea8c5be1d43c4f810ba09f2ceb29d37", size = 12066, upload-time = "2025-09-27T18:36:55.714Z" }, + { url = "https://files.pythonhosted.org/packages/bc/e6/fa0ffcda717ef64a5108eaa7b4f5ed28d56122c9a6d70ab8b72f9f715c80/markupsafe-3.0.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4e885a3d1efa2eadc93c894a21770e4bc67899e3543680313b09f139e149ab19", size = 25639, upload-time = "2025-09-27T18:36:56.908Z" }, + { url = "https://files.pythonhosted.org/packages/96/ec/2102e881fe9d25fc16cb4b25d5f5cde50970967ffa5dddafdb771237062d/markupsafe-3.0.3-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8709b08f4a89aa7586de0aadc8da56180242ee0ada3999749b183aa23df95025", size = 23569, upload-time = "2025-09-27T18:36:57.913Z" }, + { url = "https://files.pythonhosted.org/packages/4b/30/6f2fce1f1f205fc9323255b216ca8a235b15860c34b6798f810f05828e32/markupsafe-3.0.3-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b8512a91625c9b3da6f127803b166b629725e68af71f8184ae7e7d54686a56d6", size = 23284, upload-time = "2025-09-27T18:36:58.833Z" }, + { url = "https://files.pythonhosted.org/packages/58/47/4a0ccea4ab9f5dcb6f79c0236d954acb382202721e704223a8aafa38b5c8/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9b79b7a16f7fedff2495d684f2b59b0457c3b493778c9eed31111be64d58279f", size = 24801, upload-time = "2025-09-27T18:36:59.739Z" }, + { url = "https://files.pythonhosted.org/packages/6a/70/3780e9b72180b6fecb83a4814d84c3bf4b4ae4bf0b19c27196104149734c/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:12c63dfb4a98206f045aa9563db46507995f7ef6d83b2f68eda65c307c6829eb", size = 22769, upload-time = "2025-09-27T18:37:00.719Z" }, + { url = "https://files.pythonhosted.org/packages/98/c5/c03c7f4125180fc215220c035beac6b9cb684bc7a067c84fc69414d315f5/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:8f71bc33915be5186016f675cd83a1e08523649b0e33efdb898db577ef5bb009", size = 23642, upload-time = "2025-09-27T18:37:01.673Z" }, + { url = "https://files.pythonhosted.org/packages/80/d6/2d1b89f6ca4bff1036499b1e29a1d02d282259f3681540e16563f27ebc23/markupsafe-3.0.3-cp313-cp313t-win32.whl", hash = "sha256:69c0b73548bc525c8cb9a251cddf1931d1db4d2258e9599c28c07ef3580ef354", size = 14612, upload-time = "2025-09-27T18:37:02.639Z" }, + { url = "https://files.pythonhosted.org/packages/2b/98/e48a4bfba0a0ffcf9925fe2d69240bfaa19c6f7507b8cd09c70684a53c1e/markupsafe-3.0.3-cp313-cp313t-win_amd64.whl", hash = "sha256:1b4b79e8ebf6b55351f0d91fe80f893b4743f104bff22e90697db1590e47a218", size = 15200, upload-time = "2025-09-27T18:37:03.582Z" }, + { url = "https://files.pythonhosted.org/packages/0e/72/e3cc540f351f316e9ed0f092757459afbc595824ca724cbc5a5d4263713f/markupsafe-3.0.3-cp313-cp313t-win_arm64.whl", hash = "sha256:ad2cf8aa28b8c020ab2fc8287b0f823d0a7d8630784c31e9ee5edea20f406287", size = 13973, upload-time = "2025-09-27T18:37:04.929Z" }, + { url = "https://files.pythonhosted.org/packages/33/8a/8e42d4838cd89b7dde187011e97fe6c3af66d8c044997d2183fbd6d31352/markupsafe-3.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:eaa9599de571d72e2daf60164784109f19978b327a3910d3e9de8c97b5b70cfe", size = 11619, upload-time = "2025-09-27T18:37:06.342Z" }, + { url = "https://files.pythonhosted.org/packages/b5/64/7660f8a4a8e53c924d0fa05dc3a55c9cee10bbd82b11c5afb27d44b096ce/markupsafe-3.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c47a551199eb8eb2121d4f0f15ae0f923d31350ab9280078d1e5f12b249e0026", size = 12029, upload-time = "2025-09-27T18:37:07.213Z" }, + { url = "https://files.pythonhosted.org/packages/da/ef/e648bfd021127bef5fa12e1720ffed0c6cbb8310c8d9bea7266337ff06de/markupsafe-3.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f34c41761022dd093b4b6896d4810782ffbabe30f2d443ff5f083e0cbbb8c737", size = 24408, upload-time = "2025-09-27T18:37:09.572Z" }, + { url = "https://files.pythonhosted.org/packages/41/3c/a36c2450754618e62008bf7435ccb0f88053e07592e6028a34776213d877/markupsafe-3.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:457a69a9577064c05a97c41f4e65148652db078a3a509039e64d3467b9e7ef97", size = 23005, upload-time = "2025-09-27T18:37:10.58Z" }, + { url = "https://files.pythonhosted.org/packages/bc/20/b7fdf89a8456b099837cd1dc21974632a02a999ec9bf7ca3e490aacd98e7/markupsafe-3.0.3-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e8afc3f2ccfa24215f8cb28dcf43f0113ac3c37c2f0f0806d8c70e4228c5cf4d", size = 22048, upload-time = "2025-09-27T18:37:11.547Z" }, + { url = "https://files.pythonhosted.org/packages/9a/a7/591f592afdc734f47db08a75793a55d7fbcc6902a723ae4cfbab61010cc5/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:ec15a59cf5af7be74194f7ab02d0f59a62bdcf1a537677ce67a2537c9b87fcda", size = 23821, upload-time = "2025-09-27T18:37:12.48Z" }, + { url = "https://files.pythonhosted.org/packages/7d/33/45b24e4f44195b26521bc6f1a82197118f74df348556594bd2262bda1038/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:0eb9ff8191e8498cca014656ae6b8d61f39da5f95b488805da4bb029cccbfbaf", size = 21606, upload-time = "2025-09-27T18:37:13.485Z" }, + { url = "https://files.pythonhosted.org/packages/ff/0e/53dfaca23a69fbfbbf17a4b64072090e70717344c52eaaaa9c5ddff1e5f0/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:2713baf880df847f2bece4230d4d094280f4e67b1e813eec43b4c0e144a34ffe", size = 23043, upload-time = "2025-09-27T18:37:14.408Z" }, + { url = "https://files.pythonhosted.org/packages/46/11/f333a06fc16236d5238bfe74daccbca41459dcd8d1fa952e8fbd5dccfb70/markupsafe-3.0.3-cp314-cp314-win32.whl", hash = "sha256:729586769a26dbceff69f7a7dbbf59ab6572b99d94576a5592625d5b411576b9", size = 14747, upload-time = "2025-09-27T18:37:15.36Z" }, + { url = "https://files.pythonhosted.org/packages/28/52/182836104b33b444e400b14f797212f720cbc9ed6ba34c800639d154e821/markupsafe-3.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:bdc919ead48f234740ad807933cdf545180bfbe9342c2bb451556db2ed958581", size = 15341, upload-time = "2025-09-27T18:37:16.496Z" }, + { url = "https://files.pythonhosted.org/packages/6f/18/acf23e91bd94fd7b3031558b1f013adfa21a8e407a3fdb32745538730382/markupsafe-3.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:5a7d5dc5140555cf21a6fefbdbf8723f06fcd2f63ef108f2854de715e4422cb4", size = 14073, upload-time = "2025-09-27T18:37:17.476Z" }, + { url = "https://files.pythonhosted.org/packages/3c/f0/57689aa4076e1b43b15fdfa646b04653969d50cf30c32a102762be2485da/markupsafe-3.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:1353ef0c1b138e1907ae78e2f6c63ff67501122006b0f9abad68fda5f4ffc6ab", size = 11661, upload-time = "2025-09-27T18:37:18.453Z" }, + { url = "https://files.pythonhosted.org/packages/89/c3/2e67a7ca217c6912985ec766c6393b636fb0c2344443ff9d91404dc4c79f/markupsafe-3.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1085e7fbddd3be5f89cc898938f42c0b3c711fdcb37d75221de2666af647c175", size = 12069, upload-time = "2025-09-27T18:37:19.332Z" }, + { url = "https://files.pythonhosted.org/packages/f0/00/be561dce4e6ca66b15276e184ce4b8aec61fe83662cce2f7d72bd3249d28/markupsafe-3.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1b52b4fb9df4eb9ae465f8d0c228a00624de2334f216f178a995ccdcf82c4634", size = 25670, upload-time = "2025-09-27T18:37:20.245Z" }, + { url = "https://files.pythonhosted.org/packages/50/09/c419f6f5a92e5fadde27efd190eca90f05e1261b10dbd8cbcb39cd8ea1dc/markupsafe-3.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fed51ac40f757d41b7c48425901843666a6677e3e8eb0abcff09e4ba6e664f50", size = 23598, upload-time = "2025-09-27T18:37:21.177Z" }, + { url = "https://files.pythonhosted.org/packages/22/44/a0681611106e0b2921b3033fc19bc53323e0b50bc70cffdd19f7d679bb66/markupsafe-3.0.3-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f190daf01f13c72eac4efd5c430a8de82489d9cff23c364c3ea822545032993e", size = 23261, upload-time = "2025-09-27T18:37:22.167Z" }, + { url = "https://files.pythonhosted.org/packages/5f/57/1b0b3f100259dc9fffe780cfb60d4be71375510e435efec3d116b6436d43/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e56b7d45a839a697b5eb268c82a71bd8c7f6c94d6fd50c3d577fa39a9f1409f5", size = 24835, upload-time = "2025-09-27T18:37:23.296Z" }, + { url = "https://files.pythonhosted.org/packages/26/6a/4bf6d0c97c4920f1597cc14dd720705eca0bf7c787aebc6bb4d1bead5388/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:f3e98bb3798ead92273dc0e5fd0f31ade220f59a266ffd8a4f6065e0a3ce0523", size = 22733, upload-time = "2025-09-27T18:37:24.237Z" }, + { url = "https://files.pythonhosted.org/packages/14/c7/ca723101509b518797fedc2fdf79ba57f886b4aca8a7d31857ba3ee8281f/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5678211cb9333a6468fb8d8be0305520aa073f50d17f089b5b4b477ea6e67fdc", size = 23672, upload-time = "2025-09-27T18:37:25.271Z" }, + { url = "https://files.pythonhosted.org/packages/fb/df/5bd7a48c256faecd1d36edc13133e51397e41b73bb77e1a69deab746ebac/markupsafe-3.0.3-cp314-cp314t-win32.whl", hash = "sha256:915c04ba3851909ce68ccc2b8e2cd691618c4dc4c4232fb7982bca3f41fd8c3d", size = 14819, upload-time = "2025-09-27T18:37:26.285Z" }, + { url = "https://files.pythonhosted.org/packages/1a/8a/0402ba61a2f16038b48b39bccca271134be00c5c9f0f623208399333c448/markupsafe-3.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4faffd047e07c38848ce017e8725090413cd80cbc23d86e55c587bf979e579c9", size = 15426, upload-time = "2025-09-27T18:37:27.316Z" }, + { url = "https://files.pythonhosted.org/packages/70/bc/6f1c2f612465f5fa89b95bead1f44dcb607670fd42891d8fdcd5d039f4f4/markupsafe-3.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:32001d6a8fc98c8cb5c947787c5d08b0a50663d139f1305bac5885d98d9b40fa", size = 14146, upload-time = "2025-09-27T18:37:28.327Z" }, +] + +[[package]] +name = "matplotlib" +version = "3.11.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "contourpy" }, + { name = "cycler" }, + { name = "fonttools" }, + { name = "kiwisolver" }, + { name = "numpy" }, + { name = "packaging" }, + { name = "pillow" }, + { name = "pyparsing" }, + { name = "python-dateutil" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/49/64/f9a391af28f518b11ad45a8a712353c94a0aefce09d3703200e5c54b610a/matplotlib-3.11.1.tar.gz", hash = "sha256:69647db5746941c793d6e445a4cd349323ffb87d9cc958c2ad84a659b4832d30", size = 32612045, upload-time = "2026-07-18T03:39:46.63Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f2/6c/7ef7ebcb2bd9739b2b66b18b076e077f44bb46fdbe28ca0506edb3c62c79/matplotlib-3.11.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:e15ef41507f3d525f46154ac9e3ae785dacde9f20e593a25de8986267892ef74", size = 9453849, upload-time = "2026-07-18T03:38:19.593Z" }, + { url = "https://files.pythonhosted.org/packages/eb/f8/6d0c312c8d9738e7d9677f09fe5c986b3239e651a7b73a2deb38b65e4a71/matplotlib-3.11.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:21a67b961a6d597bca54fae826cd20695ba4a6e4d05424a08da6e13e3176fd6b", size = 9283113, upload-time = "2026-07-18T03:38:21.95Z" }, + { url = "https://files.pythonhosted.org/packages/c9/cf/b4ad2cc81b6672ea29ea04e64e350a9f9b493b0908ccd884c67eeff8f7b2/matplotlib-3.11.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ba8f811b8ddfac493734d6af0b2dff96919d0c28ca0d641858dab4262777c6ea", size = 10035615, upload-time = "2026-07-18T03:38:24.315Z" }, + { url = "https://files.pythonhosted.org/packages/88/90/4e10e033d9b66589d8ed98b84c95cdbb57033d57c1f41339d7393dbd2f2e/matplotlib-3.11.1-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c52f7ad20ef476806ed212380b1d54d20310c8b86bdc2c9a68b51f0024a44472", size = 10842559, upload-time = "2026-07-18T03:38:26.285Z" }, + { url = "https://files.pythonhosted.org/packages/88/eb/799612d0f8cd3e816a10fec59329fca52cd2353264df80378dfc541ae855/matplotlib-3.11.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:8b14eb22961fe865efb0e4ff167e333e428908b00115a8d800ccb65ee108e481", size = 10927532, upload-time = "2026-07-18T03:38:28.532Z" }, + { url = "https://files.pythonhosted.org/packages/88/89/56649bbaa2fd12e20f3be03dbcc135b0c8676d88bac17977599e3eb442a0/matplotlib-3.11.1-cp312-cp312-win_amd64.whl", hash = "sha256:88a2a27dd9691ae448dfae4b26f59036be90c3c28757edd3553a29559d00859f", size = 9333886, upload-time = "2026-07-18T03:38:30.477Z" }, + { url = "https://files.pythonhosted.org/packages/c1/11/4d124efbbad677b7b7552f6f85a3bd432d4232f95400cea98fcd2ae36ef3/matplotlib-3.11.1-cp312-cp312-win_arm64.whl", hash = "sha256:480194afceca4df2f137c2721227d3cba67121fbf4397b69cee7f83714b0a58a", size = 9007545, upload-time = "2026-07-18T03:38:32.833Z" }, + { url = "https://files.pythonhosted.org/packages/04/6c/4798363b7fb5644e309fe1fac30216e9146c9f70859d80d588c18caf5317/matplotlib-3.11.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:6771b0cd7838c6a857a7209814158c0ad09bfef878db3033dd82d70ad101f191", size = 9454341, upload-time = "2026-07-18T03:38:35.001Z" }, + { url = "https://files.pythonhosted.org/packages/59/98/6acadbe7f98df19d274bc107ac58bb439fa75df82c33dc110d71a4a8501f/matplotlib-3.11.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2abdee5ffa2fe11b2d19f7a5c63b785fb7c28cc46c7bc1814156341d9d1a33e1", size = 9283627, upload-time = "2026-07-18T03:38:37.061Z" }, + { url = "https://files.pythonhosted.org/packages/24/ea/65cec46fe241390ccea1b1754207ee28eb71c5ab866bd5f22fe47e538fa4/matplotlib-3.11.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b0a19dcf73406d3746d25a5ed42d713604c9a3e024d129b102852b0d941cb9f3", size = 10035860, upload-time = "2026-07-18T03:38:39.663Z" }, + { url = "https://files.pythonhosted.org/packages/c7/10/63fdccccbabe002fb0960876baabc5e3f24d9c1bb4cfb25651457f74b3a0/matplotlib-3.11.1-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7389b77ed2ab0552f46d9a90b81b7b8e6dfcdc42adc36c37a0865799843e0e3e", size = 10843594, upload-time = "2026-07-18T03:38:42.144Z" }, + { url = "https://files.pythonhosted.org/packages/98/51/a1155945bff7b91381875022ac1522c5dfdac0d006be8e7df389b3134eae/matplotlib-3.11.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:c90be0b73568da4f662afac580956a76e308437e641b4a45aa08925eeb67d95f", size = 10927962, upload-time = "2026-07-18T03:38:44.302Z" }, + { url = "https://files.pythonhosted.org/packages/0d/3a/3d5e1f42dc761bf53401a62a83ff93389b37de9d2c093b2a3aa49ac34f1b/matplotlib-3.11.1-cp313-cp313-win_amd64.whl", hash = "sha256:68408341f2312836fbbdf6b3c78047f65b2d8752f5fd221c3e72d348f5b34f8b", size = 9334074, upload-time = "2026-07-18T03:38:46.616Z" }, + { url = "https://files.pythonhosted.org/packages/e2/db/3f5ea5a5b64060ef5e1ff60a19170423e41ce21b8497a6fe15a36e0b43e3/matplotlib-3.11.1-cp313-cp313-win_arm64.whl", hash = "sha256:0c1f44890d435c1b4ef52f701ad5828cb450ea97bcc83918fda6be74965d6cd2", size = 9007662, upload-time = "2026-07-18T03:38:49.112Z" }, + { url = "https://files.pythonhosted.org/packages/98/6e/c7ae5e0531425b69c0826b00ebbc264c85cab853f1cd6e096c9983c2cdc1/matplotlib-3.11.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:5e510088c27a89d53580a752f959146893563e63c330e161d159b0fee652af6f", size = 9503790, upload-time = "2026-07-18T03:38:51.527Z" }, + { url = "https://files.pythonhosted.org/packages/92/79/15be162e0a2ed546939674e2e97d0e33ec2447d86d4d4e611fa295bb178c/matplotlib-3.11.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:1524e2bdd48a93557aa47ddcfe9c225dfdd57d5a01a5c49128c20f0632980ee1", size = 9336148, upload-time = "2026-07-18T03:38:53.564Z" }, + { url = "https://files.pythonhosted.org/packages/6a/7f/36ffe144fc4aacfe0e3ed2318f72b6755d1e73b041d619b4d393e60f5a66/matplotlib-3.11.1-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:11664c551345553db92e61cae6cf1376f138f8c47cafdf13b64b18f3e3e9e464", size = 10049244, upload-time = "2026-07-18T03:38:55.911Z" }, + { url = "https://files.pythonhosted.org/packages/ab/5f/55812d68c0a840d3a463638f48c00ab1fe338518ec49a640cb6473b444af/matplotlib-3.11.1-cp313-cp313t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5e1f8922ba31959cf6a9dfb51be64b7f7bc582801a3957dc0c2f3afcd3537adf", size = 10860798, upload-time = "2026-07-18T03:38:58.282Z" }, + { url = "https://files.pythonhosted.org/packages/7a/64/cca444b4eb5e6c768c44fc5e1f0b5211f20ca2b282778051996e996a2bdf/matplotlib-3.11.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:83235693abde86e5e0129998f80ee39fc7f58e6d56a88fafb28a9278833e9d5f", size = 10943282, upload-time = "2026-07-18T03:39:00.465Z" }, + { url = "https://files.pythonhosted.org/packages/e5/0f/a49c329d394f2e9ef38506982107e8b04ecf94dd41a9d8423ff82cc737c7/matplotlib-3.11.1-cp313-cp313t-win_amd64.whl", hash = "sha256:9a076f4fc5cdc43fdf510f5981418d25c2db4973418d9f22d8bb3dc8045ada78", size = 9383532, upload-time = "2026-07-18T03:39:02.468Z" }, + { url = "https://files.pythonhosted.org/packages/e4/50/103e86afb806d8f64d04ede14e4cfc09dbfc25f512421ff85fdd6ebd59cf/matplotlib-3.11.1-cp313-cp313t-win_arm64.whl", hash = "sha256:216fbb93a74add02ddb4cb38ef5348f59ac00b3e84567eaf16598772d40e150a", size = 9059665, upload-time = "2026-07-18T03:39:04.607Z" }, + { url = "https://files.pythonhosted.org/packages/35/04/3079499fa8cb661ea66d13d6439d5a3ae6710a7afd5c7f72e08914f275f8/matplotlib-3.11.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:30c492d4ba9448595b6fd8708c6725963f8148e25c0d8842948da5b05f0ee8d3", size = 9456022, upload-time = "2026-07-18T03:39:07.041Z" }, + { url = "https://files.pythonhosted.org/packages/53/a2/69acfe84ec1f32930e801a5782a07fc5c79c8c6599a507b806d859d5da8e/matplotlib-3.11.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:ac104be2768ffdd8655db9e71b768cbb45f2b9aa7b450cf1595e8f65d3822319", size = 9285475, upload-time = "2026-07-18T03:39:09.562Z" }, + { url = "https://files.pythonhosted.org/packages/d3/b3/31b15a2ca56d4ddd6aaa1c884c2f51cf9a61cfaf5ca6f6fbd6343d38e6df/matplotlib-3.11.1-cp314-cp314-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6be943cb68bc6660ead58c55b3aa6366cba2ef7feb06460fbcce32360376f19f", size = 10847102, upload-time = "2026-07-18T03:39:11.532Z" }, + { url = "https://files.pythonhosted.org/packages/64/0d/a17e966e620545c1548125af0b29ac812dd17b197a18a7462ac12fa859ee/matplotlib-3.11.1-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5af0dcda57d471440a7b5b623e70e0a61003518443d9098f211a96ecfbbc25be", size = 11131087, upload-time = "2026-07-18T03:39:13.764Z" }, + { url = "https://files.pythonhosted.org/packages/97/c5/5e100efdd67abb7de20befaa333612ef9bfc63417fb71398f904f25d083c/matplotlib-3.11.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:3d3fd84082b1afbd9398466c81309e20045be20d48fe0fb18c43504d164cbbb2", size = 10929036, upload-time = "2026-07-18T03:39:16.888Z" }, + { url = "https://files.pythonhosted.org/packages/ce/04/d719a0a36930ecc8dfc801ff340f9dcfc4223f8ca5d39d06b4020032fff8/matplotlib-3.11.1-cp314-cp314-win_amd64.whl", hash = "sha256:9601a1e90be21e4884c53b4f3dc3ee0544654946f9975258d691f1c2e2f119c6", size = 9489571, upload-time = "2026-07-18T03:39:19.449Z" }, + { url = "https://files.pythonhosted.org/packages/48/65/facabdc2f1f6caba7e856db64dfedddca25f7608df07d96a1c8fd114fd3b/matplotlib-3.11.1-cp314-cp314-win_arm64.whl", hash = "sha256:ae30c6109848ac0f9fa36c5d6270938487614c47ba31860bd5361266dabc5685", size = 9164486, upload-time = "2026-07-18T03:39:21.424Z" }, + { url = "https://files.pythonhosted.org/packages/88/dd/18da6cd01cf96354534f98c468a25380c68ce582a2c9dd0cae12b04af4f2/matplotlib-3.11.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:dadfe80797174e2984aae3be0b77594a3c72d2c0a40fbd4a0de48d2728caf3ae", size = 9504876, upload-time = "2026-07-18T03:39:23.633Z" }, + { url = "https://files.pythonhosted.org/packages/79/b0/f0b63555a18b79d038c81fd6126f35fc4dfce0eaff48d96103348c7cf935/matplotlib-3.11.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:89b193b255f4f6f7948dbcee3691f4f341ab05d9a8874a67b45ddb4182922eda", size = 9336120, upload-time = "2026-07-18T03:39:25.797Z" }, + { url = "https://files.pythonhosted.org/packages/c6/dd/f210ec7c4a6f198d5567237048a93d0811fb5a1f1691f13320e592f95b41/matplotlib-3.11.1-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:191163532cdefcb1571ca38a6d7e6474baccde64495783e6ba47aa07ec4b9bbb", size = 10858033, upload-time = "2026-07-18T03:39:27.999Z" }, + { url = "https://files.pythonhosted.org/packages/ec/d2/d6d5324507c5fbb316db48e258c09c2807f3de03d9af47017e120070926f/matplotlib-3.11.1-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9fdf1c818ab05d0e74002091ddaf414478a3a449ec9d51c8976d45be7e3a01e2", size = 11141827, upload-time = "2026-07-18T03:39:30.092Z" }, + { url = "https://files.pythonhosted.org/packages/0f/68/3c22e9320bdce2c4d2f1320643ef706db7a24cb7420eea28b97a2d67f5a8/matplotlib-3.11.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:b937b9dba5f5f6c1e31c47abe2186c865c0914fd18f2ce0dfc39c9adcef5951d", size = 10943061, upload-time = "2026-07-18T03:39:32.356Z" }, + { url = "https://files.pythonhosted.org/packages/f6/4a/907ed190ee81a9df581e0ed5456134fc0f7cb55ffcfda2f9e54ca900761c/matplotlib-3.11.1-cp314-cp314t-win_amd64.whl", hash = "sha256:f2912f647f3fbe1ccf085f91e213936f9101bead81a5e670565b1f1b3712f4fb", size = 9540074, upload-time = "2026-07-18T03:39:34.789Z" }, + { url = "https://files.pythonhosted.org/packages/23/d4/97c19b77e0a6e3b48581185bb65088f431cd20186076cc0f650a1757ea46/matplotlib-3.11.1-cp314-cp314t-win_arm64.whl", hash = "sha256:54d47b8ae8b579633a3902ca5b4ad6c1e132a5626d64447b2e22a66394e79987", size = 9213472, upload-time = "2026-07-18T03:39:37.141Z" }, +] + +[[package]] +name = "matplotlib-inline" +version = "0.2.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/bd/c0/9f7c9a46090390368a4d7bcb76bb87a4a36c421e4c0792cdb53486ffac7a/matplotlib_inline-0.2.2.tar.gz", hash = "sha256:72f3fe8fce36b70d4a5b612f899090cd0401deddc4ea90e1572b9f4bfb058c79", size = 8150, upload-time = "2026-05-08T17:33:33.49Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/41/09/5b161152e2d90f7b87f781c2e1267494aef9c32498df793f73ad0a0a494a/matplotlib_inline-0.2.2-py3-none-any.whl", hash = "sha256:3c821cf1c209f59fb2d2d64abbf5b23b67bcb2210d663f9918dd851c6da1fcf6", size = 9534, upload-time = "2026-05-08T17:33:32.055Z" }, +] + +[[package]] +name = "mdit-py-plugins" +version = "0.6.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markdown-it-py" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/59/fc/f8d0863f8862f25602c0404d75568e89fb6b4109804645e5cdfb1be5cf56/mdit_py_plugins-0.6.1.tar.gz", hash = "sha256:a2bca0f039f39dbd35fb74ae1b5f998608c437463371f0ff7f49a19a17a114d0", size = 56114, upload-time = "2026-05-13T09:03:38.91Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a5/69/6da5581c6a7fede7dc261bf4e67d6adca4196f176b43288b55b3db395b6e/mdit_py_plugins-0.6.1-py3-none-any.whl", hash = "sha256:214c82fb2ac524472ab6a5bcab1de80f73b50443e187f401bfd77efbc7c6481d", size = 66663, upload-time = "2026-05-13T09:03:37.76Z" }, +] + +[[package]] +name = "mdurl" +version = "0.1.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729, upload-time = "2022-08-14T12:40:10.846Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979, upload-time = "2022-08-14T12:40:09.779Z" }, +] + +[[package]] +name = "mistune" +version = "3.3.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7b/92/328a294a6de83bacb95bed01f04e0eaff4e3616ee359fc821a5dfc539b02/mistune-3.3.4.tar.gz", hash = "sha256:58b5c96d6fcb61190dfe5fae498d2b2065f99cf61e9649418fd54cf1ada86dfe", size = 121426, upload-time = "2026-07-22T05:22:30.89Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/77/e4/288365afae98953bc01de09f686f40d8ee84578135aa7767d5d4e60b5278/mistune-3.3.4-py3-none-any.whl", hash = "sha256:ee015381e955e370962968befe1d729ab60fafb6a715ac6751763fbce38c8d4a", size = 66862, upload-time = "2026-07-22T05:22:29.419Z" }, +] + +[[package]] +name = "ml-dtypes" +version = "0.6.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/12/72/307d7c4bd0600601c7133fba5cb78af7db968152951c1cd473abb1cda782/ml_dtypes-0.6.0.tar.gz", hash = "sha256:5e60251d32ced5598972e4d5e06a2f044341f9291402551a3f6f0ec44f9299b0", size = 3032327, upload-time = "2026-08-13T14:14:40.215Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/84/6a/441eb053b078954f7fea284dfb288701884d0a1404d39babb858e1649023/ml_dtypes-0.6.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:5359c588cc62de6f78d7430f06b65853d884955494d86d6ad90b6dd64a3f3a08", size = 565447, upload-time = "2026-08-13T14:14:01.737Z" }, + { url = "https://files.pythonhosted.org/packages/ed/cf/87e8a6c57eed63a91782a0d229856ddf73e138ce004dd71e2799a9dcdb33/ml_dtypes-0.6.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:37da32aa97749251025666d62372775019594577b9c9e9cfda83bed48d778fdb", size = 360227, upload-time = "2026-08-13T14:14:02.938Z" }, + { url = "https://files.pythonhosted.org/packages/c7/f9/7d76c1eae866f5d4636401b31b6d6dd90e4b4ced1fa7cfdfcca9c60e4bd3/ml_dtypes-0.6.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3b4a480aa8fd54a1805b8ac10f3f91763926a74f73c0c364c10f9231854f4170", size = 409890, upload-time = "2026-08-13T14:14:04.248Z" }, + { url = "https://files.pythonhosted.org/packages/ba/db/9c61ec2760b5cbfb1c6558d5c991a6d8fd3271053c32db20506a9a90272b/ml_dtypes-0.6.0-cp312-cp312-win_amd64.whl", hash = "sha256:2a3e9d53925597fbffafd2a37048dadeddd0bdaba58058f6ae0869ed709a184d", size = 439333, upload-time = "2026-08-13T14:14:05.501Z" }, + { url = "https://files.pythonhosted.org/packages/6a/57/780ca3e5ab135b9fbdd8e5441abf5f801b30398371b691291e05ab9834c0/ml_dtypes-0.6.0-cp312-cp312-win_arm64.whl", hash = "sha256:6eaed129a4afe90694b8685e2f9b6294849f5eda4af9a15be83a4326eeebd775", size = 552268, upload-time = "2026-08-13T14:14:06.866Z" }, + { url = "https://files.pythonhosted.org/packages/50/51/fd1582b8f5ed8a9e7be0e161a6ea0dff70cb280479a12178df0b3a72700e/ml_dtypes-0.6.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:084dfe51a7ad58b171f05115f8226ed4233a454a1611371947e806e76f0c638d", size = 565468, upload-time = "2026-08-13T14:14:08.5Z" }, + { url = "https://files.pythonhosted.org/packages/d2/22/20fd70ca6ed12446cb92d5b2a7745bd185f9d8b8cdeeadad976574398e6b/ml_dtypes-0.6.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:28d676428b104bb9717b0928bc5c5129f2d6b51b6727587cc4289e7bf8713cb5", size = 360232, upload-time = "2026-08-13T14:14:09.873Z" }, + { url = "https://files.pythonhosted.org/packages/89/a5/da8ae6c6f1babe4b68e3e55d43d39b529e29774f10e0910671a6b8c86eb8/ml_dtypes-0.6.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:26b1f1fa4f0435a2946859823f6e2bf06796f1e9f10f5a05b08a5e3c8f46ff69", size = 410169, upload-time = "2026-08-13T14:14:11.036Z" }, + { url = "https://files.pythonhosted.org/packages/e2/55/4561acefa00fa4bcbfb82ca6a48578b41f372cd7dd7cdd6eb4720abc2e5f/ml_dtypes-0.6.0-cp313-cp313-win_amd64.whl", hash = "sha256:fb87f46b4f7ad7b5d3ad8f4b452b024bd4229d44c8ff934798c1fe656210387a", size = 439357, upload-time = "2026-08-13T14:14:12.172Z" }, + { url = "https://files.pythonhosted.org/packages/b1/5d/6a01538e507ef0ed5e879985b13a92467bf8960696fb1131f8b8cadc60ff/ml_dtypes-0.6.0-cp313-cp313-win_arm64.whl", hash = "sha256:57ed0d6b4ac5e7868361303a9c57fbcf63b768236ee14456f585dfcf260d0292", size = 552278, upload-time = "2026-08-13T14:14:13.539Z" }, + { url = "https://files.pythonhosted.org/packages/d9/7a/97dc35667b7c9db33c5344c673cd27f87e34771875ea7100138726132ac9/ml_dtypes-0.6.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:84fa136b8602c8c39e3b6cb24918960cd6f36cade7a70376f56770729cd56510", size = 562551, upload-time = "2026-08-13T14:14:14.774Z" }, + { url = "https://files.pythonhosted.org/packages/db/48/77f0ede10558d0d935da2e3276ed7e9c8cc2bad3463b9a0b66b03fc60be2/ml_dtypes-0.6.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:317be9967fb84b0ce4e80e6b1bf71213d21971621cf6f1e501a63602a95297bf", size = 360334, upload-time = "2026-08-13T14:14:16.079Z" }, + { url = "https://files.pythonhosted.org/packages/1c/b1/1831dd8c9b06c013085d31a2ac4f03392d43bd36bfc6ff591a08bcedc1cf/ml_dtypes-0.6.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8f490c003369ce60e514a0c3b12374f05274c101fee1bead6740ec8a564032b0", size = 409966, upload-time = "2026-08-13T14:14:17.477Z" }, + { url = "https://files.pythonhosted.org/packages/ff/ad/9c32c53f823dda3742df19a79c10bc198365937873ea125ba65747440c23/ml_dtypes-0.6.0-cp314-cp314-win_amd64.whl", hash = "sha256:d574c2b28921dc72e869df248f1a278f6eee176a1f237c8642e1a71eb15f3977", size = 457224, upload-time = "2026-08-13T14:14:18.608Z" }, + { url = "https://files.pythonhosted.org/packages/41/3d/dd98205418a13353d41c52bf5326d8cbec515aace46174e23c6ea01c2978/ml_dtypes-0.6.0-cp314-cp314-win_arm64.whl", hash = "sha256:f4adb4af61516510d786cf8c01851a66f6d3ddfa79e1144deaa5b40d8507231e", size = 568378, upload-time = "2026-08-13T14:14:19.843Z" }, + { url = "https://files.pythonhosted.org/packages/65/36/32e7beef3281fed74883451477ad976364323206dbfaa95e948ba788dac7/ml_dtypes-0.6.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:3e169214e0d80ff1c038e1b3017e33c23e43bdf948d42d31de8283111c7e2fa3", size = 590177, upload-time = "2026-08-13T14:14:20.971Z" }, + { url = "https://files.pythonhosted.org/packages/d7/a2/99b3d9b3c984b3bd1e81d8244f1fa2f812e44060d853205b2df6271aa17c/ml_dtypes-0.6.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:573b11f3c327e17ef3826d266e676cf1149a1f3016f822a05f2306c55d8246bf", size = 363142, upload-time = "2026-08-13T14:14:22.463Z" }, + { url = "https://files.pythonhosted.org/packages/0c/fb/8091c0aee7f2712de99c7fd4b1642382644dec6a4962effe4f5b9d16a973/ml_dtypes-0.6.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b76fa1d3f92967d58289ac47ab7458ede66e6f3527fff3e59142aee57d9307cd", size = 430645, upload-time = "2026-08-13T14:14:23.737Z" }, + { url = "https://files.pythonhosted.org/packages/c4/6f/962d2c589513b5930d05b6eae5fbd22ad8bbcf26bb763449f3d8f912360f/ml_dtypes-0.6.0-cp314-cp314t-win_amd64.whl", hash = "sha256:3be9911d953f97cddded4b9961d7b650473b7e55806d20f6176f8356dfe7b38e", size = 465667, upload-time = "2026-08-13T14:14:25.04Z" }, + { url = "https://files.pythonhosted.org/packages/aa/ca/bcb25e246edd19af5fa1cf6267040bd9977a7afca846e6cfd4a52078b44f/ml_dtypes-0.6.0-cp314-cp314t-win_arm64.whl", hash = "sha256:e74266ca8e97874a937b7646378c178025650a236584f7474d10d8086a6edea3", size = 572706, upload-time = "2026-08-13T14:14:26.296Z" }, + { url = "https://files.pythonhosted.org/packages/12/42/46cb442648e3c774d8cb25f2e1e41d496cdcc91fbe9c2a6f75c0b8df7af6/ml_dtypes-0.6.0-cp315-cp315-macosx_10_15_universal2.whl", hash = "sha256:b1b503864fada3f74fabf8d9fee7b4c1cbe956301e6fdece975d5f77c2fce958", size = 562550, upload-time = "2026-08-13T14:14:27.542Z" }, + { url = "https://files.pythonhosted.org/packages/07/56/844eff5af7a2d1a09d75df12c70225c3a6b6a771f95876b2bf5f7d10ad44/ml_dtypes-0.6.0-cp315-cp315-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9c6ad60af4102789a5c09824004beade2f7f28cd1cd581ee5c170d9dc2fbb00e", size = 360332, upload-time = "2026-08-13T14:14:28.767Z" }, + { url = "https://files.pythonhosted.org/packages/b6/29/b7165a3a76364a5baa6aa4ee82a0adf73a3c014b8cd126120b62cc087992/ml_dtypes-0.6.0-cp315-cp315-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d4f1b9329a251e4affe3bb58f4d3e2db22a714396fd7ffb40d0b5db423c24d17", size = 409964, upload-time = "2026-08-13T14:14:30.023Z" }, + { url = "https://files.pythonhosted.org/packages/c8/2e/f61c54a0544b6a170ac1bb89bcf406af53fb2deffc5476b6d2d3df5ba13e/ml_dtypes-0.6.0-cp315-cp315-win_amd64.whl", hash = "sha256:488c99ab181a2f59d9ec3b12c5fa11ec904e92be2c4ba18cded54dd7501208fe", size = 457249, upload-time = "2026-08-13T14:14:31.213Z" }, + { url = "https://files.pythonhosted.org/packages/63/00/bee1bc9faa02a46e7a851019fd23f47ca1f906609edbec8b6ba5decc3cc3/ml_dtypes-0.6.0-cp315-cp315-win_arm64.whl", hash = "sha256:de9d14748dbf3968951436ef514a29c9d1fe438aa680d110134ee2f7a9f9df18", size = 568381, upload-time = "2026-08-13T14:14:32.548Z" }, + { url = "https://files.pythonhosted.org/packages/72/f7/9a5edede28f73185fd51d75030ef7f11d76997bab3a92427d986e54fe2eb/ml_dtypes-0.6.0-cp315-cp315t-macosx_10_15_universal2.whl", hash = "sha256:e25bb3b0ad1217b60626e4ed45b10ca170c41d99fbe44a12bebc1e07ec4aad55", size = 589877, upload-time = "2026-08-13T14:14:33.695Z" }, + { url = "https://files.pythonhosted.org/packages/fd/81/d5924a141b850b606eb027493c9c3ca3c665cca5163af3f5b6e5e3345503/ml_dtypes-0.6.0-cp315-cp315t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:31f1ce979d31a357e95aa81812f20412c8c954fa43c44ee3ead1e1c8a78575ef", size = 362788, upload-time = "2026-08-13T14:14:34.996Z" }, + { url = "https://files.pythonhosted.org/packages/59/8f/3298e3f334832bc28dd144af6b99cdc93502a8687e71922ea68b0a319929/ml_dtypes-0.6.0-cp315-cp315t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e2d6149f3a57f405bcad5fb41e03218b8373936253f23e1ca84c0108abbc3392", size = 430823, upload-time = "2026-08-13T14:14:36.44Z" }, + { url = "https://files.pythonhosted.org/packages/93/d2/f2dbf118f42ce4c325a139c9236737f436b7f8e00cd18701c99ef2405e6f/ml_dtypes-0.6.0-cp315-cp315t-win_amd64.whl", hash = "sha256:ce7563e0b1a4482cbc1b4a6272145e54e4489e54fe7428f94908c3d87103abfa", size = 465119, upload-time = "2026-08-13T14:14:37.776Z" }, + { url = "https://files.pythonhosted.org/packages/5a/ff/bda40387b5c5c64254595f4d81a12351770856acc5de4e6d43606a31f161/ml_dtypes-0.6.0-cp315-cp315t-win_arm64.whl", hash = "sha256:f6cb525101b6b903779188c1e9e9490c343b455ab822883e02cf01e5547338d2", size = 572666, upload-time = "2026-08-13T14:14:38.993Z" }, +] + +[[package]] +name = "mpmath" +version = "1.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e0/47/dd32fa426cc72114383ac549964eecb20ecfd886d1e5ccf5340b55b02f57/mpmath-1.3.0.tar.gz", hash = "sha256:7a28eb2a9774d00c7bc92411c19a89209d5da7c4c9a9e227be8330a23a25b91f", size = 508106, upload-time = "2023-03-07T16:47:11.061Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/43/e3/7d92a15f894aa0c9c4b49b8ee9ac9850d6e63b03c9c32c0367a13ae62209/mpmath-1.3.0-py3-none-any.whl", hash = "sha256:a0b2b9fe80bbcd81a6647ff13108738cfb482d481d826cc0e02f5b35e5c88d2c", size = 536198, upload-time = "2023-03-07T16:47:09.197Z" }, +] + +[[package]] +name = "multiprocess" +version = "0.70.19" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "dill" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a2/f2/e783ac7f2aeeed14e9e12801f22529cc7e6b7ab80928d6dcce4e9f00922d/multiprocess-0.70.19.tar.gz", hash = "sha256:952021e0e6c55a4a9fe4cd787895b86e239a40e76802a789d6305398d3975897", size = 2079989, upload-time = "2026-01-19T06:47:39.744Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e3/45/8004d1e6b9185c1a444d6b55ac5682acf9d98035e54386d967366035a03a/multiprocess-0.70.19-py310-none-any.whl", hash = "sha256:97404393419dcb2a8385910864eedf47a3cadf82c66345b44f036420eb0b5d87", size = 134948, upload-time = "2026-01-19T06:47:32.325Z" }, + { url = "https://files.pythonhosted.org/packages/86/c2/dec9722dc3474c164a0b6bcd9a7ed7da542c98af8cabce05374abab35edd/multiprocess-0.70.19-py311-none-any.whl", hash = "sha256:928851ae7973aea4ce0eaf330bbdafb2e01398a91518d5c8818802845564f45c", size = 144457, upload-time = "2026-01-19T06:47:33.711Z" }, + { url = "https://files.pythonhosted.org/packages/71/70/38998b950a97ea279e6bd657575d22d1a2047256caf707d9a10fbce4f065/multiprocess-0.70.19-py312-none-any.whl", hash = "sha256:3a56c0e85dd5025161bac5ce138dcac1e49174c7d8e74596537e729fd5c53c28", size = 150281, upload-time = "2026-01-19T06:47:35.037Z" }, + { url = "https://files.pythonhosted.org/packages/7f/74/d2c27e03cb84251dfe7249b8e82923643c6d48fa4883b9476b025e7dc7eb/multiprocess-0.70.19-py313-none-any.whl", hash = "sha256:8d5eb4ec5017ba2fab4e34a747c6d2c2b6fecfe9e7236e77988db91580ada952", size = 156414, upload-time = "2026-01-19T06:47:35.915Z" }, + { url = "https://files.pythonhosted.org/packages/a0/61/af9115673a5870fd885247e2f1b68c4f1197737da315b520a91c757a861a/multiprocess-0.70.19-py314-none-any.whl", hash = "sha256:e8cc7fbdff15c0613f0a1f1f8744bef961b0a164c0ca29bdff53e9d2d93c5e5f", size = 160318, upload-time = "2026-01-19T06:47:37.497Z" }, + { url = "https://files.pythonhosted.org/packages/7e/82/69e539c4c2027f1e1697e09aaa2449243085a0edf81ae2c6341e84d769b6/multiprocess-0.70.19-py39-none-any.whl", hash = "sha256:0d4b4397ed669d371c81dcd1ef33fd384a44d6c3de1bd0ca7ac06d837720d3c5", size = 133477, upload-time = "2026-01-19T06:47:38.619Z" }, +] + +[[package]] +name = "mypy-extensions" +version = "1.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a2/6e/371856a3fb9d31ca8dac321cda606860fa4548858c0cc45d9d1d4ca2628b/mypy_extensions-1.1.0.tar.gz", hash = "sha256:52e68efc3284861e772bbcd66823fde5ae21fd2fdb51c62a211403730b916558", size = 6343, upload-time = "2025-04-22T14:54:24.164Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/79/7b/2c79738432f5c924bef5071f933bcc9efd0473bac3b4aa584a6f7c1c8df8/mypy_extensions-1.1.0-py3-none-any.whl", hash = "sha256:1be4cccdb0f2482337c4743e60421de3a356cd97508abadd57d47403e94f5505", size = 4963, upload-time = "2025-04-22T14:54:22.983Z" }, +] + +[[package]] +name = "myst-nb" +version = "1.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "importlib-metadata" }, + { name = "ipykernel" }, + { name = "ipython" }, + { name = "jupyter-cache" }, + { name = "myst-parser" }, + { name = "nbclient" }, + { name = "nbformat" }, + { name = "pyyaml" }, + { name = "sphinx" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/bd/b4/ff1abeea67e8cfe0a8c033389f6d1d8b0bfecfd611befb5cbdeab884fce6/myst_nb-1.4.0.tar.gz", hash = "sha256:c145598de62446a6fd009773dd071a40d3b76106ace780de1abdfc6961f614c2", size = 82285, upload-time = "2026-03-02T21:14:56.95Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/94/93/0a378b48488879a1d925b42a804edfc6e0cd0ef854220f2dce738a46e7e9/myst_nb-1.4.0-py3-none-any.whl", hash = "sha256:0e2c86e7d3b82c3aa51383f82d6268f7714f3b772c23a796ab09538a8e68b4e4", size = 82555, upload-time = "2026-03-02T21:14:55.652Z" }, +] + +[[package]] +name = "myst-parser" +version = "5.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "docutils" }, + { name = "jinja2" }, + { name = "markdown-it-py" }, + { name = "mdit-py-plugins" }, + { name = "pyyaml" }, + { name = "sphinx" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/21/dc/603751677fff302f34396e206b610f556a59d7fe58b9a2145f54e96b48e8/myst_parser-5.1.0.tar.gz", hash = "sha256:ab69322dc6719dcc7f296479dbb70181b66df6ed315064f92dbc85c0e1bf2f02", size = 101182, upload-time = "2026-05-13T09:38:19.361Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/09/dc/f3dfb7488b770f3f67e6545085bf2abea5172e88f57b8ad25ef860ca704c/myst_parser-5.1.0-py3-none-any.whl", hash = "sha256:9c91c52b3cdb4d94a6506e4fab4e2f296c7623a0da0dcbe6de1565c3dad67a8a", size = 85817, upload-time = "2026-05-13T09:38:17.904Z" }, +] + +[[package]] +name = "narwhals" +version = "2.26.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/35/68/5351e34623d253423240ea7de3f8fc74fa8ab14b1ab3c0ec4ac8997413c9/narwhals-2.26.0.tar.gz", hash = "sha256:6b9cadca82f375c7e4cf584fdc86ca25da54827307a9c58f94547ee6104b82dd", size = 686970, upload-time = "2026-09-08T13:32:08.964Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/40/b5/1b84b2c784db76d69442334bc8b8748c840f13ca53be086f4f250ad4a0bc/narwhals-2.26.0-py3-none-any.whl", hash = "sha256:29326d74f107c347fd1009bd58e38d9f7c7c5b51e6de97bc93dbc325d9038b54", size = 474034, upload-time = "2026-09-08T13:32:07.159Z" }, +] + +[[package]] +name = "nbclient" +version = "0.11.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-client" }, + { name = "jupyter-core" }, + { name = "nbformat" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/28/a5/b3bae4b590c0cbcada2c63a34f7580024e834a8ba213e949a2f906705787/nbclient-0.11.0.tar.gz", hash = "sha256:04a134a5b087f2c5887f228aca155db50169b8cd9334dee6942c8e927e56081a", size = 62535, upload-time = "2026-06-05T07:52:41.746Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/36/c9/94d73e5a01c5b926c3fa2496e97d7a8dc28ed5a77c0b2ed712f1a62e6694/nbclient-0.11.0-py3-none-any.whl", hash = "sha256:ef7fa0d59d6e1d41103933d8a445a18d5de860ca6b613b87b8574accdb3c2895", size = 25288, upload-time = "2026-06-05T07:52:40.115Z" }, +] + +[[package]] +name = "nbconvert" +version = "7.17.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "beautifulsoup4" }, + { name = "bleach", extra = ["css"] }, + { name = "defusedxml" }, + { name = "jinja2" }, + { name = "jupyter-core" }, + { name = "jupyterlab-pygments" }, + { name = "markupsafe" }, + { name = "mistune" }, + { name = "nbclient" }, + { name = "nbformat" }, + { name = "packaging" }, + { name = "pandocfilters" }, + { name = "pygments" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/01/b1/708e53fe2e429c103c6e6e159106bcf0357ac41aa4c28772bd8402339051/nbconvert-7.17.1.tar.gz", hash = "sha256:34d0d0a7e73ce3cbab6c5aae8f4f468797280b01fd8bd2ca746da8569eddd7d2", size = 865311, upload-time = "2026-04-08T00:44:14.914Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/67/f8/bb0a9d5f46819c821dc1f004aa2cc29b1d91453297dbf5ff20470f00f193/nbconvert-7.17.1-py3-none-any.whl", hash = "sha256:aa85c087b435e7bf1ffd03319f658e285f2b89eccab33bc1ba7025495ab3e7c8", size = 261927, upload-time = "2026-04-08T00:44:12.845Z" }, +] + +[[package]] +name = "nbformat" +version = "5.11.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "fastjsonschema" }, + { name = "jsonschema" }, + { name = "jupyter-core" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/31/72/b3446efab8756e7df4b8ec587f8e611cb5a7249e4323db480802f1d3be04/nbformat-5.11.1.tar.gz", hash = "sha256:32d4521c68c6e7d5b29c76defaeed9f42ea733142b9b19f88277ce10390b9c4d", size = 147775, upload-time = "2026-08-17T08:10:51.942Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1a/69/ee613f74085ca7103f79cd08d579c4f3177d1d26e5d3d9528d2d6536a707/nbformat-5.11.1-py3-none-any.whl", hash = "sha256:cc6698fa75f4fab8755ead786317815f13a6fee3b53311c0abb1a8b51d52f7ec", size = 79849, upload-time = "2026-08-17T08:10:50.18Z" }, +] + +[[package]] +name = "nbmake" +version = "1.5.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "ipykernel" }, + { name = "nbclient" }, + { name = "nbformat" }, + { name = "pygments" }, + { name = "pytest" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/43/9a/aae201cee5639e1d562b3843af8fd9f8d018bb323e776a2b973bdd5fc64b/nbmake-1.5.5.tar.gz", hash = "sha256:239dc868ea13a7c049746e2aba2c229bd0f6cdbc6bfa1d22f4c88638aa4c5f5c", size = 85929, upload-time = "2024-12-23T18:33:46.774Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/eb/be/b257e12f9710819fde40adc972578bee6b72c5992da1bc8369bef2597756/nbmake-1.5.5-py3-none-any.whl", hash = "sha256:c6fbe6e48b60cacac14af40b38bf338a3b88f47f085c54ac5b8639ff0babaf4b", size = 12818, upload-time = "2024-12-23T18:33:44.566Z" }, +] + +[[package]] +name = "nbqa" +version = "1.9.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "autopep8" }, + { name = "ipython" }, + { name = "tokenize-rt" }, + { name = "tomli" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/aa/76/62d2609924cf34445148cd6b5de694cf64c179cc416cac93182579620e57/nbqa-1.9.1.tar.gz", hash = "sha256:a1f4bcf587c597302fed295951001fc4e1be4ce0e77e1ab1b25ac2fbe3db0cdd", size = 38348, upload-time = "2024-11-10T12:21:58.333Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/28/88/4789719fbbe166d12d345b3ac66b96105f10001b16e00a9765ba29261a21/nbqa-1.9.1-py3-none-any.whl", hash = "sha256:95552d2f6c2c038136252a805aa78d85018aef922586270c3a074332737282e5", size = 35259, upload-time = "2024-11-10T12:21:56.731Z" }, +] + +[[package]] +name = "nest-asyncio2" +version = "1.7.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b4/73/731debf26e27e0a0323d7bda270dc2f634b398e38f040a09da1f4351d0aa/nest_asyncio2-1.7.2.tar.gz", hash = "sha256:1921d70b92cc4612c374928d081552efb59b83d91b2b789d935c665fa01729a8", size = 14743, upload-time = "2026-02-13T00:34:04.386Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c5/3c/3179b85b0e1c3659f0369940200cd6d0fa900e6cefcc7ea0bc6dd0e29ffb/nest_asyncio2-1.7.2-py3-none-any.whl", hash = "sha256:f5dfa702f3f81f6a03857e9a19e2ba578c0946a4ad417b4c50a24d7ba641fe01", size = 7843, upload-time = "2026-02-13T00:34:02.691Z" }, +] + +[[package]] +name = "networkx" +version = "3.7" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/dc/76/3af777226b63a5e64a6b36b1ec5855c14e2b94a37096d4760e595fc43511/networkx-3.7.tar.gz", hash = "sha256:fd77a511bd90f39f3d016351345b52cf5319b813bdca01de3f755d3cca62e96a", size = 1866482, upload-time = "2026-09-21T16:45:16.974Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7e/cd/fe58041e9011f307c490e3e17dd48cc516448f7c698a3f2d9d9d65d7e6a8/networkx-3.7-py3-none-any.whl", hash = "sha256:e3fd2c13a7814cee3746340d8d7f8598a67f16a58bf47fb7f8793fab6efca1b0", size = 2142205, upload-time = "2026-09-21T16:45:14.609Z" }, +] + +[[package]] +name = "notebook" +version = "7.6.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-builder" }, + { name = "jupyter-server" }, + { name = "jupyterlab" }, + { name = "jupyterlab-server" }, + { name = "notebook-shim" }, + { name = "tornado" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/31/d9/5c76de84e96e1cf8aae3fce930875e0615e14f3557bbcdb634aab52da9d3/notebook-7.6.2.tar.gz", hash = "sha256:cc02b5f0bb972160cccfe44ad8a1a202036206ba3439469c514f03aefa9ae807", size = 5500147, upload-time = "2026-08-11T13:21:16.632Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5c/fd/3e552ff5b24dd305c6e9a10e8645e29c03091c317429f326ae10dbae1ac6/notebook-7.6.2-py3-none-any.whl", hash = "sha256:5fe9e09c335cb4b7de21627b860f77210e70e54b1fb1276ad942a4a7e1d858d3", size = 5547102, upload-time = "2026-08-11T13:21:13.302Z" }, +] + +[[package]] +name = "notebook-shim" +version = "0.2.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-server" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/54/d2/92fa3243712b9a3e8bafaf60aac366da1cada3639ca767ff4b5b3654ec28/notebook_shim-0.2.4.tar.gz", hash = "sha256:b4b2cfa1b65d98307ca24361f5b30fe785b53c3fd07b7a47e89acb5e6ac638cb", size = 13167, upload-time = "2024-02-14T23:35:18.353Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f9/33/bd5b9137445ea4b680023eb0469b2bb969d61303dedb2aac6560ff3d14a1/notebook_shim-0.2.4-py3-none-any.whl", hash = "sha256:411a5be4e9dc882a074ccbcae671eda64cceb068767e9a3419096986560e1cef", size = 13307, upload-time = "2024-02-14T23:35:16.286Z" }, +] + +[[package]] +name = "numba" +version = "0.68.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "llvmlite" }, + { name = "numpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/4e/cd/e8280f9ffa30fea9fabc5341223701231fcc5d53a31f51419d42d4bec3a6/numba-0.68.0.tar.gz", hash = "sha256:8a781de54b980b98f43bff7f1093701b5f07c80d031c7cfa8a87493d8bf73f2d", size = 2855363, upload-time = "2026-09-30T15:05:44.721Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c5/cb/b6a39189f1f342baa04ad1055bb5f63ec4061ec1f80f6b34e90c68fe1e7f/numba-0.68.0-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:0fdaa2f0256862ebbcd9632ef01ba2a4b94e6d116029e5051a92340d4050a501", size = 2760509, upload-time = "2026-09-30T15:04:53.181Z" }, + { url = "https://files.pythonhosted.org/packages/af/4d/aa2cefeef784c5695790931938944f76ee66d3c7c640f62326f64642f1c6/numba-0.68.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e3ee1f49b62efbbb804f731f2bd602bd1f8b8d3cc13009f25d69955675f82407", size = 3600404, upload-time = "2026-09-30T15:04:55.11Z" }, + { url = "https://files.pythonhosted.org/packages/6f/40/2211b4ff48cccfb21d4c38fb56788d7a975189883efb8d549be9d51aba7d/numba-0.68.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:51fe913a70fe9a7a0b193757ff977a9e96c82ae936ae388aec8990814fffdf9d", size = 3888027, upload-time = "2026-09-30T15:04:57.698Z" }, + { url = "https://files.pythonhosted.org/packages/7e/2b/1b1f8b118cec28513665d8a53ff4f037d6c05720bd9e6f32f947c93c367f/numba-0.68.0-cp312-cp312-win_amd64.whl", hash = "sha256:530961dc7e41ee358eca2b828baf7b645ce6fa466d778bb9dc73855dd103c4f7", size = 2830891, upload-time = "2026-09-30T15:04:59.747Z" }, + { url = "https://files.pythonhosted.org/packages/97/0b/02626d27333ce1f67516a059e22d65f8f2309f227d3b828d2599183d5dc9/numba-0.68.0-cp312-cp312-win_arm64.whl", hash = "sha256:25aa7021e163701f9b3e8e77be81836a4b399500eef073d75bc906ad5eff46e9", size = 2812331, upload-time = "2026-09-30T15:05:01.802Z" }, + { url = "https://files.pythonhosted.org/packages/a2/4d/42754c94f8f909b9981fd44d28292a93bca6429d93f3e1ae58ac7de9b08b/numba-0.68.0-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:b8b29602f57df06c724fc53b1740887bc4332f202206771d46e47b25b485e904", size = 2760360, upload-time = "2026-09-30T15:05:04.386Z" }, + { url = "https://files.pythonhosted.org/packages/b3/1c/8bae32109a826a49666a9645012b98d6e09ad496932a877c97a2c39dde50/numba-0.68.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:df6f881c5695f472873d0979bab54261959b3174b6c98a71f6f8a43c3e088985", size = 3560908, upload-time = "2026-09-30T15:05:06.832Z" }, + { url = "https://files.pythonhosted.org/packages/aa/b1/0b504ae34d1b79a6482a0ffcbfd1b103dde02329c11525033e02633f7984/numba-0.68.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:be647fbc60c18c0323b34479f80173879654894eec58ad061f4b1901e294d854", size = 3848615, upload-time = "2026-09-30T15:05:08.976Z" }, + { url = "https://files.pythonhosted.org/packages/8d/a5/06d1dd4553dcc71a3a18defe9e6e26e3c011b566bc9060d4f6e4bca0e0ed/numba-0.68.0-cp313-cp313-win_amd64.whl", hash = "sha256:bf7435c81912e271a28a19c348ada5b3986e2409f95a067533c5f4aab8709295", size = 2830730, upload-time = "2026-09-30T15:05:11.232Z" }, + { url = "https://files.pythonhosted.org/packages/93/d8/6b01de5fa7b4c3866c0fb680833fd58b4fc48d1e7febb46e992f0b0f0e7b/numba-0.68.0-cp313-cp313-win_arm64.whl", hash = "sha256:50e3c81d8bf6956c7d7330a985bf1468efaa9e4c4539c9fa0ac6c7866ea6e369", size = 2812090, upload-time = "2026-09-30T15:05:13.455Z" }, + { url = "https://files.pythonhosted.org/packages/6e/71/a9031907dd0fba6cfce34004398a05f090b692be811dd1f38fdd874dd4e1/numba-0.68.0-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:bfc890c9ca517823dfae0444595ef50d883ade9d3e17759d9a7650e5d128d950", size = 2760551, upload-time = "2026-09-30T15:05:15.753Z" }, + { url = "https://files.pythonhosted.org/packages/74/70/c03aebc576ded2204e5bde9b86b215f0590a81261af333d4239b9f0aed0f/numba-0.68.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:34ccf54fd9c1d5f4ba00073b81bc492a681f5437c62917fe29813f457564e312", size = 3561561, upload-time = "2026-09-30T15:05:18.266Z" }, + { url = "https://files.pythonhosted.org/packages/3d/5f/2bd2fd4b99b0b5e76fea2f1fe149e05a7ec19a9a177758688bb82c7e3126/numba-0.68.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ea11c865265e39a6019e2f0fe62743825127b3b7bc4815916f5d5121fd9b262b", size = 3848766, upload-time = "2026-09-30T15:05:20.541Z" }, + { url = "https://files.pythonhosted.org/packages/0c/41/3e3528f3b0f9ffae69310d2e71f81ff74d272ee3b6c0600c4f4abaa31a80/numba-0.68.0-cp314-cp314-win_amd64.whl", hash = "sha256:9c03de7085f08ba11ab2444f252e822c14cee5fa02b73e84d5afd5e28b2bce0f", size = 2832584, upload-time = "2026-09-30T15:05:22.621Z" }, + { url = "https://files.pythonhosted.org/packages/8a/9d/1fe8be8f3a43d339222a4aed59be0b8f4920f10465d4606c0428250c63f7/numba-0.68.0-cp314-cp314-win_arm64.whl", hash = "sha256:f58c13a6e9bfef062311cb0d3c19f6c159b901213daa325e1db473946010cec7", size = 2812334, upload-time = "2026-09-30T15:05:24.848Z" }, + { url = "https://files.pythonhosted.org/packages/89/3b/e0e31617568553ca2b18bdf43844c44893dfb6620bde9a88296c257c5a81/numba-0.68.0-cp314-cp314t-macosx_12_0_arm64.whl", hash = "sha256:79160dc2a3ff0e02aaada2c385faa6de73d71a11f06419d29bb0a90042d243a3", size = 2763380, upload-time = "2026-09-30T15:05:27.064Z" }, + { url = "https://files.pythonhosted.org/packages/20/92/405b416800424b005c179c5b6417eee2aac1933839257ca50c855397774f/numba-0.68.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1a3aa5558ba1c316020a0c2f6042be6ae063cfc6eb0c7badb3a0c77d2b5308b7", size = 3604721, upload-time = "2026-09-30T15:05:29.164Z" }, + { url = "https://files.pythonhosted.org/packages/e1/52/fc100dc163e12ba6a8df4c4f6e34f55d24dc6e97095f935996406d8cc946/numba-0.68.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a08750c81fd5c2d9f2c169a73114efb907159401dde9ef4a3b629fa45e097cb7", size = 3887891, upload-time = "2026-09-30T15:05:31.234Z" }, + { url = "https://files.pythonhosted.org/packages/e1/e0/f2e074c5bf26f236c34075d390e77ed2a787c7350791b39b099b151e2033/numba-0.68.0-cp314-cp314t-win_amd64.whl", hash = "sha256:cad7d5f6fe8eb42a69c500d36c94a61d094f3b91a7a5581a31d1df2eb925d33a", size = 2838113, upload-time = "2026-09-30T15:05:33.274Z" }, + { url = "https://files.pythonhosted.org/packages/a5/85/d7cee7a6c65634bd25cb0109585785e5c8338f44db4b191c30291d9c7968/numba-0.68.0-cp315-cp315-macosx_12_0_arm64.whl", hash = "sha256:39f935bc854be87784675d9674f5503e56df5a501c95c95bdfb6b3c0b4b9ed1b", size = 2760868, upload-time = "2026-09-30T15:05:35.662Z" }, + { url = "https://files.pythonhosted.org/packages/d6/79/312e0cf6e835f700d42a223c1bd4a24b232892bded1ddf5e40bb3a329f55/numba-0.68.0-cp315-cp315-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7cec6809fe93824e243a8a8c93966b0bb5874a3b7c24c1194c3bafee0ab11f39", size = 3568127, upload-time = "2026-09-30T15:05:37.967Z" }, + { url = "https://files.pythonhosted.org/packages/5e/05/f31cd9e40f6d4ec6de38959e4736a917aa9d115fecc4a1979aceedcc083b/numba-0.68.0-cp315-cp315-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c1f1180e0332ad5143905288325485b52ac76102330811dc6f2c10088cf4cedc", size = 3853913, upload-time = "2026-09-30T15:05:40.247Z" }, + { url = "https://files.pythonhosted.org/packages/6c/28/059b2d1ea5616a5712fd722b2ec8e8278d14e4e4eb8845d36fe1658e6be8/numba-0.68.0-cp315-cp315-win_amd64.whl", hash = "sha256:a2d21bb9c4b4818a1e71721ebd19172f488591d548f08453593348b7048ba1fb", size = 2831865, upload-time = "2026-09-30T15:05:42.306Z" }, +] + +[[package]] +name = "numpy" +version = "2.5.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/13/01/11703282db468b85f6f7b8c7f22d058de5970d5c7e60a3a8aaa313c3de36/numpy-2.5.3.tar.gz", hash = "sha256:df2d5874ff183595a4ba404edd04f6bd9b5505c1d7708573f6a6c17489a67563", size = 20791231, upload-time = "2026-09-06T16:27:47.073Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d6/50/8fdbb16af64895706a45f06a4068e29db732ec180f3c1375f14123359138/numpy-2.5.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:cb189f09db39283b26bfd061ec16189e14f71c6755207f72a0f7540867afe5b9", size = 16994982, upload-time = "2026-09-06T16:24:29.244Z" }, + { url = "https://files.pythonhosted.org/packages/60/39/789131c1188c078dcb3a1692e72e1e050c68b88ffe72c9ccaac9bcd7a9cd/numpy-2.5.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f59a878c33d6b88122d80d239bb3b845d58708750b0cb06a09aebb9b18ec696c", size = 12009327, upload-time = "2026-09-06T16:24:32.491Z" }, + { url = "https://files.pythonhosted.org/packages/9c/59/a312e95696e5f601914dd8b6dd844692ba61670807417e24b68e337b5c70/numpy-2.5.3-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:a72f874bc9e10e4b8f80426fb49716d5141f64442a0c8418065093ec8017fbb0", size = 5445405, upload-time = "2026-09-06T16:24:35.071Z" }, + { url = "https://files.pythonhosted.org/packages/30/d0/5623a1707ed4fe16e3909fe3cf5ee3da004ae677ad23d83bbf3adf1a6faf/numpy-2.5.3-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:fc36dc566135b5eceec4cf89758fcb719266a019ef07dae1754ae7c9f617ef3e", size = 6783213, upload-time = "2026-09-06T16:24:37.253Z" }, + { url = "https://files.pythonhosted.org/packages/f1/32/84146fc020ad3c25f805f70ab60da46fe3c540a21369754a7e4369754b6f/numpy-2.5.3-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:76c2c1e6bfa5c84adc6434dfbf013aa92096a7985221762c8f11fedfd20fff58", size = 15687872, upload-time = "2026-09-06T16:24:39.751Z" }, + { url = "https://files.pythonhosted.org/packages/65/af/aa78d1a88805456e212b65461354cd943197fb9acecc4c90fd12295123a3/numpy-2.5.3-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b7e18c623bb5c95acb3b3328861272816ba199fb531921c5d6d0b675f1fde9e3", size = 16717410, upload-time = "2026-09-06T16:24:42.745Z" }, + { url = "https://files.pythonhosted.org/packages/3b/24/faa79d865e69a97ba17473b23a1b74094b2259c03e820c70297293b9ea49/numpy-2.5.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:4f8929ee6c96bfbd7b4ed2032e0c03af86fe1826740ab61ddabf9072d06e57ff", size = 17040975, upload-time = "2026-09-06T16:24:45.961Z" }, + { url = "https://files.pythonhosted.org/packages/62/4a/8877e629445a7176297dffcaf9c485faa96a95d81728a62521ad55bd4c0f/numpy-2.5.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b5d93cf48f687479941d12b69c873ad2cc76bbd487f0091c2200636497f34034", size = 18476479, upload-time = "2026-09-06T16:24:49.35Z" }, + { url = "https://files.pythonhosted.org/packages/c8/db/35e1c2d38b04cbd5b731f9d71495e055e813197669d22b612f11748d2ff9/numpy-2.5.3-cp312-cp312-win32.whl", hash = "sha256:bf63afbe037eb5d2fe87fbcc7778e61da53ebaf21d938a4515aa73b62532a5d4", size = 6133378, upload-time = "2026-09-06T16:24:51.915Z" }, + { url = "https://files.pythonhosted.org/packages/3c/a1/accf6d4f0c80c5d9ba9735d6b1550e444180599f34dec69ca01360f717ad/numpy-2.5.3-cp312-cp312-win_amd64.whl", hash = "sha256:0a59a421a32580a009e8a1751345bf829631b990dc1794b80514ab722b435def", size = 12567828, upload-time = "2026-09-06T16:24:54.255Z" }, + { url = "https://files.pythonhosted.org/packages/22/43/1764aff32e4652526ae2f71fa8b3efd8d25c8a3d6926914454e47138ed1e/numpy-2.5.3-cp312-cp312-win_arm64.whl", hash = "sha256:ccb32e0525d29e8b0572eb84c9a57af0e7a4e615726927506f55063c62414034", size = 10485432, upload-time = "2026-09-06T16:24:57.278Z" }, + { url = "https://files.pythonhosted.org/packages/79/e5/8fb89cd46d14e35699d13bf943a5f5f441ecee8667120a1f6105ab89e349/numpy-2.5.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:66a78fe4556c60aceda5916f9eacd638b18e9e681016ec302dcb4682d6d4d034", size = 16991061, upload-time = "2026-09-06T16:25:00.411Z" }, + { url = "https://files.pythonhosted.org/packages/2f/06/9dc9e48b5e5e941c8b10350c5ff2d721da42a20517d911d15544246775ff/numpy-2.5.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:92f30e89b8ee0ecf363033576c422b2f58fed6a80bed0aa48dff6d14c654663e", size = 12003676, upload-time = "2026-09-06T16:25:03.475Z" }, + { url = "https://files.pythonhosted.org/packages/ab/2a/98282aa5b8f58b1157d440bb6282eed47e3632a5de53a714fbab17e659fe/numpy-2.5.3-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:f9a2353b37a1a9e78fd82b27ad7e2a32a2d036604d18f02b05e3136c62ca3b09", size = 5439695, upload-time = "2026-09-06T16:25:05.978Z" }, + { url = "https://files.pythonhosted.org/packages/a1/f9/b6533d777be9d6ffd29dc1be0867e563e6e8cc9a220ff1b716adc317f060/numpy-2.5.3-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:ccbc4665079665c3cf3bab4db9f6b095370cd6437d66be549b6c2a1fd19e1958", size = 6779395, upload-time = "2026-09-06T16:25:08.599Z" }, + { url = "https://files.pythonhosted.org/packages/73/85/735720d04ec197c5dcfacdfc9922667c7f1f5f496a279b7ba4d7c74c4cc7/numpy-2.5.3-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c76d5dde9f445058f83d0c02af00557a4db91de9a9a57c0df87d1535001d654b", size = 15681750, upload-time = "2026-09-06T16:25:11.173Z" }, + { url = "https://files.pythonhosted.org/packages/3a/1b/3b16a9bc514a440a7a0883684111dcb1ef1aee960af2ca95da8fc775f124/numpy-2.5.3-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a5fa86b80fd24bcd1aff83ad23be44ea323de3f787be8f8b15d4a65621e25321", size = 16708577, upload-time = "2026-09-06T16:25:14.171Z" }, + { url = "https://files.pythonhosted.org/packages/69/c4/386f397831b07328b639c96c5b62719346cf4baf07c68d927239752b1534/numpy-2.5.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:bd4cb9ad3c7889b9b3fe0a9a9fb5d2ed26f9879bff2608d9f01aed147a20d231", size = 17042047, upload-time = "2026-09-06T16:25:17.582Z" }, + { url = "https://files.pythonhosted.org/packages/5f/3e/a700ecbf36e85ae8328fd3b0e12eeddc22ed6358a64cb2bd913e0d195d65/numpy-2.5.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:1302b90c0e52281681b2975adfe8a860cb7b12216a27b4b0b4207c44bf7bccf0", size = 18465724, upload-time = "2026-09-06T16:25:20.949Z" }, + { url = "https://files.pythonhosted.org/packages/41/ee/38e785e88a4045f6ad1d1f2808dcdfafdca48c760260c0587bf171e29fc9/numpy-2.5.3-cp313-cp313-win32.whl", hash = "sha256:1c80eabb4035ecf4ca9cd49cde8a9fdd69a729e63e6474887d1523ade7aa277f", size = 6129003, upload-time = "2026-09-06T16:25:23.664Z" }, + { url = "https://files.pythonhosted.org/packages/f3/ec/100f2b1794ede74a9b3d7ec6b9736927f56713414c1dfe19ab6c383494bf/numpy-2.5.3-cp313-cp313-win_amd64.whl", hash = "sha256:71cad2b2a7451ab79d8f5e71b453485b6775963d5cf794179144a7463fe6e8ec", size = 12560965, upload-time = "2026-09-06T16:25:26.602Z" }, + { url = "https://files.pythonhosted.org/packages/80/b1/7dc825ca94c12acebbce4c37caa5e198695eb31424bc579679f32b1bb49d/numpy-2.5.3-cp313-cp313-win_arm64.whl", hash = "sha256:8e4dd766076855b5ff7ea52fa5f07ce26286726e0f8bff446b7739d02e6ea204", size = 10482343, upload-time = "2026-09-06T16:25:29.772Z" }, + { url = "https://files.pythonhosted.org/packages/70/78/cf416f15dc29375a229d9dfebf8db6e313f291580b39fa1a568b6052bb07/numpy-2.5.3-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:350ba9783ce969cf9f7ce6e6a9a58e1a6e2a19ca025b7ee448c4db727706212a", size = 16998686, upload-time = "2026-09-06T16:25:33.171Z" }, + { url = "https://files.pythonhosted.org/packages/9e/59/abcc2d8def4fd60eec7d87f92d27c13448ffd9ab14339bcc63a0d7a2fdea/numpy-2.5.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:012e66aca395d795496446e52aeeb5866312a5d4d3f27da270e5a0b43f70dc5c", size = 12013862, upload-time = "2026-09-06T16:25:36.748Z" }, + { url = "https://files.pythonhosted.org/packages/94/75/4640d2d6e4b64a049e48425a82728a41ef4adb61332d2cba68055774878b/numpy-2.5.3-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:adc1ada2662f8a5f960b8a10d9986897e7499ef07e06d4cfe7197f8cce923c07", size = 5449793, upload-time = "2026-09-06T16:25:39.476Z" }, + { url = "https://files.pythonhosted.org/packages/96/cd/625b57ae33d4ca560f32cc0b47b4a5922146d9beb998ddf773900d440a73/numpy-2.5.3-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:54a115e5a73b8fc44f0cebef486365a1894b5c9760685d4558b72b7c3eb846e0", size = 6785176, upload-time = "2026-09-06T16:25:42.069Z" }, + { url = "https://files.pythonhosted.org/packages/9c/72/12918652e7912ef9751e8694c88820fcd1908e0618cb23f5f3caa6004b7b/numpy-2.5.3-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:be5a8381859b6da607c84f4f7d6847725f1cf1853ef8a2c9e115b7d58bef47dc", size = 15703377, upload-time = "2026-09-06T16:25:45.135Z" }, + { url = "https://files.pythonhosted.org/packages/45/8f/9beacf79ca7c650688ad0baa80931adb988fe6e6e5d5903c23cc3dbd70eb/numpy-2.5.3-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b0521d0f4aebb6e06189451025fa17a913287b13c03d5fe05c017333b654ea5b", size = 16711928, upload-time = "2026-09-06T16:25:48.461Z" }, + { url = "https://files.pythonhosted.org/packages/09/8d/41d0a56e1ac4c87495c897a211b1368691b7237aadabec8b3b8f3a74d48f/numpy-2.5.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:9deb49575e5b0b94ed72c8a64ec4d033381adc27e9060ae842971f697ba96104", size = 17059507, upload-time = "2026-09-06T16:25:51.873Z" }, + { url = "https://files.pythonhosted.org/packages/08/1e/0dfbc5cc251d54e2af790f254d24ec38637fa97ec7d5d11de7ffed787098/numpy-2.5.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:b00eefbcf0f292945c4b4dec2ae845389ef5bcdcd596e6e4328051db5b5ba694", size = 18471002, upload-time = "2026-09-06T16:25:55.233Z" }, + { url = "https://files.pythonhosted.org/packages/b5/2c/dfa40f6991f8185c8c30ffd023dfcbb11888e823cfab9557b920f3bb7bed/numpy-2.5.3-cp314-cp314-win32.whl", hash = "sha256:c2381f82999704f818e2c987a865050e285ec3621262c66d40f5a96c8f899f8e", size = 6180485, upload-time = "2026-09-06T16:25:58.157Z" }, + { url = "https://files.pythonhosted.org/packages/a4/73/d2c08231e4fde7e415501fd02c715d96e98599b2d8384445933944152984/numpy-2.5.3-cp314-cp314-win_amd64.whl", hash = "sha256:2c25dfa72943e4336ddb6b0ee4277b47a0c85bede0807530ec68103bf58e2c10", size = 12698179, upload-time = "2026-09-06T16:26:00.789Z" }, + { url = "https://files.pythonhosted.org/packages/5c/e9/dcdcc9b95cf5f49815055573aee1b11cfbf5299f38a180e437ded050810f/numpy-2.5.3-cp314-cp314-win_arm64.whl", hash = "sha256:15aa985ac73a8db02db7663381aa109510449d3819d37206caed27b33a65a8a6", size = 10769383, upload-time = "2026-09-06T16:26:04.011Z" }, + { url = "https://files.pythonhosted.org/packages/49/c4/af8bc08a7ef4e1529a7c0cf24969accce316b783999802089a581ec99272/numpy-2.5.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ac7bb1c52d445bd4f8f7f97fefe6abc3a084dc4d63df50d79b17fa2b78e89297", size = 12132668, upload-time = "2026-09-06T16:26:07.138Z" }, + { url = "https://files.pythonhosted.org/packages/c5/ae/0f15eb56d4ec5e13c1f7ff04ff407f997d1acbadb45d3e1f2e2645a8f43c/numpy-2.5.3-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:e6ab667ba76450084eb64013762c438ea76d9d29cc676dcd6c2e9892ba37f841", size = 5568580, upload-time = "2026-09-06T16:26:09.828Z" }, + { url = "https://files.pythonhosted.org/packages/23/fb/c72a8f25d4b6e96c354e7ab45ace3b27dc11e5d6a13b6c7d0cd6b08bf112/numpy-2.5.3-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:f7fabeb6cea87d65f3b926de33d03fb016cfdc29314c90974383b5582ae72891", size = 6882634, upload-time = "2026-09-06T16:26:12.524Z" }, + { url = "https://files.pythonhosted.org/packages/07/a9/968c90ed2ab15060c338e8137f1215b5a60756ae07328e0a60d1c6734df4/numpy-2.5.3-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1fb6f8fb9ff0b3a69f52c66ce397b0246583e9f28616231b0e32ca49259a5fa6", size = 15748923, upload-time = "2026-09-06T16:26:15.092Z" }, + { url = "https://files.pythonhosted.org/packages/59/08/9df04103947b95e3b6b1f2ed1a70521f325647a31b82da6a2aae3a485508/numpy-2.5.3-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:93e1f5447e2b1e479d7bd74701e84746b86450cff1fc368b132d195e2b8f8211", size = 16746748, upload-time = "2026-09-06T16:26:18.43Z" }, + { url = "https://files.pythonhosted.org/packages/41/a0/14c8d5fe5b53a334aabb653deb391c0fef49558f491880ea300ed6785224/numpy-2.5.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c00abe94c1a69d75d827dcf1c025b25c8a45d230b3bcd77a9020883a1b047653", size = 17111561, upload-time = "2026-09-06T16:26:22.113Z" }, + { url = "https://files.pythonhosted.org/packages/c4/a6/d7e96e42f01522e154c32489640f16dfc4f6181d165d05fc3bec8c2c4999/numpy-2.5.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:536f963710a4e63934d80ac0dc4f478804a83e9a84b6828018f25d09953ada33", size = 18513945, upload-time = "2026-09-06T16:26:25.401Z" }, + { url = "https://files.pythonhosted.org/packages/25/39/3453afb7119d0449ef11c886874120ff180e2c337760e0e2d88f70f1a945/numpy-2.5.3-cp314-cp314t-win32.whl", hash = "sha256:4c8a6d2ebce6305fd82fbefca827775437147052a976ee7c94b36a0c1b52ac6c", size = 6335421, upload-time = "2026-09-06T16:26:28.175Z" }, + { url = "https://files.pythonhosted.org/packages/99/01/22815d2b19a1a746b1d45205cffebb3fe511a18acb75fba6c88491fc9894/numpy-2.5.3-cp314-cp314t-win_amd64.whl", hash = "sha256:9a37475425b431b4d060f23b4f52cd2f3aef6bc7c654bd760adf0040eec9d435", size = 12896420, upload-time = "2026-09-06T16:26:31.265Z" }, + { url = "https://files.pythonhosted.org/packages/fa/ee/a7cbba67eeaff038dc29ca8b98a88396c8b0cc9c89d4924f4a27a5c9150b/numpy-2.5.3-cp314-cp314t-win_arm64.whl", hash = "sha256:2d8240cb4c16fd831074aa2b2cf9fc54664d826341d61c372245b96a74a49a9a", size = 10857177, upload-time = "2026-09-06T16:26:34.167Z" }, + { url = "https://files.pythonhosted.org/packages/45/56/78194492883ff5eec90423fe56a3a44b154da047d88a6307f629713c584f/numpy-2.5.3-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:a6391fafaba97500887132cd582abc6e19452b1ac775a47caa7b24490e152058", size = 16996531, upload-time = "2026-09-06T16:26:37.287Z" }, + { url = "https://files.pythonhosted.org/packages/11/39/dd55c0af90bbab564b09ae3b0aa60ec5c02b900fa4f1ba23440525c8b32d/numpy-2.5.3-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:09d5a423c71ad5feb5625844ad58050e35df43871004b52ac9c0ad44a56775be", size = 12012569, upload-time = "2026-09-06T16:26:40.707Z" }, + { url = "https://files.pythonhosted.org/packages/b6/51/04f67d32e4862b281b1cb84ceeaed3421189a84fb6fb51a391cd6d5009f7/numpy-2.5.3-cp315-cp315-macosx_14_0_arm64.whl", hash = "sha256:f9579f383d1bf9df80081e72760e84960a7fd4f88cf0c9e535a8597c9bb646f5", size = 5448498, upload-time = "2026-09-06T16:26:43.435Z" }, + { url = "https://files.pythonhosted.org/packages/a3/c9/25b4dc0dd1344ec26c7319e84fd4e9809d2b5628f4e12decd618036e5178/numpy-2.5.3-cp315-cp315-macosx_14_0_x86_64.whl", hash = "sha256:86bff898a431c0fb71f7610b75726e75a54d47b37edc9d537f48de63bb3c0b90", size = 6783026, upload-time = "2026-09-06T16:26:46.374Z" }, + { url = "https://files.pythonhosted.org/packages/fc/c7/29285be1e5232a6e7ee3268a33c85843f5a8ee93350c6465cddd66ebbf76/numpy-2.5.3-cp315-cp315-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1f3ed25271581281f2fccb1adcedfcde4c07362eec69189b50baf6f90e3ae159", size = 15697322, upload-time = "2026-09-06T16:26:49.415Z" }, + { url = "https://files.pythonhosted.org/packages/55/49/bbad5335fb4996a16881f853ff3e0ba582f01720e55c89b1c06b8fc42a90/numpy-2.5.3-cp315-cp315-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ffdc76bfcae6b255dff75202c5e7feaf95b40246bc0a17944facc1fecf9f79ab", size = 16708995, upload-time = "2026-09-06T16:26:53.127Z" }, + { url = "https://files.pythonhosted.org/packages/ef/e9/1df35483760b04a65ea44669f89dc64f30e5aca098b48ceb8b1310b0e0fe/numpy-2.5.3-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:116f96cadd935c6122e9228d676fe7ede19e741f5c8bb1c3cddbe0c51ccebea2", size = 17052508, upload-time = "2026-09-06T16:26:56.464Z" }, + { url = "https://files.pythonhosted.org/packages/b8/99/66e54da8265cc8be8a7382bf96edce17aaa2837d6f484432025932a3caa5/numpy-2.5.3-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:09ffa5d903faeaa5c4dd05009cf81c8bab9f2cb37c548b8d39b65b4cfa7c97f7", size = 18468224, upload-time = "2026-09-06T16:26:59.966Z" }, + { url = "https://files.pythonhosted.org/packages/01/bc/b5e90a91c115168d793dfd2ad9c69c438c2fe7a13a437e770bc5b078e732/numpy-2.5.3-cp315-cp315-win32.whl", hash = "sha256:e01c918ac3d48e18a927cf7b14a26a3e29ff2bdf2eacb976da0aecd6a43ed034", size = 6179919, upload-time = "2026-09-06T16:27:03.166Z" }, + { url = "https://files.pythonhosted.org/packages/37/ea/780748fd3985109075514ef8fc64cd25f943e40dde13a6d59141eb268fc8/numpy-2.5.3-cp315-cp315-win_amd64.whl", hash = "sha256:e931e4f499e0dc7ef29d269a8e5b35dd722e5d14be07df6240166ea7c6532fae", size = 12697656, upload-time = "2026-09-06T16:27:06.153Z" }, + { url = "https://files.pythonhosted.org/packages/b3/16/407be69a2a87c8cab64d95975a8977a426a29e138f07e276ec258f0fe4e5/numpy-2.5.3-cp315-cp315-win_arm64.whl", hash = "sha256:26e15e4aecd8617dfbaecb37d223e365d7b39411fba20454be2670a96aa74cb5", size = 10767601, upload-time = "2026-09-06T16:27:09.297Z" }, + { url = "https://files.pythonhosted.org/packages/44/bf/a97ffb01e41d50a32a9177aef942a4d0e389a3daf451d04e5f38ef6afb87/numpy-2.5.3-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:6cef4bb1706dfec49243c05d921eefb4e190d41e2528b30d8035ea1f36b4c24a", size = 17090092, upload-time = "2026-09-06T16:27:12.907Z" }, + { url = "https://files.pythonhosted.org/packages/d1/24/136c02f2c2af9a067a84d0c3aa10c99012c0476fa5066732fa4a4202557d/numpy-2.5.3-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:d1c89973648c85069c5046ad460f7b8a00218b29a2e42359ac8cc63e9ab94832", size = 12129429, upload-time = "2026-09-06T16:27:16.089Z" }, + { url = "https://files.pythonhosted.org/packages/fe/6c/b47582d6597789bf946d5efbeb6b9e56fd8bcbd5efc6fbf51dbe1ea31eb3/numpy-2.5.3-cp315-cp315t-macosx_14_0_arm64.whl", hash = "sha256:214045a5bf00113a146ab9ee9730c44501af6723cdf1f6830932f7b5ef2e7af0", size = 5565452, upload-time = "2026-09-06T16:27:19.868Z" }, + { url = "https://files.pythonhosted.org/packages/be/b4/ef3cc6da73774202d4deae16bb321fd8298a4e0561e3539f8c4be237d916/numpy-2.5.3-cp315-cp315t-macosx_14_0_x86_64.whl", hash = "sha256:8617bbfae4486cf99c9f899966699428d19da931d06ca94ad3da986c76e15997", size = 6876736, upload-time = "2026-09-06T16:27:22.232Z" }, + { url = "https://files.pythonhosted.org/packages/9e/24/e3813329498596cb842703dcacac1741612ed9fb9c4e6a3e0c7e2ebbc597/numpy-2.5.3-cp315-cp315t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:595d020938c84e320bcf40ad71089e108eac0d377cd018e14a8c094f39e98d85", size = 15745777, upload-time = "2026-09-06T16:27:25.181Z" }, + { url = "https://files.pythonhosted.org/packages/4a/9e/4e7a07fd0776dc2210cdacf2010be8665194d094defc10c419d7dea794cc/numpy-2.5.3-cp315-cp315t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6f24021b9f22bc6301c37b196974a92c1c18dccedb6fef3dd252e95f2d6adbe4", size = 16746949, upload-time = "2026-09-06T16:27:28.576Z" }, + { url = "https://files.pythonhosted.org/packages/91/db/01674c0e20335057813a00c2ebd546ed25bff9ed7914f9bced00f8c55d94/numpy-2.5.3-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:71b39d9f935b6ec0f8753e3e2afb51e3efba6f2e05b68b32a40754d24bcd4a3c", size = 17108994, upload-time = "2026-09-06T16:27:31.946Z" }, + { url = "https://files.pythonhosted.org/packages/45/7a/584c5e71f8d378e57cac0b033891ed65c683ef90573ba4854e8c28203db0/numpy-2.5.3-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:6b05c171afb3aa07adbd20abc00aea86fe375beb0fdb9ef780ec5b7f63bab1c0", size = 18512266, upload-time = "2026-09-06T16:27:35.196Z" }, + { url = "https://files.pythonhosted.org/packages/a1/d2/4e1014173aa3c55e6a756e0e567290743a6ab33a288460374d7ef6bcd239/numpy-2.5.3-cp315-cp315t-win32.whl", hash = "sha256:f54660b0eb6b0b9f36e7fe1cdfdff472028dd0d14acd9b9b65098efbad059469", size = 6330292, upload-time = "2026-09-06T16:27:38.149Z" }, + { url = "https://files.pythonhosted.org/packages/6c/b0/ff5658a58199b7bcaad87bf260eef6713d9d42cca4e028f935b4fc5fbac6/numpy-2.5.3-cp315-cp315t-win_amd64.whl", hash = "sha256:1aad64d99730d013cfc6debafed22783b4fc5a7f4b8bc744d2d8cf7dcc880551", size = 12884918, upload-time = "2026-09-06T16:27:40.965Z" }, + { url = "https://files.pythonhosted.org/packages/fb/0b/b12a2df5d1b774bd9007a6fdff9381145b6223d37f11afc9c37ab0efd9a1/numpy-2.5.3-cp315-cp315t-win_arm64.whl", hash = "sha256:befa1ae5bd6030b3f512b43ff3fa5290bbed6b84411a44244b14adf835f5b89d", size = 10850807, upload-time = "2026-09-06T16:27:43.868Z" }, +] + +[[package]] +name = "opt-einsum" +version = "3.4.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/8c/b9/2ac072041e899a52f20cf9510850ff58295003aa75525e58343591b0cbfb/opt_einsum-3.4.0.tar.gz", hash = "sha256:96ca72f1b886d148241348783498194c577fa30a8faac108586b14f1ba4473ac", size = 63004, upload-time = "2024-09-26T14:33:24.483Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/23/cd/066e86230ae37ed0be70aae89aabf03ca8d9f39c8aea0dec8029455b5540/opt_einsum-3.4.0-py3-none-any.whl", hash = "sha256:69bb92469f86a1565195ece4ac0323943e83477171b91d24c35afe028a90d7cd", size = 71932, upload-time = "2024-09-26T14:33:23.039Z" }, +] + +[[package]] +name = "optax" +version = "0.2.8" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "absl-py" }, + { name = "jax" }, + { name = "jaxlib" }, + { name = "numpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/8c/f9/e3d11ae6f298ee941a0690e353a323d158ba5dedc436e75621c310845c5c/optax-0.2.8.tar.gz", hash = "sha256:5b225b35066fc3eebaa4d798f1b4173b4d57d1a480610908981f8343b50af0b0", size = 301193, upload-time = "2026-03-20T23:30:05.465Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8a/69/6a93d8600c339d7687a05857c7907bd4dd8cf88691a5ea106d7a50af90a1/optax-0.2.8-py3-none-any.whl", hash = "sha256:e3ca2d36c99daab1800ae9dbc0545034382d6bc780b24d969e1b0df65fa31cb4", size = 402960, upload-time = "2026-03-20T23:30:03.886Z" }, +] + +[[package]] +name = "packaging" +version = "26.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7d/fa/3944b40b07da9ce895c0e6303a5ab7d53da063554f534556b134a54d6093/packaging-26.3.tar.gz", hash = "sha256:94edc256424af38762eb31306eed28beb9f0efc50a8837492c9d6fd6004aed79", size = 313412, upload-time = "2026-08-04T18:15:28.737Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/63/34/ba1c580383c9eada3711951fef0795c80b829a078d72188184bcab9dd527/packaging-26.3-py3-none-any.whl", hash = "sha256:d7193f7c8e4e93f444fde0262bf90af30e16fa0ad0ad44cb553c87339b23cd1c", size = 129956, upload-time = "2026-08-04T18:15:27.159Z" }, +] + +[[package]] +name = "pandas" +version = "3.0.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, + { name = "python-dateutil" }, + { name = "tzdata", marker = "sys_platform == 'emscripten' or sys_platform == 'win32'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/be/4f/5f3422a2afec5ffc46308b79e53291365a93748b498ac2e58bead0197916/pandas-3.0.5.tar.gz", hash = "sha256:dca3734d6ab7c906e6730f0788b0a1dbb9f2467731f9711f77995c8e9d62d712", size = 4658219, upload-time = "2026-07-22T22:19:28.819Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1c/54/1dc810ea558d1320b597aa140a514f2fdf1d2ea09c38cf556f13ea712ec9/pandas-3.0.5-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:fa290c16964d4963fbfbc358928239cf3bd755b20e988ce944877def2f44471d", size = 10411717, upload-time = "2026-07-22T22:18:08.307Z" }, + { url = "https://files.pythonhosted.org/packages/68/56/fbe81c09195924d8b7b8d4461a20458fe80a6a5ed6b24f0314da684277e1/pandas-3.0.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:c2e26bb46934b8a2ca0c3de1d3d606fc5f6746584791b2db264d58cf370e08dc", size = 9957095, upload-time = "2026-07-22T22:18:10.6Z" }, + { url = "https://files.pythonhosted.org/packages/e0/51/fac252f4a913ed5eabf3c11b880a9e8d5a6c10f0b2129d0462212d238b4d/pandas-3.0.5-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:73fa87b08a7ef706f8aafda39ddaccf2a99047bea62d8c88a0361bcafb2237bc", size = 10485458, upload-time = "2026-07-22T22:18:12.834Z" }, + { url = "https://files.pythonhosted.org/packages/12/98/e976540c1addf70442be7842a18cf70884a964abbf69442504f4d2939989/pandas-3.0.5-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d373ce03ffd84010ed9839fa73672a9c8256990532e158440c0085db7d914b34", size = 10998091, upload-time = "2026-07-22T22:18:15.209Z" }, + { url = "https://files.pythonhosted.org/packages/a4/8c/1f29b5be8d3fc47dd7567eb167fabba2085879b31e0287ce7cba6d3d2ff4/pandas-3.0.5-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2a29c53d85ea98c5e792c59ef82ee9fbe6ca902c0d0adb6b23f45ef894cd7bf6", size = 11499501, upload-time = "2026-07-22T22:18:17.689Z" }, + { url = "https://files.pythonhosted.org/packages/9d/e2/bd9c98ad2df7b38bde002adde4cdf353519da51881634323b126c55997f9/pandas-3.0.5-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a5ad3b02ed6bc7d7ae9b70804b2c6aa31827489d150f8e623ce82491b82085d7", size = 12060559, upload-time = "2026-07-22T22:18:20.147Z" }, + { url = "https://files.pythonhosted.org/packages/f3/9a/ffbd852d58bd74a617fe2f8ee6a58a96982271ce41cf981eab22190b4a4b/pandas-3.0.5-cp312-cp312-pyemscripten_2024_0_wasm32.whl", hash = "sha256:b2acb4650527eec6822c3dadb2b771277b65e7dae7a267d4bccf65fd1bb3fbce", size = 7197652, upload-time = "2026-07-22T22:18:22.502Z" }, + { url = "https://files.pythonhosted.org/packages/70/b5/d2d3e9ae73362ba4229651b0ee1455cf78073a1ce585f6ff693782ce263e/pandas-3.0.5-cp312-cp312-win_amd64.whl", hash = "sha256:80a611068e8a3ac23f7398c6c14eb46dc974e5cc9997f653e2dcfd1da74edd41", size = 9831691, upload-time = "2026-07-22T22:18:24.534Z" }, + { url = "https://files.pythonhosted.org/packages/52/51/dea1e89d6a6796b9c43f85a09b484ee03edb8a4c4842e73e200a8c11301c/pandas-3.0.5-cp312-cp312-win_arm64.whl", hash = "sha256:25ff585b972a18ef1fe9ffa3ac6544d9950508aa76832e5147640b6022821e49", size = 9105796, upload-time = "2026-07-22T22:18:27.064Z" }, + { url = "https://files.pythonhosted.org/packages/bf/09/7b95c4a0025227d6f118c4039b423412ac6a982db02864166185d812fbc7/pandas-3.0.5-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:c1c05a767fe8e5b4fe9e1c29806829c582052eaedb9120a3da83ba3f69e24a5b", size = 10385742, upload-time = "2026-07-22T22:18:29.346Z" }, + { url = "https://files.pythonhosted.org/packages/8d/0c/dc78fd8c4da477b4b5e8ad37295af352190d21ef63a9ee1bc071753074cc/pandas-3.0.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:b86765f268b56f7e665b93bce9d5df69dee7f99e595cf8fb839483ab315942a3", size = 9932067, upload-time = "2026-07-22T22:18:31.833Z" }, + { url = "https://files.pythonhosted.org/packages/3e/71/3592c055cf44df9808550f9368ceda80ff2b224d355ef73fe251dcda1802/pandas-3.0.5-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c597ecf5616b5c420372c1d4d4c00dbbfba7398bea857dcc984347e1ea48417b", size = 10466756, upload-time = "2026-07-22T22:18:34.195Z" }, + { url = "https://files.pythonhosted.org/packages/e3/70/4363150359f95b4cb4bcbb34ca23572bb5495749a621a8f3d5a1ddfd293c/pandas-3.0.5-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4b11c36e218331d0387cbe3a0a5f75162357a1d92d57b2b08a336ff94b19b2be", size = 10938525, upload-time = "2026-07-22T22:18:36.81Z" }, + { url = "https://files.pythonhosted.org/packages/f7/d0/317e7a0c67c0e69fa905a0161409397a7dc2d46ff611f6ca4803352c042b/pandas-3.0.5-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:cf52e1f61d229496da17dc7ab54acdee627357e7008fd4fecba3d0ba2937fa58", size = 11489303, upload-time = "2026-07-22T22:18:39.287Z" }, + { url = "https://files.pythonhosted.org/packages/f1/8d/36dade89b49e4f9d5cbdbe863772581f98c0c6d78fc39ad4c557f6f2e17e/pandas-3.0.5-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:db172144bb56422bd157812f3b021eacc255451470b31e2c633c349490a1cfee", size = 11989004, upload-time = "2026-07-22T22:18:42.208Z" }, + { url = "https://files.pythonhosted.org/packages/9c/ba/18c4ec8a746e177da05a9e7a7963781d8ea195780724f854601b6ebd6b78/pandas-3.0.5-cp313-cp313-win_amd64.whl", hash = "sha256:0d298e951f23016ce4699951d044ae6418dbc91bf68cefca0f77666fcbb4e5c6", size = 9826896, upload-time = "2026-07-22T22:18:44.539Z" }, + { url = "https://files.pythonhosted.org/packages/de/ec/28a57266b753799a87b8bc79e7887ac6fd981b8c6d2978a0b7e7b6bd708c/pandas-3.0.5-cp313-cp313-win_arm64.whl", hash = "sha256:66266d3442a5e8b3c90274c2b8b230bee42dd1c286bc822cc2f9f2c7e12b883e", size = 9094790, upload-time = "2026-07-22T22:18:47.468Z" }, + { url = "https://files.pythonhosted.org/packages/51/2f/cf6aae281264f4463f0875bcbb15fd2bb6d291cc535187dad1732475e4a9/pandas-3.0.5-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:2f264fc46911cc8131a7322a16199bbf8e353d27c10bb211f5bd0c814324dc36", size = 10390034, upload-time = "2026-07-22T22:18:49.818Z" }, + { url = "https://files.pythonhosted.org/packages/06/ec/5189518c7a7659c4bdcc6b1eb32c46c6f3c86b0661ffd84143d1112c7732/pandas-3.0.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:53730687fcd161883b24e10411c06d6a4c0f2275d2faf3bb2bc25deb4ba8007c", size = 9980065, upload-time = "2026-07-22T22:18:52.249Z" }, + { url = "https://files.pythonhosted.org/packages/ea/f1/598503ce8d7e3c35601e0747ba288c7864baae66380725bc12f13f884dfe/pandas-3.0.5-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:960d3ebcf249f75206899fcd2c6de53f736b7265759ced0d3e559df0b8b709b0", size = 10545532, upload-time = "2026-07-22T22:18:54.813Z" }, + { url = "https://files.pythonhosted.org/packages/fa/de/ceae2adf7034e07e9910299fe412e1819c4f0dd520700a888bcb03625448/pandas-3.0.5-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9e94c2c5ca43bd3ca32bf64d32308887b65e5f9bfd8023ea52755107a999f93b", size = 10963120, upload-time = "2026-07-22T22:18:57.42Z" }, + { url = "https://files.pythonhosted.org/packages/66/25/86e0f4451874eb79e688deeebe3c451fec4557f8952005818d800ee8ac7e/pandas-3.0.5-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:e819dd5f62966b481a8cb649d3299ebd886a1ea91ed5a99bf7ce77c98d18ab94", size = 11563178, upload-time = "2026-07-22T22:18:59.729Z" }, + { url = "https://files.pythonhosted.org/packages/f3/45/8643daa3b4147e433adfcccefdd0380d3aad79d86b15d8999730fe1944d5/pandas-3.0.5-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:3c5ed2e7c06e91d340dfd091d7934f9bc82e4a36b95f647f090b9d1c9ac649da", size = 12028708, upload-time = "2026-07-22T22:19:02.164Z" }, + { url = "https://files.pythonhosted.org/packages/96/58/ad979ae617615576e8aafd569c9d4b62f1191d896e38f51d66ba06f3b89a/pandas-3.0.5-cp314-cp314-win_amd64.whl", hash = "sha256:cd8f7c6dc98527058ee6264219343f5392240a6f1bfa654fc5d79023020d0c92", size = 9951806, upload-time = "2026-07-22T22:19:04.596Z" }, + { url = "https://files.pythonhosted.org/packages/69/32/7ac03886b304049a9d2625ee88f59af760d8a93bd30ed9239bce7b9869a8/pandas-3.0.5-cp314-cp314-win_arm64.whl", hash = "sha256:5183427f5a8156d480f30333777bc978be93650a49a7c01db26adffe95b31e85", size = 9238297, upload-time = "2026-07-22T22:19:06.836Z" }, + { url = "https://files.pythonhosted.org/packages/be/ed/1d1f2ee5547d5167face2376d11c8b2a4c7bfff5a416ee7a9046891fab1e/pandas-3.0.5-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:303da736987d481074ca720ada325f8bd80c64ebc2d45ed79b29df3aaa4a26ca", size = 10849690, upload-time = "2026-07-22T22:19:09.391Z" }, + { url = "https://files.pythonhosted.org/packages/57/55/17e17152e98fbb0c4b1e562bc65387a2f20a80db0f4a86bf8d3a0e4248d4/pandas-3.0.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:3b2801bbb049d0136f6c213eae02b5fca969384fc2064dd728d8620552aa49da", size = 10509945, upload-time = "2026-07-22T22:19:11.773Z" }, + { url = "https://files.pythonhosted.org/packages/88/90/817d44dbf83facf9556f33576d9af0a241981e7bb5c00606c0bcb5df8dda/pandas-3.0.5-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:cce3a9d11d2b1f82c69a27ec1f4948a170e2c403c4bbfa8cca62e3fdebe2ef3a", size = 10392197, upload-time = "2026-07-22T22:19:14.024Z" }, + { url = "https://files.pythonhosted.org/packages/f1/da/889f00c0a6f5aa1545add70abbf01502dff87ab577adb855bd631c54d2f2/pandas-3.0.5-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ef01af4d8dc6cd2c8d6c7736f149574ef93fe043811eeb5e445f2647154b5040", size = 10862726, upload-time = "2026-07-22T22:19:16.351Z" }, + { url = "https://files.pythonhosted.org/packages/bc/98/f1e934fb3c98fce859c6147c6785816c7b5b9ab7821115c5d8c4de9842b9/pandas-3.0.5-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e2759e890db96dfcffdbd9b86c3c2cb6afaf58def482820317e06163ec1066cd", size = 11414864, upload-time = "2026-07-22T22:19:18.981Z" }, + { url = "https://files.pythonhosted.org/packages/fe/be/d448af7d657d82e1888dd8551f79c6d6fb161080b5b9752d84d910ec2319/pandas-3.0.5-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:b58b1b39d46a5862e3fb18f50d1a201398619d16a0f9f73f57eea5583cf0e63c", size = 11925105, upload-time = "2026-07-22T22:19:21.515Z" }, + { url = "https://files.pythonhosted.org/packages/29/c1/ccb4238212c8c4f496c584f3044d94e0c030ed8e1d68999db46c91c2242f/pandas-3.0.5-cp314-cp314t-win_amd64.whl", hash = "sha256:1c10461f6eeb35d8f05b6184c65c8b9991663b66c46b1d559b682cb34ae7c6ea", size = 10387612, upload-time = "2026-07-22T22:19:24.257Z" }, + { url = "https://files.pythonhosted.org/packages/d2/cf/6a51b2c38980e04c279fd2fa908a1b0982064e860444acfca4ec2e2c8359/pandas-3.0.5-cp314-cp314t-win_arm64.whl", hash = "sha256:3c5015fd1730fbf883647e88068176c839c102cea883ba1769a6f4593bfc1f8c", size = 9509776, upload-time = "2026-07-22T22:19:26.694Z" }, +] + +[[package]] +name = "pandocfilters" +version = "1.5.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/70/6f/3dd4940bbe001c06a65f88e36bad298bc7a0de5036115639926b0c5c0458/pandocfilters-1.5.1.tar.gz", hash = "sha256:002b4a555ee4ebc03f8b66307e287fa492e4a77b4ea14d3f934328297bb4939e", size = 8454, upload-time = "2024-01-18T20:08:13.726Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ef/af/4fbc8cab944db5d21b7e2a5b8e9211a03a79852b1157e2c102fcc61ac440/pandocfilters-1.5.1-py2.py3-none-any.whl", hash = "sha256:93be382804a9cdb0a7267585f157e5d1731bbe5545a85b268d6f5fe6232de2bc", size = 8663, upload-time = "2024-01-18T20:08:11.28Z" }, +] + +[[package]] +name = "parso" +version = "0.8.7" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/30/4b/90c937815137d43ce71ba043cd3566221e9df6b9c805f24b5d138c9d40a7/parso-0.8.7.tar.gz", hash = "sha256:eaaac4c9fdd5e9e8852dc778d2d7405897ec510f2a298071453e5e3a07914bb1", size = 401824, upload-time = "2026-05-01T23:13:02.138Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/99/5d/8268b644392ee874ee82a635cd0df1773de230bde356c38de28e298392cc/parso-0.8.7-py2.py3-none-any.whl", hash = "sha256:a8926eb2a1b915486941fdbd31e86a4baf88fe8c210f25f2f35ecec5b574ca1c", size = 107025, upload-time = "2026-05-01T23:12:58.867Z" }, +] + +[[package]] +name = "pathspec" +version = "1.1.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/5a/82/42f767fc1c1143d6fd36efb827202a2d997a375e160a71eb2888a925aac1/pathspec-1.1.1.tar.gz", hash = "sha256:17db5ecd524104a120e173814c90367a96a98d07c45b2e10c2f3919fff91bf5a", size = 135180, upload-time = "2026-04-27T01:46:08.907Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f1/d9/7fb5aa316bc299258e68c73ba3bddbc499654a07f151cba08f6153988714/pathspec-1.1.1-py3-none-any.whl", hash = "sha256:a00ce642f577bf7f473932318056212bc4f8bfdf53128c78bbd5af0b9b20b189", size = 57328, upload-time = "2026-04-27T01:46:07.06Z" }, +] + +[[package]] +name = "periodictable" +version = "2.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, + { name = "pyparsing" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/44/0d/f494a2ec62ab56ffd44da4f236db374421fe0cd1e39d9ebc9785751eb432/periodictable-2.1.0-py3-none-any.whl", hash = "sha256:e9155d2bf5ac10050abeff2f99096d4f04312c0c8a6bb432e28744367c5064b3", size = 830749, upload-time = "2026-02-28T00:08:27.135Z" }, +] + +[[package]] +name = "pexpect" +version = "4.9.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "ptyprocess", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/42/92/cc564bf6381ff43ce1f4d06852fc19a2f11d180f23dc32d9588bee2f149d/pexpect-4.9.0.tar.gz", hash = "sha256:ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f", size = 166450, upload-time = "2023-11-25T09:07:26.339Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9e/c3/059298687310d527a58bb01f3b1965787ee3b40dce76752eda8b44e9a2c5/pexpect-4.9.0-py2.py3-none-any.whl", hash = "sha256:7236d1e080e4936be2dc3e326cec0af72acf9212a7e1d060210e70a47e253523", size = 63772, upload-time = "2023-11-25T06:56:14.81Z" }, +] + +[[package]] +name = "pillow" +version = "12.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1c/3d/bb7fca845737cf9d7dbde16ed1843984665ff2e0a518f5db43e77ec540b9/pillow-12.3.0.tar.gz", hash = "sha256:3b8182a766685eaa002637e28b4ec8d6b18819a0c71f579bf0dbaa5830297cce", size = 47025035, upload-time = "2026-07-01T11:56:38.965Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/37/bf/fb3ebff8ddcb76aac5a01389251bbbb9519922a9b520d8247c1ca864a25d/pillow-12.3.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:ba09209fbe443b4acccebe845d8a138b89a8f4fbaeedd44953490b5315d5e965", size = 5345969, upload-time = "2026-07-01T11:54:06.397Z" }, + { url = "https://files.pythonhosted.org/packages/d8/66/9a386a92561f402389a4fc70c18838bf6d35eb5eb5c6850b4b2dc64f5048/pillow-12.3.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ffd0c5368496f41b0944be820fcb7a838aa6e623d250b01acf2643939c3f99d7", size = 4780323, upload-time = "2026-07-01T11:54:09.351Z" }, + { url = "https://files.pythonhosted.org/packages/25/27/ac8f99618ffd3dde21db0f4d4b1d2ab00c0880595bfd17df103f7f39fd0c/pillow-12.3.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d9c7f76c0673154f044e9d78c8655fb4213f6ca31a836df48b40fe5d187717b9", size = 6266838, upload-time = "2026-07-01T11:54:11.71Z" }, + { url = "https://files.pythonhosted.org/packages/84/21/a35af28dcc61f37ed850a2d64c65c701321dfbf25085e469d5559360cbbf/pillow-12.3.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:78cb2c6865a35ab8ff8b75fd122f6033b92a62c82801110e48ddd6c936a45d91", size = 6940830, upload-time = "2026-07-01T11:54:13.732Z" }, + { url = "https://files.pythonhosted.org/packages/eb/51/8b08617af3ad95e33ce6d7dd2c99ed6c8298f7fb131636303956be022e25/pillow-12.3.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e491916b378fba47242221bb9ead245211b70d504f495d105d17b14a24b4907c", size = 6344383, upload-time = "2026-07-01T11:54:15.756Z" }, + { url = "https://files.pythonhosted.org/packages/1d/72/cf78ac9780bb93c28328f408973845a309d4d145041665f734572ced1b52/pillow-12.3.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:0dd2064cbc55aaec028ef5fbb60fa47bb6c3e7918e07ff17935284b227a9d2df", size = 7052934, upload-time = "2026-07-01T11:54:17.721Z" }, + { url = "https://files.pythonhosted.org/packages/20/20/25e0f4dc178a6bc0696793720055519a0de89e7661dae886992decbd2f81/pillow-12.3.0-cp312-cp312-win32.whl", hash = "sha256:dbce0b29841537a2fa4a214c2bbf14de3587c9680caa9b4e217568472490b28f", size = 6472684, upload-time = "2026-07-01T11:54:19.839Z" }, + { url = "https://files.pythonhosted.org/packages/45/89/da2f7971a317f83d807fdd4065c0af40208e59e692cc43d315a71a0e96d1/pillow-12.3.0-cp312-cp312-win_amd64.whl", hash = "sha256:a2b55dd6b2a4c4b7d87ffa56bdb33fdc5fdb9a462173861a7bc097f17d91cb09", size = 7227137, upload-time = "2026-07-01T11:54:22.025Z" }, + { url = "https://files.pythonhosted.org/packages/de/47/4845a0a6c0dbf1db8456bd9fc791f13c5ced7ced20606d08a0aacfd25b49/pillow-12.3.0-cp312-cp312-win_arm64.whl", hash = "sha256:331b624368d4f1d069149002f25f44bc61c8919ce8ddb3c45bdad8f6e2d89510", size = 2568267, upload-time = "2026-07-01T11:54:24.051Z" }, + { url = "https://files.pythonhosted.org/packages/9d/ac/31fb64e1e7efb5a4b50cd3d92049ba89ac6e4d8d3bb6a74e15048ca3353e/pillow-12.3.0-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:21900ce7ba264168cd50defae43cd75d25c833ad4ad6e73ffc5596d12e25ac89", size = 4161684, upload-time = "2026-07-01T11:54:25.934Z" }, + { url = "https://files.pythonhosted.org/packages/87/b4/9805e23d2b4d77842b468513841fda254ee42f0289d25088340e4ff46e2d/pillow-12.3.0-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:4e8c2a84d977f50b9daed6eeaf3baef67d00d5d74d932288f02cb94518ee3ace", size = 4255487, upload-time = "2026-07-01T11:54:27.935Z" }, + { url = "https://files.pythonhosted.org/packages/df/39/ecf519435a200c693fe053a6ee4d835b41cf963a4dfc2551c4e637cb2a71/pillow-12.3.0-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:ae26d61dfa7a47befdc7572b521024e8745f3d809bd95ca9505a7bba9ef849ec", size = 3696433, upload-time = "2026-07-01T11:54:29.813Z" }, + { url = "https://files.pythonhosted.org/packages/42/92/2fc3ffad878ae8dd5469ec1bc8eb83b71f48e13efdf68f02709003982a32/pillow-12.3.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:7a743ff716f746fc19a9557f60dab1600d4613255f8a7aeb3cdde4db7eb15a66", size = 5345889, upload-time = "2026-07-01T11:54:31.97Z" }, + { url = "https://files.pythonhosted.org/packages/10/76/8803c13605b763d33d156c4678fc77f8443389c0c51c8aef707bb02015f4/pillow-12.3.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:d69141514cc30b774ceea5e3ed3a6635c8d8a96edf664689b890f4089111fb35", size = 4780109, upload-time = "2026-07-01T11:54:34.026Z" }, + { url = "https://files.pythonhosted.org/packages/1f/01/e18aff37cb0b4aac47ac90f016d347a49aca667ef97f190b06ac2aabc928/pillow-12.3.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f7401aebd7f581d7f83a439d87d474999317ee099218e5ad25d125290990ba65", size = 6263736, upload-time = "2026-07-01T11:54:36.131Z" }, + { url = "https://files.pythonhosted.org/packages/f7/62/de5bdd77d935331f4f802edc11e4d82950f642caad6cb2f949837b8560e2/pillow-12.3.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0847a763afefb695bc912d7c131e7e0632d4edc1d8698f58ddabec8e46b8b6d3", size = 6937129, upload-time = "2026-07-01T11:54:38.216Z" }, + { url = "https://files.pythonhosted.org/packages/70/4d/105627a13300c5e0df1d174230b32fd1273062c96f7745fd552b945d1e1d/pillow-12.3.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:571b9fcb07b97ef3a492028fb3d2dc0993ca23a06138b0315286566d29ef718a", size = 6339562, upload-time = "2026-07-01T11:54:40.354Z" }, + { url = "https://files.pythonhosted.org/packages/6b/1d/f13de01a553988ab895ba1c722e06cf3144d4f57656fd5b81b6d881f1179/pillow-12.3.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:756c768d0c9c2955feb7a56c37ea24aea2e369f8d36a88da270b6a9f19e62b5e", size = 7049439, upload-time = "2026-07-01T11:54:42.489Z" }, + { url = "https://files.pythonhosted.org/packages/c9/f9/066794cca041b969964f779ee5fa66a9498bbf34248ac39c5d7954e4198f/pillow-12.3.0-cp313-cp313-win32.whl", hash = "sha256:a876864214e136f0eb367788dbd7df045f4806801518e2cfe9e13229cfe06d8f", size = 6473287, upload-time = "2026-07-01T11:54:44.9Z" }, + { url = "https://files.pythonhosted.org/packages/a6/9b/7a58e61d62be561da3a356fe2384d4059a6345fc130e23ef1c36a5b81d24/pillow-12.3.0-cp313-cp313-win_amd64.whl", hash = "sha256:1cca606cd25738df4ed873d5ad46bbdb3d83b5cbca291f6b4ff13a4df6b0bbe8", size = 7239691, upload-time = "2026-07-01T11:54:47.141Z" }, + { url = "https://files.pythonhosted.org/packages/aa/b0/c4ed4f0ef8f8fa5ee8351537db6650bb8189f7e118842978dd6589065692/pillow-12.3.0-cp313-cp313-win_arm64.whl", hash = "sha256:b629de27fda84b42cde7edef0d85f13b958b47f6e9bbcbba9b673c562a89bd8b", size = 2568185, upload-time = "2026-07-01T11:54:49.137Z" }, + { url = "https://files.pythonhosted.org/packages/dc/01/001f65b68192f0228cc1dbbc8d2530ab5d58b61037ba0587f946fea607cd/pillow-12.3.0-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:9cf95fe4d0f84c82d282745d9bb08ad9f926efa00be4697e767b814ce40d4330", size = 4161736, upload-time = "2026-07-01T11:54:51.156Z" }, + { url = "https://files.pythonhosted.org/packages/1a/d2/0219746d0fd16fc8a84498e79452375be3797d3ce4044596ce565164b84f/pillow-12.3.0-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:8728f216dcdb6e6d555cf971cb34076139ad74b31fc2c14da4fafc741c5f6217", size = 4255435, upload-time = "2026-07-01T11:54:53.414Z" }, + { url = "https://files.pythonhosted.org/packages/c8/02/8d0bc62ef0302318c46ff2a512822d2610e81c7aa46c9b3abe6cbaca5ad0/pillow-12.3.0-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:a45650e8ce7fafffd731db8550230db6b0d306d181a90b67d3e6bca2f1990930", size = 3696262, upload-time = "2026-07-01T11:54:55.739Z" }, + { url = "https://files.pythonhosted.org/packages/85/e2/73c77d218410b14f5f2d565e8a998d5317b7b9c75368d29985139f7a46f0/pillow-12.3.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:ba54cfebe86920a559a7c4d6b9050791c20513650a1952ebe3368c7dc70306f8", size = 5350344, upload-time = "2026-07-01T11:54:57.657Z" }, + { url = "https://files.pythonhosted.org/packages/c7/da/32c752228ae345f489e3a42499d817b6c3996da7e8a3bc7a04fc806b243b/pillow-12.3.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:e158cb00350dc278f3b91551101aa7d12415a66ebf2c91d8d5ac14e56ddd3ad0", size = 4780131, upload-time = "2026-07-01T11:54:59.713Z" }, + { url = "https://files.pythonhosted.org/packages/b1/9d/8b2c807dbef61a5197c047afe99823787eb66f63daf9fb2432f91d6f0462/pillow-12.3.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e9aeb04d6aef139de265b29683e119b638208f88cf73cdd1658aa07221165321", size = 6263757, upload-time = "2026-07-01T11:55:01.778Z" }, + { url = "https://files.pythonhosted.org/packages/5c/44/c85361f65dbe00eea8576ee467c768d25129989efb76e94f205e9ca9bb46/pillow-12.3.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:251bf95b67017e27b13d82f5b326234ca62d70f9cf4c2b9032de2358a3b12c7b", size = 6936962, upload-time = "2026-07-01T11:55:03.93Z" }, + { url = "https://files.pythonhosted.org/packages/18/7e/e483414b35800b86b6f08dbbc7803fb5cd52c4d6f897f47d53ea2c7e6f65/pillow-12.3.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:fe3cca2e4e8a592be0f269a1ca4835c25199d9f3ce815c8491048f785b0a0198", size = 6339171, upload-time = "2026-07-01T11:55:05.989Z" }, + { url = "https://files.pythonhosted.org/packages/f0/f4/68c491844841ede6bed70189546b3ee9731cf9f2cbad396faff5e1ccba45/pillow-12.3.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:23aceaa007d6172b02c277f0cd359c79492bbb14f7072b4ede9fbcaf20648130", size = 7048116, upload-time = "2026-07-01T11:55:08.131Z" }, + { url = "https://files.pythonhosted.org/packages/a3/34/77f3f793fed8efc7d243f21b33c5a3f0d1c97ee70346d3db855587e155ff/pillow-12.3.0-cp314-cp314-win32.whl", hash = "sha256:af8d94b0db561cf68b88a267c5c44b49e134f525d0dc2cb7ed413a66bc23559a", size = 6467209, upload-time = "2026-07-01T11:55:10.408Z" }, + { url = "https://files.pythonhosted.org/packages/f1/e0/492879f69d94f91f60fc8cd05ba03650e9520afebb2fb7aa12777d7c7f38/pillow-12.3.0-cp314-cp314-win_amd64.whl", hash = "sha256:fdafc9cce40277e0f7a0feabce0ee50dd2fa1800f3b38015e51296b5e814048d", size = 7237707, upload-time = "2026-07-01T11:55:12.745Z" }, + { url = "https://files.pythonhosted.org/packages/c9/ac/6b11f2875f1c2ac040d84e1bbf9cf22a88038f901ca1037898b280b38365/pillow-12.3.0-cp314-cp314-win_arm64.whl", hash = "sha256:e91206ee562682b51b98ef4b26a6ef48fd84e15fd4c4bc5ec768eb641d206838", size = 2565995, upload-time = "2026-07-01T11:55:14.736Z" }, + { url = "https://files.pythonhosted.org/packages/52/69/c2208e56af9bfc1913afb24020297a691eb1d4ef688474c8a04913f65e04/pillow-12.3.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:164b31cd1a0490ab6efae01aa5df49da7061be0af1b30e035b6e9a1bfe34ee6e", size = 5352503, upload-time = "2026-07-01T11:55:17.076Z" }, + { url = "https://files.pythonhosted.org/packages/07/70/e5686d753e898a45d778ff1718dba8516ead6ab6b95d85fc8c4b70650cf2/pillow-12.3.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:5afb51d599ea772b8365ae807ae557f18bccfe46ab261fd1c2a9ed700fc6eb17", size = 4782956, upload-time = "2026-07-01T11:55:19.448Z" }, + { url = "https://files.pythonhosted.org/packages/d5/37/25c6692f06927ee973ff18c8d9ee98ad0b4d84ee67a09610c2dd1447958e/pillow-12.3.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3edce1d53195db527e0191f84b71d02022de0540bf43a16ed734ed7537b07385", size = 6322855, upload-time = "2026-07-01T11:55:21.613Z" }, + { url = "https://files.pythonhosted.org/packages/cc/91/420637fcb8f1bc11029e403b4538e6694744428d8246118e45719f944556/pillow-12.3.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bf16ba1b4d0b6b7c8e534936632270cf70eb00dbe09005bc345b2677b726855c", size = 6989642, upload-time = "2026-07-01T11:55:24.006Z" }, + { url = "https://files.pythonhosted.org/packages/10/08/b94d7811281ccf0d143a1cf768d1c49e1e54af63e7b708ab2ee3eb87face/pillow-12.3.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:24870b09b224f7ae3c39ed07d10e819d06f8720bc551847b1d623832b5b0e28d", size = 6391281, upload-time = "2026-07-01T11:55:26.252Z" }, + { url = "https://files.pythonhosted.org/packages/d2/87/24233f785f55474dc02ce3e739c5528a77e3a862e9333d1dd7a25cc31f70/pillow-12.3.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:30f2aa603c41533cc25c05acd0da21636e84a315768feb631c937177db558931", size = 7096716, upload-time = "2026-07-01T11:55:28.318Z" }, + { url = "https://files.pythonhosted.org/packages/23/26/fcb2f6e37175b04f53570b59937867e2b80ee1685e744023153028fc14f9/pillow-12.3.0-cp314-cp314t-win32.whl", hash = "sha256:4b0a7fe987b14c31ebda6083f74f22b561fd3739bc0ac51e019622e3d72668c7", size = 6474125, upload-time = "2026-07-01T11:55:30.956Z" }, + { url = "https://files.pythonhosted.org/packages/90/de/3634abee5f1c9e13c56787b7d5517b0ba8d6de51700b95578cf338349c9f/pillow-12.3.0-cp314-cp314t-win_amd64.whl", hash = "sha256:962864dc93511324d51ddbb5b9f8731bf71675b93ca612a07441896f4688fb8c", size = 7242939, upload-time = "2026-07-01T11:55:34.044Z" }, + { url = "https://files.pythonhosted.org/packages/ce/2a/fd13f8eb24de5714a6eb444a3d67e2842c6c576e159a43793adf23051351/pillow-12.3.0-cp314-cp314t-win_arm64.whl", hash = "sha256:0740a512dc522224c77d9aa5a8d70d8b7d73fb91f2c21125d8d025d3b8990e45", size = 2567506, upload-time = "2026-07-01T11:55:35.988Z" }, + { url = "https://files.pythonhosted.org/packages/5d/dc/8fdce34ec725a33c81c6ba122b904d6b9024e50ea9ac7bede62fab54506c/pillow-12.3.0-cp315-cp315-ios_13_0_arm64_iphoneos.whl", hash = "sha256:0feb2e9d6ad6c9e3c06effe9d00f3f1e618a6643273576b016f591e9315a7139", size = 4162063, upload-time = "2026-07-01T11:55:37.941Z" }, + { url = "https://files.pythonhosted.org/packages/76/66/2044b9a63d3b84ff048228dfcb7cd9bf0df983e8470971bf7d4c57b693de/pillow-12.3.0-cp315-cp315-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:9e881fca225083806662a5c43d627d215f258ff43c890f831966c7d7ba9c7402", size = 4255549, upload-time = "2026-07-01T11:55:40.022Z" }, + { url = "https://files.pythonhosted.org/packages/52/7e/1f67e6f4ece6b582ee4b539decbcc9f848dc245a93ed8cd7338bafef72f1/pillow-12.3.0-cp315-cp315-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:4998562bf62a445225f22e07c896bb04b35b1b1f2eb6d760584c9c51d7a5f78c", size = 3696331, upload-time = "2026-07-01T11:55:41.98Z" }, + { url = "https://files.pythonhosted.org/packages/12/40/d306fc2c8e4d45d7f175c77edca7063be7b86fe7fe6e68f4353bf71d808c/pillow-12.3.0-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:dc624f6bc473dacdf7ef7eb8678d0d08edf15cd94fad6ae5c7d6cc67a4e4902f", size = 5350370, upload-time = "2026-07-01T11:55:44.028Z" }, + { url = "https://files.pythonhosted.org/packages/dd/44/668fb1437e8ce420f62d6106eb66e44a5971602a4d794615bdf79315d82d/pillow-12.3.0-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:71d6097b330eea8fd15097780c8e89cb1a8ce7838669f48c5bacd6f663dd4701", size = 4780147, upload-time = "2026-07-01T11:55:46.073Z" }, + { url = "https://files.pythonhosted.org/packages/0c/08/93fa2e70e30a2d81547e481b6ee2bb9522117221fb1e0ce4b5df70967677/pillow-12.3.0-cp315-cp315-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:28ce87c5ab450a9dd970b52e5aca5fe63ed432d18a2eaddd1979a00a1ba24ace", size = 6273659, upload-time = "2026-07-01T11:55:48.264Z" }, + { url = "https://files.pythonhosted.org/packages/f8/6d/043e96ff814fc31a33077e4cba86082167db520c93632afdf2042febbb0c/pillow-12.3.0-cp315-cp315-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6b02afb9b97f65fbca5f31db6a2a3ba21aa93030225f150fa3f249717e938fb4", size = 6947439, upload-time = "2026-07-01T11:55:50.503Z" }, + { url = "https://files.pythonhosted.org/packages/af/92/ba71d2ee2ac0edf3fa33bd9d5ee9ee080da70b1766f3ca3934f9938ddac9/pillow-12.3.0-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:1182d52bc2d5e5d7d0949503aa7e36d12f42205dc287e4883f407b1988820d39", size = 6353577, upload-time = "2026-07-01T11:55:52.697Z" }, + { url = "https://files.pythonhosted.org/packages/0f/ce/e63064e2122923ff687c8ad792d0d736a7b3920a56a46982e81a7fdd25d6/pillow-12.3.0-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:e795b7eb908249c4e43c7c99fac7c2c75dab0c43566e37db472a355f63693d71", size = 7060394, upload-time = "2026-07-01T11:55:55.149Z" }, + { url = "https://files.pythonhosted.org/packages/54/76/a09cc3ccc8d773a7283d34c38bec1708f9e3cc932093cbc4c5e71ac4060b/pillow-12.3.0-cp315-cp315-win32.whl", hash = "sha256:57b3d78c95ba9059768b10e28b813002261d3f3dfc55cc48b0c988f625175827", size = 6467375, upload-time = "2026-07-01T11:55:57.769Z" }, + { url = "https://files.pythonhosted.org/packages/3e/03/1846c49ba3b1d5550392a4bbd06d6fb4578e1cd91a803198b5c90f5f7d53/pillow-12.3.0-cp315-cp315-win_amd64.whl", hash = "sha256:fa4ecea169a355be7a3ade2c783e2ed12f0e40d2c5621cda8b3297faf7fbb9f5", size = 7237048, upload-time = "2026-07-01T11:55:59.975Z" }, + { url = "https://files.pythonhosted.org/packages/fb/bb/89f35dcc79610423f9f195504d7def7f0d1416a711541b42867e25fe3412/pillow-12.3.0-cp315-cp315-win_arm64.whl", hash = "sha256:877c3f311ff35410f690861c4409e7ccbf0cd2f878e50628a28e5a0bb689e658", size = 2566006, upload-time = "2026-07-01T11:56:02.143Z" }, + { url = "https://files.pythonhosted.org/packages/30/88/707027ba09942dfa2c28759b5c222d769290a41c6d20ea60ec250801941f/pillow-12.3.0-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:e9871b1ffbfa9656b60aeee92ed5136a5742696006fa322b29ea3d8da0ecc9cf", size = 5352509, upload-time = "2026-07-01T11:56:04.2Z" }, + { url = "https://files.pythonhosted.org/packages/b0/6d/00352fa25332c2569cd387851f568cc5a4b75a9adbfb37ac4fbce4c02eec/pillow-12.3.0-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:53aa02d20d10c3d814d536aa4e5ac9b84ca0ff5a88377963b085ad6822f93e64", size = 4783167, upload-time = "2026-07-01T11:56:06.631Z" }, + { url = "https://files.pythonhosted.org/packages/13/4f/9e049dfa21af7c22427275720e2490267ba8138120add5c4c574deb69782/pillow-12.3.0-cp315-cp315t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:446c34dcc4324b084a53b705127dc15717b22c5e140ae0a3c38349d4efec071e", size = 6329237, upload-time = "2026-07-01T11:56:08.868Z" }, + { url = "https://files.pythonhosted.org/packages/36/16/cf6eeaae8d0fce8dd390a33437cf68c5d5bd73834a2bc6e2f14efda0ab45/pillow-12.3.0-cp315-cp315t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:cf1845d02ad822a369a49f2bb9345b1614744267682e7a03527dc3bf6eea1777", size = 6997047, upload-time = "2026-07-01T11:56:11.379Z" }, + { url = "https://files.pythonhosted.org/packages/1e/69/dbf769bdd55f48bf5733cac28edc6364ffaa072ec9ba336266e4fe66be55/pillow-12.3.0-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:186941b6aef820ad110fb01fb06eb925374dc3a21b17e37ec9a53b250c6fe2d1", size = 6400440, upload-time = "2026-07-01T11:56:13.908Z" }, + { url = "https://files.pythonhosted.org/packages/a0/e1/ffc9cfc2eea0d178da8018e18e959301ad9d6bc9f3edb7181e748a474b97/pillow-12.3.0-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:f13c32a3abd6079a66d9526e18dad9b6d280384d49d7c54040cd57b6424041d9", size = 7105895, upload-time = "2026-07-01T11:56:16.575Z" }, + { url = "https://files.pythonhosted.org/packages/18/f0/a5595c1e8c3ae44b9828cb2f0fa8155e5095ef04d6327b8f61cf44a3df85/pillow-12.3.0-cp315-cp315t-win32.whl", hash = "sha256:1657923d2d45afb66526e5b933e5b3052e6bdea196c90d3abb2424e18c77dae8", size = 6474384, upload-time = "2026-07-01T11:56:18.855Z" }, + { url = "https://files.pythonhosted.org/packages/e4/04/62bcd9f844984c5938d3b05264a61d797a29d3e0812341a8204af70bbdee/pillow-12.3.0-cp315-cp315t-win_amd64.whl", hash = "sha256:8cd2f7bdda092d99c9fc2fb7391354f306d01443d22785d0cbfafa2e2c8bb418", size = 7243537, upload-time = "2026-07-01T11:56:21.214Z" }, + { url = "https://files.pythonhosted.org/packages/3d/68/1f3066acedf37673694a7141381d8f811ae97f30d34413d236abe7d489f1/pillow-12.3.0-cp315-cp315t-win_arm64.whl", hash = "sha256:06ff022112bc9cbf83b60f8e028d94ad87b60621706487e65f673de61610ab59", size = 2567491, upload-time = "2026-07-01T11:56:23.506Z" }, +] + +[[package]] +name = "platformdirs" +version = "4.11.8" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/53/18/f3bb8ef0d3b930692343da8aa4d3cbcd6749477c053959395ac81965a6e9/platformdirs-4.11.8.tar.gz", hash = "sha256:f23abafea7dd4276d1f29104b83598d7dcc567cafd07c9c951e66665645437fc", size = 37182, upload-time = "2026-09-08T22:20:42.866Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f4/e1/5b7b8bbb55084d1425bcb9bc823ff519e1b2be05f6ebb0089e2eacc38413/platformdirs-4.11.8-py3-none-any.whl", hash = "sha256:52f2f181bbfde907966932cc8312d967d02976422d66d537ea16092b8e291081", size = 24027, upload-time = "2026-09-08T22:20:41.537Z" }, +] + +[[package]] +name = "pluggy" +version = "1.6.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" }, +] + +[[package]] +name = "pocomc" +version = "1.2.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "dill" }, + { name = "multiprocess" }, + { name = "numpy" }, + { name = "scipy" }, + { name = "torch", version = "2.15.0", source = { registry = "https://download.pytorch.org/whl/cpu" }, marker = "sys_platform == 'darwin'" }, + { name = "torch", version = "2.15.0+cpu", source = { registry = "https://download.pytorch.org/whl/cpu" }, marker = "sys_platform != 'darwin'" }, + { name = "tqdm" }, + { name = "zuko" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/13/91/b5118f38e75d0a6ef6f6736db1bf1f7af4e84a8f43cb728e15451b92f158/pocomc-1.2.6.tar.gz", hash = "sha256:c9d28250b379ccd80eee043c1d1b6fbfb68e4fe07cf848f5a8b0af9c42052b31", size = 46329, upload-time = "2024-09-20T13:39:26.281Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/db/43/9bcde0d06aefc46856af85e8c495e9026f3374af0e95a0bb396ef8f8c119/pocomc-1.2.6-py3-none-any.whl", hash = "sha256:fd087841d27cce0a0940697cd4ff95456dc15400d680db8fb82b133fa9945bd7", size = 45985, upload-time = "2024-09-20T13:39:24.937Z" }, +] + +[[package]] +name = "prometheus-client" +version = "0.26.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/52/73/f1334c29c2af4cd9dba6c7817e61b611bd0215e2eb5565c6064a4de18802/prometheus_client-0.26.0.tar.gz", hash = "sha256:04a91bcf94e2cf74a44a1a874d651a2e853ed354b6e822f3b7487751465d5c2b", size = 92910, upload-time = "2026-07-24T19:36:41.893Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/eb/a3/b69efbf4143b5b9859b977770bbbabcc2796b702fa69dc40271e45cd5a56/prometheus_client-0.26.0-py3-none-any.whl", hash = "sha256:fa93d06737aa02bacd05794768508bb97d2fbee28cb3bca04eaae92f0ca953d6", size = 64494, upload-time = "2026-07-24T19:36:40.854Z" }, +] + +[[package]] +name = "prompt-toolkit" +version = "3.0.53" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "wcwidth" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/7d/ea/39b988c938f75cb75d7045b5c69f8bfed47ee2152c8837fb403de29d6fb8/prompt_toolkit-3.0.53.tar.gz", hash = "sha256:9ec8a0ad96d5c56148b3f914aa79c1564c3fde5d2e6b876e7bc327e353cf8fa6", size = 435492, upload-time = "2026-07-26T20:56:14.758Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/54/6f/84908cad2d6aa5144abcf7b42709fe4fdb459bc640ec7ac5786e7693dabc/prompt_toolkit-3.0.53-py3-none-any.whl", hash = "sha256:01c0891d7f9237d5e339f7d3e42cdae80b7534abb1c7c0e3352efba6231492f2", size = 392288, upload-time = "2026-07-26T20:56:12.512Z" }, +] + +[[package]] +name = "psutil" +version = "7.2.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/aa/c6/d1ddf4abb55e93cebc4f2ed8b5d6dbad109ecb8d63748dd2b20ab5e57ebe/psutil-7.2.2.tar.gz", hash = "sha256:0746f5f8d406af344fd547f1c8daa5f5c33dbc293bb8d6a16d80b4bb88f59372", size = 493740, upload-time = "2026-01-28T18:14:54.428Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/51/08/510cbdb69c25a96f4ae523f733cdc963ae654904e8db864c07585ef99875/psutil-7.2.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:2edccc433cbfa046b980b0df0171cd25bcaeb3a68fe9022db0979e7aa74a826b", size = 130595, upload-time = "2026-01-28T18:14:57.293Z" }, + { url = "https://files.pythonhosted.org/packages/d6/f5/97baea3fe7a5a9af7436301f85490905379b1c6f2dd51fe3ecf24b4c5fbf/psutil-7.2.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:e78c8603dcd9a04c7364f1a3e670cea95d51ee865e4efb3556a3a63adef958ea", size = 131082, upload-time = "2026-01-28T18:14:59.732Z" }, + { url = "https://files.pythonhosted.org/packages/37/d6/246513fbf9fa174af531f28412297dd05241d97a75911ac8febefa1a53c6/psutil-7.2.2-cp313-cp313t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1a571f2330c966c62aeda00dd24620425d4b0cc86881c89861fbc04549e5dc63", size = 181476, upload-time = "2026-01-28T18:15:01.884Z" }, + { url = "https://files.pythonhosted.org/packages/b8/b5/9182c9af3836cca61696dabe4fd1304e17bc56cb62f17439e1154f225dd3/psutil-7.2.2-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:917e891983ca3c1887b4ef36447b1e0873e70c933afc831c6b6da078ba474312", size = 184062, upload-time = "2026-01-28T18:15:04.436Z" }, + { url = "https://files.pythonhosted.org/packages/16/ba/0756dca669f5a9300d0cbcbfae9a4c30e446dfc7440ffe43ded5724bfd93/psutil-7.2.2-cp313-cp313t-win_amd64.whl", hash = "sha256:ab486563df44c17f5173621c7b198955bd6b613fb87c71c161f827d3fb149a9b", size = 139893, upload-time = "2026-01-28T18:15:06.378Z" }, + { url = "https://files.pythonhosted.org/packages/1c/61/8fa0e26f33623b49949346de05ec1ddaad02ed8ba64af45f40a147dbfa97/psutil-7.2.2-cp313-cp313t-win_arm64.whl", hash = "sha256:ae0aefdd8796a7737eccea863f80f81e468a1e4cf14d926bd9b6f5f2d5f90ca9", size = 135589, upload-time = "2026-01-28T18:15:08.03Z" }, + { url = "https://files.pythonhosted.org/packages/81/69/ef179ab5ca24f32acc1dac0c247fd6a13b501fd5534dbae0e05a1c48b66d/psutil-7.2.2-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:eed63d3b4d62449571547b60578c5b2c4bcccc5387148db46e0c2313dad0ee00", size = 130664, upload-time = "2026-01-28T18:15:09.469Z" }, + { url = "https://files.pythonhosted.org/packages/7b/64/665248b557a236d3fa9efc378d60d95ef56dd0a490c2cd37dafc7660d4a9/psutil-7.2.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7b6d09433a10592ce39b13d7be5a54fbac1d1228ed29abc880fb23df7cb694c9", size = 131087, upload-time = "2026-01-28T18:15:11.724Z" }, + { url = "https://files.pythonhosted.org/packages/d5/2e/e6782744700d6759ebce3043dcfa661fb61e2fb752b91cdeae9af12c2178/psutil-7.2.2-cp314-cp314t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1fa4ecf83bcdf6e6c8f4449aff98eefb5d0604bf88cb883d7da3d8d2d909546a", size = 182383, upload-time = "2026-01-28T18:15:13.445Z" }, + { url = "https://files.pythonhosted.org/packages/57/49/0a41cefd10cb7505cdc04dab3eacf24c0c2cb158a998b8c7b1d27ee2c1f5/psutil-7.2.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e452c464a02e7dc7822a05d25db4cde564444a67e58539a00f929c51eddda0cf", size = 185210, upload-time = "2026-01-28T18:15:16.002Z" }, + { url = "https://files.pythonhosted.org/packages/dd/2c/ff9bfb544f283ba5f83ba725a3c5fec6d6b10b8f27ac1dc641c473dc390d/psutil-7.2.2-cp314-cp314t-win_amd64.whl", hash = "sha256:c7663d4e37f13e884d13994247449e9f8f574bc4655d509c3b95e9ec9e2b9dc1", size = 141228, upload-time = "2026-01-28T18:15:18.385Z" }, + { url = "https://files.pythonhosted.org/packages/f2/fc/f8d9c31db14fcec13748d373e668bc3bed94d9077dbc17fb0eebc073233c/psutil-7.2.2-cp314-cp314t-win_arm64.whl", hash = "sha256:11fe5a4f613759764e79c65cf11ebdf26e33d6dd34336f8a337aa2996d71c841", size = 136284, upload-time = "2026-01-28T18:15:19.912Z" }, + { url = "https://files.pythonhosted.org/packages/e7/36/5ee6e05c9bd427237b11b3937ad82bb8ad2752d72c6969314590dd0c2f6e/psutil-7.2.2-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:ed0cace939114f62738d808fdcecd4c869222507e266e574799e9c0faa17d486", size = 129090, upload-time = "2026-01-28T18:15:22.168Z" }, + { url = "https://files.pythonhosted.org/packages/80/c4/f5af4c1ca8c1eeb2e92ccca14ce8effdeec651d5ab6053c589b074eda6e1/psutil-7.2.2-cp36-abi3-macosx_11_0_arm64.whl", hash = "sha256:1a7b04c10f32cc88ab39cbf606e117fd74721c831c98a27dc04578deb0c16979", size = 129859, upload-time = "2026-01-28T18:15:23.795Z" }, + { url = "https://files.pythonhosted.org/packages/b5/70/5d8df3b09e25bce090399cf48e452d25c935ab72dad19406c77f4e828045/psutil-7.2.2-cp36-abi3-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:076a2d2f923fd4821644f5ba89f059523da90dc9014e85f8e45a5774ca5bc6f9", size = 155560, upload-time = "2026-01-28T18:15:25.976Z" }, + { url = "https://files.pythonhosted.org/packages/63/65/37648c0c158dc222aba51c089eb3bdfa238e621674dc42d48706e639204f/psutil-7.2.2-cp36-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b0726cecd84f9474419d67252add4ac0cd9811b04d61123054b9fb6f57df6e9e", size = 156997, upload-time = "2026-01-28T18:15:27.794Z" }, + { url = "https://files.pythonhosted.org/packages/8e/13/125093eadae863ce03c6ffdbae9929430d116a246ef69866dad94da3bfbc/psutil-7.2.2-cp36-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:fd04ef36b4a6d599bbdb225dd1d3f51e00105f6d48a28f006da7f9822f2606d8", size = 148972, upload-time = "2026-01-28T18:15:29.342Z" }, + { url = "https://files.pythonhosted.org/packages/04/78/0acd37ca84ce3ddffaa92ef0f571e073faa6d8ff1f0559ab1272188ea2be/psutil-7.2.2-cp36-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:b58fabe35e80b264a4e3bb23e6b96f9e45a3df7fb7eed419ac0e5947c61e47cc", size = 148266, upload-time = "2026-01-28T18:15:31.597Z" }, + { url = "https://files.pythonhosted.org/packages/b4/90/e2159492b5426be0c1fef7acba807a03511f97c5f86b3caeda6ad92351a7/psutil-7.2.2-cp37-abi3-win_amd64.whl", hash = "sha256:eb7e81434c8d223ec4a219b5fc1c47d0417b12be7ea866e24fb5ad6e84b3d988", size = 137737, upload-time = "2026-01-28T18:15:33.849Z" }, + { url = "https://files.pythonhosted.org/packages/8c/c7/7bb2e321574b10df20cbde462a94e2b71d05f9bbda251ef27d104668306a/psutil-7.2.2-cp37-abi3-win_arm64.whl", hash = "sha256:8c233660f575a5a89e6d4cb65d9f938126312bca76d8fe087b947b3a1aaac9ee", size = 134617, upload-time = "2026-01-28T18:15:36.514Z" }, +] + +[[package]] +name = "ptemcee" +version = "1.0.0" +source = { git = "https://github.com/NuclearTalent/ptemcee_2025?rev=modernize#de76a0ea966765f27aaeb41d2bde4bb7a5ffea33" } +dependencies = [ + { name = "attrs" }, + { name = "numpy" }, +] + +[[package]] +name = "ptyprocess" +version = "0.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/20/e5/16ff212c1e452235a90aeb09066144d0c5a6a8c0834397e03f5224495c4e/ptyprocess-0.7.0.tar.gz", hash = "sha256:5c5d0a3b48ceee0b48485e0c26037c0acd7d29765ca3fbb5cb3831d347423220", size = 70762, upload-time = "2020-12-28T15:15:30.155Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/22/a6/858897256d0deac81a172289110f31629fc4cee19b6f01283303e18c8db3/ptyprocess-0.7.0-py2.py3-none-any.whl", hash = "sha256:4b41f3967fce3af57cc7e94b888626c18bf37a083e3651ca8feeb66d492fef35", size = 13993, upload-time = "2020-12-28T15:15:28.35Z" }, +] + +[[package]] +name = "pure-eval" +version = "0.2.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/da/9f/abfd2959e9261dd5217ca8551d4de211ca6ab26fe9b72cf44731ff6c4442/pure_eval-0.2.4.tar.gz", hash = "sha256:260c2774686e651b79f8b8e7fc9d80b3599ea6a66334b47d5f4abb69fc2c0ea1", size = 20563, upload-time = "2026-09-10T21:41:22.836Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6d/18/83376915176eb058cb86470eb7396388a13350b09a8f233a79303bbcbc5b/pure_eval-0.2.4-py3-none-any.whl", hash = "sha256:96cae060a313cfaad51bb761278bfb0e62dc0248d9315a81173752dc546cd37a", size = 11893, upload-time = "2026-09-10T21:41:21.532Z" }, +] + +[[package]] +name = "pycodestyle" +version = "2.14.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/11/e0/abfd2a0d2efe47670df87f3e3a0e2edda42f055053c85361f19c0e2c1ca8/pycodestyle-2.14.0.tar.gz", hash = "sha256:c4b5b517d278089ff9d0abdec919cd97262a3367449ea1c8b49b91529167b783", size = 39472, upload-time = "2025-06-20T18:49:48.75Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d7/27/a58ddaf8c588a3ef080db9d0b7e0b97215cee3a45df74f3a94dbbf5c893a/pycodestyle-2.14.0-py2.py3-none-any.whl", hash = "sha256:dd6bf7cb4ee77f8e016f9c8e74a35ddd9f67e1d5fd4184d86c3b98e07099f42d", size = 31594, upload-time = "2025-06-20T18:49:47.491Z" }, +] + +[[package]] +name = "pycparser" +version = "3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1b/7d/92392ff7815c21062bea51aa7b87d45576f649f16458d78b7cf94b9ab2e6/pycparser-3.0.tar.gz", hash = "sha256:600f49d217304a5902ac3c37e1281c9fe94e4d0489de643a9504c5cdfdfc6b29", size = 103492, upload-time = "2026-01-21T14:26:51.89Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0c/c3/44f3fbbfa403ea2a7c779186dc20772604442dde72947e7d01069cbe98e3/pycparser-3.0-py3-none-any.whl", hash = "sha256:b727414169a36b7d524c1c3e31839a521725078d7b2ff038656844266160a992", size = 48172, upload-time = "2026-01-21T14:26:50.693Z" }, +] + +[[package]] +name = "pydata-sphinx-theme" +version = "0.21.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "accessible-pygments" }, + { name = "babel" }, + { name = "beautifulsoup4" }, + { name = "docutils" }, + { name = "jinja2" }, + { name = "pygments" }, + { name = "requests" }, + { name = "sphinx" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/bd/ac/692035c97b732b26ee269fb14ec790046b21c7383a46bedfb3d40c3a4884/pydata_sphinx_theme-0.21.0.tar.gz", hash = "sha256:dc3f71216ea34725ddad68e505497eab4ba134a88abfb971a7df6b28a35c1997", size = 5010490, upload-time = "2026-08-25T14:16:47.949Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b5/8d/fb90c2ada1a938ba55f1730139f4d43736aee22d5f82f927c64cd858256f/pydata_sphinx_theme-0.21.0-py3-none-any.whl", hash = "sha256:d36a754bf9580b01789efa8a01869f2d7c87fa6c543ecbcafb14b6bdd4364f90", size = 6208465, upload-time = "2026-08-25T14:16:46.223Z" }, +] + +[[package]] +name = "pygments" +version = "2.21.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/49/2e/ced460408999b33da6b31b0021b0f37d329e202d4169aeb164493778f25b/pygments-2.21.0.tar.gz", hash = "sha256:610ca751c9bc2492b38eb9a38a7fbc93edbbb2d7182edaf34e66ae493dee5c8c", size = 5005329, upload-time = "2026-08-17T08:02:48.824Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/71/46/17f022dd3e953bf20a04a028a21ec746d942f8d2af30fa0f124fa0e6a684/pygments-2.21.0-py3-none-any.whl", hash = "sha256:2363c69b61c4a97c838da3b130dcd6468f4848992b21a82f2a63ec34377137d9", size = 1250147, upload-time = "2026-08-17T08:02:44.912Z" }, +] + +[[package]] +name = "pymc" +version = "6.3.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "arviz" }, + { name = "cachetools" }, + { name = "cloudpickle" }, + { name = "numpy" }, + { name = "pandas" }, + { name = "pytensor" }, + { name = "rich" }, + { name = "scipy" }, + { name = "threadpoolctl" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/dc/2d/f8a4d6358fe5398cf3b270da3eb0237ef7cbc115e48163c94704ac3f1621/pymc-6.3.2.tar.gz", hash = "sha256:3cd58e55249b3650786e2c717078de5595811e17187a666868072d15e3a931a1", size = 555223, upload-time = "2026-09-08T12:53:36.278Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/50/fd/592d2ba382c9a4734008bfccf99dd6196b7c670a84d50be0a4911f5283f2/pymc-6.3.2-py3-none-any.whl", hash = "sha256:f3eef7d1637d4bac243562abcd087a5363e99103ae984c69ab72d081f2eb0a1e", size = 608275, upload-time = "2026-09-08T12:53:34.476Z" }, +] + +[[package]] +name = "pyparsing" +version = "3.3.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f3/91/9c6ee907786a473bf81c5f53cf703ba0957b23ab84c264080fb5a450416f/pyparsing-3.3.2.tar.gz", hash = "sha256:c777f4d763f140633dcb6d8a3eda953bf7a214dc4eff598413c070bcdc117cbc", size = 6851574, upload-time = "2026-01-21T03:57:59.36Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/10/bd/c038d7cc38edc1aa5bf91ab8068b63d4308c66c4c8bb3cbba7dfbc049f9c/pyparsing-3.3.2-py3-none-any.whl", hash = "sha256:850ba148bd908d7e2411587e247a1e4f0327839c40e2e5e6d05a007ecc69911d", size = 122781, upload-time = "2026-01-21T03:57:55.912Z" }, +] + +[[package]] +name = "pyproject-hooks" +version = "1.2.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e7/82/28175b2414effca1cdac8dc99f76d660e7a4fb0ceefa4b4ab8f5f6742925/pyproject_hooks-1.2.0.tar.gz", hash = "sha256:1e859bd5c40fae9448642dd871adf459e5e2084186e8d2c2a79a824c970da1f8", size = 19228, upload-time = "2024-09-29T09:24:13.293Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/bd/24/12818598c362d7f300f18e74db45963dbcb85150324092410c8b49405e42/pyproject_hooks-1.2.0-py3-none-any.whl", hash = "sha256:9e5c6bfa8dcc30091c74b0cf803c81fdd29d94f01992a7707bc97babb1141913", size = 10216, upload-time = "2024-09-29T09:24:11.978Z" }, +] + +[[package]] +name = "pytensor" +version = "3.3.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "filelock" }, + { name = "numba" }, + { name = "numpy" }, + { name = "scipy" }, + { name = "setuptools" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/92/f9/f80cc84751a533d9f0b29a001bbf97235521de6f344d8327f62f73bff99f/pytensor-3.3.4.tar.gz", hash = "sha256:6e091e0c3d0341c60ccaaf33b482f2b0e0ea0992b1ce11fa1ee5c781464b6222", size = 5291407, upload-time = "2026-10-16T02:57:46.743Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c8/c2/702961306a321eaaf7282dea683dcc49e5131d14bfa9317c6892f803e87f/pytensor-3.3.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:52fb3c20233d12d6f1897c0fc5f1ed6edb150973eee78ab4442f60d8d98c132b", size = 1763253, upload-time = "2026-10-16T02:57:17.861Z" }, + { url = "https://files.pythonhosted.org/packages/a5/0f/3c6ad78d19ea67c863a9523386501e251f1bcea9a0f3431fdb01c0ea4386/pytensor-3.3.4-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:948db2ea003bcd333d80afca3b50ac74d0d8eaeb5a07f96a9fb579844e315f83", size = 2303346, upload-time = "2026-10-16T02:57:19.966Z" }, + { url = "https://files.pythonhosted.org/packages/23/63/d59700cbb6b2da19890cbe82908d17b0fb8aef4cc8a934f1c99eefb6854c/pytensor-3.3.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b6afee2742ebe93680f1b7ef0cbc5c1f631761d101977fa0f5d0f833b58a7fe8", size = 2303603, upload-time = "2026-10-16T02:57:21.714Z" }, + { url = "https://files.pythonhosted.org/packages/a7/4a/45e40a5765b01efd02c694d33eafca3c9dc7f141b79aa3abb74592849d5b/pytensor-3.3.4-cp312-cp312-win_amd64.whl", hash = "sha256:fcb4e928adbbf5f02e21d533ec503a2699a0d757fc1a3e7f6280b2fa882b413a", size = 1752186, upload-time = "2026-10-16T02:57:23.247Z" }, + { url = "https://files.pythonhosted.org/packages/28/55/aff93225853d9f218986b81f7bc5b279540735bd15330d5ac5ced5896574/pytensor-3.3.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:3621aa8867d25515de62acdaf815b355eefacb47ac486a1a2e7246ad448e7b10", size = 1969808, upload-time = "2026-10-16T02:57:24.798Z" }, + { url = "https://files.pythonhosted.org/packages/45/78/c9412c1226493cfdb3b9c5dbf9c585a893014ab36debb498db8443e3cf7b/pytensor-3.3.4-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1d1bc9c679485f22fc4382d90b3d1233b0fcf1a59506593b5c0c314f913cbfd0", size = 2506360, upload-time = "2026-10-16T02:57:26.294Z" }, + { url = "https://files.pythonhosted.org/packages/ec/3f/192b0fce6d238b74e9b2894f1a6296eb23bbc54c9f69bc74c78ddeaaa95b/pytensor-3.3.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:586e740f0422e994ddc36c09171612e713968fbae7c1688b8d9ee3f887c88e2f", size = 2506603, upload-time = "2026-10-16T02:57:28.1Z" }, + { url = "https://files.pythonhosted.org/packages/71/b0/1f2f5d3250bd4adecef5070578eec4ba197ea58ee6795654ddd155417ab7/pytensor-3.3.4-cp313-cp313-win_amd64.whl", hash = "sha256:954f727df86e1c5b33fdf7222bb3d5115d47c4adcdddd373a693686a84a4e8a0", size = 1959566, upload-time = "2026-10-16T02:57:29.69Z" }, + { url = "https://files.pythonhosted.org/packages/be/4f/b2da9f7ea509ba2641d1c7ac8080a039554fe67791f2c4c6abfae677f6c1/pytensor-3.3.4-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:d977e0df7a847bb8240088d68088715225b37d69766745340f04f9f0554dcb3e", size = 1970805, upload-time = "2026-10-16T02:57:31.319Z" }, + { url = "https://files.pythonhosted.org/packages/5b/3c/30068de8bf8708f4425b0eff98c890c1c12505faefe53de22f288b0cb824/pytensor-3.3.4-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:db61f0005c9759126c901504b5332c0c9fd5509754f3d20d076e07b19ddfda16", size = 2500484, upload-time = "2026-10-16T02:57:33.009Z" }, + { url = "https://files.pythonhosted.org/packages/d6/11/fb0b91081560944f22b1ef0838e2a2259f8fd2a504d3af5734e40b9a540f/pytensor-3.3.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:4be6d476c90295779c4043a072838b7990b799514bedaaf72c21dc6e5a41e9da", size = 2500947, upload-time = "2026-10-16T02:57:34.894Z" }, + { url = "https://files.pythonhosted.org/packages/b1/38/2f82ff4d2d637e1e54e723014bac672c40e570b7027c1c80b6dd1c3c9607/pytensor-3.3.4-cp314-cp314-win_amd64.whl", hash = "sha256:7339eaa4f29447a5a970c8365b285a4684ac5856e80087392e2cd2479ead8948", size = 1962279, upload-time = "2026-10-16T02:57:36.495Z" }, + { url = "https://files.pythonhosted.org/packages/20/b6/abbadd5991ab1135e974425ce7b6f58041369d42140552373e59da744c23/pytensor-3.3.4-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:06de974fb3be70a69481479bf4539a853022f679c72dcbfb73301b869cc2bc06", size = 1977408, upload-time = "2026-10-16T02:57:38.229Z" }, + { url = "https://files.pythonhosted.org/packages/5c/cc/bb43ce40ca6764c48a2b6ec108aaa1708e3548f7cd05f8eca6778601dd64/pytensor-3.3.4-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c657d513fd4b1ec787e0e0367b754be7a48ed2a73248272bfadf4b1adec3254d", size = 2518793, upload-time = "2026-10-16T02:57:39.803Z" }, + { url = "https://files.pythonhosted.org/packages/87/d3/4e9a2981a3b7f4ff3ef72a7cf6af101f80cbd050e05c6da12f46bb146d46/pytensor-3.3.4-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:70e4b40f7a0aba8ba9c85320c6b13ffc275a268c068ded30178553cf92f656a0", size = 2514341, upload-time = "2026-10-16T02:57:41.714Z" }, + { url = "https://files.pythonhosted.org/packages/d7/c4/0e9876b93e7dcfa078039c87381ae297acbd1f7999e8316b055df56ebeed/pytensor-3.3.4-cp314-cp314t-win_amd64.whl", hash = "sha256:92d28e7ba6e6dc9a0805dd6b625d443ffe42824ecf07f48c0f190db325d0aad7", size = 1968240, upload-time = "2026-10-16T02:57:43.46Z" }, + { url = "https://files.pythonhosted.org/packages/c7/5d/40232d057121c260f2d7db988b5d2586edef060e4523c2f0219514b0486c/pytensor-3.3.4-py2.py3-none-any.whl", hash = "sha256:b6363832bb24b8dc8ea01da840864d7a148daaa4fda301a4772dfac9618bfb09", size = 1645633, upload-time = "2026-10-16T02:57:45.174Z" }, +] + +[[package]] +name = "pytest" +version = "9.1.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "iniconfig" }, + { name = "packaging" }, + { name = "pluggy" }, + { name = "pygments" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e4/47/b9efed96c114afcfa3c9d3fe98a76a1d14c74a9e266d397cf6eb64be5e01/pytest-9.1.1.tar.gz", hash = "sha256:1088fbde8f2b49d95a549a195707afa7a76a3ce9bcadc26b6d71f0ffda5fe313", size = 1636369, upload-time = "2026-06-19T10:58:32.857Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/24/25/1de2678b631f5a49215c6c96fff41ba892b0a34df68d6d80292b1b48aa7f/pytest-9.1.1-py3-none-any.whl", hash = "sha256:37a86b45efb9a47a61a36449063e8e18d0cab3161329fc099eb21783169c4f0c", size = 386536, upload-time = "2026-06-19T10:58:31.347Z" }, +] + +[[package]] +name = "python-dateutil" +version = "2.9.0.post0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "six" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432, upload-time = "2024-03-01T18:36:20.211Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892, upload-time = "2024-03-01T18:36:18.57Z" }, +] + +[[package]] +name = "python-json-logger" +version = "4.2.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/21/25/5473e46b179f8e8b4ad3aeeb36773d1701b7770eaf5e5bc2025c7303b598/python_json_logger-4.2.0.tar.gz", hash = "sha256:e371ebe22ec01e289850102091a2b1f6fc9e655c7f1f5f29073936756c290afa", size = 18211, upload-time = "2026-08-15T11:36:38.232Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/dc/55/6467fde553886cb293e41538f3a8b4e4fd4688c6df242cf982162d8367fb/python_json_logger-4.2.0-py3-none-any.whl", hash = "sha256:158a52126fcd6869e09574d2b66272666f3dc8f468c62637ef9a1fa883719cb9", size = 14988, upload-time = "2026-08-15T11:36:36.821Z" }, +] + +[[package]] +name = "pytokens" +version = "0.4.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b6/34/b4e015b99031667a7b960f888889c5bd34ef585c85e1cb56a594b92836ac/pytokens-0.4.1.tar.gz", hash = "sha256:292052fe80923aae2260c073f822ceba21f3872ced9a68bb7953b348e561179a", size = 23015, upload-time = "2026-01-30T01:03:45.924Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/41/5d/e44573011401fb82e9d51e97f1290ceb377800fb4eed650b96f4753b499c/pytokens-0.4.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:140709331e846b728475786df8aeb27d24f48cbcf7bcd449f8de75cae7a45083", size = 160663, upload-time = "2026-01-30T01:03:06.473Z" }, + { url = "https://files.pythonhosted.org/packages/f0/e6/5bbc3019f8e6f21d09c41f8b8654536117e5e211a85d89212d59cbdab381/pytokens-0.4.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6d6c4268598f762bc8e91f5dbf2ab2f61f7b95bdc07953b602db879b3c8c18e1", size = 255626, upload-time = "2026-01-30T01:03:08.177Z" }, + { url = "https://files.pythonhosted.org/packages/bf/3c/2d5297d82286f6f3d92770289fd439956b201c0a4fc7e72efb9b2293758e/pytokens-0.4.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:24afde1f53d95348b5a0eb19488661147285ca4dd7ed752bbc3e1c6242a304d1", size = 269779, upload-time = "2026-01-30T01:03:09.756Z" }, + { url = "https://files.pythonhosted.org/packages/20/01/7436e9ad693cebda0551203e0bf28f7669976c60ad07d6402098208476de/pytokens-0.4.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:5ad948d085ed6c16413eb5fec6b3e02fa00dc29a2534f088d3302c47eb59adf9", size = 268076, upload-time = "2026-01-30T01:03:10.957Z" }, + { url = "https://files.pythonhosted.org/packages/2e/df/533c82a3c752ba13ae7ef238b7f8cdd272cf1475f03c63ac6cf3fcfb00b6/pytokens-0.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:3f901fe783e06e48e8cbdc82d631fca8f118333798193e026a50ce1b3757ea68", size = 103552, upload-time = "2026-01-30T01:03:12.066Z" }, + { url = "https://files.pythonhosted.org/packages/cb/dc/08b1a080372afda3cceb4f3c0a7ba2bde9d6a5241f1edb02a22a019ee147/pytokens-0.4.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:8bdb9d0ce90cbf99c525e75a2fa415144fd570a1ba987380190e8b786bc6ef9b", size = 160720, upload-time = "2026-01-30T01:03:13.843Z" }, + { url = "https://files.pythonhosted.org/packages/64/0c/41ea22205da480837a700e395507e6a24425151dfb7ead73343d6e2d7ffe/pytokens-0.4.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5502408cab1cb18e128570f8d598981c68a50d0cbd7c61312a90507cd3a1276f", size = 254204, upload-time = "2026-01-30T01:03:14.886Z" }, + { url = "https://files.pythonhosted.org/packages/e0/d2/afe5c7f8607018beb99971489dbb846508f1b8f351fcefc225fcf4b2adc0/pytokens-0.4.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:29d1d8fb1030af4d231789959f21821ab6325e463f0503a61d204343c9b355d1", size = 268423, upload-time = "2026-01-30T01:03:15.936Z" }, + { url = "https://files.pythonhosted.org/packages/68/d4/00ffdbd370410c04e9591da9220a68dc1693ef7499173eb3e30d06e05ed1/pytokens-0.4.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:970b08dd6b86058b6dc07efe9e98414f5102974716232d10f32ff39701e841c4", size = 266859, upload-time = "2026-01-30T01:03:17.458Z" }, + { url = "https://files.pythonhosted.org/packages/a7/c9/c3161313b4ca0c601eeefabd3d3b576edaa9afdefd32da97210700e47652/pytokens-0.4.1-cp313-cp313-win_amd64.whl", hash = "sha256:9bd7d7f544d362576be74f9d5901a22f317efc20046efe2034dced238cbbfe78", size = 103520, upload-time = "2026-01-30T01:03:18.652Z" }, + { url = "https://files.pythonhosted.org/packages/8f/a7/b470f672e6fc5fee0a01d9e75005a0e617e162381974213a945fcd274843/pytokens-0.4.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:4a14d5f5fc78ce85e426aa159489e2d5961acf0e47575e08f35584009178e321", size = 160821, upload-time = "2026-01-30T01:03:19.684Z" }, + { url = "https://files.pythonhosted.org/packages/80/98/e83a36fe8d170c911f864bfded690d2542bfcfacb9c649d11a9e6eb9dc41/pytokens-0.4.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:97f50fd18543be72da51dd505e2ed20d2228c74e0464e4262e4899797803d7fa", size = 254263, upload-time = "2026-01-30T01:03:20.834Z" }, + { url = "https://files.pythonhosted.org/packages/0f/95/70d7041273890f9f97a24234c00b746e8da86df462620194cef1d411ddeb/pytokens-0.4.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:dc74c035f9bfca0255c1af77ddd2d6ae8419012805453e4b0e7513e17904545d", size = 268071, upload-time = "2026-01-30T01:03:21.888Z" }, + { url = "https://files.pythonhosted.org/packages/da/79/76e6d09ae19c99404656d7db9c35dfd20f2086f3eb6ecb496b5b31163bad/pytokens-0.4.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:f66a6bbe741bd431f6d741e617e0f39ec7257ca1f89089593479347cc4d13324", size = 271716, upload-time = "2026-01-30T01:03:23.633Z" }, + { url = "https://files.pythonhosted.org/packages/79/37/482e55fa1602e0a7ff012661d8c946bafdc05e480ea5a32f4f7e336d4aa9/pytokens-0.4.1-cp314-cp314-win_amd64.whl", hash = "sha256:b35d7e5ad269804f6697727702da3c517bb8a5228afa450ab0fa787732055fc9", size = 104539, upload-time = "2026-01-30T01:03:24.788Z" }, + { url = "https://files.pythonhosted.org/packages/30/e8/20e7db907c23f3d63b0be3b8a4fd1927f6da2395f5bcc7f72242bb963dfe/pytokens-0.4.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:8fcb9ba3709ff77e77f1c7022ff11d13553f3c30299a9fe246a166903e9091eb", size = 168474, upload-time = "2026-01-30T01:03:26.428Z" }, + { url = "https://files.pythonhosted.org/packages/d6/81/88a95ee9fafdd8f5f3452107748fd04c24930d500b9aba9738f3ade642cc/pytokens-0.4.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:79fc6b8699564e1f9b521582c35435f1bd32dd06822322ec44afdeba666d8cb3", size = 290473, upload-time = "2026-01-30T01:03:27.415Z" }, + { url = "https://files.pythonhosted.org/packages/cf/35/3aa899645e29b6375b4aed9f8d21df219e7c958c4c186b465e42ee0a06bf/pytokens-0.4.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d31b97b3de0f61571a124a00ffe9a81fb9939146c122c11060725bd5aea79975", size = 303485, upload-time = "2026-01-30T01:03:28.558Z" }, + { url = "https://files.pythonhosted.org/packages/52/a0/07907b6ff512674d9b201859f7d212298c44933633c946703a20c25e9d81/pytokens-0.4.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:967cf6e3fd4adf7de8fc73cd3043754ae79c36475c1c11d514fc72cf5490094a", size = 306698, upload-time = "2026-01-30T01:03:29.653Z" }, + { url = "https://files.pythonhosted.org/packages/39/2a/cbbf9250020a4a8dd53ba83a46c097b69e5eb49dd14e708f496f548c6612/pytokens-0.4.1-cp314-cp314t-win_amd64.whl", hash = "sha256:584c80c24b078eec1e227079d56dc22ff755e0ba8654d8383b2c549107528918", size = 116287, upload-time = "2026-01-30T01:03:30.912Z" }, + { url = "https://files.pythonhosted.org/packages/c6/78/397db326746f0a342855b81216ae1f0a32965deccfd7c830a2dbc66d2483/pytokens-0.4.1-py3-none-any.whl", hash = "sha256:26cef14744a8385f35d0e095dc8b3a7583f6c953c2e3d269c7f82484bf5ad2de", size = 13729, upload-time = "2026-01-30T01:03:45.029Z" }, +] + +[[package]] +name = "pywinpty" +version = "3.0.5" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a9/ef/2d27f30c59a67be7025b2d7858c8c2d282b74d66544b2384730b82de74fd/pywinpty-3.0.5.tar.gz", hash = "sha256:61db0db063de9865adbea66db294628f8577f608d9764a4c7d3384eeacc4e81b", size = 16223484, upload-time = "2026-06-11T00:11:58.93Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/45/34/942cc95ca4e26489875aa8a95192766247a687379ec29543eebe73ec945f/pywinpty-3.0.5-cp312-cp312-win_amd64.whl", hash = "sha256:d62946adf14b15b54c0b8d785f93fe18b04da23f4ad59e2e8c4612646e9abd23", size = 2090915, upload-time = "2026-06-10T23:43:14.98Z" }, + { url = "https://files.pythonhosted.org/packages/6a/70/5b9053004844139ea8bd86209c57ade12b134b2782f383a095784c8531ec/pywinpty-3.0.5-cp312-cp312-win_arm64.whl", hash = "sha256:e9391c05fbfa7a992a97e831fc6849887b4014a614192e3d984a7ca59592b376", size = 815934, upload-time = "2026-06-10T23:41:42.384Z" }, + { url = "https://files.pythonhosted.org/packages/b9/f4/2a464b9893cceb3b3f416356e94fdc3e1bca9476993927e4e6d99fe95382/pywinpty-3.0.5-cp313-cp313-win_amd64.whl", hash = "sha256:48db1b0ad9d0a1b81dcaaa7163a99a7808deaceb0c1b2344716dc1fc090c3c4c", size = 2090471, upload-time = "2026-06-10T23:42:11.071Z" }, + { url = "https://files.pythonhosted.org/packages/3c/2c/a138491a0afbdb50eb79395577bd326d4b0fbde7209417d1a8087ff2493a/pywinpty-3.0.5-cp313-cp313-win_arm64.whl", hash = "sha256:2c6008fb2d3774b48693b2fcb7f2cc317ade9dc581289a964ffeeaf81307c9b5", size = 815518, upload-time = "2026-06-10T23:42:02.363Z" }, + { url = "https://files.pythonhosted.org/packages/6f/15/54400049a380582acd1282665c70fcf11e0bd3713679aca78e24c3aae738/pywinpty-3.0.5-cp313-cp313t-win_amd64.whl", hash = "sha256:22ce1b780d89821cc52daf6eac0708af22d93d000ce9c7c07e37489db8594598", size = 2089920, upload-time = "2026-06-10T23:44:13.395Z" }, + { url = "https://files.pythonhosted.org/packages/94/0c/6f24f3c0799f502259b24bdf841a99ad2b0d59df5c2525b4e2a286d14be2/pywinpty-3.0.5-cp313-cp313t-win_arm64.whl", hash = "sha256:9c2919a81bc5cfb09b86fc5a002112b2de95ca4304a07413cbeeb746a1307a5c", size = 814520, upload-time = "2026-06-10T23:43:28.588Z" }, + { url = "https://files.pythonhosted.org/packages/e9/23/f3cd1b1e5fc56517f54452c49f92049e7dd9ffc8a63de22a495581f50d04/pywinpty-3.0.5-cp314-cp314-win_amd64.whl", hash = "sha256:03bb3c16d691d9242267201830bcd0e64a9b663170e9042bc84b210da9de15ac", size = 2090663, upload-time = "2026-06-10T23:43:59.845Z" }, + { url = "https://files.pythonhosted.org/packages/9d/dd/96d6cbfc6d9ddab5c1c2f92c26545ae8997446a2ba7ee2024cd43c81f49b/pywinpty-3.0.5-cp314-cp314-win_arm64.whl", hash = "sha256:89c5c6ef08997a3b4b277b214a35fe15cab4dd6d119f0140aa71df5b1168fdbc", size = 815700, upload-time = "2026-06-10T23:40:50.001Z" }, + { url = "https://files.pythonhosted.org/packages/30/36/d98087bce0acaa4cce7f196103cfa7be3f63ce65f52473bb3e38784ae5d9/pywinpty-3.0.5-cp314-cp314t-win_amd64.whl", hash = "sha256:7b566165e0c5fdd6abe167a5ac8b954be6a843eb55a85946576d6bc1dea03d6d", size = 2090093, upload-time = "2026-06-10T23:40:58.933Z" }, + { url = "https://files.pythonhosted.org/packages/57/fd/fe2b0db922ba052ce3976a08f3fc05d0c05047c8b4ebb6102e832b8ef563/pywinpty-3.0.5-cp314-cp314t-win_arm64.whl", hash = "sha256:24366280a8aa677323da87bec729cb3ea3b35367386cece0978bdc6e4695c690", size = 814517, upload-time = "2026-06-10T23:42:34.946Z" }, +] + +[[package]] +name = "pyyaml" +version = "6.0.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d1/33/422b98d2195232ca1826284a76852ad5a86fe23e31b009c9886b2d0fb8b2/pyyaml-6.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196", size = 182063, upload-time = "2025-09-25T21:32:11.445Z" }, + { url = "https://files.pythonhosted.org/packages/89/a0/6cf41a19a1f2f3feab0e9c0b74134aa2ce6849093d5517a0c550fe37a648/pyyaml-6.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0", size = 173973, upload-time = "2025-09-25T21:32:12.492Z" }, + { url = "https://files.pythonhosted.org/packages/ed/23/7a778b6bd0b9a8039df8b1b1d80e2e2ad78aa04171592c8a5c43a56a6af4/pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28", size = 775116, upload-time = "2025-09-25T21:32:13.652Z" }, + { url = "https://files.pythonhosted.org/packages/65/30/d7353c338e12baef4ecc1b09e877c1970bd3382789c159b4f89d6a70dc09/pyyaml-6.0.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c", size = 844011, upload-time = "2025-09-25T21:32:15.21Z" }, + { url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc", size = 807870, upload-time = "2025-09-25T21:32:16.431Z" }, + { url = "https://files.pythonhosted.org/packages/05/c0/b3be26a015601b822b97d9149ff8cb5ead58c66f981e04fedf4e762f4bd4/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e", size = 761089, upload-time = "2025-09-25T21:32:17.56Z" }, + { url = "https://files.pythonhosted.org/packages/be/8e/98435a21d1d4b46590d5459a22d88128103f8da4c2d4cb8f14f2a96504e1/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea", size = 790181, upload-time = "2025-09-25T21:32:18.834Z" }, + { url = "https://files.pythonhosted.org/packages/74/93/7baea19427dcfbe1e5a372d81473250b379f04b1bd3c4c5ff825e2327202/pyyaml-6.0.3-cp312-cp312-win32.whl", hash = "sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5", size = 137658, upload-time = "2025-09-25T21:32:20.209Z" }, + { url = "https://files.pythonhosted.org/packages/86/bf/899e81e4cce32febab4fb42bb97dcdf66bc135272882d1987881a4b519e9/pyyaml-6.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b", size = 154003, upload-time = "2025-09-25T21:32:21.167Z" }, + { url = "https://files.pythonhosted.org/packages/1a/08/67bd04656199bbb51dbed1439b7f27601dfb576fb864099c7ef0c3e55531/pyyaml-6.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd", size = 140344, upload-time = "2025-09-25T21:32:22.617Z" }, + { url = "https://files.pythonhosted.org/packages/d1/11/0fd08f8192109f7169db964b5707a2f1e8b745d4e239b784a5a1dd80d1db/pyyaml-6.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8", size = 181669, upload-time = "2025-09-25T21:32:23.673Z" }, + { url = "https://files.pythonhosted.org/packages/b1/16/95309993f1d3748cd644e02e38b75d50cbc0d9561d21f390a76242ce073f/pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1", size = 173252, upload-time = "2025-09-25T21:32:25.149Z" }, + { url = "https://files.pythonhosted.org/packages/50/31/b20f376d3f810b9b2371e72ef5adb33879b25edb7a6d072cb7ca0c486398/pyyaml-6.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c", size = 767081, upload-time = "2025-09-25T21:32:26.575Z" }, + { url = "https://files.pythonhosted.org/packages/49/1e/a55ca81e949270d5d4432fbbd19dfea5321eda7c41a849d443dc92fd1ff7/pyyaml-6.0.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5", size = 841159, upload-time = "2025-09-25T21:32:27.727Z" }, + { url = "https://files.pythonhosted.org/packages/74/27/e5b8f34d02d9995b80abcef563ea1f8b56d20134d8f4e5e81733b1feceb2/pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6", size = 801626, upload-time = "2025-09-25T21:32:28.878Z" }, + { url = "https://files.pythonhosted.org/packages/f9/11/ba845c23988798f40e52ba45f34849aa8a1f2d4af4b798588010792ebad6/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6", size = 753613, upload-time = "2025-09-25T21:32:30.178Z" }, + { url = "https://files.pythonhosted.org/packages/3d/e0/7966e1a7bfc0a45bf0a7fb6b98ea03fc9b8d84fa7f2229e9659680b69ee3/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be", size = 794115, upload-time = "2025-09-25T21:32:31.353Z" }, + { url = "https://files.pythonhosted.org/packages/de/94/980b50a6531b3019e45ddeada0626d45fa85cbe22300844a7983285bed3b/pyyaml-6.0.3-cp313-cp313-win32.whl", hash = "sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26", size = 137427, upload-time = "2025-09-25T21:32:32.58Z" }, + { url = "https://files.pythonhosted.org/packages/97/c9/39d5b874e8b28845e4ec2202b5da735d0199dbe5b8fb85f91398814a9a46/pyyaml-6.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c", size = 154090, upload-time = "2025-09-25T21:32:33.659Z" }, + { url = "https://files.pythonhosted.org/packages/73/e8/2bdf3ca2090f68bb3d75b44da7bbc71843b19c9f2b9cb9b0f4ab7a5a4329/pyyaml-6.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb", size = 140246, upload-time = "2025-09-25T21:32:34.663Z" }, + { url = "https://files.pythonhosted.org/packages/9d/8c/f4bd7f6465179953d3ac9bc44ac1a8a3e6122cf8ada906b4f96c60172d43/pyyaml-6.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac", size = 181814, upload-time = "2025-09-25T21:32:35.712Z" }, + { url = "https://files.pythonhosted.org/packages/bd/9c/4d95bb87eb2063d20db7b60faa3840c1b18025517ae857371c4dd55a6b3a/pyyaml-6.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310", size = 173809, upload-time = "2025-09-25T21:32:36.789Z" }, + { url = "https://files.pythonhosted.org/packages/92/b5/47e807c2623074914e29dabd16cbbdd4bf5e9b2db9f8090fa64411fc5382/pyyaml-6.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7", size = 766454, upload-time = "2025-09-25T21:32:37.966Z" }, + { url = "https://files.pythonhosted.org/packages/02/9e/e5e9b168be58564121efb3de6859c452fccde0ab093d8438905899a3a483/pyyaml-6.0.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788", size = 836355, upload-time = "2025-09-25T21:32:39.178Z" }, + { url = "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", hash = "sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5", size = 794175, upload-time = "2025-09-25T21:32:40.865Z" }, + { url = "https://files.pythonhosted.org/packages/dd/3f/5989debef34dc6397317802b527dbbafb2b4760878a53d4166579111411e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764", size = 755228, upload-time = "2025-09-25T21:32:42.084Z" }, + { url = "https://files.pythonhosted.org/packages/d7/ce/af88a49043cd2e265be63d083fc75b27b6ed062f5f9fd6cdc223ad62f03e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35", size = 789194, upload-time = "2025-09-25T21:32:43.362Z" }, + { url = "https://files.pythonhosted.org/packages/23/20/bb6982b26a40bb43951265ba29d4c246ef0ff59c9fdcdf0ed04e0687de4d/pyyaml-6.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac", size = 156429, upload-time = "2025-09-25T21:32:57.844Z" }, + { url = "https://files.pythonhosted.org/packages/f4/f4/a4541072bb9422c8a883ab55255f918fa378ecf083f5b85e87fc2b4eda1b/pyyaml-6.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:93dda82c9c22deb0a405ea4dc5f2d0cda384168e466364dec6255b293923b2f3", size = 143912, upload-time = "2025-09-25T21:32:59.247Z" }, + { url = "https://files.pythonhosted.org/packages/7c/f9/07dd09ae774e4616edf6cda684ee78f97777bdd15847253637a6f052a62f/pyyaml-6.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3", size = 189108, upload-time = "2025-09-25T21:32:44.377Z" }, + { url = "https://files.pythonhosted.org/packages/4e/78/8d08c9fb7ce09ad8c38ad533c1191cf27f7ae1effe5bb9400a46d9437fcf/pyyaml-6.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba", size = 183641, upload-time = "2025-09-25T21:32:45.407Z" }, + { url = "https://files.pythonhosted.org/packages/7b/5b/3babb19104a46945cf816d047db2788bcaf8c94527a805610b0289a01c6b/pyyaml-6.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c", size = 831901, upload-time = "2025-09-25T21:32:48.83Z" }, + { url = "https://files.pythonhosted.org/packages/8b/cc/dff0684d8dc44da4d22a13f35f073d558c268780ce3c6ba1b87055bb0b87/pyyaml-6.0.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702", size = 861132, upload-time = "2025-09-25T21:32:50.149Z" }, + { url = "https://files.pythonhosted.org/packages/b1/5e/f77dc6b9036943e285ba76b49e118d9ea929885becb0a29ba8a7c75e29fe/pyyaml-6.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c", size = 839261, upload-time = "2025-09-25T21:32:51.808Z" }, + { url = "https://files.pythonhosted.org/packages/ce/88/a9db1376aa2a228197c58b37302f284b5617f56a5d959fd1763fb1675ce6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065", size = 805272, upload-time = "2025-09-25T21:32:52.941Z" }, + { url = "https://files.pythonhosted.org/packages/da/92/1446574745d74df0c92e6aa4a7b0b3130706a4142b2d1a5869f2eaa423c6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65", size = 829923, upload-time = "2025-09-25T21:32:54.537Z" }, + { url = "https://files.pythonhosted.org/packages/f0/7a/1c7270340330e575b92f397352af856a8c06f230aa3e76f86b39d01b416a/pyyaml-6.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4ad1906908f2f5ae4e5a8ddfce73c320c2a1429ec52eafd27138b7f1cbe341c9", size = 174062, upload-time = "2025-09-25T21:32:55.767Z" }, + { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341, upload-time = "2025-09-25T21:32:56.828Z" }, +] + +[[package]] +name = "pyzmq" +version = "27.2.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cffi", marker = "implementation_name == 'pypy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e7/8d/5b3d5631c2f4b4b8862f64cd0c9eb777b5710eeb5125b4be8dd0a200a4c0/pyzmq-27.2.0.tar.gz", hash = "sha256:54d4259d1bfae24ecdb5ca79f7acc2eac6c286a02d6a0ae617797cb45f0726d3", size = 292316, upload-time = "2026-08-20T19:08:21.19Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/57/8a/153532fa53db30e116118164f3af269a1f3966b3e2ba32c89b12fe864bd8/pyzmq-27.2.0-cp312-abi3-macosx_10_15_universal2.whl", hash = "sha256:591c8de5851c5ea372194469fe97587b97c3b641e9a70f31bb3474acbfde0241", size = 1431074, upload-time = "2026-08-20T19:06:40.601Z" }, + { url = "https://files.pythonhosted.org/packages/c8/ef/c08b91248bb90a9efa81fa00ba81b69c157c74d0c5efbb2c319d91babb62/pyzmq-27.2.0-cp312-abi3-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:00e73942ef12cecbc7951c4a9104bb8ffaed742abb13af2da6833d90dd368cef", size = 973915, upload-time = "2026-08-20T19:06:42.037Z" }, + { url = "https://files.pythonhosted.org/packages/b4/78/a3a3a86c2b00fadb92ece1ca4f8f028d62b2ce9ac3526097239ab2d6fba9/pyzmq-27.2.0-cp312-abi3-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1f8079d0521fe94bbb401fe9407578b28f3701627c8be2c9f7e0c5b77dcb0109", size = 697722, upload-time = "2026-08-20T19:06:43.325Z" }, + { url = "https://files.pythonhosted.org/packages/62/2c/d5828306f795e8d34676d266823b74e2101e0ad3760d12083de3e02abbb2/pyzmq-27.2.0-cp312-abi3-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:dea74fd65f1fc5f7fe167916a473ebe6ed6174e5e5d9de11ea6583661be6cf43", size = 872258, upload-time = "2026-08-20T19:06:44.627Z" }, + { url = "https://files.pythonhosted.org/packages/09/52/51253b78fd8739293e283407eeecb14215c02c71b6519af21f6eed8e69cd/pyzmq-27.2.0-cp312-abi3-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:dcc99ca132b667a4ed750afd42db4ea73288f18425a9b2e3c0af095665c491f5", size = 739591, upload-time = "2026-08-20T19:06:46.214Z" }, + { url = "https://files.pythonhosted.org/packages/e6/3e/142c85b67a4c9678629b0cf6d5125b29663d75be69bfaa57a3cac344d780/pyzmq-27.2.0-cp312-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:b8d5f66e4a8246cf77f7b8f7902af64f00553368fa0373c89d99b78f0ad79394", size = 1689031, upload-time = "2026-08-20T19:06:47.612Z" }, + { url = "https://files.pythonhosted.org/packages/0e/ee/0776fb0f98ed1eb74d77240087fef0ab045b6ad15cb09555c6c5134c98ad/pyzmq-27.2.0-cp312-abi3-musllinux_1_2_i686.whl", hash = "sha256:d1526b42a2e725b84ed226f37becedc250c6347594e5ed304e4e9aff68c9aec3", size = 2059547, upload-time = "2026-08-20T19:06:49.064Z" }, + { url = "https://files.pythonhosted.org/packages/aa/0e/ec77f691a4aebe29ab6329f996fb0e0270c876a3016086e3ca6ef733bcae/pyzmq-27.2.0-cp312-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:f707bcf2c1d007d14d70531d4dd7b41060881c73efa845580bf6faaf9ea24d42", size = 1910457, upload-time = "2026-08-20T19:06:50.783Z" }, + { url = "https://files.pythonhosted.org/packages/30/97/1f5530ff4fc271b4597048371d5af972c2baab51be132ba15874e0327a6a/pyzmq-27.2.0-cp312-abi3-win32.whl", hash = "sha256:fdaaa4ea3242f6ad298eb5177eb042aea5c73c30e76d20caee7b15af20d24ec2", size = 563450, upload-time = "2026-08-20T19:06:52.307Z" }, + { url = "https://files.pythonhosted.org/packages/02/8b/b83f7780dad22e0878e4c7bd9158ebd24ed12bc3d5e3a471cd0576f77ded/pyzmq-27.2.0-cp312-abi3-win_amd64.whl", hash = "sha256:2c218c6ab8bc447ba62054b581fd30209689d199c6ecb253f79615ca74a38e12", size = 628633, upload-time = "2026-08-20T19:06:53.809Z" }, + { url = "https://files.pythonhosted.org/packages/52/aa/3918b5ac7f9987bd9c421b065074fd7409ded88f856f2c704a24341877ec/pyzmq-27.2.0-cp312-abi3-win_arm64.whl", hash = "sha256:348d6fd3e4b81ae4580622ea8c2ea60224e84b2ac1b3be4482e6edc7de06e7a3", size = 556006, upload-time = "2026-08-20T19:06:55.242Z" }, + { url = "https://files.pythonhosted.org/packages/83/5e/d0541596b48c5a19f85dcbea83d6673d8e91681cdf853eb194c31fc9766e/pyzmq-27.2.0-cp313-cp313-android_24_arm64_v8a.whl", hash = "sha256:c551b9e2f86dc625fcb1a032c0d68042678caf96a8dd7c28796766b673bd5b52", size = 1127193, upload-time = "2026-08-20T19:06:56.545Z" }, + { url = "https://files.pythonhosted.org/packages/50/9f/8c7411bb283982d46e6d56dca6a095678c87eb0398daead12776d9881ac2/pyzmq-27.2.0-cp313-cp313-android_24_x86_64.whl", hash = "sha256:288cc790da0e3064a14a38ddc56ba169dada8c8af4cb86518db2bcbd380eedbb", size = 1166833, upload-time = "2026-08-20T19:06:58.011Z" }, + { url = "https://files.pythonhosted.org/packages/f9/84/a849161ff88b2de9b991cc8ab332218824741122fdc4fdf222a5b822ac8c/pyzmq-27.2.0-cp314-cp314-android_24_arm64_v8a.whl", hash = "sha256:3d45189c0c3c99f817b7fefff0d32eeef684cf33e1e3c0fc4281515357c54702", size = 1134452, upload-time = "2026-08-20T19:06:59.898Z" }, + { url = "https://files.pythonhosted.org/packages/3c/34/ff4aaff0cfba2a4d7ad1a16ffedc52c6deb89fcf673d455085446b23f215/pyzmq-27.2.0-cp314-cp314-android_24_x86_64.whl", hash = "sha256:d61910b52be5b2cd8b248dbcbe3a1b0275556a7d99fb613fc43323b546e273b8", size = 1167520, upload-time = "2026-08-20T19:07:01.283Z" }, + { url = "https://files.pythonhosted.org/packages/b6/07/42111e9dc1041d78b4443d6eb1b82b027f1a58178dc8a38385effbc72ad5/pyzmq-27.2.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:3ab6eb88590e510ab16715c32dbba12000da9bee989fdadd9ee19a234c492eb7", size = 1466289, upload-time = "2026-08-20T19:07:02.738Z" }, + { url = "https://files.pythonhosted.org/packages/4b/b4/def7a478458da78665840564161772e7e938600c32a89f28e8b221b54d2d/pyzmq-27.2.0-cp314-cp314t-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:1ecbdd131b9669f62d3a45afee5527c7ae9f141e4301267f21714c90bd21725f", size = 975868, upload-time = "2026-08-20T19:07:04.155Z" }, + { url = "https://files.pythonhosted.org/packages/38/d5/e3e85f7fea37153097aaff49db9e33093909cc2a7b22c1ac4ebe546600fc/pyzmq-27.2.0-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3146385b94a760236c5eceff468a66a296a716ca98a2e0f9217b1518118466b1", size = 706054, upload-time = "2026-08-20T19:07:05.623Z" }, + { url = "https://files.pythonhosted.org/packages/1c/ef/3b7d9449b223183222bf517245e1e53d5f1ab8c10be8b45f6a301b2f994a/pyzmq-27.2.0-cp314-cp314t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9846e881620dd62566ca76a53e384c3f37490faf4b9240aebc7498810dfca853", size = 878984, upload-time = "2026-08-20T19:07:07.153Z" }, + { url = "https://files.pythonhosted.org/packages/be/a5/8b49dbd494f6dcfda69dc4cade322a4b02706ef4e3d30cc366d4e369899f/pyzmq-27.2.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:d9527e3dbaef1edaeeb2446fa7379446814a43ade8adc7c4a5ebe69437815ddd", size = 1697489, upload-time = "2026-08-20T19:07:08.945Z" }, + { url = "https://files.pythonhosted.org/packages/da/5a/4bb8280901130c26ea25f0cbb4a6d39d94250860c6b3dbd912f1cf48fca7/pyzmq-27.2.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:56b48fa9d478a3af7254f397697a62f5ad3e1bb677e200b2701f0c290d97e5af", size = 2064236, upload-time = "2026-08-20T19:07:10.384Z" }, + { url = "https://files.pythonhosted.org/packages/de/38/f433af66922554adb2b5f79e897018c8e19a90b9eaeb49c4814f8355ebe4/pyzmq-27.2.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:bf0b6e4ce1bb089751c504c5493d6b0557eabd02dd21b76e9086cf964234b103", size = 1917424, upload-time = "2026-08-20T19:07:11.909Z" }, + { url = "https://files.pythonhosted.org/packages/36/81/ea1c1ae3f801d96ba2c269e056761ebcfe023476e651d3af2a7817962051/pyzmq-27.2.0-cp314-cp314t-win32.whl", hash = "sha256:fba8afcf265c6e9fbe1594cb045d4765c6c9a7d607653a8196067ef23566b843", size = 591103, upload-time = "2026-08-20T19:07:13.451Z" }, + { url = "https://files.pythonhosted.org/packages/8a/04/149a627707e780fa9f2c1ede3590c14fa6b18b5576d15744342622299a50/pyzmq-27.2.0-cp314-cp314t-win_amd64.whl", hash = "sha256:d1bc1d380a91d954ed5fc9f12915dba014eed0978d2de05ee7ca688bdaac144a", size = 670215, upload-time = "2026-08-20T19:07:15.069Z" }, + { url = "https://files.pythonhosted.org/packages/30/ba/f9c3c1536c41ef3dbf765ea04218990e2056e558f98184ecd883767fc501/pyzmq-27.2.0-cp314-cp314t-win_arm64.whl", hash = "sha256:c7cfb75caa83f5153c687e9d2107f64b5ef0ef0d6edd260d3ff920baaaa69101", size = 582252, upload-time = "2026-08-20T19:07:16.582Z" }, + { url = "https://files.pythonhosted.org/packages/fa/00/78fe097a304a408275747ce43f20428789130b059c5649956277c20f30cf/pyzmq-27.2.0-cp315-cp315-android_24_arm64_v8a.whl", hash = "sha256:c5129a8fe43ecc49b99eb75616603d483a3c2fcaef504988fafe8ea392aea98b", size = 1134295, upload-time = "2026-08-20T19:07:17.94Z" }, + { url = "https://files.pythonhosted.org/packages/f2/83/1c36270658d2ee56e23a3f9ef5fbcb94cbd2f9fe966a6641f2f38e697162/pyzmq-27.2.0-cp315-cp315-android_24_x86_64.whl", hash = "sha256:baa2ce3485145653194d6c8c5beedd1e9f0bf46a0919c9fa2fe2204fc35b74d9", size = 1167492, upload-time = "2026-08-20T19:07:19.476Z" }, + { url = "https://files.pythonhosted.org/packages/58/b2/f0ae223438d7faa991f6feefdc823815f11cc604f898738376b59fd96515/pyzmq-27.2.0-cp315-cp315t-macosx_10_15_universal2.whl", hash = "sha256:e1ed46048d1920cabc96d952a0d5cfe4127ad8db572c335aae4e3c57b9278d7f", size = 1465992, upload-time = "2026-08-20T19:07:20.941Z" }, + { url = "https://files.pythonhosted.org/packages/59/46/fb56f3f37a6a0937b0e1d2885e808b5eedc171320bac85573cfae78fa9bc/pyzmq-27.2.0-cp315-cp315t-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:e0fa0bc6b1a184aee59b32efcd1b7f0e6d5b8f9387799e4c16a4cb66a86747d6", size = 976118, upload-time = "2026-08-20T19:07:22.577Z" }, + { url = "https://files.pythonhosted.org/packages/21/82/a2c9bfd7c4d34eea1278493cd041bc000d41acb4463c89ceaad29dc813b6/pyzmq-27.2.0-cp315-cp315t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0f4bd6743e8bf854c3bfce892dd6578a514aabf128e37a4b2eafcf01856f7e44", size = 705968, upload-time = "2026-08-20T19:07:24.019Z" }, + { url = "https://files.pythonhosted.org/packages/d6/12/b906b269116b6591dc15c0acc5d04c043957c8a531d336999731f4b1d899/pyzmq-27.2.0-cp315-cp315t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:95369ed6626afcfe2ac89832fb1b917c077fbeb905fbbe5d918349ce0222b89b", size = 879011, upload-time = "2026-08-20T19:07:25.428Z" }, + { url = "https://files.pythonhosted.org/packages/12/13/f96359534bfb77651c15f1fbfc4bfdd7ec3489d23f434706d39598dd0dcd/pyzmq-27.2.0-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:40124779c3a56ad5d91902df1ff89159cb414b6c1a0ee697abcc66cf5e6db62d", size = 1697496, upload-time = "2026-08-20T19:07:26.821Z" }, + { url = "https://files.pythonhosted.org/packages/21/b4/2c007ae5f2fe5eca86cbfbc874ed86b5135f2f7812615dfd78606d3c93f6/pyzmq-27.2.0-cp315-cp315t-musllinux_1_2_i686.whl", hash = "sha256:ec8a318dfc27c7d946651b3d9e8025d5734f30c168a822195601827207bac09b", size = 2064347, upload-time = "2026-08-20T19:07:28.315Z" }, + { url = "https://files.pythonhosted.org/packages/9b/88/767af3a6630c15215f3a66700ec79598a375edd1fdc9d75a3ad522178c01/pyzmq-27.2.0-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:88c0fac061bac269076edeb3a209acefc96cd6167c239daf1c2b404ac48d7012", size = 1917360, upload-time = "2026-08-20T19:07:29.693Z" }, + { url = "https://files.pythonhosted.org/packages/35/c1/80dd2d20d6e57bc68e1dce1e84bf3e76c9577c1bf728199985c8b4ea0fd1/pyzmq-27.2.0-cp315-cp315t-win32.whl", hash = "sha256:ac126d48cf18aa955daabef43bf0009ff76ad4deee437d09ecf15388214b5beb", size = 591073, upload-time = "2026-08-20T19:07:31.341Z" }, + { url = "https://files.pythonhosted.org/packages/f8/b5/33b781666f3f52ae834bc9c8e38f4f0483a826c5a91cccc993292007bf10/pyzmq-27.2.0-cp315-cp315t-win_amd64.whl", hash = "sha256:edce90a1e588ec63adbf612cc0ad582de4169cd216c7ae53c15f42a2ee902f35", size = 670701, upload-time = "2026-08-20T19:07:32.895Z" }, + { url = "https://files.pythonhosted.org/packages/6e/97/bc4f0edefb992df4fdebcf9f0cc40f631cd4ed277e1ed59ef2cd99a5c8c5/pyzmq-27.2.0-cp315-cp315t-win_arm64.whl", hash = "sha256:a843094b4d3d633bc3623e47a2ff50742d6af02bc1f7606aa2e67e971e21878d", size = 581985, upload-time = "2026-08-20T19:07:34.19Z" }, +] + +[[package]] +name = "referencing" +version = "0.37.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "attrs" }, + { name = "rpds-py" }, + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/22/f5/df4e9027acead3ecc63e50fe1e36aca1523e1719559c499951bb4b53188f/referencing-0.37.0.tar.gz", hash = "sha256:44aefc3142c5b842538163acb373e24cce6632bd54bdb01b21ad5863489f50d8", size = 78036, upload-time = "2025-10-13T15:30:48.871Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2c/58/ca301544e1fa93ed4f80d724bf5b194f6e4b945841c5bfd555878eea9fcb/referencing-0.37.0-py3-none-any.whl", hash = "sha256:381329a9f99628c9069361716891d34ad94af76e461dcb0335825aecc7692231", size = 26766, upload-time = "2025-10-13T15:30:47.625Z" }, +] + +[[package]] +name = "requests" +version = "2.34.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "certifi" }, + { name = "charset-normalizer" }, + { name = "idna" }, + { name = "urllib3" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ac/c3/e2a2b89f2d3e2179abd6d00ebd70bff6273f37fb3e0cc209f48b39d00cbf/requests-2.34.2.tar.gz", hash = "sha256:f288924cae4e29463698d6d60bc6a4da69c89185ad1e0bcc4104f584e960b9ed", size = 142856, upload-time = "2026-05-14T19:25:27.735Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a0/f4/c67b0b3f1b9245e8d266f0f112c500d50e5b4e83cb6f3b71b6528104182a/requests-2.34.2-py3-none-any.whl", hash = "sha256:2a0d60c172f83ac6ab31e4554906c0f3b3588d37b5cb939b1c061f4907e278e0", size = 73075, upload-time = "2026-05-14T19:25:26.443Z" }, +] + +[[package]] +name = "rfc3339-validator" +version = "0.1.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "six" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/28/ea/a9387748e2d111c3c2b275ba970b735e04e15cdb1eb30693b6b5708c4dbd/rfc3339_validator-0.1.4.tar.gz", hash = "sha256:138a2abdf93304ad60530167e51d2dfb9549521a836871b88d7f4695d0022f6b", size = 5513, upload-time = "2021-05-12T16:37:54.178Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7b/44/4e421b96b67b2daff264473f7465db72fbdf36a07e05494f50300cc7b0c6/rfc3339_validator-0.1.4-py2.py3-none-any.whl", hash = "sha256:24f6ec1eda14ef823da9e36ec7113124b39c04d50a4d3d3a3c2859577e7791fa", size = 3490, upload-time = "2021-05-12T16:37:52.536Z" }, +] + +[[package]] +name = "rfc3986-validator" +version = "0.1.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/da/88/f270de456dd7d11dcc808abfa291ecdd3f45ff44e3b549ffa01b126464d0/rfc3986_validator-0.1.1.tar.gz", hash = "sha256:3d44bde7921b3b9ec3ae4e3adca370438eccebc676456449b145d533b240d055", size = 6760, upload-time = "2019-10-28T16:00:19.144Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9e/51/17023c0f8f1869d8806b979a2bffa3f861f26a3f1a66b094288323fba52f/rfc3986_validator-0.1.1-py2.py3-none-any.whl", hash = "sha256:2f235c432ef459970b4306369336b9d5dbdda31b510ca1e327636e01f528bfa9", size = 4242, upload-time = "2019-10-28T16:00:13.976Z" }, +] + +[[package]] +name = "rfc3987-syntax" +version = "1.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "lark" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/2c/06/37c1a5557acf449e8e406a830a05bf885ac47d33270aec454ef78675008d/rfc3987_syntax-1.1.0.tar.gz", hash = "sha256:717a62cbf33cffdd16dfa3a497d81ce48a660ea691b1ddd7be710c22f00b4a0d", size = 14239, upload-time = "2025-07-18T01:05:05.015Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7e/71/44ce230e1b7fadd372515a97e32a83011f906ddded8d03e3c6aafbdedbb7/rfc3987_syntax-1.1.0-py3-none-any.whl", hash = "sha256:6c3d97604e4c5ce9f714898e05401a0445a641cfa276432b0a648c80856f6a3f", size = 8046, upload-time = "2025-07-18T01:05:03.843Z" }, +] + +[[package]] +name = "rich" +version = "15.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markdown-it-py" }, + { name = "pygments" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c0/8f/0722ca900cc807c13a6a0c696dacf35430f72e0ec571c4275d2371fca3e9/rich-15.0.0.tar.gz", hash = "sha256:edd07a4824c6b40189fb7ac9bc4c52536e9780fbbfbddf6f1e2502c31b068c36", size = 230680, upload-time = "2026-04-12T08:24:00.75Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/82/3b/64d4899d73f91ba49a8c18a8ff3f0ea8f1c1d75481760df8c68ef5235bf5/rich-15.0.0-py3-none-any.whl", hash = "sha256:33bd4ef74232fb73fe9279a257718407f169c09b78a87ad3d296f548e27de0bb", size = 310654, upload-time = "2026-04-12T08:24:02.83Z" }, +] + +[[package]] +name = "roman-numerals" +version = "4.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ae/f9/41dc953bbeb056c17d5f7a519f50fdf010bd0553be2d630bc69d1e022703/roman_numerals-4.1.0.tar.gz", hash = "sha256:1af8b147eb1405d5839e78aeb93131690495fe9da5c91856cb33ad55a7f1e5b2", size = 9077, upload-time = "2025-12-17T18:25:34.381Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/04/54/6f679c435d28e0a568d8e8a7c0a93a09010818634c3c3907fc98d8983770/roman_numerals-4.1.0-py3-none-any.whl", hash = "sha256:647ba99caddc2cc1e55a51e4360689115551bf4476d90e8162cf8c345fe233c7", size = 7676, upload-time = "2025-12-17T18:25:33.098Z" }, +] + +[[package]] +name = "rpds-py" +version = "2026.6.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/aa/2a/9618a122aeb2a169a28b03889a2995fe297588964333d4a7d67bdf46e147/rpds_py-2026.6.3.tar.gz", hash = "sha256:1cebd1337c242e4ec2293e541f712b2da849b29f48f0c293684b71c0632625d4", size = 64051, upload-time = "2026-06-30T07:17:53.009Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5c/be/2e8974163072e7bab7df1a5acd54c4498e75e35d6d18b864d3a9d5dadc92/rpds_py-2026.6.3-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:a0811d33247c3d6128a3001d763f2aa056bb3425204335400ac54f89eec3a0d0", size = 343691, upload-time = "2026-06-30T07:15:14.96Z" }, + { url = "https://files.pythonhosted.org/packages/a4/73/319dfa745dd668efe89309141ded489126461fcecd2b8f3a3cda185129b6/rpds_py-2026.6.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:538949e262e46caa31ac01bdb3c1e8f642622922cacbabbae6a8445d9dc33eaf", size = 338542, upload-time = "2026-06-30T07:15:16.267Z" }, + { url = "https://files.pythonhosted.org/packages/21/63/4239893be1c4d09b709b1a8f6be4188f0870084ff547f46606b8a75f1b03/rpds_py-2026.6.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:55927d532399c2c646100ff7feb48eaa940ad70f42cd68e1328f3ded9f81ca24", size = 368180, upload-time = "2026-06-30T07:15:17.62Z" }, + { url = "https://files.pythonhosted.org/packages/1c/ca/9c5de382225234ceb37b1844ebdb140db12b2a278bb9efe2fcd19f6c82ce/rpds_py-2026.6.3-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f56f1695bc5c0871cbc33dc0130fcf503aab0c57dcc5a6700a4f49eba4f2652e", size = 375067, upload-time = "2026-06-30T07:15:18.952Z" }, + { url = "https://files.pythonhosted.org/packages/87/dc/863f69d1bf04ade34b7fe0d59b9fdf6f0135fe2d7cbca74f1d665589559d/rpds_py-2026.6.3-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:270b293dae9058fc9fcedab50f13cebf46fb8ed1d1d54e0521a9da5d6b211975", size = 490509, upload-time = "2026-06-30T07:15:20.434Z" }, + { url = "https://files.pythonhosted.org/packages/ce/ef/eac16a12048b45ec7c7fa94f2be3438a5f26bf9cc8580b18a1cfd609b7f6/rpds_py-2026.6.3-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:127565fead0a10943b282957bd5447804ff3160ad79f2ad2635e6d249e380680", size = 382754, upload-time = "2026-06-30T07:15:21.831Z" }, + { url = "https://files.pythonhosted.org/packages/04/8f/d2f3f532616be4d06c316ef119683e832bd3d41e112bf3a88f4151c95b17/rpds_py-2026.6.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ecabd69db66de867690f9797f2f8fa27ba501bbc24540cbdbdc649cd15888ba6", size = 366189, upload-time = "2026-06-30T07:15:23.371Z" }, + { url = "https://files.pythonhosted.org/packages/e3/29/41a7b0e98a4b44cd676ab7598419623373eb43b20be68c084935c1a8cf88/rpds_py-2026.6.3-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:58eadac9cd119677b60e1cf8ac4052f35949d71b8a9e5556efccbe82533cf22a", size = 377750, upload-time = "2026-06-30T07:15:24.659Z" }, + { url = "https://files.pythonhosted.org/packages/2e/05/ecda0bec46f9a1565090bcdc941d023f6a25aff85fda28f89f8d19878152/rpds_py-2026.6.3-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:7491ee23305ac3eb59e492b6945881f5cd77a6f731061a3f25b77fd40f9e99a4", size = 395576, upload-time = "2026-06-30T07:15:25.987Z" }, + { url = "https://files.pythonhosted.org/packages/68/a8/6ed52f03ee6cb854ce78785cc9a9a672eb880e83fd7224d471f667d151f1/rpds_py-2026.6.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2c99f7e8ccb3dd6e3e4bfeac657a7b208c9bac8075f4b078c02d7404c34107fa", size = 543807, upload-time = "2026-06-30T07:15:27.356Z" }, + { url = "https://files.pythonhosted.org/packages/8f/d6/156c0d3eea27ba09b92562ba2364ba124c0a061b199e17eac637cd25a5e2/rpds_py-2026.6.3-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:62698275682bf121181861295c9181e789030a2d516071f5b8f3c23c170cd0fc", size = 611187, upload-time = "2026-06-30T07:15:28.931Z" }, + { url = "https://files.pythonhosted.org/packages/f1/31/774212ed989c62f7f310220089f9b0a3fb8f40f5443d1727abd5d9f52bc9/rpds_py-2026.6.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a214c993455f99a89aaeadc9b21241900037adc9d97203e374d75513c5911822", size = 573030, upload-time = "2026-06-30T07:15:30.553Z" }, + { url = "https://files.pythonhosted.org/packages/c9/50/22f73127a41f1ce4f87fe39aadfb9a126345801c274aa93ae88456249327/rpds_py-2026.6.3-cp312-cp312-win32.whl", hash = "sha256:501f9f04a588d6a09179368c57071301445191767c64e4b52a6aa9871f1ef5ed", size = 202185, upload-time = "2026-06-30T07:15:32.027Z" }, + { url = "https://files.pythonhosted.org/packages/04/3a/f0ee4d4dde9d3b69dedf1b5f74e7a40017046d55052d173e418c6a94f960/rpds_py-2026.6.3-cp312-cp312-win_amd64.whl", hash = "sha256:2c958bf94822e9290a40aaf2a822d4bc5c88099093e3948ad6c571eca9272e5f", size = 220394, upload-time = "2026-06-30T07:15:33.359Z" }, + { url = "https://files.pythonhosted.org/packages/f3/83/3382fe37f809b59f02aac04dbc4e765b480b46ee0227ed516e3bdc4d3dfc/rpds_py-2026.6.3-cp312-cp312-win_arm64.whl", hash = "sha256:22bffe6042b9bcb0822bcd1955ec00e245daf17b4344e4ed8e9551b976b63e96", size = 215753, upload-time = "2026-06-30T07:15:34.778Z" }, + { url = "https://files.pythonhosted.org/packages/a4/9e/b818ee580026ec578138e961027a68820c40afeb1ec8f6819b54fb99e196/rpds_py-2026.6.3-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:3cfe765c1da0072636ca06628261e0ea05688e160d5c8a03e0217c3854037223", size = 343012, upload-time = "2026-06-30T07:15:36.005Z" }, + { url = "https://files.pythonhosted.org/packages/f3/6b/686d9dc4359a8f163cfbbf89ee0b4e586431de22fe8248edb63a8cf50d49/rpds_py-2026.6.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f4d78253f6996be4901669ad25319f842f740eccf4d58e3c7f3dd39e6dde1d8f", size = 338203, upload-time = "2026-06-30T07:15:37.462Z" }, + { url = "https://files.pythonhosted.org/packages/9e/9b/069aa329940f8207615e091f5eedbbd40e1e15eac68a0790fd05ccdf796c/rpds_py-2026.6.3-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:54f45a148e28767bf343d33a684693c70e451c6f4c0e9904709a723fafbdfc1f", size = 367984, upload-time = "2026-06-30T07:15:39.008Z" }, + { url = "https://files.pythonhosted.org/packages/14/db/34c203e4becff3703e4d3bc121842c00b8689197f398161203a880052f4e/rpds_py-2026.6.3-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:842e7b070435622248c7a2c44ae53fa1440e073cc3023bc919fed570884097a7", size = 374815, upload-time = "2026-06-30T07:15:40.253Z" }, + { url = "https://files.pythonhosted.org/packages/ee/7d/8071067d2cc453d916ad836e828c943f575e8a44612537759002a1e07381/rpds_py-2026.6.3-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8020133a74bd81b4572dd8e4be028a6b1ebcd70e6726edc3918008c08bee6ee6", size = 490545, upload-time = "2026-06-30T07:15:41.729Z" }, + { url = "https://files.pythonhosted.org/packages/a3/42/da06c5aa8f0484ff07f270787434204d9f4535e2f8c3b51ed402267e63c3/rpds_py-2026.6.3-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cdc7e35386f3847df728fbcb5e887e2d79c19e2fa1eba9e51b6621d23e3243af", size = 382828, upload-time = "2026-06-30T07:15:43.327Z" }, + { url = "https://files.pythonhosted.org/packages/57/d7/fe978efc2ae50abe48eb7464668ea99f53c010c60aeebb7b35ad27f23661/rpds_py-2026.6.3-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:acac386b453c2516111b50985d60ce46e7fadb5ea71ae7b25f4c946935bf27cf", size = 365678, upload-time = "2026-06-30T07:15:44.992Z" }, + { url = "https://files.pythonhosted.org/packages/69/9d/1d8922e1990b2a6eb532b6ff53d3e73d2b3bbffc84116c75826bee73dfc6/rpds_py-2026.6.3-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:425560c6fa0415f27261727bb20bd097568485e5eb0c121f1949417d1c516885", size = 377811, upload-time = "2026-06-30T07:15:46.523Z" }, + { url = "https://files.pythonhosted.org/packages/b1/3d/198dceafb4fb034a6a47347e1b0735d34e0bd4a50be4e898d408ee66cb14/rpds_py-2026.6.3-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:a550fb4950a06dde3beb4721f5ad4b25bf4513784665b0a8522c792e2bd822a4", size = 395382, upload-time = "2026-06-30T07:15:47.955Z" }, + { url = "https://files.pythonhosted.org/packages/1f/f1/13968e49655d40b6b19d8b9140296bbc6f1d86b3f0f6c346cf9f1adddf4b/rpds_py-2026.6.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4f4bca01b63096f606e095734dd56e74e175f94cfbf24ff3d63281cec61f7bb7", size = 543832, upload-time = "2026-06-30T07:15:49.33Z" }, + { url = "https://files.pythonhosted.org/packages/ac/ab/289bcb1b90bd3e40a2900c561fa0e2087345ecbb094f0b870f2345142b7c/rpds_py-2026.6.3-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:ccffae9a092a00deb7efd545fe5e2c33c33b88e7c054337e9a74c179347d0b7d", size = 611011, upload-time = "2026-06-30T07:15:50.847Z" }, + { url = "https://files.pythonhosted.org/packages/1e/16/5043105e679436ccfbc8e5e0dd2d663ed18a8b8113515fd06a5e5d77c83e/rpds_py-2026.6.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:1cf01971c4f2c5553b772a542e4aaf191789cd331bc2cd4ff0e6e65ba49e1e97", size = 572431, upload-time = "2026-06-30T07:15:52.394Z" }, + { url = "https://files.pythonhosted.org/packages/85/ed/adab103321c0a6565d5ae1c2998349bc3ee175b82ccc5ae8fc04cc413075/rpds_py-2026.6.3-cp313-cp313-win32.whl", hash = "sha256:8c3d1e9c15b9d51ca0391e13da1a25a0a4df3c58a37c9dc368e0736cf7f69df0", size = 201710, upload-time = "2026-06-30T07:15:53.894Z" }, + { url = "https://files.pythonhosted.org/packages/7b/ed/a03b09668e74e5dabbf2e211f6468e1820c0552f7b0500082da31841bf7b/rpds_py-2026.6.3-cp313-cp313-win_amd64.whl", hash = "sha256:9250a9a0a6fd4648b3f868da8d91a4c52b5811a62df58e753d50ae4454a36f80", size = 219454, upload-time = "2026-06-30T07:15:55.25Z" }, + { url = "https://files.pythonhosted.org/packages/27/17/b8642c12930b71bc2b25831f6708ccf0f75abcd11883932ec9ce54ba3a78/rpds_py-2026.6.3-cp313-cp313-win_arm64.whl", hash = "sha256:900a67df3fd1660b035a4761c4ce73c382ea6b35f90f9863c36c6fd8bf8b09bb", size = 215063, upload-time = "2026-06-30T07:15:56.573Z" }, + { url = "https://files.pythonhosted.org/packages/b6/36/7fbe9dcdaf857fb3f63c2a2284b62492d95f5e8334e947e5fb6e7f68c9be/rpds_py-2026.6.3-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:931908d9fc855d8f74783377822be318edb6dcb19e47169dc038f9a1bf60b06e", size = 344510, upload-time = "2026-06-30T07:15:57.921Z" }, + { url = "https://files.pythonhosted.org/packages/ba/54/f785cc3d3f60839ca57a5af4927a9f347b07b2799c373fc20f7949f87c7e/rpds_py-2026.6.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:d7469697dce35be237db177d42e2a2ee26e6dcc5fc052078a6fefabd288c6edd", size = 339495, upload-time = "2026-06-30T07:15:59.238Z" }, + { url = "https://files.pythonhosted.org/packages/63/ef/d4cdaf309e6b095b43597103cf8c0b951d6cca2acce68c474f75ec12e0c7/rpds_py-2026.6.3-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bcfbcf66006befb9fd2aeaa9e01feaf881b4dc330a02ba07d2322b1c11be7b5d", size = 369454, upload-time = "2026-06-30T07:16:01.021Z" }, + { url = "https://files.pythonhosted.org/packages/96/4a/9559a68b7ee15db09d7981212e8c2e219d2a1d6d4faa0391d813c3496a36/rpds_py-2026.6.3-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:847927daf4cffbd4e90e42bc890069897101edd015f956cb8721b3473372edda", size = 374583, upload-time = "2026-06-30T07:16:02.287Z" }, + { url = "https://files.pythonhosted.org/packages/ef/75/8964aa7d2c6e8ac43eba8eb6e6b0fdda1f46d39f2fc3e6aa9f2cb17f485d/rpds_py-2026.6.3-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:aca6c1ef08a82bfe327cc156da694660f599923e2e6665b6d81c9c2d0ac9ffc8", size = 492919, upload-time = "2026-06-30T07:16:03.723Z" }, + { url = "https://files.pythonhosted.org/packages/8f/97/6908094ac804115e65aedfd90f1b5fee4eebebd3f6c4cfc5419939267565/rpds_py-2026.6.3-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ae50181a047c871561212bb97f7932a2d45fb53e947bd9b57ebad85b529cbc53", size = 383725, upload-time = "2026-06-30T07:16:05.305Z" }, + { url = "https://files.pythonhosted.org/packages/d1/9c/0d1fdc2e7aba23e290d603bc494e97bd205bae262ce33c6b32a69768ed5e/rpds_py-2026.6.3-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dc319e5a1de4b6913aac94bf6a2f9e847371e0a140a43dd4991db1a09bc2d504", size = 367255, upload-time = "2026-06-30T07:16:07.086Z" }, + { url = "https://files.pythonhosted.org/packages/c4/fe/f0209ca4a9ed074bc8acb44dfd0e81c3122e94c9689f5645b7973a866719/rpds_py-2026.6.3-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:e4316bf32babbed84e691e352faf967ce2f0f024174a8643c37c94a1080374fc", size = 379060, upload-time = "2026-06-30T07:16:08.525Z" }, + { url = "https://files.pythonhosted.org/packages/c6/8d/f1cc54c616b9d8897de8738aac148d20afca93f68187475fe194d09a71b9/rpds_py-2026.6.3-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:8c6e5a2f750cc71c3e3b11d71661f21d6f9bc6cebc6564b1466417a1ec03ec77", size = 395960, upload-time = "2026-06-30T07:16:09.989Z" }, + { url = "https://files.pythonhosted.org/packages/fb/04/aafff00f73aeca2945f734f1d483c64ab8f472d0864ab02377fd8e89c3b2/rpds_py-2026.6.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:4470ce197d4090875cf6affbf1f853338387428df97c4fb7b7106317b8214698", size = 545356, upload-time = "2026-06-30T07:16:11.816Z" }, + { url = "https://files.pythonhosted.org/packages/fd/cc/e229663b9e4ddac5a4acbe9085dd80a71af2a5d356b8b39d6bff233f24b0/rpds_py-2026.6.3-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:ea964164cc9afa72d4d9b23cc28dafae93693c0a53e0b42acbff15b22c3f9ddd", size = 612319, upload-time = "2026-06-30T07:16:13.586Z" }, + { url = "https://files.pythonhosted.org/packages/e3/7a/8a0e6d3e6cd066af108b71b43122c3fe158dd9eb86acac626593a2582eb1/rpds_py-2026.6.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:639c8929aa0afe81be836b04de888460d6bed38b9c54cfc18da8f6bfabf5af5d", size = 573508, upload-time = "2026-06-30T07:16:15.23Z" }, + { url = "https://files.pythonhosted.org/packages/87/03/2a69ab618a789cf6cf85c86bb844c62d090e700ab1a2aa676b3741b6c516/rpds_py-2026.6.3-cp314-cp314-win32.whl", hash = "sha256:882076c00c0a608b131187055ddc5ae29f2e7eaf870d6168980420d58528a5c8", size = 202504, upload-time = "2026-06-30T07:16:16.893Z" }, + { url = "https://files.pythonhosted.org/packages/85/62/a3892ba945f4e24c78f352e5de3c7620d8479f73f211406a97263d13c7d2/rpds_py-2026.6.3-cp314-cp314-win_amd64.whl", hash = "sha256:0be972be84cfcaf46c8c6edf690ca0f154ac17babf1f6a955a51579b34ad2dc5", size = 220380, upload-time = "2026-06-30T07:16:18.108Z" }, + { url = "https://files.pythonhosted.org/packages/3d/e7/c2bd44dc831931815ad11ebb5f430b5a0a4d3caa9de837107876c30c3432/rpds_py-2026.6.3-cp314-cp314-win_arm64.whl", hash = "sha256:2a9c6f195058cb45335e8cc3802745c603d716eb96bc9625950c1aac71c0c703", size = 215976, upload-time = "2026-06-30T07:16:19.654Z" }, + { url = "https://files.pythonhosted.org/packages/79/9c/fff7b74bce9a091ec9a012a03f9ff5f69364eaf9451060dfc4486da2ffdd/rpds_py-2026.6.3-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:f90938e92afda60266da758ee7d363447f7f0138c9559f9e1811629580582d90", size = 346840, upload-time = "2026-06-30T07:16:21.268Z" }, + { url = "https://files.pythonhosted.org/packages/e9/44/77bcb1168b33704908295533d27f10eb811e9e3e193e8993dc99572211d3/rpds_py-2026.6.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ec829541c45bca16e61c7ae50c20501f213605beb75d1aba91a6ee37fbbb56a4", size = 340282, upload-time = "2026-06-30T07:16:22.875Z" }, + { url = "https://files.pythonhosted.org/packages/87/3c/7a9081c7c9e645b39efe19e4ffbeccd80add246327cd9b888aecffd72317/rpds_py-2026.6.3-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:afd70d95892096cdb26f15a00c45907b17817577aa8d1c76b2dcc2788391f9e9", size = 370403, upload-time = "2026-06-30T07:16:24.415Z" }, + { url = "https://files.pythonhosted.org/packages/f7/69/af47021eb7dad6ff3396cb001c08f0f3c4d06c20253f75be6421a59fe6b7/rpds_py-2026.6.3-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:29dfa0533a5d4c94d4dfa1b694fcb56c9c63aad8330ffdd816fd225d0a7a162f", size = 376055, upload-time = "2026-06-30T07:16:26.111Z" }, + { url = "https://files.pythonhosted.org/packages/81/fc/a3bcf517084396a6dd258c592567a3c011ba4557f2fde23dceaf26e74f2e/rpds_py-2026.6.3-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:af05d726809bff6b141be124d4c7ce998f9c9c7f30edb1f46c07aa103d540b41", size = 494419, upload-time = "2026-06-30T07:16:27.596Z" }, + { url = "https://files.pythonhosted.org/packages/c9/eb/13d529d1788135425c7bf207f8463458ca5d92e43f3f701365b83e9dffc1/rpds_py-2026.6.3-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9826217f048f620d9a712672818bf231442c1b35d96b227a07eabd11b4bb6945", size = 384848, upload-time = "2026-06-30T07:16:29.183Z" }, + { url = "https://files.pythonhosted.org/packages/8e/f4/b7ac49f30013aba8f7b9566b1dd07e81de95e708c1374b7bacc5b9bc5c9c/rpds_py-2026.6.3-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:536bceea4fa4acf7e1c61da2b5786304367c816c8895be71b8f537c480b0ea1f", size = 371369, upload-time = "2026-06-30T07:16:30.912Z" }, + { url = "https://files.pythonhosted.org/packages/31/86/6260bafa622f788b07ddec0e52d810305c8b9b0b8c27f58a2ab04bf62b4f/rpds_py-2026.6.3-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:bc0011654b91cc4fb2ae701bec0a0ba1e552c0714247fa7af6c59e0ccfa3a4e1", size = 379673, upload-time = "2026-06-30T07:16:32.486Z" }, + { url = "https://files.pythonhosted.org/packages/19/c3/03f1ee79a047b48daeca157c89a18509cde22b6b951d642b9b0af1be660a/rpds_py-2026.6.3-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:539d75de9e0d536c84ff18dfeb805398e58227001ce09231a26a08b9aed1ee0e", size = 397500, upload-time = "2026-06-30T07:16:34.471Z" }, + { url = "https://files.pythonhosted.org/packages/f0/95/8ed0cd8c377dca12aea498f119fe639fc474d1461545c39d2b5872eb1c0f/rpds_py-2026.6.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:166cf54d9f44fc6ceb53c7860258dde44a81406646de79f8ed3234fca3b6e538", size = 545978, upload-time = "2026-06-30T07:16:36.45Z" }, + { url = "https://files.pythonhosted.org/packages/d3/f2/0eb57f0eaa83f8fc152a7e03de968ab77e1f00732bebc892b190c6eebde7/rpds_py-2026.6.3-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:d34c20167764fbcf927194d532dd7e0c56772f0a5f943fa5ef9e9afbba8fb9db", size = 613350, upload-time = "2026-06-30T07:16:38.213Z" }, + { url = "https://files.pythonhosted.org/packages/5b/de/e0674bdbc3ef7634989b3f854c3f34bc1f587d36e5bfdc5c378d57034619/rpds_py-2026.6.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ea7bb13b7c9a29791f87a0387ba7d3ad3a6d783d827e4d3f27b40a0ff44495e2", size = 576486, upload-time = "2026-06-30T07:16:39.797Z" }, + { url = "https://files.pythonhosted.org/packages/f2/f6/21101359743cd136ada781e8210a85769578422ba460672eea0e29739200/rpds_py-2026.6.3-cp314-cp314t-win32.whl", hash = "sha256:6de4744d05bd1aa1be4ed7ea1189e3979196808008113bbbf899a460966b925e", size = 201068, upload-time = "2026-06-30T07:16:41.316Z" }, + { url = "https://files.pythonhosted.org/packages/a6/b2/9574d4d44f7760c2aa32d92a0a4f41698e33f5b204a0bf5c9758f52c79d5/rpds_py-2026.6.3-cp314-cp314t-win_amd64.whl", hash = "sha256:c7b9a2f8f4d8e90af72571d3d495deebdd7e3c75451f5b41719aee166e940fc2", size = 220600, upload-time = "2026-06-30T07:16:43.091Z" }, + { url = "https://files.pythonhosted.org/packages/08/ae/f23a2697e6ee6340a578b0f136be6483657bef0c6f9497b752bb5c0964bb/rpds_py-2026.6.3-cp315-cp315-macosx_10_12_x86_64.whl", hash = "sha256:e059c5dde6452b44424bd1834557556c226b57781dee1227af23518459722b13", size = 344726, upload-time = "2026-06-30T07:16:44.5Z" }, + { url = "https://files.pythonhosted.org/packages/c3/63/e7b3a1a5358dd32c930a1062d8e15b67fd6e8922e81df9e91706d66ee5c8/rpds_py-2026.6.3-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:2f7c26fbc5acd2522b95d4177fe4710ffd8e9b20529e703ffbf8db4d93903f05", size = 339587, upload-time = "2026-06-30T07:16:46.255Z" }, + { url = "https://files.pythonhosted.org/packages/ec/64/10a85681916ca55fffb91b0a211f84e34297c109243484dd6394660a8a7c/rpds_py-2026.6.3-cp315-cp315-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a3086b538543802f84c843911242db20447de00d8752dd0efc936dbcf02218ba", size = 369585, upload-time = "2026-06-30T07:16:48.101Z" }, + { url = "https://files.pythonhosted.org/packages/76/c2/baf95c7c38823e12ba34407c5f5767a89e5cf2233895e56f608167ae9493/rpds_py-2026.6.3-cp315-cp315-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:8f2e5c5ee828d42cb11760761c0af6507927bec42d0ad5458f97c9203b054617", size = 375479, upload-time = "2026-06-30T07:16:49.93Z" }, + { url = "https://files.pythonhosted.org/packages/6a/94/0aad06c72d65101e11d33528d438cda99a39ce0da99466e156158f2541d3/rpds_py-2026.6.3-cp315-cp315-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ed0c1e5d10cdc7135537988c74a0188da68e2f3c30813ba3744ab1e42e0480f9", size = 492418, upload-time = "2026-06-30T07:16:51.641Z" }, + { url = "https://files.pythonhosted.org/packages/b5/17/de3f5a479a1f056535d7489819639d8cd591ea6281d700390b43b1abd745/rpds_py-2026.6.3-cp315-cp315-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8c2642a7603ec0b16ed77da4555db3b4b472341904873788327c0b0d7b95f1bb", size = 384123, upload-time = "2026-06-30T07:16:53.622Z" }, + { url = "https://files.pythonhosted.org/packages/46/7d/bf09bd1b145bb2671c03e1e6d1ab8651858d90d8c7dfeadd85a37a934fd8/rpds_py-2026.6.3-cp315-cp315-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8e4320744c1ffdd95a603def63344bfab2d33edeab301c5007e7de9f9f5b3885", size = 367351, upload-time = "2026-06-30T07:16:55.241Z" }, + { url = "https://files.pythonhosted.org/packages/a3/ea/1bb734f314b8be319149ddee80b18bd41372bdcfbdf88d28131c0cd37719/rpds_py-2026.6.3-cp315-cp315-manylinux_2_31_riscv64.whl", hash = "sha256:a9f4645593036b81bbdb36b9c8e0ea0d1c3fee968c4d59db0344c14087ef143a", size = 378827, upload-time = "2026-06-30T07:16:56.841Z" }, + { url = "https://files.pythonhosted.org/packages/4b/93/d9611e5b25e26df9a3649813ed66193ace9347a7c7fc4ab7cf70e94851c0/rpds_py-2026.6.3-cp315-cp315-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:e55d236be29255554da47abe5c577637db7c24a02b8b46f0ca9524c855801868", size = 395966, upload-time = "2026-06-30T07:16:58.557Z" }, + { url = "https://files.pythonhosted.org/packages/c3/cb/99d77e16e5534ae1d90629bbe419ba6ee170833a6a85e3aa1cc41726fbbc/rpds_py-2026.6.3-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:24e9c5386e16669b674a69c156c8eeefcb578f3b3397b713b08e6d60f3c7b187", size = 545680, upload-time = "2026-06-30T07:17:00.164Z" }, + { url = "https://files.pythonhosted.org/packages/59/15/11a29755f790cef7a2f755e8e14f4f0c33f39489e1893a632a2eee59672b/rpds_py-2026.6.3-cp315-cp315-musllinux_1_2_i686.whl", hash = "sha256:c60924535c75f1566b6eb75b5c31a48a43fef04fa2d0d201acbad8a9969c6107", size = 611853, upload-time = "2026-06-30T07:17:01.962Z" }, + { url = "https://files.pythonhosted.org/packages/68/86/0c27547e21644da938fb530f7e1a8148dd24d02db07e7a5f2567a17ce710/rpds_py-2026.6.3-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:38a2fea2787428f811719ceb9114cb78964a3138838320c29ac39526c79c16ba", size = 573715, upload-time = "2026-06-30T07:17:03.693Z" }, + { url = "https://files.pythonhosted.org/packages/29/71/4d8fcf700931815594bce892255bbd973b94efaf0fc1932b0590df18d886/rpds_py-2026.6.3-cp315-cp315-win32.whl", hash = "sha256:d483fe17f01ad64b7bf7cc38fcefff1ca9fb83f8c2b2542b68f97ffe0611b369", size = 202864, upload-time = "2026-06-30T07:17:05.746Z" }, + { url = "https://files.pythonhosted.org/packages/eb/62/b577562de0edbb55b2be85ce5fd09c33e386b9b13eee09833af4240fd5c4/rpds_py-2026.6.3-cp315-cp315-win_amd64.whl", hash = "sha256:67e3a721ffc5d8d2210d3671872298c4a84e4b8035cfe42ffd7cde35d772b146", size = 220430, upload-time = "2026-06-30T07:17:07.471Z" }, + { url = "https://files.pythonhosted.org/packages/c8/95/d6d0b2509825141eef60669a5739eec88dbc6a48053d6c92993a5704defe/rpds_py-2026.6.3-cp315-cp315-win_arm64.whl", hash = "sha256:6e84adbcf4bf841aed8116a8264b9f50b4cb3e7bd89b516122e616ac56ca269e", size = 215877, upload-time = "2026-06-30T07:17:09.008Z" }, + { url = "https://files.pythonhosted.org/packages/b7/bf/f3ea278f0afd615c1d0f19cb69043a41526e2bb600c2b536eb192218eb27/rpds_py-2026.6.3-cp315-cp315t-macosx_10_12_x86_64.whl", hash = "sha256:ae6dd8f10bd17aad820876d24caec9efdafd80a318d16c0a48edb5e136902c6b", size = 346933, upload-time = "2026-06-30T07:17:10.762Z" }, + { url = "https://files.pythonhosted.org/packages/9d/29/9907bdf1c5346763cf10b7f6852aad86652168c259def904cbe0082c5864/rpds_py-2026.6.3-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:bdbd97738551fca3917c1bd7188bec1920bb520104f28e7e1007f9ceb17b7690", size = 340274, upload-time = "2026-06-30T07:17:12.266Z" }, + { url = "https://files.pythonhosted.org/packages/6f/2c/8e03767b5778ef25cebf74a7a91a2c3806f8eced4c92cb7406bbe060756d/rpds_py-2026.6.3-cp315-cp315t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8b95977e7211527ab0ba576e286d023389fbeeb32a6b7b771665d333c60e5342", size = 370763, upload-time = "2026-06-30T07:17:14.107Z" }, + { url = "https://files.pythonhosted.org/packages/2e/e1/df2a7e1ba2efd796af26194250b8d42c821b46592311595162af9ef0528d/rpds_py-2026.6.3-cp315-cp315t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:d15fde0e6fb0d88a60d221204873743e5d9f0b7d29165e62cd86d0413ad74ba6", size = 376467, upload-time = "2026-06-30T07:17:15.76Z" }, + { url = "https://files.pythonhosted.org/packages/6b/de/8a0814d1946af29cb068fb259aa8622f856df1d0bab58429448726b537f5/rpds_py-2026.6.3-cp315-cp315t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a136d453475ac0fcbda502ef1e6504bd28d6d904700915d278deeab0d00fe140", size = 496689, upload-time = "2026-06-30T07:17:17.308Z" }, + { url = "https://files.pythonhosted.org/packages/df/f3/f19e0c852ba13694f5a79f3b719331051573cb5693feacf8a88ffffc3a71/rpds_py-2026.6.3-cp315-cp315t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f826877d462181e5eb1c26a0026b8d0cab05d99844ecb6d8bf3627a2ca0c0442", size = 385340, upload-time = "2026-06-30T07:17:18.928Z" }, + { url = "https://files.pythonhosted.org/packages/e2/ae/7ec3a9d2d4351f99e37bcb06b6b6f954512646bfdbf9742e1de727865daf/rpds_py-2026.6.3-cp315-cp315t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:79486287de1730dbaff3dbd124d0ca4d2ef7f9d29bf2544f1f93c09b5bcbbd12", size = 372179, upload-time = "2026-06-30T07:17:20.539Z" }, + { url = "https://files.pythonhosted.org/packages/d3/ac/9cee911dff2aaa9a5a8354f6610bf2e6a616de9197c5fff4f54f82585f1e/rpds_py-2026.6.3-cp315-cp315t-manylinux_2_31_riscv64.whl", hash = "sha256:808345f53cb952433ca2816f1604ff3515608a81784954f38d4452acfe8e61d5", size = 379993, upload-time = "2026-06-30T07:17:22.212Z" }, + { url = "https://files.pythonhosted.org/packages/83/6b/7c2a07ba88d1e9a936612f7a5d067467ed03d971d5a06f7d309dff044a7e/rpds_py-2026.6.3-cp315-cp315t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:1967debc37f64f2c4dc90a7f563aec558b471966e12adcac4e1c4240496b6ebf", size = 398909, upload-time = "2026-06-30T07:17:23.66Z" }, + { url = "https://files.pythonhosted.org/packages/97/0b/776ffcb66783637b0031f6d58d6fb55913c8b5abf00aeecd46bf933fb477/rpds_py-2026.6.3-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:f0840b5b17057f7fd918b76183a4b5a0635f43e14eb2ce60dce1d4ee4707ea00", size = 546584, upload-time = "2026-06-30T07:17:25.264Z" }, + { url = "https://files.pythonhosted.org/packages/55/33/ba3bc04d7092bd553c9b2b195624992d2cc4f3de1f380b7b93cbee67bd79/rpds_py-2026.6.3-cp315-cp315t-musllinux_1_2_i686.whl", hash = "sha256:faa679d19a6696fd54259ad321251ad77a13e70e03dd834daa762a44fb6196ef", size = 614357, upload-time = "2026-06-30T07:17:26.888Z" }, + { url = "https://files.pythonhosted.org/packages/8b/71/14edf065f04630b1a8472f7653cad03f6c478bcf95ea0e6aed55451e33ea/rpds_py-2026.6.3-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:23a439f31ccbeff1574e24889128821d1f7917470e830cf6544dced1c662262a", size = 576533, upload-time = "2026-06-30T07:17:28.546Z" }, + { url = "https://files.pythonhosted.org/packages/ba/76/65002b08596c389105720a8c0d22298b8dc25a4baf89b2ce431343c8b1de/rpds_py-2026.6.3-cp315-cp315t-win32.whl", hash = "sha256:913ca42ccad3f8cc6e292b587ae8ae49c8c823e5dce51a736252fc7c7cdfa577", size = 201204, upload-time = "2026-06-30T07:17:30.193Z" }, + { url = "https://files.pythonhosted.org/packages/8c/97/d855d6b3c322d1f27e26f5241c42016b56cf01377ea8ed348285f54652f0/rpds_py-2026.6.3-cp315-cp315t-win_amd64.whl", hash = "sha256:ae3d4fe8c0b9213624fdce7279d70e3b148b682ca20719ebd193a23ebfa47324", size = 220719, upload-time = "2026-06-30T07:17:31.788Z" }, +] + +[[package]] +name = "ruff" +version = "0.16.7" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/82/bb/5a449b9162e49b139d72f61672bd3ac1d790221f796d3304e2241fff4c58/ruff-0.16.7.tar.gz", hash = "sha256:5f71d004ac1263b22fa39462ac5ae618a4b77d58981af2cc79bf79a29c12b1a6", size = 4924184, upload-time = "2026-09-10T18:04:06.336Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e3/b2/c80aeeb7f9e469c0d63a85d2f1ab6e1ebfbe10ea7a8d2438b7e09e3ff09e/ruff-0.16.7-py3-none-linux_armv6l.whl", hash = "sha256:727307773e7c7f9181d3ed3a2484186e56c1fa1874255911c74585eb2c7c19f9", size = 10048917, upload-time = "2026-09-10T18:03:30.28Z" }, + { url = "https://files.pythonhosted.org/packages/7b/96/20bb7bcae008004df52afcb7ac83432d4a467f2c17b672fe46d26be231c5/ruff-0.16.7-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:9d61c258deabf58f34c67bd4bb4d939c7f2e6b5f0e59c1cdd1cf771b11cde929", size = 10242929, upload-time = "2026-09-10T18:03:32.706Z" }, + { url = "https://files.pythonhosted.org/packages/90/b2/f184b0d5abec02db69cfd7e49b688ae0237554528ca777136c613bf36bee/ruff-0.16.7-py3-none-macosx_11_0_arm64.whl", hash = "sha256:7ab81118df8945e0193d0240712aa4496573595b75185c3636ed825592a0f728", size = 9847245, upload-time = "2026-09-10T18:03:34.509Z" }, + { url = "https://files.pythonhosted.org/packages/eb/2d/db1633a641866ed801e34cc6b60ef236c5e16f9b2124ab1d49cc24a5fe4f/ruff-0.16.7-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4c196c968874fc8019da8e7163de7a1a370f111e2309b4b7dfea0fce950198d0", size = 9961780, upload-time = "2026-09-10T18:03:36.618Z" }, + { url = "https://files.pythonhosted.org/packages/4d/98/edea21e1a3e38dbbc3bf6bb068b863b3b06184cf8533a4c7dbbe208a89d5/ruff-0.16.7-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ac8c3bd0a7e10ad31e6ce51e7a99f3cb772e69aecdd6b9ea7e99b362f62a62c0", size = 9866337, upload-time = "2026-09-10T18:03:38.805Z" }, + { url = "https://files.pythonhosted.org/packages/0b/11/a15e60d4c87b214646f116ca9d204475bf993ee1047459bc9a360fd4d6d1/ruff-0.16.7-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:398d3988edde000b5c75dc1b3f584708da9bc990de069c18909142580fec1af9", size = 10562512, upload-time = "2026-09-10T18:03:40.71Z" }, + { url = "https://files.pythonhosted.org/packages/29/42/eaff4c9b6d0c7cdf56df313a17e89ae854f5bbc0b0c8f9cce19be0ab7a8f/ruff-0.16.7-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ce05b62b770a8217c4646a9c4139fca00efe8fe5d71f87df2b243ff20d4584d1", size = 11302938, upload-time = "2026-09-10T18:03:42.607Z" }, + { url = "https://files.pythonhosted.org/packages/5d/43/c75aa59a4ec181fe2ec06cab30e198c1c6d107229a9f008ae3a7c16cabd8/ruff-0.16.7-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:af1b576fddb9d9ef2ececfb5fadcd6a624b25070ed85e3cfcfe449fc3ff6a7b9", size = 10840857, upload-time = "2026-09-10T18:03:44.604Z" }, + { url = "https://files.pythonhosted.org/packages/21/33/81f3da371942ea031105ba679d8d6e28ec1660ccd690a45f42d381161356/ruff-0.16.7-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9ce7f8f22df67c93ed96c717f9128eadb797144ac2bad475cf536f31d6100c55", size = 10370001, upload-time = "2026-09-10T18:03:46.706Z" }, + { url = "https://files.pythonhosted.org/packages/fa/0b/6345fb4dbf6dd0ed1cfe5d18391dc9c3f59cc81622a7b0a65b84b3e730ba/ruff-0.16.7-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:06d0e93d04f392996435ebd600c153f65b47d73fbec2415aa99c5ee5756b3a5f", size = 10548735, upload-time = "2026-09-10T18:03:48.658Z" }, + { url = "https://files.pythonhosted.org/packages/3f/4d/c5576adf511f92a328e5569dda190ecdd430da51f1a649f3a4a2fd73e21e/ruff-0.16.7-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:142151a5e7b93c1b11111337142f89dd2fbfee92161225c99a97222f22e32656", size = 10108496, upload-time = "2026-09-10T18:03:50.563Z" }, + { url = "https://files.pythonhosted.org/packages/ff/8c/667d83c16199a17a56adc6b0bd4c3beb5b767a2babcd16a56f76f9be7fd6/ruff-0.16.7-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:e6651f97a342d8b35d54d8991544ca22169b86dc54111cb604666940c431b750", size = 9860136, upload-time = "2026-09-10T18:03:52.621Z" }, + { url = "https://files.pythonhosted.org/packages/99/75/78d401106731999a1dd20cc5a6961e37e1eb9397a3b589f73f3a5ce146a3/ruff-0.16.7-py3-none-musllinux_1_2_i686.whl", hash = "sha256:ef140c6eb935fa9a84c9c607dfb2cb1b85843c192e79265b0c54f35f557ea8e5", size = 10286290, upload-time = "2026-09-10T18:03:55.207Z" }, + { url = "https://files.pythonhosted.org/packages/68/49/56f9c3a8b755df93a0ad318b2147bf4ef5dae9a7e5ec61c460109c67957f/ruff-0.16.7-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:53e39506a730fadeee0d998ed5946f30671f0db240c6c7c73bdabbe33604bb6f", size = 10745048, upload-time = "2026-09-10T18:03:57.299Z" }, + { url = "https://files.pythonhosted.org/packages/5f/ea/7f9b938a63ece4bec677ad7f9f7fa02df3383db1949ed93a382441c09a87/ruff-0.16.7-py3-none-win32.whl", hash = "sha256:2ea3470fcebcbc5df2fb0c6f3b90333fa9084c534e0111c038fa4a6ab9f1c4b7", size = 10059082, upload-time = "2026-09-10T18:03:59.632Z" }, + { url = "https://files.pythonhosted.org/packages/39/11/480a6973a927aa653e1cead6a6416008640e03a99d05b34c0434b8c6c366/ruff-0.16.7-py3-none-win_amd64.whl", hash = "sha256:7ac26aca826e9e21d0f1cb25b54ac660760a9fdd094d3e4df9848232be98cfc6", size = 10593368, upload-time = "2026-09-10T18:04:01.999Z" }, + { url = "https://files.pythonhosted.org/packages/8b/4b/51327018d056f0dad2c2238f26d1fb0f53707a9d91b75dea6d1b3039f136/ruff-0.16.7-py3-none-win_arm64.whl", hash = "sha256:aab7f39e2c9df6c596216070f98eef1207b94f8516cca20c808826974971855b", size = 10412401, upload-time = "2026-09-10T18:04:04.098Z" }, +] + +[[package]] +name = "rxmc" +source = { editable = "." } +dependencies = [ + { name = "exfor-tools" }, + { name = "jax" }, + { name = "jitr" }, + { name = "numpy" }, + { name = "scipy" }, + { name = "tinygp" }, +] + +[package.optional-dependencies] +docs = [ + { name = "myst-nb" }, + { name = "pydata-sphinx-theme" }, + { name = "sphinx" }, + { name = "sphinx-copybutton" }, +] +examples = [ + { name = "blackjax" }, + { name = "corner" }, + { name = "dill" }, + { name = "dynesty" }, + { name = "emcee" }, + { name = "ipykernel" }, + { name = "jupyter" }, + { name = "matplotlib" }, + { name = "pocomc" }, + { name = "torch", version = "2.15.0", source = { registry = "https://download.pytorch.org/whl/cpu" }, marker = "sys_platform == 'darwin'" }, + { name = "torch", version = "2.15.0+cpu", source = { registry = "https://download.pytorch.org/whl/cpu" }, marker = "sys_platform != 'darwin'" }, + { name = "tqdm" }, +] +samplers = [ + { name = "ptemcee" }, + { name = "pymc" }, +] +validation = [ + { name = "black" }, + { name = "blackjax" }, + { name = "build" }, + { name = "corner" }, + { name = "dill" }, + { name = "dynesty" }, + { name = "emcee" }, + { name = "ipykernel" }, + { name = "isort" }, + { name = "jupyter" }, + { name = "matplotlib" }, + { name = "nbmake" }, + { name = "nbqa" }, + { name = "pocomc" }, + { name = "pytest" }, + { name = "ruff" }, + { name = "scikit-learn" }, + { name = "torch", version = "2.15.0", source = { registry = "https://download.pytorch.org/whl/cpu" }, marker = "sys_platform == 'darwin'" }, + { name = "torch", version = "2.15.0+cpu", source = { registry = "https://download.pytorch.org/whl/cpu" }, marker = "sys_platform != 'darwin'" }, + { name = "tqdm" }, +] + +[package.metadata] +requires-dist = [ + { name = "black", marker = "extra == 'validation'", specifier = ">=24.0" }, + { name = "blackjax", marker = "extra == 'examples'", specifier = ">=1.2" }, + { name = "blackjax", marker = "extra == 'validation'", specifier = ">=1.2" }, + { name = "build", marker = "extra == 'validation'", specifier = ">=1.2" }, + { name = "corner", marker = "extra == 'examples'", specifier = ">=2.2" }, + { name = "corner", marker = "extra == 'validation'", specifier = ">=2.2" }, + { name = "dill", marker = "extra == 'examples'", specifier = ">=0.3" }, + { name = "dill", marker = "extra == 'validation'", specifier = ">=0.3" }, + { name = "dynesty", marker = "extra == 'examples'", specifier = ">=2.1" }, + { name = "dynesty", marker = "extra == 'validation'", specifier = ">=2.1" }, + { name = "emcee", marker = "extra == 'examples'", specifier = ">=3.1" }, + { name = "emcee", marker = "extra == 'validation'", specifier = ">=3.1" }, + { name = "exfor-tools", specifier = ">=0.4" }, + { name = "ipykernel", marker = "extra == 'examples'", specifier = ">=6.0" }, + { name = "ipykernel", marker = "extra == 'validation'", specifier = ">=6.0" }, + { name = "isort", marker = "extra == 'validation'", specifier = ">=5.13" }, + { name = "jax", specifier = ">=0.4.35" }, + { name = "jitr", git = "https://github.com/beykyle/jitr?rev=jax-core" }, + { name = "jupyter", marker = "extra == 'examples'", specifier = ">=1.0" }, + { name = "jupyter", marker = "extra == 'validation'", specifier = ">=1.0" }, + { name = "matplotlib", marker = "extra == 'examples'", specifier = ">=3.8" }, + { name = "matplotlib", marker = "extra == 'validation'", specifier = ">=3.8" }, + { name = "myst-nb", marker = "extra == 'docs'", specifier = ">=1.0" }, + { name = "nbmake", marker = "extra == 'validation'", specifier = ">=1.5" }, + { name = "nbqa", marker = "extra == 'validation'", specifier = ">=1.9" }, + { name = "numpy", specifier = ">=2.2.6" }, + { name = "pocomc", marker = "extra == 'examples'", specifier = ">=1.2" }, + { name = "pocomc", marker = "extra == 'validation'", specifier = ">=1.2" }, + { name = "ptemcee", marker = "extra == 'samplers'", git = "https://github.com/NuclearTalent/ptemcee_2025?rev=modernize" }, + { name = "pydata-sphinx-theme", marker = "extra == 'docs'", specifier = ">=0.15" }, + { name = "pymc", marker = "extra == 'samplers'", specifier = ">=5.0" }, + { name = "pytest", marker = "extra == 'validation'", specifier = ">=8.0" }, + { name = "ruff", marker = "extra == 'validation'", specifier = ">=0.6" }, + { name = "scikit-learn", marker = "extra == 'validation'", specifier = ">=1.0" }, + { name = "scipy", specifier = ">=1.15" }, + { name = "sphinx", marker = "extra == 'docs'", specifier = ">=7.0" }, + { name = "sphinx-copybutton", marker = "extra == 'docs'", specifier = ">=0.5" }, + { name = "tinygp", specifier = ">=0.3" }, + { name = "torch", marker = "extra == 'examples'", index = "https://download.pytorch.org/whl/cpu" }, + { name = "torch", marker = "extra == 'validation'", index = "https://download.pytorch.org/whl/cpu" }, + { name = "tqdm", marker = "extra == 'examples'", specifier = ">=4.66" }, + { name = "tqdm", marker = "extra == 'validation'", specifier = ">=4.66" }, +] +provides-extras = ["docs", "examples", "validation", "samplers"] + +[[package]] +name = "scikit-learn" +version = "1.9.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "joblib" }, + { name = "narwhals" }, + { name = "numpy" }, + { name = "scipy" }, + { name = "threadpoolctl" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/d2/eb/eaf5e07fcc0da7149b0e084f24e54edd7441b9a89ce7e034032ae97fe3a0/scikit_learn-1.9.1.tar.gz", hash = "sha256:629cada3e33e2b9bf376cdc7614a47a4140b8aedc1d836579e359736fbd82977", size = 7786908, upload-time = "2026-09-10T18:34:04.679Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/df/a7/25f0a43d2fde306e8ef45f45121192f687b79beaf4bae8c21607c46c5e63/scikit_learn-1.9.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:0c0f8b5d09b44101cea2767f300680bada1ea27f976fe4b48b83950a4f55a49a", size = 8775209, upload-time = "2026-09-10T18:32:42.804Z" }, + { url = "https://files.pythonhosted.org/packages/60/ea/57e57539ce175d774fc291ed091b0a6d756854b92cd92554c6bb4d0ae498/scikit_learn-1.9.1-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:8c14ce41d561f7749f990b41d6703fe02c4669fbc485e598e069e0a1967b488e", size = 8295541, upload-time = "2026-09-10T18:32:45.069Z" }, + { url = "https://files.pythonhosted.org/packages/78/2b/5721a174406bfba49bce20ae997b3b64cf355c3f623a2638284ab6a82156/scikit_learn-1.9.1-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e4c20a6c017d820faa7ac8c783e3d0c6a9a2e297bf9f55332ca17cdf7fd4d04d", size = 8871592, upload-time = "2026-09-10T18:32:46.999Z" }, + { url = "https://files.pythonhosted.org/packages/8e/57/a50162f3d29feb979ab6347c6debda506dfb525bcff3c50dd17606651c7e/scikit_learn-1.9.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e5d7b18a5b9dca241a74695f3275fa4c895a9dadc72b3d8df5fa9d1083c9b83e", size = 9166043, upload-time = "2026-09-10T18:32:49.343Z" }, + { url = "https://files.pythonhosted.org/packages/72/8d/27c054166bac671770d1ea0ef7716134fe8119c0df224a58c89fd735a61c/scikit_learn-1.9.1-cp312-cp312-win_amd64.whl", hash = "sha256:4b59abb30618121cc46b45972d6bf53a7128b4df4cd346c6ca6f4d5f9031e49c", size = 8262238, upload-time = "2026-09-10T18:32:51.679Z" }, + { url = "https://files.pythonhosted.org/packages/9d/d6/493086006ea0c68ad62c40a8dece1961b61bf503f45400f133d47f56e5be/scikit_learn-1.9.1-cp312-cp312-win_arm64.whl", hash = "sha256:d5945a2908be62350e2978344e62b56c1552c2ca4f844ebf6277c94944d647dd", size = 7902102, upload-time = "2026-09-10T18:32:53.67Z" }, + { url = "https://files.pythonhosted.org/packages/bb/8d/b60d5e7354ff0ff5cc9400e60273696589d87a30b8b2235886a76d80d062/scikit_learn-1.9.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:2c2b312fd8c02951a364fa120ea08c1cec10d863466bf1701b013152d7537835", size = 8739300, upload-time = "2026-09-10T18:32:55.483Z" }, + { url = "https://files.pythonhosted.org/packages/2f/81/3c6392c03665d2899457a76e535a9a6f597dddddf3220fd2e1d790da88c5/scikit_learn-1.9.1-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:61cd968ab831a76d0ecbaf0347ab2270268716da28f94fd022497e3d6f205f13", size = 8262364, upload-time = "2026-09-10T18:32:57.966Z" }, + { url = "https://files.pythonhosted.org/packages/0f/35/a15b8653499692879821301d48059376d6e68e8b65cd0f22d19b6ee83cd9/scikit_learn-1.9.1-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5990f9c69e431bfaddcde1a6d7c5355243e026bc9b9e560c13893b90dab53fb4", size = 8823698, upload-time = "2026-09-10T18:33:00.632Z" }, + { url = "https://files.pythonhosted.org/packages/23/e5/688703d357e5393f708d98eb189fd415ae69e39f6de03c6bd4005aef6118/scikit_learn-1.9.1-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:55e79d6e9b0923f1a978179822bd43d7f5543f45e970a00fe861f43486380aba", size = 9121732, upload-time = "2026-09-10T18:33:02.825Z" }, + { url = "https://files.pythonhosted.org/packages/96/45/a10add34c08184d373be9384660c75758128ca881ed27b503b6f6a742478/scikit_learn-1.9.1-cp313-cp313-win_amd64.whl", hash = "sha256:2070f271e5375dc42c6bb93b461ab1c0aa5841d4009267e0cfd95a39dca94a43", size = 8237244, upload-time = "2026-09-10T18:33:05.26Z" }, + { url = "https://files.pythonhosted.org/packages/9e/08/7a89bcdadd1fff0d464d01056417b646c9abcbc54f7297a0a1203bba5ebb/scikit_learn-1.9.1-cp313-cp313-win_arm64.whl", hash = "sha256:613f0a783ca05aa844a4e1ac42d48425058f2c52be73f40f8cd98b7cd111acd6", size = 7875398, upload-time = "2026-09-10T18:33:07.506Z" }, + { url = "https://files.pythonhosted.org/packages/64/e3/b58e45082dcf3dcf0eb1192ee03545ec43d8c98441dfe20e88afca8442ce/scikit_learn-1.9.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:d5d117952769b563067656784e03c75a2d8235a7a05cf7fffa78a311e75aac08", size = 8747414, upload-time = "2026-09-10T18:33:10.698Z" }, + { url = "https://files.pythonhosted.org/packages/9b/ed/d68115577c8b42b0442ebd8180945d4008880a33176094640e00b585128e/scikit_learn-1.9.1-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:8893bc6331f60f18d4ac75e12ed356e2dcf6a564bf767918b5b7ca54c8c8be49", size = 8279175, upload-time = "2026-09-10T18:33:12.846Z" }, + { url = "https://files.pythonhosted.org/packages/c4/6c/06c7eb61a438e389cbf3f7210897069bec5a883dbe03c189ae792781e11a/scikit_learn-1.9.1-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b5492cf2df5226691c32611de8734bcf42148c6547ae53c7f4e6b847793addc0", size = 8881706, upload-time = "2026-09-10T18:33:14.741Z" }, + { url = "https://files.pythonhosted.org/packages/86/4e/0bab75490ca4b85fad8388739c7ebc71d9db553f8c69e39943ee8db0aaae/scikit_learn-1.9.1-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:993d332ff80e62efae9e39603b7e872297c418d780f01a01855269a3489c950f", size = 9152030, upload-time = "2026-09-10T18:33:17.436Z" }, + { url = "https://files.pythonhosted.org/packages/9a/13/31c6f8ba1b7eecef9dd9558576c752d2ec5785fd0e456bb9fc59305be23f/scikit_learn-1.9.1-cp314-cp314-win_amd64.whl", hash = "sha256:ca9051447455dae341d4d591eece7deb2d8e3d1020298fc87a81fc51e4da8f53", size = 8377024, upload-time = "2026-09-10T18:33:19.941Z" }, + { url = "https://files.pythonhosted.org/packages/62/e6/6d3cb8a45f5228f915acd66b819dd6b8232ccbe24532f51d278e3991df31/scikit_learn-1.9.1-cp314-cp314-win_arm64.whl", hash = "sha256:90de6573f733a9fb79476ff1371af52a397d41c8b35f9146e20923db010d67b6", size = 8014196, upload-time = "2026-09-10T18:33:22.126Z" }, + { url = "https://files.pythonhosted.org/packages/66/6e/6befb2d5961490d18d9dbc16a5df37aa121d08bc9893316a6a363977a903/scikit_learn-1.9.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:7b5cad1624de8b75e5b9ccb7b0ce1ff1d01306340a3efc56d5529c5ba92392eb", size = 9066066, upload-time = "2026-09-10T18:33:24.396Z" }, + { url = "https://files.pythonhosted.org/packages/cb/18/11271f2f7db337db01f598e358721b1e83989407131272e5dd64214c28a8/scikit_learn-1.9.1-cp314-cp314t-macosx_12_0_arm64.whl", hash = "sha256:d137ce8a6142029fb5c35bd82f470c40cd9e760e5e2f7694b362c497c4ab3fa2", size = 8647654, upload-time = "2026-09-10T18:33:26.649Z" }, + { url = "https://files.pythonhosted.org/packages/e7/04/9c15d201e1b6a2e81b8215865df7646c5a360f560831769c8dc92ac1ab9a/scikit_learn-1.9.1-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:66f852f7325b5070bc28329005aca76055a2def78faac039548ae889aeaa45a6", size = 8889070, upload-time = "2026-09-10T18:33:28.95Z" }, + { url = "https://files.pythonhosted.org/packages/1a/5a/4cb6c85160af4a639e87a3b7bf8b1c25cfc3b504c5af710ca416a6dcfc5f/scikit_learn-1.9.1-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:748bcb0a4cc04aec470652c9e5ec68450948e867387e7dfade647107ade68d25", size = 9131227, upload-time = "2026-09-10T18:33:31.008Z" }, + { url = "https://files.pythonhosted.org/packages/00/0e/361440972ae3d19b90ea88a84791138a51de0e8432a770ba741b2c8d9ced/scikit_learn-1.9.1-cp314-cp314t-win_amd64.whl", hash = "sha256:38cd925e893e5539be704d5edc64dbe081aacdab6b89d8c2977c1f6a7a453ce5", size = 8683001, upload-time = "2026-09-10T18:33:33.188Z" }, + { url = "https://files.pythonhosted.org/packages/e2/8f/a9f405c5c0e2df6f343a871b40c97fb32969e3ccc38e3033dd118f3c261e/scikit_learn-1.9.1-cp314-cp314t-win_arm64.whl", hash = "sha256:b01e5b01735d38474127ca3f49319b592506225a87793b27559816b5c75cea39", size = 8257996, upload-time = "2026-09-10T18:33:35.343Z" }, + { url = "https://files.pythonhosted.org/packages/e5/c5/74a83ea39cef7cd07f53e06cc1cf51e79f35df74f81db956835d59ec34b1/scikit_learn-1.9.1-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:8dec64f31a6e0ec826aca6c1b39a51e16d946e400d4c0904316f3ca72ccfb825", size = 8747991, upload-time = "2026-09-10T18:33:37.4Z" }, + { url = "https://files.pythonhosted.org/packages/64/c9/cc93e8a7fe204e43d70e96e5eb89871643be20025eea05eb4fdaf19afe39/scikit_learn-1.9.1-cp315-cp315-macosx_12_0_arm64.whl", hash = "sha256:e1b468241f4a7a9a7a0d6479ad3cc47681cc151a4046c530f2777c3d68f08942", size = 8279340, upload-time = "2026-09-10T18:33:39.705Z" }, + { url = "https://files.pythonhosted.org/packages/a2/61/0c6080f0d356fb966053009e7f25e9bff6cf74b0b16195ccf0c3757d1ae8/scikit_learn-1.9.1-cp315-cp315-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8ca869d0080a5723cde2d5a8b54a2da1ff7e68735a9e9adb3da1243183a0fa01", size = 8881917, upload-time = "2026-09-10T18:33:41.912Z" }, + { url = "https://files.pythonhosted.org/packages/47/bb/98a31f10fffbd39edcc2f8bf4119b29652248bb110b7d45c84e68aa293ab/scikit_learn-1.9.1-cp315-cp315-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6754b7cabfc3df0b1f7b38f7a344f559bbae9d82f0ac5e3d48cccbd19fdcefdf", size = 9152805, upload-time = "2026-09-10T18:33:44.23Z" }, + { url = "https://files.pythonhosted.org/packages/f6/48/858ceff52213cfd97c0a069362071756bcb70b9fac9771b38d87c4cf7f17/scikit_learn-1.9.1-cp315-cp315-win_amd64.whl", hash = "sha256:52cfdb1fed3a34362dbc0bd96f2e761a66fd5724d6901629f5a558f1f3bd9849", size = 8376719, upload-time = "2026-09-10T18:33:46.492Z" }, + { url = "https://files.pythonhosted.org/packages/2a/1e/5337a871bdea53effbd154b61429df048f2665653251de74a3bd8a6dea9e/scikit_learn-1.9.1-cp315-cp315-win_arm64.whl", hash = "sha256:ae6571a4828c6f5019bcd2b4125e5b18c0af3dbc9c99726c891f45f41335ec8e", size = 8014341, upload-time = "2026-09-10T18:33:48.762Z" }, + { url = "https://files.pythonhosted.org/packages/0e/35/150383a42d83ec4c7b39f9c50bd68408ecf04c19fc30ea5198fa42e67d9c/scikit_learn-1.9.1-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:48fefd8eb42bd4eec3e2d348149368ccd6d71987e20c30706a56a24eb86a6e73", size = 9059953, upload-time = "2026-09-10T18:33:50.951Z" }, + { url = "https://files.pythonhosted.org/packages/9f/dd/aa0d738808540f7eaacfab93e01982db8ef1c1c7473ef0ad38193e6aebd1/scikit_learn-1.9.1-cp315-cp315t-macosx_12_0_arm64.whl", hash = "sha256:09f4d73049cd63575157f6b1060e06a8c83a4bd3488dbfaeedf35ccba7aad712", size = 8646602, upload-time = "2026-09-10T18:33:53.23Z" }, + { url = "https://files.pythonhosted.org/packages/7e/cc/687ae4214c2f598906c3b9fa5f86fbaf834b35e20360625528ff1b713f06/scikit_learn-1.9.1-cp315-cp315t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b3da53831534214322d9cb240fa6f390b36cf69eba727a6d4bd3238677630d70", size = 8880366, upload-time = "2026-09-10T18:33:55.764Z" }, + { url = "https://files.pythonhosted.org/packages/c2/03/82215cb78ad1c513a4498777571fb28444621ad26ef636287551767b7732/scikit_learn-1.9.1-cp315-cp315t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:caae15634feceafa2612566b109a3082d3293167fac388eedaf77bff66b51983", size = 9129640, upload-time = "2026-09-10T18:33:58.186Z" }, + { url = "https://files.pythonhosted.org/packages/d4/90/4b7af4efd7909a4a0524a9f18457e4eb2eb60616eff2c7627eda8e3cdceb/scikit_learn-1.9.1-cp315-cp315t-win_amd64.whl", hash = "sha256:ffbcbbbb44202fbe9bc64bced25a145759adb9ef010b3d37a8064958ac13df2a", size = 8678083, upload-time = "2026-09-10T18:34:00.354Z" }, + { url = "https://files.pythonhosted.org/packages/31/27/068e484d4b83004302e0d9cfc1faca69bcc010d76fbb66a642446095af1b/scikit_learn-1.9.1-cp315-cp315t-win_arm64.whl", hash = "sha256:800dd22dd87fe97dcea484c24e85dd93cf1734d86bd74e668ad18f7967f4d1b5", size = 8259434, upload-time = "2026-09-10T18:34:02.678Z" }, +] + +[[package]] +name = "scipy" +version = "1.18.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/7e/74/66de6258867beb2ef08f35f9f2ac017a52cacd5081714d239ff1a442d458/scipy-1.18.1.tar.gz", hash = "sha256:52c4b7422442aba924d03ad4019852b08a92e64ea187b933135687bfe2747307", size = 30781235, upload-time = "2026-08-21T23:28:50.599Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/18/f7/240c110c08693826b4513a52f5717d62ec7c7af72f2920821247c03b17b3/scipy-1.18.1-cp312-cp312-macosx_10_15_x86_64.whl", hash = "sha256:457fd7a2a8edeb044ab6ffbc0aa03ff6cd18491356e5e0c834d76ce621b916d1", size = 31111061, upload-time = "2026-08-21T23:23:44.522Z" }, + { url = "https://files.pythonhosted.org/packages/05/4a/78c6285577c375e7cf27277ea8ee6961224327f1e1a0c44af5f17f23635c/scipy-1.18.1-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:e708533e8b2ae2497d65346538a7dcc92814410b25b81432eac66de0f2af8265", size = 28733332, upload-time = "2026-08-21T23:23:50.015Z" }, + { url = "https://files.pythonhosted.org/packages/a5/f6/a5b82f8abbe14d134691b8b903696f701d25a081353a29dc655c364d9e62/scipy-1.18.1-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:7bbf207c4453ce1ad2e00b17313852b33310b83090c2311bdaf97f93c0380d12", size = 20475078, upload-time = "2026-08-21T23:23:54.138Z" }, + { url = "https://files.pythonhosted.org/packages/23/22/0858a0bbd6b3e825ceb8cd9baf9eaf3b2f2b1d77727eb6be40500bcdc92f/scipy-1.18.1-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:78c0665edead396b1abb4897c41a5c1d9bf090c8a637a4c20a61678e0a264e66", size = 23108904, upload-time = "2026-08-21T23:23:57.824Z" }, + { url = "https://files.pythonhosted.org/packages/75/9a/2e71719f31eaefe0e3a1706c4a1ded94e664bfd95ffca2b219a671faee01/scipy-1.18.1-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3c085faa2cfa879c5141df483f836f4d691045a078224a670fa570fa01612d89", size = 34025113, upload-time = "2026-08-21T23:24:02.209Z" }, + { url = "https://files.pythonhosted.org/packages/df/64/ff35eb9e54894cf471ff4716abd3c81eb0a0626869217ce3e6ba4ccf17d7/scipy-1.18.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f55fa87b6c612ecd6b058f167c53231b1d14e412efe361d3d6e38b3631c73218", size = 35344199, upload-time = "2026-08-21T23:24:07.844Z" }, + { url = "https://files.pythonhosted.org/packages/d3/af/c5538be1792f7034c12c7db6ee67cace58253c7b87b122d68253eaf5de89/scipy-1.18.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:c35d74ce0e193ff740c2f2be2ac913ddc232fe6c1ff40b26cfecb9c670c63314", size = 35639587, upload-time = "2026-08-21T23:24:13.05Z" }, + { url = "https://files.pythonhosted.org/packages/91/4c/075e4f66471bac101141ac739e9e135549be1bae584571bd03a530c056e1/scipy-1.18.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:d2924a03db38dc2e848bca2fe9f077dafb891480b91a00a0963a8cf86dfc31c1", size = 37480330, upload-time = "2026-08-21T23:24:19.608Z" }, + { url = "https://files.pythonhosted.org/packages/39/e7/979fd14e75008623df31ba70d6bb144700f68feadcea042021c06a05bf82/scipy-1.18.1-cp312-cp312-win_amd64.whl", hash = "sha256:5e4d44984abc0020154ea81b247adeddcc3ac5527b975ff798bd1ba0adc513c2", size = 36658278, upload-time = "2026-08-21T23:24:25.463Z" }, + { url = "https://files.pythonhosted.org/packages/c7/0b/e1525354ff9d7d5feb6d1b31af6d14072e5c91e9607b421fa1ec889660b3/scipy-1.18.1-cp312-cp312-win_arm64.whl", hash = "sha256:d65d448389b8436493abcf629cc94ad0cf32aecaf06e1acca1de53cc795f2f12", size = 24400588, upload-time = "2026-08-21T23:24:30.579Z" }, + { url = "https://files.pythonhosted.org/packages/b6/55/4540ee0f9c42a9ad7109d0d1a8cc70de54c3572b01c6693a2b1c70e90ceb/scipy-1.18.1-cp313-cp313-macosx_10_15_x86_64.whl", hash = "sha256:3ab3523da44749156e1f68b464dc56af11ae4cbc5c739a49d05f32b982eca9f3", size = 31089958, upload-time = "2026-08-21T23:24:35.8Z" }, + { url = "https://files.pythonhosted.org/packages/2a/f5/769f36d14922b8071a43e95d24d18b6bdafad10d7f5cf647867e1ac052bc/scipy-1.18.1-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:e6fb6a55cc0ba97b59a1f288fb86dc6fce8bdfc0fffcbfd015e3a954bf2a2d93", size = 28715106, upload-time = "2026-08-21T23:24:40.775Z" }, + { url = "https://files.pythonhosted.org/packages/9a/d7/21d890274f75ea37a8209d5519e72da3da90302e3b9fb8397a0918386a62/scipy-1.18.1-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:ea324d9dd34c38bfb9bec8ca4d1b407db97dbb74029f566b8e322b1b6fe56fe6", size = 20456846, upload-time = "2026-08-21T23:24:45.066Z" }, + { url = "https://files.pythonhosted.org/packages/ec/01/798430ecea2e78ec7c02663d5f71c007bb6abeca931080debd40d7fa55ea/scipy-1.18.1-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:75b00eb8fb802090aa903f4ea1c7f5a584779f967361e68b7e98e531cc2d7174", size = 23087986, upload-time = "2026-08-21T23:24:49.539Z" }, + { url = "https://files.pythonhosted.org/packages/e6/5f/4634e9d35c68496e4e34cb6946eafab044458e6cedab42b40b6588e475b6/scipy-1.18.1-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d416b16cccfd70fbf62400e84d0bb2f4e6af519a45557f1692c749b37f14b315", size = 33998146, upload-time = "2026-08-21T23:24:54.714Z" }, + { url = "https://files.pythonhosted.org/packages/41/48/6450ed9243315322bbc19ac57b9b70d66a20bf1d38d124c96bc4bf6af9ea/scipy-1.18.1-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fdaf5ea890a6183d0565f51a61799d67081bd5b1cf03c5f4b3fd3732108625c9", size = 35312578, upload-time = "2026-08-21T23:25:00.44Z" }, + { url = "https://files.pythonhosted.org/packages/00/bd/bf5a4be6a3525676499f6dff307991739ff6fdcad1481b1aeb6745339f58/scipy-1.18.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:c825cef2f49e46753726a7181a8e199804a912b29519ada542c6ebc654951899", size = 35612621, upload-time = "2026-08-21T23:25:06.144Z" }, + { url = "https://files.pythonhosted.org/packages/bd/4e/3c45c33e00a77996c4b1cb707929f833ba7b1d522ee29f882512c330676d/scipy-1.18.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e3b417bf8c2c7c16e8f58ad91db17783ec911ac16e7b50eb6eab6e809b4f5b07", size = 37457323, upload-time = "2026-08-21T23:25:12.483Z" }, + { url = "https://files.pythonhosted.org/packages/93/0e/e0348fbc0dbab65c114cf78957e7dfeb49f8e8b556b4d930cc12ff195e18/scipy-1.18.1-cp313-cp313-win_amd64.whl", hash = "sha256:559ed65f60c1af5a03f3912605a1b5114f522c7c32fb23c3376ae8f03219fe28", size = 36622841, upload-time = "2026-08-21T23:25:18.722Z" }, + { url = "https://files.pythonhosted.org/packages/50/a8/6a77f5f267c555108f0a864b6db714363dab567a8266422a79a385f9232b/scipy-1.18.1-cp313-cp313-win_arm64.whl", hash = "sha256:cd479fc04dd9401e3b4f49e76518768ef99c4f517a98c284eb091fd725719adf", size = 24399315, upload-time = "2026-08-21T23:25:23.458Z" }, + { url = "https://files.pythonhosted.org/packages/06/d5/d8eb4e280ddb56a4ab2c6f02ee49b56b23f6e977cf0802fd6d68dbef14f5/scipy-1.18.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:83de5453a7799afc9048b4616bd085cef126e36412f0ea2f6370c36a2a3a51e7", size = 31090936, upload-time = "2026-08-21T23:25:28.686Z" }, + { url = "https://files.pythonhosted.org/packages/2a/49/59ea385dc3a62ff498ddf3cfff7c2b41b0f9f9d3c4122b3f1dcb6d6327fe/scipy-1.18.1-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:9554bcc6d715ee87a633a3cc8e7703c6628b100dd29cb8a2efc4c0533c7ff729", size = 28725221, upload-time = "2026-08-21T23:25:33.244Z" }, + { url = "https://files.pythonhosted.org/packages/70/e8/6b0c288c50942d78193696c9f15f9a0874f5178aa0ddf40f83d9924b3e8d/scipy-1.18.1-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:011413b7426b75012840e35649e00fe0a2c3bae89fed433876e3a99251572efc", size = 20466839, upload-time = "2026-08-21T23:25:37.516Z" }, + { url = "https://files.pythonhosted.org/packages/4b/e0/54fd3793c729e3b936782f181b59cbb1205bf250ab605a16cb1ba61cdd5e/scipy-1.18.1-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:88f0e784020649f88ea48c9f5ddfa403bf9205820667c0914740b392035afb82", size = 23089121, upload-time = "2026-08-21T23:25:42.019Z" }, + { url = "https://files.pythonhosted.org/packages/0b/56/030af62bea3cf878e0028515dff78c123b01633606a879b63f42d2db99cc/scipy-1.18.1-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2d3ab0e8c69a17dd3559eab8cbb88f258e285c94d572c2719033f90f83290c89", size = 34053851, upload-time = "2026-08-21T23:25:47.998Z" }, + { url = "https://files.pythonhosted.org/packages/6b/89/2a844506d49651e9aa1af6ef95b6bd8031cb1d5a4375edec6155037e04cf/scipy-1.18.1-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ac0333bdf38309aa3dcbe7e3fa7ea29e7a2c37c6ea306a757b700ded8e4596ad", size = 35329183, upload-time = "2026-08-21T23:25:53.522Z" }, + { url = "https://files.pythonhosted.org/packages/eb/56/c7370c3640e92ac9613cbf26cb3f729f9b12ddf1727b55b94b53b24d6f48/scipy-1.18.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:911de823097db8b63f034299d12662db93344e6ffa0b881cbb57748974b70168", size = 35672551, upload-time = "2026-08-21T23:25:59.387Z" }, + { url = "https://files.pythonhosted.org/packages/24/16/ec8536f351421f8bf60a1120930638f83790f4710b8230446aca3d6159d4/scipy-1.18.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:95298364e251be3e60249facbeeca03631d3bb7584f85879516ec55ac717b81f", size = 37469416, upload-time = "2026-08-21T23:26:05.432Z" }, + { url = "https://files.pythonhosted.org/packages/52/94/d73da0d28f16c45bb9b0a5691b91610b0275c5ef0eb5e43c87cf2dc1bf31/scipy-1.18.1-cp314-cp314-win_amd64.whl", hash = "sha256:78a0d7c918e74a232394117160e7e3db503377572a45bcef8826e4ab8a35feba", size = 37362755, upload-time = "2026-08-21T23:26:11.366Z" }, + { url = "https://files.pythonhosted.org/packages/89/25/e996e4dc74e10e227b1e14db5eaf6608bb6dd33884a64851c38f18dd4249/scipy-1.18.1-cp314-cp314-win_arm64.whl", hash = "sha256:cbf38d043c1aa4ab306e1ada6ab6eddacc3322a20b7af1b30bc93254b366fe09", size = 25036090, upload-time = "2026-08-21T23:26:15.887Z" }, + { url = "https://files.pythonhosted.org/packages/fa/c9/c00213f92309d753b48903e6a451b87eb52ff5b7a16e789d1568bbf221c4/scipy-1.18.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:0fcb3c93519f27bb4f0c4b0f7802cdcaca7fcf93267b75edda2e9f4e8a55cbd7", size = 31485550, upload-time = "2026-08-21T23:26:20.776Z" }, + { url = "https://files.pythonhosted.org/packages/74/b2/e3067c487982d4eeab2938928529410370c06fea84a4d3f4925e7d96647d/scipy-1.18.1-cp314-cp314t-macosx_12_0_arm64.whl", hash = "sha256:ddef79fb382df40104a19bb7151b3b23e57c1778fcf857c71ceecd9bd264513f", size = 29174642, upload-time = "2026-08-21T23:26:25.395Z" }, + { url = "https://files.pythonhosted.org/packages/d5/ab/374c9fe2d1ec014e576c781a4b5d8e1ba340e8f6b4638c16f711d2b194f0/scipy-1.18.1-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:0e82073ecc7acc6436fac4b31674109c7e1d3e596789767eda01258a8c9e8123", size = 20916357, upload-time = "2026-08-21T23:26:30.112Z" }, + { url = "https://files.pythonhosted.org/packages/90/38/223915c88a17317cafbf8ca2a42b11c265a9fb1e804aa665544132b5fe8a/scipy-1.18.1-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:8bcf3c1ba5d6456e2effd30fcbd3459b044d683fcdac79a2e6830f0bdf7de487", size = 23482611, upload-time = "2026-08-21T23:26:34.846Z" }, + { url = "https://files.pythonhosted.org/packages/c4/d1/db0948da8ca57a80b36520ef0a768b967d99f3af65f4b6f1bf6362ad4dd4/scipy-1.18.1-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:cfbf154f2ba187f2ed6cce2639efff7d105f1140573642c0161615b6d91d6a87", size = 34143202, upload-time = "2026-08-21T23:26:40.4Z" }, + { url = "https://files.pythonhosted.org/packages/87/53/39d046cc7574ed6acacb6bd5723e220107ece80bff12faaf3efc4ddeede4/scipy-1.18.1-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a1d33a7836f7ddc1993427966a0823468ec41bcbdb1a9f9942d1d7e57f803ba3", size = 35380876, upload-time = "2026-08-21T23:26:46.1Z" }, + { url = "https://files.pythonhosted.org/packages/f9/da/32e0e799d875a85ca57d9bde6c78148afcc0e38276df683d95854eadc8c3/scipy-1.18.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:7f4b8bc363b6d65ee2152bec57568e3c52639bb34c46057b09857a307ed5e21d", size = 35770885, upload-time = "2026-08-21T23:26:51.533Z" }, + { url = "https://files.pythonhosted.org/packages/88/2e/f97a666d362fee68b18f41c9c30ed502ca5c98b549749bfcb52a8b74d1eb/scipy-1.18.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:11c423f1049c5755ad4409af52a9ada1cff96fe9b50795d4af3619f292901239", size = 37525424, upload-time = "2026-08-21T23:26:56.751Z" }, + { url = "https://files.pythonhosted.org/packages/ca/d5/a9e765a84654ebba8479a1fd1b059ced1af72b168a3b2a3a46540ea38d20/scipy-1.18.1-cp314-cp314t-win_amd64.whl", hash = "sha256:c24acac1e18912761c4700239bbc1fd32f615af690f1584d49b35859be51324d", size = 37416961, upload-time = "2026-08-21T23:27:01.546Z" }, + { url = "https://files.pythonhosted.org/packages/ee/16/e79e0d1c63ef698879d85439d37e9fb434e3b804e506a6991038d086ebd9/scipy-1.18.1-cp314-cp314t-win_arm64.whl", hash = "sha256:9f2897bf7737392ad0d5213ea7b6add72a4edf5679b3153106aeb88b6507b3b9", size = 25331848, upload-time = "2026-08-21T23:27:05.884Z" }, + { url = "https://files.pythonhosted.org/packages/be/4f/1bd37c883b67163e2ca1f60977a399500e6879c15defecac62831c8d078d/scipy-1.18.1-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:eb0dfcf4e28a99c12c999744a2ff67c9b06200e20401c7c88186e33552a46331", size = 31091484, upload-time = "2026-08-21T23:27:11.051Z" }, + { url = "https://files.pythonhosted.org/packages/8c/c5/ba929d7feb9b2332f96827c12e0e924b61973b59b4dea383b603372c65ce/scipy-1.18.1-cp315-cp315-macosx_12_0_arm64.whl", hash = "sha256:30f464bee641fa8e282577c7dce027308403213c6ca8270bba73285c91024bc5", size = 28725057, upload-time = "2026-08-21T23:27:15.9Z" }, + { url = "https://files.pythonhosted.org/packages/a4/19/68f1c50f609d955d230e66d25d02bd3e1e167ec540232135354fb9a4b9e3/scipy-1.18.1-cp315-cp315-macosx_14_0_arm64.whl", hash = "sha256:1bca3b943fc2567ea49cd02c99abde49da4d5178ec46f624bd8255cda8755beb", size = 20466734, upload-time = "2026-08-21T23:27:20.044Z" }, + { url = "https://files.pythonhosted.org/packages/ef/6d/319fa29b73d1802fa80b32a6eaf3f5be456ef81526da2716a9493bcb5501/scipy-1.18.1-cp315-cp315-macosx_14_0_x86_64.whl", hash = "sha256:c9d18a33309122074ea483dd92dd444189166b8b2ec429fe9ed5ac73c7a0aa23", size = 23089664, upload-time = "2026-08-21T23:27:24.345Z" }, + { url = "https://files.pythonhosted.org/packages/b7/db/30992f9b51a63de671daf3888ffd18378b6cb9ec9f2c972264238ffa7fd6/scipy-1.18.1-cp315-cp315-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:82f201b4c878551d48558337aab270d3c6cca5507b8737c8d8a608d234cccde0", size = 34054035, upload-time = "2026-08-21T23:27:29.409Z" }, + { url = "https://files.pythonhosted.org/packages/91/d4/bf3e735dc0b9d5a8ff45079d2540e17d3aff7a2f0048dd8f552ffd031d2b/scipy-1.18.1-cp315-cp315-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0ac49ea97594532dd44b7136094d35f5440fa06e6d9c6384a74c01764df388c5", size = 35333883, upload-time = "2026-08-21T23:27:34.293Z" }, + { url = "https://files.pythonhosted.org/packages/19/93/12d78ce9f871fe945fca588d32644e6e63f553c2a35c564d73f3b22a3313/scipy-1.18.1-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:ceb30a00ce7c92d459819443d29ca486d882b83fb6738bdcbb2a1cce94ac5daa", size = 35673124, upload-time = "2026-08-21T23:27:39.059Z" }, + { url = "https://files.pythonhosted.org/packages/70/cd/886219313a1012a48e6ae0ec4f302c837151beb92e1ff0d709ef8fdfc488/scipy-1.18.1-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:f29633129f9fa7e88a3f0fca835de2d030bfc9643f7799e1a0c46cee24d38fc7", size = 37470753, upload-time = "2026-08-21T23:27:44.435Z" }, + { url = "https://files.pythonhosted.org/packages/17/6c/a776888ce618bee54fbde26172f0f46ac1da70d27b63861797fe78e1904b/scipy-1.18.1-cp315-cp315-win_amd64.whl", hash = "sha256:92c14f5bdbfb6216315ce33e78080474082de8b3830122ba97809bfbe65f75c0", size = 37361483, upload-time = "2026-08-21T23:27:49.334Z" }, + { url = "https://files.pythonhosted.org/packages/ab/09/97b651691322ebee97999b017ffc18a15a0b815103844c97e8da9d469731/scipy-1.18.1-cp315-cp315-win_arm64.whl", hash = "sha256:e402cf31eb68f453dbb2d36fc6d722b33f24a55d68b2ae1d92fa6305ca71c298", size = 25035883, upload-time = "2026-08-21T23:27:53.596Z" }, + { url = "https://files.pythonhosted.org/packages/ed/0f/9ec20467bbabd0d44e2a77d0fd3d124f884b4d67df92af82c91d2d6a486f/scipy-1.18.1-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:2a0b02f9fc46f8520330c23d45e6560db7e3a0d927232139427637f98943e11d", size = 31474926, upload-time = "2026-08-21T23:27:57.993Z" }, + { url = "https://files.pythonhosted.org/packages/8a/58/dcb79161e56efbedc50079fcd2f5fe427a0ebb53022eb476aa73c015ad8f/scipy-1.18.1-cp315-cp315t-macosx_12_0_arm64.whl", hash = "sha256:1d73131e358976663dd969e1fb4ed1404b815cd977eaaedc3b3a133ba2d81c35", size = 29164940, upload-time = "2026-08-21T23:28:03.062Z" }, + { url = "https://files.pythonhosted.org/packages/71/d3/1eeea80c817fcb8ef7bd4a05a58824977a0e57a375cfc3d7ea7c911c01ad/scipy-1.18.1-cp315-cp315t-macosx_14_0_arm64.whl", hash = "sha256:bff0b729edd992766136b34e39cc76bc2fad905aa58897ee72a9cd000a6d8443", size = 20906742, upload-time = "2026-08-21T23:28:07.642Z" }, + { url = "https://files.pythonhosted.org/packages/54/46/e59350428b6099301a20128108c995e2eb175a43f383af9a346e38824f9b/scipy-1.18.1-cp315-cp315t-macosx_14_0_x86_64.whl", hash = "sha256:10ac20c69d880f77f375db44c22e3e6a644f9fefa291d4cd2fb9790a89fc99fd", size = 23472183, upload-time = "2026-08-21T23:28:12.109Z" }, + { url = "https://files.pythonhosted.org/packages/89/31/cc91623fa98f0621766a0f0aaaadb2c66de74a7ea7e3837164f6e4354260/scipy-1.18.1-cp315-cp315t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:33a834464fdabc0f26a45508df31b3cc5d028e04dbf6c5ed398541418e0a12fe", size = 34130796, upload-time = "2026-08-21T23:28:17.906Z" }, + { url = "https://files.pythonhosted.org/packages/fc/3e/8572ef536957ddb8aa81bb4090d9e25f257e3b4e05d97deb54319deb8a3a/scipy-1.18.1-cp315-cp315t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:49023963c193dacee096301452f223ee24d86ec5807f8df93c0f7221d119e305", size = 35374253, upload-time = "2026-08-21T23:28:23.732Z" }, + { url = "https://files.pythonhosted.org/packages/b5/c6/59fdeffb4f1435299f93d9dc8140b43ad2916e6cfc944be6c3041fcec86d/scipy-1.18.1-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:d84a09d0dad90ba6525d8ac1c2334b33e64bf3ccfe9e841f02feb867a22681e4", size = 35758543, upload-time = "2026-08-21T23:28:29.431Z" }, + { url = "https://files.pythonhosted.org/packages/cf/d9/135be205d9de8783193aff9cc3bf483a03a38e4b29432c954e8cb66ac14e/scipy-1.18.1-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:179ce34a8d0fe273d8883ba59e17e052247d08973dfcb743ca52bb1cce2d60b0", size = 37521946, upload-time = "2026-08-21T23:28:35.245Z" }, + { url = "https://files.pythonhosted.org/packages/5c/a2/5b7d5270621ab7cfa3f7766067bf95dc360b5efb6394694e8143b4156e2b/scipy-1.18.1-cp315-cp315t-win_amd64.whl", hash = "sha256:5632e3ae3d09197c446310cd5187de63e28448ce22f0f67b2b93d97503c0c230", size = 37408295, upload-time = "2026-08-21T23:28:40.724Z" }, + { url = "https://files.pythonhosted.org/packages/63/ad/741c19fcb66755ff953daf9243af8480e4bf3d7fbe57583c178c7d2b6b51/scipy-1.18.1-cp315-cp315t-win_arm64.whl", hash = "sha256:eda632a7981f69730d6281f451db9c1c370993a2c0d7ddb43e2a809a2862b83a", size = 25319710, upload-time = "2026-08-21T23:28:45.713Z" }, +] + +[[package]] +name = "send2trash" +version = "2.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/c5/f0/184b4b5f8d00f2a92cf96eec8967a3d550b52cf94362dad1100df9e48d57/send2trash-2.1.0.tar.gz", hash = "sha256:1c72b39f09457db3c05ce1d19158c2cbef4c32b8bedd02c155e49282b7ea7459", size = 17255, upload-time = "2026-01-14T06:27:36.056Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1c/78/504fdd027da3b84ff1aecd9f6957e65f35134534ccc6da8628eb71e76d3f/send2trash-2.1.0-py3-none-any.whl", hash = "sha256:0da2f112e6d6bb22de6aa6daa7e144831a4febf2a87261451c4ad849fe9a873c", size = 17610, upload-time = "2026-01-14T06:27:35.218Z" }, +] + +[[package]] +name = "setuptools" +version = "84.2.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/70/b3/c19426f783614d625699a4b247faf628ea9ab1db228674491767b417f9e1/setuptools-84.2.1.tar.gz", hash = "sha256:3ff8b3b5492a0aa66960f4419365a86b84e013070d4313e4d4a6894f5d64d6bc", size = 1230289, upload-time = "2026-10-20T19:01:37.742Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ef/55/6dc6d6bb953bdfc52519a0059592c52b6e3b8ad51cf8256dffceb55b0610/setuptools-84.2.1-py3-none-any.whl", hash = "sha256:ca140b45d5325a9478f880e351484f62fef15f336462e449ca0c03c873d589c2", size = 876263, upload-time = "2026-10-20T19:01:35.678Z" }, +] + +[[package]] +name = "six" +version = "1.17.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031, upload-time = "2024-12-04T17:35:28.174Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050, upload-time = "2024-12-04T17:35:26.475Z" }, +] + +[[package]] +name = "snowballstemmer" +version = "3.1.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/43/f8/0a71edf031f03c40db17503cb8ca78a69a171254e568e7db241b0ab57ea1/snowballstemmer-3.1.1.tar.gz", hash = "sha256:e07bbc54a0d798fe6010a12398422e62a8bfbba95c394fd0956ef58cb4d3e260", size = 123314, upload-time = "2026-06-03T00:56:40.194Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4c/07/2ebca9b11fb9be7340a818d8d6f63feaebb146be2c4afbd6061701d6df6e/snowballstemmer-3.1.1-py3-none-any.whl", hash = "sha256:7e207fa178741da09cdee59d3ecec3827ad5f92b1fc5c9ff3755b639f71f5752", size = 104164, upload-time = "2026-06-03T00:56:38.614Z" }, +] + +[[package]] +name = "soupsieve" +version = "2.9.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/69/99/a6ca3beb3ccacb41fb3321d8a60e5566f9e6467601ef8eba6a17e1b89778/soupsieve-2.9.2.tar.gz", hash = "sha256:4a55d8cf158a9c2e587fa4922f1bbb91d68ac829e2d6f25403a85747c71daf74", size = 122445, upload-time = "2026-08-07T00:57:24.801Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/eb/dc/ad025c1ee131eba60c69f4dd5779b18fcf1e6b21a343e2162a84d5d133c7/soupsieve-2.9.2-py3-none-any.whl", hash = "sha256:8089a26fd974ca7a1f30276d3d8492ab266ab15af581642dfe8aa162e0c1c823", size = 37370, upload-time = "2026-08-07T00:57:23.524Z" }, +] + +[[package]] +name = "sphinx" +version = "9.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "alabaster" }, + { name = "babel" }, + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "docutils" }, + { name = "imagesize" }, + { name = "jinja2" }, + { name = "packaging" }, + { name = "pygments" }, + { name = "requests" }, + { name = "roman-numerals" }, + { name = "snowballstemmer" }, + { name = "sphinxcontrib-applehelp" }, + { name = "sphinxcontrib-devhelp" }, + { name = "sphinxcontrib-htmlhelp" }, + { name = "sphinxcontrib-jsmath" }, + { name = "sphinxcontrib-qthelp" }, + { name = "sphinxcontrib-serializinghtml" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/cd/bd/f08eb0f4eed5c83f1ba2a3bd18f7745a2b1525fad70660a1c00224ec468a/sphinx-9.1.0.tar.gz", hash = "sha256:7741722357dd75f8190766926071fed3bdc211c74dd2d7d4df5404da95930ddb", size = 8718324, upload-time = "2025-12-31T15:09:27.646Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/73/f7/b1884cb3188ab181fc81fa00c266699dab600f927a964df02ec3d5d1916a/sphinx-9.1.0-py3-none-any.whl", hash = "sha256:c84fdd4e782504495fe4f2c0b3413d6c2bf388589bb352d439b2a3bb99991978", size = 3921742, upload-time = "2025-12-31T15:09:25.561Z" }, +] + +[[package]] +name = "sphinx-copybutton" +version = "0.5.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "sphinx" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/fc/2b/a964715e7f5295f77509e59309959f4125122d648f86b4fe7d70ca1d882c/sphinx-copybutton-0.5.2.tar.gz", hash = "sha256:4cf17c82fb9646d1bc9ca92ac280813a3b605d8c421225fd9913154103ee1fbd", size = 23039, upload-time = "2023-04-14T08:10:22.998Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9e/48/1ea60e74949eecb12cdd6ac43987f9fd331156388dcc2319b45e2ebb81bf/sphinx_copybutton-0.5.2-py3-none-any.whl", hash = "sha256:fb543fd386d917746c9a2c50360c7905b605726b9355cd26e9974857afeae06e", size = 13343, upload-time = "2023-04-14T08:10:20.844Z" }, +] + +[[package]] +name = "sphinxcontrib-applehelp" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ba/6e/b837e84a1a704953c62ef8776d45c3e8d759876b4a84fe14eba2859106fe/sphinxcontrib_applehelp-2.0.0.tar.gz", hash = "sha256:2f29ef331735ce958efa4734873f084941970894c6090408b079c61b2e1c06d1", size = 20053, upload-time = "2024-07-29T01:09:00.465Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5d/85/9ebeae2f76e9e77b952f4b274c27238156eae7979c5421fba91a28f4970d/sphinxcontrib_applehelp-2.0.0-py3-none-any.whl", hash = "sha256:4cd3f0ec4ac5dd9c17ec65e9ab272c9b867ea77425228e68ecf08d6b28ddbdb5", size = 119300, upload-time = "2024-07-29T01:08:58.99Z" }, +] + +[[package]] +name = "sphinxcontrib-devhelp" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f6/d2/5beee64d3e4e747f316bae86b55943f51e82bb86ecd325883ef65741e7da/sphinxcontrib_devhelp-2.0.0.tar.gz", hash = "sha256:411f5d96d445d1d73bb5d52133377b4248ec79db5c793ce7dbe59e074b4dd1ad", size = 12967, upload-time = "2024-07-29T01:09:23.417Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/35/7a/987e583882f985fe4d7323774889ec58049171828b58c2217e7f79cdf44e/sphinxcontrib_devhelp-2.0.0-py3-none-any.whl", hash = "sha256:aefb8b83854e4b0998877524d1029fd3e6879210422ee3780459e28a1f03a8a2", size = 82530, upload-time = "2024-07-29T01:09:21.945Z" }, +] + +[[package]] +name = "sphinxcontrib-htmlhelp" +version = "2.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/43/93/983afd9aa001e5201eab16b5a444ed5b9b0a7a010541e0ddfbbfd0b2470c/sphinxcontrib_htmlhelp-2.1.0.tar.gz", hash = "sha256:c9e2916ace8aad64cc13a0d233ee22317f2b9025b9cf3295249fa985cc7082e9", size = 22617, upload-time = "2024-07-29T01:09:37.889Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0a/7b/18a8c0bcec9182c05a0b3ec2a776bba4ead82750a55ff798e8d406dae604/sphinxcontrib_htmlhelp-2.1.0-py3-none-any.whl", hash = "sha256:166759820b47002d22914d64a075ce08f4c46818e17cfc9470a9786b759b19f8", size = 98705, upload-time = "2024-07-29T01:09:36.407Z" }, +] + +[[package]] +name = "sphinxcontrib-jsmath" +version = "1.0.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b2/e8/9ed3830aeed71f17c026a07a5097edcf44b692850ef215b161b8ad875729/sphinxcontrib-jsmath-1.0.1.tar.gz", hash = "sha256:a9925e4a4587247ed2191a22df5f6970656cb8ca2bd6284309578f2153e0c4b8", size = 5787, upload-time = "2019-01-21T16:10:16.347Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c2/42/4c8646762ee83602e3fb3fbe774c2fac12f317deb0b5dbeeedd2d3ba4b77/sphinxcontrib_jsmath-1.0.1-py2.py3-none-any.whl", hash = "sha256:2ec2eaebfb78f3f2078e73666b1415417a116cc848b72e5172e596c871103178", size = 5071, upload-time = "2019-01-21T16:10:14.333Z" }, +] + +[[package]] +name = "sphinxcontrib-qthelp" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/68/bc/9104308fc285eb3e0b31b67688235db556cd5b0ef31d96f30e45f2e51cae/sphinxcontrib_qthelp-2.0.0.tar.gz", hash = "sha256:4fe7d0ac8fc171045be623aba3e2a8f613f8682731f9153bb2e40ece16b9bbab", size = 17165, upload-time = "2024-07-29T01:09:56.435Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/27/83/859ecdd180cacc13b1f7e857abf8582a64552ea7a061057a6c716e790fce/sphinxcontrib_qthelp-2.0.0-py3-none-any.whl", hash = "sha256:b18a828cdba941ccd6ee8445dbe72ffa3ef8cbe7505d8cd1fa0d42d3f2d5f3eb", size = 88743, upload-time = "2024-07-29T01:09:54.885Z" }, +] + +[[package]] +name = "sphinxcontrib-serializinghtml" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/3b/44/6716b257b0aa6bfd51a1b31665d1c205fb12cb5ad56de752dfa15657de2f/sphinxcontrib_serializinghtml-2.0.0.tar.gz", hash = "sha256:e9d912827f872c029017a53f0ef2180b327c3f7fd23c87229f7a8e8b70031d4d", size = 16080, upload-time = "2024-07-29T01:10:09.332Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/52/a7/d2782e4e3f77c8450f727ba74a8f12756d5ba823d81b941f1b04da9d033a/sphinxcontrib_serializinghtml-2.0.0-py3-none-any.whl", hash = "sha256:6e2cb0eef194e10c27ec0023bfeb25badbbb5868244cf5bc5bdc04e4464bf331", size = 92072, upload-time = "2024-07-29T01:10:08.203Z" }, +] + +[[package]] +name = "sqlalchemy" +version = "2.0.52" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "greenlet", marker = "platform_machine == 'AMD64' or platform_machine == 'WIN32' or platform_machine == 'aarch64' or platform_machine == 'amd64' or platform_machine == 'ppc64le' or platform_machine == 'win32' or platform_machine == 'x86_64'" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/3b/21/77b4c147963073040dc3c3a5cb7a8c3001a1893c0209432cb77f9df836aa/sqlalchemy-2.0.52.tar.gz", hash = "sha256:5e2d46356ac2ccb7d268ab6c2319ac6a2b42f1b8d5fd8bd3d46855cd82abee97", size = 9945637, upload-time = "2026-08-11T19:07:09.829Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e0/d5/1b77a026d161f98a08f11af1a5f6c47b98ee7c7e2648af525a1004826c78/sqlalchemy-2.0.52-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:be8c49131665dfe2cc74c498aa1240ffb548d0fd901325dd11c2c7a18956f727", size = 2170940, upload-time = "2026-08-11T20:58:11.25Z" }, + { url = "https://files.pythonhosted.org/packages/54/bd/f444444adb37b5d53753fb1730ee7a421628e2e3b756c4da461af7e6394a/sqlalchemy-2.0.52-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1b2d9e507a458832adcfbd8af6e2036ddf069b7710b799448542ebccae2dceee", size = 3383415, upload-time = "2026-08-11T21:02:38.534Z" }, + { url = "https://files.pythonhosted.org/packages/be/57/2eadf93a552568c57e8680b7e58bb5e9770d80942a1bdbaf4f2f63f0d7c8/sqlalchemy-2.0.52-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8738008376d22f30f411ea3efecf39b51110b6996d80bb73786f30bcfdd5fd3b", size = 3398577, upload-time = "2026-08-11T21:16:59.092Z" }, + { url = "https://files.pythonhosted.org/packages/15/c3/2887cf9dd111d1fbf05d22165b404c221ef43e029f7a2695e7302f27a7cc/sqlalchemy-2.0.52-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:37a4d548327b6cab9c7d8cdb4e0e82feabee0110c4d150059068e2d1cfbd99ee", size = 3328225, upload-time = "2026-08-11T21:02:40.183Z" }, + { url = "https://files.pythonhosted.org/packages/02/0f/466bdf9e1feeeef5587f868c187d8687e21ff8c85b1775e9041130181132/sqlalchemy-2.0.52-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e49f51a5d59857a7a0dcaf9469febf7197d9394bd88f00d69c2c4e848112cdbf", size = 3357374, upload-time = "2026-08-11T21:17:01.076Z" }, + { url = "https://files.pythonhosted.org/packages/22/20/5c2b4583904af4173076dda1c9e53c9e2ffc7a702d2efde0216bbacbf7cb/sqlalchemy-2.0.52-cp312-cp312-win32.whl", hash = "sha256:afda3ec521d0517d0de783fc70030775841900896d832de5bbd066549290470e", size = 2129366, upload-time = "2026-08-11T21:14:50.991Z" }, + { url = "https://files.pythonhosted.org/packages/ed/06/543dab8ef62d4e9fb96fb31a30c2b8b14a8763bccf48d428294d6b3041c0/sqlalchemy-2.0.52-cp312-cp312-win_amd64.whl", hash = "sha256:2d5e53e36e37129fe0be8b9d08b6e4052c10a963ee6cda56c8c10dcc194b99ca", size = 2157344, upload-time = "2026-08-11T21:14:52.453Z" }, + { url = "https://files.pythonhosted.org/packages/7f/18/e30c6fe1eca1bf34a39fbdd6066121cc9974c850faf6f349eac563697a26/sqlalchemy-2.0.52-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2eb3c6a64b1bfe6704777cfd504e7b8ad093a5f3e03ce67663a5e6742f294e43", size = 2167724, upload-time = "2026-08-11T20:58:12.679Z" }, + { url = "https://files.pythonhosted.org/packages/d0/56/2e17d161a4f7ecc1c2ffb93e607b4e1898bb551b451b283235acb8f6ce47/sqlalchemy-2.0.52-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:923bb183c1dc64fdf7b717965e3d59938ec4f8b8710b419a21ce403e5da9a9e1", size = 3321189, upload-time = "2026-08-11T21:02:41.932Z" }, + { url = "https://files.pythonhosted.org/packages/cf/b8/8490916e893f3f8d74dc9cc54c078619364999dee37047a188e73abbc852/sqlalchemy-2.0.52-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:651d6d8782e80679e6151707c7b490834d46ada526328895abf567f25e63d29c", size = 3338185, upload-time = "2026-08-11T21:17:02.597Z" }, + { url = "https://files.pythonhosted.org/packages/8b/f7/752cc8ee453da222829b3f5c4613614bf750d97429363b70414fa10478e4/sqlalchemy-2.0.52-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:b08cddb8989775e3c88799d86704bdfc3ee6e9846118201aa5997f16f27e3a15", size = 3271698, upload-time = "2026-08-11T21:02:43.963Z" }, + { url = "https://files.pythonhosted.org/packages/51/e6/074ade0c07b9e4c8e8bca46820320ed94df9702afdb6f2af06623068d2e6/sqlalchemy-2.0.52-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ab66fa9618269390d4dfa222f2f2f88f7bc4bf5da13905131b818217db7e8057", size = 3308936, upload-time = "2026-08-11T21:17:04.172Z" }, + { url = "https://files.pythonhosted.org/packages/66/07/557c0d04716705599227945ac14e0a17ad0338e899f37d8c2ddff4dcc663/sqlalchemy-2.0.52-cp313-cp313-win32.whl", hash = "sha256:c63bda077685c85ca513286547a531ba57e7a68cf0a7ed3bafcc2bbd18896f4d", size = 2127308, upload-time = "2026-08-11T21:14:53.879Z" }, + { url = "https://files.pythonhosted.org/packages/96/4e/226eda27654318ce525d043025221f689abef883da2c7126f9065121618c/sqlalchemy-2.0.52-cp313-cp313-win_amd64.whl", hash = "sha256:9876b09b9f1ce7398b0ffece585c0a911244c53191187341f6bcae640e133751", size = 2153876, upload-time = "2026-08-11T21:14:55.527Z" }, + { url = "https://files.pythonhosted.org/packages/d5/f5/71cb30af58c9b80a4e1fac0b73bb48f86d497a774a6a2eb6d2f1e657bb73/sqlalchemy-2.0.52-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:410d52be41d17f1a236d19520fbe776257dc16516ed06bd16d433311842aefd9", size = 2169537, upload-time = "2026-08-11T20:58:13.855Z" }, + { url = "https://files.pythonhosted.org/packages/4c/93/d07ebd645d1b07b6b5ed63450a70f063a346a7e0f2c8810daf2e532400cb/sqlalchemy-2.0.52-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:dfe9ce533dbe4d0a2ae1486546619bd30b76bcd670539a44d910361376175f5e", size = 3319606, upload-time = "2026-08-11T21:02:45.829Z" }, + { url = "https://files.pythonhosted.org/packages/ae/5c/290c84c7c2566ecd3b65baaae0fddec9bc33b033b398a06123bb86fbfc6e/sqlalchemy-2.0.52-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:812bae5138bfc0aa46fb0686da0fc7f581f68e2bbb05bc24c3713bebaedd1437", size = 3323642, upload-time = "2026-08-11T21:17:05.675Z" }, + { url = "https://files.pythonhosted.org/packages/13/f5/2cc160590ca49173359557880b92a0572293ccb899e8f6cedf150c5a3ddf/sqlalchemy-2.0.52-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:50bff43b632a56fbf5ed9afdd76307e1512b62051bcd5afb341ae67205bbb6c8", size = 3268125, upload-time = "2026-08-11T21:02:47.649Z" }, + { url = "https://files.pythonhosted.org/packages/35/f3/ea8933fc9f7d1353e9c2ff9965eae687c4cef181120574591ed2fa0633e1/sqlalchemy-2.0.52-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:49565daf5af554f538e23aef1fc81a95a4e49658f152285e45c02f5fc44f04cd", size = 3289516, upload-time = "2026-08-11T21:17:07.267Z" }, + { url = "https://files.pythonhosted.org/packages/45/67/05cf86541c1e1716fca1e4a996954a439cd74501707cda607fb7cb02ef50/sqlalchemy-2.0.52-cp314-cp314-win32.whl", hash = "sha256:ab9da41e61b9979b910499d633b241df20c51ee5037e5405b11c2faac3cbe1a2", size = 2130249, upload-time = "2026-08-11T21:14:57.273Z" }, + { url = "https://files.pythonhosted.org/packages/96/d7/8ac6ffa1e36169e762ef65bd835046abb2251b1bc17f8f6708e14ed8d31f/sqlalchemy-2.0.52-cp314-cp314-win_amd64.whl", hash = "sha256:a593db51b3bae75db17a5738ad5f992244b3a03863f83c28117ee482c6a3f76d", size = 2156718, upload-time = "2026-08-11T21:14:58.667Z" }, + { url = "https://files.pythonhosted.org/packages/dc/4b/e01a737eef378e734cc6394a82248a6ce13b167dfa36c731075ce9fc9c64/sqlalchemy-2.0.52-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c1e61d08bdf4ee2f41024569e3400de7d6734ba498144766b11260936ccfa582", size = 2190344, upload-time = "2026-08-11T19:53:21.393Z" }, + { url = "https://files.pythonhosted.org/packages/b3/3f/3582293d1e185e71d19d7c731c3e2ee20ba21981c4a1115c0806c1f62120/sqlalchemy-2.0.52-py3-none-any.whl", hash = "sha256:3b81b8363a919ce53453591cdb93702e6bd54ade6c4fa2f468fc053baee5ed89", size = 1950700, upload-time = "2026-08-11T20:47:21.603Z" }, +] + +[[package]] +name = "stack-data" +version = "0.6.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "asttokens" }, + { name = "executing" }, + { name = "pure-eval" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/28/e3/55dcc2cfbc3ca9c29519eb6884dd1415ecb53b0e934862d3559ddcb7e20b/stack_data-0.6.3.tar.gz", hash = "sha256:836a778de4fec4dcd1dcd89ed8abff8a221f58308462e1c4aa2a3cf30148f0b9", size = 44707, upload-time = "2023-09-30T13:58:05.479Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f1/7b/ce1eafaf1a76852e2ec9b22edecf1daa58175c090266e9f6c64afcd81d91/stack_data-0.6.3-py3-none-any.whl", hash = "sha256:d5558e0c25a4cb0853cddad3d77da9891a08cb85dd9f9f91b9f8cd66e511e695", size = 24521, upload-time = "2023-09-30T13:58:03.53Z" }, +] + +[[package]] +name = "sympy" +version = "1.14.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "mpmath" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/83/d3/803453b36afefb7c2bb238361cd4ae6125a569b4db67cd9e79846ba2d68c/sympy-1.14.0.tar.gz", hash = "sha256:d3d3fe8df1e5a0b42f0e7bdf50541697dbe7d23746e894990c030e2b05e72517", size = 7793921, upload-time = "2025-04-27T18:05:01.611Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a2/09/77d55d46fd61b4a135c444fc97158ef34a095e5681d0a6c10b75bf356191/sympy-1.14.0-py3-none-any.whl", hash = "sha256:e091cc3e99d2141a0ba2847328f5479b05d94a6635cb96148ccb3f34671bd8f5", size = 6299353, upload-time = "2025-04-27T18:04:59.103Z" }, +] + +[[package]] +name = "tabulate" +version = "0.10.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/46/58/8c37dea7bbf769b20d58e7ace7e5edfe65b849442b00ffcdd56be88697c6/tabulate-0.10.0.tar.gz", hash = "sha256:e2cfde8f79420f6deeffdeda9aaec3b6bc5abce947655d17ac662b126e48a60d", size = 91754, upload-time = "2026-03-04T18:55:34.402Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/99/55/db07de81b5c630da5cbf5c7df646580ca26dfaefa593667fc6f2fe016d2e/tabulate-0.10.0-py3-none-any.whl", hash = "sha256:f0b0622e567335c8fabaaa659f1b33bcb6ddfe2e496071b743aa113f8774f2d3", size = 39814, upload-time = "2026-03-04T18:55:31.284Z" }, +] + +[[package]] +name = "terminado" +version = "0.18.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "ptyprocess", marker = "os_name != 'nt'" }, + { name = "pywinpty", marker = "os_name == 'nt' and sys_platform != 'darwin'" }, + { name = "tornado" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/8a/11/965c6fd8e5cc254f1fe142d547387da17a8ebfd75a3455f637c663fb38a0/terminado-0.18.1.tar.gz", hash = "sha256:de09f2c4b85de4765f7714688fff57d3e75bad1f909b589fde880460c753fd2e", size = 32701, upload-time = "2024-03-12T14:34:39.026Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6a/9e/2064975477fdc887e47ad42157e214526dcad8f317a948dee17e1659a62f/terminado-0.18.1-py3-none-any.whl", hash = "sha256:a4468e1b37bb318f8a86514f65814e1afc977cf29b3992a4500d9dd305dcceb0", size = 14154, upload-time = "2024-03-12T14:34:36.569Z" }, +] + +[[package]] +name = "threadpoolctl" +version = "3.6.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b7/4d/08c89e34946fce2aec4fbb45c9016efd5f4d7f24af8e5d93296e935631d8/threadpoolctl-3.6.0.tar.gz", hash = "sha256:8ab8b4aa3491d812b623328249fab5302a68d2d71745c8a4c719a2fcaba9f44e", size = 21274, upload-time = "2025-03-13T13:49:23.031Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/32/d5/f9a850d79b0851d1d4ef6456097579a9005b31fea68726a4ae5f2d82ddd9/threadpoolctl-3.6.0-py3-none-any.whl", hash = "sha256:43a0b8fd5a2928500110039e43a5eed8480b918967083ea48dc3ab9f13c4a7fb", size = 18638, upload-time = "2025-03-13T13:49:21.846Z" }, +] + +[[package]] +name = "tinycss2" +version = "1.5.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "webencodings" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a3/ae/2ca4913e5c0f09781d75482874c3a95db9105462a92ddd303c7d285d3df2/tinycss2-1.5.1.tar.gz", hash = "sha256:d339d2b616ba90ccce58da8495a78f46e55d4d25f9fd71dfd526f07e7d53f957", size = 88195, upload-time = "2025-11-23T10:29:10.082Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/60/45/c7b5c3168458db837e8ceab06dc77824e18202679d0463f0e8f002143a97/tinycss2-1.5.1-py3-none-any.whl", hash = "sha256:3415ba0f5839c062696996998176c4a3751d18b7edaaeeb658c9ce21ec150661", size = 28404, upload-time = "2025-11-23T10:29:08.676Z" }, +] + +[[package]] +name = "tinygp" +version = "0.3.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "equinox" }, + { name = "jax" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/14/75/416a47815e1f95b0d595dc4309a4feeecf178385f7fd219df5cda52f5138/tinygp-0.3.1.tar.gz", hash = "sha256:14cd14dc4d33e15ac58a91b8aab71fb234524ccd1b52e40dc80fdf08d1f045d6", size = 174542, upload-time = "2026-03-15T14:46:37.952Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e9/ed/511ae07f5616833d27904bcffc194c9ef1712d2a1cdfbc6cd3700ee6e2db/tinygp-0.3.1-py3-none-any.whl", hash = "sha256:893169e1722b67279c33a17559cefa3179d05e0b9bd0db15b2a38d06b79138a4", size = 45215, upload-time = "2026-03-15T14:46:36.708Z" }, +] + +[[package]] +name = "tokenize-rt" +version = "6.2.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/69/ed/8f07e893132d5051d86a553e749d5c89b2a4776eb3a579b72ed61f8559ca/tokenize_rt-6.2.0.tar.gz", hash = "sha256:8439c042b330c553fdbe1758e4a05c0ed460dbbbb24a606f11f0dee75da4cad6", size = 5476, upload-time = "2025-05-23T23:48:00.035Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/33/f0/3fe8c6e69135a845f4106f2ff8b6805638d4e85c264e70114e8126689587/tokenize_rt-6.2.0-py2.py3-none-any.whl", hash = "sha256:a152bf4f249c847a66497a4a95f63376ed68ac6abf092a2f7cfb29d044ecff44", size = 6004, upload-time = "2025-05-23T23:47:58.812Z" }, +] + +[[package]] +name = "tomli" +version = "2.4.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/22/de/48c59722572767841493b26183a0d1cc411d54fd759c5607c4590b6563a6/tomli-2.4.1.tar.gz", hash = "sha256:7c7e1a961a0b2f2472c1ac5b69affa0ae1132c39adcb67aba98568702b9cc23f", size = 17543, upload-time = "2026-03-25T20:22:03.828Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c1/ba/42f134a3fe2b370f555f44b1d72feebb94debcab01676bf918d0cb70e9aa/tomli-2.4.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:c742f741d58a28940ce01d58f0ab2ea3ced8b12402f162f4d534dfe18ba1cd6a", size = 155924, upload-time = "2026-03-25T20:21:21.626Z" }, + { url = "https://files.pythonhosted.org/packages/dc/c7/62d7a17c26487ade21c5422b646110f2162f1fcc95980ef7f63e73c68f14/tomli-2.4.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:7f86fd587c4ed9dd76f318225e7d9b29cfc5a9d43de44e5754db8d1128487085", size = 150018, upload-time = "2026-03-25T20:21:23.002Z" }, + { url = "https://files.pythonhosted.org/packages/5c/05/79d13d7c15f13bdef410bdd49a6485b1c37d28968314eabee452c22a7fda/tomli-2.4.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ff18e6a727ee0ab0388507b89d1bc6a22b138d1e2fa56d1ad494586d61d2eae9", size = 244948, upload-time = "2026-03-25T20:21:24.04Z" }, + { url = "https://files.pythonhosted.org/packages/10/90/d62ce007a1c80d0b2c93e02cab211224756240884751b94ca72df8a875ca/tomli-2.4.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:136443dbd7e1dee43c68ac2694fde36b2849865fa258d39bf822c10e8068eac5", size = 253341, upload-time = "2026-03-25T20:21:25.177Z" }, + { url = "https://files.pythonhosted.org/packages/1a/7e/caf6496d60152ad4ed09282c1885cca4eea150bfd007da84aea07bcc0a3e/tomli-2.4.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:5e262d41726bc187e69af7825504c933b6794dc3fbd5945e41a79bb14c31f585", size = 248159, upload-time = "2026-03-25T20:21:26.364Z" }, + { url = "https://files.pythonhosted.org/packages/99/e7/c6f69c3120de34bbd882c6fba7975f3d7a746e9218e56ab46a1bc4b42552/tomli-2.4.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:5cb41aa38891e073ee49d55fbc7839cfdb2bc0e600add13874d048c94aadddd1", size = 253290, upload-time = "2026-03-25T20:21:27.46Z" }, + { url = "https://files.pythonhosted.org/packages/d6/2f/4a3c322f22c5c66c4b836ec58211641a4067364f5dcdd7b974b4c5da300c/tomli-2.4.1-cp312-cp312-win32.whl", hash = "sha256:da25dc3563bff5965356133435b757a795a17b17d01dbc0f42fb32447ddfd917", size = 98141, upload-time = "2026-03-25T20:21:28.492Z" }, + { url = "https://files.pythonhosted.org/packages/24/22/4daacd05391b92c55759d55eaee21e1dfaea86ce5c571f10083360adf534/tomli-2.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:52c8ef851d9a240f11a88c003eacb03c31fc1c9c4ec64a99a0f922b93874fda9", size = 108847, upload-time = "2026-03-25T20:21:29.386Z" }, + { url = "https://files.pythonhosted.org/packages/68/fd/70e768887666ddd9e9f5d85129e84910f2db2796f9096aa02b721a53098d/tomli-2.4.1-cp312-cp312-win_arm64.whl", hash = "sha256:f758f1b9299d059cc3f6546ae2af89670cb1c4d48ea29c3cacc4fe7de3058257", size = 95088, upload-time = "2026-03-25T20:21:30.677Z" }, + { url = "https://files.pythonhosted.org/packages/07/06/b823a7e818c756d9a7123ba2cda7d07bc2dd32835648d1a7b7b7a05d848d/tomli-2.4.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:36d2bd2ad5fb9eaddba5226aa02c8ec3fa4f192631e347b3ed28186d43be6b54", size = 155866, upload-time = "2026-03-25T20:21:31.65Z" }, + { url = "https://files.pythonhosted.org/packages/14/6f/12645cf7f08e1a20c7eb8c297c6f11d31c1b50f316a7e7e1e1de6e2e7b7e/tomli-2.4.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:eb0dc4e38e6a1fd579e5d50369aa2e10acfc9cace504579b2faabb478e76941a", size = 149887, upload-time = "2026-03-25T20:21:33.028Z" }, + { url = "https://files.pythonhosted.org/packages/5c/e0/90637574e5e7212c09099c67ad349b04ec4d6020324539297b634a0192b0/tomli-2.4.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c7f2c7f2b9ca6bdeef8f0fa897f8e05085923eb091721675170254cbc5b02897", size = 243704, upload-time = "2026-03-25T20:21:34.51Z" }, + { url = "https://files.pythonhosted.org/packages/10/8f/d3ddb16c5a4befdf31a23307f72828686ab2096f068eaf56631e136c1fdd/tomli-2.4.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f3c6818a1a86dd6dca7ddcaaf76947d5ba31aecc28cb1b67009a5877c9a64f3f", size = 251628, upload-time = "2026-03-25T20:21:36.012Z" }, + { url = "https://files.pythonhosted.org/packages/e3/f1/dbeeb9116715abee2485bf0a12d07a8f31af94d71608c171c45f64c0469d/tomli-2.4.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d312ef37c91508b0ab2cee7da26ec0b3ed2f03ce12bd87a588d771ae15dcf82d", size = 247180, upload-time = "2026-03-25T20:21:37.136Z" }, + { url = "https://files.pythonhosted.org/packages/d3/74/16336ffd19ed4da28a70959f92f506233bd7cfc2332b20bdb01591e8b1d1/tomli-2.4.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:51529d40e3ca50046d7606fa99ce3956a617f9b36380da3b7f0dd3dd28e68cb5", size = 251674, upload-time = "2026-03-25T20:21:38.298Z" }, + { url = "https://files.pythonhosted.org/packages/16/f9/229fa3434c590ddf6c0aa9af64d3af4b752540686cace29e6281e3458469/tomli-2.4.1-cp313-cp313-win32.whl", hash = "sha256:2190f2e9dd7508d2a90ded5ed369255980a1bcdd58e52f7fe24b8162bf9fedbd", size = 97976, upload-time = "2026-03-25T20:21:39.316Z" }, + { url = "https://files.pythonhosted.org/packages/6a/1e/71dfd96bcc1c775420cb8befe7a9d35f2e5b1309798f009dca17b7708c1e/tomli-2.4.1-cp313-cp313-win_amd64.whl", hash = "sha256:8d65a2fbf9d2f8352685bc1364177ee3923d6baf5e7f43ea4959d7d8bc326a36", size = 108755, upload-time = "2026-03-25T20:21:40.248Z" }, + { url = "https://files.pythonhosted.org/packages/83/7a/d34f422a021d62420b78f5c538e5b102f62bea616d1d75a13f0a88acb04a/tomli-2.4.1-cp313-cp313-win_arm64.whl", hash = "sha256:4b605484e43cdc43f0954ddae319fb75f04cc10dd80d830540060ee7cd0243cd", size = 95265, upload-time = "2026-03-25T20:21:41.219Z" }, + { url = "https://files.pythonhosted.org/packages/3c/fb/9a5c8d27dbab540869f7c1f8eb0abb3244189ce780ba9cd73f3770662072/tomli-2.4.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:fd0409a3653af6c147209d267a0e4243f0ae46b011aa978b1080359fddc9b6cf", size = 155726, upload-time = "2026-03-25T20:21:42.23Z" }, + { url = "https://files.pythonhosted.org/packages/62/05/d2f816630cc771ad836af54f5001f47a6f611d2d39535364f148b6a92d6b/tomli-2.4.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:a120733b01c45e9a0c34aeef92bf0cf1d56cfe81ed9d47d562f9ed591a9828ac", size = 149859, upload-time = "2026-03-25T20:21:43.386Z" }, + { url = "https://files.pythonhosted.org/packages/ce/48/66341bdb858ad9bd0ceab5a86f90eddab127cf8b046418009f2125630ecb/tomli-2.4.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:559db847dc486944896521f68d8190be1c9e719fced785720d2216fe7022b662", size = 244713, upload-time = "2026-03-25T20:21:44.474Z" }, + { url = "https://files.pythonhosted.org/packages/df/6d/c5fad00d82b3c7a3ab6189bd4b10e60466f22cfe8a08a9394185c8a8111c/tomli-2.4.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:01f520d4f53ef97964a240a035ec2a869fe1a37dde002b57ebc4417a27ccd853", size = 252084, upload-time = "2026-03-25T20:21:45.62Z" }, + { url = "https://files.pythonhosted.org/packages/00/71/3a69e86f3eafe8c7a59d008d245888051005bd657760e96d5fbfb0b740c2/tomli-2.4.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7f94b27a62cfad8496c8d2513e1a222dd446f095fca8987fceef261225538a15", size = 247973, upload-time = "2026-03-25T20:21:46.937Z" }, + { url = "https://files.pythonhosted.org/packages/67/50/361e986652847fec4bd5e4a0208752fbe64689c603c7ae5ea7cb16b1c0ca/tomli-2.4.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:ede3e6487c5ef5d28634ba3f31f989030ad6af71edfb0055cbbd14189ff240ba", size = 256223, upload-time = "2026-03-25T20:21:48.467Z" }, + { url = "https://files.pythonhosted.org/packages/8c/9a/b4173689a9203472e5467217e0154b00e260621caa227b6fa01feab16998/tomli-2.4.1-cp314-cp314-win32.whl", hash = "sha256:3d48a93ee1c9b79c04bb38772ee1b64dcf18ff43085896ea460ca8dec96f35f6", size = 98973, upload-time = "2026-03-25T20:21:49.526Z" }, + { url = "https://files.pythonhosted.org/packages/14/58/640ac93bf230cd27d002462c9af0d837779f8773bc03dee06b5835208214/tomli-2.4.1-cp314-cp314-win_amd64.whl", hash = "sha256:88dceee75c2c63af144e456745e10101eb67361050196b0b6af5d717254dddf7", size = 109082, upload-time = "2026-03-25T20:21:50.506Z" }, + { url = "https://files.pythonhosted.org/packages/d5/2f/702d5e05b227401c1068f0d386d79a589bb12bf64c3d2c72ce0631e3bc49/tomli-2.4.1-cp314-cp314-win_arm64.whl", hash = "sha256:b8c198f8c1805dc42708689ed6864951fd2494f924149d3e4bce7710f8eb5232", size = 96490, upload-time = "2026-03-25T20:21:51.474Z" }, + { url = "https://files.pythonhosted.org/packages/45/4b/b877b05c8ba62927d9865dd980e34a755de541eb65fffba52b4cc495d4d2/tomli-2.4.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:d4d8fe59808a54658fcc0160ecfb1b30f9089906c50b23bcb4c69eddc19ec2b4", size = 164263, upload-time = "2026-03-25T20:21:52.543Z" }, + { url = "https://files.pythonhosted.org/packages/24/79/6ab420d37a270b89f7195dec5448f79400d9e9c1826df982f3f8e97b24fd/tomli-2.4.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7008df2e7655c495dd12d2a4ad038ff878d4ca4b81fccaf82b714e07eae4402c", size = 160736, upload-time = "2026-03-25T20:21:53.674Z" }, + { url = "https://files.pythonhosted.org/packages/02/e0/3630057d8eb170310785723ed5adcdfb7d50cb7e6455f85ba8a3deed642b/tomli-2.4.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1d8591993e228b0c930c4bb0db464bdad97b3289fb981255d6c9a41aedc84b2d", size = 270717, upload-time = "2026-03-25T20:21:55.129Z" }, + { url = "https://files.pythonhosted.org/packages/7a/b4/1613716072e544d1a7891f548d8f9ec6ce2faf42ca65acae01d76ea06bb0/tomli-2.4.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:734e20b57ba95624ecf1841e72b53f6e186355e216e5412de414e3c51e5e3c41", size = 278461, upload-time = "2026-03-25T20:21:56.228Z" }, + { url = "https://files.pythonhosted.org/packages/05/38/30f541baf6a3f6df77b3df16b01ba319221389e2da59427e221ef417ac0c/tomli-2.4.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8a650c2dbafa08d42e51ba0b62740dae4ecb9338eefa093aa5c78ceb546fcd5c", size = 274855, upload-time = "2026-03-25T20:21:57.653Z" }, + { url = "https://files.pythonhosted.org/packages/77/a3/ec9dd4fd2c38e98de34223b995a3b34813e6bdadf86c75314c928350ed14/tomli-2.4.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:504aa796fe0569bb43171066009ead363de03675276d2d121ac1a4572397870f", size = 283144, upload-time = "2026-03-25T20:21:59.089Z" }, + { url = "https://files.pythonhosted.org/packages/ef/be/605a6261cac79fba2ec0c9827e986e00323a1945700969b8ee0b30d85453/tomli-2.4.1-cp314-cp314t-win32.whl", hash = "sha256:b1d22e6e9387bf4739fbe23bfa80e93f6b0373a7f1b96c6227c32bef95a4d7a8", size = 108683, upload-time = "2026-03-25T20:22:00.214Z" }, + { url = "https://files.pythonhosted.org/packages/12/64/da524626d3b9cc40c168a13da8335fe1c51be12c0a63685cc6db7308daae/tomli-2.4.1-cp314-cp314t-win_amd64.whl", hash = "sha256:2c1c351919aca02858f740c6d33adea0c5deea37f9ecca1cc1ef9e884a619d26", size = 121196, upload-time = "2026-03-25T20:22:01.169Z" }, + { url = "https://files.pythonhosted.org/packages/5a/cd/e80b62269fc78fc36c9af5a6b89c835baa8af28ff5ad28c7028d60860320/tomli-2.4.1-cp314-cp314t-win_arm64.whl", hash = "sha256:eab21f45c7f66c13f2a9e0e1535309cee140182a9cdae1e041d02e47291e8396", size = 100393, upload-time = "2026-03-25T20:22:02.137Z" }, + { url = "https://files.pythonhosted.org/packages/7b/61/cceae43728b7de99d9b847560c262873a1f6c98202171fd5ed62640b494b/tomli-2.4.1-py3-none-any.whl", hash = "sha256:0d85819802132122da43cb86656f8d1f8c6587d54ae7dcaf30e90533028b49fe", size = 14583, upload-time = "2026-03-25T20:22:03.012Z" }, +] + +[[package]] +name = "torch" +version = "2.15.0" +source = { registry = "https://download.pytorch.org/whl/cpu" } +resolution-markers = [ + "python_full_version >= '3.14' and sys_platform == 'darwin'", + "python_full_version == '3.13.*' and sys_platform == 'darwin'", + "python_full_version < '3.13' and sys_platform == 'darwin'", +] +dependencies = [ + { name = "filelock", marker = "sys_platform == 'darwin'" }, + { name = "fsspec", marker = "sys_platform == 'darwin'" }, + { name = "jinja2", marker = "sys_platform == 'darwin'" }, + { name = "networkx", marker = "sys_platform == 'darwin'" }, + { name = "setuptools", marker = "sys_platform == 'darwin'" }, + { name = "sympy", marker = "sys_platform == 'darwin'" }, + { name = "typing-extensions", marker = "sys_platform == 'darwin'" }, +] +wheels = [ + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.15.0-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:593e5fd0c204284890d1c3dff643be34e549e1d24523e13402510f960d4da438", upload-time = "2026-10-28T13:17:02Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.15.0-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:fbefd73b521d3c75c5a1d7c77056b2c6339b81468d14d4e33c55f525418a5855", upload-time = "2026-10-28T13:17:07Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.15.0-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:0d2b2d9674fa0b9b3f50e83231aa6545a0b19e437a52f0af939a224faaa45515", upload-time = "2026-10-28T13:17:13Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.15.0-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:628f54cb55a2363a5f14471a80c1b6efb63724449d2611ad2772fb5d4c42d19d", upload-time = "2026-10-28T13:17:20Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.15.0-cp315-cp315-macosx_14_0_arm64.whl", hash = "sha256:06a686eb717cd3d1662363082820be45497318887c596d691af0af0c7649c8f0", upload-time = "2026-10-28T13:17:25Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.15.0-cp315-cp315t-macosx_14_0_arm64.whl", hash = "sha256:02ac0b22211c1984e5dc002d2e57fdbc13d32116537ea6ae1a0c9d07cafce0c9", upload-time = "2026-10-28T13:17:32Z" }, +] + +[[package]] +name = "torch" +version = "2.15.0+cpu" +source = { registry = "https://download.pytorch.org/whl/cpu" } +resolution-markers = [ + "python_full_version >= '3.14' and sys_platform == 'win32'", + "python_full_version >= '3.14' and sys_platform == 'emscripten'", + "python_full_version >= '3.14' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.13.*' and sys_platform == 'win32'", + "python_full_version < '3.13' and sys_platform == 'win32'", + "python_full_version == '3.13.*' and sys_platform == 'emscripten'", + "python_full_version < '3.13' and sys_platform == 'emscripten'", + "python_full_version == '3.13.*' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version < '3.13' and sys_platform != 'darwin' and sys_platform != 'emscripten' and sys_platform != 'win32'", +] +dependencies = [ + { name = "filelock", marker = "sys_platform != 'darwin'" }, + { name = "fsspec", marker = "sys_platform != 'darwin'" }, + { name = "jinja2", marker = "sys_platform != 'darwin'" }, + { name = "networkx", marker = "sys_platform != 'darwin'" }, + { name = "setuptools", marker = "sys_platform != 'darwin'" }, + { name = "sympy", marker = "sys_platform != 'darwin'" }, + { name = "typing-extensions", marker = "sys_platform != 'darwin'" }, +] +wheels = [ + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.15.0%2Bcpu-cp312-cp312-linux_s390x.whl", hash = "sha256:29c74659a82483d9a9c5d7f9e1112973dfa2dce5b3956dba5d1b97381b94cfae", upload-time = "2026-10-28T13:18:25Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.15.0%2Bcpu-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:75941d429aaf4450bcd364345d7677e2d54aad45b38fbfcb1c0552450a6e9c40", upload-time = "2026-10-28T13:18:32Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.15.0%2Bcpu-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:0955c7e3446326293f48af18fad67872fa31dee5a36a87690eb9e5be8b465be3", upload-time = "2026-10-28T13:18:39Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.15.0%2Bcpu-cp312-cp312-win_amd64.whl", hash = "sha256:5af9fb357790db09e62484b12032304f046c22c4b1895ca88c4cf5987ea369ca", upload-time = "2026-10-28T13:18:45Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.15.0%2Bcpu-cp312-cp312-win_arm64.whl", hash = "sha256:fe17318e964a6eb4b1380fd6dcd5405264af3e54b10bce7abcce5fa701a3f049", upload-time = "2026-10-28T13:18:48Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.15.0%2Bcpu-cp313-cp313-linux_s390x.whl", hash = "sha256:88f5fe2c5d25a809a315a4a3f494e367539a307356f37752d89cd0b9d84f175a", upload-time = "2026-10-28T13:18:52Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.15.0%2Bcpu-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:ab35875b15ac536a645e165b296300fed71df7b4f2ddbae40c725ab08f0a5e78", upload-time = "2026-10-28T13:18:58Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.15.0%2Bcpu-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:0f6f69701b2d38ddc412364dfb92e2e13e74960d33fa3573b4930ced626e81c7", upload-time = "2026-10-28T13:19:05Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.15.0%2Bcpu-cp313-cp313-win_amd64.whl", hash = "sha256:086f79c78c941b428410dc15f898ce2420a4580ae6983ea314692d71ce76c619", upload-time = "2026-10-28T13:19:11Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.15.0%2Bcpu-cp313-cp313-win_arm64.whl", hash = "sha256:e01d89c7cbc6c07a5d8a03ecff767083a2d997ee030622e96e406f92a06cee11", upload-time = "2026-10-28T13:19:15Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.15.0%2Bcpu-cp314-cp314-linux_s390x.whl", hash = "sha256:ef810702df4dd70fe1b8ebee9e7394c6491f779841571a71433829e44927eaa5", upload-time = "2026-10-28T13:19:19Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.15.0%2Bcpu-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:01bdc7d291e3f6b5c03cf72d8a1718a5012d9fad5f380e67b563b0a76592055a", upload-time = "2026-10-28T13:19:25Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.15.0%2Bcpu-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:f089c94912c955269a20e5fee6b6a371209b610849c9ece26e908a748d87a723", upload-time = "2026-10-28T13:19:32Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.15.0%2Bcpu-cp314-cp314-win_amd64.whl", hash = "sha256:8c145170f1ad54edd1ef1da3c872a4a8ada202e24894893df4ed2fc75a8322af", upload-time = "2026-10-28T13:19:38Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.15.0%2Bcpu-cp314-cp314t-linux_s390x.whl", hash = "sha256:7f8e2d696d12f965a5967bda4bc903decf6aa714b0b5ffb50e189733112a4dfd", upload-time = "2026-10-28T13:19:42Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.15.0%2Bcpu-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:68e4595afffb1af18480b6ecb7217688c02a0f2a7b482c7a95b4896a3b38d49a", upload-time = "2026-10-28T13:19:48Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.15.0%2Bcpu-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:17d66ae6f8a49d4dfca368b50b7dc15f7129175e80b4ae2832dfa0cce86d3159", upload-time = "2026-10-28T13:19:55Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.15.0%2Bcpu-cp314-cp314t-win_amd64.whl", hash = "sha256:c556fb12f69e907386e98136d3be6fbcf4f3962ad018cf74fc6fe43d1c81a240", upload-time = "2026-10-28T13:20:02Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.15.0%2Bcpu-cp315-cp315-manylinux_2_28_aarch64.whl", hash = "sha256:2cec97b29524b3352bb794321976da7cef2ecee171866499c5630c865396c0a2", upload-time = "2026-10-28T13:20:08Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.15.0%2Bcpu-cp315-cp315-manylinux_2_28_x86_64.whl", hash = "sha256:3552930ba3d358d3ff0b6fee19cb296e199767443c0c86be2a715471036d9233", upload-time = "2026-10-28T13:20:15Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.15.0%2Bcpu-cp315-cp315-win_amd64.whl", hash = "sha256:5c21ee962b6f67821dac0bc882f5ee1539a4edeabe736284d2ff1d652e595ed1", upload-time = "2026-10-28T13:20:21Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.15.0%2Bcpu-cp315-cp315t-manylinux_2_28_aarch64.whl", hash = "sha256:3fb23f534fdffdd3a178f8ef3327ab5fff833f291e5955be7edcaa7547a3f1fa", upload-time = "2026-10-28T13:20:26Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.15.0%2Bcpu-cp315-cp315t-manylinux_2_28_x86_64.whl", hash = "sha256:92551daf5873fc6db15be48fe9644398f13143291c151ab6769f19e7c5ebd10c", upload-time = "2026-10-28T13:20:33Z" }, + { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.15.0%2Bcpu-cp315-cp315t-win_amd64.whl", hash = "sha256:694b58039c3b1df7f5a890e97494728de849adb168a4617dd6024ca19eb8598e", upload-time = "2026-10-28T13:20:39Z" }, +] + +[[package]] +name = "tornado" +version = "6.5.8" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/10/d3/343e5bb989d6515b1646cf3d40135d73f3d5e45339bded401b56cdac24dd/tornado-6.5.8.tar.gz", hash = "sha256:9452e1b208a8bd771e2cb1f2ff564985b9b214bdebbe622793e1799e0a6bd23f", size = 520493, upload-time = "2026-08-07T02:12:42.971Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f2/d5/007086fd8df5489338e204f65adce33fd4f21a4999dbb2b9cff2f897b5f4/tornado-6.5.8-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:cc6aa787d7cfab7c3d35189dc7a56fbd2399a569624c730c6b55b3d6531d0403", size = 449487, upload-time = "2026-08-07T02:12:28.682Z" }, + { url = "https://files.pythonhosted.org/packages/70/c8/5a24a99495903f594f6a199dd7beead1cbc0a13e2cb9102727bcaaf2a997/tornado-6.5.8-cp39-abi3-macosx_10_9_x86_64.whl", hash = "sha256:9715b5eb79735b2bcd454ce216a9275b7c0470e64ea1bf5742f78b2f72b26eeb", size = 447649, upload-time = "2026-08-07T02:12:30.306Z" }, + { url = "https://files.pythonhosted.org/packages/6e/de/f2e733f386b85962d1b1dc82cd63d169b5b4580062b35397eac9244a41fe/tornado-6.5.8-cp39-abi3-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:547d63f450d570c14fe0e8db2cfb14c9bbd1c2503b4a6612586267955aa47b58", size = 450707, upload-time = "2026-08-07T02:12:31.95Z" }, + { url = "https://files.pythonhosted.org/packages/0b/94/20efeee9a01c141e9ac47c397f81679dfda24b32768fc4fff24e76d36c2c/tornado-6.5.8-cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7e2360a0ffbe145eca8af0b19cb7203d79b1a98dd4cccdd6b368f6f49c2e3808", size = 451677, upload-time = "2026-08-07T02:12:33.512Z" }, + { url = "https://files.pythonhosted.org/packages/42/ec/a96ccb8ccf0de2b7bc2c5fa1608a4803735018242e90c4882365a9fd418f/tornado-6.5.8-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:5d242290bdf7ab3151bc1065fdd75c0dcc21cbc7b49f22a4c56329c2d6566d22", size = 451510, upload-time = "2026-08-07T02:12:35.346Z" }, + { url = "https://files.pythonhosted.org/packages/29/b5/93185859245ad3f00e62175f29607346788b696369347f0146e0421286bb/tornado-6.5.8-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:7b94ff0e128fe0542f3bd331fb44d06260fc4ac16881545159f34ef08aad4195", size = 450917, upload-time = "2026-08-07T02:12:36.963Z" }, + { url = "https://files.pythonhosted.org/packages/97/cf/fe33cf062834487d34d1559746a4a12521033c22645b6d74d4bca702e018/tornado-6.5.8-cp39-abi3-win32.whl", hash = "sha256:67832909c4779c64942380cb5f044a5c6163d00831472d80e25e115de9917836", size = 451952, upload-time = "2026-08-07T02:12:38.512Z" }, + { url = "https://files.pythonhosted.org/packages/cb/e1/468ad54333e92ccb62627e62cb88e5fc14a2171daa67ed47b1b8542d5b86/tornado-6.5.8-cp39-abi3-win_amd64.whl", hash = "sha256:11881db6b7c168494be2c2d12e65931451bdf7ee718535418ae1d8855dd5a0ee", size = 452391, upload-time = "2026-08-07T02:12:39.971Z" }, + { url = "https://files.pythonhosted.org/packages/ad/3e/cd5e4f06e34cde33b8ef66cf36aa2b5ad46354cc1af7d2136bbe365fee1d/tornado-6.5.8-cp39-abi3-win_arm64.whl", hash = "sha256:68a7468c7e289f8514d7d664101753903217eff1bb6822c6b5994a0b5f5bcb26", size = 451411, upload-time = "2026-08-07T02:12:41.469Z" }, +] + +[[package]] +name = "tqdm" +version = "4.70.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/21/3b/6c24bec5be5e743ffd99576daa5cc077722fc7d5bbc00bd133fa0c698dc6/tqdm-4.70.0.tar.gz", hash = "sha256:55b0b0dbd97462d06ebee91e4dac24ed4d4702be82b24f07e6c1d27e08cea220", size = 795438, upload-time = "2026-07-27T11:33:15.271Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f9/1c/01bfd571a64e7f270e6bab5e33777debe0edc56759233ce84f27dec92d14/tqdm-4.70.0-py3-none-any.whl", hash = "sha256:7f585706bfddbdebf89daac705b2dfcc16890130727d3197ca62c732b4310953", size = 80184, upload-time = "2026-07-27T11:33:13.167Z" }, +] + +[[package]] +name = "traitlets" +version = "5.16.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/2c/2e/a7fbfe268c8a3b32546930c0297c101d65a4a14c304ad5790a9f478f0e4e/traitlets-5.16.1.tar.gz", hash = "sha256:ed900c2b631aa3a112811139fa97b8d2c3bad5e989656bba4b7e52c7852c18c1", size = 166137, upload-time = "2026-08-03T08:32:36.848Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ad/66/0d785f0bc5e4315a96c989bb476d0fc07ea4f85132550c7b156ca2035d52/traitlets-5.16.1-py3-none-any.whl", hash = "sha256:f775618166caa0396c8e337099240f2bd3e5e917d203b2e6fbe21a58d3cb1f6b", size = 86211, upload-time = "2026-08-03T08:32:34.48Z" }, +] + +[[package]] +name = "typing-extensions" +version = "4.16.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f6/cc/6253133b5bb138fc3306cebfbda2c520f545d36b5be2c7255cc528bb45d6/typing_extensions-4.16.0.tar.gz", hash = "sha256:dc983d19a509c94dba722ee6abd33940f7c05a89e243c47e907eb4db6f1a43e5", size = 113555, upload-time = "2026-07-02T08:40:05.92Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/49/d3/b8441a820a491ddfc024b0b0cf0393375b75ea13866d9c66727e54c2fc80/typing_extensions-4.16.0-py3-none-any.whl", hash = "sha256:481caa481374e813c1b176ada14e97f1f67a4539ce9cfeb3f350d78d6370c2e8", size = 45571, upload-time = "2026-07-02T08:40:04.659Z" }, +] + +[[package]] +name = "tzdata" +version = "2026.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/92/ff/5a28bdfd8c3ebec42564ac7d0e54ca3db65044a9314a97f9564fa7a1e926/tzdata-2026.3.tar.gz", hash = "sha256:4a1518b8993086a7982523e071643f3c0e5f213e75b21318e78bcabfff9d1415", size = 198674, upload-time = "2026-07-10T08:50:37.887Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e5/6d/b53b99a9f2766d095985947a5782f1702cabb129a34f7a802d7197af832f/tzdata-2026.3-py2.py3-none-any.whl", hash = "sha256:dc096730c87af6cab1b171c9d532be840741ff5d459015e7f6947bd7d7e54931", size = 348168, upload-time = "2026-07-10T08:50:36.46Z" }, +] + +[[package]] +name = "uri-template" +version = "1.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/31/c7/0336f2bd0bcbada6ccef7aaa25e443c118a704f828a0620c6fa0207c1b64/uri-template-1.3.0.tar.gz", hash = "sha256:0e00f8eb65e18c7de20d595a14336e9f337ead580c70934141624b6d1ffdacc7", size = 21678, upload-time = "2023-06-21T01:49:05.374Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e7/00/3fca040d7cf8a32776d3d81a00c8ee7457e00f80c649f1e4a863c8321ae9/uri_template-1.3.0-py3-none-any.whl", hash = "sha256:a44a133ea12d44a0c0f06d7d42a52d71282e77e2f937d8abd5655b8d56fc1363", size = 11140, upload-time = "2023-06-21T01:49:03.467Z" }, +] + +[[package]] +name = "urllib3" +version = "2.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/53/0c/06f8b233b8fd13b9e5ee11424ef85419ba0d8ba0b3138bf360be2ff56953/urllib3-2.7.0.tar.gz", hash = "sha256:231e0ec3b63ceb14667c67be60f2f2c40a518cb38b03af60abc813da26505f4c", size = 433602, upload-time = "2026-05-07T16:13:18.596Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7f/3e/5db95bcf282c52709639744ca2a8b149baccf648e39c8cc87553df9eae0c/urllib3-2.7.0-py3-none-any.whl", hash = "sha256:9fb4c81ebbb1ce9531cce37674bbc6f1360472bc18ca9a553ede278ef7276897", size = 131087, upload-time = "2026-05-07T16:13:17.151Z" }, +] + +[[package]] +name = "wadler-lindig" +version = "0.1.8" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ea/bf/4caf1aada6c84eb3fadf9341a90367f436a759692456e1a234d444d428ee/wadler_lindig-0.1.8.tar.gz", hash = "sha256:1a94d51cd26100dda9e430c64539c5b92b9788c87f10db3e1c87503ab814411a", size = 16256, upload-time = "2026-10-25T19:06:02.92Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/00/0b/b170089cd44848f25dbc9efda08e5aa4a8402d9a13f0d4d0f3d7808be539/wadler_lindig-0.1.8-py3-none-any.whl", hash = "sha256:8671e8c98449ae3f4e4ba720eccd63a502b3983042f8d112b49a9c6be49e8d92", size = 20840, upload-time = "2026-10-25T19:06:01.79Z" }, +] + +[[package]] +name = "wcwidth" +version = "0.8.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/36/57/ed58088fafdf4c55a0ad6bde846502567645424d7ebf325230b9237f4085/wcwidth-0.8.3.tar.gz", hash = "sha256:d128512515fbf4612e0ff21fd6380399210318b7b54a9af59dff8454cf9730eb", size = 1458450, upload-time = "2026-08-28T18:10:06.875Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c4/0e/57f6bb3024a597b2e8ec4aee710ffe62ddc95af2e2bb1ee7a7abdc22c68c/wcwidth-0.8.3-py3-none-any.whl", hash = "sha256:d5b73dba6158a595ec9370350e7f2637bcac8d6c5e4fde34f30fcffb6103a5e4", size = 331669, upload-time = "2026-08-28T18:10:04.909Z" }, +] + +[[package]] +name = "webcolors" +version = "25.10.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1d/7a/eb316761ec35664ea5174709a68bbd3389de60d4a1ebab8808bfc264ed67/webcolors-25.10.0.tar.gz", hash = "sha256:62abae86504f66d0f6364c2a8520de4a0c47b80c03fc3a5f1815fedbef7c19bf", size = 53491, upload-time = "2025-10-31T07:51:03.977Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e2/cc/e097523dd85c9cf5d354f78310927f1656c422bd7b2613b2db3e3f9a0f2c/webcolors-25.10.0-py3-none-any.whl", hash = "sha256:032c727334856fc0b968f63daa252a1ac93d33db2f5267756623c210e57a4f1d", size = 14905, upload-time = "2025-10-31T07:51:01.778Z" }, +] + +[[package]] +name = "webencodings" +version = "0.6.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d5/a0/8fd707bcb776a7be556bad06a2ea5fb9bd519df78ef8e26f70ccf0f38bff/webencodings-0.6.1.tar.gz", hash = "sha256:565f9ad031c702dae404e27a099e3e09186a3ab1b9520f06d215502b651fd910", size = 15001, upload-time = "2026-08-15T14:22:57.549Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/77/c6/040cbc72480d789a5f40d63fb484d3106554c4dfa2d2b70ad5022057750f/webencodings-0.6.1-py3-none-any.whl", hash = "sha256:7fab6269c8bf237c657876b52058ccb182e861518d1c695c1a9aaa8c1c105d5b", size = 8745, upload-time = "2026-08-15T14:22:56.31Z" }, +] + +[[package]] +name = "websocket-client" +version = "1.9.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d8/cb/a5abcc2891249f393827c650c6296660ce40374ac22d99ab9aea41f9d2a2/websocket_client-1.9.2.tar.gz", hash = "sha256:0fcb57545848be86992e128218fd96dd87a6769ffdb1a968dff79632b85604d0", size = 84110, upload-time = "2026-08-31T14:08:40.964Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d5/d2/cc4dc1271e464942db7ee278baae2daa99ee77cb2af744025c04da585a3e/websocket_client-1.9.2-py3-none-any.whl", hash = "sha256:e1a673830a9c7bfa47b1cd3d5e4178f4c9651d80a4eab02c9c23a1c3ec6250ce", size = 95786, upload-time = "2026-08-31T14:08:39.899Z" }, +] + +[[package]] +name = "widgetsnbextension" +version = "4.0.16" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/bf/60/bc7a980fc78837d6ef8f5940cca4cadc433364503a4c4d42e2a7a0de3231/widgetsnbextension-4.0.16.tar.gz", hash = "sha256:adeea0ae78f0856ee4945f413299801b82a0a01416303301f39a704282a37b73", size = 1111094, upload-time = "2026-08-18T08:52:55.859Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/34/95/40e17e20046b7bc820d29d09ae84ec157ec8dd6e6f6cd722626292c31b2e/widgetsnbextension-4.0.16-py3-none-any.whl", hash = "sha256:a31a8774885b96fe825462f5d6496166f0c7cae111195b6465c801d230eb5a4e", size = 2225148, upload-time = "2026-08-18T08:52:53.736Z" }, +] + +[[package]] +name = "x4i3" +version = "1.2.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "requests" }, + { name = "tqdm" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/04/98/290f423615798f1f25ce73928f1d3070f2bd589280689d6b5ba0ade4d2fe/x4i3-1.2.4.tar.gz", hash = "sha256:3ec5dca1d1c810b06a3ec53dcaf68ffcdd7498d903fa7a53cb09c30749357a33", size = 245755, upload-time = "2023-05-11T13:23:50.761Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/58/41/c6de129a91ad682028aa541f5b4bd0c5c2ce1d6f1d6e6332b236ac5f9172/x4i3-1.2.4-py2.py3-none-any.whl", hash = "sha256:c61fea07a9922acd4950f6a330622cd1766e493fa34567ce60876d652447e31d", size = 270096, upload-time = "2023-05-11T13:23:48.702Z" }, +] + +[[package]] +name = "xarray" +version = "2026.9.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, + { name = "packaging" }, + { name = "pandas" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ff/f5/781c70b234f54e0401f4f7c4427a7486da38d50dbb138c7d7c55144b3d86/xarray-2026.9.0.tar.gz", hash = "sha256:6abc69694c22fa1f0fb2f357ff4e41d88beb4477ed71091f944b7dbf67ed54fe", size = 3176922, upload-time = "2026-09-29T23:06:25.807Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3f/44/3159af4fb3c868970a412e294320ed6bb1a9fbdfa6431050eda8e0b34b6e/xarray-2026.9.0-py3-none-any.whl", hash = "sha256:fe349fa871628b1a0a5217af3fe1283a2862d5485156e6eda354fffb81c3bb7c", size = 1445445, upload-time = "2026-09-29T23:06:23.686Z" }, +] + +[[package]] +name = "xarray-einstats" +version = "0.11.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, + { name = "scipy" }, + { name = "xarray" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/6f/70/adb14007ee636eadd2a404802f7bb340c6f123ea81cfca152ebd4b6e2660/xarray_einstats-0.11.0.tar.gz", hash = "sha256:69f48a60f62151d40c49fd6d9a6dc0b970aecef2813a33209e4dcde897fca48b", size = 34290, upload-time = "2026-07-20T15:32:38.448Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/30/7b/34a9ce89f7a1e78423ca5a66492341c4f7daf6d0e9668af427fc2a7bc099/xarray_einstats-0.11.0-py3-none-any.whl", hash = "sha256:9dc8372aeb5db233054ddde4e57cbbcd1eee6c2e1b6bbe85863881c09b4421b3", size = 39828, upload-time = "2026-07-20T15:32:37.169Z" }, +] + +[[package]] +name = "zipp" +version = "4.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b9/d8/eab98a517c14134c0b2eb4e2387bc5f457334293ec5d2dd3857ec2966802/zipp-4.1.0.tar.gz", hash = "sha256:4cb57381f544315db7688e976e922a2b18cdb513d21cc194eb42232ba2a3e602", size = 26214, upload-time = "2026-05-18T20:08:57.967Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3a/13/547360d81e6d88d58492968ffda9f9542854f11310ee556fef14260cc886/zipp-4.1.0-py3-none-any.whl", hash = "sha256:25ad4e16390cd314347dd8f1de67a2ac538ae658ed4ab9db16029c07c188e97f", size = 10238, upload-time = "2026-05-18T20:08:57.045Z" }, +] + +[[package]] +name = "zuko" +version = "1.6.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy" }, + { name = "torch", version = "2.15.0", source = { registry = "https://download.pytorch.org/whl/cpu" }, marker = "sys_platform == 'darwin'" }, + { name = "torch", version = "2.15.0+cpu", source = { registry = "https://download.pytorch.org/whl/cpu" }, marker = "sys_platform != 'darwin'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/8c/41/ddbe72cb64996d7826ba427c675252be0c38fbd9fbf8920d0fcdaf5d8e38/zuko-1.6.0.tar.gz", hash = "sha256:edc516e51bbbf9d64e7663b617cf9293c6e1e6bbfcb39559bc383383e6663b04", size = 45245, upload-time = "2026-03-10T08:38:19.646Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/95/10/ff159867f522cd98e039e748c5e9777446e8b797a79be691c6b730676094/zuko-1.6.0-py3-none-any.whl", hash = "sha256:5c073b613a84a7cd65470ddb94855169020ac49432f73b85f25207e377248a4a", size = 48033, upload-time = "2026-03-10T08:38:21.039Z" }, +]