diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
new file mode 100644
index 0000000..a254a7f
--- /dev/null
+++ b/.github/workflows/tests.yml
@@ -0,0 +1,97 @@
+name: tests
+
+# cpm has to give the same results with and without numba, so the test suite
+# runs in both setups: with numba installed, and without it.
+on:
+  pull_request:
+  push:
+    branches: [main]
+  workflow_dispatch:
+
+concurrency:
+  group: tests-${{ github.ref }}
+  cancel-in-progress: true
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    name: ${{ matrix.os }}, Python ${{ matrix.python }}, ${{ matrix.numba && 'numba' || 'no numba' }}
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 30
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest]
+        python: ["3.11", "3.12", "3.13", "3.14"]
+        numba: [true, false]
+        include:
+          - { os: windows-latest, python: "3.14", numba: true }
+          - { os: windows-latest, python: "3.14", numba: false }
+          - { os: macos-latest, python: "3.14", numba: true }
+          - { os: macos-latest, python: "3.14", numba: false }
+    steps:
+      - uses: actions/checkout@v7
+
+      - uses: actions/setup-python@v7
+        with:
+          python-version: ${{ matrix.python }}
+          cache: pip
+
+      - name: Install cpm
+        run: pip install -e "${{ matrix.numba && '.[numba]' || '.' }}" pytest
+
+      - name: Check that numba is used
+        if: matrix.numba
+        run: python -c "from cpm.core import _jit; assert _jit.JIT_ENABLED"
+
+      - name: Run the tests
+        run: python -m pytest -q
+
+      - name: Run the kernel and application tests with NUMBA_DISABLE_JIT=1
+        if: matrix.numba
+        env:
+          NUMBA_DISABLE_JIT: "1"
+        run: python -m pytest -q test/models/test_kernels.py test/applications/test_backends.py
+
+  lowest:
+    name: lowest supported versions, Python 3.11
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    steps:
+      - uses: actions/checkout@v7
+
+      - uses: actions/setup-python@v7
+        with:
+          python-version: "3.11"
+
+      - name: Install cpm with the lowest versions pyproject.toml allows
+        run: |
+          pip install uv
+          uv pip install --system --resolution lowest-direct -e ".[numba]" "pytest>=8"
+
+      - name: Run the tests
+        run: python -m pytest -q
+
+  prerelease:
+    # the fast priors in cpm.generators._fast_priors follow scipy's internals,
+    # so pre-releases show early when a release would change them
+    name: pre-releases of NumPy, SciPy and pandas
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    continue-on-error: true
+    steps:
+      - uses: actions/checkout@v7
+
+      - uses: actions/setup-python@v7
+        with:
+          python-version: "3.14"
+
+      - name: Install cpm and the pre-releases
+        run: |
+          pip install -e . pytest
+          pip install --pre --upgrade numpy scipy pandas
+
+      - name: Run the tests
+        run: python -m pytest -q
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 45679af..dd27499 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,50 +5,75 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [0.25.7.dev0] - 2026-08-13
+## [0.26.0.dev0] - 2026-09-28
 
 ### Added
 
-- Added test units for `cpm.hierarchical.EmpiricalBayes`
-- Added test units for `cpm.hierarchical.VariationalBayes`
-- Added `number_of_starts` and `initial_guess_supplied` attributes to `cpm.optimisation.Fmin`, `cpm.optimisation.FminBound`, `cpm.optimisation.Minimize` and `cpm.optimisation.Bads`, so that the number of starts and the origin of the initial guesses are recoverable from a constructed or fitted optimiser. Previously `number_of_starts` was consumed in `__init__` and discarded, recoverable only as `initial_guess.shape[0]`, and there was no record of whether the guesses were supplied by the user or drawn from the parameter bounds - which meant a fit started from a fixed point was indistinguishable from one started from random restarts (#83)
-- Added test units for the new optimiser provenance attributes, covering all four optimisers
-- Added a `cpm.optimisation.Bads` smoke test that runs a real fit and asserts it reaches `scipy.optimize.minimize` through pybads and gpyreg. `Bads.optimise()` was previously never executed by the test suite, so breakage in that chain - such as a SciPy or NumPy release changing an API it depends on - went undetected
-- Added `log_likelihood` and `log_prior` to the fitted output of all optimisers when run with `prior=True`, so that `fun` (the negative log posterior) can be split into its two terms ([#28](https://github.com/DevComPsy/cpm/issues/28))
-- Added a `metrics` argument to all optimisers, which evaluates user-supplied goodness-of-fit metrics (such as `PenalisedLikelihoods.BIC`) at the optimum and adds them to `export()` ([#28](https://github.com/DevComPsy/cpm/issues/28))
-- Added `cpm.applications.reinforcement_learning.HybridMBMF`, the 6-parameter hybrid model-based / model-free model for the two-step task (Kool et al., 2016; Smid et al., 2022)
-- Added `cpm.models.learning.SARSATrace`, a SARSA learning rule with an eligibility trace for two-stage tasks
+- Added test units for `cpm.hierarchical.EmpiricalBayes` and `cpm.hierarchical.VariationalBayes`
+- Added `number_of_starts` and `initial_guess_supplied` attributes to all optimisers, recording how many starts a fit used and whether the initial guesses were supplied ([#83](https://github.com/DevComPsy/cpm/issues/83))
+- Added test units for the new optimiser attributes, and a smoke test that runs a real `cpm.optimisation.Bads` fit
+- Added `log_likelihood` and `log_prior` to the output of all optimisers fitted with `prior=True` ([#28](https://github.com/DevComPsy/cpm/issues/28))
+- Added a `metrics` argument to all optimisers, for goodness-of-fit metrics such as `PenalisedLikelihoods.BIC` evaluated at the optimum ([#28](https://github.com/DevComPsy/cpm/issues/28))
+- Added `cpm.applications.reinforcement_learning.HybridMBMF`, the hybrid model-based / model-free model of the two-step task (Kool et al., 2016; Smid et al., 2022)
+- Added `cpm.models.learning.SARSATrace`, a SARSA learning rule with an eligibility trace
 - Added test units for `HybridMBMF` and `SARSATrace`
-- Added a two-step task example notebook replicating Smid et al. (2022)
-- Added `cpm.datasets.load_two_step_data`, which loads the adult two-step task data of Smid et al. (2022) that ship with the package
+- Added a two-step task example replicating Smid et al. (2022), with its data in `cpm.datasets.load_two_step_data`
+- Added `cpm.generators.SessionWrapper`, a `Wrapper` for models that compute all trials of a participant at once
+- Added `cpm.models.kernels`, the formulas of the `cpm.models` classes as functions that numba can compile, used by the classes and the built-in applications
+- Added numba as an optional dependency (`pip install "cpm-toolbox[numba]"`) that compiles the built-in applications; without it, they give the same results as plain Python
+- Added the numba install option to the installation guide, a how-to guide on numba, and troubleshooting entries
+- Added a how-to guide on speeding up your own model with `SessionWrapper`, with a test that runs its example
+- Added test units for `SessionWrapper`, `cpm.models.kernels`, the fast priors, and the built-in applications with and without numba
+- Added a benchmark suite (`benchmarks/run.py` for one evaluation, `benchmarks/hierarchical.py` for the hierarchical tutorials) and `scripts/local_tests.py`, which runs the tests with and without numba
+- Added a GitHub Actions workflow that runs the tests with and without numba, on Python 3.11 to 3.14
 
 ### Changed
 
-- Rebuilt the documentation with Sphinx and the PyData theme, replacing MkDocs. The site now separates the API reference from the tutorials (a numbered learning path from fitting a first model to hierarchical estimation), a gallery of research examples, and how-to guides; adds a quickstart and core concept pages; documents every public object; and links API pages to the tutorials that use them. All tutorials and examples were rewritten or revised and re-run on the current version. Pages of the old site redirect to their new locations
-- Converted all docstrings from Markdown to reStructuredText (NumPy style), fixed incorrect examples in the docstrings of `RLRW`, `EmpiricalBayes`, `ProspectUtility`, `bin_ratings`, `count_trials` and `convert_to_RLRW`, added an example to `VariationalBayes`, and corrected the column list of `load_bandit_data`. Docstrings with LaTeX are now raw strings, which fixes a `SyntaxWarning` and a corrupted equation in the docstring of `RLRW`
-- Restricted package discovery to `cpm`, so that files under `docs/` are no longer packaged, and added `docs` and `notebooks` optional dependencies
-- Significantly improved the performance of `cpm.hierarchical.EmpiricalBayes` and `cpm.hierarchical.VariationalBayes` for long or multi-chain EM runs, by buffering results instead of concatenating on every iteration and vectorising the Hessian inversions
+- Rebuilt the documentation with Sphinx and the PyData theme, with a separate API reference, tutorials, examples and how-to guides; pages of the old site redirect
+- Converted all docstrings to reStructuredText (NumPy style), and fixed incorrect examples and a `SyntaxWarning` from LaTeX in docstrings
+- Restricted package discovery to `cpm`, and added `docs` and `notebooks` optional dependencies
+- Sped up long and multi-chain runs of `cpm.hierarchical.EmpiricalBayes` and `cpm.hierarchical.VariationalBayes`
+- Made every model cheaper to evaluate: copies of a `cpm.generators.Value` share their prior, and the built-in priors are evaluated without scipy overhead, with identical results
+- `cpm.generators.Value.update_prior()` now replaces the prior instead of changing it in place; changing `value.prior.kwds` directly now affects every copy of the `Value`
+- `cpm.generators.Wrapper.reset()` now keeps the current priors and bounds of the parameters, instead of restoring the ones the model was created with
+- Made the built-in applications (`RLRW`, `HybridMBMF`, `PTSM`, `PTSM1992`, `PTSM2025`) compute all trials at once: 90-220 times faster with numba, 11-23 times without, with the same interface and results
+- Made per-trial `cpm.generators.Wrapper` models about twice as fast, by reading trials without `DataFrame.iloc`
+- Made the classes in `cpm.models` faster, up to 17 times for large inputs, with identical results
+- Made `LogLikelihood.bernoulli` and `LogLikelihood.continuous` 2.5-3 times faster, with identical results
+- Made `cpm.applications.signal_detection.EstimatorMetaD` about 10 times faster, with identical results
+- `cpm.models.decision.Softmax` no longer overflows: it returns the correct policy where it returned NaN and warned
+- `cpm.models.activation.ProspectUtility.weights` and `.utilities` are float arrays instead of object arrays, and the `simulation` records of `HybridMBMF` hold NumPy scalars instead of Python numbers
+- `PTSM2025` always uses its power utility: replacing `parameters.utility_curvature` on a model no longer changes it
+- Required Python 3.11 or later (previously `>3.11.0`, which excluded 3.11.0), removed the PyPy classifier, and tagged the wheel for Python 3 only
 
 ### Fixed
 
-- Fixed `cpm.optimisation.Bads` emitting a `DeprecationWarning` on every GP fit, which would become an error on Python 3.16, by passing `gp_fixed_mean` to pybads as a NumPy boolean ([#88](https://github.com/DevComPsy/cpm/issues/88))
-- Fixed `cpm.optimisation.Bads` failing with `ValueError: setting an array element with a sequence` under NumPy 2 by requiring `gpyreg>=1.2.1`
-- Fixed `cpm.optimisation.FminBound` raising `TypeError` on SciPy 1.18.0 and later, which removed the `disp` and `iprint` options of L-BFGS-B; they are now passed only where SciPy still accepts them
-- Fixed `cpm.hierarchical.VariationalBayes.ttest` raising a `NameError` when `null` was passed as a `pandas.DataFrame`, due to referencing an undefined variable from the wrong branch
-- Fixed `cpm.hierarchical.VariationalBayes.lmes` recording the same, fully-grown list of log model evidence values for every iteration of a chain instead of a snapshot of that iteration's value, due to appending a reference to a still-mutating list
-- Removed a dead, always-zero `mean_errorbar` column from `cpm.hierarchical.VariationalBayes.hyperparameters` that was left behind by a column-naming mismatch (values were actually being written to a separate `mean_se` column)
-- Fixed `cpm.generators.Value` with `prior="uniform"` spanning `[lower, lower + upper]` instead of `[lower, upper]`, due to passing `upper` rather than `upper - lower` as the scale, which biased every log prior and let `Parameters.sample()` draw values above the upper bound
-- Fixed `cpm.generators.Parameters.sample()` raising `AttributeError` when a parameter was `None`, due to a missing `None` guard that `free()`, `bounds()` and `PDF()` already had
-- Fixed callable arguments to `cpm.generators.Parameters` leaking onto every other `Parameters` instance in the process, due to being set as static methods on the class rather than stored on the instance
-- Fixed `cpm.models.learning.SeparableRule.error` never being populated, which left it at zeros and made `noisy_learning_rule()` a no-op because the noise scales with the error; it now holds the prediction error for each outcome-stimulus pair. Also fixed `DeltaRule` and `SeparableRule` sizing `error` before promoting 1D weights to 2D
-- Fixed `cpm.generators.Wrapper.reset()` misassigning an array of parameter values whenever a non-free attribute (such as an initial state) was declared before a free parameter, due to mapping the array onto all keys instead of `Parameters.free()`
-- Fixed `cpm.generators.Simulator` not raising its intended `TypeError` for an ungrouped `pandas.DataFrame`, due to type-checking a boolean flag instead of the data; the mistake previously surfaced later as a misleading group-count `ValueError`
-- Fixed `cpm.generators.Simulator` raising `AttributeError` when parameters were passed as a `pandas.DataFrame` with grouped data, due to looking up parameter rows by group key instead of position; `cpm.core.data.unpack_participants` also returned every remaining row instead of a single participant's row
-- Fixed `cpm.hierarchical.EmpiricalBayes.diagnostics()` and `cpm.hierarchical.VariationalBayes.diagnostics()` raising `IndexError` for models with three or more free parameters, due to hardcoded trace limits for two parameters; `convergence_diagnostics_plots` now takes the limits from the model's parameter bounds via a new `bounds` argument
-- Fixed a clean install of `cpm-toolbox` raising `ModuleNotFoundError` on `diagnostics()`, due to `matplotlib` being imported by `cpm.core.diagnostics` but missing from the declared dependencies
-- Fixed `cpm.utils.data` (and `cpm.utils.metad`) not being reachable after `import cpm`, due to `cpm/utils/__init__.py` not importing its submodules
-- Fixed `cpm.generators.Simulator` raising `ValueError` for a single parameter set given as a `Parameters` object, `dict` or `pandas.Series`, due to checking the length of the input rather than of the cast parameters; a `Parameters` object is now used as-is for every participant, as documented, instead of drawing a new prior sample for each
-- Fixed `cpm.core.diagnostics.gelman_rubin` and `cpm.core.diagnostics.psrf` failing on every call, due to the removed `pandas.DataFrame.append` and a nonexistent `unique_` attribute; `gelman_rubin` also computed the statistic incorrectly (misaligned chains, swapped within- and between-chain variances) and now reports it for both the mean and sd of each parameter, comparing chains over their common iterations
+- Fixed `cpm.hierarchical.EmpiricalBayes` and `cpm.hierarchical.VariationalBayes` discarding the estimated population priors after the first evaluation of each fit; hierarchical results change
+- Fixed the random starting priors of later chains of `EmpiricalBayes` and `VariationalBayes` being length-one arrays
+- Fixed `numpy.random.seed` not reproducing the later chains of `EmpiricalBayes` and `VariationalBayes`, whose starting priors now also respect the lower bound and work with infinite bounds
+- Fixed `cpm.optimisation.Bads` emitting a `DeprecationWarning` on every GP fit ([#88](https://github.com/DevComPsy/cpm/issues/88))
+- Fixed `cpm.optimisation.Bads` failing under NumPy 2, by requiring `gpyreg>=1.2.1`
+- Fixed installs with pandas, matplotlib or pybads releases that do not work with NumPy 2, by requiring `pandas>=2.2.2`, `matplotlib>=3.8.4` and `pybads>=1.0.5`
+- Fixed `cpm.optimisation.FminBound` raising `TypeError` on SciPy 1.18.0 and later
+- Fixed `cpm.hierarchical.VariationalBayes.ttest` raising `NameError` when `null` is a `pandas.DataFrame`
+- Fixed `cpm.hierarchical.VariationalBayes.lmes` repeating the final list of model evidences for every iteration
+- Removed a dead, always-zero `mean_errorbar` column from `cpm.hierarchical.VariationalBayes.hyperparameters`
+- Fixed `cpm.generators.Value` with `prior="uniform"` spanning `[lower, lower + upper]` instead of `[lower, upper]`
+- Fixed `cpm.generators.Parameters.sample()` raising `AttributeError` for a parameter that is `None`
+- Fixed callables passed to `cpm.generators.Parameters` leaking onto every other `Parameters` instance
+- Fixed `cpm.models.learning.SeparableRule.error` never being filled, which made `noisy_learning_rule()` a no-op, and the `error` of `DeltaRule` and `SeparableRule` having the wrong shape for 1D weights
+- Fixed `cpm.generators.Wrapper.reset()` misassigning an array of parameter values when a state is declared before a free parameter
+- Fixed `numpy.asarray(value, dtype=...)` raising `TypeError` for a `cpm.generators.Value`
+- Fixed `cpm.models.activation.ProspectUtility` with `weighting="prelec"` failing for options with several outcomes
+- Fixed `cpm.applications.decision_making.PTSM2025` stopping a fit with `ValueError` when its exponentials overflowed
+- Fixed `cpm.models.learning.HumbleTeacher` raising `IndexError` for 1D weights
+- Fixed `cpm.generators.Simulator` not raising its intended `TypeError` for an ungrouped `pandas.DataFrame`
+- Fixed `cpm.generators.Simulator` raising `AttributeError` for parameters in a `pandas.DataFrame` with grouped data
+- Fixed `cpm.generators.Simulator` raising `ValueError` for a single parameter set given as `Parameters`, `dict` or `pandas.Series`
+- Fixed `diagnostics()` of `EmpiricalBayes` and `VariationalBayes` failing for three or more free parameters; `convergence_diagnostics_plots` has a new `bounds` argument
+- Fixed a clean install raising `ModuleNotFoundError` in `diagnostics()`, by adding `matplotlib` to the dependencies
+- Fixed `cpm.utils.data` and `cpm.utils.metad` not being reachable after `import cpm`
+- Fixed `cpm.core.diagnostics.gelman_rubin` and `cpm.core.diagnostics.psrf` failing on every call, and `gelman_rubin` computing the statistic incorrectly
 
 ## [0.25.6] - 2026-04-15
 
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 50363cb..d8b1c6a 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -25,6 +25,14 @@ pip install -e .
 pip install -e ".[docs]"
 ```
 
+5. (Optional) Install numba, which compiles the built-in models (`cpm.applications`) and the kernels in `cpm.models.kernels`:
+
+```bash
+pip install -e ".[numba]"
+```
+
+cpm has to work, with the same results, with and without numba, so changes to the models are tested both ways (see [Testing](#testing)).
+
 ## Development workflow (with direct access to repository)
 
 1. Create a branch from `main`.
@@ -75,6 +83,16 @@ pytest
 
 If you changed specific functionality, also run targeted tests first (for example, under `test/models/` or `test/optimisation/`).
 
+If you changed the models (`cpm.models`, `cpm.applications`) or anything they use, also run the tests with and without numba, and the benchmark suite:
+
+```bash
+python scripts/local_tests.py
+```
+
+It runs the test suite with numba (if it is installed), with `CPM_DISABLE_JIT=1` (as if numba were not installed), and with `NUMBA_DISABLE_JIT=1`, and then `benchmarks/run.py`.
+
+numba caches compiled code in the `__pycache__` folders under `cpm/`, and only recompiles a function when its own file changes. After changing `cpm/models/kernels.py` (yourself, or by pulling), the compiled loops in `cpm/applications/_sessions.py` still use the old kernels until you delete the cached `*.nbi` and `*.nbc` files; `scripts/local_tests.py` deletes them before it runs.
+
 ## Documentation
 
 The documentation is built with [Sphinx](https://www.sphinx-doc.org/) and the [PyData theme](https://pydata-sphinx-theme.readthedocs.io/).
diff --git a/README.md b/README.md
index 89a346a..e1f9fe4 100644
--- a/README.md
+++ b/README.md
@@ -16,6 +16,12 @@ To install the package, run the following command:
 pip install cpm-toolbox
 ```
 
+To fit the built-in models many times faster, also install the optional [numba](https://numba.pydata.org/) dependency, which compiles them; nothing else changes:
+
+```bash
+pip install "cpm-toolbox[numba]"
+```
+
 Once the package is installed, you can import it in your Python code:
 
 ```python
diff --git a/benchmarks/cases.py b/benchmarks/cases.py
new file mode 100644
index 0000000..cd15444
--- /dev/null
+++ b/benchmarks/cases.py
@@ -0,0 +1,132 @@
+"""
+The benchmark cases: every built-in application of cpm, on one participant.
+
+Each case builds a model for a given backend and returns it together with the
+observed data and the parameter values at which the objective is evaluated.
+
+- "python" and "numba": the application, which computes all trials at once, as
+  plain Python or compiled with numba. Installing numba makes "numba" the default.
+- "trial": the application's per-trial `model` function in a plain per-trial
+  `Wrapper`, which is how users extend an application trial by trial.
+
+With cpm versions before the applications computed all trials at once, only
+"trial" is available, and it is the application itself.
+"""
+
+import warnings
+
+import numpy as np
+import pandas as pd
+
+import cpm
+from cpm.generators import Wrapper
+from cpm.datasets import load_bandit_data, load_risky_choices
+
+
+def bandit():
+    data = load_bandit_data()
+    data = data[data.ppt == 1].reset_index(drop=True)
+    data["observed"] = data["response"]
+    return data
+
+
+def two_step(n=200, seed=0):
+    rng = np.random.default_rng(seed)
+    action = rng.integers(0, 2, n)
+    common = rng.random(n) < 1.0  # deterministic transitions in the novel task
+    return pd.DataFrame(
+        {
+            "s1": rng.integers(0, 2, n),
+            "stimuli_first": rng.integers(0, 2, n),
+            "action": action,
+            "s2": np.where(common, 1 - action, action),
+            "reward": rng.integers(0, 10, n) / 9,
+            "reward_0": rng.integers(0, 10, n) / 9,
+            "reward_1": rng.integers(0, 10, n) / 9,
+            "observed": action,
+        }
+    )
+
+
+def risky():
+    data = load_risky_choices()
+    data = data[data.ppt == 1].reset_index(drop=True)
+    data["observed"] = data["choice"].astype(int)
+    return data
+
+
+PT_SETTINGS = {
+    "alpha": [0.8, 1e-2, 5.0],
+    "lambda_loss": [1.6, 1e-2, 5.0],
+    "gamma": [0.7, 1e-2, 5.0],
+    "temperature": [3.0, 1e-2, 15.0],
+    "beta": [0.9, 0.0, 5.0],
+    "delta": [0.6, 1e-2, 5.0],
+    "eta": [0.1, -0.49, 0.49],
+    "phi_gain": [0.2, -10.0, 10.0],
+    "phi_loss": [-0.3, -10.0, 10.0],
+}
+
+
+def _application(module, name):
+    return getattr(getattr(cpm.applications, module), name)
+
+
+def _on_backend(model, backend):
+    """The model on `backend`, or None if this version of cpm cannot run it there."""
+    session = getattr(model, "_session_model", None)
+    if backend == "trial":
+        if session is None:
+            return model  # an older cpm: the application is a per-trial Wrapper
+        return Wrapper(model=model.model, data=model.data, parameters=model.parameters)
+    if session is None:
+        return None
+    session.backend = backend
+    return model
+
+
+def build(case, backend="trial"):
+    """
+    The model, observed data and parameter values of a benchmark case.
+
+    Returns None if the installed cpm has no model for this backend.
+    """
+    warnings.simplefilter("ignore")
+    if case == "RLRW":
+        cls = _application("reinforcement_learning", "RLRW")
+        data = bandit()
+        kwargs = dict(dimensions=4, parameters_settings=[[0.3, 0, 1], [4, 0, 10]])
+    elif case == "HybridMBMF":
+        cls = _application("reinforcement_learning", "HybridMBMF")
+        data = two_step()
+        kwargs = dict(
+            parameters_settings=[
+                [2, 0, 5], [0.4, 0, 1], [0.6, 0, 1], [0.5, 0, 1], [0.3, -5, 5], [-0.2, -5, 5]
+            ]
+        )
+    elif case in ("PTSM", "PTSM1992", "PTSM2025"):
+        cls = _application("decision_making", case)
+        data = risky()
+        kwargs = dict(parameters_settings=PT_SETTINGS)
+    else:
+        raise ValueError(case)
+    if backend == "numba" and not _jit_enabled():
+        return None
+    model = _on_backend(cls(data=data, **kwargs), backend)
+    if model is None:
+        return None
+    observed = data["observed"].to_numpy()
+    x = np.array([model.parameters[k].value for k in model.parameters.free()], dtype=float)
+    return model, observed, x
+
+
+def _jit_enabled():
+    try:
+        from cpm.core import _jit
+    except ImportError:
+        return False
+    return _jit.JIT_ENABLED
+
+
+CASES = ["RLRW", "HybridMBMF", "PTSM", "PTSM1992", "PTSM2025"]
+BACKENDS = ["trial", "python", "numba"]
diff --git a/benchmarks/hierarchical.py b/benchmarks/hierarchical.py
new file mode 100644
index 0000000..4f5f0ea
--- /dev/null
+++ b/benchmarks/hierarchical.py
@@ -0,0 +1,186 @@
+"""
+How long does a hierarchical analysis take? The two hierarchical tutorials, timed.
+
+    python benchmarks/hierarchical.py ANALYSIS MODEL OUT
+
+ANALYSIS is "eb" (docs/tutorials/hierarchical-empirical-bayes.ipynb: separate
+maximum-likelihood fits, then empirical Bayes) or "vb"
+(docs/tutorials/hierarchical-variational-bayes.ipynb: variational Bayes). Both
+simulate 50 participants of the bandit task from a known group distribution
+and fit them with `FminBound` (2 starts per participant), exactly as the
+tutorials do, with the same random seed.
+
+MODEL is "tutorial" (the per-trial model the tutorials build from `Softmax`
+and `SeparableRule`, in a `Wrapper`) or "rlrw" (the same model as the built-in
+`cpm.applications.reinforcement_learning.RLRW`, which computes all trials at
+once and is compiled with numba if it is installed). The data are simulated
+with the tutorial model in both cases, so both fit the same data.
+
+Writes the timings and the results (estimates and hyperparameters) to OUT, a
+pickle file.
+"""
+
+import pickle
+import platform
+import sys
+import time
+import warnings
+from functools import partial
+
+import numpy as np
+import pandas as pd
+
+import cpm
+from cpm.datasets import load_bandit_data
+from cpm.generators import Parameters, Simulator, Value, Wrapper
+from cpm.models.decision import Softmax
+from cpm.models.learning import SeparableRule
+from cpm.optimisation import FminBound, minimise
+
+ANALYSIS, MODEL, OUT = sys.argv[1:4]
+assert ANALYSIS in ("eb", "vb") and MODEL in ("tutorial", "rlrw")
+
+np.random.seed(2026)
+_ = np.seterr(all="ignore")
+warnings.simplefilter("ignore")
+
+
+## ---------------------------------------------------------------------------
+## the tutorials' model and data (cell 3 of both notebooks)
+
+
+def model(parameters, trial, generate=False):
+    values = np.asarray(parameters.values).copy()
+    stimuli = np.array([trial.arm_left, trial.arm_right]).astype(int)
+    rewards = np.array([trial.reward_left, trial.reward_right])
+
+    choice_rule = Softmax(activations=values[stimuli - 1], temperature=parameters.temperature)
+    choice_rule.compute()
+    choice = choice_rule.choice() if generate else int(trial.response)
+
+    chosen = np.zeros(4)
+    chosen[stimuli[choice] - 1] = 1
+    update = SeparableRule(weights=values, feedback=[rewards[choice]], input=chosen, alpha=parameters.alpha)
+    update.compute()
+    values += update.weights.flatten()
+
+    return {
+        "policy": choice_rule.policies,
+        "response": choice,
+        "values": values,
+        "dependent": np.array([choice_rule.policies[1]]),
+    }
+
+
+def make_parameters(alpha_mean, alpha_sd, temperature_mean, temperature_sd):
+    return Parameters(
+        alpha=Value(value=0.5, lower=1e-10, upper=1, prior="truncated_normal", args={"mean": alpha_mean, "sd": alpha_sd}),
+        temperature=Value(value=1, lower=0, upper=10, prior="truncated_normal", args={"mean": temperature_mean, "sd": temperature_sd}),
+        values=np.array([0.25, 0.25, 0.25, 0.25]),
+    )
+
+
+timings = {}
+start = time.perf_counter()
+data = load_bandit_data()
+data = data[data.ppt <= 50].reset_index(drop=True)
+data["observed"] = data["response"]
+population = make_parameters(alpha_mean=0.6, alpha_sd=0.2, temperature_mean=2, temperature_sd=1)
+true_parameters = pd.DataFrame(population.sample(size=data.ppt.nunique()))
+simulator = Simulator(
+    wrapper=Wrapper(model=partial(model, generate=True), parameters=population, data=data[data.ppt == 1]),
+    parameters=true_parameters,
+    data=data.groupby("ppt"),
+)
+simulator.run()
+data["response"] = simulator.export()["response"].to_numpy()
+data["observed"] = data["response"]
+timings["simulate"] = time.perf_counter() - start
+
+
+def make_wrapper():
+    """The model with the broad starting priors of the tutorials."""
+    if MODEL == "tutorial":
+        parameters = make_parameters(alpha_mean=0.5, alpha_sd=0.5, temperature_mean=5, temperature_sd=5)
+        return Wrapper(model=model, parameters=parameters, data=data[data.ppt == 1])
+    from cpm.applications.reinforcement_learning import RLRW
+
+    wrapper = RLRW(data=data[data.ppt == 1], dimensions=4, parameters_settings=[[0.5, 1e-10, 1], [1, 0, 10]])
+    wrapper.parameters.update_prior(alpha={"mean": 0.5, "sd": 0.5}, temperature={"mean": 5, "sd": 5})
+    return wrapper
+
+
+def optimiser(prior):
+    return FminBound(
+        model=make_wrapper(),
+        data=data.groupby("ppt"),
+        minimisation=minimise.LogLikelihood.bernoulli,
+        prior=prior,
+        number_of_starts=2,
+        ppt_identifier="ppt",
+        parallel=False,
+        display=False,
+        approx_grad=True,
+    )
+
+
+results = {"true_parameters": true_parameters}
+if ANALYSIS == "eb":
+    from cpm.hierarchical import EmpiricalBayes
+
+    start = time.perf_counter()
+    separate = optimiser(prior=False)
+    separate.optimise()
+    timings["separate fits"] = time.perf_counter() - start
+    results["maximum_likelihood"] = pd.DataFrame(separate.parameters)
+
+    start = time.perf_counter()
+    eb = EmpiricalBayes(optimiser=optimiser(prior=True), iteration=6, chain=2, tolerance=1e-3, quiet=True)
+    eb.optimise()
+    timings["empirical Bayes"] = time.perf_counter() - start
+    results["hyperparameters"] = eb.hyperparameters
+    results["fit"] = eb.fit
+else:
+    from cpm.hierarchical import VariationalBayes
+
+    start = time.perf_counter()
+    number_of_parameters = 2
+    vb = VariationalBayes(
+        optimiser=optimiser(prior=True),
+        iteration=6,
+        chain=2,
+        convergence="lme",
+        tolerance_lme=1e-2,
+        hyperpriors={
+            "a0": np.zeros(number_of_parameters),
+            "b": 1,
+            "v": 0.5,
+            "s": np.repeat(0.01, number_of_parameters),
+        },
+        quiet=True,
+    )
+    vb.optimise()
+    timings["variational Bayes"] = time.perf_counter() - start
+    results["hyperparameters"] = vb.hyperparameters
+    results["fit"] = vb.fit
+
+try:
+    from cpm.core import _jit
+
+    numba_used = MODEL == "rlrw" and bool(_jit.JIT_ENABLED)
+except ImportError:
+    numba_used = False
+record = {
+    "analysis": ANALYSIS,
+    "model": MODEL,
+    "numba": numba_used,
+    "cpm": cpm.__version__,
+    "python": platform.python_version(),
+    "numpy": np.__version__,
+    "timings": timings,
+    "results": results,
+}
+with open(OUT, "wb") as f:
+    pickle.dump(record, f)
+print(f"{ANALYSIS} {MODEL} (cpm {cpm.__version__}, numba {'on' if numba_used else 'off'}): "
+      + ", ".join(f"{k} {v:.1f} s" for k, v in timings.items()))
diff --git a/benchmarks/results/hierarchical-report.csv b/benchmarks/results/hierarchical-report.csv
new file mode 100644
index 0000000..12a612d
--- /dev/null
+++ b/benchmarks/results/hierarchical-report.csv
@@ -0,0 +1,9 @@
+analysis,variant,separate_fits_s,hierarchical_fit_s,iterations,seconds_per_iteration,fitting_total_s
+empirical Bayes,"main, tutorial model",37.02,458.9981,10,45.8998,496.0181
+empirical Bayes,"branch, tutorial model",18.5401,224.9755,12,18.748,243.5156
+empirical Bayes,"branch, RLRW without numba",3.0379,45.0587,12,3.7549,48.0966
+empirical Bayes,"branch, RLRW with numba",1.0321,7.5243,12,0.627,8.5564
+variational Bayes,"main, tutorial model",,180.9569,4,45.2392,180.9569
+variational Bayes,"branch, tutorial model",,227.5081,12,18.959,227.5081
+variational Bayes,"branch, RLRW without numba",,43.6024,12,3.6335,43.6024
+variational Bayes,"branch, RLRW with numba",,8.4628,12,0.7052,8.4628
diff --git a/benchmarks/results/report-branch.csv b/benchmarks/results/report-branch.csv
new file mode 100644
index 0000000..779f338
--- /dev/null
+++ b/benchmarks/results/report-branch.csv
@@ -0,0 +1,16 @@
+case,backend,trials,parameters,objective_ms,reset_ms,prior_ms,run_ms,loss_ms,log_posterior,speed_up
+RLRW,trial,71,2,3.8262499729171395,0.004699919372797012,0.004800036549568176,3.712500096298754,0.019399914890527725,-26.034401210112605,1.0
+RLRW,python,71,2,0.7825000211596489,0.004800036549568176,0.004799920134246349,0.7339000003412366,0.01910002902150154,-26.034401210112605,4.889776190991939
+RLRW,numba,71,2,0.08020002860575914,0.004999921657145023,0.004800036549568176,0.03490003291517496,0.018799910321831703,-26.034401210112605,47.708835513337675
+HybridMBMF,trial,200,6,11.40304998261854,0.011499971151351929,0.008800067007541656,11.376600014045835,0.021999934688210487,-151.7819350468299,1.0
+HybridMBMF,python,200,6,2.066750021185726,0.011999974958598614,0.009300070814788342,1.9907000241801143,0.022000051103532314,-151.7819350468299,5.517382298647051
+HybridMBMF,numba,200,6,0.11930009350180626,0.012100092135369778,0.00870006624609232,0.0564999645575881,0.022099935449659824,-151.7819350468299,95.58290901461777
+PTSM,trial,40,4,2.216799999587238,0.0067999353632330894,0.0069999368861317635,2.084299921989441,0.019300030544400215,-36.42346848683204,1.0
+PTSM,python,40,4,0.30149996746331453,0.007600057870149612,0.00700005330145359,0.24449999909847975,0.01850002445280552,-36.42346848683204,7.352571273020022
+PTSM,numba,40,4,0.07349997758865356,0.0074999406933784485,0.0069999368861317635,0.02119992859661579,0.0171000137925148,-36.42346848683204,30.160553408514954
+PTSM1992,trial,40,6,2.256499952636659,0.009400071576237679,0.009200070053339005,2.155599999241531,0.018600025214254856,-39.43873213610623,1.0
+PTSM1992,python,40,6,0.3492499818094075,0.0097999582067132,0.009200070053339005,0.2853999612852931,0.018799910321831703,-39.43873213610623,6.460988031970966
+PTSM1992,numba,40,6,0.08310005068778992,0.009199953638017178,0.008500064723193645,0.025799963623285294,0.0198000343516469,-39.43873213610623,27.154014154749632
+PTSM2025,trial,40,5,1.9840000313706696,0.007400056347250938,0.008100061677396297,1.8681000219658017,0.019799917936325073,-33.01065168146936,1.0
+PTSM2025,python,40,5,0.30955002875998616,0.007999944500625134,0.00809994526207447,0.25210005696862936,0.019400031305849552,-33.01065168146936,6.409303333998366
+PTSM2025,numba,40,5,0.0665000407025218,0.00800006091594696,0.00809994526207447,0.014499993994832039,0.019600032828748226,-33.01065168146936,29.834568677120114
diff --git a/benchmarks/results/report-main.csv b/benchmarks/results/report-main.csv
new file mode 100644
index 0000000..e9314e8
--- /dev/null
+++ b/benchmarks/results/report-main.csv
@@ -0,0 +1,6 @@
+case,backend,trials,parameters,objective_ms,reset_ms,prior_ms,run_ms,loss_ms,log_posterior,speed_up
+RLRW,trial,71,2,8.587050018832088,0.41924999095499516,0.08154998067766428,7.541499915532768,0.04809990059584379,-26.034401210112605,1.0
+HybridMBMF,trial,200,6,25.720649980939925,0.8374500321224332,0.23040000814944506,23.526999983005226,0.054900068789720535,-151.7819350468299,1.0
+PTSM,trial,40,4,6.807900033891201,0.6519000162370503,0.16279995907098055,5.2281999960541725,0.04780001472681761,-36.42346848683204,1.0
+PTSM1992,trial,40,6,7.718699984252453,0.8669000235386193,0.2381000085733831,6.072300020605326,0.0479499576613307,-39.43873213610623,1.0
+PTSM2025,trial,40,5,76.83905004523695,0.7273000665009022,0.202000024728477,76.62820001132786,0.04780001472681761,-33.01065168146936,1.0
diff --git a/benchmarks/run.py b/benchmarks/run.py
new file mode 100644
index 0000000..411b492
--- /dev/null
+++ b/benchmarks/run.py
@@ -0,0 +1,116 @@
+"""
+Where does the time of one evaluation of the objective go, for every built-in
+application of cpm and every backend?
+
+    python benchmarks/run.py [--repeats 200] [--label NAME]
+
+Prints a table and writes benchmarks/results/<label>.csv. Times are medians of
+wall-clock time per call. `backend` is "python" or "numba" for the applications,
+and "trial" for their per-trial `model` function in a per-trial `Wrapper` (see
+cases.py).
+"""
+
+import argparse
+import pathlib
+import platform
+import sys
+import time
+import warnings
+
+import numpy as np
+import pandas as pd
+
+sys.path.insert(0, str(pathlib.Path(__file__).parent))
+
+import cpm  # noqa: E402
+from cpm.core.optimisers import objective  # noqa: E402
+from cpm.optimisation.minimise import LogLikelihood  # noqa: E402
+
+from cases import BACKENDS, CASES, build  # noqa: E402
+
+RESULTS = pathlib.Path(__file__).parent / "results"
+
+
+def clock(function, repeats):
+    """Median wall-clock seconds of one call, after one warm-up call."""
+    function()
+    times = []
+    for _ in range(repeats):
+        start = time.perf_counter()
+        function()
+        times.append(time.perf_counter() - start)
+    return float(np.median(times))
+
+
+def layers(model, observed, x, repeats):
+    """Seconds per call of the objective and of its parts."""
+    loss = LogLikelihood.bernoulli
+    out = {"objective": clock(lambda: objective(x, model, observed, loss, True), repeats)}
+
+    def reset():
+        model.__run__ = True
+        model.reset(parameters=x)
+
+    out["reset"] = clock(reset, repeats)
+    out["prior"] = clock(lambda: model.parameters.PDF(log=True), repeats)
+    model.reset(parameters=x)
+
+    def run():
+        model.__run__ = False
+        model.run()
+
+    out["run"] = clock(run, max(repeats // 4, 5))
+    predicted = model.dependent.copy()
+    out["loss"] = clock(lambda: loss(predicted=predicted, observed=observed), repeats)
+    return out, -objective(x, model, observed, loss, True)
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("--repeats", type=int, default=200)
+    parser.add_argument("--label", default="current")
+    parser.add_argument("--cases", nargs="*", default=CASES)
+    args = parser.parse_args()
+    warnings.simplefilter("ignore")
+
+    rows = []
+    for case in args.cases:
+        for backend in BACKENDS:
+            built = build(case, backend)
+            if built is None:
+                continue
+            model, observed, x = built
+            times, log_posterior = layers(model, observed, x, args.repeats)
+            rows.append(
+                {
+                    "case": case,
+                    "backend": backend,
+                    "trials": len(observed),
+                    "parameters": len(x),
+                    **{f"{k}_ms": v * 1e3 for k, v in times.items()},
+                    "log_posterior": log_posterior,
+                }
+            )
+            print(f"{case:>10} {backend:>6}: {times['objective'] * 1e3:8.3f} ms", flush=True)
+
+    table = pd.DataFrame(rows)
+    trial = table[table.backend == "trial"].set_index("case")["objective_ms"]
+    table["speed_up"] = trial.reindex(table.case).to_numpy() / table["objective_ms"]
+    RESULTS.mkdir(exist_ok=True)
+    table.to_csv(RESULTS / f"{args.label}.csv", index=False)
+    with pd.option_context("display.width", 200):
+        print(table.to_string(index=False, float_format=lambda v: f"{v:10.4f}"))
+    try:
+        import numba
+
+        numba_version = numba.__version__
+    except ImportError:
+        numba_version = "not installed"
+    print(
+        f"\ncpm {cpm.__version__} ({pathlib.Path(cpm.__file__).parent}), numpy {np.__version__}, "
+        f"numba {numba_version}, Python {platform.python_version()}, {platform.system()}"
+    )
+
+
+if __name__ == "__main__":
+    main()
diff --git a/cpm/__version__.py b/cpm/__version__.py
index 556378b..38fe9be 100644
--- a/cpm/__version__.py
+++ b/cpm/__version__.py
@@ -1 +1 @@
-__version__ = "0.25.7.dev0"
+__version__ = "0.26.0.dev0"
diff --git a/cpm/applications/_backend.py b/cpm/applications/_backend.py
new file mode 100644
index 0000000..578b725
--- /dev/null
+++ b/cpm/applications/_backend.py
@@ -0,0 +1,154 @@
+"""
+Shared machinery of the built-in applications.
+
+Each application computes all trials of a participant in one call of a loop in
+`cpm.applications._sessions`, compiled with numba if numba is installed and
+plain Python otherwise. The `Application` base class keeps the interface of a
+per-trial `cpm.generators.Wrapper` on top of that:
+
+- `model` is a per-trial model function, `model(parameters, trial)`, which
+  returns the outputs of one trial as a dictionary. It runs the same loop on that
+  single trial, so there is only one implementation of each model.
+- `simulation` is the list of these per-trial dictionaries for the last run,
+  built from the outputs of the run when it is first read.
+"""
+
+import copy
+
+import numpy as np
+import pandas as pd
+
+from ..core import _jit
+from ..generators.session import SessionWrapper, session_data, trial_view
+
+__all__ = ["Application", "SessionModel", "TrialModel", "indices", "require", "uniforms"]
+
+
+class SessionModel:
+    """
+    A model function for `SessionWrapper` that runs a loop of `cpm.applications._sessions`.
+
+    Subclasses implement `__call__(parameters, data)`. The loops are looked up
+    by backend when needed, rather than stored, so that the model function pickles
+    by reference and can be sent to other processes for parallel fits.
+
+    Parameters
+    ----------
+    generate : bool
+        Whether the model samples its choices.
+
+    Attributes
+    ----------
+    backend : str
+        "numba" if numba is installed and not disabled, "python" otherwise.
+    """
+
+    def __init__(self, generate=False):
+        self.generate = generate
+        self.backend = _jit.resolve_backend("auto")
+
+    @property
+    def sessions(self):
+        return _jit.kernels("cpm.applications._sessions", python=self.backend == "python")
+
+
+def one_trial(trial):
+    """The data of a single trial (a `pandas.Series` or a dict) as one-row data."""
+    items = trial.items() if isinstance(trial, (pd.Series, dict)) else dict(trial).items()
+    return {key: np.asarray([value]) for key, value in items}
+
+
+class TrialModel:
+    """
+    The per-trial model function of an application: its session model, run on one trial.
+
+    Called as `model(parameters, trial)`, like the model function of a per-trial
+    `Wrapper`, it computes one trial from the states in `parameters` and returns
+    that trial's outputs, including the updated states.
+    """
+
+    def __init__(self, session_model, prepare, shapes):
+        self.session_model = session_model
+        self.prepare = prepare
+        self.shapes = shapes
+
+    def __call__(self, parameters, trial, generate=None):
+        model, prepare = self.session_model, self.prepare
+        if generate is not None and generate != model.generate:
+            model = copy.copy(model)
+            model.generate = generate
+            if hasattr(prepare, "generate"):
+                prepare = copy.copy(prepare)
+                prepare.generate = generate
+        output = model(parameters=parameters, data=prepare(one_trial(trial)))
+        return trial_view(output, 0, self.shapes)
+
+
+class Application(SessionWrapper):
+    """
+    The base class of the built-in applications, see the module docstring.
+
+    Subclasses call `_setup` from their constructor, and set `_trial_shapes` for
+    outputs whose per-trial value is not simply a row of the session output.
+    """
+
+    def _setup(self, data, parameters, session_model, prepare):
+        super().__init__(model=session_model, data=data, parameters=parameters, prepare=prepare)
+        self._session_model = session_model
+        self.model = TrialModel(session_model, prepare, self._trial_shapes)
+
+    def _run_session(self):
+        return self._session_model(parameters=self.parameters, data=self.session)
+
+
+def require(data, columns, model):
+    """Raise a helpful error if the prepared data lack any of `columns`."""
+    missing = [column for column in columns if column not in data]
+    if missing:
+        raise KeyError(
+            f"{model} needs the column(s) {missing} in the data, which has "
+            f"{sorted(data)}."
+        )
+
+
+def uniforms(trials, needed):
+    """One uniform random number per trial from `numpy.random` if `needed`, else an empty array."""
+    if needed:
+        return np.random.random_sample(trials)
+    return np.empty(0)
+
+
+def indices(values):
+    """
+    `values` as int64 indices.
+
+    Casting NaN or infinity to an integer gives a different number on different
+    platforms (0 on ARM), so they become an index out of any range instead, which
+    the loops of `cpm.applications._sessions` reject where they use it.
+    """
+    values = np.asarray(values)
+    if values.dtype.kind == "f":
+        values = np.where(np.isfinite(values), values, np.iinfo(np.int32).min)
+    return np.ascontiguousarray(values, dtype=np.int64)
+
+
+def prepared(data):
+    """`session_data`, with integer and boolean columns as int64 and all others as float64 where possible."""
+    out = {}
+    for key, value in session_data(data).items():
+        if value.dtype.kind in "iub":
+            out[key] = np.ascontiguousarray(value, dtype=np.int64)
+        elif value.dtype.kind == "f":
+            out[key] = np.ascontiguousarray(value, dtype=np.float64)
+        else:
+            out[key] = value
+    return out
+
+
+def ordered_columns(data, pattern):
+    """The columns of `data` whose name contains `pattern`, in the order of the data."""
+    if isinstance(data, pd.DataFrame):
+        names = list(data.columns)
+    else:
+        names = [k for k in data if k != "ppt"]
+    return [name for name in names if pattern in name]
diff --git a/cpm/applications/_sessions.py b/cpm/applications/_sessions.py
new file mode 100644
index 0000000..e9491db
--- /dev/null
+++ b/cpm/applications/_sessions.py
@@ -0,0 +1,311 @@
+"""
+The models of the built-in applications.
+
+Each function computes all trials of one participant for one of the
+applications (`RLRW`, `HybridMBMF`, `PTSM`, `PTSM1992` and `PTSM2025`), from
+plain floats and numpy arrays, using the kernels of `cpm.models.kernels`. They
+are the only implementation of these models: the per-trial `model` function of
+an application runs the same loop on a single trial. With numba installed, they
+are compiled as a whole; `cpm.core._jit.kernels` loads this module either
+compiled or as plain Python.
+
+Random choices are made from uniform random numbers drawn with NumPy before
+the loop, one per trial, which `kernels.choose` turns into the choice that
+`numpy.random.choice` would have made. Simulations are therefore reproducible
+with `numpy.random.seed`, identical across backends, and identical to the
+former per-trial implementations of the applications.
+"""
+
+import numpy as np
+
+from ..core import _jit
+
+njit = _jit.decorator(globals())
+kernels = _jit.kernels("cpm.models.kernels", python=globals().get(_jit.PYTHON_FLAG, False))
+
+softmax = kernels.softmax
+choose = kernels.choose
+sarsa_trace_update = kernels.sarsa_trace_update
+separable_rule = kernels.separable_rule
+prospect_utility = kernels.prospect_utility
+prospect_weight = kernels.prospect_weight
+expected_utility = kernels.expected_utility
+
+
+@njit
+def check_activations(activations):
+    """Raise ValueError for NaN or infinite activations, as `cpm.models.decision.Softmax` does."""
+    if np.isfinite(activations).all():  # one call on every trial, the cheap one in plain Python
+        return
+    if np.isnan(activations).any():
+        raise ValueError("Activations contain NaN values. Please remove or impute missing values.")
+    if np.isinf(activations).any():
+        raise ValueError(
+            "Activations contain infinite values. Please remove or impute infinite values."
+        )
+
+
+@njit
+def rlrw(alpha, temperature, initial_values, arms, rewards, response, generate, uniforms):
+    """
+    All trials of `RLRW`.
+
+    Parameters
+    ----------
+    alpha, temperature : float
+    initial_values : numpy.ndarray
+        The initial value of each stimulus, shape (stimuli,).
+    arms : numpy.ndarray
+        The stimulus on each arm (1-based, as in the data), shape (trials, arms).
+    rewards : numpy.ndarray
+        The reward of each arm, shape (trials, arms).
+    response : numpy.ndarray
+        The chosen arm on each trial (0-based); ignored if `generate`.
+    generate : bool
+        Whether to choose from the policy instead.
+    uniforms : numpy.ndarray
+        One uniform random number per trial if `generate`.
+
+    Returns
+    -------
+    policy, reward, values, change, dependent : numpy.ndarray
+    """
+    n, k = arms.shape
+    d = initial_values.shape[0]
+    ## numba does not check indices, so the data are checked here, as the
+    ## per-trial models did by raising IndexError
+    if k < 2:
+        raise ValueError("RLRW needs at least two arms.")
+    values = initial_values.copy()
+    policy = np.empty((n, k))
+    reward = np.empty(n)
+    history = np.empty((n, d))
+    change = np.empty((n, d))
+    activations = np.empty(k)
+    mute = np.zeros(d)
+    feedback = np.empty(1)
+    for t in range(n):
+        for j in range(k):
+            if not -d <= arms[t, j] - 1 < d:
+                raise IndexError("RLRW: the arm columns must hold stimuli from 1 to dimensions.")
+            activations[j] = values[arms[t, j] - 1]
+        check_activations(activations)
+        policy[t] = softmax(activations, temperature)
+        choice = choose(policy[t], uniforms[t]) if generate else response[t]
+        if not -k <= choice < k:
+            raise IndexError("RLRW: response must be an arm, from 0 to the number of arms - 1.")
+        stimulus = arms[t, choice] - 1
+        if stimulus < 0:
+            stimulus += d
+        teacher = rewards[t, choice]
+        reward[t] = teacher
+        ## the update of SeparableRule, for the chosen stimulus only
+        mute[:] = 0.0
+        mute[stimulus] = 1.0
+        feedback[0] = teacher
+        update, _ = separable_rule(values.reshape(1, d), feedback, mute, alpha)
+        change[t] = update[0]
+        values += update[0]
+        history[t] = values
+    return policy, reward, history, change, policy[:, 1].copy()
+
+
+@njit
+def hybrid_mbmf(inv_temperature, learning_rate, eligibility_trace, mb_weight,
+                choice_stickiness, response_stickiness, q_mf_0, q2_0, m_0, r_0,
+                s1, stimuli_first, action, s2, reward, position, reward_0, reward_1,
+                generate, uniforms):
+    """
+    All trials of `HybridMBMF`.
+
+    The data arrays are one value per trial. `action`, `s2`, `reward` and
+    `position` are ignored if `generate`, and `reward_0` and `reward_1` are
+    used only then. Returns the outputs of `HybridMBMF`, one row per trial.
+    """
+    n = s1.shape[0]
+    q_mf = q_mf_0.copy()
+    q2 = q2_0.copy()
+    m = m_0.copy()
+    r = r_0.copy()
+    out_policy = np.empty((n, 2))
+    out_action = np.empty(n, dtype=np.int64)
+    out_s2 = np.empty(n, dtype=np.int64)
+    out_reward = np.empty(n)
+    out_position = np.empty(n, dtype=np.int64)
+    out_pe1 = np.empty(n)
+    out_pe2 = np.empty(n)
+    out_q_mf = np.empty((n, 2, 2))
+    out_q2 = np.empty((n, 2))
+    out_m = np.empty((n, 2, 2))
+    out_r = np.empty((n, 2))
+    q_hybrid = np.empty(2)
+    for t in range(n):
+        state = s1[t]
+        ## numba does not check indices, see rlrw
+        if not -2 <= state < 2:
+            raise IndexError("HybridMBMF: s1, stimuli_first, action, s2 and position must be 0 or 1.")
+        first = stimuli_first[t]
+        ## the model-based value of action 0 is that of state 1, and vice versa
+        for i in range(2):
+            r_action = r[1 - i] if first == 1 else r[i]
+            q_hybrid[i] = (
+                mb_weight * q2[1 - i]
+                + (1 - mb_weight) * q_mf[state, i]
+                + choice_stickiness * m[state, i]
+                + response_stickiness * r_action
+            )
+        check_activations(q_hybrid)
+        policy = softmax(q_hybrid, inv_temperature)
+        if generate:
+            chosen = choose(policy, uniforms[t])
+            reached = 1 - chosen
+            payout = reward_1[t] if reached == 1 else reward_0[t]
+            side = first ^ chosen
+        else:
+            chosen = action[t]
+            reached = s2[t]
+            payout = reward[t]
+            side = position[t]
+        if not (-2 <= chosen < 2 and -2 <= reached < 2 and -2 <= side < 2):
+            raise IndexError("HybridMBMF: s1, stimuli_first, action, s2 and position must be 0 or 1.")
+        m[:, :] = 0.0
+        m[state, chosen] = 1.0
+        r[:] = 0.0
+        r[side] = 1.0
+        pe1, pe2 = sarsa_trace_update(q_mf, q2, state, chosen, reached, payout,
+                                      learning_rate, eligibility_trace)
+        out_policy[t] = policy
+        out_action[t] = chosen
+        out_s2[t] = reached
+        out_reward[t] = payout
+        out_position[t] = side
+        out_pe1[t] = pe1
+        out_pe2[t] = pe2
+        out_q_mf[t] = q_mf
+        out_q2[t] = q2
+        out_m[t] = m
+        out_r[t] = r
+    return (out_policy, out_action, out_s2, out_reward, out_position, out_pe1, out_pe2,
+            out_q_mf, out_q2, out_m, out_r)
+
+
+@njit
+def prospect_softmax(alpha, beta, lambda_loss, gamma, delta, temperature, safe, risky,
+                     probability, observed, weighting, utilities, custom_utilities,
+                     choose_always, generate, uniforms, dependent_chosen):
+    """
+    All trials of `PTSM` and `PTSM1992`: prospect-theory utilities and a softmax.
+
+    Parameters
+    ----------
+    alpha, beta, lambda_loss, gamma, delta, temperature : float
+    safe, risky, probability, observed : numpy.ndarray
+        One value per trial.
+    weighting : int
+        The weighting function, see `kernels.WEIGHTING`.
+    utilities : numpy.ndarray
+        The utilities of the safe and risky magnitude on each trial, shape
+        (trials, 2), if `custom_utilities` (computed by a user-supplied
+        utility curve); otherwise ignored.
+    choose_always : bool
+        Whether a choice is sampled on every trial (as `PTSM1992` does), or only
+        if `generate` (as `PTSM` does).
+    dependent_chosen : bool
+        Whether the dependent variable is the probability of the observed choice
+        (`PTSM`) rather than of the risky option (`PTSM1992`).
+
+    Returns
+    -------
+    policy, dependent, chosen, is_optimal, objective_best, ev_safe, ev_risk, u_safe, u_risk
+    """
+    n = safe.shape[0]
+    out_policy = np.empty((n, 2))
+    out_dependent = np.empty(n)
+    out_chosen = np.empty(n, dtype=np.int64)
+    out_optimal = np.empty(n, dtype=np.int64)
+    out_best = np.empty(n, dtype=np.int64)
+    out_ev_risk = np.empty(n)
+    out_u_safe = np.empty(n)
+    out_u_risk = np.empty(n)
+    ## the expected utilities of the two options (safe, risky) on all trials at
+    ## once, as ProspectUtility computes them for options with one outcome each;
+    ## they do not depend on earlier trials. The safe option pays with probability 1.
+    magnitudes = np.empty((n, 2))
+    magnitudes[:, 0] = safe
+    magnitudes[:, 1] = risky
+    probabilities = np.ones((n, 2))
+    probabilities[:, 1] = probability
+    weights = prospect_weight(probabilities, magnitudes, gamma, delta, weighting)
+    if custom_utilities:
+        outcome_utilities = utilities
+    else:
+        outcome_utilities = prospect_utility(magnitudes, alpha, beta, lambda_loss)
+    expected_all = expected_utility(
+        weights.reshape(2 * n, 1), outcome_utilities.reshape(2 * n, 1)
+    ).reshape(n, 2)
+    for t in range(n):
+        ev_risk = risky[t] * probability[t]
+        best = 1 if ev_risk >= safe[t] else 0
+        expected = expected_all[t]
+        check_activations(expected)
+        policy = softmax(expected, temperature)
+        ## numba does not check indices, see rlrw
+        if (dependent_chosen or not (choose_always or generate)) and not -2 <= observed[t] < 2:
+            raise IndexError("observed must be 0 (safe) or 1 (risky).")
+        if choose_always or generate:
+            chosen = choose(policy, uniforms[t])
+        else:
+            chosen = observed[t]
+        out_policy[t] = policy
+        out_dependent[t] = policy[observed[t]] if dependent_chosen else policy[1]
+        out_chosen[t] = chosen
+        out_optimal[t] = 1 if chosen == best else 0
+        out_best[t] = best
+        out_ev_risk[t] = ev_risk
+        out_u_safe[t] = expected[0]
+        out_u_risk[t] = expected[1]
+    return (out_policy, out_dependent, out_chosen, out_optimal, out_best, out_ev_risk,
+            out_u_safe, out_u_risk)
+
+
+@njit
+def power_utility(x, alpha):
+    """The piecewise power utility of `PTSM2025`, which its parameters also hold as `utility_curvature`."""
+    return x ** alpha if x >= 0 else -np.abs(x) ** alpha
+
+
+@njit
+def ptsm2025(eta, phi_gain, phi_loss, temperature, alpha, safe, risky, probability,
+             ambiguity, uniforms):
+    """
+    All trials of `PTSM2025`.
+
+    Returns
+    -------
+    policy, model_choice, u_safe, u_risk : numpy.ndarray
+    """
+    n = safe.shape[0]
+    out_policy = np.empty(n)
+    out_choice = np.empty(n, dtype=np.int64)
+    out_u_safe = np.empty(n)
+    out_u_risk = np.empty(n)
+    pair = np.empty(2)
+    terms = np.empty(2)
+    for t in range(n):
+        subjective = probability[t] - eta * ambiguity[t]
+        subjective = min(max(subjective, 0.0), 1.0)
+        u_safe = power_utility(safe[t], alpha)
+        u_risk = subjective * power_utility(risky[t], alpha)
+        phi = phi_gain if risky[t] >= 0 else phi_loss
+        ## the policy of PTSM2025: a softmax of the scaled utilities, with the
+        ## gambling bias added to the risky one
+        terms[0] = temperature * u_safe
+        terms[1] = temperature * u_risk + phi
+        p = softmax(terms, 1.0)[1]
+        pair[0] = 1 - p
+        pair[1] = p
+        out_policy[t] = p
+        out_choice[t] = choose(pair, uniforms[t])
+        out_u_safe[t] = u_safe
+        out_u_risk[t] = u_risk
+    return out_policy, out_choice, out_u_safe, out_u_risk
diff --git a/cpm/applications/decision_making.py b/cpm/applications/decision_making.py
index 9667287..4b2fb8f 100644
--- a/cpm/applications/decision_making.py
+++ b/cpm/applications/decision_making.py
@@ -1,12 +1,326 @@
-import copy
 import numpy as np
 import warnings
-from cpm.generators import Wrapper, Parameters, Value
-from cpm.models.decision import Softmax
-from cpm.models.activation import ProspectUtility
+from cpm.generators import Parameters, Value
+from cpm.core import _jit
+from cpm.applications._backend import Application, SessionModel, indices, prepared, require, uniforms
+
+
+def _ptsm_parameters(parameters_settings, utility_curve, weighting):
+    """The parameters of `PTSM`."""
+    # Use default parameter settings if none provided.
+    if parameters_settings is None:
+        parameters_settings = {
+            "alpha":        [1.0, 1e-2, 5.0],    # alpha: starting value 1.0
+            "lambda_loss":  [1.0, 1e-2, 5.0],    # lambda_loss: starting value 1.0
+            "gamma":        [0.5, 1e-2, 5.0],    # gamma: starting value 0.5
+            "temperature":  [5.0, 1e-2, 15.0]    # temperature: starting value 5.0
+        }
+        warnings.warn("No parameters specified, using default settings.", stacklevel=3)
+
+    if callable(utility_curve):
+        warnings.warn("Utility curve provided, using it instead of power function.", stacklevel=3)
+    if utility_curve is not None and not callable(utility_curve):
+        raise ValueError("Utility curve must be a callable function.")
+
+    # Create the unified Parameters object with priors.
+    params = Parameters(
+        alpha=Value(
+            value=parameters_settings["alpha"][0],
+            lower=parameters_settings["alpha"][1],
+            upper=parameters_settings["alpha"][2],
+            prior="truncated_normal",
+            args={
+                "mean": 1.0, "sd": 1.0
+            }
+        ),
+        lambda_loss=Value(
+            value=parameters_settings["lambda_loss"][0],
+            lower=parameters_settings["lambda_loss"][1],
+            upper=parameters_settings["lambda_loss"][2],
+            prior="truncated_normal",
+            args={"mean": 2.5, "sd": 1.0},
+        ),
+        gamma=Value(
+            value=parameters_settings["gamma"][0],
+            lower=parameters_settings["gamma"][1],
+            upper=parameters_settings["gamma"][2],
+            prior="truncated_normal",
+            args={"mean": 2.5, "sd": 1.0},
+        ),
+        temperature=Value(
+            value=parameters_settings["temperature"][0],
+            lower=parameters_settings["temperature"][1],
+            upper=parameters_settings["temperature"][2],
+            prior="truncated_normal",
+            args={
+                "mean": 10.0, "sd": 5
+            }
+        ),
+        utility_curve=utility_curve,  # Use the piecewise utility transform
+        weighting = weighting  # Store the chosen weighting function type
+    )
+    return params
+
+
+def _ptsm1992_parameters(parameters_settings, utility_curve, weighting):
+    """The parameters of `PTSM1992`."""
+    # Use default parameter settings if none provided.
+    if parameters_settings is None:
+        parameters_settings = {
+            "alpha":         [1.0, 0.0, 5.0],   # alpha: starting value 1.0
+            "lambda_loss":   [1.0, 0.0, 5.0],   # lambda_loss: starting value 1.0
+            "beta":          [1.0, 0.0, 5.0],   # beta: starting value 1.0
+            "gamma":         [0.5, 1e-2, 5.0],   # gamma: starting value 0.5
+            "delta":         [0.5, 1e-2, 5.0],   # delta: starting value 0.0
+            "temperature":   [5.0, 1e-2, 15.0]   # temperature: starting value 5.0
+        }
+        warnings.warn("No parameters specified, using default settings.", stacklevel=3)
+
+    if callable(utility_curve):
+        warnings.warn("Utility curve provided, using it instead of power function.", stacklevel=3)
+    if utility_curve is not None and not callable(utility_curve):
+        raise ValueError("Utility curve must be a callable function.")
+
+
+    # Create the unified Parameters object with priors.
+    params = Parameters(
+        alpha = Value(
+            value=parameters_settings["alpha"][0],
+            lower=parameters_settings["alpha"][1],
+            upper=parameters_settings["alpha"][2],
+            prior="truncated_normal",
+            args={
+                "mean": 2.5, "sd": 1.0
+            }
+        ),
+        lambda_loss=Value(
+            value=parameters_settings["lambda_loss"][0],
+            lower=parameters_settings["lambda_loss"][1],
+            upper=parameters_settings["lambda_loss"][2],
+            prior="truncated_normal",
+            args={"mean": 2.5, "sd": 1.0},
+        ),
+        beta=Value(
+            value=parameters_settings["beta"][0],
+            lower=parameters_settings["beta"][1],
+            upper=parameters_settings["beta"][2],
+            prior="truncated_normal",
+            args={"mean": 2.5, "sd": 1.0},
+        ),
+        gamma=Value(
+            value=parameters_settings["gamma"][0],
+            lower=parameters_settings["gamma"][1],
+            upper=parameters_settings["gamma"][2],
+            prior="truncated_normal",
+            args={"mean": 2.5, "sd": 1.0},
+        ),
+        delta=Value(
+            value=parameters_settings["delta"][0],
+            lower=parameters_settings["delta"][1],
+            upper=parameters_settings["delta"][2],
+            prior="truncated_normal",
+            args={"mean": 2.5, "sd": 1.0},
+        ),
+        temperature=Value(
+            value=parameters_settings["temperature"][0],
+            lower=parameters_settings["temperature"][1],
+            upper=parameters_settings["temperature"][2],
+            prior="truncated_normal",
+            args={"mean": 10, "sd": 2.5},
+        ),
+        utility_curve=utility_curve,  # Use the piecewise utility transform
+        weighting = weighting  # Store the chosen weighting function type
+    )
+    return params
+
+
+def _ptsm2025_transform(x, alpha):
+    ## Piecewise utility transform, as the model computes it
+    return _jit.kernels("cpm.applications._sessions", python=True).power_utility(x, alpha)
+
+
+def _ptsm2025_parameters(parameters_settings, utility_curve, variant):
+    """The parameters of `PTSM2025`."""
+    if parameters_settings is None:
+        warnings.warn("No parameters specified, using JAGS-inspired defaults.", stacklevel=3)
+        parameters_settings = {
+            "eta":         [0.0,   -0.49,  0.49],
+            "phi_gain":    [0.0,   -10.0,  10.0],
+            "phi_loss":    [0.0,   -10.0,  10.0],
+            "temperature": [5.0,    0.001, 20.0],
+            "alpha":       [1.0,    0.001,  5.0],
+        }
+
+    if callable(utility_curve):
+        warnings.warn("Utility curve provided, using it instead of power function.", stacklevel=3)
+    if utility_curve is not None and not callable(utility_curve):
+        raise ValueError("Utility curve must be a callable function.")
+
+    parameters = Parameters(
+        eta=Value(
+            value=parameters_settings["eta"][0],
+            lower=parameters_settings["eta"][1],
+            upper=parameters_settings["eta"][2],
+            prior="truncated_normal",
+            args={"mean": 0.0, "sd": 0.25}
+        ),
+        phi_gain=Value(
+            value=parameters_settings["phi_gain"][0],
+            lower=parameters_settings["phi_gain"][1],
+            upper=parameters_settings["phi_gain"][2],
+            prior="truncated_normal",
+            args={"mean": 0.0, "sd": 2.5}
+        ),
+        phi_loss=Value(
+            value=parameters_settings["phi_loss"][0],
+            lower=parameters_settings["phi_loss"][1],
+            upper=parameters_settings["phi_loss"][2],
+            prior="truncated_normal",
+            args={"mean": 0.0, "sd": 2.5}
+        ),
+        temperature=Value(
+            value=parameters_settings["temperature"][0],
+            lower=parameters_settings["temperature"][1],
+            upper=parameters_settings["temperature"][2],
+            prior="truncated_normal",
+            args={
+                "mean": 10.0, "sd": 5
+            }
+        ),
+        utility_curvature=_ptsm2025_transform,
+    )
+
+    if variant == "alpha":
+        parameters["alpha"] = Value(
+            value=parameters_settings["alpha"][0],
+            lower=parameters_settings["alpha"][1],
+            upper=parameters_settings["alpha"][2],
+            prior="truncated_normal",
+            args={
+                "mean": 1.0, "sd": 1.0
+            }
+        )
+    else:
+        parameters["alpha"] = 1.0
+    return parameters
+
+
+
+def _weighting_code(weighting):
+    """The number of a weighting function in `cpm.models.kernels.WEIGHTING`."""
+    from cpm.models.kernels import WEIGHTING
+
+    if weighting not in WEIGHTING:
+        raise ValueError(
+            "Invalid weighting type. Must be one of: 'tk', 'power', 'prelec', 'gw'."
+        )
+    return WEIGHTING[weighting]
+
+
+class _PrepareRisky:
+    """The data preparation of the prospect-theory session models."""
+
+    def __init__(self, columns, model):
+        self.columns = columns
+        self.model = model
+
+    def __call__(self, data):
+        out = prepared(data)
+        require(out, self.columns + ["observed"], self.model)
+        for key in self.columns:
+            out[key] = np.ascontiguousarray(out[key], dtype=np.float64)
+        out["observed"] = indices(out["observed"])
+        return out
+
+
+RISKY_COLUMNS = ["safe_magnitudes", "risky_magnitudes", "risky_probability"]
+
+
+
+class _ProspectModel(SessionModel):
+    """The model function of `PTSM` and `PTSM1992`, for all trials at once."""
+
+    def __init__(self, weighting, generate, choose_always, dependent_chosen, separate):
+        super().__init__(generate)
+        self.weighting = _weighting_code(weighting)
+        self.choose_always = choose_always
+        self.dependent_chosen = dependent_chosen
+        ## whether losses have their own curvatures (beta, delta), as in PTSM1992
+        self.separate = separate
+
+    def utilities(self, parameters, data, alpha, lambda_loss):
+        """The utilities of a user-supplied utility curve, called as `ProspectUtility` calls it."""
+        curve = parameters.utility_curve if self.separate else None
+        trials = data["observed"].shape[0]
+        if curve is None:
+            return False, np.empty((0, 2))
+        out = np.empty((trials, 2))
+        for t in range(trials):
+            for j, key in enumerate(("safe_magnitudes", "risky_magnitudes")):
+                x = np.array([data[key][t]], dtype=float)
+                out[t, j] = np.sum(curve(x=x, alpha=alpha, lambda_loss=lambda_loss))
+        return True, out
+
+    def __call__(self, parameters, data):
+        alpha = float(parameters.alpha)
+        lambda_loss = float(parameters.lambda_loss)
+        gamma = float(parameters.gamma)
+        if self.separate:
+            beta, delta = float(parameters.beta), float(parameters.delta)
+        else:
+            beta, delta = alpha, 1.0
+        custom, utilities = self.utilities(parameters, data, alpha, lambda_loss)
+        observed = data["observed"]
+        trials = observed.shape[0]
+        out = self.sessions.prospect_softmax(
+            alpha, beta, lambda_loss, gamma, delta, float(parameters.temperature),
+            data["safe_magnitudes"], data["risky_magnitudes"], data["risky_probability"],
+            observed, self.weighting, utilities, custom, self.choose_always, self.generate,
+            uniforms(trials, self.choose_always or self.generate), self.dependent_chosen,
+        )
+        policy, dependent, chosen, optimal, best, ev_risk, u_safe, u_risk = out
+        return {
+            "policy": policy,
+            "dependent": dependent,
+            "observed": observed,
+            "chosen": chosen,
+            "is_optimal": optimal,
+            "objective_best": best,
+            "ev_safe": data["safe_magnitudes"],
+            "ev_risk": ev_risk,
+            "u_safe": u_safe,
+            "u_risk": u_risk,
+        }
+
+
+class _PTSM2025Model(SessionModel):
+    """The model function of `PTSM2025`, for all trials at once."""
+
+    def __call__(self, parameters, data):
+        observed = data["observed"]
+        policy, choice, u_safe, u_risk = self.sessions.ptsm2025(
+            float(parameters.eta),
+            float(parameters.phi_gain),
+            float(parameters.phi_loss),
+            float(parameters.temperature),
+            float(parameters.alpha),
+            data["safe_magnitudes"],
+            data["risky_magnitudes"],
+            data["risky_probability"],
+            data["ambiguity"],
+            uniforms(observed.shape[0], True),
+        )
+        return {
+            "policy": policy,
+            "model_choice": choice,
+            "real_choice": observed,
+            "u_safe": u_safe,
+            "u_risk": u_risk,
+            "dependent": policy,
+        }
 
 
-class PTSM(Wrapper):
+class PTSM(Application):
     r"""
     A simplified version of the Prospect Theory-based Softmax Model (PTSM) for decision-making tasks based on Tversky & Kahneman (1992), similar to the initial publication of the theory in Kahneman & Tversky (1979). It differs from :class:`cpm.applications.decision_making.PTSM2025` and :class:`cpm.applications.decision_making.PTSM1992` in that it does not use use different utility and weight curvature parameters for gains and losses.
     
@@ -104,6 +418,10 @@ class PTSM(Wrapper):
 
     If you get **overflow warnings** during fitting, consider lowering the upper bound of the temperature parameter. Another possible reason for these **overflow warnings** is that the computed utilities are very large in magnitude. Ensure that the magnitudes in your dataset are within a reasonable range (e.g., between 0 and 1, or -1 and 1). Another option is to z-score the utilities before passing them to the softmax function, which can help stabilize the exponentials. 
 
+    .. rubric:: Computation
+
+    The model computes all trials of a participant in one call, compiled with numba if numba is installed (``pip install cpm-toolbox[numba]``) and as plain Python otherwise, with the same results. `model` is the model function for a single trial, ``model(parameters, trial)``, which returns the outputs of that trial.
+
     See Also
     --------
     cpm.models.decision.Softmax : for mapping utilities to choice probabilities.
@@ -127,123 +445,17 @@ def __init__(
         utility_curve=None,  # Callable function for utility transformation
         weighting="tk"  # Options: "tk" or "power"
     ):
-        # Use default parameter settings if none provided.
-        if parameters_settings is None:
-            parameters_settings = {
-                "alpha":        [1.0, 1e-2, 5.0],    # alpha: starting value 1.0
-                "lambda_loss":  [1.0, 1e-2, 5.0],    # lambda_loss: starting value 1.0
-                "gamma":        [0.5, 1e-2, 5.0],    # gamma: starting value 0.5
-                "temperature":  [5.0, 1e-2, 15.0]    # temperature: starting value 5.0
-            }
-            warnings.warn("No parameters specified, using default settings.")
-
-        if callable(utility_curve):
-            warnings.warn("Utility curve provided, using it instead of power function.")
-        if utility_curve is not None and not callable(utility_curve):
-            raise ValueError("Utility curve must be a callable function.")
-
-        # Create the unified Parameters object with priors.
-        params = Parameters(
-            alpha=Value(
-                value=parameters_settings["alpha"][0],
-                lower=parameters_settings["alpha"][1],
-                upper=parameters_settings["alpha"][2],
-                prior="truncated_normal",
-                args={
-                    "mean": 1.0, "sd": 1.0
-                }
-            ),
-            lambda_loss=Value(
-                value=parameters_settings["lambda_loss"][0],
-                lower=parameters_settings["lambda_loss"][1],
-                upper=parameters_settings["lambda_loss"][2],
-                prior="truncated_normal",
-                args={"mean": 2.5, "sd": 1.0},
-            ),
-            gamma=Value(
-                value=parameters_settings["gamma"][0],
-                lower=parameters_settings["gamma"][1],
-                upper=parameters_settings["gamma"][2],
-                prior="truncated_normal",
-                args={"mean": 2.5, "sd": 1.0},
-            ),
-            temperature=Value(
-                value=parameters_settings["temperature"][0],
-                lower=parameters_settings["temperature"][1],
-                upper=parameters_settings["temperature"][2],
-                prior="truncated_normal",
-                args={
-                    "mean": 10.0, "sd": 5
-                }
-            ),
-            utility_curve=utility_curve,  # Use the piecewise utility transform
-            weighting = weighting  # Store the chosen weighting function type
+        params = _ptsm_parameters(parameters_settings, utility_curve, weighting)
+        self._setup(
+            data=data,
+            parameters=params,
+            session_model=_ProspectModel(weighting, generate, choose_always=False,
+                                         dependent_chosen=True, separate=False),
+            prepare=_PrepareRisky(RISKY_COLUMNS, "PTSM"),
         )
 
-        def model_fn(parameters, trial):
-            """
-            Called per trial. Computes the subjective utility for two options based on prospect theory,
-            using an external weighting function from the ProspectUtility class.
-            """
-            # Extract parameter values
-            alpha = copy.deepcopy(parameters.alpha.value)
-            lambd = copy.deepcopy(parameters.lambda_loss.value)
-            gamma = copy.deepcopy(parameters.gamma.value)  
-            temp  = copy.deepcopy(parameters.temperature.value)
-
-            # Read trial data 
-            safe_magn  = trial["safe_magnitudes"]
-            risky_magn = trial["risky_magnitudes"]
-            risky_prob = trial["risky_probability"]
-            observed = trial["observed"].astype(int)
-
-            # Compute objective expected values (EV)
-            ev_safe = safe_magn
-            ev_risk = risky_magn * risky_prob
-
-            # Determine which option is objectively better
-            objective_best = 1 if ev_risk >= ev_safe else 0
-
-            pt_util = ProspectUtility(
-                magnitudes=np.array([safe_magn, risky_magn]),
-                probabilities=np.array([1.0, risky_prob]),
-                alpha=alpha,
-                lambda_loss=lambd,
-                gamma=gamma,
-                weighting=parameters.weighting
-            )
-            subjective_utilities = pt_util.compute()
-
-
-            # Compute softmax probabilities using the specified temperature
-            sm = Softmax(temperature=temp, activations=subjective_utilities)
-            policies = sm.compute()
-            prob_chosen = policies[observed]
-
-            # Determine choice: generate a response if required, else use the observed one
-            chosen = sm.choice() if generate else observed
-            # Determine if the chosen option is optimal
-            is_optimal = 1 if chosen == objective_best else 0
-
-
-            return {
-                "policy": policies,
-                "dependent": np.array([prob_chosen]),
-                "observed": observed,  # Ensure the optimizer sees the 'observed' column
-                "chosen": chosen,
-                "is_optimal": is_optimal,
-                "objective_best": objective_best,
-                "ev_safe": ev_safe,
-                "ev_risk": ev_risk,
-                "u_safe": subjective_utilities[0],
-                "u_risk": subjective_utilities[1],
-            }
 
-        # Pass the model function and parameters to the parent Wrapper
-        super().__init__(data=data, model=model_fn, parameters=params)
-
-
-class PTSM1992(Wrapper):
+class PTSM1992(Application):
     r"""
     A Prospect Theory-based Softmax Model (PTSM) for decision-making tasks based on Tversky & Kahneman (1992), similar to the initial publication of the theory in Kahneman & Tversky (1979). It computes expected utility by combining transformed magnitudes and weighted probabilities, suitable for safe–risky decision paradigms.
 
@@ -356,6 +568,10 @@ class PTSM1992(Wrapper):
     If you get **overflow warnings** during fitting, consider lowering the upper bound of the temperature parameter. Another possible reason for these **overflow warnings** is that the computed utilities are very large in magnitude. Ensure that the magnitudes in your dataset are within a reasonable range (e.g., between 0 and 1, or -1 and 1). Another option is to z-score the utilities before passing them to the softmax function, which can help stabilize the exponentials. 
         
 
+    .. rubric:: Computation
+
+    The model computes all trials of a participant in one call, compiled with numba if numba is installed (``pip install cpm-toolbox[numba]``) and as plain Python otherwise, with the same results. `model` is the model function for a single trial, ``model(parameters, trial)``, which returns the outputs of that trial.
+
     See Also
     --------
     cpm.models.decision.Softmax : for mapping utilities to choice probabilities.
@@ -378,141 +594,17 @@ def __init__(
         utility_curve=None,
         weighting="tk"  # Options: "tk" or "power"
     ):
-        # Use default parameter settings if none provided.
-        if parameters_settings is None:
-            parameters_settings = {
-                "alpha":         [1.0, 0.0, 5.0],   # alpha: starting value 1.0
-                "lambda_loss":   [1.0, 0.0, 5.0],   # lambda_loss: starting value 1.0
-                "beta":          [1.0, 0.0, 5.0],   # beta: starting value 1.0
-                "gamma":         [0.5, 1e-2, 5.0],   # gamma: starting value 0.5
-                "delta":         [0.5, 1e-2, 5.0],   # delta: starting value 0.0
-                "temperature":   [5.0, 1e-2, 15.0]   # temperature: starting value 5.0
-            }
-            warnings.warn("No parameters specified, using default settings.")
-
-        if callable(utility_curve):
-            warnings.warn("Utility curve provided, using it instead of power function.")
-        if utility_curve is not None and not callable(utility_curve):
-            raise ValueError("Utility curve must be a callable function.")
-
-
-        # Create the unified Parameters object with priors.
-        params = Parameters(
-            alpha = Value(
-                value=parameters_settings["alpha"][0],
-                lower=parameters_settings["alpha"][1],
-                upper=parameters_settings["alpha"][2],
-                prior="truncated_normal",
-                args={
-                    "mean": 2.5, "sd": 1.0
-                }
-            ),
-            lambda_loss=Value(
-                value=parameters_settings["lambda_loss"][0],
-                lower=parameters_settings["lambda_loss"][1],
-                upper=parameters_settings["lambda_loss"][2],
-                prior="truncated_normal",
-                args={"mean": 2.5, "sd": 1.0},
-            ),
-            beta=Value(
-                value=parameters_settings["beta"][0],
-                lower=parameters_settings["beta"][1],
-                upper=parameters_settings["beta"][2],
-                prior="truncated_normal",
-                args={"mean": 2.5, "sd": 1.0},
-            ),
-            gamma=Value(
-                value=parameters_settings["gamma"][0],
-                lower=parameters_settings["gamma"][1],
-                upper=parameters_settings["gamma"][2],
-                prior="truncated_normal",
-                args={"mean": 2.5, "sd": 1.0},
-            ),
-            delta=Value(
-                value=parameters_settings["delta"][0],
-                lower=parameters_settings["delta"][1],
-                upper=parameters_settings["delta"][2],
-                prior="truncated_normal",
-                args={"mean": 2.5, "sd": 1.0},
-            ),
-            temperature=Value(
-                value=parameters_settings["temperature"][0],
-                lower=parameters_settings["temperature"][1],
-                upper=parameters_settings["temperature"][2],
-                prior="truncated_normal",
-                args={"mean": 10, "sd": 2.5},
-            ),
-            utility_curve=utility_curve,  # Use the piecewise utility transform
-            weighting = weighting  # Store the chosen weighting function type
+        params = _ptsm1992_parameters(parameters_settings, utility_curve, weighting)
+        self._setup(
+            data=data,
+            parameters=params,
+            session_model=_ProspectModel(weighting, generate=False, choose_always=True,
+                                         dependent_chosen=False, separate=True),
+            prepare=_PrepareRisky(RISKY_COLUMNS, "PTSM1992"),
         )
 
-        def model_fn(parameters, trial):
-            """
-            Called per trial. Computes the subjective utility for two options based on prospect theory,
-            using an external weighting function from the ProspectUtility class.
-            """
-            # Extract parameter values
-            alpha = copy.deepcopy(parameters.alpha.value)
-            lambd = copy.deepcopy(parameters.lambda_loss.value)
-            beta = copy.deepcopy(parameters.beta.value)  # This is used for the utility curvature
-            gamma = copy.deepcopy(parameters.gamma.value)  # This is used as the weighting curvature for gains
-            delta = copy.deepcopy(parameters.delta.value)  # This is used for the weighting curvature for losses
-            temperature  = copy.deepcopy(parameters.temperature.value)
-            safe_magnitude = trial["safe_magnitudes"]
-            risky_magnitude = trial["risky_magnitudes"]
-            risky_prob = trial["risky_probability"]
-            observed = trial["observed"].astype(int)
-            # Compute objective expected values (EV)
-            ev_safe = safe_magnitude
-            ev_risk = risky_magnitude * risky_prob
-
-            # Determine which option is objectively better
-            objective_best = 1 if ev_risk >= ev_safe else 0
-
-            # Create a temporary instance; dummy magnitudes are provided (they're not used in weighting)
-            # Now use our unified parameter names: alpha for utility curvature, lambda_loss, and gamma
-            pt_util = ProspectUtility(
-                magnitudes=np.array([[safe_magnitude], [risky_magnitude]]),
-                probabilities=np.array([[1.0], [risky_prob]]),
-                alpha=alpha,
-                beta=beta,
-                lambda_loss=lambd,
-                gamma=gamma,
-                delta=delta,
-                weighting=parameters.weighting,
-                utility_curve=parameters.utility_curve,
-            )
-
-            utilities = pt_util.compute()
-
-            # Compute softmax probabilities using the specified temperature
-            sm = Softmax(temperature=temperature, activations=utilities)
-            policies = sm.compute()
-
-            # Determine choice: generate a response if required, else use the observed one
-            chosen = sm.choice()
-
-            # Determine if the chosen option is optimal
-            is_optimal = 1 if chosen == objective_best else 0
-            prob_chosen = policies[1]
-
-            return {
-                "policy": policies,
-                "dependent": np.array([prob_chosen]),
-                "observed": observed,  # Ensure the optimizer sees the 'observed' column
-                "chosen": chosen,
-                "is_optimal": is_optimal,
-                "objective_best": objective_best,
-                "ev_safe": ev_safe,
-                "ev_risk": ev_risk,
-                "u_safe": utilities[0],
-                "u_risk": utilities[1],
-            }
-
-        # Pass the model function and parameters to the parent Wrapper
-        super().__init__(data=data, model=model_fn, parameters=params)
 
-class PTSM2025(Wrapper):
+class PTSM2025(Application):
     r"""
     An Prospect Theory Softmax Model loosely based on Chew et al. (2019), incorporating a bias term (phi_gain / phi_loss) in the softmax function for risks and gains, a utility curvature parameter (alpha) for non-linear utility transformations, and an ambiguity aversion parameter (eta).
 
@@ -598,10 +690,15 @@ class PTSM2025(Wrapper):
 
     If you get **overflow warnings** during fitting, consider lowering the upper bound of the temperature parameter. Another possible reason for these **overflow warnings** is that the computed utilities are very large in magnitude. Ensure that the magnitudes in your dataset are within a reasonable range (e.g., between 0 and 1, or -1 and 1). Another option is to z-score the utilities before passing them to the softmax function, which can help stabilize the exponentials. 
 
+    .. rubric:: Computation
+
+    The model computes all trials of a participant in one call, compiled with numba if numba is installed (``pip install cpm-toolbox[numba]``) and as plain Python otherwise, with the same results. `model` is the model function for a single trial, ``model(parameters, trial)``, which returns the outputs of that trial.
+
     References
     ----------
     Chew, B., Hauser, T. U., Papoutsi, M., Magerkurth, J., Dolan, R. J., & Rutledge, R. B. (2019). Endogenous fluctuations in the dopaminergic midbrain drive behavioral choice variability. Proceedings of the National Academy of Sciences, 116(37), 18732–18737. https://doi.org/10.1073/pnas.1900872116
     """
+
     def __init__(
         self,
         data=None,
@@ -609,117 +706,11 @@ def __init__(
         utility_curve=None,
         variant="alpha"
     ):
-        if parameters_settings is None:
-            warnings.warn("No parameters specified, using JAGS-inspired defaults.")
-            parameters_settings = {
-                "eta":         [0.0,   -0.49,  0.49],
-                "phi_gain":    [0.0,   -10.0,  10.0],
-                "phi_loss":    [0.0,   -10.0,  10.0],
-                "temperature": [5.0,    0.001, 20.0],
-                "alpha":       [1.0,    0.001,  5.0],
-            }
-
         self.variant = variant
-
-        if callable(utility_curve):
-            warnings.warn("Utility curve provided, using it instead of power function.")
-        if utility_curve is not None and not callable(utility_curve):
-            raise ValueError("Utility curve must be a callable function.")
-
-        def transform(x, alpha):
-            ## Piecewise utility transform
-            return x ** alpha if x >= 0 else -np.abs(x) ** alpha
-
-        parameters = Parameters(
-            eta=Value(
-                value=parameters_settings["eta"][0],
-                lower=parameters_settings["eta"][1],
-                upper=parameters_settings["eta"][2],
-                prior="truncated_normal",
-                args={"mean": 0.0, "sd": 0.25}
-            ),
-            phi_gain=Value(
-                value=parameters_settings["phi_gain"][0],
-                lower=parameters_settings["phi_gain"][1],
-                upper=parameters_settings["phi_gain"][2],
-                prior="truncated_normal",
-                args={"mean": 0.0, "sd": 2.5}
-            ),
-            phi_loss=Value(
-                value=parameters_settings["phi_loss"][0],
-                lower=parameters_settings["phi_loss"][1],
-                upper=parameters_settings["phi_loss"][2],
-                prior="truncated_normal",
-                args={"mean": 0.0, "sd": 2.5}
-            ),
-            temperature=Value(
-                value=parameters_settings["temperature"][0],
-                lower=parameters_settings["temperature"][1],
-                upper=parameters_settings["temperature"][2],
-                prior="truncated_normal",
-                args={
-                    "mean": 10.0, "sd": 5
-                }
-            ),
-            utility_curvature=transform,
+        parameters = _ptsm2025_parameters(parameters_settings, utility_curve, variant)
+        self._setup(
+            data=data,
+            parameters=parameters,
+            session_model=_PTSM2025Model(),
+            prepare=_PrepareRisky(RISKY_COLUMNS + ["ambiguity"], "PTSM2025"),
         )
-
-        if variant == "alpha":
-            parameters["alpha"] = Value(
-                value=parameters_settings["alpha"][0],
-                lower=parameters_settings["alpha"][1],
-                upper=parameters_settings["alpha"][2],
-                prior="truncated_normal",
-                args={
-                    "mean": 1.0, "sd": 1.0
-                }
-            )
-        else:
-            parameters["alpha"] = 1.0
-
-        # CORRECTED: Renamed back to model_fn
-        def model_fn(parameters, trial):
-            eta = copy.deepcopy(parameters.eta)
-            phi_gain = copy.deepcopy(parameters.phi_gain)
-            phi_loss = copy.deepcopy(parameters.phi_loss)
-            temperature = copy.deepcopy(parameters.temperature)
-            alpha = copy.deepcopy(parameters.alpha)
-
-            safe = trial["safe_magnitudes"]
-            risky = trial["risky_magnitudes"]
-            risky_probability= trial["risky_probability"]
-            ambiguity  = trial["ambiguity"]
-            observed = trial["observed"].astype(int)
-
-            # Compute subjective probability with ambiguity aversion
-            subjective_risky_probability = np.clip(risky_probability- eta * ambiguity, 0, 1)
-
-
-            utility_safe_option  = parameters.utility_curvature(safe, alpha)
-            utility_risky_option  = subjective_risky_probability * parameters.utility_curvature(risky, alpha)
-
-            ## Adjust phi_t based on the sign of the magnitude of risky choice
-            if risky >= 0:
-                phi_t = phi_gain
-            else:
-                phi_t = phi_loss
-            
-            ## compute the policies adjusted via loss aversion and gain sensitivity
-            policies = np.exp(temperature * utility_risky_option  + phi_t) / (
-                np.exp(temperature * utility_risky_option  + phi_t) + np.exp(temperature * utility_safe_option)
-            )
-            ## generate a random response between 0 and 1
-            model_choice = np.random.choice([0,1], p=[1-policies, policies])
-            
-            output = {
-                "policy": policies,
-                "model_choice": model_choice,
-                "real_choice": observed,
-                "u_safe": utility_safe_option,
-                "u_risk": utility_risky_option,
-                "dependent": np.array([policies])
-            }
-            
-            return output
-
-        super().__init__(data=data, model=model_fn, parameters=parameters)
\ No newline at end of file
diff --git a/cpm/applications/reinforcement_learning.py b/cpm/applications/reinforcement_learning.py
index a6aad4c..3e67c1e 100644
--- a/cpm/applications/reinforcement_learning.py
+++ b/cpm/applications/reinforcement_learning.py
@@ -1,13 +1,133 @@
-from cpm.generators import Wrapper, Parameters, Value
-
-import cpm
 import numpy
-import pandas
 import warnings
-import ipyparallel as ipp  ## for parallel computing with ipython (specific for Jupyter Notebook)
+
+from cpm.generators import Parameters, Value
+from cpm.applications._backend import (
+    Application, SessionModel, indices, ordered_columns, prepared, require, uniforms,
+)
+
+
+def _rlrw_parameters(parameters_settings, dimensions):
+    """The parameters of `RLRW`."""
+    if parameters_settings is None:
+        parameters_settings = [[0.5, 0, 1], [5, 0, 10]]
+        warnings.warn("No parameters specified, using default parameters.", stacklevel=3)
+    return Parameters(
+        # freely varying parameters are indicated by specifying priors
+        alpha=Value(
+            value=parameters_settings[0][0],
+            lower=parameters_settings[0][1],
+            upper=parameters_settings[0][2],
+            prior="truncated_normal",
+            args={"mean": 0.5, "sd": 0.25},
+        ),
+        temperature=Value(
+            value=parameters_settings[1][0],
+            lower=parameters_settings[1][1],
+            upper=parameters_settings[1][2],
+            prior="truncated_normal",
+            args={"mean": 5, "sd": 2.5},
+        ),
+        values=numpy.ones(dimensions) / dimensions,
+    )
+
+
+def _hybrid_parameters(parameters_settings, q_init):
+    """The parameters of `HybridMBMF`."""
+    if parameters_settings is None:
+        parameters_settings = [
+            [2, 0, 5],
+            [0.5, 0, 1],
+            [0.5, 0, 1],
+            [0.5, 0, 1],
+            [0, -5, 5],
+            [0, -5, 5],
+        ]
+        warnings.warn("No parameters specified, using default parameters.", stacklevel=3)
+    priors = [
+        {"mean": 1.5, "sd": 2.0},
+        {"mean": 0.5, "sd": 0.25},
+        {"mean": 0.5, "sd": 0.25},
+        {"mean": 0.5, "sd": 0.25},
+        {"mean": 0.0, "sd": 1.0},
+        {"mean": 0.0, "sd": 1.0},
+    ]
+    return Parameters(
+        # freely varying parameters are indicated by specifying priors
+        **{
+            name: Value(
+                value=settings[0],
+                lower=settings[1],
+                upper=settings[2],
+                prior="truncated_normal",
+                args=prior,
+            )
+            for name, settings, prior in zip(HYBRID_PARAMETERS, parameters_settings, priors)
+        },
+        # internal states of the model
+        q_mf=numpy.full((2, 2), q_init, dtype=float),
+        q2=numpy.full(2, q_init, dtype=float),
+        m=numpy.zeros((2, 2)),
+        r=numpy.zeros(2),
+    )
+
+
+
+HYBRID_PARAMETERS = [
+    "inv_temperature",
+    "learning_rate",
+    "eligibility_trace",
+    "mb_weight",
+    "choice_stickiness",
+    "response_stickiness",
+]
+
+
+class _RLRWModel(SessionModel):
+    """The model function of `RLRW`, for all trials at once."""
+
+    def __call__(self, parameters, data):
+        policy, reward, values, change, dependent = self.sessions.rlrw(
+            float(parameters.alpha),
+            float(parameters.temperature),
+            numpy.asarray(parameters.values, dtype=float),
+            data["arms"],
+            data["rewards"],
+            data["response"],
+            self.generate,
+            uniforms(data["arms"].shape[0], self.generate),
+        )
+        return {
+            "policy": policy,
+            "reward": reward,
+            "values": values,
+            "change": change,
+            "dependent": dependent,
+        }
+
+
+def _prepare_rlrw(data):
+    """Collect the arm and reward columns of the data into arrays, once."""
+    out = prepared(data)
+    arms = ordered_columns(data, "arm")
+    rewards = ordered_columns(data, "reward")
+    if not arms or not rewards:
+        raise KeyError(
+            "RLRW needs columns with 'arm' and 'reward' in their names, "
+            f"such as arm_left and reward_left, but the data have {sorted(out)}."
+        )
+    trials = len(out[arms[0]])
+    out["arms"] = indices(numpy.column_stack([out[c] for c in arms]))
+    out["rewards"] = numpy.ascontiguousarray(
+        numpy.column_stack([out[c] for c in rewards]), dtype=numpy.float64
+    )
+    response = out.get("response", numpy.zeros(trials))
+    out["response"] = indices(response)
+    return out
 
 
-class RLRW(Wrapper):
+
+class RLRW(Application):
     r"""
     The class implements a simple reinforcement learning model for a multi-armed bandit tasks using a standard update rule calculating prediction error and a Softmax decision rule.
     The model is an n-dimensional and k-armed implementation of model 3 from Wilson and Collins (2019), which largely corresponds to the model presented by Sutton & Barto (2020) in Chapter 14.
@@ -68,6 +188,10 @@ class RLRW(Wrapper):
 
     where :math:`\alpha` is the learning rate, :math:`R` is the reward received for the chosen action, and :math:`Q(a_t)` is the estimated value of the chosen action before updating. The values of unchosen stimuli remain unchanged.
 
+    .. rubric:: Computation
+
+    The model computes all trials of a participant in one call, compiled with numba if numba is installed (``pip install cpm-toolbox[numba]``) and as plain Python otherwise, with the same results. `model` is the model function for a single trial, ``model(parameters, trial)``, which computes one trial from the states in `parameters` and returns its outputs.
+
     References
     ----------
 
@@ -85,102 +209,83 @@ class RLRW(Wrapper):
 
     """
 
+    _trial_shapes = {"change": (1, -1)}
+
     def __init__(
         self, data=None, dimensions=2, parameters_settings=None, generate=False
     ):
-        if parameters_settings is None:
-            parameters_settings = [[0.5, 0, 1], [5, 0, 10]]
-            warnings.warn("No parameters specified, using default parameters.")
-        parameters = Parameters(
-            # freely varying parameters are indicated by specifying priors
-            alpha=Value(
-                value=parameters_settings[0][0],
-                lower=parameters_settings[0][1],
-                upper=parameters_settings[0][2],
-                prior="truncated_normal",
-                args={"mean": 0.5, "sd": 0.25},
-            ),
-            temperature=Value(
-                value=parameters_settings[1][0],
-                lower=parameters_settings[1][1],
-                upper=parameters_settings[1][2],
-                prior="truncated_normal",
-                args={"mean": 5, "sd": 2.5},
-            ),
-            values=numpy.ones(dimensions) / dimensions,
+        parameters = _rlrw_parameters(parameters_settings, dimensions)
+        self._setup(
+            data=data,
+            parameters=parameters,
+            session_model=_RLRWModel(generate),
+            prepare=_prepare_rlrw,
         )
 
-        @ipp.require("numpy")
-        def model(parameters, trial, generate=generate):
-            # pull out the parameters
-            alpha = parameters.alpha
-            temperature = parameters.temperature
-            values = numpy.asarray(parameters.values).copy()
-            ## first we get the bandits and their corresponding stimulus identifier
-            arm_names = [
-                col for col in trial.index if "arm" in col
-            ]  ## get column names beginning with stimulus
-            arms = numpy.array(
-                [trial[i] for i in arm_names],
-                dtype=int,
-            )  ## stimulus identifier for each arm of the bandit
-            k_arms = arms.shape[0]  ## number of arms
-            dims = values.shape[0]  ## number of stimuli
-            choice = trial.response.astype(int)
-            reward_names = [
-                col for col in trial.index if "reward" in col
-            ]  ## get column names beginning with stimulus
-            feedback = numpy.array(
-                [trial[i] for i in reward_names]
-            )  ## compile reward vector
-            ## get the activations for each arm given q-values for each stimulus
-            activations = numpy.array([values[i - 1] for i in arms])
-
-            ## compute softmax
-            response = cpm.models.decision.Softmax(
-                activations=activations, temperature=temperature
-            )
-            response.compute()
-            ## check for NaN in policy
-            if numpy.isnan(response.policies).any():
-                # if the policy is NaN for a given action, then we need to set it to 1 to avoid numerical issues
-                warnings.warn(
-                    f"NaN in policy with parameters: {alpha.value}, {temperature.value}, \nand with policy: {response.policies}\n"
-                )
-                response.policies[numpy.isnan(response.policies)] = 1
-            # if generate is true, generate a response from softmax probabilities
-            if generate:
-                choice = response.choice()
-            ## match choice to stimulus identifier
-            stim_choice = arms[choice] - 1
-            # update the values for that stimulus
-            mute = numpy.zeros(dims)
-            mute[stim_choice] = (
-                1  ## determine which stimulus' q-values we need to update
-            )
-            teacher = feedback[choice]  ## get reward for that bandit
-            update = cpm.models.learning.SeparableRule(
-                weights=values, feedback=[teacher], input=mute, alpha=alpha
-            )
-            update.compute()
 
-            values += update.weights.flatten()
-            ## compile output
-            output = {
-                "policy": response.policies,  # policies
-                "reward": teacher,  # reward of the chosen action
-                "values": values.copy(),  # updated values
-                "change": update.weights,  # change in the values - prediction error
-                "dependent": numpy.asarray(
-                    [response.policies[1]]
-                ),  # dependent variable P(choosing the right | stimuli on right)
-            }
-            return output
+class _HybridModel(SessionModel):
+    """The model function of `HybridMBMF`, for all trials at once."""
+
+    def __call__(self, parameters, data):
+        trials = data["s1"].shape[0]
+        out = self.sessions.hybrid_mbmf(
+            *(float(getattr(parameters, name)) for name in HYBRID_PARAMETERS),
+            numpy.asarray(parameters.q_mf, dtype=float),
+            numpy.asarray(parameters.q2, dtype=float),
+            numpy.asarray(parameters.m, dtype=float),
+            numpy.asarray(parameters.r, dtype=float),
+            data["s1"],
+            data["stimuli_first"],
+            data["action"],
+            data["s2"],
+            data["reward"],
+            data["position"],
+            data["reward_0"],
+            data["reward_1"],
+            self.generate,
+            uniforms(trials, self.generate),
+        )
+        policy, action, s2, reward, position, pe1, pe2, q_mf, q2, m, r = out
+        return {
+            "policy": policy,
+            "action": action,
+            "s2": s2,
+            "reward": reward,
+            "position": position,
+            "stage1_prediction_error": pe1,
+            "stage2_prediction_error": pe2,
+            "q_mf": q_mf,
+            "q2": q2,
+            "m": m,
+            "r": r,
+            "dependent": policy[:, 1].copy(),
+        }
+
+
+class _PrepareHybrid:
+    """The data preparation of `HybridMBMF`, filling in the optional columns once."""
+
+    def __init__(self, generate):
+        self.generate = generate
+
+    def __call__(self, data):
+        out = prepared(data)
+        require(out, ["s1"], "HybridMBMF")
+        needed = ["reward_0", "reward_1"] if self.generate else ["action", "s2", "reward"]
+        require(out, needed, "HybridMBMF")
+        trials = out["s1"].shape[0]
+        for key in ("s1", "stimuli_first", "action", "s2"):
+            out[key] = indices(out.get(key, numpy.zeros(trials)))
+        for key in ("reward", "reward_0", "reward_1"):
+            out[key] = numpy.ascontiguousarray(
+                out.get(key, numpy.zeros(trials)), dtype=numpy.float64
+            )
+        out["position"] = indices(out.get("position", out["stimuli_first"] ^ out["action"]))
+        return out
 
-        super().__init__(data=data, model=model, parameters=parameters)
 
 
-class HybridMBMF(Wrapper):
+class HybridMBMF(Application):
     r"""
     The class implements the hybrid model-based / model-free reinforcement learning model for the deterministic two-step task (Kool et al., 2016), in the 6-parameter variant used by Smid et al. (2022).
     Model-free values are learned with a SARSA rule with an eligibility trace, model-based values are computed from the known transition structure, and the two are mixed before a Softmax decision rule.
@@ -269,6 +374,10 @@ class HybridMBMF(Wrapper):
 
     After the choice, the model-free and second-stage values are updated with a SARSA rule with an eligibility trace, see :class:`cpm.models.learning.SARSATrace`.
 
+    .. rubric:: Computation
+
+    The model computes all trials of a participant in one call, compiled with numba if numba is installed (``pip install cpm-toolbox[numba]``) and as plain Python otherwise, with the same results. `model` is the model function for a single trial, ``model(parameters, trial)``, which computes one trial from the states in `parameters` and returns its outputs.
+
     References
     ----------
 
@@ -281,135 +390,10 @@ class HybridMBMF(Wrapper):
     """
 
     def __init__(self, data=None, parameters_settings=None, q_init=0.5, generate=False):
-        if parameters_settings is None:
-            parameters_settings = [
-                [2, 0, 5],
-                [0.5, 0, 1],
-                [0.5, 0, 1],
-                [0.5, 0, 1],
-                [0, -5, 5],
-                [0, -5, 5],
-            ]
-            warnings.warn("No parameters specified, using default parameters.")
-        priors = [
-            {"mean": 1.5, "sd": 2.0},
-            {"mean": 0.5, "sd": 0.25},
-            {"mean": 0.5, "sd": 0.25},
-            {"mean": 0.5, "sd": 0.25},
-            {"mean": 0.0, "sd": 1.0},
-            {"mean": 0.0, "sd": 1.0},
-        ]
-        names = [
-            "inv_temperature",
-            "learning_rate",
-            "eligibility_trace",
-            "mb_weight",
-            "choice_stickiness",
-            "response_stickiness",
-        ]
-        parameters = Parameters(
-            # freely varying parameters are indicated by specifying priors
-            **{
-                name: Value(
-                    value=settings[0],
-                    lower=settings[1],
-                    upper=settings[2],
-                    prior="truncated_normal",
-                    args=prior,
-                )
-                for name, settings, prior in zip(names, parameters_settings, priors)
-            },
-            # internal states of the model
-            q_mf=numpy.full((2, 2), q_init, dtype=float),
-            q2=numpy.full(2, q_init, dtype=float),
-            m=numpy.zeros((2, 2)),
-            r=numpy.zeros(2),
+        parameters = _hybrid_parameters(parameters_settings, q_init)
+        self._setup(
+            data=data,
+            parameters=parameters,
+            session_model=_HybridModel(generate),
+            prepare=_PrepareHybrid(generate),
         )
-        ## deterministic transitions: action 0 -> state 1, action 1 -> state 0
-        transitions = numpy.array([[0.0, 1.0], [1.0, 0.0]])
-
-        @ipp.require("numpy")
-        def model(parameters, trial, generate=generate):
-            # pull out the parameters
-            inv_temperature = parameters.inv_temperature
-            learning_rate = parameters.learning_rate
-            eligibility_trace = parameters.eligibility_trace
-            mb_weight = parameters.mb_weight
-            choice_stickiness = parameters.choice_stickiness
-            response_stickiness = parameters.response_stickiness
-            q_mf = numpy.asarray(parameters.q_mf).copy()
-            q2 = numpy.asarray(parameters.q2).copy()
-            m = numpy.asarray(parameters.m).copy()
-            r = numpy.asarray(parameters.r).copy()
-
-            s1 = int(trial.s1)
-            stimuli_first = int(trial.get("stimuli_first", 0))
-            ## response stickiness is stored by screen position [left, right],
-            ## so flip it to action space when action 1 is displayed on the left
-            r_action = r[::-1] if stimuli_first == 1 else r
-
-            ## hybrid values
-            q_mb = transitions @ q2
-            q_hybrid = (
-                mb_weight * q_mb
-                + (1 - mb_weight) * q_mf[s1]
-                + choice_stickiness * m[s1]
-                + response_stickiness * r_action
-            )
-            response = cpm.models.decision.Softmax(
-                activations=q_hybrid, temperature=inv_temperature
-            )
-            response.compute()
-
-            if generate:
-                action = response.choice()
-                s2 = int(numpy.argmax(transitions[action]))
-                reward = float(trial[f"reward_{s2}"])
-                position = stimuli_first ^ action
-            else:
-                action = int(trial.action)
-                s2 = int(trial.s2)
-                reward = float(trial.reward)
-                position = int(trial.get("position", stimuli_first ^ action))
-
-            ## update stickiness for the next trial
-            m = numpy.zeros((2, 2))
-            m[s1, action] = 1
-            r = numpy.zeros(2)
-            r[position] = 1
-
-            ## update values
-            update = cpm.models.learning.SARSATrace(
-                learning_rate=learning_rate,
-                eligibility_trace=eligibility_trace,
-                model_free_values=q_mf,
-                second_stage_values=q2,
-                starting_state=s1,
-                action=action,
-                reached_second_stage=s2,
-                reward=reward,
-            )
-            model_free_delta, planet_value_delta = update.compute()
-            q_mf += model_free_delta
-            q2 += planet_value_delta
-
-            ## compile output
-            output = {
-                "policy": response.policies,  # policies
-                "action": action,  # chosen (or generated) first-stage action
-                "s2": s2,  # second-stage state reached
-                "reward": reward,  # reward received
-                "position": position,  # screen position of the response
-                "stage1_prediction_error": update.stage1_prediction_error,
-                "stage2_prediction_error": update.stage2_prediction_error,
-                "q_mf": q_mf.copy(),  # updated model-free values
-                "q2": q2.copy(),  # updated second-stage values
-                "m": m,  # choice stickiness for the next trial
-                "r": r,  # response stickiness for the next trial
-                "dependent": numpy.asarray(
-                    [response.policies[1]]
-                ),  # dependent variable P(choosing action 1)
-            }
-            return output
-
-        super().__init__(data=data, model=model, parameters=parameters)
diff --git a/cpm/applications/signal_detection.py b/cpm/applications/signal_detection.py
index 493bb26..a66eb82 100644
--- a/cpm/applications/signal_detection.py
+++ b/cpm/applications/signal_detection.py
@@ -9,6 +9,7 @@
 import cpm
 from scipy.optimize import SR1, Bounds, LinearConstraint, minimize
 from scipy.stats import norm, multivariate_normal
+from scipy.special import ndtr
 
 from cpm.core.optimisers import numerical_hessian, prepare_data
 from cpm.core.data import detailed_pandas_compiler, decompose
@@ -85,57 +86,41 @@ def metad_nll(
     nC_rS2 = [nR_S2[i + nRatings] for i in np.arange(nRatings)]
     nI_rS2 = [nR_S1[i + nRatings] for i in np.arange(nRatings)]
 
-    # get type 2 probabilities
-    C_area_rS1 = norm.cdf(t1c1, S1mu, S1sd)
-    I_area_rS1 = norm.cdf(t1c1, S2mu, S2sd)
+    # get type 2 probabilities; ndtr((x - mu) / sd) is what norm.cdf(x, mu, sd)
+    # evaluates, and a single vectorised call avoids scipy's per-call overhead
+    C_area_rS1 = ndtr((t1c1 - S1mu) / S1sd)
+    I_area_rS1 = ndtr((t1c1 - S2mu) / S2sd)
 
-    C_area_rS2 = 1 - norm.cdf(t1c1, S2mu, S2sd)
-    I_area_rS2 = 1 - norm.cdf(t1c1, S1mu, S1sd)
+    C_area_rS2 = 1 - ndtr((t1c1 - S2mu) / S2sd)
+    I_area_rS2 = 1 - ndtr((t1c1 - S1mu) / S1sd)
 
     t2c1x = [-np.inf]
     t2c1x.extend(t2c1[0 : (nRatings - 1)])
     t2c1x.append(t1c1)
     t2c1x.extend(t2c1[(nRatings - 1) :])
     t2c1x.append(np.inf)
-
-    prC_rS1 = [
-        (norm.cdf(t2c1x[i + 1], S1mu, S1sd) - norm.cdf(t2c1x[i], S1mu, S1sd))
-        / C_area_rS1
-        for i in range(nRatings)
-    ]
-    prI_rS1 = [
-        (norm.cdf(t2c1x[i + 1], S2mu, S2sd) - norm.cdf(t2c1x[i], S2mu, S2sd))
-        / I_area_rS1
-        for i in range(nRatings)
-    ]
-
-    prC_rS2 = [
-        (
-            (1 - norm.cdf(t2c1x[nRatings + i], S2mu, S2sd))
-            - (1 - norm.cdf(t2c1x[nRatings + i + 1], S2mu, S2sd))
-        )
-        / C_area_rS2
-        for i in range(nRatings)
-    ]
-    prI_rS2 = [
-        (
-            (1 - norm.cdf(t2c1x[nRatings + i], S1mu, S1sd))
-            - (1 - norm.cdf(t2c1x[nRatings + i + 1], S1mu, S1sd))
-        )
-        / I_area_rS2
-        for i in range(nRatings)
-    ]
-
-    # calculate logL
+    t2c1x = np.asarray(t2c1x, dtype=float)
+
+    cdf_S1 = ndtr((t2c1x - S1mu) / S1sd)
+    cdf_S2 = ndtr((t2c1x - S2mu) / S2sd)
+
+    prC_rS1 = (cdf_S1[1 : nRatings + 1] - cdf_S1[:nRatings]) / C_area_rS1
+    prI_rS1 = (cdf_S2[1 : nRatings + 1] - cdf_S2[:nRatings]) / I_area_rS1
+    prC_rS2 = (
+        (1 - cdf_S2[nRatings : 2 * nRatings]) - (1 - cdf_S2[nRatings + 1 : 2 * nRatings + 1])
+    ) / C_area_rS2
+    prI_rS2 = (
+        (1 - cdf_S1[nRatings : 2 * nRatings]) - (1 - cdf_S1[nRatings + 1 : 2 * nRatings + 1])
+    ) / I_area_rS2
+
+    # calculate logL, summed in the same order as before
+    terms_C_rS1 = np.asarray(nC_rS1, dtype=float) * np.log(prC_rS1)
+    terms_I_rS1 = np.asarray(nI_rS1, dtype=float) * np.log(prI_rS1)
+    terms_C_rS2 = np.asarray(nC_rS2, dtype=float) * np.log(prC_rS2)
+    terms_I_rS2 = np.asarray(nI_rS2, dtype=float) * np.log(prI_rS2)
     logL = 0.0
     for i in range(nRatings):
-        logL = (
-            logL
-            + nC_rS1[i] * np.log(prC_rS1[i])
-            + nI_rS1[i] * np.log(prI_rS1[i])
-            + nC_rS2[i] * np.log(prC_rS2[i])
-            + nI_rS2[i] * np.log(prI_rS2[i])
-        )
+        logL = logL + terms_C_rS1[i] + terms_I_rS1[i] + terms_C_rS2[i] + terms_I_rS2[i]
 
     if prior:
         parameters.update(**{
diff --git a/cpm/core/_jit.py b/cpm/core/_jit.py
new file mode 100644
index 0000000..4bbffcd
--- /dev/null
+++ b/cpm/core/_jit.py
@@ -0,0 +1,160 @@
+"""
+Optional compilation with numba.
+
+numba is an optional dependency of cpm (``pip install cpm-toolbox[numba]``): it
+lags behind new NumPy releases and does not support PyPy. Modules with
+compiled kernels decorate them with `njit` from here, which is numba's `njit`
+if numba can be imported and an identity decorator otherwise, so the same
+kernels run as plain Python without numba and give the same results.
+
+`kernels` returns such a module either compiled or as plain Python. The
+plain-Python version is a second copy of the module, loaded from the same source
+file with compilation turned off, so that kernels calling other kernels stay
+uncompiled throughout. The classes in `cpm.models` compute with it, and the
+tests use it to check the compiled models against the plain-Python ones.
+
+Compilation can be turned off for a whole process with the environment variable
+``CPM_DISABLE_JIT=1`` (or numba's own ``NUMBA_DISABLE_JIT=1``).
+
+numba is imported when it is first needed, that is, when a compiled kernel is
+first created, and not when cpm is imported. `HAVE_NUMBA` and `JIT_ENABLED` are
+determined then.
+"""
+
+import importlib
+import importlib.util
+import os
+import sys
+import warnings
+
+__all__ = ["HAVE_NUMBA", "JIT_ENABLED", "njit", "kernels", "resolve_backend"]
+
+## set in the namespace of a module copy that is loaded without compilation
+PYTHON_FLAG = "__cpm_python__"
+
+_STATE = {}
+
+
+def _probe():
+    """Import numba, once, and record whether compiled kernels are available."""
+    if not _STATE:
+        numba = None
+        if os.environ.get("CPM_DISABLE_JIT", "0") in ("", "0"):
+            try:
+                import numba
+            except Exception as error:  # such as a numba that rejects the installed NumPy
+                if not (isinstance(error, ModuleNotFoundError) and error.name == "numba"):
+                    warnings.warn(
+                        f"numba is installed but could not be imported ({error!r}), so the "
+                        "built-in models run as plain Python, with the same results.",
+                        stacklevel=2,
+                    )
+        _STATE["numba"] = numba
+        have = numba is not None
+        _STATE["HAVE_NUMBA"] = have
+        ## numba's own switch turns njit into an identity decorator as well
+        _STATE["JIT_ENABLED"] = have and os.environ.get("NUMBA_DISABLE_JIT", "0") in ("", "0")
+    return _STATE
+
+
+def __getattr__(name):
+    if name in ("HAVE_NUMBA", "JIT_ENABLED"):
+        return _probe()[name]
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+def _flag(name):
+    """`HAVE_NUMBA` or `JIT_ENABLED`; a value set on the module (for example by a test) takes precedence."""
+    return globals()[name] if name in globals() else _probe()[name]
+
+
+def _identity(*args, **kwargs):
+    if len(args) == 1 and callable(args[0]) and not kwargs:
+        return args[0]
+    return lambda function: function
+
+
+def njit(*args, **kwargs):
+    """numba's `njit` (with ``cache=True`` by default), or an identity decorator without numba."""
+    if not _flag("HAVE_NUMBA"):
+        return _identity(*args, **kwargs)
+    kwargs.setdefault("cache", True)
+    numba = _probe()["numba"]
+    if not (len(args) == 1 and callable(args[0])):
+        return numba.njit(*args, **kwargs)
+    try:
+        return numba.njit(**kwargs)(args[0])
+    except RuntimeError:  # numba has nowhere to write its cache, such as on a read-only install
+        return numba.njit(**{**kwargs, "cache": False})(args[0])
+
+
+def decorator(namespace):
+    """The `njit` a module should use: an identity decorator in its plain-Python copy."""
+    return _identity if namespace.get(PYTHON_FLAG, False) else njit
+
+
+_PYTHON_MODULES = {}
+
+
+def kernels(name, python=False):
+    """
+    A module of kernels, compiled or as plain Python.
+
+    Parameters
+    ----------
+    name : str
+        The name of the module, for example ``"cpm.models.kernels"``.
+    python : bool
+        If True, return a copy of the module that is loaded without compiling its
+        kernels (and without importing numba). This is what the classes in
+        `cpm.models` compute with.
+
+    Returns
+    -------
+    module
+    """
+    if not python:
+        return importlib.import_module(name)
+    if name not in _PYTHON_MODULES:
+        spec = importlib.util.find_spec(name)
+        copy_name = f"{name}__python"
+        copy_spec = importlib.util.spec_from_file_location(copy_name, spec.origin)
+        module = importlib.util.module_from_spec(copy_spec)
+        module.__package__ = name.rpartition(".")[0]
+        setattr(module, PYTHON_FLAG, True)
+        sys.modules[copy_name] = module
+        ## from the source, since the file does not exist if cpm is imported from a zip
+        exec(compile(spec.loader.get_source(name), spec.origin, "exec"), module.__dict__)
+        _PYTHON_MODULES[name] = module
+    return _PYTHON_MODULES[name]
+
+
+def resolve_backend(backend):
+    """
+    The backend a session model runs on.
+
+    Parameters
+    ----------
+    backend : str
+        ``"auto"`` (numba if it is installed and not disabled, plain Python
+        otherwise), ``"numba"`` or ``"python"``. The built-in applications use
+        ``"auto"``, so that installing numba is all it takes to compile them.
+
+    Returns
+    -------
+    str
+        ``"numba"`` or ``"python"``.
+    """
+    if backend == "auto":
+        return "numba" if _flag("JIT_ENABLED") else "python"
+    if backend == "numba":
+        if not _flag("HAVE_NUMBA"):
+            raise ImportError(
+                "Compiling with numba needs numba, which could not be imported. Install "
+                "it with `pip install cpm-toolbox[numba]` (numba supports a NumPy release "
+                "some time after it comes out)."
+            )
+        return "numba"
+    if backend == "python":
+        return "python"
+    raise ValueError(f"backend must be 'auto', 'numba' or 'python', not {backend!r}.")
diff --git a/cpm/core/data.py b/cpm/core/data.py
index 4e9dba1..0d25128 100644
--- a/cpm/core/data.py
+++ b/cpm/core/data.py
@@ -6,6 +6,7 @@
 
 __all__ = [
     "unpack_trials",
+    "trial_reader",
     "unpack_participants",
     "determine_data_length",
     "extract_params_from_fit",
@@ -40,6 +41,51 @@ def unpack_trials(data, i, pandas=True):
     return trial
 
 
+def trial_reader(data, pandas=True):
+    """
+    A function that returns trial `i` of `data`, as `unpack_trials(data, i, pandas)` does.
+
+    Reading a row of a `pandas.DataFrame` with `iloc` takes about 50 microseconds,
+    which a model run pays on every trial. For data with only numeric columns, or
+    only boolean ones, the reader converts the data to a numpy array once and builds each row
+    from it, which gives the same `pandas.Series` (values, dtype, index and name)
+    about seven times faster. The array is a copy made when the reader is created,
+    so the data are read afresh on every run, and changing a trial inside a model
+    cannot change the data.
+
+    Parameters
+    ----------
+    data : pandas.DataFrame or dict
+        The data of one participant.
+    pandas : bool
+        Whether `data` is a `pandas.DataFrame`.
+
+    Returns
+    -------
+    function
+        A function of the trial index.
+    """
+    if pandas and isinstance(data, pd.DataFrame):
+        dtypes = data.dtypes
+        plain = all(
+            isinstance(dtype, np.dtype) and dtype.kind in "biuf" for dtype in dtypes
+        )
+        values = data.to_numpy(copy=True) if plain and data.shape[1] > 0 else None
+        ## mixed bool and numeric columns give an object array of Python scalars,
+        ## where iloc gives numpy scalars, so those are read with iloc
+        if values is not None and values.dtype != object:
+            columns = data.columns
+            index = data.index
+            single = data.shape[1] == 1
+
+            def read(i):
+                row = pd.Series(values[i], index=columns, name=index[i])
+                return row.squeeze() if single else row
+
+            return read
+    return lambda i: unpack_trials(data, i, pandas)
+
+
 def unpack_participants(data, index, keys=None, pandas=True):
     """
     Return a single participant's data or parameter identified by an indexing variable.
diff --git a/cpm/generators/__init__.py b/cpm/generators/__init__.py
index 714381e..b9271b5 100644
--- a/cpm/generators/__init__.py
+++ b/cpm/generators/__init__.py
@@ -2,10 +2,11 @@
 Here we import all the modules that are needed for the project.
 """
 
-__all__ = ["Wrapper", "Simulator", "Parameters", "Value", "LogParameters"]
+__all__ = ["Wrapper", "SessionWrapper", "Simulator", "Parameters", "Value", "LogParameters"]
 
 from .simulator import Simulator
 from .wrapper import Wrapper
+from .session import SessionWrapper
 from .parameters import Parameters, Value, LogParameters
 
-del simulator, wrapper, parameters
+del simulator, wrapper, session, parameters
diff --git a/cpm/generators/_fast_priors.py b/cpm/generators/_fast_priors.py
new file mode 100644
index 0000000..41e8aa0
--- /dev/null
+++ b/cpm/generators/_fast_priors.py
@@ -0,0 +1,172 @@
+"""
+Fast log densities for the prior distributions cpm builds.
+
+`Parameters.PDF` is evaluated on every call of the objective function, and a
+scipy `logpdf` call on a frozen distribution costs about 30 microseconds, most
+of it argument handling for arrays. For a single point, and for the
+distribution families that `Value` builds from a string (and the same families
+when they are passed in as frozen scipy distributions), this module evaluates
+the same expression as scipy, in the same order of floating-point operations,
+with the constants that depend only on the distribution's arguments computed
+once. The results are identical to scipy's, not only close.
+
+The scipy object stays the prior: this module only caches an evaluator on it.
+The evaluator is rebuilt whenever the distribution's arguments change, so
+priors that are updated in place still give the right density. Anything the
+fast path does not cover (other distributions, array-valued or invalid parameters, points
+on or outside the boundary of the support, non-finite values) is passed on to
+scipy unchanged.
+"""
+
+import math
+
+import numpy as np
+from scipy import special
+
+__all__ = ["fast_logpdf"]
+
+## attribute under which the evaluator is cached on the frozen distribution
+_CACHE = "_cpm_fast_logpdf"
+
+try:  # scipy's normalising constants, as its distributions compute them
+    from scipy.stats._continuous_distns import _log_gauss_mass, _norm_pdf_logC
+except ImportError:  # pragma: no cover - a scipy without them uses scipy throughout
+    _log_gauss_mass = _norm_pdf_logC = None
+
+
+def _constants(name, shapes):
+    """The terms of scipy's `_logpdf` that depend only on the shape parameters."""
+    if name in ("norm", "truncnorm"):
+        if _norm_pdf_logC is None:
+            raise ValueError("scipy internals not available")
+        if name == "norm":
+            return (_norm_pdf_logC,)
+        return (_norm_pdf_logC, np.real(_log_gauss_mass(*shapes))[()])
+    if name == "gamma":
+        return (shapes[0] - 1.0, special.gammaln(shapes[0]))
+    if name == "beta":
+        return (shapes[0] - 1.0, shapes[1] - 1.0, special.betaln(shapes[0], shapes[1]))
+    if name == "truncexpon":
+        return (np.log(-special.expm1(-shapes[0])),)
+    return ()  # uniform
+
+
+## scipy's `_logpdf` of each family at the standardised point y, with the
+## constants above; the order of operations is scipy's
+_LOGPDF = {
+    "norm": lambda y, c: -(y * y) / 2.0 - c[0],
+    "truncnorm": lambda y, c: (-(y * y) / 2.0 - c[0]) - c[1],
+    "uniform": lambda y, c: 0.0,
+    "gamma": lambda y, c: special.xlogy(c[0], y) - y - c[1],
+    "beta": lambda y, c: (special.xlog1py(c[1], -y) + special.xlogy(c[0], y)) - c[2],
+    "truncexpon": lambda y, c: -y - c[0],
+}
+
+
+def _support(name, shapes):
+    """The open interior of the support in the standardised variable."""
+    if name == "norm":
+        return -math.inf, math.inf
+    if name == "truncnorm":
+        return shapes[0], shapes[1]
+    if name == "gamma":
+        return 0.0, math.inf
+    if name == "truncexpon":
+        return 0.0, shapes[0]
+    return 0.0, 1.0  # uniform, beta
+
+
+class _Evaluator:
+    """The log density of one frozen distribution with fixed arguments."""
+
+    __slots__ = ("args", "kwds", "loc", "scale", "log_scale", "constants", "logpdf", "low", "high")
+
+    def __init__(self, prior, name):
+        self.args = tuple(prior.args)
+        self.kwds = dict(prior.kwds)
+        shapes, loc, scale = prior.dist._parse_args(*prior.args, **prior.kwds)
+        self.loc, self.scale = np.float64(loc), np.float64(scale)
+        shapes = tuple(np.float64(s) for s in shapes)
+        self.log_scale = np.log(self.scale)
+        self.constants = _constants(name, shapes)
+        self.logpdf = _LOGPDF[name]
+        self.low, self.high = _support(name, shapes)
+
+    def valid(self, prior):
+        try:
+            return bool(self.kwds == prior.kwds and self.args == tuple(prior.args))
+        except (TypeError, ValueError):  # array-valued arguments
+            return False
+
+    def __reduce__(self):
+        ## the cache is not pickled (`logpdf` is a lambda); an unpickled prior rebuilds it
+        return type(None), ()
+
+    def __call__(self, x):
+        y = (x - self.loc) / self.scale
+        if self.low < y < self.high:
+            return self.logpdf(y, self.constants) - self.log_scale
+        return None
+
+
+def _evaluator(prior):
+    """
+    The cached evaluator of `prior`, (re)built if its arguments changed.
+
+    Returns False if there is no fast path for `prior`. Only an unsupported
+    distribution family is remembered as such, since everything else depends on
+    arguments that may still change.
+    """
+    cached = getattr(prior, _CACHE, None)
+    if cached is False:
+        return False
+    if cached is not None and cached.valid(prior):
+        return cached
+    dist = getattr(prior, "dist", None)
+    name = getattr(dist, "name", None)
+    if name not in _LOGPDF or not hasattr(prior, "kwds") or not hasattr(prior, "args"):
+        try:
+            setattr(prior, _CACHE, False)
+        except AttributeError:
+            pass
+        return False
+    try:
+        shapes, loc, scale = dist._parse_args(*prior.args, **prior.kwds)
+        if not all(np.ndim(v) == 0 for v in (*shapes, loc, scale)) or not scale > 0:
+            return False
+        if not np.all(dist._argcheck(*shapes)):  # scipy returns NaN for these
+            return False
+        evaluator = _Evaluator(prior, name)
+    except Exception:
+        return False
+    try:
+        setattr(prior, _CACHE, evaluator)
+    except AttributeError:
+        return False
+    return evaluator
+
+
+def fast_logpdf(prior, x):
+    """
+    The log density of `prior` at `x`, or None where the fast path does not apply.
+
+    Parameters
+    ----------
+    prior : object
+        The prior distribution of a `Value`, normally a frozen scipy distribution.
+    x : float
+        The point at which to evaluate the log density.
+
+    Returns
+    -------
+    numpy.float64 or None
+        The log density, equal to `prior.logpdf(x)`, or None if the caller has to
+        ask `prior.logpdf` itself.
+    """
+    if not isinstance(x, (float, int, np.floating, np.integer)) or isinstance(x, bool):
+        return None
+    evaluator = _evaluator(prior)
+    if evaluator is False:
+        return None
+    value = evaluator(np.float64(x))
+    return None if value is None else np.float64(value)
diff --git a/cpm/generators/parameters.py b/cpm/generators/parameters.py
index 96b1853..25fa4fe 100644
--- a/cpm/generators/parameters.py
+++ b/cpm/generators/parameters.py
@@ -1,6 +1,7 @@
 import numpy as np
 import pandas as pd
 import copy
+from ._fast_priors import fast_logpdf
 from scipy.stats import (
     truncnorm,
     truncexpon,
@@ -419,8 +420,10 @@ def __rtruediv__(self, other):  # other / self
     def __copy__(self):
         return Value(**self.__dict__)
 
-    def __array__(self) -> np.ndarray:
-        return np.asarray(self.value)
+    def __array__(self, dtype=None, copy=None) -> np.ndarray:
+        if copy:
+            return np.array(self.value, dtype=dtype, copy=True)
+        return np.asarray(self.value, dtype=dtype)
 
     def __float__(self) -> float:
         return float(self.value)
@@ -444,7 +447,16 @@ def __copy__(self):
         return Value(**self.__dict__)
 
     def __deepcopy__(self, memo):
-        return Value(**copy.deepcopy(self.__dict__, memo))
+        # copies share the prior distribution instead of deep-copying it: a frozen
+        # scipy distribution takes about 0.1 ms to copy, and the model's
+        # parameters are copied on every evaluation of the objective function.
+        # `update_prior` replaces the prior rather than changing it in place, so
+        # copies do not see each other's updates.
+        new = type(self).__new__(type(self))
+        memo[id(self)] = new
+        for key, item in self.__dict__.items():
+            new.__dict__[key] = item if key == "prior" else copy.deepcopy(item, memo)
+        return new
 
     def copy(self):
         """
@@ -482,7 +494,10 @@ def PDF(self, log=False):
             The probability of the parameter value under the prior distribution. If `log` is True, the log probability is returned.
         """
         if log:
-            return self.prior.logpdf(self.value)
+            density = fast_logpdf(self.prior, self.value)
+            if density is None:
+                density = self.prior.logpdf(self.value)
+            return density
         else:
             return self.prior.pdf(self.value)
 
@@ -522,8 +537,11 @@ def update_prior(self, **kwargs):
             updates["a"] = (self.lower - kwargs.get("mean")) / kwargs.get("sd")
             updates["b"] = (self.upper - kwargs.get("mean")) / kwargs.get("sd")
 
-        # now, update the prior object
-        self.prior.kwds.update(**updates)
+        # now, replace the prior object with an updated copy: copies of a Value
+        # share their prior, so changing it in place would change theirs too
+        prior = copy.deepcopy(self.prior)
+        prior.kwds.update(**updates)
+        self.prior = prior
 
 
 class LogParameters(Parameters):
diff --git a/cpm/generators/session.py b/cpm/generators/session.py
new file mode 100644
index 0000000..af0d7c6
--- /dev/null
+++ b/cpm/generators/session.py
@@ -0,0 +1,308 @@
+import numpy as np
+import pandas as pd
+import warnings
+
+from .wrapper import Wrapper
+from ..core.data import determine_data_length
+
+__all__ = ["SessionWrapper", "session_data", "session_export"]
+
+
+def session_data(data):
+    """
+    Convert the data of one participant into a dictionary of contiguous numpy arrays.
+
+    Parameters
+    ----------
+    data : pandas.DataFrame or dict
+        The data of one participant. If a `pandas.DataFrame`, each row is a trial.
+        If a dictionary, each entry holds the values of one variable on all
+        trials; its `"ppt"` entry, if any, is left out, as in :class:`Wrapper`.
+
+    Returns
+    -------
+    dict
+        One C-contiguous numpy array per column or entry, a copy of the data, with
+        the trials along the first axis.
+    """
+    if isinstance(data, pd.DataFrame):
+        return {
+            column: np.array(data[column].to_numpy(), order="C")
+            for column in data.columns
+        }
+    if isinstance(data, dict):
+        return {
+            key: np.array(value, order="C")
+            for key, value in data.items()
+            if key != "ppt"
+        }
+    raise TypeError(
+        f"The data must be a pandas.DataFrame or a dict, not {type(data).__name__}."
+    )
+
+
+def trial_view(output, t, shapes):
+    """
+    The outputs of trial `t` of a run, as the per-trial model returns them.
+
+    Parameters
+    ----------
+    output : dict
+        The outputs of a session model, one array per output, trials first.
+    t : int
+        The trial.
+    shapes : dict
+        Outputs whose per-trial value has a shape of its own, such as (1, -1).
+        `dependent` is always at least one-dimensional.
+    """
+    row = {}
+    for key, value in output.items():
+        item = value[t]
+        if key == "dependent":
+            item = np.atleast_1d(item).copy()
+        elif key in shapes:
+            item = np.reshape(item, shapes[key]).copy()
+        elif isinstance(item, np.ndarray):
+            item = item.copy()
+        row[key] = item
+    return row
+
+
+def session_export(output, trials):
+    """
+    Turn the output of a session model into one row per trial.
+
+    Parameters
+    ----------
+    output : dict
+        The output of a session model. Each entry is an array with the trials
+        along the first axis, or a scalar, which is repeated on every trial.
+    trials : int
+        The number of trials.
+
+    Returns
+    -------
+    pandas.DataFrame
+        A table with one row per trial, laid out as :meth:`Wrapper.export` lays
+        out the output of a per-trial model: an entry with more than one value per
+        trial is split into columns named `<key>_0`, `<key>_1`, and so on, in C
+        order, and a `ppt` column is added.
+    """
+    columns = {}
+    for key, value in output.items():
+        value = np.asarray(value)
+        if value.ndim == 0:
+            value = np.repeat(value, trials)
+        if value.shape[0] != trials:
+            raise ValueError(
+                f"The output {key!r} of the session model has {value.shape[0]} rows, "
+                f"but the data have {trials} trials. Session models have to return "
+                "one row per trial."
+            )
+        value = value.reshape(trials, -1)
+        if value.shape[1] == 1:
+            columns[key] = value[:, 0]
+        else:
+            for i in range(value.shape[1]):
+                columns[f"{key}_{i}"] = value[:, i]
+    table = pd.DataFrame(columns)
+    table["ppt"] = 0
+    return table
+
+
+class SessionWrapper(Wrapper):
+    """
+    A `Wrapper` for a model function that computes all trials of a participant at once.
+
+    `SessionWrapper` works like :class:`Wrapper <cpm.generators.Wrapper>`, and can
+    be used wherever a `Wrapper` can (the optimisers, :class:`Simulator
+    <cpm.generators.Simulator>` and `cpm.hierarchical`), but its model function is
+    called once per run instead of once per trial. Loops over trials can then be
+    written in plain Python on numpy arrays, or compiled with numba, and the cost
+    of calling a Python function and copying the parameters on every trial is
+    gone. This is typically 10 to 100 times faster than a per-trial `Wrapper`.
+
+    Use it instead of a `Wrapper` when fitting your own model is too slow; the
+    built-in models in `cpm.applications` already compute all trials at once. See
+    :doc:`/how-to/speed-up-your-model` for how to rewrite a per-trial model.
+
+    Parameters
+    ----------
+    model : function
+        The model function, which computes the outputs of the model on all trials
+        of a participant. See Notes.
+    data : pandas.DataFrame or dict
+        The data of a single participant (or the environment of a simulation), as
+        for :class:`Wrapper`: a `pandas.DataFrame` with one row per trial, or a
+        dictionary with one entry per variable, each holding the values on all
+        trials.
+    parameters : Parameters
+        The parameters of the model, including its initial states.
+    prepare : function, optional
+        A function that turns the data into the form the model function takes. It
+        is called once, when the data are first needed (and again after `reset` with
+        new data or without parameters), not on every run. The default is :func:`session_data`,
+        which returns a dictionary of contiguous numpy arrays, one per column.
+
+    Notes
+    -----
+    The model function takes two arguments, `parameters` and `data`. `parameters`
+    is the :class:`Parameters <cpm.generators.Parameters>` object of the model, and
+    `data` is the output of `prepare`. The model function returns a dictionary of
+    outputs, each an array with one row per trial (or a scalar, repeated on every
+    trial). If the model is to be fitted, the outputs include
+
+    - 'dependent': the dependent variables for the loss function, with shape
+      `(trials,)` or `(trials, k)`.
+
+    After a run, `dependent` has shape `(trials, k)`, as for a `Wrapper`, and each
+    output whose name is also a parameter (such as a state) sets that parameter to
+    its value on the last trial, the state a per-trial `Wrapper` ends a run with.
+    Otherwise the model function should not change `parameters`.
+
+    `export()` returns one row per trial, laid out as the export of a per-trial
+    `Wrapper`, see :func:`session_export`. The outputs of the last run are in
+    `session_output`, one array per output, and in `simulation`, one dictionary
+    per trial, as for a `Wrapper`. The model function should not change `data`,
+    which is reused on every run.
+
+    Examples
+    --------
+    A Rescorla-Wagner model of a single cue, written for all trials at once:
+
+    >>> import numpy as np
+    >>> import pandas as pd
+    >>> from cpm.generators import SessionWrapper, Parameters, Value
+    >>> def model(parameters, data):
+    ...     alpha = parameters.alpha.value
+    ...     value = float(parameters.value.value)
+    ...     predictions = np.empty(len(data["reward"]))
+    ...     for t, reward in enumerate(data["reward"]):
+    ...         predictions[t] = value
+    ...         value += alpha * (reward - value)
+    ...     return {"prediction": predictions, "dependent": predictions}
+    >>> parameters = Parameters(
+    ...     alpha=Value(value=0.3, lower=0, upper=1, prior="uniform"),
+    ...     value=0.0,
+    ... )
+    >>> data = pd.DataFrame({"reward": [1, 1, 0, 1], "observed": [0.2, 0.5, 0.6, 0.4]})
+    >>> wrapper = SessionWrapper(model=model, data=data, parameters=parameters)
+    >>> wrapper.run()
+    >>> wrapper.dependent.ravel()
+    array([0.   , 0.3  , 0.51 , 0.357])
+    """
+
+    ## outputs whose per-trial value in `simulation` has a shape of its own, see `trial_view`
+    _trial_shapes = {}
+
+    def __init__(self, model=None, data=None, parameters=None, prepare=None):
+        self.prepare = session_data if prepare is None else prepare
+        super().__init__(model=model, data=data, parameters=parameters)
+        self.simulation = {}
+        self.session_output = {}
+        self._prepared = None
+        self._prepared_from = None
+
+    @property
+    def session(self):
+        """The data as the model function takes them: the output of `prepare`, computed once."""
+        if self._prepared is None or self._prepared_from is not self.data:
+            self._prepared = self.prepare(self.data)
+            self._prepared_from = self.data
+        return self._prepared
+
+    @property
+    def simulation(self):
+        """The outputs of each trial of the last run, as a list of dictionaries, as for a `Wrapper`."""
+        stored = self.__dict__.get("_simulation", [])
+        if isinstance(stored, dict):
+            trials = len(next(iter(stored.values()))) if stored else 0
+            stored = [trial_view(stored, t, self._trial_shapes) for t in range(trials)]
+            self.__dict__["_simulation"] = stored
+        return stored
+
+    @simulation.setter
+    def simulation(self, value):
+        self.__dict__["_simulation"] = value
+
+    def _run_session(self):
+        """Call the model function on all trials."""
+        return self.model(parameters=self.parameters, data=self.session)
+
+    def run(self):
+        """
+        Run the model on all trials.
+
+        Returns
+        -------
+        None
+        """
+        output = self._run_session()
+        dependent = output.get("dependent")
+        if dependent is not None:
+            dependent = np.asarray(dependent, dtype=float)
+            if dependent.ndim == 1:
+                dependent = dependent.reshape(-1, 1)
+            if dependent.shape[0] != self.__len__:
+                raise ValueError(
+                    f"The dependent variable of the session model has "
+                    f"{dependent.shape[0]} rows, but the data have {self.__len__} trials."
+                )
+            self.dependent = dependent
+        self.session_output = output
+        self.simulation = output
+
+        ## end the run in the state of the last trial, as a per-trial Wrapper does
+        keys = self.parameters.keys()
+        final = {}
+        for key, value in output.items():
+            if key in keys and key != "dependent":
+                value = np.asarray(value)
+                final[key] = value[-1] if value.ndim > 0 else value
+        if final:
+            self.parameters.update(**final)
+
+        self.__run__ = True
+        return None
+
+    def reset(self, parameters=None, data=None):
+        """
+        Reset the model.
+
+        Parameters
+        ----------
+        parameters : dict, array_like, pd.Series or Parameters, optional
+            The parameters to reset the model with.
+        data : pandas.DataFrame or dict, optional
+            New data for the model, which are passed through `prepare` once, when
+            they are first needed.
+
+        Notes
+        -----
+        See :meth:`Wrapper.reset <cpm.generators.Wrapper.reset>`.
+
+        Returns
+        -------
+        None
+        """
+        was_run = self.__run__
+        super().reset(parameters=parameters, data=data)
+        if was_run:
+            self.simulation = {}
+            self.session_output = {}
+        if data is not None or parameters is None:
+            ## a reset without parameters also reads data that were changed in place
+            self._prepared = None
+        return None
+
+    def export(self):
+        """
+        Export the trial-level output of the last run.
+
+        Returns
+        -------
+        pandas.DataFrame
+            One row per trial. An output with more than one value per trial is split
+            into columns `<key>_0`, `<key>_1`, and so on.
+        """
+        return session_export(self.session_output, self.__len__)
diff --git a/cpm/generators/wrapper.py b/cpm/generators/wrapper.py
index 31e69da..0f0016a 100644
--- a/cpm/generators/wrapper.py
+++ b/cpm/generators/wrapper.py
@@ -6,11 +6,57 @@
 
 ## import local modules
 from .parameters import Parameters, Value
-from ..core.data import unpack_trials, determine_data_length
+from ..core.data import unpack_trials, trial_reader, determine_data_length
 from ..core.exports import simulation_export
 from ..core.optimisers import objective
 
 
+def _copy_value(value):
+    """A copy of a parameter value or state that the model cannot change in place."""
+    if isinstance(value, np.ndarray):
+        return value.copy()
+    if isinstance(value, (float, int, str, bool, np.generic)) or value is None:
+        return value
+    return copy.deepcopy(value)
+
+
+def restore_parameters(initial, current):
+    """
+    Parameters with the values of `initial` and the priors and bounds of `current`.
+
+    This is what `Wrapper.reset` does after a run. It is equivalent to deep-copying
+    `initial`, except that the prior distributions are neither copied (which takes
+    about 0.1 ms each) nor reset: priors updated in `current` are kept.
+
+    Parameters
+    ----------
+    initial : Parameters
+        The parameters the model was created with.
+    current : Parameters
+        The parameters after a run.
+
+    Returns
+    -------
+    Parameters
+        A new Parameters object.
+    """
+    restored = {}
+    for key, value in initial.__dict__.items():
+        now = current.__dict__.get(key)
+        if isinstance(value, Value):
+            source = now if isinstance(now, Value) else value
+            new = type(source).__new__(type(source))
+            new.__dict__.update(source.__dict__)
+            new.value = _copy_value(value.value)
+            restored[key] = new
+        else:
+            restored[key] = copy.deepcopy(value)
+    ## not constructed with **restored, since LogParameters transforms the values it is given
+    new = type(current).__new__(type(current))
+    new.__dict__.update(restored)
+    return new
+
+
 class Wrapper:
     """
     A `Wrapper` class for a model function in the CPM toolbox. It is designed to run a model for a **single** experiment (participant) and store the output in a format that can be used for further analysis.
@@ -78,9 +124,10 @@ def run(self):
         None
 
         """
+        read = trial_reader(self.data, self.__pandas__)
         for i in range(self.__len__):
             ## create input for the model
-            trial = unpack_trials(self.data, i, self.__pandas__)
+            trial = read(i)
             ## run the model
             output = self.model(parameters=self.parameters, trial=trial)
             self.simulation.append(output.copy())
@@ -119,6 +166,11 @@ def reset(self, parameters=None, data=None):
         Notes
         -----
         When resetting the model, and `parameters` is None, reset model to initial state.
+        After a run, resetting restores the values of all parameters and initial states
+        to the ones the model was created with. The prior distributions and bounds are
+        kept as they currently are, so that priors updated with
+        :meth:`Parameters.update_prior <cpm.generators.Parameters.update_prior>`, for
+        example by `cpm.hierarchical`, stay in effect.
         If parameter is `array_like`, it resets only the freely-varying parameters (those with a prior),
         matching elements to parameters in the order returned by `Parameters.free()`, so non-free
         attributes such as initial states can be declared in any order.
@@ -140,9 +192,12 @@ def reset(self, parameters=None, data=None):
 
         """
         if self.__run__:
-            self.dependent.fill(0)
+            if isinstance(self.dependent, np.ndarray):  # a SessionWrapper model may return none
+                self.dependent.fill(0)
             self.simulation = []
-            self.parameters = copy.deepcopy(self.__init_parameters__)
+            self.parameters = restore_parameters(
+                self.__init_parameters__, self.parameters
+            )
             self.__run__ = False
         # if dict, update using parameters update method
         if isinstance(parameters, dict) or isinstance(parameters, pd.Series):
diff --git a/cpm/hierarchical/_chains.py b/cpm/hierarchical/_chains.py
new file mode 100644
index 0000000..8a9bb2d
--- /dev/null
+++ b/cpm/hierarchical/_chains.py
@@ -0,0 +1,43 @@
+"""The random starting priors of the chains of the hierarchical methods."""
+
+import numpy as np
+
+
+def starting_priors(names, bounds, priors):
+    """
+    Draw a random starting prior for each parameter, for every chain after the first.
+
+    Within finite bounds, the mean is a Beta(2, 2) draw stretched over the bounds,
+    and the standard deviation a Beta(2, 2) draw stretched over half of their range.
+    A parameter with an infinite bound instead starts from a draw of its prior when
+    the estimation started, with the standard deviation of that prior. All draws
+    come from NumPy's global random generator, so `numpy.random.seed` reproduces them.
+
+    Parameters
+    ----------
+    names : list
+        The names of the free parameters.
+    bounds : tuple
+        The lower and upper bounds of the free parameters, in the order of `names`.
+    priors : dict
+        The prior of each free parameter when the estimation started.
+
+    Returns
+    -------
+    dict
+        The mean and standard deviation of each starting prior, for `Parameters.update_prior`.
+    """
+    updates = {}
+    for i, name in enumerate(names):
+        lower, upper = bounds[0][i], bounds[1][i]
+        if np.isfinite(lower) and np.isfinite(upper):
+            updates[name] = {
+                "mean": lower + np.random.beta(a=2, b=2) * (upper - lower),
+                "sd": np.random.beta(a=2, b=2) * (upper - lower) / 2,
+            }
+        else:
+            updates[name] = {
+                "mean": float(priors[name].rvs()),
+                "sd": float(priors[name].std()),
+            }
+    return updates
diff --git a/cpm/hierarchical/empirical.py b/cpm/hierarchical/empirical.py
index 3d8fff5..2e5f605 100644
--- a/cpm/hierarchical/empirical.py
+++ b/cpm/hierarchical/empirical.py
@@ -2,6 +2,7 @@
 import pandas as pd
 import copy
 from ..core.diagnostics import convergence_diagnostics_plots, parameter_bounds
+from ._chains import starting_priors
 
 
 class EmpiricalBayes:
@@ -19,7 +20,7 @@ class EmpiricalBayes:
     tolerance : float, optional
         The tolerance for convergence. Default is 1e-6.
     chain : int, optional
-        The number of random parameter initialisations. Default is 4.
+        The number of random parameter initialisations. Default is 4. The first chain starts from the priors of the model, and every later chain from priors drawn at random within the bounds of the parameters; `numpy.random.seed` makes them reproducible.
     quiet : bool, optional
         Whether to suppress the output. Default is False.
 
@@ -370,17 +371,13 @@ def optimise(self):
 
         output = []
         parameter_names = self.optimiser.model.parameters.free()
-        rng = np.random.default_rng()
+        # the priors the estimation starts from, before any chain updates them
+        priors = {name: getattr(self.optimiser.model.parameters, name).prior for name in parameter_names}
 
         for chain in range(self.chain):
             ## select a random starting point for each chain
             if chain > 0:
-                population_updates = {}
-                for i, name in enumerate(parameter_names):
-                    population_updates[name] = {
-                        "mean": rng.beta(a=2, b=2, size=1) * self.__bounds__[1][i],
-                        "sd": rng.beta(a=2, b=2, size=1) * (self.__bounds__[1][i] / 2),
-                    }
+                population_updates = starting_priors(parameter_names, self.__bounds__, priors)
                 self.optimiser.model.parameters.update_prior(**population_updates)
 
             if self.quiet is False:
diff --git a/cpm/hierarchical/variational.py b/cpm/hierarchical/variational.py
index 9cef234..dc5a0b2 100644
--- a/cpm/hierarchical/variational.py
+++ b/cpm/hierarchical/variational.py
@@ -8,6 +8,7 @@
 
 from ..generators import Parameters
 from ..core.diagnostics import convergence_diagnostics_plots, parameter_bounds
+from ._chains import starting_priors
 
 
 class VariationalBayes:
@@ -27,7 +28,7 @@ class VariationalBayes:
     tolerance_param : float, optional
         The tolerance for convergence with respect to the "normalized" means of parameters. Default is 1e-3.
     chain : int, optional
-        The number of random parameter initialisations. Default is 4.
+        The number of random parameter initialisations. Default is 4. The first chain starts from the priors of the model, and every later chain from priors drawn at random within the bounds of the parameters; `numpy.random.seed` makes them reproducible.
     hyperpriors: dict, optional
         A dictionary of given parameter values of the prior distributions on the population-level parameters (means mu and precisions tau). See Notes for details. Default is None.
     convergence : str, optional
@@ -663,17 +664,13 @@ def optimise(self):
         """
         output = []
         parameter_names = self.optimiser.model.parameters.free()
-        rng = np.random.default_rng()
+        # the priors the estimation starts from, before any chain updates them
+        priors = {name: getattr(self.optimiser.model.parameters, name).prior for name in parameter_names}
 
         for chain in range(self.chain):
             ## select a random starting point for each chain to avoid local minima
             if chain > 0:
-                population_updates = {}
-                for i, name in enumerate(parameter_names):
-                    population_updates[name] = {
-                        "mean": rng.beta(a=2, b=2, size=1) * self.__bounds__[1][i],
-                        "sd": rng.beta(a=2, b=2, size=1) * (self.__bounds__[1][i] / 2),
-                    }
+                population_updates = starting_priors(parameter_names, self.__bounds__, priors)
                 self.optimiser.model.parameters.update_prior(**population_updates)
 
             if self.__quiet__ is False:
diff --git a/cpm/models/activation.py b/cpm/models/activation.py
index 2ea53d1..4bbcec9 100644
--- a/cpm/models/activation.py
+++ b/cpm/models/activation.py
@@ -1,4 +1,8 @@
 import numpy as np
+from ..core._jit import kernels as _kernel_module
+
+## the formulas, as plain Python (numba is never needed for the classes)
+_kernels = _kernel_module("cpm.models.kernels", python=True)
 
 __all__ = ["SigmoidActivation", "CompetitiveGating", "ProspectUtility", "Offset"]
 
@@ -45,7 +49,7 @@ def compute(self):
         numpy.ndarray
             The computed activation value.
         """
-        return np.asarray(1 / (1 + np.exp(-self.input * self.weights)))
+        return np.asarray(_kernels.sigmoid_activation(self.input, self.weights))
 
 
 class CompetitiveGating:
@@ -114,12 +118,8 @@ def compute(self):
         array_like
             The values updated with the attentional gain and stimulus vector.
         """
-        self.gain = self.input * self.salience
-        self.gain = self.gain**self.P
-        self.gain = self.gain / np.sum(self.gain) ** (1 / self.P)
-        for i in range(self.values.shape[0]):
-            for k in range(self.values.shape[1]):
-                self.values[i, k] = self.values[i, k] * self.gain[k]
+        self.gain = _kernels.gating_gain(self.input, self.salience, self.P)
+        self.values[:] = _kernels.gate(self.values, self.gain)
         return self.values
 
     def __call__(self):
@@ -260,22 +260,31 @@ def __init__(
         weighting="tk",
         **kwargs,
     ):
-        self.magnitudes = np.asarray(magnitudes.copy())
-        self.magnitudes = np.array(
-            [
-                np.array(self.magnitudes[i], dtype=float)
-                for i in range(self.magnitudes.shape[0])
-            ],
-            dtype=object,
-        )
-        self.probabilities = np.asarray(probabilities.copy())
-        self.probabilities = np.array(
-            [
-                np.array(self.probabilities[i], dtype=float)
-                for i in range(self.probabilities.shape[0])
-            ],
-            dtype=object,
-        )
+        ## outcomes with the same number of outcomes per option are kept as float
+        ## arrays and computed at once; anything else as an array of arrays
+        try:
+            self.magnitudes = np.array(magnitudes, dtype=float)
+            self.probabilities = np.array(probabilities, dtype=float)
+            self.__regular = self.magnitudes.ndim > 0
+        except (TypeError, ValueError):
+            self.__regular = False
+        if not self.__regular:
+            self.magnitudes = np.asarray(magnitudes.copy())
+            self.magnitudes = np.array(
+                [
+                    np.array(self.magnitudes[i], dtype=float)
+                    for i in range(self.magnitudes.shape[0])
+                ],
+                dtype=object,
+            )
+            self.probabilities = np.asarray(probabilities.copy())
+            self.probabilities = np.array(
+                [
+                    np.array(self.probabilities[i], dtype=float)
+                    for i in range(self.probabilities.shape[0])
+                ],
+                dtype=object,
+            )
         self.alpha = alpha
         if beta is not None:
             self.beta = beta
@@ -293,18 +302,12 @@ def __init__(
             raise ValueError("magnitudes and probabilities do not have the same shape.")
 
         # Choose weighting function based on the argument
-        if weighting == "tk":
-            self.__weighting_fun = self.__weighting_tk
-        elif weighting == "power":
-            self.__weighting_fun = self.__weighting_power
-        elif weighting == "prelec":
-            self.__weighting_fun = self.__weighting_prelec
-        elif weighting == "gw":
-            self.__weighting_fun = self.__weighting_gw
-        else:
+        if weighting not in _kernels.WEIGHTING:
             raise ValueError(
                 "Invalid weighting type. Must be one of: 'tk', 'power', 'prelec', 'gw'."
             )
+        self.__weighting_code = _kernels.WEIGHTING[weighting]
+        self.__weighting_fun = self.__weighting
 
         if utility_curve is None:
             self.__utility_curve = self.__utility_power
@@ -324,31 +327,16 @@ def __utility_power(self, x=None, alpha=None, beta=None, lambda_loss=None):
         if x is None:
             raise ValueError("Magnitudes cannot be None.")
         x = np.asarray(x, dtype=float)
-        expected = np.zeros_like(x, dtype=float)
-        gains = x >= 0
-        losses = ~gains
-        expected[gains] = np.power(x[gains], self.alpha)
-        expected[losses] = -self.lambda_loss * np.power(-x[losses], self.beta)
-        return expected
-
-    def __weighting_tk(self, x=None, magnitudes=None):
-        # Vectorized implementation for speed
-        powers = np.where(np.asarray(magnitudes) > 0, self.gamma, self.delta)
-        # x is an array of probabilities, powers is an array of exponents
-        numerator = np.power(x, powers)
-        denominator = np.power(numerator + np.power(1 - x, powers), 1 / powers)
-        return numerator / denominator
-
-    def __weighting_power(self, x=None, magnitudes=None):
-        return np.power(x, self.gamma)
-
-    def __weighting_prelec(self, x=None, magnitudes=None):
-        return np.exp(-self.delta * np.power(-np.log(x), self.gamma))
-
-    def __weighting_gw(self, x=None, magnitudes=None):
-        numerator = self.delta * np.power(x, self.gamma)
-        denominator = numerator + np.power(1 - x, self.gamma)
-        return numerator / denominator
+        return _kernels.prospect_utility(x, self.alpha, self.beta, self.lambda_loss)
+
+    def __weighting(self, x=None, magnitudes=None):
+        # the weighting function chosen with `weighting`; the magnitudes decide
+        # between gamma and delta for the Tversky & Kahneman function
+        if magnitudes is not None:
+            magnitudes = np.asarray(magnitudes)
+        return _kernels.prospect_weight(
+            x, magnitudes, self.gamma, self.delta, self.__weighting_code
+        )
 
     def weight_probability(self, x, **kwargs):
         return self.__weighting_fun(x, **kwargs)
@@ -362,6 +350,8 @@ def compute(self):
         numpy.ndarray
             The computed expected utility of each choice option.
         """
+        if self.__regular:
+            return self.__compute_regular()
         # Determine the utilities of the potential outcomes, for each choice option and each trial.
         self.utilities = np.array(
             [
@@ -388,6 +378,33 @@ def compute(self):
         )
         return self.expected_utility
 
+    def __compute_regular(self):
+        """`compute` for float arrays: all options at once."""
+        options = self.shape[0]
+        self.weights = self.__weighting_fun(x=self.probabilities, magnitudes=self.magnitudes)
+        if self.__utility_curve == self.__utility_power:
+            self.utilities = self.__utility_power(x=self.magnitudes)
+            self.expected_utility = _kernels.expected_utility(self.weights, self.utilities)
+            return self.expected_utility
+        ## a user-supplied utility curve is called for each option, as before
+        self.utilities = [
+            self.__utility_curve(
+                x=self.magnitudes[j], alpha=self.alpha, lambda_loss=self.lambda_loss
+            )
+            for j in range(options)
+        ]
+        try:
+            utilities = np.asarray(self.utilities, dtype=float)
+        except (TypeError, ValueError):
+            utilities = None
+        if utilities is not None and utilities.shape == np.shape(self.weights):
+            self.expected_utility = _kernels.expected_utility(self.weights, utilities)
+        else:  # utilities of a shape of their own: summed for each option
+            self.expected_utility = np.array(
+                [np.sum(self.weights[j] * self.utilities[j]) for j in range(options)],
+            )
+        return self.expected_utility
+
     def __call__(self):
         return self.compute()
 
@@ -443,7 +460,7 @@ def compute(self):
         numpy.ndarray
             The stimulus representation (vector) with offset added to the requested element.
         """
-        self.output[self.index] += self.offset
+        _kernels.add_offset(self.output, self.offset, self.index)
         return self.output
 
     def __call__(self):
diff --git a/cpm/models/attention.py b/cpm/models/attention.py
index 3671dd5..35179b5 100644
--- a/cpm/models/attention.py
+++ b/cpm/models/attention.py
@@ -1,4 +1,8 @@
 import numpy as np
+from ..core._jit import kernels as _kernel_module
+
+## the formulas, as plain Python (numba is never needed for the classes)
+_kernels = _kernel_module("cpm.models.kernels", python=True)
 
 __all__ = ["RapidAttentionShift"]
 
@@ -102,12 +106,10 @@ def compute(self):
         ndarray
             Gain update, a 1D array of length n_stimuli.
         """
-        activations = self.weights * self.input
-        a_power = self.gain ** (self.P - 1)
-        attention = np.outer(self.predictions, a_power)
-        out = (activations - attention) * self.error[:, np.newaxis]
-        out_sum = out.sum(axis=0)
-        self.delta_gain = self.rho * (self.pnorm**-1) * out_sum
+        self.delta_gain = _kernels.rapid_attention_shift(
+            self.weights, self.predictions, self.input, self.error, self.gain,
+            self.pnorm, self.P, self.rho,
+        )
         return self.delta_gain
 
     def reset(self):
diff --git a/cpm/models/decision.py b/cpm/models/decision.py
index 009cbcc..ed3c20a 100644
--- a/cpm/models/decision.py
+++ b/cpm/models/decision.py
@@ -1,6 +1,10 @@
 import numpy as np
 import warnings
 from ..generators import Value
+from ..core._jit import kernels as _kernel_module
+
+## the formulas, as plain Python (numba is never needed for the classes)
+_kernels = _kernel_module("cpm.models.kernels", python=True)
 
 __all__ = [
     "Softmax",
@@ -73,11 +77,11 @@ def __init__(self, temperature=None, xi=None, activations=None, **kwargs):
         else:
             self.activations = np.zeros(1)
         ## Throw error if activations contain missing values of infities
-        if np.isnan(self.activations).any():
-            raise ValueError(
-                "Activations contain NaN values. Please remove or impute missing values."
-            )
-        if np.isinf(self.activations).any():
+        if not np.isfinite(self.activations).all():
+            if np.isnan(self.activations).any():
+                raise ValueError(
+                    "Activations contain NaN values. Please remove or impute missing values."
+                )
             raise ValueError(
                 "Activations contain infinite values. Please remove or impute infinite values."
             )
@@ -94,17 +98,21 @@ def __init__(self, temperature=None, xi=None, activations=None, **kwargs):
         self.__run__ = False
 
     def compute(self):
-        """
+        r"""
         Compute the policies based on the activations and temperature.
 
         Returns
         -------
         numpy.ndarray: Array of computed policies.
+
+        Notes
+        -----
+        Where the exponentials would overflow (or all underflow), that is where the
+        largest scaled activation is beyond ±700, the policies are computed as
+        :math:`e^{\beta x_i - m} / \sum_j e^{\beta x_j - m}` with :math:`m` the
+        largest scaled activation, which is the same function without overflow.
         """
-        output = np.exp(self.activations * self.temperature) / np.sum(
-            np.exp(self.activations * self.temperature)
-        )
-        self.policies = output
+        self.policies = _kernels.softmax(self.activations, self.temperature)
 
         if np.isnan(self.policies).any():
             self.policies[np.isnan(self.policies)] = 1
@@ -192,7 +200,7 @@ def irreducible_noise(self):
             policies = self.policies
         else:
             policies = self.compute()
-        policies = policies * (1 - self.xi) + (self.xi / self.shape[0])
+        policies = _kernels.irreducible_noise(policies, self.xi)
         self.policies = policies
         return policies
 
@@ -278,7 +286,7 @@ def compute(self):
         output: ndarray
             A 2D array of outputs computed using the sigmoid function.
         """
-        output = 1 / (1 + np.exp((self.activations - self.beta) * -self.temperature))
+        output = _kernels.sigmoid(self.activations, self.temperature, self.beta)
         self.policies = output
 
         if np.isnan(self.policies).any():
@@ -374,17 +382,7 @@ def compute(self):
         output: ndarray
             A 2D array of outputs computed using the greedy rule.
         """
-        output = self.activations.sum(axis=1)
-        policies = np.zeros(output.shape)
-        maximum = np.max(output)
-        policies[output != maximum] = self.epsilon * 1
-        policies[output == maximum] = 1 - (output.shape[0] - 1) * self.epsilon
-        policies[output <= 0] = 0
-        if np.all(policies == 0):
-            policies.fill(1 / policies.shape[0])
-        else:
-            policies = policies / policies.sum()  # normalise
-        self.policies = policies
+        self.policies = _kernels.greedy(self.activations, self.epsilon)
         self.run = True
         return self.policies
 
@@ -495,14 +493,9 @@ def __init__(
         self.run = False
 
     def compute(self):
-        output = np.zeros(self.shape[0])
-        values = self.activations * self.temperature_a
-        kernels = self.kernel * self.temperature_k
-        # activation of output unit for action/outcome
-        nominator = np.exp(np.sum(values, axis=1) * kernels)
-        # denominator term for scaling
-        denominator = np.sum(np.exp(np.sum(values, axis=1) * kernels))
-        output = nominator / denominator
+        output = _kernels.choice_kernel(
+            self.activations, self.kernel, self.temperature_a, self.temperature_k
+        )
         self.policies = output
         self.run = True
         return output
diff --git a/cpm/models/kernels.py b/cpm/models/kernels.py
new file mode 100644
index 0000000..05a315a
--- /dev/null
+++ b/cpm/models/kernels.py
@@ -0,0 +1,520 @@
+r"""
+The computations of the building blocks in `cpm.models`, as functions.
+
+The classes in :mod:`cpm.models.decision`, :mod:`cpm.models.learning`,
+:mod:`cpm.models.activation` and :mod:`cpm.models.attention` compute one step
+of a model and are convenient to write per-trial models with. Their formulas
+live here, once, as functions on numpy arrays and numbers, and the classes
+compute with them: each class converts and checks its input, calls the function
+it is named after, and keeps the result in its attributes.
+
+The functions are written with numpy operations that numba can also compile, so
+that loops over trials that are compiled as a whole, such as the models of the
+built-in applications (see :class:`cpm.generators.SessionWrapper`), can call
+them too. With numba installed, the functions of this module are compiled on
+first use (and cached on disk); the classes use a plain-Python copy of them
+(see `cpm.core._jit.kernels`), which never needs numba. Both give the same
+results.
+
+`logistic`, `p_second`, `log_softmax` and `choose` have no class counterpart:
+they are for compiled loops. The softmax switches to an equivalent form that
+cannot overflow where the largest scaled activation is beyond ±700; `logistic`
+and `p_second` cannot overflow.
+
+Functions that update values in place say so; all others return new arrays.
+
+Examples
+--------
+A Rescorla-Wagner learner with a softmax policy, compiled as a whole:
+
+>>> import numpy as np
+>>> from numba import njit
+>>> from cpm.models import kernels
+>>> @njit
+... def session(alpha, beta, rewards, choices):
+...     values = np.zeros(2)
+...     p_right = np.empty(len(choices))
+...     for t in range(len(choices)):
+...         p_right[t] = kernels.p_second(beta, values[0], values[1])
+...         values[choices[t]] += alpha * (rewards[t] - values[choices[t]])
+...     return p_right
+>>> session(0.3, 2.0, np.array([1.0, 0.0, 1.0]), np.array([1, 1, 0]))
+array([0.5       , 0.64565631, 0.60348325])
+"""
+
+import math
+
+import numpy as np
+
+from ..core import _jit
+
+njit = _jit.decorator(globals())
+
+__all__ = [
+    "logistic",
+    "p_second",
+    "softmax",
+    "log_softmax",
+    "irreducible_noise",
+    "softmax_noise",
+    "sigmoid",
+    "greedy",
+    "choice_kernel",
+    "choose",
+    "delta_rule",
+    "separable_rule",
+    "q_learning",
+    "humble_teacher_change",
+    "humble_teacher",
+    "sarsa_trace",
+    "sarsa_trace_update",
+    "sigmoid_activation",
+    "gating_gain",
+    "gate",
+    "competitive_gating",
+    "prospect_utility",
+    "weight_tk",
+    "weight_power",
+    "weight_prelec",
+    "weight_gw",
+    "prospect_weight",
+    "expected_utility",
+    "add_offset",
+    "offset",
+    "rapid_attention_shift",
+]
+
+
+## ----------------------------------------------------------------------------
+## decision rules (cpm.models.decision)
+
+
+@njit
+def logistic(x):
+    """The logistic function, 1 / (1 + exp(-x)), without overflow."""
+    if x >= 0:
+        return 1.0 / (1.0 + math.exp(-x))
+    e = math.exp(x)
+    return e / (1.0 + e)
+
+
+@njit
+def p_second(beta, value_0, value_1):
+    """
+    The probability of the second of two options under a softmax.
+
+    Equals ``softmax(np.array([value_0, value_1]), beta)[1]``, computed as the
+    logistic of the scaled value difference.
+    """
+    return logistic(beta * (value_1 - value_0))
+
+
+@njit
+def softmax(values, beta):
+    r"""
+    The softmax policy, :math:`e^{\beta x_i} / \sum_j e^{\beta x_j}`, of :class:`cpm.models.decision.Softmax`.
+
+    The exponentials of the scaled activations are divided by their sum. Where
+    the largest scaled activation is beyond ±700, and the exponentials would
+    overflow (or all underflow), the largest one is subtracted first, which gives
+    the same function without overflow.
+
+    Parameters
+    ----------
+    values : numpy.ndarray
+        The activations, a 1D array.
+    beta : float
+        The inverse temperature.
+
+    Returns
+    -------
+    numpy.ndarray
+        The policy. If the scaled activations contain NaN, it is NaN throughout,
+        which `Softmax` then replaces.
+    """
+    scaled = values * beta
+    top = np.max(scaled) if scaled.size else 0.0
+    if -700.0 < top < 700.0:
+        output = np.exp(scaled)
+    else:
+        output = np.exp(scaled - top)
+    output /= output.sum()
+    return output
+
+
+@njit
+def log_softmax(values, beta):
+    """The logarithm of `softmax`, computed without forming the probabilities."""
+    n = values.shape[0]
+    out = np.empty(n)
+    top = -np.inf
+    for i in range(n):
+        out[i] = values[i] * beta
+        if out[i] > top:
+            top = out[i]
+    total = 0.0
+    for i in range(n):
+        total += math.exp(out[i] - top)
+    norm = top + math.log(total)
+    for i in range(n):
+        out[i] -= norm
+    return out
+
+
+@njit
+def irreducible_noise(policy, xi):
+    """A policy with irreducible noise `xi`, as `Softmax.irreducible_noise` computes it."""
+    return policy * (1 - xi) + (xi / policy.shape[0])
+
+
+@njit
+def softmax_noise(values, beta, xi):
+    """The softmax with irreducible noise, as `Softmax.irreducible_noise`."""
+    return irreducible_noise(softmax(values, beta), xi)
+
+
+@njit
+def sigmoid(activations, temperature, bias):
+    """The policy of :class:`cpm.models.decision.Sigmoid` (``Sigmoid(temperature, activations, beta=bias)``)."""
+    return 1 / (1 + np.exp((activations - bias) * -temperature))
+
+
+@njit
+def greedy(activations, epsilon):
+    """
+    The policy of :class:`cpm.models.decision.GreedyRule`.
+
+    Parameters
+    ----------
+    activations : numpy.ndarray
+        A 2D array, one row per action, summed over columns.
+    epsilon : float
+        The exploration parameter.
+    """
+    output = np.sum(activations, axis=1)
+    policies = np.zeros(output.shape)
+    maximum = np.max(output)
+    policies[output != maximum] = epsilon * 1
+    policies[output == maximum] = 1 - (output.shape[0] - 1) * epsilon
+    policies[output <= 0] = 0
+    if np.all(policies == 0):
+        policies.fill(1 / policies.shape[0])
+    else:
+        policies = policies / policies.sum()  # normalise
+    return policies
+
+
+@njit
+def choice_kernel(activations, kernel, temperature_activations, temperature_kernel):
+    """
+    The policy of :class:`cpm.models.decision.ChoiceKernel`.
+
+    Note that `ChoiceKernel` multiplies the summed activations with the scaled
+    kernel inside the exponential.
+    """
+    values = activations * temperature_activations
+    kernels = kernel * temperature_kernel
+    nominator = np.exp(np.sum(values, axis=1) * kernels)
+    denominator = np.sum(np.exp(np.sum(values, axis=1) * kernels))
+    return nominator / denominator
+
+
+@njit
+def choose(policy, uniform):
+    """
+    Sample an option from a policy, given a uniform random number in [0, 1).
+
+    This is the inverse-CDF step of ``numpy.random.choice(len(policy),
+    p=policy)``, which is how the `choice()` methods of the decision classes
+    sample. With ``uniform = numpy.random.random_sample()``, it returns the
+    option `numpy.random.choice` would have returned, so simulations can draw
+    all uniforms with NumPy before a compiled loop and still be reproducible
+    with `numpy.random.seed`, and identical to the per-trial models.
+    """
+    n = policy.shape[0]
+    cdf = np.empty(n)
+    total = 0.0
+    for i in range(n):
+        total += policy[i]
+        cdf[i] = total
+    last = cdf[n - 1]
+    index = 0
+    for i in range(n):
+        if cdf[i] / last <= uniform:
+            index += 1
+    if index > n - 1:
+        index = n - 1
+    return index
+
+
+## ----------------------------------------------------------------------------
+## learning rules (cpm.models.learning)
+
+
+@njit
+def delta_rule(weights, feedback, input, alpha):
+    """
+    The change in the weights and the prediction errors of :class:`cpm.models.learning.DeltaRule`.
+
+    Parameters
+    ----------
+    weights : numpy.ndarray
+        A 2D array, one row per outcome.
+    feedback : numpy.ndarray
+        The teaching signal, one per outcome.
+    input : numpy.ndarray
+        The stimulus representation, one value per column of `weights`.
+    alpha : float
+        The learning rate.
+
+    Returns
+    -------
+    change : numpy.ndarray
+        The change in `weights`, with the same shape.
+    error : numpy.ndarray
+        The summed prediction error of each outcome.
+    """
+    activations = np.sum(weights * input, axis=1)
+    error = feedback - activations
+    return alpha * error[:, np.newaxis] * input, error
+
+
+@njit
+def separable_rule(weights, feedback, input, alpha):
+    """
+    The change in the weights and the prediction errors of :class:`cpm.models.learning.SeparableRule`.
+
+    Returns
+    -------
+    change : numpy.ndarray
+        The change in `weights`, with the same shape.
+    error : numpy.ndarray
+        The prediction error of each outcome-stimulus pair, with the same shape.
+    """
+    error = feedback[:, np.newaxis] - weights
+    return alpha * error * input, error
+
+
+@njit
+def q_learning(values, reward, maximum, alpha, gamma):
+    """
+    The updated values of :class:`cpm.models.learning.QLearningRule`.
+
+    Like the class, values that are not positive are not treated as active:
+    the update of each value is scaled by 1 if it is positive, and by the value
+    itself otherwise.
+    """
+    active = values.copy()
+    active[active > 0] = 1
+    output = np.zeros(values.shape[0])
+    output += values + (alpha * (reward + gamma * maximum - values)) * active
+    return output
+
+
+@njit
+def humble_teacher_change(weights, feedback, input, alpha):
+    """The change in the weights of :class:`cpm.models.learning.HumbleTeacher`."""
+    activations = np.sum(weights * input, axis=1)
+    teacher = np.where(feedback == 0, np.minimum(-1, activations), np.maximum(1, activations))
+    return alpha * (teacher - activations)[:, np.newaxis] * input
+
+
+@njit
+def humble_teacher(weights, feedback, input, alpha):
+    """The updated weights (a new array) of :class:`cpm.models.learning.HumbleTeacher`."""
+    return weights + humble_teacher_change(weights, feedback, input, alpha)
+
+
+@njit
+def sarsa_trace(model_free_values, second_stage_values, starting_state, action,
+                reached_second_stage, reward, learning_rate, eligibility_trace):
+    """
+    The prediction errors and value changes of :class:`cpm.models.learning.SARSATrace`.
+
+    Returns
+    -------
+    stage1_prediction_error, stage2_prediction_error : float
+    model_free_change : float
+        The change of ``model_free_values[starting_state, action]``.
+    second_stage_change : float
+        The change of ``second_stage_values[reached_second_stage]``.
+    """
+    stage1 = (second_stage_values[reached_second_stage]
+              - model_free_values[starting_state, action])
+    stage2 = reward - second_stage_values[reached_second_stage]
+    return (
+        stage1,
+        stage2,
+        learning_rate * stage1 + eligibility_trace * learning_rate * stage2,
+        learning_rate * stage2,
+    )
+
+
+@njit
+def sarsa_trace_update(model_free_values, second_stage_values, starting_state, action,
+                       reached_second_stage, reward, learning_rate, eligibility_trace):
+    """
+    `sarsa_trace`, applied to the values in place.
+
+    Parameters
+    ----------
+    model_free_values : numpy.ndarray
+        The first-stage model-free values, shape (states, actions). Updated in place.
+    second_stage_values : numpy.ndarray
+        The second-stage values, a 1D array. Updated in place.
+    starting_state, action, reached_second_stage : int
+    reward, learning_rate, eligibility_trace : float
+
+    Returns
+    -------
+    stage1_prediction_error, stage2_prediction_error : float
+    """
+    stage1, stage2, model_free_change, second_stage_change = sarsa_trace(
+        model_free_values, second_stage_values, starting_state, action,
+        reached_second_stage, reward, learning_rate, eligibility_trace,
+    )
+    model_free_values[starting_state, action] += model_free_change
+    second_stage_values[reached_second_stage] += second_stage_change
+    return stage1, stage2
+
+
+## ----------------------------------------------------------------------------
+## activation functions (cpm.models.activation)
+
+
+@njit
+def sigmoid_activation(input, weights):
+    """The activations of :class:`cpm.models.activation.SigmoidActivation`."""
+    return 1 / (1 + np.exp(-input * weights))
+
+
+@njit
+def gating_gain(input, salience, P):
+    """The normalised attentional gain of :class:`cpm.models.activation.CompetitiveGating`."""
+    gain = input * salience
+    gain = gain**P
+    return gain / np.sum(gain) ** (1 / P)
+
+
+@njit
+def gate(values, gain):
+    """The values of each stimulus scaled by its attentional gain (a new array)."""
+    return values * gain[: values.shape[1]]
+
+
+@njit
+def competitive_gating(input, values, salience, P):
+    """The gated values (a new array) of :class:`cpm.models.activation.CompetitiveGating`."""
+    return gate(values, gating_gain(input, salience, P))
+
+
+@njit
+def prospect_utility(magnitude, alpha, beta, lambda_loss):
+    r"""
+    The power utility of `ProspectUtility`: :math:`x^\alpha` for gains, :math:`-\lambda (-x)^\beta` for losses.
+
+    `magnitude` is a number or an array of any shape.
+    """
+    gains = magnitude >= 0
+    return np.where(gains, 1.0, -lambda_loss) * np.power(
+        np.abs(magnitude), np.where(gains, alpha, beta)
+    )
+
+
+@njit
+def weight_tk(probability, power):
+    """The Tversky & Kahneman (1992) weighting function with curvature `power`."""
+    numerator = np.power(probability, power)
+    denominator = np.power(numerator + np.power(1 - probability, power), 1 / power)
+    return numerator / denominator
+
+
+@njit
+def weight_power(probability, gamma):
+    """The power weighting function, p^gamma."""
+    return np.power(probability, gamma)
+
+
+@njit
+def weight_prelec(probability, gamma, delta):
+    """The Prelec (1998) weighting function."""
+    return np.exp(-delta * np.power(-np.log(probability), gamma))
+
+
+@njit
+def weight_gw(probability, gamma, delta):
+    """The Gonzalez & Wu (1999) weighting function."""
+    numerator = delta * np.power(probability, gamma)
+    denominator = numerator + np.power(1 - probability, gamma)
+    return numerator / denominator
+
+
+## the weighting functions by number, for `prospect_weight`
+WEIGHTING = {"tk": 0, "power": 1, "prelec": 2, "gw": 3}
+
+
+@njit
+def prospect_weight(probability, magnitude, gamma, delta, weighting):
+    """
+    The decision weights of outcomes, as `ProspectUtility` computes them.
+
+    Parameters
+    ----------
+    probability, magnitude : float or numpy.ndarray
+        The probabilities and magnitudes of the outcomes, numbers or arrays of the
+        same shape.
+    gamma, delta : float
+        The parameters of the weighting function. With the Tversky & Kahneman
+        function, `gamma` applies to gains (positive magnitudes) and `delta` to
+        losses and zero magnitudes, as in `ProspectUtility`.
+    weighting : int
+        The weighting function: ``WEIGHTING[name]`` for name in "tk", "power",
+        "prelec" and "gw".
+    """
+    if weighting == 0:
+        return weight_tk(probability, np.where(magnitude > 0, gamma, delta))
+    if weighting == 1:
+        return weight_power(probability, gamma)
+    if weighting == 2:
+        return weight_prelec(probability, gamma, delta)
+    return weight_gw(probability, gamma, delta)
+
+
+@njit
+def expected_utility(weights, utilities):
+    """
+    The expected utility of each option: the sum of its weighted utilities.
+
+    `weights` and `utilities` have one row per option (or one number per option,
+    for options with a single outcome).
+    """
+    weighted = weights * utilities
+    return weighted.reshape(weighted.shape[0], -1).sum(axis=1)
+
+
+@njit
+def add_offset(array, offset, index):
+    """Add `offset` to element `index` of `array`, in place, as :class:`cpm.models.activation.Offset` does."""
+    array[index] += offset
+    return array
+
+
+@njit
+def offset(input, offset, index):
+    """The output of :class:`cpm.models.activation.Offset`: a copy of `input` with `offset` added to element `index`."""
+    return add_offset(input.copy(), offset, index)
+
+
+## ----------------------------------------------------------------------------
+## attention (cpm.models.attention)
+
+
+@njit
+def rapid_attention_shift(weights, predictions, input, error, gain, pnorm, P, rho):
+    """The change in the attention gain of :class:`cpm.models.attention.RapidAttentionShift`."""
+    activations = weights * input
+    a_power = gain ** (P - 1)
+    attention = np.outer(predictions, a_power)
+    out = (activations - attention) * error[:, np.newaxis]
+    out_sum = out.sum(axis=0)
+    return rho * (pnorm**-1) * out_sum
diff --git a/cpm/models/learning.py b/cpm/models/learning.py
index f5c15bf..b416ed0 100644
--- a/cpm/models/learning.py
+++ b/cpm/models/learning.py
@@ -1,4 +1,8 @@
 import numpy as np
+from ..core._jit import kernels as _kernel_module
+
+## the formulas, as plain Python (numba is never needed for the classes)
+_kernels = _kernel_module("cpm.models.kernels", python=True)
 
 __all__ = [
     "DeltaRule",
@@ -9,6 +13,25 @@
 ]
 
 
+def _leading(values, n):
+    """The first `n` elements of `values` as a float array (the loops this replaces read only those)."""
+    values = np.asarray(values, dtype=float)
+    if values.shape[0] < n:  # which the loops raised as well, rather than broadcast
+        raise IndexError(
+            f"Expected {n} values, one per row or column of the weights, not {values.shape[0]}."
+        )
+    return values if values.shape[0] == n else values[:n]
+
+
+def _assign(rule, name, values):
+    """Set an array attribute, keeping its dtype as element-wise assignment into it did."""
+    current = getattr(rule, name)
+    if current.dtype == values.dtype:
+        setattr(rule, name, values)
+    else:
+        current[...] = values
+
+
 class DeltaRule:
     r"""
     DeltaRule class computes the prediction error for a given input and target value.
@@ -125,13 +148,11 @@ def compute(self):
             It has the same shape as the weights input argument.
         """
 
-        for i in range(self.shape[0]):
-            # calculate summed error for a given output unit
-            activations = np.sum(self.weights[i] * self.input)
-            self.error[i] = self.teacher[i] - activations
-            for j in range(self.shape[1]):
-                # calcualte the change on weights
-                self.weights[i, j] = self.alpha * self.error[i] * self.input[j]
+        rows, columns = self.shape
+        change, self.error = _kernels.delta_rule(
+            self.weights, _leading(self.teacher, rows), _leading(self.input, columns), self.alpha
+        )
+        _assign(self, "weights", change)
         self.__run__ = True
         return self.weights
 
@@ -261,11 +282,12 @@ def compute(self):
         The prediction error for each stimuli-outcome mapping before the update is stored in `error`,
         which has the same shape as the weights.
         """
-        for i in range(self.shape[0]):
-            for j in range(self.shape[1]):
-                # separable prediction error for each outcome-stimulus pair
-                self.error[i, j] = self.teacher[i] - self.weights[i, j]
-                self.weights[i, j] = self.alpha * self.error[i, j] * self.input[j]
+        rows, columns = self.shape
+        # separable prediction error for each outcome-stimulus pair
+        change, self.error = _kernels.separable_rule(
+            self.weights, _leading(self.teacher, rows), _leading(self.input, columns), self.alpha
+        )
+        _assign(self, "weights", change)
         self.__run__ = True
         return self.weights
 
@@ -381,21 +403,7 @@ def compute(self):
             The computed output values.
         """
 
-        active = self.values.copy()
-        active[active > 0] = 1
-        output = np.zeros(self.values.shape[0])
-
-        for i in range(self.values.shape[0]):
-            output[i] += (
-                self.values[i]
-                + (
-                    self.alpha
-                    * (self.reward + self.gamma * self.maximum - self.values[i])
-                )
-                * active[i]
-            )
-
-        return output
+        return _kernels.q_learning(self.values, self.reward, self.maximum, self.alpha, self.gamma)
 
     def __repr__(self):
         return f"QLearningRule(alpha={self.alpha},\n gamma={self.gamma},\n values={self.values},\n reward={self.reward},\n maximum={self.maximum})"
@@ -487,10 +495,10 @@ def __init__(self, alpha=None, weights=None, feedback=None, input=None, **kwargs
         self.teacher = feedback
         self.input = np.asarray(input)
         self.shape = self.weights.shape
-        self.delta = np.zeros(self.weights.shape)
         if len(self.shape) == 1:
             self.shape = (1, self.shape[0])
             self.weights = np.array([self.weights])
+        self.delta = np.zeros(self.shape)
 
     def compute(self):
         """
@@ -502,15 +510,11 @@ def compute(self):
             The updated weights matrix.
         """
 
-        for i in range(self.shape[0]):
-            activations = np.sum(self.weights[i] * self.input)
-            for j in range(self.shape[1]):
-                if self.teacher[i] == 0:
-                    teacher = np.min([-1, activations])
-                else:
-                    teacher = np.max([1, activations])
-                self.delta[i, j] = self.alpha * (teacher - activations) * self.input[j]
-                self.weights[i, j] += self.delta[i, j]
+        rows, columns = self.shape
+        self.delta[:] = _kernels.humble_teacher_change(
+            self.weights, _leading(self.teacher, rows), _leading(self.input, columns), self.alpha
+        )
+        np.add(self.weights, self.delta, out=self.weights, casting="unsafe")
         return self.weights
 
 
@@ -640,23 +644,20 @@ def compute(self):
         action = self.action
         planet = self.reached_second_stage
 
-        self.stage1_prediction_error = (
-            self.second_stage_values[planet] - self.model_free_values[state, action]
+        (
+            self.stage1_prediction_error,
+            self.stage2_prediction_error,
+            model_free_change,
+            second_stage_change,
+        ) = _kernels.sarsa_trace(
+            self.model_free_values, self.second_stage_values, state, action, planet,
+            self.reward, self.learning_rate, self.eligibility_trace,
         )
-        self.stage2_prediction_error = self.reward - self.second_stage_values[planet]
 
         self.model_free_delta = np.zeros_like(self.model_free_values)
         self.planet_value_delta = np.zeros_like(self.second_stage_values)
-
-        self.model_free_delta[state, action] = (
-            self.learning_rate * self.stage1_prediction_error
-            + self.eligibility_trace
-            * self.learning_rate
-            * self.stage2_prediction_error
-        )
-        self.planet_value_delta[planet] = (
-            self.learning_rate * self.stage2_prediction_error
-        )
+        self.model_free_delta[state, action] = model_free_change
+        self.planet_value_delta[planet] = second_stage_change
 
         return self.model_free_delta, self.planet_value_delta
 
diff --git a/cpm/optimisation/minimise.py b/cpm/optimisation/minimise.py
index 92df6b9..a979f7f 100644
--- a/cpm/optimisation/minimise.py
+++ b/cpm/optimisation/minimise.py
@@ -1,4 +1,5 @@
 from scipy.stats import norm, bernoulli, multinomial
+from scipy import special
 import numpy as np
 
 __all__ = ["LogLikelihood", "CrossEntropy", "Distance", "Discrete"]
@@ -31,6 +32,11 @@ def check_nan_and_bounds_in_input(predicted, observed):
         "pred_inf": "Predicted values contain Inf at indices {}. This is often due to out-of-bounds parameter values during model fitting. Investigate the parameter values and consider setting bounds or rescaling the model input to prevent this issue.",
         "obs_inf": "Observed values contain Inf at indices {}. This is often due to issues in your dataset. Consider handling such values appropriately before fitting the model.",
     }
+    ## one pass over each array in the common case; the checks below name the problem
+    if np.isfinite(predicted_s).all() and np.isfinite(observed_s).all():
+        if predicted_s.shape != observed_s.shape:
+            raise ValueError(f"Shape mismatch: predicted shape {predicted.shape} (squeezed {predicted_s.shape}) does not match observed shape {observed.shape} (squeezed {observed_s.shape}).")
+        return predicted_s, observed_s
     if np.any(np.isnan(predicted_s)):
         idx = np.where(np.isnan(predicted_s))
         raise ValueError(error_msgs["pred_nan"].format(idx))
@@ -62,6 +68,33 @@ def check_nan_bounds_in_log(value, bound=-1e100):
     output = np.nan_to_num(output, copy=False, nan=bound, posinf=bound, neginf=bound)
     return output
 
+def _bernoulli_logpmf(k, p):
+    """
+    `scipy.stats.bernoulli.logpmf(k, p)` for probabilities in [0, 1], without scipy's argument handling.
+
+    It evaluates the same expression as scipy, ``xlogy(k, p) + xlog1py(1 - k, -p)``,
+    and gives the same values, including -inf where `k` is neither 0 nor 1, at a
+    fraction of the cost of a call to scipy's distribution machinery.
+    """
+    k = np.asarray(k)
+    p = np.asarray(p, dtype=float)
+    out = 0.0 + special.xlogy(k, p) + special.xlog1py(1 - k, -p)
+    support = (k == 0) | (k == 1)
+    if not support.all():
+        out = np.where(support, out, -np.inf)
+    return out
+
+
+## the normalising constant of scipy.stats.norm
+_NORM_PDF_LOGC = np.log(np.sqrt(2 * np.pi))
+
+
+def _standard_normal_logpdf(x):
+    """`scipy.stats.norm.logpdf(x)` for finite `x`, computed as scipy computes it."""
+    x = np.asarray(x, dtype=float)
+    return -(x**2) / 2.0 - _NORM_PDF_LOGC - np.log(1.0)
+
+
 # Define your custom objective function
 class LogLikelihood:
 
@@ -164,7 +197,7 @@ def bernoulli(predicted=None, observed=None, negative=True, **kwargs):
         ## bump up the probabilities to avoid log(0)
         np.clip(probabilities, 1e-10, 1 - 1e-10, out=probabilities)
 
-        LL = bernoulli.logpmf(k=observed.flatten(), p=probabilities)
+        LL = _bernoulli_logpmf(observed.flatten(), probabilities)
         LL = check_nan_bounds_in_log(LL, bound=bound)
         LL = np.sum(LL)
         if negative:
@@ -201,7 +234,7 @@ def continuous(predicted, observed, negative=True, **kwargs):
 
         predicted, observed = check_nan_and_bounds_in_input(predicted, observed)
         bound = -1e100
-        LL = norm.logpdf(predicted, observed, 1)
+        LL = _standard_normal_logpdf(predicted - observed)
         LL = check_nan_bounds_in_log(LL, bound=bound)
         LL = np.sum(LL)
         if negative:
diff --git a/docs/about/roadmap.md b/docs/about/roadmap.md
index b54c44f..b1bf01f 100644
--- a/docs/about/roadmap.md
+++ b/docs/about/roadmap.md
@@ -5,7 +5,7 @@ We would like to invite anyone interested in contributing to the development of
 ## Ongoing Improvements
 
 - **Performance**
-    - Integrate `numba` for JIT compilation (e.g., with [@jitclass](https://numba.pydata.org/numba-doc/dev/user/jitclass.html))
+    - Compile more of the fitting pipeline with `numba`: the loss functions and the objective function, now that the built-in models are compiled (see {doc}`/how-to/fast-session-models`)
     - Reduce code duplication and improve organization
     - Optimize `cpm.generators` for faster simulations and data compilation/export
     - Improve shared memory usage and minimize data copies
diff --git a/docs/api/applications.rst b/docs/api/applications.rst
index dda3b75..68c618a 100644
--- a/docs/api/applications.rst
+++ b/docs/api/applications.rst
@@ -5,7 +5,8 @@ cpm.applications
 
 Ready-made models from the literature. Most are subclasses of
 :class:`~cpm.generators.Wrapper`, so they can be simulated and fitted like any
-model you build yourself.
+model you build yourself. They compute all trials of a participant at once, and
+are compiled with numba if it is installed; see :doc:`/how-to/fast-session-models`.
 
 Reinforcement learning
 ----------------------
diff --git a/docs/api/generators.rst b/docs/api/generators.rst
index dfc5513..c8e3910 100644
--- a/docs/api/generators.rst
+++ b/docs/api/generators.rst
@@ -4,7 +4,8 @@ cpm.generators
 .. currentmodule:: cpm.generators
 
 The building blocks of every model: parameters and their priors, the
-:class:`Wrapper` that runs a model over the trials of one participant, and the
+:class:`Wrapper` that runs a model over the trials of one participant (or the
+:class:`SessionWrapper` for models that compute all trials at once), and the
 :class:`Simulator` that runs it over many.
 
 Parameters
@@ -26,4 +27,5 @@ Wrappers and simulators
    :nosignatures:
 
    Wrapper
+   SessionWrapper
    Simulator
diff --git a/docs/api/models.rst b/docs/api/models.rst
index d35b14f..781ad61 100644
--- a/docs/api/models.rst
+++ b/docs/api/models.rst
@@ -4,7 +4,9 @@ cpm.models
 .. currentmodule:: cpm.models
 
 The components that models are built from. Combine them inside a model
-function and pass that to :class:`~cpm.generators.Wrapper`.
+function and pass that to :class:`~cpm.generators.Wrapper`. Their formulas are
+in :mod:`cpm.models.kernels`, as functions that the classes compute with and
+that loops compiled with numba can call.
 
 Learning rules
 --------------
@@ -60,3 +62,47 @@ Utilities
    :nosignatures:
 
    utils.Nominal
+
+Kernels for compiled models
+---------------------------
+
+.. automodule:: cpm.models.kernels
+   :no-members:
+
+.. currentmodule:: cpm.models.kernels
+
+.. autosummary::
+   :toctree: generated/
+   :nosignatures:
+
+   softmax
+   log_softmax
+   p_second
+   logistic
+   irreducible_noise
+   softmax_noise
+   sigmoid
+   greedy
+   choice_kernel
+   choose
+   delta_rule
+   separable_rule
+   q_learning
+   humble_teacher_change
+   humble_teacher
+   sarsa_trace
+   sarsa_trace_update
+   sigmoid_activation
+   gating_gain
+   gate
+   competitive_gating
+   prospect_utility
+   prospect_weight
+   weight_tk
+   weight_power
+   weight_prelec
+   weight_gw
+   expected_utility
+   add_offset
+   offset
+   rapid_attention_shift
diff --git a/docs/conf.py b/docs/conf.py
index 032b0f3..40da8d4 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -183,7 +183,7 @@
         },
     ],
     "navbar_align": "left",
-    "header_links_before_dropdown": 6,
+    "header_links_before_dropdown": 7,
     "navbar_end": ["theme-switcher", "navbar-icon-links"],
     "navbar_persistent": ["search-button"],
     "use_edit_page_button": True,
diff --git a/docs/get-started/installation.md b/docs/get-started/installation.md
index 6501012..93b6270 100644
--- a/docs/get-started/installation.md
+++ b/docs/get-started/installation.md
@@ -20,6 +20,12 @@ The latest release:
 ```bash
 pip install cpm-toolbox
 ```
+
+With numba, for faster fitting (see [below](#faster-fitting-with-numba)):
+
+```bash
+pip install "cpm-toolbox[numba]"
+```
 :::
 
 :::{tab-item} Development version
@@ -28,6 +34,12 @@ The latest version from GitHub, with changes that are not released yet:
 ```bash
 pip install git+https://github.com/DevComPsy/cpm.git
 ```
+
+With numba:
+
+```bash
+pip install "cpm-toolbox[numba] @ git+https://github.com/DevComPsy/cpm.git"
+```
 :::
 
 :::{tab-item} From source
@@ -39,6 +51,8 @@ cd cpm
 pip install -e .
 ```
 
+With numba: `pip install -e ".[numba]"`.
+
 See {doc}`/about/contributing` for the development setup.
 :::
 
@@ -54,6 +68,26 @@ import cpm
 print(cpm.__version__)
 ```
 
+## Faster fitting with numba
+
+[numba](https://numba.pydata.org/) is an optional dependency that compiles the built-in models ({py:class}`~cpm.applications.reinforcement_learning.RLRW`, {py:class}`~cpm.applications.reinforcement_learning.HybridMBMF`, {py:class}`~cpm.applications.decision_making.PTSM`, {py:class}`~cpm.applications.decision_making.PTSM1992` and {py:class}`~cpm.applications.decision_making.PTSM2025`), which makes fitting and simulating them many times faster.
+Install it together with cpm:
+
+```bash
+pip install "cpm-toolbox[numba]"
+```
+
+or add it to an existing installation with the same command, or with `pip install "numba>=0.64"`.
+
+Nothing else changes: your code stays the same, and cpm uses numba whenever it can import it. Without numba, cpm runs the same models as plain Python, with the same results, only more slowly. numba matters most when a model is run many times, as in fitting many participants, hierarchical estimation or parameter recovery; for a single run, it makes little difference.
+
+- **Check whether numba is used.** cpm uses numba if `python -c "import numba"` runs without an error in the environment you run cpm in.
+- **Compilation.** The first time a built-in model runs, numba compiles it, which takes a few seconds (up to about 15 s). The result is cached on disk, so later runs, new Python sessions and parallel fits start at full speed.
+- **Limitations.** numba supports a new NumPy release some time after it comes out, and does not support PyPy. If numba cannot be installed or imported in your environment, cpm works as usual, without it.
+- **Turning it off.** To run without numba although it is installed, for example to compare, set the environment variable `CPM_DISABLE_JIT=1` before starting Python.
+
+See {doc}`/how-to/fast-session-models` for how much faster the models are, and how to compile your own models.
+
 ## Extras for the tutorials
 
 The tutorials and examples also use [matplotlib](https://matplotlib.org/) for figures, which is installed with cpm.
diff --git a/docs/get-started/troubleshooting.md b/docs/get-started/troubleshooting.md
index 6213e28..ac917ab 100644
--- a/docs/get-started/troubleshooting.md
+++ b/docs/get-started/troubleshooting.md
@@ -22,11 +22,24 @@ A {py:class}`~cpm.generators.Simulator` runs a model for many participants, so i
 The code that runs the fit must be under an `if __name__ == "__main__":` guard.
 See {doc}`/how-to/parallelise-fitting`.
 
-### Warnings about overflow in the Softmax
+### Warnings about overflow
 
-While the optimiser explores the parameter space, it can try very large inverse temperatures, where the exponentials in the Softmax overflow.
+While the optimiser explores the parameter space, it can try very large parameter values, such as inverse temperatures, where exponentials overflow.
+{py:class}`~cpm.models.decision.Softmax` and the built-in models compute their probabilities in a way that cannot overflow, but other functions, such as {py:class}`~cpm.models.decision.Sigmoid` or the exponentials in your own model, can still warn about it.
 These warnings are usually harmless, because the optimiser moves away from those values.
-If they persist, lower the upper bound of the inverse temperature, or rescale the values that go into the Softmax.
+If they persist, lower the upper bound of the parameter, or rescale the values that go into the exponential.
+
+### numba does not install, or does not work with my version of NumPy
+
+numba is optional (see [Faster fitting with numba](installation.md#faster-fitting-with-numba)), and cpm works without it.
+numba supports a new NumPy release some time after it comes out, so the newest NumPy may not have a numba release yet; `pip` then either installs an older NumPy for numba, or cannot install numba.
+If numba is installed but cannot be imported, cpm warns once, with numba's error, and runs the models as plain Python, with the same results, only more slowly.
+To use numba, install a NumPy version that numba supports (see the [numba installation notes](https://numba.readthedocs.io/en/stable/user/installing.html)), for example in a separate virtual environment.
+
+### The first fit of a built-in model takes a few seconds longer
+
+With numba installed, the first run of each built-in model compiles it.
+The compiled code is cached on disk, so this happens once per model and cpm version, not on every run.
 
 ### A parameter estimate sits exactly at its bound
 
diff --git a/docs/how-to/fast-session-models.md b/docs/how-to/fast-session-models.md
new file mode 100644
index 0000000..dfba6b9
--- /dev/null
+++ b/docs/how-to/fast-session-models.md
@@ -0,0 +1,118 @@
+# Speed up fitting with numba
+
+Fitting a model evaluates it thousands of times per participant. A {py:class}`~cpm.generators.Wrapper` calls the model function once per trial, and that call, not the model itself, is what most of the time goes into. The built-in applications in {py:mod}`cpm.applications` therefore compute all trials of a participant at once, and with [numba](https://numba.pydata.org/) installed, that loop over trials is compiled as a whole. You can do the same for your own models with {py:class}`~cpm.generators.SessionWrapper`.
+
+## Install numba
+
+numba is an optional dependency. Install it with cpm (see {doc}`/get-started/installation` for the other ways to install it):
+
+```bash
+pip install "cpm-toolbox[numba]"
+```
+
+That is all: the applications use numba whenever it can be imported, and your code stays the same. Without numba, they run the same computation as plain Python, with the same results. numba supports a new NumPy release some time after it comes out, and does not support PyPy; if numba is not installed, cpm uses plain Python without further notice, and if it is installed but cannot be imported, cpm warns once, with numba's error, and uses plain Python.
+
+## What to expect
+
+One evaluation of the objective function, with the parameters' priors, for one participant (from `python benchmarks/run.py` in the cpm repository):
+
+| Application | Trials | Without numba | With numba | Per trial, in a `Wrapper` |
+|---|---:|---:|---:|---:|
+| `RLRW` | 71 | 0.66 ms | 0.08 ms | 3.7 ms |
+| `HybridMBMF` | 200 | 1.8 ms | 0.11 ms | 11 ms |
+| `PTSM` | 40 | 0.26 ms | 0.07 ms | 2.1 ms |
+| `PTSM1992` | 40 | 0.31 ms | 0.08 ms | 2.1 ms |
+| `PTSM2025` | 40 | 0.31 ms | 0.07 ms | 1.8 ms |
+
+With numba, the model itself takes 0.02 to 0.05 ms of this, and the loss function about 0.02 ms. The last column is the same model computed one trial at a time, see [below](#extend-an-application-trial-by-trial).
+
+The first time an application runs with numba, numba compiles it, which takes a few seconds: about 3 to 5 s for the reinforcement-learning models, and up to about 15 s for the prospect-theory models. The machine code is cached on disk, next to cpm's own files, so later runs, new Python sessions and the worker processes of a parallel fit (see {doc}`parallelise-fitting`) load it in a fraction of a second. If cpm is installed in a directory you cannot write to, numba caches in your user directory instead; if it cannot write there either, as on some clusters, it compiles the models again in every new Python session.
+
+To run without numba although it is installed, for example to compare, set the environment variable `CPM_DISABLE_JIT=1` before starting Python.
+
+## Simulations and random numbers
+
+Where a model samples choices, as with `generate=True`, the applications draw one uniform random number per trial from `numpy.random` and turn it into a choice exactly as `numpy.random.choice` does. A simulation after `numpy.random.seed(...)` therefore makes the same choices with and without numba.
+
+## Extend an application trial by trial
+
+The `model` attribute of an application is still its model function for a single trial, `model(parameters, trial)`, which computes one trial from the states in `parameters` and returns that trial's outputs, including the updated states. You can call it from your own per-trial model, for example to give the parameters of an application different values on different kinds of trials, and wrap that in a {py:class}`~cpm.generators.Wrapper`:
+
+```python
+from cpm.applications.reinforcement_learning import HybridMBMF
+from cpm.generators import Wrapper
+
+application = HybridMBMF(data=two_step_data_of_one_participant)
+hybrid = application.model
+
+def model(parameters, trial):
+    ## ... for example, change the parameters for this trial ...
+    return hybrid(parameters=parameters, trial=trial)
+
+wrapper = Wrapper(model=model, data=two_step_data_of_one_participant, parameters=application.parameters)
+wrapper.run()
+```
+
+This gives the same results as the application, one trial at a time, and runs at the speed of a per-trial `Wrapper` (the last column above). To get the speed of the application back, write the extended model for all trials at once, as below.
+
+## Write your own session model
+
+A session model is a function of `parameters` and `data` that computes all trials at once and returns one row per trial. Wrap it in a {py:class}`~cpm.generators.SessionWrapper`:
+
+```python
+import numpy as np
+from cpm.generators import SessionWrapper, Parameters, Value
+
+def model(parameters, data):
+    alpha = parameters.alpha.value
+    beta = parameters.beta.value
+    values = np.asarray(parameters.values, dtype=float).copy()
+    n = len(data["choice"])
+    p_right = np.empty(n)
+    for t in range(n):
+        p_right[t] = 1 / (1 + np.exp(-beta * (values[1] - values[0])))
+        choice = data["choice"][t]
+        values[choice] += alpha * (data["reward"][t] - values[choice])
+    return {"p_right": p_right, "dependent": p_right}
+
+parameters = Parameters(
+    alpha=Value(value=0.3, lower=0, upper=1, prior="truncated_normal", args={"mean": 0.5, "sd": 0.25}),
+    beta=Value(value=2.0, lower=0, upper=10, prior="truncated_normal", args={"mean": 5, "sd": 2.5}),
+    values=np.array([0.5, 0.5]),
+)
+wrapper = SessionWrapper(model=model, data=data_of_one_participant, parameters=parameters)
+```
+
+`data` arrives as a dictionary of numpy arrays, one per column, converted once when the data are set (pass `prepare` to convert them differently). Outputs with one value per trial become one column of `export()`, and outputs with several values per trial become several columns, as with a `Wrapper`.
+
+This alone, in plain Python, is typically 5 to 15 times faster than the same model in a per-trial `Wrapper`. To compile it, move the loop into a function of numbers and arrays only, decorate it with `numba.njit`, and call it from the model function:
+
+```python
+from numba import njit
+from cpm.models import kernels
+
+@njit
+def learn(alpha, beta, values, choices, rewards):
+    values = values.copy()
+    p_right = np.empty(choices.shape[0])
+    for t in range(choices.shape[0]):
+        p_right[t] = kernels.p_second(beta, values[0], values[1])
+        values[choices[t]] += alpha * (rewards[t] - values[choices[t]])
+    return p_right
+
+def model(parameters, data):
+    p_right = learn(
+        float(parameters.alpha), float(parameters.beta),
+        np.asarray(parameters.values, dtype=float), data["choice"], data["reward"],
+    )
+    return {"p_right": p_right, "dependent": p_right}
+```
+
+`@njit(cache=True)` keeps the compiled code on disk between Python sessions. This works in scripts, modules and Jupyter notebooks; at the plain Python prompt, numba cannot cache and raises an error, so leave out `cache=True` there.
+{py:mod}`cpm.models.kernels` holds the formulas of the learning rules, decision rules, activation functions and attention mechanisms in {py:mod}`cpm.models` as functions: the classes compute with them, and compiled loops like this one can call them directly.
+
+Inside a compiled function, use numbers, numpy arrays, and functions from `math`, `numpy` and {py:mod}`cpm.models.kernels`. pandas objects, dictionaries of mixed types, cpm's `Parameters` and `Value` objects, and most other Python objects are not available there, which is why the model function unpacks them first. See numba's [list of supported Python and NumPy features](https://numba.readthedocs.io/en/stable/reference/pysupported.html).
+
+## Debug a compiled model
+
+Set the environment variable `NUMBA_DISABLE_JIT=1` before starting Python to run all compiled functions, cpm's and your own, as plain Python, where you can use a debugger and `print` and get ordinary tracebacks. cpm's own `CPM_DISABLE_JIT=1` does not do this: it turns off only cpm's compilation, so the functions in {py:mod}`cpm.models.kernels` become plain Python functions, and a compiled function of yours that calls them can no longer be compiled. numba's error messages for code it cannot compile name the line and the types involved; the most common cause is passing a pandas object, a list or a `Value` into a compiled function.
diff --git a/docs/how-to/index.md b/docs/how-to/index.md
index 6f915b6..b3911e5 100644
--- a/docs/how-to/index.md
+++ b/docs/how-to/index.md
@@ -5,6 +5,20 @@ Short, task-focused recipes for problems you will meet once you have learned the
 ::::{grid} 1 2 2 2
 :gutter: 3
 
+:::{grid-item-card} {fas}`bolt` Speed up fitting with numba
+:link: fast-session-models
+:link-type: doc
+
+Install numba to fit the built-in models many times faster, and compile your own models too.
+:::
+
+:::{grid-item-card} {fas}`rocket` Speed up your own model
+:link: speed-up-your-model
+:link-type: doc
+
+Write your model function for all trials at once, check it against the per-trial version, and fit it about 10 times faster.
+:::
+
 :::{grid-item-card} {fas}`gauge-high` Parallelise model fitting
 :link: parallelise-fitting
 :link-type: doc
@@ -23,6 +37,8 @@ Split participants across the nodes of a SLURM cluster with a job array, then co
 ```{toctree}
 :hidden:
 
+fast-session-models
+speed-up-your-model
 parallelise-fitting
 run-on-hpc
 ```
diff --git a/docs/how-to/speed-up-your-model.md b/docs/how-to/speed-up-your-model.md
new file mode 100644
index 0000000..d65ba80
--- /dev/null
+++ b/docs/how-to/speed-up-your-model.md
@@ -0,0 +1,196 @@
+# Speed up your own model
+
+The built-in models in {py:mod}`cpm.applications` are already fast.
+If fitting your own model is too slow, usually because you fit it many times (in hierarchical estimation, parameter recovery or model comparison), write its model function for all trials at once, and wrap it in a {py:class}`~cpm.generators.SessionWrapper` instead of a {py:class}`~cpm.generators.Wrapper`.
+Everything else stays the same: the optimisers, {py:class}`~cpm.generators.Simulator`, {py:mod}`cpm.hierarchical` and `export()` work with either.
+
+For the model on this page, fitted to one participant of the bandit data (71 trials), one evaluation of the objective function takes:
+
+| Model function | Time per evaluation |
+|---|---:|
+| Trial by trial, in a `Wrapper` | 4.2 ms |
+| All trials at once, in a `SessionWrapper` | 0.44 ms |
+| All trials at once, compiled with numba | 0.06 ms |
+
+A fit evaluates the objective function thousands of times per participant, and hierarchical estimation refits every participant on each iteration.
+
+## The same model, two ways
+
+This is the model of {doc}`/tutorials/first-model`, trial by trial:
+
+```python
+import numpy as np
+
+from cpm.datasets import load_bandit_data
+from cpm.generators import Parameters, Value
+from cpm.models.decision import Softmax
+from cpm.models.learning import SeparableRule
+
+experiment = load_bandit_data()
+experiment["observed"] = experiment["response"]
+
+parameters = Parameters(
+    alpha=Value(value=0.5, lower=1e-10, upper=1, prior="truncated_normal", args={"mean": 0.5, "sd": 0.25}),
+    temperature=Value(value=1, lower=0, upper=10, prior="truncated_normal", args={"mean": 5, "sd": 2.5}),
+    values=np.array([0.25, 0.25, 0.25, 0.25]),
+)
+
+
+def model(parameters, trial, generate=False):
+    alpha = parameters.alpha
+    temperature = parameters.temperature
+    values = np.asarray(parameters.values).copy()
+
+    # the stimuli on screen, and the reward each of them would give
+    stimuli = np.array([trial.arm_left, trial.arm_right]).astype(int)
+    rewards = np.array([trial.reward_left, trial.reward_right])
+
+    # Equation 1: choice probabilities from the values of the two stimuli
+    # (stimuli are numbered from 1, Python counts from 0)
+    choice_rule = Softmax(activations=values[stimuli - 1], temperature=temperature)
+    choice_rule.compute()
+
+    # learn from the choice of the participant, or from the model's own choice
+    choice = choice_rule.choice() if generate else int(trial.response)
+    reward = rewards[choice]
+
+    # Equation 2: update the value of the chosen stimulus
+    chosen = np.zeros(4)
+    chosen[stimuli[choice] - 1] = 1
+    update = SeparableRule(weights=values, feedback=[reward], input=chosen, alpha=alpha)
+    update.compute()
+    values += update.weights.flatten()
+
+    return {
+        "policy": choice_rule.policies,  # probability of choosing left and right
+        "response": choice,  # the choice the model learned from
+        "reward": reward,
+        "error": update.error[0, stimuli[choice] - 1],  # the prediction error
+        "values": values,  # the updated values, used on the next trial
+        "dependent": np.array([choice_rule.policies[1]]),  # what the model is fitted to
+    }
+```
+
+And the same model for all trials at once:
+
+```python
+def session_model(parameters, data, generate=False):
+    alpha = parameters.alpha.value
+    temperature = parameters.temperature.value
+    values = np.asarray(parameters.values, dtype=float).copy()
+
+    # one row per trial for every output
+    n = len(data["response"])
+    policy = np.empty((n, 2))
+    response = np.empty(n, dtype=int)
+    reward = np.empty(n)
+    error = np.empty(n)
+    history = np.empty((n, 4))
+
+    for t in range(n):
+        stimuli = np.array([data["arm_left"][t], data["arm_right"][t]]).astype(int) - 1
+        rewards = np.array([data["reward_left"][t], data["reward_right"][t]])
+
+        # Equation 1
+        exponentials = np.exp(values[stimuli] * temperature)
+        policy[t] = exponentials / exponentials.sum()
+
+        choice = np.random.choice(2, p=policy[t]) if generate else int(data["response"][t])
+        response[t] = choice
+        reward[t] = rewards[choice]
+
+        # Equation 2
+        error[t] = reward[t] - values[stimuli[choice]]
+        values[stimuli[choice]] += alpha * error[t]
+        history[t] = values
+
+    return {
+        "policy": policy,
+        "response": response,
+        "reward": reward,
+        "error": error,
+        "values": history,
+        "dependent": policy[:, 1],
+    }
+```
+
+The differences:
+
+- **The loop over trials is inside the model function.** A `Wrapper` calls `model(parameters, trial)` once per trial; a `SessionWrapper` calls `model(parameters, data)` once per run.
+- **`data` replaces `trial`.** It is a dictionary of numpy arrays, one per column of the data, so `trial.arm_left` becomes `data["arm_left"][t]`.
+- **The formulas are written out.** Equations 1 and 2 are computed with numpy, instead of creating a `Softmax` and a `SeparableRule` on every trial. `np.random.choice(2, p=...)` is how `Softmax.choice()` samples, so simulations make the same choices.
+- **States are local variables.** `values` is updated in the loop and recorded on every trial. After a run, the `SessionWrapper` sets the `values` parameter to its last row, the state a `Wrapper` ends a run with.
+- **Outputs are arrays**, one row per trial. `dependent` is what the model is fitted to, as before, and `export()` gives the same table as with a `Wrapper`.
+
+Wrap the new model function in a `SessionWrapper`, and use it wherever you used the `Wrapper`:
+
+```python
+from cpm.generators import SessionWrapper, Wrapper
+
+one = experiment[experiment.ppt == 1]
+per_trial = Wrapper(model=model, parameters=parameters, data=one)
+all_trials = SessionWrapper(model=session_model, parameters=parameters, data=one)
+```
+
+## Check that both give the same results
+
+A mistake in the loop changes the results without raising an error, so compare the new model function with the per-trial one before you use it, at a few parameter values:
+
+```python
+for alpha, temperature in [(0.1, 1.0), (0.5, 5.0), (0.9, 9.0)]:
+    for wrapper in (per_trial, all_trials):
+        wrapper.reset(parameters={"alpha": alpha, "temperature": temperature})
+        wrapper.run()
+    print(np.allclose(per_trial.dependent, all_trials.dependent))
+```
+
+All three lines should print `True`.
+If your model simulates choices, also compare the exports of a simulation with each version, each run after the same `np.random.seed(...)`.
+
+## Optional: compile it with numba
+
+With [numba](https://numba.pydata.org/) installed (`pip install "cpm-toolbox[numba]"`, see {doc}`fast-session-models`), the loop can be compiled to machine code.
+Move the loop into a function of numbers and arrays only, decorate it with `njit`, and call it from the model function:
+
+```python
+from numba import njit
+
+
+@njit(cache=True)
+def learn(alpha, temperature, values, arm_left, arm_right, reward_left, reward_right, response):
+    values = values.copy()
+    n = response.shape[0]
+    p_right = np.empty(n)
+    for t in range(n):
+        left, right = arm_left[t] - 1, arm_right[t] - 1
+
+        # Equation 1
+        exponentials = np.exp(np.array([values[left], values[right]]) * temperature)
+        p_right[t] = exponentials[1] / exponentials.sum()
+
+        # Equation 2
+        chosen = right if response[t] == 1 else left
+        reward = reward_right[t] if response[t] == 1 else reward_left[t]
+        values[chosen] += alpha * (reward - values[chosen])
+    return p_right
+
+
+def compiled_model(parameters, data):
+    p_right = learn(
+        float(parameters.alpha), float(parameters.temperature), np.asarray(parameters.values, dtype=float),
+        data["arm_left"], data["arm_right"], data["reward_left"], data["reward_right"], data["response"],
+    )
+    return {"p_right": p_right, "dependent": p_right}
+
+
+compiled = SessionWrapper(model=compiled_model, parameters=parameters, data=one)
+```
+
+It computes what the loop above computes, with numbers and arrays only, and without the outputs this version does not need.
+Inside a compiled function, use numbers, numpy arrays, and functions from `math` and `numpy`; pandas objects, dictionaries and cpm's `Parameters` are not available there, which is why the model function unpacks them first.
+This version only fits the model; for simulations, use the one above.
+
+The first call compiles the function, which takes a second or two.
+With `cache=True`, numba keeps the compiled code on disk, and later Python sessions load it in a fraction of a second.
+This works in scripts and in Jupyter notebooks; at the plain Python prompt, numba cannot cache and raises an error, so leave out `cache=True` there.
+To find errors in a compiled function, see [Debug a compiled model](fast-session-models.md#debug-a-compiled-model).
diff --git a/docs/index.md b/docs/index.md
index 1e89950..9c43e83 100644
--- a/docs/index.md
+++ b/docs/index.md
@@ -23,6 +23,8 @@ Build models from reusable components, fit them to data, check whether they can
 pip install cpm-toolbox
 ```
 
+To fit the built-in models many times faster, install it with the optional [numba](https://numba.pydata.org/) dependency: `pip install "cpm-toolbox[numba]"` (see {doc}`get-started/installation`).
+
 ::::{grid} 1 2 2 4
 :gutter: 3
 :class-container: landing-cards
@@ -105,4 +107,5 @@ examples/index
 how-to/index
 api/index
 about/index
+news/index
 ```
diff --git a/docs/news/2026-09-faster-fitting.md b/docs/news/2026-09-faster-fitting.md
new file mode 100644
index 0000000..21a7b0a
--- /dev/null
+++ b/docs/news/2026-09-faster-fitting.md
@@ -0,0 +1,219 @@
+---
+file_format: mystnb
+kernelspec:
+  name: python3
+  display_name: Python 3
+---
+
+# Faster fitting in cpm 0.26
+
+*28 September 2026 · cpm 0.26.0, in development*
+
+The built-in models of cpm now compute all trials of a participant in one call instead of one call per trial, and, when [numba](https://numba.pydata.org/) is installed, that loop over trials is compiled.
+Fitting them is 90 to 220 times faster than in cpm 0.25, and more than 1,000 times faster for {py:class}`~cpm.applications.decision_making.PTSM2025`, with the same results.
+Your code does not change.
+
+```{code-cell} ipython3
+:tags: [remove-cell]
+
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+from matplotlib.lines import Line2D
+
+RESULTS = "../../benchmarks/results"
+main = pd.read_csv(f"{RESULTS}/report-main.csv")
+branch = pd.read_csv(f"{RESULTS}/report-branch.csv")
+hierarchical = pd.read_csv(f"{RESULTS}/hierarchical-report.csv")
+
+MODELS = ["RLRW", "HybridMBMF", "PTSM", "PTSM1992", "PTSM2025"]
+## one colour per variant, the same in every figure (checked for colour-vision deficiencies)
+SERIES = [
+    ("main", "cpm 0.25", "#6b6a65", True),
+    ("per_trial", "Per trial", "#1baf7a", False),
+    ("python", "Without numba", "#eb6834", False),
+    ("numba", "With numba", "#2a78d6", False),
+]
+INK, INK_2, MUTED, GRID, AXIS = "#0b0b0b", "#52514e", "#898781", "#e1e0d9", "#c3c2b7"
+
+evaluation = pd.DataFrame(
+    {
+        "model": MODELS,
+        "trials": [int(main.set_index("case").loc[m, "trials"]) for m in MODELS],
+        "main": [main.set_index("case").loc[m, "objective_ms"] for m in MODELS],
+        **{
+            key: [branch[(branch.case == m) & (branch.backend == backend)].objective_ms.iloc[0] for m in MODELS]
+            for key, backend in (("per_trial", "trial"), ("python", "python"), ("numba", "numba"))
+        },
+    }
+)
+
+
+def dot_plot(rows, labels, unit, ticks, tick_labels, series=SERIES):
+    """One row per item, one dot per variant, on a log scale; the speed-up of numba over cpm 0.25 above its dot."""
+    fig, ax = plt.subplots(figsize=(7.4, 0.62 * len(rows) + 1.1), dpi=144)
+    fig.patch.set_facecolor("white")
+    for i, (_, row) in enumerate(rows.iterrows()):
+        y = len(rows) - 1 - i
+        values = [row[key] for key, *_ in series]
+        ax.plot([min(values), max(values)], [y, y], color=AXIS, linewidth=1, zorder=1)
+        for key, _, color, hollow in series:
+            if hollow:
+                ax.scatter(row[key], y, s=58, facecolor="white", edgecolor=color, linewidth=2, zorder=3)
+            else:
+                ax.scatter(row[key], y, s=72, color=color, edgecolor="white", linewidth=1.5, zorder=3)
+        ax.annotate(f"{row['main'] / row['numba']:,.0f}×", (row["numba"], y), xytext=(0, 9),
+                    textcoords="offset points", ha="center", va="bottom", fontsize=9.5, fontweight="bold", color=INK)
+    ax.set_xscale("log")
+    ax.set_xticks(ticks, tick_labels)
+    ax.minorticks_off()
+    ax.set_yticks(range(len(rows)), labels[::-1])
+    ax.set_ylim(-0.6, len(rows) - 0.3)
+    ax.grid(axis="x", color=GRID, linewidth=0.8)
+    ax.set_axisbelow(True)
+    for side in ("top", "right", "left"):
+        ax.spines[side].set_visible(False)
+    ax.spines["bottom"].set_color(AXIS)
+    ax.tick_params(axis="x", colors=MUTED, labelsize=9, length=0)
+    ax.tick_params(axis="y", colors=INK, labelsize=10, length=0)
+    ax.set_xlabel(unit, color=INK_2, fontsize=9.5)
+    handles = [
+        Line2D([], [], linestyle="none", marker="o", markersize=7.5, markerfacecolor="white" if hollow else color,
+               markeredgecolor=color, markeredgewidth=2 if hollow else 0, label=label)
+        for _, label, color, hollow in series
+    ]
+    ax.legend(handles=handles, loc="lower left", bbox_to_anchor=(0, 1.0), ncol=4, frameon=False,
+              fontsize=9, handletextpad=0.3, columnspacing=1.4, labelcolor=INK_2)
+    fig.tight_layout()
+    return fig
+```
+
+## What changes for you
+
+- **Install numba** with cpm: `pip install "cpm-toolbox[numba]"`. That is all it takes. {py:class}`~cpm.applications.reinforcement_learning.RLRW`, {py:class}`~cpm.applications.reinforcement_learning.HybridMBMF`, {py:class}`~cpm.applications.decision_making.PTSM`, {py:class}`~cpm.applications.decision_making.PTSM1992` and {py:class}`~cpm.applications.decision_making.PTSM2025` keep their arguments, parameters, priors and outputs, and give the same results.
+- **Without numba**, the same models run as plain Python, 11 to 23 times faster than in cpm 0.25 (about 250 times for `PTSM2025`). numba is optional because it supports a new NumPy release only some time after it comes out, and does not support PyPy.
+- **Your own models are faster too.** Every per-trial {py:class}`~cpm.generators.Wrapper` model runs about twice as fast, and you can compile your own models with the new {py:class}`~cpm.generators.SessionWrapper`: see {doc}`/how-to/fast-session-models`.
+- **Hierarchical results change.** {py:class}`~cpm.hierarchical.EmpiricalBayes` and {py:class}`~cpm.hierarchical.VariationalBayes` used to discard the population priors they estimated after the first evaluation of each fit. They now use them throughout, so their results differ from cpm 0.25 (see [below](#same-results-and-one-fix)).
+
+## How much faster
+
+Fitting a model evaluates its objective function (the negative log posterior) at one parameter set after another, thousands of times per participant.
+The figure shows how long one evaluation takes for each built-in model, fitted to one participant.
+
+```{code-cell} ipython3
+:tags: [remove-input]
+
+fig = dot_plot(
+    evaluation,
+    [f"{m}  ({t} trials)" for m, t in zip(evaluation.model, evaluation.trials)],
+    "milliseconds per evaluation of the objective function (log scale)",
+    [0.1, 1, 10, 100], ["0.1", "1", "10", "100"],
+)
+plt.show()
+```
+
+**Per trial** is a model's own per-trial function, `model(parameters, trial)`, in a plain `Wrapper`, which is how you extend a built-in model trial by trial; it runs without numba.
+**Without numba** and **With numba** are the built-in model computing all trials at once.
+
+```{code-cell} ipython3
+:tags: [remove-input]
+
+table = evaluation.set_index("model")[["trials", "main", "per_trial", "python", "numba"]].copy()
+table["speed-up"] = (table["main"] / table["numba"]).map(lambda x: f"{x:,.0f}×")
+table.columns = ["Trials", "cpm 0.25, ms", "Per trial, ms", "Without numba, ms", "With numba, ms", "Speed-up with numba"]
+table.index.name = None
+table.style.format({c: "{:.3g}" for c in table.columns[1:5]})
+```
+
+With numba, running the model now takes about as long as computing the loss, and resetting the parameters and evaluating the priors, which took about 1 ms per evaluation in cpm 0.25, take a few microseconds.
+
+## Hierarchical estimation
+
+The two hierarchical tutorials, {doc}`/tutorials/hierarchical-empirical-bayes` and {doc}`/tutorials/hierarchical-variational-bayes`, simulate 50 participants and fit them with two starts each, in 2 chains of up to 6 iterations; each iteration refits all 50 participants.
+Their model is written out per trial, and is the built-in `RLRW` model, which gives the same estimates.
+
+In cpm 0.25, the fitters stopped after fewer iterations, because discarding the updated priors made each iteration refit almost the same model.
+The figure therefore compares the same amount of work: the separate maximum-likelihood fits, and one iteration of each method.
+
+```{code-cell} ipython3
+:tags: [remove-input]
+
+variant = {"main, tutorial model": "main", "branch, tutorial model": "per_trial",
+           "branch, RLRW without numba": "python", "branch, RLRW with numba": "numba"}
+h = hierarchical.assign(key=hierarchical.variant.map(variant))
+eb = h[h.analysis == "empirical Bayes"].set_index("key")
+vb = h[h.analysis == "variational Bayes"].set_index("key")
+work = pd.DataFrame(
+    [
+        {"item": "Separate fits", **eb.separate_fits_s.to_dict()},
+        {"item": "Empirical Bayes, one iteration", **eb.seconds_per_iteration.to_dict()},
+        {"item": "Variational Bayes, one iteration", **vb.seconds_per_iteration.to_dict()},
+    ]
+)
+HSERIES = [
+    ("main", "cpm 0.25 (tutorial model)", "#6b6a65", True),
+    ("per_trial", "Tutorial model", "#1baf7a", False),
+    ("python", "RLRW without numba", "#eb6834", False),
+    ("numba", "RLRW with numba", "#2a78d6", False),
+]
+fig = dot_plot(work, list(work["item"]), "seconds (log scale)", [1, 10, 60], ["1 s", "10 s", "1 min"], HSERIES)
+plt.show()
+```
+
+The whole analyses, fitting only, with the number of iterations they ran:
+
+```{code-cell} ipython3
+:tags: [remove-input]
+
+def cell(row):
+    return f"{row.fitting_total_s:,.0f} s ({row.iterations})" if row.fitting_total_s >= 10 else f"{row.fitting_total_s:.1f} s ({row.iterations})"
+
+
+totals = pd.DataFrame(
+    {name: [cell(frame.loc[k]) for k in ("main", "per_trial", "python", "numba")] for name, frame in (("Empirical Bayes", eb), ("Variational Bayes", vb))},
+    index=["cpm 0.25, tutorial model", "Tutorial model", "RLRW without numba", "RLRW with numba"],
+).T
+totals
+```
+
+The tutorials themselves keep their per-trial model, which shows how a model is built from cpm's components; they run about twice as fast as before.
+
+## Same results, and one fix
+
+- The objective function of the built-in models is the same as in cpm 0.25, and so are all their outputs: exports, dependent variables, states and seeded simulations, with and without numba. They are bit-identical on the machine below; on other machines they can differ in the last digit, where numba and NumPy compute exponentials slightly differently.
+- The classes in {py:mod}`cpm.models` give bit-identical results, and the quickstart, the first tutorial and the two-step example reproduce their stored outputs.
+- Hierarchical estimation changes, as intended. The table compares the group estimates of the first chain with the group distribution the data were simulated from.
+
+```{code-cell} ipython3
+:tags: [remove-input]
+
+accuracy = pd.DataFrame(
+    [
+        [0.60, 0.20, 2.00, 1.00],
+        [0.547, 0.297, 2.688, 2.369],
+        [0.570, 0.202, 2.163, 0.916],
+        [0.536, 0.304, 2.635, 2.375],
+        [0.553, 0.229, 2.131, 0.981],
+    ],
+    index=["True group distribution", "Empirical Bayes, cpm 0.25", "Empirical Bayes, cpm 0.26",
+           "Variational Bayes, cpm 0.25", "Variational Bayes, cpm 0.26"],
+    columns=["α mean", "α SD", "β mean", "β SD"],
+)
+accuracy.style.format("{:.2f}")
+```
+
+In cpm 0.25, every participant was fitted with the broad starting priors, so the estimated spread of the inverse temperature β was more than twice its true value.
+
+## How we measured
+
+- **Machine:** Intel Xeon w5-2455X (12 cores), 32 GB, Windows 11; Python 3.12.4, NumPy 2.5.3, SciPy 1.18.1, pandas 3.0.6, numba 0.67.0.
+- **Code:** cpm 0.25 is `main` at commit `32629af`; cpm 0.26 is the development version at commit `830d479`.
+- **One evaluation:** `python benchmarks/run.py --repeats 300`, the median of 300 calls after one warm-up call.
+- **Hierarchical:** `python benchmarks/hierarchical.py eb|vb tutorial|rlrw OUT`, single runs.
+
+All runs used one thread for NumPy's linear algebra, ran one at a time, and loaded numba's compiled code from its cache.
+The first run of a model with numba compiles it once, which takes a few seconds (up to about 15 s for the prospect-theory models); after that, cpm loads the compiled code from disk.
+The results on other machines, operating systems and Python versions will differ, but the ratios should be similar.
+The data behind the figures are in `benchmarks/results/` in the [cpm repository](https://github.com/DevComPsy/cpm).
+
+For every change in this version, see the {doc}`changelog </about/changelog>`.
diff --git a/docs/news/index.md b/docs/news/index.md
new file mode 100644
index 0000000..a644e7d
--- /dev/null
+++ b/docs/news/index.md
@@ -0,0 +1,13 @@
+# News
+
+Announcements of new cpm releases and what they change, newest first.
+For the full list of changes in each version, see the {doc}`changelog </about/changelog>`.
+
+**28 September 2026** · [Faster fitting in cpm 0.26](2026-09-faster-fitting.md)
+: The built-in models now compute all trials of a participant at once, compiled with numba if it is installed: fitting them is 90 to 220 times faster, with the same results. Hierarchical estimation also gets an important fix.
+
+```{toctree}
+:hidden:
+
+2026-09-faster-fitting
+```
diff --git a/docs/tutorials/hierarchical-empirical-bayes.ipynb b/docs/tutorials/hierarchical-empirical-bayes.ipynb
index cfc2db5..f726f5d 100644
--- a/docs/tutorials/hierarchical-empirical-bayes.ipynb
+++ b/docs/tutorials/hierarchical-empirical-bayes.ipynb
@@ -30,10 +30,10 @@
    "id": "861ad04d",
    "metadata": {
     "execution": {
-     "iopub.execute_input": "2026-09-23T15:27:53.194382Z",
-     "iopub.status.busy": "2026-09-23T15:27:53.193380Z",
-     "iopub.status.idle": "2026-09-23T15:27:55.090000Z",
-     "shell.execute_reply": "2026-09-23T15:27:55.089692Z"
+     "iopub.execute_input": "2026-09-28T11:25:31.659871Z",
+     "iopub.status.busy": "2026-09-28T11:25:31.658871Z",
+     "iopub.status.idle": "2026-09-28T11:25:45.375566Z",
+     "shell.execute_reply": "2026-09-28T11:25:45.374555Z"
     }
    },
    "outputs": [
@@ -41,7 +41,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "0.25.7.dev0\n"
+      "0.26.0.dev0\n"
      ]
     }
    ],
@@ -91,10 +91,10 @@
    "id": "b85995a7",
    "metadata": {
     "execution": {
-     "iopub.execute_input": "2026-09-23T15:27:55.092554Z",
-     "iopub.status.busy": "2026-09-23T15:27:55.092554Z",
-     "iopub.status.idle": "2026-09-23T15:27:59.683391Z",
-     "shell.execute_reply": "2026-09-23T15:27:59.682384Z"
+     "iopub.execute_input": "2026-09-28T11:25:45.378563Z",
+     "iopub.status.busy": "2026-09-28T11:25:45.377563Z",
+     "iopub.status.idle": "2026-09-28T11:25:51.608666Z",
+     "shell.execute_reply": "2026-09-28T11:25:51.607655Z"
     }
    },
    "outputs": [
@@ -244,6 +244,16 @@
     "true_parameters.describe()"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "5aab5557",
+   "metadata": {},
+   "source": [
+    "This model is the built-in [`RLRW`](#cpm.applications.reinforcement_learning.RLRW) model, written out trial by trial to show how a model is built from cpm's components.\n",
+    "For your own analyses, `RLRW` gives the same estimates and computes all trials of a participant at once: with [numba](../get-started/installation.md#faster-fitting-with-numba) installed, the fitting in this tutorial runs more than 25 times faster.\n",
+    "See [Speed up fitting with numba](../how-to/fast-session-models.md)."
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "b842ab2f",
@@ -260,10 +270,10 @@
    "id": "1827d37b",
    "metadata": {
     "execution": {
-     "iopub.execute_input": "2026-09-23T15:27:59.685391Z",
-     "iopub.status.busy": "2026-09-23T15:27:59.685391Z",
-     "iopub.status.idle": "2026-09-23T15:28:55.930536Z",
-     "shell.execute_reply": "2026-09-23T15:28:55.930536Z"
+     "iopub.execute_input": "2026-09-28T11:25:51.634214Z",
+     "iopub.status.busy": "2026-09-28T11:25:51.634214Z",
+     "iopub.status.idle": "2026-09-28T11:26:27.037212Z",
+     "shell.execute_reply": "2026-09-28T11:26:27.036203Z"
     }
    },
    "outputs": [],
@@ -307,10 +317,10 @@
    "id": "969fa878",
    "metadata": {
     "execution": {
-     "iopub.execute_input": "2026-09-23T15:28:55.934099Z",
-     "iopub.status.busy": "2026-09-23T15:28:55.933543Z",
-     "iopub.status.idle": "2026-09-23T15:40:20.209964Z",
-     "shell.execute_reply": "2026-09-23T15:40:20.209404Z"
+     "iopub.execute_input": "2026-09-28T11:26:27.040235Z",
+     "iopub.status.busy": "2026-09-28T11:26:27.039227Z",
+     "iopub.status.idle": "2026-09-28T11:32:24.111566Z",
+     "shell.execute_reply": "2026-09-28T11:32:24.110922Z"
     }
    },
    "outputs": [
@@ -332,21 +342,35 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Iteration: 2, LME: -1002111.6878144502. \n"
+      "Iteration: 2, LME: -2129.2483896343138. \n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Iteration: 3, LME: -2118.660385652465. \n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Iteration: 4, LME: -2116.775324661551. \n"
      ]
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Iteration: 3, LME: -1002111.6878229581. \n"
+      "Iteration: 5, LME: -2116.190938974253. \n"
      ]
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Iteration: 4, LME: -1002111.6879784929. \n",
+      "Iteration: 6, LME: -2115.946883918983. \n",
       "Chain: 2\n"
      ]
     },
@@ -354,42 +378,42 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Iteration: 1, LME: -1002111.68789715. \n"
+      "Iteration: 1, LME: -2171.7025418727876. \n"
      ]
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Iteration: 2, LME: -1002111.6880721282. \n"
+      "Iteration: 2, LME: -2119.56153566882. \n"
      ]
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Iteration: 3, LME: -1002111.6879817494. \n"
+      "Iteration: 3, LME: -2116.510826937048. \n"
      ]
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Iteration: 4, LME: -1002112.7669982793. \n"
+      "Iteration: 4, LME: -2115.9283152971693. \n"
      ]
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Iteration: 5, LME: -1002111.6874826007. \n"
+      "Iteration: 5, LME: -2120.4912998972068. \n"
      ]
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Iteration: 6, LME: -1002111.6882978933. \n"
+      "Iteration: 6, LME: -2116.096626634608. \n"
      ]
     }
    ],
@@ -431,16 +455,16 @@
    "id": "45063e29",
    "metadata": {
     "execution": {
-     "iopub.execute_input": "2026-09-23T15:40:20.212486Z",
-     "iopub.status.busy": "2026-09-23T15:40:20.212486Z",
-     "iopub.status.idle": "2026-09-23T15:40:20.796064Z",
-     "shell.execute_reply": "2026-09-23T15:40:20.795057Z"
+     "iopub.execute_input": "2026-09-28T11:32:24.114084Z",
+     "iopub.status.busy": "2026-09-28T11:32:24.114084Z",
+     "iopub.status.idle": "2026-09-28T11:32:25.294537Z",
+     "shell.execute_reply": "2026-09-28T11:32:25.293533Z"
     }
    },
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 1200x800 with 7 Axes>"
       ]
@@ -467,10 +491,10 @@
    "id": "1e510420",
    "metadata": {
     "execution": {
-     "iopub.execute_input": "2026-09-23T15:40:20.798066Z",
-     "iopub.status.busy": "2026-09-23T15:40:20.798066Z",
-     "iopub.status.idle": "2026-09-23T15:40:20.807819Z",
-     "shell.execute_reply": "2026-09-23T15:40:20.807819Z"
+     "iopub.execute_input": "2026-09-28T11:32:25.296537Z",
+     "iopub.status.busy": "2026-09-28T11:32:25.296537Z",
+     "iopub.status.idle": "2026-09-28T11:32:25.310158Z",
+     "shell.execute_reply": "2026-09-28T11:32:25.309144Z"
     }
    },
    "outputs": [
@@ -511,15 +535,15 @@
        "  <tbody>\n",
        "    <tr>\n",
        "      <th>alpha</th>\n",
-       "      <td>0.55</td>\n",
-       "      <td>0.30</td>\n",
+       "      <td>0.58</td>\n",
+       "      <td>0.21</td>\n",
        "      <td>0.6</td>\n",
        "      <td>0.2</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>temperature</th>\n",
-       "      <td>2.69</td>\n",
-       "      <td>2.37</td>\n",
+       "      <td>2.16</td>\n",
+       "      <td>0.95</td>\n",
        "      <td>2.0</td>\n",
        "      <td>1.0</td>\n",
        "    </tr>\n",
@@ -530,8 +554,8 @@
       "text/plain": [
        "             mean    sd  true mean  true sd\n",
        "parameter                                  \n",
-       "alpha        0.55  0.30        0.6      0.2\n",
-       "temperature  2.69  2.37        2.0      1.0"
+       "alpha        0.58  0.21        0.6      0.2\n",
+       "temperature  2.16  0.95        2.0      1.0"
       ]
      },
      "execution_count": 6,
@@ -563,10 +587,10 @@
    "id": "47d5fbd2",
    "metadata": {
     "execution": {
-     "iopub.execute_input": "2026-09-23T15:40:20.810207Z",
-     "iopub.status.busy": "2026-09-23T15:40:20.810207Z",
-     "iopub.status.idle": "2026-09-23T15:40:20.821466Z",
-     "shell.execute_reply": "2026-09-23T15:40:20.820754Z"
+     "iopub.execute_input": "2026-09-28T11:32:25.312312Z",
+     "iopub.status.busy": "2026-09-28T11:32:25.311298Z",
+     "iopub.status.idle": "2026-09-28T11:32:25.325330Z",
+     "shell.execute_reply": "2026-09-28T11:32:25.324823Z"
     }
    },
    "outputs": [
@@ -603,38 +627,38 @@
        "    </tr>\n",
        "    <tr>\n",
        "      <th>mean</th>\n",
-       "      <td>0.547013</td>\n",
-       "      <td>2.688099</td>\n",
+       "      <td>0.579994</td>\n",
+       "      <td>2.157246</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>std</th>\n",
-       "      <td>0.247382</td>\n",
-       "      <td>1.362774</td>\n",
+       "      <td>0.134918</td>\n",
+       "      <td>0.759992</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>min</th>\n",
-       "      <td>0.017481</td>\n",
-       "      <td>0.567998</td>\n",
+       "      <td>0.118010</td>\n",
+       "      <td>0.797288</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>25%</th>\n",
-       "      <td>0.406963</td>\n",
-       "      <td>1.576051</td>\n",
+       "      <td>0.497941</td>\n",
+       "      <td>1.472777</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>50%</th>\n",
-       "      <td>0.579247</td>\n",
-       "      <td>2.456307</td>\n",
+       "      <td>0.606694</td>\n",
+       "      <td>2.178590</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>75%</th>\n",
-       "      <td>0.745620</td>\n",
-       "      <td>3.453586</td>\n",
+       "      <td>0.685379</td>\n",
+       "      <td>2.795440</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>max</th>\n",
-       "      <td>1.000000</td>\n",
-       "      <td>5.687499</td>\n",
+       "      <td>0.844977</td>\n",
+       "      <td>3.431649</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
        "</table>\n",
@@ -643,13 +667,13 @@
       "text/plain": [
        "           alpha  temperature\n",
        "count  50.000000    50.000000\n",
-       "mean    0.547013     2.688099\n",
-       "std     0.247382     1.362774\n",
-       "min     0.017481     0.567998\n",
-       "25%     0.406963     1.576051\n",
-       "50%     0.579247     2.456307\n",
-       "75%     0.745620     3.453586\n",
-       "max     1.000000     5.687499"
+       "mean    0.579994     2.157246\n",
+       "std     0.134918     0.759992\n",
+       "min     0.118010     0.797288\n",
+       "25%     0.497941     1.472777\n",
+       "50%     0.606694     2.178590\n",
+       "75%     0.685379     2.795440\n",
+       "max     0.844977     3.431649"
       ]
      },
      "execution_count": 7,
@@ -683,10 +707,10 @@
    "id": "8a060492",
    "metadata": {
     "execution": {
-     "iopub.execute_input": "2026-09-23T15:40:20.822984Z",
-     "iopub.status.busy": "2026-09-23T15:40:20.822984Z",
-     "iopub.status.idle": "2026-09-23T15:40:20.962715Z",
-     "shell.execute_reply": "2026-09-23T15:40:20.961708Z"
+     "iopub.execute_input": "2026-09-28T11:32:25.328336Z",
+     "iopub.status.busy": "2026-09-28T11:32:25.327337Z",
+     "iopub.status.idle": "2026-09-28T11:32:25.598236Z",
+     "shell.execute_reply": "2026-09-28T11:32:25.596725Z"
     },
     "tags": [
      "thumbnail"
@@ -695,7 +719,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 1000x450 with 2 Axes>"
       ]
@@ -726,10 +750,10 @@
    "id": "28fb73fe",
    "metadata": {
     "execution": {
-     "iopub.execute_input": "2026-09-23T15:40:20.964716Z",
-     "iopub.status.busy": "2026-09-23T15:40:20.963717Z",
-     "iopub.status.idle": "2026-09-23T15:40:20.970929Z",
-     "shell.execute_reply": "2026-09-23T15:40:20.970929Z"
+     "iopub.execute_input": "2026-09-28T11:32:25.601247Z",
+     "iopub.status.busy": "2026-09-28T11:32:25.600247Z",
+     "iopub.status.idle": "2026-09-28T11:32:25.613185Z",
+     "shell.execute_reply": "2026-09-28T11:32:25.612180Z"
     }
    },
    "outputs": [
@@ -767,12 +791,12 @@
        "    <tr>\n",
        "      <th>alpha</th>\n",
        "      <td>0.213</td>\n",
-       "      <td>0.149</td>\n",
+       "      <td>0.125</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>temperature</th>\n",
        "      <td>0.969</td>\n",
-       "      <td>0.854</td>\n",
+       "      <td>0.489</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
        "</table>\n",
@@ -781,8 +805,8 @@
       "text/plain": [
        "                     separate fits  empirical Bayes\n",
        "mean absolute error                                \n",
-       "alpha                        0.213            0.149\n",
-       "temperature                  0.969            0.854"
+       "alpha                        0.213            0.125\n",
+       "temperature                  0.969            0.489"
       ]
      },
      "execution_count": 9,
diff --git a/docs/tutorials/hierarchical-variational-bayes.ipynb b/docs/tutorials/hierarchical-variational-bayes.ipynb
index 07b4519..cc45773 100644
--- a/docs/tutorials/hierarchical-variational-bayes.ipynb
+++ b/docs/tutorials/hierarchical-variational-bayes.ipynb
@@ -31,10 +31,10 @@
    "id": "2a79edad",
    "metadata": {
     "execution": {
-     "iopub.execute_input": "2026-09-23T15:18:50.332905Z",
-     "iopub.status.busy": "2026-09-23T15:18:50.332905Z",
-     "iopub.status.idle": "2026-09-23T15:18:52.213512Z",
-     "shell.execute_reply": "2026-09-23T15:18:52.213512Z"
+     "iopub.execute_input": "2026-09-28T11:25:32.111521Z",
+     "iopub.status.busy": "2026-09-28T11:25:32.111521Z",
+     "iopub.status.idle": "2026-09-28T11:25:46.156156Z",
+     "shell.execute_reply": "2026-09-28T11:25:46.155148Z"
     }
    },
    "outputs": [
@@ -42,7 +42,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "0.25.7.dev0\n"
+      "0.26.0.dev0\n"
      ]
     }
    ],
@@ -88,10 +88,10 @@
    "id": "78831d24",
    "metadata": {
     "execution": {
-     "iopub.execute_input": "2026-09-23T15:18:52.216031Z",
-     "iopub.status.busy": "2026-09-23T15:18:52.216031Z",
-     "iopub.status.idle": "2026-09-23T15:18:56.770088Z",
-     "shell.execute_reply": "2026-09-23T15:18:56.769081Z"
+     "iopub.execute_input": "2026-09-28T11:25:46.158867Z",
+     "iopub.status.busy": "2026-09-28T11:25:46.157865Z",
+     "iopub.status.idle": "2026-09-28T11:25:52.149271Z",
+     "shell.execute_reply": "2026-09-28T11:25:52.148264Z"
     }
    },
    "outputs": [],
@@ -152,6 +152,16 @@
     "data[\"observed\"] = data[\"response\"]"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "91fb77e4",
+   "metadata": {},
+   "source": [
+    "As in [Tutorial 4](hierarchical-empirical-bayes.ipynb), this model is the built-in [`RLRW`](#cpm.applications.reinforcement_learning.RLRW) model, written out trial by trial.\n",
+    "`RLRW` gives the same estimates and computes all trials of a participant at once: with [numba](../get-started/installation.md#faster-fitting-with-numba) installed, the fitting in this tutorial runs more than 25 times faster.\n",
+    "See [Speed up fitting with numba](../how-to/fast-session-models.md)."
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "a97d2344",
@@ -170,10 +180,10 @@
    "id": "26f307af",
    "metadata": {
     "execution": {
-     "iopub.execute_input": "2026-09-23T15:18:56.772582Z",
-     "iopub.status.busy": "2026-09-23T15:18:56.772582Z",
-     "iopub.status.idle": "2026-09-23T15:23:37.131067Z",
-     "shell.execute_reply": "2026-09-23T15:23:37.131067Z"
+     "iopub.execute_input": "2026-09-28T11:25:52.198730Z",
+     "iopub.status.busy": "2026-09-28T11:25:52.197728Z",
+     "iopub.status.idle": "2026-09-28T11:31:48.706919Z",
+     "shell.execute_reply": "2026-09-28T11:31:48.704919Z"
     }
    },
    "outputs": [
@@ -195,7 +205,35 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Iteration: 3, LME: -2113.6158865535735\n",
+      "Iteration: 3, LME: -2131.082474046452\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Iteration: 4, LME: -2120.870576271314\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Iteration: 5, LME: -2119.146740698291\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Iteration: 6, LME: -2118.652560765555\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Iteration: 7, LME: -2118.4745210680217\n",
       "Chain: 2\n"
      ]
     },
@@ -203,14 +241,42 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Iteration: 2, LME: -2113.615661748695\n"
+      "Iteration: 2, LME: -2167.6694320261067\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Iteration: 3, LME: -2135.3989797647705\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Iteration: 4, LME: -2123.04316296454\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Iteration: 5, LME: -2119.945351761445\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Iteration: 6, LME: -2118.9763922575758\n"
      ]
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Iteration: 3, LME: -2113.6156702566254\n"
+      "Iteration: 7, LME: -2120.463474736944\n"
      ]
     }
    ],
@@ -264,16 +330,16 @@
    "id": "c9d283c9",
    "metadata": {
     "execution": {
-     "iopub.execute_input": "2026-09-23T15:23:37.134075Z",
-     "iopub.status.busy": "2026-09-23T15:23:37.134075Z",
-     "iopub.status.idle": "2026-09-23T15:23:38.088937Z",
-     "shell.execute_reply": "2026-09-23T15:23:38.087929Z"
+     "iopub.execute_input": "2026-09-28T11:31:48.709437Z",
+     "iopub.status.busy": "2026-09-28T11:31:48.708439Z",
+     "iopub.status.idle": "2026-09-28T11:31:50.069534Z",
+     "shell.execute_reply": "2026-09-28T11:31:50.068613Z"
     }
    },
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAABK4AAAMWCAYAAADYpM7pAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjIsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvgI3uAAAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3Qd8k9Uax/En6S60Ze89BATZIijIcIGI4hYVJyIuFJwoDlwoXLfiAAUH4sKFCk4cgCDKkCV7712g0Jn7eU5GkzTpIm0zft/re/PmXXmTlIx/znmOxWaz2QQAAAAAAAAIMtayPgEAAAAAAADAF4IrAAAAAAAABCWCKwAAAAAAAAQlgisAAAAAAAAEJYIrAAAAAAAABCWCKwAAAAAAAAQlgisAAAAAAAAEJYIrAAAAAAAABCWCKwAAAAAAAAQlgisAAIAQ1LFjRznzzDOLtW+NGjVk0KBBAT+nQN/28dxHAAAQHgiuAABASLnnnnvEYrHIhg0byvpUpHnz5uZcWrRo4XP9okWLzHqdnnzySQk1zvvna4qOji7r0wMAABGA4AoAAOA4lCtXTv777z+ZN29ennUTJ04060NZy5YtxWaz5ZmysrKKdbwdO3bIhAkTAn6eAAAgPBFcAQAAHIdWrVrJCSecIJMmTfJYnpGRIZMnT5ZLLrmExxcAAKCYCK4AAEDY0dZA2jWvWbNmEhcXJ1WrVpUrr7xS1q9f77FdWlqa3HnnnVK9enUpX7689O7d23RBLGptpWuvvVY++ugjOXbsmGvZtGnTZP/+/XLNNdcc1zkePXpUhg0bZmpDuZ+jPxqgnXzyyZKYmChJSUly9tlny99//y0lqXXr1uYx8+XUU081rbbyq3FVEvcxPj5e7rrrLpk7d6507tzZXG/UqJGMHz/e5zHfe+89s53efpUqVaR///6ydOnSIt8uAAAILIIrAAAQdjQAGj16tIwcOVJ27dolP/zwg+nOp8HEli1bXNtdfvnl8v7778ubb74p27Ztk8cee0xuv/12jwCqMDScSk1Nla+++sqjm2CvXr2kXr16x3WOAwYMMMcaN26cOcdHHnlEbrnlFp/neO+998qQIUNk4MCBJvhZuXKlNG3aVLp16yYLFy6UknLjjTfKP//8I4sXL/ZYrvfnzz//NOvzU1L3cc2aNfLiiy+aUEqPe+GFF8rgwYNNmOVOQzMN0y644AJZsWKFrF69Wm644QZ56aWXinW7AAAggGwAAAAh5O6777bpR5j169f7XD9nzhyz/umnn/ZYrttHR0fbbr75ZnP9jz/+MNu99tprHtvNmzfPLD/jjDMKPJdmzZrZTjnlFDN/9tln23r37m3mt23bZouKirJNnjzZtnr1anO8J554osjnOHv2bLPdK6+84rHdrFmz8pzj0qVLbRaLxfboo496bJuTk2Nr3bq1rW/fvq5l1atXt914442Fun96O74m99veu3evLS4uznbHHXd47H/PPffYYmJibLt27fJ72yV1H/V8qlatajt8+LBrWXp6uq1y5cq266+/3rVs0aJF5nYefPBBv49DUW4XAAAEFi2uAABAWPn555/N5UUXXeSxvEGDBtKhQwfX+pkzZ5rLfv36eWzXqVMnqVatWpFv97rrrpMff/zRtOzRVlza5Uxb+BzPOTovzz//fI/tTjvtNNOdzd0333xjiqZfeumlHst1BEBt+fXbb79JIIuz//TTT65tKlWqZLrWaU2v9PR0V1dIfRz03LUbpD8leR979OjhURw/NjbW1CNbt26da9l3333nagHnT0k9tgAAoGCMYwwAAMLK3r17zaXWS/Kmy7SLl/t2vkKq4gRXGlJpWKVhzbvvvmu6ISYkJATkHLUGlzfvZTpan2rTpo25dAZMznlnwXgNb0qCdrX7+OOP5csvvzT3XcOenTt3FthNsCTvY82aNfMcMzk52XUcpd00Ve3atf2eY1k/tgAARDJaXAEAgLCirX+UhibedJmzFU/lypU9ggt3vpYVRIt/a2Dz7LPPmjpJ119/fcDO0d927pz7rF271rR2ys7OlpycHDM5g5aSDFbOOOMMadiwobzzzjvmul7WqVPHFDDPT0neR20RVRBna7CtW7f63aasH1sAACIZwRUAAAgrGqCoL774wmP5xo0bTQFx5/qePXuay2+//dZju/nz5xcruFIaVulIgs2bNzdF1o/3HLUbmnOEQndz5syRPXv2eCw777zzzKW2eioLGhLp/dcuhPPmzZPp06eb7pNRUVH57lfW97Fv377m8sMPP/S7TVk/tgAARDK6CgIAgLBy6qmnmtpRTz75pNStW9cEE+vXr5ebbrpJUlJS5KGHHjLbde3a1azT67Vq1TJB1vLly+Wpp54ydZ2KQ8MqZ9exQJyj1nnS0OThhx82Xdk00Fq6dKnZz/sctRubjnynI/JpiKStv7Q1kdZz0hBJR8J79dVXpSRpcKUjM2otKG2VlF+rM6eyvo96zDvvvFPGjh0rSUlJcvXVV5u6WLNmzTJh2ltvvRUUjy0AAJGKFlcAACAkabc0DRG8p//++08++ugjEzQ8+uijJmA488wzpXHjxjJ37lwTFDl98sknctVVV5n6TFpbSrd/+eWXzXHi4uJK9PyLco4DBw6UwYMHu85RQxLtmuhtzJgxpr6W1pdq1aqV6eJ2xRVXmDpSI0aMKNZ5Llu2zOfjrNOaNWs8ttWugeecc45s3rzZBIGNGjUq1G2U9X188cUX5Y033pDPPvvMFG9v1qyZTJw40QRaJXm7AACgYBYdWrAQ2wEAAESMihUrmhZRb7/9dlmfCgAAQESjxRUAAICbX375RQ4cOCDdu3fncQEAAChjtLgCAAARS7uDpaWlmRpL2spq9uzZMmTIEFPrSIukl3R3QQAAAOSPFlcAACBi9e/fX1atWmXqS2mdKa11dfbZZ8vMmTMJrQAAAIIALa4AAAAAAAAQlGhxBQAAAAAAgKBEcAUAAAAAAICgFF3WJxCpcnJyZNu2bab4q8ViKevTAQAAAAAAKBU2m00OHToktWrVEqs1/zZVBFdlREOrunXrltXNAwAAAAAAlKnNmzdLnTp18t2G4KqMaEsr55OUnJxcVqcBAAAAAABQqlJTU01jHmc2kh+CqzLi7B6ooRXBFQAAAAAAiDSWQpROojg7AAAAAAAAghLBFQAAAAAAAIISwRUAAAAAAACCEsEVAAAAAAAAghLBFYrNZrPJszP+k++X7ZDUY5k8kgAAAAAAIKAYVRDFtnb3EXn917VmPspqkTZ1UqRr06rSrWkVaVu3gsREkYsCAAAAAIDiI7hCscVEWWRg5/oye80eWbfniCzYdMBML/+8WsrHRUvnRpWka5MqJsxqXLVcoYa5BAAAAAAAcLLYtL8XSl1qaqqkpKTIwYMHJTk5OeSfgS3700yA9cfqPeZyf5pn18GaKfGOEKuKnNakilQpH1dm5woAAAAAAEIjEyG4KiPhFly5y8mxyfLtqSbEmrVmt8zfsF8ysnI8tmlRM9l0KdQwq1PDShIfE1Vm5wsAAAAAAEoPwVUICOfgytuxzGz5a/0+meVokbVie6rH+thoq5zcoKJ0bWKvj3VizWSxWulWCAAAAABAOCK4CgGRFFx523M43XQnnGVaZO2R7QePeayvVC5WTm1c2YRY2q2wTsXEMjtXAAAAAAAQWARXISCSgyt3WmJNRyectXq3CbH+XLtXjmRke2zTsEo5V32sLo0rS3J8TJmdLwAAAAAAOD4EVyGA4Mq3zOwcWbT5gL0+1urdsnjLQcnOyR0/IMpqkTZ1UsxIhdoiq23dChITZS215w0AAAAAABwfgqsQQHBVyMfpWKbMXbvXtMbSroXr9hzxWF8uNko6N6psWmNpkNW4anmxWKiPBQAAAABAsCK4CgEEV8Wz9cBR0xJLW2Rpnaz9aZke62umxJu6WM76WFXKxwXk+QIAAAAAAIFBcBUCCK6OX06OTZZvT7V3K1yzW+Zv2C8ZWTke27SomWxCLK2R1alhJYmPiQrALQMAAAAAgOIiuAoBBFeBdywzW+Zv2Ge6FGqYpaGWu9hoq3SsX9HerbBJVWlZK1msVroVAgAAAABQmgiuQgDBVcnbczjddCfUIEtrZG0/eMxjfcXEGDlVuxU6RiysUzGxFM4KAAAAAIDIlpqaKikpKXLw4EFJTk7Od1uLzWbLHbINpYbgqnTpn/na3UdMfaxZa/bK3HV75XB6lsc2DauUM10KNcTq0riyJMfHlPJZAgAAAAAQ/lIJroIfwVXZyszOkcWbDzjqY+2RRZsPSHZOboarPQjb1K3gaI1VVdrVqyAxUdYyPWcAAAAgkn541iYWNue8uXSs0/+5Nb/wXu5c5dzPtY1ZZ1+S33bmmuuYBRy/OOfhdv7+7pfzPIp7fPf7mHvMot3P3OW5++V5DItzHj6O734fvY9fqPPI5/jOK85tnLfnuU8B5yH5PS/FPI98ju/5vNh8bte7VQ1TxzlURWxwpXf4yy+/lFWrVkmtWrXkkksukerVq+fZbvny5fLhhx9KQkKCPPTQQ8U+zuzZs2XGjBkSHR0t559/vrRr167Q50pwFVxSj2XK3LV7TYilXQvX7Tnisb5cbJR0blTZXh+raRVpXLW8WCzUxwIAAAgk/WqivyXmmEv7lz77vP3SlpO7Tpc5vxi6tslxv+7YpqBjurYrYBvXbRd8TPFzG577u6+3n7uv7fXLWkHb+D2m1zm4L/O7v+N+5v845oY2/h+zfPb3eJ7sz6P3NjofLdmSLVaxCT8gA95Gnd9Srj21gYSqiAyufvrpJxk0aJD07NlTmjRpIvPnzzfLvvvuOzn99NNd25155pmybds2qVixouzcuVPWrFlTrOP873//k0cffVQGDx4sx44dk3feeUfGjx8v11xzTaHOl+AquG09cFRma5H3NXtMnax9RzI81tdIjneFWKc1qSJVyseV2bkCAICyoV++M7JzJD0rx4xsrPOZjku97lyuLb2d682l+7zjMivHX7BQQBCQJ0zxDDwK3KYQ4UTudgXsn5NPGOK2vS2f24c9rImSHDPZ57Ml2lx3LLc4l+eu99jebb37vq5jWPI5tusY9uVW13Ze21v8HNt53Wu9r/tjzXM/7Jeu27Tk/kFk2qIkU6IlU6Ikw1xGS5ZjmfO6c8qwRUuWOLd3rLfZ93Ved67XbT32dR7XotvkLjfzFvtxsp3zznWO+SyJkWyL/d6KWMyP3K6fuS3mP/usLve+7pp3bOyY1znnb+W6Ve68fT/X4S0Fb+c8tL/bdd/PuT73GL63sx/Tx3Z+jp/3sfA6ntt23ufi6/jet2t/3PMe39djlP9j4bXc72Prudz7PPxu5/UY+zxXj8fd4vW3ZD/OmS2qSYf6tLgKKWvXrpUqVaqYxM7psssuk40bN8q8efNcy2bNmiVdu3aVxx57TD744IM8wVVhjrNjxw6pX7++vPnmm3LdddeZZU8++aQ899xzJhTTllwFIbgKrQ+lOkKhszXWXxv2mQ+Y7prXSDIhlnYr7NSgkiTE6hsWAAAIBA06nAFPZrbNLfzJNuGQ9zL7pduyrGx7qJRtyw2ZHNtmZuUeO91H+OQrZHLOu5cZwHE9w3nCC1e44SOMcQ83Yiw5rkm3iRH7vAYn0Rb7+mgNgzSIcRzDvswRpDgDFq/j25f7CYZc55Ab1OReZovV5rbM5tzOfs5Wm3ObbNc63d5+ad8GYSAq1jHFeM5bnde9L3WK9r+fXpp9fSx3zccUY189J763oGwUJROJljDRuHHjPMtOOukkmTNnjscyDa2O9zjTp093BVpO2tLq4Ycfll9//VX69OlTrPuA4GS1WqRV7RQzDeneWI5lZsv8DftMiKU1sjTU+m/HITON/2O9xEZbpWP9ivYWWU2qSstayeYYAACEQkCkYYx7QGMPhrxCGz9hjm6X7mOZc7v8WyDZXAFT7r6O8Ck7NL7Mx0ZZzecAMznmY6IsEhsdZebjPJbpfJTEWi2SGJUlcZJhAhXtFGVv0+FsGePZIsU+ZbnmNeyIdlvmDD9MWOIWkuiy3KDEEZw4whSLCVGyHNtlm+smTLHpfJbjun3Seed1c5mjg93kmEvnOovbvOQ4juG41GZZ9kv7NvbLEnx+XQVhJPRZHSGDNdrt0jFZovIus3ovi3LbNroQ2+u2Vq9tCnNc72P7Ojdfx/Zz+/r3kZ3hmDK95jP9LM8QyXFfX9R9swq/n96ON+f2oUCftzyhl1vIZS0gUIvKLxTLJ0wrKKzzty/lWiJS2ARX3jIyMmTKlCke3fsCdRytfVWjRg1JTEx0LatXr57ExMTI6tWrfQZX6enpZnJPFxGa4mOipFvTqmYaISJ7Dqeb7oQ6aZi17eAxmbN2r5nGyEqpmBgjpzbREMverbBupdy/GwBA5HLvZpZZUOseZ0sg925p/rqmFaHFkHM7965uoVBEItrqDH40BLKHRHHOwMhtmStEcgZJXstinPtFee0b7XlM1zK9XWuWJOSkSWz2UYnNOSoxOWkSk5Um0VlHxJJ5SCTjsEjGEZF0x2WGj8tjR9y2OSyiAQ7yCWv8hRpBENb4PfZxhDU+gyBqPAUtfdF0D7eKEnoVKmgrYL9C3abbMu/XG72epdMxCQmuQKsooVcgWqcVY1/9t0zQFt7BVU5OjgwfPjzfbbQG1e233+5z3c033yx79uyRZ5999rjOw9dx0tLSJCkpKc+2ukzX+TJ69GgZNWrUcZ0LgpPWt7qgbW0z6S/VWtjd2Rpr7rq9sj8tU779d7uZVIPKiaY1VtcmVaVL48qSkhBT1ncBACKim5lHd7JAtRjKJxRy3y7dxzKtaRTs9PO2M9RxD3hcQY576OOztZFboORjX+cxPY7n75hu4VOhWjKbL5MZuWFRniBJp0O580c1SHK77itw0kvTwigMwxrzBauQxyWsATxfKKNj7VMoyMkuZMsy79CsqGFZUYM2X7eZ7uP8M+2Tj4ZuwcdSQOh1nC3bGvUQqVX4AeJCWdAGV1qArEGD/Cvka6snX+6880756quv5Oeff5a6desW+xz8HUcDqgMHDuT5UKx9M30FWmrEiBEeQZy2uDqec0Pw/t3qiIM66QgP+uVk8eYDJsTSGlmLNh+QDXvTZMPeTfLB3E2in7vb1K1gWmNpfax29SqYD+8AEG70fXJH6jHZduBonhZDBQU87qGRPXxy1jBy72KWW8cobx2k0OpmltuNzBncRElsnmW5YU9+gVJcYUImt/AozmtZlNVeYLhUZGU4wiG38OiIr8DJRwDlETg51x0u2ZApOkEktpx9ikvKnTdTecfknNdtvK6byW2/6DhHYMXnAAAlyBlIx8QH/8NsRm/ILmRYVlJBmyMoK8xt5uk2qj+gpPsO4AKhz1iCq7KmH5LuuuuuIu+n4dD7779vRgJs16746WN+xznxxBPNiIQaXlWoUMEs0y6C2dnZZp0vcXFxZkJk0S8BHRtUMtOws06Q1GOZMnftXtOtUEcsXLf7iCzcdMBML/+yRsrFRknnRpVNl0It9t6kWvnS+8IAAAGgQdGGvUdk7a7Dsna3Tkdkza7Dsm73YTmSERzdoTSM8dU6yHtZjFd3Mfsy3dder8gZGpmgyRkwubZ1BE1u2+p2cT6WOY8dUq/3rpDJKyhyv16owMltP191YgIlOt5HoOQMk9yDJB/XfQZO5SloDAAlTd8XTZdAbW+TGDndRgvbKq1qM4kUQdviqjjuvvtumTRpkgmb2rdvX2LH0RpW8fHxMmHCBLnnnnvMsnHjxkmtWrUKLP6OyJYcHyNnt6xhJrX1wFGZrd0KHTWy9h3JkJ//22UmVSM53hVi6WXVJMJPAMHhYFqmrDHB1GGPkGrTvjS/I61pYFQzJV4SYqKK312sgG5pruN5hU+5IZO9FVFE0Q+3HkGSd4hUiJZL3vuVZNFhV8jkJ0gqauAUU87xpQcAgBIUat1GQ4jFpm33w4AGTddff7306tXLjALo7sUXX3TNv/zyy7Ju3TqZO3eu/Pfff3LdddeZ5Vp/SodiLOxxJk+eLIMGDZLevXvLsWPH5Pfff5epU6ea64Ee+hGRU6RXRyjULoVaI+uvDftMywV3zWskmRBLuxV2alBJEmIZvhZAyb4ubTt41NVqKjekOmIGpvCnfFy0NK5aThpXs3ed1qlJtXJSr1I5EyChECGTz5ZL3kGSn5ZL3vWbSjJkiorz0TLpeAInDZmo/QgAQLhLLUImEjY/P7Vq1UpeeOGFArerWbOmKfzuXT8rKiqqSMe56qqr5NRTTzX1r6Kjo+Xtt982La6A4tJCs61qp5hpSPfGciwzW+Zv2GdCLA2zlm1Llf92HDLT+D/WmxYEHRtUdBR6ryKtaqUUrlgtAHjR1xvt3mfCqV1HHK2ntHvfETma6b97n7YK1S7N7iGVXq+WFBda3d6KKzvLf8ulPK2X/LRc8u5OV1J1MJQWcy2wq5xX3SW/9Zkcl4RMAACghIVNi6tQQ4srFNXew+kye+1embV6twmzth30HLK2QmKMnNa4iivIqlspBPqBAyhV+49kmEDK1XrK0ZJq8/40U5bBF63B1KByOXvLqWrlXOFUo6rlTcuq0AyZ8qm7lKflUj61m0o8ZPIRFBW20Ld3CyjtLkfXBQAAEIKZCMFVGSG4wvHQvHndniMmwNIRC+eu2yuH0z1HTmpQOdERYlWVLo0rS0oCXS+ASKD1pbbu1+59znDKGVQdMXX0/EmKj3a0nsptOaUtqTQEL/XRTjVkysyv5VJhAie3rnI6ZXmG/QGlQ1iboCi/keXyK/TtYz9CJgAAEMZSCa6CH8EVAikrO0cWbzlgQiwNsxZuPuBRHFl7ELapW0G6NbEXeW9XryJ1ZoAQdzQjW9btsQdSWnfKFErfdVjW7zki6V718dzVrpAgjbRrnyucsrekqlq+BLv3HT0gsnOpyPZ/Rfat82zF5GvkudIImQI1shwhEwAAQJERXIUAgiuUpEPHMmXuOq2PtduMWKh1atyVi42SUxpVNl0Ktdi7fnmNiHo0QAi2rtyr3fscLaZyu/gdNqOS+uvepzXwGlbRulPlpIkJpuwBlQZWibEl2L1PT+jQdntAtWOJyI7F9vkDG4t3PEuUW6h0nCPLuWoyxdpH/QEAAECZIbgKAQRXKE3bDhy1dytcs0dmr9mTp7uQFlg+zRFi6WXVpDieIKCUW01ucXTvc68/pZcH0jL97qddgDV4todTua2o6lRMlKiSHqwhJ0dk31qR7YtFdjiCKg2p0vb4Odl6IjVbi1RtJhKf4qNuk4/AiZAJAAAgLBFchQCCK5Tl8PYrdqS6Riv8a/2+PN2KmtdIMq2xtEbWKQ0rS0KsfdRNAMfnSHqW6crn3nJKR/HTZRnZvrv3aeMg7d7nq/5UpXKxpdNaMvOYyO4VjpZU/9ovdy6z16HKc8JRIlVOsIdUNXQ6yT4lVir58wQAAEBIILgKAQRXCBbHMrPl7w375Y819tEKl21LzdPlqEP9iibE0hZZLWullHxLDiDEu/ftPpzuKohu7+Znrz/lPRqou7hoqxmpr7FX/Snt8leq4bHWozLd/JbkhlR7VorkeA4AYUQniFRvmRtS6WW1E0ViEkrvfAEAABByCK5CAMEVgtXew+kye+1eUx9LgyzvL9oVEmPktMb21ljaKktHHAMitXvfxn1pPutPHTrmI+RxqFwu1lUQ3X5p7+pXq0JC6YbCHvWo3FpS+atHlVDJEVBpC6o29vnKTUSstMgEAABA0RBchQCCK4RKyxHtwqRdCnXEwrlr98qhdM8v5PUrJ7qKvHdpXMXU3AHCbbADHeDAGUo5W1Jt3HtEMrN9V0fX/ElDXfdufc5ufhXLxZb6fZCcbJG9az0DKm1RVVA9KmdXP51Prk1RcwAAAAQEwVUIILhCqLYwWbzlgAmxtDXWws0HJDvH5vFlvXWdCibE0jCrXb2KEhttLdNzBgob0u5MTfcKp+z1p3ak+u/elxATZUbqc68/pS2pGlQuJ/ExZdQSSetR7Vru2dWvsPWonC2qEiqWxZkDAAAgQqSmpkpKSoocPHhQkpOT893WYtNP6yh1BFcIl5Yoc9ftM90KdcRCbZXiLjE2Sjo3quxqkaVf7kulkDTgR0ZWjmzadyRv/andR+SwV2tCd1XKx0kTZ9c+Z/e+auWlZnK8WMuy5purHpVbK6r86lHVaOXZiop6VAAAACgDBFchgOAK4WjbgaOmW6G2xpq9Zo/sPZLhsb56cpyc5gix9LJaUnyZnSvC28Gjma6C6CagcsxrTSr3VoLutL5U/UqJ9gLpjpDKtKSqUl5SEsu4C6z+xpS6zS2kWmy/PLCpgHpU2oqqjT2ooh4VAAAAggTBVQgguEK4y8mxyYodqSbE0jDrr/X7JD0rx2Ob5jWSTGssLfR+SsPKpTtyGkKeNhjefvCYR1F0Z0uq3YfS/e5XLjbKtJiyt57K7eZXr3KixEUHwd+gz3pU/4qk7fW9fYV6jlZUzq5+Wo+qFvWoAAAAELQIrkIAwRUizbHMbPl7w375Y419tMJl21I91sdGWaVD/YomxNIWWS1rpZTuCGsIWulZ2bJhT5qr1dQaR0ilXVPTMrL97qct/HKLo+fWn6qRHB88XVZd9ajcuvrtXCqSmea7HlXVZp5d/ahHBQAAgBBEcBUCCK4Q6fYeTpc5a/e6WmRtPXDUY32FxBg5tbHWx6pqgiwdoQ3h7UBahqsgugmnHC2pNu1LEz+9+yRau/dVdh+9z15/SltSJcUH2QiXR/eL7Fjq2Ypq90oRm4/wLSZRpHpLz4Lp1KMCAABAmCC4CgEEV4Bnl6/1e46YAEtHLJy7dq8c8iqUreGEs8h7l8ZVJCUhyEIJFLoLqYaU7t36nC2pvGuiuUuKi5ZGWhDdq/5UvUqJEhMVZCNXuupRuQVURapH1VqkcmMRaxB0WwQAAABKAMFVCCC4AvzLys6RxVsOyKzVe2XWmt2ycNMByXJrcqM9CFvXqeCqj9W+XkWJjQ6y8CLCaddQDSNz60/Z59fvOSzHMj1rnbmrmRLv1rWvnH30vqrlpWpSXPB07/NXj8pZMF27+xVUj8pZMJ16VAAAAIhABFchgOAKKLxDxzJl3rp9jhZZu00I4i4xNkpOaVhJuja1dytsWq18cIYcYWjfkYzccMpxqd38tuw/ahoe+RITZZGGVeytpty7+DWsWk7Kx0VL0DL1qJbZgylnS6qdywquR+VsTVWjlUhCxbI4cwAAACCoEFyFAIIroPi2HThqQiytjzV7zZ48Xcy0KPdpjm6FelktKZ6H+zhk59hky35ncXR71z5nWLU/LdPvfsnx0a5Qyr3+VN2KCRIdbN37fNajcgZUSwpRj6qVW8H01o56VPzdAQAAAL4QXIUAgisgcDWTVuxIdRV5/2v9PknP8uyK1rxGkulWeFrTKqZlVmJsELfqKUNpGVlmpL7c1lP2+XV7jkiG12PqrnaFBFeXPvf6U5XLxQZ/y7ei1qNKrOzViop6VAAAAEBRRWRwlZmZKe+++66ZVq1aJbVq1ZLrrrtObr/9domKyi1wq+vefPNNmTx5slSvXl0WL16c51g//vijvPDCC7Jw4UJJSkqSs88+Wx577DGpUqWKa5t9+/bJ3XffLTNmzJDo6Gjp37+/PPvss5KYWLiRzwiugJKrrfTPxv2myLvWx1q2LdWjy1pslFXa168g3ZpWNWFWq9opEqVFsyKEvuTvOewYvc+9QPquw3lGdnSnNcQaafc+9/pTVctLo6rlQicINPWo1jhaUhW1HpVjZL/kWiLBHsYBAAAAQS4ig6uJEyfKnDlzTFjVpEkTmT9/vgwcONAEV0888YRruzZt2pjlGzdulOnTp8uaNWs8jqPL77rrLrntttukdevWsmnTJhkyZIiUL19efv31V9d2PXv2lCNHjpjbPXbsmFxxxRXSsWNHmTJlSqHOl+AKKL0aTNqd0NkiyzucqZAYI6c2rixdm9jrY9WtVLjwORQK3G/ef9QEUmvc6k9pSHXwqP/ufRUTY9yKo9tbUDWpmiS1KyaEVsDnrEfl3tUv33pUzT27+ul8QoWyOHMAAAAg7KVGYnDly0MPPWSCpHXr1uVZpy2oPvjggzzBlS/vvPOODB48WDIyMsRqtcrcuXOlS5cu8vfff0uHDh3MNl9//bVccMEFsn79emnQoEGBxyS4AkqfvtzpSHfO+lh/rt0rh9KzPLapXznRPlphkypyauMqkpIYE9RP1ZF0e/e+NbsPedSf2rD3iGRm+3551wZDdSsmulpNmaDKEVZVKhcrIcejHpWjy9+eVfnXozIBlWNUP+pRAQAAAKWqKJlIiPTvKP4DUdiue/7s2LFDPvroIzn33HNNaKVmzZplHmBnaKXOPPNMczl79uxCBVcASp/WW2pkureVl2u6NDCtkhZvOehojbVbFm46IBv3psnGvZtk8rxNog2MTqpTQbppkNW0irSvV9F0mSuLwG3XoXSPVlPO4ujbDx7zu198jHbvK5+n/pSO6Bcfk9uFOmSYelRbPVtR6fxB6lEBAAAA4Spsg6vly5fL22+/LY8//nix9tfuhFOnTpWjR49Kt27d5LPPPnOt27Ztm1SrVs1jew3ItDvh9u3bfR4vPT3dTO6hGoCypSPbdahf0Ux3ntlUDqdnydy1e02LrD9W7zYB0eLNB8z06sw1khgbZYq7d21q71bYtFr5gBYfz8zOMcGZd/2pdbsO52kZ5q5K+VgTxuWO3mcPqLRoujWUuvf5qkdlQqrFuS2qju7zvX2F+p4F03U+qSb1qAAAAIAQF7TBVXZ2tmnVlB8NlLROlbetW7fKeeedZ4qqDx8+vFi3P378eHn11VdlxYoVMnToUDn//PNl5syZri+pztZX7nSZv56Xo0ePllGjRhXrXACUjvJx0XLmidXNpLYfPGov8r56j6mTtfdIhsxcudtMqnpynJzWpIoJsU5rXEWqJccX6nZSj2XaR+/zqj+loVVWju/XEM2f6lVKdAuncltQVUgMwe597jKPiuxa7tnVT+tRZR31X4/KvRYV9agAAACAsBW0wZWOBKjd9Araxpu2htLC6SeeeKJ88sknPgOmwoiPjzdT586d5fXXXzeF1//55x9zqa2tdu+2f3F10tZU2orKuyWW04gRIzxCNN22bt26xTo3AKWjZkqCXNaxrplycmzy345Dpkuhhll/rd8nO1PT5fMFW82kmlVPMl0KderUoJIJqLTu1Jpdh+wj9zlaUul+/iTERDkKojvDKXtQpbW34qJDsHufr3pU3l39ClWPytGKqmoLkZjCBYQAAAAAQl/QBldKu94VhXbT09BKRxXUbn6xsYFpheBsZaWtwJQWZt+3b58sW7ZMWrZsaZY5RxzUoMuXuLg4MwEITdrl7sRayWYafHpjOZaZLf9s3G9vkbVmtyzbliordx4y09uz1hd4vGpJcR6tppytqGokx4du9z6/9agcQVW+9aiqeBZMr9lGpFIjEWsYhHUAAAAAwjO4KoqdO3dKr169TGj1+eefFzskmjx5sqSlpcmFF14olStXlpUrV8pdd90lzZs3dxVj1y6K7du3l2HDhsmHH35oWls9+OCD0rt3b2nWrFmA7xmAYKTFzbWboE4izWXfkQyZs9berVDDrK0HjkqU1WJaSjX2qj+l9ahSEoJ7tMLjqkflbFFVYD2qNvaginpUAAAAAMI9uJo0aZL8999/snHjRhM4uTt8+LBrXutezZkzRzIyMiQrK8vVqmvVqlVSq1Yt6dOnjzz11FPSunVr2bNnjzlWv379zMiC0dH2h0u7H3755Zdy0003Sc2aNc113ebNN98s5XsNIFhUKhcr57WuZSatdbfncIYJp8piFMISr0e1c7lnwfTC1qPSS+36l1ChLM4cAAAAQAiy2PxVEw8xmZmZHqP2+etyqKMEOrv8uStXrlye0cF0O191tLy30f2KWktLa1xp8fmDBw9KcnJykfYFgFKRts+zFpXO+61HVU6kRiu3rn7UowIAAABw/JlI2LS4iomJMVNBEhISCn3MgkKrwm4DAEFNf784uMUrpNJ6VJsLqEflqElFPSoAAAAAJSRsgisAQCHrUe1Z7SiY/m/B9agqNnC0omqTWzw9qaaOWsHDDQAAAKDEEVwBQLhyr0flDKj81aOyRtvrUblaUVGPCgAAAEDZI7gCgLCsR/Wvox5VTj71qNxCqqotRGLiy+LMAQAAAMAvgisACMl6VI4WVEWpR+W8rNRIxEp9PgAAAADBj+AKAIJVdpbI3jWOVlSLc8Oqo/vzqUflFVIl1aAeFQAAAICQRXAFAMEgI01k13LPrn5an6qgelTOguk6xaeUxZkDAAAAQIkhuAKAMqlH5TaiX2HrUTlbUVVrIRIdx/MGAAAAIOwRXAFAadSjcrai0qDKXz2qclU9C6bXaOOoR2XlOQIAAAAQkQiuACCQcnJEVn4r8vc7ItsWFlyPytmKinpUAAAAAJAHwRUABCqw+u8bkd+eFdm51KseVQu3VlQ6taIeFQAAAAAUAsEVABxvYLXia5HfxojsWmZfFpskcspgkRbnU48KAAAAAEIluDp69KhkZmZKcnJyad4sAJRQYPWVI7BanhtYdR4i0vlWkcRKPOoAAAAAcJwCVvF30qRJcsstt7iuf/vttzJ27FiPbSZPnizDhw8P1E0CQNkEVks/F3n9VJFPr7OHVnHJIqffJ3LXvyK9RhJaAQAAAECwtbjKysoyramctm/fLitXrgzU4QGgbOVkiyz7QuT3sSK7/7Mvi0sR6XyLvZVVQkWeIQAAAAAIMGpcAUBhAivtErjHEcbHa2B1q8gpGlhV4PEDAAAAgBJCcAUA/gKrpVPtLaz2rMoNrLrcLnLKzYwKCAAAAAClgOAKANxlZzkCqzEie9fYl8VXcARWgwmsAAAAACBUg6spU6bIjBkzzHxaWpqkp6e7rjuXXXTRRYG8SQAIXGC15FN7C6t9a+3LtG5Vl9tEOmkLK0ZDBQAAAICQDa46duwoI0aMKHC7du3aSUlau3atrFq1SmrVqiWtW7cWi8WSZxstIv/zzz+b+d69e+d7vD///FO2bt0qZ599tiQne35xTU1NNeujo6OlS5cukpiYGOB7A6B0AqtPHIHVOvuyhEoip94u0mmwSFwSTwIAAAAAhHpw1bZtWzOVlaVLl8qQIUNk586d0qRJE1myZIlUq1ZNvvzyS6lXr55ru0ceeUQmTpxo5uPi4mTNGkdXIB8WLFhgAqvDhw+b47Vq1cq17ocffpDLLrtMmjZtKseOHZPdu3fL119/LZ06dSrhewogYIHVvx/bA6v9690CqztEOt1EYAUAAAAAQcAqYeLgwYMyZswYWb16tUyfPt0EUhpM3XLLLR7blS9fXubPny833nhjvsfTsGrAgAHy4IMP5ll35MgRueqqq8yx9VgaamnApctycnICft8ABFB2psiC90Ve7SDy1a320CqxssiZo0TuWiLSbTihFQAAAACEW4urTz/9tFBdBbWV0tNPPy2Bdtppp3lcj4+Pl379+smrr77qsfy+++4r1PFuvfVW6du3r5x11ll5wiut27Vv3z4ZNmyYa9k999wjbdq0kblz58qpp556XPcFQAkFVouniPz+P5EDG+3LEquInDZUpOONInHledgBAAAAIFyDK23xtG7dOjnjjDPyhEju2rdvL6Vl5syZ0rJlyyLv9+6778rixYvlr7/+Mq2pvP37779SvXp10xXRSbsRWq1Ws85XcKWF6nVyr48FoBRkZYgs/lDkj+dEDmyyLytXVeS0O0U63iASW46nAQAAAADCPbjq06ePaYH0/vvvy+bNm01XvGuuucYEPMVhs9lk6tSp+W5TtWpV6d69u8912tLq119/ld9//71It6uF3bX1lIZe2tXQX0hXsWJFj2UaWlWoUEEOHDjgc5/Ro0fLqFGjinQuAI4zsFo0WeSP50UOOgOram6BFYMpAAAAAEDEBFe1a9eW5557zgQ0X331lUyYMEEefvhhM2qfhljnnnuuREVFFSm4+uijj/LdRltT+QqupkyZIsOHDzdF2HW0v6K47bbbzD7//fefmbQVmfrxxx9NEXYdPVEDrbS0NJ+1r7SLoi/ajVLPyb3FVd26dYt0bgAKG1h94AisNtuXla9uD6w6XE9gBQAAAACRGFw5xcbGyqWXXmqmTZs2yTvvvGOKnGvrq3HjxhX6ONqC6bPPPivy7X/88cdy3XXXyfjx4+Xqq68u8v46MuL69etdodn+/fvNpRZ81/umwVWjRo3M6IUZGRlmmdLr2hVQ1/miYZe/FlwAAiArXWTh+yJ/vCCSusW+rHwNka53iXS4TiQmgYcZAAAAACI9uHLSIEdDJA2AEhISpEOHDlLStEC8BmRvvvmmXHvttcU6xtixYz2u//3333LyySfL888/b+pYqXPOOceEVN9++61ceOGFZtknn3xi7mePHj0CcE8AFCmwWvCeyCwNrLa6BVbDRDpcS2AFAAAAACEsoMFVVlaWfPfdd6aVlY6817NnT3niiSfkggsucLVMKik//fSTXHnllWYkwfLly3u01rrkkktc81r3as+ePbJ8+XLTtc+5nY4gqMFTYTRo0MDU8xo0aJDpSqhdCJ966ilzX5OTk0vg3gHII/NYbmB1aJt9WVIte2DV/hqRGN/ddgEAAAAAERhcaTFzDY40/Ln++uvllVdeKdUaTocPHzYBmfKujeUeXP3888+yYsUKM6+jHzq37dWrl8/gqlKlSnLxxRdLSkqKx/L//e9/ptugBnTR0dGmxdV5551XIvcNgHdg9a4jsNqeG1h1Gy7SbiCBFQAAAACEEYtNq6AHgBZjHzx4sDRs2FAsFovf7S677DJ5+umnJdJpcXYNw3SEQlppAYWQeVTkn3dFZr+YG1gl185tYRVNDTkAAAAACLdMJGAtrrT10eOPP17gdu3atQvUTQKIlMDq74n2wOrwTvuy5DqOFlZXE1gBAAAAQBgLWHClo/HpBAABkZEm8o8GVi/lBlYpde2BVdurCKwAAAAAIAKU2KiC/kb9W7hwIV0FAfiXcUTk73dEZr8scmSXfVlKPZHT7xZpc6VIdMkO9AAAAAAAiNDgSvsu7trl+CIKAN6B1fy3ReZoYLXbvqxCPZFu94i0GUBgBQAAAAARqFSDKwDwHVhNsLewSttjX1ahvsjp94q0uUIkKoYHDQAAAAAiFMEVgLKRflhk/niROa+IpO21L6vYwB5Ytb6cwAoAAAAAQHAFoJSlHxL5yxFYHd1nX1axoSOwuozACgAAAAAQ+BZXU6ZMkXvvvTffbdLS0uSiiy4K1E0CCCXHUkX+ekvkz1dFju63L6vUSOT0+0ROulQkigagAAAAAABPAfum2KJFCxkyZEiB27Vr1y5QNwkgZAKrN0X+fC03sKrcxN7CqtUlBFYAAAAAgJIPrtq2bWsmADCOHRSZ52hhdeyAfVnlpiLd7xNpdbGINYoHCgAAAACQL/rmAAh8YDX3DZG5r9nnVZUT7F0CW11EYAUAAAAAKDSCKwCBcfSAyDwNrMa5BVbN7C2sWl5IYAUAAAAAKDKCKwDHR+tWzX3d3soq3RFYVW1uD6xO7E9gBQAAAAAoNoIrAMWTts8eWGkrq/RU+7KqLdwCKyuPLAAAAADguBBcAShGYDXO3sIq45B9WbUTRbrfL9LifAIrAAAAAEDAEFwBKHxgpSME6kiBzsCqeit7C6vm/QisAAAAAAABR3AFIH9H9toDq780sDpsX1b9JJEe94s060tgBQAAAAAoMQRXAHw7skdkzisif40XyTxiX1bjJJHuD4g0O5fACgAAAABQ4giuAPgIrF4W+WuCW2DVWqSHI7CyWHjEAAAAAAClIqyCq+XLl8v7778vq1atklq1asm1114rHTt29NgmKytLpk2bJpMnT5bk5GR555138hynb9++kp2d7bFsyJAh0r9/f9f1nJwcmThxosyYMUOio6PNussvv7wE7x1Qwg7vtgdW8zWwSrMvq9lGpMcIkRN6E1gBAAAAAEpd2ARXn332mTz++ONy1VVXyZVXXinz58+XLl26yHvvvScDBgxwbdeiRQtp2bKl2Gw2+f33330e6/vvv5dRo0ZJhw4dPPZzd8cdd8jUqVPNdseOHZNBgwbJ6tWrZeTIkSV4L4EScHiXyOyXRP5+JzewqtXO3iXwhHMIrAAAAAAAZcZi0wQnDOzdu1cqVaokFrduTDfffLPMmTNHlixZ4lq2Y8cOqVGjhjz22GPywQcfyJo1a/IcS1tQffPNN9K7d2+ft6X7nHDCCabllrbOUm+++abceeedsn37dqlYsWKB55uamiopKSly8OBB0/ILKHWHdjpaWL0tknXUvqxWe3sLq6ZnEVgBAAAAAEpEUTIRq4SJypUre4RWqlq1anL4sGMUNAcNrQrj+eefN93/hg0bJgsXLvRY98MPP0hCQoKcffbZrmUXX3yxpKeny6+//npc9wMocYd2iMwYIfJSa/togRpa1e4octVnIjf9InLC2YRWAAAAAICgEDZdBb3t37/f1K+68MILi7xvo0aN5JxzzpF69erJzz//LKeccopMmjTJdEFUGzZskOrVq0tMTIxrnypVqkh8fLxZ54uGWjq5p4tAqQdWs14U+WeiSNYx+7I6J9u7BDY5g7AKAAAAABB0gja40uLn5557br7btG7dWsaMGZNnuQZEl156qSQlJcnTTz9d5NtesGCBlC9f3szrccqVK2dqWmmtLG3VlZGRYVpcedNlus6X0aNHm3pYQKlL3eYIrCaJZDvC0zqd7KMENu5FYAUAAAAACFpBG1xpQHTXXXflu43WtPKmwdEll1wiGzduNN32ilM/yhlaOWkdK+06qK2pGjZsKBUqVJB9+/blCdq0b6a/+lYjRoyQ4cOHe7S4qlu3bpHPDShaYPWCyD/v5gZWdTuL9LhfpFFPAisAAAAAQNAL6uDKX3F0fzIzM00LqRUrVpjQqnbt2gE5F2dIFRsbay7btm0rO3fuNIXYa9asaZYtWrTIhFdt2rTxeYy4uDgzASXu4FZ7YLVAAytHC8B6XewtrBp2J7ACAAAAAISMsCnOnpWVJZdddpksW7bMhFZ16tQp1nF+++03+ffff13Xd+/eLU899ZSpc+UMwrT+lda4evbZZ811HZhR51u0aCGdOnUK0D0CiujgFpFvhou83FZk/nh7aFX/NJFrvha5frpIox6EVgAAAACAkBK0La6Katy4cfLll1+a1lCDBg3yWDdjxgzX/D333CNLly6VNWvWmBZTzlZdH3zwgSmwXrVqVbnppptkz549Zl5DrM6dO8uECRM8all99NFHpkvi999/b7onamuvadOm5RnZEChxBzaLzHpeZMH7IjmZ9mX1uzpaWHXjCQAAAAAAhCyLTZsLhYH169fLypUrfa5z73I4b948M+Kgt549e3p05Vu7dq0JtrSmlb8uh8eOHZO///5boqOjpUOHDh6jDBZEa1ylpKSYuljFqcMFyIFNIn88L7Lwg9zAqkE3ke73E1gBAAAAAIJWUTKRsAmuQg3BFYpt/0aRP54TWfRhbmDV8HSR7g+INDiNBxYAAAAAEDaZSNh0FQTC3v4NboFVln2ZFlvXLoH1Ty3rswMAAAAAIOAIroBgt2+9PbBaPCU3sGrU0x5Y1etc1mcHAAAAAECJIbgCgtW+dSK/OwIrW7Z9WeNe9i6B9U4p67MDAAAAAKDEEVwBwWbvWkcLq4/cAqsz7C2s6nYq67MDAAAAAKDUEFwBwRRY/T5W5N9PcgOrJmfZRwmse3JZnx0AAAAAAKWO4Aooa3vW2AOrJRpY5diXNT3b3iWwToeyPjsAAAAAAMoMwRVQVvasdgRWn+YGVif0Ful+n0htAisAAAAAAAiugNK2e5XI72NElk51C6z6OAKr9jwfAAAAAAA4EFwBpWX3SpHfHIGV2OzLmvW1B1a12vI8AAAAAADgheAKKGm7VtgDq2Vf5AZWzc+zB1Y12/D4AwAAAADgB8EVUFJ2Lrd3CVz2pVdgdb9IzdY87gAAAAAAFIDgCgi0ncvsLayWa2Dl0OJ8ewurGifxeAMAAAAAUEgEV0Cg7Fgq8tuzIiu+zl124gUip2tg1YrHGQAAAACAIiK4Ao7XjiWOwGqaY4FFpGV/e2BV/UQeXwAAAAAAiongCiiu7YvtXQL/+8YtsLrQ3iWwWgseVwAAAAAAjhPBFVCcwOrXZ0VWfutYYBFpdZG9hVW15jyeAAAAAAAECMEVUFjbFtpbWK38zrHAInLSJSKn3ytStRmPIwAAAAAAAUZwBRRk6wJ7DatVM+zXLVaRVs7A6gQePwAAAAAASkhYBleHDh2SpKSkfLc5ePCgZGZmSpUqVQrcLiUlxe/6w4cPS1RUlCQkJBT7fBGktv5j7xK4+vvcwOqky0ROv0ekStOyPjsAAAAAAMKeVcLE3r175YEHHpAaNWpIrVq1JDk5We644w45evSox3YzZsyQCy64QKpWrSqdO3f2eSybzSZjxowxx6pXr540bNhQPvvsM49t1q1bJ926dZNKlSqZ2+rTp4/s3LmzRO8jSsmWv0U+uERkfC97aKWBVZsBIrfNF7noTUIrAAAAAABKSdgEVzNnzpSKFSvK4sWLTYurv/76S7766isZNmyYx3ZvvPGGXH/99XL//ff7PdbIkSNNcPXpp5+aFld6rIULF7rWZ2dnm/BLb2/fvn0msDpw4IAMGDCgRO8jStjm+SIfXCwy4QyRNT+KWKJE2l4lcvvfIhe+IVKlCU8BAAAAAAClyGLT5kVhatSoUTJhwgTZvHlznnWPPfaYfPDBB7JmzRqP5du3bzetrF5//XUZNGiQz+P+/PPPcuaZZ8p///0nzZo181i2bNkyOfHEEws8t9TUVNMFUYMxbbGFMrT5L5FfnxFZ+7P9ugZW2sLq9LtFKjXiqQEAAAAAIICKkomEZY0rp/Xr10v16tWLtM8PP/xgWlRdfPHFpgZWRkaGlCtXzmMbbYGltbGcoZU6/fTTXesKE1whCGyaaw+s1s20XzctrAaIdCOwAgAAAAAgGAR1cLVjx45818fGxpoaU7789ttvpkXVxIkTi3SbmzZtMvWvXn31VRk7dqwJsbTWlXYd1DBL7d69O09R95iYGJMW7tq1y+dx09PTzeSeLqKMbPxT5DcNrH61X7dGi7S90h5YVWzA0wIAAAAAQJAI2uBKA6O2bdvmu82pp54qn3/+eZ7l//77r1x44YVy6623ysCBA4t0uxaLxYRPS5YsMd0GExMT5bnnnpMrrrhC/vnnH2ndurXZJisrK8++ukxHGPRl9OjRpusiytCG2fbAav3vboHVVY7Aqj5PDQAAAAAAQSZogysNgApqceWLBk5nnHGGXH755fLSSy8Vef/atWuby4cfftjVRfCee+4xwZN2I9TgSrfRcEvLg2mIpY4cOWImHdHQlxEjRsjw4cM9WlzVrVu3yOeHYtgwy94lcMMf9uvWGJF2V4t0Gy5SoR4PKQAAAAAAQSpog6vi0MLoGlppl75x48a5QqWi6NGjh7nUEMrJWetKW18561lp8KT1rE455RSz7Pvvvze317VrV5/HjYuLMxNK0fo/RH571jOwaj9QpKsGVoSGAAAAAAAEu7AJrnSEv169eplQ6dFHH5WdO3e61mmNKqd9+/aZEOrw4cOmO6KzVVe1atXEarVKw4YN5dprr5U777xTXnnlFVPd/tlnn5X4+HjT/VB17NhRzjnnHBk8eLC89dZbcuzYMdOaSvejFVUZ00EyNajSFlYbZ9uXRcWKtNPAahiBFQAAAAAAIcRi0/5uYUCLqT/55JM+17l3Obzgggtk3rx5ebZZuHCh1KxZ08xrEfUnnnjC1M/ScKtdu3by2GOPSfPmzV3ba4urBx98UGbMmCHR0dHSv39/U8OqsK2qijL0IwpB/4zX/yby67Mim+bkBlbtr7EHVil1eBgBAAAAAAgCRclEwia4CjUEVwGif746OqC2sNo8174sKk6kw7Uip90lkmKvWQYAAAAAAEIvEwmbroKIwMBq7S/2Glab57kFVteJdL1LJNl3kXwAAAAAABA6CK4QgoHVz/YugVv+si+LjhfpcL3IaXeKJNu7ewIAAAAAgNBHcIXQCazWaGA1WmTr37mBVccb7IFVUm4BfgAAAAAAEB4IrhD8gdXqH0V+e0Zk6z/2ZdEJIiffKHLqUJGk6mV9hgAAAAAAoIQQXCGIA6sf7EXXty3wDKy0hVX5amV9hgAAAAAAoIQRXCH4AqtVM+xF17cttC+LScxtYUVgBQAAAABAxCC4QvAEViun27sEbl9sXxZTTqTTIJEud4iUr1rWZwgAAAAAAEoZwRWCILD6zt4lcMe/boHVTSKn3iFSrgrPEAAAAAAAEYrgCmUjJ0dk5bf2LoE7ltiXxZYX6TRYpMvtIuUq88wAAAAAABDhCK5Q+oHVf9/YA6udS3MDq1NutgdWiZV4RgAAAAAAgEFwhdILrFZ8LfLbGJFdy+zLYpMcgdVtBFYAAAAAACAPgiuUQmD1lSOwWm5fFpcscsoQkc63EFgBAAAAAAC/CK5QcoHV8i/tgdXuFfZlcSkinR2BVUJFHnkAAAAAAJAvgisEVk62yLIvRH4fK7L7v9zAqsut9lZWCRV4xAEAAAAAQKEQXCGwgZW2sNqz0r4sXltY3WavY0VgBQAAAAAAiojgCscfWC2dam9htWeVfVl8BfsIgacMtodXAAAAAAAAxUBwheLb8o/IFzeL7F1tv651q3SEwE43i8Qn88gCAAAAAIDjQnCF4kuqIXJgoyOwul2kk7awIrACAAAAAACBQXCF4kupLTLgI5G6nUTikngkAQAAAABAQIVVcJWZmSm//PKLrFq1SmrVqiW9e/eWcuXK5dlu586d8umnn0pMTIzcfPPNHutWrFghX331lc/jX3PNNea4TitXrpSffvpJoqOjzW3Vr19fIk6TM8r6DAAAAAAAQJiySpiYM2eOnHjiifLiiy+a4Grs2LHSuHFjWbRokcd2V111lXTs2FHGjx9vtvEVfh04cMBj+uKLL+SRRx4xQZfTxIkTpW3btjJr1iyZMWOGNG/eXKZNm1Yq9xUAAAAAACASWGw2m03CwJIlS6RChQpSt25d17Jzzz1XDh8+LL///rtr2dSpU6Vfv37y9NNPywcffCBr1qwp8NitWrWSFi1amFZaau/evaZ11VNPPSV33nmnWXbvvffK+++/L5s2bZLY2NgCj5mamiopKSly8OBBSU6mLhQAAAAAAIgMqUXIRMKmxdVJJ53kEVqp0047TdauXeux7OKLLy5UsOQ0b948WbZsmQwePNi1bPr06ZKeni7XXXeda5l2OdQuiH/88cdx3Q8AAAAAAACEWXDlLScnx3Tx69Sp03Ed5+2335YGDRrImWee6VEHq0aNGiYddNJuiVrrStf5okGXJoruEwAAAAAAAEKwOLv2YHz22Wfz3aZevXpy5ZVX+lx3//33m1pXkydPLvY5HDlyRD766CNzLIvF4lqu3Q/dQyul67V5m67zZfTo0TJq1Kg8ywmwAAAAAABAJEl1NOYpTPWqoA6utDB6fipVquRzudavGjdunHz77bfSrFmzYp/DJ598ImlpaXL99dd7LNeRCn0FTocOHfI5iqEaMWKEDB8+3HV969atppi8d/dGAAAAAACASHDo0KE8DYNCJriyWq3yzDPPFHk/baX15JNPyjfffCM9evQ47m6Cffv2lVq1anksP+GEE2THjh2mdVX58uXNsg0bNpgRCXWdL3FxcWZy0v02b94sSUlJHq25Qo0GeBq+6X2hyDzAvw2A9wyAz1MA3zUAvoMXprGShlbeeUtIBVfFMXbsWHn88cdl2rRp0qtXr+M61sqVK2X27NnmWN769OljgrUpU6bITTfdZJZNnDjRtADr3r17oY6v+9epU0fChYZWBFcA/zYA3jMAPk8BfNcA+A5eGAW1tAq74OrTTz+V++67T84991yZP3++mZweeOAB17zWvNLWQbNmzTJdEZ2tum677TbT+sm9tVXt2rVNSOWtevXqMmbMGBk6dKgsWLBAjh07Jh9++KG8++67Eh8fX+L3FQAAAAAAIBKETXBVrVo1U0Rd5VcbS5ui6fqOHTuaybmtd0GwmjVryssvvyxRUVE+j6OhVZcuXeT77783owlqgNWyZcuA3icAAAAAAIBIFjbBlXbRK0w3vSFDhhTqeMOGDStwm5NPPtlMkUzrdj366KMe9bsA8G8D4D0D4PMUwHcNgO/ggWCxFWbsQQAAAAAAAKCUWUv7BgEAAAAAAIDCILgCAAAAAABAUCK4AgAAAAAAQFAKm+LsKH07d+6UefPmSbly5aRr164UaAccNm7cKHPnzpW2bdtKs2bNeFwAx3vGwoULJTExUdq1aydJSUk8LoCIbN68WRYvXiwpKSnSoUMH828EgF1OTo5MnTrV/Lvo27cvDwsi2vz582Xt2rUeyypWrCjnnHOOhDuCKxTLe++9J7fccot07NhRdu3aJUePHpUffvhBTjjhBB5RRKz//vtP7r33Xlm6dKls375dnnzySYIrRLy0tDS5+eabZebMmdKqVSvZu3evrFu3Tt5++23p379/xD8+iFyHDh2SG264QRYsWCAtW7Y0P3ps3brVfMY699xzy/r0gKDwxBNPyNNPPy1169YluELEe/PNN+XHH3+ULl26uB6LBg0aEFwBvmzZskUGDx4sL774ogwZMkSys7PNB6wbb7xR/vjjDx40RKyDBw/KTTfdZD5Y1a5du6xPBwgK6enp5gPVpEmTJCoqyix79NFH5aqrrpIdO3bQ8goRS3/00+Dq008/dS277bbbzPuIBlhApNPvFe+++6753jF9+vSyPh0gKHTp0kU++ugjiTTUuEKRffbZZ6ZboH7YUvpF5K677pJZs2bJhg0beEQRsU455RQ5//zzXV/OAdibsF999dUe/y4uvvhi0xJr9erVPESIWNWqVZM+ffp4LNPu5YcPHxabzVZm5wUEg3379snAgQPNjx7ajRZA7r+Nr776Sn7//Xfzo3mkoKsgimzJkiXmg1VsbKxr2UknnWQutYuUNlcEAMCfn376yfwA0rRpUx4kRDz94W/Tpk2mbsmECRPktddeE4vFEvGPCyKb/kB+5ZVXyumnn27KkQCw03qh2mVQe0Hpe8crr7xiQt5wR3CFItNkt1KlSh7LKleubC4PHDjAIwoA8EuLUD/yyCPy0EMP0U0QEDED3fz555+yYsUKqVKlijRu3JjHBRFNv4hrd1n3brQAxJRZePXVVyU+Pt48HP/73/9MuR4d2OPEE08M64eIroIoMv2VXJuxu3Ned/4jAgDA28qVK6V3795y6aWXysiRI3mAABG5++67TRmGZcuWmXpwWicxNTWVxwYRac+ePWagm379+pnRBLWWz/Lly813DZ2n/hsiWc+ePT2+b+v7R7ly5WTGjBkS7giuUGT6S6A2S3SnI+GoRo0a8YgCAPJYtWqV9OrVS8466ywzoiBdoYC8tLvH/v37TekFIBJpfTcdcVbDqi+//NJM+qPHkSNHzLyO2gzATj9LlS9fXnbv3i3hjq6CKDIdQVCHptWm7VqMWn388cdSq1Ytadu2LY8oAMCDFmHXXwnPOOMMU2jXauV3M0BH1axevbpHiPvPP/+Yyzp16vAAISJVrVo1z4hp2kJXl0XiSGqAU3Z2tinMrv9GnP766y9T6+rkk08O+weK4ApF1rlzZ1Ms8ZJLLjHNE7dt2yYvvviiTJ48mS8jkEiv/+YcrvnYsWOyaNEi8yGrdu3a0q1bt7I+PaBM6IcsbWml3cy1m+Ann3ziWqdFd/VHDyAS/fLLLzJu3Dg577zzTIClg9+MHz9e7rnnHqlXr15Znx4AIIhkZmaaz03aiETrWWmPJ60Hd8EFF5hWiuHOYmO8XRRDTk6OvPfee2YYzsTERBNknXrqqTyWiGj6i4d+4fDWvn17ue+++8rknIBg/Xeh7r//fmnXrl2pnxMQLDSs0jBX6/bojxz6BaRjx45lfVpAUNF/I3PmzDE/lAOR7PDhw/Luu++aH8crVqwo3bt3N3URIwHBFQAAAAAAAIISRSYAAAAAAAAQlAiuAAAAAAAAEJQIrgAAAAAAABCUCK4AAAAAAAAQlAiuAAAAAAAAEJQIrgAAAAAAABCUCK4AAAAAAAAQlAiuAAAA4FNmZqa8+OKLsmPHDh4hAABQJgiuAAAAgsDLL78sy5YtM/Pp6ekmMNq1a1ep3b6v29Rlw4YNkw0bNpTaeQAAALgjuAIAAAgCw4cPlz///NPMHz161ARGmzZtKrXb93WbsbGxcuedd0rNmjVL7TwAAADcRXtcAwAAQJl78803zeWUKVNk1qxZUr16dRkwYIBZtnXrVvn5558lOztbOnbsKCeddJJrv7S0NHnrrbdk4MCB8u+//8qKFSuke/fu0rJlSxk3bpxkZGRIVFSU1KtXT3r06CEpKSn53uYll1wiDRo0kLi4OI/z0+P+8ccfJtg644wzpG7duj7PYc2aNbJ06VKpVauWnHPOOWK18pspAAAoGj49AAAABJnNmzeby+3bt5tuenqpJk2aZEKoadOmye+//y69evWSBx54wLVfamqqaTXVt29fGTlypAmYDh06ZNZt3LjRHGvlypXy3HPPSfPmzU2olN9t+uoq+PTTT0v79u3ll19+kalTp0rTpk3lk08+yXMO/fr1k3vvvde0Irvxxhvl4osvLoVHDgAAhBuLzWazlfVJAAAARLro6Gh54403ZNCgQXLgwAGpWLGizJ8/37SqUmvXrpVWrVqZlk7OZRooaZClIdIpp5xiiqhrt75rrrlG3n333Xxv79Zbb5Vt27bJl19+aa77us3Dhw9LUlKSCZ86d+5sQi89h88//9wEU2r06NEmCNPz0xZcznO47bbb5NVXXzXbLF++3JynBmV6CQAAUFh0FQQAAAgBn332mQmG5s6d66qFpb8/VqpUSebMmWOCK6drr702z/667W+//Wa672kgpV36Fi5cWKRz+Pbbb6VOnTqu0EoNHTpUHnroIXMOffr0cS2/8sorXfMnnniiJCYmmnCL4AoAABQFwRUAAEAI2LJli2mVpcGTO+2C16xZM49l1apV87iuQZXWtNq/f7907dpVKlSoIHv37pV9+/YV6Ry0O6EGV+7KlStnwjNnV0On5ORkj+sxMTGmxhYAAEBREFwBAACEgMqVK5vLF198scj7fvTRR7J7925ZtWqVq9C6FmOfOXNmkY5To0YNcxx3mZmZppuhrgMAAAg0irMDAAAEmfLly5sR+LQ7n5N2z9MRBTWEcrdz5848YZK3gwcPmhZQztBKRyR8//33C7xNbzqCoIZff/31l2vZBx98IPHx8aYGFgAAQKDR4goAACDIaJdArVn18MMPy/nnny+1atWSAQMGyFNPPSUDBw6U6dOnm+6BGiLNnj1bvv/+e6latarf4/Xv318effRRueSSS6Rt27by3XffmVEGC7pN91pWSou2DxkyxNSyGjx4sBw5ckTeeustGTNmTJ7uiQAAAIFAiysAAIAgcOedd5oR+5ymTZsmF110kWzfvt1M6sEHH5QFCxZIixYtTN0qbQG1aNEiadSokavelB6nSpUqHsdu3Lix/Pvvv9KuXTsTNg0bNswUWteR/9x532ZsbKw5no4S6DRu3DiZPHmyWCwWMwqhFnzXAu1O/s7hlltukaZNmwb4UQMAAOHOYtMhZgAAAAAAAIAgQ4srAAAAAAAABCWCKwAAAAAAAAQlgisAAAAAAAAEJYIrAAAAAAAABCWCKwAAAAAAAAQlgisAAAAAAAAEJYIrAAAAAAAABCWCKwAAAAAAAAQlgisAAAAAAAAEJYIrAAAAAAAABCWCKwAAAAAAAAQlgisAAAAAAAAEJYIrAAAAAAAABCWCKwAAAAAAAAQlgisAAAAAAAAEJYIrAAAAAAAABCWCKwAAAAAAAAQlgisAAAAAAIrJZrPJOeecI6+99hqPIVACCK4AAAAAACimjRs3yg8//CAWi4XHECgB0SVxUACl64svvpBGjRpJmzZtPJbPmjVLjh07JmeeeSZPCQCEifnz58u0adNky5YtkpmZab4oOafGjRvLww8/XNanCAARZenSpeayZcuWZX0qQFgiuAJC3Pbt2+Wiiy6Sl19+OU9wdcMNN8hJJ51EcAUAYWL48OHywgsvSKtWraR169ayaNEiWb58uURFRUmVKlXksssuK+tTBICIctttt8lPP/1k5u+77z5JSEgwPyToD8v6A/IVV1whw4YNM6/bL730knnNHjFihHTo0EEuvPBC081QxcXFSZ06deTyyy+Xs88+O8/t6Ov9hx9+aPaPj4+XM844QwYNGiQxMTGubVasWCHvvfeeLFmyxGzTtWtXufXWWyU2Nta1TXZ2tnz66afmnLdt2yZ169Y159G7d+9SebyA4qCrIBDiFi5caC71zc9damqqrFmzJs9yf/TN6/rrry/Utnfffbd89NFHxThbAEBxvfHGGya0euSRR+Tff/+VyZMnmy8yXbp0MV9c1q9fb37EKMirr74qzzzzTKFuU7/I6BcgAIBvV199tVSsWNH0fnj22Wflsccek8cff1wqVKggf/31l/z222+mpay2hu3Vq5e0a9dOypUrJ1arVR599FGzvU633367Cb30dfeTTz7xuI0HH3xQTj75ZDl8+LBce+210r9/f/nxxx/l3nvvdW3z/PPPS9u2bWX//v1y0003mfBrzJgx0qdPH1c4pkHaaaedZs5T3zuGDh1qfuS+//775d133y3UU/zHH39Ienp6gdvt3bvX9T0FOF60uAJCnL4h6C/t+kblbsGCBeZNqrDB1Z9//ml+mSmMGTNmyLnnnlus8wUAFJ12CRw1apT59Vy/4DjrqGhgdfHFF5vXcO2qol9sCjJz5kyfv+Z7O3LkiPlipL/GAwB80wBIe0BoINSjRw+PdX///be51B8W9McGfe3W0CkjI8O0gvLevl+/fuZz9rfffutqQash0//+9z/5/vvvTfDlHpjpD9VKgy79YXn8+PGmFZZT/fr1TRCmP1CfddZZpsXWvHnzZM+ePVK5cmXXdrfccoscPXq0wKd43759pqWXBmgF0R+59f3ms88+408Hx40WV0CI04CqefPmkpiYmGe5Kmxwpb+oa7eTgugb7apVq+TEE08s5hkDAIpKaxbu2LHDtIz1V/zX+33geF/vly1bJjVq1DCtBgAA/sOcTZs25fkR2RlcRUdHm+DJ/bVbQ6ucnBz5/PPPTUur888/34RYOm3evFmqV69uttOufPpjxZ133ukRWjklJydLVlaW6Yp4yimneIRWSsM0pd0Lna2glHZj1Nt30h/By5cvX+BTrK19mzVr5tH1ML/3Gr4vIFBocQWEQYurbt265Vn+zz//mF9ZtOaJ0yWXXCL//fefeQPVsOvpp582zZqdb0TaXFhps2Klv6borz76BqXdU/RY+sanb2zah/7GG2+UgwcPykMPPeRqgaVNnqdOnWrenPVXel3nfNMEABSPvqYrXy2qFi9eLElJSaYwu9IvMbqdttLSlrSdOnWS0aNHS0pKiqSlpcm6detMrRVnLUT9MqRdP5zvJ7qtfinR9wX90jFp0iR55513TBcWfS9wfhHRui3aykvfU/R9Qt9TnOcAAJFCu2wr7QLo67VbPwfXrFnTY7kOrqEtobTrnr4O9+zZUypVqmQ+Z2vXQmcIpp+pdRvvQMqdvn5rwKU1snRAJme3QL3U9wPlDKX0x4+vv/7adCXUrovaCktb7Wpw5gzW9Ny03Ihe1wBNvzM46fuCdi10tsrV69riTM9bt2/RooXHthq4adfF1atXm/cO53no9wdnN0L9cUSL2rvX6gK8EVwBIezAgQOm6fEdd9zhsVx/Qfnll1/k1FNP9Vj+1FNPmS8y2i99woQJJnjSJrz6hrh27VrXG5Huq2822p9ev6Ro02MNoN58802zXIs6TpkyRUaOHCk///yzeTPVN0ylx7z00kvNNnrsCy64wDSf5s0IAI7vF32ldVHcaTeRb775xnzpcO/u/f7775vLQ4cOmS6G+ou9vp5r0FSvXj0TdKnvvvtO5s6da3500B839AtUkyZNTLcRfb3XL2Snn366jB071tTPeuCBB8yXHqXH1fcUbYmrwdZ1111nvkABQCRxBjDewZW2wtq1a5dpUeVroA3trqeBjwZW7q1rlTO4Wrlypflx4IQTTvB7+7qN0tqF1apV87mNs5Wt/gitr9P6Q7Z2H9QfJvT94p577jGv80q7KernfP0+ocfWYEpbaGkw5d5iVwM2/Y6gP5Rri2D9LqH1t7SOooZm+n7z+++/m3pf+j6h3z/0fUWDKn3M9H3J+Tjp+5d2edcfWACfbABC1syZM/UnFduzzz7rsfytt94yy5988km/+27YsMFWqVIlM//333/b6tev71pXq1Yt2xtvvOG6/tlnn9natWtn5u+55x5bjx49XOs2bdpkS0xM9Hs7VapUsa1bt66Y9xAAoMaNG2de191fm7Ozs23XXHONeQ1etmyZ3wfqyy+/tPXq1cvMT5gwwXbBBReY+V27dpljzp0717XtyJEjbddff72Z19f6u+++27Xu888/t51++uk+b2PLli225ORkniwAEWfgwIHms7O3qVOnmtfYH3/8Mc+6OnXq2Pr27eux7ODBg7a6deva4uPjbVlZWWbZ/fffb46h6/x58803zTZLly4t8rnr7TRu3Njva/uRI0fMfVu8eLG53qlTJ9s333xj5p955hlbUlKSbd68eeb6woULbRaLxbZ//37z2V/P6fHHH3e9XzVp0sT2/fff57mNnJwc21lnnWV7++23i3z+iBy0uAJCmNax0j7p+iu60ua8s2fPlmnTprn61esvGvoLkDbT1SF49Zcc/fVHCzA6izK6N/vVvu+6Xn85d9KuJc5f+XXbK6+80rVO611pFxGlzZHfeust8+u/tsDS69pKwP2XJABA0WmRXh1NUOuYaEvbqlWrmtooOmKVjgTlXkdE17/44ovm9V9f+7V1rv5i7v16r/PaZVDrovh6vddf1nWUKl+v93pMbYGlv6bre4a23HUv9AsAkUJf//TzuLZQ0pECnfRzuF7X7treGjZsaF6j9bVUWyDp52X9fL1161Zp3769OZ7S7oRanP3JJ580Lar0eNqa6dNPPzWv3draSQfb0O7d2nJW3w+cr+HayklbTumgHtqNW3tO1K5dW/r27evqFqitr7SmlnerMG0FpV0G9RjaTVxb7+rtau1DZ4srfY+47bbbXPdPW4lpDwttSabbNWjQwHRHVHreOmlNLqfdu3fLhg0bTJdD3U9vA/CH4uxACNM3vKZNm5o3L+2Lrm8++qahbxb65UaL6jq/SOhQuNplT7v/ffDBB+ZNy9mk2b3Zr85rAKb95J2mT5/uGvVE17sXfNfwrE2bNmb+rrvukq+++sq8+U2cONH0a9c3LZr9AsDx0ddyDYn0tfvjjz+WN954w3xh0W5+7j8m6Jcg/ZKiwZbWnNIRpLR2iL/Xez2Gk34p0VGr9PVef3zQLxHOWljer/fnnXee+bKj7ynazURHwvJV3wUAwt3gwYPNa69+JtfXz+eee84VXOnrr3tY46Q/CuhrrgZKHTt2ND8o6Gd17crnXuRdj6c/EuhogXXq1DEhUa1atUztLL2u9LO2/pChP0boOt1Ga01p98KNGzea7uFKAzLt7q2XWgdRf4jQWoX6XqGf2ZVur/truRHtPqjBk3YB1PPUSw2YnCPN6u25F4zXsEtpOKbvL1q3y8m9vqLOa9d0/cFFgy/tMqjlRaiRiHyVdZMvAMXXsmVL22WXXVbgdtq8WP+5a1cO9c8//9iqVatmGzt2rLl+xhln2KZMmWLmX375ZVt0dLRt+fLlrq4huu3OnTtte/bsMeuOHTvmOvaAAQNsL774oplv2rSp6ZKi9Lbat29vu/zyy3mKAaCU/Pbbb6ZbR0ZGhqurSmxsrKurinbfXrFihZm/4YYbbLVr1zbdOrSrhnbpaNOmjek6Mn36dFvbtm09jq2v8bNmzTJdR/Q9RbucO7uHVK9e3TZ69GieZwAR6dChQ6b0hpbx2Lhxo1mmXejy67539OhRs8+iRYtsmZmZpjud7u98bXWnn731tXvBggW2tLQ0n8fT/XVf7f6tl3rdlx07dpht1qxZY27X3aWXXmq6jLuXC9Fujc73k27dupl5fY/R9xY9X6f77rvP7O88zksvveRaN2fOHNNVUGmJE+0m6ewOqecRFRVlzgvwh66CQIjSrn5aWHHAgAEFbqu/9OiIIfpLhv4So7+AaIsq5+hU3r/A6y9HOiqJ0ubB2vVPiz1q0XYdWcS9NZa2+rr55pvNvHYv1NvRX2K0uK+2tPI1AhYAoGRoi1j9xV4nbaV1+eWXmwLq+ou+tqLS0WK1VYDz9f6qq64y1/WXf/31XbuaaxcV/SXd/Vd/3U9/Ldf3isTERHNc3V7fU7R4u75X8HoPIFLpaHnuPRKUry6C7rQgufc+zh4O3vSzt/vofr5oVzxtRevektYX7Vmhky/aNVDfG/SzvxaO1+6Fvr4vaNF2/X6hXdjvvfdeU1j9vffek3nz5rm21dZU7i12ne8pehvaJVJ7aWgXSS0zou8l/s4JUBZNr3gogNCjdU20b7uO7qRdNApDm//qG6t+mdE3I/2yok1+ddQPba6rb3haB0X70OublPY9d3/z06FrtSm0+7IVK1aYQEz71qudO3ea2lbaTFjrrOht+WoiDQAoGTqqq9YN0S8B+tqs3Tu024j+4KHd+7T7iNZi0ddmrWHirNGi3cuddIQofU9wjlClXzScx3HvFqK1VPR13vu9AAAQevS7goZRWvO2f//+5nO/dj3X0QKfeOIJ09XvwgsvNLWztHuizk+ePNn8YH3//febAErfX7Tu1meffWa6JSqtu6g/aF9//fXmhxAdmVzDL+2SqIGc/hCuXRYBfwiugBD166+/muFmtd+7vkkEgubY+kVG62XxqwcAhK/Vq1ebllJa+xAAgKLQ+obR0dHy+OOP88ChVFCcHQhR2pRYf8kIVGiltIWUtsAitAKA8KbdONxbTwHhRssp6KAx2qJ89OjRhdpHu8MOHDjQdGk655xz5Ntvvy3x8wRCkXYnL6jrIhBIBFcAXLSbiHZBBACE/48fWo8ECEezZs0yXZicpQ20jEFBtNaOjsiZnp4u48aNM7U+L7jgAjOyMgBP2gWQkWRRmugqCAAAACBsaPjkHEhGBybQQEpr7ORH6+s8//zzpvustj5XOniBlk9wFpwGAJQNWlwBAAAACBvuox8X1syZM+WMM85whVaqb9++Mn/+fFNMGgBQdqLL8LYjmo62oMNSJyUlicViKevTAYCgpgMHHDp0yNR005HOQgmv9wAQ/K/3OuJmy5Yt85RQ0PPRz+w6Gqevll06ub/ea5dDHWmTz/cAELjXe4KrMqJvgHXr1i2rmweAkKRfLOrUqSOhhNd7AAj+1/vs7GyJjY312XIrKyvL5z5a9H3UqFGlcn4AEMmv9wRXZURbWjmfpOTk5LI6DQAICampqSbsd752hhJe7wEg+F/vtZXUnj17PJY5r+s6X0aMGCHDhw93XT948KDUq1ePz/cAEODXe4KrMuJsPqyhFcEVABTttTOU8HoPAMV/7SwtJ598svz8888ey+bMmWNaAVSvXt3nPtoiy1c9LT7fA0BgX+9Dq1BIEPbJ3Lhxo+nLDgAIDVqPZP369ZKZmVnofbRuybp162TXrl0lem4AgNLx66+/SvPmzWXTpk3m+qBBg2TlypXy7rvvmuurVq2Sd955R4YMGcJTAgBljOCqGDIyMuSJJ54wv7707NlT6tevb4baXbRoUeCfIQBAQCxfvlwuvvhiqVKlivTq1UtSUlLkjjvu8Fu7xOmXX34xXT86d+5sLvv06SMHDhzgWQGAIKXFfjWU0mnZsmXy3nvvmfkLL7zQtY2OFKhBlX6uV23atDGh1bBhw6RatWpy0kknme3vv//+MrwnAABFV8Fi2Lt3ryneuGbNGtMU+NixY3L11VfLpZdeKqtXr+YvCwCC0Lx588xr9ccffyzR0dHmy8zpp58uVatWlUceecTnPlrfRL+4DB06VB5//HETWHXt2lVuu+02mTx5cqnfBwBAwcqVKydffvllnuXx8fGuef3xecWKFeYHaCd9j7j88stly5Ytpq4V5TwAIDhYbNrfDcft7bfflltuucWEWIUZulcLkemv/VrEkTdFACib18xrr73WdPnWLiO+vPLKK6b4rgZYzi88kyZNkptuukl2794tFSpUKPA2eL0HgMIL5dfMUD53AAjm10xaXB0HHRFw//79pu7JmDFj5N577y1UaAUACJ7ug9p9xJ9//vnHdB9x/5X+1FNPNd0LFy9eLN27dy+lMwUAAAAiE8HVcXjhhRdk+vTppqhjhw4dZPDgwfkWA9bJPV0EAJSdF1980YRPb731Vr5dw72HQXde9x423YnXewAAACBwCK6Ow/PPP2+mtLQ0ufnmm02tlP/++08SEhLybDt69GgZNWrU8dwcAIjMHF26j0LPEcd9iBd+XOWaH3bWCRIMtM7VfffdJxMmTJB27dr53U5rYR09etRjmfNHiJiYGJ/7BPz13u05/3Pd3oAddm49/z+2eAuW5w0AAACRh35tAZCYmCgPPfSQaXm1YMECn9tojRTtu+mctJshAKD0ffbZZ3LNNdfIG2+8YS7zU7duXdm+fbvHMud1XecLr/cAAABA4BBcFYNz2Fx3OvqI0uJivsTFxZmCY+4TAKB0TZ06Va666ioZN26c3HDDDT5f35cuXWqGUneOOrVkyRLXa7z69ttvTXdBHSrdF17vAQAAgMChq2AxTJw4Uf766y/p37+/1KhRwwyp/uijj8q5554rrVq1CuDTAwAIFA2cBgwYILfffruccsopJqByBk1NmzY189pyVgOpadOmyXnnnSfnn3++dOzYUS677DJ54oknzAiEzzzzjDz77LOmGyEAAACAksWn7mLQIuyVKlUyAZb+Cl+7dm0TXA0cODDwzxAAICD0B4cTTjhBfvjhBzM51atXT7777jtXiNWyZUtXq9ioqCiZMWOGPP744/LAAw9IUlKSaa113XXX8awAAAAApYDgqhgsFotceumlZgIAhAYtmF5Q0XStW+VsieWkP1ToCIQAAAAASh81rgAAAAAAABCUCK4AAAAAAAAQlAiuAAAAAAAAEJQIrgAAAAAAABCUCK4AAAAAAAAQlAiuAAAAAAAAEJQIrgAAAAAAABCUCK4AAAAAAAAQlAiuAAAAAAAAEJQIrgAAAAAAABCUCK4AAAAAAAAQlAiuAAAAAAAAEJQIrgAAAAAAABCUCK4AAAAAoIxlZueU9SkAQFCKLusTAAAAAIBIN/6PdZKTY5OE2GhJiImSxNgoiXdcus8n6PWYaHMZG007BADhj+AKAAAAAIJAZrZNMo9mSurRzEJtH2212IMsDbtirZLgCLRMwBUTlWc+LjqqxO8DAAQawRUAAACAsDNv3jxZsmSJVK9eXc4++2yJi4vLd/usrCz59ddfZePGjVKxYkU5/fTTpUqVKhLMsnJscuhYlpmKEnR5Blq5LbzMOrfWXjoBQFkjuAIAAAAQVgYNGiRffPGFnHPOObJw4UK5//77TShVrVo1n9tv375devToYea7du0q69evl2uuuUamTJki/fr1k3BR1KArymrx02Ux2meLLoIuACWB4AoAAABA2Pj6669l0qRJsmDBAmndurWkpaVJp06dZMSIEfL222/73Of111+XQ4cOydq1ayUhIcEsu/baa2XkyJFhFVwVVXYxgi5niJW3FZejO2NstCQ6tomNsorVainx+wEgtBFcAQAAAAgbH3/8sZx22mkmtFKJiYly/fXXy6hRo2T8+PFiteYtaB4dHW0Cq/j4eNcy7S6oy1G0oOtwepaZCku7L8ZEWyUmyiqxURZzaabo3OtahN65XMOumGjHcue2up3Z3j4RhgHhhVdiAAAAAGFj+fLlcsopp3gsa9GihWlRtWXLFqlXr16efYYOHWpqYp133nnSs2dP2bBhg+la+M477/i9nfT0dDM5paamBvieRAbtvpiVkS1HJTtgx9SWX7EFhGGuIMwRgjkDMl9hmF7XYwIoGwRXAAAAAMKGBlQVKlTwWKatp/ILl7QVVqVKleTvv/82xdydXQZjY2P93s7o0aNNKy4EZ8uvoyUQhjkDLfcWYHo9zuO6Zxjm3UosymIxLcL0ePZ5bXVGMAbkh+AKAAAAQNjQwEnDK3fOwEq7DfrywAMPmNBq0aJFrtEHhw0bJhdccIGsW7dOoqLyjq6nNbOGDx/ucRt169YN8L1BMIVh2TnZciyz5G7DhFlWi1gtFtOF0gRcFvtynTfLLI7Qy2teQzDnds55+ySe27kCM+/t3I6nl1G5wZpzO4uFVmcoGwRXAAAAAMJG06ZNzaiA7jR80kDKX7Ck3QS1i6AztFK9e/eWF198UbZt2+ZzP93WfXsgMOGYLWgfSBOoRTkDrtxALDdky710bmefRDTz0uBLoy+zzCqi13S5Xne/1OW6jx5Lt7e4juFY7gjQ3Pdzvw2z3G197jae113nYr9R17EtXrfhftuEd2WD4AoAAABA2Dj//PNlyJAhJnCqVauW5OTkyOTJk6VPnz4SExNjttEaVt98840MHDhQUlJSpGHDhmYUQpvN5vpi+s8//5hi7TVr1izjewQEhxybTTKygjdYKw3ewZpyD86cgZd9W2fwZnIx+3XHanPhsd5znXOZ4z9xvi651nntk/f2nCFg7nmbpe7n4n6fCro99+O5ztPebbZDfXtX7JJEcAUAAAAgbFx99dXy7rvvmhZUV111lcydO1dWrFghb7/9tmubpUuXyh133GFaVWlw9cgjj0jXrl3l7LPPlrPOOsu00Jo4caI888wzjCwIwMVmE7GJTUzDuCBuHVdaEmOjCK4AAAAAoCiio6Plhx9+MK2slixZIj169DChlXvLKW1hddttt7mKuLdu3doUZP/4449l48aN0qBBA/nzzz+lffv2PPhAaaRBYhOL5IhFWz2KpkM55tJMjnlxn7flbu+9r867r/dcZj+Gsq/3nDctjMyy3Hmzr/u8zde+brfjuk929nM3Cx3na5+3r3Ofd6xz3Kfc9f72dbsNj3V51+du473OJHF5luWei/u6vPtaYrRu4MNS0mhxBQAAACCsaJfA6667zu/6li1byquvvuqxrGrVqnL77beXwtkBJcSEJ9li1YDFTNliNaFKtrnunLc6rudum20CF5/zZj+9LMS2Zt6xj+O6Pdyxhy7munvo5ApjaLkUqiy2EhytwA3BFQAAAAAAAWDNyZSonAyJstkvo818hkTlZIrVluWY7C13PIOhHFfgk3vdGTw5Ayd72OTa1gRPudt6t7ABwgXBFQAAAAAgouUJnBxhk32Zztuvey7Xy3TXcj0G4REQeARXAAAAAICQZM3J8gqW7EGSewjl0frJY3luCEXgBAQvgisAAAAAQKnSrm3RprWSIzyyeV6adc6AybVcwyedd4RTtkxXgWwA4YvgCgAQMXbs2CETJkyQzz//XDp16iRvvPFGvttv27bNDI3ubdy4cXL66aeX4JkCABD6LLYsic86JPGZByU+S6dU+5R5UOKyj1CUG0ChEFwBACLCzp07TVg1cOBAqVKlimzYsKHAfTIyMmTZsmXy3XffSd26dV3L69evX8JnCwBAaCCcAlDSCK4AABGhcuXKsnbtWjNE+tVXXy179uwp9L5NmzaVJk2alOj5AQAQcuFU1kGJy6LlFICSRXAFAIgI0dHFf8vTVlo5OTkmwBo6dKhpuQUAQDghnAIQrAiuAADIR+/evWXIkCFSqVIlUxurS5cu8tVXX8l5553nc/v09HQzOaWmpvL4AgCCAuEUgFBEcAUAgB916tSR6dOnu65369bNdDF84IEH/AZXo0ePllGjRvGYAgCCIJyyd+ejWx+AUEZwBQBAEboXdu/eXaZMmSJZWVk+148YMUKGDx/u0eLKvbA7AADHi3AKQCQhuAIAoAi2bNkiiYmJfmtmxcXFmQkAgONBOAUAdgRXAAA4bN68Wfr06SPjxo2T008/Xd59911p3ry5nHLKKWb9vHnz5KWXXjLF2gEACKRqqUsl+uheuvUBgBeCKwBAxOjRo4epUaWtprKzs6VVq1amddQ///xj1mtR9WXLlrkKqrdr107uvPNO+ffffyUhIUH2798vt956qzzxxBNlfE8AAOGm9v75Ilm5g3sAAOwIrgAAEePNN9+UzMxMj2VWq9U1X69ePVmyZInUr1/fXG/durXMnDnTBFkHDhwwxdrdtwcAAABQsgiuAAARo1mzZvmuj42NNa2wvCUnJ5sJAAAAQOniZ2MAAAAAAAAEJYIrAAAAAAAABCW6Ch6HxYsXy6pVq6RWrVrSuXNniYqKCtwzAwAAAAAAEOEIroph4cKFcuONN4rNZpMmTZrIokWLTGj17bffSuPGjQP/LAEAAAAAAEQggqti0BGpJk6cKG3atDHXs7KypFevXmaI9O+//z7QzxEAAAAAAEBEosZVMXTq1MkVWqno6Gjp3bu3GUIdAAAAAAAAgUGLqwDRllbuYZa39PR0MzmlpqYG6qYBAAAAAADCEsFVAIwZM0bmzp0rc+bM8bvN6NGjZdSoUYG4OQAAAAAAgIhQqOAqOzvb1HUKRzExMcc1GuCECRNk5MiR8tFHH0mHDh38bjdixAgZPny4R4urunXrFvt2AQAAAAAAIjq40lHzduzYIQcOHJBwVqFCBalRo4ZYLJYi7ffOO+/IbbfdJpMnT5aLLroo323j4uLMBAAAAKBk/fbbb3LXXXfJ0qVLpVq1amb+3nvvzXefI0eOyMMPPyxTpkwxPzKfddZZ8sorr/BjMwAEc3DlDK30xT4xMbHIwU6w02AuLS1Ndu3aZa7XrFmz0Pu+++67csstt8j7778vl156aQmeJQAAAIDC2rBhg5x77rmmt8Ovv/5qynlccskl5sfqm266yec+OTk50q9fP9m/f7/88MMP0qJFC/npp5/ks88+k2HDhvHgA0AwBlfaPdAZWlWuXFnCVUJCgrnU8Erva2G6DU6fPl1uuOEG8+amwdekSZNc66677roSPV8AAAAA/r3++utSpUoVeeKJJ8z1Pn36mM/ozz33nN/g6pNPPjGttFauXClNmjQxy3TUcJ0AAEEaXDlrWmlLq3DnvI96nwsTXOkvMgMHDjTz+iuOO4IrAAAAoOxoC6vu3bt7LOvVq5eMGzdO9u3bJ5UqVcqzz1dffSUdO3Z0hVYAgBAqzh5u3QMDcR/79u1rJgAAAADBZefOndKpUyePZdqzwrnOV3C1fv16adiwodx4442mxpX2ytCwS1tp1atXz+ftpKenm8lJ62IBAALPKqXogw8+kL/++uu4j/Pxxx/L7NmzA3JOAAAAAMKb9pjI7wdrrX2r3QU1vNq9e7csXLjQXJ5//vmufb2NHj1aUlJSXBMjhgNACARX2vR26tSp8uqrr8qnn34qa9eu9Vj/4osvyi+//BKQfutaZwoAAAAA3OmAS87Bl5w0hFLVq1f3u49OI0eOlHLlyplWVloja/HixXm+0ziNGDFCDh486Jo2b97MEwEAwRxcjRkzxvzKoKGVFjX8/PPP5bzzzpMBAwZIoF1++eXStWvXgB8XAAAAQGg77bTTTB1abUXl9PPPP5uRAitWrGiu67qsrCzX+m7dunls7xysSvmrgRsXFyfJyckeEwCgDGpcFcZrr70mDz74oHz33Xdy9tlnu5bri7+vllFr1qwxXf30TUBH+XAftfCbb76R//77zzTj1dFAunTpIieccILH/tovPSkpyaMLom6jy/0dFwAAAED4GzJkiLzyyity//33yz333GOKteso4Nprw+nbb781I4SvXr3aFGTXEcPHjh0rDz/8sAwbNkz27NkjDz30kJx66qmm+yAAIIRbXOkvEY899phcf/31HqGV0vDp3HPP9Vimfcf79+8vf/75p2md1apVK1Mk0Umb2e7YsUO2b98uM2bMkA4dOsgbb7yRb1dB7YKob1D5HRcAAABA+NNuft9//738/vvvJnQaPny4PPvssx6jf1utVvNjt7PmlbbE0lZZ8+bNk/r168sZZ5xhWmh98cUXETFYFQCEdYurpUuXml8kevfuXajtdeSNf/75R+Lj402hw+bNm8s777xj+oirq666ykxOGl5deumlcs0110hiYmKxjwsAAAAgMmhLqblz5/pdrz+uu3cVVC1btpQffvihFM4OAFCqwZWGVqp27dqF2v6CCy4w4ZLzl4527dqZ4WfdLVmyRBYsWGCOnZGRIYcPHzZFEU866aTjOi4AAAAAAAAiKLiqUKGCudTufYXhXbQwJibGhFNOQ4cONTWrtNuhjvrhLIaoIxYez3EBAAAAAJFFa+5r2f0csTjmLZKjyx3XzXKzndty7+vu2+n+juOY49pyl+e3zn25OS/Hcp2xzyuv9TZ7N1Xv9Wbe3/Hc7rPH9q7t7PfHuY/3Nnqbucc8vvPR9bn7ep5D7jZ5z9/5mPg8Tp7nN/c23Y/pOpaP2/a7vdvjkruN930q/O167GPzf9/z3d9rP6e85+R5XK+xJgp/ux5/G577+9zXEiVV3vpTPhrcRYI6uNJWUBoa6cgdWmPqeGhdKy2k+Pfff5vaVmrLli3ywgsv5BnlAwAAAABQcrJtFsm0WSUjxyoZemmzOq5HFf66a98o17HMpc3qCJMseYIln0GT+3be1/0GUtQnQ8nTv7wYyZYYyZIoyZYcsUqmREu2WM0SZ6gUrrZtOVjit3HcwVVsbKwZreOpp54ydajat2/vsV5DqI4dOxbqWKmpqeZSRwd00jpVAAAAABCpNIjJFosjQHIEQK5AKTcQKkyYlLuv53V7wOS2LMdqvnhHEnvUZY+7rBb7pV63Wpzr8l732M4MUOZYruvdt9OYzVzPbRuTO5+7n/08ctv5mGVux3Etc9/G4ueYjnPIvW9ex3ft5+f4ltxzyHN8H+fkfj7ex/R1XM9j5x4/d1ubCYKiJcsEQ3oZZcvOnTeXufO6PMrmtdzmnM+WKMlyXGZLtM1x6djXuZ37NrnL7PPe25tLM2lk6p+GqPatNKy1So7FcelYlu24rn9BZjuLRmG+trc65j3X6X7O69mu61FiM8fRZVGOYNe+n811PIvkmHX2f+s27+PpvPu5WfQv3P1cLCIxidK859US9MGV0qFid+/eLaeddppceOGFZkQ/rU+lxdK1q98vv/xSqOM0bdpUunTpYoamveyyy2TFihUye/bsQJwiAAAAAAQd7Vly3cT5smtLS8nItniFSzpvD5PKuvVQtCVHYi3ZEmvJkRidt+bkzutyq3Pefj3GY71u77avXlrNV+v8gyBL4cIk95DIGR6ZS8dy56OX322Zy/BuGHN8bDli1VBIp5xMsdoyJUqnnCz7fI79utnGMa+TxZYjFpvGIo5LvZ6jMawez77Mfd65ne6n8+HAHvu4DQbhr79eqPr8eZETC1c6qkyDKy2G/vLLL8sdd9xhhp7VLn8NGjSQSy65xIzo4TRw4EBp3bq1x759+/Y1+zuPo8PQao0rLazevXt3ee211+Tpp5+WunXruva5/PLLzdC2hT0uAAAAAAQji8Uif67bKxlZKYXexzNA8gyE7IFStkdA5NreESa51hcQLrlf18AHIcDmaFtjwiUNmjLdgqbCh0555m1ZZX/XdLI4Ww1FuVoLmVZB3vOOlkl6mbuP+7xzG+exNF5yLHNsZ2+B5DiGaQll9Zr3sZ9YzeNvcTwPJrgr1HVH51Zf623e67z2cW2X323ks39hzsH9unfSZg1IrJSvgN6CtpjSyZ8777wzz7IBAwZ4XE9ISJCbbrrJY9n//vc/j+u33HJLkY8LAAAAAMFo7CWtZe0fH0tMTnre8MkVNtkDJJ1oGRQmbDavcMk+bzWBkfu8/brPeR8BlemWWFKnrN3eLNGSY42RbIt9yrFG+53P0W19BEXuYVNuOORr3rmNVcR0VQt+9gBNwpfN0QpSW8XFxsnJl95f4jdZ8tEYAAAAAMCvC9rWlj8X7xXJSudRCmH6RT4mO01izXTEXMa4z+cczRNAlSQNfjRkMiGShkkmbHIPnfILoOzr3ef1GHpMktMIZ3F04NWA0Ronkphbo7ykEFwBAAAAAOCPzSbROcc8Ail/wVRxGtpo+6jccMkZNEWboMkscyzPDZ9y1+fdLzegCpUWSkBBCK4AAAAAABHJmpPhM5ByzjtbUBW2ULhWAMqMKicZUYmS4bq0z2da4yXbGpsndKIVE5A/gisAAAAAQFjRkem8W0T5Cqe0y15hZVgTJNMtiPJ1mWWNpysdEGAEVwCAiLJu3Tr58ssvpU6dOnLZZZcVap+///5b5syZI0lJSXLeeedJ1apVS/w8AQCADzab6ZJnD6U8W0d5dOHLOVbohy/LEuMKnjL9hFKZUQmmUDiA0kdwBQCICIcOHTJB1apVq8RqtUrjxo0LFVw9+uij8sILL8jFF18sGzdulLvvvlt++uknad++famcNwAAEcFmkyibZ7c9bS0V5+qul7ussKPm5UiUR1c9f8GUFh8HELwIrgAAEcFms8nQoUPlnHPOkWuuuUb27NlT4D5LliyRJ554QqZNmyZ9+/Y1yy666CIZMmSI/PXXX6Vw1gAAhBcNnpLSd0r5jF0mlHKvI1XYUfZ0RLNMa4LPOlL2cMrZbS+ObntAGCC4AgBEhOTkZOnTp0+R9pk6darUrFlTzj33XNeywYMHm+No66v69euXwJkCABAmbDmSmLnPBFVJGTvNZXz24Xx3ybTG5a0jZS0nGdG5lxpaMWIeEDkIrgAA8GPFihVywgkniMWSO7h1s2bNXOt8BVfp6elmckpNTeXxBQBEhKicdElK3+UKqbRVlXcrKm0tlRZTSQ7FVpNjMSleo+5ptz2+ogLwFNavCqtXr5bo6Ghp2LBhWZ8KACAEHT58WFJSUjyWVahQwbXOl9GjR8uoUaMk2HXe9Faht/3zbSlzc+sNLrXHoUujysd/4J4jirzLCz+ukrIw7KwTJOTMHF0yxy3G8xbs+LtCibHZJD7roCRl7LK3qErfIYlZB/JslmWJlUNx1eRQbHU5FFddDsdWlRxrLE8MgMgNrrKzs2X8+PHy+uuvm+CqU6dO8uuvv5b1aQEAQlC5cuXy1MI6ePCga50vI0aMkOHDh3u0uKpbt24JnykAACXLmpMl5TJ2u1pT6WVMTm4LY6ej0cmukEovj8ZUpM4UgOMSHY6jRi1atEjeffddefXVV2XNmjVlfUoAgBCl3QTnzZvnscz5vqLrfImLizMTAAChLDbrsCOksnf9S8zYk2c0vxxLlGlBlRtUVZOsqIQyO2cA4SnsgivtwvHGG2+U9WkAAELQgQMHzHvIpZdeKo0bN5YLL7xQnnrqKZk5c6b07NnTbDNx4kQ56aSTzHoAAMKBxRRR3+vo8mdvTaUj/nnTWlSpri5/1eVIbGWxWaLK5JwBRI7oog4lfjQzW0pbQkyUR2FcAACKQ1viam2qZcuWSVpamjzzzDOmFuI999xj1mu3QO3q16pVKxNMdejQQYYOHSqXXHKJXHPNNWYkwe+//15++OEHngAAQMiKzj4m5d1aU9mLqGfnKaJ+JKayvSWVo9ufFlAXvpcBCObgSkOrEx/5Xkrb8sfPkcTYsGscBgAoZVqfSruUn3POOa4WVjExMa71FStWlPvvv1+aNGniWvbSSy9Jv379ZPbs2aZW1QsvvOBzNEEAAIKSzSYJWQdcLanKp+/yXUTdGme6+jlDKnsR9dz3SAAoK6RBAICI8dBDD+W7vnLlyqYVlrczzzzTTAAABDtrTqaU9yiivkuifRRRT4uuIIfdRvs7Gl2B1lQAQj+40i572vqptOntAgAAAADc2GwSm33Y1ZpKu/6Vy9wrFq8i6tmmiHpuSKXzWVHxPJQAwi+40jpTdNkDAAAAgNJnsWVLuYy9bq2pdkpsdlqe7dKjyuWO9BdXXdJitIi6lacMQEgKy66Cq1atkoyMDNm/f78cOXJEli5dapZrsV0AAAAA4S09PV0mTZokS5YskerVq8t1111n6hQWhtY/fOCBB8xo5b66j5em6OyjuSFV+k4pn7lHrF5F1HPEImmxVRxBlb1VVUZ0+TI7ZwAItLAMru644w7ZunWr6/oVV1xhLp0BFgAAAIDwlJmZKb169TIDcuiIsH/++ac8//zzZpCNE088scD9b7rpJrNtbGxs6QZXWkQ9Y59Ha6qErNQ8m2WaIuq5I/0dMUXUw/JrHQAYYfkKp0OVAwAAAIg87733nixYsEA2bNhgWlvZbDbp2bOnaUX19ddf57vvG2+8ITt37pRBgwaZ45SKtH0iUwfJyZv+kOicjLyroyu6uvzpqH/HolMoog4gooRlcAUAAAAgMk2bNs20uNLQylmnd8CAATJ06FDTGismJsbnfto7Y9SoUTJ37lyZOHFi6Z1wfAWRLX+b0CrbEm0vou5oTaVd/7KtcaV3LgAQhAiuAAAAAISNNWvWSPfu3T2WNWzY0NTA3bRpkzRu3DjPPmlpaXL55ZfLc889J/Xr1y90HS2dnFJT83brKxSrVeTCN2Tx719KmrW8CEXUAcADQ0sAAAAACBtHjx6VpKQkj2XO67rOlzvvvFPatm0rV155ZaFvZ/To0ZKSkuKaClv83afm50paXFVCKwDwgeAKAAAAQNhITk42o4u727dvn2udtx07dsiECRNMiyytbaWT1sLau3evmf/nn3983s6IESNMAXjntHnz5hK6RwAQ2egqCAAAACBstGrVSpYvX+6xbNmyZSa0qlOnTp7tdfn48eM9lu3atct0K+zcubNUrlzZ5+3ExcWZCQBQsgiuAAAAAIQNLcTer18/M7Jg+/bt5fDhw6bY+hVXXCFWrSclIv/++6+8/PLLprtf1apVTcsqd1u2bDHbeC8HAJQ+ugoCAAAACBvnnnuuDBkyxIwseNFFF5naVbGxsfLUU0+5ttHWVG+//bbp4gcACG60uAIAAAAQVl577TW56aabZMmSJSbE6tmzp8TExLjWt2nTxnQPrFatms/9zz//fGnRokUpnjEAwB+CKwAAAABhR1ta6eSLjgCYXzdA7WKoEwCg7NFVEAAAAAAAAEEp7IKrzMxMU3zx7LPPlmbNmsk555wjX375ZVmfFgAAAAAAACI9uBozZozMmjVL7r33Xvn6669N//RLL71UPvjgg7I+NQAAAAAAAERyjasHHnhAoqKiXNe11dWcOXNkwoQJcvXVVwf0tnSI3A8//FASEhLk0UcfDeixAQAAAAAAIl3RgiubTSQzTUpdTKKIxVKoTd1DK/fug+6jiARCjx49ZO/evVKhQgXZvn07wRUAAAAAAECZBlcaWj1dS0rdg9tEYssVa9f58+fLF198IW+99VZAT+mZZ56Rzp07y2OPPUY3RAAAAAAAgBIQdjWu3K1bt0769+8vl19+uVx//fUBPbaGVgAAAAAAAAiWFlfaZU9bP5U2vd0i2rBhg/Tq1UtOPfVUmTRpkpS19PR0MzmlpqaW6fkAAAAAABDptCiRViayX1o8553rXPOWgrc1B7Vfd8w65u3b5y5zLHUucxzHOa//l3sMi+v4rvMO4G0UdLsex3BfVsyecSUbXOmZltKJHY+NGzdKz549pWPHjjJlyhSJji77GvSjR4+WUaNGBe6AM0dLqes5ovRvE4FV2n83kfA3Uxb/Fovoz3V7XfNdGlUOyDFf+HGVx/VhZ53gdx0AAADCkwYYVqtFrBYRqyPI0Uv7lF+441jub95HMKTHM7fpPLb9iulG5gxeXLeZJ3Dyc/tu+/q/k1YRa5RIVIyINVrEGuP7upmPEsnOFMnJclxm+rieZb8eDiylczNln+gE2ObNm01o1aFDB/noo4+CIrRSI0aMkOHDh3u0uKpbt26ZnhMAAAAAIAzCI0cwYwIja97wyBksuZa5hU3OwCnKT/DkfTzvgKp076zFERI5QiMTHvm6Hu22LNrP9XxCKI/rJVBhSQe+8xts+bie7R56+bvu4xh6O2EgOFKdABo7dqysX79ejh49Kg0aNHAtr1mzpinUXlbi4uLMBAAAAAAIf1FWi0RbLR6XnmGSZyiUGwblHx75CpmCgjmxWJHoeJGYeJHohNwAyBUERfu+nm8I5XU9HOhjFR0rIjqVoOwCgi1fAVh2hv913tctpfN8hF1w9fjjj8t9992XZ3mwtLwCAAAAAAS/KM1hrFaJjvIOoKz2S4/l1jxBVYFd0IKVhkMaPrkHUN6X0XEiMQmObRyXOpVE6yQUn7Yu00mfoxAWdmlOhQoVzFTSXnjhBVm7dq389ddfsmfPHrn99tvN8ieffLJUbh8AAAAA4J+2VsovaHLNR/kOn4KmJVNxaYsefyGTe9iUJ5Qq4VZAQKQHV6Wlfv36EhMTI82bN/dYrssAAAAAAMcfPOVp5eS8HuUZNPlaFvLBk7MweH6tnPILoGj9hDBBcFVMF110UWCfCQAAAAAIYxojxcVYJSEmSuJjouyBU1TeLnbOZVrHKWxoABVXvhhd8KiTDBBcAQAAAAACJibK4gqndLLPW818WLSCyk9sokhCJZHEyiKJlRzzelkxfAqLA6WM4AoAAAAAUORufLmhlD2YSoi1X9fuemFNi127AinHpQZVOq8tpwCUbnBls9kk3EXCfQQA5Nq1a5ckJiZK+fLl831YsrKyZMuWLXmWV69eXRISQnt0FgAACqJto2KjrR6tpsxlbJTERVvFYrYIU9oyLD7FLZhyC6niku3rAZRtcOUsMp6Wlhb2H871PioKqwNAeJszZ45ce+21smPHDklPT5cLLrhAJk6c6DfA0tCqYcOGUrt2bYmOzn3LfOedd6RXr16leOYAAJQcrSelgVSCozuftpxydvMLqzpTvmgdKfcWU86ASrv2acsqAGXO77/EqKgoqVChgvlVWukv05Ywe9HSllYaWul91Puq9xkAEJ72798v/fr1k+uuu06effZZ2b17t3Tv3l2GDh1qgqj8/Prrr9KkSZNSO1cAAAJNv8k560w5u/c5A6rYqDDv2meNFkms6NW9z1GDSoMrAEEt3wi5Ro0a5tIZXoUrDa2c9xUAEJ4++ugjOXr0qDzxxBOm9VTNmjXlvvvuk9tuu01efPFFSU5O9ruv7qdBV9WqVUv1nAEAKKrYKEtuOOUIpsy8du0Ls4YIHvS+aRc+j2DKEVZpl79wvu9AJAdX+sKmH+yrVasmmZmZEo60eyAtrQAg/M2fP1/atm1rWhA7de3aVTIyMmTx4sXSrVs3v/uefPLJEh9vL7Z61113yciRIz26DgIAUJqiHIXR3VtNOWtQhX1hdC1+7nPUvkp07QPCVKE+dWuwQ7gDAAhl2mKqcuXKHsuqVKniWudLbGysvPLKKzJo0CATXP38889y4YUXmh92Hn30UZ/7aO0snZxSU1MDej8AAJFVGN09mHKGU7HhXhhdu/YlVPA9al9s7g9QACIDPxcDACKC1Wo1ravcOVsT+/txplatWnL77be7rp9xxhmmJtb48eP9BlejR4+WUaNGBfTcAQDhr1pSvMRb3Ebui4kSa9h37UvyCqYq2ufjK9C1D4ALwRUAICLUqVPHjCroTkcXVDpqYGHpKINbt26VrKwsn90FR4wYIcOHD/docVW3bt3jOncAQNEdO3ZMNmzYYOoTere49efAgQOyd+9eqVevXqmPON64ajmRrNwWu2EpKkakUkORKieIVG5CYXQAhRLmHaABALDr0aOH/Pvvv66wSs2YMcMM0NG6dWtzXcMo/ZKjxdhVdnZ2nodPwy/9QuOvxlVcXJwp9O4+AQBKl44Wq3V6zz77bNN69tprr823Zq+OHqt1D/XHCd2nUqVK8tRTT5XqOYct7dpXs43ISZeKnHaXSKuLRWqcRGgFoNBocQUAiAham6pVq1Zy5ZVXmu58GzdulKeffloeeeQRU8tKaWjVtGlTmTZtmpx33nmmy5/NZpPevXtLuXLlZOrUqTJp0iTTVRAAEJwWLFggN910k0yePFmuuOIKWb9+vXTu3Nm85vvr5v3PP//ImDFj5NRTTzXXf/nlF/Pa37hxY3MMFJF296vS1N6yKrk23f4AHBeCKwBARNAWUj/88IM89NBDct1110lSUpIJsNxrWGm3kPr167tGHtRtX331VdP9T7uPnHDCCTJz5kw5/fTTy/CeAADyM2HCBDnxxBNdgZO2orrhhhvkrbfe8htc3X333R7Xe/XqJe3btzev+QRXhaxXlVTTHlRpYFXOPvgJAAQCwRUAIGJUr17dfKHxR0MrbXXl3u1Pv8x4f6EBAAQvbT3VqVMnj2VdunSRZ555Rnbu3GneCwqSlpYma9askfPPP78EzzQMRv6rWN9eq0rDKi20DgAlgOAKAAAAQNjQ4urexdid1/fs2VOo4Oquu+4yo9EOGjTI7zbp6elmch+MI+xFx4lUbmxvWVWpkf06AJQwgisAAAAAYUO7fbsHSsp5vTAjBT722GPy4Ycfyvfff28KvPuj3c21FmLYi08Wqaz1qpqKVKgnYo0q6zMCEGEIrgAAAACEjbp168r27ds9lm3btk0sFovUrl07332ffPJJGTt2rHz33Xdy2mmn5but1j8cPny4R4srve2wUL6qo17VCSJJNcr6bABEOIIrAAAAAGFDC6tr+KStrLRWofrmm2/MyII6QqwzZFq3bp0p4u4cWVZHHdRWVN9++6107969wNvRYzuPH/IsVpGUOo6wqolIQsWyPiMAcCG4AgAAABA2hgwZIuPGjZPLL79chg4dKnPmzJHPPvtMpk+f7trm999/l379+snq1aulSZMm8sILL8jIkSPNZYUKFWTRokVmu5SUFDMqYViKirbXqdJugFpgPdY+oi4ABBuCKwAAAABhQ4OnWbNmyeOPP26682kxdg2tzjrrLNc2Gki1adPG1WLq33//ldatW8vEiRPN5HT66afLyy+/LGFDwykzCuAJIhUbiEQVXPMLAMoawRUAAACAsFKvXj2ZMGGC3/XdunVztapS7mFV2NFuf1pYXcMq7Q5osZT1GQFAkRBcAQAAAEC40GBKC6o7i6uXq1LWZwQAx4XgCgAAAABCmTVKpEJ9R8uqpiJxSWV9RgAQMARXAAAAABBqouNEKjd2FFdvbL8OAGGI4AoAAAAAQoG2pHK2qtIWVtrSCgDCHMEVAAAAAAQrrVHlrFeVXLOszwYASh3BFQAAAAAEC4tVJKW2I6xqah8VEAAiGMEVAAAAAJQ1Z/e/yk1EYhPL+mwAIGgQXAEAAABAWWvRr6zPAACCkrWsTwAAAAAAAADwheAKAAAAAAAAQYngCgAAAAAAAEGJ4AoAAAAAAABBieAKAAAAAAAAQYngCgAAAAAAAEGJ4AoAAAAAAABBieAKAAAAAAAAQYngCgAAAAAAAEGJ4AoAAAAAAABBieAKAAAAAAAAQYngCgAAAAAAAEGJ4AoAAAAAAABBieAKAAAAAAAAQYngCgAAAAAAAEGJ4AoAAAAAAABBieAKAAAAAAAAQYngqpgyMzPlueeek7POOkv69Okjb775pthstsA+OwCAgDp06JA8/PDD0qtXL7ngggtk6tSpJbIPAAAAgMCIDtBxIs6gQYNk5syZMnbsWDl27JgMGzZM1q9fL88880xZnxoAwAf9ceHcc8+VI0eOyKOPPiobN26UK6+8Ul577TXzmh6ofQAAAAAEDsFVMaxYsULee+89+fHHH+XMM890fbkZPHiw3HPPPVKlSpUAPkUAgED45ptvZNasWbJu3Tpp2LChWbZr1y4ZOXKkXH/99RIVFRWQfQAAAAAEDl0Fi+Hnn3+WcuXKSc+ePV3LtPuIdh/87bffAvj0AAAC+drdqlUrVwDlfO3euXOnLF26NGD7AAAAAAgcWlwVg3YVqV69uscv7RUrVpSEhASzzpf09HQzOR08eNBcpqamFucURI4ck1JX3HNF8Cjtv5tI+Jspi3+LRXTkaO5rT2pRz9fPc3jsyGGvzVL9rvO3XdFOw77f8dQS1NfnWrVqeSxzXtd1bdq0Ccg+Jfl67/5cRpr8/q6Oh6/HtMj/TnwpxvNdUvexIMX+2wzH195QfCzC7O8qEK/3ZcV5ziH5bwoASllRXu8JropBW1bFxcXlWR4fH2/W+TJ69GgZNWpUnuV169aV0PF4WZ8AQg5/M5HyHD5YyKMVdrv8CqWnpKQE7LVbf3BwrgvUPuHxeh+MXpXQEjqvf8f77zK8hM7zFuzK8vW+rOg5K17vASCwr/cEV8VQqVIl2bdvn8ey7OxsOXDggFSuXNnnPiNGjJDhw4e7rufk5Jhj6PYWi0VCKRXVN+PNmzdLcnKyhAPuU+jguYrc50l/idE3Ne/WT0V97dZaVe727t1rLv29dhdnn3B5vS+ucPx3Wtp4DHn8IvnvLxCv92VFz1kft6SkpCK/3pf1414WIu0+R9r9jcT7HGn393jvc1Fe7wmuiqF9+/amvsmmTZukXr16Ztn8+fPNA9+uXTuf++gv9t6/2leoUEFClf5Rhts/Ru5T6OC5iszn6Xh/edfX7i+//NJ043O+Hs+bN890+z7ppJMCtk+4vd4XVzj+Oy1tPIY8fpH69xdqLa2crFar1KlT57iOEYn/7iPtPkfa/Y3E+xxp9/d47nNhX+8pzl4MZ511lgmsnnjiCVdrq6eeekratm0rHTp0KM4hAQAl7IorrjCtn1544QVz/fDhw/Lcc89J//79Xa2ntmzZIp07d5bZs2cXeh8AAAAAJYfgqhj0l/SpU6fKjz/+aJq11ahRQ9auXSsff/xx4J8hAEBA6Gv1Rx99JGPHjjWjBOrrt44Q+8Ybb7i2OXbsmGlRtX///kLvAwAAAKDk0FWwmDp27GjCqhUrVkh0dLQ0a9YsImqXaGj36KOP+ixOH6q4T6GD5yo0BPPzdN5558m2bdvkv//+MzVIGjVq5LFe++j/+eef0rx580Lvg9B5/kMFjyGPH39/kScS/91H2n2OtPsbifc50u5vad5niy0Ux5oFAAAAAABA2KOrIAAAAAAAAIISwRUAAAAAAACCEsEVAAAAAAAAghLF2SPIgQMH5JlnnjEjZlWoUEFuuOEG6devX6H23bdvn1x66aWSnp4us2bNci3XEmlff/21fP7557J161Zp3Lix3H777XLSSSe5tlm3bp1ceeWVeY45btw4ad++/XHdp7S0NPnf//4nv/76qxnpa8CAAT5vy5ejR4/KZZddJrt375bvv/9eUlJSzPKDBw/KOeeck2f7J598Us4888yA3HZ+MjMz5eWXX5YZM2aYwv/9+/eXwYMHF6r4f3Z2tgwcONA85h9++KGriPRPP/0kI0eO9LnPxIkTpUWLFma+a9eukpWV5bF+2LBhcvnllx/XfdK/k7feeku+/PJLc/zevXvL0KFDJSYmxu8+559/vuzatctj2TXXXCO33nprkY5bnNsuLH2Mp0yZIkeOHJEePXrIPffcI4mJiX63v/76682ADu769u0rDz/8sOv6mjVr5M0335TFixebf6f6b/Sqq64Sq9VapOMU17Rp0+Sdd94xrxennHKKPPDAA+Y8/NH77P6aoLp06SIvvPBCkbYpzm2jdPz111/y0ksvyZYtW8xrxYgRI6R+/fp+t9fXUP0398cff5h/f507dzb/5rSwvS9fffWVjB49OmB/w8Fm06ZN5v7pv1kdlVIfC31M8nsP+OCDD8x7gI5uqe+nd911lxk4wJ0+tjqa8aeffiqHDx82j99tt90mUVFREk4OHTokY8aMkdmzZ5u/IX0fuPjii/PdZ/r06fLJJ5+Yx17fB2+55ZY8nzeWL18ur776qqxcudK8bnfr1s08fvp+Hk5ycnLk9ddfN5/V9G/G+Xeiny/80cEoXnvtNZk/f755bHr27Gk+hyQkJBzXcRG45yjUrV+/3rxP6GfoG2+8UQYNGiThTAf00s92ixYtMp9r9DnWz+vun+3C8bPD22+/LatXrzYjNF9xxRXms30kGD9+vLnv+nn95ptvlnB0sJDflwNKi7Mj/GVmZto6dOhg69y5s+2rr76yjRkzxhYdHW2bMmVKofbv37+/rVWrVraoqCiP5ffee69Z9+6779p++ukn22233WaLiYmxzZ4927XNkiVLdAAA27fffmv7888/XdPBgweP+36dc845thNPPNE2depU27hx42wJCQm2F154oVD7Dh482NwnPbfdu3e7luu8Lnvvvfc8znfPnj0Bu+38XHPNNba6devaPvroI9ukSZNsFStWtN1///2F2veRRx5x3Sd93J303N3vi07nn3++rWrVqrb09HTXdvr86n1w32779u3HfZ/uu+8+W6VKlcz90ftVp04d27XXXpvvPrVr17aNHDnS41w2bdpU5OMW57YL4/nnn7clJibaXn/9dfM30KJFC/M3kR/9N3jrrbd63Kc1a9a41i9evNjWvHlz2//+9z/bDz/8YHvrrbdsVapUMf+uinKc4vrwww/Nv9+xY8ea14lTTjnF3Ja+fvjTt29f2+WXX+5xLitWrCjyNsW5bZS8+fPn2+Li4mzDhg2zfffdd7YLL7zQVrNmTduuXbv87qN/w/rv7uuvv7Z98cUXtvbt29vatm1rS0tLy7Ptxo0bzb/Jhg0bBuTfZbDR95NatWqZ90l9D7z77rttsbGxtrlz5/rd56KLLrLdcMMN5vXq+++/N4955cqVbRs2bPDY7qabbrJVr17dvE7MnDnTvB8/88wztnCSk5Nj69q1q61du3a2L7/80vbSSy+Zx2/8+PF+9xk1apTt3HPPtU2cONF8LtHHXN/bfvzxR9c2+nqZlJRkGzhwoNnm448/tjVp0sTWp08fW7gZOnSorVq1arb333/fvM7WqFHDdvPNN/vd/tChQ7aWLVua12J9bD744AOfj01Rj4vAPUehbsaMGbZGjRrZnnzySfNZ79FHH7WFs6VLl9qaNWtm/k3pZ7sJEyaY5zucn+Np06bZevXqZXv77bdtv/zyi/lcq58l9DU83C1cuNBWr1498x3roYcesoWr3YX8vhxIBFcRQt8I9YObewhx55132ho0aFDgvi+//LKtR48etjfffDNPcKUfcLx169bNNmDAgDzBVSACEHf6Qugd0IwePdqWkpJiO3bsWL77fvrpp7aTTjrJ9tlnn/kNrvSFpyRuOz/Lly83x3X/gK0fvvULvfs5+vLrr7+aL3+6r/e5edOwSr8I3XPPPR7L9fmdPn26LZD0C66GpPqBzElvQ8/RO7xwpx9m9L4fz3GLe9sF0edYn2v9EOKkfy96XH0e/NEgRv9O/NEv9llZWR7L9E1fnxf3L/0FHae49PVAv+Q5bd261Wa1Ws0XaH80lNLXkvwUZpvi3DZKngYA7oFsRkaGCa40VPbH+31Bwynnjxfu9G/9tNNOM8FL9+7dwzK40h8T9EuoPm5O+nj27t270I+fhrf6mGsg4/065h2AHT161BZONPzU+7lu3TrXMv0ioIGd92tlfp9LNHTp16+f67p+ntEvUe7H0PcJi8VyXO/hwWbLli3mdVQ/8zhpmKz30/0xdaePifdj8Mknn5jnITU1tdjHReCeo1Cn/0azs7PNfOPGjcM+uNLXZe/XK/3BX593X69X4eDIkSN5lukPMvqeH84OHz5sQkr9vKN/25EQXC3M5/tyoIVv+0R4+Pnnn+Xkk082TTWdLrjgAtmwYYNpvuqPdld6+umn5b333vPZnLV8+fI+l2VkZORZfu2115qmg9r8WZvmB+I+aXeVVq1aedwnbbr4999/+91P7/Mdd9xhunnFxcX53U67yPXq1cs0j1+wYEFAbrsw90m7KWizfPfjateR3377ze9+e/fuNd0ntNtfYbpWabc53cdX0+wnnnjCdHvT5q353WZh6TG0i955553nWqZ/B9r9QO9vfrQbh56LNqf+5ptvinzc47nt/Gj3CX2u3bvatm3bVurVq2e6ZeZH/+66d+9uupVqN0N32g3Du5uP/nvSbgT6N1DY4xSHdlHUfxvu90m7NXXs2LHA+6TdcvR50q632jz6/+3dB3wUZf7H8d+m03sR6YIoKtgLcDbEs5dDbGcXewf/d4JnwXLo2cV+nr2fiOjZQbHRFFFULIgISJFOgISEJPN/fZ9kltlNIaTtZvfzfr0m2Z2dnZ2y+zwzv6dpe7dmmep8NmqPztFHH30UcV7UxPbwww+v8LxE5wt+06vofOGGG26w1q1b23nnnWeJSumMmicHmyYrTddxVdPuyhw/NRfKysqKOH7PPvusa/qmJrVBWi7Rjp/y2W7dukUcvz/++MO+++67Mt9TmesSHTulqTNmzHDPVZA7efJk69OnT4XXBfWNvmd+0zOffr/6Tn344Ydlvkd5UPAY6P1q9tujR4/wsa3KelFz56i+0/cokZvIRVO6XNlru0QR3W2GmrPrXqpv376WyHSPq/uMI444wpLFVRXcL9e05Ek1ktz8+fPdjWCQ/1yvlUX99qhvo3vvvbdU3xoV3dC///77rl+mIP2IFQgZNmyY669CF4fqr6I6tN3bbrvtVu2Tghi60VffOcGgUzTdDKgPsL///e+WkZHhnqsflup8dmX3qV27dhEZXIsWLVxAo6L16thqvxTIqAy1u95///2tV69eEfPVl4r2+9prr3XbMWjQIBdkqA5ttzKwYEBNF2Rt27atcJ/UX5r2S31zbb/99i7goXbTW7Peqn52ZfZJyvpNVbRevX7WWWe5fnz22GMP11+X+oQrjy5o7rjjDpchNG3atMrrqc19atmypQua6jwpMHX99de7c7U1y1T1s1G71P+f+gKs7nlR4Yd+g8H0STdkTz31lD3++OOWjHmv+otU8KUyFJhWYDfYN4j6Z1Jg95FHHnH56/HHH+/6jYzuozAZr12iKcCl/Dt4XaJjp3kKFuh6RIUOWk7XL4lEx8i/hvApKNWqVastHj/1y6ZrH13rTJkyxf1m/b42q7Ne1Nw5Qv2kdFr99ilP1LlPZMq3dJ3qF0ZG922aSJ5//nnXr5eu25PFPlu4X65pidvrH0rdAEeXIvqZZHnRfkWN9QWsbMfc6gT1L3/5i51wwgl22mmnhecr6KCLQf+CR1FodfauL3l0h821vU+6cVYAQJ3jlkeZiLbL7xRTHc9t3LjRhg8f7kp6q/rZVd0nv7SmvPUqsKiOVMeOHVvp86TaEk8//XSp16ZOnRr+fAWtdAzUsbY6zqxq6Vh5+6TjVdGx0nfGf59uzHReFNXX91KPK7Peqn52ZfZJyvoOVLRedaIc3CfV2tOgB1dccYX17NkzYlmVwKomis6XBlSo6npqYp/UWXp5FNgMbotuAtXJsX5D6uy/MstU9bNRu6r6PQ9SbV117P7qq6+GL9AVEFMtSnXErxpXiay6eYUKg5QOKEi99957h+crT1LH7Pp9KC9dsmSJK5DRRbMCgomiusdv6dKlLt8+9NBDIzrIVbqqmteq2aLvomogK6CuawR1GJ0oqpMH6tpPN9bqWFmFRip4VN5T3fWi5s4R6h9d2yktUmuX6Gu7RDRq1CjXQkH3F7feeqtr/aOaOYlGLQd0Da77q2AQOpG1qMT9ck2jxlWSUI0HBYuCdKEmKtUpiwIbqvKn0Y80qfRNTRv0WBfMQRptSrVCVP1eTRiCFIGNHhFPN69qhhiLfVLJtUY0034oKCNqyqHSalFtp+iRXLS9ymRU1bWqn13VfdIx181JRfukkacUCNA+qZaSaCQ6NfuLpuaEGkFRAcZo0RdP2u/s7Gw3+kt19kmZVnTzMR2vio5VWduiUirVNKjseqv62ZXZJynrO7C1+ySzZs0qdWGjWlRvv/22ayrTtWvXKq0nFvvUv39/F2gN/r63tExVPxu1f1GitLuq5+Wll15yzZEVoArWdlFQWutUU0E/f1Fe89Zbb7nH+s0mioryCv97Xx4dE10IKnCli//o9ao2qUp4VcigGo0q5VV+kCzHb0vfQY1Kq+sS1d5VwCV4HaJSfzXf1PHS8dNoV/qeKshenXS0Phy/yv6GNRpjv379XDcP+i0r+KyaV9VdL2ruHKH+UcBcNVJ0beeP/J3IdtttN1fTXgUrmv72t7+5a9xEo8oDCjRfeOGF4esa3RurIKmyrWHqm9RK3C/XNGpcJQkFlO6//353A+/XnFGkXzeUGt68LP4Fik/D9Kpqq2r4BG+kFy1a5Ppk0np0cRjsy6OiUtDqDjmtfdKFpn4cfr8LfumF+hsqi26Mgv1cqLmiglcqBejdu3eF26v9UhCuqp9d2X1S8xGVBqvpgl/irkReiX95NRrUrNP3448/uuCVSuGj+z/R+VfgSjXiKtMXivZbqnOutE/6XPUlopIWUfBQNxXl7VNltqUy662pz47mv1fnxu//RwE+HfuKavNtaZ98qlWmmwQ1zaioSeuW1rM1dtppJ5ceaJ/877CCprp5vvLKKyu9HgVZVeJS0bZEL1NTn42apfOjGrM6L8FatErrtvT7eeWVV9wNrwIBCqoEKRijfl2CFKjdZpttXM2i6uYN8URpkI5fkI6f+gtq0qRJue+bOXNmOCBVVtMKNblQ/hO8aNTx839fKpxIlOOnPhnVtNIPgOv46YJZTdu3FLRS8xTdJEbndwoU6HgFg1l+E8Syggj1+fjp2H377bfh46U+RpVfbU0e6H+3VqxYUaPrBccymej6UE2/FbRSzfNko3REaYTuwxKpL0FRzd3oAJVaQiiQc9FFF1myWBp1v1zj6qwbeMTUvHnz3Ag6Y8aMcc9Xr17thiwPjuL0888/uyHoZ8yYUeY6NPx09KiCixcv9nr27OlG69FIdWXRMJk//fRTxPDqGpFtS6OMbcmqVau85s2bh0ds0Kgd++23X8QIWCtXrnT7FBylL3q41uhRBceOHet99dVX4ecafU4j3J100klb9dlVoZF8NITq0KFD3XONQnLUUUe5oeSDtE/ljbam41veqIIaWl2vzZo1q8zXPv3004iRwHbccUc32ld1hzPv27evd8wxx4RHVTn77LPdfgZHLtLoZQ8++KB7PHny5IgRyP744w9v33339Xr37h0eiaYy663sZ1fFoYce6kZH8Ufxuuaaa9x3Qt8Nn4Zav+mmm9zj77//3nvxxRfdNsnatWvdSFcdOnSIGH3l0ksv9Vq3bl3mOdqa9VTFGWec4YZBX7NmjXt+7733unTjt99+Cy9z5ZVXuskf+U+jc/nnRCMf/vWvf3XDzOucVXaZyn426t6//vUvNwLpL7/84p5rKG+NhBRMUzXybHDENo2OlZGR4T311FOV/pxEHVVQI9DqeCl9lblz57rjGRwVVMdSabryK/n666+9li1bVphHfvPNN+4Yf/TRR+65Ri1UHtWjRw8vkWg04kaNGoWPl0bgUn44ePDg8DILFy50x++zzz5zz5Wf77zzzt4hhxwSMRprkIajV/rij8qo9EnpWtOmTSPS8PpO+6V8fMiQIe6x8o1TTz3VjXal0Sp9Ola6xhN9pyZOnBh+TXnlRRdd5NJs/zta2fWi5s5RokqGUQVF6YvS/rocgS2WNCK27j19S5cu9XbffXdv4MCBXrJI9FEFx1bifrmmEbhKIrqZUMCoe/fu7kLw4IMPDt8kihJTBTX8C+HKBK50Y6737Lbbbu7C0Z8036dgiC40FSxQkEsXi0rAa2LIaV3wt23b1q1b+7bXXnu5G+XgRa+2Tzf6lQ1c6aahX79+7sen4J5uDjSEqwIEW/PZVaXAU5cuXdzw5wpg6IImGPgTbfM999yz1YGrE0880Z2fssyZM8cF3rRPCiDoPJ1wwgkus6kubb/2Q/uj/dL+aTuDNLz53//+93BAVDcmyuR1A5KVleWGj48eGroy663MMlWhc73nnnu6c9+pUyd33CZMmBCxjIJm/s24gsVnnXWW16JFC2+XXXZxv0EFvoLnSTcLOncdO3aM+D1pUmC5suupKq1b6YLWqXRC+xYcolv0HfEDtLopvOyyy8Lbops+7fOUKVPCy1dmmcp+NuqeAr76vik92H777d1v8bbbbotYZvjw4S699JdPT093N7nR3+Hnn38+6QJXcscdd7jjpuOn46ggbfCGVPmTfvfKr0R5ifLa6OP3j3/8o9Rw6gqWK6Cv9KdPnz4uoJVolE8rkNe1a1f3vVJ6F8yzlXfp+Gk5UZBFz5XOBI+f8jOfggOXX365Oy86fgr8K90NFpgkiu+++85de+k7onxW6auuc4KU3vrBAxVaqbCnTZs27hjqNd1wBgu2Krte1Nw5SiS6xvN/l0oTlX/osX67iejjjz92aZK/n8FJN/uJSNezun5Xuq00Vmmt0mA/n0sGiR64+rqS98s1KaQ/tVOXC/FII0SpOrdGeIruNycnJ8f17aAmc8ERzHzqUPfXX3+NaH6mzuj8quNBauoRXY1fbX01oqDadNdkFVG1Kf7hhx9cfx9qfhH9mpqJqcPqsvoKUJMKNe9Ss4vodrpqsqd90zDc0cO6Vuazq0PNpLRebZNG/ovuI0ydHOr8tW/fvtR71WxQ1fc15Gx0B4FqeqXOkP1miGVRvwrq6FfrL2tY8apSUqPvnvqpUrPS6KGBtW1t2rSJGMFSfbX4zSbLa/qypfVWdpmq0m9Avx2tN7qZrM6DvhvqYyV4fvQ7UrOU6O+k9lfnvSyqVh78Hla0nupSc0r9NnbYYYdSTWz0exG9FkxXdBw0EqVGbCxLZZbZ0mcjdpQeahAIpd/Rv0X9RpVu+E2ElD6VRYMI+E2OoqnvOuULwd9KItFvW79X7X90uq1jpw6wNfKS0hClG8Hm3z6l3dH5jJ+nKw3o2LFjqbwiUahZmtIeNa+M7hdGr6lppdIMXdvoOKupYDSlJ9FN+dXcUmmOrlmUz9Rk3hBPlAcqb9F/5VXRg618+eWX7nup71DwO6tR7TS/vDR7S+tFzZ2jROL/ZqPp3qOibjvqKzWP8/tnjaZ7pURqHh9t4cKFbv+VvlbUPD4Rff311y7fDqarieiPStwv1xQCVwAAAAAAAIhLiRvOBwAAAAAAQL1G4AoAAAAAAABxicAVAAAAAAAA4hKBKwAAAAAAAMQlAlcAAAAAAACISwSuAAAAAAAAEJcIXAEAAAAAACAuEbgCAAAAACCJzZo1yzp27GjZ2dmx3hSgFAJXAAAAAADUgd9++80FiL744gv3fObMme55Tk5OnR3/sj4zPz/fFi1aZEVFRXW2HUBlEbgCAAAAAKAOFBQUuABRXl6ee67/dR0wKusz+/btawsXLrRmzZrV2XYAlUXgCgAAAACAGNS+OuaYY9zjXr16uVpQl19+uXu+ZMkSu/DCC23HHXe03Xbbza666qqIZnxTpkxxy0+YMMEOOOAA69q1q6vFtXTpUjdfU7du3WzgwIE2duzYLX7mDz/8YPvuu6+tW7cuvKzmDRkyxHr06GF77LGH/etf/4oIdvnb8NFHH9kRRxxhO+ywgx177LE2Z86cOjl+SB5psd4AAAAAAACSTadOnew///mPCyQp+NOwYUNr1KiRrV271vr372+HHXaYvfTSSy5YdP3119vRRx9tkyZNslAoFK41deWVV9p9991n22+/vbVr185SU1Nt6tSpbv1a5vPPP7czzzzTmjZtaoMGDSr3M+fOnRtRC2v16tW2//77u4DUa6+9ZvPmzbPzzz/fBc9uueWW8Pr1nuHDh9vdd99tbdq0sREjRtgJJ5xg33zzTUyPLRILgSsAAAAAAOqYgkwK9kiHDh2scePG7vHtt99urVu3toceeii87PPPP28tW7Z0/VPtvvvu4flaRgGmINWC8m233Xb29ddf21NPPeUCV+V9ZrQHH3zQBbSeeOIJ954+ffrYmjVr7KKLLrJrrrkm4n3//ve/XY0sufnmm23XXXe1P/74wwXSgJpA4AoAAAAAgDgxefJkmz17tmv+53lexPTLL79EBK6Cj33PPfecPfnkk7ZgwQLLzc11zf923nnnrdoG1Zjq16+fC1r5DjzwQLe+n3/+OeJzg+v2g1UrVqwgcIUaQ+AKAAAAAIA4sXHjRjv00EPt/vvvL/Waal0FZWVlRTxX08JLL73UxowZ42pBqYngPffcYx9//PFWbYOaAUbXxsrMzAy/FhQMbvkUZANqCoErAAAAAABiwA/6BAM9O+20k73++uvWvn17S0vbulv2999/33WQfvrpp4fnzZ8/f4ufGU0dt6vj9yA1U1T/Wj179tyqbQKqi1EFAQAAAACIgW233db9/+mnn8LzLr74Ylu2bJlddtlltmHDBjdPzf5Ukyo46l9Z1L/VtGnTbOXKlS4w9fLLL9u4ceO2+JnRNKLh999/7/rQ0no0WuHIkSPtlFNOcf1vAXWJwBUAAAAAADGgDtIvueQSGzBggAsoXX755dajRw9X20k1nJo1a2bNmzd3/Uv17t3bdZhekWHDhrngldar99566602ZMiQLX5mNHXqrmaHt912m2tu2LlzZ+vWrZtrggjUtZBH41MAAAAAAGpdYWGhLVmyxNq2bWsZGRnh+fn5+a5D8wYNGliLFi3C89evX29FRUUueBSkfqaWL18eMYJgkN5XUFDggl6qpaVO1fWZQcHPVH9WGglQgSw1BwzS5+h1LbelbdC2Ll68uErNHIHyELgCAAAAAABAXKKpIAAAAAAAAOISgSsAAAAAAADEJQJXAAAAAAAAiEsErgAAAAAAABCXCFwBAAAAAAAgLhG4AgAAAAAAQFwicAUAAAAAAIC4ROAKAAAAAAAAcYnAFQAAAAAAAOISgSsAAAAAAADEJQJXAAAAAAAAiEsErgAAAAAAABCXCFwBAAAAAAAgLhG4AgAAAAAAQFwicAUAAAAAAIC4ROAKAAAAAAAAcYnAFQAAAAAgaaxYscK+/vpr27RpU6w3BUAlELgCAAAAACSNu+66y/baay/zPC/WmwKgEtIqsxAAAACqLj8/39avX+8eh0Kh8P9GjRpZeno6hxYA6tB3331nPXr0sIyMDI47UA9Q4wqoY48//rgdcMABpaomz5gxwwYMGGBffvkl5wQAEsRTTz1lu+yyi2VlZVmrVq3c1LJlSze1aNHCpk+fHutNBICkkZOT45oIzpo1y9q3b+8ea5o/f757fdGiRfbtt9+Gl9f82bNnu8dLly4NL//NN9/YwoULrbCwsMLPW758uf3444+2cePGCpstapnc3NxylykqKrLff//dFixYQC0xJCUCV0Ade/vtt10mFl3C/umnn9rnn39unTt35pwAQAK4+eab7eyzz7add97ZPvjgA/vwww/t4IMPdq8de+yxNnr0aNt1111jvZkAkDQmT55sp5xyigsA/frrr3bWWWe5afz48e71Sy65xI455hgX2Orfv79Ls08//XT32pgxY8LLn3baaa5QYtttt7Vnn3221Oe8/PLL7nVd1x911FGuoOLCCy+0DRs2hJf53//+Z7vvvrt1797djjzySGvatKkNHTo0IsilQNvVV1/tCjv2339/69evn7Vt29buvPPOOjleQLwgcAXUsa+++sr22GOPUvNV46pjx44uM/J9/PHHFZa+1AerV6+2adOmxXozAKDOm6GMGjXK3eC8+OKLNnDgQDvooIPshRdecE0Emzdvbtdcc41rKqiblI8++qjenyHVTPjhhx9ivRkAUK5DDjnE7rvvPvf4ySefDNeguvzyy908tXzIzMy0Rx991N59912bO3eu3XLLLe61W2+9Nby8amWpptQJJ5xg55xzTrgpuF9oceaZZ9p5551n69ats19++cUVWjdr1sxSUlLCn60A2YknnuiulfU5Cqopj7jhhhvC69I63nnnHRdIU6BNta6mTp1qK1eu5CwjqRC4AuqQMiZd2JcXuArOz87Odjc69b3TyNdff91l4ACQTB588EH3/1//+lfE/Hbt2rnmgsGbji+++MIuuugiq++0r6plAADxTIEnia7x+scff7imgmqWp87bmzRp4uYffvjhEcsp/VbhhKZtttnGCgoKXBBLJk6caNdff7099NBDLhiWllbcpXTjxo3t9ttvtwYNGrhAlmpfXXzxxa4AIzU11S2jzuKHDBlir732Wvizxo4d6z4/2CJju+22czV2fap9pRYd9Znud7Tva9asifWmIE4RuALq0MyZM93/6MCVqg3/9NNP4fkqnXnmmWesdevWrvRl0qRJ4WVVMq9aW3PmzIlYh0p+VAqj4Jjeo3WI+tJSyczixYvDy65atcr1q6KMWQEzfXY0VU3Wayrdic7s1cZ/yZIlbrtUI0zbM2HCBPdc2+BT6ZFKq5RJ63WVxKvESesN+uSTT8JVp3UDpwsC9RugGgi6GPCPibZZ8wEg3inN23fffa1NmzYR85Umr1271qXvorRZNykKZuk9wfRRBRiqsRpMv0VpvNahG6wpU6aE+0xUOqnnwQt/vxZUXl6eey2YRvu0vD5HaXt0E3alzUrLVQNY9F/bqdeUlwTzN22X0my9rs9R/vHzzz+Hl9E2qLmkT4/Vab36dtF7fboBpEYBgNqi9KpLly6u+V2QrkHlqquucv0SBim9U5BJ7+nZs6cLsqhGrYJGCkppfaLaWTvuuKNrJl6ee+65x6V9akKo4Jeu4VWjSpOCWMuWLQsv26tXL3vggQfcZ6s2mK7do+meob4P8qH7GjWpV21koEwegDpz5513eqFQyFu3bl3E/EmTJqlalffWW2+551988YXXs2dPb5tttvEGDhzonXHGGW7+K6+84rVv397be++9vTZt2ngXX3xxeB377LOPd9ppp3k777yzt/3223tdunTxJk+e7O2xxx7ennvu6WVlZbn1yuOPP+7Wse+++3p77bWX16BBA+/GG28Mr+uZZ57x2rZt69bZqlUr729/+1v4tZ122sk7/vjjve2228475JBDvI0bN3rnnHOO284//elPXuPGjb0xY8a4Ze+66y6vWbNmXt++fd3r+ty7777bO/3008PrW79+vZeamuplZ2e75+3atfMGDx7s9v/oo4928+699163Hdre5s2bu+MIAPGqoKDAS0lJ8f7617+Weu3999936b3Sc3nxxRdduq40T+nkqFGj3PzRo0eH0z2low8//LCbX1hY6DVs2NA777zzvF133dXr0KGDd/DBB3tvvvmmS/979+7t0u8VK1a45S+99FLvqKOO8nbccUeX3mdkZHivvvpqeHuuu+66iM95+umn3fzc3FyXNg8ZMsSl+2effbaXn5/vDRo0yG2n8pAmTZp4H3zwgVv+ggsucPmb8gG9/sknn7i8S/mAT3mS8g5ZsmSJW7/yE+3HFVdc4Y6btlf5m5/e/+9//6vFMwUgGfXq1cs77rjjSs2/4YYbXPo8b968iPm61u3Tp4+3ww47eNOnT494TfP79evnHufl5bm0/6qrrtri5yt90/VxWdNf/vKX8LJKK7U+5RHaNqWPN910U/h1pbNpaWku3T322GO9n376yc3/7LPPXLp61llnee+++25EHnTrrbd6b7/9trtvGDFihEvvv//+e++iiy5yectvv/0Wzm+0LXpt+PDh7rMmTJgQsS8ffvihS7d1L6DHvjfeeMNdvz/33HPeySef7LZBeY+2Ucf+/PPP97788ku37HfffeeOYdOmTd3rWldOTo7LH3RMfbqH0HpF69V9xaOPPuqdeOKJ3ueffx7+3AsvvNDth3/fg8RA4AqoQ6eeeqq7QYmmBF+Z0dKlS8PzLr/8cndD4Zs2bZrXunVrb+bMme75mjVrXJDnhx9+cBlLo0aNXEKtx5s2bXI3M7qB0HKiRN2/IVJGpu3wM7f33nvP3QgVFRV5H330kbvpmT17tntt2bJlXosWLbwFCxa4jFuZo/85ZdGNSadOncLPtR3ffPNN+LmCVsEbGWU03bp1c4+1/zoO1157bfj1l19+2evatav7fJk7d64Ljm3YsGGrjz8A1GXg6ogjjij1mgI/LVu2jEjD9t9/f2/s2LHh5//5z3/cjY1uWEQ3DUr3tN4ff/zRpZMPPfSQe23x4sXuuS70lfYrHdd7x48f714/4IADXAHGqlWr3PPbb7/dBYXkvvvuczdJfpBLF/nKZ0Q3FMHPKYte8wsYtB0qBNE2+nbZZRdv4sSJ4ecPPviguxER3cRo/UrjfbqBOvDAA8MFGX4wDgBqigpMlT4HC2x9Rx55pLftttuWmv/666+79ErBnqA5c+a4+X5Bsn8de/PNN1e4DbquHjp06FZvu67b//znP7vP0PW2n45rfePGjXOT8pZ77rnHFWCrIPmBBx5whRMKZIkCUJ07d3aFDSqo7t69u3fKKae4tFzPtf5jjjkm/Hk6VkqXVXiiNFqFH/41+S233OIKI/SaglTajq+++sq9pvXruQJIKqjRsZk1a5bbRuV3usfR6ytXrvQWLVrknXTSSS7P1Ou6F9F9j39/4Nttt928d955xz1WIbf2S/c0Cogpj9P9lPIdBbRU+KPgoB+EQ/1X3OgWQJ1VTVZTOVUJ1kgjftv1Rx55xI02or5PgsuqqrLvn//8p+vzSk061IROgWe1q1dTDHX0qOF41b+IHvuT2tirI0jJyMhwVZlFnz9y5Ejbfvvtw23q1TRQTUJUxfmII45w7fzVbESfow7j582b57a9YcOGroqz37mkqLqzmoOoarPe5zdT1HM1+1OV6eB+qWp18Hnfvn3dYw0trA7qb7rppvDrevyXv/zFNVVRnwDaHm2DmqH42w8A8URNPfbee2/XFE6jxWpkKjWT08hQagrxxhtvuHRMlKapCfZuu+0Wke5pxCo1oVMzPy2jDt2Vviqd3GmnncJ9YiltV3qsPMLvS0VNRoLpvfoaVB7jp/ePPfaYa26ijobVB4uWKSnMdHmMmijqc7QP0X1vqQNiNelQsxml7356r7Rc+ZrfV4v2V9se7EMmOr1XXqOOif31Km+5++67XXMYbYuaHSrtB4CaovRL6Z+a4EVTU+0BAwaUmq+m2aJR/3y67lYfVeKna7peVr9Y6kIjmtJEdfou6q9Kn+Wn7UHqEkTNFPWaHqu7DZ+uezUi4nvvvRfuf6t9+/Yu/zjuuOPC+3fddde5NFajFYq6EVGTdOVFmq8+s3TvIbNnz3ajG2qblXeoefvf//5395ryBg0g8tJLL4XvUdRRvJp277DDDu6+Q+/XyIqibkSU32h79Dl//etf3UiMPq3Dv//Rtb365dJnHHDAAe6cqOmkvx/qHD+Yf6hJ/Pfff299+vRxz7X+yy67LNyRvfJW3VNpe/zmhspD9RmJ0IckzAhcAXVEgSEFdw488ECXcfTo0cNd9CsT2meffdzNjV5TP1HKrJQgB29k9LqW9Uc2EfWJojb1Wlb9Y/mZmDIoBZ2Cma8yBn84Xz32R1QRbZcyKt3o6HN0sxL8HAWTNKlvE2UuwXb/ygiVcWhbNKlvEu2bf5OiYeD9dvfKgJWJBDMi9ScQzIQGDRoUDorpQkGZlDJlveZTphccfREA4o3S2D//+c8uHe7atatLk5UW/vvf/7ajjz46vJxf+NCtWzf3XP1W+aNGafIpn1DfKkoLlVf41CeKCgf8mwpd3KvfQqW96htLASENnx5M73Uzo5sbvyAkOKKhCkiUF+hztP1BuknRpP1RoYiCSkqz/fQ+mGf5nRYH+5BReq9glUSvXzdxOj668QgKHisAqC4FWZTWKMCiTs71WEEYXb8qnd5vv/1KvUcjwiqA87e//c1dH+v6VIF2FeiKf12rINSIESNc4bAKKhSI0bWvCjEU1Pc7VP/HP/7hgvaDBw+2oUOHuoIF9UeoPl8V3NK6FfjXNbdGFVQarmtspZM33nijG8VQaXxZae/zzz/vrtO1rX6BhAp+de/h5xkq6PAtWLDAzjjjjPC1uvqSVRrv3y+ceuqpEQXrKiDRvjz77LOuAOaKK64If47yHqXxeqw84Omnn444jsrT/vvf/7o8ToE85Uc6rv5+DBs2LLysngfvF3Q/oPucDh06uIL23377zS655JLw6/osFeToePrbo3zGD5Sh/iNwBdQRZRQqnVGGpiCTMhEFgxSUUY0lJch+wEeZlxJcP+MQlUSo9MHPqEQ3JLrBUElIMHFX6b1KkvwAk25k/JJvZcrKaP1ScVGnj8qY/BEMlfgHP9v/HJWa+KVKotJw1Z5Shrznnnu6ecr8giX9flDK3y9lOv6NjC4SVPNAN3L+MfLX4++zbuiCtROC2wMA8UoFAErnVdqrNFc3S4ceemi45pMvWAPXT/d0A6GBLfwaVKILdaXpSiePPfbYiPQ+mP6rtFkdvyu4r3UE03rlQSpl142GPkc3DCql9kv8lQdowA2lu/qcSy+9NPxe3ZDcdttt7r8KOpT+K5imGlz+fuy///7h5bXvfp4muuHSTYSfJ2j9559/fsR+6xipY3efPkPbDAA1RenX+PHj7eGHH3Yj+ynd02ATCoToGlfBomidOnVyowUqcK9O0lXQ8H//93/umlojyAbTcF3nq1bsCy+84AJYCuArzVYtWt8JJ5zgAjMaefCOO+5w2+B3+K58Qnr37u3SZwWIVBCiQI8+98UXXwwXGIjWE1y30l59noJmQQrOaXtVuB28llceouCYT+m0n6coXQ8WgqvAXXmM0v7nnnvOBd4OOeSQiM/RfYoKNZSPBVtGaD9UO0q1n/R+1ex966233LFSzV0d/+A9g/IIv6BDVHjuv67t0rHwBznx91vHIXgfIWWN5I76icAVUEf8asNKdFWFNZiwqoQgWFqimwbdPChTUABJmYZKnVWKMHz4cBfo0g2JMj5lTspkom9kgutT0EolNbqRUSaokhOVauimQdWNNZqUJt28HHnkkXbmmWe65iOqJaZM5dxzz3WZpD4nWN1WNxqaFFhS6YmqD7/55puuqYfohkkZqtahDFnboKCTMmBdOGgUFJVaBZuOqBTJpxs8lXyddNJJbhvUNEUXG6NGjSo1hDEAxBuleX5N1/IondRFvkr/ld4rbdMNhpqD6CJcQa9x48a5EnjdBCidVIl7eel99E2HmraoVFo3F08++aTLB7RNfjNwPVbJv25oVNvp8ccfdwUFumkI3kQoiKR8Sctov7RNSt/9wJX2Q0EnBav0PuUzClbp5k03JVqvChxU20s3YAqABdevPFH5gbb1sMMOc7UAXn31VdeExW9eAwA1QU3lNAXpWlvpaXkUbImuESq6No92zDHHuKkiuvZVgXRFlJZv6XpXtXZVEO5TjSRdk/tN7lR4rXsG5Su65legSPcdotpgqvUU/AzlIX5XJcoH/MIW5RmqRab1KpCnz9H9iP85euznATpOwfRddE+jJogXXHCBK5DQPYi2RU0h9TmqxRsspNY1v194o1pgCvApsOdvY/T6tT26f/K3R/cbGklX24rEsLmTGgC1Shf4ql0VPTR6WdT2/f7773c1qXTRLyqVOf74491zNSdUgu8Hq1SDKbpqc7CUQqUramfu38joJkXr0k2M3qvmG37G9NRTT7nSHmUwn332mcu8/JIdbXt0wE03W6oOrCaDCjr5TWNEwSY91r7oBkYlIwpWqdRK1YVVcqXPUlVtZYjKeIOlQKJAleZpWxX8U58sBK0AJAql1aq5qppQShtFNxdKF5944gmXZvtBK91k6OYjWPNWtViDNZ10k+LnDXqvAv0KUClNP/jgg11BgoJMuiFQbVnlS//5z39cM27VQNBFvpoQqsaYtsGnGwzVLFANMjUtVG0D5Q3+tuhzFJjSzYWaO6o5o2obqHaAmiwqvVeQTAUkCpJpG4O1z7QfqvWgGw8FuXSjovf6zUgAAKXpuvzss892ARulmyp41jW2amypwEIBHgWVogs2/DxC195+n1CiIJKWUeG10m61jtC1vFpyKCCm+xFRQboKrLV+NTHXe/yWG/qc6Ot5LaN8Q9ukIKAKJ5TPiN/KQ00i1f2IqABDBenKZ3QPo7wq2LVI9PqvvfZal4epMEX5j9YV7B8M9V9IPbTHeiOAZMlYVEqtG5JYUuamRN3vUBIAkJhUE0vBpmAfVwCAxKHasOqfVoXUajWhJnoKVKnAWAUZu+++e7h7DQWlVIPV75hegSkNvuT3f6XlVTih2mIaJEO1yVRorIJs1YhSsCjYmbwKU/xO5vU5fo0pvUfLBws/RDXaFAhTYbtqemm71CJDNF8F6aolrO3ROtUJvGh5NRVUk0wVgiswp6bl0bWpVMtKn+23ZKG2bmIhcAXUkenTp7vaTcE+P2IVQFOJuDqaBAAkJjXFUG0ljfIU3a8WkKzUbFXNh1SzXbUXy6LRO9XFgpq7BkdFBpKJavyqsP3ll1+O9aYADk0FgTqi6rCxDlr5bcDV5AMAkLh0860+XAhaAWbLli1zfXSqya06lFbT3LJoAAI1W9KIbKqpqO4PNDACkGzUjJDALeIJgSsgyagjdfV3AgBIXCqkUAfqAIoDueofR82T/GZS0dTHmkaE0yAzqiWvZdX3W3AwBCBZaIAQdS8CxAsCVwAAAAASlvrGUY0rDQJQnqefftr22GMP13m0PyCNBpnRoDVAMrYU6dKlS6w3AwgrHmMSda6oqMh1iKcMNNjJHQCgNHXSqb5J/OGO6xPSewCI//ReHUerQ+cgPVen0bpm1/ZEy8vLc5NP6f2qVavcYDxc3wNAzaX3BK5iRBlg9EgIAICKaahnDd1cn5DeA0D8p/dr1qxxg+gEKQAlGrGtrMDV6NGjbdSoUXW2jQCQrOk9gasY8asq6yRp2E8AQPmys7NdsL+iZh7xivQeAOI/vc/IyLDc3NyIeTk5OeHXyqI+sYYNGxZ+vnbtWjdiIdf3AFCz6T2Bqxjxqw8raEXgCgC2Lu2sT0jvAaDqaWdd0WiCCjgF/f7775aamlpuK4nMzEw3ReP6HgBqNr2vXx2FAAAAAEANO+yww2zixImuvxXf2LFj7YADDrCsrCyONwDEEDWuqmjjxo32yiuv2MyZM13VtkMPPdQGDBhQs2cHABBz6vfkpZdestmzZ7tRpo477jg3QhUAoH4oKCiwCRMmhJumzJ8/3959911XM6pfv35u/tChQ+3hhx+2I4880i688EKbPHmyffDBBzZp0qQYbz0AgBpXVaDRRTTKyCeffGLdunVz7d8PP/xwGzlyJN8oAEgg3377re27774uaNWzZ0/X0fruu+9uTzzxRKw3DQBQSRr5795773VT9+7dXV9Wevz888+Hl2nYsKF9/vnntv/++9vLL79s+fn5NmXKFJcHAABiixpXVdCgQQMXtFLJu0+94F977bV2yy231Luh2gEAZWvfvr3NmDHDGjVqFJ6n/k7uueceO+ecczhsAFAPKA1XDast0aiCupYHAMQXAldVzPyCNzGybNkyF8giaAUAiSNYQBFM79u1axeT7QEAAACSDYGranjkkUds+vTp9uuvv7o+r8aPH19hFWVNPrWvBwDUDzfddJNL67///ntr3bp1hU0FSe8BAACAmkPgqhrU34mGblTHjs8++6zr9LFv375lLjt69GgbNWqU1ZR7Pvi5Usvtu+CxMufv172V1aqDRtTu+gGgDqkzdgWs0tLS7LXXXrNp06ZZ586dY5Lel5eu14Spnc+PeH7VoO1r7bMAAACAyiBwVQ0DBw50k+y333526qmn2gknnGBdunQpteyIESNs2LBhETWuOnXqVJ2PBwDUkeOPPz78WINyaPSpY4891jIyMkotS3oPAAAA1BwCVzVEo0wVFRXZvHnzygxcZWZmugkAUP/TexU+qK8rDcwRjfQeAAAAqDkMf1cFX3zxhS1ZsiRinpoKarTBPn361NS5AQDE2KRJkyL6JFQBhYZPV43ZDh06xHTbAAAAgGRAjasqKCgosEMPPdTatm3rhkpXZ71Lly61Z555xg2jCwBIDGvWrLG9997bunfvbs2aNbMvv/zSBa9efPFFRpEFAAAA6gCBqypQf1YzZsywqVOn2u+//27nn3++u7FRjSsAQOI47rjj7JBDDrEpU6bYypUr7bLLLrN99tnHUlNTY71pAAAAQFIgcFVF6pB3//33r9mzAQCIO40bN7ZBgwbFejMAAACApEQfVwAAAAAAAIhLBK4AAAAAAAAQlwhcAQAAAAAAIC4RuAIAAAAAAEBcInAFAAAAAACAuETgCgAAAAAAAHGJwBUAAAAAAADiEoErAAAAAAAAxCUCVwAAAAAAAIhLBK4AAAAAAAAQlwhcAQAAAAAAIC4RuAIAAAAAAEBcInAFAAAAAACAuETgCgAAAAAAAHGJwBUAAAAAAADiEoErAAAAAAAAxCUCVwAAAACS3muvvWaHHXaY7bjjjtavXz+7+eabLTc3N+mPCwDEWlqsNwAAAAAAYunNN9+0IUOG2N13322HHnqozZs3zy644AKbP3++Pf7445wcAIghAlcAAAAAktqHH35ou+yyi11xxRXuuWpdnX322fbss8/GetMAIOnRVBAAAABAUjvooINs7ty59u2337rna9eutQkTJtigQYNivWkAkPQIXAEAAABIasccc4zdd999tvfee1v79u2tbdu21rVrV3vooYfKfU9eXp5lZ2dHTACAmkfgCgAAAEBSmzhxol1++eU2evRo12zw1Vdftc8//9yuu+66ct+jZZs1axaeOnXqVKfbDADJgj6uAAAAACS1f/7zn25EwSuvvNI97927t2sueOaZZ9o111zjAlPRRowYYcOGDQs/V40rglcAUPMIXAEAAABIahs3brTmzZtHzFOwqqioyPLz88t8T2ZmppsAALWLpoIAAAAAkpo6YR87dqzNnDnTPV+9erXdddddtuuuu1qbNm1ivXkAkNSocQUAAAAgqY0cOdJWrlxpAwYMsEaNGrlmf/3797dXXnkl1psGAEmPwBUAAACApJaRkWFjxoyx+++/35YtW2YtWrRw8wAAsUfgCgAAAADMLBQKWbt27TgWABBH6OMKAAAAAAAAcYnAFQAAAAAAAOISgSsAAAAAAADEJQJXAAAAAAAAiEsErgAAAAAAABCXCFwBAAAAAAAgLhG4AgAAAAAAQFwicAUAAAAAAIC4ROAKAAAAAAAAcYnAFQAAAAAAAOISgSsAAAAAAADEJQJXAAAAAAAAiEsErgAAAAAAABCXCFwBAAAAAAAgLhG4AgAAAAAAQFwicAUAAAAAAIC4ROAKAAAAAAAAcYnAFQAAAAAAAOISgasqmjRpkp199tnWv39/GzJkiL311ls1e2YAADHneZ6NGzfOTjnlFJfen3766TZlypRYbxYAAACQNAhcVcEzzzxjo0aNsgMPPND+9a9/uZuZwYMH20MPPVTzZwgAEDM33nijPffcc3bssce69L5Lly42YMAAe/fddzkrAAAAQB1Iq4sPSTSqYXXGGWeEnytwNX/+fBszZoxdfPHFMd02AEDNueaaa6xBgwYR6f0333xjDz74oB122GEcagAAAKCWUeOqCoI3Mb7MzEwrKCioiXMCAIgTpPcAAABAbFHjqgYsXrzYHn/8cRs6dGi5y+Tl5bnJl52dXRMfDQCoQ19//bW98cYbFTYNJ70HAAAAag41rqpp3bp1ru+T7t27u75QyjN69Ghr1qxZeOrUqVN1PxoAUId+//13l94fffTRdu6555a7HOk9AAAAUHMIXFXD+vXr7fDDD7fCwkJ77733LCsrq9xlR4wYYWvXrg1PCxcurM5HAwDquGbtwQcfbLvssou9+OKLFgqFyl2W9B4A6q81a9bYyy+/bI899pjNmTMn1psDACBwVb2g1RFHHGEbNmywCRMmWIsWLSpcXn1gNW3aNGICAMS/JUuW2EEHHWQ9evSwsWPHWkZGRoXLk94DQP2kgmi1olDQ6ttvv7WTTjrJjSwLAIgt+riqgpycHDvyyCNd8GrixInWsmXLmj8zAICY++OPP8JBq9dee80FpQAAiWfRokVu5PCrr77arr/+ejdPAy/NmjUr1psGAEmPwFUVPPzww/bJJ5+4Ehk1HYnuuBcAkBjUd+FPP/1kKSkpts8++4Tnd+7c2XXSDgBIDKpllZ6e7pp7+9LS0mz33XeP6XYBAKhxVSWnn366DRw4kO8PACS4kSNH2gUXXFBqPjWvACCxTJkyxfr37+9q2r711lvWsGFDGzBggHXr1q3c9zCKLADUDWpcVUHbtm3dBABIbBoBllFgASDxrVq1yoqKiuzAAw90LSpWrFhh559/vt1///123nnnlTuK7KhRo+p8WwEg2RC4AgAAAJDUVMNq2rRp9uOPP4ZrWd1111122WWX2SmnnGKNGzcu9R41Kxw2bFj4eXZ2NoUdAFALCFwBAAAASGq9evWypUuXRjQN1OAcag44d+5c69u3b5nNxmk6DgC1L6UOPgMAAAAA4tbgwYNt4cKFLnjlmz59uuugvaJ+rgAAtY8aVwAAAACS2mGHHWZDhgxxHbKfeuqpro+rp59+2u644w5r2rRprDcPAJIagSsAAAAASe+ZZ56xt99+240wuN1227n/ffr0SfrjAgCxRuAKAAAAAMzsiCOOcBMAIH7QxxUAAAAAAADiEoErAAAAAAAAxCUCVwAAAAAAAIhLBK4AAAAAAAAQlwhcAQAAAAAAIC4RuAIAAAAAAEBcInAFAAAAAACAuETgCgAAAAAAAHGJwBUAAAAAxNrM581+n2G2aWOstwQA4kparDcAAAAAAJLe+j/M1iww+/VDszY7mG3T16x556Q/LABA4AoAAAAA4kVhgdnS74qnhq2KA1jtdzHLaBjrLQOAmCBwBQAAAAAxNn9VjrXJ8qxhRuAWLWel2dwPzeZ9bNZ6++IgVouuZqFQLDcVAOoUgSsAAAAAiLHFa3JtcUGeNc1Ks7ZNsqxV4wxL8QNURYVmy34onho0L6mF1ccss3GsNxsAah2BKwAAAACIE9kbCyx743r7bWXIWjfJtHZNMiNrYeWuMfv1Y7N5n5q12s6sw25mLbtTCwtAwiJwBQAAAABxpqDIs6VrN7qpiauFlWmtGmdaql8LyysyWzGneMpqWlwDa5s+ZlnNYr3pAFCjCFwBAAAAQBxbt7HATfNX5ljrxpnWtmmmNQrWwtqYbfbbZ2bzPy+ufaWmhK16mqWkxHCrAaBmELgCAAAAgPpSCyt7o5uaZKa5AFZkLSzPbOXc4imjUfFohApiNWwZ600HgCojcAUAAAAA9cy6vAJbt7zAfluZY20aZ1jbplmRtbDyN5gtmGq2cJpZ885m2+xq1qaXWUpqDLcaALYegSsAAAAAqKcKXS2sPDc1zkyzdqqF1SjTUlMCtbBWzy+e0huYtd/ZbJvdzBq1ivWmA0ClELgCAAAAgASwPq/A1pfUwmrdKMPaqRZWZuCWb1Ou2cIviqdmHc06qBbWDmap6bHcbACoEIErAAAAAEiwWlh/rMtzU6PMVGvXJMtaNc6wtGBn7Wt/L57mfGDWTrWw+po1aRfLzQaAMhG4AgAAAIAEtSGv0H7N22DzV+VYq5JaWGpSGFaQZ7ZoRvHUdJviAFbbnczSMmK52QAQRuAKAAAAAJKgFtaydXluUi2stk2yrHV0LazsJcXTLxPN2vYubkrYtEMsNxsACFwBAAAAQLLVwpqXt8EWlNTCats005pkBvq5KtxktuSb4qlx2+IRCdvtZJaeFcvNBpCkqHEFAAAAAAE5OTnuf8OGDZOnFlZGqrVtWkYtrPXLzOa8b/brh8UduSuI1bxTLDcbQJIJpEgAAAAAkNwmTJhgTZo0sd69e1sy2ZBfaPNWbLCv5q+2X5avt3UbN0UuUFhgtvQ7s5nPmU3/t9nC6Wb5xQE+AKhN1LgCAAAAADNbtmyZnXvuuXbUUUfZN998k5THpNAzW74uz00NVQurSaa1aZIZWQtrw4rifrB+nWTWevviDt1bdDULhWK56QASFIErAAAAAEnP8zw744wz7NJLL7UNGzYkbeAqKCe/0H5bmWMLV+VYy0aZri+splmBvrCKCs2W/VA8NWhhtk0fs/Z9zDIbx3KzASQYmgoCAAAASHp33HGH5efn2/Dhw5P+WJRZC2t9nn2/ONu++X2NLVmbawVFRZEL5a42+/VjsykPmn031mzlXDPP41gCqDZqXAEAAABIatOnT7e77rrLZsyYYSnBJnEVyMvLc5MvOzvbkqkW1uYRCbMia2F5RWbLfy6espoW18BSTaysZrHcbAD1GDWuAAAAACSt3NxcO/nkk+22226z5s2b2/r1613NKzUd1OPCwsIy3zd69Ghr1qxZeOrUKblG2itytbDyXS2srxeuscVrc21TYVQtrI3ZZr99Zjb1YbNZrxQHs6JragHAFhC4AgAAAJC0Vq9e7Tplv+yyy6x9+/ZuuvPOO23hwoXu8Ztvvlnm+0aMGGFr164NT1o+WeVuKrT5K3PsqwWrbc6ydbY2N2pEQjUZVNNBNSGc+mBxp+45q2K1uQDqGZoKAgAAAEhaHTp0cDWrgm688UZ76qmn7Lfffiv3fZmZmW5CZC2sFevz3dQgPcXaNslyIxKmpwbqS+StN5s/pXhKTTPLbFbcjFBTg+abH2vKaMThBUDgCgAAAABQs3I3Fdn8VTm2cHWOtWiYYe3UF1aDNAtZaPNChQVmOSuLp7KkpgcCWVFBLRfYashpA5IANa4AAAAAICAjI8MaNaK2T03Vwlq5Id9NWSW1sNpG18IqT+Emsw0riqeypGWYZTY1a9CidFBLU3oDvtdAAiBwBQAAAAABI0eOdBNq1sZNRW40wt9X51jzhhnWID3V0lNDlpGW4gJZGakplp6WYqmhQK2sihTkmxVUFNjKLB7Z0NXWiqqxpWaJeh1A3CNwBQAAAACo01pYqzbkl/t6akqoOIgVDGoFg1sl89NStlBrqyDPbP3y4qksClxF9KsV9Vg1ugDEHIErAAAAAEDcKCzyLLeo0KIHJ4yWErJwLa3igJYf4ApFzE9LVc9aobIDW+v+KJ7KoqaGEc0PA4EtBbzUBxeAWkfgCgAAAABQL2tubSwoclNFFLLya2xFB7U2B72K54eCzRQ35RZP65aWvWJ1Dl+qb61As0SNmgig2vglVVNRUZF5nmepqanVPxsAgLhO7yVlS80SAABAXPHMLK+gyE0VUchKtbPKa5pYqh+u/JziKXtJGSsLmaVHBbbUkbyaH6aWTGqqmJpZMq/kP4BSCFxV0ZdffmkPP/ywvfjii9ahQwf75ZdfqroqAECcUsHEhx9+6NL78ePH28CBA+3dd9+N9WYBAIBaCnBtKvRsU2Gh5eQXVrhsWkowwBVVi8ufX7jO0vI3mGUvrtwGhFKKmx+6gFY5gS33P/h6WctlFgfOgARB4KqKrrrqKjvzzDOtZcuWNm7cuJo9KwCAuLBkyRL75z//aRdeeKGrWbt27dpYbxIAAIgDBUWeFbh+uCoOcKWq4lVJICstVTW11DdXyFJSQq7Wlv6rry51SF88f6Olhta7eaWWCYUimzJW+MHp5QS+MiofDEvLMkuhZRFij8BVFX366afu/4033liT5wMAEEdUo3bixInusWpcAQAAbI1Cz6ywEv1wVZYLaIVCgUCXBYJbCnQVB7wilokIjPnBsJL1RM0r1Ym9AlcV1u7aQi0wvT8lLfA/jdpg2GoErgAAAAAAqCcd0hd5qu2lho01LyLIFQ5+BWp/uXlbqDUWfJ9qiJX8V0jMPU1JtVBKmqWon2gXyAoGt6LnpQQCXlHzKnxfybzw87Lm+e+hWWW8I3BVR/Ly8tzky87OrquPBgDUIdJ7AMBW+/hf1i57lm1IbW456a2sSDfTQKwCY6om5nr8ql3hQFZJUCsl8Nj9d8/NUlQPzH+tOA5WHAhzjzcvp9c1hE6ZywUDZyW10MLvLQlopWgUyJQ0C6WmWkpI/4uDWylpaZaSku7m+wG3FDXFLC9wFg6ElWyY+29lzAvVwDyr4fUFHldmOfXLlt7AahspYh0ZPXq0jRo1yuLFlF9XVvm9+3VvteWFPhpd45+7xc8+aITVuXL2s1ZtxX7e88HP1fqoqwZtX633I87F+fe3voq39H5r7LvgsYjnU/5Tc+ue2vl8q6vtrtE8Jgm+s0mlNtO9OP2uVPdaoKq4htgKhZvMPrnTuhcWF3J7FrLctOa2IaOVrc9obRvSW1tORisrTGHEOSQWFx4L/wnOjX8VBd0sEBTbvGzxEz+gVvw4uHzkvM3vLX6xJGxUMj+wbv+zyllP+L3+50etO3I9xQ/8z/L3I/h6cD/c/4xG1vCgYVbbCFzVkREjRtiwYcMialx16tSprj4eAFBHSO8BAFulIM+s/xW2+ouXrVHeMssoyrWGBavd1CZn88jluWlNbUNGG9uQXhzQUs2sgtQsDjYQA/U56FaTQhmbbF+rfQSu6khmZqabAACJjfQeALB1GUdjs4OvtR8X5rggVnphjjXKX+Gmxpv0f6VlFq63BgXZbmptc8Nv3Zja2DaoVlZJzSwFtApSa7/ZDgDUJQJXVVRYWGie51lRUfHoEAUFBcUHNI1DCgCJmN77k9J7VZNOVYeiAADUsE2pDW1Ng85u8qUV5lqjTSsDAa2VllWQbVmF6y0rd721yv0tvGxeaiNXK2tzQKuV5ac2ogNqAPUWUZYqGjhwoH322Wfh51lZxdV058+fb9tuu23NnB0AQMx16dLFli5dGpHea1q/fn1MtwsAkDxUi2ptakdbm9UxPC+1KM/VxmrkamUV18xqULDGMgs3uKnlxgXhZTelZLkg1vr0kmBWRivLS21CMAtAvUDgqoomTZpUs2cCABCXfv/991hvAgAApRSmZFp2Vgc3+VKKNgVqZhUHtRpuWm3pRRut+cbf3eQrCGWEa2WtL6mhtTGtGcEsAHGHwBUAAAAAJICilHRbl9neTb6UogJruGlVSc2s4qCWnqd5+dYsb7GbfIWhdFcbq7i/rOL/uenNi4e8B4AYIXAFAAAAAAmqKCXN1me2dZMv5BVag01rAh3AK5i10lK9TdY0b6mbwu8PpW7uM6tkRMPc9BbmhejrEUDdIHAFAAAAADH0r3d/tOXLO1qzlBxrnppvzdPy3f9mafmWFvJq/PMUdMrJaOWm5darZGaR6yPLr5WlgFbD/JWW5m2yJvnL3OQrshTLSW9ZXDurZERDPVeQDABqGikLAAAAAMSIRqz996e/2qbCzaMIBjVOiQxkBQNb+t8sNc/9b5yiUW+rsSGhFMtNb+mmFY16+htnWQVrS41omFaU5wJbmmzDT8WLWshy0luUGtFQzRcBoDoIXAEAAABAjGwq9OyiA7az7776zNZsSrM1BRm2pjDD1hZkWKGl2PqiDFufn2FbGiok1YpcYKtFVIDLD2wFA14ZKUWV27hQyDamN3fTyobbFc/zPMssXB8OZKnvrMb5K1wH8I1cX1qrzHLmFC9q5jp8X19SK8sf0VAdywNAZRG4AgAAAIAYyUhLsWGH9rIpS54xK8gLzy/yzDYU+YGsTPd/bWFGOLC1piAzHOBaX5TuglyrCrLcZJtXU6YGKQXhGlwtUvOiAl1+gCvPmqZuspToWlyhkOWlNXHTqobdiud5nmUU5pR0AO8HtFZaZuEGa1Cw1k1tbG54FRtTm7ggVn5qAysMZVhhiqZ097hA//U8FJyXQQfxQBIjcAUAAAAAcUYBoyapBW7qZDkVLrupKGTZCmYVZtjqcIBrc2CrONBV/H+Tl2q5RWluWrKpYYXrDZnnAlnhwJYf1ErLCwS4ioNdXmojy09rZKsbdAm/P13BLPWZFRjRMKtwXfGUu26rjkdhKHVzkCuU7oJZ/uPiwFc58yOCYekEwIB6iMAVAAAAANRj6SmetUrJs1bpFVe18jyz3KLUiBpb0TW5FOhaXZhp6wrTXb9VrrZXYabN38I2ZIYKAwGuyFpcLrjVuPh/q5Rsa6pA1qZVrq+s1KL84snb5P6nBR6nepoK3fr1P9XLNSvKrdaxKgylhWtx+TW6Imt8BYNh6WUv6wJg1elQDMDWIHAFAAAAAElAsZaGqYXWMDXXOmRUHAAq9FSLKz0qsFXcZDFYk0uvqfZWnpdqyzY1cNOW+B3OZ6UUulETM0JFlh4KPE4psvRUzSuyzNAmaxzKtSaWa41Kpoa20RrZRsuyjdbA22gNbKNlenmWaXnuf4aXZ+levqUX5blREV0QzPwAWIGbMooqrsW2JQXhGl1lBLkqqAXmhVLMsxQrCqWWPE61Iv0Plfy3VIJiQBQCVwAAAACACKkhz1qoD6y0/C0emY1Fqba2ID2yLy4/2BUIcEV3OF+XGobyrHlog5tahDZYs1CuNQ3lWLNQjjVxU641thxr7IJimwNkmhQYy/IUKMuztJIAmAJiaYWbamVbVdPNBbaCAS4Ftiwl6vHmYJcf/NLr/mvB95QZKLPS79m8HME1xA8CVwAAAACS3tSpU+2tt96yFStWWO/eve2ss86yJk2aJP1xqQzVnMrKKLR2trHC5dThvDqS94NbeUUptslLsQIvxfK9qMclr5U7lfl6KPA4NeKzc7xMNy22ltU6p5mWb40tt6QWmB/wKn7cuORxUz8IVlJTLFhjTDXL0q3AMqzA0m2TqVt9zYvuW0y1wsJDM8ahIgtZoQuCpYaDYUWlgmH6ryaVKSX/tWchV6PM/+/mhVLcf/Nfc4Gz4LIpEe/zX/ffW9aywc8te9nNy+k9VubjzdtW9rKlP4MmpLWDwBUAAACApHbFFVfYF198YYcffrj16dPHnn/+ebvjjjvcvHbt2sV68xKqw3mNVKjJbEOtfpb68yooCWTllwTESj0uI3C25SCZHxxTR/eZttxrZYujg2iB58UBjYqFrMgFsDJcIEsBrULLCBUEnhcHujTPfx6ep8ehqOeBeZmBdaaXrDO8TMk6I56XvLf0vMjgWnGdrAKzOA+wxSKgV9Y5Dx4evbqlZSpaLlpllim9nLfV6498d4lQyDbe9qJlXTPHahOBKwAAAABJ7corr7Ru3bqFn5999tm23Xbb2YMPPmg33XRTTLcNVaMKN+khzwVsGpY076trCp4VWsgFyPxgmQIbRSXz1Y9Y8XPVXir+72oyeWW/VvxfjRXTS5Yt7ous+D0ppl7L1ntlr6+s/265kmX9bS2M2kZ/HUWea8BoKV6RpVmB+68O81Os0NK8AjUsdM0oU63APU8L+fNdo0PVybLUUFHJckWb57nJ1d0Kz0srWc6fV7ze6PcE16ftcPW7ylyflvPfE7l85JQSXq74/SX1xyKW17ZVRMsnVRTPM9uQW/v7S+AKAAAAQFILBq0kKyvLOnTo4JoNAtUJnqUp8JGqwFlsgmfxQEGx4nBOcW0kBd/85wqQFc8vqa1U8lzhIa8kOOde9/zaTJvfV1DyPNfbPL/UOgOvlfdZpZYr+Wx/uYj3ubiV/0wvRD32vJKwVfF6ig/A5lCWV1JzyX/Nf3dx7afNnxsxz4ppG/Wqv53BdQfX794Zccw3v+KvX8/9dXjhP5s/OxyKKtn34LrdFpQs4KWkWsv2Xex2q10ErgAAAAAgYNq0aTZjxgwbOXJkucclLy/PTb7s7GyOIVBOAC8Y+rBQEtVISnChjIa27+lX1vrnqGcxAAAAAICZLVq0yIYMGWInnHCCHX/88eUek9GjR1uzZs3CU6dOnTh+AFALCFwBAAAAgJktXbrUBg4caDvttJM9++yzFR6TESNG2Nq1a8PTwoULOYYAUAtoKggAAAAg6SloddBBB1mXLl1s3LhxlpmZWeEx0etbWgYAUH3UuAIAAACQ1JYtW2YHH3ywC1qNHz/edc4OAIgP1LgCAAAAkNTOOecc+/HHH6137942dOjQ8PzddtvNhg8fHtNtA4BkR+AKAAAAQFK7/PLL7eSTTy41v2PHjjHZHgDAZgSuAAAAACS1Qw89NNabAAAoB31cAQAAAAAAIC4RuAIAAAAAAEBcInAFAAAAAACAuETgCgAAAAAAAHGJwBUAAAAAAADiEoErAAAAAAAAxCUCVwAAAAAAAIhLBK4AAAAAAAAQl9JivQEAAAAAACAoZF74oR6HAvND+hf5vGRG8DV/fvi97l/UukLhFUWsp6LXiucHts99ZvQ2Bl4Lvydy/4Lr1svFm1c8P/qx/37/byiwvvIeWygleJgCjyPf754Htiv8zJ9f8sd/7LY34rNKtt+9VrJkyfEoXiSwr/5+hIrrEBWvK3h+Nu93cT0jf3n/OIa3JLBTJR8eOO5u+cD2bV4+at+s9HaGUjafy+Cx2Lzvm+elpdVNSInAFQAAAAAgih8ICc4KBEdKLRd1813Wa9Hz3I1wiruZ138/WFI8L8Uto//+zXX584rXUdY8t96SIMLm5fzXNi9rEesPvq+ceW7Z4u1XgCRi+9y+pVhKSoqlpqZZelqKpaakWEpamrvpT3GBk+LggptSFGAJWUpKcVBAgQN/Gf1PKQkq6H9wvr8OzS9er7/Oze/bvExxuGHz+2yrP8NfR6nPcNtsZX6Gey0QNHLvDXydIgJIQDkIXAEAAABAjH237YmWv6kwEACKru3iZgbm+bMqCCJF1PSIXKbM5ZIgiJCaErK01JClp6S4/2nueYr7n54amFfyuubpPempZczz11GyvtSo9RKUAWoGgSsAAAAAiLFNaY0s3yuyZKQaOsUBoc3Boc1BopLHfoDJDxL5waRA0Ck4Lz0lVBKkSgmvQ/8JJgH1D4ErAAAAAECtykhLsXZNs6xd00xr3zTL2jbJsqwMBZjUpC7xa3oBqDoCVwAAAACAGqOaTm2aZLoglYJVClS1bJRBbScAVULgCgAAAABQJeoWS0Gp4tpUxUEqBa0UvAKAmkDgCgAAAABQKU2y0qx9s81BqrZNMy0zLZWjB6DWELgCAAAAAJSSlZ5q7ZtlWrsmWdauWXGgqlEmt5AA6hapDgAAAAAkOY2417YkQOV3oN68YUasNwsACFwBAAAAQDJJCYWsVeMMF5xyfVM1y7TWjTIZ3Q9AXKLGFQAAAAAksOYN00v6o8py/VO1bZJp6akpsd4sAKgUAlcAAAAAkCAaZaaGO053/5tlub6qAKC+InAFAAAAAPVQRlpKIEiV6fqnapqVHuvNAoAaReAKAAAAAOJcakrI2jQp7jS9bUnn6S0bZVgoFIr1pgFArSJwBQAAAABxRLEoBaWCTf4UtFLwCgCSDYGraigoKLDvv//e0tLSrHfv3pR2AECC2rhxo82ePduaNGliPXv2jPXmAABqydq1a23OnDnWrl0769SpU50e5+3aNLZWJcEq1ajKTKNfKgAQhpKoounTp1u3bt3s6KOPtoEDB9oOO+xgP/74I98qAEgwb7zxhnXo0MFOOukk23vvvW2//fazZcuWxXqzAAA1bMyYMbbNNtvYGWecYb169bLBgwdbXl5enR3nP+/U3vbs2tI6tWxI0AoAAghcVYEyMGVkRxxxhC1YsMAWL17sAle6qQEAJI4lS5bYKaecYiNGjHAl8IsWLbL8/Hy78MILY71pAIAaNG3aNLviiivs5ZdfdjVsf/nlF5s6daqNGjWK4wwAMUbgqgref/99+/333+26664rPogpKTZy5EibNWuWffnllzV9jgAAMfLSSy+55uC6mZGGDRvasGHDXC2slStXcl4AIEE88cQT1rdvX9eaQlTT9pxzznHzAQCxRR9XVTBz5kzX7r1jx47heXvuuafr40qv6XFZtbSCVY3Vfl6ys7OrdOI2blhfqeU25NZ89ebsDRur/N7qbk+Fn13FY1kt1TgWVbYV+1nZ70n5HxWDY4q6E+ff38i3Fb/P8zyrS0rTd9llF8vIyAjPU3PBwsJCV1hx0EEH1Xl6Xxvpel2obnpUkZo6JmXmMaSDiaU20704/a7U5m+vItn1ML3fY489IuYpvb/llltc7Vs1Iazt9B4Akkn2VqT3BK6qYNWqVdaqVauIeampqda8eXP3WllGjx5dZlXjuu70MbHdZMmh7vZzZJ19EpJH9b6/69ats2bNmlks03v/Oen91nrA6qdkyVtQfXxXavIaIt7S+7ICV1zfA0D1VSa9J3BVBenp6W6EqWiaFyyVD1L/KGpe4isqKgpnkKqpFQ/RTgXRFi5caE2bNrVkwD5znhNVIn63VRKjTE1NN+o6vc/JyYmYl5ub6/7HIr1PxHOb6PvGftU/nLPkTe+jr+/rMr1P1O9dRZJtn5Ntf5Nxn5Ntf6u7z1uT3hO4qoIuXbrYH3/84ZqKqKaVKJNS5ta5c+cy35OZmemmINXQijf6siXLj8zHPicHznP9V5cl78H0fsKECRHz1EG7xDK9T+Tvc6LuG/tV/3DOki+999N3n56rL9tg9yC1nd4n6veuIsm2z8m2v8m4z8m2v9XZ58qm93TOXgWHHHKIbdiwwSZOnBieN378eFdSc8ABB1RllQCAODRo0CD7/vvvbe7cuRHpffv27V3fVwCAxEnvVVARrGWr9L5///7WoEGDmG4bACQ7alxVwQ477GBnn322nXvuuXbbbbe5asVXX321/d///Z+1bt265s8SACAmjjjiCFcgMXjwYDeS7Pz58+2OO+6wRx55xJXCAwASw/nnn28PPfSQHX/88XbJJZfY5MmT3QiywYJqAEBsELiqoscee8weeOABe/bZZ91Q6bqRUSCrvlI15xtuuKFUdedExj4nB84zqkN9lLz11lvhYFWTJk3slVdeseOOOy4mBzaRv8+Jum/sV/3DOUtOSt8///xzVyh93333uRHEJ02a5Gpc1YVE/d5VJNn2Odn2Nxn3Odn2ty73OeTV9VizAAAAAAAAQCXQzgEAAAAAAABxicAVAAAAAAAA4hKBKwAAAAAAAMQlOmdPIsuXL7fff//dunXrZs2bN6+198STBQsW2Nq1a2277bazhg0bVvp9RUVFNmXKFGvcuLH17dvX6ovCwkKbM2eOG+2se/fubuCAyr7vhx9+cMM961jVJ3l5efbTTz+572enTp1cZ9pbsmnTJps7d64bEVTf7WbNmll9ou3WPqsj2a5du1ZqdLuCggL7/vvv3Xeid+/elTpOqBtKY3/77TfbddddXZpTGVp+xYoVbpTb8t5TmWVq0/r16+2bb76xzp07u99mddNs5Uf63kfbb7/9LDU11eqKugb96quvLD093fr06bPFtFV5SbRevXpZmzZtIubl5+e736jSYZ2zWFC6uGTJEtt3330rzD+U7n7xxRdlvqa8p0OHDu7xt99+685nkPZb+1+X50v7pXRf21bZzmOXLl1qCxcudO9p1apVlZepTcuWLbPFixdvVT5W0Xs2bNhgM2fOLPUefc+bNm1aY9uNsq879fvX93WnnXaq0zQtVvR9+/rrr13+oHwi0VXlerW+U/qv9Ld9+/bhfCEZrFq1ymbPnu2+14n63S4oKLCpU6eWmq/rl9atW9fOh6pzdiS2qVOnevvvv7/Xpk0bb9ddd/UaNGjgnXPOOV5+fn6Nviee/Pe///V22GEHr3Pnzt7OO+/sNW7c2Lvtttsq/f5bb73VS0lJ8fbYYw+vvtA2t2/f3u13t27dvA4dOnivv/76Ft+nZbbZZhv3nl122cU7+OCDvWXLlnnxbu3atd6ll17qNW/e3OvTp4/Xtm1b9//rr7+u8H3jx493x0n727dvX/fdvvrqq736IDc31xs2bJjXqlUrb7fddvPatWvn9ezZ0/v8888rfN+0adO8jh07ep06dXLv2X777b0ffvihzrYbZZs8ebJ3zDHHeK1bt9YgKd4XX3yxxUO1fv167/DDD/caNWrk9erVy2vYsKH3+OOPb/UytWnRokXeJZdc4tKVjIwM7+abb66RNPvZZ5/10tPTvf79+0dM69at8+pCYWGhd8cdd3g9evRw6c4+++yzxfesXr3anVulNcFtfu+99yKWmzBhgstvlS7p963lFyxY4NWVt956yzvooIO8li1buu1dvnx5hcsvWbKk1HnYaaed3Huff/758HKar3QnuNwNN9zg1ZWHHnrIfae22247l+5p/5566qktnufzzz/fy8zM9Hr37u3+jxw5cquXqU2fffaZ169fP5fv+ddoF1xwgVdQUFCt98ycOdOdQ323g+ds1qxZdbRnyUnHV99RpZnbbrut16VLF++rr77yEtXixYu9yy67zO2vfjt1mSbUp+vV+mzhwoXeiSee6K5vdt99d69Jkyben/70J3d9kOiUPxx44IHuPvLaa6/1EtXy5ctdfqH8JJhf6HqmthC4SgK62P/kk0/Cz+fMmeMujEeNGlWj74knd955p/fTTz+Fn7/77rsuAdHFeWVuJrt27eqdeuqp9SpwpYvm4M2GbhazsrK833//vdz3KOCRmprqPfroo+F5Ou/14SL1559/9saMGeOCOZKXl+cNGTLE3fiVRxfoTZs29YYPHx6eN2nSJJfwfvDBB168W7p0qffII4+4ffX35/TTT3c3ZuXZuHGjC1rpJsvPUBUs0UUTYku/u3HjxnnfffddpQNXuvjt3r17+LeutFpp27fffrtVy9QmpSH333+/t2bNGncDVpnAVWXSbO2HAq+xkpOT49IO5YcKzG1N4Kqic6tlWrRoEQ586PetC3wFkurK7bff7i4233777UoFrsqi7W/WrJm3YcOG8Ly6DlRF0zVLMA/897//7fK8ivK4Bx54wO2HH9zXNYECpmPHjt2qZWrTk08+6T7TN3v2bHdTrPNYnff4gauqnH9UjfJkBe1POukkr6ioyM077bTTXBq+adOmhDysuva87777XNqngF2iB66qcr2aCOc4mH9nZ2e7Ahl9zxOd8p3Bgwe773YyBK5mzpxZZ59J4CpJnXzyyd6gQYNq/T3xRKXkI0aMqHAZZaLKSD788EN3Y1KfAlfRVqxY4RIU1TAqj86nalglCt3sap/LK9FRzYxQKOS9+uqrEYEd3SC/8MILXn302GOPuRJLXfyW5Y033nDHRKVfwRqVlQ2UoPbp5rcy50M3MQq8KsgTpDTLD8ZWZpm6VNnAVWXSbAWuVFKtQJ8m/XZjZWsDV6+99pr35ZdfuufRnnjiCVczTaXyvv/973/uffPmzfPq0jvvvFOlwIWC6KopcvHFF0fMV+Dqqquu8qZPnx6RBsWKAgMKMAULa6KpdsDQoUMj5h122GHekUceuVXL1LXjjjvOO/roo6v1Hj9wpTxCj+uqNmMyU6Bfx1xpmk9B/PpSoFZdyRC4qsr1aiJSy50BAwZ4if57VmHyypUrkyZw9cYbb3gzZsxwhZW1jc7Zk5D63FAfBj169KjV98STP/74w/VDsaXtHzp0qJ1wwgl20EEHWX3n9z9SXp9Vapv8ySef2NFHH+36opkxY4br96K+77P68mnXrl2Zr+u1f/zjH3b99dfbf//7X3vvvffs9NNPd33kHHfccVZf/Pjjj+7cPfXUU/bPf/7TRo0aVW4/V/rd6nh07NgxPG/PPfd0fSuU1ZcJ4tevv/5q2dnZtscee0TM32uvvcLnsjLL1Oc0W/3zHH/88S7datmypd15551WH1xwwQV21llnWdu2be3UU0+N6PdJ56Vnz54RfQjtvffe4dfqg3fffdcWLVpk5513XqnXHnnkETdf/faoz0j1aRMr6nNNfV2Vdy2gax31yxX9+9H58M9FZZapa9on7dvWXKNV9B5dB51yyinuN3bZZZe5ZVE79J1Rv2v6ffi23357lx7Ul98/av56NZH286OPPrK7777b3njjDbv22mstkfu1Ou200+w///mPSzuTxdChQ+3MM890/Vdq/3UNWlvonD0J3XDDDa4z4KuuuqpW3xNPHV6ec845rnO8k08+udzlHn74YXfT98ILL1h9t3LlSrvkkkvsL3/5S8TFUPQy6ihSnYHqIkkdJ/7yyy/u4vvFF18s1XFwvNMF+OjRo11gqqJOTU888UR7//337eqrr3Yd0+oG+f7773cdItcXzz//vE2YMMF1eKlzd+yxx1aYkUZ3Gqzjo85B9RrqD/98RZ9PPf/5558rvUx9TbMVhJ81a5btsssu7vnYsWNtyJAh1qVLF/c/HqkDd/1eFawSpbEDBw60yy+/3J5++ulyf6P+RW99+Y3qQl0BcQ0wEHThhRe6fEgd7asjZhUUqJDgu+++q/MBA3Jyctz3asCAAeUWTq1bt84Facr6/fjnojLL1LURI0a4PF3fq+q8R3miCnQOPfRQ91wFWgcffLD7PqqABDWvrN9/rL9PiI/r1USg/dSgK+qUXteq++yzjyWqc889112LHHLIIZYMMjIy3P2if52ma0xd3yhWoGuC2kCNqyTzwAMP2B133GEvv/yyK+GtrffECzWHVUmvLr4U6S9vZEGVFA8fPtwuuugimz59un322WduZCXVRNLj6FGR4pki3UcccYS76HnyyScrvKESBXFUqqdRsjQKmY7FsGHDrD7RSIqHH364DR482K655ppyl1u9erUdcMABLlOZP3++uwkeN26cu5l68803rb64+eab3UhlOle6iddNmG4KyzvPGoUwmuYp00H94f9mo89nbm5u+FxWZpn6mmarZqQftBL93nWD/dJLL1m8atSoUThoJard8n//93+uxqcCdOX9Rv3n9eGcqRbc//73vzJrW6n01T+HOhYqdVfaW9ZIi7VJhTQKoCmdfPXVV8sdzas+/sbuuusue/DBB91+aZTZ6rxHIw36QStRrTKd13j+jdV35eXR9SXNRu1cryaK1157zb788ktXg1r3GCo8TkSq9PD555+7c6v7Rk36XWu/J0+ebImoadOmEYWLKkjXvbTiBbqWqw0ErpKIahTpC6UL5iOPPLLW3hMv9KNR8wxdUH/44YcVDi+uC4Tdd9/dlYArI9HkBwb0WDWx6gOVBB922GGuKYMCUhUNX92iRQv3ukq//arKKlVVpvLpp59afaEaDArcaFKgrqLhhZV5qARTtdF8/fr1s912261eBa6CF7xXXnmlG5K9vCYFqo2iWmX6Tvh0DPSdT9QhehOVzqUoXQrSc/9cVmaZREizfUq7ovc13mmb9fvza1PonJV1viTez5k888wz7gZbTcu2xM9r6vKc5efnu6CV8nE1WamoaY6Cayr0qej3U5ll6sq9997ram2oAGbQoEG18p76+BurT/T7V6GaagQGA62qDVcffv+onevVRKNa/gqCT5w40aXJiUbXLwrcqIWSfx+p37DynOuuu86SRbt27VwBUW1V+CBwlSQeffRRd4P7yiuv2DHHHFPqdWWY0TWLtvSeeE9A1ERh/Pjx7gaod+/eZZYSa591Q69ScD9C7k+60O3Vq5d7rMBGfQlaKUP44IMPXCYRTU3LVLNKlGGqZDX6glRNQutLM0HdiOgCYP/993c3T2VVuVaVbL+JlL9f2kefzr9q19WHfS6rVpUuhCTY1EDfWb+/MtUu0/t0seDT70JBL9U+Q3xT9XrVDJTWrVu7pliqieTTDY/6O/NvQCuzTDwIpr+VTbOjv/8qzVSQfeedd7Z4ob4DtV/Lly8v9zerQgU1zfZ/szovSof9tFl0HFSwEE/NKvQ91PcxmpoEqNS1SZMmEfMVnPNrlQX3XerqnPlBK9Vy0A1Ehw4dSi2jZixTp04NP9f5CBZk6Dv61ltvRfx+KrNMbVMTdzX3U40G5f3R/Brjwf5GtvSesr6vup6Ip4sv73AAAApMSURBVN9YolFTTPVRqYC97+2333ZpiZrdIDFU5no1kZR3varmyH6t1UTy17/+tdR95LbbbmtnnHFGxPV3ItlQzvWN+tQt6x60JtDHVRJ47rnnXBM49emjC2X9mPxSQz8gowT1T3/6k7tA0Y1uZd4Tz1RL7IknnnDNHHXT5m+/IsF+c0ddGJx99tnu9dr6gdUVXeCoRpwCNCrFUb9VPgXldJMkavI5adIk17m3qM8KNb9RaYDOvzpRVIaqNsvxTsEmXQTo+6laGsGmJ7px9/tPUZtz1dzQd1rNHlTDSk0DVSqi867vib4D+i7EO1W/1c2RasnpnOo833bbbXbSSSfZjjvuGF5O5/Kee+5xgWftu/ZNx0HL6mZfv2s1V1KQA7H9DiuYrBtnP8iq86PmOrrgEX1PVb3ev7FWZ/zqmFwl8UqL1eRHfT/p4shXmWVqk/ZBTQP8mgPaP6XB+r35N8DR6W9l0mzV6NH7lWbpM8aMGeNuznUjXlcUXFJBj86dCgv87ezfv78rDFizZo37/T377LOumZwKgJSu6nxoP3VzqkEVtK9+abveq9e1f2oGvGLFCnfeb731VsvKyqqT/dJ3TAF9P++YNm2au8FQuuIH2M4//3zXrCzYbExNI5SfaJ+izZs3z3VIr7RH32l1aK590n6qP6y6oIDaxx9/7IJr2h5Not+GX5tF50K1kHTuRPmh+npUvnLUUUe5c6lzre+orzLL1CbtzxVXXOE6OlbA0P8e6rE6wBedF30XFdxVv16VeY9qYingqOtA1aJT8xcFvfV7Re1QMFX9jKkmuNIWBTSUP+savLJNP+sb5Qv+AEJKy/08QmlOsDl4oqjs9Woi+dvf/uYCsgceeKBrLq7zq8FUbr/99qSqaZbIHnzwQVegpftPFbSpMEf3WrqPrC0hDS1Ya2tHXNCFsDrbjNa9e/fwl0sXc7qZ18WbLigr8554j3yrH41o6vtp5MiR7vE777zjLqI1GlJZmYZu/HUR//jjj1u8081bWaWnogsgv/NuZRpqUqbOgn2zZ892/Y7oxqVTp07uJkMXufFON8YKzJRFF+iqLeePdqGq+H5VXZUQKLFVIEAX6FpOoyaVN/pivFFwWYFF3WQquKEbXo2yFrwQ0PnTDYrfYbUCmwoI6LuelpbmAl86z1w8xJZqPei3F+3SSy8N9xtw4403uoteBUB8qjmikdpUDV2Bqb///e+lgpCVWaa2qPaQgqnRNLKh0tWy0t/KpNn6vWqfFIjQd1c327rhq8vRe8rbTtUS042+ai3rIk4jl/p9Ban2lPoSUkBK6YwCQH369Il4v27edGx03jRQhM5/ZZre1RSliWUVWNxyyy3uxkN0w7XNNtu476RP1wxqgq2a2WVR/qIuB1SoovcqyKMR6+qKaqzoJjmaOmnX5Aeu1B2CvpM+Bdn029QNtQKnugnT9U9QZZapLcrP9F2JpoIK/5pFteOUzuv4KxhQmfeohpxuPFRAorxSryk9StQASrzQcX/sscdcTVndlikNUeAqUWvlqHuDstIB5VUqkEg0lb1eTSSqhaqAvtJV1fpU4YVGnounWsS1Tfm48qCy+n9MFOPGjXPXsrq+UUUJXSfUZg1dAlcAAAAAAACIS/RxBQAAAAAAgLhE4AoAAAAAAABxicAVAAAAAAAA4hKBKwAAAAAAAMQlAlcAAAAAAACISwSuAAAAAAAAEJcIXAEAAAAAACAuEbgCAAAAACCJrV692l566SXbtGlTrDcFKIXAFQAAAAAAdWD9+vUuQLRixQr3fOXKle55QUFBnR3/sj5z7ty5dsopp9iGDRvqbDuAyiJwBQAAAABAHVi6dKkLEP3444/u+Zw5c9zzjRs31tnxL+szW7ZsaSeddJJlZGTU2XYAlZVW6SUBAAAAAECN1b6aMGGCezx27FjLzMy0rl272r777uvmqVbWtGnTLCsry3bffXdr0aJF+L3Lli2zDz/80E488USbMWOGzZ8/3w488EBr1KiRjR8/3i2Tnp5u3bt3t1133dVCoVCFn9mrVy877rjj3HuC5s2bZ9988401a9bM+vXr55aP3gYFvH744Qf79ddfbfvtt3cTUJMIXAEAAAAAUMfULO/jjz92j998801LS0uzP/3pTy5w9cADD9g//vEP22uvvayoqMhmzpxp//73v23w4MFu+dmzZ7taU88995wtWrTIBYt22WUXS0lJsddff90tk5eXZ19++aV17tzZ3n33XWvSpEm5n6n/Wp/6umrevLl7/ZprrrExY8ZY//79bcGCBZaTk2PvvPOO7bTTThHb8MILL9jixYutTZs29tFHH9mtt95qw4cP5/uEGhPyPM+rudUBAAAAAICy/PLLL9azZ0/79NNPbcCAATZ16lTbb7/9bN26dda4cWO3zOTJk+3www93r+24445unmpRnXHGGa4GlJr1TZo0yQ466CAXILrzzjvLPdj5+fm2//77u/XdcMMNbl5Zn6kAl4JkfuBKwa2DDz7YPvvsM7dsYWGhnXDCCa6W1eeff+7e42/DjTfeGF73008/bRdddJGtWbOGZoeoMdS4AgAAAAAgTjz11FOuBtX3339v3333namuiSb1SaVmgYMGDQove/nll5e5DtXQUi2p3Nxc69ixo02fPn2rtkGdt6vpoYJWkpqa6mpgqTaY1qtaXD4Fqnx6jz5Ty/To0aMKew+URuAKAAAAAIA48dtvv7maT6+++mrE/OOPP94aNGgQMW+bbbaJeL58+XIX2NL/vn37WtOmTV1n7Fvb6br6zFL/WEHbbbdd+LVg4Eo1wHx+H1h12dk8Eh+BKwAAAAAA4oSCTapxpVpPW+J3uu675557XPBIwSX1WyVXX321a9a3NVq3bm2rVq2KmOc/12tAXUqp008DAAAAAACO38dUsIbSYYcdZhMnTnQ1pYLUv9SmTZsqPHJLly51NaP8oJWWf+ONN7b4mdHU/5a2Ye3ateF5//3vf619+/bhmldAXaHGFQAAAAAAMaDmeC1atHAjCB5wwAHWrVs3O+uss2zcuHFuNL/LLrvMNQecNWuWG9Hvm2++sfT09HLXd+yxx9qQIUNcB/B63zPPPOOaDaoWV0Wf6Qe6fOecc449+uijrs+q888/33UKf++997r+t7a22SFQXdS4AgAAAACgDjRp0sROOukka9OmjXvesGFDV7NJfVe9+eabrvN1BZH0+KGHHrLFixe7jtV32GEH1+G6lpe2bdu69aSkpJQKXGkEwj/++MONFHjhhRfaE088YX/+85/Dy5T1meqnSuvzg1Lahk8++cQF0TQKoWpnffTRR3bqqaeG11PWNmidmqeRCYGaEvI0PAEAAAAAAAAQZ6hxBQAAAAAAgLhE4AoAAAAAAABxicAVAAAAAAAA4hKBKwAAAAAAAMQlAlcAAAAAAACISwSuAAAAAAAAEJcIXAEAAAAAACAuEbgCAAAAAABAXCJwBQAAAAAAgLhE4AoAAAAAAABxicAVAAAAAAAA4hKBKwAAAAAAAFg8+n/K8LHaKsYlPwAAAABJRU5ErkJggg==",
       "text/plain": [
        "<Figure size 1200x800 with 7 Axes>"
       ]
@@ -303,10 +369,10 @@
    "id": "e8fe3579",
    "metadata": {
     "execution": {
-     "iopub.execute_input": "2026-09-23T15:23:38.090938Z",
-     "iopub.status.busy": "2026-09-23T15:23:38.089937Z",
-     "iopub.status.idle": "2026-09-23T15:23:38.105884Z",
-     "shell.execute_reply": "2026-09-23T15:23:38.105366Z"
+     "iopub.execute_input": "2026-09-28T11:31:50.071575Z",
+     "iopub.status.busy": "2026-09-28T11:31:50.071575Z",
+     "iopub.status.idle": "2026-09-28T11:31:50.088992Z",
+     "shell.execute_reply": "2026-09-28T11:31:50.087982Z"
     }
    },
    "outputs": [
@@ -349,17 +415,17 @@
        "  <tbody>\n",
        "    <tr>\n",
        "      <th>alpha</th>\n",
-       "      <td>0.536</td>\n",
-       "      <td>0.043</td>\n",
-       "      <td>0.304</td>\n",
+       "      <td>0.553</td>\n",
+       "      <td>0.032</td>\n",
+       "      <td>0.229</td>\n",
        "      <td>0.6</td>\n",
        "      <td>0.2</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>temperature</th>\n",
-       "      <td>2.635</td>\n",
-       "      <td>0.333</td>\n",
-       "      <td>2.375</td>\n",
+       "      <td>2.131</td>\n",
+       "      <td>0.137</td>\n",
+       "      <td>0.981</td>\n",
        "      <td>2.0</td>\n",
        "      <td>1.0</td>\n",
        "    </tr>\n",
@@ -370,8 +436,8 @@
       "text/plain": [
        "              mean  mean_se     sd  true mean  true sd\n",
        "parameter                                             \n",
-       "alpha        0.536    0.043  0.304        0.6      0.2\n",
-       "temperature  2.635    0.333  2.375        2.0      1.0"
+       "alpha        0.553    0.032  0.229        0.6      0.2\n",
+       "temperature  2.131    0.137  0.981        2.0      1.0"
       ]
      },
      "execution_count": 5,
@@ -405,10 +471,10 @@
    "id": "072aac7f",
    "metadata": {
     "execution": {
-     "iopub.execute_input": "2026-09-23T15:23:38.108891Z",
-     "iopub.status.busy": "2026-09-23T15:23:38.107895Z",
-     "iopub.status.idle": "2026-09-23T15:23:38.120504Z",
-     "shell.execute_reply": "2026-09-23T15:23:38.119496Z"
+     "iopub.execute_input": "2026-09-28T11:31:50.090992Z",
+     "iopub.status.busy": "2026-09-28T11:31:50.089992Z",
+     "iopub.status.idle": "2026-09-28T11:31:50.104195Z",
+     "shell.execute_reply": "2026-09-28T11:31:50.103679Z"
     }
    },
    "outputs": [
@@ -443,21 +509,21 @@
        "  </thead>\n",
        "  <tbody>\n",
        "    <tr>\n",
-       "      <th>6</th>\n",
+       "      <th>10</th>\n",
        "      <td>alpha</td>\n",
-       "      <td>0.5363</td>\n",
-       "      <td>0.0426</td>\n",
+       "      <td>0.5530</td>\n",
+       "      <td>0.0321</td>\n",
        "      <td>0.5</td>\n",
-       "      <td>0.8518</td>\n",
-       "      <td>0.3983</td>\n",
+       "      <td>1.6516</td>\n",
+       "      <td>0.1048</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>7</th>\n",
+       "      <th>11</th>\n",
        "      <td>temperature</td>\n",
-       "      <td>2.6354</td>\n",
-       "      <td>0.3326</td>\n",
+       "      <td>2.1311</td>\n",
+       "      <td>0.1374</td>\n",
        "      <td>5.0</td>\n",
-       "      <td>-7.1088</td>\n",
+       "      <td>-20.8845</td>\n",
        "      <td>0.0000</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
@@ -465,9 +531,9 @@
        "</div>"
       ],
       "text/plain": [
-       "     parameter    mean  mean_se  null  t_stat   p_val\n",
-       "6        alpha  0.5363   0.0426   0.5  0.8518  0.3983\n",
-       "7  temperature  2.6354   0.3326   5.0 -7.1088  0.0000"
+       "      parameter    mean  mean_se  null   t_stat   p_val\n",
+       "10        alpha  0.5530   0.0321   0.5   1.6516  0.1048\n",
+       "11  temperature  2.1311   0.1374   5.0 -20.8845  0.0000"
       ]
      },
      "execution_count": 6,
@@ -502,10 +568,10 @@
    "id": "3a59fc01",
    "metadata": {
     "execution": {
-     "iopub.execute_input": "2026-09-23T15:23:38.123011Z",
-     "iopub.status.busy": "2026-09-23T15:23:38.122504Z",
-     "iopub.status.idle": "2026-09-23T15:23:38.280874Z",
-     "shell.execute_reply": "2026-09-23T15:23:38.280368Z"
+     "iopub.execute_input": "2026-09-28T11:31:50.105709Z",
+     "iopub.status.busy": "2026-09-28T11:31:50.105709Z",
+     "iopub.status.idle": "2026-09-28T11:31:50.376592Z",
+     "shell.execute_reply": "2026-09-28T11:31:50.376086Z"
     },
     "tags": [
      "thumbnail"
@@ -514,7 +580,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 1000x450 with 2 Axes>"
       ]
@@ -548,18 +614,18 @@
    "id": "24b6fccc",
    "metadata": {
     "execution": {
-     "iopub.execute_input": "2026-09-23T15:23:38.282881Z",
-     "iopub.status.busy": "2026-09-23T15:23:38.282881Z",
-     "iopub.status.idle": "2026-09-23T15:23:38.290916Z",
-     "shell.execute_reply": "2026-09-23T15:23:38.289909Z"
+     "iopub.execute_input": "2026-09-28T11:31:50.379104Z",
+     "iopub.status.busy": "2026-09-28T11:31:50.378103Z",
+     "iopub.status.idle": "2026-09-28T11:31:50.386138Z",
+     "shell.execute_reply": "2026-09-28T11:31:50.385631Z"
     }
    },
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "alpha          0.149\n",
-       "temperature    0.854\n",
+       "alpha          0.123\n",
+       "temperature    0.491\n",
        "Name: mean absolute error, dtype: float64"
       ]
      },
diff --git a/pyproject.toml b/pyproject.toml
index cc599cb..64227ba 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -21,30 +21,35 @@ maintainers = [
     { name = "Lenard Dome", email = "lenarddome@gmail.com" }
 ]
 license = { text = "AGPLv3" }
-requires-python = ">3.11.0"
+requires-python = ">=3.11"
 keywords = ["cpm-toolbox", "cpm", "computational-psychiatry", "computational-psychology", "psychometrics", "psychology"]
 classifiers = [
     "Development Status :: 4 - Beta",
     "Intended Audience :: Developers",
     "License :: OSI Approved :: GNU Affero General Public License v3",
     "Natural Language :: English",
-    "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: Implementation :: PyPy"
+    "Programming Language :: Python :: 3"
 ]
 dependencies = [
     "numpy>=2.0.0",
     "SciPy>=1.16.0",
-    "pandas>=2.1.4",
+    "pandas>=2.2.2",  # the first release that works with NumPy 2
     "multiprocess>=0.70.16",
     "ipyparallel>=8.8.0",
     "numdifftools>=0.9.41",
-    "pybads>=1.0.4",
+    "pybads>=1.0.5",  # the first release that works with NumPy 2
     "gpyreg>=1.2.1", # see 7ced733
     "dill>=0.3.8",
-    "matplotlib>=3.8.0"
+    "matplotlib>=3.8.4"  # the first release that works with NumPy 2
 ]
 
 [project.optional-dependencies]
+# compiles the session models of cpm.applications and the kernels in cpm.models.kernels;
+# numba supports a new NumPy release some time after it comes out (0.64 is the first
+# release that supports NumPy 2.4), and does not support PyPy
+numba = [
+    "numba>=0.64",
+]
 docs = [
     "sphinx>=8.2",
     "pydata-sphinx-theme>=0.16",
diff --git a/scripts/local_tests.py b/scripts/local_tests.py
new file mode 100644
index 0000000..8c1c06e
--- /dev/null
+++ b/scripts/local_tests.py
@@ -0,0 +1,86 @@
+"""
+Run the test suite in each local configuration, then the benchmark suite.
+
+    python scripts/local_tests.py [--python PATH ...] [--no-benchmark]
+
+For each Python interpreter (by default the one running this script), the
+suite runs three times:
+
+- with numba, if it is installed in that environment;
+- with ``CPM_DISABLE_JIT=1``, as if numba were not installed, which runs the
+  built-in applications as plain Python;
+- with ``NUMBA_DISABLE_JIT=1``, numba's own switch, for the kernel and application
+  tests only.
+
+To test several environments, create one virtual environment per Python
+version, install cpm into each (``pip install -e .[numba] pytest``, and one
+with ``pip install -e . pytest`` for an install without numba), and pass their
+interpreters with ``--python``. The benchmark runs with the first interpreter
+and writes benchmarks/results/local.csv.
+
+numba's cache of compiled code is deleted first: numba only checks whether a
+function's own file changed, so the compiled loops of cpm.applications would
+otherwise keep using kernels of cpm.models.kernels that have since changed.
+
+The script exits with a non-zero status if any run fails.
+"""
+
+import argparse
+import os
+import pathlib
+import subprocess
+import sys
+
+ROOT = pathlib.Path(__file__).resolve().parents[1]
+FAST = ["test/models/test_kernels.py", "test/applications/test_backends.py"]
+
+
+def run(python, environment, tests, label):
+    env = {**os.environ, **environment}
+    command = [python, "-m", "pytest", "-q", "-p", "no:cacheprovider", *tests]
+    print(f"\n=== {label}: {' '.join(f'{k}={v}' for k, v in environment.items()) or 'numba on'}", flush=True)
+    return subprocess.run(command, cwd=ROOT, env=env).returncode
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("--python", nargs="*", default=[sys.executable])
+    parser.add_argument("--no-benchmark", action="store_true")
+    args = parser.parse_args()
+
+    for path in ROOT.glob("cpm/**/__pycache__/*.nb[ci]"):
+        path.unlink()
+
+    failures = []
+    for python in args.python:
+        version = subprocess.run(
+            [python, "-c", "import sys, platform; print(platform.python_version(), sys.platform)"],
+            capture_output=True, text=True,
+        ).stdout.strip()
+        for environment, tests in (
+            ({}, []),
+            ({"CPM_DISABLE_JIT": "1"}, []),
+            ({"NUMBA_DISABLE_JIT": "1"}, FAST),
+        ):
+            label = f"{python} (Python {version})"
+            if run(python, environment, tests, label) != 0:
+                failures.append((label, environment))
+
+    if not args.no_benchmark:
+        print("\n=== benchmark", flush=True)
+        code = subprocess.run(
+            [args.python[0], "benchmarks/run.py", "--label", "local"], cwd=ROOT
+        ).returncode
+        if code != 0:
+            failures.append(("benchmark", {}))
+
+    if failures:
+        print("\nFailed:")
+        for label, environment in failures:
+            print(f"  {label} {environment}")
+        sys.exit(1)
+    print("\nAll local runs passed.")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/setup.cfg b/setup.cfg
deleted file mode 100644
index 0a8df87..0000000
--- a/setup.cfg
+++ /dev/null
@@ -1,2 +0,0 @@
-[wheel]
-universal = 1
\ No newline at end of file
diff --git a/test/applications/data/per_trial_reference.pkl.gz b/test/applications/data/per_trial_reference.pkl.gz
new file mode 100644
index 0000000..ac409d9
Binary files /dev/null and b/test/applications/data/per_trial_reference.pkl.gz differ
diff --git a/test/applications/test_backends.py b/test/applications/test_backends.py
new file mode 100644
index 0000000..73f12da
--- /dev/null
+++ b/test/applications/test_backends.py
@@ -0,0 +1,351 @@
+"""
+The built-in applications give the same results as their former per-trial
+implementations, with and without numba.
+
+The applications compute all trials of a participant in one call, compiled with
+numba if it is installed. Until commit 3385574 they were per-trial `Wrapper`
+models built from the classes in `cpm.models`. The outputs of those per-trial
+implementations, for the cases below, are frozen in
+`data/per_trial_reference.pkl.gz`: exports, dependent variables, final states,
+objective values, the per-trial `simulation` records, a call of the per-trial
+`model` function, and a seeded simulation with `Simulator`. Tables are stored as
+dictionaries of numpy arrays, so that any version of pandas can read them.
+
+numba and NumPy may compute exponentials differently in the last digit, depending
+on the platform and CPU, so results are compared to a relative tolerance of 1e-12.
+"""
+
+import builtins
+import copy
+import gzip
+import os
+import pathlib
+import pickle
+import subprocess
+import sys
+import warnings
+import zipfile
+
+import numpy as np
+import pandas as pd
+import pytest
+
+from cpm.applications.decision_making import PTSM, PTSM1992, PTSM2025
+from cpm.applications.reinforcement_learning import RLRW, HybridMBMF
+from cpm.core import _jit
+from cpm.core.data import unpack_trials
+from cpm.core.optimisers import objective
+from cpm.datasets import load_bandit_data, load_risky_choices
+from cpm.generators import Simulator, Wrapper
+from cpm.optimisation import FminBound, minimise
+
+with gzip.open(os.path.join(os.path.dirname(__file__), "data", "per_trial_reference.pkl.gz")) as f:
+    REFERENCE = pickle.load(f)
+
+BACKENDS = ["python", pytest.param("numba", marks=pytest.mark.skipif(
+    not _jit.JIT_ENABLED, reason="numba is not installed or disabled"))]
+TOLERANCE = dict(rtol=1e-12, atol=1e-12)
+
+
+@pytest.fixture(autouse=True)
+def quiet():
+    warnings.simplefilter("ignore")
+
+
+def bandit(ppt=1):
+    data = load_bandit_data()
+    data = data[data.ppt == ppt].reset_index(drop=True)
+    data["observed"] = data["response"]
+    return data
+
+
+def two_step(n=120, seed=0):
+    rng = np.random.default_rng(seed)
+    action = rng.integers(0, 2, n)
+    return pd.DataFrame({
+        "s1": rng.integers(0, 2, n),
+        "stimuli_first": rng.integers(0, 2, n),
+        "action": action,
+        "s2": 1 - action,
+        "reward": rng.integers(0, 10, n) / 9,
+        "reward_0": rng.integers(0, 10, n) / 9,
+        "reward_1": rng.integers(0, 10, n) / 9,
+        "observed": action,
+    })
+
+
+def risky(ppt=1):
+    data = load_risky_choices()
+    data = data[data.ppt == ppt].reset_index(drop=True)
+    data["observed"] = data["choice"].astype(int)
+    return data
+
+
+PT = {
+    "alpha": [0.8, 1e-2, 5.0], "lambda_loss": [1.6, 1e-2, 5.0], "gamma": [0.7, 1e-2, 5.0],
+    "temperature": [3.0, 1e-2, 15.0], "beta": [0.9, 0.0, 5.0], "delta": [0.6, 1e-2, 5.0],
+    "eta": [0.1, -0.49, 0.49], "phi_gain": [0.2, -10.0, 10.0], "phi_loss": [-0.3, -10.0, 10.0],
+}
+HYBRID = [[2, 0, 5], [0.4, 0, 1], [0.6, 0, 1], [0.5, 0, 1], [0.3, -5, 5], [-0.2, -5, 5]]
+
+
+def cubic(x=None, alpha=None, lambda_loss=None):
+    return np.where(x >= 0, x**3 * alpha, lambda_loss * x**3)
+
+
+## (name in the reference, class, data, keyword arguments)
+CASES = [
+    ("RLRW", RLRW, bandit, dict(dimensions=4, parameters_settings=[[0.3, 0, 1], [4, 0, 10]])),
+    ("RLRW-generate", RLRW, bandit,
+     dict(dimensions=4, parameters_settings=[[0.3, 0, 1], [4, 0, 10]], generate=True)),
+    ("HybridMBMF", HybridMBMF, two_step, dict(parameters_settings=HYBRID)),
+    ("HybridMBMF-q_init", HybridMBMF, two_step, dict(parameters_settings=HYBRID, q_init=4.5)),
+    ("HybridMBMF-generate", HybridMBMF, two_step, dict(parameters_settings=HYBRID, generate=True)),
+    ("PTSM", PTSM, risky, dict(parameters_settings=PT)),
+    ("PTSM-power", PTSM, risky, dict(parameters_settings=PT, weighting="power")),
+    ("PTSM-prelec", PTSM, risky, dict(parameters_settings=PT, weighting="prelec")),
+    ("PTSM-generate", PTSM, risky, dict(parameters_settings=PT, generate=True)),
+    ("PTSM1992", PTSM1992, risky, dict(parameters_settings=PT)),
+    ("PTSM1992-gw", PTSM1992, risky, dict(parameters_settings=PT, weighting="gw")),
+    ("PTSM1992-curve", PTSM1992, risky, dict(parameters_settings=PT, utility_curve=cubic)),
+    ("PTSM2025", PTSM2025, risky, dict(parameters_settings=PT)),
+    ("PTSM2025-standard", PTSM2025, risky, dict(parameters_settings=PT, variant="standard")),
+]
+IDS = [case[0] for case in CASES]
+
+
+def on_backend(model, backend):
+    """Run `model` on `backend` (normally chosen by whether numba is installed)."""
+    model._session_model.backend = backend
+    return model
+
+
+def build(case, backend):
+    _, cls, data, kwargs = case
+    frame = data()
+    return on_backend(cls(data=frame, **kwargs), backend), frame["observed"].to_numpy()
+
+
+def free_values(model, scale):
+    """Parameter values inside the bounds, away from the initial ones."""
+    lower, upper = model.parameters.bounds()
+    return lower + scale * (upper - lower)
+
+
+def assert_same_records(got, expected):
+    assert list(got) == list(expected)
+    for key in expected:
+        np.testing.assert_allclose(np.asarray(got[key], float), np.asarray(expected[key], float), **TOLERANCE)
+        assert np.shape(got[key]) == np.shape(expected[key]), key
+
+
+@pytest.mark.parametrize("backend", BACKENDS)
+@pytest.mark.parametrize("case", CASES, ids=IDS)
+def test_runs_equal_the_per_trial_implementation(case, backend):
+    reference = REFERENCE["cases"][case[0]]
+    model, _ = build(case, backend)
+    for scale in (None, 0.2, 0.7):
+        x = None if scale is None else free_values(model, scale)
+        np.random.seed(123)
+        model.reset(parameters=x)
+        model.run()
+        np.testing.assert_allclose(model.dependent, reference["dependent"][scale], **TOLERANCE)
+        if scale in reference["exports"]:
+            expected, got = pd.DataFrame(reference["exports"][scale]), model.export()
+            assert list(got.columns) == list(expected.columns)
+            assert dict(got.dtypes) == dict(expected.dtypes)
+            np.testing.assert_allclose(got.to_numpy(float), expected.to_numpy(float), **TOLERANCE)
+        if scale is None:
+            for key, value in reference["states"].items():
+                np.testing.assert_allclose(np.asarray(model.parameters[key].value, float), value, **TOLERANCE)
+            ## the per-trial records of the run, as a per-trial Wrapper kept them
+            assert len(model.simulation) == len(model.dependent)
+            for got, expected in zip(model.simulation[:3], reference["simulation"]):
+                assert_same_records(got, expected)
+
+
+@pytest.mark.parametrize("backend", BACKENDS)
+@pytest.mark.parametrize("case", [c for c in CASES if "generate" not in c[0]],
+                         ids=[i for i in IDS if "generate" not in i])
+def test_objective_equals_the_per_trial_implementation(case, backend):
+    model, observed = build(case, backend)
+    for scale, (expected, closest) in REFERENCE["cases"][case[0]]["objective"].items():
+        np.random.seed(1)
+        got = objective(free_values(model, scale), model, observed, minimise.LogLikelihood.bernoulli, True)
+        ## near p = 0 or 1, rounding errors in p are amplified by 1 / (1 - p) in the log likelihood
+        rel = 1e-12 if closest > 1e-6 else 1e-12 + 1e-15 / closest
+        assert got == pytest.approx(expected, rel=rel, abs=1e-12)
+
+
+@pytest.mark.parametrize("backend", BACKENDS)
+@pytest.mark.parametrize("case", CASES, ids=IDS)
+def test_the_per_trial_model_function_is_unchanged(case, backend):
+    """`model(parameters, trial)` computes one trial from the states in `parameters`."""
+    model, _ = build(case, backend)
+    np.random.seed(5)
+    first = unpack_trials(model.data, 0, model.__pandas__)
+    got = model.model(parameters=model.parameters, trial=first)
+    assert_same_records(got, REFERENCE["cases"][case[0]]["model"])
+
+
+@pytest.mark.parametrize("backend", BACKENDS)
+@pytest.mark.parametrize("case", CASES, ids=IDS)
+def test_the_per_trial_model_function_reproduces_a_run(case, backend):
+    """Wrapping `model` in a per-trial Wrapper, as users do to extend a model, gives the same run."""
+    model, _ = build(case, backend)
+    per_trial = Wrapper(model=model.model, data=model.data, parameters=model.parameters)
+    for wrapper in (model, per_trial):
+        np.random.seed(9)
+        wrapper.run()
+    pd.testing.assert_frame_equal(per_trial.export(), model.export(), check_exact=False, rtol=1e-12, atol=1e-12)
+
+
+@pytest.mark.parametrize("backend", BACKENDS)
+def test_simulations_equal_the_per_trial_implementation(backend):
+    data = pd.concat([two_step(60, seed=s).assign(ppt=s) for s in range(3)], ignore_index=True)
+    draws = pd.DataFrame({
+        "inv_temperature": [1.0, 2.0, 3.0], "learning_rate": [0.2, 0.5, 0.8],
+        "eligibility_trace": [0.5, 0.5, 0.5], "mb_weight": [0.1, 0.5, 0.9],
+        "choice_stickiness": [0.0, 0.3, -0.3], "response_stickiness": [0.2, 0.0, 0.1],
+    })
+    wrapper = on_backend(HybridMBMF(data=data[data.ppt == 0], parameters_settings=HYBRID, generate=True), backend)
+    simulator = Simulator(wrapper=wrapper, data=data.groupby("ppt"), parameters=draws)
+    np.random.seed(2024)
+    simulator.run()
+    pd.testing.assert_frame_equal(simulator.export(), pd.DataFrame(REFERENCE["simulator"]), check_exact=False,
+                                  rtol=1e-12, atol=1e-12)
+
+
+@pytest.mark.skipif(not _jit.JIT_ENABLED, reason="numba is not installed or disabled")
+@pytest.mark.parametrize("case", CASES, ids=IDS)
+def test_backends_agree(case):
+    exports = []
+    for backend in ("python", "numba"):
+        model, _ = build(case, backend)
+        np.random.seed(7)
+        model.run()
+        exports.append(model.export())
+    pd.testing.assert_frame_equal(exports[0], exports[1], check_exact=False, **TOLERANCE)
+
+
+def test_numba_is_used_when_installed(monkeypatch):
+    model = RLRW(data=bandit(), dimensions=4)
+    assert model._session_model.backend == ("numba" if _jit.JIT_ENABLED else "python")
+    monkeypatch.setattr(_jit, "HAVE_NUMBA", False)
+    monkeypatch.setattr(_jit, "JIT_ENABLED", False)
+    assert RLRW(data=bandit(), dimensions=4)._session_model.backend == "python"
+
+
+def test_a_numba_that_fails_to_load_falls_back_to_python_with_a_warning(monkeypatch):
+    real_import = builtins.__import__
+
+    def failing_import(name, *args, **kwargs):
+        if name == "numba":
+            raise OSError("llvmlite could not be loaded")
+        return real_import(name, *args, **kwargs)
+
+    monkeypatch.delenv("CPM_DISABLE_JIT", raising=False)
+    monkeypatch.setattr(builtins, "__import__", failing_import)
+    monkeypatch.setattr(_jit, "_STATE", {})
+    with pytest.warns(UserWarning, match="could not be imported"):
+        assert _jit._probe()["HAVE_NUMBA"] is False
+
+
+@pytest.mark.skipif(not _jit.JIT_ENABLED, reason="numba is not installed or disabled")
+def test_kernels_compile_where_numba_cannot_cache(monkeypatch):
+    from numba.core import caching
+
+    monkeypatch.setattr(caching.CacheImpl, "_locator_classes", [])
+
+    def double(x):
+        return 2 * x
+
+    assert _jit.njit(double)(2) == 4
+
+
+def test_cpm_imports_from_a_zip(tmp_path):
+    root = pathlib.Path(__file__).resolve().parents[2]
+    archive = tmp_path / "cpm.zip"
+    with zipfile.ZipFile(archive, "w") as z:
+        for path in (root / "cpm").rglob("*.py"):
+            z.write(path, path.relative_to(root))
+    code = "import cpm, cpm.models; assert 'cpm.zip' in cpm.__file__"
+    env = {**os.environ, "PYTHONPATH": str(archive)}
+    subprocess.run([sys.executable, "-c", code], cwd=tmp_path, env=env, check=True)
+
+
+def test_missing_columns_are_reported_when_the_model_runs():
+    """As before, the data are checked when they are used, not when the model is created."""
+    model = PTSM2025(data=risky().drop(columns="ambiguity"), parameters_settings=PT)
+    with pytest.raises(KeyError, match="ambiguity"):
+        model.run()
+    model = HybridMBMF(data=two_step().drop(columns="reward_0"), generate=True)
+    with pytest.raises(KeyError, match="reward_0"):
+        model.run()
+
+
+def _recoded(data, **columns):
+    data = data.copy()
+    for key, value in columns.items():
+        data[key] = value(data[key])
+    return data
+
+
+@pytest.mark.parametrize("backend", BACKENDS)
+@pytest.mark.parametrize("make, match", [
+    (lambda: RLRW(data=_recoded(bandit(), response=lambda x: x + 1), dimensions=4), "response"),
+    (lambda: RLRW(data=_recoded(bandit(), response=lambda x: x.where(x.index != 3)), dimensions=4),
+     "response"),
+    (lambda: RLRW(data=bandit(), dimensions=2), "stimuli"),
+    (lambda: HybridMBMF(data=_recoded(two_step(), s1=lambda x: x + 1)), "s1"),
+    (lambda: HybridMBMF(data=_recoded(two_step(), action=lambda x: x + 1)), "action"),
+    (lambda: PTSM(data=_recoded(risky(), observed=lambda x: x + 1), parameters_settings=PT),
+     "observed"),
+], ids=["RLRW-1-based", "RLRW-NaN", "RLRW-dimensions", "Hybrid-s1", "Hybrid-action", "PTSM"])
+def test_data_out_of_range_raise_instead_of_reading_past_the_arrays(make, match, backend):
+    """numba does not check indices; the models check the data they index with."""
+    model = on_backend(make(), backend)
+    with pytest.raises(IndexError, match=match):
+        model.run()
+
+
+@pytest.mark.parametrize("backend", BACKENDS)
+def test_nan_rewards_raise_as_softmax_does(backend):
+    data = bandit()
+    data["reward_left"] = data.reward_left.where(data.index != 3)
+    model = on_backend(RLRW(data=data, dimensions=4), backend)
+    with pytest.raises(ValueError, match="NaN"):
+        model.run()
+
+
+def test_models_survive_deepcopy_and_pickling():
+    model = HybridMBMF(data=two_step(), parameters_settings=HYBRID)
+    model.run()
+    clone = pickle.loads(pickle.dumps(copy.deepcopy(model)))
+    clone.reset()
+    clone.run()
+    np.testing.assert_array_equal(clone.dependent, model.dependent)
+    assert len(clone.simulation) == len(model.simulation)
+
+
+def test_parallel_fit_matches_the_serial_fit():
+    """With multiprocess on Windows (spawn), each worker loads the cached kernels."""
+    data = pd.concat([bandit(p).assign(ppt=p) for p in (1, 2, 3, 4)], ignore_index=True)
+    fits = []
+    for parallel in (False, True):
+        fit = FminBound(
+            model=RLRW(data=bandit(1), dimensions=4, parameters_settings=[[0.3, 0, 1], [4, 0, 10]]),
+            data=data,
+            minimisation=minimise.LogLikelihood.bernoulli,
+            prior=True,
+            ppt_identifier="ppt",
+            initial_guess=[[0.4, 3.0]],
+            number_of_starts=1,
+            approx_grad=True,
+            parallel=parallel,
+            cl=2 if parallel else None,
+        )
+        fit.optimise()
+        fits.append(fit.export().sort_values("ppt").reset_index(drop=True))
+    for column in ("x_0", "x_1", "fun"):
+        np.testing.assert_allclose(fits[1][column], fits[0][column], rtol=1e-10)
diff --git a/test/applications/test_reinforcement_learning.py b/test/applications/test_reinforcement_learning.py
index b2c1277..fa26152 100644
--- a/test/applications/test_reinforcement_learning.py
+++ b/test/applications/test_reinforcement_learning.py
@@ -88,8 +88,9 @@ def test_model_accuracy(setup_data):
     model.run()
     import numpy as np
 
-    assert np.array_equal(
-        model.dependent, expected_output
+    ## to the last digits, in which NumPy's exponentials differ between CPUs
+    assert np.allclose(
+        model.dependent, expected_output, rtol=1e-12, atol=1e-12
     ), "Model accuracy test failed"
     print("test_model_accuracy passed")
 
@@ -117,12 +118,14 @@ def test_model_warnings(setup_data):
             parameters_settings=[[0.5, 0, 1], [1000, 1, 10]],
         )
         model.run()
-        assert len(w) > 0, "Warnings not raised"
-        assert issubclass(w[-1].category, UserWarning), "Warning is not a UserWarning"
-        assert (
-            "NaN values found in policies. Replacing NaN values with 1 and normalising the policies to sum to 1."
-            in str(w[-1].message)
-        ), "Warning message mismatch"
+        ## an inverse temperature this large used to overflow the softmax, which
+        ## then replaced the NaN policies with a warning; the softmax now computes
+        ## these policies without overflow, so there is nothing to warn about
+        assert not any("NaN" in str(warning.message) for warning in w)
+        assert not any(issubclass(warning.category, RuntimeWarning) for warning in w)
+        policies = model.export().filter(like="policy").to_numpy()
+        assert np.all(np.isfinite(policies))
+        np.testing.assert_allclose(policies.sum(axis=1), 1.0)
 
     print("test_model_warnings passed")
 
diff --git a/test/applications/test_signal_detection.py b/test/applications/test_signal_detection.py
index 05883ad..91f29b5 100644
--- a/test/applications/test_signal_detection.py
+++ b/test/applications/test_signal_detection.py
@@ -80,3 +80,40 @@ def test_estimatormetad_init_optimise_export(synthetic_data):
     df = est.export()
     assert isinstance(df, pd.DataFrame)
     assert np.all(np.isclose(expected_output, df, atol=1e-5))
+
+
+def _metad_nll_with_scipy(guess, nR_S1, nR_S2, nRatings, d1, t1c1, s):
+    """The meta-d' log likelihood written out with scipy.stats.norm.cdf, as metad_nll used to compute it."""
+    from scipy.stats import norm
+
+    meta_d1, t2c1 = guess[0], guess[1:]
+    S1mu, S2mu, S1sd, S2sd = -meta_d1 / 2, meta_d1 / 2, 1, 1 / s
+    S1mu, S2mu = S1mu - meta_d1 * (t1c1 / d1), S2mu - meta_d1 * (t1c1 / d1)
+    x = [-np.inf, *t2c1[: nRatings - 1], 0, *t2c1[nRatings - 1 :], np.inf]
+    areas = (norm.cdf(0, S1mu, S1sd), norm.cdf(0, S2mu, S2sd),
+             1 - norm.cdf(0, S2mu, S2sd), 1 - norm.cdf(0, S1mu, S1sd))
+    logL = 0.0
+    for i in range(nRatings):
+        logL = (logL
+                + nR_S1[i] * np.log((norm.cdf(x[i + 1], S1mu, S1sd) - norm.cdf(x[i], S1mu, S1sd)) / areas[0])
+                + nR_S2[i] * np.log((norm.cdf(x[i + 1], S2mu, S2sd) - norm.cdf(x[i], S2mu, S2sd)) / areas[1])
+                + nR_S2[i + nRatings] * np.log(((1 - norm.cdf(x[nRatings + i], S2mu, S2sd))
+                                                - (1 - norm.cdf(x[nRatings + i + 1], S2mu, S2sd))) / areas[2])
+                + nR_S1[i + nRatings] * np.log(((1 - norm.cdf(x[nRatings + i], S1mu, S1sd))
+                                                - (1 - norm.cdf(x[nRatings + i + 1], S1mu, S1sd))) / areas[3]))
+    if np.isinf(logL) or np.isnan(logL):  # as metad_nll does
+        logL = -1e300
+    return -logL
+
+
+def test_metad_nll_equals_the_scipy_computation():
+    rng = np.random.default_rng(11)
+    for n_ratings in (2, 3, 4, 6):
+        for _ in range(50):
+            nR_S1 = rng.integers(0, 40, 2 * n_ratings) + 0.25
+            nR_S2 = rng.integers(0, 40, 2 * n_ratings) + 0.25
+            t2 = np.sort(np.concatenate([-rng.uniform(0, 3, n_ratings - 1), rng.uniform(0, 3, n_ratings - 1)]))
+            guess = np.concatenate([[rng.normal(1, 1)], t2])
+            args = (nR_S1, nR_S2, n_ratings, rng.uniform(0.2, 2), rng.normal(0, 0.5), 1)
+            assert signal_detection.metad_nll(guess, *args) == pytest.approx(
+                _metad_nll_with_scipy(guess, *args), rel=1e-14)
diff --git a/test/generators/test_fast_priors.py b/test/generators/test_fast_priors.py
new file mode 100644
index 0000000..c7df8fa
--- /dev/null
+++ b/test/generators/test_fast_priors.py
@@ -0,0 +1,204 @@
+import copy
+import pickle
+import warnings
+
+import numpy as np
+import pandas as pd
+import pytest
+from scipy import stats
+
+from cpm.generators import LogParameters, Parameters, Value, Wrapper
+from cpm.generators._fast_priors import fast_logpdf
+
+## the priors Value builds from a string, as (prior, args, lower, upper)
+BUILT_IN = [
+    ("uniform", None, 0.1, 3.0),
+    ("truncated_normal", {"mean": 0.5, "sd": 0.25}, 0.0, 1.0),
+    ("truncated_normal", {"mean": 5, "sd": 2.5}, 0.0, 10.0),
+    ("truncated_normal", {"mean": 0.0, "sd": 1.0}, -5.0, 5.0),
+    ("beta", {"a": 2.0, "b": 3.0, "mean": 0.0, "sd": 1.0}, 0.0, 1.0),
+    ("gamma", {"a": 2.5, "mean": 0.0, "sd": 1.5}, 0.0, 20.0),
+    ("gamma", {"a": 0.7, "mean": 0.0, "sd": 1.0}, 0.0, 20.0),
+    ("truncated_exponential", {"mean": 0.0, "sd": 2.0}, 0.0, 10.0),
+    ("norm", {"mean": 1.0, "sd": 2.0}, -10.0, 10.0),
+]
+
+
+@pytest.mark.parametrize("prior, args, lower, upper", BUILT_IN)
+def test_logpdf_equals_scipy_inside_and_outside_the_support(prior, args, lower, upper):
+    value = Value(value=lower, lower=lower, upper=upper, prior=prior, args=args)
+    rng = np.random.default_rng(1)
+    points = np.concatenate(
+        [
+            rng.uniform(lower - 1, upper + 1, 200),
+            [lower, upper, lower - 1e-9, upper + 1e-9, (lower + upper) / 2],
+        ]
+    )
+    for x in points:
+        value.fill(x)
+        expected = value.prior.logpdf(x)
+        got = value.PDF(log=True)
+        assert got == expected  # identical, not only close
+        assert isinstance(got, np.float64)
+
+
+@pytest.mark.parametrize(
+    "frozen",
+    [
+        stats.norm(0.3, 2.0),  # positional arguments
+        stats.gamma(2.0, scale=3.0),
+        stats.beta(0.5, 0.5),
+        stats.truncnorm(-1.0, 3.0, loc=1.0, scale=0.5),
+        stats.uniform(-2, 4),
+    ],
+)
+def test_logpdf_of_user_supplied_frozen_distributions(frozen):
+    for x in np.linspace(-3, 6, 101):
+        expected = frozen.logpdf(x)
+        got = fast_logpdf(frozen, x)
+        got = frozen.logpdf(x) if got is None else got
+        assert got == expected
+
+
+def test_other_priors_and_values_fall_back_to_scipy():
+    ## unsupported family
+    assert fast_logpdf(stats.lognorm(0.5), 1.0) is None
+    ## array-valued points
+    assert fast_logpdf(stats.norm(0, 1), np.array([0.1, 0.2])) is None
+    ## objects that are not scipy distributions
+    assert fast_logpdf(object(), 0.1) is None
+    ## non-finite points
+    assert fast_logpdf(stats.norm(0, 1), np.nan) is None
+    mvn = Value(
+        value=np.zeros(2),
+        lower=-1,
+        upper=1,
+        prior=stats.multivariate_normal,
+        args={"mean": np.zeros(2), "cov": np.eye(2)},
+    )
+    assert mvn.PDF(log=True) == pytest.approx(
+        stats.multivariate_normal(np.zeros(2), np.eye(2)).logpdf(np.zeros(2))
+    )
+
+
+@pytest.mark.parametrize("prior", ["beta", "gamma"])
+def test_invalid_shape_parameters_give_nan_as_in_scipy(prior):
+    ## the default arguments of these priors have a = 0, which scipy rejects
+    value = Value(value=0.5, lower=0, upper=1, prior=prior)
+    assert np.isnan(value.prior.logpdf(0.5))
+    assert np.isnan(value.PDF(log=True))
+
+
+def test_priors_pickle_after_they_were_evaluated():
+    parameters = Parameters(
+        a=Value(value=0.5, lower=0, upper=1, prior="truncated_normal",
+                args={"mean": 0.5, "sd": 0.25})
+    )
+    expected = parameters.PDF(log=True)
+    restored = pickle.loads(pickle.dumps(parameters))
+    assert restored.PDF(log=True) == expected
+
+
+def test_priors_changed_in_place_are_picked_up():
+    value = Value(value=0.4, lower=0, upper=1, prior="truncated_normal",
+                  args={"mean": 0.5, "sd": 0.25})
+    before = value.PDF(log=True)
+    value.prior.kwds.update(loc=0.9, scale=0.05, a=(0 - 0.9) / 0.05, b=(1 - 0.9) / 0.05)
+    after = value.PDF(log=True)
+    assert after != before
+    assert after == pytest.approx(value.prior.logpdf(0.4), rel=1e-12)
+
+
+def test_copies_share_the_prior_but_not_the_value():
+    value = Value(value=np.array([0.1, 0.2]), lower=0, upper=1, prior="uniform")
+    copied = copy.deepcopy(value)
+    assert copied.prior is value.prior
+    assert copied.__pdef__ == "uniform"
+    copied.value[0] = 0.9
+    assert value.value[0] == 0.1
+
+
+def test_update_prior_does_not_leak_into_copies():
+    parameters = Parameters(
+        a=Value(value=0.5, lower=0, upper=1, prior="truncated_normal",
+                args={"mean": 0.5, "sd": 0.25})
+    )
+    copied = copy.deepcopy(parameters)
+    original = copied.PDF(log=True)
+    parameters.update_prior(a={"mean": 0.9, "sd": 0.05})
+    assert parameters.a.prior is not copied.a.prior
+    assert copied.PDF(log=True) == original
+    assert parameters.PDF(log=True) != original
+    assert isinstance(
+        parameters.a.prior, stats._distn_infrastructure.rv_continuous_frozen
+    )
+
+
+def _wrapper():
+    parameters = Parameters(
+        a=Value(value=0.5, lower=0, upper=1, prior="truncated_normal",
+                args={"mean": 0.5, "sd": 0.25}),
+        state=np.zeros(2),
+    )
+
+    def model(parameters, trial):
+        state = np.asarray(parameters.state) + parameters.a.value
+        return {"state": state, "dependent": np.array([parameters.a.value])}
+
+    data = pd.DataFrame({"x": np.zeros(3), "observed": np.zeros(3)})
+    return Wrapper(model=model, data=data, parameters=parameters)
+
+
+def test_reset_restores_values_and_states():
+    wrapper = _wrapper()
+    wrapper.reset(parameters=[0.2])
+    wrapper.run()
+    assert np.allclose(wrapper.parameters.state.value, 0.6)
+    wrapper.reset()
+    assert wrapper.parameters.a.value == 0.5
+    assert np.allclose(wrapper.parameters.state.value, 0.0)
+    assert np.allclose(wrapper.__init_parameters__.state.value, 0.0)
+
+
+def test_reset_keeps_updated_priors():
+    """cpm.hierarchical updates the priors of model.parameters between fits."""
+    wrapper = _wrapper()
+    wrapper.parameters.update_prior(a={"mean": 0.9, "sd": 0.05})
+    updated = wrapper.parameters.PDF(log=True)
+    for _ in range(3):
+        wrapper.reset(parameters=[0.5])
+        wrapper.run()
+    wrapper.reset(parameters=[0.5])
+    assert wrapper.parameters.PDF(log=True) == updated
+
+
+def test_reset_keeps_updated_priors_of_log_parameters():
+    parameters = LogParameters(
+        a=Value(value=0.5, lower=0, upper=1, prior="truncated_normal",
+                args={"mean": 0.5, "sd": 0.25})
+    )
+    data = pd.DataFrame({"x": np.zeros(3), "observed": np.zeros(3)})
+    wrapper = Wrapper(model=lambda parameters, trial: {"dependent": np.array([0.5])},
+                      data=data, parameters=parameters)
+    wrapper.parameters.update_prior(a={"mean": 0.9, "sd": 0.05})
+    updated = wrapper.parameters.a.prior
+    wrapper.run()
+    wrapper.reset()
+    assert type(wrapper.parameters) is LogParameters
+    assert wrapper.parameters.a.prior is updated
+
+
+def test_hierarchical_prior_updates_reach_the_objective():
+    """The prior that update_prior sets is the one the objective uses."""
+    from cpm.core.optimisers import objective
+    from cpm.optimisation.minimise import LogLikelihood
+
+    warnings.simplefilter("ignore")
+    wrapper = _wrapper()
+    observed = np.zeros((3, 1))
+    first = objective([0.5], wrapper, observed, LogLikelihood.bernoulli, True)
+    wrapper.parameters.update_prior(a={"mean": 0.9, "sd": 0.05})
+    values = [objective([0.5], wrapper, observed, LogLikelihood.bernoulli, True)
+              for _ in range(3)]
+    assert values[0] != first
+    assert values[0] == values[1] == values[2]
diff --git a/test/generators/test_session_wrapper.py b/test/generators/test_session_wrapper.py
new file mode 100644
index 0000000..4533dcb
--- /dev/null
+++ b/test/generators/test_session_wrapper.py
@@ -0,0 +1,303 @@
+"""
+A SessionWrapper has to be a drop-in replacement for a Wrapper: the same model
+written per trial and per session must give the same dependent variable,
+export, log likelihood and fits, and work with Simulator and cpm.hierarchical.
+"""
+
+import warnings
+
+import numpy as np
+import pandas as pd
+import pytest
+
+from cpm.core.optimisers import objective
+from cpm.generators import Parameters, SessionWrapper, Simulator, Value, Wrapper
+from cpm.hierarchical import EmpiricalBayes
+from cpm.optimisation import FminBound, Minimize, minimise
+
+
+def parameters():
+    return Parameters(
+        alpha=Value(value=0.3, lower=0, upper=1, prior="truncated_normal",
+                    args={"mean": 0.5, "sd": 0.25}),
+        beta=Value(value=2.0, lower=0, upper=10, prior="truncated_normal",
+                   args={"mean": 5, "sd": 2.5}),
+        values=np.array([0.5, 0.5]),
+    )
+
+
+def trial_model(parameters, trial):
+    """Q-learning on a two-armed bandit with a softmax policy, one trial."""
+    values = np.asarray(parameters.values).copy()
+    beta = parameters.beta.value
+    policy = np.exp(beta * values) / np.sum(np.exp(beta * values))
+    choice = int(trial["choice"])
+    error = trial["reward"] - values[choice]
+    values[choice] += parameters.alpha.value * error
+    return {
+        "policy": policy,
+        "error": error,
+        "values": values.copy(),
+        "dependent": np.array([policy[1]]),
+    }
+
+
+def session_model(parameters, data):
+    """The same model, all trials at once."""
+    alpha, beta = parameters.alpha.value, parameters.beta.value
+    values = np.asarray(parameters.values, dtype=float).copy()
+    n = len(data["choice"])
+    policy = np.empty((n, 2))
+    error = np.empty(n)
+    history = np.empty((n, 2))
+    for t in range(n):
+        policy[t] = np.exp(beta * values) / np.sum(np.exp(beta * values))
+        choice = int(data["choice"][t])
+        error[t] = data["reward"][t] - values[choice]
+        values[choice] += alpha * error[t]
+        history[t] = values
+    return {"policy": policy, "error": error, "values": history, "dependent": policy[:, 1]}
+
+
+def make_data(participants=(1, 2, 3), trials=60, seed=3):
+    rng = np.random.default_rng(seed)
+    frames = []
+    for ppt in participants:
+        choice = rng.integers(0, 2, trials)
+        frames.append(pd.DataFrame({
+            "ppt": ppt,
+            "choice": choice,
+            "reward": (rng.random(trials) < np.where(choice == 1, 0.7, 0.3)).astype(float),
+            "observed": choice,
+        }))
+    return pd.concat(frames, ignore_index=True)
+
+
+@pytest.fixture
+def data():
+    return make_data()
+
+
+@pytest.fixture
+def one(data):
+    return data[data.ppt == 1].reset_index(drop=True)
+
+
+def both(one):
+    warnings.simplefilter("ignore")
+    return (
+        Wrapper(model=trial_model, data=one, parameters=parameters()),
+        SessionWrapper(model=session_model, data=one, parameters=parameters()),
+    )
+
+
+def test_run_gives_the_same_dependent_and_final_state(one):
+    trial, session = both(one)
+    trial.run()
+    session.run()
+    assert session.dependent.shape == trial.dependent.shape == (len(one), 1)
+    np.testing.assert_allclose(session.dependent, trial.dependent, rtol=0, atol=1e-12)
+    np.testing.assert_allclose(session.parameters.values.value, trial.parameters.values.value,
+                               rtol=0, atol=1e-12)
+
+
+def test_export_has_the_same_layout(one):
+    trial, session = both(one)
+    trial.run()
+    session.run()
+    pd.testing.assert_frame_equal(session.export(), trial.export(), check_exact=False,
+                                  rtol=0, atol=1e-12)
+
+
+def test_objective_is_the_same_before_and_after_reset(one):
+    trial, session = both(one)
+    observed = one.observed.to_numpy()
+    for x in ([0.3, 2.0], [0.8, 6.0], [0.1, 0.5], [0.3, 2.0]):
+        expected = objective(x, trial, observed, minimise.LogLikelihood.bernoulli, True)
+        got = objective(x, session, observed, minimise.LogLikelihood.bernoulli, True)
+        assert got == pytest.approx(expected, rel=1e-12, abs=1e-12)
+    ## the initial state is restored on reset
+    np.testing.assert_array_equal(session.__init_parameters__.values.value, [0.5, 0.5])
+
+
+def test_reset_with_new_data_prepares_them_once(one, data):
+    calls = []
+
+    def prepare(frame):
+        calls.append(len(frame))
+        return {k: frame[k].to_numpy() for k in frame.columns}
+
+    warnings.simplefilter("ignore")
+    session = SessionWrapper(model=session_model, data=one, parameters=parameters(), prepare=prepare)
+    session.run()
+    session.run()
+    two = data[data.ppt == 2].reset_index(drop=True).iloc[:30]
+    session.reset(data=two)
+    session.run()
+    assert calls == [len(one), 30]
+    assert session.dependent.shape == (30, 1)
+    assert len(session.export()) == 30
+
+
+def test_dict_data_and_scalar_outputs():
+    warnings.simplefilter("ignore")
+
+    def model(parameters, data):
+        return {"constant": 1.5, "dependent": data["x"] * parameters.a.value}
+
+    session = SessionWrapper(
+        model=model,
+        data={"ppt": 7, "x": np.arange(4.0), "observed": np.zeros(4)},
+        parameters=Parameters(a=Value(value=2.0, lower=0, upper=5, prior="uniform")),
+    )
+    session.run()
+    table = session.export()
+    assert list(table.columns) == ["constant", "dependent", "ppt"]
+    np.testing.assert_array_equal(table.constant, 1.5)
+    np.testing.assert_array_equal(table.dependent, [0, 2, 4, 6])
+
+
+def test_wrong_number_of_rows_is_an_error(one):
+    warnings.simplefilter("ignore")
+    session = SessionWrapper(
+        model=lambda parameters, data: {"dependent": np.zeros(3)},
+        data=one,
+        parameters=parameters(),
+    )
+    with pytest.raises(ValueError, match="rows"):
+        session.run()
+
+
+def test_simulation_holds_the_trials_as_for_a_wrapper(one):
+    trial, session = both(one)
+    trial.run()
+    session.run()
+    assert isinstance(session.simulation, list) and len(session.simulation) == len(one)
+    for got, expected in zip(session.simulation, trial.simulation):
+        assert got.keys() == expected.keys()
+        for key in expected:
+            np.testing.assert_allclose(got[key], expected[key], rtol=0, atol=1e-12)
+
+
+def test_reset_without_parameters_reads_data_changed_in_place(one):
+    flipped = one.assign(reward=1.0 - one.reward)
+    expected, _ = both(flipped)
+    expected.run()
+    _, session = both(one)
+    session.run()
+    session.data["reward"] = flipped.reward
+    session.reset()
+    session.run()
+    np.testing.assert_allclose(session.dependent, expected.dependent, rtol=0, atol=1e-12)
+
+
+def test_a_model_without_a_dependent_variable_can_be_reset():
+    warnings.simplefilter("ignore")
+    session = SessionWrapper(
+        model=lambda parameters, data: {"x": data["x"] * 2},
+        data={"x": np.arange(3.0)},
+        parameters=Parameters(a=Value(value=2.0, lower=0, upper=5, prior="uniform")),
+    )
+    session.run()
+    session.reset()
+    session.run()
+    np.testing.assert_array_equal(session.export().x, [0, 2, 4])
+
+
+def test_the_model_cannot_change_the_data_it_was_given():
+    warnings.simplefilter("ignore")
+
+    def meddling(parameters, data):
+        data["x"][0] = 99.0
+        return {"dependent": data["x"]}
+
+    x = np.arange(3.0)
+    session = SessionWrapper(model=meddling, data={"x": x, "observed": np.zeros(3)},
+                             parameters=Parameters(a=Value(value=2.0)))
+    session.run()
+    np.testing.assert_array_equal(x, [0, 1, 2])
+
+
+@pytest.mark.parametrize("optimiser", [FminBound, Minimize])
+def test_fits_reach_the_same_optima(data, optimiser):
+    warnings.simplefilter("ignore")
+    fits = []
+    for wrapper in both(data[data.ppt == 1].reset_index(drop=True)):
+        fit = optimiser(
+            model=wrapper,
+            data=data,
+            minimisation=minimise.LogLikelihood.bernoulli,
+            prior=True,
+            ppt_identifier="ppt",
+            initial_guess=[[0.4, 3.0]],
+            number_of_starts=1,
+            **({"approx_grad": True} if optimiser is FminBound else {}),
+        )
+        fit.optimise()
+        fits.append(fit.export())
+    trial, session = fits
+    for column in ("x_0", "x_1", "fun", "log_likelihood", "log_prior"):
+        np.testing.assert_allclose(session[column], trial[column], rtol=1e-6, atol=1e-8)
+
+
+def test_bads_fit_reaches_the_same_optimum(data):
+    bads = pytest.importorskip("cpm.optimisation").Bads
+    warnings.simplefilter("ignore")
+    fits = []
+    for wrapper in both(data[data.ppt == 1].reset_index(drop=True)):
+        fit = bads(
+            model=wrapper,
+            data=data[data.ppt == 1],
+            minimisation=minimise.LogLikelihood.bernoulli,
+            prior=True,
+            ppt_identifier="ppt",
+            initial_guess=[[0.4, 3.0]],
+            display=False,
+            options={"display": "off", "max_fun_evals": 60, "random_seed": 1},
+        )
+        fit.optimise()
+        fits.append(fit.export())
+    trial, session = fits
+    np.testing.assert_allclose(session["fun"], trial["fun"], rtol=1e-6)
+
+
+def test_simulator_exports_have_the_same_shape(data):
+    warnings.simplefilter("ignore")
+    grouped = data.groupby("ppt")
+    draws = pd.DataFrame({"alpha": [0.2, 0.5, 0.8], "beta": [1.0, 3.0, 6.0]})
+    out = []
+    for wrapper in both(data[data.ppt == 1].reset_index(drop=True)):
+        simulator = Simulator(wrapper=wrapper, data=grouped, parameters=draws)
+        simulator.run()
+        out.append(simulator.export())
+    trial, session = out
+    assert list(session.columns) == list(trial.columns)
+    assert session.shape == trial.shape
+    pd.testing.assert_frame_equal(session, trial, check_exact=False, rtol=0, atol=1e-12)
+
+
+def test_empirical_bayes_runs_on_a_session_wrapper(data):
+    warnings.simplefilter("ignore")
+    results = []
+    for wrapper in both(data[data.ppt == 1].reset_index(drop=True)):
+        fit = FminBound(
+            model=wrapper,
+            data=data,
+            minimisation=minimise.LogLikelihood.bernoulli,
+            prior=True,
+            ppt_identifier="ppt",
+            initial_guess=[[0.4, 3.0]],
+            number_of_starts=1,
+            maxiter=30,
+            approx_grad=True,
+        )
+        eb = EmpiricalBayes(optimiser=fit, iteration=2, tolerance=1e-6, chain=1, quiet=True)
+        np.random.seed(11)  # EmpiricalBayes draws new starting points on every iteration
+        eb.optimise()
+        results.append(eb.hyperparameters)
+    trial, session = results
+    np.testing.assert_allclose(
+        session.select_dtypes("number").to_numpy(),
+        trial.select_dtypes("number").to_numpy(),
+        rtol=1e-6, atol=1e-8,
+    )
diff --git a/test/generators/test_speed_up_how_to.py b/test/generators/test_speed_up_how_to.py
new file mode 100644
index 0000000..986b42a
--- /dev/null
+++ b/test/generators/test_speed_up_how_to.py
@@ -0,0 +1,84 @@
+"""
+The example of docs/how-to/speed-up-your-model.md: the model of Tutorial 1, written
+for all trials at once in a SessionWrapper, gives the same results as trial by trial.
+
+The code blocks of the page are run as they are, from a file (numba can only cache
+functions defined in a file), so that the page and this test cannot drift apart.
+"""
+
+import importlib.util
+import pathlib
+import re
+import warnings
+from functools import partial
+
+import numpy as np
+import pandas as pd
+import pytest
+
+from cpm.core.optimisers import objective
+from cpm.generators import SessionWrapper, Simulator, Wrapper
+from cpm.optimisation import minimise
+
+PAGE = pathlib.Path(__file__).parents[2] / "docs" / "how-to" / "speed-up-your-model.md"
+HAVE_NUMBA = importlib.util.find_spec("numba") is not None
+
+pytestmark = pytest.mark.skipif(not PAGE.exists(), reason="the documentation is not available")
+
+
+@pytest.fixture(scope="module")
+def page(tmp_path_factory):
+    blocks = re.findall(r"```python\n(.*?)```", PAGE.read_text(encoding="utf-8"), flags=re.S)
+    if not HAVE_NUMBA:
+        blocks = [block for block in blocks if "njit" not in block]
+    path = tmp_path_factory.mktemp("how_to") / "speed_up_your_model.py"
+    path.write_text("\n".join(blocks), encoding="utf-8")
+    spec = importlib.util.spec_from_file_location("speed_up_your_model", path)
+    module = importlib.util.module_from_spec(spec)
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore")
+        spec.loader.exec_module(module)
+    return module
+
+
+def test_the_check_on_the_page_passes(page):
+    ## the check of the page, with exact equality instead of np.allclose
+    for alpha, temperature in [(0.1, 1.0), (0.5, 5.0), (0.9, 9.0)]:
+        for wrapper in (page.per_trial, page.all_trials):
+            wrapper.reset(parameters={"alpha": alpha, "temperature": temperature})
+            wrapper.run()
+        np.testing.assert_array_equal(page.all_trials.dependent, page.per_trial.dependent)
+
+
+def test_the_objective_and_export_are_the_same(page):
+    observed = page.one.observed.to_numpy()
+    loss = minimise.LogLikelihood.bernoulli
+    rng = np.random.default_rng(1)
+    points = [[rng.uniform(1e-10, 1), rng.uniform(0, 10)] for _ in range(20)]
+    versions = [page.all_trials] + ([page.compiled] if HAVE_NUMBA else [])
+    expected = [objective(x, page.per_trial, observed, loss, True) for x in points]
+    for wrapper in versions:
+        assert [objective(x, wrapper, observed, loss, True) for x in points] == pytest.approx(
+            expected, rel=1e-12, abs=1e-12
+        )
+    for wrapper in (page.per_trial, page.all_trials):
+        wrapper.reset()
+        wrapper.run()
+    pd.testing.assert_frame_equal(page.all_trials.export(), page.per_trial.export(), check_exact=False, rtol=0, atol=1e-12)
+
+
+def test_simulations_make_the_same_choices(page):
+    warnings.simplefilter("ignore")
+    data = page.experiment[page.experiment.ppt <= 2].groupby("ppt")
+    draws = pd.DataFrame({"alpha": [0.2, 0.6], "temperature": [2.0, 5.0]})
+    exports = []
+    for function, wrapper in ((page.model, Wrapper), (page.session_model, SessionWrapper)):
+        np.random.seed(5)
+        simulator = Simulator(
+            wrapper=wrapper(model=partial(function, generate=True), parameters=page.parameters, data=page.one),
+            parameters=draws,
+            data=data,
+        )
+        simulator.run()
+        exports.append(simulator.export())
+    pd.testing.assert_frame_equal(exports[1], exports[0], check_exact=False, rtol=0, atol=1e-12)
diff --git a/test/generators/test_wrapper.py b/test/generators/test_wrapper.py
index 623f49c..43f2d41 100644
--- a/test/generators/test_wrapper.py
+++ b/test/generators/test_wrapper.py
@@ -106,5 +106,60 @@ def test_run_warning_without_observed():
         wrapper = Wrapper(model=dummy_model, data=df, parameters=parameters)
         wrapper.connector(loss=dummy_loss)
 
+
+## ---------------------------------------------------------------------------
+## the rows Wrapper.run hands to the model (cpm.core.data.trial_reader)
+
+from cpm.core.data import trial_reader, unpack_trials
+
+
+@pytest.mark.parametrize(
+    "frame",
+    [
+        pd.DataFrame({"a": [0.5, 1.5], "b": [2.0, 3.0]}),
+        pd.DataFrame({"a": [1, 2], "b": [0.5, 1.5]}, index=[10, 20]),
+        pd.DataFrame({"a": [1, 2], "b": [3, 4]}),
+        pd.DataFrame({"a": [True, False], "b": [3, 4]}),
+        pd.DataFrame({"a": np.array([1, 2], dtype=np.uint8), "b": [3, 4]}),
+        pd.DataFrame({"a": [1.0, 2.0]}),
+        pd.DataFrame({"a": [1, 2], "label": ["x", "y"]}),
+        pd.DataFrame({"a": pd.array([1, None], dtype="Int64"), "b": [1.0, 2.0]}),
+    ],
+    ids=["float", "int+float", "int", "bool+int", "uint8", "one column", "strings", "nullable"],
+)
+def test_trial_reader_gives_the_rows_iloc_gives(frame):
+    read = trial_reader(frame, pandas=True)
+    for i in range(len(frame)):
+        expected, got = unpack_trials(frame, i, True), read(i)
+        if isinstance(expected, pd.Series):
+            pd.testing.assert_series_equal(got, expected, check_exact=True)
+            ## object Series compare equal whether they hold Python or numpy scalars
+            assert [type(v) for v in got] == [type(v) for v in expected]
+        else:
+            assert type(got) is type(expected) and got == expected
+
+
+def test_trials_changed_by_a_model_do_not_change_the_data():
+    data = pd.DataFrame({"stimulus": [1.0, 2.0, 3.0], "observed": [0.0, 0.0, 0.0]})
+
+    def meddling(parameters, trial):
+        trial["stimulus"] = 100.0
+        return {"dependent": np.array([trial["stimulus"]])}
+
+    wrapper = Wrapper(model=meddling, data=data, parameters=Parameters(alpha=0.1))
+    wrapper.run()
+    assert data.stimulus.tolist() == [1.0, 2.0, 3.0]
+
+
+def test_runs_read_the_data_afresh():
+    data = pd.DataFrame({"stimulus": [1.0, 2.0, 3.0], "observed": [0.0, 0.0, 0.0]})
+    wrapper = Wrapper(model=dummy_model, data=data, parameters=Parameters(alpha=Value(1.0)))
+    wrapper.run()
+    wrapper.data["stimulus"] = [4.0, 5.0, 6.0]
+    wrapper.reset()
+    wrapper.run()
+    np.testing.assert_array_equal(wrapper.dependent.ravel(), [4.0, 5.0, 6.0])
+
+
 if __name__ == "__main__":
     pytest.main()
diff --git a/test/hierarchical/test_chains.py b/test/hierarchical/test_chains.py
new file mode 100644
index 0000000..984a693
--- /dev/null
+++ b/test/hierarchical/test_chains.py
@@ -0,0 +1,68 @@
+import numpy as np
+from scipy.stats import norm
+
+from cpm.generators import Parameters, Value
+from cpm.hierarchical._chains import starting_priors
+
+SIGNED = (np.array([0.0, -5.0]), np.array([1.0, 5.0]))
+
+
+def draw(names, bounds, priors, seed=2026):
+    np.random.seed(seed)
+    return starting_priors(names, bounds, priors)
+
+
+class TestStartingPriors:
+    def test_seed_reproduces_the_draws(self):
+        assert draw(["a", "b"], SIGNED, {}) == draw(["a", "b"], SIGNED, {})
+
+    def test_draws_come_from_the_global_generator(self):
+        np.random.seed(2026)
+        first = starting_priors(["a", "b"], SIGNED, {})
+        second = starting_priors(["a", "b"], SIGNED, {})
+        assert first != second
+        assert draw(["a", "b"], SIGNED, {}) == first
+
+    def test_means_cover_signed_bounds(self):
+        bounds = (np.array([-0.49]), np.array([0.49]))
+        np.random.seed(0)
+        draws = [starting_priors(["eta"], bounds, {})["eta"] for _ in range(2000)]
+        means = np.array([d["mean"] for d in draws])
+        sds = np.array([d["sd"] for d in draws])
+        assert np.all((means >= -0.49) & (means <= 0.49))
+        assert means.min() < -0.4 and means.max() > 0.4, "both halves of the range are explored"
+        assert np.all((sds > 0) & (sds <= 0.49))
+
+    def test_bounds_from_zero_keep_the_previous_draws(self):
+        np.random.seed(3)
+        updates = starting_priors(["x"], (np.array([0.0]), np.array([10.0])), {})
+        np.random.seed(3)
+        mean = np.random.beta(a=2, b=2) * 10.0
+        sd = np.random.beta(a=2, b=2) * (10.0 / 2)
+        assert updates["x"] == {"mean": mean, "sd": sd}
+
+    def test_infinite_bounds_draw_from_the_starting_prior(self):
+        prior = norm(loc=1.5, scale=2.0)
+        updates = draw(["x"], (np.array([-np.inf]), np.array([np.inf])), {"x": prior}, seed=4)
+        np.random.seed(4)
+        assert updates["x"] == {"mean": prior.rvs(), "sd": 2.0}
+
+    def test_half_infinite_bounds_stay_within_the_finite_bound(self):
+        parameters = Parameters(
+            x=Value(value=1.0, lower=0, upper=np.inf, prior="truncated_normal", args={"mean": 1.0, "sd": 2.0})
+        )
+        priors = {"x": parameters.x.prior}
+        np.random.seed(5)
+        draws = [starting_priors(["x"], parameters.bounds(), priors)["x"] for _ in range(500)]
+        assert all(d["mean"] >= 0 and np.isfinite(d["mean"]) for d in draws)
+        assert all(0 < d["sd"] < np.inf for d in draws)
+
+    def test_update_prior_accepts_the_draws(self):
+        parameters = Parameters(
+            eta=Value(value=0.0, lower=-0.49, upper=0.49, prior="truncated_normal", args={"mean": 0.0, "sd": 0.2}),
+            x=Value(value=0.0, lower=-np.inf, upper=np.inf, prior="norm", args={"mean": 0.0, "sd": 1.0}),
+        )
+        names = parameters.free()
+        priors = {name: getattr(parameters, name).prior for name in names}
+        parameters.update_prior(**draw(names, parameters.bounds(), priors))
+        assert np.isfinite(parameters.PDF(log=True))
diff --git a/test/hierarchical/test_empirical.py b/test/hierarchical/test_empirical.py
index 0a0fe08..9719f72 100644
--- a/test/hierarchical/test_empirical.py
+++ b/test/hierarchical/test_empirical.py
@@ -119,6 +119,16 @@ def test_multiple_chains_produce_independent_results(self, optimiser):
         # each chain (after the first) starts from a different random prior
         assert set(multi.fit.chain.unique()) == {0, 1}
 
+    def test_seed_reproduces_every_chain(self, optimiser):
+        warnings.simplefilter("ignore")
+        runs = []
+        for _ in range(2):
+            np.random.seed(2026)
+            multi = EmpiricalBayes(optimiser=optimiser, iteration=2, chain=2, quiet=True)
+            multi.optimise()
+            runs.append(multi.hyperparameters)
+        pd.testing.assert_frame_equal(runs[0], runs[1])
+
     def test_parameters_method_returns_fit_history(self, eb):
         warnings.simplefilter("ignore")
         eb.optimise()
diff --git a/test/hierarchical/test_variational.py b/test/hierarchical/test_variational.py
index 47ebc8b..c5ee5f1 100644
--- a/test/hierarchical/test_variational.py
+++ b/test/hierarchical/test_variational.py
@@ -185,6 +185,16 @@ def test_multiple_chains_produce_independent_results(self, optimiser):
         assert set(multi.hyperparameters.chain.unique()) == {1, 2}
         assert set(multi.fit.chain.unique()) == {1, 2}
 
+    def test_seed_reproduces_every_chain(self, optimiser):
+        warnings.simplefilter("ignore")
+        runs = []
+        for _ in range(2):
+            np.random.seed(2026)
+            multi = VariationalBayes(optimiser=optimiser, iteration=2, chain=2, quiet=True)
+            multi.optimise()
+            runs.append(multi.hyperparameters)
+        pd.testing.assert_frame_equal(runs[0], runs[1])
+
 
 class TestTtest:
     def test_dict_null_matches_dataframe_null(self, vb):
diff --git a/test/models/test_activation.py b/test/models/test_activation.py
index a8fd34d..0f5f77f 100644
--- a/test/models/test_activation.py
+++ b/test/models/test_activation.py
@@ -69,5 +69,25 @@ def test_compute(self):
         )
 
 
+@pytest.mark.parametrize("weighting", ["tk", "power", "prelec", "gw"])
+def test_prospect_utility_on_several_outcomes_per_option(weighting):
+    """Options with several outcomes, as 2D arrays; `prelec` used to fail on them."""
+    from cpm.models import kernels
+
+    rng = np.random.default_rng(1)
+    magnitudes = rng.normal(0, 1, (3, 4))
+    probabilities = rng.uniform(0.01, 1, (3, 4))
+    model = ProspectUtility(magnitudes=magnitudes, probabilities=probabilities, alpha=0.8, beta=0.9,
+                            lambda_loss=1.7, gamma=0.6, delta=0.8, weighting=weighting)
+    got = model.compute()
+    code = kernels.WEIGHTING[weighting]
+    expected = [
+        sum(kernels.prospect_weight(p, m, 0.6, 0.8, code) * kernels.prospect_utility(m, 0.8, 0.9, 1.7)
+            for m, p in zip(magnitudes[j], probabilities[j]))
+        for j in range(3)
+    ]
+    np.testing.assert_allclose(got, expected, rtol=1e-12)
+
+
 if __name__ == "__main__":
     pytest.main()
diff --git a/test/models/test_decision.py b/test/models/test_decision.py
index 0904276..fe3e720 100644
--- a/test/models/test_decision.py
+++ b/test/models/test_decision.py
@@ -142,5 +142,31 @@ def test_choice_kernel_choice():
     ], "The ChoiceKernel.choice output is not in the expected range."
 
 
+def test_softmax_does_not_overflow():
+    import warnings
+
+    with warnings.catch_warnings():
+        warnings.simplefilter("error")  # no overflow warning, and no NaN replacement
+        big = Softmax(temperature=2.0, activations=np.array([1000.0, 999.0])).compute()
+        tiny = Softmax(temperature=5.0, activations=np.array([-1000.0, -1001.0, -1000.0])).compute()
+    np.testing.assert_allclose(big, [1 / (1 + np.exp(-2.0)), 1 / (1 + np.exp(2.0))])
+    np.testing.assert_allclose(tiny, np.exp([0.0, -5.0, 0.0]) / np.exp([0.0, -5.0, 0.0]).sum())
+
+
+def test_softmax_is_unchanged_where_it_does_not_overflow():
+    rng = np.random.default_rng(0)
+    for _ in range(100):
+        activations, beta = rng.normal(0, 3, 4), rng.uniform(0, 10)
+        expected = np.exp(activations * beta) / np.sum(np.exp(activations * beta))
+        np.testing.assert_array_equal(Softmax(temperature=beta, activations=activations).compute(), expected)
+
+
+def test_softmax_replaces_a_nan_policy_as_before():
+    """0 * inf is NaN, so the whole policy is NaN, which is replaced by a uniform one."""
+    with pytest.warns(UserWarning, match="NaN values found in policies"):
+        policy = Softmax(temperature=np.inf, activations=np.array([0.0, 1.0])).compute()
+    np.testing.assert_array_equal(policy, [0.5, 0.5])
+
+
 if __name__ == "__main__":
     pytest.main()
diff --git a/test/models/test_kernels.py b/test/models/test_kernels.py
new file mode 100644
index 0000000..7d66274
--- /dev/null
+++ b/test/models/test_kernels.py
@@ -0,0 +1,216 @@
+"""
+Every kernel in cpm.models.kernels gives the same result as the class it is
+named after, compiled with numba and as plain Python.
+"""
+
+import warnings
+
+import numpy as np
+import pytest
+
+from cpm.core import _jit
+from cpm.models import activation, attention, decision, learning
+
+RNG = np.random.default_rng(2024)
+TOLERANCE = dict(rtol=1e-12, atol=1e-13)
+
+
+@pytest.fixture(params=["numba", "python"], scope="module")
+def k(request):
+    if request.param == "numba" and not _jit.JIT_ENABLED:
+        pytest.skip("numba is not installed or disabled")
+    return _jit.kernels("cpm.models.kernels", python=request.param == "python")
+
+
+def draws(n=25):
+    return range(n)
+
+
+def test_the_python_build_is_not_compiled():
+    python = _jit.kernels("cpm.models.kernels", python=True)
+    assert not hasattr(python.softmax, "py_func")
+    if _jit.JIT_ENABLED:
+        assert hasattr(_jit.kernels("cpm.models.kernels").softmax, "py_func")
+
+
+def test_softmax(k):
+    for _ in draws():
+        values = RNG.normal(0, 2, RNG.integers(2, 6))
+        beta = RNG.uniform(0, 5)
+        expected = decision.Softmax(temperature=beta, activations=values).compute()
+        np.testing.assert_allclose(k.softmax(values, beta), expected, **TOLERANCE)
+        np.testing.assert_allclose(k.log_softmax(values, beta), np.log(expected), **TOLERANCE)
+        if len(values) == 2:
+            assert k.p_second(beta, values[0], values[1]) == pytest.approx(expected[1], rel=1e-12)
+
+
+def test_softmax_does_not_overflow(k):
+    policy = k.softmax(np.array([1000.0, 999.0]), 2.0)
+    assert np.all(np.isfinite(policy))
+    assert policy[0] == pytest.approx(1 / (1 + np.exp(-2.0)))
+    assert k.p_second(1000.0, 0.0, 1.0) == 1.0
+    assert k.p_second(1000.0, 1.0, 0.0) == 0.0
+
+
+def test_softmax_noise(k):
+    for _ in draws():
+        values = RNG.normal(0, 2, 3)
+        beta, xi = RNG.uniform(0, 5), RNG.uniform(0, 1)
+        expected = decision.Softmax(temperature=beta, xi=xi, activations=values).irreducible_noise()
+        np.testing.assert_allclose(k.softmax_noise(values, beta, xi), expected, **TOLERANCE)
+
+
+def test_sigmoid(k):
+    for _ in draws():
+        activations = RNG.normal(0, 1, 3)
+        temperature, bias = RNG.uniform(0, 5), RNG.normal()
+        expected = decision.Sigmoid(temperature=temperature, activations=activations, beta=bias).compute()
+        np.testing.assert_allclose(k.sigmoid(activations, temperature, bias), expected, **TOLERANCE)
+
+
+def test_greedy(k):
+    for _ in draws():
+        activations = RNG.normal(0.5, 1, (4, 3))
+        epsilon = RNG.uniform(0, 0.3)
+        expected = decision.GreedyRule(activations=activations, epsilon=epsilon).compute()
+        np.testing.assert_allclose(k.greedy(activations, epsilon), expected, **TOLERANCE)
+    ## all non-positive: uniform
+    np.testing.assert_allclose(k.greedy(-np.ones((3, 2)), 0.1), np.full(3, 1 / 3))
+
+
+def test_choice_kernel(k):
+    for _ in draws():
+        activations = RNG.normal(0, 1, (3, 2))
+        kernel = RNG.uniform(0, 1, 3)
+        ta, tk = RNG.uniform(0, 2, 2)
+        expected = decision.ChoiceKernel(temperature_activations=ta, temperature_kernel=tk,
+                                         activations=activations, kernel=kernel).compute()
+        np.testing.assert_allclose(k.choice_kernel(activations, kernel, ta, tk), expected, **TOLERANCE)
+
+
+def test_choose_reproduces_numpy_random_choice(k):
+    for n in (2, 3, 5):
+        for _ in draws(200):
+            policy = RNG.dirichlet(np.ones(n))
+            np.random.seed(int(RNG.integers(1 << 31)))
+            state = np.random.get_state()
+            expected = np.random.choice(n, p=policy)
+            np.random.set_state(state)
+            assert k.choose(policy, np.random.random_sample()) == expected
+    ## also with the option list and two-element probabilities PTSM2025 draws from
+    for _ in draws(200):
+        p = RNG.uniform()
+        np.random.seed(int(RNG.integers(1 << 31)))
+        state = np.random.get_state()
+        expected = np.random.choice([0, 1], p=[1 - p, p])
+        np.random.set_state(state)
+        assert k.choose(np.array([1 - p, p]), np.random.random_sample()) == expected
+
+
+def test_delta_and_separable_rules(k):
+    for _ in draws():
+        weights = RNG.normal(0, 1, (2, 4))
+        feedback = RNG.normal(0, 1, 2)
+        stimulus = RNG.integers(0, 2, 4).astype(float)
+        alpha = RNG.uniform()
+        rule = learning.DeltaRule(alpha=alpha, weights=weights, feedback=feedback, input=stimulus)
+        expected = rule.compute()
+        change, error = k.delta_rule(weights, feedback, stimulus, alpha)
+        np.testing.assert_allclose(change, expected, **TOLERANCE)
+        np.testing.assert_allclose(error, rule.error, **TOLERANCE)
+
+        rule = learning.SeparableRule(alpha=alpha, weights=weights, feedback=feedback, input=stimulus)
+        expected = rule.compute()
+        change, error = k.separable_rule(weights, feedback, stimulus, alpha)
+        np.testing.assert_allclose(change, expected, **TOLERANCE)
+        np.testing.assert_allclose(error, rule.error, **TOLERANCE)
+
+
+def test_q_learning(k):
+    for _ in draws():
+        values = RNG.normal(0.3, 1, 4)
+        reward, maximum = RNG.normal(), RNG.normal()
+        alpha, gamma = RNG.uniform(size=2)
+        expected = learning.QLearningRule(alpha=alpha, gamma=gamma, values=values,
+                                          reward=reward, maximum=maximum).compute()
+        np.testing.assert_allclose(k.q_learning(values, reward, maximum, alpha, gamma), expected, **TOLERANCE)
+
+
+def test_humble_teacher(k):
+    for _ in draws():
+        weights = RNG.normal(0, 1, (2, 3))
+        feedback = RNG.integers(0, 2, 2)
+        stimulus = RNG.integers(0, 2, 3).astype(float)
+        alpha = RNG.uniform()
+        expected = learning.HumbleTeacher(alpha=alpha, weights=weights, feedback=feedback, input=stimulus).compute()
+        np.testing.assert_allclose(k.humble_teacher(weights, feedback.astype(float), stimulus, alpha),
+                                   expected, **TOLERANCE)
+
+
+def test_sarsa_trace(k):
+    for _ in draws():
+        q_mf, q2 = RNG.uniform(0, 5, (2, 2)), RNG.uniform(0, 5, 2)
+        s1, a, s2 = RNG.integers(0, 2, 3)
+        reward, lr, lam = RNG.uniform(0, 9), RNG.uniform(), RNG.uniform()
+        rule = learning.SARSATrace(learning_rate=lr, eligibility_trace=lam, model_free_values=q_mf,
+                                   second_stage_values=q2, starting_state=s1, action=a,
+                                   reached_second_stage=s2, reward=reward)
+        d_mf, d2 = rule.compute()
+        new_mf, new_2 = q_mf.copy(), q2.copy()
+        pe1, pe2 = k.sarsa_trace_update(new_mf, new_2, s1, a, s2, reward, lr, lam)
+        np.testing.assert_allclose(new_mf, q_mf + d_mf, **TOLERANCE)
+        np.testing.assert_allclose(new_2, q2 + d2, **TOLERANCE)
+        assert pe1 == pytest.approx(rule.stage1_prediction_error, rel=1e-12)
+        assert pe2 == pytest.approx(rule.stage2_prediction_error, rel=1e-12)
+
+
+def test_activations(k):
+    for _ in draws():
+        stimulus = RNG.integers(0, 2, 3).astype(float)
+        stimulus[0] = 1.0
+        weights = RNG.normal(0, 1, (2, 3))
+        expected = activation.SigmoidActivation(input=stimulus, weights=weights).compute()
+        np.testing.assert_allclose(k.sigmoid_activation(stimulus, weights), expected, **TOLERANCE)
+
+        salience, P = RNG.uniform(0.1, 1, 3), RNG.uniform(0.5, 3)
+        expected = activation.CompetitiveGating(input=stimulus, values=weights, salience=salience, P=P).compute()
+        np.testing.assert_allclose(k.competitive_gating(stimulus, weights, salience, P), expected, **TOLERANCE)
+
+        index, shift = int(RNG.integers(0, 3)), RNG.normal()
+        expected = activation.Offset(input=weights[0], offset=shift, index=index).compute()
+        np.testing.assert_allclose(k.offset(weights[0], shift, index), expected, **TOLERANCE)
+
+
+@pytest.mark.parametrize("weighting", ["tk", "power", "prelec", "gw"])
+def test_prospect_utility(k, weighting):
+    warnings.simplefilter("ignore")
+    for _ in draws(50):
+        magnitudes = RNG.normal(0, 1, 3)
+        magnitudes[0] = 0.0 if RNG.uniform() < 0.2 else magnitudes[0]
+        probabilities = RNG.uniform(0, 1, 3)
+        probabilities[1] = 1.0
+        alpha, beta, lam, gamma, delta = RNG.uniform(0.2, 2, 5)
+        expected = activation.ProspectUtility(
+            magnitudes=magnitudes, probabilities=probabilities, alpha=alpha, beta=beta,
+            lambda_loss=lam, gamma=gamma, delta=delta, weighting=weighting,
+        ).compute()
+        got = [
+            k.prospect_weight(p, m, gamma, delta, k.WEIGHTING[weighting])
+            * k.prospect_utility(m, alpha, beta, lam)
+            for m, p in zip(magnitudes, probabilities)
+        ]
+        np.testing.assert_allclose(got, expected, **TOLERANCE)
+
+
+def test_rapid_attention_shift(k):
+    for _ in draws():
+        weights = RNG.normal(0, 1, (2, 3))
+        predictions, error = RNG.normal(0, 1, 2), RNG.normal(0, 1, 2)
+        stimulus, gain = RNG.integers(0, 2, 3).astype(float), RNG.uniform(0.1, 1, 3)
+        pnorm, P, rho = RNG.uniform(0.5, 2), RNG.uniform(1, 3), RNG.uniform(0, 1)
+        expected = attention.RapidAttentionShift(weights=weights, predictions=predictions, input=stimulus,
+                                                 error=error, gain=gain, pnorm=pnorm, P=P, rho=rho).compute()
+        np.testing.assert_allclose(
+            k.rapid_attention_shift(weights, predictions, stimulus, error, gain, pnorm, P, rho),
+            expected, **TOLERANCE,
+        )
diff --git a/test/models/test_learning.py b/test/models/test_learning.py
index e504029..004e6bc 100644
--- a/test/models/test_learning.py
+++ b/test/models/test_learning.py
@@ -141,5 +141,28 @@ def test_sarsa_trace():
     assert np.all(model_free_values == 0), "The input values should not be modified."
 
 
+def test_humble_teacher_with_one_dimensional_weights():
+    """1D weights are promoted to one row, as in the other learning rules; this used to raise."""
+    rule = HumbleTeacher(alpha=0.1, weights=np.array([0.1, 0.2, 0.3]), feedback=[1], input=np.array([1, 1, 0]))
+    expected = HumbleTeacher(alpha=0.1, weights=np.array([[0.1, 0.2, 0.3]]), feedback=[1],
+                             input=np.array([1, 1, 0])).compute()
+    np.testing.assert_array_equal(rule.compute(), expected)
+
+
+@pytest.mark.parametrize("rule", [DeltaRule, SeparableRule, HumbleTeacher])
+def test_too_little_feedback_is_an_error_rather_than_broadcast(rule):
+    weights = np.zeros((2, 3))
+    with pytest.raises(IndexError):
+        rule(alpha=0.1, weights=weights, feedback=np.array([1.0]), input=np.array([1, 0, 1])).compute()
+
+
+@pytest.mark.parametrize("rule", [DeltaRule, SeparableRule])
+def test_learning_rules_keep_the_dtype_of_the_weights(rule):
+    """Integer weights are updated in place with truncation, as element-wise assignment did."""
+    weights = np.array([[1, 2], [3, 4]])
+    out = rule(alpha=0.5, weights=weights, feedback=[1, 0], input=np.array([1, 1])).compute()
+    assert out.dtype == weights.dtype
+
+
 if __name__ == "__main__":
     pytest.main()
diff --git a/test/optimisation/test_minimise.py b/test/optimisation/test_minimise.py
index 39e5f64..d7178b0 100644
--- a/test/optimisation/test_minimise.py
+++ b/test/optimisation/test_minimise.py
@@ -353,5 +353,31 @@ def test_2d_arrays(self):
         result = Discrete.G2(predicted, observed)
         assert isinstance(result, float)
 
+
+def test_bernoulli_and_continuous_equal_scipy():
+    """The losses no longer call scipy.stats, but must give the same values."""
+    from scipy.stats import bernoulli, norm
+
+    rng = np.random.default_rng(5)
+    p = rng.uniform(0, 1, 200)
+    p[:3] = [0.0, 1.0, 1e-12]
+    k = rng.integers(0, 2, 200).astype(float)
+    k[5] = 0.5  # not a Bernoulli outcome: log probability -inf, replaced by -1e100
+    clipped = np.clip(p, 1e-10, 1 - 1e-10)
+    expected = -np.sum(np.nan_to_num(bernoulli.logpmf(k, clipped), neginf=-1e100))
+    assert LogLikelihood.bernoulli(predicted=p.copy(), observed=k) == expected
+    x, y = rng.normal(0, 1, 50), rng.normal(0, 1, 50)
+    assert LogLikelihood.continuous(predicted=x, observed=y) == -np.sum(norm.logpdf(x, y, 1))
+
+
+def test_losses_still_name_nan_and_inf():
+    with pytest.raises(ValueError, match="Predicted values contain NaN"):
+        LogLikelihood.bernoulli(predicted=np.array([0.5, np.nan]), observed=np.array([1, 0]))
+    with pytest.raises(ValueError, match="Observed values contain Inf"):
+        LogLikelihood.bernoulli(predicted=np.array([0.5, 0.5]), observed=np.array([1, np.inf]))
+    with pytest.raises(ValueError, match="Shape mismatch"):
+        LogLikelihood.bernoulli(predicted=np.array([0.5, 0.5]), observed=np.array([1, 0, 1]))
+
+
 if __name__ == "__main__":
     pytest.main()