diff --git a/CHANGELOG.md b/CHANGELOG.md
index 4a8ee98..c147e1b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,76 @@
 # Changelog
 
+## 0.9.0 (unreleased)
+
+A new simplify kernel. `simplify` is now a best-first cancellation SEARCH instead of a fixed
+cancellation order; masking (numeric literals -> `<constant>`) is separated from the
+equivalence loop so representation is no longer entangled with rewriting; and the constant-fold
+fallback is brought under the same finite-a.e. certificate the rules and cancellation already
+enforce.
+
+### Added
+- **Cancellation search** (`Engine::simplify_search`). `simplify` no longer commits to one
+  cancellation order. Cancel is non-confluent -- taking candidate A can destroy candidate B,
+  and which choice ends shortest depends on what the ruleset can fold -- so the kernel now
+  SEARCHES a small move graph instead of guessing. State = an expression; the moves are a flat
+  choice set (apply the rules pass, or cancel any one qualifying candidate); the answer is the
+  shortest state visited. Every state is a.e.-equivalent to the input and the input is state
+  zero, so a result can never be longer than its own input. Best-first by
+  length with a visited-set, pre-filled with the greedy result so a truncated budget can never
+  do worse than the plain fixpoint. The node budget (`SIMPLIPY_SEARCH_BUDGET`, default 24;
+  0 restores the plain greedy fixpoint and its speed exactly) bounds a rare heavy tail -- the
+  median expression expands 2 nodes and 53% have no cancellation candidate at all, but the p99
+  is ~186. The default is the measured elbow of the returns curve on the 64k v23.0 prior: below
+  24 an extra microsecond buys ~14 output tokens, above it ~2.7, and by 256 only 0.7. On that
+  corpus the search shortens ~2860/1000/350 expressions (2-1/3-2/4-3) that no previous version
+  could reach, at ~2.3x the simplify wall time; raise the budget for offline corpus
+  canonicalisation, lower it for latency.
+- **Symmetric `neg`/`inv` cancellation** (BEHAVIOUR CHANGE). The cancellation unit already
+  EMITTED the class inverses but never CONSUMED them: a leaf under its own class inverse was
+  shielded, so `x * inv(x)` and `x + neg(x)` did not cancel through the inverse. Each inverse is
+  now region-continuing in its own class (`neg` additive, `inv` multiplicative), symmetric with
+  the emit path, and there is exactly one region shape -- the asymmetry is not preserved behind
+  a flag. Consequence on sparse rule sets: a handful of expressions come out ONE token longer
+  than in 0.7.x, because the old opaque treatment happened to leave a sign arrangement those
+  rule sets can re-fold and the connected treatment does not (6 of 65536 on the 2-1/3-2-class
+  `3-2` set; none on `4-3` or richer, and never longer than the input). Cancelling through the
+  class inverse is worth far more than it costs: the same corpus gets 1005 expressions SHORTER
+  on `3-2` and 350 on `4-3`.
+- **Soundness `Mode` (`simplify(expr, mode=Mode.SOUND)`).** A single ordinal soundness axis,
+  exposed as `simplipy.Mode`. `Mode.SOUND` (the default) is equivalence-preserving and
+  idempotent -- the deployed inference/scoring path, byte-identical to the historical default.
+  `Mode.LOSSY` trades soundness for recall: every rule placeholder binds any subtree (the
+  `!`-sort finite-a.e. certificate is skipped) AND the constant-fold's finiteness gate is
+  relaxed, so a non-finite-a.e. subtree such as `<constant>/0` collapses to `<constant>` too.
+  `Mode.LOSSY` is for training-corpus canonicalisation ONLY -- the training data is generated
+  FROM the simplified form (target == data) -- and must never run on an inference or scoring
+  path. The decided full ordering is `EXACT <= SOUND <= AE <= LOSSY`; only `SOUND` and `LOSSY`
+  are implemented.
+
+### Changed
+- **BREAKING: masking is separated from `simplify`.** Masking numeric literals to the generic
+  `<constant>` placeholder is a REPRESENTATION step for downstream models that cannot consume
+  literals, not an equivalence-preserving rewrite. `simplify` no longer masks; it is now the
+  equivalence loop only (search + sort to a fixpoint), sound and idempotent by construction. The
+  `mask_elementary_literals` parameter of `simplify` is removed; use the new terminal
+  `Engine.mask()` (relabel literals + one sort, no re-simplify) on `simplify`'s output when
+  placeholders are needed, and do NOT re-`simplify` a masked expression. Entangling masking with
+  the search fixpoint was also the sole cause of the former non-idempotence: masking mints a free
+  `<constant>` from a structural literal (`x - x -> 0 -> <constant>`), and re-searching could
+  fold that constant into a denominator, dropping the reachable `C = 0` the input required.
+
+### Fixed
+- **Constant folding respects the finiteness certificate.** The constant-fold fallback collapsed
+  any subtree whose operands are all `<constant>` or finite literals to a free `<constant>`, on a
+  syntactic test that assumed finite operands compose to a finite result. That is false at a pole
+  (`<constant> / 0` is +-inf/nan for every constant), so a structural zero reaching a denominator
+  could be folded to a finite free constant -- unsound (it revives a structurally zeroed term).
+  This was the one search edge that skipped the finiteness certification the rule matcher and the
+  cancellation already enforce. The fold now consults the same value-set analysis and collapses to
+  `<constant>` only when the subtree has a positive-measure finite part, keeping
+  unbounded-but-finite-a.e. folds (`1/C`, `tan C`, `cosh(C + 5)`) and refusing non-finite-a.e.
+  ones (`C / 0`, `C * inv(0)`).
+
 ## 0.8.0 (unreleased)
 
 Makes the public package produce the BEST rule sets from one command: mining now natively
diff --git a/Cargo.lock b/Cargo.lock
index ae4d08f..e409807 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -361,7 +361,7 @@ dependencies = [
 
 [[package]]
 name = "simplipy-core"
-version = "0.8.0"
+version = "0.9.0"
 dependencies = [
  "astro-float",
  "pyo3",
diff --git a/Cargo.toml b/Cargo.toml
index 7c1a5b1..b85b6c2 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "simplipy-core"
-version = "0.8.0"              # kept in lockstep with the Python package version (pyproject.toml)
+version = "0.9.0"              # kept in lockstep with the Python package version (pyproject.toml)
 edition = "2021"
 rust-version = "1.83"          # MSRV floor of the resolved tree (pyo3 0.29 requires Rust >= 1.83)
 description = "Rust inline-phase backend for the SimpliPy prefix-expression simplifier (PyO3, the simplipy._core extension)"
diff --git a/benchmarks/corpus/reference_aligned_mpl4.json b/benchmarks/corpus/reference_aligned_mpl4.json
deleted file mode 100644
index 7ee48f1..0000000
--- a/benchmarks/corpus/reference_aligned_mpl4.json
+++ /dev/null
@@ -1 +0,0 @@
-[["cos", "div4", "-", "*", "mult2", "x15", "/", "pow2", "/", "-", "x16", "x3", "*", "x14", "pow2", "x15", "*", "x3", "pow2", "x16", "x14"], ["pow1_5", "+", "tanh", "x17", "sin", "/", "x8", "pow5", "mult3", "x11"], ["*", "x16", "+", "/", "x16", "+", "x16", "x8", "*", "x16", "*", "x8", "pow1_2", "/", "/", "x8", "x16", "*", "mult5", "x16", "asin", "x8"], ["/", "pow4", "/", "-", "exp", "-", "x4", "tan", "+", "x4", "mult5", "log", "/", "x17", "-", "*", "x4", "sin", "*", "x17", "x4", "x17", "x17", "x17", "x4"], ["/", "+", "x4", "cos", "-", "<constant>", "*", "x4", "+", "x4", "+", "x5", "pow4", "x5", "x5"], ["/", "x12", "-", "-", "inv", "div2", "-", "x13", "-", "div3", "-", "+", "x10", "+", "mult2", "x8", "/", "div3", "x8", "x13", "/", "x11", "x10", "x9", "x7", "inv", "x4"], ["*", "x7", "+", "x7", "-", "+", "pow2", "*", "cosh", "x1", "/", "atan", "x7", "x7", "-", "*", "pow1_4", "x7", "+", "x1", "mult2", "x7", "x1", "log", "x7"], ["*", "exp", "x6", "*", "/", "-", "x1", "x11", "exp", "x3", "+", "<constant>", "/", "/", "neg", "*", "x13", "x16", "x10", "x12"], ["*", "x15", "-", "/", "/", "x3", "-", "x17", "x7", "x4", "mult4", "mult2", "x6"], ["-", "*", "x7", "+", "-", "x7", "x13", "+", "sinh", "div5", "x7", "/", "inv", "-", "+", "x14", "x8", "+", "x5", "x7", "mult4", "x14", "x8"], ["atanh", "+", "inv", "x9", "/", "x11", "div2", "acos", "x11"], ["*", "+", "<constant>", "x15", "+", "-", "x11", "-", "x13", "+", "x14", "x9", "*", "x11", "+", "-", "x4", "x1", "*", "x15", "+", "sinh", "x1", "*", "/", "x15", "x2", "+", "x1", "+", "x2", "x4"], ["-", "-", "*", "pow2", "x11", "-", "mult4", "x11", "<constant>", "x11", "+", "atanh", "x11", "/", "pow2", "x11", "<constant>"], ["pow1_4", "-", "x12", "cos", "-", "+", "x14", "/", "-", "div3", "x12", "/", "*", "log", "x14", "div5", "x8", "x12", "tan", "x14", "x12"], ["+", "-", "*", "x12", "x9", "mult2", "x4", "tan", "mult4", "/", "/", "/", "<constant>", "-", "-", "*", "x15", "x17", "x5", "+", "<constant>", "x9", "sinh", "x12", "x6"], ["+", "<constant>", "+", "x6", "pow5", "+", "x15", "*", "div4", "/", "x11", "+", "x1", "atanh", "x6", "pow5", "*", "x11", "/", "x15", "+", "<constant>", "mult2", "x15"], ["asinh", "*", "cos", "x8", "*", "mult2", "x8", "*", "-", "acos", "x8", "x8", "-", "log", "mult2", "sinh", "x13", "x13"], ["*", "x16", "-", "cosh", "x5", "atan", "pow3", "-", "+", "asinh", "x8", "*", "x1", "*", "x6", "/", "x15", "/", "x13", "x10", "x4"], ["*", "mult2", "x14", "-", "+", "*", "x14", "pow2", "x6", "-", "<constant>", "*", "x14", "x6", "x6"], ["*", "/", "x14", "x2", "sin", "/", "*", "x11", "/", "+", "x11", "/", "pow2", "x3", "*", "x10", "*", "x14", "*", "atan", "x8", "-", "x8", "x3", "-", "x8", "x10", "x12"], ["/", "*", "x2", "-", "+", "mult2", "x13", "*", "x13", "tanh", "+", "x13", "+", "x14", "*", "float(\"inf\")", "*", "x14", "-", "x11", "x17", "x14", "x11"], ["-", "x16", "+", "x1", "*", "atan", "x12", "/", "+", "<constant>", "+", "x12", "+", "x14", "+", "x16", "+", "*", "<constant>", "x14", "-", "/", "x2", "<constant>", "x1", "*", "pow2", "x12", "/", "x12", "x16"], ["asinh", "/", "-", "*", "x7", "+", "x4", "+", "x9", "mult3", "x14", "/", "cos", "*", "x8", "pow2", "x1", "-", "/", "/", "x1", "+", "x4", "mult2", "x1", "x14", "x6", "x14"], ["*", "x7", "+", "acos", "x15", "+", "/", "-", "mult2", "x7", "/", "mult4", "pow2", "x13", "x5", "x8", "abs", "+", "<constant>", "/", "/", "pow5", "x13", "<constant>", "*", "x13", "x5"], ["*", "x5", "/", "pow2", "x13", "/", "*", "<constant>", "acos", "*", "x16", "-", "x17", "x1", "/", "*", "x16", "*", "x2", "atan", "x6", "x14"], ["+", "mult2", "x14", "div5", "acosh", "/", "-", "mult2", "+", "mult4", "x17", "-", "x17", "x6", "-", "mult2", "x16", "x4", "mult2", "x8"], ["sinh", "log", "mult5", "x16"], ["+", "div2", "x2", "tan", "+", "x2", "+", "x7", "+", "sin", "*", "x2", "*", "x3", "x7", "/", "+", "x13", "*", "x11", "x15", "*", "div5", "x6", "+", "x4", "-", "x16", "x17"], ["pow1_5", "+", "x6", "+", "mult2", "x8", "+", "/", "x15", "<constant>", "pow5", "-", "x1", "-", "x11", "x9"], ["mult5", "-", "-", "abs", "-", "atan", "exp", "x8", "x3", "acos", "-", "x3", "+", "*", "x5", "x8", "*", "x8", "/", "acosh", "x7", "x12", "x13"], ["*", "-", "x1", "*", "x15", "-", "x15", "x17", "/", "/", "pow1_2", "x15", "/", "x17", "pow2", "x15", "log", "pow3", "/", "/", "x14", "-", "/", "exp", "x14", "x1", "x14", "pow5", "x17"], ["-", "x14", "tan", "-", "/", "acos", "+", "div3", "-", "neg", "x14", "x16", "-", "+", "x16", "acosh", "abs", "x14", "/", "+", "asinh", "x14", "tanh", "x16", "x16", "x14", "x16"], ["-", "asinh", "neg", "+", "sin", "x11", "div5", "/", "cosh", "x12", "+", "x12", "-", "asinh", "sin", "x12", "cosh", "x11", "x15"], ["neg", "/", "/", "div5", "log", "x13", "x17", "pow2", "pow1_2", "+", "x7", "+", "div4", "x14", "/", "+", "x11", "*", "x6", "x8", "*", "x4", "mult2", "x5"], ["*", "-", "inv", "x15", "x11", "*", "asin", "+", "x11", "mult5", "x15", "-", "abs", "x11", "+", "x11", "x15"], ["*", "/", "x3", "log", "x15", "+", "*", "x6", "+", "<constant>", "x13", "/", "-", "x8", "+", "x7", "/", "x5", "*", "x12", "-", "pow3", "x2", "-", "x11", "x17", "x1"], ["*", "x14", "*", "x6", "+", "x14", "-", "+", "x7", "*", "x7", "/", "+", "x14", "+", "x7", "x8", "-", "x6", "abs", "x14", "+", "*", "x8", "cos", "x2", "pow1_3", "-", "x7", "x8"], ["/", "*", "x12", "+", "x16", "-", "x13", "-", "<constant>", "x5", "-", "x6", "+", "x5", "x8"], ["+", "-", "x5", "inv", "mult2", "x13", "/", "pow1_3", "/", "div5", "div4", "x5", "asinh", "+", "pow1_5", "x13", "/", "x13", "x12", "*", "x12", "x13"], ["+", "x8", "-", "div2", "/", "/", "x8", "pow2", "x6", "-", "pow2", "+", "x8", "asinh", "x6", "acosh", "x8", "+", "div3", "x6", "-", "x6", "pow1_3", "cosh", "x8"], ["*", "pow2", "x12", "*", "pow1_2", "pow1_3", "x12", "+", "x12", "div3", "/", "x12", "*", "pow3", "x12", "-", "x12", "cos", "x12"], ["*", "x6", "log", "-", "x6", "*", "-", "div3", "exp", "asinh", "x6", "x6", "-", "mult2", "x6", "+", "<constant>", "*", "x6", "pow3", "pow1_4", "x6"], ["*", "sin", "x5", "*", "asinh", "-", "tan", "x14", "x2", "-", "x12", "mult2", "-", "x9", "-", "x8", "-", "x4", "/", "x14", "x8"], ["+", "-", "*", "x10", "atan", "x10", "<constant>", "-", "/", "acosh", "-", "/", "sinh", "/", "x11", "<constant>", "*", "x10", "x4", "pow1_2", "x4", "x11", "x3"], ["*", "-", "pow1_4", "x13", "x2", "pow1_2", "+", "x1", "+", "x14", "div4", "exp", "div4", "tan", "-", "x9", "/", "+", "/", "x16", "x6", "-", "/", "x3", "x7", "x1", "x10"], ["abs", "*", "x2", "neg", "atan", "+", "mult2", "/", "x2", "pow2", "*", "x15", "pow1_5", "x2", "*", "pow2", "x2", "/", "*", "x14", "/", "x15", "x17", "+", "<constant>", "+", "x15", "x2"], ["+", "x11", "/", "-", "x5", "x11", "exp", "tanh", "x5"], ["-", "/", "/", "*", "x6", "x7", "-", "+", "x5", "mult5", "x7", "x17", "/", "x10", "+", "x7", "/", "*", "x12", "mult3", "*", "x6", "*", "x7", "x9", "x17", "x4"], ["*", "x9", "div2", "/", "x2", "*", "x9", "+", "mult4", "atan", "x2", "-", "pow2", "x2", "x2"], ["-", "-", "/", "abs", "mult3", "/", "x15", "/", "/", "-", "exp", "-", "x2", "x3", "x16", "<constant>", "x1", "*", "<constant>", "*", "x1", "x14", "x8", "*", "x2", "x8"], ["+", "asinh", "mult2", "x7", "/", "x4", "/", "acos", "-", "-", "*", "-", "x13", "log", "x13", "-", "x2", "/", "x5", "x8", "x7", "x8", "x13"], ["*", "exp", "x1", "-", "neg", "atanh", "*", "x13", "atanh", "-", "+", "x11", "pow4", "x11", "x7", "tan", "exp", "x10"], ["pow1_2", "-", "x1", "-", "-", "x17", "/", "tan", "+", "x5", "+", "sinh", "x4", "sinh", "*", "x13", "+", "x17", "/", "x2", "x16", "x14", "pow3", "-", "+", "x14", "-", "x3", "x6", "x17"], ["*", "atanh", "x12", "-", "x14", "-", "pow1_3", "-", "mult2", "x1", "*", "x12", "+", "x12", "-", "div5", "x16", "+", "div3", "x1", "mult4", "x14", "x12"], ["-", "/", "x9", "*", "x11", "-", "-", "/", "x1", "x8", "+", "x10", "+", "x6", "/", "x3", "x4", "mult4", "/", "div3", "x14", "-", "*", "x5", "-", "<constant>", "x14", "x6", "x2"], ["mult2", "*", "x7", "*", "+", "x11", "x3", "/", "+", "x7", "/", "/", "atanh", "x7", "*", "<constant>", "*", "x13", "x2", "x5", "x9"], ["-", "*", "<constant>", "*", "x9", "/", "float(\"inf\")", "*", "x4", "abs", "x9", "x2"], ["-", "+", "x12", "+", "x7", "+", "atanh", "x10", "*", "x5", "+", "<constant>", "+", "/", "<constant>", "x11", "-", "mult2", "x4", "x6", "/", "+", "x4", "/", "/", "x17", "x11", "pow2", "x2", "<constant>"], ["-", "+", "x12", "+", "x2", "/", "-", "x12", "pow3", "+", "x2", "-", "*", "x9", "pow2", "x10", "pow2", "x11", "x11", "cosh", "x10"], ["<constant>"], ["*", "+", "x8", "pow5", "x6", "/", "/", "x14", "*", "x17", "/", "-", "+", "x4", "asinh", "-", "x10", "x7", "x15", "+", "*", "x12", "x9", "cos", "-", "+", "x5", "*", "x3", "x4", "x2", "<constant>"], ["-", "*", "x6", "*", "+", "x11", "/", "x9", "x11", "/", "/", "pow2", "x12", "pow2", "x6", "+", "x12", "+", "x8", "x9", "*", "x11", "*", "x6", "mult3", "x9"], ["+", "/", "x1", "x13", "pow3", "*", "x1", "*", "acosh", "x13", "-", "*", "x1", "-", "x13", "inv", "x13", "mult2", "x13"], ["+", "mult2", "x15", "+", "/", "sin", "/", "x9", "x3", "mult3", "+", "mult4", "x7", "/", "x11", "x5", "*", "+", "x17", "*", "<constant>", "x2", "/", "x4", "-", "neg", "x16", "x1"], ["neg", "atan", "pow3", "*", "x4", "abs", "x4"], ["/", "pow1_4", "x7", "*", "x4", "abs", "+", "x16", "+", "*", "x15", "*", "x16", "x8", "/", "pow4", "x8", "/", "x7", "-", "x10", "acosh", "x15"], ["-", "div5", "/", "/", "x10", "sin", "mult5", "*", "x10", "/", "mult3", "+", "x10", "*", "x12", "div4", "x1", "pow1_4", "x9", "-", "pow4", "x17", "x1", "x17"], ["cosh", "/", "-", "-", "+", "x6", "*", "x9", "-", "+", "x15", "*", "<constant>", "x5", "x2", "*", "x1", "*", "x17", "+", "x11", "atan", "inv", "exp", "x9", "x14", "x4"], ["*", "atan", "x16", "*", "-", "x6", "x3", "/", "+", "*", "x12", "x14", "-", "x10", "/", "x17", "+", "-", "x8", "x2", "*", "x9", "-", "log", "x4", "x2", "pow4", "x11"], ["+", "x9", "*", "x10", "pow1_4", "atan", "*", "<constant>", "/", "x10", "x8"], ["-", "neg", "x5", "abs", "+", "mult5", "x5", "+", "pow2", "x5", "-", "x5", "*", "mult2", "pow2", "x5", "/", "-", "x5", "pow3", "x5", "x5"], ["*", "atan", "sin", "cos", "*", "x1", "x5", "+", "x8", "-", "/", "-", "x11", "x12", "x3", "*", "x15", "+", "x11", "*", "x5", "x9"], ["+", "inv", "x16", "*", "x14", "/", "x6", "asinh", "*", "x12", "*", "x15", "/", "-", "x1", "*", "x11", "x4", "<constant>"], ["+", "pow2", "x11", "/", "+", "<constant>", "mult5", "+", "mult2", "x5", "-", "-", "sinh", "pow2", "x6", "/", "<constant>", "x11", "cos", "exp", "cosh", "x5", "+", "<constant>", "x11"], ["*", "pow1_3", "x15", "+", "x12", "+", "x15", "tanh", "/", "x15", "/", "+", "x11", "*", "x15", "-", "+", "<constant>", "x12", "x15", "x12"], ["/", "x14", "/", "+", "<constant>", "-", "/", "mult5", "x17", "x12", "x14", "*", "x15", "pow1_3", "div3", "+", "x2", "+", "mult2", "x6", "inv", "+", "x12", "+", "x15", "-", "x3", "x16"], ["-", "x16", "+", "x13", "+", "pow2", "x16", "/", "x15", "/", "div3", "mult4", "x15", "x16"], ["/", "acos", "+", "x6", "/", "<constant>", "*", "/", "-", "x1", "asinh", "abs", "*", "x17", "atanh", "x5", "x3", "pow1_3", "+", "x9", "-", "tan", "/", "/", "x2", "x16", "x10", "x15", "x4"], ["+", "*", "div5", "x9", "+", "x15", "-", "x9", "/", "x9", "acos", "x9", "*", "x9", "+", "x15", "*", "-", "asinh", "x9", "x9", "/", "sin", "mult3", "x15", "pow2", "x15"], ["div4", "-", "mult2", "x1", "/", "atan", "x4", "*", "exp", "/", "<constant>", "x9", "+", "x7", "+", "x8", "-", "x9", "<constant>"], ["*", "x7", "-", "-", "x12", "-", "*", "x8", "-", "*", "<constant>", "tan", "x7", "pow4", "-", "<constant>", "pow3", "x8", "pow1_4", "/", "-", "<constant>", "-", "x16", "x7", "x16", "x8"], ["/", "x16", "-", "x3", "*", "x12", "*", "+", "x10", "pow1_5", "*", "x16", "mult4", "div3", "x2", "acos", "cos", "+", "div5", "*", "x15", "x9", "tan", "*", "<constant>", "*", "x12", "x13"], ["/", "/", "/", "/", "-", "x6", "/", "x6", "x15", "tan", "pow3", "tan", "*", "x10", "*", "x6", "-", "-", "x5", "x16", "x12", "+", "cosh", "x1", "mult3", "x4", "x12", "+", "x5", "x9"], ["+", "x16", "+", "-", "x3", "pow3", "/", "x17", "-", "*", "x10", "x8", "+", "x1", "x8", "/", "+", "/", "x12", "div3", "x17", "-", "x7", "-", "x3", "-", "x12", "x9", "+", "x9", "/", "x12", "x9"], ["+", "x17", "*", "x17", "+", "x17", "sin", "+", "mult3", "x17", "*", "mult2", "x17", "/", "pow2", "x17", "<constant>"], ["+", "/", "acosh", "x8", "tan", "x4", "-", "x4", "/", "pow4", "+", "<constant>", "log", "+", "<constant>", "x14", "pow3", "x4"], ["/", "mult2", "pow1_3", "+", "pow1_4", "x12", "-", "mult2", "x12", "inv", "pow1_3", "*", "x3", "*", "acosh", "x6", "-", "x3", "exp", "x12", "x3"], ["/", "<constant>", "/", "x4", "-", "x14", "/", "/", "sin", "/", "x14", "x4", "*", "x10", "+", "x16", "pow1_3", "x7", "/", "sinh", "x7", "+", "x1", "+", "x16", "mult2", "abs", "x5"], ["/", "*", "x16", "x5", "/", "+", "x16", "+", "mult2", "x9", "*", "x3", "x5", "div5", "/", "x5", "/", "/", "/", "x9", "x10", "div2", "x6", "pow1_5", "x10"], ["+", "*", "x4", "x8", "/", "log", "pow1_3", "+", "x8", "-", "x11", "*", "x8", "/", "/", "x5", "x6", "acosh", "x3", "/", "div4", "div5", "x4", "x12"], ["div4", "-", "mult2", "x7", "-", "<constant>", "-", "/", "pow2", "x7", "neg", "cosh", "x7", "*", "x7", "-", "atanh", "x7", "x7"], ["*", "atan", "x8", "*", "pow1_2", "x8", "*", "pow3", "x8", "div3", "div4", "div3", "tanh", "x8"], ["-", "pow4", "acos", "+", "x13", "mult4", "pow3", "x13", "mult4", "x13"], ["*", "x3", "exp", "/", "tanh", "pow5", "pow4", "log", "x11", "+", "<constant>", "+", "x16", "*", "tanh", "atan", "x16", "-", "acosh", "/", "pow1_4", "x11", "x3", "x11"], ["acos", "asinh", "pow1_2", "/", "-", "x14", "+", "x4", "+", "pow3", "x13", "mult4", "x14", "neg", "/", "x14", "x1"], ["/", "x8", "-", "-", "+", "x12", "-", "/", "x12", "mult3", "*", "x14", "div3", "x8", "*", "x10", "-", "*", "x2", "x8", "mult4", "x1", "x10", "x2"], ["x10"], ["pow1_5", "/", "cos", "pow3", "x5", "+", "pow5", "x6", "mult5", "/", "inv", "*", "x17", "/", "<constant>", "x7", "+", "x10", "pow1_4", "-", "x3", "<constant>"], ["cosh", "/", "-", "<constant>", "pow1_3", "x14", "pow5", "*", "x17", "*", "mult5", "x14", "sinh", "+", "x14", "-", "mult5", "*", "x14", "x17", "mult3", "x14"], ["+", "x15", "+", "cos", "x14", "+", "-", "x1", "/", "*", "x4", "-", "asinh", "x9", "x7", "x14", "/", "-", "x3", "mult2", "x6", "*", "x16", "/", "x14", "x17"], ["*", "x11", "-", "/", "asinh", "x2", "atanh", "pow1_3", "+", "x11", "x2", "+", "x14", "*", "cos", "x14", "sin", "log", "acosh", "acosh", "/", "cosh", "x9", "x5"], ["/", "div4", "-", "pow1_5", "*", "x17", "*", "/", "x13", "x2", "tan", "-", "x9", "x13", "/", "pow5", "x17", "x6", "x17"], ["*", "acosh", "x14", "sin", "/", "+", "pow3", "x11", "+", "pow1_5", "mult4", "x6", "/", "*", "-", "x14", "<constant>", "div3", "pow1_3", "+", "x12", "x17", "x11", "x12"], ["-", "x5", "*", "x11", "+", "*", "x5", "+", "x11", "x5", "*", "x11", "asin", "*", "x11", "+", "<constant>", "*", "-", "pow1_2", "x11", "x11", "/", "atan", "x5", "x11"], ["+", "*", "x6", "-", "x6", "div2", "x12", "/", "*", "atan", "x12", "atan", "pow2", "mult2", "x15", "/", "x15", "atanh", "x6"], ["*", "pow2", "x10", "*", "+", "x4", "*", "<constant>", "+", "x10", "x5", "/", "acosh", "*", "x10", "sin", "pow1_2", "/", "*", "x10", "pow1_2", "x5", "<constant>", "x4"], ["div3", "-", "+", "<constant>", "pow4", "x16", "*", "x14", "*", "mult5", "x16", "-", "+", "x10", "+", "x6", "/", "x13", "x5", "+", "mult2", "x7", "*", "x15", "x4"], ["+", "x5", "*", "atanh", "x14", "*", "pow1_2", "+", "x13", "+", "x4", "cosh", "x1", "-", "mult5", "x4", "/", "x12", "/", "*", "x3", "*", "abs", "x3", "pow2", "x5", "x4"], ["-", "-", "/", "*", "x11", "neg", "x14", "x3", "<constant>", "*", "x10", "x7"], ["/", "sin", "+", "x11", "/", "*", "-", "x7", "x2", "/", "x2", "cosh", "/", "pow1_5", "x13", "/", "x13", "+", "x11", "x8", "x8", "x7"], ["+", "x9", "+", "-", "x4", "cosh", "x9", "asin", "+", "x9", "+", "mult3", "pow4", "inv", "x9", "/", "-", "x4", "x9", "pow2", "x9"], ["-", "/", "x5", "x1", "*", "mult4", "x12", "*", "pow1_5", "pow1_5", "x14", "*", "-", "x9", "tan", "-", "x9", "x5", "mult3", "*", "x14", "/", "+", "<constant>", "x8", "/", "atanh", "x9", "x1"], ["/", "*", "acos", "x17", "+", "x9", "*", "x8", "tan", "pow1_5", "div2", "mult5", "x5", "atanh", "x15"], ["/", "acosh", "x13", "*", "x1", "+", "x3", "/", "+", "x9", "mult5", "*", "x1", "*", "x7", "tan", "-", "x2", "<constant>", "asin", "acos", "asinh", "x13"], ["+", "/", "-", "x14", "x2", "*", "x16", "atan", "x2", "-", "pow2", "x11", "+", "x11", "+", "x2", "+", "acosh", "x2", "asinh", "x2"], ["*", "x1", "pow2", "/", "/", "x14", "mult2", "x7", "+", "mult2", "x6", "-", "-", "*", "x15", "x8", "*", "x10", "atanh", "x1", "*", "x12", "*", "x14", "x15"], ["+", "exp", "div3", "x17", "sinh", "-", "/", "x15", "neg", "+", "*", "x6", "+", "x12", "x3", "-", "/", "cos", "x9", "x16", "<constant>", "x2"], ["/", "x6", "div5", "+", "x11", "pow2", "atanh", "*", "+", "<constant>", "x6", "acos", "pow1_4", "+", "x3", "log", "*", "x11", "+", "sinh", "x7", "-", "x6", "+", "<constant>", "x3"], ["exp", "-", "x13", "/", "+", "/", "x13", "x9", "/", "/", "div5", "x10", "pow1_4", "log", "-", "x8", "mult2", "-", "x15", "mult2", "sin", "x17", "x5", "x14"], ["/", "div5", "x2", "/", "*", "x8", "-", "x11", "-", "-", "acosh", "x3", "acos", "x16", "<constant>", "div4", "x12"], ["neg", "asin", "-", "x3", "div3", "/", "*", "x13", "-", "x17", "x13", "*", "x7", "-", "*", "x4", "x5", "x15"], ["+", "<constant>", "atanh", "pow1_2", "pow1_5", "*", "<constant>", "pow1_2", "-", "atanh", "pow4", "-", "div4", "cosh", "x17", "x17", "pow3", "x17"], ["+", "x13", "*", "x13", "+", "pow1_2", "+", "x5", "/", "x7", "x9", "*", "acos", "x12", "-", "x8", "mult5", "/", "/", "x9", "x8", "x7"], ["+", "-", "x3", "x16", "div5", "div2", "pow1_5", "mult2", "-", "mult5", "x10", "x3"], ["+", "x3", "-", "/", "x13", "x3", "div3", "-", "-", "div4", "/", "cos", "x3", "x3", "/", "pow3", "mult2", "x13", "x13", "cos", "x3"], ["*", "x17", "sinh", "+", "x13", "+", "x17", "-", "x3", "pow1_2", "*", "x13", "*", "div5", "+", "x13", "sin", "x13", "-", "x17", "/", "x13", "+", "x13", "/", "div2", "x13", "abs", "x13"], ["*", "abs", "x12", "sinh", "div4", "/", "+", "div5", "*", "x5", "x9", "acos", "-", "exp", "x17", "*", "<constant>", "-", "x4", "x8", "x6"], ["atanh", "exp", "+", "x1", "*", "x7", "/", "+", "x16", "x7", "-", "pow1_3", "abs", "*", "x16", "-", "+", "x15", "acos", "/", "x14", "x16", "<constant>", "cosh", "x11"], ["/", "*", "x14", "mult2", "x4", "*", "x10", "-", "*", "x14", "-", "-", "neg", "x14", "x10", "/", "x4", "/", "x10", "-", "/", "x4", "x14", "x14", "<constant>"], ["atanh", "/", "+", "sinh", "pow3", "x13", "/", "x10", "sinh", "+", "/", "x15", "*", "x17", "x3", "pow1_4", "/", "+", "x1", "+", "x4", "x6", "/", "x5", "x8", "x16"], ["-", "/", "-", "/", "x7", "/", "/", "-", "/", "x3", "x7", "pow5", "x6", "neg", "x12", "pow3", "-", "x5", "x1", "x2", "asinh", "x9", "*", "x17", "*", "div2", "x16", "/", "x14", "x16"], ["*", "pow1_4", "x7", "/", "pow4", "asin", "+", "x16", "/", "+", "x12", "*", "x11", "div3", "x8", "x15", "-", "+", "div5", "x1", "/", "x5", "*", "+", "x10", "x17", "/", "x14", "x6", "x4"], ["pow1_4", "+", "x10", "/", "mult2", "x10", "+", "<constant>", "pow2", "x10"], ["-", "/", "x6", "x8", "/", "+", "-", "pow1_4", "x1", "x3", "atanh", "*", "/", "x7", "exp", "x16", "-", "x6", "/", "x17", "x13", "+", "x5", "pow1_2", "sinh", "pow1_4", "x9"], ["/", "x12", "-", "sinh", "atan", "-", "*", "x7", "*", "cos", "*", "x14", "x3", "/", "/", "x3", "log", "x6", "x17", "-", "x6", "x17", "-", "*", "<constant>", "x15", "<constant>"], ["-", "pow1_4", "-", "log", "/", "/", "-", "x5", "x2", "x16", "-", "/", "x4", "neg", "x11", "+", "x12", "atanh", "div4", "x3", "x1", "div4", "x15"], ["+", "x8", "div5", "*", "x13", "+", "<constant>", "+", "*", "-", "x4", "x2", "sin", "-", "x7", "x6", "sin", "+", "x10", "-", "x5", "sinh", "-", "x14", "*", "x11", "*", "x12", "*", "x15", "x17"], ["acosh", "+", "*", "pow3", "x12", "-", "abs", "atanh", "+", "x10", "+", "x12", "cosh", "x11", "<constant>", "*", "/", "x2", "<constant>", "/", "asinh", "x2", "acos", "*", "x10", "/", "x12", "x2"], ["/", "-", "+", "x4", "x7", "*", "x17", "*", "x3", "tan", "x8", "x17"], ["*", "x3", "-", "mult2", "x1", "mult4", "exp", "+", "x16", "*", "x9", "sinh", "+", "-", "x13", "x2", "*", "acos", "x4", "pow2", "-", "*", "x15", "mult2", "+", "x10", "x5", "x17"], ["atanh", "*", "+", "x13", "x4", "-", "-", "x13", "pow2", "x4", "inv", "x4"], ["*", "x17", "*", "-", "x17", "/", "x5", "*", "x17", "x6", "+", "x8", "+", "pow3", "x17", "/", "asin", "div5", "x13", "<constant>"], ["+", "/", "pow2", "x4", "x3", "*", "x12", "+", "x1", "-", "/", "x12", "x1", "+", "x4", "-", "-", "x10", "*", "x4", "-", "div3", "x1", "atanh", "pow2", "+", "x10", "x12", "asinh", "x10"], ["+", "x13", "+", "x8", "*", "mult3", "/", "x7", "x15", "mult5", "+", "x3", "div2", "x8"], ["+", "x11", "+", "acosh", "x13", "/", "asinh", "mult5", "/", "x7", "*", "<constant>", "x16", "+", "<constant>", "/", "x1", "asinh", "x17"], ["+", "x11", "+", "x12", "+", "x16", "+", "x4", "+", "mult2", "x1", "+", "mult2", "x13", "*", "x16", "+", "x4", "pow4", "+", "x16", "x4"], ["*", "x5", "*", "div2", "cos", "x11", "pow1_2", "+", "x11", "+", "x5", "+", "atanh", "mult2", "x5", "/", "x11", "pow1_4", "mult3", "pow2", "x5"], ["+", "/", "x5", "x7", "abs", "-", "-", "x12", "x2", "-", "x13", "x10"], ["*", "x10", "sinh", "mult4", "asinh", "/", "sinh", "x10", "-", "x14", "sinh", "+", "x10", "x14"], ["/", "x10", "*", "x13", "*", "acosh", "*", "x2", "x8", "/", "+", "x3", "+", "x6", "+", "/", "x9", "x11", "-", "+", "x5", "pow2", "x1", "/", "x1", "x14", "mult5", "+", "x13", "pow2", "x9"], ["cosh", "*", "x17", "*", "x4", "*", "neg", "*", "x17", "x4", "+", "x17", "+", "x4", "+", "pow1_2", "x17", "pow5", "div5", "x4"], ["+", "*", "x13", "-", "x14", "/", "x7", "x17", "/", "x2", "*", "+", "x7", "x8", "+", "x8", "-", "-", "x7", "x17", "x14"], ["-", "x13", "/", "x13", "-", "mult2", "x1", "*", "x13", "+", "x13", "/", "*", "mult2", "x1", "/", "x13", "x1", "-", "+", "x13", "mult2", "x1", "/", "-", "neg", "x1", "x13", "mult2", "x13"], ["/", "+", "cosh", "x17", "/", "*", "x4", "/", "-", "x16", "x9", "x11", "x10", "-", "tanh", "+", "sin", "x2", "atanh", "pow4", "x11", "/", "*", "<constant>", "x6", "asin", "*", "x13", "x15"], ["-", "*", "<constant>", "/", "x3", "-", "/", "pow4", "+", "x12", "*", "x16", "x7", "acos", "pow4", "x2", "+", "x11", "+", "x9", "*", "x16", "exp", "cos", "x14", "x15"], ["+", "*", "x1", "*", "x9", "pow4", "x9", "*", "x14", "+", "pow1_5", "x1", "*", "x14", "+", "x1", "asinh", "x1"], ["pow3", "/", "x5", "*", "log", "asinh", "x4", "+", "<constant>", "+", "x4", "+", "pow1_5", "x4", "/", "*", "x4", "-", "x5", "x4", "x5"], ["/", "/", "-", "/", "-", "sinh", "x15", "x15", "mult5", "x8", "x17", "pow3", "sin", "pow2", "x17", "*", "x15", "mult3", "mult4", "pow2", "mult4", "x15"], ["-", "/", "/", "+", "x7", "atanh", "x7", "tanh", "x7", "acos", "sinh", "sinh", "x7", "*", "x7", "-", "x7", "pow3", "x7"], ["/", "x7", "*", "pow2", "x7", "*", "div3", "+", "x7", "pow2", "x7", "sin", "tanh", "pow4", "pow2", "x7"], ["+", "x13", "*", "+", "x13", "mult4", "x2", "/", "x2", "/", "/", "*", "exp", "x2", "-", "pow1_5", "tan", "div5", "x13", "x2", "-", "pow1_4", "x2", "x2", "x13"], ["+", "*", "x14", "+", "x2", "-", "x12", "x14", "*", "x14", "mult4", "/", "+", "*", "x14", "x2", "*", "x2", "/", "sinh", "x14", "+", "x12", "*", "x12", "div5", "x2", "x2"], ["pow1_2", "-", "cos", "/", "*", "x15", "x9", "-", "+", "x16", "x8", "x7", "exp", "*", "x8", "-", "/", "x3", "/", "div5", "x8", "/", "x10", "+", "x6", "*", "x11", "x13", "inv", "x12"], ["/", "/", "/", "mult3", "x16", "mult5", "x4", "div4", "*", "x4", "cos", "pow1_3", "-", "mult2", "x4", "+", "x16", "/", "x16", "+", "x4", "+", "asin", "x4", "mult4", "x4", "x16"], ["pow5", "+", "x10", "/", "div4", "x10", "/", "x16", "*", "x11", "-", "mult3", "+", "x10", "x11", "x10"], ["/", "x5", "-", "*", "+", "mult2", "x5", "cos", "atanh", "x5", "+", "x5", "tanh", "/", "+", "<constant>", "x5", "x5", "asinh", "x5"], ["log", "+", "mult2", "x9", "-", "pow4", "*", "x9", "sinh", "x9", "+", "pow2", "x9", "*", "x9", "pow3", "pow2", "x9"], ["*", "x15", "div3", "/", "*", "x12", "+", "x9", "/", "acos", "+", "x4", "*", "x17", "x9", "x11", "/", "/", "x14", "x16", "pow5", "*", "x4", "+", "x12", "+", "x14", "cos", "x15"], ["-", "+", "x1", "*", "<constant>", "cosh", "*", "+", "x7", "*", "x14", "log", "x16", "/", "inv", "x5", "-", "x8", "asin", "x11", "x9"], ["mult2", "pow3", "*", "tan", "mult2", "x10", "/", "cosh", "x10", "*", "x10", "tanh", "*", "x10", "pow4", "mult2", "x10"], ["*", "x12", "*", "x14", "*", "x15", "*", "x8", "*", "/", "x4", "*", "x10", "pow1_3", "x1", "+", "/", "x5", "x14", "-", "-", "/", "x5", "x15", "x8", "*", "x1", "x15"], ["/", "-", "pow4", "+", "x1", "+", "x16", "-", "mult3", "+", "x11", "div2", "-", "x5", "pow1_3", "x9", "*", "x10", "x12", "x12", "x7"], ["*", "x11", "*", "-", "/", "x16", "x13", "x7", "+", "<constant>", "*", "x1", "+", "x17", "+", "-", "x5", "x16", "inv", "*", "<constant>", "*", "x10", "*", "div3", "x6", "-", "*", "x13", "x7", "x16"], ["*", "-", "x12", "*", "x12", "/", "x7", "x2", "/", "/", "+", "x17", "-", "x11", "x7", "-", "*", "sinh", "x11", "/", "x12", "/", "x5", "x7", "x1", "x5"], ["+", "x11", "+", "x13", "+", "x14", "+", "x4", "-", "x6", "*", "x5", "+", "<constant>", "+", "x12", "x17"], ["+", "asin", "+", "x14", "/", "acos", "x9", "cos", "pow2", "x11", "/", "*", "<constant>", "pow1_3", "x1", "*", "x2", "*", "x3", "*", "x4", "x6"], ["/", "/", "x8", "x15", "pow1_3", "+", "x11", "/", "x9", "*", "x3", "+", "x13", "div2", "asin", "+", "/", "x16", "x17", "/", "mult5", "atanh", "/", "pow5", "x14", "*", "x15", "x4", "x1"], ["div5", "*", "x9", "*", "+", "x9", "asin", "div3", "pow2", "x9", "pow2", "pow4", "pow1_3", "mult2", "+", "mult2", "x9", "sinh", "x9"], ["sinh", "+", "-", "x4", "*", "<constant>", "*", "x11", "div5", "x10", "*", "x13", "*", "x15", "*", "x5", "*", "x7", "*", "x8", "-", "x6", "x16"], ["+", "-", "<constant>", "x9", "+", "/", "<constant>", "x9", "/", "x9", "-", "/", "acos", "x9", "div3", "mult2", "x9", "x9"], ["+", "x12", "+", "pow5", "x1", "/", "/", "-", "*", "x1", "x12", "mult4", "sin", "*", "x1", "*", "x12", "*", "tanh", "x1", "exp", "x12", "tan", "x1", "x1"], ["pow1_2", "-", "x5", "*", "pow3", "*", "x3", "mult2", "/", "tanh", "x12", "+", "x11", "x13", "/", "x13", "+", "x11", "mult2", "-", "/", "pow5", "x9", "x3", "x1"], ["*", "x7", "/", "pow2", "x10", "/", "x11", "*", "x16", "*", "x3", "atan", "mult4", "+", "x10", "+", "pow3", "/", "x7", "x10", "mult2", "/", "x7", "pow2", "-", "x3", "x10"], ["acos", "/", "+", "pow2", "x15", "/", "x15", "-", "/", "x15", "div2", "mult3", "x2", "x15", "/", "x15", "-", "x2", "asinh", "+", "x2", "pow1_4", "x2"], ["+", "x1", "+", "x9", "+", "acos", "x1", "/", "+", "x1", "/", "x1", "x9", "-", "x1", "div3", "mult2", "x1"], ["cosh", "-", "x9", "+", "-", "-", "x7", "<constant>", "<constant>", "/", "tanh", "*", "/", "x7", "+", "<constant>", "x10", "-", "x14", "/", "+", "x7", "/", "x10", "*", "<constant>", "/", "x17", "x9", "x10", "x14"], ["*", "x14", "*", "x7", "*", "x9", "+", "*", "x7", "x9", "-", "/", "mult5", "cos", "x8", "-", "x8", "x9", "sinh", "x16"], ["*", "x9", "tanh", "-", "pow1_2", "x12", "+", "<constant>", "*", "x10", "*", "x14", "*", "x8", "-", "x9", "/", "<constant>", "-", "+", "<constant>", "*", "<constant>", "x2", "pow5", "x3"], ["/", "sin", "x13", "cos", "*", "x10", "-", "x10", "*", "x13", "-", "x13", "atan", "x13"], ["-", "-", "x2", "-", "/", "pow3", "+", "x14", "-", "asinh", "/", "x12", "tan", "x14", "*", "x12", "asin", "-", "x12", "x14", "+", "x12", "x2", "x14", "atan", "x12"], ["pow1_2", "*", "+", "x5", "/", "x16", "x13", "mult4", "-", "x15", "*", "pow2", "x5", "tanh", "/", "+", "x13", "div4", "x15", "x8"], ["/", "mult3", "/", "x13", "/", "-", "-", "mult2", "x4", "x13", "+", "div4", "x4", "mult2", "x4", "x4", "log", "pow1_4", "x4"], ["abs", "/", "tan", "/", "x6", "-", "/", "pow2", "x12", "x10", "x2", "/", "pow1_4", "x7", "x2"], ["+", "x16", "/", "cosh", "+", "x4", "+", "exp", "x11", "+", "-", "<constant>", "x1", "-", "mult3", "-", "x3", "pow2", "pow5", "x7", "x11", "x3"], ["/", "+", "<constant>", "+", "x12", "+", "x13", "+", "x14", "mult2", "x2", "sinh", "x12"], ["asinh", "-", "mult2", "x9", "pow2", "acos", "-", "-", "x9", "-", "pow2", "x9", "acos", "x9", "abs", "x9"], ["*", "<constant>", "*", "/", "x5", "div5", "-", "pow1_2", "x2", "/", "x7", "<constant>", "pow1_4", "-", "-", "x7", "log", "/", "x5", "x2", "pow2", "x5"], ["pow1_2", "*", "x10", "+", "x8", "*", "x12", "*", "+", "x13", "/", "x16", "*", "x15", "x8", "exp", "div3", "div4", "-", "x3", "-", "+", "x14", "mult5", "x17", "<constant>"], ["*", "x17", "/", "sinh", "pow3", "+", "x16", "/", "x17", "x16", "*", "pow4", "x17", "pow4", "*", "x17", "+", "x16", "div4", "x17"], ["-", "sin", "-", "-", "x2", "atan", "/", "x7", "x11", "*", "x12", "div2", "x2", "+", "x7", "*", "x12", "x7"], ["*", "-", "+", "x2", "mult2", "x5", "<constant>", "+", "-", "pow3", "+", "<constant>", "x2", "<constant>", "/", "-", "mult5", "/", "inv", "*", "x2", "x5", "x2", "x5", "<constant>"], ["*", "/", "x16", "x4", "-", "+", "x11", "x16", "cos", "-", "/", "pow1_3", "x4", "*", "atanh", "x16", "+", "x4", "-", "exp", "x11", "atan", "-", "+", "x4", "div4", "x16", "x16", "x16"], ["+", "x16", "+", "div3", "x16", "div4", "x16"], ["*", "+", "x8", "*", "x12", "/", "<constant>", "x5", "-", "<constant>", "/", "/", "+", "x5", "/", "+", "<constant>", "x5", "mult3", "mult2", "x12", "<constant>", "x5"], ["*", "pow2", "x12", "+", "mult2", "pow2", "x12", "asin", "*", "x12", "-", "/", "tan", "x12", "x12", "*", "x12", "-", "pow5", "x12", "x12"], ["-", "pow4", "*", "x14", "+", "x12", "-", "+", "x11", "*", "<constant>", "x8", "x1", "mult5", "x1"], ["abs", "/", "/", "+", "<constant>", "x5", "x5", "neg", "x5"], ["-", "/", "mult3", "mult2", "x5", "-", "+", "x14", "x15", "-", "pow1_4", "x8", "*", "x6", "-", "-", "x11", "-", "x17", "*", "x13", "x7", "pow5", "/", "tanh", "x16", "+", "x11", "x3", "x9"], ["+", "sinh", "x3", "-", "-", "log", "*", "x17", "*", "/", "x9", "x4", "+", "x12", "/", "/", "x15", "x1", "x16", "x7", "abs", "-", "-", "<constant>", "x11", "-", "x13", "x8"], ["+", "x13", "-", "cos", "x13", "x14"], ["+", "inv", "cos", "asin", "sin", "x9", "-", "neg", "x9", "pow3", "atanh", "inv", "x9"], ["+", "x6", "*", "/", "tanh", "x1", "x6", "+", "div2", "x6", "-", "x1", "mult4", "/", "x5", "*", "x1", "x6"], ["div5", "-", "asin", "*", "sinh", "x14", "+", "x1", "+", "x14", "acos", "*", "x1", "*", "x14", "pow1_5", "x1", "*", "float(\"inf\")", "+", "x14", "mult2", "x1"], ["pow4", "div2", "*", "x10", "*", "x4", "atanh", "-", "x12", "+", "-", "x16", "*", "x4", "+", "x12", "/", "x14", "x5", "*", "+", "x4", "pow3", "x15", "+", "<constant>", "+", "x10", "x3"], ["div3", "*", "pow2", "x2", "/", "-", "/", "x13", "mult4", "x14", "x13", "*", "+", "<constant>", "x17", "/", "pow1_5", "x17", "+", "x6", "/", "x8", "*", "x1", "x16"], ["-", "/", "+", "x1", "*", "x9", "+", "x14", "+", "pow1_2", "x4", "cos", "+", "x1", "+", "x13", "/", "*", "x13", "/", "pow5", "x14", "pow1_2", "x10", "mult3", "x4", "x10", "x16"], ["+", "<constant>", "/", "+", "x6", "*", "x6", "/", "/", "/", "+", "x17", "mult4", "*", "x12", "pow2", "x15", "x2", "pow2", "x11", "x15", "asinh", "x13"], ["+", "x1", "+", "x13", "mult5", "+", "x6", "-", "/", "*", "x6", "*", "div5", "x1", "+", "x10", "x5", "x2", "/", "/", "x1", "/", "mult2", "x10", "x5", "x13"], ["/", "-", "/", "x9", "x3", "x14", "*", "div3", "x1", "pow4", "+", "x16", "-", "+", "x12", "x7", "+", "x10", "*", "x8", "-", "x15", "-", "neg", "x7", "x9"], ["/", "-", "div4", "x3", "x15", "atanh", "+", "*", "x15", "pow4", "x10", "-", "+", "*", "x10", "x12", "*", "x16", "+", "x5", "div4", "x3", "-", "pow2", "-", "x17", "x8", "x15"], ["div3", "-", "/", "x12", "+", "x10", "pow1_3", "/", "*", "asinh", "x11", "-", "x4", "x7", "*", "x4", "-", "x12", "div5", "x5", "+", "x10", "+", "x14", "atan", "-", "x11", "x14"], ["*", "x5", "-", "-", "x10", "+", "<constant>", "+", "mult2", "x10", "pow1_5", "x5", "-", "x5", "/", "mult2", "x10", "<constant>"], ["*", "-", "x4", "x9", "pow5", "*", "<constant>", "*", "x12", "div4", "div4", "/", "x17", "x11"], ["+", "x6", "-", "/", "pow1_4", "+", "tanh", "x6", "-", "+", "<constant>", "+", "x2", "x6", "x9", "x9", "mult2", "x2"], ["*", "x1", "*", "/", "x17", "pow2", "x7", "-", "+", "x5", "+", "-", "x3", "x8", "/", "+", "x11", "+", "x15", "+", "x8", "-", "acosh", "x12", "x2", "x7", "x16"], ["asinh", "+", "x17", "/", "x17", "-", "/", "+", "x17", "*", "x17", "-", "pow1_2", "sin", "pow2", "div5", "pow2", "x17", "x17", "tanh", "x17", "pow5", "x17"], ["*", "x2", "/", "/", "pow5", "-", "x12", "+", "x14", "div5", "*", "x2", "+", "x12", "-", "x14", "x2", "x14", "atan", "x14"], ["-", "/", "x10", "x12", "+", "x8", "-", "+", "x14", "pow3", "x3", "/", "-", "x15", "x4", "-", "*", "x1", "*", "x10", "div4", "x14", "/", "x1", "x11"], ["-", "acosh", "-", "<constant>", "/", "x2", "x16", "+", "x2", "-", "/", "mult5", "/", "abs", "*", "x16", "x2", "x2", "x16", "div3", "-", "x16", "x2"], ["/", "x14", "/", "neg", "x17", "/", "*", "x17", "*", "neg", "x11", "/", "+", "x9", "/", "pow2", "x14", "div5", "x11", "x1", "div2", "x3"], ["*", "<constant>", "+", "mult5", "x2", "*", "<constant>", "+", "x15", "+", "x16", "+", "x2", "+", "div2", "x17", "-", "mult3", "abs", "/", "pow4", "acos", "x5", "x17", "mult5", "x15"], ["*", "x15", "-", "x11", "*", "x11", "/", "+", "x9", "asinh", "asin", "*", "x9", "-", "sinh", "sinh", "x9", "x9", "x9"], ["*", "acos", "x13", "/", "-", "/", "+", "acos", "-", "x15", "/", "x6", "x7", "*", "x17", "+", "/", "x16", "x15", "div2", "atan", "x3", "x3", "atanh", "x15", "/", "asin", "x17", "x17"], ["+", "/", "div4", "x15", "x14", "+", "-", "*", "x11", "tan", "x8", "x14", "+", "-", "atanh", "*", "x11", "x17", "x7", "*", "x5", "+", "x8", "*", "/", "x5", "x17", "+", "x6", "x7"], ["/", "/", "exp", "/", "+", "x3", "*", "x12", "+", "x14", "-", "*", "x1", "+", "x17", "/", "<constant>", "x6", "x7", "x14", "x2", "/", "x6", "-", "-", "cos", "x9", "/", "x15", "x1", "x1"], ["-", "/", "x15", "-", "div5", "pow4", "x11", "mult4", "/", "*", "/", "x11", "x8", "-", "log", "/", "pow2", "x15", "x17", "x8", "pow1_4", "x17", "pow4", "x15"], ["/", "-", "x6", "*", "+", "inv", "x6", "pow2", "x6", "tan", "-", "+", "x17", "/", "x17", "sinh", "inv", "pow2", "x6", "x6", "x6"], ["/", "*", "x12", "-", "+", "x12", "+", "pow4", "x12", "mult2", "x5", "pow4", "+", "pow2", "x14", "pow2", "x5", "-", "pow1_3", "x5", "pow2", "x14"], ["*", "-", "+", "x15", "x3", "<constant>", "/", "+", "x14", "+", "x2", "+", "x5", "pow4", "/", "x13", "x7", "*", "cosh", "pow4", "x2", "mult2", "-", "x6", "*", "x11", "cosh", "x7"], ["+", "<constant>", "+", "div4", "+", "x8", "-", "x4", "pow2", "/", "x1", "/", "x13", "x12", "/", "+", "x13", "x7", "+", "x11", "/", "/", "x14", "x9", "*", "x7", "-", "x5", "cosh", "pow1_5", "x10"], ["/", "+", "<constant>", "x11", "*", "x11", "tanh", "asinh", "+", "x11", "pow4", "*", "x11", "abs", "/", "<constant>", "x11"], ["+", "x12", "*", "/", "neg", "x6", "x1", "/", "-", "pow1_3", "-", "x12", "x13", "+", "x6", "/", "+", "x5", "x7", "<constant>", "+", "<constant>", "/", "x15", "-", "x5", "x1"], ["*", "pow1_2", "*", "x15", "div3", "x9", "+", "pow1_5", "x4", "-", "/", "x11", "*", "x1", "*", "x7", "/", "x16", "-", "/", "x17", "-", "/", "x12", "mult3", "x8", "x2", "x5", "x13"], ["-", "x8", "/", "-", "mult2", "x8", "mult2", "+", "x8", "+", "mult2", "x8", "-", "-", "log", "x8", "/", "x8", "-", "exp", "mult2", "x8", "x8", "pow2", "x8", "x8"], ["-", "x17", "*", "/", "x8", "/", "x3", "-", "x7", "<constant>", "+", "x15", "/", "-", "pow4", "+", "x1", "x12", "-", "x6", "x14", "x16"], ["/", "/", "mult5", "/", "tanh", "x9", "+", "x9", "/", "x13", "-", "-", "x2", "-", "atan", "-", "x11", "x9", "x6", "x5", "x5", "x17"], ["/", "*", "x15", "mult3", "+", "x15", "-", "acosh", "/", "x12", "x8", "+", "x9", "-", "x16", "x17", "+", "tanh", "x12", "-", "x4", "abs", "x16"], ["pow5", "*", "/", "x11", "x2", "*", "sin", "*", "<constant>", "x4", "/", "x17", "-", "log", "/", "mult2", "*", "x1", "x5", "x6", "-", "*", "x7", "-", "x8", "x3", "x9"], ["+", "x17", "-", "-", "x3", "/", "/", "x17", "x9", "acosh", "pow2", "x3", "x1"], ["+", "acos", "pow1_5", "x6", "pow2", "+", "*", "x1", "x17", "*", "pow1_3", "x12", "/", "+", "*", "x13", "x15", "/", "/", "x5", "x2", "x13", "+", "x17", "*", "x17", "x3"], ["/", "x9", "-", "+", "x1", "exp", "div2", "sinh", "*", "x16", "+", "x3", "+", "x5", "+", "/", "mult4", "x17", "x8", "*", "pow2", "x6", "+", "x13", "/", "-", "x4", "x12", "x7", "x2"], ["/", "/", "mult3", "x16", "*", "x16", "/", "-", "x16", "-", "x17", "mult2", "x16", "pow1_4", "pow1_3", "x16", "x17"], ["*", "x17", "+", "<constant>", "-", "x13", "pow1_3", "div3", "/", "*", "x10", "/", "pow2", "x1", "x11", "/", "x7", "+", "x14", "+", "x7", "tanh", "x4"], ["/", "-", "/", "pow5", "pow3", "-", "atanh", "x16", "x16", "x16", "mult3", "x16", "pow2", "x16"], ["+", "-", "x13", "x5", "pow1_4", "+", "x9", "/", "*", "<constant>", "*", "x6", "-", "tanh", "pow1_3", "x11", "x14", "/", "exp", "-", "x15", "x4", "x2"], ["+", "x15", "/", "x15", "+", "<constant>", "+", "mult3", "x15", "*", "x15", "asin", "x15"], ["exp", "/", "x9", "-", "*", "x1", "-", "x16", "*", "abs", "x17", "-", "x1", "+", "x16", "-", "sinh", "*", "x17", "sin", "neg", "x9", "x8", "-", "x16", "x8"], ["/", "-", "/", "x7", "x8", "pow1_2", "-", "mult2", "x8", "div3", "*", "x14", "mult2", "x7", "/", "inv", "x8", "/", "x7", "log", "inv", "x7"], ["-", "/", "x10", "-", "x7", "/", "x14", "+", "x17", "x8", "+", "/", "/", "<constant>", "x3", "x16", "*", "x9", "mult5", "-", "/", "+", "x4", "-", "pow1_3", "x13", "x11", "x15", "abs", "x2"], ["-", "sinh", "*", "<constant>", "-", "x8", "/", "cosh", "/", "x2", "x11", "+", "-", "x1", "x12", "*", "x17", "abs", "sinh", "x1", "x15"], ["cos", "div3", "*", "x12", "+", "mult2", "x15", "-", "x12", "/", "-", "x16", "x14", "/", "pow2", "*", "x14", "/", "x15", "x16", "x16"], ["*", "x4", "log", "*", "x3", "+", "<constant>", "-", "*", "+", "x3", "-", "<constant>", "x4", "sin", "-", "tan", "x3", "-", "<constant>", "pow1_3", "atanh", "div5", "-", "<constant>", "x4", "x4"], ["-", "x5", "/", "-", "*", "<constant>", "*", "x5", "/", "acos", "*", "x8", "/", "/", "<constant>", "x2", "exp", "x15", "x3", "x13", "abs", "+", "x1", "*", "x7", "-", "x4", "x10"], ["cos", "*", "x2", "*", "-", "exp", "inv", "div3", "+", "x1", "x12", "x8", "+", "sin", "x17", "div2", "/", "x11", "pow5", "exp", "mult2", "x13"], ["-", "+", "<constant>", "-", "/", "neg", "x15", "pow4", "*", "x15", "/", "asinh", "x11", "x13", "asin", "/", "x13", "+", "x15", "mult2", "x11", "mult2", "x15"], ["/", "-", "cosh", "*", "x2", "*", "/", "mult2", "x14", "mult2", "x2", "+", "x2", "/", "x2", "asin", "mult3", "x2", "/", "x2", "/", "cosh", "x11", "x14", "x11"], ["*", "div3", "-", "x10", "-", "<constant>", "+", "acosh", "x16", "*", "x15", "x16", "/", "-", "x12", "exp", "/", "*", "x13", "/", "x17", "x7", "x16", "sinh", "x14"], ["pow1_3", "+", "x9", "+", "asinh", "/", "x9", "div5", "x3", "pow1_4", "+", "pow1_5", "x3", "+", "pow4", "x3", "/", "asin", "x3", "/", "*", "x1", "/", "-", "x14", "x3", "x14", "x3"], ["/", "x1", "/", "*", "pow1_5", "x16", "/", "mult5", "acos", "/", "asinh", "x8", "x8", "-", "acosh", "x15", "/", "x16", "x2", "/", "x2", "/", "x5", "+", "x5", "atan", "+", "x15", "x2"], ["/", "*", "-", "x2", "sin", "pow1_2", "x2", "/", "pow1_4", "x2", "/", "x2", "cosh", "x2", "pow4", "*", "x2", "-", "-", "+", "x2", "pow1_4", "x2", "cos", "pow2", "x4", "x4"], ["+", "x16", "+", "x5", "-", "+", "*", "x9", "-", "x6", "x12", "-", "x4", "/", "+", "<constant>", "x11", "-", "-", "*", "x14", "-", "+", "x12", "x9", "x3", "x1", "x4", "<constant>"], ["/", "*", "sin", "x3", "div4", "+", "-", "x7", "x10", "atan", "*", "x8", "/", "/", "x16", "/", "+", "x15", "x5", "div5", "/", "x13", "x4", "x4", "x12"], ["/", "pow4", "*", "log", "x5", "*", "/", "pow1_2", "x5", "x8", "/", "pow1_4", "x8", "pow2", "x5", "log", "*", "x7", "pow1_2", "*", "x5", "pow5", "x7"], ["-", "pow4", "x13", "pow1_2", "/", "x7", "cosh", "*", "div5", "x1", "-", "-", "x15", "pow5", "x8", "/", "x10", "pow1_4", "+", "x17", "*", "<constant>", "x8"], ["*", "x3", "/", "x16", "*", "+", "x5", "-", "x6", "x4", "/", "*", "<constant>", "x13", "-", "/", "x10", "/", "-", "-", "*", "x2", "x7", "+", "<constant>", "+", "x11", "x9", "x3", "x14", "tan", "x3"], ["*", "x13", "+", "-", "-", "inv", "x10", "x7", "x13", "pow4", "+", "-", "mult2", "x4", "x7", "*", "abs", "x9", "+", "x7", "+", "atanh", "x10", "*", "x7", "div3", "x10"], ["mult3", "/", "-", "+", "x7", "*", "x7", "pow2", "x5", "x5", "+", "x7", "/", "tanh", "tan", "-", "*", "x5", "tan", "x5", "div4", "x5", "sinh", "-", "x7", "x5"], ["/", "+", "x4", "pow1_2", "*", "x4", "/", "x15", "+", "pow1_3", "-", "<constant>", "x4", "-", "/", "x15", "x4", "x12", "/", "x15", "pow3", "div3", "mult4", "x12"], ["-", "+", "-", "mult2", "x2", "pow2", "mult2", "x2", "/", "/", "tan", "x2", "x2", "<constant>", "pow2", "x2"], ["-", "cosh", "-", "exp", "atan", "/", "x6", "*", "x7", "/", "*", "x11", "/", "<constant>", "pow1_2", "sin", "x3", "x16", "tan", "x5", "x1"], ["-", "+", "x2", "/", "/", "cosh", "x14", "x2", "<constant>", "*", "pow2", "x11", "+", "x5", "-", "+", "x2", "div4", "cosh", "x2", "pow1_5", "pow3", "*", "<constant>", "*", "x14", "x2"], ["/", "*", "acosh", "x1", "-", "/", "sinh", "pow5", "pow1_4", "/", "x7", "+", "x1", "cosh", "+", "pow1_4", "x7", "-", "x15", "x4", "/", "+", "x15", "x7", "x1", "x7", "x4"], ["+", "-", "-", "*", "x14", "x16", "mult2", "x16", "x6", "-", "neg", "x6", "-", "acosh", "x9", "inv", "-", "cosh", "x9", "/", "x15", "x14"], ["float(\"inf\")"], ["/", "x17", "cosh", "*", "atanh", "pow1_2", "x1", "/", "-", "x17", "/", "-", "+", "x17", "*", "x10", "x17", "pow2", "x17", "div5", "x17", "/", "-", "x10", "x1", "x10"], ["-", "*", "<constant>", "*", "/", "cos", "x11", "x12", "div4", "/", "x12", "mult2", "x11", "+", "x12", "div3", "*", "x12", "-", "x11", "<constant>"], ["/", "div5", "x7", "/", "tan", "sin", "*", "pow1_5", "x7", "*", "atanh", "x9", "asin", "-", "x12", "div2", "x7", "x9"], ["sin", "*", "x14", "asinh", "*", "pow2", "x14", "cos", "mult4", "atan", "neg", "/", "asin", "x14", "*", "x14", "-", "x14", "sin", "x14"], ["+", "x12", "tanh", "/", "acosh", "x11", "*", "x17", "*", "-", "x3", "+", "x1", "x17", "-", "-", "*", "x2", "-", "inv", "x13", "sinh", "x8", "x14", "x1"], ["*", "x9", "/", "x11", "+", "x1", "+", "x7", "log", "-", "-", "+", "x16", "x17", "*", "<constant>", "*", "x14", "exp", "x13", "/", "-", "x3", "-", "x15", "atanh", "x5", "x10"], ["-", "*", "x2", "x8", "*", "x14", "-", "/", "/", "x6", "x7", "-", "sin", "x12", "+", "/", "x17", "x10", "-", "pow3", "/", "pow1_4", "/", "x16", "x5", "div5", "x1", "x4", "x13"], ["*", "x3", "+", "mult2", "x1", "+", "exp", "x11", "-", "-", "x6", "x15", "+", "x7", "+", "*", "<constant>", "*", "x3", "x8", "pow4", "-", "x1", "pow1_5", "x10"], ["*", "x2", "pow2", "div2", "*", "x10", "tan", "pow3", "tanh", "/", "/", "+", "<constant>", "+", "x14", "-", "*", "x11", "abs", "+", "x3", "x6", "x11", "x10", "x5"], ["*", "-", "x13", "<constant>", "+", "x13", "pow1_4", "*", "x13", "+", "x13", "+", "cosh", "x11", "div3", "*", "x11", "-", "x13", "x11"], ["+", "x14", "/", "cosh", "*", "div5", "pow3", "x5", "-", "/", "x2", "+", "x5", "mult2", "x2", "x15", "x2"], ["-", "*", "x3", "acos", "x3", "*", "x13", "/", "/", "x2", "cosh", "x2", "tan", "*", "/", "x3", "x11", "/", "-", "/", "x13", "<constant>", "pow1_4", "x15", "x2"], ["inv", "-", "pow1_3", "+", "inv", "x17", "+", "asinh", "*", "<constant>", "acosh", "/", "x9", "<constant>", "*", "<constant>", "*", "pow1_4", "x17", "-", "<constant>", "pow1_5", "x17", "x17"], ["+", "-", "x12", "x15", "/", "+", "x6", "x8", "-", "-", "*", "pow3", "x6", "*", "sinh", "*", "x13", "x2", "+", "x7", "+", "/", "x12", "x8", "*", "x8", "-", "x15", "x13", "x12", "x17"], ["tanh", "div4", "pow1_3", "*", "x16", "+", "x10", "acosh", "+", "x1", "-", "x7", "-", "mult3", "*", "x2", "-", "x13", "+", "x12", "pow1_4", "x12", "-", "x15", "pow1_4", "x8"], ["-", "+", "x8", "*", "x10", "x9", "log", "pow1_2", "/", "-", "/", "+", "x12", "x14", "*", "x10", "x8", "-", "x12", "*", "x14", "x7", "x9"], ["*", "<constant>", "*", "x11", "*", "x12", "*", "x16", "/", "pow1_2", "+", "x13", "+", "x4", "pow3", "*", "x14", "*", "x17", "/", "x5", "-", "x9", "x2", "x3"], ["-", "mult2", "x7", "pow5", "-", "/", "x7", "*", "<constant>", "asin", "*", "<constant>", "log", "asinh", "x7", "<constant>"], ["pow1_2", "+", "-", "+", "x8", "-", "x10", "x11", "x17", "*", "mult2", "x17", "/", "acosh", "-", "x13", "x15", "x3"], ["+", "-", "+", "<constant>", "acos", "x9", "mult4", "x16", "*", "x16", "*", "/", "x2", "x9", "-", "x14", "/", "pow5", "x7", "mult2", "x15"], ["atanh", "-", "div2", "-", "x15", "/", "*", "x2", "*", "/", "*", "pow2", "x11", "mult2", "x15", "x15", "asin", "-", "x15", "*", "x15", "mult2", "x11", "x7", "acosh", "x11"], ["pow3", "*", "cosh", "x16", "*", "-", "x12", "x10", "-", "div4", "/", "x1", "atan", "x17", "sinh", "+", "x6", "-", "x5", "pow4", "x6"], ["/", "+", "x10", "*", "<constant>", "/", "+", "x3", "+", "mult2", "x1", "-", "+", "x10", "*", "x15", "asin", "x15", "/", "x9", "x10", "*", "x1", "x3", "pow1_3", "x7"], ["-", "*", "x4", "-", "*", "x10", "x2", "+", "x11", "*", "x10", "+", "x3", "/", "-", "+", "x11", "x16", "pow5", "x12", "x17", "x13"], ["*", "<constant>", "tanh", "*", "abs", "div3", "mult2", "x4", "pow2", "/", "atanh", "/", "x16", "+", "x3", "x6", "x12"], ["/", "*", "x16", "/", "x5", "tanh", "+", "x10", "pow3", "div4", "-", "asin", "/", "+", "x4", "-", "+", "x10", "x12", "<constant>", "x8", "inv", "-", "x8", "x1", "x7"], ["-", "/", "/", "sin", "atan", "x4", "-", "<constant>", "x4", "x4", "atan", "x4"], ["/", "-", "+", "asinh", "*", "x10", "mult4", "acos", "x6", "-", "cosh", "x15", "+", "x17", "+", "x8", "asinh", "div5", "/", "x11", "x12", "x6", "+", "x9", "*", "x12", "+", "<constant>", "x10"], ["/", "<constant>", "-", "mult2", "x2", "+", "x15", "+", "inv", "mult5", "x2", "/", "-", "x5", "-", "-", "<constant>", "x2", "x15", "/", "cosh", "x11", "x10"], ["-", "*", "x1", "x17", "/", "x8", "+", "x10", "*", "x16", "/", "sinh", "x13", "-", "*", "<constant>", "x6", "x11"], ["-", "*", "x6", "-", "/", "x7", "/", "+", "x1", "mult2", "x2", "/", "x6", "div3", "-", "x2", "x1", "pow1_5", "pow4", "pow1_4", "x7", "x6"], ["div4", "+", "-", "x1", "x10", "/", "-", "x12", "x6", "-", "pow1_5", "x1", "pow1_2", "*", "x10", "x6"], ["/", "/", "*", "x15", "div3", "x12", "+", "x15", "/", "cos", "asin", "x12", "x12", "x12"], ["*", "pow1_5", "x4", "mult5", "+", "*", "x15", "neg", "mult2", "x14", "exp", "/", "x11", "*", "x17", "*", "x2", "*", "+", "x13", "x7", "*", "/", "x9", "x1", "+", "<constant>", "+", "x1", "x3"], ["*", "div2", "x3", "+", "x3", "*", "mult2", "x3", "/", "x3", "*", "exp", "x3", "+", "x3", "*", "x3", "log", "mult2", "x3"], ["*", "x15", "-", "pow1_5", "neg", "x12", "-", "x12", "*", "x15", "+", "x12", "+", "x8", "+", "inv", "x15", "+", "mult3", "x8", "tan", "-", "*", "x8", "mult3", "x15", "x12"], ["-", "/", "x11", "x5", "+", "mult2", "x11", "*", "pow3", "x5", "mult3", "neg", "+", "pow1_3", "x11", "/", "-", "x11", "x5", "div3", "x5"], ["mult5", "-", "div2", "x17", "*", "<constant>", "-", "-", "<constant>", "*", "x8", "pow3", "*", "x13", "x17", "/", "x17", "x13"], ["exp", "+", "x10", "sin", "-", "-", "cos", "pow5", "*", "x7", "-", "*", "pow2", "x10", "+", "mult3", "x16", "pow2", "atanh", "x10", "x7", "/", "x10", "x16", "cos", "x16"], ["+", "x16", "/", "*", "x14", "-", "sin", "x16", "*", "x14", "tanh", "+", "x14", "+", "div5", "x16", "pow1_4", "*", "x14", "*", "x16", "acosh", "inv", "x14", "x16"], ["mult3", "*", "/", "/", "x3", "mult2", "sinh", "*", "x2", "pow1_4", "x5", "x15", "+", "<constant>", "/", "x1", "pow1_2", "-", "*", "x13", "x17", "*", "x16", "-", "x10", "/", "x4", "x6"], ["pow1_2", "/", "x16", "*", "asin", "div4", "x14", "+", "x11", "mult3", "-", "/", "/", "asinh", "div2", "/", "exp", "x9", "+", "x17", "x7", "x4", "*", "x2", "x3", "-", "x8", "x5"], ["*", "x10", "-", "+", "div5", "x13", "acos", "*", "x11", "x9", "-", "x4", "/", "-", "/", "x2", "mult3", "x3", "<constant>", "*", "x14", "/", "+", "x1", "*", "x15", "x5", "x16"], ["-", "/", "x14", "*", "mult5", "x10", "*", "exp", "x5", "/", "inv", "x14", "atanh", "x10", "/", "mult2", "x10", "pow1_3", "x14"], ["-", "x10", "-", "x11", "mult5", "*", "x10", "*", "tan", "x11", "/", "/", "pow2", "x10", "x11", "/", "asinh", "-", "/", "/", "x10", "x11", "x1", "x1", "+", "x1", "x11"], ["/", "x3", "-", "/", "+", "*", "x8", "pow3", "+", "x2", "tan", "x10", "*", "x10", "+", "x17", "-", "pow1_5", "x17", "/", "x2", "x10", "-", "x3", "x8", "+", "x17", "x2"], ["/", "x12", "+", "x12", "-", "-", "*", "x14", "x8", "-", "+", "x16", "x5", "/", "/", "/", "x12", "*", "cosh", "x8", "-", "x3", "/", "x8", "x17", "*", "x14", "x15", "+", "x3", "x4", "x15"], ["div5", "mult3", "/", "+", "x7", "+", "inv", "x2", "acos", "pow1_4", "x5", "*", "x4", "div2", "-", "x8", "*", "x12", "*", "x4", "sin", "/", "x9", "pow4", "x16"], ["*", "x8", "*", "+", "mult3", "x13", "+", "inv", "x5", "*", "x3", "pow5", "abs", "x14", "/", "x10", "+", "x6", "asinh", "-", "*", "abs", "x12", "sin", "sinh", "x2", "x8"], ["mult2", "/", "asin", "-", "cosh", "x10", "x10", "+", "*", "x10", "cosh", "x10", "sin", "+", "x10", "pow2", "x10"], ["/", "*", "x10", "*", "x2", "-", "pow5", "/", "-", "<constant>", "x11", "*", "x13", "x15", "+", "x5", "+", "*", "x11", "x13", "*", "x9", "+", "x13", "x3", "+", "x15", "+", "x2", "+", "x8", "x9"], ["/", "div5", "*", "tanh", "*", "x2", "x8", "mult2", "abs", "mult2", "neg", "pow2", "x8", "x8"], ["div2", "/", "pow5", "div4", "+", "*", "x3", "atanh", "x14", "acosh", "-", "x3", "asinh", "x3", "*", "x13", "asin", "-", "pow1_5", "/", "x13", "x11", "<constant>"], ["/", "*", "x2", "x3", "*", "x16", "-", "x16", "/", "/", "mult5", "+", "x4", "mult5", "+", "x7", "*", "x6", "*", "/", "x15", "mult4", "x12", "+", "<constant>", "/", "*", "x5", "x9", "x13", "x15", "x14"], ["*", "x10", "-", "pow1_3", "x10", "*", "pow4", "*", "x6", "-", "x10", "x6", "/", "+", "x10", "*", "x10", "atan", "div2", "x17", "pow2", "x17"], ["div3", "*", "/", "x7", "acosh", "x14", "acos", "tan", "/", "pow2", "x7", "+", "/", "sinh", "abs", "x7", "sinh", "x13", "*", "x14", "asinh", "*", "x13", "pow2", "x7"], ["+", "x14", "+", "/", "x4", "-", "mult2", "x16", "x3", "/", "x6", "-", "x4", "*", "-", "x9", "x16", "+", "<constant>", "*", "x8", "-", "x13", "/", "*", "x10", "-", "<constant>", "x15", "pow1_5", "x9"], ["*", "+", "x1", "x7", "/", "x14", "*", "<constant>", "+", "x6", "+", "div3", "+", "x4", "asinh", "x5", "/", "sin", "x4", "-", "<constant>", "log", "+", "x4", "acos", "/", "x5", "-", "x14", "x7"], ["+", "/", "x3", "x2", "pow4", "*", "pow1_3", "+", "x3", "*", "<constant>", "log", "log", "x7", "-", "div5", "x2", "exp", "mult2", "-", "pow2", "x7", "<constant>"], ["float(\"nan\")"], ["*", "float(\"inf\")", "x8"], ["*", "mult2", "x11", "mult2", "+", "x14", "-", "/", "/", "-", "mult4", "x17", "mult3", "x15", "x11", "*", "/", "x3", "pow4", "x10", "pow1_4", "+", "x15", "x17", "x10"], ["-", "x7", "mult2", "-", "div2", "-", "x4", "div4", "sin", "mult3", "-", "x11", "x15", "x3"], ["abs", "+", "/", "<constant>", "x7", "+", "/", "x3", "pow1_5", "x5", "pow5", "-", "cosh", "-", "asin", "/", "x5", "+", "x5", "tanh", "x10", "/", "<constant>", "x11", "+", "x6", "log", "x5"], ["/", "+", "x16", "+", "-", "x12", "x1", "acosh", "tan", "-", "x12", "abs", "+", "mult2", "x1", "div3", "mult4", "x11", "pow2", "*", "<constant>", "atan", "x16"], ["*", "x16", "/", "x2", "*", "div3", "x8", "asinh", "pow1_4", "+", "div2", "x13", "-", "pow2", "+", "x16", "x4", "-", "-", "x16", "mult4", "*", "x2", "+", "x11", "x12", "x8"], ["acos", "/", "cosh", "-", "pow1_2", "/", "x13", "acosh", "*", "x7", "*", "/", "x9", "/", "x11", "<constant>", "+", "x11", "/", "x9", "*", "x11", "mult2", "x13", "sin", "+", "x11", "x17", "x8"], ["/", "/", "x4", "x10", "/", "-", "x12", "exp", "acosh", "x10", "/", "atanh", "mult5", "x4", "/", "+", "<constant>", "x12", "abs", "x12"], ["+", "x1", "/", "/", "-", "x14", "mult3", "-", "exp", "/", "+", "x10", "pow2", "-", "x6", "x10", "asinh", "x13", "x7", "pow2", "x13", "+", "x14", "x2"], ["/", "sin", "*", "+", "<constant>", "x5", "/", "x17", "-", "-", "/", "x13", "x8", "<constant>", "-", "acosh", "x8", "x8", "*", "+", "x1", "x11", "-", "x13", "x5"], ["+", "x6", "/", "acosh", "x4", "/", "x3", "/", "acosh", "x4", "div5", "-", "cos", "*", "x15", "-", "x6", "x14", "sinh", "x3"], ["-", "-", "+", "x1", "+", "x11", "+", "/", "acos", "/", "x12", "x6", "x9", "*", "+", "x14", "x16", "asin", "mult4", "x17", "x13", "mult3", "-", "+", "x4", "/", "x15", "x7", "x2"], ["/", "*", "+", "x14", "+", "x6", "cos", "x17", "-", "/", "+", "x14", "/", "/", "x17", "atanh", "x13", "+", "<constant>", "div4", "x5", "-", "asinh", "x5", "x16", "<constant>", "x12"], ["*", "pow2", "/", "x1", "x11", "+", "x11", "-", "x14", "acos", "-", "pow1_3", "*", "x12", "-", "x14", "tan", "+", "x12", "pow2", "x5", "x12"], ["+", "x14", "pow1_3", "+", "x14", "x15"], ["-", "/", "/", "x15", "pow2", "x17", "x17", "mult3", "pow4", "/", "x17", "-", "sinh", "*", "x15", "x17", "x17"], ["div5", "+", "*", "acos", "x12", "cosh", "div4", "x16", "-", "x9", "acosh", "+", "x1", "+", "x11", "+", "x7", "div3", "/", "x14", "*", "mult4", "x4", "pow1_4", "/", "x2", "x15"], ["/", "+", "mult2", "x13", "inv", "asinh", "log", "x13", "x13"], ["-", "*", "x5", "pow2", "-", "acos", "x6", "/", "x6", "/", "+", "x7", "pow1_4", "x9", "-", "asinh", "+", "x14", "pow2", "x5", "mult3", "log", "x14", "x6"], ["+", "exp", "x6", "-", "*", "x11", "*", "x5", "+", "x14", "+", "x16", "log", "x9", "/", "/", "x14", "*", "x11", "+", "x11", "+", "x14", "x15", "<constant>"], ["/", "-", "<constant>", "x7", "*", "<constant>", "x3"], ["neg", "/", "x1", "exp", "/", "-", "/", "exp", "/", "x14", "x1", "atanh", "/", "x1", "x14", "x14", "tan", "mult3", "mult2", "x1"], ["-", "/", "<constant>", "abs", "/", "/", "x16", "-", "+", "sin", "x14", "*", "x8", "+", "x1", "x3", "*", "x15", "x3", "/", "x9", "+", "x10", "/", "abs", "x11", "*", "x2", "+", "x17", "x5", "x4"], ["mult5", "+", "<constant>", "abs", "x10"], ["-", "x13", "*", "x17", "acosh", "/", "/", "sinh", "mult3", "pow2", "x13", "*", "x13", "x17", "+", "x13", "x17"], ["/", "x10", "-", "*", "x13", "/", "x7", "x3", "-", "-", "cos", "x6", "x15", "pow1_3", "cos", "*", "-", "-", "x11", "<constant>", "x16", "+", "x1", "*", "x2", "+", "x12", "x9"], ["+", "-", "x11", "*", "x15", "pow3", "-", "x15", "x11", "acosh", "-", "*", "sin", "x13", "*", "div5", "x15", "sin", "*", "x11", "pow", "float(\"-inf\")", "x15", "x11"], ["sin", "+", "x4", "cos", "/", "/", "-", "x7", "-", "x1", "<constant>", "pow1_3", "+", "x11", "+", "x3", "div5", "/", "+", "<constant>", "x15", "x10", "/", "x17", "x4"], ["*", "/", "<constant>", "x9", "+", "log", "x11", "/", "mult5", "div3", "/", "x14", "x11", "mult2", "+", "x14", "*", "x6", "*", "asinh", "x7", "/", "*", "x15", "x16", "x3"], ["pow3", "-", "*", "x4", "/", "+", "x4", "+", "x5", "/", "/", "x14", "+", "x5", "inv", "x11", "x5", "/", "x16", "div5", "x4", "/", "x11", "exp", "x14"], ["*", "pow2", "x2", "*", "-", "/", "x2", "x14", "x14", "/", "mult5", "x14", "/", "pow1_4", "x6", "log", "/", "*", "pow5", "x16", "tanh", "x7", "acosh", "x7"], ["tan", "mult3", "+", "x16", "/", "*", "x17", "div3", "/", "-", "*", "+", "x3", "x6", "-", "x9", "x15", "x10", "asin", "exp", "x5", "/", "x11", "x7"], ["*", "x4", "mult2", "pow1_5", "+", "x11", "+", "x4", "pow1_3", "-", "*", "x11", "div3", "pow3", "acos", "/", "x4", "+", "<constant>", "pow1_3", "x4", "x11"], ["*", "x3", "-", "*", "x3", "-", "x3", "*", "x3", "atan", "+", "<constant>", "div3", "+", "div3", "x3", "tan", "mult2", "x3", "x3"], ["+", "x9", "-", "x11", "*", "-", "x6", "x13", "-", "-", "-", "acos", "-", "x8", "x15", "+", "x11", "x8", "pow1_2", "+", "x1", "x10", "pow2", "mult4", "pow2", "x12"], ["-", "*", "x17", "div5", "-", "x17", "-", "*", "+", "x17", "pow2", "x17", "-", "mult2", "x17", "/", "x17", "<constant>", "abs", "sin", "x17", "x17"], ["/", "/", "-", "x11", "+", "x9", "cos", "acosh", "/", "x8", "pow5", "x5", "x5", "x3"], ["+", "x11", "+", "*", "x11", "log", "+", "x14", "abs", "x11", "tanh", "acosh", "/", "/", "div3", "x10", "x11", "atanh", "x15"], ["pow2", "+", "x12", "sinh", "*", "x9", "acosh", "+", "x11", "/", "-", "<constant>", "+", "/", "asin", "-", "x3", "<constant>", "x16", "-", "-", "x15", "*", "x13", "x14", "x10", "x11"], ["cosh", "*", "x1", "*", "+", "x11", "x9", "-", "x2", "-", "*", "x1", "+", "*", "x11", "*", "x2", "pow5", "x15", "*", "+", "x15", "*", "<constant>", "x3", "-", "<constant>", "/", "pow5", "x1", "x16", "x11"], ["pow1_4", "-", "*", "+", "x11", "+", "x14", "x9", "pow4", "+", "/", "x2", "x16", "tan", "+", "x11", "-", "+", "x16", "*", "x6", "+", "x6", "*", "x6", "x9", "x9", "x4"], ["+", "x6", "-", "pow1_4", "-", "sin", "mult5", "x6", "x13", "+", "x4", "/", "*", "mult4", "cosh", "x13", "asin", "-", "x4", "x13", "-", "x4", "mult4", "pow2", "x11"], ["/", "/", "-", "x15", "x6", "pow1_3", "-", "x13", "/", "+", "sin", "*", "x9", "-", "asin", "x4", "x14", "/", "x6", "*", "x7", "-", "+", "x12", "x13", "x11", "+", "x1", "-", "<constant>", "x17", "x5"], ["*", "x3", "-", "/", "-", "x7", "mult4", "asin", "-", "x4", "abs", "-", "x10", "x8", "+", "<constant>", "x5", "+", "<constant>", "+", "x11", "+", "x17", "x6"], ["/", "+", "*", "x2", "mult5", "pow2", "x3", "asinh", "*", "x17", "*", "x3", "/", "*", "x6", "x7", "*", "x2", "pow1_3", "*", "x5", "+", "x6", "div4", "x17", "x17"], ["+", "x2", "/", "/", "x2", "+", "x2", "*", "float(\"inf\")", "pow1_2", "mult5", "div3", "inv", "x2", "div4", "x2"], ["div2", "*", "x10", "mult5", "-", "(-1)", "-", "inv", "cosh", "-", "mult2", "x10", "x7", "x7"], ["/", "+", "div2", "atanh", "/", "x2", "x7", "/", "x2", "-", "+", "x6", "mult3", "cosh", "pow1_5", "x12", "*", "x8", "pow3", "x6", "x7"], ["*", "pow1_2", "x9", "*", "/", "x13", "+", "x8", "*", "x14", "asinh", "x14", "+", "/", "x9", "x2", "/", "x9", "*", "x12", "div5", "x1"], ["mult2", "acosh", "*", "x3", "+", "x9", "mult5", "+", "x16", "/", "x10", "*", "x6", "*", "cosh", "x10", "-", "x10", "x11"], ["-", "x16", "+", "asin", "*", "x9", "*", "+", "x3", "x8", "+", "x15", "/", "pow5", "x13", "x11", "*", "x17", "/", "+", "x11", "/", "-", "<constant>", "-", "x2", "x12", "x10", "*", "x7", "/", "x5", "x6"], ["-", "x4", "+", "sin", "x7", "/", "*", "-", "+", "<constant>", "x11", "-", "atanh", "x11", "x14", "-", "tan", "/", "x7", "/", "x4", "tan", "x15", "pow5", "x15", "-", "+", "x2", "x5", "x3"], ["/", "inv", "asinh", "-", "x6", "x17", "mult5", "+", "x6", "*", "x15", "x6"], ["+", "pow2", "x15", "+", "sin", "pow2", "x15", "pow2", "sinh", "neg", "sinh", "x15"], ["/", "*", "x4", "+", "*", "x4", "sin", "x4", "/", "acosh", "x4", "pow2", "x4", "pow1_2", "+", "div5", "x4", "mult2", "x4"], ["+", "x7", "asin", "neg", "/", "tan", "x7", "/", "-", "<constant>", "x7", "*", "atan", "x7", "pow1_4", "x7"]]
\ No newline at end of file
diff --git a/benchmarks/corpus/reference_aligned_mpl7.json b/benchmarks/corpus/reference_aligned_mpl7.json
deleted file mode 100644
index 388c3eb..0000000
--- a/benchmarks/corpus/reference_aligned_mpl7.json
+++ /dev/null
@@ -1 +0,0 @@
-[["cos", "div4", "-", "*", "mult2", "x15", "/", "pow2", "/", "-", "x16", "x3", "*", "x14", "pow2", "x15", "*", "x3", "pow2", "x16", "x14"], ["pow1_5", "+", "tanh", "x17", "sin", "/", "x8", "pow5", "mult3", "x11"], ["*", "x16", "+", "/", "x16", "+", "x16", "x8", "*", "x16", "*", "x8", "pow1_2", "/", "/", "x8", "x16", "*", "mult5", "x16", "asin", "x8"], ["/", "pow4", "/", "-", "exp", "-", "x4", "tan", "+", "x4", "mult5", "log", "/", "x17", "-", "*", "x4", "sin", "*", "x17", "x4", "x17", "x17", "x17", "x4"], ["/", "+", "x4", "cos", "-", "<constant>", "*", "x4", "+", "x4", "+", "x5", "pow4", "x5", "x5"], ["/", "x12", "-", "-", "inv", "div2", "-", "x13", "-", "div3", "-", "+", "x10", "+", "mult2", "x8", "/", "div3", "x8", "x13", "/", "x11", "x10", "x9", "x7", "inv", "x4"], ["*", "x7", "+", "x7", "-", "+", "pow2", "*", "cosh", "x1", "/", "atan", "x7", "x7", "-", "*", "pow1_4", "x7", "+", "x1", "mult2", "x7", "x1", "log", "x7"], ["*", "exp", "x6", "*", "/", "-", "x1", "x11", "exp", "x3", "+", "<constant>", "/", "/", "neg", "*", "x13", "x16", "x10", "x12"], ["*", "x15", "-", "/", "/", "x3", "-", "x17", "x7", "x4", "mult4", "mult2", "x6"], ["-", "*", "x7", "+", "-", "x7", "x13", "+", "sinh", "div5", "x7", "/", "inv", "-", "+", "x14", "x8", "+", "x5", "x7", "mult4", "x14", "x8"], ["atanh", "+", "inv", "x9", "/", "x11", "div2", "acos", "x11"], ["*", "+", "<constant>", "x15", "+", "-", "x11", "-", "x13", "+", "x14", "x9", "*", "x11", "+", "-", "x4", "x1", "*", "x15", "+", "sinh", "x1", "*", "/", "x15", "x2", "+", "x1", "+", "x2", "x4"], ["-", "-", "*", "pow2", "x11", "-", "mult4", "x11", "<constant>", "x11", "+", "atanh", "x11", "/", "pow2", "x11", "<constant>"], ["pow1_4", "-", "x12", "cos", "-", "+", "x14", "/", "-", "div3", "x12", "/", "*", "log", "x14", "div5", "x8", "x12", "tan", "x14", "x12"], ["+", "-", "*", "x12", "x9", "mult2", "x4", "tan", "mult4", "/", "/", "/", "<constant>", "-", "-", "*", "x15", "x17", "x5", "+", "<constant>", "x9", "sinh", "x12", "x6"], ["+", "<constant>", "+", "x6", "pow5", "+", "x15", "*", "div4", "/", "x11", "+", "x1", "atanh", "x6", "pow5", "*", "x11", "/", "x15", "+", "<constant>", "mult2", "x15"], ["asinh", "*", "cos", "x8", "*", "mult2", "x8", "*", "-", "acos", "x8", "x8", "-", "log", "mult2", "sinh", "x13", "x13"], ["*", "x16", "-", "cosh", "x5", "atan", "pow3", "-", "+", "asinh", "x8", "*", "x1", "*", "x6", "/", "x15", "/", "x13", "x10", "x4"], ["*", "mult2", "x14", "-", "+", "*", "x14", "pow2", "x6", "-", "<constant>", "*", "x14", "x6", "x6"], ["*", "/", "x14", "x2", "sin", "/", "*", "x11", "/", "+", "x11", "/", "pow2", "x3", "*", "x10", "*", "x14", "*", "atan", "x8", "-", "x8", "x3", "-", "x8", "x10", "x12"], ["/", "*", "x2", "-", "+", "mult2", "x13", "*", "x13", "tanh", "*", "float(\"inf\")", "*", "x14", "-", "x11", "x17", "x14", "x11"], ["-", "x16", "+", "x1", "*", "atan", "x12", "/", "+", "<constant>", "+", "x12", "+", "x14", "+", "x16", "+", "*", "<constant>", "x14", "-", "/", "x2", "<constant>", "x1", "*", "pow2", "x12", "/", "x12", "x16"], ["asinh", "/", "-", "*", "x7", "+", "x4", "+", "x9", "mult3", "x14", "/", "cos", "*", "x8", "pow2", "x1", "-", "/", "/", "x1", "+", "x4", "mult2", "x1", "x14", "x6", "x14"], ["*", "x7", "+", "acos", "x15", "+", "/", "-", "mult2", "x7", "/", "mult4", "pow2", "x13", "x5", "x8", "abs", "+", "<constant>", "/", "/", "pow5", "x13", "<constant>", "*", "x13", "x5"], ["*", "x5", "/", "pow2", "x13", "/", "*", "<constant>", "acos", "*", "x16", "-", "x17", "x1", "/", "*", "x16", "*", "x2", "atan", "x6", "x14"], ["+", "mult2", "x14", "div5", "acosh", "/", "-", "mult2", "+", "mult4", "x17", "-", "x17", "x6", "-", "mult2", "x16", "x4", "mult2", "x8"], ["sinh", "log", "mult5", "x16"], ["+", "div2", "x2", "tan", "+", "x2", "+", "x7", "+", "sin", "*", "x2", "*", "x3", "x7", "/", "+", "x13", "*", "x11", "x15", "*", "div5", "x6", "+", "x4", "-", "x16", "x17"], ["pow1_5", "+", "x6", "+", "mult2", "x8", "+", "/", "x15", "<constant>", "pow5", "-", "x1", "-", "x11", "x9"], ["mult5", "-", "-", "abs", "-", "atan", "exp", "x8", "x3", "acos", "-", "x3", "+", "*", "x5", "x8", "*", "x8", "/", "acosh", "x7", "x12", "x13"], ["*", "-", "x1", "*", "x15", "-", "x15", "x17", "/", "/", "pow1_2", "x15", "/", "x17", "pow2", "x15", "log", "pow3", "/", "/", "x14", "-", "/", "exp", "x14", "x1", "x14", "pow5", "x17"], ["-", "x14", "tan", "-", "/", "acos", "+", "div3", "-", "neg", "x14", "x16", "-", "+", "x16", "acosh", "abs", "x14", "/", "+", "asinh", "x14", "tanh", "x16", "x16", "x14", "x16"], ["-", "asinh", "neg", "+", "sin", "x11", "div5", "/", "cosh", "x12", "+", "x12", "-", "asinh", "sin", "x12", "cosh", "x11", "x15"], ["neg", "/", "/", "div5", "log", "x13", "x17", "pow2", "pow1_2", "+", "x7", "+", "div4", "x14", "/", "+", "x11", "*", "x6", "x8", "*", "x4", "mult2", "x5"], ["*", "-", "inv", "x15", "x11", "*", "asin", "+", "x11", "mult5", "x15", "-", "abs", "x11", "+", "x11", "x15"], ["*", "/", "x3", "log", "x15", "+", "*", "x6", "+", "<constant>", "x13", "/", "-", "x8", "+", "x7", "/", "x5", "*", "x12", "-", "pow3", "x2", "-", "x11", "x17", "x1"], ["*", "x14", "*", "x6", "+", "x14", "-", "+", "x7", "*", "x7", "/", "+", "x14", "+", "x7", "x8", "-", "x6", "abs", "x14", "+", "*", "x8", "cos", "x2", "pow1_3", "-", "x7", "x8"], ["/", "*", "x12", "+", "x16", "-", "x13", "-", "<constant>", "x5", "-", "x6", "+", "x5", "x8"], ["+", "-", "x5", "inv", "mult2", "x13", "/", "pow1_3", "/", "div5", "div4", "x5", "asinh", "+", "pow1_5", "x13", "/", "x13", "x12", "*", "x12", "x13"], ["+", "x8", "-", "div2", "/", "/", "x8", "pow2", "x6", "-", "pow2", "+", "x8", "asinh", "x6", "acosh", "x8", "+", "div3", "x6", "-", "x6", "pow1_3", "cosh", "x8"], ["*", "pow2", "x12", "*", "pow1_2", "pow1_3", "x12", "+", "x12", "div3", "/", "x12", "*", "pow3", "x12", "-", "x12", "cos", "x12"], ["*", "x6", "log", "-", "x6", "*", "-", "div3", "exp", "asinh", "x6", "x6", "-", "mult2", "x6", "+", "<constant>", "*", "x6", "pow3", "pow1_4", "x6"], ["*", "sin", "x5", "*", "asinh", "-", "tan", "x14", "x2", "-", "x12", "mult2", "-", "x9", "-", "x8", "-", "x4", "/", "x14", "x8"], ["+", "-", "*", "x10", "atan", "x10", "<constant>", "-", "/", "acosh", "-", "/", "sinh", "/", "x11", "<constant>", "*", "x10", "x4", "pow1_2", "x4", "x11", "x3"], ["*", "-", "pow1_4", "x13", "x2", "pow1_2", "+", "x1", "+", "x14", "div4", "exp", "div4", "tan", "-", "x9", "/", "+", "/", "x16", "x6", "-", "/", "x3", "x7", "x1", "x10"], ["abs", "*", "x2", "neg", "atan", "+", "mult2", "/", "x2", "pow2", "*", "x15", "pow1_5", "x2", "*", "pow2", "x2", "/", "*", "x14", "/", "x15", "x17", "+", "<constant>", "+", "x15", "x2"], ["+", "x11", "/", "-", "x5", "x11", "exp", "tanh", "x5"], ["-", "/", "/", "*", "x6", "x7", "-", "+", "x5", "mult5", "x7", "x17", "/", "x10", "+", "x7", "/", "*", "x12", "mult3", "*", "x6", "*", "x7", "x9", "x17", "x4"], ["*", "x9", "div2", "/", "x2", "*", "x9", "+", "mult4", "atan", "x2", "-", "pow2", "x2", "x2"], ["-", "-", "/", "abs", "mult3", "/", "x15", "/", "/", "-", "exp", "-", "x2", "x3", "x16", "<constant>", "x1", "*", "<constant>", "*", "x1", "x14", "x8", "*", "x2", "x8"], ["+", "asinh", "mult2", "x7", "/", "x4", "/", "acos", "-", "-", "*", "-", "x13", "log", "x13", "-", "x2", "/", "x5", "x8", "x7", "x8", "x13"], ["*", "exp", "x1", "-", "neg", "atanh", "*", "x13", "atanh", "-", "+", "x11", "pow4", "x11", "x7", "tan", "exp", "x10"], ["pow1_2", "-", "x1", "-", "-", "x17", "/", "tan", "+", "x5", "+", "sinh", "x4", "sinh", "*", "x13", "+", "x17", "/", "x2", "x16", "x14", "pow3", "-", "+", "x14", "-", "x3", "x6", "x17"], ["*", "atanh", "x12", "-", "x14", "-", "pow1_3", "-", "mult2", "x1", "*", "x12", "+", "x12", "-", "div5", "x16", "+", "div3", "x1", "mult4", "x14", "x12"], ["-", "/", "x9", "*", "x11", "-", "-", "/", "x1", "x8", "+", "x10", "+", "x6", "/", "x3", "x4", "mult4", "/", "div3", "x14", "-", "*", "x5", "-", "<constant>", "x14", "x6", "x2"], ["mult2", "*", "x7", "*", "+", "x11", "x3", "/", "+", "x7", "/", "/", "atanh", "x7", "*", "<constant>", "*", "x13", "x2", "x5", "x9"], ["-", "*", "<constant>", "*", "x9", "/", "float(\"inf\")", "*", "x4", "abs", "x9", "x2"], ["-", "+", "x12", "+", "x7", "+", "atanh", "x10", "*", "x5", "+", "<constant>", "+", "/", "<constant>", "x11", "-", "mult2", "x4", "x6", "/", "+", "x4", "/", "/", "x17", "x11", "pow2", "x2", "<constant>"], ["-", "+", "x12", "+", "x2", "/", "-", "x12", "pow3", "+", "x2", "-", "*", "x9", "pow2", "x10", "pow2", "x11", "x11", "cosh", "x10"], ["<constant>"], ["*", "+", "x8", "pow5", "x6", "/", "/", "x14", "*", "x17", "/", "-", "+", "x4", "asinh", "-", "x10", "x7", "x15", "+", "*", "x12", "x9", "cos", "-", "+", "x5", "*", "x3", "x4", "x2", "<constant>"], ["-", "*", "x6", "*", "+", "x11", "/", "x9", "x11", "/", "/", "pow2", "x12", "pow2", "x6", "+", "x12", "+", "x8", "x9", "*", "x11", "*", "x6", "mult3", "x9"], ["+", "/", "x1", "x13", "pow3", "*", "x1", "*", "acosh", "x13", "-", "*", "x1", "-", "x13", "inv", "x13", "mult2", "x13"], ["+", "mult2", "x15", "+", "/", "sin", "/", "x9", "x3", "mult3", "+", "mult4", "x7", "/", "x11", "x5", "*", "+", "x17", "*", "<constant>", "x2", "/", "x4", "-", "neg", "x16", "x1"], ["neg", "atan", "pow3", "*", "x4", "abs", "x4"], ["/", "pow1_4", "x7", "*", "x4", "abs", "+", "x16", "+", "*", "x15", "*", "x16", "x8", "/", "pow4", "x8", "/", "x7", "-", "x10", "acosh", "x15"], ["-", "div5", "/", "/", "x10", "sin", "mult5", "*", "x10", "/", "mult3", "+", "x10", "*", "x12", "div4", "x1", "pow1_4", "x9", "-", "pow4", "x17", "x1", "x17"], ["cosh", "/", "-", "-", "+", "x6", "*", "x9", "-", "+", "x15", "*", "<constant>", "x5", "x2", "*", "x1", "*", "x17", "+", "x11", "atan", "inv", "exp", "x9", "x14", "x4"], ["*", "atan", "x16", "*", "-", "x6", "x3", "/", "+", "*", "x12", "x14", "-", "x10", "/", "x17", "+", "-", "x8", "x2", "*", "x9", "-", "log", "x4", "x2", "pow4", "x11"], ["+", "x9", "*", "x10", "pow1_4", "atan", "*", "<constant>", "/", "x10", "x8"], ["-", "neg", "x5", "abs", "+", "mult5", "x5", "+", "pow2", "x5", "-", "x5", "*", "mult2", "pow2", "x5", "/", "-", "x5", "pow3", "x5", "x5"], ["*", "atan", "sin", "cos", "*", "x1", "x5", "+", "x8", "-", "/", "-", "x11", "x12", "x3", "*", "x15", "+", "x11", "*", "x5", "x9"], ["+", "inv", "x16", "*", "x14", "/", "x6", "asinh", "*", "x12", "*", "x15", "/", "-", "x1", "*", "x11", "x4", "<constant>"], ["+", "pow2", "x11", "/", "+", "<constant>", "mult5", "+", "mult2", "x5", "-", "-", "sinh", "pow2", "x6", "/", "<constant>", "x11", "cos", "exp", "cosh", "x5", "+", "<constant>", "x11"], ["*", "pow1_3", "x15", "+", "x12", "+", "x15", "tanh", "/", "x15", "/", "+", "x11", "*", "x15", "-", "+", "<constant>", "x12", "x15", "x12"], ["/", "x14", "/", "+", "<constant>", "-", "/", "mult5", "x17", "x12", "x14", "*", "x15", "pow1_3", "div3", "+", "x2", "+", "mult2", "x6", "inv", "+", "x12", "+", "x15", "-", "x3", "x16"], ["-", "x16", "+", "x13", "+", "pow2", "x16", "/", "x15", "/", "div3", "mult4", "x15", "x16"], ["/", "acos", "+", "x6", "/", "<constant>", "*", "/", "-", "x1", "asinh", "abs", "*", "x17", "atanh", "x5", "x3", "pow1_3", "+", "x9", "-", "tan", "/", "/", "x2", "x16", "x10", "x15", "x4"], ["+", "*", "div5", "x9", "+", "x15", "-", "x9", "/", "x9", "acos", "x9", "*", "x9", "+", "x15", "*", "-", "asinh", "x9", "x9", "/", "sin", "mult3", "x15", "pow2", "x15"], ["div4", "-", "mult2", "x1", "/", "atan", "x4", "*", "exp", "/", "<constant>", "x9", "+", "x7", "+", "x8", "-", "x9", "<constant>"], ["*", "x7", "-", "-", "x12", "-", "*", "x8", "-", "*", "<constant>", "tan", "x7", "pow4", "-", "<constant>", "pow3", "x8", "pow1_4", "/", "-", "<constant>", "-", "x16", "x7", "x16", "x8"], ["/", "x16", "-", "x3", "*", "x12", "*", "+", "x10", "pow1_5", "*", "x16", "mult4", "div3", "x2", "acos", "cos", "+", "div5", "*", "x15", "x9", "tan", "*", "<constant>", "*", "x12", "x13"], ["/", "/", "/", "/", "-", "x6", "/", "x6", "x15", "tan", "pow3", "tan", "*", "x10", "*", "x6", "-", "-", "x5", "x16", "x12", "+", "cosh", "x1", "mult3", "x4", "x12", "+", "x5", "x9"], ["+", "x16", "+", "-", "x3", "pow3", "/", "x17", "-", "*", "x10", "x8", "+", "x1", "x8", "/", "+", "/", "x12", "div3", "x17", "-", "x7", "-", "x3", "-", "x12", "x9", "+", "x9", "/", "x12", "x9"], ["+", "x17", "*", "x17", "+", "x17", "sin", "+", "mult3", "x17", "*", "mult2", "x17", "/", "pow2", "x17", "<constant>"], ["+", "/", "acosh", "x8", "tan", "x4", "-", "x4", "/", "pow4", "+", "<constant>", "log", "+", "<constant>", "x14", "pow3", "x4"], ["/", "mult2", "pow1_3", "+", "pow1_4", "x12", "-", "mult2", "x12", "inv", "pow1_3", "*", "x3", "*", "acosh", "x6", "-", "x3", "exp", "x12", "x3"], ["/", "<constant>", "/", "x4", "-", "x14", "/", "/", "sin", "/", "x14", "x4", "*", "x10", "+", "x16", "pow1_3", "x7", "/", "sinh", "x7", "+", "x1", "+", "x16", "mult2", "abs", "x5"], ["/", "*", "x16", "x5", "/", "+", "x16", "+", "mult2", "x9", "*", "x3", "x5", "div5", "/", "x5", "/", "/", "/", "x9", "x10", "div2", "x6", "pow1_5", "x10"], ["+", "*", "x4", "x8", "/", "log", "pow1_3", "+", "x8", "-", "x11", "*", "x8", "/", "/", "x5", "x6", "acosh", "x3", "/", "div4", "div5", "x4", "x12"], ["div4", "-", "mult2", "x7", "-", "<constant>", "-", "/", "pow2", "x7", "neg", "cosh", "x7", "*", "x7", "-", "atanh", "x7", "x7"], ["*", "atan", "x8", "*", "pow1_2", "x8", "*", "pow3", "x8", "div3", "div4", "div3", "tanh", "x8"], ["-", "pow4", "acos", "+", "x13", "mult4", "pow3", "x13", "mult4", "x13"], ["*", "x3", "exp", "/", "tanh", "pow5", "pow4", "log", "x11", "+", "<constant>", "+", "x16", "*", "tanh", "atan", "x16", "-", "acosh", "/", "pow1_4", "x11", "x3", "x11"], ["acos", "asinh", "pow1_2", "/", "-", "x14", "+", "x4", "+", "pow3", "x13", "mult4", "x14", "neg", "/", "x14", "x1"], ["/", "x8", "-", "-", "+", "x12", "-", "/", "x12", "mult3", "*", "x14", "div3", "x8", "*", "x10", "-", "*", "x2", "x8", "mult4", "x1", "x10", "x2"], ["x10"], ["pow1_5", "/", "cos", "pow3", "x5", "+", "pow5", "x6", "mult5", "/", "inv", "*", "x17", "/", "<constant>", "x7", "+", "x10", "pow1_4", "-", "x3", "<constant>"], ["cosh", "/", "-", "<constant>", "pow1_3", "x14", "pow5", "*", "x17", "*", "mult5", "x14", "sinh", "+", "x14", "-", "mult5", "*", "x14", "x17", "mult3", "x14"], ["+", "x15", "+", "cos", "x14", "+", "-", "x1", "/", "*", "x4", "-", "asinh", "x9", "x7", "x14", "/", "-", "x3", "mult2", "x6", "*", "x16", "/", "x14", "x17"], ["*", "x11", "-", "/", "asinh", "x2", "atanh", "pow1_3", "+", "x11", "x2", "+", "x14", "*", "cos", "x14", "sin", "log", "acosh", "acosh", "/", "cosh", "x9", "x5"], ["/", "div4", "-", "pow1_5", "*", "x17", "*", "/", "x13", "x2", "tan", "-", "x9", "x13", "/", "pow5", "x17", "x6", "x17"], ["*", "acosh", "x14", "sin", "/", "+", "pow3", "x11", "+", "pow1_5", "mult4", "x6", "/", "*", "-", "x14", "<constant>", "div3", "pow1_3", "+", "x12", "x17", "x11", "x12"], ["-", "x5", "*", "x11", "+", "*", "x5", "+", "x11", "x5", "*", "x11", "asin", "*", "x11", "+", "<constant>", "*", "-", "pow1_2", "x11", "x11", "/", "atan", "x5", "x11"], ["+", "*", "x6", "-", "x6", "div2", "x12", "/", "*", "atan", "x12", "atan", "pow2", "mult2", "x15", "/", "x15", "atanh", "x6"], ["*", "pow2", "x10", "*", "+", "x4", "*", "<constant>", "+", "x10", "x5", "/", "acosh", "*", "x10", "sin", "pow1_2", "/", "*", "x10", "pow1_2", "x5", "<constant>", "x4"], ["div3", "-", "+", "<constant>", "pow4", "x16", "*", "x14", "*", "mult5", "x16", "-", "+", "x10", "+", "x6", "/", "x13", "x5", "+", "mult2", "x7", "*", "x15", "x4"], ["+", "x5", "*", "atanh", "x14", "*", "pow1_2", "+", "x13", "+", "x4", "cosh", "x1", "-", "mult5", "x4", "/", "x12", "/", "*", "x3", "*", "abs", "x3", "pow2", "x5", "x4"], ["-", "-", "/", "*", "x11", "neg", "x14", "x3", "<constant>", "*", "x10", "x7"], ["/", "sin", "+", "x11", "/", "*", "-", "x7", "x2", "/", "x2", "cosh", "/", "pow1_5", "x13", "/", "x13", "+", "x11", "x8", "x8", "x7"], ["+", "x9", "+", "-", "x4", "cosh", "x9", "asin", "+", "x9", "+", "mult3", "pow4", "inv", "x9", "/", "-", "x4", "x9", "pow2", "x9"], ["-", "/", "x5", "x1", "*", "mult4", "x12", "*", "pow1_5", "pow1_5", "x14", "*", "-", "x9", "tan", "-", "x9", "x5", "mult3", "*", "x14", "/", "+", "<constant>", "x8", "/", "atanh", "x9", "x1"], ["/", "*", "acos", "x17", "+", "x9", "*", "x8", "tan", "pow1_5", "div2", "mult5", "x5", "atanh", "x15"], ["/", "acosh", "x13", "*", "x1", "+", "x3", "/", "+", "x9", "mult5", "*", "x1", "*", "x7", "tan", "-", "x2", "<constant>", "asin", "acos", "asinh", "x13"], ["+", "/", "-", "x14", "x2", "*", "x16", "atan", "x2", "-", "pow2", "x11", "+", "x11", "+", "x2", "+", "acosh", "x2", "asinh", "x2"], ["*", "x1", "pow2", "/", "/", "x14", "mult2", "x7", "+", "mult2", "x6", "-", "-", "*", "x15", "x8", "*", "x10", "atanh", "x1", "*", "x12", "*", "x14", "x15"], ["+", "exp", "div3", "x17", "sinh", "-", "/", "x15", "neg", "+", "*", "x6", "+", "x12", "x3", "-", "/", "cos", "x9", "x16", "<constant>", "x2"], ["/", "x6", "div5", "+", "x11", "pow2", "atanh", "*", "+", "<constant>", "x6", "acos", "pow1_4", "+", "x3", "log", "*", "x11", "+", "sinh", "x7", "-", "x6", "+", "<constant>", "x3"], ["exp", "-", "x13", "/", "+", "/", "x13", "x9", "/", "/", "div5", "x10", "pow1_4", "log", "-", "x8", "mult2", "-", "x15", "mult2", "sin", "x17", "x5", "x14"], ["/", "div5", "x2", "/", "*", "x8", "-", "x11", "-", "-", "acosh", "x3", "acos", "x16", "<constant>", "div4", "x12"], ["neg", "asin", "-", "x3", "div3", "/", "*", "x13", "-", "x17", "x13", "*", "x7", "-", "*", "x4", "x5", "x15"], ["+", "<constant>", "atanh", "pow1_2", "pow1_5", "*", "<constant>", "pow1_2", "-", "atanh", "pow4", "-", "div4", "cosh", "x17", "x17", "pow3", "x17"], ["+", "x13", "*", "x13", "+", "pow1_2", "+", "x5", "/", "x7", "x9", "*", "acos", "x12", "-", "x8", "mult5", "/", "/", "x9", "x8", "x7"], ["+", "-", "x3", "x16", "div5", "div2", "pow1_5", "mult2", "-", "mult5", "x10", "x3"], ["+", "x3", "-", "/", "x13", "x3", "div3", "-", "-", "div4", "/", "cos", "x3", "x3", "/", "pow3", "mult2", "x13", "x13", "cos", "x3"], ["*", "x17", "sinh", "+", "x13", "+", "x17", "-", "x3", "pow1_2", "*", "x13", "*", "div5", "+", "x13", "sin", "x13", "-", "x17", "/", "x13", "+", "x13", "/", "div2", "x13", "abs", "x13"], ["*", "abs", "x12", "sinh", "div4", "/", "+", "div5", "*", "x5", "x9", "acos", "-", "exp", "x17", "*", "<constant>", "-", "x4", "x8", "x6"], ["atanh", "exp", "+", "x1", "*", "x7", "/", "+", "x16", "x7", "-", "pow1_3", "abs", "*", "x16", "-", "+", "x15", "acos", "/", "x14", "x16", "<constant>", "cosh", "x11"], ["/", "*", "x14", "mult2", "x4", "*", "x10", "-", "*", "x14", "-", "-", "neg", "x14", "x10", "/", "x4", "/", "x10", "-", "/", "x4", "x14", "x14", "<constant>"], ["atanh", "/", "+", "sinh", "pow3", "x13", "/", "x10", "sinh", "+", "/", "x15", "*", "x17", "x3", "pow1_4", "/", "+", "x1", "+", "x4", "x6", "/", "x5", "x8", "x16"], ["-", "/", "-", "/", "x7", "/", "/", "-", "/", "x3", "x7", "pow5", "x6", "neg", "x12", "pow3", "-", "x5", "x1", "x2", "asinh", "x9", "*", "x17", "div2", "x14"], ["*", "pow1_4", "x7", "/", "pow4", "asin", "+", "x16", "/", "+", "x12", "*", "x11", "div3", "x8", "x15", "-", "+", "div5", "x1", "/", "x5", "*", "+", "x10", "x17", "/", "x14", "x6", "x4"], ["pow1_4", "+", "x10", "/", "mult2", "x10", "+", "<constant>", "pow2", "x10"], ["-", "/", "x6", "x8", "/", "+", "-", "pow1_4", "x1", "x3", "atanh", "*", "/", "x7", "exp", "x16", "-", "x6", "/", "x17", "x13", "+", "x5", "pow1_2", "sinh", "pow1_4", "x9"], ["/", "x12", "-", "sinh", "atan", "-", "*", "x7", "*", "cos", "*", "x14", "x3", "/", "/", "x3", "log", "x6", "x17", "-", "x6", "x17", "-", "*", "<constant>", "x15", "<constant>"], ["-", "pow1_4", "-", "log", "/", "/", "-", "x5", "x2", "x16", "-", "/", "x4", "neg", "x11", "+", "x12", "atanh", "div4", "x3", "x1", "div4", "x15"], ["+", "x8", "div5", "*", "x13", "+", "<constant>", "+", "*", "-", "x4", "x2", "sin", "-", "x7", "x6", "sin", "+", "x10", "-", "x5", "sinh", "-", "x14", "*", "x11", "*", "x12", "*", "x15", "x17"], ["acosh", "+", "*", "pow3", "x12", "-", "abs", "atanh", "+", "x10", "+", "x12", "cosh", "x11", "<constant>", "*", "/", "x2", "<constant>", "/", "asinh", "x2", "acos", "*", "x10", "/", "x12", "x2"], ["/", "-", "+", "x4", "x7", "*", "x17", "*", "x3", "tan", "x8", "x17"], ["*", "x3", "-", "mult2", "x1", "mult4", "exp", "+", "x16", "*", "x9", "sinh", "+", "-", "x13", "x2", "*", "acos", "x4", "pow2", "-", "*", "x15", "mult2", "+", "x10", "x5", "x17"], ["atanh", "*", "+", "x13", "x4", "-", "-", "x13", "pow2", "x4", "inv", "x4"], ["*", "x17", "*", "-", "x17", "/", "x5", "*", "x17", "x6", "+", "x8", "+", "pow3", "x17", "/", "asin", "div5", "x13", "<constant>"], ["+", "/", "pow2", "x4", "x3", "*", "x12", "+", "x1", "-", "/", "x12", "x1", "+", "x4", "-", "-", "x10", "*", "x4", "-", "div3", "x1", "atanh", "pow2", "+", "x10", "x12", "asinh", "x10"], ["+", "x13", "+", "x8", "*", "mult3", "/", "x7", "x15", "mult5", "+", "x3", "div2", "x8"], ["+", "x11", "+", "acosh", "x13", "/", "asinh", "mult5", "/", "x7", "*", "<constant>", "x16", "+", "<constant>", "/", "x1", "asinh", "x17"], ["+", "x11", "+", "x12", "+", "x16", "+", "x4", "+", "mult2", "x1", "+", "mult2", "x13", "*", "x16", "+", "x4", "pow4", "+", "x16", "x4"], ["*", "x5", "*", "div2", "cos", "x11", "pow1_2", "+", "x11", "+", "x5", "+", "atanh", "mult2", "x5", "/", "x11", "pow1_4", "mult3", "pow2", "x5"], ["+", "/", "x5", "x7", "abs", "-", "-", "x12", "x2", "-", "x13", "x10"], ["*", "x10", "sinh", "mult4", "asinh", "/", "sinh", "x10", "-", "x14", "sinh", "+", "x10", "x14"], ["/", "x10", "*", "x13", "*", "acosh", "*", "x2", "x8", "/", "+", "x3", "+", "x6", "+", "/", "x9", "x11", "-", "+", "x5", "pow2", "x1", "/", "x1", "x14", "mult5", "+", "x13", "pow2", "x9"], ["cosh", "*", "x17", "*", "x4", "*", "neg", "*", "x17", "x4", "+", "x17", "+", "x4", "+", "pow1_2", "x17", "pow5", "div5", "x4"], ["+", "*", "x13", "-", "x14", "/", "x7", "x17", "/", "x2", "*", "+", "x7", "x8", "+", "x8", "-", "-", "x7", "x17", "x14"], ["-", "x13", "/", "x13", "-", "mult2", "x1", "*", "x13", "+", "x13", "/", "mult2", "x13", "-", "+", "x13", "mult2", "x1", "/", "-", "neg", "x1", "x13", "mult2", "x13"], ["/", "+", "cosh", "x17", "/", "*", "x4", "/", "-", "x16", "x9", "x11", "x10", "-", "tanh", "+", "sin", "x2", "atanh", "pow4", "x11", "/", "*", "<constant>", "x6", "asin", "*", "x13", "x15"], ["-", "*", "<constant>", "/", "x3", "-", "/", "pow4", "+", "x12", "*", "x16", "x7", "acos", "pow4", "x2", "+", "x11", "+", "x9", "*", "x16", "exp", "cos", "x14", "x15"], ["+", "*", "x1", "*", "x9", "pow4", "x9", "*", "x14", "+", "pow1_5", "x1", "*", "x14", "+", "x1", "asinh", "x1"], ["pow3", "/", "x5", "*", "log", "asinh", "x4", "+", "<constant>", "+", "x4", "+", "pow1_5", "x4", "/", "*", "x4", "-", "x5", "x4", "x5"], ["/", "/", "-", "/", "-", "sinh", "x15", "x15", "mult5", "x8", "x17", "pow3", "sin", "pow2", "x17", "*", "x15", "mult3", "mult4", "pow2", "mult4", "x15"], ["-", "/", "/", "+", "x7", "atanh", "x7", "tanh", "x7", "acos", "sinh", "sinh", "x7", "*", "x7", "-", "x7", "pow3", "x7"], ["/", "x7", "*", "pow2", "x7", "*", "div3", "+", "x7", "pow2", "x7", "sin", "tanh", "pow4", "pow2", "x7"], ["+", "x13", "*", "+", "x13", "mult4", "x2", "/", "x2", "/", "/", "*", "exp", "x2", "-", "pow1_5", "tan", "div5", "x13", "x2", "-", "pow1_4", "x2", "x2", "x13"], ["+", "*", "x14", "+", "x2", "-", "x12", "x14", "*", "x14", "mult4", "/", "+", "*", "x14", "x2", "*", "x2", "/", "sinh", "x14", "+", "x12", "*", "x12", "div5", "x2", "x2"], ["pow1_2", "-", "cos", "/", "*", "x15", "x9", "-", "+", "x16", "x8", "x7", "exp", "*", "x8", "-", "/", "x3", "/", "div5", "x8", "/", "x10", "+", "x6", "*", "x11", "x13", "inv", "x12"], ["/", "/", "/", "mult3", "x16", "mult5", "x4", "div4", "*", "x4", "cos", "pow1_3", "-", "mult2", "x4", "+", "x16", "/", "x16", "+", "x4", "+", "asin", "x4", "mult4", "x4", "x16"], ["pow5", "+", "x10", "/", "div4", "x10", "/", "x16", "*", "x11", "-", "mult3", "+", "x10", "x11", "x10"], ["/", "x5", "-", "*", "+", "mult2", "x5", "cos", "atanh", "x5", "+", "x5", "tanh", "/", "+", "<constant>", "x5", "x5", "asinh", "x5"], ["log", "+", "mult2", "x9", "-", "pow4", "*", "x9", "sinh", "x9", "+", "pow2", "x9", "*", "x9", "pow3", "pow2", "x9"], ["*", "x15", "div3", "/", "*", "x12", "+", "x9", "/", "acos", "+", "x4", "*", "x17", "x9", "x11", "/", "/", "x14", "x16", "pow5", "*", "x4", "+", "x12", "+", "x14", "cos", "x15"], ["-", "+", "x1", "*", "<constant>", "cosh", "*", "+", "x7", "*", "x14", "log", "x16", "/", "inv", "x5", "-", "x8", "asin", "x11", "x9"], ["mult2", "pow3", "*", "tan", "mult2", "x10", "/", "cosh", "x10", "*", "x10", "tanh", "*", "x10", "pow4", "mult2", "x10"], ["*", "x12", "*", "x14", "*", "x15", "*", "x8", "*", "/", "x4", "*", "x10", "pow1_3", "x1", "+", "/", "x5", "x14", "-", "-", "/", "x5", "x15", "x8", "*", "x1", "x15"], ["/", "-", "pow4", "+", "x1", "+", "x16", "-", "mult3", "+", "x11", "div2", "-", "x5", "pow1_3", "x9", "*", "x10", "x12", "x12", "x7"], ["*", "x11", "*", "-", "/", "x16", "x13", "x7", "+", "<constant>", "*", "x1", "+", "x17", "+", "-", "x5", "x16", "inv", "*", "<constant>", "*", "x10", "*", "div3", "x6", "-", "*", "x13", "x7", "x16"], ["*", "-", "x12", "*", "x12", "/", "x7", "x2", "/", "/", "+", "x17", "-", "x11", "x7", "-", "*", "sinh", "x11", "/", "x12", "/", "x5", "x7", "x1", "x5"], ["+", "x11", "+", "x13", "+", "x14", "+", "x4", "-", "x6", "*", "x5", "+", "<constant>", "+", "x12", "x17"], ["+", "asin", "+", "x14", "/", "acos", "x9", "cos", "pow2", "x11", "/", "*", "<constant>", "pow1_3", "x1", "*", "x2", "*", "x3", "*", "x4", "x6"], ["/", "/", "x8", "x15", "pow1_3", "+", "x11", "/", "x9", "*", "x3", "+", "x13", "div2", "asin", "+", "/", "x16", "x17", "/", "mult5", "atanh", "/", "pow5", "x14", "*", "x15", "x4", "x1"], ["div5", "*", "x9", "*", "+", "x9", "asin", "div3", "pow2", "x9", "pow2", "pow4", "pow1_3", "mult2", "+", "mult2", "x9", "sinh", "x9"], ["sinh", "+", "-", "x4", "*", "<constant>", "*", "x11", "div5", "x10", "*", "x13", "*", "x15", "*", "x5", "*", "x7", "*", "x8", "-", "x6", "x16"], ["+", "-", "<constant>", "x9", "+", "/", "<constant>", "x9", "/", "x9", "-", "/", "acos", "x9", "div3", "mult2", "x9", "x9"], ["+", "x12", "+", "pow5", "x1", "/", "/", "-", "*", "x1", "x12", "mult4", "sin", "*", "x1", "*", "x12", "*", "tanh", "x1", "exp", "x12", "tan", "x1", "x1"], ["pow1_2", "-", "x5", "*", "pow3", "*", "x3", "mult2", "/", "tanh", "x12", "+", "x11", "x13", "/", "x13", "+", "x11", "mult2", "-", "/", "pow5", "x9", "x3", "x1"], ["*", "x7", "/", "pow2", "x10", "/", "x11", "*", "x16", "*", "x3", "atan", "mult4", "+", "x10", "+", "pow3", "/", "x7", "x10", "mult2", "/", "x7", "pow2", "-", "x3", "x10"], ["acos", "/", "+", "pow2", "x15", "/", "x15", "-", "/", "x15", "div2", "mult3", "x2", "x15", "/", "x15", "-", "x2", "asinh", "+", "x2", "pow1_4", "x2"], ["+", "x1", "+", "x9", "+", "acos", "x1", "/", "+", "x1", "/", "x1", "x9", "-", "x1", "div3", "mult2", "x1"], ["cosh", "-", "x9", "+", "-", "x7", "<constant>", "/", "tanh", "*", "/", "x7", "+", "<constant>", "x10", "-", "x14", "/", "+", "x7", "/", "x10", "*", "<constant>", "/", "x17", "x9", "x10", "x14"], ["*", "x14", "*", "x7", "*", "x9", "+", "*", "x7", "x9", "-", "/", "mult5", "cos", "x8", "-", "x8", "x9", "sinh", "x16"], ["*", "x9", "tanh", "-", "pow1_2", "x12", "+", "<constant>", "*", "x10", "*", "x14", "*", "x8", "-", "x9", "/", "<constant>", "-", "+", "<constant>", "*", "<constant>", "x2", "pow5", "x3"], ["/", "sin", "x13", "cos", "*", "x10", "-", "x10", "*", "x13", "-", "x13", "atan", "x13"], ["-", "-", "x2", "-", "/", "pow3", "+", "x14", "-", "asinh", "/", "x12", "tan", "x14", "*", "x12", "asin", "-", "x12", "x14", "+", "x12", "x2", "x14", "atan", "x12"], ["pow1_2", "*", "+", "x5", "/", "x16", "x13", "mult4", "-", "x15", "*", "pow2", "x5", "tanh", "/", "+", "x13", "div4", "x15", "x8"], ["/", "mult3", "/", "x13", "/", "+", "*", "<constant>", "x4", "-", "x4", "x13", "x4", "log", "pow1_4", "x4"], ["abs", "/", "tan", "/", "x6", "-", "/", "pow2", "x12", "x10", "x2", "/", "pow1_4", "x7", "x2"], ["+", "x16", "/", "cosh", "+", "x4", "+", "exp", "x11", "+", "-", "<constant>", "x1", "-", "mult3", "-", "x3", "pow2", "pow5", "x7", "x11", "x3"], ["/", "+", "<constant>", "+", "x12", "+", "x13", "+", "x14", "mult2", "x2", "sinh", "x12"], ["asinh", "-", "mult2", "x9", "pow2", "acos", "-", "-", "x9", "-", "pow2", "x9", "acos", "x9", "abs", "x9"], ["*", "<constant>", "*", "/", "x5", "div5", "-", "pow1_2", "x2", "/", "x7", "<constant>", "pow1_4", "-", "-", "x7", "log", "/", "x5", "x2", "pow2", "x5"], ["pow1_2", "*", "x10", "+", "x8", "*", "x12", "*", "+", "x13", "/", "x16", "*", "x15", "x8", "exp", "div3", "div4", "-", "x3", "-", "+", "x14", "mult5", "x17", "<constant>"], ["*", "x17", "/", "sinh", "pow3", "+", "x16", "/", "x17", "x16", "*", "pow4", "x17", "pow4", "*", "x17", "+", "x16", "div4", "x17"], ["-", "sin", "-", "-", "x2", "atan", "/", "x7", "x11", "*", "x12", "div2", "x2", "+", "x7", "*", "x12", "x7"], ["*", "float(\"inf\")", "*", "-", "+", "x2", "mult2", "x5", "<constant>", "-", "mult5", "/", "inv", "*", "x2", "x5", "x2", "x5"], ["*", "/", "x16", "x4", "-", "+", "x11", "x16", "cos", "-", "/", "pow1_3", "x4", "*", "atanh", "x16", "+", "x4", "-", "exp", "x11", "atan", "-", "+", "x4", "div4", "x16", "x16", "x16"], ["/", "x16", "<constant>"], ["*", "+", "x8", "*", "x12", "/", "<constant>", "x5", "-", "<constant>", "/", "/", "+", "x5", "/", "+", "<constant>", "x5", "mult3", "mult2", "x12", "<constant>", "x5"], ["*", "pow2", "x12", "+", "mult2", "pow2", "x12", "asin", "*", "x12", "-", "/", "tan", "x12", "x12", "*", "x12", "-", "pow5", "x12", "x12"], ["-", "pow4", "*", "x14", "+", "x12", "-", "+", "x11", "*", "<constant>", "x8", "x1", "mult5", "x1"], ["abs", "/", "/", "+", "<constant>", "x5", "x5", "neg", "x5"], ["-", "/", "mult3", "mult2", "x5", "-", "+", "x14", "x15", "-", "pow1_4", "x8", "*", "x6", "-", "-", "x11", "-", "x17", "*", "x13", "x7", "pow5", "/", "tanh", "x16", "+", "x11", "x3", "x9"], ["+", "sinh", "x3", "-", "-", "log", "*", "x17", "*", "/", "x9", "x4", "+", "x12", "/", "/", "x15", "x1", "x16", "x7", "abs", "-", "-", "<constant>", "x11", "-", "x13", "x8"], ["+", "x13", "-", "cos", "x13", "x14"], ["+", "inv", "cos", "asin", "sin", "x9", "-", "neg", "x9", "pow3", "atanh", "inv", "x9"], ["+", "x6", "*", "/", "tanh", "x1", "x6", "+", "div2", "x6", "-", "x1", "mult4", "/", "x5", "*", "x1", "x6"], ["*", "float(\"-inf\")", "+", "x14", "mult2", "x1"], ["pow4", "div2", "*", "x10", "*", "x4", "atanh", "-", "x12", "+", "-", "x16", "*", "x4", "+", "x12", "/", "x14", "x5", "*", "+", "x4", "pow3", "x15", "+", "<constant>", "+", "x10", "x3"], ["div3", "*", "pow2", "x2", "/", "-", "/", "x13", "mult4", "x14", "x13", "*", "+", "<constant>", "x17", "/", "pow1_5", "x17", "+", "x6", "/", "x8", "*", "x1", "x16"], ["-", "/", "+", "x1", "*", "x9", "+", "x14", "+", "pow1_2", "x4", "cos", "+", "x1", "+", "x13", "/", "*", "x13", "/", "pow5", "x14", "pow1_2", "x10", "mult3", "x4", "x10", "x16"], ["+", "<constant>", "/", "+", "x6", "*", "x6", "/", "/", "/", "+", "x17", "mult4", "*", "x12", "pow2", "x15", "x2", "pow2", "x11", "x15", "asinh", "x13"], ["+", "x1", "+", "x13", "mult5", "+", "x6", "-", "/", "*", "x6", "*", "div5", "x1", "+", "x10", "x5", "x2", "/", "/", "x1", "/", "mult2", "x10", "x5", "x13"], ["/", "-", "/", "x9", "x3", "x14", "*", "div3", "x1", "pow4", "+", "x16", "-", "+", "x12", "x7", "+", "x10", "*", "x8", "-", "x15", "-", "neg", "x7", "x9"], ["/", "-", "div4", "x3", "x15", "atanh", "+", "*", "x15", "pow4", "x10", "-", "+", "*", "x10", "x12", "*", "x16", "+", "x5", "div4", "x3", "-", "pow2", "-", "x17", "x8", "x15"], ["div3", "-", "/", "x12", "+", "x10", "pow1_3", "/", "*", "asinh", "x11", "-", "x4", "x7", "*", "x4", "-", "x12", "div5", "x5", "+", "x10", "+", "x14", "atan", "-", "x11", "x14"], ["*", "x5", "-", "-", "x10", "+", "<constant>", "+", "mult2", "x10", "pow1_5", "x5", "-", "x5", "/", "mult2", "x10", "<constant>"], ["*", "-", "x4", "x9", "pow5", "*", "<constant>", "*", "x12", "div4", "div4", "/", "x17", "x11"], ["+", "x6", "-", "/", "pow1_4", "+", "tanh", "x6", "-", "+", "<constant>", "+", "x2", "x6", "x9", "x9", "mult2", "x2"], ["*", "x1", "*", "/", "x17", "pow2", "x7", "-", "+", "x5", "+", "-", "x3", "x8", "/", "+", "x11", "+", "x15", "+", "x8", "-", "acosh", "x12", "x2", "x7", "x16"], ["asinh", "+", "x17", "/", "x17", "-", "/", "+", "x17", "*", "x17", "-", "pow1_2", "sin", "pow2", "div5", "pow2", "x17", "x17", "tanh", "x17", "pow5", "x17"], ["*", "x2", "/", "/", "pow5", "-", "x12", "+", "x14", "div5", "*", "x2", "+", "x12", "-", "x14", "x2", "x14", "atan", "x14"], ["-", "/", "x10", "x12", "+", "x8", "-", "+", "x14", "pow3", "x3", "/", "-", "x15", "x4", "-", "*", "x1", "*", "x10", "div4", "x14", "/", "x1", "x11"], ["-", "acosh", "-", "<constant>", "/", "x2", "x16", "+", "x2", "-", "/", "mult5", "/", "abs", "*", "x16", "x2", "x2", "x16", "div3", "-", "x16", "x2"], ["/", "x14", "/", "neg", "x17", "/", "*", "x17", "*", "neg", "x11", "/", "+", "x9", "/", "pow2", "x14", "div5", "x11", "x1", "div2", "x3"], ["*", "<constant>", "+", "mult5", "x2", "*", "<constant>", "+", "x15", "+", "x16", "+", "x2", "+", "div2", "x17", "-", "mult3", "abs", "/", "pow4", "acos", "x5", "x17", "mult5", "x15"], ["*", "x15", "-", "x11", "*", "x11", "/", "+", "x9", "asinh", "asin", "*", "x9", "-", "sinh", "sinh", "x9", "x9", "x9"], ["*", "acos", "x13", "/", "-", "/", "+", "acos", "-", "x15", "/", "x6", "x7", "*", "x17", "+", "/", "x16", "x15", "div2", "atan", "x3", "x3", "atanh", "x15", "/", "asin", "x17", "x17"], ["+", "/", "div4", "x15", "x14", "+", "-", "*", "x11", "tan", "x8", "x14", "+", "-", "atanh", "*", "x11", "x17", "x7", "*", "x5", "+", "x8", "*", "/", "x5", "x17", "+", "x6", "x7"], ["/", "/", "exp", "/", "+", "x3", "*", "x12", "+", "x14", "-", "*", "x1", "+", "x17", "/", "<constant>", "x6", "x7", "x14", "x2", "/", "x6", "-", "-", "cos", "x9", "/", "x15", "x1", "x1"], ["-", "/", "x15", "-", "div5", "pow4", "x11", "mult4", "/", "*", "/", "x11", "x8", "-", "log", "/", "pow2", "x15", "x17", "x8", "pow1_4", "x17", "pow4", "x15"], ["/", "-", "x6", "*", "+", "inv", "x6", "pow2", "x6", "tan", "-", "+", "x17", "/", "x17", "sinh", "inv", "pow2", "x6", "x6", "x6"], ["/", "*", "x12", "-", "+", "x12", "+", "pow4", "x12", "mult2", "x5", "pow4", "+", "pow2", "x14", "pow2", "x5", "-", "pow1_3", "x5", "pow2", "x14"], ["*", "-", "+", "x15", "x3", "<constant>", "/", "+", "x14", "+", "x2", "+", "x5", "pow4", "/", "x13", "x7", "*", "cosh", "pow4", "x2", "mult2", "-", "x6", "*", "x11", "cosh", "x7"], ["+", "<constant>", "+", "div4", "+", "x8", "-", "x4", "pow2", "/", "x1", "/", "x13", "x12", "/", "+", "x13", "x7", "+", "x11", "/", "/", "x14", "x9", "*", "x7", "-", "x5", "cosh", "pow1_5", "x10"], ["/", "+", "<constant>", "x11", "*", "x11", "tanh", "asinh", "+", "x11", "pow4", "*", "x11", "abs", "/", "<constant>", "x11"], ["+", "x12", "*", "/", "neg", "x6", "x1", "/", "-", "pow1_3", "-", "x12", "x13", "+", "x6", "/", "+", "x5", "x7", "<constant>", "+", "<constant>", "/", "x15", "-", "x5", "x1"], ["*", "pow1_2", "*", "x15", "div3", "x9", "+", "pow1_5", "x4", "-", "/", "x11", "*", "x1", "*", "x7", "/", "x16", "-", "/", "x17", "-", "/", "x12", "mult3", "x8", "x2", "x5", "x13"], ["-", "x8", "/", "-", "mult2", "x8", "mult2", "+", "x8", "+", "mult2", "x8", "-", "-", "log", "x8", "/", "x8", "-", "exp", "mult2", "x8", "x8", "pow2", "x8", "x8"], ["-", "x17", "*", "/", "x8", "/", "x3", "-", "x7", "<constant>", "+", "x15", "/", "-", "pow4", "+", "x1", "x12", "-", "x6", "x14", "x16"], ["/", "/", "mult5", "/", "tanh", "x9", "+", "x9", "/", "x13", "-", "-", "x2", "-", "atan", "-", "x11", "x9", "x6", "x5", "x5", "x17"], ["/", "*", "x15", "mult3", "+", "x15", "-", "acosh", "/", "x12", "x8", "+", "x9", "-", "x16", "x17", "+", "tanh", "x12", "-", "x4", "abs", "x16"], ["pow5", "*", "/", "x11", "x2", "*", "sin", "*", "<constant>", "x4", "/", "x17", "-", "log", "/", "mult2", "*", "x1", "x5", "x6", "-", "*", "x7", "-", "x8", "x3", "x9"], ["+", "x17", "-", "-", "x3", "/", "/", "x17", "x9", "acosh", "pow2", "x3", "x1"], ["+", "acos", "pow1_5", "x6", "pow2", "+", "*", "x1", "x17", "*", "pow1_3", "x12", "/", "+", "*", "x13", "x15", "/", "/", "x5", "x2", "x13", "+", "x17", "*", "x17", "x3"], ["/", "x9", "-", "+", "x1", "exp", "div2", "sinh", "*", "x16", "+", "x3", "+", "x5", "+", "/", "mult4", "x17", "x8", "*", "pow2", "x6", "+", "x13", "/", "-", "x4", "x12", "x7", "x2"], ["/", "inv", "div3", "/", "-", "x16", "-", "x17", "mult2", "x16", "pow1_4", "pow1_3", "x16", "x17"], ["*", "x17", "+", "<constant>", "-", "x13", "pow1_3", "div3", "/", "*", "x10", "/", "pow2", "x1", "x11", "/", "x7", "+", "x14", "+", "x7", "tanh", "x4"], ["/", "-", "/", "pow5", "pow3", "-", "atanh", "x16", "x16", "x16", "mult3", "x16", "pow2", "x16"], ["+", "-", "x13", "x5", "pow1_4", "+", "x9", "/", "*", "<constant>", "*", "x6", "-", "tanh", "pow1_3", "x11", "x14", "/", "exp", "-", "x15", "x4", "x2"], ["+", "x15", "/", "x15", "+", "<constant>", "+", "mult3", "x15", "*", "x15", "asin", "x15"], ["exp", "/", "x9", "-", "*", "x1", "-", "x16", "*", "abs", "x17", "-", "x1", "+", "x16", "-", "sinh", "*", "x17", "sin", "neg", "x9", "x8", "-", "x16", "x8"], ["/", "-", "/", "x7", "x8", "pow1_2", "-", "mult2", "x8", "div3", "*", "x14", "mult2", "x7", "/", "inv", "x8", "/", "x7", "log", "inv", "x7"], ["-", "/", "x10", "-", "x7", "/", "x14", "+", "x17", "x8", "+", "/", "/", "<constant>", "x3", "x16", "*", "x9", "mult5", "-", "/", "+", "x4", "-", "pow1_3", "x13", "x11", "x15", "abs", "x2"], ["-", "sinh", "*", "<constant>", "-", "x8", "/", "cosh", "/", "x2", "x11", "+", "-", "x1", "x12", "*", "x17", "abs", "sinh", "x1", "x15"], ["cos", "div3", "*", "x12", "+", "mult2", "x15", "-", "x12", "/", "-", "x16", "x14", "/", "pow2", "*", "x14", "/", "x15", "x16", "x16"], ["*", "x4", "log", "*", "x3", "+", "<constant>", "-", "*", "+", "x3", "-", "<constant>", "x4", "sin", "-", "tan", "x3", "-", "<constant>", "pow1_3", "atanh", "div5", "-", "<constant>", "x4", "x4"], ["-", "x5", "/", "-", "*", "<constant>", "*", "x5", "/", "acos", "*", "x8", "/", "/", "<constant>", "x2", "exp", "x15", "x3", "x13", "abs", "+", "x1", "*", "x7", "-", "x4", "x10"], ["cos", "*", "x2", "*", "-", "exp", "inv", "div3", "+", "x1", "x12", "x8", "+", "sin", "x17", "div2", "/", "x11", "pow5", "exp", "mult2", "x13"], ["-", "+", "<constant>", "-", "/", "neg", "x15", "pow4", "*", "x15", "/", "asinh", "x11", "x13", "asin", "/", "x13", "+", "x15", "mult2", "x11", "mult2", "x15"], ["/", "-", "cosh", "*", "x14", "+", "x2", "/", "x2", "asin", "mult3", "x2", "/", "x2", "/", "cosh", "x11", "x14", "x11"], ["*", "div3", "-", "x10", "-", "<constant>", "+", "acosh", "x16", "*", "x15", "x16", "/", "-", "x12", "exp", "/", "*", "x13", "/", "x17", "x7", "x16", "sinh", "x14"], ["pow1_3", "+", "x9", "+", "asinh", "/", "x9", "div5", "x3", "pow1_4", "+", "pow1_5", "x3", "+", "pow4", "x3", "/", "asin", "x3", "/", "*", "x1", "/", "-", "x14", "x3", "x14", "x3"], ["/", "x1", "/", "*", "pow1_5", "x16", "/", "mult5", "acos", "/", "asinh", "x8", "x8", "-", "acosh", "x15", "/", "x16", "x2", "/", "x2", "/", "x5", "+", "x5", "atan", "+", "x15", "x2"], ["/", "*", "-", "x2", "sin", "pow1_2", "x2", "/", "pow1_4", "x2", "/", "x2", "cosh", "x2", "pow4", "*", "x2", "-", "-", "+", "x2", "pow1_4", "x2", "cos", "pow2", "x4", "x4"], ["+", "x16", "+", "x5", "-", "+", "*", "x9", "-", "x6", "x12", "-", "x4", "/", "+", "<constant>", "x11", "-", "-", "*", "x14", "-", "+", "x12", "x9", "x3", "x1", "x4", "<constant>"], ["/", "*", "sin", "x3", "div4", "+", "-", "x7", "x10", "atan", "*", "x8", "/", "/", "x16", "/", "+", "x15", "x5", "div5", "/", "x13", "x4", "x4", "x12"], ["/", "pow4", "*", "log", "x5", "*", "/", "pow1_2", "x5", "x8", "/", "pow1_4", "x8", "pow2", "x5", "log", "*", "x7", "pow1_2", "*", "x5", "pow5", "x7"], ["-", "pow4", "x13", "pow1_2", "/", "x7", "cosh", "*", "div5", "x1", "-", "-", "x15", "pow5", "x8", "/", "x10", "pow1_4", "+", "x17", "*", "<constant>", "x8"], ["*", "x3", "/", "x16", "*", "+", "x5", "-", "x6", "x4", "/", "*", "<constant>", "x13", "-", "/", "x10", "/", "-", "-", "*", "x2", "x7", "+", "<constant>", "+", "x11", "x9", "x3", "x14", "tan", "x3"], ["*", "x13", "+", "-", "-", "inv", "x10", "x7", "x13", "pow4", "+", "-", "mult2", "x4", "x7", "*", "abs", "x9", "+", "x7", "+", "atanh", "x10", "*", "x7", "div3", "x10"], ["mult3", "/", "-", "+", "x7", "*", "x7", "pow2", "x5", "x5", "+", "x7", "/", "tanh", "tan", "-", "*", "x5", "tan", "x5", "div4", "x5", "sinh", "-", "x7", "x5"], ["/", "+", "x4", "pow1_2", "*", "x4", "/", "x15", "+", "pow1_3", "-", "<constant>", "x4", "-", "/", "x15", "x4", "x12", "/", "x15", "pow3", "div3", "mult4", "x12"], ["*", "float(\"inf\")", "/", "tan", "x2", "x2"], ["-", "cosh", "-", "exp", "atan", "/", "x6", "*", "x7", "/", "*", "x11", "/", "<constant>", "pow1_2", "sin", "x3", "x16", "tan", "x5", "x1"], ["-", "+", "x2", "/", "/", "cosh", "x14", "x2", "<constant>", "*", "pow2", "x11", "+", "x5", "-", "+", "x2", "div4", "cosh", "x2", "pow1_5", "pow3", "*", "<constant>", "*", "x14", "x2"], ["/", "*", "acosh", "x1", "-", "/", "sinh", "pow5", "pow1_4", "/", "x7", "+", "x1", "cosh", "+", "pow1_4", "x7", "-", "x15", "x4", "/", "+", "x15", "x7", "x1", "x7", "x4"], ["+", "-", "-", "*", "x14", "x16", "mult2", "x16", "x6", "-", "neg", "x6", "-", "acosh", "x9", "inv", "-", "cosh", "x9", "/", "x15", "x14"], ["float(\"inf\")"], ["/", "x17", "cosh", "*", "atanh", "pow1_2", "x1", "/", "-", "x17", "/", "-", "+", "x17", "*", "x10", "x17", "pow2", "x17", "div5", "x17", "/", "-", "x10", "x1", "x10"], ["-", "*", "<constant>", "*", "/", "cos", "x11", "x12", "div4", "/", "x12", "mult2", "x11", "+", "x12", "div3", "*", "x12", "-", "x11", "<constant>"], ["/", "div5", "x7", "/", "tan", "sin", "*", "pow1_5", "x7", "*", "atanh", "x9", "asin", "-", "x12", "div2", "x7", "x9"], ["sin", "*", "x14", "asinh", "*", "pow2", "x14", "cos", "mult4", "atan", "neg", "/", "asin", "x14", "*", "x14", "-", "x14", "sin", "x14"], ["+", "x12", "tanh", "/", "acosh", "x11", "*", "x17", "*", "-", "x3", "+", "x1", "x17", "-", "-", "*", "x2", "-", "inv", "x13", "sinh", "x8", "x14", "x1"], ["*", "x9", "/", "x11", "+", "x1", "+", "x7", "log", "-", "-", "+", "x16", "x17", "*", "<constant>", "*", "x14", "exp", "x13", "/", "-", "x3", "-", "x15", "atanh", "x5", "x10"], ["-", "*", "x2", "x8", "*", "x14", "-", "/", "/", "x6", "x7", "-", "sin", "x12", "+", "/", "x17", "x10", "-", "pow3", "/", "pow1_4", "/", "x16", "x5", "div5", "x1", "x4", "x13"], ["*", "x3", "+", "mult2", "x1", "+", "exp", "x11", "-", "-", "x6", "x15", "+", "x7", "+", "*", "<constant>", "*", "x3", "x8", "pow4", "-", "x1", "pow1_5", "x10"], ["*", "x2", "pow2", "div2", "*", "x10", "tan", "pow3", "tanh", "/", "/", "+", "<constant>", "+", "x14", "-", "*", "x11", "abs", "+", "x3", "x6", "x11", "x10", "x5"], ["*", "-", "x13", "<constant>", "+", "x13", "pow1_4", "*", "x13", "+", "x13", "+", "cosh", "x11", "div3", "*", "x11", "-", "x13", "x11"], ["+", "x14", "/", "cosh", "*", "div5", "pow3", "x5", "-", "/", "x2", "+", "x5", "mult2", "x2", "x15", "x2"], ["-", "*", "x3", "acos", "x3", "*", "x13", "/", "/", "x2", "cosh", "x2", "tan", "*", "/", "x3", "x11", "/", "-", "/", "x13", "<constant>", "pow1_4", "x15", "x2"], ["inv", "-", "pow1_3", "+", "inv", "x17", "+", "asinh", "*", "<constant>", "acosh", "/", "x9", "<constant>", "*", "<constant>", "*", "pow1_4", "x17", "-", "<constant>", "pow1_5", "x17", "x17"], ["+", "-", "x12", "x15", "/", "+", "x6", "x8", "-", "-", "*", "pow3", "x6", "*", "sinh", "*", "x13", "x2", "+", "x7", "+", "/", "x12", "x8", "*", "x8", "-", "x15", "x13", "x12", "x17"], ["tanh", "div4", "pow1_3", "*", "x16", "+", "x10", "acosh", "+", "x1", "-", "x7", "-", "mult3", "*", "x2", "-", "x13", "+", "x12", "pow1_4", "x12", "-", "x15", "pow1_4", "x8"], ["-", "+", "x8", "*", "x10", "x9", "log", "pow1_2", "/", "-", "/", "+", "x12", "x14", "*", "x10", "x8", "-", "x12", "*", "x14", "x7", "x9"], ["*", "<constant>", "*", "x11", "*", "x12", "*", "x16", "/", "pow1_2", "+", "x13", "+", "x4", "pow3", "*", "x14", "*", "x17", "/", "x5", "-", "x9", "x2", "x3"], ["-", "mult2", "x7", "pow5", "-", "/", "x7", "*", "<constant>", "asin", "*", "<constant>", "log", "asinh", "x7", "<constant>"], ["pow1_2", "+", "-", "+", "x8", "-", "x10", "x11", "x17", "*", "mult2", "x17", "/", "acosh", "-", "x13", "x15", "x3"], ["+", "-", "+", "<constant>", "acos", "x9", "mult4", "x16", "*", "x16", "*", "/", "x2", "x9", "-", "x14", "/", "pow5", "x7", "mult2", "x15"], ["atanh", "-", "div2", "-", "x15", "/", "*", "x2", "*", "/", "*", "pow2", "x11", "mult2", "x15", "x15", "asin", "-", "x15", "*", "x15", "mult2", "x11", "x7", "acosh", "x11"], ["pow3", "*", "cosh", "x16", "*", "-", "x12", "x10", "-", "div4", "/", "x1", "atan", "x17", "sinh", "+", "x6", "-", "x5", "pow4", "x6"], ["/", "+", "x10", "*", "<constant>", "/", "+", "x3", "+", "mult2", "x1", "-", "+", "x10", "*", "x15", "asin", "x15", "/", "x9", "x10", "*", "x1", "x3", "pow1_3", "x7"], ["-", "*", "x4", "-", "*", "x10", "x2", "+", "x11", "*", "x10", "+", "x3", "/", "-", "+", "x11", "x16", "pow5", "x12", "x17", "x13"], ["*", "<constant>", "tanh", "*", "abs", "div3", "mult2", "x4", "pow2", "/", "atanh", "/", "x16", "+", "x3", "x6", "x12"], ["/", "*", "x16", "/", "x5", "tanh", "+", "x10", "pow3", "div4", "-", "asin", "/", "+", "x4", "-", "+", "x10", "x12", "<constant>", "x8", "inv", "-", "x8", "x1", "x7"], ["-", "/", "/", "sin", "atan", "x4", "-", "<constant>", "x4", "x4", "atan", "x4"], ["/", "-", "+", "asinh", "*", "x10", "mult4", "acos", "x6", "-", "cosh", "x15", "+", "x17", "+", "x8", "asinh", "div5", "/", "x11", "x12", "x6", "+", "x9", "*", "x12", "+", "<constant>", "x10"], ["/", "<constant>", "-", "mult2", "x2", "+", "x15", "+", "inv", "mult5", "x2", "/", "-", "x5", "-", "-", "<constant>", "x2", "x15", "/", "cosh", "x11", "x10"], ["-", "*", "x1", "x17", "/", "x8", "+", "x10", "*", "x16", "/", "sinh", "x13", "-", "*", "<constant>", "x6", "x11"], ["-", "*", "x6", "-", "/", "x7", "/", "+", "x1", "mult2", "x2", "/", "x6", "div3", "-", "x2", "x1", "pow1_5", "pow4", "pow1_4", "x7", "x6"], ["div4", "+", "-", "x1", "x10", "/", "-", "x12", "x6", "-", "pow1_5", "x1", "pow1_2", "*", "x10", "x6"], ["/", "/", "*", "x15", "div3", "x12", "+", "x15", "/", "cos", "asin", "x12", "x12", "x12"], ["*", "pow1_5", "x4", "mult5", "+", "*", "x15", "neg", "mult2", "x14", "exp", "/", "x11", "*", "x17", "*", "x2", "*", "+", "x13", "x7", "*", "/", "x9", "x1", "+", "<constant>", "+", "x1", "x3"], ["*", "div2", "x3", "+", "x3", "*", "mult2", "x3", "/", "x3", "*", "exp", "x3", "+", "x3", "*", "x3", "log", "mult2", "x3"], ["*", "x15", "-", "pow1_5", "neg", "x12", "-", "x12", "*", "x15", "+", "x12", "+", "x8", "+", "inv", "x15", "+", "mult3", "x8", "tan", "-", "*", "x8", "mult3", "x15", "x12"], ["-", "/", "x11", "x5", "+", "mult2", "x11", "*", "pow3", "x5", "mult3", "neg", "+", "pow1_3", "x11", "/", "-", "x11", "x5", "div3", "x5"], ["mult5", "-", "div2", "x17", "*", "<constant>", "-", "-", "<constant>", "*", "x8", "pow3", "*", "x13", "x17", "/", "x17", "x13"], ["exp", "+", "x10", "sin", "-", "-", "cos", "pow5", "*", "x7", "-", "*", "pow2", "x10", "+", "mult3", "x16", "pow2", "atanh", "x10", "x7", "/", "x10", "x16", "cos", "x16"], ["+", "x16", "/", "*", "x14", "-", "sin", "x16", "*", "x14", "tanh", "+", "x14", "+", "div5", "x16", "pow1_4", "*", "x14", "*", "x16", "acosh", "inv", "x14", "x16"], ["mult3", "*", "/", "/", "x3", "mult2", "sinh", "*", "x2", "pow1_4", "x5", "x15", "+", "<constant>", "/", "x1", "pow1_2", "-", "*", "x13", "x17", "*", "x16", "-", "x10", "/", "x4", "x6"], ["pow1_2", "/", "x16", "*", "asin", "div4", "x14", "+", "x11", "mult3", "-", "/", "/", "asinh", "div2", "/", "exp", "x9", "+", "x17", "x7", "x4", "*", "x2", "x3", "-", "x8", "x5"], ["*", "x10", "-", "+", "div5", "x13", "acos", "*", "x11", "x9", "-", "x4", "/", "-", "/", "x2", "mult3", "x3", "<constant>", "*", "x14", "/", "+", "x1", "*", "x15", "x5", "x16"], ["-", "/", "x14", "*", "mult5", "x10", "*", "exp", "x5", "/", "inv", "x14", "atanh", "x10", "/", "mult2", "x10", "pow1_3", "x14"], ["-", "x10", "-", "x11", "mult5", "*", "x10", "*", "tan", "x11", "/", "/", "pow2", "x10", "x11", "/", "asinh", "-", "/", "/", "x10", "x11", "x1", "x1", "+", "x1", "x11"], ["/", "x3", "-", "/", "+", "*", "x8", "pow3", "+", "x2", "tan", "x10", "*", "x10", "+", "x17", "-", "pow1_5", "x17", "/", "x2", "x10", "-", "x3", "x8", "+", "x17", "x2"], ["/", "x12", "+", "x12", "-", "-", "*", "x14", "x8", "-", "+", "x16", "x5", "/", "/", "/", "x12", "*", "cosh", "x8", "-", "x3", "/", "x8", "x17", "*", "x14", "x15", "+", "x3", "x4", "x15"], ["div5", "mult3", "/", "+", "x7", "+", "inv", "x2", "acos", "pow1_4", "x5", "*", "x4", "div2", "-", "x8", "*", "x12", "*", "x4", "sin", "/", "x9", "pow4", "x16"], ["*", "x8", "*", "+", "mult3", "x13", "+", "inv", "x5", "*", "x3", "pow5", "abs", "x14", "/", "x10", "+", "x6", "asinh", "-", "*", "abs", "x12", "sin", "sinh", "x2", "x8"], ["mult2", "/", "asin", "-", "cosh", "x10", "x10", "+", "*", "x10", "cosh", "x10", "sin", "+", "x10", "pow2", "x10"], ["/", "*", "x10", "*", "x2", "-", "pow5", "/", "-", "<constant>", "x11", "*", "x13", "x15", "+", "x5", "+", "*", "x11", "x13", "*", "x9", "+", "x13", "x3", "+", "x15", "+", "x2", "+", "x8", "x9"], ["/", "div5", "*", "tanh", "*", "x2", "x8", "mult2", "abs", "mult2", "neg", "pow2", "x8", "x8"], ["div2", "/", "pow5", "div4", "+", "*", "x3", "atanh", "x14", "acosh", "-", "x3", "asinh", "x3", "*", "x13", "asin", "-", "pow1_5", "/", "x13", "x11", "<constant>"], ["/", "*", "x2", "x3", "*", "x16", "-", "x16", "/", "/", "mult5", "+", "x4", "mult5", "+", "x7", "*", "x6", "*", "/", "x15", "mult4", "x12", "+", "<constant>", "/", "*", "x5", "x9", "x13", "x15", "x14"], ["*", "x10", "-", "pow1_3", "x10", "*", "pow4", "*", "x6", "-", "x10", "x6", "/", "+", "x10", "*", "x10", "atan", "div2", "x17", "pow2", "x17"], ["div3", "*", "/", "x7", "acosh", "x14", "acos", "tan", "/", "pow2", "x7", "+", "/", "sinh", "abs", "x7", "sinh", "x13", "*", "x14", "asinh", "*", "x13", "pow2", "x7"], ["+", "x14", "+", "/", "x4", "-", "mult2", "x16", "x3", "/", "x6", "-", "x4", "*", "-", "x9", "x16", "+", "<constant>", "*", "x8", "-", "x13", "/", "*", "x10", "-", "<constant>", "x15", "pow1_5", "x9"], ["*", "+", "x1", "x7", "/", "x14", "*", "<constant>", "+", "x6", "+", "div3", "+", "x4", "asinh", "x5", "/", "sin", "x4", "-", "<constant>", "log", "+", "x4", "acos", "/", "x5", "-", "x14", "x7"], ["+", "/", "x3", "x2", "pow4", "*", "pow1_3", "+", "x3", "*", "<constant>", "log", "log", "x7", "-", "div5", "x2", "exp", "mult2", "-", "pow2", "x7", "<constant>"], ["float(\"nan\")"], ["*", "float(\"inf\")", "x8"], ["*", "mult2", "x11", "mult2", "+", "x14", "-", "/", "/", "-", "mult4", "x17", "mult3", "x15", "x11", "*", "/", "x3", "pow4", "x10", "pow1_4", "+", "x15", "x17", "x10"], ["-", "x7", "mult2", "-", "div2", "-", "x4", "div4", "sin", "mult3", "-", "x11", "x15", "x3"], ["abs", "+", "/", "<constant>", "x7", "+", "/", "x3", "pow1_5", "x5", "pow5", "-", "cosh", "-", "asin", "/", "x5", "+", "x5", "tanh", "x10", "/", "<constant>", "x11", "+", "x6", "log", "x5"], ["/", "+", "x16", "+", "-", "x12", "x1", "acosh", "tan", "-", "x12", "abs", "+", "mult2", "x1", "div3", "mult4", "x11", "pow2", "*", "<constant>", "atan", "x16"], ["*", "x16", "/", "x2", "*", "div3", "x8", "asinh", "pow1_4", "+", "div2", "x13", "-", "pow2", "+", "x16", "x4", "-", "-", "x16", "mult4", "*", "x2", "+", "x11", "x12", "x8"], ["acos", "/", "cosh", "-", "pow1_2", "/", "x13", "acosh", "*", "x7", "*", "/", "x9", "/", "x11", "<constant>", "+", "x11", "/", "x9", "*", "x11", "mult2", "x13", "sin", "+", "x11", "x17", "x8"], ["/", "/", "x4", "x10", "/", "-", "x12", "exp", "acosh", "x10", "/", "atanh", "mult5", "x4", "/", "+", "<constant>", "x12", "abs", "x12"], ["+", "x1", "/", "/", "-", "x14", "mult3", "-", "exp", "/", "+", "x10", "pow2", "-", "x6", "x10", "asinh", "x13", "x7", "pow2", "x13", "+", "x14", "x2"], ["/", "sin", "*", "+", "<constant>", "x5", "/", "x17", "-", "-", "/", "x13", "x8", "<constant>", "-", "acosh", "x8", "x8", "*", "+", "x1", "x11", "-", "x13", "x5"], ["+", "x6", "/", "acosh", "x4", "/", "x3", "/", "acosh", "x4", "div5", "-", "cos", "*", "x15", "-", "x6", "x14", "sinh", "x3"], ["-", "-", "+", "x1", "+", "x11", "+", "/", "acos", "/", "x12", "x6", "x9", "*", "+", "x14", "x16", "asin", "mult4", "x17", "x13", "mult3", "-", "+", "x4", "/", "x15", "x7", "x2"], ["/", "*", "+", "x14", "+", "x6", "cos", "x17", "-", "/", "+", "x14", "/", "/", "x17", "atanh", "x13", "+", "<constant>", "div4", "x5", "-", "asinh", "x5", "x16", "<constant>", "x12"], ["*", "pow2", "/", "x1", "x11", "+", "x11", "-", "x14", "acos", "-", "pow1_3", "*", "x12", "-", "x14", "tan", "+", "x12", "pow2", "x5", "x12"], ["+", "x14", "pow1_3", "+", "x14", "x15"], ["-", "/", "/", "x15", "pow2", "x17", "x17", "mult3", "pow4", "/", "x17", "-", "sinh", "*", "x15", "x17", "x17"], ["div5", "+", "*", "acos", "x12", "cosh", "div4", "x16", "-", "x9", "acosh", "+", "x1", "+", "x11", "+", "x7", "div3", "/", "x14", "*", "mult4", "x4", "pow1_4", "/", "x2", "x15"], ["/", "+", "mult2", "x13", "inv", "asinh", "log", "x13", "x13"], ["-", "*", "x5", "pow2", "-", "acos", "x6", "/", "x6", "/", "+", "x7", "pow1_4", "x9", "-", "asinh", "+", "x14", "pow2", "x5", "mult3", "log", "x14", "x6"], ["*", "float(\"-inf\")", "/", "x14", "*", "x11", "+", "x11", "+", "x14", "x15"], ["/", "-", "<constant>", "x7", "*", "<constant>", "x3"], ["neg", "/", "x1", "exp", "/", "-", "/", "exp", "/", "x14", "x1", "atanh", "/", "x1", "x14", "x14", "tan", "mult3", "mult2", "x1"], ["-", "/", "<constant>", "abs", "/", "/", "x16", "-", "+", "sin", "x14", "*", "x8", "+", "x1", "x3", "*", "x15", "x3", "/", "x9", "+", "x10", "/", "abs", "x11", "*", "x2", "+", "x17", "x5", "x4"], ["mult5", "+", "<constant>", "abs", "x10"], ["-", "x13", "*", "x17", "acosh", "/", "/", "sinh", "mult3", "pow2", "x13", "*", "x13", "x17", "+", "x13", "x17"], ["/", "x10", "-", "*", "x13", "/", "x7", "x3", "-", "-", "cos", "x6", "x15", "pow1_3", "cos", "*", "-", "-", "x11", "<constant>", "x16", "+", "x1", "*", "x2", "+", "x12", "x9"], ["+", "-", "x11", "*", "x15", "pow3", "-", "x15", "x11", "acosh", "-", "*", "sin", "x13", "*", "div5", "x15", "sin", "*", "x11", "pow", "float(\"-inf\")", "x15", "x11"], ["sin", "+", "x4", "cos", "/", "/", "-", "x7", "-", "x1", "<constant>", "pow1_3", "+", "x11", "+", "x3", "div5", "/", "+", "<constant>", "x15", "x10", "/", "x17", "x4"], ["*", "/", "<constant>", "x9", "+", "log", "x11", "/", "mult5", "div3", "/", "x14", "x11", "mult2", "+", "x14", "*", "x6", "*", "asinh", "x7", "/", "*", "x15", "x16", "x3"], ["pow3", "-", "*", "x4", "/", "+", "x4", "+", "x5", "/", "/", "x14", "+", "x5", "inv", "x11", "x5", "/", "x16", "div5", "x4", "/", "x11", "exp", "x14"], ["*", "pow2", "x2", "*", "-", "/", "x2", "x14", "x14", "/", "mult5", "x14", "/", "pow1_4", "x6", "log", "/", "*", "pow5", "x16", "tanh", "x7", "acosh", "x7"], ["tan", "mult3", "+", "x16", "/", "*", "x17", "div3", "/", "-", "*", "+", "x3", "x6", "-", "x9", "x15", "x10", "asin", "exp", "x5", "/", "x11", "x7"], ["*", "x4", "mult2", "pow1_5", "+", "x11", "+", "x4", "pow1_3", "-", "*", "x11", "div3", "pow3", "acos", "/", "x4", "+", "<constant>", "pow1_3", "x4", "x11"], ["*", "x3", "-", "*", "x3", "-", "x3", "*", "x3", "atan", "+", "<constant>", "div3", "+", "div3", "x3", "tan", "mult2", "x3", "x3"], ["+", "x9", "-", "x11", "*", "-", "x6", "x13", "-", "-", "-", "acos", "-", "x8", "x15", "+", "x11", "x8", "pow1_2", "+", "x1", "x10", "pow2", "mult4", "pow2", "x12"], ["-", "*", "x17", "div5", "-", "x17", "-", "*", "float(\"-inf\")", "*", "x17", "+", "x17", "pow2", "x17", "abs", "sin", "x17", "x17"], ["/", "/", "-", "x11", "+", "x9", "cos", "acosh", "/", "x8", "pow5", "x5", "x5", "x3"], ["+", "x11", "+", "*", "x11", "log", "+", "x14", "abs", "x11", "tanh", "acosh", "/", "/", "div3", "x10", "x11", "atanh", "x15"], ["pow2", "+", "x12", "sinh", "*", "x9", "acosh", "+", "x11", "/", "-", "<constant>", "+", "/", "asin", "-", "x3", "<constant>", "x16", "-", "-", "x15", "*", "x13", "x14", "x10", "x11"], ["cosh", "*", "x1", "*", "+", "x11", "x9", "-", "x2", "-", "*", "x1", "+", "*", "x11", "*", "x2", "pow5", "x15", "*", "+", "x15", "*", "<constant>", "x3", "-", "<constant>", "/", "pow5", "x1", "x16", "x11"], ["pow1_4", "-", "*", "+", "x11", "+", "x14", "x9", "pow4", "+", "/", "x2", "x16", "tan", "+", "x11", "-", "+", "x16", "*", "x6", "+", "x6", "*", "x6", "x9", "x9", "x4"], ["+", "x6", "-", "pow1_4", "-", "sin", "mult5", "x6", "x13", "+", "x4", "/", "*", "mult4", "cosh", "x13", "asin", "-", "x4", "x13", "-", "x4", "mult4", "pow2", "x11"], ["/", "/", "-", "x15", "x6", "pow1_3", "-", "x13", "/", "+", "sin", "*", "x9", "-", "asin", "x4", "x14", "/", "x6", "*", "x7", "-", "+", "x12", "x13", "x11", "+", "x1", "-", "<constant>", "x17", "x5"], ["*", "x3", "-", "/", "-", "x7", "mult4", "asin", "-", "x4", "abs", "-", "x10", "x8", "+", "<constant>", "x5", "+", "<constant>", "+", "x11", "+", "x17", "x6"], ["/", "+", "*", "x2", "mult5", "pow2", "x3", "asinh", "*", "x17", "*", "x3", "/", "*", "x6", "x7", "*", "x2", "pow1_3", "*", "x5", "+", "x6", "div4", "x17", "x17"], ["x2"], ["div2", "*", "x10", "mult5", "-", "(-1)", "-", "inv", "cosh", "-", "mult2", "x10", "x7", "x7"], ["/", "+", "div2", "atanh", "/", "x2", "x7", "/", "x2", "-", "+", "x6", "mult3", "cosh", "pow1_5", "x12", "*", "x8", "pow3", "x6", "x7"], ["*", "pow1_2", "x9", "*", "/", "x13", "+", "x8", "*", "x14", "asinh", "x14", "+", "/", "x9", "x2", "/", "x9", "*", "x12", "div5", "x1"], ["mult2", "acosh", "*", "x3", "+", "x9", "mult5", "+", "x16", "/", "x10", "*", "x6", "*", "cosh", "x10", "-", "x10", "x11"], ["-", "x16", "+", "asin", "*", "x9", "*", "+", "x3", "x8", "+", "x15", "/", "pow5", "x13", "x11", "*", "x17", "/", "+", "x11", "/", "-", "<constant>", "-", "x2", "x12", "x10", "*", "x7", "/", "x5", "x6"], ["-", "x4", "+", "sin", "x7", "/", "*", "-", "+", "<constant>", "x11", "-", "atanh", "x11", "x14", "-", "tan", "/", "x7", "/", "x4", "tan", "x15", "pow5", "x15", "-", "+", "x2", "x5", "x3"], ["/", "inv", "asinh", "-", "x6", "x17", "mult5", "+", "x6", "*", "x15", "x6"], ["+", "pow2", "x15", "+", "sin", "pow2", "x15", "pow2", "sinh", "neg", "sinh", "x15"], ["/", "*", "x4", "+", "*", "x4", "sin", "x4", "/", "acosh", "x4", "pow2", "x4", "pow1_2", "*", "<constant>", "x4"], ["+", "x7", "asin", "neg", "/", "tan", "x7", "/", "-", "<constant>", "x7", "*", "atan", "x7", "pow1_4", "x7"]]
\ No newline at end of file
diff --git a/docs/index.md b/docs/index.md
index 19b0356..6d62ab1 100644
--- a/docs/index.md
+++ b/docs/index.md
@@ -21,8 +21,9 @@ costs that dominate at scale. SimpliPy was created to remove those bottlenecks:
 
 - **Prefix-first representation** – Expressions stay as token lists the entire
 	time, so there's no repeated parsing or AST allocation.
-- **Deterministic pipelines** – Rule application, operand sorting, and literal
-	masking always produce the same layout, which keeps downstream caches warm.
+- **Deterministic pipelines** – Rule application, operand sorting, and the separate
+	literal-masking step (`mask`) always produce the same layout, which keeps downstream
+	caches warm.
 - **ML-pipeline integration** – Outputs stay in the prefix token space consumed
 	by the `symbolic-data` layer (and through it by Flash-ANSR training) without
 	any conversion step, making it practical to simplify millions of candidates
@@ -55,26 +56,39 @@ of magnitude faster than SymPy, while producing near-identical simplification ra
 ## Simplification Pipeline (Pseudo-Algorithm)
 
 ```text
-function simplify(expr, max_iter=5):
-    tokens = parse(expr)               # infix→prefix, or validate existing prefix
-
-    for _ in range(max_iter):          # fixpoint loop
-        tokens = cancel_terms(tokens)  # one additive/multiplicative cancellation per pass
-        tokens = apply_rules(tokens)   # indexed rewrite patterns, top-down, first match wins
-        if unchanged_vs_previous_pass:
-            break                      # converged
-
-    tokens = mask_literals(tokens)     # collapse trivial numerics to <constant> (before sort)
-    tokens = sort_operands(tokens)     # canonical order for commutative ops
-    return tokens if len(tokens) <= len(input) else input   # longer results are rejected
+function simplify(expr, node_budget=48, mode=SOUND):
+    tokens = parse(expr)                        # infix→prefix, or validate existing prefix
+
+    loop:                                       # the EQUIVALENCE loop: search → sort to a fixpoint
+        best   = search(tokens, node_budget, mode)  # best-first over the rewrite MOVE graph
+                                                     # (apply the rules pass, or cancel any one
+                                                     # candidate); answer = shortest state VISITED
+        sorted = sort_operands(best)            # canonical order for commutative operands
+        if sorted == tokens: break              # converged
+        tokens = sorted
+    return tokens                               # never longer than the input (the input is
+                                                # state zero), sound and idempotent by construction
 ```
 
-Masking runs before sorting (so the canonical operand order is computed on the masked
-tokens and the mask/sort pair is a fixpoint), both run once after the loop, and a
-result longer than the input is rejected in favor of the input. Since 0.6.0 the loop
-memoizes whole passes and rule-normal subtrees per call, so the convergence-confirming
-iteration and unchanged subexpressions cost hash lookups instead of re-scans — with
-byte-identical outputs.
+`simplify` is the **equivalence loop only**. Every move — cancellation, rule application, and
+the constant-fold fallback — preserves the function almost everywhere, so the result is sound,
+never longer than the input (the input is the first candidate), and idempotent by construction.
+The search replaces the old fixed cancel→rules order: cancellation is non-confluent (taking one
+candidate can destroy another), so the kernel searches a bounded move graph instead of guessing
+(`node_budget` caps how many nodes it expands; `SIMPLIPY_SEARCH_BUDGET` overrides the default).
+
+**Masking is not part of `simplify`.** Relabelling numeric literals to the generic `<constant>`
+placeholder is a *representation* step for a downstream model that cannot consume literals, not
+an equivalence-preserving rewrite. It is a separate terminal method — apply it to `simplify`'s
+output and never re-`simplify` the result:
+
+```python
+tokens = engine.mask(engine.simplify(expr))   # literals -> <constant>, then one sort
+```
+
+The `mode` argument selects the soundness/recall trade-off; see **Soundness Modes** below.
+Since 0.6.0 the loop memoizes whole passes and rule-normal subtrees per call, so the
+convergence-confirming iteration and unchanged subexpressions cost hash lookups, not re-scans.
 
 The same call as a flowchart, with the memo state each stage touches drawn as
 cylinders (dotted links are lookups/inserts, not data flow):
@@ -82,28 +96,25 @@ cylinders (dotted links are lookups/inserts, not data flow):
 ```mermaid
 flowchart TD
     IN["input tokens"] --> INTERN["intern to token ids"]
-    INTERN --> CANCEL
-    subgraph LOOP["fixpoint loop (up to max_iter passes)"]
-        CANCEL["cancel_terms"] --> RULES["apply_rules"]
-        RULES --> CONV{"changed vs<br/>previous pass?"}
-        CONV -- yes --> CANCEL
+    INTERN --> SEARCH
+    subgraph LOOP["equivalence loop (search → sort to a fixpoint)"]
+        SEARCH["best-first SEARCH over the move graph<br/>(apply rules · cancel any one candidate);<br/>answer = shortest state VISITED"] --> SORT["sort operands"]
+        SORT --> CONV{"changed vs<br/>previous round?"}
+        CONV -- yes --> SEARCH
     end
-    CONV -- "no (converged)" --> MASK["mask elementary literals"]
-    MASK --> SORT["sort operands"]
-    SORT --> GUARD{"result longer<br/>than input?"}
-    GUARD -- yes --> ORIG["return original input"]
-    GUARD -- no --> OUT["output tokens"]
+    CONV -- "no (converged)" --> OUT["output tokens<br/>(≤ input · sound · idempotent)"]
+    OUT -. "callers, when placeholders needed" .-> MASK["mask() — separate terminal step:<br/>literals → &lt;constant&gt;, one sort"]
 
-    subgraph WALK["inside apply_rules: per subtree, top-down"]
+    subgraph WALK["inside the rules move: per subtree, top-down"]
         EXACT["exact rule lookup"] -- miss --> PATT["pattern scan,<br/>first match wins"]
-        PATT -- "match completed" --> CERT["certify !-bindings"]
-        PATT -- "no match" --> REC["recurse into operands,<br/>re-check the rebuilt node"]
+        PATT -- "match completed" --> CERT["certify !-bindings<br/>(skipped in LOSSY)"]
+        PATT -- "no match" --> FOLD["constant-fold fallback<br/>(finiteness-gated; relaxed in LOSSY)"]
+        FOLD -- "no fold" --> REC["recurse into operands,<br/>re-check the rebuilt node"]
     end
-    RULES -.- WALK
+    SEARCH -.- WALK
 
     STORE[("token store:<br/>engine table +<br/>per-call overlay")] -.- INTERN
-    PMEMO[("pass memos<br/>(cancel / rules)")] -.- CANCEL
-    PMEMO -.- RULES
+    PMEMO[("pass memos<br/>(cancel / rules)")] -.- SEARCH
     NF[("rule-normal<br/>subtree set")] -.- WALK
     CCACHE[("certificate caches:<br/>per-call + per-engine")] -.- CERT
 ```
@@ -114,6 +125,56 @@ corrected conversions, and real-semantics power evaluation. Byte-exact reproduct
 historical behavior (the dev_7-3 / v23.0 era) is served by installing `simplipy<=0.6.0`.
 
 
+## Soundness Modes
+
+`simplify(expr, mode=...)` selects a point on a single ordinal soundness axis, `simplipy.Mode`.
+Two rungs are implemented; `EXACT` and `AE` are reserved positions in the decided
+`EXACT ≤ SOUND ≤ AE ≤ LOSSY` ordering.
+
+- **`Mode.SOUND`** (the default) is equivalence-preserving and idempotent. Every rewrite edge
+  carries a soundness gate: rules only bind a composite subtree that a match-time certificate
+  proves defined-and-finite almost everywhere (the `!`-sort); cancellation only cancels leaves
+  where the group axioms hold; and the constant-fold collapses a subtree to a free `<constant>`
+  only when its value is finite on a positive-measure set of its constants. This is the mode to
+  use whenever the output is scored against data from an unknown function (inference, recovery
+  scoring, holdout matching).
+
+- **`Mode.LOSSY`** relaxes *all three* gates together — every rule placeholder binds any subtree
+  (`!`-certificate skipped), cancellation drops its group-axiom gate, and the constant-fold drops
+  its finiteness gate. It only ever binds *more*, so it recovers reductions the sound line leaves
+  on the table, at the cost of firing off the certified domain (pole/`inf`/`nan`-bearing
+  cofactors). It is **not** equivalence-preserving.
+
+```python
+from simplipy import Mode
+
+# <constant>/0 is ±inf/nan for every constant: SOUND keeps it, LOSSY folds it.
+engine.simplify(['/', '<constant>', '0'], mode=Mode.SOUND)   # -> ['/', '<constant>', '0']
+engine.simplify(['/', '<constant>', '0'], mode=Mode.LOSSY)   # -> ['<constant>']
+
+# A finite-a.e. subtree (pole at a single measure-zero constant) folds in BOTH modes:
+engine.simplify(['inv', '<constant>'])                       # -> ['<constant>']   (1/C)
+```
+
+**Why two modes, and how flash-ansr uses them.** The downstream trainer
+([flash-ansr](https://github.com/psaegert/flash-ansr), a transformer for symbolic regression)
+uses each mode on a different side of its pipeline:
+
+- **Training-data generation uses `Mode.LOSSY`.** A skeleton is lossy-simplified and the numeric
+  data is then generated *from that simplified form* — so the target the model learns and the data
+  it is trained on are the *same* expression (`target == data`). There is no external ground-truth
+  function for LOSSY to violate, so the aggressive reductions are safe here and they give the model
+  the shortest, most canonical target. (A structural `<constant>/0` that survives cancellation, for
+  instance, becomes a plain `<constant>`, which is what the generated data reflects.)
+
+- **Inference and recovery scoring use `Mode.SOUND`.** At test time the data comes from an unknown
+  true function; the predicted skeleton must be simplified *without* changing what it computes, or
+  the fit and the score would drift. Only the equivalence-preserving mode is safe there.
+
+That split is the whole reason both modes exist: LOSSY maximizes canonicalization where the
+simplified form *defines* the data, and SOUND guarantees equivalence where it must not.
+
+
 ## Key Components
 
 - **Parsing & normalization** – `SimpliPyEngine.parse` and
@@ -152,6 +213,14 @@ engine.simplify(['/', '<constant>', '*', '/', '*', 'x3', '<constant>', 'x3', 'lo
 # Simplify infix expressions
 engine.simplify('x3 * sin(<constant> + 1) / (x3 * x3)')
 # -> '<constant> / x3'
+
+# Mask numeric literals to <constant> AFTER simplifying (for models that need placeholders)
+engine.mask(engine.simplify(['+', 'x1', '3.14']))
+# -> ['+', '<constant>', 'x1']
+
+# Aggressive canonicalization for training targets (see Soundness Modes)
+from simplipy import Mode
+engine.simplify(['/', '<constant>', '0'], mode=Mode.LOSSY)   # -> ['<constant>']
 ```
 
 Available engines can be browsed and downloaded from Hugging Face.
diff --git a/examples/profile_simplify.rs b/examples/profile_simplify.rs
index 0a69666..1b7e1d6 100644
--- a/examples/profile_simplify.rs
+++ b/examples/profile_simplify.rs
@@ -37,13 +37,13 @@ fn main() {
         .map(|l| l.split(' ').map(str::to_string).collect())
         .collect();
     for e in corpus.iter().take(200) {
-        eng.simplify(e, 5, None, true, true);
+        eng.simplify(e, 5, None, true, false);
     }
     let (a0, b0) = (ALLOCS.load(Relaxed), BYTES.load(Relaxed));
     let t0 = std::time::Instant::now();
     let mut sink = 0usize;
     for e in &corpus {
-        sink += eng.simplify(e, 5, None, true, true).len();
+        sink += eng.simplify(e, 5, None, true, false).len();
     }
     let dt = t0.elapsed();
     let (a1, b1) = (ALLOCS.load(Relaxed), BYTES.load(Relaxed));
diff --git a/pyproject.toml b/pyproject.toml
index 8e7647d..47cbae8 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -6,7 +6,7 @@ authors = [
     ]
 readme = "README.md"
 requires-python = ">=3.11"
-version = "0.8.0"
+version = "0.9.0"
 license = "MIT"
 license-files = ["LICEN[CS]E*"]
 keywords = ["symbolic-regression", "simplification", "expression", "prefix", "rewriting", "rust"]
diff --git a/rust/cancel.rs b/rust/cancel.rs
index c2586d2..4626187 100644
--- a/rust/cancel.rs
+++ b/rust/cancel.rs
@@ -1,7 +1,7 @@
 //! Port of the term-cancellation unit: `collect_multiplicities` feeding
-//! `cancel_terms`. In the `simplify` fixpoint these always run as a pair
-//! (`cancel_terms(*collect_multiplicities(expr))`), so the public entry here is the fused unit
-//! [`cancel_terms_unit`].
+//! `cancel_terms`. These always run as a pair (`cancel_terms(*collect_multiplicities(expr))`),
+//! so the public entry here is the fused unit [`cancel_terms_unit`]; the tree search enumerates
+//! a node's cancellation children through [`cancel_successors`].
 //!
 //! ## What it does (the actual mechanism, not the docstring)
 //! Within a maximal *connected region* of one connection class -- additive (`+`/`-`) or
@@ -9,7 +9,8 @@
 //! leaf's `sum(|pos|,|neg|) > 1`, merges its occurrences: the first occurrence becomes the merged
 //! term (`mult{k}`/`pow{k}` hyper-operator, or a `neg`/`inv` inverse prefix, or a `*k`/`pow ... k`
 //! coefficient fallback) and every later occurrence becomes the class neutral (`0`/`1`). Only ONE
-//! cancellation candidate is taken per call; the fixpoint re-invokes until convergence. Composite
+//! cancellation candidate is taken per call -- the search branches over the choice, and reaching
+//! a further cancellation is simply another edge deeper in the graph. Composite
 //! subtrees do NOT register as cancellable hashes (only leaf `(token,)` hashes propagate), so the
 //! `(a*b)+(a*b)` docstring example is not what the code actually cancels.
 //!
@@ -18,6 +19,11 @@
 //!   insertion-ordered `Vec<(key,[i64;2])>`, NOT a hash map.
 //! * Candidate selection does **NOT break**: it runs the full `[add, mult] x dict.items()` nest, so
 //!   the candidate is the **last** qualifying match, not the first.
+//! * Which candidate to take is NOT decided here. Cancellation is non-confluent -- taking
+//!   candidate A can destroy candidate B, and which choice ends shortest depends on what the
+//!   rule set can fold afterwards -- so `Engine::simplify_search` BRANCHES over every candidate
+//!   (via [`cancel_successors`]) and keeps the shortest node it reaches. It is searched, never
+//!   guessed; the `select_nth` argument below just names which branch to emit.
 //! * `factorize_to_at_most` raising `ValueError` is control flow -> the `Err` arm selects the
 //!   `*`/`pow`-coefficient fallback.
 //! * The `[::-1]` reversed-flatten label of a subtree is exactly its prefix-token sequence (leaves
@@ -120,7 +126,11 @@ struct AnnNode {
 /// Port of `collect_multiplicities`. Right-to-left scan building a stack
 /// of annotated subtrees; for a well-formed prefix expression the stack ends with a single root,
 /// which is returned. Mirrors the leaf / binary-connectable / general-operator branches exactly.
-fn collect_multiplicities(expression: &[Tok], view: &TokenView) -> Option<AnnNode> {
+fn collect_multiplicities(
+    expression: &[Tok],
+    view: &TokenView,
+    wildcard_all: bool,
+) -> Option<AnnNode> {
     let tt = view.table;
     let mut stack: Vec<AnnNode> = Vec::new();
 
@@ -168,24 +178,48 @@ fn collect_multiplicities(expression: &[Tok], view: &TokenView) -> Option<AnnNod
         }
 
         if let Some(arity) = view.arity(token) {
-            // General (non-connectable) operator: empty annotation in BOTH classes.
             let arity = arity as usize;
             let mut operands: Vec<AnnNode> = stack.split_off(stack.len() - arity);
             operands.reverse();
+            // The class INVERSE operators (`cc_inverse`) are made region-CONTINUING in THEIR OWN
+            // class, symmetric with how `cancel_terms` already EMITS them: `neg` = additive inverse
+            // (flip CC_ADD multiplicities); `inv` = multiplicative inverse (flip CC_MULT). Each is
+            // OPAQUE in the other class. (`neg` as a cross-class `-1` MULTIPLICATIVE factor is NOT
+            // handled here: it needs the `-1` sign preserved when the inner content fully cancels,
+            // which the emit does not currently thread -- deferred; any other general operator: empty.)
+            let own: [Ann; N_CC] = if token == tt.neg && arity == 1 {
+                let mut add: Ann = Vec::new();
+                for (h, v) in &operands[0].own[CC_ADD] {
+                    let e = ann_entry(&mut add, h);
+                    e[0] += v[1];
+                    e[1] += v[0];
+                }
+                [add, Vec::new()]
+            } else if token == tt.inv && arity == 1 {
+                let mut mult: Ann = Vec::new();
+                for (h, v) in &operands[0].own[CC_MULT] {
+                    let e = ann_entry(&mut mult, h);
+                    e[0] += v[1];
+                    e[1] += v[0];
+                }
+                [Vec::new(), mult]
+            } else {
+                [Vec::new(), Vec::new()]
+            };
             let label = build_label(token, &operands);
             stack.push(AnnNode {
                 op: Some(token),
                 token,
                 operands,
-                own: [Vec::new(), Vec::new()],
+                own,
                 label,
             });
             i -= 1;
             continue;
         }
 
-        // Leaf: registers itself with multiplicity [1,0]. Cancellation assumes the group
-        // axioms, so a leaf registers ONLY in the connection classes where they hold:
+        // Leaf: registers itself with multiplicity [1,0]. In SOUND mode cancellation assumes the
+        // group axioms, so a leaf registers ONLY in the connection classes where they hold:
         //   - VARIABLES in both classes (`x - x -> 0` is total; `x/x -> 1` fills a null hole);
         //   - a LITERAL where its value is a group element: nonzero finite in both classes; 0 in
         //     the ADDITIVE class only (`0/0 -> 1` and the sign-of-zero family are wrong answers);
@@ -194,6 +228,12 @@ fn collect_multiplicities(expression: &[Tok], view: &TokenView) -> Option<AnnNod
         // Not registering is the same state a composite subtree has always had (own = empty), so
         // the cancel phase needs no other change; it also UN-SHADOWS the already-mined correct
         // ground rules (`('/','0','0') -> float("nan")` et al.) that this pass pre-empted.
+        //
+        // LOSSY mode (`wildcard_all`) drops this group-axiom gate, exactly as it drops the rule
+        // matcher's `!`-certificate and the constant-fold's finiteness gate: EVERY leaf registers
+        // in BOTH classes, so `0/0 -> 1`, `inf/inf -> 1`, `inf - inf -> 0` cancel structurally. Not
+        // sound; the training-corpus-canonicalisation contract (data generated FROM the simplified
+        // form, target == data) is what makes the three relaxations coherent.
         let leaf_hash = vec![token];
         let lv = if token == tt.constant {
             None
@@ -207,10 +247,14 @@ fn collect_multiplicities(expression: &[Tok], view: &TokenView) -> Option<AnnNod
                 Vec::new()
             }
         };
-        let own = [
-            reg(lv.map(|v| v.is_finite()).unwrap_or(true)),
-            reg(lv.map(|v| v.is_finite() && v != 0.0).unwrap_or(true)),
-        ];
+        let own = if wildcard_all {
+            [reg(true), reg(true)]
+        } else {
+            [
+                reg(lv.map(|v| v.is_finite()).unwrap_or(true)),
+                reg(lv.map(|v| v.is_finite() && v != 0.0).unwrap_or(true)),
+            ]
+        };
         stack.push(AnnNode {
             op: None,
             token,
@@ -249,13 +293,21 @@ struct Frame<'a> {
 }
 
 /// Port of `cancel_terms`, the deployed `collect_statistics=False` path.
-fn cancel_terms(root: &AnnNode, ops: &Operators, view: &TokenView) -> Vec<Tok> {
+/// The second return value is the CHOSEN candidate's sum (`None` when no cancellation fired).
+fn cancel_terms(
+    root: &AnnNode,
+    ops: &Operators,
+    view: &TokenView,
+    select_nth: Option<usize>,
+) -> (Vec<Tok>, Option<i64>, usize) {
     let tt = view.table;
     let mut expression: Vec<Tok> = Vec::new();
 
     // (argmax_class, cancelled_subtree, cancelled_multiplicity_sum). Set at most once.
     let mut cancellation_candidate: Option<(usize, Vec<Tok>, i64)> = None;
     let mut n_replaced: i64 = 0;
+    // Total qualifying (node, cc, hash) triples seen -- the state's branching factor.
+    let mut n_candidates: usize = 0;
 
     // stack initialized to the single root; parity {add:1, mult:1}; still_connected = False.
     let mut stack: Vec<Frame> = vec![Frame {
@@ -276,7 +328,12 @@ fn cancel_terms(root: &AnnNode, ops: &Operators, view: &TokenView) -> Vec<Tok> {
         {
             // still_connected stays true only along operators of the cancellation class (or leaves).
             let st0 = subtree.token;
-            let in_class = connection_ops(argmax_class, tt).contains(&st0);
+            // neg/inv are region-continuing class inverses (see collect_multiplicities): treat them
+            // as in-class so still_connected survives across them (neg additive; inv mult only),
+            // mirroring the collect.
+            let in_class = connection_ops(argmax_class, tt).contains(&st0)
+                || (st0 == tt.neg && argmax_class == CC_ADD)
+                || (st0 == tt.inv && argmax_class == CC_MULT);
             let not_operator = !view.is_operator(st0);
             still_connected = still_connected && (in_class || not_operator);
 
@@ -416,15 +473,31 @@ fn cancel_terms(root: &AnnNode, ops: &Operators, view: &TokenView) -> Vec<Tok> {
 
             // Try to find a cancellation candidate in THIS subtree (only if none yet). No break:
             // the full nest runs, so the LAST qualifying (cc, hash) wins.
-            if cancellation_candidate.is_none() {
+            //
+            // `select_nth = Some(k)`: enumerate every qualifying (node, cc, hash) triple in walk
+            // order and select the k-th -- this is how the tree search names a child (each k is
+            // one cancellation edge);
+            // `n_candidates` keeps counting past the selection so the caller learns the full
+            // branching factor of this state in one pass.
+            if select_nth.is_some() || cancellation_candidate.is_none() {
                 for cc in [CC_ADD, CC_MULT] {
                     for (subtree_hash, multiplicity) in &subtree.own[cc] {
                         let abs_sum = multiplicity[0].abs() + multiplicity[1].abs();
                         let has_constant = subtree_hash.iter().any(|&t| t == tt.constant);
                         if abs_sum > 1 && (!has_constant || subtree_hash.len() == 1) {
-                            cancellation_candidate =
-                                Some((cc, subtree_hash.clone(), multiplicity[0] - multiplicity[1]));
-                            still_connected = true;
+                            let take = match select_nth {
+                                Some(k) => n_candidates == k,
+                                None => true,
+                            };
+                            n_candidates += 1;
+                            if take {
+                                cancellation_candidate = Some((
+                                    cc,
+                                    subtree_hash.clone(),
+                                    multiplicity[0] - multiplicity[1],
+                                ));
+                                still_connected = true;
+                            }
                         }
                     }
                 }
@@ -445,6 +518,22 @@ fn cancel_terms(root: &AnnNode, ops: &Operators, view: &TokenView) -> Vec<Tok> {
                 parity: prop[0],
                 still_connected,
             });
+        } else if operator == tt.neg && subtree.operands.len() == 1 {
+            // neg: additive inverse (flip CC_ADD parity); the multiplicative region resets inside.
+            expression.push(operator);
+            stack.push(Frame {
+                node: &subtree.operands[0],
+                parity: [-subtree_parities[CC_ADD], 1],
+                still_connected,
+            });
+        } else if operator == tt.inv && subtree.operands.len() == 1 {
+            // inv: multiplicative inverse (flip CC_MULT parity); the additive region resets inside.
+            expression.push(operator);
+            stack.push(Frame {
+                node: &subtree.operands[0],
+                parity: [1, -subtree_parities[CC_MULT]],
+                still_connected,
+            });
         } else {
             // General operator: children get reset parity {add:1, mult:1}; still_connected carried.
             expression.push(operator);
@@ -458,15 +547,49 @@ fn cancel_terms(root: &AnnNode, ops: &Operators, view: &TokenView) -> Vec<Tok> {
         }
     }
 
-    expression
+    let chosen_sum = cancellation_candidate.as_ref().map(|(_, _, s)| *s);
+    (expression, chosen_sum, n_candidates)
 }
 
-/// The fused public entry: `cancel_terms(*collect_multiplicities(expression))`. On a malformed
-/// expression (`collect_multiplicities` does not collapse to a single root) returns the input
-/// unchanged -- the deployed skeleton path only ever feeds well-formed prefix expressions.
+/// SEARCH branching operator: every successor of `expression` under the cancel move, each
+/// paired with the SIGNED multiplicity sum of the candidate it took (the caller ranks on it).
+///
+/// The annotation tree is collected ONCE and the per-candidate emit walks reuse it; enumerating
+/// via a per-candidate entry point re-collected it `b + 1` times per expansion.
+///
+/// There is exactly ONE region shape: `neg`/`inv` are ALWAYS region-continuing class inverses.
+/// Treating them as opaque was the original defect (the unit emitted the class inverses but
+/// never consumed them); the pre-0.8.0 outputs that relied on that asymmetry are not preserved.
+pub fn cancel_successors(
+    expression: &[Tok],
+    ops: &Operators,
+    view: &TokenView,
+    wildcard_all: bool,
+) -> Vec<(Vec<Tok>, i64)> {
+    let Some(root) = collect_multiplicities(expression, view, wildcard_all) else {
+        return Vec::new();
+    };
+    // select_nth = usize::MAX selects nothing and just counts the qualifying triples.
+    let (_, _, n_candidates) = cancel_terms(&root, ops, view, Some(usize::MAX));
+    (0..n_candidates)
+        .map(|k| {
+            let (out, sum, _) = cancel_terms(&root, ops, view, Some(k));
+            (out, sum.unwrap_or(0))
+        })
+        .collect()
+}
+
+/// The fused public entry: `cancel_terms(*collect_multiplicities(expression))` under the
+/// engine's own candidate selection (historical last-qualifying-at-the-root-most-node)
+/// -- i.e. exactly the step [`crate::Engine::simplify`]'s
+/// greedy seed takes, so this validation entry and the kernel cannot drift apart. On a malformed
+/// expression (`collect_multiplicities` does not collapse to a single root) the input is
+/// returned unchanged; the deployed skeleton path only ever feeds well-formed prefix
+/// expressions.
 pub fn cancel_terms_unit(expression: &[Tok], ops: &Operators, view: &TokenView) -> Vec<Tok> {
-    match collect_multiplicities(expression, view) {
-        Some(root) => cancel_terms(&root, ops, view),
+    // The diagnostic unit entry (`cancel_only`) stays SOUND (group-axiom gate on).
+    match collect_multiplicities(expression, view, false) {
+        Some(root) => cancel_terms(&root, ops, view, None).0,
         None => expression.to_vec(),
     }
 }
@@ -483,8 +606,7 @@ mod tests {
         s.iter().map(|t| t.to_string()).collect()
     }
 
-    /// Canonical cancellation cases, cross-checked against fresh Python (see benchmarks/diff_cancel.py
-    /// for the full 10k+18k corpus gate). These pin the mechanism: hyper-operator factorization
+    /// Canonical cancellation cases. These pin the mechanism: hyper-operator factorization
     /// (`mult{k}`/`pow{k}`), the `neg`/`inv` parity prefix, the `<constant>` special case, and
     /// the additive-vs-multiplicative neutral element.
     #[test]
@@ -554,4 +676,54 @@ mod tests {
             );
         }
     }
+
+    /// neg/inv are region-continuing class inverses (symmetric with `cc_inverse` on EMIT): a leaf
+    /// cancels through the unary inverse OF ITS OWN CLASS. `inv` = multiplicative inverse; `neg` =
+    /// additive inverse (across a composite too). Cross-class `neg` as a `-1` multiplicative factor
+    /// is deliberately NOT handled (sign preservation on full inner cancellation) -- see
+    /// `collect_multiplicities` -- so `neg(x)/x` is left to a rule, not cancelled here.
+    #[test]
+    fn cancel_neg_inv_symmetric() {
+        let Some(e) = engine() else { return };
+        let cases: &[(&[&str], &[&str])] = &[
+            // inv = multiplicative inverse: x / inv(x) = x^2 ; x * inv(x) = 1.
+            (&["/", "x0", "inv", "x0"], &["/", "pow2", "x0", "inv", "1"]),
+            (&["*", "x0", "inv", "x0"], &["*", "1", "inv", "1"]),
+            // neg = additive inverse across a composite: x0 + neg(x0 + x1) -> -x1.
+            (
+                &["+", "x0", "neg", "+", "x0", "x1"],
+                &["+", "0", "neg", "+", "0", "x1"],
+            ),
+            // NO false cancel: x0 / inv(x0 + x1) keeps x0 (inner x0 is an ADDITIVE sub-leaf, not a
+            // multiplicative leaf of the outer region).
+            (
+                &["/", "x0", "inv", "+", "x0", "x1"],
+                &["/", "x0", "inv", "+", "x0", "x1"],
+            ),
+            // cross-class neg is NOT cancelled here (deferred): neg(x0) / x0 stays for a rule.
+            (&["/", "neg", "x0", "x0"], &["/", "neg", "x0", "x0"]),
+        ];
+        for (input, expected) in cases {
+            assert_eq!(
+                e.cancel_terms(&toks(input)),
+                toks(expected),
+                "input {input:?}"
+            );
+        }
+    }
+
+    /// `cancel_terms_unit` (behind the public `cancel_only`) applies ONE cancellation using the
+    /// default selection. It is a unit-inspection entry, NOT "what simplify does" -- the tree
+    /// search branches over every candidate rather than privileging one, so the two answer
+    /// different questions and must not be read as equivalent. This pins the unit's own contract
+    /// on a tree with two candidates: `(x1/x1) * inv(x1)` has an inner annihilation (x1:[1,1])
+    /// and a root-level x1:[1,2]; the walk selects the root-most.
+    #[test]
+    fn cancel_unit_selects_the_root_most_candidate() {
+        let Some(e) = engine() else { return };
+        assert_eq!(
+            e.cancel_terms(&toks(&["*", "/", "x1", "x1", "inv", "x1"])),
+            toks(&["*", "/", "inv", "x1", "1", "inv", "1"]),
+        );
+    }
 }
diff --git a/rust/engine/memo.rs b/rust/engine/memo.rs
index 166f5ee..8904a92 100644
--- a/rust/engine/memo.rs
+++ b/rust/engine/memo.rs
@@ -51,8 +51,9 @@ impl BangCache {
 
 /// Per-simplify-call memo context. Pure-function memoization, valid because both passes are
 /// deterministic for a fixed engine + max_pattern_length (fixed within one call):
-/// - `cancel_memo` / `rules_memo`: whole-pass input->output token maps, so the converged
-///   fixpoint's confirming pass collapses to two hash lookups.
+/// - `rules_memo`: a whole-pass input->output token map. The tree search reaches the same node
+///   by many paths, so the rules pass for a node is computed once no matter how often it recurs.
+///   The cancel enumeration needs no memo: the search's `visited` set already dedupes its nodes.
 /// - `normal_forms`: flattened subtrees the rule walk returned UNCHANGED (no fire anywhere
 ///   inside; guarded against the faithful-mode all-`<constant>`-operand entry collapse).
 ///   Reaching an identical subtree in a later iteration (or a repeated substructure in the
@@ -64,19 +65,21 @@ impl BangCache {
 pub(super) struct SimplifyCtx {
     pub(super) overlay: RefCell<TokenOverlay>,
     pub(super) cert_scratch: RefCell<FxHashMap<Vec<Tok>, bool>>,
-    pub(super) cancel_memo: RefCell<FxHashMap<Vec<Tok>, Vec<Tok>>>,
     pub(super) rules_memo: RefCell<FxHashMap<Vec<Tok>, Vec<Tok>>>,
     pub(super) normal_forms: RefCell<rustc_hash::FxHashSet<Vec<Tok>>>,
+    /// AGGRESSIVE apply-time mode: bind every placeholder as `_` and skip the `!` certificate
+    /// (see `matcher::match_pattern_with_cert`). Set once per call at the simplify entry.
+    pub(super) wildcard_all: bool,
 }
 
 impl SimplifyCtx {
-    pub(super) fn new(table_len: usize) -> Self {
+    pub(super) fn new(table_len: usize, wildcard_all: bool) -> Self {
         Self {
             overlay: RefCell::new(TokenOverlay::new(table_len)),
             cert_scratch: RefCell::new(FxHashMap::default()),
-            cancel_memo: RefCell::new(FxHashMap::default()),
             rules_memo: RefCell::new(FxHashMap::default()),
             normal_forms: RefCell::new(rustc_hash::FxHashSet::default()),
+            wildcard_all,
         }
     }
 }
diff --git a/rust/engine/miner.rs b/rust/engine/miner.rs
index c88be8c..49de00c 100644
--- a/rust/engine/miner.rs
+++ b/rust/engine/miner.rs
@@ -185,7 +185,7 @@ impl Engine {
             .filter_map(|(idx, src)| {
                 // Kruskal prune: simplify with the current rules; skip if it
                 // shortens (strict), or tighten the search bound to the simplified length (relaxed).
-                let slen = self.simplify(src, 5, None, true, true).len();
+                let slen = self.simplify(src, 48, None, true, false).len();
                 if slen < src.len() && !relaxed_kruskal {
                     return None;
                 }
@@ -234,7 +234,13 @@ impl Engine {
                 .iter()
                 .map(|&t| self.tokens.resolve(t).to_string())
                 .collect();
-            let result = self.simplify(lhs, 5, None, mask_elementary_literals, true);
+            let simplified = self.simplify(lhs, 48, None, true, false);
+            // rhs may be stored in masked (placeholder) form; mask to compare like-for-like.
+            let result = if mask_elementary_literals {
+                self.mask(&simplified)
+            } else {
+                simplified
+            };
             if result == rhs {
                 pruned.push(lhs.clone()); // redundant: keep removed
             } else {
diff --git a/rust/engine/mod.rs b/rust/engine/mod.rs
index 97bff2a..e44b5e0 100644
--- a/rust/engine/mod.rs
+++ b/rust/engine/mod.rs
@@ -193,7 +193,7 @@ impl Engine {
     /// as invoked once per `simplify` fixpoint iteration. Cancel is
     /// `max_pattern_length`-independent (no `mpl` argument).
     pub fn cancel_terms(&self, expression: &[String]) -> Vec<String> {
-        let ctx = SimplifyCtx::new(self.tokens.len());
+        let ctx = SimplifyCtx::new(self.tokens.len(), false);
         let toks = self.intern_seq(expression, &ctx);
         let out = crate::cancel::cancel_terms_unit(&toks, &self.operators, &self.view(&ctx));
         self.resolve_seq(&out, &ctx)
@@ -203,7 +203,7 @@ impl Engine {
     /// commutative-operand ordering, the final stage of the `simplify` fixpoint (runs once, after the
     /// loop).
     pub fn sort_operands(&self, expression: &[String]) -> Vec<String> {
-        let ctx = SimplifyCtx::new(self.tokens.len());
+        let ctx = SimplifyCtx::new(self.tokens.len(), false);
         let toks = self.intern_seq(expression, &ctx);
         let out = crate::sort::sort_operands_unit(&toks, &self.view(&ctx));
         self.resolve_seq(&out, &ctx)
diff --git a/rust/engine/simplify.rs b/rust/engine/simplify.rs
index d64ad55..0b8fc5d 100644
--- a/rust/engine/simplify.rs
+++ b/rust/engine/simplify.rs
@@ -1,10 +1,12 @@
 //! The simplify kernel: the `!`-certificate lookup, `apply_rules_top_down` (with the
-//! constant-fold fallback), and the `simplify` fixpoint, all running on interned ids against
+//! constant-fold fallback), and the `simplify` tree search, all running on interned ids against
 //! the per-call [`SimplifyCtx`].
 
 use std::cell::RefCell;
+use std::cmp::Reverse;
+use std::collections::BinaryHeap;
 
-use rustc_hash::FxHashMap;
+use rustc_hash::{FxHashMap, FxHashSet};
 
 use crate::matcher::{apply_mapping, match_pattern_with_cert};
 use crate::parse::{parse_subtree, tree_to_prefix, Node};
@@ -14,7 +16,7 @@ use super::memo::SimplifyCtx;
 use super::stats;
 use super::Engine;
 
-/// One memo-wrapped pass of the fixpoint: return the cached output for `input`, or run
+/// One memo-wrapped rewrite pass: return the cached output for `input`, or run
 /// `compute` and memoize its result (whole-pass input -> output map; see [`SimplifyCtx`]).
 fn memoized_pass(
     memo: &RefCell<FxHashMap<Vec<Tok>, Vec<Tok>>>,
@@ -77,20 +79,20 @@ impl Engine {
 
     /// The rule-application sub-unit `apply_simplification_rules`: the whole-expression
     /// all-`<constant>`/operator fold, then parse -> `apply_rules_top_down` -> flatten back to
-    /// prefix. This is the `simplify` fixpoint's per-iteration rule pass.
+    /// prefix. This is the rules EDGE of the search graph.
     pub fn apply_simplification_rules(
         &self,
         expression: &[String],
         max_pattern_length: Option<usize>,
     ) -> Vec<String> {
-        let ctx = SimplifyCtx::new(self.tokens.len());
+        let ctx = SimplifyCtx::new(self.tokens.len(), false);
         let toks = self.intern_seq(expression, &ctx);
         let out = self.apply_simplification_rules_with_ctx(&toks, max_pattern_length, &ctx);
         self.resolve_seq(&out, &ctx)
     }
 
     /// The rules pass against a caller-owned memo context: `simplify` threads ONE ctx
-    /// across all fixpoint iterations so the confirming pass and unchanged subtrees are free.
+    /// across every node it expands, so a node reached by several paths costs one pass.
     fn apply_simplification_rules_with_ctx(
         &self,
         expression: &[Tok],
@@ -146,6 +148,7 @@ impl Engine {
                     &rule.lhs_tree,
                     &mut mapping,
                     Some(&|n: &Node| self.bang_certified(n, ctx)),
+                    ctx.wildcard_all,
                     &view,
                 ) {
                     stats::bump(&stats::PATTERN_FIRES);
@@ -240,9 +243,14 @@ impl Engine {
     /// ALL leaves. If every operand is VALUED (`numeric::leaf_value` resolves it: numeric
     /// literals, `np.pi`/`np.e`, `(-1)`-style parenthesized literals, the `float("...")`
     /// tokens) -> evaluate to the `f64` result token (`evaluate_constant_subtree`; `None` if
-    /// unfoldable). ELSE if every operand is `<constant>` or a FINITE-valued leaf -> collapse to
-    /// `<constant>` (inf/nan literals never absorb into `<constant>`: non-finite algebra belongs
-    /// to explicit rules such as `+ float("-inf") <constant> -> float("-inf")`).
+    /// unfoldable). ELSE if every operand is `<constant>` or a FINITE-valued leaf, AND the subtree
+    /// is CERTIFIED to have a positive-measure finite value (`interval::value_set` over R:
+    /// `has_fin && !fin_null`) -> collapse to `<constant>` (inf/nan literals never absorb into
+    /// `<constant>`: non-finite algebra belongs to explicit rules such as
+    /// `+ float("-inf") <constant> -> float("-inf")`). The finiteness certificate is REQUIRED, not
+    /// cosmetic: finite operands can compose to a non-finite-a.e. value (`<constant>/0`), and
+    /// collapsing that to a free finite constant is unsound -- this edge is the one that used to
+    /// skip the certification the rule matcher and the cancellation already enforce.
     /// The `if all_valued { ... } elif ... { ... }` ORDER is load-bearing: an all-valued but
     /// UNFOLDABLE subtree returns `None` (it does NOT fall through to the `<constant>` collapse).
     /// Both gates MUST use `numeric::leaf_value` -- the tape evaluator's own leaf table -- so the
@@ -293,111 +301,287 @@ impl Engine {
             .iter()
             .all(|&v| v == self.tokens.constant || view.leaf_value(v).is_some_and(f64::is_finite));
         if all_const_or_finite {
-            return Some(Node::Leaf(self.tokens.constant));
+            // The syntactic "every operand is <constant> or a finite literal" test is NOT
+            // sufficient to collapse the subtree to a free <constant>: an operator can map finite
+            // operands to a value that is non-finite on FULL measure. `<constant> / 0` is +-inf/nan
+            // for EVERY constant, so folding it to a finite free <constant> both drops the reachable
+            // non-finite value and fabricates finite ones -- unsound (it revives a structurally
+            // zeroed term; corpus idx 35585, the `zoo`-collapse). This is the one search edge that
+            // skipped the finiteness certification the rule matcher (`match_pattern_with_cert` ->
+            // `bang_certified`) and the cancellation (its group-axiom leaf gate) both already carry.
+            // Gate it on the SAME value-set analysis: fold only when the subtree has a
+            // POSITIVE-MEASURE finite part (`has_fin && !fin_null`) -- the exact predicate whose
+            // negation is `finite_ae`'s witness. This is WEAKER than `finite_ae` on purpose: an
+            // unbounded-but-finite-a.e. subtree (`inv <constant>` = 1/C, `tan <constant>`,
+            // `cosh(<constant>+5)`) stays foldable (the pole is measure-zero), while a non-finite-a.e.
+            // subtree (`<constant>/0`, `<constant>*inv(0)`) does not.
+            //
+            // LOSSY mode (`wildcard_all`) relaxes this finiteness certificate, exactly as it relaxes
+            // the rule matcher's `!`-certificate: a non-finite-a.e. subtree (`<constant>/0`) then
+            // collapses to `<constant>` too. That is the intended training-corpus behaviour (the data
+            // is generated FROM the simplified form, so target == data and there is nothing to
+            // violate); it is NOT sound and must never run on an inference/scoring path.
+            if ctx.wildcard_all {
+                return Some(Node::Leaf(self.tokens.constant));
+            }
+            let mut flat: Vec<String> = Vec::with_capacity(values.len() + 1);
+            flat.push(view.to_string(operator));
+            flat.extend(values.iter().map(|&v| view.to_string(v)));
+            let finite_pm =
+                crate::interval::value_set(&flat, &self.operators, &crate::interval::Vs::reals())
+                    .is_some_and(|vs| vs.has_fin && !vs.fin_null);
+            if finite_pm {
+                return Some(Node::Leaf(self.tokens.constant));
+            }
+            return None;
         }
         None
     }
 
-    /// THE whole-unit kernel: the `simplify` fixpoint, the
-    /// prefix-token-list contract: per iteration `cancel_terms` -> `apply_simplification_rules`
-    /// (when enabled), break when the iteration is a no-op vs the previous (`<= max_iter`); then
-    /// `mask_elementary_literals` (when enabled); then `sort_operands` (mask-BEFORE-sort so the
-    /// canonical operand order is a fixpoint -- idempotent); then the LONGER-RESULT GUARD
-    /// (if the result is longer than the original input, return the ORIGINAL).
+    /// THE whole-unit kernel, on the prefix-token-list contract: run the tree search
+    /// ([`Engine::simplify_search`]) to a `search -> sort` fixpoint (the EQUIVALENCE LOOP), which
+    /// preserves the function EXACTLY and is idempotent by construction.
+    ///
+    /// `simplify` does NOT mask. Masking (numeric literals -> `<constant>`) is a REPRESENTATION
+    /// step for a downstream model that cannot consume literals, not an equivalence-preserving
+    /// rewrite; it is carved out into [`Engine::mask`] and applied by callers to `simplify`'s
+    /// output when placeholders are needed. Entangling it here was unsound: masking mints a free
+    /// `<constant>` from a structural literal (`x-x -> 0 -> <constant>`), and re-searching that
+    /// folds the fresh constant into a denominator, losing the reachable `C=0` and turning a term
+    /// that was identically 0 into a non-zeroable one (non-equivalent). It was also the sole cause
+    /// of the former non-idempotence.
     ///
     /// Returns the simplified prefix tokens (the Python `'list'` return). The `inplace` /
     /// return-type machinery (str/tuple/np_array) is a Python-shim concern, not part of this kernel.
     ///
     /// This is the string boundary -- intern once at entry, resolve once at exit; the whole
-    /// fixpoint runs on `Tok` ids ([`Engine::simplify_toks`]).
+    /// search runs on `Tok` ids ([`Engine::simplify_toks`]).
     pub fn simplify(
         &self,
         tokens: &[String],
-        max_iter: usize,
+        node_budget: usize,
         max_pattern_length: Option<usize>,
-        mask_elementary_literals: bool,
         apply_simplification_rules: bool,
+        wildcard_all: bool,
     ) -> Vec<String> {
-        let ctx = SimplifyCtx::new(self.tokens.len());
+        let ctx = SimplifyCtx::new(self.tokens.len(), wildcard_all);
         let toks = self.intern_seq(tokens, &ctx);
         let out = self.simplify_toks(
             &toks,
-            max_iter,
+            node_budget,
             max_pattern_length,
-            mask_elementary_literals,
             apply_simplification_rules,
             &ctx,
         );
         self.resolve_seq(&out, &ctx)
     }
 
-    /// The id-level simplify fixpoint (see [`Engine::simplify`] for the contract).
+    /// The REPRESENTATION pass, carved out of the simplify kernel: relabel every numeric literal
+    /// token to `<constant>` (so a downstream model sees placeholders), then sort to canonicalise
+    /// the relabelled operands. A pure WIDENING -- every masked value is recoverable by its
+    /// placeholder (`0*X -> <constant>*X` at C=0; `pi/2 -> <constant>` at C=pi/2). Apply ONCE to a
+    /// simplified expression and never re-`simplify` the result: a masked form re-fed to the search
+    /// can collect redundant constants (~0.4% of rows) and, on structural-zero inputs, fold
+    /// unsoundly -- which is exactly why masking is not part of `simplify`. mask+sort are each
+    /// idempotent, so `mask` itself is a fixpoint.
+    pub fn mask(&self, tokens: &[String]) -> Vec<String> {
+        let ctx = SimplifyCtx::new(self.tokens.len(), false);
+        let toks = self.intern_seq(tokens, &ctx);
+        let masked = crate::utils::mask_elementary_literals(&toks, &self.view(&ctx));
+        let out = crate::sort::sort_operands_unit(&masked, &self.view(&ctx));
+        self.resolve_seq(&out, &ctx)
+    }
+
+    /// The id-level kernel (see [`Engine::simplify`] for the contract): the EQUIVALENCE LOOP only.
     fn simplify_toks(
         &self,
         tokens: &[Tok],
-        max_iter: usize,
+        node_budget: usize,
         max_pattern_length: Option<usize>,
-        mask_elementary_literals: bool,
         apply_simplification_rules: bool,
         ctx: &SimplifyCtx,
     ) -> Vec<Tok> {
-        let length_before = tokens.len();
         stats::bump(&stats::SIMPLIFY_CALLS);
 
-        // current_expression / new_expression both start as a copy of the input.
-        let mut current_expression = tokens.to_vec();
-        let mut new_expression = current_expression.clone();
+        // EQUIVALENCE LOOP: iterate SEARCH -> sort until the pair stops moving. Both are
+        // equivalence-preserving; sorting is in the loop because reordering operands changes
+        // WHICH RULES MATCH, so a re-sorted answer can be searchable again. This reaches a fixpoint
+        // on its own -- masking is NOT part of `simplify` (see the doc on `simplify`/`mask`), so
+        // there is no mint-a-constant-then-refold churn and idempotence holds by construction.
+        // `ctx` is shared across rounds, so the rules memo makes repeated nodes free. Every round
+        // but the last strictly shortens, so this terminates.
+        let mut current = tokens.to_vec();
+        loop {
+            let searched = self.simplify_search(
+                &current,
+                node_budget,
+                max_pattern_length,
+                apply_simplification_rules,
+                ctx,
+            );
+            let t_post = std::time::Instant::now();
+            let canonical = crate::sort::sort_operands_unit(&searched, &self.view(ctx));
+            stats::add(&stats::NANOS_MASK_SORT, t_post.elapsed().as_nanos() as u64);
+            if canonical == current {
+                return current;
+            }
+            current = canonical;
+        }
+    }
 
-        for _ in 0..max_iter {
-            stats::bump(&stats::SIMPLIFY_ITERS);
-            // Cancel any terms (cancel_terms(*collect_multiplicities(new_expression))).
-            let t_cancel = std::time::Instant::now();
-            new_expression = memoized_pass(&ctx.cancel_memo, &new_expression, || {
-                crate::cancel::cancel_terms_unit(&new_expression, &self.operators, &self.view(ctx))
-            });
-            stats::add(&stats::NANOS_CANCEL, t_cancel.elapsed().as_nanos() as u64);
-
-            // Apply simplification rules.
-            if apply_simplification_rules {
-                let t_rules = std::time::Instant::now();
-                new_expression = memoized_pass(&ctx.rules_memo, &new_expression, || {
-                    self.apply_simplification_rules_with_ctx(
-                        &new_expression,
-                        max_pattern_length,
-                        ctx,
-                    )
-                });
-                stats::add(&stats::NANOS_RULES, t_rules.elapsed().as_nanos() as u64);
+    /// THE simplification algorithm: a best-first TREE SEARCH over rewrite states, re-rooted
+    /// until it reaches a fixed point (see [`Engine::search_once`] for one search).
+    ///
+    /// One bounded search is not enough on its own: `best` is adopted the moment a node is
+    /// GENERATED, but the budget can stop before that node is ever EXPANDED, so the answer may
+    /// sit one move away from something shorter -- which is exactly what a user calling
+    /// `simplify` twice would discover. (Measured on the 64k v23.0 prior: 0.87% of 4-3 rows
+    /// improved on a second call, worth 979 tokens, about half of what the search itself buys.)
+    /// Re-rooting the search at its own answer until the answer stops moving closes that, and
+    /// makes idempotence hold BY CONSTRUCTION rather than by hope. It terminates because every
+    /// round but the last strictly shortens the expression: `best` starts at the root and only
+    /// strictly shorter nodes replace it, so a round either returns its root unchanged or
+    /// returns something shorter.
+    fn simplify_search(
+        &self,
+        tokens: &[Tok],
+        node_budget: usize,
+        max_pattern_length: Option<usize>,
+        apply_simplification_rules: bool,
+        ctx: &SimplifyCtx,
+    ) -> Vec<Tok> {
+        let mut current = tokens.to_vec();
+        loop {
+            let out = self.search_once(
+                &current,
+                node_budget,
+                max_pattern_length,
+                apply_simplification_rules,
+                ctx,
+            );
+            if out == current {
+                return current;
             }
+            current = out;
+        }
+    }
+
+    /// ONE bounded best-first search over rewrite states.
+    ///
+    /// * **Node** = a prefix expression. The **root** is the input.
+    /// * **Edges** (one flat move set; there is no cancel->rules alternation): a node's children
+    ///   are `apply_simplification_rules(node)` and `cancel(node, k)` for every qualifying
+    ///   cancellation candidate `k`. `neg`/`inv` are always region-connected -- one cancel, one
+    ///   region shape.
+    /// * **Answer** = the shortest node ever VISITED, not merely the leaves. Every node is
+    ///   a.e.-equivalent to the root (sound cancel and sound rules compose), so every node is a
+    ///   legal answer and minimising over all of them is free. Two properties fall out with no
+    ///   extra machinery: declining to cancel is simply keeping the parent, and no answer can
+    ///   ever be longer than the input, because the root itself is the first candidate.
+    ///
+    /// The graph is a DAG rather than a tree -- most branches reconverge -- so a `visited` set on
+    /// the exact token sequence collapses it. The frontier is a min-heap on node length; ties go
+    /// to insertion order, which keeps the result deterministic.
+    ///
+    /// ONE bound, about work rather than correctness: `node_budget` caps how many nodes are
+    /// EXPANDED. Its default (48, set at the API boundary) is the measured elbow of the returns
+    /// curve on the 64k v23.0 prior; raise it for offline corpus canonicalisation. A budget of 0
+    /// disables the SEARCH only -- the caller still gets masking and operand sorting, so the
+    /// result is the CANONICALISED input, not the input verbatim. A separate depth cap used to exist and was removed as provably redundant --
+    /// depth <= expansions <= budget, so any cap at or above the budget can never bind, and
+    /// measurement confirmed the reachable depth saturates well inside it.
+    ///
+    /// Deliberately absent, each tried and measured on the 64k v23.0 prior:
+    /// * a greedy PRE-FILL of `best` -- at matched wall-clock it is a wash (un-pre-filled at
+    ///   budget 32 is 1509383 tokens / 78.5 us against pre-filled at 24 with 1509365 / 79.1), and
+    ///   it forced a whole second cancel->rules code path to exist purely to produce it;
+    /// * frontier PRIORITISATION by the promise of a move -- tie-breaking by candidate kind won
+    ///   ~15 tokens per 1.5M for +2.8% time, and a one-ply post-rules lookahead LOST outright at
+    ///   matched cost. Spending the time on more expansions beats spending it on a better order.
+    fn search_once(
+        &self,
+        tokens: &[Tok],
+        node_budget: usize,
+        max_pattern_length: Option<usize>,
+        apply_simplification_rules: bool,
+        ctx: &SimplifyCtx,
+    ) -> Vec<Tok> {
+        // The root is the first candidate answer; every other node must beat it to be adopted.
+        let mut best = tokens.to_vec();
+        let mut visited: FxHashSet<Vec<Tok>> = FxHashSet::default();
+        visited.insert(tokens.to_vec());
+        // (length, tie, node) under `Reverse` -> pop the SHORTEST first; `tie` is unique so the
+        // node itself is never compared (deterministic, and no Ord cost on the payload).
+        let mut frontier: BinaryHeap<Reverse<(usize, usize, Vec<Tok>)>> = BinaryHeap::new();
+        frontier.push(Reverse((tokens.len(), 0, tokens.to_vec())));
+        let mut tie: usize = 0;
+        let mut expanded: usize = 0;
 
-            // Converged: this iteration produced no change vs the previous iteration's result.
-            if new_expression == current_expression {
+        while let Some(Reverse((_, _, node))) = frontier.pop() {
+            if expanded >= node_budget {
                 break;
             }
-            current_expression = new_expression.clone();
-        }
+            expanded += 1;
+            stats::bump(&stats::SIMPLIFY_ITERS);
 
-        // Mask elementary literals (0/1/coefficients -> <constant>) BEFORE sorting, so the final
-        // operand order is computed on the canonical (masked) tokens. Masking still runs AFTER the
-        // rule loop, so which rules fire is unchanged; this only reorders the operands of
-        // masked-literal cases and makes sort/mask a fixpoint -- fixing the sort-then-mask
-        // non-idempotency (a literal's post-sort position differed from <constant>'s, so a re-pass
-        // re-sorted the now-masked token).
-        let t_post = std::time::Instant::now();
-        if mask_elementary_literals {
-            new_expression =
-                crate::utils::mask_elementary_literals(&new_expression, &self.view(ctx));
+            let children =
+                self.children_of(&node, max_pattern_length, apply_simplification_rules, ctx);
+
+            for child in children {
+                if !visited.insert(child.clone()) {
+                    continue;
+                }
+                if child.len() < best.len() {
+                    best = child.clone();
+                }
+                tie += 1;
+                frontier.push(Reverse((child.len(), tie, child)));
+            }
         }
 
-        // Sort operands (once, after masking).
-        new_expression = crate::sort::sort_operands_unit(&new_expression, &self.view(ctx));
-        stats::add(&stats::NANOS_MASK_SORT, t_post.elapsed().as_nanos() as u64);
+        best
+    }
 
-        // Longer-result guard: a result longer than the input is not a simplification.
-        if new_expression.len() > length_before {
-            return tokens.to_vec();
+    /// A node's children in the search graph: one rules pass, plus one per qualifying
+    /// cancellation candidate.
+    fn children_of(
+        &self,
+        node: &[Tok],
+        max_pattern_length: Option<usize>,
+        apply_simplification_rules: bool,
+        ctx: &SimplifyCtx,
+    ) -> Vec<Vec<Tok>> {
+        let mut children: Vec<Vec<Tok>> = Vec::new();
+        if apply_simplification_rules {
+            children.push(memoized_pass(&ctx.rules_memo, node, || {
+                self.apply_simplification_rules_with_ctx(node, max_pattern_length, ctx)
+            }));
         }
-
-        new_expression
+        let t_cancel = std::time::Instant::now();
+        children.extend(
+            crate::cancel::cancel_successors(
+                node,
+                &self.operators,
+                &self.view(ctx),
+                ctx.wildcard_all,
+            )
+            .into_iter()
+            .map(|(child, _sum)| child),
+        );
+        stats::add(&stats::NANOS_CANCEL, t_cancel.elapsed().as_nanos() as u64);
+        // Operand SORTING is a legitimate edge -- length-neutral, semantically identity on
+        // commutative operands, and it changes which rules match -- and it was TRIED as one. It
+        // raises the reachable ceiling: with sorting confined to the pipeline loop the 64k prior
+        // saturates at 1508224 tokens (4-3) no matter how large the budget gets, while sorting
+        // as an edge reaches 1508057. But it is not efficient, because a sort pass is then paid
+        // at EVERY expansion:
+        //     ~124us  budget-only 1508255 (b96)  vs  sort-edge 1508656 (b12)
+        //     ~150us  budget-only 1508229 (b192) vs  sort-edge 1508301 (b24)
+        //     ~174us  budget-only 1508224 (b384) vs  sort-edge 1508158 (b32)   <- crossover
+        // Below ~170us/expr the budget wins outright; only past the plateau does sorting pay.
+        // At the shipped operating point (~106us) it costs ~2x for 241 tokens in 1.5M, so the
+        // cheap way to get sorting's rule-unlocking effect is what `simplify_toks` already does:
+        // sort BETWEEN pipeline rounds, a handful of times, instead of at every node.
+        children
     }
 }
diff --git a/rust/engine/tests.rs b/rust/engine/tests.rs
index dd92a07..f2b9ed0 100644
--- a/rust/engine/tests.rs
+++ b/rust/engine/tests.rs
@@ -46,7 +46,7 @@ fn prune_explicit_is_correct() {
         sample.len()
     );
     for lhs in &pruned {
-        let r = e.simplify(lhs, 5, None, false, true);
+        let r = e.simplify(lhs, 5, None, true, false);
         assert_eq!(
             &r,
             rhs_of.get(lhs).unwrap(),
@@ -60,36 +60,69 @@ fn load(name: &str) -> Vec<Vec<String>> {
     serde_json::from_str(&fs::read_to_string(p).expect("corpus fixture present")).unwrap()
 }
 
-/// Whole-unit regression gate: the composed Rust `simplify` fixpoint reproduces the frozen
-/// reference outputs on the first 400 corpus skeletons at mpl=4 AND mpl=7. The reference is the
-/// 0.7.0 ALIGNED engine line (real pow semantics at a -inf base; single engine line) -- it was
-/// regenerated from this engine when the faithful dev_7-3 reproduction line was removed. The
-/// corpus is the first 400 skeletons of the 65,536-expression training-prior benchmark. To
-/// reproduce the historical dev_7-3 / v23.0-era outputs byte-for-byte, install simplipy<=0.6.0.
+/// Whole-unit gate over the 400-skeleton corpus slice, asserting the search's INVARIANTS
+/// rather than a stored answer sheet.
+///
+/// It used to compare against frozen per-row outputs. That is the wrong shape of test for a
+/// bounded search: the outputs are a function of `node_budget`, so the expectations had to be
+/// regenerated on every tuning change and would fail confusingly for anyone running a different
+/// budget -- reporting "regression" when the engine had merely searched harder. What is actually
+/// contractual is asserted here instead, and holds at ANY budget:
+///   * no result is longer than its input (the root is the first candidate answer);
+///   * the EQUIVALENCE LOOP (mask=false) is idempotent (a second pass cannot beat the first);
+///   * it is deterministic (ties break on insertion order);
+///   * a larger budget never yields a longer result (more search cannot hurt);
+///   * the engine actually does something (most rows change);
+///   * the TERMINAL MASK (mask=true) is length-neutral -- it only relabels literals to
+///     `<constant>`, never grows or shrinks. Idempotence is asserted on the equivalence loop,
+///     NOT on the masked result: masking mints free constants from structural literals
+///     (`x-x -> 0 -> <constant>`), so a masked output re-fed to `simplify` can collect
+///     redundant constants (~0.4% of rows). That is by design -- masking is a terminal
+///     representation step for the downstream model, never re-simplified -- so requiring the
+///     masked form to be a search fixpoint would re-introduce the unsound in-loop fold it
+///     was split out to avoid.
 #[test]
-fn simplify_matches_frozen_reference() {
-    // Skip when the frozen corpus is absent -- this in-crate slice only fires where the
-    // fixtures are staged (benchmarks/corpus/).
+fn simplify_holds_its_invariants_on_the_corpus() {
     let corpus = format!(
         "{}/benchmarks/corpus/raw_skeletons.json",
         env!("CARGO_MANIFEST_DIR")
     );
     if !std::path::Path::new(&corpus).exists() {
-        eprintln!("simplify_matches_frozen_reference: SKIPPED (corpus fixtures not vendored)");
+        eprintln!("simplify_holds_its_invariants_on_the_corpus: SKIPPED (fixtures not vendored)");
         return;
     }
     let Some(e) = engine() else { return };
     let raw = load("raw_skeletons.json");
     for mpl in [4usize, 7usize] {
-        let reference = load(&format!("reference_aligned_mpl{mpl}.json"));
-        assert_eq!(raw.len(), reference.len());
         let mut n_changed = 0;
-        for (s, r) in raw.iter().zip(reference.iter()).take(400) {
-            let out = e.simplify(s, 5, Some(mpl), true, true);
+        for s in raw.iter().take(400) {
+            // The equivalence loop: the sound, idempotent, deterministic core (no masking).
+            let out = e.simplify(s, 48, Some(mpl), true, false);
+            assert!(
+                out.len() <= s.len(),
+                "grew: mpl={mpl} {} -> {} input={s:?}",
+                s.len(),
+                out.len()
+            );
+            let again = e.simplify(&out, 48, Some(mpl), true, false);
+            assert_eq!(&again, &out, "not idempotent: mpl={mpl} input={s:?}");
+            let repeat = e.simplify(s, 48, Some(mpl), true, false);
+            assert_eq!(&repeat, &out, "not deterministic: mpl={mpl} input={s:?}");
+            let richer = e.simplify(s, 256, Some(mpl), true, false);
+            assert!(
+                richer.len() <= out.len(),
+                "more budget gave a longer result: mpl={mpl} input={s:?}"
+            );
+            // The separate mask pass is length-neutral (it only relabels literals + sorts).
+            let masked = e.mask(&out);
+            assert_eq!(
+                masked.len(),
+                out.len(),
+                "mask changed length: mpl={mpl} input={s:?}"
+            );
             if &out != s {
                 n_changed += 1;
             }
-            assert_eq!(&out, r, "mpl={mpl} input={s:?}");
         }
         assert!(
             n_changed > 300,
@@ -179,13 +212,13 @@ fn nan_literal_propagates_in_numeric_fold() {
             5,
             None,
             true,
-            true
+            false
         ),
         nan
     );
     // propagation reaches VARIABLE contexts, which the evidence-based miner cannot:
     assert_eq!(
-        e.simplify(&t(&["*", "x0", "acos", "np.e"]), 5, None, true, true),
+        e.simplify(&t(&["*", "x0", "acos", "np.e"]), 5, None, true, false),
         nan
     );
     // pow does not propagate structurally (pow(1, NaN) = 1):
@@ -195,7 +228,7 @@ fn nan_literal_propagates_in_numeric_fold() {
         5,
         None,
         true,
-        true,
+        false,
     );
     assert_ne!(kept, nan, "pow(<constant>, nan) must not fold to nan");
     assert_eq!(
diff --git a/rust/lib.rs b/rust/lib.rs
index 0a1970a..f28ea42 100644
--- a/rust/lib.rs
+++ b/rust/lib.rs
@@ -6,7 +6,7 @@
 //! with NO boundary crossings:
 //!   cancel_terms -> apply_simplification_rules (parse_subtree + apply_rules_top_down +
 //!   match_pattern_with_cert + apply_mapping + the constant fold) -> sort_operands ->
-//!   mask_elementary_literals -> longer-result guard, iterated to a fixpoint (<= max_iter).
+//!   mask_elementary_literals, over a best-first tree search bounded by `node_budget`.
 //! ~1.8 boundary crossings/expr; FFI marshalling stays <1% of wall time.
 //! Porting the pattern matcher alone is a TRAP (millions of crossings -> the speedup evaporates).
 //! Therefore the PyO3 layer here is deliberately THIN: marshal `list[str]` <-> `Vec<String>`,
@@ -142,34 +142,46 @@ impl PyEngine {
     }
 
     /// THE hot path and the whole FFI unit. `tokens` is a prefix token list; returns the
-    /// simplified prefix token list. Defaults mirror the deployed call
+    /// EQUIVALENCE-preserving simplified prefix token list. Defaults mirror the deployed call
     /// (`simplify(skeleton, inplace=True, max_pattern_length=None)`); `inplace` is a Python-shim
     /// concern (the shim mutates the caller's list), so it is NOT a kernel parameter here.
-    #[pyo3(signature = (tokens, max_iter=5, max_pattern_length=None, mask_elementary_literals=true,
-                        apply_simplification_rules=true))]
+    ///
+    /// Does NOT mask: masking (literals -> `<constant>`) is a representation step carved out into
+    /// [`PyEngine::mask`] -- callers needing placeholders apply it to this output.
+    #[pyo3(signature = (tokens, node_budget=48, max_pattern_length=None,
+                        apply_simplification_rules=true, wildcard_all=false))]
     fn simplify(
         &self,
         py: Python<'_>,
         tokens: Vec<String>,
-        max_iter: usize,
+        node_budget: usize,
         max_pattern_length: Option<usize>,
-        mask_elementary_literals: bool,
         apply_simplification_rules: bool,
+        wildcard_all: bool,
     ) -> PyResult<Py<PyList>> {
         ensure_well_formed(&self.inner, &tokens)?;
         // Release the GIL for the pure-Rust kernel (parallel callers are not serialized on Python's lock).
         let out = py.detach(|| {
             self.inner.simplify(
                 &tokens,
-                max_iter,
+                node_budget,
                 max_pattern_length,
-                mask_elementary_literals,
                 apply_simplification_rules,
+                wildcard_all,
             )
         });
         Ok(PyList::new(py, out)?.into())
     }
 
+    /// The REPRESENTATION pass: relabel numeric literals to `<constant>` + sort. Apply to
+    /// `simplify`'s output when a downstream model needs placeholders; never re-`simplify` the
+    /// result (see [`Engine::mask`]).
+    fn mask(&self, py: Python<'_>, tokens: Vec<String>) -> PyResult<Py<PyList>> {
+        ensure_well_formed(&self.inner, &tokens)?;
+        let out = py.detach(|| self.inner.mask(&tokens));
+        Ok(PyList::new(py, out)?.into())
+    }
+
     /// Validation entry (NOT the shipped surface): the rule-application sub-unit only
     /// (`apply_simplification_rules`).
     #[pyo3(signature = (tokens, max_pattern_length=None))]
diff --git a/rust/matcher.rs b/rust/matcher.rs
index c62d0c4..77e4e6d 100644
--- a/rust/matcher.rs
+++ b/rust/matcher.rs
@@ -55,11 +55,18 @@ fn is_variable_leaf(node: &Node, view: &TokenView) -> bool {
 /// certificates run ONCE per COMPLETED syntactic match, over the final `!`-bindings -- the same
 /// conjunction as certifying mid-walk (identical verdicts), but never paid on attempts that
 /// fail syntactically elsewhere.
+///
+/// `wildcard_all` (the AGGRESSIVE apply-time mode, the symmetric opposite of
+/// `leaf_wildcards_only`): every placeholder (`?`/`!`/`_`) binds ANY subtree and the `!`
+/// certificate is SKIPPED. This is the "ignore certificates, treat all as `_`" mode -- slightly
+/// unsound (binds pole/inf/nan-bearing composites) by construction. The sort-independent
+/// `contains_constant` rebind guard is preserved (it is not a soundness certificate).
 pub fn match_pattern_with_cert<'a>(
     tree: &'a Node,
     pattern: &Node,
     mapping: &mut FxHashMap<Tok, &'a Node>,
     cert: Option<&dyn Fn(&Node) -> bool>,
+    wildcard_all: bool,
     view: &TokenView,
 ) -> bool {
     if !match_pattern_impl(
@@ -68,15 +75,18 @@ pub fn match_pattern_with_cert<'a>(
         mapping,
         leaf_wildcards_only(),
         cert.is_some(),
+        wildcard_all,
         view,
     ) {
         return false;
     }
-    for (pkey, bound) in mapping.iter() {
-        if view.sigil(*pkey) == b'!' && !is_variable_leaf(bound, view) {
-            match cert {
-                Some(f) if f(bound) => {}
-                _ => return false, // uncertified or uncertifiable: no binding (fail-closed)
+    if !wildcard_all {
+        for (pkey, bound) in mapping.iter() {
+            if view.sigil(*pkey) == b'!' && !is_variable_leaf(bound, view) {
+                match cert {
+                    Some(f) if f(bound) => {}
+                    _ => return false, // uncertified or uncertifiable: no binding (fail-closed)
+                }
             }
         }
     }
@@ -89,6 +99,7 @@ fn match_pattern_impl<'a>(
     mapping: &mut FxHashMap<Tok, &'a Node>,
     leaf_only: bool,
     bang_binds_composite: bool,
+    wildcard_all: bool,
     view: &TokenView,
 ) -> bool {
     match pattern {
@@ -102,11 +113,13 @@ fn match_pattern_impl<'a>(
                 // SIMPLIPY_LEAF_WILDCARDS diagnostic demotes it; `!` binds a variable leaf
                 // freely, or a SUBTREE only when the
                 // certifier proves it defined-and-finite a.e.
-                if (sigil == b'?' || leaf_only) && !is_variable_leaf(tree, view) {
-                    return false;
-                }
-                if sigil == b'!' && !is_variable_leaf(tree, view) && !bang_binds_composite {
-                    return false; // no certifier available: `!` binds variable leaves only
+                if !wildcard_all {
+                    if (sigil == b'?' || leaf_only) && !is_variable_leaf(tree, view) {
+                        return false;
+                    }
+                    if sigil == b'!' && !is_variable_leaf(tree, view) && !bang_binds_composite {
+                        return false; // no certifier available: `!` binds variable leaves only
+                    }
                 }
                 match mapping.get(pkey) {
                     None => {
@@ -148,6 +161,7 @@ fn match_pattern_impl<'a>(
                         mapping,
                         leaf_only,
                         bang_binds_composite,
+                        wildcard_all,
                         view,
                     ) {
                         return false;
@@ -231,7 +245,7 @@ mod tests {
         let view = TokenView::new(&table, &overlay);
         let (q, p) = (tree(query, &view), tree(pattern, &view));
         let mut m = FxHashMap::default();
-        match_pattern_impl(&q, &p, &mut m, leaf_only, false, &view)
+        match_pattern_impl(&q, &p, &mut m, leaf_only, false, false, &view)
     }
 
     /// Under `?`-sort semantics (leaf_only=true) a slot binds a variable leaf or nothing.
diff --git a/src/simplipy/__init__.py b/src/simplipy/__init__.py
index 563f0e4..f40b82b 100644
--- a/src/simplipy/__init__.py
+++ b/src/simplipy/__init__.py
@@ -6,7 +6,7 @@
 helpers, token/rule utilities, and asset management for downloading and
 resolving engine rulesets and test data.
 """
-from .engine import SimpliPyEngine
+from .engine import SimpliPyEngine, Mode
 from . import engine
 from . import operators
 from . import utils
diff --git a/src/simplipy/_core.pyi b/src/simplipy/_core.pyi
index fe3d5fd..2b04bdc 100644
--- a/src/simplipy/_core.pyi
+++ b/src/simplipy/_core.pyi
@@ -16,11 +16,12 @@ class Engine:
     def simplify(
         self,
         tokens: list[str],
-        max_iter: int = ...,
+        node_budget: int = ...,
         max_pattern_length: int | None = ...,
-        mask_elementary_literals: bool = ...,
         apply_simplification_rules: bool = ...,
+        wildcard_all: bool = ...,
     ) -> list[str]: ...
+    def mask(self, tokens: list[str]) -> list[str]: ...
     def apply_rules(
         self, tokens: list[str], max_pattern_length: int | None = ...
     ) -> list[str]: ...
diff --git a/src/simplipy/engine.py b/src/simplipy/engine.py
index dadd694..3bda3d5 100644
--- a/src/simplipy/engine.py
+++ b/src/simplipy/engine.py
@@ -17,6 +17,7 @@
 from pathlib import Path
 from typing import Any, Literal
 from copy import deepcopy
+from enum import IntEnum
 
 import numpy as np
 import json
@@ -140,6 +141,28 @@ def _load_proposals(
     return entries, record
 
 
+class Mode(IntEnum):
+    """The simplification soundness mode: an ORDINAL axis where a higher rung permits
+    strictly more aggressive (less sound) rewrites.
+
+    The decided full ordering is ``EXACT <= SOUND <= AE <= LOSSY``; only the two implemented
+    rungs are exposed. ``EXACT`` (0) and ``AE`` (2) are reserved positions in that ordering,
+    not yet implemented -- the gaps in the integer values keep the ordinal stable when they
+    are added.
+
+    - ``SOUND`` (the default): equivalence-preserving and idempotent. The deployed
+      inference/scoring mode. Byte-identical to the historical default.
+    - ``LOSSY``: trades soundness for recall -- every rule placeholder binds any subtree (the
+      ``!``-sort finite-a.e. certificate is skipped) AND the constant-fold's finiteness gate is
+      relaxed (so e.g. ``<constant>/0`` collapses to ``<constant>``). For training-corpus
+      canonicalisation ONLY: the training data is generated FROM the simplified form, so the
+      target equals the data and there is no external function to violate. Do NOT use on an
+      inference or scoring path.
+    """
+    SOUND = 1
+    LOSSY = 3
+
+
 class SimpliPyEngine:
     """Manages and manipulates symbolic expressions.
 
@@ -335,7 +358,7 @@ def prune_covered_rules(self, verbose: bool = False) -> int:
 
         def covered(core: Any, lhs: tuple[str, ...], rhs: tuple[str, ...]) -> bool:
             return all(
-                len(core.simplify(variant_lhs, 5, None, True, True)) <= len(variant_rhs)
+                len(core.simplify(variant_lhs, 5, None, True)) <= len(variant_rhs)
                 for variant_lhs, variant_rhs in _coverage_variants(lhs, rhs))
 
         kept = set(full)
@@ -659,40 +682,57 @@ def parse(
     def simplify(
             self,
             expression: str | list[str] | tuple[str, ...] | np.ndarray,
-            max_iter: int = 5,
+            node_budget: int = 48,
             max_pattern_length: int | None = None,
-            mask_elementary_literals: bool = True,
             apply_simplification_rules: bool = True,
-            inplace: bool = False) -> str | list[str] | tuple[str, ...] | np.ndarray:
-        """Performs a full simplification of a mathematical expression.
+            inplace: bool = False,
+            mode: Mode = Mode.SOUND) -> str | list[str] | tuple[str, ...] | np.ndarray:
+        """Performs a full, EQUIVALENCE-preserving simplification of an expression.
 
         This is the main public method for simplification. The whole fixpoint
-        (term cancellation, rule application, constant folding, operand sorting,
-        the longer-result guard) runs in the compiled core as ONE call.
+        (term cancellation, rule application, constant folding, operand sorting)
+        runs in the compiled core as ONE call, and is idempotent by construction.
+
+        ``simplify`` does NOT mask literals. Masking (replacing numeric literals with the
+        generic ``<constant>`` placeholder) is a REPRESENTATION step for a downstream model
+        that cannot consume literals, not an equivalence-preserving rewrite -- it is carved out
+        into :meth:`mask`. A caller that needs placeholders applies ``mask`` to this output,
+        e.g. ``engine.mask(engine.simplify(expr))``. Masking was removed from ``simplify``
+        because folding a freshly-masked literal is unsound (a structural ``x-x -> 0`` masked to
+        a free ``<constant>`` can be re-folded into a denominator, dropping the reachable ``0``
+        and making the result non-equivalent) and was the sole cause of non-idempotence.
 
         Parameters
         ----------
         expression : str or list[str] or tuple[str, ...] or np.ndarray
             The expression to simplify, given as an infix string, a prefix
             token list/tuple, or a one-dimensional numpy array of tokens.
-        max_iter : int, optional
-            The maximum number of simplification iterations. Defaults to 5.
+        node_budget : int, optional
+            How many nodes the simplification tree search may EXPAND before it stops and
+            returns the shortest expression it reached. Defaults to 48, the measured elbow of
+            the returns curve: below it an extra microsecond buys several output tokens, above
+            it a fraction of one. Raise it for offline corpus canonicalisation. Note that 0
+            disables the SEARCH only: operand sorting still runs, so the result is the
+            sort-canonicalised input rather than the input verbatim.
         max_pattern_length : int or None, optional
             The maximum length of a rule pattern to consider.
-        mask_elementary_literals : bool, optional
-            If True, replaces literals like '0' and '1' that result from
-            cancellation with a generic `<constant>` token. Defaults to True.
         apply_simplification_rules : bool, optional
             If False, skips the rule-based simplification step. Defaults to True.
         inplace : bool, optional
             If the input is a list, this modifies it directly. Defaults to False.
+        mode : Mode, optional
+            The soundness mode (see :class:`Mode`). ``Mode.SOUND`` (default) is
+            equivalence-preserving and idempotent -- the deployed inference/scoring path.
+            ``Mode.LOSSY`` trades soundness for recall: rule placeholders bind any subtree
+            (the ``!``-sort finite-a.e. certificate is skipped) and the constant-fold's
+            finiteness gate is relaxed (so e.g. ``<constant>/0`` collapses to ``<constant>``).
+            Use ``Mode.LOSSY`` ONLY for training-corpus canonicalisation, never on an inference
+            or scoring path.
 
         Returns
         -------
         str or list[str] or tuple[str, ...] or np.ndarray
-            The simplified expression, in the same format as the input. If the
-            simplification results in a longer expression, the original
-            expression is returned (for a str input, the re-rendered original).
+            The simplified expression, in the same format as the input.
 
         Notes
         -----
@@ -701,9 +741,6 @@ def simplify(
         (``1/0`` -> ``float("inf")``, ``sqrt(-1)`` -> ``float("nan")``). The
         resulting ``float("inf")`` / ``float("-inf")`` / ``float("nan")`` tokens
         are atomic and round-trip through the prefix/infix conversions.
-
-        The ``collect_statistics`` and ``verbose`` debugging parameters of the removed
-        pure-Python engine are gone.
         """
         # Normalize the input to a prefix token list (per type), then ONE core call, then
         # denormalize back to the input type.
@@ -715,9 +752,54 @@ def simplify(
         else:
             tokens = list(expression)
 
-        out = self._core.simplify(tokens, max_iter, max_pattern_length,
-                                  mask_elementary_literals, apply_simplification_rules)
+        out = self._core.simplify(tokens, node_budget, max_pattern_length,
+                                  apply_simplification_rules, mode == Mode.LOSSY)
+
+        return self._denormalize(out, expression, inplace)
+
+    def mask(
+            self,
+            expression: str | list[str] | tuple[str, ...] | np.ndarray,
+            inplace: bool = False) -> str | list[str] | tuple[str, ...] | np.ndarray:
+        """The REPRESENTATION pass, carved out of :meth:`simplify`.
 
+        Relabels every numeric-literal token (``0``, ``1``, ``3.14``, ...) to the generic
+        ``<constant>`` placeholder and sorts, so a downstream model that cannot consume literals
+        sees placeholders. Apply to the output of :meth:`simplify`; do NOT re-``simplify`` the
+        result (a masked form re-fed to the search can collect redundant constants and, on
+        structural-zero inputs, fold unsoundly -- which is why masking is not part of
+        ``simplify``). ``mask`` is a pure widening and is idempotent.
+
+        Parameters
+        ----------
+        expression : str or list[str] or tuple[str, ...] or np.ndarray
+            The expression to mask, in any of the accepted input formats.
+        inplace : bool, optional
+            If the input is a list, this modifies it directly. Defaults to False.
+
+        Returns
+        -------
+        str or list[str] or tuple[str, ...] or np.ndarray
+            The masked expression, in the same format as the input.
+        """
+        if isinstance(expression, str):
+            tokens = self._core.parse(expression, True, False)
+        elif isinstance(expression, np.ndarray):
+            _validate_ndarray_input(expression, inplace)
+            tokens = expression.tolist()
+        else:
+            tokens = list(expression)
+
+        out = self._core.mask(tokens)
+
+        return self._denormalize(out, expression, inplace)
+
+    def _denormalize(
+            self,
+            out: list[str],
+            expression: str | list[str] | tuple[str, ...] | np.ndarray,
+            inplace: bool) -> str | list[str] | tuple[str, ...] | np.ndarray:
+        """Map a core prefix-token result back to the input's type (shared by simplify/mask)."""
         if isinstance(expression, str):
             return self._core.prefix_to_infix(out, '**', False)
         if isinstance(expression, np.ndarray):
diff --git a/src/simplipy/promotion/_refund.py b/src/simplipy/promotion/_refund.py
index b156c02..9e0c8e1 100644
--- a/src/simplipy/promotion/_refund.py
+++ b/src/simplipy/promotion/_refund.py
@@ -128,7 +128,7 @@ def sub_apply(a, sig):
         rest = [[list(l), list(r)] for j, (l, r) in enumerate(current) if j != i and (l, r) not in pruned]
         e2 = SimpliPyEngine(operators=OPS, rules=rest)
         try:
-            got = e2.simplify(fresh(lhs), max_pattern_length=None, mask_elementary_literals=False)
+            got = e2.simplify(fresh(lhs), max_pattern_length=None)
         except Exception:
             keep.append((lhs, rhs))
             continue
diff --git a/tests/test_engine_simplification.py b/tests/test_engine_simplification.py
index e446db5..9f2da23 100644
--- a/tests/test_engine_simplification.py
+++ b/tests/test_engine_simplification.py
@@ -163,7 +163,7 @@ def test_remaining_explicit_rules_are_necessary(self) -> None:
             engine.simplification_rules = [r for r in all_rules if tuple(r[0]) != tuple(lhs)]
             engine.compile_rules()
             try:
-                result = engine.simplify(list(lhs), mask_elementary_literals=False)
+                result = engine.simplify(list(lhs))
                 assert tuple(result) != tuple(rhs), (
                     f"Rule {lhs} -> {rhs} is still redundant after pruning"
                 )
@@ -405,6 +405,52 @@ def test_no_matching_rule_unchanged(self) -> None:
         assert result == ["+", "x", "y"]
 
 
+class TestMode:
+    """The soundness `Mode` axis: SOUND (default) keeps a non-finite-a.e. subtree; LOSSY
+    relaxes the constant-fold's finiteness gate (and the rule matcher's `!`-certificate)."""
+
+    def test_mode_is_exported_and_ordinal(self) -> None:
+        from simplipy import Mode
+        assert Mode.SOUND < Mode.LOSSY
+        assert [m.name for m in Mode] == ["SOUND", "LOSSY"]
+
+    def test_sound_keeps_constant_over_zero(self) -> None:
+        """`<constant>/0` is +-inf/nan for every constant, so SOUND must NOT fold it."""
+        from simplipy import Mode
+        engine = SimpliPyEngine(operators=_MINIMAL_OPERATORS, rules=[])
+        assert engine.simplify(["/", "<constant>", "0"], mode=Mode.SOUND) == ["/", "<constant>", "0"]
+        # the default is SOUND
+        assert engine.simplify(["/", "<constant>", "0"]) == ["/", "<constant>", "0"]
+
+    def test_lossy_folds_constant_over_zero(self) -> None:
+        """LOSSY relaxes the finiteness gate: `<constant>/0` collapses to `<constant>`."""
+        from simplipy import Mode
+        engine = SimpliPyEngine(operators=_MINIMAL_OPERATORS, rules=[])
+        assert engine.simplify(["/", "<constant>", "0"], mode=Mode.LOSSY) == ["<constant>"]
+
+    def test_finite_ae_fold_is_mode_independent(self) -> None:
+        """A finite-a.e. subtree (`1/C`) folds in BOTH modes -- the pole is measure-zero."""
+        from simplipy import Mode
+        engine = SimpliPyEngine(operators=_MINIMAL_OPERATORS, rules=[])
+        assert engine.simplify(["inv", "<constant>"], mode=Mode.SOUND) == ["<constant>"]
+        assert engine.simplify(["inv", "<constant>"], mode=Mode.LOSSY) == ["<constant>"]
+
+    def test_lossy_relaxes_cancellation_group_axioms(self) -> None:
+        """The THIRD edge: SOUND cancellation respects the group axioms (`inf/inf`, `inf-inf`
+        stay the sound `nan`); LOSSY relaxes them (structural cancel) -- the same relaxation LOSSY
+        applies to the rule matcher's `!`-cert and the constant-fold's finiteness gate, so all
+        three edges behave consistently under `Mode.LOSSY`."""
+        import simplipy
+        from simplipy import Mode
+        engine = SimpliPyEngine.from_config(simplipy.get_path('4-3', install=True))
+        for c in ([["*", "/", 'float("inf")', 'float("inf")', "x0"],    # (inf/inf)*x0
+                   ["+", "-", 'float("inf")', 'float("inf")', "x0"]]):   # (inf-inf)+x0
+            sound = list(engine.simplify(list(c), mode=Mode.SOUND))
+            lossy = list(engine.simplify(list(c), mode=Mode.LOSSY))
+            assert sound == ['float("nan")'], (c, sound)   # SOUND keeps the sound (non-finite) value
+            assert lossy != sound, (c, sound, lossy)       # LOSSY structurally relaxed it
+
+
 class TestOperatorConversions:
     """Tests for operators_to_realizations and realizations_to_operators."""
 
@@ -432,7 +478,7 @@ def test_unknown_token_passed_through(self) -> None:
     engine = SimpliPyEngine.load("dev_7-3", install=True)
     expr = " + ".join(["x"] * 14)
 
-    simplified = engine.simplify(expr, max_iter=1)
+    simplified = engine.simplify(expr, node_budget=2)
     simplified_prefix = engine.parse(simplified)
 
     assert "mult7" not in simplified_prefix
@@ -443,7 +489,7 @@ def test_repeated_multiplication_avoids_unsupported_powers() -> None:
     engine = SimpliPyEngine.load("dev_7-3", install=True)
     expr = "x / (" + " * ".join(["x"] * 15) + ")"
 
-    simplified = engine.simplify(expr, max_iter=1)
+    simplified = engine.simplify(expr, node_budget=2)
     simplified_prefix = engine.parse(simplified)
 
     assert "pow7" not in simplified_prefix
@@ -456,7 +502,7 @@ def test_simplify_accepts_numpy_array_tokens() -> None:
     prefix_tokens = engine.parse("x1 + x2")
     expr = np.array(prefix_tokens, dtype=object)
 
-    simplified = engine.simplify(expr, max_iter=1, apply_simplification_rules=False)
+    simplified = engine.simplify(expr, node_budget=2, apply_simplification_rules=False)
 
     assert isinstance(simplified, np.ndarray)
     assert simplified.dtype == expr.dtype
@@ -685,69 +731,69 @@ def _engine(self, rules=None) -> SimpliPyEngine:
     def test_binary_addition_folding(self) -> None:
         """1.23 + 4.56 should evaluate to a numeric result close to 5.79."""
         engine = self._engine()
-        result = engine.simplify(["+", "1.23", "4.56"], mask_elementary_literals=False)
+        result = engine.simplify(["+", "1.23", "4.56"])
         assert len(result) == 1
         assert abs(float(result[0]) - 5.79) < 1e-10
 
     def test_binary_subtraction_folding(self) -> None:
         """5 - 3 should evaluate to 2."""
         engine = self._engine()
-        result = engine.simplify(["-", "5", "3"], mask_elementary_literals=False)
+        result = engine.simplify(["-", "5", "3"])
         assert result == ["2"]
 
     def test_integer_result_formatting(self) -> None:
         """Integer-valued results should not have a decimal point."""
         engine = self._engine()
-        result = engine.simplify(["+", "1", "2"], mask_elementary_literals=False)
+        result = engine.simplify(["+", "1", "2"])
         assert result == ["3"]
 
     def test_unary_folding(self) -> None:
         """neg(3) should evaluate to -3."""
         engine = self._engine()
-        result = engine.simplify(["neg", "3"], mask_elementary_literals=False)
+        result = engine.simplify(["neg", "3"])
         assert result == ["-3"]
 
     def test_nested_constant_folding(self) -> None:
         """2 * 3 + 4 should evaluate to 10 via nested folding."""
         engine = self._engine()
-        result = engine.simplify(["+", "*", "2", "3", "4"], mask_elementary_literals=False)
+        result = engine.simplify(["+", "*", "2", "3", "4"])
         assert result == ["10"]
 
     def test_division_by_zero_produces_inf(self) -> None:
         """1 / 0 should produce float("inf") token."""
         engine = self._engine()
-        result = engine.simplify(["/", "1", "0"], mask_elementary_literals=False)
+        result = engine.simplify(["/", "1", "0"])
         assert result == ['float("inf")']
 
     def test_mixed_constant_and_placeholder(self) -> None:
         """<constant> + numeric should fold to <constant>."""
         engine = self._engine()
-        result = engine.simplify(["+", "1.23", "<constant>"], mask_elementary_literals=False)
+        result = engine.simplify(["+", "1.23", "<constant>"])
         assert result == ["<constant>"]
 
     def test_constant_placeholder_still_folds(self) -> None:
         """<constant> + <constant> should still fold to <constant>."""
         engine = self._engine()
-        result = engine.simplify(["+", "<constant>", "<constant>"], mask_elementary_literals=False)
+        result = engine.simplify(["+", "<constant>", "<constant>"])
         assert result == ["<constant>"]
 
     def test_folding_enables_further_rules(self) -> None:
         """1 - 1 = 0, then x + 0 should simplify to x via rule."""
         engine = self._engine(rules=[(["+", "_0", "0"], ["_0"])])
-        result = engine.simplify(["+", "x", "-", "1", "1"], mask_elementary_literals=False)
+        result = engine.simplify(["+", "x", "-", "1", "1"])
         assert result == ["x"]
 
     def test_simplify_infix_numeric_constants(self) -> None:
-        """End-to-end: infix '1.23 + 4.56' should become '<constant>'."""
+        """End-to-end: infix '1.23 + 4.56' folds to a literal, then mask() -> '<constant>'."""
         engine = self._engine()
-        result = engine.simplify("1.23 + 4.56")
+        result = engine.mask(engine.simplify("1.23 + 4.56"))
         assert result == "<constant>"
 
     def test_constant_folding_observable(self) -> None:
         """Folding is observable through the simplify result itself (the pure-Python
         SimplificationStatistics instrumentation was removed in the Rust-only cutover)."""
         engine = self._engine()
-        assert engine.simplify(["+", "1", "2"], mask_elementary_literals=False) == ["3"]
+        assert engine.simplify(["+", "1", "2"]) == ["3"]
 
 
 class TestResolveConstantRules:
@@ -806,7 +852,7 @@ def test_compile_rules_called(self) -> None:
         rules = {tuple(lhs): tuple(rhs) for lhs, rhs in engine.simplification_rules}
         assert ("sin", "1") in rules
         assert rules[("sin", "1")] != ("<constant>",)
-        result = engine.simplify(["sin", "1"], mask_elementary_literals=False)
+        result = engine.simplify(["sin", "1"])
         assert tuple(result) == rules[("sin", "1")]
 
     def test_multiple_rules_mixed(self) -> None:
@@ -877,3 +923,67 @@ def test_uncertified_subtrees_do_not_bind(self, tmp_path) -> None:
         # inv: finite a.e. but pole-bearing -- OUT of the certificate's stated scope (needs
         # inf_null); fail-closed means no binding, never unsoundness
         assert list(engine.simplify(["-", "inv", "x0", "inv", "x0"])) == ["-", "inv", "x0", "inv", "x0"]
+
+
+class TestSearchAndAggressiveMode:
+    """The cancel/rules SEARCH (`Engine::simplify_search`) and the `Mode.LOSSY` apply-time
+    aggressive mode -- the two public behaviours added on top of the plain fixpoint."""
+
+    def _engine(self):
+        import simplipy
+        return SimpliPyEngine.from_config(simplipy.get_path('4-3', install=True))
+
+    def test_search_never_grows_an_expression(self) -> None:
+        """The search minimises over VISITED states and the input is state zero, so no result
+        can ever be longer than its input -- for any node budget."""
+        engine = self._engine()
+        cases = [
+            ["/", "x0", "inv", "x0"],
+            ["*", "/", "x1", "x1", "inv", "x1"],
+            ["+", "x0", "neg", "+", "x0", "x1"],
+            ["/", "inv", "x4", "x4"],
+            ["-", "x5", "+", "x5", "x5"],
+        ]
+        for expr in cases:
+            assert len(engine.simplify(list(expr))) <= len(expr), expr
+
+    def test_search_finds_the_shadowed_cancellation(self) -> None:
+        """Regression for the candidate-shadowing tail: `inv(x)/x` must not be left at the
+        greedy hyper-merge form, which is LONGER than simply not cancelling."""
+        engine = self._engine()
+        assert len(engine.simplify(["/", "inv", "x4", "x4"])) <= 4
+
+    def test_simplify_is_idempotent(self) -> None:
+        """A second pass must be a no-op: the search returns a state the next call cannot beat."""
+        engine = self._engine()
+        for expr in (["/", "x0", "inv", "x0"], ["*", "/", "x1", "x1", "inv", "x1"],
+                     ["-", "x5", "+", "x5", "x5"], ["/", "inv", "x4", "x4"]):
+            once = list(engine.simplify(list(expr)))
+            assert list(engine.simplify(list(once))) == once, expr
+
+    def test_lossy_mode_is_off_by_default_and_only_widens(self) -> None:
+        """`Mode.LOSSY` is the AGGRESSIVE apply-time mode: `Mode.SOUND` is the default, and LOSSY
+        only ever binds MORE (never fewer) placeholders, so it can only shorten."""
+        from simplipy import Mode
+        engine = self._engine()
+        exprs = [
+            ["/", "x0", "inv", "x0"],
+            ["*", "x1", "/", "x1", "x1"],
+            ["+", "sin", "x0", "neg", "sin", "x0"],
+            ["-", "log", "x0", "log", "x0"],
+        ]
+        for expr in exprs:
+            default = list(engine.simplify(list(expr)))
+            explicit_sound = list(engine.simplify(list(expr), mode=Mode.SOUND))
+            aggressive = list(engine.simplify(list(expr), mode=Mode.LOSSY))
+            assert default == explicit_sound, expr
+            assert len(aggressive) <= len(default), (expr, default, aggressive)
+
+    def test_cancel_only_applies_one_cancellation(self) -> None:
+        """`cancel_only` exposes the cancellation unit alone: ONE cancellation under the default
+        selection. It is not "what simplify does" -- the tree search branches over every
+        candidate instead of privileging one -- so this pins the unit's own contract only."""
+        engine = self._engine()
+        expr = ["*", "/", "x1", "x1", "inv", "x1"]
+        assert list(engine._core.cancel_only(list(expr))) == \
+            ["*", "/", "inv", "x1", "1", "inv", "1"]
diff --git a/tests/test_equivalence.py b/tests/test_equivalence.py
index 089085d..1ac3476 100644
--- a/tests/test_equivalence.py
+++ b/tests/test_equivalence.py
@@ -96,13 +96,24 @@ def test_equivalence_10k_with_asset_manager():
                 is_both_negative_inf_mask = (np.isneginf(y_filtered) & np.isneginf(y_candidate_filtered))
                 is_both_invalid_mask = is_both_nan_mask | is_both_inf_mask | is_both_negative_inf_mask
 
-                # absolute_equivalence_mask = abs_diff <= absolute_tolerance
+                # Accept a point as equivalent on EITHER a small relative OR a small absolute
+                # difference. The absolute clause matters for expressions that are mathematically
+                # zero: `simplify` now correctly reduces them to the literal `0` (previously the
+                # trailing mask relabelled that `0` to `<constant>`, so the candidate carried a
+                # constant and this branch was skipped entirely), but the ORIGINAL evaluates to
+                # floating-point noise ~1e-14 around zero, and dividing that noise by itself gives
+                # a relative difference of ~1. A small absolute tolerance recognises "original ~= 0,
+                # candidate == 0" as the correct simplification it is.
+                absolute_tolerance = 1e-8
+                absolute_equivalence_mask = abs_diff <= absolute_tolerance
                 relative_equivalence_mask = np.abs(abs_diff / np.where(y_filtered != 0, y_filtered, 1)) <= relative_tolerance
 
-                # Require 99% of values to be equivalent
-                # The following is a correct simplification but creates <1% values that are not equivalent (perhaps due to numerical issues):
-                # ['tan', '+', 'atan', 'x2', '*', 'exp', '-', '+', 'x2', '+', 'x3', '/', 'x2', 'x3', 'x2', 'x2'] -> ['tan', '+', 'atan', 'x2', '*', 'exp', '-', '+', 'x2', '+', 'x3', '/', 'x2', 'x3', 'x2', 'x2']
-                expressions_match = np.mean(relative_equivalence_mask | is_both_invalid_mask) >= 0.95
+                # Require 95% of values to be equivalent (relative OR absolute OR both-invalid).
+                # Some correct simplifications still leave <5% numerically-divergent points, e.g.
+                # ['tan', '+', 'atan', 'x2', '*', 'exp', '-', '+', 'x2', '+', 'x3', '/', 'x2', 'x3', 'x2', 'x2'].
+                expressions_match = np.mean(
+                    relative_equivalence_mask | absolute_equivalence_mask | is_both_invalid_mask
+                ) >= 0.95
             else:
                 # FIXME: Cannot check reliably because optimizer sometimes cannot reliably fit constants
                 expressions_match = True