From 2f0a967517c3ab060db679771f1f8a3da9da48ce Mon Sep 17 00:00:00 2001
From: Lenard Dome <23503601+lenarddome@users.noreply.github.com>
Date: Thu, 24 Sep 2026 17:35:22 +0200
Subject: [PATCH 01/34] perf(generators): share priors between copies, evaluate
 them in closed form

Also fixes cpm.hierarchical discarding its population priors after the first evaluation.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 CHANGELOG.md                        |   5 +
 benchmarks/cases.py                 | 111 ++++++++++++++++++
 benchmarks/results/main.csv         |   6 +
 benchmarks/results/phase0.csv       |   6 +
 benchmarks/run.py                   | 115 +++++++++++++++++++
 cpm/generators/_fast_priors.py      | 147 ++++++++++++++++++++++++
 cpm/generators/parameters.py        |  24 +++-
 cpm/generators/wrapper.py           |  52 ++++++++-
 cpm/hierarchical/empirical.py       |   4 +-
 cpm/hierarchical/variational.py     |   4 +-
 test/generators/test_fast_priors.py | 172 ++++++++++++++++++++++++++++
 11 files changed, 637 insertions(+), 9 deletions(-)
 create mode 100644 benchmarks/cases.py
 create mode 100644 benchmarks/results/main.csv
 create mode 100644 benchmarks/results/phase0.csv
 create mode 100644 benchmarks/run.py
 create mode 100644 cpm/generators/_fast_priors.py
 create mode 100644 test/generators/test_fast_priors.py

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 45679af..9d58e4f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -28,9 +28,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - 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
+- Made each evaluation of the objective function cheaper for every model, by 0.5-1 ms for 2-6 free parameters (about 0.1 ms per free parameter): `cpm.generators.Value` copies now share their prior distribution instead of deep-copying it, `cpm.generators.Wrapper.reset()` restores parameter values and initial states without copying the priors, and `Value.PDF(log=True)` evaluates the uniform, truncated normal, beta, gamma, truncated exponential and normal priors (including frozen scipy distributions of these families passed in by the user) in closed form instead of through scipy. The priors remain frozen scipy distributions, and the log densities equal scipy's to 1e-12. Models that copy their parameters on every trial gain most: `PTSM2025` runs 17 times faster
+- `cpm.generators.Value.update_prior()` now replaces the prior with an updated copy instead of changing it in place, since copies of a `Value` share their prior. Code that changes `value.prior.kwds` directly now changes the prior of every copy of that `Value`
+- Added a benchmark suite under `benchmarks/`, which times each part of the objective function for every built-in application (`python benchmarks/run.py`)
 
 ### Fixed
 
+- Fixed `cpm.hierarchical.EmpiricalBayes` and `cpm.hierarchical.VariationalBayes` fitting every participant with the model's original priors instead of the estimated population-level priors, apart from the first evaluation of the objective function. `Wrapper.reset()` restored the parameters, including their priors, from a copy made when the model was created, so every prior update was discarded after the first run of the model. Hierarchical fits now use the updated priors throughout, which changes their results
+- Fixed the random starting priors of the second and later chains of `cpm.hierarchical.EmpiricalBayes` and `cpm.hierarchical.VariationalBayes` being arrays of length one instead of numbers, which made the log prior an array. It went unnoticed because of the previous issue
 - 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
diff --git a/benchmarks/cases.py b/benchmarks/cases.py
new file mode 100644
index 0000000..0eaf57a
--- /dev/null
+++ b/benchmarks/cases.py
@@ -0,0 +1,111 @@
+"""
+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.
+`backend=None` is the per-trial application (the original classes); the other
+backends are the session versions. Cases whose session version does not exist
+in the installed cpm are skipped, so the same file also benchmarks older
+versions of cpm.
+"""
+
+import warnings
+
+import numpy as np
+import pandas as pd
+
+import cpm
+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, backend):
+    """The per-trial class for backend None, else its session version (or None)."""
+    module = getattr(cpm.applications, module)
+    if backend is None:
+        return getattr(module, name)
+    session = getattr(module, name + "Session", None)
+    if session is None:
+        return None
+    return lambda **kwargs: session(backend=backend, **kwargs)
+
+
+def build(case, backend=None):
+    """
+    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", backend)
+        data = bandit()
+        kwargs = dict(dimensions=4, parameters_settings=[[0.3, 0, 1], [4, 0, 10]])
+    elif case == "HybridMBMF":
+        cls = _application("reinforcement_learning", "HybridMBMF", backend)
+        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, backend)
+        data = risky()
+        kwargs = dict(parameters_settings=PT_SETTINGS)
+    else:
+        raise ValueError(case)
+    if cls is None:
+        return None
+    model = cls(data=data, **kwargs)
+    observed = data["observed"].to_numpy()
+    x = np.array([model.parameters[k].value for k in model.parameters.free()], dtype=float)
+    return model, observed, x
+
+
+CASES = ["RLRW", "HybridMBMF", "PTSM", "PTSM1992", "PTSM2025"]
+BACKENDS = [None, "python", "numba"]
diff --git a/benchmarks/results/main.csv b/benchmarks/results/main.csv
new file mode 100644
index 0000000..2ec3a77
--- /dev/null
+++ b/benchmarks/results/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.6474500130862,0.42120006401091814,0.08180004078894854,7.56499997805804,0.04610000178217888,-26.034401210112605,1.0
+HybridMBMF,trial,200,6,25.437099975533783,0.8433500188402832,0.24389999452978373,23.479699972085655,0.05304999649524689,-151.7819350468299,1.0
+PTSM,trial,40,4,6.54054997721687,0.6358500104397535,0.15730003360658884,5.147499963641167,0.04579999949783087,-36.42346848683204,1.0
+PTSM1992,trial,40,6,7.78515002457425,0.8213000255636871,0.22419996093958616,6.095800083130598,0.04350004019215703,-39.43873213610623,1.0
+PTSM2025,trial,40,5,75.79680002527311,0.6942999898456037,0.19024999346584082,74.84180002938956,0.04529999569058418,-33.01065168146936,1.0
diff --git a/benchmarks/results/phase0.csv b/benchmarks/results/phase0.csv
new file mode 100644
index 0000000..7efdf3c
--- /dev/null
+++ b/benchmarks/results/phase0.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,7.531950017437339,0.004799978341907263,0.003999972250312567,7.398999994620681,0.04650000482797623,-26.034401210112605,1.0
+HybridMBMF,trial,200,6,23.840799927711487,0.01279998105019331,0.007400056347250938,23.64180004224181,0.0543000060133636,-151.7819350468299,1.0
+PTSM,trial,40,4,5.247199966106564,0.0073499977588653564,0.005299923941493034,5.067099933512509,0.04069996066391468,-36.42346848683204,1.0
+PTSM1992,trial,40,6,6.09894999070093,0.010300078429281712,0.007400056347250938,5.823099985718727,0.046749948523938656,-39.438732136106225,1.0
+PTSM2025,trial,40,5,4.435600014403462,0.0071999384090304375,0.005500041879713535,4.139299970120192,0.04824995994567871,-33.01065168146936,1.0
diff --git a/benchmarks/run.py b/benchmarks/run.py
new file mode 100644
index 0000000..6465dbf
--- /dev/null
+++ b/benchmarks/run.py
@@ -0,0 +1,115 @@
+"""
+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 "trial" for the original per-trial
+applications and "python" or "numba" for their session versions.
+"""
+
+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 or "trial",
+                    "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 or 'trial':>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/generators/_fast_priors.py b/cpm/generators/_fast_priors.py
new file mode 100644
index 0000000..f403604
--- /dev/null
+++ b/cpm/generators/_fast_priors.py
@@ -0,0 +1,147 @@
+"""
+Closed-form 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 checking. For the distribution families that `Value` builds
+from a string (and the same families when they are passed in as frozen scipy
+distributions), the log density at a point inside the support is a short
+closed-form kernel plus a constant. This module evaluates that instead.
+
+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 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
+
+__all__ = ["fast_logpdf"]
+
+## attribute under which the evaluator is cached on the frozen distribution
+_CACHE = "_cpm_fast_logpdf"
+
+## kernels of the log density in the standardised variable y = (x - loc) / scale,
+## up to a constant, keyed by scipy distribution name
+_KERNELS = {
+    "norm": lambda y, shapes: -0.5 * y * y,
+    "truncnorm": lambda y, shapes: -0.5 * y * y,
+    "uniform": lambda y, shapes: 0.0,
+    "gamma": lambda y, shapes: (shapes[0] - 1.0) * math.log(y) - y,
+    "beta": lambda y, shapes: (shapes[0] - 1.0) * math.log(y)
+    + (shapes[1] - 1.0) * math.log1p(-y),
+    "truncexpon": lambda y, shapes: -y,
+}
+
+
+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 closed-form log density of one frozen distribution with fixed arguments."""
+
+    __slots__ = ("args", "kwds", "loc", "scale", "shapes", "kernel", "low", "high", "const")
+
+    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 = float(loc), float(scale)
+        self.shapes = tuple(float(s) for s in shapes)
+        self.kernel = _KERNELS[name]
+        self.low, self.high = _support(name, self.shapes)
+        ## the normalising constant, taken from scipy at the median, which lies
+        ## inside the support for all of the families above
+        median = float(prior.median())
+        reference = float(prior.logpdf(median))
+        y = (median - self.loc) / self.scale
+        if not (self.low < y < self.high) or not math.isfinite(reference):
+            raise ValueError("no interior reference point")
+        self.const = reference - self.kernel(y, self.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 __call__(self, x):
+        y = (x - self.loc) / self.scale
+        if self.low < y < self.high:
+            return self.kernel(y, self.shapes) + self.const
+        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 _KERNELS 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
+        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)` to within rounding error, 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(float(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..76feda0 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,
@@ -444,7 +445,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 +492,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 +535,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/wrapper.py b/cpm/generators/wrapper.py
index 31e69da..03ddb42 100644
--- a/cpm/generators/wrapper.py
+++ b/cpm/generators/wrapper.py
@@ -11,6 +11,49 @@
 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)
+    return type(current)(**restored) if type(current) is Parameters else copy.deepcopy(initial)
+
+
 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.
@@ -119,6 +162,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.
@@ -142,7 +190,9 @@ def reset(self, parameters=None, data=None):
         if self.__run__:
             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/empirical.py b/cpm/hierarchical/empirical.py
index 3d8fff5..9eb1937 100644
--- a/cpm/hierarchical/empirical.py
+++ b/cpm/hierarchical/empirical.py
@@ -378,8 +378,8 @@ def optimise(self):
                 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),
+                        "mean": rng.beta(a=2, b=2) * self.__bounds__[1][i],
+                        "sd": rng.beta(a=2, b=2) * (self.__bounds__[1][i] / 2),
                     }
                 self.optimiser.model.parameters.update_prior(**population_updates)
 
diff --git a/cpm/hierarchical/variational.py b/cpm/hierarchical/variational.py
index 9cef234..9678748 100644
--- a/cpm/hierarchical/variational.py
+++ b/cpm/hierarchical/variational.py
@@ -671,8 +671,8 @@ def optimise(self):
                 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),
+                        "mean": rng.beta(a=2, b=2) * self.__bounds__[1][i],
+                        "sd": rng.beta(a=2, b=2) * (self.__bounds__[1][i] / 2),
                     }
                 self.optimiser.model.parameters.update_prior(**population_updates)
 
diff --git a/test/generators/test_fast_priors.py b/test/generators/test_fast_priors.py
new file mode 100644
index 0000000..3688a94
--- /dev/null
+++ b/test/generators/test_fast_priors.py
@@ -0,0 +1,172 @@
+import copy
+import warnings
+
+import numpy as np
+import pandas as pd
+import pytest
+from scipy import stats
+
+from cpm.generators import 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)
+        if np.isfinite(expected):
+            assert got == pytest.approx(expected, rel=1e-12, abs=1e-12)
+        else:
+            assert got == expected
+        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 == pytest.approx(expected, rel=1e-12, abs=1e-12) or 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))
+    )
+
+
+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_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]

From 09db79c41f7082a490efc82e28ca6cb8257b4445 Mon Sep 17 00:00:00 2001
From: Lenard Dome <23503601+lenarddome@users.noreply.github.com>
Date: Thu, 24 Sep 2026 17:40:32 +0200
Subject: [PATCH 02/34] feat(generators): add SessionWrapper, for models that
 run a whole session per call

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 CHANGELOG.md                            |   2 +
 cpm/generators/__init__.py              |   5 +-
 cpm/generators/parameters.py            |   6 +-
 cpm/generators/session.py               | 239 ++++++++++++++++++++++
 test/generators/test_session_wrapper.py | 253 ++++++++++++++++++++++++
 5 files changed, 501 insertions(+), 4 deletions(-)
 create mode 100644 cpm/generators/session.py
 create mode 100644 test/generators/test_session_wrapper.py

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9d58e4f..9484f7f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -21,6 +21,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - 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 `cpm.generators.SessionWrapper`, a `Wrapper` whose model function computes all trials of a participant in one call instead of being called once per trial. It works with the optimisers, `Simulator` and `cpm.hierarchical` unchanged, and its `export()` has the same layout as that of a `Wrapper`
 
 ### Changed
 
@@ -47,6 +48,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - 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 `numpy.asarray(value, dtype=...)` raising `TypeError` for a `cpm.generators.Value`, because `Value.__array__` did not take the `dtype` and `copy` arguments of the NumPy array protocol
 - 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
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/parameters.py b/cpm/generators/parameters.py
index 76feda0..25fa4fe 100644
--- a/cpm/generators/parameters.py
+++ b/cpm/generators/parameters.py
@@ -420,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)
diff --git a/cpm/generators/session.py b/cpm/generators/session.py
new file mode 100644
index 0000000..9df584b
--- /dev/null
+++ b/cpm/generators/session.py
@@ -0,0 +1,239 @@
+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, with the trials along
+        the first axis.
+    """
+    if isinstance(data, pd.DataFrame):
+        return {
+            column: np.ascontiguousarray(data[column].to_numpy())
+            for column in data.columns
+        }
+    if isinstance(data, dict):
+        return {
+            key: np.ascontiguousarray(np.asarray(value))
+            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 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`.
+
+    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 set, and 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`.
+
+    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])
+    """
+
+    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 = self.prepare(data)
+
+    def run(self):
+        """
+        Run the model on all trials.
+
+        Returns
+        -------
+        None
+        """
+        output = self.model(parameters=self.parameters, data=self.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.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.
+
+        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 = {}
+        if data is not None:
+            self.session = self.prepare(data)
+        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.simulation, self.__len__)
diff --git a/test/generators/test_session_wrapper.py b/test/generators/test_session_wrapper.py
new file mode 100644
index 0000000..0a1c107
--- /dev/null
+++ b/test/generators/test_session_wrapper.py
@@ -0,0 +1,253 @@
+"""
+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()
+
+
+@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,
+    )

From 4b051faa51059d6d4a2919a36ecbc1a7560a5900 Mon Sep 17 00:00:00 2001
From: Lenard Dome <23503601+lenarddome@users.noreply.github.com>
Date: Thu, 24 Sep 2026 18:11:18 +0200
Subject: [PATCH 03/34] feat: add numba-compiled session versions of the
 built-in applications

numba is optional; without it, the same code runs as plain Python.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 CHANGELOG.md                               |   4 +
 benchmarks/results/local.csv               |  16 +
 benchmarks/results/phase2.csv              |  16 +
 cpm/applications/_backend.py               |  82 +++
 cpm/applications/_sessions.py              | 261 ++++++++
 cpm/applications/decision_making.py        | 665 +++++++++++++++------
 cpm/applications/reinforcement_learning.py | 374 ++++++++++--
 cpm/core/_jit.py                           | 126 ++++
 cpm/models/kernels.py                      | 497 +++++++++++++++
 docs/api/applications.rst                  |   9 +-
 docs/api/generators.rst                    |   4 +-
 docs/api/models.rst                        |  41 +-
 docs/how-to/fast-session-models.md         | 144 +++++
 docs/how-to/index.md                       |   8 +
 pyproject.toml                             |   6 +
 scripts/local_tests.py                     |  79 +++
 test/applications/test_sessions.py         | 243 ++++++++
 test/models/test_kernels.py                | 216 +++++++
 18 files changed, 2535 insertions(+), 256 deletions(-)
 create mode 100644 benchmarks/results/local.csv
 create mode 100644 benchmarks/results/phase2.csv
 create mode 100644 cpm/applications/_backend.py
 create mode 100644 cpm/applications/_sessions.py
 create mode 100644 cpm/core/_jit.py
 create mode 100644 cpm/models/kernels.py
 create mode 100644 docs/how-to/fast-session-models.md
 create mode 100644 scripts/local_tests.py
 create mode 100644 test/applications/test_sessions.py
 create mode 100644 test/models/test_kernels.py

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9484f7f..733bff6 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -22,6 +22,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - 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 `cpm.generators.SessionWrapper`, a `Wrapper` whose model function computes all trials of a participant in one call instead of being called once per trial. It works with the optimisers, `Simulator` and `cpm.hierarchical` unchanged, and its `export()` has the same layout as that of a `Wrapper`
+- Added session versions of all built-in applications that are models: `RLRWSession` and `HybridMBMFSession` in `cpm.applications.reinforcement_learning`, and `PTSMSession`, `PTSM1992Session` and `PTSM2025Session` in `cpm.applications.decision_making`. Each takes the same arguments as the application it is named after (plus `backend`), has the same parameters and priors, and gives the same results and `export()`, but computes all trials of a participant in one call, compiled with numba where available. One evaluation of the objective function is 50 to 200 times faster than with the per-trial applications (15 to 25 times without numba). Simulations with `generate=True` sample from `numpy.random` exactly as the per-trial applications do, so they make the same choices for a given seed
+- Added `cpm.models.kernels`, function versions of the learning rules, decision rules, activation functions and attention mechanism in `cpm.models` that can be called from loops compiled with numba, each tested against its class. Its softmax, sigmoid and logistic functions cannot overflow, and `choose` samples from a policy as `numpy.random.choice` does, given a uniform random number drawn beforehand
+- Added numba as an optional dependency (`pip install cpm-toolbox[numba]`). Without it, or with `CPM_DISABLE_JIT=1`, the session models run as plain Python and give the same results
+- Added a how-to guide on session models and numba, and `scripts/local_tests.py`, which runs the test suite with numba, without it and with `NUMBA_DISABLE_JIT=1`, and then the benchmark suite
 
 ### Changed
 
diff --git a/benchmarks/results/local.csv b/benchmarks/results/local.csv
new file mode 100644
index 0000000..48be5bd
--- /dev/null
+++ b/benchmarks/results/local.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,7.659750001039356,0.004899920895695686,0.004100031219422817,7.564100029412657,0.045249995309859514,-26.034401210112605,1.0
+RLRW,python,71,2,0.4428999964147806,0.004900037311017513,0.004100031219422817,0.354300020262599,0.04859990440309048,-26.034401210112605,17.29453615498772
+RLRW,numba,71,2,0.08764996891841292,0.004900037311017513,0.004100031219422817,0.011599971912801266,0.044199987314641476,-26.034401210112605,87.39021925004067
+HybridMBMF,trial,200,6,23.857699998188764,0.01279998105019331,0.007600057870149612,24.291999987326562,0.05609996151179075,-151.7819350468299,1.0
+HybridMBMF,python,200,6,1.470250019337982,0.01109996810555458,0.006749993190169334,1.3379499432630837,0.05365000106394291,-151.7819350468299,16.226967988023773
+HybridMBMF,numba,200,6,0.1292000524699688,0.012800039257854223,0.0070999376475811005,0.02729997504502535,0.0540000619366765,-151.7819350468299,184.65704573714657
+PTSM,trial,40,4,5.286899977363646,0.0078000593930482864,0.005799927748739719,5.09605003753677,0.04529999569058418,-36.42346848683204,1.0
+PTSM,python,40,4,0.24894997477531433,0.007999944500625134,0.005800044164061546,0.16289995983242989,0.045900000259280205,-36.423468486832036,21.236796597931974
+PTSM,numba,40,4,0.09355001384392381,0.0074999406933784485,0.005500041879713535,0.011399970389902592,0.04569999873638153,-36.423468486832036,56.51415494373053
+PTSM1992,trial,40,6,6.143599981442094,0.009699957445263863,0.006500049494206905,6.034650024957955,0.04630000330507755,-39.438732136106225,1.0
+PTSM1992,python,40,6,0.29039999935775995,0.009900075383484364,0.007400056347250938,0.19880000036209822,0.04600000102072954,-39.438732136106225,21.15564736580268
+PTSM1992,numba,40,6,0.09820004925131798,0.009699957445263863,0.0068999361246824265,0.016200006939470768,0.04610000178217888,-39.438732136106225,62.56208655984598
+PTSM2025,trial,40,5,4.46989998454228,0.008399947546422482,0.006500049494206905,4.286449984647334,0.04409998655319214,-33.01065168146936,1.0
+PTSM2025,python,40,5,0.1829999964684248,0.00800006091594696,0.005799927748739719,0.08535000961273909,0.04579999949783087,-33.01065168146936,24.425683447013217
+PTSM2025,numba,40,5,0.09099999442696571,0.007899943739175797,0.006100046448409557,0.00879995059221983,0.04579999949783087,-33.01065168146936,49.11978305811556
diff --git a/benchmarks/results/phase2.csv b/benchmarks/results/phase2.csv
new file mode 100644
index 0000000..eb46ef4
--- /dev/null
+++ b/benchmarks/results/phase2.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,7.574449991807342,0.004500034265220165,0.003800028935074806,7.411799975670874,0.04680000711232424,-26.034401210112605,1.0
+RLRW,python,71,2,0.43494999408721924,0.004999921657145023,0.00409991480410099,0.3561500343494117,0.044599990360438824,-26.034401210112605,17.414530623693857
+RLRW,numba,71,2,0.08834997424855828,0.00500003807246685,0.004100031219422817,0.011299969628453255,0.042350031435489655,-26.034401210112605,85.73233955335243
+HybridMBMF,trial,200,6,24.17849999619648,0.012199976481497288,0.007100054062902927,23.846850031986833,0.05439994856715202,-151.7819350468299,1.0
+HybridMBMF,python,200,6,1.4406500267796218,0.012800097465515137,0.0074999406933784485,1.2855499517172575,0.05365000106394291,-151.7819350468299,16.783049003403168
+HybridMBMF,numba,200,6,0.12910005170851946,0.012899981811642647,0.0074999406933784485,0.03170000854879618,0.05440006498247385,-151.7819350468299,187.28497530571408
+PTSM,trial,40,4,5.363749980460852,0.007600057870149612,0.005400041118264198,5.142699985299259,0.04504999378696084,-36.42346848683204,1.0
+PTSM,python,40,4,0.24780002422630787,0.007600057870149612,0.005500041879713535,0.15520001761615276,0.04600000102072954,-36.423468486832036,21.64547803095576
+PTSM,numba,40,4,0.09079999290406704,0.00809994526207447,0.005799927748739719,0.012399978004395962,0.04810001701116562,-36.423468486832036,59.07214096511899
+PTSM1992,trial,40,6,6.236799992620945,0.009600073099136353,0.007400056347250938,5.850800022017211,0.0475000124424696,-39.438732136106225,1.0
+PTSM1992,python,40,6,0.28870004462078214,0.010600080713629723,0.007400056347250938,0.17205002950504422,0.04665000597015023,-39.438732136106225,21.603044782390683
+PTSM1992,numba,40,6,0.0990999978967011,0.010399962775409222,0.007300055585801601,0.016300007700920105,0.04650000482797623,-39.438732136106225,62.934410948444224
+PTSM2025,trial,40,5,4.576249921228737,0.00800006091594696,0.00609993003308773,4.337250022217631,0.047099951189011335,-33.01065168146936,1.0
+PTSM2025,python,40,5,0.18390000332146883,0.00800006091594696,0.006499933078885078,0.09790004696696997,0.0439999857917428,-33.01065168146936,24.88444719182067
+PTSM2025,numba,40,5,0.09159999899566174,0.008599949069321156,0.0065999338403344154,0.009599956683814526,0.04630000330507755,-33.01065168146936,49.959060823193596
diff --git a/cpm/applications/_backend.py b/cpm/applications/_backend.py
new file mode 100644
index 0000000..645762b
--- /dev/null
+++ b/cpm/applications/_backend.py
@@ -0,0 +1,82 @@
+"""
+Shared machinery of the session versions of the built-in applications.
+"""
+
+import numpy as np
+import pandas as pd
+
+from ..core import _jit
+from ..generators.session import session_data
+
+__all__ = ["SessionModel", "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 first needed, rather than stored, so that the model function
+    pickles by reference and can be sent to other processes for parallel fits.
+
+    Parameters
+    ----------
+    backend : str
+        "numba" or "python", as returned by `cpm.core._jit.resolve_backend`.
+    """
+
+    def __init__(self, backend):
+        self.backend = backend
+        self._sessions = None
+
+    @property
+    def sessions(self):
+        if self._sessions is None:
+            self._sessions = _jit.kernels(
+                "cpm.applications._sessions", python=self.backend == "python"
+            )
+        return self._sessions
+
+    def __getstate__(self):
+        state = self.__dict__.copy()
+        state["_sessions"] = None
+        return state
+
+
+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 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..2a7b630
--- /dev/null
+++ b/cpm/applications/_sessions.py
@@ -0,0 +1,261 @@
+"""
+Session loops of the built-in applications.
+
+Each function computes all trials of one participant for one of the session
+applications (`RLRWSession`, `HybridMBMFSession`, `PTSMSession`,
+`PTSM1992Session` and `PTSM2025Session`), from plain floats and numpy arrays.
+They repeat the per-trial models of the applications step by step, using the
+kernels of `cpm.models.kernels`, and are compiled with numba as a whole when
+numba is available. `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
+per-trial 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
+logistic = kernels.logistic
+sarsa_trace_update = kernels.sarsa_trace_update
+prospect_utility = kernels.prospect_utility
+prospect_weight = kernels.prospect_weight
+
+
+@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]
+    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)
+    for t in range(n):
+        for j in range(k):
+            activations[j] = values[arms[t, j] - 1]
+        policy[t] = softmax(activations, temperature)
+        choice = choose(policy[t], uniforms[t]) if generate else response[t]
+        stimulus = arms[t, choice] - 1
+        if stimulus < 0:
+            stimulus += d
+        teacher = rewards[t, choice]
+        reward[t] = teacher
+        for j in range(d):
+            mute = 1.0 if j == stimulus else 0.0
+            change[t, j] = alpha * (teacher - values[j]) * mute
+        for j in range(d):
+            values[j] += change[t, j]
+        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]
+        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
+            )
+        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]
+        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)
+    expected = np.empty(2)
+    for t in range(n):
+        ev_risk = risky[t] * probability[t]
+        best = 1 if ev_risk >= safe[t] else 0
+        if custom_utilities:
+            u_safe, u_risk = utilities[t, 0], utilities[t, 1]
+        else:
+            u_safe = prospect_utility(safe[t], alpha, beta, lambda_loss)
+            u_risk = prospect_utility(risky[t], alpha, beta, lambda_loss)
+        expected[0] = prospect_weight(1.0, safe[t], gamma, delta, weighting) * u_safe
+        expected[1] = prospect_weight(probability[t], risky[t], gamma, delta, weighting) * u_risk
+        policy = softmax(expected, temperature)
+        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):
+    if x >= 0:
+        return x**alpha
+    return -(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)
+    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
+        p = logistic((temperature * u_risk + phi) - temperature * u_safe)
+        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..8ffbed4 100644
--- a/cpm/applications/decision_making.py
+++ b/cpm/applications/decision_making.py
@@ -1,11 +1,213 @@
 import copy
 import numpy as np
 import warnings
-from cpm.generators import Wrapper, Parameters, Value
+from cpm.generators import Wrapper, SessionWrapper, Parameters, Value
+from cpm.core._jit import resolve_backend
+from cpm.applications._backend import SessionModel, prepared, require, uniforms
 from cpm.models.decision import Softmax
 from cpm.models.activation import ProspectUtility
 
 
+def _ptsm_parameters(parameters_settings, utility_curve, weighting):
+    """The parameters of `PTSM` and `PTSMSession`."""
+    # 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` and `PTSM1992Session`."""
+    # 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
+    return x ** alpha if x >= 0 else -np.abs(x) ** alpha
+
+
+def _ptsm2025_parameters(parameters_settings, utility_curve, variant):
+    """The parameters of `PTSM2025` and `PTSM2025Session`."""
+    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
+
+
 class PTSM(Wrapper):
     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.
@@ -127,58 +329,7 @@ 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)
 
         def model_fn(parameters, trial):
             """
@@ -378,73 +529,7 @@ 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)
 
         def model_fn(parameters, trial):
             """
@@ -609,73 +694,8 @@ 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,
-        )
-
-        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
+        parameters = _ptsm2025_parameters(parameters_settings, utility_curve, variant)
 
         # CORRECTED: Renamed back to model_fn
         def model_fn(parameters, trial):
@@ -722,4 +742,275 @@ def model_fn(parameters, trial):
             
             return output
 
-        super().__init__(data=data, model=model_fn, parameters=parameters)
\ No newline at end of file
+        super().__init__(data=data, model=model_fn, parameters=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"] = np.ascontiguousarray(out["observed"], dtype=np.int64)
+        return out
+
+
+RISKY_COLUMNS = ["safe_magnitudes", "risky_magnitudes", "risky_probability"]
+
+
+class _ProspectModel(SessionModel):
+    """The session model function of `PTSMSession` and `PTSM1992Session`."""
+
+    def __init__(self, backend, weighting, generate, choose_always, dependent_chosen, separate):
+        super().__init__(backend)
+        self.weighting = _weighting_code(weighting)
+        self.generate = generate
+        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 PTSMSession(SessionWrapper):
+    r"""
+    The session version of :class:`PTSM`: the same model, computed for all trials of a participant at once.
+
+    It takes the same arguments as :class:`PTSM`, has the same parameters and
+    priors, gives the same results, and has the same output in `export()`, but
+    runs the whole session in one call, compiled with numba if it is available
+    (see :class:`cpm.generators.SessionWrapper`).
+
+    Parameters
+    ----------
+    data : pandas.DataFrame or dict
+        The data, with the columns 'safe_magnitudes', 'risky_magnitudes',
+        'risky_probability' and 'observed'.
+    parameters_settings : dict, optional
+        The initial values and bounds of the parameters, as for :class:`PTSM`.
+    generate : bool
+        If True, choices are sampled from the policy.
+    utility_curve : callable, optional
+        As for :class:`PTSM`, which stores it but does not use it; neither does
+        this class.
+    weighting : str
+        The probability weighting function: "tk" (default), "power", "prelec" or "gw".
+    backend : str
+        "auto" (numba if it is installed, plain Python otherwise), "numba" or "python".
+
+    Notes
+    -----
+    The softmax is computed so that it cannot overflow, which is where it can
+    differ from :class:`PTSM`; everywhere else the two agree to within rounding
+    error. With `generate`, choices are sampled from `numpy.random` as in
+    :class:`PTSM`, so a simulation with a given `numpy.random.seed` makes the same
+    choices with both classes and both backends.
+
+    See Also
+    --------
+    cpm.applications.decision_making.PTSM : the per-trial version, with the model specification.
+    """
+
+    def __init__(self, data=None, parameters_settings=None, generate=False,
+                 utility_curve=None, weighting="tk", backend="auto"):
+        parameters = _ptsm_parameters(parameters_settings, utility_curve, weighting)
+        self.backend = resolve_backend(backend)
+        self.generate = generate
+        super().__init__(
+            model=_ProspectModel(self.backend, weighting, generate, choose_always=False,
+                                 dependent_chosen=True, separate=False),
+            data=data,
+            parameters=parameters,
+            prepare=_PrepareRisky(RISKY_COLUMNS, "PTSMSession"),
+        )
+
+
+class PTSM1992Session(SessionWrapper):
+    r"""
+    The session version of :class:`PTSM1992`: the same model, computed for all trials of a participant at once.
+
+    It takes the same arguments as :class:`PTSM1992`, has the same parameters and
+    priors, gives the same results, and has the same output in `export()`, but
+    runs the whole session in one call, compiled with numba if it is available
+    (see :class:`cpm.generators.SessionWrapper`).
+
+    Parameters
+    ----------
+    data : pandas.DataFrame or dict
+        The data, with the columns 'safe_magnitudes', 'risky_magnitudes',
+        'risky_probability' and 'observed'.
+    parameters_settings : dict, optional
+        The initial values and bounds of the parameters, as for :class:`PTSM1992`.
+    utility_curve : callable, optional
+        A utility curve that replaces the power utility, called as
+        :class:`PTSM1992` calls it. It runs as plain Python on every trial, so a
+        model with a utility curve is slower than one without.
+    weighting : str
+        The probability weighting function: "tk" (default), "power", "prelec" or "gw".
+    backend : str
+        "auto" (numba if it is installed, plain Python otherwise), "numba" or "python".
+
+    Notes
+    -----
+    Like :class:`PTSM1992`, the model samples a choice from its policy on every
+    trial (the `chosen` and `is_optimal` outputs), also when it is fitted, and
+    it does so from `numpy.random` in the same way, so both classes and both
+    backends make the same choices for a given `numpy.random.seed`. The softmax
+    is computed so that it cannot overflow, which is where it can differ from
+    :class:`PTSM1992`; everywhere else the two agree to within rounding error.
+
+    See Also
+    --------
+    cpm.applications.decision_making.PTSM1992 : the per-trial version, with the model specification.
+    """
+
+    def __init__(self, data=None, parameters_settings=None, utility_curve=None,
+                 weighting="tk", backend="auto"):
+        parameters = _ptsm1992_parameters(parameters_settings, utility_curve, weighting)
+        self.backend = resolve_backend(backend)
+        super().__init__(
+            model=_ProspectModel(self.backend, weighting, generate=False, choose_always=True,
+                                 dependent_chosen=False, separate=True),
+            data=data,
+            parameters=parameters,
+            prepare=_PrepareRisky(RISKY_COLUMNS, "PTSM1992Session"),
+        )
+
+
+class _PTSM2025Model(SessionModel):
+    """The session model function of `PTSM2025Session`."""
+
+    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 PTSM2025Session(SessionWrapper):
+    r"""
+    The session version of :class:`PTSM2025`: the same model, computed for all trials of a participant at once.
+
+    It takes the same arguments as :class:`PTSM2025`, has the same parameters and
+    priors, gives the same results, and has the same output in `export()`, but
+    runs the whole session in one call, compiled with numba if it is available
+    (see :class:`cpm.generators.SessionWrapper`).
+
+    Parameters
+    ----------
+    data : pandas.DataFrame or dict
+        The data, with the columns 'safe_magnitudes', 'risky_magnitudes',
+        'risky_probability', 'ambiguity' and 'observed'.
+    parameters_settings : dict, optional
+        The initial values and bounds of the parameters, as for :class:`PTSM2025`.
+    utility_curve : callable, optional
+        As for :class:`PTSM2025`, which checks it but uses the power utility
+        regardless; so does this class.
+    variant : str
+        "alpha" (default) to fit the utility curvature, or "standard" to fix it at 1.
+    backend : str
+        "auto" (numba if it is installed, plain Python otherwise), "numba" or "python".
+
+    Notes
+    -----
+    Like :class:`PTSM2025`, the model samples a choice on every trial
+    (`model_choice`), from `numpy.random` in the same way, so both classes and
+    both backends make the same choices for a given `numpy.random.seed`. The
+    policy is computed as a logistic function, which cannot overflow; where the
+    exponentials of :class:`PTSM2025` overflow, it returns NaN and fails to sample
+    a choice, whereas this class returns the limiting probability. Everywhere
+    else the two agree to within rounding error.
+
+    See Also
+    --------
+    cpm.applications.decision_making.PTSM2025 : the per-trial version, with the model specification.
+    """
+
+    def __init__(self, data=None, parameters_settings=None, utility_curve=None,
+                 variant="alpha", backend="auto"):
+        self.variant = variant
+        parameters = _ptsm2025_parameters(parameters_settings, utility_curve, variant)
+        self.backend = resolve_backend(backend)
+        super().__init__(
+            model=_PTSM2025Model(self.backend),
+            data=data,
+            parameters=parameters,
+            prepare=_PrepareRisky(RISKY_COLUMNS + ["ambiguity"], "PTSM2025Session"),
+        )
diff --git a/cpm/applications/reinforcement_learning.py b/cpm/applications/reinforcement_learning.py
index a6aad4c..20252b9 100644
--- a/cpm/applications/reinforcement_learning.py
+++ b/cpm/applications/reinforcement_learning.py
@@ -1,4 +1,8 @@
-from cpm.generators import Wrapper, Parameters, Value
+from cpm.generators import Wrapper, SessionWrapper, Parameters, Value
+from cpm.core._jit import resolve_backend
+from cpm.applications._backend import (
+    SessionModel, ordered_columns, prepared, require, uniforms,
+)
 
 import cpm
 import numpy
@@ -7,6 +11,82 @@
 import ipyparallel as ipp  ## for parallel computing with ipython (specific for Jupyter Notebook)
 
 
+def _rlrw_parameters(parameters_settings, dimensions):
+    """The parameters of `RLRW` and `RLRWSession`."""
+    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` and `HybridMBMFSession`."""
+    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 RLRW(Wrapper):
     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.
@@ -88,27 +168,7 @@ class RLRW(Wrapper):
     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)
 
         @ipp.require("numpy")
         def model(parameters, trial, generate=generate):
@@ -281,50 +341,7 @@ 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)
         ## deterministic transitions: action 0 -> state 1, action 1 -> state 0
         transitions = numpy.array([[0.0, 1.0], [1.0, 0.0]])
 
@@ -413,3 +430,228 @@ def model(parameters, trial, generate=generate):
             return output
 
         super().__init__(data=data, model=model, parameters=parameters)
+
+
+class _RLRWModel(SessionModel):
+    """The session model function of `RLRWSession`."""
+
+    def __init__(self, backend, generate):
+        super().__init__(backend)
+        self.generate = generate
+
+    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(
+            "RLRWSession 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"] = numpy.ascontiguousarray(
+        numpy.column_stack([out[c] for c in arms]), dtype=numpy.int64
+    )
+    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"] = numpy.ascontiguousarray(response, dtype=numpy.int64)
+    return out
+
+
+class RLRWSession(SessionWrapper):
+    r"""
+    The session version of :class:`RLRW`: the same model, computed for all trials of a participant at once.
+
+    It takes the same arguments as :class:`RLRW`, has the same parameters and
+    priors, gives the same results, and has the same output in `export()`, but
+    runs the whole session in one call, compiled with numba if it is available
+    (see :class:`cpm.generators.SessionWrapper`).
+
+    Parameters
+    ----------
+    data : pandas.DataFrame or dict
+        The data, as for :class:`RLRW`.
+    dimensions : int
+        The number of distinct stimuli present in the data.
+    parameters_settings : list-like
+        The initial values and bounds of the parameters, as for :class:`RLRW`.
+    generate : bool
+        If True, choices are sampled from the policy instead of taken from the data.
+    backend : str
+        "auto" (numba if it is installed, plain Python otherwise), "numba" or "python".
+
+    Notes
+    -----
+    The softmax is computed so that it cannot overflow. Where :class:`RLRW`
+    replaces an overflowed policy (with a warning), the two differ; everywhere
+    else they agree to within rounding error. With `generate`, the choices are
+    sampled from `numpy.random` as in :class:`RLRW`, so a simulation with a given
+    `numpy.random.seed` makes the same choices with both classes and both backends.
+
+    See Also
+    --------
+    cpm.applications.reinforcement_learning.RLRW : the per-trial version, with the model specification.
+
+    Examples
+    --------
+    >>> from cpm.applications.reinforcement_learning import RLRWSession
+    >>> from cpm.datasets import load_bandit_data
+    >>> data = load_bandit_data()
+    >>> model = RLRWSession(data=data[data.ppt == 1], dimensions=4)
+    >>> model.run()
+    >>> model.export().head()
+    """
+
+    def __init__(
+        self, data=None, dimensions=2, parameters_settings=None, generate=False, backend="auto"
+    ):
+        parameters = _rlrw_parameters(parameters_settings, dimensions)
+        self.backend = resolve_backend(backend)
+        self.generate = generate
+        super().__init__(
+            model=_RLRWModel(self.backend, generate),
+            data=data,
+            parameters=parameters,
+            prepare=_prepare_rlrw,
+        )
+
+
+class _HybridModel(SessionModel):
+    """The session model function of `HybridMBMFSession`."""
+
+    def __init__(self, backend, generate):
+        super().__init__(backend)
+        self.generate = generate
+
+    def __call__(self, parameters, data):
+        trials = data["s1"].shape[0]
+        out = self.sessions.hybrid_mbmf(
+            *(float(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 `HybridMBMFSession`, filling in the optional columns once."""
+
+    def __init__(self, generate):
+        self.generate = generate
+
+    def __call__(self, data):
+        out = prepared(data)
+        require(out, ["s1"], "HybridMBMFSession")
+        needed = ["reward_0", "reward_1"] if self.generate else ["action", "s2", "reward"]
+        require(out, needed, "HybridMBMFSession")
+        trials = out["s1"].shape[0]
+        for key in ("s1", "stimuli_first", "action", "s2"):
+            out[key] = numpy.ascontiguousarray(
+                out.get(key, numpy.zeros(trials)), dtype=numpy.int64
+            )
+        for key in ("reward", "reward_0", "reward_1"):
+            out[key] = numpy.ascontiguousarray(
+                out.get(key, numpy.zeros(trials)), dtype=numpy.float64
+            )
+        out["position"] = numpy.ascontiguousarray(
+            out.get("position", out["stimuli_first"] ^ out["action"]), dtype=numpy.int64
+        )
+        return out
+
+
+class HybridMBMFSession(SessionWrapper):
+    r"""
+    The session version of :class:`HybridMBMF`: the same model, computed for all trials of a participant at once.
+
+    It takes the same arguments as :class:`HybridMBMF`, has the same parameters,
+    priors and initial states, gives the same results, and has the same output in
+    `export()`, but runs the whole session in one call, compiled with numba if it
+    is available (see :class:`cpm.generators.SessionWrapper`).
+
+    Parameters
+    ----------
+    data : pandas.DataFrame or dict
+        The data, with the columns described for :class:`HybridMBMF`.
+    parameters_settings : list-like
+        The initial values and bounds of the parameters, as for :class:`HybridMBMF`.
+    q_init : float
+        The initial value of all model-free and second-stage values. Default is 0.5.
+    generate : bool
+        If True, first-stage actions are sampled from the policy, and rewards are
+        taken from `reward_0` and `reward_1`.
+    backend : str
+        "auto" (numba if it is installed, plain Python otherwise), "numba" or "python".
+
+    Notes
+    -----
+    The softmax is computed so that it cannot overflow, which is where it can
+    differ from :class:`HybridMBMF`; everywhere else the two agree to within
+    rounding error. With `generate`, actions are sampled from `numpy.random` as
+    in :class:`HybridMBMF`, so a simulation with a given `numpy.random.seed` makes
+    the same choices with both classes and both backends.
+
+    See Also
+    --------
+    cpm.applications.reinforcement_learning.HybridMBMF : the per-trial version, with the model specification.
+    """
+
+    def __init__(self, data=None, parameters_settings=None, q_init=0.5, generate=False,
+                 backend="auto"):
+        parameters = _hybrid_parameters(parameters_settings, q_init)
+        self.backend = resolve_backend(backend)
+        self.generate = generate
+        super().__init__(
+            model=_HybridModel(self.backend, generate),
+            data=data,
+            parameters=parameters,
+            prepare=_PrepareHybrid(generate),
+        )
diff --git a/cpm/core/_jit.py b/cpm/core/_jit.py
new file mode 100644
index 0000000..600081b
--- /dev/null
+++ b/cpm/core/_jit.py
@@ -0,0 +1,126 @@
+"""
+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, whatever
+is installed. 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. That is what `backend="python"` of
+the session models uses, for example to debug a model or to check the compiled
+version against it.
+
+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``).
+"""
+
+import importlib
+import importlib.util
+import os
+import sys
+
+__all__ = ["HAVE_NUMBA", "JIT_ENABLED", "njit", "kernels", "resolve_backend"]
+
+try:
+    if os.environ.get("CPM_DISABLE_JIT", "0") not in ("", "0"):
+        raise ImportError("compilation disabled with CPM_DISABLE_JIT")
+    import numba as _numba
+
+    HAVE_NUMBA = True
+except ImportError:  # includes numba installs that reject the installed NumPy
+    _numba = None
+    HAVE_NUMBA = False
+
+## numba's own switch turns njit into an identity decorator as well
+JIT_ENABLED = HAVE_NUMBA and os.environ.get("NUMBA_DISABLE_JIT", "0") in ("", "0")
+
+## set in the namespace of a module copy that is loaded without compilation
+PYTHON_FLAG = "__cpm_python__"
+
+
+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 HAVE_NUMBA:
+        return _identity(*args, **kwargs)
+    kwargs.setdefault("cache", True)
+    return _numba.njit(*args, **kwargs)
+
+
+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. Without numba, the module itself is plain Python already and is
+        returned either way.
+
+    Returns
+    -------
+    module
+    """
+    if not python or not JIT_ENABLED:
+        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
+        copy_spec.loader.exec_module(module)
+        _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"``.
+
+    Returns
+    -------
+    str
+        ``"numba"`` or ``"python"``.
+    """
+    if backend == "auto":
+        return "numba" if JIT_ENABLED else "python"
+    if backend == "numba":
+        if not HAVE_NUMBA:
+            raise ImportError(
+                "backend='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), or use backend='python' or 'auto'."
+            )
+        return "numba"
+    if backend == "python":
+        return "python"
+    raise ValueError(f"backend must be 'auto', 'numba' or 'python', not {backend!r}.")
diff --git a/cpm/models/kernels.py b/cpm/models/kernels.py
new file mode 100644
index 0000000..3a55815
--- /dev/null
+++ b/cpm/models/kernels.py
@@ -0,0 +1,497 @@
+r"""
+Function versions of the building blocks in `cpm.models`, for compiled session models.
+
+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. This module
+holds the same computations as functions on numpy arrays and floats, written
+to be called *inside* a loop over trials that is compiled with numba as a
+whole, such as the session models of the built-in applications (see
+:class:`cpm.generators.SessionWrapper`). With numba installed, every function
+here is compiled on first use (and cached on disk); without numba, they are
+plain Python and give the same results.
+
+Each function gives the same result as the class it is named after, to within
+rounding error, and is tested against it. The exceptions are deliberate: the
+softmax, sigmoid and logistic functions here are computed in a way that cannot
+overflow, so where the classes return NaN (or replace it) because an
+exponential overflowed, these return the limiting probabilities.
+
+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",
+    "softmax_noise",
+    "sigmoid",
+    "greedy",
+    "choice_kernel",
+    "choose",
+    "delta_rule",
+    "separable_rule",
+    "q_learning",
+    "humble_teacher",
+    "sarsa_trace_update",
+    "sigmoid_activation",
+    "competitive_gating",
+    "prospect_utility",
+    "weight_tk",
+    "weight_power",
+    "weight_prelec",
+    "weight_gw",
+    "prospect_weight",
+    "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}`.
+
+    As :class:`cpm.models.decision.Softmax` (``Softmax(temperature=beta,
+    activations=values).compute()``), without overflow.
+
+    Parameters
+    ----------
+    values : numpy.ndarray
+        The activations, a 1D array.
+    beta : float
+        The inverse temperature.
+
+    Returns
+    -------
+    numpy.ndarray
+    """
+    n = values.shape[0]
+    scaled = np.empty(n)
+    top = -np.inf
+    for i in range(n):
+        scaled[i] = values[i] * beta
+        if scaled[i] > top:
+            top = scaled[i]
+    total = 0.0
+    for i in range(n):
+        scaled[i] = math.exp(scaled[i] - top)
+        total += scaled[i]
+    for i in range(n):
+        scaled[i] /= total
+    return scaled
+
+
+@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 softmax_noise(values, beta, xi):
+    """The softmax with irreducible noise, as `Softmax.irreducible_noise`."""
+    policy = softmax(values, beta)
+    n = policy.shape[0]
+    for i in range(n):
+        policy[i] = policy[i] * (1.0 - xi) + xi / n
+    return policy
+
+
+@njit
+def sigmoid(activations, temperature, bias):
+    """As :class:`cpm.models.decision.Sigmoid` (``Sigmoid(temperature, activations, beta=bias)``), without overflow."""
+    n = activations.shape[0]
+    out = np.empty(n)
+    for i in range(n):
+        out[i] = logistic((activations[i] - bias) * temperature)
+    return out
+
+
+@njit
+def greedy(activations, epsilon):
+    """
+    As :class:`cpm.models.decision.GreedyRule`.
+
+    Parameters
+    ----------
+    activations : numpy.ndarray
+        A 2D array, one row per action, summed over columns.
+    epsilon : float
+        The exploration parameter.
+    """
+    n = activations.shape[0]
+    summed = np.empty(n)
+    for i in range(n):
+        summed[i] = np.sum(activations[i])
+    top = np.max(summed)
+    policy = np.empty(n)
+    for i in range(n):
+        if summed[i] <= 0:
+            policy[i] = 0.0
+        elif summed[i] == top:
+            policy[i] = 1.0 - (n - 1) * epsilon
+        else:
+            policy[i] = epsilon
+    total = np.sum(policy)
+    if np.all(policy == 0):
+        policy[:] = 1.0 / n
+    else:
+        policy /= total
+    return policy
+
+
+@njit
+def choice_kernel(activations, kernel, temperature_activations, temperature_kernel):
+    """
+    As :class:`cpm.models.decision.ChoiceKernel`.
+
+    Note that `ChoiceKernel` multiplies the summed activations with the scaled
+    kernel inside the exponential; this function does the same.
+    """
+    n = kernel.shape[0]
+    out = np.empty(n)
+    total = 0.0
+    for i in range(n):
+        out[i] = math.exp(
+            np.sum(activations[i] * temperature_activations) * (kernel[i] * temperature_kernel)
+        )
+        total += out[i]
+    for i in range(n):
+        out[i] /= total
+    return out
+
+
+@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):
+    """
+    As :class:`cpm.models.learning.DeltaRule`: the change in the weights and the prediction errors.
+
+    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.
+    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.
+    """
+    rows, columns = weights.shape
+    change = np.empty((rows, columns))
+    error = np.empty(rows)
+    for i in range(rows):
+        activation = np.sum(weights[i] * input)
+        error[i] = feedback[i] - activation
+        for j in range(columns):
+            change[i, j] = alpha * error[i] * input[j]
+    return change, error
+
+
+@njit
+def separable_rule(weights, feedback, input, alpha):
+    """
+    As :class:`cpm.models.learning.SeparableRule`: the change in the weights and the prediction errors.
+
+    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.
+    """
+    rows, columns = weights.shape
+    change = np.empty((rows, columns))
+    error = np.empty((rows, columns))
+    for i in range(rows):
+        for j in range(columns):
+            error[i, j] = feedback[i] - weights[i, j]
+            change[i, j] = alpha * error[i, j] * input[j]
+    return change, error
+
+
+@njit
+def q_learning(values, reward, maximum, alpha, gamma):
+    """
+    As :class:`cpm.models.learning.QLearningRule`: the updated values.
+
+    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.
+    """
+    n = values.shape[0]
+    out = np.empty(n)
+    for i in range(n):
+        active = 1.0 if values[i] > 0 else values[i]
+        out[i] = values[i] + alpha * (reward + gamma * maximum - values[i]) * active
+    return out
+
+
+@njit
+def humble_teacher(weights, feedback, input, alpha):
+    """As :class:`cpm.models.learning.HumbleTeacher`: the updated weights (a new array)."""
+    rows, columns = weights.shape
+    out = weights.copy()
+    for i in range(rows):
+        activation = np.sum(out[i] * input)
+        if feedback[i] == 0:
+            teacher = min(-1.0, activation)
+        else:
+            teacher = max(1.0, activation)
+        for j in range(columns):
+            out[i, j] += alpha * (teacher - activation) * input[j]
+    return out
+
+
+@njit
+def sarsa_trace_update(model_free_values, second_stage_values, starting_state, action,
+                       reached_second_stage, reward, learning_rate, eligibility_trace):
+    """
+    As :class:`cpm.models.learning.SARSATrace`, updating 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 = (second_stage_values[reached_second_stage]
+              - model_free_values[starting_state, action])
+    stage2 = reward - second_stage_values[reached_second_stage]
+    model_free_values[starting_state, action] += (
+        learning_rate * stage1 + eligibility_trace * learning_rate * stage2
+    )
+    second_stage_values[reached_second_stage] += learning_rate * stage2
+    return stage1, stage2
+
+
+## ----------------------------------------------------------------------------
+## activation functions (cpm.models.activation)
+
+
+@njit
+def sigmoid_activation(input, weights):
+    """As :class:`cpm.models.activation.SigmoidActivation` for 2D weights (one row per outcome), without overflow."""
+    rows, columns = weights.shape
+    out = np.empty((rows, columns))
+    for i in range(rows):
+        for j in range(columns):
+            out[i, j] = logistic(input[j] * weights[i, j])
+    return out
+
+
+@njit
+def competitive_gating(input, values, salience, P):
+    """As :class:`cpm.models.activation.CompetitiveGating`: the gated values (a new array)."""
+    gain = (input * salience) ** P
+    gain = gain / np.sum(gain) ** (1.0 / P)
+    rows, columns = values.shape
+    out = np.empty((rows, columns))
+    for i in range(rows):
+        for k in range(columns):
+            out[i, k] = values[i, k] * gain[k]
+    return out
+
+
+@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.
+    """
+    if magnitude >= 0:
+        return magnitude**alpha
+    return -lambda_loss * (-magnitude) ** beta
+
+
+@njit
+def weight_tk(probability, power):
+    """The Tversky & Kahneman (1992) weighting function with curvature `power`."""
+    numerator = probability**power
+    return numerator / (numerator + (1.0 - probability) ** power) ** (1.0 / power)
+
+
+@njit
+def weight_power(probability, gamma):
+    """The power weighting function, p^gamma."""
+    return probability**gamma
+
+
+@njit
+def weight_prelec(probability, gamma, delta):
+    """The Prelec (1998) weighting function."""
+    if probability <= 0:
+        return 0.0
+    return math.exp(-delta * (-math.log(probability)) ** gamma)
+
+
+@njit
+def weight_gw(probability, gamma, delta):
+    """The Gonzalez & Wu (1999) weighting function."""
+    numerator = delta * probability**gamma
+    return numerator / (numerator + (1.0 - probability) ** gamma)
+
+
+## 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 weight of an outcome, as `ProspectUtility` computes it.
+
+    Parameters
+    ----------
+    probability, magnitude : float
+        The probability and magnitude of the outcome.
+    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, gamma if magnitude > 0 else 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 offset(input, offset, index):
+    """As :class:`cpm.models.activation.Offset`: a copy of `input` with `offset` added to element `index`."""
+    out = input.copy()
+    out[index] += offset
+    return out
+
+
+## ----------------------------------------------------------------------------
+## attention (cpm.models.attention)
+
+
+@njit
+def rapid_attention_shift(weights, predictions, input, error, gain, pnorm, P, rho):
+    """As :class:`cpm.models.attention.RapidAttentionShift`: the change in the attention gain."""
+    rows, columns = weights.shape
+    out = np.zeros(columns)
+    for i in range(rows):
+        for j in range(columns):
+            out[j] += (weights[i, j] * input[j] - predictions[i] * gain[j] ** (P - 1.0)) * error[i]
+    for j in range(columns):
+        out[j] = rho * (pnorm**-1) * out[j]
+    return out
diff --git a/docs/api/applications.rst b/docs/api/applications.rst
index dda3b75..076a83f 100644
--- a/docs/api/applications.rst
+++ b/docs/api/applications.rst
@@ -5,7 +5,9 @@ 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. Each of them has a session version (named with
+``Session`` appended), which gives the same results many times faster; see
+:doc:`/how-to/fast-session-models`.
 
 Reinforcement learning
 ----------------------
@@ -15,7 +17,9 @@ Reinforcement learning
    :nosignatures:
 
    reinforcement_learning.RLRW
+   reinforcement_learning.RLRWSession
    reinforcement_learning.HybridMBMF
+   reinforcement_learning.HybridMBMFSession
 
 Decision making
 ---------------
@@ -25,8 +29,11 @@ Decision making
    :nosignatures:
 
    decision_making.PTSM
+   decision_making.PTSMSession
    decision_making.PTSM1992
+   decision_making.PTSM1992Session
    decision_making.PTSM2025
+   decision_making.PTSM2025Session
 
 Metacognition
 -------------
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..015bbf3 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`. For models that
+compute all trials at once, :mod:`cpm.models.kernels` has the same components
+as functions that can be compiled with numba.
 
 Learning rules
 --------------
@@ -60,3 +62,40 @@ 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
+   softmax_noise
+   sigmoid
+   greedy
+   choice_kernel
+   choose
+   delta_rule
+   separable_rule
+   q_learning
+   humble_teacher
+   sarsa_trace_update
+   sigmoid_activation
+   competitive_gating
+   prospect_utility
+   prospect_weight
+   weight_tk
+   weight_power
+   weight_prelec
+   weight_gw
+   offset
+   rapid_attention_shift
diff --git a/docs/how-to/fast-session-models.md b/docs/how-to/fast-session-models.md
new file mode 100644
index 0000000..b14b359
--- /dev/null
+++ b/docs/how-to/fast-session-models.md
@@ -0,0 +1,144 @@
+# Speed up fitting with session models
+
+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. A {py:class}`~cpm.generators.SessionWrapper` calls the model function once for all trials of a participant instead, and with [numba](https://numba.pydata.org/) the loop over trials can be compiled as a whole. For the built-in applications, this makes one evaluation of the objective function 50 to 200 times faster, and a fit correspondingly faster.
+
+## Use the session version of a built-in application
+
+Every application in {py:mod}`cpm.applications` that is a `Wrapper` has a session version, named after it with `Session` appended:
+
+| Per-trial | Session version |
+|---|---|
+| {py:class}`~cpm.applications.reinforcement_learning.RLRW` | {py:class}`~cpm.applications.reinforcement_learning.RLRWSession` |
+| {py:class}`~cpm.applications.reinforcement_learning.HybridMBMF` | {py:class}`~cpm.applications.reinforcement_learning.HybridMBMFSession` |
+| {py:class}`~cpm.applications.decision_making.PTSM` | {py:class}`~cpm.applications.decision_making.PTSMSession` |
+| {py:class}`~cpm.applications.decision_making.PTSM1992` | {py:class}`~cpm.applications.decision_making.PTSM1992Session` |
+| {py:class}`~cpm.applications.decision_making.PTSM2025` | {py:class}`~cpm.applications.decision_making.PTSM2025Session` |
+
+A session version takes the same arguments, has the same parameters and priors, gives the same results and the same `export()`, and works with the optimisers, {py:class}`~cpm.generators.Simulator` and {py:mod}`cpm.hierarchical` in the same way. Swap the class and nothing else changes:
+
+```python
+from cpm.applications.reinforcement_learning import RLRWSession
+from cpm.datasets import load_bandit_data
+from cpm.optimisation import FminBound, minimise
+
+data = load_bandit_data()
+data["observed"] = data["response"]
+
+model = RLRWSession(data=data[data.ppt == 1], dimensions=4)  # was: RLRW(...)
+fit = FminBound(
+    model=model,
+    data=data.groupby("ppt"),
+    minimisation=minimise.LogLikelihood.bernoulli,
+    prior=True,
+    number_of_starts=5,
+    ppt_identifier="ppt",
+    approx_grad=True,
+)
+fit.optimise()
+```
+
+## Install numba
+
+The session versions run without numba, as plain Python, which is already 15 to 25 times faster than the per-trial applications. Compiled with numba, they are about 5 times faster again. numba is an optional dependency:
+
+```bash
+pip install cpm-toolbox[numba]
+```
+
+numba supports a new NumPy release some time after it comes out, and does not support PyPy. If numba cannot be imported, for either reason, cpm uses the plain-Python version without further notice.
+
+Choose between the two with `backend`:
+
+- `backend="auto"` (the default) uses numba if it is available and plain Python otherwise.
+- `backend="numba"` requires numba and raises an error without it.
+- `backend="python"` never compiles. Use it to debug a model, or to check a result against the compiled version.
+
+Both backends give the same results, to within rounding error.
+
+## 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 | Per-trial | Session, Python | Session, numba |
+|---|---:|---:|---:|---:|
+| `RLRW` | 71 | 7.6 ms | 0.43 ms | 0.09 ms |
+| `HybridMBMF` | 200 | 24 ms | 1.4 ms | 0.13 ms |
+| `PTSM` | 40 | 5.4 ms | 0.25 ms | 0.09 ms |
+| `PTSM1992` | 40 | 6.2 ms | 0.29 ms | 0.10 ms |
+| `PTSM2025` | 40 | 4.6 ms | 0.18 ms | 0.09 ms |
+
+With numba, the model itself takes 0.01 to 0.03 ms of this; most of the rest is the loss function.
+
+The first time a session model runs, numba compiles it, which takes 0.5 to 2.5 seconds. 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.
+
+## Simulations and random numbers
+
+Where a model samples choices, as with `generate=True`, the session versions draw one uniform random number per trial from `numpy.random` before the loop and turn it into a choice exactly as `numpy.random.choice` does. A simulation after `numpy.random.seed(...)` therefore makes the same choices with the per-trial application, the session version and both backends.
+
+## Where results can differ
+
+The session versions compute softmax and logistic probabilities in a way that cannot overflow. Where the per-trial applications overflow (an inverse temperature times a value above about 709), they return NaN or replace it, and the two differ; everywhere else they agree to within rounding error.
+
+Where a predicted probability comes within about $10^{-6}$ of 0 or 1, rounding errors of order $10^{-16}$ in the probability become relative errors of order $10^{-16}/(1 - p)$ in its log likelihood, in both versions. Their log likelihoods can then differ in the 8th or 10th significant digit instead of the 12th.
+
+## 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 10 to 20 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}
+```
+
+In a script or module, `@njit(cache=True)` keeps the compiled code on disk between Python sessions (not in an interactive session, where there is no file to cache it for).
+{py:mod}`cpm.models.kernels` has function versions of the learning rules, decision rules, activation functions and attention mechanisms in {py:mod}`cpm.models`, written to be called from compiled loops like this one.
+
+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` (or cpm's own `CPM_DISABLE_JIT=1`) before starting Python to run all compiled functions as plain Python, where you can use a debugger and `print` and get ordinary tracebacks. 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..ac169a6 100644
--- a/docs/how-to/index.md
+++ b/docs/how-to/index.md
@@ -5,6 +5,13 @@ 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 session models
+:link: fast-session-models
+:link-type: doc
+
+Fit the built-in models 50 to 200 times faster, and compile your own models with numba.
+:::
+
 :::{grid-item-card} {fas}`gauge-high` Parallelise model fitting
 :link: parallelise-fitting
 :link-type: doc
@@ -23,6 +30,7 @@ Split participants across the nodes of a SLURM cluster with a job array, then co
 ```{toctree}
 :hidden:
 
+fast-session-models
 parallelise-fitting
 run-on-hpc
 ```
diff --git a/pyproject.toml b/pyproject.toml
index cc599cb..5aca4df 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -45,6 +45,12 @@ dependencies = [
 ]
 
 [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..082afae
--- /dev/null
+++ b/scripts/local_tests.py
@@ -0,0 +1,79 @@
+"""
+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
+  session models as plain Python;
+- with ``NUMBA_DISABLE_JIT=1``, numba's own switch, for the kernel and session
+  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.
+
+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_sessions.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()
+
+    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/test/applications/test_sessions.py b/test/applications/test_sessions.py
new file mode 100644
index 0000000..59d37b7
--- /dev/null
+++ b/test/applications/test_sessions.py
@@ -0,0 +1,243 @@
+"""
+The session versions of the built-in applications give the same results as
+the per-trial applications, on both backends: the same dependent variable,
+export (columns, types and values), objective function and simulations.
+"""
+
+import copy
+import warnings
+
+import numpy as np
+import pandas as pd
+import pytest
+
+from cpm.applications.decision_making import (
+    PTSM, PTSM1992, PTSM2025, PTSM1992Session, PTSM2025Session, PTSMSession,
+)
+from cpm.applications.reinforcement_learning import (
+    RLRW, HybridMBMF, HybridMBMFSession, RLRWSession,
+)
+from cpm.core import _jit
+from cpm.core.optimisers import objective
+from cpm.datasets import load_bandit_data, load_risky_choices
+from cpm.generators import Simulator
+from cpm.optimisation import FminBound, minimise
+
+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, per-trial class, session class, data, keyword arguments, seed or None)
+CASES = [
+    ("RLRW", RLRW, RLRWSession, bandit, dict(dimensions=4, parameters_settings=[[0.3, 0, 1], [4, 0, 10]])),
+    ("RLRW-generate", RLRW, RLRWSession, bandit,
+     dict(dimensions=4, parameters_settings=[[0.3, 0, 1], [4, 0, 10]], generate=True)),
+    ("HybridMBMF", HybridMBMF, HybridMBMFSession, two_step, dict(parameters_settings=HYBRID)),
+    ("HybridMBMF-q_init", HybridMBMF, HybridMBMFSession, two_step,
+     dict(parameters_settings=HYBRID, q_init=4.5)),
+    ("HybridMBMF-generate", HybridMBMF, HybridMBMFSession, two_step,
+     dict(parameters_settings=HYBRID, generate=True)),
+    ("PTSM", PTSM, PTSMSession, risky, dict(parameters_settings=PT)),
+    ("PTSM-power", PTSM, PTSMSession, risky, dict(parameters_settings=PT, weighting="power")),
+    ("PTSM-prelec", PTSM, PTSMSession, risky, dict(parameters_settings=PT, weighting="prelec")),
+    ("PTSM-generate", PTSM, PTSMSession, risky, dict(parameters_settings=PT, generate=True)),
+    ("PTSM1992", PTSM1992, PTSM1992Session, risky, dict(parameters_settings=PT)),
+    ("PTSM1992-gw", PTSM1992, PTSM1992Session, risky, dict(parameters_settings=PT, weighting="gw")),
+    ("PTSM1992-curve", PTSM1992, PTSM1992Session, risky, dict(parameters_settings=PT, utility_curve=cubic)),
+    ("PTSM2025", PTSM2025, PTSM2025Session, risky, dict(parameters_settings=PT)),
+    ("PTSM2025-standard", PTSM2025, PTSM2025Session, risky, dict(parameters_settings=PT, variant="standard")),
+]
+IDS = [case[0] for case in CASES]
+
+
+def build(case, backend):
+    _, trial_class, session_class, data, kwargs = case
+    frame = data()
+    return (trial_class(data=frame, **kwargs), session_class(data=frame, backend=backend, **kwargs),
+            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)
+
+
+@pytest.mark.parametrize("backend", BACKENDS)
+@pytest.mark.parametrize("case", CASES, ids=IDS)
+def test_export_equals_the_per_trial_model(case, backend):
+    trial, session, _ = build(case, backend)
+    for scale in (None, 0.2, 0.7):
+        x = None if scale is None else free_values(trial, scale)
+        for model in (trial, session):
+            np.random.seed(123)
+            model.reset(parameters=x)
+            model.run()
+        expected, got = trial.export(), session.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)
+        np.testing.assert_allclose(session.dependent, trial.dependent, **TOLERANCE)
+        ## the states a run ends with
+        for key in session.parameters.keys():
+            value = session.parameters[key]
+            numeric = isinstance(getattr(value, "value", None), (int, float, np.ndarray, np.number))
+            if numeric and value.prior is None:
+                np.testing.assert_allclose(np.asarray(value.value, float),
+                                           np.asarray(trial.parameters[key].value, float), **TOLERANCE)
+
+
+@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_model(case, backend):
+    """
+    The objective agrees to 1e-12 where the predicted probabilities are not
+    extreme. Where a probability p is within about 1e-6 of 0 or 1, the loss takes
+    log(1 - p), which turns the rounding error of p (of order 1e-16 in either
+    implementation) into a relative error of order 1e-16 / (1 - p); there the
+    two agree to within that bound.
+    """
+    trial, session, observed = build(case, backend)
+    for scale in (0.1, 0.35, 0.5, 0.8):
+        x = free_values(trial, scale)
+        np.random.seed(1)
+        expected = objective(x, trial, observed, minimise.LogLikelihood.bernoulli, True)
+        np.random.seed(1)
+        got = objective(x, session, observed, minimise.LogLikelihood.bernoulli, True)
+        p = np.clip(trial.dependent, 1e-10, 1 - 1e-10)
+        closest = np.min(np.minimum(p, 1 - p))
+        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.skipif(not _jit.JIT_ENABLED, reason="numba is not installed or disabled")
+@pytest.mark.parametrize("case", CASES, ids=IDS)
+def test_backends_agree(case):
+    _, _, session_class, data, kwargs = case
+    frame = data()
+    exports = []
+    for backend in ("python", "numba"):
+        model = session_class(data=frame, backend=backend, **kwargs)
+        np.random.seed(7)
+        model.run()
+        exports.append(model.export())
+    pd.testing.assert_frame_equal(exports[0], exports[1], check_exact=False, rtol=1e-12, atol=1e-12)
+
+
+@pytest.mark.parametrize("backend", BACKENDS)
+def test_simulations_are_reproducible_and_match_the_per_trial_model(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],
+    })
+    out = []
+    for cls, kwargs in ((HybridMBMF, {}), (HybridMBMFSession, {"backend": backend})):
+        wrapper = cls(data=data[data.ppt == 0], parameters_settings=HYBRID, generate=True, **kwargs)
+        simulator = Simulator(wrapper=wrapper, data=data.groupby("ppt"), parameters=draws)
+        np.random.seed(2024)
+        simulator.run()
+        out.append(simulator.export())
+    pd.testing.assert_frame_equal(out[1], out[0], check_exact=False, rtol=1e-12, atol=1e-12)
+
+
+def test_unknown_backend_and_missing_numba(monkeypatch):
+    with pytest.raises(ValueError, match="backend"):
+        RLRWSession(data=bandit(), dimensions=4, backend="cuda")
+    monkeypatch.setattr(_jit, "HAVE_NUMBA", False)
+    monkeypatch.setattr(_jit, "JIT_ENABLED", False)
+    with pytest.raises(ImportError, match="numba"):
+        RLRWSession(data=bandit(), dimensions=4, backend="numba")
+    assert RLRWSession(data=bandit(), dimensions=4, backend="auto").backend == "python"
+
+
+def test_missing_columns_are_named():
+    with pytest.raises(KeyError, match="ambiguity"):
+        PTSM2025Session(data=risky().drop(columns="ambiguity"), parameters_settings=PT)
+    with pytest.raises(KeyError, match="reward_0"):
+        HybridMBMFSession(data=two_step().drop(columns="reward_0"), generate=True)
+
+
+def test_session_models_survive_deepcopy_and_pickling():
+    import pickle
+
+    model = HybridMBMFSession(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)
+
+
+@pytest.mark.skipif(not _jit.JIT_ENABLED, reason="numba is not installed or disabled")
+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=RLRWSession(data=bandit(1), dimensions=4, parameters_settings=[[0.3, 0, 1], [4, 0, 10]],
+                              backend="numba"),
+            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/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,
+        )

From 68c2d9f4c8f99d0fc0d04d824356c244016017ce Mon Sep 17 00:00:00 2001
From: Lenard Dome <23503601+lenarddome@users.noreply.github.com>
Date: Thu, 24 Sep 2026 18:35:07 +0200
Subject: [PATCH 04/34] perf: speed up cpm.models, per-trial runs, the losses
 and meta-d'

Results are unchanged, except that Softmax no longer overflows.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 CHANGELOG.md                                  |  9 ++-
 benchmarks/results/per-trial.csv              | 16 ++++
 cpm/applications/reinforcement_learning.py    | 10 +--
 cpm/applications/signal_detection.py          | 69 +++++++----------
 cpm/core/data.py                              | 44 +++++++++++
 cpm/generators/wrapper.py                     |  5 +-
 cpm/models/activation.py                      | 68 ++++++++++++-----
 cpm/models/decision.py                        | 32 +++++---
 cpm/models/learning.py                        | 74 ++++++++++---------
 cpm/optimisation/minimise.py                  | 37 +++++++++-
 docs/how-to/fast-session-models.md            | 18 ++---
 .../test_reinforcement_learning.py            | 14 ++--
 test/applications/test_signal_detection.py    | 37 ++++++++++
 test/generators/test_wrapper.py               | 53 +++++++++++++
 test/models/test_activation.py                | 20 +++++
 test/models/test_decision.py                  | 19 +++++
 test/models/test_learning.py                  | 16 ++++
 test/optimisation/test_minimise.py            | 26 +++++++
 18 files changed, 439 insertions(+), 128 deletions(-)
 create mode 100644 benchmarks/results/per-trial.csv

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 733bff6..7bb0699 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -22,7 +22,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - 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 `cpm.generators.SessionWrapper`, a `Wrapper` whose model function computes all trials of a participant in one call instead of being called once per trial. It works with the optimisers, `Simulator` and `cpm.hierarchical` unchanged, and its `export()` has the same layout as that of a `Wrapper`
-- Added session versions of all built-in applications that are models: `RLRWSession` and `HybridMBMFSession` in `cpm.applications.reinforcement_learning`, and `PTSMSession`, `PTSM1992Session` and `PTSM2025Session` in `cpm.applications.decision_making`. Each takes the same arguments as the application it is named after (plus `backend`), has the same parameters and priors, and gives the same results and `export()`, but computes all trials of a participant in one call, compiled with numba where available. One evaluation of the objective function is 50 to 200 times faster than with the per-trial applications (15 to 25 times without numba). Simulations with `generate=True` sample from `numpy.random` exactly as the per-trial applications do, so they make the same choices for a given seed
+- Added session versions of all built-in applications that are models: `RLRWSession` and `HybridMBMFSession` in `cpm.applications.reinforcement_learning`, and `PTSMSession`, `PTSM1992Session` and `PTSM2025Session` in `cpm.applications.decision_making`. Each takes the same arguments as the application it is named after (plus `backend`), has the same parameters and priors, and gives the same results and `export()`, but computes all trials of a participant in one call, compiled with numba where available. One evaluation of the objective function is 35 to 120 times faster than with the per-trial applications (8 to 15 times without numba). Simulations with `generate=True` sample from `numpy.random` exactly as the per-trial applications do, so they make the same choices for a given seed
 - Added `cpm.models.kernels`, function versions of the learning rules, decision rules, activation functions and attention mechanism in `cpm.models` that can be called from loops compiled with numba, each tested against its class. Its softmax, sigmoid and logistic functions cannot overflow, and `choose` samples from a policy as `numpy.random.choice` does, given a uniform random number drawn beforehand
 - Added numba as an optional dependency (`pip install cpm-toolbox[numba]`). Without it, or with `CPM_DISABLE_JIT=1`, the session models run as plain Python and give the same results
 - Added a how-to guide on session models and numba, and `scripts/local_tests.py`, which runs the test suite with numba, without it and with `NUMBA_DISABLE_JIT=1`, and then the benchmark suite
@@ -35,6 +35,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - 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
 - Made each evaluation of the objective function cheaper for every model, by 0.5-1 ms for 2-6 free parameters (about 0.1 ms per free parameter): `cpm.generators.Value` copies now share their prior distribution instead of deep-copying it, `cpm.generators.Wrapper.reset()` restores parameter values and initial states without copying the priors, and `Value.PDF(log=True)` evaluates the uniform, truncated normal, beta, gamma, truncated exponential and normal priors (including frozen scipy distributions of these families passed in by the user) in closed form instead of through scipy. The priors remain frozen scipy distributions, and the log densities equal scipy's to 1e-12. Models that copy their parameters on every trial gain most: `PTSM2025` runs 17 times faster
 - `cpm.generators.Value.update_prior()` now replaces the prior with an updated copy instead of changing it in place, since copies of a `Value` share their prior. Code that changes `value.prior.kwds` directly now changes the prior of every copy of that `Value`
+- Made per-trial models about twice as fast. `cpm.generators.Wrapper.run()` builds each trial from a copy of the data made once per run instead of reading it with `DataFrame.iloc` (about 50 microseconds per trial), for data with numeric and boolean columns; the trials are the same `pandas.Series` as before. The applications in `cpm.applications.reinforcement_learning` look up trial variables by key instead of by attribute, which pandas makes slow
+- Made the classes in `cpm.models` faster, with results identical to before: `Softmax` computes the exponentials once, the learning rules `DeltaRule`, `SeparableRule`, `HumbleTeacher` and `QLearningRule` and `CompetitiveGating` compute all weights at once instead of looping over them (3 to 18 times faster for 32 stimuli), and `ProspectUtility` computes options with the same number of outcomes as float arrays instead of arrays of arrays (2 to 3 times faster)
+- Made `LogLikelihood.bernoulli` and `LogLikelihood.continuous` 2.5 and 3 times faster, with identical results, by evaluating the expressions scipy evaluates without scipy's per-call argument handling, and by checking the inputs for non-finite values in one pass
+- Made `cpm.applications.signal_detection.EstimatorMetaD` about 10 times faster, with identical results, by computing all normal CDFs of `metad_nll` in one vectorised call instead of one scipy call each
+- `cpm.models.decision.Softmax` no longer overflows: where the scaled activations exceed ±700, it computes the same function with the largest activation subtracted. It previously returned NaN there, replaced it with 1 and warned; the policies are now the correct ones, without a warning. Elsewhere its results are unchanged
 - Added a benchmark suite under `benchmarks/`, which times each part of the objective function for every built-in application (`python benchmarks/run.py`)
 
 ### Fixed
@@ -53,6 +58,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - 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 `numpy.asarray(value, dtype=...)` raising `TypeError` for a `cpm.generators.Value`, because `Value.__array__` did not take the `dtype` and `copy` arguments of the NumPy array protocol
+- Fixed `cpm.models.activation.ProspectUtility` with `weighting="prelec"` raising `TypeError` for options with more than one outcome, because the probabilities were stored as an object array, which `numpy.log` does not accept
+- Fixed `cpm.models.learning.HumbleTeacher` raising `IndexError` for 1D weights, which it promotes to one row like the other learning rules but sized its `delta` before doing so
 - 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
diff --git a/benchmarks/results/per-trial.csv b/benchmarks/results/per-trial.csv
new file mode 100644
index 0000000..4ef8741
--- /dev/null
+++ b/benchmarks/results/per-trial.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.47880000481382,0.004200031980872154,0.003500026650726795,3.418999956920743,0.019600032828748226,-26.034401210112605,1.0
+RLRW,python,71,2,0.41675003012642264,0.00500003807246685,0.00409991480410099,0.35879993811249733,0.021200045011937618,-26.034401210112605,8.347449918020434
+RLRW,numba,71,2,0.04700000863522291,0.005100038833916187,0.004100031219422817,0.01170008908957243,0.02010003663599491,-26.034401210112605,74.01700778000976
+HybridMBMF,trial,200,6,10.28014998883009,0.01170008908957243,0.006800051778554916,10.141300037503242,0.021700048819184303,-151.7819350468299,1.0
+HybridMBMF,python,200,6,1.3584000407718122,0.012200092896819115,0.00700005330145359,1.322799944318831,0.021600048057734966,-151.7819350468299,7.567836925997986
+HybridMBMF,numba,200,6,0.08459994569420815,0.01209997572004795,0.00700005330145359,0.029199989512562752,0.02159993164241314,-151.7819350468299,121.5148532835747
+PTSM,trial,40,4,2.043900021817535,0.007850001566112041,0.00900006853044033,2.0222999155521393,0.019400031305849552,-36.42346848683204,1.0
+PTSM,python,40,4,0.21490000654011965,0.006900052540004253,0.005400041118264198,0.16300007700920105,0.020799983758479357,-36.423468486832036,9.51093513082774
+PTSM,numba,40,4,0.059699988923966885,0.007899943739175797,0.005699926987290382,0.012299977242946625,0.019400031305849552,-36.423468486832036,34.23618762175349
+PTSM1992,trial,40,6,2.584350004326552,0.00900006853044033,0.006299989763647318,2.4742999812588096,0.016700010746717453,-39.438732136106225,1.0
+PTSM1992,python,40,6,0.2594499965198338,0.009599956683814526,0.006699992809444666,0.1984999980777502,0.02039998071268201,-39.438732136106225,9.96087893232633
+PTSM1992,numba,40,6,0.06925000343471766,0.009800016414374113,0.006199930794537067,0.014199991710484028,0.017900019884109497,-39.438732136106225,37.31913178549995
+PTSM2025,trial,40,5,2.1840999834239483,0.008400063961744308,0.006400048732757568,2.0939999958500266,0.019099912606179714,-33.01065168146936,1.0
+PTSM2025,python,40,5,0.1489499700255692,0.007950002327561378,0.006100046448409557,0.09280000813305378,0.01829996472224593,-33.01065168146936,14.663312675048
+PTSM2025,numba,40,5,0.05689996760338545,0.008500064723193645,0.006399932317435741,0.009499955922365189,0.01910002902150154,-33.01065168146936,38.38490732803156
diff --git a/cpm/applications/reinforcement_learning.py b/cpm/applications/reinforcement_learning.py
index 20252b9..48bdf2b 100644
--- a/cpm/applications/reinforcement_learning.py
+++ b/cpm/applications/reinforcement_learning.py
@@ -186,7 +186,7 @@ def model(parameters, trial, generate=generate):
             )  ## 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)
+            choice = trial["response"].astype(int)
             reward_names = [
                 col for col in trial.index if "reward" in col
             ]  ## get column names beginning with stimulus
@@ -359,7 +359,7 @@ def model(parameters, trial, generate=generate):
             m = numpy.asarray(parameters.m).copy()
             r = numpy.asarray(parameters.r).copy()
 
-            s1 = int(trial.s1)
+            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
@@ -384,9 +384,9 @@ def model(parameters, trial, generate=generate):
                 reward = float(trial[f"reward_{s2}"])
                 position = stimuli_first ^ action
             else:
-                action = int(trial.action)
-                s2 = int(trial.s2)
-                reward = float(trial.reward)
+                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
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/data.py b/cpm/core/data.py
index 4e9dba1..1e8488a 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,49 @@ 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 and boolean
+    columns, 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
+        )
+        if plain and data.shape[1] > 0:
+            values = data.to_numpy(copy=True)
+            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/wrapper.py b/cpm/generators/wrapper.py
index 03ddb42..ed725c1 100644
--- a/cpm/generators/wrapper.py
+++ b/cpm/generators/wrapper.py
@@ -6,7 +6,7 @@
 
 ## 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
 
@@ -121,9 +121,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())
diff --git a/cpm/models/activation.py b/cpm/models/activation.py
index 2ea53d1..77fea70 100644
--- a/cpm/models/activation.py
+++ b/cpm/models/activation.py
@@ -117,9 +117,7 @@ def compute(self):
         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.values[:] = self.values * self.gain[: self.values.shape[1]]
         return self.values
 
     def __call__(self):
@@ -260,22 +258,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
@@ -362,6 +369,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 +397,27 @@ 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)
+            weighted = np.asarray(self.weights * self.utilities)
+            self.expected_utility = weighted.reshape(options, -1).sum(axis=1)
+            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)
+        ]
+        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()
 
diff --git a/cpm/models/decision.py b/cpm/models/decision.py
index 009cbcc..7f9c6c5 100644
--- a/cpm/models/decision.py
+++ b/cpm/models/decision.py
@@ -73,11 +73,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,16 +94,30 @@ 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)
-        )
+        scaled = self.activations * self.temperature
+        top = scaled.max() if scaled.size else 0.0
+        if -700.0 < top < 700.0:
+            output = np.exp(scaled)
+            output = output / output.sum()
+        elif np.isnan(top):
+            output = np.exp(scaled)
+        else:
+            output = np.exp(scaled - top)
+            output = output / output.sum()
         self.policies = output
 
         if np.isnan(self.policies).any():
diff --git a/cpm/models/learning.py b/cpm/models/learning.py
index f5c15bf..819ae96 100644
--- a/cpm/models/learning.py
+++ b/cpm/models/learning.py
@@ -9,6 +9,21 @@
 ]
 
 
+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)
+    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 +140,13 @@ 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
+        stimulus = _leading(self.input, columns)
+        # calculate summed error for each output unit
+        activations = np.sum(self.weights * stimulus, axis=1)
+        self.error = _leading(self.teacher, rows) - activations
+        # calculate the change on weights
+        _assign(self, "weights", self.alpha * self.error[:, np.newaxis] * stimulus)
         self.__run__ = True
         return self.weights
 
@@ -261,11 +276,11 @@ 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
+        teacher = _leading(self.teacher, rows)
+        self.error = teacher[:, np.newaxis] - self.weights
+        _assign(self, "weights", self.alpha * self.error * _leading(self.input, columns))
         self.__run__ = True
         return self.weights
 
@@ -384,17 +399,10 @@ def compute(self):
         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]
-            )
-
+        output += (
+            self.values
+            + (self.alpha * (self.reward + self.gamma * self.maximum - self.values)) * active
+        )
         return output
 
     def __repr__(self):
@@ -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,15 @@ 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
+        stimulus = _leading(self.input, columns)
+        activations = np.sum(self.weights * stimulus, axis=1)
+        feedback = _leading(self.teacher, rows)
+        teacher = np.where(
+            feedback == 0, np.minimum(-1, activations), np.maximum(1, activations)
+        )
+        self.delta[:] = self.alpha * (teacher - activations)[:, np.newaxis] * stimulus
+        np.add(self.weights, self.delta, out=self.weights, casting="unsafe")
         return self.weights
 
 
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/how-to/fast-session-models.md b/docs/how-to/fast-session-models.md
index b14b359..8044ad5 100644
--- a/docs/how-to/fast-session-models.md
+++ b/docs/how-to/fast-session-models.md
@@ -1,6 +1,6 @@
 # Speed up fitting with session models
 
-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. A {py:class}`~cpm.generators.SessionWrapper` calls the model function once for all trials of a participant instead, and with [numba](https://numba.pydata.org/) the loop over trials can be compiled as a whole. For the built-in applications, this makes one evaluation of the objective function 50 to 200 times faster, and a fit correspondingly faster.
+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. A {py:class}`~cpm.generators.SessionWrapper` calls the model function once for all trials of a participant instead, and with [numba](https://numba.pydata.org/) the loop over trials can be compiled as a whole. For the built-in applications, this makes one evaluation of the objective function 35 to 120 times faster, and a fit correspondingly faster.
 
 ## Use the session version of a built-in application
 
@@ -39,7 +39,7 @@ fit.optimise()
 
 ## Install numba
 
-The session versions run without numba, as plain Python, which is already 15 to 25 times faster than the per-trial applications. Compiled with numba, they are about 5 times faster again. numba is an optional dependency:
+The session versions run without numba, as plain Python, which is already 8 to 15 times faster than the per-trial applications. Compiled with numba, they are 3 to 16 times faster again. numba is an optional dependency:
 
 ```bash
 pip install cpm-toolbox[numba]
@@ -61,13 +61,13 @@ One evaluation of the objective function, with the parameters' priors, for one p
 
 | Application | Trials | Per-trial | Session, Python | Session, numba |
 |---|---:|---:|---:|---:|
-| `RLRW` | 71 | 7.6 ms | 0.43 ms | 0.09 ms |
-| `HybridMBMF` | 200 | 24 ms | 1.4 ms | 0.13 ms |
-| `PTSM` | 40 | 5.4 ms | 0.25 ms | 0.09 ms |
-| `PTSM1992` | 40 | 6.2 ms | 0.29 ms | 0.10 ms |
-| `PTSM2025` | 40 | 4.6 ms | 0.18 ms | 0.09 ms |
+| `RLRW` | 71 | 3.5 ms | 0.42 ms | 0.05 ms |
+| `HybridMBMF` | 200 | 10 ms | 1.4 ms | 0.09 ms |
+| `PTSM` | 40 | 2.0 ms | 0.22 ms | 0.06 ms |
+| `PTSM1992` | 40 | 2.6 ms | 0.26 ms | 0.07 ms |
+| `PTSM2025` | 40 | 2.2 ms | 0.15 ms | 0.06 ms |
 
-With numba, the model itself takes 0.01 to 0.03 ms of this; most of the rest is the loss function.
+With numba, the model itself takes 0.01 to 0.03 ms of this, and the loss function about 0.02 ms.
 
 The first time a session model runs, numba compiles it, which takes 0.5 to 2.5 seconds. 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.
 
@@ -111,7 +111,7 @@ wrapper = SessionWrapper(model=model, data=data_of_one_participant, parameters=p
 
 `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 10 to 20 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:
+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
diff --git a/test/applications/test_reinforcement_learning.py b/test/applications/test_reinforcement_learning.py
index b2c1277..6f83748 100644
--- a/test/applications/test_reinforcement_learning.py
+++ b/test/applications/test_reinforcement_learning.py
@@ -117,12 +117,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_wrapper.py b/test/generators/test_wrapper.py
index 623f49c..e91bd36 100644
--- a/test/generators/test_wrapper.py
+++ b/test/generators/test_wrapper.py
@@ -106,5 +106,58 @@ 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)
+        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/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..916870d 100644
--- a/test/models/test_decision.py
+++ b/test/models/test_decision.py
@@ -142,5 +142,24 @@ 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)
+
+
 if __name__ == "__main__":
     pytest.main()
diff --git a/test/models/test_learning.py b/test/models/test_learning.py
index e504029..72ce4f2 100644
--- a/test/models/test_learning.py
+++ b/test/models/test_learning.py
@@ -141,5 +141,21 @@ 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])
+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()

From aadbc63c84964d3c2ba6779ec07ae7c4a5f53e8a Mon Sep 17 00:00:00 2001
From: Lenard Dome <23503601+lenarddome@users.noreply.github.com>
Date: Fri, 25 Sep 2026 18:20:27 +0200
Subject: [PATCH 05/34] refactor(applications): one implementation per model,
 same API

Each application computes all trials in one loop, compiled with numba if it is installed.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 CHANGELOG.md                                  |  10 +-
 README.md                                     |   6 +
 benchmarks/cases.py                           |  57 +-
 benchmarks/results/local.csv                  |  16 -
 benchmarks/results/one-implementation.csv     |  16 +
 benchmarks/run.py                             |   9 +-
 cpm/applications/_backend.py                  | 139 +++-
 cpm/applications/_sessions.py                 |  28 +-
 cpm/applications/decision_making.py           | 607 +++++-------------
 cpm/applications/reinforcement_learning.py    | 522 ++++-----------
 cpm/core/_jit.py                              |  20 +-
 cpm/generators/_fast_priors.py                |  87 ++-
 cpm/generators/session.py                     |  36 +-
 cpm/models/kernels.py                         |   8 +-
 docs/api/applications.rst                     |  10 +-
 docs/get-started/installation.md              |  10 +
 docs/how-to/fast-session-models.md            |  92 +--
 docs/how-to/index.md                          |   4 +-
 scripts/local_tests.py                        |   6 +-
 .../data/per_trial_reference.pkl.gz           | Bin 0 -> 80786 bytes
 test/applications/test_backends.py            | 270 ++++++++
 test/applications/test_sessions.py            | 243 -------
 test/generators/test_fast_priors.py           |   7 +-
 23 files changed, 915 insertions(+), 1288 deletions(-)
 delete mode 100644 benchmarks/results/local.csv
 create mode 100644 benchmarks/results/one-implementation.csv
 create mode 100644 test/applications/data/per_trial_reference.pkl.gz
 create mode 100644 test/applications/test_backends.py
 delete mode 100644 test/applications/test_sessions.py

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7bb0699..1e1efe9 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -22,10 +22,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - 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 `cpm.generators.SessionWrapper`, a `Wrapper` whose model function computes all trials of a participant in one call instead of being called once per trial. It works with the optimisers, `Simulator` and `cpm.hierarchical` unchanged, and its `export()` has the same layout as that of a `Wrapper`
-- Added session versions of all built-in applications that are models: `RLRWSession` and `HybridMBMFSession` in `cpm.applications.reinforcement_learning`, and `PTSMSession`, `PTSM1992Session` and `PTSM2025Session` in `cpm.applications.decision_making`. Each takes the same arguments as the application it is named after (plus `backend`), has the same parameters and priors, and gives the same results and `export()`, but computes all trials of a participant in one call, compiled with numba where available. One evaluation of the objective function is 35 to 120 times faster than with the per-trial applications (8 to 15 times without numba). Simulations with `generate=True` sample from `numpy.random` exactly as the per-trial applications do, so they make the same choices for a given seed
 - Added `cpm.models.kernels`, function versions of the learning rules, decision rules, activation functions and attention mechanism in `cpm.models` that can be called from loops compiled with numba, each tested against its class. Its softmax, sigmoid and logistic functions cannot overflow, and `choose` samples from a policy as `numpy.random.choice` does, given a uniform random number drawn beforehand
-- Added numba as an optional dependency (`pip install cpm-toolbox[numba]`). Without it, or with `CPM_DISABLE_JIT=1`, the session models run as plain Python and give the same results
-- Added a how-to guide on session models and numba, and `scripts/local_tests.py`, which runs the test suite with numba, without it and with `NUMBA_DISABLE_JIT=1`, and then the benchmark suite
+- Added numba as an optional dependency (`pip install cpm-toolbox[numba]`), which compiles the built-in applications. Without it, or with `CPM_DISABLE_JIT=1`, they run as plain Python and give the same results
+- Added a how-to guide on numba and session models, and `scripts/local_tests.py`, which runs the test suite with numba, without it and with `NUMBA_DISABLE_JIT=1`, and then the benchmark suite
 
 ### Changed
 
@@ -33,9 +32,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - 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
-- Made each evaluation of the objective function cheaper for every model, by 0.5-1 ms for 2-6 free parameters (about 0.1 ms per free parameter): `cpm.generators.Value` copies now share their prior distribution instead of deep-copying it, `cpm.generators.Wrapper.reset()` restores parameter values and initial states without copying the priors, and `Value.PDF(log=True)` evaluates the uniform, truncated normal, beta, gamma, truncated exponential and normal priors (including frozen scipy distributions of these families passed in by the user) in closed form instead of through scipy. The priors remain frozen scipy distributions, and the log densities equal scipy's to 1e-12. Models that copy their parameters on every trial gain most: `PTSM2025` runs 17 times faster
+- Made each evaluation of the objective function cheaper for every model, by 0.5-1 ms for 2-6 free parameters (about 0.1 ms per free parameter): `cpm.generators.Value` copies now share their prior distribution instead of deep-copying it, `cpm.generators.Wrapper.reset()` restores parameter values and initial states without copying the priors, and `Value.PDF(log=True)` evaluates the uniform, truncated normal, beta, gamma, truncated exponential and normal priors (including frozen scipy distributions of these families passed in by the user) in closed form instead of through scipy. The priors remain frozen scipy distributions, and the log densities are identical to scipy's (the same floating-point operations, with the constant terms computed once). Models that copy their parameters on every trial gain most: `PTSM2025` runs 17 times faster
 - `cpm.generators.Value.update_prior()` now replaces the prior with an updated copy instead of changing it in place, since copies of a `Value` share their prior. Code that changes `value.prior.kwds` directly now changes the prior of every copy of that `Value`
-- Made per-trial models about twice as fast. `cpm.generators.Wrapper.run()` builds each trial from a copy of the data made once per run instead of reading it with `DataFrame.iloc` (about 50 microseconds per trial), for data with numeric and boolean columns; the trials are the same `pandas.Series` as before. The applications in `cpm.applications.reinforcement_learning` look up trial variables by key instead of by attribute, which pandas makes slow
+- Made the built-in applications `RLRW`, `HybridMBMF`, `PTSM`, `PTSM1992` and `PTSM2025` compute all trials of a participant in one call instead of one call per trial, compiled with numba if it is installed. Together with the changes below, one evaluation of the objective function is 100 to 270 times faster than before with numba, and 18 to 29 times faster without it (`PTSM2025`: 1,200 and 470 times). Their interface is unchanged: the same arguments, parameters, priors and outputs, `export()`, `simulation` (the outputs of each trial), and `model`, which is still the model function for a single trial, `model(parameters, trial)`, and can be used in a per-trial `Wrapper` as before. Their results are the same as before (bit for bit where exponentials do not overflow, tested against the outputs of the previous implementation), including simulations with `generate=True`, which sample from `numpy.random` in the same way. Each model has a single implementation in `cpm.applications._sessions`, which `model` runs on one trial
+- Made per-trial models about twice as fast. `cpm.generators.Wrapper.run()` builds each trial from a copy of the data made once per run instead of reading it with `DataFrame.iloc` (about 50 microseconds per trial), for data with numeric and boolean columns; the trials are the same `pandas.Series` as before
 - Made the classes in `cpm.models` faster, with results identical to before: `Softmax` computes the exponentials once, the learning rules `DeltaRule`, `SeparableRule`, `HumbleTeacher` and `QLearningRule` and `CompetitiveGating` compute all weights at once instead of looping over them (3 to 18 times faster for 32 stimuli), and `ProspectUtility` computes options with the same number of outcomes as float arrays instead of arrays of arrays (2 to 3 times faster)
 - Made `LogLikelihood.bernoulli` and `LogLikelihood.continuous` 2.5 and 3 times faster, with identical results, by evaluating the expressions scipy evaluates without scipy's per-call argument handling, and by checking the inputs for non-finite values in one pass
 - Made `cpm.applications.signal_detection.EstimatorMetaD` about 10 times faster, with identical results, by computing all normal CDFs of `metad_nll` in one vectorised call instead of one scipy call each
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
index 0eaf57a..cd15444 100644
--- a/benchmarks/cases.py
+++ b/benchmarks/cases.py
@@ -3,10 +3,14 @@
 
 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.
-`backend=None` is the per-trial application (the original classes); the other
-backends are the session versions. Cases whose session version does not exist
-in the installed cpm are skipped, so the same file also benchmarks older
-versions of cpm.
+
+- "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
@@ -15,6 +19,7 @@
 import pandas as pd
 
 import cpm
+from cpm.generators import Wrapper
 from cpm.datasets import load_bandit_data, load_risky_choices
 
 
@@ -63,18 +68,24 @@ def risky():
 }
 
 
-def _application(module, name, backend):
-    """The per-trial class for backend None, else its session version (or None)."""
-    module = getattr(cpm.applications, module)
-    if backend is None:
-        return getattr(module, name)
-    session = getattr(module, name + "Session", None)
+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
-    return lambda **kwargs: session(backend=backend, **kwargs)
+    session.backend = backend
+    return model
 
 
-def build(case, backend=None):
+def build(case, backend="trial"):
     """
     The model, observed data and parameter values of a benchmark case.
 
@@ -82,11 +93,11 @@ def build(case, backend=None):
     """
     warnings.simplefilter("ignore")
     if case == "RLRW":
-        cls = _application("reinforcement_learning", "RLRW", backend)
+        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", backend)
+        cls = _application("reinforcement_learning", "HybridMBMF")
         data = two_step()
         kwargs = dict(
             parameters_settings=[
@@ -94,18 +105,28 @@ def build(case, backend=None):
             ]
         )
     elif case in ("PTSM", "PTSM1992", "PTSM2025"):
-        cls = _application("decision_making", case, backend)
+        cls = _application("decision_making", case)
         data = risky()
         kwargs = dict(parameters_settings=PT_SETTINGS)
     else:
         raise ValueError(case)
-    if cls is None:
+    if backend == "numba" and not _jit_enabled():
+        return None
+    model = _on_backend(cls(data=data, **kwargs), backend)
+    if model is None:
         return None
-    model = cls(data=data, **kwargs)
     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 = [None, "python", "numba"]
+BACKENDS = ["trial", "python", "numba"]
diff --git a/benchmarks/results/local.csv b/benchmarks/results/local.csv
deleted file mode 100644
index 48be5bd..0000000
--- a/benchmarks/results/local.csv
+++ /dev/null
@@ -1,16 +0,0 @@
-case,backend,trials,parameters,objective_ms,reset_ms,prior_ms,run_ms,loss_ms,log_posterior,speed_up
-RLRW,trial,71,2,7.659750001039356,0.004899920895695686,0.004100031219422817,7.564100029412657,0.045249995309859514,-26.034401210112605,1.0
-RLRW,python,71,2,0.4428999964147806,0.004900037311017513,0.004100031219422817,0.354300020262599,0.04859990440309048,-26.034401210112605,17.29453615498772
-RLRW,numba,71,2,0.08764996891841292,0.004900037311017513,0.004100031219422817,0.011599971912801266,0.044199987314641476,-26.034401210112605,87.39021925004067
-HybridMBMF,trial,200,6,23.857699998188764,0.01279998105019331,0.007600057870149612,24.291999987326562,0.05609996151179075,-151.7819350468299,1.0
-HybridMBMF,python,200,6,1.470250019337982,0.01109996810555458,0.006749993190169334,1.3379499432630837,0.05365000106394291,-151.7819350468299,16.226967988023773
-HybridMBMF,numba,200,6,0.1292000524699688,0.012800039257854223,0.0070999376475811005,0.02729997504502535,0.0540000619366765,-151.7819350468299,184.65704573714657
-PTSM,trial,40,4,5.286899977363646,0.0078000593930482864,0.005799927748739719,5.09605003753677,0.04529999569058418,-36.42346848683204,1.0
-PTSM,python,40,4,0.24894997477531433,0.007999944500625134,0.005800044164061546,0.16289995983242989,0.045900000259280205,-36.423468486832036,21.236796597931974
-PTSM,numba,40,4,0.09355001384392381,0.0074999406933784485,0.005500041879713535,0.011399970389902592,0.04569999873638153,-36.423468486832036,56.51415494373053
-PTSM1992,trial,40,6,6.143599981442094,0.009699957445263863,0.006500049494206905,6.034650024957955,0.04630000330507755,-39.438732136106225,1.0
-PTSM1992,python,40,6,0.29039999935775995,0.009900075383484364,0.007400056347250938,0.19880000036209822,0.04600000102072954,-39.438732136106225,21.15564736580268
-PTSM1992,numba,40,6,0.09820004925131798,0.009699957445263863,0.0068999361246824265,0.016200006939470768,0.04610000178217888,-39.438732136106225,62.56208655984598
-PTSM2025,trial,40,5,4.46989998454228,0.008399947546422482,0.006500049494206905,4.286449984647334,0.04409998655319214,-33.01065168146936,1.0
-PTSM2025,python,40,5,0.1829999964684248,0.00800006091594696,0.005799927748739719,0.08535000961273909,0.04579999949783087,-33.01065168146936,24.425683447013217
-PTSM2025,numba,40,5,0.09099999442696571,0.007899943739175797,0.006100046448409557,0.00879995059221983,0.04579999949783087,-33.01065168146936,49.11978305811556
diff --git a/benchmarks/results/one-implementation.csv b/benchmarks/results/one-implementation.csv
new file mode 100644
index 0000000..91b6803
--- /dev/null
+++ b/benchmarks/results/one-implementation.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.5462499945424497,0.004899920895695686,0.004799920134246349,3.534849965944886,0.02019992098212242,-26.034401210112605,1.0
+RLRW,python,71,2,0.4120499943383038,0.004700035788118839,0.004100031219422817,0.36609999369829893,0.03390002530068159,-26.034401210112605,8.60635855665341
+RLRW,numba,71,2,0.05650008097290993,0.005200039595365524,0.004400033503770828,0.011400086805224419,0.01750001683831215,-26.034401210112605,62.765396676913944
+HybridMBMF,trial,200,6,10.832400002982467,0.012500095181167126,0.00870006624609232,10.568150028120726,0.021600048057734966,-151.7819350468299,1.0
+HybridMBMF,python,200,6,1.4124999870546162,0.012299977242946625,0.00870006624609232,1.4587999903596938,0.02234999556094408,-151.7819350468299,7.66895582460888
+HybridMBMF,numba,200,6,0.09350001346319914,0.01309998333454132,0.009199953638017178,0.03125000512227416,0.02150004729628563,-151.7819350468299,115.85452880438369
+PTSM,trial,40,4,1.9270499469712377,0.007900060154497623,0.006900052540004253,1.8142999615520239,0.019300030544400215,-36.42346848683204,1.0
+PTSM,python,40,4,0.22014998830854893,0.008299946784973145,0.0069999368861317635,0.20319997565820813,0.022099993657320738,-36.42346848683204,8.753350212630494
+PTSM,numba,40,4,0.06430002395063639,0.008299946784973145,0.006900052540004253,0.013000040780752897,0.019200029782950878,-36.42346848683204,29.969661418021374
+PTSM1992,trial,40,6,1.969299977645278,0.0097999582067132,0.008399947546422482,1.8565500504337251,0.019399914890527725,-39.43873213610623,1.0
+PTSM1992,python,40,6,0.26510003954172134,0.009999959729611874,0.008500064723193645,0.20109995966777205,0.018299906514585018,-39.43873213610623,7.42851634820428
+PTSM1992,numba,40,6,0.07379997987300158,0.010200077667832375,0.008699949830770493,0.017000013031065464,0.019300030544400215,-39.43873213610623,26.68428881734305
+PTSM2025,trial,40,5,1.7644499894231558,0.008599949069321156,0.007999944500625134,1.6838500159792602,0.01850002445280552,-33.01065168146936,1.0
+PTSM2025,python,40,5,0.15740003436803818,0.00879995059221983,0.00800006091594696,0.10269996710121632,0.016700010746717453,-33.01065168146936,11.209972072162692
+PTSM2025,numba,40,5,0.06005004979670048,0.008800067007541656,0.007900060154497623,0.010299962013959885,0.018000020645558834,-33.01065168146936,29.382989612776402
diff --git a/benchmarks/run.py b/benchmarks/run.py
index 6465dbf..411b492 100644
--- a/benchmarks/run.py
+++ b/benchmarks/run.py
@@ -5,8 +5,9 @@
     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 "trial" for the original per-trial
-applications and "python" or "numba" for their session versions.
+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
@@ -83,14 +84,14 @@ def main():
             rows.append(
                 {
                     "case": case,
-                    "backend": backend or "trial",
+                    "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 or 'trial':>6}: {times['objective'] * 1e3:8.3f} ms", flush=True)
+            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"]
diff --git a/cpm/applications/_backend.py b/cpm/applications/_backend.py
index 645762b..924641d 100644
--- a/cpm/applications/_backend.py
+++ b/cpm/applications/_backend.py
@@ -1,14 +1,27 @@
 """
-Shared machinery of the session versions of the built-in applications.
+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 session_data
+from ..generators.session import SessionWrapper, session_data
 
-__all__ = ["SessionModel", "require", "uniforms"]
+__all__ = ["Application", "SessionModel", "TrialModel", "require", "uniforms"]
 
 
 class SessionModel:
@@ -16,31 +29,119 @@ 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 first needed, rather than stored, so that the model function
-    pickles by reference and can be sent to other processes for parallel fits.
+    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" or "python", as returned by `cpm.core._jit.resolve_backend`.
+        "numba" if numba is installed and not disabled, "python" otherwise.
     """
 
-    def __init__(self, backend):
-        self.backend = backend
-        self._sessions = None
+    def __init__(self, generate=False):
+        self.generate = generate
+        self.backend = _jit.resolve_backend("auto")
 
     @property
     def sessions(self):
-        if self._sessions is None:
-            self._sessions = _jit.kernels(
-                "cpm.applications._sessions", python=self.backend == "python"
-            )
-        return self._sessions
-
-    def __getstate__(self):
-        state = self.__dict__.copy()
-        state["_sessions"] = None
-        return state
+        return _jit.kernels("cpm.applications._sessions", python=self.backend == "python")
+
+
+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 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.
+    """
+
+    _trial_shapes = {}
+
+    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)
+
+    @property
+    def simulation(self):
+        """The outputs of each trial of the last run, as a list of dictionaries."""
+        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 require(data, columns, model):
diff --git a/cpm/applications/_sessions.py b/cpm/applications/_sessions.py
index 2a7b630..49a0746 100644
--- a/cpm/applications/_sessions.py
+++ b/cpm/applications/_sessions.py
@@ -1,21 +1,23 @@
 """
-Session loops of the built-in applications.
+The models of the built-in applications.
 
-Each function computes all trials of one participant for one of the session
-applications (`RLRWSession`, `HybridMBMFSession`, `PTSMSession`,
-`PTSM1992Session` and `PTSM2025Session`), from plain floats and numpy arrays.
-They repeat the per-trial models of the applications step by step, using the
-kernels of `cpm.models.kernels`, and are compiled with numba as a whole when
-numba is available. `cpm.core._jit.kernels` loads this module either compiled
-or as plain Python.
+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
-per-trial applications.
+former per-trial implementations of the applications.
 """
 
+import math
+
 import numpy as np
 
 from ..core import _jit
@@ -251,7 +253,13 @@ def ptsm2025(eta, phi_gain, phi_loss, temperature, alpha, safe, risky, probabili
         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
-        p = logistic((temperature * u_risk + phi) - temperature * u_safe)
+        risky_term = temperature * u_risk + phi
+        safe_term = temperature * u_safe
+        if -700.0 < risky_term < 700.0 and -700.0 < safe_term < 700.0:
+            ## the formula of PTSM2025
+            p = math.exp(risky_term) / (math.exp(risky_term) + math.exp(safe_term))
+        else:
+            p = logistic(risky_term - safe_term)
         pair[0] = 1 - p
         pair[1] = p
         out_policy[t] = p
diff --git a/cpm/applications/decision_making.py b/cpm/applications/decision_making.py
index 8ffbed4..d18602f 100644
--- a/cpm/applications/decision_making.py
+++ b/cpm/applications/decision_making.py
@@ -1,15 +1,11 @@
-import copy
 import numpy as np
 import warnings
-from cpm.generators import Wrapper, SessionWrapper, Parameters, Value
-from cpm.core._jit import resolve_backend
-from cpm.applications._backend import SessionModel, prepared, require, uniforms
-from cpm.models.decision import Softmax
-from cpm.models.activation import ProspectUtility
+from cpm.generators import Wrapper, Parameters, Value
+from cpm.applications._backend import Application, SessionModel, prepared, require, uniforms
 
 
 def _ptsm_parameters(parameters_settings, utility_curve, weighting):
-    """The parameters of `PTSM` and `PTSMSession`."""
+    """The parameters of `PTSM`."""
     # Use default parameter settings if none provided.
     if parameters_settings is None:
         parameters_settings = {
@@ -66,7 +62,7 @@ def _ptsm_parameters(parameters_settings, utility_curve, weighting):
 
 
 def _ptsm1992_parameters(parameters_settings, utility_curve, weighting):
-    """The parameters of `PTSM1992` and `PTSM1992Session`."""
+    """The parameters of `PTSM1992`."""
     # Use default parameter settings if none provided.
     if parameters_settings is None:
         parameters_settings = {
@@ -143,7 +139,7 @@ def _ptsm2025_transform(x, alpha):
 
 
 def _ptsm2025_parameters(parameters_settings, utility_curve, variant):
-    """The parameters of `PTSM2025` and `PTSM2025Session`."""
+    """The parameters of `PTSM2025`."""
     if parameters_settings is None:
         warnings.warn("No parameters specified, using JAGS-inspired defaults.", stacklevel=3)
         parameters_settings = {
@@ -208,7 +204,122 @@ def _ptsm2025_parameters(parameters_settings, utility_curve, variant):
     return parameters
 
 
-class PTSM(Wrapper):
+
+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"] = np.ascontiguousarray(out["observed"], dtype=np.int64)
+        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(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.
     
@@ -306,6 +417,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.
@@ -330,71 +445,16 @@ def __init__(
         weighting="tk"  # Options: "tk" or "power"
     ):
         params = _ptsm_parameters(parameters_settings, utility_curve, weighting)
-
-        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)
+        self._setup(
+            data=data,
+            parameters=params,
+            session_model=_ProspectModel(weighting, generate, choose_always=False,
+                                         dependent_chosen=True, separate=False),
+            prepare=_PrepareRisky(RISKY_COLUMNS, "PTSM"),
+        )
 
 
-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.
 
@@ -507,6 +567,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.
@@ -530,74 +594,16 @@ def __init__(
         weighting="tk"  # Options: "tk" or "power"
     ):
         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).
 
@@ -683,10 +689,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,
@@ -696,321 +707,9 @@ def __init__(
     ):
         self.variant = variant
         parameters = _ptsm2025_parameters(parameters_settings, utility_curve, variant)
-
-        # 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)
-
-
-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"] = np.ascontiguousarray(out["observed"], dtype=np.int64)
-        return out
-
-
-RISKY_COLUMNS = ["safe_magnitudes", "risky_magnitudes", "risky_probability"]
-
-
-class _ProspectModel(SessionModel):
-    """The session model function of `PTSMSession` and `PTSM1992Session`."""
-
-    def __init__(self, backend, weighting, generate, choose_always, dependent_chosen, separate):
-        super().__init__(backend)
-        self.weighting = _weighting_code(weighting)
-        self.generate = generate
-        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 PTSMSession(SessionWrapper):
-    r"""
-    The session version of :class:`PTSM`: the same model, computed for all trials of a participant at once.
-
-    It takes the same arguments as :class:`PTSM`, has the same parameters and
-    priors, gives the same results, and has the same output in `export()`, but
-    runs the whole session in one call, compiled with numba if it is available
-    (see :class:`cpm.generators.SessionWrapper`).
-
-    Parameters
-    ----------
-    data : pandas.DataFrame or dict
-        The data, with the columns 'safe_magnitudes', 'risky_magnitudes',
-        'risky_probability' and 'observed'.
-    parameters_settings : dict, optional
-        The initial values and bounds of the parameters, as for :class:`PTSM`.
-    generate : bool
-        If True, choices are sampled from the policy.
-    utility_curve : callable, optional
-        As for :class:`PTSM`, which stores it but does not use it; neither does
-        this class.
-    weighting : str
-        The probability weighting function: "tk" (default), "power", "prelec" or "gw".
-    backend : str
-        "auto" (numba if it is installed, plain Python otherwise), "numba" or "python".
-
-    Notes
-    -----
-    The softmax is computed so that it cannot overflow, which is where it can
-    differ from :class:`PTSM`; everywhere else the two agree to within rounding
-    error. With `generate`, choices are sampled from `numpy.random` as in
-    :class:`PTSM`, so a simulation with a given `numpy.random.seed` makes the same
-    choices with both classes and both backends.
-
-    See Also
-    --------
-    cpm.applications.decision_making.PTSM : the per-trial version, with the model specification.
-    """
-
-    def __init__(self, data=None, parameters_settings=None, generate=False,
-                 utility_curve=None, weighting="tk", backend="auto"):
-        parameters = _ptsm_parameters(parameters_settings, utility_curve, weighting)
-        self.backend = resolve_backend(backend)
-        self.generate = generate
-        super().__init__(
-            model=_ProspectModel(self.backend, weighting, generate, choose_always=False,
-                                 dependent_chosen=True, separate=False),
-            data=data,
-            parameters=parameters,
-            prepare=_PrepareRisky(RISKY_COLUMNS, "PTSMSession"),
-        )
-
-
-class PTSM1992Session(SessionWrapper):
-    r"""
-    The session version of :class:`PTSM1992`: the same model, computed for all trials of a participant at once.
-
-    It takes the same arguments as :class:`PTSM1992`, has the same parameters and
-    priors, gives the same results, and has the same output in `export()`, but
-    runs the whole session in one call, compiled with numba if it is available
-    (see :class:`cpm.generators.SessionWrapper`).
-
-    Parameters
-    ----------
-    data : pandas.DataFrame or dict
-        The data, with the columns 'safe_magnitudes', 'risky_magnitudes',
-        'risky_probability' and 'observed'.
-    parameters_settings : dict, optional
-        The initial values and bounds of the parameters, as for :class:`PTSM1992`.
-    utility_curve : callable, optional
-        A utility curve that replaces the power utility, called as
-        :class:`PTSM1992` calls it. It runs as plain Python on every trial, so a
-        model with a utility curve is slower than one without.
-    weighting : str
-        The probability weighting function: "tk" (default), "power", "prelec" or "gw".
-    backend : str
-        "auto" (numba if it is installed, plain Python otherwise), "numba" or "python".
-
-    Notes
-    -----
-    Like :class:`PTSM1992`, the model samples a choice from its policy on every
-    trial (the `chosen` and `is_optimal` outputs), also when it is fitted, and
-    it does so from `numpy.random` in the same way, so both classes and both
-    backends make the same choices for a given `numpy.random.seed`. The softmax
-    is computed so that it cannot overflow, which is where it can differ from
-    :class:`PTSM1992`; everywhere else the two agree to within rounding error.
-
-    See Also
-    --------
-    cpm.applications.decision_making.PTSM1992 : the per-trial version, with the model specification.
-    """
-
-    def __init__(self, data=None, parameters_settings=None, utility_curve=None,
-                 weighting="tk", backend="auto"):
-        parameters = _ptsm1992_parameters(parameters_settings, utility_curve, weighting)
-        self.backend = resolve_backend(backend)
-        super().__init__(
-            model=_ProspectModel(self.backend, weighting, generate=False, choose_always=True,
-                                 dependent_chosen=False, separate=True),
-            data=data,
-            parameters=parameters,
-            prepare=_PrepareRisky(RISKY_COLUMNS, "PTSM1992Session"),
-        )
-
-
-class _PTSM2025Model(SessionModel):
-    """The session model function of `PTSM2025Session`."""
-
-    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 PTSM2025Session(SessionWrapper):
-    r"""
-    The session version of :class:`PTSM2025`: the same model, computed for all trials of a participant at once.
-
-    It takes the same arguments as :class:`PTSM2025`, has the same parameters and
-    priors, gives the same results, and has the same output in `export()`, but
-    runs the whole session in one call, compiled with numba if it is available
-    (see :class:`cpm.generators.SessionWrapper`).
-
-    Parameters
-    ----------
-    data : pandas.DataFrame or dict
-        The data, with the columns 'safe_magnitudes', 'risky_magnitudes',
-        'risky_probability', 'ambiguity' and 'observed'.
-    parameters_settings : dict, optional
-        The initial values and bounds of the parameters, as for :class:`PTSM2025`.
-    utility_curve : callable, optional
-        As for :class:`PTSM2025`, which checks it but uses the power utility
-        regardless; so does this class.
-    variant : str
-        "alpha" (default) to fit the utility curvature, or "standard" to fix it at 1.
-    backend : str
-        "auto" (numba if it is installed, plain Python otherwise), "numba" or "python".
-
-    Notes
-    -----
-    Like :class:`PTSM2025`, the model samples a choice on every trial
-    (`model_choice`), from `numpy.random` in the same way, so both classes and
-    both backends make the same choices for a given `numpy.random.seed`. The
-    policy is computed as a logistic function, which cannot overflow; where the
-    exponentials of :class:`PTSM2025` overflow, it returns NaN and fails to sample
-    a choice, whereas this class returns the limiting probability. Everywhere
-    else the two agree to within rounding error.
-
-    See Also
-    --------
-    cpm.applications.decision_making.PTSM2025 : the per-trial version, with the model specification.
-    """
-
-    def __init__(self, data=None, parameters_settings=None, utility_curve=None,
-                 variant="alpha", backend="auto"):
-        self.variant = variant
-        parameters = _ptsm2025_parameters(parameters_settings, utility_curve, variant)
-        self.backend = resolve_backend(backend)
-        super().__init__(
-            model=_PTSM2025Model(self.backend),
+        self._setup(
             data=data,
             parameters=parameters,
-            prepare=_PrepareRisky(RISKY_COLUMNS + ["ambiguity"], "PTSM2025Session"),
+            session_model=_PTSM2025Model(),
+            prepare=_PrepareRisky(RISKY_COLUMNS + ["ambiguity"], "PTSM2025"),
         )
diff --git a/cpm/applications/reinforcement_learning.py b/cpm/applications/reinforcement_learning.py
index 48bdf2b..cf3f134 100644
--- a/cpm/applications/reinforcement_learning.py
+++ b/cpm/applications/reinforcement_learning.py
@@ -1,18 +1,14 @@
-from cpm.generators import Wrapper, SessionWrapper, Parameters, Value
-from cpm.core._jit import resolve_backend
-from cpm.applications._backend import (
-    SessionModel, ordered_columns, prepared, require, uniforms,
-)
-
-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 Wrapper, Parameters, Value
+from cpm.applications._backend import (
+    Application, SessionModel, ordered_columns, prepared, require, uniforms,
+)
 
 
 def _rlrw_parameters(parameters_settings, dimensions):
-    """The parameters of `RLRW` and `RLRWSession`."""
+    """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)
@@ -37,7 +33,7 @@ def _rlrw_parameters(parameters_settings, dimensions):
 
 
 def _hybrid_parameters(parameters_settings, q_init):
-    """The parameters of `HybridMBMF` and `HybridMBMFSession`."""
+    """The parameters of `HybridMBMF`."""
     if parameters_settings is None:
         parameters_settings = [
             [2, 0, 5],
@@ -76,6 +72,7 @@ def _hybrid_parameters(parameters_settings, q_init):
     )
 
 
+
 HYBRID_PARAMETERS = [
     "inv_temperature",
     "learning_rate",
@@ -86,8 +83,53 @@ def _hybrid_parameters(parameters_settings, q_init):
 ]
 
 
+class _RLRWModel(SessionModel):
+    """The model function of `RLRW`, for all trials at once."""
 
-class RLRW(Wrapper):
+    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"] = numpy.ascontiguousarray(
+        numpy.column_stack([out[c] for c in arms]), dtype=numpy.int64
+    )
+    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"] = numpy.ascontiguousarray(response, dtype=numpy.int64)
+    return out
+
+
+
+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.
@@ -148,6 +190,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
     ----------
 
@@ -165,82 +211,87 @@ class RLRW(Wrapper):
 
     """
 
+    _trial_shapes = {"change": (1, -1)}
+
     def __init__(
         self, data=None, dimensions=2, parameters_settings=None, generate=False
     ):
         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
+
+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] = numpy.ascontiguousarray(
+                out.get(key, numpy.zeros(trials)), dtype=numpy.int64
             )
-            teacher = feedback[choice]  ## get reward for that bandit
-            update = cpm.models.learning.SeparableRule(
-                weights=values, feedback=[teacher], input=mute, alpha=alpha
+        for key in ("reward", "reward_0", "reward_1"):
+            out[key] = numpy.ascontiguousarray(
+                out.get(key, numpy.zeros(trials)), dtype=numpy.float64
             )
-            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
+        out["position"] = numpy.ascontiguousarray(
+            out.get("position", out["stimuli_first"] ^ out["action"]), dtype=numpy.int64
+        )
+        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.
@@ -329,6 +380,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
     ----------
 
@@ -342,316 +397,9 @@ class HybridMBMF(Wrapper):
 
     def __init__(self, data=None, parameters_settings=None, q_init=0.5, generate=False):
         parameters = _hybrid_parameters(parameters_settings, q_init)
-        ## 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)
-
-
-class _RLRWModel(SessionModel):
-    """The session model function of `RLRWSession`."""
-
-    def __init__(self, backend, generate):
-        super().__init__(backend)
-        self.generate = generate
-
-    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(
-            "RLRWSession 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"] = numpy.ascontiguousarray(
-        numpy.column_stack([out[c] for c in arms]), dtype=numpy.int64
-    )
-    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"] = numpy.ascontiguousarray(response, dtype=numpy.int64)
-    return out
-
-
-class RLRWSession(SessionWrapper):
-    r"""
-    The session version of :class:`RLRW`: the same model, computed for all trials of a participant at once.
-
-    It takes the same arguments as :class:`RLRW`, has the same parameters and
-    priors, gives the same results, and has the same output in `export()`, but
-    runs the whole session in one call, compiled with numba if it is available
-    (see :class:`cpm.generators.SessionWrapper`).
-
-    Parameters
-    ----------
-    data : pandas.DataFrame or dict
-        The data, as for :class:`RLRW`.
-    dimensions : int
-        The number of distinct stimuli present in the data.
-    parameters_settings : list-like
-        The initial values and bounds of the parameters, as for :class:`RLRW`.
-    generate : bool
-        If True, choices are sampled from the policy instead of taken from the data.
-    backend : str
-        "auto" (numba if it is installed, plain Python otherwise), "numba" or "python".
-
-    Notes
-    -----
-    The softmax is computed so that it cannot overflow. Where :class:`RLRW`
-    replaces an overflowed policy (with a warning), the two differ; everywhere
-    else they agree to within rounding error. With `generate`, the choices are
-    sampled from `numpy.random` as in :class:`RLRW`, so a simulation with a given
-    `numpy.random.seed` makes the same choices with both classes and both backends.
-
-    See Also
-    --------
-    cpm.applications.reinforcement_learning.RLRW : the per-trial version, with the model specification.
-
-    Examples
-    --------
-    >>> from cpm.applications.reinforcement_learning import RLRWSession
-    >>> from cpm.datasets import load_bandit_data
-    >>> data = load_bandit_data()
-    >>> model = RLRWSession(data=data[data.ppt == 1], dimensions=4)
-    >>> model.run()
-    >>> model.export().head()
-    """
-
-    def __init__(
-        self, data=None, dimensions=2, parameters_settings=None, generate=False, backend="auto"
-    ):
-        parameters = _rlrw_parameters(parameters_settings, dimensions)
-        self.backend = resolve_backend(backend)
-        self.generate = generate
-        super().__init__(
-            model=_RLRWModel(self.backend, generate),
-            data=data,
-            parameters=parameters,
-            prepare=_prepare_rlrw,
-        )
-
-
-class _HybridModel(SessionModel):
-    """The session model function of `HybridMBMFSession`."""
-
-    def __init__(self, backend, generate):
-        super().__init__(backend)
-        self.generate = generate
-
-    def __call__(self, parameters, data):
-        trials = data["s1"].shape[0]
-        out = self.sessions.hybrid_mbmf(
-            *(float(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 `HybridMBMFSession`, filling in the optional columns once."""
-
-    def __init__(self, generate):
-        self.generate = generate
-
-    def __call__(self, data):
-        out = prepared(data)
-        require(out, ["s1"], "HybridMBMFSession")
-        needed = ["reward_0", "reward_1"] if self.generate else ["action", "s2", "reward"]
-        require(out, needed, "HybridMBMFSession")
-        trials = out["s1"].shape[0]
-        for key in ("s1", "stimuli_first", "action", "s2"):
-            out[key] = numpy.ascontiguousarray(
-                out.get(key, numpy.zeros(trials)), dtype=numpy.int64
-            )
-        for key in ("reward", "reward_0", "reward_1"):
-            out[key] = numpy.ascontiguousarray(
-                out.get(key, numpy.zeros(trials)), dtype=numpy.float64
-            )
-        out["position"] = numpy.ascontiguousarray(
-            out.get("position", out["stimuli_first"] ^ out["action"]), dtype=numpy.int64
-        )
-        return out
-
-
-class HybridMBMFSession(SessionWrapper):
-    r"""
-    The session version of :class:`HybridMBMF`: the same model, computed for all trials of a participant at once.
-
-    It takes the same arguments as :class:`HybridMBMF`, has the same parameters,
-    priors and initial states, gives the same results, and has the same output in
-    `export()`, but runs the whole session in one call, compiled with numba if it
-    is available (see :class:`cpm.generators.SessionWrapper`).
-
-    Parameters
-    ----------
-    data : pandas.DataFrame or dict
-        The data, with the columns described for :class:`HybridMBMF`.
-    parameters_settings : list-like
-        The initial values and bounds of the parameters, as for :class:`HybridMBMF`.
-    q_init : float
-        The initial value of all model-free and second-stage values. Default is 0.5.
-    generate : bool
-        If True, first-stage actions are sampled from the policy, and rewards are
-        taken from `reward_0` and `reward_1`.
-    backend : str
-        "auto" (numba if it is installed, plain Python otherwise), "numba" or "python".
-
-    Notes
-    -----
-    The softmax is computed so that it cannot overflow, which is where it can
-    differ from :class:`HybridMBMF`; everywhere else the two agree to within
-    rounding error. With `generate`, actions are sampled from `numpy.random` as
-    in :class:`HybridMBMF`, so a simulation with a given `numpy.random.seed` makes
-    the same choices with both classes and both backends.
-
-    See Also
-    --------
-    cpm.applications.reinforcement_learning.HybridMBMF : the per-trial version, with the model specification.
-    """
-
-    def __init__(self, data=None, parameters_settings=None, q_init=0.5, generate=False,
-                 backend="auto"):
-        parameters = _hybrid_parameters(parameters_settings, q_init)
-        self.backend = resolve_backend(backend)
-        self.generate = generate
-        super().__init__(
-            model=_HybridModel(self.backend, generate),
+        self._setup(
             data=data,
             parameters=parameters,
+            session_model=_HybridModel(generate),
             prepare=_PrepareHybrid(generate),
         )
diff --git a/cpm/core/_jit.py b/cpm/core/_jit.py
index 600081b..6e78f18 100644
--- a/cpm/core/_jit.py
+++ b/cpm/core/_jit.py
@@ -7,12 +7,11 @@
 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, whatever
-is installed. 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. That is what `backend="python"` of
-the session models uses, for example to debug a model or to check the compiled
-version against it.
+`kernels` returns such a module either compiled or as plain Python. With numba
+installed, 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 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``).
@@ -104,7 +103,8 @@ def resolve_backend(backend):
     ----------
     backend : str
         ``"auto"`` (numba if it is installed and not disabled, plain Python
-        otherwise), ``"numba"`` or ``"python"``.
+        otherwise), ``"numba"`` or ``"python"``. The built-in applications use
+        ``"auto"``, so that installing numba is all it takes to compile them.
 
     Returns
     -------
@@ -116,9 +116,9 @@ def resolve_backend(backend):
     if backend == "numba":
         if not HAVE_NUMBA:
             raise ImportError(
-                "backend='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), or use backend='python' or 'auto'."
+                "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":
diff --git a/cpm/generators/_fast_priors.py b/cpm/generators/_fast_priors.py
index f403604..c4a52b5 100644
--- a/cpm/generators/_fast_priors.py
+++ b/cpm/generators/_fast_priors.py
@@ -1,12 +1,14 @@
 """
-Closed-form log densities for the prior distributions cpm builds.
+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 checking. For the distribution families that `Value` builds
-from a string (and the same families when they are passed in as frozen scipy
-distributions), the log density at a point inside the support is a short
-closed-form kernel plus a constant. This module evaluates that instead.
+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
@@ -19,22 +21,45 @@
 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"
 
-## kernels of the log density in the standardised variable y = (x - loc) / scale,
-## up to a constant, keyed by scipy distribution name
-_KERNELS = {
-    "norm": lambda y, shapes: -0.5 * y * y,
-    "truncnorm": lambda y, shapes: -0.5 * y * y,
-    "uniform": lambda y, shapes: 0.0,
-    "gamma": lambda y, shapes: (shapes[0] - 1.0) * math.log(y) - y,
-    "beta": lambda y, shapes: (shapes[0] - 1.0) * math.log(y)
-    + (shapes[1] - 1.0) * math.log1p(-y),
-    "truncexpon": lambda y, shapes: -y,
+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],
 }
 
 
@@ -52,26 +77,20 @@ def _support(name, shapes):
 
 
 class _Evaluator:
-    """The closed-form log density of one frozen distribution with fixed arguments."""
+    """The log density of one frozen distribution with fixed arguments."""
 
-    __slots__ = ("args", "kwds", "loc", "scale", "shapes", "kernel", "low", "high", "const")
+    __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 = float(loc), float(scale)
-        self.shapes = tuple(float(s) for s in shapes)
-        self.kernel = _KERNELS[name]
-        self.low, self.high = _support(name, self.shapes)
-        ## the normalising constant, taken from scipy at the median, which lies
-        ## inside the support for all of the families above
-        median = float(prior.median())
-        reference = float(prior.logpdf(median))
-        y = (median - self.loc) / self.scale
-        if not (self.low < y < self.high) or not math.isfinite(reference):
-            raise ValueError("no interior reference point")
-        self.const = reference - self.kernel(y, self.shapes)
+        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:
@@ -82,7 +101,7 @@ def valid(self, prior):
     def __call__(self, x):
         y = (x - self.loc) / self.scale
         if self.low < y < self.high:
-            return self.kernel(y, self.shapes) + self.const
+            return self.logpdf(y, self.constants) - self.log_scale
         return None
 
 
@@ -101,7 +120,7 @@ def _evaluator(prior):
         return cached
     dist = getattr(prior, "dist", None)
     name = getattr(dist, "name", None)
-    if name not in _KERNELS or not hasattr(prior, "kwds") or not hasattr(prior, "args"):
+    if name not in _LOGPDF or not hasattr(prior, "kwds") or not hasattr(prior, "args"):
         try:
             setattr(prior, _CACHE, False)
         except AttributeError:
@@ -135,13 +154,13 @@ def fast_logpdf(prior, x):
     Returns
     -------
     numpy.float64 or None
-        The log density, equal to `prior.logpdf(x)` to within rounding error, or
-        None if the caller has to ask `prior.logpdf` itself.
+        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(float(x))
+    value = evaluator(np.float64(x))
     return None if value is None else np.float64(value)
diff --git a/cpm/generators/session.py b/cpm/generators/session.py
index 9df584b..5ac9961 100644
--- a/cpm/generators/session.py
+++ b/cpm/generators/session.py
@@ -109,9 +109,9 @@ class SessionWrapper(Wrapper):
         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 set, and not on every run. The default is
-        :func:`session_data`, which returns a dictionary of contiguous numpy arrays,
-        one per column.
+        is called once, when the data are first needed (and again after new data are
+        set with `reset`), not on every run. The default is :func:`session_data`,
+        which returns a dictionary of contiguous numpy arrays, one per column.
 
     Notes
     -----
@@ -130,7 +130,8 @@ class SessionWrapper(Wrapper):
     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`.
+    `Wrapper`, see :func:`session_export`. The outputs of the last run are in
+    `session_output`, one array per output.
 
     Examples
     --------
@@ -162,7 +163,21 @@ 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 = self.prepare(data)
+        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
+
+    def _run_session(self):
+        """Call the model function on all trials; subclasses can compute the run differently."""
+        return self.model(parameters=self.parameters, data=self.session)
 
     def run(self):
         """
@@ -172,7 +187,7 @@ def run(self):
         -------
         None
         """
-        output = self.model(parameters=self.parameters, data=self.session)
+        output = self._run_session()
         dependent = output.get("dependent")
         if dependent is not None:
             dependent = np.asarray(dependent, dtype=float)
@@ -184,6 +199,7 @@ def run(self):
                     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
@@ -208,7 +224,8 @@ def reset(self, parameters=None, data=None):
         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.
+            New data for the model, which are passed through `prepare` once, when
+            they are first needed.
 
         Notes
         -----
@@ -222,8 +239,9 @@ def reset(self, parameters=None, data=None):
         super().reset(parameters=parameters, data=data)
         if was_run:
             self.simulation = {}
+            self.session_output = {}
         if data is not None:
-            self.session = self.prepare(data)
+            self._prepared = None
         return None
 
     def export(self):
@@ -236,4 +254,4 @@ def export(self):
             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.simulation, self.__len__)
+        return session_export(self.session_output, self.__len__)
diff --git a/cpm/models/kernels.py b/cpm/models/kernels.py
index 3a55815..bca203b 100644
--- a/cpm/models/kernels.py
+++ b/cpm/models/kernels.py
@@ -104,7 +104,10 @@ def softmax(values, beta):
     The softmax policy, :math:`e^{\beta x_i} / \sum_j e^{\beta x_j}`.
 
     As :class:`cpm.models.decision.Softmax` (``Softmax(temperature=beta,
-    activations=values).compute()``), without overflow.
+    activations=values).compute()``), with the same formula: the exponentials of
+    the scaled activations divided by their sum, or, where the largest scaled
+    activation is beyond ±700 and the exponentials would overflow (or all
+    underflow), the same function with the largest one subtracted first.
 
     Parameters
     ----------
@@ -124,9 +127,10 @@ def softmax(values, beta):
         scaled[i] = values[i] * beta
         if scaled[i] > top:
             top = scaled[i]
+    shift = 0.0 if -700.0 < top < 700.0 else top
     total = 0.0
     for i in range(n):
-        scaled[i] = math.exp(scaled[i] - top)
+        scaled[i] = math.exp(scaled[i] - shift)
         total += scaled[i]
     for i in range(n):
         scaled[i] /= total
diff --git a/docs/api/applications.rst b/docs/api/applications.rst
index 076a83f..68c618a 100644
--- a/docs/api/applications.rst
+++ b/docs/api/applications.rst
@@ -5,9 +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. Each of them has a session version (named with
-``Session`` appended), which gives the same results many times faster; see
-:doc:`/how-to/fast-session-models`.
+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
 ----------------------
@@ -17,9 +16,7 @@ Reinforcement learning
    :nosignatures:
 
    reinforcement_learning.RLRW
-   reinforcement_learning.RLRWSession
    reinforcement_learning.HybridMBMF
-   reinforcement_learning.HybridMBMFSession
 
 Decision making
 ---------------
@@ -29,11 +26,8 @@ Decision making
    :nosignatures:
 
    decision_making.PTSM
-   decision_making.PTSMSession
    decision_making.PTSM1992
-   decision_making.PTSM1992Session
    decision_making.PTSM2025
-   decision_making.PTSM2025Session
 
 Metacognition
 -------------
diff --git a/docs/get-started/installation.md b/docs/get-started/installation.md
index 6501012..5fc4853 100644
--- a/docs/get-started/installation.md
+++ b/docs/get-started/installation.md
@@ -54,6 +54,16 @@ import cpm
 print(cpm.__version__)
 ```
 
+## Faster fitting with numba
+
+The built-in models run many times faster when [numba](https://numba.pydata.org/) is installed, which compiles them. It is optional; install it with cpm:
+
+```bash
+pip install "cpm-toolbox[numba]"
+```
+
+Nothing else changes: cpm uses numba if it can import it, and otherwise runs the same models as plain Python, with the same results. See {doc}`/how-to/fast-session-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/how-to/fast-session-models.md b/docs/how-to/fast-session-models.md
index 8044ad5..e02ac29 100644
--- a/docs/how-to/fast-session-models.md
+++ b/docs/how-to/fast-session-models.md
@@ -1,85 +1,59 @@
-# Speed up fitting with session models
+# 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. A {py:class}`~cpm.generators.SessionWrapper` calls the model function once for all trials of a participant instead, and with [numba](https://numba.pydata.org/) the loop over trials can be compiled as a whole. For the built-in applications, this makes one evaluation of the objective function 35 to 120 times faster, and a fit correspondingly faster.
-
-## Use the session version of a built-in application
-
-Every application in {py:mod}`cpm.applications` that is a `Wrapper` has a session version, named after it with `Session` appended:
-
-| Per-trial | Session version |
-|---|---|
-| {py:class}`~cpm.applications.reinforcement_learning.RLRW` | {py:class}`~cpm.applications.reinforcement_learning.RLRWSession` |
-| {py:class}`~cpm.applications.reinforcement_learning.HybridMBMF` | {py:class}`~cpm.applications.reinforcement_learning.HybridMBMFSession` |
-| {py:class}`~cpm.applications.decision_making.PTSM` | {py:class}`~cpm.applications.decision_making.PTSMSession` |
-| {py:class}`~cpm.applications.decision_making.PTSM1992` | {py:class}`~cpm.applications.decision_making.PTSM1992Session` |
-| {py:class}`~cpm.applications.decision_making.PTSM2025` | {py:class}`~cpm.applications.decision_making.PTSM2025Session` |
-
-A session version takes the same arguments, has the same parameters and priors, gives the same results and the same `export()`, and works with the optimisers, {py:class}`~cpm.generators.Simulator` and {py:mod}`cpm.hierarchical` in the same way. Swap the class and nothing else changes:
-
-```python
-from cpm.applications.reinforcement_learning import RLRWSession
-from cpm.datasets import load_bandit_data
-from cpm.optimisation import FminBound, minimise
-
-data = load_bandit_data()
-data["observed"] = data["response"]
-
-model = RLRWSession(data=data[data.ppt == 1], dimensions=4)  # was: RLRW(...)
-fit = FminBound(
-    model=model,
-    data=data.groupby("ppt"),
-    minimisation=minimise.LogLikelihood.bernoulli,
-    prior=True,
-    number_of_starts=5,
-    ppt_identifier="ppt",
-    approx_grad=True,
-)
-fit.optimise()
-```
+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
 
-The session versions run without numba, as plain Python, which is already 8 to 15 times faster than the per-trial applications. Compiled with numba, they are 3 to 16 times faster again. numba is an optional dependency:
+numba is an optional dependency. Install it with cpm:
 
 ```bash
 pip install cpm-toolbox[numba]
 ```
 
-numba supports a new NumPy release some time after it comes out, and does not support PyPy. If numba cannot be imported, for either reason, cpm uses the plain-Python version without further notice.
-
-Choose between the two with `backend`:
-
-- `backend="auto"` (the default) uses numba if it is available and plain Python otherwise.
-- `backend="numba"` requires numba and raises an error without it.
-- `backend="python"` never compiles. Use it to debug a model, or to check a result against the compiled version.
-
-Both backends give the same results, to within rounding error.
+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 cannot be imported, for either reason, cpm uses plain Python without further notice.
 
 ## 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 | Per-trial | Session, Python | Session, numba |
+| Application | Trials | Without numba | With numba | Per trial, in a `Wrapper` |
 |---|---:|---:|---:|---:|
-| `RLRW` | 71 | 3.5 ms | 0.42 ms | 0.05 ms |
-| `HybridMBMF` | 200 | 10 ms | 1.4 ms | 0.09 ms |
-| `PTSM` | 40 | 2.0 ms | 0.22 ms | 0.06 ms |
-| `PTSM1992` | 40 | 2.6 ms | 0.26 ms | 0.07 ms |
-| `PTSM2025` | 40 | 2.2 ms | 0.15 ms | 0.06 ms |
+| `RLRW` | 71 | 0.40 ms | 0.06 ms | 3.6 ms |
+| `HybridMBMF` | 200 | 1.4 ms | 0.09 ms | 11 ms |
+| `PTSM` | 40 | 0.28 ms | 0.06 ms | 2.0 ms |
+| `PTSM1992` | 40 | 0.27 ms | 0.07 ms | 2.1 ms |
+| `PTSM2025` | 40 | 0.16 ms | 0.06 ms | 1.8 ms |
+
+With numba, the model itself takes 0.01 to 0.03 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).
 
-With numba, the model itself takes 0.01 to 0.03 ms of this, and the loss function about 0.02 ms.
+The first time an application runs with numba, numba compiles it, which takes 0.5 to 2.5 seconds. 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.
 
-The first time a session model runs, numba compiles it, which takes 0.5 to 2.5 seconds. 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.
+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 session versions draw one uniform random number per trial from `numpy.random` before the loop and turn it into a choice exactly as `numpy.random.choice` does. A simulation after `numpy.random.seed(...)` therefore makes the same choices with the per-trial application, the session version and both backends.
+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.
 
-## Where results can differ
+## Extend an application trial by trial
 
-The session versions compute softmax and logistic probabilities in a way that cannot overflow. Where the per-trial applications overflow (an inverse temperature times a value above about 709), they return NaN or replace it, and the two differ; everywhere else they agree to within rounding error.
+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()
+```
 
-Where a predicted probability comes within about $10^{-6}$ of 0 or 1, rounding errors of order $10^{-16}$ in the probability become relative errors of order $10^{-16}/(1 - p)$ in its log likelihood, in both versions. Their log likelihoods can then differ in the 8th or 10th significant digit instead of the 12th.
+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
 
diff --git a/docs/how-to/index.md b/docs/how-to/index.md
index ac169a6..0586bc0 100644
--- a/docs/how-to/index.md
+++ b/docs/how-to/index.md
@@ -5,11 +5,11 @@ 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 session models
+:::{grid-item-card} {fas}`bolt` Speed up fitting with numba
 :link: fast-session-models
 :link-type: doc
 
-Fit the built-in models 50 to 200 times faster, and compile your own models with numba.
+Install numba to fit the built-in models many times faster, and compile your own models too.
 :::
 
 :::{grid-item-card} {fas}`gauge-high` Parallelise model fitting
diff --git a/scripts/local_tests.py b/scripts/local_tests.py
index 082afae..627628a 100644
--- a/scripts/local_tests.py
+++ b/scripts/local_tests.py
@@ -8,8 +8,8 @@
 
 - with numba, if it is installed in that environment;
 - with ``CPM_DISABLE_JIT=1``, as if numba were not installed, which runs the
-  session models as plain Python;
-- with ``NUMBA_DISABLE_JIT=1``, numba's own switch, for the kernel and session
+  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
@@ -28,7 +28,7 @@
 import sys
 
 ROOT = pathlib.Path(__file__).resolve().parents[1]
-FAST = ["test/models/test_kernels.py", "test/applications/test_sessions.py"]
+FAST = ["test/models/test_kernels.py", "test/applications/test_backends.py"]
 
 
 def run(python, environment, tests, label):
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 0000000000000000000000000000000000000000..62ac8f415cdac297356bdc3a30fbf071400d57e4
GIT binary patch
literal 80786
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

literal 0
HcmV?d00001

diff --git a/test/applications/test_backends.py b/test/applications/test_backends.py
new file mode 100644
index 0000000..d8af82c
--- /dev/null
+++ b/test/applications/test_backends.py
@@ -0,0 +1,270 @@
+"""
+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`.
+"""
+
+import copy
+import gzip
+import os
+import pickle
+import warnings
+
+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 = 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(), 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_exactly(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=True)
+
+
+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_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 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_sessions.py b/test/applications/test_sessions.py
deleted file mode 100644
index 59d37b7..0000000
--- a/test/applications/test_sessions.py
+++ /dev/null
@@ -1,243 +0,0 @@
-"""
-The session versions of the built-in applications give the same results as
-the per-trial applications, on both backends: the same dependent variable,
-export (columns, types and values), objective function and simulations.
-"""
-
-import copy
-import warnings
-
-import numpy as np
-import pandas as pd
-import pytest
-
-from cpm.applications.decision_making import (
-    PTSM, PTSM1992, PTSM2025, PTSM1992Session, PTSM2025Session, PTSMSession,
-)
-from cpm.applications.reinforcement_learning import (
-    RLRW, HybridMBMF, HybridMBMFSession, RLRWSession,
-)
-from cpm.core import _jit
-from cpm.core.optimisers import objective
-from cpm.datasets import load_bandit_data, load_risky_choices
-from cpm.generators import Simulator
-from cpm.optimisation import FminBound, minimise
-
-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, per-trial class, session class, data, keyword arguments, seed or None)
-CASES = [
-    ("RLRW", RLRW, RLRWSession, bandit, dict(dimensions=4, parameters_settings=[[0.3, 0, 1], [4, 0, 10]])),
-    ("RLRW-generate", RLRW, RLRWSession, bandit,
-     dict(dimensions=4, parameters_settings=[[0.3, 0, 1], [4, 0, 10]], generate=True)),
-    ("HybridMBMF", HybridMBMF, HybridMBMFSession, two_step, dict(parameters_settings=HYBRID)),
-    ("HybridMBMF-q_init", HybridMBMF, HybridMBMFSession, two_step,
-     dict(parameters_settings=HYBRID, q_init=4.5)),
-    ("HybridMBMF-generate", HybridMBMF, HybridMBMFSession, two_step,
-     dict(parameters_settings=HYBRID, generate=True)),
-    ("PTSM", PTSM, PTSMSession, risky, dict(parameters_settings=PT)),
-    ("PTSM-power", PTSM, PTSMSession, risky, dict(parameters_settings=PT, weighting="power")),
-    ("PTSM-prelec", PTSM, PTSMSession, risky, dict(parameters_settings=PT, weighting="prelec")),
-    ("PTSM-generate", PTSM, PTSMSession, risky, dict(parameters_settings=PT, generate=True)),
-    ("PTSM1992", PTSM1992, PTSM1992Session, risky, dict(parameters_settings=PT)),
-    ("PTSM1992-gw", PTSM1992, PTSM1992Session, risky, dict(parameters_settings=PT, weighting="gw")),
-    ("PTSM1992-curve", PTSM1992, PTSM1992Session, risky, dict(parameters_settings=PT, utility_curve=cubic)),
-    ("PTSM2025", PTSM2025, PTSM2025Session, risky, dict(parameters_settings=PT)),
-    ("PTSM2025-standard", PTSM2025, PTSM2025Session, risky, dict(parameters_settings=PT, variant="standard")),
-]
-IDS = [case[0] for case in CASES]
-
-
-def build(case, backend):
-    _, trial_class, session_class, data, kwargs = case
-    frame = data()
-    return (trial_class(data=frame, **kwargs), session_class(data=frame, backend=backend, **kwargs),
-            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)
-
-
-@pytest.mark.parametrize("backend", BACKENDS)
-@pytest.mark.parametrize("case", CASES, ids=IDS)
-def test_export_equals_the_per_trial_model(case, backend):
-    trial, session, _ = build(case, backend)
-    for scale in (None, 0.2, 0.7):
-        x = None if scale is None else free_values(trial, scale)
-        for model in (trial, session):
-            np.random.seed(123)
-            model.reset(parameters=x)
-            model.run()
-        expected, got = trial.export(), session.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)
-        np.testing.assert_allclose(session.dependent, trial.dependent, **TOLERANCE)
-        ## the states a run ends with
-        for key in session.parameters.keys():
-            value = session.parameters[key]
-            numeric = isinstance(getattr(value, "value", None), (int, float, np.ndarray, np.number))
-            if numeric and value.prior is None:
-                np.testing.assert_allclose(np.asarray(value.value, float),
-                                           np.asarray(trial.parameters[key].value, float), **TOLERANCE)
-
-
-@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_model(case, backend):
-    """
-    The objective agrees to 1e-12 where the predicted probabilities are not
-    extreme. Where a probability p is within about 1e-6 of 0 or 1, the loss takes
-    log(1 - p), which turns the rounding error of p (of order 1e-16 in either
-    implementation) into a relative error of order 1e-16 / (1 - p); there the
-    two agree to within that bound.
-    """
-    trial, session, observed = build(case, backend)
-    for scale in (0.1, 0.35, 0.5, 0.8):
-        x = free_values(trial, scale)
-        np.random.seed(1)
-        expected = objective(x, trial, observed, minimise.LogLikelihood.bernoulli, True)
-        np.random.seed(1)
-        got = objective(x, session, observed, minimise.LogLikelihood.bernoulli, True)
-        p = np.clip(trial.dependent, 1e-10, 1 - 1e-10)
-        closest = np.min(np.minimum(p, 1 - p))
-        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.skipif(not _jit.JIT_ENABLED, reason="numba is not installed or disabled")
-@pytest.mark.parametrize("case", CASES, ids=IDS)
-def test_backends_agree(case):
-    _, _, session_class, data, kwargs = case
-    frame = data()
-    exports = []
-    for backend in ("python", "numba"):
-        model = session_class(data=frame, backend=backend, **kwargs)
-        np.random.seed(7)
-        model.run()
-        exports.append(model.export())
-    pd.testing.assert_frame_equal(exports[0], exports[1], check_exact=False, rtol=1e-12, atol=1e-12)
-
-
-@pytest.mark.parametrize("backend", BACKENDS)
-def test_simulations_are_reproducible_and_match_the_per_trial_model(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],
-    })
-    out = []
-    for cls, kwargs in ((HybridMBMF, {}), (HybridMBMFSession, {"backend": backend})):
-        wrapper = cls(data=data[data.ppt == 0], parameters_settings=HYBRID, generate=True, **kwargs)
-        simulator = Simulator(wrapper=wrapper, data=data.groupby("ppt"), parameters=draws)
-        np.random.seed(2024)
-        simulator.run()
-        out.append(simulator.export())
-    pd.testing.assert_frame_equal(out[1], out[0], check_exact=False, rtol=1e-12, atol=1e-12)
-
-
-def test_unknown_backend_and_missing_numba(monkeypatch):
-    with pytest.raises(ValueError, match="backend"):
-        RLRWSession(data=bandit(), dimensions=4, backend="cuda")
-    monkeypatch.setattr(_jit, "HAVE_NUMBA", False)
-    monkeypatch.setattr(_jit, "JIT_ENABLED", False)
-    with pytest.raises(ImportError, match="numba"):
-        RLRWSession(data=bandit(), dimensions=4, backend="numba")
-    assert RLRWSession(data=bandit(), dimensions=4, backend="auto").backend == "python"
-
-
-def test_missing_columns_are_named():
-    with pytest.raises(KeyError, match="ambiguity"):
-        PTSM2025Session(data=risky().drop(columns="ambiguity"), parameters_settings=PT)
-    with pytest.raises(KeyError, match="reward_0"):
-        HybridMBMFSession(data=two_step().drop(columns="reward_0"), generate=True)
-
-
-def test_session_models_survive_deepcopy_and_pickling():
-    import pickle
-
-    model = HybridMBMFSession(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)
-
-
-@pytest.mark.skipif(not _jit.JIT_ENABLED, reason="numba is not installed or disabled")
-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=RLRWSession(data=bandit(1), dimensions=4, parameters_settings=[[0.3, 0, 1], [4, 0, 10]],
-                              backend="numba"),
-            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/generators/test_fast_priors.py b/test/generators/test_fast_priors.py
index 3688a94..782ce21 100644
--- a/test/generators/test_fast_priors.py
+++ b/test/generators/test_fast_priors.py
@@ -37,10 +37,7 @@ def test_logpdf_equals_scipy_inside_and_outside_the_support(prior, args, lower,
         value.fill(x)
         expected = value.prior.logpdf(x)
         got = value.PDF(log=True)
-        if np.isfinite(expected):
-            assert got == pytest.approx(expected, rel=1e-12, abs=1e-12)
-        else:
-            assert got == expected
+        assert got == expected  # identical, not only close
         assert isinstance(got, np.float64)
 
 
@@ -59,7 +56,7 @@ def test_logpdf_of_user_supplied_frozen_distributions(frozen):
         expected = frozen.logpdf(x)
         got = fast_logpdf(frozen, x)
         got = frozen.logpdf(x) if got is None else got
-        assert got == pytest.approx(expected, rel=1e-12, abs=1e-12) or got == expected
+        assert got == expected
 
 
 def test_other_priors_and_values_fall_back_to_scipy():

From f7eb422267c3bde252efe61863f4b4e0ddcff821 Mon Sep 17 00:00:00 2001
From: Lenard Dome <23503601+lenarddome@users.noreply.github.com>
Date: Mon, 28 Sep 2026 09:58:54 +0200
Subject: [PATCH 06/34] refactor(models): one formula per building block,
 shared with the compiled loops

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 CHANGELOG.md                          |   4 +-
 benchmarks/results/single-kernels.csv |  16 ++
 cpm/applications/_sessions.py         |  68 ++---
 cpm/applications/decision_making.py   |   5 +-
 cpm/core/_jit.py                      |  69 +++--
 cpm/models/activation.py              |  77 +++---
 cpm/models/attention.py               |  14 +-
 cpm/models/decision.py                |  43 +---
 cpm/models/kernels.py                 | 357 ++++++++++++++------------
 cpm/models/learning.py                |  61 ++---
 docs/api/models.rst                   |  13 +-
 docs/how-to/fast-session-models.md    |  14 +-
 12 files changed, 387 insertions(+), 354 deletions(-)
 create mode 100644 benchmarks/results/single-kernels.csv

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1e1efe9..29394de 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -22,7 +22,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - 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 `cpm.generators.SessionWrapper`, a `Wrapper` whose model function computes all trials of a participant in one call instead of being called once per trial. It works with the optimisers, `Simulator` and `cpm.hierarchical` unchanged, and its `export()` has the same layout as that of a `Wrapper`
-- Added `cpm.models.kernels`, function versions of the learning rules, decision rules, activation functions and attention mechanism in `cpm.models` that can be called from loops compiled with numba, each tested against its class. Its softmax, sigmoid and logistic functions cannot overflow, and `choose` samples from a policy as `numpy.random.choice` does, given a uniform random number drawn beforehand
+- Added `cpm.models.kernels`, which holds the formulas of the learning rules, decision rules, activation functions and attention mechanism in `cpm.models` as functions of numpy arrays and numbers that numba can compile. Each formula exists once: the classes in `cpm.models` compute with a plain-Python copy of these functions (so they never need numba, and their results are unchanged), and the built-in applications call the compiled functions in their loops over trials. `choose` samples from a policy as `numpy.random.choice` does, given a uniform random number drawn beforehand
 - Added numba as an optional dependency (`pip install cpm-toolbox[numba]`), which compiles the built-in applications. Without it, or with `CPM_DISABLE_JIT=1`, they run as plain Python and give the same results
 - Added a how-to guide on numba and session models, and `scripts/local_tests.py`, which runs the test suite with numba, without it and with `NUMBA_DISABLE_JIT=1`, and then the benchmark suite
 
@@ -34,7 +34,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - 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
 - Made each evaluation of the objective function cheaper for every model, by 0.5-1 ms for 2-6 free parameters (about 0.1 ms per free parameter): `cpm.generators.Value` copies now share their prior distribution instead of deep-copying it, `cpm.generators.Wrapper.reset()` restores parameter values and initial states without copying the priors, and `Value.PDF(log=True)` evaluates the uniform, truncated normal, beta, gamma, truncated exponential and normal priors (including frozen scipy distributions of these families passed in by the user) in closed form instead of through scipy. The priors remain frozen scipy distributions, and the log densities are identical to scipy's (the same floating-point operations, with the constant terms computed once). Models that copy their parameters on every trial gain most: `PTSM2025` runs 17 times faster
 - `cpm.generators.Value.update_prior()` now replaces the prior with an updated copy instead of changing it in place, since copies of a `Value` share their prior. Code that changes `value.prior.kwds` directly now changes the prior of every copy of that `Value`
-- Made the built-in applications `RLRW`, `HybridMBMF`, `PTSM`, `PTSM1992` and `PTSM2025` compute all trials of a participant in one call instead of one call per trial, compiled with numba if it is installed. Together with the changes below, one evaluation of the objective function is 100 to 270 times faster than before with numba, and 18 to 29 times faster without it (`PTSM2025`: 1,200 and 470 times). Their interface is unchanged: the same arguments, parameters, priors and outputs, `export()`, `simulation` (the outputs of each trial), and `model`, which is still the model function for a single trial, `model(parameters, trial)`, and can be used in a per-trial `Wrapper` as before. Their results are the same as before (bit for bit where exponentials do not overflow, tested against the outputs of the previous implementation), including simulations with `generate=True`, which sample from `numpy.random` in the same way. Each model has a single implementation in `cpm.applications._sessions`, which `model` runs on one trial
+- Made the built-in applications `RLRW`, `HybridMBMF`, `PTSM`, `PTSM1992` and `PTSM2025` compute all trials of a participant in one call instead of one call per trial, compiled with numba if it is installed. Together with the changes below, one evaluation of the objective function is 90 to 230 times faster than before with numba, and 13 to 25 times faster without it (`PTSM2025`: 1,100 and 250 times). Their interface is unchanged: the same arguments, parameters, priors and outputs, `export()`, `simulation` (the outputs of each trial), and `model`, which is still the model function for a single trial, `model(parameters, trial)`, and can be used in a per-trial `Wrapper` as before. Their results are the same as before (bit for bit where exponentials do not overflow, tested against the outputs of the previous implementation), including simulations with `generate=True`, which sample from `numpy.random` in the same way. Each model has a single implementation in `cpm.applications._sessions`, which `model` runs on one trial, and which uses the formulas of `cpm.models.kernels`. numba is imported when an application is first created, not when cpm is imported
 - Made per-trial models about twice as fast. `cpm.generators.Wrapper.run()` builds each trial from a copy of the data made once per run instead of reading it with `DataFrame.iloc` (about 50 microseconds per trial), for data with numeric and boolean columns; the trials are the same `pandas.Series` as before
 - Made the classes in `cpm.models` faster, with results identical to before: `Softmax` computes the exponentials once, the learning rules `DeltaRule`, `SeparableRule`, `HumbleTeacher` and `QLearningRule` and `CompetitiveGating` compute all weights at once instead of looping over them (3 to 18 times faster for 32 stimuli), and `ProspectUtility` computes options with the same number of outcomes as float arrays instead of arrays of arrays (2 to 3 times faster)
 - Made `LogLikelihood.bernoulli` and `LogLikelihood.continuous` 2.5 and 3 times faster, with identical results, by evaluating the expressions scipy evaluates without scipy's per-call argument handling, and by checking the inputs for non-finite values in one pass
diff --git a/benchmarks/results/single-kernels.csv b/benchmarks/results/single-kernels.csv
new file mode 100644
index 0000000..c81fec8
--- /dev/null
+++ b/benchmarks/results/single-kernels.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.653449995908886,0.004999921657145023,0.004800036549568176,3.535500029101968,0.018700025975704193,-26.034401210112605,1.0
+RLRW,python,71,2,0.6643999367952347,0.005400041118264198,0.004700035788118839,0.6152499699965119,0.018700025975704193,-26.034401210112605,5.498871678903944
+RLRW,numba,71,2,0.07589999586343765,0.005300040356814861,0.004500034265220165,0.029699993319809437,0.019000028260052204,-26.034401210112605,48.1350486827736
+HybridMBMF,trial,200,6,11.062649951782078,0.012999982573091984,0.009399955160915852,10.866799973882735,0.020700041204690933,-151.7819350468299,1.0
+HybridMBMF,python,200,6,1.8010499770753086,0.013399985618889332,0.009399955160915852,1.7200500005856156,0.021600048057734966,-151.7819350468299,6.142333690121419
+HybridMBMF,numba,200,6,0.11009996524080634,0.01309998333454132,0.009299954399466515,0.04429998807609081,0.021200045011937618,-151.7819350468299,100.47823291847806
+PTSM,trial,40,4,2.097700024023652,0.007900060154497623,0.007100054062902927,1.9856500439345837,0.019999919459223747,-36.42346848683204,1.0
+PTSM,python,40,4,0.2633999683894217,0.0077999429777264595,0.0068999361246824265,0.20700000459328294,0.019749975763261318,-36.42346848683204,7.963934228429076
+PTSM,numba,40,4,0.07419998291879892,0.008399947546422482,0.0070999376475811005,0.019400031305849552,0.019000028260052204,-36.42346848683204,28.27089631973742
+PTSM1992,trial,40,6,2.139899996109307,0.010500079952180386,0.009299954399466515,2.0222500315867364,0.019600032828748226,-39.43873213610623,1.0
+PTSM1992,python,40,6,0.30895002419129014,0.010900082997977734,0.009200011845678091,0.24999998277053237,0.019700033590197563,-39.43873213610623,6.92636293429892
+PTSM1992,numba,40,6,0.0836000544950366,0.011000025551766157,0.009299954399466515,0.02350006252527237,0.01850002445280552,-39.43873213610623,25.5968732201766
+PTSM2025,trial,40,5,1.805800013244152,0.008399947546422482,0.00800006091594696,1.6980000073090196,0.018600025214254856,-33.01065168146936,1.0
+PTSM2025,python,40,5,0.3053999971598387,0.008399947546422482,0.0075999414548277855,0.25099999038502574,0.018799910321831703,-33.01065168146936,5.912901211649461
+PTSM2025,numba,40,5,0.06780005060136318,0.008999952115118504,0.00809994526207447,0.015400000847876072,0.01880002673715353,-33.01065168146936,26.634198606451257
diff --git a/cpm/applications/_sessions.py b/cpm/applications/_sessions.py
index 49a0746..326bbe7 100644
--- a/cpm/applications/_sessions.py
+++ b/cpm/applications/_sessions.py
@@ -16,8 +16,6 @@
 former per-trial implementations of the applications.
 """
 
-import math
-
 import numpy as np
 
 from ..core import _jit
@@ -27,10 +25,11 @@
 
 softmax = kernels.softmax
 choose = kernels.choose
-logistic = kernels.logistic
 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
@@ -66,6 +65,8 @@ def rlrw(alpha, temperature, initial_values, arms, rewards, response, generate,
     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):
             activations[j] = values[arms[t, j] - 1]
@@ -76,11 +77,13 @@ def rlrw(alpha, temperature, initial_values, arms, rewards, response, generate,
             stimulus += d
         teacher = rewards[t, choice]
         reward[t] = teacher
-        for j in range(d):
-            mute = 1.0 if j == stimulus else 0.0
-            change[t, j] = alpha * (teacher - values[j]) * mute
-        for j in range(d):
-            values[j] += change[t, j]
+        ## 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()
 
@@ -196,17 +199,26 @@ def prospect_softmax(alpha, beta, lambda_loss, gamma, delta, temperature, safe,
     out_ev_risk = np.empty(n)
     out_u_safe = np.empty(n)
     out_u_risk = np.empty(n)
-    expected = np.empty(2)
+    ## 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
-        if custom_utilities:
-            u_safe, u_risk = utilities[t, 0], utilities[t, 1]
-        else:
-            u_safe = prospect_utility(safe[t], alpha, beta, lambda_loss)
-            u_risk = prospect_utility(risky[t], alpha, beta, lambda_loss)
-        expected[0] = prospect_weight(1.0, safe[t], gamma, delta, weighting) * u_safe
-        expected[1] = prospect_weight(probability[t], risky[t], gamma, delta, weighting) * u_risk
+        expected = expected_all[t]
         policy = softmax(expected, temperature)
         if choose_always or generate:
             chosen = choose(policy, uniforms[t])
@@ -225,10 +237,9 @@ def prospect_softmax(alpha, beta, lambda_loss, gamma, delta, temperature, safe,
 
 
 @njit
-def _power_utility(x, alpha):
-    if x >= 0:
-        return x**alpha
-    return -(abs(x) ** alpha)
+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
@@ -247,19 +258,18 @@ def ptsm2025(eta, phi_gain, phi_loss, temperature, alpha, safe, risky, probabili
     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)
+        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
-        risky_term = temperature * u_risk + phi
-        safe_term = temperature * u_safe
-        if -700.0 < risky_term < 700.0 and -700.0 < safe_term < 700.0:
-            ## the formula of PTSM2025
-            p = math.exp(risky_term) / (math.exp(risky_term) + math.exp(safe_term))
-        else:
-            p = logistic(risky_term - safe_term)
+        ## 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
diff --git a/cpm/applications/decision_making.py b/cpm/applications/decision_making.py
index d18602f..0c9546d 100644
--- a/cpm/applications/decision_making.py
+++ b/cpm/applications/decision_making.py
@@ -1,6 +1,7 @@
 import numpy as np
 import warnings
 from cpm.generators import Wrapper, Parameters, Value
+from cpm.core import _jit
 from cpm.applications._backend import Application, SessionModel, prepared, require, uniforms
 
 
@@ -134,8 +135,8 @@ def _ptsm1992_parameters(parameters_settings, utility_curve, weighting):
 
 
 def _ptsm2025_transform(x, alpha):
-    ## Piecewise utility transform
-    return x ** alpha if x >= 0 else -np.abs(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):
diff --git a/cpm/core/_jit.py b/cpm/core/_jit.py
index 6e78f18..a1c7f50 100644
--- a/cpm/core/_jit.py
+++ b/cpm/core/_jit.py
@@ -7,14 +7,18 @@
 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. With numba
-installed, 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 tests use it to check the compiled
-models against the plain-Python ones.
+`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
@@ -24,21 +28,38 @@
 
 __all__ = ["HAVE_NUMBA", "JIT_ENABLED", "njit", "kernels", "resolve_backend"]
 
-try:
-    if os.environ.get("CPM_DISABLE_JIT", "0") not in ("", "0"):
-        raise ImportError("compilation disabled with CPM_DISABLE_JIT")
-    import numba as _numba
+## set in the namespace of a module copy that is loaded without compilation
+PYTHON_FLAG = "__cpm_python__"
 
-    HAVE_NUMBA = True
-except ImportError:  # includes numba installs that reject the installed NumPy
-    _numba = None
-    HAVE_NUMBA = False
+_STATE = {}
 
-## numba's own switch turns njit into an identity decorator as well
-JIT_ENABLED = HAVE_NUMBA and os.environ.get("NUMBA_DISABLE_JIT", "0") in ("", "0")
 
-## set in the namespace of a module copy that is loaded without compilation
-PYTHON_FLAG = "__cpm_python__"
+def _probe():
+    """Import numba, once, and record whether compiled kernels are available."""
+    if not _STATE:
+        try:
+            if os.environ.get("CPM_DISABLE_JIT", "0") not in ("", "0"):
+                raise ImportError("compilation disabled with CPM_DISABLE_JIT")
+            import numba
+
+            _STATE["numba"], have = numba, True
+        except ImportError:  # includes numba installs that reject the installed NumPy
+            _STATE["numba"], have = None, False
+        _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):
@@ -49,10 +70,10 @@ def _identity(*args, **kwargs):
 
 def njit(*args, **kwargs):
     """numba's `njit` (with ``cache=True`` by default), or an identity decorator without numba."""
-    if not HAVE_NUMBA:
+    if not _flag("HAVE_NUMBA"):
         return _identity(*args, **kwargs)
     kwargs.setdefault("cache", True)
-    return _numba.njit(*args, **kwargs)
+    return _probe()["numba"].njit(*args, **kwargs)
 
 
 def decorator(namespace):
@@ -73,14 +94,14 @@ def kernels(name, python=False):
         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. Without numba, the module itself is plain Python already and is
-        returned either way.
+        kernels (and without importing numba). This is what the classes in
+        `cpm.models` compute with.
 
     Returns
     -------
     module
     """
-    if not python or not JIT_ENABLED:
+    if not python:
         return importlib.import_module(name)
     if name not in _PYTHON_MODULES:
         spec = importlib.util.find_spec(name)
@@ -112,9 +133,9 @@ def resolve_backend(backend):
         ``"numba"`` or ``"python"``.
     """
     if backend == "auto":
-        return "numba" if JIT_ENABLED else "python"
+        return "numba" if _flag("JIT_ENABLED") else "python"
     if backend == "numba":
-        if not HAVE_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 "
diff --git a/cpm/models/activation.py b/cpm/models/activation.py
index 77fea70..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,10 +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)
-        self.values[:] = self.values * self.gain[: self.values.shape[1]]
+        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):
@@ -300,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
@@ -331,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)
@@ -403,8 +384,7 @@ def __compute_regular(self):
         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)
-            weighted = np.asarray(self.weights * self.utilities)
-            self.expected_utility = weighted.reshape(options, -1).sum(axis=1)
+            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 = [
@@ -413,9 +393,16 @@ def __compute_regular(self):
             )
             for j in range(options)
         ]
-        self.expected_utility = np.array(
-            [np.sum(self.weights[j] * self.utilities[j]) 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):
@@ -473,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 7f9c6c5..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",
@@ -108,17 +112,7 @@ def compute(self):
         :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.
         """
-        scaled = self.activations * self.temperature
-        top = scaled.max() if scaled.size else 0.0
-        if -700.0 < top < 700.0:
-            output = np.exp(scaled)
-            output = output / output.sum()
-        elif np.isnan(top):
-            output = np.exp(scaled)
-        else:
-            output = np.exp(scaled - top)
-            output = output / output.sum()
-        self.policies = output
+        self.policies = _kernels.softmax(self.activations, self.temperature)
 
         if np.isnan(self.policies).any():
             self.policies[np.isnan(self.policies)] = 1
@@ -206,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
 
@@ -292,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():
@@ -388,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
 
@@ -509,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
index bca203b..e403300 100644
--- a/cpm/models/kernels.py
+++ b/cpm/models/kernels.py
@@ -1,21 +1,25 @@
 r"""
-Function versions of the building blocks in `cpm.models`, for compiled session models.
+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. This module
-holds the same computations as functions on numpy arrays and floats, written
-to be called *inside* a loop over trials that is compiled with numba as a
-whole, such as the session models of the built-in applications (see
-:class:`cpm.generators.SessionWrapper`). With numba installed, every function
-here is compiled on first use (and cached on disk); without numba, they are
-plain Python and give the same results.
-
-Each function gives the same result as the class it is named after, to within
-rounding error, and is tested against it. The exceptions are deliberate: the
-softmax, sigmoid and logistic functions here are computed in a way that cannot
-overflow, so where the classes return NaN (or replace it) because an
-exponential overflowed, these return the limiting probabilities.
+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.
 
@@ -51,6 +55,7 @@
     "p_second",
     "softmax",
     "log_softmax",
+    "irreducible_noise",
     "softmax_noise",
     "sigmoid",
     "greedy",
@@ -59,9 +64,13 @@
     "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",
@@ -69,6 +78,8 @@
     "weight_prelec",
     "weight_gw",
     "prospect_weight",
+    "expected_utility",
+    "add_offset",
     "offset",
     "rapid_attention_shift",
 ]
@@ -101,13 +112,12 @@ def p_second(beta, value_0, value_1):
 @njit
 def softmax(values, beta):
     r"""
-    The softmax policy, :math:`e^{\beta x_i} / \sum_j e^{\beta x_j}`.
+    The softmax policy, :math:`e^{\beta x_i} / \sum_j e^{\beta x_j}`, of :class:`cpm.models.decision.Softmax`.
 
-    As :class:`cpm.models.decision.Softmax` (``Softmax(temperature=beta,
-    activations=values).compute()``), with the same formula: the exponentials of
-    the scaled activations divided by their sum, or, where the largest scaled
-    activation is beyond ±700 and the exponentials would overflow (or all
-    underflow), the same function with the largest one subtracted first.
+    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
     ----------
@@ -119,22 +129,19 @@ def softmax(values, beta):
     Returns
     -------
     numpy.ndarray
+        The policy. If the scaled activations contain NaN, their exponentials,
+        which `Softmax` then replaces.
     """
-    n = values.shape[0]
-    scaled = np.empty(n)
-    top = -np.inf
-    for i in range(n):
-        scaled[i] = values[i] * beta
-        if scaled[i] > top:
-            top = scaled[i]
-    shift = 0.0 if -700.0 < top < 700.0 else top
-    total = 0.0
-    for i in range(n):
-        scaled[i] = math.exp(scaled[i] - shift)
-        total += scaled[i]
-    for i in range(n):
-        scaled[i] /= total
-    return scaled
+    scaled = values * beta
+    top = np.max(scaled) if scaled.size else 0.0
+    if -700.0 < top < 700.0:
+        output = np.exp(scaled)
+    elif np.isnan(top):
+        return np.exp(scaled)
+    else:
+        output = np.exp(scaled - top)
+    output /= output.sum()
+    return output
 
 
 @njit
@@ -156,30 +163,28 @@ def log_softmax(values, beta):
     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`."""
-    policy = softmax(values, beta)
-    n = policy.shape[0]
-    for i in range(n):
-        policy[i] = policy[i] * (1.0 - xi) + xi / n
-    return policy
+    return irreducible_noise(softmax(values, beta), xi)
 
 
 @njit
 def sigmoid(activations, temperature, bias):
-    """As :class:`cpm.models.decision.Sigmoid` (``Sigmoid(temperature, activations, beta=bias)``), without overflow."""
-    n = activations.shape[0]
-    out = np.empty(n)
-    for i in range(n):
-        out[i] = logistic((activations[i] - bias) * temperature)
-    return out
+    """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):
     """
-    As :class:`cpm.models.decision.GreedyRule`.
+    The policy of :class:`cpm.models.decision.GreedyRule`.
 
     Parameters
     ----------
@@ -188,46 +193,32 @@ def greedy(activations, epsilon):
     epsilon : float
         The exploration parameter.
     """
-    n = activations.shape[0]
-    summed = np.empty(n)
-    for i in range(n):
-        summed[i] = np.sum(activations[i])
-    top = np.max(summed)
-    policy = np.empty(n)
-    for i in range(n):
-        if summed[i] <= 0:
-            policy[i] = 0.0
-        elif summed[i] == top:
-            policy[i] = 1.0 - (n - 1) * epsilon
-        else:
-            policy[i] = epsilon
-    total = np.sum(policy)
-    if np.all(policy == 0):
-        policy[:] = 1.0 / n
+    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:
-        policy /= total
-    return policy
+        policies = policies / policies.sum()  # normalise
+    return policies
 
 
 @njit
 def choice_kernel(activations, kernel, temperature_activations, temperature_kernel):
     """
-    As :class:`cpm.models.decision.ChoiceKernel`.
+    The policy of :class:`cpm.models.decision.ChoiceKernel`.
 
     Note that `ChoiceKernel` multiplies the summed activations with the scaled
-    kernel inside the exponential; this function does the same.
+    kernel inside the exponential.
     """
-    n = kernel.shape[0]
-    out = np.empty(n)
-    total = 0.0
-    for i in range(n):
-        out[i] = math.exp(
-            np.sum(activations[i] * temperature_activations) * (kernel[i] * temperature_kernel)
-        )
-        total += out[i]
-    for i in range(n):
-        out[i] /= total
-    return out
+    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
@@ -265,7 +256,7 @@ def choose(policy, uniform):
 @njit
 def delta_rule(weights, feedback, input, alpha):
     """
-    As :class:`cpm.models.learning.DeltaRule`: the change in the weights and the prediction errors.
+    The change in the weights and the prediction errors of :class:`cpm.models.learning.DeltaRule`.
 
     Parameters
     ----------
@@ -274,7 +265,7 @@ def delta_rule(weights, feedback, input, alpha):
     feedback : numpy.ndarray
         The teaching signal, one per outcome.
     input : numpy.ndarray
-        The stimulus representation.
+        The stimulus representation, one value per column of `weights`.
     alpha : float
         The learning rate.
 
@@ -285,21 +276,15 @@ def delta_rule(weights, feedback, input, alpha):
     error : numpy.ndarray
         The summed prediction error of each outcome.
     """
-    rows, columns = weights.shape
-    change = np.empty((rows, columns))
-    error = np.empty(rows)
-    for i in range(rows):
-        activation = np.sum(weights[i] * input)
-        error[i] = feedback[i] - activation
-        for j in range(columns):
-            change[i, j] = alpha * error[i] * input[j]
-    return change, error
+    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):
     """
-    As :class:`cpm.models.learning.SeparableRule`: the change in the weights and the prediction errors.
+    The change in the weights and the prediction errors of :class:`cpm.models.learning.SeparableRule`.
 
     Returns
     -------
@@ -308,54 +293,70 @@ def separable_rule(weights, feedback, input, alpha):
     error : numpy.ndarray
         The prediction error of each outcome-stimulus pair, with the same shape.
     """
-    rows, columns = weights.shape
-    change = np.empty((rows, columns))
-    error = np.empty((rows, columns))
-    for i in range(rows):
-        for j in range(columns):
-            error[i, j] = feedback[i] - weights[i, j]
-            change[i, j] = alpha * error[i, j] * input[j]
-    return change, error
+    error = feedback[:, np.newaxis] - weights
+    return alpha * error * input, error
 
 
 @njit
 def q_learning(values, reward, maximum, alpha, gamma):
     """
-    As :class:`cpm.models.learning.QLearningRule`: the updated values.
+    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.
     """
-    n = values.shape[0]
-    out = np.empty(n)
-    for i in range(n):
-        active = 1.0 if values[i] > 0 else values[i]
-        out[i] = values[i] + alpha * (reward + gamma * maximum - values[i]) * active
-    return out
+    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):
-    """As :class:`cpm.models.learning.HumbleTeacher`: the updated weights (a new array)."""
-    rows, columns = weights.shape
-    out = weights.copy()
-    for i in range(rows):
-        activation = np.sum(out[i] * input)
-        if feedback[i] == 0:
-            teacher = min(-1.0, activation)
-        else:
-            teacher = max(1.0, activation)
-        for j in range(columns):
-            out[i, j] += alpha * (teacher - activation) * input[j]
-    return out
+    """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):
     """
-    As :class:`cpm.models.learning.SARSATrace`, updating the values in place.
+    `sarsa_trace`, applied to the values in place.
 
     Parameters
     ----------
@@ -370,13 +371,12 @@ def sarsa_trace_update(model_free_values, second_stage_values, starting_state, a
     -------
     stage1_prediction_error, stage2_prediction_error : float
     """
-    stage1 = (second_stage_values[reached_second_stage]
-              - model_free_values[starting_state, action])
-    stage2 = reward - second_stage_values[reached_second_stage]
-    model_free_values[starting_state, action] += (
-        learning_rate * stage1 + eligibility_trace * learning_rate * stage2
+    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,
     )
-    second_stage_values[reached_second_stage] += learning_rate * stage2
+    model_free_values[starting_state, action] += model_free_change
+    second_stage_values[reached_second_stage] += second_stage_change
     return stage1, stage2
 
 
@@ -386,64 +386,69 @@ def sarsa_trace_update(model_free_values, second_stage_values, starting_state, a
 
 @njit
 def sigmoid_activation(input, weights):
-    """As :class:`cpm.models.activation.SigmoidActivation` for 2D weights (one row per outcome), without overflow."""
-    rows, columns = weights.shape
-    out = np.empty((rows, columns))
-    for i in range(rows):
-        for j in range(columns):
-            out[i, j] = logistic(input[j] * weights[i, j])
-    return out
+    """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):
-    """As :class:`cpm.models.activation.CompetitiveGating`: the gated values (a new array)."""
-    gain = (input * salience) ** P
-    gain = gain / np.sum(gain) ** (1.0 / P)
-    rows, columns = values.shape
-    out = np.empty((rows, columns))
-    for i in range(rows):
-        for k in range(columns):
-            out[i, k] = values[i, k] * gain[k]
-    return out
+    """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.
     """
-    if magnitude >= 0:
-        return magnitude**alpha
-    return -lambda_loss * (-magnitude) ** beta
+    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 = probability**power
-    return numerator / (numerator + (1.0 - probability) ** power) ** (1.0 / 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 probability**gamma
+    return np.power(probability, gamma)
 
 
 @njit
 def weight_prelec(probability, gamma, delta):
     """The Prelec (1998) weighting function."""
-    if probability <= 0:
-        return 0.0
-    return math.exp(-delta * (-math.log(probability)) ** gamma)
+    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 * probability**gamma
-    return numerator / (numerator + (1.0 - probability) ** gamma)
+    numerator = delta * np.power(probability, gamma)
+    denominator = numerator + np.power(1 - probability, gamma)
+    return numerator / denominator
 
 
 ## the weighting functions by number, for `prospect_weight`
@@ -453,12 +458,13 @@ def weight_gw(probability, gamma, delta):
 @njit
 def prospect_weight(probability, magnitude, gamma, delta, weighting):
     """
-    The decision weight of an outcome, as `ProspectUtility` computes it.
+    The decision weights of outcomes, as `ProspectUtility` computes them.
 
     Parameters
     ----------
-    probability, magnitude : float
-        The probability and magnitude of the outcome.
+    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
@@ -468,7 +474,7 @@ def prospect_weight(probability, magnitude, gamma, delta, weighting):
         "prelec" and "gw".
     """
     if weighting == 0:
-        return weight_tk(probability, gamma if magnitude > 0 else delta)
+        return weight_tk(probability, np.where(magnitude > 0, gamma, delta))
     if weighting == 1:
         return weight_power(probability, gamma)
     if weighting == 2:
@@ -476,12 +482,29 @@ def prospect_weight(probability, magnitude, gamma, delta, weighting):
     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):
-    """As :class:`cpm.models.activation.Offset`: a copy of `input` with `offset` added to element `index`."""
-    out = input.copy()
-    out[index] += offset
-    return out
+    """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)
 
 
 ## ----------------------------------------------------------------------------
@@ -490,12 +513,10 @@ def offset(input, offset, index):
 
 @njit
 def rapid_attention_shift(weights, predictions, input, error, gain, pnorm, P, rho):
-    """As :class:`cpm.models.attention.RapidAttentionShift`: the change in the attention gain."""
-    rows, columns = weights.shape
-    out = np.zeros(columns)
-    for i in range(rows):
-        for j in range(columns):
-            out[j] += (weights[i, j] * input[j] - predictions[i] * gain[j] ** (P - 1.0)) * error[i]
-    for j in range(columns):
-        out[j] = rho * (pnorm**-1) * out[j]
-    return out
+    """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 819ae96..7dd0bcc 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",
@@ -141,12 +145,10 @@ def compute(self):
         """
 
         rows, columns = self.shape
-        stimulus = _leading(self.input, columns)
-        # calculate summed error for each output unit
-        activations = np.sum(self.weights * stimulus, axis=1)
-        self.error = _leading(self.teacher, rows) - activations
-        # calculate the change on weights
-        _assign(self, "weights", self.alpha * self.error[:, np.newaxis] * stimulus)
+        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
 
@@ -278,9 +280,10 @@ def compute(self):
         """
         rows, columns = self.shape
         # separable prediction error for each outcome-stimulus pair
-        teacher = _leading(self.teacher, rows)
-        self.error = teacher[:, np.newaxis] - self.weights
-        _assign(self, "weights", self.alpha * self.error * _leading(self.input, columns))
+        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
 
@@ -396,14 +399,7 @@ def compute(self):
             The computed output values.
         """
 
-        active = self.values.copy()
-        active[active > 0] = 1
-        output = np.zeros(self.values.shape[0])
-        output += (
-            self.values
-            + (self.alpha * (self.reward + self.gamma * self.maximum - self.values)) * active
-        )
-        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})"
@@ -511,13 +507,9 @@ def compute(self):
         """
 
         rows, columns = self.shape
-        stimulus = _leading(self.input, columns)
-        activations = np.sum(self.weights * stimulus, axis=1)
-        feedback = _leading(self.teacher, rows)
-        teacher = np.where(
-            feedback == 0, np.minimum(-1, activations), np.maximum(1, activations)
+        self.delta[:] = _kernels.humble_teacher_change(
+            self.weights, _leading(self.teacher, rows), _leading(self.input, columns), self.alpha
         )
-        self.delta[:] = self.alpha * (teacher - activations)[:, np.newaxis] * stimulus
         np.add(self.weights, self.delta, out=self.weights, casting="unsafe")
         return self.weights
 
@@ -648,23 +640,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/docs/api/models.rst b/docs/api/models.rst
index 015bbf3..781ad61 100644
--- a/docs/api/models.rst
+++ b/docs/api/models.rst
@@ -4,9 +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`. For models that
-compute all trials at once, :mod:`cpm.models.kernels` has the same components
-as functions that can be compiled with numba.
+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
 --------------
@@ -79,6 +79,7 @@ Kernels for compiled models
    log_softmax
    p_second
    logistic
+   irreducible_noise
    softmax_noise
    sigmoid
    greedy
@@ -87,9 +88,13 @@ Kernels for compiled models
    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
@@ -97,5 +102,7 @@ Kernels for compiled models
    weight_power
    weight_prelec
    weight_gw
+   expected_utility
+   add_offset
    offset
    rapid_attention_shift
diff --git a/docs/how-to/fast-session-models.md b/docs/how-to/fast-session-models.md
index e02ac29..8016c3b 100644
--- a/docs/how-to/fast-session-models.md
+++ b/docs/how-to/fast-session-models.md
@@ -18,13 +18,13 @@ One evaluation of the objective function, with the parameters' priors, for one p
 
 | Application | Trials | Without numba | With numba | Per trial, in a `Wrapper` |
 |---|---:|---:|---:|---:|
-| `RLRW` | 71 | 0.40 ms | 0.06 ms | 3.6 ms |
-| `HybridMBMF` | 200 | 1.4 ms | 0.09 ms | 11 ms |
-| `PTSM` | 40 | 0.28 ms | 0.06 ms | 2.0 ms |
-| `PTSM1992` | 40 | 0.27 ms | 0.07 ms | 2.1 ms |
-| `PTSM2025` | 40 | 0.16 ms | 0.06 ms | 1.8 ms |
+| `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.01 to 0.03 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).
+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 0.5 to 2.5 seconds. 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.
 
@@ -109,7 +109,7 @@ def model(parameters, data):
 ```
 
 In a script or module, `@njit(cache=True)` keeps the compiled code on disk between Python sessions (not in an interactive session, where there is no file to cache it for).
-{py:mod}`cpm.models.kernels` has function versions of the learning rules, decision rules, activation functions and attention mechanisms in {py:mod}`cpm.models`, written to be called from compiled loops like this one.
+{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).
 

From eaebd8b4366a2962b547a6e4eded5639f48f44c0 Mon Sep 17 00:00:00 2001
From: Lenard Dome <23503601+lenarddome@users.noreply.github.com>
Date: Mon, 28 Sep 2026 11:07:44 +0200
Subject: [PATCH 07/34] docs: add the numba install option

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 CONTRIBUTING.md                     | 16 ++++++++++++++++
 docs/about/roadmap.md               |  2 +-
 docs/get-started/installation.md    | 28 ++++++++++++++++++++++++++--
 docs/get-started/troubleshooting.md | 19 ++++++++++++++++---
 docs/how-to/fast-session-models.md  |  4 ++--
 docs/index.md                       |  2 ++
 6 files changed, 63 insertions(+), 8 deletions(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 50363cb..5e44e53 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,14 @@ 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`.
+
 ## 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/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/get-started/installation.md b/docs/get-started/installation.md
index 5fc4853..1826f63 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.
 :::
 
@@ -56,13 +70,23 @@ print(cpm.__version__)
 
 ## Faster fitting with numba
 
-The built-in models run many times faster when [numba](https://numba.pydata.org/) is installed, which compiles them. It is optional; install it with cpm:
+[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]"
 ```
 
-Nothing else changes: cpm uses numba if it can import it, and otherwise runs the same models as plain Python, with the same results. See {doc}`/how-to/fast-session-models`.
+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 second or two. 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
 
diff --git a/docs/get-started/troubleshooting.md b/docs/get-started/troubleshooting.md
index 6213e28..1b490de 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 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 second or two 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
index 8016c3b..65cecd2 100644
--- a/docs/how-to/fast-session-models.md
+++ b/docs/how-to/fast-session-models.md
@@ -4,10 +4,10 @@ Fitting a model evaluates it thousands of times per participant. A {py:class}`~c
 
 ## Install numba
 
-numba is an optional dependency. Install it with cpm:
+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]
+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 cannot be imported, for either reason, cpm uses plain Python without further notice.
diff --git a/docs/index.md b/docs/index.md
index 1e89950..62388fc 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

From e145a7cbb38e82feb57e9e5437ae34095f49d71f Mon Sep 17 00:00:00 2001
From: Lenard Dome <23503601+lenarddome@users.noreply.github.com>
Date: Mon, 28 Sep 2026 11:11:42 +0200
Subject: [PATCH 08/34] docs(changelog): bring the numba entries up to date

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 CHANGELOG.md | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 29394de..6051b9e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -23,8 +23,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - 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 `cpm.generators.SessionWrapper`, a `Wrapper` whose model function computes all trials of a participant in one call instead of being called once per trial. It works with the optimisers, `Simulator` and `cpm.hierarchical` unchanged, and its `export()` has the same layout as that of a `Wrapper`
 - Added `cpm.models.kernels`, which holds the formulas of the learning rules, decision rules, activation functions and attention mechanism in `cpm.models` as functions of numpy arrays and numbers that numba can compile. Each formula exists once: the classes in `cpm.models` compute with a plain-Python copy of these functions (so they never need numba, and their results are unchanged), and the built-in applications call the compiled functions in their loops over trials. `choose` samples from a policy as `numpy.random.choice` does, given a uniform random number drawn beforehand
-- Added numba as an optional dependency (`pip install cpm-toolbox[numba]`), which compiles the built-in applications. Without it, or with `CPM_DISABLE_JIT=1`, they run as plain Python and give the same results
-- Added a how-to guide on numba and session models, and `scripts/local_tests.py`, which runs the test suite with numba, without it and with `NUMBA_DISABLE_JIT=1`, and then the benchmark suite
+- Added numba as an optional dependency (`pip install "cpm-toolbox[numba]"`), which compiles the built-in applications. Without it, or with `CPM_DISABLE_JIT=1`, they run as plain Python and give the same results. numba is imported when an application is first created, not when cpm is imported
+- Added the numba install option to the documentation: the landing page, the installation guide (for installs from PyPI, from GitHub and from source, with how to check that numba is used and how to turn it off), a how-to guide on numba and session models, troubleshooting entries on numba that does not install or import and on its first-run compilation, and the development setup and testing in the contributing guide
+- Added test units for `cpm.generators.SessionWrapper`, the fast priors, `cpm.models.kernels`, and the built-in applications with and without numba. The latter compare the applications with the outputs of their former per-trial implementations, frozen in `test/applications/data/per_trial_reference.pkl.gz`
+- Added a benchmark suite under `benchmarks/`, which times each part of the objective function for every built-in application (`python benchmarks/run.py`), and `scripts/local_tests.py`, which runs the test suite with numba, without it and with `NUMBA_DISABLE_JIT=1`, and then the benchmark suite
 
 ### Changed
 
@@ -34,13 +36,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - 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
 - Made each evaluation of the objective function cheaper for every model, by 0.5-1 ms for 2-6 free parameters (about 0.1 ms per free parameter): `cpm.generators.Value` copies now share their prior distribution instead of deep-copying it, `cpm.generators.Wrapper.reset()` restores parameter values and initial states without copying the priors, and `Value.PDF(log=True)` evaluates the uniform, truncated normal, beta, gamma, truncated exponential and normal priors (including frozen scipy distributions of these families passed in by the user) in closed form instead of through scipy. The priors remain frozen scipy distributions, and the log densities are identical to scipy's (the same floating-point operations, with the constant terms computed once). Models that copy their parameters on every trial gain most: `PTSM2025` runs 17 times faster
 - `cpm.generators.Value.update_prior()` now replaces the prior with an updated copy instead of changing it in place, since copies of a `Value` share their prior. Code that changes `value.prior.kwds` directly now changes the prior of every copy of that `Value`
-- Made the built-in applications `RLRW`, `HybridMBMF`, `PTSM`, `PTSM1992` and `PTSM2025` compute all trials of a participant in one call instead of one call per trial, compiled with numba if it is installed. Together with the changes below, one evaluation of the objective function is 90 to 230 times faster than before with numba, and 13 to 25 times faster without it (`PTSM2025`: 1,100 and 250 times). Their interface is unchanged: the same arguments, parameters, priors and outputs, `export()`, `simulation` (the outputs of each trial), and `model`, which is still the model function for a single trial, `model(parameters, trial)`, and can be used in a per-trial `Wrapper` as before. Their results are the same as before (bit for bit where exponentials do not overflow, tested against the outputs of the previous implementation), including simulations with `generate=True`, which sample from `numpy.random` in the same way. Each model has a single implementation in `cpm.applications._sessions`, which `model` runs on one trial, and which uses the formulas of `cpm.models.kernels`. numba is imported when an application is first created, not when cpm is imported
-- Made per-trial models about twice as fast. `cpm.generators.Wrapper.run()` builds each trial from a copy of the data made once per run instead of reading it with `DataFrame.iloc` (about 50 microseconds per trial), for data with numeric and boolean columns; the trials are the same `pandas.Series` as before
-- Made the classes in `cpm.models` faster, with results identical to before: `Softmax` computes the exponentials once, the learning rules `DeltaRule`, `SeparableRule`, `HumbleTeacher` and `QLearningRule` and `CompetitiveGating` compute all weights at once instead of looping over them (3 to 18 times faster for 32 stimuli), and `ProspectUtility` computes options with the same number of outcomes as float arrays instead of arrays of arrays (2 to 3 times faster)
+- Made the built-in applications `RLRW`, `HybridMBMF`, `PTSM`, `PTSM1992` and `PTSM2025` compute all trials of a participant in one call instead of one call per trial, compiled with numba if it is installed. Together with the changes below, one evaluation of the objective function is 90 to 230 times faster than before with numba, and 13 to 25 times faster without it (`PTSM2025`: 1,100 and 250 times). Their interface is unchanged: the same arguments, parameters, priors and outputs, `export()`, `simulation` (the outputs of each trial), and `model`, which is still the model function for a single trial, `model(parameters, trial)`, and can be used in a per-trial `Wrapper` as before. Their results are the same as before (bit for bit where exponentials do not overflow, tested against the outputs of the previous implementation), including simulations with `generate=True`, which sample from `numpy.random` in the same way. Each model has a single implementation in `cpm.applications._sessions`, which `model` runs on one trial, and which uses the formulas of `cpm.models.kernels`. The applications are now subclasses of `SessionWrapper` (which is a subclass of `Wrapper`), and have its `prepare`, `session` and `session_output` attributes in addition to their own
+- Made per-trial models about twice as fast. `cpm.generators.Wrapper.run()` builds each trial from a copy of the data made once per run instead of reading it with `DataFrame.iloc` (about 50 microseconds per trial), for data with numeric and boolean columns (see `cpm.core.data.trial_reader`); the trials are the same `pandas.Series` as before
+- Made the classes in `cpm.models` faster, with results identical to before: `Softmax` computes the exponentials once, the learning rules `DeltaRule`, `SeparableRule`, `HumbleTeacher` and `QLearningRule` and `CompetitiveGating` compute all weights at once instead of looping over them (3 to 17 times faster for 32 stimuli, and about as fast as before for a few stimuli), and `ProspectUtility` computes options with the same number of outcomes as float arrays instead of arrays of arrays (2.5 to 3.5 times faster). The classes now compute with the formulas in `cpm.models.kernels`
 - Made `LogLikelihood.bernoulli` and `LogLikelihood.continuous` 2.5 and 3 times faster, with identical results, by evaluating the expressions scipy evaluates without scipy's per-call argument handling, and by checking the inputs for non-finite values in one pass
 - Made `cpm.applications.signal_detection.EstimatorMetaD` about 10 times faster, with identical results, by computing all normal CDFs of `metad_nll` in one vectorised call instead of one scipy call each
 - `cpm.models.decision.Softmax` no longer overflows: where the scaled activations exceed ±700, it computes the same function with the largest activation subtracted. It previously returned NaN there, replaced it with 1 and warned; the policies are now the correct ones, without a warning. Elsewhere its results are unchanged
-- Added a benchmark suite under `benchmarks/`, which times each part of the objective function for every built-in application (`python benchmarks/run.py`)
 
 ### Fixed
 
@@ -59,6 +60,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - 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 `numpy.asarray(value, dtype=...)` raising `TypeError` for a `cpm.generators.Value`, because `Value.__array__` did not take the `dtype` and `copy` arguments of the NumPy array protocol
 - Fixed `cpm.models.activation.ProspectUtility` with `weighting="prelec"` raising `TypeError` for options with more than one outcome, because the probabilities were stored as an object array, which `numpy.log` does not accept
+- Fixed `cpm.applications.decision_making.PTSM2025` raising `ValueError: probabilities contain NaN` when its exponentials overflowed (for large temperatures or utilities), which stopped a fit; its policy is now computed as a softmax that cannot overflow
 - Fixed `cpm.models.learning.HumbleTeacher` raising `IndexError` for 1D weights, which it promotes to one row like the other learning rules but sized its `delta` before doing so
 - 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

From 755cd3f6637a166a7f266ac5ccdfc8747dee37af Mon Sep 17 00:00:00 2001
From: Lenard Dome <23503601+lenarddome@users.noreply.github.com>
Date: Mon, 28 Sep 2026 11:13:50 +0200
Subject: [PATCH 09/34] docs(changelog): shorten the entries of the development
 version

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 CHANGELOG.md | 103 +++++++++++++++++++++++++--------------------------
 1 file changed, 50 insertions(+), 53 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6051b9e..f9db72f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -9,66 +9,63 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### 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 `cpm.generators.SessionWrapper`, a `Wrapper` whose model function computes all trials of a participant in one call instead of being called once per trial. It works with the optimisers, `Simulator` and `cpm.hierarchical` unchanged, and its `export()` has the same layout as that of a `Wrapper`
-- Added `cpm.models.kernels`, which holds the formulas of the learning rules, decision rules, activation functions and attention mechanism in `cpm.models` as functions of numpy arrays and numbers that numba can compile. Each formula exists once: the classes in `cpm.models` compute with a plain-Python copy of these functions (so they never need numba, and their results are unchanged), and the built-in applications call the compiled functions in their loops over trials. `choose` samples from a policy as `numpy.random.choice` does, given a uniform random number drawn beforehand
-- Added numba as an optional dependency (`pip install "cpm-toolbox[numba]"`), which compiles the built-in applications. Without it, or with `CPM_DISABLE_JIT=1`, they run as plain Python and give the same results. numba is imported when an application is first created, not when cpm is imported
-- Added the numba install option to the documentation: the landing page, the installation guide (for installs from PyPI, from GitHub and from source, with how to check that numba is used and how to turn it off), a how-to guide on numba and session models, troubleshooting entries on numba that does not install or import and on its first-run compilation, and the development setup and testing in the contributing guide
-- Added test units for `cpm.generators.SessionWrapper`, the fast priors, `cpm.models.kernels`, and the built-in applications with and without numba. The latter compare the applications with the outputs of their former per-trial implementations, frozen in `test/applications/data/per_trial_reference.pkl.gz`
-- Added a benchmark suite under `benchmarks/`, which times each part of the objective function for every built-in application (`python benchmarks/run.py`), and `scripts/local_tests.py`, which runs the test suite with numba, without it and with `NUMBA_DISABLE_JIT=1`, and then the benchmark suite
+- 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 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`) and `scripts/local_tests.py`, which runs the tests with and without numba
 
 ### 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
-- Made each evaluation of the objective function cheaper for every model, by 0.5-1 ms for 2-6 free parameters (about 0.1 ms per free parameter): `cpm.generators.Value` copies now share their prior distribution instead of deep-copying it, `cpm.generators.Wrapper.reset()` restores parameter values and initial states without copying the priors, and `Value.PDF(log=True)` evaluates the uniform, truncated normal, beta, gamma, truncated exponential and normal priors (including frozen scipy distributions of these families passed in by the user) in closed form instead of through scipy. The priors remain frozen scipy distributions, and the log densities are identical to scipy's (the same floating-point operations, with the constant terms computed once). Models that copy their parameters on every trial gain most: `PTSM2025` runs 17 times faster
-- `cpm.generators.Value.update_prior()` now replaces the prior with an updated copy instead of changing it in place, since copies of a `Value` share their prior. Code that changes `value.prior.kwds` directly now changes the prior of every copy of that `Value`
-- Made the built-in applications `RLRW`, `HybridMBMF`, `PTSM`, `PTSM1992` and `PTSM2025` compute all trials of a participant in one call instead of one call per trial, compiled with numba if it is installed. Together with the changes below, one evaluation of the objective function is 90 to 230 times faster than before with numba, and 13 to 25 times faster without it (`PTSM2025`: 1,100 and 250 times). Their interface is unchanged: the same arguments, parameters, priors and outputs, `export()`, `simulation` (the outputs of each trial), and `model`, which is still the model function for a single trial, `model(parameters, trial)`, and can be used in a per-trial `Wrapper` as before. Their results are the same as before (bit for bit where exponentials do not overflow, tested against the outputs of the previous implementation), including simulations with `generate=True`, which sample from `numpy.random` in the same way. Each model has a single implementation in `cpm.applications._sessions`, which `model` runs on one trial, and which uses the formulas of `cpm.models.kernels`. The applications are now subclasses of `SessionWrapper` (which is a subclass of `Wrapper`), and have its `prepare`, `session` and `session_output` attributes in addition to their own
-- Made per-trial models about twice as fast. `cpm.generators.Wrapper.run()` builds each trial from a copy of the data made once per run instead of reading it with `DataFrame.iloc` (about 50 microseconds per trial), for data with numeric and boolean columns (see `cpm.core.data.trial_reader`); the trials are the same `pandas.Series` as before
-- Made the classes in `cpm.models` faster, with results identical to before: `Softmax` computes the exponentials once, the learning rules `DeltaRule`, `SeparableRule`, `HumbleTeacher` and `QLearningRule` and `CompetitiveGating` compute all weights at once instead of looping over them (3 to 17 times faster for 32 stimuli, and about as fast as before for a few stimuli), and `ProspectUtility` computes options with the same number of outcomes as float arrays instead of arrays of arrays (2.5 to 3.5 times faster). The classes now compute with the formulas in `cpm.models.kernels`
-- Made `LogLikelihood.bernoulli` and `LogLikelihood.continuous` 2.5 and 3 times faster, with identical results, by evaluating the expressions scipy evaluates without scipy's per-call argument handling, and by checking the inputs for non-finite values in one pass
-- Made `cpm.applications.signal_detection.EstimatorMetaD` about 10 times faster, with identical results, by computing all normal CDFs of `metad_nll` in one vectorised call instead of one scipy call each
-- `cpm.models.decision.Softmax` no longer overflows: where the scaled activations exceed ±700, it computes the same function with the largest activation subtracted. It previously returned NaN there, replaced it with 1 and warned; the policies are now the correct ones, without a warning. Elsewhere its results are unchanged
+- 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`
+- Made the built-in applications (`RLRW`, `HybridMBMF`, `PTSM`, `PTSM1992`, `PTSM2025`) compute all trials at once: 90-230 times faster with numba, 13-25 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
 
 ### Fixed
 
-- Fixed `cpm.hierarchical.EmpiricalBayes` and `cpm.hierarchical.VariationalBayes` fitting every participant with the model's original priors instead of the estimated population-level priors, apart from the first evaluation of the objective function. `Wrapper.reset()` restored the parameters, including their priors, from a copy made when the model was created, so every prior update was discarded after the first run of the model. Hierarchical fits now use the updated priors throughout, which changes their results
-- Fixed the random starting priors of the second and later chains of `cpm.hierarchical.EmpiricalBayes` and `cpm.hierarchical.VariationalBayes` being arrays of length one instead of numbers, which made the log prior an array. It went unnoticed because of the previous issue
-- 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 `numpy.asarray(value, dtype=...)` raising `TypeError` for a `cpm.generators.Value`, because `Value.__array__` did not take the `dtype` and `copy` arguments of the NumPy array protocol
-- Fixed `cpm.models.activation.ProspectUtility` with `weighting="prelec"` raising `TypeError` for options with more than one outcome, because the probabilities were stored as an object array, which `numpy.log` does not accept
-- Fixed `cpm.applications.decision_making.PTSM2025` raising `ValueError: probabilities contain NaN` when its exponentials overflowed (for large temperatures or utilities), which stopped a fit; its policy is now computed as a softmax that cannot overflow
-- Fixed `cpm.models.learning.HumbleTeacher` raising `IndexError` for 1D weights, which it promotes to one row like the other learning rules but sized its `delta` before doing so
-- 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 `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 `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
 

From cc7160d2549ae5ff3802b39741e155a5181ad566 Mon Sep 17 00:00:00 2001
From: Lenard Dome <23503601+lenarddome@users.noreply.github.com>
Date: Mon, 28 Sep 2026 11:27:28 +0200
Subject: [PATCH 10/34] chore: bump the version to 0.26.0.dev0

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 CHANGELOG.md       | 2 +-
 cpm/__version__.py | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index f9db72f..1edbe52 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,7 +5,7 @@ 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
 
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"

From 2d48bad8843f8670fec6e03538f4bee7e1c35024 Mon Sep 17 00:00:00 2001
From: Lenard Dome <23503601+lenarddome@users.noreply.github.com>
Date: Mon, 28 Sep 2026 11:59:44 +0200
Subject: [PATCH 11/34] bench: time the hierarchical tutorials; correct the
 compile times in the docs

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 CHANGELOG.md                               |   2 +-
 benchmarks/hierarchical.py                 | 186 +++++++++++++++++++++
 benchmarks/results/hierarchical-report.csv |   9 +
 benchmarks/results/report-branch.csv       |  16 ++
 benchmarks/results/report-main.csv         |   6 +
 docs/get-started/installation.md           |   2 +-
 docs/get-started/troubleshooting.md        |   2 +-
 docs/how-to/fast-session-models.md         |   2 +-
 8 files changed, 221 insertions(+), 4 deletions(-)
 create mode 100644 benchmarks/hierarchical.py
 create mode 100644 benchmarks/results/hierarchical-report.csv
 create mode 100644 benchmarks/results/report-branch.csv
 create mode 100644 benchmarks/results/report-main.csv

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1edbe52..62c38c3 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -23,7 +23,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - 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 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`) and `scripts/local_tests.py`, which runs the tests 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
 
 ### Changed
 
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..69c0b5c
--- /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.66120005492121,0.00500003807246685,0.004500034265220165,3.499699989333749,0.019099912606179714,-26.034401210112605,1.0
+RLRW,python,71,2,0.6896499544382095,0.005599926225841045,0.004700035788118839,0.6378000834956765,0.020000035874545574,-26.034401210112605,5.3087802462100235
+RLRW,numba,71,2,0.07609999738633633,0.005400041118264198,0.004700035788118839,0.030199997127056122,0.0198000343516469,-26.034401210112605,48.11038345158438
+HybridMBMF,trial,200,6,11.158149980474263,0.012999982573091984,0.009199953638017178,10.877399938181043,0.022000051103532314,-151.7819350468299,1.0
+HybridMBMF,python,200,6,1.8414499936625361,0.013399985618889332,0.009299954399466515,1.7601000145077705,0.0210499856621027,-151.7819350468299,6.059436867075253
+HybridMBMF,numba,200,6,0.10960001964122057,0.013200100511312485,0.00909995287656784,0.044199987314641476,0.021900050342082977,-151.7819350468299,101.80791953323413
+PTSM,trial,40,4,2.113299909979105,0.0072999391704797745,0.006500049494206905,1.9810000667348504,0.01969997538253665,-36.42346848683204,1.0
+PTSM,python,40,4,0.2642999170348048,0.0078000593930482864,0.0067999353632330894,0.2074000658467412,0.019600032828748226,-36.42346848683204,7.995840232143588
+PTSM,numba,40,4,0.07309997454285622,0.008100061677396297,0.006700051017105579,0.018999911844730377,0.019700033590197563,-36.42346848683204,28.909721558659964
+PTSM1992,trial,40,6,2.1307499264366925,0.010500079952180386,0.009100069291889668,2.0070000318810344,0.01939997309818864,-39.43873213610623,1.0
+PTSM1992,python,40,6,0.31260005198419094,0.010900082997977734,0.009100069291889668,0.2495000371709466,0.018700025975704193,-39.43873213610623,6.816217441142494
+PTSM1992,numba,40,6,0.08249992970377207,0.010899966582655907,0.008500064723193645,0.022300053387880325,0.01969997538253665,-39.43873213610623,25.82729384240033
+PTSM2025,trial,40,5,1.8072000239044428,0.008599949069321156,0.007900060154497623,1.707299961708486,0.019900035113096237,-33.01065168146936,1.0
+PTSM2025,python,40,5,0.30369998421519995,0.008999952115118504,0.007900060154497623,0.24500000290572643,0.019400031305849552,-33.01065168146936,5.950609541763663
+PTSM2025,numba,40,5,0.06640003994107246,0.008900067768990993,0.00800006091594696,0.015199999324977398,0.018200022168457508,-33.01065168146936,27.216851458346483
diff --git a/benchmarks/results/report-main.csv b/benchmarks/results/report-main.csv
new file mode 100644
index 0000000..551ea4b
--- /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.740949968341738,0.4334500408731401,0.08230004459619522,7.631500018760562,0.04830001853406429,-26.034401210112605,1.0
+HybridMBMF,trial,200,6,25.65465000225231,0.8509999606758356,0.23659993894398212,23.677100078202784,0.05199998850002885,-151.7819350468299,1.0
+PTSM,trial,40,4,6.53229997260496,0.6324999849312007,0.15425001038238406,5.112400045618415,0.046999892219901085,-36.42346848683204,1.0
+PTSM1992,trial,40,6,7.755799975711852,0.8447500295005739,0.23965002037584782,5.928300088271499,0.04700000863522291,-39.43873213610623,1.0
+PTSM2025,trial,40,5,76.71145000495017,0.7241499843075871,0.19545003306120634,76.82600000407547,0.04789989907294512,-33.01065168146936,1.0
diff --git a/docs/get-started/installation.md b/docs/get-started/installation.md
index 1826f63..93b6270 100644
--- a/docs/get-started/installation.md
+++ b/docs/get-started/installation.md
@@ -82,7 +82,7 @@ or add it to an existing installation with the same command, or with `pip instal
 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 second or two. The result is cached on disk, so later runs, new Python sessions and parallel fits start at full speed.
+- **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.
 
diff --git a/docs/get-started/troubleshooting.md b/docs/get-started/troubleshooting.md
index 1b490de..c5d9c71 100644
--- a/docs/get-started/troubleshooting.md
+++ b/docs/get-started/troubleshooting.md
@@ -36,7 +36,7 @@ numba supports a new NumPy release some time after it comes out, so the newest N
 If numba is installed but cannot be imported, cpm 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 second or two longer
+### 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.
diff --git a/docs/how-to/fast-session-models.md b/docs/how-to/fast-session-models.md
index 65cecd2..6fc6bee 100644
--- a/docs/how-to/fast-session-models.md
+++ b/docs/how-to/fast-session-models.md
@@ -26,7 +26,7 @@ One evaluation of the objective function, with the parameters' priors, for one p
 
 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 0.5 to 2.5 seconds. 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.
+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.
 
 To run without numba although it is installed, for example to compare, set the environment variable `CPM_DISABLE_JIT=1` before starting Python.
 

From 9debd33e7c62c9798ae485c350d8b52c74f1b8f0 Mon Sep 17 00:00:00 2001
From: Lenard Dome <23503601+lenarddome@users.noreply.github.com>
Date: Mon, 28 Sep 2026 12:06:44 +0200
Subject: [PATCH 12/34] docs: re-run the hierarchical tutorials

Their outputs predated the population-prior fix.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 .../hierarchical-empirical-bayes.ipynb        | 172 +++++++++--------
 .../hierarchical-variational-bayes.ipynb      | 176 ++++++++++++------
 2 files changed, 209 insertions(+), 139 deletions(-)

diff --git a/docs/tutorials/hierarchical-empirical-bayes.ipynb b/docs/tutorials/hierarchical-empirical-bayes.ipynb
index cfc2db5..b98bb73 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-28T09:57:35.673727Z",
+     "iopub.status.busy": "2026-09-28T09:57:35.673727Z",
+     "iopub.status.idle": "2026-09-28T09:57:37.318385Z",
+     "shell.execute_reply": "2026-09-28T09:57:37.318385Z"
     }
    },
    "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-28T09:57:37.320840Z",
+     "iopub.status.busy": "2026-09-28T09:57:37.320840Z",
+     "iopub.status.idle": "2026-09-28T09:57:40.359740Z",
+     "shell.execute_reply": "2026-09-28T09:57:40.359227Z"
     }
    },
    "outputs": [
@@ -260,10 +260,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-28T09:57:40.361748Z",
+     "iopub.status.busy": "2026-09-28T09:57:40.360748Z",
+     "iopub.status.idle": "2026-09-28T09:57:58.072108Z",
+     "shell.execute_reply": "2026-09-28T09:57:58.071592Z"
     }
    },
    "outputs": [],
@@ -307,10 +307,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-28T09:57:58.074689Z",
+     "iopub.status.busy": "2026-09-28T09:57:58.074689Z",
+     "iopub.status.idle": "2026-09-28T10:01:42.755953Z",
+     "shell.execute_reply": "2026-09-28T10:01:42.754945Z"
     }
    },
    "outputs": [
@@ -332,21 +332,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: -1002111.6878229581. \n"
+      "Iteration: 3, LME: -2118.660385652465. \n"
      ]
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Iteration: 4, LME: -1002111.6879784929. \n",
+      "Iteration: 4, LME: -2116.775324661551. \n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Iteration: 5, LME: -2116.190938974253. \n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Iteration: 6, LME: -2115.946883918983. \n",
       "Chain: 2\n"
      ]
     },
@@ -354,42 +368,42 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Iteration: 1, LME: -1002111.68789715. \n"
+      "Iteration: 1, LME: -2143.736725126121. \n"
      ]
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Iteration: 2, LME: -1002111.6880721282. \n"
+      "Iteration: 2, LME: -2122.6267536873347. \n"
      ]
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Iteration: 3, LME: -1002111.6879817494. \n"
+      "Iteration: 3, LME: -2118.975955557839. \n"
      ]
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Iteration: 4, LME: -1002112.7669982793. \n"
+      "Iteration: 4, LME: -2117.441897597485. \n"
      ]
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Iteration: 5, LME: -1002111.6874826007. \n"
+      "Iteration: 5, LME: -2116.4985554579416. \n"
      ]
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Iteration: 6, LME: -1002111.6882978933. \n"
+      "Iteration: 6, LME: -2115.8769881909275. \n"
      ]
     }
    ],
@@ -431,16 +445,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-28T10:01:42.757953Z",
+     "iopub.status.busy": "2026-09-28T10:01:42.756953Z",
+     "iopub.status.idle": "2026-09-28T10:01:43.356924Z",
+     "shell.execute_reply": "2026-09-28T10:01:43.355916Z"
     }
    },
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 1200x800 with 7 Axes>"
       ]
@@ -467,10 +481,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-28T10:01:43.357924Z",
+     "iopub.status.busy": "2026-09-28T10:01:43.357924Z",
+     "iopub.status.idle": "2026-09-28T10:01:43.365944Z",
+     "shell.execute_reply": "2026-09-28T10:01:43.365437Z"
     }
    },
    "outputs": [
@@ -511,15 +525,15 @@
        "  <tbody>\n",
        "    <tr>\n",
        "      <th>alpha</th>\n",
-       "      <td>0.55</td>\n",
-       "      <td>0.30</td>\n",
+       "      <td>0.53</td>\n",
+       "      <td>0.10</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.14</td>\n",
+       "      <td>0.92</td>\n",
        "      <td>2.0</td>\n",
        "      <td>1.0</td>\n",
        "    </tr>\n",
@@ -530,8 +544,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.53  0.10        0.6      0.2\n",
+       "temperature  2.14  0.92        2.0      1.0"
       ]
      },
      "execution_count": 6,
@@ -563,10 +577,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-28T10:01:43.366949Z",
+     "iopub.status.busy": "2026-09-28T10:01:43.366949Z",
+     "iopub.status.idle": "2026-09-28T10:01:43.375195Z",
+     "shell.execute_reply": "2026-09-28T10:01:43.375195Z"
     }
    },
    "outputs": [
@@ -603,38 +617,38 @@
        "    </tr>\n",
        "    <tr>\n",
        "      <th>mean</th>\n",
-       "      <td>0.547013</td>\n",
-       "      <td>2.688099</td>\n",
+       "      <td>0.533227</td>\n",
+       "      <td>2.144847</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>std</th>\n",
-       "      <td>0.247382</td>\n",
-       "      <td>1.362774</td>\n",
+       "      <td>0.044128</td>\n",
+       "      <td>0.757282</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>min</th>\n",
-       "      <td>0.017481</td>\n",
-       "      <td>0.567998</td>\n",
+       "      <td>0.432360</td>\n",
+       "      <td>0.850733</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>25%</th>\n",
-       "      <td>0.406963</td>\n",
-       "      <td>1.576051</td>\n",
+       "      <td>0.500097</td>\n",
+       "      <td>1.432731</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>50%</th>\n",
-       "      <td>0.579247</td>\n",
-       "      <td>2.456307</td>\n",
+       "      <td>0.542153</td>\n",
+       "      <td>2.217574</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>75%</th>\n",
-       "      <td>0.745620</td>\n",
-       "      <td>3.453586</td>\n",
+       "      <td>0.563997</td>\n",
+       "      <td>2.817876</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>max</th>\n",
-       "      <td>1.000000</td>\n",
-       "      <td>5.687499</td>\n",
+       "      <td>0.616313</td>\n",
+       "      <td>3.422121</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
        "</table>\n",
@@ -643,13 +657,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.533227     2.144847\n",
+       "std     0.044128     0.757282\n",
+       "min     0.432360     0.850733\n",
+       "25%     0.500097     1.432731\n",
+       "50%     0.542153     2.217574\n",
+       "75%     0.563997     2.817876\n",
+       "max     0.616313     3.422121"
       ]
      },
      "execution_count": 7,
@@ -683,10 +697,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-28T10:01:43.377203Z",
+     "iopub.status.busy": "2026-09-28T10:01:43.377203Z",
+     "iopub.status.idle": "2026-09-28T10:01:43.515477Z",
+     "shell.execute_reply": "2026-09-28T10:01:43.515477Z"
     },
     "tags": [
      "thumbnail"
@@ -695,7 +709,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 +740,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-28T10:01:43.517485Z",
+     "iopub.status.busy": "2026-09-28T10:01:43.517485Z",
+     "iopub.status.idle": "2026-09-28T10:01:43.523505Z",
+     "shell.execute_reply": "2026-09-28T10:01:43.523505Z"
     }
    },
    "outputs": [
@@ -767,12 +781,12 @@
        "    <tr>\n",
        "      <th>alpha</th>\n",
        "      <td>0.213</td>\n",
-       "      <td>0.149</td>\n",
+       "      <td>0.146</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>temperature</th>\n",
        "      <td>0.969</td>\n",
-       "      <td>0.854</td>\n",
+       "      <td>0.450</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
        "</table>\n",
@@ -781,8 +795,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.146\n",
+       "temperature                  0.969            0.450"
       ]
      },
      "execution_count": 9,
diff --git a/docs/tutorials/hierarchical-variational-bayes.ipynb b/docs/tutorials/hierarchical-variational-bayes.ipynb
index 07b4519..b85125c 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-28T10:01:44.723076Z",
+     "iopub.status.busy": "2026-09-28T10:01:44.723076Z",
+     "iopub.status.idle": "2026-09-28T10:01:46.359981Z",
+     "shell.execute_reply": "2026-09-28T10:01:46.359981Z"
     }
    },
    "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-28T10:01:46.361988Z",
+     "iopub.status.busy": "2026-09-28T10:01:46.361988Z",
+     "iopub.status.idle": "2026-09-28T10:01:49.445743Z",
+     "shell.execute_reply": "2026-09-28T10:01:49.444736Z"
     }
    },
    "outputs": [],
@@ -170,10 +170,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-28T10:01:49.447743Z",
+     "iopub.status.busy": "2026-09-28T10:01:49.447743Z",
+     "iopub.status.idle": "2026-09-28T10:05:53.241104Z",
+     "shell.execute_reply": "2026-09-28T10:05:53.240601Z"
     }
    },
    "outputs": [
@@ -195,7 +195,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 +231,42 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Iteration: 2, LME: -2113.615661748695\n"
+      "Iteration: 2, LME: -2271.0170015037593\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Iteration: 3, LME: -2196.3439009039193\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Iteration: 4, LME: -2156.4774257583167\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Iteration: 5, LME: -2132.425635132036\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Iteration: 6, LME: -2123.035793430094\n"
      ]
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Iteration: 3, LME: -2113.6156702566254\n"
+      "Iteration: 7, LME: -2120.062812336691\n"
      ]
     }
    ],
@@ -264,16 +320,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-28T10:05:53.243116Z",
+     "iopub.status.busy": "2026-09-28T10:05:53.243116Z",
+     "iopub.status.idle": "2026-09-28T10:05:53.837526Z",
+     "shell.execute_reply": "2026-09-28T10:05:53.837017Z"
     }
    },
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAABK4AAAMWCAYAAADYpM7pAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjIsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvgI3uAAAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3QecE9Xax/EnyfZld+l9KVIVpNo72FAsWBAb2L342rFyLVxsWO69Ym+ooHLtHXvBitjoRZEO0uuyLFsz7+c52cmmbc9ussnv+zEmmUwmkwk7k/znnOc4LMuyBAAAAAAAAIgyzkivAAAAAAAAABAKwRUAAAAAAACiEsEVAAAAAAAAohLBFQAAAAAAAKISwRUAAAAAAACiEsEVAAAAAAAAohLBFQAAAAAAAKISwRUAAAAAAACiEsEVAAAAAAAAohLBFQAAQAO03377yTHHHFOj57Zu3VouvfTSsK9TuF+7Nu8RAADEBoIrAADQoNx4443icDhk5cqVkV4V6dmzp1mXvffeO+Tjc+bMMY/r5Z577pGGxn5/oS4JCQmRXj0AABAHCK4AAABqIT09Xf744w/5+eefgx578cUXzeMNWa9evcSyrKBLcXFxjZa3YcMGmTRpUtjXEwAAxCaCKwAAgFro3bu3dO/eXSZPnuw3vbCwUKZOnSpnnnkm2xcAAKCGCK4AAEDM0dZA2jWvR48ekpycLC1atJBzzz1XVqxY4TdfXl6eXHvttdKqVStp1KiRDBkyxHRBrG5tpQsuuEBee+01yc/P90778MMPZfv27TJq1KhareOePXvk+uuvN7WhfNexPBqg7b///pKWliYZGRly3HHHyW+//SZ1qU+fPmabhXLIIYeYVlsV1biqi/eYkpIi1113ncycOVMOOuggc3+vvfaS5557LuQyX3rpJTOfvn7z5s1l2LBhsmDBgmq/LgAACC+CKwAAEHM0AJowYYLcfvvtsmnTJvn8889Ndz4NJtauXeudb8SIEfLyyy/LM888I+vWrZN//etfctVVV/kFUFWh4VROTo68//77ft0EBw8eLB06dKjVOp5zzjlmWU8++aRZxzvvvFOuuOKKkOt40003yejRo2XkyJEm+Pnzzz+lW7ducvjhh8vs2bOlrlxyySXy+++/y9y5c/2m6/v56aefzOMVqav3uHTpUpk4caIJpXS5p512mlx++eUmzPKloZmGaaeeeqosXrxY/vrrL7n44ovlkUceqdHrAgCAMLIAAAAakBtuuMHSrzArVqwI+fiMGTPM4/fdd5/fdJ0/ISHB+sc//mHuf//992a+J554wm++n3/+2Uw/+uijK12XHj16WAceeKC5fdxxx1lDhgwxt9etW2e5XC5r6tSp1l9//WWWd/fdd1d7HX/88Ucz32OPPeY33w8//BC0jgsWLLAcDoc1btw4v3ndbrfVp08fa+jQod5prVq1si655JIqvT99nVAX39feunWrlZycbF199dV+z7/xxhutxMREa9OmTeW+dl29R12fFi1aWLm5ud5pBQUFVrNmzayLLrrIO23OnDnmdf75z3+Wux2q87oAACC8aHEFAABiyldffWWuTz/9dL/pnTp1koEDB3ofnz59urk++eST/eY74IADpGXLltV+3QsvvFC++OIL07JHW3FplzNt4VObdbSvTznlFL/5Dj30UNOdzde0adNM0fThw4f7TdcRALXl17fffivhLM7+5Zdfeudp2rSp6VqnNb0KCgq8XSF1O+i6azfI8tTlezzqqKP8iuMnJSWZemTLly/3Tvv444+9LeDKU1fbFgAAVI5xjAEAQEzZunWrudZ6SYF0mnbx8p0vVEhVk+BKQyoNqzSsmTJliumGmJqaGpZ11BpcgQKn6Wh9qm/fvubaDpjs23bBeA1v6oJ2tXv99dflvffeM+9dw56NGzdW2k2wLt9jmzZtgpaZmZnpXY7SbpqqXbt25a5jpLctAADxjBZXAAAgpmjrH6WhSSCdZrfiadasmV9w4SvUtMpo8W8NbB544AFTJ+miiy4K2zqWN58v+znLli0zrZ1KSkrE7Xabix201GWwcvTRR0vnzp3lhRdeMPf1un379qaAeUXq8j1qi6jK2K3B/v7773LnifS2BQAgnhFcAQCAmKIBinr33Xf9pq9atcoUELcfHzRokLn+6KOP/Ob79ddfaxRcKQ2rdCTBnj17miLrtV1H7YZmj1Doa8aMGbJlyxa/aSeddJK51lZPkaAhkb5/7UL4888/yyeffGK6T7pcrgqfF+n3OHToUHP9v//9r9x5Ir1tAQCIZ3QVBAAAMeWQQw4xtaPuueceyc7ONsHEihUr5LLLLpOsrCy57bbbzHyHHXaYeUzvt23b1gRZixYtknvvvdfUdaoJDavsrmPhWEet86ShyR133GG6smmgtWDBAvO8wHXUbmw68p2OyKchkrb+0tZEWs9JQyQdCe/xxx+XuqTBlY7MqLWgtFVSRa3ObJF+j7rMa6+9Vh566CHJyMiQ888/39TF+uGHH0yY9uyzz0bFtgUAIF7R4goAADRI2i1NQ4TAyx9//CGvvfaaCRrGjRtnAoZjjjlGunTpIjNnzjRBke2NN96Q8847z9Rn0tpSOv+jjz5qlpOcnFyn61+ddRw5cqRcfvnl3nXUkES7JgZ68MEHTX0trS/Vu3dv08Xt7LPPNnWkxo4dW6P1XLhwYcjtrJelS5f6zatdA48//nhZs2aNCQL32muvKr1GpN/jxIkT5emnn5a33nrLFG/v0aOHvPjiiybQqsvXBQAAlXPo0IJVmA8AACBuNGnSxLSIev755yO9KgAAAHGNFlcAAAA+vv76a9mxY4cceeSRbBcAAIAIo8UVAACIW9odLC8vz9RY0lZWP/74o4wePdrUOtIi6XXdXRAAAAAVo8UVAACIW8OGDZMlS5aY+lJaZ0prXR133HEyffp0QisAAIAoQIsrAAAAAAAARCVaXAEAAAAAACAqEVwBAAAAAAAgKiVEegXildvtlnXr1pnirw6HI9KrAwAAAAAAUC8sy5Jdu3ZJ27ZtxemsuE0VwVWEaGiVnZ0dqZcHAAAAAACIqDVr1kj79u0rnIfgKkK0pZX9IWVmZkZqNQAAAAAAAOpVTk6OacxjZyMVIbiKELt7oIZWBFcAAAAAACDeOKpQOoni7AAAAAAAAIhKBFcAAAAAAACISgRXAAAAAAAAiEoEVwAAAAAAAIhKFGdHje0pLJEXflwhLRolS4uMZGleet2sUZIkushEAQAAAABA7RBcocY25uTLQ5/9GfKxJmmJJsTyBloB4ZZ93TQ9SVzOykcRAAAAAAAA8YfgCjX/x+NyyPCB7WVzboFsyS2Qzbv0ulBK3JZszysylyUbcytchmZWTdM9IZYn0Ery3C4NtnwDr8ZpiVUaKhMAAAAAAMQGh2VZVqRXIh7l5ORIVlaW7Ny5UzIzMyVWuN2W7NhTZEIsT5DluTbhVum1PX3r7kKpzr++RJfDBFjNfUKt5hlJpeFWSlnolZEsjZITCLkAAAAAAGjgmQgtrhBWTqfDdP/TS4/WGRXOW1zilm27C71hlt1iK1TQtXNPkRSVWLJ+Z765VCY5wenfVdEbdAW35kpNcoVxCwAAAAAAgHAhuELEJLic0jIzxVwqU1BcIltLQy1vKy77tk83Rb3OLSiWgmK3rN2+x1wqo62zfFtrharJZRedT04g5AIAAEB00s40do8GvbI713hu29PL5pFyppf3XL2j89nPs3xf12d53nt+81Tw3ErWx/tYOe+5onmCe3gEzF/Ja4TqIWJVtgyrevOHUt1lWNXcLnWxbUJ15qr0OYFz1MXnUd1tU9k6Vukzr95rhv43UfH72rtNpnRqni7xgOAKDYIGRm0bp5pLVUY71EBrUyXdFfWiAZcGXXpZuTWv0mVnpXqKznuCrpSA7oqeoKtladF5DeYAAEBo+iXebYmpjeku/eFaYqZZYrnLbpuLW0LfLl2GXutyLJ/bOt0KvO0zv5Y3CLytj3vWS5/necwKuu3zvEqWZ5ZT+t50mvd2iHW0KvzBHxgKBE8PChTKDSPKnlB5wOH/YyvkMssJI6oecJTdKTfgqM76BLwXqUaI4x+eVLA+fq9fhfcY9DlV/TWquh0BxJ/xp/QiuAIaKu36l900zVwqogd8Daz8uijuyvfvruhTk0u7KmqXRb0s3VTxOmgN+aZpSUGttsqKz6d4A68maUmmiyUAoHYBSGUhR2BoEDJACApGqhJKeJ5TFnoEhDEhghnzfHc5tysIUkKGKqXPCwpVAgOWEO8rcDt4b4dYZtntgPcSuNxy3lfg9gEQu/S7sP3tVgdXcvhNL73nN0/Z9PKeW7bwEK8X9Pr+UwLHd6p0/hDvp7JXrfw1Ah+v+PlVWU+p7DUqec3Q81T8mpV9HqHWsLrbtyrbptavUd5rWpY4xS0uh1tcUiIuq8Rz7b1dNt0Zch7PNKeUSELpNGfp4wni9t72XNzisop9bpfOH7hM8Xmedx63JOWNFJFOEg9ocYW4pTu3jJREc9mrRcXz6hdtDazsllqb/VpxFfoXnc8tMF/Ktfi8XkR2Vbhsl9MhzdKTqlSTKzOVovMAIk9DB7u1am6+XhfJrvxi2V1Q4r1d9pjPJb9Y8gpLyg05PMFJ6JCjohCI1gaxTc/tOB0Oc5LHvu3SH7N622nf9jymx1Rn6WN+tx3B082yfG+XzuN0+twund8RdFtf1zOf3tdG1oG3fZfh+zp+yyt9X+a9lP6Kcvj8oNIfUr4/rhwh5/GZ7vODX+9UHgqUFyIEPLda61M2j+9080iodfZ9blXXJ8R7kYqCj5quT9D7DfEeK9i2UkEQU+lr1PY9h3iumT8c77ncz48TsTFDz0hYJSLuYp9LiPslRRU8Xs5zqj1PbZZRVLNlNhQZJ0m8ILgCqkAPxI3TksylW6uKi87rj6rteXYLroprcmlxep1fuzXqpTJJLk/R+aCaXCGCrvRk/rwBlNEQSLtH+4ZKuwqKzPXuQvu+T9gUInSyH99TVNIgN60jMPQwIYP/bb8AIzDYKCfkCAxOgkOU0CFHYBjjt2zfkCZgHX3fh87jWWbw7dDvo/IgpUohUNBr+Ac++h7LAh7/kKnK61z6OgBQ70zz07oIXar7nKI6Cnsqua/9tRHMmSjiTCi9uHxuh+N+wDRXYuXP6Xhw3HxK/LIFwky/fGuYpJe921Q8b1GJ2xSd9w23/Ftzld3XH5uFJW75e8cec6lMaqKrwi6KvqFXSiJF54GG1rpJ7+8uKA5q3bSrdLr3vk8AFe7uWUkJTslITpBGKQmSnuS5tu/rwBf2fQ3S9X5GSoKkJiV4w4uahEIVtaYJai0T0HKG1gAAECWKC0QKckUKSy/l3S7cLVJSWHetcrwthgKDm4Z5gqbOOWoQzrjqMeyp9nMSq/Ec6hdHEsEVEEGJLqe0zkoxl8rkF3mKzvvX5AooPq9F6XMKTGsIvazelmculdEfk94WWwHdEz1BV4p3ZEVdZwCVt27KLyob/MG3dZM3cApo3eQNnOq4dZMGPY1KQ6ZGpaFShh00BYZNpdM9jyf6zZOe7GKkVQCIl9ZHGjSZUGlXWaBkAqZd/rfN9W6feXeHDqa0JVFD5HCGOXgJVzBTUTgUxtelOygihOAKaCC0VVT7JmnmUhn98RvURdHbeqvQrzVXYWnXIb0s37K70mU3SbNHVqy4q6KOrKgtIoCGpLjE7anTVNp1rtx6TT6tm0xXu4L6bd3kDZwqad1kwqaAUCot0UX3KwCI9aCpaE9wC6ZKWzjtLgumvAFUaRhVVy2QElJFktJFkhuJJGX43G5Udu1KqoOwp6ZhDidwgUgguAJikP5w1UvHZumVtgrJybdHVgwddPm28vLU7yoylyUbcytctmZWTdMDuioGtebyXDdOS6QLD2rduklbNJnQKaB1U2DY5NuaKbC2U123bvILkXzCJk8LpuDWTXrb8/dM6yYAiOmgyYREvi2VAoKk6rZqqqsaRYlpPqFSuidssgMmEzpl+NwuDaOC5tXbdijFz1EAlWNPAcQxrfeSlZpoLl1bNqpwXh35a4fPyIplgZZ/bS4zsuLuQjMSmN7WS2USXTqyYnKImlz+rbj0tv7Ip05NbLVu8gZOVWzdFFTbidZNAID6HnGtyA6SatGqyRtG6cnA8LbS9bJDJG/YFNiqqfS+bwuncm+ne1ohAUA9I7gCUCVaOFm7/+mlR+uMSgOJbX4jK5Zfk2tHXpEUlViyISffXCqTnGCPrOgbdPm25vLU5NLaXGlJ7OLqsnWTp4ucJ3jyDZo0UApVqymwthOtmwAA9UILb4fq/hayhVMVWjVpaFUnHMFBkd2Cybelkl+rpgpaOCVq0ETXNgANH7/qAIR/x+JySsuMFHOpTEFxSdDIin7hVmlNLr2vwUdBsVvWbt9jLpVJT/IdWbGcmlylLbySE1xx07qp3NHofGs1BXSt8+1yF221m+zudNRuAoAYUVIcUPQ7sFVTBUW/Q7VwKqp8oJoaF+oO7P5WWaulih7XbngUvwaAIARXACJKA6O2jVPNpTJ7Cj0jK26qQk0ubRW0u7BEdm/Nk5VbK//CmqkjKwa24ApqzZUszdKTTDAXidZNQbWafMKn3SFaN/nOT+smAECdKSkqv6h3Ra2afIMp3zCquPIW2DXicAW0SiqvVVNgGBWiVZNp0ZRK0AQA9YDgCkCDkZrkkuymaeZSWeCjgU3ILor2bZ+aXNpVUYvU62XZ5oqb/+uJ0KZpSQHhVlnxeXu6dqnUERvLrdcUoutcJFo3+RYJ9ysWbrd8onUTAMSe4oIQrZMqauFUSaumksK6WU9nYsWjzVW3hVNCMkETADRABFcAYo4Wb89ISTSXzs0rH1lxp1103i/cKvTprui53ppbYIrOa/F5vfy5cVc9vZ/aj0xnB1EaXAEAGtiIc9oCqdIR5nZVXgDcbtXkLqqbdXUlV6/VUtDjAfMmJNXNegIAGhSCKwAS7yFX47Qkc+nWquKi89r6aXtexa247Jpc23YX0roJABA6iMrdKLJjtcj2VSI7Si+7twa0ZPIJo6ySutmSCSnljzZX1bpMvt3tXIl84gCAsCO4AoAqcjkdpiugXvZuU/G8brdlRmIEAMRhMJW3TWTHSp9warUnnNLbO9fUvIaTFu+utNVSiFpMoebVi4ufAgCA6MfRCgDqAKEVAMSw/J3BgZR9W6+11VRlo9FlthNp3EGkcUfPdaOWFRQJL73vjO0RcAEACIXgCgAAAPCl3fSCWkutLLutwVVlGrUWadLRP5yy72e2p34TAABVRHAFAACA+FKU7+myF6q1lN7P21L5MtKaeQIpv3Cq9H5We5HE1Pp4JwAAxDyCKwAAAMSWkiKRnWvL78q3a33ly0jJCg6k7JZTetEufAAAoM4RXAEAAKBhcZd4wqfy6kzl/C1iuSteRmJ6+V359H5q4/p6NwAAoAIEVwAAAIi+kflyN/rUmbIvpfe1NZW7qOJluJLLWkf5tpayb2tXPwejvwIAEO0IrgAAAFD/wVTetrJAKrArn16K8ytehjPBU0sqMJCyu/Wlt9QhXuvrHQEAgDpCcAUAAIDw05H3yuvKp9eFuRU/3+EUyWgborVUaVe+zLYiThefHAAAMY7gCgAAANVXuNunK58dSNkB1SpPcFWZRq3L6crXQSSzvUhCEp8MAABxjuAKAAAAwYryS0fmWxncWkrv522pfKtpHamg1lKdPLe1m19iKlseAABUiOAKAAAgHpUUlQZT5XTl01H7KpOcJdKkg39tKe8ofdkiyRn18U4AAEAMI7gCAACIRe4ST/gUqrWU3s75W8RyV7yMxLTgQMr3dmrj+no3AAAgThFcAQAANNSR+XI3+deV8g2ntDWVu6jiZbiSS0OogMLndkClXf0cjvp6RwAAALEdXE2bNk2mTJkiS5YskbZt28qFF14oI0aM8Jtny5Yt8uKLL8rUqVOlWbNm8tVXXwUtp2fPnlJcXOw37fbbbzfLs+Xl5cndd98tn376qSQkJMiwYcPk5ptvlsTExDp8hwAAIK6CqbxtwYGUfVsvxfkVL8OZ4Kkl5VdnyqcQeqNWIk5nfb0jAACA+A2uNIx65513TLjUtWtX+fXXX+Wiiy6Sv//+W8aMGeOd78ADD5TTTjtN+vfvL99//33IZS1dulSee+45Ofzww73TWrRo4TfPeeedJ4sXL5YnnnhC8vPz5bLLLjOv9eSTT9bhuwQAADFFR94rryuf3i7MrWQBDpHMduV35ctoI+KKma97AAAgDjksS0/nNXxFRUVBrZ1uuukmef/9900LLFthYaEkJSXJv/71L3nllVdMSBVIW1Bp660hQ4aEfK05c+aY4OuHH36QQw891Ex7/fXX5dxzz5W1a9dKmzZtKl3fnJwcycrKkp07d0pmZmYN3jEAAIh6hbt9wig7nPIphJ6/o/JlNGodoitf6f3M9iIJSfXxTgAAAMKmOplIzJyCC9VFTzM5R0BdBg2tquLGG280l86dO5uWW6effrr3sW+++UYyMjLkkEMO8U478cQTxe12y3fffRfUPREAAMSoovzSkflWBreW0tt5WypfhtaRCmot1an0OlskMbU+3gkAAEBUipngKtCqVatk0qRJcs0111T7uYcddphcf/310qFDB1MD6/zzz5fx48ebFlxqzZo10rJlS79QTIOstLQ00+IqlIKCAnPxTRcBAECUKykqDabK6cqno/ZVJjlLpIlP0XO/WlPZIskZ9fFOAAAAGqSoDa5KSkqkR48eFc6j9aq0yHqg7du3y8knnyx9+vQxRdWrS8Mql8tlbmuXQA2cxo0bZ8Is7UaoLatCtfDS1ly63qFMmDDBhF8AACCKuEs84VPIOlOrRXLWiljuipeRmBZcW8o3nEptXF/vBgAAIOZEbXClwZGO2FeR1NTgpvM7duyQY489Vho1aiQfffRRlbsGBr52YAusPXv2yIoVK6Rbt27SvHlz2bp1q988Ogqh9s3Ux0IZO3asX5F4bXGVnZ1d7XUDAADVoKU8czf5BFIr/cMpbU3lLqp4Ga5kT8uooHCq9L529QsoTQAAAIAYD66Ujg5YHRocHXfccaY1lIZe2n0vHFauXGmuGzf2nDHdf//9ZfPmzbJs2TLp0qWLmfbjjz+amlr77bdfyGUkJyebCwAACHMwlbetrOh5UCH01SLF+RUvw5kgktU+OJCyW041aiXidPKxAQAAREBUB1fVoS2YNLTSrnwaWtV0pD4dhVADqJNOOsksa8GCBWYEwqFDh0qLFi3MPIMHD5bu3bubVlQ6MqG2ttKuhFqsXbsnAgCAMMrfWX5XPr1fmFvJAhwime3K78qX0UbEFTNfiQAAAGJKzHxLe+aZZ+SXX36Rtm3byoABA/weW7p0qff22WefLb/99pts27ZNcnNzva26fvjhB2ndurVpMXXLLbfIqFGjTLF1DcQuuOACuf/++73L0EDrvffek3PPPVeaNm1qgit93uuvv16P7xgAgBhRuLs0hPItfL6qLJzK31H5MrRVVFDh89Lbme1FEqpfOgAAAACR57C0eVEM0NpWW7ZsqbTL4d9//23qVQXq3LmzX22roqIiU8eqVatWfqMHBtqwYYMJssqrbVUeDcSysrJM98aatg4DAKDBKNojsmG+yMYF/q2l9HZe6OO3H60jFdRaqlPptGyRxOC6lwAAAIhO1clEYqbFldafsmtQVaRdu3ZVWp7WydIWWJWpyjwAAMTdSH1bloj8/XvZZeNCEXdx+c9JzhJp4lNjyhtO6bQOIsnhqVsJAACAhiVmgisAABAB2nA752+fkGqWyLrZoetOpbcQadNPpGnn4HAqtUkk1h4AAABRjuAKAABU3Z7tnmDKDqn0Ondj8HyJ6SJt+4u0GyDSbqDnOitbpILu9wAAAEAggisAABBaUb6nJpVvl7+tZQOeeDlcIq32KQ2o9vNct+gh4iyrHQkAAADUBMEVAAAQcbtFtv7lH1JtWCDiLgreOk06lYZUpZfWfUSS0tiKAAAACDuCKwAA4lHOOv+Qat0ckYKc0KP5+YZUbQeIpDeLxBoDAAAgDhFcAQAQ6/J3Btel2rU+eL6EVJG2/cpqUum1FlGnLhUAAAAihOAKAIBYUlxQWpeqNKDSy5YlwfM5nCIt9/Epnq51qfYWcfHVAAAAANGDb6cAADTkulTblgXUpZovUlIYPG/jDv5d/tr0FUlKj8RaAwAAAFVGcAUAQEOxa4N/SPX3bJGCncHzpTYJrkvVqEUk1hgAAACoFYIrAACiUX6OyPo5PiHVLJGcv4PnS0jxtJ7yBlUDRJp0pi4VAAAAYgLBFQAAkVZcKLJpoX/x9M1/iogVMKNDpOXe/nWptE6VKzFCKw4AAADULYIrAADqk2WJbFvu3+Vv/TyRkoLgebOy/UMqbVmVnMHnBQAAgLhBcAUAQF3K3RRQl2qWSP6O4PlSsoLrUmW04rMBAABAXCO4AgAgXApyg+tS7VwTPJ8rWaRNH/+gqule1KUCAAAAAhBcAQBQEyVFIpsW+7em2vyHiOUOmNEh0qJHWeF0U5eql0hCEtsdAAAAqATBFQAAValLtX2lf/H09XNFivcEz5vZLqAuVT+RlEy2MQAAAFADBFcAAATavaUsoLIve7YFb6dkrUvV378uVWYbticAAAAQJgRXAID4VpjnaT3lG1LtWBU8nytJpPW+AXWpuog4nZFYawAAACAuEFwBAOJHSbGnDpVv8fRNi0SskuB5m3f3CakGiLTqLZKQHIm1BgAAAOIWwRUAIHbrUu1Y7R9S6Yh/RXnB8zZqLdJ+v7LaVG37i6RkRWKtAQAAAPgguAIAxIa8bcF1qfK2BM+XlOFfl0ovmW0jscYAAAAAKkFwBQBoeIr2iKyf5x9SbV8RPJ8zUaR1b/+Qqlk36lIBAAAADQTBFQAgurlLRDb/6R9SbVwYui5Vs67+IZXWpUpMicRaAwAAAGhowdWePXukqKhIMjMz6/NlAQANqS7VzrX+danWzRYp2h08b3rL4LpUqU0isdYAAAAAoj24mjx5svz888/y1FNPmfsfffSRLFq0SG666SbvPFOnTpWZM2fKpEmTwvWyAICGbM/20rpUPrWpdm8Kni+pkSeYskMqU5eqnYjDEYm1BgAAANDQgqvi4mLTmsq2fv16+fPPP8O1eABAQ1eUL7Jhvn+Xv23LgudzJoi06uXf5a95dxGnKxJrDQAAACCCqHEFAAg/t1tky5KAulQLRNzFwfM23cs/pGq9r0hiKp8KAAAAAIIrAEAY6lLlrPMPqdbNESncFTxvWvPSulQaUg0QaTtAJK0pHwEAAACAkGhxBQConj07PAXT7eLpep27IXi+xLTgulRZ2dSlAgAAABCZ4OrVV1+VTz/91NzOy8uTgoIC73172umnnx7OlwQA1KXiApENC/xbU239K3g+h0uk1T4Bdal6iLg4PwIAAACg5sL2i2K//faTsWPHVjpf//79w/WSAIBw16XautQ/pNJi6u6ygTe8mnQKqEvVRyQpjc8DAAAAQHQGV/369TMXAEADkbM+oC7VbJGCnOD5Upv61KUa6KlLld4sEmsMAAAAIM7QhwMA4kF+jk9dqtLaVLvWBc+XkCrStl9Z8XS9btyRulQAAAAAGnZw9eabb1apq+BZZ50l9913X7heFgAQqLhQZKNdl2qWyLpZIpv/1OH//OdzOEVa7C3S3qfLn96nLhUAAACAWAuudu7cKcuXL5ejjz5aDj300HLnGzBgQLheEgBgWSLblntCqrW/ldWlKikI3jaNO/h392vTVyS5EdsQAAAAQOwHVyeccIJcf/318vLLL8uaNWvkkksukVGjRkmrVq3C9RIAgF0bPS2ofGtT5e8M3i4pjctCKq1PpUFVoxZsPwAAAAANisOy9HR9+BQWFsr7778vkyZNkm+//VaGDBliQqwTTzxRXC5XOF+qQcvJyZGsrCzTUi0zMzPSqwMgGhXkiqyf41+Xauea4PlcyZ7WU95R/gaINN2LulQAAAAAGnwmEvbgytfq1avlhRdekH//+9+m9dWTTz5ZVy/V4BBcAfBTUiSyaZF/SLX5DxHLHbChHCItevoXT2/VS8SVyAYFAAAAEHOZSJ2NKrhx40Z5/fXX5bXXXpPU1FQZOHBgXb0UADQser5g+wpPOGUHVevnihTnB8+b2b4soDK1qfqJJGdEYq0BAAAAoN6FNbgqLi6Wjz/+2LSy+vTTT2XQoEFy9913y6mnnipJSUnhfCkAaDhyNwfXpdqzPXi+lCxPLSrfLn8ZrSOxxgAAAAAQW8HV9OnT5dxzzzWtqy666CJ57LHHJDs7W+rbhg0b5K+//pK2bdtKly5dajxPfn6+/P7775KQkGBGQkxMTKzRPADi0M6/RRa9J7L2V09ItWN18DyuJJHWfXxCqoGeulROZyTWGAAAAABiO7hatmyZ6R7YuXNnmTJlirmEctZZZ8l9990n4fbnn3/KtddeK/PmzTNh1B9//CE9e/aUN954Q9q0aVPledR3330nZ555pjRr1kwKCgqkpKREPvjgA+nbt2+15gEQR0qKRf76XGTWFM+1X20qh0jz7gF1qXqLJNASFQAAAADqpTj7nDlzZNq0aZXO179/fxk6dKiE2zfffGMCpOOPP97cz83NlSOPPFI6dOgg7777bpXn2bNnj+y1114yYsQImThxoujm0dsLFiyQhQsXisPhqNI8laE4OxAjtq8UmfWyyJypIrvWl03veKhI12PK6lJpN0AAAAAAgETNqIKRdu+998oTTzwh69atq/I87733npx++umydu1a05VQzZo1yxSXnzlzphx44IFVmqcyBFdAA1ZcKPLnx57WVcuma7V1z/S0ZiL9zhUZcIFI826RXksAAAAAiEpRMapgKG+++abMnj27TroKhjJjxgzp0aNHtebRlmOtWrXyBlKqX79+4nQ6Ze7cuSaUqso8gbSll158PyQADcyWpZ6wau6rIrs3l03fa5DIwAtEegyl+x8AAAAAhFG9BleapG3atKlK82pDsM8++6zCeZo2bSoHHHBAyMfskQ2//vrrcp8fap4dO3aY5frSQEqTwO3bt1d5nkATJkyQ8ePHV/h+AEShonyRxR96AquV35dNb9RapP95Iv1HijTtHMk1BAAAAICYVa/BVXVocKX1oyrSp0+fkMGVduUbPXq0PPXUU6aGVSjlzZOUlGRqWAXSafpYVecJNHbsWBkzZoxfi6tIjLoIoIo2LRb5fYrIvNdE9pQG0g6nSNdjPa2ruh0v4oraXSgAAAAAxISo/dWlLZi0NVR16ch+Z599tjzyyCNy+eWXV3ueTp06mdERi4qKJDEx0UzbsmWL5Ofnm8eqOk+g5ORkcwEQxQp3iyx81xNYrf2lbHpme5EBozwtrLLaR3INAQAAACCuOCWG6KiGZ511lvz3v/+VK664okbzHHfccabl1Oeff+6d9vbbb5vQ6aijjqryPAAakPVzRaaNEflPT5H3r/SEVg6XSM+TRM57S+S6eSJH3UJoBQAAAAANtcXVq6++KjfddFOF8+Tl5ZnR+OrCd999J2eeeaacdNJJstdee/m11hoyZEiV5+natasJtC655BJTk0pbUd1+++1y2223SZMmTao8D4Aol58jsuAtT+uq9XPKpjfp5BkVsN95IhmtIrmGAAAAABD3HJYWkwoDHWlPWzNVpn///jJ06NCwb/g33njDFFsPxQ6oqjKPcrvd3sLtCQkJMmzYMNO10FdV5gnX0I8AwkR3d3//LvL7ZJEF74gU7fZMdyV5Wldp7apOR2hfZTY5AAAAANSR6mQiYQuuUD0EV0A90uLq897wtK7atLBsevPuntZVfc8RSW/GRwIAAAAAUZaJRG1xdgCoFc3kV//kaV216H2R4nzP9IQUkX2GiQy8UKTDQSIOBxsaAAAAAKIUwRWA2LJ7i8jcV0VmvSSyZUnZ9Fa9Pa2r+gwXSaUWHQAAAAA0BARXABo+t1tkxbcis6aILJ4m4i7yTE9MF+l9usjAi0TaDaB1FQAAAAA0MARXABquXRtE5kz1tK7avrJsetv+ntZV+54pkpwRyTUEAAAAANQCwRWAhsVdIrL0K0/rqj8/EbFKPNOTM0X6nOUJrNr0ifRaAgAAAADCgOAKQMOwY43I7Fc8l5y1ZdOzD/SEVb2GiSSlR3INAQAAAABhRnAFIHqVFIks+czTuuqvL3SoQM90La7e9xyRAaNEWu4d6bUEAAAAANQRgisA0WfbCk/dKq1flbuxbHqnw0UGXijS8ySRxJRIriEAAAAAoB4QXAGIDsUFIn985GldtfybsunpLUT6nevpDtisSyTXEAAAAABQzwiuAETWlr9Efp8sMvdVkbytpRMdIl0Giwy8QKT7CSIJSRFeSQAAAABAJBBcAah/RXtEFr0v8vsUkdUzyqZntBHpf75I/5EiTTryyQAAAABAnCO4AlB/Ni70hFXzXhPJ3+mZ5nCKdDve07qq67EiLnZLAAAAAAAPfiECqFsFuSIL3/EEVn//VjY9q4NnVMD+54lktuVTAAAAAAAEIbgCUDfWzfaEVfPfEinc5ZnmTBDpcaKnddVeg0WcTrY+AAAAAKBcBFcAwke7/81/0xNYbZhXNr3pXp5RAXV0wEYt2eIAAAAAgCohuAJQO5YlsvZXz8iAC98VKcrzTHcliex9isjAC0U6HSbicLClAQAAAADVQnAFoGbytonMe93Tumrz4rLpLXp6Wlf1PVskrSlbFwAAAABQYwRXAKrXumrlDyKzpogs+kCkpKB0T5Iq0us0T+uq7ANoXQUAAAAACAuCKwCVy90sMvd/ntZV25aVTW+9r6d11b7DRVIbsyUBAAAAAGFFcAUgNLdbZPl0T+uqPz4WcRd5pic1Etn3TE9g1bY/rasAAAAAAHWG4AqAv5z1IrNfEZn9ksiO1WXT2w30dAXsdbpIciO2GgAAAACgzhFcARApKRZZ+qWnddWSz0SsEs9WSc4S6TvC07qqdW+2FAAAAACgXhFcAfFMW1TNetnTwmrXurLpHQ72hFX7nCqSlBbJNQQAAAAAxDGCKyDelBSJ/PmJp3XV0q90qEDP9NSmIv3OFRkwSqRFj0ivJQAAAAAABFdA3Ni6TGTWSyJz/ieye1PZ9M5Higy8QKTnSSIJyZFcQwAAAAAA/NDiCohlxQUiiz8U+X2yyMrvy6antxTpf56ndVXTvSK5hgAAAAAAlIvgCohFm/8U+X2KyNxXRfZsK53oEOl6jKd1VfchIq7ECK8kAAAAAAAVI7gCYkVhnsii9zyB1ZqZZdMz24n0HynS/3yRxtmRXEMAAAAAAKqF4Apo6DbM94RV894QKdjpmeZweVpVaesqbWXldEV6LQEAAAAAqDaCK6AhKtglsuBtT2C1blbZ9MYdPXWr+p0nktkmkmsIAAAAAECtEVwBDYVleUIqLbS+4B2RwlzPdGeiSM+hntZVnY8ScTojvaYAAAAAAIQFwRUQ7fbsEJn/pqd11cb5ZdObdRUZcIFI33NEGrWI5BoCAAAAAFAnCK6AaG1dtXqmyKwpIgvfEyne45nuShbpNcwTWHU8RMThiPSaAgAAAABQZwiugGiye6vI3FdFZr0ksuXPsukt9/GEVX3OEklrGsk1BAAAAACg3hBcAZHmdous/N7TumrxhyIlhZ7piWkivU8XGXChSPv9aF0FAAAAAIg7BFdApORuEpkz1VO7avuKsult+npaV+07XCQlk88HAAAAABC3CK6A+uQuEVk2XWTWZJE/PxFxF3umJ2WI9BnuCaza9uMzAQAAAACA4AqoJzv/Fpn9isjsl0V2rimb3n5/T1ilXQKT0vk4AAAAAADwQYsroK6UFIv89bmndpVeW27P9JTGIn3P9gRWrfZh+wMAAAAAUA6CKyDctq8UmfWyp37VrvVl0zseJjLwApG9TxZJTGW7AwAAAABQCYIrIByKC0X+/MhTaH35NyJieaanNRfpd46ndVXzbmxrAAAAAADiNbj6888/5ZVXXpElS5ZI27ZtZdSoUdK/f/9qz3PqqadKSUmJ37TLL79cTjnlFO99y7LkpZdekk8//VQSEhJk2LBhcsYZZ9TxO0TU2bLU0xVwzv9E8raUTd9rkKd1VY+hIglJkVxDAAAAAAAaLKfEiLfffltOP/10SUlJMdcul0sOOOAAeeONN6o1j/roo4/M9NGjR3sv++67r9881157rdx0001y2GGHSb9+/eSCCy6QCRMm1Nv7RQQV5YvMe0PkxaEijw8UmfGoJ7Rq1Frk8BtErpkjMuo9kV6nEVoBAAAAAFALDkubDsWALVu2SNOmTcXpdPq1kpo5c6bMmzevyvMobUE1bdo0GTJkSMjXWrZsmXTr1k3ef/99Ofnkk820p556SsaMGSPr16+Xxo0bV7q+OTk5kpWVJTt37pTMzMxavXfUk02LPV0B570msme7Z5rDKdL1WE/rqm7Hi7hiqhEjAAAAAABhV51MJGZ+ZTdv3jxoWuvWrc3GqM48tkceeUQmTZoknTt3lpEjR0qfPn28j33++eem1ZZvsHXmmWfK//3f/8k333xjug0iRhTuFln4riewWvtL2fSsbJH+I0X6nyeS1T6SawgAAAAAQMyKmeAqkKZ2L774ordFVHXm6dSpkxx11FHSoUMH+eqrr2S//faTl19+WUaMGGEeX7FihbRq1UoSExO9z2nRooUJs/SxUAoKCszFFiosQxRZN8dTu2r+WyIFpZ+VM0Gk+xCRgReKdBks4nRFei0BAAAAAIhpURtcud1uv2LooWjdqVB1pQoLC+Wss86S1NTUcutOVTTPrFmzvE3VzjnnHMnIyJArr7zSzO9wOMxz09LSgpapy9LHQtHXGD9+fIXvBxGWnyOy4C1P66r1c8qmN+ksMmCUSL/zRDJaRXINAQAAAACIK1EbXGlApEXRK9KsWbOgaUVFRaZl1NKlS023Pe0zWd15AvtXaousiRMnysqVK03XQa1htW3btqCgTVtwlVffauzYsaYGlm+Lq+zs7ArfH+qBlnhb+5vIrMkiC94RKcrzTHcliex9ssiAC0Q6HS7iUxcNAAAAAADUj6gOrk466aRqPae4uNgEUnPnzjWBVKhgqCrzBNq+3VOI2+4a2LdvX9m4caNs2LDB1MhSujwNr/SxUJKTk80FUUKLq+vIgL9PFtm0qGx68+6esKrvOSLpwcEoAAAAAACoPzEzqqAGUmeffbbp5qeBlNanqsk83333nWnJ1atXL3N/69atctxxx5mRCH/99VczLS8vz7S8Ov/88+U///mPt0vh7NmzZdGiRX6jFpaHUQUjQP+pr5rhqV216H2R4nzP9IQUkX2GeWpXdThIU9NIrB0AAAAAAHEhJx5HFXzqqafk7bfflgEDBpjR/XxNmzatyvM0bdpULrnkEtm1a5cpuD5nzhwz/wsvvOCdV+tbvfbaa2YkQR1hUIuua5j14YcfVim0Qj3bvUVk7que2lVb/yqb3qq3p3VVn+EiqU34WAAAAAAAiDIxE1ydeOKJphVUbefp3bu3/PTTT7JkyRJZv369mb9jx45B8w0aNEjWrFkjv/zyiyQkJMj+++9PV8Bo4naLrPjW07pq8TQRd5FnemK6yL5niAy4UKTdAFpXAQAAAAAQxWKmq2BDQ1fBOrJrg8jsV0RmvyyyfWXZ9Lb9PV0Be58hkpxRV68OAAAAAAAqEZddBRHH3CUiS7/yFFpf8qmIVeKZnpwp0ucsT3fANn0ivZYAAAAAAKCaCK7QcO1YU9q66hWRnLVl07MP9LSu0oLrSWmRXEMAAAAAAFALBFdoWEqKRJZ85mldtfRLHSrQM12Lq/c9R2TAKJGWe0d6LQEAAAAAQBgQXKFh2LZCZNZLInOmiuRuLJve6XBP66qeJ4kkpkRyDQEAAAAAQJgRXCF6FReI/DFN5PcpnhECbektRPqd66ld1axLJNcQAAAAAADUIYIrRJ/NS0RmTRGZ+6pI3tbSiQ6RLoNFBl4g0v0EkYSkCK8kAAAAAACoawRXiA5Fe0QWve9pXbV6Rtn0jLYi/c/3XJp0jOQaAgAAAACAekZwhcjasMDTumre6yL5Oz3THE6Rbsd7Wld1PVbExT9TAAAAAADiEYkA6l9BrsjCdzytq/7+rWx6VgfPqID9zxPJbMsnAwAAAABAnCO4Qv1ZN1vk98ki898SKcz1THMmiPQ40dO6aq/BIk4nnwgAAAAAADAIrlC3tPvf/Dc9ras2zCub3nQvz6iAOjpgo5Z8CgAAAAAAIAjBFcLPskTW/OKpXbXwXZGiPM90V5LIPqd6AqtOh4k4HGx9AAAAAABQLoIrhE/eNpG5r4nMeklk8+Ky6S16esKqvmeLpDVliwMAAAAAgCohuELtW1et/MHTumrRByIlBaX/slJFep/uCayyD6B1FQAAAAAAqDaCK9Tc2t9E3rlcZNuysmmt9xUZeKHIvsNFUrLYugAAAAAAoMYIrlBzWe1Ftq8USWoksu+ZntZVbfvTugoAAAAAAIQFwRVqLqO1yHlvimQfKJLciC0JAAAAAADCiuAKtdP1aLYgAAAAAACoE866WSwAAAAAAABQOwRXAAAAAAAAiEoEVwAAAAAAAIhKBFcAAAAAAACIShRnjxDLssx1Tk5OpFYBAAAAAACg3tlZiJ2NVITgKkJ27dplrrOzsyO1CgAAAAAAABHNRrKysiqcx2FVJd5C2Lndblm3bp1kZGSIw+Fo0Cmphm9r1qyRzMzMSK8OEDX42wD4uwA4ZgB8nwL4nRGaRlEaWrVt21aczoqrWNHiKkL0g2nfvr3ECg2tCK4A/jYAjhkA36cAfmsA/AavispaWtkozg4AAAAAAICoRHAFAAAAAACAqERwhVpJTk6WcePGmWsA/G0AHDMAvk8B4cJvDYC/C0VxdgAAAAAAAEQlWlwBAAAAAAAgKhFcAQAAAAAAICoRXAEAAAAAACAqJUR6BdBwbdy4UX7++WdJT0+Xww47jALtQKlVq1bJzJkzpV+/ftKjRw+2C1B6zJg9e7akpaVJ//79JSMjg+0CiMiaNWtk7ty5kpWVJQMHDjR/IwA83G63vP322+bvYujQoWwWxLVff/1Vli1b5jetSZMmcvzxx0usI7hCjbz00ktyxRVXyH777SebNm2SPXv2yOeffy7du3dniyJu/fHHH3LTTTfJggULZP369XLPPfcQXCHu5eXlyT/+8Q+ZPn269O7dW7Zu3SrLly+X559/XoYNGxb32wfxa9euXXLxxRfLrFmzpFevXuakx99//22+Y5144omRXj0gKtx9991y3333SXZ2NsEV4t4zzzwjX3zxhRx88MHebdGpUyeCKyCUtWvXyuWXXy4TJ06U0aNHS0lJifmCdckll8j333/PRkPc2rlzp1x22WXmi1W7du0ivTpAVCgoKDBfqCZPniwul8tMGzdunJx33nmyYcMGWl4hbulJPw2u3nzzTe+0K6+80hxHNMAC4p3+rpgyZYr53fHJJ59EenWAqHDwwQfLa6+9JvGGGleotrfeest0C9QvW0p/iFx33XXyww8/yMqVK9miiFsHHnignHLKKd4f5wA8TdjPP/98v7+LM844w7TE+uuvv9hEiFstW7aUE044wW+adi/Pzc0Vy7Iitl5ANNi2bZuMHDnSnPTQbrQAyv423n//ffnuu+/MSfN4QVdBVNv8+fPNF6ukpCTvtH333ddcaxcpba4IAEB5vvzyS3MCpFu3bmwkxD098bd69WpTt2TSpEnyxBNPiMPhiPvtgvimJ8jPPfdcOeKII0w5EgAeWi9UuwxqLyg9djz22GMm5I11BFeoNk12mzZt6jetWbNm5nrHjh1sUQBAubQI9Z133im33XYb3QQBETPQzU8//SSLFy+W5s2bS5cuXdguiGv6Q1y7y/p2owUgpszC448/LikpKWZz/Pvf/zblenRgj3322SemNxFdBVFtepZcm7H7su/bf0QAAAT6888/ZciQITJ8+HC5/fbb2UCAiNxwww2mDMPChQtNPTitk5iTk8O2QVzasmWLGejm5JNPNqMJai2fRYsWmd8aepv6b4hngwYN8vu9rceP9PR0+fTTTyXWEVyh2vRMoDZL9KUj4ai99tqLLQoACLJkyRIZPHiwHHvssWZEQbpCAcG0u8f27dtN6QUgHml9Nx1xVsOq9957z1z0pMfu3bvNbR21GYCHfpdq1KiRbN68WWIdXQVRbTqCoA5Nq03btRi1ev3116Vt27bSr18/tigAwI8WYdezhEcffbQptOt0ct4M0FE1W7Vq5Rfi/v777+a6ffv2bCDEpRYtWgSNmKYtdHVaPI6kBthKSkpMYXb9G7H98ssvptbV/vvvH/MbiuAK1XbQQQeZYolnnnmmaZ64bt06mThxokydOpUfI5B4r/9mD9ecn58vc+bMMV+y2rVrJ4cffnikVw+ICP2SpS2ttJu5dhN84403vI9p0V096QHEo6+//lqefPJJOemkk0yApYPfPPfcc3LjjTdKhw4dIr16AIAoUlRUZL43aSMSrWelPZ60Htypp55qWinGOofFeLuoAbfbLS+99JIZhjMtLc0EWYcccgjbEnFNz3joD45AAwYMkJtvvjki6wRE69+FuuWWW6R///71vk5AtNCwSsNcrdujJzn0B8h+++0X6dUCoor+jcyYMcOcKAfiWW5urkyZMsWcHG/SpIkceeSRpi5iPCC4AgAAAAAAQFSiyAQAAAAAAACiEsEVAAAAAAAAohLBFQAAAAAAAKISwRUAAAAAAACiEsEVAAAAAAAAohLBFQAAAAAAAKISwRUAAAAAAACiEsEVAAAAQioqKpKJEyfKhg0b2EIAACAiCK4AAACiwKOPPioLFy40twsKCkxgtGnTpnp7/VCvqdOuv/56WblyZb2tBwAAgC+CKwAAgCgwZswY+emnn8ztPXv2mMBo9erV9fb6oV4zKSlJrr32WmnTpk29rQcAAICvBL97AAAAiLhnnnnGXL/66qvyww8/SKtWreScc84x0/7++2/56quvpKSkRPbbbz/Zd999vc/Ly8uTZ599VkaOHCnz5s2TxYsXy5FHHim9evWSJ598UgoLC8XlckmHDh3kqKOOkqysrApf88wzz5ROnTpJcnKy3/rpcr///nsTbB199NGSnZ0dch2WLl0qCxYskLZt28rxxx8vTifnTAEAQPXw7QEAACDKrFmzxlyvX7/edNPTazV58mQTQn344Yfy3XffyeDBg+XWW2/1Pi8nJ8e0mho6dKjcfvvtJmDatWuXeWzVqlVmWX/++af85z//kZ49e5pQqaLXDNVV8L777pMBAwbI119/LW+//bZ069ZN3njjjaB1OPnkk+Wmm24yrcguueQSOeOMM+phywEAgFjjsCzLivRKAAAAxLuEhAR5+umn5dJLL5UdO3ZIkyZN5NdffzWtqtSyZcukd+/epqWTPU0DJQ2yNEQ68MADTRF17dY3atQomTJlSoWv93//93+ybt06ee+998z9UK+Zm5srGRkZJnw66KCDTOil6/DOO++YYEpNmDDBBGG6ftqCy16HK6+8Uh5//HEzz6JFi8x6alCm1wAAAFVFV0EAAIAG4K233jLB0MyZM721sPT8Y9OmTWXGjBkmuLJdcMEFQc/Xeb/99lvTfU8DKe3SN3v27Gqtw0cffSTt27f3hlbqmmuukdtuu82swwknnOCdfu6553pv77PPPpKWlmbCLYIrAABQHQRXAAAADcDatWtNqywNnnxpF7wePXr4TWvZsqXffQ2qtKbV9u3b5bDDDpPGjRvL1q1bZdu2bdVaB+1OqMGVr/T0dBOe2V0NbZmZmX73ExMTTY0tAACA6iC4AgAAaACaNWtmridOnFjt57722muyefNmWbJkibfQuhZjnz59erWW07p1a7McX0VFRaaboT4GAAAQbhRnBwAAiDKNGjUyI/Bpdz6bds/TEQU1hPK1cePGoDAp0M6dO00LKDu00hEJX3755UpfM5COIKjh1y+//OKd9sorr0hKSoqpgQUAABButLgCAACIMtolUGtW3XHHHXLKKadI27Zt5ZxzzpF7771XRo4cKZ988onpHqgh0o8//iifffaZtGjRotzlDRs2TMaNGydnnnmm9OvXTz7++GMzymBlr+lby0pp0fbRo0ebWlaXX3657N69W5599ll58MEHg7onAgAAhAMtrgAAAKLAtddea0bss3344Ydy+umny/r1681F/fOf/5RZs2bJ3nvvbepWaQuoOXPmyF577eWtN6XLad68ud+yu3TpIvPmzZP+/fubsOn66683hdZ15D9fga+ZlJRklqejBNqefPJJmTp1qjgcDjMKoRZ81wLttvLW4YorrpBu3bqFeasBAIBY57B0iBkAAAAAAAAgytDiCgAAAAAAAFGJ4AoAAAAAAABRieAKAAAAAAAAUYngCgAAAAAAAFGJ4AoAAAAAAABRieAKAAAAAAAAUYngCgAAAAAAAFGJ4AoAAAAAAABRieAKAAAAAAAAUYngCgAAAAAAAFGJ4AoAAAAAAABRieAKAAAAAAAAUYngCgAAAAAAAFGJ4AoAAAAAAABRieAKAAAAAAAAUYngCgAAAAAAAFGJ4AoAAAAAAABRieAKAAAAAIAasixLjj/+eHniiSfYhkAdILgCAAAAAKCGVq1aJZ9//rk4HA62IVAHEupioQDq17vvvit77bWX9O3b12/6Dz/8IPn5+XLMMcfwkQBAjPj111/lww8/lLVr10pRUZH5oWRfunTpInfccUekVxEA4sqCBQvMda9evSK9KkBMIrgCGrj169fL6aefLo8++mhQcHXxxRfLvvvuS3AFADFizJgx8vDDD0vv3r2lT58+MmfOHFm0aJG4XC5p3ry5nHXWWZFeRQCIK1deeaV8+eWX5vbNN98sqamp5kSCnljWE8hnn322XH/99Wa//cgjj5h99tixY2XgwIFy2mmnmW6GKjk5Wdq3by8jRoyQ4447Luh1dH//v//9zzw/JSVFjj76aLn00kslMTHRO8/ixYvlpZdekvnz55t5DjvsMPm///s/SUpK8s5TUlIib775plnndevWSXZ2tlmPIUOG1Mv2AmqCroJAAzd79mxzrQc/Xzk5ObJ06dKg6eXRg9dFF11UpXlvuOEGee2112qwtgCAmnr66adNaHXnnXfKvHnzZOrUqeaHzMEHH2x+uKxYscKcxKjM448/Lvfff3+VXlN/yOgPIABAaOeff740adLE9H544IEH5F//+pfcdddd0rhxY/nll1/k22+/NS1ltTXs4MGDpX///pKeni5Op1PGjRtn5tfLVVddZUIv3e++8cYbfq/xz3/+U/bff3/Jzc2VCy64QIYNGyZffPGF3HTTTd55/vvf/0q/fv1k+/btctlll5nw68EHH5QTTjjBG45pkHbooYea9dRjxzXXXGNOct9yyy0yZcqUKn3E33//vRQUFFQ639atW72/U4DaosUV0MDpAUHPtOuBytesWbPMQaqqwdVPP/1kzsxUxaeffionnnhijdYXAFB92iVw/Pjx5uy5/sCx66hoYHXGGWeYfbh2VdEfNpWZPn16yLP5gXbv3m1+GOnZeABAaBoAaQ8IDYSOOuoov8d+++03c60nFvRkg+67NXQqLCw0raAC5z/55JPN9+yPPvrI24JWQ6Z///vf8tlnn5ngyzcw0xPVSoMuPbH83HPPmVZYto4dO5ogTE9QH3vssabF1s8//yxbtmyRZs2aeee74oorZM+ePZV+xNu2bTMtvTRAq4ye5NbjzVtvvcU/HdQaLa6ABk4Dqp49e0paWlrQdFXV4ErPqGu3k8rogXbJkiWyzz771HCNAQDVpTULN2zYYFrGllf8N/A4UNv9/cKFC6V169am1QAAoPwwZ/Xq1UEnke3gKiEhwQRPvvtuDa3cbre88847pqXVKaecYkIsvaxZs0ZatWpl5tOufHqy4tprr/ULrWyZmZlSXFxsuiIeeOCBfqGV0jBNafdCuxWU0m6M+vo2PQneqFGjSj9ibe3bo0cPv66HFR1r+L2AcKHFFRADLa4OP/zwoOm///67OcuiNU9sZ555pvzxxx/mAKph13333WeaNdsHIm0urLRZsdKzKXrWRw9Q2j1Fl6UHPj2waR/6Sy65RHbu3Cm33XabtwWWNnl+++23zcFZz9LrY/ZBEwBQM7pPV6FaVM2dO1cyMjJMYXalP2J0Pm2lpS1pDzjgAJkwYYJkZWVJXl6eLF++3NRasWsh6o8h7fphH090Xv1RoscF/dExefJkeeGFF0wXFj0W2D9EtG6LtvLSY4oeJ/SYYq8DAMQL7bKttAtgqH23fg9u06aN33QdXENbQmnXPd0PDxo0SJo2bWq+Z2vXQjsE0+/UOk9gIOVL998acGmNLB2Qye4WqNd6PFB2KKUnPz744APTlVC7LmorLG21q8GZHazpumm5Eb2vAZr+ZrDpcUG7FtqtcvW+tjjT9db59957b795NXDTrot//fWXOXbY66G/H+xuhHpyRIva+9bqAgIRXAEN2I4dO0zT46uvvtpvup5B+frrr+WQQw7xm37vvfeaHzLaL33SpEkmeNImvHpAXLZsmfdApM/Vg432p9cfKdr0WAOoZ555xkzXoo6vvvqq3H777fLVV1+Zg6keMJUuc/jw4WYeXfapp55qmk9zMAKA2p3RV1oXxZd2E5k2bZr50eHb3fvll18217t27TJdDPWMve7PNWjq0KGDCbrUxx9/LDNnzjQnHfTkhv6A6tq1q+k2ovt7/UF2xBFHyEMPPWTqZ916663mR4/S5eoxRVviarB14YUXmh9QABBP7AAmMLjSVlibNm0yLapCDbSh3fU08NHAyrd1rbKDqz///NOcHOjevXu5r6/zKK1d2LJly5Dz2K1s9SS07qf1RLZ2H9QTE3q8uPHGG81+Xmk3Rf2er78ndNkaTGkLLQ2mfFvsasCmvxH0RLm2CNbfElp/S+soamimx5vvvvvO1PvS44T+/tDjigZVus30uGRvJz1+aZd3PcEChGQBaLCmT5+up1SsBx54wG/6s88+a6bfc8895T535cqVVtOmTc3t3377zerYsaP3sbZt21pPP/209/5bb71l9e/f39y+8cYbraOOOsr72OrVq620tLRyX6d58+bW8uXLa/gOAQDqySefNPt1331zSUmJNWrUKLMPXrhwYbkb6r333rMGDx5sbk+aNMk69dRTze1NmzaZZc6cOdM77+23325ddNFF5rbu62+44QbvY++88451xBFHhHyNtWvXWpmZmXxYAOLOyJEjzXfnQG+//bbZx37xxRdBj7Vv394aOnSo37SdO3da2dnZVkpKilVcXGym3XLLLWYZ+lh5nnnmGTPPggULqr3u+jpdunQpd9++e/du897mzp1r7h9wwAHWtGnTzO3777/fysjIsH7++Wdzf/bs2ZbD4bC2b99uvvvrOt11113e41XXrl2tzz77LOg13G63deyxx1rPP/98tdcf8YMWV0ADpnWstE+6nkVX2pz3xx9/lA8//NDbr17PaOgZIG2mq0Pw6pkcPfujBRjtooy+zX6177s+rmfObdq1xD7Lr/Oee+653se03pV2EVHaHPnZZ581Z/+1BZbe11YCvmeSAADVp0V6dTRBrWOiLW1btGhhaqPoiFU6EpRvHRF9fOLEiWb/r/t+bZ2rZ8wD9/d6W7sMal2UUPt7PbOuo1SF2t/rMrUFlp5N12OGttz1LfQLAPFC93/6fVxbKOlIgTb9Hq73tbt2oM6dO5t9tO5LtQWSfl/W79d///23DBgwwCxPaXdCLc5+zz33mBZVujxtzfTmm2+afbe2dtLBNrR7t7ac1eOBvQ/XVk7ackoH9dBu3Npzol27djJ06FBvt0BtfaU1tQJbhWkrKO0yqMvQbuLaeldfV2sf2i2u9Bhx5ZVXet+fthLTHhbakkzn69Spk+mOqHS99aI1uWybN2+WlStXmi6H+jx9DaA8FGcHGjA94HXr1s0cvLQvuh589KChBwv9caNFde0fEjoUrnbZ0+5/r7zyijlo2U2afZv96m0NwLSfvO2TTz7xjnqij/sWfNfwrG/fvub2ddddJ++//745+L344oumX7setGj2CwC1o/tyDYl03/3666/L008/bX6waDc/35MJ+iNIf6RosKU1p3QEKa0dUt7+Xpdh0x8lOmqV7u/15IP+iLBrYQXu70866STzY0ePKdrNREfCClXfBQBi3eWXX272vfqdXPef//nPf7zBle5/fcMam54U0H2uBkr77befOaGg39W1K59vkXddnp4k0NEC27dvb0Kitm3bmtpZel/pd209kaEnI/QxnUdrTWn3wlWrVpnu4UoDMu3urddaB1FPRGitQj1W6Hd2pfPr87XciHYf1OBJuwDqeuq1Bkz2SLP6er4F4zXsUhqO6fFF63bZfOsr6m3tmq4nXDT40i6DWl6EGomoUKSbfAGouV69ellnnXVWpfNp82L9c9euHOr333+3WrZsaT300EPm/tFHH229+uqr5vajjz5qJSQkWIsWLfJ2DdF5N27caG3ZssU8lp+f7132OeecY02cONHc7tatm+mSovS1BgwYYI0YMYKPGADqybfffmu6dRQWFnq7qiQlJXm7qmj37cWLF5vbF198sdWuXTvTrUO7amiXjr59+5quI5988onVr18/v2XrPv6HH34wXUf0mKJdzu3uIa1atbImTJjA5wwgLu3atcuU3tAyHqtWrTLTtAtdRd339uzZY54zZ84cq6ioyHSn0+fb+1Zf+t1b992zZs2y8vLyQi5Pn6/P1e7feq33Q9mwYYOZZ+nSpeZ1fQ0fPtx0GfctF6LdGu3jyeGHH25u6zFGjy26vrabb77ZPN9eziOPPOJ9bMaMGaaroNISJ9pN0u4OqevhcrnMegHloasg0EBpVz8trHjOOedUOq+e6dERQ/RMhp6J0TMg2qLKHp0q8Ay8njnSUUmUNg/Wrn9a7FGLtuvIIr6tsbTV1z/+8Q9zW7sX6uvomRgt7qstrUKNgAUAqBvaIlbP2OtFW2mNGDHCFFDXM/raikpHi9VWAfb+/rzzzjP39cy/nn3XrubaRUXPpPue9dfn6dlyPVakpaWZ5er8ekzR4u16rGB/DyBe6Wh5vj0SVKgugr60IHngc+weDoH0u7fv6H6haFc8bUXr25I2FO1ZoZdQtGugHhv0u78WjtfuhaF+L2jRdv19oV3Yb7rpJlNY/aWXXpKff/7ZO6+2pvJtsWsfU/Q1tEuk9tLQLpJaZkSPJeWtE6Acml6xKYCGR+uaaN92Hd1Ju2hUhTb/1QOr/pjRg5H+WNEmvzrqhzbX1QOe1kHRPvR6kNK+574HPx26VptC+05bvHixCcS0b73auHGjqW2lzYS1zoq+Vqgm0gCAuqGjumrdEP0RoPtm7d6h3Ub0hId279PuI1qLRffNWsPErtGi3cttOkKUHhPsEar0h4a9HN9uIVpLRffzgccCAEDDo78VNIzSmrfDhg0z3/u167mOFnj33Xebrn6nnXaaqZ2l3RP19tSpU80J61tuucUEUHp80bpbb731lumWqLTuop7Qvuiii8yJEB2ZXMMv7ZKogZyeCNcui0B5CK6ABuqbb74xw81qv3c9SISD5tj6Q0brZXHWAwBi119//WVaSmntQwAAqkPrGyYkJMhdd93FhkO9oDg70EBpU2I9kxGu0EppCyltgUVoBQCxTbtx+LaeAmKNllPQQWO0RfmECROq9BztDjty5EjTpen444+Xjz76qM7XE2iItDt5ZV0XgXAiuALgpd1EtAsiACD2T35oPRIgFv3www+mC5Nd2kDLGFRGa+3oiJwFBQXy5JNPmlqfp556qhlZGYA/7QLISLKoT3QVBAAAABAzNHyyB5LRgQk0kNIaOxXR+jr//e9/TfdZbX2udPACLZ9gF5wGAEQGLa4AAAAAxAzf0Y+ravr06XL00Ud7Qys1dOhQ+fXXX00xaQBA5CRE8LXjmo62oMNSZ2RkiMPhiPTqAEBU04EDdu3aZWq66UhnDQn7ewCI/v29jrjZq1evoBIKuj76nV1H4wzVsksvvvt77XKoI23y/R4Awre/J7iKED0AZmdnR+rlAaBB0h8W7du3l4aE/T0ARP/+vqSkRJKSkkK23CouLg75HC36Pn78+HpZPwCI5/09wVWEaEsr+0PKzMyM1GoAQIOQk5Njwn5739mQsL8HgOjf32srqS1btvhNs+/rY6GMHTtWxowZ472/c+dO6dChA9/vASDM+3uCqwixmw9raEVwBQDV23c2JOzvAaDm+876sv/++8tXX33lN23GjBmmFUCrVq1CPkdbZIWqp8X3ewAI7/6+YRUKicI+matWrTJ92QEADYPWI1mxYoUUFRVV+Tlat2T58uWyadOmOl03AED9+Oabb6Rnz56yevVqc//SSy+VP//8U6ZMmWLuL1myRF544QUZPXo0HwkARBjBVQ0UFhbK3Xffbc6+DBo0SDp27GiG2p0zZ074PyEAQFgsWrRIzjjjDGnevLkMHjxYsrKy5Oqrry63dont66+/Nl0/DjroIHN9wgknyI4dO/hUACBKabFfDaX0snDhQnnppZfM7dNOO807j44UqEGVfq9Xffv2NaHV9ddfLy1btpR9993XzH/LLbdE8J0AABRdBWtg69atpnjj0qVLTVPg/Px8Of/882X48OHy119/8S8LAKLQzz//bPbVr7/+uiQkJJgfM0cccYS0aNFC7rzzzpDP0fom+sPlmmuukbvuussEVocddphceeWVMnXq1Hp/DwCAyqWnp8t7770XND0lJcV7W08+L1682JyAtukxYsSIEbJ27VpT14pyHgAQHRyW9ndDrT3//PNyxRVXmBCrKkP3aiEyPduvRRw5KAJAZPaZF1xwgenyrV1GQnnsscdM8V0NsOwfPJMnT5bLLrtMNm/eLI0bN670NdjfA0DVNeR9ZkNedwCI5n0mLa5qQUcE3L59u6l78uCDD8pNN91UpdAKABA93Qe1+0h5fv/9d9N9xPcs/SGHHGK6F86dO1eOPPLIelpTAAAAID4RXNXCww8/LJ988okp6jhw4EC5/PLLKywGrBffdBEAEDkTJ0404dOzzz5bYdfwwGHQ7fuBw6bb2N8DAAAA4UNwVQv//e9/zSUvL0/+8Y9/mFopf/zxh6SmpgbNO2HCBBk/fnxtXg4AGrSHv1gi1x/bXaKB1rm6+eabZdKkSdK/f/9y59NaWHv27PGbZp+ESExMDPmcsO/vp0/w3vxp+dbwLVdEZnYo/4SLr2j53AAAABB/6NcWBmlpaXLbbbeZllezZs0KOY/WSNG+m/ZFuxkCAOrfW2+9JaNGjZKnn37aXFckOztb1q9f7zfNvq+PhcL+HgAAAAgfgqsasIfN9aWjjygtLhZKcnKyKTjmewEA1K+3335bzjvvPHnyySfl4osvDrl/X7BggRlK3R51av78+d59vProo49Md0EdKj0U9vcAAABA+NBVsAZefPFF+eWXX2TYsGHSunVrM6T6uHHj5MQTT5TevXuH8eMBAISLBk7nnHOOXHXVVXLggQeagMoOmrp162Zua8tZDaQ+/PBDOemkk+SUU06R/fbbT8466yy5++67zQiE999/vzzwwAOmGyEAAACAusW37hrQIuxNmzY1AZaehW/Xrp0JrkaOHBn+TwgAEBZ6wqF79+7y+eefm4utQ4cO8vHHH3tDrF69enlbxbpcLvn000/lrrvukltvvVUyMjJMa60LL7yQTwUAAACoBwRXNeBwOGT48OHmAgBoGLRgemVF07Vuld0Sy6YnKnQEQgAAAAD1jxpXAAAAAAAAiEoEVwAAAAAAAIhKBFcAAAAAAACISgRXAAAAAAAAiEoEVwAAAAAAAIhKBFcAAAAAAACISgRXAAAAAAAAiEoEVwAAAAAAAIhKBFcAAAAAAACISgRXAAAAAAAAiEoEVwAAAAAAAIhKBFcAAAAAAACISgRXAAAAAAAAiEoEVwAAAAAQYUUl7kivAgBEpYRIrwAAAAAAxLvnvl8ubrclqUkJkprokrQkl6SUXvveTtX7iQnmOimBdggAYh/BFQAAAABEgaISS4r2FEnOnqIqzZ/gdHiCLA27kpySWhpomYAr0RV0OznBVefvAQDCjeAKAAAAQMz5+eefZf78+dKqVSs57rjjJDk5ucL5i4uL5ZtvvpFVq1ZJkyZN5IgjjpDmzZtLNCt2W7Irv9hcqhN0+QdaZS28zGM+rb30AgCRRnAFAAAAIKZceuml8u6778rxxx8vs2fPlltuucWEUi1btgw5//r16+Woo44ytw877DBZsWKFjBo1Sl599VU5+eSTJVZUN+hyOR3ldFlMCNmii6ALQF0guAIAAAAQMz744AOZPHmyzJo1S/r06SN5eXlywAEHyNixY+X5558P+ZynnnpKdu3aJcuWLZPU1FQz7YILLpDbb789poKr6iqpQdBlh1jBrbhKuzMmJUha6TxJLqc4nY46fx8AGjaCKwAAAAAx4/XXX5dDDz3UhFYqLS1NLrroIhk/frw899xz4nQGFzRPSEgwgVVKSop3mnYX1OmoXtCVW1BsLlWl3RcTE5yS6HJKksthrs0loey+FqG3p2vYlZhQOt2eV+cz83suhGFAbGFPDAAAACBmLFq0SA488EC/aXvvvbdpUbV27Vrp0KFD0HOuueYaUxPrpJNOkkGDBsnKlStN18IXXnih3NcpKCgwF1tOTk6Y30l80O6LxYUlskdKwrZMbfmVVEkY5g3CSkMwOyALFYbpfV0mgMgguAIAAAAQMzSgaty4sd80bT1VUbikrbCaNm0qv/32mynmbncZTEpKKvd1JkyYYFpxITpbfu2pgzDMDrR8W4Dp/WS/+/5hWGArMZfDYVqE6fI8t7XVGcEYUBGCKwAAAAAxQwMnDa982YGVdhsM5dZbbzWh1Zw5c7yjD15//fVy6qmnyvLly8XlCh5dT2tmjRkzxu81srOzw/xuEE1hWIm7RPKL6u41TJjldIjT4TBdKE3A5fBM19tmmqM09Aq4rSGYPZ9923MR//m8gVngfD7L02tXWbBmz+dw0OoMkUFwBQAAACBmdOvWzYwK6EvDJw2kyguWtJugdhG0Qys1ZMgQmThxoqxbty7k83Re3/mB8IRjVtRuSBOoueyAqywQKwvZyq7t+TwXEc28NPjS6MtMc4roPZ2u932vdbo+R5el8zu8yyidXhqg+T7P9zXMdJ/Hy+bxv+9dF8+LepftCHgN39cmvIsMgisAAAAAMeOUU06R0aNHm8Cpbdu24na7ZerUqXLCCSdIYmKimUdrWE2bNk1GjhwpWVlZ0rlzZzMKoWVZ3h+mv//+uynW3qZNmwi/IyA6uC1LCoujN1irD4HBmvINzuzAyzOvHbyZXMxzv/Rhc+X3uP9j9rTS/8TeL3kfC3hO8OvZIWDZepupvuvi+54qez3f5XnX09NtdmBHT1fsukRwBQAAACBmnH/++TJlyhTTguq8886TmTNnyuLFi+X555/3zrNgwQK5+uqrTasqDa7uvPNOOeyww+S4446TY4891rTQevHFF+X+++9nZEEAXpYlYoklpmFcFLeOqy9pSS6CKwAAAACojoSEBPn8889NK6v58+fLUUcdZUIr35ZT2sLqyiuv9BZx79OnjynI/vrrr8uqVaukU6dO8tNPP8mAAQPY+AAQYbS4AgAAABBTtEvghRdeWO7jvXr1kscff9xvWosWLeSqq66qh7UDAFQHwRUAAAAAAACqxGEVi9NdLInFUi8IrgAAAAAAAGKJ5RaXVWQCJr12adhkAie9XWRuu9yl197pOk+R33T7tpleOp9DPPW9HElp2tm6zt8KwRUAAAAAAEB9s6zSgMg3SLIDIk/Q5PILkorKn176HO9tqyRmPk+CKwAAAAAAgGp2l0ssyZfEkjxJdO+RpJI9kuDOLwufzHVJaWsnO3AqC6U8AZOGS4xOWBmCKwBA3NiwYYNMmjRJ3nnnHTnggAPk6aefrnD+devWmaHRAz355JNyxBFH1OGaAgAAoL6Zuk3uPZ4wqmRP6W3PJcmdJwl6XTrd5S7kA6onBFcAgLiwceNGE1aNHDlSmjdvLitXrqz0OYWFhbJw4UL5+OOPJTs72zu9Y8eOdby2AAAACAetyVQWRuVLUkmeJJS2kCoLpjytprSVFKIPwRUAIC40a9ZMli1bZoZIP//882XLli1Vfm63bt2ka9eudbp+AAAAqEYYVZInSX7BU37IllLaJQ8NG8EVACAuJCTU/JCnrbTcbrcJsK655hrTcgsAAADho13vggIobxc9T0spO5DS4uOIHwRXAABUYMiQITJ69Ghp2rSpqY118MEHy/vvvy8nnXRSyPkLCgrMxZaTk8P2BQAAccnlLggdQPkGVN4wKnZGwUN4EVwBAFCO9u3byyeffOK9f/jhh5suhrfeemu5wdWECRNk/PjxbFMAABA3tGh5WtE2SSvaLmmFW811avF2akYhLAiuAACoRvfCI488Ul599VUpLi4O+fjYsWNlzJgxfi2ufAu7AwAANOTaUnZAlVq0TdKLtklq4XbTagqoKwRXAABUw9q1ayUtLa3cmlnJycnmAgAA0FA5rBJJLdohqdqCygRVnkty8W4RsSK9eogzBFcAAJRas2aNnHDCCfLkk0/KEUccIVOmTJGePXvKgQceaB7/+eef5ZFHHjHF2gEAABo8y5Lk4hxPFz+fgCqlOEccljvSawcYBFcAgLhx1FFHmRpV2mqqpKREevfubVpH/f777+ZxLaq+cOFCb0H1/v37y7XXXivz5s2T1NRU2b59u/zf//2f3H333RF+JwAAANWTWLw7KKDSVlWM0IdoR3AFAIgbzzzzjBQVFflNczqd3tsdOnSQ+fPnS8eOHc39Pn36yPTp002QtWPHDlOs3Xd+AACAaBzJz1Mk3Q6n9HqHJLjzI71qQI0QXAEA4kaPHj0qfDwpKcm0wgqUmZlpLgAAANHCYRWbQCo1YDS/pBKtQwXEDoIrAAAAAACileU2NafSAgIqrU3loFA64gDBFQAAAAAAUSCpOLcsoCraKmmF2yWlWOtQlUR61YCIIbiqhblz58qSJUukbdu2ctBBB4nL5QrfJwMAAAAAiEkJJfml9ad8i6VvF5e7MNKrBkQdgqsamD17tlxyySViWZZ07dpV5syZY0Krjz76SLp06RL+TwkAAAAA0PBYbjNyX3rRFkk3Xfw8IVViyZ5IrxnQYBBc1YCOSPXiiy9K3759zf3i4mIZPHiwGSL9s88+C/dnBAAAAACIcg6rxIzk5wmpPBdtReW0iiO9akCDRnBVAwcccID/RkxIkCFDhsjjjz8ers8FAAAAABClnG4d0c/TikoDqkaFWyS1eLs4LHekVw2IOQRXYaItrewWWKEUFBSYiy0nJydcLw0AAAAAqCMud4E3oLJbU6UU7WREP6CeEFyFwYMPPigzZ86UGTNmlDvPhAkTZPz48eF4OQDxZvqE+n29QWPr9/UAAACiqGh6euFmSS8qDao0pCrepcWqIr1qQNyqUnBVUlJi6jrFosTExFqNBjhp0iS5/fbb5bXXXpOBAweWO9/YsWNlzJgxfi2usrOza/y6AAAAAICaSyrOLW1FVRZSJZXsZpMCDSm40lHzNmzYIDt27JBY1rhxY2ndurU4HI5qPe+FF16QK6+8UqZOnSqnn356hfMmJyebCwAAAIC69e2338p1110nCxYskJYtW5rbN910U4XP2b17t9xxxx3y6quvmpPMxx57rDz22GOcbI4RycU53nDKDqsY2Q+IgeDKDq10Z5+WllbtYCfaaTCXl5cnmzZtMvfbtGlT5edOmTJFrrjiCnn55Zdl+PDhdbiWAAAAAKpq5cqVcuKJJ5reDt98840p53HmmWeak9WXXXZZyOe43W45+eSTZfv27fL555/L3nvvLV9++aW89dZbcv3117PxGxLLkpTind6AqlHRFkkr3CoJ7rJ6wwBiJLjS7oF2aNWsWTOJVampqeZawyt9r1XpNvjJJ5/IxRdfbA5uGnxNnjzZ+9iFF15Yp+sLAAAAoHxPPfWUNG/eXO6++25z/4QTTjDf0f/zn/+UG1y98cYbppXWn3/+KV27djXTdNRwvSCKWW5JK9rmUzh9qwmpXFZslrkB4lW5wZVd00pbWsU6+z3qe65KcKVnZEaOHGlu61kcXwRXAAAAQORoC6sjjzzSb9rgwYPlySeflG3btknTpk2DnvP+++/Lfvvt5w2tEH0cVrGkFW6TRj4j+6UWbRenVRLpVQMQ6eLssdY9MBzvcejQoeYCAAAAILps3LhRDjjgAL9p2rPCfixUcLVixQrp3LmzXHLJJabGlfbK0LBLW2l16NAh5OsUFBSYi03rYiE8nO4iv4LpdkjlYGQ/IC456/PFXnnlFfnll19qvZzXX39dfvzxx7CsEwAAAIDYpj0mKjphrbVvtbughlebN2+W2bNnm+tTTjnF+9xAEyZMkKysLO+FEcNrxuUukMz8v6VNzlzpuuVr6bv+DTlg7WTptfED6bR9hrTYvcR0ByS0AuJXpS2uqkOb3k6fPl3Wr18vrVq1kgEDBkiXLl28j0+cONEURgw8A1KTfuuHHXaYHHrooWFYawAAAACxQgdcsgdfsmkIpfQ3SnnP0cvtt99u7qenp5saWUcccYQsW7ZMunXrFvScsWPHmgLwvi2uCK/K53QXS2rxDkkp2iFpRdtNCyrt8pdcnFvDTxpAvAhbcPXggw/K+PHjTSjVu3dv0yLqzjvvlH79+pnmtuE0YsQIczYEAAAAAHzpyW0d+VtbUdktrL766iszUmCTJk3MfX1MB6NKSPD8HDr88MODeobo46q8GrjJycnmAn8ud6EJpVKLdniuiz1BlSegsthcACITXD3xxBPyz3/+Uz7++GM57rjjvNP1gKAj8AVaunSpCbb0IKCjfPiOWjht2jT5448/zEFGRwM5+OCDpXv37n7P137pGRkZfl0QdR6dXt5yAQAAAMS+0aNHy2OPPSa33HKL3HjjjaZYu44Crr02bB999JEZIfyvv/4yBdl1xPCHHnpI7rjjDrn++utly5Ytctttt8khhxzCCfNyJJTkm2DKtJ4qtoOqHZJUsru+PmoAcaLWwZWeifjXv/4lF110kV9opTR8OvHEE/2mad9xDZq0q9+cOXPkpptuMtd2s92dO3fKhg0bzO3ffvtNrrrqKnMQ0QNQeV0FtQui9j0vLCwsd7kAAAAAYp8WU//ss89MNz49wa6/Bx544AG/0b+dTqc52W23yNKWWNoqS0Orjh07SuPGjeX444+X++67Ly4Gq6pIUnGuaTXlbUFlwqodkuDOj/SqAYgTtQ6uFixYYM5IDBkypErz68gbv//+u6SkpJiwqWfPnvLCCy+YPuLqvPPOMxfbp59+KsOHD5dRo0ZJWlpajZcLAAAAID5oS6mZM2eW+7ieXC8uLvab1qtXL/n8888lLlmWJJfs8uniV1qHqniH6foHAA06uNLQSrVr165K85966qkmXLLPdPTv398MP+tr/vz5MmvWLLNsbUWVm5triiLuu+++tVouAAAAAMQtyy0pxTne4ugmpCptTeW0/IM8AIiZ4Eqb0Sq7e19lMjMz/e4nJiaacMp2zTXXmK6E2u1Qm/XaxRB1xMLaLBcAAAAA4oHDKpbUop3ecCrN1KDabkIrh+WWeGJZnpLwbnGU3naIbgGr9L6ZbubzmR5433c+fX7pcsxyrbLpFT3mO92sV+l0veG5rQIetzzdVAMfN7fLW57Pe/ab3zuf5/3YzwmcR1+zbJm1Wx99vOy5/utQNk/w+tvbJORygj7fstf0XaZ3WSFeu9z5fbZL2TyB76nqr+v3HKv8917h8wOeZwteJ//l+r7nar2u378N/+eHfK7DJc2f/Uleu/xgiergSltBaWj0zTffyLBhw2q1rPXr15tCilrbauDAgWba2rVr5eGHHzaF3gEAAAAAHk53kd/IfXYdquTiXSF+ZlZfieWQIssphW6nFOq15Sy976r6fe9zXd5lmWvLWRomOYKCpZBBk+98gffLDaTiuz4ZUB/Wrd1Z569R6+AqKSnJjNZx7733mjpUAwYM8HtcQ6j99tuvSsvKyckx1zo6oE3rVAEAAABAvHIW75EULYhesENchTsloTBHnIW5IsUFJgDKt5yS4w2IUqXISi83TLJDo8D7noDJZ5rbKSXilHjiibo8cZfT4bnW+06H/Vjwfb/5zABlpdP1cd/5NGYz98vaxpTdLnueZz3K2vmYaT7L8U7zncdRzjJL16HsvQUs3/u8cpbvKFuHoOWHWCff9QlcZqjl+i+7bPm+77u85fgGs2Wv51mG72sFze/3nv3n93uOz3sv93VDvBf/5wQvw399/cPlyp7vCFiQ37+RkMspe89VWn7QeobeBr7PdSYmyz6Dz5eoD66UDhW7efNmM8rfaaedJr179zb1qbRYunb1+/rrr6u0nG7dusnBBx9shqY966yzZPHixfLjjz+GYxUBAAAAIOpoz5ILX/xVlm/OlaLiYnGXFEtJiVtK3G4pcltS5Pa0evL8dNefb81KL/UrweGWJEeJJDnckqi3ne6y2zrdad/23E/0e1zn93muXjvd4ioNisoNghxVC5N8QyI7PDLXpdPtrVfRa3lCiHrfrECD5khKk4N6tmwYwZUWQ3/00Ufl6quvNkPPape/Tp06yZlnnmlG9LCNHDlS+vTp4/fcoUOHmufby9FhaLXGlRZWP/LII80QtjoMbXZ2tvc5I0aMkM6dO1d5uQAAAAAQjRwOh/y0fKsUFvvWntIExVPrNxT/AMk/EPIESiV+AZF3/tIwyft4JeGS730NfADEEcsSp1UiLqvQjC6a4NbrAknwva+tsr4cL3LMuOgPrnxbTOmlPNdee23QtHPOOcfvfmpqqlx22WV+0/7973/73b/iiiuqvVwAAAAAiEYPndlHln3/uiS6C4LDJ2/Y5AmQ9ELLIACVstyecMkveCr0D558gijvNKtsXq1EV6mfFzas4AoAAAAAUD2n9msnP83dampWAYCntVOxJLgL/IKkioIozzSdv6j0ujgsG1KrWZU4kqTYmSQlpZdiR+nthHRp3fdYzzCGdZioE1wBAAAAAACEiUO72AWFSwVBLZqCW0CV3Q/HyKCqxJFQbvBU7Hc/WYqdiebab35HYrmhlNa4an30HVLXCK4AAAAAAACqQEOl5OJdklyS67kuzvXeTirZbYInrQ0VDm5xlIZNyf5hk0+wZN/3C6JKwye9bTkafu1vgisAAAAAAAATTBV4wiifcCqlpCyg0m54VVXsSAzRyik5ZKun4DAqWdwOF8NdElwBAOLN8uXL5b333pP27dvLWWedVaXn/PbbbzJjxgzJyMiQk046SVq0aFHn6wkAAIAwsywTPCV7g6jSa+/tXZJgFVW6mCJnshS4MqQgoVHZdUKGFLjSS7vc2V3sGn5rp2hAiysAQFzYtWuXCaqWLFkiTqdTunTpUqXgaty4cfLwww/LGWecIatWrZIbbrhBvvzySxkwYEC9rDcAAACqE0zle4OolBBd+rR4eWUKnalSmNBI8l12IFV6XRpUuZ2JfCT1iOAKABAXLMuSa665Ro4//ngZNWqUbNmypdLnzJ8/X+6++2758MMPZejQoWba6aefLqNHj5ZffvmlHtYaAAAAXpYlie495daY0rDKVYX6UhpMhQqkyoIpopJowqcBAIgLmZmZcsIJJ1TrOW+//ba0adNGTjzxRO+0yy+/3CxHW1917NixDtYUAAAgTlmWJJXkSVJJbmlrqYAufSW5lRY+17H4Cl3ppaFUYFc+zzTLQRTSkPBpAQBQjsWLF0v37t3F4TMEcI8ePbyPhQquCgoKzMWWk5PD9gUAAFCW2wRTZbWl7JZTZeGUU9wVbitLHFLoSvNvMeVqJPkJGVLoDaZcbO8YEtPB1V9//SUJCQnSuXPnSK8KAKABys3NlaysLL9pjRs39j4WyoQJE2T8+PESSx7+Ykm15j9o9bN1sh4zO1wu9eH6Y7uHb2HTJ1R51p+Wb43Itgh6v9VY52oZNLZultvQ1jfK/36j8u8IQMNiWZJSnCONCjdLSvFOvy592pLKadpEVfB0cZgi54HBlN2lT8Mpi6LncSXmgquSkhJ57rnn5KmnnjLB1QEHHCDffPNNpFcLANAApaenB9XC2rlzp/exUMaOHStjxozxa3GVnZ1dx2sKAAAQGS53gTQq2CQZhZulUeEmc0l0l7U+D+Q2Lab8a0vlm0DKvk5nND7EdnClo0bNmTNHpkyZIo8//rgsXbo00qsEAGigtJvgzz//7DfNPq7oY6EkJyebCwAAQMyx3JJWtE0yNKAyYdUmSS32nNTz5RaX7E5qJnmJTYJaTmk3P6HFFOI5uNIuHE8//XSkVwMA0ADt2LHDHEOGDx8uXbp0kdNOO03uvfdemT59ugwaNMjM8+KLL8q+++5rHgcAAIhlScW7va2oNKRKL9wiLqs4aL78hEzZldRScpNamuu8pKbUmUJkgisdSnxPUeVDS4ZbaqLLrzAuAAA1oS1xtTbVwoULJS8vT+6//35TC/HGG280j2u3QO3q17t3bxNMDRw4UK655ho588wzZdSoUWYkwc8++0w+//xzPgAAABBTnO5iSS/a4m1JpWFVcsnuoPmKHYkmoMpN9oRUuUktpNiVGpF1RnyoVnClodU+d34m9W3RXcdLWlLMNQ4DANQzrU+lXcqPP/54bwurxMRE7+NNmjSRW265Rbp27eqd9sgjj8jJJ58sP/74o6lV9fDDD4ccTRAAAKBhFVDf6WlJVaAh1WZJL9oqjoDC6VooXbv72a2pNKzak9BYhIYlqEekQQCAuHHbbbdV+HizZs1MK6xAxxxzjLkAAAA0RAkl+SacKuv2t1kSQhRQL3Smyq7kVqYVVW6SXjcXt7PsJB8Q9cGVdtnT1k/1TV8XAAAAAABUzFFaQF27/Nm1qUIWUHe4JDexuacuVbKnRZVnRD/K9KABB1daZ4ouewAAAAAARIek4lzTmsoz0t9GU6fKZQXXpt6TkOktnq5d/vISKaCOhiEmuwouWbJECgsLZfv27bJ7925ZsGCBma7FdgEAAADEtoKCApk8ebLMnz9fWrVqJRdeeKGpU1gVWv/w1ltvNaOVh+o+DkSS011kRvazi6drYBW6gHqS5Ca3kF1Jdre/llLsSonIOgO1FZPB1dVXXy1///239/7ZZ59tru0ACwAAAEBsKioqksGDB5sBOXRE2J9++kn++9//mkE29tlnn0qff9lll5l5k5KSCK4QFQXUPS2pPEFVetG2cgqoN/W2pNLr/IQsuvwhZsRkcKVDlQMAAACIPy+99JLMmjVLVq5caVpbWZYlgwYNMq2oPvjggwqf+/TTT8vGjRvl0ksvNcsBIlVA3Q6rEqzCoPkKnWnemlQaUu2mgDpiXEwGVwAAAADi04cffmhaXGloZdfpPeecc+Saa64xrbESE0OPkKa9M8aPHy8zZ86UF198sZ7XGvFZQH2rCafsbn+pxTnlF1AvbUlFAXXEI4IrAAAAADFj6dKlcuSRR/pN69y5s6mBu3r1aunSpUvQc/Ly8mTEiBHyn//8Rzp27FjlOlp6seXkBIcOgC2peLc0KtxY1u2vaIs4QxZQzzI1qUxtquQWkpfYTCyHkw2JuEZwBQAAACBm7NmzRzIyMvym2ff1sVCuvfZa6devn5x77rlVfp0JEyaYFlpAEMttalFlFGhQtdFcJ5fkllNAvawllQZWFFAHghFcAQAAAIgZmZmZZnRxX9u2bfM+FmjDhg0yadIkOfPMM01tK6U1srZu3WruX3HFFTJw4MCg540dO1bGjBnj1+KqqiMXIra43IXSqGCjZJaGVNrtz2UV+81DAXWg5giuAAAAAMSM3r17y6JFi/ymLVy40IRW7du3D5pfpz/33HN+0zZt2mS6FR500EHSrFmzkK+TnJxsLogzliXJJbs8rakKNpiuf2lmpD9/xY5EyU1uJTlJrWRXcivTosrtDF1fDUDFCK4AAAAAxAwtxH7yySebVlMDBgyQ3NxcU2z97LPPFqfTUyto3rx58uijj5rufi1atPC2tLKtXbvWzBM4HfHHYZVIeuEWv25/Se7gLqf5rgwTUJlLUmvJS2wsQm0qICwIrgAAAADEjBNPPFFGjx5tRhbUiwZQ6enpcu+993rn0dZUzz//vNx6660muAJsCSV7TCsq05rKdPvbIk7xL6LuFqfsTmpeGlJ5wqoiVxobEagjBFcAAAAAYsoTTzwhl112mcyfP9+EWIMGDZLExLJuWn379jXdA1u2bBny+aeccorsvffe9bjGiAjLktTiHaXd/jwtqlKLdwbNVuRM8QZUnm5/zcVy8FMaqC/8tQEAAACIOTpKoF5C0SLqFXUD1C6GekFscbqLTeF0u8uftqxKcBcEzZeX0Lg0pGptRvzLT8gScQRWsQJQXwiuAAAAAAAxJ6l4t2QUapc/T9e/tKKt4hTLb54Sh8sUTrdbVOntYldKxNYZQBwEV0VFRfLKK6/Iq6++KqtWrZJOnTqZIWyHDRsW6VUDAAAAANQFy21G99OWVJmlLaqSS3KDZit0pZWO9KetqVpJXlIzsSiiDkS1mAuuHnzwQVm+fLncdNNN0qFDB/nyyy9l+PDhZiSR888/P9KrBwAAAACoJZe7UBqVdvczhdQLN4vLKvKbxxKH5CU2NS2pPGFVKyl0NaLbH9DAxFxwpSODuFwu7/0ePXrIjBkzZNKkSWEPrnSEkv/973+Smpoq48aNC+uyAQAAAACeIurJJbv8iqhr66rAqlPFjkTJTdZuf61LR/xrIW5nEpsQiKvgyrJEivKk3iWmVTkV9w2tfLsP+o4iEg5HHXWUbN26VRo3bizr168nuAIAAACAMHBYJZJeuKWsiHrBRkly7wmaL9+V4R3pz3T7S2wiQrc/IM6DKw2t7msr9e6f60SS0mv01F9//VXeffddefbZZ8O6Svfff78cdNBB8q9//cvU1AIAAAAAVF9CSb5PSLVBGhVuEaeU+M3jFqfsTmruLaKulyJXGpsbiAMx11XQl9a60qLsI0aMkIsuuiisy9bQCgAAAABQdQ7LLalF26VR4WZvWJVavDNoviJnsl9ItTtRu/3F9M9XAOVIqHaXPW39VN/0datp5cqVMnjwYDnkkENk8uTJEmkFBQXmYsvJyYno+gAAAABAnTIh1Q5pVLTFBFXa/S+9aKs4Lf/WVCovobG3y59e5ydkUUQd9UKLEmllIs+1w/+2/Zj3tqPyec1CPfdLb5be9sxfNq10qj2tdDn2bf1f2TIc3uV71zuMr1HZ6/otw3daDXvG1W1wpWtaTytWG6tWrZJBgwbJfvvtJ6+++qokJEQ+mZ8wYYKMHz8+fAucPkHq1aCx9ft6sf7+6lusb89Yf39R4uEvlpjr64/tXq357PsAACDGQ6rinSac0q5+6RpUFW0Vl1UcNKsWUfft9peb1FKKXSkRWW3UjgYYTqdDnA4RZ2mQo9eeS0XhTun08m6HCIZ0eeY17WV77ojTJ3jxvmZQ4FTO6/s8FzVQT5su8olOmK1Zs8aEVgMHDpTXXnstKkIrNXbsWBkzZoxfi6vs7OyIrhMAAAAAVJtlSYpPSNWoSFtTaUhVFDRriQmpmkluYgvJTWpuAitaU9VBeFQazJjAyBkcHtnBkneaT9hkB06ucoKnwOUFBlRAXYuOVCeMHnroIVmxYoXs2bNHOnXq5J3epk0bU6g9UpKTk80FAAAAABoMy5Lkkl3ern72dULIkCpBdic2k91JZSHVHtPlT9vExB+X0yEJTofftX+Y5B8KlYVBFYdHoUImIJbFXHB11113yc033xw0PVpaXgEAAABAVLIsSSrJ9bSisoOqoi2S4C6r1WtzO1wmpPIEVC0kN7G57ElsHFMhlUsDIqdTElyBAZTTc+033RkUVNEFDQ2SQ//hJ3lqjSemBlzSRBJSyh6LyhpXDUDjxo3Npa49/PDDsmzZMvnll19ky5YtctVVV5np99xzT728PgAAAADULqTaXRpO2a2ptkiiOz9oVrc4Jc909/O0ospNaiF7EpuIFeUhlbZWqiho8t52hQ6faMmEmAihEpLLgqaEgBAq0SeE8g2ltIlfFIm54Kq+dOzYURITE6Vnz55+03UaAAAAAESTxJK8oO5+Se49QfO5xSF5prtfc29rqjwTUrkiEjwFtXKy77v8g6ZQ0wieEFMcTv8QKrAllF8wZd9PiboQqiYIrmro9NNPD+8nAQAAAABhkFCyxzuyn108PakkL2g+y4RUTbytqLSAel6ShlR18zNRKzElJzolNdElKYkuT+DkCu5iZ0/TOk5AzIZQfq2dQnTDC2wRlZDiaUEVhwiuAAAAAKCBSijJl/Qin5pUhZsluWR3yJBKa1B5uvt5iqdryyq3M/w/CRNdDm84pRfPbae5TSsoxKzkDJHUJpV0w7NvJ8dtCFUTBFcAAAAA0AC43AXecMpuUZVSkhs0nyUiexIae1tS6bUWUnc7E8Paja8slPIEU6lJnvvaXQ+ISU6XJ5xKayqS1sz/omEUIhNcWZbu9mJbPLxHAECZTZs2SVpamjRq1KjCzVJcXCxr164Nmt6qVStJTU1lkwIA6ozLXWhCKm9QVbRFUopzQs67JyHT24pKu/vtTtKQKqnW66DtQZISnH6tpsx1kkuSE5ziMHMAMUhDqMBgSi8aWhHMRk9wZRcZz8vLi/kv5/oeFYXVASC2zZgxQy644ALZsGGDFBQUyKmnniovvvhiuQGWhladO3eWdu3aSUJC2SHzhRdekMGDB9fjmgMAYlpBrmTkr5NGe9Z5g6rU4p0hZ813ZXhbUXmum0mJs3YtPbSelAZSqaXd+bTllN3NjzpTiFnaVU+793mDKbsVVXOR5IpPbiJKgiuXyyWNGzc2Z6WVnpl2xFgfTG1ppaGVvkd9r/qeAQCxafv27XLyySfLhRdeKA888IBs3rxZjjzySLnmmmtMEFWRb775Rrp27Vpv6woAiCN520Qe6iK9LXfQQ/muRt6WVHqt3f2KXSk1ehn9JWfXmbK799kBVZKLrn2IYVrHLbVxWUCV3ry09VRTkYTat0xEhLsKtm7d2lzb4VWs0tDKfq8AgNj02muvyZ49e+Tuu+82rafatGkjN998s1x55ZUyceJEyczMLPe5+jwNulq0aFGv6wwAiAPayiOznRTkbjetpzyj+3mCqpqEVEkuR1k4VRpMmdvatS/GGiIAfrQYurf1VGk4pX9fKY3p3hfLwZXu2PSLfcuWLaWoqEhikXYPpKUVAMS+X3/9Vfr162daENsOO+wwKSwslLlz58rhhx9e7nP3339/SUnx/Hi47rrr5Pbbb/frOggAQK1cMUNmvf6ASHFBlWZ3lRZG9201ZdegojA6Yr97X6ZP6ymf+lNJ6ZFeO9SRKn3r1mCHcAcA0JBpi6lmzZr5TWvevLn3sVCSkpLksccek0svvdQEV1999ZWcdtpp5sTOuHHjQj5Ha2fpxZaTE7qQLgAAXimZ5RZG9w2m7HBKp1MYHTHfvS+tSUDrqdIWVK7wjY6JhoHTxQCAuOB0Ok3rKl92a+LyTs60bdtWrrrqKu/9o48+2tTEeu6558oNriZMmCDjx48P67oDAGJfy4wUSXH4jNyX6BInXfsQ6xJTy2pO+YZT2r2Pf/8oRXAFAIgL7du3N6MK+tLRBZWOGlhVOsrg33//LcXFxSG7C44dO1bGjBnj1+IqOzu7VusOAKi+/Px8WblypalPGNjitjw7duyQrVu3SocOHep9xPEuLdKr3FUQaFA0gNIgym/kPrt7X1kJB6A8DB8BAIgLRx11lMybN88bVqlPP/3UDNDRp08fc1/DKP2Ro8XYVUlJSdByNPzSHzTl1bhKTk42hd59LwCA+qWjxWqd3uOOO860nr3gggsqrNmro8dq3UM9OaHPadq0qdx77731us5ATHV9bb2vyN4niex/icjhN4ocNFqkz3CRrkeLtO0n0jib0ApVRosrAEBc0NpUvXv3lnPPPdd051u1apXcd999cuedd5paVkpDq27dusmHH34oJ510kunyZ1mWDBkyRNLT0+Xtt9+WyZMnm66CAIDoNGvWLLnssstk6tSpcvbZZ8uKFSvkoIMOMvv88rp5//777/Lggw/KIYccYu5//fXXZt/fpUsXswwAlXT3a9JRpHFHkSadPK2qgDAiuAIAxAVtIfX555/LbbfdJhdeeKFkZGSYAMu3hpV2C+nYsaN35EGd9/HHHzfd/7T7SPfu3WX69OlyxBFHRPCdAAAqMmnSJNlnn328gZO2orr44ovl2WefLTe4uuGGG/zuDx48WAYMGGD2+QRXQAAtjt64Q1lQ1agl9ahQpwiuAABxo1WrVuYHTXk0tNJWV77d/vTHTOAPGgBA9NLWUwcccIDftIMPPljuv/9+2bhxozkWVCYvL0+WLl0qp5xySh2uKdBAOF0imW09IZWGVXpbpwH1hOAKAAAAQMzQ4uqBxdjt+1u2bKlScHXdddeZ0WgvvfTScucpKCgwF9/BOICYKaaurajsoEpbV2krKyBCCK4AAAAAxAzt9u0bKCn7flVGCvzXv/4l//vf/+Szzz4zBd7Lo93NtRYiEBN0hD+tU2XCqg6eulVAlCC4AgAAABAzsrOzZf369X7T1q1bJw6HQ9q1a1fhc++55x556KGH5OOPP5ZDDz20wnm1/uGYMWP8WlzpawMNQnKGT1DV0TMSIBClCK4AAAAAxAwtrK7hk7ay0lqFatq0aWZkQR0h1g6Zli9fboq42yPL6qiD2orqo48+kiOPPLLS19Fl28sHol5iSmkxde3610kk3b87LRDNCK4AAAAAxIzRo0fLk08+KSNGjJBrrrlGZsyYIW+99ZZ88skn3nm+++47Ofnkk+Wvv/6Srl27ysMPPyy33367uW7cuLHMmTPHzJeVlWVGJQQaHK1JlZVd1qqqUStG/kODRXAFAAAAIGZo8PTDDz/IXXfdZbrzaTF2Da2OPfZY7zwaSPXt29fbYmrevHnSp08fefHFF83FdsQRR8ijjz4akfcBVIuO8pfRxhNSaViV2Y6R/xAzCK4AAAAAxJQOHTrIpEmTyn388MMP97aqUr5hFdCgRv4z3f86eVpXJXi6vQKxhuAKAAAAAIBol9a0LKjSkf+S0iK9RkC9ILgCAAAAACDaJDcqG/VPu/+lZEV6jYCIILgCAAAAACAqRv7r4Bn1TwMrRv4DDIIrAAAAAADqmyuhdOS/0lZVGa0Z+Q8IgeAKAAAAAIC65nCKZLYpC6qy2jPyH1AFBFcAAAAAANTFyH/pzT1BVZPOjPwH1BDBFQAAAAAA4ZDa2L+gelI62xWoJYIrAAAAAABqIimtNKTSVlUdRVKbsB2BMCO4AgAAAACgSr+gk0SyOpQFVektKKgO1DGCKwAAAAAAQnG6RDLbeUIqDasy2oo4nWwroB4RXAEAAAAAYBdUb9SytEVVJ09BdVci2waIIIIrAAAAAED8SmvqX1A9MTXSawTAB8EVAAAAACB+JDfyL6iekhXpNQJQAYIrAAAAAEDsSkgWaawF1TuXFlRvHuk1AlANBFcAAAAAgNjhTBDJal9WUL1RawqqAw0YwRUAAAAAoOFyOEUyWpUVVM9sL+Lipy4QK/hrBgAAAAA0LNrdzy6ort0AE1MivUYA6gjBFQAAAAAguqVk+hdUT86I9BoBqCcEVwAAAACA6KItqExQpZfOImlNI71GACKE4AoAAAAAEFlakyqrg09B9VYiDgefCgCCKwAAAABABAqqZ7Ypq1OlowA6XXwMAILQ4goAAAAAULecCZ6gKitbpHG2Z+S/hCS2OoBKEVwBAAAAAMLLlSiS2c4z4p8GVRltPd0BAaCa2HMAAAAAAGonIbmsNZVeZ7QRcTrZqgBqjeAKAAAAAFA9SemeulTaokqDqkYtKaYOoE4QXNVQUVGRPProo/Lpp59KQkKCDBs2TC6//HJxMPIFAEStXbt2yYMPPig//vijZGRkyKhRo+SMM84I+3MAAIg5KZk+Lao6iKQ3i/QaAYgTBFc1dOmll8r06dPloYcekvz8fLn++utlxYoVcv/994f3EwIAhIVlWXLiiSfK7t27Zdy4cbJq1So599xz5YknnjD79HA9BwCAmJDW1L/rX2rjSK8RgDhFcFUDixcvlpdeekm++OILOeaYY7w/brTF1Y033ijNmzcP9+cEAKiladOmyQ8//CDLly+Xzp07m2mbNm2S22+/XS666CJxuVxheQ4AAA2O9hpJb+5pSWUHVcmNIr1WAGBQLa8GvvrqK0lPT5dBgwZ5p5166qmm++C3335bk0UCAOph3927d29vAGXvuzdu3CgLFiwI23MAAIh6DqdIRmuR7P1Fep8hcui1IvtfKtL9OJGWexNaAYgqtLiqAe0q0qpVK78z7U2aNJHU1FTzWCgFBQXmYtu5c6e5zsnJqckqiOzOl3pV0/WsqVh/f/Ut1rcn769ePr/83bmlD1f8+QbOZ9+vynPLX6Ucb+vWmtL9c9u2bf2m2ff1sb59+4blOXW5v9+9p2y54eD72YRTuNezrtc3UI0/q1run6qz3cK5LYLeb13tU+vq2NDQ1ree1dffTaBI7u8jxV7nWu3vi+tm/ynOBJFGrUSy2nkume08owDa9hR5LgBQT6qzvye4qgFtWZWc7LOjL5WSkmIeC2XChAkyfvz4oOnZ2dnSMNwlsS3W3199i/XtGd/v759VXMo/a/HcigqlZ2VlhW3frScc7MfC9ZyGtb9/XBqW+lnf2v47bWjbov7eb0Pbdza09Y0ukdzfR4quc/Tu7wEgOlVlf09wVQNNmzaVbdu2+U0rKSmRHTt2SLNmoUfXGDt2rIwZM8Z73+12m2Xo/FUdiVATST0QrlmzRjIzM6Wh4n1EHz6T6MNn4k/PxOhBLbD1U3X33VqrytfWrVvNdXn77po8Jxz7+4YsVv7tRhLbkO0Xz//+wrG/jxRdZ91uOgJtdff3kd7ukRBv7zne3m88vud4e7+1fc/V2d8TXNXAgAEDTH2T1atXS4cOHcy0X3/91Wz4/v37h3yOnrEPPGvfuHHNRubQfxCx8IfA+4g+fCbRh8+kTG3PvOu++7333jPd+Oz98c8//2y6fe+7775he0449/cNWaz8240ktiHbL17//TW0llY2p9Mp7du3r9Uy4vHvPt7ec7y933h8z/H2fmvznqu6v6c4ew0ce+yxJrC6++67va2t7r33XunXr58MHDiwJosEANSxs88+27R+evjhh8393Nxc+c9//iPDhg3ztp5au3atHHTQQfLjjz9W+TkAAAAA6g7BVQ3omfS3335bvvjiC9OsrXXr1rJs2TJ5/fXXw/8JAQDCQvfVr732mjz00ENmlEDdf+sIsU8//bR3nvz8fNOiavv27VV+DgAAAIC6Q1fBGtpvv/1MWLV48WJJSEiQHj161HntEg3Mxo0bF7IwfEPC+4g+fCbRh8+kbpx00kmybt06+eOPP0wNkr322svvce2j/9NPP0nPnj2r/BzE5r/dSGIbsv349xd/4vHvPt7ec7y933h8z/H2fuvzPTushjjWLAAAAAAAAGIeXQUBAAAAAAAQlQiuAAAAAAAAEJUIrgAAAAAAABCVKM4eIfPmzTNDqq9cuVK6du0qt9xyi3Tv3r3c+Xfv3i2TJk2Sb775RgoKCmT//feXa6+9Vpo2beqd5+WXX5YnnnjC73lpaWny9ddf19n70HXRYeK//PJLU5Bt+PDhcuGFF1b4nKVLl8qTTz5ptkHjxo3lhBNOkAsuuMAUua/Ncmvru+++M9tv48aNsu+++8o///lPadOmTbnzFxYWyuTJk+Wzzz6T3Nxc6dWrl1x99dVm5DHbgw8+KO+8847f87p06SJTp06ts/exc+dOuf/++2XmzJmSlZUlF110kZx66qlVeu6OHTvMtt61a5d5friWW1MffvihvPDCC2a9DjzwQLn11lvNv5mq0H8/OtLnNddcI+eee653+o033ig//PCD37wHH3ywmb+ubNiwQe677z7zb75ly5byf//3f3LUUUeVO/+vv/5q/i0F0vfTsWPHGi83HF566SWzHjr63tFHHy1jxoyRlJSUcuc/77zzzEAWvk4//XS5+eabqzUPImfOnDny3//+V1atWiXdunUzf4d63CqP7g+fe+45+fbbb6WoqMh7vGrSpEnI+XWE3jvuuEMGDx5s/j3Hmr///lsmTJggCxYsMKNUXnXVVXLYYYeVO39xcbH873//k08++US2bt0q++yzj1x//fV+f/u2t956y4x6mZOTI0OGDDH7O99jaSzQ7z96LP3++++lUaNGcv7558tZZ51V4XP0uKz7Kf0326lTJ7niiivMoDq+dHCdxx9/XP78809JTU2VQw891Hw2+hqxxO12y1NPPSUffPCBaFnboUOHypVXXlnhvxMdjEK/D+mxSL9HDho0SC6//HKznWqzXITvM2roVqxYIc8++6z5XXPJJZfIpZdeKrFMv+M888wz5niq32P1Mx45cqQ4nbHbhuSXX36R559/Xv766y9z7Dv77LPllFNOkXig34H0vetvpX/84x8Si3bu3CnHH3980PR77rlHjjnmmLp5US3Ojvq1aNEiq1GjRtY//vEP6+OPP7bOO+88q2nTptaqVavKfc5+++1nXXfddda7775rffjhh9ahhx5qde/e3dq5c6d3ngkTJlg9e/a0fvrpJ+/ll19+qdP3cvrpp1tdu3a13nzzTeu5556zMjIyrLvvvrvc+f/66y9rwIAB1qOPPmp9/fXX5jmtWrWyLrvsslott7Z0XRISEqzbbrvNmjZtmnX88cdbnTt3tnJycsp9zrnnnmtde+211gcffGA+x2HDhlnNmjWzVq9e7Z1HP+NBgwb5fSZz586ts/dRXFxsHXDAAeby/vvvW//+97/N+3r55Zer9PwzzjjD6t27tw7YENbl1sT//vc/KzEx0XrooYfMax544IHWwIEDraKiokqf+/3331tdunQxf2f6fF9Dhw61RowY4feZLF68uM7ex65du8y6HHfccebf1h133GG23Zdfflnuc7744gvzGfiuo1727NlTq+XW1n333Wf+Fp999lnzt9mtWzfr1FNPrfA5vXr1Mvsu3/exfPnyas+DyJg/f76Vnp5uXXHFFWY/d/bZZ5v93Jo1a8p9Tv/+/a0xY8aY45XuHw8++GBzbAq1P92wYYPVoUMH829J9z+xZseOHeb96X7no48+sm699VazX/vuu+/Kfc4555xjXXDBBdarr75qffbZZ9ZZZ51lZWVlmeOnr6uvvtpq3ry59dRTT1nffPONNXbsWGv8+PFWLHG73dZRRx1l9e3b1/x7euyxx6zk5GTznstz7733WkOGDLFeeOEFsz+8+eabLZfLZX366afeeXT/kpmZaY7jOs8bb7xhvlMde+yxVqy55pprrJYtW5rjtR5XW7dubb6blEePLbpP1mOnbptXXnnFfB874YQTarVchO8zauj0b3Gvvfay7rnnHqtdu3bWuHHjrFi2YMECq0ePHuZv6vPPP7cmTZpkPu9Y/oz1t+rgwYOt559/3vzG0t8Nuu9+5JFHrFg3e/Zsc9xv0aKF+V0ZqzZv3mx+q7z00kt+39+3bNlSZ69JcBUB+kVJf4TbSkpKzBemq666qsIvEr62bdtmOZ1Oa+rUqX7Blf6wry+//vqr98e1Tb9Upqamlhv45Ofnm/fr67///a/5Ul6b5dbWIYccYsIM2+7du82XWt3Rlkfn8VVQUGCCgxdffNE7TQ9K9fljTL9867+LtWvXeqfdcMMNVnZ2tvkBUJEnn3zSOuyww8xBJjC4qs1ya6pTp07mNWx///23WYfXXnutwufp34Y+V8Mr/YEdKrjSwLG+6L9vDXt8/73ov7WDDjqo0uAq3MutjdzcXCstLc38Ldr0b1TXc+bMmeU+T38APfzwwxUuuyrzIDI0NNETJb4htgamGjRW9XilX24cDof1+uuv+03XfYcGBfpvWf8uYzG40rBX90N67LNp2KthTFW3nx4zdZ+mwZRt+vTp5m9PAytfvuF2LNCwVN+nb2inP3I1sCvvJEbg9lMnn3yyX/CixzkNEH2XoUGhvpbu62KFHrP1uKknGmwaAOrfY3knB/Rv3Pffq/0dQLeN/R2sJstF+D6jhk7/Ru3fAno8ifXgSvfL+nfla8qUKeZzD7W/igWBv5HUxRdf7Pd9Ihbp8UNDSj1Rpf+24yG4mj17dr29Zuy2T4xiX331lZx88sne+9pM9KSTTjLd4soT2HRdu+ZoE2LtruZLux4ee+yxZnnjx483Xb7qiq5v8+bN5aCDDvJO065je/bskRkzZoR8jnb7820Wq10idN6+ffvWarm1kZeXZ7q/+X4m2jRemzlW9JnoPL5++uknKSkpMd0MfWlTe+0Cc9ppp5nuNoGfWbj/bQ0YMEDatWvnt+3WrFkjS5YsKfd52oVF/7288sorIZst13S5NaXdSfXfsu9n0rZtW9PVo6LPRF188cWm61lFXXG0C452qdPuJtqcV5vp1xXddtqlzvffi267n3/+udK/T33/xx13nOkmtHr16rAttyb037f+rfh+Jvo32qpVq0o/E+1Se+SRR5rP5c0336zxPIj88crlcpkuDtU5Xmn3In1e4L7vgQceMN1irrvuOonl7afHZD32+f6darc37RJfle2n+2Tdhr7bT0sDaBdC/ZvxVVG33Ya6/Xr27OnXNVW335YtW2Tu3LkhnxOqq59O891+/fv3N8dr7cqi9N/hjz/+aLr8p6enS6yYPn26t+uZTcsz6PfH8spI6N+q779Xfb7+e9XPwN62NVkuwvcZNXT67yiWu8gF0v2y/l0FbgP97qnd6WNR4G8kLSEwa9Ysv997sUi7+OrvxxNPPFHixfXXX29+52p3cv2M61L87DWihH5R1RpK+iPcl97XWgxV9e9//9sc1PQLsU3vn3POOabmjNaAeP/9903YoDuLuqDrG/g+tCaUw+Go9L3oP/IDDjjAzK/1i959992wLLcmNHzRg0dNPhMNvPTHu/6A0GDqvffek4EDB/rtuPWz0Jow2q9ba0ZorQj9wlwXQm07+35570XDiBEjRpiaa6FqqNR0ubVhL7O6n4nWK9F6Mv/617/KnUfrwo0aNUpuv/12E17deeedldZLqY3ytp1+UdV/e+XRf0/aN15rrixfvtz8oPrjjz9qvdzavA8VWPdN71f0mWRnZ5v3oTWM9AuL1rLQOmPVnQeRqS2kNZZqe7zS+kT6Q9i35oHuOydOnChTpkwx+/ZYVd7fqR4DdF9VFXp81HpMvjUFFy1aZIJ8raGh3wOGDRsmjz76aMz9CArHsUe3nW5D3Ua+wdW0adPMND3ZpMc+/cJdWQjf0Og20tpyvrWp9G+xWbNmlW4/rcumtSX1hJWeuNAQxf5brc1yEb7PCA2TnrTX46KeeCiv9mOs0N8++rvIPvlcl/VkI03rF+vJkIceekjixYEHHmgaDGit7qSkJHNf84e6ErtV/6KU/aXS92yW0gNWVb9wajiirWO0aLVvCxgt5uy7XG2poWfI9Me8Bifhpusb+D40PNNLZe9FC9WdccYZ3pY+d911l/kRU9vl1vR91PQz2Xvvvc1669lfLZ6vn0G/fv2kQ4cO3i9+vss9/PDDzdljbVGiRQrr4r1kZGQEvQ/7sVC0mK+GBdrSJZzLravPRIPOUPTsuwZW+gW7ooKm2sLKXq7+kO7Tp4/5XLRge0WttGoq1L/nyradro/vj3xtQakBqYZtWoy5psut7fvQM6SJiYlBr1nR6+n+ynd765cXDQ713539d1KVedAwj1f67/Xee+81Rf21OKtd0FNPsuggHYGhRKyp7d+pFvLVgUl0oALdL9h0cAT9cqitK2+66SbZtGmTGVBEWyVrsfZYUdvtp9tFfzjpCSMdvMKmoaGeFNDQTweH2b59u4wbN85sQ/1uFcvbr6p/w3pCS39Ya2FlLbarJ0Xt1rC1WS7C9xmh4dGTi/obSIu1awv5WKe/8fSYryer9LuADtaiLXNijfYU0UFo9OSHbwgdy5o0aWJ+O9m/ubRQu343ueGGG+ps8C6Cq3qmTdD1ALVt2za/6XpWW8+uVOajjz4ygYeGJfrDzlfggU9blmiLq/Ka09eWLj/wfeiXaD3QVvZeNLxRGhRoiw0966lfivRHam2WW9P3oWrymejoenaXRm3are/rkUceMa2XQn0mGiTqCEf6mdRFcBVq2+n7UOW9F23x0KNHD+/72Lx5s7nW+/aIfDVZbm3fh9LX9A0uKvpM9MeafiHQUVpserB87LHHTFN8/dsJ9ZnoSFLajFs/k7oIrmqy7QLXUQMjbYb79ttv12q5taGvpy0TdZv6juxY2d9J4HvRYEo/p/nz53s/26rMg/qnYbUGlTU9XukIWRqI68kT35E9dRQpHbVMzzjrRenIbvrvXPc72jqmohFdG5La/J3qv38NVnQbarfKwOVqy0rd7+lZTqVfls8880zT8kpHGY0F+j61dVlNtp8ey7Q7te5DdN/p2zXJPlGmXS7t6drqSkeY1UBLvzvF6r+/qv4N77XXXuZyyCGHSO/evU1rCT0xpNuoNstF+D4jNDx6gltPOmgLRv37inXaulVpDwdtaawnYS677LKYa2mtxxj9nTp69GjvtLVr15oyGNrVWkdZjjWugO6v9vd3bQmuvb3qYoRegqt6pn+o2iJH6x750tTd/uMuz8cff2xaKWkTRP1iVRUbNmwwQUld0C92WrNJWxtpTSplnz2o7L34sn+g6EFav2CGa7lVpWf8tSWAfibassWmr+l7hrsqf8AtWrQw610ebR6sj9dVDQ3ddtqNVF/HTsD1feiPT+1qFoqm5RoS2DTg0bOr+sXe7jpYk+XWhi5Twwz9TPTvRekBT7tylFcPR8+mByb8Ojy8TtMWC+XRFlx6hqAuPxMNznzpttN/K74tJqvyt+y7juFablXZP+T0M7G7KOvfrHZjrM7fpb4PVdH2rso8qHu6T9MWifqZ+34Zq8rx6sMPPzRdcLVbgO9z1RFHHBH0JU67hmoAc99993mD61igfzehjvft27f3Ht9C0dbIGrroMV+7mAfSEEG/FNuhle+xVFsPxUpwpdvvjTfeMPtou36Xbj8Nm/TfZnn0OKvbT7ex/lsMPAOuQYEe933DLLv1X6gQoSFvPy1RoSGoXX9TQ+KcnJwafU+zv9+Ea7lgW8YTPRn86quvmtp9Fe2/YpXuR3QfofUGQ7UybMj0pHlgzcnhw4ebIOeKK66QeLFhwwbz29D3u0lY1VsZeHjpUPKNGjWy5s2bZ+7PmDHDSkpK8htRREemGzRokPf+J598YqWkpFiPPvpouVvygQce8Bt1T0fp0o9YRyirCzoShg7nao/QVlhYaIY+9R0xIi8vz4yg+P7775v7ev3bb7/5LeP000+32rdvb55f1eWG2z//+U+rbdu23lHz3nrrLTOiyy+//OI3OpSOCGm/Lx1x0F5n+73pqII6MpE9yuD9999vrpWOXqRDxOtIRosWLaqT97F69Wrz78QeoW3nzp1mxLbzzjvPO8+yZcvMZ+L73nzpv73AXUNVlhtuo0aNMq+hw8mriRMnmqF0V65c6Z1HRzaraHSzwFEFdWTCZ555xjuajX6O+h50dL6NGzfWyfv4/fffzb8l++9b10GHf77lllv8RufTz8R+b08//bTZ5jb9G9Z9hI4cWp3lhtsRRxxh9kv2v2nd9jq6l+9+R0c21H2RmjNnjvlb8h3x8eijj7Y6duzoHbWqKvMgcnS0UR1hdeHChea+jtap+zkd9cr23HPPWcccc4z3/rRp08zf6hNPPFHl14nVUQX1+K5/px988IG5v2rVKqtVq1Z+o2h9++235u9/3bp15r5uax1Ge/To0eWO2vrHH3+YfYIOK690xCrdZ+rfTeDoVQ2Z7pd1/3z33Xd7R6rS0ZN1ZEabbjfdfrod1datW60+ffqYfVWoka3U5MmTzbH4xx9/NPd1O994443mu1ldDuVd3/RYt/fee1vDhw83t/V96vcYHe3Kd0RF/fvVv2N7xMqvvvrK+5juh6+44grzOei2rc5yEb7PKFbFw6iC9vcl/U5anyOwRZKO3LpixQrv/Q0bNlgDBgww3+/iRayPKvj2229bs2bN8t5fvHix+R2ivwPqCsFVBOhB6eqrrzZfOrt3726+4Gtw4ku/pKWnp3vvN2nSxAxFr1/OfC/6A9emw9S3bt3aHAD1Wi8vvfRSnb4X/RGjgY/+Q9V11C+LvjsqDaE0BLG/EC1YsMAMA96mTRtr3333Ne/xyCOP9IZ4VV1uuOkXM/3SoOFMt27drNTU1KAfXZdccokJUpR+udCdkf5o1/eRnZ1tbv/nP//x+5xvv/12c6Dq3bu3udadmA7vXdc7ksaNG1udO3c2X8J1e2sYYJs/f36FgWao4Koqyw237du3m8BS/43stddeVlZWll+4q44//nhzqWpwpUGV/u3pvyn93PQHed++fU1wVJf071T/frt27Wr+jWlY6ztsvQbTus11p690GF3dN+i/F33v+lz9YmcHblVdbrjpj+5+/fqZ7adhs/4d2z8WbToM8D/+8Q9zW38Ann/++VbTpk3N9tZ11b93+31WdR5Eju7H/u///s/veHXHHXf4zaP/NvXv06Y/cPXvNvB4ZR8H4im4UnrCSY8pemzRv9Ozzz7bG/4qDQH1798+xh1++OEm7DrggAP8tt/NN9/st1w9SaJ/i/Yxf5999jGBdqzRY6YeXzWU0332wQf/f3v3Ad9Gef9x/CfJ27GdvXdCAmGEVUYS9oYCoRAotEChlD0KtP0TOthNW0opu6WUUkYZBcIoBUrYBJKQEBJIGCFk72U73uv+r+8jnyI7tuM4tiVLn3deF0unk+50kp67+97zPHdgnRMNWm9af36YqjJe97XfEL3+xo8fX+d7ffXVV7vPQ+vN3994+eWXvUSj/S5993RCUKGptik6YRBNv18/PFA5f9JJJ7nwVNtHPaYDTu2Xbe/rovU+o0Tih80atE3Rb0+3FZAmIu0nqUzy32f0kKj7Ogq/dewzePBgV8aqrD3ttNO8VatWecki0YOrTz/91BszZoz7Xu+8885uP/H88893lRvaSkD/tU1dLmyL+l9QVX81x6rfNEIdh6oPEHViJ2pq0NCV6NTcQINP06gjTVWL15W62uNys2o+pqv2qNrniBEj6jymPnF0hYVhw4a5Jkw+VTfX+9OyN9YspKnXbStaJl31UX1R1e+MXE2i1GY3unqv2jN//fXXrkmT3ktDnYKrSqw+E3Vi518dsa2pWYWuQKc+uIYMGVLnsdLSUtefk66EmJub2+D3Up1G+n1eNfd128rixYtdcz71H1b/Uu/+Vfb8PtPqmzVrlmv+Ub+/HK0DdaTYq1evdmtSo++OvgeaX/2mfOo3St91NYuMfo967/r+aF3X7xS9Oa/bVvSdVzMRXZyg/nde3y19r6K/H+qjbtGiRa5MauwKOs2ZBrHfXqnpef3PR+NVPVzN10Rlvsr+bW2vovl9XO20006WiPT99suc+h3Sq2mf3r+aWGl7N2/ePDd9fdpW1t8WqkzWc/WZ6LeTaP2G+FQOqoxUnxnan4imsmj27Nmur0atB5Uj2o7Xp3Vbvxmbrpyp6XUFYO2LNdRnRyLQrr7Wn/6q3K6/bzhz5kzXdDL696ntkq5qp/GNbSe39bpovc8okfi/2fq076B900Sj5nH1++rzqaltIneLoL4Y9f7VFUz946pEp4urqLl6Y/s9iWLNmjXuuF77/dqWtiWCKwAAAAAAAMSlxI3zAQAAAAAA0KERXAEAAAAAACAuEVwBAAAAAAAgLhFcAQAAAAAAIC4RXAEAAAAAACAuEVwBAAAAAAAgLhFcAQAAAAAAIC4RXAEAAAAAkMTmzp1r/fv3t8LCwlgvCrAVgisAAAAAANrB4sWLXUD08ccfu/uzZ89290tKStpt/Tc0z4qKCluxYoXV1NS023IAzUVwBQAAAABAO6iqqnIBUXl5ubuvv+0dGDU0z9GjR9uyZcssLy+v3ZYDaC6CKwAAAAAAYlD76qSTTnK3R44c6WpBXXnlle7+qlWr7OKLL7ZddtnF9tprL7v66qvrNOP76KOP3PRTpkyxQw45xAYPHuxqca1evdqN1zBkyBA74ogj7LnnntvmPL/44gs74IADbPPmzZFpNW7ChAk2fPhw22effewPf/hDnbDLX4a3337bjj/+eNt5553t5JNPtgULFrTL+kPySIn1AgAAAAAAkGwGDBhgf//7312QpPAnKyvLsrOzraCgwMaOHWvHHnusPfXUUy4s+s1vfmMnnniivfPOOxYIBCK1pn7605/aXXfdZSNGjLBevXpZKBSyadOmudfXNFOnTrVzzz3XcnNz7aijjmp0ngsXLqxTC2vTpk128MEHu0Dq+eeft0WLFtmFF17owrNbb7018vp6zrXXXmt/+tOfrEePHjZx4kQ77bTTbM6cOTFdt0gsBFcAAAAAALQzhUwKe6Rv377WqVMnd/v3v/+9de/e3e6///7ItE888YR17drV9U+19957R8ZrGgVM0VQLyjds2DD79NNP7ZFHHnHBVWPzrO++++5zgdbDDz/snrPHHntYfn6+XXLJJXbdddfVed7f/vY3VyNLbrnlFttzzz1tzZo1LkgDWgPBFQAAAAAAceLDDz+0+fPnu+Z/nufVGb755ps6wVX0bd/jjz9u//jHP2zp0qVWWlrqmv/ttttu27UMqjE1ZswYF1r5Dj30UPd6X3/9dZ35Rr+2H1atX7+e4AqthuAKAAAAAIA4UVZWZkcffbTdfffdWz2mWlfRMjIy6txX08LLL7/c7rnnHlcLSk0E77zzTnv33Xe3axnUDLB+baz09PTIY9Giwy2fQjagtRBcAQAAAAAQA37oEx307LrrrvbCCy9Y7969LSVl+w7Z//e//7kO0s8+++zIuCVLlmxznvWp43Z1/B5NzRTVv9ZOO+20XcsE7CiuKggAAAAAQAz069fP/f3qq68i4y699FJbu3atXXHFFVZcXOzGqdmfalJFX/WvIerfavr06bZhwwYXTD399NM2efLkbc6zPl3RcN68ea4PLb2OrlZ4/fXX25lnnun63wLaE8EVAAAAAAAxoA7SL7vsMhs3bpwLlK688kobPny4q+2kGk55eXnWuXNn17/UqFGjXIfpTbnmmmtceKXX1XNvu+02mzBhwjbnWZ86dVezw9/97neuueHAgQNtyJAhrgki0N4CHo1PAQAAAABoc9XV1bZq1Srr2bOnpaWlRcZXVFS4Ds0zMzOtS5cukfFFRUVWU1PjwqNo6mdq3bp1da4gGE3Pq6qqcqGXammpU3XNM1r0PNWfla4EqCBLzQGjaT56XNNtaxm0rCtXrmxRM0egMQRXAAAAAAAAiEs0FQQAAAAAAEBcIrgCAAAAAABAXCK4AgAAAAAAQFwiuAIAAAAAAEBcIrgCAAAAAABAXCK4AgAAAAAAQFwiuAIAAAAAAEBcIrgCAAAAAABAXCK4AgAAAAAAQFwiuAIAAAAAAEBcIrgCAAAAAABAXCK4AgAAAAAAQFwiuAIAAAAAAEBcIrgCAAAAAABAXCK4AgAAAAAAQFwiuAIAAAAAAEBcIrgCAAAAACSN9evX26effmqVlZWxXhQAzUBwBQAAAABIGnfccYd95zvfMc/zYr0oAJohpTkTAQAAoOUqKiqsqKjI3Q4EApG/2dnZlpqayqoFgHb0+eef2/Dhwy0tLY31DnQA1LgC2tlDDz1khxxyyFZVk2fNmmXjxo2zmTNn8pkAQIJ45JFHbPfdd7eMjAzr1q2bG7p27eqGLl262IwZM2K9iACQNEpKSlwTwblz51rv3r3dbQ1Llixxj69YscI+++yzyPQaP3/+fHd79erVkennzJljy5Yts+rq6ibnt27dOvvyyy+trKysyWaLmqa0tLTRaWpqamz58uW2dOlSaokhKRFcAe3sv//9r9uI1T/D/v7779vUqVNt4MCBfCYAkABuueUWO++882y33XazN954w9566y07/PDD3WMnn3yyTZo0yfbcc89YLyYAJI0PP/zQzjzzTBcAffvtt/ajH/3IDS+++KJ7/LLLLrOTTjrJBVtjx451ZfbZZ5/tHrvnnnsi0//whz90JyX69etnjz322Fbzefrpp93j2q//7ne/605UXHzxxVZcXByZ5j//+Y/tvffeNnToUDvhhBMsNzfXLrjggjohl4K2n/3sZ+5kx8EHH2xjxoyxnj172h//+Md2WV9AvCC4AtrZJ598Yvvss89W41Xjqn///m5j5Hv33XebPPvSEWzatMmmT58e68UAgHZvhnLTTTe5A5wnn3zSjjjiCDvssMPsX//6l2si2LlzZ7vuuutcU0EdpLz99tsd/hNSzYQvvvgi1osBAI068sgj7a677nK3//GPf0RqUF155ZVunFo+pKen21//+ld77bXXbOHChXbrrbe6x2677bbI9KqVpZpSp512mp1//vmRpuD+SYtzzz3XfvKTn9jmzZvtm2++cSet8/LyLBgMRuatgOz00093+8qaj0I1bSNuuOGGyGvpNV599VUXpCloU62radOm2YYNG/iUkVQIroB2pA2TduwbC66ixxcWFroDnY7eaeQLL7zgNuAAkEzuu+8+9/cPf/hDnfG9evVyzQWjDzo+/vhju+SSS6yj03tVLQMAiGcKnqR+jdc1a9a4poJqlqfO23Nyctz44447rs50Kr91ckJDnz59rKqqyoVY8uabb9pvfvMbu//++10YlpIS7lK6U6dO9vvf/94yMzNdkKXaV5deeqk7gREKhdw06ix+woQJ9vzzz0fm9dxzz7n5R7fIGDZsmKux61PtK7Xo6Mh0vKP3np+fH+tFQZwiuALa0ezZs93f+sGVqg1/9dVXkfE6O/Poo49a9+7d3dmXd955JzKtzsyr1taCBQvqvIbO/OgsjMIxPUevIepLS2dmVq5cGZl248aNrl8VbZgVmGne9alqsh7T2Z36G3u18V+1apVbLtUI0/JMmTLF3dcy+HT2SGertJHW4zoTrzNOet1o7733XqTqtA7gtEOgfgNUA0E7A/460TJrPADEO5V5BxxwgPXo0aPOeJXJBQUFrnwXlc06SFGYpedEl486gaEaq9Hlt6iM12voAOujjz6K9JmoclL3o3f8/VpQ5eXl7rHoMtqn6TUfle31m7CrbFZZrhrAor9aTj2mbUn09k3LpTJbj2s+2n58/fXXkWm0DGou6dNtdVqvvl30XJ8OAKlRAKCtqLwaNGiQa34XTfugcvXVV7t+CaOpvFPIpOfstNNOLmRRjVqFRgql9Hqi2lm77LKLaybemDvvvNOVfWpCqPBL+/CqUaVBIdbatWsj044cOdLuvfdeN2/VBtO+e306ZujoF/nQcY2a1Ks2MtAgD0C7+eMf/+gFAgFv8+bNdca/8847qlblvfLKK+7+xx9/7O20005enz59vCOOOMI755xz3PhnnnnG6927t7fffvt5PXr08C699NLIa+y///7eD3/4Q2+33XbzRowY4Q0aNMj78MMPvX322cfbd999vYyMDPe68tBDD7nXOOCAA7zvfOc7XmZmpnfjjTdGXuvRRx/1evbs6V6zW7du3i9+8YvIY7vuuqt3yimneMOGDfOOPPJIr6yszDv//PPdch500EFep06dvHvuucdNe8cdd3h5eXne6NGj3eOa75/+9Cfv7LPPjrxeUVGRFwqFvMLCQne/V69e3qmnnure/4knnujG/fnPf3bLoeXt3LmzW48AEK+qqqq8YDDo/eAHP9jqsf/973+uvFd5Lk8++aQr11XmqZy86aab3PhJkyZFyj2Vow888IAbX11d7WVlZXk/+clPvD333NPr27evd/jhh3svv/yyK/9HjRrlyu/169e76S+//HLvu9/9rrfLLru48j4tLc179tlnI8vz61//us58/vnPf7rxpaWlrmyeMGGCK/fPO+88r6KiwjvqqKPccmobkpOT473xxhtu+osuusht37Qd0OPvvfee23ZpO+DTNknbDlm1apV7fW1P9D6uuuoqt960vNq++eX9f/7znzb8pAAko5EjR3rjx4/favwNN9zgyudFixbVGa993T322MPbeeedvRkzZtR5TOPHjBnjbpeXl7uy/+qrr97m/FW+af+4oeF73/teZFqVlXo9bSO0bCofb7755sjjKmdTUlJcuXvyySd7X331lRv/wQcfuHL1Rz/6kffaa6/V2Qbddttt3n//+1933DBx4kRX3s+bN8+75JJL3LZl8eLFke2NlkWPXXvttW5eU6ZMqfNe3nrrLVdu61hAt30vvfSS239//PHHve9///tuGbTt0TJq3V944YXezJkz3bSff/65W4e5ubnucb1WSUmJ2z5onfp0DKHXFb2ujiv++te/eqeffro3derUyHwvvvhi9z784x4kBoIroB2dddZZ7gClPhX42hitXr06Mu7KK690BxS+6dOne927d/dmz57t7ufn57uQ54svvnAbluzsbFdQ63ZlZaU7mNEBhKYTFer+AZE2ZFoOf+P2+uuvuwOhmpoa7+2333YHPfPnz3ePrV271uvSpYu3dOlSt+HWxtGfT0N0YDJgwIDIfS3HnDlzIvcVWkUfyGhDM2TIEHdb71/r4Ze//GXk8aefftobPHiwm78sXLjQhWPFxcXbvf4BoD2Dq+OPP36rxxT8dO3atU4ZdvDBB3vPPfdc5P7f//53d2CjAxbRQYPKPb3ul19+6crJ+++/3z22cuVKd187+ir7VY7ruS+++KJ7/JBDDnEnMDZu3Oju//73v3ehkNx1113uIMkPubSTr+2M6IAiej4N0WP+CQYth06CaBl9u+++u/fmm29G7t93333uQER0EKPXVxnv0wHUoYceGjmR4YdxANBadMJU5XP0CVvfCSec4PXr12+r8S+88IIrrxT2RFuwYIEb759I9vdjb7nlliaXQfvVF1xwwXYvu/bbjznmGDcP7W/75bheb/LkyW7QtuXOO+90J7B1Ivnee+91JycUZIkCqIEDB7qTDTpRPXToUO/MM890Zbnu6/VPOumkyPy0rlQu6+SJymid/PD3yW+99VZ3MkKPKaTScnzyySfuMb2+7itA0okarZu5c+e6ZdT2Tsc4enzDhg3eihUrvDPOOMNtM/W4jkV03OMfH/j22msv79VXX3W3dZJb70vHNArEtI3T8ZS2Owq0dPJH4aAfwqHjCze6BdBuVZPVVE5VgnWlEb/t+l/+8hd3tRH1fRI9raoq+37729+6Pq/UpENN6BQ8q129mmKoo0ddjlf9i+i2P6iNvTqClLS0NFeVWTT/66+/3kaMGBFpU6+mgWoSoirOxx9/vGvnr2Yjmo86jF+0aJFb9qysLFfF2e9cUlTdWc1BVLVZz/ObKeq+mv2pynT0+1LV6uj7o0ePdrd1aWF1UH/zzTdHHtft733ve66pivoE0PJoGdQMxV9+AIgnauqx3377uaZwulqsrkylZnK6MpSaQrz00kuuHBOVaWqCvddee9Up93TFKjWhUzM/TaMO3VW+qpzcddddI31iqWxXeaxthN+XipqMRJf36mtQ2xi/vH/wwQddcxN1NKw+WDRN7clMt41RE0XNR++hft9b6oBYTTrUbEblu1/eqyzXds3vq0XvV8se3YdM/fJe2xp1TOy/rrYtf/rTn1xzGC2Lmh2q7AeA1qLyS+WfmuDVp6ba48aN22q8mmaLrvrn0363+qgSv1zT/rL6xVIXGvWpTFSn76L+qjQvv2yPpi5B1ExRj+m2utvwab9XV0R8/fXXI/1v9e7d220/xo8fH3l/v/71r10Zq6sViroRUZN0bYs0Xn1m6dhD5s+f765uqGXWtkPN2//v//7PPaZtgy4g8tRTT0WOUdRRvJp277zzzu64Q8/XlRVF3Yhoe6Pl0Xx+8IMfuCsx+vQa/vGP9u3VL5fmccghh7jPRE0n/fehzvGjtx9qEj9v3jzbY4893H29/hVXXBHpyF7bVh1TaXn85obahmoeidCHJMwIroB2omBI4c6hhx7qNhzDhw93O/3aCO2///7u4EaPqZ8obaxUIEcfyOhxTetf2UTUJ4ra1Gta9Y/lb8S0gVLoFL3x1YbBv5yvbvtXVBEtlzZUOtDRfHSwEj0fhUka1LeJNi7R7f61IdSGQ8uiQX2T6L35Bym6DLzf7l4bYG1EojdE6k8geiN01FFHRUIx7ShoI6WNsh7zaaMXffVFAIg3KmOPOeYYVw4PHjzYlckqC//2t7/ZiSeeGJnOP/kwZMgQd1/9VvlXjdLg03ZCfauoLNS2wqc+UXRywD+o0M69+i1U2au+sRQI6fLp0eW9DmZ0cOOfCIm+oqFOkGhboPlo+aPpIEWD3o9OiihUUpntl/fR2yy/0+LoPmRU3iuskvqvr4M4rR8deESLXlcAsKMUsqisUcCiTs51WyGM9l9VTh944IFbPUdXhFWA84tf/MLtH2v/VEG7TuiKv1+rEGrixInu5LBOVCiI0b6vTmIo1Pc7VP/Vr37lQvtTTz3VLrjgAndiQf0Rqs9XhVt6bQX/2ufWVQVVhmsfW+XkjTfe6K5iqDK+obL3iSeecPvpWlb/hIRO/OrYw99m6ESHb+nSpXbOOedE9tXVl6zKeP944ayzzqpzYl0nSPReHnvsMXcC5qqrrorMR9selfG6rW3AP//5zzrrUdu0f//7324bpyBP2yOtV/99XHPNNZFpdT/6eEHHAzrO6du3rzvRvnjxYrvssssij2teOpGj9ekvj7YzflCGjo/gCmgn2lDo7Iw2aAqZtBFRGKRQRjWWVCD7gY82Xipw/Q2H6EyEzj74GyrRAYkOMHQmJLpw19l7nUnyAyYdyPhnvrVR1obWPysu6vRRGyb/CoYq/KPn7c9HZ038s0qis+GqPaUN8r777uvGaeMXfabfD6X896WNjn8go50E1TzQgZy/jvzX8d+zDuiiaydELw8AxCudAFA5r7O9KnN1sHT00UdHaj75omvg+uWeDiB0YQu/BpVoR11lusrJk08+uU55H13+62yzOn5XuK/XiC7rtQ3SWXYdaGg+OmDQWWr/jL+2Abrghspdzefyyy+PPFcHJL/73e/cX53oUPmvME01uPz3cfDBB0em13v3t2miAy4dRPjbBL3+hRdeWOd9ax2pY3ef5qFlBoDWovLrxRdftAceeMBd2U/lni42oSBE+7gKi+obMGCAu1qggnt1kq4TDT//+c/dPrWuIBtdhms/X7Vi//Wvf7kASwG+ymzVovWddtppLpjRlQdvv/12twx+h+/aTsioUaNc+ayASCdCFPRovk8++WTkhIHodaJfW2Wv5qfQLJrCOS2vTm5H78trG6JwzKdy2t+mqFyPPgmuE+7axqjsf/zxx13wduSRR9aZj45TdFJD27HolhF6H6odpdpPer5q9r7yyituXanmrtZ/9DGDthH+iQ7RyXP/cS2X1oV/kRP/fWs9RB9HSENXckfHRHAFtBO/2rAKXVVhjS5YdYYg+myJDhp08KCNggIkbTR01llnEa699loXdOmARBs+bZy0kal/IBP9egqtdKZGBzLaCOrMic5q6KBB1Y11NSkNOng54YQT7Nxzz3XNR1RLTBuVH//4x24jqflEV7fVgYYGBUs6e6Lqwy+//LJr6iE6YNIGVa+hDbKWQaGTNsDacdBVUHTWKrrpiM4i+XSApzNfZ5xxhlsGNU3RzsZNN9201SWMASDeqMzza7o2RuWkdvJ19l/lvco2HWCoOYh2whV6TZ482Z2B10GAykmdcW+svK9/0KGmLTorrYOLf/zjH247oGXym4Hrts7864BGtZ0eeughd6JABw3RBxEKkbRd0jR6X1omle9+cKX3odBJYZWep+2MwiodvOmgRK+rEw6q7aUDMAVg0a+vbaK2B1rWY4891tUCePbZZ10TFr95DQC0BjWV0xBN+9oqTxujsKV+jVDRvnl9J510khuaon1fnZBuisrybe3vqtauToT7VCNJ++R+kzudvNYxg7Yr2udXUKTjDlFtMNV6ip6HtiF+VyXaDvgnW7TNUC0yva6CPM1HxyP+fHTb3wZoPUWX76JjGjVBvOiii9wJCR2DaFnUFFLzUS3e6JPU2uf3T96oFpgCPgV7/jLWf30tj46f/OXR8YaupKtlRWLY0kkNgDalHXzVrqp/afSGqO373Xff7WpSaadfdFbmlFNOcffVnFAFvh9WqQZT/arN0WcpdHZF7cz9AxkdpOi1dBCj56r5hr9heuSRR9zZHm1gPvjgA7fx8s/saNnrB2462FJ1YDUZVOjkN40RhU26rfeiAxidGVFYpbNWqi6sM1eal6pqa4OoDW/0WSBRUKVxWlaFf+qThdAKQKJQWa2aq6oJpbJRdHChcvHhhx92ZbYfWukgQwcf0TVvVYs1uqaTDlL8bYOeq6BfAZXK9MMPP9ydSFDIpAMC1ZbVdunvf/+7a8atGgjayVcTQtUY0zL4dIChmgWqQaamhaptoG2Dvyyaj4IpHVyouaOaM6q2gWoHqMmiynuFZDpBopBMyxhd+0zvQ7UedOChkEsHKnqu34wEALA17Zefd955LrBRuakTz9rHVo0tnbBQwKNQqf6JDX8boX1vv08oUYikaXTyWmW3WkdoX14tORSI6XhEdCJdJ6z1+mpiruf4LTc0n/r785pG2w0tk0JAnZzQdkb8Vh5qEqnuR0QnMHQiXdsZHcNoWxXdtUj91//lL3/ptmE6maLtj14run8wdHwB9dAe64UAkmXDorPUOiCJJW3cVKj7HUoCABKTamIpbIru4woAkDhUG1b90+oktVpNqImegiqdMNaJjL333jvSvYZCKdVg9TumVzCliy/5/V9pep2cUG0xXSRDtcl00lgnslUjSmFRdGfyOpnidzKv+fg1pvQcTR998kNUo01BmE62q6aXlkstMkTjdSJdtYS1PHpNdQIvml5NBdUkUyfBFcypaXn92lSqZaV5+y1ZqK2bWAiugHYyY8YMV7spus+PWAVoOiOujiYBAIlJTTFUW0lXearfrxaQrNRsVc2HVLNdtRcboqt3qosFNXeNvioykExU41cn259++ulYLwrg0FQQaCeqDhvr0MpvA64mHwCAxKWDb/XhQmgFmK1du9b10akmt+pQWk1zG6ILEKjZkq7IppqK6v5AF0YAko2aERLcIp4QXAFJRh2pq78TAEDi0kkKdaAOIBzkqn8cNU/ym0nVpz7WdEU4XWRGteQ1rfp+i74YApAsdIEQdS8CxAuCKwAAAAAJS33jqMaVLgLQmH/+85+2zz77uM6j/QvS6CIzumgNkIwtRQYNGhTrxQAiwteYRLurqalxHeJpAxrdyR0AYGvqpFN9k/iXO+5IKO8BIP7Le3UcrQ6do+m+Oo3WPruWp77y8nI3+FTeb9y40V2Mh/17AGi98p7gKka0Aax/JQQAQNN0qWddurkjobwHgPgv7/Pz891FdKIpgBJdsa2h4GrSpEl20003tdsyAkCylvcEVzHiV1XWh6TLfgIAGldYWOjC/qaaecQrynsAiP/yPi0tzUpLS+uMKykpiTzWEPWJdc0110TuFxQUuCsWsn8PAK1b3hNcxYhffVihFcEVAGxf2dmRUN4DQMvLzvaiqwkqcIq2fPlyC4VCjbaSSE9Pd0N97N8DQOuW9x2roxAAAAAAaGXHHnusvfnmm66/Fd9zzz1nhxxyiGVkZLC+ASCGqHHVQmVlZfbMM8/Y7NmzXdW2o48+2saNG9e6nw4AIObU78lTTz1l8+fPd1eZGj9+vLtCFQCgY6iqqrIpU6ZEmqYsWbLEXnvtNVczasyYMW78BRdcYA888ICdcMIJdvHFF9uHH35ob7zxhr3zzjsxXnoAADWuWkBXF9FVRt577z0bMmSIa/9+3HHH2fXXX883CgASyGeffWYHHHCAC6122mkn19H63nvvbQ8//HCsFw0A0Ey68t+f//xnNwwdOtT1ZaXbTzzxRGSarKwsmzp1qh188MH29NNPW0VFhX300UduGwAAiC1qXLVAZmamC6105t2nXvB/+ctf2q233trhLtUOAGhY7969bdasWZadnR0Zp/5O7rzzTjv//PNZbQDQAagMVw2rbdFVBbUvDwCILwRXLdz4RR/EyNq1a12QRWgFAIkj+gRFdHnfq1evmCwPAAAAkGwIrnbAX/7yF5sxY4Z9++23rs+rF198sckqyhp8al8PAOgYbr75ZlfWz5s3z7p3795kU0HKewAAAKD1EFztAPV3oks3qmPHxx57zHX6OHr06AannTRpkt10003WWu584+utxl191IjwjbcnWUwcNjE28wWANqbO2BVYpaSk2PPPP2/Tp0+3gQMHxqy8by+R7QoAAAAQIwRXO+CII45wgxx44IF21lln2WmnnWaDBg3aatqJEyfaNddcU6fG1YABA3Zk9gCAdnLKKadEbuuiHLr61Mknn2xpaWlbTUt5DwAAALQegqtWoqtM1dTU2KJFixoMrtLT090AAOj45b1OPqivK12Yoz7KewAAAKD1cPm7Fvj4449t1apVdcapqaCuNrjHHnu01mcDAIixd955p06fhDpBocunq8Zs3759Y7psAAAAQDKgxlULVFVV2dFHH209e/Z0l0pXZ72rV6+2Rx991F1GFwCQGPLz822//fazoUOHWl5ens2cOdOFV08++SRXkQUAAADaAcFVC6g/q1mzZtm0adNs+fLlduGFF7oDG9W4AgAkjvHjx9uRRx5pH330kW3YsMGuuOIK23///S0UCsV60QAAAICkQHDVQuqQ9+CDD27dTwMAEHc6depkRx11VKwXAwAAAEhK9HEFAAAAAACAuERwBQAAAAAAgLhEcAUAAAAAAIC4RHAFAAAAAACAuERwBQAAAAAAgLhEcAUAAAAAAIC4RHAFAAAAAACAuERwBQAAAAAAgLhEcAUAAAAAAIC4RHAFAAAAAACAuERwBQAAAAAAgLhEcAUAAAAAAIC4RHAFAAAAAACAuERwBQAAAAAAgLhEcAUAAAAAAIC4RHAFAAAAAACAuERwBQAAACDpPf/883bsscfaLrvsYmPGjLFbbrnFSktLk369AECspcR6AQAAAAAgll5++WWbMGGC/elPf7Kjjz7aFi1aZBdddJEtWbLEHnroIT4cAIghgisAAAAASe2tt96y3Xff3a666ip3X7WuzjvvPHvsscdivWgAkPRoKggAAAAgqR122GG2cOFC++yzz9z9goICmzJlih111FGxXjQASHoEVwAAAACS2kknnWR33XWX7bfffta7d2/r2bOnDR482O6///5Gn1NeXm6FhYV1BgBA6yO4AgAAAJDU3nzzTbvyyitt0qRJrtngs88+a1OnTrVf//rXjT5H0+bl5UWGAQMGtOsyA0CyoI8rAAAAAEntt7/9rbui4E9/+lN3f9SoUa654LnnnmvXXXedC6bqmzhxol1zzTWR+6pxtUPhleeZBQItfz4AJCiCKwAAAABJrayszDp37lxnnMKqmpoaq6ioaPA56enpbmg1nzxq1m8fs167EmABQBSaCgIAAABIauqE/bnnnrPZs2e7+5s2bbI77rjD9txzT+vRo0f7LETJBrMvXjab8TezNfPCNbAAANS4AgAAAJDcrr/+etuwYYONGzfOsrOzXbO/sWPH2jPPPNP+C6MAa/5LZks+NBs01qznLtTAApDUaCoIAAAAIKmlpaXZPffcY3fffbetXbvWunTp4sbFVPF6s/kvmi2ZSoAFIKnRVBAAAAAATBWbAtarV6/Yh1YNBVgfP2S29guaEAJIOtS4AgAAAIB4pwBr3gtm2d3NBo8z67EzTQgBJAWCKwAAAADoaAFWpx5mgxRgjSTAApDQCK4AAAAAoKMpWmc2b3I4wBp8kFn3EQRYABISwRUAAAAAdOQA6/PnzTr1DDchJMACkGAIrgAAAACgoytaGxVgHWTWY0SslwgAWgXBFQAAAAAkVID1nFlOr9o+sAiwAHRsBFcAAAAAkGg2r9kSYLk+sHaK9RIBQIsQXAEAAABAIgdYnz1rltO7NsAaHuslAoDtQnAFAAAAAIlu82qzz/5tltsn3ISQAAtAB0FwBQAAAADJonDVlgBLNbC6DYv1EgFAkwiuAAAAACAZA6y5z5jl9jUbPI4AC0DcIrgCAAAAgGRVuJIAC0BcI7gCAAAAgGTnB1h5/cI1sLoOjfUSAYBDcAUAAAAACCtYYTbnaQIsAHGD4AoAAAAA0EiA1b+2BtYQ1hCAmCC4AgAAAAA0rGC52ZynzDoPCAdYXQazpgC0K4IrAAAAAEDT8peZffokARaAdkdwBQAAAADYzgBrYG0NrEGsOQBtKti2L5+43nnnHTvvvPNs7NixNmHCBHvllVdivUgAgFbmeZ5NnjzZzjzzTFfen3322fbRRx+xngEAyF9q9um/zGY/Ye42ALQRgqsWePTRR+2mm26yQw891P7whz+4g5lTTz3V7r///tb/hAAAMXPjjTfa448/bieffLIr7wcNGmTjxo2z1157jU8FAABRaKXwSiEWARaANkBTwRZQDatzzjkncl/B1ZIlS+yee+6xSy+9tDU/HwBADF133XWWmZlZp7yfM2eO3XfffXbsscfy2QAA4Nu0JDyo6eDgg8J9YQFAKyC4aoHogxhfenq6VVVVtcZnAgCI8/K+uLg4JssDAEDHCbAGmw05yCyvf6yXCEAHR3DVClauXGkPPfSQXXDBBY1OU15e7gZfYWFha8waANCOPv30U3vppZeabBpOeQ8AgAKsxeGh65BwJ+4EWABaiOBqB23evNn1fTJ06FDXF0pjJk2a5PrFAgB0TMuXL3fl/Yknnmg//vGPO1R5f8DSB1v2xLe7NW+6wya27PWBRPH2pLZ9fX5j6Mg2LgoPLsBSDax+sV4iAB0MnbPvgKKiIjvuuOOsurraXn/9dcvIyGh02okTJ1pBQUFkWLZs2Y7MGgDQzjVrDz/8cNt9993tySeftEAg0Oi0lPcA0HHl5+fb008/bQ8++KAtWLAg1ouTWBReffKo2ZynzQpWxHppAHQgBFc7EFodf/zxrp+TKVOmWJcuXZqcXn2i5Obm1hkAAPFv1apVdthhh9nw4cPtueees7S0tCanp7wHgI5JJ6LVikKh1WeffWZnnHGGu7IsWtnGb8MB1txnzAqWs3oBbBNNBVugpKTETjjhBBdevfnmm9a1a9eWvAwAIM6tWbMmElo9//zzLpQCACSeFStWuCuH/+xnP7Pf/OY3bpwuvDR37txYL1ri2rAwPHQeaDZoTLgpIQA0gOCqBR544AF777333BkZNR2p33EvACAxqO/Cr776yoLBoO2///6R8QMHDnSdtAMAEoNqWaWmprrm3r6UlBTbe++9Y7pcSSF/aXjI7Ws2aKxZ9+GxXiIAcYbgqgXOPvtsO+KII1r/0wAAxJXrr7/eLrrooq3GU/MKABLLRx99ZGPHjnU1bV955RXLysqycePG2ZAhjdcC4iqyraxwpdln/zbr1DNcA6vHzmZN9CkJIHkQXLVAz5493QAASGwDBgxwAwAgsW3cuNFqamrs0EMPdS0q1q9fbxdeeKHdfffd9pOf/KTDXEU2IRStNZv3gllWN7NBB5r13NUsSNfMQDIjuAIAAACQ1FTDavr06fbll19GalndcccddsUVV9iZZ55pnTp12uo5alZ4zTXXRO4XFhZysqM1lWww++I/Zos/MBuwv1nvPcxCHL4CyYhfPgAAAICkNnLkSFu9enWdpoG6OIeaAy5cuNBGjx7dYLPxVms6rk7Kqytb57USTWm+2devmy35MBxg9d3TLJQa66UC0I6ocwkAAAAgqZ166qm2bNkyF175ZsyY4Tpob6qfq1ZRU2321A/MPrrHbOWn4fvYWvlms2+mmE27PxxiVZWzloAkQY0rAAAAAEnt2GOPtQkTJrgO2c866yzXx9U///lPu/322y03N7dtZ64r6lUUhYOZBa+ZLZ9uNvggsx670Dl5QypKzL5912zpNLP++5r129csLattPyMAMUWNKwAAAABJ79FHH3WdsXueZ8OGDXNXGvzpT3/a9uul6xCzK2aZjTjWLDXLrHST2Rcvmc162GzDN2ael/SfTYNU42rx1HANrG/eNCsvYj0BCYoaVwAAAABgZscff7wb2l1Kerj/pp6jzJbPNFs23ax4ndnnz5rl9jMbcohZ54F8Rg1R32DLZpit+MSsz2izgfubZeSxroAEQnAFAAAAAPEglGY2aIxZ373C4dWKmWaFK8zm/Musy5BwgJXTO9ZLGZ9qqsxWzDJb9alZr13NBh5oltU11ksFoBUQXAEAAABAPEnNNBt6qFm/fcyWfmi2ao7ZpkXhofvIcB9Y2d1jvZTxSZ3br5prtvpzs547mw0cY9apR6yXCsAOILgCAAAAgHiUnmO20zFm/fc3W/K+2Zp5Zuu/Mlv/tVnv3cwGjaNZXGO8GrM1883WfmHWbbjZoLFmuX3a9eMD0DoIrgAAAAAgnmV2Ntv5RLMBB5gtes9swwKz1Z+Fg5m+e4ZrFaVlx3op45M6t1+/IDx0HRpuitl5QKyXCsB2ILgCAAAAgI4gu4fZbqeaFa40W/SuWf6S2n6d5pr13zfcwXtKRqyXMn5t/DY8KLhSgKUgC0DcI7gCAAAAgI4kt6/Z6DPNNi0OB1ibV5kt/chs5SfhWln99jULpcZ6KeNX/jKz/KfDTQdVW637TmaBQKyXCkAjCK4AAAAAoCPqMtis86Bw00E1ISxZHw6ydDVCBTJ99jQLhmK9lPGrcJXZ58+FO2/X+uq5CwEWEIcIrgAAAACgo1JNoe4jwh2Qr51vtvh9s7ICs2/eMFs+I9yBe69dzQLBWC9p/CpaZzb/xfC6G3iAWa/dzYKsLyBeEFwBAAAAQEenYKrXbmY9djFbNcds6dRwgPXVK2bLppsNOcis2whqFDWlZKPZl/81WzzVbOD+Zr1Hm4U4ZAZijV8hAAAAACQKNQ3st7dZ793DHbcvmxZuQjhvsllOH7Mhh4SbGKJxCvy+/p/Zkg/DHd6ryWVKGmsMiBGCKwAAAABINOqcXc3e+u5ptmyG2fKPw524z30q3C/WkIPNcvvFeinjW3mR2TdvhgOs/t8x67ePWSpXbQTaGw13AQAAACDGlmwssZKKqtZ/4ZSMcEi1/8Xh4CUQMstfYjb7sXDH5MXrWn+eiaayNNz5/bT7zb5916yiJNZLBCQValwBAAAAQIytzC+1lVXllpuRYj1zMqxbpzQLquP11pKWbTb8KLP++5kt+cBs9efhqxFq6Lmr2eBxZpldWm9+iaiqPFz7SrXXVJNNzQjTc2K9VEDCI7gCAAAAgDhRWFZlhWVFtnhDwLrnpFuvnHTLSmvFw7aMPLORJ5gNOCBci2j9V2Zr55mt+yLcGfmgMYQx21JdabbsY7MVs8N9ialJZmbn1vuMANRBcAUAAAAAcaaqxrPVBWVuyHG1sNKtW6d0C7VWLaysbma7nmK2ebXZonfNNi0yWzXbbM1n4SaFCrZSM1tnXomqpsps5ezwVRx77RoO/bK6xnqpgIRDcAUAAAAAcWxzWZUblmwose6d0q1nbrplt1YtrJzeZnucYZa/NBxgFa4wWzbdbOWnZgP2M+u3r1lKeuvMK1F5NWarPzNb87lZj53DAVannrFeKiBhEFwBAAAAQEephVVY5oac9BQXYLVaLazOA832/KHZxoXhJoTFa80Wv2+2YpbZwAPN+u5lFuTwsUmeZ7b2C7N1X5p1Gx4OsHL77vhnAyQ5Sh4AAAAA6GA2l1fZ5nVVtnhDifXolGY9czN2vBaWAjAFLl2Hhfu8UnBVusls4ZvhDskHjQ336RTg4vTbDLDWLwgPXYeEg78ug3bsswGSGMEVAAAAAHRQ1a4WVrkbOqWnWC/VwspOt1AwsGMBVs9RZt1Hhvu8WjzVrLzQ7OtXw80IBx8UbhLXmlc9TFQbF4WHvP7hWmudB4Q7yAfQbARXAAAAAJAAisqrrKi2Flb37DTrpVpY6TtwyBcMmfXZ06zXbmYrPjFb+pFZ6UazL140WzbNbPDBZl2HEmA1R8Hy8CAKrhRgKczKG2iW3a3lnxGQBAiuAAAAACDBamGt2Vzuhuz0kPXKybBundIsJdjCJn7q20odtfcZHW4yuHyGWdEas8//HQ5fhhxiljegtd9G4iorMFut4fPw/bSsLSGW/nbqZdbSzwpIQARXAAAAAJCgisur7dvyYluyscS61dbCUpPCFtHVBQePM+u3t9nSaeGO21WL6NMnwv1iqQmhrlKI7VNRYrbu6/Dg1nOaWa6CrP7hmlk5fc1CHLojefHtBwAAAIAkqIW1dnO5G1QLq2dOhnVvaS2s1CyzYYeb9d/XbMmHZqvmhK9GqKHHLuEAK6trW7yN5FBVYbbx2/Dg13hTIOiaF9Y2MVSICCQJgisAAAAASLJaWIvKi21pbS2snrnplpOeuv0vlJ5rNuJYswH7h69AuHZ++GqE6740671H+CqEGblt8RaSS01VVB9ZH4X7FMvuYdZ54JYgK71TrJcSaDMEVwAAAAAQpaSkxP3NyspKnlpYaSHrmdvCWliZXcx2OSkcYC16L1zzavUcszWfm/Xd22zggeF+nNA6PM+saG14WD4zPE413PwQSzWz9JkACYLgCgAAAABqTZkyxY455hgbMGCALV68OGnWS3FFtS1aX2xLNxRb107p1isn3XIytrMWljoV331CuGbQonfNCpaZrfg4HGL12zfcwXtKRlu9heRWsjE8qNmmpOdsCbEUaKmGlmpqAR0QwRUAAAAAmNnatWvtxz/+sX33u9+1OXNqA4AkU+2Zrdtc7oYs1cLKSbceOenbVwtLgcnos8w2LQ4HWEWrzZZ+aLbyk3DtK9XCCrWgaSKar3yz2dovwoOkZmypkaW/6jMrGGKNokMguAIAAACQ9DzPs3POOccuv/xyKy4uTtrgKlpJRbUt3lBiyzaWWNfsdNcXVm5za2Gpdk/XIWZdBput/yrcB1bJBrNv3zZb/nG4/6veu4c7HkfbqywzW78gPIiuUpjbLyrM6k+YiLhFKQEAAAAg6d1+++1WUVFh1157rd18881Jvz62qoVVVO6G7a6FpQCrx85m3UeE+7xa/IFZeaHZgtfDIVa34eHHug41C6Wx3ttLdZXZpiXhwX1OQbOcXuEgy3X63t8sNZPPA3GB4AoAAABAUpsxY4bdcccdNmvWLAs2s0lceXm5G3yFhYWWTLWwtlyRMKN5tbAUjOhKgz1Hma361GzpdLMKNWebHx5U80rhVfeRZt2G0RdWe/NqzApXhYdlM8KBY1a3LSGWAi2uEIkYIbgCAAAAkLRKS0vt+9//vv3ud7+zzp07W1FRkat5paaDup2ZmWmh0NZ9AU2aNMluuukmS1Y1rhZWhRsyU3VFwnTr0SndUkPbCP4UUKmj9r77mBWuDDcj1FBWYLb+6/AQCIWbGKomlgZq/sTmyoXF68PDik/C4zLytnT27jp87xaDBUMyIrgCAAAAkLQ2bdrkOmW/4oor3CAKrqqqqqx37972+OOP2/jx47d63sSJE+2aa66pU+NKVyJMRqWV1bYk0hdWmvXMybC8zG3UwlKNnjz1sdTPbOhhZkVraoOrr8J9YW1cGB6+fi1c60c1sRRipXdqr7eF+hQurtbwefh+WtaWEEuBVnZPs+3pxB9oJoIrAAAAAEmrb9++rmZVtBtvvNEeeeQRW7x4caPPS09PdwPq1sJaX1ThhszUoAuw1BfWNmthKcTSVe40DDk4XMtHAda6r8yK15rlLwkP3/zPLLd/OMDqMTJcAwixU1ES/ow0SEpa+PNxtbL6m+X0DXcCD+wgvkUAAAAAgFZVWlljSzaW2LJNJdYlK816qS+szBQLWGDbT87uHh505cHSTeGaWApHNq80K1weHr59y6xT73CApdpYWV35BGOtqsJs47fhQYIhs/TccN9Y6TlRQ96W26q1BWwDwRUAAAAARElLS7Ps7GzWSSvVwtpQXOGGjNpaWD2bUwvLl9nFbMD+4aGscEtzwoLlZkWrw8Oid82ye9T2iTUyfFu1uBBbNdXh4FFDY1QjK71+sEW4hboIrgAAAAAgyvXXX++G9rS02zjrtX66pVfXbbaYSMoqa9zVCJdvKrHOWWmuU/fUUMDSUoIuyEoLBS01JWihxkIn1dzpv294qCg2W78gHGKpGWHxuvCwZGo47HJ9Yo0MNz8kxIpf1VVmJRvDQ2MIt5IewRUAAAAAxNiGTjvZqrRB1mfzPOtXONtCNRWWyLWwNhY3/v5CwUA4xIoOtaLDLTc+01L67mmmobLUbMM34RBr46JwDZ9l08KDavP4NbHUEXyAzsM7HMKtpEdwBQAAAABxwAuk2Mrc0bY2e6T1K/zEehfNt4BXY8mmusaz0ppqK61serpgwCK1tNJCgy2191BL71Nl2UWLLbNgoaUWLLJAeaHZipnhITV7S8fuuhKe+mBCYiDcSmgEVwAAAAAQR6pCGbakyxhbnbObDcz/2LqVqLNrL9aLFZc1t8qqatxQV3+zTv0tmDXW8sqXW7eSRdalbKmlVBabrZrthupQhlXkDbWqbiMs0GWwpaamuhAsQLPCxEW41WERXO2gmpoa8zzPQiHSegBI9PJegkGaGAAA2kd5Sq4t6H6ErSzf3QblT7fc8lWs+u1QE0yxTZmD3RDwqi2vbKV1LV1kXUuXWGp1mWVunG+2cb5VBVItP3OgbcwcYkXZAyyUmt5A08Rm9sOF5A630rLNUtLNQmnhISWtPZc+YRFctdDMmTPtgQcesCeffNL69u1r33zzTet+MgCAmNOJibfeesuV9y+++KIdccQR9tprr8V6sQAASaY4vafN73WidSlZbAMLZlhmZX6sF6nD8QIhy88c4IZvvRrLLV/tQqxupYstrbrEupcsdEP1xpDlZwxwIdbGzIFWHWw4eEgJBqL63gpENVmM7pMrYCmc8ErOcMunPtVCqbUhVnrt7dq/dQKuqNt+4OVuR0+brjOolowIrlro6quvtnPPPde6du1qkydPbt1PBQAQF1atWmW//e1v7eKLL3Y1awsKCmK9SACAJLYpS7WHBlrP4q+sf8EsF7igBQJBK8zo64bFncdYp4q11k01sUoWWUZ1kQuzNNRY0Aoy+tnGzMFuUBNOX1WNZ1WuH67qJmcVClgkyEoJqaaW+uYKWDAYcLW29Fd9dalD+jrjNV39aQIBmjJ2NOqjrqo8PJRv3vHXC6ZEhVppWwdiDQZeTUzbQRBctdD777/v/t54442t+XkAAOKIatS++eab7rZqXAEAEHOBoK3ttIutzxpufTbPtb6Fcy3kbaMXczSxPgNWlN7LDUvy9resyg21IdZiy6rKty5ly9wwdNMHVpjexzaoJlbWYKsMZTVrrVZ7qqDTUD9cLeMCrUAgKuiyqHBLQVc48KozTUPBWLD2deqNCxhNIONaTZVZRZWZtUJoreaukRpg0bW8GqgF1lhtMf3NyLO2RnAFAAAAAB1MTTDVVuTt40Is1b7qWfSlBejAfccEAlaS1t0Ny/K+Y5mVm1wtLNW+yq7cYHnlK90wJH+qbU7r5QIsNSksT8mx9uyQvsZTba+26ay/TsgVCb+ian+5cduoNRb9PIUjtX8Vibm7msbdJiSLKc8zq6oIDy2VlmU29iprawRX7aS8vNwNvsLCwvaaNQCgHVHeAwDak2r+LOp6kK3K2d0G5s+wrqWL+QBaSWlqF1uRp2FvS68qdFcn1PrNqVhruRVr3DA4f7oVpXa3DVnqE2uwlaV27tDr3wVjqibWDiFodJCl28Go2+6vu28WVD0w/7FwDhYOwtztLdNFB2JbTVc/OKv/XKsdV++5hG7xgeCqnUyaNMluuummNp3HnW987f4esHSD+3vg0G51Hv/o2/B4X/3HW3MZfFcfNcLa1NuTLCYOm2hJg3WcuGLx2SbBb6c9yvv2Un+70ZhpVXXL/tZ2wNIH2/T1pw28sH22WR3595wEv91EVX/frL106N9TB6XA5OseR1tO2Sp3BUL124TWvcLjytzRbkirKnIBlgZ18t6pcr11Klhvgwo+tpKULpEQqyS1azgVQYNcPBb5L3ps/GsqdLOoUGzLtOE7figWvh09fd1xW54bftCNi4yPem1/Xo28TuS5/vzrvXbd1wnf8Oflv4/ox6PfR3iSamteo9kdQ3DVTiZOnGjXXHNNnRpXAwYMaK/ZAwDaCeU9ACCWNmf0sc97j7duJQttQP7HllFFS4/WVpHSyVbn7OaGlOpSF2CpOWFu2QrLqtpkWYWbbEDhJ1aaklt7dcLBVpTWgxArgXTk0K01BdIq7QBrewRX7SQ9Pd0NAIDERnkPAIgHG7KGucCkV9EX1r/gE0upKYv1IiWkqlCm62dMQ6im3LqULrFuJYutc9lyy6wqtH6b57ihPJRtmzIGWmlqZytLybWylDzXN5YXUOM2AE0huGqh6upq8zzPamrCV4eoqlLP/mYpKaxSAEjE8t4fVN6rmnQoFIr1ogEA0CQvEHK1gtZlj7C+hZ9an82fW9ALH7eg9VUH02199gg3BGsq3NUI1bm7/qZXF1vv4i/qfj4WsPJQJytLzXNhVmlK+K+GcKjFvgYgpCwtdMQRR9gHH3wQuZ+RkeH+LlmyxPr168e3CwASxKBBg2z16tV1ynsNRUVFMV0uAACaqzqYZss672drOo2yAQUzrUfxgqRs1tSeaoJprtabhmBNleWVL7ec8jWu6WZ4KLCQV20Z1ZvdUN+WUCtcOyscbEXX1CLUQvIguGqhd955p3U/CQBAXFq+fHmsFwEAgFbrm2lht0Nrr0A43TVnQ9urCabYpszBbojwPEutKbHMynCIFR1o6W/Iq4oKtVY0EGplRwKt6HCrzIVaHOYjsfCNBgAAAIAkUpLWzb7sebzllS23gfkzLLtifawXKfkEAlYZynZDofWp+5gLtUrDIVbllkBLfWaFQ61Ky6gucoOV1w+1LFxTq7bJoQu0XLAVHgi10BERXAEAAABAEirI6G+f9epn3UsW2ID8mZauIARxEmpluWFzemOhVm2gVenX1gr/TakTaq2s+1TVuouuqRXVr1Z5Sq6rGQbEI76ZAAAAABBDf3jtS5u7PN/SU0KWlRayrPQUy9bftBQLBQNtO/NAwHUmviFrqPXZPM/6Fc62UE1F284TrRRq9a77mOe5q0dmRjc9jAq2FGqpk3gNefVCLQk3P4xudrjlNqEWYongCgAAAABiRFes/dv731pldcOdpWekBi07LWWrQCs7vfZv7fiMlKC76m2LlyOQYitzR9ua7JHWv3C29S6aZwEvfAV1dBCBgFWFMm2zhkZCrfrNDv1gK8WriAq1VjURatUNtMKhVmr7vUckJYIrAAAAAIgRBVaXHDLM3vl6nW0uq7Li8iorqai2kooqq/HMyiprrKyywjYUN/06qpi1VaClwCs95IKv6PEpoWCjr1MdyrAlXQ601Tm72sD8j61bybdcgTCBQq0iDem9Ggi1yhvsJF4Blx5rKtSqCGZF+tHymx5uqalFqIUdR3AFAAAAADGSlhK0a44eaRlpISuvrKlTE6usqsZKyqusWEGW/7ci/DcScJVXuekUchWVV7nBrLzpeYaCWwKt2hpbqtGl+/74rLQsK+12uOXk7G6D8qdbbgOBBRIp1MqwIg31Qy2FBtV+Ta2tr4CYWlNuaTUlllZeYrnlq7d6bnUgxaqDaVYVSHN/t76dGv5be786kF57O9WqA+HxFmg8aEVyILgCAAAAgDijZn+ZqSE3dNvGtFU1NVaqMCs64IoKukpqgy7dr67xrKK6xipKaiy/pLLpZTCzTBdojba8lF2sl7feugeLrHNKueWFKqxzSoV1DlW425nBauUfSEBbQq2eDYZa6VWbo/rV2hJspdaUWcirslB1laVZSYvn31T4tSXwaug24VeiILgCAAAAgA4sJRi0nAwNTTfLUi0uhVYl5Qq51CxxSw0uF3BFjS+trHZXoQs3W6y2dWb2jYvQGo7R0gPVllcbZHUOlW+57YdbUX9TAg3354WOGWppKE7vsdVj6uRf/Wql1FS42+6+19TtStcs0Y3Tfa86/DqtFH5VBdOtOrqGVxPhV52QzD2WSs2vGCK4AgAAAIAkqcWlKxdq6JKd1uS0NTWeC6+KowOt2ppcGqpKC6y0vNIKqlOttCbFyr2Qra3MdMO2dAqGA62MYLULsdICNZYaiL4dNQTr3a8dNF2KfzsYdbv2b0qd2x61wWLAD36abrjaOF0cwA+xGgq/IuO8xm/XD7926P0EUiMhVlPhV00gZF4gGP5rtX8DIauxYPhvIPzXf8yf3rPwYzSN3BrBFQAAAACgjmAwYNm6imF6illOQyunr6VUl9qAglmWW/i1FValWH51uuVXpVlBdZrla6iqHarD4wqq0qzaglZUk2ZFFU0HZ61NwVjd8MvbvoAsWC8sqx+QNfL86PnQlHL7KMxxNbosYwfCr+otIVd04OVVNhp+1a8JFoyEX5UWqm66eW1r8CxQL/QK1t6PCr00zqJCrwaCMT0eeW7t9NsOzhoJ3Wofj9WXmOAKAAAAQNKbNm2avfLKK7Z+/XobNWqU/ehHP7KcnAYTG9TSVeoWdR1nGTm72cD8GTaydHGT68Z1IF+TGgm3ymuCVukFrcoLWoVX73btY40ODT4eiLodqjNv3a8/rr25KCHguUExQFC3a/+6WKDOfYtMV2f6Bp4T/Vr1pw3f1rybnu9WfxtdNmvWMul+wJ/G1fZTHBN+rrKPgD++9r4bH+4nvlUpdNH3VIO1dvjVQOAVrKm0oFdjAUW0XrWrNeb+KlZy9xXd1oT/arra+3Xmp3Xo1dYOi7NWtTVauugaZMEUs/vfMLv0ozadL8EVAAAAgKR21VVX2ccff2zHHXec7bHHHvbEE0/Y7bff7sb16rX1VdZQV1lqZ/u6x9GWU77aBm2aZp0q1ja4ihR65IYq3WBW3Kar0fPMqmqDrIraQGyr2w0EZ9sOyfxwLLTldhMhWziOCVNEUe3FXxgRb8Kh1tYBl4IxF27VBmgu9HLfq6jxjYRkDYZm0dM1M1zb6jXrzduiHvPHu3G1X4M6j9X29RbwPEuxaku1KjekqHagV+nGpei+6b7G6/FqV/Mr/Jies+V2iqe/4fuh2tdTU0m9hu6n6DVqH0up91id27XThm/XDdX0/k2hmh+s1ZhVblxiTfeut+MIrgAAAAAktZ/+9Kc2ZMiQyP3zzjvPhg0bZvfdd5/dfPPNMV22jmRzem/7vPd461ryrauBpSvLxYqCAtdMz6oty8JNvdqbwjPVtVFA5odlqrFSUzu+2gvU3lf9nPBfV1fHa/ix+n8VKfjTVbvXrr3fwOs19NdNVzutv6zV9ZaxzjLVf81tLlM4pokO75q13lx9pcDWAR+BX7vTJ6nfUJpVuiAsTUOgMvy3NmjLqjZ7qo2Xg+AKAAAAQFKLDq0kIyPD+vbt65oNYvttzBpqmzIHWa+iL6x/wSfuynLJSOFZinmWElJwFpvwLB4oFAtXNHP1j1zA5d9XQBYZXxugufHuebV/a8e7xxt6XtTrNfVYY/PaarraefvTNT4v/379xyT8Oq6CUu3jFv1Y7Yj6j/nz9aeLrqBX44UDQH/+W9ZtvdeoDf2ilzPyeNTrR16j3nI29PrRr6042PPCdayqgyHL7D/c2hrBFQAAAABEmT59us2aNcuuv/76RtdLeXm5G3yFhbGrXRSP1AfO6pzdbF32COtb+Kn12fy5Bf3mRUgq4aZ1tiU+qW0ih44vkJZlB5x9VpvPxzXDBAAAAACYrVixwiZMmGCnnXaanXLKKY2ukkmTJlleXl5kGDBgAKuvAdXBNFvWeT/7tM/ptjZ7ZG3vPgDQfARXAAAAAGBmq1evtiOOOMJ23XVXe+yxx5pcJxMnTrSCgoLIsGzZMtZhEypSOtm33Q6xub2/Z/kZ/VlXAJqNpoIAAAAAkp5Cq8MOO8wGDRpkkydPtvT09CbXiR7f1jTYWklaN/uy5/GWU7bKcstXWWZlvmVVbrKMqgKaEgJoEMEVAAAAgKS2du1aO/zww11o9cILL7jO2dG2Nmf0cUOE51l6VaELsTKr8i2zclM40KossJBXyccBJDGCKwAAAABJ7fzzz7cvv/zSRo0aZRdccEFk/F577WXXXnttTJctaQQCVp6a54ZN0eMVaFUXuSDLD7Pc7ap8C9UQaAHJgOAKAAAAQFK78sor7fvf//5W4/v3py+muAi0UnLckJ85sM5DaVVFW4VZuh2qqYjZ4gJofQRXAAAAAJLa0UcfHetFQAs7fNdQkFn3io6pVcWWVaUwK9zkMBxu5VtKTRnrGeiACK4AAAAAAAmjMiXbCjTUu3phanVJbZAVrpnl306tKY3ZsgLYNoIrAAAAAEDCqwxluaEwo1+d8SnVZVuaHEbV1EqrLonZsgLYguAKAAAAAJC0qkIZtjlU7yqHZhaqKY80M8ys3Fj7V4FWccyWFUhGBFcAAAAAANRTHUy3ovTeboimzt/9ZobRNbXSqxRoeaxHoJURXAEAAAAA0EzVwTQrSu/lhmjBmspwmFXlX+lQfWlttPSqIgItYAcQXAEAAAAAsINqgqlWnN7DDdGCNVWWWZVv6VWbLehVWqim0oJelYW8Khd2hbza++52Ve00tX/1WE14WmpzIVkRXAEAAAAA0EZqgilWnNbdDS3meRb0qiNh1pbwyw+2toRf4WmqIuPD02wJy7ZME35ugOaNiHMEVwAAAAAAxLNAwGoCKVZjKVZlma370i7M2hJ++bXA6tQM20ZYVjc4Cz8W8GpadTmRvAiuAAAAAABIUl4gxapCCsQyWvV1A161BTx1Vu/V1uqq7bje033bMl61yQK6HVA+58YHNY0b57nQLjyd1U5n7n54sKjn6Hbt/Nzza59XO32wdhn85/jP9x/3pw1GLZt7XsBfZj1py+u78ZF56TX85/mv6i9bA+smanx4HUUWJOpmw68TaOR16j25wdfXOtnm6zSyDA09LyU1zdoDwRUAAAAAAK19sB0MWEooaKmhgLsdCgXdQX8wEHChhws73O1wPBAMhoMCjXfjav+GA5Lw3+jxW54ffl74Nes+b6t5RJ63/fPwX2Oreehf0Bqch/9+IgFR7TTh23WDFKAxBFcAAAAAgKQQcmFSwFKDQffXD5f0NzUUNa72cY3Tc8LhU71x/mvUvl6o3usSygCtg+AKAAAAABAzqqETDoS2hENbQqLa237A5IdEfpgUFTpFj0tVDac6NZ7CfwmTgI6H4AoAAAAA0KbSUoLWKzfDeuWmW+/cDOuZk2EZaQqYghYMt1MDgAYRXAEAAAAAWo1qOvXISXchlcIqBVVds9Oo7QSgRQiuAAAAAAAtor61FUqFa1OFQyqFVgqvAKA1EFwBAAAAAJolJyPFeudtCal65qZbekqItQegzRBcAQAAAAC2kpEast556dYrJ8N65YWDqux0DiEBtC9KHQAAAABIcrriXs/agMrvQL1zVlqsFwsACK4AAAAAIJkEAwHr1inNhVOub6q8dOuenc7V/QDEJWpcAQAAAEAC65yVWtsfVYbrn6pnTrqlhoKxXiwAaBaCKwAAAABIENnpoUjH6e5vXobrqwoAOiqCKwAAAADogNJSglEhVbrrnyo3IzXWiwUArYrgCgAAAADiXCgYsB454U7Te9Z2nt41O80CgUCsFw0A2hTBFQAAAADEEWVRCqWim/wptFJ4BQDJhuBqB1RVVdm8efMsJSXFRo0axdkOAEhQZWVlNn/+fMvJybGddtop1osDAGgjBQUFtmDBAuvVq5cNGDCgXdfzsB6drFttWKUaVekp9EsFAMKlJFpoxowZNmTIEDvxxBPtiCOOsJ133tm+/PJLvlUAkGBeeukl69u3r51xxhm233772YEHHmhr166N9WIBAFrZPffcY3369LFzzjnHRo4caaeeeqqVl5e323o+Ztfetu/grjagaxahFQBEIbhqAW3AtCE7/vjjbenSpbZy5UoXXOmgBgCQOFatWmVnnnmmTZw40Z2BX7FihVVUVNjFF18c60UDALSi6dOn21VXXWVPP/20q2H7zTff2LRp0+ymm25iPQNAjBFctcD//vc/W758uf36178Or8Rg0K6//nqbO3euzZw5s7U/IwBAjDz11FOuObgOZiQrK8uuueYaVwtrw4YNfC4AkCAefvhhGz16tGtNIappe/7557vxAIDYoo+rFpg9e7Zr996/f//IuH333df1caXHdLuhWlrRVY3Vfl4KCwtb9MGVFRc1+lhxaXg+hcVlDY731X98hxUWbrVcLX1/zdba76G52vp9xRPWceKKxWfbwt+OX5Z4nmftSWX67rvvbmlpaZFxai5YXV3tTlYcdthhMS3vm6t++d/aWmMZ42H523yb1ZF/zx153ST5+m/r32djCjtgeb/PPvvUGafy/tZbb3W1b9WEsK3LewBIJoXbUd4TXLXAxo0brVu3bnXGhUIh69y5s3usIZMmTWqwqnF7d/rYtm7easz1lqi2fq9gHaPtfzubN2+2vLy8mJb3/v3kLu/ru9cSYfkTd5vVGtjusf63z47+nuKtvG8ouErO8h4AWldzynuCqxZITU11V5iqT+Oiz8pHU/8oal7iq6mpiWwgVVPLTxy1oVu2bJnl5ua2ZNHAemxVfCdZl/FCZ2K0UVPTjfYu70tKSuqMKy0tdX93pLxvqUT+TSbqe+N9dTx8Zslb3tffv2/P8j5Rv3dNSbb3nGzvNxnfc7K93x19z9tT3hNctcCgQYNszZo1rqmIalqJNlLauA0cOLDB56Snp7shmmpoNUQfeLJ80dsS65F1GY/4XrZce555jy7vp0yZUmecOmiX1ijvWyqRv0eJ+t54Xx0Pn1nylfd++e7TffVlG909SFuX94n6vWtKsr3nZHu/yfiek+397sh7bm55T+fsLXDkkUdacXGxvfnmm5FxL774ojtTc8ghh7TkJQEAceioo46yefPm2cKFC+uU971793Z9XwEAEqe814mK6Fq2Ku/Hjh1rmZmZMV02AEh21LhqgZ133tnOO+88+/GPf2y/+93vXLXin/3sZ/bzn//cunfv3vqfEgAgJo4//nh3QuLUU091V5JdsmSJ3X777faXv/zFnYUHACSGCy+80O6//3475ZRT7LLLLrMPP/zQXUE2+kQ1ACA2CK5a6MEHH7R7773XHnvsMXepdB3IKMjaEapqfMMNN2xV5Risx1jhO8m6THbqo+SVV16JhFU5OTn2zDPP2Pjx42OyPIn8m0zU98b76nj4zJKTyvepU6e6k9J33XWXu4L4O++842pctYdE/d41Jdnec7K932R8z8n2ftvzPQe89r7WLAAAAAAAANAMtHMAAAAAAABAXCK4AgAAAAAAQFwiuAIAAAAAAEBconP2OKBuxr799lsrLy+3YcOGJVVnbq2turravv76a9eh8pAhQ1iXrWDevHm2adMm23///S01NbU1XjJprF271n0f6xszZgxXpEPE8uXLbfHixbbnnntap06dmrVmNP369evdVW4be05zpmlLRUVFNmfOHBs4cKANGDCgWc9ZunSpFRQUuG1hVlZWncfWrVtnX3311VbPOfDAAy0UCll7brM/+eQTVx7uscce29wmffTRR1uNHzlypPXo0aPOuIqKClfeZmZmus8sFhYuXGirVq2yAw44wF14pjHaX/n4448bfGzo0KHWt29fd/uzzz5zn2c0vW+9//b8vPS+Kisr3bI1dx9r9erVtmzZMvecbt26tXiatt7GrFy50u3v5OXl7fBziouLbfbs2Vs9R9/z3NzcVltubK2mpsb9/vV93XXXXdu1TIsVfd8+/fRTt33QdiLRqdzUNqxz587uPetYJdGp/Ff527t378h2IRls3LjR5s+f777XifrdrqqqsmnTpm01Xvsv3bt3b5uZqnN2xM5DDz3kDR482Bs6dKi38847e507d/YefPBBPpIWuPfee71+/fp5u+22m1uf3bp18/7xj3+wLnfAzJkzvYyMDF3AwVu1ahXrcjvp+5eWluaNHTu2zlBSUsK6hPfhhx96J510kte9e3f3G/v444+3uVaKioq84447zsvOzvZGjhzpZWVlue3I9k7TllasWOFddtllXp8+fdz3/5Zbbtnmc/7973+7beDAgQNdGd6pUyfvd7/7XZ1pHnvsMS81NXWr39PmzZu99lBdXe3dfvvt3vDhw922ev/999/mczZt2uQ+29GjR9dZ5tdff73OdFOmTPF69OjhDRkyxG27NP3SpUu99vLKK694hx12mNe1a1e3vOvWrWtyem0P6n8Ou+66q3vuE088EZlO4wcMGFBnuhtuuMFrL/fff7/7Tg0bNswbMWKEe3+PPPLINj/nCy+80EtPT/dGjRrl/l5//fXbPU1b+uCDD7wxY8Z4PXv29Pbcc08vMzPTu+iii7yqqqodes7s2bPdZ6jvdvRnNnfu3HZ6Z8lJ61ffUZWZ2o8dNGiQ98knn3iJauXKld4VV1zh3q9+O+1ZJsRCQUGBd/nll7vtxh577OF+g/r76aefeolq2bJl3umnn+72b/bee28vJyfHO+igg9z+QaLT9uHQQw/1gsGg98tf/tJLVOvWrXPbC21PorcX2p9pKwRXMXbrrbd6S5YsqbNjHggEmnUAg7r++Mc/ehs3bozcv+uuu1yhsXz5clZVCxQWFno77bST9/Of/5zgageCK+2EAg3561//6k2ePNn7/PPPmx1caedXwbwfLGiboXLus88+265p2tJ7773n3X333V5+fr47AGtOcKXy+6uvvorcf+2119wyK1Dx6X306tXLixUFztdee623YMECF8xtT3DV1Gerabp06RIJPsrLy90OvoKk9vL73//e7Wz+97//bVZw1RAtf15enldcXBwZ195BVX033XRTnX2Av/3tb14oFGoyiNFJML2PL774IhIwKzB97rnntmuatt62aJ6++fPnu4NifY478hw/uGrJ54+WH+QqtD/jjDO8mpoaN+6HP/yhK8MrKysTcrVOnTrV7aOr7FNgl+jB1ddff+3dc889XmlpaaSMnzBhgjtRkaj0GUdvv3VMoRMy+p4nOm13Tj31VPfdTobgavbs2e02T4KrOKQzzSrQsWO0Y6oflGoNYfudddZZ3s9+9jPv1VdfJbhqIR0o6IyiAgOFE9pZAerTwW9zgisdxOTm5rqQJ5p2fhWoNHea9tTc4Kohqtk0ceLEOsGVzlTrt6ShrKzMi5XtDa6ef/55ty3S/foefvhhVzNNZ+V9//nPf9zzFi1a5LUnv7zf3uBCtXYU0l966aV1xiu4uvrqq70ZM2a4M/CxpmBAAZNC48aodsAFF1xQZ9yxxx7rnXDCCds1TXsbP368d+KJJ+7Qc/zgatq0ae52e9VmTGYK+rXOVab5FOJr3BtvvOElumQIrhqikzP6jJOhBpLv/PPP98aNG+cl+u9ZtXw3bNiQNMHVSy+95M2aNcudrGxrdM4eZ7744gvXL8jw4cNjvSgd0ooVK+yDDz6w559/3i666CI77bTTbO+99471YnU4//jHP1zb7Ntuuy3Wi9Lhqb+YU0891b773e9a165d7c4774z1IqGDUl+IhYWFts8++9QZ/53vfCfSL01zpukI1qxZ4/oOqr8tVP88p5xyip144onu9/THP/7ROgJtj370ox9Zz5497ayzzqrT75M+l5122qlOH0L77bdf5LGO4LXXXnPb35/85CdbPfaXv/zFjVe/PaNHj3Z92sSK+lxTX1eN7WOpTzL1y1X/96PPw/8smjNNe9N70nvbnn3Hpp6jfaczzzzT/cauuOIKNy3ahr4z6ndNvw/fiBEjXHnQUX7/2H7qI1B9T/bq1Svh3+fbb79tf/rTn+yll16yX/7yl5bI/Vr98Ic/tL///e+u7EwWF1xwgZ177rmu/0q9f+2DthWCqzhSVlZm5513ntv5OeaYY2K9OB3S+++/b//3f/9n11xzjQsMtLOcDJ0ftiZ1HPmLX/zCnnjiCUtLS4v14nRoOhj9/PPP3TpdtGiRPfzww3bttdfa5MmTY71o6KA7RVK/E2jd9x9rzjQdoZPi888/33Vo+v3vfz8yXh22z507113wQAHdo48+6sqqf//73xav1IG7ylIFbgo7dEJg6tSpduWVV0am0edS//Pyd3o7ymemHfV9993XXWAg2sUXX+wuEKCwSh2C6zMcP368O0HX3kpKStz3aty4cXbYYYc1OM3mzZtdSNPU76c507S3iRMn2oYNG+p8r1ryHHXW/vrrr7vQWCdSdWEB/c5uvfXWNlpyNPT772hlNraPAuNJkybZ9ddfn/Cd8Ot9/vznP7cbbrjBHdvqQk+J6sc//rFNmDDBjjzySEsGOkZ88skn3YlG7d/oeOfdd9+1q6++us3mSXAVJ7QTdPrpp7urJqm2UKIXZG1FBzk6KNDVtJTqH3/88e5AB82n8FS1GbTDpNprusqNzJgxw61XNN/YsWPrnEXVb/zwww+3p556itWI7eZf1VMnOaKVlpZGQubmTBPP1IWBTjjMmjXLnZ2NvrKgrh64++67R+6rJuPRRx8d17+n7OxsV8PKp9ot2olX2KaAzv/M6n9e/v2O8JkplPvPf/7TYG0rnX31P0OtC511X7JkSYNXWmzrq3l973vfc1cxe/bZZxs9odURf2N33HGH3Xfffe59DR48eIeeoysN6jflU60yfa7x/Bvr6Br6/XekMhvbZ8GCBXbccce57dd1112X8KtPx7QzZ850YbiOIbQfnIj+9a9/ueNPfbY6dtKg37Xe94cffmiJKDc3t87JRdUU1cn5p59+2u3LtQWCqzgJrc444wyXVKo6Zb9+/WK9SAlTdVE/qv/973+xXpQORZesVY0GbVA1qNmgqNngK6+8EuvF6/BULVxNaoDtNWjQIPe3/vdH9/3LLTdnmnilHR01qVMI8tZbb7lLKifi70nLrINSvzaFPrOGPi+J989MVCNHB9hqWrYtfrOY9vzMKioqXGilWnrax2qqaY7CNdV0aer305xp2suf//xn+9WvfuVq8R511FFt8pyO+BvrSPT737Rpk6sRGB20qjZcR/j9o/m++eYbV9tTg/atk6lFSOfOnV0I/uabb7oyOdFo/0XBjWqW+cdP+g1rm/PrX//akkWvXr3cCaLo7hBaE8FVjFVVVbm0UtXo33nnHTZSLaSDAP/sdfRZYLWzbagKNpo+O+KfLdDg9yHz4osv2mWXXcaq2w4qvOt/T7VOd9ttN9YjmkXNTP1ao927d3dNsVQTyacDnvfeey9yANqcaeKBymf9FtRfkL/Tp2ZlKmcUWo0aNWqbvyedzVTz8Hj6PWmbrvel2tMNLbPoZIpOEPjbJn0uCgY++eSTyDRaDzrxEk/NKvQ91PexoWaC2o/JycnZ5nbZP5HUXp+ZH1qploMOIPr27bvVNEuXLrVp06ZF7uvzePnll4QN4oUAAAnVSURBVCP39R3VSZvo309zpmlrd999t2vup232scceu9Xjao6p72J0fyPbek5D39c33ngjrn5jiUa1sIPBoAvsff/9739dWXLEEUfEdNnQehScK7A6+OCDXdif6C1rGipLFNypObJfazWR/OAHP6hz7KRBFVHOOeccF9YlouJG9m/69+/vgsq2kNImr4pm0xf61VdftYceesjtPGmQAQMGRM6cY9u0U6oz9WrmNnToUFu+fLlrkjBy5MiErZaK+Kfv3l577WUHHHCAO5uqgwYdbKsfNkD98C1cuDBS7qvfC30/1FzHr3mrs3eqXu8fWP/2t791TXl1Jl7fLTX5Ub9B2pb4mjNNW9J7UNMAv+aA3p924rQj4x8A68BM5bVCNY1X9XL1AXfvvfe6cZreP3unvuJENXr0fDUZ1Dzuueced3CuA/H2onBJv2V9durryF9ONQvW2fP8/Hw76KCD7LHHHnPN5P7617+6zmn1eeh96uD0kUcece/VP9uu5+pxvb9bbrnF9Qmlz121XDMyMtrlfek7pu2m3zR8+vTp7gBjl112iQRsF154oWtWFt1sTE0jvvzyS/ee6lO/fuqQXv1+6DutPjD0nvQ+1R9We1Cgpj43FK5peTSIfht+bRZ9FqqFpM9OdHZcfY1qn0IX1dBnqc9a31Ffc6ZpS3o/V111lesSQYGh/z3UbXWAL/pc9F1UuKt+vZrzHNXEUuCoPlpUi07NXxR66/eKtqEwVf2M6cSgyhYFGmpOfMkllzS76WdHo+2CykVRWe5vI1TmRDcHTxTaXii0UlmqMiO6qbRONKmT9kSj/icVyB566KGuubh/Ivz3v/99UtU0S2T33XefO6F1wgknuBNtOpnz+OOPu2C2rQR0acE2e3Vsk9rCamenPu3w6uwzmk+d3urqRdpZ08ZBO2rqiDUzM5PVuAN0AKOdcdXgSKarZLQG7YTqO6kDJ+2M6uBAO6hdunSJ9aIhDqjWgwL2+i6//PJIvwE33nij2+lVAOJTzRF9r1QNXcGUglDVtIrWnGnaimoPqfl7fbqyoX9VTZ2wUYihq9Fpp11nK9X3UX3qp1Ad2IoOqP3fk3Z8/d9Te5ZLjS2naonpQF/V47UT95vf/CbSV5BqT6kvIQVSChAVAO2xxx51nq+DN60bfW7aZunzb07Tu9bcAVUnq/WpU24deIgOuPr06eO+kz4FPuq/45lnnml0u/zAAw+45ud6rkIeXbGuvajGig6S69O+gQY/uFKfY/pO+hSy6bepA2oFpzoI00mxaM2Zpq0oONN3pT41r9WJUFHtOIWGWv8KA5rzHNWQ04GHao/pbLoeU3mUqAFKvNB6f/DBB91+lg7LVIYouErUWjmrV69usBzQtkonJBKNTuT89Kc/bfAxBco6yZ5oVAtVgb7KVdX61MkLXXkunmoRtzVtx7UNaqj/x0QxefJkty+r/Rv14an9hLasoUtwBQAAAAAAgLhEH1cAAAAAAACISwRXAAAAAAAAiEsEVwAAAAAAAIhLBFcAAAAAAACISwRXAAAAAAAAiEsEVwAAAAAAAIhLBFcAAAAAAACISwRXAAAAAAAksU2bNtlTTz1llZWVsV4UYCsEVwAAAAAAtIOioiIXEK1fv97d37Bhg7tfVVXVbuu/oXkuXLjQzjzzTCsuLm635QCai+AKAAAAAIB2sHr1ahcQffnll+7+ggUL3P2ysrJ2W/8NzbNr1652xhlnWFpaWrstB9BcKc2eEgAAAAAAtFrtqylTprjbzz33nKWnp9vgwYPtgAMOcONUK2v69OmWkZFhe++9t3Xp0iXy3LVr19pbb71lp59+us2aNcuWLFlihx56qGVnZ9uLL77opklNTbWhQ4fannvuaYFAoMl5jhw50saPH++eE23RokU2Z84cy8vLszFjxrjp6y+DAq8vvvjCvv32WxsxYoQbgNZEcAUAAAAAQDtTs7x3333X3X755ZctJSXFDjroIBdc3XvvvfarX/3KvvOd71hNTY3Nnj3b/va3v9mpp57qpp8/f76rNfX444/bihUrXFi0++67WzAYtBdeeMFNU15ebjNnzrSBAwfaa6+9Zjk5OY3OU3/1eurrqnPnzu7x6667zu655x4bO3asLV261EpKSuzVV1+1XXfdtc4y/Otf/7KVK1dajx497O2337bbbrvNrr32Wr5PaDUBz/O81ns5AAAAAADQkG+++cZ22mkne//9923cuHE2bdo0O/DAA23z5s3WqVMnN82HH35oxx13nHtsl112ceNUi+qcc85xNaDUrO+dd96xww47zAVEf/zjHxtd2RUVFXbwwQe717vhhhvcuIbmqYBLIZkfXCncOvzww+2DDz5w01ZXV9tpp53mallNnTrVPcdfhhtvvDHy2v/85z/tkksusfz8fJodotVQ4woAAAAAgDjxyCOPuBpU8+bNs88//9xU10SD+qRSs8CjjjoqMu2VV17Z4GuohpZqSZWWllr//v1txowZ27UM6rxdTQ8VWkkoFHI1sFQbTK+rWlw+BVU+PUfz1DTDhw9vwbsHtkZwBQAAAABAnFi8eLGr+fTss8/WGX/KKadYZmZmnXF9+vSpc3/dunUu2NLf0aNHW25uruuMfXs7XVefWeofK9qwYcMij0UHV6oB5vP7wGrPzuaR+AiuAAAAAACIEwqbVONKtZ62xe903XfnnXe68Ejhkvqtkp/97GeuWd/26N69u23cuLHOOP++HgPaU7Bd5wYAAAAAABy/j6noGkrHHnusvfnmm66mVDT1L1VZWdnkmlu9erWrGeWHVpr+pZde2uY861P/W1qGgoKCyLh///vf1rt370jNK6C9UOMKAAAAAIAYUHO8Ll26uCsIHnLIITZkyBD70Y9+ZJMnT3ZX87viiitcc8C5c+e6K/rNmTPHUlNTG329k08+2SZMmOA6gNfzHn30UddsULW4mpqnH3T5zj//fPvrX//q+qy68MILXafwf/7zn13/W9vb7BDYUdS4AgAAAACgHeTk5NgZZ5xhPXr0cPezsrJczSb1XfXyyy+7ztcVIun2/fffbytXrnQdq++8886uw3VNLz179nSvEwwGtwqudAXCNWvWuCsFXnzxxfbwww/bMcccE5mmoXmqnyq9nh9KaRnee+89F6LpKoSqnfX222/bWWedFXmdhpZBr6lxujIh0FoCni5PAAAAAAAAAMQZalwBAAAAAAAgLhFcAQAAAAAAIC4RXAEAAAAAACAuEVwBAAAAAAAgLhFcAQAAAAAAIC4RXAEAAAAAACAuEVwBAAAAAAAgLhFcAQAAAAAAIC4RXAEAAAAAACAuEVwBAAAAAAAgLhFcAQAAAAAAIC4RXAEAAAAAAMDi0f8DDObMCzVq4/8AAAAASUVORK5CYII=",
       "text/plain": [
        "<Figure size 1200x800 with 7 Axes>"
       ]
@@ -303,10 +359,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-28T10:05:53.840040Z",
+     "iopub.status.busy": "2026-09-28T10:05:53.838530Z",
+     "iopub.status.idle": "2026-09-28T10:05:53.849507Z",
+     "shell.execute_reply": "2026-09-28T10:05:53.849507Z"
     }
    },
    "outputs": [
@@ -349,17 +405,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 +426,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 +461,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-28T10:05:53.851015Z",
+     "iopub.status.busy": "2026-09-28T10:05:53.851015Z",
+     "iopub.status.idle": "2026-09-28T10:05:53.859523Z",
+     "shell.execute_reply": "2026-09-28T10:05:53.859523Z"
     }
    },
    "outputs": [
@@ -443,21 +499,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 +521,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 +558,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-28T10:05:53.861036Z",
+     "iopub.status.busy": "2026-09-28T10:05:53.861036Z",
+     "iopub.status.idle": "2026-09-28T10:05:53.996789Z",
+     "shell.execute_reply": "2026-09-28T10:05:53.996789Z"
     },
     "tags": [
      "thumbnail"
@@ -514,7 +570,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 +604,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-28T10:05:53.999503Z",
+     "iopub.status.busy": "2026-09-28T10:05:53.998971Z",
+     "iopub.status.idle": "2026-09-28T10:05:54.004777Z",
+     "shell.execute_reply": "2026-09-28T10:05:54.004251Z"
     }
    },
    "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"
       ]
      },

From 6b31a1262955812cd336bbe08b9b65245578edb0 Mon Sep 17 00:00:00 2001
From: Lenard Dome <23503601+lenarddome@users.noreply.github.com>
Date: Mon, 28 Sep 2026 12:09:51 +0200
Subject: [PATCH 13/34] docs: add a News section, with a post on faster fitting
 in cpm 0.26

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 docs/conf.py                        |   2 +-
 docs/index.md                       |   1 +
 docs/news/2026-09-faster-fitting.md | 219 ++++++++++++++++++++++++++++
 docs/news/index.md                  |  13 ++
 4 files changed, 234 insertions(+), 1 deletion(-)
 create mode 100644 docs/news/2026-09-faster-fitting.md
 create mode 100644 docs/news/index.md

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/index.md b/docs/index.md
index 62388fc..9c43e83 100644
--- a/docs/index.md
+++ b/docs/index.md
@@ -107,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..eba264e
--- /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 230 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, 13 to 25 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 bit-identical to cpm 0.25, and so are all their outputs: exports, dependent variables, states and seeded simulations, with and without numba.
+- 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..5e1f7cd
--- /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 230 times faster, with the same results. Hierarchical estimation also gets an important fix.
+
+```{toctree}
+:hidden:
+
+2026-09-faster-fitting
+```

From 8c61db8c64118be56ecbf04d4fdaeb20aced6443 Mon Sep 17 00:00:00 2001
From: Lenard Dome <23503601+lenarddome@users.noreply.github.com>
Date: Mon, 28 Sep 2026 13:33:41 +0200
Subject: [PATCH 14/34] fix(hierarchical): seed the starting priors of later
 chains, within both bounds

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 CHANGELOG.md                          |  1 +
 cpm/hierarchical/_chains.py           | 43 +++++++++++++++++
 cpm/hierarchical/empirical.py         | 13 ++---
 cpm/hierarchical/variational.py       | 13 ++---
 test/hierarchical/test_chains.py      | 68 +++++++++++++++++++++++++++
 test/hierarchical/test_empirical.py   | 10 ++++
 test/hierarchical/test_variational.py | 10 ++++
 7 files changed, 142 insertions(+), 16 deletions(-)
 create mode 100644 cpm/hierarchical/_chains.py
 create mode 100644 test/hierarchical/test_chains.py

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 62c38c3..c66f417 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -44,6 +44,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - 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 `cpm.optimisation.FminBound` raising `TypeError` on SciPy 1.18.0 and later
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 9eb1937..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) * self.__bounds__[1][i],
-                        "sd": rng.beta(a=2, b=2) * (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 9678748..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) * self.__bounds__[1][i],
-                        "sd": rng.beta(a=2, b=2) * (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/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):

From 9d275aab3d7e5b7868d5d36b3b978987c62b4820 Mon Sep 17 00:00:00 2001
From: Lenard Dome <23503601+lenarddome@users.noreply.github.com>
Date: Mon, 28 Sep 2026 13:33:42 +0200
Subject: [PATCH 15/34] docs(tutorials): point the hierarchical tutorials to
 RLRW, and re-run them

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 .../hierarchical-empirical-bayes.ipynb        | 160 ++++++++++--------
 .../hierarchical-variational-bayes.ipynb      |  88 +++++-----
 2 files changed, 134 insertions(+), 114 deletions(-)

diff --git a/docs/tutorials/hierarchical-empirical-bayes.ipynb b/docs/tutorials/hierarchical-empirical-bayes.ipynb
index b98bb73..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-28T09:57:35.673727Z",
-     "iopub.status.busy": "2026-09-28T09:57:35.673727Z",
-     "iopub.status.idle": "2026-09-28T09:57:37.318385Z",
-     "shell.execute_reply": "2026-09-28T09:57:37.318385Z"
+     "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": [
@@ -91,10 +91,10 @@
    "id": "b85995a7",
    "metadata": {
     "execution": {
-     "iopub.execute_input": "2026-09-28T09:57:37.320840Z",
-     "iopub.status.busy": "2026-09-28T09:57:37.320840Z",
-     "iopub.status.idle": "2026-09-28T09:57:40.359740Z",
-     "shell.execute_reply": "2026-09-28T09:57:40.359227Z"
+     "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-28T09:57:40.361748Z",
-     "iopub.status.busy": "2026-09-28T09:57:40.360748Z",
-     "iopub.status.idle": "2026-09-28T09:57:58.072108Z",
-     "shell.execute_reply": "2026-09-28T09:57:58.071592Z"
+     "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-28T09:57:58.074689Z",
-     "iopub.status.busy": "2026-09-28T09:57:58.074689Z",
-     "iopub.status.idle": "2026-09-28T10:01:42.755953Z",
-     "shell.execute_reply": "2026-09-28T10:01:42.754945Z"
+     "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": [
@@ -368,42 +378,42 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Iteration: 1, LME: -2143.736725126121. \n"
+      "Iteration: 1, LME: -2171.7025418727876. \n"
      ]
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Iteration: 2, LME: -2122.6267536873347. \n"
+      "Iteration: 2, LME: -2119.56153566882. \n"
      ]
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Iteration: 3, LME: -2118.975955557839. \n"
+      "Iteration: 3, LME: -2116.510826937048. \n"
      ]
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Iteration: 4, LME: -2117.441897597485. \n"
+      "Iteration: 4, LME: -2115.9283152971693. \n"
      ]
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Iteration: 5, LME: -2116.4985554579416. \n"
+      "Iteration: 5, LME: -2120.4912998972068. \n"
      ]
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Iteration: 6, LME: -2115.8769881909275. \n"
+      "Iteration: 6, LME: -2116.096626634608. \n"
      ]
     }
    ],
@@ -445,16 +455,16 @@
    "id": "45063e29",
    "metadata": {
     "execution": {
-     "iopub.execute_input": "2026-09-28T10:01:42.757953Z",
-     "iopub.status.busy": "2026-09-28T10:01:42.756953Z",
-     "iopub.status.idle": "2026-09-28T10:01:43.356924Z",
-     "shell.execute_reply": "2026-09-28T10:01:43.355916Z"
+     "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>"
       ]
@@ -481,10 +491,10 @@
    "id": "1e510420",
    "metadata": {
     "execution": {
-     "iopub.execute_input": "2026-09-28T10:01:43.357924Z",
-     "iopub.status.busy": "2026-09-28T10:01:43.357924Z",
-     "iopub.status.idle": "2026-09-28T10:01:43.365944Z",
-     "shell.execute_reply": "2026-09-28T10:01:43.365437Z"
+     "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": [
@@ -525,15 +535,15 @@
        "  <tbody>\n",
        "    <tr>\n",
        "      <th>alpha</th>\n",
-       "      <td>0.53</td>\n",
-       "      <td>0.10</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.14</td>\n",
-       "      <td>0.92</td>\n",
+       "      <td>2.16</td>\n",
+       "      <td>0.95</td>\n",
        "      <td>2.0</td>\n",
        "      <td>1.0</td>\n",
        "    </tr>\n",
@@ -544,8 +554,8 @@
       "text/plain": [
        "             mean    sd  true mean  true sd\n",
        "parameter                                  \n",
-       "alpha        0.53  0.10        0.6      0.2\n",
-       "temperature  2.14  0.92        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,
@@ -577,10 +587,10 @@
    "id": "47d5fbd2",
    "metadata": {
     "execution": {
-     "iopub.execute_input": "2026-09-28T10:01:43.366949Z",
-     "iopub.status.busy": "2026-09-28T10:01:43.366949Z",
-     "iopub.status.idle": "2026-09-28T10:01:43.375195Z",
-     "shell.execute_reply": "2026-09-28T10:01:43.375195Z"
+     "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": [
@@ -617,38 +627,38 @@
        "    </tr>\n",
        "    <tr>\n",
        "      <th>mean</th>\n",
-       "      <td>0.533227</td>\n",
-       "      <td>2.144847</td>\n",
+       "      <td>0.579994</td>\n",
+       "      <td>2.157246</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>std</th>\n",
-       "      <td>0.044128</td>\n",
-       "      <td>0.757282</td>\n",
+       "      <td>0.134918</td>\n",
+       "      <td>0.759992</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>min</th>\n",
-       "      <td>0.432360</td>\n",
-       "      <td>0.850733</td>\n",
+       "      <td>0.118010</td>\n",
+       "      <td>0.797288</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>25%</th>\n",
-       "      <td>0.500097</td>\n",
-       "      <td>1.432731</td>\n",
+       "      <td>0.497941</td>\n",
+       "      <td>1.472777</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>50%</th>\n",
-       "      <td>0.542153</td>\n",
-       "      <td>2.217574</td>\n",
+       "      <td>0.606694</td>\n",
+       "      <td>2.178590</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>75%</th>\n",
-       "      <td>0.563997</td>\n",
-       "      <td>2.817876</td>\n",
+       "      <td>0.685379</td>\n",
+       "      <td>2.795440</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>max</th>\n",
-       "      <td>0.616313</td>\n",
-       "      <td>3.422121</td>\n",
+       "      <td>0.844977</td>\n",
+       "      <td>3.431649</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
        "</table>\n",
@@ -657,13 +667,13 @@
       "text/plain": [
        "           alpha  temperature\n",
        "count  50.000000    50.000000\n",
-       "mean    0.533227     2.144847\n",
-       "std     0.044128     0.757282\n",
-       "min     0.432360     0.850733\n",
-       "25%     0.500097     1.432731\n",
-       "50%     0.542153     2.217574\n",
-       "75%     0.563997     2.817876\n",
-       "max     0.616313     3.422121"
+       "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,
@@ -697,10 +707,10 @@
    "id": "8a060492",
    "metadata": {
     "execution": {
-     "iopub.execute_input": "2026-09-28T10:01:43.377203Z",
-     "iopub.status.busy": "2026-09-28T10:01:43.377203Z",
-     "iopub.status.idle": "2026-09-28T10:01:43.515477Z",
-     "shell.execute_reply": "2026-09-28T10:01:43.515477Z"
+     "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"
@@ -709,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>"
       ]
@@ -740,10 +750,10 @@
    "id": "28fb73fe",
    "metadata": {
     "execution": {
-     "iopub.execute_input": "2026-09-28T10:01:43.517485Z",
-     "iopub.status.busy": "2026-09-28T10:01:43.517485Z",
-     "iopub.status.idle": "2026-09-28T10:01:43.523505Z",
-     "shell.execute_reply": "2026-09-28T10:01:43.523505Z"
+     "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": [
@@ -781,12 +791,12 @@
        "    <tr>\n",
        "      <th>alpha</th>\n",
        "      <td>0.213</td>\n",
-       "      <td>0.146</td>\n",
+       "      <td>0.125</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>temperature</th>\n",
        "      <td>0.969</td>\n",
-       "      <td>0.450</td>\n",
+       "      <td>0.489</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
        "</table>\n",
@@ -795,8 +805,8 @@
       "text/plain": [
        "                     separate fits  empirical Bayes\n",
        "mean absolute error                                \n",
-       "alpha                        0.213            0.146\n",
-       "temperature                  0.969            0.450"
+       "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 b85125c..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-28T10:01:44.723076Z",
-     "iopub.status.busy": "2026-09-28T10:01:44.723076Z",
-     "iopub.status.idle": "2026-09-28T10:01:46.359981Z",
-     "shell.execute_reply": "2026-09-28T10:01:46.359981Z"
+     "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": [
@@ -88,10 +88,10 @@
    "id": "78831d24",
    "metadata": {
     "execution": {
-     "iopub.execute_input": "2026-09-28T10:01:46.361988Z",
-     "iopub.status.busy": "2026-09-28T10:01:46.361988Z",
-     "iopub.status.idle": "2026-09-28T10:01:49.445743Z",
-     "shell.execute_reply": "2026-09-28T10:01:49.444736Z"
+     "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-28T10:01:49.447743Z",
-     "iopub.status.busy": "2026-09-28T10:01:49.447743Z",
-     "iopub.status.idle": "2026-09-28T10:05:53.241104Z",
-     "shell.execute_reply": "2026-09-28T10:05:53.240601Z"
+     "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": [
@@ -231,42 +241,42 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Iteration: 2, LME: -2271.0170015037593\n"
+      "Iteration: 2, LME: -2167.6694320261067\n"
      ]
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Iteration: 3, LME: -2196.3439009039193\n"
+      "Iteration: 3, LME: -2135.3989797647705\n"
      ]
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Iteration: 4, LME: -2156.4774257583167\n"
+      "Iteration: 4, LME: -2123.04316296454\n"
      ]
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Iteration: 5, LME: -2132.425635132036\n"
+      "Iteration: 5, LME: -2119.945351761445\n"
      ]
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Iteration: 6, LME: -2123.035793430094\n"
+      "Iteration: 6, LME: -2118.9763922575758\n"
      ]
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Iteration: 7, LME: -2120.062812336691\n"
+      "Iteration: 7, LME: -2120.463474736944\n"
      ]
     }
    ],
@@ -320,16 +330,16 @@
    "id": "c9d283c9",
    "metadata": {
     "execution": {
-     "iopub.execute_input": "2026-09-28T10:05:53.243116Z",
-     "iopub.status.busy": "2026-09-28T10:05:53.243116Z",
-     "iopub.status.idle": "2026-09-28T10:05:53.837526Z",
-     "shell.execute_reply": "2026-09-28T10:05:53.837017Z"
+     "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>"
       ]
@@ -359,10 +369,10 @@
    "id": "e8fe3579",
    "metadata": {
     "execution": {
-     "iopub.execute_input": "2026-09-28T10:05:53.840040Z",
-     "iopub.status.busy": "2026-09-28T10:05:53.838530Z",
-     "iopub.status.idle": "2026-09-28T10:05:53.849507Z",
-     "shell.execute_reply": "2026-09-28T10:05:53.849507Z"
+     "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": [
@@ -461,10 +471,10 @@
    "id": "072aac7f",
    "metadata": {
     "execution": {
-     "iopub.execute_input": "2026-09-28T10:05:53.851015Z",
-     "iopub.status.busy": "2026-09-28T10:05:53.851015Z",
-     "iopub.status.idle": "2026-09-28T10:05:53.859523Z",
-     "shell.execute_reply": "2026-09-28T10:05:53.859523Z"
+     "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": [
@@ -558,10 +568,10 @@
    "id": "3a59fc01",
    "metadata": {
     "execution": {
-     "iopub.execute_input": "2026-09-28T10:05:53.861036Z",
-     "iopub.status.busy": "2026-09-28T10:05:53.861036Z",
-     "iopub.status.idle": "2026-09-28T10:05:53.996789Z",
-     "shell.execute_reply": "2026-09-28T10:05:53.996789Z"
+     "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"
@@ -604,10 +614,10 @@
    "id": "24b6fccc",
    "metadata": {
     "execution": {
-     "iopub.execute_input": "2026-09-28T10:05:53.999503Z",
-     "iopub.status.busy": "2026-09-28T10:05:53.998971Z",
-     "iopub.status.idle": "2026-09-28T10:05:54.004777Z",
-     "shell.execute_reply": "2026-09-28T10:05:54.004251Z"
+     "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": [

From 63ba29de44b4b464e8c21d50e671f54738449243 Mon Sep 17 00:00:00 2001
From: Lenard Dome <23503601+lenarddome@users.noreply.github.com>
Date: Mon, 28 Sep 2026 14:28:55 +0200
Subject: [PATCH 16/34] docs: add a how-to guide on speeding up your own model

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 CHANGELOG.md                            |   1 +
 cpm/generators/session.py               |   4 +
 docs/how-to/index.md                    |   8 +
 docs/how-to/speed-up-your-model.md      | 196 ++++++++++++++++++++++++
 test/generators/test_speed_up_how_to.py |  84 ++++++++++
 5 files changed, 293 insertions(+)
 create mode 100644 docs/how-to/speed-up-your-model.md
 create mode 100644 test/generators/test_speed_up_how_to.py

diff --git a/CHANGELOG.md b/CHANGELOG.md
index c66f417..aa2c27a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -22,6 +22,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - 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
 
diff --git a/cpm/generators/session.py b/cpm/generators/session.py
index 5ac9961..8331be1 100644
--- a/cpm/generators/session.py
+++ b/cpm/generators/session.py
@@ -95,6 +95,10 @@ class SessionWrapper(Wrapper):
     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
diff --git a/docs/how-to/index.md b/docs/how-to/index.md
index 0586bc0..b3911e5 100644
--- a/docs/how-to/index.md
+++ b/docs/how-to/index.md
@@ -12,6 +12,13 @@ Short, task-focused recipes for problems you will meet once you have learned the
 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
@@ -31,6 +38,7 @@ Split participants across the nodes of a SLURM cluster with a job array, then co
 :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/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)

From fd56207049def3c070d010814551e6490cd05c13 Mon Sep 17 00:00:00 2001
From: Lenard Dome <23503601+lenarddome@users.noreply.github.com>
Date: Mon, 28 Sep 2026 14:41:04 +0200
Subject: [PATCH 17/34] docs(numba): correct the caching and debugging advice

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 docs/how-to/fast-session-models.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/how-to/fast-session-models.md b/docs/how-to/fast-session-models.md
index 6fc6bee..6b68ce4 100644
--- a/docs/how-to/fast-session-models.md
+++ b/docs/how-to/fast-session-models.md
@@ -108,11 +108,11 @@ def model(parameters, data):
     return {"p_right": p_right, "dependent": p_right}
 ```
 
-In a script or module, `@njit(cache=True)` keeps the compiled code on disk between Python sessions (not in an interactive session, where there is no file to cache it for).
+`@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` (or cpm's own `CPM_DISABLE_JIT=1`) before starting Python to run all compiled functions as plain Python, where you can use a debugger and `print` and get ordinary tracebacks. 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.
+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.

From 832a2fff0405031d7b5e78259042dadf27ecf2ad Mon Sep 17 00:00:00 2001
From: Lenard Dome <23503601+lenarddome@users.noreply.github.com>
Date: Tue, 29 Sep 2026 12:57:49 +0200
Subject: [PATCH 18/34] fix(applications): check indices and activations in the
 compiled loops

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 cpm/applications/_sessions.py      | 30 ++++++++++++++++++++++++++
 test/applications/test_backends.py | 34 ++++++++++++++++++++++++++++++
 2 files changed, 64 insertions(+)

diff --git a/cpm/applications/_sessions.py b/cpm/applications/_sessions.py
index 326bbe7..9208a32 100644
--- a/cpm/applications/_sessions.py
+++ b/cpm/applications/_sessions.py
@@ -32,6 +32,17 @@
 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.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):
     """
@@ -59,6 +70,10 @@ def rlrw(alpha, temperature, initial_values, arms, rewards, response, generate,
     """
     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)
@@ -69,9 +84,14 @@ def rlrw(alpha, temperature, initial_values, arms, rewards, response, generate,
     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
@@ -119,6 +139,9 @@ def hybrid_mbmf(inv_temperature, learning_rate, eligibility_trace, mb_weight,
     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):
@@ -129,6 +152,7 @@ def hybrid_mbmf(inv_temperature, learning_rate, eligibility_trace, mb_weight,
                 + 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])
@@ -140,6 +164,8 @@ def hybrid_mbmf(inv_temperature, learning_rate, eligibility_trace, mb_weight,
             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
@@ -219,7 +245,11 @@ def prospect_softmax(alpha, beta, lambda_loss, gamma, delta, temperature, safe,
         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:
diff --git a/test/applications/test_backends.py b/test/applications/test_backends.py
index d8af82c..e8069f8 100644
--- a/test/applications/test_backends.py
+++ b/test/applications/test_backends.py
@@ -237,6 +237,40 @@ def test_missing_columns_are_reported_when_the_model_runs():
         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()

From 03ffcf0b9bbaf253c332ab20b21bd5c638785373 Mon Sep 17 00:00:00 2001
From: Lenard Dome <23503601+lenarddome@users.noreply.github.com>
Date: Tue, 29 Sep 2026 12:57:50 +0200
Subject: [PATCH 19/34] fix(generators): pickling and invalid priors, and
 SessionWrapper and reset fixes

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 cpm/applications/_backend.py            | 45 +----------------
 cpm/core/data.py                        | 10 ++--
 cpm/generators/_fast_priors.py          |  8 ++-
 cpm/generators/session.py               | 65 +++++++++++++++++++++----
 cpm/generators/wrapper.py               |  8 ++-
 test/generators/test_fast_priors.py     | 37 +++++++++++++-
 test/generators/test_session_wrapper.py | 50 +++++++++++++++++++
 test/generators/test_wrapper.py         |  2 +
 8 files changed, 164 insertions(+), 61 deletions(-)

diff --git a/cpm/applications/_backend.py b/cpm/applications/_backend.py
index 924641d..4e6420a 100644
--- a/cpm/applications/_backend.py
+++ b/cpm/applications/_backend.py
@@ -19,7 +19,7 @@
 import pandas as pd
 
 from ..core import _jit
-from ..generators.session import SessionWrapper, session_data
+from ..generators.session import SessionWrapper, session_data, trial_view
 
 __all__ = ["Application", "SessionModel", "TrialModel", "require", "uniforms"]
 
@@ -52,33 +52,6 @@ def sessions(self):
         return _jit.kernels("cpm.applications._sessions", python=self.backend == "python")
 
 
-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 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()
@@ -119,8 +92,6 @@ class Application(SessionWrapper):
     outputs whose per-trial value is not simply a row of the session output.
     """
 
-    _trial_shapes = {}
-
     def _setup(self, data, parameters, session_model, prepare):
         super().__init__(model=session_model, data=data, parameters=parameters, prepare=prepare)
         self._session_model = session_model
@@ -129,20 +100,6 @@ def _setup(self, data, parameters, session_model, prepare):
     def _run_session(self):
         return self._session_model(parameters=self.parameters, data=self.session)
 
-    @property
-    def simulation(self):
-        """The outputs of each trial of the last run, as a list of dictionaries."""
-        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 require(data, columns, model):
     """Raise a helpful error if the prepared data lack any of `columns`."""
diff --git a/cpm/core/data.py b/cpm/core/data.py
index 1e8488a..0d25128 100644
--- a/cpm/core/data.py
+++ b/cpm/core/data.py
@@ -46,8 +46,8 @@ 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 and boolean
-    columns, the reader converts the data to a numpy array once and builds each row
+    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
@@ -70,8 +70,10 @@ def trial_reader(data, pandas=True):
         plain = all(
             isinstance(dtype, np.dtype) and dtype.kind in "biuf" for dtype in dtypes
         )
-        if plain and data.shape[1] > 0:
-            values = data.to_numpy(copy=True)
+        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
diff --git a/cpm/generators/_fast_priors.py b/cpm/generators/_fast_priors.py
index c4a52b5..41e8aa0 100644
--- a/cpm/generators/_fast_priors.py
+++ b/cpm/generators/_fast_priors.py
@@ -13,7 +13,7 @@
 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 parameters, points
+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.
 """
@@ -98,6 +98,10 @@ def valid(self, prior):
         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:
@@ -130,6 +134,8 @@ def _evaluator(prior):
         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
diff --git a/cpm/generators/session.py b/cpm/generators/session.py
index 8331be1..af0d7c6 100644
--- a/cpm/generators/session.py
+++ b/cpm/generators/session.py
@@ -22,17 +22,17 @@ def session_data(data):
     Returns
     -------
     dict
-        One C-contiguous numpy array per column or entry, with the trials along
-        the first axis.
+        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.ascontiguousarray(data[column].to_numpy())
+            column: np.array(data[column].to_numpy(), order="C")
             for column in data.columns
         }
     if isinstance(data, dict):
         return {
-            key: np.ascontiguousarray(np.asarray(value))
+            key: np.array(value, order="C")
             for key, value in data.items()
             if key != "ppt"
         }
@@ -41,6 +41,33 @@ def session_data(data):
     )
 
 
+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.
@@ -113,8 +140,8 @@ class SessionWrapper(Wrapper):
         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 new data are
-        set with `reset`), not on every run. The default is :func:`session_data`,
+        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
@@ -135,7 +162,9 @@ class SessionWrapper(Wrapper):
 
     `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.
+    `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
     --------
@@ -163,6 +192,9 @@ class SessionWrapper(Wrapper):
     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)
@@ -179,8 +211,22 @@ def session(self):
             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; subclasses can compute the run differently."""
+        """Call the model function on all trials."""
         return self.model(parameters=self.parameters, data=self.session)
 
     def run(self):
@@ -244,7 +290,8 @@ def reset(self, parameters=None, data=None):
         if was_run:
             self.simulation = {}
             self.session_output = {}
-        if data is not None:
+        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
 
diff --git a/cpm/generators/wrapper.py b/cpm/generators/wrapper.py
index ed725c1..0f0016a 100644
--- a/cpm/generators/wrapper.py
+++ b/cpm/generators/wrapper.py
@@ -51,7 +51,10 @@ def restore_parameters(initial, current):
             restored[key] = new
         else:
             restored[key] = copy.deepcopy(value)
-    return type(current)(**restored) if type(current) is Parameters else copy.deepcopy(initial)
+    ## 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:
@@ -189,7 +192,8 @@ 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 = restore_parameters(
                 self.__init_parameters__, self.parameters
diff --git a/test/generators/test_fast_priors.py b/test/generators/test_fast_priors.py
index 782ce21..c7df8fa 100644
--- a/test/generators/test_fast_priors.py
+++ b/test/generators/test_fast_priors.py
@@ -1,4 +1,5 @@
 import copy
+import pickle
 import warnings
 
 import numpy as np
@@ -6,7 +7,7 @@
 import pytest
 from scipy import stats
 
-from cpm.generators import Parameters, Value, Wrapper
+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)
@@ -80,6 +81,24 @@ def test_other_priors_and_values_fall_back_to_scipy():
     )
 
 
+@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})
@@ -153,6 +172,22 @@ def test_reset_keeps_updated_priors():
     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
diff --git a/test/generators/test_session_wrapper.py b/test/generators/test_session_wrapper.py
index 0a1c107..4533dcb 100644
--- a/test/generators/test_session_wrapper.py
+++ b/test/generators/test_session_wrapper.py
@@ -168,6 +168,56 @@ def test_wrong_number_of_rows_is_an_error(one):
         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")
diff --git a/test/generators/test_wrapper.py b/test/generators/test_wrapper.py
index e91bd36..43f2d41 100644
--- a/test/generators/test_wrapper.py
+++ b/test/generators/test_wrapper.py
@@ -133,6 +133,8 @@ def test_trial_reader_gives_the_rows_iloc_gives(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
 

From ee689cd8c5dd33f3e904a0b30f293112a3445990 Mon Sep 17 00:00:00 2001
From: Lenard Dome <23503601+lenarddome@users.noreply.github.com>
Date: Tue, 29 Sep 2026 12:57:50 +0200
Subject: [PATCH 20/34] fix(jit): fall back to plain Python or no caching when
 numba cannot be used

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 CONTRIBUTING.md                    |  2 ++
 cpm/core/_jit.py                   | 33 ++++++++++++++++-------
 scripts/local_tests.py             |  7 +++++
 test/applications/test_backends.py | 43 ++++++++++++++++++++++++++++++
 4 files changed, 75 insertions(+), 10 deletions(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 5e44e53..d8b1c6a 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -91,6 +91,8 @@ 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/cpm/core/_jit.py b/cpm/core/_jit.py
index a1c7f50..4bbffcd 100644
--- a/cpm/core/_jit.py
+++ b/cpm/core/_jit.py
@@ -25,6 +25,7 @@
 import importlib.util
 import os
 import sys
+import warnings
 
 __all__ = ["HAVE_NUMBA", "JIT_ENABLED", "njit", "kernels", "resolve_backend"]
 
@@ -37,14 +38,19 @@
 def _probe():
     """Import numba, once, and record whether compiled kernels are available."""
     if not _STATE:
-        try:
-            if os.environ.get("CPM_DISABLE_JIT", "0") not in ("", "0"):
-                raise ImportError("compilation disabled with CPM_DISABLE_JIT")
-            import numba
-
-            _STATE["numba"], have = numba, True
-        except ImportError:  # includes numba installs that reject the installed NumPy
-            _STATE["numba"], have = None, False
+        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")
@@ -73,7 +79,13 @@ def njit(*args, **kwargs):
     if not _flag("HAVE_NUMBA"):
         return _identity(*args, **kwargs)
     kwargs.setdefault("cache", True)
-    return _probe()["numba"].njit(*args, **kwargs)
+    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):
@@ -111,7 +123,8 @@ def kernels(name, python=False):
         module.__package__ = name.rpartition(".")[0]
         setattr(module, PYTHON_FLAG, True)
         sys.modules[copy_name] = module
-        copy_spec.loader.exec_module(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]
 
diff --git a/scripts/local_tests.py b/scripts/local_tests.py
index 627628a..8c1c06e 100644
--- a/scripts/local_tests.py
+++ b/scripts/local_tests.py
@@ -18,6 +18,10 @@
 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.
 """
 
@@ -44,6 +48,9 @@ def main():
     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(
diff --git a/test/applications/test_backends.py b/test/applications/test_backends.py
index e8069f8..ac15a01 100644
--- a/test/applications/test_backends.py
+++ b/test/applications/test_backends.py
@@ -11,11 +11,16 @@
 `model` function, and a seeded simulation with `Simulator`.
 """
 
+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
@@ -227,6 +232,44 @@ def test_numba_is_used_when_installed(monkeypatch):
     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)

From dcb3b93114ff1632405018d27ecadfd2c418454e Mon Sep 17 00:00:00 2001
From: Lenard Dome <23503601+lenarddome@users.noreply.github.com>
Date: Tue, 29 Sep 2026 12:57:50 +0200
Subject: [PATCH 21/34] chore: fix the wheel tag, Python requirement and
 classifiers; drop unused imports

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 cpm/applications/decision_making.py        | 2 +-
 cpm/applications/reinforcement_learning.py | 2 +-
 pyproject.toml                             | 5 ++---
 setup.cfg                                  | 2 --
 4 files changed, 4 insertions(+), 7 deletions(-)
 delete mode 100644 setup.cfg

diff --git a/cpm/applications/decision_making.py b/cpm/applications/decision_making.py
index 0c9546d..e6ca0a6 100644
--- a/cpm/applications/decision_making.py
+++ b/cpm/applications/decision_making.py
@@ -1,6 +1,6 @@
 import numpy as np
 import warnings
-from cpm.generators import Wrapper, Parameters, Value
+from cpm.generators import Parameters, Value
 from cpm.core import _jit
 from cpm.applications._backend import Application, SessionModel, prepared, require, uniforms
 
diff --git a/cpm/applications/reinforcement_learning.py b/cpm/applications/reinforcement_learning.py
index cf3f134..26278d0 100644
--- a/cpm/applications/reinforcement_learning.py
+++ b/cpm/applications/reinforcement_learning.py
@@ -1,7 +1,7 @@
 import numpy
 import warnings
 
-from cpm.generators import Wrapper, Parameters, Value
+from cpm.generators import Parameters, Value
 from cpm.applications._backend import (
     Application, SessionModel, ordered_columns, prepared, require, uniforms,
 )
diff --git a/pyproject.toml b/pyproject.toml
index 5aca4df..5ee9e85 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -21,15 +21,14 @@ 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",
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

From 18b44bba823c338bd42ea5287971d71964ddb42d Mon Sep 17 00:00:00 2001
From: Lenard Dome <23503601+lenarddome@users.noreply.github.com>
Date: Tue, 29 Sep 2026 13:36:20 +0200
Subject: [PATCH 22/34] ci: run the tests on Python 3.11-3.14, with and without
 numba

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .github/workflows/tests.yml | 97 +++++++++++++++++++++++++++++++++++++
 1 file changed, 97 insertions(+)
 create mode 100644 .github/workflows/tests.yml

diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
new file mode 100644
index 0000000..15fff69
--- /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@v6
+        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@v6
+        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@v6
+        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

From a1a3e411105de96d3759632a7d5952da983983ce Mon Sep 17 00:00:00 2001
From: Lenard Dome <23503601+lenarddome@users.noreply.github.com>
Date: Tue, 29 Sep 2026 13:36:20 +0200
Subject: [PATCH 23/34] docs(changelog): note that Wrapper.reset keeps the
 current priors

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 CHANGELOG.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index aa2c27a..8af0740 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -34,6 +34,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - 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-230 times faster with numba, 13-25 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

From 897f97f0bf9dd70451fe1005825f1df06dde9d73 Mon Sep 17 00:00:00 2001
From: Lenard Dome <23503601+lenarddome@users.noreply.github.com>
Date: Tue, 29 Sep 2026 13:36:20 +0200
Subject: [PATCH 24/34] chore(benchmarks): remove results that nothing reads

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 benchmarks/results/main.csv               |  6 ------
 benchmarks/results/one-implementation.csv | 16 ----------------
 benchmarks/results/per-trial.csv          | 16 ----------------
 benchmarks/results/phase0.csv             |  6 ------
 benchmarks/results/phase2.csv             | 16 ----------------
 benchmarks/results/single-kernels.csv     | 16 ----------------
 6 files changed, 76 deletions(-)
 delete mode 100644 benchmarks/results/main.csv
 delete mode 100644 benchmarks/results/one-implementation.csv
 delete mode 100644 benchmarks/results/per-trial.csv
 delete mode 100644 benchmarks/results/phase0.csv
 delete mode 100644 benchmarks/results/phase2.csv
 delete mode 100644 benchmarks/results/single-kernels.csv

diff --git a/benchmarks/results/main.csv b/benchmarks/results/main.csv
deleted file mode 100644
index 2ec3a77..0000000
--- a/benchmarks/results/main.csv
+++ /dev/null
@@ -1,6 +0,0 @@
-case,backend,trials,parameters,objective_ms,reset_ms,prior_ms,run_ms,loss_ms,log_posterior,speed_up
-RLRW,trial,71,2,8.6474500130862,0.42120006401091814,0.08180004078894854,7.56499997805804,0.04610000178217888,-26.034401210112605,1.0
-HybridMBMF,trial,200,6,25.437099975533783,0.8433500188402832,0.24389999452978373,23.479699972085655,0.05304999649524689,-151.7819350468299,1.0
-PTSM,trial,40,4,6.54054997721687,0.6358500104397535,0.15730003360658884,5.147499963641167,0.04579999949783087,-36.42346848683204,1.0
-PTSM1992,trial,40,6,7.78515002457425,0.8213000255636871,0.22419996093958616,6.095800083130598,0.04350004019215703,-39.43873213610623,1.0
-PTSM2025,trial,40,5,75.79680002527311,0.6942999898456037,0.19024999346584082,74.84180002938956,0.04529999569058418,-33.01065168146936,1.0
diff --git a/benchmarks/results/one-implementation.csv b/benchmarks/results/one-implementation.csv
deleted file mode 100644
index 91b6803..0000000
--- a/benchmarks/results/one-implementation.csv
+++ /dev/null
@@ -1,16 +0,0 @@
-case,backend,trials,parameters,objective_ms,reset_ms,prior_ms,run_ms,loss_ms,log_posterior,speed_up
-RLRW,trial,71,2,3.5462499945424497,0.004899920895695686,0.004799920134246349,3.534849965944886,0.02019992098212242,-26.034401210112605,1.0
-RLRW,python,71,2,0.4120499943383038,0.004700035788118839,0.004100031219422817,0.36609999369829893,0.03390002530068159,-26.034401210112605,8.60635855665341
-RLRW,numba,71,2,0.05650008097290993,0.005200039595365524,0.004400033503770828,0.011400086805224419,0.01750001683831215,-26.034401210112605,62.765396676913944
-HybridMBMF,trial,200,6,10.832400002982467,0.012500095181167126,0.00870006624609232,10.568150028120726,0.021600048057734966,-151.7819350468299,1.0
-HybridMBMF,python,200,6,1.4124999870546162,0.012299977242946625,0.00870006624609232,1.4587999903596938,0.02234999556094408,-151.7819350468299,7.66895582460888
-HybridMBMF,numba,200,6,0.09350001346319914,0.01309998333454132,0.009199953638017178,0.03125000512227416,0.02150004729628563,-151.7819350468299,115.85452880438369
-PTSM,trial,40,4,1.9270499469712377,0.007900060154497623,0.006900052540004253,1.8142999615520239,0.019300030544400215,-36.42346848683204,1.0
-PTSM,python,40,4,0.22014998830854893,0.008299946784973145,0.0069999368861317635,0.20319997565820813,0.022099993657320738,-36.42346848683204,8.753350212630494
-PTSM,numba,40,4,0.06430002395063639,0.008299946784973145,0.006900052540004253,0.013000040780752897,0.019200029782950878,-36.42346848683204,29.969661418021374
-PTSM1992,trial,40,6,1.969299977645278,0.0097999582067132,0.008399947546422482,1.8565500504337251,0.019399914890527725,-39.43873213610623,1.0
-PTSM1992,python,40,6,0.26510003954172134,0.009999959729611874,0.008500064723193645,0.20109995966777205,0.018299906514585018,-39.43873213610623,7.42851634820428
-PTSM1992,numba,40,6,0.07379997987300158,0.010200077667832375,0.008699949830770493,0.017000013031065464,0.019300030544400215,-39.43873213610623,26.68428881734305
-PTSM2025,trial,40,5,1.7644499894231558,0.008599949069321156,0.007999944500625134,1.6838500159792602,0.01850002445280552,-33.01065168146936,1.0
-PTSM2025,python,40,5,0.15740003436803818,0.00879995059221983,0.00800006091594696,0.10269996710121632,0.016700010746717453,-33.01065168146936,11.209972072162692
-PTSM2025,numba,40,5,0.06005004979670048,0.008800067007541656,0.007900060154497623,0.010299962013959885,0.018000020645558834,-33.01065168146936,29.382989612776402
diff --git a/benchmarks/results/per-trial.csv b/benchmarks/results/per-trial.csv
deleted file mode 100644
index 4ef8741..0000000
--- a/benchmarks/results/per-trial.csv
+++ /dev/null
@@ -1,16 +0,0 @@
-case,backend,trials,parameters,objective_ms,reset_ms,prior_ms,run_ms,loss_ms,log_posterior,speed_up
-RLRW,trial,71,2,3.47880000481382,0.004200031980872154,0.003500026650726795,3.418999956920743,0.019600032828748226,-26.034401210112605,1.0
-RLRW,python,71,2,0.41675003012642264,0.00500003807246685,0.00409991480410099,0.35879993811249733,0.021200045011937618,-26.034401210112605,8.347449918020434
-RLRW,numba,71,2,0.04700000863522291,0.005100038833916187,0.004100031219422817,0.01170008908957243,0.02010003663599491,-26.034401210112605,74.01700778000976
-HybridMBMF,trial,200,6,10.28014998883009,0.01170008908957243,0.006800051778554916,10.141300037503242,0.021700048819184303,-151.7819350468299,1.0
-HybridMBMF,python,200,6,1.3584000407718122,0.012200092896819115,0.00700005330145359,1.322799944318831,0.021600048057734966,-151.7819350468299,7.567836925997986
-HybridMBMF,numba,200,6,0.08459994569420815,0.01209997572004795,0.00700005330145359,0.029199989512562752,0.02159993164241314,-151.7819350468299,121.5148532835747
-PTSM,trial,40,4,2.043900021817535,0.007850001566112041,0.00900006853044033,2.0222999155521393,0.019400031305849552,-36.42346848683204,1.0
-PTSM,python,40,4,0.21490000654011965,0.006900052540004253,0.005400041118264198,0.16300007700920105,0.020799983758479357,-36.423468486832036,9.51093513082774
-PTSM,numba,40,4,0.059699988923966885,0.007899943739175797,0.005699926987290382,0.012299977242946625,0.019400031305849552,-36.423468486832036,34.23618762175349
-PTSM1992,trial,40,6,2.584350004326552,0.00900006853044033,0.006299989763647318,2.4742999812588096,0.016700010746717453,-39.438732136106225,1.0
-PTSM1992,python,40,6,0.2594499965198338,0.009599956683814526,0.006699992809444666,0.1984999980777502,0.02039998071268201,-39.438732136106225,9.96087893232633
-PTSM1992,numba,40,6,0.06925000343471766,0.009800016414374113,0.006199930794537067,0.014199991710484028,0.017900019884109497,-39.438732136106225,37.31913178549995
-PTSM2025,trial,40,5,2.1840999834239483,0.008400063961744308,0.006400048732757568,2.0939999958500266,0.019099912606179714,-33.01065168146936,1.0
-PTSM2025,python,40,5,0.1489499700255692,0.007950002327561378,0.006100046448409557,0.09280000813305378,0.01829996472224593,-33.01065168146936,14.663312675048
-PTSM2025,numba,40,5,0.05689996760338545,0.008500064723193645,0.006399932317435741,0.009499955922365189,0.01910002902150154,-33.01065168146936,38.38490732803156
diff --git a/benchmarks/results/phase0.csv b/benchmarks/results/phase0.csv
deleted file mode 100644
index 7efdf3c..0000000
--- a/benchmarks/results/phase0.csv
+++ /dev/null
@@ -1,6 +0,0 @@
-case,backend,trials,parameters,objective_ms,reset_ms,prior_ms,run_ms,loss_ms,log_posterior,speed_up
-RLRW,trial,71,2,7.531950017437339,0.004799978341907263,0.003999972250312567,7.398999994620681,0.04650000482797623,-26.034401210112605,1.0
-HybridMBMF,trial,200,6,23.840799927711487,0.01279998105019331,0.007400056347250938,23.64180004224181,0.0543000060133636,-151.7819350468299,1.0
-PTSM,trial,40,4,5.247199966106564,0.0073499977588653564,0.005299923941493034,5.067099933512509,0.04069996066391468,-36.42346848683204,1.0
-PTSM1992,trial,40,6,6.09894999070093,0.010300078429281712,0.007400056347250938,5.823099985718727,0.046749948523938656,-39.438732136106225,1.0
-PTSM2025,trial,40,5,4.435600014403462,0.0071999384090304375,0.005500041879713535,4.139299970120192,0.04824995994567871,-33.01065168146936,1.0
diff --git a/benchmarks/results/phase2.csv b/benchmarks/results/phase2.csv
deleted file mode 100644
index eb46ef4..0000000
--- a/benchmarks/results/phase2.csv
+++ /dev/null
@@ -1,16 +0,0 @@
-case,backend,trials,parameters,objective_ms,reset_ms,prior_ms,run_ms,loss_ms,log_posterior,speed_up
-RLRW,trial,71,2,7.574449991807342,0.004500034265220165,0.003800028935074806,7.411799975670874,0.04680000711232424,-26.034401210112605,1.0
-RLRW,python,71,2,0.43494999408721924,0.004999921657145023,0.00409991480410099,0.3561500343494117,0.044599990360438824,-26.034401210112605,17.414530623693857
-RLRW,numba,71,2,0.08834997424855828,0.00500003807246685,0.004100031219422817,0.011299969628453255,0.042350031435489655,-26.034401210112605,85.73233955335243
-HybridMBMF,trial,200,6,24.17849999619648,0.012199976481497288,0.007100054062902927,23.846850031986833,0.05439994856715202,-151.7819350468299,1.0
-HybridMBMF,python,200,6,1.4406500267796218,0.012800097465515137,0.0074999406933784485,1.2855499517172575,0.05365000106394291,-151.7819350468299,16.783049003403168
-HybridMBMF,numba,200,6,0.12910005170851946,0.012899981811642647,0.0074999406933784485,0.03170000854879618,0.05440006498247385,-151.7819350468299,187.28497530571408
-PTSM,trial,40,4,5.363749980460852,0.007600057870149612,0.005400041118264198,5.142699985299259,0.04504999378696084,-36.42346848683204,1.0
-PTSM,python,40,4,0.24780002422630787,0.007600057870149612,0.005500041879713535,0.15520001761615276,0.04600000102072954,-36.423468486832036,21.64547803095576
-PTSM,numba,40,4,0.09079999290406704,0.00809994526207447,0.005799927748739719,0.012399978004395962,0.04810001701116562,-36.423468486832036,59.07214096511899
-PTSM1992,trial,40,6,6.236799992620945,0.009600073099136353,0.007400056347250938,5.850800022017211,0.0475000124424696,-39.438732136106225,1.0
-PTSM1992,python,40,6,0.28870004462078214,0.010600080713629723,0.007400056347250938,0.17205002950504422,0.04665000597015023,-39.438732136106225,21.603044782390683
-PTSM1992,numba,40,6,0.0990999978967011,0.010399962775409222,0.007300055585801601,0.016300007700920105,0.04650000482797623,-39.438732136106225,62.934410948444224
-PTSM2025,trial,40,5,4.576249921228737,0.00800006091594696,0.00609993003308773,4.337250022217631,0.047099951189011335,-33.01065168146936,1.0
-PTSM2025,python,40,5,0.18390000332146883,0.00800006091594696,0.006499933078885078,0.09790004696696997,0.0439999857917428,-33.01065168146936,24.88444719182067
-PTSM2025,numba,40,5,0.09159999899566174,0.008599949069321156,0.0065999338403344154,0.009599956683814526,0.04630000330507755,-33.01065168146936,49.959060823193596
diff --git a/benchmarks/results/single-kernels.csv b/benchmarks/results/single-kernels.csv
deleted file mode 100644
index c81fec8..0000000
--- a/benchmarks/results/single-kernels.csv
+++ /dev/null
@@ -1,16 +0,0 @@
-case,backend,trials,parameters,objective_ms,reset_ms,prior_ms,run_ms,loss_ms,log_posterior,speed_up
-RLRW,trial,71,2,3.653449995908886,0.004999921657145023,0.004800036549568176,3.535500029101968,0.018700025975704193,-26.034401210112605,1.0
-RLRW,python,71,2,0.6643999367952347,0.005400041118264198,0.004700035788118839,0.6152499699965119,0.018700025975704193,-26.034401210112605,5.498871678903944
-RLRW,numba,71,2,0.07589999586343765,0.005300040356814861,0.004500034265220165,0.029699993319809437,0.019000028260052204,-26.034401210112605,48.1350486827736
-HybridMBMF,trial,200,6,11.062649951782078,0.012999982573091984,0.009399955160915852,10.866799973882735,0.020700041204690933,-151.7819350468299,1.0
-HybridMBMF,python,200,6,1.8010499770753086,0.013399985618889332,0.009399955160915852,1.7200500005856156,0.021600048057734966,-151.7819350468299,6.142333690121419
-HybridMBMF,numba,200,6,0.11009996524080634,0.01309998333454132,0.009299954399466515,0.04429998807609081,0.021200045011937618,-151.7819350468299,100.47823291847806
-PTSM,trial,40,4,2.097700024023652,0.007900060154497623,0.007100054062902927,1.9856500439345837,0.019999919459223747,-36.42346848683204,1.0
-PTSM,python,40,4,0.2633999683894217,0.0077999429777264595,0.0068999361246824265,0.20700000459328294,0.019749975763261318,-36.42346848683204,7.963934228429076
-PTSM,numba,40,4,0.07419998291879892,0.008399947546422482,0.0070999376475811005,0.019400031305849552,0.019000028260052204,-36.42346848683204,28.27089631973742
-PTSM1992,trial,40,6,2.139899996109307,0.010500079952180386,0.009299954399466515,2.0222500315867364,0.019600032828748226,-39.43873213610623,1.0
-PTSM1992,python,40,6,0.30895002419129014,0.010900082997977734,0.009200011845678091,0.24999998277053237,0.019700033590197563,-39.43873213610623,6.92636293429892
-PTSM1992,numba,40,6,0.0836000544950366,0.011000025551766157,0.009299954399466515,0.02350006252527237,0.01850002445280552,-39.43873213610623,25.5968732201766
-PTSM2025,trial,40,5,1.805800013244152,0.008399947546422482,0.00800006091594696,1.6980000073090196,0.018600025214254856,-33.01065168146936,1.0
-PTSM2025,python,40,5,0.3053999971598387,0.008399947546422482,0.0075999414548277855,0.25099999038502574,0.018799910321831703,-33.01065168146936,5.912901211649461
-PTSM2025,numba,40,5,0.06780005060136318,0.008999952115118504,0.00809994526207447,0.015400000847876072,0.01880002673715353,-33.01065168146936,26.634198606451257

From f5539015d98790ff60a168ee2576f39814ceec05 Mon Sep 17 00:00:00 2001
From: Lenard Dome <23503601+lenarddome@users.noreply.github.com>
Date: Tue, 29 Sep 2026 14:13:48 +0200
Subject: [PATCH 25/34] perf(applications): check the activations with one call
 per trial

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 cpm/applications/_sessions.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/cpm/applications/_sessions.py b/cpm/applications/_sessions.py
index 9208a32..e9491db 100644
--- a/cpm/applications/_sessions.py
+++ b/cpm/applications/_sessions.py
@@ -35,6 +35,8 @@
 @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():

From 2980bfd907c55d2dc8f94bc45c6db1dabcee8982 Mon Sep 17 00:00:00 2001
From: Lenard Dome <23503601+lenarddome@users.noreply.github.com>
Date: Tue, 29 Sep 2026 14:13:48 +0200
Subject: [PATCH 26/34] fix(models): NaN policies and short feedback behave as
 on main again

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 cpm/models/kernels.py        | 4 +---
 cpm/models/learning.py       | 4 ++++
 test/models/test_decision.py | 7 +++++++
 test/models/test_learning.py | 7 +++++++
 4 files changed, 19 insertions(+), 3 deletions(-)

diff --git a/cpm/models/kernels.py b/cpm/models/kernels.py
index e403300..05a315a 100644
--- a/cpm/models/kernels.py
+++ b/cpm/models/kernels.py
@@ -129,15 +129,13 @@ def softmax(values, beta):
     Returns
     -------
     numpy.ndarray
-        The policy. If the scaled activations contain NaN, their exponentials,
+        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)
-    elif np.isnan(top):
-        return np.exp(scaled)
     else:
         output = np.exp(scaled - top)
     output /= output.sum()
diff --git a/cpm/models/learning.py b/cpm/models/learning.py
index 7dd0bcc..b416ed0 100644
--- a/cpm/models/learning.py
+++ b/cpm/models/learning.py
@@ -16,6 +16,10 @@
 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]
 
 
diff --git a/test/models/test_decision.py b/test/models/test_decision.py
index 916870d..fe3e720 100644
--- a/test/models/test_decision.py
+++ b/test/models/test_decision.py
@@ -161,5 +161,12 @@ def test_softmax_is_unchanged_where_it_does_not_overflow():
         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_learning.py b/test/models/test_learning.py
index 72ce4f2..004e6bc 100644
--- a/test/models/test_learning.py
+++ b/test/models/test_learning.py
@@ -149,6 +149,13 @@ def test_humble_teacher_with_one_dimensional_weights():
     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."""

From 3f4894ab6c414f02228b0412dce2dd8bbeaa077b Mon Sep 17 00:00:00 2001
From: Lenard Dome <23503601+lenarddome@users.noreply.github.com>
Date: Tue, 29 Sep 2026 14:13:49 +0200
Subject: [PATCH 27/34] bench: re-measure the speed-ups, and update them in the
 News post

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 benchmarks/results/report-branch.csv | 30 ++++++++++++++--------------
 benchmarks/results/report-main.csv   | 10 +++++-----
 docs/news/2026-09-faster-fitting.md  |  4 ++--
 docs/news/index.md                   |  2 +-
 4 files changed, 23 insertions(+), 23 deletions(-)

diff --git a/benchmarks/results/report-branch.csv b/benchmarks/results/report-branch.csv
index 69c0b5c..779f338 100644
--- a/benchmarks/results/report-branch.csv
+++ b/benchmarks/results/report-branch.csv
@@ -1,16 +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.66120005492121,0.00500003807246685,0.004500034265220165,3.499699989333749,0.019099912606179714,-26.034401210112605,1.0
-RLRW,python,71,2,0.6896499544382095,0.005599926225841045,0.004700035788118839,0.6378000834956765,0.020000035874545574,-26.034401210112605,5.3087802462100235
-RLRW,numba,71,2,0.07609999738633633,0.005400041118264198,0.004700035788118839,0.030199997127056122,0.0198000343516469,-26.034401210112605,48.11038345158438
-HybridMBMF,trial,200,6,11.158149980474263,0.012999982573091984,0.009199953638017178,10.877399938181043,0.022000051103532314,-151.7819350468299,1.0
-HybridMBMF,python,200,6,1.8414499936625361,0.013399985618889332,0.009299954399466515,1.7601000145077705,0.0210499856621027,-151.7819350468299,6.059436867075253
-HybridMBMF,numba,200,6,0.10960001964122057,0.013200100511312485,0.00909995287656784,0.044199987314641476,0.021900050342082977,-151.7819350468299,101.80791953323413
-PTSM,trial,40,4,2.113299909979105,0.0072999391704797745,0.006500049494206905,1.9810000667348504,0.01969997538253665,-36.42346848683204,1.0
-PTSM,python,40,4,0.2642999170348048,0.0078000593930482864,0.0067999353632330894,0.2074000658467412,0.019600032828748226,-36.42346848683204,7.995840232143588
-PTSM,numba,40,4,0.07309997454285622,0.008100061677396297,0.006700051017105579,0.018999911844730377,0.019700033590197563,-36.42346848683204,28.909721558659964
-PTSM1992,trial,40,6,2.1307499264366925,0.010500079952180386,0.009100069291889668,2.0070000318810344,0.01939997309818864,-39.43873213610623,1.0
-PTSM1992,python,40,6,0.31260005198419094,0.010900082997977734,0.009100069291889668,0.2495000371709466,0.018700025975704193,-39.43873213610623,6.816217441142494
-PTSM1992,numba,40,6,0.08249992970377207,0.010899966582655907,0.008500064723193645,0.022300053387880325,0.01969997538253665,-39.43873213610623,25.82729384240033
-PTSM2025,trial,40,5,1.8072000239044428,0.008599949069321156,0.007900060154497623,1.707299961708486,0.019900035113096237,-33.01065168146936,1.0
-PTSM2025,python,40,5,0.30369998421519995,0.008999952115118504,0.007900060154497623,0.24500000290572643,0.019400031305849552,-33.01065168146936,5.950609541763663
-PTSM2025,numba,40,5,0.06640003994107246,0.008900067768990993,0.00800006091594696,0.015199999324977398,0.018200022168457508,-33.01065168146936,27.216851458346483
+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
index 551ea4b..e9314e8 100644
--- a/benchmarks/results/report-main.csv
+++ b/benchmarks/results/report-main.csv
@@ -1,6 +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.740949968341738,0.4334500408731401,0.08230004459619522,7.631500018760562,0.04830001853406429,-26.034401210112605,1.0
-HybridMBMF,trial,200,6,25.65465000225231,0.8509999606758356,0.23659993894398212,23.677100078202784,0.05199998850002885,-151.7819350468299,1.0
-PTSM,trial,40,4,6.53229997260496,0.6324999849312007,0.15425001038238406,5.112400045618415,0.046999892219901085,-36.42346848683204,1.0
-PTSM1992,trial,40,6,7.755799975711852,0.8447500295005739,0.23965002037584782,5.928300088271499,0.04700000863522291,-39.43873213610623,1.0
-PTSM2025,trial,40,5,76.71145000495017,0.7241499843075871,0.19545003306120634,76.82600000407547,0.04789989907294512,-33.01065168146936,1.0
+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/docs/news/2026-09-faster-fitting.md b/docs/news/2026-09-faster-fitting.md
index eba264e..6607a7b 100644
--- a/docs/news/2026-09-faster-fitting.md
+++ b/docs/news/2026-09-faster-fitting.md
@@ -10,7 +10,7 @@ kernelspec:
 *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 230 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.
+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
@@ -91,7 +91,7 @@ def dot_plot(rows, labels, unit, ticks, tick_labels, series=SERIES):
 ## 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, 13 to 25 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.
+- **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)).
 
diff --git a/docs/news/index.md b/docs/news/index.md
index 5e1f7cd..a644e7d 100644
--- a/docs/news/index.md
+++ b/docs/news/index.md
@@ -4,7 +4,7 @@ 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 230 times faster, with the same results. Hierarchical estimation also gets an important fix.
+: 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:

From 435da17a0ccbe5cf3ec7ff493dc65f7a0fd1e790 Mon Sep 17 00:00:00 2001
From: Lenard Dome <23503601+lenarddome@users.noreply.github.com>
Date: Tue, 29 Sep 2026 14:13:49 +0200
Subject: [PATCH 28/34] docs: complete the changelog, and describe the numba
 fallbacks

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 CHANGELOG.md                        | 6 +++++-
 docs/get-started/troubleshooting.md | 2 +-
 docs/how-to/fast-session-models.md  | 4 ++--
 3 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 8af0740..1ac8702 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -25,6 +25,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - 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
 
@@ -35,12 +36,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - 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-230 times faster with numba, 13-25 times without, with the same interface and results
+- 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
 
diff --git a/docs/get-started/troubleshooting.md b/docs/get-started/troubleshooting.md
index c5d9c71..ac917ab 100644
--- a/docs/get-started/troubleshooting.md
+++ b/docs/get-started/troubleshooting.md
@@ -33,7 +33,7 @@ If they persist, lower the upper bound of the parameter, or rescale the values t
 
 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 runs the models as plain Python, with the same results, only more slowly.
+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
diff --git a/docs/how-to/fast-session-models.md b/docs/how-to/fast-session-models.md
index 6b68ce4..dfba6b9 100644
--- a/docs/how-to/fast-session-models.md
+++ b/docs/how-to/fast-session-models.md
@@ -10,7 +10,7 @@ numba is an optional dependency. Install it with cpm (see {doc}`/get-started/ins
 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 cannot be imported, for either reason, cpm uses plain Python without further notice.
+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
 
@@ -26,7 +26,7 @@ One evaluation of the objective function, with the parameters' priors, for one p
 
 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.
+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.
 

From d7bf882291d60d9f8ec513581e94103ea0a19845 Mon Sep 17 00:00:00 2001
From: Lenard Dome <23503601+lenarddome@users.noreply.github.com>
Date: Tue, 29 Sep 2026 14:56:23 +0200
Subject: [PATCH 29/34] ci: use actions/setup-python v7 in the tests, as in the
 other workflows

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .github/workflows/tests.yml | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
index 15fff69..a254a7f 100644
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@@ -34,7 +34,7 @@ jobs:
     steps:
       - uses: actions/checkout@v7
 
-      - uses: actions/setup-python@v6
+      - uses: actions/setup-python@v7
         with:
           python-version: ${{ matrix.python }}
           cache: pip
@@ -62,7 +62,7 @@ jobs:
     steps:
       - uses: actions/checkout@v7
 
-      - uses: actions/setup-python@v6
+      - uses: actions/setup-python@v7
         with:
           python-version: "3.11"
 
@@ -84,7 +84,7 @@ jobs:
     steps:
       - uses: actions/checkout@v7
 
-      - uses: actions/setup-python@v6
+      - uses: actions/setup-python@v7
         with:
           python-version: "3.14"
 

From 2468bae70f8a3aa99ffaf1038b099afd40db66fa Mon Sep 17 00:00:00 2001
From: Lenard Dome <23503601+lenarddome@users.noreply.github.com>
Date: Tue, 29 Sep 2026 14:56:24 +0200
Subject: [PATCH 30/34] build: require pandas and matplotlib releases that work
 with NumPy 2

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 CHANGELOG.md   | 1 +
 pyproject.toml | 4 ++--
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1ac8702..70b0797 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -53,6 +53,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - 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 or matplotlib releases that do not work with NumPy 2, by requiring `pandas>=2.2.2` and `matplotlib>=3.8.4`
 - 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
diff --git a/pyproject.toml b/pyproject.toml
index 5ee9e85..506651b 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -33,14 +33,14 @@ classifiers = [
 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",
     "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]

From 82bbfd0e7b00d54a43bc354cf9580f26a5487dd3 Mon Sep 17 00:00:00 2001
From: Lenard Dome <23503601+lenarddome@users.noreply.github.com>
Date: Tue, 29 Sep 2026 15:16:28 +0200
Subject: [PATCH 31/34] fix(applications): reject NaN indices on every
 platform, not only on x86

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 cpm/applications/_backend.py               | 16 +++++++++++++++-
 cpm/applications/decision_making.py        |  4 ++--
 cpm/applications/reinforcement_learning.py | 16 +++++-----------
 3 files changed, 22 insertions(+), 14 deletions(-)

diff --git a/cpm/applications/_backend.py b/cpm/applications/_backend.py
index 4e6420a..578b725 100644
--- a/cpm/applications/_backend.py
+++ b/cpm/applications/_backend.py
@@ -21,7 +21,7 @@
 from ..core import _jit
 from ..generators.session import SessionWrapper, session_data, trial_view
 
-__all__ = ["Application", "SessionModel", "TrialModel", "require", "uniforms"]
+__all__ = ["Application", "SessionModel", "TrialModel", "indices", "require", "uniforms"]
 
 
 class SessionModel:
@@ -118,6 +118,20 @@ def uniforms(trials, needed):
     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 = {}
diff --git a/cpm/applications/decision_making.py b/cpm/applications/decision_making.py
index e6ca0a6..4b2fb8f 100644
--- a/cpm/applications/decision_making.py
+++ b/cpm/applications/decision_making.py
@@ -2,7 +2,7 @@
 import warnings
 from cpm.generators import Parameters, Value
 from cpm.core import _jit
-from cpm.applications._backend import Application, SessionModel, prepared, require, uniforms
+from cpm.applications._backend import Application, SessionModel, indices, prepared, require, uniforms
 
 
 def _ptsm_parameters(parameters_settings, utility_curve, weighting):
@@ -229,7 +229,7 @@ def __call__(self, data):
         require(out, self.columns + ["observed"], self.model)
         for key in self.columns:
             out[key] = np.ascontiguousarray(out[key], dtype=np.float64)
-        out["observed"] = np.ascontiguousarray(out["observed"], dtype=np.int64)
+        out["observed"] = indices(out["observed"])
         return out
 
 
diff --git a/cpm/applications/reinforcement_learning.py b/cpm/applications/reinforcement_learning.py
index 26278d0..3e67c1e 100644
--- a/cpm/applications/reinforcement_learning.py
+++ b/cpm/applications/reinforcement_learning.py
@@ -3,7 +3,7 @@
 
 from cpm.generators import Parameters, Value
 from cpm.applications._backend import (
-    Application, SessionModel, ordered_columns, prepared, require, uniforms,
+    Application, SessionModel, indices, ordered_columns, prepared, require, uniforms,
 )
 
 
@@ -117,14 +117,12 @@ def _prepare_rlrw(data):
             f"such as arm_left and reward_left, but the data have {sorted(out)}."
         )
     trials = len(out[arms[0]])
-    out["arms"] = numpy.ascontiguousarray(
-        numpy.column_stack([out[c] for c in arms]), dtype=numpy.int64
-    )
+    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"] = numpy.ascontiguousarray(response, dtype=numpy.int64)
+    out["response"] = indices(response)
     return out
 
 
@@ -277,16 +275,12 @@ def __call__(self, data):
         require(out, needed, "HybridMBMF")
         trials = out["s1"].shape[0]
         for key in ("s1", "stimuli_first", "action", "s2"):
-            out[key] = numpy.ascontiguousarray(
-                out.get(key, numpy.zeros(trials)), dtype=numpy.int64
-            )
+            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"] = numpy.ascontiguousarray(
-            out.get("position", out["stimuli_first"] ^ out["action"]), dtype=numpy.int64
-        )
+        out["position"] = indices(out.get("position", out["stimuli_first"] ^ out["action"]))
         return out
 
 

From 68f623bb2347769185108b3b125b4da0ceabd898 Mon Sep 17 00:00:00 2001
From: Lenard Dome <23503601+lenarddome@users.noreply.github.com>
Date: Tue, 29 Sep 2026 15:16:28 +0200
Subject: [PATCH 32/34] test: compare to 1e-12 across CPUs, and store the
 reference without pandas objects

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../data/per_trial_reference.pkl.gz           | Bin 80786 -> 80311 bytes
 test/applications/test_backends.py            |  14 +++++++++-----
 .../test_reinforcement_learning.py            |   5 +++--
 3 files changed, 12 insertions(+), 7 deletions(-)

diff --git a/test/applications/data/per_trial_reference.pkl.gz b/test/applications/data/per_trial_reference.pkl.gz
index 62ac8f415cdac297356bdc3a30fbf071400d57e4..ac409d91c77890be2f3e624d11ab95f4ee3edc9a 100644
GIT binary patch
literal 80311
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
N{{hkDZY_hd1OPg{5y1ce

literal 80786
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

diff --git a/test/applications/test_backends.py b/test/applications/test_backends.py
index ac15a01..73f12da 100644
--- a/test/applications/test_backends.py
+++ b/test/applications/test_backends.py
@@ -8,7 +8,11 @@
 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`.
+`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
@@ -147,7 +151,7 @@ def test_runs_equal_the_per_trial_implementation(case, backend):
         model.run()
         np.testing.assert_allclose(model.dependent, reference["dependent"][scale], **TOLERANCE)
         if scale in reference["exports"]:
-            expected, got = reference["exports"][scale], model.export()
+            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)
@@ -208,20 +212,20 @@ def test_simulations_equal_the_per_trial_implementation(backend):
     simulator = Simulator(wrapper=wrapper, data=data.groupby("ppt"), parameters=draws)
     np.random.seed(2024)
     simulator.run()
-    pd.testing.assert_frame_equal(simulator.export(), REFERENCE["simulator"], check_exact=False,
+    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_exactly(case):
+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=True)
+    pd.testing.assert_frame_equal(exports[0], exports[1], check_exact=False, **TOLERANCE)
 
 
 def test_numba_is_used_when_installed(monkeypatch):
diff --git a/test/applications/test_reinforcement_learning.py b/test/applications/test_reinforcement_learning.py
index 6f83748..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")
 

From f9e4367f7e8f4428b8cb6ada76c7061ef247edd5 Mon Sep 17 00:00:00 2001
From: Lenard Dome <23503601+lenarddome@users.noreply.github.com>
Date: Tue, 29 Sep 2026 15:16:29 +0200
Subject: [PATCH 33/34] docs(news): results can differ in the last digit on
 other machines

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 docs/news/2026-09-faster-fitting.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/news/2026-09-faster-fitting.md b/docs/news/2026-09-faster-fitting.md
index 6607a7b..21a7b0a 100644
--- a/docs/news/2026-09-faster-fitting.md
+++ b/docs/news/2026-09-faster-fitting.md
@@ -180,7 +180,7 @@ The tutorials themselves keep their per-trial model, which shows how a model is
 
 ## Same results, and one fix
 
-- The objective function of the built-in models is bit-identical to cpm 0.25, and so are all their outputs: exports, dependent variables, states and seeded simulations, with and without numba.
+- 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.
 

From 040c87bad9ad4be31f6909128027f5b99301eb6c Mon Sep 17 00:00:00 2001
From: Lenard Dome <23503601+lenarddome@users.noreply.github.com>
Date: Tue, 29 Sep 2026 15:28:30 +0200
Subject: [PATCH 34/34] build: require pybads 1.0.5, the first release that
 works with NumPy 2

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 CHANGELOG.md   | 2 +-
 pyproject.toml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 70b0797..dd27499 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -53,7 +53,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - 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 or matplotlib releases that do not work with NumPy 2, by requiring `pandas>=2.2.2` and `matplotlib>=3.8.4`
+- 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
diff --git a/pyproject.toml b/pyproject.toml
index 506651b..64227ba 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -37,7 +37,7 @@ dependencies = [
     "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.4"  # the first release that works with NumPy 2