Surefold
On this page

Benchmark study · supporting material

Measurements and method

The evidence behind the Watershed benchmark, including what each timing measures, how the results were checked and how to reproduce the runs.

Machine and runs

One desktop: Ryzen 9 5950X (16 cores, 32 threads), 47 GB, one RTX 3090 (24 GB, driver 621.14), WSL2, CUDA 13.1, Rust 1.99.1, JAX 0.12.0.1. All arithmetic is double precision.

The benchmarks were run in two sessions on 13 November 2026.

  • First session: one pass of every benchmark at watershed b7587e9.
  • Repeat passes: five further passes at 8045417, the published revision, each benchmark in a fresh process (three passes for the nested simulation). The two revisions have the same engine code; 8045417 adds the JAX baseline, documentation and four lines of example output.

The tables give the median and range of the repeat passes, with the first session’s value beside them. The article quotes the medians. Measured means the full workload was run and timed. Extrapolated (marked ≈) means a sample of scenarios was timed and the time scaled linearly; the sample is given in the basis column.

The machine was a shared desktop and was not idle throughout: during the second repeat pass another job was using the CPU and some GPU memory. In that pass CPU-bound timings were two to three times the median (the hand-written loan loop took 68.8 s against a median of 19.8 s), while GPU execution times moved by a few per cent. A second job, using the GPU and then the CPU, also overlapped the end of the first pass and the start of the second. Both passes are included in every median, range and count, so the upper end of a range may reflect contention. No run was discarded.

Insurance: scenario evaluation

20,000 model points (1,009,152 policies, 1,916,579 policy-months), 10,000 market paths of 240 monthly returns, four outputs per path. The plan has 19,889,057 nodes in 967 levels with 34 shapes and needs 344,124 slots (2,752,992 bytes) per scenario.

The liabilities example · times in the first six rows are reported by the example; the stage rows by the crate’s Timing record
FigureMedian, range, runsFirst sessionBasis
GPU plan, first run of 10,000 scenarios10.2 s10.1 to 10.3 s
5 runs
10.0 sMeasured in full. Host inputs to host outputs: kernel compilation, upload, execution in two parts (6,807 scenarios at a time), download
GPU plan, each of eight further runs under changed shared inputs9.6 s9.5 to 14.4 s
40 runs
9.4 to 9.9 sMeasured in full. Includes set_shared and transfers; kernels already compiled. See the note on batch size below
Graph construction22.7 s21.3 to 28.4 s
5 runs
22.6 sMeasured. Single-threaded
Plan compilation17.7 s17.6 to 34.1 s
5 runs
18.0 sMeasured
Plan on 32 CPU threads, per scenario45 ms45 to 95 ms
5 runs
44 msMeasured on 128 scenarios; results asserted bit-identical to the GPU’s
Plan on 32 CPU threads, 10,000 scenarios≈ 7.5 minutes7.5 to 16 minutes
5 runs
7.3 minutesExtrapolated: the row above × 10,000
Stage: kernel compilation18 ms18 to 133 ms
5 runs
19 msMeasured. NVRTC, 34 kernels. Smaller plans had already been compiled and run in the same process, so this is not a cold start. The 133 ms was the first pass of the session
Stage: host to device977 ms904 ms to 1.0 s
5 runs
869 msMeasured. Plan tables, working-table allocation and inputs
Stage: execution9.2 s9.1 to 9.2 s
5 runs
9.1 sMeasured
Stage: device to host4 ms3 to 66 ms
5 runs
5 msMeasured. Four values per scenario

Batch size: the first run of each process fitted 6,807 scenarios at a time, so it ran in two parts. The eight further runs of each process ran 1,161 to 5,676 scenarios at a time, in up to nine parts, and took 9.5 to 10.0 s (in the disturbed pass, 972 to 5,822 at a time). A run sizes its batch from the free device memory at that moment, and the pattern is consistent with the previous run’s table not yet having been released; that cause was not confirmed.

lifelib was timed once by its reference script: 17.6 s for 200 model points on 1,000 paths, on one core. Scaling that to 20,000 model points and 10,000 paths gives about 4.9 hours. It was not run at full size.

The JAX baseline, savings_jax.py, same GPU · measured in full · five timed runs per invocation after one run that includes tracing and XLA compilation
VariantMedian, range, runsFirst run, with compilationEarlier session
Model points sorted by remaining term, 2,500 at a time6.20 s6.17 to 6.21 s
10 runs
6.42 and 6.45 s6.10 to 6.32 s
Unsorted, 5,000 at a time13.11 s13.09 to 13.11 s
10 runs
13.23 and 13.25 s13.11 to 13.12 s

The JAX program is the same model, checked against lifelib to the same 3.1 × 10⁻¹³. It takes inputs of the same form, 10,000 paths of 240 monthly returns from its own random draws, and produces the same four outputs per path. It holds model points in batches of 2,500 (sorted) or 5,000 (unsorted). Unsorted, it steps 4,820,000 padded policy-months where the graph contains 1,916,579.

Two boundary differences favour JAX slightly. Its timed run excludes working out its constants and copying them to the device (0.3 s, once), where the plan’s time includes uploading its tables on every run (about 1 s). Tracing and XLA compilation add 0.1 to 0.2 s to its first run, which is shown separately.

At start-up XLA logged failed attempts to reserve its default memory pool, 18 GiB and then progressively less down to about 4 GiB, before proceeding. The timed runs were stable, with a range under 1%.

Nested simulation

The capital example · 4,000 model points (200,278 policies), 3,210,292 nodes · 1,000 outer × 1,000 inner scenarios
FigureMedian, range, runsFirst sessionBasis
GPU plan, 1,000,000 valuations3 minutes3 minutes
3 runs
3 minutesMeasured in full. Plan and inner scenarios resident on the device; one set_shared and one run per outer scenario; the example reports whole minutes above two minutes

The result (6,117,962,840 for the worst year in 200) was identical in every run. lifelib at its measured rate would take about 98 hours; that figure is extrapolated and was not run.

Insurance: incremental recomputation

The amendments example · 20,000 model points, one market path, no GPU · all measured
FigureMedian, range, runsFirst sessionBasis
One model point changes: mean of 1,000 changes58 µs56 to 94 µs
5 runs
56 µsEach iteration sets one guarantee, calls stabilize() and reads the total. A different model point each time. Mean of 570 nodes recomputed
Every input changes (a new market path)5.3 s5.1 to 15.3 s
5 runs
5.2 sOne timed update
First valuation, including graph construction26.4 s26.0 to 42.8 s
5 runs
27.7 sOne timed build and update
of which graph construction21.2 s20.8 to 27.6 s
5 runs
22.5 s

The CPU comparison with lifelib was measured by amendments_reference.py in the first session and not repeated: 3.6 s for a first valuation and for a new market path, 2.3 s after one model point changes (median of five), and 0.29 s to revalue one row alone (median of five).

Why two examples report different times for one change

The liabilities example also times one changed guarantee and reports a larger figure. Both examples build the same graph with the same code. They differ in what is timed.

One guarantee raised by 10% · both measured
amendmentsliabilities
Time reported58 µs (56 to 94 µs over five runs; 54 µs and 56 µs in earlier runs)137 µs (131 to 159 µs over five runs; 120 µs and 133 µs in earlier runs)
Samples behind the figureMean of 1,000 consecutive changesOne change, timed once
Model point changed1,000 different model points, spread across the portfolioThe first model point with more than 120 months remaining
Nodes recomputed570 on average952
State of the graphInputs set to one of lifelib’s market pathsInputs at their steady default; the process has just run the GPU benchmark
Timed regionset, stabilize(), read the totalset, stabilize()

A separate probe, built on the same model code and run three times, timed both cases on one graph. Changing 1,000 different model points recomputed between 7 and 1,455 nodes, 570 on average, about six per remaining month; the portfolio averages 95 months remaining. Per change the mean was 54 to 57 µs, the median 50 to 52 µs, the 5th percentile 12 µs and the 95th 112 to 126 µs. The model point liabilities changes has 157 months remaining and recomputes 952 nodes. Timed once it took 112 to 144 µs; repeated 1,000 times its median was 66 to 68 µs. Whether the inputs held a market path or their defaults did not change the node counts.

So the two reported figures differ for two reasons: the single change touches 952 nodes where the average change touches 570, and a single first-time sample costs about twice what the same change costs when it is repeated. The article quotes the median of five runs, each averaging 1,000 changes.

The liabilities example times two larger changes the same way, once each: one late-month return changed, 62,221 nodes, 12 ms; and the fee changed for every policy, 19,927,802 nodes, 4.9 s (4.9 to 6.6 s).

Insurance: updating a batch after a change

Run of 13 November 2026 at watershed ba7b414, after the other measurements, with no other job on the machine. The rerun example was run five times in fresh processes. Each run amends five model points in turn and twice checks the kept values against compiling and running the whole plan again. The feature is experimental (Kept).

20,000 model points × 10,000 scenarios, keeping 11,436 values per scenario (915 MB): the sums over each group of eight model points and the sums above them. Medians of five runs, with ranges.
Model point (months left)Nodes in the small planCompile itRun on CPU threadsRun on the GPUWhole refresh, CPU
12099 (9)9,32713 ms207 ms (206–209)248 ms (227–255)222 ms (220–223)
11073 (44)5,77110 ms127 ms (127–129)220 ms (202–225)140 ms (137–146)
17041 (88)7,1519 ms160 ms (158–161)43 ms (41–45)170 ms (168–175)
2770 (136)7,42610 ms171 ms (171–173)32 ms (29–56)184 ms (182–191)
19912 (240)8,55910 ms192 ms (191–196)34 ms (34–55)203 ms (202–209)

The whole refresh is compiling the small plan, running it on CPU threads and storing the results (1 to 2 ms). The first run, which returns the kept values, took 11.2 s (11.2–11.3); compiling the whole plan again took 17.8 s (17.6–18.1) and running it again 11.2 s (11.1–11.3). All ten checks found every kept value on every scenario identical to the last bit. The GPU timings of the small plan include compiling any kernel not already compiled in the process, which is the likely reason the first two rows are slow; that was not separated out. JAX was not given an update path: its comparable figure is the 6.2 s whole-batch run.

Reproduce with cargo run --release --features cuda -p watershed-gpu --example rerun -- export 20000 10000 1.

The same on the loan book, with the kept values chosen by the engine

To check the result is not particular to one model, the loan book (20,000 loans, 5.2 million nodes, 10,000 scenarios) was run the same way at watershed a8d2198. Here the engine chose what to keep from a budget of 12,000 values alone, taking the calculated values nearest the outputs: 8,577 per scenario, 686 MB. One loan’s house is revalued, five loans in turn, and the small plan runs on the GPU.

Loan book, 20,000 loans × 10,000 scenarios. Medians of five runs in fresh processes, with ranges.
StepTime ↓
Each refresh after the first29 to 36 ms (29–49)
First refresh in a process167 ms (157–249)
Compile the whole plan again5.3 s (5.2–5.4)
Run the whole plan again on the GPU7.2 s (7.1–7.5)

In all five runs every kept value on every scenario was identical to the last bit to compiling and running the whole plan again. That depends on where the small plan runs. This model uses exp, whose last digits differ between a CPU and a GPU, so a refresh on CPU threads after a GPU batch gave values up to 1.3 × 10⁻¹⁵ away: correct, but not identical. The first refresh is slower, most likely from compiling kernels; that was not separated out.

Reproduce with cargo run --release --features cuda -p watershed-gpu --example loans -- 20000 10000.

Other workloads

Large graphs · scenarios are economic paths
FigureMedian, range, runsFirst sessionBasis
Loans: GPU plan, 20,000 loans × 10,000 scenarios6.3 s6.2 to 6.7 s
5 runs
6.4 sMeasured in full, host to host. 5,179,699 nodes, 206 levels
Loans: plan on 32 CPU threads≈ 2.7 minutes2.5 to 8.8 minutes
5 runs
3 minutesExtrapolated from 64 scenarios
Loans: hand-written Rust loop, 32 threads≈ 19.8 s18.2 to 68.8 s
5 runs
22.7 sExtrapolated from 32 scenarios
Loans: graph construction9.2 s9.0 to 14.6 s
5 runs
9.6 sMeasured
Loans: plan compilation5.6 s5.3 to 8.2 s
5 runs
6.2 sMeasured
Pensions: GPU plan, 50,000 member groups × 5,000 scenarios683 ms621 ms to 1.2 s
5 runs
721 msMeasured in full, host to host. 2,492,023 nodes, 85 levels
Pensions: plan on 32 CPU threads≈ 16.7 s14.3 to 17.0 s
5 runs
16.3 sExtrapolated from 128 scenarios
Pensions: hand-written Rust loop, 32 threads≈ 5.4 s4.9 to 5.7 s
5 runs
5.2 sExtrapolated from 128 scenarios
Pensions: 30 further runs under changed shared inputs12.4 s12.4 to 13.2 s
5 runs
12.4 sMeasured in full; total for the 30
Small graphs · each scenario is one entity (a trial, a patient, a household, a policy)
FigureMedian, range, runsFirst sessionBasis
Workbook: GPU plan, 10 million trials457 ms449 to 467 ms
5 runs
438 msMeasured in full, host to host. 171 nodes
Workbook: plan on 32 CPU threads1.8 s1.8 s
5 runs
1.9 sMeasured in full
Workbook: graph, one trial at a time≈ 105 s103 to 107 s
5 runs
106 sExtrapolated from 20,000 trials
Dosing: GPU plan, 5 million scenarios, per protocol60 ms59 to 61 ms
5 runs
60 msMeasured in full. Inputs resident on the device; counts reduced on the device; only totals return. 243 nodes, 85 levels, 40 shapes
Dosing: loading the 5 million scenarios onto the device186 ms182 to 343 ms
5 runs
172 msMeasured. Paid once, not per protocol
Dosing: 51 protocols3.0 s3.0 to 3.1 s
5 runs
3.0 sMeasured in full
Dosing: plan on 32 CPU threads≈ 2.0 s2.0 to 4.7 s
5 runs
2.0 sExtrapolated from 1 million scenarios
Dosing: graph, one scenario at a time≈ 71.6 s71.2 s to 2 minutes
5 runs
73.2 sExtrapolated from 20,000 scenarios
Tax: GPU plan, 10 million households638 ms629 to 706 ms
5 runs
627 msMeasured in full, host to host; includes kernel compilation. 49 nodes, 14 levels; 11 inputs and 5 outputs per scenario
Tax: of which execution19 ms19 ms
5 runs
19 msMeasured
Tax: each later run under changed rules510 ms498 to 524 ms
20 runs
479 to 544 msMeasured in full, host to host; kernels already compiled
Tax: plan on 32 CPU threads≈ 632 ms618 to 652 ms
5 runs
622 msExtrapolated from 1 million households
Tax: graph, one household at a time≈ 27.9 s27.3 to 28.9 s
5 runs
28.9 sExtrapolated from 20,000 households
Pricing: GPU plan, 5 million policies339 ms332 to 392 ms
5 runs
339 msMeasured in full, host to host; includes kernel compilation. 22 nodes, 8 levels; 13 inputs and 5 outputs per scenario
Pricing: of which execution5 ms5 to 6 ms
5 runs
5 msMeasured
Pricing: each later run under changed factors280 ms270 to 306 ms
20 runs
261 to 267 msMeasured in full, host to host; kernels already compiled
Pricing: plan on 32 CPU threads≈ 191 ms182 to 201 ms
5 runs
219 msExtrapolated from 1 million policies
Pricing: graph, one policy at a time≈ 11.1 s10.8 to 11.6 s
5 runs
11.2 sExtrapolated from 20,000 policies
Pricing: 1,000 repricings, inputs resident, totals only5.0 s5.0 to 5.1 s
5 runs
5.0 sMeasured in full

The crate has further examples (monte_carlo, backtest, experts). Their figures are in the crate README.

What each comparison includes

GPU plan against JAX, insurance

  • Timings. Both measured in full on the same GPU.
  • Setup and compilation. Excluded on both sides: graph construction and plan compilation for the plan; tracing, XLA compilation and preparing constants for JAX. The plan’s first run includes kernel compilation.
  • Transfers. Inputs and outputs are included on both sides. The plan also uploads its tables on every run.
  • Equivalent work. The same model with the same sizes of input and output. Each side draws its own 10,000 paths. Unsorted JAX steps padded months that the graph does not contain.
  • Precision and checks. Double precision. Both are checked against lifelib to 3.1 × 10⁻¹³.

GPU plan against the same plan on CPU threads

  • Timings. GPU measured in full. CPU extrapolated from 64 or 128 scenarios on the large graphs and from 1 million on the small ones, and measured in full for the workbook.
  • Setup and compilation. Plan compilation is excluded from both.
  • Transfers. Included for the GPU unless a figure is stated as resident.
  • Equivalent work. The same plan and the same inputs.
  • Precision and checks. Double precision. Asserted bit-identical on the sample for insurance and pensions, and within 10⁻⁹ relative for loans, which uses exp.

Plan against a hand-written Rust loop, loans and pensions

  • Timings. The loop is extrapolated from 32 scenarios (loans) or 128 (pensions).
  • Setup and transfers. None for the loop.
  • Equivalent work. The same model and inputs, on 32 threads.
  • Precision and checks. Double precision. The loop and the plan agree to 3.3 × 10⁻¹⁷ and 4.6 × 10⁻¹³.

GPU plan against lifelib

  • Timings. lifelib is extrapolated from 200 model points × 1,000 scenarios and was not run at full size.
  • Equivalent work. The same model. lifelib runs on one core and projects every policy to the longest term.
  • Precision and checks. Double precision. They agree to 3.1 × 10⁻¹³.

Incremental recomputation against lifelib

  • Timings. Both measured. Graph construction is reported separately.
  • Equivalent work. The same portfolio, one market path and the same change. No GPU.
  • Precision and checks. Double precision. Portfolio values agree to 4 × 10⁻¹⁵ before and after the change.

Incremental recomputation against GPU scenario evaluation

The two timings show how the same model serves different workloads. The incremental run updates an existing valuation after one small change. The GPU run evaluates 10,000 market paths. A hardware speedup requires timings for the same workload.

GPU utilisation was sampled once during a long run in an earlier session: 96 to 98%, about 335 W. Bytes moved were not measured, so the suggestion that the plan is bound by memory bandwidth is an inference.

Correctness

Each model against something independent of the graph · differences are relative to the size of the quantity compared
ModelReferenceComparedLargest difference
Insurance, as published by lifeliblifelib, four configurations1,440,000 outputs9.7 × 10⁻¹⁵
Insurance, mixed portfoliolifelib, 200 model points × 1,000 scenarios, static and dynamic lapses1,600,000 outputs3.1 × 10⁻¹³
Insurance, JAX baselineThe same lifelib run800,000 outputs3.1 × 10⁻¹³
Insurance, incrementallifelib portfolio value before and after one change2 values3.7 × 10⁻¹⁵
Loan bookHand-written Rust loop200 loans × 50 scenarios3.3 × 10⁻¹⁷
Pension schemeHand-written Rust loop2,000 groups × 100 scenarios4.6 × 10⁻¹³
Two-compartment dosing modelSciPy LSODA, tolerance 10⁻¹¹300 scenarios1.7 × 10⁻¹⁰
Excel workbookValues stored in the file by Excel176 cellsall within 10⁻⁹

One formula differs from lifelib’s published model: where lapses depend on the fund, the monthly rate is scaled directly. The reference was changed in the same way for that check.

Between Watershed’s own strategies

  • A property test builds 40 random graphs and requires the plan to equal the incremental engine bit for bit. It runs against the CPU interpreter, the GPU interpreter kernel and the generated GPU kernels.
  • The workbook, dosing, tax and pricing examples assert that the plan equals the graph bit for bit on 20,000 scenarios each.
  • The insurance and pension examples assert that the plan gives bit-identical results on the CPU and the GPU for 128 scenarios. The loan example, which uses exp, asserts agreement within 10⁻⁹.
  • Exceptions on the GPU: NaN payloads may differ; min and max of ±0 follow x86-64; exp, ln and pow may differ from the CPU in the last one or two digits, tested to 10⁻¹⁴ relative.
  • A conditional is lazy in the graph and evaluates both branches in the plan. The two agree because no operation in the supported subset can fail.

These equalities are established by testing. Nothing is proved.

How the plan compiler works

A plan is compiled from the graph’s formulas and dependency edges, given the inputs that vary per scenario, the inputs shared by all scenarios, and the outputs.

Compiling and running a plan
let mut plan = Scenarios::with_shared(&g, &vary, &shared, &outputs)?;
let results = gpu.run(&plan, &inputs)?;       // one row of inputs per scenario

let mut loaded = gpu.load(&plan, &inputs)?;   // plan and inputs stay on the device
plan.set_shared(&stressed);                   // change shared inputs only
let totals = loaded.totals(&plan)?;           // rerun and sum each output on the device
  1. Extraction. A walk back from the outputs collects the nodes they depend on. Nodes that depend on a varied input are evaluated per scenario, nodes that depend only on shared inputs once on the CPU, and the rest become constants.
  2. Execution levels. A node’s level is one more than the highest level it reads, so the nodes of a level are independent and can run in parallel. The insurance model has 967 levels.
  3. Kernel grouping. Nodes with the same operation sequence and different operands share a shape. The insurance model’s 19.9 million nodes have 34. For up to 256 shapes, one CUDA kernel is generated per shape and compiled with NVRTC; beyond that an interpreter kernel is used.
  4. Slot allocation. Each node gets a row of working memory, reused once its value is dead.

A kernel launch evaluates one shape’s nodes within one level for every scenario. Each GPU thread handles one node in one scenario, reading its operands from the working table and writing one value back. Kernels are not fused across nodes, so every intermediate value passes through device memory. Fused multiply-add is disabled so the GPU rounds as the CPU does. The same plan runs on CPU threads through an interpreter.

Value lifetimes and memory reuse

The working table has one row per slot and one column per scenario. With a slot per node, the insurance model would need 159 MB per scenario, and the 18.7 GB of working memory would hold about 118 scenarios. Instead the plan compiler runs a liveness analysis at level granularity (plan.rs):

  1. For each node, find the last level that reads it. Outputs are never dead.
  2. Visit nodes in level order. Before level L, release the slot of every value whose last reader is below L. Nodes of a level run concurrently, so a slot is never released mid-level.
  3. Give each node the lowest-numbered free slot, or a new one if none is free.
level 1 level 2 level 3 level 4 level 5 level 6 fund present value f1 v1 f2 v2 f3 v3 f4 v4 f5 v5 slot 0 slot 1 slot 2 slot 3 f1 f3 f5 f2 f4 v5 v1 v3 v2 v4
A five-month projection, and the slot each value holds from the level that writes it to the last level that reads it. Ten nodes need four slots, and a longer projection needs no more. Input slots are omitted.

The insurance plan needs 344,124 slots for 19,889,057 nodes, 58 times fewer. That is 2.75 MB per scenario, so 6,807 scenarios fit at once and 10,000 run in two parts. Most values in a month-by-month projection are read only by the following month, so the live set, about 17 values per model point, does not grow with the length of the projection.

The saving has limits. It applies to the working table only: the plan’s operand tables are stored on the device in full, and every node is still evaluated for every scenario. Lifetimes are not optimised either. Levels are assigned as early as possible and never reordered, so a value computed early and read late holds its slot throughout. And a larger batch is not a faster one: runs split into as many as nine parts were no slower.

Reproduction

The code is the watershed-gpu crate. Each benchmark is an example that runs its correctness checks before timing anything. Without --features cuda an example runs the plan on CPU threads.

The insurance benchmark
pip install lifelib pandas openpyxl scipy
mkdir export && python crates/watershed-gpu/examples/shared/liabilities_reference.py
cargo run --release --features cuda --example liabilities -- export   # scenarios
cargo run --release --features cuda --example capital -- export       # nested simulation

python crates/watershed-gpu/examples/shared/amendments_reference.py export
cargo run --release --example amendments -- export                    # incremental

pip install "jax[cuda12]" numpy                                       # the JAX baseline
python crates/watershed-gpu/examples/shared/savings_jax.py export 20000 10000 2500 sorted
python crates/watershed-gpu/examples/shared/savings_jax.py export 20000 10000 5000
The other workloads
cargo run --release --features cuda --example loans
cargo run --release --features cuda --example pensions
cargo run --release --features cuda --example tax_benefit
cargo run --release --features cuda --example insurance               # motor pricing

mkdir out && python crates/watershed-gpu/examples/shared/dosing_reference.py out
cargo run --release --features cuda --example dosing -- out

cargo run --release --features cuda --example spreadsheet -- \
  fcffsimpleginzu.xlsx "'Input sheet'!B26=0.02:0.09" "'Input sheet'!B28=0.02:0.09" \
  "'Input sheet'!B29=0.10:0.18" "'Input sheet'!B31=1.2:2.4" "'Input sheet'!B12=2500:3600" \
  "'Input sheet'!B13=400:600" "'Input sheet'!B34=0.035:0.055" "'Input sheet'!B23=0.15:0.20" \
  "'Valuation output'!B33" 10000000

Setting TIMING=1 makes the insurance examples print the per-stage timings. Sources: liabilities.rs, amendments.rs, capital.rs, the shared model, the JAX baseline, and the property tests.